From c3fe8bb026038f3547597c3683a530e53e13e063 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Wed, 16 Aug 2017 20:50:12 +0300
Subject: [PATCH 001/266] added FunctionArrayConcat [#CLICKHOUSE-2090]

---
 dbms/src/Functions/CMakeLists.txt     |   1 +
 dbms/src/Functions/FunctionsArray.cpp | 111 ++++++++++++++++++++++++++
 dbms/src/Functions/FunctionsArray.h   |  19 +++++
 3 files changed, 131 insertions(+)

diff --git a/dbms/src/Functions/CMakeLists.txt b/dbms/src/Functions/CMakeLists.txt
index a0827afdd1e..f726e78883c 100644
--- a/dbms/src/Functions/CMakeLists.txt
+++ b/dbms/src/Functions/CMakeLists.txt
@@ -52,6 +52,7 @@ generate_function_register(Array
   FunctionRange
   FunctionArrayReduce
   FunctionArrayReverse
+  FunctionArrayConcat
 )
 
 
diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index 6fae2c7e525..4d17e7d20e9 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -7,6 +7,7 @@
 #include <Functions/FunctionsConversion.h>
 #include <Functions/Conditional/getArrayType.h>
 #include <Functions/Conditional/CondException.h>
+#include <Functions/GatherUtils.h>
 #include <Common/HashTable/HashMap.h>
 #include <Common/HashTable/ClearableHashMap.h>
 #include <Parsers/ExpressionListParsers.h>
@@ -18,6 +19,7 @@
 #include <Columns/ColumnAggregateFunction.h>
 #include <tuple>
 #include <array>
+#include <iostream>
 
 
 namespace DB
@@ -2876,4 +2878,113 @@ void FunctionArrayReduce::executeImpl(Block & block, const ColumnNumbers & argum
     }
 }
 
+/// Implementation of FunctionArrayConcat.
+
+FunctionPtr FunctionArrayConcat::create(const Context & context)
+{
+    return std::make_shared<FunctionArrayConcat>();
+}
+
+String FunctionArrayConcat::getName() const
+{
+    return name;
+}
+
+DataTypePtr FunctionArrayConcat::getReturnTypeImpl(const DataTypes & arguments) const
+{
+    bool has_nullable = false;
+    DataTypePtr common_type;
+
+    for (size_t i : ext::range(0, arguments.size()))
+    {
+        const auto & argument = arguments[i];
+        auto data_type_array = checkAndGetDataType<DataTypeArray>(argument.get());
+        if (!data_type_array)
+            throw Exception("Argument " + toString(i) + " for function " + getName() + " must be an array but it has type "
+                            + argument->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+
+        DataTypePtr nested_type = data_type_array->getNestedType();
+        if (nested_type->isNullable())
+        {
+            has_nullable = true;
+            auto nullable_type = static_cast<const DataTypeNullable *>(nested_type.get());
+            nested_type = nullable_type->getNestedType();
+        }
+
+        if (!common_type)
+            common_type = nested_type;
+        else if (!common_type->equals(*nested_type.get()))
+            throw Exception("Arguments for function " + getName() + " has different nested types: "
+                            + common_type->getName() + " and " + nested_type->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+    }
+
+    if (has_nullable)
+        common_type = std::make_shared<DataTypeNullable>(common_type);
+
+    return std::make_shared<DataTypeArray>(common_type);
+}
+
+void FunctionArrayConcat::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+{
+    std::cerr << block.dumpStructure() << std::endl;
+    auto & result_column = block.getByPosition(result).column;
+
+    ColumnPtr column_to_clone_for_result = block.getByPosition(arguments.front()).column;
+    bool is_nullable_result = false;
+    size_t size = 0;
+
+    for (auto argument : arguments)
+    {
+        const auto & argument_column = block.safeGetByPosition(argument).column;
+        auto argument_column_array = typeid_cast<ColumnArray *>(argument_column.get());
+        if (checkColumn<ColumnNullable>(&argument_column_array->getData()))
+        {
+            is_nullable_result = true;
+            column_to_clone_for_result = argument_column;
+            break;
+        }
+        size = argument_column->size();
+    }
+
+    std::vector<ColumnPtr> nullable_columns_holder;
+    std::vector<GenericArraySource> sources;
+
+    for (auto argument : arguments)
+    {
+        auto & argument_column = block.getByPosition(argument).column;
+        auto argument_column_array = typeid_cast<ColumnArray *>(argument_column.get());
+
+        if (is_nullable_result)
+        {
+            if (!checkColumn<ColumnNullable>(&argument_column_array->getData()))
+            {
+                ColumnPtr null_map = std::make_shared<ColumnUInt8>(argument_column_array->getData().size(), 0);
+                argument_column = std::make_shared<ColumnArray>(
+                        std::make_shared<ColumnNullable>(argument_column_array->getDataPtr(), null_map),
+                        argument_column_array->getOffsetsColumn()
+                );
+            }
+            nullable_columns_holder.push_back(argument_column);
+        }
+        sources.emplace_back(static_cast<ColumnArray &>(*argument_column.get()));
+    }
+
+    result_column = column_to_clone_for_result->cloneEmpty();
+    GenericArraySink sink(typeid_cast<ColumnArray &>(*result_column.get()), size);
+
+    while (!sink.isEnd())
+    {
+        for (auto & source : sources)
+        {
+            auto slice = source.getWhole();
+            std::cerr << slice.size << std::endl;
+            writeSlice(slice, sink);
+            source.next();
+        }
+        sink.next();
+        std::cerr << sink.elements.size() << std::endl;
+    }
+    std::cerr << block.dumpStructure() << std::endl;
+}
+
 }
diff --git a/dbms/src/Functions/FunctionsArray.h b/dbms/src/Functions/FunctionsArray.h
index e79242e4c9b..1af4df8ca84 100644
--- a/dbms/src/Functions/FunctionsArray.h
+++ b/dbms/src/Functions/FunctionsArray.h
@@ -1406,6 +1406,25 @@ private:
 };
 
 
+class FunctionArrayConcat : public IFunction
+{
+public:
+    static constexpr auto name = "arrayConcat";
+    static FunctionPtr create(const Context & context);
+
+    String getName() const override;
+
+    bool isVariadic() const override { return false; }
+    size_t getNumberOfArguments() const override { return 2; }
+
+    DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
+
+    void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override;
+
+    bool useDefaultImplementationForConstants() const override { return true; }
+};
+
+
 struct NameHas { static constexpr auto name = "has"; };
 struct NameIndexOf { static constexpr auto name = "indexOf"; };
 struct NameCountEqual { static constexpr auto name = "countEqual"; };

From c1479a55946d37b896dda8affbd6f83d5b66e4ad Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Thu, 17 Aug 2017 22:33:02 +0300
Subject: [PATCH 002/266] updated GatherUtils [#CLICKHOUSE-2090]

---
 dbms/src/Common/TypeList.h            |  51 ++
 dbms/src/Core/TypeListNumber.h        |  10 +
 dbms/src/Functions/FunctionsArray.cpp | 106 ++--
 dbms/src/Functions/FunctionsArray.h   |   4 +-
 dbms/src/Functions/GatherUtils.h      | 664 ++++++++++++++++++++++++--
 5 files changed, 736 insertions(+), 99 deletions(-)
 create mode 100644 dbms/src/Common/TypeList.h
 create mode 100644 dbms/src/Core/TypeListNumber.h

diff --git a/dbms/src/Common/TypeList.h b/dbms/src/Common/TypeList.h
new file mode 100644
index 00000000000..607f81720c0
--- /dev/null
+++ b/dbms/src/Common/TypeList.h
@@ -0,0 +1,51 @@
+#pragma once
+
+namespace DB
+{
+
+template <typename ... Types>
+struct TypeList;
+
+template <typename Type, typename ... Types>
+struct TypeList<Type, Types...>
+{
+    using Head = Type;
+    using Tail = TypeList<Types ...>;
+};
+
+template<>
+struct TypeList<>
+{
+};
+
+/// Append Type to TypeList
+/// Usage:
+///     using TypeListWithType = typename AppendToTypeList<Type, ConcreteTypeList>::Type;
+template <typename TypeToAppend, typename List, typename ... Types>
+struct AppendToTypeList
+{
+    using Type = typename AppendToTypeList<TypeToAppend, typename List::Tail, Types ..., typename List::Head>::Type;
+};
+
+template <typename TypeToAppend, typename ... Types>
+struct AppendToTypeList<TypeToAppend, TypeList<>, Types ...>
+{
+    using Type = TypeList<TypeToAppend, Types ...>;
+};
+
+/// Apply TypeList as variadic template argument of Class.
+/// Usage:
+///     using ClassWithAppliedTypeList = typename ApplyTypeListForClass<Class, ConcreteTypeList>::Type;
+template <template <typename ...> typename Class, typename List, typename ... Types>
+struct ApplyTypeListForClass
+{
+    using Type = typename ApplyTypeListForClass<Class, typename List::Tail, Types ..., typename List::Head>::Type;
+};
+
+template <template <typename ...> typename Class, typename ... Types>
+struct ApplyTypeListForClass<Class, TypeList<>, Types ...>
+{
+    using Type = Class<Types ...>;
+};
+
+}
diff --git a/dbms/src/Core/TypeListNumber.h b/dbms/src/Core/TypeListNumber.h
new file mode 100644
index 00000000000..db7dcc2e5d0
--- /dev/null
+++ b/dbms/src/Core/TypeListNumber.h
@@ -0,0 +1,10 @@
+#pragma once
+#include <Core/Types.h>
+#include <Common/TypeList.h>
+
+namespace DB
+{
+
+using TypeListNumber = TypeList<UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32, Float64>;
+
+}
diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index 4d17e7d20e9..3e374995afc 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -2892,98 +2892,88 @@ String FunctionArrayConcat::getName() const
 
 DataTypePtr FunctionArrayConcat::getReturnTypeImpl(const DataTypes & arguments) const
 {
-    bool has_nullable = false;
-    DataTypePtr common_type;
+    if (arguments.empty())
+        throw Exception{"Function array requires at least one argument.", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
 
+    DataTypes nested_types;
+    nested_types.reserve(arguments.size());
     for (size_t i : ext::range(0, arguments.size()))
     {
-        const auto & argument = arguments[i];
-        auto data_type_array = checkAndGetDataType<DataTypeArray>(argument.get());
-        if (!data_type_array)
+        auto argument = arguments[i].get();
+
+        if (auto data_type_array = checkAndGetDataType<DataTypeArray>(argument))
+            nested_types.push_back(data_type_array->getNestedType());
+        else
             throw Exception("Argument " + toString(i) + " for function " + getName() + " must be an array but it has type "
                             + argument->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
-
-        DataTypePtr nested_type = data_type_array->getNestedType();
-        if (nested_type->isNullable())
-        {
-            has_nullable = true;
-            auto nullable_type = static_cast<const DataTypeNullable *>(nested_type.get());
-            nested_type = nullable_type->getNestedType();
-        }
-
-        if (!common_type)
-            common_type = nested_type;
-        else if (!common_type->equals(*nested_type.get()))
-            throw Exception("Arguments for function " + getName() + " has different nested types: "
-                            + common_type->getName() + " and " + nested_type->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
     }
 
-    if (has_nullable)
-        common_type = std::make_shared<DataTypeNullable>(common_type);
+    if (foundNumericType(nested_types))
+    {
+        /// Since we have found at least one numeric argument, we infer that all
+        /// the arguments are numeric up to nullity. Let's determine the least
+        /// common type.
+        auto enriched_result_type = Conditional::getArrayType(nested_types);
+        return std::make_shared<DataTypeArray>(enriched_result_type);
+    }
+    else
+    {
+        /// Otherwise all the arguments must have the same type up to nullability or nullity.
+        if (!hasArrayIdenticalTypes(nested_types))
+            throw Exception{"Arguments for function " + getName() + " must have same type or behave as number.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
-    return std::make_shared<DataTypeArray>(common_type);
+        return std::make_shared<DataTypeArray>(getArrayElementType(nested_types));
+    }
 }
 
 void FunctionArrayConcat::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
     std::cerr << block.dumpStructure() << std::endl;
     auto & result_column = block.getByPosition(result).column;
+    const DataTypePtr & return_type = block.getByPosition(result).type;
+    result_column = return_type->createColumn();
 
-    ColumnPtr column_to_clone_for_result = block.getByPosition(arguments.front()).column;
-    bool is_nullable_result = false;
     size_t size = 0;
 
     for (auto argument : arguments)
     {
         const auto & argument_column = block.safeGetByPosition(argument).column;
-        auto argument_column_array = typeid_cast<ColumnArray *>(argument_column.get());
-        if (checkColumn<ColumnNullable>(&argument_column_array->getData()))
-        {
-            is_nullable_result = true;
-            column_to_clone_for_result = argument_column;
-            break;
-        }
         size = argument_column->size();
     }
 
-    std::vector<ColumnPtr> nullable_columns_holder;
-    std::vector<GenericArraySource> sources;
+    std::vector<std::unique_ptr<IArraySource>> sources;
 
     for (auto argument : arguments)
     {
-        auto & argument_column = block.getByPosition(argument).column;
-        auto argument_column_array = typeid_cast<ColumnArray *>(argument_column.get());
+        auto argument_column = block.getByPosition(argument).column.get();
+        size_t column_size = argument_column->size();
+        bool is_const = false;
 
-        if (is_nullable_result)
+        if (auto argument_column_const = typeid_cast<ColumnConst *>(argument_column))
         {
-            if (!checkColumn<ColumnNullable>(&argument_column_array->getData()))
-            {
-                ColumnPtr null_map = std::make_shared<ColumnUInt8>(argument_column_array->getData().size(), 0);
-                argument_column = std::make_shared<ColumnArray>(
-                        std::make_shared<ColumnNullable>(argument_column_array->getDataPtr(), null_map),
-                        argument_column_array->getOffsetsColumn()
-                );
-            }
-            nullable_columns_holder.push_back(argument_column);
+            is_const = true;
+            argument_column = &argument_column_const->getDataColumn();
         }
-        sources.emplace_back(static_cast<ColumnArray &>(*argument_column.get()));
+
+        if (auto argument_column_array = typeid_cast<ColumnArray *>(argument_column))
+            sources.emplace_back(createArraySource(*argument_column_array, is_const, column_size));
+        else
+            throw Exception{"Arguments for function " + getName() + " must be arrays.", ErrorCodes::LOGICAL_ERROR};
     }
 
-    result_column = column_to_clone_for_result->cloneEmpty();
-    GenericArraySink sink(typeid_cast<ColumnArray &>(*result_column.get()), size);
+    auto sink = createArraySink(typeid_cast<ColumnArray &>(*result_column.get()), size);
+    concat(sources, *sink);
 
-    while (!sink.isEnd())
+    auto array = checkAndGetColumn<ColumnArray>(result_column.get());
+    if (array)
     {
-        for (auto & source : sources)
-        {
-            auto slice = source.getWhole();
-            std::cerr << slice.size << std::endl;
-            writeSlice(slice, sink);
-            source.next();
-        }
-        sink.next();
-        std::cerr << sink.elements.size() << std::endl;
+        auto & offsets = array->getOffsets();
+        std::cerr << offsets.size()  << " " << array->size()<< std::endl;
+        for (auto & val : offsets)
+            std::cerr << val << ' ';
+        std::cerr << std::endl;
     }
+
     std::cerr << block.dumpStructure() << std::endl;
 }
 
diff --git a/dbms/src/Functions/FunctionsArray.h b/dbms/src/Functions/FunctionsArray.h
index 1af4df8ca84..60970b733f9 100644
--- a/dbms/src/Functions/FunctionsArray.h
+++ b/dbms/src/Functions/FunctionsArray.h
@@ -1414,8 +1414,8 @@ public:
 
     String getName() const override;
 
-    bool isVariadic() const override { return false; }
-    size_t getNumberOfArguments() const override { return 2; }
+    bool isVariadic() const override { return true; }
+    size_t getNumberOfArguments() const override { return 0; }
 
     DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
 
diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index d0f90733c95..bf825c818cc 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -7,13 +7,19 @@
 #include <Columns/ColumnString.h>
 #include <Columns/ColumnFixedString.h>
 #include <Columns/ColumnConst.h>
+#include <Columns/ColumnNullable.h>
 
 #include <Functions/FunctionHelpers.h>
 #include <DataTypes/NumberTraits.h>
 
 #include <Common/typeid_cast.h>
 #include <Common/memcpySmall.h>
+#include <ext/range.h>
+#include <Core/TypeListNumber.h>
 
+#include <DataTypes/DataTypeTraits.h>
+#include <iostream>
+#include <typeindex>
 
 /** These methods are intended for implementation of functions, that
   *  copy ranges from one or more columns to another column.
@@ -36,6 +42,11 @@
 namespace DB
 {
 
+namespace ErrorCodes
+{
+    extern const int LOGICAL_ERROR;
+}
+
 template <typename T>
 struct NumericArraySlice
 {
@@ -44,8 +55,24 @@ struct NumericArraySlice
 };
 
 
+struct IArraySource
+{
+    virtual ~IArraySource() {}
+
+    virtual size_t getSizeForReserve() const = 0;
+    virtual const typename ColumnArray::Offsets_t & getOffsets() const = 0;
+    virtual size_t getColumnSize() const = 0;
+    virtual bool isConst() const { return false; }
+    virtual bool isNullable() const { return false; }
+};
+struct IArraySink
+{
+    virtual ~IArraySink() {}
+};
+
+
 template <typename T>
-struct NumericArraySource
+struct NumericArraySource : public IArraySource
 {
     using Slice = NumericArraySlice<T>;
     using Column = ColumnArray;
@@ -77,12 +104,22 @@ struct NumericArraySource
         return row_num;
     }
 
+    const typename ColumnArray::Offsets_t & getOffsets() const
+    {
+        return offsets;
+    }
+
     /// Get size for corresponding call or Sink::reserve to reserve memory for elements.
-    size_t getSizeForReserve() const
+    size_t getSizeForReserve() const override
     {
         return elements.size();
     }
 
+    size_t getColumnSize() const override
+    {
+        return offsets.size();
+    }
+
     Slice getWhole() const
     {
         return {&elements[prev_offset], offsets[row_num] - prev_offset};
@@ -123,7 +160,7 @@ struct NumericArraySource
 
 
 template <typename Base>
-struct ConstSource
+struct ConstSource : public Base
 {
     using Slice = typename Base::Slice;
     using Column = ColumnConst;
@@ -131,10 +168,21 @@ struct ConstSource
     size_t total_rows;
     size_t row_num = 0;
 
-    Base base;
+    /// Base base;
 
-    ConstSource(const ColumnConst & col)
-        : total_rows(col.size()), base(static_cast<const typename Base::Column &>(col.getDataColumn()))
+    /// template <typename ColumnType>
+    explicit ConstSource(const ColumnConst & col)
+        : Base(static_cast<const typename Base::Column &>(col.getDataColumn())), total_rows(col.size())
+    {
+    }
+
+    template <typename ColumnType>
+    ConstSource(const ColumnType & col, size_t total_rows) : Base(col), total_rows(total_rows)
+    {
+    }
+
+    template <typename ColumnType>
+    ConstSource(const ColumnType & col, const ColumnUInt8 & null_map, size_t total_rows) : Base(col, null_map), total_rows(total_rows)
     {
     }
 
@@ -155,33 +203,43 @@ struct ConstSource
 
     size_t getSizeForReserve() const
     {
-        return total_rows * base.getSizeForReserve();
+        return total_rows * Base::getSizeForReserve();
     }
 
-    Slice getWhole() const
+    size_t getColumnSize() const // overrides for IArraySource
     {
-        return base.getWhole();
+        return total_rows;
     }
 
-    Slice getSliceFromLeft(size_t offset) const
+    bool isConst() const // overrides for IArraySource
     {
-        return base.getSliceFromLeft(offset);
+        return true;
     }
 
-    Slice getSliceFromLeft(size_t offset, size_t length) const
-    {
-        return base.getSliceFromLeft(offset, length);
-    }
-
-    Slice getSliceFromRight(size_t offset) const
-    {
-        return base.getSliceFromRight(offset);
-    }
-
-    Slice getSliceFromRight(size_t offset, size_t length) const
-    {
-        return base.getSliceFromRight(offset, length);
-    }
+//    Slice getWhole() const
+//    {
+//        return base.getWhole();
+//    }
+//
+//    Slice getSliceFromLeft(size_t offset) const
+//    {
+//        return base.getSliceFromLeft(offset);
+//    }
+//
+//    Slice getSliceFromLeft(size_t offset, size_t length) const
+//    {
+//        return base.getSliceFromLeft(offset, length);
+//    }
+//
+//    Slice getSliceFromRight(size_t offset) const
+//    {
+//        return base.getSliceFromRight(offset);
+//    }
+//
+//    Slice getSliceFromRight(size_t offset, size_t length) const
+//    {
+//        return base.getSliceFromRight(offset, length);
+//    }
 };
 
 
@@ -336,7 +394,7 @@ struct FixedStringSource
 
 
 template <typename T>
-struct NumericArraySink
+struct NumericArraySink : public IArraySink
 {
     typename ColumnVector<T>::Container_t & elements;
     typename ColumnArray::Offsets_t & offsets;
@@ -499,7 +557,7 @@ struct GenericArraySlice
 };
 
 
-struct GenericArraySource
+struct GenericArraySource : public IArraySource
 {
     using Slice = GenericArraySlice;
     using Column = ColumnArray;
@@ -531,7 +589,17 @@ struct GenericArraySource
         return row_num;
     }
 
-    size_t getSizeForReserve() const
+    const typename ColumnArray::Offsets_t & getOffsets() const
+    {
+        return offsets;
+    }
+
+    size_t getSizeForReserve() const override
+    {
+        return elements.size();
+    }
+
+    size_t getColumnSize() const override
     {
         return elements.size();
     }
@@ -574,7 +642,7 @@ struct GenericArraySource
     }
 };
 
-struct GenericArraySink
+struct GenericArraySink : public IArraySink
 {
     IColumn & elements;
     ColumnArray::Offsets_t & offsets;
@@ -611,6 +679,200 @@ struct GenericArraySink
 };
 
 
+template <typename Slice>
+struct NullableArraySlice : public Slice
+{
+    const UInt8 * null_map;
+
+    NullableArraySlice() {}
+    NullableArraySlice(const Slice & base) : Slice(base) {}
+};
+
+
+template <typename ArraySource>
+struct NullableArraySource : public ArraySource
+{
+    using Slice = NullableArraySlice<typename ArraySource::Slice>;
+    using ArraySource::prev_offset;
+    using ArraySource::row_num;
+    using ArraySource::offsets;
+
+    const ColumnUInt8::Container_t & null_map;
+
+    NullableArraySource(const ColumnArray & arr, const ColumnUInt8 & null_map)
+            : ArraySource(arr), null_map(null_map.getData())
+    {
+    }
+
+    Slice getWhole() const
+    {
+        Slice slice = ArraySource::getWhole();
+        slice.null_map = &null_map[prev_offset];
+        return slice;
+    }
+
+    Slice getSliceFromLeft(size_t offset) const
+    {
+        Slice slice = ArraySource::getSliceFromLeft(offset);
+        if (!slice.size)
+            slice.null_map = &null_map[prev_offset];
+        else
+            slice.null_map = &null_map[prev_offset + offset];
+        return slice;
+    }
+
+    Slice getSliceFromLeft(size_t offset, size_t length) const
+    {
+        Slice slice = ArraySource::getSliceFromLeft(offset, length);
+        if (!slice.size)
+            slice.null_map = &null_map[prev_offset];
+        else
+            slice.null_map = &null_map[prev_offset + offset];
+        return slice;
+    }
+
+    Slice getSliceFromRight(size_t offset) const
+    {
+        Slice slice = ArraySource::getSliceFromRight(offset);
+        if (!slice.size)
+            slice.null_map = &null_map[prev_offset];
+        else
+            slice.null_map = &null_map[offsets[row_num] - offset];
+        return slice;
+    }
+
+    Slice getSliceFromRight(size_t offset, size_t length) const
+    {
+        Slice slice = ArraySource::getSliceFromRight(offset, length);
+        if (!slice.size)
+            slice.null_map = &null_map[prev_offset];
+        else
+            slice.null_map = &null_map[offsets[row_num] - offset];
+        return slice;
+    }
+
+    bool isNullable() const override
+    {
+        return true;
+    }
+};
+
+template <typename ArraySink>
+struct NullableArraySink : public ArraySink
+{
+    ColumnUInt8::Container_t & null_map;
+
+    NullableArraySink(ColumnArray & arr, ColumnUInt8 & null_map, size_t column_size)
+        : ArraySink(arr, column_size), null_map(null_map.getData())
+    {
+    }
+
+    void reserve(size_t num_elements)
+    {
+        ArraySink::reserve(num_elements);
+        null_map.reserve(num_elements);
+    }
+};
+
+template <typename ... Types>
+struct ArraySourceCreator;
+
+template <typename Type, typename ... Types>
+struct ArraySourceCreator<Type, Types ...>
+{
+    static std::unique_ptr<IArraySource> create(const ColumnArray & col, const ColumnUInt8 * null_map, bool is_const, size_t total_rows)
+    {
+        std::cerr << "Numeric " << typeid(Type).name() << std::endl;
+        if (typeid_cast<const ColumnVector<Type> *>(&col.getData()))
+        {
+            std::cerr << "Created" << typeid(NumericArraySource<Type>).name() << std::endl;
+            if (null_map)
+            {
+                if (is_const)
+                    return std::make_unique<ConstSource<NullableArraySource<NumericArraySource<Type>>>>(col, *null_map, total_rows);
+                return std::make_unique<NullableArraySource<NumericArraySource<Type>>>(col, *null_map);
+            }
+            if (is_const)
+                return std::make_unique<ConstSource<NumericArraySource<Type>>>(col, total_rows);
+            return std::make_unique<NumericArraySource<Type>>(col);
+        }
+
+        return ArraySourceCreator<Types...>::create(col, null_map, is_const, total_rows);
+    }
+};
+
+template <>
+struct ArraySourceCreator<>
+{
+    static std::unique_ptr<IArraySource> create(const ColumnArray & col, const ColumnUInt8 * null_map, bool is_const, size_t total_rows)
+    {
+        std::cerr << "Generic " << typeid(GenericArraySource).name() << std::endl;
+        if (null_map)
+        {
+            if (is_const)
+                return std::make_unique<ConstSource<NullableArraySource<GenericArraySource>>>(col, *null_map, total_rows);
+            return std::make_unique<NullableArraySource<GenericArraySource>>(col, *null_map);
+        }
+        if (is_const)
+            return std::make_unique<ConstSource<GenericArraySource>>(col, total_rows);
+        return std::make_unique<GenericArraySource>(col);
+    }
+};
+
+inline std::unique_ptr<IArraySource> createArraySource(const ColumnArray & col, bool is_const, size_t total_rows)
+{
+    using Creator = typename ApplyTypeListForClass<ArraySourceCreator, TypeListNumber>::Type;
+    if (auto column_nullable = typeid_cast<const ColumnNullable *>(&col.getData()))
+    {
+        ColumnArray column(column_nullable->getNestedColumn(), col.getOffsetsColumn());
+        return Creator::create(column, &column_nullable->getNullMapConcreteColumn(), is_const, total_rows);
+    }
+    return Creator::create(col, nullptr, is_const, total_rows);
+}
+
+
+template <typename ... Types>
+struct ArraySinkCreator;
+
+template <typename Type, typename ... Types>
+struct ArraySinkCreator<Type, Types ...>
+{
+    static std::unique_ptr<IArraySink> create(ColumnArray & col, ColumnUInt8 * null_map, size_t column_size)
+    {
+        if (typeid_cast<ColumnVector<Type> *>(&col.getData()))
+        {
+            if (null_map)
+                return std::make_unique<NullableArraySink<NumericArraySink<Type>>>(col, *null_map, column_size);
+            return std::make_unique<NumericArraySink<Type>>(col, column_size);
+        }
+
+        return ArraySinkCreator<Types ...>::create(col, null_map, column_size);
+    }
+};
+
+template <>
+struct ArraySinkCreator<>
+{
+    static std::unique_ptr<IArraySink> create(ColumnArray & col, ColumnUInt8 * null_map, size_t column_size)
+    {
+        if (null_map)
+            return std::make_unique<NullableArraySink<GenericArraySink>>(col, *null_map, column_size);
+        return std::make_unique<GenericArraySink>(col, column_size);
+    }
+};
+
+inline std::unique_ptr<IArraySink> createArraySink(ColumnArray & col, size_t column_size)
+{
+    using Creator = ApplyTypeListForClass<ArraySinkCreator, TypeListNumber>::Type;
+    if (auto column_nullable = typeid_cast<ColumnNullable *>(&col.getData()))
+    {
+        ColumnArray column(column_nullable->getNestedColumn(), col.getOffsetsColumn());
+        return Creator::create(column, &column_nullable->getNullMapConcreteColumn(), column_size);
+    }
+    return Creator::create(col, nullptr, column_size);
+}
+
+
 template <typename T>
 using NumericSlice = const T *;
 
@@ -700,15 +962,17 @@ struct NumericSink
 template <typename T>
 void writeSlice(const NumericArraySlice<T> & slice, NumericArraySink<T> & sink)
 {
-    sink.elements.resize(sink.current_offset + slice.size);
-    memcpySmallAllowReadWriteOverflow15(&sink.elements[sink.current_offset], slice.data, slice.size * sizeof(T));
+    if (sink.elements.size() < sink.current_offset + slice.size)
+        sink.elements.resize(sink.current_offset + slice.size);
+    memcpy(&sink.elements[sink.current_offset], slice.data, slice.size * sizeof(T));
     sink.current_offset += slice.size;
 }
 
 template <typename T, typename U>
 void writeSlice(const NumericArraySlice<T> & slice, NumericArraySink<U> & sink)
 {
-    sink.elements.resize(sink.current_offset + slice.size);
+    if (sink.elements.size() < sink.current_offset + slice.size)
+        sink.elements.resize(sink.current_offset + slice.size);
     for (size_t i = 0; i < slice.size; ++i)
     {
         sink.elements[sink.current_offset] = slice.data[i];
@@ -718,7 +982,8 @@ void writeSlice(const NumericArraySlice<T> & slice, NumericArraySink<U> & sink)
 
 inline ALWAYS_INLINE void writeSlice(const StringSource::Slice & slice, StringSink & sink)
 {
-    sink.elements.resize(sink.current_offset + slice.size);
+    if (sink.elements.size() < sink.current_offset + slice.size)
+        sink.elements.resize(sink.current_offset + slice.size);
     memcpySmallAllowReadWriteOverflow15(&sink.elements[sink.current_offset], slice.data, slice.size);
     sink.current_offset += slice.size;
 }
@@ -728,24 +993,179 @@ inline ALWAYS_INLINE void writeSlice(const StringSource::Slice & slice, FixedStr
     memcpySmallAllowReadWriteOverflow15(&sink.elements[sink.current_offset], slice.data, slice.size);
 }
 
-/// Assuming same types of underlying columns for slice and sink.
 inline ALWAYS_INLINE void writeSlice(const GenericArraySlice & slice, GenericArraySink & sink)
 {
-    sink.elements.insertRangeFrom(*slice.elements, slice.begin, slice.size);
+    if (std::type_index(typeid(slice.elements)) == std::type_index(typeid(&sink.elements)))
+        sink.elements.insertRangeFrom(*slice.elements, slice.begin, slice.size);
+    else
+    {
+        for (size_t i = 0; i < slice.size; ++i)
+        {
+            Field field;
+            slice.elements->get(slice.begin + i, field);
+            sink.elements.insert(field);
+        }
+    }
     sink.current_offset += slice.size;
 }
 
-template <typename T, typename U>
-void ALWAYS_INLINE writeSlice(const NumericSlice<T> & slice, NumericSink<U> & sink)
+template <typename T>
+inline ALWAYS_INLINE void writeSlice(const GenericArraySlice & slice, NumericArraySink<T> & sink)
 {
-    *sink.pos = *slice;
+    if (sink.elements.size() < sink.current_offset + slice.size)
+        sink.elements.resize(sink.current_offset + slice.size);
+    for (size_t i = 0; i < slice.size; ++i)
+    {
+        Field field;
+        slice.elements->get(slice.begin + i, field);
+        sink.elements.push_back(field.get<T>());
+    }
+    sink.current_offset += slice.size;
 }
 
+template <typename T>
+inline ALWAYS_INLINE void writeSlice(const NumericArraySlice<T> & slice, GenericArraySink & sink)
+{
+    for (size_t i = 0; i < slice.size; ++i)
+    {
+        Field field = static_cast<typename NearestFieldType<T>::Type>(slice.data[i]);
+        sink.elements.insert(field);
+    }
+    sink.current_offset += slice.size;
+}
+
+/// Assuming same types of underlying columns for slice and sink if (ArraySlice, ArraySink) is (GenericArraySlice, GenericArraySink).
+template <typename ArraySlice, typename ArraySink>
+inline ALWAYS_INLINE void writeSlice(const NullableArraySlice<ArraySlice> & slice, NullableArraySink<ArraySink> & sink)
+{
+    if (sink.null_map.size() < sink.current_offset + slice.size)
+        sink.null_map.resize(sink.current_offset + slice.size);
+    memcpy(&sink.null_map[sink.current_offset], slice.null_map, slice.size * sizeof(UInt8));
+    writeSlice(static_cast<const ArraySlice &>(slice), static_cast<ArraySink &>(sink));
+}
+
+/// Assuming same types of underlying columns for slice and sink if (ArraySlice, ArraySink) is (GenericArraySlice, GenericArraySink).
+template <typename ArraySlice, typename ArraySink>
+inline ALWAYS_INLINE void writeSlice(const ArraySlice & slice, NullableArraySink<ArraySink> & sink)
+{
+    if (sink.null_map.size() < sink.current_offset + slice.size)
+        sink.null_map.resize(sink.current_offset + slice.size);
+    memset(&sink.null_map[sink.current_offset], 0, slice.size * sizeof(UInt8));
+    writeSlice(slice, static_cast<ArraySink &>(sink));
+}
 
 /// Algorithms
 
+template <typename Source, typename Sink>
+static void append(Source & source, Sink & sink)
+{
+    sink.row_num = 0;
+    while (!source.isEnd())
+    {
+        sink.current_offset = sink.offsets[sink.row_num];
+        writeSlice(source.getWhole(), sink);
+        sink.next();
+        source.next();
+    }
+}
+
+template <template <typename ...> typename Base, typename ... Types>
+struct ArraySourceSelector;
+
+template <template <typename ...> typename Base, typename Type, typename ... Types>
+struct ArraySourceSelector<Base, Type, Types ...>
+{
+    template <typename ... Args>
+    static void select(IArraySource & source, Args & ... args)
+    {
+        if (auto array = typeid_cast<NumericArraySource<Type> *>(&source))
+            Base<Types ...>::selectImpl(*array, args ...);
+        else if(auto nullable_array = typeid_cast<NullableArraySource<NumericArraySource<Type>> *>(&source))
+            Base<Types ...>::selectImpl(*nullable_array, args ...);
+        else if (auto const_array = typeid_cast<ConstSource<NumericArraySource<Type>> *>(&source))
+            Base<Types ...>::selectImpl(*const_array, args ...);
+        else if(auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<NumericArraySource<Type>>> *>(&source))
+            Base<Types ...>::selectImpl(*const_nullable_array, args ...);
+        else
+            Base<Types ...>::select(source, args ...);
+    }
+};
+
+template <template <typename ...> typename Base>
+struct ArraySourceSelector<Base>
+{
+    template <typename ... Args>
+    static void select(IArraySource & source, Args & ... args)
+    {
+        if (auto array = typeid_cast<GenericArraySource *>(&source))
+            Base<>::selectImpl(*array, args ...);
+        else if(auto nullable_array = typeid_cast<NullableArraySource<GenericArraySource> *>(&source))
+            Base<>::selectImpl(*nullable_array, args ...);
+        else if (auto const_array = typeid_cast<ConstSource<GenericArraySource> *>(&source))
+            Base<>::selectImpl(*const_array, args ...);
+        else if(auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<GenericArraySource>> *>(&source))
+            Base<>::selectImpl(*const_nullable_array, args ...);
+        else
+            throw Exception(std::string("Unknown ArraySource type: ") + typeid(source).name(), ErrorCodes::LOGICAL_ERROR);
+    }
+};
+
+
+template <template <typename ...> typename Base, typename ... Types>
+struct ArraySinkSelector;
+
+template <template <typename ...> typename Base, typename Type, typename ... Types>
+struct ArraySinkSelector<Base, Type, Types ...>
+{
+    template <typename ... Args>
+    static void select(IArraySink & sink, Args & ... args)
+    {
+        if (auto nullable_numeric_sink = typeid_cast<NullableArraySink<NumericArraySink<Type>> *>(&sink))
+            Base<>::selectImpl(*nullable_numeric_sink, args ...);
+        else if (auto numeric_sink = typeid_cast<NumericArraySink<Type> *>(&sink))
+            Base<>::selectImpl(*numeric_sink, args ...);
+        else
+            Base<Types ...>::select(sink, args ...);
+    }
+};
+
+template <template <typename ...> typename Base>
+struct ArraySinkSelector<Base>
+{
+    template <typename ... Args>
+    static void select(IArraySink & sink, Args & ... args)
+    {
+        if (auto nullable_generic_sink = typeid_cast<NullableArraySink<GenericArraySink> *>(&sink))
+            Base<>::selectImpl(*nullable_generic_sink, args ...);
+        else if (auto generic_sink = typeid_cast<GenericArraySink *>(&sink))
+            Base<>::selectImpl(*generic_sink, args ...);
+        else
+            throw Exception(std::string("Unknown ArraySink type: ") + typeid(sink).name(), ErrorCodes::LOGICAL_ERROR);
+    }
+};
+
+
+template <typename ... Types>
+struct ArrayAppend : public ArraySourceSelector<ArrayAppend, Types ...>
+{
+    template <typename Source, typename Sink>
+    static void selectImpl(Source & source, Sink & sink)
+    {
+        append<Source, Sink>(source, sink);
+    }
+};
+
+template <typename Sink>
+static void append(IArraySource & source, Sink & sink)
+{
+    // using List = typename AppendToTypeList<Sink, TypeListNumber>::Type;
+    using AppendImpl = typename ApplyTypeListForClass<ArrayAppend, TypeListNumber>::Type;
+    AppendImpl::select(source, sink);
+}
+
+
 template <typename SourceA, typename SourceB, typename Sink>
-void NO_INLINE concat(SourceA && src_a, SourceB && src_b, Sink && sink)
+void NO_INLINE concat(SourceA & src_a, SourceB & src_b, Sink & sink)
 {
     sink.reserve(src_a.getSizeForReserve() + src_b.getSizeForReserve());
 
@@ -760,6 +1180,12 @@ void NO_INLINE concat(SourceA && src_a, SourceB && src_b, Sink && sink)
     }
 }
 
+template <typename SourceA, typename SourceB, typename Sink>
+void NO_INLINE concat(SourceA && src_a, SourceB && src_b, Sink && sink)
+{
+    concat(src_a, src_b, sink);
+}
+
 template <typename Sink>
 void NO_INLINE concat(StringSources & sources, Sink && sink)
 {
@@ -774,6 +1200,163 @@ void NO_INLINE concat(StringSources & sources, Sink && sink)
     }
 }
 
+template <typename SourceType, typename SinkType>
+struct ConcatGenericImpl
+{
+    static void concat(GenericArraySource * generic_source, SinkType & sink)
+    {
+        auto source = static_cast<SourceType *>(generic_source);
+        writeSlice(source->getWhole(), sink);
+        source->next();
+    }
+};
+
+template <typename Sink>
+static void NO_INLINE concatGeneric(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink & sink)
+{
+    std::vector<GenericArraySource *> generic_sources;
+    std::vector<bool> is_nullable;
+    std::vector<bool> is_const;
+
+    generic_sources.reserve(sources.size());
+    is_nullable.assign(sources.size(), false);
+    is_const.assign(sources.size(), false);
+
+    for (auto i : ext::range(0, sources.size()))
+    {
+        const auto &source = sources[i];
+        if (auto generic_source = typeid_cast<GenericArraySource *>(source.get()))
+            generic_sources.push_back(static_cast<GenericArraySource *>(generic_source));
+        else if (auto const_generic_source = typeid_cast<ConstSource<GenericArraySource> *>(source.get()))
+        {
+            generic_sources.push_back(static_cast<GenericArraySource *>(const_generic_source));
+            is_const[i] = true;
+        }
+        else if (auto nullable_source = typeid_cast<NullableArraySource<GenericArraySource> *>(source.get()))
+        {
+            generic_sources.push_back(static_cast<GenericArraySource *>(nullable_source));
+            is_nullable[i] = true;
+        }
+        else if (auto const_nullable_source = typeid_cast<ConstSource<NullableArraySource<GenericArraySource>> *>(source.get()))
+        {
+            generic_sources.push_back(static_cast<GenericArraySource *>(const_nullable_source));
+            is_nullable[i] = is_const[i] = true;
+        }
+        else
+            throw Exception(std::string("GenericArraySource expected for GenericArraySink, got: ") + typeid(source).name(),
+                            ErrorCodes::LOGICAL_ERROR);
+    }
+
+    while (!sink.isEnd())
+    {
+        for (auto i : ext::range(0, sources.size()))
+        {
+            auto source = generic_sources[i];
+            if (is_const[i])
+            {
+                if (is_nullable[i])
+                    ConcatGenericImpl<ConstSource<NullableArraySource<GenericArraySource>>, Sink>::concat(source, sink);
+                else
+                    ConcatGenericImpl<ConstSource<GenericArraySource>, Sink>::concat(source, sink);
+            }
+            else
+            {
+                if (is_nullable[i])
+                    ConcatGenericImpl<NullableArraySource<GenericArraySource>, Sink>::concat(source, sink);
+                else
+                    ConcatGenericImpl<GenericArraySource, Sink>::concat(source, sink);
+            }
+        }
+        sink.next();
+    }
+}
+
+template <typename Sink>
+void NO_INLINE concat(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink & sink)
+{
+    size_t elements_to_reserve = 0;
+    bool is_first = true;
+    /// Prepare offsets column. Offsets should point to starts of result arrays.
+
+    for (const auto & source : sources)
+    {
+        elements_to_reserve += source->getSizeForReserve();
+        const auto & offsets = source->getOffsets();
+
+        if (is_first)
+        {
+            sink.offsets.resize(source->getColumnSize());
+            memset(&sink.offsets[0], 0, sink.offsets.size() * sizeof(offsets[0]));
+            is_first = false;
+        }
+        std::cerr << "Offsets:";
+        for (size_t i : ext::range(1, offsets.size()))
+        {
+            std::cerr << ' ' << offsets[i];
+        }
+        std::cerr << std::endl;
+
+        if (source->isConst())
+        {
+            for (size_t i : ext::range(1, offsets.size()))
+                sink.offsets[i] += offsets[0];
+        }
+        else
+        {
+            for (size_t i : ext::range(1, offsets.size()))
+                sink.offsets[i] += offsets[i - 1] - (i > 1 ? offsets[i - 2] : 0);
+        }
+    }
+
+    std::cerr << "Sink offsets:";
+    for (size_t i : ext::range(1, sink.offsets.size()))
+    {
+        sink.offsets[i] += sink.offsets[i - 1];
+        std::cerr << ' ' << sink.offsets[i];
+    }
+    std::cerr << std::endl;
+
+    sink.reserve(elements_to_reserve);
+
+    for (const auto & source : sources)
+    {
+        append<Sink>(*source, sink);
+    }
+}
+
+template <typename ... Types>
+struct ArrayConcat;
+
+template <typename ... Types>
+struct ArrayConcat : public ArraySinkSelector<ArrayConcat, Types ...>
+{
+    using Sources = std::vector<std::unique_ptr<IArraySource>>;
+
+    template <typename Sink>
+    static void selectImpl(Sink & sink, Sources & sources)
+    {
+        concat<Sink>(sources, sink);
+    }
+
+    static void selectImpl(GenericArraySink & sink, Sources & sources)
+    {
+        concatGeneric<GenericArraySink>(sources, sink);
+    }
+
+    static void selectImpl(NullableArraySink<GenericArraySink> & sink, Sources & sources)
+    {
+        concatGeneric<NullableArraySink<GenericArraySink>>(sources, sink);
+    }
+};
+
+
+inline void concat(std::vector<std::unique_ptr<IArraySource>> & sources, IArraySink & sink)
+{
+    /// using List = typename AppendToTypeList<std::vector<std::unique_ptr<IArraySource>>, TypeListNumber>::Type;
+    using ConcatImpl = typename ApplyTypeListForClass<ArrayConcat, TypeListNumber>::Type;
+    using Sources = std::vector<std::unique_ptr<IArraySource>>;
+    return ConcatImpl::select(sink, sources);
+}
 
 template <typename Source, typename Sink>
 void NO_INLINE sliceFromLeftConstantOffsetUnbounded(Source && src, Sink && sink, size_t offset)
@@ -870,6 +1453,9 @@ void NO_INLINE sliceDynamicOffsetBounded(Source && src, Sink && sink, IColumn &
 }
 
 
+
+
+
 template <typename SourceA, typename SourceB, typename Sink>
 void NO_INLINE conditional(SourceA && src_a, SourceB && src_b, Sink && sink, const PaddedPODArray<UInt8> & condition)
 {

From 096d34bb7f120694a2779ffe05f17e8f328b3d30 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Tue, 22 Aug 2017 20:54:14 +0300
Subject: [PATCH 003/266] added arraySlice function [#CLICKHOUSE-2090]

---
 dbms/src/Functions/CMakeLists.txt     |   1 +
 dbms/src/Functions/FunctionsArray.cpp | 124 +++++++++++
 dbms/src/Functions/FunctionsArray.h   |  21 ++
 dbms/src/Functions/GatherUtils.h      | 282 ++++++++++++++++++++++----
 4 files changed, 383 insertions(+), 45 deletions(-)

diff --git a/dbms/src/Functions/CMakeLists.txt b/dbms/src/Functions/CMakeLists.txt
index f726e78883c..a1a1946984a 100644
--- a/dbms/src/Functions/CMakeLists.txt
+++ b/dbms/src/Functions/CMakeLists.txt
@@ -53,6 +53,7 @@ generate_function_register(Array
   FunctionArrayReduce
   FunctionArrayReverse
   FunctionArrayConcat
+  FunctionArraySlice
 )
 
 
diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index 3e374995afc..e803fc46551 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -2977,4 +2977,128 @@ void FunctionArrayConcat::executeImpl(Block & block, const ColumnNumbers & argum
     std::cerr << block.dumpStructure() << std::endl;
 }
 
+
+/// Implementation of FunctionArraySlice.
+
+FunctionPtr FunctionArraySlice::create(const Context & context)
+{
+    return std::make_shared<FunctionArraySlice>();
+}
+
+String FunctionArraySlice::getName() const
+{
+    return name;
+}
+
+DataTypePtr FunctionArraySlice::getReturnTypeImpl(const DataTypes & arguments) const
+{
+    if (arguments[0]->isNull())
+        return arguments[0];
+
+    auto array_type = typeid_cast<DataTypeArray *>(arguments[0].get());
+    if (!array_type)
+        throw Exception("First argument for function " + getName() + " must be an array but it has type "
+                        + arguments[0]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+
+    for (size_t i = 1; i < arguments.size(); ++i)
+    {
+        if (!arguments[i]->isNumeric() && !arguments[i]->isNull())
+            throw Exception("Argument " + toString(i) + " for function " + getName() + " must be numeric but it has type "
+                            + arguments[i]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+    }
+
+    return arguments[0];
+}
+
+void FunctionArraySlice::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+{
+    std::cerr << block.dumpStructure() << std::endl;
+
+    auto & result_colum_with_name_and_type = block.getByPosition(result);
+    auto & result_column = result_colum_with_name_and_type.column;
+    auto & return_type = result_colum_with_name_and_type.type;
+    result_column = return_type->createColumn();
+
+    if (return_type->isNull())
+        return;
+
+    auto & array_column = block.getByPosition(arguments[0]).column;
+    auto & offset_column = block.getByPosition(arguments[1]).column;
+    auto & length_column = block.getByPosition(arguments[2]).column;
+
+    std::unique_ptr<IArraySource> source;
+
+
+    size_t size = array_column->size();
+    bool is_const = false;
+
+    if (auto const_array_column = typeid_cast<ColumnConst *>(array_column.get()))
+    {
+        is_const = true;
+        array_column = const_array_column->getDataColumnPtr();
+    }
+
+    if (auto argument_column_array = typeid_cast<ColumnArray *>(array_column.get()))
+        source = createArraySource(*argument_column_array, is_const, size);
+    else
+        throw Exception{"First arguments for function " + getName() + " must be array.", ErrorCodes::LOGICAL_ERROR};
+
+    auto sink = createArraySink(typeid_cast<ColumnArray &>(*result_column), size);
+
+    if (offset_column->isNull())
+    {
+        if (length_column->isNull())
+            result_column = array_column->clone();
+        else if (length_column->isConst())
+            sliceFromLeftConstantOffsetBounded(*source, *sink, 0, length_column->getInt(0));
+        else
+        {
+            auto const_offset_column = std::make_shared<ColumnConst>(std::make_shared<ColumnInt8>(1, 1), size);
+            sliceDynamicOffsetBounded(*source, *sink, *const_offset_column, *length_column);
+        }
+    }
+    else if (offset_column->isConst())
+    {
+        ssize_t offset = offset_column->getUInt(0);
+
+        if (length_column->isNull())
+        {
+            if (offset > 0)
+                sliceFromLeftConstantOffsetUnbounded(*source, *sink, static_cast<size_t>(offset - 1));
+            else
+                sliceFromRightConstantOffsetUnbounded(*source, *sink, static_cast<size_t>(-offset));
+        }
+        else if (length_column->isConst())
+        {
+            ssize_t length = length_column->getInt(0);
+            if (offset > 0)
+                sliceFromLeftConstantOffsetBounded(*source, *sink, static_cast<size_t>(offset - 1), length);
+            else
+                sliceFromRightConstantOffsetBounded(*source, *sink, static_cast<size_t>(-offset), length);
+        }
+        else
+            sliceDynamicOffsetBounded(*source, *sink, *offset_column, *length_column);
+    }
+    else
+    {
+        if (length_column->isNull())
+            sliceDynamicOffsetUnbounded(*source, *sink, *offset_column);
+        else
+            sliceDynamicOffsetBounded(*source, *sink, *offset_column, *length_column);
+    }
+
+
+    auto array = checkAndGetColumn<ColumnArray>(result_column.get());
+    if (array)
+    {
+        auto & offsets = array->getOffsets();
+        std::cerr << offsets.size()  << " " << array->size()<< std::endl;
+        for (auto & val : offsets)
+            std::cerr << val << ' ';
+        std::cerr << std::endl;
+    }
+
+    std::cerr << block.dumpStructure() << std::endl;
+}
+
 }
diff --git a/dbms/src/Functions/FunctionsArray.h b/dbms/src/Functions/FunctionsArray.h
index 60970b733f9..f6cfd4744e3 100644
--- a/dbms/src/Functions/FunctionsArray.h
+++ b/dbms/src/Functions/FunctionsArray.h
@@ -1425,6 +1425,27 @@ public:
 };
 
 
+class FunctionArraySlice : public IFunction
+{
+public:
+    static constexpr auto name = "arraySlice";
+    static FunctionPtr create(const Context & context);
+
+    String getName() const override;
+
+    bool isVariadic() const override { return false; }
+    size_t getNumberOfArguments() const override { return 3; }
+
+    DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
+
+    void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override;
+
+    bool useDefaultImplementationForConstants() const override { return true; }
+    bool useDefaultImplementationForNulls() const { return false; }
+};
+
+
+
 struct NameHas { static constexpr auto name = "has"; };
 struct NameIndexOf { static constexpr auto name = "indexOf"; };
 struct NameCountEqual { static constexpr auto name = "countEqual"; };
diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index bf825c818cc..cfd445723f9 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -120,6 +120,11 @@ struct NumericArraySource : public IArraySource
         return offsets.size();
     }
 
+    size_t getElementSize() const
+    {
+        return offsets[row_num] - prev_offset;
+    }
+
     Slice getWhole() const
     {
         return {&elements[prev_offset], offsets[row_num] - prev_offset};
@@ -280,6 +285,11 @@ struct StringSource
         return elements.size();
     }
 
+    size_t getElementSize() const
+    {
+        return offsets[row_num] - prev_offset;
+    }
+
     Slice getWhole() const
     {
         return {&elements[prev_offset], offsets[row_num] - prev_offset - 1};
@@ -358,6 +368,11 @@ struct FixedStringSource
         return end - pos;
     }
 
+    size_t getElementSize() const
+    {
+        return string_size;
+    }
+
     Slice getWhole() const
     {
         return {pos, string_size};
@@ -604,6 +619,11 @@ struct GenericArraySource : public IArraySource
         return elements.size();
     }
 
+    size_t getElementSize() const
+    {
+        return offsets[row_num] - prev_offset;
+    }
+
     Slice getWhole() const
     {
         return {&elements, prev_offset, offsets[row_num] - prev_offset};
@@ -1069,84 +1089,110 @@ static void append(Source & source, Sink & sink)
     }
 }
 
-template <template <typename ...> typename Base, typename ... Types>
+template <typename Base, typename ... Types>
 struct ArraySourceSelector;
 
-template <template <typename ...> typename Base, typename Type, typename ... Types>
+template <typename Base, typename Type, typename ... Types>
 struct ArraySourceSelector<Base, Type, Types ...>
 {
     template <typename ... Args>
     static void select(IArraySource & source, Args & ... args)
     {
         if (auto array = typeid_cast<NumericArraySource<Type> *>(&source))
-            Base<Types ...>::selectImpl(*array, args ...);
+            Base::selectImpl(*array, args ...);
         else if(auto nullable_array = typeid_cast<NullableArraySource<NumericArraySource<Type>> *>(&source))
-            Base<Types ...>::selectImpl(*nullable_array, args ...);
+            Base::selectImpl(*nullable_array, args ...);
         else if (auto const_array = typeid_cast<ConstSource<NumericArraySource<Type>> *>(&source))
-            Base<Types ...>::selectImpl(*const_array, args ...);
+            Base::selectImpl(*const_array, args ...);
         else if(auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<NumericArraySource<Type>>> *>(&source))
-            Base<Types ...>::selectImpl(*const_nullable_array, args ...);
+            Base::selectImpl(*const_nullable_array, args ...);
         else
-            Base<Types ...>::select(source, args ...);
+            ArraySourceSelector<Base, Types ...>::select(source, args ...);
     }
 };
 
-template <template <typename ...> typename Base>
+template <typename Base>
 struct ArraySourceSelector<Base>
 {
     template <typename ... Args>
     static void select(IArraySource & source, Args & ... args)
     {
         if (auto array = typeid_cast<GenericArraySource *>(&source))
-            Base<>::selectImpl(*array, args ...);
+            Base::selectImpl(*array, args ...);
         else if(auto nullable_array = typeid_cast<NullableArraySource<GenericArraySource> *>(&source))
-            Base<>::selectImpl(*nullable_array, args ...);
+            Base::selectImpl(*nullable_array, args ...);
         else if (auto const_array = typeid_cast<ConstSource<GenericArraySource> *>(&source))
-            Base<>::selectImpl(*const_array, args ...);
+            Base::selectImpl(*const_array, args ...);
         else if(auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<GenericArraySource>> *>(&source))
-            Base<>::selectImpl(*const_nullable_array, args ...);
+            Base::selectImpl(*const_nullable_array, args ...);
         else
             throw Exception(std::string("Unknown ArraySource type: ") + typeid(source).name(), ErrorCodes::LOGICAL_ERROR);
     }
 };
 
+template <typename Base>
+using GetArraySourceSelector = typename ApplyTypeListForClass<ArraySourceSelector, typename AppendToTypeList<Base, TypeListNumber>::Type>::Type;
 
-template <template <typename ...> typename Base, typename ... Types>
+template <typename Base, typename ... Types>
 struct ArraySinkSelector;
 
-template <template <typename ...> typename Base, typename Type, typename ... Types>
+template <typename Base, typename Type, typename ... Types>
 struct ArraySinkSelector<Base, Type, Types ...>
 {
     template <typename ... Args>
     static void select(IArraySink & sink, Args & ... args)
     {
         if (auto nullable_numeric_sink = typeid_cast<NullableArraySink<NumericArraySink<Type>> *>(&sink))
-            Base<>::selectImpl(*nullable_numeric_sink, args ...);
+            Base::selectImpl(*nullable_numeric_sink, args ...);
         else if (auto numeric_sink = typeid_cast<NumericArraySink<Type> *>(&sink))
-            Base<>::selectImpl(*numeric_sink, args ...);
+            Base::selectImpl(*numeric_sink, args ...);
         else
-            Base<Types ...>::select(sink, args ...);
+            ArraySinkSelector<Base, Types ...>::select(sink, args ...);
     }
 };
 
-template <template <typename ...> typename Base>
+template <typename Base>
 struct ArraySinkSelector<Base>
 {
     template <typename ... Args>
     static void select(IArraySink & sink, Args & ... args)
     {
         if (auto nullable_generic_sink = typeid_cast<NullableArraySink<GenericArraySink> *>(&sink))
-            Base<>::selectImpl(*nullable_generic_sink, args ...);
+            Base::selectImpl(*nullable_generic_sink, args ...);
         else if (auto generic_sink = typeid_cast<GenericArraySink *>(&sink))
-            Base<>::selectImpl(*generic_sink, args ...);
+            Base::selectImpl(*generic_sink, args ...);
         else
             throw Exception(std::string("Unknown ArraySink type: ") + typeid(sink).name(), ErrorCodes::LOGICAL_ERROR);
     }
 };
 
+template <typename Base>
+using GetArraySinkSelector = typename ApplyTypeListForClass<ArraySinkSelector, typename AppendToTypeList<Base, TypeListNumber>::Type>::Type;
 
-template <typename ... Types>
-struct ArrayAppend : public ArraySourceSelector<ArrayAppend, Types ...>
+template <typename Base>
+struct ArraySinkSourceSelector
+{
+    template <typename ... Args>
+    static void select(IArraySource & source, IArraySink & sink, Args & ... args)
+    {
+        GetArraySinkSelector<Base>::select(sink, source, args ...);
+    }
+
+    template <typename Sink, typename ... Args>
+    static void selectImpl(Sink & sink, IArraySource & source, Args & ... args)
+    {
+        GetArraySourceSelector<Base>::select(source, sink, args ...);
+    }
+
+    template <typename Source, typename Sink, typename ... Args>
+    static void selectImpl(Source & source, Sink & sink, Args & ... args)
+    {
+        Base::selectSourceSink(source, sink, args ...);
+    }
+};
+
+
+struct ArrayAppend : public GetArraySourceSelector<ArrayAppend>
 {
     template <typename Source, typename Sink>
     static void selectImpl(Source & source, Sink & sink)
@@ -1158,9 +1204,7 @@ struct ArrayAppend : public ArraySourceSelector<ArrayAppend, Types ...>
 template <typename Sink>
 static void append(IArraySource & source, Sink & sink)
 {
-    // using List = typename AppendToTypeList<Sink, TypeListNumber>::Type;
-    using AppendImpl = typename ApplyTypeListForClass<ArrayAppend, TypeListNumber>::Type;
-    AppendImpl::select(source, sink);
+    ArrayAppend::select(source, sink);
 }
 
 
@@ -1324,11 +1368,7 @@ void NO_INLINE concat(const std::vector<std::unique_ptr<IArraySource>> & sources
     }
 }
 
-template <typename ... Types>
-struct ArrayConcat;
-
-template <typename ... Types>
-struct ArrayConcat : public ArraySinkSelector<ArrayConcat, Types ...>
+struct ArrayConcat : public GetArraySinkSelector<ArrayConcat>
 {
     using Sources = std::vector<std::unique_ptr<IArraySource>>;
 
@@ -1352,14 +1392,12 @@ struct ArrayConcat : public ArraySinkSelector<ArrayConcat, Types ...>
 
 inline void concat(std::vector<std::unique_ptr<IArraySource>> & sources, IArraySink & sink)
 {
-    /// using List = typename AppendToTypeList<std::vector<std::unique_ptr<IArraySource>>, TypeListNumber>::Type;
-    using ConcatImpl = typename ApplyTypeListForClass<ArrayConcat, TypeListNumber>::Type;
     using Sources = std::vector<std::unique_ptr<IArraySource>>;
-    return ConcatImpl::select(sink, sources);
+    return ArrayConcat::select(sink, sources);
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceFromLeftConstantOffsetUnbounded(Source && src, Sink && sink, size_t offset)
+void NO_INLINE sliceFromLeftConstantOffsetUnbounded(Source & src, Sink & sink, size_t offset)
 {
     while (!src.isEnd())
     {
@@ -1370,18 +1408,24 @@ void NO_INLINE sliceFromLeftConstantOffsetUnbounded(Source && src, Sink && sink,
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceFromLeftConstantOffsetBounded(Source && src, Sink && sink, size_t offset, size_t length)
+void NO_INLINE sliceFromLeftConstantOffsetBounded(Source & src, Sink & sink, size_t offset, ssize_t length)
 {
     while (!src.isEnd())
     {
-        writeSlice(src.getSliceFromLeft(offset, length), sink);
+        ssize_t size = length;
+        if (size < 0)
+            size += static_cast<ssize_t>(src.getElementSize()) - offset;
+
+        if (size > 0)
+            writeSlice(src.getSliceFromLeft(offset, size), sink);
+
         sink.next();
         src.next();
     }
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceFromRightConstantOffsetUnbounded(Source && src, Sink && sink, size_t offset)
+void NO_INLINE sliceFromRightConstantOffsetUnbounded(Source & src, Sink & sink, size_t offset)
 {
     while (!src.isEnd())
     {
@@ -1392,22 +1436,34 @@ void NO_INLINE sliceFromRightConstantOffsetUnbounded(Source && src, Sink && sink
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceFromRightConstantOffsetBounded(Source && src, Sink && sink, size_t offset, size_t length)
+void NO_INLINE sliceFromRightConstantOffsetBounded(Source & src, Sink & sink, size_t offset, ssize_t length)
 {
     while (!src.isEnd())
     {
-        writeSlice(src.getSliceFromRight(offset, length), sink);
+        ssize_t size = length;
+        if (size < 0)
+            size += static_cast<ssize_t>(src.getElementSize()) - offset;
+
+        if (size > 0)
+            writeSlice(src.getSliceFromRight(offset, size), sink);
+
         sink.next();
         src.next();
     }
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceDynamicOffsetUnbounded(Source && src, Sink && sink, IColumn & offset_column)
+void NO_INLINE sliceDynamicOffsetUnbounded(Source & src, Sink & sink, IColumn & offset_column)
 {
+    const bool is_null = offset_column.isNull();
+    const bool is_nullable = offset_column.isNullable();
+    auto null_map = is_nullable ? &static_cast<ColumnNullable &>(offset_column).getNullMapConcreteColumn().getData() : nullptr;
+
     while (!src.isEnd())
     {
-        Int64 offset = offset_column.getInt(src.rowNum());
+        auto row_num = src.rowNum();
+        bool has_offset = !is_null && !(is_nullable && (*null_map)[row_num]);
+        Int64 offset = has_offset ? offset_column.getInt(row_num) : 1;
 
         if (offset != 0)
         {
@@ -1427,15 +1483,28 @@ void NO_INLINE sliceDynamicOffsetUnbounded(Source && src, Sink && sink, IColumn
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceDynamicOffsetBounded(Source && src, Sink && sink, IColumn & offset_column, IColumn & length_column)
+void NO_INLINE sliceDynamicOffsetBounded(Source & src, Sink & sink, IColumn & offset_column, IColumn & length_column)
 {
+    const bool is_offset_null = offset_column.isNull();
+    const bool is_offset_nullable = offset_column.isNullable();
+    auto offset_null_map = is_offset_nullable ? &static_cast<ColumnNullable &>(offset_column).getNullMapConcreteColumn().getData() : nullptr;
+
+    const bool is_length_null = length_column.isNull();
+    const bool is_length_nullable = length_column.isNullable();
+    auto length_null_map = is_length_nullable ? &static_cast<ColumnNullable &>(length_column).getNullMapConcreteColumn().getData() : nullptr;
+
     while (!src.isEnd())
     {
         size_t row_num = src.rowNum();
-        Int64 offset = offset_column.getInt(row_num);
-        UInt64 size = length_column.getInt(row_num);
+        bool has_offset = !is_offset_null && !(is_offset_nullable && (*offset_null_map)[row_num]);
+        bool has_length = !is_length_null && !(is_length_nullable && (*length_null_map)[row_num]);
+        Int64 offset = has_offset ? offset_column.getInt(row_num) : 1;
+        Int64 size = has_length ? length_column.getInt(row_num) : static_cast<Int64>(src.getElementSize());
 
-        if (offset != 0 && size < 0x8000000000000000ULL)
+        if (size < 0)
+            size += offset > 0 ? static_cast<Int64>(src.getElementSize()) - (offset - 1) : -offset;
+
+        if (offset != 0 && size > 0)
         {
             typename std::decay<Source>::type::Slice slice;
 
@@ -1453,8 +1522,131 @@ void NO_INLINE sliceDynamicOffsetBounded(Source && src, Sink && sink, IColumn &
 }
 
 
+template <typename Source, typename Sink>
+void NO_INLINE sliceFromLeftConstantOffsetUnbounded(Source && src, Sink && sink, size_t offset)
+{
+    sliceFromLeftConstantOffsetUnbounded(src, sink, offset);
+}
 
+template <typename Source, typename Sink>
+void NO_INLINE sliceFromLeftConstantOffsetBounded(Source && src, Sink && sink, size_t offset, ssize_t length)
+{
+    sliceFromLeftConstantOffsetBounded(src, sink, offset, length);
+}
 
+template <typename Source, typename Sink>
+void NO_INLINE sliceFromRightConstantOffsetUnbounded(Source && src, Sink && sink, size_t offset)
+{
+    sliceFromRightConstantOffsetUnbounded(src, sink, offset);
+}
+
+template <typename Source, typename Sink>
+void NO_INLINE sliceFromRightConstantOffsetBounded(Source && src, Sink && sink, size_t offset, ssize_t length)
+{
+    sliceFromRightConstantOffsetBounded(src, sink, offset, length);
+}
+
+template <typename Source, typename Sink>
+void NO_INLINE sliceDynamicOffsetUnbounded(Source && src, Sink && sink, IColumn & offset_column)
+{
+    sliceDynamicOffsetUnbounded(src, sink, offset_column);
+}
+
+template <typename Source, typename Sink>
+void NO_INLINE sliceDynamicOffsetBounded(Source && src, Sink && sink, IColumn & offset_column, IColumn & length_column)
+{
+    sliceDynamicOffsetBounded(src, sink, offset_column, length_column);
+}
+
+struct SliceFromLeftConstantOffsetUnboundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceFromLeftConstantOffsetUnboundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, size_t & offset)
+    {
+        sliceFromLeftConstantOffsetUnbounded<Source, Sink>(source, sink, offset);
+    }
+};
+
+struct SliceFromLeftConstantOffsetBoundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceFromLeftConstantOffsetBoundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, size_t & offset, ssize_t & length)
+    {
+        sliceFromLeftConstantOffsetBounded<Source, Sink>(source, sink, offset, length);
+    }
+};
+
+struct SliceFromRightConstantOffsetUnboundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceFromRightConstantOffsetUnboundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, size_t & offset)
+    {
+        sliceFromRightConstantOffsetUnbounded<Source, Sink>(source, sink, offset);
+    }
+};
+
+struct SliceFromRightConstantOffsetBoundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceFromRightConstantOffsetBoundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, size_t & offset, ssize_t & length)
+    {
+        sliceFromRightConstantOffsetBounded<Source, Sink>(source, sink, offset, length);
+    }
+};
+
+struct SliceDynamicOffsetUnboundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceDynamicOffsetUnboundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, IColumn & offset_column)
+    {
+        sliceDynamicOffsetUnbounded<Source, Sink>(source, sink, offset_column);
+    }
+};
+
+struct SliceDynamicOffsetBoundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceDynamicOffsetBoundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, IColumn & offset_column, IColumn & length_column)
+    {
+        sliceDynamicOffsetBounded<Source, Sink>(source, sink, offset_column, length_column);
+    }
+};
+
+inline void sliceFromLeftConstantOffsetUnbounded(IArraySource & src, IArraySink & sink, size_t offset)
+{
+    SliceFromLeftConstantOffsetUnboundedSelectArraySource::select(src, sink, offset);
+}
+
+inline void sliceFromLeftConstantOffsetBounded(IArraySource & src, IArraySink & sink, size_t offset, ssize_t length)
+{
+    SliceFromLeftConstantOffsetBoundedSelectArraySource::select(src, sink, offset, length);
+}
+
+inline void sliceFromRightConstantOffsetUnbounded(IArraySource & src, IArraySink & sink, size_t offset)
+{
+    SliceFromRightConstantOffsetUnboundedSelectArraySource::select(src, sink, offset);
+}
+
+inline void sliceFromRightConstantOffsetBounded(IArraySource & src, IArraySink & sink, size_t offset, ssize_t length)
+{
+    SliceFromRightConstantOffsetBoundedSelectArraySource::select(src, sink, offset, length);
+}
+
+inline void sliceDynamicOffsetUnbounded(IArraySource & src, IArraySink & sink, IColumn & offset_column)
+{
+    SliceDynamicOffsetUnboundedSelectArraySource::select(src, sink, offset_column);
+}
+
+inline void sliceDynamicOffsetBounded(IArraySource & src, IArraySink & sink, IColumn & offset_column, IColumn & length_column)
+{
+    SliceDynamicOffsetBoundedSelectArraySource::select(src, sink, offset_column, length_column);
+}
 
 template <typename SourceA, typename SourceB, typename Sink>
 void NO_INLINE conditional(SourceA && src_a, SourceB && src_b, Sink && sink, const PaddedPODArray<UInt8> & condition)

From e6fd55ff42ba97f5f2b1c5549f1477f591c1c0d7 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Thu, 24 Aug 2017 16:00:23 +0300
Subject: [PATCH 004/266] added arrayPushBack arrayPushFront arrayPopBack
 arrayPopFront function [#CLICKHOUSE-2090]

---
 dbms/src/Functions/CMakeLists.txt     |    4 +
 dbms/src/Functions/FunctionsArray.cpp | 1940 ++++++++++++++-----------
 dbms/src/Functions/FunctionsArray.h   |   86 +-
 dbms/src/Functions/GatherUtils.cpp    |  482 ++++++
 dbms/src/Functions/GatherUtils.h      |  528 +------
 5 files changed, 1680 insertions(+), 1360 deletions(-)
 create mode 100644 dbms/src/Functions/GatherUtils.cpp

diff --git a/dbms/src/Functions/CMakeLists.txt b/dbms/src/Functions/CMakeLists.txt
index a1a1946984a..dde2fe117c3 100644
--- a/dbms/src/Functions/CMakeLists.txt
+++ b/dbms/src/Functions/CMakeLists.txt
@@ -54,6 +54,10 @@ generate_function_register(Array
   FunctionArrayReverse
   FunctionArrayConcat
   FunctionArraySlice
+  FunctionArrayPushBack
+  FunctionArrayPushFront
+  FunctionArrayPopBack
+  FunctionArrayPopFront
 )
 
 
diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index e803fc46551..ca57755cec1 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -33,13 +33,13 @@ String FunctionArray::getName() const
     return name;
 }
 
-FunctionPtr FunctionArray::create(const Context & context)
+FunctionPtr FunctionArray::create(const Context &context)
 {
     return std::make_shared<FunctionArray>(context);
 }
 
-FunctionArray::FunctionArray(const Context & context)
-    : context(context)
+FunctionArray::FunctionArray(const Context &context)
+        : context(context)
 {
 }
 
@@ -48,7 +48,7 @@ namespace
 {
 
 /// Is there at least one numeric argument among the specified ones?
-bool foundNumericType(const DataTypes & args)
+bool foundNumericType(const DataTypes &args)
 {
     for (size_t i = 0; i < args.size(); ++i)
     {
@@ -63,7 +63,7 @@ bool foundNumericType(const DataTypes & args)
 
 
 /// Check if the specified arguments have the same type up to nullability or nullity.
-bool hasArrayIdenticalTypes(const DataTypes & args)
+bool hasArrayIdenticalTypes(const DataTypes &args)
 {
     std::string first_type_name;
 
@@ -71,8 +71,8 @@ bool hasArrayIdenticalTypes(const DataTypes & args)
     {
         if (!args[i]->isNull())
         {
-            const IDataType * observed_type = DataTypeTraits::removeNullable(args[i]).get();
-            const std::string & name = observed_type->getName();
+            const IDataType *observed_type = DataTypeTraits::removeNullable(args[i]).get();
+            const std::string &name = observed_type->getName();
 
             if (first_type_name.empty())
                 first_type_name = name;
@@ -88,16 +88,16 @@ bool hasArrayIdenticalTypes(const DataTypes & args)
 /// function hasArrayIdenticalTypes(), deduce the element type of an array that
 /// would be constructed from a set of values V, such that, for each i, the
 /// type of V[i] is args[i].
-DataTypePtr getArrayElementType(const DataTypes & args)
+DataTypePtr getArrayElementType(const DataTypes &args)
 {
     bool found_null = false;
     bool found_nullable = false;
 
-    const DataTypePtr * ret = nullptr;
+    const DataTypePtr *ret = nullptr;
 
     for (size_t i = 0; i < args.size(); ++i)
     {
-        const auto & type = args[i];
+        const auto &type = args[i];
 
         if (type->isNull())
             found_null = true;
@@ -129,8 +129,8 @@ DataTypePtr getArrayElementType(const DataTypes & args)
     }
 }
 
-template <typename T0, typename T1>
-bool tryAddField(DataTypePtr type_res, const Field & f, Array & arr)
+template<typename T0, typename T1>
+bool tryAddField(DataTypePtr type_res, const Field &f, Array &arr)
 {
     if (typeid_cast<const T0 *>(type_res.get()))
     {
@@ -145,28 +145,28 @@ bool tryAddField(DataTypePtr type_res, const Field & f, Array & arr)
 
 }
 
-bool FunctionArray::addField(DataTypePtr type_res, const Field & f, Array & arr) const
+bool FunctionArray::addField(DataTypePtr type_res, const Field &f, Array &arr) const
 {
     /// Otherwise, it is necessary
-    if (    tryAddField<DataTypeUInt8, DataTypeUInt64>(type_res, f, arr)
-        ||    tryAddField<DataTypeUInt16, DataTypeUInt64>(type_res, f, arr)
-        ||    tryAddField<DataTypeUInt32, DataTypeUInt64>(type_res, f, arr)
-        ||    tryAddField<DataTypeUInt64, DataTypeUInt64>(type_res, f, arr)
-        ||    tryAddField<DataTypeInt8, DataTypeInt64>(type_res, f, arr)
-        ||    tryAddField<DataTypeInt16, DataTypeInt64>(type_res, f, arr)
-        ||    tryAddField<DataTypeInt32, DataTypeInt64>(type_res, f, arr)
-        ||    tryAddField<DataTypeInt64, DataTypeInt64>(type_res, f, arr)
-        ||    tryAddField<DataTypeFloat32, DataTypeFloat64>(type_res, f, arr)
-        ||    tryAddField<DataTypeFloat64, DataTypeFloat64>(type_res, f, arr) )
+    if (tryAddField<DataTypeUInt8, DataTypeUInt64>(type_res, f, arr)
+        || tryAddField<DataTypeUInt16, DataTypeUInt64>(type_res, f, arr)
+        || tryAddField<DataTypeUInt32, DataTypeUInt64>(type_res, f, arr)
+        || tryAddField<DataTypeUInt64, DataTypeUInt64>(type_res, f, arr)
+        || tryAddField<DataTypeInt8, DataTypeInt64>(type_res, f, arr)
+        || tryAddField<DataTypeInt16, DataTypeInt64>(type_res, f, arr)
+        || tryAddField<DataTypeInt32, DataTypeInt64>(type_res, f, arr)
+        || tryAddField<DataTypeInt64, DataTypeInt64>(type_res, f, arr)
+        || tryAddField<DataTypeFloat32, DataTypeFloat64>(type_res, f, arr)
+        || tryAddField<DataTypeFloat64, DataTypeFloat64>(type_res, f, arr))
         return true;
     else
     {
         throw Exception{"Illegal result type " + type_res->getName() + " of function " + getName(),
-            ErrorCodes::LOGICAL_ERROR};
+                        ErrorCodes::LOGICAL_ERROR};
     }
 }
 
-const DataTypePtr & FunctionArray::getScalarType(const DataTypePtr & type)
+const DataTypePtr &FunctionArray::getScalarType(const DataTypePtr &type)
 {
     const auto array = checkAndGetDataType<DataTypeArray>(type.get());
 
@@ -176,7 +176,7 @@ const DataTypePtr & FunctionArray::getScalarType(const DataTypePtr & type)
     return getScalarType(array->getNestedType());
 }
 
-DataTypeTraits::EnrichedDataTypePtr FunctionArray::getLeastCommonType(const DataTypes & arguments) const
+DataTypeTraits::EnrichedDataTypePtr FunctionArray::getLeastCommonType(const DataTypes &arguments) const
 {
     DataTypeTraits::EnrichedDataTypePtr result_type;
 
@@ -184,26 +184,26 @@ DataTypeTraits::EnrichedDataTypePtr FunctionArray::getLeastCommonType(const Data
     {
         result_type = Conditional::getArrayType(arguments);
     }
-    catch (const Conditional::CondException & ex)
+    catch (const Conditional::CondException &ex)
     {
         /// Translate a context-free error into a contextual error.
         if (ex.getCode() == Conditional::CondErrorCodes::TYPE_DEDUCER_ILLEGAL_COLUMN_TYPE)
             throw Exception{"Illegal type of column " + ex.getMsg1() +
-                " in array", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+                            " in array", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
         else if (ex.getCode() == Conditional::CondErrorCodes::TYPE_DEDUCER_UPSCALING_ERROR)
             throw Exception("Arguments of function " + getName() + " are not upscalable "
-                "to a common type without loss of precision.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                                    "to a common type without loss of precision.",
+                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
         else
             throw Exception{"An unexpected error has occurred in function " + getName(),
-                ErrorCodes::LOGICAL_ERROR};
+                            ErrorCodes::LOGICAL_ERROR};
     }
 
     return result_type;
 }
 
 
-DataTypePtr FunctionArray::getReturnTypeImpl(const DataTypes & arguments) const
+DataTypePtr FunctionArray::getReturnTypeImpl(const DataTypes &arguments) const
 {
     if (arguments.empty())
         throw Exception{"Function array requires at least one argument.", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
@@ -220,13 +220,14 @@ DataTypePtr FunctionArray::getReturnTypeImpl(const DataTypes & arguments) const
     {
         /// Otherwise all the arguments must have the same type up to nullability or nullity.
         if (!hasArrayIdenticalTypes(arguments))
-            throw Exception{"Arguments for function array must have same type or behave as number.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception{"Arguments for function array must have same type or behave as number.",
+                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         return std::make_shared<DataTypeArray>(getArrayElementType(arguments));
     }
 }
 
-void FunctionArray::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+void FunctionArray::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
 {
     size_t num_elements = arguments.size();
     bool is_const = true;
@@ -240,17 +241,17 @@ void FunctionArray::executeImpl(Block & block, const ColumnNumbers & arguments,
         }
     }
 
-    const DataTypePtr & return_type = block.getByPosition(result).type;
-    const DataTypePtr & elem_type = static_cast<const DataTypeArray &>(*return_type).getNestedType();
+    const DataTypePtr &return_type = block.getByPosition(result).type;
+    const DataTypePtr &elem_type = static_cast<const DataTypeArray &>(*return_type).getNestedType();
 
     if (is_const)
     {
-        const DataTypePtr & observed_type = DataTypeTraits::removeNullable(elem_type);
+        const DataTypePtr &observed_type = DataTypeTraits::removeNullable(elem_type);
 
         Array arr;
         for (const auto arg_num : arguments)
         {
-            const auto & elem = block.getByPosition(arg_num);
+            const auto &elem = block.getByPosition(arg_num);
 
             if (DataTypeTraits::removeNullable(elem.type)->equals(*observed_type))
             {
@@ -280,11 +281,11 @@ void FunctionArray::executeImpl(Block & block, const ColumnNumbers & arguments,
           */
 
         Columns columns_holder(num_elements);
-        const IColumn * columns[num_elements];
+        const IColumn *columns[num_elements];
 
         for (size_t i = 0; i < num_elements; ++i)
         {
-            const auto & arg = block.getByPosition(arguments[i]);
+            const auto &arg = block.getByPosition(arguments[i]);
 
             String elem_type_name = elem_type->getName();
             ColumnPtr preprocessed_column = arg.column;
@@ -292,29 +293,30 @@ void FunctionArray::executeImpl(Block & block, const ColumnNumbers & arguments,
             if (arg.type->getName() != elem_type_name)
             {
                 Block temporary_block
-                {
-                    {
-                        arg.column,
-                        arg.type,
-                        arg.name
-                    },
-                    {
-                        DataTypeString().createConstColumn(block_size, elem_type_name),
-                        std::make_shared<DataTypeString>(),
-                        ""
-                    },
-                    {
-                        nullptr,
-                        elem_type,
-                        ""
-                    }
-                };
+                        {
+                                {
+                                        arg.column,
+                                        arg.type,
+                                        arg.name
+                                },
+                                {
+                                        DataTypeString().createConstColumn(block_size, elem_type_name),
+                                        std::make_shared<DataTypeString>(),
+                                        ""
+                                },
+                                {
+                                        nullptr,
+                                        elem_type,
+                                        ""
+                                }
+                        };
 
                 FunctionCast func_cast(context);
 
                 {
                     DataTypePtr unused_return_type;
-                    ColumnsWithTypeAndName arguments{ temporary_block.getByPosition(0), temporary_block.getByPosition(1) };
+                    ColumnsWithTypeAndName arguments{temporary_block.getByPosition(0),
+                                                     temporary_block.getByPosition(1)};
                     std::vector<ExpressionAction> unused_prerequisites;
 
                     /// Prepares function to execution. TODO It is not obvious.
@@ -336,8 +338,8 @@ void FunctionArray::executeImpl(Block & block, const ColumnNumbers & arguments,
           */
 
         auto out = std::make_shared<ColumnArray>(elem_type->createColumn());
-        IColumn & out_data = out->getData();
-        IColumn::Offsets_t & out_offsets = out->getOffsets();
+        IColumn &out_data = out->getData();
+        IColumn::Offsets_t &out_offsets = out->getOffsets();
 
         out_data.reserve(block_size * num_elements);
         out_offsets.resize(block_size);
@@ -364,15 +366,18 @@ namespace ArrayImpl
 class NullMapBuilder
 {
 public:
-    operator bool() const { return src_nullable_col || src_array; }
-    bool operator!() const { return !src_nullable_col && !src_array; }
+    operator bool() const
+    { return src_nullable_col || src_array; }
 
-    void initSource(const ColumnNullable & src_nullable_col_)
+    bool operator!() const
+    { return !src_nullable_col && !src_array; }
+
+    void initSource(const ColumnNullable &src_nullable_col_)
     {
         src_nullable_col = &src_nullable_col_;
     }
 
-    void initSource(const Array & src_array_)
+    void initSource(const Array &src_array_)
     {
         src_array = &src_array_;
     }
@@ -386,7 +391,8 @@ public:
     void update(size_t from)
     {
         if (index >= size)
-            throw Exception{"Logical error: index passed to NullMapBuilder is out of range of column.", ErrorCodes::LOGICAL_ERROR};
+            throw Exception{"Logical error: index passed to NullMapBuilder is out of range of column.",
+                            ErrorCodes::LOGICAL_ERROR};
 
         bool is_null;
         if (src_nullable_col)
@@ -394,7 +400,7 @@ public:
         else
             is_null = from < src_array->size() ? (*src_array)[from].isNull() : true;
 
-        auto & null_map_data = static_cast<ColumnUInt8 &>(*sink_null_map).getData();
+        auto &null_map_data = static_cast<ColumnUInt8 &>(*sink_null_map).getData();
         null_map_data[index] = is_null ? 1 : 0;
 
         ++index;
@@ -403,18 +409,20 @@ public:
     void update()
     {
         if (index >= size)
-            throw Exception{"Logical error: index passed to NullMapBuilder is out of range of column.", ErrorCodes::LOGICAL_ERROR};
+            throw Exception{"Logical error: index passed to NullMapBuilder is out of range of column.",
+                            ErrorCodes::LOGICAL_ERROR};
 
-        auto & null_map_data = static_cast<ColumnUInt8 &>(*sink_null_map).getData();
+        auto &null_map_data = static_cast<ColumnUInt8 &>(*sink_null_map).getData();
         null_map_data[index] = 0;
         ++index;
     }
 
-    ColumnPtr getNullMap() const { return sink_null_map; }
+    ColumnPtr getNullMap() const
+    { return sink_null_map; }
 
 private:
-    const ColumnNullable * src_nullable_col = nullptr;
-    const Array * src_array = nullptr;
+    const ColumnNullable *src_nullable_col = nullptr;
+    const Array *src_array = nullptr;
     ColumnPtr sink_null_map;
     size_t size = 0;
     size_t index = 0;
@@ -425,18 +433,18 @@ private:
 namespace
 {
 
-template <typename T>
+template<typename T>
 struct ArrayElementNumImpl
 {
     /** Implementation for constant index.
       * If negative = false - index is from beginning of array, started from 1.
       * If negative = true - index is from end of array, started from -1.
       */
-    template <bool negative>
+    template<bool negative>
     static void vectorConst(
-        const PaddedPODArray<T> & data, const ColumnArray::Offsets_t & offsets,
-        const ColumnArray::Offset_t index,
-        PaddedPODArray<T> & result, ArrayImpl::NullMapBuilder & builder)
+            const PaddedPODArray<T> &data, const ColumnArray::Offsets_t &offsets,
+            const ColumnArray::Offset_t index,
+            PaddedPODArray<T> &result, ArrayImpl::NullMapBuilder &builder)
     {
         size_t size = offsets.size();
         result.resize(size);
@@ -467,11 +475,11 @@ struct ArrayElementNumImpl
 
     /** Implementation for non-constant index.
       */
-    template <typename TIndex>
+    template<typename TIndex>
     static void vector(
-        const PaddedPODArray<T> & data, const ColumnArray::Offsets_t & offsets,
-        const PaddedPODArray<TIndex> & indices,
-        PaddedPODArray<T> & result, ArrayImpl::NullMapBuilder & builder)
+            const PaddedPODArray<T> &data, const ColumnArray::Offsets_t &offsets,
+            const PaddedPODArray<TIndex> &indices,
+            PaddedPODArray<T> &result, ArrayImpl::NullMapBuilder &builder)
     {
         size_t size = offsets.size();
         result.resize(size);
@@ -517,12 +525,13 @@ struct ArrayElementStringImpl
       * If negative = false - index is from beginning of array, started from 1.
       * If negative = true - index is from end of array, started from -1.
       */
-    template <bool negative>
+    template<bool negative>
     static void vectorConst(
-        const ColumnString::Chars_t & data, const ColumnArray::Offsets_t & offsets, const ColumnString::Offsets_t & string_offsets,
-        const ColumnArray::Offset_t index,
-        ColumnString::Chars_t & result_data, ColumnArray::Offsets_t & result_offsets,
-        ArrayImpl::NullMapBuilder & builder)
+            const ColumnString::Chars_t &data, const ColumnArray::Offsets_t &offsets,
+            const ColumnString::Offsets_t &string_offsets,
+            const ColumnArray::Offset_t index,
+            ColumnString::Chars_t &result_data, ColumnArray::Offsets_t &result_offsets,
+            ArrayImpl::NullMapBuilder &builder)
     {
         size_t size = offsets.size();
         result_offsets.resize(size);
@@ -538,18 +547,19 @@ struct ArrayElementStringImpl
             {
                 size_t adjusted_index = !negative ? index : (array_size - index - 1);
 
-                size_t j =  (current_offset == 0 && adjusted_index == 0) ? 0 : current_offset + adjusted_index;
+                size_t j = (current_offset == 0 && adjusted_index == 0) ? 0 : current_offset + adjusted_index;
                 if (builder)
                     builder.update(j);
 
                 ColumnArray::Offset_t string_pos = current_offset == 0 && adjusted_index == 0
-                    ? 0
-                    : string_offsets[current_offset + adjusted_index - 1];
+                                                   ? 0
+                                                   : string_offsets[current_offset + adjusted_index - 1];
 
                 ColumnArray::Offset_t string_size = string_offsets[current_offset + adjusted_index] - string_pos;
 
                 result_data.resize(current_result_offset + string_size);
-                memcpySmallAllowReadWriteOverflow15(&result_data[current_result_offset], &data[string_pos], string_size);
+                memcpySmallAllowReadWriteOverflow15(&result_data[current_result_offset], &data[string_pos],
+                                                    string_size);
                 current_result_offset += string_size;
                 result_offsets[i] = current_result_offset;
             }
@@ -571,12 +581,13 @@ struct ArrayElementStringImpl
 
     /** Implementation for non-constant index.
       */
-    template <typename TIndex>
+    template<typename TIndex>
     static void vector(
-        const ColumnString::Chars_t & data, const ColumnArray::Offsets_t & offsets, const ColumnString::Offsets_t & string_offsets,
-        const PaddedPODArray<TIndex> & indices,
-        ColumnString::Chars_t & result_data, ColumnArray::Offsets_t & result_offsets,
-        ArrayImpl::NullMapBuilder & builder)
+            const ColumnString::Chars_t &data, const ColumnArray::Offsets_t &offsets,
+            const ColumnString::Offsets_t &string_offsets,
+            const PaddedPODArray<TIndex> &indices,
+            ColumnString::Chars_t &result_data, ColumnArray::Offsets_t &result_offsets,
+            ArrayImpl::NullMapBuilder &builder)
     {
         size_t size = offsets.size();
         result_offsets.resize(size);
@@ -604,13 +615,14 @@ struct ArrayElementStringImpl
                     builder.update(j);
 
                 ColumnArray::Offset_t string_pos = current_offset == 0 && adjusted_index == 0
-                    ? 0
-                    : string_offsets[current_offset + adjusted_index - 1];
+                                                   ? 0
+                                                   : string_offsets[current_offset + adjusted_index - 1];
 
                 ColumnArray::Offset_t string_size = string_offsets[current_offset + adjusted_index] - string_pos;
 
                 result_data.resize(current_result_offset + string_size);
-                memcpySmallAllowReadWriteOverflow15(&result_data[current_result_offset], &data[string_pos], string_size);
+                memcpySmallAllowReadWriteOverflow15(&result_data[current_result_offset], &data[string_pos],
+                                                    string_size);
                 current_result_offset += string_size;
                 result_offsets[i] = current_result_offset;
             }
@@ -638,11 +650,11 @@ struct ArrayElementGenericImpl
       * If negative = false - index is from beginning of array, started from 1.
       * If negative = true - index is from end of array, started from -1.
       */
-    template <bool negative>
+    template<bool negative>
     static void vectorConst(
-        const IColumn & data, const ColumnArray::Offsets_t & offsets,
-        const ColumnArray::Offset_t index,
-        IColumn & result, ArrayImpl::NullMapBuilder & builder)
+            const IColumn &data, const ColumnArray::Offsets_t &offsets,
+            const ColumnArray::Offset_t index,
+            IColumn &result, ArrayImpl::NullMapBuilder &builder)
     {
         size_t size = offsets.size();
         result.reserve(size);
@@ -672,11 +684,11 @@ struct ArrayElementGenericImpl
 
     /** Implementation for non-constant index.
       */
-    template <typename TIndex>
+    template<typename TIndex>
     static void vector(
-        const IColumn & data, const ColumnArray::Offsets_t & offsets,
-        const PaddedPODArray<TIndex> & indices,
-        IColumn & result, ArrayImpl::NullMapBuilder & builder)
+            const IColumn &data, const ColumnArray::Offsets_t &offsets,
+            const PaddedPODArray<TIndex> &indices,
+            IColumn &result, ArrayImpl::NullMapBuilder &builder)
     {
         size_t size = offsets.size();
         result.reserve(size);
@@ -716,22 +728,23 @@ struct ArrayElementGenericImpl
 }
 
 
-FunctionPtr FunctionArrayElement::create(const Context & context)
+FunctionPtr FunctionArrayElement::create(const Context &context)
 {
     return std::make_shared<FunctionArrayElement>();
 }
 
 
-template <typename DataType>
-bool FunctionArrayElement::executeNumberConst(Block & block, const ColumnNumbers & arguments, size_t result, const Field & index,
-    ArrayImpl::NullMapBuilder & builder)
+template<typename DataType>
+bool FunctionArrayElement::executeNumberConst(Block &block, const ColumnNumbers &arguments, size_t result,
+                                              const Field &index,
+                                              ArrayImpl::NullMapBuilder &builder)
 {
-    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const ColumnVector<DataType> * col_nested = checkAndGetColumn<ColumnVector<DataType>>(&col_array->getData());
+    const ColumnVector<DataType> *col_nested = checkAndGetColumn<ColumnVector<DataType>>(&col_array->getData());
 
     if (!col_nested)
         return false;
@@ -741,26 +754,29 @@ bool FunctionArrayElement::executeNumberConst(Block & block, const ColumnNumbers
 
     if (index.getType() == Field::Types::UInt64)
         ArrayElementNumImpl<DataType>::template vectorConst<false>(
-            col_nested->getData(), col_array->getOffsets(), safeGet<UInt64>(index) - 1, col_res->getData(), builder);
+                col_nested->getData(), col_array->getOffsets(), safeGet<UInt64>(index) - 1, col_res->getData(),
+                builder);
     else if (index.getType() == Field::Types::Int64)
         ArrayElementNumImpl<DataType>::template vectorConst<true>(
-            col_nested->getData(), col_array->getOffsets(), -safeGet<Int64>(index) - 1, col_res->getData(), builder);
+                col_nested->getData(), col_array->getOffsets(), -safeGet<Int64>(index) - 1, col_res->getData(),
+                builder);
     else
         throw Exception("Illegal type of array index", ErrorCodes::LOGICAL_ERROR);
 
     return true;
 }
 
-template <typename IndexType, typename DataType>
-bool FunctionArrayElement::executeNumber(Block & block, const ColumnNumbers & arguments, size_t result, const PaddedPODArray<IndexType> & indices,
-    ArrayImpl::NullMapBuilder & builder)
+template<typename IndexType, typename DataType>
+bool FunctionArrayElement::executeNumber(Block &block, const ColumnNumbers &arguments, size_t result,
+                                         const PaddedPODArray<IndexType> &indices,
+                                         ArrayImpl::NullMapBuilder &builder)
 {
-    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const ColumnVector<DataType> * col_nested = checkAndGetColumn<ColumnVector<DataType>>(&col_array->getData());
+    const ColumnVector<DataType> *col_nested = checkAndGetColumn<ColumnVector<DataType>>(&col_array->getData());
 
     if (!col_nested)
         return false;
@@ -769,20 +785,21 @@ bool FunctionArrayElement::executeNumber(Block & block, const ColumnNumbers & ar
     block.getByPosition(result).column = col_res;
 
     ArrayElementNumImpl<DataType>::template vector<IndexType>(
-        col_nested->getData(), col_array->getOffsets(), indices, col_res->getData(), builder);
+            col_nested->getData(), col_array->getOffsets(), indices, col_res->getData(), builder);
 
     return true;
 }
 
-bool FunctionArrayElement::executeStringConst(Block & block, const ColumnNumbers & arguments, size_t result, const Field & index,
-    ArrayImpl::NullMapBuilder & builder)
+bool FunctionArrayElement::executeStringConst(Block &block, const ColumnNumbers &arguments, size_t result,
+                                              const Field &index,
+                                              ArrayImpl::NullMapBuilder &builder)
 {
-    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const ColumnString * col_nested = checkAndGetColumn<ColumnString>(&col_array->getData());
+    const ColumnString *col_nested = checkAndGetColumn<ColumnString>(&col_array->getData());
 
     if (!col_nested)
         return false;
@@ -792,38 +809,39 @@ bool FunctionArrayElement::executeStringConst(Block & block, const ColumnNumbers
 
     if (index.getType() == Field::Types::UInt64)
         ArrayElementStringImpl::vectorConst<false>(
-            col_nested->getChars(),
-            col_array->getOffsets(),
-            col_nested->getOffsets(),
-            safeGet<UInt64>(index) - 1,
-            col_res->getChars(),
-            col_res->getOffsets(),
-            builder);
+                col_nested->getChars(),
+                col_array->getOffsets(),
+                col_nested->getOffsets(),
+                safeGet<UInt64>(index) - 1,
+                col_res->getChars(),
+                col_res->getOffsets(),
+                builder);
     else if (index.getType() == Field::Types::Int64)
         ArrayElementStringImpl::vectorConst<true>(
-            col_nested->getChars(),
-            col_array->getOffsets(),
-            col_nested->getOffsets(),
-            -safeGet<Int64>(index) - 1,
-            col_res->getChars(),
-            col_res->getOffsets(),
-            builder);
+                col_nested->getChars(),
+                col_array->getOffsets(),
+                col_nested->getOffsets(),
+                -safeGet<Int64>(index) - 1,
+                col_res->getChars(),
+                col_res->getOffsets(),
+                builder);
     else
         throw Exception("Illegal type of array index", ErrorCodes::LOGICAL_ERROR);
 
     return true;
 }
 
-template <typename IndexType>
-bool FunctionArrayElement::executeString(Block & block, const ColumnNumbers & arguments, size_t result, const PaddedPODArray<IndexType> & indices,
-    ArrayImpl::NullMapBuilder & builder)
+template<typename IndexType>
+bool FunctionArrayElement::executeString(Block &block, const ColumnNumbers &arguments, size_t result,
+                                         const PaddedPODArray<IndexType> &indices,
+                                         ArrayImpl::NullMapBuilder &builder)
 {
-    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const ColumnString * col_nested = checkAndGetColumn<ColumnString>(&col_array->getData());
+    const ColumnString *col_nested = checkAndGetColumn<ColumnString>(&col_array->getData());
 
     if (!col_nested)
         return false;
@@ -832,64 +850,67 @@ bool FunctionArrayElement::executeString(Block & block, const ColumnNumbers & ar
     block.getByPosition(result).column = col_res;
 
     ArrayElementStringImpl::vector<IndexType>(
-        col_nested->getChars(),
-        col_array->getOffsets(),
-        col_nested->getOffsets(),
-        indices,
-        col_res->getChars(),
-        col_res->getOffsets(),
-        builder);
+            col_nested->getChars(),
+            col_array->getOffsets(),
+            col_nested->getOffsets(),
+            indices,
+            col_res->getChars(),
+            col_res->getOffsets(),
+            builder);
 
     return true;
 }
 
-bool FunctionArrayElement::executeGenericConst(Block & block, const ColumnNumbers & arguments, size_t result, const Field & index,
-    ArrayImpl::NullMapBuilder & builder)
+bool FunctionArrayElement::executeGenericConst(Block &block, const ColumnNumbers &arguments, size_t result,
+                                               const Field &index,
+                                               ArrayImpl::NullMapBuilder &builder)
 {
-    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const auto & col_nested = col_array->getData();
+    const auto &col_nested = col_array->getData();
     auto col_res = col_nested.cloneEmpty();
     block.getByPosition(result).column = col_res;
 
     if (index.getType() == Field::Types::UInt64)
         ArrayElementGenericImpl::vectorConst<false>(
-            col_nested, col_array->getOffsets(), safeGet<UInt64>(index) - 1, *col_res, builder);
+                col_nested, col_array->getOffsets(), safeGet<UInt64>(index) - 1, *col_res, builder);
     else if (index.getType() == Field::Types::Int64)
         ArrayElementGenericImpl::vectorConst<true>(
-            col_nested, col_array->getOffsets(), -safeGet<Int64>(index) - 1, *col_res, builder);
+                col_nested, col_array->getOffsets(), -safeGet<Int64>(index) - 1, *col_res, builder);
     else
         throw Exception("Illegal type of array index", ErrorCodes::LOGICAL_ERROR);
 
     return true;
 }
 
-template <typename IndexType>
-bool FunctionArrayElement::executeGeneric(Block & block, const ColumnNumbers & arguments, size_t result, const PaddedPODArray<IndexType> & indices,
-    ArrayImpl::NullMapBuilder & builder)
+template<typename IndexType>
+bool FunctionArrayElement::executeGeneric(Block &block, const ColumnNumbers &arguments, size_t result,
+                                          const PaddedPODArray<IndexType> &indices,
+                                          ArrayImpl::NullMapBuilder &builder)
 {
-    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const auto & col_nested = col_array->getData();
+    const auto &col_nested = col_array->getData();
     auto col_res = col_nested.cloneEmpty();
     block.getByPosition(result).column = col_res;
 
     ArrayElementGenericImpl::vector<IndexType>(
-        col_nested, col_array->getOffsets(), indices, *col_res, builder);
+            col_nested, col_array->getOffsets(), indices, *col_res, builder);
 
     return true;
 }
 
-bool FunctionArrayElement::executeConstConst(Block & block, const ColumnNumbers & arguments, size_t result, const Field & index,
-    ArrayImpl::NullMapBuilder & builder)
+bool
+FunctionArrayElement::executeConstConst(Block &block, const ColumnNumbers &arguments, size_t result, const Field &index,
+                                        ArrayImpl::NullMapBuilder &builder)
 {
-    const ColumnConst * col_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnConst *col_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
@@ -913,8 +934,8 @@ bool FunctionArrayElement::executeConstConst(Block & block, const ColumnNumbers
         value = block.getByPosition(result).type->getDefault();
 
     block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(
-        block.rows(),
-        value);
+            block.rows(),
+            value);
 
     if (builder)
         builder.update(real_index);
@@ -922,11 +943,12 @@ bool FunctionArrayElement::executeConstConst(Block & block, const ColumnNumbers
     return true;
 }
 
-template <typename IndexType>
-bool FunctionArrayElement::executeConst(Block & block, const ColumnNumbers & arguments, size_t result, const PaddedPODArray<IndexType> & indices,
-    ArrayImpl::NullMapBuilder & builder)
+template<typename IndexType>
+bool FunctionArrayElement::executeConst(Block &block, const ColumnNumbers &arguments, size_t result,
+                                        const PaddedPODArray<IndexType> &indices,
+                                        ArrayImpl::NullMapBuilder &builder)
 {
-    const ColumnConst * col_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnConst *col_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
@@ -964,52 +986,52 @@ bool FunctionArrayElement::executeConst(Block & block, const ColumnNumbers & arg
     return true;
 }
 
-template <typename IndexType>
-bool FunctionArrayElement::executeArgument(Block & block, const ColumnNumbers & arguments, size_t result,
-    ArrayImpl::NullMapBuilder & builder)
+template<typename IndexType>
+bool FunctionArrayElement::executeArgument(Block &block, const ColumnNumbers &arguments, size_t result,
+                                           ArrayImpl::NullMapBuilder &builder)
 {
     auto index = checkAndGetColumn<ColumnVector<IndexType>>(block.getByPosition(arguments[1]).column.get());
 
     if (!index)
         return false;
 
-    const auto & index_data = index->getData();
+    const auto &index_data = index->getData();
 
     if (builder)
         builder.initSink(index_data.size());
 
-    if (!(    executeNumber<IndexType, UInt8>        (block, arguments, result, index_data, builder)
-        ||    executeNumber<IndexType, UInt16>    (block, arguments, result, index_data, builder)
-        ||    executeNumber<IndexType, UInt32>    (block, arguments, result, index_data, builder)
-        ||    executeNumber<IndexType, UInt64>    (block, arguments, result, index_data, builder)
-        ||    executeNumber<IndexType, Int8>        (block, arguments, result, index_data, builder)
-        ||    executeNumber<IndexType, Int16>        (block, arguments, result, index_data, builder)
-        ||    executeNumber<IndexType, Int32>        (block, arguments, result, index_data, builder)
-        ||    executeNumber<IndexType, Int64>        (block, arguments, result, index_data, builder)
-        ||    executeNumber<IndexType, Float32>    (block, arguments, result, index_data, builder)
-        ||    executeNumber<IndexType, Float64>    (block, arguments, result, index_data, builder)
-        ||    executeConst <IndexType>            (block, arguments, result, index_data, builder)
-        ||    executeString<IndexType>            (block, arguments, result, index_data, builder)
-        ||    executeGeneric<IndexType>            (block, arguments, result, index_data, builder)))
-    throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                + " of first argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
+    if (!(executeNumber<IndexType, UInt8>(block, arguments, result, index_data, builder)
+          || executeNumber<IndexType, UInt16>(block, arguments, result, index_data, builder)
+          || executeNumber<IndexType, UInt32>(block, arguments, result, index_data, builder)
+          || executeNumber<IndexType, UInt64>(block, arguments, result, index_data, builder)
+          || executeNumber<IndexType, Int8>(block, arguments, result, index_data, builder)
+          || executeNumber<IndexType, Int16>(block, arguments, result, index_data, builder)
+          || executeNumber<IndexType, Int32>(block, arguments, result, index_data, builder)
+          || executeNumber<IndexType, Int64>(block, arguments, result, index_data, builder)
+          || executeNumber<IndexType, Float32>(block, arguments, result, index_data, builder)
+          || executeNumber<IndexType, Float64>(block, arguments, result, index_data, builder)
+          || executeConst<IndexType>(block, arguments, result, index_data, builder)
+          || executeString<IndexType>(block, arguments, result, index_data, builder)
+          || executeGeneric<IndexType>(block, arguments, result, index_data, builder)))
+        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
+                        + " of first argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
 
     return true;
 }
 
-bool FunctionArrayElement::executeTuple(Block & block, const ColumnNumbers & arguments, size_t result)
+bool FunctionArrayElement::executeTuple(Block &block, const ColumnNumbers &arguments, size_t result)
 {
-    ColumnArray * col_array = typeid_cast<ColumnArray *>(block.getByPosition(arguments[0]).column.get());
+    ColumnArray *col_array = typeid_cast<ColumnArray *>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    ColumnTuple * col_nested = typeid_cast<ColumnTuple *>(&col_array->getData());
+    ColumnTuple *col_nested = typeid_cast<ColumnTuple *>(&col_array->getData());
 
     if (!col_nested)
         return false;
 
-    Block & tuple_block = col_nested->getData();
+    Block &tuple_block = col_nested->getData();
     size_t tuple_size = tuple_block.columns();
 
     /** We will calculate the function for the tuple of the internals of the array.
@@ -1032,9 +1054,9 @@ bool FunctionArrayElement::executeTuple(Block & block, const ColumnNumbers & arg
     {
         ColumnWithTypeAndName array_of_tuple_section;
         array_of_tuple_section.column = std::make_shared<ColumnArray>(
-            tuple_block.getByPosition(i).column, col_array->getOffsetsColumn());
+                tuple_block.getByPosition(i).column, col_array->getOffsetsColumn());
         array_of_tuple_section.type = std::make_shared<DataTypeArray>(
-            tuple_block.getByPosition(i).type);
+                tuple_block.getByPosition(i).type);
         block_of_temporary_results.insert(array_of_tuple_section);
 
         ColumnWithTypeAndName array_elements_of_tuple_section;
@@ -1056,26 +1078,28 @@ String FunctionArrayElement::getName() const
     return name;
 }
 
-DataTypePtr FunctionArrayElement::getReturnTypeImpl(const DataTypes & arguments) const
+DataTypePtr FunctionArrayElement::getReturnTypeImpl(const DataTypes &arguments) const
 {
-    const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
+    const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
     if (!array_type)
-        throw Exception("First argument for function " + getName() + " must be array.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+        throw Exception("First argument for function " + getName() + " must be array.",
+                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     if (!arguments[1]->isNumeric()
         || (!startsWith(arguments[1]->getName(), "UInt") && !startsWith(arguments[1]->getName(), "Int")))
-        throw Exception("Second argument for function " + getName() + " must have UInt or Int type.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+        throw Exception("Second argument for function " + getName() + " must have UInt or Int type.",
+                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     return array_type->getNestedType();
 }
 
-void FunctionArrayElement::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+void FunctionArrayElement::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
 {
     /// Check nullability.
     bool is_nullable;
 
-    const ColumnArray * col_array = nullptr;
-    const ColumnConst * col_const_array = nullptr;
+    const ColumnArray *col_array = nullptr;
+    const ColumnConst *col_const_array = nullptr;
 
     col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
     if (col_array)
@@ -1086,11 +1110,12 @@ void FunctionArrayElement::executeImpl(Block & block, const ColumnNumbers & argu
         if (col_const_array)
         {
             Array arr = col_const_array->getValue<Array>();
-            is_nullable = std::any_of(arr.begin(), arr.end(), [](const Field & f){ return f.isNull(); });
+            is_nullable = std::any_of(arr.begin(), arr.end(), [](const Field &f)
+            { return f.isNull(); });
         }
         else
             throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-            + " of first argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
+                            + " of first argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
     }
 
     if (!is_nullable)
@@ -1104,30 +1129,32 @@ void FunctionArrayElement::executeImpl(Block & block, const ColumnNumbers & argu
         ArrayImpl::NullMapBuilder builder;
         Block source_block;
 
-        const auto & input_type = static_cast<const DataTypeNullable &>(*block.getByPosition(arguments[0]).type).getNestedType();
-        const auto & tmp_ret_type = static_cast<const DataTypeNullable &>(*block.getByPosition(result).type).getNestedType();
+        const auto &input_type = static_cast<const DataTypeNullable &>(*block.getByPosition(
+                arguments[0]).type).getNestedType();
+        const auto &tmp_ret_type = static_cast<const DataTypeNullable &>(*block.getByPosition(
+                result).type).getNestedType();
 
         Array const_array;
         if (col_array)
         {
-            const auto & nullable_col = static_cast<const ColumnNullable &>(col_array->getData());
-            const auto & nested_col = nullable_col.getNestedColumn();
+            const auto &nullable_col = static_cast<const ColumnNullable &>(col_array->getData());
+            const auto &nested_col = nullable_col.getNestedColumn();
 
             /// Put nested_col inside a ColumnArray.
             source_block =
-            {
-                {
-                    std::make_shared<ColumnArray>(nested_col, col_array->getOffsetsColumn()),
-                    std::make_shared<DataTypeArray>(input_type),
-                    ""
-                },
-                block.getByPosition(arguments[1]),
-                {
-                    nullptr,
-                    tmp_ret_type,
-                    ""
-                }
-            };
+                    {
+                            {
+                                    std::make_shared<ColumnArray>(nested_col, col_array->getOffsetsColumn()),
+                                    std::make_shared<DataTypeArray>(input_type),
+                                    ""
+                            },
+                            block.getByPosition(arguments[1]),
+                            {
+                                    nullptr,
+                                    tmp_ret_type,
+                                    ""
+                            }
+                    };
 
             builder.initSource(nullable_col);
         }
@@ -1135,15 +1162,15 @@ void FunctionArrayElement::executeImpl(Block & block, const ColumnNumbers & argu
         {
             /// Almost a copy of block.
             source_block =
-            {
-                block.getByPosition(arguments[0]),
-                block.getByPosition(arguments[1]),
-                {
-                    nullptr,
-                    tmp_ret_type,
-                    ""
-                }
-            };
+                    {
+                            block.getByPosition(arguments[0]),
+                            block.getByPosition(arguments[1]),
+                            {
+                                    nullptr,
+                                    tmp_ret_type,
+                                    ""
+                            }
+                    };
 
             const_array = col_const_array->getValue<Array>();
             builder.initSource(const_array);
@@ -1152,30 +1179,30 @@ void FunctionArrayElement::executeImpl(Block & block, const ColumnNumbers & argu
         perform(source_block, {0, 1}, 2, builder);
 
         /// Store the result.
-        const ColumnWithTypeAndName & source_col = source_block.getByPosition(2);
-        ColumnWithTypeAndName & dest_col = block.getByPosition(result);
+        const ColumnWithTypeAndName &source_col = source_block.getByPosition(2);
+        ColumnWithTypeAndName &dest_col = block.getByPosition(result);
         dest_col.column = std::make_shared<ColumnNullable>(source_col.column, builder.getNullMap());
     }
 }
 
-void FunctionArrayElement::perform(Block & block, const ColumnNumbers & arguments, size_t result,
-    ArrayImpl::NullMapBuilder & builder)
+void FunctionArrayElement::perform(Block &block, const ColumnNumbers &arguments, size_t result,
+                                   ArrayImpl::NullMapBuilder &builder)
 {
     if (executeTuple(block, arguments, result))
     {
     }
     else if (!block.getByPosition(arguments[1]).column->isConst())
     {
-        if (!(    executeArgument<UInt8>   (block, arguments, result, builder)
-            ||    executeArgument<UInt16>  (block, arguments, result, builder)
-            ||    executeArgument<UInt32>  (block, arguments, result, builder)
-            ||    executeArgument<UInt64>  (block, arguments, result, builder)
-            ||    executeArgument<Int8>    (block, arguments, result, builder)
-            ||    executeArgument<Int16>   (block, arguments, result, builder)
-            ||    executeArgument<Int32>   (block, arguments, result, builder)
-            ||    executeArgument<Int64>   (block, arguments, result, builder)))
-        throw Exception("Second argument for function " + getName() + " must must have UInt or Int type.",
-                        ErrorCodes::ILLEGAL_COLUMN);
+        if (!(executeArgument<UInt8>(block, arguments, result, builder)
+              || executeArgument<UInt16>(block, arguments, result, builder)
+              || executeArgument<UInt32>(block, arguments, result, builder)
+              || executeArgument<UInt64>(block, arguments, result, builder)
+              || executeArgument<Int8>(block, arguments, result, builder)
+              || executeArgument<Int16>(block, arguments, result, builder)
+              || executeArgument<Int32>(block, arguments, result, builder)
+              || executeArgument<Int64>(block, arguments, result, builder)))
+            throw Exception("Second argument for function " + getName() + " must must have UInt or Int type.",
+                            ErrorCodes::ILLEGAL_COLUMN);
     }
     else
     {
@@ -1187,28 +1214,28 @@ void FunctionArrayElement::perform(Block & block, const ColumnNumbers & argument
         if (index == UInt64(0))
             throw Exception("Array indices is 1-based", ErrorCodes::ZERO_ARRAY_OR_TUPLE_INDEX);
 
-        if (!(    executeNumberConst<UInt8>   (block, arguments, result, index, builder)
-            ||    executeNumberConst<UInt16>  (block, arguments, result, index, builder)
-            ||    executeNumberConst<UInt32>  (block, arguments, result, index, builder)
-            ||    executeNumberConst<UInt64>  (block, arguments, result, index, builder)
-            ||    executeNumberConst<Int8>    (block, arguments, result, index, builder)
-            ||    executeNumberConst<Int16>   (block, arguments, result, index, builder)
-            ||    executeNumberConst<Int32>   (block, arguments, result, index, builder)
-            ||    executeNumberConst<Int64>   (block, arguments, result, index, builder)
-            ||    executeNumberConst<Float32> (block, arguments, result, index, builder)
-            ||    executeNumberConst<Float64> (block, arguments, result, index, builder)
-            ||    executeConstConst           (block, arguments, result, index, builder)
-            ||    executeStringConst          (block, arguments, result, index, builder)
-            ||    executeGenericConst         (block, arguments, result, index, builder)))
-        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-            + " of first argument of function " + getName(),
-            ErrorCodes::ILLEGAL_COLUMN);
+        if (!(executeNumberConst<UInt8>(block, arguments, result, index, builder)
+              || executeNumberConst<UInt16>(block, arguments, result, index, builder)
+              || executeNumberConst<UInt32>(block, arguments, result, index, builder)
+              || executeNumberConst<UInt64>(block, arguments, result, index, builder)
+              || executeNumberConst<Int8>(block, arguments, result, index, builder)
+              || executeNumberConst<Int16>(block, arguments, result, index, builder)
+              || executeNumberConst<Int32>(block, arguments, result, index, builder)
+              || executeNumberConst<Int64>(block, arguments, result, index, builder)
+              || executeNumberConst<Float32>(block, arguments, result, index, builder)
+              || executeNumberConst<Float64>(block, arguments, result, index, builder)
+              || executeConstConst(block, arguments, result, index, builder)
+              || executeStringConst(block, arguments, result, index, builder)
+              || executeGenericConst(block, arguments, result, index, builder)))
+            throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
+                            + " of first argument of function " + getName(),
+                            ErrorCodes::ILLEGAL_COLUMN);
     }
 }
 
 /// Implementation of FunctionArrayEnumerate.
 
-FunctionPtr FunctionArrayEnumerate::create(const Context & context)
+FunctionPtr FunctionArrayEnumerate::create(const Context &context)
 {
     return std::make_shared<FunctionArrayEnumerate>();
 }
@@ -1218,27 +1245,27 @@ String FunctionArrayEnumerate::getName() const
     return name;
 }
 
-DataTypePtr FunctionArrayEnumerate::getReturnTypeImpl(const DataTypes & arguments) const
+DataTypePtr FunctionArrayEnumerate::getReturnTypeImpl(const DataTypes &arguments) const
 {
-    const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
+    const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
     if (!array_type)
         throw Exception("First argument for function " + getName() + " must be an array but it has type "
-            + arguments[0]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                        + arguments[0]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     return std::make_shared<DataTypeArray>(std::make_shared<DataTypeUInt32>());
 }
 
-void FunctionArrayEnumerate::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+void FunctionArrayEnumerate::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
 {
-    if (const ColumnArray * array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get()))
+    if (const ColumnArray *array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get()))
     {
-        const ColumnArray::Offsets_t & offsets = array->getOffsets();
+        const ColumnArray::Offsets_t &offsets = array->getOffsets();
 
         auto res_nested = std::make_shared<ColumnUInt32>();
         auto res_array = std::make_shared<ColumnArray>(res_nested, array->getOffsetsColumn());
         block.getByPosition(result).column = res_array;
 
-        ColumnUInt32::Container_t & res_values = res_nested->getData();
+        ColumnUInt32::Container_t &res_values = res_nested->getData();
         res_values.resize(array->getData().size());
         size_t prev_off = 0;
         for (size_t i = 0; i < offsets.size(); ++i)
@@ -1251,7 +1278,8 @@ void FunctionArrayEnumerate::executeImpl(Block & block, const ColumnNumbers & ar
             prev_off = off;
         }
     }
-    else if (const ColumnConst * array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get()))
+    else if (const ColumnConst *array = checkAndGetColumnConst<ColumnArray>(
+            block.getByPosition(arguments[0]).column.get()))
     {
         Array values = array->getValue<Array>();
 
@@ -1261,50 +1289,53 @@ void FunctionArrayEnumerate::executeImpl(Block & block, const ColumnNumbers & ar
             res_values[i] = i + 1;
         }
 
-        block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(array->size(), res_values);
+        block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(array->size(),
+                                                                                                 res_values);
     }
     else
     {
         throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                + " of first argument of function " + getName(),
-            ErrorCodes::ILLEGAL_COLUMN);
+                        + " of first argument of function " + getName(),
+                        ErrorCodes::ILLEGAL_COLUMN);
     }
 }
 
 /// Implementation of FunctionArrayUniq.
 
-FunctionPtr FunctionArrayUniq::create(const Context & context) { return std::make_shared<FunctionArrayUniq>(); }
+FunctionPtr FunctionArrayUniq::create(const Context &context)
+{ return std::make_shared<FunctionArrayUniq>(); }
 
 String FunctionArrayUniq::getName() const
 {
     return name;
 }
 
-DataTypePtr FunctionArrayUniq::getReturnTypeImpl(const DataTypes & arguments) const
+DataTypePtr FunctionArrayUniq::getReturnTypeImpl(const DataTypes &arguments) const
 {
     if (arguments.size() == 0)
         throw Exception("Number of arguments for function " + getName() + " doesn't match: passed "
-            + toString(arguments.size()) + ", should be at least 1.",
-            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+                        + toString(arguments.size()) + ", should be at least 1.",
+                        ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
     for (size_t i = 0; i < arguments.size(); ++i)
     {
-        const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[i].get());
+        const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[i].get());
         if (!array_type)
             throw Exception("All arguments for function " + getName() + " must be arrays but argument " +
-                toString(i + 1) + " has type " + arguments[i]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                            toString(i + 1) + " has type " + arguments[i]->getName() + ".",
+                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
     }
 
     return std::make_shared<DataTypeUInt32>();
 }
 
-void FunctionArrayUniq::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+void FunctionArrayUniq::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
 {
     if (arguments.size() == 1 && executeConst(block, arguments, result))
         return;
 
     Columns array_columns(arguments.size());
-    const ColumnArray::Offsets_t * offsets = nullptr;
+    const ColumnArray::Offsets_t *offsets = nullptr;
     ConstColumnPlainPtrs data_columns(arguments.size());
     ConstColumnPlainPtrs original_data_columns(arguments.size());
     ConstColumnPlainPtrs null_maps(arguments.size());
@@ -1314,27 +1345,28 @@ void FunctionArrayUniq::executeImpl(Block & block, const ColumnNumbers & argumen
     for (size_t i = 0; i < arguments.size(); ++i)
     {
         ColumnPtr array_ptr = block.getByPosition(arguments[i]).column;
-        const ColumnArray * array = checkAndGetColumn<ColumnArray>(array_ptr.get());
+        const ColumnArray *array = checkAndGetColumn<ColumnArray>(array_ptr.get());
         if (!array)
         {
-            const ColumnConst * const_array = checkAndGetColumnConst<ColumnArray>(
-                block.getByPosition(arguments[i]).column.get());
+            const ColumnConst *const_array = checkAndGetColumnConst<ColumnArray>(
+                    block.getByPosition(arguments[i]).column.get());
             if (!const_array)
                 throw Exception("Illegal column " + block.getByPosition(arguments[i]).column->getName()
-                    + " of " + toString(i + 1) + getOrdinalSuffix(i + 1) + " argument of function " + getName(),
-                    ErrorCodes::ILLEGAL_COLUMN);
+                                + " of " + toString(i + 1) + getOrdinalSuffix(i + 1) + " argument of function " +
+                                getName(),
+                                ErrorCodes::ILLEGAL_COLUMN);
             array_ptr = const_array->convertToFullColumn();
             array = static_cast<const ColumnArray *>(array_ptr.get());
         }
 
         array_columns[i] = array_ptr;
 
-        const ColumnArray::Offsets_t & offsets_i = array->getOffsets();
+        const ColumnArray::Offsets_t &offsets_i = array->getOffsets();
         if (i == 0)
             offsets = &offsets_i;
         else if (offsets_i != *offsets)
             throw Exception("Lengths of all arrays passsed to " + getName() + " must be equal.",
-                ErrorCodes::SIZES_OF_ARRAYS_DOESNT_MATCH);
+                            ErrorCodes::SIZES_OF_ARRAYS_DOESNT_MATCH);
 
         data_columns[i] = &array->getData();
         original_data_columns[i] = data_columns[i];
@@ -1342,7 +1374,7 @@ void FunctionArrayUniq::executeImpl(Block & block, const ColumnNumbers & argumen
         if (data_columns[i]->isNullable())
         {
             has_nullable_columns = true;
-            const auto & nullable_col = static_cast<const ColumnNullable &>(*data_columns[i]);
+            const auto &nullable_col = static_cast<const ColumnNullable &>(*data_columns[i]);
             data_columns[i] = nullable_col.getNestedColumn().get();
             null_maps[i] = nullable_col.getNullMapColumn().get();
         }
@@ -1350,30 +1382,30 @@ void FunctionArrayUniq::executeImpl(Block & block, const ColumnNumbers & argumen
             null_maps[i] = nullptr;
     }
 
-    const ColumnArray * first_array = static_cast<const ColumnArray *>(array_columns[0].get());
-    const IColumn * first_null_map = null_maps[0];
+    const ColumnArray *first_array = static_cast<const ColumnArray *>(array_columns[0].get());
+    const IColumn *first_null_map = null_maps[0];
     auto res = std::make_shared<ColumnUInt32>();
     block.getByPosition(result).column = res;
 
-    ColumnUInt32::Container_t & res_values = res->getData();
+    ColumnUInt32::Container_t &res_values = res->getData();
     res_values.resize(offsets->size());
 
     if (arguments.size() == 1)
     {
-        if (!(    executeNumber<UInt8>    (first_array, first_null_map, res_values)
-            ||    executeNumber<UInt16>    (first_array, first_null_map, res_values)
-            ||    executeNumber<UInt32>    (first_array, first_null_map, res_values)
-            ||    executeNumber<UInt64>    (first_array, first_null_map, res_values)
-            ||    executeNumber<Int8>        (first_array, first_null_map, res_values)
-            ||    executeNumber<Int16>    (first_array, first_null_map, res_values)
-            ||    executeNumber<Int32>    (first_array, first_null_map, res_values)
-            ||    executeNumber<Int64>    (first_array, first_null_map, res_values)
-            ||    executeNumber<Float32>    (first_array, first_null_map, res_values)
-            ||    executeNumber<Float64>    (first_array, first_null_map, res_values)
-            ||    executeString            (first_array, first_null_map, res_values)))
+        if (!(executeNumber<UInt8>(first_array, first_null_map, res_values)
+              || executeNumber<UInt16>(first_array, first_null_map, res_values)
+              || executeNumber<UInt32>(first_array, first_null_map, res_values)
+              || executeNumber<UInt64>(first_array, first_null_map, res_values)
+              || executeNumber<Int8>(first_array, first_null_map, res_values)
+              || executeNumber<Int16>(first_array, first_null_map, res_values)
+              || executeNumber<Int32>(first_array, first_null_map, res_values)
+              || executeNumber<Int64>(first_array, first_null_map, res_values)
+              || executeNumber<Float32>(first_array, first_null_map, res_values)
+              || executeNumber<Float64>(first_array, first_null_map, res_values)
+              || executeString(first_array, first_null_map, res_values)))
             throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                    + " of first argument of function " + getName(),
-                ErrorCodes::ILLEGAL_COLUMN);
+                            + " of first argument of function " + getName(),
+                            ErrorCodes::ILLEGAL_COLUMN);
     }
     else
     {
@@ -1382,30 +1414,31 @@ void FunctionArrayUniq::executeImpl(Block & block, const ColumnNumbers & argumen
     }
 }
 
-template <typename T>
-bool FunctionArrayUniq::executeNumber(const ColumnArray * array, const IColumn * null_map, ColumnUInt32::Container_t & res_values)
+template<typename T>
+bool FunctionArrayUniq::executeNumber(const ColumnArray *array, const IColumn *null_map,
+                                      ColumnUInt32::Container_t &res_values)
 {
-    const IColumn * inner_col;
+    const IColumn *inner_col;
 
-    const auto & array_data = array->getData();
+    const auto &array_data = array->getData();
     if (array_data.isNullable())
     {
-        const auto & nullable_col = static_cast<const ColumnNullable &>(array_data);
+        const auto &nullable_col = static_cast<const ColumnNullable &>(array_data);
         inner_col = nullable_col.getNestedColumn().get();
     }
     else
         inner_col = &array_data;
 
-    const ColumnVector<T> * nested = checkAndGetColumn<ColumnVector<T>>(inner_col);
+    const ColumnVector<T> *nested = checkAndGetColumn<ColumnVector<T>>(inner_col);
     if (!nested)
         return false;
-    const ColumnArray::Offsets_t & offsets = array->getOffsets();
-    const typename ColumnVector<T>::Container_t & values = nested->getData();
+    const ColumnArray::Offsets_t &offsets = array->getOffsets();
+    const typename ColumnVector<T>::Container_t &values = nested->getData();
 
     using Set = ClearableHashSet<T, DefaultHash<T>, HashTableGrower<INITIAL_SIZE_DEGREE>,
-        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(T)>>;
+            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(T)>>;
 
-    const PaddedPODArray<UInt8> * null_map_data = nullptr;
+    const PaddedPODArray<UInt8> *null_map_data = nullptr;
     if (null_map)
         null_map_data = &static_cast<const ColumnUInt8 *>(null_map)->getData();
 
@@ -1430,28 +1463,29 @@ bool FunctionArrayUniq::executeNumber(const ColumnArray * array, const IColumn *
     return true;
 }
 
-bool FunctionArrayUniq::executeString(const ColumnArray * array, const IColumn * null_map, ColumnUInt32::Container_t & res_values)
+bool FunctionArrayUniq::executeString(const ColumnArray *array, const IColumn *null_map,
+                                      ColumnUInt32::Container_t &res_values)
 {
-    const IColumn * inner_col;
+    const IColumn *inner_col;
 
-    const auto & array_data = array->getData();
+    const auto &array_data = array->getData();
     if (array_data.isNullable())
     {
-        const auto & nullable_col = static_cast<const ColumnNullable &>(array_data);
+        const auto &nullable_col = static_cast<const ColumnNullable &>(array_data);
         inner_col = nullable_col.getNestedColumn().get();
     }
     else
         inner_col = &array_data;
 
-    const ColumnString * nested = checkAndGetColumn<ColumnString>(inner_col);
+    const ColumnString *nested = checkAndGetColumn<ColumnString>(inner_col);
     if (!nested)
         return false;
-    const ColumnArray::Offsets_t & offsets = array->getOffsets();
+    const ColumnArray::Offsets_t &offsets = array->getOffsets();
 
     using Set = ClearableHashSet<StringRef, StringRefHash, HashTableGrower<INITIAL_SIZE_DEGREE>,
-        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(StringRef)>>;
+            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(StringRef)>>;
 
-    const PaddedPODArray<UInt8> * null_map_data = nullptr;
+    const PaddedPODArray<UInt8> *null_map_data = nullptr;
     if (null_map)
         null_map_data = &static_cast<const ColumnUInt8 *>(null_map)->getData();
 
@@ -1476,9 +1510,9 @@ bool FunctionArrayUniq::executeString(const ColumnArray * array, const IColumn *
     return true;
 }
 
-bool FunctionArrayUniq::executeConst(Block & block, const ColumnNumbers & arguments, size_t result)
+bool FunctionArrayUniq::executeConst(Block &block, const ColumnNumbers &arguments, size_t result)
 {
-    const ColumnConst * array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnConst *array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
     if (!array)
         return false;
     Array values = array->getValue<Array>();
@@ -1492,11 +1526,11 @@ bool FunctionArrayUniq::executeConst(Block & block, const ColumnNumbers & argume
 }
 
 bool FunctionArrayUniq::execute128bit(
-    const ColumnArray::Offsets_t & offsets,
-    const ConstColumnPlainPtrs & columns,
-    const ConstColumnPlainPtrs & null_maps,
-    ColumnUInt32::Container_t & res_values,
-    bool has_nullable_columns)
+        const ColumnArray::Offsets_t &offsets,
+        const ConstColumnPlainPtrs &columns,
+        const ConstColumnPlainPtrs &null_maps,
+        ColumnUInt32::Container_t &res_values,
+        bool has_nullable_columns)
 {
     size_t count = columns.size();
     size_t keys_bytes = 0;
@@ -1516,7 +1550,7 @@ bool FunctionArrayUniq::execute128bit(
         return false;
 
     using Set = ClearableHashSet<UInt128, UInt128HashCRC32, HashTableGrower<INITIAL_SIZE_DEGREE>,
-        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
+            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
 
     /// Suppose that, for a given row, each of the N columns has an array whose length is M.
     /// Denote arr_i each of these arrays (1 <= i <= N). Then the following is performed:
@@ -1547,7 +1581,7 @@ bool FunctionArrayUniq::execute128bit(
                 {
                     if (null_maps[i])
                     {
-                        const auto & null_map = static_cast<const ColumnUInt8 &>(*null_maps[i]).getData();
+                        const auto &null_map = static_cast<const ColumnUInt8 &>(*null_maps[i]).getData();
                         if (null_map[j] == 1)
                         {
                             size_t bucket = i / 8;
@@ -1570,14 +1604,14 @@ bool FunctionArrayUniq::execute128bit(
 }
 
 void FunctionArrayUniq::executeHashed(
-    const ColumnArray::Offsets_t & offsets,
-    const ConstColumnPlainPtrs & columns,
-    ColumnUInt32::Container_t & res_values)
+        const ColumnArray::Offsets_t &offsets,
+        const ConstColumnPlainPtrs &columns,
+        ColumnUInt32::Container_t &res_values)
 {
     size_t count = columns.size();
 
     using Set = ClearableHashSet<UInt128, UInt128TrivialHash, HashTableGrower<INITIAL_SIZE_DEGREE>,
-        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
+            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
 
     Set set;
     size_t prev_off = 0;
@@ -1595,7 +1629,7 @@ void FunctionArrayUniq::executeHashed(
 
 /// Implementation of FunctionArrayEnumerateUniq.
 
-FunctionPtr FunctionArrayEnumerateUniq::create(const Context & context)
+FunctionPtr FunctionArrayEnumerateUniq::create(const Context &context)
 {
     return std::make_shared<FunctionArrayEnumerateUniq>();
 }
@@ -1605,31 +1639,32 @@ String FunctionArrayEnumerateUniq::getName() const
     return name;
 }
 
-DataTypePtr FunctionArrayEnumerateUniq::getReturnTypeImpl(const DataTypes & arguments) const
+DataTypePtr FunctionArrayEnumerateUniq::getReturnTypeImpl(const DataTypes &arguments) const
 {
     if (arguments.size() == 0)
         throw Exception("Number of arguments for function " + getName() + " doesn't match: passed "
-            + toString(arguments.size()) + ", should be at least 1.",
-            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+                        + toString(arguments.size()) + ", should be at least 1.",
+                        ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
     for (size_t i = 0; i < arguments.size(); ++i)
     {
-        const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[i].get());
+        const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[i].get());
         if (!array_type)
             throw Exception("All arguments for function " + getName() + " must be arrays but argument " +
-                toString(i + 1) + " has type " + arguments[i]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                            toString(i + 1) + " has type " + arguments[i]->getName() + ".",
+                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
     }
 
     return std::make_shared<DataTypeArray>(std::make_shared<DataTypeUInt32>());
 }
 
-void FunctionArrayEnumerateUniq::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+void FunctionArrayEnumerateUniq::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
 {
     if (arguments.size() == 1 && executeConst(block, arguments, result))
         return;
 
     Columns array_columns(arguments.size());
-    const ColumnArray::Offsets_t * offsets = nullptr;
+    const ColumnArray::Offsets_t *offsets = nullptr;
     ConstColumnPlainPtrs data_columns(arguments.size());
     ConstColumnPlainPtrs original_data_columns(arguments.size());
     ConstColumnPlainPtrs null_maps(arguments.size());
@@ -1639,25 +1674,25 @@ void FunctionArrayEnumerateUniq::executeImpl(Block & block, const ColumnNumbers
     for (size_t i = 0; i < arguments.size(); ++i)
     {
         ColumnPtr array_ptr = block.getByPosition(arguments[i]).column;
-        const ColumnArray * array = checkAndGetColumn<ColumnArray>(array_ptr.get());
+        const ColumnArray *array = checkAndGetColumn<ColumnArray>(array_ptr.get());
         if (!array)
         {
-            const ColumnConst * const_array = checkAndGetColumnConst<ColumnArray>(
-                block.getByPosition(arguments[i]).column.get());
+            const ColumnConst *const_array = checkAndGetColumnConst<ColumnArray>(
+                    block.getByPosition(arguments[i]).column.get());
             if (!const_array)
                 throw Exception("Illegal column " + block.getByPosition(arguments[i]).column->getName()
-                    + " of " + toString(i + 1) + "-th argument of function " + getName(),
-                    ErrorCodes::ILLEGAL_COLUMN);
+                                + " of " + toString(i + 1) + "-th argument of function " + getName(),
+                                ErrorCodes::ILLEGAL_COLUMN);
             array_ptr = const_array->convertToFullColumn();
             array = checkAndGetColumn<ColumnArray>(array_ptr.get());
         }
         array_columns[i] = array_ptr;
-        const ColumnArray::Offsets_t & offsets_i = array->getOffsets();
+        const ColumnArray::Offsets_t &offsets_i = array->getOffsets();
         if (i == 0)
             offsets = &offsets_i;
         else if (offsets_i != *offsets)
             throw Exception("Lengths of all arrays passsed to " + getName() + " must be equal.",
-                ErrorCodes::SIZES_OF_ARRAYS_DOESNT_MATCH);
+                            ErrorCodes::SIZES_OF_ARRAYS_DOESNT_MATCH);
 
         data_columns[i] = &array->getData();
         original_data_columns[i] = data_columns[i];
@@ -1665,7 +1700,7 @@ void FunctionArrayEnumerateUniq::executeImpl(Block & block, const ColumnNumbers
         if (data_columns[i]->isNullable())
         {
             has_nullable_columns = true;
-            const auto & nullable_col = static_cast<const ColumnNullable &>(*data_columns[i]);
+            const auto &nullable_col = static_cast<const ColumnNullable &>(*data_columns[i]);
             data_columns[i] = nullable_col.getNestedColumn().get();
             null_maps[i] = nullable_col.getNullMapColumn().get();
         }
@@ -1673,32 +1708,32 @@ void FunctionArrayEnumerateUniq::executeImpl(Block & block, const ColumnNumbers
             null_maps[i] = nullptr;
     }
 
-    const ColumnArray * first_array = checkAndGetColumn<ColumnArray>(array_columns[0].get());
-    const IColumn * first_null_map = null_maps[0];
+    const ColumnArray *first_array = checkAndGetColumn<ColumnArray>(array_columns[0].get());
+    const IColumn *first_null_map = null_maps[0];
     auto res_nested = std::make_shared<ColumnUInt32>();
     auto res_array = std::make_shared<ColumnArray>(res_nested, first_array->getOffsetsColumn());
     block.getByPosition(result).column = res_array;
 
-    ColumnUInt32::Container_t & res_values = res_nested->getData();
+    ColumnUInt32::Container_t &res_values = res_nested->getData();
     if (!offsets->empty())
         res_values.resize(offsets->back());
 
     if (arguments.size() == 1)
     {
-        if (!(    executeNumber<UInt8>    (first_array, first_null_map, res_values)
-            ||    executeNumber<UInt16>    (first_array, first_null_map, res_values)
-            ||    executeNumber<UInt32>    (first_array, first_null_map, res_values)
-            ||    executeNumber<UInt64>    (first_array, first_null_map, res_values)
-            ||    executeNumber<Int8>        (first_array, first_null_map, res_values)
-            ||    executeNumber<Int16>    (first_array, first_null_map, res_values)
-            ||    executeNumber<Int32>    (first_array, first_null_map, res_values)
-            ||    executeNumber<Int64>    (first_array, first_null_map, res_values)
-            ||    executeNumber<Float32>    (first_array, first_null_map, res_values)
-            ||    executeNumber<Float64>    (first_array, first_null_map, res_values)
-            ||    executeString            (first_array, first_null_map, res_values)))
+        if (!(executeNumber<UInt8>(first_array, first_null_map, res_values)
+              || executeNumber<UInt16>(first_array, first_null_map, res_values)
+              || executeNumber<UInt32>(first_array, first_null_map, res_values)
+              || executeNumber<UInt64>(first_array, first_null_map, res_values)
+              || executeNumber<Int8>(first_array, first_null_map, res_values)
+              || executeNumber<Int16>(first_array, first_null_map, res_values)
+              || executeNumber<Int32>(first_array, first_null_map, res_values)
+              || executeNumber<Int64>(first_array, first_null_map, res_values)
+              || executeNumber<Float32>(first_array, first_null_map, res_values)
+              || executeNumber<Float64>(first_array, first_null_map, res_values)
+              || executeString(first_array, first_null_map, res_values)))
             throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                    + " of first argument of function " + getName(),
-                ErrorCodes::ILLEGAL_COLUMN);
+                            + " of first argument of function " + getName(),
+                            ErrorCodes::ILLEGAL_COLUMN);
     }
     else
     {
@@ -1708,30 +1743,31 @@ void FunctionArrayEnumerateUniq::executeImpl(Block & block, const ColumnNumbers
 }
 
 
-template <typename T>
-bool FunctionArrayEnumerateUniq::executeNumber(const ColumnArray * array, const IColumn * null_map, ColumnUInt32::Container_t & res_values)
+template<typename T>
+bool FunctionArrayEnumerateUniq::executeNumber(const ColumnArray *array, const IColumn *null_map,
+                                               ColumnUInt32::Container_t &res_values)
 {
-    const IColumn * inner_col;
+    const IColumn *inner_col;
 
-    const auto & array_data = array->getData();
+    const auto &array_data = array->getData();
     if (array_data.isNullable())
     {
-        const auto & nullable_col = static_cast<const ColumnNullable &>(array_data);
+        const auto &nullable_col = static_cast<const ColumnNullable &>(array_data);
         inner_col = nullable_col.getNestedColumn().get();
     }
     else
         inner_col = &array_data;
 
-    const ColumnVector<T> * nested = checkAndGetColumn<ColumnVector<T>>(inner_col);
+    const ColumnVector<T> *nested = checkAndGetColumn<ColumnVector<T>>(inner_col);
     if (!nested)
         return false;
-    const ColumnArray::Offsets_t & offsets = array->getOffsets();
-    const typename ColumnVector<T>::Container_t & values = nested->getData();
+    const ColumnArray::Offsets_t &offsets = array->getOffsets();
+    const typename ColumnVector<T>::Container_t &values = nested->getData();
 
     using ValuesToIndices = ClearableHashMap<T, UInt32, DefaultHash<T>, HashTableGrower<INITIAL_SIZE_DEGREE>,
-        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(T)>>;
+            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(T)>>;
 
-    const PaddedPODArray<UInt8> * null_map_data = nullptr;
+    const PaddedPODArray<UInt8> *null_map_data = nullptr;
     if (null_map)
         null_map_data = &static_cast<const ColumnUInt8 *>(null_map)->getData();
 
@@ -1754,29 +1790,30 @@ bool FunctionArrayEnumerateUniq::executeNumber(const ColumnArray * array, const
     return true;
 }
 
-bool FunctionArrayEnumerateUniq::executeString(const ColumnArray * array, const IColumn * null_map, ColumnUInt32::Container_t & res_values)
+bool FunctionArrayEnumerateUniq::executeString(const ColumnArray *array, const IColumn *null_map,
+                                               ColumnUInt32::Container_t &res_values)
 {
-    const IColumn * inner_col;
+    const IColumn *inner_col;
 
-    const auto & array_data = array->getData();
+    const auto &array_data = array->getData();
     if (array_data.isNullable())
     {
-        const auto & nullable_col = static_cast<const ColumnNullable &>(array_data);
+        const auto &nullable_col = static_cast<const ColumnNullable &>(array_data);
         inner_col = nullable_col.getNestedColumn().get();
     }
     else
         inner_col = &array_data;
 
-    const ColumnString * nested = checkAndGetColumn<ColumnString>(inner_col);
+    const ColumnString *nested = checkAndGetColumn<ColumnString>(inner_col);
     if (!nested)
         return false;
-    const ColumnArray::Offsets_t & offsets = array->getOffsets();
+    const ColumnArray::Offsets_t &offsets = array->getOffsets();
 
     size_t prev_off = 0;
     using ValuesToIndices = ClearableHashMap<StringRef, UInt32, StringRefHash, HashTableGrower<INITIAL_SIZE_DEGREE>,
-        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(StringRef)>>;
+            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(StringRef)>>;
 
-    const PaddedPODArray<UInt8> * null_map_data = nullptr;
+    const PaddedPODArray<UInt8> *null_map_data = nullptr;
     if (null_map)
         null_map_data = &static_cast<const ColumnUInt8 *>(null_map)->getData();
 
@@ -1798,9 +1835,9 @@ bool FunctionArrayEnumerateUniq::executeString(const ColumnArray * array, const
     return true;
 }
 
-bool FunctionArrayEnumerateUniq::executeConst(Block & block, const ColumnNumbers & arguments, size_t result)
+bool FunctionArrayEnumerateUniq::executeConst(Block &block, const ColumnNumbers &arguments, size_t result)
 {
-    const ColumnConst * array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnConst *array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
     if (!array)
         return false;
     Array values = array->getValue<Array>();
@@ -1818,11 +1855,11 @@ bool FunctionArrayEnumerateUniq::executeConst(Block & block, const ColumnNumbers
 }
 
 bool FunctionArrayEnumerateUniq::execute128bit(
-    const ColumnArray::Offsets_t & offsets,
-    const ConstColumnPlainPtrs & columns,
-    const ConstColumnPlainPtrs & null_maps,
-    ColumnUInt32::Container_t & res_values,
-    bool has_nullable_columns)
+        const ColumnArray::Offsets_t &offsets,
+        const ConstColumnPlainPtrs &columns,
+        const ConstColumnPlainPtrs &null_maps,
+        ColumnUInt32::Container_t &res_values,
+        bool has_nullable_columns)
 {
     size_t count = columns.size();
     size_t keys_bytes = 0;
@@ -1842,7 +1879,7 @@ bool FunctionArrayEnumerateUniq::execute128bit(
         return false;
 
     using ValuesToIndices = ClearableHashMap<UInt128, UInt32, UInt128HashCRC32, HashTableGrower<INITIAL_SIZE_DEGREE>,
-        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
+            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
 
     ValuesToIndices indices;
     size_t prev_off = 0;
@@ -1860,7 +1897,7 @@ bool FunctionArrayEnumerateUniq::execute128bit(
                 {
                     if (null_maps[i])
                     {
-                        const auto & null_map = static_cast<const ColumnUInt8 &>(*null_maps[i]).getData();
+                        const auto &null_map = static_cast<const ColumnUInt8 &>(*null_maps[i]).getData();
                         if (null_map[j] == 1)
                         {
                             size_t bucket = i / 8;
@@ -1881,14 +1918,14 @@ bool FunctionArrayEnumerateUniq::execute128bit(
 }
 
 void FunctionArrayEnumerateUniq::executeHashed(
-    const ColumnArray::Offsets_t & offsets,
-    const ConstColumnPlainPtrs & columns,
-    ColumnUInt32::Container_t & res_values)
+        const ColumnArray::Offsets_t &offsets,
+        const ConstColumnPlainPtrs &columns,
+        ColumnUInt32::Container_t &res_values)
 {
     size_t count = columns.size();
 
     using ValuesToIndices = ClearableHashMap<UInt128, UInt32, UInt128TrivialHash, HashTableGrower<INITIAL_SIZE_DEGREE>,
-        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
+            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
 
     ValuesToIndices indices;
     size_t prev_off = 0;
@@ -1906,19 +1943,20 @@ void FunctionArrayEnumerateUniq::executeHashed(
 
 /// Implementation of FunctionEmptyArrayToSingle.
 
-FunctionPtr FunctionEmptyArrayToSingle::create(const Context & context) { return std::make_shared<FunctionEmptyArrayToSingle>(); }
+FunctionPtr FunctionEmptyArrayToSingle::create(const Context &context)
+{ return std::make_shared<FunctionEmptyArrayToSingle>(); }
 
 String FunctionEmptyArrayToSingle::getName() const
 {
     return name;
 }
 
-DataTypePtr FunctionEmptyArrayToSingle::getReturnTypeImpl(const DataTypes & arguments) const
+DataTypePtr FunctionEmptyArrayToSingle::getReturnTypeImpl(const DataTypes &arguments) const
 {
-    const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
+    const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
     if (!array_type)
         throw Exception("Argument for function " + getName() + " must be array.",
-            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     return arguments[0]->clone();
 }
@@ -1926,347 +1964,366 @@ DataTypePtr FunctionEmptyArrayToSingle::getReturnTypeImpl(const DataTypes & argu
 
 namespace
 {
-    namespace FunctionEmptyArrayToSingleImpl
+namespace FunctionEmptyArrayToSingleImpl
+{
+bool executeConst(Block &block, const ColumnNumbers &arguments, size_t result)
+{
+    if (const ColumnConst *const_array = checkAndGetColumnConst<ColumnArray>(
+            block.getByPosition(arguments[0]).column.get()))
     {
-        bool executeConst(Block & block, const ColumnNumbers & arguments, size_t result)
+        if (const_array->getValue<Array>().empty())
         {
-            if (const ColumnConst * const_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get()))
-            {
-                if (const_array->getValue<Array>().empty())
-                {
-                    auto nested_type = typeid_cast<const DataTypeArray &>(*block.getByPosition(arguments[0]).type).getNestedType();
+            auto nested_type = typeid_cast<const DataTypeArray &>(
+                    *block.getByPosition(arguments[0]).type).getNestedType();
 
-                    block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(
-                        block.rows(),
-                        Array{nested_type->getDefault()});
-                }
-                else
-                    block.getByPosition(result).column = block.getByPosition(arguments[0]).column;
-
-                return true;
-            }
-            else
-                return false;
+            block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(
+                    block.rows(),
+                    Array{nested_type->getDefault()});
         }
+        else
+            block.getByPosition(result).column = block.getByPosition(arguments[0]).column;
 
-        template <typename T, bool nullable>
-        bool executeNumber(
-            const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
-            IColumn & res_data_col, ColumnArray::Offsets_t & res_offsets,
-            const NullMap * src_null_map,
-            NullMap * res_null_map)
+        return true;
+    }
+    else
+        return false;
+}
+
+template<typename T, bool nullable>
+bool executeNumber(
+        const IColumn &src_data, const ColumnArray::Offsets_t &src_offsets,
+        IColumn &res_data_col, ColumnArray::Offsets_t &res_offsets,
+        const NullMap *src_null_map,
+        NullMap *res_null_map)
+{
+    if (const ColumnVector<T> *src_data_concrete = checkAndGetColumn<ColumnVector<T>>(&src_data))
+    {
+        const PaddedPODArray<T> &src_data = src_data_concrete->getData();
+        PaddedPODArray<T> &res_data = static_cast<ColumnVector<T> &>(res_data_col).getData();
+
+        size_t size = src_offsets.size();
+        res_offsets.resize(size);
+        res_data.reserve(src_data.size());
+
+        if (nullable)
+            res_null_map->reserve(src_null_map->size());
+
+        ColumnArray::Offset_t src_prev_offset = 0;
+        ColumnArray::Offset_t res_prev_offset = 0;
+
+        for (size_t i = 0; i < size; ++i)
         {
-            if (const ColumnVector<T> * src_data_concrete = checkAndGetColumn<ColumnVector<T>>(&src_data))
+            if (src_offsets[i] != src_prev_offset)
             {
-                const PaddedPODArray<T> & src_data = src_data_concrete->getData();
-                PaddedPODArray<T> & res_data = static_cast<ColumnVector<T> &>(res_data_col).getData();
-
-                size_t size = src_offsets.size();
-                res_offsets.resize(size);
-                res_data.reserve(src_data.size());
+                size_t size_to_write = src_offsets[i] - src_prev_offset;
+                res_data.resize(res_prev_offset + size_to_write);
+                memcpy(&res_data[res_prev_offset], &src_data[src_prev_offset], size_to_write * sizeof(T));
 
                 if (nullable)
-                    res_null_map->reserve(src_null_map->size());
-
-                ColumnArray::Offset_t src_prev_offset = 0;
-                ColumnArray::Offset_t res_prev_offset = 0;
-
-                for (size_t i = 0; i < size; ++i)
                 {
-                    if (src_offsets[i] != src_prev_offset)
-                    {
-                        size_t size_to_write = src_offsets[i] - src_prev_offset;
-                        res_data.resize(res_prev_offset + size_to_write);
-                        memcpy(&res_data[res_prev_offset], &src_data[src_prev_offset], size_to_write * sizeof(T));
-
-                        if (nullable)
-                        {
-                            res_null_map->resize(res_prev_offset + size_to_write);
-                            memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
-                        }
-
-                        res_prev_offset += size_to_write;
-                        res_offsets[i] = res_prev_offset;
-                    }
-                    else
-                    {
-                        res_data.push_back(T());
-                        ++res_prev_offset;
-                        res_offsets[i] = res_prev_offset;
-
-                        if (nullable)
-                            res_null_map->push_back(1); /// Push NULL.
-                    }
-
-                    src_prev_offset = src_offsets[i];
+                    res_null_map->resize(res_prev_offset + size_to_write);
+                    memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
                 }
 
-                return true;
+                res_prev_offset += size_to_write;
+                res_offsets[i] = res_prev_offset;
             }
             else
-                return false;
-        }
-
-
-        template <bool nullable>
-        bool executeFixedString(
-            const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
-            IColumn & res_data_col, ColumnArray::Offsets_t & res_offsets,
-            const NullMap * src_null_map,
-            NullMap * res_null_map)
-        {
-            if (const ColumnFixedString * src_data_concrete = checkAndGetColumn<ColumnFixedString>(&src_data))
             {
-                const size_t n = src_data_concrete->getN();
-                const ColumnFixedString::Chars_t & src_data = src_data_concrete->getChars();
-
-                auto concrete_res_data = typeid_cast<ColumnFixedString *>(&res_data_col);
-                if (!concrete_res_data)
-                    throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
-
-                ColumnFixedString::Chars_t & res_data = concrete_res_data->getChars();
-                size_t size = src_offsets.size();
-                res_offsets.resize(size);
-                res_data.reserve(src_data.size());
+                res_data.push_back(T());
+                ++res_prev_offset;
+                res_offsets[i] = res_prev_offset;
 
                 if (nullable)
-                    res_null_map->reserve(src_null_map->size());
-
-                ColumnArray::Offset_t src_prev_offset = 0;
-                ColumnArray::Offset_t res_prev_offset = 0;
-
-                for (size_t i = 0; i < size; ++i)
-                {
-                    if (src_offsets[i] != src_prev_offset)
-                    {
-                        size_t size_to_write = src_offsets[i] - src_prev_offset;
-                        size_t prev_res_data_size = res_data.size();
-                        res_data.resize(prev_res_data_size + size_to_write * n);
-                        memcpy(&res_data[prev_res_data_size], &src_data[src_prev_offset * n], size_to_write * n);
-
-                        if (nullable)
-                        {
-                            res_null_map->resize(res_prev_offset + size_to_write);
-                            memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
-                        }
-
-                        res_prev_offset += size_to_write;
-                        res_offsets[i] = res_prev_offset;
-                    }
-                    else
-                    {
-                        size_t prev_res_data_size = res_data.size();
-                        res_data.resize(prev_res_data_size + n);
-                        memset(&res_data[prev_res_data_size], 0, n);
-                        ++res_prev_offset;
-                        res_offsets[i] = res_prev_offset;
-
-                        if (nullable)
-                            res_null_map->push_back(1);
-                    }
-
-                    src_prev_offset = src_offsets[i];
-                }
-
-                return true;
+                    res_null_map->push_back(1); /// Push NULL.
             }
-            else
-                return false;
+
+            src_prev_offset = src_offsets[i];
         }
 
+        return true;
+    }
+    else
+        return false;
+}
 
-        template <bool nullable>
-        bool executeString(
-            const IColumn & src_data, const ColumnArray::Offsets_t & src_array_offsets,
-            IColumn & res_data_col, ColumnArray::Offsets_t & res_array_offsets,
-            const NullMap * src_null_map,
-            NullMap * res_null_map)
+
+template<bool nullable>
+bool executeFixedString(
+        const IColumn &src_data, const ColumnArray::Offsets_t &src_offsets,
+        IColumn &res_data_col, ColumnArray::Offsets_t &res_offsets,
+        const NullMap *src_null_map,
+        NullMap *res_null_map)
+{
+    if (const ColumnFixedString *src_data_concrete = checkAndGetColumn<ColumnFixedString>(&src_data))
+    {
+        const size_t n = src_data_concrete->getN();
+        const ColumnFixedString::Chars_t &src_data = src_data_concrete->getChars();
+
+        auto concrete_res_data = typeid_cast<ColumnFixedString *>(&res_data_col);
+        if (!concrete_res_data)
+            throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
+
+        ColumnFixedString::Chars_t &res_data = concrete_res_data->getChars();
+        size_t size = src_offsets.size();
+        res_offsets.resize(size);
+        res_data.reserve(src_data.size());
+
+        if (nullable)
+            res_null_map->reserve(src_null_map->size());
+
+        ColumnArray::Offset_t src_prev_offset = 0;
+        ColumnArray::Offset_t res_prev_offset = 0;
+
+        for (size_t i = 0; i < size; ++i)
         {
-            if (const ColumnString * src_data_concrete = checkAndGetColumn<ColumnString>(&src_data))
+            if (src_offsets[i] != src_prev_offset)
             {
-                const ColumnString::Offsets_t & src_string_offsets = src_data_concrete->getOffsets();
-
-                auto concrete_res_string_offsets = typeid_cast<ColumnString *>(&res_data_col);
-                if (!concrete_res_string_offsets)
-                    throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
-                ColumnString::Offsets_t & res_string_offsets = concrete_res_string_offsets->getOffsets();
-
-                const ColumnString::Chars_t & src_data = src_data_concrete->getChars();
-
-                auto concrete_res_data = typeid_cast<ColumnString *>(&res_data_col);
-                if (!concrete_res_data)
-                    throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
-                ColumnString::Chars_t & res_data = concrete_res_data->getChars();
-
-                size_t size = src_array_offsets.size();
-                res_array_offsets.resize(size);
-                res_string_offsets.reserve(src_string_offsets.size());
-                res_data.reserve(src_data.size());
+                size_t size_to_write = src_offsets[i] - src_prev_offset;
+                size_t prev_res_data_size = res_data.size();
+                res_data.resize(prev_res_data_size + size_to_write * n);
+                memcpy(&res_data[prev_res_data_size], &src_data[src_prev_offset * n], size_to_write * n);
 
                 if (nullable)
-                    res_null_map->reserve(src_null_map->size());
-
-                ColumnArray::Offset_t src_array_prev_offset = 0;
-                ColumnArray::Offset_t res_array_prev_offset = 0;
-
-                ColumnString::Offset_t src_string_prev_offset = 0;
-                ColumnString::Offset_t res_string_prev_offset = 0;
-
-                for (size_t i = 0; i < size; ++i)
                 {
-                    if (src_array_offsets[i] != src_array_prev_offset)
-                    {
-                        size_t array_size = src_array_offsets[i] - src_array_prev_offset;
-
-                        size_t bytes_to_copy = 0;
-                        size_t from_string_prev_offset_local = src_string_prev_offset;
-                        for (size_t j = 0; j < array_size; ++j)
-                        {
-                            size_t string_size = src_string_offsets[src_array_prev_offset + j] - from_string_prev_offset_local;
-
-                            res_string_prev_offset += string_size;
-                            res_string_offsets.push_back(res_string_prev_offset);
-
-                            from_string_prev_offset_local += string_size;
-                            bytes_to_copy += string_size;
-                        }
-
-                        size_t res_data_old_size = res_data.size();
-                        res_data.resize(res_data_old_size + bytes_to_copy);
-                        memcpy(&res_data[res_data_old_size], &src_data[src_string_prev_offset], bytes_to_copy);
-
-                        if (nullable)
-                        {
-                            res_null_map->resize(res_array_prev_offset + array_size);
-                            memcpy(&(*res_null_map)[res_array_prev_offset], &(*src_null_map)[src_array_prev_offset], array_size);
-                        }
-
-                        res_array_prev_offset += array_size;
-                        res_array_offsets[i] = res_array_prev_offset;
-                    }
-                    else
-                    {
-                        res_data.push_back(0);  /// An empty string, including zero at the end.
-
-                        if (nullable)
-                            res_null_map->push_back(1);
-
-                        ++res_string_prev_offset;
-                        res_string_offsets.push_back(res_string_prev_offset);
-
-                        ++res_array_prev_offset;
-                        res_array_offsets[i] = res_array_prev_offset;
-                    }
-
-                    src_array_prev_offset = src_array_offsets[i];
-
-                    if (src_array_prev_offset)
-                        src_string_prev_offset = src_string_offsets[src_array_prev_offset - 1];
+                    res_null_map->resize(res_prev_offset + size_to_write);
+                    memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
                 }
 
-                return true;
+                res_prev_offset += size_to_write;
+                res_offsets[i] = res_prev_offset;
             }
             else
-                return false;
+            {
+                size_t prev_res_data_size = res_data.size();
+                res_data.resize(prev_res_data_size + n);
+                memset(&res_data[prev_res_data_size], 0, n);
+                ++res_prev_offset;
+                res_offsets[i] = res_prev_offset;
+
+                if (nullable)
+                    res_null_map->push_back(1);
+            }
+
+            src_prev_offset = src_offsets[i];
         }
 
+        return true;
+    }
+    else
+        return false;
+}
 
-        template <bool nullable>
-        void executeGeneric(
-            const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
-            IColumn & res_data, ColumnArray::Offsets_t & res_offsets,
-            const NullMap * src_null_map,
-            NullMap * res_null_map)
+
+template<bool nullable>
+bool executeString(
+        const IColumn &src_data, const ColumnArray::Offsets_t &src_array_offsets,
+        IColumn &res_data_col, ColumnArray::Offsets_t &res_array_offsets,
+        const NullMap *src_null_map,
+        NullMap *res_null_map)
+{
+    if (const ColumnString *src_data_concrete = checkAndGetColumn<ColumnString>(&src_data))
+    {
+        const ColumnString::Offsets_t &src_string_offsets = src_data_concrete->getOffsets();
+
+        auto concrete_res_string_offsets = typeid_cast<ColumnString *>(&res_data_col);
+        if (!concrete_res_string_offsets)
+            throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
+        ColumnString::Offsets_t &res_string_offsets = concrete_res_string_offsets->getOffsets();
+
+        const ColumnString::Chars_t &src_data = src_data_concrete->getChars();
+
+        auto concrete_res_data = typeid_cast<ColumnString *>(&res_data_col);
+        if (!concrete_res_data)
+            throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
+        ColumnString::Chars_t &res_data = concrete_res_data->getChars();
+
+        size_t size = src_array_offsets.size();
+        res_array_offsets.resize(size);
+        res_string_offsets.reserve(src_string_offsets.size());
+        res_data.reserve(src_data.size());
+
+        if (nullable)
+            res_null_map->reserve(src_null_map->size());
+
+        ColumnArray::Offset_t src_array_prev_offset = 0;
+        ColumnArray::Offset_t res_array_prev_offset = 0;
+
+        ColumnString::Offset_t src_string_prev_offset = 0;
+        ColumnString::Offset_t res_string_prev_offset = 0;
+
+        for (size_t i = 0; i < size; ++i)
         {
-            size_t size = src_offsets.size();
-            res_offsets.resize(size);
-            res_data.reserve(src_data.size());
+            if (src_array_offsets[i] != src_array_prev_offset)
+            {
+                size_t array_size = src_array_offsets[i] - src_array_prev_offset;
+
+                size_t bytes_to_copy = 0;
+                size_t from_string_prev_offset_local = src_string_prev_offset;
+                for (size_t j = 0; j < array_size; ++j)
+                {
+                    size_t string_size = src_string_offsets[src_array_prev_offset + j] - from_string_prev_offset_local;
+
+                    res_string_prev_offset += string_size;
+                    res_string_offsets.push_back(res_string_prev_offset);
+
+                    from_string_prev_offset_local += string_size;
+                    bytes_to_copy += string_size;
+                }
+
+                size_t res_data_old_size = res_data.size();
+                res_data.resize(res_data_old_size + bytes_to_copy);
+                memcpy(&res_data[res_data_old_size], &src_data[src_string_prev_offset], bytes_to_copy);
+
+                if (nullable)
+                {
+                    res_null_map->resize(res_array_prev_offset + array_size);
+                    memcpy(&(*res_null_map)[res_array_prev_offset], &(*src_null_map)[src_array_prev_offset],
+                           array_size);
+                }
+
+                res_array_prev_offset += array_size;
+                res_array_offsets[i] = res_array_prev_offset;
+            }
+            else
+            {
+                res_data.push_back(0);  /// An empty string, including zero at the end.
+
+                if (nullable)
+                    res_null_map->push_back(1);
+
+                ++res_string_prev_offset;
+                res_string_offsets.push_back(res_string_prev_offset);
+
+                ++res_array_prev_offset;
+                res_array_offsets[i] = res_array_prev_offset;
+            }
+
+            src_array_prev_offset = src_array_offsets[i];
+
+            if (src_array_prev_offset)
+                src_string_prev_offset = src_string_offsets[src_array_prev_offset - 1];
+        }
+
+        return true;
+    }
+    else
+        return false;
+}
+
+
+template<bool nullable>
+void executeGeneric(
+        const IColumn &src_data, const ColumnArray::Offsets_t &src_offsets,
+        IColumn &res_data, ColumnArray::Offsets_t &res_offsets,
+        const NullMap *src_null_map,
+        NullMap *res_null_map)
+{
+    size_t size = src_offsets.size();
+    res_offsets.resize(size);
+    res_data.reserve(src_data.size());
+
+    if (nullable)
+        res_null_map->reserve(src_null_map->size());
+
+    ColumnArray::Offset_t src_prev_offset = 0;
+    ColumnArray::Offset_t res_prev_offset = 0;
+
+    for (size_t i = 0; i < size; ++i)
+    {
+        if (src_offsets[i] != src_prev_offset)
+        {
+            size_t size_to_write = src_offsets[i] - src_prev_offset;
+            res_data.insertRangeFrom(src_data, src_prev_offset, size_to_write);
 
             if (nullable)
-                res_null_map->reserve(src_null_map->size());
-
-            ColumnArray::Offset_t src_prev_offset = 0;
-            ColumnArray::Offset_t res_prev_offset = 0;
-
-            for (size_t i = 0; i < size; ++i)
             {
-                if (src_offsets[i] != src_prev_offset)
-                {
-                    size_t size_to_write = src_offsets[i] - src_prev_offset;
-                    res_data.insertRangeFrom(src_data, src_prev_offset, size_to_write);
-
-                    if (nullable)
-                    {
-                        res_null_map->resize(res_prev_offset + size_to_write);
-                        memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
-                    }
-
-                    res_prev_offset += size_to_write;
-                    res_offsets[i] = res_prev_offset;
-                }
-                else
-                {
-                    res_data.insertDefault();
-                    ++res_prev_offset;
-                    res_offsets[i] = res_prev_offset;
-
-                    if (nullable)
-                        res_null_map->push_back(1);
-                }
-
-                src_prev_offset = src_offsets[i];
+                res_null_map->resize(res_prev_offset + size_to_write);
+                memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
             }
+
+            res_prev_offset += size_to_write;
+            res_offsets[i] = res_prev_offset;
         }
-
-
-        template <bool nullable>
-        void executeDispatch(
-            const IColumn & src_data, const ColumnArray::Offsets_t & src_array_offsets,
-            IColumn & res_data_col, ColumnArray::Offsets_t & res_array_offsets,
-            const NullMap * src_null_map,
-            NullMap * res_null_map)
+        else
         {
-            if (!( executeNumber<UInt8, nullable>  (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeNumber<UInt16, nullable> (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeNumber<UInt32, nullable> (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeNumber<UInt64, nullable> (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeNumber<Int8, nullable>   (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeNumber<Int16, nullable>  (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeNumber<Int32, nullable>  (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeNumber<Int64, nullable>  (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeNumber<Float32, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeNumber<Float64, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeString<nullable>         (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
-                || executeFixedString<nullable>    (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)))
-                executeGeneric<nullable>           (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map);
+            res_data.insertDefault();
+            ++res_prev_offset;
+            res_offsets[i] = res_prev_offset;
+
+            if (nullable)
+                res_null_map->push_back(1);
         }
+
+        src_prev_offset = src_offsets[i];
     }
 }
 
-void FunctionEmptyArrayToSingle::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+
+template<bool nullable>
+void executeDispatch(
+        const IColumn &src_data, const ColumnArray::Offsets_t &src_array_offsets,
+        IColumn &res_data_col, ColumnArray::Offsets_t &res_array_offsets,
+        const NullMap *src_null_map,
+        NullMap *res_null_map)
+{
+    if (!(executeNumber<UInt8, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                         res_null_map)
+          || executeNumber<UInt16, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                             res_null_map)
+          || executeNumber<UInt32, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                             res_null_map)
+          || executeNumber<UInt64, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                             res_null_map)
+          || executeNumber<Int8, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                           res_null_map)
+          || executeNumber<Int16, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                            res_null_map)
+          || executeNumber<Int32, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                            res_null_map)
+          || executeNumber<Int64, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                            res_null_map)
+          ||
+          executeNumber<Float32, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                           res_null_map)
+          ||
+          executeNumber<Float64, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                           res_null_map)
+          || executeString<nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                     res_null_map)
+          || executeFixedString<nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                          res_null_map)))
+        executeGeneric<nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
+                                 res_null_map);
+}
+}
+}
+
+void FunctionEmptyArrayToSingle::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
 {
     if (FunctionEmptyArrayToSingleImpl::executeConst(block, arguments, result))
         return;
 
-    const ColumnArray * array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray *array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
     if (!array)
-        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName() + " of first argument of function " + getName(),
-            ErrorCodes::ILLEGAL_COLUMN);
+        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName() +
+                        " of first argument of function " + getName(),
+                        ErrorCodes::ILLEGAL_COLUMN);
 
     ColumnPtr res_ptr = array->cloneEmpty();
     block.getByPosition(result).column = res_ptr;
-    ColumnArray & res = static_cast<ColumnArray &>(*res_ptr);
+    ColumnArray &res = static_cast<ColumnArray &>(*res_ptr);
 
-    const IColumn & src_data = array->getData();
-    const ColumnArray::Offsets_t & src_offsets = array->getOffsets();
-    IColumn & res_data = res.getData();
-    ColumnArray::Offsets_t & res_offsets = res.getOffsets();
+    const IColumn &src_data = array->getData();
+    const ColumnArray::Offsets_t &src_offsets = array->getOffsets();
+    IColumn &res_data = res.getData();
+    ColumnArray::Offsets_t &res_offsets = res.getOffsets();
 
-    const NullMap * src_null_map = nullptr;
-    NullMap * res_null_map = nullptr;
+    const NullMap *src_null_map = nullptr;
+    NullMap *res_null_map = nullptr;
 
-    const IColumn * inner_col;
-    IColumn * inner_res_col;
+    const IColumn *inner_col;
+    IColumn *inner_res_col;
 
     bool nullable = src_data.isNullable();
     if (nullable)
@@ -2286,9 +2343,11 @@ void FunctionEmptyArrayToSingle::executeImpl(Block & block, const ColumnNumbers
     }
 
     if (nullable)
-        FunctionEmptyArrayToSingleImpl::executeDispatch<true>(*inner_col, src_offsets, *inner_res_col, res_offsets, src_null_map, res_null_map);
+        FunctionEmptyArrayToSingleImpl::executeDispatch<true>(*inner_col, src_offsets, *inner_res_col, res_offsets,
+                                                              src_null_map, res_null_map);
     else
-        FunctionEmptyArrayToSingleImpl::executeDispatch<false>(*inner_col, src_offsets, *inner_res_col, res_offsets, src_null_map, res_null_map);
+        FunctionEmptyArrayToSingleImpl::executeDispatch<false>(*inner_col, src_offsets, *inner_res_col, res_offsets,
+                                                               src_null_map, res_null_map);
 }
 
 
@@ -2299,7 +2358,7 @@ String FunctionRange::getName() const
     return name;
 }
 
-DataTypePtr FunctionRange::getReturnTypeImpl(const DataTypes & arguments) const
+DataTypePtr FunctionRange::getReturnTypeImpl(const DataTypes &arguments) const
 {
     const auto arg = arguments.front().get();
 
@@ -2309,47 +2368,48 @@ DataTypePtr FunctionRange::getReturnTypeImpl(const DataTypes & arguments) const
         !checkDataType<DataTypeUInt64>(arg))
     {
         throw Exception{
-            "Illegal type " + arg->getName() + " of argument of function " + getName(),
-            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+                "Illegal type " + arg->getName() + " of argument of function " + getName(),
+                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
     }
 
     return std::make_shared<DataTypeArray>(arg->clone());
 }
 
-template <typename T>
-bool FunctionRange::executeInternal(Block & block, const IColumn * arg, const size_t result)
+template<typename T>
+bool FunctionRange::executeInternal(Block &block, const IColumn *arg, const size_t result)
 {
     static constexpr size_t max_elements = 100'000'000;
 
     if (const auto in = checkAndGetColumn<ColumnVector<T>>(arg))
     {
-        const auto & in_data = in->getData();
+        const auto &in_data = in->getData();
         const auto total_values = std::accumulate(std::begin(in_data), std::end(in_data), size_t{},
-            [this] (const size_t lhs, const size_t rhs)
-            {
-                const auto sum = lhs + rhs;
-                if (sum < lhs)
-                    throw Exception{
-                        "A call to function " + getName() + " overflows, investigate the values of arguments you are passing",
-                        ErrorCodes::ARGUMENT_OUT_OF_BOUND};
+                                                  [this](const size_t lhs, const size_t rhs)
+                                                  {
+                                                      const auto sum = lhs + rhs;
+                                                      if (sum < lhs)
+                                                          throw Exception{
+                                                                  "A call to function " + getName() +
+                                                                  " overflows, investigate the values of arguments you are passing",
+                                                                  ErrorCodes::ARGUMENT_OUT_OF_BOUND};
 
-                return sum;
-            });
+                                                      return sum;
+                                                  });
 
         if (total_values > max_elements)
             throw Exception{
-                "A call to function " + getName() + " would produce " + std::to_string(total_values) +
+                    "A call to function " + getName() + " would produce " + std::to_string(total_values) +
                     " array elements, which is greater than the allowed maximum of " + std::to_string(max_elements),
-                ErrorCodes::ARGUMENT_OUT_OF_BOUND};
+                    ErrorCodes::ARGUMENT_OUT_OF_BOUND};
 
         const auto data_col = std::make_shared<ColumnVector<T>>(total_values);
         const auto out = std::make_shared<ColumnArray>(
-            data_col,
-            std::make_shared<ColumnArray::ColumnOffsets_t>(in->size()));
+                data_col,
+                std::make_shared<ColumnArray::ColumnOffsets_t>(in->size()));
         block.getByPosition(result).column = out;
 
-        auto & out_data = data_col->getData();
-        auto & out_offsets = out->getOffsets();
+        auto &out_data = data_col->getData();
+        auto &out_offsets = out->getOffsets();
 
         IColumn::Offset_t offset{};
         for (size_t row_idx = 0, rows = in->size(); row_idx < rows; ++row_idx)
@@ -2368,24 +2428,25 @@ bool FunctionRange::executeInternal(Block & block, const IColumn * arg, const si
         T in_data = in->template getValue<T>();
         if ((in_data != 0) && (in->size() > (std::numeric_limits<size_t>::max() / in_data)))
             throw Exception{
-                "A call to function " + getName() + " overflows, investigate the values of arguments you are passing",
-                ErrorCodes::ARGUMENT_OUT_OF_BOUND};
+                    "A call to function " + getName() +
+                    " overflows, investigate the values of arguments you are passing",
+                    ErrorCodes::ARGUMENT_OUT_OF_BOUND};
 
         const size_t total_values = in->size() * in_data;
         if (total_values > max_elements)
             throw Exception{
-                "A call to function " + getName() + " would produce " + toString(total_values) +
+                    "A call to function " + getName() + " would produce " + toString(total_values) +
                     " array elements, which is greater than the allowed maximum of " + toString(max_elements),
-                ErrorCodes::ARGUMENT_OUT_OF_BOUND};
+                    ErrorCodes::ARGUMENT_OUT_OF_BOUND};
 
         const auto data_col = std::make_shared<ColumnVector<T>>(total_values);
         const auto out = std::make_shared<ColumnArray>(
-            data_col,
-            std::make_shared<ColumnArray::ColumnOffsets_t>(in->size()));
+                data_col,
+                std::make_shared<ColumnArray::ColumnOffsets_t>(in->size()));
         block.getByPosition(result).column = out;
 
-        auto & out_data = data_col->getData();
-        auto & out_offsets = out->getOffsets();
+        auto &out_data = data_col->getData();
+        auto &out_offsets = out->getOffsets();
 
         IColumn::Offset_t offset{};
         for (size_t row_idx = 0, rows = in->size(); row_idx < rows; ++row_idx)
@@ -2403,7 +2464,7 @@ bool FunctionRange::executeInternal(Block & block, const IColumn * arg, const si
         return false;
 }
 
-void FunctionRange::executeImpl(Block & block, const ColumnNumbers & arguments, const size_t result)
+void FunctionRange::executeImpl(Block &block, const ColumnNumbers &arguments, const size_t result)
 {
     const auto col = block.getByPosition(arguments[0]).column.get();
 
@@ -2413,15 +2474,15 @@ void FunctionRange::executeImpl(Block & block, const ColumnNumbers & arguments,
         !executeInternal<UInt64>(block, col, result))
     {
         throw Exception{
-            "Illegal column " + col->getName() + " of argument of function " + getName(),
-            ErrorCodes::ILLEGAL_COLUMN
+                "Illegal column " + col->getName() + " of argument of function " + getName(),
+                ErrorCodes::ILLEGAL_COLUMN
         };
     }
 }
 
 /// Implementation of FunctionArrayReverse.
 
-FunctionPtr FunctionArrayReverse::create(const Context & context)
+FunctionPtr FunctionArrayReverse::create(const Context &context)
 {
     return std::make_shared<FunctionArrayReverse>();
 }
@@ -2431,40 +2492,41 @@ String FunctionArrayReverse::getName() const
     return name;
 }
 
-DataTypePtr FunctionArrayReverse::getReturnTypeImpl(const DataTypes & arguments) const
+DataTypePtr FunctionArrayReverse::getReturnTypeImpl(const DataTypes &arguments) const
 {
-    const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
+    const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
     if (!array_type)
         throw Exception("Argument for function " + getName() + " must be array.",
-            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     return arguments[0]->clone();
 }
 
-void FunctionArrayReverse::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+void FunctionArrayReverse::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
 {
     if (executeConst(block, arguments, result))
         return;
 
-    const ColumnArray * array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray *array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
     if (!array)
-        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName() + " of first argument of function " + getName(),
-            ErrorCodes::ILLEGAL_COLUMN);
+        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName() +
+                        " of first argument of function " + getName(),
+                        ErrorCodes::ILLEGAL_COLUMN);
 
     ColumnPtr res_ptr = array->cloneEmpty();
     block.getByPosition(result).column = res_ptr;
-    ColumnArray & res = static_cast<ColumnArray &>(*res_ptr);
+    ColumnArray &res = static_cast<ColumnArray &>(*res_ptr);
 
-    const IColumn & src_data = array->getData();
-    const ColumnArray::Offsets_t & offsets = array->getOffsets();
-    IColumn & res_data = res.getData();
+    const IColumn &src_data = array->getData();
+    const ColumnArray::Offsets_t &offsets = array->getOffsets();
+    IColumn &res_data = res.getData();
     res.getOffsetsColumn() = array->getOffsetsColumn();
 
-    const ColumnNullable * nullable_col = nullptr;
-    ColumnNullable * nullable_res_col = nullptr;
+    const ColumnNullable *nullable_col = nullptr;
+    ColumnNullable *nullable_res_col = nullptr;
 
-    const IColumn * inner_col;
-    IColumn * inner_res_col;
+    const IColumn *inner_col;
+    IColumn *inner_res_col;
 
     if (src_data.isNullable())
     {
@@ -2480,26 +2542,27 @@ void FunctionArrayReverse::executeImpl(Block & block, const ColumnNumbers & argu
         inner_res_col = &res_data;
     }
 
-    if (!(    executeNumber<UInt8>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeNumber<UInt16>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeNumber<UInt32>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeNumber<UInt64>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeNumber<Int8>        (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeNumber<Int16>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeNumber<Int32>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeNumber<Int64>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeNumber<Float32>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeNumber<Float64>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeString            (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-        ||    executeFixedString        (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)))
+    if (!(executeNumber<UInt8>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeNumber<UInt16>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeNumber<UInt32>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeNumber<UInt64>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeNumber<Int8>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeNumber<Int16>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeNumber<Int32>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeNumber<Int64>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeNumber<Float32>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeNumber<Float64>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeString(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+          || executeFixedString(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)))
         throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-            + " of first argument of function " + getName(),
-            ErrorCodes::ILLEGAL_COLUMN);
+                        + " of first argument of function " + getName(),
+                        ErrorCodes::ILLEGAL_COLUMN);
 }
 
-bool FunctionArrayReverse::executeConst(Block & block, const ColumnNumbers & arguments, size_t result)
+bool FunctionArrayReverse::executeConst(Block &block, const ColumnNumbers &arguments, size_t result)
 {
-    if (const ColumnConst * const_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get()))
+    if (const ColumnConst *const_array = checkAndGetColumnConst<ColumnArray>(
+            block.getByPosition(arguments[0]).column.get()))
     {
         Array arr = const_array->getValue<Array>();
 
@@ -2517,22 +2580,22 @@ bool FunctionArrayReverse::executeConst(Block & block, const ColumnNumbers & arg
         return false;
 }
 
-template <typename T>
+template<typename T>
 bool FunctionArrayReverse::executeNumber(
-    const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
-    IColumn & res_data_col,
-    const ColumnNullable * nullable_col,
-    ColumnNullable * nullable_res_col)
+        const IColumn &src_data, const ColumnArray::Offsets_t &src_offsets,
+        IColumn &res_data_col,
+        const ColumnNullable *nullable_col,
+        ColumnNullable *nullable_res_col)
 {
-    auto do_reverse = [](const auto & src_data, const auto & src_offsets, auto & res_data)
+    auto do_reverse = [](const auto &src_data, const auto &src_offsets, auto &res_data)
     {
         size_t size = src_offsets.size();
         ColumnArray::Offset_t src_prev_offset = 0;
 
         for (size_t i = 0; i < size; ++i)
         {
-            const auto * src = &src_data[src_prev_offset];
-            const auto * src_end = &src_data[src_offsets[i]];
+            const auto *src = &src_data[src_prev_offset];
+            const auto *src_end = &src_data[src_offsets[i]];
 
             if (src == src_end)
                 continue;
@@ -2550,18 +2613,18 @@ bool FunctionArrayReverse::executeNumber(
         }
     };
 
-    if (const ColumnVector<T> * src_data_concrete = checkAndGetColumn<ColumnVector<T>>(&src_data))
+    if (const ColumnVector<T> *src_data_concrete = checkAndGetColumn<ColumnVector<T>>(&src_data))
     {
-        const PaddedPODArray<T> & src_data = src_data_concrete->getData();
-        PaddedPODArray<T> & res_data = typeid_cast<ColumnVector<T> &>(res_data_col).getData();
+        const PaddedPODArray<T> &src_data = src_data_concrete->getData();
+        PaddedPODArray<T> &res_data = typeid_cast<ColumnVector<T> &>(res_data_col).getData();
         res_data.resize(src_data.size());
         do_reverse(src_data, src_offsets, res_data);
 
         if ((nullable_col) && (nullable_res_col))
         {
             /// Make a reverted null map.
-            const auto & src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
-            auto & res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
+            const auto &src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
+            auto &res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
             res_null_map.resize(src_data.size());
             do_reverse(src_null_map, src_offsets, res_null_map);
         }
@@ -2573,16 +2636,16 @@ bool FunctionArrayReverse::executeNumber(
 }
 
 bool FunctionArrayReverse::executeFixedString(
-    const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
-    IColumn & res_data_col,
-    const ColumnNullable * nullable_col,
-    ColumnNullable * nullable_res_col)
+        const IColumn &src_data, const ColumnArray::Offsets_t &src_offsets,
+        IColumn &res_data_col,
+        const ColumnNullable *nullable_col,
+        ColumnNullable *nullable_res_col)
 {
-    if (const ColumnFixedString * src_data_concrete = checkAndGetColumn<ColumnFixedString>(&src_data))
+    if (const ColumnFixedString *src_data_concrete = checkAndGetColumn<ColumnFixedString>(&src_data))
     {
         const size_t n = src_data_concrete->getN();
-        const ColumnFixedString::Chars_t & src_data = src_data_concrete->getChars();
-        ColumnFixedString::Chars_t & res_data = typeid_cast<ColumnFixedString &>(res_data_col).getChars();
+        const ColumnFixedString::Chars_t &src_data = src_data_concrete->getChars();
+        ColumnFixedString::Chars_t &res_data = typeid_cast<ColumnFixedString &>(res_data_col).getChars();
         size_t size = src_offsets.size();
         res_data.resize(src_data.size());
 
@@ -2590,13 +2653,13 @@ bool FunctionArrayReverse::executeFixedString(
 
         for (size_t i = 0; i < size; ++i)
         {
-            const UInt8 * src = &src_data[src_prev_offset * n];
-            const UInt8 * src_end = &src_data[src_offsets[i] * n];
+            const UInt8 *src = &src_data[src_prev_offset * n];
+            const UInt8 *src_end = &src_data[src_offsets[i] * n];
 
             if (src == src_end)
                 continue;
 
-            UInt8 * dst = &res_data[src_offsets[i] * n - n];
+            UInt8 *dst = &res_data[src_offsets[i] * n - n];
 
             while (src < src_end)
             {
@@ -2612,21 +2675,21 @@ bool FunctionArrayReverse::executeFixedString(
         if ((nullable_col) && (nullable_res_col))
         {
             /// Make a reverted null map.
-            const auto & src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
-            auto & res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
+            const auto &src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
+            auto &res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
             res_null_map.resize(src_null_map.size());
 
             ColumnArray::Offset_t src_prev_offset = 0;
 
             for (size_t i = 0; i < size; ++i)
             {
-                const UInt8 * src = &src_null_map[src_prev_offset];
-                const UInt8 * src_end = &src_null_map[src_offsets[i]];
+                const UInt8 *src = &src_null_map[src_prev_offset];
+                const UInt8 *src_end = &src_null_map[src_offsets[i]];
 
                 if (src == src_end)
                     continue;
 
-                UInt8 * dst = &res_null_map[src_offsets[i] - 1];
+                UInt8 *dst = &res_null_map[src_offsets[i] - 1];
 
                 while (src < src_end)
                 {
@@ -2646,18 +2709,18 @@ bool FunctionArrayReverse::executeFixedString(
 }
 
 bool FunctionArrayReverse::executeString(
-    const IColumn & src_data, const ColumnArray::Offsets_t & src_array_offsets,
-    IColumn & res_data_col,
-    const ColumnNullable * nullable_col,
-    ColumnNullable * nullable_res_col)
+        const IColumn &src_data, const ColumnArray::Offsets_t &src_array_offsets,
+        IColumn &res_data_col,
+        const ColumnNullable *nullable_col,
+        ColumnNullable *nullable_res_col)
 {
-    if (const ColumnString * src_data_concrete = checkAndGetColumn<ColumnString>(&src_data))
+    if (const ColumnString *src_data_concrete = checkAndGetColumn<ColumnString>(&src_data))
     {
-        const ColumnString::Offsets_t & src_string_offsets = src_data_concrete->getOffsets();
-        ColumnString::Offsets_t & res_string_offsets = typeid_cast<ColumnString &>(res_data_col).getOffsets();
+        const ColumnString::Offsets_t &src_string_offsets = src_data_concrete->getOffsets();
+        ColumnString::Offsets_t &res_string_offsets = typeid_cast<ColumnString &>(res_data_col).getOffsets();
 
-        const ColumnString::Chars_t & src_data = src_data_concrete->getChars();
-        ColumnString::Chars_t & res_data = typeid_cast<ColumnString &>(res_data_col).getChars();
+        const ColumnString::Chars_t &src_data = src_data_concrete->getChars();
+        ColumnString::Chars_t &res_data = typeid_cast<ColumnString &>(res_data_col).getChars();
 
         size_t size = src_array_offsets.size();
         res_string_offsets.resize(src_string_offsets.size());
@@ -2676,10 +2739,13 @@ bool FunctionArrayReverse::executeString(
                 {
                     size_t j_reversed = array_size - j - 1;
 
-                    auto src_pos = src_array_prev_offset + j_reversed == 0 ? 0 : src_string_offsets[src_array_prev_offset + j_reversed - 1];
+                    auto src_pos =
+                            src_array_prev_offset + j_reversed == 0 ? 0 : src_string_offsets[src_array_prev_offset +
+                                                                                             j_reversed - 1];
                     size_t string_size = src_string_offsets[src_array_prev_offset + j_reversed] - src_pos;
 
-                    memcpySmallAllowReadWriteOverflow15(&res_data[res_string_prev_offset], &src_data[src_pos], string_size);
+                    memcpySmallAllowReadWriteOverflow15(&res_data[res_string_prev_offset], &src_data[src_pos],
+                                                        string_size);
 
                     res_string_prev_offset += string_size;
                     res_string_offsets[src_array_prev_offset + j] = res_string_prev_offset;
@@ -2692,8 +2758,8 @@ bool FunctionArrayReverse::executeString(
         if ((nullable_col) && (nullable_res_col))
         {
             /// Make a reverted null map.
-            const auto & src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
-            auto & res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
+            const auto &src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
+            auto &res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
             res_null_map.resize(src_string_offsets.size());
 
             size_t size = src_string_offsets.size();
@@ -2701,8 +2767,8 @@ bool FunctionArrayReverse::executeString(
 
             for (size_t i = 0; i < size; ++i)
             {
-                const auto * src = &src_null_map[src_prev_offset];
-                const auto * src_end = &src_null_map[src_array_offsets[i]];
+                const auto *src = &src_null_map[src_prev_offset];
+                const auto *src_end = &src_null_map[src_array_offsets[i]];
 
                 if (src == src_end)
                     continue;
@@ -2728,7 +2794,7 @@ bool FunctionArrayReverse::executeString(
 
 /// Implementation of FunctionArrayReduce.
 
-FunctionPtr FunctionArrayReduce::create(const Context & context)
+FunctionPtr FunctionArrayReduce::create(const Context &context)
 {
     return std::make_shared<FunctionArrayReduce>();
 }
@@ -2739,30 +2805,32 @@ String FunctionArrayReduce::getName() const
 }
 
 void FunctionArrayReduce::getReturnTypeAndPrerequisitesImpl(
-    const ColumnsWithTypeAndName & arguments,
-    DataTypePtr & out_return_type,
-    std::vector<ExpressionAction> & out_prerequisites)
+        const ColumnsWithTypeAndName &arguments,
+        DataTypePtr &out_return_type,
+        std::vector<ExpressionAction> &out_prerequisites)
 {
     /// The first argument is a constant string with the name of the aggregate function
     ///  (possibly with parameters in parentheses, for example: "quantile(0.99)").
 
     if (arguments.size() < 2)
         throw Exception("Number of arguments for function " + getName() + " doesn't match: passed "
-            + toString(arguments.size()) + ", should be at least 2.",
-            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+                        + toString(arguments.size()) + ", should be at least 2.",
+                        ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-    const ColumnConst * aggregate_function_name_column = checkAndGetColumnConst<ColumnString>(arguments[0].column.get());
+    const ColumnConst *aggregate_function_name_column = checkAndGetColumnConst<ColumnString>(arguments[0].column.get());
     if (!aggregate_function_name_column)
-        throw Exception("First argument for function " + getName() + " must be constant string: name of aggregate function.",
-            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+        throw Exception(
+                "First argument for function " + getName() + " must be constant string: name of aggregate function.",
+                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     DataTypes argument_types(arguments.size() - 1);
     for (size_t i = 1, size = arguments.size(); i < size; ++i)
     {
-        const DataTypeArray * arg = checkAndGetDataType<DataTypeArray>(arguments[i].type.get());
+        const DataTypeArray *arg = checkAndGetDataType<DataTypeArray>(arguments[i].type.get());
         if (!arg)
-            throw Exception("Argument " + toString(i) + " for function " + getName() + " must be an array but it has type "
-                + arguments[i].type->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+            throw Exception(
+                    "Argument " + toString(i) + " for function " + getName() + " must be an array but it has type "
+                    + arguments[i].type->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
         argument_types[i - 1] = arg->getNestedType()->clone();
     }
@@ -2772,15 +2840,17 @@ void FunctionArrayReduce::getReturnTypeAndPrerequisitesImpl(
         String aggregate_function_name_with_params = aggregate_function_name_column->getValue<String>();
 
         if (aggregate_function_name_with_params.empty())
-            throw Exception("First argument for function " + getName() + " (name of aggregate function) cannot be empty.",
-                ErrorCodes::BAD_ARGUMENTS);
+            throw Exception(
+                    "First argument for function " + getName() + " (name of aggregate function) cannot be empty.",
+                    ErrorCodes::BAD_ARGUMENTS);
 
         String aggregate_function_name;
         Array params_row;
         getAggregateFunctionNameAndParametersArray(aggregate_function_name_with_params,
                                                    aggregate_function_name, params_row, "function " + getName());
 
-        aggregate_function = AggregateFunctionFactory::instance().get(aggregate_function_name, argument_types, params_row);
+        aggregate_function = AggregateFunctionFactory::instance().get(aggregate_function_name, argument_types,
+                                                                      params_row);
         if (!params_row.empty())
             aggregate_function->setParameters(params_row);
         aggregate_function->setArguments(argument_types);
@@ -2790,11 +2860,10 @@ void FunctionArrayReduce::getReturnTypeAndPrerequisitesImpl(
 }
 
 
-
-void FunctionArrayReduce::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+void FunctionArrayReduce::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
 {
-    IAggregateFunction & agg_func = *aggregate_function.get();
-    std::unique_ptr<char[]> place_holder { new char[agg_func.sizeOfData()] };
+    IAggregateFunction &agg_func = *aggregate_function.get();
+    std::unique_ptr<char[]> place_holder{new char[agg_func.sizeOfData()]};
     AggregateDataPtr place = place_holder.get();
 
     std::unique_ptr<Arena> arena = agg_func.allocatesMemoryInArena() ? std::make_unique<Arena>() : nullptr;
@@ -2810,30 +2879,31 @@ void FunctionArrayReduce::executeImpl(Block & block, const ColumnNumbers & argum
 
     for (size_t i = 0, size = arguments.size() - 1; i < size; ++i)
     {
-        const IColumn * col = block.getByPosition(arguments[i + 1]).column.get();
-        if (const ColumnArray * arr = checkAndGetColumn<ColumnArray>(col))
+        const IColumn *col = block.getByPosition(arguments[i + 1]).column.get();
+        if (const ColumnArray *arr = checkAndGetColumn<ColumnArray>(col))
         {
             aggregate_arguments_vec[i] = arr->getDataPtr().get();
             is_const = false;
         }
-        else if (const ColumnConst * arr = checkAndGetColumnConst<ColumnArray>(col))
+        else if (const ColumnConst *arr = checkAndGetColumnConst<ColumnArray>(col))
         {
             materialized_columns.emplace_back(arr->convertToFullColumn());
             aggregate_arguments_vec[i] = typeid_cast<const ColumnArray &>(*materialized_columns.back().get()).getDataPtr().get();
         }
         else
-            throw Exception("Illegal column " + col->getName() + " as argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
+            throw Exception("Illegal column " + col->getName() + " as argument of function " + getName(),
+                            ErrorCodes::ILLEGAL_COLUMN);
 
     }
-    const IColumn ** aggregate_arguments = aggregate_arguments_vec.data();
+    const IColumn **aggregate_arguments = aggregate_arguments_vec.data();
 
-    const ColumnArray::Offsets_t & offsets = typeid_cast<const ColumnArray &>(!materialized_columns.empty()
-        ? *materialized_columns.front().get()
-        : *block.getByPosition(arguments[1]).column.get()).getOffsets();
+    const ColumnArray::Offsets_t &offsets = typeid_cast<const ColumnArray &>(!materialized_columns.empty()
+                                                                             ? *materialized_columns.front().get()
+                                                                             : *block.getByPosition(arguments[1]).column.get()).getOffsets();
 
 
     ColumnPtr result_holder = block.getByPosition(result).type->createColumn();
-    IColumn & res_col = *result_holder;
+    IColumn &res_col = *result_holder;
 
     /// AggregateFunction's states should be inserted into column using specific way
     auto res_col_aggregate_function = typeid_cast<ColumnAggregateFunction *>(&res_col);
@@ -2904,8 +2974,9 @@ DataTypePtr FunctionArrayConcat::getReturnTypeImpl(const DataTypes & arguments)
         if (auto data_type_array = checkAndGetDataType<DataTypeArray>(argument))
             nested_types.push_back(data_type_array->getNestedType());
         else
-            throw Exception("Argument " + toString(i) + " for function " + getName() + " must be an array but it has type "
-                            + argument->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+            throw Exception(
+                    "Argument " + toString(i) + " for function " + getName() + " must be an array but it has type "
+                    + argument->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
     }
 
     if (foundNumericType(nested_types))
@@ -2920,7 +2991,8 @@ DataTypePtr FunctionArrayConcat::getReturnTypeImpl(const DataTypes & arguments)
     {
         /// Otherwise all the arguments must have the same type up to nullability or nullity.
         if (!hasArrayIdenticalTypes(nested_types))
-            throw Exception{"Arguments for function " + getName() + " must have same type or behave as number.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception{"Arguments for function " + getName() + " must have same type or behave as number.",
+                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         return std::make_shared<DataTypeArray>(getArrayElementType(nested_types));
     }
@@ -2928,7 +3000,6 @@ DataTypePtr FunctionArrayConcat::getReturnTypeImpl(const DataTypes & arguments)
 
 void FunctionArrayConcat::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
-    std::cerr << block.dumpStructure() << std::endl;
     auto & result_column = block.getByPosition(result).column;
     const DataTypePtr & return_type = block.getByPosition(result).type;
     result_column = return_type->createColumn();
@@ -2963,18 +3034,6 @@ void FunctionArrayConcat::executeImpl(Block & block, const ColumnNumbers & argum
 
     auto sink = createArraySink(typeid_cast<ColumnArray &>(*result_column.get()), size);
     concat(sources, *sink);
-
-    auto array = checkAndGetColumn<ColumnArray>(result_column.get());
-    if (array)
-    {
-        auto & offsets = array->getOffsets();
-        std::cerr << offsets.size()  << " " << array->size()<< std::endl;
-        for (auto & val : offsets)
-            std::cerr << val << ' ';
-        std::cerr << std::endl;
-    }
-
-    std::cerr << block.dumpStructure() << std::endl;
 }
 
 
@@ -3003,8 +3062,9 @@ DataTypePtr FunctionArraySlice::getReturnTypeImpl(const DataTypes & arguments) c
     for (size_t i = 1; i < arguments.size(); ++i)
     {
         if (!arguments[i]->isNumeric() && !arguments[i]->isNull())
-            throw Exception("Argument " + toString(i) + " for function " + getName() + " must be numeric but it has type "
-                            + arguments[i]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+            throw Exception(
+                    "Argument " + toString(i) + " for function " + getName() + " must be numeric but it has type "
+                    + arguments[i]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
     }
 
     return arguments[0];
@@ -3012,23 +3072,23 @@ DataTypePtr FunctionArraySlice::getReturnTypeImpl(const DataTypes & arguments) c
 
 void FunctionArraySlice::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
-    std::cerr << block.dumpStructure() << std::endl;
-
     auto & result_colum_with_name_and_type = block.getByPosition(result);
     auto & result_column = result_colum_with_name_and_type.column;
     auto & return_type = result_colum_with_name_and_type.type;
     result_column = return_type->createColumn();
 
-    if (return_type->isNull())
-        return;
+    auto array_column = block.getByPosition(arguments[0]).column;
+    auto offset_column = block.getByPosition(arguments[1]).column;
+    auto length_column = block.getByPosition(arguments[2]).column;
 
-    auto & array_column = block.getByPosition(arguments[0]).column;
-    auto & offset_column = block.getByPosition(arguments[1]).column;
-    auto & length_column = block.getByPosition(arguments[2]).column;
+    if (return_type->isNull())
+    {
+        result_column = array_column->clone();
+        return;
+    }
 
     std::unique_ptr<IArraySource> source;
 
-
     size_t size = array_column->size();
     bool is_const = false;
 
@@ -3091,9 +3151,9 @@ void FunctionArraySlice::executeImpl(Block & block, const ColumnNumbers & argume
     auto array = checkAndGetColumn<ColumnArray>(result_column.get());
     if (array)
     {
-        auto & offsets = array->getOffsets();
-        std::cerr << offsets.size()  << " " << array->size()<< std::endl;
-        for (auto & val : offsets)
+        auto &offsets = array->getOffsets();
+        std::cerr << offsets.size() << " " << array->size() << std::endl;
+        for (auto &val : offsets)
             std::cerr << val << ' ';
         std::cerr << std::endl;
     }
@@ -3101,4 +3161,176 @@ void FunctionArraySlice::executeImpl(Block & block, const ColumnNumbers & argume
     std::cerr << block.dumpStructure() << std::endl;
 }
 
+
+/// Implementation of FunctionArrayPush.
+
+DataTypePtr FunctionArrayPush::getReturnTypeImpl(const DataTypes & arguments) const
+{
+    if (arguments[0]->isNull())
+        return arguments[0];
+
+    auto array_type = typeid_cast<DataTypeArray *>(arguments[0].get());
+    if (!array_type)
+        throw Exception("First argument for function " + getName() + " must be an array but it has type "
+                        + arguments[0]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+
+    auto nested_type = array_type->getNestedType();
+
+    DataTypes types = {nested_type, arguments[1]};
+
+    if (foundNumericType(types))
+    {
+        /// Since we have found at least one numeric argument, we infer that all
+        /// the arguments are numeric up to nullity. Let's determine the least
+        /// common type.
+        auto enriched_result_type = Conditional::getArrayType(types);
+        return std::make_shared<DataTypeArray>(enriched_result_type);
+    }
+    else
+    {
+        /// Otherwise all the arguments must have the same type up to nullability or nullity.
+        if (!hasArrayIdenticalTypes(types))
+            throw Exception{"Arguments for function " + getName() + " must have same type or behave as number.",
+                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+
+        return std::make_shared<DataTypeArray>(getArrayElementType(types));
+    }
+}
+
+void FunctionArrayPush::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+{
+    auto & result_colum_with_name_and_type = block.getByPosition(result);
+    auto & result_column = result_colum_with_name_and_type.column;
+    auto & return_type = result_colum_with_name_and_type.type;
+    result_column = return_type->createColumn();
+
+    auto array_column = block.getByPosition(arguments[0]).column;
+    auto appended_column = block.getByPosition(arguments[1]).column;
+
+    if (return_type->isNull())
+    {
+        result_column = array_column->clone();
+        return;
+    }
+
+    std::vector<std::unique_ptr<IArraySource>> sources;
+
+    size_t size = array_column->size();
+    bool is_const = false;
+
+    if (auto const_array_column = typeid_cast<ColumnConst *>(array_column.get()))
+    {
+        is_const = true;
+        array_column = const_array_column->getDataColumnPtr();
+    }
+
+    if (auto argument_column_array = typeid_cast<ColumnArray *>(array_column.get()))
+        sources.push_back(createArraySource(*argument_column_array, is_const, size));
+    else
+        throw Exception{"First arguments for function " + getName() + " must be array.", ErrorCodes::LOGICAL_ERROR};
+
+
+    bool is_appended_const = false;
+    if (auto const_appended_column = typeid_cast<ColumnConst *>(appended_column.get()))
+    {
+        is_appended_const = true;
+        appended_column = const_appended_column->getDataColumnPtr();
+    }
+
+    auto offsets = std::make_shared<ColumnArray::ColumnOffsets_t>(appended_column->size());
+    for (size_t i : ext::range(0, offsets->size()))
+        offsets->getElement(i) = i + 1;
+
+    ColumnArray appended_array_column(appended_column, offsets);
+    sources.push_back(createArraySource(appended_array_column, is_appended_const, size));
+
+    auto sink = createArraySink(typeid_cast<ColumnArray &>(*result_column), size);
+
+    if (push_front)
+        sources[0].swap(sources[1]);
+    concat(sources, *sink);
+}
+
+/// Implementation of FunctionArrayPushFront.
+
+FunctionPtr FunctionArrayPushFront::create(const Context & context)
+{
+    return std::make_shared<FunctionArrayPushFront>();
+}
+
+/// Implementation of FunctionArrayPushBack.
+
+FunctionPtr FunctionArrayPushBack::create(const Context & context)
+{
+    return std::make_shared<FunctionArrayPushBack>();
+}
+
+/// Implementation of FunctionArrayPop.
+
+DataTypePtr FunctionArrayPop::getReturnTypeImpl(const DataTypes & arguments) const
+{
+    if (arguments[0]->isNull())
+        return arguments[0];
+
+    auto array_type = typeid_cast<DataTypeArray *>(arguments[0].get());
+    if (!array_type)
+        throw Exception("First argument for function " + getName() + " must be an array but it has type "
+                        + arguments[0]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+
+    return arguments[0];
+}
+
+void FunctionArrayPop::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
+{
+    auto & result_colum_with_name_and_type = block.getByPosition(result);
+    auto & result_column = result_colum_with_name_and_type.column;
+    auto & return_type = result_colum_with_name_and_type.type;
+    result_column = return_type->createColumn();
+
+    auto array_column = block.getByPosition(arguments[0]).column;
+
+    if (return_type->isNull())
+    {
+        result_column = array_column->clone();
+        return;
+    }
+
+    std::unique_ptr<IArraySource> source;
+
+    size_t size = array_column->size();
+    bool is_const = false;
+
+    if (auto const_array_column = typeid_cast<ColumnConst *>(array_column.get()))
+    {
+        is_const = true;
+        array_column = const_array_column->getDataColumnPtr();
+    }
+
+    if (auto argument_column_array = typeid_cast<ColumnArray *>(array_column.get()))
+        source = createArraySource(*argument_column_array, is_const, size);
+    else
+        throw Exception{"First arguments for function " + getName() + " must be array.", ErrorCodes::LOGICAL_ERROR};
+
+    auto sink = createArraySink(typeid_cast<ColumnArray &>(*result_column), size);
+
+    if (pop_front)
+        sliceFromLeftConstantOffsetUnbounded(*source, *sink, 1);
+    else
+        sliceFromLeftConstantOffsetBounded(*source, *sink, 0, -1);
+}
+
+/// Implementation of FunctionArrayPopFront.
+
+FunctionPtr FunctionArrayPopFront::create(const Context &context)
+{
+    return std::make_shared<FunctionArrayPopFront>();
+}
+
+/// Implementation of FunctionArrayPopBack.
+
+FunctionPtr FunctionArrayPopBack::create(const Context &context)
+{
+    return std::make_shared<FunctionArrayPopBack>();
+}
+
 }
diff --git a/dbms/src/Functions/FunctionsArray.h b/dbms/src/Functions/FunctionsArray.h
index f6cfd4744e3..9d3740309f0 100644
--- a/dbms/src/Functions/FunctionsArray.h
+++ b/dbms/src/Functions/FunctionsArray.h
@@ -1441,10 +1441,94 @@ public:
     void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override;
 
     bool useDefaultImplementationForConstants() const override { return true; }
-    bool useDefaultImplementationForNulls() const { return false; }
+    bool useDefaultImplementationForNulls() const override { return false; }
 };
 
 
+class FunctionArrayPush : public IFunction
+{
+public:
+    FunctionArrayPush(bool push_front, const char * name) : push_front(push_front), name(name) {}
+
+    String getName() const override { return name; }
+
+    bool isVariadic() const override { return false; }
+    size_t getNumberOfArguments() const override { return 2; }
+
+    DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
+
+    void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override;
+
+    bool useDefaultImplementationForConstants() const override { return true; }
+    bool useDefaultImplementationForNulls() const override { return false; }
+
+private:
+    bool push_front;
+    const char * name;
+};
+
+class FunctionArrayPushFront : public FunctionArrayPush
+{
+public:
+    static constexpr auto name = "arrayPushFront";
+
+    static FunctionPtr create(const Context & context);
+
+    FunctionArrayPushFront() : FunctionArrayPush(true, name) {}
+};
+
+class FunctionArrayPushBack : public FunctionArrayPush
+{
+public:
+    static constexpr auto name = "arrayPushBack";
+
+    static FunctionPtr create(const Context & context);
+
+    FunctionArrayPushBack() : FunctionArrayPush(false, name) {}
+};
+
+class FunctionArrayPop : public IFunction
+{
+public:
+    FunctionArrayPop(bool pop_front, const char * name) : pop_front(pop_front), name(name) {}
+
+    String getName() const override { return name; }
+
+    bool isVariadic() const override { return false; }
+    size_t getNumberOfArguments() const override { return 1; }
+
+    DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
+
+    void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override;
+
+    bool useDefaultImplementationForConstants() const override { return true; }
+    bool useDefaultImplementationForNulls() const override { return false; }
+
+private:
+    bool pop_front;
+    const char * name;
+};
+
+class FunctionArrayPopFront : public FunctionArrayPop
+{
+public:
+    static constexpr auto name = "arrayPopFront";
+
+    static FunctionPtr create(const Context & context);
+
+    FunctionArrayPopFront() : FunctionArrayPop(true, name) {}
+};
+
+class FunctionArrayPopBack : public FunctionArrayPop
+{
+public:
+    static constexpr auto name = "arrayPopBack";
+
+    static FunctionPtr create(const Context & context);
+
+    FunctionArrayPopBack() : FunctionArrayPop(false, name) {}
+};
+
 
 struct NameHas { static constexpr auto name = "has"; };
 struct NameIndexOf { static constexpr auto name = "indexOf"; };
diff --git a/dbms/src/Functions/GatherUtils.cpp b/dbms/src/Functions/GatherUtils.cpp
new file mode 100644
index 00000000000..a8079a96fc9
--- /dev/null
+++ b/dbms/src/Functions/GatherUtils.cpp
@@ -0,0 +1,482 @@
+#include <Functions/GatherUtils.h>
+
+namespace DB
+{
+
+/// Creates IArraySource from ColumnArray
+
+template <typename ... Types>
+struct ArraySourceCreator;
+
+template <typename Type, typename ... Types>
+struct ArraySourceCreator<Type, Types ...>
+{
+    static std::unique_ptr<IArraySource> create(const ColumnArray & col, const ColumnUInt8 * null_map, bool is_const, size_t total_rows)
+    {
+        if (typeid_cast<const ColumnVector<Type> *>(&col.getData()))
+        {
+            if (null_map)
+            {
+                if (is_const)
+                    return std::make_unique<ConstSource<NullableArraySource<NumericArraySource<Type>>>>(col, *null_map, total_rows);
+                return std::make_unique<NullableArraySource<NumericArraySource<Type>>>(col, *null_map);
+            }
+            if (is_const)
+                return std::make_unique<ConstSource<NumericArraySource<Type>>>(col, total_rows);
+            return std::make_unique<NumericArraySource<Type>>(col);
+        }
+
+        return ArraySourceCreator<Types...>::create(col, null_map, is_const, total_rows);
+    }
+};
+
+template <>
+struct ArraySourceCreator<>
+{
+    static std::unique_ptr<IArraySource> create(const ColumnArray & col, const ColumnUInt8 * null_map, bool is_const, size_t total_rows)
+    {
+        if (null_map)
+        {
+            if (is_const)
+                return std::make_unique<ConstSource<NullableArraySource<GenericArraySource>>>(col, *null_map, total_rows);
+            return std::make_unique<NullableArraySource<GenericArraySource>>(col, *null_map);
+        }
+        if (is_const)
+            return std::make_unique<ConstSource<GenericArraySource>>(col, total_rows);
+        return std::make_unique<GenericArraySource>(col);
+    }
+};
+
+std::unique_ptr<IArraySource> createArraySource(const ColumnArray & col, bool is_const, size_t total_rows)
+{
+    using Creator = typename ApplyTypeListForClass<ArraySourceCreator, TypeListNumber>::Type;
+    if (auto column_nullable = typeid_cast<const ColumnNullable *>(&col.getData()))
+    {
+        ColumnArray column(column_nullable->getNestedColumn(), col.getOffsetsColumn());
+        return Creator::create(column, &column_nullable->getNullMapConcreteColumn(), is_const, total_rows);
+    }
+    return Creator::create(col, nullptr, is_const, total_rows);
+}
+
+
+/// Creates IArraySink from ColumnArray
+
+template <typename ... Types>
+struct ArraySinkCreator;
+
+template <typename Type, typename ... Types>
+struct ArraySinkCreator<Type, Types ...>
+{
+    static std::unique_ptr<IArraySink> create(ColumnArray & col, ColumnUInt8 * null_map, size_t column_size)
+    {
+        if (typeid_cast<ColumnVector<Type> *>(&col.getData()))
+        {
+            if (null_map)
+                return std::make_unique<NullableArraySink<NumericArraySink<Type>>>(col, *null_map, column_size);
+            return std::make_unique<NumericArraySink<Type>>(col, column_size);
+        }
+
+        return ArraySinkCreator<Types ...>::create(col, null_map, column_size);
+    }
+};
+
+template <>
+struct ArraySinkCreator<>
+{
+    static std::unique_ptr<IArraySink> create(ColumnArray & col, ColumnUInt8 * null_map, size_t column_size)
+    {
+        if (null_map)
+            return std::make_unique<NullableArraySink<GenericArraySink>>(col, *null_map, column_size);
+        return std::make_unique<GenericArraySink>(col, column_size);
+    }
+};
+
+std::unique_ptr<IArraySink> createArraySink(ColumnArray & col, size_t column_size)
+{
+    using Creator = ApplyTypeListForClass<ArraySinkCreator, TypeListNumber>::Type;
+    if (auto column_nullable = typeid_cast<ColumnNullable *>(&col.getData()))
+    {
+        ColumnArray column(column_nullable->getNestedColumn(), col.getOffsetsColumn());
+        return Creator::create(column, &column_nullable->getNullMapConcreteColumn(), column_size);
+    }
+    return Creator::create(col, nullptr, column_size);
+}
+
+
+/// Base classes which selects template function implementation with concrete ArraySource or ArraySink
+/// Derived classes should implement selectImpl for ArraySourceSelector and ArraySinkSelector
+///  or selectSourceSink for ArraySinkSourceSelector
+
+template <typename Base, typename ... Types>
+struct ArraySourceSelector;
+
+template <typename Base, typename Type, typename ... Types>
+struct ArraySourceSelector<Base, Type, Types ...>
+{
+    template <typename ... Args>
+    static void select(IArraySource & source, Args & ... args)
+    {
+        if (auto array = typeid_cast<NumericArraySource<Type> *>(&source))
+            Base::selectImpl(*array, args ...);
+        else if(auto nullable_array = typeid_cast<NullableArraySource<NumericArraySource<Type>> *>(&source))
+            Base::selectImpl(*nullable_array, args ...);
+        else if (auto const_array = typeid_cast<ConstSource<NumericArraySource<Type>> *>(&source))
+            Base::selectImpl(*const_array, args ...);
+        else if(auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<NumericArraySource<Type>>> *>(&source))
+            Base::selectImpl(*const_nullable_array, args ...);
+        else
+            ArraySourceSelector<Base, Types ...>::select(source, args ...);
+    }
+};
+
+template <typename Base>
+struct ArraySourceSelector<Base>
+{
+    template <typename ... Args>
+    static void select(IArraySource & source, Args & ... args)
+    {
+        if (auto array = typeid_cast<GenericArraySource *>(&source))
+            Base::selectImpl(*array, args ...);
+        else if(auto nullable_array = typeid_cast<NullableArraySource<GenericArraySource> *>(&source))
+            Base::selectImpl(*nullable_array, args ...);
+        else if (auto const_array = typeid_cast<ConstSource<GenericArraySource> *>(&source))
+            Base::selectImpl(*const_array, args ...);
+        else if(auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<GenericArraySource>> *>(&source))
+            Base::selectImpl(*const_nullable_array, args ...);
+        else
+            throw Exception(std::string("Unknown ArraySource type: ") + typeid(source).name(), ErrorCodes::LOGICAL_ERROR);
+    }
+};
+
+template <typename Base>
+using GetArraySourceSelector = typename ApplyTypeListForClass<ArraySourceSelector, typename AppendToTypeList<Base, TypeListNumber>::Type>::Type;
+
+template <typename Base, typename ... Types>
+struct ArraySinkSelector;
+
+template <typename Base, typename Type, typename ... Types>
+struct ArraySinkSelector<Base, Type, Types ...>
+{
+    template <typename ... Args>
+    static void select(IArraySink & sink, Args & ... args)
+    {
+        if (auto nullable_numeric_sink = typeid_cast<NullableArraySink<NumericArraySink<Type>> *>(&sink))
+            Base::selectImpl(*nullable_numeric_sink, args ...);
+        else if (auto numeric_sink = typeid_cast<NumericArraySink<Type> *>(&sink))
+            Base::selectImpl(*numeric_sink, args ...);
+        else
+            ArraySinkSelector<Base, Types ...>::select(sink, args ...);
+    }
+};
+
+template <typename Base>
+struct ArraySinkSelector<Base>
+{
+    template <typename ... Args>
+    static void select(IArraySink & sink, Args & ... args)
+    {
+        if (auto nullable_generic_sink = typeid_cast<NullableArraySink<GenericArraySink> *>(&sink))
+            Base::selectImpl(*nullable_generic_sink, args ...);
+        else if (auto generic_sink = typeid_cast<GenericArraySink *>(&sink))
+            Base::selectImpl(*generic_sink, args ...);
+        else
+            throw Exception(std::string("Unknown ArraySink type: ") + typeid(sink).name(), ErrorCodes::LOGICAL_ERROR);
+    }
+};
+
+template <typename Base>
+using GetArraySinkSelector = typename ApplyTypeListForClass<ArraySinkSelector, typename AppendToTypeList<Base, TypeListNumber>::Type>::Type;
+
+template <typename Base>
+struct ArraySinkSourceSelector
+{
+    template <typename ... Args>
+    static void select(IArraySource & source, IArraySink & sink, Args & ... args)
+    {
+        GetArraySinkSelector<Base>::select(sink, source, args ...);
+    }
+
+    template <typename Sink, typename ... Args>
+    static void selectImpl(Sink & sink, IArraySource & source, Args & ... args)
+    {
+        GetArraySourceSelector<Base>::select(source, sink, args ...);
+    }
+
+    template <typename Source, typename Sink, typename ... Args>
+    static void selectImpl(Source & source, Sink & sink, Args & ... args)
+    {
+        Base::selectSourceSink(source, sink, args ...);
+    }
+};
+
+
+/// Algorithms.
+
+/// Appends slices from source to sink. Offsets for sink should be precalculated as start positions of result arrays.
+/// Only for NumericArraySource, because can't insert values in the middle of arbitary column.
+/// Used for array concat implementation.
+template <typename Source, typename Sink>
+static void append(Source & source, Sink & sink)
+{
+    sink.row_num = 0;
+    while (!source.isEnd())
+    {
+        sink.current_offset = sink.offsets[sink.row_num];
+        writeSlice(source.getWhole(), sink);
+        sink.next();
+        source.next();
+    }
+}
+
+struct ArrayAppend : public GetArraySourceSelector<ArrayAppend>
+{
+    template <typename Source, typename Sink>
+    static void selectImpl(Source & source, Sink & sink)
+    {
+        append<Source, Sink>(source, sink);
+    }
+};
+
+template <typename Sink>
+static void append(IArraySource & source, Sink & sink)
+{
+    ArrayAppend::select(source, sink);
+}
+
+/// Concat specialization for GenericArraySource. Because can't use append with arbitrary column type.
+
+template <typename SourceType, typename SinkType>
+struct ConcatGenericImpl
+{
+    static void concat(GenericArraySource * generic_source, SinkType & sink)
+    {
+        auto source = static_cast<SourceType *>(generic_source);
+        writeSlice(source->getWhole(), sink);
+        source->next();
+    }
+};
+
+template <typename Sink>
+static void NO_INLINE concatGeneric(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink & sink)
+{
+    std::vector<GenericArraySource *> generic_sources;
+    std::vector<bool> is_nullable;
+    std::vector<bool> is_const;
+
+    generic_sources.reserve(sources.size());
+    is_nullable.assign(sources.size(), false);
+    is_const.assign(sources.size(), false);
+
+    for (auto i : ext::range(0, sources.size()))
+    {
+        const auto &source = sources[i];
+        if (auto generic_source = typeid_cast<GenericArraySource *>(source.get()))
+            generic_sources.push_back(static_cast<GenericArraySource *>(generic_source));
+        else if (auto const_generic_source = typeid_cast<ConstSource<GenericArraySource> *>(source.get()))
+        {
+            generic_sources.push_back(static_cast<GenericArraySource *>(const_generic_source));
+            is_const[i] = true;
+        }
+        else if (auto nullable_source = typeid_cast<NullableArraySource<GenericArraySource> *>(source.get()))
+        {
+            generic_sources.push_back(static_cast<GenericArraySource *>(nullable_source));
+            is_nullable[i] = true;
+        }
+        else if (auto const_nullable_source = typeid_cast<ConstSource<NullableArraySource<GenericArraySource>> *>(source.get()))
+        {
+            generic_sources.push_back(static_cast<GenericArraySource *>(const_nullable_source));
+            is_nullable[i] = is_const[i] = true;
+        }
+        else
+            throw Exception(std::string("GenericArraySource expected for GenericArraySink, got: ") + typeid(source).name(),
+                            ErrorCodes::LOGICAL_ERROR);
+    }
+
+    while (!sink.isEnd())
+    {
+        for (auto i : ext::range(0, sources.size()))
+        {
+            auto source = generic_sources[i];
+            if (is_const[i])
+            {
+                if (is_nullable[i])
+                    ConcatGenericImpl<ConstSource<NullableArraySource<GenericArraySource>>, Sink>::concat(source, sink);
+                else
+                    ConcatGenericImpl<ConstSource<GenericArraySource>, Sink>::concat(source, sink);
+            }
+            else
+            {
+                if (is_nullable[i])
+                    ConcatGenericImpl<NullableArraySource<GenericArraySource>, Sink>::concat(source, sink);
+                else
+                    ConcatGenericImpl<GenericArraySource, Sink>::concat(source, sink);
+            }
+        }
+        sink.next();
+    }
+}
+
+/// Concat for array sources. Sources must be either all numeric either all generic.
+template <typename Sink>
+void NO_INLINE concat(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink & sink)
+{
+    size_t elements_to_reserve = 0;
+    bool is_first = true;
+
+    /// Prepare offsets column. Offsets should point to starts of result arrays.
+    for (const auto & source : sources)
+    {
+        elements_to_reserve += source->getSizeForReserve();
+        const auto & offsets = source->getOffsets();
+
+        if (is_first)
+        {
+            sink.offsets.resize(source->getColumnSize());
+            memset(&sink.offsets[0], 0, sink.offsets.size() * sizeof(offsets[0]));
+            is_first = false;
+        }
+
+        if (source->isConst())
+        {
+            for (size_t i : ext::range(1, offsets.size()))
+                sink.offsets[i] += offsets[0];
+        }
+        else
+        {
+            for (size_t i : ext::range(1, offsets.size()))
+                sink.offsets[i] += offsets[i - 1] - (i > 1 ? offsets[i - 2] : 0);
+        }
+    }
+
+    for (auto i : ext::range(1, sink.offsets.size()))
+        sink.offsets[i] += sink.offsets[i - 1];
+
+    sink.reserve(elements_to_reserve);
+
+    for (const auto & source : sources)
+    {
+        append<Sink>(*source, sink);
+    }
+}
+
+struct ArrayConcat : public GetArraySinkSelector<ArrayConcat>
+{
+    using Sources = std::vector<std::unique_ptr<IArraySource>>;
+
+    template <typename Sink>
+    static void selectImpl(Sink & sink, Sources & sources)
+    {
+        concat<Sink>(sources, sink);
+    }
+
+    static void selectImpl(GenericArraySink & sink, Sources & sources)
+    {
+        concatGeneric<GenericArraySink>(sources, sink);
+    }
+
+    static void selectImpl(NullableArraySink<GenericArraySink> & sink, Sources & sources)
+    {
+        concatGeneric<NullableArraySink<GenericArraySink>>(sources, sink);
+    }
+};
+
+void concat(std::vector<std::unique_ptr<IArraySource>> & sources, IArraySink & sink)
+{
+    using Sources = std::vector<std::unique_ptr<IArraySource>>;
+    return ArrayConcat::select(sink, sources);
+}
+
+
+/// Slice for array sources.
+
+struct SliceFromLeftConstantOffsetUnboundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceFromLeftConstantOffsetUnboundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, size_t & offset)
+    {
+        sliceFromLeftConstantOffsetUnbounded<Source, Sink>(source, sink, offset);
+    }
+};
+
+struct SliceFromLeftConstantOffsetBoundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceFromLeftConstantOffsetBoundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, size_t & offset, ssize_t & length)
+    {
+        sliceFromLeftConstantOffsetBounded<Source, Sink>(source, sink, offset, length);
+    }
+};
+
+struct SliceFromRightConstantOffsetUnboundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceFromRightConstantOffsetUnboundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, size_t & offset)
+    {
+        sliceFromRightConstantOffsetUnbounded<Source, Sink>(source, sink, offset);
+    }
+};
+
+struct SliceFromRightConstantOffsetBoundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceFromRightConstantOffsetBoundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, size_t & offset, ssize_t & length)
+    {
+        sliceFromRightConstantOffsetBounded<Source, Sink>(source, sink, offset, length);
+    }
+};
+
+struct SliceDynamicOffsetUnboundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceDynamicOffsetUnboundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, IColumn & offset_column)
+    {
+        sliceDynamicOffsetUnbounded<Source, Sink>(source, sink, offset_column);
+    }
+};
+
+struct SliceDynamicOffsetBoundedSelectArraySource
+        : public ArraySinkSourceSelector<SliceDynamicOffsetBoundedSelectArraySource>
+{
+    template <typename Source, typename Sink>
+    static void selectSourceSink(Source & source, Sink & sink, IColumn & offset_column, IColumn & length_column)
+    {
+        sliceDynamicOffsetBounded<Source, Sink>(source, sink, offset_column, length_column);
+    }
+};
+
+void sliceFromLeftConstantOffsetUnbounded(IArraySource & src, IArraySink & sink, size_t offset)
+{
+    SliceFromLeftConstantOffsetUnboundedSelectArraySource::select(src, sink, offset);
+}
+
+void sliceFromLeftConstantOffsetBounded(IArraySource & src, IArraySink & sink, size_t offset, ssize_t length)
+{
+    SliceFromLeftConstantOffsetBoundedSelectArraySource::select(src, sink, offset, length);
+}
+
+void sliceFromRightConstantOffsetUnbounded(IArraySource & src, IArraySink & sink, size_t offset)
+{
+    SliceFromRightConstantOffsetUnboundedSelectArraySource::select(src, sink, offset);
+}
+
+void sliceFromRightConstantOffsetBounded(IArraySource & src, IArraySink & sink, size_t offset, ssize_t length)
+{
+    SliceFromRightConstantOffsetBoundedSelectArraySource::select(src, sink, offset, length);
+}
+
+void sliceDynamicOffsetUnbounded(IArraySource & src, IArraySink & sink, IColumn & offset_column)
+{
+    SliceDynamicOffsetUnboundedSelectArraySource::select(src, sink, offset_column);
+}
+
+void sliceDynamicOffsetBounded(IArraySource & src, IArraySink & sink, IColumn & offset_column, IColumn & length_column)
+{
+    SliceDynamicOffsetBoundedSelectArraySource::select(src, sink, offset_column, length_column);
+}
+
+}
diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index cfd445723f9..95602b04d0a 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -18,7 +18,6 @@
 #include <Core/TypeListNumber.h>
 
 #include <DataTypes/DataTypeTraits.h>
-#include <iostream>
 #include <typeindex>
 
 /** These methods are intended for implementation of functions, that
@@ -83,7 +82,7 @@ struct NumericArraySource : public IArraySource
     size_t row_num = 0;
     ColumnArray::Offset_t prev_offset = 0;
 
-    NumericArraySource(const ColumnArray & arr)
+    explicit NumericArraySource(const ColumnArray & arr)
         : elements(typeid_cast<const ColumnVector<T> &>(arr.getData()).getData()), offsets(arr.getOffsets())
     {
     }
@@ -104,7 +103,7 @@ struct NumericArraySource : public IArraySource
         return row_num;
     }
 
-    const typename ColumnArray::Offsets_t & getOffsets() const
+    const typename ColumnArray::Offsets_t & getOffsets() const override
     {
         return offsets;
     }
@@ -173,14 +172,13 @@ struct ConstSource : public Base
     size_t total_rows;
     size_t row_num = 0;
 
-    /// Base base;
-
-    /// template <typename ColumnType>
     explicit ConstSource(const ColumnConst & col)
         : Base(static_cast<const typename Base::Column &>(col.getDataColumn())), total_rows(col.size())
     {
     }
 
+    /// Constructors for NullableArraySource.
+
     template <typename ColumnType>
     ConstSource(const ColumnType & col, size_t total_rows) : Base(col), total_rows(total_rows)
     {
@@ -220,31 +218,6 @@ struct ConstSource : public Base
     {
         return true;
     }
-
-//    Slice getWhole() const
-//    {
-//        return base.getWhole();
-//    }
-//
-//    Slice getSliceFromLeft(size_t offset) const
-//    {
-//        return base.getSliceFromLeft(offset);
-//    }
-//
-//    Slice getSliceFromLeft(size_t offset, size_t length) const
-//    {
-//        return base.getSliceFromLeft(offset, length);
-//    }
-//
-//    Slice getSliceFromRight(size_t offset) const
-//    {
-//        return base.getSliceFromRight(offset);
-//    }
-//
-//    Slice getSliceFromRight(size_t offset, size_t length) const
-//    {
-//        return base.getSliceFromRight(offset, length);
-//    }
 };
 
 
@@ -259,7 +232,7 @@ struct StringSource
     size_t row_num = 0;
     ColumnString::Offset_t prev_offset = 0;
 
-    StringSource(const ColumnString & col)
+    explicit StringSource(const ColumnString & col)
         : elements(col.getChars()), offsets(col.getOffsets())
     {
     }
@@ -339,7 +312,7 @@ struct FixedStringSource
     size_t string_size;
     size_t row_num = 0;
 
-    FixedStringSource(const ColumnFixedString & col)
+    explicit FixedStringSource(const ColumnFixedString & col)
         : string_size(col.getN())
     {
         const auto & chars = col.getChars();
@@ -539,7 +512,7 @@ struct DynamicStringSource final : IStringSource
 {
     Impl impl;
 
-    DynamicStringSource(const IColumn & col) : impl(static_cast<const typename Impl::Column &>(col)) {}
+    explicit DynamicStringSource(const IColumn & col) : impl(static_cast<const typename Impl::Column &>(col)) {}
 
     void next() override { impl.next(); }
     bool isEnd() const override { return impl.isEnd(); }
@@ -563,7 +536,6 @@ inline std::unique_ptr<IStringSource> createDynamicStringSource(const IColumn &
 using StringSources = std::vector<std::unique_ptr<IStringSource>>;
 
 
-
 struct GenericArraySlice
 {
     const IColumn * elements;
@@ -583,7 +555,7 @@ struct GenericArraySource : public IArraySource
     size_t row_num = 0;
     ColumnArray::Offset_t prev_offset = 0;
 
-    GenericArraySource(const ColumnArray & arr)
+    explicit GenericArraySource(const ColumnArray & arr)
         : elements(arr.getData()), offsets(arr.getOffsets())
     {
     }
@@ -604,7 +576,7 @@ struct GenericArraySource : public IArraySource
         return row_num;
     }
 
-    const typename ColumnArray::Offsets_t & getOffsets() const
+    const typename ColumnArray::Offsets_t & getOffsets() const override
     {
         return offsets;
     }
@@ -702,9 +674,9 @@ struct GenericArraySink : public IArraySink
 template <typename Slice>
 struct NullableArraySlice : public Slice
 {
-    const UInt8 * null_map;
+    const UInt8 * null_map = nullptr;
 
-    NullableArraySlice() {}
+    NullableArraySlice() = default;
     NullableArraySlice(const Slice & base) : Slice(base) {}
 };
 
@@ -771,7 +743,7 @@ struct NullableArraySource : public ArraySource
         return slice;
     }
 
-    bool isNullable() const override
+    bool isNullable() const
     {
         return true;
     }
@@ -794,103 +766,9 @@ struct NullableArraySink : public ArraySink
     }
 };
 
-template <typename ... Types>
-struct ArraySourceCreator;
 
-template <typename Type, typename ... Types>
-struct ArraySourceCreator<Type, Types ...>
-{
-    static std::unique_ptr<IArraySource> create(const ColumnArray & col, const ColumnUInt8 * null_map, bool is_const, size_t total_rows)
-    {
-        std::cerr << "Numeric " << typeid(Type).name() << std::endl;
-        if (typeid_cast<const ColumnVector<Type> *>(&col.getData()))
-        {
-            std::cerr << "Created" << typeid(NumericArraySource<Type>).name() << std::endl;
-            if (null_map)
-            {
-                if (is_const)
-                    return std::make_unique<ConstSource<NullableArraySource<NumericArraySource<Type>>>>(col, *null_map, total_rows);
-                return std::make_unique<NullableArraySource<NumericArraySource<Type>>>(col, *null_map);
-            }
-            if (is_const)
-                return std::make_unique<ConstSource<NumericArraySource<Type>>>(col, total_rows);
-            return std::make_unique<NumericArraySource<Type>>(col);
-        }
-
-        return ArraySourceCreator<Types...>::create(col, null_map, is_const, total_rows);
-    }
-};
-
-template <>
-struct ArraySourceCreator<>
-{
-    static std::unique_ptr<IArraySource> create(const ColumnArray & col, const ColumnUInt8 * null_map, bool is_const, size_t total_rows)
-    {
-        std::cerr << "Generic " << typeid(GenericArraySource).name() << std::endl;
-        if (null_map)
-        {
-            if (is_const)
-                return std::make_unique<ConstSource<NullableArraySource<GenericArraySource>>>(col, *null_map, total_rows);
-            return std::make_unique<NullableArraySource<GenericArraySource>>(col, *null_map);
-        }
-        if (is_const)
-            return std::make_unique<ConstSource<GenericArraySource>>(col, total_rows);
-        return std::make_unique<GenericArraySource>(col);
-    }
-};
-
-inline std::unique_ptr<IArraySource> createArraySource(const ColumnArray & col, bool is_const, size_t total_rows)
-{
-    using Creator = typename ApplyTypeListForClass<ArraySourceCreator, TypeListNumber>::Type;
-    if (auto column_nullable = typeid_cast<const ColumnNullable *>(&col.getData()))
-    {
-        ColumnArray column(column_nullable->getNestedColumn(), col.getOffsetsColumn());
-        return Creator::create(column, &column_nullable->getNullMapConcreteColumn(), is_const, total_rows);
-    }
-    return Creator::create(col, nullptr, is_const, total_rows);
-}
-
-
-template <typename ... Types>
-struct ArraySinkCreator;
-
-template <typename Type, typename ... Types>
-struct ArraySinkCreator<Type, Types ...>
-{
-    static std::unique_ptr<IArraySink> create(ColumnArray & col, ColumnUInt8 * null_map, size_t column_size)
-    {
-        if (typeid_cast<ColumnVector<Type> *>(&col.getData()))
-        {
-            if (null_map)
-                return std::make_unique<NullableArraySink<NumericArraySink<Type>>>(col, *null_map, column_size);
-            return std::make_unique<NumericArraySink<Type>>(col, column_size);
-        }
-
-        return ArraySinkCreator<Types ...>::create(col, null_map, column_size);
-    }
-};
-
-template <>
-struct ArraySinkCreator<>
-{
-    static std::unique_ptr<IArraySink> create(ColumnArray & col, ColumnUInt8 * null_map, size_t column_size)
-    {
-        if (null_map)
-            return std::make_unique<NullableArraySink<GenericArraySink>>(col, *null_map, column_size);
-        return std::make_unique<GenericArraySink>(col, column_size);
-    }
-};
-
-inline std::unique_ptr<IArraySink> createArraySink(ColumnArray & col, size_t column_size)
-{
-    using Creator = ApplyTypeListForClass<ArraySinkCreator, TypeListNumber>::Type;
-    if (auto column_nullable = typeid_cast<ColumnNullable *>(&col.getData()))
-    {
-        ColumnArray column(column_nullable->getNestedColumn(), col.getOffsetsColumn());
-        return Creator::create(column, &column_nullable->getNullMapConcreteColumn(), column_size);
-    }
-    return Creator::create(col, nullptr, column_size);
-}
+std::unique_ptr<IArraySource> createArraySource(const ColumnArray & col, bool is_const, size_t total_rows);
+std::unique_ptr<IArraySink> createArraySink(ColumnArray & col, size_t column_size);
 
 
 template <typename T>
@@ -906,7 +784,7 @@ struct NumericSource
     const T * pos;
     const T * end;
 
-    NumericSource(const Column & col)
+    explicit NumericSource(const Column & col)
     {
         const auto & container = col.getData();
         begin = container.data();
@@ -1013,6 +891,7 @@ inline ALWAYS_INLINE void writeSlice(const StringSource::Slice & slice, FixedStr
     memcpySmallAllowReadWriteOverflow15(&sink.elements[sink.current_offset], slice.data, slice.size);
 }
 
+/// Assuming same types of underlying columns for slice and sink if (ArraySlice, ArraySink) is (GenericArraySlice, GenericArraySink).
 inline ALWAYS_INLINE void writeSlice(const GenericArraySlice & slice, GenericArraySink & sink)
 {
     if (std::type_index(typeid(slice.elements)) == std::type_index(typeid(&sink.elements)))
@@ -1054,7 +933,6 @@ inline ALWAYS_INLINE void writeSlice(const NumericArraySlice<T> & slice, Generic
     sink.current_offset += slice.size;
 }
 
-/// Assuming same types of underlying columns for slice and sink if (ArraySlice, ArraySink) is (GenericArraySlice, GenericArraySink).
 template <typename ArraySlice, typename ArraySink>
 inline ALWAYS_INLINE void writeSlice(const NullableArraySlice<ArraySlice> & slice, NullableArraySink<ArraySink> & sink)
 {
@@ -1064,7 +942,6 @@ inline ALWAYS_INLINE void writeSlice(const NullableArraySlice<ArraySlice> & slic
     writeSlice(static_cast<const ArraySlice &>(slice), static_cast<ArraySink &>(sink));
 }
 
-/// Assuming same types of underlying columns for slice and sink if (ArraySlice, ArraySink) is (GenericArraySlice, GenericArraySink).
 template <typename ArraySlice, typename ArraySink>
 inline ALWAYS_INLINE void writeSlice(const ArraySlice & slice, NullableArraySink<ArraySink> & sink)
 {
@@ -1076,138 +953,6 @@ inline ALWAYS_INLINE void writeSlice(const ArraySlice & slice, NullableArraySink
 
 /// Algorithms
 
-template <typename Source, typename Sink>
-static void append(Source & source, Sink & sink)
-{
-    sink.row_num = 0;
-    while (!source.isEnd())
-    {
-        sink.current_offset = sink.offsets[sink.row_num];
-        writeSlice(source.getWhole(), sink);
-        sink.next();
-        source.next();
-    }
-}
-
-template <typename Base, typename ... Types>
-struct ArraySourceSelector;
-
-template <typename Base, typename Type, typename ... Types>
-struct ArraySourceSelector<Base, Type, Types ...>
-{
-    template <typename ... Args>
-    static void select(IArraySource & source, Args & ... args)
-    {
-        if (auto array = typeid_cast<NumericArraySource<Type> *>(&source))
-            Base::selectImpl(*array, args ...);
-        else if(auto nullable_array = typeid_cast<NullableArraySource<NumericArraySource<Type>> *>(&source))
-            Base::selectImpl(*nullable_array, args ...);
-        else if (auto const_array = typeid_cast<ConstSource<NumericArraySource<Type>> *>(&source))
-            Base::selectImpl(*const_array, args ...);
-        else if(auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<NumericArraySource<Type>>> *>(&source))
-            Base::selectImpl(*const_nullable_array, args ...);
-        else
-            ArraySourceSelector<Base, Types ...>::select(source, args ...);
-    }
-};
-
-template <typename Base>
-struct ArraySourceSelector<Base>
-{
-    template <typename ... Args>
-    static void select(IArraySource & source, Args & ... args)
-    {
-        if (auto array = typeid_cast<GenericArraySource *>(&source))
-            Base::selectImpl(*array, args ...);
-        else if(auto nullable_array = typeid_cast<NullableArraySource<GenericArraySource> *>(&source))
-            Base::selectImpl(*nullable_array, args ...);
-        else if (auto const_array = typeid_cast<ConstSource<GenericArraySource> *>(&source))
-            Base::selectImpl(*const_array, args ...);
-        else if(auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<GenericArraySource>> *>(&source))
-            Base::selectImpl(*const_nullable_array, args ...);
-        else
-            throw Exception(std::string("Unknown ArraySource type: ") + typeid(source).name(), ErrorCodes::LOGICAL_ERROR);
-    }
-};
-
-template <typename Base>
-using GetArraySourceSelector = typename ApplyTypeListForClass<ArraySourceSelector, typename AppendToTypeList<Base, TypeListNumber>::Type>::Type;
-
-template <typename Base, typename ... Types>
-struct ArraySinkSelector;
-
-template <typename Base, typename Type, typename ... Types>
-struct ArraySinkSelector<Base, Type, Types ...>
-{
-    template <typename ... Args>
-    static void select(IArraySink & sink, Args & ... args)
-    {
-        if (auto nullable_numeric_sink = typeid_cast<NullableArraySink<NumericArraySink<Type>> *>(&sink))
-            Base::selectImpl(*nullable_numeric_sink, args ...);
-        else if (auto numeric_sink = typeid_cast<NumericArraySink<Type> *>(&sink))
-            Base::selectImpl(*numeric_sink, args ...);
-        else
-            ArraySinkSelector<Base, Types ...>::select(sink, args ...);
-    }
-};
-
-template <typename Base>
-struct ArraySinkSelector<Base>
-{
-    template <typename ... Args>
-    static void select(IArraySink & sink, Args & ... args)
-    {
-        if (auto nullable_generic_sink = typeid_cast<NullableArraySink<GenericArraySink> *>(&sink))
-            Base::selectImpl(*nullable_generic_sink, args ...);
-        else if (auto generic_sink = typeid_cast<GenericArraySink *>(&sink))
-            Base::selectImpl(*generic_sink, args ...);
-        else
-            throw Exception(std::string("Unknown ArraySink type: ") + typeid(sink).name(), ErrorCodes::LOGICAL_ERROR);
-    }
-};
-
-template <typename Base>
-using GetArraySinkSelector = typename ApplyTypeListForClass<ArraySinkSelector, typename AppendToTypeList<Base, TypeListNumber>::Type>::Type;
-
-template <typename Base>
-struct ArraySinkSourceSelector
-{
-    template <typename ... Args>
-    static void select(IArraySource & source, IArraySink & sink, Args & ... args)
-    {
-        GetArraySinkSelector<Base>::select(sink, source, args ...);
-    }
-
-    template <typename Sink, typename ... Args>
-    static void selectImpl(Sink & sink, IArraySource & source, Args & ... args)
-    {
-        GetArraySourceSelector<Base>::select(source, sink, args ...);
-    }
-
-    template <typename Source, typename Sink, typename ... Args>
-    static void selectImpl(Source & source, Sink & sink, Args & ... args)
-    {
-        Base::selectSourceSink(source, sink, args ...);
-    }
-};
-
-
-struct ArrayAppend : public GetArraySourceSelector<ArrayAppend>
-{
-    template <typename Source, typename Sink>
-    static void selectImpl(Source & source, Sink & sink)
-    {
-        append<Source, Sink>(source, sink);
-    }
-};
-
-template <typename Sink>
-static void append(IArraySource & source, Sink & sink)
-{
-    ArrayAppend::select(source, sink);
-}
-
-
 template <typename SourceA, typename SourceB, typename Sink>
 void NO_INLINE concat(SourceA & src_a, SourceB & src_b, Sink & sink)
 {
@@ -1244,157 +989,8 @@ void NO_INLINE concat(StringSources & sources, Sink && sink)
     }
 }
 
-template <typename SourceType, typename SinkType>
-struct ConcatGenericImpl
-{
-    static void concat(GenericArraySource * generic_source, SinkType & sink)
-    {
-        auto source = static_cast<SourceType *>(generic_source);
-        writeSlice(source->getWhole(), sink);
-        source->next();
-    }
-};
+void concat(std::vector<std::unique_ptr<IArraySource>> & sources, IArraySink & sink);
 
-template <typename Sink>
-static void NO_INLINE concatGeneric(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink & sink)
-{
-    std::vector<GenericArraySource *> generic_sources;
-    std::vector<bool> is_nullable;
-    std::vector<bool> is_const;
-
-    generic_sources.reserve(sources.size());
-    is_nullable.assign(sources.size(), false);
-    is_const.assign(sources.size(), false);
-
-    for (auto i : ext::range(0, sources.size()))
-    {
-        const auto &source = sources[i];
-        if (auto generic_source = typeid_cast<GenericArraySource *>(source.get()))
-            generic_sources.push_back(static_cast<GenericArraySource *>(generic_source));
-        else if (auto const_generic_source = typeid_cast<ConstSource<GenericArraySource> *>(source.get()))
-        {
-            generic_sources.push_back(static_cast<GenericArraySource *>(const_generic_source));
-            is_const[i] = true;
-        }
-        else if (auto nullable_source = typeid_cast<NullableArraySource<GenericArraySource> *>(source.get()))
-        {
-            generic_sources.push_back(static_cast<GenericArraySource *>(nullable_source));
-            is_nullable[i] = true;
-        }
-        else if (auto const_nullable_source = typeid_cast<ConstSource<NullableArraySource<GenericArraySource>> *>(source.get()))
-        {
-            generic_sources.push_back(static_cast<GenericArraySource *>(const_nullable_source));
-            is_nullable[i] = is_const[i] = true;
-        }
-        else
-            throw Exception(std::string("GenericArraySource expected for GenericArraySink, got: ") + typeid(source).name(),
-                            ErrorCodes::LOGICAL_ERROR);
-    }
-
-    while (!sink.isEnd())
-    {
-        for (auto i : ext::range(0, sources.size()))
-        {
-            auto source = generic_sources[i];
-            if (is_const[i])
-            {
-                if (is_nullable[i])
-                    ConcatGenericImpl<ConstSource<NullableArraySource<GenericArraySource>>, Sink>::concat(source, sink);
-                else
-                    ConcatGenericImpl<ConstSource<GenericArraySource>, Sink>::concat(source, sink);
-            }
-            else
-            {
-                if (is_nullable[i])
-                    ConcatGenericImpl<NullableArraySource<GenericArraySource>, Sink>::concat(source, sink);
-                else
-                    ConcatGenericImpl<GenericArraySource, Sink>::concat(source, sink);
-            }
-        }
-        sink.next();
-    }
-}
-
-template <typename Sink>
-void NO_INLINE concat(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink & sink)
-{
-    size_t elements_to_reserve = 0;
-    bool is_first = true;
-    /// Prepare offsets column. Offsets should point to starts of result arrays.
-
-    for (const auto & source : sources)
-    {
-        elements_to_reserve += source->getSizeForReserve();
-        const auto & offsets = source->getOffsets();
-
-        if (is_first)
-        {
-            sink.offsets.resize(source->getColumnSize());
-            memset(&sink.offsets[0], 0, sink.offsets.size() * sizeof(offsets[0]));
-            is_first = false;
-        }
-        std::cerr << "Offsets:";
-        for (size_t i : ext::range(1, offsets.size()))
-        {
-            std::cerr << ' ' << offsets[i];
-        }
-        std::cerr << std::endl;
-
-        if (source->isConst())
-        {
-            for (size_t i : ext::range(1, offsets.size()))
-                sink.offsets[i] += offsets[0];
-        }
-        else
-        {
-            for (size_t i : ext::range(1, offsets.size()))
-                sink.offsets[i] += offsets[i - 1] - (i > 1 ? offsets[i - 2] : 0);
-        }
-    }
-
-    std::cerr << "Sink offsets:";
-    for (size_t i : ext::range(1, sink.offsets.size()))
-    {
-        sink.offsets[i] += sink.offsets[i - 1];
-        std::cerr << ' ' << sink.offsets[i];
-    }
-    std::cerr << std::endl;
-
-    sink.reserve(elements_to_reserve);
-
-    for (const auto & source : sources)
-    {
-        append<Sink>(*source, sink);
-    }
-}
-
-struct ArrayConcat : public GetArraySinkSelector<ArrayConcat>
-{
-    using Sources = std::vector<std::unique_ptr<IArraySource>>;
-
-    template <typename Sink>
-    static void selectImpl(Sink & sink, Sources & sources)
-    {
-        concat<Sink>(sources, sink);
-    }
-
-    static void selectImpl(GenericArraySink & sink, Sources & sources)
-    {
-        concatGeneric<GenericArraySink>(sources, sink);
-    }
-
-    static void selectImpl(NullableArraySink<GenericArraySink> & sink, Sources & sources)
-    {
-        concatGeneric<NullableArraySink<GenericArraySink>>(sources, sink);
-    }
-};
-
-
-inline void concat(std::vector<std::unique_ptr<IArraySource>> & sources, IArraySink & sink)
-{
-    using Sources = std::vector<std::unique_ptr<IArraySource>>;
-    return ArrayConcat::select(sink, sources);
-}
 
 template <typename Source, typename Sink>
 void NO_INLINE sliceFromLeftConstantOffsetUnbounded(Source & src, Sink & sink, size_t offset)
@@ -1558,95 +1154,17 @@ void NO_INLINE sliceDynamicOffsetBounded(Source && src, Sink && sink, IColumn &
     sliceDynamicOffsetBounded(src, sink, offset_column, length_column);
 }
 
-struct SliceFromLeftConstantOffsetUnboundedSelectArraySource
-        : public ArraySinkSourceSelector<SliceFromLeftConstantOffsetUnboundedSelectArraySource>
-{
-    template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, size_t & offset)
-    {
-        sliceFromLeftConstantOffsetUnbounded<Source, Sink>(source, sink, offset);
-    }
-};
+void sliceFromLeftConstantOffsetUnbounded(IArraySource & src, IArraySink & sink, size_t offset);
 
-struct SliceFromLeftConstantOffsetBoundedSelectArraySource
-        : public ArraySinkSourceSelector<SliceFromLeftConstantOffsetBoundedSelectArraySource>
-{
-    template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, size_t & offset, ssize_t & length)
-    {
-        sliceFromLeftConstantOffsetBounded<Source, Sink>(source, sink, offset, length);
-    }
-};
+void sliceFromLeftConstantOffsetBounded(IArraySource & src, IArraySink & sink, size_t offset, ssize_t length);
 
-struct SliceFromRightConstantOffsetUnboundedSelectArraySource
-        : public ArraySinkSourceSelector<SliceFromRightConstantOffsetUnboundedSelectArraySource>
-{
-    template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, size_t & offset)
-    {
-        sliceFromRightConstantOffsetUnbounded<Source, Sink>(source, sink, offset);
-    }
-};
+void sliceFromRightConstantOffsetUnbounded(IArraySource & src, IArraySink & sink, size_t offset);
 
-struct SliceFromRightConstantOffsetBoundedSelectArraySource
-        : public ArraySinkSourceSelector<SliceFromRightConstantOffsetBoundedSelectArraySource>
-{
-    template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, size_t & offset, ssize_t & length)
-    {
-        sliceFromRightConstantOffsetBounded<Source, Sink>(source, sink, offset, length);
-    }
-};
+void sliceFromRightConstantOffsetBounded(IArraySource & src, IArraySink & sink, size_t offset, ssize_t length);
 
-struct SliceDynamicOffsetUnboundedSelectArraySource
-        : public ArraySinkSourceSelector<SliceDynamicOffsetUnboundedSelectArraySource>
-{
-    template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, IColumn & offset_column)
-    {
-        sliceDynamicOffsetUnbounded<Source, Sink>(source, sink, offset_column);
-    }
-};
+void sliceDynamicOffsetUnbounded(IArraySource & src, IArraySink & sink, IColumn & offset_column);
 
-struct SliceDynamicOffsetBoundedSelectArraySource
-        : public ArraySinkSourceSelector<SliceDynamicOffsetBoundedSelectArraySource>
-{
-    template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, IColumn & offset_column, IColumn & length_column)
-    {
-        sliceDynamicOffsetBounded<Source, Sink>(source, sink, offset_column, length_column);
-    }
-};
-
-inline void sliceFromLeftConstantOffsetUnbounded(IArraySource & src, IArraySink & sink, size_t offset)
-{
-    SliceFromLeftConstantOffsetUnboundedSelectArraySource::select(src, sink, offset);
-}
-
-inline void sliceFromLeftConstantOffsetBounded(IArraySource & src, IArraySink & sink, size_t offset, ssize_t length)
-{
-    SliceFromLeftConstantOffsetBoundedSelectArraySource::select(src, sink, offset, length);
-}
-
-inline void sliceFromRightConstantOffsetUnbounded(IArraySource & src, IArraySink & sink, size_t offset)
-{
-    SliceFromRightConstantOffsetUnboundedSelectArraySource::select(src, sink, offset);
-}
-
-inline void sliceFromRightConstantOffsetBounded(IArraySource & src, IArraySink & sink, size_t offset, ssize_t length)
-{
-    SliceFromRightConstantOffsetBoundedSelectArraySource::select(src, sink, offset, length);
-}
-
-inline void sliceDynamicOffsetUnbounded(IArraySource & src, IArraySink & sink, IColumn & offset_column)
-{
-    SliceDynamicOffsetUnboundedSelectArraySource::select(src, sink, offset_column);
-}
-
-inline void sliceDynamicOffsetBounded(IArraySource & src, IArraySink & sink, IColumn & offset_column, IColumn & length_column)
-{
-    SliceDynamicOffsetBoundedSelectArraySource::select(src, sink, offset_column, length_column);
-}
+void sliceDynamicOffsetBounded(IArraySource & src, IArraySink & sink, IColumn & offset_column, IColumn & length_column);
 
 template <typename SourceA, typename SourceB, typename Sink>
 void NO_INLINE conditional(SourceA && src_a, SourceB && src_b, Sink && sink, const PaddedPODArray<UInt8> & condition)

From 09a307b94f545e1e4f1df8342adb1158d46bee4f Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Thu, 24 Aug 2017 18:59:35 +0300
Subject: [PATCH 005/266] removed debug stderr output [#CLICKHOUSE-2090]

---
 dbms/src/Functions/FunctionsArray.cpp | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index ca57755cec1..9637997ba19 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -3146,19 +3146,6 @@ void FunctionArraySlice::executeImpl(Block & block, const ColumnNumbers & argume
         else
             sliceDynamicOffsetBounded(*source, *sink, *offset_column, *length_column);
     }
-
-
-    auto array = checkAndGetColumn<ColumnArray>(result_column.get());
-    if (array)
-    {
-        auto &offsets = array->getOffsets();
-        std::cerr << offsets.size() << " " << array->size() << std::endl;
-        for (auto &val : offsets)
-            std::cerr << val << ' ';
-        std::cerr << std::endl;
-    }
-
-    std::cerr << block.dumpStructure() << std::endl;
 }
 
 

From d8529e1846c579a9bc26947dc2a46f29ed4434a4 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Thu, 24 Aug 2017 21:16:25 +0300
Subject: [PATCH 006/266] unused type alias [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/dbms/src/Functions/GatherUtils.cpp b/dbms/src/Functions/GatherUtils.cpp
index a8079a96fc9..fc10670de00 100644
--- a/dbms/src/Functions/GatherUtils.cpp
+++ b/dbms/src/Functions/GatherUtils.cpp
@@ -382,7 +382,6 @@ struct ArrayConcat : public GetArraySinkSelector<ArrayConcat>
 
 void concat(std::vector<std::unique_ptr<IArraySource>> & sources, IArraySink & sink)
 {
-    using Sources = std::vector<std::unique_ptr<IArraySource>>;
     return ArrayConcat::select(sink, sources);
 }
 

From d213efa97429eb5d7fe253008cf5734949df4d77 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Thu, 24 Aug 2017 21:59:28 +0300
Subject: [PATCH 007/266] fixed slice for nullable index [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.h | 27 +++++++++++++++------------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index 95602b04d0a..90ffb574f14 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -1052,14 +1052,15 @@ template <typename Source, typename Sink>
 void NO_INLINE sliceDynamicOffsetUnbounded(Source & src, Sink & sink, IColumn & offset_column)
 {
     const bool is_null = offset_column.isNull();
-    const bool is_nullable = offset_column.isNullable();
-    auto null_map = is_nullable ? &static_cast<ColumnNullable &>(offset_column).getNullMapConcreteColumn().getData() : nullptr;
+    auto * nullable = typeid_cast<ColumnNullable *>(&offset_column);
+    ColumnUInt8::Container_t * null_map = nullable ? &nullable->getNullMapConcreteColumn().getData() : nullptr;
+    IColumn * nested_column = nullable ? nullable->getNestedColumn().get() : &offset_column;
 
     while (!src.isEnd())
     {
         auto row_num = src.rowNum();
-        bool has_offset = !is_null && !(is_nullable && (*null_map)[row_num]);
-        Int64 offset = has_offset ? offset_column.getInt(row_num) : 1;
+        bool has_offset = !is_null && !(null_map && (*null_map)[row_num]);
+        Int64 offset = has_offset ? nested_column->getInt(row_num) : 1;
 
         if (offset != 0)
         {
@@ -1082,20 +1083,22 @@ template <typename Source, typename Sink>
 void NO_INLINE sliceDynamicOffsetBounded(Source & src, Sink & sink, IColumn & offset_column, IColumn & length_column)
 {
     const bool is_offset_null = offset_column.isNull();
-    const bool is_offset_nullable = offset_column.isNullable();
-    auto offset_null_map = is_offset_nullable ? &static_cast<ColumnNullable &>(offset_column).getNullMapConcreteColumn().getData() : nullptr;
+    auto * offset_nullable = typeid_cast<ColumnNullable *>(&offset_column);
+    ColumnUInt8::Container_t * offset_null_map = offset_nullable ? &offset_nullable->getNullMapConcreteColumn().getData() : nullptr;
+    IColumn * offset_nested_column = offset_nullable ? offset_nullable->getNestedColumn().get() : &offset_column;
 
     const bool is_length_null = length_column.isNull();
-    const bool is_length_nullable = length_column.isNullable();
-    auto length_null_map = is_length_nullable ? &static_cast<ColumnNullable &>(length_column).getNullMapConcreteColumn().getData() : nullptr;
+    auto * length_nullable = typeid_cast<ColumnNullable *>(&length_column);
+    ColumnUInt8::Container_t * length_null_map = length_nullable ? &length_nullable->getNullMapConcreteColumn().getData() : nullptr;
+    IColumn * length_nested_column = length_nullable ? length_nullable->getNestedColumn().get() : &length_column;
 
     while (!src.isEnd())
     {
         size_t row_num = src.rowNum();
-        bool has_offset = !is_offset_null && !(is_offset_nullable && (*offset_null_map)[row_num]);
-        bool has_length = !is_length_null && !(is_length_nullable && (*length_null_map)[row_num]);
-        Int64 offset = has_offset ? offset_column.getInt(row_num) : 1;
-        Int64 size = has_length ? length_column.getInt(row_num) : static_cast<Int64>(src.getElementSize());
+        bool has_offset = !is_offset_null && !(offset_null_map && (*offset_null_map)[row_num]);
+        bool has_length = !is_length_null && !(length_null_map && (*length_null_map)[row_num]);
+        Int64 offset = has_offset ? offset_nested_column->getInt(row_num) : 1;
+        Int64 size = has_length ? length_nested_column->getInt(row_num) : static_cast<Int64>(src.getElementSize());
 
         if (size < 0)
             size += offset > 0 ? static_cast<Int64>(src.getElementSize()) - (offset - 1) : -offset;

From f70ead25394f03ed51e099be4980afb4240ac3f5 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Thu, 24 Aug 2017 22:39:30 +0300
Subject: [PATCH 008/266] added test [#CLICKHOUSE-2090]

---
 ..._functions_concat_slice_push_pop.reference | 1216 +++++++++++++++++
 ..._array_functions_concat_slice_push_pop.sql |  366 +++++
 2 files changed, 1582 insertions(+)
 create mode 100644 dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.reference
 create mode 100644 dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.sql

diff --git a/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.reference b/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.reference
new file mode 100644
index 00000000000..e46a94775cd
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.reference
@@ -0,0 +1,1216 @@
+const args
+concat
+[]
+[]
+[]
+[NULL]
+[NULL,1]
+[1,2,-1,-2,0.3,0.7,NULL]
+\N
+\N
+[1,2,3,4]
+[1,2,3,4]
+[]
+['abc','def','gh','qwe']
+[1,NULL,2,3,NULL,4]
+[1,NULL,2,3,4]
+slice
+\N
+[1,2,3,4,5,6]
+[2,3,4,5,6]
+[1,2,3,4]
+[1,2,3,4]
+[4,5,6]
+[2,3,4]
+[2,3,4]
+[3,4]
+[3,4]
+[]
+[]
+[]
+[]
+[]
+[2,NULL,4,5]
+['b','c','d']
+['b',NULL,'d']
+push back
+\N
+[1,1]
+[NULL,1]
+[0.5,0.7,1]
+[1,-1]
+['a','b','cd']
+[1]
+[-1]
+push front
+\N
+[1,1]
+[1,NULL]
+[1,0.5,0.7]
+[-1,1]
+['cd','a','b']
+[1]
+[-1]
+pop back
+\N
+[]
+[]
+[1,2]
+[0.1,0.2]
+['a','b']
+pop front
+\N
+[]
+[]
+[2,3]
+[0.2,0.3]
+['b','c']
+
+table
+[]	[]	1	\N	1	\N
+[]	[1]	1	\N	1	\N
+[1,2,3,4,5]	[6,7]	2	\N	1	\N
+[1,2,3,4,5,6,7]	[8]	2	2	3	3
+[1,2,3,4,5,6,7]	[]	2	\N	-3	-3
+[1,2,3,4,5,6,7]	[]	2	\N	-3	\N
+[1,2,3,4,5,6,7]	[]	-5	-5	4	4
+[1,2,3,4,5,6,7]	[]	-5	-5	-3	-3
+concat arr1, arr2
+[]	[]	[]
+[1]	[]	[1]
+[1,2,3,4,5,6,7]	[1,2,3,4,5]	[6,7]
+[1,2,3,4,5,6,7,8]	[1,2,3,4,5,6,7]	[8]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[]
+concat arr1, arr2, arr1
+[]	[]	[]
+[1]	[]	[1]
+[1,2,3,4,5,6,7,1,2,3,4,5]	[1,2,3,4,5]	[6,7]
+[1,2,3,4,5,6,7,8,1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[8]
+[1,2,3,4,5,6,7,1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[]
+[1,2,3,4,5,6,7,1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[]
+[1,2,3,4,5,6,7,1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[]
+[1,2,3,4,5,6,7,1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[]
+arraySlice(arr1, o, l)
+[]	1	1	[]
+[]	1	1	[]
+[1,2,3,4,5]	2	1	[2]
+[1,2,3,4,5,6,7]	2	3	[2,3,4]
+[1,2,3,4,5,6,7]	2	-3	[2,3,4]
+[1,2,3,4,5,6,7]	2	-3	[2,3,4]
+[1,2,3,4,5,6,7]	-5	4	[3,4,5,6]
+[1,2,3,4,5,6,7]	-5	-3	[3,4]
+arraySlice(arr1, no, nl)
+[]	\N	\N	[]
+[]	\N	\N	[]
+[1,2,3,4,5]	\N	\N	[1,2,3,4,5]
+[1,2,3,4,5,6,7]	2	3	[2,3,4]
+[1,2,3,4,5,6,7]	\N	-3	[1,2,3,4]
+[1,2,3,4,5,6,7]	\N	\N	[1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	-5	4	[3,4,5,6]
+[1,2,3,4,5,6,7]	-5	-3	[3,4]
+arraySlice(arr1, 2, l)
+[]	2	1	[]
+[]	2	1	[]
+[1,2,3,4,5]	2	1	[2]
+[1,2,3,4,5,6,7]	2	3	[2,3,4]
+[1,2,3,4,5,6,7]	2	-3	[2,3,4]
+[1,2,3,4,5,6,7]	2	-3	[2,3,4]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	-3	[2,3,4]
+arraySlice(arr1, o, 2)
+[]	1	2	[]
+[]	1	2	[]
+[1,2,3,4,5]	2	2	[2,3]
+[1,2,3,4,5,6,7]	2	2	[2,3]
+[1,2,3,4,5,6,7]	2	2	[2,3]
+[1,2,3,4,5,6,7]	2	2	[2,3]
+[1,2,3,4,5,6,7]	-5	2	[3,4]
+[1,2,3,4,5,6,7]	-5	2	[3,4]
+arraySlice(arr1, 2, nl)
+[]	2	\N	[]
+[]	2	\N	[]
+[1,2,3,4,5]	2	\N	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	3	[2,3,4]
+[1,2,3,4,5,6,7]	2	-3	[2,3,4]
+[1,2,3,4,5,6,7]	2	\N	[2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	-3	[2,3,4]
+arraySlice(arr1, no, 2)
+[]	\N	2	[]
+[]	\N	2	[]
+[1,2,3,4,5]	\N	2	[1,2]
+[1,2,3,4,5,6,7]	2	2	[2,3]
+[1,2,3,4,5,6,7]	\N	2	[1,2]
+[1,2,3,4,5,6,7]	\N	2	[1,2]
+[1,2,3,4,5,6,7]	-5	2	[3,4]
+[1,2,3,4,5,6,7]	-5	2	[3,4]
+arraySlice(arr1, -4, l)
+[]	2	1	[]
+[]	2	1	[]
+[1,2,3,4,5]	2	1	[2]
+[1,2,3,4,5,6,7]	2	3	[4,5,6]
+[1,2,3,4,5,6,7]	2	-3	[4]
+[1,2,3,4,5,6,7]	2	-3	[4]
+[1,2,3,4,5,6,7]	2	4	[4,5,6,7]
+[1,2,3,4,5,6,7]	2	-3	[4]
+arraySlice(arr1, o, -2)
+[]	1	2	[]
+[]	1	2	[]
+[1,2,3,4,5]	2	2	[2,3]
+[1,2,3,4,5,6,7]	2	2	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	2	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	2	[2,3,4,5]
+[1,2,3,4,5,6,7]	-5	2	[3,4,5]
+[1,2,3,4,5,6,7]	-5	2	[3,4,5]
+arraySlice(arr1, -4, nl)
+[]	2	\N	[]
+[]	2	\N	[]
+[1,2,3,4,5]	2	\N	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	3	[4,5,6]
+[1,2,3,4,5,6,7]	2	-3	[4]
+[1,2,3,4,5,6,7]	2	\N	[4,5,6,7]
+[1,2,3,4,5,6,7]	2	4	[4,5,6,7]
+[1,2,3,4,5,6,7]	2	-3	[4]
+arraySlice(arr1, no, -2)
+[]	\N	2	[]
+[]	\N	2	[]
+[1,2,3,4,5]	\N	2	[1,2,3]
+[1,2,3,4,5,6,7]	2	2	[2,3,4,5]
+[1,2,3,4,5,6,7]	\N	2	[1,2,3,4,5]
+[1,2,3,4,5,6,7]	\N	2	[1,2,3,4,5]
+[1,2,3,4,5,6,7]	-5	2	[3,4,5]
+[1,2,3,4,5,6,7]	-5	2	[3,4,5]
+arraySlice(arr1, 2, 4)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+arraySlice(arr1, 2, -4)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[]
+[1,2,3,4,5,6,7]	2	4	[2,3]
+[1,2,3,4,5,6,7]	2	4	[2,3]
+[1,2,3,4,5,6,7]	2	4	[2,3]
+[1,2,3,4,5,6,7]	2	4	[2,3]
+[1,2,3,4,5,6,7]	2	4	[2,3]
+arraySlice(arr1, -4, 2)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[2,3]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+arraySlice(arr1, -4, -1)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+arrayPushFront(arr1, 1)
+[]	[1]
+[]	[]
+[1,2,3,4,5]	[1,2,3,4,5]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+arrayPushFront(arr1, 0.1)
+[]	[0.1]
+[]	[]
+[1,2,3,4,5]	[1,2,3,4,5]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+arrayPushFront(arr1, l)
+[]	[1]
+[]	[1]
+[1,2,3,4,5]	[1,1,2,3,4,5]
+[1,2,3,4,5,6,7]	[3,1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[-3,1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[-3,1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[4,1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[-3,1,2,3,4,5,6,7]
+arrayPushFront(arr1, nl)
+[]	[NULL]
+[]	[NULL]
+[1,2,3,4,5]	[NULL,1,2,3,4,5]
+[1,2,3,4,5,6,7]	[3,1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[-3,1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[NULL,1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[4,1,2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[-3,1,2,3,4,5,6,7]
+arrayPushFront([1, 2, 3], l)
+[1,1,1,1]
+[1]
+[1]
+[1]
+[1]
+[1]
+[2]
+[3]
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+[NULL,1,1,1]
+[1]
+[1]
+[1]
+[1]
+[1]
+[2]
+[3]
+arrayPushBack(arr1, 1)
+[]	[1]
+[]	[]
+[1,2,3,4,5]	[2,3,4,5,1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,1]
+arrayPushBack(arr1, 0.1)
+[]	[0.1]
+[]	[]
+[1,2,3,4,5]	[2,3,4,5,0.1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,0.1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,0.1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,0.1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,0.1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,0.1]
+arrayPushBack(arr1, l)
+[]	[1]
+[]	[1]
+[1,2,3,4,5]	[1,2,3,4,5,1]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,3]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,-3]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,-3]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,4]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,-3]
+arrayPushBack(arr1, nl)
+[]	[NULL]
+[]	[NULL]
+[1,2,3,4,5]	[1,2,3,4,5,NULL]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,3]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,-3]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,NULL]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,4]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,-3]
+arrayPushBack([1, 2, 3], l)
+[1,1,1,1]
+[1]
+[1]
+[3]
+[-3]
+[-3]
+[4]
+[-3]
+arrayPushBack([1, 2, 3], nl)
+[1,1,1,NULL]
+[NULL]
+[NULL]
+[3]
+[-3]
+[NULL]
+[4]
+[-3]
+arrayPopFront(arr1)
+[]	[]
+[]	[]
+[1,2,3,4,5]	[2,3,4,5]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7]
+arrayPopBack(arr1)
+[]	[]
+[]	[]
+[1,2,3,4,5]	[1,2,3,4]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6]
+
+table
+[]	[]	1	\N	1	\N
+[]	[1,NULL]	1	\N	1	\N
+[1,2,3,4,5]	[6,NULL]	2	\N	1	\N
+[1,NULL,3,4,NULL,6,7]	[8]	2	2	3	3
+[1,2,3,NULL,5,6,7]	[NULL,1]	2	\N	-3	-3
+[1,2,3,4,5,NULL,7]	[1,NULL]	2	\N	-3	\N
+[1,2,3,4,5,6,7]	[1,2]	-5	-5	4	4
+[1,NULL,3,NULL,5,6,7]	[]	-5	-5	-3	-3
+concat arr1, arr2
+[]	[]	[]
+[1,NULL]	[]	[1,NULL]
+[1,2,3,4,5,6,NULL]	[1,2,3,4,5]	[6,NULL]
+[1,NULL,3,4,NULL,6,7,8]	[1,NULL,3,4,NULL,6,7]	[8]
+[1,2,3,NULL,5,6,7,NULL,1]	[1,2,3,NULL,5,6,7]	[NULL,1]
+[1,2,3,4,5,NULL,7,1,NULL]	[1,2,3,4,5,NULL,7]	[1,NULL]
+[1,2,3,4,5,6,7,1,2]	[1,2,3,4,5,6,7]	[1,2]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7]	[]
+concat arr1, arr2, arr1
+[]	[]	[]
+[1,NULL]	[]	[1,NULL]
+[1,2,3,4,5,6,NULL,1,2,3,4,5]	[1,2,3,4,5]	[6,NULL]
+[1,NULL,3,4,NULL,6,7,8,1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7]	[8]
+[1,2,3,NULL,5,6,7,NULL,1,1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7]	[NULL,1]
+[1,2,3,4,5,NULL,7,1,NULL,1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7]	[1,NULL]
+[1,2,3,4,5,6,7,1,2,1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[1,2]
+[1,NULL,3,NULL,5,6,7,1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7]	[]
+arraySlice(arr1, o, l)
+[]	1	1	[]
+[]	1	1	[]
+[1,2,3,4,5]	2	1	[2]
+[1,NULL,3,4,NULL,6,7]	2	3	[NULL,3,4]
+[1,2,3,NULL,5,6,7]	2	-3	[2,3,NULL]
+[1,2,3,4,5,NULL,7]	2	-3	[2,3,4]
+[1,2,3,4,5,6,7]	-5	4	[3,4,5,6]
+[1,NULL,3,NULL,5,6,7]	-5	-3	[3,NULL]
+arraySlice(arr1, no, nl)
+[]	\N	\N	[]
+[]	\N	\N	[]
+[1,2,3,4,5]	\N	\N	[1,2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	2	3	[NULL,3,4]
+[1,2,3,NULL,5,6,7]	\N	-3	[1,2,3,NULL]
+[1,2,3,4,5,NULL,7]	\N	\N	[1,2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	-5	4	[3,4,5,6]
+[1,NULL,3,NULL,5,6,7]	-5	-3	[3,NULL]
+arraySlice(arr1, 2, l)
+[]	2	1	[]
+[]	2	1	[]
+[1,2,3,4,5]	2	1	[2]
+[1,NULL,3,4,NULL,6,7]	2	3	[NULL,3,4]
+[1,2,3,NULL,5,6,7]	2	-3	[2,3,NULL]
+[1,2,3,4,5,NULL,7]	2	-3	[2,3,4]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,NULL,3,NULL,5,6,7]	2	-3	[NULL,3,NULL]
+arraySlice(arr1, o, 2)
+[]	1	2	[]
+[]	1	2	[]
+[1,2,3,4,5]	2	2	[2,3]
+[1,NULL,3,4,NULL,6,7]	2	2	[NULL,3]
+[1,2,3,NULL,5,6,7]	2	2	[2,3]
+[1,2,3,4,5,NULL,7]	2	2	[2,3]
+[1,2,3,4,5,6,7]	-5	2	[3,4]
+[1,NULL,3,NULL,5,6,7]	-5	2	[3,NULL]
+arraySlice(arr1, 2, nl)
+[]	2	\N	[]
+[]	2	\N	[]
+[1,2,3,4,5]	2	\N	[2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	2	3	[NULL,3,4]
+[1,2,3,NULL,5,6,7]	2	-3	[2,3,NULL]
+[1,2,3,4,5,NULL,7]	2	\N	[2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,NULL,3,NULL,5,6,7]	2	-3	[NULL,3,NULL]
+arraySlice(arr1, no, 2)
+[]	\N	2	[]
+[]	\N	2	[]
+[1,2,3,4,5]	\N	2	[1,2]
+[1,NULL,3,4,NULL,6,7]	2	2	[NULL,3]
+[1,2,3,NULL,5,6,7]	\N	2	[1,2]
+[1,2,3,4,5,NULL,7]	\N	2	[1,2]
+[1,2,3,4,5,6,7]	-5	2	[3,4]
+[1,NULL,3,NULL,5,6,7]	-5	2	[3,NULL]
+arraySlice(arr1, -4, l)
+[]	2	1	[]
+[]	2	1	[]
+[1,2,3,4,5]	2	1	[2]
+[1,NULL,3,4,NULL,6,7]	2	3	[4,NULL,6]
+[1,2,3,NULL,5,6,7]	2	-3	[NULL]
+[1,2,3,4,5,NULL,7]	2	-3	[4]
+[1,2,3,4,5,6,7]	2	4	[4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	2	-3	[NULL]
+arraySlice(arr1, o, -2)
+[]	1	2	[]
+[]	1	2	[]
+[1,2,3,4,5]	2	2	[2,3]
+[1,NULL,3,4,NULL,6,7]	2	2	[NULL,3,4,NULL]
+[1,2,3,NULL,5,6,7]	2	2	[2,3,NULL,5]
+[1,2,3,4,5,NULL,7]	2	2	[2,3,4,5]
+[1,2,3,4,5,6,7]	-5	2	[3,4,5]
+[1,NULL,3,NULL,5,6,7]	-5	2	[3,NULL,5]
+arraySlice(arr1, -4, nl)
+[]	2	\N	[]
+[]	2	\N	[]
+[1,2,3,4,5]	2	\N	[2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	2	3	[4,NULL,6]
+[1,2,3,NULL,5,6,7]	2	-3	[NULL]
+[1,2,3,4,5,NULL,7]	2	\N	[4,5,NULL,7]
+[1,2,3,4,5,6,7]	2	4	[4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	2	-3	[NULL]
+arraySlice(arr1, no, -2)
+[]	\N	2	[]
+[]	\N	2	[]
+[1,2,3,4,5]	\N	2	[1,2,3]
+[1,NULL,3,4,NULL,6,7]	2	2	[NULL,3,4,NULL]
+[1,2,3,NULL,5,6,7]	\N	2	[1,2,3,NULL,5]
+[1,2,3,4,5,NULL,7]	\N	2	[1,2,3,4,5]
+[1,2,3,4,5,6,7]	-5	2	[3,4,5]
+[1,NULL,3,NULL,5,6,7]	-5	2	[3,NULL,5]
+arraySlice(arr1, 2, 4)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	2	4	[NULL,3,4,NULL]
+[1,2,3,NULL,5,6,7]	2	4	[2,3,NULL,5]
+[1,2,3,4,5,NULL,7]	2	4	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,NULL,3,NULL,5,6,7]	2	4	[NULL,3,NULL,5]
+arraySlice(arr1, 2, -4)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[]
+[1,NULL,3,4,NULL,6,7]	2	4	[NULL,3]
+[1,2,3,NULL,5,6,7]	2	4	[2,3]
+[1,2,3,4,5,NULL,7]	2	4	[2,3]
+[1,2,3,4,5,6,7]	2	4	[2,3]
+[1,NULL,3,NULL,5,6,7]	2	4	[NULL,3]
+arraySlice(arr1, -4, 2)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[2,3]
+[1,NULL,3,4,NULL,6,7]	2	4	[4,NULL]
+[1,2,3,NULL,5,6,7]	2	4	[NULL,5]
+[1,2,3,4,5,NULL,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,NULL,3,NULL,5,6,7]	2	4	[NULL,5]
+arraySlice(arr1, -4, -1)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[]
+[1,NULL,3,4,NULL,6,7]	2	4	[4,NULL]
+[1,2,3,NULL,5,6,7]	2	4	[NULL,5]
+[1,2,3,4,5,NULL,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,NULL,3,NULL,5,6,7]	2	4	[NULL,5]
+arrayPushFront(arr1, 1)
+[]	[1]
+[]	[]
+[1,2,3,4,5]	[1,2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7]
+[1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7]
+[1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7]
+arrayPushFront(arr1, 0.1)
+[]	[0.1]
+[]	[]
+[1,2,3,4,5]	[1,2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7]
+[1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7]
+[1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7]
+arrayPushFront(arr1, l)
+[]	[1]
+[]	[1]
+[1,2,3,4,5]	[1,1,2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	[3,1,NULL,3,4,NULL,6,7]
+[1,2,3,NULL,5,6,7]	[-3,1,2,3,NULL,5,6,7]
+[1,2,3,4,5,NULL,7]	[-3,1,2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	[4,1,2,3,4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	[-3,1,NULL,3,NULL,5,6,7]
+arrayPushFront(arr1, nl)
+[]	[NULL]
+[]	[NULL]
+[1,2,3,4,5]	[NULL,1,2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	[3,1,NULL,3,4,NULL,6,7]
+[1,2,3,NULL,5,6,7]	[-3,1,2,3,NULL,5,6,7]
+[1,2,3,4,5,NULL,7]	[NULL,1,2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	[4,1,2,3,4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	[-3,1,NULL,3,NULL,5,6,7]
+arrayPushFront([1, 2, 3], l)
+[1,1,1,1]
+[1]
+[1]
+[1]
+[1]
+[1]
+[2]
+[3]
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+[NULL,1,1,1]
+[1]
+[1]
+[1]
+[1]
+[1]
+[2]
+[3]
+arrayPushBack(arr1, 1)
+[]	[1]
+[]	[]
+[1,2,3,4,5]	[2,3,4,5,1]
+[1,NULL,3,4,NULL,6,7]	[NULL,3,4,NULL,6,7,1]
+[1,2,3,NULL,5,6,7]	[2,3,NULL,5,6,7,1]
+[1,2,3,4,5,NULL,7]	[2,3,4,5,NULL,7,1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,1]
+[1,NULL,3,NULL,5,6,7]	[NULL,3,NULL,5,6,7,1]
+arrayPushBack(arr1, 0.1)
+[]	[0.1]
+[]	[]
+[1,2,3,4,5]	[2,3,4,5,0.1]
+[1,NULL,3,4,NULL,6,7]	[NULL,3,4,NULL,6,7,0.1]
+[1,2,3,NULL,5,6,7]	[2,3,NULL,5,6,7,0.1]
+[1,2,3,4,5,NULL,7]	[2,3,4,5,NULL,7,0.1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,0.1]
+[1,NULL,3,NULL,5,6,7]	[NULL,3,NULL,5,6,7,0.1]
+arrayPushBack(arr1, l)
+[]	[1]
+[]	[1]
+[1,2,3,4,5]	[1,2,3,4,5,1]
+[1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7,3]
+[1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7,-3]
+[1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7,-3]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,4]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7,-3]
+arrayPushBack(arr1, nl)
+[]	[NULL]
+[]	[NULL]
+[1,2,3,4,5]	[1,2,3,4,5,NULL]
+[1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7,3]
+[1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7,-3]
+[1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7,NULL]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,4]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7,-3]
+arrayPushBack([1, 2, 3], l)
+[1,1,1,1]
+[1]
+[1]
+[3]
+[-3]
+[-3]
+[4]
+[-3]
+arrayPushBack([1, 2, 3], nl)
+[1,1,1,NULL]
+[NULL]
+[NULL]
+[3]
+[-3]
+[NULL]
+[4]
+[-3]
+arrayPopFront(arr1)
+[]	[]
+[]	[]
+[1,2,3,4,5]	[2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	[NULL,3,4,NULL,6,7]
+[1,2,3,NULL,5,6,7]	[2,3,NULL,5,6,7]
+[1,2,3,4,5,NULL,7]	[2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	[NULL,3,NULL,5,6,7]
+arrayPopBack(arr1)
+[]	[]
+[]	[]
+[1,2,3,4,5]	[1,2,3,4]
+[1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6]
+[1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6]
+[1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6]
+
+table
+[]	[]	1	\N	1	\N
+[]	[1,2]	1	\N	1	\N
+[1,2,3,4,5]	[6,7]	2	\N	1	\N
+[1,NULL,3,4,NULL,6,7]	[8]	2	2	3	3
+[1,2,3,NULL,5,6,7]	[0,1]	2	\N	-3	-3
+[1,2,3,4,5,NULL,7]	[1,2]	2	\N	-3	\N
+[1,2,3,4,5,6,7]	[1,2]	-5	-5	4	4
+[1,NULL,3,NULL,5,6,7]	[]	-5	-5	-3	-3
+concat arr1, arr2
+[]	[]	[]
+[1,2]	[]	[1,2]
+[1,2,3,4,5,6,7]	[1,2,3,4,5]	[6,7]
+[1,NULL,3,4,NULL,6,7,8]	[1,NULL,3,4,NULL,6,7]	[8]
+[1,2,3,NULL,5,6,7,0,1]	[1,2,3,NULL,5,6,7]	[0,1]
+[1,2,3,4,5,NULL,7,1,2]	[1,2,3,4,5,NULL,7]	[1,2]
+[1,2,3,4,5,6,7,1,2]	[1,2,3,4,5,6,7]	[1,2]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7]	[]
+concat arr1, arr2, arr1
+[]	[]	[]
+[1,2]	[]	[1,2]
+[1,2,3,4,5,6,7,1,2,3,4,5]	[1,2,3,4,5]	[6,7]
+[1,NULL,3,4,NULL,6,7,8,1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7]	[8]
+[1,2,3,NULL,5,6,7,0,1,1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7]	[0,1]
+[1,2,3,4,5,NULL,7,1,2,1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7]	[1,2]
+[1,2,3,4,5,6,7,1,2,1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[1,2]
+[1,NULL,3,NULL,5,6,7,1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7]	[]
+[]	[]	1	\N	1	\N
+[]	[1,2]	1	\N	1	\N
+[1,2,3,4,5]	[6,7]	2	\N	1	\N
+[1,NULL,3,4,NULL,6,7]	[8]	2	2	3	3
+[1,2,3,NULL,5,6,7]	[0,1]	2	\N	-3	-3
+[1,2,3,4,5,NULL,7]	[1,2]	2	\N	-3	\N
+[1,2,3,4,5,6,7]	[1,2]	-5	-5	4	4
+[1,NULL,3,NULL,5,6,7]	[]	-5	-5	-3	-3
+concat arr1, arr2
+[]	[]	[]
+[1,2]	[]	[1,2]
+[1,2,3,4,5,6,7]	[1,2,3,4,5]	[6,7]
+[1,NULL,3,4,NULL,6,7,8]	[1,NULL,3,4,NULL,6,7]	[8]
+[1,2,3,NULL,5,6,7,0,1]	[1,2,3,NULL,5,6,7]	[0,1]
+[1,2,3,4,5,NULL,7,1,2]	[1,2,3,4,5,NULL,7]	[1,2]
+[1,2,3,4,5,6,7,1,2]	[1,2,3,4,5,6,7]	[1,2]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7]	[]
+concat arr1, arr2, arr1
+[]	[]	[]
+[1,2]	[]	[1,2]
+[1,2,3,4,5,6,7,1,2,3,4,5]	[1,2,3,4,5]	[6,7]
+[1,NULL,3,4,NULL,6,7,8,1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7]	[8]
+[1,2,3,NULL,5,6,7,0,1,1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7]	[0,1]
+[1,2,3,4,5,NULL,7,1,2,1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7]	[1,2]
+[1,2,3,4,5,6,7,1,2,1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]	[1,2]
+[1,NULL,3,NULL,5,6,7,1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7]	[]
+arraySlice(arr1, o, l)
+[]	1	1	[]
+[]	1	1	[]
+[1,2,3,4,5]	2	1	[2]
+[1,NULL,3,4,NULL,6,7]	2	3	[NULL,3,4]
+[1,2,3,NULL,5,6,7]	2	-3	[2,3,NULL]
+[1,2,3,4,5,NULL,7]	2	-3	[2,3,4]
+[1,2,3,4,5,6,7]	-5	4	[3,4,5,6]
+[1,NULL,3,NULL,5,6,7]	-5	-3	[3,NULL]
+arraySlice(arr1, no, nl)
+[]	\N	\N	[]
+[]	\N	\N	[]
+[1,2,3,4,5]	\N	\N	[1,2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	2	3	[NULL,3,4]
+[1,2,3,NULL,5,6,7]	\N	-3	[1,2,3,NULL]
+[1,2,3,4,5,NULL,7]	\N	\N	[1,2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	-5	4	[3,4,5,6]
+[1,NULL,3,NULL,5,6,7]	-5	-3	[3,NULL]
+arraySlice(arr1, 2, l)
+[]	2	1	[]
+[]	2	1	[]
+[1,2,3,4,5]	2	1	[2]
+[1,NULL,3,4,NULL,6,7]	2	3	[NULL,3,4]
+[1,2,3,NULL,5,6,7]	2	-3	[2,3,NULL]
+[1,2,3,4,5,NULL,7]	2	-3	[2,3,4]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,NULL,3,NULL,5,6,7]	2	-3	[NULL,3,NULL]
+arraySlice(arr1, o, 2)
+[]	1	2	[]
+[]	1	2	[]
+[1,2,3,4,5]	2	2	[2,3]
+[1,NULL,3,4,NULL,6,7]	2	2	[NULL,3]
+[1,2,3,NULL,5,6,7]	2	2	[2,3]
+[1,2,3,4,5,NULL,7]	2	2	[2,3]
+[1,2,3,4,5,6,7]	-5	2	[3,4]
+[1,NULL,3,NULL,5,6,7]	-5	2	[3,NULL]
+arraySlice(arr1, 2, nl)
+[]	2	\N	[]
+[]	2	\N	[]
+[1,2,3,4,5]	2	\N	[2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	2	3	[NULL,3,4]
+[1,2,3,NULL,5,6,7]	2	-3	[2,3,NULL]
+[1,2,3,4,5,NULL,7]	2	\N	[2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,NULL,3,NULL,5,6,7]	2	-3	[NULL,3,NULL]
+arraySlice(arr1, no, 2)
+[]	\N	2	[]
+[]	\N	2	[]
+[1,2,3,4,5]	\N	2	[1,2]
+[1,NULL,3,4,NULL,6,7]	2	2	[NULL,3]
+[1,2,3,NULL,5,6,7]	\N	2	[1,2]
+[1,2,3,4,5,NULL,7]	\N	2	[1,2]
+[1,2,3,4,5,6,7]	-5	2	[3,4]
+[1,NULL,3,NULL,5,6,7]	-5	2	[3,NULL]
+arraySlice(arr1, -4, l)
+[]	2	1	[]
+[]	2	1	[]
+[1,2,3,4,5]	2	1	[2]
+[1,NULL,3,4,NULL,6,7]	2	3	[4,NULL,6]
+[1,2,3,NULL,5,6,7]	2	-3	[NULL]
+[1,2,3,4,5,NULL,7]	2	-3	[4]
+[1,2,3,4,5,6,7]	2	4	[4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	2	-3	[NULL]
+arraySlice(arr1, o, -2)
+[]	1	2	[]
+[]	1	2	[]
+[1,2,3,4,5]	2	2	[2,3]
+[1,NULL,3,4,NULL,6,7]	2	2	[NULL,3,4,NULL]
+[1,2,3,NULL,5,6,7]	2	2	[2,3,NULL,5]
+[1,2,3,4,5,NULL,7]	2	2	[2,3,4,5]
+[1,2,3,4,5,6,7]	-5	2	[3,4,5]
+[1,NULL,3,NULL,5,6,7]	-5	2	[3,NULL,5]
+arraySlice(arr1, -4, nl)
+[]	2	\N	[]
+[]	2	\N	[]
+[1,2,3,4,5]	2	\N	[2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	2	3	[4,NULL,6]
+[1,2,3,NULL,5,6,7]	2	-3	[NULL]
+[1,2,3,4,5,NULL,7]	2	\N	[4,5,NULL,7]
+[1,2,3,4,5,6,7]	2	4	[4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	2	-3	[NULL]
+arraySlice(arr1, no, -2)
+[]	\N	2	[]
+[]	\N	2	[]
+[1,2,3,4,5]	\N	2	[1,2,3]
+[1,NULL,3,4,NULL,6,7]	2	2	[NULL,3,4,NULL]
+[1,2,3,NULL,5,6,7]	\N	2	[1,2,3,NULL,5]
+[1,2,3,4,5,NULL,7]	\N	2	[1,2,3,4,5]
+[1,2,3,4,5,6,7]	-5	2	[3,4,5]
+[1,NULL,3,NULL,5,6,7]	-5	2	[3,NULL,5]
+arraySlice(arr1, 2, 4)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	2	4	[NULL,3,4,NULL]
+[1,2,3,NULL,5,6,7]	2	4	[2,3,NULL,5]
+[1,2,3,4,5,NULL,7]	2	4	[2,3,4,5]
+[1,2,3,4,5,6,7]	2	4	[2,3,4,5]
+[1,NULL,3,NULL,5,6,7]	2	4	[NULL,3,NULL,5]
+arraySlice(arr1, 2, -4)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[]
+[1,NULL,3,4,NULL,6,7]	2	4	[NULL,3]
+[1,2,3,NULL,5,6,7]	2	4	[2,3]
+[1,2,3,4,5,NULL,7]	2	4	[2,3]
+[1,2,3,4,5,6,7]	2	4	[2,3]
+[1,NULL,3,NULL,5,6,7]	2	4	[NULL,3]
+arraySlice(arr1, -4, 2)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[2,3]
+[1,NULL,3,4,NULL,6,7]	2	4	[4,NULL]
+[1,2,3,NULL,5,6,7]	2	4	[NULL,5]
+[1,2,3,4,5,NULL,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,NULL,3,NULL,5,6,7]	2	4	[NULL,5]
+arraySlice(arr1, -4, -1)
+[]	2	4	[]
+[]	2	4	[]
+[1,2,3,4,5]	2	4	[]
+[1,NULL,3,4,NULL,6,7]	2	4	[4,NULL]
+[1,2,3,NULL,5,6,7]	2	4	[NULL,5]
+[1,2,3,4,5,NULL,7]	2	4	[4,5]
+[1,2,3,4,5,6,7]	2	4	[4,5]
+[1,NULL,3,NULL,5,6,7]	2	4	[NULL,5]
+arrayPushFront(arr1, 1)
+[]	[1]
+[]	[]
+[1,2,3,4,5]	[1,2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7]
+[1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7]
+[1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7]
+arrayPushFront(arr1, 0.1)
+[]	[0.1]
+[]	[]
+[1,2,3,4,5]	[1,2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7]
+[1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7]
+[1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7]
+arrayPushFront(arr1, l)
+[]	[1]
+[]	[1]
+[1,2,3,4,5]	[1,1,2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	[3,1,NULL,3,4,NULL,6,7]
+[1,2,3,NULL,5,6,7]	[-3,1,2,3,NULL,5,6,7]
+[1,2,3,4,5,NULL,7]	[-3,1,2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	[4,1,2,3,4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	[-3,1,NULL,3,NULL,5,6,7]
+arrayPushFront(arr1, nl)
+[]	[NULL]
+[]	[NULL]
+[1,2,3,4,5]	[NULL,1,2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	[3,1,NULL,3,4,NULL,6,7]
+[1,2,3,NULL,5,6,7]	[-3,1,2,3,NULL,5,6,7]
+[1,2,3,4,5,NULL,7]	[NULL,1,2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	[4,1,2,3,4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	[-3,1,NULL,3,NULL,5,6,7]
+arrayPushFront([1, 2, 3], l)
+[1,1,1,1]
+[1]
+[1]
+[1]
+[1]
+[1]
+[2]
+[3]
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+arrayPushFront([1, 2, 3], nl)
+[NULL,1,1,1]
+[1]
+[1]
+[1]
+[1]
+[1]
+[2]
+[3]
+arrayPushBack(arr1, 1)
+[]	[1]
+[]	[]
+[1,2,3,4,5]	[2,3,4,5,1]
+[1,NULL,3,4,NULL,6,7]	[NULL,3,4,NULL,6,7,1]
+[1,2,3,NULL,5,6,7]	[2,3,NULL,5,6,7,1]
+[1,2,3,4,5,NULL,7]	[2,3,4,5,NULL,7,1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,1]
+[1,NULL,3,NULL,5,6,7]	[NULL,3,NULL,5,6,7,1]
+arrayPushBack(arr1, 0.1)
+[]	[0.1]
+[]	[]
+[1,2,3,4,5]	[2,3,4,5,0.1]
+[1,NULL,3,4,NULL,6,7]	[NULL,3,4,NULL,6,7,0.1]
+[1,2,3,NULL,5,6,7]	[2,3,NULL,5,6,7,0.1]
+[1,2,3,4,5,NULL,7]	[2,3,4,5,NULL,7,0.1]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7,0.1]
+[1,NULL,3,NULL,5,6,7]	[NULL,3,NULL,5,6,7,0.1]
+arrayPushBack(arr1, l)
+[]	[1]
+[]	[1]
+[1,2,3,4,5]	[1,2,3,4,5,1]
+[1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7,3]
+[1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7,-3]
+[1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7,-3]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,4]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7,-3]
+arrayPushBack(arr1, nl)
+[]	[NULL]
+[]	[NULL]
+[1,2,3,4,5]	[1,2,3,4,5,NULL]
+[1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6,7,3]
+[1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6,7,-3]
+[1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL,7,NULL]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6,7,4]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6,7,-3]
+arrayPushBack([1, 2, 3], l)
+[1,1,1,1]
+[1]
+[1]
+[3]
+[-3]
+[-3]
+[4]
+[-3]
+arrayPushBack([1, 2, 3], nl)
+[1,1,1,NULL]
+[NULL]
+[NULL]
+[3]
+[-3]
+[NULL]
+[4]
+[-3]
+arrayPopFront(arr1)
+[]	[]
+[]	[]
+[1,2,3,4,5]	[2,3,4,5]
+[1,NULL,3,4,NULL,6,7]	[NULL,3,4,NULL,6,7]
+[1,2,3,NULL,5,6,7]	[2,3,NULL,5,6,7]
+[1,2,3,4,5,NULL,7]	[2,3,4,5,NULL,7]
+[1,2,3,4,5,6,7]	[2,3,4,5,6,7]
+[1,NULL,3,NULL,5,6,7]	[NULL,3,NULL,5,6,7]
+arrayPopBack(arr1)
+[]	[]
+[]	[]
+[1,2,3,4,5]	[1,2,3,4]
+[1,NULL,3,4,NULL,6,7]	[1,NULL,3,4,NULL,6]
+[1,2,3,NULL,5,6,7]	[1,2,3,NULL,5,6]
+[1,2,3,4,5,NULL,7]	[1,2,3,4,5,NULL]
+[1,2,3,4,5,6,7]	[1,2,3,4,5,6]
+[1,NULL,3,NULL,5,6,7]	[1,NULL,3,NULL,5,6]
+
+table
+[]	[]		\N	1	\N	1	\N
+[]	['1','2']	a	b	1	\N	1	\N
+['1','2','3','4','5']	['6','7']	a	\N	2	\N	1	\N
+['1',NULL,'3','4',NULL,'6','7']	['8']	a	b	2	2	3	3
+['1','2','3',NULL,'5','6','7']	['0','1']	a	\N	2	\N	-3	-3
+['1','2','3','4','5',NULL,'7']	['1','2']	a	b	2	\N	-3	\N
+['1','2','3','4','5','6','7']	['1','2']	a	\N	-5	-5	4	4
+['1',NULL,'3',NULL,'5','6','7']	[]	a	b	-5	-5	-3	-3
+concat arr1, arr2
+[]	[]	[]
+['1','2']	[]	['1','2']
+['1','2','3','4','5','6','7']	['1','2','3','4','5']	['6','7']
+['1',NULL,'3','4',NULL,'6','7','8']	['1',NULL,'3','4',NULL,'6','7']	['8']
+['1','2','3',NULL,'5','6','7','0','1']	['1','2','3',NULL,'5','6','7']	['0','1']
+['1','2','3','4','5',NULL,'7','1','2']	['1','2','3','4','5',NULL,'7']	['1','2']
+['1','2','3','4','5','6','7','1','2']	['1','2','3','4','5','6','7']	['1','2']
+['1',NULL,'3',NULL,'5','6','7']	['1',NULL,'3',NULL,'5','6','7']	[]
+concat arr1, arr2, arr1
+[]	[]	[]
+['1','2']	[]	['1','2']
+['1','2','3','4','5','6','7','1','2','3','4','5']	['1','2','3','4','5']	['6','7']
+['1',NULL,'3','4',NULL,'6','7','8','1',NULL,'3','4',NULL,'6','7']	['1',NULL,'3','4',NULL,'6','7']	['8']
+['1','2','3',NULL,'5','6','7','0','1','1','2','3',NULL,'5','6','7']	['1','2','3',NULL,'5','6','7']	['0','1']
+['1','2','3','4','5',NULL,'7','1','2','1','2','3','4','5',NULL,'7']	['1','2','3','4','5',NULL,'7']	['1','2']
+['1','2','3','4','5','6','7','1','2','1','2','3','4','5','6','7']	['1','2','3','4','5','6','7']	['1','2']
+['1',NULL,'3',NULL,'5','6','7','1',NULL,'3',NULL,'5','6','7']	['1',NULL,'3',NULL,'5','6','7']	[]
+arraySlice(arr1, o, l)
+[]	1	1	[]
+[]	1	1	[]
+['1','2','3','4','5']	2	1	['2']
+['1',NULL,'3','4',NULL,'6','7']	2	3	[NULL,'3','4']
+['1','2','3',NULL,'5','6','7']	2	-3	['2','3',NULL]
+['1','2','3','4','5',NULL,'7']	2	-3	['2','3','4']
+['1','2','3','4','5','6','7']	-5	4	['3','4','5','6']
+['1',NULL,'3',NULL,'5','6','7']	-5	-3	['3',NULL]
+arraySlice(arr1, no, nl)
+[]	\N	\N	[]
+[]	\N	\N	[]
+['1','2','3','4','5']	\N	\N	['1','2','3','4','5']
+['1',NULL,'3','4',NULL,'6','7']	2	3	[NULL,'3','4']
+['1','2','3',NULL,'5','6','7']	\N	-3	['1','2','3',NULL]
+['1','2','3','4','5',NULL,'7']	\N	\N	['1','2','3','4','5',NULL,'7']
+['1','2','3','4','5','6','7']	-5	4	['3','4','5','6']
+['1',NULL,'3',NULL,'5','6','7']	-5	-3	['3',NULL]
+arraySlice(arr1, 2, l)
+[]	2	1	[]
+[]	2	1	[]
+['1','2','3','4','5']	2	1	['2']
+['1',NULL,'3','4',NULL,'6','7']	2	3	[NULL,'3','4']
+['1','2','3',NULL,'5','6','7']	2	-3	['2','3',NULL]
+['1','2','3','4','5',NULL,'7']	2	-3	['2','3','4']
+['1','2','3','4','5','6','7']	2	4	['2','3','4','5']
+['1',NULL,'3',NULL,'5','6','7']	2	-3	[NULL,'3',NULL]
+arraySlice(arr1, o, 2)
+[]	1	2	[]
+[]	1	2	[]
+['1','2','3','4','5']	2	2	['2','3']
+['1',NULL,'3','4',NULL,'6','7']	2	2	[NULL,'3']
+['1','2','3',NULL,'5','6','7']	2	2	['2','3']
+['1','2','3','4','5',NULL,'7']	2	2	['2','3']
+['1','2','3','4','5','6','7']	-5	2	['3','4']
+['1',NULL,'3',NULL,'5','6','7']	-5	2	['3',NULL]
+arraySlice(arr1, 2, nl)
+[]	2	\N	[]
+[]	2	\N	[]
+['1','2','3','4','5']	2	\N	['2','3','4','5']
+['1',NULL,'3','4',NULL,'6','7']	2	3	[NULL,'3','4']
+['1','2','3',NULL,'5','6','7']	2	-3	['2','3',NULL]
+['1','2','3','4','5',NULL,'7']	2	\N	['2','3','4','5',NULL,'7']
+['1','2','3','4','5','6','7']	2	4	['2','3','4','5']
+['1',NULL,'3',NULL,'5','6','7']	2	-3	[NULL,'3',NULL]
+arraySlice(arr1, no, 2)
+[]	\N	2	[]
+[]	\N	2	[]
+['1','2','3','4','5']	\N	2	['1','2']
+['1',NULL,'3','4',NULL,'6','7']	2	2	[NULL,'3']
+['1','2','3',NULL,'5','6','7']	\N	2	['1','2']
+['1','2','3','4','5',NULL,'7']	\N	2	['1','2']
+['1','2','3','4','5','6','7']	-5	2	['3','4']
+['1',NULL,'3',NULL,'5','6','7']	-5	2	['3',NULL]
+arraySlice(arr1, -4, l)
+[]	2	1	[]
+[]	2	1	[]
+['1','2','3','4','5']	2	1	['2']
+['1',NULL,'3','4',NULL,'6','7']	2	3	['4',NULL,'6']
+['1','2','3',NULL,'5','6','7']	2	-3	[NULL]
+['1','2','3','4','5',NULL,'7']	2	-3	['4']
+['1','2','3','4','5','6','7']	2	4	['4','5','6','7']
+['1',NULL,'3',NULL,'5','6','7']	2	-3	[NULL]
+arraySlice(arr1, o, -2)
+[]	1	2	[]
+[]	1	2	[]
+['1','2','3','4','5']	2	2	['2','3']
+['1',NULL,'3','4',NULL,'6','7']	2	2	[NULL,'3','4',NULL]
+['1','2','3',NULL,'5','6','7']	2	2	['2','3',NULL,'5']
+['1','2','3','4','5',NULL,'7']	2	2	['2','3','4','5']
+['1','2','3','4','5','6','7']	-5	2	['3','4','5']
+['1',NULL,'3',NULL,'5','6','7']	-5	2	['3',NULL,'5']
+arraySlice(arr1, -4, nl)
+[]	2	\N	[]
+[]	2	\N	[]
+['1','2','3','4','5']	2	\N	['2','3','4','5']
+['1',NULL,'3','4',NULL,'6','7']	2	3	['4',NULL,'6']
+['1','2','3',NULL,'5','6','7']	2	-3	[NULL]
+['1','2','3','4','5',NULL,'7']	2	\N	['4','5',NULL,'7']
+['1','2','3','4','5','6','7']	2	4	['4','5','6','7']
+['1',NULL,'3',NULL,'5','6','7']	2	-3	[NULL]
+arraySlice(arr1, no, -2)
+[]	\N	2	[]
+[]	\N	2	[]
+['1','2','3','4','5']	\N	2	['1','2','3']
+['1',NULL,'3','4',NULL,'6','7']	2	2	[NULL,'3','4',NULL]
+['1','2','3',NULL,'5','6','7']	\N	2	['1','2','3',NULL,'5']
+['1','2','3','4','5',NULL,'7']	\N	2	['1','2','3','4','5']
+['1','2','3','4','5','6','7']	-5	2	['3','4','5']
+['1',NULL,'3',NULL,'5','6','7']	-5	2	['3',NULL,'5']
+arraySlice(arr1, 2, 4)
+[]	2	4	[]
+[]	2	4	[]
+['1','2','3','4','5']	2	4	['2','3','4','5']
+['1',NULL,'3','4',NULL,'6','7']	2	4	[NULL,'3','4',NULL]
+['1','2','3',NULL,'5','6','7']	2	4	['2','3',NULL,'5']
+['1','2','3','4','5',NULL,'7']	2	4	['2','3','4','5']
+['1','2','3','4','5','6','7']	2	4	['2','3','4','5']
+['1',NULL,'3',NULL,'5','6','7']	2	4	[NULL,'3',NULL,'5']
+arraySlice(arr1, 2, -4)
+[]	2	4	[]
+[]	2	4	[]
+['1','2','3','4','5']	2	4	[]
+['1',NULL,'3','4',NULL,'6','7']	2	4	[NULL,'3']
+['1','2','3',NULL,'5','6','7']	2	4	['2','3']
+['1','2','3','4','5',NULL,'7']	2	4	['2','3']
+['1','2','3','4','5','6','7']	2	4	['2','3']
+['1',NULL,'3',NULL,'5','6','7']	2	4	[NULL,'3']
+arraySlice(arr1, -4, 2)
+[]	2	4	[]
+[]	2	4	[]
+['1','2','3','4','5']	2	4	['2','3']
+['1',NULL,'3','4',NULL,'6','7']	2	4	['4',NULL]
+['1','2','3',NULL,'5','6','7']	2	4	[NULL,'5']
+['1','2','3','4','5',NULL,'7']	2	4	['4','5']
+['1','2','3','4','5','6','7']	2	4	['4','5']
+['1',NULL,'3',NULL,'5','6','7']	2	4	[NULL,'5']
+arraySlice(arr1, -4, -1)
+[]	2	4	[]
+[]	2	4	[]
+['1','2','3','4','5']	2	4	[]
+['1',NULL,'3','4',NULL,'6','7']	2	4	['4',NULL]
+['1','2','3',NULL,'5','6','7']	2	4	[NULL,'5']
+['1','2','3','4','5',NULL,'7']	2	4	['4','5']
+['1','2','3','4','5','6','7']	2	4	['4','5']
+['1',NULL,'3',NULL,'5','6','7']	2	4	[NULL,'5']
+arrayPushFront(arr1, 1)
+[]	['1']
+[]	['1']
+['1','2','3','4','5']	['1','1','2','3','4','5']
+['1',NULL,'3','4',NULL,'6','7']	['1','1',NULL,'3','4',NULL,'6','7']
+['1','2','3',NULL,'5','6','7']	['1','1','2','3',NULL,'5','6','7']
+['1','2','3','4','5',NULL,'7']	['1','1','2','3','4','5',NULL,'7']
+['1','2','3','4','5','6','7']	['1','1','2','3','4','5','6','7']
+['1',NULL,'3',NULL,'5','6','7']	['1','1',NULL,'3',NULL,'5','6','7']
+arrayPushFront(arr1, val)
+[]	['']
+[]	['a']
+['1','2','3','4','5']	['a','1','2','3','4','5']
+['1',NULL,'3','4',NULL,'6','7']	['a','1',NULL,'3','4',NULL,'6','7']
+['1','2','3',NULL,'5','6','7']	['a','1','2','3',NULL,'5','6','7']
+['1','2','3','4','5',NULL,'7']	['a','1','2','3','4','5',NULL,'7']
+['1','2','3','4','5','6','7']	['a','1','2','3','4','5','6','7']
+['1',NULL,'3',NULL,'5','6','7']	['a','1',NULL,'3',NULL,'5','6','7']
+arrayPushFront(arr1, val2)
+[]	[NULL]
+[]	['b']
+['1','2','3','4','5']	[NULL,'1','2','3','4','5']
+['1',NULL,'3','4',NULL,'6','7']	['b','1',NULL,'3','4',NULL,'6','7']
+['1','2','3',NULL,'5','6','7']	[NULL,'1','2','3',NULL,'5','6','7']
+['1','2','3','4','5',NULL,'7']	['b','1','2','3','4','5',NULL,'7']
+['1','2','3','4','5','6','7']	[NULL,'1','2','3','4','5','6','7']
+['1',NULL,'3',NULL,'5','6','7']	['b','1',NULL,'3',NULL,'5','6','7']
+arrayPushFront([a, b, c], val)
+['','a','b','c']
+['a','a','b','c']
+['a','a','b','c']
+['a','a','b','c']
+['a','a','b','c']
+['a','a','b','c']
+['a','a','b','c']
+['a','a','b','c']
+arrayPushFront([a, b, c], val2)
+[NULL,'a','b','c']
+['b','a','b','c']
+[NULL,'a','b','c']
+['b','a','b','c']
+[NULL,'a','b','c']
+['b','a','b','c']
+[NULL,'a','b','c']
+['b','a','b','c']
+arrayPushBack(arr1, 1)
+[]	['1']
+[]	['1']
+['1','2','3','4','5']	['1','2','3','4','5','1']
+['1',NULL,'3','4',NULL,'6','7']	['1',NULL,'3','4',NULL,'6','7','1']
+['1','2','3',NULL,'5','6','7']	['1','2','3',NULL,'5','6','7','1']
+['1','2','3','4','5',NULL,'7']	['1','2','3','4','5',NULL,'7','1']
+['1','2','3','4','5','6','7']	['1','2','3','4','5','6','7','1']
+['1',NULL,'3',NULL,'5','6','7']	['1',NULL,'3',NULL,'5','6','7','1']
+arrayPushBack(arr1, val)
+[]	['']
+[]	['a']
+['1','2','3','4','5']	['1','2','3','4','5','a']
+['1',NULL,'3','4',NULL,'6','7']	['1',NULL,'3','4',NULL,'6','7','a']
+['1','2','3',NULL,'5','6','7']	['1','2','3',NULL,'5','6','7','a']
+['1','2','3','4','5',NULL,'7']	['1','2','3','4','5',NULL,'7','a']
+['1','2','3','4','5','6','7']	['1','2','3','4','5','6','7','a']
+['1',NULL,'3',NULL,'5','6','7']	['1',NULL,'3',NULL,'5','6','7','a']
+arrayPushBack(arr1, val2)
+[]	[NULL]
+[]	['b']
+['1','2','3','4','5']	['1','2','3','4','5',NULL]
+['1',NULL,'3','4',NULL,'6','7']	['1',NULL,'3','4',NULL,'6','7','b']
+['1','2','3',NULL,'5','6','7']	['1','2','3',NULL,'5','6','7',NULL]
+['1','2','3','4','5',NULL,'7']	['1','2','3','4','5',NULL,'7','b']
+['1','2','3','4','5','6','7']	['1','2','3','4','5','6','7',NULL]
+['1',NULL,'3',NULL,'5','6','7']	['1',NULL,'3',NULL,'5','6','7','b']
+arrayPushBack([a, b, c], val)
+['a','b','c','']
+['a','b','c','a']
+['a','b','c','a']
+['a','b','c','a']
+['a','b','c','a']
+['a','b','c','a']
+['a','b','c','a']
+['a','b','c','a']
+arrayPushBack([a, b, c], val2)
+['a','b','c',NULL]
+['a','b','c','b']
+['a','b','c',NULL]
+['a','b','c','b']
+['a','b','c',NULL]
+['a','b','c','b']
+['a','b','c',NULL]
+['a','b','c','b']
+arrayPopFront(arr1)
+[]	[]
+[]	[]
+['1','2','3','4','5']	['2','3','4','5']
+['1',NULL,'3','4',NULL,'6','7']	[NULL,'3','4',NULL,'6','7']
+['1','2','3',NULL,'5','6','7']	['2','3',NULL,'5','6','7']
+['1','2','3','4','5',NULL,'7']	['2','3','4','5',NULL,'7']
+['1','2','3','4','5','6','7']	['2','3','4','5','6','7']
+['1',NULL,'3',NULL,'5','6','7']	[NULL,'3',NULL,'5','6','7']
+arrayPopBack(arr1)
+[]	[]
+[]	[]
+['1','2','3','4','5']	['1','2','3','4']
+['1',NULL,'3','4',NULL,'6','7']	['1',NULL,'3','4',NULL,'6']
+['1','2','3',NULL,'5','6','7']	['1','2','3',NULL,'5','6']
+['1','2','3','4','5',NULL,'7']	['1','2','3','4','5',NULL]
+['1','2','3','4','5','6','7']	['1','2','3','4','5','6']
+['1',NULL,'3',NULL,'5','6','7']	['1',NULL,'3',NULL,'5','6']
diff --git a/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.sql b/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.sql
new file mode 100644
index 00000000000..7465fc2c731
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.sql
@@ -0,0 +1,366 @@
+select 'const args';
+select 'concat';
+select arrayConcat(emptyArrayUInt8());
+select arrayConcat(emptyArrayUInt8(), emptyArrayUInt8());
+select arrayConcat(emptyArrayUInt8(), emptyArrayUInt8(), emptyArrayUInt8());
+select arrayConcat([Null], emptyArrayUInt8());
+select arrayConcat([Null], emptyArrayUInt8(), [1]);
+select arrayConcat([1, 2], [-1, -2], [0.3, 0.7], [Null]);
+select arrayConcat(Null, emptyArrayUInt8());
+select arrayConcat([1], [-1], Null);
+select arrayConcat([1, 2], [3, 4]);
+select arrayConcat([1], [2, 3, 4]);
+select arrayConcat(emptyArrayUInt8(), emptyArrayUInt8());
+SELECT arrayConcat(['abc'], ['def', 'gh', 'qwe']);
+SELECT arrayConcat([1, NULL, 2], [3, NULL, 4]);
+select arrayConcat([1, Null, 2], [3, 4]);
+
+select 'slice';
+select arraySlice(Null, 1, 2);
+select arraySlice([1, 2, 3, 4, 5, 6], Null, Null);
+select arraySlice([1, 2, 3, 4, 5, 6], 2, Null);
+select arraySlice([1, 2, 3, 4, 5, 6], Null, 4);
+select arraySlice([1, 2, 3, 4, 5, 6], Null, -2);
+select arraySlice([1, 2, 3, 4, 5, 6], -3, Null);
+select arraySlice([1, 2, 3, 4, 5, 6], 2, 3);
+select arraySlice([1, 2, 3, 4, 5, 6], 2, -2);
+select arraySlice([1, 2, 3, 4, 5, 6], -4, 2);
+select arraySlice([1, 2, 3, 4, 5, 6], -4, -2);
+select arraySlice([1, 2, 3, 4, 5, 6], 2, 0);
+select arraySlice([1, 2, 3, 4, 5, 6], -10, 15);
+select arraySlice([1, 2, 3, 4, 5, 6], 10, 0);
+select arraySlice([1, 2, 3, 4, 5, 6], 10, -1);
+select arraySlice([1, 2, 3, 4, 5, 6], 10, 1);
+select arraySlice([1, 2, Null, 4, 5, 6], 2, 4);
+select arraySlice(['a', 'b', 'c', 'd', 'e'], 2, 3);
+select arraySlice([Null, 'b', Null, 'd', 'e'], 2, 3);
+
+select 'push back';
+select arrayPushBack(Null, 1);
+select arrayPushBack([1], 1);
+select arrayPushBack([Null], 1);
+select arrayPushBack([0.5, 0.7], 1);
+select arrayPushBack([1], -1);
+select arrayPushBack(['a', 'b'], 'cd');
+select arrayPushBack(emptyArrayUInt8(), 1);
+select arrayPushBack(emptyArrayUInt8(), -1);
+
+select 'push front';
+select arrayPushFront(Null, 1);
+select arrayPushFront([1], 1);
+select arrayPushFront([Null], 1);
+select arrayPushFront([0.5, 0.7], 1);
+select arrayPushFront([1], -1);
+select arrayPushFront(['a', 'b'], 'cd');
+select arrayPushFront(emptyArrayUInt8(), 1);
+select arrayPushFront(emptyArrayUInt8(), -1);
+
+select 'pop back';
+select arrayPopBack(Null);
+select arrayPopBack(emptyArrayUInt8());
+select arrayPopBack([1]);
+select arrayPopBack([1, 2, 3]);
+select arrayPopBack([0.1, 0.2, 0.3]);
+select arrayPopBack(['a', 'b', 'c']);
+
+select 'pop front';
+select arrayPopFront(Null);
+select arrayPopFront(emptyArrayUInt8());
+select arrayPopFront([1]);
+select arrayPopFront([1, 2, 3]);
+select arrayPopFront([0.1, 0.2, 0.3]);
+select arrayPopFront(['a', 'b', 'c']);
+
+DROP TABLE if exists test_array_functions;
+select '';
+select 'table';
+create table test_array_functions (arr1 Array(Int8), arr2 Array(Int8), o Int8, no Nullable(Int8), l Int8, nl Nullable(Int8)) engine = TinyLog;
+insert into test_array_functions values ([], [], 1, Null, 1, Null), ([], [1], 1, Null, 1, Null), ([1, 2, 3, 4, 5], [6, 7], 2, Null, 1, Null), ([1, 2, 3, 4, 5, 6, 7], [8], 2, 2, 3, 3), ([1, 2, 3, 4, 5, 6, 7], [], 2, Null, -3, -3), ([1, 2, 3, 4, 5, 6, 7], [], 2, Null, -3, Null), ([1, 2, 3, 4, 5, 6, 7], [], -5, -5, 4, 4), ([1, 2, 3, 4, 5, 6, 7], [], -5, -5, -3, -3);
+
+select * from test_array_functions;
+select 'concat arr1, arr2';
+select arrayConcat(arr1, arr2), arr1, arr2 from test_array_functions;
+select 'concat arr1, arr2, arr1';
+select arrayConcat(arr1, arr2, arr1), arr1, arr2 from test_array_functions;
+
+select 'arraySlice(arr1, o, l)';
+select arr1, o, l, arraySlice(arr1, o, l) from test_array_functions;
+select 'arraySlice(arr1, no, nl)';
+select arr1, no, nl, arraySlice(arr1, no, nl) from test_array_functions;
+select 'arraySlice(arr1, 2, l)';
+select arr1, 2, l, arraySlice(arr1, 2, l) from test_array_functions;
+select 'arraySlice(arr1, o, 2)';
+select arr1, o, 2, arraySlice(arr1, o, 2) from test_array_functions;
+select 'arraySlice(arr1, 2, nl)';
+select arr1, 2, nl, arraySlice(arr1, 2, nl) from test_array_functions;
+select 'arraySlice(arr1, no, 2)';
+select arr1, no, 2, arraySlice(arr1, no, 2) from test_array_functions;
+select 'arraySlice(arr1, -4, l)';
+select arr1, 2, l, arraySlice(arr1, -4, l) from test_array_functions;
+select 'arraySlice(arr1, o, -2)';
+select arr1, o, 2, arraySlice(arr1, o, -2) from test_array_functions;
+select 'arraySlice(arr1, -4, nl)';
+select arr1, 2, nl, arraySlice(arr1, -4, nl) from test_array_functions;
+select 'arraySlice(arr1, no, -2)';
+select arr1, no, 2, arraySlice(arr1, no, -2) from test_array_functions;
+select 'arraySlice(arr1, 2, 4)';
+select arr1, 2, 4, arraySlice(arr1, 2, 4) from test_array_functions;
+select 'arraySlice(arr1, 2, -4)';
+select arr1, 2, 4, arraySlice(arr1, 2, -4) from test_array_functions;
+select 'arraySlice(arr1, -4, 2)';
+select arr1, 2, 4, arraySlice(arr1, -4, 2) from test_array_functions;
+select 'arraySlice(arr1, -4, -1)';
+select arr1, 2, 4, arraySlice(arr1, -4, -1) from test_array_functions;
+
+select 'arrayPushFront(arr1, 1)';
+select arr1, arrayPushFront(arr1, 1) from test_array_functions;
+select 'arrayPushFront(arr1, 0.1)';
+select arr1, arrayPushFront(arr1, 0.1) from test_array_functions;
+select 'arrayPushFront(arr1, l)';
+select arr1, arrayPushFront(arr1, l) from test_array_functions;
+select 'arrayPushFront(arr1, nl)';
+select arr1, arrayPushFront(arr1, nl) from test_array_functions;
+select 'arrayPushFront([1, 2, 3], l)';
+select arrayPushFront([1, 2, 3], l) from test_array_functions;
+select 'arrayPushFront([1, 2, 3], nl)' from test_array_functions;
+select arrayPushFront([1, 2, 3], nl) from test_array_functions;
+
+select 'arrayPushBack(arr1, 1)';
+select arr1, arrayPushBack(arr1, 1) from test_array_functions;
+select 'arrayPushBack(arr1, 0.1)';
+select arr1, arrayPushBack(arr1, 0.1) from test_array_functions;
+select 'arrayPushBack(arr1, l)';
+select arr1, arrayPushBack(arr1, l) from test_array_functions;
+select 'arrayPushBack(arr1, nl)';
+select arr1, arrayPushBack(arr1, nl) from test_array_functions;
+select 'arrayPushBack([1, 2, 3], l)';
+select arrayPushBack([1, 2, 3], l) from test_array_functions;
+select 'arrayPushBack([1, 2, 3], nl)';
+select arrayPushBack([1, 2, 3], nl) from test_array_functions;
+
+select 'arrayPopFront(arr1)';
+select arr1, arrayPopFront(arr1) from test_array_functions;
+select 'arrayPopBack(arr1)';
+select arr1, arrayPopBack(arr1) from test_array_functions;
+
+
+DROP TABLE if exists test_array_functions;
+select '';
+select 'table';
+create table test_array_functions (arr1 Array(Nullable(Int8)), arr2 Array(Nullable(Float32)), o Int8, no Nullable(Int8), l Int8, nl Nullable(Int8)) engine = TinyLog;
+insert into test_array_functions values ([], [], 1, Null, 1, Null), ([], [1, Null], 1, Null, 1, Null), ([1, 2, 3, 4, 5], [6, Null], 2, Null, 1, Null), ([1, Null, 3, 4, Null, 6, 7], [8], 2, 2, 3, 3),([1, 2, 3, Null, 5, 6, 7], [Null, 1], 2, Null, -3, -3),([1, 2, 3, 4, 5, Null, 7], [1, Null], 2, Null, -3, Null), ([1, 2, 3, 4, 5, 6, 7], [1, 2], -5, -5, 4, 4),([1, Null, 3, Null, 5, 6, 7], [], -5, -5, -3, -3);
+
+select * from test_array_functions;
+select 'concat arr1, arr2';
+select arrayConcat(arr1, arr2), arr1, arr2 from test_array_functions;
+select 'concat arr1, arr2, arr1';
+select arrayConcat(arr1, arr2, arr1), arr1, arr2 from test_array_functions;
+
+select 'arraySlice(arr1, o, l)';
+select arr1, o, l, arraySlice(arr1, o, l) from test_array_functions;
+select 'arraySlice(arr1, no, nl)';
+select arr1, no, nl, arraySlice(arr1, no, nl) from test_array_functions;
+select 'arraySlice(arr1, 2, l)';
+select arr1, 2, l, arraySlice(arr1, 2, l) from test_array_functions;
+select 'arraySlice(arr1, o, 2)';
+select arr1, o, 2, arraySlice(arr1, o, 2) from test_array_functions;
+select 'arraySlice(arr1, 2, nl)';
+select arr1, 2, nl, arraySlice(arr1, 2, nl) from test_array_functions;
+select 'arraySlice(arr1, no, 2)';
+select arr1, no, 2, arraySlice(arr1, no, 2) from test_array_functions;
+select 'arraySlice(arr1, -4, l)';
+select arr1, 2, l, arraySlice(arr1, -4, l) from test_array_functions;
+select 'arraySlice(arr1, o, -2)';
+select arr1, o, 2, arraySlice(arr1, o, -2) from test_array_functions;
+select 'arraySlice(arr1, -4, nl)';
+select arr1, 2, nl, arraySlice(arr1, -4, nl) from test_array_functions;
+select 'arraySlice(arr1, no, -2)';
+select arr1, no, 2, arraySlice(arr1, no, -2) from test_array_functions;
+select 'arraySlice(arr1, 2, 4)';
+select arr1, 2, 4, arraySlice(arr1, 2, 4) from test_array_functions;
+select 'arraySlice(arr1, 2, -4)';
+select arr1, 2, 4, arraySlice(arr1, 2, -4) from test_array_functions;
+select 'arraySlice(arr1, -4, 2)';
+select arr1, 2, 4, arraySlice(arr1, -4, 2) from test_array_functions;
+select 'arraySlice(arr1, -4, -1)';
+select arr1, 2, 4, arraySlice(arr1, -4, -1) from test_array_functions;
+
+select 'arrayPushFront(arr1, 1)';
+select arr1, arrayPushFront(arr1, 1) from test_array_functions;
+select 'arrayPushFront(arr1, 0.1)';
+select arr1, arrayPushFront(arr1, 0.1) from test_array_functions;
+select 'arrayPushFront(arr1, l)';
+select arr1, arrayPushFront(arr1, l) from test_array_functions;
+select 'arrayPushFront(arr1, nl)';
+select arr1, arrayPushFront(arr1, nl) from test_array_functions;
+select 'arrayPushFront([1, 2, 3], l)';
+select arrayPushFront([1, 2, 3], l) from test_array_functions;
+select 'arrayPushFront([1, 2, 3], nl)' from test_array_functions;
+select arrayPushFront([1, 2, 3], nl) from test_array_functions;
+
+select 'arrayPushBack(arr1, 1)';
+select arr1, arrayPushBack(arr1, 1) from test_array_functions;
+select 'arrayPushBack(arr1, 0.1)';
+select arr1, arrayPushBack(arr1, 0.1) from test_array_functions;
+select 'arrayPushBack(arr1, l)';
+select arr1, arrayPushBack(arr1, l) from test_array_functions;
+select 'arrayPushBack(arr1, nl)';
+select arr1, arrayPushBack(arr1, nl) from test_array_functions;
+select 'arrayPushBack([1, 2, 3], l)';
+select arrayPushBack([1, 2, 3], l) from test_array_functions;
+select 'arrayPushBack([1, 2, 3], nl)';
+select arrayPushBack([1, 2, 3], nl) from test_array_functions;
+
+select 'arrayPopFront(arr1)';
+select arr1, arrayPopFront(arr1) from test_array_functions;
+select 'arrayPopBack(arr1)';
+select arr1, arrayPopBack(arr1) from test_array_functions;
+
+
+DROP TABLE if exists test_array_functions;
+select '';
+select 'table';
+create table test_array_functions (arr1 Array(Nullable(Int8)), arr2 Array(UInt8), o Int8, no Nullable(Int8), l Int8, nl Nullable(Int8)) engine = TinyLog;
+insert into test_array_functions values ([], [], 1, Null, 1, Null), ([], [1, 2], 1, Null, 1, Null), ([1, 2, 3, 4, 5], [6, 7], 2, Null, 1, Null), ([1, Null,3,4, Null, 6, 7], [8], 2, 2, 3, 3),([1, 2, 3, Null, 5, 6, 7], [0, 1], 2, Null, -3, -3),([1, 2, 3, 4, 5, Null, 7], [1, 2], 2, Null, -3, Null),([1, 2, 3,4, 5, 6, 7], [1, 2], -5, -5, 4, 4),([1, Null, 3, Null, 5, 6, 7], [], -5, -5, -3, -3);
+
+select * from test_array_functions;
+select 'concat arr1, arr2';
+select arrayConcat(arr1, arr2), arr1, arr2 from test_array_functions;
+select 'concat arr1, arr2, arr1';
+select arrayConcat(arr1, arr2, arr1), arr1, arr2 from test_array_functions;
+
+
+select * from test_array_functions;
+select 'concat arr1, arr2';
+select arrayConcat(arr1, arr2), arr1, arr2 from test_array_functions;
+select 'concat arr1, arr2, arr1';
+select arrayConcat(arr1, arr2, arr1), arr1, arr2 from test_array_functions;
+
+select 'arraySlice(arr1, o, l)';
+select arr1, o, l, arraySlice(arr1, o, l) from test_array_functions;
+select 'arraySlice(arr1, no, nl)';
+select arr1, no, nl, arraySlice(arr1, no, nl) from test_array_functions;
+select 'arraySlice(arr1, 2, l)';
+select arr1, 2, l, arraySlice(arr1, 2, l) from test_array_functions;
+select 'arraySlice(arr1, o, 2)';
+select arr1, o, 2, arraySlice(arr1, o, 2) from test_array_functions;
+select 'arraySlice(arr1, 2, nl)';
+select arr1, 2, nl, arraySlice(arr1, 2, nl) from test_array_functions;
+select 'arraySlice(arr1, no, 2)';
+select arr1, no, 2, arraySlice(arr1, no, 2) from test_array_functions;
+select 'arraySlice(arr1, -4, l)';
+select arr1, 2, l, arraySlice(arr1, -4, l) from test_array_functions;
+select 'arraySlice(arr1, o, -2)';
+select arr1, o, 2, arraySlice(arr1, o, -2) from test_array_functions;
+select 'arraySlice(arr1, -4, nl)';
+select arr1, 2, nl, arraySlice(arr1, -4, nl) from test_array_functions;
+select 'arraySlice(arr1, no, -2)';
+select arr1, no, 2, arraySlice(arr1, no, -2) from test_array_functions;
+select 'arraySlice(arr1, 2, 4)';
+select arr1, 2, 4, arraySlice(arr1, 2, 4) from test_array_functions;
+select 'arraySlice(arr1, 2, -4)';
+select arr1, 2, 4, arraySlice(arr1, 2, -4) from test_array_functions;
+select 'arraySlice(arr1, -4, 2)';
+select arr1, 2, 4, arraySlice(arr1, -4, 2) from test_array_functions;
+select 'arraySlice(arr1, -4, -1)';
+select arr1, 2, 4, arraySlice(arr1, -4, -1) from test_array_functions;
+
+select 'arrayPushFront(arr1, 1)';
+select arr1, arrayPushFront(arr1, 1) from test_array_functions;
+select 'arrayPushFront(arr1, 0.1)';
+select arr1, arrayPushFront(arr1, 0.1) from test_array_functions;
+select 'arrayPushFront(arr1, l)';
+select arr1, arrayPushFront(arr1, l) from test_array_functions;
+select 'arrayPushFront(arr1, nl)';
+select arr1, arrayPushFront(arr1, nl) from test_array_functions;
+select 'arrayPushFront([1, 2, 3], l)';
+select arrayPushFront([1, 2, 3], l) from test_array_functions;
+select 'arrayPushFront([1, 2, 3], nl)' from test_array_functions;
+select arrayPushFront([1, 2, 3], nl) from test_array_functions;
+
+select 'arrayPushBack(arr1, 1)';
+select arr1, arrayPushBack(arr1, 1) from test_array_functions;
+select 'arrayPushBack(arr1, 0.1)';
+select arr1, arrayPushBack(arr1, 0.1) from test_array_functions;
+select 'arrayPushBack(arr1, l)';
+select arr1, arrayPushBack(arr1, l) from test_array_functions;
+select 'arrayPushBack(arr1, nl)';
+select arr1, arrayPushBack(arr1, nl) from test_array_functions;
+select 'arrayPushBack([1, 2, 3], l)';
+select arrayPushBack([1, 2, 3], l) from test_array_functions;
+select 'arrayPushBack([1, 2, 3], nl)';
+select arrayPushBack([1, 2, 3], nl) from test_array_functions;
+
+select 'arrayPopFront(arr1)';
+select arr1, arrayPopFront(arr1) from test_array_functions;
+select 'arrayPopBack(arr1)';
+select arr1, arrayPopBack(arr1) from test_array_functions;
+
+DROP TABLE if exists test_array_functions;
+select '';
+select 'table';
+create table test_array_functions (arr1 Array(Nullable(String)), arr2 Array(String), val String, val2 Nullable(String), o Int8, no Nullable(Int8), l Int8, nl Nullable(Int8)) engine = TinyLog;
+insert into test_array_functions values ([], [], '', Null, 1, Null, 1, Null), ([], ['1', '2'], 'a', 'b', 1, Null, 1, Null), (['1', '2', '3', '4', '5'], ['6','7'], 'a', Null, 2, Null, 1, Null), (['1', Null, '3', '4', Null, '6', '7'], ['8'], 'a', 'b', 2, 2, 3, 3),(['1', '2', '3', Null, '5', '6', '7'], ['0','1'], 'a', Null, 2, Null, -3, -3),(['1', '2', '3', '4', '5', Null, '7'], ['1', '2'], 'a', 'b', 2, Null, -3, Null),(['1', '2', '3', '4', '5', '6', '7'],['1', '2'], 'a', Null, -5, -5, 4, 4),(['1', Null, '3', Null, '5', '6', '7'], [], 'a', 'b', -5, -5, -3, -3);
+
+
+select * from test_array_functions;
+select 'concat arr1, arr2';
+select arrayConcat(arr1, arr2), arr1, arr2 from test_array_functions;
+select 'concat arr1, arr2, arr1';
+select arrayConcat(arr1, arr2, arr1), arr1, arr2 from test_array_functions;
+
+select 'arraySlice(arr1, o, l)';
+select arr1, o, l, arraySlice(arr1, o, l) from test_array_functions;
+select 'arraySlice(arr1, no, nl)';
+select arr1, no, nl, arraySlice(arr1, no, nl) from test_array_functions;
+select 'arraySlice(arr1, 2, l)';
+select arr1, 2, l, arraySlice(arr1, 2, l) from test_array_functions;
+select 'arraySlice(arr1, o, 2)';
+select arr1, o, 2, arraySlice(arr1, o, 2) from test_array_functions;
+select 'arraySlice(arr1, 2, nl)';
+select arr1, 2, nl, arraySlice(arr1, 2, nl) from test_array_functions;
+select 'arraySlice(arr1, no, 2)';
+select arr1, no, 2, arraySlice(arr1, no, 2) from test_array_functions;
+select 'arraySlice(arr1, -4, l)';
+select arr1, 2, l, arraySlice(arr1, -4, l) from test_array_functions;
+select 'arraySlice(arr1, o, -2)';
+select arr1, o, 2, arraySlice(arr1, o, -2) from test_array_functions;
+select 'arraySlice(arr1, -4, nl)';
+select arr1, 2, nl, arraySlice(arr1, -4, nl) from test_array_functions;
+select 'arraySlice(arr1, no, -2)';
+select arr1, no, 2, arraySlice(arr1, no, -2) from test_array_functions;
+select 'arraySlice(arr1, 2, 4)';
+select arr1, 2, 4, arraySlice(arr1, 2, 4) from test_array_functions;
+select 'arraySlice(arr1, 2, -4)';
+select arr1, 2, 4, arraySlice(arr1, 2, -4) from test_array_functions;
+select 'arraySlice(arr1, -4, 2)';
+select arr1, 2, 4, arraySlice(arr1, -4, 2) from test_array_functions;
+select 'arraySlice(arr1, -4, -1)';
+select arr1, 2, 4, arraySlice(arr1, -4, -1) from test_array_functions;
+
+select 'arrayPushFront(arr1, 1)';
+select arr1, arrayPushFront(arr1, '1') from test_array_functions;
+select 'arrayPushFront(arr1, val)';
+select arr1, arrayPushFront(arr1, val) from test_array_functions;
+select 'arrayPushFront(arr1, val2)';
+select arr1, arrayPushFront(arr1, val2) from test_array_functions;
+select 'arrayPushFront([a, b, c], val)';
+select arrayPushFront(['a', 'b', 'c'], val) from test_array_functions;
+select 'arrayPushFront([a, b, c], val2)';
+select arrayPushFront(['a', 'b', 'c'], val2) from test_array_functions;
+
+select 'arrayPushBack(arr1, 1)';
+select arr1, arrayPushBack(arr1, '1') from test_array_functions;
+select 'arrayPushBack(arr1, val)';
+select arr1, arrayPushBack(arr1, val) from test_array_functions;
+select 'arrayPushBack(arr1, val2)';
+select arr1, arrayPushBack(arr1, val2) from test_array_functions;
+select 'arrayPushBack([a, b, c], val)';
+select arrayPushBack(['a', 'b', 'c'], val) from test_array_functions;
+select 'arrayPushBack([a, b, c], val2)';
+select arrayPushBack(['a', 'b', 'c'], val2) from test_array_functions;
+
+select 'arrayPopFront(arr1)';
+select arr1, arrayPopFront(arr1) from test_array_functions;
+select 'arrayPopBack(arr1)';
+select arr1, arrayPopBack(arr1) from test_array_functions;

From 0f4e7f1833c653173db848803bd3a7fd93ec9e7d Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 25 Aug 2017 14:19:54 +0300
Subject: [PATCH 009/266] fixed array slice with offset <= -(array length)
 [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.h | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index 90ffb574f14..93f755ce4e0 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -149,7 +149,7 @@ struct NumericArraySource : public IArraySource
     {
         size_t elem_size = offsets[row_num] - prev_offset;
         if (offset >= elem_size)
-            return {&elements[prev_offset], 0};
+            return {&elements[prev_offset], elem_size};
         return {&elements[offsets[row_num] - offset], offset};
     }
 
@@ -157,7 +157,7 @@ struct NumericArraySource : public IArraySource
     {
         size_t elem_size = offsets[row_num] - prev_offset;
         if (offset >= elem_size)
-            return {&elements[prev_offset], 0};
+            return {&elements[prev_offset], length + elem_size > offset ? std::min(elem_size, length + elem_size - offset) : 0};
         return {&elements[offsets[row_num] - offset], std::min(length, offset)};
     }
 };
@@ -621,7 +621,7 @@ struct GenericArraySource : public IArraySource
     {
         size_t elem_size = offsets[row_num] - prev_offset;
         if (offset >= elem_size)
-            return {&elements, prev_offset, 0};
+            return {&elements, prev_offset, elem_size};
         return {&elements, offsets[row_num] - offset, offset};
     }
 
@@ -629,7 +629,7 @@ struct GenericArraySource : public IArraySource
     {
         size_t elem_size = offsets[row_num] - prev_offset;
         if (offset >= elem_size)
-            return {&elements, prev_offset, 0};
+            return {&elements, prev_offset, length + elem_size > offset ? std::min(elem_size, length + elem_size - offset) : 0};
         return {&elements, offsets[row_num] - offset, std::min(length, offset)};
     }
 };
@@ -706,40 +706,40 @@ struct NullableArraySource : public ArraySource
     Slice getSliceFromLeft(size_t offset) const
     {
         Slice slice = ArraySource::getSliceFromLeft(offset);
-        if (!slice.size)
-            slice.null_map = &null_map[prev_offset];
-        else
+        if (offsets[row_num] > prev_offset + offset)
             slice.null_map = &null_map[prev_offset + offset];
+        else
+            slice.null_map = &null_map[prev_offset];
         return slice;
     }
 
     Slice getSliceFromLeft(size_t offset, size_t length) const
     {
         Slice slice = ArraySource::getSliceFromLeft(offset, length);
-        if (!slice.size)
-            slice.null_map = &null_map[prev_offset];
-        else
+        if (offsets[row_num] > prev_offset + offset)
             slice.null_map = &null_map[prev_offset + offset];
+        else
+            slice.null_map = &null_map[prev_offset];
         return slice;
     }
 
     Slice getSliceFromRight(size_t offset) const
     {
         Slice slice = ArraySource::getSliceFromRight(offset);
-        if (!slice.size)
-            slice.null_map = &null_map[prev_offset];
-        else
+        if (offsets[row_num] > prev_offset + offset)
             slice.null_map = &null_map[offsets[row_num] - offset];
+        else
+            slice.null_map = &null_map[prev_offset];
         return slice;
     }
 
     Slice getSliceFromRight(size_t offset, size_t length) const
     {
         Slice slice = ArraySource::getSliceFromRight(offset, length);
-        if (!slice.size)
-            slice.null_map = &null_map[prev_offset];
-        else
+        if (offsets[row_num] > prev_offset + offset)
             slice.null_map = &null_map[offsets[row_num] - offset];
+        else
+            slice.null_map = &null_map[prev_offset];
         return slice;
     }
 

From e223d070311d6a775c08a1a2ccd4a5030e6d6396 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 25 Aug 2017 14:58:33 +0300
Subject: [PATCH 010/266] fixed test [#CLICKHOUSE-2090]

---
 .../00498_array_functions_concat_slice_push_pop.reference       | 2 ++
 .../0_stateless/00498_array_functions_concat_slice_push_pop.sql | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.reference b/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.reference
index e46a94775cd..319518f5efb 100644
--- a/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.reference
+++ b/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.reference
@@ -26,6 +26,8 @@ slice
 [3,4]
 [3,4]
 []
+[1,2,3,4,5,6]
+[1]
 []
 []
 []
diff --git a/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.sql b/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.sql
index 7465fc2c731..2540d2b3fe4 100644
--- a/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.sql
+++ b/dbms/tests/queries/0_stateless/00498_array_functions_concat_slice_push_pop.sql
@@ -28,6 +28,8 @@ select arraySlice([1, 2, 3, 4, 5, 6], -4, 2);
 select arraySlice([1, 2, 3, 4, 5, 6], -4, -2);
 select arraySlice([1, 2, 3, 4, 5, 6], 2, 0);
 select arraySlice([1, 2, 3, 4, 5, 6], -10, 15);
+select arraySlice([1, 2, 3, 4, 5, 6], -15, 10);
+select arraySlice([1, 2, 3, 4, 5, 6], -15, 9);
 select arraySlice([1, 2, 3, 4, 5, 6], 10, 0);
 select arraySlice([1, 2, 3, 4, 5, 6], 10, -1);
 select arraySlice([1, 2, 3, 4, 5, 6], 10, 1);

From 1ec04d1024b71df543dcb7202eca60a9487a14d4 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 25 Aug 2017 16:05:26 +0300
Subject: [PATCH 011/266] supported || for arrayConcat [#CLICKHOUSE-2090]

---
 dbms/src/Functions/FunctionsString.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/dbms/src/Functions/FunctionsString.cpp b/dbms/src/Functions/FunctionsString.cpp
index e1cdc8dc6a1..de1d3686fc0 100644
--- a/dbms/src/Functions/FunctionsString.cpp
+++ b/dbms/src/Functions/FunctionsString.cpp
@@ -683,6 +683,9 @@ public:
 
     DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
     {
+        if (!is_injective && !arguments.empty() && checkDataType<DataTypeArray>(arguments[0].get()))
+            return FunctionArrayConcat().getReturnTypeImpl(arguments);
+
         if (arguments.size() < 2)
             throw Exception("Number of arguments for function " + getName() + " doesn't match: passed " + toString(arguments.size())
                 + ", should be at least 2.",
@@ -702,6 +705,9 @@ public:
 
     void executeImpl(Block & block, const ColumnNumbers & arguments, const size_t result) override
     {
+        if (!is_injective && !arguments.empty() && checkDataType<DataTypeArray>(block.getByPosition(0).type.get()))
+            return FunctionArrayConcat().executeImpl(block, arguments, result);
+
         if (arguments.size() == 2)
             executeBinary(block, arguments, result);
         else

From 24e135fbe6c2d2d2d73fcd6a3fdeccf51b843d66 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 25 Aug 2017 16:54:08 +0300
Subject: [PATCH 012/266] supported arraySlice with 2 arguments, added comments
 [#CLICKHOUSE-2090]

---
 dbms/src/Functions/FunctionsArray.cpp | 17 ++++++++++++-----
 dbms/src/Functions/FunctionsArray.h   | 20 ++++++++++++++++++--
 2 files changed, 30 insertions(+), 7 deletions(-)

diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index 9637997ba19..47cbb030a39 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -3051,6 +3051,13 @@ String FunctionArraySlice::getName() const
 
 DataTypePtr FunctionArraySlice::getReturnTypeImpl(const DataTypes & arguments) const
 {
+    size_t number_of_arguments = arguments.size();
+
+    if (number_of_arguments < 2 || number_of_arguments > 3)
+        throw Exception("Number of arguments for function " + getName() + " doesn't match: passed "
+                        + toString(number_of_arguments) + ", should be 2 or 3",
+                        ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+
     if (arguments[0]->isNull())
         return arguments[0];
 
@@ -3059,7 +3066,7 @@ DataTypePtr FunctionArraySlice::getReturnTypeImpl(const DataTypes & arguments) c
         throw Exception("First argument for function " + getName() + " must be an array but it has type "
                         + arguments[0]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
-    for (size_t i = 1; i < arguments.size(); ++i)
+    for (size_t i = 1; i < number_of_arguments; ++i)
     {
         if (!arguments[i]->isNumeric() && !arguments[i]->isNull())
             throw Exception(
@@ -3079,7 +3086,7 @@ void FunctionArraySlice::executeImpl(Block & block, const ColumnNumbers & argume
 
     auto array_column = block.getByPosition(arguments[0]).column;
     auto offset_column = block.getByPosition(arguments[1]).column;
-    auto length_column = block.getByPosition(arguments[2]).column;
+    auto length_column = arguments.size() > 2 ? block.getByPosition(arguments[2]).column : nullptr;
 
     if (return_type->isNull())
     {
@@ -3107,7 +3114,7 @@ void FunctionArraySlice::executeImpl(Block & block, const ColumnNumbers & argume
 
     if (offset_column->isNull())
     {
-        if (length_column->isNull())
+        if (!length_column || length_column->isNull())
             result_column = array_column->clone();
         else if (length_column->isConst())
             sliceFromLeftConstantOffsetBounded(*source, *sink, 0, length_column->getInt(0));
@@ -3121,7 +3128,7 @@ void FunctionArraySlice::executeImpl(Block & block, const ColumnNumbers & argume
     {
         ssize_t offset = offset_column->getUInt(0);
 
-        if (length_column->isNull())
+        if (!length_column || length_column->isNull())
         {
             if (offset > 0)
                 sliceFromLeftConstantOffsetUnbounded(*source, *sink, static_cast<size_t>(offset - 1));
@@ -3141,7 +3148,7 @@ void FunctionArraySlice::executeImpl(Block & block, const ColumnNumbers & argume
     }
     else
     {
-        if (length_column->isNull())
+        if (!length_column || length_column->isNull())
             sliceDynamicOffsetUnbounded(*source, *sink, *offset_column);
         else
             sliceDynamicOffsetBounded(*source, *sink, *offset_column, *length_column);
diff --git a/dbms/src/Functions/FunctionsArray.h b/dbms/src/Functions/FunctionsArray.h
index 9d3740309f0..af2f04adff2 100644
--- a/dbms/src/Functions/FunctionsArray.h
+++ b/dbms/src/Functions/FunctionsArray.h
@@ -61,6 +61,22 @@ namespace ErrorCodes
   *
   * arrayReduce('agg', arr1, ...) - apply the aggregate function `agg` to arrays `arr1...`
   *  If multiple arrays passed, then elements on corresponding positions are passed as multiple arguments to the aggregate function.
+  *
+  *  arrayConcat(arr1, ...) - concatenate arrays.
+  *
+  *  arraySlice(arr, offset, length) - make slice of array. Offsets and length may be < 0 or Null
+  *   - if offset <= 0, indexation from right element
+  *   - if length < 0, length = len(array) - (positive_index(offset) - 1) + length
+  *   indexation:
+  *     [ 1,  2,  3,  4,  5,  6]
+  *     [-5, -4, -3, -2, -1,  0]
+  *   examples:
+  *     arraySlice([1, 2, 3, 4, 5, 6], -4, 2) -> [2, 3]
+  *     arraySlice([1, 2, 3, 4, 5, 6], 2, -1) -> [2, 3, 4, 5] (6 - (2 - 1) + (-1) = 4)
+  *     arraySlice([1, 2, 3, 4, 5, 6], -4, -1) = arraySlice([1, 2, 3, 4, 5, 6], -4, -1) -> [2, 3, 4, 5]
+  *
+  *  arrayPushBack(arr, x), arrayPushFront(arr, x)
+  *  arrayPopBack(arr), arrayPopFront(arr)
   */
 
 
@@ -1433,8 +1449,8 @@ public:
 
     String getName() const override;
 
-    bool isVariadic() const override { return false; }
-    size_t getNumberOfArguments() const override { return 3; }
+    bool isVariadic() const override { return true; }
+    size_t getNumberOfArguments() const override { return 0; }
 
     DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override;
 

From eb0579813069c0b1ca7ef5b4478c8e4295deb5f4 Mon Sep 17 00:00:00 2001
From: Vitaliy Lyudvichenko <vludv@yandex-team.ru>
Date: Fri, 4 Aug 2017 18:54:00 +0300
Subject: [PATCH 013/266] Add SYSTEM queries parser. [#CLICKHOUSE-2931]

---
 dbms/src/Interpreters/InterpreterFactory.cpp  |  8 +++
 .../Interpreters/InterpreterSystemQuery.cpp   | 14 +++++
 .../src/Interpreters/InterpreterSystemQuery.h | 27 +++++++++
 .../evaluateConstantExpression.cpp            | 23 +++++++-
 .../Interpreters/evaluateConstantExpression.h |  6 ++
 dbms/src/Parsers/ASTQueryWithOnCluster.cpp    | 17 +-----
 dbms/src/Parsers/ASTSetQuery.h                |  2 +-
 dbms/src/Parsers/ASTSystemQuery.cpp           | 55 +++++++++++++++++
 dbms/src/Parsers/ASTSystemQuery.h             | 59 +++++++++++++++++++
 dbms/src/Parsers/ParserQuery.cpp              |  5 +-
 dbms/src/Parsers/ParserSetQuery.h             |  6 +-
 dbms/src/Parsers/ParserSystemQuery.cpp        | 57 ++++++++++++++++++
 dbms/src/Parsers/ParserSystemQuery.h          | 19 ++++++
 .../00486_system_query_simple.reference       |  0
 .../0_stateless/00486_system_query_simple.sh  | 20 +++++++
 15 files changed, 297 insertions(+), 21 deletions(-)
 create mode 100644 dbms/src/Interpreters/InterpreterSystemQuery.cpp
 create mode 100644 dbms/src/Interpreters/InterpreterSystemQuery.h
 create mode 100644 dbms/src/Parsers/ASTSystemQuery.cpp
 create mode 100644 dbms/src/Parsers/ASTSystemQuery.h
 create mode 100644 dbms/src/Parsers/ParserSystemQuery.cpp
 create mode 100644 dbms/src/Parsers/ParserSystemQuery.h
 create mode 100644 dbms/tests/queries/0_stateless/00486_system_query_simple.reference
 create mode 100755 dbms/tests/queries/0_stateless/00486_system_query_simple.sh

diff --git a/dbms/src/Interpreters/InterpreterFactory.cpp b/dbms/src/Interpreters/InterpreterFactory.cpp
index cbd7a10b8c4..63ceb3d1c4b 100644
--- a/dbms/src/Interpreters/InterpreterFactory.cpp
+++ b/dbms/src/Interpreters/InterpreterFactory.cpp
@@ -32,6 +32,9 @@
 #include <Interpreters/InterpreterFactory.h>
 
 #include <Common/typeid_cast.h>
+#include <Parsers/ASTSystemQuery.h>
+#include "InterpreterSystemQuery.h"
+
 
 namespace DB
 {
@@ -123,6 +126,11 @@ std::unique_ptr<IInterpreter> InterpreterFactory::get(ASTPtr & query, Context &
     {
         return std::make_unique<InterpreterKillQueryQuery>(query, context);
     }
+    else if (typeid_cast<ASTSystemQuery *>(query.get()))
+    {
+        throwIfReadOnly(context);
+        return std::make_unique<InterpreterSystemQuery>(query, context);
+    }
     else
         throw Exception("Unknown type of query: " + query->getID(), ErrorCodes::UNKNOWN_TYPE_OF_QUERY);
 }
diff --git a/dbms/src/Interpreters/InterpreterSystemQuery.cpp b/dbms/src/Interpreters/InterpreterSystemQuery.cpp
new file mode 100644
index 00000000000..b454b5375e6
--- /dev/null
+++ b/dbms/src/Interpreters/InterpreterSystemQuery.cpp
@@ -0,0 +1,14 @@
+#include "InterpreterSystemQuery.h"
+
+namespace DB
+{
+
+InterpreterSystemQuery::InterpreterSystemQuery(const ASTPtr & query_ptr_, Context & context_)
+        : query_ptr(query_ptr_), context(context_) {}
+
+BlockIO InterpreterSystemQuery::execute()
+{
+    return BlockIO();
+}
+
+}
\ No newline at end of file
diff --git a/dbms/src/Interpreters/InterpreterSystemQuery.h b/dbms/src/Interpreters/InterpreterSystemQuery.h
new file mode 100644
index 00000000000..f6010dafc5b
--- /dev/null
+++ b/dbms/src/Interpreters/InterpreterSystemQuery.h
@@ -0,0 +1,27 @@
+#pragma once
+#include <Interpreters/IInterpreter.h>
+
+namespace DB
+{
+
+class Context;
+class IAST;
+using ASTPtr = std::shared_ptr<IAST>;
+
+
+/** Return list of currently executing queries.
+  */
+class InterpreterSystemQuery : public IInterpreter
+{
+public:
+    InterpreterSystemQuery(const ASTPtr & query_ptr_, Context & context_);
+
+    BlockIO execute() override;
+
+private:
+    ASTPtr query_ptr;
+    Context & context;
+};
+
+
+}
diff --git a/dbms/src/Interpreters/evaluateConstantExpression.cpp b/dbms/src/Interpreters/evaluateConstantExpression.cpp
index 24ea8924c38..82fda244573 100644
--- a/dbms/src/Interpreters/evaluateConstantExpression.cpp
+++ b/dbms/src/Interpreters/evaluateConstantExpression.cpp
@@ -4,6 +4,7 @@
 #include <Parsers/IAST.h>
 #include <Parsers/ASTIdentifier.h>
 #include <Parsers/ASTLiteral.h>
+#include <Parsers/ExpressionElementParsers.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <Interpreters/Context.h>
 #include <Interpreters/ExpressionAnalyzer.h>
@@ -62,10 +63,30 @@ ASTPtr evaluateConstantExpressionAsLiteral(ASTPtr & node, const Context & contex
 
 ASTPtr evaluateConstantExpressionOrIdentifierAsLiteral(ASTPtr & node, const Context & context)
 {
-    if (const ASTIdentifier * id = typeid_cast<const ASTIdentifier *>(node.get()))
+    if (auto id = typeid_cast<const ASTIdentifier *>(node.get()))
         return std::make_shared<ASTLiteral>(node->range, Field(id->name));
 
     return evaluateConstantExpressionAsLiteral(node, context);
 }
 
+
+bool parseIdentifierOrStringLiteral(IParser::Pos & pos, Expected & expected, String & result)
+{
+    IParser::Pos begin = pos;
+    ASTPtr res;
+
+    if (!ParserIdentifier().parse(pos, res, expected))
+    {
+        pos = begin;
+        if (!ParserStringLiteral().parse(pos, res, expected))
+            return false;
+
+        result = typeid_cast<const ASTLiteral &>(*res).value.safeGet<String>();
+    }
+    else
+        result = typeid_cast<const ASTIdentifier &>(*res).name;
+
+    return true;
+}
+
 }
diff --git a/dbms/src/Interpreters/evaluateConstantExpression.h b/dbms/src/Interpreters/evaluateConstantExpression.h
index ed3befdf02b..f5833a1af18 100644
--- a/dbms/src/Interpreters/evaluateConstantExpression.h
+++ b/dbms/src/Interpreters/evaluateConstantExpression.h
@@ -2,6 +2,7 @@
 
 #include <memory>
 #include <Core/Field.h>
+#include <Parsers/IParser.h>
 
 
 namespace DB
@@ -11,6 +12,7 @@ class IAST;
 class Context;
 class IDataType;
 
+
 /** Evaluate constant expression and its type.
   * Used in rare cases - for elements of set for IN, for data to INSERT.
   * Quite suboptimal.
@@ -31,4 +33,8 @@ std::shared_ptr<IAST> evaluateConstantExpressionAsLiteral(std::shared_ptr<IAST>
   */
 std::shared_ptr<IAST> evaluateConstantExpressionOrIdentifierAsLiteral(std::shared_ptr<IAST> & node, const Context & context);
 
+/** Parses a name of an object which could be written in 3 forms:
+  * name, `name` or 'name' */
+bool parseIdentifierOrStringLiteral(IParser::Pos & pos, Expected & expected, String & result);
+
 }
diff --git a/dbms/src/Parsers/ASTQueryWithOnCluster.cpp b/dbms/src/Parsers/ASTQueryWithOnCluster.cpp
index 98dacfab2c5..4812bdd110f 100644
--- a/dbms/src/Parsers/ASTQueryWithOnCluster.cpp
+++ b/dbms/src/Parsers/ASTQueryWithOnCluster.cpp
@@ -5,6 +5,7 @@
 #include <Parsers/ASTIdentifier.h>
 #include <Parsers/ASTLiteral.h>
 #include <Common/typeid_cast.h>
+#include <Interpreters/evaluateConstantExpression.h>
 
 
 namespace DB
@@ -21,21 +22,7 @@ bool ASTQueryWithOnCluster::parse(Pos & pos, std::string & cluster_str, Expected
     if (!ParserKeyword{"CLUSTER"}.ignore(pos, expected))
         return false;
 
-    Pos begin = pos;
-    ASTPtr res;
-
-    if (!ParserIdentifier().parse(pos, res, expected))
-    {
-        pos = begin;
-        if (!ParserStringLiteral().parse(pos, res, expected))
-            return false;
-        else
-            cluster_str = typeid_cast<const ASTLiteral &>(*res).value.safeGet<String>();
-    }
-    else
-        cluster_str = typeid_cast<const ASTIdentifier &>(*res).name;
-
-    return true;
+    return parseIdentifierOrStringLiteral(pos, expected, cluster_str);
 }
 
 
diff --git a/dbms/src/Parsers/ASTSetQuery.h b/dbms/src/Parsers/ASTSetQuery.h
index d359f6d4e28..c2acb2c3aff 100644
--- a/dbms/src/Parsers/ASTSetQuery.h
+++ b/dbms/src/Parsers/ASTSetQuery.h
@@ -24,7 +24,7 @@ public:
     Changes changes;
 
     ASTSetQuery() = default;
-    ASTSetQuery(const StringRange range_) : IAST(range_) {}
+    explicit ASTSetQuery(const StringRange range_) : IAST(range_) {}
 
     /** Get the text that identifies this element. */
     String getID() const override { return "Set"; };
diff --git a/dbms/src/Parsers/ASTSystemQuery.cpp b/dbms/src/Parsers/ASTSystemQuery.cpp
new file mode 100644
index 00000000000..2eb45f5b5e9
--- /dev/null
+++ b/dbms/src/Parsers/ASTSystemQuery.cpp
@@ -0,0 +1,55 @@
+#include <Parsers/IAST.h>
+#include <Parsers/ASTSystemQuery.h>
+
+
+namespace ErrorCodes
+{
+    extern const int BAD_TYPE_OF_FIELD;
+}
+
+
+namespace DB
+{
+
+
+const char * ASTSystemQuery::typeToString(Type type)
+{
+    switch (type)
+    {
+        case Type::SHUTDOWN:
+            return "SHUTDOWN";
+        case Type::KILL:
+            return "KILL";
+        case Type::DROP_DNS_CACHE:
+            return "DROP DNS CACHE";
+        case Type::DROP_MARK_CACHE:
+            return "DROP MARK CACHE";
+        case Type::DROP_UNCOMPRESSED_CACHE:
+            return "DROP UNCOMPRESSED CACHE";
+        case Type::STOP_LISTEN_QUERIES:
+            return "STOP LISTEN QUERIES";
+        case Type::START_LISTEN_QUERIES:
+            return "START LISTEN QUERIES";
+        case Type::RESTART_REPLICAS:
+            return "RESTART REPLICAS";
+        case Type::SYNC_REPLICA:
+            return "SYNC REPLICA";
+        case Type::RELOAD_DICTIONARY:
+            return "RELOAD DICTIONARY";
+        case Type::RELOAD_DICTIONARIES:
+            return "RELOAD DICTIONARIES";
+        case Type::STOP_MERGES:
+            return "STOP MERGES";
+        case Type::START_MERGES:
+            return "START MERGES";
+        case Type::STOP_REPLICATION_QUEUES:
+            return "STOP REPLICATION QUEUES";
+        case Type::START_REPLICATION_QUEUES:
+            return "START REPLICATION QUEUES";
+        default:
+            throw Exception("Unknown SYSTEM query command", ErrorCodes::BAD_TYPE_OF_FIELD);
+    }
+}
+
+
+}
\ No newline at end of file
diff --git a/dbms/src/Parsers/ASTSystemQuery.h b/dbms/src/Parsers/ASTSystemQuery.h
new file mode 100644
index 00000000000..e4f08a4eb12
--- /dev/null
+++ b/dbms/src/Parsers/ASTSystemQuery.h
@@ -0,0 +1,59 @@
+#pragma once
+#include <Parsers/IAST.h>
+#include <AggregateFunctions/AggregateFunctionCount.h>
+
+
+namespace DB
+{
+
+class ASTSystemQuery : public IAST
+{
+public:
+
+    enum class Type
+    {
+        _UNKNOWN,
+        SHUTDOWN,
+        KILL,
+        DROP_DNS_CACHE,
+        DROP_MARK_CACHE,
+        DROP_UNCOMPRESSED_CACHE,
+        STOP_LISTEN_QUERIES,
+        START_LISTEN_QUERIES,
+        RESTART_REPLICAS,
+        SYNC_REPLICA,
+        RELOAD_DICTIONARY,
+        RELOAD_DICTIONARIES,
+        STOP_MERGES,
+        START_MERGES,
+        STOP_REPLICATION_QUEUES,
+        START_REPLICATION_QUEUES,
+        _END
+    };
+
+    static const char * typeToString(Type type);
+
+    Type type = Type::_UNKNOWN;
+
+    String target_dictionary;
+    //String target_replica;
+
+    ASTSystemQuery() = default;
+    explicit ASTSystemQuery(const StringRange range) : IAST(range) {}
+
+    String getID() const override { return "SYSTEM"; };
+
+    ASTPtr clone() const override { return std::make_shared<ASTSystemQuery>(*this); }
+
+    ~ASTSystemQuery() override = default;
+
+protected:
+
+    void formatImpl(const FormatSettings & settings, FormatState & state, FormatStateStacked frame) const override
+    {
+        settings.ostr << (settings.hilite ? hilite_keyword : "") << "SYSTEM " << (settings.hilite ? hilite_none : "");
+    }
+};
+
+
+}
\ No newline at end of file
diff --git a/dbms/src/Parsers/ParserQuery.cpp b/dbms/src/Parsers/ParserQuery.cpp
index 6a93110c143..3506c8c92ea 100644
--- a/dbms/src/Parsers/ParserQuery.cpp
+++ b/dbms/src/Parsers/ParserQuery.cpp
@@ -8,6 +8,7 @@
 #include <Parsers/ParserUseQuery.h>
 #include <Parsers/ParserSetQuery.h>
 #include <Parsers/ParserAlterQuery.h>
+#include "ParserSystemQuery.h"
 
 
 namespace DB
@@ -22,12 +23,14 @@ bool ParserQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
     ParserUseQuery use_p;
     ParserSetQuery set_p;
     ParserOptimizeQuery optimize_p;
+    ParserSystemQuery system_p;
 
     bool res = query_with_output_p.parse(pos, node, expected)
         || insert_p.parse(pos, node, expected)
         || use_p.parse(pos, node, expected)
         || set_p.parse(pos, node, expected)
-        || optimize_p.parse(pos, node, expected);
+        || optimize_p.parse(pos, node, expected)
+        || system_p.parse(pos, node, expected);
 
     return res;
 }
diff --git a/dbms/src/Parsers/ParserSetQuery.h b/dbms/src/Parsers/ParserSetQuery.h
index 64f6b5d96be..d48ecd8ddab 100644
--- a/dbms/src/Parsers/ParserSetQuery.h
+++ b/dbms/src/Parsers/ParserSetQuery.h
@@ -13,11 +13,11 @@ namespace DB
 class ParserSetQuery : public IParserBase
 {
 public:
-    ParserSetQuery(bool parse_only_internals_ = false) : parse_only_internals(parse_only_internals_) {}
+    explicit ParserSetQuery(bool parse_only_internals_ = false) : parse_only_internals(parse_only_internals_) {}
 
 protected:
-    const char * getName() const { return "SET query"; }
-    bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected);
+    const char * getName() const override { return "SET query"; }
+    bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
 
     /// Parse the list `name = value` pairs, without SET [GLOBAL].
     bool parse_only_internals;
diff --git a/dbms/src/Parsers/ParserSystemQuery.cpp b/dbms/src/Parsers/ParserSystemQuery.cpp
new file mode 100644
index 00000000000..5aa340a4785
--- /dev/null
+++ b/dbms/src/Parsers/ParserSystemQuery.cpp
@@ -0,0 +1,57 @@
+#include <Parsers/ParserSystemQuery.h>
+#include <Parsers/ASTSystemQuery.h>
+#include <Parsers/CommonParsers.h>
+#include <Parsers/ASTIdentifier.h>
+#include <Parsers/ASTLiteral.h>
+#include <Interpreters/evaluateConstantExpression.h>
+#include "ASTSystemQuery.h"
+
+
+namespace ErrorCodes
+{
+    extern const int NOT_IMPLEMENTED;
+}
+
+
+namespace DB
+{
+
+
+bool ParserSystemQuery::parseImpl(IParser::Pos & pos, ASTPtr & node, Expected & expected)
+{
+    if (!ParserKeyword{"SYSTEM"}.ignore(pos))
+        return false;
+
+    using Type = ASTSystemQuery::Type;
+
+    auto res = std::make_shared<ASTSystemQuery>();
+
+    bool found = false;
+    for (int i = static_cast<int>(Type::SHUTDOWN); i < static_cast<int>(Type::_END); ++i)
+    {
+        Type t = static_cast<Type>(i);
+        if (ParserKeyword{ASTSystemQuery::typeToString(t)}.ignore(pos))
+        {
+            res->type = t;
+            found = true;
+        }
+    }
+
+    if (!found)
+        return false;
+
+    if (res->type == Type::RELOAD_DICTIONARY)
+    {
+        if (!parseIdentifierOrStringLiteral(pos, expected, res->target_dictionary))
+            return false;
+    }
+    else if (res->type == Type::SYNC_REPLICA)
+    {
+        throw Exception("SYNC REPLICA is not supported yet", ErrorCodes::NOT_IMPLEMENTED);
+    }
+
+    node = std::move(res);
+    return true;
+}
+
+}
diff --git a/dbms/src/Parsers/ParserSystemQuery.h b/dbms/src/Parsers/ParserSystemQuery.h
new file mode 100644
index 00000000000..745e7748220
--- /dev/null
+++ b/dbms/src/Parsers/ParserSystemQuery.h
@@ -0,0 +1,19 @@
+#pragma once
+#include <Parsers/IParserBase.h>
+
+
+namespace DB
+{
+
+
+class ParserSystemQuery : public IParserBase
+{
+public:
+    ParserSystemQuery() = default;
+
+protected:
+    const char * getName() const override { return "SYSTEM query"; }
+    bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
+};
+
+}
\ No newline at end of file
diff --git a/dbms/tests/queries/0_stateless/00486_system_query_simple.reference b/dbms/tests/queries/0_stateless/00486_system_query_simple.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/dbms/tests/queries/0_stateless/00486_system_query_simple.sh b/dbms/tests/queries/0_stateless/00486_system_query_simple.sh
new file mode 100755
index 00000000000..1b20cb032d0
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00486_system_query_simple.sh
@@ -0,0 +1,20 @@
+#!/bin/bash
+set -e
+
+cli="clickhouse-client -q "
+
+$cli "SYSTEM SHUTDOWN"
+$cli "SYSTEM KILL"
+$cli "SYSTEM DROP DNS CACHE"
+$cli "SYSTEM DROP MARK CACHE"
+$cli "SYSTEM DROP UNCOMPRESSED CACHE"
+$cli "SYSTEM STOP LISTEN QUERIES"
+$cli "SYSTEM START LISTEN QUERIES"
+$cli "SYSTEM RESTART REPLICAS"
+#$cli "SYSTEM SYNC REPLICA test"
+$cli "SYSTEM RELOAD DICTIONARY dict"
+$cli "SYSTEM RELOAD DICTIONARIES"
+$cli "SYSTEM STOP MERGES"
+$cli "SYSTEM START MERGES"
+$cli "SYSTEM STOP REPLICATION QUEUES"
+$cli "SYSTEM START REPLICATION QUEUES"

From ffe7558fe265189f04827233b42f712d00658024 Mon Sep 17 00:00:00 2001
From: Vitaliy Lyudvichenko <vludv@yandex-team.ru>
Date: Sun, 6 Aug 2017 23:26:23 +0300
Subject: [PATCH 014/266] Add SYSTEM KILL and SHUTDOWN implementations.
 [#CLICKHOUSE-2931]

---
 dbms/src/Core/ErrorCodes.cpp                  |  1 +
 .../Interpreters/InterpreterSystemQuery.cpp   | 50 ++++++++++++++++++-
 .../src/Interpreters/InterpreterSystemQuery.h |  3 +-
 dbms/src/Parsers/ASTSystemQuery.cpp           | 22 ++++++--
 dbms/src/Parsers/ASTSystemQuery.h             | 10 ++--
 5 files changed, 73 insertions(+), 13 deletions(-)

diff --git a/dbms/src/Core/ErrorCodes.cpp b/dbms/src/Core/ErrorCodes.cpp
index ceee11c9e2b..8fbb1956941 100644
--- a/dbms/src/Core/ErrorCodes.cpp
+++ b/dbms/src/Core/ErrorCodes.cpp
@@ -382,6 +382,7 @@ namespace ErrorCodes
     extern const int ILLEGAL_SYNTAX_FOR_DATA_TYPE = 377;
     extern const int DATA_TYPE_CANNOT_HAVE_ARGUMENTS = 378;
     extern const int UNKNOWN_STATUS_OF_DISTRIBUTED_DDL_TASK = 379;
+    extern const int CANNOT_KILL = 380;
 
     extern const int KEEPER_EXCEPTION = 999;
     extern const int POCO_EXCEPTION = 1000;
diff --git a/dbms/src/Interpreters/InterpreterSystemQuery.cpp b/dbms/src/Interpreters/InterpreterSystemQuery.cpp
index b454b5375e6..e738f5978b7 100644
--- a/dbms/src/Interpreters/InterpreterSystemQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterSystemQuery.cpp
@@ -1,14 +1,62 @@
-#include "InterpreterSystemQuery.h"
+#include <Interpreters/InterpreterSystemQuery.h>
+#include <Parsers/ASTSystemQuery.h>
+#include <Common/typeid_cast.h>
+#include <csignal>
+
 
 namespace DB
 {
 
+
+namespace ErrorCodes
+{
+    extern const int BAD_ARGUMENTS;
+    extern const int CANNOT_KILL;
+}
+
+
 InterpreterSystemQuery::InterpreterSystemQuery(const ASTPtr & query_ptr_, Context & context_)
         : query_ptr(query_ptr_), context(context_) {}
 
+
 BlockIO InterpreterSystemQuery::execute()
 {
+    auto & query = typeid_cast<ASTSystemQuery &>(*query_ptr);
+
+    using Type = ASTSystemQuery::Type;
+
+    switch (query.type)
+    {
+        case Type::SHUTDOWN:
+            if (kill(0, SIGTERM))
+                throw Exception("System call kill() failed", ErrorCodes::CANNOT_KILL);
+            break;
+        case Type::KILL:
+            if (kill(0, SIGKILL))
+                throw Exception("System call kill() failed", ErrorCodes::CANNOT_KILL);
+            break;
+        case Type::DROP_DNS_CACHE:
+            break;
+        case Type::DROP_MARK_CACHE:
+            break;
+        case Type::DROP_UNCOMPRESSED_CACHE:
+            break;
+        case Type::STOP_LISTEN_QUERIES:break;
+        case Type::START_LISTEN_QUERIES:break;
+        case Type::RESTART_REPLICAS:break;
+        case Type::SYNC_REPLICA:break;
+        case Type::RELOAD_DICTIONARY:break;
+        case Type::RELOAD_DICTIONARIES:break;
+        case Type::STOP_MERGES:break;
+        case Type::START_MERGES:break;
+        case Type::STOP_REPLICATION_QUEUES:break;
+        case Type::START_REPLICATION_QUEUES:break;
+        default:
+            throw Exception("Unknown type of SYSTEM query", ErrorCodes::BAD_ARGUMENTS);
+    }
+
     return BlockIO();
 }
 
+
 }
\ No newline at end of file
diff --git a/dbms/src/Interpreters/InterpreterSystemQuery.h b/dbms/src/Interpreters/InterpreterSystemQuery.h
index f6010dafc5b..9f797b98383 100644
--- a/dbms/src/Interpreters/InterpreterSystemQuery.h
+++ b/dbms/src/Interpreters/InterpreterSystemQuery.h
@@ -1,6 +1,7 @@
 #pragma once
 #include <Interpreters/IInterpreter.h>
 
+
 namespace DB
 {
 
@@ -9,8 +10,6 @@ class IAST;
 using ASTPtr = std::shared_ptr<IAST>;
 
 
-/** Return list of currently executing queries.
-  */
 class InterpreterSystemQuery : public IInterpreter
 {
 public:
diff --git a/dbms/src/Parsers/ASTSystemQuery.cpp b/dbms/src/Parsers/ASTSystemQuery.cpp
index 2eb45f5b5e9..753b2c05a26 100644
--- a/dbms/src/Parsers/ASTSystemQuery.cpp
+++ b/dbms/src/Parsers/ASTSystemQuery.cpp
@@ -2,16 +2,17 @@
 #include <Parsers/ASTSystemQuery.h>
 
 
+namespace DB
+{
+
+
 namespace ErrorCodes
 {
     extern const int BAD_TYPE_OF_FIELD;
+    extern const int NOT_IMPLEMENTED;
 }
 
 
-namespace DB
-{
-
-
 const char * ASTSystemQuery::typeToString(Type type)
 {
     switch (type)
@@ -52,4 +53,17 @@ const char * ASTSystemQuery::typeToString(Type type)
 }
 
 
+void ASTSystemQuery::formatImpl(const IAST::FormatSettings & settings, IAST::FormatState & state,
+                                IAST::FormatStateStacked frame) const
+{
+    settings.ostr << (settings.hilite ? hilite_keyword : "") << "SYSTEM " << (settings.hilite ? hilite_none : "");
+    settings.ostr << typeToString(type);
+
+    if (type == Type::RELOAD_DICTIONARY)
+        settings.ostr << " " << backQuoteIfNeed(target_dictionary);
+    else if (type == Type::SYNC_REPLICA)
+        throw Exception("SYNC_REPLICA isn't supported yet", ErrorCodes::NOT_IMPLEMENTED);
+}
+
+
 }
\ No newline at end of file
diff --git a/dbms/src/Parsers/ASTSystemQuery.h b/dbms/src/Parsers/ASTSystemQuery.h
index e4f08a4eb12..5573345ffa0 100644
--- a/dbms/src/Parsers/ASTSystemQuery.h
+++ b/dbms/src/Parsers/ASTSystemQuery.h
@@ -36,12 +36,13 @@ public:
     Type type = Type::_UNKNOWN;
 
     String target_dictionary;
-    //String target_replica;
+    //String target_replica_database;
+    //String target_replica_table;
 
     ASTSystemQuery() = default;
     explicit ASTSystemQuery(const StringRange range) : IAST(range) {}
 
-    String getID() const override { return "SYSTEM"; };
+    String getID() const override { return "SYSTEM query"; };
 
     ASTPtr clone() const override { return std::make_shared<ASTSystemQuery>(*this); }
 
@@ -49,10 +50,7 @@ public:
 
 protected:
 
-    void formatImpl(const FormatSettings & settings, FormatState & state, FormatStateStacked frame) const override
-    {
-        settings.ostr << (settings.hilite ? hilite_keyword : "") << "SYSTEM " << (settings.hilite ? hilite_none : "");
-    }
+    void formatImpl(const FormatSettings & settings, FormatState & state, FormatStateStacked frame) const override;
 };
 
 

From 48f5d8f1a3e0f980e1d559d0a5cd4b9ebbe29220 Mon Sep 17 00:00:00 2001
From: Vitaliy Lyudvichenko <vludv@yandex-team.ru>
Date: Mon, 7 Aug 2017 20:01:04 +0300
Subject: [PATCH 015/266] Add SYSTEM DROP DNS CACHE. [#CLICKHOUSE-2931]

---
 dbms/src/Common/SimpleCache.h                 |  6 +++
 dbms/src/IO/ReadWriteBufferFromHTTP.cpp       | 19 ++-----
 dbms/src/Interpreters/Cluster.cpp             | 22 ++------
 dbms/src/Interpreters/Context.cpp             | 42 ++++++++++++----
 dbms/src/Interpreters/Context.h               | 30 +++++------
 dbms/src/Interpreters/DDLWorker.cpp           |  3 +-
 dbms/src/Interpreters/DNSCache.cpp            | 50 +++++++++++++++++++
 dbms/src/Interpreters/DNSCache.h              | 35 +++++++++++++
 .../Interpreters/InterpreterSystemQuery.cpp   | 28 +++++++----
 dbms/src/Parsers/ParserQuery.cpp              |  2 +-
 dbms/src/Storages/MergeTree/MergeTreeData.cpp |  6 +--
 dbms/src/Storages/StorageMergeTree.cpp        |  2 +-
 12 files changed, 173 insertions(+), 72 deletions(-)
 create mode 100644 dbms/src/Interpreters/DNSCache.cpp
 create mode 100644 dbms/src/Interpreters/DNSCache.h

diff --git a/dbms/src/Common/SimpleCache.h b/dbms/src/Common/SimpleCache.h
index 67602c00d02..81043876fdd 100644
--- a/dbms/src/Common/SimpleCache.h
+++ b/dbms/src/Common/SimpleCache.h
@@ -52,4 +52,10 @@ public:
 
         return res;
     }
+
+    void dropCache()
+    {
+        std::lock_guard<std::mutex> lock(mutex);
+        cache.clear();
+    }
 };
diff --git a/dbms/src/IO/ReadWriteBufferFromHTTP.cpp b/dbms/src/IO/ReadWriteBufferFromHTTP.cpp
index ab5822d920e..6545bc7e739 100644
--- a/dbms/src/IO/ReadWriteBufferFromHTTP.cpp
+++ b/dbms/src/IO/ReadWriteBufferFromHTTP.cpp
@@ -4,15 +4,17 @@
 #include <Common/config.h>
 #include <Core/Types.h>
 #include <IO/ReadBufferFromIStream.h>
-#include <Poco/Net/DNS.h>
+#include <Interpreters/DNSCache.h>
 #include <Poco/Net/HTTPRequest.h>
 #include <Poco/Net/HTTPResponse.h>
-#include <Poco/URI.h>
 #include <Poco/Version.h>
 #include <common/logger_useful.h>
 
 #if Poco_NetSSL_FOUND
 #include <Poco/Net/HTTPSClientSession.h>
+#include <Interpreters/DNSCache.h>
+
+
 #endif
 
 
@@ -24,17 +26,6 @@ namespace ErrorCodes
     extern const int RECEIVED_ERROR_TOO_MANY_REQUESTS;
 }
 
-static Poco::Net::IPAddress resolveHostImpl(const String & host)
-{
-    return Poco::Net::DNS::resolveOne(host);
-}
-
-static Poco::Net::IPAddress resolveHost(const String & host)
-{
-    static SimpleCache<decltype(resolveHostImpl), &resolveHostImpl> cache;
-    return cache(host);
-}
-
 
 ReadWriteBufferFromHTTP::ReadWriteBufferFromHTTP(const Poco::URI & uri,
     const std::string & method_,
@@ -55,7 +46,7 @@ ReadWriteBufferFromHTTP::ReadWriteBufferFromHTTP(const Poco::URI & uri,
                new Poco::Net::HTTPClientSession)
 }
 {
-    session->setHost(resolveHost(uri.getHost()).toString()); /// Cache DNS forever (until server restart)
+    session->setHost(DNSCache::instance().resolveHost(uri.getHost()).toString());
     session->setPort(uri.getPort());
 
 #if POCO_CLICKHOUSE_PATCH || POCO_VERSION >= 0x02000000
diff --git a/dbms/src/Interpreters/Cluster.cpp b/dbms/src/Interpreters/Cluster.cpp
index f2af88823fa..d1196cf7d4e 100644
--- a/dbms/src/Interpreters/Cluster.cpp
+++ b/dbms/src/Interpreters/Cluster.cpp
@@ -1,4 +1,5 @@
 #include <Interpreters/Cluster.h>
+#include <Interpreters/DNSCache.h>
 #include <Common/escapeForFileName.h>
 #include <Common/isLocalAddress.h>
 #include <Common/SimpleCache.h>
@@ -44,27 +45,14 @@ inline bool isLocal(const Cluster::Address & address)
 }
 
 
-/// To cache DNS requests.
-Poco::Net::SocketAddress resolveSocketAddressImpl1(const String & host, UInt16 port)
-{
-    return Poco::Net::SocketAddress(host, port);
-}
-
-Poco::Net::SocketAddress resolveSocketAddressImpl2(const String & host_and_port)
-{
-    return Poco::Net::SocketAddress(host_and_port);
-}
-
 Poco::Net::SocketAddress resolveSocketAddress(const String & host, UInt16 port)
 {
-    static SimpleCache<decltype(resolveSocketAddressImpl1), &resolveSocketAddressImpl1> cache;
-    return cache(host, port);
+    return Poco::Net::SocketAddress(DNSCache::instance().resolveHost(host), port);
 }
 
 Poco::Net::SocketAddress resolveSocketAddress(const String & host_and_port)
 {
-    static SimpleCache<decltype(resolveSocketAddressImpl2), &resolveSocketAddressImpl2> cache;
-    return cache(host_and_port);
+    return DNSCache::instance().resolveHostAndPort(host_and_port);
 }
 
 }
@@ -74,7 +62,7 @@ Poco::Net::SocketAddress resolveSocketAddress(const String & host_and_port)
 Cluster::Address::Address(Poco::Util::AbstractConfiguration & config, const String & config_prefix)
 {
     host_name = config.getString(config_prefix + ".host");
-    port = config.getInt(config_prefix + ".port");
+    port = static_cast<UInt16>(config.getInt(config_prefix + ".port"));
     resolved_address = resolveSocketAddress(host_name, port);
     user = config.getString(config_prefix + ".user", "default");
     password = config.getString(config_prefix + ".password", "");
@@ -86,7 +74,7 @@ Cluster::Address::Address(Poco::Util::AbstractConfiguration & config, const Stri
 Cluster::Address::Address(const String & host_port_, const String & user_, const String & password_)
     : user(user_), password(password_)
 {
-    UInt16 default_port = Poco::Util::Application::instance().config().getInt("tcp_port", 0);
+    UInt16 default_port = static_cast<UInt16>(Poco::Util::Application::instance().config().getInt("tcp_port", 0));
 
     /// It's like that 'host_port_' string contains port. If condition is met, it doesn't necessarily mean that port exists (example: [::]).
     if ((nullptr != strchr(host_port_.c_str(), ':')) || !default_port)
diff --git a/dbms/src/Interpreters/Context.cpp b/dbms/src/Interpreters/Context.cpp
index c011734bdb1..7aa072a48e3 100644
--- a/dbms/src/Interpreters/Context.cpp
+++ b/dbms/src/Interpreters/Context.cpp
@@ -36,6 +36,7 @@
 #include <Interpreters/QueryLog.h>
 #include <Interpreters/PartLog.h>
 #include <Interpreters/Context.h>
+#include <Interpreters/DNSCache.h>
 #include <IO/ReadBufferFromFile.h>
 #include <IO/UncompressedCache.h>
 #include <Parsers/ASTCreateQuery.h>
@@ -1094,6 +1095,15 @@ UncompressedCachePtr Context::getUncompressedCache() const
     return shared->uncompressed_cache;
 }
 
+
+void Context::dropUncompressedCache() const
+{
+    auto lock = getLock();
+    if (shared->uncompressed_cache)
+        shared->uncompressed_cache->reset();
+}
+
+
 void Context::setMarkCache(size_t cache_size_in_bytes)
 {
     auto lock = getLock();
@@ -1104,12 +1114,33 @@ void Context::setMarkCache(size_t cache_size_in_bytes)
     shared->mark_cache = std::make_shared<MarkCache>(cache_size_in_bytes, std::chrono::seconds(settings.mark_cache_min_lifetime));
 }
 
+
 MarkCachePtr Context::getMarkCache() const
 {
     auto lock = getLock();
     return shared->mark_cache;
 }
 
+
+void Context::dropMarkCache() const
+{
+    auto lock = getLock();
+    if (shared->mark_cache)
+        shared->mark_cache->reset();
+}
+
+
+void Context::dropCaches() const
+{
+    auto lock = getLock();
+
+    if (shared->uncompressed_cache)
+        shared->uncompressed_cache->reset();
+
+    if (shared->mark_cache)
+        shared->mark_cache->reset();
+}
+
 BackgroundProcessingPool & Context::getBackgroundPool()
 {
     auto lock = getLock();
@@ -1151,17 +1182,6 @@ DDLWorker & Context::getDDLWorker()
     return *shared->ddl_worker;
 }
 
-void Context::resetCaches() const
-{
-    auto lock = getLock();
-
-    if (shared->uncompressed_cache)
-        shared->uncompressed_cache->reset();
-
-    if (shared->mark_cache)
-        shared->mark_cache->reset();
-}
-
 void Context::setZooKeeper(zkutil::ZooKeeperPtr zookeeper)
 {
     std::lock_guard<std::mutex> lock(shared->zookeeper_mutex);
diff --git a/dbms/src/Interpreters/Context.h b/dbms/src/Interpreters/Context.h
index f2e5855bc6b..29b51a4f94d 100644
--- a/dbms/src/Interpreters/Context.h
+++ b/dbms/src/Interpreters/Context.h
@@ -248,8 +248,8 @@ public:
     Context & getGlobalContext();
     bool hasGlobalContext() const { return global_context != nullptr; }
 
-    void setSessionContext(Context & context_)                                { session_context = &context_; }
-    void setGlobalContext(Context & context_)                                { global_context = &context_; }
+    void setSessionContext(Context & context_)                                  { session_context = &context_; }
+    void setGlobalContext(Context & context_)                                   { global_context = &context_; }
 
     const Settings & getSettingsRef() const { return settings; };
     Settings & getSettingsRef() { return settings; };
@@ -273,19 +273,29 @@ public:
     MergeList & getMergeList();
     const MergeList & getMergeList() const;
 
-    /// Create a cache of uncompressed blocks of specified size. This can be done only once.
-    void setUncompressedCache(size_t max_size_in_bytes);
-    std::shared_ptr<UncompressedCache> getUncompressedCache() const;
-
     void setZooKeeper(std::shared_ptr<zkutil::ZooKeeper> zookeeper);
     /// If the current session is expired at the time of the call, synchronously creates and returns a new session with the startNewSession() call.
     std::shared_ptr<zkutil::ZooKeeper> getZooKeeper() const;
     /// Has ready or expired ZooKeeper
     bool hasZooKeeper() const;
 
+    /// Create a cache of uncompressed blocks of specified size. This can be done only once.
+    void setUncompressedCache(size_t max_size_in_bytes);
+    std::shared_ptr<UncompressedCache> getUncompressedCache() const;
+    void dropUncompressedCache() const;
+
     /// Create a cache of marks of specified size. This can be done only once.
     void setMarkCache(size_t cache_size_in_bytes);
     std::shared_ptr<MarkCache> getMarkCache() const;
+    void dropMarkCache() const;
+
+    /** Clear the caches of the uncompressed blocks and marks.
+      * This is usually done when renaming tables, changing the type of columns, deleting a table.
+      *  - since caches are linked to file names, and become incorrect.
+      *  (when deleting a table - it is necessary, since in its place another can appear)
+      * const - because the change in the cache is not considered significant.
+      */
+    void dropCaches() const;
 
     BackgroundProcessingPool & getBackgroundPool();
 
@@ -295,14 +305,6 @@ public:
     void setDDLWorker(std::shared_ptr<DDLWorker> ddl_worker);
     DDLWorker & getDDLWorker();
 
-    /** Clear the caches of the uncompressed blocks and marks.
-      * This is usually done when renaming tables, changing the type of columns, deleting a table.
-      *  - since caches are linked to file names, and become incorrect.
-      *  (when deleting a table - it is necessary, since in its place another can appear)
-      * const - because the change in the cache is not considered significant.
-      */
-    void resetCaches() const;
-
     Clusters & getClusters() const;
     std::shared_ptr<Cluster> getCluster(const std::string & cluster_name) const;
     std::shared_ptr<Cluster> tryGetCluster(const std::string & cluster_name) const;
diff --git a/dbms/src/Interpreters/DDLWorker.cpp b/dbms/src/Interpreters/DDLWorker.cpp
index 1035082a773..08e9f2dba84 100644
--- a/dbms/src/Interpreters/DDLWorker.cpp
+++ b/dbms/src/Interpreters/DDLWorker.cpp
@@ -16,6 +16,7 @@
 
 #include <Interpreters/executeQuery.h>
 #include <Interpreters/Cluster.h>
+#include <Interpreters/DNSCache.h>
 
 #include <Common/getFQDNOrHostName.h>
 #include <Common/setThreadName.h>
@@ -85,7 +86,7 @@ struct HostID
     {
         try
         {
-            return DB::isLocalAddress(Poco::Net::SocketAddress(host_name, port));
+            return DB::isLocalAddress(Poco::Net::SocketAddress(DNSCache::instance().resolveHost(host_name), port));
         }
         catch (const Poco::Exception & e)
         {
diff --git a/dbms/src/Interpreters/DNSCache.cpp b/dbms/src/Interpreters/DNSCache.cpp
new file mode 100644
index 00000000000..b90185fb7a8
--- /dev/null
+++ b/dbms/src/Interpreters/DNSCache.cpp
@@ -0,0 +1,50 @@
+#include "DNSCache.h"
+#include <Poco/Net/DNS.h>
+#include <Common/SimpleCache.h>
+#include <Core/Types.h>
+
+
+namespace DB
+{
+
+static Poco::Net::IPAddress resolveIPAddressImpl(const std::string & host)
+{
+    return Poco::Net::DNS::resolveOne(host);
+}
+
+static Poco::Net::SocketAddress resolveSocketAddressImpl(const std::string & host_and_port)
+{
+    return Poco::Net::SocketAddress(host_and_port);
+}
+
+struct DNSCache::Impl
+{
+    /// TODO: Use only one cache for different formats
+
+    SimpleCache<decltype(resolveIPAddressImpl), &resolveIPAddressImpl> cache_host;
+    SimpleCache<decltype(resolveSocketAddressImpl), &resolveSocketAddressImpl> cache_host_and_port;
+};
+
+
+DNSCache::DNSCache() : impl(std::make_unique<DNSCache::Impl>()) {}
+
+Poco::Net::IPAddress DNSCache::resolveHost(const std::string & host)
+{
+    return impl->cache_host(host);
+}
+
+Poco::Net::SocketAddress DNSCache::resolveHostAndPort(const std::string & host_and_port)
+{
+    return impl->cache_host_and_port(host_and_port);
+}
+
+void DNSCache::dropCache()
+{
+    impl->cache_host.dropCache();
+    impl->cache_host_and_port.dropCache();
+}
+
+DNSCache::~DNSCache() = default;
+
+
+}
diff --git a/dbms/src/Interpreters/DNSCache.h b/dbms/src/Interpreters/DNSCache.h
new file mode 100644
index 00000000000..64bde3d5d7c
--- /dev/null
+++ b/dbms/src/Interpreters/DNSCache.h
@@ -0,0 +1,35 @@
+#pragma once
+#include <Poco/Net/IPAddress.h>
+#include <Poco/Net/SocketAddress.h>
+#include <memory>
+#include <ext/singleton.h>
+
+
+namespace DB
+{
+
+class DNSCache : public ext::singleton<DNSCache>
+{
+public:
+
+    DNSCache(const DNSCache &) = delete;
+
+    Poco::Net::IPAddress resolveHost(const std::string & host);
+
+    Poco::Net::SocketAddress resolveHostAndPort(const std::string & host_and_port);
+
+    void dropCache();
+
+    ~DNSCache();
+
+protected:
+
+    DNSCache();
+
+    friend class ext::singleton<DNSCache>;
+
+    struct Impl;
+    std::unique_ptr<Impl> impl;
+};
+
+}
\ No newline at end of file
diff --git a/dbms/src/Interpreters/InterpreterSystemQuery.cpp b/dbms/src/Interpreters/InterpreterSystemQuery.cpp
index e738f5978b7..90224c91025 100644
--- a/dbms/src/Interpreters/InterpreterSystemQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterSystemQuery.cpp
@@ -1,7 +1,10 @@
 #include <Interpreters/InterpreterSystemQuery.h>
+#include <Interpreters/DNSCache.h>
+#include <Interpreters/Context.h>
 #include <Parsers/ASTSystemQuery.h>
 #include <Common/typeid_cast.h>
 #include <csignal>
+#include <bits/signum.h>
 
 
 namespace DB
@@ -12,6 +15,7 @@ namespace ErrorCodes
 {
     extern const int BAD_ARGUMENTS;
     extern const int CANNOT_KILL;
+    extern const int NOT_IMPLEMENTED;
 }
 
 
@@ -36,21 +40,25 @@ BlockIO InterpreterSystemQuery::execute()
                 throw Exception("System call kill() failed", ErrorCodes::CANNOT_KILL);
             break;
         case Type::DROP_DNS_CACHE:
+            DNSCache::instance().dropCache();
             break;
         case Type::DROP_MARK_CACHE:
+            context.dropMarkCache();
             break;
         case Type::DROP_UNCOMPRESSED_CACHE:
+            context.dropUncompressedCache();
             break;
-        case Type::STOP_LISTEN_QUERIES:break;
-        case Type::START_LISTEN_QUERIES:break;
-        case Type::RESTART_REPLICAS:break;
-        case Type::SYNC_REPLICA:break;
-        case Type::RELOAD_DICTIONARY:break;
-        case Type::RELOAD_DICTIONARIES:break;
-        case Type::STOP_MERGES:break;
-        case Type::START_MERGES:break;
-        case Type::STOP_REPLICATION_QUEUES:break;
-        case Type::START_REPLICATION_QUEUES:break;
+        case Type::STOP_LISTEN_QUERIES:
+        case Type::START_LISTEN_QUERIES:
+        case Type::RESTART_REPLICAS:
+        case Type::SYNC_REPLICA:
+        case Type::RELOAD_DICTIONARY:
+        case Type::RELOAD_DICTIONARIES:
+        case Type::STOP_MERGES:
+        case Type::START_MERGES:
+        case Type::STOP_REPLICATION_QUEUES:
+        case Type::START_REPLICATION_QUEUES:
+            throw Exception(String(ASTSystemQuery::typeToString(query.type)) + " is not supported yet", ErrorCodes::NOT_IMPLEMENTED);
         default:
             throw Exception("Unknown type of SYSTEM query", ErrorCodes::BAD_ARGUMENTS);
     }
diff --git a/dbms/src/Parsers/ParserQuery.cpp b/dbms/src/Parsers/ParserQuery.cpp
index 3506c8c92ea..eb2cc792590 100644
--- a/dbms/src/Parsers/ParserQuery.cpp
+++ b/dbms/src/Parsers/ParserQuery.cpp
@@ -8,7 +8,7 @@
 #include <Parsers/ParserUseQuery.h>
 #include <Parsers/ParserSetQuery.h>
 #include <Parsers/ParserAlterQuery.h>
-#include "ParserSystemQuery.h"
+#include <Parsers/ParserSystemQuery.h>
 
 
 namespace DB
diff --git a/dbms/src/Storages/MergeTree/MergeTreeData.cpp b/dbms/src/Storages/MergeTree/MergeTreeData.cpp
index 78a7c3188f0..6e20f5f9ec1 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeData.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeData.cpp
@@ -576,7 +576,7 @@ void MergeTreeData::setPath(const String & new_full_path, bool move_data)
         Poco::File(full_path).renameTo(new_full_path);
         /// If we don't need to move the data, it means someone else has already moved it.
         /// We hope that he has also reset the caches.
-        context.resetCaches();
+        context.dropCaches();
     }
 
     full_path = new_full_path;
@@ -595,7 +595,7 @@ void MergeTreeData::dropAllData()
     all_data_parts.clear();
     column_sizes.clear();
 
-    context.resetCaches();
+    context.dropCaches();
 
     LOG_TRACE(log, "dropAllData: removing data from filesystem.");
 
@@ -1133,7 +1133,7 @@ void MergeTreeData::AlterDataPartTransaction::commit()
         mutable_part.size_in_bytes = MergeTreeData::DataPart::calcTotalSize(path);
 
         /// TODO: we can skip resetting caches when the column is added.
-        data_part->storage.context.resetCaches();
+        data_part->storage.context.dropCaches();
 
         clear();
     }
diff --git a/dbms/src/Storages/StorageMergeTree.cpp b/dbms/src/Storages/StorageMergeTree.cpp
index b96ba9ad7bd..d74b3a4f215 100644
--- a/dbms/src/Storages/StorageMergeTree.cpp
+++ b/dbms/src/Storages/StorageMergeTree.cpp
@@ -529,7 +529,7 @@ void StorageMergeTree::attachPartition(const ASTPtr & query, const Field & field
     }
 
     /// New parts with other data may appear in place of deleted parts.
-    context.resetCaches();
+    context.dropCaches();
 }
 
 

From 8fa3364e4e97954ad042f94a7c379248e5cab2a5 Mon Sep 17 00:00:00 2001
From: Vitaliy Lyudvichenko <vludv@yandex-team.ru>
Date: Thu, 24 Aug 2017 21:19:06 +0300
Subject: [PATCH 016/266] Add SYSTEM RELOAD DICTIONARY(IES) implementation.
 [#CLICKHOUSE-2931]

---
 dbms/src/Interpreters/Context.cpp             | 14 ++-
 dbms/src/Interpreters/Context.h               |  6 +-
 .../src/Interpreters/EmbeddedDictionaries.cpp | 28 ++++--
 dbms/src/Interpreters/EmbeddedDictionaries.h  | 13 ++-
 .../src/Interpreters/ExternalDictionaries.cpp | 93 +++++++++++++------
 dbms/src/Interpreters/ExternalDictionaries.h  | 21 ++++-
 .../Interpreters/InterpreterSystemQuery.cpp   | 48 +++++++++-
 .../Interpreters/tests/gtest_small_utils.cpp  | 10 ++
 dbms/src/Parsers/ParserSystemQuery.cpp        |  3 +
 9 files changed, 186 insertions(+), 50 deletions(-)
 create mode 100644 dbms/src/Interpreters/tests/gtest_small_utils.cpp

diff --git a/dbms/src/Interpreters/Context.cpp b/dbms/src/Interpreters/Context.cpp
index 7aa072a48e3..3e2bd9785bc 100644
--- a/dbms/src/Interpreters/Context.cpp
+++ b/dbms/src/Interpreters/Context.cpp
@@ -1009,14 +1009,24 @@ const EmbeddedDictionaries & Context::getEmbeddedDictionaries() const
     return getEmbeddedDictionariesImpl(false);
 }
 
+EmbeddedDictionaries & Context::getEmbeddedDictionaries()
+{
+    return getEmbeddedDictionariesImpl(false);
+}
+
 
 const ExternalDictionaries & Context::getExternalDictionaries() const
 {
     return getExternalDictionariesImpl(false);
 }
 
+ExternalDictionaries & Context::getExternalDictionaries()
+{
+    return getExternalDictionariesImpl(false);
+}
 
-const EmbeddedDictionaries & Context::getEmbeddedDictionariesImpl(const bool throw_on_error) const
+
+EmbeddedDictionaries & Context::getEmbeddedDictionariesImpl(const bool throw_on_error) const
 {
     std::lock_guard<std::mutex> lock(shared->embedded_dictionaries_mutex);
 
@@ -1027,7 +1037,7 @@ const EmbeddedDictionaries & Context::getEmbeddedDictionariesImpl(const bool thr
 }
 
 
-const ExternalDictionaries & Context::getExternalDictionariesImpl(const bool throw_on_error) const
+ExternalDictionaries & Context::getExternalDictionariesImpl(const bool throw_on_error) const
 {
     std::lock_guard<std::mutex> lock(shared->external_dictionaries_mutex);
 
diff --git a/dbms/src/Interpreters/Context.h b/dbms/src/Interpreters/Context.h
index 29b51a4f94d..b950efeb674 100644
--- a/dbms/src/Interpreters/Context.h
+++ b/dbms/src/Interpreters/Context.h
@@ -205,6 +205,8 @@ public:
 
     const EmbeddedDictionaries & getEmbeddedDictionaries() const;
     const ExternalDictionaries & getExternalDictionaries() const;
+    EmbeddedDictionaries & getEmbeddedDictionaries();
+    ExternalDictionaries & getExternalDictionaries();
     void tryCreateEmbeddedDictionaries() const;
     void tryCreateExternalDictionaries() const;
 
@@ -354,8 +356,8 @@ private:
       */
     void checkDatabaseAccessRights(const std::string & database_name) const;
 
-    const EmbeddedDictionaries & getEmbeddedDictionariesImpl(bool throw_on_error) const;
-    const ExternalDictionaries & getExternalDictionariesImpl(bool throw_on_error) const;
+    EmbeddedDictionaries & getEmbeddedDictionariesImpl(bool throw_on_error) const;
+    ExternalDictionaries & getExternalDictionariesImpl(bool throw_on_error) const;
 
     StoragePtr getTableImpl(const String & database_name, const String & table_name, Exception * exception) const;
 
diff --git a/dbms/src/Interpreters/EmbeddedDictionaries.cpp b/dbms/src/Interpreters/EmbeddedDictionaries.cpp
index 4d1f11d0167..7268c37f7c5 100644
--- a/dbms/src/Interpreters/EmbeddedDictionaries.cpp
+++ b/dbms/src/Interpreters/EmbeddedDictionaries.cpp
@@ -12,6 +12,11 @@
 namespace DB
 {
 
+namespace ErrorCodes
+{
+    extern const int UNFINISHED;
+}
+
 void EmbeddedDictionaries::handleException(const bool throw_on_error) const
 {
     const auto exception_ptr = std::current_exception();
@@ -24,9 +29,12 @@ void EmbeddedDictionaries::handleException(const bool throw_on_error) const
 
 
 template <typename Dictionary>
-bool EmbeddedDictionaries::reloadDictionary(MultiVersion<Dictionary> & dictionary, const bool throw_on_error)
+bool EmbeddedDictionaries::reloadDictionary(MultiVersion<Dictionary> & dictionary, const bool throw_on_error, const bool force_reload)
 {
-    if (Dictionary::isConfigured() && (!is_fast_start_stage || !dictionary.get()))
+    bool defined_in_config = Dictionary::isConfigured();
+    bool not_initialized = dictionary.get() == nullptr;
+
+    if (defined_in_config && (force_reload || !is_fast_start_stage || not_initialized))
     {
         try
         {
@@ -45,8 +53,10 @@ bool EmbeddedDictionaries::reloadDictionary(MultiVersion<Dictionary> & dictionar
 }
 
 
-bool EmbeddedDictionaries::reloadImpl(const bool throw_on_error)
+bool EmbeddedDictionaries::reloadImpl(const bool throw_on_error, const bool force_reload)
 {
+    std::unique_lock<std::mutex> lock(mutex);
+
     /** If you can not update the directories, then despite this, do not throw an exception (use the old directories).
       * If there are no old correct directories, then when using functions that depend on them,
       *  will throw an exception.
@@ -58,14 +68,14 @@ bool EmbeddedDictionaries::reloadImpl(const bool throw_on_error)
     bool was_exception = false;
 
 #if USE_MYSQL
-    if (!reloadDictionary<TechDataHierarchy>(tech_data_hierarchy, throw_on_error))
+    if (!reloadDictionary<TechDataHierarchy>(tech_data_hierarchy, throw_on_error, force_reload))
         was_exception = true;
 #endif
 
-    if (!reloadDictionary<RegionsHierarchies>(regions_hierarchies, throw_on_error))
+    if (!reloadDictionary<RegionsHierarchies>(regions_hierarchies, throw_on_error, force_reload))
         was_exception = true;
 
-    if (!reloadDictionary<RegionsNames>(regions_names, throw_on_error))
+    if (!reloadDictionary<RegionsNames>(regions_names, throw_on_error, force_reload))
         was_exception = true;
 
     if (!was_exception)
@@ -120,5 +130,11 @@ EmbeddedDictionaries::~EmbeddedDictionaries()
     reloading_thread.join();
 }
 
+void EmbeddedDictionaries::reload()
+{
+    if (!reloadImpl(true, true))
+        throw Exception("Some embedded dictionaries were not successfully reloaded", ErrorCodes::UNFINISHED);
+}
+
 
 }
diff --git a/dbms/src/Interpreters/EmbeddedDictionaries.h b/dbms/src/Interpreters/EmbeddedDictionaries.h
index d71b4feb927..9b607f2da66 100644
--- a/dbms/src/Interpreters/EmbeddedDictionaries.h
+++ b/dbms/src/Interpreters/EmbeddedDictionaries.h
@@ -32,6 +32,8 @@ private:
     int cur_reload_period = 1;
     bool is_fast_start_stage = true;
 
+    mutable std::mutex mutex;
+
     std::thread reloading_thread;
     Poco::Event destroy;
 
@@ -40,17 +42,17 @@ private:
 
     void handleException(const bool throw_on_error) const;
 
-    /// Updates dictionaries.
-    bool reloadImpl(const bool throw_on_error);
-
     /** Updates directories (dictionaries) every reload_period seconds.
      * If all dictionaries are not loaded at least once, try reload them with exponential delay (1, 2, ... reload_period).
      * If all dictionaries are loaded, update them using constant reload_period delay.
      */
     void reloadPeriodically();
 
+    /// Updates dictionaries.
+    bool reloadImpl(const bool throw_on_error, const bool force_reload = false);
+
     template <typename Dictionary>
-    bool reloadDictionary(MultiVersion<Dictionary> & dictionary, const bool throw_on_error);
+    bool reloadDictionary(MultiVersion<Dictionary> & dictionary, const bool throw_on_error, const bool force_reload);
 
 public:
     /// Every reload_period seconds directories are updated inside a separate thread.
@@ -58,6 +60,9 @@ public:
 
     EmbeddedDictionaries(const bool throw_on_error);
 
+    /// Forcibly reloads all dictionaries.
+    void reload();
+
     ~EmbeddedDictionaries();
 
 
diff --git a/dbms/src/Interpreters/ExternalDictionaries.cpp b/dbms/src/Interpreters/ExternalDictionaries.cpp
index 4d3dc137131..d6952061e7c 100644
--- a/dbms/src/Interpreters/ExternalDictionaries.cpp
+++ b/dbms/src/Interpreters/ExternalDictionaries.cpp
@@ -38,7 +38,7 @@ void ExternalDictionaries::reloadPeriodically()
         if (destroy.tryWait(check_period_sec * 1000))
             return;
 
-        reloadImpl();
+        reloadAndUpdate();
     }
 }
 
@@ -52,7 +52,7 @@ ExternalDictionaries::ExternalDictionaries(Context & context, const bool throw_o
             */
         TemporarilyDisableMemoryTracker temporarily_disable_memory_tracker;
 
-        reloadImpl(throw_on_error);
+        reloadAndUpdate(throw_on_error);
     }
 
     reloading_thread = std::thread{&ExternalDictionaries::reloadPeriodically, this};
@@ -93,28 +93,15 @@ std::set<std::string> getDictionariesConfigPaths(const Poco::Util::AbstractConfi
 }
 }
 
-void ExternalDictionaries::reloadImpl(const bool throw_on_error)
+void ExternalDictionaries::reloadAndUpdate(bool throw_on_error)
 {
-    const auto config_paths = getDictionariesConfigPaths(Poco::Util::Application::instance().config());
-
-    for (const auto & config_path : config_paths)
-    {
-        try
-        {
-            reloadFromFile(config_path, throw_on_error);
-        }
-        catch (...)
-        {
-            tryLogCurrentException(log, "reloadFromFile has thrown while reading from " + config_path);
-
-            if (throw_on_error)
-                throw;
-        }
-    }
+    reloadFromConfigFiles(throw_on_error);
 
     /// list of recreated dictionaries to perform delayed removal from unordered_map
     std::list<std::string> recreated_failed_dictionaries;
 
+    std::unique_lock<std::mutex> all_lock(all_mutex);
+
     /// retry loading failed dictionaries
     for (auto & failed_dictionary : failed_dictionaries)
     {
@@ -130,7 +117,7 @@ void ExternalDictionaries::reloadImpl(const bool throw_on_error)
             {
                 /// recalculate next attempt time
                 std::uniform_int_distribution<UInt64> distribution(
-                    0, std::exp2(failed_dictionary.second.error_count));
+                        0, static_cast<UInt64>(std::exp2(failed_dictionary.second.error_count)));
 
                 failed_dictionary.second.next_attempt_time = std::chrono::system_clock::now() +
                     std::chrono::seconds{
@@ -154,7 +141,7 @@ void ExternalDictionaries::reloadImpl(const bool throw_on_error)
                 else
                     dict_it->second.dict = std::make_shared<MultiVersion<IDictionaryBase>>(dict_ptr.release());
 
-                /// erase stored exception on success
+                /// clear stored exception on success
                 dict_it->second.exception = std::exception_ptr{};
 
                 recreated_failed_dictionaries.push_back(name);
@@ -234,7 +221,28 @@ void ExternalDictionaries::reloadImpl(const bool throw_on_error)
     }
 }
 
-void ExternalDictionaries::reloadFromFile(const std::string & config_path, const bool throw_on_error)
+void ExternalDictionaries::reloadFromConfigFiles(const bool throw_on_error, const bool force_reload, const std::string & only_dictionary)
+{
+    const auto config_paths = getDictionariesConfigPaths(Poco::Util::Application::instance().config());
+
+    for (const auto & config_path : config_paths)
+    {
+        try
+        {
+            reloadFromConfigFile(config_path, throw_on_error, force_reload, only_dictionary);
+        }
+        catch (...)
+        {
+            tryLogCurrentException(log, "reloadFromConfigFile has thrown while reading from " + config_path);
+
+            if (throw_on_error)
+                throw;
+        }
+    }
+}
+
+void ExternalDictionaries::reloadFromConfigFile(const std::string & config_path, const bool throw_on_error, const bool force_reload,
+                                                const std::string & only_dictionary)
 {
     const Poco::File config_file{config_path};
 
@@ -244,18 +252,23 @@ void ExternalDictionaries::reloadFromFile(const std::string & config_path, const
     }
     else
     {
+        std::unique_lock<std::mutex> all_lock(all_mutex);
+
         auto modification_time_it = last_modification_times.find(config_path);
         if (modification_time_it == std::end(last_modification_times))
             modification_time_it = last_modification_times.emplace(config_path, Poco::Timestamp{0}).first;
         auto & config_last_modified = modification_time_it->second;
 
         const auto last_modified = config_file.getLastModified();
-        if (last_modified > config_last_modified)
+        if (force_reload || last_modified > config_last_modified)
         {
             Poco::AutoPtr<Poco::Util::XMLConfiguration> config = new Poco::Util::XMLConfiguration(config_path);
 
-            /// definitions of dictionaries may have changed, recreate all of them
-            config_last_modified = last_modified;
+            /// Definitions of dictionaries may have changed, recreate all of them
+
+            /// If we need update only one dictionary, don't update modification time: might be other dictionaries in the config file
+            if (only_dictionary.empty())
+                config_last_modified = last_modified;
 
             /// get all dictionaries' definitions
             Poco::Util::AbstractConfiguration::Keys keys;
@@ -284,10 +297,17 @@ void ExternalDictionaries::reloadFromFile(const std::string & config_path, const
                         continue;
                     }
 
-                    const auto dict_it = dictionaries.find(name);
-                    if (dict_it != std::end(dictionaries))
-                        if (dict_it->second.origin != config_path)
-                            throw std::runtime_error{"Overriding dictionary from file " + dict_it->second.origin};
+                    if (!only_dictionary.empty() && name != only_dictionary)
+                        continue;
+
+                    decltype(dictionaries.begin()) dict_it;
+                    {
+                        std::lock_guard<std::mutex> lock{dictionaries_mutex};
+                        dict_it = dictionaries.find(name);
+                    }
+
+                    if (dict_it != std::end(dictionaries) && dict_it->second.origin != config_path)
+                        throw std::runtime_error{"Overriding dictionary from file " + dict_it->second.origin};
 
                     auto dict_ptr = DictionaryFactory::instance().create(name, *config, key, context);
 
@@ -373,6 +393,21 @@ void ExternalDictionaries::reloadFromFile(const std::string & config_path, const
     }
 }
 
+void ExternalDictionaries::reload()
+{
+    reloadFromConfigFiles(true, true);
+}
+
+void ExternalDictionaries::reloadDictionary(const std::string & name)
+{
+    reloadFromConfigFiles(true, true, name);
+
+    /// Check that specified dict was loaded
+    const std::lock_guard<std::mutex> lock{dictionaries_mutex};
+    if (!dictionaries.count(name))
+        throw Exception("Dictionary " + name + " wasn't loaded during the reload process", ErrorCodes::BAD_ARGUMENTS);
+}
+
 MultiVersion<IDictionaryBase>::Version ExternalDictionaries::getDictionary(const std::string & name) const
 {
     const std::lock_guard<std::mutex> lock{dictionaries_mutex};
diff --git a/dbms/src/Interpreters/ExternalDictionaries.h b/dbms/src/Interpreters/ExternalDictionaries.h
index 22cc6f647d1..7419f44a627 100644
--- a/dbms/src/Interpreters/ExternalDictionaries.h
+++ b/dbms/src/Interpreters/ExternalDictionaries.h
@@ -40,8 +40,12 @@ private:
     friend class StorageSystemDictionaries;
     friend class DatabaseDictionary;
 
+    /// Protects only dictionaries map.
     mutable std::mutex dictionaries_mutex;
 
+    /// Protects all data, currently used to avoid races between updating thread and SYSTEM queries
+    mutable std::mutex all_mutex;
+
     using DictionaryPtr = std::shared_ptr<MultiVersion<IDictionaryBase>>;
     struct DictionaryInfo final
     {
@@ -61,7 +65,7 @@ private:
       */
     std::unordered_map<std::string, DictionaryInfo> dictionaries;
 
-    /** Here are dictionaries, that has been never loaded sussessfully.
+    /** Here are dictionaries, that has been never loaded successfully.
       * They are also in 'dictionaries', but with nullptr as 'dict'.
       */
     std::unordered_map<std::string, FailedDictionaryInfo> failed_dictionaries;
@@ -81,8 +85,13 @@ private:
 
     std::unordered_map<std::string, Poco::Timestamp> last_modification_times;
 
-    void reloadImpl(bool throw_on_error = false);
-    void reloadFromFile(const std::string & config_path, bool throw_on_error);
+    /// Check dictionaries definitions in config files and reload or/and add new ones if the definition is changed
+    void reloadFromConfigFiles(const bool throw_on_error, const bool force_reload = false, const std::string & only_dictionary = "");
+    void reloadFromConfigFile(const std::string & config_path, const bool throw_on_error, const bool force_reload,
+                                  const std::string & only_dictionary);
+
+    /// Check config files and update expired dictionaries
+    void reloadAndUpdate(bool throw_on_error = false);
 
     void reloadPeriodically();
 
@@ -91,6 +100,12 @@ public:
     ExternalDictionaries(Context & context, const bool throw_on_error);
     ~ExternalDictionaries();
 
+    /// Forcibly reloads all dictionaries.
+    void reload();
+
+    /// Forcibly reloads specified dictionary.
+    void reloadDictionary(const std::string & name);
+
     MultiVersion<IDictionaryBase>::Version getDictionary(const std::string & name) const;
 };
 
diff --git a/dbms/src/Interpreters/InterpreterSystemQuery.cpp b/dbms/src/Interpreters/InterpreterSystemQuery.cpp
index 90224c91025..ef87633aa3d 100644
--- a/dbms/src/Interpreters/InterpreterSystemQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterSystemQuery.cpp
@@ -1,6 +1,8 @@
 #include <Interpreters/InterpreterSystemQuery.h>
 #include <Interpreters/DNSCache.h>
 #include <Interpreters/Context.h>
+#include <Interpreters/ExternalDictionaries.h>
+#include <Interpreters/EmbeddedDictionaries.h>
 #include <Parsers/ASTSystemQuery.h>
 #include <Common/typeid_cast.h>
 #include <csignal>
@@ -22,6 +24,33 @@ namespace ErrorCodes
 InterpreterSystemQuery::InterpreterSystemQuery(const ASTPtr & query_ptr_, Context & context_)
         : query_ptr(query_ptr_), context(context_) {}
 
+ExecutionStatus getOverallExecutionStatusOfCommands()
+{
+    return ExecutionStatus(0);
+}
+
+/// Consequently execute all commands and genreates final exception message for failed commands
+template <typename Callable, typename ... Callables>
+ExecutionStatus getOverallExecutionStatusOfCommands(Callable && command, Callables && ... commands)
+{
+    ExecutionStatus status_head(0);
+    try
+    {
+        command();
+    }
+    catch (...)
+    {
+        status_head = ExecutionStatus::fromCurrentException();
+    }
+
+    ExecutionStatus status_tail = getOverallExecutionStatusOfCommands(std::forward<Callables>(commands)...);
+
+    auto res_status = status_head.code != 0 ? status_head.code : status_tail.code;
+    auto res_message = status_head.message + (status_tail.message.empty() ? "" : ("\n" + status_tail.message));
+
+    return ExecutionStatus(res_status, res_message);
+}
+
 
 BlockIO InterpreterSystemQuery::execute()
 {
@@ -33,11 +62,11 @@ BlockIO InterpreterSystemQuery::execute()
     {
         case Type::SHUTDOWN:
             if (kill(0, SIGTERM))
-                throw Exception("System call kill() failed", ErrorCodes::CANNOT_KILL);
+                throw Exception("System call kill(0, SIGTERM) failed", ErrorCodes::CANNOT_KILL);
             break;
         case Type::KILL:
             if (kill(0, SIGKILL))
-                throw Exception("System call kill() failed", ErrorCodes::CANNOT_KILL);
+                throw Exception("System call kill(0, SIGKILL) failed", ErrorCodes::CANNOT_KILL);
             break;
         case Type::DROP_DNS_CACHE:
             DNSCache::instance().dropCache();
@@ -48,12 +77,23 @@ BlockIO InterpreterSystemQuery::execute()
         case Type::DROP_UNCOMPRESSED_CACHE:
             context.dropUncompressedCache();
             break;
+        case Type::RELOAD_DICTIONARY:
+            context.getExternalDictionaries().reloadDictionary(query.target_dictionary);
+            break;
+        case Type::RELOAD_DICTIONARIES:
+        {
+            auto status = getOverallExecutionStatusOfCommands(
+                    [&] { context.getExternalDictionaries().reload(); },
+                    [&] { context.getEmbeddedDictionaries().reload(); }
+            );
+            if (status.code != 0)
+                throw Exception(status.message, status.code);
+            break;
+        }
         case Type::STOP_LISTEN_QUERIES:
         case Type::START_LISTEN_QUERIES:
         case Type::RESTART_REPLICAS:
         case Type::SYNC_REPLICA:
-        case Type::RELOAD_DICTIONARY:
-        case Type::RELOAD_DICTIONARIES:
         case Type::STOP_MERGES:
         case Type::START_MERGES:
         case Type::STOP_REPLICATION_QUEUES:
diff --git a/dbms/src/Interpreters/tests/gtest_small_utils.cpp b/dbms/src/Interpreters/tests/gtest_small_utils.cpp
new file mode 100644
index 00000000000..3c40150ae5d
--- /dev/null
+++ b/dbms/src/Interpreters/tests/gtest_small_utils.cpp
@@ -0,0 +1,10 @@
+#include <gtest/gtest.h>
+#include <Common/Exception.h>
+using namespace DB;
+
+
+TEST(Interpreters, getOverallExecutionStatusOfCommands)
+{
+
+}
+
diff --git a/dbms/src/Parsers/ParserSystemQuery.cpp b/dbms/src/Parsers/ParserSystemQuery.cpp
index 5aa340a4785..18a0b0faa26 100644
--- a/dbms/src/Parsers/ParserSystemQuery.cpp
+++ b/dbms/src/Parsers/ParserSystemQuery.cpp
@@ -19,6 +19,8 @@ namespace DB
 
 bool ParserSystemQuery::parseImpl(IParser::Pos & pos, ASTPtr & node, Expected & expected)
 {
+    auto begin = pos;
+
     if (!ParserKeyword{"SYSTEM"}.ignore(pos))
         return false;
 
@@ -50,6 +52,7 @@ bool ParserSystemQuery::parseImpl(IParser::Pos & pos, ASTPtr & node, Expected &
         throw Exception("SYNC REPLICA is not supported yet", ErrorCodes::NOT_IMPLEMENTED);
     }
 
+    res->range = {begin, pos};
     node = std::move(res);
     return true;
 }

From 4b0c7ecf21ea83cb6dc426974a0df251211ea6e2 Mon Sep 17 00:00:00 2001
From: Vitaliy Lyudvichenko <vludv@yandex-team.ru>
Date: Fri, 25 Aug 2017 19:35:02 +0300
Subject: [PATCH 017/266] Add integration tests for SYSTEM queries.
 [#CLICKHOUSE-2931]

---
 dbms/src/Parsers/ParserSystemQuery.h          |  2 +-
 .../test_system_queries/__init__.py}          |  0
 .../configs/config.d/dictionaries_config.xml  |  4 ++
 .../dictionary_clickhouse_cache.xml           | 37 ++++++++++
 .../dictionary_clickhouse_flat.xml            | 37 ++++++++++
 .../test_system_queries/configs/users.xml     | 23 ++++++
 .../integration/test_system_queries/test.py   | 71 +++++++++++++++++++
 .../0_stateless/00486_system_query_simple.sh  | 20 ------
 8 files changed, 173 insertions(+), 21 deletions(-)
 rename dbms/tests/{queries/0_stateless/00486_system_query_simple.reference => integration/test_system_queries/__init__.py} (100%)
 create mode 100644 dbms/tests/integration/test_system_queries/configs/config.d/dictionaries_config.xml
 create mode 100644 dbms/tests/integration/test_system_queries/configs/dictionaries/dictionary_clickhouse_cache.xml
 create mode 100644 dbms/tests/integration/test_system_queries/configs/dictionaries/dictionary_clickhouse_flat.xml
 create mode 100644 dbms/tests/integration/test_system_queries/configs/users.xml
 create mode 100644 dbms/tests/integration/test_system_queries/test.py
 delete mode 100755 dbms/tests/queries/0_stateless/00486_system_query_simple.sh

diff --git a/dbms/src/Parsers/ParserSystemQuery.h b/dbms/src/Parsers/ParserSystemQuery.h
index 745e7748220..7083e282a06 100644
--- a/dbms/src/Parsers/ParserSystemQuery.h
+++ b/dbms/src/Parsers/ParserSystemQuery.h
@@ -16,4 +16,4 @@ protected:
     bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
 };
 
-}
\ No newline at end of file
+}
diff --git a/dbms/tests/queries/0_stateless/00486_system_query_simple.reference b/dbms/tests/integration/test_system_queries/__init__.py
similarity index 100%
rename from dbms/tests/queries/0_stateless/00486_system_query_simple.reference
rename to dbms/tests/integration/test_system_queries/__init__.py
diff --git a/dbms/tests/integration/test_system_queries/configs/config.d/dictionaries_config.xml b/dbms/tests/integration/test_system_queries/configs/config.d/dictionaries_config.xml
new file mode 100644
index 00000000000..b6e52983db2
--- /dev/null
+++ b/dbms/tests/integration/test_system_queries/configs/config.d/dictionaries_config.xml
@@ -0,0 +1,4 @@
+<?xml version="1.0"?>
+<yandex>
+    <dictionaries_config>/etc/clickhouse-server/dictionaries/*.xml</dictionaries_config>
+</yandex>
diff --git a/dbms/tests/integration/test_system_queries/configs/dictionaries/dictionary_clickhouse_cache.xml b/dbms/tests/integration/test_system_queries/configs/dictionaries/dictionary_clickhouse_cache.xml
new file mode 100644
index 00000000000..8132a129292
--- /dev/null
+++ b/dbms/tests/integration/test_system_queries/configs/dictionaries/dictionary_clickhouse_cache.xml
@@ -0,0 +1,37 @@
+<dictionaries>
+    <dictionary>
+        <name>clickhouse_cache</name>
+
+        <source>
+            <clickhouse>
+                <host>localhost</host>
+                <port>9000</port>
+                <user>default</user>
+                <password></password>
+                <db>default</db>
+                <table>dictionary_source</table>
+            </clickhouse>
+        </source>
+
+        <lifetime>
+            <min>0</min>
+            <max>0</max>
+        </lifetime>
+
+        <layout>
+            <cache><size_in_cells>128</size_in_cells></cache>
+        </layout>
+
+        <structure>
+            <id>
+                <name>id</name>
+            </id>
+
+            <attribute>
+                <name>value</name>
+                <type>UInt8</type>
+                <null_value>1</null_value>
+            </attribute>
+        </structure>
+    </dictionary>
+</dictionaries>
\ No newline at end of file
diff --git a/dbms/tests/integration/test_system_queries/configs/dictionaries/dictionary_clickhouse_flat.xml b/dbms/tests/integration/test_system_queries/configs/dictionaries/dictionary_clickhouse_flat.xml
new file mode 100644
index 00000000000..6180c3be3e3
--- /dev/null
+++ b/dbms/tests/integration/test_system_queries/configs/dictionaries/dictionary_clickhouse_flat.xml
@@ -0,0 +1,37 @@
+<dictionaries>
+    <dictionary>
+        <name>clickhouse_flat</name>
+
+        <source>
+            <clickhouse>
+                <host>localhost</host>
+                <port>9000</port>
+                <user>default</user>
+                <password></password>
+                <db>default</db>
+                <table>dictionary_source</table>
+            </clickhouse>
+        </source>
+
+        <lifetime>
+            <min>0</min>
+            <max>0</max>
+        </lifetime>
+
+        <layout>
+            <flat/>
+        </layout>
+
+        <structure>
+            <id>
+                <name>id</name>
+            </id>
+
+            <attribute>
+                <name>value</name>
+                <type>UInt8</type>
+                <null_value>1</null_value>
+            </attribute>
+        </structure>
+    </dictionary>
+</dictionaries>
\ No newline at end of file
diff --git a/dbms/tests/integration/test_system_queries/configs/users.xml b/dbms/tests/integration/test_system_queries/configs/users.xml
new file mode 100644
index 00000000000..6061af8e33d
--- /dev/null
+++ b/dbms/tests/integration/test_system_queries/configs/users.xml
@@ -0,0 +1,23 @@
+<?xml version="1.0"?>
+<yandex>
+    <profiles>
+        <default>
+        </default>
+    </profiles>
+
+    <users>
+        <default>
+            <password></password>
+            <networks incl="networks" replace="replace">
+                <ip>::/0</ip>
+            </networks>
+            <profile>default</profile>
+            <quota>default</quota>
+        </default>
+    </users>
+
+    <quotas>
+        <default>
+        </default>
+    </quotas>
+</yandex>
diff --git a/dbms/tests/integration/test_system_queries/test.py b/dbms/tests/integration/test_system_queries/test.py
new file mode 100644
index 00000000000..7d6153dafea
--- /dev/null
+++ b/dbms/tests/integration/test_system_queries/test.py
@@ -0,0 +1,71 @@
+import os
+import os.path as p
+import sys
+import time
+import datetime
+import pytest
+from contextlib import contextmanager
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+from helpers.cluster import ClickHouseCluster
+from helpers.test_tools import TSV
+
+
+@pytest.fixture(scope="module")
+def started_cluster():
+    global cluster
+    global instance
+    try:
+        cluster = ClickHouseCluster(__file__)
+        cluster.add_instance('ch1', config_dir="configs")
+        cluster.start()
+
+        instance = cluster.instances['ch1']
+        instance.query('CREATE DATABASE dictionaries ENGINE = Dictionary')
+        instance.query('CREATE TABLE dictionary_source (id UInt64, value UInt8) ENGINE = Memory')
+        #print instance.query('SELECT * FROM system.dictionaries FORMAT Vertical')
+
+        yield cluster
+
+    finally:
+        cluster.shutdown()
+
+
+def test_SYSTEM_RELOAD_DICTIONARY(started_cluster):
+    instance = cluster.instances['ch1']
+
+    instance.query("SYSTEM RELOAD DICTIONARIES")
+    assert TSV(instance.query("SELECT dictHas('clickhouse_flat', toUInt64(0)), dictHas('clickhouse_flat', toUInt64(1))")) == TSV("0\t0\n")
+
+    instance.query("INSERT INTO dictionary_source VALUES (0, 0)")
+    assert TSV(instance.query("SELECT dictGetUInt8('clickhouse_cache', 'value', toUInt64(0)), dictHas('clickhouse_cache', toUInt64(1))")) == TSV("0\t0\n")
+    instance.query("INSERT INTO dictionary_source VALUES (1, 1)")
+    assert TSV(instance.query("SELECT dictGetUInt8('clickhouse_cache', 'value', toUInt64(0)), dictHas('clickhouse_cache', toUInt64(1))")) == TSV("0\t0\n")
+
+    instance.query("SYSTEM RELOAD DICTIONARY clickhouse_cache")
+    assert TSV(instance.query("SELECT dictGetUInt8('clickhouse_cache', 'value', toUInt64(0)), dictGetUInt8('clickhouse_cache', 'value', toUInt64(1))")) == TSV("0\t1\n")
+    assert TSV(instance.query("SELECT dictHas('clickhouse_flat', toUInt64(0)), dictHas('clickhouse_flat', toUInt64(1))")) == TSV("0\t0\n")
+
+    instance.query("SYSTEM RELOAD DICTIONARIES")
+    assert TSV(instance.query("SELECT dictGetUInt8('clickhouse_cache', 'value', toUInt64(0)), dictGetUInt8('clickhouse_cache', 'value', toUInt64(1))")) == TSV("0\t1\n")
+    assert TSV(instance.query("SELECT dictGetUInt8('clickhouse_flat', 'value', toUInt64(0)), dictGetUInt8('clickhouse_flat', 'value', toUInt64(1))")) == TSV("0\t1\n")
+
+
+def test_DROP_DNS_CACHE(started_cluster):
+    instance = cluster.instances['ch1']
+
+    with pytest.raises(Exception):
+        instance.query("SELECT * FROM remote('apperol', 'system', 'one')")
+
+    print instance.exec_in_container(['bash', '-c', 'echo $USER `cat /etc/hosts`'], privileged=True)
+    instance.exec_in_container(['bash', '-c', 'echo 127.0.0.1 apperol >> /etc/hosts'], privileged=True)
+    instance.query("SYSTEM DROP DNS CACHE")
+
+    instance.query("SELECT * FROM remote('apperol', 'system', 'one')")
+
+
+if __name__ == '__main__':
+    with contextmanager(started_cluster)() as cluster:
+       for name, instance in cluster.instances.items():
+           print name, instance.ip_address
+       raw_input("Cluster created, press any key to destroy...")
diff --git a/dbms/tests/queries/0_stateless/00486_system_query_simple.sh b/dbms/tests/queries/0_stateless/00486_system_query_simple.sh
deleted file mode 100755
index 1b20cb032d0..00000000000
--- a/dbms/tests/queries/0_stateless/00486_system_query_simple.sh
+++ /dev/null
@@ -1,20 +0,0 @@
-#!/bin/bash
-set -e
-
-cli="clickhouse-client -q "
-
-$cli "SYSTEM SHUTDOWN"
-$cli "SYSTEM KILL"
-$cli "SYSTEM DROP DNS CACHE"
-$cli "SYSTEM DROP MARK CACHE"
-$cli "SYSTEM DROP UNCOMPRESSED CACHE"
-$cli "SYSTEM STOP LISTEN QUERIES"
-$cli "SYSTEM START LISTEN QUERIES"
-$cli "SYSTEM RESTART REPLICAS"
-#$cli "SYSTEM SYNC REPLICA test"
-$cli "SYSTEM RELOAD DICTIONARY dict"
-$cli "SYSTEM RELOAD DICTIONARIES"
-$cli "SYSTEM STOP MERGES"
-$cli "SYSTEM START MERGES"
-$cli "SYSTEM STOP REPLICATION QUEUES"
-$cli "SYSTEM START REPLICATION QUEUES"

From c9daea1a3363d6b32c01792c054819d36660f7a9 Mon Sep 17 00:00:00 2001
From: Vitaliy Lyudvichenko <vludv@yandex-team.ru>
Date: Mon, 28 Aug 2017 21:39:57 +0300
Subject: [PATCH 018/266] Fixed IP resolving in DNSCache. [#CLICKHOUSE-2931]

---
 dbms/src/Interpreters/DNSCache.cpp | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/dbms/src/Interpreters/DNSCache.cpp b/dbms/src/Interpreters/DNSCache.cpp
index b90185fb7a8..ab897a332cb 100644
--- a/dbms/src/Interpreters/DNSCache.cpp
+++ b/dbms/src/Interpreters/DNSCache.cpp
@@ -2,6 +2,8 @@
 #include <Poco/Net/DNS.h>
 #include <Common/SimpleCache.h>
 #include <Core/Types.h>
+#include <Poco/Net/NetException.h>
+
 
 
 namespace DB
@@ -9,7 +11,9 @@ namespace DB
 
 static Poco::Net::IPAddress resolveIPAddressImpl(const std::string & host)
 {
-    return Poco::Net::DNS::resolveOne(host);
+    /// NOTE: Poco::Net::DNS::resolveOne(host) doesn't work for IP addresses like 127.0.0.2
+    /// Therefore we use SocketAddress constructor with dummy port to resolve IP
+    return Poco::Net::SocketAddress(host, 0U).host();
 }
 
 static Poco::Net::SocketAddress resolveSocketAddressImpl(const std::string & host_and_port)

From aa2d29f5f9bacee37eaf5e3dd1e7ae8a05ee78f2 Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Thu, 31 Aug 2017 00:25:44 +0300
Subject: [PATCH 019/266] Update ReadWriteBufferFromHTTP.cpp, Context.cpp, etc

Update ASTSystemQuery.cpp

Update ASTSystemQuery.h

Update dictionary_clickhouse_cache.xml

Update dictionary_clickhouse_flat.xml
---
 dbms/src/IO/ReadWriteBufferFromHTTP.cpp                        | 3 ---
 dbms/src/Interpreters/Context.cpp                              | 2 +-
 dbms/src/Interpreters/DNSCache.h                               | 2 +-
 dbms/src/Interpreters/InterpreterSystemQuery.cpp               | 2 +-
 dbms/src/Parsers/ASTSystemQuery.cpp                            | 2 +-
 dbms/src/Parsers/ASTSystemQuery.h                              | 2 +-
 .../configs/dictionaries/dictionary_clickhouse_cache.xml       | 2 +-
 .../configs/dictionaries/dictionary_clickhouse_flat.xml        | 2 +-
 8 files changed, 7 insertions(+), 10 deletions(-)

diff --git a/dbms/src/IO/ReadWriteBufferFromHTTP.cpp b/dbms/src/IO/ReadWriteBufferFromHTTP.cpp
index 6545bc7e739..4e2b2ae2b51 100644
--- a/dbms/src/IO/ReadWriteBufferFromHTTP.cpp
+++ b/dbms/src/IO/ReadWriteBufferFromHTTP.cpp
@@ -12,9 +12,6 @@
 
 #if Poco_NetSSL_FOUND
 #include <Poco/Net/HTTPSClientSession.h>
-#include <Interpreters/DNSCache.h>
-
-
 #endif
 
 
diff --git a/dbms/src/Interpreters/Context.cpp b/dbms/src/Interpreters/Context.cpp
index 3670700f180..ce12cc7ce7b 100644
--- a/dbms/src/Interpreters/Context.cpp
+++ b/dbms/src/Interpreters/Context.cpp
@@ -1142,7 +1142,7 @@ void Context::setMarkCache(size_t cache_size_in_bytes)
     auto lock = getLock();
 
     if (shared->mark_cache)
-        throw Exception("Uncompressed cache has been already created.", ErrorCodes::LOGICAL_ERROR);
+        throw Exception("Mark cache has been already created.", ErrorCodes::LOGICAL_ERROR);
 
     shared->mark_cache = std::make_shared<MarkCache>(cache_size_in_bytes, std::chrono::seconds(settings.mark_cache_min_lifetime));
 }
diff --git a/dbms/src/Interpreters/DNSCache.h b/dbms/src/Interpreters/DNSCache.h
index 64bde3d5d7c..538bb1269c1 100644
--- a/dbms/src/Interpreters/DNSCache.h
+++ b/dbms/src/Interpreters/DNSCache.h
@@ -32,4 +32,4 @@ protected:
     std::unique_ptr<Impl> impl;
 };
 
-}
\ No newline at end of file
+}
diff --git a/dbms/src/Interpreters/InterpreterSystemQuery.cpp b/dbms/src/Interpreters/InterpreterSystemQuery.cpp
index ef87633aa3d..6a167ac190a 100644
--- a/dbms/src/Interpreters/InterpreterSystemQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterSystemQuery.cpp
@@ -107,4 +107,4 @@ BlockIO InterpreterSystemQuery::execute()
 }
 
 
-}
\ No newline at end of file
+}
diff --git a/dbms/src/Parsers/ASTSystemQuery.cpp b/dbms/src/Parsers/ASTSystemQuery.cpp
index 753b2c05a26..cbc249ad48e 100644
--- a/dbms/src/Parsers/ASTSystemQuery.cpp
+++ b/dbms/src/Parsers/ASTSystemQuery.cpp
@@ -66,4 +66,4 @@ void ASTSystemQuery::formatImpl(const IAST::FormatSettings & settings, IAST::For
 }
 
 
-}
\ No newline at end of file
+}
diff --git a/dbms/src/Parsers/ASTSystemQuery.h b/dbms/src/Parsers/ASTSystemQuery.h
index 5573345ffa0..5ccad6bec80 100644
--- a/dbms/src/Parsers/ASTSystemQuery.h
+++ b/dbms/src/Parsers/ASTSystemQuery.h
@@ -54,4 +54,4 @@ protected:
 };
 
 
-}
\ No newline at end of file
+}
diff --git a/dbms/tests/integration/test_system_queries/configs/dictionaries/dictionary_clickhouse_cache.xml b/dbms/tests/integration/test_system_queries/configs/dictionaries/dictionary_clickhouse_cache.xml
index 8132a129292..a149c2ba774 100644
--- a/dbms/tests/integration/test_system_queries/configs/dictionaries/dictionary_clickhouse_cache.xml
+++ b/dbms/tests/integration/test_system_queries/configs/dictionaries/dictionary_clickhouse_cache.xml
@@ -34,4 +34,4 @@
             </attribute>
         </structure>
     </dictionary>
-</dictionaries>
\ No newline at end of file
+</dictionaries>
diff --git a/dbms/tests/integration/test_system_queries/configs/dictionaries/dictionary_clickhouse_flat.xml b/dbms/tests/integration/test_system_queries/configs/dictionaries/dictionary_clickhouse_flat.xml
index 6180c3be3e3..feb01b27d1b 100644
--- a/dbms/tests/integration/test_system_queries/configs/dictionaries/dictionary_clickhouse_flat.xml
+++ b/dbms/tests/integration/test_system_queries/configs/dictionaries/dictionary_clickhouse_flat.xml
@@ -34,4 +34,4 @@
             </attribute>
         </structure>
     </dictionary>
-</dictionaries>
\ No newline at end of file
+</dictionaries>

From c6f87d95430913695d71721ce05bd1b3a17f9590 Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Thu, 31 Aug 2017 19:24:46 +0300
Subject: [PATCH 020/266] Update GatherUtils.h

---
 dbms/src/Functions/GatherUtils.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index c554b7e468a..1886f412a92 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -894,7 +894,7 @@ inline ALWAYS_INLINE void writeSlice(const StringSource::Slice & slice, FixedStr
 /// Assuming same types of underlying columns for slice and sink if (ArraySlice, ArraySink) is (GenericArraySlice, GenericArraySink).
 inline ALWAYS_INLINE void writeSlice(const GenericArraySlice & slice, GenericArraySink & sink)
 {
-    if (std::type_index(typeid(slice.elements)) == std::type_index(typeid(&sink.elements)))
+    if (typeid(slice.elements) == typeid(&sink.elements))
         sink.elements.insertRangeFrom(*slice.elements, slice.begin, slice.size);
     else
     {

From 1b8100ae8694a148a594907ec256e51c75dfd9db Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Thu, 31 Aug 2017 20:00:51 +0300
Subject: [PATCH 021/266] Update FunctionsArray.cpp

---
 dbms/src/Functions/FunctionsArray.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index 47cbb030a39..4d65860f11d 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -19,7 +19,6 @@
 #include <Columns/ColumnAggregateFunction.h>
 #include <tuple>
 #include <array>
-#include <iostream>
 
 
 namespace DB

From c0b05f2ca97864ea82387ba550e78483cc2d8342 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 14:02:26 +0300
Subject: [PATCH 022/266] hanged & to && in GatherUtils [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.h | 56 ++++----------------------------
 1 file changed, 7 insertions(+), 49 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index 1886f412a92..59d0b9427aa 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -954,7 +954,7 @@ inline ALWAYS_INLINE void writeSlice(const ArraySlice & slice, NullableArraySink
 /// Algorithms
 
 template <typename SourceA, typename SourceB, typename Sink>
-void NO_INLINE concat(SourceA & src_a, SourceB & src_b, Sink & sink)
+void NO_INLINE concat(SourceA && src_a, SourceB && src_b, Sink && sink)
 {
     sink.reserve(src_a.getSizeForReserve() + src_b.getSizeForReserve());
 
@@ -969,12 +969,6 @@ void NO_INLINE concat(SourceA & src_a, SourceB & src_b, Sink & sink)
     }
 }
 
-template <typename SourceA, typename SourceB, typename Sink>
-void NO_INLINE concat(SourceA && src_a, SourceB && src_b, Sink && sink)
-{
-    concat(src_a, src_b, sink);
-}
-
 template <typename Sink>
 void NO_INLINE concat(StringSources & sources, Sink && sink)
 {
@@ -993,7 +987,7 @@ void concat(std::vector<std::unique_ptr<IArraySource>> & sources, IArraySink & s
 
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceFromLeftConstantOffsetUnbounded(Source & src, Sink & sink, size_t offset)
+void NO_INLINE sliceFromLeftConstantOffsetUnbounded(Source && src, Sink && sink, size_t offset)
 {
     while (!src.isEnd())
     {
@@ -1004,7 +998,7 @@ void NO_INLINE sliceFromLeftConstantOffsetUnbounded(Source & src, Sink & sink, s
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceFromLeftConstantOffsetBounded(Source & src, Sink & sink, size_t offset, ssize_t length)
+void NO_INLINE sliceFromLeftConstantOffsetBounded(Source && src, Sink && sink, size_t offset, ssize_t length)
 {
     while (!src.isEnd())
     {
@@ -1021,7 +1015,7 @@ void NO_INLINE sliceFromLeftConstantOffsetBounded(Source & src, Sink & sink, siz
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceFromRightConstantOffsetUnbounded(Source & src, Sink & sink, size_t offset)
+void NO_INLINE sliceFromRightConstantOffsetUnbounded(Source && src, Sink && sink, size_t offset)
 {
     while (!src.isEnd())
     {
@@ -1032,7 +1026,7 @@ void NO_INLINE sliceFromRightConstantOffsetUnbounded(Source & src, Sink & sink,
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceFromRightConstantOffsetBounded(Source & src, Sink & sink, size_t offset, ssize_t length)
+void NO_INLINE sliceFromRightConstantOffsetBounded(Source && src, Sink && sink, size_t offset, ssize_t length)
 {
     while (!src.isEnd())
     {
@@ -1049,7 +1043,7 @@ void NO_INLINE sliceFromRightConstantOffsetBounded(Source & src, Sink & sink, si
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceDynamicOffsetUnbounded(Source & src, Sink & sink, IColumn & offset_column)
+void NO_INLINE sliceDynamicOffsetUnbounded(Source && src, Sink && sink, IColumn & offset_column)
 {
     const bool is_null = offset_column.isNull();
     auto * nullable = typeid_cast<ColumnNullable *>(&offset_column);
@@ -1080,7 +1074,7 @@ void NO_INLINE sliceDynamicOffsetUnbounded(Source & src, Sink & sink, IColumn &
 }
 
 template <typename Source, typename Sink>
-void NO_INLINE sliceDynamicOffsetBounded(Source & src, Sink & sink, IColumn & offset_column, IColumn & length_column)
+void NO_INLINE sliceDynamicOffsetBounded(Source && src, Sink && sink, IColumn & offset_column, IColumn & length_column)
 {
     const bool is_offset_null = offset_column.isNull();
     auto * offset_nullable = typeid_cast<ColumnNullable *>(&offset_column);
@@ -1121,42 +1115,6 @@ void NO_INLINE sliceDynamicOffsetBounded(Source & src, Sink & sink, IColumn & of
 }
 
 
-template <typename Source, typename Sink>
-void NO_INLINE sliceFromLeftConstantOffsetUnbounded(Source && src, Sink && sink, size_t offset)
-{
-    sliceFromLeftConstantOffsetUnbounded(src, sink, offset);
-}
-
-template <typename Source, typename Sink>
-void NO_INLINE sliceFromLeftConstantOffsetBounded(Source && src, Sink && sink, size_t offset, ssize_t length)
-{
-    sliceFromLeftConstantOffsetBounded(src, sink, offset, length);
-}
-
-template <typename Source, typename Sink>
-void NO_INLINE sliceFromRightConstantOffsetUnbounded(Source && src, Sink && sink, size_t offset)
-{
-    sliceFromRightConstantOffsetUnbounded(src, sink, offset);
-}
-
-template <typename Source, typename Sink>
-void NO_INLINE sliceFromRightConstantOffsetBounded(Source && src, Sink && sink, size_t offset, ssize_t length)
-{
-    sliceFromRightConstantOffsetBounded(src, sink, offset, length);
-}
-
-template <typename Source, typename Sink>
-void NO_INLINE sliceDynamicOffsetUnbounded(Source && src, Sink && sink, IColumn & offset_column)
-{
-    sliceDynamicOffsetUnbounded(src, sink, offset_column);
-}
-
-template <typename Source, typename Sink>
-void NO_INLINE sliceDynamicOffsetBounded(Source && src, Sink && sink, IColumn & offset_column, IColumn & length_column)
-{
-    sliceDynamicOffsetBounded(src, sink, offset_column, length_column);
-}
-
 void sliceFromLeftConstantOffsetUnbounded(IArraySource & src, IArraySink & sink, size_t offset);
 
 void sliceFromLeftConstantOffsetBounded(IArraySource & src, IArraySink & sink, size_t offset, ssize_t length);

From c695f10c6642fc5fcdac62b6533d5311a3357d5b Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 14:32:31 +0300
Subject: [PATCH 023/266] hanged & to && in GatherUtils [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.cpp b/dbms/src/Functions/GatherUtils.cpp
index fc10670de00..e86b0e9e482 100644
--- a/dbms/src/Functions/GatherUtils.cpp
+++ b/dbms/src/Functions/GatherUtils.cpp
@@ -394,7 +394,7 @@ struct SliceFromLeftConstantOffsetUnboundedSelectArraySource
     template <typename Source, typename Sink>
     static void selectSourceSink(Source & source, Sink & sink, size_t & offset)
     {
-        sliceFromLeftConstantOffsetUnbounded<Source, Sink>(source, sink, offset);
+        sliceFromLeftConstantOffsetUnbounded(source, sink, offset);
     }
 };
 
@@ -404,7 +404,7 @@ struct SliceFromLeftConstantOffsetBoundedSelectArraySource
     template <typename Source, typename Sink>
     static void selectSourceSink(Source & source, Sink & sink, size_t & offset, ssize_t & length)
     {
-        sliceFromLeftConstantOffsetBounded<Source, Sink>(source, sink, offset, length);
+        sliceFromLeftConstantOffsetBounded(source, sink, offset, length);
     }
 };
 
@@ -414,7 +414,7 @@ struct SliceFromRightConstantOffsetUnboundedSelectArraySource
     template <typename Source, typename Sink>
     static void selectSourceSink(Source & source, Sink & sink, size_t & offset)
     {
-        sliceFromRightConstantOffsetUnbounded<Source, Sink>(source, sink, offset);
+        sliceFromRightConstantOffsetUnbounded(source, sink, offset);
     }
 };
 
@@ -424,7 +424,7 @@ struct SliceFromRightConstantOffsetBoundedSelectArraySource
     template <typename Source, typename Sink>
     static void selectSourceSink(Source & source, Sink & sink, size_t & offset, ssize_t & length)
     {
-        sliceFromRightConstantOffsetBounded<Source, Sink>(source, sink, offset, length);
+        sliceFromRightConstantOffsetBounded(source, sink, offset, length);
     }
 };
 
@@ -434,7 +434,7 @@ struct SliceDynamicOffsetUnboundedSelectArraySource
     template <typename Source, typename Sink>
     static void selectSourceSink(Source & source, Sink & sink, IColumn & offset_column)
     {
-        sliceDynamicOffsetUnbounded<Source, Sink>(source, sink, offset_column);
+        sliceDynamicOffsetUnbounded(source, sink, offset_column);
     }
 };
 
@@ -444,7 +444,7 @@ struct SliceDynamicOffsetBoundedSelectArraySource
     template <typename Source, typename Sink>
     static void selectSourceSink(Source & source, Sink & sink, IColumn & offset_column, IColumn & length_column)
     {
-        sliceDynamicOffsetBounded<Source, Sink>(source, sink, offset_column, length_column);
+        sliceDynamicOffsetBounded(source, sink, offset_column, length_column);
     }
 };
 

From 78915965795c7d2f7b5ffc61e5b84033363ac14e Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 15:05:19 +0300
Subject: [PATCH 024/266] unified TypeList [#CLICKHOUSE-2090]

---
 dbms/src/Common/TypeList.h                    | 49 +++++++++++++------
 dbms/src/Functions/GatherUtils.cpp            |  4 +-
 dbms/src/Interpreters/SpecializedAggregator.h | 38 +-------------
 3 files changed, 37 insertions(+), 54 deletions(-)

diff --git a/dbms/src/Common/TypeList.h b/dbms/src/Common/TypeList.h
index 607f81720c0..8a683de74d8 100644
--- a/dbms/src/Common/TypeList.h
+++ b/dbms/src/Common/TypeList.h
@@ -3,34 +3,53 @@
 namespace DB
 {
 
-template <typename ... Types>
-struct TypeList;
-
-template <typename Type, typename ... Types>
-struct TypeList<Type, Types...>
+template <typename... TTail>
+struct TypeList
 {
-    using Head = Type;
-    using Tail = TypeList<Types ...>;
+    static constexpr size_t size = 0;
+
+    template <size_t I>
+    using At = std::nullptr_t;
+
+    template <typename Func, size_t index = 0>
+    static void forEach(Func && func)
+    {
+    }
 };
 
-template<>
-struct TypeList<>
+
+template <typename THead, typename... TTail>
+struct TypeList<THead, TTail...>
 {
+    using Head = THead;
+    using Tail = TypeList<TTail...>;
+
+    static constexpr size_t size = 1 + sizeof...(TTail);
+
+    template <size_t I>
+    using At = typename std::template conditional<I == 0, Head, typename Tail::template At<I - 1>>::type;
+
+    template <typename Func, size_t index = 0>
+    static void ALWAYS_INLINE forEach(Func && func)
+    {
+        func.template operator()<Head, index>();
+        Tail::template forEach<Func, index + 1>(std::forward<Func>(func));
+    }
 };
 
 /// Append Type to TypeList
 /// Usage:
 ///     using TypeListWithType = typename AppendToTypeList<Type, ConcreteTypeList>::Type;
-template <typename TypeToAppend, typename List, typename ... Types>
-struct AppendToTypeList
+template <typename TypeToPrepend, typename List, typename ... Types>
+struct PrependToTypeList
 {
-    using Type = typename AppendToTypeList<TypeToAppend, typename List::Tail, Types ..., typename List::Head>::Type;
+    using Type = typename PrependToTypeList<TypeToPrepend, typename List::Tail, Types ..., typename List::Head>::Type;
 };
 
-template <typename TypeToAppend, typename ... Types>
-struct AppendToTypeList<TypeToAppend, TypeList<>, Types ...>
+template <typename TypeToPrepend, typename ... Types>
+struct PrependToTypeList<TypeToPrepend, TypeList<>, Types ...>
 {
-    using Type = TypeList<TypeToAppend, Types ...>;
+    using Type = TypeList<TypeToPrepend, Types ...>;
 };
 
 /// Apply TypeList as variadic template argument of Class.
diff --git a/dbms/src/Functions/GatherUtils.cpp b/dbms/src/Functions/GatherUtils.cpp
index e86b0e9e482..861f549b498 100644
--- a/dbms/src/Functions/GatherUtils.cpp
+++ b/dbms/src/Functions/GatherUtils.cpp
@@ -149,7 +149,7 @@ struct ArraySourceSelector<Base>
 };
 
 template <typename Base>
-using GetArraySourceSelector = typename ApplyTypeListForClass<ArraySourceSelector, typename AppendToTypeList<Base, TypeListNumber>::Type>::Type;
+using GetArraySourceSelector = typename ApplyTypeListForClass<ArraySourceSelector, typename PrependToTypeList<Base, TypeListNumber>::Type>::Type;
 
 template <typename Base, typename ... Types>
 struct ArraySinkSelector;
@@ -185,7 +185,7 @@ struct ArraySinkSelector<Base>
 };
 
 template <typename Base>
-using GetArraySinkSelector = typename ApplyTypeListForClass<ArraySinkSelector, typename AppendToTypeList<Base, TypeListNumber>::Type>::Type;
+using GetArraySinkSelector = typename ApplyTypeListForClass<ArraySinkSelector, typename PrependToTypeList<Base, TypeListNumber>::Type>::Type;
 
 template <typename Base>
 struct ArraySinkSourceSelector
diff --git a/dbms/src/Interpreters/SpecializedAggregator.h b/dbms/src/Interpreters/SpecializedAggregator.h
index c582e72b4fe..56a1d803a90 100644
--- a/dbms/src/Interpreters/SpecializedAggregator.h
+++ b/dbms/src/Interpreters/SpecializedAggregator.h
@@ -1,3 +1,4 @@
+#include <Common/TypeList.h>
 #include <Interpreters/Aggregator.h>
 
 #include <AggregateFunctions/AggregateFunctionArgMinMax.h>
@@ -40,43 +41,6 @@ namespace DB
   */
 
 
-/** List of types - for convenient listing of aggregate functions.
-  */
-template <typename... TTail>
-struct TypeList
-{
-    static constexpr size_t size = 0;
-
-    template <size_t I>
-    using At = std::nullptr_t;
-
-    template <typename Func, size_t index = 0>
-    static void forEach(Func && func)
-    {
-    }
-};
-
-
-template <typename THead, typename... TTail>
-struct TypeList<THead, TTail...>
-{
-    using Head = THead;
-    using Tail = TypeList<TTail...>;
-
-    static constexpr size_t size = 1 + sizeof...(TTail);
-
-    template <size_t I>
-    using At = typename std::template conditional<I == 0, Head, typename Tail::template At<I - 1>>::type;
-
-    template <typename Func, size_t index = 0>
-    static void ALWAYS_INLINE forEach(Func && func)
-    {
-        func.template operator()<Head, index>();
-        Tail::template forEach<Func, index + 1>(std::forward<Func>(func));
-    }
-};
-
-
 struct AggregateFunctionsUpdater
 {
     AggregateFunctionsUpdater(

From 7885c5c0324ee847ae31a2531a1a4b79c9e2403d Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 15:09:08 +0300
Subject: [PATCH 025/266] renamed TypeListNumber to TypeListNumbers
 [#CLICKHOUSE-2090]

---
 dbms/src/Core/TypeListNumber.h     | 2 +-
 dbms/src/Functions/GatherUtils.cpp | 8 ++++----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/dbms/src/Core/TypeListNumber.h b/dbms/src/Core/TypeListNumber.h
index db7dcc2e5d0..d9e6f82a7a6 100644
--- a/dbms/src/Core/TypeListNumber.h
+++ b/dbms/src/Core/TypeListNumber.h
@@ -5,6 +5,6 @@
 namespace DB
 {
 
-using TypeListNumber = TypeList<UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32, Float64>;
+using TypeListNumbers = TypeList<UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32, Float64>;
 
 }
diff --git a/dbms/src/Functions/GatherUtils.cpp b/dbms/src/Functions/GatherUtils.cpp
index 861f549b498..0b8419ab421 100644
--- a/dbms/src/Functions/GatherUtils.cpp
+++ b/dbms/src/Functions/GatherUtils.cpp
@@ -49,7 +49,7 @@ struct ArraySourceCreator<>
 
 std::unique_ptr<IArraySource> createArraySource(const ColumnArray & col, bool is_const, size_t total_rows)
 {
-    using Creator = typename ApplyTypeListForClass<ArraySourceCreator, TypeListNumber>::Type;
+    using Creator = typename ApplyTypeListForClass<ArraySourceCreator, TypeListNumbers>::Type;
     if (auto column_nullable = typeid_cast<const ColumnNullable *>(&col.getData()))
     {
         ColumnArray column(column_nullable->getNestedColumn(), col.getOffsetsColumn());
@@ -93,7 +93,7 @@ struct ArraySinkCreator<>
 
 std::unique_ptr<IArraySink> createArraySink(ColumnArray & col, size_t column_size)
 {
-    using Creator = ApplyTypeListForClass<ArraySinkCreator, TypeListNumber>::Type;
+    using Creator = ApplyTypeListForClass<ArraySinkCreator, TypeListNumbers>::Type;
     if (auto column_nullable = typeid_cast<ColumnNullable *>(&col.getData()))
     {
         ColumnArray column(column_nullable->getNestedColumn(), col.getOffsetsColumn());
@@ -149,7 +149,7 @@ struct ArraySourceSelector<Base>
 };
 
 template <typename Base>
-using GetArraySourceSelector = typename ApplyTypeListForClass<ArraySourceSelector, typename PrependToTypeList<Base, TypeListNumber>::Type>::Type;
+using GetArraySourceSelector = typename ApplyTypeListForClass<ArraySourceSelector, typename PrependToTypeList<Base, TypeListNumbers>::Type>::Type;
 
 template <typename Base, typename ... Types>
 struct ArraySinkSelector;
@@ -185,7 +185,7 @@ struct ArraySinkSelector<Base>
 };
 
 template <typename Base>
-using GetArraySinkSelector = typename ApplyTypeListForClass<ArraySinkSelector, typename PrependToTypeList<Base, TypeListNumber>::Type>::Type;
+using GetArraySinkSelector = typename ApplyTypeListForClass<ArraySinkSelector, typename PrependToTypeList<Base, TypeListNumbers>::Type>::Type;
 
 template <typename Base>
 struct ArraySinkSourceSelector

From a9e2a17f6956ab55c6f4ccc22c43597f74bcdd87 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Thu, 31 Aug 2017 21:49:48 +0300
Subject: [PATCH 026/266] fixed estimateNumRows in MergeTreeBlockSizePredictor;
 fixed reading of empty block in prewhere; added test [#CLICKHOUSE-3266]

---
 .../Storages/MergeTree/MergeTreeBaseBlockInputStream.cpp   | 7 +++++++
 dbms/src/Storages/MergeTree/MergeTreeBlockReadUtils.h      | 2 +-
 .../00484_preferred_max_column_in_block_size_bytes.sql     | 6 ++++++
 3 files changed, 14 insertions(+), 1 deletion(-)

diff --git a/dbms/src/Storages/MergeTree/MergeTreeBaseBlockInputStream.cpp b/dbms/src/Storages/MergeTree/MergeTreeBaseBlockInputStream.cpp
index 592a97135da..29cdfcc478a 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeBaseBlockInputStream.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeBaseBlockInputStream.cpp
@@ -215,6 +215,13 @@ Block MergeTreeBaseBlockInputStream::readFromPart()
                 return res;
             }
 
+            if (!res.rows())
+            {
+                task->current_range_reader = std::experimental::nullopt;
+                res.clear();
+                continue;
+            }
+
             progressImpl({ res.rows(), res.bytes() });
             pre_reader->fillMissingColumns(res, task->ordered_names, task->should_reorder);
 
diff --git a/dbms/src/Storages/MergeTree/MergeTreeBlockReadUtils.h b/dbms/src/Storages/MergeTree/MergeTreeBlockReadUtils.h
index 95f66f4b6b3..8f0f9107648 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeBlockReadUtils.h
+++ b/dbms/src/Storages/MergeTree/MergeTreeBlockReadUtils.h
@@ -94,7 +94,7 @@ struct MergeTreeBlockSizePredictor
     inline size_t estimateNumRows(size_t bytes_quota) const
     {
         return (bytes_quota > block_size_bytes)
-            ? static_cast<size_t>((bytes_quota - block_size_bytes) / bytes_per_row_current)
+            ? static_cast<size_t>((bytes_quota - block_size_bytes) / std::max<size_t>(1, bytes_per_row_current))
             : 0;
     }
 
diff --git a/dbms/tests/queries/0_stateless/00484_preferred_max_column_in_block_size_bytes.sql b/dbms/tests/queries/0_stateless/00484_preferred_max_column_in_block_size_bytes.sql
index 6ab513feac1..8545f3abd60 100644
--- a/dbms/tests/queries/0_stateless/00484_preferred_max_column_in_block_size_bytes.sql
+++ b/dbms/tests/queries/0_stateless/00484_preferred_max_column_in_block_size_bytes.sql
@@ -18,3 +18,9 @@ create table test.tab (date Date, x UInt64, s FixedString(128)) engine = MergeTr
 insert into test.tab select today(), number, toFixedString('', 128) from system.numbers limit 47;
 set preferred_max_column_in_block_size_bytes = 1152;
 select blockSize(), * from test.tab where x = 1 or x > 36 format Null;
+
+drop table if exists test.tab;
+create table test.tab (date Date, x UInt64, s FixedString(128)) engine = MergeTree(date, (date, x), 8192);
+insert into test.tab select today(), number, toFixedString('', 128) from system.numbers limit 10;
+set preferred_max_column_in_block_size_bytes = 128;
+select s from test.tab where s == '' format Null;

From 937f37c489f5b817efed8318c9326016721e5791 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Thu, 31 Aug 2017 22:14:38 +0300
Subject: [PATCH 027/266] fixed reading of empty block in prewhere
 [#CLICKHOUSE-3266]

---
 .../MergeTree/MergeTreeBaseBlockInputStream.cpp      | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)

diff --git a/dbms/src/Storages/MergeTree/MergeTreeBaseBlockInputStream.cpp b/dbms/src/Storages/MergeTree/MergeTreeBaseBlockInputStream.cpp
index 29cdfcc478a..7486bf84e00 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeBaseBlockInputStream.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeBaseBlockInputStream.cpp
@@ -207,19 +207,9 @@ Block MergeTreeBaseBlockInputStream::readFromPart()
 
             /// In case of isCancelled.
             if (!res)
-            {
-                if (!pre_range_reader)
-                {
-                    task->current_range_reader = std::experimental::nullopt;
-                }
-                return res;
-            }
-
-            if (!res.rows())
             {
                 task->current_range_reader = std::experimental::nullopt;
-                res.clear();
-                continue;
+                return res;
             }
 
             progressImpl({ res.rows(), res.bytes() });

From 1da43b683c4c3f4efaab1b090e2fdcdef487df4b Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 15:23:06 +0300
Subject: [PATCH 028/266] fixed comment [#CLICKHOUSE-2090]

---
 dbms/src/Functions/FunctionsArray.h | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/dbms/src/Functions/FunctionsArray.h b/dbms/src/Functions/FunctionsArray.h
index af2f04adff2..243f41a7251 100644
--- a/dbms/src/Functions/FunctionsArray.h
+++ b/dbms/src/Functions/FunctionsArray.h
@@ -65,15 +65,15 @@ namespace ErrorCodes
   *  arrayConcat(arr1, ...) - concatenate arrays.
   *
   *  arraySlice(arr, offset, length) - make slice of array. Offsets and length may be < 0 or Null
-  *   - if offset <= 0, indexation from right element
+  *   - if offset < 0, indexation from right element
   *   - if length < 0, length = len(array) - (positive_index(offset) - 1) + length
   *   indexation:
   *     [ 1,  2,  3,  4,  5,  6]
-  *     [-5, -4, -3, -2, -1,  0]
+  *     [-6, -5, -4, -3, -2, -1]
   *   examples:
-  *     arraySlice([1, 2, 3, 4, 5, 6], -4, 2) -> [2, 3]
+  *     arraySlice([1, 2, 3, 4, 5, 6], -4, 2) -> [3, 4]
   *     arraySlice([1, 2, 3, 4, 5, 6], 2, -1) -> [2, 3, 4, 5] (6 - (2 - 1) + (-1) = 4)
-  *     arraySlice([1, 2, 3, 4, 5, 6], -4, -1) = arraySlice([1, 2, 3, 4, 5, 6], -4, -1) -> [2, 3, 4, 5]
+  *     arraySlice([1, 2, 3, 4, 5, 6], -5, -1) = arraySlice([1, 2, 3, 4, 5, 6], 2, -1) -> [2, 3, 4, 5]
   *
   *  arrayPushBack(arr, x), arrayPushFront(arr, x)
   *  arrayPopBack(arr), arrayPopFront(arr)

From 6956e1277063f11edf079d4e7f9b83c21b6cb214 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 16:03:54 +0300
Subject: [PATCH 029/266] added comments to writeSlice functions
 [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.h | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index 59d0b9427aa..2b1bccf06c0 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -860,8 +860,11 @@ struct NumericSink
 template <typename T>
 void writeSlice(const NumericArraySlice<T> & slice, NumericArraySink<T> & sink)
 {
+    /// It's possible to write slice into the middle of numeric column. Used in numeric array concat.
     if (sink.elements.size() < sink.current_offset + slice.size)
         sink.elements.resize(sink.current_offset + slice.size);
+    /// Can't use memcpySmallAllowReadWriteOverflow15 when need to write slice into the middle of numeric column.
+    /// TODO: Implement more efficient memcpy without overflow.
     memcpy(&sink.elements[sink.current_offset], slice.data, slice.size * sizeof(T));
     sink.current_offset += slice.size;
 }
@@ -869,6 +872,7 @@ void writeSlice(const NumericArraySlice<T> & slice, NumericArraySink<T> & sink)
 template <typename T, typename U>
 void writeSlice(const NumericArraySlice<T> & slice, NumericArraySink<U> & sink)
 {
+    /// It's possible to write slice into the middle of numeric column. Used in numeric array concat.
     if (sink.elements.size() < sink.current_offset + slice.size)
         sink.elements.resize(sink.current_offset + slice.size);
     for (size_t i = 0; i < slice.size; ++i)
@@ -880,8 +884,7 @@ void writeSlice(const NumericArraySlice<T> & slice, NumericArraySink<U> & sink)
 
 inline ALWAYS_INLINE void writeSlice(const StringSource::Slice & slice, StringSink & sink)
 {
-    if (sink.elements.size() < sink.current_offset + slice.size)
-        sink.elements.resize(sink.current_offset + slice.size);
+    sink.elements.resize(sink.current_offset + slice.size);
     memcpySmallAllowReadWriteOverflow15(&sink.elements[sink.current_offset], slice.data, slice.size);
     sink.current_offset += slice.size;
 }
@@ -911,6 +914,7 @@ inline ALWAYS_INLINE void writeSlice(const GenericArraySlice & slice, GenericArr
 template <typename T>
 inline ALWAYS_INLINE void writeSlice(const GenericArraySlice & slice, NumericArraySink<T> & sink)
 {
+    /// It's possible to write slice into the middle of numeric column. Used in numeric array concat.
     if (sink.elements.size() < sink.current_offset + slice.size)
         sink.elements.resize(sink.current_offset + slice.size);
     for (size_t i = 0; i < slice.size; ++i)
@@ -936,8 +940,11 @@ inline ALWAYS_INLINE void writeSlice(const NumericArraySlice<T> & slice, Generic
 template <typename ArraySlice, typename ArraySink>
 inline ALWAYS_INLINE void writeSlice(const NullableArraySlice<ArraySlice> & slice, NullableArraySink<ArraySink> & sink)
 {
+    /// It's possible to write slice into the middle of numeric column. Used in numeric array concat.
     if (sink.null_map.size() < sink.current_offset + slice.size)
         sink.null_map.resize(sink.current_offset + slice.size);
+    /// Can't use memcpySmallAllowReadWriteOverflow15 when need to write slice into the middle of numeric column.
+    /// TODO: Implement more efficient memcpy without overflow.
     memcpy(&sink.null_map[sink.current_offset], slice.null_map, slice.size * sizeof(UInt8));
     writeSlice(static_cast<const ArraySlice &>(slice), static_cast<ArraySink &>(sink));
 }
@@ -945,8 +952,11 @@ inline ALWAYS_INLINE void writeSlice(const NullableArraySlice<ArraySlice> & slic
 template <typename ArraySlice, typename ArraySink>
 inline ALWAYS_INLINE void writeSlice(const ArraySlice & slice, NullableArraySink<ArraySink> & sink)
 {
+    /// It's possible to write slice into the middle of numeric column. Used in numeric array concat.
     if (sink.null_map.size() < sink.current_offset + slice.size)
         sink.null_map.resize(sink.current_offset + slice.size);
+    /// Can't use memcpySmallAllowReadWriteOverflow15 when need to write slice into the middle of numeric column.
+    /// TODO: Implement more efficient memcpy without overflow.
     memset(&sink.null_map[sink.current_offset], 0, slice.size * sizeof(UInt8));
     writeSlice(slice, static_cast<ArraySink &>(sink));
 }

From f1c01118b59fbb6ee90793a52c01144dc44dc47f Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 16:55:05 +0300
Subject: [PATCH 030/266] fixed writeSlice for const GenericArraySlice and
 NumericArraySink [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index 2b1bccf06c0..6543e2bbeab 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -16,9 +16,9 @@
 #include <Common/memcpySmall.h>
 #include <ext/range.h>
 #include <Core/TypeListNumber.h>
+#include <Core/FieldVisitors.h
 
 #include <DataTypes/DataTypeTraits.h>
-#include <typeindex>
 
 /** These methods are intended for implementation of functions, that
   *  copy ranges from one or more columns to another column.
@@ -921,7 +921,7 @@ inline ALWAYS_INLINE void writeSlice(const GenericArraySlice & slice, NumericArr
     {
         Field field;
         slice.elements->get(slice.begin + i, field);
-        sink.elements.push_back(field.get<T>());
+        sink.elements.push_back(applyVisitor(FieldVisitorConvertToNumber<T>(), field));
     }
     sink.current_offset += slice.size;
 }

From 5b4759acd97a80a2d162ec5df7385ac783a205eb Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 17:32:12 +0300
Subject: [PATCH 031/266] changed sibstring behaviour for offset <
 -string_lenght [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index 6543e2bbeab..4865583907c 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -296,7 +296,7 @@ struct StringSource
     {
         size_t elem_size = offsets[row_num] - prev_offset - 1;
         if (offset > elem_size)
-            return {&elements[prev_offset], elem_size};
+            return {&elements[prev_offset], length + elem_size > offset ? std::min(elem_size, length + elem_size - offset) : 0};
         return {&elements[prev_offset + elem_size - offset], std::min(length, offset)};
     }
 };
@@ -375,7 +375,7 @@ struct FixedStringSource
     Slice getSliceFromRight(size_t offset, size_t length) const
     {
         if (offset > string_size)
-            return {pos, string_size};
+            return {pos, length + string_size > offset ? std::min(string_size, length + string_size - offset) : 0};
         return {pos + string_size - offset, std::min(length, offset)};
     }
 };

From b392788e861b109618dca9d4456dd041fb7dd9f8 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 17:35:37 +0300
Subject: [PATCH 032/266] fix build [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index 4865583907c..1c011a747a7 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -16,7 +16,7 @@
 #include <Common/memcpySmall.h>
 #include <ext/range.h>
 #include <Core/TypeListNumber.h>
-#include <Core/FieldVisitors.h
+#include <Core/FieldVisitors.h>
 
 #include <DataTypes/DataTypeTraits.h>
 

From 02af42d9d831d92d59be178bd26fdfc66334f37a Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 1 Sep 2017 17:47:32 +0300
Subject: [PATCH 033/266] Better path to submodule [#CLICKHOUSE-2].

---
 .gitmodules | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitmodules b/.gitmodules
index 6898dbf788d..587c25ac56f 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +1,3 @@
 [submodule "contrib/mariadb-connector-c"]
 	path = contrib/mariadb-connector-c
-	url = https://github.com/MariaDB/mariadb-connector-c.git
+	url = ../../MariaDB/mariadb-connector-c.git

From 862460f293ac4b98cded31feea7f549ac1260d42 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 17:47:42 +0300
Subject: [PATCH 034/266] changed & to && in GatherUtils.cpp [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.cpp | 62 +++++++++++++++++-------------
 1 file changed, 36 insertions(+), 26 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.cpp b/dbms/src/Functions/GatherUtils.cpp
index 0b8419ab421..20b5c392f39 100644
--- a/dbms/src/Functions/GatherUtils.cpp
+++ b/dbms/src/Functions/GatherUtils.cpp
@@ -114,7 +114,7 @@ template <typename Base, typename Type, typename ... Types>
 struct ArraySourceSelector<Base, Type, Types ...>
 {
     template <typename ... Args>
-    static void select(IArraySource & source, Args & ... args)
+    static void select(IArraySource & source, Args && ... args)
     {
         if (auto array = typeid_cast<NumericArraySource<Type> *>(&source))
             Base::selectImpl(*array, args ...);
@@ -133,7 +133,7 @@ template <typename Base>
 struct ArraySourceSelector<Base>
 {
     template <typename ... Args>
-    static void select(IArraySource & source, Args & ... args)
+    static void select(IArraySource & source, Args && ... args)
     {
         if (auto array = typeid_cast<GenericArraySource *>(&source))
             Base::selectImpl(*array, args ...);
@@ -158,7 +158,7 @@ template <typename Base, typename Type, typename ... Types>
 struct ArraySinkSelector<Base, Type, Types ...>
 {
     template <typename ... Args>
-    static void select(IArraySink & sink, Args & ... args)
+    static void select(IArraySink & sink, Args && ... args)
     {
         if (auto nullable_numeric_sink = typeid_cast<NullableArraySink<NumericArraySink<Type>> *>(&sink))
             Base::selectImpl(*nullable_numeric_sink, args ...);
@@ -173,7 +173,7 @@ template <typename Base>
 struct ArraySinkSelector<Base>
 {
     template <typename ... Args>
-    static void select(IArraySink & sink, Args & ... args)
+    static void select(IArraySink & sink, Args && ... args)
     {
         if (auto nullable_generic_sink = typeid_cast<NullableArraySink<GenericArraySink> *>(&sink))
             Base::selectImpl(*nullable_generic_sink, args ...);
@@ -191,19 +191,19 @@ template <typename Base>
 struct ArraySinkSourceSelector
 {
     template <typename ... Args>
-    static void select(IArraySource & source, IArraySink & sink, Args & ... args)
+    static void select(IArraySource & source, IArraySink & sink, Args && ... args)
     {
         GetArraySinkSelector<Base>::select(sink, source, args ...);
     }
 
     template <typename Sink, typename ... Args>
-    static void selectImpl(Sink & sink, IArraySource & source, Args & ... args)
+    static void selectImpl(Sink && sink, IArraySource & source, Args && ... args)
     {
         GetArraySourceSelector<Base>::select(source, sink, args ...);
     }
 
     template <typename Source, typename Sink, typename ... Args>
-    static void selectImpl(Source & source, Sink & sink, Args & ... args)
+    static void selectImpl(Source && source, Sink && sink, Args && ... args)
     {
         Base::selectSourceSink(source, sink, args ...);
     }
@@ -216,7 +216,7 @@ struct ArraySinkSourceSelector
 /// Only for NumericArraySource, because can't insert values in the middle of arbitary column.
 /// Used for array concat implementation.
 template <typename Source, typename Sink>
-static void append(Source & source, Sink & sink)
+static void append(Source && source, Sink && sink)
 {
     sink.row_num = 0;
     while (!source.isEnd())
@@ -231,14 +231,14 @@ static void append(Source & source, Sink & sink)
 struct ArrayAppend : public GetArraySourceSelector<ArrayAppend>
 {
     template <typename Source, typename Sink>
-    static void selectImpl(Source & source, Sink & sink)
+    static void selectImpl(Source && source, Sink && sink)
     {
-        append<Source, Sink>(source, sink);
+        append(source, sink);
     }
 };
 
 template <typename Sink>
-static void append(IArraySource & source, Sink & sink)
+static void append(IArraySource & source, Sink && sink)
 {
     ArrayAppend::select(source, sink);
 }
@@ -248,7 +248,7 @@ static void append(IArraySource & source, Sink & sink)
 template <typename SourceType, typename SinkType>
 struct ConcatGenericImpl
 {
-    static void concat(GenericArraySource * generic_source, SinkType & sink)
+    static void concat(GenericArraySource * generic_source, SinkType && sink)
     {
         auto source = static_cast<SourceType *>(generic_source);
         writeSlice(source->getWhole(), sink);
@@ -257,7 +257,7 @@ struct ConcatGenericImpl
 };
 
 template <typename Sink>
-static void NO_INLINE concatGeneric(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink & sink)
+static void NO_INLINE concatGeneric(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink && sink)
 {
     std::vector<GenericArraySource *> generic_sources;
     std::vector<bool> is_nullable;
@@ -318,7 +318,7 @@ static void NO_INLINE concatGeneric(const std::vector<std::unique_ptr<IArraySour
 
 /// Concat for array sources. Sources must be either all numeric either all generic.
 template <typename Sink>
-void NO_INLINE concat(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink & sink)
+void NO_INLINE concat(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink && sink)
 {
     size_t elements_to_reserve = 0;
     bool is_first = true;
@@ -355,7 +355,7 @@ void NO_INLINE concat(const std::vector<std::unique_ptr<IArraySource>> & sources
 
     for (const auto & source : sources)
     {
-        append<Sink>(*source, sink);
+        append(*source, sink);
     }
 }
 
@@ -364,19 +364,29 @@ struct ArrayConcat : public GetArraySinkSelector<ArrayConcat>
     using Sources = std::vector<std::unique_ptr<IArraySource>>;
 
     template <typename Sink>
-    static void selectImpl(Sink & sink, Sources & sources)
+    static void selectImpl(Sink && sink, Sources && sources)
     {
         concat<Sink>(sources, sink);
     }
 
-    static void selectImpl(GenericArraySink & sink, Sources & sources)
+    static void selectImpl(GenericArraySink & sink, Sources && sources)
     {
-        concatGeneric<GenericArraySink>(sources, sink);
+        concatGeneric(sources, sink);
     }
 
-    static void selectImpl(NullableArraySink<GenericArraySink> & sink, Sources & sources)
+    static void selectImpl(NullableArraySink<GenericArraySink> & sink, Sources && sources)
     {
-        concatGeneric<NullableArraySink<GenericArraySink>>(sources, sink);
+        concatGeneric(sources, sink);
+    }
+
+    static void selectImpl(GenericArraySink && sink, Sources && sources)
+    {
+        concatGeneric(sources, sink);
+    }
+
+    static void selectImpl(NullableArraySink<GenericArraySink> && sink, Sources && sources)
+    {
+        concatGeneric(sources, sink);
     }
 };
 
@@ -392,7 +402,7 @@ struct SliceFromLeftConstantOffsetUnboundedSelectArraySource
         : public ArraySinkSourceSelector<SliceFromLeftConstantOffsetUnboundedSelectArraySource>
 {
     template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, size_t & offset)
+    static void selectSourceSink(Source && source, Sink && sink, size_t & offset)
     {
         sliceFromLeftConstantOffsetUnbounded(source, sink, offset);
     }
@@ -402,7 +412,7 @@ struct SliceFromLeftConstantOffsetBoundedSelectArraySource
         : public ArraySinkSourceSelector<SliceFromLeftConstantOffsetBoundedSelectArraySource>
 {
     template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, size_t & offset, ssize_t & length)
+    static void selectSourceSink(Source && source, Sink && sink, size_t & offset, ssize_t & length)
     {
         sliceFromLeftConstantOffsetBounded(source, sink, offset, length);
     }
@@ -412,7 +422,7 @@ struct SliceFromRightConstantOffsetUnboundedSelectArraySource
         : public ArraySinkSourceSelector<SliceFromRightConstantOffsetUnboundedSelectArraySource>
 {
     template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, size_t & offset)
+    static void selectSourceSink(Source && source, Sink && sink, size_t & offset)
     {
         sliceFromRightConstantOffsetUnbounded(source, sink, offset);
     }
@@ -422,7 +432,7 @@ struct SliceFromRightConstantOffsetBoundedSelectArraySource
         : public ArraySinkSourceSelector<SliceFromRightConstantOffsetBoundedSelectArraySource>
 {
     template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, size_t & offset, ssize_t & length)
+    static void selectSourceSink(Source && source, Sink && sink, size_t & offset, ssize_t & length)
     {
         sliceFromRightConstantOffsetBounded(source, sink, offset, length);
     }
@@ -432,7 +442,7 @@ struct SliceDynamicOffsetUnboundedSelectArraySource
         : public ArraySinkSourceSelector<SliceDynamicOffsetUnboundedSelectArraySource>
 {
     template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, IColumn & offset_column)
+    static void selectSourceSink(Source && source, Sink && sink, IColumn & offset_column)
     {
         sliceDynamicOffsetUnbounded(source, sink, offset_column);
     }
@@ -442,7 +452,7 @@ struct SliceDynamicOffsetBoundedSelectArraySource
         : public ArraySinkSourceSelector<SliceDynamicOffsetBoundedSelectArraySource>
 {
     template <typename Source, typename Sink>
-    static void selectSourceSink(Source & source, Sink & sink, IColumn & offset_column, IColumn & length_column)
+    static void selectSourceSink(Source && source, Sink && sink, IColumn & offset_column, IColumn & length_column)
     {
         sliceDynamicOffsetBounded(source, sink, offset_column, length_column);
     }

From 8629ded37e4caa95cfdac1c489f2b552358d309f Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 1 Sep 2017 17:49:58 +0300
Subject: [PATCH 035/266] Better path to submodule [#CLICKHOUSE-2].

---
 .gitmodules | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitmodules b/.gitmodules
index 587c25ac56f..3e2525f500b 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +1,3 @@
 [submodule "contrib/mariadb-connector-c"]
 	path = contrib/mariadb-connector-c
-	url = ../../MariaDB/mariadb-connector-c.git
+	url = /MariaDB/mariadb-connector-c.git

From 3370ba270f2ee27c2152acfbbca10d4d32d5366c Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 17:55:43 +0300
Subject: [PATCH 036/266] fix build [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.cpp b/dbms/src/Functions/GatherUtils.cpp
index 20b5c392f39..e7783ad91be 100644
--- a/dbms/src/Functions/GatherUtils.cpp
+++ b/dbms/src/Functions/GatherUtils.cpp
@@ -364,17 +364,17 @@ struct ArrayConcat : public GetArraySinkSelector<ArrayConcat>
     using Sources = std::vector<std::unique_ptr<IArraySource>>;
 
     template <typename Sink>
-    static void selectImpl(Sink && sink, Sources && sources)
+    static void selectImpl(Sink && sink, Sources & sources)
     {
         concat<Sink>(sources, sink);
     }
 
-    static void selectImpl(GenericArraySink & sink, Sources && sources)
+    static void selectImpl(GenericArraySink & sink, Sources & sources)
     {
         concatGeneric(sources, sink);
     }
 
-    static void selectImpl(NullableArraySink<GenericArraySink> & sink, Sources && sources)
+    static void selectImpl(NullableArraySink<GenericArraySink> & sink, Sources & sources)
     {
         concatGeneric(sources, sink);
     }
@@ -384,7 +384,7 @@ struct ArrayConcat : public GetArraySinkSelector<ArrayConcat>
         concatGeneric(sources, sink);
     }
 
-    static void selectImpl(NullableArraySink<GenericArraySink> && sink, Sources && sources)
+    static void selectImpl(NullableArraySink<GenericArraySink> && sink, Sources & sources)
     {
         concatGeneric(sources, sink);
     }

From a46780e4a5f5eedf86e653f9049320f0d131a32c Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 19:45:05 +0300
Subject: [PATCH 037/266] renamed concatGeneric to concatGenericArray
 [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.cpp | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.cpp b/dbms/src/Functions/GatherUtils.cpp
index e7783ad91be..636fb8ad049 100644
--- a/dbms/src/Functions/GatherUtils.cpp
+++ b/dbms/src/Functions/GatherUtils.cpp
@@ -246,9 +246,9 @@ static void append(IArraySource & source, Sink && sink)
 /// Concat specialization for GenericArraySource. Because can't use append with arbitrary column type.
 
 template <typename SourceType, typename SinkType>
-struct ConcatGenericImpl
+struct ConcatGenericArrayWriteWholeImpl
 {
-    static void concat(GenericArraySource * generic_source, SinkType && sink)
+    static void writeWhole(GenericArraySource * generic_source, SinkType && sink)
     {
         auto source = static_cast<SourceType *>(generic_source);
         writeSlice(source->getWhole(), sink);
@@ -257,7 +257,7 @@ struct ConcatGenericImpl
 };
 
 template <typename Sink>
-static void NO_INLINE concatGeneric(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink && sink)
+static void NO_INLINE concatGenericArray(const std::vector<std::unique_ptr<IArraySource>> & sources, Sink && sink)
 {
     std::vector<GenericArraySource *> generic_sources;
     std::vector<bool> is_nullable;
@@ -300,16 +300,16 @@ static void NO_INLINE concatGeneric(const std::vector<std::unique_ptr<IArraySour
             if (is_const[i])
             {
                 if (is_nullable[i])
-                    ConcatGenericImpl<ConstSource<NullableArraySource<GenericArraySource>>, Sink>::concat(source, sink);
+                    ConcatGenericArrayWriteWholeImpl<ConstSource<NullableArraySource<GenericArraySource>>, Sink>::writeWhole(source, sink);
                 else
-                    ConcatGenericImpl<ConstSource<GenericArraySource>, Sink>::concat(source, sink);
+                    ConcatGenericArrayWriteWholeImpl<ConstSource<GenericArraySource>, Sink>::writeWhole(source, sink);
             }
             else
             {
                 if (is_nullable[i])
-                    ConcatGenericImpl<NullableArraySource<GenericArraySource>, Sink>::concat(source, sink);
+                    ConcatGenericArrayWriteWholeImpl<NullableArraySource<GenericArraySource>, Sink>::writeWhole(source, sink);
                 else
-                    ConcatGenericImpl<GenericArraySource, Sink>::concat(source, sink);
+                    ConcatGenericArrayWriteWholeImpl<GenericArraySource, Sink>::writeWhole(source, sink);
             }
         }
         sink.next();
@@ -371,22 +371,22 @@ struct ArrayConcat : public GetArraySinkSelector<ArrayConcat>
 
     static void selectImpl(GenericArraySink & sink, Sources & sources)
     {
-        concatGeneric(sources, sink);
+        concatGenericArray(sources, sink);
     }
 
     static void selectImpl(NullableArraySink<GenericArraySink> & sink, Sources & sources)
     {
-        concatGeneric(sources, sink);
+        concatGenericArray(sources, sink);
     }
 
     static void selectImpl(GenericArraySink && sink, Sources && sources)
     {
-        concatGeneric(sources, sink);
+        concatGenericArray(sources, sink);
     }
 
     static void selectImpl(NullableArraySink<GenericArraySink> && sink, Sources & sources)
     {
-        concatGeneric(sources, sink);
+        concatGenericArray(sources, sink);
     }
 };
 

From b4f7e0e15c8100e3ccd8de1eaeb84c1e495f620c Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 19:57:01 +0300
Subject: [PATCH 038/266] restored identation in FunctionsArray.cpp
 [#CLICKHOUSE-2090]

---
 dbms/src/Functions/FunctionsArray.cpp | 1717 ++++++++++++-------------
 1 file changed, 823 insertions(+), 894 deletions(-)

diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index 4d65860f11d..d8682a9d5b0 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -7,7 +7,6 @@
 #include <Functions/FunctionsConversion.h>
 #include <Functions/Conditional/getArrayType.h>
 #include <Functions/Conditional/CondException.h>
-#include <Functions/GatherUtils.h>
 #include <Common/HashTable/HashMap.h>
 #include <Common/HashTable/ClearableHashMap.h>
 #include <Parsers/ExpressionListParsers.h>
@@ -32,13 +31,13 @@ String FunctionArray::getName() const
     return name;
 }
 
-FunctionPtr FunctionArray::create(const Context &context)
+FunctionPtr FunctionArray::create(const Context & context)
 {
     return std::make_shared<FunctionArray>(context);
 }
 
-FunctionArray::FunctionArray(const Context &context)
-        : context(context)
+FunctionArray::FunctionArray(const Context & context)
+    : context(context)
 {
 }
 
@@ -47,7 +46,7 @@ namespace
 {
 
 /// Is there at least one numeric argument among the specified ones?
-bool foundNumericType(const DataTypes &args)
+bool foundNumericType(const DataTypes & args)
 {
     for (size_t i = 0; i < args.size(); ++i)
     {
@@ -62,7 +61,7 @@ bool foundNumericType(const DataTypes &args)
 
 
 /// Check if the specified arguments have the same type up to nullability or nullity.
-bool hasArrayIdenticalTypes(const DataTypes &args)
+bool hasArrayIdenticalTypes(const DataTypes & args)
 {
     std::string first_type_name;
 
@@ -70,8 +69,8 @@ bool hasArrayIdenticalTypes(const DataTypes &args)
     {
         if (!args[i]->isNull())
         {
-            const IDataType *observed_type = DataTypeTraits::removeNullable(args[i]).get();
-            const std::string &name = observed_type->getName();
+            const IDataType * observed_type = DataTypeTraits::removeNullable(args[i]).get();
+            const std::string & name = observed_type->getName();
 
             if (first_type_name.empty())
                 first_type_name = name;
@@ -87,16 +86,16 @@ bool hasArrayIdenticalTypes(const DataTypes &args)
 /// function hasArrayIdenticalTypes(), deduce the element type of an array that
 /// would be constructed from a set of values V, such that, for each i, the
 /// type of V[i] is args[i].
-DataTypePtr getArrayElementType(const DataTypes &args)
+DataTypePtr getArrayElementType(const DataTypes & args)
 {
     bool found_null = false;
     bool found_nullable = false;
 
-    const DataTypePtr *ret = nullptr;
+    const DataTypePtr * ret = nullptr;
 
     for (size_t i = 0; i < args.size(); ++i)
     {
-        const auto &type = args[i];
+        const auto & type = args[i];
 
         if (type->isNull())
             found_null = true;
@@ -128,8 +127,8 @@ DataTypePtr getArrayElementType(const DataTypes &args)
     }
 }
 
-template<typename T0, typename T1>
-bool tryAddField(DataTypePtr type_res, const Field &f, Array &arr)
+template <typename T0, typename T1>
+bool tryAddField(DataTypePtr type_res, const Field & f, Array & arr)
 {
     if (typeid_cast<const T0 *>(type_res.get()))
     {
@@ -144,28 +143,28 @@ bool tryAddField(DataTypePtr type_res, const Field &f, Array &arr)
 
 }
 
-bool FunctionArray::addField(DataTypePtr type_res, const Field &f, Array &arr) const
+bool FunctionArray::addField(DataTypePtr type_res, const Field & f, Array & arr) const
 {
     /// Otherwise, it is necessary
-    if (tryAddField<DataTypeUInt8, DataTypeUInt64>(type_res, f, arr)
-        || tryAddField<DataTypeUInt16, DataTypeUInt64>(type_res, f, arr)
-        || tryAddField<DataTypeUInt32, DataTypeUInt64>(type_res, f, arr)
-        || tryAddField<DataTypeUInt64, DataTypeUInt64>(type_res, f, arr)
-        || tryAddField<DataTypeInt8, DataTypeInt64>(type_res, f, arr)
-        || tryAddField<DataTypeInt16, DataTypeInt64>(type_res, f, arr)
-        || tryAddField<DataTypeInt32, DataTypeInt64>(type_res, f, arr)
-        || tryAddField<DataTypeInt64, DataTypeInt64>(type_res, f, arr)
-        || tryAddField<DataTypeFloat32, DataTypeFloat64>(type_res, f, arr)
-        || tryAddField<DataTypeFloat64, DataTypeFloat64>(type_res, f, arr))
+    if (    tryAddField<DataTypeUInt8, DataTypeUInt64>(type_res, f, arr)
+        ||    tryAddField<DataTypeUInt16, DataTypeUInt64>(type_res, f, arr)
+        ||    tryAddField<DataTypeUInt32, DataTypeUInt64>(type_res, f, arr)
+        ||    tryAddField<DataTypeUInt64, DataTypeUInt64>(type_res, f, arr)
+        ||    tryAddField<DataTypeInt8, DataTypeInt64>(type_res, f, arr)
+        ||    tryAddField<DataTypeInt16, DataTypeInt64>(type_res, f, arr)
+        ||    tryAddField<DataTypeInt32, DataTypeInt64>(type_res, f, arr)
+        ||    tryAddField<DataTypeInt64, DataTypeInt64>(type_res, f, arr)
+        ||    tryAddField<DataTypeFloat32, DataTypeFloat64>(type_res, f, arr)
+        ||    tryAddField<DataTypeFloat64, DataTypeFloat64>(type_res, f, arr) )
         return true;
     else
     {
         throw Exception{"Illegal result type " + type_res->getName() + " of function " + getName(),
-                        ErrorCodes::LOGICAL_ERROR};
+            ErrorCodes::LOGICAL_ERROR};
     }
 }
 
-const DataTypePtr &FunctionArray::getScalarType(const DataTypePtr &type)
+const DataTypePtr & FunctionArray::getScalarType(const DataTypePtr & type)
 {
     const auto array = checkAndGetDataType<DataTypeArray>(type.get());
 
@@ -175,7 +174,7 @@ const DataTypePtr &FunctionArray::getScalarType(const DataTypePtr &type)
     return getScalarType(array->getNestedType());
 }
 
-DataTypeTraits::EnrichedDataTypePtr FunctionArray::getLeastCommonType(const DataTypes &arguments) const
+DataTypeTraits::EnrichedDataTypePtr FunctionArray::getLeastCommonType(const DataTypes & arguments) const
 {
     DataTypeTraits::EnrichedDataTypePtr result_type;
 
@@ -183,26 +182,26 @@ DataTypeTraits::EnrichedDataTypePtr FunctionArray::getLeastCommonType(const Data
     {
         result_type = Conditional::getArrayType(arguments);
     }
-    catch (const Conditional::CondException &ex)
+    catch (const Conditional::CondException & ex)
     {
         /// Translate a context-free error into a contextual error.
         if (ex.getCode() == Conditional::CondErrorCodes::TYPE_DEDUCER_ILLEGAL_COLUMN_TYPE)
             throw Exception{"Illegal type of column " + ex.getMsg1() +
-                            " in array", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+                " in array", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
         else if (ex.getCode() == Conditional::CondErrorCodes::TYPE_DEDUCER_UPSCALING_ERROR)
             throw Exception("Arguments of function " + getName() + " are not upscalable "
-                                    "to a common type without loss of precision.",
-                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                "to a common type without loss of precision.",
+                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
         else
             throw Exception{"An unexpected error has occurred in function " + getName(),
-                            ErrorCodes::LOGICAL_ERROR};
+                ErrorCodes::LOGICAL_ERROR};
     }
 
     return result_type;
 }
 
 
-DataTypePtr FunctionArray::getReturnTypeImpl(const DataTypes &arguments) const
+DataTypePtr FunctionArray::getReturnTypeImpl(const DataTypes & arguments) const
 {
     if (arguments.empty())
         throw Exception{"Function array requires at least one argument.", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
@@ -219,14 +218,13 @@ DataTypePtr FunctionArray::getReturnTypeImpl(const DataTypes &arguments) const
     {
         /// Otherwise all the arguments must have the same type up to nullability or nullity.
         if (!hasArrayIdenticalTypes(arguments))
-            throw Exception{"Arguments for function array must have same type or behave as number.",
-                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            throw Exception{"Arguments for function array must have same type or behave as number.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
 
         return std::make_shared<DataTypeArray>(getArrayElementType(arguments));
     }
 }
 
-void FunctionArray::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
+void FunctionArray::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
     size_t num_elements = arguments.size();
     bool is_const = true;
@@ -240,17 +238,17 @@ void FunctionArray::executeImpl(Block &block, const ColumnNumbers &arguments, si
         }
     }
 
-    const DataTypePtr &return_type = block.getByPosition(result).type;
-    const DataTypePtr &elem_type = static_cast<const DataTypeArray &>(*return_type).getNestedType();
+    const DataTypePtr & return_type = block.getByPosition(result).type;
+    const DataTypePtr & elem_type = static_cast<const DataTypeArray &>(*return_type).getNestedType();
 
     if (is_const)
     {
-        const DataTypePtr &observed_type = DataTypeTraits::removeNullable(elem_type);
+        const DataTypePtr & observed_type = DataTypeTraits::removeNullable(elem_type);
 
         Array arr;
         for (const auto arg_num : arguments)
         {
-            const auto &elem = block.getByPosition(arg_num);
+            const auto & elem = block.getByPosition(arg_num);
 
             if (DataTypeTraits::removeNullable(elem.type)->equals(*observed_type))
             {
@@ -280,11 +278,11 @@ void FunctionArray::executeImpl(Block &block, const ColumnNumbers &arguments, si
           */
 
         Columns columns_holder(num_elements);
-        const IColumn *columns[num_elements];
+        const IColumn * columns[num_elements];
 
         for (size_t i = 0; i < num_elements; ++i)
         {
-            const auto &arg = block.getByPosition(arguments[i]);
+            const auto & arg = block.getByPosition(arguments[i]);
 
             String elem_type_name = elem_type->getName();
             ColumnPtr preprocessed_column = arg.column;
@@ -292,30 +290,29 @@ void FunctionArray::executeImpl(Block &block, const ColumnNumbers &arguments, si
             if (arg.type->getName() != elem_type_name)
             {
                 Block temporary_block
-                        {
-                                {
-                                        arg.column,
-                                        arg.type,
-                                        arg.name
-                                },
-                                {
-                                        DataTypeString().createConstColumn(block_size, elem_type_name),
-                                        std::make_shared<DataTypeString>(),
-                                        ""
-                                },
-                                {
-                                        nullptr,
-                                        elem_type,
-                                        ""
-                                }
-                        };
+                {
+                    {
+                        arg.column,
+                        arg.type,
+                        arg.name
+                    },
+                    {
+                        DataTypeString().createConstColumn(block_size, elem_type_name),
+                        std::make_shared<DataTypeString>(),
+                        ""
+                    },
+                    {
+                        nullptr,
+                        elem_type,
+                        ""
+                    }
+                };
 
                 FunctionCast func_cast(context);
 
                 {
                     DataTypePtr unused_return_type;
-                    ColumnsWithTypeAndName arguments{temporary_block.getByPosition(0),
-                                                     temporary_block.getByPosition(1)};
+                    ColumnsWithTypeAndName arguments{ temporary_block.getByPosition(0), temporary_block.getByPosition(1) };
                     std::vector<ExpressionAction> unused_prerequisites;
 
                     /// Prepares function to execution. TODO It is not obvious.
@@ -337,8 +334,8 @@ void FunctionArray::executeImpl(Block &block, const ColumnNumbers &arguments, si
           */
 
         auto out = std::make_shared<ColumnArray>(elem_type->createColumn());
-        IColumn &out_data = out->getData();
-        IColumn::Offsets_t &out_offsets = out->getOffsets();
+        IColumn & out_data = out->getData();
+        IColumn::Offsets_t & out_offsets = out->getOffsets();
 
         out_data.reserve(block_size * num_elements);
         out_offsets.resize(block_size);
@@ -365,18 +362,15 @@ namespace ArrayImpl
 class NullMapBuilder
 {
 public:
-    operator bool() const
-    { return src_nullable_col || src_array; }
+    operator bool() const { return src_nullable_col || src_array; }
+    bool operator!() const { return !src_nullable_col && !src_array; }
 
-    bool operator!() const
-    { return !src_nullable_col && !src_array; }
-
-    void initSource(const ColumnNullable &src_nullable_col_)
+    void initSource(const ColumnNullable & src_nullable_col_)
     {
         src_nullable_col = &src_nullable_col_;
     }
 
-    void initSource(const Array &src_array_)
+    void initSource(const Array & src_array_)
     {
         src_array = &src_array_;
     }
@@ -390,8 +384,7 @@ public:
     void update(size_t from)
     {
         if (index >= size)
-            throw Exception{"Logical error: index passed to NullMapBuilder is out of range of column.",
-                            ErrorCodes::LOGICAL_ERROR};
+            throw Exception{"Logical error: index passed to NullMapBuilder is out of range of column.", ErrorCodes::LOGICAL_ERROR};
 
         bool is_null;
         if (src_nullable_col)
@@ -399,7 +392,7 @@ public:
         else
             is_null = from < src_array->size() ? (*src_array)[from].isNull() : true;
 
-        auto &null_map_data = static_cast<ColumnUInt8 &>(*sink_null_map).getData();
+        auto & null_map_data = static_cast<ColumnUInt8 &>(*sink_null_map).getData();
         null_map_data[index] = is_null ? 1 : 0;
 
         ++index;
@@ -408,20 +401,18 @@ public:
     void update()
     {
         if (index >= size)
-            throw Exception{"Logical error: index passed to NullMapBuilder is out of range of column.",
-                            ErrorCodes::LOGICAL_ERROR};
+            throw Exception{"Logical error: index passed to NullMapBuilder is out of range of column.", ErrorCodes::LOGICAL_ERROR};
 
-        auto &null_map_data = static_cast<ColumnUInt8 &>(*sink_null_map).getData();
+        auto & null_map_data = static_cast<ColumnUInt8 &>(*sink_null_map).getData();
         null_map_data[index] = 0;
         ++index;
     }
 
-    ColumnPtr getNullMap() const
-    { return sink_null_map; }
+    ColumnPtr getNullMap() const { return sink_null_map; }
 
 private:
-    const ColumnNullable *src_nullable_col = nullptr;
-    const Array *src_array = nullptr;
+    const ColumnNullable * src_nullable_col = nullptr;
+    const Array * src_array = nullptr;
     ColumnPtr sink_null_map;
     size_t size = 0;
     size_t index = 0;
@@ -432,18 +423,18 @@ private:
 namespace
 {
 
-template<typename T>
+template <typename T>
 struct ArrayElementNumImpl
 {
     /** Implementation for constant index.
       * If negative = false - index is from beginning of array, started from 1.
       * If negative = true - index is from end of array, started from -1.
       */
-    template<bool negative>
+    template <bool negative>
     static void vectorConst(
-            const PaddedPODArray<T> &data, const ColumnArray::Offsets_t &offsets,
-            const ColumnArray::Offset_t index,
-            PaddedPODArray<T> &result, ArrayImpl::NullMapBuilder &builder)
+        const PaddedPODArray<T> & data, const ColumnArray::Offsets_t & offsets,
+        const ColumnArray::Offset_t index,
+        PaddedPODArray<T> & result, ArrayImpl::NullMapBuilder & builder)
     {
         size_t size = offsets.size();
         result.resize(size);
@@ -474,11 +465,11 @@ struct ArrayElementNumImpl
 
     /** Implementation for non-constant index.
       */
-    template<typename TIndex>
+    template <typename TIndex>
     static void vector(
-            const PaddedPODArray<T> &data, const ColumnArray::Offsets_t &offsets,
-            const PaddedPODArray<TIndex> &indices,
-            PaddedPODArray<T> &result, ArrayImpl::NullMapBuilder &builder)
+        const PaddedPODArray<T> & data, const ColumnArray::Offsets_t & offsets,
+        const PaddedPODArray<TIndex> & indices,
+        PaddedPODArray<T> & result, ArrayImpl::NullMapBuilder & builder)
     {
         size_t size = offsets.size();
         result.resize(size);
@@ -524,13 +515,12 @@ struct ArrayElementStringImpl
       * If negative = false - index is from beginning of array, started from 1.
       * If negative = true - index is from end of array, started from -1.
       */
-    template<bool negative>
+    template <bool negative>
     static void vectorConst(
-            const ColumnString::Chars_t &data, const ColumnArray::Offsets_t &offsets,
-            const ColumnString::Offsets_t &string_offsets,
-            const ColumnArray::Offset_t index,
-            ColumnString::Chars_t &result_data, ColumnArray::Offsets_t &result_offsets,
-            ArrayImpl::NullMapBuilder &builder)
+        const ColumnString::Chars_t & data, const ColumnArray::Offsets_t & offsets, const ColumnString::Offsets_t & string_offsets,
+        const ColumnArray::Offset_t index,
+        ColumnString::Chars_t & result_data, ColumnArray::Offsets_t & result_offsets,
+        ArrayImpl::NullMapBuilder & builder)
     {
         size_t size = offsets.size();
         result_offsets.resize(size);
@@ -546,19 +536,18 @@ struct ArrayElementStringImpl
             {
                 size_t adjusted_index = !negative ? index : (array_size - index - 1);
 
-                size_t j = (current_offset == 0 && adjusted_index == 0) ? 0 : current_offset + adjusted_index;
+                size_t j =  (current_offset == 0 && adjusted_index == 0) ? 0 : current_offset + adjusted_index;
                 if (builder)
                     builder.update(j);
 
                 ColumnArray::Offset_t string_pos = current_offset == 0 && adjusted_index == 0
-                                                   ? 0
-                                                   : string_offsets[current_offset + adjusted_index - 1];
+                    ? 0
+                    : string_offsets[current_offset + adjusted_index - 1];
 
                 ColumnArray::Offset_t string_size = string_offsets[current_offset + adjusted_index] - string_pos;
 
                 result_data.resize(current_result_offset + string_size);
-                memcpySmallAllowReadWriteOverflow15(&result_data[current_result_offset], &data[string_pos],
-                                                    string_size);
+                memcpySmallAllowReadWriteOverflow15(&result_data[current_result_offset], &data[string_pos], string_size);
                 current_result_offset += string_size;
                 result_offsets[i] = current_result_offset;
             }
@@ -580,13 +569,12 @@ struct ArrayElementStringImpl
 
     /** Implementation for non-constant index.
       */
-    template<typename TIndex>
+    template <typename TIndex>
     static void vector(
-            const ColumnString::Chars_t &data, const ColumnArray::Offsets_t &offsets,
-            const ColumnString::Offsets_t &string_offsets,
-            const PaddedPODArray<TIndex> &indices,
-            ColumnString::Chars_t &result_data, ColumnArray::Offsets_t &result_offsets,
-            ArrayImpl::NullMapBuilder &builder)
+        const ColumnString::Chars_t & data, const ColumnArray::Offsets_t & offsets, const ColumnString::Offsets_t & string_offsets,
+        const PaddedPODArray<TIndex> & indices,
+        ColumnString::Chars_t & result_data, ColumnArray::Offsets_t & result_offsets,
+        ArrayImpl::NullMapBuilder & builder)
     {
         size_t size = offsets.size();
         result_offsets.resize(size);
@@ -614,14 +602,13 @@ struct ArrayElementStringImpl
                     builder.update(j);
 
                 ColumnArray::Offset_t string_pos = current_offset == 0 && adjusted_index == 0
-                                                   ? 0
-                                                   : string_offsets[current_offset + adjusted_index - 1];
+                    ? 0
+                    : string_offsets[current_offset + adjusted_index - 1];
 
                 ColumnArray::Offset_t string_size = string_offsets[current_offset + adjusted_index] - string_pos;
 
                 result_data.resize(current_result_offset + string_size);
-                memcpySmallAllowReadWriteOverflow15(&result_data[current_result_offset], &data[string_pos],
-                                                    string_size);
+                memcpySmallAllowReadWriteOverflow15(&result_data[current_result_offset], &data[string_pos], string_size);
                 current_result_offset += string_size;
                 result_offsets[i] = current_result_offset;
             }
@@ -649,11 +636,11 @@ struct ArrayElementGenericImpl
       * If negative = false - index is from beginning of array, started from 1.
       * If negative = true - index is from end of array, started from -1.
       */
-    template<bool negative>
+    template <bool negative>
     static void vectorConst(
-            const IColumn &data, const ColumnArray::Offsets_t &offsets,
-            const ColumnArray::Offset_t index,
-            IColumn &result, ArrayImpl::NullMapBuilder &builder)
+        const IColumn & data, const ColumnArray::Offsets_t & offsets,
+        const ColumnArray::Offset_t index,
+        IColumn & result, ArrayImpl::NullMapBuilder & builder)
     {
         size_t size = offsets.size();
         result.reserve(size);
@@ -683,11 +670,11 @@ struct ArrayElementGenericImpl
 
     /** Implementation for non-constant index.
       */
-    template<typename TIndex>
+    template <typename TIndex>
     static void vector(
-            const IColumn &data, const ColumnArray::Offsets_t &offsets,
-            const PaddedPODArray<TIndex> &indices,
-            IColumn &result, ArrayImpl::NullMapBuilder &builder)
+        const IColumn & data, const ColumnArray::Offsets_t & offsets,
+        const PaddedPODArray<TIndex> & indices,
+        IColumn & result, ArrayImpl::NullMapBuilder & builder)
     {
         size_t size = offsets.size();
         result.reserve(size);
@@ -727,23 +714,22 @@ struct ArrayElementGenericImpl
 }
 
 
-FunctionPtr FunctionArrayElement::create(const Context &context)
+FunctionPtr FunctionArrayElement::create(const Context & context)
 {
     return std::make_shared<FunctionArrayElement>();
 }
 
 
-template<typename DataType>
-bool FunctionArrayElement::executeNumberConst(Block &block, const ColumnNumbers &arguments, size_t result,
-                                              const Field &index,
-                                              ArrayImpl::NullMapBuilder &builder)
+template <typename DataType>
+bool FunctionArrayElement::executeNumberConst(Block & block, const ColumnNumbers & arguments, size_t result, const Field & index,
+    ArrayImpl::NullMapBuilder & builder)
 {
-    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const ColumnVector<DataType> *col_nested = checkAndGetColumn<ColumnVector<DataType>>(&col_array->getData());
+    const ColumnVector<DataType> * col_nested = checkAndGetColumn<ColumnVector<DataType>>(&col_array->getData());
 
     if (!col_nested)
         return false;
@@ -753,29 +739,26 @@ bool FunctionArrayElement::executeNumberConst(Block &block, const ColumnNumbers
 
     if (index.getType() == Field::Types::UInt64)
         ArrayElementNumImpl<DataType>::template vectorConst<false>(
-                col_nested->getData(), col_array->getOffsets(), safeGet<UInt64>(index) - 1, col_res->getData(),
-                builder);
+            col_nested->getData(), col_array->getOffsets(), safeGet<UInt64>(index) - 1, col_res->getData(), builder);
     else if (index.getType() == Field::Types::Int64)
         ArrayElementNumImpl<DataType>::template vectorConst<true>(
-                col_nested->getData(), col_array->getOffsets(), -safeGet<Int64>(index) - 1, col_res->getData(),
-                builder);
+            col_nested->getData(), col_array->getOffsets(), -safeGet<Int64>(index) - 1, col_res->getData(), builder);
     else
         throw Exception("Illegal type of array index", ErrorCodes::LOGICAL_ERROR);
 
     return true;
 }
 
-template<typename IndexType, typename DataType>
-bool FunctionArrayElement::executeNumber(Block &block, const ColumnNumbers &arguments, size_t result,
-                                         const PaddedPODArray<IndexType> &indices,
-                                         ArrayImpl::NullMapBuilder &builder)
+template <typename IndexType, typename DataType>
+bool FunctionArrayElement::executeNumber(Block & block, const ColumnNumbers & arguments, size_t result, const PaddedPODArray<IndexType> & indices,
+    ArrayImpl::NullMapBuilder & builder)
 {
-    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const ColumnVector<DataType> *col_nested = checkAndGetColumn<ColumnVector<DataType>>(&col_array->getData());
+    const ColumnVector<DataType> * col_nested = checkAndGetColumn<ColumnVector<DataType>>(&col_array->getData());
 
     if (!col_nested)
         return false;
@@ -784,21 +767,20 @@ bool FunctionArrayElement::executeNumber(Block &block, const ColumnNumbers &argu
     block.getByPosition(result).column = col_res;
 
     ArrayElementNumImpl<DataType>::template vector<IndexType>(
-            col_nested->getData(), col_array->getOffsets(), indices, col_res->getData(), builder);
+        col_nested->getData(), col_array->getOffsets(), indices, col_res->getData(), builder);
 
     return true;
 }
 
-bool FunctionArrayElement::executeStringConst(Block &block, const ColumnNumbers &arguments, size_t result,
-                                              const Field &index,
-                                              ArrayImpl::NullMapBuilder &builder)
+bool FunctionArrayElement::executeStringConst(Block & block, const ColumnNumbers & arguments, size_t result, const Field & index,
+    ArrayImpl::NullMapBuilder & builder)
 {
-    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const ColumnString *col_nested = checkAndGetColumn<ColumnString>(&col_array->getData());
+    const ColumnString * col_nested = checkAndGetColumn<ColumnString>(&col_array->getData());
 
     if (!col_nested)
         return false;
@@ -808,39 +790,38 @@ bool FunctionArrayElement::executeStringConst(Block &block, const ColumnNumbers
 
     if (index.getType() == Field::Types::UInt64)
         ArrayElementStringImpl::vectorConst<false>(
-                col_nested->getChars(),
-                col_array->getOffsets(),
-                col_nested->getOffsets(),
-                safeGet<UInt64>(index) - 1,
-                col_res->getChars(),
-                col_res->getOffsets(),
-                builder);
+            col_nested->getChars(),
+            col_array->getOffsets(),
+            col_nested->getOffsets(),
+            safeGet<UInt64>(index) - 1,
+            col_res->getChars(),
+            col_res->getOffsets(),
+            builder);
     else if (index.getType() == Field::Types::Int64)
         ArrayElementStringImpl::vectorConst<true>(
-                col_nested->getChars(),
-                col_array->getOffsets(),
-                col_nested->getOffsets(),
-                -safeGet<Int64>(index) - 1,
-                col_res->getChars(),
-                col_res->getOffsets(),
-                builder);
+            col_nested->getChars(),
+            col_array->getOffsets(),
+            col_nested->getOffsets(),
+            -safeGet<Int64>(index) - 1,
+            col_res->getChars(),
+            col_res->getOffsets(),
+            builder);
     else
         throw Exception("Illegal type of array index", ErrorCodes::LOGICAL_ERROR);
 
     return true;
 }
 
-template<typename IndexType>
-bool FunctionArrayElement::executeString(Block &block, const ColumnNumbers &arguments, size_t result,
-                                         const PaddedPODArray<IndexType> &indices,
-                                         ArrayImpl::NullMapBuilder &builder)
+template <typename IndexType>
+bool FunctionArrayElement::executeString(Block & block, const ColumnNumbers & arguments, size_t result, const PaddedPODArray<IndexType> & indices,
+    ArrayImpl::NullMapBuilder & builder)
 {
-    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const ColumnString *col_nested = checkAndGetColumn<ColumnString>(&col_array->getData());
+    const ColumnString * col_nested = checkAndGetColumn<ColumnString>(&col_array->getData());
 
     if (!col_nested)
         return false;
@@ -849,67 +830,64 @@ bool FunctionArrayElement::executeString(Block &block, const ColumnNumbers &argu
     block.getByPosition(result).column = col_res;
 
     ArrayElementStringImpl::vector<IndexType>(
-            col_nested->getChars(),
-            col_array->getOffsets(),
-            col_nested->getOffsets(),
-            indices,
-            col_res->getChars(),
-            col_res->getOffsets(),
-            builder);
+        col_nested->getChars(),
+        col_array->getOffsets(),
+        col_nested->getOffsets(),
+        indices,
+        col_res->getChars(),
+        col_res->getOffsets(),
+        builder);
 
     return true;
 }
 
-bool FunctionArrayElement::executeGenericConst(Block &block, const ColumnNumbers &arguments, size_t result,
-                                               const Field &index,
-                                               ArrayImpl::NullMapBuilder &builder)
+bool FunctionArrayElement::executeGenericConst(Block & block, const ColumnNumbers & arguments, size_t result, const Field & index,
+    ArrayImpl::NullMapBuilder & builder)
 {
-    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const auto &col_nested = col_array->getData();
+    const auto & col_nested = col_array->getData();
     auto col_res = col_nested.cloneEmpty();
     block.getByPosition(result).column = col_res;
 
     if (index.getType() == Field::Types::UInt64)
         ArrayElementGenericImpl::vectorConst<false>(
-                col_nested, col_array->getOffsets(), safeGet<UInt64>(index) - 1, *col_res, builder);
+            col_nested, col_array->getOffsets(), safeGet<UInt64>(index) - 1, *col_res, builder);
     else if (index.getType() == Field::Types::Int64)
         ArrayElementGenericImpl::vectorConst<true>(
-                col_nested, col_array->getOffsets(), -safeGet<Int64>(index) - 1, *col_res, builder);
+            col_nested, col_array->getOffsets(), -safeGet<Int64>(index) - 1, *col_res, builder);
     else
         throw Exception("Illegal type of array index", ErrorCodes::LOGICAL_ERROR);
 
     return true;
 }
 
-template<typename IndexType>
-bool FunctionArrayElement::executeGeneric(Block &block, const ColumnNumbers &arguments, size_t result,
-                                          const PaddedPODArray<IndexType> &indices,
-                                          ArrayImpl::NullMapBuilder &builder)
+template <typename IndexType>
+bool FunctionArrayElement::executeGeneric(Block & block, const ColumnNumbers & arguments, size_t result, const PaddedPODArray<IndexType> & indices,
+    ArrayImpl::NullMapBuilder & builder)
 {
-    const ColumnArray *col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray * col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    const auto &col_nested = col_array->getData();
+    const auto & col_nested = col_array->getData();
     auto col_res = col_nested.cloneEmpty();
     block.getByPosition(result).column = col_res;
 
     ArrayElementGenericImpl::vector<IndexType>(
-            col_nested, col_array->getOffsets(), indices, *col_res, builder);
+        col_nested, col_array->getOffsets(), indices, *col_res, builder);
 
     return true;
 }
 
-bool
-FunctionArrayElement::executeConstConst(Block &block, const ColumnNumbers &arguments, size_t result, const Field &index,
-                                        ArrayImpl::NullMapBuilder &builder)
+bool FunctionArrayElement::executeConstConst(Block & block, const ColumnNumbers & arguments, size_t result, const Field & index,
+    ArrayImpl::NullMapBuilder & builder)
 {
-    const ColumnConst *col_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnConst * col_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
@@ -933,8 +911,8 @@ FunctionArrayElement::executeConstConst(Block &block, const ColumnNumbers &argum
         value = block.getByPosition(result).type->getDefault();
 
     block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(
-            block.rows(),
-            value);
+        block.rows(),
+        value);
 
     if (builder)
         builder.update(real_index);
@@ -942,12 +920,11 @@ FunctionArrayElement::executeConstConst(Block &block, const ColumnNumbers &argum
     return true;
 }
 
-template<typename IndexType>
-bool FunctionArrayElement::executeConst(Block &block, const ColumnNumbers &arguments, size_t result,
-                                        const PaddedPODArray<IndexType> &indices,
-                                        ArrayImpl::NullMapBuilder &builder)
+template <typename IndexType>
+bool FunctionArrayElement::executeConst(Block & block, const ColumnNumbers & arguments, size_t result, const PaddedPODArray<IndexType> & indices,
+    ArrayImpl::NullMapBuilder & builder)
 {
-    const ColumnConst *col_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnConst * col_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
@@ -985,52 +962,52 @@ bool FunctionArrayElement::executeConst(Block &block, const ColumnNumbers &argum
     return true;
 }
 
-template<typename IndexType>
-bool FunctionArrayElement::executeArgument(Block &block, const ColumnNumbers &arguments, size_t result,
-                                           ArrayImpl::NullMapBuilder &builder)
+template <typename IndexType>
+bool FunctionArrayElement::executeArgument(Block & block, const ColumnNumbers & arguments, size_t result,
+    ArrayImpl::NullMapBuilder & builder)
 {
     auto index = checkAndGetColumn<ColumnVector<IndexType>>(block.getByPosition(arguments[1]).column.get());
 
     if (!index)
         return false;
 
-    const auto &index_data = index->getData();
+    const auto & index_data = index->getData();
 
     if (builder)
         builder.initSink(index_data.size());
 
-    if (!(executeNumber<IndexType, UInt8>(block, arguments, result, index_data, builder)
-          || executeNumber<IndexType, UInt16>(block, arguments, result, index_data, builder)
-          || executeNumber<IndexType, UInt32>(block, arguments, result, index_data, builder)
-          || executeNumber<IndexType, UInt64>(block, arguments, result, index_data, builder)
-          || executeNumber<IndexType, Int8>(block, arguments, result, index_data, builder)
-          || executeNumber<IndexType, Int16>(block, arguments, result, index_data, builder)
-          || executeNumber<IndexType, Int32>(block, arguments, result, index_data, builder)
-          || executeNumber<IndexType, Int64>(block, arguments, result, index_data, builder)
-          || executeNumber<IndexType, Float32>(block, arguments, result, index_data, builder)
-          || executeNumber<IndexType, Float64>(block, arguments, result, index_data, builder)
-          || executeConst<IndexType>(block, arguments, result, index_data, builder)
-          || executeString<IndexType>(block, arguments, result, index_data, builder)
-          || executeGeneric<IndexType>(block, arguments, result, index_data, builder)))
-        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                        + " of first argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
+    if (!(    executeNumber<IndexType, UInt8>        (block, arguments, result, index_data, builder)
+        ||    executeNumber<IndexType, UInt16>    (block, arguments, result, index_data, builder)
+        ||    executeNumber<IndexType, UInt32>    (block, arguments, result, index_data, builder)
+        ||    executeNumber<IndexType, UInt64>    (block, arguments, result, index_data, builder)
+        ||    executeNumber<IndexType, Int8>        (block, arguments, result, index_data, builder)
+        ||    executeNumber<IndexType, Int16>        (block, arguments, result, index_data, builder)
+        ||    executeNumber<IndexType, Int32>        (block, arguments, result, index_data, builder)
+        ||    executeNumber<IndexType, Int64>        (block, arguments, result, index_data, builder)
+        ||    executeNumber<IndexType, Float32>    (block, arguments, result, index_data, builder)
+        ||    executeNumber<IndexType, Float64>    (block, arguments, result, index_data, builder)
+        ||    executeConst <IndexType>            (block, arguments, result, index_data, builder)
+        ||    executeString<IndexType>            (block, arguments, result, index_data, builder)
+        ||    executeGeneric<IndexType>            (block, arguments, result, index_data, builder)))
+    throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
+                + " of first argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
 
     return true;
 }
 
-bool FunctionArrayElement::executeTuple(Block &block, const ColumnNumbers &arguments, size_t result)
+bool FunctionArrayElement::executeTuple(Block & block, const ColumnNumbers & arguments, size_t result)
 {
-    ColumnArray *col_array = typeid_cast<ColumnArray *>(block.getByPosition(arguments[0]).column.get());
+    ColumnArray * col_array = typeid_cast<ColumnArray *>(block.getByPosition(arguments[0]).column.get());
 
     if (!col_array)
         return false;
 
-    ColumnTuple *col_nested = typeid_cast<ColumnTuple *>(&col_array->getData());
+    ColumnTuple * col_nested = typeid_cast<ColumnTuple *>(&col_array->getData());
 
     if (!col_nested)
         return false;
 
-    Block &tuple_block = col_nested->getData();
+    Block & tuple_block = col_nested->getData();
     size_t tuple_size = tuple_block.columns();
 
     /** We will calculate the function for the tuple of the internals of the array.
@@ -1053,9 +1030,9 @@ bool FunctionArrayElement::executeTuple(Block &block, const ColumnNumbers &argum
     {
         ColumnWithTypeAndName array_of_tuple_section;
         array_of_tuple_section.column = std::make_shared<ColumnArray>(
-                tuple_block.getByPosition(i).column, col_array->getOffsetsColumn());
+            tuple_block.getByPosition(i).column, col_array->getOffsetsColumn());
         array_of_tuple_section.type = std::make_shared<DataTypeArray>(
-                tuple_block.getByPosition(i).type);
+            tuple_block.getByPosition(i).type);
         block_of_temporary_results.insert(array_of_tuple_section);
 
         ColumnWithTypeAndName array_elements_of_tuple_section;
@@ -1077,28 +1054,26 @@ String FunctionArrayElement::getName() const
     return name;
 }
 
-DataTypePtr FunctionArrayElement::getReturnTypeImpl(const DataTypes &arguments) const
+DataTypePtr FunctionArrayElement::getReturnTypeImpl(const DataTypes & arguments) const
 {
-    const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
+    const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
     if (!array_type)
-        throw Exception("First argument for function " + getName() + " must be array.",
-                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+        throw Exception("First argument for function " + getName() + " must be array.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     if (!arguments[1]->isNumeric()
         || (!startsWith(arguments[1]->getName(), "UInt") && !startsWith(arguments[1]->getName(), "Int")))
-        throw Exception("Second argument for function " + getName() + " must have UInt or Int type.",
-                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+        throw Exception("Second argument for function " + getName() + " must have UInt or Int type.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     return array_type->getNestedType();
 }
 
-void FunctionArrayElement::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
+void FunctionArrayElement::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
     /// Check nullability.
     bool is_nullable;
 
-    const ColumnArray *col_array = nullptr;
-    const ColumnConst *col_const_array = nullptr;
+    const ColumnArray * col_array = nullptr;
+    const ColumnConst * col_const_array = nullptr;
 
     col_array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
     if (col_array)
@@ -1109,12 +1084,11 @@ void FunctionArrayElement::executeImpl(Block &block, const ColumnNumbers &argume
         if (col_const_array)
         {
             Array arr = col_const_array->getValue<Array>();
-            is_nullable = std::any_of(arr.begin(), arr.end(), [](const Field &f)
-            { return f.isNull(); });
+            is_nullable = std::any_of(arr.begin(), arr.end(), [](const Field & f){ return f.isNull(); });
         }
         else
             throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                            + " of first argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
+            + " of first argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
     }
 
     if (!is_nullable)
@@ -1128,32 +1102,30 @@ void FunctionArrayElement::executeImpl(Block &block, const ColumnNumbers &argume
         ArrayImpl::NullMapBuilder builder;
         Block source_block;
 
-        const auto &input_type = static_cast<const DataTypeNullable &>(*block.getByPosition(
-                arguments[0]).type).getNestedType();
-        const auto &tmp_ret_type = static_cast<const DataTypeNullable &>(*block.getByPosition(
-                result).type).getNestedType();
+        const auto & input_type = static_cast<const DataTypeNullable &>(*block.getByPosition(arguments[0]).type).getNestedType();
+        const auto & tmp_ret_type = static_cast<const DataTypeNullable &>(*block.getByPosition(result).type).getNestedType();
 
         Array const_array;
         if (col_array)
         {
-            const auto &nullable_col = static_cast<const ColumnNullable &>(col_array->getData());
-            const auto &nested_col = nullable_col.getNestedColumn();
+            const auto & nullable_col = static_cast<const ColumnNullable &>(col_array->getData());
+            const auto & nested_col = nullable_col.getNestedColumn();
 
             /// Put nested_col inside a ColumnArray.
             source_block =
-                    {
-                            {
-                                    std::make_shared<ColumnArray>(nested_col, col_array->getOffsetsColumn()),
-                                    std::make_shared<DataTypeArray>(input_type),
-                                    ""
-                            },
-                            block.getByPosition(arguments[1]),
-                            {
-                                    nullptr,
-                                    tmp_ret_type,
-                                    ""
-                            }
-                    };
+            {
+                {
+                    std::make_shared<ColumnArray>(nested_col, col_array->getOffsetsColumn()),
+                    std::make_shared<DataTypeArray>(input_type),
+                    ""
+                },
+                block.getByPosition(arguments[1]),
+                {
+                    nullptr,
+                    tmp_ret_type,
+                    ""
+                }
+            };
 
             builder.initSource(nullable_col);
         }
@@ -1161,15 +1133,15 @@ void FunctionArrayElement::executeImpl(Block &block, const ColumnNumbers &argume
         {
             /// Almost a copy of block.
             source_block =
-                    {
-                            block.getByPosition(arguments[0]),
-                            block.getByPosition(arguments[1]),
-                            {
-                                    nullptr,
-                                    tmp_ret_type,
-                                    ""
-                            }
-                    };
+            {
+                block.getByPosition(arguments[0]),
+                block.getByPosition(arguments[1]),
+                {
+                    nullptr,
+                    tmp_ret_type,
+                    ""
+                }
+            };
 
             const_array = col_const_array->getValue<Array>();
             builder.initSource(const_array);
@@ -1178,30 +1150,30 @@ void FunctionArrayElement::executeImpl(Block &block, const ColumnNumbers &argume
         perform(source_block, {0, 1}, 2, builder);
 
         /// Store the result.
-        const ColumnWithTypeAndName &source_col = source_block.getByPosition(2);
-        ColumnWithTypeAndName &dest_col = block.getByPosition(result);
+        const ColumnWithTypeAndName & source_col = source_block.getByPosition(2);
+        ColumnWithTypeAndName & dest_col = block.getByPosition(result);
         dest_col.column = std::make_shared<ColumnNullable>(source_col.column, builder.getNullMap());
     }
 }
 
-void FunctionArrayElement::perform(Block &block, const ColumnNumbers &arguments, size_t result,
-                                   ArrayImpl::NullMapBuilder &builder)
+void FunctionArrayElement::perform(Block & block, const ColumnNumbers & arguments, size_t result,
+    ArrayImpl::NullMapBuilder & builder)
 {
     if (executeTuple(block, arguments, result))
     {
     }
     else if (!block.getByPosition(arguments[1]).column->isConst())
     {
-        if (!(executeArgument<UInt8>(block, arguments, result, builder)
-              || executeArgument<UInt16>(block, arguments, result, builder)
-              || executeArgument<UInt32>(block, arguments, result, builder)
-              || executeArgument<UInt64>(block, arguments, result, builder)
-              || executeArgument<Int8>(block, arguments, result, builder)
-              || executeArgument<Int16>(block, arguments, result, builder)
-              || executeArgument<Int32>(block, arguments, result, builder)
-              || executeArgument<Int64>(block, arguments, result, builder)))
-            throw Exception("Second argument for function " + getName() + " must must have UInt or Int type.",
-                            ErrorCodes::ILLEGAL_COLUMN);
+        if (!(    executeArgument<UInt8>   (block, arguments, result, builder)
+            ||    executeArgument<UInt16>  (block, arguments, result, builder)
+            ||    executeArgument<UInt32>  (block, arguments, result, builder)
+            ||    executeArgument<UInt64>  (block, arguments, result, builder)
+            ||    executeArgument<Int8>    (block, arguments, result, builder)
+            ||    executeArgument<Int16>   (block, arguments, result, builder)
+            ||    executeArgument<Int32>   (block, arguments, result, builder)
+            ||    executeArgument<Int64>   (block, arguments, result, builder)))
+        throw Exception("Second argument for function " + getName() + " must must have UInt or Int type.",
+                        ErrorCodes::ILLEGAL_COLUMN);
     }
     else
     {
@@ -1213,28 +1185,28 @@ void FunctionArrayElement::perform(Block &block, const ColumnNumbers &arguments,
         if (index == UInt64(0))
             throw Exception("Array indices is 1-based", ErrorCodes::ZERO_ARRAY_OR_TUPLE_INDEX);
 
-        if (!(executeNumberConst<UInt8>(block, arguments, result, index, builder)
-              || executeNumberConst<UInt16>(block, arguments, result, index, builder)
-              || executeNumberConst<UInt32>(block, arguments, result, index, builder)
-              || executeNumberConst<UInt64>(block, arguments, result, index, builder)
-              || executeNumberConst<Int8>(block, arguments, result, index, builder)
-              || executeNumberConst<Int16>(block, arguments, result, index, builder)
-              || executeNumberConst<Int32>(block, arguments, result, index, builder)
-              || executeNumberConst<Int64>(block, arguments, result, index, builder)
-              || executeNumberConst<Float32>(block, arguments, result, index, builder)
-              || executeNumberConst<Float64>(block, arguments, result, index, builder)
-              || executeConstConst(block, arguments, result, index, builder)
-              || executeStringConst(block, arguments, result, index, builder)
-              || executeGenericConst(block, arguments, result, index, builder)))
-            throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                            + " of first argument of function " + getName(),
-                            ErrorCodes::ILLEGAL_COLUMN);
+        if (!(    executeNumberConst<UInt8>   (block, arguments, result, index, builder)
+            ||    executeNumberConst<UInt16>  (block, arguments, result, index, builder)
+            ||    executeNumberConst<UInt32>  (block, arguments, result, index, builder)
+            ||    executeNumberConst<UInt64>  (block, arguments, result, index, builder)
+            ||    executeNumberConst<Int8>    (block, arguments, result, index, builder)
+            ||    executeNumberConst<Int16>   (block, arguments, result, index, builder)
+            ||    executeNumberConst<Int32>   (block, arguments, result, index, builder)
+            ||    executeNumberConst<Int64>   (block, arguments, result, index, builder)
+            ||    executeNumberConst<Float32> (block, arguments, result, index, builder)
+            ||    executeNumberConst<Float64> (block, arguments, result, index, builder)
+            ||    executeConstConst           (block, arguments, result, index, builder)
+            ||    executeStringConst          (block, arguments, result, index, builder)
+            ||    executeGenericConst         (block, arguments, result, index, builder)))
+        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
+            + " of first argument of function " + getName(),
+            ErrorCodes::ILLEGAL_COLUMN);
     }
 }
 
 /// Implementation of FunctionArrayEnumerate.
 
-FunctionPtr FunctionArrayEnumerate::create(const Context &context)
+FunctionPtr FunctionArrayEnumerate::create(const Context & context)
 {
     return std::make_shared<FunctionArrayEnumerate>();
 }
@@ -1244,27 +1216,27 @@ String FunctionArrayEnumerate::getName() const
     return name;
 }
 
-DataTypePtr FunctionArrayEnumerate::getReturnTypeImpl(const DataTypes &arguments) const
+DataTypePtr FunctionArrayEnumerate::getReturnTypeImpl(const DataTypes & arguments) const
 {
-    const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
+    const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
     if (!array_type)
         throw Exception("First argument for function " + getName() + " must be an array but it has type "
-                        + arguments[0]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+            + arguments[0]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     return std::make_shared<DataTypeArray>(std::make_shared<DataTypeUInt32>());
 }
 
-void FunctionArrayEnumerate::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
+void FunctionArrayEnumerate::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
-    if (const ColumnArray *array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get()))
+    if (const ColumnArray * array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get()))
     {
-        const ColumnArray::Offsets_t &offsets = array->getOffsets();
+        const ColumnArray::Offsets_t & offsets = array->getOffsets();
 
         auto res_nested = std::make_shared<ColumnUInt32>();
         auto res_array = std::make_shared<ColumnArray>(res_nested, array->getOffsetsColumn());
         block.getByPosition(result).column = res_array;
 
-        ColumnUInt32::Container_t &res_values = res_nested->getData();
+        ColumnUInt32::Container_t & res_values = res_nested->getData();
         res_values.resize(array->getData().size());
         size_t prev_off = 0;
         for (size_t i = 0; i < offsets.size(); ++i)
@@ -1277,8 +1249,7 @@ void FunctionArrayEnumerate::executeImpl(Block &block, const ColumnNumbers &argu
             prev_off = off;
         }
     }
-    else if (const ColumnConst *array = checkAndGetColumnConst<ColumnArray>(
-            block.getByPosition(arguments[0]).column.get()))
+    else if (const ColumnConst * array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get()))
     {
         Array values = array->getValue<Array>();
 
@@ -1288,53 +1259,50 @@ void FunctionArrayEnumerate::executeImpl(Block &block, const ColumnNumbers &argu
             res_values[i] = i + 1;
         }
 
-        block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(array->size(),
-                                                                                                 res_values);
+        block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(array->size(), res_values);
     }
     else
     {
         throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                        + " of first argument of function " + getName(),
-                        ErrorCodes::ILLEGAL_COLUMN);
+                + " of first argument of function " + getName(),
+            ErrorCodes::ILLEGAL_COLUMN);
     }
 }
 
 /// Implementation of FunctionArrayUniq.
 
-FunctionPtr FunctionArrayUniq::create(const Context &context)
-{ return std::make_shared<FunctionArrayUniq>(); }
+FunctionPtr FunctionArrayUniq::create(const Context & context) { return std::make_shared<FunctionArrayUniq>(); }
 
 String FunctionArrayUniq::getName() const
 {
     return name;
 }
 
-DataTypePtr FunctionArrayUniq::getReturnTypeImpl(const DataTypes &arguments) const
+DataTypePtr FunctionArrayUniq::getReturnTypeImpl(const DataTypes & arguments) const
 {
     if (arguments.size() == 0)
         throw Exception("Number of arguments for function " + getName() + " doesn't match: passed "
-                        + toString(arguments.size()) + ", should be at least 1.",
-                        ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+            + toString(arguments.size()) + ", should be at least 1.",
+            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
     for (size_t i = 0; i < arguments.size(); ++i)
     {
-        const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[i].get());
+        const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[i].get());
         if (!array_type)
             throw Exception("All arguments for function " + getName() + " must be arrays but argument " +
-                            toString(i + 1) + " has type " + arguments[i]->getName() + ".",
-                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                toString(i + 1) + " has type " + arguments[i]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
     }
 
     return std::make_shared<DataTypeUInt32>();
 }
 
-void FunctionArrayUniq::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
+void FunctionArrayUniq::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
     if (arguments.size() == 1 && executeConst(block, arguments, result))
         return;
 
     Columns array_columns(arguments.size());
-    const ColumnArray::Offsets_t *offsets = nullptr;
+    const ColumnArray::Offsets_t * offsets = nullptr;
     ConstColumnPlainPtrs data_columns(arguments.size());
     ConstColumnPlainPtrs original_data_columns(arguments.size());
     ConstColumnPlainPtrs null_maps(arguments.size());
@@ -1344,28 +1312,27 @@ void FunctionArrayUniq::executeImpl(Block &block, const ColumnNumbers &arguments
     for (size_t i = 0; i < arguments.size(); ++i)
     {
         ColumnPtr array_ptr = block.getByPosition(arguments[i]).column;
-        const ColumnArray *array = checkAndGetColumn<ColumnArray>(array_ptr.get());
+        const ColumnArray * array = checkAndGetColumn<ColumnArray>(array_ptr.get());
         if (!array)
         {
-            const ColumnConst *const_array = checkAndGetColumnConst<ColumnArray>(
-                    block.getByPosition(arguments[i]).column.get());
+            const ColumnConst * const_array = checkAndGetColumnConst<ColumnArray>(
+                block.getByPosition(arguments[i]).column.get());
             if (!const_array)
                 throw Exception("Illegal column " + block.getByPosition(arguments[i]).column->getName()
-                                + " of " + toString(i + 1) + getOrdinalSuffix(i + 1) + " argument of function " +
-                                getName(),
-                                ErrorCodes::ILLEGAL_COLUMN);
+                    + " of " + toString(i + 1) + getOrdinalSuffix(i + 1) + " argument of function " + getName(),
+                    ErrorCodes::ILLEGAL_COLUMN);
             array_ptr = const_array->convertToFullColumn();
             array = static_cast<const ColumnArray *>(array_ptr.get());
         }
 
         array_columns[i] = array_ptr;
 
-        const ColumnArray::Offsets_t &offsets_i = array->getOffsets();
+        const ColumnArray::Offsets_t & offsets_i = array->getOffsets();
         if (i == 0)
             offsets = &offsets_i;
         else if (offsets_i != *offsets)
             throw Exception("Lengths of all arrays passsed to " + getName() + " must be equal.",
-                            ErrorCodes::SIZES_OF_ARRAYS_DOESNT_MATCH);
+                ErrorCodes::SIZES_OF_ARRAYS_DOESNT_MATCH);
 
         data_columns[i] = &array->getData();
         original_data_columns[i] = data_columns[i];
@@ -1373,7 +1340,7 @@ void FunctionArrayUniq::executeImpl(Block &block, const ColumnNumbers &arguments
         if (data_columns[i]->isNullable())
         {
             has_nullable_columns = true;
-            const auto &nullable_col = static_cast<const ColumnNullable &>(*data_columns[i]);
+            const auto & nullable_col = static_cast<const ColumnNullable &>(*data_columns[i]);
             data_columns[i] = nullable_col.getNestedColumn().get();
             null_maps[i] = nullable_col.getNullMapColumn().get();
         }
@@ -1381,30 +1348,30 @@ void FunctionArrayUniq::executeImpl(Block &block, const ColumnNumbers &arguments
             null_maps[i] = nullptr;
     }
 
-    const ColumnArray *first_array = static_cast<const ColumnArray *>(array_columns[0].get());
-    const IColumn *first_null_map = null_maps[0];
+    const ColumnArray * first_array = static_cast<const ColumnArray *>(array_columns[0].get());
+    const IColumn * first_null_map = null_maps[0];
     auto res = std::make_shared<ColumnUInt32>();
     block.getByPosition(result).column = res;
 
-    ColumnUInt32::Container_t &res_values = res->getData();
+    ColumnUInt32::Container_t & res_values = res->getData();
     res_values.resize(offsets->size());
 
     if (arguments.size() == 1)
     {
-        if (!(executeNumber<UInt8>(first_array, first_null_map, res_values)
-              || executeNumber<UInt16>(first_array, first_null_map, res_values)
-              || executeNumber<UInt32>(first_array, first_null_map, res_values)
-              || executeNumber<UInt64>(first_array, first_null_map, res_values)
-              || executeNumber<Int8>(first_array, first_null_map, res_values)
-              || executeNumber<Int16>(first_array, first_null_map, res_values)
-              || executeNumber<Int32>(first_array, first_null_map, res_values)
-              || executeNumber<Int64>(first_array, first_null_map, res_values)
-              || executeNumber<Float32>(first_array, first_null_map, res_values)
-              || executeNumber<Float64>(first_array, first_null_map, res_values)
-              || executeString(first_array, first_null_map, res_values)))
+        if (!(    executeNumber<UInt8>    (first_array, first_null_map, res_values)
+            ||    executeNumber<UInt16>    (first_array, first_null_map, res_values)
+            ||    executeNumber<UInt32>    (first_array, first_null_map, res_values)
+            ||    executeNumber<UInt64>    (first_array, first_null_map, res_values)
+            ||    executeNumber<Int8>        (first_array, first_null_map, res_values)
+            ||    executeNumber<Int16>    (first_array, first_null_map, res_values)
+            ||    executeNumber<Int32>    (first_array, first_null_map, res_values)
+            ||    executeNumber<Int64>    (first_array, first_null_map, res_values)
+            ||    executeNumber<Float32>    (first_array, first_null_map, res_values)
+            ||    executeNumber<Float64>    (first_array, first_null_map, res_values)
+            ||    executeString            (first_array, first_null_map, res_values)))
             throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                            + " of first argument of function " + getName(),
-                            ErrorCodes::ILLEGAL_COLUMN);
+                    + " of first argument of function " + getName(),
+                ErrorCodes::ILLEGAL_COLUMN);
     }
     else
     {
@@ -1413,31 +1380,30 @@ void FunctionArrayUniq::executeImpl(Block &block, const ColumnNumbers &arguments
     }
 }
 
-template<typename T>
-bool FunctionArrayUniq::executeNumber(const ColumnArray *array, const IColumn *null_map,
-                                      ColumnUInt32::Container_t &res_values)
+template <typename T>
+bool FunctionArrayUniq::executeNumber(const ColumnArray * array, const IColumn * null_map, ColumnUInt32::Container_t & res_values)
 {
-    const IColumn *inner_col;
+    const IColumn * inner_col;
 
-    const auto &array_data = array->getData();
+    const auto & array_data = array->getData();
     if (array_data.isNullable())
     {
-        const auto &nullable_col = static_cast<const ColumnNullable &>(array_data);
+        const auto & nullable_col = static_cast<const ColumnNullable &>(array_data);
         inner_col = nullable_col.getNestedColumn().get();
     }
     else
         inner_col = &array_data;
 
-    const ColumnVector<T> *nested = checkAndGetColumn<ColumnVector<T>>(inner_col);
+    const ColumnVector<T> * nested = checkAndGetColumn<ColumnVector<T>>(inner_col);
     if (!nested)
         return false;
-    const ColumnArray::Offsets_t &offsets = array->getOffsets();
-    const typename ColumnVector<T>::Container_t &values = nested->getData();
+    const ColumnArray::Offsets_t & offsets = array->getOffsets();
+    const typename ColumnVector<T>::Container_t & values = nested->getData();
 
     using Set = ClearableHashSet<T, DefaultHash<T>, HashTableGrower<INITIAL_SIZE_DEGREE>,
-            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(T)>>;
+        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(T)>>;
 
-    const PaddedPODArray<UInt8> *null_map_data = nullptr;
+    const PaddedPODArray<UInt8> * null_map_data = nullptr;
     if (null_map)
         null_map_data = &static_cast<const ColumnUInt8 *>(null_map)->getData();
 
@@ -1462,29 +1428,28 @@ bool FunctionArrayUniq::executeNumber(const ColumnArray *array, const IColumn *n
     return true;
 }
 
-bool FunctionArrayUniq::executeString(const ColumnArray *array, const IColumn *null_map,
-                                      ColumnUInt32::Container_t &res_values)
+bool FunctionArrayUniq::executeString(const ColumnArray * array, const IColumn * null_map, ColumnUInt32::Container_t & res_values)
 {
-    const IColumn *inner_col;
+    const IColumn * inner_col;
 
-    const auto &array_data = array->getData();
+    const auto & array_data = array->getData();
     if (array_data.isNullable())
     {
-        const auto &nullable_col = static_cast<const ColumnNullable &>(array_data);
+        const auto & nullable_col = static_cast<const ColumnNullable &>(array_data);
         inner_col = nullable_col.getNestedColumn().get();
     }
     else
         inner_col = &array_data;
 
-    const ColumnString *nested = checkAndGetColumn<ColumnString>(inner_col);
+    const ColumnString * nested = checkAndGetColumn<ColumnString>(inner_col);
     if (!nested)
         return false;
-    const ColumnArray::Offsets_t &offsets = array->getOffsets();
+    const ColumnArray::Offsets_t & offsets = array->getOffsets();
 
     using Set = ClearableHashSet<StringRef, StringRefHash, HashTableGrower<INITIAL_SIZE_DEGREE>,
-            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(StringRef)>>;
+        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(StringRef)>>;
 
-    const PaddedPODArray<UInt8> *null_map_data = nullptr;
+    const PaddedPODArray<UInt8> * null_map_data = nullptr;
     if (null_map)
         null_map_data = &static_cast<const ColumnUInt8 *>(null_map)->getData();
 
@@ -1509,9 +1474,9 @@ bool FunctionArrayUniq::executeString(const ColumnArray *array, const IColumn *n
     return true;
 }
 
-bool FunctionArrayUniq::executeConst(Block &block, const ColumnNumbers &arguments, size_t result)
+bool FunctionArrayUniq::executeConst(Block & block, const ColumnNumbers & arguments, size_t result)
 {
-    const ColumnConst *array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnConst * array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
     if (!array)
         return false;
     Array values = array->getValue<Array>();
@@ -1525,11 +1490,11 @@ bool FunctionArrayUniq::executeConst(Block &block, const ColumnNumbers &argument
 }
 
 bool FunctionArrayUniq::execute128bit(
-        const ColumnArray::Offsets_t &offsets,
-        const ConstColumnPlainPtrs &columns,
-        const ConstColumnPlainPtrs &null_maps,
-        ColumnUInt32::Container_t &res_values,
-        bool has_nullable_columns)
+    const ColumnArray::Offsets_t & offsets,
+    const ConstColumnPlainPtrs & columns,
+    const ConstColumnPlainPtrs & null_maps,
+    ColumnUInt32::Container_t & res_values,
+    bool has_nullable_columns)
 {
     size_t count = columns.size();
     size_t keys_bytes = 0;
@@ -1549,7 +1514,7 @@ bool FunctionArrayUniq::execute128bit(
         return false;
 
     using Set = ClearableHashSet<UInt128, UInt128HashCRC32, HashTableGrower<INITIAL_SIZE_DEGREE>,
-            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
+        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
 
     /// Suppose that, for a given row, each of the N columns has an array whose length is M.
     /// Denote arr_i each of these arrays (1 <= i <= N). Then the following is performed:
@@ -1580,7 +1545,7 @@ bool FunctionArrayUniq::execute128bit(
                 {
                     if (null_maps[i])
                     {
-                        const auto &null_map = static_cast<const ColumnUInt8 &>(*null_maps[i]).getData();
+                        const auto & null_map = static_cast<const ColumnUInt8 &>(*null_maps[i]).getData();
                         if (null_map[j] == 1)
                         {
                             size_t bucket = i / 8;
@@ -1603,14 +1568,14 @@ bool FunctionArrayUniq::execute128bit(
 }
 
 void FunctionArrayUniq::executeHashed(
-        const ColumnArray::Offsets_t &offsets,
-        const ConstColumnPlainPtrs &columns,
-        ColumnUInt32::Container_t &res_values)
+    const ColumnArray::Offsets_t & offsets,
+    const ConstColumnPlainPtrs & columns,
+    ColumnUInt32::Container_t & res_values)
 {
     size_t count = columns.size();
 
     using Set = ClearableHashSet<UInt128, UInt128TrivialHash, HashTableGrower<INITIAL_SIZE_DEGREE>,
-            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
+        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
 
     Set set;
     size_t prev_off = 0;
@@ -1628,7 +1593,7 @@ void FunctionArrayUniq::executeHashed(
 
 /// Implementation of FunctionArrayEnumerateUniq.
 
-FunctionPtr FunctionArrayEnumerateUniq::create(const Context &context)
+FunctionPtr FunctionArrayEnumerateUniq::create(const Context & context)
 {
     return std::make_shared<FunctionArrayEnumerateUniq>();
 }
@@ -1638,32 +1603,31 @@ String FunctionArrayEnumerateUniq::getName() const
     return name;
 }
 
-DataTypePtr FunctionArrayEnumerateUniq::getReturnTypeImpl(const DataTypes &arguments) const
+DataTypePtr FunctionArrayEnumerateUniq::getReturnTypeImpl(const DataTypes & arguments) const
 {
     if (arguments.size() == 0)
         throw Exception("Number of arguments for function " + getName() + " doesn't match: passed "
-                        + toString(arguments.size()) + ", should be at least 1.",
-                        ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+            + toString(arguments.size()) + ", should be at least 1.",
+            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
     for (size_t i = 0; i < arguments.size(); ++i)
     {
-        const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[i].get());
+        const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[i].get());
         if (!array_type)
             throw Exception("All arguments for function " + getName() + " must be arrays but argument " +
-                            toString(i + 1) + " has type " + arguments[i]->getName() + ".",
-                            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                toString(i + 1) + " has type " + arguments[i]->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
     }
 
     return std::make_shared<DataTypeArray>(std::make_shared<DataTypeUInt32>());
 }
 
-void FunctionArrayEnumerateUniq::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
+void FunctionArrayEnumerateUniq::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
     if (arguments.size() == 1 && executeConst(block, arguments, result))
         return;
 
     Columns array_columns(arguments.size());
-    const ColumnArray::Offsets_t *offsets = nullptr;
+    const ColumnArray::Offsets_t * offsets = nullptr;
     ConstColumnPlainPtrs data_columns(arguments.size());
     ConstColumnPlainPtrs original_data_columns(arguments.size());
     ConstColumnPlainPtrs null_maps(arguments.size());
@@ -1673,25 +1637,25 @@ void FunctionArrayEnumerateUniq::executeImpl(Block &block, const ColumnNumbers &
     for (size_t i = 0; i < arguments.size(); ++i)
     {
         ColumnPtr array_ptr = block.getByPosition(arguments[i]).column;
-        const ColumnArray *array = checkAndGetColumn<ColumnArray>(array_ptr.get());
+        const ColumnArray * array = checkAndGetColumn<ColumnArray>(array_ptr.get());
         if (!array)
         {
-            const ColumnConst *const_array = checkAndGetColumnConst<ColumnArray>(
-                    block.getByPosition(arguments[i]).column.get());
+            const ColumnConst * const_array = checkAndGetColumnConst<ColumnArray>(
+                block.getByPosition(arguments[i]).column.get());
             if (!const_array)
                 throw Exception("Illegal column " + block.getByPosition(arguments[i]).column->getName()
-                                + " of " + toString(i + 1) + "-th argument of function " + getName(),
-                                ErrorCodes::ILLEGAL_COLUMN);
+                    + " of " + toString(i + 1) + "-th argument of function " + getName(),
+                    ErrorCodes::ILLEGAL_COLUMN);
             array_ptr = const_array->convertToFullColumn();
             array = checkAndGetColumn<ColumnArray>(array_ptr.get());
         }
         array_columns[i] = array_ptr;
-        const ColumnArray::Offsets_t &offsets_i = array->getOffsets();
+        const ColumnArray::Offsets_t & offsets_i = array->getOffsets();
         if (i == 0)
             offsets = &offsets_i;
         else if (offsets_i != *offsets)
             throw Exception("Lengths of all arrays passsed to " + getName() + " must be equal.",
-                            ErrorCodes::SIZES_OF_ARRAYS_DOESNT_MATCH);
+                ErrorCodes::SIZES_OF_ARRAYS_DOESNT_MATCH);
 
         data_columns[i] = &array->getData();
         original_data_columns[i] = data_columns[i];
@@ -1699,7 +1663,7 @@ void FunctionArrayEnumerateUniq::executeImpl(Block &block, const ColumnNumbers &
         if (data_columns[i]->isNullable())
         {
             has_nullable_columns = true;
-            const auto &nullable_col = static_cast<const ColumnNullable &>(*data_columns[i]);
+            const auto & nullable_col = static_cast<const ColumnNullable &>(*data_columns[i]);
             data_columns[i] = nullable_col.getNestedColumn().get();
             null_maps[i] = nullable_col.getNullMapColumn().get();
         }
@@ -1707,32 +1671,32 @@ void FunctionArrayEnumerateUniq::executeImpl(Block &block, const ColumnNumbers &
             null_maps[i] = nullptr;
     }
 
-    const ColumnArray *first_array = checkAndGetColumn<ColumnArray>(array_columns[0].get());
-    const IColumn *first_null_map = null_maps[0];
+    const ColumnArray * first_array = checkAndGetColumn<ColumnArray>(array_columns[0].get());
+    const IColumn * first_null_map = null_maps[0];
     auto res_nested = std::make_shared<ColumnUInt32>();
     auto res_array = std::make_shared<ColumnArray>(res_nested, first_array->getOffsetsColumn());
     block.getByPosition(result).column = res_array;
 
-    ColumnUInt32::Container_t &res_values = res_nested->getData();
+    ColumnUInt32::Container_t & res_values = res_nested->getData();
     if (!offsets->empty())
         res_values.resize(offsets->back());
 
     if (arguments.size() == 1)
     {
-        if (!(executeNumber<UInt8>(first_array, first_null_map, res_values)
-              || executeNumber<UInt16>(first_array, first_null_map, res_values)
-              || executeNumber<UInt32>(first_array, first_null_map, res_values)
-              || executeNumber<UInt64>(first_array, first_null_map, res_values)
-              || executeNumber<Int8>(first_array, first_null_map, res_values)
-              || executeNumber<Int16>(first_array, first_null_map, res_values)
-              || executeNumber<Int32>(first_array, first_null_map, res_values)
-              || executeNumber<Int64>(first_array, first_null_map, res_values)
-              || executeNumber<Float32>(first_array, first_null_map, res_values)
-              || executeNumber<Float64>(first_array, first_null_map, res_values)
-              || executeString(first_array, first_null_map, res_values)))
+        if (!(    executeNumber<UInt8>    (first_array, first_null_map, res_values)
+            ||    executeNumber<UInt16>    (first_array, first_null_map, res_values)
+            ||    executeNumber<UInt32>    (first_array, first_null_map, res_values)
+            ||    executeNumber<UInt64>    (first_array, first_null_map, res_values)
+            ||    executeNumber<Int8>        (first_array, first_null_map, res_values)
+            ||    executeNumber<Int16>    (first_array, first_null_map, res_values)
+            ||    executeNumber<Int32>    (first_array, first_null_map, res_values)
+            ||    executeNumber<Int64>    (first_array, first_null_map, res_values)
+            ||    executeNumber<Float32>    (first_array, first_null_map, res_values)
+            ||    executeNumber<Float64>    (first_array, first_null_map, res_values)
+            ||    executeString            (first_array, first_null_map, res_values)))
             throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                            + " of first argument of function " + getName(),
-                            ErrorCodes::ILLEGAL_COLUMN);
+                    + " of first argument of function " + getName(),
+                ErrorCodes::ILLEGAL_COLUMN);
     }
     else
     {
@@ -1742,31 +1706,30 @@ void FunctionArrayEnumerateUniq::executeImpl(Block &block, const ColumnNumbers &
 }
 
 
-template<typename T>
-bool FunctionArrayEnumerateUniq::executeNumber(const ColumnArray *array, const IColumn *null_map,
-                                               ColumnUInt32::Container_t &res_values)
+template <typename T>
+bool FunctionArrayEnumerateUniq::executeNumber(const ColumnArray * array, const IColumn * null_map, ColumnUInt32::Container_t & res_values)
 {
-    const IColumn *inner_col;
+    const IColumn * inner_col;
 
-    const auto &array_data = array->getData();
+    const auto & array_data = array->getData();
     if (array_data.isNullable())
     {
-        const auto &nullable_col = static_cast<const ColumnNullable &>(array_data);
+        const auto & nullable_col = static_cast<const ColumnNullable &>(array_data);
         inner_col = nullable_col.getNestedColumn().get();
     }
     else
         inner_col = &array_data;
 
-    const ColumnVector<T> *nested = checkAndGetColumn<ColumnVector<T>>(inner_col);
+    const ColumnVector<T> * nested = checkAndGetColumn<ColumnVector<T>>(inner_col);
     if (!nested)
         return false;
-    const ColumnArray::Offsets_t &offsets = array->getOffsets();
-    const typename ColumnVector<T>::Container_t &values = nested->getData();
+    const ColumnArray::Offsets_t & offsets = array->getOffsets();
+    const typename ColumnVector<T>::Container_t & values = nested->getData();
 
     using ValuesToIndices = ClearableHashMap<T, UInt32, DefaultHash<T>, HashTableGrower<INITIAL_SIZE_DEGREE>,
-            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(T)>>;
+        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(T)>>;
 
-    const PaddedPODArray<UInt8> *null_map_data = nullptr;
+    const PaddedPODArray<UInt8> * null_map_data = nullptr;
     if (null_map)
         null_map_data = &static_cast<const ColumnUInt8 *>(null_map)->getData();
 
@@ -1789,30 +1752,29 @@ bool FunctionArrayEnumerateUniq::executeNumber(const ColumnArray *array, const I
     return true;
 }
 
-bool FunctionArrayEnumerateUniq::executeString(const ColumnArray *array, const IColumn *null_map,
-                                               ColumnUInt32::Container_t &res_values)
+bool FunctionArrayEnumerateUniq::executeString(const ColumnArray * array, const IColumn * null_map, ColumnUInt32::Container_t & res_values)
 {
-    const IColumn *inner_col;
+    const IColumn * inner_col;
 
-    const auto &array_data = array->getData();
+    const auto & array_data = array->getData();
     if (array_data.isNullable())
     {
-        const auto &nullable_col = static_cast<const ColumnNullable &>(array_data);
+        const auto & nullable_col = static_cast<const ColumnNullable &>(array_data);
         inner_col = nullable_col.getNestedColumn().get();
     }
     else
         inner_col = &array_data;
 
-    const ColumnString *nested = checkAndGetColumn<ColumnString>(inner_col);
+    const ColumnString * nested = checkAndGetColumn<ColumnString>(inner_col);
     if (!nested)
         return false;
-    const ColumnArray::Offsets_t &offsets = array->getOffsets();
+    const ColumnArray::Offsets_t & offsets = array->getOffsets();
 
     size_t prev_off = 0;
     using ValuesToIndices = ClearableHashMap<StringRef, UInt32, StringRefHash, HashTableGrower<INITIAL_SIZE_DEGREE>,
-            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(StringRef)>>;
+        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(StringRef)>>;
 
-    const PaddedPODArray<UInt8> *null_map_data = nullptr;
+    const PaddedPODArray<UInt8> * null_map_data = nullptr;
     if (null_map)
         null_map_data = &static_cast<const ColumnUInt8 *>(null_map)->getData();
 
@@ -1834,9 +1796,9 @@ bool FunctionArrayEnumerateUniq::executeString(const ColumnArray *array, const I
     return true;
 }
 
-bool FunctionArrayEnumerateUniq::executeConst(Block &block, const ColumnNumbers &arguments, size_t result)
+bool FunctionArrayEnumerateUniq::executeConst(Block & block, const ColumnNumbers & arguments, size_t result)
 {
-    const ColumnConst *array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnConst * array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get());
     if (!array)
         return false;
     Array values = array->getValue<Array>();
@@ -1854,11 +1816,11 @@ bool FunctionArrayEnumerateUniq::executeConst(Block &block, const ColumnNumbers
 }
 
 bool FunctionArrayEnumerateUniq::execute128bit(
-        const ColumnArray::Offsets_t &offsets,
-        const ConstColumnPlainPtrs &columns,
-        const ConstColumnPlainPtrs &null_maps,
-        ColumnUInt32::Container_t &res_values,
-        bool has_nullable_columns)
+    const ColumnArray::Offsets_t & offsets,
+    const ConstColumnPlainPtrs & columns,
+    const ConstColumnPlainPtrs & null_maps,
+    ColumnUInt32::Container_t & res_values,
+    bool has_nullable_columns)
 {
     size_t count = columns.size();
     size_t keys_bytes = 0;
@@ -1878,7 +1840,7 @@ bool FunctionArrayEnumerateUniq::execute128bit(
         return false;
 
     using ValuesToIndices = ClearableHashMap<UInt128, UInt32, UInt128HashCRC32, HashTableGrower<INITIAL_SIZE_DEGREE>,
-            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
+        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
 
     ValuesToIndices indices;
     size_t prev_off = 0;
@@ -1896,7 +1858,7 @@ bool FunctionArrayEnumerateUniq::execute128bit(
                 {
                     if (null_maps[i])
                     {
-                        const auto &null_map = static_cast<const ColumnUInt8 &>(*null_maps[i]).getData();
+                        const auto & null_map = static_cast<const ColumnUInt8 &>(*null_maps[i]).getData();
                         if (null_map[j] == 1)
                         {
                             size_t bucket = i / 8;
@@ -1917,14 +1879,14 @@ bool FunctionArrayEnumerateUniq::execute128bit(
 }
 
 void FunctionArrayEnumerateUniq::executeHashed(
-        const ColumnArray::Offsets_t &offsets,
-        const ConstColumnPlainPtrs &columns,
-        ColumnUInt32::Container_t &res_values)
+    const ColumnArray::Offsets_t & offsets,
+    const ConstColumnPlainPtrs & columns,
+    ColumnUInt32::Container_t & res_values)
 {
     size_t count = columns.size();
 
     using ValuesToIndices = ClearableHashMap<UInt128, UInt32, UInt128TrivialHash, HashTableGrower<INITIAL_SIZE_DEGREE>,
-            HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
+        HashTableAllocatorWithStackMemory<(1ULL << INITIAL_SIZE_DEGREE) * sizeof(UInt128)>>;
 
     ValuesToIndices indices;
     size_t prev_off = 0;
@@ -1942,20 +1904,19 @@ void FunctionArrayEnumerateUniq::executeHashed(
 
 /// Implementation of FunctionEmptyArrayToSingle.
 
-FunctionPtr FunctionEmptyArrayToSingle::create(const Context &context)
-{ return std::make_shared<FunctionEmptyArrayToSingle>(); }
+FunctionPtr FunctionEmptyArrayToSingle::create(const Context & context) { return std::make_shared<FunctionEmptyArrayToSingle>(); }
 
 String FunctionEmptyArrayToSingle::getName() const
 {
     return name;
 }
 
-DataTypePtr FunctionEmptyArrayToSingle::getReturnTypeImpl(const DataTypes &arguments) const
+DataTypePtr FunctionEmptyArrayToSingle::getReturnTypeImpl(const DataTypes & arguments) const
 {
-    const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
+    const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
     if (!array_type)
         throw Exception("Argument for function " + getName() + " must be array.",
-                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     return arguments[0]->clone();
 }
@@ -1963,366 +1924,347 @@ DataTypePtr FunctionEmptyArrayToSingle::getReturnTypeImpl(const DataTypes &argum
 
 namespace
 {
-namespace FunctionEmptyArrayToSingleImpl
-{
-bool executeConst(Block &block, const ColumnNumbers &arguments, size_t result)
-{
-    if (const ColumnConst *const_array = checkAndGetColumnConst<ColumnArray>(
-            block.getByPosition(arguments[0]).column.get()))
+    namespace FunctionEmptyArrayToSingleImpl
     {
-        if (const_array->getValue<Array>().empty())
+        bool executeConst(Block & block, const ColumnNumbers & arguments, size_t result)
         {
-            auto nested_type = typeid_cast<const DataTypeArray &>(
-                    *block.getByPosition(arguments[0]).type).getNestedType();
-
-            block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(
-                    block.rows(),
-                    Array{nested_type->getDefault()});
-        }
-        else
-            block.getByPosition(result).column = block.getByPosition(arguments[0]).column;
-
-        return true;
-    }
-    else
-        return false;
-}
-
-template<typename T, bool nullable>
-bool executeNumber(
-        const IColumn &src_data, const ColumnArray::Offsets_t &src_offsets,
-        IColumn &res_data_col, ColumnArray::Offsets_t &res_offsets,
-        const NullMap *src_null_map,
-        NullMap *res_null_map)
-{
-    if (const ColumnVector<T> *src_data_concrete = checkAndGetColumn<ColumnVector<T>>(&src_data))
-    {
-        const PaddedPODArray<T> &src_data = src_data_concrete->getData();
-        PaddedPODArray<T> &res_data = static_cast<ColumnVector<T> &>(res_data_col).getData();
-
-        size_t size = src_offsets.size();
-        res_offsets.resize(size);
-        res_data.reserve(src_data.size());
-
-        if (nullable)
-            res_null_map->reserve(src_null_map->size());
-
-        ColumnArray::Offset_t src_prev_offset = 0;
-        ColumnArray::Offset_t res_prev_offset = 0;
-
-        for (size_t i = 0; i < size; ++i)
-        {
-            if (src_offsets[i] != src_prev_offset)
+            if (const ColumnConst * const_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get()))
             {
-                size_t size_to_write = src_offsets[i] - src_prev_offset;
-                res_data.resize(res_prev_offset + size_to_write);
-                memcpy(&res_data[res_prev_offset], &src_data[src_prev_offset], size_to_write * sizeof(T));
-
-                if (nullable)
+                if (const_array->getValue<Array>().empty())
                 {
-                    res_null_map->resize(res_prev_offset + size_to_write);
-                    memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
-                }
+                    auto nested_type = typeid_cast<const DataTypeArray &>(*block.getByPosition(arguments[0]).type).getNestedType();
 
-                res_prev_offset += size_to_write;
-                res_offsets[i] = res_prev_offset;
+                    block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(
+                        block.rows(),
+                        Array{nested_type->getDefault()});
+                }
+                else
+                    block.getByPosition(result).column = block.getByPosition(arguments[0]).column;
+
+                return true;
             }
             else
-            {
-                res_data.push_back(T());
-                ++res_prev_offset;
-                res_offsets[i] = res_prev_offset;
-
-                if (nullable)
-                    res_null_map->push_back(1); /// Push NULL.
-            }
-
-            src_prev_offset = src_offsets[i];
+                return false;
         }
 
-        return true;
-    }
-    else
-        return false;
-}
-
-
-template<bool nullable>
-bool executeFixedString(
-        const IColumn &src_data, const ColumnArray::Offsets_t &src_offsets,
-        IColumn &res_data_col, ColumnArray::Offsets_t &res_offsets,
-        const NullMap *src_null_map,
-        NullMap *res_null_map)
-{
-    if (const ColumnFixedString *src_data_concrete = checkAndGetColumn<ColumnFixedString>(&src_data))
-    {
-        const size_t n = src_data_concrete->getN();
-        const ColumnFixedString::Chars_t &src_data = src_data_concrete->getChars();
-
-        auto concrete_res_data = typeid_cast<ColumnFixedString *>(&res_data_col);
-        if (!concrete_res_data)
-            throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
-
-        ColumnFixedString::Chars_t &res_data = concrete_res_data->getChars();
-        size_t size = src_offsets.size();
-        res_offsets.resize(size);
-        res_data.reserve(src_data.size());
-
-        if (nullable)
-            res_null_map->reserve(src_null_map->size());
-
-        ColumnArray::Offset_t src_prev_offset = 0;
-        ColumnArray::Offset_t res_prev_offset = 0;
-
-        for (size_t i = 0; i < size; ++i)
+        template <typename T, bool nullable>
+        bool executeNumber(
+            const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
+            IColumn & res_data_col, ColumnArray::Offsets_t & res_offsets,
+            const NullMap * src_null_map,
+            NullMap * res_null_map)
         {
-            if (src_offsets[i] != src_prev_offset)
+            if (const ColumnVector<T> * src_data_concrete = checkAndGetColumn<ColumnVector<T>>(&src_data))
             {
-                size_t size_to_write = src_offsets[i] - src_prev_offset;
-                size_t prev_res_data_size = res_data.size();
-                res_data.resize(prev_res_data_size + size_to_write * n);
-                memcpy(&res_data[prev_res_data_size], &src_data[src_prev_offset * n], size_to_write * n);
+                const PaddedPODArray<T> & src_data = src_data_concrete->getData();
+                PaddedPODArray<T> & res_data = static_cast<ColumnVector<T> &>(res_data_col).getData();
+
+                size_t size = src_offsets.size();
+                res_offsets.resize(size);
+                res_data.reserve(src_data.size());
 
                 if (nullable)
+                    res_null_map->reserve(src_null_map->size());
+
+                ColumnArray::Offset_t src_prev_offset = 0;
+                ColumnArray::Offset_t res_prev_offset = 0;
+
+                for (size_t i = 0; i < size; ++i)
                 {
-                    res_null_map->resize(res_prev_offset + size_to_write);
-                    memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
+                    if (src_offsets[i] != src_prev_offset)
+                    {
+                        size_t size_to_write = src_offsets[i] - src_prev_offset;
+                        res_data.resize(res_prev_offset + size_to_write);
+                        memcpy(&res_data[res_prev_offset], &src_data[src_prev_offset], size_to_write * sizeof(T));
+
+                        if (nullable)
+                        {
+                            res_null_map->resize(res_prev_offset + size_to_write);
+                            memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
+                        }
+
+                        res_prev_offset += size_to_write;
+                        res_offsets[i] = res_prev_offset;
+                    }
+                    else
+                    {
+                        res_data.push_back(T());
+                        ++res_prev_offset;
+                        res_offsets[i] = res_prev_offset;
+
+                        if (nullable)
+                            res_null_map->push_back(1); /// Push NULL.
+                    }
+
+                    src_prev_offset = src_offsets[i];
                 }
 
-                res_prev_offset += size_to_write;
-                res_offsets[i] = res_prev_offset;
+                return true;
             }
             else
-            {
-                size_t prev_res_data_size = res_data.size();
-                res_data.resize(prev_res_data_size + n);
-                memset(&res_data[prev_res_data_size], 0, n);
-                ++res_prev_offset;
-                res_offsets[i] = res_prev_offset;
-
-                if (nullable)
-                    res_null_map->push_back(1);
-            }
-
-            src_prev_offset = src_offsets[i];
+                return false;
         }
 
-        return true;
-    }
-    else
-        return false;
-}
 
-
-template<bool nullable>
-bool executeString(
-        const IColumn &src_data, const ColumnArray::Offsets_t &src_array_offsets,
-        IColumn &res_data_col, ColumnArray::Offsets_t &res_array_offsets,
-        const NullMap *src_null_map,
-        NullMap *res_null_map)
-{
-    if (const ColumnString *src_data_concrete = checkAndGetColumn<ColumnString>(&src_data))
-    {
-        const ColumnString::Offsets_t &src_string_offsets = src_data_concrete->getOffsets();
-
-        auto concrete_res_string_offsets = typeid_cast<ColumnString *>(&res_data_col);
-        if (!concrete_res_string_offsets)
-            throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
-        ColumnString::Offsets_t &res_string_offsets = concrete_res_string_offsets->getOffsets();
-
-        const ColumnString::Chars_t &src_data = src_data_concrete->getChars();
-
-        auto concrete_res_data = typeid_cast<ColumnString *>(&res_data_col);
-        if (!concrete_res_data)
-            throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
-        ColumnString::Chars_t &res_data = concrete_res_data->getChars();
-
-        size_t size = src_array_offsets.size();
-        res_array_offsets.resize(size);
-        res_string_offsets.reserve(src_string_offsets.size());
-        res_data.reserve(src_data.size());
-
-        if (nullable)
-            res_null_map->reserve(src_null_map->size());
-
-        ColumnArray::Offset_t src_array_prev_offset = 0;
-        ColumnArray::Offset_t res_array_prev_offset = 0;
-
-        ColumnString::Offset_t src_string_prev_offset = 0;
-        ColumnString::Offset_t res_string_prev_offset = 0;
-
-        for (size_t i = 0; i < size; ++i)
+        template <bool nullable>
+        bool executeFixedString(
+            const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
+            IColumn & res_data_col, ColumnArray::Offsets_t & res_offsets,
+            const NullMap * src_null_map,
+            NullMap * res_null_map)
         {
-            if (src_array_offsets[i] != src_array_prev_offset)
+            if (const ColumnFixedString * src_data_concrete = checkAndGetColumn<ColumnFixedString>(&src_data))
             {
-                size_t array_size = src_array_offsets[i] - src_array_prev_offset;
+                const size_t n = src_data_concrete->getN();
+                const ColumnFixedString::Chars_t & src_data = src_data_concrete->getChars();
 
-                size_t bytes_to_copy = 0;
-                size_t from_string_prev_offset_local = src_string_prev_offset;
-                for (size_t j = 0; j < array_size; ++j)
-                {
-                    size_t string_size = src_string_offsets[src_array_prev_offset + j] - from_string_prev_offset_local;
+                auto concrete_res_data = typeid_cast<ColumnFixedString *>(&res_data_col);
+                if (!concrete_res_data)
+                    throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
 
-                    res_string_prev_offset += string_size;
-                    res_string_offsets.push_back(res_string_prev_offset);
-
-                    from_string_prev_offset_local += string_size;
-                    bytes_to_copy += string_size;
-                }
-
-                size_t res_data_old_size = res_data.size();
-                res_data.resize(res_data_old_size + bytes_to_copy);
-                memcpy(&res_data[res_data_old_size], &src_data[src_string_prev_offset], bytes_to_copy);
+                ColumnFixedString::Chars_t & res_data = concrete_res_data->getChars();
+                size_t size = src_offsets.size();
+                res_offsets.resize(size);
+                res_data.reserve(src_data.size());
 
                 if (nullable)
+                    res_null_map->reserve(src_null_map->size());
+
+                ColumnArray::Offset_t src_prev_offset = 0;
+                ColumnArray::Offset_t res_prev_offset = 0;
+
+                for (size_t i = 0; i < size; ++i)
                 {
-                    res_null_map->resize(res_array_prev_offset + array_size);
-                    memcpy(&(*res_null_map)[res_array_prev_offset], &(*src_null_map)[src_array_prev_offset],
-                           array_size);
+                    if (src_offsets[i] != src_prev_offset)
+                    {
+                        size_t size_to_write = src_offsets[i] - src_prev_offset;
+                        size_t prev_res_data_size = res_data.size();
+                        res_data.resize(prev_res_data_size + size_to_write * n);
+                        memcpy(&res_data[prev_res_data_size], &src_data[src_prev_offset * n], size_to_write * n);
+
+                        if (nullable)
+                        {
+                            res_null_map->resize(res_prev_offset + size_to_write);
+                            memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
+                        }
+
+                        res_prev_offset += size_to_write;
+                        res_offsets[i] = res_prev_offset;
+                    }
+                    else
+                    {
+                        size_t prev_res_data_size = res_data.size();
+                        res_data.resize(prev_res_data_size + n);
+                        memset(&res_data[prev_res_data_size], 0, n);
+                        ++res_prev_offset;
+                        res_offsets[i] = res_prev_offset;
+
+                        if (nullable)
+                            res_null_map->push_back(1);
+                    }
+
+                    src_prev_offset = src_offsets[i];
                 }
 
-                res_array_prev_offset += array_size;
-                res_array_offsets[i] = res_array_prev_offset;
+                return true;
             }
             else
-            {
-                res_data.push_back(0);  /// An empty string, including zero at the end.
-
-                if (nullable)
-                    res_null_map->push_back(1);
-
-                ++res_string_prev_offset;
-                res_string_offsets.push_back(res_string_prev_offset);
-
-                ++res_array_prev_offset;
-                res_array_offsets[i] = res_array_prev_offset;
-            }
-
-            src_array_prev_offset = src_array_offsets[i];
-
-            if (src_array_prev_offset)
-                src_string_prev_offset = src_string_offsets[src_array_prev_offset - 1];
+                return false;
         }
 
-        return true;
-    }
-    else
-        return false;
-}
 
-
-template<bool nullable>
-void executeGeneric(
-        const IColumn &src_data, const ColumnArray::Offsets_t &src_offsets,
-        IColumn &res_data, ColumnArray::Offsets_t &res_offsets,
-        const NullMap *src_null_map,
-        NullMap *res_null_map)
-{
-    size_t size = src_offsets.size();
-    res_offsets.resize(size);
-    res_data.reserve(src_data.size());
-
-    if (nullable)
-        res_null_map->reserve(src_null_map->size());
-
-    ColumnArray::Offset_t src_prev_offset = 0;
-    ColumnArray::Offset_t res_prev_offset = 0;
-
-    for (size_t i = 0; i < size; ++i)
-    {
-        if (src_offsets[i] != src_prev_offset)
+        template <bool nullable>
+        bool executeString(
+            const IColumn & src_data, const ColumnArray::Offsets_t & src_array_offsets,
+            IColumn & res_data_col, ColumnArray::Offsets_t & res_array_offsets,
+            const NullMap * src_null_map,
+            NullMap * res_null_map)
         {
-            size_t size_to_write = src_offsets[i] - src_prev_offset;
-            res_data.insertRangeFrom(src_data, src_prev_offset, size_to_write);
+            if (const ColumnString * src_data_concrete = checkAndGetColumn<ColumnString>(&src_data))
+            {
+                const ColumnString::Offsets_t & src_string_offsets = src_data_concrete->getOffsets();
+
+                auto concrete_res_string_offsets = typeid_cast<ColumnString *>(&res_data_col);
+                if (!concrete_res_string_offsets)
+                    throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
+                ColumnString::Offsets_t & res_string_offsets = concrete_res_string_offsets->getOffsets();
+
+                const ColumnString::Chars_t & src_data = src_data_concrete->getChars();
+
+                auto concrete_res_data = typeid_cast<ColumnString *>(&res_data_col);
+                if (!concrete_res_data)
+                    throw Exception{"Internal error", ErrorCodes::LOGICAL_ERROR};
+                ColumnString::Chars_t & res_data = concrete_res_data->getChars();
+
+                size_t size = src_array_offsets.size();
+                res_array_offsets.resize(size);
+                res_string_offsets.reserve(src_string_offsets.size());
+                res_data.reserve(src_data.size());
+
+                if (nullable)
+                    res_null_map->reserve(src_null_map->size());
+
+                ColumnArray::Offset_t src_array_prev_offset = 0;
+                ColumnArray::Offset_t res_array_prev_offset = 0;
+
+                ColumnString::Offset_t src_string_prev_offset = 0;
+                ColumnString::Offset_t res_string_prev_offset = 0;
+
+                for (size_t i = 0; i < size; ++i)
+                {
+                    if (src_array_offsets[i] != src_array_prev_offset)
+                    {
+                        size_t array_size = src_array_offsets[i] - src_array_prev_offset;
+
+                        size_t bytes_to_copy = 0;
+                        size_t from_string_prev_offset_local = src_string_prev_offset;
+                        for (size_t j = 0; j < array_size; ++j)
+                        {
+                            size_t string_size = src_string_offsets[src_array_prev_offset + j] - from_string_prev_offset_local;
+
+                            res_string_prev_offset += string_size;
+                            res_string_offsets.push_back(res_string_prev_offset);
+
+                            from_string_prev_offset_local += string_size;
+                            bytes_to_copy += string_size;
+                        }
+
+                        size_t res_data_old_size = res_data.size();
+                        res_data.resize(res_data_old_size + bytes_to_copy);
+                        memcpy(&res_data[res_data_old_size], &src_data[src_string_prev_offset], bytes_to_copy);
+
+                        if (nullable)
+                        {
+                            res_null_map->resize(res_array_prev_offset + array_size);
+                            memcpy(&(*res_null_map)[res_array_prev_offset], &(*src_null_map)[src_array_prev_offset], array_size);
+                        }
+
+                        res_array_prev_offset += array_size;
+                        res_array_offsets[i] = res_array_prev_offset;
+                    }
+                    else
+                    {
+                        res_data.push_back(0);  /// An empty string, including zero at the end.
+
+                        if (nullable)
+                            res_null_map->push_back(1);
+
+                        ++res_string_prev_offset;
+                        res_string_offsets.push_back(res_string_prev_offset);
+
+                        ++res_array_prev_offset;
+                        res_array_offsets[i] = res_array_prev_offset;
+                    }
+
+                    src_array_prev_offset = src_array_offsets[i];
+
+                    if (src_array_prev_offset)
+                        src_string_prev_offset = src_string_offsets[src_array_prev_offset - 1];
+                }
+
+                return true;
+            }
+            else
+                return false;
+        }
+
+
+        template <bool nullable>
+        void executeGeneric(
+            const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
+            IColumn & res_data, ColumnArray::Offsets_t & res_offsets,
+            const NullMap * src_null_map,
+            NullMap * res_null_map)
+        {
+            size_t size = src_offsets.size();
+            res_offsets.resize(size);
+            res_data.reserve(src_data.size());
 
             if (nullable)
+                res_null_map->reserve(src_null_map->size());
+
+            ColumnArray::Offset_t src_prev_offset = 0;
+            ColumnArray::Offset_t res_prev_offset = 0;
+
+            for (size_t i = 0; i < size; ++i)
             {
-                res_null_map->resize(res_prev_offset + size_to_write);
-                memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
+                if (src_offsets[i] != src_prev_offset)
+                {
+                    size_t size_to_write = src_offsets[i] - src_prev_offset;
+                    res_data.insertRangeFrom(src_data, src_prev_offset, size_to_write);
+
+                    if (nullable)
+                    {
+                        res_null_map->resize(res_prev_offset + size_to_write);
+                        memcpy(&(*res_null_map)[res_prev_offset], &(*src_null_map)[src_prev_offset], size_to_write);
+                    }
+
+                    res_prev_offset += size_to_write;
+                    res_offsets[i] = res_prev_offset;
+                }
+                else
+                {
+                    res_data.insertDefault();
+                    ++res_prev_offset;
+                    res_offsets[i] = res_prev_offset;
+
+                    if (nullable)
+                        res_null_map->push_back(1);
+                }
+
+                src_prev_offset = src_offsets[i];
             }
-
-            res_prev_offset += size_to_write;
-            res_offsets[i] = res_prev_offset;
         }
-        else
+
+
+        template <bool nullable>
+        void executeDispatch(
+            const IColumn & src_data, const ColumnArray::Offsets_t & src_array_offsets,
+            IColumn & res_data_col, ColumnArray::Offsets_t & res_array_offsets,
+            const NullMap * src_null_map,
+            NullMap * res_null_map)
         {
-            res_data.insertDefault();
-            ++res_prev_offset;
-            res_offsets[i] = res_prev_offset;
-
-            if (nullable)
-                res_null_map->push_back(1);
+            if (!( executeNumber<UInt8, nullable>  (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeNumber<UInt16, nullable> (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeNumber<UInt32, nullable> (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeNumber<UInt64, nullable> (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeNumber<Int8, nullable>   (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeNumber<Int16, nullable>  (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeNumber<Int32, nullable>  (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeNumber<Int64, nullable>  (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeNumber<Float32, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeNumber<Float64, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeString<nullable>         (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)
+                || executeFixedString<nullable>    (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map)))
+                executeGeneric<nullable>           (src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map, res_null_map);
         }
-
-        src_prev_offset = src_offsets[i];
     }
 }
 
-
-template<bool nullable>
-void executeDispatch(
-        const IColumn &src_data, const ColumnArray::Offsets_t &src_array_offsets,
-        IColumn &res_data_col, ColumnArray::Offsets_t &res_array_offsets,
-        const NullMap *src_null_map,
-        NullMap *res_null_map)
-{
-    if (!(executeNumber<UInt8, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                         res_null_map)
-          || executeNumber<UInt16, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                             res_null_map)
-          || executeNumber<UInt32, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                             res_null_map)
-          || executeNumber<UInt64, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                             res_null_map)
-          || executeNumber<Int8, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                           res_null_map)
-          || executeNumber<Int16, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                            res_null_map)
-          || executeNumber<Int32, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                            res_null_map)
-          || executeNumber<Int64, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                            res_null_map)
-          ||
-          executeNumber<Float32, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                           res_null_map)
-          ||
-          executeNumber<Float64, nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                           res_null_map)
-          || executeString<nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                     res_null_map)
-          || executeFixedString<nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                          res_null_map)))
-        executeGeneric<nullable>(src_data, src_array_offsets, res_data_col, res_array_offsets, src_null_map,
-                                 res_null_map);
-}
-}
-}
-
-void FunctionEmptyArrayToSingle::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
+void FunctionEmptyArrayToSingle::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
     if (FunctionEmptyArrayToSingleImpl::executeConst(block, arguments, result))
         return;
 
-    const ColumnArray *array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray * array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
     if (!array)
-        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName() +
-                        " of first argument of function " + getName(),
-                        ErrorCodes::ILLEGAL_COLUMN);
+        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName() + " of first argument of function " + getName(),
+            ErrorCodes::ILLEGAL_COLUMN);
 
     ColumnPtr res_ptr = array->cloneEmpty();
     block.getByPosition(result).column = res_ptr;
-    ColumnArray &res = static_cast<ColumnArray &>(*res_ptr);
+    ColumnArray & res = static_cast<ColumnArray &>(*res_ptr);
 
-    const IColumn &src_data = array->getData();
-    const ColumnArray::Offsets_t &src_offsets = array->getOffsets();
-    IColumn &res_data = res.getData();
-    ColumnArray::Offsets_t &res_offsets = res.getOffsets();
+    const IColumn & src_data = array->getData();
+    const ColumnArray::Offsets_t & src_offsets = array->getOffsets();
+    IColumn & res_data = res.getData();
+    ColumnArray::Offsets_t & res_offsets = res.getOffsets();
 
-    const NullMap *src_null_map = nullptr;
-    NullMap *res_null_map = nullptr;
+    const NullMap * src_null_map = nullptr;
+    NullMap * res_null_map = nullptr;
 
-    const IColumn *inner_col;
-    IColumn *inner_res_col;
+    const IColumn * inner_col;
+    IColumn * inner_res_col;
 
     bool nullable = src_data.isNullable();
     if (nullable)
@@ -2342,11 +2284,9 @@ void FunctionEmptyArrayToSingle::executeImpl(Block &block, const ColumnNumbers &
     }
 
     if (nullable)
-        FunctionEmptyArrayToSingleImpl::executeDispatch<true>(*inner_col, src_offsets, *inner_res_col, res_offsets,
-                                                              src_null_map, res_null_map);
+        FunctionEmptyArrayToSingleImpl::executeDispatch<true>(*inner_col, src_offsets, *inner_res_col, res_offsets, src_null_map, res_null_map);
     else
-        FunctionEmptyArrayToSingleImpl::executeDispatch<false>(*inner_col, src_offsets, *inner_res_col, res_offsets,
-                                                               src_null_map, res_null_map);
+        FunctionEmptyArrayToSingleImpl::executeDispatch<false>(*inner_col, src_offsets, *inner_res_col, res_offsets, src_null_map, res_null_map);
 }
 
 
@@ -2357,7 +2297,7 @@ String FunctionRange::getName() const
     return name;
 }
 
-DataTypePtr FunctionRange::getReturnTypeImpl(const DataTypes &arguments) const
+DataTypePtr FunctionRange::getReturnTypeImpl(const DataTypes & arguments) const
 {
     const auto arg = arguments.front().get();
 
@@ -2367,48 +2307,47 @@ DataTypePtr FunctionRange::getReturnTypeImpl(const DataTypes &arguments) const
         !checkDataType<DataTypeUInt64>(arg))
     {
         throw Exception{
-                "Illegal type " + arg->getName() + " of argument of function " + getName(),
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+            "Illegal type " + arg->getName() + " of argument of function " + getName(),
+            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
     }
 
     return std::make_shared<DataTypeArray>(arg->clone());
 }
 
-template<typename T>
-bool FunctionRange::executeInternal(Block &block, const IColumn *arg, const size_t result)
+template <typename T>
+bool FunctionRange::executeInternal(Block & block, const IColumn * arg, const size_t result)
 {
     static constexpr size_t max_elements = 100'000'000;
 
     if (const auto in = checkAndGetColumn<ColumnVector<T>>(arg))
     {
-        const auto &in_data = in->getData();
+        const auto & in_data = in->getData();
         const auto total_values = std::accumulate(std::begin(in_data), std::end(in_data), size_t{},
-                                                  [this](const size_t lhs, const size_t rhs)
-                                                  {
-                                                      const auto sum = lhs + rhs;
-                                                      if (sum < lhs)
-                                                          throw Exception{
-                                                                  "A call to function " + getName() +
-                                                                  " overflows, investigate the values of arguments you are passing",
-                                                                  ErrorCodes::ARGUMENT_OUT_OF_BOUND};
+            [this] (const size_t lhs, const size_t rhs)
+            {
+                const auto sum = lhs + rhs;
+                if (sum < lhs)
+                    throw Exception{
+                        "A call to function " + getName() + " overflows, investigate the values of arguments you are passing",
+                        ErrorCodes::ARGUMENT_OUT_OF_BOUND};
 
-                                                      return sum;
-                                                  });
+                return sum;
+            });
 
         if (total_values > max_elements)
             throw Exception{
-                    "A call to function " + getName() + " would produce " + std::to_string(total_values) +
+                "A call to function " + getName() + " would produce " + std::to_string(total_values) +
                     " array elements, which is greater than the allowed maximum of " + std::to_string(max_elements),
-                    ErrorCodes::ARGUMENT_OUT_OF_BOUND};
+                ErrorCodes::ARGUMENT_OUT_OF_BOUND};
 
         const auto data_col = std::make_shared<ColumnVector<T>>(total_values);
         const auto out = std::make_shared<ColumnArray>(
-                data_col,
-                std::make_shared<ColumnArray::ColumnOffsets_t>(in->size()));
+            data_col,
+            std::make_shared<ColumnArray::ColumnOffsets_t>(in->size()));
         block.getByPosition(result).column = out;
 
-        auto &out_data = data_col->getData();
-        auto &out_offsets = out->getOffsets();
+        auto & out_data = data_col->getData();
+        auto & out_offsets = out->getOffsets();
 
         IColumn::Offset_t offset{};
         for (size_t row_idx = 0, rows = in->size(); row_idx < rows; ++row_idx)
@@ -2427,25 +2366,24 @@ bool FunctionRange::executeInternal(Block &block, const IColumn *arg, const size
         T in_data = in->template getValue<T>();
         if ((in_data != 0) && (in->size() > (std::numeric_limits<size_t>::max() / in_data)))
             throw Exception{
-                    "A call to function " + getName() +
-                    " overflows, investigate the values of arguments you are passing",
-                    ErrorCodes::ARGUMENT_OUT_OF_BOUND};
+                "A call to function " + getName() + " overflows, investigate the values of arguments you are passing",
+                ErrorCodes::ARGUMENT_OUT_OF_BOUND};
 
         const size_t total_values = in->size() * in_data;
         if (total_values > max_elements)
             throw Exception{
-                    "A call to function " + getName() + " would produce " + toString(total_values) +
+                "A call to function " + getName() + " would produce " + toString(total_values) +
                     " array elements, which is greater than the allowed maximum of " + toString(max_elements),
-                    ErrorCodes::ARGUMENT_OUT_OF_BOUND};
+                ErrorCodes::ARGUMENT_OUT_OF_BOUND};
 
         const auto data_col = std::make_shared<ColumnVector<T>>(total_values);
         const auto out = std::make_shared<ColumnArray>(
-                data_col,
-                std::make_shared<ColumnArray::ColumnOffsets_t>(in->size()));
+            data_col,
+            std::make_shared<ColumnArray::ColumnOffsets_t>(in->size()));
         block.getByPosition(result).column = out;
 
-        auto &out_data = data_col->getData();
-        auto &out_offsets = out->getOffsets();
+        auto & out_data = data_col->getData();
+        auto & out_offsets = out->getOffsets();
 
         IColumn::Offset_t offset{};
         for (size_t row_idx = 0, rows = in->size(); row_idx < rows; ++row_idx)
@@ -2463,7 +2401,7 @@ bool FunctionRange::executeInternal(Block &block, const IColumn *arg, const size
         return false;
 }
 
-void FunctionRange::executeImpl(Block &block, const ColumnNumbers &arguments, const size_t result)
+void FunctionRange::executeImpl(Block & block, const ColumnNumbers & arguments, const size_t result)
 {
     const auto col = block.getByPosition(arguments[0]).column.get();
 
@@ -2473,15 +2411,15 @@ void FunctionRange::executeImpl(Block &block, const ColumnNumbers &arguments, co
         !executeInternal<UInt64>(block, col, result))
     {
         throw Exception{
-                "Illegal column " + col->getName() + " of argument of function " + getName(),
-                ErrorCodes::ILLEGAL_COLUMN
+            "Illegal column " + col->getName() + " of argument of function " + getName(),
+            ErrorCodes::ILLEGAL_COLUMN
         };
     }
 }
 
 /// Implementation of FunctionArrayReverse.
 
-FunctionPtr FunctionArrayReverse::create(const Context &context)
+FunctionPtr FunctionArrayReverse::create(const Context & context)
 {
     return std::make_shared<FunctionArrayReverse>();
 }
@@ -2491,41 +2429,40 @@ String FunctionArrayReverse::getName() const
     return name;
 }
 
-DataTypePtr FunctionArrayReverse::getReturnTypeImpl(const DataTypes &arguments) const
+DataTypePtr FunctionArrayReverse::getReturnTypeImpl(const DataTypes & arguments) const
 {
-    const DataTypeArray *array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
+    const DataTypeArray * array_type = checkAndGetDataType<DataTypeArray>(arguments[0].get());
     if (!array_type)
         throw Exception("Argument for function " + getName() + " must be array.",
-                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     return arguments[0]->clone();
 }
 
-void FunctionArrayReverse::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
+void FunctionArrayReverse::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
     if (executeConst(block, arguments, result))
         return;
 
-    const ColumnArray *array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
+    const ColumnArray * array = checkAndGetColumn<ColumnArray>(block.getByPosition(arguments[0]).column.get());
     if (!array)
-        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName() +
-                        " of first argument of function " + getName(),
-                        ErrorCodes::ILLEGAL_COLUMN);
+        throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName() + " of first argument of function " + getName(),
+            ErrorCodes::ILLEGAL_COLUMN);
 
     ColumnPtr res_ptr = array->cloneEmpty();
     block.getByPosition(result).column = res_ptr;
-    ColumnArray &res = static_cast<ColumnArray &>(*res_ptr);
+    ColumnArray & res = static_cast<ColumnArray &>(*res_ptr);
 
-    const IColumn &src_data = array->getData();
-    const ColumnArray::Offsets_t &offsets = array->getOffsets();
-    IColumn &res_data = res.getData();
+    const IColumn & src_data = array->getData();
+    const ColumnArray::Offsets_t & offsets = array->getOffsets();
+    IColumn & res_data = res.getData();
     res.getOffsetsColumn() = array->getOffsetsColumn();
 
-    const ColumnNullable *nullable_col = nullptr;
-    ColumnNullable *nullable_res_col = nullptr;
+    const ColumnNullable * nullable_col = nullptr;
+    ColumnNullable * nullable_res_col = nullptr;
 
-    const IColumn *inner_col;
-    IColumn *inner_res_col;
+    const IColumn * inner_col;
+    IColumn * inner_res_col;
 
     if (src_data.isNullable())
     {
@@ -2541,27 +2478,26 @@ void FunctionArrayReverse::executeImpl(Block &block, const ColumnNumbers &argume
         inner_res_col = &res_data;
     }
 
-    if (!(executeNumber<UInt8>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeNumber<UInt16>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeNumber<UInt32>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeNumber<UInt64>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeNumber<Int8>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeNumber<Int16>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeNumber<Int32>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeNumber<Int64>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeNumber<Float32>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeNumber<Float64>(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeString(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
-          || executeFixedString(*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)))
+    if (!(    executeNumber<UInt8>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeNumber<UInt16>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeNumber<UInt32>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeNumber<UInt64>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeNumber<Int8>        (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeNumber<Int16>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeNumber<Int32>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeNumber<Int64>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeNumber<Float32>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeNumber<Float64>    (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeString            (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)
+        ||    executeFixedString        (*inner_col, offsets, *inner_res_col, nullable_col, nullable_res_col)))
         throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-                        + " of first argument of function " + getName(),
-                        ErrorCodes::ILLEGAL_COLUMN);
+            + " of first argument of function " + getName(),
+            ErrorCodes::ILLEGAL_COLUMN);
 }
 
-bool FunctionArrayReverse::executeConst(Block &block, const ColumnNumbers &arguments, size_t result)
+bool FunctionArrayReverse::executeConst(Block & block, const ColumnNumbers & arguments, size_t result)
 {
-    if (const ColumnConst *const_array = checkAndGetColumnConst<ColumnArray>(
-            block.getByPosition(arguments[0]).column.get()))
+    if (const ColumnConst * const_array = checkAndGetColumnConst<ColumnArray>(block.getByPosition(arguments[0]).column.get()))
     {
         Array arr = const_array->getValue<Array>();
 
@@ -2579,22 +2515,22 @@ bool FunctionArrayReverse::executeConst(Block &block, const ColumnNumbers &argum
         return false;
 }
 
-template<typename T>
+template <typename T>
 bool FunctionArrayReverse::executeNumber(
-        const IColumn &src_data, const ColumnArray::Offsets_t &src_offsets,
-        IColumn &res_data_col,
-        const ColumnNullable *nullable_col,
-        ColumnNullable *nullable_res_col)
+    const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
+    IColumn & res_data_col,
+    const ColumnNullable * nullable_col,
+    ColumnNullable * nullable_res_col)
 {
-    auto do_reverse = [](const auto &src_data, const auto &src_offsets, auto &res_data)
+    auto do_reverse = [](const auto & src_data, const auto & src_offsets, auto & res_data)
     {
         size_t size = src_offsets.size();
         ColumnArray::Offset_t src_prev_offset = 0;
 
         for (size_t i = 0; i < size; ++i)
         {
-            const auto *src = &src_data[src_prev_offset];
-            const auto *src_end = &src_data[src_offsets[i]];
+            const auto * src = &src_data[src_prev_offset];
+            const auto * src_end = &src_data[src_offsets[i]];
 
             if (src == src_end)
                 continue;
@@ -2612,18 +2548,18 @@ bool FunctionArrayReverse::executeNumber(
         }
     };
 
-    if (const ColumnVector<T> *src_data_concrete = checkAndGetColumn<ColumnVector<T>>(&src_data))
+    if (const ColumnVector<T> * src_data_concrete = checkAndGetColumn<ColumnVector<T>>(&src_data))
     {
-        const PaddedPODArray<T> &src_data = src_data_concrete->getData();
-        PaddedPODArray<T> &res_data = typeid_cast<ColumnVector<T> &>(res_data_col).getData();
+        const PaddedPODArray<T> & src_data = src_data_concrete->getData();
+        PaddedPODArray<T> & res_data = typeid_cast<ColumnVector<T> &>(res_data_col).getData();
         res_data.resize(src_data.size());
         do_reverse(src_data, src_offsets, res_data);
 
         if ((nullable_col) && (nullable_res_col))
         {
             /// Make a reverted null map.
-            const auto &src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
-            auto &res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
+            const auto & src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
+            auto & res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
             res_null_map.resize(src_data.size());
             do_reverse(src_null_map, src_offsets, res_null_map);
         }
@@ -2635,16 +2571,16 @@ bool FunctionArrayReverse::executeNumber(
 }
 
 bool FunctionArrayReverse::executeFixedString(
-        const IColumn &src_data, const ColumnArray::Offsets_t &src_offsets,
-        IColumn &res_data_col,
-        const ColumnNullable *nullable_col,
-        ColumnNullable *nullable_res_col)
+    const IColumn & src_data, const ColumnArray::Offsets_t & src_offsets,
+    IColumn & res_data_col,
+    const ColumnNullable * nullable_col,
+    ColumnNullable * nullable_res_col)
 {
-    if (const ColumnFixedString *src_data_concrete = checkAndGetColumn<ColumnFixedString>(&src_data))
+    if (const ColumnFixedString * src_data_concrete = checkAndGetColumn<ColumnFixedString>(&src_data))
     {
         const size_t n = src_data_concrete->getN();
-        const ColumnFixedString::Chars_t &src_data = src_data_concrete->getChars();
-        ColumnFixedString::Chars_t &res_data = typeid_cast<ColumnFixedString &>(res_data_col).getChars();
+        const ColumnFixedString::Chars_t & src_data = src_data_concrete->getChars();
+        ColumnFixedString::Chars_t & res_data = typeid_cast<ColumnFixedString &>(res_data_col).getChars();
         size_t size = src_offsets.size();
         res_data.resize(src_data.size());
 
@@ -2652,13 +2588,13 @@ bool FunctionArrayReverse::executeFixedString(
 
         for (size_t i = 0; i < size; ++i)
         {
-            const UInt8 *src = &src_data[src_prev_offset * n];
-            const UInt8 *src_end = &src_data[src_offsets[i] * n];
+            const UInt8 * src = &src_data[src_prev_offset * n];
+            const UInt8 * src_end = &src_data[src_offsets[i] * n];
 
             if (src == src_end)
                 continue;
 
-            UInt8 *dst = &res_data[src_offsets[i] * n - n];
+            UInt8 * dst = &res_data[src_offsets[i] * n - n];
 
             while (src < src_end)
             {
@@ -2674,21 +2610,21 @@ bool FunctionArrayReverse::executeFixedString(
         if ((nullable_col) && (nullable_res_col))
         {
             /// Make a reverted null map.
-            const auto &src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
-            auto &res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
+            const auto & src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
+            auto & res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
             res_null_map.resize(src_null_map.size());
 
             ColumnArray::Offset_t src_prev_offset = 0;
 
             for (size_t i = 0; i < size; ++i)
             {
-                const UInt8 *src = &src_null_map[src_prev_offset];
-                const UInt8 *src_end = &src_null_map[src_offsets[i]];
+                const UInt8 * src = &src_null_map[src_prev_offset];
+                const UInt8 * src_end = &src_null_map[src_offsets[i]];
 
                 if (src == src_end)
                     continue;
 
-                UInt8 *dst = &res_null_map[src_offsets[i] - 1];
+                UInt8 * dst = &res_null_map[src_offsets[i] - 1];
 
                 while (src < src_end)
                 {
@@ -2708,18 +2644,18 @@ bool FunctionArrayReverse::executeFixedString(
 }
 
 bool FunctionArrayReverse::executeString(
-        const IColumn &src_data, const ColumnArray::Offsets_t &src_array_offsets,
-        IColumn &res_data_col,
-        const ColumnNullable *nullable_col,
-        ColumnNullable *nullable_res_col)
+    const IColumn & src_data, const ColumnArray::Offsets_t & src_array_offsets,
+    IColumn & res_data_col,
+    const ColumnNullable * nullable_col,
+    ColumnNullable * nullable_res_col)
 {
-    if (const ColumnString *src_data_concrete = checkAndGetColumn<ColumnString>(&src_data))
+    if (const ColumnString * src_data_concrete = checkAndGetColumn<ColumnString>(&src_data))
     {
-        const ColumnString::Offsets_t &src_string_offsets = src_data_concrete->getOffsets();
-        ColumnString::Offsets_t &res_string_offsets = typeid_cast<ColumnString &>(res_data_col).getOffsets();
+        const ColumnString::Offsets_t & src_string_offsets = src_data_concrete->getOffsets();
+        ColumnString::Offsets_t & res_string_offsets = typeid_cast<ColumnString &>(res_data_col).getOffsets();
 
-        const ColumnString::Chars_t &src_data = src_data_concrete->getChars();
-        ColumnString::Chars_t &res_data = typeid_cast<ColumnString &>(res_data_col).getChars();
+        const ColumnString::Chars_t & src_data = src_data_concrete->getChars();
+        ColumnString::Chars_t & res_data = typeid_cast<ColumnString &>(res_data_col).getChars();
 
         size_t size = src_array_offsets.size();
         res_string_offsets.resize(src_string_offsets.size());
@@ -2738,13 +2674,10 @@ bool FunctionArrayReverse::executeString(
                 {
                     size_t j_reversed = array_size - j - 1;
 
-                    auto src_pos =
-                            src_array_prev_offset + j_reversed == 0 ? 0 : src_string_offsets[src_array_prev_offset +
-                                                                                             j_reversed - 1];
+                    auto src_pos = src_array_prev_offset + j_reversed == 0 ? 0 : src_string_offsets[src_array_prev_offset + j_reversed - 1];
                     size_t string_size = src_string_offsets[src_array_prev_offset + j_reversed] - src_pos;
 
-                    memcpySmallAllowReadWriteOverflow15(&res_data[res_string_prev_offset], &src_data[src_pos],
-                                                        string_size);
+                    memcpySmallAllowReadWriteOverflow15(&res_data[res_string_prev_offset], &src_data[src_pos], string_size);
 
                     res_string_prev_offset += string_size;
                     res_string_offsets[src_array_prev_offset + j] = res_string_prev_offset;
@@ -2757,8 +2690,8 @@ bool FunctionArrayReverse::executeString(
         if ((nullable_col) && (nullable_res_col))
         {
             /// Make a reverted null map.
-            const auto &src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
-            auto &res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
+            const auto & src_null_map = static_cast<const ColumnUInt8 &>(*nullable_col->getNullMapColumn()).getData();
+            auto & res_null_map = static_cast<ColumnUInt8 &>(*nullable_res_col->getNullMapColumn()).getData();
             res_null_map.resize(src_string_offsets.size());
 
             size_t size = src_string_offsets.size();
@@ -2766,8 +2699,8 @@ bool FunctionArrayReverse::executeString(
 
             for (size_t i = 0; i < size; ++i)
             {
-                const auto *src = &src_null_map[src_prev_offset];
-                const auto *src_end = &src_null_map[src_array_offsets[i]];
+                const auto * src = &src_null_map[src_prev_offset];
+                const auto * src_end = &src_null_map[src_array_offsets[i]];
 
                 if (src == src_end)
                     continue;
@@ -2793,7 +2726,7 @@ bool FunctionArrayReverse::executeString(
 
 /// Implementation of FunctionArrayReduce.
 
-FunctionPtr FunctionArrayReduce::create(const Context &context)
+FunctionPtr FunctionArrayReduce::create(const Context & context)
 {
     return std::make_shared<FunctionArrayReduce>();
 }
@@ -2804,32 +2737,30 @@ String FunctionArrayReduce::getName() const
 }
 
 void FunctionArrayReduce::getReturnTypeAndPrerequisitesImpl(
-        const ColumnsWithTypeAndName &arguments,
-        DataTypePtr &out_return_type,
-        std::vector<ExpressionAction> &out_prerequisites)
+    const ColumnsWithTypeAndName & arguments,
+    DataTypePtr & out_return_type,
+    std::vector<ExpressionAction> & out_prerequisites)
 {
     /// The first argument is a constant string with the name of the aggregate function
     ///  (possibly with parameters in parentheses, for example: "quantile(0.99)").
 
     if (arguments.size() < 2)
         throw Exception("Number of arguments for function " + getName() + " doesn't match: passed "
-                        + toString(arguments.size()) + ", should be at least 2.",
-                        ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+            + toString(arguments.size()) + ", should be at least 2.",
+            ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-    const ColumnConst *aggregate_function_name_column = checkAndGetColumnConst<ColumnString>(arguments[0].column.get());
+    const ColumnConst * aggregate_function_name_column = checkAndGetColumnConst<ColumnString>(arguments[0].column.get());
     if (!aggregate_function_name_column)
-        throw Exception(
-                "First argument for function " + getName() + " must be constant string: name of aggregate function.",
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+        throw Exception("First argument for function " + getName() + " must be constant string: name of aggregate function.",
+            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     DataTypes argument_types(arguments.size() - 1);
     for (size_t i = 1, size = arguments.size(); i < size; ++i)
     {
-        const DataTypeArray *arg = checkAndGetDataType<DataTypeArray>(arguments[i].type.get());
+        const DataTypeArray * arg = checkAndGetDataType<DataTypeArray>(arguments[i].type.get());
         if (!arg)
-            throw Exception(
-                    "Argument " + toString(i) + " for function " + getName() + " must be an array but it has type "
-                    + arguments[i].type->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+            throw Exception("Argument " + toString(i) + " for function " + getName() + " must be an array but it has type "
+                + arguments[i].type->getName() + ".", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
         argument_types[i - 1] = arg->getNestedType()->clone();
     }
@@ -2839,17 +2770,15 @@ void FunctionArrayReduce::getReturnTypeAndPrerequisitesImpl(
         String aggregate_function_name_with_params = aggregate_function_name_column->getValue<String>();
 
         if (aggregate_function_name_with_params.empty())
-            throw Exception(
-                    "First argument for function " + getName() + " (name of aggregate function) cannot be empty.",
-                    ErrorCodes::BAD_ARGUMENTS);
+            throw Exception("First argument for function " + getName() + " (name of aggregate function) cannot be empty.",
+                ErrorCodes::BAD_ARGUMENTS);
 
         String aggregate_function_name;
         Array params_row;
         getAggregateFunctionNameAndParametersArray(aggregate_function_name_with_params,
                                                    aggregate_function_name, params_row, "function " + getName());
 
-        aggregate_function = AggregateFunctionFactory::instance().get(aggregate_function_name, argument_types,
-                                                                      params_row);
+        aggregate_function = AggregateFunctionFactory::instance().get(aggregate_function_name, argument_types, params_row);
         if (!params_row.empty())
             aggregate_function->setParameters(params_row);
         aggregate_function->setArguments(argument_types);
@@ -2859,10 +2788,11 @@ void FunctionArrayReduce::getReturnTypeAndPrerequisitesImpl(
 }
 
 
-void FunctionArrayReduce::executeImpl(Block &block, const ColumnNumbers &arguments, size_t result)
+
+void FunctionArrayReduce::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
-    IAggregateFunction &agg_func = *aggregate_function.get();
-    std::unique_ptr<char[]> place_holder{new char[agg_func.sizeOfData()]};
+    IAggregateFunction & agg_func = *aggregate_function.get();
+    std::unique_ptr<char[]> place_holder { new char[agg_func.sizeOfData()] };
     AggregateDataPtr place = place_holder.get();
 
     std::unique_ptr<Arena> arena = agg_func.allocatesMemoryInArena() ? std::make_unique<Arena>() : nullptr;
@@ -2878,31 +2808,30 @@ void FunctionArrayReduce::executeImpl(Block &block, const ColumnNumbers &argumen
 
     for (size_t i = 0, size = arguments.size() - 1; i < size; ++i)
     {
-        const IColumn *col = block.getByPosition(arguments[i + 1]).column.get();
-        if (const ColumnArray *arr = checkAndGetColumn<ColumnArray>(col))
+        const IColumn * col = block.getByPosition(arguments[i + 1]).column.get();
+        if (const ColumnArray * arr = checkAndGetColumn<ColumnArray>(col))
         {
             aggregate_arguments_vec[i] = arr->getDataPtr().get();
             is_const = false;
         }
-        else if (const ColumnConst *arr = checkAndGetColumnConst<ColumnArray>(col))
+        else if (const ColumnConst * arr = checkAndGetColumnConst<ColumnArray>(col))
         {
             materialized_columns.emplace_back(arr->convertToFullColumn());
             aggregate_arguments_vec[i] = typeid_cast<const ColumnArray &>(*materialized_columns.back().get()).getDataPtr().get();
         }
         else
-            throw Exception("Illegal column " + col->getName() + " as argument of function " + getName(),
-                            ErrorCodes::ILLEGAL_COLUMN);
+            throw Exception("Illegal column " + col->getName() + " as argument of function " + getName(), ErrorCodes::ILLEGAL_COLUMN);
 
     }
-    const IColumn **aggregate_arguments = aggregate_arguments_vec.data();
+    const IColumn ** aggregate_arguments = aggregate_arguments_vec.data();
 
-    const ColumnArray::Offsets_t &offsets = typeid_cast<const ColumnArray &>(!materialized_columns.empty()
-                                                                             ? *materialized_columns.front().get()
-                                                                             : *block.getByPosition(arguments[1]).column.get()).getOffsets();
+    const ColumnArray::Offsets_t & offsets = typeid_cast<const ColumnArray &>(!materialized_columns.empty()
+        ? *materialized_columns.front().get()
+        : *block.getByPosition(arguments[1]).column.get()).getOffsets();
 
 
     ColumnPtr result_holder = block.getByPosition(result).type->createColumn();
-    IColumn &res_col = *result_holder;
+    IColumn & res_col = *result_holder;
 
     /// AggregateFunction's states should be inserted into column using specific way
     auto res_col_aggregate_function = typeid_cast<ColumnAggregateFunction *>(&res_col);

From c32bf4f59741a0bd265d93f228784a6b8cf7f151 Mon Sep 17 00:00:00 2001
From: Vitaliy Lyudvichenko <vludv@yandex-team.ru>
Date: Thu, 31 Aug 2017 15:55:19 +0300
Subject: [PATCH 039/266] Use only one cache in DNSCache. Add requested
 changes. [#CLICKHOUSE-2931]

---
 dbms/src/Common/SimpleCache.h                 |  2 +-
 dbms/src/Interpreters/DNSCache.cpp            | 73 +++++++++++++++----
 dbms/src/Interpreters/DNSCache.h              |  7 +-
 dbms/src/Interpreters/InterpreterFactory.cpp  |  2 +-
 .../Interpreters/InterpreterSystemQuery.cpp   | 17 +++--
 .../Interpreters/tests/gtest_small_utils.cpp  | 10 ---
 dbms/src/Parsers/ASTSystemQuery.h             |  8 +-
 dbms/src/Parsers/ParserSystemQuery.cpp        |  4 +-
 dbms/src/Parsers/ParserSystemQuery.h          |  3 -
 .../integration/test_system_queries/test.py   |  7 +-
 ...s_and_insert_without_explicit_database.sql |  4 +
 11 files changed, 90 insertions(+), 47 deletions(-)
 delete mode 100644 dbms/src/Interpreters/tests/gtest_small_utils.cpp

diff --git a/dbms/src/Common/SimpleCache.h b/dbms/src/Common/SimpleCache.h
index 81043876fdd..3028673c6b5 100644
--- a/dbms/src/Common/SimpleCache.h
+++ b/dbms/src/Common/SimpleCache.h
@@ -53,7 +53,7 @@ public:
         return res;
     }
 
-    void dropCache()
+    void drop()
     {
         std::lock_guard<std::mutex> lock(mutex);
         cache.clear();
diff --git a/dbms/src/Interpreters/DNSCache.cpp b/dbms/src/Interpreters/DNSCache.cpp
index ab897a332cb..d9ec6cc2803 100644
--- a/dbms/src/Interpreters/DNSCache.cpp
+++ b/dbms/src/Interpreters/DNSCache.cpp
@@ -1,14 +1,65 @@
 #include "DNSCache.h"
-#include <Poco/Net/DNS.h>
 #include <Common/SimpleCache.h>
+#include <Common/Exception.h>
 #include <Core/Types.h>
+#include <Poco/Net/DNS.h>
 #include <Poco/Net/NetException.h>
-
+#include <Poco/NumberParser.h>
+#include <arpa/inet.h>
 
 
 namespace DB
 {
 
+/// Slightly altered implementation from https://github.com/pocoproject/poco/blob/poco-1.6.1/Net/src/SocketAddress.cpp#L86
+static void splitHostAndPort(const std::string & host_and_port, std::string & out_host, UInt16 & out_port)
+{
+    String port_str;
+    out_host.clear();
+
+    auto it = host_and_port.begin();
+    auto end = host_and_port.end();
+
+    if (*it == '[') /// Try parse case '[<IPv6 or something else>]:<port>'
+    {
+        ++it;
+        while (it != end && *it != ']')
+            out_host += *it++;
+        if (it == end)
+            throw Exception("Malformed IPv6 address", ErrorCodes::BAD_ARGUMENTS);
+        ++it;
+    }
+    else /// Case '<IPv4 or domain name or something else>:<port>'
+    {
+        while (it != end && *it != ':')
+            out_host += *it++;
+    }
+
+    if (it != end && *it == ':')
+    {
+        ++it;
+        while (it != end)
+            port_str += *it++;
+    }
+    else
+        throw Exception("Missing port number", ErrorCodes::BAD_ARGUMENTS);
+
+    unsigned port;
+    if (Poco::NumberParser::tryParseUnsigned(port_str, port) && port <= 0xFFFF)
+    {
+        out_port = static_cast<UInt16>(port);
+    }
+    else
+    {
+        struct servent * se = getservbyname(port_str.c_str(), nullptr);
+        if (se)
+            out_port = ntohs(static_cast<uint16_t>(se->s_port));
+        else
+            throw Exception("Service not found", ErrorCodes::BAD_ARGUMENTS);
+    }
+}
+
+
 static Poco::Net::IPAddress resolveIPAddressImpl(const std::string & host)
 {
     /// NOTE: Poco::Net::DNS::resolveOne(host) doesn't work for IP addresses like 127.0.0.2
@@ -16,17 +67,10 @@ static Poco::Net::IPAddress resolveIPAddressImpl(const std::string & host)
     return Poco::Net::SocketAddress(host, 0U).host();
 }
 
-static Poco::Net::SocketAddress resolveSocketAddressImpl(const std::string & host_and_port)
-{
-    return Poco::Net::SocketAddress(host_and_port);
-}
 
 struct DNSCache::Impl
 {
-    /// TODO: Use only one cache for different formats
-
     SimpleCache<decltype(resolveIPAddressImpl), &resolveIPAddressImpl> cache_host;
-    SimpleCache<decltype(resolveSocketAddressImpl), &resolveSocketAddressImpl> cache_host_and_port;
 };
 
 
@@ -39,13 +83,16 @@ Poco::Net::IPAddress DNSCache::resolveHost(const std::string & host)
 
 Poco::Net::SocketAddress DNSCache::resolveHostAndPort(const std::string & host_and_port)
 {
-    return impl->cache_host_and_port(host_and_port);
+    String host;
+    UInt16 port;
+    splitHostAndPort(host_and_port, host, port);
+
+    return Poco::Net::SocketAddress(impl->cache_host(host), port);
 }
 
-void DNSCache::dropCache()
+void DNSCache::drop()
 {
-    impl->cache_host.dropCache();
-    impl->cache_host_and_port.dropCache();
+    impl->cache_host.drop();
 }
 
 DNSCache::~DNSCache() = default;
diff --git a/dbms/src/Interpreters/DNSCache.h b/dbms/src/Interpreters/DNSCache.h
index 538bb1269c1..46722f43a64 100644
--- a/dbms/src/Interpreters/DNSCache.h
+++ b/dbms/src/Interpreters/DNSCache.h
@@ -8,17 +8,22 @@
 namespace DB
 {
 
+/// A singleton implementing global and permanent DNS cache
+/// It could be updated only manually via drop() method
 class DNSCache : public ext::singleton<DNSCache>
 {
 public:
 
     DNSCache(const DNSCache &) = delete;
 
+    /// Accepts host names like 'example.com' or '127.0.0.1' or '::1' and resolve its IP
     Poco::Net::IPAddress resolveHost(const std::string & host);
 
+    /// Accepts host names like 'example.com:port' or '127.0.0.1:port' or '[::1]:port' and resolve its IP and port
     Poco::Net::SocketAddress resolveHostAndPort(const std::string & host_and_port);
 
-    void dropCache();
+    /// Drops all caches
+    void drop();
 
     ~DNSCache();
 
diff --git a/dbms/src/Interpreters/InterpreterFactory.cpp b/dbms/src/Interpreters/InterpreterFactory.cpp
index 63ceb3d1c4b..cbc5f4d3b29 100644
--- a/dbms/src/Interpreters/InterpreterFactory.cpp
+++ b/dbms/src/Interpreters/InterpreterFactory.cpp
@@ -29,11 +29,11 @@
 #include <Interpreters/InterpreterShowProcesslistQuery.h>
 #include <Interpreters/InterpreterCheckQuery.h>
 #include <Interpreters/InterpreterKillQueryQuery.h>
+#include <Interpreters/InterpreterSystemQuery.h>
 #include <Interpreters/InterpreterFactory.h>
 
 #include <Common/typeid_cast.h>
 #include <Parsers/ASTSystemQuery.h>
-#include "InterpreterSystemQuery.h"
 
 
 namespace DB
diff --git a/dbms/src/Interpreters/InterpreterSystemQuery.cpp b/dbms/src/Interpreters/InterpreterSystemQuery.cpp
index 6a167ac190a..eab515245b6 100644
--- a/dbms/src/Interpreters/InterpreterSystemQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterSystemQuery.cpp
@@ -6,7 +6,6 @@
 #include <Parsers/ASTSystemQuery.h>
 #include <Common/typeid_cast.h>
 #include <csignal>
-#include <bits/signum.h>
 
 
 namespace DB
@@ -21,8 +20,8 @@ namespace ErrorCodes
 }
 
 
-InterpreterSystemQuery::InterpreterSystemQuery(const ASTPtr & query_ptr_, Context & context_)
-        : query_ptr(query_ptr_), context(context_) {}
+namespace
+{
 
 ExecutionStatus getOverallExecutionStatusOfCommands()
 {
@@ -51,6 +50,12 @@ ExecutionStatus getOverallExecutionStatusOfCommands(Callable && command, Callabl
     return ExecutionStatus(res_status, res_message);
 }
 
+}
+
+
+InterpreterSystemQuery::InterpreterSystemQuery(const ASTPtr & query_ptr_, Context & context_)
+        : query_ptr(query_ptr_), context(context_) {}
+
 
 BlockIO InterpreterSystemQuery::execute()
 {
@@ -62,14 +67,14 @@ BlockIO InterpreterSystemQuery::execute()
     {
         case Type::SHUTDOWN:
             if (kill(0, SIGTERM))
-                throw Exception("System call kill(0, SIGTERM) failed", ErrorCodes::CANNOT_KILL);
+                throwFromErrno("System call kill(0, SIGTERM) failed", ErrorCodes::CANNOT_KILL);
             break;
         case Type::KILL:
             if (kill(0, SIGKILL))
-                throw Exception("System call kill(0, SIGKILL) failed", ErrorCodes::CANNOT_KILL);
+                throwFromErrno("System call kill(0, SIGKILL) failed", ErrorCodes::CANNOT_KILL);
             break;
         case Type::DROP_DNS_CACHE:
-            DNSCache::instance().dropCache();
+            DNSCache::instance().drop();
             break;
         case Type::DROP_MARK_CACHE:
             context.dropMarkCache();
diff --git a/dbms/src/Interpreters/tests/gtest_small_utils.cpp b/dbms/src/Interpreters/tests/gtest_small_utils.cpp
deleted file mode 100644
index 3c40150ae5d..00000000000
--- a/dbms/src/Interpreters/tests/gtest_small_utils.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <gtest/gtest.h>
-#include <Common/Exception.h>
-using namespace DB;
-
-
-TEST(Interpreters, getOverallExecutionStatusOfCommands)
-{
-
-}
-
diff --git a/dbms/src/Parsers/ASTSystemQuery.h b/dbms/src/Parsers/ASTSystemQuery.h
index 5ccad6bec80..31f40193ec3 100644
--- a/dbms/src/Parsers/ASTSystemQuery.h
+++ b/dbms/src/Parsers/ASTSystemQuery.h
@@ -12,7 +12,7 @@ public:
 
     enum class Type
     {
-        _UNKNOWN,
+        UNKNOWN,
         SHUTDOWN,
         KILL,
         DROP_DNS_CACHE,
@@ -28,12 +28,12 @@ public:
         START_MERGES,
         STOP_REPLICATION_QUEUES,
         START_REPLICATION_QUEUES,
-        _END
+        END
     };
 
     static const char * typeToString(Type type);
 
-    Type type = Type::_UNKNOWN;
+    Type type = Type::UNKNOWN;
 
     String target_dictionary;
     //String target_replica_database;
@@ -46,8 +46,6 @@ public:
 
     ASTPtr clone() const override { return std::make_shared<ASTSystemQuery>(*this); }
 
-    ~ASTSystemQuery() override = default;
-
 protected:
 
     void formatImpl(const FormatSettings & settings, FormatState & state, FormatStateStacked frame) const override;
diff --git a/dbms/src/Parsers/ParserSystemQuery.cpp b/dbms/src/Parsers/ParserSystemQuery.cpp
index 18a0b0faa26..37b25560b5e 100644
--- a/dbms/src/Parsers/ParserSystemQuery.cpp
+++ b/dbms/src/Parsers/ParserSystemQuery.cpp
@@ -1,10 +1,8 @@
 #include <Parsers/ParserSystemQuery.h>
 #include <Parsers/ASTSystemQuery.h>
 #include <Parsers/CommonParsers.h>
-#include <Parsers/ASTIdentifier.h>
 #include <Parsers/ASTLiteral.h>
 #include <Interpreters/evaluateConstantExpression.h>
-#include "ASTSystemQuery.h"
 
 
 namespace ErrorCodes
@@ -29,7 +27,7 @@ bool ParserSystemQuery::parseImpl(IParser::Pos & pos, ASTPtr & node, Expected &
     auto res = std::make_shared<ASTSystemQuery>();
 
     bool found = false;
-    for (int i = static_cast<int>(Type::SHUTDOWN); i < static_cast<int>(Type::_END); ++i)
+    for (int i = static_cast<int>(Type::UNKNOWN) + 1; i < static_cast<int>(Type::END); ++i)
     {
         Type t = static_cast<Type>(i);
         if (ParserKeyword{ASTSystemQuery::typeToString(t)}.ignore(pos))
diff --git a/dbms/src/Parsers/ParserSystemQuery.h b/dbms/src/Parsers/ParserSystemQuery.h
index 7083e282a06..5f947e63b95 100644
--- a/dbms/src/Parsers/ParserSystemQuery.h
+++ b/dbms/src/Parsers/ParserSystemQuery.h
@@ -8,9 +8,6 @@ namespace DB
 
 class ParserSystemQuery : public IParserBase
 {
-public:
-    ParserSystemQuery() = default;
-
 protected:
     const char * getName() const override { return "SYSTEM query"; }
     bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected) override;
diff --git a/dbms/tests/integration/test_system_queries/test.py b/dbms/tests/integration/test_system_queries/test.py
index 7d6153dafea..b7bf350d395 100644
--- a/dbms/tests/integration/test_system_queries/test.py
+++ b/dbms/tests/integration/test_system_queries/test.py
@@ -55,13 +55,12 @@ def test_DROP_DNS_CACHE(started_cluster):
     instance = cluster.instances['ch1']
 
     with pytest.raises(Exception):
-        instance.query("SELECT * FROM remote('apperol', 'system', 'one')")
+        instance.query("SELECT * FROM remote('aperol', 'system', 'one')")
 
-    print instance.exec_in_container(['bash', '-c', 'echo $USER `cat /etc/hosts`'], privileged=True)
-    instance.exec_in_container(['bash', '-c', 'echo 127.0.0.1 apperol >> /etc/hosts'], privileged=True)
+    instance.exec_in_container(['bash', '-c', 'echo 127.0.0.1 aperol >> /etc/hosts'], privileged=True, user='root')
     instance.query("SYSTEM DROP DNS CACHE")
 
-    instance.query("SELECT * FROM remote('apperol', 'system', 'one')")
+    instance.query("SELECT * FROM remote('aperol', 'system', 'one')")
 
 
 if __name__ == '__main__':
diff --git a/dbms/tests/queries/0_stateless/00101_materialized_views_and_insert_without_explicit_database.sql b/dbms/tests/queries/0_stateless/00101_materialized_views_and_insert_without_explicit_database.sql
index 772ac54d830..5754d86d8c9 100644
--- a/dbms/tests/queries/0_stateless/00101_materialized_views_and_insert_without_explicit_database.sql
+++ b/dbms/tests/queries/0_stateless/00101_materialized_views_and_insert_without_explicit_database.sql
@@ -18,8 +18,12 @@ USE test;
 DROP TABLE IF EXISTS tmp;
 DROP TABLE IF EXISTS tmp_mv;
 DROP TABLE IF EXISTS tmp_mv2;
+DROP TABLE IF EXISTS tmp_mv3;
+DROP TABLE IF EXISTS tmp_mv4;
 DROP TABLE IF EXISTS `.inner.tmp_mv`;
 DROP TABLE IF EXISTS `.inner.tmp_mv2`;
+DROP TABLE IF EXISTS `.inner.tmp_mv3`;
+DROP TABLE IF EXISTS `.inner.tmp_mv4`;
 
 CREATE TABLE tmp (date Date, name String) ENGINE = Memory;
 CREATE MATERIALIZED VIEW tmp_mv ENGINE = AggregatingMergeTree(date, (date, name), 8192) AS SELECT date, name, countState() AS cc FROM tmp GROUP BY date, name;

From df0991286486182fb9bf00d5b108a85cbc4a1baa Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 20:07:58 +0300
Subject: [PATCH 040/266] reformated GatherUtils.cpp [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.cpp | 33 ++++++++++++++++++++----------
 1 file changed, 22 insertions(+), 11 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.cpp b/dbms/src/Functions/GatherUtils.cpp
index 636fb8ad049..67966653fa7 100644
--- a/dbms/src/Functions/GatherUtils.cpp
+++ b/dbms/src/Functions/GatherUtils.cpp
@@ -11,7 +11,8 @@ struct ArraySourceCreator;
 template <typename Type, typename ... Types>
 struct ArraySourceCreator<Type, Types ...>
 {
-    static std::unique_ptr<IArraySource> create(const ColumnArray & col, const ColumnUInt8 * null_map, bool is_const, size_t total_rows)
+    static std::unique_ptr<IArraySource>
+    create(const ColumnArray & col, const ColumnUInt8 * null_map, bool is_const, size_t total_rows)
     {
         if (typeid_cast<const ColumnVector<Type> *>(&col.getData()))
         {
@@ -33,7 +34,8 @@ struct ArraySourceCreator<Type, Types ...>
 template <>
 struct ArraySourceCreator<>
 {
-    static std::unique_ptr<IArraySource> create(const ColumnArray & col, const ColumnUInt8 * null_map, bool is_const, size_t total_rows)
+    static std::unique_ptr<IArraySource>
+    create(const ColumnArray & col, const ColumnUInt8 * null_map, bool is_const, size_t total_rows)
     {
         if (null_map)
         {
@@ -118,11 +120,11 @@ struct ArraySourceSelector<Base, Type, Types ...>
     {
         if (auto array = typeid_cast<NumericArraySource<Type> *>(&source))
             Base::selectImpl(*array, args ...);
-        else if(auto nullable_array = typeid_cast<NullableArraySource<NumericArraySource<Type>> *>(&source))
+        else if (auto nullable_array = typeid_cast<NullableArraySource<NumericArraySource<Type>> *>(&source))
             Base::selectImpl(*nullable_array, args ...);
         else if (auto const_array = typeid_cast<ConstSource<NumericArraySource<Type>> *>(&source))
             Base::selectImpl(*const_array, args ...);
-        else if(auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<NumericArraySource<Type>>> *>(&source))
+        else if (auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<NumericArraySource<Type>>> *>(&source))
             Base::selectImpl(*const_nullable_array, args ...);
         else
             ArraySourceSelector<Base, Types ...>::select(source, args ...);
@@ -137,11 +139,11 @@ struct ArraySourceSelector<Base>
     {
         if (auto array = typeid_cast<GenericArraySource *>(&source))
             Base::selectImpl(*array, args ...);
-        else if(auto nullable_array = typeid_cast<NullableArraySource<GenericArraySource> *>(&source))
+        else if (auto nullable_array = typeid_cast<NullableArraySource<GenericArraySource> *>(&source))
             Base::selectImpl(*nullable_array, args ...);
         else if (auto const_array = typeid_cast<ConstSource<GenericArraySource> *>(&source))
             Base::selectImpl(*const_array, args ...);
-        else if(auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<GenericArraySource>> *>(&source))
+        else if (auto const_nullable_array = typeid_cast<ConstSource<NullableArraySource<GenericArraySource>> *>(&source))
             Base::selectImpl(*const_nullable_array, args ...);
         else
             throw Exception(std::string("Unknown ArraySource type: ") + typeid(source).name(), ErrorCodes::LOGICAL_ERROR);
@@ -149,7 +151,8 @@ struct ArraySourceSelector<Base>
 };
 
 template <typename Base>
-using GetArraySourceSelector = typename ApplyTypeListForClass<ArraySourceSelector, typename PrependToTypeList<Base, TypeListNumbers>::Type>::Type;
+using GetArraySourceSelector = typename ApplyTypeListForClass<ArraySourceSelector,
+        typename PrependToTypeList<Base, TypeListNumbers>::Type>::Type;
 
 template <typename Base, typename ... Types>
 struct ArraySinkSelector;
@@ -185,7 +188,8 @@ struct ArraySinkSelector<Base>
 };
 
 template <typename Base>
-using GetArraySinkSelector = typename ApplyTypeListForClass<ArraySinkSelector, typename PrependToTypeList<Base, TypeListNumbers>::Type>::Type;
+using GetArraySinkSelector = typename ApplyTypeListForClass<ArraySinkSelector,
+        typename PrependToTypeList<Base, TypeListNumbers>::Type>::Type;
 
 template <typename Base>
 struct ArraySinkSourceSelector
@@ -269,7 +273,7 @@ static void NO_INLINE concatGenericArray(const std::vector<std::unique_ptr<IArra
 
     for (auto i : ext::range(0, sources.size()))
     {
-        const auto &source = sources[i];
+        const auto & source = sources[i];
         if (auto generic_source = typeid_cast<GenericArraySource *>(source.get()))
             generic_sources.push_back(static_cast<GenericArraySource *>(generic_source));
         else if (auto const_generic_source = typeid_cast<ConstSource<GenericArraySource> *>(source.get()))
@@ -288,8 +292,9 @@ static void NO_INLINE concatGenericArray(const std::vector<std::unique_ptr<IArra
             is_nullable[i] = is_const[i] = true;
         }
         else
-            throw Exception(std::string("GenericArraySource expected for GenericArraySink, got: ") + typeid(source).name(),
-                            ErrorCodes::LOGICAL_ERROR);
+            throw Exception(
+                    std::string("GenericArraySource expected for GenericArraySink, got: ") + typeid(source).name(),
+                    ErrorCodes::LOGICAL_ERROR);
     }
 
     while (!sink.isEnd())
@@ -339,17 +344,23 @@ void NO_INLINE concat(const std::vector<std::unique_ptr<IArraySource>> & sources
         if (source->isConst())
         {
             for (size_t i : ext::range(1, offsets.size()))
+            {
                 sink.offsets[i] += offsets[0];
+            }
         }
         else
         {
             for (size_t i : ext::range(1, offsets.size()))
+            {
                 sink.offsets[i] += offsets[i - 1] - (i > 1 ? offsets[i - 2] : 0);
+            }
         }
     }
 
     for (auto i : ext::range(1, sink.offsets.size()))
+    {
         sink.offsets[i] += sink.offsets[i - 1];
+    }
 
     sink.reserve(elements_to_reserve);
 

From 0140c1409418f40b1e66760a73a8495296ff277a Mon Sep 17 00:00:00 2001
From: BayoNet <da-daos@yandex.ru>
Date: Fri, 1 Sep 2017 20:12:46 +0300
Subject: [PATCH 041/266] Getting external dictionary from MySQL through the
 sockets. (#1184)

---
 docs/ru/dicts/external_dicts_dict_sources.rst | 28 ++++++++++++++++---
 1 file changed, 24 insertions(+), 4 deletions(-)

diff --git a/docs/ru/dicts/external_dicts_dict_sources.rst b/docs/ru/dicts/external_dicts_dict_sources.rst
index 251f89adb34..821208ed475 100644
--- a/docs/ru/dicts/external_dicts_dict_sources.rst
+++ b/docs/ru/dicts/external_dicts_dict_sources.rst
@@ -125,7 +125,7 @@ ODBC
       <db>DatabaseName</db>
       <table>TableName</table>
       <connection_string>DSN=some_parameters</connection_string>
-      <invalidate_query>SQL_REQUEST</invalidate_query>
+      <invalidate_query>SQL_QUERY</invalidate_query>
   </odbc>
 
 Поля настройки:
@@ -307,10 +307,10 @@ MySQL
             <host>example01-2</host>
             <priority>1</priority>
         </replica>
-        <db>conv_main</db>
-        <table>counters</table>
+        <db>db_name</db>
+        <table>table_name</table>
         <where>id=10</where>
-        <invalidate_query>SQL_REQUEST</invalidate_query>
+        <invalidate_query>SQL_QUERY</invalidate_query>
     </mysql>
   </source>
 
@@ -328,6 +328,26 @@ MySQL
 * ``table`` - имя таблицы.
 * ``where`` - условие выбора. Необязательный параметр.
 * ``invalidate_query`` - запрос для проверки статуса словаря. Необязательный параметр. Читайте подробнее в разделе :ref:`dicts-external_dicts_dict_lifetime`.
+  
+MySQL можно подключить на локальном хосте через сокеты, для этого необходимо задать ``host`` и ``socket``.
+
+Пример настройки:
+
+.. code-block:: xml
+
+  <source>
+    <mysql>
+        <host>localhost</host>
+        <socket>/path/to/socket/file.sock</socket>
+        <user>clickhouse</user>
+        <password>qwerty</password>
+        <db>db_name</db>
+        <table>table_name</table>
+        <where>id=10</where>
+        <invalidate_query>SQL_QUERY</invalidate_query>
+    </mysql>
+  </source>
+
 
 .. _dicts-external_dicts_dict_sources-clickhouse:
 

From a88bb9375a009a05db53148f45ee6c01030db423 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 20:14:47 +0300
Subject: [PATCH 042/266] removed useless code from GatherUtils
 [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.h | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index 1c011a747a7..6c4b3d4edcb 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -900,15 +900,8 @@ inline ALWAYS_INLINE void writeSlice(const GenericArraySlice & slice, GenericArr
     if (typeid(slice.elements) == typeid(&sink.elements))
         sink.elements.insertRangeFrom(*slice.elements, slice.begin, slice.size);
     else
-    {
-        for (size_t i = 0; i < slice.size; ++i)
-        {
-            Field field;
-            slice.elements->get(slice.begin + i, field);
-            sink.elements.insert(field);
-        }
-    }
-    sink.current_offset += slice.size;
+        throw Exception("Function writeSlice expect same column types for GenericArraySlice and GenericArraySink.",
+                        ErrorCodes::LOGICAL_ERROR);
 }
 
 template <typename T>

From 463c05b33d636e0b33268720540d65bd82a8a4e5 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 20:16:48 +0300
Subject: [PATCH 043/266] fixed build [#CLICKHOUSE-2090]

---
 dbms/src/Functions/FunctionsArray.cpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index d8682a9d5b0..eea4410ca26 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -7,6 +7,7 @@
 #include <Functions/FunctionsConversion.h>
 #include <Functions/Conditional/getArrayType.h>
 #include <Functions/Conditional/CondException.h>
+#include <Functions/GatherUtils.h>
 #include <Common/HashTable/HashMap.h>
 #include <Common/HashTable/ClearableHashMap.h>
 #include <Parsers/ExpressionListParsers.h>

From 1a8e22c37f54d18b2162b2048db5171bca4d8594 Mon Sep 17 00:00:00 2001
From: proller <proller@users.noreply.github.com>
Date: Fri, 1 Sep 2017 20:21:03 +0300
Subject: [PATCH 044/266] Allow compile on 32bit systems (#1175)

* Trying compile under 32bit..

* PerformanceTest: use getMultiple*FromConfig, fix debug helpers

* Missing file

* clnag-format of Split ComplexKeyCacheDictionary

* wip

* Requested changes

* wip

* wip

* Fix boost 1.64 and gcc7+ compile errors

* More fixes

* wip

* Fix arm build

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* clean

* fix

* wip

* wip

* clean

* clean

* wip

* wip

* Update MergeTreeSettings.h

* Requested changes

* Requested changes

* Requested changes

* Requested changes
---
 CMakeLists.txt                                 |  9 ++++++++-
 contrib/libzlib-ng/CMakeLists.txt              |  2 +-
 .../AggregateFunctionGroupArray.h              |  2 +-
 dbms/src/Common/LRUCache.h                     |  2 +-
 dbms/src/Core/Defines.h                        |  4 ++--
 .../PrettySpaceBlockOutputStream.cpp           |  4 ++--
 dbms/src/Dictionaries/CacheDictionary.cpp      |  2 +-
 dbms/src/Dictionaries/CacheDictionary.h        |  4 ++--
 dbms/src/Dictionaries/TrieDictionary.cpp       |  5 +++++
 dbms/src/Functions/FunctionsArray.cpp          |  4 ++--
 dbms/src/Functions/FunctionsDateTime.h         |  2 +-
 dbms/src/Functions/FunctionsMiscellaneous.cpp  |  2 +-
 dbms/src/Functions/FunctionsReinterpret.h      |  2 +-
 dbms/src/IO/MemoryReadWriteBuffer.cpp          |  2 +-
 dbms/src/IO/ReadBufferAIO.cpp                  |  2 +-
 dbms/src/IO/WriteBufferValidUTF8.cpp           |  2 +-
 dbms/src/Interpreters/Cluster.h                |  2 +-
 dbms/src/Interpreters/DDLWorker.cpp            |  8 ++++----
 dbms/src/Interpreters/createBlockSelector.cpp  | 18 +++++++++---------
 dbms/src/Interpreters/createBlockSelector.h    |  2 +-
 dbms/src/Parsers/ASTSampleRatio.h              |  6 +++++-
 dbms/src/Storages/MergeTree/DiskSpaceMonitor.h |  2 +-
 .../MergeTreeBaseBlockInputStream.cpp          |  8 ++++----
 .../Storages/MergeTree/MergeTreeDataMerger.cpp |  2 +-
 .../Storages/MergeTree/MergeTreeDataPart.cpp   |  6 +++---
 .../src/Storages/MergeTree/MergeTreeSettings.h |  2 +-
 dbms/src/Storages/MergeTree/MergeTreeSharder.h |  2 +-
 .../ReplicatedMergeTreeCleanupThread.cpp       |  2 +-
 dbms/src/Storages/StorageLog.cpp               |  2 +-
 dbms/src/Storages/StorageStripeLog.cpp         |  2 +-
 dbms/src/Storages/StorageTinyLog.cpp           |  2 +-
 .../Storages/System/StorageSystemColumns.cpp   |  6 +++---
 .../System/StorageSystemDictionaries.cpp       |  8 ++++----
 .../src/Storages/System/StorageSystemParts.cpp | 18 +++++++++---------
 .../Storages/System/StorageSystemProcesses.cpp | 10 +++++-----
 libs/libcommon/cmake/find_gperftools.cmake     |  8 +++++---
 libs/libdaemon/cmake/find_unwind.cmake         |  4 ++--
 37 files changed, 94 insertions(+), 76 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index d98476dca39..fe0838b2ff5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -50,6 +50,13 @@ endif ()
 if (ARCH_AARCH64 OR CMAKE_SYSTEM_PROCESSOR MATCHES "arm")
     set (ARCH_ARM 1)
 endif ()
+if (CMAKE_LIBRARY_ARCHITECTURE MATCHES "i386")
+    set (ARCH_I386 1)
+endif ()
+if ( ( ARCH_ARM AND NOT ARCH_AARCH64 ) OR ARCH_I386)
+    set (ARCH_32 1)
+    message (WARNING "Support 32bit platforms is highly experimental")
+endif ()
 
 set (COMMON_WARNING_FLAGS "-Wall")    # -Werror is also added inside directories with our own code.
 set (CXX_WARNING_FLAGS "-Wnon-virtual-dtor")
@@ -162,7 +169,7 @@ else ()
     set(NOT_UNBUNDLED 1)
 endif ()
 # Using system libs can cause lot of warnings in includes. 
-if (UNBUNDLED OR NOT (CMAKE_SYSTEM MATCHES "Linux" OR APPLE))
+if (UNBUNDLED OR NOT (CMAKE_SYSTEM MATCHES "Linux" OR APPLE) OR ARCH_32)
     option (NO_WERROR "Disable -Werror compiler option" ON)
 endif ()
 
diff --git a/contrib/libzlib-ng/CMakeLists.txt b/contrib/libzlib-ng/CMakeLists.txt
index 4eaf584414d..7054ab81115 100644
--- a/contrib/libzlib-ng/CMakeLists.txt
+++ b/contrib/libzlib-ng/CMakeLists.txt
@@ -334,7 +334,7 @@ else()
     add_feature_info(SSE2 1 "Support the SSE2 instruction set, using \"${SSE2FLAG}\"")
 endif()
 if(WITH_OPTIM)
-    if(NOT ARCH MATCHES "aarch64")
+    if(NOT CMAKE_SYSTEM_PROCESSOR MATCHES "arm")
         set(ZLIB_ARCH_SRCS ${ZLIB_ARCH_SRCS} ${ARCHDIR}/x86.c)
     endif()
     if(HAVE_SSE42_INTRIN)
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionGroupArray.h b/dbms/src/AggregateFunctions/AggregateFunctionGroupArray.h
index c766d8c02d6..398abc3038a 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionGroupArray.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionGroupArray.h
@@ -89,7 +89,7 @@ public:
         }
         else
         {
-            UInt64 elems_to_insert = std::min(max_elems - cur_elems.value.size(), rhs_elems.value.size());
+            UInt64 elems_to_insert = std::min(static_cast<size_t>(max_elems) - cur_elems.value.size(), rhs_elems.value.size());
             cur_elems.value.insert(rhs_elems.value.begin(), rhs_elems.value.begin() + elems_to_insert, arena);
         }
     }
diff --git a/dbms/src/Common/LRUCache.h b/dbms/src/Common/LRUCache.h
index 3acfdcc9b7e..85be0d5d0e4 100644
--- a/dbms/src/Common/LRUCache.h
+++ b/dbms/src/Common/LRUCache.h
@@ -43,7 +43,7 @@ private:
 
 public:
     LRUCache(size_t max_size_, const Delay & expiration_delay_ = Delay::zero())
-        : max_size(std::max(1ul, max_size_)), expiration_delay(expiration_delay_) {}
+        : max_size(std::max(static_cast<size_t>(1), max_size_)), expiration_delay(expiration_delay_) {}
 
     MappedPtr get(const Key & key)
     {
diff --git a/dbms/src/Core/Defines.h b/dbms/src/Core/Defines.h
index 10ba7030836..820b9fc15fd 100644
--- a/dbms/src/Core/Defines.h
+++ b/dbms/src/Core/Defines.h
@@ -44,7 +44,7 @@
 #define DEFAULT_MERGE_BLOCK_SIZE 8192
 
 #define DEFAULT_MAX_QUERY_SIZE 262144
-#define SHOW_CHARS_ON_SYNTAX_ERROR 160L
+#define SHOW_CHARS_ON_SYNTAX_ERROR ptrdiff_t(160)
 #define DEFAULT_MAX_DISTRIBUTED_CONNECTIONS 1024
 #define DEFAULT_INTERACTIVE_DELAY 100000
 #define DBMS_DEFAULT_DISTRIBUTED_CONNECTIONS_POOL_SIZE 1024
@@ -82,7 +82,7 @@
 #define PLATFORM_NOT_SUPPORTED "The only supported platforms are x86_64 and AArch64 (work in progress)"
 
 #if !defined(__x86_64__) && !defined(__aarch64__)
-    #error PLATFORM_NOT_SUPPORTED
+//    #error PLATFORM_NOT_SUPPORTED
 #endif
 
 /// Check for presence of address sanitizer
diff --git a/dbms/src/DataStreams/PrettySpaceBlockOutputStream.cpp b/dbms/src/DataStreams/PrettySpaceBlockOutputStream.cpp
index b9d0b4e2101..2ed5f151a45 100644
--- a/dbms/src/DataStreams/PrettySpaceBlockOutputStream.cpp
+++ b/dbms/src/DataStreams/PrettySpaceBlockOutputStream.cpp
@@ -39,7 +39,7 @@ void PrettySpaceBlockOutputStream::write(const Block & block)
 
         if (col.type->isNumeric())
         {
-            for (ssize_t k = 0; k < std::max(0L, static_cast<ssize_t>(max_widths[i] - name_widths[i])); ++k)
+            for (ssize_t k = 0; k < std::max(static_cast<ssize_t>(0), static_cast<ssize_t>(max_widths[i] - name_widths[i])); ++k)
                 writeChar(' ', ostr);
 
             if (!no_escapes)
@@ -56,7 +56,7 @@ void PrettySpaceBlockOutputStream::write(const Block & block)
             if (!no_escapes)
                 writeCString("\033[0m", ostr);
 
-            for (ssize_t k = 0; k < std::max(0L, static_cast<ssize_t>(max_widths[i] - name_widths[i])); ++k)
+            for (ssize_t k = 0; k < std::max(static_cast<ssize_t>(0), static_cast<ssize_t>(max_widths[i] - name_widths[i])); ++k)
                 writeChar(' ', ostr);
         }
     }
diff --git a/dbms/src/Dictionaries/CacheDictionary.cpp b/dbms/src/Dictionaries/CacheDictionary.cpp
index a991d63f96b..f69fbd607f4 100644
--- a/dbms/src/Dictionaries/CacheDictionary.cpp
+++ b/dbms/src/Dictionaries/CacheDictionary.cpp
@@ -52,7 +52,7 @@ namespace ErrorCodes
 }
 
 
-inline UInt64 CacheDictionary::getCellIdx(const Key id) const
+inline size_t CacheDictionary::getCellIdx(const Key id) const
 {
     const auto hash = intHash64(id);
     const auto idx = hash & size_overlap_mask;
diff --git a/dbms/src/Dictionaries/CacheDictionary.h b/dbms/src/Dictionaries/CacheDictionary.h
index 1ac5edfe6c5..45bfceb16ad 100644
--- a/dbms/src/Dictionaries/CacheDictionary.h
+++ b/dbms/src/Dictionaries/CacheDictionary.h
@@ -214,7 +214,7 @@ private:
 
     bool isEmptyCell(const UInt64 idx) const;
 
-    UInt64 getCellIdx(const Key id) const;
+    size_t getCellIdx(const Key id) const;
 
     void setDefaultAttributeValue(Attribute & attribute, const Key idx) const;
 
@@ -253,7 +253,7 @@ private:
     /// Max tries to find cell, overlaped with mask: if size = 16 and start_cell=10: will try cells: 10,11,12,13,14,15,0,1,2,3
     static constexpr size_t max_collision_length = 10;
 
-    const UInt64 zero_cell_idx{getCellIdx(0)};
+    const size_t zero_cell_idx{getCellIdx(0)};
     std::map<std::string, size_t> attribute_index_by_name;
     mutable std::vector<Attribute> attributes;
     mutable std::vector<CellMetadata> cells;
diff --git a/dbms/src/Dictionaries/TrieDictionary.cpp b/dbms/src/Dictionaries/TrieDictionary.cpp
index bd913a21ea2..ad502b0364b 100644
--- a/dbms/src/Dictionaries/TrieDictionary.cpp
+++ b/dbms/src/Dictionaries/TrieDictionary.cpp
@@ -24,6 +24,7 @@ namespace ErrorCodes
     extern const int ARGUMENT_OUT_OF_BOUND;
     extern const int BAD_ARGUMENTS;
     extern const int DICTIONARY_IS_EMPTY;
+    extern const int NOT_IMPLEMENTED;
 }
 
 TrieDictionary::TrieDictionary(
@@ -598,6 +599,7 @@ Columns TrieDictionary::getKeyColumns() const
     auto ip_column = std::make_shared<ColumnFixedString>(IPV6_BINARY_LENGTH);
     auto mask_column = std::make_shared<ColumnVector<UInt8>>();
 
+#if defined(__SIZEOF_INT128__)
     auto getter = [& ip_column, & mask_column](__uint128_t ip, size_t mask) {
         UInt64 * ip_array = reinterpret_cast<UInt64 *>(&ip);
         ip_array[0] = Poco::ByteOrder::fromNetwork(ip_array[0]);
@@ -608,6 +610,9 @@ Columns TrieDictionary::getKeyColumns() const
     };
 
     trieTraverse<decltype(getter), __uint128_t>(trie, std::move(getter));
+#else
+    throw Exception("TrieDictionary::getKeyColumns is not implemented for 32bit arch", ErrorCodes::NOT_IMPLEMENTED);
+#endif
     return {ip_column, mask_column};
 }
 
diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index 6fae2c7e525..d5fc2cf990e 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -1256,7 +1256,7 @@ void FunctionArrayEnumerate::executeImpl(Block & block, const ColumnNumbers & ar
         Array res_values(values.size());
         for (size_t i = 0; i < values.size(); ++i)
         {
-            res_values[i] = i + 1;
+            res_values[i] = static_cast<UInt64>(i + 1);
         }
 
         block.getByPosition(result).column = block.getByPosition(result).type->createConstColumn(array->size(), res_values);
@@ -1485,7 +1485,7 @@ bool FunctionArrayUniq::executeConst(Block & block, const ColumnNumbers & argume
     for (size_t i = 0; i < values.size(); ++i)
         set.insert(values[i]);
 
-    block.getByPosition(result).column = DataTypeUInt32().createConstColumn(array->size(), set.size());
+    block.getByPosition(result).column = DataTypeUInt32().createConstColumn(array->size(), static_cast<UInt64>(set.size()));
     return true;
 }
 
diff --git a/dbms/src/Functions/FunctionsDateTime.h b/dbms/src/Functions/FunctionsDateTime.h
index 215bc0d5339..e10aff4b05b 100644
--- a/dbms/src/Functions/FunctionsDateTime.h
+++ b/dbms/src/Functions/FunctionsDateTime.h
@@ -651,7 +651,7 @@ public:
     {
         block.getByPosition(result).column = DataTypeUInt32().createConstColumn(
             block.rows(),
-            time(0));
+            static_cast<UInt64>(time(0)));
     }
 };
 
diff --git a/dbms/src/Functions/FunctionsMiscellaneous.cpp b/dbms/src/Functions/FunctionsMiscellaneous.cpp
index 2c41f02a097..7ff48b85bb9 100644
--- a/dbms/src/Functions/FunctionsMiscellaneous.cpp
+++ b/dbms/src/Functions/FunctionsMiscellaneous.cpp
@@ -1301,7 +1301,7 @@ public:
 
     void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override
     {
-        block.getByPosition(result).column = DataTypeUInt32().createConstColumn(block.rows(), uptime);
+        block.getByPosition(result).column = DataTypeUInt32().createConstColumn(block.rows(), static_cast<UInt64>(uptime));
     }
 
 private:
diff --git a/dbms/src/Functions/FunctionsReinterpret.h b/dbms/src/Functions/FunctionsReinterpret.h
index a6bbf5bb92c..5f50e364da4 100644
--- a/dbms/src/Functions/FunctionsReinterpret.h
+++ b/dbms/src/Functions/FunctionsReinterpret.h
@@ -157,7 +157,7 @@ public:
             for (size_t i = 0; i < size; ++i)
             {
                 ToFieldType value = 0;
-                memcpy(&value, &data_from[offset], std::min(sizeof(ToFieldType), offsets_from[i] - offset - 1));
+                memcpy(&value, &data_from[offset], std::min(static_cast<UInt64>(sizeof(ToFieldType)), offsets_from[i] - offset - 1));
                 vec_res[i] = value;
                 offset = offsets_from[i];
             }
diff --git a/dbms/src/IO/MemoryReadWriteBuffer.cpp b/dbms/src/IO/MemoryReadWriteBuffer.cpp
index 7ac9279240c..c007d611ce3 100644
--- a/dbms/src/IO/MemoryReadWriteBuffer.cpp
+++ b/dbms/src/IO/MemoryReadWriteBuffer.cpp
@@ -103,7 +103,7 @@ void MemoryWriteBuffer::addChunk()
     }
     else
     {
-        next_chunk_size = std::max(1ul, static_cast<size_t>(chunk_tail->size() * growth_rate));
+        next_chunk_size = std::max(static_cast<size_t>(1), static_cast<size_t>(chunk_tail->size() * growth_rate));
         next_chunk_size = std::min(next_chunk_size, max_chunk_size);
     }
 
diff --git a/dbms/src/IO/ReadBufferAIO.cpp b/dbms/src/IO/ReadBufferAIO.cpp
index cc6d28c199f..b86aaa0c6e9 100644
--- a/dbms/src/IO/ReadBufferAIO.cpp
+++ b/dbms/src/IO/ReadBufferAIO.cpp
@@ -271,7 +271,7 @@ void ReadBufferAIO::finalize()
     bytes_read -= region_left_padding;
 
     /// Ignore redundant bytes on the right.
-    bytes_read = std::min(bytes_read, static_cast<off_t>(requested_byte_count));
+    bytes_read = std::min(static_cast<off_t>(bytes_read), static_cast<off_t>(requested_byte_count));
 
     if (bytes_read > 0)
         fill_buffer.buffer().resize(region_left_padding + bytes_read);
diff --git a/dbms/src/IO/WriteBufferValidUTF8.cpp b/dbms/src/IO/WriteBufferValidUTF8.cpp
index dddd38b2a10..9aa77b86ff3 100644
--- a/dbms/src/IO/WriteBufferValidUTF8.cpp
+++ b/dbms/src/IO/WriteBufferValidUTF8.cpp
@@ -36,7 +36,7 @@ namespace
 
 WriteBufferValidUTF8::WriteBufferValidUTF8(
     WriteBuffer & output_buffer, bool group_replacements, const char * replacement, size_t size)
-    : BufferWithOwnMemory<WriteBuffer>(std::max(32LU, size)), output_buffer(output_buffer),
+    : BufferWithOwnMemory<WriteBuffer>(std::max(static_cast<size_t>(32), size)), output_buffer(output_buffer),
     group_replacements(group_replacements), replacement(replacement)
 {
 }
diff --git a/dbms/src/Interpreters/Cluster.h b/dbms/src/Interpreters/Cluster.h
index cad36bd6ce8..0dc476bc04f 100644
--- a/dbms/src/Interpreters/Cluster.h
+++ b/dbms/src/Interpreters/Cluster.h
@@ -124,7 +124,7 @@ public:
     std::unique_ptr<Cluster> getClusterWithSingleShard(size_t index) const;
 
 private:
-    using SlotToShard = std::vector<size_t>;
+    using SlotToShard = std::vector<UInt64>;
     SlotToShard slot_to_shard;
 
 public:
diff --git a/dbms/src/Interpreters/DDLWorker.cpp b/dbms/src/Interpreters/DDLWorker.cpp
index fee78388266..ce10deaac96 100644
--- a/dbms/src/Interpreters/DDLWorker.cpp
+++ b/dbms/src/Interpreters/DDLWorker.cpp
@@ -220,7 +220,7 @@ DDLWorker::DDLWorker(const std::string & zk_root_dir, Context & context_, const
     {
         task_max_lifetime = config->getUInt64(prefix + ".task_max_lifetime", static_cast<UInt64>(task_max_lifetime));
         cleanup_delay_period = config->getUInt64(prefix + ".cleanup_delay_period", static_cast<UInt64>(cleanup_delay_period));
-        max_tasks_in_queue = std::max(1UL, config->getUInt64(prefix + ".max_tasks_in_queue", max_tasks_in_queue));
+        max_tasks_in_queue = std::max(static_cast<UInt64>(1), config->getUInt64(prefix + ".max_tasks_in_queue", max_tasks_in_queue));
     }
 
     host_fqdn = getFQDNOrHostName();
@@ -983,7 +983,7 @@ public:
             }
 
             if (num_hosts_finished != 0 || try_number != 0)
-                std::this_thread::sleep_for(std::chrono::milliseconds(50 * std::min(20LU, try_number + 1)));
+                std::this_thread::sleep_for(std::chrono::milliseconds(50 * std::min(static_cast<size_t>(20), try_number + 1)));
 
             /// TODO: add shared lock
             if (!zookeeper->exists(node_path))
@@ -1018,8 +1018,8 @@ public:
                 res.getByName("port").column->insert(static_cast<UInt64>(port));
                 res.getByName("status").column->insert(static_cast<Int64>(status.code));
                 res.getByName("error").column->insert(status.message);
-                res.getByName("num_hosts_remaining").column->insert(waiting_hosts.size() - (++num_hosts_finished));
-                res.getByName("num_hosts_active").column->insert(cur_active_hosts.size());
+                res.getByName("num_hosts_remaining").column->insert(static_cast<UInt64>(waiting_hosts.size() - (++num_hosts_finished)));
+                res.getByName("num_hosts_active").column->insert(static_cast<UInt64>(cur_active_hosts.size()));
             }
         }
 
diff --git a/dbms/src/Interpreters/createBlockSelector.cpp b/dbms/src/Interpreters/createBlockSelector.cpp
index b28c98662cc..59a0183759b 100644
--- a/dbms/src/Interpreters/createBlockSelector.cpp
+++ b/dbms/src/Interpreters/createBlockSelector.cpp
@@ -18,7 +18,7 @@ template <typename T>
 IColumn::Selector createBlockSelector(
     const IColumn & column,
     size_t num_shards,
-    const std::vector<size_t> & slots)
+    const std::vector<UInt64> & slots)
 {
     const auto total_weight = slots.size();
     size_t num_rows = column.size();
@@ -55,13 +55,13 @@ IColumn::Selector createBlockSelector(
 
 
 /// Explicit instantiations to avoid code bloat in headers.
-template IColumn::Selector createBlockSelector<UInt8>(const IColumn & column, size_t num_shards, const std::vector<size_t> & slots);
-template IColumn::Selector createBlockSelector<UInt16>(const IColumn & column, size_t num_shards, const std::vector<size_t> & slots);
-template IColumn::Selector createBlockSelector<UInt32>(const IColumn & column, size_t num_shards, const std::vector<size_t> & slots);
-template IColumn::Selector createBlockSelector<UInt64>(const IColumn & column, size_t num_shards, const std::vector<size_t> & slots);
-template IColumn::Selector createBlockSelector<Int8>(const IColumn & column, size_t num_shards, const std::vector<size_t> & slots);
-template IColumn::Selector createBlockSelector<Int16>(const IColumn & column, size_t num_shards, const std::vector<size_t> & slots);
-template IColumn::Selector createBlockSelector<Int32>(const IColumn & column, size_t num_shards, const std::vector<size_t> & slots);
-template IColumn::Selector createBlockSelector<Int64>(const IColumn & column, size_t num_shards, const std::vector<size_t> & slots);
+template IColumn::Selector createBlockSelector<UInt8>(const IColumn & column, size_t num_shards, const std::vector<UInt64> & slots);
+template IColumn::Selector createBlockSelector<UInt16>(const IColumn & column, size_t num_shards, const std::vector<UInt64> & slots);
+template IColumn::Selector createBlockSelector<UInt32>(const IColumn & column, size_t num_shards, const std::vector<UInt64> & slots);
+template IColumn::Selector createBlockSelector<UInt64>(const IColumn & column, size_t num_shards, const std::vector<UInt64> & slots);
+template IColumn::Selector createBlockSelector<Int8>(const IColumn & column, size_t num_shards, const std::vector<UInt64> & slots);
+template IColumn::Selector createBlockSelector<Int16>(const IColumn & column, size_t num_shards, const std::vector<UInt64> & slots);
+template IColumn::Selector createBlockSelector<Int32>(const IColumn & column, size_t num_shards, const std::vector<UInt64> & slots);
+template IColumn::Selector createBlockSelector<Int64>(const IColumn & column, size_t num_shards, const std::vector<UInt64> & slots);
 
 }
diff --git a/dbms/src/Interpreters/createBlockSelector.h b/dbms/src/Interpreters/createBlockSelector.h
index 065a440913c..ea7d57266b1 100644
--- a/dbms/src/Interpreters/createBlockSelector.h
+++ b/dbms/src/Interpreters/createBlockSelector.h
@@ -22,6 +22,6 @@ template <typename T>
 IColumn::Selector createBlockSelector(
     const IColumn & column,
     size_t num_shards,
-    const std::vector<size_t> & slots);
+    const std::vector<UInt64> & slots);
 
 }
diff --git a/dbms/src/Parsers/ASTSampleRatio.h b/dbms/src/Parsers/ASTSampleRatio.h
index 2924bafdb09..81888cc247c 100644
--- a/dbms/src/Parsers/ASTSampleRatio.h
+++ b/dbms/src/Parsers/ASTSampleRatio.h
@@ -2,7 +2,6 @@
 
 #include <Parsers/IAST.h>
 
-
 namespace DB
 {
 
@@ -12,7 +11,12 @@ namespace DB
 class ASTSampleRatio : public IAST
 {
 public:
+#ifdef __SIZEOF_INT128__
     using BigNum = __uint128_t;    /// Must contain the result of multiplying two UInt64.
+#else
+    // TODO: incomplete temporary fallback. change with boost::multiprecision
+    using BigNum = uint64_t;
+#endif
 
     struct Rational
     {
diff --git a/dbms/src/Storages/MergeTree/DiskSpaceMonitor.h b/dbms/src/Storages/MergeTree/DiskSpaceMonitor.h
index 2ed9c96e68b..d6e22e22acc 100644
--- a/dbms/src/Storages/MergeTree/DiskSpaceMonitor.h
+++ b/dbms/src/Storages/MergeTree/DiskSpaceMonitor.h
@@ -106,7 +106,7 @@ public:
         size_t res = fs.f_bfree * fs.f_bsize;
 
         /// Heuristic by Michael Kolupaev: reserve 30 MB more, because statvfs shows few megabytes more space than df.
-        res -= std::min(res, 30 * (1ul << 20));
+        res -= std::min(res, static_cast<size_t>(30 * (1ul << 20)));
 
         std::lock_guard<std::mutex> lock(mutex);
 
diff --git a/dbms/src/Storages/MergeTree/MergeTreeBaseBlockInputStream.cpp b/dbms/src/Storages/MergeTree/MergeTreeBaseBlockInputStream.cpp
index 7486bf84e00..ab21fa52db8 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeBaseBlockInputStream.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeBaseBlockInputStream.cpp
@@ -189,7 +189,7 @@ Block MergeTreeBaseBlockInputStream::readFromPart()
             size_t recommended_rows = estimateNumRows(*task, *pre_range_reader);
             if (res && recommended_rows < 1)
                 break;
-            size_t space_left = std::max(1LU, std::min(max_block_size_rows, recommended_rows));
+            size_t space_left = std::max(static_cast<decltype(max_block_size_rows)>(1), std::min(max_block_size_rows, recommended_rows));
 
             while ((pre_range_reader || !task->mark_ranges.empty()) && space_left && !isCancelled())
             {
@@ -437,7 +437,7 @@ Block MergeTreeBaseBlockInputStream::readFromPart()
     }
     else
     {
-        size_t space_left = std::max(1LU, max_block_size_rows);
+        size_t space_left = std::max(static_cast<decltype(max_block_size_rows)>(1), max_block_size_rows);
         while (!task->isFinished() && space_left && !isCancelled())
         {
             if (!task->current_range_reader)
@@ -451,7 +451,7 @@ Block MergeTreeBaseBlockInputStream::readFromPart()
             size_t recommended_rows = estimateNumRows(*task, *task->current_range_reader);
             if (res && recommended_rows < 1)
                 break;
-            rows_to_read = std::min(rows_to_read, std::max(1LU, recommended_rows));
+            rows_to_read = std::min(rows_to_read, std::max(static_cast<decltype(recommended_rows)>(1), recommended_rows));
 
             size_t rows_was_read = task->current_range_reader->read(res, rows_to_read);
             if (task->current_range_reader->isReadingFinished())
@@ -497,7 +497,7 @@ void MergeTreeBaseBlockInputStream::injectVirtualColumns(Block & block)
             else if (virt_column_name == "_part_index")
             {
                 block.insert(ColumnWithTypeAndName{
-                    DataTypeUInt64().createConstColumn(rows, task->part_index_in_query)->convertToFullColumnIfConst(),
+                    DataTypeUInt64().createConstColumn(rows, static_cast<UInt64>(task->part_index_in_query))->convertToFullColumnIfConst(),
                     std::make_shared<DataTypeUInt64>(),
                     virt_column_name});
             }
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataMerger.cpp b/dbms/src/Storages/MergeTree/MergeTreeDataMerger.cpp
index 18d6ad133ee..c9638a1137f 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataMerger.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataMerger.cpp
@@ -352,7 +352,7 @@ public:
         for (const auto & name : ordinary_columns)
             sum_ordinary_columns += map.at(name);
 
-        sum_total = std::max(1UL, sum_index_columns + sum_ordinary_columns);
+        sum_total = std::max(static_cast<decltype(sum_index_columns)>(1), sum_index_columns + sum_ordinary_columns);
     }
 
     /// Approximate size of num_rows column elements if column contains num_total_rows elements
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp b/dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp
index c3daa3939dc..0b86571a25f 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp
@@ -636,7 +636,7 @@ void MergeTreeDataPart::loadIndex()
 
         String index_path = getFullPath() + "primary.idx";
         ReadBufferFromFile index_file(index_path,
-            std::min(static_cast<size_t>(DBMS_DEFAULT_BUFFER_SIZE), Poco::File(index_path).getSize()));
+            std::min(static_cast<Poco::File::FileSize>(DBMS_DEFAULT_BUFFER_SIZE), Poco::File(index_path).getSize()));
 
         for (size_t i = 0; i < size; ++i)
             for (size_t j = 0; j < key_size; ++j)
@@ -679,7 +679,7 @@ void MergeTreeDataPart::loadChecksums(bool require)
 
         return;
     }
-    ReadBufferFromFile file(path, std::min(static_cast<size_t>(DBMS_DEFAULT_BUFFER_SIZE), Poco::File(path).getSize()));
+    ReadBufferFromFile file(path, std::min(static_cast<Poco::File::FileSize>(DBMS_DEFAULT_BUFFER_SIZE), Poco::File(path).getSize()));
     if (checksums.read(file))
         assertEOF(file);
 }
@@ -717,7 +717,7 @@ void MergeTreeDataPart::loadColumns(bool require)
         return;
     }
 
-    ReadBufferFromFile file(path, std::min(static_cast<size_t>(DBMS_DEFAULT_BUFFER_SIZE), Poco::File(path).getSize()));
+    ReadBufferFromFile file(path, std::min(static_cast<Poco::File::FileSize>(DBMS_DEFAULT_BUFFER_SIZE), Poco::File(path).getSize()));
     columns.readText(file);
 }
 
diff --git a/dbms/src/Storages/MergeTree/MergeTreeSettings.h b/dbms/src/Storages/MergeTree/MergeTreeSettings.h
index 5f89b888492..80608b79101 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeSettings.h
+++ b/dbms/src/Storages/MergeTree/MergeTreeSettings.h
@@ -22,7 +22,7 @@ struct MergeTreeSettings
     /** Merge settings. */
 
     /// Maximum in total size of parts to merge, when there are maximum (minimum) free threads in background pool (or entries in replication queue).
-    size_t max_bytes_to_merge_at_max_space_in_pool = 150ULL * 1024 * 1024 * 1024;
+    size_t max_bytes_to_merge_at_max_space_in_pool = size_t(150) * 1024 * 1024 * 1024;
     size_t max_bytes_to_merge_at_min_space_in_pool = 1024 * 1024;
 
     /// How many tasks of merging parts are allowed simultaneously in ReplicatedMergeTree queue.
diff --git a/dbms/src/Storages/MergeTree/MergeTreeSharder.h b/dbms/src/Storages/MergeTree/MergeTreeSharder.h
index b80a61fe9ad..f6b8e829264 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeSharder.h
+++ b/dbms/src/Storages/MergeTree/MergeTreeSharder.h
@@ -50,7 +50,7 @@ private:
     MergeTreeData & data;
     const ReshardingJob & job;
     Logger * log;
-    std::vector<size_t> slots;
+    std::vector<UInt64> slots;
     ExpressionActionsPtr sharding_key_expr;
     std::string sharding_key_column_name;
 };
diff --git a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeCleanupThread.cpp b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeCleanupThread.cpp
index 3283ca1d988..dbcd0deb18d 100644
--- a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeCleanupThread.cpp
+++ b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeCleanupThread.cpp
@@ -159,7 +159,7 @@ void ReplicatedMergeTreeCleanupThread::clearOldBlocks()
 
     /// Use ZooKeeper's first node (last according to time) timestamp as "current" time.
     Int64 current_time = timed_blocks.front().stat.ctime;
-    Int64 time_threshold = std::max(0L, current_time - static_cast<Int64>(1000 * storage.data.settings.replicated_deduplication_window_seconds));
+    Int64 time_threshold = std::max(static_cast<Int64>(0), current_time - static_cast<Int64>(1000 * storage.data.settings.replicated_deduplication_window_seconds));
 
     /// Virtual node, all nodes that are "greater" than this one will be deleted
     NodeWithStat block_threshold("", RequiredStat(time_threshold));
diff --git a/dbms/src/Storages/StorageLog.cpp b/dbms/src/Storages/StorageLog.cpp
index 25cd948ed5a..2bcdc6e1a57 100644
--- a/dbms/src/Storages/StorageLog.cpp
+++ b/dbms/src/Storages/StorageLog.cpp
@@ -111,7 +111,7 @@ private:
     struct Stream
     {
         Stream(const std::string & data_path, size_t offset, size_t max_read_buffer_size)
-            : plain(data_path, std::min(max_read_buffer_size, Poco::File(data_path).getSize())),
+            : plain(data_path, std::min(static_cast<Poco::File::FileSize>(max_read_buffer_size), Poco::File(data_path).getSize())),
             compressed(plain)
         {
             if (offset)
diff --git a/dbms/src/Storages/StorageStripeLog.cpp b/dbms/src/Storages/StorageStripeLog.cpp
index af6d271262b..fc7fe894b71 100644
--- a/dbms/src/Storages/StorageStripeLog.cpp
+++ b/dbms/src/Storages/StorageStripeLog.cpp
@@ -72,7 +72,7 @@ protected:
 
             data_in.emplace(
                 storage.full_path() + "data.bin", 0, 0,
-                std::min(max_read_buffer_size, Poco::File(storage.full_path() + "data.bin").getSize()));
+                std::min(static_cast<Poco::File::FileSize>(max_read_buffer_size), Poco::File(storage.full_path() + "data.bin").getSize()));
 
             block_in.emplace(*data_in, 0, true, index_begin, index_end);
         }
diff --git a/dbms/src/Storages/StorageTinyLog.cpp b/dbms/src/Storages/StorageTinyLog.cpp
index b7f23b16108..484fe417d30 100644
--- a/dbms/src/Storages/StorageTinyLog.cpp
+++ b/dbms/src/Storages/StorageTinyLog.cpp
@@ -76,7 +76,7 @@ private:
     struct Stream
     {
         Stream(const std::string & data_path, size_t max_read_buffer_size)
-            : plain(data_path, std::min(max_read_buffer_size, Poco::File(data_path).getSize())),
+            : plain(data_path, std::min(static_cast<Poco::File::FileSize>(max_read_buffer_size), Poco::File(data_path).getSize())),
             compressed(plain)
         {
         }
diff --git a/dbms/src/Storages/System/StorageSystemColumns.cpp b/dbms/src/Storages/System/StorageSystemColumns.cpp
index a6dcf155227..79e11be949c 100644
--- a/dbms/src/Storages/System/StorageSystemColumns.cpp
+++ b/dbms/src/Storages/System/StorageSystemColumns.cpp
@@ -193,9 +193,9 @@ BlockInputStreams StorageSystemColumns::read(
                 }
                 else
                 {
-                    data_compressed_bytes_column->insert(it->second.data_compressed);
-                    data_uncompressed_bytes_column->insert(it->second.data_uncompressed);
-                    marks_bytes_column->insert(it->second.marks);
+                    data_compressed_bytes_column->insert(static_cast<UInt64>(it->second.data_compressed));
+                    data_uncompressed_bytes_column->insert(static_cast<UInt64>(it->second.data_uncompressed));
+                    marks_bytes_column->insert(static_cast<UInt64>(it->second.marks));
                 }
             }
         }
diff --git a/dbms/src/Storages/System/StorageSystemDictionaries.cpp b/dbms/src/Storages/System/StorageSystemDictionaries.cpp
index 4c5c7544ea4..62f00b00323 100644
--- a/dbms/src/Storages/System/StorageSystemDictionaries.cpp
+++ b/dbms/src/Storages/System/StorageSystemDictionaries.cpp
@@ -98,12 +98,12 @@ BlockInputStreams StorageSystemDictionaries::read(
             col_attribute_types.column->insert(ext::map<Array>(dict_struct.attributes, [] (auto & attr) -> decltype(auto) {
                 return attr.type->getName();
             }));
-            col_bytes_allocated.column->insert(dict_ptr->getBytesAllocated());
-            col_query_count.column->insert(dict_ptr->getQueryCount());
+            col_bytes_allocated.column->insert(static_cast<UInt64>(dict_ptr->getBytesAllocated()));
+            col_query_count.column->insert(static_cast<UInt64>(dict_ptr->getQueryCount()));
             col_hit_rate.column->insert(dict_ptr->getHitRate());
-            col_element_count.column->insert(dict_ptr->getElementCount());
+            col_element_count.column->insert(static_cast<UInt64>(dict_ptr->getElementCount()));
             col_load_factor.column->insert(dict_ptr->getLoadFactor());
-            col_creation_time.column->insert(std::chrono::system_clock::to_time_t(dict_ptr->getCreationTime()));
+            col_creation_time.column->insert(static_cast<UInt64>(std::chrono::system_clock::to_time_t(dict_ptr->getCreationTime())));
             col_source.column->insert(dict_ptr->getSource()->toString());
         }
         else
diff --git a/dbms/src/Storages/System/StorageSystemParts.cpp b/dbms/src/Storages/System/StorageSystemParts.cpp
index 15f6d5d156c..a93b1a08724 100644
--- a/dbms/src/Storages/System/StorageSystemParts.cpp
+++ b/dbms/src/Storages/System/StorageSystemParts.cpp
@@ -205,7 +205,7 @@ BlockInputStreams StorageSystemParts::read(
             block.getByPosition(i++).column->insert(part->info.partition_id);
             block.getByPosition(i++).column->insert(part->name);
             block.getByPosition(i++).column->insert(static_cast<UInt64>(active_parts.count(part)));
-            block.getByPosition(i++).column->insert(part->size);
+            block.getByPosition(i++).column->insert(static_cast<UInt64>(part->size));
 
             size_t marks_size = 0;
             for (const NameAndTypePair & it : part->columns)
@@ -215,23 +215,23 @@ BlockInputStreams StorageSystemParts::read(
                 if (checksum != part->checksums.files.end())
                     marks_size += checksum->second.file_size;
             }
-            block.getByPosition(i++).column->insert(marks_size);
+            block.getByPosition(i++).column->insert(static_cast<UInt64>(marks_size));
 
-            block.getByPosition(i++).column->insert(part->getExactSizeRows());
-            block.getByPosition(i++).column->insert(static_cast<size_t>(part->size_in_bytes));
-            block.getByPosition(i++).column->insert(part->modification_time);
-            block.getByPosition(i++).column->insert(part->remove_time);
+            block.getByPosition(i++).column->insert(static_cast<UInt64>(part->getExactSizeRows()));
+            block.getByPosition(i++).column->insert(static_cast<UInt64>(part->size_in_bytes));
+            block.getByPosition(i++).column->insert(static_cast<UInt64>(part->modification_time));
+            block.getByPosition(i++).column->insert(static_cast<UInt64>(part->remove_time));
 
             /// For convenience, in returned refcount, don't add references that was due to local variables in this method: all_parts, active_parts.
-            block.getByPosition(i++).column->insert(part.use_count() - (active_parts.count(part) ? 2 : 1));
+            block.getByPosition(i++).column->insert(static_cast<UInt64>(part.use_count() - (active_parts.count(part) ? 2 : 1)));
 
             block.getByPosition(i++).column->insert(static_cast<UInt64>(part->getMinDate()));
             block.getByPosition(i++).column->insert(static_cast<UInt64>(part->getMaxDate()));
             block.getByPosition(i++).column->insert(part->info.min_block);
             block.getByPosition(i++).column->insert(part->info.max_block);
             block.getByPosition(i++).column->insert(static_cast<UInt64>(part->info.level));
-            block.getByPosition(i++).column->insert(part->getIndexSizeInBytes());
-            block.getByPosition(i++).column->insert(part->getIndexSizeInAllocatedBytes());
+            block.getByPosition(i++).column->insert(static_cast<UInt64>(part->getIndexSizeInBytes()));
+            block.getByPosition(i++).column->insert(static_cast<UInt64>(part->getIndexSizeInAllocatedBytes()));
 
             block.getByPosition(i++).column->insert(database);
             block.getByPosition(i++).column->insert(table);
diff --git a/dbms/src/Storages/System/StorageSystemProcesses.cpp b/dbms/src/Storages/System/StorageSystemProcesses.cpp
index 4b5d3e4fa3e..19f09964d38 100644
--- a/dbms/src/Storages/System/StorageSystemProcesses.cpp
+++ b/dbms/src/Storages/System/StorageSystemProcesses.cpp
@@ -91,11 +91,11 @@ BlockInputStreams StorageSystemProcesses::read(
         block.getByPosition(i++).column->insert(process.client_info.http_user_agent);
         block.getByPosition(i++).column->insert(process.client_info.quota_key);
         block.getByPosition(i++).column->insert(process.elapsed_seconds);
-        block.getByPosition(i++).column->insert(process.read_rows);
-        block.getByPosition(i++).column->insert(process.read_bytes);
-        block.getByPosition(i++).column->insert(process.total_rows);
-        block.getByPosition(i++).column->insert(process.written_rows);
-        block.getByPosition(i++).column->insert(process.written_bytes);
+        block.getByPosition(i++).column->insert(UInt64(process.read_rows));
+        block.getByPosition(i++).column->insert(UInt64(process.read_bytes));
+        block.getByPosition(i++).column->insert(UInt64(process.total_rows));
+        block.getByPosition(i++).column->insert(UInt64(process.written_rows));
+        block.getByPosition(i++).column->insert(UInt64(process.written_bytes));
         block.getByPosition(i++).column->insert(process.memory_usage);
         block.getByPosition(i++).column->insert(process.query);
     }
diff --git a/libs/libcommon/cmake/find_gperftools.cmake b/libs/libcommon/cmake/find_gperftools.cmake
index ff95e2a480a..bbec87d72f9 100644
--- a/libs/libcommon/cmake/find_gperftools.cmake
+++ b/libs/libcommon/cmake/find_gperftools.cmake
@@ -1,4 +1,4 @@
-if (CMAKE_SYSTEM MATCHES "FreeBSD")
+if (CMAKE_SYSTEM MATCHES "FreeBSD" OR ARCH_32)
     option (USE_INTERNAL_GPERFTOOLS_LIBRARY "Set to FALSE to use system gperftools (tcmalloc) library instead of bundled" OFF)
 else ()
     option (USE_INTERNAL_GPERFTOOLS_LIBRARY "Set to FALSE to use system gperftools (tcmalloc) library instead of bundled" ${NOT_UNBUNDLED})
@@ -12,13 +12,15 @@ if (ENABLE_LIBTCMALLOC)
         find_package (Gperftools)
     endif ()
 
-    if (NOT (GPERFTOOLS_FOUND AND GPERFTOOLS_INCLUDE_DIR AND GPERFTOOLS_TCMALLOC_MINIMAL))
+    if (NOT (GPERFTOOLS_FOUND AND GPERFTOOLS_INCLUDE_DIR AND GPERFTOOLS_TCMALLOC_MINIMAL) AND NOT (CMAKE_SYSTEM MATCHES "FreeBSD" OR ARCH_32))
         set (USE_INTERNAL_GPERFTOOLS_LIBRARY 1)
         set (GPERFTOOLS_INCLUDE_DIR "${ClickHouse_SOURCE_DIR}/contrib/libtcmalloc/include")
         set (GPERFTOOLS_TCMALLOC_MINIMAL tcmalloc_minimal_internal)
     endif ()
 
-    set (USE_TCMALLOC 1)
+    if (GPERFTOOLS_FOUND OR USE_INTERNAL_GPERFTOOLS_LIBRARY)
+        set (USE_TCMALLOC 1)
+    endif ()
 
     message (STATUS "Using tcmalloc=${USE_TCMALLOC}: ${GPERFTOOLS_INCLUDE_DIR} : ${GPERFTOOLS_TCMALLOC_MINIMAL}")
 endif ()
diff --git a/libs/libdaemon/cmake/find_unwind.cmake b/libs/libdaemon/cmake/find_unwind.cmake
index 80b2c746c7c..1567fa4892e 100644
--- a/libs/libdaemon/cmake/find_unwind.cmake
+++ b/libs/libdaemon/cmake/find_unwind.cmake
@@ -1,7 +1,7 @@
 include (CMakePushCheckState)
 cmake_push_check_state ()
 
-if (CMAKE_SYSTEM MATCHES "Linux" AND NOT ARCH_ARM)
+if (CMAKE_SYSTEM MATCHES "Linux" AND NOT ARCH_ARM AND NOT ARCH_32)
     option (USE_INTERNAL_UNWIND_LIBRARY "Set to FALSE to use system unwind library instead of bundled" ${NOT_UNBUNDLED})
 else ()
     option (USE_INTERNAL_UNWIND_LIBRARY "Set to FALSE to use system unwind library instead of bundled" OFF)
@@ -34,7 +34,7 @@ endif ()
 
 if (UNWIND_LIBRARY AND UNWIND_INCLUDE_DIR)
     set (USE_UNWIND 1)
-elseif (CMAKE_SYSTEM MATCHES "Linux" AND NOT ARCH_ARM)
+elseif (CMAKE_SYSTEM MATCHES "Linux" AND NOT ARCH_ARM AND NOT ARCH_32)
     set (USE_INTERNAL_UNWIND_LIBRARY 1)
     set (UNWIND_INCLUDE_DIR "${ClickHouse_SOURCE_DIR}/contrib/libunwind/include")
     set (UNWIND_LIBRARY unwind)

From 32ed1b0b41befa4a6f37b28441c4cc8348dee622 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 20:41:43 +0300
Subject: [PATCH 045/266] fix arrasSlice for gereric arrays [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index 6c4b3d4edcb..c0ded6b8b97 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -897,7 +897,7 @@ inline ALWAYS_INLINE void writeSlice(const StringSource::Slice & slice, FixedStr
 /// Assuming same types of underlying columns for slice and sink if (ArraySlice, ArraySink) is (GenericArraySlice, GenericArraySink).
 inline ALWAYS_INLINE void writeSlice(const GenericArraySlice & slice, GenericArraySink & sink)
 {
-    if (typeid(slice.elements) == typeid(&sink.elements))
+    if (typeid(slice.elements) == typeid(static_cast<const IColumn *>(&sink.elements)))
         sink.elements.insertRangeFrom(*slice.elements, slice.begin, slice.size);
     else
         throw Exception("Function writeSlice expect same column types for GenericArraySlice and GenericArraySink.",

From add3f920fffa19d2b29fdc46b5b6e63201fd03c1 Mon Sep 17 00:00:00 2001
From: Vitaliy Lyudvichenko <vludv@yandex-team.ru>
Date: Fri, 1 Sep 2017 00:11:25 +0300
Subject: [PATCH 046/266] RWLockFIFO implementation. [#CLICKHOUSE-3246]

---
 dbms/src/Common/RWLockFIFO.cpp                |  81 ++++++++++++++
 dbms/src/Common/RWLockFIFO.h                  | 105 ++++++++++++++++++
 .../Common/tests/gtest_rw_lock_fifo.cpp.cpp   |  79 +++++++++++++
 3 files changed, 265 insertions(+)
 create mode 100644 dbms/src/Common/RWLockFIFO.cpp
 create mode 100644 dbms/src/Common/RWLockFIFO.h
 create mode 100644 dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp

diff --git a/dbms/src/Common/RWLockFIFO.cpp b/dbms/src/Common/RWLockFIFO.cpp
new file mode 100644
index 00000000000..c46dfea346f
--- /dev/null
+++ b/dbms/src/Common/RWLockFIFO.cpp
@@ -0,0 +1,81 @@
+#include <boost/core/noncopyable.hpp>
+#include "RWLockFIFO.h"
+
+namespace DB
+{
+
+
+RWLockFIFO::LockHandler RWLockFIFO::getLock(RWLockFIFO::Type type, RWLockFIFO::Client client)
+{
+    GroupsContainer::iterator it_group;
+    ClientsContainer::iterator it_client;
+
+    std::unique_lock<std::mutex> lock(mutex);
+
+
+    if (type == Type::Write || queue.empty() || queue.back().type == Type::Write)
+    {
+        /// Create new group of clients
+        it_group = queue.emplace(queue.end(), type);
+    }
+    else
+    {
+        /// Will append myself to last group
+        it_group = std::prev(queue.end());
+    }
+
+    /// Append myself to the end of chosen group
+    auto & clients = it_group->clients;
+    try
+    {
+        it_client = clients.emplace(clients.end(), std::move(client));
+    }
+    catch (...)
+    {
+        /// Remove group if it was the first client in the group and an error occurred
+        if (clients.empty())
+            queue.erase(it_group);
+        throw;
+    }
+
+    LockHandler res = std::make_unique<LockHandlerImpl>(shared_from_this(), it_group, it_client);
+
+    /// We are first, we should not wait anything
+    /// If we are not the first client in the group, a notification could be already sent
+    if (it_group == queue.begin())
+        return res;
+
+    /// Wait a notification
+    it_group->cv.wait(lock, [&it_group] () { return it_group->awakened; } );
+    return res;
+}
+
+
+void RWLockFIFO::LockHandlerImpl::unlock()
+{
+    std::unique_lock<std::mutex> lock(parent->mutex);
+
+    auto & clients = it_group->clients;
+    clients.erase(it_client);
+
+    if (clients.empty())
+    {
+        auto & queue = parent->queue;
+        queue.erase(it_group);
+
+        if (!queue.empty())
+        {
+            queue.front().awakened = true;
+            queue.front().cv.notify_all();
+        }
+    }
+}
+
+
+RWLockFIFO::LockHandlerImpl::~LockHandlerImpl()
+{
+    unlock();
+}
+
+
+}
diff --git a/dbms/src/Common/RWLockFIFO.h b/dbms/src/Common/RWLockFIFO.h
new file mode 100644
index 00000000000..2e3005438b2
--- /dev/null
+++ b/dbms/src/Common/RWLockFIFO.h
@@ -0,0 +1,105 @@
+#pragma once
+#include <list>
+#include <mutex>
+#include <condition_variable>
+#include <Common/Exception.h>
+
+
+namespace DB
+{
+
+
+namespace ErrorCodes
+{
+    extern const int LOGICAL_ERROR;
+}
+
+
+struct RWLockFIFO;
+using RWLockFIFOPtr = std::shared_ptr<RWLockFIFO>;
+
+
+/// Implements shared lock with FIFO service
+class RWLockFIFO : public std::enable_shared_from_this<RWLockFIFO>
+{
+public:
+
+    static RWLockFIFOPtr create()
+    {
+        return RWLockFIFOPtr(new RWLockFIFO);
+    }
+
+    enum Type
+    {
+        Read,
+        Write
+    };
+
+    /// Client is that who wants to acquire the lock.
+    struct Client
+    {
+        explicit Client(const std::string & info = "Anonymous client") : info{info} {}
+        std::string info;
+    };
+
+    class LockHandlerImpl;
+    using LockHandler = std::unique_ptr<LockHandlerImpl>;
+
+    /// Waits in the queue and returns appropriate lock
+    LockHandler getLock(Type type, Client client);
+
+    LockHandler getLock(Type type, const std::string & who)
+    {
+        return getLock(type, Client(who));
+    }
+
+private:
+
+    RWLockFIFO() = default;
+
+    struct Group;
+    using GroupsContainer = std::list<Group>;
+    using ClientsContainer = std::list<Client>;
+
+    /// Group of clients that should be executed concurrently
+    /// i.e. a group could contain several readers, but only one writer
+    struct Group
+    {
+        const Type type;
+        ClientsContainer clients;
+
+        std::condition_variable cv; /// all clients of the group wait group condvar
+        bool awakened{false}; /// just only to handle spurious wake ups
+
+        explicit Group(Type type) : type{type} {}
+    };
+
+public:
+
+    class LockHandlerImpl
+    {
+        RWLockFIFOPtr parent;
+        GroupsContainer::iterator it_group;
+        ClientsContainer::iterator it_client;
+
+    public:
+        LockHandlerImpl(RWLockFIFOPtr && parent, GroupsContainer::iterator it_group, ClientsContainer::iterator it_client)
+                : parent{std::move(parent)}, it_group{it_group}, it_client{it_client} {}
+
+        LockHandlerImpl(const LockHandlerImpl & other) = delete;
+
+        void unlock();
+
+        ~LockHandlerImpl();
+
+        friend class RWLockFIFO;
+    };
+
+private:
+
+    std::mutex mutex;
+    GroupsContainer queue;
+};
+
+
+}
diff --git a/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp b/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp
new file mode 100644
index 00000000000..827058a2d20
--- /dev/null
+++ b/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp
@@ -0,0 +1,79 @@
+#include <gtest/gtest.h>
+#include <Common/RWLockFIFO.h>
+#include <Common/Stopwatch.h>
+#include <common/Types.h>
+#include <common/ThreadPool.h>
+#include <random>
+#include <thread>
+#include <atomic>
+#include <iomanip>
+
+
+using namespace DB;
+
+static void execute_1(size_t threads, int round, int cycles)
+{
+    static std::atomic<int> readers{0};
+    static std::atomic<int> writers{0};
+
+    static auto fifo_lock = RWLockFIFO::create();
+
+    static __thread std::random_device rd;
+    static __thread std::mt19937 gen(rd());
+
+    for (int  i = 0; i < cycles; ++i)
+    {
+        auto type = (std::uniform_int_distribution<>(0, 9)(gen) >= round) ? RWLockFIFO::Read : RWLockFIFO::Write;
+        auto sleep_for = std::chrono::duration<int, std::micro>(std::uniform_int_distribution<>(1, 5)(gen));
+
+        auto lock = fifo_lock->getLock(type, "RW");
+
+        if (type == RWLockFIFO::Write)
+        {
+            ++writers;
+
+            ASSERT_EQ(writers, 1);
+            ASSERT_EQ(readers, 0);
+
+            std::this_thread::sleep_for(sleep_for);
+
+            --writers;
+        }
+        else
+        {
+            ++readers;
+
+            ASSERT_EQ(writers, 0);
+            ASSERT_GE(readers, 1);
+            ASSERT_LE(readers, threads);
+
+            std::this_thread::sleep_for(sleep_for);
+
+            --readers;
+        }
+    }
+}
+
+TEST(Common, RWLockFIFO_1)
+{
+    constexpr int cycles = 10000;
+
+    for (size_t pool_size = 1; pool_size < 8; ++pool_size)
+    {
+        for (int round = 0; round < 10; ++round)
+        {
+            Stopwatch watch(CLOCK_MONOTONIC_COARSE);
+
+            std::vector<std::thread> threads;
+            threads.reserve(pool_size);
+            for (int thread = 0; thread < pool_size; ++thread)
+                threads.emplace_back([=] () { execute_1(pool_size, round, cycles); });
+
+            for (auto & thread : threads)
+                thread.join();
+
+            auto total_time = watch.elapsedSeconds();
+            std::cout << "Threads " << pool_size << ", round " << round << ", total_time " << std::setprecision(2) << total_time << "\n";
+        }
+    }
+}

From 566160c0486e4d1a7a9adf7f357cf7653a13d858 Mon Sep 17 00:00:00 2001
From: Vitaliy Lyudvichenko <vludv@yandex-team.ru>
Date: Fri, 1 Sep 2017 18:05:23 +0300
Subject: [PATCH 047/266] Use FIFO lock in IStorage. [#CLICKHOUSE-3246]

---
 dbms/src/Common/RWLockFIFO.cpp                | 42 +++++++++++++++----
 dbms/src/Common/RWLockFIFO.h                  | 29 +++++++------
 .../Common/tests/gtest_rw_lock_fifo.cpp.cpp   |  5 ++-
 .../PushingToViewsBlockOutputStream.h         |  2 +-
 .../Interpreters/InterpreterCreateQuery.cpp   |  4 +-
 .../Interpreters/InterpreterDescribeQuery.cpp |  2 +-
 .../src/Interpreters/InterpreterDropQuery.cpp |  4 +-
 .../Interpreters/InterpreterInsertQuery.cpp   |  2 +-
 .../Interpreters/InterpreterOptimizeQuery.cpp |  2 +-
 .../Interpreters/InterpreterRenameQuery.cpp   |  2 +-
 .../Interpreters/InterpreterSelectQuery.cpp   |  2 +-
 dbms/src/Storages/IStorage.cpp                |  8 ++--
 dbms/src/Storages/IStorage.h                  | 37 +++++++++-------
 .../Storages/MergeTree/DataPartsExchange.cpp  |  2 +-
 .../ReplicatedMergeTreeAlterThread.cpp        |  4 +-
 .../ReplicatedMergeTreePartCheckThread.cpp    |  2 +-
 .../MergeTree/ShardedPartitionUploader.cpp    |  2 +-
 dbms/src/Storages/StorageBuffer.cpp           |  2 +-
 dbms/src/Storages/StorageDistributed.cpp      |  2 +-
 dbms/src/Storages/StorageMerge.cpp            |  4 +-
 dbms/src/Storages/StorageMergeTree.cpp        | 12 +++---
 .../Storages/StorageReplicatedMergeTree.cpp   | 10 ++---
 dbms/src/Storages/StorageTrivialBuffer.cpp    |  2 +-
 .../Storages/System/StorageSystemColumns.cpp  |  2 +-
 .../Storages/System/StorageSystemParts.cpp    |  2 +-
 25 files changed, 113 insertions(+), 74 deletions(-)

diff --git a/dbms/src/Common/RWLockFIFO.cpp b/dbms/src/Common/RWLockFIFO.cpp
index c46dfea346f..2367ee6f76f 100644
--- a/dbms/src/Common/RWLockFIFO.cpp
+++ b/dbms/src/Common/RWLockFIFO.cpp
@@ -1,5 +1,8 @@
-#include <boost/core/noncopyable.hpp>
 #include "RWLockFIFO.h"
+#include <Common/Exception.h>
+#include <iostream>
+#include <Poco/Ext/ThreadNumber.h>
+
 
 namespace DB
 {
@@ -12,7 +15,6 @@ RWLockFIFO::LockHandler RWLockFIFO::getLock(RWLockFIFO::Type type, RWLockFIFO::C
 
     std::unique_lock<std::mutex> lock(mutex);
 
-
     if (type == Type::Write || queue.empty() || queue.back().type == Type::Write)
     {
         /// Create new group of clients
@@ -38,15 +40,41 @@ RWLockFIFO::LockHandler RWLockFIFO::getLock(RWLockFIFO::Type type, RWLockFIFO::C
         throw;
     }
 
+    it_client->thread_number = Poco::ThreadNumber::get();
+    it_client->enqueue_time = time(nullptr);
+    it_client->type = type;
+
     LockHandler res = std::make_unique<LockHandlerImpl>(shared_from_this(), it_group, it_client);
 
     /// We are first, we should not wait anything
     /// If we are not the first client in the group, a notification could be already sent
     if (it_group == queue.begin())
+    {
+        it_client->start_time = it_client->enqueue_time;
         return res;
+    }
 
     /// Wait a notification
-    it_group->cv.wait(lock, [&it_group] () { return it_group->awakened; } );
+    it_group->cv.wait(lock, [&] () { return it_group == queue.begin(); } );
+
+    it_client->start_time = time(nullptr);
+    return res;
+}
+
+
+RWLockFIFO::Clients RWLockFIFO::getClientsInTheQueue() const
+{
+    std::unique_lock<std::mutex> lock(mutex);
+
+    Clients res;
+    for (const auto & group : queue)
+    {
+        for (const auto & client : group.clients)
+        {
+            res.emplace_back(client);
+        }
+    }
+
     return res;
 }
 
@@ -64,17 +92,17 @@ void RWLockFIFO::LockHandlerImpl::unlock()
         queue.erase(it_group);
 
         if (!queue.empty())
-        {
-            queue.front().awakened = true;
             queue.front().cv.notify_all();
-        }
     }
+
+    parent.reset();
 }
 
 
 RWLockFIFO::LockHandlerImpl::~LockHandlerImpl()
 {
-    unlock();
+    if (parent)
+        unlock();
 }
 
 
diff --git a/dbms/src/Common/RWLockFIFO.h b/dbms/src/Common/RWLockFIFO.h
index 2e3005438b2..0cdcbe67ec3 100644
--- a/dbms/src/Common/RWLockFIFO.h
+++ b/dbms/src/Common/RWLockFIFO.h
@@ -1,25 +1,20 @@
 #pragma once
+#include <boost/core/noncopyable.hpp>
 #include <list>
+#include <vector>
 #include <mutex>
 #include <condition_variable>
-#include <Common/Exception.h>
 
 
 namespace DB
 {
 
-
-namespace ErrorCodes
-{
-    extern const int LOGICAL_ERROR;
-}
-
-
 struct RWLockFIFO;
 using RWLockFIFOPtr = std::shared_ptr<RWLockFIFO>;
 
 
 /// Implements shared lock with FIFO service
+/// It does not work as recursive mutex, so a deadlock will occur if you try to acquire 2 locks in the same thread
 class RWLockFIFO : public std::enable_shared_from_this<RWLockFIFO>
 {
 public:
@@ -38,21 +33,31 @@ public:
     /// Client is that who wants to acquire the lock.
     struct Client
     {
-        explicit Client(const std::string & info = "Anonymous client") : info{info} {}
+        explicit Client(const std::string & info = {}) : info{info} {}
+
         std::string info;
+        int thread_number = 0;
+        std::time_t enqueue_time = 0;
+        std::time_t start_time = 0;
+        Type type;
     };
 
     class LockHandlerImpl;
     using LockHandler = std::unique_ptr<LockHandlerImpl>;
 
     /// Waits in the queue and returns appropriate lock
-    LockHandler getLock(Type type, Client client);
+    LockHandler getLock(Type type, Client client = Client{});
 
     LockHandler getLock(Type type, const std::string & who)
     {
         return getLock(type, Client(who));
     }
 
+    using Clients = std::vector<Client>;
+
+    /// Returns list of executing and waiting clients
+    Clients getClientsInTheQueue() const;
+
 private:
 
     RWLockFIFO() = default;
@@ -69,7 +74,6 @@ private:
         ClientsContainer clients;
 
         std::condition_variable cv; /// all clients of the group wait group condvar
-        bool awakened{false}; /// just only to handle spurious wake ups
 
         explicit Group(Type type) : type{type} {}
     };
@@ -88,6 +92,7 @@ public:
 
         LockHandlerImpl(const LockHandlerImpl & other) = delete;
 
+        /// Unlocks acquired lock
         void unlock();
 
         ~LockHandlerImpl();
@@ -97,7 +102,7 @@ public:
 
 private:
 
-    std::mutex mutex;
+    mutable std::mutex mutex;
     GroupsContainer queue;
 };
 
diff --git a/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp b/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp
index 827058a2d20..63a29bbe567 100644
--- a/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp
+++ b/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp
@@ -24,7 +24,7 @@ static void execute_1(size_t threads, int round, int cycles)
     for (int  i = 0; i < cycles; ++i)
     {
         auto type = (std::uniform_int_distribution<>(0, 9)(gen) >= round) ? RWLockFIFO::Read : RWLockFIFO::Write;
-        auto sleep_for = std::chrono::duration<int, std::micro>(std::uniform_int_distribution<>(1, 5)(gen));
+        auto sleep_for = std::chrono::duration<int, std::micro>(std::uniform_int_distribution<>(1, 1000)(gen));
 
         auto lock = fifo_lock->getLock(type, "RW");
 
@@ -57,8 +57,9 @@ static void execute_1(size_t threads, int round, int cycles)
 TEST(Common, RWLockFIFO_1)
 {
     constexpr int cycles = 10000;
+    const std::vector<size_t> pool_sizes{1, 2, 4, 8};
 
-    for (size_t pool_size = 1; pool_size < 8; ++pool_size)
+    for (auto pool_size : pool_sizes)
     {
         for (int round = 0; round < 10; ++round)
         {
diff --git a/dbms/src/DataStreams/PushingToViewsBlockOutputStream.h b/dbms/src/DataStreams/PushingToViewsBlockOutputStream.h
index 3236d44a2d1..dba48d34cdf 100644
--- a/dbms/src/DataStreams/PushingToViewsBlockOutputStream.h
+++ b/dbms/src/DataStreams/PushingToViewsBlockOutputStream.h
@@ -26,7 +26,7 @@ public:
           * Although now any insertion into the table is done via PushingToViewsBlockOutputStream,
           *  but it's clear that here is not the best place for this functionality.
           */
-        addTableLock(storage->lockStructure(true));
+        addTableLock(storage->lockStructure(true, __PRETTY_FUNCTION__));
 
         Dependencies dependencies = context.getDependencies(database, table);
         for (const auto & database_table : dependencies)
diff --git a/dbms/src/Interpreters/InterpreterCreateQuery.cpp b/dbms/src/Interpreters/InterpreterCreateQuery.cpp
index 80536a76a15..3be60614bd2 100644
--- a/dbms/src/Interpreters/InterpreterCreateQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterCreateQuery.cpp
@@ -506,7 +506,7 @@ BlockIO InterpreterCreateQuery::createTable(ASTCreateQuery & create)
     if (!as_table_name.empty())
     {
         as_storage = context.getTable(as_database_name, as_table_name);
-        as_storage_lock = as_storage->lockStructure(false);
+        as_storage_lock = as_storage->lockStructure(false, __PRETTY_FUNCTION__);
     }
 
     /// Set and retrieve list of columns.
@@ -557,7 +557,7 @@ BlockIO InterpreterCreateQuery::createTable(ASTCreateQuery & create)
     /// If the CREATE SELECT query is, insert the data into the table
     if (create.select && storage_name != "View" && (storage_name != "MaterializedView" || create.is_populate))
     {
-        auto table_lock = res->lockStructure(true);
+        auto table_lock = res->lockStructure(true, __PRETTY_FUNCTION__);
 
         /// Also see InterpreterInsertQuery.
         BlockOutputStreamPtr out =
diff --git a/dbms/src/Interpreters/InterpreterDescribeQuery.cpp b/dbms/src/Interpreters/InterpreterDescribeQuery.cpp
index 12983d0705e..11e8ca92fe7 100644
--- a/dbms/src/Interpreters/InterpreterDescribeQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterDescribeQuery.cpp
@@ -60,7 +60,7 @@ BlockInputStreamPtr InterpreterDescribeQuery::executeImpl()
 
     {
         StoragePtr table = context.getTable(ast.database, ast.table);
-        auto table_lock = table->lockStructure(false);
+        auto table_lock = table->lockStructure(false, __PRETTY_FUNCTION__);
         columns = table->getColumnsList();
         columns.insert(std::end(columns), std::begin(table->alias_columns), std::end(table->alias_columns));
         column_defaults = table->column_defaults;
diff --git a/dbms/src/Interpreters/InterpreterDropQuery.cpp b/dbms/src/Interpreters/InterpreterDropQuery.cpp
index ae25c53ea1d..cefb092820f 100644
--- a/dbms/src/Interpreters/InterpreterDropQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterDropQuery.cpp
@@ -53,7 +53,7 @@ BlockIO InterpreterDropQuery::execute()
         {
             table->shutdown();
             /// If table was already dropped by anyone, an exception will be thrown
-            auto table_lock = table->lockForAlter();
+            auto table_lock = table->lockForAlter(__PRETTY_FUNCTION__);
             /// Delete table data
             table->drop();
             table->is_dropped = true;
@@ -116,7 +116,7 @@ BlockIO InterpreterDropQuery::execute()
         table.first->shutdown();
 
         /// If table was already dropped by anyone, an exception will be thrown
-        auto table_lock = table.first->lockForAlter();
+        auto table_lock = table.first->lockForAlter(__PRETTY_FUNCTION__);
 
         String current_table_name = table.first->getTableName();
 
diff --git a/dbms/src/Interpreters/InterpreterInsertQuery.cpp b/dbms/src/Interpreters/InterpreterInsertQuery.cpp
index 72d093c9408..e3ceec26f75 100644
--- a/dbms/src/Interpreters/InterpreterInsertQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterInsertQuery.cpp
@@ -86,7 +86,7 @@ BlockIO InterpreterInsertQuery::execute()
     ASTInsertQuery & query = typeid_cast<ASTInsertQuery &>(*query_ptr);
     StoragePtr table = getTable();
 
-    auto table_lock = table->lockStructure(true);
+    auto table_lock = table->lockStructure(true, __PRETTY_FUNCTION__);
 
     NamesAndTypesListPtr required_columns = std::make_shared<NamesAndTypesList>(table->getColumnsList());
 
diff --git a/dbms/src/Interpreters/InterpreterOptimizeQuery.cpp b/dbms/src/Interpreters/InterpreterOptimizeQuery.cpp
index 42c6901acc8..c9bce30271c 100644
--- a/dbms/src/Interpreters/InterpreterOptimizeQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterOptimizeQuery.cpp
@@ -22,7 +22,7 @@ BlockIO InterpreterOptimizeQuery::execute()
         throw Exception("FINAL flag for OPTIMIZE query is meaningful only with specified PARTITION", ErrorCodes::BAD_ARGUMENTS);
 
     StoragePtr table = context.getTable(ast.database, ast.table);
-    auto table_lock = table->lockStructure(true);
+    auto table_lock = table->lockStructure(true, __PRETTY_FUNCTION__);
     table->optimize(query_ptr, ast.partition, ast.final, ast.deduplicate, context.getSettings());
     return {};
 }
diff --git a/dbms/src/Interpreters/InterpreterRenameQuery.cpp b/dbms/src/Interpreters/InterpreterRenameQuery.cpp
index 6e33d068648..d626e80a06b 100644
--- a/dbms/src/Interpreters/InterpreterRenameQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterRenameQuery.cpp
@@ -100,7 +100,7 @@ BlockIO InterpreterRenameQuery::execute()
 
     for (const auto & names : unique_tables_from)
         if (auto table = context.tryGetTable(names.database_name, names.table_name))
-            locks.emplace_back(table->lockForAlter());
+            locks.emplace_back(table->lockForAlter(__PRETTY_FUNCTION__));
 
     /** All tables are locked. If there are more than one rename in chain,
       *  we need to hold global lock while doing all renames. Order matters to avoid deadlocks.
diff --git a/dbms/src/Interpreters/InterpreterSelectQuery.cpp b/dbms/src/Interpreters/InterpreterSelectQuery.cpp
index f5f2659afb5..c5518e7de35 100644
--- a/dbms/src/Interpreters/InterpreterSelectQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterSelectQuery.cpp
@@ -156,7 +156,7 @@ void InterpreterSelectQuery::basicInit(BlockInputStreamPtr input_)
             storage = context.getTable(database_name, table_name);
         }
 
-        table_lock = storage->lockStructure(false);
+        table_lock = storage->lockStructure(false, __PRETTY_FUNCTION__);
         if (table_column_names.empty())
             table_column_names = storage->getColumnsListNonMaterialized();
     }
diff --git a/dbms/src/Storages/IStorage.cpp b/dbms/src/Storages/IStorage.cpp
index 628d0e34d93..70d016566d4 100644
--- a/dbms/src/Storages/IStorage.cpp
+++ b/dbms/src/Storages/IStorage.cpp
@@ -4,13 +4,13 @@
 namespace DB
 {
 
-TableStructureReadLock::TableStructureReadLock(StoragePtr storage_, bool lock_structure, bool lock_data)
-    : storage(storage_), data_lock(storage->data_lock, std::defer_lock), structure_lock(storage->structure_lock, std::defer_lock)
+TableStructureReadLock::TableStructureReadLock(StoragePtr storage_, bool lock_structure, bool lock_data, const std::string & who)
+    : storage(storage_)
 {
     if (lock_data)
-        data_lock.lock();
+        data_lock = storage->data_lock->getLock(RWLockFIFO::Read, who);
     if (lock_structure)
-        structure_lock.lock();
+        structure_lock = storage->structure_lock->getLock(RWLockFIFO::Read, who);
 }
 
 }
diff --git a/dbms/src/Storages/IStorage.h b/dbms/src/Storages/IStorage.h
index b0a87f74ca5..685480177a4 100644
--- a/dbms/src/Storages/IStorage.h
+++ b/dbms/src/Storages/IStorage.h
@@ -2,6 +2,7 @@
 
 #include <Core/Names.h>
 #include <Common/Exception.h>
+#include <Common/RWLockFIFO.h>
 #include <Core/QueryProcessingStage.h>
 #include <Storages/ITableDeclaration.h>
 #include <Storages/SelectQueryInfo.h>
@@ -22,6 +23,9 @@ class Context;
 class IBlockInputStream;
 class IBlockOutputStream;
 
+struct RWLockFIFO;
+using RWLockFIFOPtr = std::shared_ptr<RWLockFIFO>;
+
 using BlockOutputStreamPtr = std::shared_ptr<IBlockOutputStream>;
 using BlockInputStreamPtr = std::shared_ptr<IBlockInputStream>;
 using BlockInputStreams = std::vector<BlockInputStreamPtr>;
@@ -54,18 +58,19 @@ private:
 
     StoragePtr storage;
     /// Order is important.
-    std::shared_lock<std::shared_mutex> data_lock;
-    std::shared_lock<std::shared_mutex> structure_lock;
+    RWLockFIFO::LockHandler data_lock;
+    RWLockFIFO::LockHandler structure_lock;
 
 public:
-    TableStructureReadLock(StoragePtr storage_, bool lock_structure, bool lock_data);
+    TableStructureReadLock(StoragePtr storage_, bool lock_structure, bool lock_data, const std::string & who);
 };
 
+
 using TableStructureReadLockPtr = std::shared_ptr<TableStructureReadLock>;
 using TableStructureReadLocks = std::vector<TableStructureReadLockPtr>;
 
-using TableStructureWriteLock = std::unique_lock<std::shared_mutex>;
-using TableDataWriteLock = std::unique_lock<std::shared_mutex>;
+using TableStructureWriteLock = RWLockFIFO::LockHandler;
+using TableDataWriteLock = RWLockFIFO::LockHandler;
 using TableFullWriteLock = std::pair<TableDataWriteLock, TableStructureWriteLock>;
 
 
@@ -107,9 +112,9 @@ public:
       * WARNING: You need to call methods from ITableDeclaration under such a lock. Without it, they are not thread safe.
       * WARNING: To avoid deadlocks, this method must not be called under lock of Context.
       */
-    TableStructureReadLockPtr lockStructure(bool will_modify_data)
+    TableStructureReadLockPtr lockStructure(bool will_modify_data, const std::string & who = "Anonymous")
     {
-        TableStructureReadLockPtr res = std::make_shared<TableStructureReadLock>(shared_from_this(), true, will_modify_data);
+        TableStructureReadLockPtr res = std::make_shared<TableStructureReadLock>(shared_from_this(), true, will_modify_data, who);
         if (is_dropped)
             throw Exception("Table is dropped", ErrorCodes::TABLE_IS_DROPPED);
         return res;
@@ -117,11 +122,11 @@ public:
 
     /** Does not allow reading the table structure. It is taken for ALTER, RENAME and DROP.
       */
-    TableFullWriteLock lockForAlter()
+    TableFullWriteLock lockForAlter(const std::string & who = "Alter")
     {
         /// The calculation order is important.
-        auto data_lock = lockDataForAlter();
-        auto structure_lock = lockStructureForAlter();
+        auto data_lock = lockDataForAlter(who);
+        auto structure_lock = lockStructureForAlter(who);
 
         return {std::move(data_lock), std::move(structure_lock)};
     }
@@ -130,17 +135,17 @@ public:
       * It is taken during write temporary data in ALTER MODIFY.
       * Under this lock, you can take lockStructureForAlter() to change the structure of the table.
       */
-    TableDataWriteLock lockDataForAlter()
+    TableDataWriteLock lockDataForAlter(const std::string & who = "Alter")
     {
-        std::unique_lock<std::shared_mutex> res(data_lock);
+        auto res = data_lock->getLock(RWLockFIFO::Write, who);
         if (is_dropped)
             throw Exception("Table is dropped", ErrorCodes::TABLE_IS_DROPPED);
         return res;
     }
 
-    TableStructureWriteLock lockStructureForAlter()
+    TableStructureWriteLock lockStructureForAlter(const std::string & who = "Alter")
     {
-        std::unique_lock<std::shared_mutex> res(structure_lock);
+        auto res = structure_lock->getLock(RWLockFIFO::Write, who);
         if (is_dropped)
             throw Exception("Table is dropped", ErrorCodes::TABLE_IS_DROPPED);
         return res;
@@ -316,7 +321,7 @@ private:
       *  2) all changes to the data after releasing the lock will be based on the structure of the table at the time after the lock was released.
       * You need to take for read for the entire time of the operation that changes the data.
       */
-    mutable std::shared_mutex data_lock;
+    mutable RWLockFIFOPtr data_lock = RWLockFIFO::create();
 
     /** Lock for multiple columns and path to table. It is taken for write at RENAME, ALTER (for ALTER MODIFY for a while) and DROP.
       * It is taken for read for the whole time of SELECT, INSERT and merge parts (for MergeTree).
@@ -325,7 +330,7 @@ private:
       * That is, if this lock is taken for write, you should not worry about `parts_writing_lock`.
       * parts_writing_lock is only needed for cases when you do not want to take `table_structure_lock` for long operations (ALTER MODIFY).
       */
-    mutable std::shared_mutex structure_lock;
+    mutable RWLockFIFOPtr structure_lock = RWLockFIFO::create();
 };
 
 /// table name -> table
diff --git a/dbms/src/Storages/MergeTree/DataPartsExchange.cpp b/dbms/src/Storages/MergeTree/DataPartsExchange.cpp
index b68a0207c66..f914da23ffc 100644
--- a/dbms/src/Storages/MergeTree/DataPartsExchange.cpp
+++ b/dbms/src/Storages/MergeTree/DataPartsExchange.cpp
@@ -77,7 +77,7 @@ void Service::processQuery(const Poco::Net::HTMLForm & params, ReadBuffer & body
 
     try
     {
-        auto storage_lock = owned_storage->lockStructure(false);
+        auto storage_lock = owned_storage->lockStructure(false, __PRETTY_FUNCTION__);
 
         MergeTreeData::DataPartPtr part;
 
diff --git a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeAlterThread.cpp b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeAlterThread.cpp
index 766a9c4f3c8..8de62e18852 100644
--- a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeAlterThread.cpp
+++ b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeAlterThread.cpp
@@ -82,7 +82,7 @@ void ReplicatedMergeTreeAlterThread::run()
 
                     LOG_INFO(log, "Changed version of 'columns' node in ZooKeeper. Waiting for structure write lock.");
 
-                    auto table_lock = storage.lockStructureForAlter();
+                    auto table_lock = storage.lockStructureForAlter(__PRETTY_FUNCTION__);
 
                     const auto columns_changed = columns != storage.data.getColumnsListNonMaterialized();
                     const auto materialized_columns_changed = materialized_columns != storage.data.materialized_columns;
@@ -140,7 +140,7 @@ void ReplicatedMergeTreeAlterThread::run()
                 /// Update parts.
                 if (changed_version || force_recheck_parts)
                 {
-                    auto table_lock = storage.lockStructure(false);
+                    auto table_lock = storage.lockStructure(false, __PRETTY_FUNCTION__);
 
                     if (changed_version)
                         LOG_INFO(log, "ALTER-ing parts");
diff --git a/dbms/src/Storages/MergeTree/ReplicatedMergeTreePartCheckThread.cpp b/dbms/src/Storages/MergeTree/ReplicatedMergeTreePartCheckThread.cpp
index bb7ae636b7c..e17c87e030a 100644
--- a/dbms/src/Storages/MergeTree/ReplicatedMergeTreePartCheckThread.cpp
+++ b/dbms/src/Storages/MergeTree/ReplicatedMergeTreePartCheckThread.cpp
@@ -218,7 +218,7 @@ void ReplicatedMergeTreePartCheckThread::checkPart(const String & part_name)
     else if (part->name == part_name)
     {
         auto zookeeper = storage.getZooKeeper();
-        auto table_lock = storage.lockStructure(false);
+        auto table_lock = storage.lockStructure(false, __PRETTY_FUNCTION__);
 
         /// If the part is in ZooKeeper, check its data with its checksums, and them with ZooKeeper.
         if (zookeeper->exists(storage.replica_path + "/parts/" + part_name))
diff --git a/dbms/src/Storages/MergeTree/ShardedPartitionUploader.cpp b/dbms/src/Storages/MergeTree/ShardedPartitionUploader.cpp
index 7d3dd4aa6cd..73f0da0912d 100644
--- a/dbms/src/Storages/MergeTree/ShardedPartitionUploader.cpp
+++ b/dbms/src/Storages/MergeTree/ShardedPartitionUploader.cpp
@@ -143,7 +143,7 @@ bool Client::send(const std::string & part_name, size_t shard_no,
 
     LOG_TRACE(log, "Sending part " << part_name);
 
-    auto storage_lock = storage.lockStructure(false);
+    auto storage_lock = storage.lockStructure(false, __PRETTY_FUNCTION__);
 
     MergeTreeData::DataPartPtr part = findShardedPart(part_name, shard_no);
 
diff --git a/dbms/src/Storages/StorageBuffer.cpp b/dbms/src/Storages/StorageBuffer.cpp
index 90ffaab12a2..e8241fec0ad 100644
--- a/dbms/src/Storages/StorageBuffer.cpp
+++ b/dbms/src/Storages/StorageBuffer.cpp
@@ -592,7 +592,7 @@ void StorageBuffer::alter(const AlterCommands & params, const String & database_
         if (param.type == AlterCommand::MODIFY_PRIMARY_KEY)
             throw Exception("Storage engine " + getName() + " doesn't support primary key.", ErrorCodes::NOT_IMPLEMENTED);
 
-    auto lock = lockStructureForAlter();
+    auto lock = lockStructureForAlter(__PRETTY_FUNCTION__);
 
     /// So that no blocks of the old structure remain.
     optimize({} /*query*/, {} /*partition_id*/, false /*final*/, false /*deduplicate*/, context.getSettings());
diff --git a/dbms/src/Storages/StorageDistributed.cpp b/dbms/src/Storages/StorageDistributed.cpp
index 7b75cb54497..f389c57f8b8 100644
--- a/dbms/src/Storages/StorageDistributed.cpp
+++ b/dbms/src/Storages/StorageDistributed.cpp
@@ -246,7 +246,7 @@ void StorageDistributed::alter(const AlterCommands & params, const String & data
         if (param.type == AlterCommand::MODIFY_PRIMARY_KEY)
             throw Exception("Storage engine " + getName() + " doesn't support primary key.", ErrorCodes::NOT_IMPLEMENTED);
 
-    auto lock = lockStructureForAlter();
+    auto lock = lockStructureForAlter(__PRETTY_FUNCTION__);
     params.apply(*columns, materialized_columns, alias_columns, column_defaults);
 
     context.getDatabase(database_name)->alterTable(
diff --git a/dbms/src/Storages/StorageMerge.cpp b/dbms/src/Storages/StorageMerge.cpp
index 5d1502daed7..d5a33ba1323 100644
--- a/dbms/src/Storages/StorageMerge.cpp
+++ b/dbms/src/Storages/StorageMerge.cpp
@@ -335,7 +335,7 @@ StorageMerge::StorageListWithLocks StorageMerge::getSelectedTables() const
         {
             auto & table = iterator->table();
             if (table.get() != this)
-                selected_tables.emplace_back(table, table->lockStructure(false));
+                selected_tables.emplace_back(table, table->lockStructure(false, __PRETTY_FUNCTION__));
         }
 
         iterator->next();
@@ -351,7 +351,7 @@ void StorageMerge::alter(const AlterCommands & params, const String & database_n
         if (param.type == AlterCommand::MODIFY_PRIMARY_KEY)
             throw Exception("Storage engine " + getName() + " doesn't support primary key.", ErrorCodes::NOT_IMPLEMENTED);
 
-    auto lock = lockStructureForAlter();
+    auto lock = lockStructureForAlter(__PRETTY_FUNCTION__);
     params.apply(*columns, materialized_columns, alias_columns, column_defaults);
 
     context.getDatabase(database_name)->alterTable(
diff --git a/dbms/src/Storages/StorageMergeTree.cpp b/dbms/src/Storages/StorageMergeTree.cpp
index 4525dd667dc..41caba6cf14 100644
--- a/dbms/src/Storages/StorageMergeTree.cpp
+++ b/dbms/src/Storages/StorageMergeTree.cpp
@@ -151,7 +151,7 @@ void StorageMergeTree::alter(
     /// NOTE: Here, as in ReplicatedMergeTree, you can do ALTER which does not block the writing of data for a long time.
     auto merge_blocker = merger.cancel();
 
-    auto table_soft_lock = lockDataForAlter();
+    auto table_soft_lock = lockDataForAlter(__PRETTY_FUNCTION__);
 
     data.checkAlter(params);
 
@@ -194,7 +194,7 @@ void StorageMergeTree::alter(
             transactions.push_back(std::move(transaction));
     }
 
-    auto table_hard_lock = lockStructureForAlter();
+    auto table_hard_lock = lockStructureForAlter(__PRETTY_FUNCTION__);
 
     IDatabase::ASTModifier engine_modifier;
     if (primary_key_is_modified)
@@ -293,7 +293,7 @@ bool StorageMergeTree::merge(
         data.clearOldTemporaryDirectories();
     }
 
-    auto structure_lock = lockStructure(true);
+    auto structure_lock = lockStructure(true, __PRETTY_FUNCTION__);
 
     size_t disk_space = DiskSpaceMonitor::getUnreservedFreeSpace(full_path);
 
@@ -402,8 +402,8 @@ void StorageMergeTree::clearColumnInPartition(const ASTPtr & query, const Field
     /// This protects against "revival" of data for a removed partition after completion of merge.
     auto merge_blocker = merger.cancel();
 
-    auto lock_read_structure = lockStructure(false);
-    auto lock_write_data = lockDataForAlter();
+    /// We don't change table structure, only data in some parts, parts are locked inside alterDataPart() function
+    auto lock_read_structure = lockStructure(false, __PRETTY_FUNCTION__);
 
     String partition_id = data.getPartitionIDFromQuery(partition);
     MergeTreeData::DataParts parts = data.getDataParts();
@@ -452,7 +452,7 @@ void StorageMergeTree::dropPartition(const ASTPtr & query, const Field & partiti
     /// This protects against "revival" of data for a removed partition after completion of merge.
     auto merge_blocker = merger.cancel();
     /// Waits for completion of merge and does not start new ones.
-    auto lock = lockForAlter();
+    auto lock = lockForAlter(__PRETTY_FUNCTION__);
 
     String partition_id = data.getPartitionIDFromQuery(partition);
 
diff --git a/dbms/src/Storages/StorageReplicatedMergeTree.cpp b/dbms/src/Storages/StorageReplicatedMergeTree.cpp
index c2b5280884b..ef5728b9f04 100644
--- a/dbms/src/Storages/StorageReplicatedMergeTree.cpp
+++ b/dbms/src/Storages/StorageReplicatedMergeTree.cpp
@@ -1065,7 +1065,7 @@ bool StorageReplicatedMergeTree::executeLogEntry(const LogEntry & entry)
             /// Can throw an exception.
             DiskSpaceMonitor::ReservationPtr reserved_space = DiskSpaceMonitor::reserve(full_path, estimated_space_for_merge);
 
-            auto table_lock = lockStructure(false);
+            auto table_lock = lockStructure(false, __PRETTY_FUNCTION__);
 
             MergeList::EntryPtr merge_entry = context.getMergeList().insert(database_name, table_name, entry.new_part_name, parts);
             MergeTreeData::Transaction transaction;
@@ -1430,7 +1430,7 @@ void StorageReplicatedMergeTree::executeClearColumnInPartition(const LogEntry &
     /// We don't change table structure, only data in some parts
     /// To disable reading from these parts, we will sequentially acquire write lock for each part inside alterDataPart()
     /// If we will lock the whole table here, a deadlock can occur. For example, if use use Buffer table (CLICKHOUSE-3238)
-    auto lock_read_structure = lockStructure(false);
+    auto lock_read_structure = lockStructure(false, __PRETTY_FUNCTION__);
 
     auto zookeeper = getZooKeeper();
 
@@ -2107,7 +2107,7 @@ bool StorageReplicatedMergeTree::fetchPart(const String & part_name, const Strin
 
     TableStructureReadLockPtr table_lock;
     if (!to_detached)
-        table_lock = lockStructure(true);
+        table_lock = lockStructure(true, __PRETTY_FUNCTION__);
 
     ReplicatedMergeTreeAddress address(getZooKeeper()->get(replica_path + "/host"));
 
@@ -2408,7 +2408,7 @@ void StorageReplicatedMergeTree::alter(const AlterCommands & params,
 
     {
         /// Just to read current structure. Alter will be done in separate thread.
-        auto table_lock = lockStructure(false);
+        auto table_lock = lockStructure(false, __PRETTY_FUNCTION__);
 
         if (is_readonly)
             throw Exception("Can't ALTER readonly table", ErrorCodes::TABLE_IS_READ_ONLY);
@@ -3788,7 +3788,7 @@ void StorageReplicatedMergeTree::clearOldPartsAndRemoveFromZK(Logger * log_)
 
     Logger * log = log_ ? log_ : this->log;
 
-    auto table_lock = lockStructure(false);
+    auto table_lock = lockStructure(false, __PRETTY_FUNCTION__);
     auto zookeeper = getZooKeeper();
 
     MergeTreeData::DataPartsVector parts = data.grabOldParts();
diff --git a/dbms/src/Storages/StorageTrivialBuffer.cpp b/dbms/src/Storages/StorageTrivialBuffer.cpp
index e205905865f..9dafe302766 100644
--- a/dbms/src/Storages/StorageTrivialBuffer.cpp
+++ b/dbms/src/Storages/StorageTrivialBuffer.cpp
@@ -536,7 +536,7 @@ void StorageTrivialBuffer::alter(
             throw Exception("Storage engine " + getName() + " doesn't support primary key.",
                     ErrorCodes::NOT_IMPLEMENTED);
 
-    auto lock = lockStructureForAlter();
+    auto lock = lockStructureForAlter(__PRETTY_FUNCTION__);
 
     /// To avoid presence of blocks of different structure in the buffer.
     flush(false);
diff --git a/dbms/src/Storages/System/StorageSystemColumns.cpp b/dbms/src/Storages/System/StorageSystemColumns.cpp
index 79e11be949c..b0df8444fcb 100644
--- a/dbms/src/Storages/System/StorageSystemColumns.cpp
+++ b/dbms/src/Storages/System/StorageSystemColumns.cpp
@@ -130,7 +130,7 @@ BlockInputStreams StorageSystemColumns::read(
 
             try
             {
-                table_lock = storage->lockStructure(false);
+                table_lock = storage->lockStructure(false, __PRETTY_FUNCTION__);
             }
             catch (const Exception & e)
             {
diff --git a/dbms/src/Storages/System/StorageSystemParts.cpp b/dbms/src/Storages/System/StorageSystemParts.cpp
index a93b1a08724..3b053aed166 100644
--- a/dbms/src/Storages/System/StorageSystemParts.cpp
+++ b/dbms/src/Storages/System/StorageSystemParts.cpp
@@ -163,7 +163,7 @@ BlockInputStreams StorageSystemParts::read(
 
         try
         {
-            table_lock = storage->lockStructure(false);    /// For table not to be dropped.
+            table_lock = storage->lockStructure(false, __PRETTY_FUNCTION__);    /// For table not to be dropped.
         }
         catch (const Exception & e)
         {

From 88c9dcbb3d3e1c1722f8fa0f11f6e27b20f437ad Mon Sep 17 00:00:00 2001
From: Vitaliy Lyudvichenko <vludv@yandex-team.ru>
Date: Fri, 1 Sep 2017 20:11:41 +0300
Subject: [PATCH 048/266] Changed method signature. [#CLICKHOUSE-3246]

---
 dbms/src/Storages/IStorage.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/dbms/src/Storages/IStorage.h b/dbms/src/Storages/IStorage.h
index 685480177a4..eac1930016f 100644
--- a/dbms/src/Storages/IStorage.h
+++ b/dbms/src/Storages/IStorage.h
@@ -108,11 +108,12 @@ public:
     /** Does not allow you to change the structure or name of the table.
       * If you change the data in the table, you will need to specify will_modify_data = true.
       * This will take an extra lock that does not allow starting ALTER MODIFY.
+      * Parameter 'who' identifies a client of the lock (ALTER query, merge process, etc), used for diagnostic purposes.
       *
       * WARNING: You need to call methods from ITableDeclaration under such a lock. Without it, they are not thread safe.
       * WARNING: To avoid deadlocks, this method must not be called under lock of Context.
       */
-    TableStructureReadLockPtr lockStructure(bool will_modify_data, const std::string & who = "Anonymous")
+    TableStructureReadLockPtr lockStructure(bool will_modify_data, const std::string & who)
     {
         TableStructureReadLockPtr res = std::make_shared<TableStructureReadLock>(shared_from_this(), true, will_modify_data, who);
         if (is_dropped)

From 20766debb0dae0efaa68586c849e7c25a9bcdf64 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Fri, 1 Sep 2017 21:01:06 +0300
Subject: [PATCH 049/266] fix arrasSlice for gereric arrays [#CLICKHOUSE-2090]

---
 dbms/src/Functions/GatherUtils.h | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/dbms/src/Functions/GatherUtils.h b/dbms/src/Functions/GatherUtils.h
index c0ded6b8b97..4edafb84f43 100644
--- a/dbms/src/Functions/GatherUtils.h
+++ b/dbms/src/Functions/GatherUtils.h
@@ -898,7 +898,10 @@ inline ALWAYS_INLINE void writeSlice(const StringSource::Slice & slice, FixedStr
 inline ALWAYS_INLINE void writeSlice(const GenericArraySlice & slice, GenericArraySink & sink)
 {
     if (typeid(slice.elements) == typeid(static_cast<const IColumn *>(&sink.elements)))
+    {
         sink.elements.insertRangeFrom(*slice.elements, slice.begin, slice.size);
+        sink.current_offset += slice.size;
+    }
     else
         throw Exception("Function writeSlice expect same column types for GenericArraySlice and GenericArraySink.",
                         ErrorCodes::LOGICAL_ERROR);

From 2af874716450b4c53af669931c3c2c17cc486480 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 1 Sep 2017 21:21:01 +0300
Subject: [PATCH 050/266] Removed obsolete code [#CLICKHOUSE-3270].

---
 dbms/src/Columns/ColumnAggregateFunction.cpp           |  4 ++--
 dbms/src/Columns/ColumnArray.cpp                       |  2 +-
 dbms/src/Columns/IColumn.h                             |  2 +-
 dbms/src/Common/typeid_cast.h                          |  1 +
 dbms/src/DataStreams/BinaryRowInputStream.cpp          |  2 +-
 .../BlockOutputStreamFromRowOutputStream.cpp           |  2 +-
 dbms/src/DataStreams/CSVRowInputStream.cpp             |  2 +-
 dbms/src/DataStreams/IRowOutputStream.cpp              |  2 +-
 dbms/src/DataStreams/JSONEachRowRowInputStream.cpp     |  4 ++--
 dbms/src/DataStreams/ODBCDriverBlockOutputStream.cpp   |  2 +-
 dbms/src/DataStreams/TSKVRowInputStream.cpp            |  4 ++--
 dbms/src/DataStreams/TabSeparatedBlockOutputStream.cpp |  2 +-
 dbms/src/DataStreams/TabSeparatedRowInputStream.cpp    |  2 +-
 dbms/src/DataStreams/ValuesRowInputStream.cpp          |  4 ++--
 dbms/src/DataStreams/VerticalRowOutputStream.cpp       |  2 +-
 dbms/src/DataTypes/DataTypeAggregateFunction.cpp       |  4 ++--
 dbms/src/Storages/MergeTree/MergeTreeData.cpp          |  4 ++--
 dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp      | 10 +++++-----
 .../Storages/MergeTree/MergeTreeDataSelectExecutor.cpp |  2 +-
 dbms/src/Storages/MergeTree/MergeTreePartChecker.cpp   |  4 ++--
 dbms/src/Storages/MergeTree/MergeTreeReader.cpp        |  2 +-
 .../src/Storages/MergeTree/MergedBlockOutputStream.cpp |  6 +++---
 dbms/src/Storages/MergeTree/ReplicatedMergeTreeQueue.h |  4 ++--
 23 files changed, 37 insertions(+), 36 deletions(-)

diff --git a/dbms/src/Columns/ColumnAggregateFunction.cpp b/dbms/src/Columns/ColumnAggregateFunction.cpp
index 57a83a1fda8..5194a1d8ae8 100644
--- a/dbms/src/Columns/ColumnAggregateFunction.cpp
+++ b/dbms/src/Columns/ColumnAggregateFunction.cpp
@@ -176,7 +176,7 @@ size_t ColumnAggregateFunction::byteSize() const
     size_t res = getData().size() * sizeof(getData()[0]);
 
     for (const auto & arena : arenas)
-        res += arena.get()->size();
+        res += arena->size();
 
     return res;
 }
@@ -188,7 +188,7 @@ size_t ColumnAggregateFunction::allocatedBytes() const
     size_t res = getData().allocated_bytes();
 
     for (const auto & arena : arenas)
-        res += arena.get()->size();
+        res += arena->size();
 
     return res;
 }
diff --git a/dbms/src/Columns/ColumnArray.cpp b/dbms/src/Columns/ColumnArray.cpp
index 3531faef847..bc835df09db 100644
--- a/dbms/src/Columns/ColumnArray.cpp
+++ b/dbms/src/Columns/ColumnArray.cpp
@@ -328,7 +328,7 @@ ColumnPtr ColumnArray::convertToFullColumnIfConst() const
     else
         new_data = data;
 
-    if (auto full_column = offsets.get()->convertToFullColumnIfConst())
+    if (auto full_column = offsets->convertToFullColumnIfConst())
         new_offsets = full_column;
     else
         new_offsets = offsets;
diff --git a/dbms/src/Columns/IColumn.h b/dbms/src/Columns/IColumn.h
index dde614c845f..2b5925f889d 100644
--- a/dbms/src/Columns/IColumn.h
+++ b/dbms/src/Columns/IColumn.h
@@ -129,7 +129,7 @@ public:
     virtual ColumnPtr cut(size_t start, size_t length) const
     {
         ColumnPtr res = cloneEmpty();
-        res.get()->insertRangeFrom(*this, start, length);
+        res->insertRangeFrom(*this, start, length);
         return res;
     }
 
diff --git a/dbms/src/Common/typeid_cast.h b/dbms/src/Common/typeid_cast.h
index e335f8f9672..7f0934ad0cb 100644
--- a/dbms/src/Common/typeid_cast.h
+++ b/dbms/src/Common/typeid_cast.h
@@ -2,6 +2,7 @@
 
 #include <type_traits>
 #include <typeinfo>
+#include <typeindex>
 #include <string>
 
 #include <Common/Exception.h>
diff --git a/dbms/src/DataStreams/BinaryRowInputStream.cpp b/dbms/src/DataStreams/BinaryRowInputStream.cpp
index 3f903118a12..c74d2658a76 100644
--- a/dbms/src/DataStreams/BinaryRowInputStream.cpp
+++ b/dbms/src/DataStreams/BinaryRowInputStream.cpp
@@ -19,7 +19,7 @@ bool BinaryRowInputStream::read(Block & block)
 
     size_t columns = block.columns();
     for (size_t i = 0; i < columns; ++i)
-        block.getByPosition(i).type.get()->deserializeBinary(*block.getByPosition(i).column.get(), istr);
+        block.getByPosition(i).type->deserializeBinary(*block.getByPosition(i).column.get(), istr);
 
     return true;
 }
diff --git a/dbms/src/DataStreams/BlockOutputStreamFromRowOutputStream.cpp b/dbms/src/DataStreams/BlockOutputStreamFromRowOutputStream.cpp
index ab56b9c3ff1..8c466bc3c00 100644
--- a/dbms/src/DataStreams/BlockOutputStreamFromRowOutputStream.cpp
+++ b/dbms/src/DataStreams/BlockOutputStreamFromRowOutputStream.cpp
@@ -28,7 +28,7 @@ void BlockOutputStreamFromRowOutputStream::write(const Block & block)
                 row_output->writeFieldDelimiter();
 
             auto & col = block.getByPosition(j);
-            row_output->writeField(*col.column.get(), *col.type.get(), i);
+            row_output->writeField(*col.column, *col.type, i);
         }
 
         row_output->writeRowEndDelimiter();
diff --git a/dbms/src/DataStreams/CSVRowInputStream.cpp b/dbms/src/DataStreams/CSVRowInputStream.cpp
index 7521abd690e..edfc096b973 100644
--- a/dbms/src/DataStreams/CSVRowInputStream.cpp
+++ b/dbms/src/DataStreams/CSVRowInputStream.cpp
@@ -125,7 +125,7 @@ bool CSVRowInputStream::read(Block & block)
     for (size_t i = 0; i < size; ++i)
     {
         skipWhitespacesAndTabs(istr);
-        data_types[i].get()->deserializeTextCSV(*block.getByPosition(i).column.get(), istr, delimiter);
+        data_types[i]->deserializeTextCSV(*block.getByPosition(i).column.get(), istr, delimiter);
         skipWhitespacesAndTabs(istr);
 
         skipDelimiter(istr, delimiter, i + 1 == size);
diff --git a/dbms/src/DataStreams/IRowOutputStream.cpp b/dbms/src/DataStreams/IRowOutputStream.cpp
index 489e497d125..f5d80bceb2b 100644
--- a/dbms/src/DataStreams/IRowOutputStream.cpp
+++ b/dbms/src/DataStreams/IRowOutputStream.cpp
@@ -17,7 +17,7 @@ void IRowOutputStream::write(const Block & block, size_t row_num)
             writeFieldDelimiter();
 
         auto & col = block.getByPosition(i);
-        writeField(*col.column.get(), *col.type.get(), row_num);
+        writeField(*col.column, *col.type, row_num);
     }
 
     writeRowEndDelimiter();
diff --git a/dbms/src/DataStreams/JSONEachRowRowInputStream.cpp b/dbms/src/DataStreams/JSONEachRowRowInputStream.cpp
index b4d602c7598..69dcc368edb 100644
--- a/dbms/src/DataStreams/JSONEachRowRowInputStream.cpp
+++ b/dbms/src/DataStreams/JSONEachRowRowInputStream.cpp
@@ -120,7 +120,7 @@ bool JSONEachRowRowInputStream::read(Block & block)
         read_columns[index] = true;
 
         auto & col = block.getByPosition(index);
-        col.type.get()->deserializeTextJSON(*col.column.get(), istr);
+        col.type->deserializeTextJSON(*col.column, istr);
     }
 
     skipWhitespaceIfAny(istr);
@@ -130,7 +130,7 @@ bool JSONEachRowRowInputStream::read(Block & block)
     /// Fill non-visited columns with the default values.
     for (size_t i = 0; i < columns; ++i)
         if (!read_columns[i])
-            block.getByPosition(i).column.get()->insertDefault();
+            block.getByPosition(i).column->insertDefault();
 
     return true;
 }
diff --git a/dbms/src/DataStreams/ODBCDriverBlockOutputStream.cpp b/dbms/src/DataStreams/ODBCDriverBlockOutputStream.cpp
index d250d601e98..71161eeb117 100644
--- a/dbms/src/DataStreams/ODBCDriverBlockOutputStream.cpp
+++ b/dbms/src/DataStreams/ODBCDriverBlockOutputStream.cpp
@@ -33,7 +33,7 @@ void ODBCDriverBlockOutputStream::write(const Block & block)
 
             {
                 WriteBufferFromString text_out(text_value);
-                col.type->serializeText(*col.column.get(), i, text_out);
+                col.type->serializeText(*col.column, i, text_out);
             }
 
             writeStringBinary(text_value, out);
diff --git a/dbms/src/DataStreams/TSKVRowInputStream.cpp b/dbms/src/DataStreams/TSKVRowInputStream.cpp
index 9216cddc8b4..fd1d42c283a 100644
--- a/dbms/src/DataStreams/TSKVRowInputStream.cpp
+++ b/dbms/src/DataStreams/TSKVRowInputStream.cpp
@@ -136,7 +136,7 @@ bool TSKVRowInputStream::read(Block & block)
                     read_columns[index] = true;
 
                     auto & col = block.getByPosition(index);
-                    col.type.get()->deserializeTextEscaped(*col.column.get(), istr);
+                    col.type->deserializeTextEscaped(*col.column, istr);
                 }
             }
             else
@@ -177,7 +177,7 @@ bool TSKVRowInputStream::read(Block & block)
     /// Fill in the not met columns with default values.
     for (size_t i = 0; i < columns; ++i)
         if (!read_columns[i])
-            block.getByPosition(i).column.get()->insertDefault();
+            block.getByPosition(i).column->insertDefault();
 
     return true;
 }
diff --git a/dbms/src/DataStreams/TabSeparatedBlockOutputStream.cpp b/dbms/src/DataStreams/TabSeparatedBlockOutputStream.cpp
index 63992a2a860..10863a72234 100644
--- a/dbms/src/DataStreams/TabSeparatedBlockOutputStream.cpp
+++ b/dbms/src/DataStreams/TabSeparatedBlockOutputStream.cpp
@@ -23,7 +23,7 @@ void TabSeparatedBlockOutputStream::write(const Block & block)
         {
             if (j != 0)
                 ostr.write('\t');
-            col.type->serializeTextEscaped(*col.column.get(), j, ostr);
+            col.type->serializeTextEscaped(*col.column, j, ostr);
         }
         ostr.write('\n');
     }
diff --git a/dbms/src/DataStreams/TabSeparatedRowInputStream.cpp b/dbms/src/DataStreams/TabSeparatedRowInputStream.cpp
index 35bc8ac89a1..b5cbf6db6d7 100644
--- a/dbms/src/DataStreams/TabSeparatedRowInputStream.cpp
+++ b/dbms/src/DataStreams/TabSeparatedRowInputStream.cpp
@@ -84,7 +84,7 @@ bool TabSeparatedRowInputStream::read(Block & block)
 
     for (size_t i = 0; i < size; ++i)
     {
-        data_types[i].get()->deserializeTextEscaped(*block.getByPosition(i).column.get(), istr);
+        data_types[i]->deserializeTextEscaped(*block.getByPosition(i).column.get(), istr);
 
         /// skip separators
         if (i + 1 == size)
diff --git a/dbms/src/DataStreams/ValuesRowInputStream.cpp b/dbms/src/DataStreams/ValuesRowInputStream.cpp
index 5c795dd123e..1c14de4afa5 100644
--- a/dbms/src/DataStreams/ValuesRowInputStream.cpp
+++ b/dbms/src/DataStreams/ValuesRowInputStream.cpp
@@ -63,7 +63,7 @@ bool ValuesRowInputStream::read(Block & block)
         bool rollback_on_exception = false;
         try
         {
-            col.type.get()->deserializeTextQuoted(*col.column.get(), istr);
+            col.type->deserializeTextQuoted(*col.column, istr);
             rollback_on_exception = true;
             skipWhitespaceIfAny(istr);
 
@@ -94,7 +94,7 @@ bool ValuesRowInputStream::read(Block & block)
                     throw;
 
                 if (rollback_on_exception)
-                    col.column.get()->popBack(1);
+                    col.column->popBack(1);
 
                 IDataType & type = *block.safeGetByPosition(i).type;
 
diff --git a/dbms/src/DataStreams/VerticalRowOutputStream.cpp b/dbms/src/DataStreams/VerticalRowOutputStream.cpp
index 2fae4b4dcc2..b4f6428987e 100644
--- a/dbms/src/DataStreams/VerticalRowOutputStream.cpp
+++ b/dbms/src/DataStreams/VerticalRowOutputStream.cpp
@@ -152,7 +152,7 @@ void VerticalRowOutputStream::writeSpecialRow(const Block & block, size_t row_nu
             writeFieldDelimiter();
 
         auto & col = block.getByPosition(i);
-        writeField(*col.column.get(), *col.type.get(), row_num);
+        writeField(*col.column, *col.type, row_num);
     }
 }
 
diff --git a/dbms/src/DataTypes/DataTypeAggregateFunction.cpp b/dbms/src/DataTypes/DataTypeAggregateFunction.cpp
index 5da0fd620a0..1906b31304d 100644
--- a/dbms/src/DataTypes/DataTypeAggregateFunction.cpp
+++ b/dbms/src/DataTypes/DataTypeAggregateFunction.cpp
@@ -70,7 +70,7 @@ void DataTypeAggregateFunction::deserializeBinary(Field & field, ReadBuffer & is
 
 void DataTypeAggregateFunction::serializeBinary(const IColumn & column, size_t row_num, WriteBuffer & ostr) const
 {
-    function.get()->serialize(static_cast<const ColumnAggregateFunction &>(column).getData()[row_num], ostr);
+    function->serialize(static_cast<const ColumnAggregateFunction &>(column).getData()[row_num], ostr);
 }
 
 void DataTypeAggregateFunction::deserializeBinary(IColumn & column, ReadBuffer & istr) const
@@ -147,7 +147,7 @@ void DataTypeAggregateFunction::deserializeBinaryBulk(IColumn & column, ReadBuff
 static String serializeToString(const AggregateFunctionPtr & function, const IColumn & column, size_t row_num)
 {
     WriteBufferFromOwnString buffer;
-    function.get()->serialize(static_cast<const ColumnAggregateFunction &>(column).getData()[row_num], buffer);
+    function->serialize(static_cast<const ColumnAggregateFunction &>(column).getData()[row_num], buffer);
     return buffer.str();
 }
 
diff --git a/dbms/src/Storages/MergeTree/MergeTreeData.cpp b/dbms/src/Storages/MergeTree/MergeTreeData.cpp
index 02864db0f33..e4fc0c51f0a 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeData.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeData.cpp
@@ -809,7 +809,7 @@ void MergeTreeData::createConvertExpression(const DataPartPtr & part, const Name
     {
         if (!new_types.count(column.name))
         {
-            bool is_nullable = column.type.get()->isNullable();
+            bool is_nullable = column.type->isNullable();
 
             if (!part || part->hasColumnFiles(column.name))
             {
@@ -1049,7 +1049,7 @@ MergeTreeData::AlterDataPartTransactionPtr MergeTreeData::alterDataPart(
 
         for (size_t i = 0, size = part->size; i < size; ++i)
             for (size_t j = 0; j < new_key_size; ++j)
-                new_primary_key_sample.getByPosition(j).type.get()->serializeBinary(*new_index[j].get(), i, index_stream);
+                new_primary_key_sample.getByPosition(j).type->serializeBinary(*new_index[j].get(), i, index_stream);
 
         transaction->rename_map["primary.idx.tmp"] = "primary.idx";
 
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp b/dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp
index 0b86571a25f..3af6d0d8a91 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp
@@ -630,8 +630,8 @@ void MergeTreeDataPart::loadIndex()
 
         for (size_t i = 0; i < key_size; ++i)
         {
-            index[i] = storage.primary_key_data_types[i].get()->createColumn();
-            index[i].get()->reserve(size);
+            index[i] = storage.primary_key_data_types[i]->createColumn();
+            index[i]->reserve(size);
         }
 
         String index_path = getFullPath() + "primary.idx";
@@ -640,12 +640,12 @@ void MergeTreeDataPart::loadIndex()
 
         for (size_t i = 0; i < size; ++i)
             for (size_t j = 0; j < key_size; ++j)
-                storage.primary_key_data_types[j].get()->deserializeBinary(*index[j].get(), index_file);
+                storage.primary_key_data_types[j]->deserializeBinary(*index[j].get(), index_file);
 
         for (size_t i = 0; i < key_size; ++i)
-            if (index[i].get()->size() != size)
+            if (index[i]->size() != size)
                 throw Exception("Cannot read all data from index file " + index_path
-                    + "(expected size: " + toString(size) + ", read: " + toString(index[i].get()->size()) + ")",
+                    + "(expected size: " + toString(size) + ", read: " + toString(index[i]->size()) + ")",
                     ErrorCodes::CANNOT_READ_ALL_DATA);
 
         if (!index_file.eof())
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp b/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
index 68bb0edfa39..04f912a5372 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
@@ -854,7 +854,7 @@ MarkRanges MergeTreeDataSelectExecutor::markRangesFromPKRange(
     MarkRanges res;
 
     size_t used_key_size = key_condition.getMaxKeyColumn() + 1;
-    size_t marks_count = index.at(0).get()->size();
+    size_t marks_count = index.at(0)->size();
 
     /// If index is not used.
     if (key_condition.alwaysUnknownOrTrue())
diff --git a/dbms/src/Storages/MergeTree/MergeTreePartChecker.cpp b/dbms/src/Storages/MergeTree/MergeTreePartChecker.cpp
index 723e208a8d5..6ce836828e8 100644
--- a/dbms/src/Storages/MergeTree/MergeTreePartChecker.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreePartChecker.cpp
@@ -332,7 +332,7 @@ void MergeTreePartChecker::checkDataPart(
             Columns tmp_columns(key_size);
 
             for (size_t j = 0; j < key_size; ++j)
-                tmp_columns[j] = primary_key_data_types[j].get()->createColumn();
+                tmp_columns[j] = primary_key_data_types[j]->createColumn();
 
             while (!hashing_buf.eof())
             {
@@ -341,7 +341,7 @@ void MergeTreePartChecker::checkDataPart(
 
                 ++marks_in_primary_key;
                 for (size_t j = 0; j < key_size; ++j)
-                    primary_key_data_types[j].get()->deserializeBinary(*tmp_columns[j].get(), hashing_buf);
+                    primary_key_data_types[j]->deserializeBinary(*tmp_columns[j].get(), hashing_buf);
             }
         }
         else
diff --git a/dbms/src/Storages/MergeTree/MergeTreeReader.cpp b/dbms/src/Storages/MergeTree/MergeTreeReader.cpp
index c1f7b4bea53..5391561013f 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeReader.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeReader.cpp
@@ -110,7 +110,7 @@ size_t MergeTreeReader::readRows(size_t from_mark, bool continue_reading, size_t
             const IDataType * observed_type;
             bool is_nullable;
 
-            if (column.type.get()->isNullable())
+            if (column.type->isNullable())
             {
                 const DataTypeNullable & nullable_type = static_cast<const DataTypeNullable &>(*column.type);
                 observed_type = nullable_type.getNestedType().get();
diff --git a/dbms/src/Storages/MergeTree/MergedBlockOutputStream.cpp b/dbms/src/Storages/MergeTree/MergedBlockOutputStream.cpp
index 4936cd82e49..062dfe4ab33 100644
--- a/dbms/src/Storages/MergeTree/MergedBlockOutputStream.cpp
+++ b/dbms/src/Storages/MergeTree/MergedBlockOutputStream.cpp
@@ -500,7 +500,7 @@ void MergedBlockOutputStream::writeImpl(const Block & block, const IColumn::Perm
     {
         index_columns.resize(sort_description.size());
         for (size_t i = 0, size = sort_description.size(); i < size; ++i)
-            index_columns[i] = primary_columns[i].column.get()->cloneEmpty();
+            index_columns[i] = primary_columns[i].column->cloneEmpty();
     }
 
     /// Now write the data.
@@ -545,8 +545,8 @@ void MergedBlockOutputStream::writeImpl(const Block & block, const IColumn::Perm
                 for (size_t j = 0, size = primary_columns.size(); j < size; ++j)
                 {
                     const IColumn & primary_column = *primary_columns[j].column.get();
-                    index_columns[j].get()->insertFrom(primary_column, i);
-                    primary_columns[j].type.get()->serializeBinary(primary_column, i, *index_stream);
+                    index_columns[j]->insertFrom(primary_column, i);
+                    primary_columns[j].type->serializeBinary(primary_column, i, *index_stream);
                 }
             }
 
diff --git a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeQueue.h b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeQueue.h
index a96710db8b8..93b515a4e4c 100644
--- a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeQueue.h
+++ b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeQueue.h
@@ -28,8 +28,8 @@ private:
     {
         bool operator()(const LogEntryPtr & lhs, const LogEntryPtr & rhs) const
         {
-            return std::forward_as_tuple(lhs.get()->create_time, lhs.get())
-                 < std::forward_as_tuple(rhs.get()->create_time, rhs.get());
+            return std::forward_as_tuple(lhs->create_time, lhs.get())
+                 < std::forward_as_tuple(rhs->create_time, rhs.get());
         }
     };
 

From 87fab3396e164ac31159cba72c80d91ea026cea8 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 1 Sep 2017 21:22:03 +0300
Subject: [PATCH 051/266] Fixed build [#CLICKHOUSE-2].

---
 dbms/src/Common/RWLockFIFO.h | 2 +-
 dbms/src/Storages/IStorage.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/dbms/src/Common/RWLockFIFO.h b/dbms/src/Common/RWLockFIFO.h
index 0cdcbe67ec3..6353e4c6cbe 100644
--- a/dbms/src/Common/RWLockFIFO.h
+++ b/dbms/src/Common/RWLockFIFO.h
@@ -9,7 +9,7 @@
 namespace DB
 {
 
-struct RWLockFIFO;
+class RWLockFIFO;
 using RWLockFIFOPtr = std::shared_ptr<RWLockFIFO>;
 
 
diff --git a/dbms/src/Storages/IStorage.h b/dbms/src/Storages/IStorage.h
index eac1930016f..a8d07d07e43 100644
--- a/dbms/src/Storages/IStorage.h
+++ b/dbms/src/Storages/IStorage.h
@@ -23,7 +23,7 @@ class Context;
 class IBlockInputStream;
 class IBlockOutputStream;
 
-struct RWLockFIFO;
+class RWLockFIFO;
 using RWLockFIFOPtr = std::shared_ptr<RWLockFIFO>;
 
 using BlockOutputStreamPtr = std::shared_ptr<IBlockOutputStream>;

From 5889aa9c74ab920778eea1ddca240d3e08efd0f6 Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Fri, 1 Sep 2017 21:36:03 +0300
Subject: [PATCH 052/266] Fix build

---
 dbms/src/Interpreters/DNSCache.cpp | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/dbms/src/Interpreters/DNSCache.cpp b/dbms/src/Interpreters/DNSCache.cpp
index d9ec6cc2803..d12007e908e 100644
--- a/dbms/src/Interpreters/DNSCache.cpp
+++ b/dbms/src/Interpreters/DNSCache.cpp
@@ -11,6 +11,12 @@
 namespace DB
 {
 
+namespace ErrorCodes
+{
+    extern const int BAD_ARGUMENTS;
+}
+
+
 /// Slightly altered implementation from https://github.com/pocoproject/poco/blob/poco-1.6.1/Net/src/SocketAddress.cpp#L86
 static void splitHostAndPort(const std::string & host_and_port, std::string & out_host, UInt16 & out_port)
 {

From aa1f27553e8619cdf355b78f90b65bf726e9aca5 Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Fri, 1 Sep 2017 22:04:46 +0300
Subject: [PATCH 053/266] Header compile fixes

---
 .../AggregateFunctions/AggregateFunctionQuantileTiming.h   | 7 ++++---
 dbms/src/Common/TypeList.h                                 | 4 ++++
 dbms/src/Server/HTTPHandler.h                              | 4 +++-
 dbms/src/Server/TCPHandler.h                               | 3 ++-
 dbms/src/Server/TCPHandlerFactory.h                        | 6 +++---
 5 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/dbms/src/AggregateFunctions/AggregateFunctionQuantileTiming.h b/dbms/src/AggregateFunctions/AggregateFunctionQuantileTiming.h
index d07c3a7fcca..86f9eaadf7f 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionQuantileTiming.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionQuantileTiming.h
@@ -21,14 +21,15 @@
 #include <ext/range.h>
 
 
+
+namespace DB
+{
+
 namespace ErrorCodes
 {
     extern const int LOGICAL_ERROR;
 }
 
-namespace DB
-{
-
 /** Calculates quantile for time in milliseconds, less than 30 seconds.
   * If the value is greater than 30 seconds, the value is set to 30 seconds.
   *
diff --git a/dbms/src/Common/TypeList.h b/dbms/src/Common/TypeList.h
index 8a683de74d8..ceb431a12bd 100644
--- a/dbms/src/Common/TypeList.h
+++ b/dbms/src/Common/TypeList.h
@@ -1,5 +1,9 @@
 #pragma once
 
+#include <cstddef>
+#include <utility>
+#include <Core/Defines.h>
+
 namespace DB
 {
 
diff --git a/dbms/src/Server/HTTPHandler.h b/dbms/src/Server/HTTPHandler.h
index 8ce4c8c489a..7a5bd656f9a 100644
--- a/dbms/src/Server/HTTPHandler.h
+++ b/dbms/src/Server/HTTPHandler.h
@@ -13,6 +13,8 @@ namespace CurrentMetrics
     extern const Metric HTTPConnection;
 }
 
+namespace Poco { class Logger; }
+
 namespace DB
 {
 
@@ -52,7 +54,7 @@ private:
     };
 
     IServer & server;
-    Logger * log;
+    Poco::Logger * log;
 
     CurrentMetrics::Increment metric_increment{CurrentMetrics::HTTPConnection};
 
diff --git a/dbms/src/Server/TCPHandler.h b/dbms/src/Server/TCPHandler.h
index 575568a63f5..ba40ed30d97 100644
--- a/dbms/src/Server/TCPHandler.h
+++ b/dbms/src/Server/TCPHandler.h
@@ -18,6 +18,7 @@ namespace CurrentMetrics
     extern const Metric TCPConnection;
 }
 
+namespace Poco { class Logger; }
 
 namespace DB
 {
@@ -86,7 +87,7 @@ public:
 
 private:
     IServer & server;
-    Logger * log;
+    Poco::Logger * log;
 
     String client_name;
     UInt64 client_version_major = 0;
diff --git a/dbms/src/Server/TCPHandlerFactory.h b/dbms/src/Server/TCPHandlerFactory.h
index 9514a2deb3b..3abde2ef393 100644
--- a/dbms/src/Server/TCPHandlerFactory.h
+++ b/dbms/src/Server/TCPHandlerFactory.h
@@ -1,11 +1,11 @@
 #pragma once
 
 #include <Poco/Net/TCPServerConnectionFactory.h>
-
+#include <common/logger_useful.h>
 #include "IServer.h"
-
 #include "TCPHandler.h"
 
+namespace Poco { class Logger; }
 
 namespace DB
 {
@@ -14,7 +14,7 @@ class TCPHandlerFactory : public Poco::Net::TCPServerConnectionFactory
 {
 private:
     IServer & server;
-    Logger * log;
+    Poco::Logger * log;
 
 public:
     TCPHandlerFactory(IServer & server_)

From 5f83b829cf0a26499b1f80ef227fb6eae9a2d6f1 Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Fri, 1 Sep 2017 22:48:43 +0300
Subject: [PATCH 054/266] Fix includes

---
 dbms/src/Server/HTTPHandlerFactory.h | 3 +--
 dbms/src/Server/TCPHandler.h         | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/dbms/src/Server/HTTPHandlerFactory.h b/dbms/src/Server/HTTPHandlerFactory.h
index 8201141745c..7ba25b0d194 100644
--- a/dbms/src/Server/HTTPHandlerFactory.h
+++ b/dbms/src/Server/HTTPHandlerFactory.h
@@ -3,9 +3,8 @@
 #include <Poco/Net/HTTPRequestHandlerFactory.h>
 #include <Poco/Net/HTTPServerRequest.h>
 #include <Poco/Net/HTTPServerResponse.h>
-
+#include <common/logger_useful.h>
 #include "IServer.h"
-
 #include "HTTPHandler.h"
 #include "InterserverIOHTTPHandler.h"
 #include "NotFoundHandler.h"
diff --git a/dbms/src/Server/TCPHandler.h b/dbms/src/Server/TCPHandler.h
index ba40ed30d97..846a5474561 100644
--- a/dbms/src/Server/TCPHandler.h
+++ b/dbms/src/Server/TCPHandler.h
@@ -77,7 +77,7 @@ public:
     TCPHandler(IServer & server_, const Poco::Net::StreamSocket & socket_)
         : Poco::Net::TCPServerConnection(socket_)
         , server(server_)
-        , log(&Logger::get("TCPHandler"))
+        , log(&Poco::Logger::get("TCPHandler"))
         , connection_context(server.context())
         , query_context(server.context())
     {

From 049569c1029763c24ee551ddf612d56788186a22 Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Sat, 2 Sep 2017 00:18:33 +0300
Subject: [PATCH 055/266] Update debian/.pbuilderrc description

---
 debian/.pbuilderrc | 17 ++++++++++++-----
 1 file changed, 12 insertions(+), 5 deletions(-)

diff --git a/debian/.pbuilderrc b/debian/.pbuilderrc
index d640d54871e..20f82d35565 100644
--- a/debian/.pbuilderrc
+++ b/debian/.pbuilderrc
@@ -7,14 +7,20 @@
 # sudo DIST=zesty  pbuilder create --configfile debian/.pbuilderrc && DIST=zesty  pdebuild --configfile debian/.pbuilderrc
 # sudo DIST=artful pbuilder create --configfile debian/.pbuilderrc && DIST=artful pdebuild --configfile debian/.pbuilderrc
 # build debian:
-# sudo DIST=experimental pbuilder create --configfile debian/.pbuilderrc && DIST=experimental pdebuild --configfile debian/.pbuilderrc
-# sudo DIST=testing      pbuilder create --configfile debian/.pbuilderrc && DIST=testing      pdebuild --configfile debian/.pbuilderrc
 # sudo DIST=stable       pbuilder create --configfile debian/.pbuilderrc && DIST=stable       pdebuild --configfile debian/.pbuilderrc
-# BROKEN:
-# sudo DIST=xenial       pbuilder create --configfile debian/.pbuilderrc && DIST=xenial       pdebuild --configfile debian/.pbuilderrc
+# sudo DIST=testing      pbuilder create --configfile debian/.pbuilderrc && DIST=testing      pdebuild --configfile debian/.pbuilderrc
 # sudo DIST=unstable     pbuilder create --configfile debian/.pbuilderrc && DIST=unstable     pdebuild --configfile debian/.pbuilderrc
+# sudo DIST=experimental pbuilder create --configfile debian/.pbuilderrc && DIST=experimental pdebuild --configfile debian/.pbuilderrc
+# build i386 experimental:
+# sudo DIST=trusty       ARCH=i386 pbuilder create --configfile debian/.pbuilderrc && DIST=trusty       ARCH=i386 pdebuild --configfile debian/.pbuilderrc
+# sudo DIST=zesty        ARCH=i386 pbuilder create --configfile debian/.pbuilderrc && DIST=zesty        ARCH=i386 pdebuild --configfile debian/.pbuilderrc
+# sudo DIST=artful       ARCH=i386 pbuilder create --configfile debian/.pbuilderrc && DIST=artful       ARCH=i386 pdebuild --configfile debian/.pbuilderrc
+# sudo DIST=stable       ARCH=i386 pbuilder create --configfile debian/.pbuilderrc && DIST=stable       ARCH=i386 pdebuild --configfile debian/.pbuilderrc
+# sudo DIST=testing      ARCH=i386 pbuilder create --configfile debian/.pbuilderrc && DIST=testing      ARCH=i386 pdebuild --configfile debian/.pbuilderrc
+# sudo DIST=experimental ARCH=i386 pbuilder create --configfile debian/.pbuilderrc && DIST=experimental ARCH=i386 pdebuild --configfile debian/.pbuilderrc
+# BROKEN (can't install fresh gcc):
+# sudo DIST=xenial pbuilder create --configfile debian/.pbuilderrc && DIST=xenial pdebuild --configfile debian/.pbuilderrc
 # TODO:
-# sudo DIST=zesty        ARCH=i386  pbuilder create --configfile debian/.pbuilderrc && DIST=zesty        ARCH=i386  pdebuild --configfile debian/.pbuilderrc
 
 # from https://wiki.debian.org/PbuilderTricks :
 
@@ -98,6 +104,7 @@ elif $(echo ${UBUNTU_SUITES[@]} | grep -q $DIST); then
     case "$DIST" in
        "trusty" | "xenial" )
            OTHERMIRROR+="deb http://ppa.launchpad.net/ubuntu-toolchain-r/test/$OSNAME $DIST main"
+           #OTHERMIRROR+="deb http://ppa.launchpad.net/ubuntu-toolchain-r/ppa/$OSNAME $DIST main"
            ALLOWUNTRUSTED=yes
            ;;
     esac

From f51cc679a0ced7ec276c7bda0413843e1bff71c0 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 2 Sep 2017 00:37:57 +0300
Subject: [PATCH 056/266] Fixed inserting wrong default value for Enums
 [#CLICKHOUSE-3270].

---
 .../DataStreams/JSONEachRowRowInputStream.cpp |  7 +++++-
 dbms/src/DataStreams/TSKVRowInputStream.cpp   |  7 +++++-
 .../TotalsHavingBlockInputStream.cpp          |  2 +-
 dbms/src/DataTypes/DataTypeArray.cpp          |  6 +++++
 dbms/src/DataTypes/DataTypeArray.h            |  5 +---
 dbms/src/DataTypes/DataTypeEnum.cpp           |  6 +++++
 dbms/src/DataTypes/DataTypeEnum.h             |  1 +
 dbms/src/DataTypes/DataTypeTuple.cpp          | 23 +++++++++++++------
 dbms/src/DataTypes/DataTypeTuple.h            |  2 ++
 dbms/src/DataTypes/IDataType.cpp              |  5 ++++
 dbms/src/DataTypes/IDataType.h                |  5 ++++
 dbms/src/DataTypes/IDataTypeDummy.h           |  5 ++++
 12 files changed, 60 insertions(+), 14 deletions(-)

diff --git a/dbms/src/DataStreams/JSONEachRowRowInputStream.cpp b/dbms/src/DataStreams/JSONEachRowRowInputStream.cpp
index 69dcc368edb..5744e13932e 100644
--- a/dbms/src/DataStreams/JSONEachRowRowInputStream.cpp
+++ b/dbms/src/DataStreams/JSONEachRowRowInputStream.cpp
@@ -129,8 +129,13 @@ bool JSONEachRowRowInputStream::read(Block & block)
 
     /// Fill non-visited columns with the default values.
     for (size_t i = 0; i < columns; ++i)
+    {
         if (!read_columns[i])
-            block.getByPosition(i).column->insertDefault();
+        {
+            ColumnWithTypeAndName & elem = block.getByPosition(i);
+            elem.type->insertDefaultInto(*elem.column);
+        }
+    }
 
     return true;
 }
diff --git a/dbms/src/DataStreams/TSKVRowInputStream.cpp b/dbms/src/DataStreams/TSKVRowInputStream.cpp
index fd1d42c283a..19e1f20a281 100644
--- a/dbms/src/DataStreams/TSKVRowInputStream.cpp
+++ b/dbms/src/DataStreams/TSKVRowInputStream.cpp
@@ -176,8 +176,13 @@ bool TSKVRowInputStream::read(Block & block)
 
     /// Fill in the not met columns with default values.
     for (size_t i = 0; i < columns; ++i)
+    {
         if (!read_columns[i])
-            block.getByPosition(i).column->insertDefault();
+        {
+            ColumnWithTypeAndName & elem = block.getByPosition(i);
+            elem.type->insertDefaultInto(*elem.column);
+        }
+    }
 
     return true;
 }
diff --git a/dbms/src/DataStreams/TotalsHavingBlockInputStream.cpp b/dbms/src/DataStreams/TotalsHavingBlockInputStream.cpp
index f8776e95439..c6e0dcb1a8e 100644
--- a/dbms/src/DataStreams/TotalsHavingBlockInputStream.cpp
+++ b/dbms/src/DataStreams/TotalsHavingBlockInputStream.cpp
@@ -172,7 +172,7 @@ void TotalsHavingBlockInputStream::addToTotals(Block & totals, Block & block, co
             if (init)
             {
                 ColumnPtr new_column = current.type->createColumn();
-                new_column->insert(current.type->getDefault());
+                current.type->insertDefaultInto(*new_column);
                 totals.insert(ColumnWithTypeAndName(new_column, current.type, current.name));
             }
             continue;
diff --git a/dbms/src/DataTypes/DataTypeArray.cpp b/dbms/src/DataTypes/DataTypeArray.cpp
index a73f31787be..c6609656c46 100644
--- a/dbms/src/DataTypes/DataTypeArray.cpp
+++ b/dbms/src/DataTypes/DataTypeArray.cpp
@@ -395,6 +395,12 @@ ColumnPtr DataTypeArray::createColumn() const
 }
 
 
+Field DataTypeArray::getDefault() const
+{
+    return Array();
+}
+
+
 static DataTypePtr create(const ASTPtr & arguments)
 {
     if (arguments->children.size() != 1)
diff --git a/dbms/src/DataTypes/DataTypeArray.h b/dbms/src/DataTypes/DataTypeArray.h
index 0c1757b903d..423d27e1889 100644
--- a/dbms/src/DataTypes/DataTypeArray.h
+++ b/dbms/src/DataTypes/DataTypeArray.h
@@ -87,10 +87,7 @@ public:
 
     ColumnPtr createColumn() const override;
 
-    Field getDefault() const override
-    {
-        return Array();
-    }
+    Field getDefault() const override;
 
     const DataTypePtr & getNestedType() const { return nested; }
     const DataTypeTraits::EnrichedDataTypePtr & getEnrichedNestedType() const { return enriched_nested; }
diff --git a/dbms/src/DataTypes/DataTypeEnum.cpp b/dbms/src/DataTypes/DataTypeEnum.cpp
index a4a5b5b3924..0ab7822ada7 100644
--- a/dbms/src/DataTypes/DataTypeEnum.cpp
+++ b/dbms/src/DataTypes/DataTypeEnum.cpp
@@ -241,6 +241,12 @@ Field DataTypeEnum<Type>::getDefault() const
     return typename NearestFieldType<FieldType>::Type(values.front().second);
 }
 
+template <typename Type>
+void DataTypeEnum<Type>::insertDefaultInto(IColumn & column) const
+{
+    static_cast<ColumnType &>(column).getData().push_back(values.front().second);
+}
+
 template <typename Type>
 static void checkOverflow(Int64 value)
 {
diff --git a/dbms/src/DataTypes/DataTypeEnum.h b/dbms/src/DataTypes/DataTypeEnum.h
index da205f97bbd..8ecbfb9eddf 100644
--- a/dbms/src/DataTypes/DataTypeEnum.h
+++ b/dbms/src/DataTypes/DataTypeEnum.h
@@ -106,6 +106,7 @@ public:
     ColumnPtr createColumn() const override { return std::make_shared<ColumnType>(); }
 
     Field getDefault() const override;
+    void insertDefaultInto(IColumn & column) const override;
 };
 
 
diff --git a/dbms/src/DataTypes/DataTypeTuple.cpp b/dbms/src/DataTypes/DataTypeTuple.cpp
index deee680354d..7a78ccb9567 100644
--- a/dbms/src/DataTypes/DataTypeTuple.cpp
+++ b/dbms/src/DataTypes/DataTypeTuple.cpp
@@ -35,12 +35,12 @@ std::string DataTypeTuple::getName() const
 
 static inline IColumn & extractElementColumn(IColumn & column, size_t idx)
 {
-    return *static_cast<ColumnTuple &>(column).getData().getByPosition(idx).column.get();
+    return *static_cast<ColumnTuple &>(column).getData().getByPosition(idx).column;
 }
 
 static inline const IColumn & extractElementColumn(const IColumn & column, size_t idx)
 {
-    return *static_cast<const ColumnTuple &>(column).getData().getByPosition(idx).column.get();
+    return *static_cast<const ColumnTuple &>(column).getData().getByPosition(idx).column;
 }
 
 
@@ -68,7 +68,7 @@ void DataTypeTuple::serializeBinary(const IColumn & column, size_t row_num, Writ
 
 
 template <typename F>
-static void deserializeSafe(const DataTypes & elems, IColumn & column, ReadBuffer & istr, F && impl)
+static void addElementSafe(const DataTypes & elems, IColumn & column, F && impl)
 {
     /// We use the assumption that tuples of zero size do not exist.
     size_t old_size = extractElementColumn(column, 0).size();
@@ -93,7 +93,7 @@ static void deserializeSafe(const DataTypes & elems, IColumn & column, ReadBuffe
 
 void DataTypeTuple::deserializeBinary(IColumn & column, ReadBuffer & istr) const
 {
-    deserializeSafe(elems, column, istr, [&]
+    addElementSafe(elems, column, [&]
     {
         for (const auto & i : ext::range(0, ext::size(elems)))
             elems[i]->deserializeBinary(extractElementColumn(column, i), istr);
@@ -117,7 +117,7 @@ void DataTypeTuple::deserializeText(IColumn & column, ReadBuffer & istr) const
     const size_t size = elems.size();
     assertChar('(', istr);
 
-    deserializeSafe(elems, column, istr, [&]
+    addElementSafe(elems, column, [&]
     {
         for (const auto i : ext::range(0, size))
         {
@@ -169,7 +169,7 @@ void DataTypeTuple::deserializeTextJSON(IColumn & column, ReadBuffer & istr) con
     const size_t size = elems.size();
     assertChar('[', istr);
 
-    deserializeSafe(elems, column, istr, [&]
+    addElementSafe(elems, column, [&]
     {
         for (const auto i : ext::range(0, size))
         {
@@ -208,7 +208,7 @@ void DataTypeTuple::serializeTextCSV(const IColumn & column, size_t row_num, Wri
 
 void DataTypeTuple::deserializeTextCSV(IColumn & column, ReadBuffer & istr, const char delimiter) const
 {
-    deserializeSafe(elems, column, istr, [&]
+    addElementSafe(elems, column, [&]
     {
         const size_t size = elems.size();
         for (const auto i : ext::range(0, size))
@@ -256,6 +256,15 @@ Field DataTypeTuple::getDefault() const
     return Tuple(ext::map<TupleBackend>(elems, [] (const DataTypePtr & elem) { return elem->getDefault(); }));
 }
 
+void DataTypeTuple::insertDefaultInto(IColumn & column) const
+{
+    addElementSafe(elems, column, [&]
+    {
+        for (const auto & i : ext::range(0, ext::size(elems)))
+            elems[i]->insertDefaultInto(extractElementColumn(column, i));
+    });
+}
+
 
 static DataTypePtr create(const ASTPtr & arguments)
 {
diff --git a/dbms/src/DataTypes/DataTypeTuple.h b/dbms/src/DataTypes/DataTypeTuple.h
index 0de549d0d83..10813276057 100644
--- a/dbms/src/DataTypes/DataTypeTuple.h
+++ b/dbms/src/DataTypes/DataTypeTuple.h
@@ -53,6 +53,8 @@ public:
     ColumnPtr createColumn() const override;
 
     Field getDefault() const override;
+    void insertDefaultInto(IColumn & column) const override;
+
     const DataTypes & getElements() const { return elems; }
 };
 
diff --git a/dbms/src/DataTypes/IDataType.cpp b/dbms/src/DataTypes/IDataType.cpp
index a3ce05820c1..2074424581d 100644
--- a/dbms/src/DataTypes/IDataType.cpp
+++ b/dbms/src/DataTypes/IDataType.cpp
@@ -30,4 +30,9 @@ ColumnPtr IDataType::createConstColumn(size_t size, const Field & field) const
     return std::make_shared<ColumnConst>(column, size);
 }
 
+void IDataType::insertDefaultInto(IColumn & column) const
+{
+    column.insertDefault();
+}
+
 }
diff --git a/dbms/src/DataTypes/IDataType.h b/dbms/src/DataTypes/IDataType.h
index 6ae51a7d78a..324af2eacb0 100644
--- a/dbms/src/DataTypes/IDataType.h
+++ b/dbms/src/DataTypes/IDataType.h
@@ -149,6 +149,11 @@ public:
       */
     virtual Field getDefault() const = 0;
 
+    /** Directly insert default value into a column. Default implementation use method IColumn::insertDefault.
+      * This should be overriden if data type default value differs from column default value (example: Enum data types).
+      */
+    virtual void insertDefaultInto(IColumn & column) const;
+
     /// For fixed-size types, return size of value in bytes. For other data types, return some approximate size just for estimation.
     virtual size_t getSizeOfField() const
     {
diff --git a/dbms/src/DataTypes/IDataTypeDummy.h b/dbms/src/DataTypes/IDataTypeDummy.h
index cf5d9d80f8f..54465b2b453 100644
--- a/dbms/src/DataTypes/IDataTypeDummy.h
+++ b/dbms/src/DataTypes/IDataTypeDummy.h
@@ -63,6 +63,11 @@ public:
     {
         throw Exception("Method getDefault() is not implemented for data type " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
+
+    void insertDefaultInto(IColumn & column) const override
+    {
+        throw Exception("Method insertDefaultInto() is not implemented for data type " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+    }
 };
 
 }

From 863fd72c8a896aadda62fe30bd0a30bf54cb07cb Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Sat, 2 Sep 2017 00:46:12 +0300
Subject: [PATCH 057/266] Segmentation fault on HEAD HTTP query #912

---
 .../IO/WriteBufferFromHTTPServerResponse.cpp  | 33 ++++++++++++-------
 .../IO/WriteBufferFromHTTPServerResponse.h    |  4 +++
 dbms/src/Server/HTTPHandler.cpp               |  2 +-
 dbms/src/Server/InterserverIOHTTPHandler.cpp  |  2 +-
 .../00497_whitespaces_in_insert.sh            |  2 +-
 .../0_stateless/00498_http_head.reference     |  0
 .../queries/0_stateless/00498_http_head.sh    |  4 +++
 7 files changed, 32 insertions(+), 15 deletions(-)
 create mode 100644 dbms/tests/queries/0_stateless/00498_http_head.reference
 create mode 100755 dbms/tests/queries/0_stateless/00498_http_head.sh

diff --git a/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp b/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp
index 105d3787075..026495ddd96 100644
--- a/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp
+++ b/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp
@@ -30,7 +30,8 @@ void WriteBufferFromHTTPServerResponse::startSendHeaders()
         setResponseDefaultHeaders(response);
 
 #if POCO_CLICKHOUSE_PATCH
-        std::tie(response_header_ostr, response_body_ostr) = response.beginSend();
+        if (request.getMethod() != Poco::Net::HTTPRequest::HTTP_HEAD)
+            std::tie(response_header_ostr, response_body_ostr) = response.beginSend();
 #endif
     }
 }
@@ -42,16 +43,21 @@ void WriteBufferFromHTTPServerResponse::finishSendHeaders()
     {
         headers_finished_sending = true;
 
+        if (request.getMethod() != Poco::Net::HTTPRequest::HTTP_HEAD) {
 #if POCO_CLICKHOUSE_PATCH
-        /// Send end of headers delimiter.
-        if (response_header_ostr)
-            *response_header_ostr << "\r\n" << std::flush;
+            /// Send end of headers delimiter.
+            if (response_header_ostr)
+                *response_header_ostr << "\r\n" << std::flush;
 #else
-        /// Newline autosent by response.send()
-        /// if nothing to send in body:
-        if (!response_body_ostr)
-            response_body_ostr = &(response.send());
+            /// Newline autosent by response.send()
+            /// if nothing to send in body:
+            if (!response_body_ostr)
+                response_body_ostr = &(response.send());
 #endif
+        } else {
+            if (!response_body_ostr)
+                response_body_ostr = &(response.send());
+        }
     }
 }
 
@@ -63,7 +69,7 @@ void WriteBufferFromHTTPServerResponse::nextImpl()
 
         startSendHeaders();
 
-        if (!out)
+        if (!out && request.getMethod() != Poco::Net::HTTPRequest::HTTP_HEAD)
         {
             if (compress)
             {
@@ -111,17 +117,20 @@ void WriteBufferFromHTTPServerResponse::nextImpl()
 
     }
 
-    out->position() = position();
-    out->next();
+    if (out) {
+        out->position() = position();
+        out->next();
+    }
 }
 
 
 WriteBufferFromHTTPServerResponse::WriteBufferFromHTTPServerResponse(
+    Poco::Net::HTTPServerRequest & request_,
     Poco::Net::HTTPServerResponse & response_,
     bool compress_,
     ZlibCompressionMethod compression_method_,
     size_t size)
-    : BufferWithOwnMemory<WriteBuffer>(size), response(response_),
+    : BufferWithOwnMemory<WriteBuffer>(size), request(request_), response(response_),
     compress(compress_), compression_method(compression_method_)
 {
 }
diff --git a/dbms/src/IO/WriteBufferFromHTTPServerResponse.h b/dbms/src/IO/WriteBufferFromHTTPServerResponse.h
index a2ddb1afeb2..54cfc15bb6f 100644
--- a/dbms/src/IO/WriteBufferFromHTTPServerResponse.h
+++ b/dbms/src/IO/WriteBufferFromHTTPServerResponse.h
@@ -2,6 +2,8 @@
 
 #include <experimental/optional>
 #include <mutex>
+#include <Poco/Net/HTTPServerRequest.h>
+#include <Poco/Net/HTTPServerResponse.h>
 #include <Poco/Version.h>
 #include <IO/WriteBuffer.h>
 #include <IO/BufferWithOwnMemory.h>
@@ -41,6 +43,7 @@ namespace DB
 class WriteBufferFromHTTPServerResponse : public BufferWithOwnMemory<WriteBuffer>
 {
 private:
+    Poco::Net::HTTPServerRequest & request;
     Poco::Net::HTTPServerResponse & response;
 
     bool add_cors_header = false;
@@ -81,6 +84,7 @@ private:
 
 public:
     WriteBufferFromHTTPServerResponse(
+        Poco::Net::HTTPServerRequest & request_,
         Poco::Net::HTTPServerResponse & response_,
         bool compress_ = false,        /// If true - set Content-Encoding header and compress the result.
         ZlibCompressionMethod compression_method_ = ZlibCompressionMethod::Gzip,
diff --git a/dbms/src/Server/HTTPHandler.cpp b/dbms/src/Server/HTTPHandler.cpp
index 8a421b94ff2..272b32da707 100644
--- a/dbms/src/Server/HTTPHandler.cpp
+++ b/dbms/src/Server/HTTPHandler.cpp
@@ -297,7 +297,7 @@ void HTTPHandler::processQuery(
     size_t buffer_size_memory = (buffer_size_total > buffer_size_http) ? buffer_size_total : 0;
 
     used_output.out = std::make_shared<WriteBufferFromHTTPServerResponse>(
-        response, client_supports_http_compression, http_response_compression_method, buffer_size_http);
+        request, response, client_supports_http_compression, http_response_compression_method, buffer_size_http);
     if (internal_compression)
         used_output.out_maybe_compressed = std::make_shared<CompressedWriteBuffer>(*used_output.out);
     else
diff --git a/dbms/src/Server/InterserverIOHTTPHandler.cpp b/dbms/src/Server/InterserverIOHTTPHandler.cpp
index 4e3c9589723..c3813442897 100644
--- a/dbms/src/Server/InterserverIOHTTPHandler.cpp
+++ b/dbms/src/Server/InterserverIOHTTPHandler.cpp
@@ -36,7 +36,7 @@ void InterserverIOHTTPHandler::processQuery(Poco::Net::HTTPServerRequest & reque
 
     ReadBufferFromIStream body(request.stream());
 
-    WriteBufferFromHTTPServerResponse out(response);
+    WriteBufferFromHTTPServerResponse out(request, response);
 
     auto endpoint = server.context().getInterserverIOHandler().getEndpoint(endpoint_name);
 
diff --git a/dbms/tests/queries/0_stateless/00497_whitespaces_in_insert.sh b/dbms/tests/queries/0_stateless/00497_whitespaces_in_insert.sh
index 09d1aa3de88..d1dca22530a 100755
--- a/dbms/tests/queries/0_stateless/00497_whitespaces_in_insert.sh
+++ b/dbms/tests/queries/0_stateless/00497_whitespaces_in_insert.sh
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 clickhouse-client -q "DROP TABLE IF EXISTS test.ws";
 clickhouse-client -q "CREATE TABLE test.ws (i UInt8) ENGINE = Memory";
diff --git a/dbms/tests/queries/0_stateless/00498_http_head.reference b/dbms/tests/queries/0_stateless/00498_http_head.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/dbms/tests/queries/0_stateless/00498_http_head.sh b/dbms/tests/queries/0_stateless/00498_http_head.sh
new file mode 100755
index 00000000000..558730d3ae3
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00498_http_head.sh
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+
+curl -s -X "HEAD" 'http://localhost:8123/?query=SELECT%201'
+curl -s -X "HEAD" 'http://localhost:8123/?query=select+*+from+system.numbers+limit+1000000'

From 7b2cc11520fd5ce5e7c202dbcd6c6465f360ce6c Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Sat, 2 Sep 2017 00:47:37 +0300
Subject: [PATCH 058/266] Update WriteBufferFromHTTPServerResponse.cpp

---
 dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp b/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp
index 026495ddd96..b0eb87089b8 100644
--- a/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp
+++ b/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp
@@ -54,7 +54,9 @@ void WriteBufferFromHTTPServerResponse::finishSendHeaders()
             if (!response_body_ostr)
                 response_body_ostr = &(response.send());
 #endif
-        } else {
+        }
+        else
+        {
             if (!response_body_ostr)
                 response_body_ostr = &(response.send());
         }

From f079af61978fee1f19229618f744a25a70b846fc Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Sat, 2 Sep 2017 00:48:18 +0300
Subject: [PATCH 059/266] Update WriteBufferFromHTTPServerResponse.cpp

---
 dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp b/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp
index b0eb87089b8..47cab4fbd81 100644
--- a/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp
+++ b/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp
@@ -43,7 +43,8 @@ void WriteBufferFromHTTPServerResponse::finishSendHeaders()
     {
         headers_finished_sending = true;
 
-        if (request.getMethod() != Poco::Net::HTTPRequest::HTTP_HEAD) {
+        if (request.getMethod() != Poco::Net::HTTPRequest::HTTP_HEAD)
+        {
 #if POCO_CLICKHOUSE_PATCH
             /// Send end of headers delimiter.
             if (response_header_ostr)

From ffd75017e745e8aafd0fbe6223babee5b94912ae Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Sat, 2 Sep 2017 00:49:06 +0300
Subject: [PATCH 060/266] Update WriteBufferFromHTTPServerResponse.cpp

---
 dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp b/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp
index 47cab4fbd81..26179b05873 100644
--- a/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp
+++ b/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp
@@ -120,7 +120,8 @@ void WriteBufferFromHTTPServerResponse::nextImpl()
 
     }
 
-    if (out) {
+    if (out)
+    {
         out->position() = position();
         out->next();
     }

From b6a533adefdf1ff87892ba1b5a07d3d7ec283238 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 2 Sep 2017 01:00:25 +0300
Subject: [PATCH 061/266] Added test [#CLICKHOUSE-3270].

---
 .../0_stateless/00499_json_enum_insert.reference    |  6 ++++++
 .../queries/0_stateless/00499_json_enum_insert.sql  | 13 +++++++++++++
 2 files changed, 19 insertions(+)
 create mode 100644 dbms/tests/queries/0_stateless/00499_json_enum_insert.reference
 create mode 100644 dbms/tests/queries/0_stateless/00499_json_enum_insert.sql

diff --git a/dbms/tests/queries/0_stateless/00499_json_enum_insert.reference b/dbms/tests/queries/0_stateless/00499_json_enum_insert.reference
new file mode 100644
index 00000000000..7f9f2cfae4c
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00499_json_enum_insert.reference
@@ -0,0 +1,6 @@
+browser	Hello
+browser	Hello
+browser	World 1
+browser	Hello
+browser	World 1
+browser	World 2
diff --git a/dbms/tests/queries/0_stateless/00499_json_enum_insert.sql b/dbms/tests/queries/0_stateless/00499_json_enum_insert.sql
new file mode 100644
index 00000000000..41b3fcc3837
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00499_json_enum_insert.sql
@@ -0,0 +1,13 @@
+DROP TABLE IF EXISTS test.json;
+CREATE TABLE test.json (x Enum8('browser' = 1, 'mobile' = 2), y String) ENGINE = Memory;
+
+INSERT INTO test.json (y) VALUES ('Hello');
+SELECT * FROM test.json ORDER BY y;
+
+INSERT INTO test.json (y) FORMAT JSONEachRow {"y": "World 1"};
+SELECT * FROM test.json ORDER BY y;
+
+INSERT INTO test.json (x, y) FORMAT JSONEachRow {"y": "World 2"};
+SELECT * FROM test.json ORDER BY y;
+
+DROP TABLE test.json;

From 706d4db332f965012c97cdc77c89d2d4f0404f6b Mon Sep 17 00:00:00 2001
From: Vitaliy Lyudvichenko <vludv@yandex-team.ru>
Date: Mon, 4 Sep 2017 15:49:49 +0300
Subject: [PATCH 062/266] Made RWLockFIFO recursive. [#CLICKHOUSE-3246]

---
 dbms/src/Common/RWLockFIFO.cpp                |  51 +++++--
 dbms/src/Common/RWLockFIFO.h                  |  21 ++-
 .../Common/tests/gtest_rw_lock_fifo.cpp.cpp   | 142 +++++++++++++-----
 3 files changed, 160 insertions(+), 54 deletions(-)

diff --git a/dbms/src/Common/RWLockFIFO.cpp b/dbms/src/Common/RWLockFIFO.cpp
index 2367ee6f76f..ec5dc35c990 100644
--- a/dbms/src/Common/RWLockFIFO.cpp
+++ b/dbms/src/Common/RWLockFIFO.cpp
@@ -7,14 +7,38 @@
 namespace DB
 {
 
+namespace ErrorCodes
+{
+    extern const int LOGICAL_ERROR;
+}
+
 
 RWLockFIFO::LockHandler RWLockFIFO::getLock(RWLockFIFO::Type type, RWLockFIFO::Client client)
 {
     GroupsContainer::iterator it_group;
     ClientsContainer::iterator it_client;
 
+    auto this_thread_id = std::this_thread::get_id();
+
     std::unique_lock<std::mutex> lock(mutex);
 
+    /// Check if the same thread is acquiring previously acquired lock
+    auto it_handler = thread_to_handler.find(this_thread_id);
+    if (it_handler != thread_to_handler.end())
+    {
+        auto handler_ptr = it_handler->second.lock();
+
+        if (!handler_ptr)
+            throw Exception("Lock handler cannot be nullptr. This is a bug", ErrorCodes::LOGICAL_ERROR);
+
+        if (type != Read || handler_ptr->it_group->type != Read)
+            throw Exception("Attempt to acquire exclusive lock recursively", ErrorCodes::LOGICAL_ERROR);
+
+        handler_ptr->it_client->info += "; " + client.info;
+
+        return  handler_ptr;
+    }
+
     if (type == Type::Write || queue.empty() || queue.back().type == Type::Write)
     {
         /// Create new group of clients
@@ -44,7 +68,11 @@ RWLockFIFO::LockHandler RWLockFIFO::getLock(RWLockFIFO::Type type, RWLockFIFO::C
     it_client->enqueue_time = time(nullptr);
     it_client->type = type;
 
-    LockHandler res = std::make_unique<LockHandlerImpl>(shared_from_this(), it_group, it_client);
+    LockHandler res(new LockHandlerImpl(shared_from_this(), it_group, it_client));
+
+    /// Insert myself (weak_ptr to the handler) to threads set to implement recursive lock
+    it_handler = thread_to_handler.emplace(this_thread_id, res).first;
+    res->it_handler = it_handler;
 
     /// We are first, we should not wait anything
     /// If we are not the first client in the group, a notification could be already sent
@@ -79,14 +107,18 @@ RWLockFIFO::Clients RWLockFIFO::getClientsInTheQueue() const
 }
 
 
-void RWLockFIFO::LockHandlerImpl::unlock()
+RWLockFIFO::LockHandlerImpl::~LockHandlerImpl()
 {
     std::unique_lock<std::mutex> lock(parent->mutex);
 
-    auto & clients = it_group->clients;
-    clients.erase(it_client);
+    /// Remove weak_ptr to the handler, since there are no owners of the current lock
+    parent->thread_to_handler.erase(it_handler);
 
-    if (clients.empty())
+    /// Removes myself from client list of our group
+    it_group->clients.erase(it_client);
+
+    /// Remove the group if we were the last client and notify the next group
+    if (it_group->clients.empty())
     {
         auto & queue = parent->queue;
         queue.erase(it_group);
@@ -99,11 +131,8 @@ void RWLockFIFO::LockHandlerImpl::unlock()
 }
 
 
-RWLockFIFO::LockHandlerImpl::~LockHandlerImpl()
-{
-    if (parent)
-        unlock();
-}
-
+RWLockFIFO::LockHandlerImpl::LockHandlerImpl(RWLockFIFOPtr && parent, RWLockFIFO::GroupsContainer::iterator it_group,
+                                             RWLockFIFO::ClientsContainer::iterator it_client)
+    : parent{std::move(parent)}, it_group{it_group}, it_client{it_client} {}
 
 }
diff --git a/dbms/src/Common/RWLockFIFO.h b/dbms/src/Common/RWLockFIFO.h
index 6353e4c6cbe..a106fa36edd 100644
--- a/dbms/src/Common/RWLockFIFO.h
+++ b/dbms/src/Common/RWLockFIFO.h
@@ -4,6 +4,8 @@
 #include <vector>
 #include <mutex>
 #include <condition_variable>
+#include <thread>
+#include <map>
 
 
 namespace DB
@@ -14,7 +16,7 @@ using RWLockFIFOPtr = std::shared_ptr<RWLockFIFO>;
 
 
 /// Implements shared lock with FIFO service
-/// It does not work as recursive mutex, so a deadlock will occur if you try to acquire 2 locks in the same thread
+/// You could call it recursively (several calls from the same thread) in Read mode
 class RWLockFIFO : public std::enable_shared_from_this<RWLockFIFO>
 {
 public:
@@ -35,6 +37,8 @@ public:
     {
         explicit Client(const std::string & info = {}) : info{info} {}
 
+        bool isStarted() { return start_time != 0; }
+
         std::string info;
         int thread_number = 0;
         std::time_t enqueue_time = 0;
@@ -42,8 +46,11 @@ public:
         Type type;
     };
 
+
+    /// Just use LockHandler::reset() to release the lock
     class LockHandlerImpl;
-    using LockHandler = std::unique_ptr<LockHandlerImpl>;
+    using LockHandler = std::shared_ptr<LockHandlerImpl>;
+
 
     /// Waits in the queue and returns appropriate lock
     LockHandler getLock(Type type, Client client = Client{});
@@ -65,6 +72,7 @@ private:
     struct Group;
     using GroupsContainer = std::list<Group>;
     using ClientsContainer = std::list<Client>;
+    using ThreadToHandler = std::map<std::thread::id, std::weak_ptr<LockHandlerImpl>>;
 
     /// Group of clients that should be executed concurrently
     /// i.e. a group could contain several readers, but only one writer
@@ -85,16 +93,14 @@ public:
         RWLockFIFOPtr parent;
         GroupsContainer::iterator it_group;
         ClientsContainer::iterator it_client;
+        ThreadToHandler::iterator it_handler;
+
+        LockHandlerImpl(RWLockFIFOPtr && parent, GroupsContainer::iterator it_group, ClientsContainer::iterator it_client);
 
     public:
-        LockHandlerImpl(RWLockFIFOPtr && parent, GroupsContainer::iterator it_group, ClientsContainer::iterator it_client)
-                : parent{std::move(parent)}, it_group{it_group}, it_client{it_client} {}
 
         LockHandlerImpl(const LockHandlerImpl & other) = delete;
 
-        /// Unlocks acquired lock
-        void unlock();
-
         ~LockHandlerImpl();
 
         friend class RWLockFIFO;
@@ -104,6 +110,7 @@ private:
 
     mutable std::mutex mutex;
     GroupsContainer queue;
+    ThreadToHandler thread_to_handler;
 };
 
 
diff --git a/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp b/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp
index 63a29bbe567..70d9815d89c 100644
--- a/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp
+++ b/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp
@@ -11,8 +11,12 @@
 
 using namespace DB;
 
-static void execute_1(size_t threads, int round, int cycles)
+
+TEST(Common, RWLockFIFO_1)
 {
+    constexpr int cycles = 10000;
+    const std::vector<size_t> pool_sizes{1, 2, 4, 8};
+
     static std::atomic<int> readers{0};
     static std::atomic<int> writers{0};
 
@@ -21,43 +25,39 @@ static void execute_1(size_t threads, int round, int cycles)
     static __thread std::random_device rd;
     static __thread std::mt19937 gen(rd());
 
-    for (int  i = 0; i < cycles; ++i)
-    {
-        auto type = (std::uniform_int_distribution<>(0, 9)(gen) >= round) ? RWLockFIFO::Read : RWLockFIFO::Write;
-        auto sleep_for = std::chrono::duration<int, std::micro>(std::uniform_int_distribution<>(1, 1000)(gen));
-
-        auto lock = fifo_lock->getLock(type, "RW");
-
-        if (type == RWLockFIFO::Write)
+    auto func = [&] (size_t threads, int round) {
+        for (int  i = 0; i < cycles; ++i)
         {
-            ++writers;
+            auto type = (std::uniform_int_distribution<>(0, 9)(gen) >= round) ? RWLockFIFO::Read : RWLockFIFO::Write;
+            auto sleep_for = std::chrono::duration<int, std::micro>(std::uniform_int_distribution<>(1, 100)(gen));
 
-            ASSERT_EQ(writers, 1);
-            ASSERT_EQ(readers, 0);
+            auto lock = fifo_lock->getLock(type, "RW");
 
-            std::this_thread::sleep_for(sleep_for);
+            if (type == RWLockFIFO::Write)
+            {
+                ++writers;
 
-            --writers;
+                ASSERT_EQ(writers, 1);
+                ASSERT_EQ(readers, 0);
+
+                std::this_thread::sleep_for(sleep_for);
+
+                --writers;
+            }
+            else
+            {
+                ++readers;
+
+                ASSERT_EQ(writers, 0);
+                ASSERT_GE(readers, 1);
+                ASSERT_LE(readers, threads);
+
+                std::this_thread::sleep_for(sleep_for);
+
+                --readers;
+            }
         }
-        else
-        {
-            ++readers;
-
-            ASSERT_EQ(writers, 0);
-            ASSERT_GE(readers, 1);
-            ASSERT_LE(readers, threads);
-
-            std::this_thread::sleep_for(sleep_for);
-
-            --readers;
-        }
-    }
-}
-
-TEST(Common, RWLockFIFO_1)
-{
-    constexpr int cycles = 10000;
-    const std::vector<size_t> pool_sizes{1, 2, 4, 8};
+    };
 
     for (auto pool_size : pool_sizes)
     {
@@ -65,10 +65,9 @@ TEST(Common, RWLockFIFO_1)
         {
             Stopwatch watch(CLOCK_MONOTONIC_COARSE);
 
-            std::vector<std::thread> threads;
-            threads.reserve(pool_size);
+            std::list<std::thread> threads;
             for (int thread = 0; thread < pool_size; ++thread)
-                threads.emplace_back([=] () { execute_1(pool_size, round, cycles); });
+                threads.emplace_back([=] () { func(pool_size, round); });
 
             for (auto & thread : threads)
                 thread.join();
@@ -78,3 +77,74 @@ TEST(Common, RWLockFIFO_1)
         }
     }
 }
+
+TEST(Common, RWLockFIFO_Recursive)
+{
+    constexpr auto cycles = 10000;
+
+    static auto fifo_lock = RWLockFIFO::create();
+
+    static __thread std::random_device rd;
+    static __thread std::mt19937 gen(rd());
+
+    std::thread t1([&] () {
+        for (int i = 0; i < 2 * cycles; ++i)
+        {
+            auto lock = fifo_lock->getLock(RWLockFIFO::Write);
+
+            auto sleep_for = std::chrono::duration<int, std::micro>(std::uniform_int_distribution<>(1, 100)(gen));
+            std::this_thread::sleep_for(sleep_for);
+        }
+    });
+
+    std::thread t2([&] () {
+        for (int i = 0; i < cycles; ++i)
+        {
+            auto lock1 = fifo_lock->getLock(RWLockFIFO::Read);
+
+            auto sleep_for = std::chrono::duration<int, std::micro>(std::uniform_int_distribution<>(1, 100)(gen));
+            std::this_thread::sleep_for(sleep_for);
+
+            auto lock2 = fifo_lock->getLock(RWLockFIFO::Read);
+            
+            EXPECT_ANY_THROW({fifo_lock->getLock(RWLockFIFO::Write);});
+        }
+
+        fifo_lock->getLock(RWLockFIFO::Write);
+    });
+
+    t1.join();
+    t2.join();
+}
+
+
+TEST(Common, RWLockFIFO_PerfTest_Readers)
+{
+    constexpr int cycles = 1000000; // 1 mln
+    const std::vector<size_t> pool_sizes{1, 2, 4, 8};
+
+    static auto fifo_lock = RWLockFIFO::create();
+
+    for (auto pool_size : pool_sizes)
+    {
+            Stopwatch watch(CLOCK_MONOTONIC_COARSE);
+
+            auto func = [&] ()
+            {
+                for (auto i = 0; i < cycles; ++i)
+                {
+                    auto lock = fifo_lock->getLock(RWLockFIFO::Read);
+                }
+            };
+
+            std::list<std::thread> threads;
+            for (int thread = 0; thread < pool_size; ++thread)
+                threads.emplace_back(func);
+
+            for (auto & thread : threads)
+                thread.join();
+
+            auto total_time = watch.elapsedSeconds();
+            std::cout << "Threads " << pool_size << ", total_time " << std::setprecision(2) << total_time << "\n";
+    }
+}

From e39fb48377dcfb9b54c2d6e85cb0d14315d9a2c9 Mon Sep 17 00:00:00 2001
From: Vladimir Chebotarev <chebotarev@yandex-team.ru>
Date: Mon, 4 Sep 2017 16:45:50 +0300
Subject: [PATCH 063/266] functions: pointInPolygon(). [#CLICKHOUSE-3201]

---
 dbms/src/Functions/FunctionsGeo.cpp           | 178 ++++++++++++++++++
 .../00500_point_in_polygon.reference          |   9 +
 .../0_stateless/00500_point_in_polygon.sql    |   9 +
 3 files changed, 196 insertions(+)
 create mode 100644 dbms/tests/queries/0_stateless/00500_point_in_polygon.reference
 create mode 100644 dbms/tests/queries/0_stateless/00500_point_in_polygon.sql

diff --git a/dbms/src/Functions/FunctionsGeo.cpp b/dbms/src/Functions/FunctionsGeo.cpp
index e76daa6afa0..f8d3d4b2fbf 100644
--- a/dbms/src/Functions/FunctionsGeo.cpp
+++ b/dbms/src/Functions/FunctionsGeo.cpp
@@ -1,13 +1,191 @@
 #include <Functions/FunctionFactory.h>
 #include <Functions/FunctionsGeo.h>
 
+#include <boost/geometry.hpp>
+#include <boost/geometry/geometries/point_xy.hpp>
+#include <boost/geometry/geometries/polygon.hpp>
+
+#include <Interpreters/ExpressionActions.h>
+#include <DataTypes/DataTypeTuple.h>
+#include <Columns/ColumnTuple.h>
+
 
 namespace DB
 {
+namespace ErrorCodes
+{
+    extern const int TOO_LESS_ARGUMENTS_FOR_FUNCTION;
+    extern const int BAD_ARGUMENTS;
+}
+
+
+template <typename... Args>
+using PointInPolygonCrossing = boost::geometry::strategy::within::crossings_multiply<Args...>;
+template <typename... Args>
+using PointInPolygonWinding = boost::geometry::strategy::within::winding<Args...>;
+template <typename... Args>
+using PointInPolygonFranklin = boost::geometry::strategy::within::franklin<Args...>;
+
+template <template <typename...> typename Strategy>
+class FunctionPointInPolygon : public IFunction
+{
+public:
+    static const char * name;
+
+    static FunctionPtr create(const Context & context)
+    {
+        return std::make_shared<FunctionPointInPolygon<Strategy>>();
+    }
+
+    String getName() const override
+    {
+        return name;
+    }
+
+    bool isVariadic() const override
+    {
+        return true;
+    }
+
+    size_t getNumberOfArguments() const override
+    {
+        return 0;
+    }
+
+    void getReturnTypeAndPrerequisitesImpl(
+        const ColumnsWithTypeAndName & arguments, DataTypePtr & out_return_type, ExpressionActions::Actions & out_prerequisites) override
+    {
+        if (arguments.size() < 2)
+        {
+            throw Exception("Too few arguments", ErrorCodes::TOO_LESS_ARGUMENTS_FOR_FUNCTION);
+        }
+
+        for (size_t i = 0; i < arguments.size(); ++i)
+        {
+            const DataTypeTuple * tuple = checkAndGetDataType<DataTypeTuple>(&*arguments[i].type);
+            if (tuple == nullptr)
+            {
+                throw Exception("Argument " + std::to_string(i+1) + " for function " + getName() + " must be tuple.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+            }
+
+            const DataTypes & elems = tuple->getElements();
+
+            if (elems.size() != 2)
+            {
+                throw Exception("Tuple in argument " + std::to_string(i+1) + " must have exactly two elements.", ErrorCodes::BAD_ARGUMENTS);
+            }
+
+            for (size_t elems_index = 0; elems_index < elems.size(); ++elems_index)
+            {
+                if (!checkDataType<DataTypeFloat64>(&*elems[elems_index]))
+                {
+                    throw Exception("Tuple element " + std::to_string(elems_index + 1) + " in argument " + std::to_string(i+1) + " must be Float64.", ErrorCodes::BAD_ARGUMENTS);
+                }
+            }
+        }
+
+        out_return_type = std::make_shared<DataTypeUInt8>();
+    }
+
+    void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override
+    {
+        if (block.rows() == 0)
+        {
+            return;
+        }
+
+        using PointType = boost::geometry::model::d2::point_xy<double>;
+        using PolygonType = boost::geometry::model::polygon<PointType>;
+        std::pair<double, double> min, max;
+
+        std::vector<PointType> polygon_points(arguments.size()-1);
+
+        for (size_t i = 1; i < arguments.size(); ++i)
+        {
+            auto const_tuple_col = checkAndGetColumnConst<ColumnTuple>(block.getByPosition(arguments[i]).column.get());
+            if (!const_tuple_col)
+            {
+                throw Exception("Argument " + std::to_string(i+1) + " for function " + getName() + " must be constant tuple.", ErrorCodes::ILLEGAL_COLUMN);
+            }
+
+            TupleBackend data = const_tuple_col->getValue<Tuple>();
+            const double x = data[0].get<Float64>();
+            const double y = data[1].get<Float64>();
+            polygon_points[i-1] = PointType(x, y);
+            if (i == 1)
+            {
+                min.first = x;
+                min.second = y;
+                max.first = x;
+                max.second = y;
+            }
+            else
+            {
+                min.first = std::min(min.first, x);
+                max.first = std::max(max.first, x);
+                min.second = std::min(min.second, y);
+                max.second = std::max(max.second, y);
+            }
+        }
+
+        PolygonType polygon;
+        boost::geometry::assign_points(polygon, polygon_points);
+
+        Strategy<PointType> strategy;
+        auto point_checker = [&](double x, double y) -> bool
+        {
+            if (x < min.first || x > max.first || y < min.second || y > max.second)
+            {
+                return false;
+            }
+            PointType point(x, y);
+            return boost::geometry::covered_by(point, polygon, strategy);
+        };
+
+        auto point_column_const = checkAndGetColumnConst<ColumnTuple>(block.getByPosition(arguments[0]).column.get());
+        if (point_column_const)
+        {
+            TupleBackend data = point_column_const->getValue<Tuple>();
+            const double point_x = data[0].get<Float64>();
+            const double point_y = data[1].get<Float64>();
+            UInt8 value = point_checker(point_x, point_y) ? 1 : 0;
+            block.getByPosition(result).column = DataTypeUInt8().createConstColumn(block.rows(), UInt64(value));
+            return;
+        }
+
+        auto & res = block.getByPosition(result);
+        res.column = std::make_shared<ColumnUInt8>(block.rows());
+        IColumn & result_column = *res.column;
+        auto & result_data = static_cast<ColumnUInt8 &>(result_column).getData();
+
+        auto point_column = checkAndGetColumn<ColumnTuple>(block.getByPosition(arguments[0]).column.get());
+        auto column_x = checkAndGetColumn<ColumnFloat64>(point_column->getData().getByPosition(0).column.get());
+        auto column_y = checkAndGetColumn<ColumnFloat64>(point_column->getData().getByPosition(1).column.get());
+
+        for (size_t i = 0; i < block.rows(); ++i)
+        {
+            const double point_x = column_x->getElement(i);
+            const double point_y = column_y->getElement(i);
+            result_data[i] = point_checker(point_x, point_y) ? 1 : 0;
+        }
+    }
+};
+
+template <>
+const char * FunctionPointInPolygon<PointInPolygonCrossing>::name = "pointInPolygon";
+template <>
+const char * FunctionPointInPolygon<PointInPolygonWinding>::name = "pointInPolygonWinding";
+template <>
+const char * FunctionPointInPolygon<PointInPolygonFranklin>::name = "pointInPolygonFranklin";
+
 
 void registerFunctionsGeo(FunctionFactory & factory)
 {
     factory.registerFunction<FunctionGreatCircleDistance>();
     factory.registerFunction<FunctionPointInEllipses>();
+
+    factory.registerFunction<FunctionPointInPolygon<PointInPolygonFranklin>>();
+    factory.registerFunction<FunctionPointInPolygon<PointInPolygonWinding>>();
+    factory.registerFunction<FunctionPointInPolygon<PointInPolygonCrossing>>();
 }
 }
diff --git a/dbms/tests/queries/0_stateless/00500_point_in_polygon.reference b/dbms/tests/queries/0_stateless/00500_point_in_polygon.reference
new file mode 100644
index 00000000000..86f0cc513fd
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00500_point_in_polygon.reference
@@ -0,0 +1,9 @@
+1
+0
+0
+1
+0
+0
+1
+0
+0
diff --git a/dbms/tests/queries/0_stateless/00500_point_in_polygon.sql b/dbms/tests/queries/0_stateless/00500_point_in_polygon.sql
new file mode 100644
index 00000000000..c5c5cbe8d8d
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00500_point_in_polygon.sql
@@ -0,0 +1,9 @@
+SELECT pointInPolygonFranklin(tuple(2.0,1.0), tuple(0.0,0.0), tuple(3.0,3.0), tuple(3.0,0.0), tuple(0.0,0.0));
+SELECT pointInPolygonFranklin(tuple(1.0,2.0), tuple(0.0,0.0), tuple(3.0,3.0), tuple(3.0,0.0), tuple(0.0,0.0));
+SELECT pointInPolygonFranklin(tuple(4.0,1.0), tuple(0.0,0.0), tuple(3.0,3.0), tuple(3.0,0.0), tuple(0.0,0.0));
+SELECT pointInPolygon(tuple(2.0,1.0), tuple(0.0,0.0), tuple(3.0,3.0), tuple(3.0,0.0), tuple(0.0,0.0));
+SELECT pointInPolygon(tuple(1.0,2.0), tuple(0.0,0.0), tuple(3.0,3.0), tuple(3.0,0.0), tuple(0.0,0.0));
+SELECT pointInPolygon(tuple(4.0,1.0), tuple(0.0,0.0), tuple(3.0,3.0), tuple(3.0,0.0), tuple(0.0,0.0));
+SELECT pointInPolygonWinding(tuple(2.0,1.0), tuple(0.0,0.0), tuple(3.0,3.0), tuple(3.0,0.0), tuple(0.0,0.0));
+SELECT pointInPolygonWinding(tuple(1.0,2.0), tuple(0.0,0.0), tuple(3.0,3.0), tuple(3.0,0.0), tuple(0.0,0.0));
+SELECT pointInPolygonWinding(tuple(4.0,1.0), tuple(0.0,0.0), tuple(3.0,3.0), tuple(3.0,0.0), tuple(0.0,0.0));

From 0544e0c75fccde87fa18fa61a216d1b4cad18a87 Mon Sep 17 00:00:00 2001
From: robot-metrika-test <robot-metrika-test@yandex-team.ru>
Date: Mon, 4 Sep 2017 17:31:54 +0300
Subject: [PATCH 064/266] Auto version update to [54285]

---
 dbms/cmake/version.cmake | 4 ++--
 debian/changelog         | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/dbms/cmake/version.cmake b/dbms/cmake/version.cmake
index e5a67e1c743..146988c0661 100644
--- a/dbms/cmake/version.cmake
+++ b/dbms/cmake/version.cmake
@@ -1,6 +1,6 @@
 # This strings autochanged from release_lib.sh:
-set(VERSION_DESCRIBE v1.1.54281-testing)
-set(VERSION_REVISION 54281)
+set(VERSION_DESCRIBE v1.1.54285-testing)
+set(VERSION_REVISION 54285)
 # end of autochange
 
 set (VERSION_MAJOR 1)
diff --git a/debian/changelog b/debian/changelog
index 8f6dc3b2b4a..f88a93b6db1 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,5 +1,5 @@
-clickhouse (1.1.54281) unstable; urgency=low
+clickhouse (1.1.54285) unstable; urgency=low
 
   * Modified source code
 
- --  <robot-metrika-test@yandex-team.ru>  Wed, 23 Aug 2017 15:09:15 +0300
+ --  <robot-metrika-test@yandex-team.ru>  Mon, 04 Sep 2017 17:31:53 +0300

From 39c1bf0984ebdf46c1a3fcb5c9c2e082bf61f6e0 Mon Sep 17 00:00:00 2001
From: proller <proller@users.noreply.github.com>
Date: Mon, 4 Sep 2017 18:14:05 +0300
Subject: [PATCH 065/266] Fix freebsd/macos compile (#1194)

* Header compile fixes

* Fix includes

* Update debian/.pbuilderrc description

* Fix freebsd/macos compile
---
 dbms/src/Common/RWLockFIFO.h                     | 1 +
 dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/dbms/src/Common/RWLockFIFO.h b/dbms/src/Common/RWLockFIFO.h
index 6353e4c6cbe..9cd22157d5e 100644
--- a/dbms/src/Common/RWLockFIFO.h
+++ b/dbms/src/Common/RWLockFIFO.h
@@ -4,6 +4,7 @@
 #include <vector>
 #include <mutex>
 #include <condition_variable>
+#include <string>
 
 
 namespace DB
diff --git a/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp b/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp
index 63a29bbe567..50c570b98f4 100644
--- a/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp
+++ b/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp
@@ -18,8 +18,8 @@ static void execute_1(size_t threads, int round, int cycles)
 
     static auto fifo_lock = RWLockFIFO::create();
 
-    static __thread std::random_device rd;
-    static __thread std::mt19937 gen(rd());
+    static thread_local std::random_device rd;
+    static thread_local std::mt19937 gen(rd());
 
     for (int  i = 0; i < cycles; ++i)
     {

From f68a0ea63bb5d66ae8bcc0bab8457b2961e899ca Mon Sep 17 00:00:00 2001
From: proller <proller@users.noreply.github.com>
Date: Mon, 4 Sep 2017 20:04:33 +0300
Subject: [PATCH 066/266] Fix mysql includes and remove libmariadb submodule
 (#1185)

* Use bundled libmariadbclient (CLICKHOUSE-3261)

* wip

* wip

* wip

* Update docs about git clone. move docs/en/development/build_*.sh -> utils/build/build_debian.sh

* Fix mysql includes

* Cmake: don't install mariadb targets

* Fix generated includes

* Disable mysql tests

* cmake: mariadb fixes

* Fix

* Update find_mysqlclient.cmake

* Fix zlib

* Remove bundled contrib/mariadb-connector-c

* fix

* Fix build

* Fix includes
---
 .gitmodules                                  |  3 --
 contrib/CMakeLists.txt                       | 29 ++++++++------------
 contrib/mariadb-connector-c                  |  1 -
 libs/libmysqlxx/CMakeLists.txt               |  7 +++--
 libs/libmysqlxx/cmake/find_mysqlclient.cmake | 21 ++------------
 5 files changed, 20 insertions(+), 41 deletions(-)
 delete mode 160000 contrib/mariadb-connector-c

diff --git a/.gitmodules b/.gitmodules
index 3e2525f500b..e69de29bb2d 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -1,3 +0,0 @@
-[submodule "contrib/mariadb-connector-c"]
-	path = contrib/mariadb-connector-c
-	url = /MariaDB/mariadb-connector-c.git
diff --git a/contrib/CMakeLists.txt b/contrib/CMakeLists.txt
index 8d9845f4140..bb61c089acc 100644
--- a/contrib/CMakeLists.txt
+++ b/contrib/CMakeLists.txt
@@ -1,31 +1,31 @@
 set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-old-style-cast")
 
 if (USE_INTERNAL_BOOST_LIBRARY)
-	add_subdirectory (libboost)
+    add_subdirectory (libboost)
 endif ()
 
 if (USE_INTERNAL_POCO_LIBRARY)
-	add_subdirectory (libpoco)
+    add_subdirectory (libpoco)
 endif ()
 
 if (USE_INTERNAL_LZ4_LIBRARY)
-	add_subdirectory (liblz4)
+    add_subdirectory (liblz4)
 endif ()
 
 if (USE_INTERNAL_ZSTD_LIBRARY)
-	add_subdirectory (libzstd)
+    add_subdirectory (libzstd)
 endif ()
 
 if (USE_INTERNAL_RE2_LIBRARY)
-	add_subdirectory (libre2)
+    add_subdirectory (libre2)
 endif ()
 
 if (USE_INTERNAL_DOUBLE_CONVERSION_LIBRARY)
-	add_subdirectory (libdouble-conversion)
+    add_subdirectory (libdouble-conversion)
 endif ()
 
 if (USE_INTERNAL_ZOOKEEPER_LIBRARY)
-	add_subdirectory (libzookeeper)
+    add_subdirectory (libzookeeper)
 endif ()
 
 if (USE_INTERNAL_CITYHASH_LIBRARY)
@@ -45,26 +45,21 @@ if (USE_INTERNAL_BTRIE_LIBRARY)
 endif ()
 
 if (USE_INTERNAL_UNWIND_LIBRARY)
-	add_subdirectory (libunwind)
+    add_subdirectory (libunwind)
 endif ()
 
 if (USE_INTERNAL_ZLIB_LIBRARY)
-	add_subdirectory (libzlib-ng)
+    add_subdirectory (libzlib-ng)
 endif ()
 
 if (USE_INTERNAL_CCTZ_LIBRARY)
-	add_subdirectory (libcctz)
+    add_subdirectory (libcctz)
 endif ()
 
 if (ENABLE_LIBTCMALLOC AND USE_INTERNAL_GPERFTOOLS_LIBRARY)
-	add_subdirectory (libtcmalloc)
+    add_subdirectory (libtcmalloc)
 endif ()
 
 if (NOT ARCH_ARM)
-	add_subdirectory (libcpuid)
-endif ()
-
-if (USE_INTERNAL_MYSQL_LIBRARY)
-    add_subdirectory (mariadb-connector-c)
-    target_include_directories (${MYSQLCLIENT_LIBRARIES} BEFORE PUBLIC ${MYSQL_INCLUDE_DIR})
+    add_subdirectory (libcpuid)
 endif ()
diff --git a/contrib/mariadb-connector-c b/contrib/mariadb-connector-c
deleted file mode 160000
index 35d6fb19961..00000000000
--- a/contrib/mariadb-connector-c
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 35d6fb199611158109a898e695eca2564ef826fa
diff --git a/libs/libmysqlxx/CMakeLists.txt b/libs/libmysqlxx/CMakeLists.txt
index e3a35601f90..9ae1678fcac 100644
--- a/libs/libmysqlxx/CMakeLists.txt
+++ b/libs/libmysqlxx/CMakeLists.txt
@@ -32,8 +32,11 @@ target_include_directories (mysqlxx PUBLIC include)
 
 set(PLATFORM_LIBRARIES ${CMAKE_DL_LIBS})
 
-if (USE_INTERNAL_MYSQL_LIBRARY)
-elseif (USE_STATIC_LIBRARIES AND STATIC_MYSQLCLIENT_LIB)
+if (USE_MYSQL)
+    include_directories (${MYSQL_INCLUDE_DIR})
+endif ()
+
+if (USE_STATIC_LIBRARIES AND STATIC_MYSQLCLIENT_LIB)
     set (MYSQLCLIENT_LIB ${CMAKE_CURRENT_BINARY_DIR}/libmysqlclient.a)
     add_custom_command (
         OUTPUT ${MYSQLCLIENT_LIB}
diff --git a/libs/libmysqlxx/cmake/find_mysqlclient.cmake b/libs/libmysqlxx/cmake/find_mysqlclient.cmake
index 19aa1548f59..c27822ec855 100644
--- a/libs/libmysqlxx/cmake/find_mysqlclient.cmake
+++ b/libs/libmysqlxx/cmake/find_mysqlclient.cmake
@@ -1,15 +1,6 @@
 option (ENABLE_MYSQL "Enable MySQL" ON)
 
-option (USE_INTERNAL_MYSQL_LIBRARY "Set to FALSE to use system mysql library instead of bundled" ${NOT_UNBUNDLED})
-
 if (ENABLE_MYSQL)
-
-   if (NOT EXISTS "${ClickHouse_SOURCE_DIR}/contrib/mariadb-connector-c/CMakeLists.txt")
-      message (WARNING "submodule contrib/mariadb-connector-c is missing. to fix try run: git submodule update --init --recursive")
-      set (USE_INTERNAL_MYSQL_LIBRARY 0)
-   endif ()
-
-   if (NOT USE_INTERNAL_MYSQL_LIBRARY)
     set (MYSQL_LIB_PATHS
         "/usr/local/opt/mysql/lib"
         "/usr/local/lib/mysql/"
@@ -35,22 +26,16 @@ if (ENABLE_MYSQL)
     else ()
         find_library (MYSQLCLIENT_LIBRARIES mariadbclient mysqlclient PATHS ${MYSQL_LIB_PATHS})
     endif ()
-   endif ()
 
     if (MYSQL_INCLUDE_DIR AND (STATIC_MYSQLCLIENT_LIB OR MYSQLCLIENT_LIBRARIES))
-        include_directories (MYSQL_INCLUDE_DIR)
-    else ()                                   
-        set (USE_INTERNAL_MYSQL_LIBRARY 1)
-        set (MYSQLCLIENT_LIBRARIES mariadbclient)
-        set (MYSQL_INCLUDE_DIR "${ClickHouse_SOURCE_DIR}/contrib/mariadb-connector-c/include")
+        set (USE_MYSQL 1)
     endif ()
 
-    set(USE_MYSQL 1)
-    set(MYSQLXX_LIBRARY mysqlxx)
+    set (MYSQLXX_LIBRARY mysqlxx)
 endif ()
 
 if (USE_MYSQL)
-    message (STATUS "Using mysqlclient=${USE_MYSQL}: ${MYSQL_INCLUDE_DIR} : ${MYSQLCLIENT_LIBRARIES}; staticlib=${STATIC_MYSQLCLIENT_LIB} internal=${USE_INTERNAL_MYSQL_LIBRARY}")
+    message (STATUS "Using mysqlclient=${USE_MYSQL}: ${MYSQL_INCLUDE_DIR} : ${MYSQLCLIENT_LIBRARIES}; staticlib=${STATIC_MYSQLCLIENT_LIB}")
 else ()
     message (STATUS "Build without mysqlclient (support for MYSQL dictionary source will be disabled)")
 endif ()

From 1b3bc42586cf0dfc0f98bc1e30b5eeb97b4994f2 Mon Sep 17 00:00:00 2001
From: proller <proller@users.noreply.github.com>
Date: Mon, 4 Sep 2017 21:18:45 +0300
Subject: [PATCH 067/266] Fix freebsd/macos compile (#1198)

* Header compile fixes

* Fix includes

* Update debian/.pbuilderrc description

* Fix freebsd/macos compile

* Fix freebsd/macos compile
---
 dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp b/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp
index d4b900e290d..8dee71fb379 100644
--- a/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp
+++ b/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp
@@ -84,8 +84,8 @@ TEST(Common, RWLockFIFO_Recursive)
 
     static auto fifo_lock = RWLockFIFO::create();
 
-    static __thread std::random_device rd;
-    static __thread std::mt19937 gen(rd());
+    static thread_local std::random_device rd;
+    static thread_local std::mt19937 gen(rd());
 
     std::thread t1([&] () {
         for (int i = 0; i < 2 * cycles; ++i)

From 6901e80c4cbc1ed56e4be770e72db187697c8540 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Mon, 4 Sep 2017 21:56:02 +0300
Subject: [PATCH 068/266] Updated boost; added boost geometry
 [#CLICKHOUSE-3276].

---
 cmake/find_boost.cmake                        |     4 +-
 contrib/libboost/CMakeLists.txt               |    63 +-
 .../boost_1_62_0/boost/align/align_down.hpp   |    27 -
 .../boost/align/align_down_forward.hpp        |    24 -
 .../boost_1_62_0/boost/align/align_up.hpp     |    27 -
 .../boost/align/align_up_forward.hpp          |    24 -
 .../boost/align/aligned_delete_forward.hpp    |    20 -
 .../boost/align/alignment_of_forward.hpp      |    21 -
 .../boost/align/detail/align_cxx11.hpp        |    22 -
 .../boost/align/detail/align_down.hpp         |    28 -
 .../boost/align/detail/align_up.hpp           |    28 -
 .../boost/align/detail/assume_aligned.hpp     |    17 -
 .../boost/align/detail/assume_aligned_gcc.hpp |    18 -
 .../align/detail/assume_aligned_intel.hpp     |    18 -
 .../align/detail/assume_aligned_msvc.hpp      |    20 -
 .../boost/align/detail/is_aligned.hpp         |    36 -
 .../boost/align/detail/is_alignment.hpp       |    29 -
 .../boost_1_62_0/boost/align/is_aligned.hpp   |    27 -
 .../boost/align/is_aligned_forward.hpp        |    24 -
 .../boost/container/detail/algorithm.hpp      |    35 -
 .../boost/container/detail/hash_table.hpp     |   383 -
 .../boost_1_62_0/boost/core/addressof.hpp     |   162 -
 .../boost/core/checked_delete.hpp             |    69 -
 .../boost_1_62_0/boost/core/demangle.hpp      |   131 -
 .../boost_1_62_0/boost/core/enable_if.hpp     |   128 -
 .../boost/core/explicit_operator_bool.hpp     |   154 -
 .../boost_1_62_0/boost/core/ignore_unused.hpp |    70 -
 .../boost_1_62_0/boost/core/is_same.hpp       |    40 -
 .../boost/core/lightweight_test.hpp           |   171 -
 .../boost/core/lightweight_test_trait.hpp     |    56 -
 .../boost/core/no_exceptions_support.hpp      |    44 -
 .../boost_1_62_0/boost/core/noncopyable.hpp   |    48 -
 .../boost_1_62_0/boost/core/null_deleter.hpp  |    44 -
 .../libboost/boost_1_62_0/boost/core/ref.hpp  |   301 -
 .../boost_1_62_0/boost/core/scoped_enum.hpp   |   194 -
 .../libboost/boost_1_62_0/boost/core/swap.hpp |    60 -
 .../boost_1_62_0/boost/core/typeinfo.hpp      |   151 -
 .../boost/core/underlying_type.hpp            |    79 -
 .../boost_1_62_0/boost/exception/N3757.hpp    |    46 -
 .../boost/integer/common_factor_rt.hpp        |   460 -
 .../boost/intrusive/detail/to_raw_pointer.hpp |    47 -
 .../boost/math/common_factor_ct.hpp           |    97 -
 .../boost/math/common_factor_rt.hpp           |   428 -
 .../special_functions/detail/bessel_i0.hpp    |   129 -
 .../special_functions/detail/bessel_i1.hpp    |   133 -
 .../special_functions/detail/bessel_k0.hpp    |   158 -
 .../special_functions/detail/bessel_k1.hpp    |   154 -
 .../boost/move/algo/detail/basic_op.hpp       |    81 -
 .../algo/detail/bufferless_merge_sort.hpp     |   120 -
 .../boost_1_62_0/boost/next_prior.hpp         |   165 -
 .../libboost/boost_1_62_0/boost/optional.hpp  |    18 -
 .../boost/ptr_container/clone_allocator.hpp   |    99 -
 .../detail/associative_ptr_container.hpp      |   411 -
 .../ptr_container/detail/default_deleter.hpp  |    69 -
 .../ptr_container/detail/is_convertible.hpp   |    73 -
 .../ptr_container/detail/map_iterator.hpp     |   132 -
 .../ptr_container/detail/meta_functions.hpp   |    66 -
 .../boost/ptr_container/detail/move.hpp       |    44 -
 .../detail/reversible_ptr_container.hpp       |   752 -
 .../ptr_container/detail/scoped_deleter.hpp   |   121 -
 .../detail/serialize_ptr_map_adapter.hpp      |    87 -
 .../detail/serialize_reversible_cont.hpp      |    86 -
 .../detail/serialize_xml_names.hpp            |    32 -
 .../ptr_container/detail/static_move_ptr.hpp  |   211 -
 .../ptr_container/detail/throw_exception.hpp  |    33 -
 .../detail/void_ptr_iterator.hpp              |   229 -
 .../boost/ptr_container/exception.hpp         |    58 -
 .../boost/ptr_container/indirect_fun.hpp      |   151 -
 .../boost/ptr_container/nullable.hpp          |    73 -
 .../boost/ptr_container/ptr_array.hpp         |   234 -
 .../ptr_container/ptr_circular_buffer.hpp     |   531 -
 .../boost/ptr_container/ptr_container.hpp     |    31 -
 .../boost/ptr_container/ptr_deque.hpp         |    69 -
 .../boost/ptr_container/ptr_inserter.hpp      |   258 -
 .../boost/ptr_container/ptr_list.hpp          |   110 -
 .../boost/ptr_container/ptr_map.hpp           |   165 -
 .../boost/ptr_container/ptr_map_adapter.hpp   |   874 -
 .../ptr_container/ptr_sequence_adapter.hpp    |   775 -
 .../boost/ptr_container/ptr_set.hpp           |   155 -
 .../boost/ptr_container/ptr_set_adapter.hpp   |   692 -
 .../boost/ptr_container/ptr_unordered_map.hpp |   248 -
 .../boost/ptr_container/ptr_unordered_set.hpp |   240 -
 .../boost/ptr_container/ptr_vector.hpp        |    77 -
 .../ptr_container/serialize_ptr_array.hpp     |    47 -
 .../serialize_ptr_circular_buffer.hpp         |    46 -
 .../ptr_container/serialize_ptr_container.hpp |    19 -
 .../ptr_container/serialize_ptr_deque.hpp     |    27 -
 .../ptr_container/serialize_ptr_list.hpp      |    27 -
 .../boost/ptr_container/serialize_ptr_map.hpp |    33 -
 .../boost/ptr_container/serialize_ptr_set.hpp |    33 -
 .../serialize_ptr_unordered_map.hpp           |    39 -
 .../serialize_ptr_unordered_set.hpp           |    39 -
 .../ptr_container/serialize_ptr_vector.hpp    |    40 -
 .../boost/random/exponential_distribution.hpp |   182 -
 .../boost/smart_ptr/allocate_shared_array.hpp |   181 -
 .../smart_ptr/detail/array_allocator.hpp      |   318 -
 .../smart_ptr/detail/array_count_impl.hpp     |    67 -
 .../boost/smart_ptr/detail/array_traits.hpp   |    60 -
 .../boost/smart_ptr/detail/array_utility.hpp  |   214 -
 .../boost/smart_ptr/detail/sp_if_array.hpp    |    34 -
 .../boost/smart_ptr/make_shared_array.hpp     |   158 -
 .../boost/smart_ptr/make_shared_object.hpp    |  1131 -
 .../boost/smart_ptr/owner_less.hpp            |    57 -
 .../boost/system/windows_error.hpp            |   126 -
 .../boost/test/auto_unit_test.hpp             |    18 -
 .../boost_1_62_0/boost/test/data/config.hpp   |    45 -
 .../boost_1_62_0/boost/test/data/dataset.hpp  |    19 -
 .../boost/test/data/for_each_sample.hpp       |   117 -
 .../boost/test/data/generators.hpp            |    19 -
 .../boost/test/data/index_sequence.hpp        |    62 -
 .../boost/test/data/monomorphic.hpp           |    27 -
 .../boost/test/data/monomorphic/array.hpp     |    83 -
 .../test/data/monomorphic/collection.hpp      |    91 -
 .../boost/test/data/monomorphic/fwd.hpp       |   180 -
 .../boost/test/data/monomorphic/generate.hpp  |   109 -
 .../test/data/monomorphic/generators.hpp      |    20 -
 .../data/monomorphic/generators/keywords.hpp  |    39 -
 .../data/monomorphic/generators/random.hpp    |   198 -
 .../data/monomorphic/generators/xrange.hpp    |   224 -
 .../boost/test/data/monomorphic/grid.hpp      |   181 -
 .../data/monomorphic/initializer_list.hpp     |    81 -
 .../boost/test/data/monomorphic/join.hpp      |   148 -
 .../test/data/monomorphic/sample_merge.hpp    |   103 -
 .../boost/test/data/monomorphic/singleton.hpp |   119 -
 .../boost/test/data/monomorphic/zip.hpp       |   194 -
 .../boost_1_62_0/boost/test/data/size.hpp     |   145 -
 .../boost/test/data/test_case.hpp             |   320 -
 .../boost_1_62_0/boost/test/debug.hpp         |   138 -
 .../boost_1_62_0/boost/test/debug_config.hpp  |    24 -
 .../boost_1_62_0/boost/test/detail/config.hpp |   127 -
 .../boost/test/detail/enable_warnings.hpp     |    36 -
 .../boost/test/detail/fwd_decl.hpp            |    45 -
 .../boost/test/detail/global_typedef.hpp      |    96 -
 .../boost/test/detail/log_level.hpp           |    40 -
 .../boost/test/detail/pp_variadic.hpp         |    49 -
 .../boost/test/detail/suppress_warnings.hpp   |    38 -
 .../boost/test/detail/throw_exception.hpp     |    71 -
 .../boost/test/detail/workaround.hpp          |    56 -
 .../boost/test/execution_monitor.hpp          |   531 -
 .../boost/test/floating_point_comparison.hpp  |    14 -
 .../boost_1_62_0/boost/test/framework.hpp     |   276 -
 .../test/impl/compiler_log_formatter.ipp      |   290 -
 .../boost_1_62_0/boost/test/impl/cpp_main.ipp |   136 -
 .../boost_1_62_0/boost/test/impl/debug.ipp    |  1009 -
 .../boost/test/impl/decorator.ipp             |   202 -
 .../boost/test/impl/execution_monitor.ipp     |  1436 -
 .../boost/test/impl/framework.ipp             |  1491 -
 .../boost/test/impl/junit_log_formatter.ipp   |   627 -
 .../test/impl/plain_report_formatter.ipp      |   207 -
 .../boost/test/impl/progress_monitor.ipp      |   185 -
 .../boost/test/impl/results_collector.ipp     |   279 -
 .../boost/test/impl/results_reporter.ipp      |   197 -
 .../boost/test/impl/test_main.ipp             |    65 -
 .../boost/test/impl/test_tools.ipp            |   794 -
 .../boost/test/impl/test_tree.ipp             |   460 -
 .../boost/test/impl/unit_test_log.ipp         |   675 -
 .../boost/test/impl/unit_test_main.ipp        |   295 -
 .../boost/test/impl/unit_test_monitor.ipp     |    75 -
 .../boost/test/impl/unit_test_parameters.ipp  |   749 -
 .../boost/test/impl/xml_log_formatter.ipp     |   223 -
 .../boost/test/impl/xml_report_formatter.ipp  |   111 -
 .../boost/test/included/execution_monitor.hpp |    21 -
 .../boost/test/included/prg_exec_monitor.hpp  |    25 -
 .../boost/test/included/test_exec_monitor.hpp |    39 -
 .../boost/test/included/unit_test.hpp         |    38 -
 .../test/included/unit_test_framework.hpp     |    12 -
 .../boost_1_62_0/boost/test/minimal.hpp       |   156 -
 .../test/output/compiler_log_formatter.hpp    |    70 -
 .../boost/test/output/junit_log_formatter.hpp |   135 -
 .../test/output/plain_report_formatter.hpp    |    59 -
 .../boost/test/output/xml_log_formatter.hpp   |    72 -
 .../test/output/xml_report_formatter.hpp      |    52 -
 .../boost/test/output_test_stream.hpp         |    14 -
 .../boost/test/parameterized_test.hpp         |   172 -
 .../boost/test/predicate_result.hpp           |    14 -
 .../boost/test/prg_exec_monitor.hpp           |    81 -
 .../boost/test/progress_monitor.hpp           |    66 -
 .../boost/test/results_collector.hpp          |   140 -
 .../boost/test/results_reporter.hpp           |   122 -
 .../boost/test/test_case_template.hpp         |    13 -
 .../boost/test/test_exec_monitor.hpp          |    53 -
 .../boost_1_62_0/boost/test/test_tools.hpp    |    68 -
 .../boost/test/tools/assertion.hpp            |   410 -
 .../boost/test/tools/assertion_result.hpp     |    90 -
 .../test/tools/collection_comparison_op.hpp   |   378 -
 .../boost_1_62_0/boost/test/tools/context.hpp |    65 -
 .../test/tools/cstring_comparison_op.hpp      |    91 -
 .../boost/test/tools/detail/bitwise_manip.hpp |   123 -
 .../test/tools/detail/expression_holder.hpp   |    70 -
 .../boost/test/tools/detail/fwd.hpp           |   121 -
 .../boost/test/tools/detail/indirections.hpp  |    94 -
 .../boost/test/tools/detail/it_pair.hpp       |    74 -
 .../test/tools/detail/lexicographic_manip.hpp |    69 -
 .../test/tools/detail/per_element_manip.hpp   |    69 -
 .../boost/test/tools/detail/print_helper.hpp  |   205 -
 .../test/tools/detail/tolerance_manip.hpp     |   130 -
 .../test/tools/floating_point_comparison.hpp  |   315 -
 .../boost_1_62_0/boost/test/tools/fpc_op.hpp  |   224 -
 .../boost/test/tools/fpc_tolerance.hpp        |   103 -
 .../boost/test/tools/interface.hpp            |   369 -
 .../boost/test/tools/old/impl.hpp             |   358 -
 .../boost/test/tools/old/interface.hpp        |   282 -
 .../boost/test/tools/output_test_stream.hpp   |   107 -
 .../boost/test/tree/auto_registration.hpp     |    53 -
 .../boost/test/tree/decorator.hpp             |   277 -
 .../boost_1_62_0/boost/test/tree/fixture.hpp  |   116 -
 .../boost/test/tree/global_fixture.hpp        |    65 -
 .../boost_1_62_0/boost/test/tree/observer.hpp |   116 -
 .../boost/test/tree/test_case_counter.hpp     |    52 -
 .../boost/test/tree/test_case_template.hpp    |   144 -
 .../boost/test/tree/test_unit.hpp             |   275 -
 .../boost_1_62_0/boost/test/tree/traverse.hpp |    58 -
 .../boost_1_62_0/boost/test/tree/visitor.hpp  |    52 -
 .../boost_1_62_0/boost/test/unit_test.hpp     |    70 -
 .../boost_1_62_0/boost/test/unit_test_log.hpp |   273 -
 .../boost/test/unit_test_log_formatter.hpp    |   320 -
 .../boost/test/unit_test_monitor.hpp          |    60 -
 .../boost/test/unit_test_parameters.hpp       |   134 -
 .../boost/test/unit_test_suite.hpp            |   366 -
 .../boost/test/utils/algorithm.hpp            |   320 -
 .../boost/test/utils/assign_op.hpp            |    39 -
 .../utils/basic_cstring/basic_cstring.hpp     |   738 -
 .../utils/basic_cstring/basic_cstring_fwd.hpp |    40 -
 .../utils/basic_cstring/bcs_char_traits.hpp   |   150 -
 .../test/utils/basic_cstring/compare.hpp      |   147 -
 .../boost/test/utils/basic_cstring/io.hpp     |    73 -
 .../boost/test/utils/class_properties.hpp     |   195 -
 .../boost/test/utils/custom_manip.hpp         |    61 -
 .../boost_1_62_0/boost/test/utils/foreach.hpp |   316 -
 .../boost/test/utils/is_cstring.hpp           |    58 -
 .../boost/test/utils/is_forward_iterable.hpp  |   166 -
 .../utils/iterator/input_iterator_facade.hpp  |   105 -
 .../test/utils/iterator/token_iterator.hpp    |   417 -
 .../boost/test/utils/lazy_ostream.hpp         |   128 -
 .../boost/test/utils/named_params.hpp         |   388 -
 .../boost/test/utils/nullstream.hpp           |   103 -
 .../boost_1_62_0/boost/test/utils/rtti.hpp    |    63 -
 .../boost/test/utils/runtime/argument.hpp     |   131 -
 .../test/utils/runtime/argument_factory.hpp   |   242 -
 .../test/utils/runtime/cla/argv_traverser.hpp |   105 -
 .../boost/test/utils/runtime/cla/parser.hpp   |   491 -
 .../boost/test/utils/runtime/env/fetch.hpp    |   108 -
 .../boost/test/utils/runtime/errors.hpp       |   195 -
 .../boost/test/utils/runtime/finalize.hpp     |    56 -
 .../boost/test/utils/runtime/fwd.hpp          |    45 -
 .../boost/test/utils/runtime/modifier.hpp     |   106 -
 .../boost/test/utils/runtime/parameter.hpp    |   472 -
 .../boost/test/utils/setcolor.hpp             |   126 -
 .../boost/test/utils/string_cast.hpp          |    69 -
 .../boost/test/utils/trivial_singleton.hpp    |    79 -
 .../boost/test/utils/wrap_stringstream.hpp    |   162 -
 .../boost/test/utils/xml_printer.hpp          |   143 -
 .../libs/test/src/compiler_log_formatter.cpp  |    18 -
 .../boost_1_62_0/libs/test/src/cpp_main.cpp   |    19 -
 .../boost_1_62_0/libs/test/src/debug.cpp      |    24 -
 .../boost_1_62_0/libs/test/src/decorator.cpp  |    18 -
 .../libs/test/src/execution_monitor.cpp       |    18 -
 .../boost_1_62_0/libs/test/src/framework.cpp  |    18 -
 .../libs/test/src/junit_log_formatter.cpp     |    13 -
 .../libs/test/src/plain_report_formatter.cpp  |    18 -
 .../libs/test/src/progress_monitor.cpp        |    18 -
 .../libs/test/src/results_collector.cpp       |    18 -
 .../libs/test/src/results_reporter.cpp        |    18 -
 .../boost_1_62_0/libs/test/src/test_main.cpp  |    15 -
 .../boost_1_62_0/libs/test/src/test_tools.cpp |    18 -
 .../boost_1_62_0/libs/test/src/test_tree.cpp  |    18 -
 .../libs/test/src/unit_test_log.cpp           |    18 -
 .../libs/test/src/unit_test_main.cpp          |    18 -
 .../libs/test/src/unit_test_monitor.cpp       |    18 -
 .../libs/test/src/unit_test_parameters.cpp    |    18 -
 .../libs/test/src/xml_log_formatter.cpp       |    18 -
 .../libs/test/src/xml_report_formatter.cpp    |    18 -
 .../LICENSE_1_0.txt                           |     0
 .../boost/algorithm/algorithm.hpp             |     0
 .../boost/algorithm/clamp.hpp                 |     0
 .../boost/algorithm/cxx11/all_of.hpp          |     0
 .../boost/algorithm/cxx11/any_of.hpp          |     0
 .../boost/algorithm/cxx11/copy_if.hpp         |     0
 .../boost/algorithm/cxx11/copy_n.hpp          |     0
 .../boost/algorithm/cxx11/find_if_not.hpp     |     0
 .../boost/algorithm/cxx11/iota.hpp            |     0
 .../boost/algorithm/cxx11/is_partitioned.hpp  |     6 +-
 .../boost/algorithm/cxx11/is_permutation.hpp  |     0
 .../boost/algorithm/cxx11/is_sorted.hpp       |     0
 .../boost/algorithm/cxx11/none_of.hpp         |     0
 .../boost/algorithm/cxx11/one_of.hpp          |     0
 .../boost/algorithm/cxx11/partition_copy.hpp  |     0
 .../boost/algorithm/cxx11/partition_point.hpp |     0
 .../boost/algorithm/cxx14/equal.hpp           |     3 +-
 .../boost/algorithm/cxx14/is_permutation.hpp  |     0
 .../boost/algorithm/cxx14/mismatch.hpp        |     0
 .../boost/algorithm/cxx17/exclusive_scan.hpp  |    52 +
 .../boost/algorithm/cxx17/for_each_n.hpp      |    37 +
 .../boost/algorithm/cxx17/inclusive_scan.hpp  |    60 +
 .../boost/algorithm/cxx17/reduce.hpp          |    72 +
 .../cxx17/transform_exclusive_scan.hpp        |    46 +
 .../cxx17/transform_inclusive_scan.hpp        |    58 +
 .../algorithm/cxx17/transform_reduce.hpp      |    55 +
 .../boost/algorithm/gather.hpp                |     0
 .../boost/algorithm/hex.hpp                   |     2 +-
 .../boost/algorithm/is_palindrome.hpp         |    29 +-
 .../boost/algorithm/is_partitioned_until.hpp  |    63 +
 .../boost/algorithm/minmax.hpp                |     0
 .../boost/algorithm/minmax_element.hpp        |     0
 .../boost/algorithm/searching/boyer_moore.hpp |    16 +-
 .../searching/boyer_moore_horspool.hpp        |     0
 .../algorithm/searching/detail/bm_traits.hpp  |     0
 .../algorithm/searching/detail/debugging.hpp  |     0
 .../searching/knuth_morris_pratt.hpp          |     6 +-
 .../boost/algorithm/sort_subrange.hpp         |     0
 .../boost/algorithm/string.hpp                |     0
 .../boost/algorithm/string/case_conv.hpp      |     0
 .../boost/algorithm/string/classification.hpp |     0
 .../boost/algorithm/string/compare.hpp        |     0
 .../boost/algorithm/string/concept.hpp        |     0
 .../boost/algorithm/string/config.hpp         |     0
 .../boost/algorithm/string/constants.hpp      |     0
 .../algorithm/string/detail/case_conv.hpp     |     8 +-
 .../string/detail/classification.hpp          |     0
 .../algorithm/string/detail/find_format.hpp   |     0
 .../string/detail/find_format_all.hpp         |     0
 .../string/detail/find_format_store.hpp       |     0
 .../algorithm/string/detail/find_iterator.hpp |     2 +-
 .../boost/algorithm/string/detail/finder.hpp  |     0
 .../algorithm/string/detail/finder_regex.hpp  |     0
 .../algorithm/string/detail/formatter.hpp     |     0
 .../string/detail/formatter_regex.hpp         |     0
 .../algorithm/string/detail/predicate.hpp     |     0
 .../string/detail/replace_storage.hpp         |     0
 .../algorithm/string/detail/sequence.hpp      |     0
 .../boost/algorithm/string/detail/trim.hpp    |     0
 .../boost/algorithm/string/detail/util.hpp    |     5 +-
 .../boost/algorithm/string/erase.hpp          |     0
 .../boost/algorithm/string/find.hpp           |     0
 .../boost/algorithm/string/find_format.hpp    |     0
 .../boost/algorithm/string/find_iterator.hpp  |     0
 .../boost/algorithm/string/finder.hpp         |     0
 .../boost/algorithm/string/formatter.hpp      |     0
 .../boost/algorithm/string/iter_find.hpp      |     0
 .../boost/algorithm/string/join.hpp           |     0
 .../boost/algorithm/string/predicate.hpp      |     0
 .../algorithm/string/predicate_facade.hpp     |     0
 .../boost/algorithm/string/regex.hpp          |     0
 .../algorithm/string/regex_find_format.hpp    |     0
 .../boost/algorithm/string/replace.hpp        |     0
 .../algorithm/string/sequence_traits.hpp      |     0
 .../boost/algorithm/string/split.hpp          |     0
 .../algorithm/string/std/list_traits.hpp      |     0
 .../algorithm/string/std/rope_traits.hpp      |     0
 .../algorithm/string/std/slist_traits.hpp     |     0
 .../algorithm/string/std/string_traits.hpp    |     0
 .../string/std_containers_traits.hpp          |     0
 .../boost/algorithm/string/trim.hpp           |     0
 .../boost/algorithm/string/trim_all.hpp       |     0
 .../boost/algorithm/string/yes_no_type.hpp    |     0
 .../boost/algorithm/string_regex.hpp          |     0
 .../boost/align/align.hpp                     |     9 +-
 .../boost_1_65_0/boost/align/align_down.hpp   |    25 +
 .../boost_1_65_0/boost/align/align_up.hpp     |    25 +
 .../boost/align/aligned_alloc.hpp             |     9 +-
 .../boost/align/aligned_allocator.hpp         |    45 +-
 .../boost/align/aligned_allocator_adaptor.hpp |    76 +-
 .../aligned_allocator_adaptor_forward.hpp     |    13 +-
 .../boost/align/aligned_allocator_forward.hpp |    13 +-
 .../boost/align/aligned_delete.hpp            |    13 +-
 .../boost/align/aligned_delete_forward.hpp    |    19 +
 .../boost/align/alignment_of.hpp              |    16 +-
 .../boost/align/alignment_of_forward.hpp      |    20 +
 .../boost/align/assume_aligned.hpp            |    13 +-
 .../boost/align/detail/addressof.hpp          |    15 +-
 .../boost/align/detail/align.hpp              |    22 +-
 .../boost/align/detail/align_cxx11.hpp        |    21 +
 .../boost/align/detail/align_down.hpp         |    28 +
 .../boost/align/detail/align_up.hpp           |    28 +
 .../boost/align/detail/aligned_alloc.hpp      |    34 +-
 .../align/detail/aligned_alloc_android.hpp    |    20 +-
 .../align/detail/aligned_alloc_macos.hpp      |    20 +-
 .../boost/align/detail/aligned_alloc_msvc.hpp |    20 +-
 .../align/detail/aligned_alloc_posix.hpp      |    20 +-
 .../align/detail/aligned_alloc_sunos.hpp      |    20 +-
 .../boost/align/detail/alignment_of.hpp       |    19 +-
 .../boost/align/detail/alignment_of_clang.hpp |    15 +-
 .../align/detail/alignment_of_codegear.hpp    |    15 +-
 .../boost/align/detail/alignment_of_cxx11.hpp |    15 +-
 .../boost/align/detail/alignment_of_gcc.hpp   |    15 +-
 .../boost/align/detail/alignment_of_msvc.hpp  |    20 +-
 .../boost/align/detail/assume_aligned.hpp     |    16 +
 .../align/detail/assume_aligned_clang.hpp     |    11 +-
 .../boost/align/detail/assume_aligned_gcc.hpp |    17 +
 .../align/detail/assume_aligned_intel.hpp     |    17 +
 .../align/detail/assume_aligned_msvc.hpp      |    19 +
 .../boost/align/detail/element_type.hpp       |    44 +-
 .../boost/align/detail/integral_constant.hpp  |    18 +-
 .../boost/align/detail/is_aligned.hpp         |    34 +
 .../boost/align/detail/is_alignment.hpp       |    28 +
 .../align/detail/is_alignment_constant.hpp    |    15 +-
 .../boost/align/detail/max_align.hpp          |    15 +-
 .../boost/align/detail/max_objects.hpp        |    15 +-
 .../boost/align/detail/max_size.hpp           |    15 +-
 .../boost/align/detail/min_size.hpp           |    15 +-
 .../boost_1_65_0/boost/align/is_aligned.hpp   |    26 +
 .../boost/aligned_storage.hpp                 |     0
 .../boost/any.hpp                             |    20 +-
 .../boost/array.hpp                           |    95 +-
 .../boost/assert.hpp                          |     0
 .../boost/bind.hpp                            |     0
 .../boost/bind/apply.hpp                      |     0
 .../boost/bind/arg.hpp                        |    13 +-
 .../boost/bind/bind.hpp                       |     0
 .../boost/bind/bind_cc.hpp                    |     0
 .../boost/bind/bind_mf2_cc.hpp                |     0
 .../boost/bind/bind_mf_cc.hpp                 |     0
 .../boost/bind/bind_template.hpp              |     0
 .../boost/bind/make_adaptable.hpp             |     0
 .../boost/bind/mem_fn.hpp                     |     0
 .../boost/bind/mem_fn_cc.hpp                  |     0
 .../boost/bind/mem_fn_template.hpp            |     0
 .../boost/bind/mem_fn_vw.hpp                  |     0
 .../boost/bind/placeholders.hpp               |     0
 .../boost/bind/protect.hpp                    |     0
 .../boost/bind/storage.hpp                    |     0
 contrib/libboost/boost_1_65_0/boost/blank.hpp |   106 +
 .../libboost/boost_1_65_0/boost/blank_fwd.hpp |    22 +
 .../boost/call_traits.hpp                     |     0
 .../boost/cerrno.hpp                          |     4 +-
 .../boost/checked_delete.hpp                  |     0
 .../boost/compressed_pair.hpp                 |     0
 .../boost/concept/assert.hpp                  |     0
 .../concept/detail/backward_compatibility.hpp |     0
 .../boost/concept/detail/borland.hpp          |     0
 .../boost/concept/detail/concept_def.hpp      |     0
 .../boost/concept/detail/concept_undef.hpp    |     0
 .../boost/concept/detail/general.hpp          |     0
 .../boost/concept/detail/has_constraints.hpp  |     0
 .../boost/concept/detail/msvc.hpp             |     0
 .../boost/concept/requires.hpp                |     0
 .../boost/concept/usage.hpp                   |     0
 .../boost/concept_check.hpp                   |     0
 .../boost/config.hpp                          |     8 +-
 .../boost/config/abi/borland_prefix.hpp       |     0
 .../boost/config/abi/borland_suffix.hpp       |     0
 .../boost/config/abi/msvc_prefix.hpp          |     0
 .../boost/config/abi/msvc_suffix.hpp          |     0
 .../boost/config/abi_prefix.hpp               |     0
 .../boost/config/abi_suffix.hpp               |     0
 .../boost/config/auto_link.hpp                |    11 +-
 .../boost/config/compiler/borland.hpp         |    12 +
 .../boost/config/compiler/clang.hpp           |    25 +-
 .../boost/config/compiler/codegear.hpp        |    14 +
 .../boost/config/compiler/comeau.hpp          |     0
 .../boost/config/compiler/common_edg.hpp      |    12 +
 .../boost/config/compiler/compaq_cxx.hpp      |     0
 .../boost/config/compiler/cray.hpp            |     1 +
 .../boost/config/compiler/diab.hpp            |    19 +
 .../boost/config/compiler/digitalmars.hpp     |    12 +
 .../boost/config/compiler/gcc.hpp             |    23 +
 .../boost/config/compiler/gcc_xml.hpp         |    12 +
 .../boost/config/compiler/greenhills.hpp      |     0
 .../boost/config/compiler/hp_acc.hpp          |     1 +
 .../boost/config/compiler/intel.hpp           |    24 +-
 .../boost/config/compiler/kai.hpp             |     0
 .../boost/config/compiler/metrowerks.hpp      |    12 +
 .../boost/config/compiler/mpw.hpp             |    12 +
 .../boost/config/compiler/nvcc.hpp            |    27 +
 .../boost/config/compiler/pathscale.hpp       |    19 +-
 .../boost/config/compiler/pgi.hpp             |    12 +
 .../boost/config/compiler/sgi_mipspro.hpp     |     0
 .../boost/config/compiler/sunpro_cc.hpp       |    14 +-
 .../boost/config/compiler/vacpp.hpp           |    12 +
 .../boost/config/compiler/visualc.hpp         |    45 +-
 .../boost/config/compiler/xlcpp.hpp           |    14 +
 .../boost/config/compiler/xlcpp_zos.hpp       |   168 +
 .../boost/config/detail}/posix_features.hpp   |     0
 .../config/detail}/select_compiler_config.hpp |    12 +-
 .../config/detail}/select_platform_config.hpp |    11 +-
 .../config/detail}/select_stdlib_config.hpp   |     5 +
 .../boost/config/detail}/suffix.hpp           |    43 +-
 .../boost/config/no_tr1/cmath.hpp             |     0
 .../boost/config/no_tr1/complex.hpp           |     0
 .../boost/config/no_tr1/functional.hpp        |     0
 .../boost/config/no_tr1/memory.hpp            |     0
 .../boost/config/no_tr1/utility.hpp           |     0
 .../boost/config/platform/aix.hpp             |     2 +-
 .../boost/config/platform/amigaos.hpp         |     0
 .../boost/config/platform/beos.hpp            |     2 +-
 .../boost/config/platform/bsd.hpp             |     2 +-
 .../boost/config/platform/cloudabi.hpp        |     0
 .../boost/config/platform/cray.hpp            |     2 +-
 .../boost/config/platform/cygwin.hpp          |     5 +-
 .../boost/config/platform/haiku.hpp           |     2 +-
 .../boost/config/platform/hpux.hpp            |     2 +-
 .../boost/config/platform/irix.hpp            |     2 +-
 .../boost/config/platform/linux.hpp           |     7 +-
 .../boost/config/platform/macos.hpp           |     2 +-
 .../boost/config/platform/qnxnto.hpp          |     2 +-
 .../boost/config/platform/solaris.hpp         |     2 +-
 .../boost/config/platform/symbian.hpp         |     2 +-
 .../boost/config/platform/vms.hpp             |     0
 .../boost/config/platform/vxworks.hpp         |    41 +-
 .../boost/config/platform/win32.hpp           |     0
 .../boost/config/platform/zos.hpp             |    32 +
 .../boost/config/requires_threads.hpp         |     0
 .../boost/config/stdlib/dinkumware.hpp        |    57 +-
 .../boost/config/stdlib/libcomo.hpp           |     8 +
 .../boost/config/stdlib/libcpp.hpp            |    32 +-
 .../boost/config/stdlib/libstdcpp3.hpp        |    59 +-
 .../boost/config/stdlib/modena.hpp            |     8 +
 .../boost/config/stdlib/msl.hpp               |    10 +-
 .../boost/config/stdlib/roguewave.hpp         |     8 +
 .../boost/config/stdlib/sgi.hpp               |    10 +-
 .../boost/config/stdlib/stlport.hpp           |     8 +
 .../boost/config/stdlib/vacpp.hpp             |     8 +
 .../boost/config/stdlib/xlcpp_zos.hpp         |    59 +
 .../boost/config/user.hpp                     |     0
 .../boost/config/warning_disable.hpp          |     0
 .../boost/config}/workaround.hpp              |    68 +-
 .../boost/container/adaptive_pool.hpp         |     0
 .../boost/container/allocator.hpp             |     0
 .../boost/container/allocator_traits.hpp      |    56 +-
 .../boost/container/container_fwd.hpp         |     0
 .../boost/container/deque.hpp                 |    20 +-
 .../container/detail/adaptive_node_pool.hpp   |     0
 .../detail/adaptive_node_pool_impl.hpp        |    16 +-
 .../boost/container/detail/addressof.hpp      |     0
 .../container/detail/advanced_insert_int.hpp  |    14 +-
 .../boost/container/detail/algorithm.hpp      |   157 +
 .../boost/container/detail/alloc_helpers.hpp  |     0
 .../boost/container/detail/alloc_lib.h        |     0
 .../container/detail/allocation_type.hpp      |     0
 .../detail/allocator_version_traits.hpp       |     0
 .../boost/container/detail/auto_link.hpp      |     0
 .../boost/container/detail/block_list.hpp     |     0
 .../boost/container/detail/block_slist.hpp    |     0
 .../container/detail/compare_functors.hpp     |     0
 .../boost/container/detail/config_begin.hpp   |     0
 .../boost/container/detail/config_end.hpp     |     0
 .../container/detail/construct_in_place.hpp   |     0
 .../boost/container/detail/copy_move_algo.hpp |   138 +-
 .../boost/container/detail/destroyers.hpp     |    10 +-
 .../detail/dispatch_uses_allocator.hpp        |    56 +-
 .../boost/container/detail/dlmalloc.hpp       |     0
 .../boost/container/detail/flat_tree.hpp      |   360 +-
 .../container/detail/function_detector.hpp    |     0
 .../boost/container/detail/is_sorted.hpp      |     0
 .../boost/container/detail/iterator.hpp       |     0
 .../detail/iterator_to_raw_pointer.hpp}       |    10 +-
 .../boost/container/detail/iterators.hpp      |     1 +
 .../boost/container/detail/math_functions.hpp |     0
 .../boost/container/detail/min_max.hpp        |     0
 .../detail/minimal_char_traits_header.hpp     |     0
 .../boost/container/detail/mpl.hpp            |     0
 .../detail/multiallocation_chain.hpp          |     6 +-
 .../boost/container/detail/mutex.hpp          |    13 +-
 .../boost/container/detail/next_capacity.hpp  |     0
 .../container/detail/node_alloc_holder.hpp    |    34 +-
 .../boost/container/detail/node_pool.hpp      |     0
 .../boost/container/detail/node_pool_impl.hpp |     4 +-
 .../boost/container/detail/pair.hpp           |   105 +-
 .../detail/pair_key_mapped_of_value.hpp       |    55 +
 .../boost/container/detail/placement_new.hpp  |     0
 .../boost/container/detail/pool_common.hpp    |     0
 .../container/detail/pool_common_alloc.hpp    |     0
 .../boost/container/detail/pool_resource.hpp  |     0
 .../boost/container/detail/singleton.hpp      |     0
 .../boost/container/detail/std_fwd.hpp        |     0
 .../container/detail/transform_iterator.hpp   |     0
 .../boost/container/detail/tree.hpp           |   161 +-
 .../boost/container/detail/type_traits.hpp    |     0
 .../boost/container/detail/value_init.hpp     |     0
 .../detail/variadic_templates_tools.hpp       |    26 +-
 .../boost/container/detail/version_type.hpp   |     0
 .../boost/container/detail/workaround.hpp     |     7 +
 .../boost/container/flat_map.hpp              |   838 +-
 .../boost/container/flat_set.hpp              |   419 +-
 .../boost/container/list.hpp                  |     0
 .../boost/container/map.hpp                   |   530 +-
 .../boost/container/new_allocator.hpp         |     6 +-
 .../boost/container/node_allocator.hpp        |     0
 .../boost/container/node_handle.hpp           |   185 +-
 .../boost/container/options.hpp               |     0
 .../boost/container/pmr/deque.hpp             |     0
 .../boost/container/pmr/flat_map.hpp          |     0
 .../boost/container/pmr/flat_set.hpp          |     0
 .../boost/container/pmr/global_resource.hpp   |     0
 .../boost/container/pmr/list.hpp              |     0
 .../boost/container/pmr/map.hpp               |     0
 .../boost/container/pmr/memory_resource.hpp   |     0
 .../pmr/monotonic_buffer_resource.hpp         |     0
 .../container/pmr/polymorphic_allocator.hpp   |     0
 .../boost/container/pmr/pool_options.hpp      |     0
 .../boost/container/pmr/resource_adaptor.hpp  |     0
 .../boost/container/pmr/set.hpp               |     0
 .../boost/container/pmr/slist.hpp             |     0
 .../boost/container/pmr/small_vector.hpp      |     0
 .../boost/container/pmr/stable_vector.hpp     |     0
 .../boost/container/pmr/string.hpp            |     0
 .../pmr/synchronized_pool_resource.hpp        |     0
 .../pmr/unsynchronized_pool_resource.hpp      |     0
 .../boost/container/pmr/vector.hpp            |     0
 .../boost/container/scoped_allocator.hpp      |     0
 .../boost/container/scoped_allocator_fwd.hpp  |     0
 .../boost/container/set.hpp                   |   355 +-
 .../boost/container/slist.hpp                 |     0
 .../boost/container/small_vector.hpp          |     6 +-
 .../boost/container/stable_vector.hpp         |     6 +-
 .../boost/container/static_vector.hpp         |     0
 .../boost/container/string.hpp                |   577 +-
 .../boost/container/throw_exception.hpp       |     0
 .../boost/container/uses_allocator.hpp        |     0
 .../boost/container/uses_allocator_fwd.hpp    |     4 +-
 .../boost/container/vector.hpp                |   161 +-
 .../boost/cstdint.hpp                         |    16 +-
 .../boost/cstdlib.hpp                         |     0
 .../boost/current_function.hpp                |     6 +-
 .../boost/detail/algorithm.hpp                |     0
 .../boost/detail/allocator_utilities.hpp      |     0
 .../boost/detail/atomic_count.hpp             |     0
 .../boost/detail/atomic_redef_macros.hpp      |     0
 .../boost/detail/atomic_undef_macros.hpp      |     0
 .../boost/detail/basic_pointerbuf.hpp         |     0
 .../boost/detail/binary_search.hpp            |     0
 .../boost/detail/bitmask.hpp                  |     0
 .../boost/detail/call_traits.hpp              |     0
 .../boost/detail/catch_exceptions.hpp         |     0
 .../boost/detail/compressed_pair.hpp          |     0
 .../boost/detail/container_fwd.hpp            |     0
 .../boost/detail/dynamic_bitset.hpp           |     0
 .../boost/detail/endian.hpp                   |     0
 .../boost/detail/fenv.hpp                     |     0
 .../boost/detail/has_default_constructor.hpp  |     0
 .../boost/detail/identifier.hpp               |     0
 .../boost/detail/indirect_traits.hpp          |     0
 .../boost/detail/interlocked.hpp              |     0
 .../boost/detail/is_incrementable.hpp         |     0
 .../boost/detail/is_sorted.hpp                |     0
 .../boost/detail/is_xxx.hpp                   |     0
 .../boost/detail/iterator.hpp                 |     0
 .../boost/detail/lcast_precision.hpp          |     1 +
 .../boost/detail/lightweight_main.hpp         |     0
 .../boost/detail/lightweight_mutex.hpp        |     0
 .../boost/detail/lightweight_test.hpp         |     0
 .../boost/detail/lightweight_test_report.hpp  |     0
 .../boost/detail/lightweight_thread.hpp       |     0
 .../boost/detail/named_template_params.hpp    |     0
 .../boost/detail/no_exceptions_support.hpp    |     0
 .../boost/detail/numeric_traits.hpp           |     0
 .../boost/detail/ob_compressed_pair.hpp       |     0
 .../boost/detail/quick_allocator.hpp          |     0
 .../boost/detail/reference_content.hpp        |     0
 .../boost/detail/scoped_enum_emulation.hpp    |     0
 .../boost/detail/select_type.hpp              |     0
 .../boost/detail/sp_typeinfo.hpp              |     0
 .../boost/detail/templated_streams.hpp        |     0
 .../boost/detail/utf8_codecvt_facet.hpp       |     0
 .../boost/detail/utf8_codecvt_facet.ipp       |     0
 .../boost/detail/winapi/GetCurrentProcess.hpp |     0
 .../boost/detail/winapi/GetCurrentThread.hpp  |     0
 .../boost/detail/winapi/GetLastError.hpp      |     0
 .../boost/detail/winapi/GetProcessTimes.hpp   |     0
 .../boost/detail/winapi/GetThreadTimes.hpp    |     0
 .../boost/detail/winapi/access_rights.hpp     |     0
 .../boost/detail/winapi/apc.hpp               |     0
 .../boost/detail/winapi/basic_types.hpp       |     0
 .../winapi/character_code_conversion.hpp      |     0
 .../detail/winapi/condition_variable.hpp      |     0
 .../boost/detail/winapi/config.hpp            |     8 +-
 .../boost/detail/winapi/critical_section.hpp  |     0
 .../boost/detail/winapi/crypt.hpp             |    43 +-
 .../boost/detail/winapi/dbghelp.hpp           |     0
 .../boost/detail/winapi/debugapi.hpp          |    79 +
 .../boost/detail/winapi/detail/cast_ptr.hpp   |     0
 .../detail/winapi/directory_management.hpp    |     0
 .../boost/detail/winapi/dll.hpp               |     0
 .../boost/detail/winapi/environment.hpp       |     0
 .../boost/detail/winapi/error_codes.hpp       |     0
 .../boost/detail/winapi/error_handling.hpp    |     0
 .../boost/detail/winapi/event.hpp             |     0
 .../boost/detail/winapi/file_management.hpp   |    42 +
 .../boost/detail/winapi/file_mapping.hpp      |     0
 .../detail/winapi/get_current_process.hpp     |     0
 .../detail/winapi/get_current_process_id.hpp  |     0
 .../detail/winapi/get_current_thread.hpp      |     0
 .../detail/winapi/get_current_thread_id.hpp   |     0
 .../boost/detail/winapi/get_last_error.hpp    |     0
 .../boost/detail/winapi/get_process_times.hpp |     0
 .../detail/winapi/get_system_directory.hpp    |     0
 .../boost/detail/winapi/get_thread_times.hpp  |     0
 .../boost/detail/winapi/handle_info.hpp       |     0
 .../boost/detail/winapi/handles.hpp           |     0
 .../boost/detail/winapi/heap_memory.hpp       |     0
 .../boost/detail/winapi/init_once.hpp         |     0
 .../boost/detail/winapi/jobs.hpp              |    18 +-
 .../boost/detail/winapi/limits.hpp            |     0
 .../boost/detail/winapi/local_memory.hpp      |     0
 .../boost/detail/winapi/memory.hpp            |     0
 .../boost/detail/winapi/mutex.hpp             |     0
 .../boost/detail/winapi/overlapped.hpp        |     0
 .../detail/winapi/page_protection_flags.hpp   |     0
 .../boost/detail/winapi/pipes.hpp             |     0
 .../boost/detail/winapi/priority_class.hpp    |     0
 .../boost/detail/winapi/process.hpp           |     0
 .../boost/detail/winapi/security.hpp          |     0
 .../boost/detail/winapi/semaphore.hpp         |     0
 .../boost/detail/winapi/shell.hpp             |     0
 .../boost/detail/winapi/show_window.hpp       |     0
 .../boost/detail/winapi/srw_lock.hpp          |     0
 .../boost/detail/winapi/stack_backtrace.hpp   |    55 +
 .../boost/detail/winapi/synchronization.hpp   |     0
 .../boost/detail/winapi/system.hpp            |    10 +
 .../boost/detail/winapi/thread.hpp            |     0
 .../boost/detail/winapi/thread_pool.hpp       |     0
 .../boost/detail/winapi/time.hpp              |     0
 .../boost/detail/winapi/timers.hpp            |     0
 .../boost/detail/winapi/tls.hpp               |     0
 .../boost/detail/winapi/wait.hpp              |     0
 .../boost/detail/winapi/waitable_timer.hpp    |     0
 .../boost_1_65_0/boost/detail/workaround.hpp  |    10 +
 .../boost/exception/all.hpp                   |    11 +-
 .../exception/current_exception_cast.hpp      |     0
 .../detail/clone_current_exception.hpp        |     0
 .../exception/detail/error_info_impl.hpp      |    63 +-
 .../boost/exception/detail/exception_ptr.hpp  |    19 +-
 .../exception/detail/is_output_streamable.hpp |     5 +-
 .../exception/detail/object_hex_dump.hpp      |    13 +-
 .../boost/exception/detail/shared_ptr.hpp     |    17 +
 .../boost/exception/detail/type_info.hpp      |    13 +-
 .../exception/diagnostic_information.hpp      |    17 +-
 .../exception/enable_current_exception.hpp    |     5 +
 .../boost/exception/enable_error_info.hpp     |     5 +
 .../boost/exception/errinfo_api_function.hpp  |     2 +-
 .../boost/exception/errinfo_at_line.hpp       |     0
 .../boost/exception/errinfo_errno.hpp         |     9 +-
 .../boost/exception/errinfo_file_handle.hpp   |     0
 .../boost/exception/errinfo_file_name.hpp     |     0
 .../exception/errinfo_file_open_mode.hpp      |     0
 .../exception/errinfo_nested_exception.hpp    |     0
 .../exception/errinfo_type_info_name.hpp      |     0
 .../boost/exception/error_info.hpp            |     0
 .../boost/exception/exception.hpp             |    11 +-
 .../boost/exception/get_error_info.hpp        |    13 +-
 .../boost/exception/info.hpp                  |   196 +-
 .../boost/exception/info_tuple.hpp            |     7 +-
 .../boost/exception/to_string.hpp             |     9 +-
 .../boost/exception/to_string_stub.hpp        |     9 +-
 .../boost/filesystem.hpp                      |     0
 .../boost/filesystem/config.hpp               |     0
 .../boost/filesystem/convenience.hpp          |     0
 .../boost/filesystem/detail/macro_value.hpp   |    44 +
 .../filesystem/detail/utf8_codecvt_facet.hpp  |     0
 .../boost/filesystem/exception.hpp            |     0
 .../boost/filesystem/fstream.hpp              |     0
 .../boost/filesystem/operations.hpp           |    85 +-
 .../boost/filesystem/path.hpp                 |    63 +-
 .../boost/filesystem/path_traits.hpp          |     0
 .../boost/filesystem/string_file.hpp          |     0
 .../boost/function.hpp                        |     0
 .../function/detail/function_iterate.hpp      |     0
 .../function/detail/gen_maybe_include.pl      |     0
 .../boost/function/detail/maybe_include.hpp   |     0
 .../boost/function/detail/prologue.hpp        |     0
 .../boost/function/function0.hpp              |     0
 .../boost/function/function1.hpp              |     0
 .../boost/function/function10.hpp             |     0
 .../boost/function/function2.hpp              |     0
 .../boost/function/function3.hpp              |     0
 .../boost/function/function4.hpp              |     0
 .../boost/function/function5.hpp              |     0
 .../boost/function/function6.hpp              |     0
 .../boost/function/function7.hpp              |     0
 .../boost/function/function8.hpp              |     0
 .../boost/function/function9.hpp              |     0
 .../boost/function/function_base.hpp          |     0
 .../boost/function/function_fwd.hpp           |     0
 .../boost/function/function_template.hpp      |    11 -
 .../boost/function/function_typeof.hpp        |     0
 .../boost/function/gen_function_N.pl          |     0
 .../boost/function_equal.hpp                  |     0
 .../boost/function_types/components.hpp       |   424 +
 .../boost/function_types/config/cc_names.hpp  |    31 +
 .../boost/function_types/config/compiler.hpp  |   116 +
 .../boost/function_types/config/config.hpp    |    59 +
 .../function_types/detail/class_transform.hpp |    60 +
 .../function_types/detail/classifier.hpp      |    87 +
 .../detail/classifier_impl/arity10_0.hpp      |    55 +
 .../detail/classifier_impl/arity10_1.hpp      |    52 +
 .../detail/classifier_impl/arity20_0.hpp      |    53 +
 .../detail/classifier_impl/arity20_1.hpp      |    53 +
 .../detail/classifier_impl/arity30_0.hpp      |    53 +
 .../detail/classifier_impl/arity30_1.hpp      |    53 +
 .../detail/classifier_impl/arity40_0.hpp      |    53 +
 .../detail/classifier_impl/arity40_1.hpp      |    53 +
 .../detail/classifier_impl/arity50_0.hpp      |    53 +
 .../detail/classifier_impl/arity50_1.hpp      |    52 +
 .../detail/classifier_impl/master.hpp         |    33 +
 .../detail/components_as_mpl_sequence.hpp     |   138 +
 .../detail/components_impl/arity10_0.hpp      |   132 +
 .../detail/components_impl/arity10_1.hpp      |   122 +
 .../detail/components_impl/arity20_0.hpp      |   123 +
 .../detail/components_impl/arity20_1.hpp      |   123 +
 .../detail/components_impl/arity30_0.hpp      |   123 +
 .../detail/components_impl/arity30_1.hpp      |   123 +
 .../detail/components_impl/arity40_0.hpp      |   123 +
 .../detail/components_impl/arity40_1.hpp      |   123 +
 .../detail/components_impl/arity50_0.hpp      |   123 +
 .../detail/components_impl/arity50_1.hpp      |   123 +
 .../detail/components_impl/master.hpp         |    61 +
 .../boost/function_types/detail/cv_traits.hpp |   132 +
 .../detail/encoding/aliases_def.hpp           |    16 +
 .../detail/encoding/aliases_undef.hpp         |    16 +
 .../function_types/detail/encoding/def.hpp    |    51 +
 .../function_types/detail/encoding/undef.hpp  |    38 +
 .../function_types/detail/pp_arity_loop.hpp   |   149 +
 .../detail/pp_cc_loop/master.hpp              |   136 +
 .../detail/pp_cc_loop/preprocessed.hpp        |   120 +
 .../boost/function_types/detail/pp_loop.hpp   |    80 +
 .../detail/pp_retag_default_cc/master.hpp     |   103 +
 .../pp_retag_default_cc/preprocessed.hpp      |    59 +
 .../function_types/detail/pp_tags/cc_tag.hpp  |    17 +
 .../function_types/detail/pp_tags/master.hpp  |   126 +
 .../detail/pp_tags/preprocessed.hpp           |    77 +
 .../detail/pp_variate_loop/master.hpp         |   152 +
 .../detail/pp_variate_loop/preprocessed.hpp   |   283 +
 .../detail/retag_default_cc.hpp               |    23 +
 .../function_types/detail/synthesize.hpp      |    79 +
 .../detail/synthesize_impl/arity10_0.hpp      |   334 +
 .../detail/synthesize_impl/arity10_1.hpp      |   326 +
 .../detail/synthesize_impl/arity20_0.hpp      |   517 +
 .../detail/synthesize_impl/arity20_1.hpp      |   527 +
 .../detail/synthesize_impl/arity30_0.hpp      |   717 +
 .../detail/synthesize_impl/arity30_1.hpp      |   727 +
 .../detail/synthesize_impl/arity40_0.hpp      |   917 +
 .../detail/synthesize_impl/arity40_1.hpp      |   927 +
 .../detail/synthesize_impl/arity50_0.hpp      |  1117 +
 .../detail/synthesize_impl/arity50_1.hpp      |  1127 +
 .../detail/synthesize_impl/master.hpp         |    87 +
 .../function_types/detail/to_sequence.hpp     |    45 +
 .../boost/function_types/function_arity.hpp   |    36 +
 .../boost/function_types/function_pointer.hpp |    30 +
 .../function_types/function_reference.hpp     |    30 +
 .../boost/function_types/function_type.hpp    |    28 +
 .../function_types/is_callable_builtin.hpp    |    33 +
 .../boost/function_types/is_function.hpp      |    32 +
 .../function_types/is_function_pointer.hpp    |    32 +
 .../function_types/is_function_reference.hpp  |    32 +
 .../is_member_function_pointer.hpp            |    31 +
 .../is_member_object_pointer.hpp              |    32 +
 .../function_types/is_member_pointer.hpp      |    32 +
 .../is_nonmember_callable_builtin.hpp         |    33 +
 .../member_function_pointer.hpp               |    31 +
 .../function_types/member_object_pointer.hpp  |    32 +
 .../boost/function_types/parameter_types.hpp  |    53 +
 .../boost/function_types/property_tags.hpp    |   147 +
 .../boost/function_types/result_type.hpp      |    48 +
 .../boost/functional/factory.hpp              |     0
 .../boost/functional/forward_adapter.hpp      |     0
 .../boost/functional/hash.hpp                 |     0
 .../hash/detail/float_functions.hpp           |     0
 .../functional/hash/detail/hash_float.hpp     |     2 +-
 .../boost/functional/hash/detail/limits.hpp   |     0
 .../boost/functional/hash/extensions.hpp      |     6 +-
 .../boost/functional/hash/hash.hpp            |    54 +-
 .../boost/functional/hash/hash_fwd.hpp        |     0
 .../boost/functional/hash_fwd.hpp             |     0
 .../lightweight_forward_adapter.hpp           |     0
 .../boost/functional/overloaded_function.hpp  |     0
 .../functional/overloaded_function/config.hpp |     0
 .../overloaded_function/detail/base.hpp       |     0
 .../detail/function_type.hpp                  |     0
 .../boost/functional/value_factory.hpp        |     0
 .../libboost/boost_1_65_0/boost/geometry.hpp  |    19 +
 .../boost/geometry/algorithms/append.hpp      |   370 +
 .../boost/geometry/algorithms/area.hpp        |   329 +
 .../boost/geometry/algorithms/assign.hpp      |   379 +
 .../boost/geometry/algorithms/buffer.hpp      |   302 +
 .../boost/geometry/algorithms/centroid.hpp    |   681 +
 .../boost/geometry/algorithms/clear.hpp       |   197 +
 .../algorithms/comparable_distance.hpp        |    25 +
 .../boost/geometry/algorithms/convert.hpp     |   559 +
 .../boost/geometry/algorithms/convex_hull.hpp |   375 +
 .../boost/geometry/algorithms/correct.hpp     |   375 +
 .../boost/geometry/algorithms/covered_by.hpp  |    27 +
 .../boost/geometry/algorithms/crosses.hpp     |   267 +
 .../geometry/algorithms/detail/as_range.hpp   |   105 +
 .../algorithms/detail/assign_box_corners.hpp  |   107 +
 .../detail/assign_indexed_point.hpp           |    94 +
 .../algorithms/detail/assign_values.hpp       |   336 +
 .../geometry/algorithms/detail/azimuth.hpp    |   148 +
 .../detail/buffer/buffer_inserter.hpp         |  1062 +
 .../detail/buffer/buffer_policies.hpp         |   241 +
 .../buffer/buffered_piece_collection.hpp      |  1458 +
 .../detail/buffer/buffered_ring.hpp           |   282 +
 .../detail/buffer/get_piece_turns.hpp         |   312 +
 .../detail/buffer/line_line_intersection.hpp  |    88 +
 .../detail/buffer/parallel_continue.hpp       |    33 +
 .../buffer/turn_in_original_visitor.hpp       |   277 +
 .../detail/buffer/turn_in_piece_visitor.hpp   |   806 +
 .../algorithms/detail/calculate_null.hpp      |    38 +
 .../algorithms/detail/calculate_sum.hpp       |    62 +
 .../centroid/translating_transformer.hpp      |   119 +
 .../detail/check_iterator_range.hpp           |    71 +
 .../closest_feature/geometry_to_range.hpp     |   145 +
 .../detail/closest_feature/point_to_range.hpp |   250 +
 .../detail/closest_feature/range_to_range.hpp |   196 +
 .../comparable_distance/implementation.hpp    |    24 +
 .../detail/comparable_distance/interface.hpp  |   363 +
 .../detail/convert_indexed_to_indexed.hpp     |    80 +
 .../detail/convert_point_to_point.hpp         |    68 +
 .../geometry/algorithms/detail/counting.hpp   |   107 +
 .../geometry/algorithms/detail/course.hpp     |    40 +
 .../detail/covered_by/implementation.hpp      |   280 +
 .../detail/covered_by/interface.hpp           |   261 +
 .../algorithms/detail/direction_code.hpp      |   256 +
 .../detail/disjoint/areal_areal.hpp           |   180 +
 .../algorithms/detail/disjoint/box_box.hpp    |   184 +
 .../detail/disjoint/implementation.hpp        |    37 +
 .../algorithms/detail/disjoint/interface.hpp  |   246 +
 .../detail/disjoint/linear_areal.hpp          |   301 +
 .../detail/disjoint/linear_linear.hpp         |   191 +
 .../detail/disjoint/linear_segment_or_box.hpp |   171 +
 .../detail/disjoint/multipoint_geometry.hpp   |   531 +
 .../detail/disjoint/multirange_geometry.hpp   |    94 +
 .../algorithms/detail/disjoint/point_box.hpp  |    83 +
 .../detail/disjoint/point_geometry.hpp        |    89 +
 .../detail/disjoint/point_point.hpp           |   247 +
 .../detail/disjoint/segment_box.hpp           |   231 +
 .../distance/backward_compatibility.hpp       |   333 +
 .../algorithms/detail/distance/box_to_box.hpp |    60 +
 .../detail/distance/default_strategies.hpp    |   137 +
 .../distance/geometry_to_segment_or_box.hpp   |   464 +
 .../detail/distance/implementation.hpp        |    35 +
 .../algorithms/detail/distance/interface.hpp  |   403 +
 .../detail/distance/is_comparable.hpp         |    45 +
 .../detail/distance/iterator_selector.hpp     |    70 +
 .../distance/linear_or_areal_to_areal.hpp     |   147 +
 .../detail/distance/linear_to_linear.hpp      |   123 +
 .../distance/multipoint_to_geometry.hpp       |   239 +
 .../detail/distance/point_to_geometry.hpp     |   518 +
 .../distance/range_to_geometry_rtree.hpp      |   130 +
 .../detail/distance/segment_to_box.hpp        |   892 +
 .../detail/distance/segment_to_segment.hpp    |   152 +
 .../algorithms/detail/envelope/box.hpp        |   172 +
 .../detail/envelope/implementation.hpp        |   107 +
 .../algorithms/detail/envelope/initialize.hpp |    86 +
 .../algorithms/detail/envelope/interface.hpp  |   224 +
 .../envelope/intersects_antimeridian.hpp      |    78 +
 .../algorithms/detail/envelope/linear.hpp     |   114 +
 .../algorithms/detail/envelope/multipoint.hpp |   379 +
 .../algorithms/detail/envelope/point.hpp      |   128 +
 .../algorithms/detail/envelope/range.hpp      |   187 +
 .../detail/envelope/range_of_boxes.hpp        |   331 +
 .../algorithms/detail/envelope/segment.hpp    |   454 +
 .../detail/envelope/transform_units.hpp       |   103 +
 .../detail/equals/collect_vectors.hpp         |   575 +
 .../detail/equals/implementation.hpp          |   397 +
 .../algorithms/detail/equals/interface.hpp    |   317 +
 .../algorithms/detail/equals/point_point.hpp  |    52 +
 .../geometry/algorithms/detail/expand/box.hpp |   129 +
 .../detail/expand/implementation.hpp          |    27 +
 .../algorithms/detail/expand/indexed.hpp      |   147 +
 .../algorithms/detail/expand/interface.hpp    |   199 +
 .../algorithms/detail/expand/point.hpp        |   308 +
 .../algorithms/detail/expand/segment.hpp      |   133 +
 .../algorithms/detail/expand_by_epsilon.hpp   |   113 +
 .../algorithms/detail/extreme_points.hpp      |   543 +
 .../algorithms/detail/for_each_range.hpp      |   201 +
 .../algorithms/detail/get_left_turns.hpp      |   318 +
 .../algorithms/detail/get_max_size.hpp        |    64 +
 .../detail/has_self_intersections.hpp         |   164 +
 .../algorithms/detail/interior_iterator.hpp   |    71 +
 .../detail/intersection/box_box.hpp           |    54 +
 .../detail/intersection/implementation.hpp    |    22 +
 .../detail/intersection/interface.hpp         |   398 +
 .../algorithms/detail/intersection/multi.hpp  |   421 +
 .../detail/intersects/implementation.hpp      |    88 +
 .../detail/intersects/interface.hpp           |   115 +
 .../detail/is_simple/always_simple.hpp        |    85 +
 .../algorithms/detail/is_simple/areal.hpp     |   157 +
 .../is_simple/debug_print_boundary_points.hpp |   113 +
 .../detail/is_simple/failure_policy.hpp       |    53 +
 .../detail/is_simple/implementation.hpp       |    18 +
 .../algorithms/detail/is_simple/interface.hpp |   141 +
 .../algorithms/detail/is_simple/linear.hpp    |   363 +
 .../detail/is_simple/multipoint.hpp           |    91 +
 .../algorithms/detail/is_valid/box.hpp        |   115 +
 .../detail/is_valid/complement_graph.hpp      |   239 +
 .../is_valid/debug_complement_graph.hpp       |    70 +
 .../detail/is_valid/debug_print_turns.hpp     |    78 +
 .../detail/is_valid/debug_validity_phase.hpp  |    68 +
 .../detail/is_valid/has_duplicates.hpp        |    80 +
 .../is_valid/has_invalid_coordinate.hpp       |   151 +
 .../algorithms/detail/is_valid/has_spikes.hpp |   174 +
 .../detail/is_valid/has_valid_self_turns.hpp  |   121 +
 .../detail/is_valid/implementation.hpp        |    21 +
 .../algorithms/detail/is_valid/interface.hpp  |   272 +
 .../detail/is_valid/is_acceptable_turn.hpp    |   161 +
 .../algorithms/detail/is_valid/linear.hpp     |   186 +
 .../detail/is_valid/multipolygon.hpp          |   402 +
 .../algorithms/detail/is_valid/pointlike.hpp  |    92 +
 .../algorithms/detail/is_valid/polygon.hpp    |   531 +
 .../algorithms/detail/is_valid/ring.hpp       |   237 +
 .../algorithms/detail/is_valid/segment.hpp    |    83 +
 .../algorithms/detail/max_interval_gap.hpp    |   278 +
 .../algorithms/detail/multi_modify.hpp        |    69 +
 .../detail/multi_modify_with_predicate.hpp    |    52 +
 .../geometry/algorithms/detail/multi_sum.hpp  |    52 +
 .../geometry/algorithms/detail/normalize.hpp  |   294 +
 .../boost/geometry/algorithms/detail/not.hpp  |    66 +
 .../num_distinct_consecutive_points.hpp       |    93 +
 .../algorithms/detail/occupation_info.hpp     |   219 +
 .../detail/overlaps/implementation.hpp        |   156 +
 .../algorithms/detail/overlaps/interface.hpp  |   124 +
 .../algorithms/detail/overlay/add_rings.hpp   |   161 +
 .../detail/overlay/aggregate_operations.hpp   |   252 +
 .../detail/overlay/append_no_duplicates.hpp   |    53 +
 .../overlay/append_no_dups_or_spikes.hpp      |   164 +
 .../detail/overlay/assign_parents.hpp         |   404 +
 .../detail/overlay/backtrack_check_si.hpp     |   215 +
 .../detail/overlay/check_enrich.hpp           |   168 +
 .../detail/overlay/clip_linestring.hpp        |   250 +
 .../detail/overlay/cluster_info.hpp           |    49 +
 .../detail/overlay/convert_ring.hpp           |   110 +
 .../detail/overlay/copy_segment_point.hpp     |   400 +
 .../detail/overlay/copy_segments.hpp          |   383 +
 .../detail/overlay/debug_turn_info.hpp        |    66 +
 .../algorithms/detail/overlay/do_reverse.hpp  |    47 +
 .../overlay/enrich_intersection_points.hpp    |   452 +
 .../detail/overlay/enrichment_info.hpp        |    82 +
 .../algorithms/detail/overlay/follow.hpp      |   513 +
 .../detail/overlay/follow_linear_linear.hpp   |   557 +
 .../overlay/get_intersection_points.hpp       |   165 +
 .../detail/overlay/get_relative_order.hpp     |   103 +
 .../algorithms/detail/overlay/get_ring.hpp    |   123 +
 .../detail/overlay/get_turn_info.hpp          |  1143 +
 .../overlay/get_turn_info_for_endpoint.hpp    |   667 +
 .../detail/overlay/get_turn_info_helpers.hpp  |   388 +
 .../detail/overlay/get_turn_info_la.hpp       |   893 +
 .../detail/overlay/get_turn_info_ll.hpp       |   759 +
 .../algorithms/detail/overlay/get_turns.hpp   |  1050 +
 .../detail/overlay/handle_colocations.hpp     |   802 +
 .../detail/overlay/handle_self_turns.hpp      |   143 +
 .../overlay/inconsistent_turns_exception.hpp  |    38 +
 .../detail/overlay/intersection_box_box.hpp   |    96 +
 .../detail/overlay/intersection_insert.hpp    |  1087 +
 .../detail/overlay/is_self_turn.hpp           |    68 +
 .../detail/overlay/less_by_segment_ratio.hpp  |   207 +
 .../detail/overlay/linear_linear.hpp          |   344 +
 .../algorithms/detail/overlay/overlay.hpp     |   407 +
 .../detail/overlay/overlay_type.hpp           |    67 +
 .../detail/overlay/pointlike_linear.hpp       |   394 +
 .../detail/overlay/pointlike_pointlike.hpp    |   435 +
 .../detail/overlay/range_in_geometry.hpp      |   178 +
 .../detail/overlay/ring_properties.hpp        |    82 +
 .../detail/overlay/segment_identifier.hpp     |    99 +
 .../detail/overlay/select_rings.hpp           |   371 +
 .../detail/overlay/self_turn_points.hpp       |   354 +
 .../detail/overlay/sort_by_side.hpp           |   637 +
 .../algorithms/detail/overlay/stream_info.hpp |    74 +
 .../algorithms/detail/overlay/traversal.hpp   |   847 +
 .../detail/overlay/traversal_info.hpp         |    53 +
 .../traversal_intersection_patterns.hpp       |   306 +
 .../detail/overlay/traversal_ring_creator.hpp |   361 +
 .../overlay/traversal_switch_detector.hpp     |   575 +
 .../algorithms/detail/overlay/traverse.hpp    |   112 +
 .../algorithms/detail/overlay/turn_info.hpp   |   160 +
 .../algorithms/detail/overlay/visit_info.hpp  |    98 +
 .../geometry/algorithms/detail/partition.hpp  |   848 +
 .../detail/point_is_spike_or_equal.hpp        |   147 +
 .../algorithms/detail/point_on_border.hpp     |   319 +
 .../algorithms/detail/recalculate.hpp         |   234 +
 .../algorithms/detail/relate/areal_areal.hpp  |   878 +
 .../detail/relate/boundary_checker.hpp        |   160 +
 .../algorithms/detail/relate/de9im.hpp        |   439 +
 .../detail/relate/follow_helpers.hpp          |   404 +
 .../detail/relate/implementation.hpp          |   124 +
 .../algorithms/detail/relate/interface.hpp    |   421 +
 .../algorithms/detail/relate/less.hpp         |    83 +
 .../algorithms/detail/relate/linear_areal.hpp |  1466 +
 .../detail/relate/linear_linear.hpp           |   793 +
 .../detail/relate/multi_point_geometry.hpp    |   568 +
 .../detail/relate/point_geometry.hpp          |   206 +
 .../algorithms/detail/relate/point_point.hpp  |   265 +
 .../algorithms/detail/relate/relate_impl.hpp  |    81 +
 .../algorithms/detail/relate/result.hpp       |  1296 +
 .../detail/relate/topology_check.hpp          |   343 +
 .../algorithms/detail/relate/turns.hpp        |   307 +
 .../detail/relation/implementation.hpp        |    18 +
 .../algorithms/detail/relation/interface.hpp  |   219 +
 .../algorithms/detail/ring_identifier.hpp     |    85 +
 .../detail/sections/range_by_section.hpp      |   193 +
 .../detail/sections/section_box_policies.hpp  |    49 +
 .../detail/sections/section_functions.hpp     |   139 +
 .../detail/sections/sectionalize.hpp          |   999 +
 .../algorithms/detail/signed_size_type.hpp    |    28 +
 .../algorithms/detail/single_geometry.hpp     |    94 +
 .../geometry/algorithms/detail/sub_range.hpp  |   129 +
 .../geometry/algorithms/detail/sweep.hpp      |    87 +
 .../detail/throw_on_empty_input.hpp           |    69 +
 .../detail/touches/implementation.hpp         |   459 +
 .../algorithms/detail/touches/interface.hpp   |   321 +
 .../algorithms/detail/turns/compare_turns.hpp |   117 +
 .../algorithms/detail/turns/debug_turn.hpp    |    65 +
 .../detail/turns/filter_continue_turns.hpp    |    78 +
 .../algorithms/detail/turns/print_turns.hpp   |   105 +
 .../detail/turns/remove_duplicate_turns.hpp   |    62 +
 .../detail/within/implementation.hpp          |   306 +
 .../algorithms/detail/within/interface.hpp    |   304 +
 .../algorithms/detail/within/multi_point.hpp  |   268 +
 .../detail/within/point_in_geometry.hpp       |   391 +
 .../detail/within/within_no_turns.hpp         |   221 +
 .../boost/geometry/algorithms/difference.hpp  |   406 +
 .../boost/geometry/algorithms/disjoint.hpp    |    27 +
 .../geometry/algorithms/dispatch/disjoint.hpp |    93 +
 .../geometry/algorithms/dispatch/distance.hpp |    82 +
 .../geometry/algorithms/dispatch/envelope.hpp |    49 +
 .../geometry/algorithms/dispatch/expand.hpp   |    58 +
 .../algorithms/dispatch/is_simple.hpp         |    38 +
 .../geometry/algorithms/dispatch/is_valid.hpp |    44 +
 .../boost/geometry/algorithms/distance.hpp    |    26 +
 .../boost/geometry/algorithms/envelope.hpp    |    25 +
 .../boost/geometry/algorithms/equals.hpp      |    30 +
 .../boost/geometry/algorithms/expand.hpp      |    26 +
 .../boost/geometry/algorithms/for_each.hpp    |   373 +
 .../geometry/algorithms/intersection.hpp      |    22 +
 .../boost/geometry/algorithms/intersects.hpp  |    28 +
 .../boost/geometry/algorithms/is_convex.hpp   |   224 +
 .../boost/geometry/algorithms/is_empty.hpp    |   207 +
 .../boost/geometry/algorithms/is_simple.hpp   |    16 +
 .../boost/geometry/algorithms/is_valid.hpp    |    16 +
 .../boost/geometry/algorithms/length.hpp      |   296 +
 .../boost/geometry/algorithms/make.hpp        |   200 +
 .../geometry/algorithms/not_implemented.hpp   |   131 +
 .../geometry/algorithms/num_geometries.hpp    |   141 +
 .../algorithms/num_interior_rings.hpp         |   142 +
 .../boost/geometry/algorithms/num_points.hpp  |   211 +
 .../geometry/algorithms/num_segments.hpp      |   204 +
 .../boost/geometry/algorithms/overlaps.hpp    |    27 +
 .../boost/geometry/algorithms/perimeter.hpp   |   229 +
 .../geometry/algorithms/point_on_surface.hpp  |   365 +
 .../boost/geometry/algorithms/relate.hpp      |    17 +
 .../boost/geometry/algorithms/relation.hpp    |    17 +
 .../geometry/algorithms/remove_spikes.hpp     |   323 +
 .../boost/geometry/algorithms/reverse.hpp     |   186 +
 .../boost/geometry/algorithms/simplify.hpp    |   556 +
 .../geometry/algorithms/sym_difference.hpp    |   582 +
 .../boost/geometry/algorithms/touches.hpp     |    28 +
 .../boost/geometry/algorithms/transform.hpp   |   480 +
 .../boost/geometry/algorithms/union.hpp       |   537 +
 .../boost/geometry/algorithms/unique.hpp      |   184 +
 .../algorithms/validity_failure_type.hpp      |    90 +
 .../boost/geometry/algorithms/within.hpp      |    27 +
 .../boost/geometry/arithmetic/arithmetic.hpp  |   335 +
 .../geometry/arithmetic/cross_product.hpp     |   128 +
 .../boost/geometry/arithmetic/determinant.hpp |    78 +
 .../boost/geometry/arithmetic/dot_product.hpp |    84 +
 .../boost/geometry/arithmetic/normalize.hpp   |    71 +
 .../geometry/formulas/andoyer_inverse.hpp     |   260 +
 .../boost/geometry/formulas/area_formulas.hpp |   578 +
 .../formulas/differential_quantities.hpp      |   303 +
 .../geometry/formulas/eccentricity_sqr.hpp    |    70 +
 .../boost/geometry/formulas/flattening.hpp    |    70 +
 .../boost/geometry/formulas/geographic.hpp    |   457 +
 .../formulas/gnomonic_intersection.hpp        |   148 +
 .../geometry/formulas/gnomonic_spheroid.hpp   |   125 +
 .../boost/geometry/formulas/result_direct.hpp |    39 +
 .../geometry/formulas/result_inverse.hpp      |    39 +
 .../formulas/sjoberg_intersection.hpp         |  1219 +
 .../boost/geometry/formulas/spherical.hpp     |   224 +
 .../boost/geometry/formulas/thomas_direct.hpp |   248 +
 .../geometry/formulas/thomas_inverse.hpp      |   220 +
 .../geometry/formulas/vertex_latitude.hpp     |   148 +
 .../geometry/formulas/vertex_longitude.hpp    |   339 +
 .../geometry/formulas/vincenty_direct.hpp     |   184 +
 .../geometry/formulas/vincenty_inverse.hpp    |   224 +
 .../geometries/adapted/boost_array.hpp        |   120 +
 .../geometries/adapted/boost_fusion.hpp       |   178 +
 .../geometries/adapted/boost_polygon.hpp      |    18 +
 .../geometries/adapted/boost_polygon/box.hpp  |   141 +
 .../adapted/boost_polygon/hole_iterator.hpp   |    84 +
 .../adapted/boost_polygon/holes_proxy.hpp     |   204 +
 .../adapted/boost_polygon/point.hpp           |   102 +
 .../adapted/boost_polygon/polygon.hpp         |   111 +
 .../geometries/adapted/boost_polygon/ring.hpp |   182 +
 .../adapted/boost_polygon/ring_proxy.hpp      |   301 +
 .../adapted/boost_range/adjacent_filtered.hpp |    40 +
 .../adapted/boost_range/filtered.hpp          |    40 +
 .../adapted/boost_range/reversed.hpp          |    40 +
 .../geometries/adapted/boost_range/sliced.hpp |    36 +
 .../adapted/boost_range/strided.hpp           |    36 +
 .../adapted/boost_range/uniqued.hpp           |    40 +
 .../geometries/adapted/boost_tuple.hpp        |   109 +
 .../geometry/geometries/adapted/c_array.hpp   |   111 +
 .../geometry/geometries/adapted/std_array.hpp |   115 +
 .../adapted/std_pair_as_segment.hpp           |    98 +
 .../boost/geometry/geometries/box.hpp         |   191 +
 .../geometries/concepts/box_concept.hpp       |   136 +
 .../geometry/geometries/concepts/check.hpp    |   243 +
 .../concepts/linestring_concept.hpp           |   125 +
 .../concepts/multi_linestring_concept.hpp     |    91 +
 .../concepts/multi_point_concept.hpp          |    90 +
 .../concepts/multi_polygon_concept.hpp        |    91 +
 .../geometries/concepts/point_concept.hpp     |   192 +
 .../geometries/concepts/polygon_concept.hpp   |   135 +
 .../geometries/concepts/ring_concept.hpp      |    99 +
 .../geometries/concepts/segment_concept.hpp   |   135 +
 .../boost/geometry/geometries/geometries.hpp  |    29 +
 .../geometry/geometries/helper_geometry.hpp   |   162 +
 .../boost/geometry/geometries/linestring.hpp  |   123 +
 .../geometry/geometries/multi_linestring.hpp  |   119 +
 .../boost/geometry/geometries/multi_point.hpp |   123 +
 .../geometry/geometries/multi_polygon.hpp     |   117 +
 .../boost/geometry/geometries/point.hpp       |   303 +
 .../boost/geometry/geometries/point_xy.hpp    |   134 +
 .../geometry/geometries/pointing_segment.hpp  |   142 +
 .../boost/geometry/geometries/polygon.hpp     |   367 +
 .../geometry/geometries/register/box.hpp      |   179 +
 .../geometries/register/linestring.hpp        |    60 +
 .../geometries/register/multi_linestring.hpp  |    59 +
 .../geometries/register/multi_point.hpp       |    59 +
 .../geometries/register/multi_polygon.hpp     |    59 +
 .../geometry/geometries/register/point.hpp    |   173 +
 .../geometry/geometries/register/ring.hpp     |    60 +
 .../geometry/geometries/register/segment.hpp  |   129 +
 .../boost/geometry/geometries/ring.hpp        |   181 +
 .../boost/geometry/geometries/segment.hpp     |   224 +
 .../boost/geometry/geometries/variant.hpp     |    39 +
 .../boost_1_65_0/boost/geometry/geometry.hpp  |   117 +
 .../boost/geometry/index/adaptors/query.hpp   |    88 +
 .../index/detail/algorithms/bounds.hpp        |    90 +
 .../comparable_distance_centroid.hpp          |    77 +
 .../algorithms/comparable_distance_far.hpp    |    66 +
 .../algorithms/comparable_distance_near.hpp   |    77 +
 .../index/detail/algorithms/content.hpp       |    87 +
 .../index/detail/algorithms/diff_abs.hpp      |    39 +
 .../algorithms/intersection_content.hpp       |    46 +
 .../index/detail/algorithms/is_valid.hpp      |    91 +
 .../index/detail/algorithms/margin.hpp        |   169 +
 .../index/detail/algorithms/minmaxdist.hpp    |   119 +
 .../index/detail/algorithms/nth_element.hpp   |    62 +
 .../detail/algorithms/path_intersection.hpp   |   123 +
 .../algorithms/segment_intersection.hpp       |   146 +
 .../algorithms/smallest_for_indexable.hpp     |    80 +
 .../detail/algorithms/sum_for_indexable.hpp   |    76 +
 .../index/detail/algorithms/union_content.hpp |    33 +
 .../boost/geometry/index/detail/assert.hpp    |    19 +
 .../geometry/index/detail/bounded_view.hpp    |   215 +
 .../geometry/index/detail/config_begin.hpp    |    21 +
 .../geometry/index/detail/config_end.hpp      |    12 +
 .../index/detail/distance_predicates.hpp      |   161 +
 .../boost/geometry/index/detail/exception.hpp |    87 +
 .../index/detail/is_bounding_geometry.hpp     |    35 +
 .../geometry/index/detail/is_indexable.hpp    |    47 +
 .../boost/geometry/index/detail/meta.hpp      |    42 +
 .../geometry/index/detail/predicates.hpp      |   831 +
 .../geometry/index/detail/rtree/adaptors.hpp  |    54 +
 .../geometry/index/detail/rtree/iterators.hpp |   122 +
 .../index/detail/rtree/kmeans/kmeans.hpp      |    16 +
 .../index/detail/rtree/kmeans/split.hpp       |    87 +
 .../index/detail/rtree/linear/linear.hpp      |    16 +
 .../rtree/linear/redistribute_elements.hpp    |   446 +
 .../index/detail/rtree/node/concept.hpp       |    85 +
 .../geometry/index/detail/rtree/node/node.hpp |   212 +
 .../index/detail/rtree/node/node_elements.hpp |   110 +
 .../index/detail/rtree/node/pairs.hpp         |    71 +
 .../detail/rtree/node/scoped_deallocator.hpp  |    48 +
 .../detail/rtree/node/subtree_destroyer.hpp   |    79 +
 .../detail/rtree/node/variant_dynamic.hpp     |   278 +
 .../detail/rtree/node/variant_static.hpp      |   160 +
 .../detail/rtree/node/variant_visitor.hpp     |    68 +
 .../index/detail/rtree/node/weak_dynamic.hpp  |   294 +
 .../index/detail/rtree/node/weak_static.hpp   |   174 +
 .../index/detail/rtree/node/weak_visitor.hpp  |    67 +
 .../geometry/index/detail/rtree/options.hpp   |   155 +
 .../index/detail/rtree/pack_create.hpp        |   465 +
 .../detail/rtree/quadratic/quadratic.hpp      |    16 +
 .../rtree/quadratic/redistribute_elements.hpp |   295 +
 .../index/detail/rtree/query_iterators.hpp    |   387 +
 .../detail/rtree/rstar/choose_next_node.hpp   |   234 +
 .../index/detail/rtree/rstar/insert.hpp       |   591 +
 .../rtree/rstar/redistribute_elements.hpp     |   470 +
 .../index/detail/rtree/rstar/rstar.hpp        |    18 +
 .../detail/rtree/utilities/are_boxes_ok.hpp   |   128 +
 .../detail/rtree/utilities/are_counts_ok.hpp  |   110 +
 .../detail/rtree/utilities/are_levels_ok.hpp  |   109 +
 .../index/detail/rtree/utilities/gl_draw.hpp  |   243 +
 .../index/detail/rtree/utilities/print.hpp    |   219 +
 .../detail/rtree/utilities/statistics.hpp     |   105 +
 .../index/detail/rtree/utilities/view.hpp     |    61 +
 .../detail/rtree/visitors/children_box.hpp    |    55 +
 .../index/detail/rtree/visitors/copy.hpp      |    92 +
 .../index/detail/rtree/visitors/count.hpp     |   107 +
 .../index/detail/rtree/visitors/destroy.hpp   |    71 +
 .../detail/rtree/visitors/distance_query.hpp  |   588 +
 .../index/detail/rtree/visitors/insert.hpp    |   573 +
 .../index/detail/rtree/visitors/is_leaf.hpp   |    45 +
 .../index/detail/rtree/visitors/iterator.hpp  |   134 +
 .../index/detail/rtree/visitors/remove.hpp    |   344 +
 .../detail/rtree/visitors/spatial_query.hpp   |   214 +
 .../geometry/index/detail/serialization.hpp   |   585 +
 .../boost/geometry/index/detail/tags.hpp      |    25 +
 .../geometry/index/detail/translator.hpp      |    60 +
 .../boost/geometry/index/detail/tuples.hpp    |   204 +
 .../boost/geometry/index/detail/utilities.hpp |    46 +
 .../boost/geometry/index/detail/varray.hpp    |  2199 ++
 .../geometry/index/detail/varray_detail.hpp   |   760 +
 .../geometry/index/distance_predicates.hpp    |   204 +
 .../boost/geometry/index/equal_to.hpp         |   267 +
 .../boost/geometry/index/indexable.hpp        |   197 +
 .../boost/geometry/index/inserter.hpp         |    78 +
 .../boost/geometry/index/parameters.hpp       |   258 +
 .../boost/geometry/index/predicates.hpp       |   421 +
 .../boost/geometry/index/rtree.hpp            |  2226 ++
 .../boost/geometry/io/dsv/write.hpp           |   431 +
 .../boost_1_65_0/boost/geometry/io/io.hpp     |    58 +
 .../boost/geometry/io/svg/svg_mapper.hpp      |   450 +
 .../boost/geometry/io/svg/write.hpp           |   418 +
 .../boost/geometry/io/svg/write_svg.hpp       |    28 +
 .../boost/geometry/io/svg/write_svg_multi.hpp |    27 +
 .../boost/geometry/io/wkt/detail/prefix.hpp   |    66 +
 .../geometry/io/wkt/detail/wkt_multi.hpp      |    56 +
 .../boost/geometry/io/wkt/read.hpp            |   905 +
 .../boost/geometry/io/wkt/stream.hpp          |    38 +
 .../boost/geometry/io/wkt/wkt.hpp             |    25 +
 .../boost/geometry/io/wkt/write.hpp           |   515 +
 .../boost/geometry/iterators/base.hpp         |    70 +
 .../geometry/iterators/closing_iterator.hpp   |   148 +
 .../iterators/concatenate_iterator.hpp        |   153 +
 .../point_iterator/inner_range_type.hpp       |    66 +
 .../detail/point_iterator/iterator_type.hpp   |   136 +
 .../detail/point_iterator/value_type.hpp      |    47 +
 .../detail/segment_iterator/iterator_type.hpp |   153 +
 .../range_segment_iterator.hpp                |   215 +
 .../detail/segment_iterator/value_type.hpp    |    71 +
 .../iterators/dispatch/point_iterator.hpp     |    47 +
 .../iterators/dispatch/segment_iterator.hpp   |    47 +
 .../iterators/ever_circling_iterator.hpp      |   203 +
 .../geometry/iterators/flatten_iterator.hpp   |   229 +
 .../geometry/iterators/has_one_element.hpp    |    29 +
 .../geometry/iterators/point_iterator.hpp     |   308 +
 .../iterators/point_reverse_iterator.hpp      |    89 +
 .../geometry/iterators/segment_iterator.hpp   |   353 +
 .../geometry/multi/algorithms/append.hpp      |    27 +
 .../boost/geometry/multi/algorithms/area.hpp  |    21 +
 .../geometry/multi/algorithms/centroid.hpp    |    22 +
 .../boost/geometry/multi/algorithms/clear.hpp |    21 +
 .../geometry/multi/algorithms/convert.hpp     |    21 +
 .../geometry/multi/algorithms/correct.hpp     |    21 +
 .../geometry/multi/algorithms/covered_by.hpp  |    27 +
 .../algorithms/detail/extreme_points.hpp      |    19 +
 .../algorithms/detail/for_each_range.hpp      |    21 +
 .../multi/algorithms/detail/modify.hpp        |    21 +
 .../detail/modify_with_predicate.hpp          |    21 +
 .../multi/algorithms/detail/multi_sum.hpp     |    21 +
 .../detail/overlay/copy_segment_point.hpp     |    19 +
 .../detail/overlay/copy_segments.hpp          |    16 +
 .../algorithms/detail/overlay/get_ring.hpp    |    16 +
 .../algorithms/detail/overlay/get_turns.hpp   |    16 +
 .../detail/overlay/self_turn_points.hpp       |    16 +
 .../algorithms/detail/point_on_border.hpp     |    24 +
 .../detail/sections/range_by_section.hpp      |    26 +
 .../detail/sections/sectionalize.hpp          |    24 +
 .../geometry/multi/algorithms/disjoint.hpp    |    21 +
 .../geometry/multi/algorithms/distance.hpp    |    27 +
 .../geometry/multi/algorithms/envelope.hpp    |    21 +
 .../geometry/multi/algorithms/equals.hpp      |    22 +
 .../geometry/multi/algorithms/for_each.hpp    |    21 +
 .../multi/algorithms/intersection.hpp         |    22 +
 .../geometry/multi/algorithms/length.hpp      |    21 +
 .../multi/algorithms/num_geometries.hpp       |    22 +
 .../multi/algorithms/num_interior_rings.hpp   |    26 +
 .../geometry/multi/algorithms/num_points.hpp  |    27 +
 .../geometry/multi/algorithms/perimeter.hpp   |    21 +
 .../multi/algorithms/remove_spikes.hpp        |    19 +
 .../geometry/multi/algorithms/reverse.hpp     |    21 +
 .../geometry/multi/algorithms/simplify.hpp    |    21 +
 .../geometry/multi/algorithms/transform.hpp   |    21 +
 .../geometry/multi/algorithms/unique.hpp      |    21 +
 .../geometry/multi/algorithms/within.hpp      |    25 +
 .../multi/geometries/concepts/check.hpp       |    22 +
 .../concepts/multi_linestring_concept.hpp     |    22 +
 .../concepts/multi_point_concept.hpp          |    22 +
 .../concepts/multi_polygon_concept.hpp        |    22 +
 .../multi/geometries/multi_geometries.hpp     |    21 +
 .../multi/geometries/multi_linestring.hpp     |    21 +
 .../geometry/multi/geometries/multi_point.hpp |    21 +
 .../multi/geometries/multi_polygon.hpp        |    21 +
 .../geometries/register/multi_linestring.hpp  |    22 +
 .../multi/geometries/register/multi_point.hpp |    22 +
 .../geometries/register/multi_polygon.hpp     |    22 +
 .../boost/geometry/multi/io/dsv/write.hpp     |    21 +
 .../geometry/multi/io/wkt/detail/prefix.hpp   |    21 +
 .../boost/geometry/multi/io/wkt/read.hpp      |    21 +
 .../boost/geometry/multi/io/wkt/wkt.hpp       |    20 +
 .../boost/geometry/multi/io/wkt/write.hpp     |    21 +
 .../boost/geometry/multi/multi.hpp            |    24 +
 .../strategies/cartesian/centroid_average.hpp |    21 +
 .../multi/views/detail/range_type.hpp         |    21 +
 .../boost/geometry/policies/compare.hpp       |   242 +
 .../policies/disjoint_interrupt_policy.hpp    |    67 +
 .../policies/is_valid/default_policy.hpp      |    59 +
 .../is_valid/failing_reason_policy.hpp        |   224 +
 .../policies/is_valid/failure_type_policy.hpp |    83 +
 .../predicate_based_interrupt_policy.hpp      |   101 +
 .../geometry/policies/relate/direction.hpp    |   391 +
 .../policies/relate/intersection_points.hpp   |   226 +
 .../policies/relate/intersection_ratios.hpp   |   127 +
 .../boost/geometry/policies/relate/tupled.hpp |   116 +
 .../robustness/get_rescale_policy.hpp         |   341 +
 .../policies/robustness/no_rescale_policy.hpp |    66 +
 .../policies/robustness/rescale_policy.hpp    |    88 +
 .../policies/robustness/robust_point_type.hpp |    30 +
 .../policies/robustness/robust_type.hpp       |    67 +
 .../policies/robustness/segment_ratio.hpp     |   267 +
 .../robustness/segment_ratio_type.hpp         |    28 +
 .../agnostic/buffer_distance_asymmetric.hpp   |   114 +
 .../agnostic/buffer_distance_symmetric.hpp    |   107 +
 .../agnostic/hull_graham_andrew.hpp           |   390 +
 .../agnostic/point_in_box_by_side.hpp         |   103 +
 .../strategies/agnostic/point_in_point.hpp    |    85 +
 .../point_in_poly_oriented_winding.hpp        |   208 +
 .../agnostic/point_in_poly_winding.hpp        |   575 +
 .../agnostic/simplify_douglas_peucker.hpp     |   321 +
 .../boost/geometry/strategies/area.hpp        |    50 +
 .../boost/geometry/strategies/azimuth.hpp     |    44 +
 .../boost/geometry/strategies/buffer.hpp      |   103 +
 .../strategies/cartesian/area_surveyor.hpp    |   152 +
 .../geometry/strategies/cartesian/azimuth.hpp |    49 +
 .../strategies/cartesian/box_in_box.hpp       |   311 +
 .../strategies/cartesian/buffer_end_flat.hpp  |   112 +
 .../strategies/cartesian/buffer_end_round.hpp |   178 +
 .../cartesian/buffer_join_miter.hpp           |   142 +
 .../cartesian/buffer_join_round.hpp           |   187 +
 .../cartesian/buffer_join_round_by_divide.hpp |   154 +
 .../cartesian/buffer_point_circle.hpp         |   115 +
 .../cartesian/buffer_point_square.hpp         |   109 +
 .../cartesian/buffer_side_straight.hpp        |   136 +
 .../strategies/cartesian/centroid_average.hpp |   126 +
 .../cartesian/centroid_bashein_detmer.hpp     |   258 +
 .../cartesian/centroid_weighted_length.hpp    |   174 +
 .../cartesian/disjoint_segment_box.hpp        |   319 +
 .../cartesian/distance_projected_point.hpp    |   278 +
 .../cartesian/distance_projected_point_ax.hpp |   314 +
 .../cartesian/distance_pythagoras.hpp         |   288 +
 .../cartesian/distance_pythagoras_box_box.hpp |   338 +
 .../distance_pythagoras_point_box.hpp         |   349 +
 .../strategies/cartesian/envelope_segment.hpp |    72 +
 .../strategies/cartesian/intersection.hpp     |   713 +
 .../strategies/cartesian/point_in_box.hpp     |   295 +
 .../point_in_poly_crossings_multiply.hpp      |   124 +
 .../cartesian/point_in_poly_franklin.hpp      |   118 +
 .../strategies/cartesian/side_by_triangle.hpp |   280 +
 .../cartesian/side_of_intersection.hpp        |   349 +
 .../boost/geometry/strategies/centroid.hpp    |    72 +
 .../strategies/comparable_distance_result.hpp |   196 +
 .../boost/geometry/strategies/compare.hpp     |   172 +
 .../strategies/concepts/area_concept.hpp      |    75 +
 .../strategies/concepts/centroid_concept.hpp  |    78 +
 .../concepts/convex_hull_concept.hpp          |    80 +
 .../strategies/concepts/distance_concept.hpp  |   212 +
 .../concepts/segment_intersect_concept.hpp    |    78 +
 .../strategies/concepts/simplify_concept.hpp  |    96 +
 .../strategies/concepts/within_concept.hpp    |   291 +
 .../boost/geometry/strategies/convex_hull.hpp |    47 +
 .../boost/geometry/strategies/covered_by.hpp  |    99 +
 .../strategies/default_area_result.hpp        |    51 +
 .../default_comparable_distance_result.hpp    |    43 +
 .../strategies/default_distance_result.hpp    |    43 +
 .../strategies/default_length_result.hpp      |    89 +
 .../geometry/strategies/default_strategy.hpp  |    34 +
 .../boost/geometry/strategies/disjoint.hpp    |    93 +
 .../boost/geometry/strategies/distance.hpp    |   110 +
 .../geometry/strategies/distance_result.hpp   |   213 +
 .../boost/geometry/strategies/envelope.hpp    |    45 +
 .../geometry/strategies/geographic/area.hpp   |   231 +
 .../strategies/geographic/azimuth.hpp         |   121 +
 .../geographic/disjoint_segment_box.hpp       |   130 +
 .../strategies/geographic/distance.hpp        |   195 +
 .../geographic/distance_andoyer.hpp           |   128 +
 .../strategies/geographic/distance_thomas.hpp |   121 +
 .../geographic/distance_vincenty.hpp          |   127 +
 .../geographic/envelope_segment.hpp           |   104 +
 .../strategies/geographic/intersection.hpp    |   979 +
 .../geographic/intersection_elliptic.hpp      |   243 +
 .../strategies/geographic/mapping_ssf.hpp     |   185 +
 .../strategies/geographic/parameters.hpp      |   117 +
 .../geometry/strategies/geographic/side.hpp   |   139 +
 .../strategies/geographic/side_andoyer.hpp    |    60 +
 .../strategies/geographic/side_thomas.hpp     |    60 +
 .../strategies/geographic/side_vincenty.hpp   |    60 +
 .../geometry/strategies/intersection.hpp      |    51 +
 .../strategies/intersection_result.hpp        |    78 +
 .../strategies/intersection_strategies.hpp    |   101 +
 .../boost/geometry/strategies/relate.hpp      |   177 +
 .../boost/geometry/strategies/side.hpp        |    55 +
 .../boost/geometry/strategies/side_info.hpp   |   177 +
 .../geometry/strategies/spherical/area.hpp    |   182 +
 .../geometry/strategies/spherical/azimuth.hpp |   105 +
 .../strategies/spherical/compare_circular.hpp |   152 +
 .../spherical/disjoint_segment_box.hpp        |   105 +
 .../spherical/distance_cross_track.hpp        |   773 +
 .../distance_cross_track_point_box.hpp        |   364 +
 .../spherical/distance_haversine.hpp          |   305 +
 .../strategies/spherical/envelope_segment.hpp |    86 +
 .../strategies/spherical/intersection.hpp     |  1067 +
 .../spherical/side_by_cross_track.hpp         |    76 +
 .../geometry/strategies/spherical/ssf.hpp     |   157 +
 .../boost/geometry/strategies/strategies.hpp  |   111 +
 .../strategies/strategy_transform.hpp         |   527 +
 .../boost/geometry/strategies/tags.hpp        |    43 +
 .../boost/geometry/strategies/transform.hpp   |    63 +
 .../transform/inverse_transformer.hpp         |    57 +
 .../strategies/transform/map_transformer.hpp  |   172 +
 .../transform/matrix_transformers.hpp         |   399 +
 .../boost/geometry/strategies/within.hpp      |    98 +
 .../boost/geometry/util/add_const_if_c.hpp    |    56 +
 .../boost/geometry/util/bare_type.hpp         |    52 +
 .../boost/geometry/util/calculation_type.hpp  |   178 +
 .../boost/geometry/util/closure_as_bool.hpp   |    46 +
 .../boost/geometry/util/combine_if.hpp        |    92 +
 .../boost/geometry/util/compress_variant.hpp  |   106 +
 .../boost/geometry/util/condition.hpp         |    44 +
 .../boost/geometry/util/coordinate_cast.hpp   |    55 +
 .../geometry/util/for_each_coordinate.hpp     |    94 +
 .../geometry/util/has_infinite_coordinate.hpp |    55 +
 .../geometry/util/has_nan_coordinate.hpp      |    99 +
 .../util/has_non_finite_coordinate.hpp        |    55 +
 .../boost_1_65_0/boost/geometry/util/math.hpp |   779 +
 .../normalize_spheroidal_box_coordinates.hpp  |   160 +
 .../util/normalize_spheroidal_coordinates.hpp |   324 +
 .../geometry/util/order_as_direction.hpp      |    46 +
 .../boost/geometry/util/parameter_type_of.hpp |    75 +
 .../geometry/util/promote_floating_point.hpp  |    50 +
 .../boost/geometry/util/promote_integral.hpp  |   318 +
 .../boost/geometry/util/range.hpp             |   418 +
 .../boost/geometry/util/rational.hpp          |   179 +
 .../boost/geometry/util/readme.txt            |    17 +
 .../geometry/util/select_calculation_type.hpp |    84 +
 .../geometry/util/select_coordinate_type.hpp  |    69 +
 .../geometry/util/select_most_precise.hpp     |   182 +
 .../boost/geometry/util/transform_variant.hpp |    84 +
 .../boost/geometry/views/box_view.hpp         |   118 +
 .../boost/geometry/views/closeable_view.hpp   |   109 +
 .../geometry/views/detail/boundary_view.hpp   |    16 +
 .../detail/boundary_view/implementation.hpp   |   466 +
 .../views/detail/boundary_view/interface.hpp  |    70 +
 .../views/detail/indexed_point_view.hpp       |   123 +
 .../geometry/views/detail/normalized_view.hpp |   117 +
 .../geometry/views/detail/points_view.hpp     |   142 +
 .../geometry/views/detail/range_type.hpp      |   134 +
 .../views/detail/two_dimensional_view.hpp     |   196 +
 .../boost/geometry/views/identity_view.hpp    |    61 +
 .../boost/geometry/views/reversible_view.hpp  |    74 +
 .../boost/geometry/views/segment_view.hpp     |   100 +
 .../boost/get_pointer.hpp                     |     0
 .../boost/integer.hpp                         |     0
 .../boost/integer/common_factor.hpp           |     0
 .../boost/integer/common_factor_ct.hpp        |     0
 .../boost/integer/common_factor_rt.hpp        |   578 +
 .../boost/integer/integer_log2.hpp            |     0
 .../boost/integer/integer_mask.hpp            |    10 +-
 .../boost/integer/static_log2.hpp             |     0
 .../boost/integer/static_min_max.hpp          |     0
 .../boost/integer_fwd.hpp                     |     3 +
 .../boost/integer_traits.hpp                  |     0
 .../boost/intrusive/any_hook.hpp              |     0
 .../boost/intrusive/avl_set.hpp               |     0
 .../boost/intrusive/avl_set_hook.hpp          |     0
 .../boost/intrusive/avltree.hpp               |     0
 .../boost/intrusive/avltree_algorithms.hpp    |     0
 .../boost/intrusive/bs_set.hpp                |     0
 .../boost/intrusive/bs_set_hook.hpp           |     0
 .../boost/intrusive/bstree.hpp                |     5 +-
 .../boost/intrusive/bstree_algorithms.hpp     |     3 +
 .../intrusive/circular_list_algorithms.hpp    |     0
 .../intrusive/circular_slist_algorithms.hpp   |     0
 .../intrusive/derivation_value_traits.hpp     |     0
 .../boost/intrusive/detail/algo_type.hpp      |     0
 .../boost/intrusive/detail/algorithm.hpp      |     0
 .../detail/any_node_and_algorithms.hpp        |     0
 .../intrusive/detail/array_initializer.hpp    |     0
 .../boost/intrusive/detail/assert.hpp         |     0
 .../boost/intrusive/detail/avltree_node.hpp   |     0
 .../detail/bstree_algorithms_base.hpp         |     0
 .../detail/common_slist_algorithms.hpp        |     0
 .../boost/intrusive/detail/config_begin.hpp   |     0
 .../boost/intrusive/detail/config_end.hpp     |     0
 .../detail/default_header_holder.hpp          |     4 +-
 .../intrusive/detail/ebo_functor_holder.hpp   |     2 +-
 .../intrusive/detail/empty_node_checker.hpp   |     0
 .../boost/intrusive/detail/equal_to_value.hpp |     0
 .../intrusive/detail/exception_disposer.hpp   |     0
 .../intrusive/detail/function_detector.hpp    |     0
 .../boost/intrusive/detail/generic_hook.hpp   |     0
 .../intrusive/detail/get_value_traits.hpp     |     0
 .../has_member_function_callable_with.hpp     |     0
 .../boost/intrusive/detail/hashtable_node.hpp |    29 +-
 .../boost/intrusive/detail/hook_traits.hpp    |    10 +-
 .../boost/intrusive/detail/iiterator.hpp      |     0
 .../detail/is_stateful_value_traits.hpp       |     0
 .../boost/intrusive/detail/iterator.hpp       |   110 +-
 .../intrusive/detail/key_nodeptr_comp.hpp     |    14 +-
 .../boost/intrusive/detail/list_iterator.hpp  |     0
 .../boost/intrusive/detail/list_node.hpp      |     0
 .../boost/intrusive/detail/math.hpp           |     0
 .../detail/minimal_less_equal_header.hpp      |     0
 .../intrusive/detail/minimal_pair_header.hpp  |     0
 .../boost/intrusive/detail/mpl.hpp            |     0
 .../intrusive/detail/node_cloner_disposer.hpp |     0
 .../boost/intrusive/detail/node_holder.hpp    |     0
 .../boost/intrusive/detail/node_to_value.hpp  |     2 +-
 .../intrusive/detail/parent_from_member.hpp   |     0
 .../boost/intrusive/detail/rbtree_node.hpp    |     0
 .../intrusive/detail/reverse_iterator.hpp     |     0
 .../intrusive/detail/simple_disposers.hpp     |     0
 .../boost/intrusive/detail/size_holder.hpp    |     0
 .../boost/intrusive/detail/slist_iterator.hpp |     0
 .../boost/intrusive/detail/slist_node.hpp     |     0
 .../boost/intrusive/detail/std_fwd.hpp        |     0
 .../intrusive/detail/transform_iterator.hpp   |     0
 .../boost/intrusive/detail/tree_iterator.hpp  |     0
 .../boost/intrusive/detail/tree_node.hpp      |     0
 .../intrusive/detail/tree_value_compare.hpp   |    12 +-
 .../boost/intrusive/detail/uncast.hpp         |     0
 .../boost/intrusive/detail/workaround.hpp     |     3 +
 .../boost/intrusive/hashtable.hpp             |   127 +-
 .../boost/intrusive/intrusive_fwd.hpp         |     0
 .../intrusive/linear_slist_algorithms.hpp     |     0
 .../boost/intrusive/link_mode.hpp             |     0
 .../boost/intrusive/list.hpp                  |     0
 .../boost/intrusive/list_hook.hpp             |     0
 .../boost/intrusive/member_value_traits.hpp   |     5 +-
 .../boost/intrusive/options.hpp               |     0
 .../boost/intrusive/pack_options.hpp          |     0
 .../boost/intrusive/parent_from_member.hpp    |     0
 .../boost/intrusive/pointer_plus_bits.hpp     |     0
 .../boost/intrusive/pointer_rebind.hpp        |     0
 .../boost/intrusive/pointer_traits.hpp        |     4 +-
 .../boost/intrusive/priority_compare.hpp      |     0
 .../boost/intrusive/rbtree.hpp                |     0
 .../boost/intrusive/rbtree_algorithms.hpp     |     0
 .../boost/intrusive/set.hpp                   |     0
 .../boost/intrusive/set_hook.hpp              |     0
 .../boost/intrusive/sg_set.hpp                |     0
 .../boost/intrusive/sgtree.hpp                |     0
 .../boost/intrusive/sgtree_algorithms.hpp     |     0
 .../boost/intrusive/slist.hpp                 |     2 +-
 .../boost/intrusive/slist_hook.hpp            |     0
 .../boost/intrusive/splay_set.hpp             |     0
 .../boost/intrusive/splaytree.hpp             |     0
 .../boost/intrusive/splaytree_algorithms.hpp  |     0
 .../boost/intrusive/treap.hpp                 |     2 +-
 .../boost/intrusive/treap_algorithms.hpp      |     0
 .../boost/intrusive/treap_set.hpp             |     0
 .../boost/intrusive/trivial_value_traits.hpp  |     0
 .../boost/intrusive/unordered_set.hpp         |    56 +-
 .../boost/intrusive/unordered_set_hook.hpp    |     0
 .../boost/intrusive_ptr.hpp                   |     2 +-
 .../boost/io/detail/quoted_manip.hpp          |     0
 .../boost/io/ios_state.hpp                    |     0
 .../boost/io_fwd.hpp                          |     0
 .../boost/is_placeholder.hpp                  |     0
 .../boost/iterator.hpp                        |     0
 .../boost_1_65_0/boost/iterator/advance.hpp   |    84 +
 .../boost/iterator/counting_iterator.hpp      |     0
 .../iterator/detail/any_conversion_eater.hpp  |     0
 .../boost/iterator/detail/config_def.hpp      |     0
 .../boost/iterator/detail/config_undef.hpp    |     0
 .../boost/iterator/detail/enable_if.hpp       |     0
 .../detail/facade_iterator_category.hpp       |     0
 .../iterator/detail/minimum_category.hpp      |     0
 .../boost_1_65_0/boost/iterator/distance.hpp  |    65 +
 .../boost/iterator/filter_iterator.hpp        |     0
 .../iterator/function_input_iterator.hpp      |    10 +-
 .../boost/iterator/indirect_iterator.hpp      |     0
 .../boost/iterator/interoperable.hpp          |     0
 .../boost/iterator/is_lvalue_iterator.hpp     |     0
 .../boost/iterator/is_readable_iterator.hpp   |     0
 .../boost/iterator/iterator_adaptor.hpp       |     0
 .../boost/iterator/iterator_archetypes.hpp    |     0
 .../boost/iterator/iterator_categories.hpp    |     0
 .../boost/iterator/iterator_concepts.hpp      |     0
 .../boost/iterator/iterator_facade.hpp        |     0
 .../boost/iterator/iterator_traits.hpp        |     0
 .../boost/iterator/minimum_category.hpp       |     0
 .../boost/iterator/new_iterator_tests.hpp     |     0
 .../boost/iterator/permutation_iterator.hpp   |     0
 .../boost/iterator/reverse_iterator.hpp       |    10 +-
 .../boost/iterator/transform_iterator.hpp     |     0
 .../boost/iterator/zip_iterator.hpp           |     2 +-
 .../boost/iterator_adaptors.hpp               |     0
 .../boost/lexical_cast.hpp                    |     0
 .../boost/lexical_cast/bad_lexical_cast.hpp   |     0
 .../lexical_cast/detail/converter_lexical.hpp |     0
 .../detail/converter_lexical_streams.hpp      |    67 +-
 .../lexical_cast/detail/converter_numeric.hpp |    34 +-
 .../boost/lexical_cast/detail/inf_nan.hpp     |     0
 .../lexical_cast/detail/is_character.hpp      |     0
 .../detail/lcast_char_constants.hpp           |     0
 .../detail/lcast_unsigned_converters.hpp      |     0
 .../boost/lexical_cast/detail/widest_char.hpp |     0
 .../boost/lexical_cast/lexical_cast_old.hpp   |     0
 .../lexical_cast/try_lexical_convert.hpp      |     0
 .../boost/limits.hpp                          |     0
 .../boost/make_shared.hpp                     |     3 +-
 .../math/bindings/detail/big_digamma.hpp      |     0
 .../math/bindings/detail/big_lanczos.hpp      |     0
 .../boost/math/bindings/e_float.hpp           |     0
 .../boost/math/bindings/mpfr.hpp              |     0
 .../boost/math/bindings/mpreal.hpp            |     0
 .../boost/math/bindings/rr.hpp                |     0
 .../boost/math/common_factor.hpp              |     0
 .../boost/math/common_factor_ct.hpp           |    28 +
 .../boost/math/common_factor_rt.hpp           |    25 +
 .../boost/math/complex.hpp                    |     0
 .../boost/math/complex/acos.hpp               |     0
 .../boost/math/complex/acosh.hpp              |     0
 .../boost/math/complex/asin.hpp               |     0
 .../boost/math/complex/asinh.hpp              |     0
 .../boost/math/complex/atan.hpp               |     0
 .../boost/math/complex/atanh.hpp              |     0
 .../boost/math/complex/details.hpp            |     0
 .../boost/math/complex/fabs.hpp               |     0
 .../boost/math/concepts/distributions.hpp     |     0
 .../boost/math/concepts/real_concept.hpp      |     0
 .../boost/math/concepts/real_type_concept.hpp |     0
 .../boost/math/concepts/std_real_concept.hpp  |     4 -
 .../math/constants/calculate_constants.hpp    |     0
 .../boost/math/constants/constants.hpp        |     3 +-
 .../boost/math/constants/info.hpp             |     0
 .../boost/math/cstdfloat/cstdfloat_cmath.hpp  |     0
 .../math/cstdfloat/cstdfloat_complex.hpp      |     0
 .../math/cstdfloat/cstdfloat_complex_std.hpp  |     0
 .../math/cstdfloat/cstdfloat_iostream.hpp     |     0
 .../boost/math/cstdfloat/cstdfloat_limits.hpp |     0
 .../boost/math/cstdfloat/cstdfloat_types.hpp  |     0
 .../boost/math/distributions.hpp              |     0
 .../boost/math/distributions/arcsine.hpp      |     0
 .../boost/math/distributions/bernoulli.hpp    |     0
 .../boost/math/distributions/beta.hpp         |     0
 .../boost/math/distributions/binomial.hpp     |     0
 .../boost/math/distributions/cauchy.hpp       |     0
 .../boost/math/distributions/chi_squared.hpp  |     0
 .../boost/math/distributions/complement.hpp   |     0
 .../detail/common_error_handling.hpp          |     0
 .../detail/derived_accessors.hpp              |     0
 .../distributions/detail/generic_mode.hpp     |     0
 .../distributions/detail/generic_quantile.hpp |     0
 .../detail/hypergeometric_cdf.hpp             |     0
 .../detail/hypergeometric_pdf.hpp             |     0
 .../detail/hypergeometric_quantile.hpp        |     0
 .../detail/inv_discrete_quantile.hpp          |     0
 .../boost/math/distributions/exponential.hpp  |     0
 .../math/distributions/extreme_value.hpp      |     0
 .../math/distributions/find_location.hpp      |     0
 .../boost/math/distributions/find_scale.hpp   |     0
 .../boost/math/distributions/fisher_f.hpp     |     0
 .../boost/math/distributions/fwd.hpp          |     0
 .../boost/math/distributions/gamma.hpp        |     0
 .../boost/math/distributions/geometric.hpp    |     0
 .../math/distributions/hyperexponential.hpp   |     0
 .../math/distributions/hypergeometric.hpp     |     0
 .../distributions/inverse_chi_squared.hpp     |     0
 .../math/distributions/inverse_gamma.hpp      |     0
 .../math/distributions/inverse_gaussian.hpp   |     0
 .../boost/math/distributions/laplace.hpp      |     0
 .../boost/math/distributions/logistic.hpp     |     0
 .../boost/math/distributions/lognormal.hpp    |     0
 .../math/distributions/negative_binomial.hpp  |     0
 .../math/distributions/non_central_beta.hpp   |     0
 .../distributions/non_central_chi_squared.hpp |     0
 .../math/distributions/non_central_f.hpp      |     0
 .../math/distributions/non_central_t.hpp      |     0
 .../boost/math/distributions/normal.hpp       |     0
 .../boost/math/distributions/pareto.hpp       |     0
 .../boost/math/distributions/poisson.hpp      |     0
 .../boost/math/distributions/rayleigh.hpp     |     0
 .../boost/math/distributions/skew_normal.hpp  |     0
 .../boost/math/distributions/students_t.hpp   |     0
 .../boost/math/distributions/triangular.hpp   |     0
 .../boost/math/distributions/uniform.hpp      |     0
 .../boost/math/distributions/weibull.hpp      |     0
 .../interpolators/barycentric_rational.hpp    |    70 +
 .../math/interpolators/cubic_b_spline.hpp     |    78 +
 .../detail/barycentric_rational_detail.hpp    |   151 +
 .../detail/cubic_b_spline_detail.hpp          |   287 +
 .../boost/math/octonion.hpp                   |     0
 .../boost/math/policies/error_handling.hpp    |     0
 .../boost/math/policies/policy.hpp            |     0
 .../boost/math/quadrature/trapezoidal.hpp     |   120 +
 .../boost/math/quaternion.hpp                 |     0
 .../boost/math/special_functions.hpp          |     0
 .../boost/math/special_functions/acosh.hpp    |     2 +-
 .../boost/math/special_functions/airy.hpp     |     0
 .../boost/math/special_functions/asinh.hpp    |     6 +
 .../boost/math/special_functions/atanh.hpp    |     6 +
 .../math/special_functions/bernoulli.hpp      |     0
 .../boost/math/special_functions/bessel.hpp   |     4 +-
 .../math/special_functions/bessel_prime.hpp   |     0
 .../boost/math/special_functions/beta.hpp     |     0
 .../boost/math/special_functions/binomial.hpp |     0
 .../boost/math/special_functions/cbrt.hpp     |     5 +-
 .../boost/math/special_functions/cos_pi.hpp   |     0
 .../detail/airy_ai_bi_zero.hpp                |     4 +-
 .../detail/bernoulli_details.hpp              |     0
 .../detail/bessel_derivatives_linear.hpp      |     0
 .../special_functions/detail/bessel_i0.hpp    |   554 +
 .../special_functions/detail/bessel_i1.hpp    |   577 +
 .../special_functions/detail/bessel_ik.hpp    |     0
 .../special_functions/detail/bessel_j0.hpp    |     0
 .../special_functions/detail/bessel_j1.hpp    |     0
 .../special_functions/detail/bessel_jn.hpp    |     0
 .../special_functions/detail/bessel_jy.hpp    |     0
 .../detail/bessel_jy_asym.hpp                 |     0
 .../detail/bessel_jy_derivatives_asym.hpp     |     0
 .../detail/bessel_jy_derivatives_series.hpp   |     0
 .../detail/bessel_jy_series.hpp               |     0
 .../detail/bessel_jy_zero.hpp                 |     0
 .../special_functions/detail/bessel_k0.hpp    |   509 +
 .../special_functions/detail/bessel_k1.hpp    |   551 +
 .../special_functions/detail/bessel_kn.hpp    |     8 +-
 .../special_functions/detail/bessel_y0.hpp    |     0
 .../special_functions/detail/bessel_y1.hpp    |     0
 .../special_functions/detail/bessel_yn.hpp    |     0
 .../math/special_functions/detail/erf_inv.hpp |     0
 .../special_functions/detail/fp_traits.hpp    |     0
 .../special_functions/detail/gamma_inva.hpp   |     0
 .../special_functions/detail/ibeta_inv_ab.hpp |     0
 .../detail/ibeta_inverse.hpp                  |     0
 .../math/special_functions/detail/iconv.hpp   |     0
 .../detail/igamma_inverse.hpp                 |     0
 .../special_functions/detail/igamma_large.hpp |     0
 .../special_functions/detail/lanczos_sse2.hpp |     0
 .../special_functions/detail/lgamma_small.hpp |     0
 .../special_functions/detail/polygamma.hpp    |     0
 .../special_functions/detail/round_fwd.hpp    |     0
 .../detail/t_distribution_inv.hpp             |     0
 .../detail/unchecked_bernoulli.hpp            |     0
 .../detail/unchecked_factorial.hpp            |     0
 .../boost/math/special_functions/digamma.hpp  |     0
 .../boost/math/special_functions/ellint_1.hpp |     0
 .../boost/math/special_functions/ellint_2.hpp |     0
 .../boost/math/special_functions/ellint_3.hpp |     0
 .../boost/math/special_functions/ellint_d.hpp |     0
 .../math/special_functions/ellint_rc.hpp      |     0
 .../math/special_functions/ellint_rd.hpp      |     0
 .../math/special_functions/ellint_rf.hpp      |     0
 .../math/special_functions/ellint_rg.hpp      |     0
 .../math/special_functions/ellint_rj.hpp      |     0
 .../boost/math/special_functions/erf.hpp      |     8 +-
 .../boost/math/special_functions/expint.hpp   |     0
 .../boost/math/special_functions/expm1.hpp    |     4 +
 .../math/special_functions/factorials.hpp     |     0
 .../math/special_functions/fpclassify.hpp     |     0
 .../boost/math/special_functions/gamma.hpp    |    14 +-
 .../boost/math/special_functions/hankel.hpp   |     0
 .../boost/math/special_functions/hermite.hpp  |     0
 .../math/special_functions/heuman_lambda.hpp  |     0
 .../boost/math/special_functions/hypot.hpp    |     0
 .../special_functions/jacobi_elliptic.hpp     |     0
 .../math/special_functions/jacobi_zeta.hpp    |     0
 .../boost/math/special_functions/laguerre.hpp |     0
 .../boost/math/special_functions/lanczos.hpp  |     0
 .../boost/math/special_functions/legendre.hpp |   191 +-
 .../special_functions/legendre_stieltjes.hpp  |   235 +
 .../boost/math/special_functions/log1p.hpp    |     2 +-
 .../boost/math/special_functions/math_fwd.hpp |    32 +-
 .../boost/math/special_functions/modf.hpp     |     0
 .../boost/math/special_functions/next.hpp     |   406 +-
 .../nonfinite_num_facets.hpp                  |     0
 .../boost/math/special_functions/owens_t.hpp  |     0
 .../math/special_functions/polygamma.hpp      |     0
 .../boost/math/special_functions/pow.hpp      |     0
 .../boost/math/special_functions/powm1.hpp    |     0
 .../boost/math/special_functions/prime.hpp    |     0
 .../special_functions/relative_difference.hpp |     0
 .../boost/math/special_functions/round.hpp    |     0
 .../boost/math/special_functions/sign.hpp     |     2 +-
 .../boost/math/special_functions/sin_pi.hpp   |     0
 .../boost/math/special_functions/sinc.hpp     |     0
 .../boost/math/special_functions/sinhc.hpp    |     0
 .../special_functions/spherical_harmonic.hpp  |     0
 .../boost/math/special_functions/sqrt1pm1.hpp |     0
 .../boost/math/special_functions/trigamma.hpp |     0
 .../boost/math/special_functions/trunc.hpp    |     0
 .../boost/math/special_functions/ulp.hpp      |    38 +-
 .../boost/math/special_functions/zeta.hpp     |     0
 .../boost/math/tools/big_constant.hpp         |     0
 .../boost/math/tools/config.hpp               |     2 +-
 .../boost/math/tools/convert_from_string.hpp  |     0
 .../tools/detail/polynomial_horner1_10.hpp    |     0
 .../tools/detail/polynomial_horner1_11.hpp    |     0
 .../tools/detail/polynomial_horner1_12.hpp    |     0
 .../tools/detail/polynomial_horner1_13.hpp    |     0
 .../tools/detail/polynomial_horner1_14.hpp    |     0
 .../tools/detail/polynomial_horner1_15.hpp    |     0
 .../tools/detail/polynomial_horner1_16.hpp    |     0
 .../tools/detail/polynomial_horner1_17.hpp    |     0
 .../tools/detail/polynomial_horner1_18.hpp    |     0
 .../tools/detail/polynomial_horner1_19.hpp    |     0
 .../tools/detail/polynomial_horner1_2.hpp     |     0
 .../tools/detail/polynomial_horner1_20.hpp    |     0
 .../tools/detail/polynomial_horner1_3.hpp     |     0
 .../tools/detail/polynomial_horner1_4.hpp     |     0
 .../tools/detail/polynomial_horner1_5.hpp     |     0
 .../tools/detail/polynomial_horner1_6.hpp     |     0
 .../tools/detail/polynomial_horner1_7.hpp     |     0
 .../tools/detail/polynomial_horner1_8.hpp     |     0
 .../tools/detail/polynomial_horner1_9.hpp     |     0
 .../tools/detail/polynomial_horner2_10.hpp    |     0
 .../tools/detail/polynomial_horner2_11.hpp    |     0
 .../tools/detail/polynomial_horner2_12.hpp    |     0
 .../tools/detail/polynomial_horner2_13.hpp    |     0
 .../tools/detail/polynomial_horner2_14.hpp    |     0
 .../tools/detail/polynomial_horner2_15.hpp    |     0
 .../tools/detail/polynomial_horner2_16.hpp    |     0
 .../tools/detail/polynomial_horner2_17.hpp    |     0
 .../tools/detail/polynomial_horner2_18.hpp    |     0
 .../tools/detail/polynomial_horner2_19.hpp    |     0
 .../tools/detail/polynomial_horner2_2.hpp     |     0
 .../tools/detail/polynomial_horner2_20.hpp    |     0
 .../tools/detail/polynomial_horner2_3.hpp     |     0
 .../tools/detail/polynomial_horner2_4.hpp     |     0
 .../tools/detail/polynomial_horner2_5.hpp     |     0
 .../tools/detail/polynomial_horner2_6.hpp     |     0
 .../tools/detail/polynomial_horner2_7.hpp     |     0
 .../tools/detail/polynomial_horner2_8.hpp     |     0
 .../tools/detail/polynomial_horner2_9.hpp     |     0
 .../tools/detail/polynomial_horner3_10.hpp    |     0
 .../tools/detail/polynomial_horner3_11.hpp    |     0
 .../tools/detail/polynomial_horner3_12.hpp    |     0
 .../tools/detail/polynomial_horner3_13.hpp    |     0
 .../tools/detail/polynomial_horner3_14.hpp    |     0
 .../tools/detail/polynomial_horner3_15.hpp    |     0
 .../tools/detail/polynomial_horner3_16.hpp    |     0
 .../tools/detail/polynomial_horner3_17.hpp    |     0
 .../tools/detail/polynomial_horner3_18.hpp    |     0
 .../tools/detail/polynomial_horner3_19.hpp    |     0
 .../tools/detail/polynomial_horner3_2.hpp     |     0
 .../tools/detail/polynomial_horner3_20.hpp    |     0
 .../tools/detail/polynomial_horner3_3.hpp     |     0
 .../tools/detail/polynomial_horner3_4.hpp     |     0
 .../tools/detail/polynomial_horner3_5.hpp     |     0
 .../tools/detail/polynomial_horner3_6.hpp     |     0
 .../tools/detail/polynomial_horner3_7.hpp     |     0
 .../tools/detail/polynomial_horner3_8.hpp     |     0
 .../tools/detail/polynomial_horner3_9.hpp     |     0
 .../math/tools/detail/rational_horner1_10.hpp |     0
 .../math/tools/detail/rational_horner1_11.hpp |     0
 .../math/tools/detail/rational_horner1_12.hpp |     0
 .../math/tools/detail/rational_horner1_13.hpp |     0
 .../math/tools/detail/rational_horner1_14.hpp |     0
 .../math/tools/detail/rational_horner1_15.hpp |     0
 .../math/tools/detail/rational_horner1_16.hpp |     0
 .../math/tools/detail/rational_horner1_17.hpp |     0
 .../math/tools/detail/rational_horner1_18.hpp |     0
 .../math/tools/detail/rational_horner1_19.hpp |     0
 .../math/tools/detail/rational_horner1_2.hpp  |     0
 .../math/tools/detail/rational_horner1_20.hpp |     0
 .../math/tools/detail/rational_horner1_3.hpp  |     0
 .../math/tools/detail/rational_horner1_4.hpp  |     0
 .../math/tools/detail/rational_horner1_5.hpp  |     0
 .../math/tools/detail/rational_horner1_6.hpp  |     0
 .../math/tools/detail/rational_horner1_7.hpp  |     0
 .../math/tools/detail/rational_horner1_8.hpp  |     0
 .../math/tools/detail/rational_horner1_9.hpp  |     0
 .../math/tools/detail/rational_horner2_10.hpp |     0
 .../math/tools/detail/rational_horner2_11.hpp |     0
 .../math/tools/detail/rational_horner2_12.hpp |     0
 .../math/tools/detail/rational_horner2_13.hpp |     0
 .../math/tools/detail/rational_horner2_14.hpp |     0
 .../math/tools/detail/rational_horner2_15.hpp |     0
 .../math/tools/detail/rational_horner2_16.hpp |     0
 .../math/tools/detail/rational_horner2_17.hpp |     0
 .../math/tools/detail/rational_horner2_18.hpp |     0
 .../math/tools/detail/rational_horner2_19.hpp |     0
 .../math/tools/detail/rational_horner2_2.hpp  |     0
 .../math/tools/detail/rational_horner2_20.hpp |     0
 .../math/tools/detail/rational_horner2_3.hpp  |     0
 .../math/tools/detail/rational_horner2_4.hpp  |     0
 .../math/tools/detail/rational_horner2_5.hpp  |     0
 .../math/tools/detail/rational_horner2_6.hpp  |     0
 .../math/tools/detail/rational_horner2_7.hpp  |     0
 .../math/tools/detail/rational_horner2_8.hpp  |     0
 .../math/tools/detail/rational_horner2_9.hpp  |     0
 .../math/tools/detail/rational_horner3_10.hpp |     0
 .../math/tools/detail/rational_horner3_11.hpp |     0
 .../math/tools/detail/rational_horner3_12.hpp |     0
 .../math/tools/detail/rational_horner3_13.hpp |     0
 .../math/tools/detail/rational_horner3_14.hpp |     0
 .../math/tools/detail/rational_horner3_15.hpp |     0
 .../math/tools/detail/rational_horner3_16.hpp |     0
 .../math/tools/detail/rational_horner3_17.hpp |     0
 .../math/tools/detail/rational_horner3_18.hpp |     0
 .../math/tools/detail/rational_horner3_19.hpp |     0
 .../math/tools/detail/rational_horner3_2.hpp  |     0
 .../math/tools/detail/rational_horner3_20.hpp |     0
 .../math/tools/detail/rational_horner3_3.hpp  |     0
 .../math/tools/detail/rational_horner3_4.hpp  |     0
 .../math/tools/detail/rational_horner3_5.hpp  |     0
 .../math/tools/detail/rational_horner3_6.hpp  |     0
 .../math/tools/detail/rational_horner3_7.hpp  |     0
 .../math/tools/detail/rational_horner3_8.hpp  |     0
 .../math/tools/detail/rational_horner3_9.hpp  |     0
 .../boost/math/tools/fraction.hpp             |     0
 .../boost/math/tools/minima.hpp               |     0
 .../boost/math/tools/polynomial.hpp           |     8 +-
 .../boost/math/tools/polynomial_gcd.hpp       |   209 +
 .../boost/math/tools/precision.hpp            |     0
 .../boost/math/tools/promotion.hpp            |     0
 .../boost/math/tools/rational.hpp             |     0
 .../boost/math/tools/real_cast.hpp            |     0
 .../boost/math/tools/roots.hpp                |     0
 .../boost/math/tools/series.hpp               |     0
 .../boost/math/tools/stats.hpp                |     0
 .../boost/math/tools/toms748_solve.hpp        |     0
 .../boost/math/tools/traits.hpp               |     0
 .../boost/math/tools/tuple.hpp                |     1 +
 .../boost/math/tools/user.hpp                 |     0
 .../boost/math/tools/workaround.hpp           |     0
 .../boost/math/tr1.hpp                        |     2 +-
 .../boost/math/tr1_c_macros.ipp               |     0
 .../boost/mem_fn.hpp                          |     0
 .../boost/move/adl_move_swap.hpp              |     0
 .../boost/move/algo/adaptive_merge.hpp        |     0
 .../boost/move/algo/adaptive_sort.hpp         |    15 +-
 .../move/algo/detail/adaptive_sort_merge.hpp  |  1888 +-
 .../boost/move/algo/detail/basic_op.hpp       |   121 +
 .../boost/move/algo/detail/insertion_sort.hpp |    19 +-
 .../boost/move/algo/detail/merge.hpp          |   124 +-
 .../boost/move/algo/detail/merge_sort.hpp     |    12 +-
 .../boost/move/algo/move.hpp                  |     3 +-
 .../boost/move/algo/predicate.hpp             |    86 +
 .../boost_1_65_0/boost/move/algo/unique.hpp   |    55 +
 .../boost/move/algorithm.hpp                  |     0
 .../boost/move/core.hpp                       |     0
 .../boost/move/default_delete.hpp             |    18 +-
 .../boost/move/detail/config_begin.hpp        |     0
 .../boost/move/detail/config_end.hpp          |     0
 .../boost/move/detail/destruct_n.hpp          |     7 +-
 .../boost/move/detail/fwd_macros.hpp          |    25 +
 .../move}/detail/iterator_to_raw_pointer.hpp  |    33 +-
 .../boost/move/detail/iterator_traits.hpp     |     0
 .../boost/move/detail/meta_utils.hpp          |     0
 .../boost/move/detail/meta_utils_core.hpp     |     0
 .../boost/move/detail/move_helpers.hpp        |    50 +-
 .../boost/move/detail/placement_new.hpp       |     0
 .../boost/move}/detail/pointer_element.hpp    |    24 +-
 .../boost/move/detail/reverse_iterator.hpp    |     0
 .../boost/move/detail/std_ns_begin.hpp        |     0
 .../boost/move/detail/std_ns_end.hpp          |     0
 .../boost/move/detail/to_raw_pointer.hpp      |    45 +
 .../boost/move/detail/type_traits.hpp         |     0
 .../move/detail/unique_ptr_meta_utils.hpp     |     4 +-
 .../boost/move/detail/workaround.hpp          |     5 +-
 .../boost/move/iterator.hpp                   |     0
 .../boost/move/make_unique.hpp                |     3 +-
 .../boost/move/move.hpp                       |     0
 .../boost/move/traits.hpp                     |     0
 .../boost/move/unique_ptr.hpp                 |     0
 .../boost/move/utility.hpp                    |     0
 .../boost/move/utility_core.hpp               |     0
 .../boost/mpl/O1_size.hpp                     |     0
 .../boost/mpl/O1_size_fwd.hpp                 |     0
 .../boost/mpl/accumulate.hpp                  |     0
 .../boost/mpl/advance.hpp                     |     0
 .../boost/mpl/advance_fwd.hpp                 |     0
 .../boost/mpl/alias.hpp                       |     0
 .../boost/mpl/always.hpp                      |     0
 .../boost/mpl/and.hpp                         |     0
 .../boost/mpl/apply.hpp                       |     0
 .../boost/mpl/apply_fwd.hpp                   |     0
 .../boost/mpl/apply_wrap.hpp                  |     0
 .../boost/mpl/arg.hpp                         |     0
 .../boost/mpl/arg_fwd.hpp                     |     0
 .../boost/mpl/arithmetic.hpp                  |     0
 .../boost/mpl/as_sequence.hpp                 |     0
 .../boost/mpl/assert.hpp                      |     0
 .../boost/mpl/at.hpp                          |     0
 .../boost/mpl/at_fwd.hpp                      |     0
 .../boost/mpl/aux_/O1_size_impl.hpp           |     0
 .../boost/mpl/aux_/adl_barrier.hpp            |     0
 .../boost/mpl/aux_/advance_backward.hpp       |     0
 .../boost/mpl/aux_/advance_forward.hpp        |     0
 .../boost/mpl/aux_/apply_1st.hpp              |     0
 .../boost/mpl/aux_/arg_typedef.hpp            |     0
 .../boost/mpl/aux_/arithmetic_op.hpp          |     0
 .../boost/mpl/aux_/arity.hpp                  |     0
 .../boost/mpl/aux_/arity_spec.hpp             |     0
 .../boost/mpl/aux_/at_impl.hpp                |     0
 .../boost/mpl/aux_/back_impl.hpp              |     0
 .../boost/mpl/aux_/basic_bind.hpp             |     0
 .../boost/mpl/aux_/begin_end_impl.hpp         |     0
 .../boost/mpl/aux_/clear_impl.hpp             |     0
 .../boost/mpl/aux_/common_name_wknd.hpp       |     0
 .../boost/mpl/aux_/comparison_op.hpp          |     0
 .../boost/mpl/aux_/config/adl.hpp             |     0
 .../boost/mpl/aux_/config/arrays.hpp          |     0
 .../boost/mpl/aux_/config/bcc.hpp             |     0
 .../boost/mpl/aux_/config/bind.hpp            |     0
 .../boost/mpl/aux_/config/compiler.hpp        |     0
 .../boost/mpl/aux_/config/ctps.hpp            |     0
 .../boost/mpl/aux_/config/dependent_nttp.hpp  |     0
 .../mpl/aux_/config/dmc_ambiguous_ctps.hpp    |     0
 .../boost/mpl/aux_/config/dtp.hpp             |     0
 .../boost/mpl/aux_/config/eti.hpp             |     0
 .../boost/mpl/aux_/config/forwarding.hpp      |     0
 .../boost/mpl/aux_/config/gcc.hpp             |     0
 .../boost/mpl/aux_/config/gpu.hpp             |     0
 .../boost/mpl/aux_/config/has_apply.hpp       |     0
 .../boost/mpl/aux_/config/has_xxx.hpp         |     0
 .../boost/mpl/aux_/config/integral.hpp        |     0
 .../boost/mpl/aux_/config/intel.hpp           |     0
 .../boost/mpl/aux_/config/lambda.hpp          |     0
 .../boost/mpl/aux_/config/msvc.hpp            |     0
 .../boost/mpl/aux_/config/msvc_typename.hpp   |     0
 .../boost/mpl/aux_/config/nttp.hpp            |     0
 .../boost/mpl/aux_/config/operators.hpp       |     0
 .../mpl/aux_/config/overload_resolution.hpp   |     0
 .../boost/mpl/aux_/config/pp_counter.hpp      |     0
 .../boost/mpl/aux_/config/preprocessor.hpp    |     0
 .../boost/mpl/aux_/config/static_constant.hpp |     0
 .../boost/mpl/aux_/config/ttp.hpp             |     0
 .../boost/mpl/aux_/config/typeof.hpp          |     0
 .../mpl/aux_/config/use_preprocessed.hpp      |     0
 .../boost/mpl/aux_/config/workaround.hpp      |     0
 .../boost/mpl/aux_/contains_impl.hpp          |     0
 .../boost/mpl/aux_/count_args.hpp             |     0
 .../boost/mpl/aux_/count_impl.hpp             |     0
 .../boost/mpl/aux_/empty_impl.hpp             |     0
 .../boost/mpl/aux_/erase_impl.hpp             |     0
 .../boost/mpl/aux_/erase_key_impl.hpp         |     0
 .../boost/mpl/aux_/filter_iter.hpp            |     0
 .../boost/mpl/aux_/find_if_pred.hpp           |     0
 .../boost/mpl/aux_/fold_impl.hpp              |     0
 .../boost/mpl/aux_/fold_impl_body.hpp         |     0
 .../boost/mpl/aux_/fold_op.hpp                |     0
 .../boost/mpl/aux_/fold_pred.hpp              |     0
 .../boost/mpl/aux_/front_impl.hpp             |     0
 .../boost/mpl/aux_/full_lambda.hpp            |     0
 .../boost/mpl/aux_/has_apply.hpp              |     0
 .../boost/mpl/aux_/has_begin.hpp              |     0
 .../boost/mpl/aux_/has_key_impl.hpp           |     0
 .../boost/mpl/aux_/has_rebind.hpp             |     0
 .../boost/mpl/aux_/has_size.hpp               |     0
 .../boost/mpl/aux_/has_tag.hpp                |     0
 .../boost/mpl/aux_/has_type.hpp               |     0
 .../boost/mpl/aux_/include_preprocessed.hpp   |     0
 .../boost/mpl/aux_/insert_impl.hpp            |     0
 .../boost/mpl/aux_/insert_range_impl.hpp      |     0
 .../boost/mpl/aux_/inserter_algorithm.hpp     |     0
 .../boost/mpl/aux_/integral_wrapper.hpp       |     0
 .../boost/mpl/aux_/is_msvc_eti_arg.hpp        |     0
 .../boost/mpl/aux_/iter_apply.hpp             |     0
 .../boost/mpl/aux_/iter_fold_if_impl.hpp      |     0
 .../boost/mpl/aux_/iter_fold_impl.hpp         |     0
 .../boost/mpl/aux_/iter_push_front.hpp        |     0
 .../boost/mpl/aux_/joint_iter.hpp             |     0
 .../boost/mpl/aux_/lambda_arity_param.hpp     |     0
 .../boost/mpl/aux_/lambda_no_ctps.hpp         |     0
 .../boost/mpl/aux_/lambda_spec.hpp            |     0
 .../boost/mpl/aux_/lambda_support.hpp         |     0
 .../boost/mpl/aux_/largest_int.hpp            |     0
 .../boost/mpl/aux_/logical_op.hpp             |     0
 .../boost/mpl/aux_/msvc_dtw.hpp               |     0
 .../boost/mpl/aux_/msvc_eti_base.hpp          |     0
 .../boost/mpl/aux_/msvc_is_class.hpp          |     0
 .../boost/mpl/aux_/msvc_never_true.hpp        |     0
 .../boost/mpl/aux_/msvc_type.hpp              |     0
 .../boost/mpl/aux_/na.hpp                     |     0
 .../boost/mpl/aux_/na_assert.hpp              |     0
 .../boost/mpl/aux_/na_fwd.hpp                 |     0
 .../boost/mpl/aux_/na_spec.hpp                |     0
 .../boost/mpl/aux_/nested_type_wknd.hpp       |     0
 .../boost/mpl/aux_/nttp_decl.hpp              |     0
 .../boost/mpl/aux_/numeric_cast_utils.hpp     |     0
 .../boost/mpl/aux_/numeric_op.hpp             |     0
 .../boost/mpl/aux_/order_impl.hpp             |     0
 .../boost/mpl/aux_/overload_names.hpp         |     0
 .../boost/mpl/aux_/partition_op.hpp           |     0
 .../boost/mpl/aux_/pop_back_impl.hpp          |     0
 .../boost/mpl/aux_/pop_front_impl.hpp         |     0
 .../preprocessed/bcc/advance_backward.hpp     |     0
 .../aux_/preprocessed/bcc/advance_forward.hpp |     0
 .../boost/mpl/aux_/preprocessed/bcc/and.hpp   |     0
 .../boost/mpl/aux_/preprocessed/bcc/apply.hpp |     0
 .../mpl/aux_/preprocessed/bcc/apply_fwd.hpp   |     0
 .../mpl/aux_/preprocessed/bcc/apply_wrap.hpp  |     0
 .../boost/mpl/aux_/preprocessed/bcc/arg.hpp   |     0
 .../mpl/aux_/preprocessed/bcc/basic_bind.hpp  |     0
 .../boost/mpl/aux_/preprocessed/bcc/bind.hpp  |     0
 .../mpl/aux_/preprocessed/bcc/bind_fwd.hpp    |     0
 .../mpl/aux_/preprocessed/bcc/bitand.hpp      |     0
 .../boost/mpl/aux_/preprocessed/bcc/bitor.hpp |     0
 .../mpl/aux_/preprocessed/bcc/bitxor.hpp      |     0
 .../boost/mpl/aux_/preprocessed/bcc/deque.hpp |     0
 .../mpl/aux_/preprocessed/bcc/divides.hpp     |     0
 .../mpl/aux_/preprocessed/bcc/equal_to.hpp    |     0
 .../mpl/aux_/preprocessed/bcc/fold_impl.hpp   |     0
 .../mpl/aux_/preprocessed/bcc/full_lambda.hpp |     0
 .../mpl/aux_/preprocessed/bcc/greater.hpp     |     0
 .../aux_/preprocessed/bcc/greater_equal.hpp   |     0
 .../mpl/aux_/preprocessed/bcc/inherit.hpp     |     0
 .../preprocessed/bcc/iter_fold_if_impl.hpp    |     0
 .../aux_/preprocessed/bcc/iter_fold_impl.hpp  |     0
 .../aux_/preprocessed/bcc/lambda_no_ctps.hpp  |     0
 .../boost/mpl/aux_/preprocessed/bcc/less.hpp  |     0
 .../mpl/aux_/preprocessed/bcc/less_equal.hpp  |     0
 .../boost/mpl/aux_/preprocessed/bcc/list.hpp  |     0
 .../mpl/aux_/preprocessed/bcc/list_c.hpp      |     0
 .../boost/mpl/aux_/preprocessed/bcc/map.hpp   |     0
 .../boost/mpl/aux_/preprocessed/bcc/minus.hpp |     0
 .../mpl/aux_/preprocessed/bcc/modulus.hpp     |     0
 .../aux_/preprocessed/bcc/not_equal_to.hpp    |     0
 .../boost/mpl/aux_/preprocessed/bcc/or.hpp    |     0
 .../aux_/preprocessed/bcc/placeholders.hpp    |     0
 .../boost/mpl/aux_/preprocessed/bcc/plus.hpp  |     0
 .../boost/mpl/aux_/preprocessed/bcc/quote.hpp |     0
 .../preprocessed/bcc/reverse_fold_impl.hpp    |     0
 .../bcc/reverse_iter_fold_impl.hpp            |     0
 .../boost/mpl/aux_/preprocessed/bcc/set.hpp   |     0
 .../boost/mpl/aux_/preprocessed/bcc/set_c.hpp |     0
 .../mpl/aux_/preprocessed/bcc/shift_left.hpp  |     0
 .../mpl/aux_/preprocessed/bcc/shift_right.hpp |     0
 .../aux_/preprocessed/bcc/template_arity.hpp  |     0
 .../boost/mpl/aux_/preprocessed/bcc/times.hpp |     0
 .../mpl/aux_/preprocessed/bcc/unpack_args.hpp |     0
 .../mpl/aux_/preprocessed/bcc/vector.hpp      |     0
 .../mpl/aux_/preprocessed/bcc/vector_c.hpp    |     0
 .../preprocessed/bcc551/advance_backward.hpp  |     0
 .../preprocessed/bcc551/advance_forward.hpp   |     0
 .../mpl/aux_/preprocessed/bcc551/and.hpp      |     0
 .../mpl/aux_/preprocessed/bcc551/apply.hpp    |     0
 .../aux_/preprocessed/bcc551/apply_fwd.hpp    |     0
 .../aux_/preprocessed/bcc551/apply_wrap.hpp   |     0
 .../mpl/aux_/preprocessed/bcc551/arg.hpp      |     0
 .../aux_/preprocessed/bcc551/basic_bind.hpp   |     0
 .../mpl/aux_/preprocessed/bcc551/bind.hpp     |     0
 .../mpl/aux_/preprocessed/bcc551/bind_fwd.hpp |     0
 .../mpl/aux_/preprocessed/bcc551/bitand.hpp   |     0
 .../mpl/aux_/preprocessed/bcc551/bitor.hpp    |     0
 .../mpl/aux_/preprocessed/bcc551/bitxor.hpp   |     0
 .../mpl/aux_/preprocessed/bcc551/deque.hpp    |     0
 .../mpl/aux_/preprocessed/bcc551/divides.hpp  |     0
 .../mpl/aux_/preprocessed/bcc551/equal_to.hpp |     0
 .../aux_/preprocessed/bcc551/fold_impl.hpp    |     0
 .../aux_/preprocessed/bcc551/full_lambda.hpp  |     0
 .../mpl/aux_/preprocessed/bcc551/greater.hpp  |     0
 .../preprocessed/bcc551/greater_equal.hpp     |     0
 .../mpl/aux_/preprocessed/bcc551/inherit.hpp  |     0
 .../preprocessed/bcc551/iter_fold_if_impl.hpp |     0
 .../preprocessed/bcc551/iter_fold_impl.hpp    |     0
 .../preprocessed/bcc551/lambda_no_ctps.hpp    |     0
 .../mpl/aux_/preprocessed/bcc551/less.hpp     |     0
 .../aux_/preprocessed/bcc551/less_equal.hpp   |     0
 .../mpl/aux_/preprocessed/bcc551/list.hpp     |     0
 .../mpl/aux_/preprocessed/bcc551/list_c.hpp   |     0
 .../mpl/aux_/preprocessed/bcc551/map.hpp      |     0
 .../mpl/aux_/preprocessed/bcc551/minus.hpp    |     0
 .../mpl/aux_/preprocessed/bcc551/modulus.hpp  |     0
 .../aux_/preprocessed/bcc551/not_equal_to.hpp |     0
 .../boost/mpl/aux_/preprocessed/bcc551/or.hpp |     0
 .../aux_/preprocessed/bcc551/placeholders.hpp |     0
 .../mpl/aux_/preprocessed/bcc551/plus.hpp     |     0
 .../mpl/aux_/preprocessed/bcc551/quote.hpp    |     0
 .../preprocessed/bcc551/reverse_fold_impl.hpp |     0
 .../bcc551/reverse_iter_fold_impl.hpp         |     0
 .../mpl/aux_/preprocessed/bcc551/set.hpp      |     0
 .../mpl/aux_/preprocessed/bcc551/set_c.hpp    |     0
 .../aux_/preprocessed/bcc551/shift_left.hpp   |     0
 .../aux_/preprocessed/bcc551/shift_right.hpp  |     0
 .../preprocessed/bcc551/template_arity.hpp    |     0
 .../mpl/aux_/preprocessed/bcc551/times.hpp    |     0
 .../aux_/preprocessed/bcc551/unpack_args.hpp  |     0
 .../mpl/aux_/preprocessed/bcc551/vector.hpp   |     0
 .../mpl/aux_/preprocessed/bcc551/vector_c.hpp |     0
 .../bcc_pre590/advance_backward.hpp           |     0
 .../bcc_pre590/advance_forward.hpp            |     0
 .../mpl/aux_/preprocessed/bcc_pre590/and.hpp  |     0
 .../aux_/preprocessed/bcc_pre590/apply.hpp    |     0
 .../preprocessed/bcc_pre590/apply_fwd.hpp     |     0
 .../preprocessed/bcc_pre590/apply_wrap.hpp    |     0
 .../mpl/aux_/preprocessed/bcc_pre590/arg.hpp  |     0
 .../preprocessed/bcc_pre590/basic_bind.hpp    |     0
 .../mpl/aux_/preprocessed/bcc_pre590/bind.hpp |     0
 .../aux_/preprocessed/bcc_pre590/bind_fwd.hpp |     0
 .../aux_/preprocessed/bcc_pre590/bitand.hpp   |     0
 .../aux_/preprocessed/bcc_pre590/bitor.hpp    |     0
 .../aux_/preprocessed/bcc_pre590/bitxor.hpp   |     0
 .../aux_/preprocessed/bcc_pre590/deque.hpp    |     0
 .../aux_/preprocessed/bcc_pre590/divides.hpp  |     0
 .../aux_/preprocessed/bcc_pre590/equal_to.hpp |     0
 .../preprocessed/bcc_pre590/fold_impl.hpp     |     0
 .../preprocessed/bcc_pre590/full_lambda.hpp   |     0
 .../aux_/preprocessed/bcc_pre590/greater.hpp  |     0
 .../preprocessed/bcc_pre590/greater_equal.hpp |     0
 .../aux_/preprocessed/bcc_pre590/inherit.hpp  |     0
 .../bcc_pre590/iter_fold_if_impl.hpp          |     0
 .../bcc_pre590/iter_fold_impl.hpp             |     0
 .../bcc_pre590/lambda_no_ctps.hpp             |     0
 .../mpl/aux_/preprocessed/bcc_pre590/less.hpp |     0
 .../preprocessed/bcc_pre590/less_equal.hpp    |     0
 .../mpl/aux_/preprocessed/bcc_pre590/list.hpp |     0
 .../aux_/preprocessed/bcc_pre590/list_c.hpp   |     0
 .../mpl/aux_/preprocessed/bcc_pre590/map.hpp  |     0
 .../aux_/preprocessed/bcc_pre590/minus.hpp    |     0
 .../aux_/preprocessed/bcc_pre590/modulus.hpp  |     0
 .../preprocessed/bcc_pre590/not_equal_to.hpp  |     0
 .../mpl/aux_/preprocessed/bcc_pre590/or.hpp   |     0
 .../preprocessed/bcc_pre590/placeholders.hpp  |     0
 .../mpl/aux_/preprocessed/bcc_pre590/plus.hpp |     0
 .../aux_/preprocessed/bcc_pre590/quote.hpp    |     0
 .../bcc_pre590/reverse_fold_impl.hpp          |     0
 .../bcc_pre590/reverse_iter_fold_impl.hpp     |     0
 .../mpl/aux_/preprocessed/bcc_pre590/set.hpp  |     0
 .../aux_/preprocessed/bcc_pre590/set_c.hpp    |     0
 .../preprocessed/bcc_pre590/shift_left.hpp    |     0
 .../preprocessed/bcc_pre590/shift_right.hpp   |     0
 .../bcc_pre590/template_arity.hpp             |     0
 .../aux_/preprocessed/bcc_pre590/times.hpp    |     0
 .../preprocessed/bcc_pre590/unpack_args.hpp   |     0
 .../aux_/preprocessed/bcc_pre590/vector.hpp   |     0
 .../aux_/preprocessed/bcc_pre590/vector_c.hpp |     0
 .../preprocessed/dmc/advance_backward.hpp     |     0
 .../aux_/preprocessed/dmc/advance_forward.hpp |     0
 .../boost/mpl/aux_/preprocessed/dmc/and.hpp   |     0
 .../boost/mpl/aux_/preprocessed/dmc/apply.hpp |     0
 .../mpl/aux_/preprocessed/dmc/apply_fwd.hpp   |     0
 .../mpl/aux_/preprocessed/dmc/apply_wrap.hpp  |     0
 .../boost/mpl/aux_/preprocessed/dmc/arg.hpp   |     0
 .../mpl/aux_/preprocessed/dmc/basic_bind.hpp  |     0
 .../boost/mpl/aux_/preprocessed/dmc/bind.hpp  |     0
 .../mpl/aux_/preprocessed/dmc/bind_fwd.hpp    |     0
 .../mpl/aux_/preprocessed/dmc/bitand.hpp      |     0
 .../boost/mpl/aux_/preprocessed/dmc/bitor.hpp |     0
 .../mpl/aux_/preprocessed/dmc/bitxor.hpp      |     0
 .../boost/mpl/aux_/preprocessed/dmc/deque.hpp |     0
 .../mpl/aux_/preprocessed/dmc/divides.hpp     |     0
 .../mpl/aux_/preprocessed/dmc/equal_to.hpp    |     0
 .../mpl/aux_/preprocessed/dmc/fold_impl.hpp   |     0
 .../mpl/aux_/preprocessed/dmc/full_lambda.hpp |     0
 .../mpl/aux_/preprocessed/dmc/greater.hpp     |     0
 .../aux_/preprocessed/dmc/greater_equal.hpp   |     0
 .../mpl/aux_/preprocessed/dmc/inherit.hpp     |     0
 .../preprocessed/dmc/iter_fold_if_impl.hpp    |     0
 .../aux_/preprocessed/dmc/iter_fold_impl.hpp  |     0
 .../aux_/preprocessed/dmc/lambda_no_ctps.hpp  |     0
 .../boost/mpl/aux_/preprocessed/dmc/less.hpp  |     0
 .../mpl/aux_/preprocessed/dmc/less_equal.hpp  |     0
 .../boost/mpl/aux_/preprocessed/dmc/list.hpp  |     0
 .../mpl/aux_/preprocessed/dmc/list_c.hpp      |     0
 .../boost/mpl/aux_/preprocessed/dmc/map.hpp   |     0
 .../boost/mpl/aux_/preprocessed/dmc/minus.hpp |     0
 .../mpl/aux_/preprocessed/dmc/modulus.hpp     |     0
 .../aux_/preprocessed/dmc/not_equal_to.hpp    |     0
 .../boost/mpl/aux_/preprocessed/dmc/or.hpp    |     0
 .../aux_/preprocessed/dmc/placeholders.hpp    |     0
 .../boost/mpl/aux_/preprocessed/dmc/plus.hpp  |     0
 .../boost/mpl/aux_/preprocessed/dmc/quote.hpp |     0
 .../preprocessed/dmc/reverse_fold_impl.hpp    |     0
 .../dmc/reverse_iter_fold_impl.hpp            |     0
 .../boost/mpl/aux_/preprocessed/dmc/set.hpp   |     0
 .../boost/mpl/aux_/preprocessed/dmc/set_c.hpp |     0
 .../mpl/aux_/preprocessed/dmc/shift_left.hpp  |     0
 .../mpl/aux_/preprocessed/dmc/shift_right.hpp |     0
 .../aux_/preprocessed/dmc/template_arity.hpp  |     0
 .../boost/mpl/aux_/preprocessed/dmc/times.hpp |     0
 .../mpl/aux_/preprocessed/dmc/unpack_args.hpp |     0
 .../mpl/aux_/preprocessed/dmc/vector.hpp      |     0
 .../mpl/aux_/preprocessed/dmc/vector_c.hpp    |     0
 .../preprocessed/gcc/advance_backward.hpp     |     0
 .../aux_/preprocessed/gcc/advance_forward.hpp |     0
 .../boost/mpl/aux_/preprocessed/gcc/and.hpp   |     0
 .../boost/mpl/aux_/preprocessed/gcc/apply.hpp |     0
 .../mpl/aux_/preprocessed/gcc/apply_fwd.hpp   |     0
 .../mpl/aux_/preprocessed/gcc/apply_wrap.hpp  |     0
 .../boost/mpl/aux_/preprocessed/gcc/arg.hpp   |     0
 .../mpl/aux_/preprocessed/gcc/basic_bind.hpp  |     0
 .../boost/mpl/aux_/preprocessed/gcc/bind.hpp  |     0
 .../mpl/aux_/preprocessed/gcc/bind_fwd.hpp    |     0
 .../mpl/aux_/preprocessed/gcc/bitand.hpp      |     0
 .../boost/mpl/aux_/preprocessed/gcc/bitor.hpp |     0
 .../mpl/aux_/preprocessed/gcc/bitxor.hpp      |     0
 .../boost/mpl/aux_/preprocessed/gcc/deque.hpp |     0
 .../mpl/aux_/preprocessed/gcc/divides.hpp     |     0
 .../mpl/aux_/preprocessed/gcc/equal_to.hpp    |     0
 .../mpl/aux_/preprocessed/gcc/fold_impl.hpp   |     0
 .../mpl/aux_/preprocessed/gcc/full_lambda.hpp |     0
 .../mpl/aux_/preprocessed/gcc/greater.hpp     |     0
 .../aux_/preprocessed/gcc/greater_equal.hpp   |     0
 .../mpl/aux_/preprocessed/gcc/inherit.hpp     |     0
 .../preprocessed/gcc/iter_fold_if_impl.hpp    |     0
 .../aux_/preprocessed/gcc/iter_fold_impl.hpp  |     0
 .../aux_/preprocessed/gcc/lambda_no_ctps.hpp  |     0
 .../boost/mpl/aux_/preprocessed/gcc/less.hpp  |     0
 .../mpl/aux_/preprocessed/gcc/less_equal.hpp  |     0
 .../boost/mpl/aux_/preprocessed/gcc/list.hpp  |     0
 .../mpl/aux_/preprocessed/gcc/list_c.hpp      |     0
 .../boost/mpl/aux_/preprocessed/gcc/map.hpp   |     0
 .../boost/mpl/aux_/preprocessed/gcc/minus.hpp |     0
 .../mpl/aux_/preprocessed/gcc/modulus.hpp     |     0
 .../aux_/preprocessed/gcc/not_equal_to.hpp    |     0
 .../boost/mpl/aux_/preprocessed/gcc/or.hpp    |     0
 .../aux_/preprocessed/gcc/placeholders.hpp    |     0
 .../boost/mpl/aux_/preprocessed/gcc/plus.hpp  |     0
 .../boost/mpl/aux_/preprocessed/gcc/quote.hpp |     0
 .../preprocessed/gcc/reverse_fold_impl.hpp    |     0
 .../gcc/reverse_iter_fold_impl.hpp            |     0
 .../boost/mpl/aux_/preprocessed/gcc/set.hpp   |     0
 .../boost/mpl/aux_/preprocessed/gcc/set_c.hpp |     0
 .../mpl/aux_/preprocessed/gcc/shift_left.hpp  |     0
 .../mpl/aux_/preprocessed/gcc/shift_right.hpp |     0
 .../aux_/preprocessed/gcc/template_arity.hpp  |     0
 .../boost/mpl/aux_/preprocessed/gcc/times.hpp |     0
 .../mpl/aux_/preprocessed/gcc/unpack_args.hpp |     0
 .../mpl/aux_/preprocessed/gcc/vector.hpp      |     0
 .../mpl/aux_/preprocessed/gcc/vector_c.hpp    |     0
 .../preprocessed/msvc60/advance_backward.hpp  |     0
 .../preprocessed/msvc60/advance_forward.hpp   |     0
 .../mpl/aux_/preprocessed/msvc60/and.hpp      |     0
 .../mpl/aux_/preprocessed/msvc60/apply.hpp    |     0
 .../aux_/preprocessed/msvc60/apply_fwd.hpp    |     0
 .../aux_/preprocessed/msvc60/apply_wrap.hpp   |     0
 .../mpl/aux_/preprocessed/msvc60/arg.hpp      |     0
 .../aux_/preprocessed/msvc60/basic_bind.hpp   |     0
 .../mpl/aux_/preprocessed/msvc60/bind.hpp     |     0
 .../mpl/aux_/preprocessed/msvc60/bind_fwd.hpp |     0
 .../mpl/aux_/preprocessed/msvc60/bitand.hpp   |     0
 .../mpl/aux_/preprocessed/msvc60/bitor.hpp    |     0
 .../mpl/aux_/preprocessed/msvc60/bitxor.hpp   |     0
 .../mpl/aux_/preprocessed/msvc60/deque.hpp    |     0
 .../mpl/aux_/preprocessed/msvc60/divides.hpp  |     0
 .../mpl/aux_/preprocessed/msvc60/equal_to.hpp |     0
 .../aux_/preprocessed/msvc60/fold_impl.hpp    |     0
 .../aux_/preprocessed/msvc60/full_lambda.hpp  |     0
 .../mpl/aux_/preprocessed/msvc60/greater.hpp  |     0
 .../preprocessed/msvc60/greater_equal.hpp     |     0
 .../mpl/aux_/preprocessed/msvc60/inherit.hpp  |     0
 .../preprocessed/msvc60/iter_fold_if_impl.hpp |     0
 .../preprocessed/msvc60/iter_fold_impl.hpp    |     0
 .../preprocessed/msvc60/lambda_no_ctps.hpp    |     0
 .../mpl/aux_/preprocessed/msvc60/less.hpp     |     0
 .../aux_/preprocessed/msvc60/less_equal.hpp   |     0
 .../mpl/aux_/preprocessed/msvc60/list.hpp     |     0
 .../mpl/aux_/preprocessed/msvc60/list_c.hpp   |     0
 .../mpl/aux_/preprocessed/msvc60/map.hpp      |     0
 .../mpl/aux_/preprocessed/msvc60/minus.hpp    |     0
 .../mpl/aux_/preprocessed/msvc60/modulus.hpp  |     0
 .../aux_/preprocessed/msvc60/not_equal_to.hpp |     0
 .../boost/mpl/aux_/preprocessed/msvc60/or.hpp |     0
 .../aux_/preprocessed/msvc60/placeholders.hpp |     0
 .../mpl/aux_/preprocessed/msvc60/plus.hpp     |     0
 .../mpl/aux_/preprocessed/msvc60/quote.hpp    |     0
 .../preprocessed/msvc60/reverse_fold_impl.hpp |     0
 .../msvc60/reverse_iter_fold_impl.hpp         |     0
 .../mpl/aux_/preprocessed/msvc60/set.hpp      |     0
 .../mpl/aux_/preprocessed/msvc60/set_c.hpp    |     0
 .../aux_/preprocessed/msvc60/shift_left.hpp   |     0
 .../aux_/preprocessed/msvc60/shift_right.hpp  |     0
 .../preprocessed/msvc60/template_arity.hpp    |     0
 .../mpl/aux_/preprocessed/msvc60/times.hpp    |     0
 .../aux_/preprocessed/msvc60/unpack_args.hpp  |     0
 .../mpl/aux_/preprocessed/msvc60/vector.hpp   |     0
 .../mpl/aux_/preprocessed/msvc60/vector_c.hpp |     0
 .../preprocessed/msvc70/advance_backward.hpp  |     0
 .../preprocessed/msvc70/advance_forward.hpp   |     0
 .../mpl/aux_/preprocessed/msvc70/and.hpp      |     0
 .../mpl/aux_/preprocessed/msvc70/apply.hpp    |     0
 .../aux_/preprocessed/msvc70/apply_fwd.hpp    |     0
 .../aux_/preprocessed/msvc70/apply_wrap.hpp   |     0
 .../mpl/aux_/preprocessed/msvc70/arg.hpp      |     0
 .../aux_/preprocessed/msvc70/basic_bind.hpp   |     0
 .../mpl/aux_/preprocessed/msvc70/bind.hpp     |     0
 .../mpl/aux_/preprocessed/msvc70/bind_fwd.hpp |     0
 .../mpl/aux_/preprocessed/msvc70/bitand.hpp   |     0
 .../mpl/aux_/preprocessed/msvc70/bitor.hpp    |     0
 .../mpl/aux_/preprocessed/msvc70/bitxor.hpp   |     0
 .../mpl/aux_/preprocessed/msvc70/deque.hpp    |     0
 .../mpl/aux_/preprocessed/msvc70/divides.hpp  |     0
 .../mpl/aux_/preprocessed/msvc70/equal_to.hpp |     0
 .../aux_/preprocessed/msvc70/fold_impl.hpp    |     0
 .../aux_/preprocessed/msvc70/full_lambda.hpp  |     0
 .../mpl/aux_/preprocessed/msvc70/greater.hpp  |     0
 .../preprocessed/msvc70/greater_equal.hpp     |     0
 .../mpl/aux_/preprocessed/msvc70/inherit.hpp  |     0
 .../preprocessed/msvc70/iter_fold_if_impl.hpp |     0
 .../preprocessed/msvc70/iter_fold_impl.hpp    |     0
 .../preprocessed/msvc70/lambda_no_ctps.hpp    |     0
 .../mpl/aux_/preprocessed/msvc70/less.hpp     |     0
 .../aux_/preprocessed/msvc70/less_equal.hpp   |     0
 .../mpl/aux_/preprocessed/msvc70/list.hpp     |     0
 .../mpl/aux_/preprocessed/msvc70/list_c.hpp   |     0
 .../mpl/aux_/preprocessed/msvc70/map.hpp      |     0
 .../mpl/aux_/preprocessed/msvc70/minus.hpp    |     0
 .../mpl/aux_/preprocessed/msvc70/modulus.hpp  |     0
 .../aux_/preprocessed/msvc70/not_equal_to.hpp |     0
 .../boost/mpl/aux_/preprocessed/msvc70/or.hpp |     0
 .../aux_/preprocessed/msvc70/placeholders.hpp |     0
 .../mpl/aux_/preprocessed/msvc70/plus.hpp     |     0
 .../mpl/aux_/preprocessed/msvc70/quote.hpp    |     0
 .../preprocessed/msvc70/reverse_fold_impl.hpp |     0
 .../msvc70/reverse_iter_fold_impl.hpp         |     0
 .../mpl/aux_/preprocessed/msvc70/set.hpp      |     0
 .../mpl/aux_/preprocessed/msvc70/set_c.hpp    |     0
 .../aux_/preprocessed/msvc70/shift_left.hpp   |     0
 .../aux_/preprocessed/msvc70/shift_right.hpp  |     0
 .../preprocessed/msvc70/template_arity.hpp    |     0
 .../mpl/aux_/preprocessed/msvc70/times.hpp    |     0
 .../aux_/preprocessed/msvc70/unpack_args.hpp  |     0
 .../mpl/aux_/preprocessed/msvc70/vector.hpp   |     0
 .../mpl/aux_/preprocessed/msvc70/vector_c.hpp |     0
 .../preprocessed/mwcw/advance_backward.hpp    |     0
 .../preprocessed/mwcw/advance_forward.hpp     |     0
 .../boost/mpl/aux_/preprocessed/mwcw/and.hpp  |     0
 .../mpl/aux_/preprocessed/mwcw/apply.hpp      |     0
 .../mpl/aux_/preprocessed/mwcw/apply_fwd.hpp  |     0
 .../mpl/aux_/preprocessed/mwcw/apply_wrap.hpp |     0
 .../boost/mpl/aux_/preprocessed/mwcw/arg.hpp  |     0
 .../mpl/aux_/preprocessed/mwcw/basic_bind.hpp |     0
 .../boost/mpl/aux_/preprocessed/mwcw/bind.hpp |     0
 .../mpl/aux_/preprocessed/mwcw/bind_fwd.hpp   |     0
 .../mpl/aux_/preprocessed/mwcw/bitand.hpp     |     0
 .../mpl/aux_/preprocessed/mwcw/bitor.hpp      |     0
 .../mpl/aux_/preprocessed/mwcw/bitxor.hpp     |     0
 .../mpl/aux_/preprocessed/mwcw/deque.hpp      |     0
 .../mpl/aux_/preprocessed/mwcw/divides.hpp    |     0
 .../mpl/aux_/preprocessed/mwcw/equal_to.hpp   |     0
 .../mpl/aux_/preprocessed/mwcw/fold_impl.hpp  |     0
 .../aux_/preprocessed/mwcw/full_lambda.hpp    |     0
 .../mpl/aux_/preprocessed/mwcw/greater.hpp    |     0
 .../aux_/preprocessed/mwcw/greater_equal.hpp  |     0
 .../mpl/aux_/preprocessed/mwcw/inherit.hpp    |     0
 .../preprocessed/mwcw/iter_fold_if_impl.hpp   |     0
 .../aux_/preprocessed/mwcw/iter_fold_impl.hpp |     0
 .../aux_/preprocessed/mwcw/lambda_no_ctps.hpp |     0
 .../boost/mpl/aux_/preprocessed/mwcw/less.hpp |     0
 .../mpl/aux_/preprocessed/mwcw/less_equal.hpp |     0
 .../boost/mpl/aux_/preprocessed/mwcw/list.hpp |     0
 .../mpl/aux_/preprocessed/mwcw/list_c.hpp     |     0
 .../boost/mpl/aux_/preprocessed/mwcw/map.hpp  |     0
 .../mpl/aux_/preprocessed/mwcw/minus.hpp      |     0
 .../mpl/aux_/preprocessed/mwcw/modulus.hpp    |     0
 .../aux_/preprocessed/mwcw/not_equal_to.hpp   |     0
 .../boost/mpl/aux_/preprocessed/mwcw/or.hpp   |     0
 .../aux_/preprocessed/mwcw/placeholders.hpp   |     0
 .../boost/mpl/aux_/preprocessed/mwcw/plus.hpp |     0
 .../mpl/aux_/preprocessed/mwcw/quote.hpp      |     0
 .../preprocessed/mwcw/reverse_fold_impl.hpp   |     0
 .../mwcw/reverse_iter_fold_impl.hpp           |     0
 .../boost/mpl/aux_/preprocessed/mwcw/set.hpp  |     0
 .../mpl/aux_/preprocessed/mwcw/set_c.hpp      |     0
 .../mpl/aux_/preprocessed/mwcw/shift_left.hpp |     0
 .../aux_/preprocessed/mwcw/shift_right.hpp    |     0
 .../aux_/preprocessed/mwcw/template_arity.hpp |     0
 .../mpl/aux_/preprocessed/mwcw/times.hpp      |     0
 .../aux_/preprocessed/mwcw/unpack_args.hpp    |     0
 .../mpl/aux_/preprocessed/mwcw/vector.hpp     |     0
 .../mpl/aux_/preprocessed/mwcw/vector_c.hpp   |     0
 .../preprocessed/no_ctps/advance_backward.hpp |     0
 .../preprocessed/no_ctps/advance_forward.hpp  |     0
 .../mpl/aux_/preprocessed/no_ctps/and.hpp     |     0
 .../mpl/aux_/preprocessed/no_ctps/apply.hpp   |     0
 .../aux_/preprocessed/no_ctps/apply_fwd.hpp   |     0
 .../aux_/preprocessed/no_ctps/apply_wrap.hpp  |     0
 .../mpl/aux_/preprocessed/no_ctps/arg.hpp     |     0
 .../aux_/preprocessed/no_ctps/basic_bind.hpp  |     0
 .../mpl/aux_/preprocessed/no_ctps/bind.hpp    |     0
 .../aux_/preprocessed/no_ctps/bind_fwd.hpp    |     0
 .../mpl/aux_/preprocessed/no_ctps/bitand.hpp  |     0
 .../mpl/aux_/preprocessed/no_ctps/bitor.hpp   |     0
 .../mpl/aux_/preprocessed/no_ctps/bitxor.hpp  |     0
 .../mpl/aux_/preprocessed/no_ctps/deque.hpp   |     0
 .../mpl/aux_/preprocessed/no_ctps/divides.hpp |     0
 .../aux_/preprocessed/no_ctps/equal_to.hpp    |     0
 .../aux_/preprocessed/no_ctps/fold_impl.hpp   |     0
 .../aux_/preprocessed/no_ctps/full_lambda.hpp |     0
 .../mpl/aux_/preprocessed/no_ctps/greater.hpp |     0
 .../preprocessed/no_ctps/greater_equal.hpp    |     0
 .../mpl/aux_/preprocessed/no_ctps/inherit.hpp |     0
 .../no_ctps/iter_fold_if_impl.hpp             |     0
 .../preprocessed/no_ctps/iter_fold_impl.hpp   |     0
 .../preprocessed/no_ctps/lambda_no_ctps.hpp   |     0
 .../mpl/aux_/preprocessed/no_ctps/less.hpp    |     0
 .../aux_/preprocessed/no_ctps/less_equal.hpp  |     0
 .../mpl/aux_/preprocessed/no_ctps/list.hpp    |     0
 .../mpl/aux_/preprocessed/no_ctps/list_c.hpp  |     0
 .../mpl/aux_/preprocessed/no_ctps/map.hpp     |     0
 .../mpl/aux_/preprocessed/no_ctps/minus.hpp   |     0
 .../mpl/aux_/preprocessed/no_ctps/modulus.hpp |     0
 .../preprocessed/no_ctps/not_equal_to.hpp     |     0
 .../mpl/aux_/preprocessed/no_ctps/or.hpp      |     0
 .../preprocessed/no_ctps/placeholders.hpp     |     0
 .../mpl/aux_/preprocessed/no_ctps/plus.hpp    |     0
 .../mpl/aux_/preprocessed/no_ctps/quote.hpp   |     0
 .../no_ctps/reverse_fold_impl.hpp             |     0
 .../no_ctps/reverse_iter_fold_impl.hpp        |     0
 .../mpl/aux_/preprocessed/no_ctps/set.hpp     |     0
 .../mpl/aux_/preprocessed/no_ctps/set_c.hpp   |     0
 .../aux_/preprocessed/no_ctps/shift_left.hpp  |     0
 .../aux_/preprocessed/no_ctps/shift_right.hpp |     0
 .../preprocessed/no_ctps/template_arity.hpp   |     0
 .../mpl/aux_/preprocessed/no_ctps/times.hpp   |     0
 .../aux_/preprocessed/no_ctps/unpack_args.hpp |     0
 .../mpl/aux_/preprocessed/no_ctps/vector.hpp  |     0
 .../aux_/preprocessed/no_ctps/vector_c.hpp    |     0
 .../preprocessed/no_ttp/advance_backward.hpp  |     0
 .../preprocessed/no_ttp/advance_forward.hpp   |     0
 .../mpl/aux_/preprocessed/no_ttp/and.hpp      |     0
 .../mpl/aux_/preprocessed/no_ttp/apply.hpp    |     0
 .../aux_/preprocessed/no_ttp/apply_fwd.hpp    |     0
 .../aux_/preprocessed/no_ttp/apply_wrap.hpp   |     0
 .../mpl/aux_/preprocessed/no_ttp/arg.hpp      |     0
 .../aux_/preprocessed/no_ttp/basic_bind.hpp   |     0
 .../mpl/aux_/preprocessed/no_ttp/bind.hpp     |     0
 .../mpl/aux_/preprocessed/no_ttp/bind_fwd.hpp |     0
 .../mpl/aux_/preprocessed/no_ttp/bitand.hpp   |     0
 .../mpl/aux_/preprocessed/no_ttp/bitor.hpp    |     0
 .../mpl/aux_/preprocessed/no_ttp/bitxor.hpp   |     0
 .../mpl/aux_/preprocessed/no_ttp/deque.hpp    |     0
 .../mpl/aux_/preprocessed/no_ttp/divides.hpp  |     0
 .../mpl/aux_/preprocessed/no_ttp/equal_to.hpp |     0
 .../aux_/preprocessed/no_ttp/fold_impl.hpp    |     0
 .../aux_/preprocessed/no_ttp/full_lambda.hpp  |     0
 .../mpl/aux_/preprocessed/no_ttp/greater.hpp  |     0
 .../preprocessed/no_ttp/greater_equal.hpp     |     0
 .../mpl/aux_/preprocessed/no_ttp/inherit.hpp  |     0
 .../preprocessed/no_ttp/iter_fold_if_impl.hpp |     0
 .../preprocessed/no_ttp/iter_fold_impl.hpp    |     0
 .../preprocessed/no_ttp/lambda_no_ctps.hpp    |     0
 .../mpl/aux_/preprocessed/no_ttp/less.hpp     |     0
 .../aux_/preprocessed/no_ttp/less_equal.hpp   |     0
 .../mpl/aux_/preprocessed/no_ttp/list.hpp     |     0
 .../mpl/aux_/preprocessed/no_ttp/list_c.hpp   |     0
 .../mpl/aux_/preprocessed/no_ttp/map.hpp      |     0
 .../mpl/aux_/preprocessed/no_ttp/minus.hpp    |     0
 .../mpl/aux_/preprocessed/no_ttp/modulus.hpp  |     0
 .../aux_/preprocessed/no_ttp/not_equal_to.hpp |     0
 .../boost/mpl/aux_/preprocessed/no_ttp/or.hpp |     0
 .../aux_/preprocessed/no_ttp/placeholders.hpp |     0
 .../mpl/aux_/preprocessed/no_ttp/plus.hpp     |     0
 .../mpl/aux_/preprocessed/no_ttp/quote.hpp    |     0
 .../preprocessed/no_ttp/reverse_fold_impl.hpp |     0
 .../no_ttp/reverse_iter_fold_impl.hpp         |     0
 .../mpl/aux_/preprocessed/no_ttp/set.hpp      |     0
 .../mpl/aux_/preprocessed/no_ttp/set_c.hpp    |     0
 .../aux_/preprocessed/no_ttp/shift_left.hpp   |     0
 .../aux_/preprocessed/no_ttp/shift_right.hpp  |     0
 .../preprocessed/no_ttp/template_arity.hpp    |     0
 .../mpl/aux_/preprocessed/no_ttp/times.hpp    |     0
 .../aux_/preprocessed/no_ttp/unpack_args.hpp  |     0
 .../mpl/aux_/preprocessed/no_ttp/vector.hpp   |     0
 .../mpl/aux_/preprocessed/no_ttp/vector_c.hpp |     0
 .../preprocessed/plain/advance_backward.hpp   |     0
 .../preprocessed/plain/advance_forward.hpp    |     0
 .../boost/mpl/aux_/preprocessed/plain/and.hpp |     0
 .../mpl/aux_/preprocessed/plain/apply.hpp     |     0
 .../mpl/aux_/preprocessed/plain/apply_fwd.hpp |     0
 .../aux_/preprocessed/plain/apply_wrap.hpp    |     0
 .../boost/mpl/aux_/preprocessed/plain/arg.hpp |     0
 .../aux_/preprocessed/plain/basic_bind.hpp    |     0
 .../mpl/aux_/preprocessed/plain/bind.hpp      |     0
 .../mpl/aux_/preprocessed/plain/bind_fwd.hpp  |     0
 .../mpl/aux_/preprocessed/plain/bitand.hpp    |     0
 .../mpl/aux_/preprocessed/plain/bitor.hpp     |     0
 .../mpl/aux_/preprocessed/plain/bitxor.hpp    |     0
 .../mpl/aux_/preprocessed/plain/deque.hpp     |     0
 .../mpl/aux_/preprocessed/plain/divides.hpp   |     0
 .../mpl/aux_/preprocessed/plain/equal_to.hpp  |     0
 .../mpl/aux_/preprocessed/plain/fold_impl.hpp |     0
 .../aux_/preprocessed/plain/full_lambda.hpp   |     0
 .../mpl/aux_/preprocessed/plain/greater.hpp   |     0
 .../aux_/preprocessed/plain/greater_equal.hpp |     0
 .../mpl/aux_/preprocessed/plain/inherit.hpp   |     0
 .../preprocessed/plain/iter_fold_if_impl.hpp  |     0
 .../preprocessed/plain/iter_fold_impl.hpp     |     0
 .../preprocessed/plain/lambda_no_ctps.hpp     |     0
 .../mpl/aux_/preprocessed/plain/less.hpp      |     0
 .../aux_/preprocessed/plain/less_equal.hpp    |     0
 .../mpl/aux_/preprocessed/plain/list.hpp      |     0
 .../mpl/aux_/preprocessed/plain/list_c.hpp    |     0
 .../boost/mpl/aux_/preprocessed/plain/map.hpp |     0
 .../mpl/aux_/preprocessed/plain/minus.hpp     |     0
 .../mpl/aux_/preprocessed/plain/modulus.hpp   |     0
 .../aux_/preprocessed/plain/not_equal_to.hpp  |     0
 .../boost/mpl/aux_/preprocessed/plain/or.hpp  |     0
 .../aux_/preprocessed/plain/placeholders.hpp  |     0
 .../mpl/aux_/preprocessed/plain/plus.hpp      |     0
 .../mpl/aux_/preprocessed/plain/quote.hpp     |     0
 .../preprocessed/plain/reverse_fold_impl.hpp  |     0
 .../plain/reverse_iter_fold_impl.hpp          |     0
 .../boost/mpl/aux_/preprocessed/plain/set.hpp |     0
 .../mpl/aux_/preprocessed/plain/set_c.hpp     |     0
 .../aux_/preprocessed/plain/shift_left.hpp    |     0
 .../aux_/preprocessed/plain/shift_right.hpp   |     0
 .../preprocessed/plain/template_arity.hpp     |     0
 .../mpl/aux_/preprocessed/plain/times.hpp     |     0
 .../aux_/preprocessed/plain/unpack_args.hpp   |     0
 .../mpl/aux_/preprocessed/plain/vector.hpp    |     0
 .../mpl/aux_/preprocessed/plain/vector_c.hpp  |     0
 .../boost/mpl/aux_/preprocessor/add.hpp       |     0
 .../mpl/aux_/preprocessor/def_params_tail.hpp |     0
 .../mpl/aux_/preprocessor/default_params.hpp  |     0
 .../boost/mpl/aux_/preprocessor/enum.hpp      |     0
 .../mpl/aux_/preprocessor/ext_params.hpp      |     0
 .../mpl/aux_/preprocessor/filter_params.hpp   |     0
 .../boost/mpl/aux_/preprocessor/is_seq.hpp    |     0
 .../boost/mpl/aux_/preprocessor/params.hpp    |     0
 .../aux_/preprocessor/partial_spec_params.hpp |     0
 .../boost/mpl/aux_/preprocessor/range.hpp     |     0
 .../boost/mpl/aux_/preprocessor/repeat.hpp    |     0
 .../boost/mpl/aux_/preprocessor/sub.hpp       |     0
 .../mpl/aux_/preprocessor/token_equal.hpp     |     0
 .../boost/mpl/aux_/preprocessor/tuple.hpp     |     0
 .../boost/mpl/aux_/ptr_to_ref.hpp             |     0
 .../boost/mpl/aux_/push_back_impl.hpp         |     0
 .../boost/mpl/aux_/push_front_impl.hpp        |     0
 .../boost/mpl/aux_/range_c/O1_size.hpp        |     0
 .../boost/mpl/aux_/range_c/back.hpp           |     0
 .../boost/mpl/aux_/range_c/empty.hpp          |     0
 .../boost/mpl/aux_/range_c/front.hpp          |     0
 .../boost/mpl/aux_/range_c/iterator.hpp       |     0
 .../boost/mpl/aux_/range_c/size.hpp           |     0
 .../boost/mpl/aux_/range_c/tag.hpp            |     0
 .../boost/mpl/aux_/reverse_fold_impl.hpp      |     0
 .../boost/mpl/aux_/reverse_fold_impl_body.hpp |     0
 .../boost/mpl/aux_/reverse_iter_fold_impl.hpp |     0
 .../boost/mpl/aux_/sequence_wrapper.hpp       |     0
 .../boost/mpl/aux_/shift_op.hpp               |     0
 .../boost/mpl/aux_/single_element_iter.hpp    |     0
 .../boost/mpl/aux_/size_impl.hpp              |     0
 .../boost/mpl/aux_/sort_impl.hpp              |     0
 .../boost/mpl/aux_/static_cast.hpp            |     0
 .../boost/mpl/aux_/template_arity.hpp         |     0
 .../boost/mpl/aux_/template_arity_fwd.hpp     |     0
 .../boost/mpl/aux_/test.hpp                   |     0
 .../boost/mpl/aux_/test/assert.hpp            |     0
 .../boost/mpl/aux_/test/data.hpp              |     0
 .../boost/mpl/aux_/test/test_case.hpp         |     0
 .../boost/mpl/aux_/traits_lambda_spec.hpp     |     0
 .../boost/mpl/aux_/transform_iter.hpp         |     0
 .../boost/mpl/aux_/type_wrapper.hpp           |     0
 .../boost/mpl/aux_/unwrap.hpp                 |     0
 .../boost/mpl/aux_/value_wknd.hpp             |     0
 .../boost/mpl/aux_/yes_no.hpp                 |     0
 .../boost/mpl/back.hpp                        |     0
 .../boost/mpl/back_fwd.hpp                    |     0
 .../boost/mpl/back_inserter.hpp               |     0
 .../boost/mpl/base.hpp                        |     0
 .../boost/mpl/begin.hpp                       |     0
 .../boost/mpl/begin_end.hpp                   |     0
 .../boost/mpl/begin_end_fwd.hpp               |     0
 .../boost/mpl/bind.hpp                        |     0
 .../boost/mpl/bind_fwd.hpp                    |     0
 .../boost/mpl/bitand.hpp                      |     0
 .../boost/mpl/bitor.hpp                       |     0
 .../boost/mpl/bitwise.hpp                     |     0
 .../boost/mpl/bitxor.hpp                      |     0
 .../boost/mpl/bool.hpp                        |     0
 .../boost/mpl/bool_fwd.hpp                    |     0
 .../boost/mpl/char.hpp                        |     0
 .../boost/mpl/char_fwd.hpp                    |     0
 .../boost/mpl/clear.hpp                       |     0
 .../boost/mpl/clear_fwd.hpp                   |     0
 .../boost/mpl/comparison.hpp                  |     0
 .../boost/mpl/contains.hpp                    |     0
 .../boost/mpl/contains_fwd.hpp                |     0
 .../boost/mpl/copy.hpp                        |     0
 .../boost/mpl/copy_if.hpp                     |     0
 .../boost/mpl/count.hpp                       |     0
 .../boost/mpl/count_fwd.hpp                   |     0
 .../boost/mpl/count_if.hpp                    |     0
 .../boost/mpl/deque.hpp                       |     0
 .../boost/mpl/deref.hpp                       |     0
 .../boost/mpl/distance.hpp                    |     0
 .../boost/mpl/distance_fwd.hpp                |     0
 .../boost/mpl/divides.hpp                     |     0
 .../boost/mpl/empty.hpp                       |     0
 .../boost/mpl/empty_base.hpp                  |     0
 .../boost/mpl/empty_fwd.hpp                   |     0
 .../boost/mpl/empty_sequence.hpp              |     0
 .../boost/mpl/end.hpp                         |     0
 .../boost/mpl/equal.hpp                       |     0
 .../boost/mpl/equal_to.hpp                    |     0
 .../boost/mpl/erase.hpp                       |     0
 .../boost/mpl/erase_fwd.hpp                   |     0
 .../boost/mpl/erase_key.hpp                   |     0
 .../boost/mpl/erase_key_fwd.hpp               |     0
 .../boost/mpl/eval_if.hpp                     |     0
 .../boost/mpl/filter_view.hpp                 |     0
 .../boost/mpl/find.hpp                        |     0
 .../boost/mpl/find_if.hpp                     |     0
 .../boost/mpl/fold.hpp                        |     0
 .../boost/mpl/for_each.hpp                    |     0
 .../boost/mpl/front.hpp                       |     0
 .../boost/mpl/front_fwd.hpp                   |     0
 .../boost/mpl/front_inserter.hpp              |     0
 .../boost/mpl/greater.hpp                     |     0
 .../boost/mpl/greater_equal.hpp               |     0
 .../boost/mpl/has_key.hpp                     |     0
 .../boost/mpl/has_key_fwd.hpp                 |     0
 .../boost/mpl/has_xxx.hpp                     |     0
 .../boost/mpl/identity.hpp                    |     0
 .../boost/mpl/if.hpp                          |     0
 .../boost/mpl/index_if.hpp                    |     0
 .../boost/mpl/index_of.hpp                    |     0
 .../boost/mpl/inherit.hpp                     |     0
 .../boost/mpl/inherit_linearly.hpp            |     0
 .../boost/mpl/insert.hpp                      |     0
 .../boost/mpl/insert_fwd.hpp                  |     0
 .../boost/mpl/insert_range.hpp                |     0
 .../boost/mpl/insert_range_fwd.hpp            |     0
 .../boost/mpl/inserter.hpp                    |     0
 .../boost/mpl/int.hpp                         |     0
 .../boost/mpl/int_fwd.hpp                     |     0
 .../boost/mpl/integral_c.hpp                  |     0
 .../boost/mpl/integral_c_fwd.hpp              |     0
 .../boost/mpl/integral_c_tag.hpp              |     0
 .../boost/mpl/is_placeholder.hpp              |     0
 .../boost/mpl/is_sequence.hpp                 |     0
 .../boost/mpl/iter_fold.hpp                   |     0
 .../boost/mpl/iter_fold_if.hpp                |     0
 .../boost/mpl/iterator_category.hpp           |     0
 .../boost/mpl/iterator_range.hpp              |     0
 .../boost/mpl/iterator_tags.hpp               |     0
 .../boost/mpl/joint_view.hpp                  |     0
 .../boost/mpl/key_type.hpp                    |     0
 .../boost/mpl/key_type_fwd.hpp                |     0
 .../boost/mpl/lambda.hpp                      |     0
 .../boost/mpl/lambda_fwd.hpp                  |     0
 .../boost/mpl/less.hpp                        |     0
 .../boost/mpl/less_equal.hpp                  |     0
 .../boost/mpl/limits/arity.hpp                |     0
 .../boost/mpl/limits/list.hpp                 |     0
 .../boost/mpl/limits/map.hpp                  |     0
 .../boost/mpl/limits/set.hpp                  |     0
 .../boost/mpl/limits/string.hpp               |     0
 .../boost/mpl/limits/unrolling.hpp            |     0
 .../boost/mpl/limits/vector.hpp               |     0
 .../boost/mpl/list.hpp                        |     0
 .../boost/mpl/list/aux_/O1_size.hpp           |     0
 .../boost/mpl/list/aux_/begin_end.hpp         |     0
 .../boost/mpl/list/aux_/clear.hpp             |     0
 .../boost/mpl/list/aux_/empty.hpp             |     0
 .../boost/mpl/list/aux_/front.hpp             |     0
 .../mpl/list/aux_/include_preprocessed.hpp    |     0
 .../boost/mpl/list/aux_/item.hpp              |     0
 .../boost/mpl/list/aux_/iterator.hpp          |     0
 .../boost/mpl/list/aux_/numbered.hpp          |     0
 .../boost/mpl/list/aux_/numbered_c.hpp        |     0
 .../boost/mpl/list/aux_/pop_front.hpp         |     0
 .../list/aux_/preprocessed/plain/list10.hpp   |     0
 .../list/aux_/preprocessed/plain/list10_c.hpp |     0
 .../list/aux_/preprocessed/plain/list20.hpp   |     0
 .../list/aux_/preprocessed/plain/list20_c.hpp |     0
 .../list/aux_/preprocessed/plain/list30.hpp   |     0
 .../list/aux_/preprocessed/plain/list30_c.hpp |     0
 .../list/aux_/preprocessed/plain/list40.hpp   |     0
 .../list/aux_/preprocessed/plain/list40_c.hpp |     0
 .../list/aux_/preprocessed/plain/list50.hpp   |     0
 .../list/aux_/preprocessed/plain/list50_c.hpp |     0
 .../boost/mpl/list/aux_/push_back.hpp         |     0
 .../boost/mpl/list/aux_/push_front.hpp        |     0
 .../boost/mpl/list/aux_/size.hpp              |     0
 .../boost/mpl/list/aux_/tag.hpp               |     0
 .../boost/mpl/list/list0.hpp                  |     0
 .../boost/mpl/list/list0_c.hpp                |     0
 .../boost/mpl/list/list10.hpp                 |     0
 .../boost/mpl/list/list10_c.hpp               |     0
 .../boost/mpl/list/list20.hpp                 |     0
 .../boost/mpl/list/list20_c.hpp               |     0
 .../boost/mpl/list/list30.hpp                 |     0
 .../boost/mpl/list/list30_c.hpp               |     0
 .../boost/mpl/list/list40.hpp                 |     0
 .../boost/mpl/list/list40_c.hpp               |     0
 .../boost/mpl/list/list50.hpp                 |     0
 .../boost/mpl/list/list50_c.hpp               |     0
 .../boost/mpl/list_c.hpp                      |     0
 .../boost/mpl/logical.hpp                     |     0
 .../boost/mpl/long.hpp                        |     0
 .../boost/mpl/long_fwd.hpp                    |     0
 .../boost/mpl/lower_bound.hpp                 |     0
 .../boost/mpl/map.hpp                         |     0
 .../boost/mpl/map/aux_/at_impl.hpp            |     0
 .../boost/mpl/map/aux_/begin_end_impl.hpp     |     0
 .../boost/mpl/map/aux_/clear_impl.hpp         |     0
 .../boost/mpl/map/aux_/contains_impl.hpp      |     0
 .../boost/mpl/map/aux_/empty_impl.hpp         |     0
 .../boost/mpl/map/aux_/erase_impl.hpp         |     0
 .../boost/mpl/map/aux_/erase_key_impl.hpp     |     0
 .../boost/mpl/map/aux_/has_key_impl.hpp       |     0
 .../mpl/map/aux_/include_preprocessed.hpp     |     0
 .../boost/mpl/map/aux_/insert_impl.hpp        |     0
 .../boost/mpl/map/aux_/insert_range_impl.hpp  |     0
 .../boost/mpl/map/aux_/item.hpp               |     0
 .../boost/mpl/map/aux_/iterator.hpp           |     0
 .../boost/mpl/map/aux_/key_type_impl.hpp      |     0
 .../boost/mpl/map/aux_/map0.hpp               |     0
 .../boost/mpl/map/aux_/numbered.hpp           |     0
 .../map/aux_/preprocessed/no_ctps/map10.hpp   |     0
 .../map/aux_/preprocessed/no_ctps/map20.hpp   |     0
 .../map/aux_/preprocessed/no_ctps/map30.hpp   |     0
 .../map/aux_/preprocessed/no_ctps/map40.hpp   |     0
 .../map/aux_/preprocessed/no_ctps/map50.hpp   |     0
 .../mpl/map/aux_/preprocessed/plain/map10.hpp |     0
 .../mpl/map/aux_/preprocessed/plain/map20.hpp |     0
 .../mpl/map/aux_/preprocessed/plain/map30.hpp |     0
 .../mpl/map/aux_/preprocessed/plain/map40.hpp |     0
 .../mpl/map/aux_/preprocessed/plain/map50.hpp |     0
 .../aux_/preprocessed/typeof_based/map10.hpp  |     0
 .../aux_/preprocessed/typeof_based/map20.hpp  |     0
 .../aux_/preprocessed/typeof_based/map30.hpp  |     0
 .../aux_/preprocessed/typeof_based/map40.hpp  |     0
 .../aux_/preprocessed/typeof_based/map50.hpp  |     0
 .../boost/mpl/map/aux_/size_impl.hpp          |     0
 .../boost/mpl/map/aux_/tag.hpp                |     0
 .../boost/mpl/map/aux_/value_type_impl.hpp    |     0
 .../boost/mpl/map/map0.hpp                    |     0
 .../boost/mpl/map/map10.hpp                   |     0
 .../boost/mpl/map/map20.hpp                   |     0
 .../boost/mpl/map/map30.hpp                   |     0
 .../boost/mpl/map/map40.hpp                   |     0
 .../boost/mpl/map/map50.hpp                   |     0
 .../boost/mpl/math/fixed_c.hpp                |     0
 .../boost/mpl/math/is_even.hpp                |     0
 .../boost/mpl/math/rational_c.hpp             |     0
 .../boost/mpl/max.hpp                         |     0
 .../boost/mpl/max_element.hpp                 |     0
 .../boost/mpl/min.hpp                         |     0
 .../boost/mpl/min_element.hpp                 |     0
 .../boost/mpl/min_max.hpp                     |     0
 .../boost/mpl/minus.hpp                       |     0
 .../boost/mpl/modulus.hpp                     |     0
 .../boost/mpl/multiplies.hpp                  |     0
 .../boost/mpl/multiset/aux_/count_impl.hpp    |     0
 .../boost/mpl/multiset/aux_/insert_impl.hpp   |     0
 .../boost/mpl/multiset/aux_/item.hpp          |     0
 .../boost/mpl/multiset/aux_/multiset0.hpp     |     0
 .../boost/mpl/multiset/aux_/tag.hpp           |     0
 .../boost/mpl/multiset/multiset0.hpp          |     0
 .../boost/mpl/negate.hpp                      |     0
 .../boost/mpl/next.hpp                        |     0
 .../boost/mpl/next_prior.hpp                  |     0
 .../boost/mpl/not.hpp                         |     0
 .../boost/mpl/not_equal_to.hpp                |     0
 .../boost/mpl/numeric_cast.hpp                |     0
 .../boost/mpl/or.hpp                          |     0
 .../boost/mpl/order.hpp                       |     0
 .../boost/mpl/order_fwd.hpp                   |     0
 .../boost/mpl/pair.hpp                        |     0
 .../boost/mpl/pair_view.hpp                   |     0
 .../boost/mpl/partition.hpp                   |     0
 .../boost/mpl/placeholders.hpp                |     0
 .../boost/mpl/plus.hpp                        |     0
 .../boost/mpl/pop_back.hpp                    |     0
 .../boost/mpl/pop_back_fwd.hpp                |     0
 .../boost/mpl/pop_front.hpp                   |     0
 .../boost/mpl/pop_front_fwd.hpp               |     0
 .../boost/mpl/print.hpp                       |     0
 .../boost/mpl/prior.hpp                       |     0
 .../boost/mpl/protect.hpp                     |     0
 .../boost/mpl/push_back.hpp                   |     0
 .../boost/mpl/push_back_fwd.hpp               |     0
 .../boost/mpl/push_front.hpp                  |     0
 .../boost/mpl/push_front_fwd.hpp              |     0
 .../boost/mpl/quote.hpp                       |     0
 .../boost/mpl/range_c.hpp                     |     0
 .../boost/mpl/remove.hpp                      |     0
 .../boost/mpl/remove_if.hpp                   |     0
 .../boost/mpl/replace.hpp                     |     0
 .../boost/mpl/replace_if.hpp                  |     0
 .../boost/mpl/reverse.hpp                     |     0
 .../boost/mpl/reverse_fold.hpp                |     0
 .../boost/mpl/reverse_iter_fold.hpp           |     0
 .../boost/mpl/same_as.hpp                     |     0
 .../boost/mpl/sequence_tag.hpp                |     0
 .../boost/mpl/sequence_tag_fwd.hpp            |     0
 .../boost/mpl/set.hpp                         |     0
 .../boost/mpl/set/aux_/at_impl.hpp            |     0
 .../boost/mpl/set/aux_/begin_end_impl.hpp     |     0
 .../boost/mpl/set/aux_/clear_impl.hpp         |     0
 .../boost/mpl/set/aux_/empty_impl.hpp         |     0
 .../boost/mpl/set/aux_/erase_impl.hpp         |     0
 .../boost/mpl/set/aux_/erase_key_impl.hpp     |     0
 .../boost/mpl/set/aux_/has_key_impl.hpp       |     0
 .../mpl/set/aux_/include_preprocessed.hpp     |     0
 .../boost/mpl/set/aux_/insert_impl.hpp        |     0
 .../boost/mpl/set/aux_/insert_range_impl.hpp  |     0
 .../boost/mpl/set/aux_/item.hpp               |     0
 .../boost/mpl/set/aux_/iterator.hpp           |     0
 .../boost/mpl/set/aux_/key_type_impl.hpp      |     0
 .../boost/mpl/set/aux_/numbered.hpp           |     0
 .../boost/mpl/set/aux_/numbered_c.hpp         |     0
 .../mpl/set/aux_/preprocessed/plain/set10.hpp |     0
 .../set/aux_/preprocessed/plain/set10_c.hpp   |     0
 .../mpl/set/aux_/preprocessed/plain/set20.hpp |     0
 .../set/aux_/preprocessed/plain/set20_c.hpp   |     0
 .../mpl/set/aux_/preprocessed/plain/set30.hpp |     0
 .../set/aux_/preprocessed/plain/set30_c.hpp   |     0
 .../mpl/set/aux_/preprocessed/plain/set40.hpp |     0
 .../set/aux_/preprocessed/plain/set40_c.hpp   |     0
 .../mpl/set/aux_/preprocessed/plain/set50.hpp |     0
 .../set/aux_/preprocessed/plain/set50_c.hpp   |     0
 .../boost/mpl/set/aux_/set0.hpp               |     0
 .../boost/mpl/set/aux_/size_impl.hpp          |     0
 .../boost/mpl/set/aux_/tag.hpp                |     0
 .../boost/mpl/set/aux_/value_type_impl.hpp    |     0
 .../boost/mpl/set/set0.hpp                    |     0
 .../boost/mpl/set/set0_c.hpp                  |     0
 .../boost/mpl/set/set10.hpp                   |     0
 .../boost/mpl/set/set10_c.hpp                 |     0
 .../boost/mpl/set/set20.hpp                   |     0
 .../boost/mpl/set/set20_c.hpp                 |     0
 .../boost/mpl/set/set30.hpp                   |     0
 .../boost/mpl/set/set30_c.hpp                 |     0
 .../boost/mpl/set/set40.hpp                   |     0
 .../boost/mpl/set/set40_c.hpp                 |     0
 .../boost/mpl/set/set50.hpp                   |     0
 .../boost/mpl/set/set50_c.hpp                 |     0
 .../boost/mpl/set_c.hpp                       |     0
 .../boost/mpl/shift_left.hpp                  |     0
 .../boost/mpl/shift_right.hpp                 |     0
 .../boost/mpl/single_view.hpp                 |     0
 .../boost/mpl/size.hpp                        |     0
 .../boost/mpl/size_fwd.hpp                    |     0
 .../boost/mpl/size_t.hpp                      |     0
 .../boost/mpl/size_t_fwd.hpp                  |     0
 .../boost/mpl/sizeof.hpp                      |     0
 .../boost/mpl/sort.hpp                        |     0
 .../boost/mpl/stable_partition.hpp            |     0
 .../boost/mpl/string.hpp                      |     0
 .../boost/mpl/switch.hpp                      |     0
 .../boost/mpl/tag.hpp                         |     0
 .../boost/mpl/times.hpp                       |     0
 .../boost/mpl/transform.hpp                   |     0
 .../boost/mpl/transform_view.hpp              |     0
 .../boost/mpl/unique.hpp                      |     0
 .../boost/mpl/unpack_args.hpp                 |     0
 .../boost/mpl/upper_bound.hpp                 |     0
 .../boost/mpl/value_type.hpp                  |     0
 .../boost/mpl/value_type_fwd.hpp              |     0
 .../boost/mpl/vector.hpp                      |     0
 .../boost/mpl/vector/aux_/O1_size.hpp         |     0
 .../boost/mpl/vector/aux_/at.hpp              |     0
 .../boost/mpl/vector/aux_/back.hpp            |     0
 .../boost/mpl/vector/aux_/begin_end.hpp       |     0
 .../boost/mpl/vector/aux_/clear.hpp           |     0
 .../boost/mpl/vector/aux_/empty.hpp           |     0
 .../boost/mpl/vector/aux_/front.hpp           |     0
 .../mpl/vector/aux_/include_preprocessed.hpp  |     0
 .../boost/mpl/vector/aux_/item.hpp            |     0
 .../boost/mpl/vector/aux_/iterator.hpp        |     0
 .../boost/mpl/vector/aux_/numbered.hpp        |     0
 .../boost/mpl/vector/aux_/numbered_c.hpp      |     0
 .../boost/mpl/vector/aux_/pop_back.hpp        |     0
 .../boost/mpl/vector/aux_/pop_front.hpp       |     0
 .../aux_/preprocessed/no_ctps/vector10.hpp    |     0
 .../aux_/preprocessed/no_ctps/vector10_c.hpp  |     0
 .../aux_/preprocessed/no_ctps/vector20.hpp    |     0
 .../aux_/preprocessed/no_ctps/vector20_c.hpp  |     0
 .../aux_/preprocessed/no_ctps/vector30.hpp    |     0
 .../aux_/preprocessed/no_ctps/vector30_c.hpp  |     0
 .../aux_/preprocessed/no_ctps/vector40.hpp    |     0
 .../aux_/preprocessed/no_ctps/vector40_c.hpp  |     0
 .../aux_/preprocessed/no_ctps/vector50.hpp    |     0
 .../aux_/preprocessed/no_ctps/vector50_c.hpp  |     0
 .../aux_/preprocessed/plain/vector10.hpp      |     0
 .../aux_/preprocessed/plain/vector10_c.hpp    |     0
 .../aux_/preprocessed/plain/vector20.hpp      |     0
 .../aux_/preprocessed/plain/vector20_c.hpp    |     0
 .../aux_/preprocessed/plain/vector30.hpp      |     0
 .../aux_/preprocessed/plain/vector30_c.hpp    |     0
 .../aux_/preprocessed/plain/vector40.hpp      |     0
 .../aux_/preprocessed/plain/vector40_c.hpp    |     0
 .../aux_/preprocessed/plain/vector50.hpp      |     0
 .../aux_/preprocessed/plain/vector50_c.hpp    |     0
 .../preprocessed/typeof_based/vector10.hpp    |     0
 .../preprocessed/typeof_based/vector10_c.hpp  |     0
 .../preprocessed/typeof_based/vector20.hpp    |     0
 .../preprocessed/typeof_based/vector20_c.hpp  |     0
 .../preprocessed/typeof_based/vector30.hpp    |     0
 .../preprocessed/typeof_based/vector30_c.hpp  |     0
 .../preprocessed/typeof_based/vector40.hpp    |     0
 .../preprocessed/typeof_based/vector40_c.hpp  |     0
 .../preprocessed/typeof_based/vector50.hpp    |     0
 .../preprocessed/typeof_based/vector50_c.hpp  |     0
 .../boost/mpl/vector/aux_/push_back.hpp       |     0
 .../boost/mpl/vector/aux_/push_front.hpp      |     0
 .../boost/mpl/vector/aux_/size.hpp            |     0
 .../boost/mpl/vector/aux_/tag.hpp             |     0
 .../boost/mpl/vector/aux_/vector0.hpp         |     0
 .../boost/mpl/vector/vector0.hpp              |     0
 .../boost/mpl/vector/vector0_c.hpp            |     0
 .../boost/mpl/vector/vector10.hpp             |     0
 .../boost/mpl/vector/vector10_c.hpp           |     0
 .../boost/mpl/vector/vector20.hpp             |     0
 .../boost/mpl/vector/vector20_c.hpp           |     0
 .../boost/mpl/vector/vector30.hpp             |     0
 .../boost/mpl/vector/vector30_c.hpp           |     0
 .../boost/mpl/vector/vector40.hpp             |     0
 .../boost/mpl/vector/vector40_c.hpp           |     0
 .../boost/mpl/vector/vector50.hpp             |     0
 .../boost/mpl/vector/vector50_c.hpp           |     0
 .../boost/mpl/vector_c.hpp                    |     0
 .../boost/mpl/void.hpp                        |     0
 .../boost/mpl/void_fwd.hpp                    |     0
 .../boost/mpl/zip_view.hpp                    |     0
 .../boost_1_65_0/boost/next_prior.hpp         |   180 +
 .../boost/noncopyable.hpp                     |     0
 .../boost/none.hpp                            |     0
 .../boost/none_t.hpp                          |     0
 .../boost/numeric/conversion/bounds.hpp       |     0
 .../boost/numeric/conversion/cast.hpp         |     0
 .../numeric/conversion/conversion_traits.hpp  |     0
 .../boost/numeric/conversion/converter.hpp    |     0
 .../numeric/conversion/converter_policies.hpp |     0
 .../numeric/conversion/detail/bounds.hpp      |     0
 .../conversion/detail/conversion_traits.hpp   |     0
 .../numeric/conversion/detail/converter.hpp   |     0
 .../conversion/detail/int_float_mixture.hpp   |     0
 .../conversion/detail/is_subranged.hpp        |     0
 .../boost/numeric/conversion/detail/meta.hpp  |     0
 .../conversion/detail/numeric_cast_traits.hpp |     0
 .../conversion/detail/old_numeric_cast.hpp    |     0
 .../numeric_cast_traits_common.hpp            |     0
 .../numeric_cast_traits_long_long.hpp         |     0
 .../conversion/detail/sign_mixture.hpp        |     0
 .../conversion/detail/udt_builtin_mixture.hpp |     0
 .../numeric/conversion/int_float_mixture.hpp  |     0
 .../conversion/int_float_mixture_enum.hpp     |     0
 .../boost/numeric/conversion/is_subranged.hpp |     0
 .../conversion/numeric_cast_traits.hpp        |     0
 .../boost/numeric/conversion/sign_mixture.hpp |     0
 .../numeric/conversion/sign_mixture_enum.hpp  |     0
 .../conversion/udt_builtin_mixture.hpp        |     0
 .../conversion/udt_builtin_mixture_enum.hpp   |     0
 .../boost/numeric/interval.hpp                |     2 +-
 .../boost/numeric/interval/arith.hpp          |     2 +-
 .../boost/numeric/interval/arith2.hpp         |     2 +-
 .../boost/numeric/interval/arith3.hpp         |     0
 .../boost/numeric/interval/checking.hpp       |     2 +-
 .../boost/numeric/interval/compare.hpp        |     2 +-
 .../numeric/interval/compare/certain.hpp      |     0
 .../numeric/interval/compare/explicit.hpp     |     2 +-
 .../interval/compare/lexicographic.hpp        |     0
 .../numeric/interval/compare/possible.hpp     |     0
 .../boost/numeric/interval/compare/set.hpp    |     0
 .../numeric/interval/compare/tribool.hpp      |     0
 .../boost/numeric/interval/constants.hpp      |     2 +-
 .../detail/alpha_rounding_control.hpp         |     2 +-
 .../interval/detail/bcc_rounding_control.hpp  |     2 +-
 .../boost/numeric/interval/detail/bugs.hpp    |     2 +-
 .../interval/detail/c99_rounding_control.hpp  |     2 +-
 .../detail/c99sub_rounding_control.hpp        |     2 +-
 .../numeric/interval/detail/division.hpp      |     0
 .../interval/detail/ia64_rounding_control.hpp |     0
 .../interval/detail/interval_prototype.hpp    |     2 +-
 .../interval/detail/msvc_rounding_control.hpp |     4 +-
 .../interval/detail/ppc_rounding_control.hpp  |     2 +-
 .../detail/sparc_rounding_control.hpp         |     2 +-
 .../numeric/interval/detail/test_input.hpp    |     2 +-
 .../interval/detail/x86_rounding_control.hpp  |     2 +-
 .../detail/x86gcc_rounding_control.hpp        |     2 +-
 .../boost/numeric/interval/ext/integer.hpp    |     0
 .../ext/x86_fast_rounding_control.hpp         |     2 +-
 .../boost/numeric/interval/hw_rounding.hpp    |     4 +-
 .../boost/numeric/interval/interval.hpp       |     2 +-
 .../boost/numeric/interval/io.hpp             |     0
 .../boost/numeric/interval/limits.hpp         |     2 +-
 .../boost/numeric/interval/policies.hpp       |     0
 .../boost/numeric/interval/rounded_arith.hpp  |     2 +-
 .../boost/numeric/interval/rounded_transc.hpp |     2 +-
 .../boost/numeric/interval/rounding.hpp       |     2 +-
 .../boost/numeric/interval/transc.hpp         |     2 +-
 .../boost/numeric/interval/utility.hpp        |     3 +-
 .../boost/numeric/odeint.hpp                  |     0
 .../odeint/algebra/algebra_dispatcher.hpp     |     0
 .../numeric/odeint/algebra/array_algebra.hpp  |     0
 .../odeint/algebra/default_operations.hpp     |     0
 .../algebra/detail/extract_value_type.hpp     |     0
 .../odeint/algebra/detail/for_each.hpp        |     0
 .../numeric/odeint/algebra/detail/macros.hpp  |     0
 .../odeint/algebra/detail/norm_inf.hpp        |     0
 .../numeric/odeint/algebra/fusion_algebra.hpp |     0
 .../algebra/fusion_algebra_dispatcher.hpp     |     0
 .../odeint/algebra/multi_array_algebra.hpp    |     0
 .../odeint/algebra/norm_result_type.hpp       |     0
 .../odeint/algebra/operations_dispatcher.hpp  |     0
 .../numeric/odeint/algebra/range_algebra.hpp  |     0
 .../odeint/algebra/vector_space_algebra.hpp   |     0
 .../boost/numeric/odeint/config.hpp           |     0
 .../blaze/blaze_algebra_dispatcher.hpp        |     0
 .../odeint/external/blaze/blaze_resize.hpp    |     0
 .../odeint/external/compute/compute.hpp       |     0
 .../external/compute/compute_algebra.hpp      |     0
 .../compute/compute_algebra_dispatcher.hpp    |     0
 .../external/compute/compute_operations.hpp   |     0
 .../compute/compute_operations_dispatcher.hpp |     0
 .../external/compute/compute_resize.hpp       |     0
 .../numeric/odeint/external/eigen/eigen.hpp   |     0
 .../odeint/external/eigen/eigen_algebra.hpp   |     0
 .../eigen/eigen_algebra_dispatcher.hpp        |     0
 .../odeint/external/eigen/eigen_resize.hpp    |     0
 .../odeint/external/gsl/gsl_wrapper.hpp       |     0
 .../odeint/external/mkl/mkl_operations.hpp    |     0
 .../boost/numeric/odeint/external/mpi/mpi.hpp |     0
 .../external/mpi/mpi_nested_algebra.hpp       |     0
 .../numeric/odeint/external/mpi/mpi_state.hpp |     0
 .../odeint/external/mpi/mpi_vector_state.hpp  |     0
 .../external/mtl4/implicit_euler_mtl4.hpp     |     0
 .../numeric/odeint/external/mtl4/mtl4.hpp     |     0
 .../external/mtl4/mtl4_algebra_dispatcher.hpp |     0
 .../odeint/external/mtl4/mtl4_resize.hpp      |     0
 .../external/nt2/nt2_algebra_dispatcher.hpp   |     0
 .../numeric/odeint/external/nt2/nt2_copy.hpp  |     0
 .../odeint/external/nt2/nt2_norm_inf.hpp      |     0
 .../odeint/external/nt2/nt2_resize.hpp        |     0
 .../numeric/odeint/external/openmp/openmp.hpp |     0
 .../external/openmp/openmp_nested_algebra.hpp |     0
 .../external/openmp/openmp_range_algebra.hpp  |     0
 .../odeint/external/openmp/openmp_state.hpp   |     0
 .../numeric/odeint/external/thrust/thrust.hpp |     0
 .../odeint/external/thrust/thrust_algebra.hpp |     0
 .../thrust/thrust_algebra_dispatcher.hpp      |     0
 .../external/thrust/thrust_operations.hpp     |     0
 .../thrust/thrust_operations_dispatcher.hpp   |     0
 .../odeint/external/thrust/thrust_resize.hpp  |     0
 .../numeric/odeint/external/vexcl/vexcl.hpp   |     0
 .../odeint/external/vexcl/vexcl_abs.hpp       |     0
 .../vexcl/vexcl_algebra_dispatcher.hpp        |     0
 .../odeint/external/vexcl/vexcl_copy.hpp      |     0
 .../odeint/external/vexcl/vexcl_norm_inf.hpp  |     0
 .../odeint/external/vexcl/vexcl_resize.hpp    |     0
 .../external/vexcl/vexcl_same_instance.hpp    |     0
 .../external/viennacl/viennacl_operations.hpp |     0
 .../external/viennacl/viennacl_resize.hpp     |     0
 .../odeint/integrate/check_adapter.hpp        |     0
 .../odeint/integrate/detail/functors.hpp      |     0
 .../integrate/detail/integrate_adaptive.hpp   |     0
 .../integrate/detail/integrate_const.hpp      |     0
 .../integrate/detail/integrate_n_steps.hpp    |     0
 .../integrate/detail/integrate_times.hpp      |     0
 .../numeric/odeint/integrate/integrate.hpp    |     0
 .../odeint/integrate/integrate_adaptive.hpp   |     0
 .../odeint/integrate/integrate_const.hpp      |     0
 .../odeint/integrate/integrate_n_steps.hpp    |     1 +
 .../odeint/integrate/integrate_times.hpp      |     0
 .../odeint/integrate/max_step_checker.hpp     |     6 +-
 .../odeint/integrate/null_observer.hpp        |     0
 .../odeint/integrate/observer_collection.hpp  |     0
 .../odeint/iterator/adaptive_iterator.hpp     |     0
 .../iterator/adaptive_time_iterator.hpp       |     0
 .../odeint/iterator/const_step_iterator.hpp   |     0
 .../iterator/const_step_time_iterator.hpp     |     0
 .../iterator/detail/ode_iterator_base.hpp     |     0
 .../iterator/impl/adaptive_iterator_impl.hpp  |     0
 .../impl/const_step_iterator_impl.hpp         |     0
 .../iterator/impl/n_step_iterator_impl.hpp    |     0
 .../iterator/impl/times_iterator_impl.hpp     |     0
 .../iterator/integrate/detail/functors.hpp    |     0
 .../integrate/detail/integrate_adaptive.hpp   |     0
 .../integrate/detail/integrate_const.hpp      |     0
 .../integrate/detail/integrate_n_steps.hpp    |     0
 .../integrate/detail/integrate_times.hpp      |     0
 .../odeint/iterator/integrate/integrate.hpp   |     0
 .../iterator/integrate/integrate_adaptive.hpp |     0
 .../iterator/integrate/integrate_const.hpp    |     0
 .../iterator/integrate/integrate_n_steps.hpp  |     0
 .../iterator/integrate/integrate_times.hpp    |     0
 .../iterator/integrate/null_observer.hpp      |     0
 .../integrate/observer_collection.hpp         |     0
 .../odeint/iterator/n_step_iterator.hpp       |     0
 .../odeint/iterator/n_step_time_iterator.hpp  |     0
 .../odeint/iterator/times_iterator.hpp        |     0
 .../odeint/iterator/times_time_iterator.hpp   |     0
 .../odeint/stepper/adams_bashforth.hpp        |     0
 .../stepper/adams_bashforth_moulton.hpp       |    13 +-
 .../numeric/odeint/stepper/adams_moulton.hpp  |     0
 .../stepper/base/algebra_stepper_base.hpp     |     0
 .../base/explicit_error_stepper_base.hpp      |     0
 .../base/explicit_error_stepper_fsal_base.hpp |     0
 .../stepper/base/explicit_stepper_base.hpp    |     0
 .../base/symplectic_rkn_stepper_base.hpp      |     0
 .../numeric/odeint/stepper/bulirsch_stoer.hpp |    23 +-
 .../stepper/bulirsch_stoer_dense_out.hpp      |    10 +-
 .../odeint/stepper/controlled_runge_kutta.hpp |     2 +-
 .../odeint/stepper/controlled_step_result.hpp |     0
 .../stepper/dense_output_runge_kutta.hpp      |     0
 .../detail/adams_bashforth_call_algebra.hpp   |     0
 .../detail/adams_bashforth_coefficients.hpp   |     0
 .../detail/adams_moulton_call_algebra.hpp     |     0
 .../detail/adams_moulton_coefficients.hpp     |     0
 .../stepper/detail/generic_rk_algorithm.hpp   |     0
 .../detail/generic_rk_call_algebra.hpp        |     0
 .../stepper/detail/generic_rk_operations.hpp  |     0
 .../odeint/stepper/detail/rotating_buffer.hpp |     0
 .../boost/numeric/odeint/stepper/euler.hpp    |     0
 .../stepper/explicit_error_generic_rk.hpp     |     0
 .../odeint/stepper/explicit_generic_rk.hpp    |     0
 .../odeint/stepper/extrapolation_stepper.hpp  |     0
 .../numeric/odeint/stepper/generation.hpp     |     0
 .../generation_controlled_runge_kutta.hpp     |     0
 .../generation_dense_output_runge_kutta.hpp   |     0
 .../generation/generation_rosenbrock4.hpp     |     0
 .../generation_runge_kutta_cash_karp54.hpp    |     0
 ...ration_runge_kutta_cash_karp54_classic.hpp |     0
 .../generation_runge_kutta_dopri5.hpp         |     0
 .../generation_runge_kutta_fehlberg78.hpp     |     0
 .../stepper/generation/make_controlled.hpp    |     0
 .../stepper/generation/make_dense_output.hpp  |     0
 .../numeric/odeint/stepper/implicit_euler.hpp |     0
 .../odeint/stepper/modified_midpoint.hpp      |     0
 .../numeric/odeint/stepper/rosenbrock4.hpp    |     0
 .../odeint/stepper/rosenbrock4_controller.hpp |     2 +
 .../stepper/rosenbrock4_dense_output.hpp      |     0
 .../numeric/odeint/stepper/runge_kutta4.hpp   |     0
 .../odeint/stepper/runge_kutta4_classic.hpp   |     0
 .../stepper/runge_kutta_cash_karp54.hpp       |     0
 .../runge_kutta_cash_karp54_classic.hpp       |     0
 .../odeint/stepper/runge_kutta_dopri5.hpp     |     0
 .../odeint/stepper/runge_kutta_fehlberg78.hpp |     0
 .../odeint/stepper/stepper_categories.hpp     |     0
 .../odeint/stepper/symplectic_euler.hpp       |     0
 .../symplectic_rkn_sb3a_m4_mclachlan.hpp      |     0
 .../stepper/symplectic_rkn_sb3a_mclachlan.hpp |     0
 .../odeint/stepper/velocity_verlet.hpp        |     0
 .../boost/numeric/odeint/util/bind.hpp        |     0
 .../boost/numeric/odeint/util/copy.hpp        |     0
 .../numeric/odeint/util/detail/is_range.hpp   |     0
 .../odeint/util/detail/less_with_sign.hpp     |     0
 .../boost/numeric/odeint/util/is_pair.hpp     |     0
 .../numeric/odeint/util/is_resizeable.hpp     |     0
 .../odeint/util/multi_array_adaption.hpp      |     0
 .../numeric/odeint/util/n_ary_helper.hpp      |     0
 .../numeric/odeint/util/odeint_error.hpp      |     0
 .../boost/numeric/odeint/util/resize.hpp      |     0
 .../boost/numeric/odeint/util/resizer.hpp     |     0
 .../numeric/odeint/util/same_instance.hpp     |     0
 .../boost/numeric/odeint/util/same_size.hpp   |     0
 .../boost/numeric/odeint/util/split.hpp       |     0
 .../numeric/odeint/util/split_adaptor.hpp     |     0
 .../numeric/odeint/util/state_wrapper.hpp     |     0
 .../numeric/odeint/util/stepper_traits.hpp    |     0
 .../odeint/util/ublas_matrix_expression.patch |     0
 .../numeric/odeint/util/ublas_wrapper.hpp     |     0
 .../boost/numeric/odeint/util/unit_helper.hpp |     0
 .../numeric/odeint/util/unwrap_reference.hpp  |     0
 .../boost/numeric/odeint/version.hpp          |     0
 .../boost/numeric/ublas/assignment.hpp        |     0
 .../boost/numeric/ublas/banded.hpp            |     0
 .../boost/numeric/ublas/blas.hpp              |     0
 .../boost/numeric/ublas/detail/concepts.hpp   |     0
 .../boost/numeric/ublas/detail/config.hpp     |     0
 .../numeric/ublas/detail/definitions.hpp      |     0
 .../numeric/ublas/detail/documentation.hpp    |     0
 .../boost/numeric/ublas/detail/duff.hpp       |     0
 .../boost/numeric/ublas/detail/iterator.hpp   |     0
 .../numeric/ublas/detail/matrix_assign.hpp    |     0
 .../boost/numeric/ublas/detail/raw.hpp        |     0
 .../ublas/detail/returntype_deduction.hpp     |     0
 .../boost/numeric/ublas/detail/temporary.hpp  |     0
 .../numeric/ublas/detail/vector_assign.hpp    |     0
 .../boost/numeric/ublas/doxydoc.hpp           |     0
 .../boost/numeric/ublas/exception.hpp         |     0
 .../ublas/experimental/sparse_view.hpp        |     0
 .../boost/numeric/ublas/expression_types.hpp  |     0
 .../boost/numeric/ublas/functional.hpp        |     0
 .../boost/numeric/ublas/fwd.hpp               |     0
 .../boost/numeric/ublas/hermitian.hpp         |     0
 .../boost/numeric/ublas/io.hpp                |     0
 .../boost/numeric/ublas/lu.hpp                |     0
 .../boost/numeric/ublas/matrix.hpp            |     0
 .../boost/numeric/ublas/matrix_expression.hpp |     0
 .../boost/numeric/ublas/matrix_proxy.hpp      |     0
 .../boost/numeric/ublas/matrix_sparse.hpp     |     0
 .../boost/numeric/ublas/matrix_vector.hpp     |     0
 .../boost/numeric/ublas/operation.hpp         |     0
 .../boost/numeric/ublas/operation/begin.hpp   |     0
 .../boost/numeric/ublas/operation/c_array.hpp |     0
 .../boost/numeric/ublas/operation/end.hpp     |     0
 .../numeric/ublas/operation/num_columns.hpp   |     0
 .../numeric/ublas/operation/num_rows.hpp      |     0
 .../boost/numeric/ublas/operation/size.hpp    |     0
 .../boost/numeric/ublas/operation_blocked.hpp |     0
 .../boost/numeric/ublas/operation_sparse.hpp  |     0
 .../boost/numeric/ublas/operations.hpp        |     0
 .../boost/numeric/ublas/storage.hpp           |     0
 .../boost/numeric/ublas/storage_sparse.hpp    |     0
 .../boost/numeric/ublas/symmetric.hpp         |     0
 .../boost/numeric/ublas/tags.hpp              |     0
 .../boost/numeric/ublas/traits.hpp            |     0
 .../boost/numeric/ublas/traits/c_array.hpp    |     0
 .../ublas/traits/const_iterator_type.hpp      |     0
 .../numeric/ublas/traits/iterator_type.hpp    |     0
 .../boost/numeric/ublas/triangular.hpp        |     0
 .../boost/numeric/ublas/vector.hpp            |     0
 .../boost/numeric/ublas/vector_expression.hpp |     0
 .../boost/numeric/ublas/vector_of_vector.hpp  |     0
 .../boost/numeric/ublas/vector_proxy.hpp      |     0
 .../boost/numeric/ublas/vector_sparse.hpp     |     0
 .../boost/operators.hpp                       |     0
 .../boost_1_65_0/boost/operators_v1.hpp       |   951 +
 .../boost/optional/bad_optional_access.hpp    |     0
 .../detail/old_optional_implementation.hpp    |     0
 .../detail/optional_aligned_storage.hpp       |     0
 .../boost/optional/detail/optional_config.hpp |    17 +
 .../detail/optional_factory_support.hpp       |     0
 .../detail/optional_reference_spec.hpp        |    80 +-
 .../boost/optional/detail/optional_relops.hpp |     0
 .../boost/optional/detail/optional_swap.hpp   |     0
 .../boost/optional/optional.hpp               |   311 +-
 .../boost/optional/optional_fwd.hpp           |     0
 .../boost/optional/optional_io.hpp            |     0
 .../boost/pending/bucket_sorter.hpp           |     0
 .../boost/pending/container_traits.hpp        |    29 -
 .../boost/pending/detail/disjoint_sets.hpp    |     0
 .../boost/pending/detail/int_iterator.hpp     |     0
 .../boost/pending/detail/property.hpp         |     0
 .../boost/pending/disjoint_sets.hpp           |     0
 .../boost/pending/fenced_priority_queue.hpp   |     0
 .../boost/pending/fibonacci_heap.hpp          |     0
 .../boost/pending/indirect_cmp.hpp            |     0
 .../boost/pending/integer_log2.hpp            |     0
 .../boost/pending/is_heap.hpp                 |     0
 .../boost/pending/iterator_adaptors.hpp       |     0
 .../boost/pending/iterator_tests.hpp          |     0
 .../boost/pending/lowest_bit.hpp              |     0
 .../boost/pending/mutable_heap.hpp            |     0
 .../boost/pending/mutable_queue.hpp           |     0
 .../boost/pending/property.hpp                |     0
 .../boost/pending/property_serialize.hpp      |     0
 .../boost/pending/queue.hpp                   |     0
 .../boost/pending/relaxed_heap.hpp            |     0
 .../boost/pending/stringtok.hpp               |     0
 .../boost/pointee.hpp                         |     0
 .../boost/predef.h                            |     0
 .../boost/predef/architecture.h               |     0
 .../boost/predef/architecture/alpha.h         |     0
 .../boost/predef/architecture/arm.h           |     7 +-
 .../boost/predef/architecture/blackfin.h      |     0
 .../boost/predef/architecture/convex.h        |     0
 .../boost/predef/architecture/ia64.h          |     0
 .../boost/predef/architecture/m68k.h          |     0
 .../boost/predef/architecture/mips.h          |     0
 .../boost/predef/architecture/parisc.h        |     0
 .../boost/predef/architecture/ppc.h           |     0
 .../boost/predef/architecture/pyramid.h       |     0
 .../boost/predef/architecture/rs6k.h          |     0
 .../boost/predef/architecture/sparc.h         |     0
 .../boost/predef/architecture/superh.h        |     0
 .../boost/predef/architecture/sys370.h        |     0
 .../boost/predef/architecture/sys390.h        |     0
 .../boost/predef/architecture/x86.h           |     0
 .../boost/predef/architecture/x86/32.h        |     0
 .../boost/predef/architecture/x86/64.h        |     0
 .../boost/predef/architecture/z.h             |     0
 .../boost/predef/compiler.h                   |     0
 .../boost/predef/compiler/borland.h           |     0
 .../boost/predef/compiler/clang.h             |     0
 .../boost/predef/compiler/comeau.h            |     0
 .../boost/predef/compiler/compaq.h            |     0
 .../boost/predef/compiler/diab.h              |     0
 .../boost/predef/compiler/digitalmars.h       |     0
 .../boost/predef/compiler/dignus.h            |     0
 .../boost/predef/compiler/edg.h               |     0
 .../boost/predef/compiler/ekopath.h           |     0
 .../boost/predef/compiler/gcc.h               |     0
 .../boost/predef/compiler/gcc_xml.h           |     0
 .../boost/predef/compiler/greenhills.h        |     0
 .../boost/predef/compiler/hp_acc.h            |     0
 .../boost/predef/compiler/iar.h               |     0
 .../boost/predef/compiler/ibm.h               |     0
 .../boost/predef/compiler/intel.h             |    20 +-
 .../boost/predef/compiler/kai.h               |     0
 .../boost/predef/compiler/llvm.h              |     0
 .../boost/predef/compiler/metaware.h          |     0
 .../boost/predef/compiler/metrowerks.h        |     0
 .../boost/predef/compiler/microtec.h          |     0
 .../boost/predef/compiler/mpw.h               |     0
 .../boost/predef/compiler/palm.h              |     0
 .../boost/predef/compiler/pgi.h               |     0
 .../boost/predef/compiler/sgi_mipspro.h       |     0
 .../boost/predef/compiler/sunpro.h            |     0
 .../boost/predef/compiler/tendra.h            |     0
 .../boost/predef/compiler/visualc.h           |    16 +-
 .../boost/predef/compiler/watcom.h            |     0
 .../boost/predef/detail/_cassert.h            |     0
 .../boost/predef/detail/_exception.h          |     0
 .../boost/predef/detail/comp_detected.h       |     0
 .../boost/predef/detail/endian_compat.h       |     0
 .../boost/predef/detail/os_detected.h         |     0
 .../boost/predef/detail/platform_detected.h   |     0
 .../boost/predef/detail/test.h                |     0
 .../boost/predef/detail/test_def.h            |     0
 .../boost/predef/hardware.h                   |     0
 .../boost/predef/hardware/simd.h              |     0
 .../boost/predef/hardware/simd/arm.h          |     4 +-
 .../boost/predef/hardware/simd/arm/versions.h |     0
 .../boost/predef/hardware/simd/ppc.h          |     0
 .../boost/predef/hardware/simd/ppc/versions.h |     0
 .../boost/predef/hardware/simd/x86.h          |     0
 .../boost/predef/hardware/simd/x86/versions.h |     0
 .../boost/predef/hardware/simd/x86_amd.h      |     0
 .../predef/hardware/simd/x86_amd/versions.h   |     0
 .../boost/predef/language.h                   |     0
 .../boost/predef/language/objc.h              |     0
 .../boost/predef/language/stdc.h              |     0
 .../boost/predef/language/stdcpp.h            |     0
 .../boost/predef/library.h                    |     0
 .../boost/predef/library/c.h                  |     0
 .../boost/predef/library/c/_prefix.h          |     0
 .../boost/predef/library/c/gnu.h              |     0
 .../boost/predef/library/c/uc.h               |     0
 .../boost/predef/library/c/vms.h              |     0
 .../boost/predef/library/c/zos.h              |     0
 .../boost/predef/library/std.h                |     0
 .../boost/predef/library/std/_prefix.h        |     0
 .../boost/predef/library/std/cxx.h            |     0
 .../boost/predef/library/std/dinkumware.h     |     0
 .../boost/predef/library/std/libcomo.h        |     0
 .../boost/predef/library/std/modena.h         |     0
 .../boost/predef/library/std/msl.h            |     0
 .../boost/predef/library/std/roguewave.h      |     0
 .../boost/predef/library/std/sgi.h            |     0
 .../boost/predef/library/std/stdcpp3.h        |     0
 .../boost/predef/library/std/stlport.h        |     0
 .../boost/predef/library/std/vacpp.h          |     0
 .../boost/predef/make.h                       |     0
 .../boost/predef/os.h                         |     0
 .../boost/predef/os/aix.h                     |     0
 .../boost/predef/os/amigaos.h                 |     0
 .../boost/predef/os/android.h                 |     0
 .../boost/predef/os/beos.h                    |     0
 .../boost/predef/os/bsd.h                     |     0
 .../boost/predef/os/bsd/bsdi.h                |     0
 .../boost/predef/os/bsd/dragonfly.h           |     0
 .../boost/predef/os/bsd/free.h                |     0
 .../boost/predef/os/bsd/net.h                 |     0
 .../boost/predef/os/bsd/open.h                |     0
 .../boost/predef/os/cygwin.h                  |     0
 .../boost/predef/os/haiku.h                   |     0
 .../boost/predef/os/hpux.h                    |     0
 .../boost/predef/os/ios.h                     |     0
 .../boost/predef/os/irix.h                    |     0
 .../boost/predef/os/linux.h                   |     0
 .../boost/predef/os/macos.h                   |     0
 .../boost/predef/os/os400.h                   |     0
 .../boost/predef/os/qnxnto.h                  |     0
 .../boost/predef/os/solaris.h                 |     0
 .../boost/predef/os/unix.h                    |     0
 .../boost/predef/os/vms.h                     |     0
 .../boost/predef/os/windows.h                 |     0
 .../boost/predef/other.h                      |     0
 .../boost/predef/other/endian.h               |     0
 .../boost/predef/other/workaround.h           |    87 +
 .../boost/predef/platform.h                   |     1 +
 .../boost_1_65_0/boost/predef/platform/ios.h  |    58 +
 .../boost/predef/platform/mingw.h             |     4 +-
 .../boost/predef/platform/windows_desktop.h   |     0
 .../boost/predef/platform/windows_phone.h     |     0
 .../boost/predef/platform/windows_runtime.h   |     0
 .../boost/predef/platform/windows_store.h     |     0
 .../boost/predef/version.h                    |     2 +-
 .../boost/predef/version_number.h             |    21 +-
 .../boost/preprocessor/arithmetic.hpp         |     0
 .../boost/preprocessor/arithmetic/add.hpp     |     0
 .../boost/preprocessor/arithmetic/dec.hpp     |     0
 .../arithmetic/detail/div_base.hpp            |     0
 .../boost/preprocessor/arithmetic/div.hpp     |     0
 .../boost/preprocessor/arithmetic/inc.hpp     |     0
 .../boost/preprocessor/arithmetic/mod.hpp     |     0
 .../boost/preprocessor/arithmetic/mul.hpp     |     0
 .../boost/preprocessor/arithmetic/sub.hpp     |     0
 .../boost/preprocessor/array.hpp              |     0
 .../boost/preprocessor/array/data.hpp         |     0
 .../preprocessor/array/detail/get_data.hpp    |     0
 .../boost/preprocessor/array/elem.hpp         |     0
 .../boost/preprocessor/array/enum.hpp         |     0
 .../boost/preprocessor/array/insert.hpp       |     0
 .../boost/preprocessor/array/pop_back.hpp     |     0
 .../boost/preprocessor/array/pop_front.hpp    |     0
 .../boost/preprocessor/array/push_back.hpp    |     0
 .../boost/preprocessor/array/push_front.hpp   |     0
 .../boost/preprocessor/array/remove.hpp       |     0
 .../boost/preprocessor/array/replace.hpp      |     0
 .../boost/preprocessor/array/reverse.hpp      |     0
 .../boost/preprocessor/array/size.hpp         |     0
 .../boost/preprocessor/array/to_list.hpp      |     0
 .../boost/preprocessor/array/to_seq.hpp       |     0
 .../boost/preprocessor/array/to_tuple.hpp     |     0
 .../boost/preprocessor/assert_msg.hpp         |     0
 .../boost/preprocessor/cat.hpp                |     2 +-
 .../boost/preprocessor/comma.hpp              |     0
 .../boost/preprocessor/comma_if.hpp           |     0
 .../boost/preprocessor/comparison.hpp         |     0
 .../boost/preprocessor/comparison/equal.hpp   |     0
 .../boost/preprocessor/comparison/greater.hpp |     0
 .../preprocessor/comparison/greater_equal.hpp |     0
 .../boost/preprocessor/comparison/less.hpp    |     0
 .../preprocessor/comparison/less_equal.hpp    |     0
 .../preprocessor/comparison/not_equal.hpp     |     0
 .../boost/preprocessor/config/config.hpp      |    20 +-
 .../boost/preprocessor/config/limits.hpp      |     0
 .../boost/preprocessor/control.hpp            |     0
 .../boost/preprocessor/control/deduce_d.hpp   |     0
 .../preprocessor/control/detail/dmc/while.hpp |     0
 .../preprocessor/control/detail/edg/while.hpp |     0
 .../control/detail/msvc/while.hpp             |     0
 .../preprocessor/control/detail/while.hpp     |     0
 .../boost/preprocessor/control/expr_if.hpp    |     0
 .../boost/preprocessor/control/expr_iif.hpp   |     0
 .../boost/preprocessor/control/if.hpp         |     0
 .../boost/preprocessor/control/iif.hpp        |     0
 .../boost/preprocessor/control/while.hpp      |     0
 .../boost/preprocessor/debug.hpp              |     0
 .../boost/preprocessor/debug/assert.hpp       |     0
 .../boost/preprocessor/debug/error.hpp        |     0
 .../boost/preprocessor/debug/line.hpp         |     0
 .../boost/preprocessor/dec.hpp                |     0
 .../boost/preprocessor/detail/auto_rec.hpp    |     0
 .../boost/preprocessor/detail/check.hpp       |     0
 .../preprocessor/detail/dmc/auto_rec.hpp      |     0
 .../boost/preprocessor/detail/is_binary.hpp   |     0
 .../boost/preprocessor/detail/is_nullary.hpp  |     0
 .../boost/preprocessor/detail/is_unary.hpp    |     0
 .../boost/preprocessor/detail/null.hpp        |     0
 .../boost/preprocessor/detail/split.hpp       |     0
 .../boost/preprocessor/empty.hpp              |     0
 .../boost/preprocessor/enum.hpp               |     0
 .../boost/preprocessor/enum_params.hpp        |     0
 .../enum_params_with_a_default.hpp            |     0
 .../enum_params_with_defaults.hpp             |     0
 .../boost/preprocessor/enum_shifted.hpp       |     0
 .../preprocessor/enum_shifted_params.hpp      |     0
 .../boost/preprocessor/expand.hpp             |     0
 .../boost/preprocessor/expr_if.hpp            |     0
 .../boost/preprocessor/facilities.hpp         |     0
 .../boost/preprocessor/facilities/apply.hpp   |     0
 .../facilities/detail/is_empty.hpp            |     0
 .../boost/preprocessor/facilities/empty.hpp   |     0
 .../boost/preprocessor/facilities/expand.hpp  |     0
 .../preprocessor/facilities/identity.hpp      |     0
 .../preprocessor/facilities/intercept.hpp     |     0
 .../boost/preprocessor/facilities/is_1.hpp    |     0
 .../preprocessor/facilities/is_empty.hpp      |     0
 .../preprocessor/facilities/is_empty_or_1.hpp |     0
 .../facilities/is_empty_variadic.hpp          |     0
 .../preprocessor/facilities/overload.hpp      |     0
 .../boost/preprocessor/for.hpp                |     0
 .../boost/preprocessor/identity.hpp           |     0
 .../boost/preprocessor/if.hpp                 |     0
 .../boost/preprocessor/inc.hpp                |     0
 .../boost/preprocessor/iterate.hpp            |     0
 .../boost/preprocessor/iteration.hpp          |     0
 .../iteration/detail/bounds/lower1.hpp        |     0
 .../iteration/detail/bounds/lower2.hpp        |     0
 .../iteration/detail/bounds/lower3.hpp        |     0
 .../iteration/detail/bounds/lower4.hpp        |     0
 .../iteration/detail/bounds/lower5.hpp        |     0
 .../iteration/detail/bounds/upper1.hpp        |     0
 .../iteration/detail/bounds/upper2.hpp        |     0
 .../iteration/detail/bounds/upper3.hpp        |     0
 .../iteration/detail/bounds/upper4.hpp        |     0
 .../iteration/detail/bounds/upper5.hpp        |     0
 .../preprocessor/iteration/detail/finish.hpp  |     0
 .../iteration/detail/iter/forward1.hpp        |     0
 .../iteration/detail/iter/forward2.hpp        |     0
 .../iteration/detail/iter/forward3.hpp        |     0
 .../iteration/detail/iter/forward4.hpp        |     0
 .../iteration/detail/iter/forward5.hpp        |     0
 .../iteration/detail/iter/reverse1.hpp        |     0
 .../iteration/detail/iter/reverse2.hpp        |     0
 .../iteration/detail/iter/reverse3.hpp        |     0
 .../iteration/detail/iter/reverse4.hpp        |     0
 .../iteration/detail/iter/reverse5.hpp        |     0
 .../preprocessor/iteration/detail/local.hpp   |     0
 .../preprocessor/iteration/detail/rlocal.hpp  |     0
 .../preprocessor/iteration/detail/self.hpp    |     0
 .../preprocessor/iteration/detail/start.hpp   |     0
 .../boost/preprocessor/iteration/iterate.hpp  |     0
 .../boost/preprocessor/iteration/local.hpp    |     0
 .../boost/preprocessor/iteration/self.hpp     |     0
 .../boost/preprocessor/library.hpp            |     0
 .../boost/preprocessor/limits.hpp             |     0
 .../boost/preprocessor/list.hpp               |     0
 .../boost/preprocessor/list/adt.hpp           |     0
 .../boost/preprocessor/list/append.hpp        |     0
 .../boost/preprocessor/list/at.hpp            |     0
 .../boost/preprocessor/list/cat.hpp           |     0
 .../list/detail/dmc/fold_left.hpp             |     0
 .../list/detail/edg/fold_left.hpp             |     0
 .../list/detail/edg/fold_right.hpp            |     0
 .../preprocessor/list/detail/fold_left.hpp    |     0
 .../preprocessor/list/detail/fold_right.hpp   |     0
 .../boost/preprocessor/list/enum.hpp          |     0
 .../boost/preprocessor/list/filter.hpp        |     0
 .../boost/preprocessor/list/first_n.hpp       |     0
 .../boost/preprocessor/list/fold_left.hpp     |     0
 .../boost/preprocessor/list/fold_right.hpp    |     0
 .../boost/preprocessor/list/for_each.hpp      |     0
 .../boost/preprocessor/list/for_each_i.hpp    |     0
 .../preprocessor/list/for_each_product.hpp    |     0
 .../boost/preprocessor/list/rest_n.hpp        |     0
 .../boost/preprocessor/list/reverse.hpp       |     0
 .../boost/preprocessor/list/size.hpp          |     0
 .../boost/preprocessor/list/to_array.hpp      |     0
 .../boost/preprocessor/list/to_seq.hpp        |     0
 .../boost/preprocessor/list/to_tuple.hpp      |     0
 .../boost/preprocessor/list/transform.hpp     |     0
 .../boost/preprocessor/logical.hpp            |     0
 .../boost/preprocessor/logical/and.hpp        |     0
 .../boost/preprocessor/logical/bitand.hpp     |     0
 .../boost/preprocessor/logical/bitnor.hpp     |     0
 .../boost/preprocessor/logical/bitor.hpp      |     0
 .../boost/preprocessor/logical/bitxor.hpp     |     0
 .../boost/preprocessor/logical/bool.hpp       |     0
 .../boost/preprocessor/logical/compl.hpp      |     0
 .../boost/preprocessor/logical/nor.hpp        |     0
 .../boost/preprocessor/logical/not.hpp        |     0
 .../boost/preprocessor/logical/or.hpp         |     0
 .../boost/preprocessor/logical/xor.hpp        |     0
 .../boost/preprocessor/max.hpp                |     0
 .../boost/preprocessor/min.hpp                |     0
 .../boost/preprocessor/punctuation.hpp        |     0
 .../boost/preprocessor/punctuation/comma.hpp  |     0
 .../preprocessor/punctuation/comma_if.hpp     |     0
 .../punctuation/detail/is_begin_parens.hpp    |     0
 .../punctuation/is_begin_parens.hpp           |     0
 .../boost/preprocessor/punctuation/paren.hpp  |     0
 .../preprocessor/punctuation/paren_if.hpp     |     0
 .../punctuation/remove_parens.hpp             |     0
 .../boost/preprocessor/repeat.hpp             |     0
 .../boost/preprocessor/repeat_2nd.hpp         |     0
 .../boost/preprocessor/repeat_3rd.hpp         |     0
 .../boost/preprocessor/repeat_from_to.hpp     |     0
 .../boost/preprocessor/repeat_from_to_2nd.hpp |     0
 .../boost/preprocessor/repeat_from_to_3rd.hpp |     0
 .../boost/preprocessor/repetition.hpp         |     0
 .../preprocessor/repetition/deduce_r.hpp      |     0
 .../preprocessor/repetition/deduce_z.hpp      |     0
 .../repetition/detail/dmc/for.hpp             |     0
 .../repetition/detail/edg/for.hpp             |     0
 .../preprocessor/repetition/detail/for.hpp    |     0
 .../repetition/detail/msvc/for.hpp            |     0
 .../boost/preprocessor/repetition/enum.hpp    |     0
 .../repetition/enum_binary_params.hpp         |     0
 .../preprocessor/repetition/enum_params.hpp   |     0
 .../repetition/enum_params_with_a_default.hpp |     0
 .../repetition/enum_params_with_defaults.hpp  |     0
 .../preprocessor/repetition/enum_shifted.hpp  |     0
 .../repetition/enum_shifted_binary_params.hpp |     0
 .../repetition/enum_shifted_params.hpp        |     0
 .../preprocessor/repetition/enum_trailing.hpp |     0
 .../enum_trailing_binary_params.hpp           |     0
 .../repetition/enum_trailing_params.hpp       |     0
 .../boost/preprocessor/repetition/for.hpp     |     0
 .../boost/preprocessor/repetition/repeat.hpp  |     0
 .../repetition/repeat_from_to.hpp             |     0
 .../boost/preprocessor/selection.hpp          |     0
 .../boost/preprocessor/selection/max.hpp      |     0
 .../boost/preprocessor/selection/min.hpp      |     0
 .../boost/preprocessor/seq.hpp                |     0
 .../boost/preprocessor/seq/cat.hpp            |     0
 .../seq/detail/binary_transform.hpp           |    11 +-
 .../preprocessor/seq/detail/is_empty.hpp      |     0
 .../boost/preprocessor/seq/detail/split.hpp   |     0
 .../preprocessor/seq/detail/to_list_msvc.hpp  |    55 +
 .../boost/preprocessor/seq/elem.hpp           |     0
 .../boost/preprocessor/seq/enum.hpp           |     0
 .../boost/preprocessor/seq/filter.hpp         |     0
 .../boost/preprocessor/seq/first_n.hpp        |     0
 .../boost/preprocessor/seq/fold_left.hpp      |     0
 .../boost/preprocessor/seq/fold_right.hpp     |     0
 .../boost/preprocessor/seq/for_each.hpp       |     0
 .../boost/preprocessor/seq/for_each_i.hpp     |     0
 .../preprocessor/seq/for_each_product.hpp     |     0
 .../boost/preprocessor/seq/insert.hpp         |     0
 .../boost/preprocessor/seq/pop_back.hpp       |     0
 .../boost/preprocessor/seq/pop_front.hpp      |     0
 .../boost/preprocessor/seq/push_back.hpp      |     0
 .../boost/preprocessor/seq/push_front.hpp     |     0
 .../boost/preprocessor/seq/remove.hpp         |     0
 .../boost/preprocessor/seq/replace.hpp        |     0
 .../boost/preprocessor/seq/rest_n.hpp         |     0
 .../boost/preprocessor/seq/reverse.hpp        |     0
 .../boost/preprocessor/seq/seq.hpp            |     0
 .../boost/preprocessor/seq/size.hpp           |     0
 .../boost/preprocessor/seq/subseq.hpp         |     0
 .../boost/preprocessor/seq/to_array.hpp       |     0
 .../boost/preprocessor/seq/to_list.hpp        |    12 +
 .../boost/preprocessor/seq/to_tuple.hpp       |     0
 .../boost/preprocessor/seq/transform.hpp      |     0
 .../preprocessor/seq/variadic_seq_to_seq.hpp  |     0
 .../boost/preprocessor/slot.hpp               |     0
 .../boost/preprocessor/slot/counter.hpp       |     0
 .../preprocessor/slot/detail/counter.hpp      |     0
 .../boost/preprocessor/slot/detail/def.hpp    |     0
 .../boost/preprocessor/slot/detail/shared.hpp |     0
 .../boost/preprocessor/slot/detail/slot1.hpp  |     0
 .../boost/preprocessor/slot/detail/slot2.hpp  |     0
 .../boost/preprocessor/slot/detail/slot3.hpp  |     0
 .../boost/preprocessor/slot/detail/slot4.hpp  |     0
 .../boost/preprocessor/slot/detail/slot5.hpp  |     0
 .../boost/preprocessor/slot/slot.hpp          |     0
 .../boost/preprocessor/stringize.hpp          |     0
 .../boost/preprocessor/tuple.hpp              |     0
 .../tuple/detail/is_single_return.hpp         |     0
 .../boost/preprocessor/tuple/eat.hpp          |     0
 .../boost/preprocessor/tuple/elem.hpp         |     0
 .../boost/preprocessor/tuple/enum.hpp         |     0
 .../boost/preprocessor/tuple/insert.hpp       |     0
 .../boost/preprocessor/tuple/pop_back.hpp     |     0
 .../boost/preprocessor/tuple/pop_front.hpp    |     0
 .../boost/preprocessor/tuple/push_back.hpp    |     0
 .../boost/preprocessor/tuple/push_front.hpp   |     0
 .../boost/preprocessor/tuple/rem.hpp          |     0
 .../boost/preprocessor/tuple/remove.hpp       |     0
 .../boost/preprocessor/tuple/replace.hpp      |     0
 .../boost/preprocessor/tuple/reverse.hpp      |     0
 .../boost/preprocessor/tuple/size.hpp         |     0
 .../boost/preprocessor/tuple/to_array.hpp     |     0
 .../boost/preprocessor/tuple/to_list.hpp      |     0
 .../boost/preprocessor/tuple/to_seq.hpp       |     0
 .../boost/preprocessor/variadic.hpp           |     0
 .../variadic/detail/is_single_return.hpp      |     0
 .../boost/preprocessor/variadic/elem.hpp      |     0
 .../boost/preprocessor/variadic/size.hpp      |     0
 .../boost/preprocessor/variadic/to_array.hpp  |     0
 .../boost/preprocessor/variadic/to_list.hpp   |     0
 .../boost/preprocessor/variadic/to_seq.hpp    |     0
 .../boost/preprocessor/variadic/to_tuple.hpp  |     0
 .../boost/preprocessor/while.hpp              |     0
 .../boost/preprocessor/wstringize.hpp         |     0
 .../boost/program_options.hpp                 |     0
 .../boost/program_options/cmdline.hpp         |     0
 .../boost/program_options/config.hpp          |     0
 .../boost/program_options/detail/cmdline.hpp  |     0
 .../program_options/detail/config_file.hpp    |     0
 .../boost/program_options/detail/convert.hpp  |     0
 .../boost/program_options/detail/parsers.hpp  |     0
 .../detail/utf8_codecvt_facet.hpp             |     0
 .../program_options/detail/value_semantic.hpp |    17 +
 .../program_options/environment_iterator.hpp  |     0
 .../boost/program_options/eof_iterator.hpp    |     6 +-
 .../boost/program_options/errors.hpp          |     9 +-
 .../boost/program_options/option.hpp          |     1 +
 .../program_options/options_description.hpp   |     0
 .../boost/program_options/parsers.hpp         |     0
 .../program_options/positional_options.hpp    |     0
 .../boost/program_options/value_semantic.hpp  |    15 +-
 .../boost/program_options/variables_map.hpp   |     0
 .../boost/program_options/version.hpp         |     3 +
 .../libboost/boost_1_65_0/boost/qvm/all.hpp   |    32 +
 .../boost_1_65_0/boost/qvm/assert.hpp         |     9 +
 .../boost_1_65_0/boost/qvm/deduce_mat.hpp     |    90 +
 .../boost_1_65_0/boost/qvm/deduce_quat.hpp    |    63 +
 .../boost_1_65_0/boost/qvm/deduce_scalar.hpp  |   131 +
 .../boost_1_65_0/boost/qvm/deduce_vec.hpp     |    85 +
 .../boost/qvm/detail/cofactor_impl.hpp        |    64 +
 .../boost/qvm/detail/determinant_impl.hpp     |    79 +
 .../boost/qvm/detail/mat_assign.hpp           |    75 +
 .../boost/qvm/detail/quat_assign.hpp          |    35 +
 .../boost/qvm/detail/remove_const.hpp         |    35 +
 .../boost/qvm/detail/swizzle_traits.hpp       |   338 +
 .../boost/qvm/detail/transp_impl.hpp          |   128 +
 .../boost/qvm/detail/vec_assign.hpp           |    71 +
 .../boost_1_65_0/boost/qvm/enable_if.hpp      |    24 +
 .../libboost/boost_1_65_0/boost/qvm/error.hpp |    40 +
 .../boost/qvm/gen/mat_assign2.hpp             |   125 +
 .../boost/qvm/gen/mat_assign3.hpp             |   132 +
 .../boost/qvm/gen/mat_assign4.hpp             |   141 +
 .../boost/qvm/gen/mat_operations2.hpp         |  1720 ++
 .../boost/qvm/gen/mat_operations3.hpp         |  1915 ++
 .../boost/qvm/gen/mat_operations4.hpp         |  2129 ++
 .../boost_1_65_0/boost/qvm/gen/swizzle2.hpp   |   714 +
 .../boost_1_65_0/boost/qvm/gen/swizzle3.hpp   |  4158 +++
 .../boost_1_65_0/boost/qvm/gen/swizzle4.hpp   | 24330 ++++++++++++++++
 .../boost/qvm/gen/vec_assign2.hpp             |    56 +
 .../boost/qvm/gen/vec_assign3.hpp             |    57 +
 .../boost/qvm/gen/vec_assign4.hpp             |    58 +
 .../boost/qvm/gen/vec_mat_operations2.hpp     |   114 +
 .../boost/qvm/gen/vec_mat_operations3.hpp     |   128 +
 .../boost/qvm/gen/vec_mat_operations4.hpp     |   146 +
 .../boost/qvm/gen/vec_operations2.hpp         |   632 +
 .../boost/qvm/gen/vec_operations3.hpp         |   653 +
 .../boost/qvm/gen/vec_operations4.hpp         |   674 +
 .../boost_1_65_0/boost/qvm/inline.hpp         |    34 +
 .../libboost/boost_1_65_0/boost/qvm/map.hpp   |    13 +
 .../boost_1_65_0/boost/qvm/map_mat_mat.hpp    |   895 +
 .../boost_1_65_0/boost/qvm/map_mat_vec.hpp    |   537 +
 .../boost_1_65_0/boost/qvm/map_vec_mat.hpp    |   591 +
 .../libboost/boost_1_65_0/boost/qvm/mat.hpp   |    98 +
 .../boost_1_65_0/boost/qvm/mat_access.hpp     |   258 +
 .../boost_1_65_0/boost/qvm/mat_operations.hpp |  1936 ++
 .../boost/qvm/mat_operations2.hpp             |     6 +
 .../boost/qvm/mat_operations3.hpp             |     6 +
 .../boost/qvm/mat_operations4.hpp             |     6 +
 .../boost_1_65_0/boost/qvm/mat_traits.hpp     |    33 +
 .../boost/qvm/mat_traits_array.hpp            |   118 +
 .../boost/qvm/mat_traits_defaults.hpp         |    95 +
 .../libboost/boost_1_65_0/boost/qvm/math.hpp  |    87 +
 .../boost_1_65_0/boost/qvm/operations.hpp     |    15 +
 .../libboost/boost_1_65_0/boost/qvm/quat.hpp  |    68 +
 .../boost_1_65_0/boost/qvm/quat_access.hpp    |   128 +
 .../boost/qvm/quat_operations.hpp             |  1493 +
 .../boost_1_65_0/boost/qvm/quat_traits.hpp    |    49 +
 .../boost/qvm/quat_traits_array.hpp           |   130 +
 .../boost/qvm/quat_traits_defaults.hpp        |    40 +
 .../boost/qvm/quat_vec_operations.hpp         |    62 +
 .../boost_1_65_0/boost/qvm/scalar_traits.hpp  |    92 +
 .../boost_1_65_0/boost/qvm/static_assert.hpp  |     9 +
 .../boost_1_65_0/boost/qvm/swizzle.hpp        |    13 +
 .../boost_1_65_0/boost/qvm/swizzle2.hpp       |     6 +
 .../boost_1_65_0/boost/qvm/swizzle3.hpp       |     6 +
 .../boost_1_65_0/boost/qvm/swizzle4.hpp       |     6 +
 .../boost/qvm/throw_exception.hpp             |     9 +
 .../boost_1_65_0/boost/qvm/to_string.hpp      |    31 +
 .../libboost/boost_1_65_0/boost/qvm/vec.hpp   |    89 +
 .../boost_1_65_0/boost/qvm/vec_access.hpp     |    82 +
 .../boost/qvm/vec_mat_operations.hpp          |   168 +
 .../boost/qvm/vec_mat_operations2.hpp         |     6 +
 .../boost/qvm/vec_mat_operations3.hpp         |     6 +
 .../boost/qvm/vec_mat_operations4.hpp         |     6 +
 .../boost_1_65_0/boost/qvm/vec_operations.hpp |   963 +
 .../boost/qvm/vec_operations2.hpp             |     6 +
 .../boost/qvm/vec_operations3.hpp             |     6 +
 .../boost/qvm/vec_operations4.hpp             |     6 +
 .../boost_1_65_0/boost/qvm/vec_traits.hpp     |    32 +
 .../boost/qvm/vec_traits_array.hpp            |   108 +
 .../boost/qvm/vec_traits_defaults.hpp         |    94 +
 .../boost/random.hpp                          |     0
 .../boost/random/additive_combine.hpp         |     0
 .../boost/random/bernoulli_distribution.hpp   |     0
 .../boost/random/beta_distribution.hpp        |     0
 .../boost/random/binomial_distribution.hpp    |     0
 .../boost/random/cauchy_distribution.hpp      |     0
 .../boost/random/chi_squared_distribution.hpp |     0
 .../boost/random/detail/auto_link.hpp         |     0
 .../boost/random/detail/config.hpp            |     0
 .../boost/random/detail/const_mod.hpp         |     0
 .../boost/random/detail/disable_warnings.hpp  |     0
 .../boost/random/detail/enable_warnings.hpp   |     0
 .../boost/random/detail/generator_bits.hpp    |     0
 .../random/detail/generator_seed_seq.hpp      |     0
 .../boost/random/detail/int_float_pair.hpp    |   121 +
 .../boost/random/detail/integer_log2.hpp      |     0
 .../boost/random/detail/iterator_mixin.hpp    |     0
 .../boost/random/detail/large_arithmetic.hpp  |     0
 .../boost/random/detail/operators.hpp         |     0
 .../boost/random/detail/polynomial.hpp        |     0
 .../boost/random/detail/ptr_helper.hpp        |     0
 .../boost/random/detail/seed.hpp              |     0
 .../boost/random/detail/seed_impl.hpp         |     0
 .../random/detail/signed_unsigned_tools.hpp   |     0
 .../boost/random/detail/uniform_int_float.hpp |     0
 .../boost/random/detail/vector_io.hpp         |     0
 .../boost/random/discard_block.hpp            |     0
 .../boost/random/discrete_distribution.hpp    |     0
 .../boost/random/exponential_distribution.hpp |   386 +
 .../random/extreme_value_distribution.hpp     |     0
 .../boost/random/fisher_f_distribution.hpp    |     0
 .../boost/random/gamma_distribution.hpp       |     0
 .../boost/random/generate_canonical.hpp       |     0
 .../boost/random/geometric_distribution.hpp   |     0
 .../random/hyperexponential_distribution.hpp  |     0
 .../boost/random/independent_bits.hpp         |     0
 .../boost/random/inversive_congruential.hpp   |     0
 .../boost/random/lagged_fibonacci.hpp         |     0
 .../boost/random/laplace_distribution.hpp     |     0
 .../boost/random/linear_congruential.hpp      |     0
 .../boost/random/linear_feedback_shift.hpp    |     0
 .../boost/random/lognormal_distribution.hpp   |     0
 .../boost/random/mersenne_twister.hpp         |     0
 .../random/negative_binomial_distribution.hpp |     0
 .../non_central_chi_squared_distribution.hpp  |     0
 .../boost/random/normal_distribution.hpp      |   163 +-
 .../piecewise_constant_distribution.hpp       |     0
 .../random/piecewise_linear_distribution.hpp  |     0
 .../boost/random/poisson_distribution.hpp     |     0
 .../boost/random/random_device.hpp            |     0
 .../boost/random/random_number_generator.hpp  |     0
 .../boost/random/ranlux.hpp                   |     0
 .../boost/random/seed_seq.hpp                 |     0
 .../boost/random/shuffle_order.hpp            |     0
 .../boost/random/shuffle_output.hpp           |     0
 .../boost/random/student_t_distribution.hpp   |     0
 .../boost/random/subtract_with_carry.hpp      |     0
 .../boost/random/taus88.hpp                   |     0
 .../boost/random/traits.hpp                   |     0
 .../boost/random/triangle_distribution.hpp    |     0
 .../boost/random/uniform_01.hpp               |     0
 .../boost/random/uniform_int.hpp              |     0
 .../boost/random/uniform_int_distribution.hpp |     0
 .../boost/random/uniform_on_sphere.hpp        |     0
 .../boost/random/uniform_real.hpp             |     0
 .../random/uniform_real_distribution.hpp      |     0
 .../boost/random/uniform_smallint.hpp         |     0
 .../boost/random/variate_generator.hpp        |     0
 .../boost/random/weibull_distribution.hpp     |     0
 .../boost/random/xor_combine.hpp              |     0
 contrib/libboost/boost_1_65_0/boost/range.hpp |    23 +
 .../boost/range/adaptor/adjacent_filtered.hpp |     0
 .../boost/range/adaptor/argument_fwd.hpp      |     0
 .../boost/range/adaptor/copied.hpp            |     0
 .../boost/range/adaptor/define_adaptor.hpp    |     0
 .../boost/range/adaptor/filtered.hpp          |     0
 .../boost/range/adaptor/formatted.hpp         |     0
 .../boost/range/adaptor/indexed.hpp           |     0
 .../boost/range/adaptor/indirected.hpp        |     0
 .../boost/range/adaptor/map.hpp               |     0
 .../boost/range/adaptor/replaced.hpp          |     0
 .../boost/range/adaptor/replaced_if.hpp       |     0
 .../boost/range/adaptor/reversed.hpp          |     0
 .../boost/range/adaptor/sliced.hpp            |     0
 .../boost/range/adaptor/strided.hpp           |     0
 .../boost/range/adaptor/tokenized.hpp         |     0
 .../boost/range/adaptor/transformed.hpp       |     0
 .../boost/range/adaptor/type_erased.hpp       |     0
 .../boost/range/adaptor/uniqued.hpp           |     0
 .../boost/range/adaptors.hpp                  |     0
 .../boost/range/algorithm.hpp                 |     0
 .../boost/range/algorithm/adjacent_find.hpp   |     0
 .../boost/range/algorithm/binary_search.hpp   |     0
 .../boost/range/algorithm/copy.hpp            |     0
 .../boost/range/algorithm/copy_backward.hpp   |     0
 .../boost/range/algorithm/count.hpp           |     0
 .../boost/range/algorithm/count_if.hpp        |     0
 .../boost/range/algorithm/equal.hpp           |     0
 .../boost/range/algorithm/equal_range.hpp     |     0
 .../boost/range/algorithm/fill.hpp            |     0
 .../boost/range/algorithm/fill_n.hpp          |     0
 .../boost/range/algorithm/find.hpp            |     0
 .../boost/range/algorithm/find_end.hpp        |     0
 .../boost/range/algorithm/find_first_of.hpp   |     0
 .../boost/range/algorithm/find_if.hpp         |     0
 .../boost/range/algorithm/for_each.hpp        |     0
 .../boost/range/algorithm/generate.hpp        |     0
 .../boost/range/algorithm/heap_algorithm.hpp  |     0
 .../boost/range/algorithm/inplace_merge.hpp   |     0
 .../algorithm/lexicographical_compare.hpp     |     0
 .../boost/range/algorithm/lower_bound.hpp     |     0
 .../boost/range/algorithm/max_element.hpp     |     0
 .../boost/range/algorithm/merge.hpp           |     0
 .../boost/range/algorithm/min_element.hpp     |     0
 .../boost/range/algorithm/mismatch.hpp        |     0
 .../boost/range/algorithm/nth_element.hpp     |     0
 .../boost/range/algorithm/partial_sort.hpp    |     0
 .../range/algorithm/partial_sort_copy.hpp     |     0
 .../boost/range/algorithm/partition.hpp       |     0
 .../boost/range/algorithm/permutation.hpp     |     0
 .../boost/range/algorithm/random_shuffle.hpp  |     0
 .../boost/range/algorithm/remove.hpp          |     0
 .../boost/range/algorithm/remove_copy.hpp     |     0
 .../boost/range/algorithm/remove_copy_if.hpp  |     0
 .../boost/range/algorithm/remove_if.hpp       |     0
 .../boost/range/algorithm/replace.hpp         |     0
 .../boost/range/algorithm/replace_copy.hpp    |     0
 .../boost/range/algorithm/replace_copy_if.hpp |     0
 .../boost/range/algorithm/replace_if.hpp      |     0
 .../boost/range/algorithm/reverse.hpp         |     0
 .../boost/range/algorithm/reverse_copy.hpp    |     0
 .../boost/range/algorithm/rotate.hpp          |     0
 .../boost/range/algorithm/rotate_copy.hpp     |     0
 .../boost/range/algorithm/search.hpp          |     0
 .../boost/range/algorithm/search_n.hpp        |     0
 .../boost/range/algorithm/set_algorithm.hpp   |     0
 .../boost/range/algorithm/sort.hpp            |     0
 .../range/algorithm/stable_partition.hpp      |     0
 .../boost/range/algorithm/stable_sort.hpp     |     0
 .../boost/range/algorithm/swap_ranges.hpp     |     0
 .../boost/range/algorithm/transform.hpp       |     0
 .../boost/range/algorithm/unique.hpp          |     0
 .../boost/range/algorithm/unique_copy.hpp     |     0
 .../boost/range/algorithm/upper_bound.hpp     |     0
 .../boost/range/algorithm_ext.hpp             |     0
 .../boost/range/algorithm_ext/copy_n.hpp      |     0
 .../boost/range/algorithm_ext/erase.hpp       |     0
 .../boost/range/algorithm_ext/for_each.hpp    |     0
 .../boost/range/algorithm_ext/insert.hpp      |     0
 .../boost/range/algorithm_ext/iota.hpp        |     0
 .../boost/range/algorithm_ext/is_sorted.hpp   |     0
 .../boost/range/algorithm_ext/overwrite.hpp   |     0
 .../boost/range/algorithm_ext/push_back.hpp   |     0
 .../boost/range/algorithm_ext/push_front.hpp  |     0
 .../boost/range/any_range.hpp                 |     0
 .../boost/range/as_array.hpp                  |     0
 .../boost/range/as_literal.hpp                |     0
 .../boost/range/atl.hpp                       |     0
 .../boost/range/begin.hpp                     |     0
 .../boost/range/category.hpp                  |     0
 .../boost/range/combine.hpp                   |     0
 .../boost/range/concepts.hpp                  |     0
 .../boost/range/config.hpp                    |     0
 .../boost/range/const_iterator.hpp            |     0
 .../boost/range/const_reverse_iterator.hpp    |     0
 .../boost/range/counting_range.hpp            |     0
 .../boost/range/detail/any_iterator.hpp       |     0
 .../range/detail/any_iterator_buffer.hpp      |     0
 .../range/detail/any_iterator_interface.hpp   |     0
 .../range/detail/any_iterator_wrapper.hpp     |     0
 .../boost/range/detail/as_literal.hpp         |     0
 .../boost/range/detail/begin.hpp              |     0
 .../boost/range/detail/collection_traits.hpp  |     0
 .../range/detail/collection_traits_detail.hpp |     0
 .../boost/range/detail/combine_cxx03.hpp      |     0
 .../boost/range/detail/combine_cxx11.hpp      |     0
 .../boost/range/detail/combine_no_rvalue.hpp  |     0
 .../boost/range/detail/combine_rvalue.hpp     |     0
 .../boost/range/detail/common.hpp             |     0
 .../detail/default_constructible_unary_fn.hpp |     0
 .../detail/demote_iterator_traversal_tag.hpp  |     0
 .../boost/range/detail/detail_str.hpp         |     0
 .../boost/range/detail/difference_type.hpp    |     0
 .../boost/range/detail/empty.hpp              |     0
 .../boost/range/detail/end.hpp                |     0
 .../range/detail/extract_optional_type.hpp    |     0
 .../boost/range/detail/has_member_size.hpp    |     0
 .../range/detail/implementation_help.hpp      |     0
 .../boost/range/detail/join_iterator.hpp      |     0
 .../boost/range/detail/microsoft.hpp          |     0
 .../boost/range/detail/misc_concept.hpp       |     0
 .../detail/msvc_has_iterator_workaround.hpp   |     0
 .../boost/range/detail/range_return.hpp       |     0
 .../boost/range/detail/remove_extent.hpp      |     0
 .../boost/range/detail/safe_bool.hpp          |     0
 .../boost/range/detail/sfinae.hpp             |     0
 .../boost/range/detail/size_type.hpp          |     0
 .../boost/range/detail/sizer.hpp              |     0
 .../boost/range/detail/str_types.hpp          |     0
 .../boost/range/detail/value_type.hpp         |     0
 .../boost/range/difference_type.hpp           |     0
 .../boost/range/distance.hpp                  |     0
 .../boost/range/empty.hpp                     |     0
 .../boost/range/end.hpp                       |     0
 .../boost/range/functions.hpp                 |     0
 .../boost/range/has_range_iterator.hpp        |     0
 .../boost/range/irange.hpp                    |     0
 .../boost/range/istream_range.hpp             |     0
 .../boost/range/iterator.hpp                  |     0
 .../boost/range/iterator_range.hpp            |     0
 .../boost/range/iterator_range_core.hpp       |     0
 .../boost/range/iterator_range_hash.hpp       |     0
 .../boost/range/iterator_range_io.hpp         |     0
 .../boost/range/join.hpp                      |     0
 .../boost/range/metafunctions.hpp             |     0
 .../boost/range/mfc.hpp                       |     0
 .../boost/range/mfc_map.hpp                   |     0
 .../boost/range/mutable_iterator.hpp          |     0
 .../boost/range/numeric.hpp                   |     0
 .../boost/range/pointer.hpp                   |     0
 .../boost/range/range_fwd.hpp                 |     0
 .../boost/range/rbegin.hpp                    |     0
 .../boost/range/reference.hpp                 |     0
 .../boost/range/rend.hpp                      |     0
 .../boost/range/result_iterator.hpp           |     0
 .../boost/range/reverse_iterator.hpp          |     0
 .../boost/range/reverse_result_iterator.hpp   |     0
 .../boost/range/size.hpp                      |     0
 .../boost/range/size_type.hpp                 |     5 -
 .../boost/range/sub_range.hpp                 |     0
 .../boost/range/traversal.hpp                 |     0
 .../boost/range/value_type.hpp                |     0
 .../boost/rational.hpp                        |   499 +-
 .../boost/ref.hpp                             |     0
 .../boost/scoped_array.hpp                    |     3 +-
 .../boost/scoped_ptr.hpp                      |     3 +-
 .../boost/shared_ptr.hpp                      |     2 +-
 .../smart_ptr/allocate_local_shared_array.hpp |   228 +
 .../boost/smart_ptr/allocate_shared_array.hpp |   697 +
 .../boost/smart_ptr/atomic_shared_ptr.hpp     |   183 +
 .../boost/smart_ptr/bad_weak_ptr.hpp          |    11 +
 .../boost/smart_ptr/detail/atomic_count.hpp   |     3 +
 .../smart_ptr/detail/atomic_count_gcc.hpp     |     2 +-
 .../smart_ptr/detail/atomic_count_gcc_x86.hpp |     0
 .../smart_ptr/detail/atomic_count_nt.hpp      |     0
 .../smart_ptr/detail/atomic_count_pt.hpp      |     0
 .../smart_ptr/detail/atomic_count_solaris.hpp |     0
 .../smart_ptr/detail/atomic_count_spin.hpp    |     0
 .../detail/atomic_count_std_atomic.hpp        |     0
 .../smart_ptr/detail/atomic_count_sync.hpp    |     0
 .../smart_ptr/detail/atomic_count_win32.hpp   |     0
 .../smart_ptr/detail/lightweight_mutex.hpp    |     0
 .../smart_ptr/detail/local_counted_base.hpp   |   146 +
 .../smart_ptr/detail/local_sp_deleter.hpp     |    91 +
 .../boost/smart_ptr/detail/lwm_nop.hpp        |     0
 .../boost/smart_ptr/detail/lwm_pthreads.hpp   |     0
 .../boost/smart_ptr/detail/lwm_win32_cs.hpp   |    28 +-
 .../boost/smart_ptr/detail/operator_bool.hpp  |    12 +-
 .../smart_ptr/detail/quick_allocator.hpp      |     0
 .../boost/smart_ptr/detail/shared_count.hpp   |    80 +-
 .../boost/smart_ptr/detail/sp_convertible.hpp |     0
 .../smart_ptr/detail/sp_counted_base.hpp      |     7 +-
 .../detail/sp_counted_base_acc_ia64.hpp       |     1 +
 .../smart_ptr/detail/sp_counted_base_aix.hpp  |     1 +
 .../detail/sp_counted_base_clang.hpp          |    10 +
 .../detail/sp_counted_base_cw_ppc.hpp         |     1 +
 .../detail/sp_counted_base_cw_x86.hpp         |     1 +
 .../detail/sp_counted_base_gcc_ia64.hpp       |     1 +
 .../detail/sp_counted_base_gcc_mips.hpp       |     1 +
 .../detail/sp_counted_base_gcc_ppc.hpp        |     1 +
 .../detail/sp_counted_base_gcc_sparc.hpp      |     1 +
 .../detail/sp_counted_base_gcc_x86.hpp        |     1 +
 .../smart_ptr/detail/sp_counted_base_nt.hpp   |     1 +
 .../smart_ptr/detail/sp_counted_base_pt.hpp   |     1 +
 .../detail/sp_counted_base_snc_ps3.hpp        |     1 +
 .../detail/sp_counted_base_solaris.hpp        |     1 +
 .../smart_ptr/detail/sp_counted_base_spin.hpp |     1 +
 .../detail/sp_counted_base_std_atomic.hpp     |     1 +
 .../smart_ptr/detail/sp_counted_base_sync.hpp |     1 +
 .../detail/sp_counted_base_vacpp_ppc.hpp      |     1 +
 .../smart_ptr/detail/sp_counted_base_w32.hpp  |     1 +
 .../smart_ptr/detail/sp_counted_impl.hpp      |    37 +-
 .../detail/sp_disable_deprecated.hpp          |     0
 .../boost/smart_ptr/detail/sp_forward.hpp     |     0
 .../boost/smart_ptr/detail/sp_has_sync.hpp    |     6 +-
 .../boost/smart_ptr/detail/sp_interlocked.hpp |     0
 .../boost/smart_ptr/detail/sp_noexcept.hpp    |    48 +
 .../boost/smart_ptr/detail/sp_nullptr_t.hpp   |     0
 .../boost/smart_ptr/detail/spinlock.hpp       |     3 +
 .../smart_ptr/detail/spinlock_gcc_arm.hpp     |     0
 .../boost/smart_ptr/detail/spinlock_nt.hpp    |     0
 .../boost/smart_ptr/detail/spinlock_pool.hpp  |     0
 .../boost/smart_ptr/detail/spinlock_pt.hpp    |     0
 .../smart_ptr/detail/spinlock_std_atomic.hpp  |     0
 .../boost/smart_ptr/detail/spinlock_sync.hpp  |     0
 .../boost/smart_ptr/detail/spinlock_w32.hpp   |     0
 .../boost/smart_ptr/detail/yield_k.hpp        |     2 +-
 .../smart_ptr/enable_shared_from_raw.hpp      |     0
 .../smart_ptr/enable_shared_from_this.hpp     |    17 +-
 .../boost/smart_ptr/intrusive_ptr.hpp         |    59 +-
 .../boost/smart_ptr/intrusive_ref_counter.hpp |    33 +-
 .../boost/smart_ptr/local_shared_ptr.hpp      |   684 +
 .../boost/smart_ptr/make_local_shared.hpp     |    17 +
 .../smart_ptr/make_local_shared_array.hpp     |    67 +
 .../smart_ptr/make_local_shared_object.hpp    |   199 +
 .../boost/smart_ptr/make_shared.hpp           |     3 +-
 .../boost/smart_ptr/make_shared_array.hpp     |    66 +
 .../boost/smart_ptr/make_shared_object.hpp    |   801 +
 .../boost/smart_ptr/make_unique.hpp           |    35 +-
 .../boost/smart_ptr/owner_less.hpp            |    34 +
 .../boost/smart_ptr/scoped_array.hpp          |    26 +-
 .../boost/smart_ptr/scoped_ptr.hpp            |    32 +-
 .../boost/smart_ptr/shared_array.hpp          |    57 +-
 .../boost/smart_ptr/shared_ptr.hpp            |   270 +-
 .../boost/smart_ptr/weak_ptr.hpp              |    55 +-
 .../boost/static_assert.hpp                   |     0
 .../boost/swap.hpp                            |     0
 .../boost/system/api_config.hpp               |     0
 .../boost/system/config.hpp                   |     0
 .../boost/system/cygwin_error.hpp             |     6 +-
 .../boost/system/detail/error_code.ipp        |   212 +-
 .../detail/local_free_on_destruction.hpp      |     4 +-
 .../boost/system/error_code.hpp               |   310 +-
 .../boost/system/linux_error.hpp              |     6 +-
 .../boost/system/system_error.hpp             |    14 +-
 .../boost/system/windows_error.hpp            |   128 +
 .../boost/throw_exception.hpp                 |     0
 .../boost/timer.hpp                           |     0
 .../boost/token_functions.hpp                 |     0
 .../boost/token_iterator.hpp                  |     7 +-
 .../boost/tokenizer.hpp                       |     0
 .../boost/tuple/detail/tuple_basic.hpp        |   989 +
 .../boost_1_65_0/boost/tuple/tuple.hpp        |    67 +
 .../boost/tuple/tuple_comparison.hpp          |   175 +
 .../boost_1_65_0/boost/tuple/tuple_io.hpp     |   341 +
 .../boost/type.hpp                            |     0
 .../boost/type_index.hpp                      |     0
 .../boost/type_index/ctti_type_index.hpp      |     1 +
 .../detail/compile_time_type_info.hpp         |    50 +-
 .../type_index/detail/ctti_register_class.hpp |     0
 .../type_index/detail/stl_register_class.hpp  |     0
 .../boost/type_index/runtime_cast.hpp         |    28 +
 .../runtime_cast/boost_shared_ptr_cast.hpp    |    46 +
 .../runtime_cast/detail/runtime_cast_impl.hpp |    57 +
 .../type_index/runtime_cast/pointer_cast.hpp  |    74 +
 .../runtime_cast/reference_cast.hpp           |    66 +
 .../runtime_cast/register_runtime_class.hpp   |   138 +
 .../runtime_cast/std_shared_ptr_cast.hpp      |    46 +
 .../boost/type_index/stl_type_index.hpp       |    12 +-
 .../boost/type_index/type_index_facade.hpp    |     3 +-
 .../boost/type_traits.hpp                     |     2 +
 .../boost/type_traits/add_const.hpp           |     6 +
 .../boost/type_traits/add_cv.hpp              |     6 +
 .../type_traits/add_lvalue_reference.hpp      |     6 +
 .../boost/type_traits/add_pointer.hpp         |     6 +
 .../boost/type_traits/add_reference.hpp       |     7 +
 .../type_traits/add_rvalue_reference.hpp      |     6 +
 .../boost/type_traits/add_volatile.hpp        |     6 +
 .../boost/type_traits/aligned_storage.hpp     |     0
 .../boost/type_traits/alignment_of.hpp        |     0
 .../boost/type_traits/alignment_traits.hpp    |     0
 .../boost/type_traits/arithmetic_traits.hpp   |     0
 .../boost/type_traits/array_traits.hpp        |     0
 .../type_traits/broken_compiler_spec.hpp      |     0
 .../boost/type_traits/common_type.hpp         |     0
 .../boost/type_traits/composite_traits.hpp    |     0
 .../boost/type_traits/conditional.hpp         |     6 +
 .../boost/type_traits/config.hpp              |     0
 .../boost/type_traits/conversion_traits.hpp   |     0
 .../boost/type_traits/copy_cv.hpp             |     6 +
 .../boost/type_traits/cv_traits.hpp           |     0
 .../boost/type_traits/decay.hpp               |     6 +
 .../boost/type_traits/declval.hpp             |     0
 .../type_traits/detail/bool_trait_def.hpp     |     0
 .../type_traits/detail/bool_trait_undef.hpp   |     0
 .../detail/common_arithmetic_type.hpp         |     6 +-
 .../type_traits/detail/common_type_impl.hpp   |     0
 .../detail/composite_member_pointer_type.hpp  |     0
 .../detail/composite_pointer_type.hpp         |     0
 .../boost/type_traits/detail/config.hpp       |     0
 .../detail/has_binary_operator.hpp            |     0
 .../detail/has_postfix_operator.hpp           |     0
 .../detail/has_prefix_operator.hpp            |     0
 .../boost/type_traits/detail/ice_and.hpp      |     0
 .../boost/type_traits/detail/ice_eq.hpp       |     0
 .../boost/type_traits/detail/ice_not.hpp      |     0
 .../boost/type_traits/detail/ice_or.hpp       |     0
 .../detail/is_function_ptr_helper.hpp         |     0
 .../detail/is_function_ptr_tester.hpp         |     0
 .../detail/is_mem_fun_pointer_impl.hpp        |     0
 .../detail/is_mem_fun_pointer_tester.hpp      |     0
 .../boost/type_traits/detail/mp_defer.hpp     |     0
 .../detail/template_arity_spec.hpp            |     0
 .../boost/type_traits/detail/yes_no_type.hpp  |     0
 .../boost/type_traits/extent.hpp              |     0
 .../type_traits/floating_point_promotion.hpp  |     6 +
 .../boost/type_traits/function_traits.hpp     |     0
 .../boost/type_traits/has_bit_and.hpp         |     0
 .../boost/type_traits/has_bit_and_assign.hpp  |     0
 .../boost/type_traits/has_bit_or.hpp          |     0
 .../boost/type_traits/has_bit_or_assign.hpp   |     0
 .../boost/type_traits/has_bit_xor.hpp         |     0
 .../boost/type_traits/has_bit_xor_assign.hpp  |     0
 .../boost/type_traits/has_complement.hpp      |     0
 .../boost/type_traits/has_dereference.hpp     |     0
 .../boost/type_traits/has_divides.hpp         |     0
 .../boost/type_traits/has_divides_assign.hpp  |     0
 .../boost/type_traits/has_equal_to.hpp        |     0
 .../boost/type_traits/has_greater.hpp         |     0
 .../boost/type_traits/has_greater_equal.hpp   |     0
 .../boost/type_traits/has_left_shift.hpp      |     0
 .../type_traits/has_left_shift_assign.hpp     |     0
 .../boost/type_traits/has_less.hpp            |     0
 .../boost/type_traits/has_less_equal.hpp      |     0
 .../boost/type_traits/has_logical_and.hpp     |     0
 .../boost/type_traits/has_logical_not.hpp     |     0
 .../boost/type_traits/has_logical_or.hpp      |     0
 .../boost/type_traits/has_minus.hpp           |     0
 .../boost/type_traits/has_minus_assign.hpp    |     0
 .../boost/type_traits/has_modulus.hpp         |     0
 .../boost/type_traits/has_modulus_assign.hpp  |     0
 .../boost/type_traits/has_multiplies.hpp      |     0
 .../type_traits/has_multiplies_assign.hpp     |     0
 .../boost/type_traits/has_negate.hpp          |     0
 .../boost/type_traits/has_new_operator.hpp    |     0
 .../boost/type_traits/has_not_equal_to.hpp    |     0
 .../boost/type_traits/has_nothrow_assign.hpp  |     0
 .../type_traits/has_nothrow_constructor.hpp   |     0
 .../boost/type_traits/has_nothrow_copy.hpp    |     0
 .../type_traits/has_nothrow_destructor.hpp    |     0
 .../boost/type_traits/has_operator.hpp        |     0
 .../boost/type_traits/has_plus.hpp            |     0
 .../boost/type_traits/has_plus_assign.hpp     |     0
 .../boost/type_traits/has_post_decrement.hpp  |     0
 .../boost/type_traits/has_post_increment.hpp  |     0
 .../boost/type_traits/has_pre_decrement.hpp   |     0
 .../boost/type_traits/has_pre_increment.hpp   |     0
 .../boost/type_traits/has_right_shift.hpp     |     0
 .../type_traits/has_right_shift_assign.hpp    |     0
 .../boost/type_traits/has_trivial_assign.hpp  |     0
 .../type_traits/has_trivial_constructor.hpp   |     0
 .../boost/type_traits/has_trivial_copy.hpp    |     0
 .../type_traits/has_trivial_destructor.hpp    |     0
 .../type_traits/has_trivial_move_assign.hpp   |     0
 .../has_trivial_move_constructor.hpp          |     0
 .../boost/type_traits/has_unary_minus.hpp     |     0
 .../boost/type_traits/has_unary_plus.hpp      |     0
 .../type_traits/has_virtual_destructor.hpp    |     0
 .../boost/type_traits/ice.hpp                 |     0
 .../boost/type_traits/integral_constant.hpp   |     0
 .../boost/type_traits/integral_promotion.hpp  |     6 +
 .../boost/type_traits/intrinsics.hpp          |     0
 .../boost/type_traits/is_abstract.hpp         |     0
 .../boost/type_traits/is_arithmetic.hpp       |     0
 .../boost/type_traits/is_array.hpp            |     0
 .../boost/type_traits/is_assignable.hpp       |     0
 .../boost/type_traits/is_base_and_derived.hpp |     0
 .../boost/type_traits/is_base_of.hpp          |     0
 .../boost/type_traits/is_base_of_tr1.hpp      |     0
 .../boost/type_traits/is_class.hpp            |     0
 .../boost/type_traits/is_complex.hpp          |     0
 .../boost/type_traits/is_compound.hpp         |     0
 .../boost/type_traits/is_const.hpp            |     0
 .../boost/type_traits/is_constructible.hpp    |     0
 .../boost/type_traits/is_convertible.hpp      |     0
 .../boost/type_traits/is_copy_assignable.hpp  |     0
 .../type_traits/is_copy_constructible.hpp     |     0
 .../type_traits/is_default_constructible.hpp  |     0
 .../boost/type_traits/is_destructible.hpp     |     0
 .../boost/type_traits/is_empty.hpp            |     0
 .../boost/type_traits/is_enum.hpp             |     0
 .../boost/type_traits/is_final.hpp            |     0
 .../boost/type_traits/is_float.hpp            |     0
 .../boost/type_traits/is_floating_point.hpp   |     0
 .../boost/type_traits/is_function.hpp         |     0
 .../boost/type_traits/is_fundamental.hpp      |     0
 .../boost/type_traits/is_integral.hpp         |     0
 .../boost/type_traits/is_lvalue_reference.hpp |     0
 .../is_member_function_pointer.hpp            |     0
 .../type_traits/is_member_object_pointer.hpp  |     0
 .../boost/type_traits/is_member_pointer.hpp   |     0
 .../is_nothrow_move_assignable.hpp            |     0
 .../is_nothrow_move_constructible.hpp         |     0
 .../boost/type_traits/is_object.hpp           |     0
 .../boost/type_traits/is_pod.hpp              |     0
 .../boost/type_traits/is_pointer.hpp          |     0
 .../boost/type_traits/is_polymorphic.hpp      |     0
 .../boost/type_traits/is_reference.hpp        |     0
 .../boost/type_traits/is_rvalue_reference.hpp |     2 +-
 .../boost/type_traits/is_same.hpp             |     0
 .../boost/type_traits/is_scalar.hpp           |     0
 .../boost/type_traits/is_signed.hpp           |     0
 .../boost/type_traits/is_stateless.hpp        |     0
 .../boost/type_traits/is_union.hpp            |     0
 .../boost/type_traits/is_unsigned.hpp         |     0
 .../boost/type_traits/is_virtual_base_of.hpp  |     0
 .../boost/type_traits/is_void.hpp             |     0
 .../boost/type_traits/is_volatile.hpp         |     0
 .../boost/type_traits/make_signed.hpp         |     6 +
 .../boost/type_traits/make_unsigned.hpp       |     6 +
 .../boost/type_traits/make_void.hpp           |    52 +
 .../boost/type_traits/object_traits.hpp       |     0
 .../boost/type_traits/promote.hpp             |     6 +
 .../boost/type_traits/rank.hpp                |     0
 .../boost/type_traits/reference_traits.hpp    |     0
 .../boost/type_traits/remove_all_extents.hpp  |     6 +
 .../boost/type_traits/remove_bounds.hpp       |     7 +
 .../boost/type_traits/remove_const.hpp        |     6 +
 .../boost/type_traits/remove_cv.hpp           |     5 +
 .../boost/type_traits/remove_cv_ref.hpp       |    30 +
 .../boost/type_traits/remove_extent.hpp       |     6 +
 .../boost/type_traits/remove_pointer.hpp      |     6 +
 .../boost/type_traits/remove_reference.hpp    |     5 +
 .../boost/type_traits/remove_volatile.hpp     |     5 +
 .../boost/type_traits/same_traits.hpp         |     0
 .../boost/type_traits/transform_traits.hpp    |     0
 .../boost/type_traits/type_identity.hpp       |     7 +
 .../boost/type_traits/type_with_alignment.hpp |     0
 .../boost/utility.hpp                         |     4 +-
 .../boost/utility/addressof.hpp               |     0
 .../boost/utility/base_from_member.hpp        |     0
 .../boost/utility/binary.hpp                  |     0
 .../boost/utility/compare_pointees.hpp        |    12 +-
 .../boost/utility/declval.hpp                 |     0
 .../detail/in_place_factory_prefix.hpp        |     0
 .../detail/in_place_factory_suffix.hpp        |     0
 .../utility/detail/result_of_iterate.hpp      |     0
 .../boost/utility/empty_deleter.hpp           |     0
 .../boost/utility/enable_if.hpp               |     0
 .../boost/utility/explicit_operator_bool.hpp  |     0
 .../boost/utility/identity_type.hpp           |     0
 .../boost/utility/in_place_factory.hpp        |     0
 .../boost/utility/result_of.hpp               |     5 +
 .../boost/utility/string_ref.hpp              |    11 +-
 .../boost/utility/string_ref_fwd.hpp          |     0
 .../boost/utility/string_view.hpp             |    89 +-
 .../boost/utility/string_view_fwd.hpp         |     0
 .../boost/utility/swap.hpp                    |     0
 .../boost/utility/typed_in_place_factory.hpp  |     0
 .../boost/utility/value_init.hpp              |     0
 .../boost/variant/apply_visitor.hpp           |    20 +
 .../boost_1_65_0/boost/variant/bad_visit.hpp  |    41 +
 .../variant/detail/apply_visitor_binary.hpp   |   280 +
 .../variant/detail/apply_visitor_delayed.hpp  |   151 +
 .../variant/detail/apply_visitor_unary.hpp    |   173 +
 .../boost/variant/detail/backup_holder.hpp    |    95 +
 .../boost/variant/detail/cast_storage.hpp     |    42 +
 .../boost/variant/detail/config.hpp           |    19 +
 .../boost/variant/detail/element_index.hpp    |    63 +
 .../boost/variant/detail/enable_recursive.hpp |   133 +
 .../variant/detail/enable_recursive_fwd.hpp   |    87 +
 .../boost/variant/detail/forced_return.hpp    |    64 +
 .../variant/detail/generic_result_type.hpp    |    88 +
 .../boost/variant/detail/has_result_type.hpp  |    37 +
 .../boost/variant/detail/hash_variant.hpp     |    47 +
 .../boost/variant/detail/initializer.hpp      |   249 +
 .../variant/detail/make_variant_list.hpp      |    73 +
 .../boost/variant/detail/move.hpp             |    53 +
 .../detail/multivisitors_cpp11_based.hpp      |   183 +
 .../detail/multivisitors_cpp14_based.hpp      |   142 +
 .../multivisitors_preprocessor_based.hpp      |   143 +
 .../boost/variant/detail/over_sequence.hpp    |    58 +
 .../boost/variant/detail/substitute.hpp       |   253 +
 .../boost/variant/detail/substitute_fwd.hpp   |    58 +
 .../boost/variant/detail/variant_io.hpp       |    95 +
 .../boost/variant/detail/visitation_impl.hpp  |   277 +
 .../boost_1_65_0/boost/variant/get.hpp        |   372 +
 .../boost/variant/multivisitors.hpp           |    32 +
 .../boost/variant/polymorphic_get.hpp         |   347 +
 .../boost/variant/recursive_variant.hpp       |   209 +
 .../boost/variant/recursive_wrapper.hpp       |   158 +
 .../boost/variant/recursive_wrapper_fwd.hpp   |   130 +
 .../boost/variant/static_visitor.hpp          |    95 +
 .../boost_1_65_0/boost/variant/variant.hpp    |  2493 ++
 .../boost/variant/variant_fwd.hpp             |   322 +
 .../boost/variant/visitor_ptr.hpp             |   117 +
 .../boost/version.hpp                         |     4 +-
 .../boost/visit_each.hpp                      |     0
 .../filesystem/src/codecvt_error_category.cpp |     0
 .../libs/filesystem/src/operations.cpp        |   165 +-
 .../libs/filesystem/src/path.cpp              |    99 +-
 .../libs/filesystem/src/path_traits.cpp       |     0
 .../libs/filesystem/src/portability.cpp       |     0
 .../libs/filesystem/src/unique_path.cpp       |     4 +-
 .../filesystem/src/utf8_codecvt_facet.cpp     |     0
 .../filesystem/src/windows_file_codecvt.cpp   |     0
 .../filesystem/src/windows_file_codecvt.hpp   |     0
 .../libs/program_options/src/cmdline.cpp      |    13 +-
 .../libs/program_options/src/config_file.cpp  |     0
 .../libs/program_options/src/convert.cpp      |     0
 .../src/options_description.cpp               |     0
 .../libs/program_options/src/parsers.cpp      |     0
 .../src/positional_options.cpp                |     0
 .../libs/program_options/src/split.cpp        |     0
 .../src/utf8_codecvt_facet.cpp                |     0
 .../program_options/src/value_semantic.cpp    |     0
 .../program_options/src/variables_map.cpp     |     7 +-
 .../libs/program_options/src/winmain.cpp      |     0
 .../libs/system/src/error_code.cpp            |     0
 4526 files changed, 223432 insertions(+), 47022 deletions(-)
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/align/align_down.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/align/align_down_forward.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/align/align_up.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/align/align_up_forward.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/align/aligned_delete_forward.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/align/alignment_of_forward.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/align/detail/align_cxx11.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/align/detail/align_down.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/align/detail/align_up.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/align/detail/assume_aligned.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/align/detail/assume_aligned_gcc.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/align/detail/assume_aligned_intel.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/align/detail/assume_aligned_msvc.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/align/detail/is_aligned.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/align/detail/is_alignment.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/align/is_aligned.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/align/is_aligned_forward.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/container/detail/algorithm.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/container/detail/hash_table.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/core/addressof.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/core/checked_delete.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/core/demangle.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/core/enable_if.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/core/explicit_operator_bool.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/core/ignore_unused.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/core/is_same.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/core/lightweight_test.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/core/lightweight_test_trait.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/core/no_exceptions_support.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/core/noncopyable.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/core/null_deleter.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/core/ref.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/core/scoped_enum.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/core/swap.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/core/typeinfo.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/core/underlying_type.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/exception/N3757.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/integer/common_factor_rt.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/intrusive/detail/to_raw_pointer.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/math/common_factor_ct.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/math/common_factor_rt.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_i0.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_i1.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_k0.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_k1.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/move/algo/detail/basic_op.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/move/algo/detail/bufferless_merge_sort.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/next_prior.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/optional.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/clone_allocator.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/detail/associative_ptr_container.hpp
 delete mode 100755 contrib/libboost/boost_1_62_0/boost/ptr_container/detail/default_deleter.hpp
 delete mode 100755 contrib/libboost/boost_1_62_0/boost/ptr_container/detail/is_convertible.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/detail/map_iterator.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/detail/meta_functions.hpp
 delete mode 100755 contrib/libboost/boost_1_62_0/boost/ptr_container/detail/move.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/detail/reversible_ptr_container.hpp
 delete mode 100755 contrib/libboost/boost_1_62_0/boost/ptr_container/detail/scoped_deleter.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/detail/serialize_ptr_map_adapter.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/detail/serialize_reversible_cont.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/detail/serialize_xml_names.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/detail/static_move_ptr.hpp
 delete mode 100755 contrib/libboost/boost_1_62_0/boost/ptr_container/detail/throw_exception.hpp
 delete mode 100755 contrib/libboost/boost_1_62_0/boost/ptr_container/detail/void_ptr_iterator.hpp
 delete mode 100755 contrib/libboost/boost_1_62_0/boost/ptr_container/exception.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/indirect_fun.hpp
 delete mode 100755 contrib/libboost/boost_1_62_0/boost/ptr_container/nullable.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_array.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_circular_buffer.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_container.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_deque.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_inserter.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_list.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_map.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_map_adapter.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_sequence_adapter.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_set.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_set_adapter.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_unordered_map.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_unordered_set.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_vector.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_array.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_circular_buffer.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_container.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_deque.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_list.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_map.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_set.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_unordered_map.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_unordered_set.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_vector.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/random/exponential_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/smart_ptr/allocate_shared_array.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/array_allocator.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/array_count_impl.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/array_traits.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/array_utility.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_if_array.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/smart_ptr/make_shared_array.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/smart_ptr/make_shared_object.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/smart_ptr/owner_less.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/system/windows_error.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/auto_unit_test.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/config.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/dataset.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/for_each_sample.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/generators.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/index_sequence.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/monomorphic.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/array.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/collection.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/generate.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/generators.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/generators/keywords.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/generators/random.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/generators/xrange.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/grid.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/initializer_list.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/join.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/sample_merge.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/singleton.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/zip.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/size.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/data/test_case.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/debug.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/debug_config.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/detail/config.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/detail/enable_warnings.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/detail/fwd_decl.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/detail/global_typedef.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/detail/log_level.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/detail/pp_variadic.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/detail/suppress_warnings.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/detail/throw_exception.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/detail/workaround.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/execution_monitor.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/floating_point_comparison.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/framework.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/impl/compiler_log_formatter.ipp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/impl/cpp_main.ipp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/impl/debug.ipp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/impl/decorator.ipp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/impl/execution_monitor.ipp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/impl/framework.ipp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/impl/junit_log_formatter.ipp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/impl/plain_report_formatter.ipp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/impl/progress_monitor.ipp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/impl/results_collector.ipp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/impl/results_reporter.ipp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/impl/test_main.ipp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/impl/test_tools.ipp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/impl/test_tree.ipp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/impl/unit_test_log.ipp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/impl/unit_test_main.ipp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/impl/unit_test_monitor.ipp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/impl/unit_test_parameters.ipp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/impl/xml_log_formatter.ipp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/impl/xml_report_formatter.ipp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/included/execution_monitor.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/included/prg_exec_monitor.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/included/test_exec_monitor.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/included/unit_test.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/included/unit_test_framework.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/minimal.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/output/compiler_log_formatter.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/output/junit_log_formatter.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/output/plain_report_formatter.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/output/xml_log_formatter.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/output/xml_report_formatter.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/output_test_stream.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/parameterized_test.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/predicate_result.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/prg_exec_monitor.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/progress_monitor.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/results_collector.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/results_reporter.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/test_case_template.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/test_exec_monitor.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/test_tools.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/assertion.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/assertion_result.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/collection_comparison_op.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/context.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/cstring_comparison_op.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/detail/bitwise_manip.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/detail/expression_holder.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/detail/fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/detail/indirections.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/detail/it_pair.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/detail/lexicographic_manip.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/detail/per_element_manip.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/detail/print_helper.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/detail/tolerance_manip.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/floating_point_comparison.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/fpc_op.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/fpc_tolerance.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/interface.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/old/impl.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/old/interface.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tools/output_test_stream.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tree/auto_registration.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tree/decorator.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tree/fixture.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tree/global_fixture.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tree/observer.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tree/test_case_counter.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tree/test_case_template.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tree/test_unit.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tree/traverse.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/tree/visitor.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/unit_test.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/unit_test_log.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/unit_test_log_formatter.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/unit_test_monitor.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/unit_test_parameters.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/unit_test_suite.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/algorithm.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/assign_op.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/basic_cstring/basic_cstring.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/basic_cstring/basic_cstring_fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/basic_cstring/bcs_char_traits.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/basic_cstring/compare.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/basic_cstring/io.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/class_properties.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/custom_manip.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/foreach.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/is_cstring.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/is_forward_iterable.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/iterator/input_iterator_facade.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/iterator/token_iterator.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/lazy_ostream.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/named_params.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/nullstream.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/rtti.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/runtime/argument.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/runtime/argument_factory.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/runtime/cla/argv_traverser.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/runtime/cla/parser.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/runtime/env/fetch.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/runtime/errors.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/runtime/finalize.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/runtime/fwd.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/runtime/modifier.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/runtime/parameter.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/setcolor.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/string_cast.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/trivial_singleton.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/wrap_stringstream.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/boost/test/utils/xml_printer.hpp
 delete mode 100644 contrib/libboost/boost_1_62_0/libs/test/src/compiler_log_formatter.cpp
 delete mode 100644 contrib/libboost/boost_1_62_0/libs/test/src/cpp_main.cpp
 delete mode 100644 contrib/libboost/boost_1_62_0/libs/test/src/debug.cpp
 delete mode 100644 contrib/libboost/boost_1_62_0/libs/test/src/decorator.cpp
 delete mode 100644 contrib/libboost/boost_1_62_0/libs/test/src/execution_monitor.cpp
 delete mode 100644 contrib/libboost/boost_1_62_0/libs/test/src/framework.cpp
 delete mode 100644 contrib/libboost/boost_1_62_0/libs/test/src/junit_log_formatter.cpp
 delete mode 100644 contrib/libboost/boost_1_62_0/libs/test/src/plain_report_formatter.cpp
 delete mode 100644 contrib/libboost/boost_1_62_0/libs/test/src/progress_monitor.cpp
 delete mode 100644 contrib/libboost/boost_1_62_0/libs/test/src/results_collector.cpp
 delete mode 100644 contrib/libboost/boost_1_62_0/libs/test/src/results_reporter.cpp
 delete mode 100644 contrib/libboost/boost_1_62_0/libs/test/src/test_main.cpp
 delete mode 100644 contrib/libboost/boost_1_62_0/libs/test/src/test_tools.cpp
 delete mode 100644 contrib/libboost/boost_1_62_0/libs/test/src/test_tree.cpp
 delete mode 100644 contrib/libboost/boost_1_62_0/libs/test/src/unit_test_log.cpp
 delete mode 100644 contrib/libboost/boost_1_62_0/libs/test/src/unit_test_main.cpp
 delete mode 100644 contrib/libboost/boost_1_62_0/libs/test/src/unit_test_monitor.cpp
 delete mode 100644 contrib/libboost/boost_1_62_0/libs/test/src/unit_test_parameters.cpp
 delete mode 100644 contrib/libboost/boost_1_62_0/libs/test/src/xml_log_formatter.cpp
 delete mode 100644 contrib/libboost/boost_1_62_0/libs/test/src/xml_report_formatter.cpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/LICENSE_1_0.txt (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/algorithm.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/clamp.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/cxx11/all_of.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/cxx11/any_of.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/cxx11/copy_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/cxx11/copy_n.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/cxx11/find_if_not.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/cxx11/iota.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/cxx11/is_partitioned.hpp (84%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/cxx11/is_permutation.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/cxx11/is_sorted.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/cxx11/none_of.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/cxx11/one_of.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/cxx11/partition_copy.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/cxx11/partition_point.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/cxx14/equal.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/cxx14/is_permutation.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/cxx14/mismatch.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/exclusive_scan.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/for_each_n.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/inclusive_scan.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/reduce.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/transform_exclusive_scan.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/transform_inclusive_scan.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/transform_reduce.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/gather.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/hex.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/is_palindrome.hpp (91%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/algorithm/is_partitioned_until.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/minmax.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/minmax_element.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/searching/boyer_moore.hpp (95%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/searching/boyer_moore_horspool.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/searching/detail/bm_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/searching/detail/debugging.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/searching/knuth_morris_pratt.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/sort_subrange.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/case_conv.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/classification.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/compare.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/concept.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/config.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/constants.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/detail/case_conv.hpp (94%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/detail/classification.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/detail/find_format.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/detail/find_format_all.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/detail/find_format_store.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/detail/find_iterator.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/detail/finder.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/detail/finder_regex.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/detail/formatter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/detail/formatter_regex.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/detail/predicate.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/detail/replace_storage.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/detail/sequence.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/detail/trim.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/detail/util.hpp (95%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/erase.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/find.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/find_format.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/find_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/finder.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/formatter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/iter_find.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/join.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/predicate.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/predicate_facade.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/regex.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/regex_find_format.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/replace.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/sequence_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/split.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/std/list_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/std/rope_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/std/slist_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/std/string_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/std_containers_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/trim.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/trim_all.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string/yes_no_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/algorithm/string_regex.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/align.hpp (60%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/align/align_down.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/align/align_up.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/aligned_alloc.hpp (88%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/aligned_allocator.hpp (77%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/aligned_allocator_adaptor.hpp (65%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/aligned_allocator_adaptor_forward.hpp (59%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/aligned_allocator_forward.hpp (56%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/aligned_delete.hpp (71%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/align/aligned_delete_forward.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/alignment_of.hpp (82%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/align/alignment_of_forward.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/assume_aligned.hpp (69%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/addressof.hpp (65%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/align.hpp (53%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/align/detail/align_cxx11.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/align/detail/align_down.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/align/detail/align_up.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/aligned_alloc.hpp (52%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/aligned_alloc_android.hpp (53%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/aligned_alloc_macos.hpp (63%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/aligned_alloc_msvc.hpp (54%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/aligned_alloc_posix.hpp (61%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/aligned_alloc_sunos.hpp (53%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/alignment_of.hpp (50%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/alignment_of_clang.hpp (62%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/alignment_of_codegear.hpp (63%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/alignment_of_cxx11.hpp (52%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/alignment_of_gcc.hpp (62%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/alignment_of_msvc.hpp (50%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/align/detail/assume_aligned.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/assume_aligned_clang.hpp (53%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/align/detail/assume_aligned_gcc.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/align/detail/assume_aligned_intel.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/align/detail/assume_aligned_msvc.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/element_type.hpp (60%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/integral_constant.hpp (70%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/align/detail/is_aligned.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/align/detail/is_alignment.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/is_alignment_constant.hpp (64%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/max_align.hpp (63%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/max_objects.hpp (64%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/max_size.hpp (62%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/align/detail/min_size.hpp (62%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/align/is_aligned.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/aligned_storage.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/any.hpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/array.hpp (82%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/assert.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/bind/apply.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/bind/arg.hpp (82%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/bind/bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/bind/bind_cc.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/bind/bind_mf2_cc.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/bind/bind_mf_cc.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/bind/bind_template.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/bind/make_adaptable.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/bind/mem_fn.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/bind/mem_fn_cc.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/bind/mem_fn_template.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/bind/mem_fn_vw.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/bind/placeholders.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/bind/protect.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/bind/storage.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/blank.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/blank_fwd.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/call_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/cerrno.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/checked_delete.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/compressed_pair.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/concept/assert.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/concept/detail/backward_compatibility.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/concept/detail/borland.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/concept/detail/concept_def.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/concept/detail/concept_undef.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/concept/detail/general.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/concept/detail/has_constraints.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/concept/detail/msvc.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/concept/requires.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/concept/usage.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/concept_check.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config.hpp (90%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/abi/borland_prefix.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/abi/borland_suffix.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/abi/msvc_prefix.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/abi/msvc_suffix.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/abi_prefix.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/abi_suffix.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/auto_link.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/borland.hpp (95%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/clang.hpp (92%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/codegear.hpp (94%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/comeau.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/common_edg.hpp (91%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/compaq_cxx.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/cray.hpp (98%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/config/compiler/diab.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/digitalmars.hpp (90%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/gcc.hpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/gcc_xml.hpp (88%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/greenhills.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/hp_acc.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/intel.hpp (96%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/kai.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/metrowerks.hpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/mpw.hpp (90%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/nvcc.hpp (57%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/pathscale.hpp (85%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/pgi.hpp (92%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/sgi_mipspro.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/sunpro_cc.hpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/vacpp.hpp (92%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/visualc.hpp (91%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/compiler/xlcpp.hpp (94%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/config/compiler/xlcpp_zos.hpp
 rename contrib/libboost/{boost_1_62_0/boost/config => boost_1_65_0/boost/config/detail}/posix_features.hpp (100%)
 rename contrib/libboost/{boost_1_62_0/boost/config => boost_1_65_0/boost/config/detail}/select_compiler_config.hpp (92%)
 rename contrib/libboost/{boost_1_62_0/boost/config => boost_1_65_0/boost/config/detail}/select_platform_config.hpp (94%)
 rename contrib/libboost/{boost_1_62_0/boost/config => boost_1_65_0/boost/config/detail}/select_stdlib_config.hpp (94%)
 rename contrib/libboost/{boost_1_62_0/boost/config => boost_1_65_0/boost/config/detail}/suffix.hpp (96%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/no_tr1/cmath.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/no_tr1/complex.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/no_tr1/functional.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/no_tr1/memory.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/no_tr1/utility.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/platform/aix.hpp (94%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/platform/amigaos.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/platform/beos.hpp (91%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/platform/bsd.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/platform/cloudabi.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/platform/cray.hpp (89%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/platform/cygwin.hpp (94%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/platform/haiku.hpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/platform/hpux.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/platform/irix.hpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/platform/linux.hpp (89%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/platform/macos.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/platform/qnxnto.hpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/platform/solaris.hpp (94%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/platform/symbian.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/platform/vms.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/platform/vxworks.hpp (91%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/platform/win32.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/config/platform/zos.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/requires_threads.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/stdlib/dinkumware.hpp (81%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/stdlib/libcomo.hpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/stdlib/libcpp.hpp (74%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/stdlib/libstdcpp3.hpp (85%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/stdlib/modena.hpp (91%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/stdlib/msl.hpp (91%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/stdlib/roguewave.hpp (96%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/stdlib/sgi.hpp (95%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/stdlib/stlport.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/stdlib/vacpp.hpp (91%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/config/stdlib/xlcpp_zos.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/user.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/config/warning_disable.hpp (100%)
 rename contrib/libboost/{boost_1_62_0/boost/detail => boost_1_65_0/boost/config}/workaround.hpp (81%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/adaptive_pool.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/allocator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/allocator_traits.hpp (85%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/container_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/deque.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/adaptive_node_pool.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/adaptive_node_pool_impl.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/addressof.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/advanced_insert_int.hpp (96%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/container/detail/algorithm.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/alloc_helpers.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/alloc_lib.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/allocation_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/allocator_version_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/auto_link.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/block_list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/block_slist.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/compare_functors.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/config_begin.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/config_end.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/construct_in_place.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/copy_move_algo.hpp (84%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/destroyers.hpp (96%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/dispatch_uses_allocator.hpp (87%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/dlmalloc.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/flat_tree.hpp (81%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/function_detector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/is_sorted.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0/boost/container/detail/to_raw_pointer.hpp => boost_1_65_0/boost/container/detail/iterator_to_raw_pointer.hpp} (70%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/iterators.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/math_functions.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/min_max.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/minimal_char_traits_header.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/mpl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/multiallocation_chain.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/mutex.hpp (96%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/next_capacity.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/node_alloc_holder.hpp (94%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/node_pool.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/node_pool_impl.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/pair.hpp (89%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/container/detail/pair_key_mapped_of_value.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/placement_new.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/pool_common.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/pool_common_alloc.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/pool_resource.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/singleton.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/std_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/transform_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/tree.hpp (94%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/type_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/value_init.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/variadic_templates_tools.hpp (87%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/version_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/detail/workaround.hpp (92%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/flat_map.hpp (75%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/flat_set.hpp (77%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/map.hpp (84%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/new_allocator.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/node_allocator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/node_handle.hpp (68%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/options.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/pmr/deque.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/pmr/flat_map.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/pmr/flat_set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/pmr/global_resource.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/pmr/list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/pmr/map.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/pmr/memory_resource.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/pmr/monotonic_buffer_resource.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/pmr/polymorphic_allocator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/pmr/pool_options.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/pmr/resource_adaptor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/pmr/set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/pmr/slist.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/pmr/small_vector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/pmr/stable_vector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/pmr/string.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/pmr/synchronized_pool_resource.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/pmr/unsynchronized_pool_resource.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/pmr/vector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/scoped_allocator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/scoped_allocator_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/set.hpp (77%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/slist.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/small_vector.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/stable_vector.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/static_vector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/string.hpp (83%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/throw_exception.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/uses_allocator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/uses_allocator_fwd.hpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/container/vector.hpp (95%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/cstdint.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/cstdlib.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/current_function.hpp (86%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/algorithm.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/allocator_utilities.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/atomic_count.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/atomic_redef_macros.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/atomic_undef_macros.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/basic_pointerbuf.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/binary_search.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/bitmask.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/call_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/catch_exceptions.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/compressed_pair.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/container_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/dynamic_bitset.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/endian.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/fenv.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/has_default_constructor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/identifier.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/indirect_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/interlocked.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/is_incrementable.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/is_sorted.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/is_xxx.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/lcast_precision.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/lightweight_main.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/lightweight_mutex.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/lightweight_test.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/lightweight_test_report.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/lightweight_thread.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/named_template_params.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/no_exceptions_support.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/numeric_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/ob_compressed_pair.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/quick_allocator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/reference_content.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/scoped_enum_emulation.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/select_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/sp_typeinfo.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/templated_streams.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/utf8_codecvt_facet.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/utf8_codecvt_facet.ipp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/GetCurrentProcess.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/GetCurrentThread.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/GetLastError.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/GetProcessTimes.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/GetThreadTimes.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/access_rights.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/apc.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/basic_types.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/character_code_conversion.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/condition_variable.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/config.hpp (86%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/critical_section.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/crypt.hpp (80%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/dbghelp.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/detail/winapi/debugapi.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/detail/cast_ptr.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/directory_management.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/dll.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/environment.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/error_codes.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/error_handling.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/event.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/file_management.hpp (90%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/file_mapping.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/get_current_process.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/get_current_process_id.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/get_current_thread.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/get_current_thread_id.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/get_last_error.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/get_process_times.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/get_system_directory.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/get_thread_times.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/handle_info.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/handles.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/heap_memory.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/init_once.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/jobs.hpp (86%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/limits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/local_memory.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/memory.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/mutex.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/overlapped.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/page_protection_flags.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/pipes.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/priority_class.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/process.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/security.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/semaphore.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/shell.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/show_window.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/srw_lock.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/detail/winapi/stack_backtrace.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/synchronization.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/system.hpp (90%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/thread.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/thread_pool.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/time.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/timers.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/tls.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/wait.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/detail/winapi/waitable_timer.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/detail/workaround.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/all.hpp (77%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/current_exception_cast.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/detail/clone_current_exception.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/detail/error_info_impl.hpp (60%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/detail/exception_ptr.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/detail/is_output_streamable.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/detail/object_hex_dump.hpp (99%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/exception/detail/shared_ptr.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/detail/type_info.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/diagnostic_information.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/enable_current_exception.hpp (72%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/enable_error_info.hpp (72%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/errinfo_api_function.hpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/errinfo_at_line.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/errinfo_errno.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/errinfo_file_handle.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/errinfo_file_name.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/errinfo_file_open_mode.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/errinfo_nested_exception.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/errinfo_type_info_name.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/error_info.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/exception.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/get_error_info.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/info.hpp (69%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/info_tuple.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/to_string.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/exception/to_string_stub.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/filesystem.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/filesystem/config.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/filesystem/convenience.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/filesystem/detail/macro_value.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/filesystem/detail/utf8_codecvt_facet.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/filesystem/exception.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/filesystem/fstream.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/filesystem/operations.hpp (96%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/filesystem/path.hpp (94%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/filesystem/path_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/filesystem/string_file.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function/detail/function_iterate.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function/detail/gen_maybe_include.pl (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function/detail/maybe_include.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function/detail/prologue.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function/function0.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function/function1.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function/function10.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function/function2.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function/function3.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function/function4.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function/function5.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function/function6.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function/function7.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function/function8.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function/function9.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function/function_base.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function/function_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function/function_template.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function/function_typeof.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function/gen_function_N.pl (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/function_equal.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/components.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/config/cc_names.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/config/compiler.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/config/config.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/class_transform.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity10_0.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity10_1.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity20_0.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity20_1.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity30_0.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity30_1.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity40_0.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity40_1.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity50_0.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity50_1.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/master.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/components_as_mpl_sequence.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity10_0.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity10_1.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity20_0.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity20_1.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity30_0.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity30_1.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity40_0.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity40_1.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity50_0.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity50_1.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/master.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/cv_traits.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/encoding/aliases_def.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/encoding/aliases_undef.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/encoding/def.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/encoding/undef.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_arity_loop.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_cc_loop/master.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_cc_loop/preprocessed.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_loop.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_retag_default_cc/master.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_retag_default_cc/preprocessed.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_tags/cc_tag.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_tags/master.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_tags/preprocessed.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_variate_loop/master.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_variate_loop/preprocessed.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/retag_default_cc.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity10_0.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity10_1.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity20_0.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity20_1.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity30_0.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity30_1.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity40_0.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity40_1.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity50_0.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity50_1.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/master.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/detail/to_sequence.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/function_arity.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/function_pointer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/function_reference.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/function_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/is_callable_builtin.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/is_function.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/is_function_pointer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/is_function_reference.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/is_member_function_pointer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/is_member_object_pointer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/is_member_pointer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/is_nonmember_callable_builtin.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/member_function_pointer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/member_object_pointer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/parameter_types.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/property_tags.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/function_types/result_type.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/functional/factory.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/functional/forward_adapter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/functional/hash.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/functional/hash/detail/float_functions.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/functional/hash/detail/hash_float.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/functional/hash/detail/limits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/functional/hash/extensions.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/functional/hash/hash.hpp (90%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/functional/hash/hash_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/functional/hash_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/functional/lightweight_forward_adapter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/functional/overloaded_function.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/functional/overloaded_function/config.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/functional/overloaded_function/detail/base.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/functional/overloaded_function/detail/function_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/functional/value_factory.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/append.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/area.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/assign.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/buffer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/centroid.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/clear.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/comparable_distance.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/convert.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/convex_hull.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/correct.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/covered_by.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/crosses.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/as_range.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/assign_box_corners.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/assign_indexed_point.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/assign_values.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/azimuth.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/buffer_inserter.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/buffer_policies.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/buffered_piece_collection.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/buffered_ring.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/get_piece_turns.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/line_line_intersection.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/parallel_continue.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/turn_in_original_visitor.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/turn_in_piece_visitor.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/calculate_null.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/calculate_sum.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/centroid/translating_transformer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/check_iterator_range.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/closest_feature/geometry_to_range.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/closest_feature/point_to_range.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/closest_feature/range_to_range.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/comparable_distance/implementation.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/comparable_distance/interface.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/convert_indexed_to_indexed.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/convert_point_to_point.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/counting.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/course.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/covered_by/implementation.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/covered_by/interface.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/direction_code.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/areal_areal.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/box_box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/implementation.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/interface.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/linear_areal.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/linear_linear.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/linear_segment_or_box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/multipoint_geometry.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/multirange_geometry.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/point_box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/point_geometry.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/point_point.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/segment_box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/backward_compatibility.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/box_to_box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/default_strategies.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/geometry_to_segment_or_box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/implementation.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/interface.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/is_comparable.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/iterator_selector.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/linear_or_areal_to_areal.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/linear_to_linear.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/multipoint_to_geometry.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/point_to_geometry.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/range_to_geometry_rtree.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/segment_to_box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/segment_to_segment.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/implementation.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/initialize.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/interface.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/intersects_antimeridian.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/linear.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/multipoint.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/point.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/range.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/range_of_boxes.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/segment.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/transform_units.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/equals/collect_vectors.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/equals/implementation.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/equals/interface.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/equals/point_point.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/implementation.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/indexed.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/interface.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/point.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/segment.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand_by_epsilon.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/extreme_points.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/for_each_range.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/get_left_turns.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/get_max_size.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/has_self_intersections.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/interior_iterator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersection/box_box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersection/implementation.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersection/interface.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersection/multi.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersects/implementation.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersects/interface.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/always_simple.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/areal.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/debug_print_boundary_points.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/failure_policy.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/implementation.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/interface.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/linear.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/multipoint.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/complement_graph.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/debug_complement_graph.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/debug_print_turns.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/debug_validity_phase.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/has_duplicates.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/has_invalid_coordinate.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/has_spikes.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/has_valid_self_turns.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/implementation.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/interface.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/is_acceptable_turn.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/linear.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/multipolygon.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/pointlike.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/polygon.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/ring.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/segment.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/max_interval_gap.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/multi_modify.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/multi_modify_with_predicate.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/multi_sum.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/normalize.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/not.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/num_distinct_consecutive_points.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/occupation_info.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlaps/implementation.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlaps/interface.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/add_rings.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/aggregate_operations.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/append_no_duplicates.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/append_no_dups_or_spikes.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/assign_parents.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/backtrack_check_si.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/check_enrich.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/clip_linestring.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/cluster_info.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/convert_ring.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/copy_segment_point.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/copy_segments.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/do_reverse.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/enrich_intersection_points.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/enrichment_info.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/follow.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/follow_linear_linear.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_intersection_points.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_relative_order.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_ring.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turn_info.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turn_info_for_endpoint.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turn_info_helpers.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turn_info_la.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turn_info_ll.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turns.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/handle_colocations.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/handle_self_turns.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/inconsistent_turns_exception.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/intersection_box_box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/intersection_insert.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/is_self_turn.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/less_by_segment_ratio.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/linear_linear.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/overlay.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/overlay_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/pointlike_linear.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/pointlike_pointlike.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/range_in_geometry.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/ring_properties.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/segment_identifier.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/select_rings.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/self_turn_points.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/sort_by_side.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/stream_info.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traversal.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traversal_info.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traversal_intersection_patterns.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traversal_ring_creator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traversal_switch_detector.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traverse.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/turn_info.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/visit_info.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/partition.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/point_is_spike_or_equal.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/point_on_border.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/recalculate.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/areal_areal.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/boundary_checker.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/de9im.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/follow_helpers.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/implementation.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/interface.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/less.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/linear_areal.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/linear_linear.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/multi_point_geometry.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/point_geometry.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/point_point.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/relate_impl.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/result.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/topology_check.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/turns.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relation/implementation.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relation/interface.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/ring_identifier.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sections/range_by_section.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sections/section_box_policies.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sections/section_functions.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sections/sectionalize.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/signed_size_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/single_geometry.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sub_range.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sweep.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/throw_on_empty_input.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/touches/implementation.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/touches/interface.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/turns/compare_turns.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/turns/debug_turn.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/turns/filter_continue_turns.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/turns/print_turns.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/turns/remove_duplicate_turns.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/within/implementation.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/within/interface.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/within/multi_point.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/within/point_in_geometry.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/within/within_no_turns.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/difference.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/disjoint.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/disjoint.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/distance.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/envelope.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/expand.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/is_simple.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/is_valid.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/distance.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/envelope.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/equals.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/expand.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/for_each.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/intersection.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/intersects.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/is_convex.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/is_empty.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/is_simple.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/is_valid.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/length.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/make.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/not_implemented.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/num_geometries.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/num_interior_rings.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/num_points.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/num_segments.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/overlaps.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/perimeter.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/point_on_surface.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/relate.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/relation.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/remove_spikes.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/reverse.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/simplify.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/sym_difference.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/touches.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/transform.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/union.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/unique.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/validity_failure_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/algorithms/within.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/arithmetic/arithmetic.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/arithmetic/cross_product.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/arithmetic/determinant.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/arithmetic/dot_product.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/arithmetic/normalize.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/formulas/andoyer_inverse.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/formulas/area_formulas.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/formulas/differential_quantities.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/formulas/eccentricity_sqr.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/formulas/flattening.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/formulas/geographic.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/formulas/gnomonic_intersection.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/formulas/gnomonic_spheroid.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/formulas/result_direct.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/formulas/result_inverse.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/formulas/sjoberg_intersection.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/formulas/spherical.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/formulas/thomas_direct.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/formulas/thomas_inverse.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/formulas/vertex_latitude.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/formulas/vertex_longitude.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/formulas/vincenty_direct.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/formulas/vincenty_inverse.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_array.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_fusion.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/hole_iterator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/holes_proxy.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/point.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/polygon.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/ring.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/ring_proxy.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/adjacent_filtered.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/filtered.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/reversed.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/sliced.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/strided.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/uniqued.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_tuple.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/c_array.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/std_array.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/std_pair_as_segment.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/box_concept.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/check.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/linestring_concept.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/multi_linestring_concept.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/multi_point_concept.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/multi_polygon_concept.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/point_concept.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/polygon_concept.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/ring_concept.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/segment_concept.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/geometries.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/helper_geometry.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/linestring.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/multi_linestring.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/multi_point.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/multi_polygon.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/point.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/point_xy.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/pointing_segment.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/polygon.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/linestring.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/multi_linestring.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/multi_point.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/multi_polygon.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/point.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/ring.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/segment.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/ring.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/segment.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometries/variant.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/geometry.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/adaptors/query.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/bounds.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/comparable_distance_centroid.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/comparable_distance_far.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/comparable_distance_near.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/content.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/diff_abs.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/intersection_content.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/is_valid.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/margin.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/minmaxdist.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/nth_element.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/path_intersection.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/segment_intersection.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/smallest_for_indexable.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/sum_for_indexable.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/union_content.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/assert.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/bounded_view.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/config_begin.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/config_end.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/distance_predicates.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/exception.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/is_bounding_geometry.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/is_indexable.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/meta.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/predicates.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/adaptors.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/iterators.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/kmeans/kmeans.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/kmeans/split.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/linear/linear.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/linear/redistribute_elements.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/concept.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/node.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/node_elements.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/pairs.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/scoped_deallocator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/subtree_destroyer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/variant_dynamic.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/variant_static.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/variant_visitor.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/weak_dynamic.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/weak_static.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/weak_visitor.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/options.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/pack_create.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/quadratic/quadratic.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/quadratic/redistribute_elements.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/query_iterators.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/rstar/choose_next_node.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/rstar/insert.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/rstar/redistribute_elements.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/rstar/rstar.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/are_boxes_ok.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/are_counts_ok.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/are_levels_ok.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/gl_draw.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/print.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/statistics.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/view.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/children_box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/copy.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/count.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/destroy.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/distance_query.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/insert.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/is_leaf.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/iterator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/remove.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/spatial_query.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/serialization.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/tags.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/translator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/tuples.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/utilities.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/varray.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/detail/varray_detail.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/distance_predicates.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/equal_to.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/indexable.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/inserter.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/parameters.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/predicates.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/index/rtree.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/io/dsv/write.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/io/io.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/io/svg/svg_mapper.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/io/svg/write.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/io/svg/write_svg.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/io/svg/write_svg_multi.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/detail/prefix.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/detail/wkt_multi.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/read.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/stream.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/wkt.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/write.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/iterators/base.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/iterators/closing_iterator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/iterators/concatenate_iterator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/point_iterator/inner_range_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/point_iterator/iterator_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/point_iterator/value_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/segment_iterator/iterator_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/segment_iterator/range_segment_iterator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/segment_iterator/value_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/iterators/dispatch/point_iterator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/iterators/dispatch/segment_iterator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/iterators/ever_circling_iterator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/iterators/flatten_iterator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/iterators/has_one_element.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/iterators/point_iterator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/iterators/point_reverse_iterator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/iterators/segment_iterator.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/append.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/area.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/centroid.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/clear.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/convert.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/correct.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/covered_by.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/extreme_points.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/for_each_range.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/modify.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/modify_with_predicate.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/multi_sum.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/overlay/copy_segment_point.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/overlay/copy_segments.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/overlay/get_ring.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/overlay/get_turns.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/overlay/self_turn_points.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/point_on_border.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/sections/range_by_section.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/sections/sectionalize.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/disjoint.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/distance.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/envelope.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/equals.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/for_each.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/intersection.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/length.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/num_geometries.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/num_interior_rings.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/num_points.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/perimeter.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/remove_spikes.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/reverse.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/simplify.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/transform.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/unique.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/within.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/concepts/check.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/concepts/multi_linestring_concept.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/concepts/multi_point_concept.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/concepts/multi_polygon_concept.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/multi_geometries.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/multi_linestring.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/multi_point.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/multi_polygon.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/register/multi_linestring.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/register/multi_point.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/register/multi_polygon.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/io/dsv/write.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/io/wkt/detail/prefix.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/io/wkt/read.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/io/wkt/wkt.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/io/wkt/write.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/multi.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/strategies/cartesian/centroid_average.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/views/detail/range_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/policies/compare.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/policies/disjoint_interrupt_policy.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/policies/is_valid/default_policy.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/policies/is_valid/failing_reason_policy.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/policies/is_valid/failure_type_policy.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/policies/predicate_based_interrupt_policy.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/policies/relate/direction.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/policies/relate/intersection_points.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/policies/relate/intersection_ratios.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/policies/relate/tupled.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/get_rescale_policy.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/no_rescale_policy.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/rescale_policy.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/robust_point_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/robust_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/segment_ratio.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/segment_ratio_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/buffer_distance_asymmetric.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/buffer_distance_symmetric.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/hull_graham_andrew.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/point_in_box_by_side.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/point_in_point.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/point_in_poly_oriented_winding.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/point_in_poly_winding.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/simplify_douglas_peucker.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/area.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/azimuth.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/buffer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/area_surveyor.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/azimuth.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/box_in_box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_end_flat.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_end_round.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_join_miter.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_join_round.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_join_round_by_divide.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_point_circle.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_point_square.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_side_straight.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/centroid_average.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/centroid_bashein_detmer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/centroid_weighted_length.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/disjoint_segment_box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/distance_projected_point.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/distance_projected_point_ax.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/distance_pythagoras.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/distance_pythagoras_box_box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/distance_pythagoras_point_box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/envelope_segment.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/intersection.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/point_in_box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/point_in_poly_crossings_multiply.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/point_in_poly_franklin.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/side_by_triangle.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/side_of_intersection.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/centroid.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/comparable_distance_result.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/compare.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/area_concept.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/centroid_concept.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/convex_hull_concept.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/distance_concept.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/segment_intersect_concept.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/simplify_concept.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/within_concept.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/convex_hull.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/covered_by.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/default_area_result.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/default_comparable_distance_result.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/default_distance_result.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/default_length_result.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/default_strategy.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/disjoint.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/distance.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/distance_result.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/envelope.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/area.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/azimuth.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/disjoint_segment_box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/distance.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/distance_andoyer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/distance_thomas.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/distance_vincenty.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/envelope_segment.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/intersection.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/intersection_elliptic.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/mapping_ssf.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/parameters.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/side.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/side_andoyer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/side_thomas.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/side_vincenty.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/intersection.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/intersection_result.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/intersection_strategies.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/relate.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/side.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/side_info.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/area.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/azimuth.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/compare_circular.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/disjoint_segment_box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/distance_cross_track.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/distance_cross_track_point_box.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/distance_haversine.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/envelope_segment.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/intersection.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/side_by_cross_track.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/ssf.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/strategies.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/strategy_transform.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/tags.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/transform.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/transform/inverse_transformer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/transform/map_transformer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/transform/matrix_transformers.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/strategies/within.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/add_const_if_c.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/bare_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/calculation_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/closure_as_bool.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/combine_if.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/compress_variant.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/condition.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/coordinate_cast.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/for_each_coordinate.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/has_infinite_coordinate.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/has_nan_coordinate.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/has_non_finite_coordinate.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/math.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/normalize_spheroidal_box_coordinates.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/normalize_spheroidal_coordinates.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/order_as_direction.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/parameter_type_of.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/promote_floating_point.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/promote_integral.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/range.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/rational.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/readme.txt
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/select_calculation_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/select_coordinate_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/select_most_precise.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/util/transform_variant.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/views/box_view.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/views/closeable_view.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/views/detail/boundary_view.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/views/detail/boundary_view/implementation.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/views/detail/boundary_view/interface.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/views/detail/indexed_point_view.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/views/detail/normalized_view.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/views/detail/points_view.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/views/detail/range_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/views/detail/two_dimensional_view.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/views/identity_view.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/views/reversible_view.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/views/segment_view.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/get_pointer.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/integer.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/integer/common_factor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/integer/common_factor_ct.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/integer/common_factor_rt.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/integer/integer_log2.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/integer/integer_mask.hpp (94%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/integer/static_log2.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/integer/static_min_max.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/integer_fwd.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/integer_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/any_hook.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/avl_set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/avl_set_hook.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/avltree.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/avltree_algorithms.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/bs_set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/bs_set_hook.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/bstree.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/bstree_algorithms.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/circular_list_algorithms.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/circular_slist_algorithms.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/derivation_value_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/algo_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/algorithm.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/any_node_and_algorithms.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/array_initializer.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/assert.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/avltree_node.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/bstree_algorithms_base.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/common_slist_algorithms.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/config_begin.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/config_end.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/default_header_holder.hpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/ebo_functor_holder.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/empty_node_checker.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/equal_to_value.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/exception_disposer.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/function_detector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/generic_hook.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/get_value_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/has_member_function_callable_with.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/hashtable_node.hpp (88%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/hook_traits.hpp (94%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/iiterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/is_stateful_value_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/iterator.hpp (55%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/key_nodeptr_comp.hpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/list_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/list_node.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/math.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/minimal_less_equal_header.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/minimal_pair_header.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/mpl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/node_cloner_disposer.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/node_holder.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/node_to_value.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/parent_from_member.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/rbtree_node.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/reverse_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/simple_disposers.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/size_holder.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/slist_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/slist_node.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/std_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/transform_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/tree_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/tree_node.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/tree_value_compare.hpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/uncast.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/detail/workaround.hpp (90%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/hashtable.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/intrusive_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/linear_slist_algorithms.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/link_mode.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/list_hook.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/member_value_traits.hpp (95%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/options.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/pack_options.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/parent_from_member.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/pointer_plus_bits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/pointer_rebind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/pointer_traits.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/priority_compare.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/rbtree.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/rbtree_algorithms.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/set_hook.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/sg_set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/sgtree.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/sgtree_algorithms.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/slist.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/slist_hook.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/splay_set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/splaytree.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/splaytree_algorithms.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/treap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/treap_algorithms.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/treap_set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/trivial_value_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/unordered_set.hpp (94%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive/unordered_set_hook.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/intrusive_ptr.hpp (83%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/io/detail/quoted_manip.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/io/ios_state.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/io_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/is_placeholder.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/iterator/advance.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/counting_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/detail/any_conversion_eater.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/detail/config_def.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/detail/config_undef.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/detail/enable_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/detail/facade_iterator_category.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/detail/minimum_category.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/iterator/distance.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/filter_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/function_input_iterator.hpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/indirect_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/interoperable.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/is_lvalue_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/is_readable_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/iterator_adaptor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/iterator_archetypes.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/iterator_categories.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/iterator_concepts.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/iterator_facade.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/iterator_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/minimum_category.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/new_iterator_tests.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/permutation_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/reverse_iterator.hpp (90%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/transform_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator/zip_iterator.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/iterator_adaptors.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/lexical_cast.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/lexical_cast/bad_lexical_cast.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/lexical_cast/detail/converter_lexical.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/lexical_cast/detail/converter_lexical_streams.hpp (94%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/lexical_cast/detail/converter_numeric.hpp (85%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/lexical_cast/detail/inf_nan.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/lexical_cast/detail/is_character.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/lexical_cast/detail/lcast_char_constants.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/lexical_cast/detail/lcast_unsigned_converters.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/lexical_cast/detail/widest_char.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/lexical_cast/lexical_cast_old.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/lexical_cast/try_lexical_convert.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/limits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/make_shared.hpp (82%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/bindings/detail/big_digamma.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/bindings/detail/big_lanczos.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/bindings/e_float.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/bindings/mpfr.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/bindings/mpreal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/bindings/rr.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/common_factor.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/math/common_factor_ct.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/math/common_factor_rt.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/complex.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/complex/acos.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/complex/acosh.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/complex/asin.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/complex/asinh.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/complex/atan.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/complex/atanh.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/complex/details.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/complex/fabs.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/concepts/distributions.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/concepts/real_concept.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/concepts/real_type_concept.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/concepts/std_real_concept.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/constants/calculate_constants.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/constants/constants.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/constants/info.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/cstdfloat/cstdfloat_cmath.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/cstdfloat/cstdfloat_complex.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/cstdfloat/cstdfloat_complex_std.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/cstdfloat/cstdfloat_iostream.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/cstdfloat/cstdfloat_limits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/cstdfloat/cstdfloat_types.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/arcsine.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/bernoulli.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/beta.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/binomial.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/cauchy.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/chi_squared.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/complement.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/detail/common_error_handling.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/detail/derived_accessors.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/detail/generic_mode.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/detail/generic_quantile.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/detail/hypergeometric_cdf.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/detail/hypergeometric_pdf.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/detail/hypergeometric_quantile.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/detail/inv_discrete_quantile.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/exponential.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/extreme_value.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/find_location.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/find_scale.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/fisher_f.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/gamma.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/geometric.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/hyperexponential.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/hypergeometric.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/inverse_chi_squared.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/inverse_gamma.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/inverse_gaussian.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/laplace.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/logistic.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/lognormal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/negative_binomial.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/non_central_beta.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/non_central_chi_squared.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/non_central_f.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/non_central_t.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/normal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/pareto.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/poisson.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/rayleigh.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/skew_normal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/students_t.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/triangular.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/uniform.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/distributions/weibull.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/math/interpolators/barycentric_rational.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/math/interpolators/cubic_b_spline.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/math/interpolators/detail/barycentric_rational_detail.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/math/interpolators/detail/cubic_b_spline_detail.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/octonion.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/policies/error_handling.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/policies/policy.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/math/quadrature/trapezoidal.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/quaternion.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/acosh.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/airy.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/asinh.hpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/atanh.hpp (94%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/bernoulli.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/bessel.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/bessel_prime.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/beta.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/binomial.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/cbrt.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/cos_pi.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/airy_ai_bi_zero.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/bernoulli_details.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/bessel_derivatives_linear.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_i0.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_i1.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/bessel_ik.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/bessel_j0.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/bessel_j1.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/bessel_jn.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/bessel_jy.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/bessel_jy_asym.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/bessel_jy_derivatives_asym.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/bessel_jy_derivatives_series.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/bessel_jy_series.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/bessel_jy_zero.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_k0.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_k1.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/bessel_kn.hpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/bessel_y0.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/bessel_y1.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/bessel_yn.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/erf_inv.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/fp_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/gamma_inva.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/ibeta_inv_ab.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/ibeta_inverse.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/iconv.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/igamma_inverse.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/igamma_large.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/lanczos_sse2.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/lgamma_small.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/polygamma.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/round_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/t_distribution_inv.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/unchecked_bernoulli.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/detail/unchecked_factorial.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/digamma.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/ellint_1.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/ellint_2.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/ellint_3.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/ellint_d.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/ellint_rc.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/ellint_rd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/ellint_rf.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/ellint_rg.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/ellint_rj.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/erf.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/expint.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/expm1.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/factorials.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/fpclassify.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/gamma.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/hankel.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/hermite.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/heuman_lambda.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/hypot.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/jacobi_elliptic.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/jacobi_zeta.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/laguerre.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/lanczos.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/legendre.hpp (51%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/math/special_functions/legendre_stieltjes.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/log1p.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/math_fwd.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/modf.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/next.hpp (50%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/nonfinite_num_facets.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/owens_t.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/polygamma.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/pow.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/powm1.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/prime.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/relative_difference.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/round.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/sign.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/sin_pi.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/sinc.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/sinhc.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/spherical_harmonic.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/sqrt1pm1.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/trigamma.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/trunc.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/ulp.hpp (57%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/special_functions/zeta.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/big_constant.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/config.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/convert_from_string.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner1_10.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner1_11.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner1_12.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner1_13.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner1_14.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner1_15.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner1_16.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner1_17.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner1_18.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner1_19.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner1_2.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner1_20.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner1_3.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner1_4.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner1_5.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner1_6.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner1_7.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner1_8.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner1_9.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner2_10.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner2_11.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner2_12.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner2_13.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner2_14.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner2_15.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner2_16.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner2_17.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner2_18.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner2_19.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner2_2.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner2_20.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner2_3.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner2_4.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner2_5.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner2_6.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner2_7.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner2_8.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner2_9.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner3_10.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner3_11.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner3_12.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner3_13.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner3_14.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner3_15.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner3_16.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner3_17.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner3_18.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner3_19.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner3_2.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner3_20.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner3_3.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner3_4.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner3_5.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner3_6.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner3_7.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner3_8.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/polynomial_horner3_9.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner1_10.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner1_11.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner1_12.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner1_13.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner1_14.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner1_15.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner1_16.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner1_17.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner1_18.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner1_19.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner1_2.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner1_20.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner1_3.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner1_4.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner1_5.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner1_6.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner1_7.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner1_8.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner1_9.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner2_10.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner2_11.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner2_12.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner2_13.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner2_14.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner2_15.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner2_16.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner2_17.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner2_18.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner2_19.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner2_2.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner2_20.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner2_3.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner2_4.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner2_5.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner2_6.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner2_7.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner2_8.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner2_9.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner3_10.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner3_11.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner3_12.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner3_13.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner3_14.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner3_15.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner3_16.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner3_17.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner3_18.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner3_19.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner3_2.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner3_20.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner3_3.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner3_4.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner3_5.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner3_6.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner3_7.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner3_8.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/detail/rational_horner3_9.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/fraction.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/minima.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/polynomial.hpp (98%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/math/tools/polynomial_gcd.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/precision.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/promotion.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/rational.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/real_cast.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/roots.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/series.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/stats.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/toms748_solve.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/tuple.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/user.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tools/workaround.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tr1.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/math/tr1_c_macros.ipp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mem_fn.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/adl_move_swap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/algo/adaptive_merge.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/algo/adaptive_sort.hpp (85%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/algo/detail/adaptive_sort_merge.hpp (60%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/move/algo/detail/basic_op.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/algo/detail/insertion_sort.hpp (84%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/algo/detail/merge.hpp (88%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/algo/detail/merge_sort.hpp (92%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/algo/move.hpp (97%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/move/algo/predicate.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/move/algo/unique.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/algorithm.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/core.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/default_delete.hpp (96%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/detail/config_begin.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/detail/config_end.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/detail/destruct_n.hpp (91%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/detail/fwd_macros.hpp (98%)
 rename contrib/libboost/{boost_1_62_0/boost/container => boost_1_65_0/boost/move}/detail/iterator_to_raw_pointer.hpp (51%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/detail/iterator_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/detail/meta_utils.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/detail/meta_utils_core.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/detail/move_helpers.hpp (79%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/detail/placement_new.hpp (100%)
 rename contrib/libboost/{boost_1_62_0/boost/intrusive => boost_1_65_0/boost/move}/detail/pointer_element.hpp (87%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/detail/reverse_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/detail/std_ns_begin.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/detail/std_ns_end.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/move/detail/to_raw_pointer.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/detail/type_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/detail/unique_ptr_meta_utils.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/detail/workaround.hpp (92%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/make_unique.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/move.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/unique_ptr.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/utility.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/move/utility_core.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/O1_size.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/O1_size_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/accumulate.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/advance.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/advance_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/alias.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/always.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/and.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/apply.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/apply_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/apply_wrap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/arg.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/arg_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/arithmetic.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/as_sequence.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/assert.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/at.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/at_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/O1_size_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/adl_barrier.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/advance_backward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/advance_forward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/apply_1st.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/arg_typedef.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/arithmetic_op.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/arity.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/arity_spec.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/at_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/back_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/basic_bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/begin_end_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/clear_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/common_name_wknd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/comparison_op.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/adl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/arrays.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/bcc.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/compiler.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/ctps.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/dependent_nttp.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/dtp.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/eti.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/forwarding.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/gcc.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/gpu.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/has_apply.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/has_xxx.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/integral.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/intel.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/lambda.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/msvc.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/msvc_typename.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/nttp.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/operators.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/overload_resolution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/pp_counter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/preprocessor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/static_constant.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/ttp.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/typeof.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/use_preprocessed.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/config/workaround.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/contains_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/count_args.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/count_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/empty_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/erase_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/erase_key_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/filter_iter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/find_if_pred.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/fold_impl_body.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/fold_op.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/fold_pred.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/front_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/full_lambda.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/has_apply.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/has_begin.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/has_key_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/has_rebind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/has_size.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/has_tag.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/has_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/include_preprocessed.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/insert_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/insert_range_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/inserter_algorithm.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/integral_wrapper.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/is_msvc_eti_arg.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/iter_apply.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/iter_fold_if_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/iter_push_front.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/joint_iter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/lambda_arity_param.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/lambda_no_ctps.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/lambda_spec.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/lambda_support.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/largest_int.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/logical_op.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/msvc_dtw.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/msvc_eti_base.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/msvc_is_class.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/msvc_never_true.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/msvc_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/na.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/na_assert.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/na_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/na_spec.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/nested_type_wknd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/nttp_decl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/numeric_cast_utils.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/numeric_op.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/order_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/overload_names.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/partition_op.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/pop_back_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/pop_front_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/advance_backward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/advance_forward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/and.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/apply.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/apply_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/apply_wrap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/arg.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/basic_bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/bind_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/bitand.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/bitor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/bitxor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/deque.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/divides.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/full_lambda.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/greater.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/greater_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/inherit.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/iter_fold_if_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/lambda_no_ctps.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/less.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/less_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/list_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/map.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/minus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/modulus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/not_equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/or.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/placeholders.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/plus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/quote.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/reverse_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/reverse_iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/set_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/shift_left.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/shift_right.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/template_arity.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/times.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/unpack_args.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/vector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc/vector_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/advance_backward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/advance_forward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/and.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/apply.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/apply_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/apply_wrap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/arg.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/basic_bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/bind_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/bitand.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/bitor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/bitxor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/deque.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/divides.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/full_lambda.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/greater.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/greater_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/inherit.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/iter_fold_if_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/lambda_no_ctps.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/less.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/less_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/list_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/map.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/minus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/modulus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/not_equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/or.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/placeholders.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/plus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/quote.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/reverse_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/reverse_iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/set_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/shift_left.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/shift_right.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/template_arity.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/times.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/unpack_args.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/vector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc551/vector_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/advance_backward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/advance_forward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/and.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/apply.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/apply_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/apply_wrap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/arg.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/basic_bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/bind_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/bitand.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/bitor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/bitxor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/deque.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/divides.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/full_lambda.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/greater.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/greater_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/inherit.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/iter_fold_if_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/lambda_no_ctps.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/less.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/less_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/list_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/map.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/minus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/modulus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/not_equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/or.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/placeholders.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/plus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/quote.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/reverse_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/reverse_iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/set_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/shift_left.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/shift_right.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/template_arity.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/times.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/unpack_args.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/vector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/bcc_pre590/vector_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/advance_backward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/advance_forward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/and.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/apply.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/apply_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/apply_wrap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/arg.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/basic_bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/bind_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/bitand.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/bitor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/bitxor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/deque.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/divides.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/full_lambda.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/greater.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/greater_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/inherit.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/iter_fold_if_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/lambda_no_ctps.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/less.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/less_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/list_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/map.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/minus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/modulus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/not_equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/or.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/placeholders.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/plus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/quote.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/reverse_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/reverse_iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/set_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/shift_left.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/shift_right.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/template_arity.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/times.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/unpack_args.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/vector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/dmc/vector_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/and.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/apply.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/arg.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/basic_bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/bitand.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/bitor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/bitxor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/deque.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/divides.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/greater.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/inherit.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/lambda_no_ctps.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/less.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/less_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/list_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/map.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/minus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/modulus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/or.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/plus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/quote.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/reverse_iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/set_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/shift_left.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/shift_right.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/times.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/unpack_args.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/vector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/gcc/vector_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/advance_backward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/advance_forward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/and.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/apply.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/apply_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/apply_wrap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/arg.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/basic_bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/bind_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/bitand.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/bitor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/bitxor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/deque.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/divides.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/full_lambda.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/greater.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/greater_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/inherit.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/iter_fold_if_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/lambda_no_ctps.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/less.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/less_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/list_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/map.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/minus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/modulus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/not_equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/or.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/placeholders.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/plus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/quote.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/reverse_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/reverse_iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/set_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/shift_left.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/shift_right.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/template_arity.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/times.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/unpack_args.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/vector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc60/vector_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/advance_backward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/advance_forward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/and.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/apply.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/apply_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/apply_wrap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/arg.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/basic_bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/bind_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/bitand.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/bitor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/bitxor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/deque.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/divides.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/full_lambda.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/greater.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/greater_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/inherit.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/iter_fold_if_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/lambda_no_ctps.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/less.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/less_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/list_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/map.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/minus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/modulus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/not_equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/or.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/placeholders.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/plus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/quote.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/reverse_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/reverse_iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/set_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/shift_left.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/shift_right.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/template_arity.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/times.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/unpack_args.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/vector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/msvc70/vector_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/advance_backward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/advance_forward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/and.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/apply.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/apply_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/apply_wrap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/arg.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/basic_bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/bind_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/bitand.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/bitor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/bitxor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/deque.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/divides.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/full_lambda.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/greater.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/greater_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/inherit.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/iter_fold_if_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/lambda_no_ctps.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/less.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/less_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/list_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/map.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/minus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/modulus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/not_equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/or.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/placeholders.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/plus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/quote.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/reverse_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/reverse_iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/set_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/shift_left.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/shift_right.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/template_arity.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/times.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/unpack_args.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/vector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/mwcw/vector_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/advance_backward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/advance_forward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/and.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/apply.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/apply_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/apply_wrap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/arg.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/basic_bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/bind_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/bitand.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/bitor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/bitxor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/deque.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/divides.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/full_lambda.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/greater.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/greater_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/inherit.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/iter_fold_if_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/lambda_no_ctps.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/less.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/less_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/list_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/map.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/minus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/modulus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/not_equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/or.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/placeholders.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/plus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/quote.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/reverse_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/reverse_iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/set_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/shift_left.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/shift_right.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/template_arity.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/times.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/unpack_args.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/vector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ctps/vector_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/advance_backward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/advance_forward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/and.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/apply.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/apply_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/apply_wrap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/arg.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/basic_bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/bind_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/bitand.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/bitor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/bitxor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/deque.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/divides.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/full_lambda.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/greater.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/greater_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/inherit.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_if_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/lambda_no_ctps.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/less.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/less_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/list_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/map.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/minus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/modulus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/not_equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/or.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/placeholders.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/plus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/quote.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/reverse_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/reverse_iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/set_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/shift_left.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/shift_right.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/template_arity.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/times.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/unpack_args.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/vector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/no_ttp/vector_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/advance_backward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/advance_forward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/and.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/apply.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/apply_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/apply_wrap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/arg.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/basic_bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/bind_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/bitand.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/bitor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/bitxor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/deque.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/divides.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/full_lambda.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/greater.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/greater_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/inherit.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/iter_fold_if_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/lambda_no_ctps.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/less.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/less_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/list_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/map.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/minus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/modulus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/not_equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/or.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/placeholders.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/plus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/quote.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/reverse_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/reverse_iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/set_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/shift_left.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/shift_right.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/template_arity.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/times.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/unpack_args.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/vector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessed/plain/vector_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessor/add.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessor/def_params_tail.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessor/default_params.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessor/enum.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessor/ext_params.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessor/filter_params.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessor/is_seq.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessor/params.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessor/partial_spec_params.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessor/range.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessor/repeat.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessor/sub.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessor/token_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/preprocessor/tuple.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/ptr_to_ref.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/push_back_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/push_front_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/range_c/O1_size.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/range_c/back.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/range_c/empty.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/range_c/front.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/range_c/iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/range_c/size.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/range_c/tag.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/reverse_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/reverse_fold_impl_body.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/reverse_iter_fold_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/sequence_wrapper.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/shift_op.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/single_element_iter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/size_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/sort_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/static_cast.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/template_arity.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/template_arity_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/test.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/test/assert.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/test/data.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/test/test_case.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/traits_lambda_spec.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/transform_iter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/type_wrapper.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/unwrap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/value_wknd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/aux_/yes_no.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/back.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/back_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/back_inserter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/base.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/begin.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/begin_end.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/begin_end_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/bind_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/bitand.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/bitor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/bitwise.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/bitxor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/bool.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/bool_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/char.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/char_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/clear.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/clear_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/comparison.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/contains.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/contains_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/copy.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/copy_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/count.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/count_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/count_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/deque.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/deref.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/distance.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/distance_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/divides.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/empty.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/empty_base.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/empty_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/empty_sequence.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/end.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/erase.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/erase_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/erase_key.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/erase_key_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/eval_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/filter_view.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/find.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/find_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/fold.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/for_each.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/front.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/front_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/front_inserter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/greater.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/greater_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/has_key.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/has_key_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/has_xxx.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/identity.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/index_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/index_of.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/inherit.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/inherit_linearly.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/insert.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/insert_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/insert_range.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/insert_range_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/inserter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/int.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/int_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/integral_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/integral_c_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/integral_c_tag.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/is_placeholder.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/is_sequence.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/iter_fold.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/iter_fold_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/iterator_category.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/iterator_range.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/iterator_tags.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/joint_view.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/key_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/key_type_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/lambda.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/lambda_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/less.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/less_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/limits/arity.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/limits/list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/limits/map.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/limits/set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/limits/string.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/limits/unrolling.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/limits/vector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/O1_size.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/begin_end.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/clear.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/empty.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/front.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/include_preprocessed.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/item.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/numbered.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/numbered_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/pop_front.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/preprocessed/plain/list10.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/preprocessed/plain/list10_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/preprocessed/plain/list20.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/preprocessed/plain/list20_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/preprocessed/plain/list30.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/preprocessed/plain/list30_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/preprocessed/plain/list40.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/preprocessed/plain/list40_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/preprocessed/plain/list50.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/preprocessed/plain/list50_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/push_back.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/push_front.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/size.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/aux_/tag.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/list0.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/list0_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/list10.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/list10_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/list20.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/list20_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/list30.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/list30_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/list40.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/list40_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/list50.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list/list50_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/list_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/logical.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/long.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/long_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/lower_bound.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/at_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/begin_end_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/clear_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/contains_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/empty_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/erase_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/erase_key_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/has_key_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/include_preprocessed.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/insert_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/insert_range_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/item.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/key_type_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/map0.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/numbered.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/preprocessed/no_ctps/map10.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/preprocessed/no_ctps/map20.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/preprocessed/no_ctps/map30.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/preprocessed/no_ctps/map40.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/preprocessed/no_ctps/map50.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/preprocessed/plain/map10.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/preprocessed/plain/map20.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/preprocessed/plain/map30.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/preprocessed/plain/map40.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/preprocessed/plain/map50.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/preprocessed/typeof_based/map10.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/preprocessed/typeof_based/map20.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/preprocessed/typeof_based/map30.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/preprocessed/typeof_based/map40.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/preprocessed/typeof_based/map50.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/size_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/tag.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/aux_/value_type_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/map0.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/map10.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/map20.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/map30.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/map40.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/map/map50.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/math/fixed_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/math/is_even.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/math/rational_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/max.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/max_element.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/min.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/min_element.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/min_max.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/minus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/modulus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/multiplies.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/multiset/aux_/count_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/multiset/aux_/insert_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/multiset/aux_/item.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/multiset/aux_/multiset0.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/multiset/aux_/tag.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/multiset/multiset0.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/negate.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/next.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/next_prior.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/not.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/not_equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/numeric_cast.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/or.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/order.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/order_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/pair.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/pair_view.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/partition.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/placeholders.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/plus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/pop_back.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/pop_back_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/pop_front.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/pop_front_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/print.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/prior.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/protect.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/push_back.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/push_back_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/push_front.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/push_front_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/quote.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/range_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/remove.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/remove_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/replace.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/replace_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/reverse.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/reverse_fold.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/reverse_iter_fold.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/same_as.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/sequence_tag.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/sequence_tag_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/at_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/begin_end_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/clear_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/empty_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/erase_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/erase_key_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/has_key_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/include_preprocessed.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/insert_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/insert_range_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/item.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/key_type_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/numbered.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/numbered_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/preprocessed/plain/set10.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/preprocessed/plain/set10_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/preprocessed/plain/set20.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/preprocessed/plain/set20_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/preprocessed/plain/set30.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/preprocessed/plain/set30_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/preprocessed/plain/set40.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/preprocessed/plain/set40_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/preprocessed/plain/set50.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/preprocessed/plain/set50_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/set0.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/size_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/tag.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/aux_/value_type_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/set0.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/set0_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/set10.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/set10_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/set20.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/set20_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/set30.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/set30_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/set40.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/set40_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/set50.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set/set50_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/set_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/shift_left.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/shift_right.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/single_view.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/size.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/size_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/size_t.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/size_t_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/sizeof.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/sort.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/stable_partition.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/string.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/switch.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/tag.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/times.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/transform.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/transform_view.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/unique.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/unpack_args.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/upper_bound.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/value_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/value_type_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/O1_size.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/at.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/back.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/begin_end.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/clear.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/empty.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/front.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/include_preprocessed.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/item.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/numbered.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/numbered_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/pop_back.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/pop_front.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/no_ctps/vector10.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/no_ctps/vector10_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/no_ctps/vector30.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/no_ctps/vector30_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/no_ctps/vector40.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/no_ctps/vector40_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/no_ctps/vector50.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/no_ctps/vector50_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/plain/vector10.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/plain/vector10_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/plain/vector20.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/plain/vector20_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/plain/vector30.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/plain/vector30_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/plain/vector40.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/plain/vector40_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/plain/vector50.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/plain/vector50_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/typeof_based/vector40.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/typeof_based/vector40_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/typeof_based/vector50.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/preprocessed/typeof_based/vector50_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/push_back.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/push_front.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/size.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/tag.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/aux_/vector0.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/vector0.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/vector0_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/vector10.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/vector10_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/vector20.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/vector20_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/vector30.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/vector30_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/vector40.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/vector40_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/vector50.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector/vector50_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/vector_c.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/void.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/void_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/mpl/zip_view.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/next_prior.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/noncopyable.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/none.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/none_t.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/bounds.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/cast.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/conversion_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/converter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/converter_policies.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/detail/bounds.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/detail/conversion_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/detail/converter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/detail/int_float_mixture.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/detail/is_subranged.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/detail/meta.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/detail/numeric_cast_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/detail/old_numeric_cast.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_common.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_long_long.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/detail/sign_mixture.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/detail/udt_builtin_mixture.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/int_float_mixture.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/int_float_mixture_enum.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/is_subranged.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/numeric_cast_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/sign_mixture.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/sign_mixture_enum.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/udt_builtin_mixture.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/conversion/udt_builtin_mixture_enum.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval.hpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/arith.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/arith2.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/arith3.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/checking.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/compare.hpp (89%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/compare/certain.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/compare/explicit.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/compare/lexicographic.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/compare/possible.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/compare/set.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/compare/tribool.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/constants.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/detail/alpha_rounding_control.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/detail/bcc_rounding_control.hpp (95%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/detail/bugs.hpp (95%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/detail/c99_rounding_control.hpp (94%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/detail/c99sub_rounding_control.hpp (94%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/detail/division.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/detail/ia64_rounding_control.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/detail/interval_prototype.hpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/detail/msvc_rounding_control.hpp (95%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/detail/ppc_rounding_control.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/detail/sparc_rounding_control.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/detail/test_input.hpp (96%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/detail/x86_rounding_control.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/detail/x86gcc_rounding_control.hpp (94%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/ext/integer.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/ext/x86_fast_rounding_control.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/hw_rounding.hpp (92%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/interval.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/io.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/limits.hpp (95%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/policies.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/rounded_arith.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/rounded_transc.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/rounding.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/transc.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/interval/utility.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/algebra/algebra_dispatcher.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/algebra/array_algebra.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/algebra/default_operations.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/algebra/detail/extract_value_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/algebra/detail/for_each.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/algebra/detail/macros.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/algebra/detail/norm_inf.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/algebra/fusion_algebra.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/algebra/fusion_algebra_dispatcher.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/algebra/multi_array_algebra.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/algebra/norm_result_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/algebra/operations_dispatcher.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/algebra/range_algebra.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/algebra/vector_space_algebra.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/config.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/blaze/blaze_algebra_dispatcher.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/blaze/blaze_resize.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/compute/compute.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/compute/compute_algebra.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/compute/compute_algebra_dispatcher.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/compute/compute_operations.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/compute/compute_operations_dispatcher.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/compute/compute_resize.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/eigen/eigen.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/eigen/eigen_algebra.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/eigen/eigen_algebra_dispatcher.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/eigen/eigen_resize.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/gsl/gsl_wrapper.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/mkl/mkl_operations.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/mpi/mpi.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/mpi/mpi_nested_algebra.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/mpi/mpi_state.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/mpi/mpi_vector_state.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/mtl4/implicit_euler_mtl4.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/mtl4/mtl4.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/mtl4/mtl4_algebra_dispatcher.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/mtl4/mtl4_resize.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/nt2/nt2_algebra_dispatcher.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/nt2/nt2_copy.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/nt2/nt2_norm_inf.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/nt2/nt2_resize.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/openmp/openmp.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/openmp/openmp_nested_algebra.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/openmp/openmp_range_algebra.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/openmp/openmp_state.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/thrust/thrust.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/thrust/thrust_algebra.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/thrust/thrust_algebra_dispatcher.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/thrust/thrust_operations.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/thrust/thrust_operations_dispatcher.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/thrust/thrust_resize.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/vexcl/vexcl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/vexcl/vexcl_abs.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/vexcl/vexcl_algebra_dispatcher.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/vexcl/vexcl_copy.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/vexcl/vexcl_norm_inf.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/vexcl/vexcl_resize.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/vexcl/vexcl_same_instance.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/viennacl/viennacl_operations.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/external/viennacl/viennacl_resize.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/integrate/check_adapter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/integrate/detail/functors.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/integrate/detail/integrate_const.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/integrate/detail/integrate_n_steps.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/integrate/detail/integrate_times.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/integrate/integrate.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/integrate/integrate_adaptive.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/integrate/integrate_const.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/integrate/integrate_n_steps.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/integrate/integrate_times.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/integrate/max_step_checker.hpp (92%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/integrate/null_observer.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/integrate/observer_collection.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/adaptive_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/adaptive_time_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/const_step_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/const_step_time_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/impl/adaptive_iterator_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/impl/const_step_iterator_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/impl/n_step_iterator_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/impl/times_iterator_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/integrate/detail/functors.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/integrate/detail/integrate_adaptive.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/integrate/detail/integrate_const.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/integrate/detail/integrate_n_steps.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/integrate/detail/integrate_times.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/integrate/integrate.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/integrate/integrate_adaptive.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/integrate/integrate_const.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/integrate/integrate_n_steps.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/integrate/integrate_times.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/integrate/null_observer.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/integrate/observer_collection.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/n_step_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/n_step_time_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/times_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/iterator/times_time_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/adams_bashforth.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/adams_bashforth_moulton.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/adams_moulton.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/base/explicit_error_stepper_fsal_base.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/bulirsch_stoer.hpp (96%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/bulirsch_stoer_dense_out.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/controlled_runge_kutta.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/controlled_step_result.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/detail/adams_bashforth_call_algebra.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/detail/adams_bashforth_coefficients.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/detail/adams_moulton_call_algebra.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/detail/adams_moulton_coefficients.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/detail/generic_rk_algorithm.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/detail/generic_rk_call_algebra.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/detail/generic_rk_operations.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/detail/rotating_buffer.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/euler.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/explicit_generic_rk.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/extrapolation_stepper.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/generation.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/generation/generation_controlled_runge_kutta.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/generation/generation_dense_output_runge_kutta.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/generation/generation_rosenbrock4.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54_classic.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/generation/generation_runge_kutta_dopri5.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/generation/generation_runge_kutta_fehlberg78.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/generation/make_controlled.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/generation/make_dense_output.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/implicit_euler.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/modified_midpoint.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/rosenbrock4.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/rosenbrock4_controller.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/rosenbrock4_dense_output.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/runge_kutta4.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/runge_kutta4_classic.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/runge_kutta_cash_karp54.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/runge_kutta_cash_karp54_classic.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/runge_kutta_fehlberg78.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/stepper_categories.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/symplectic_euler.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_m4_mclachlan.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_mclachlan.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/stepper/velocity_verlet.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/bind.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/copy.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/detail/is_range.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/detail/less_with_sign.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/is_pair.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/is_resizeable.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/multi_array_adaption.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/n_ary_helper.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/odeint_error.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/resize.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/resizer.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/same_instance.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/same_size.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/split.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/split_adaptor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/state_wrapper.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/stepper_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/ublas_matrix_expression.patch (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/ublas_wrapper.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/unit_helper.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/util/unwrap_reference.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/odeint/version.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/assignment.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/banded.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/blas.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/detail/concepts.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/detail/config.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/detail/definitions.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/detail/documentation.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/detail/duff.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/detail/iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/detail/matrix_assign.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/detail/raw.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/detail/returntype_deduction.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/detail/temporary.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/detail/vector_assign.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/doxydoc.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/exception.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/experimental/sparse_view.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/expression_types.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/functional.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/hermitian.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/io.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/lu.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/matrix.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/matrix_expression.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/matrix_proxy.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/matrix_sparse.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/matrix_vector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/operation.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/operation/begin.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/operation/c_array.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/operation/end.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/operation/num_columns.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/operation/num_rows.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/operation/size.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/operation_blocked.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/operation_sparse.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/operations.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/storage.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/storage_sparse.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/symmetric.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/tags.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/traits/c_array.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/traits/const_iterator_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/traits/iterator_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/triangular.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/vector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/vector_expression.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/vector_of_vector.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/vector_proxy.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/numeric/ublas/vector_sparse.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/operators.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/operators_v1.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/optional/bad_optional_access.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/optional/detail/old_optional_implementation.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/optional/detail/optional_aligned_storage.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/optional/detail/optional_config.hpp (81%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/optional/detail/optional_factory_support.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/optional/detail/optional_reference_spec.hpp (68%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/optional/detail/optional_relops.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/optional/detail/optional_swap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/optional/optional.hpp (83%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/optional/optional_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/optional/optional_io.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/bucket_sorter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/container_traits.hpp (96%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/detail/disjoint_sets.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/detail/int_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/detail/property.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/disjoint_sets.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/fenced_priority_queue.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/fibonacci_heap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/indirect_cmp.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/integer_log2.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/is_heap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/iterator_adaptors.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/iterator_tests.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/lowest_bit.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/mutable_heap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/mutable_queue.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/property.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/property_serialize.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/queue.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/relaxed_heap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pending/stringtok.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/pointee.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/architecture.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/architecture/alpha.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/architecture/arm.h (89%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/architecture/blackfin.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/architecture/convex.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/architecture/ia64.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/architecture/m68k.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/architecture/mips.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/architecture/parisc.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/architecture/ppc.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/architecture/pyramid.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/architecture/rs6k.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/architecture/sparc.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/architecture/superh.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/architecture/sys370.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/architecture/sys390.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/architecture/x86.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/architecture/x86/32.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/architecture/x86/64.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/architecture/z.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/borland.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/clang.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/comeau.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/compaq.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/diab.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/digitalmars.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/dignus.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/edg.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/ekopath.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/gcc.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/gcc_xml.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/greenhills.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/hp_acc.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/iar.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/ibm.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/intel.h (67%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/kai.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/llvm.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/metaware.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/metrowerks.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/microtec.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/mpw.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/palm.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/pgi.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/sgi_mipspro.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/sunpro.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/tendra.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/visualc.h (80%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/compiler/watcom.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/detail/_cassert.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/detail/_exception.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/detail/comp_detected.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/detail/endian_compat.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/detail/os_detected.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/detail/platform_detected.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/detail/test.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/detail/test_def.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/hardware.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/hardware/simd.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/hardware/simd/arm.h (90%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/hardware/simd/arm/versions.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/hardware/simd/ppc.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/hardware/simd/ppc/versions.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/hardware/simd/x86.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/hardware/simd/x86/versions.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/hardware/simd/x86_amd.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/hardware/simd/x86_amd/versions.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/language.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/language/objc.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/language/stdc.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/language/stdcpp.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/library.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/library/c.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/library/c/_prefix.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/library/c/gnu.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/library/c/uc.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/library/c/vms.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/library/c/zos.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/library/std.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/library/std/_prefix.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/library/std/cxx.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/library/std/dinkumware.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/library/std/libcomo.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/library/std/modena.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/library/std/msl.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/library/std/roguewave.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/library/std/sgi.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/library/std/stdcpp3.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/library/std/stlport.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/library/std/vacpp.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/make.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/aix.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/amigaos.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/android.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/beos.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/bsd.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/bsd/bsdi.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/bsd/dragonfly.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/bsd/free.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/bsd/net.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/bsd/open.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/cygwin.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/haiku.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/hpux.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/ios.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/irix.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/linux.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/macos.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/os400.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/qnxnto.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/solaris.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/unix.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/vms.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/os/windows.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/other.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/other/endian.h (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/predef/other/workaround.h
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/platform.h (94%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/predef/platform/ios.h
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/platform/mingw.h (96%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/platform/windows_desktop.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/platform/windows_phone.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/platform/windows_runtime.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/platform/windows_store.h (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/version.h (83%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/predef/version_number.h (73%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/arithmetic.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/arithmetic/add.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/arithmetic/dec.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/arithmetic/detail/div_base.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/arithmetic/div.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/arithmetic/inc.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/arithmetic/mod.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/arithmetic/mul.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/arithmetic/sub.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/array.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/array/data.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/array/detail/get_data.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/array/elem.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/array/enum.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/array/insert.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/array/pop_back.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/array/pop_front.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/array/push_back.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/array/push_front.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/array/remove.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/array/replace.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/array/reverse.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/array/size.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/array/to_list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/array/to_seq.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/array/to_tuple.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/assert_msg.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/cat.hpp (88%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/comma.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/comma_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/comparison.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/comparison/equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/comparison/greater.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/comparison/greater_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/comparison/less.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/comparison/less_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/comparison/not_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/config/config.hpp (80%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/config/limits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/control.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/control/deduce_d.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/control/detail/dmc/while.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/control/detail/edg/while.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/control/detail/msvc/while.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/control/detail/while.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/control/expr_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/control/expr_iif.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/control/if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/control/iif.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/control/while.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/debug.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/debug/assert.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/debug/error.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/debug/line.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/dec.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/detail/auto_rec.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/detail/check.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/detail/dmc/auto_rec.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/detail/is_binary.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/detail/is_nullary.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/detail/is_unary.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/detail/null.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/detail/split.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/empty.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/enum.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/enum_params.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/enum_params_with_a_default.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/enum_params_with_defaults.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/enum_shifted.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/enum_shifted_params.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/expand.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/expr_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/facilities.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/facilities/apply.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/facilities/detail/is_empty.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/facilities/empty.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/facilities/expand.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/facilities/identity.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/facilities/intercept.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/facilities/is_1.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/facilities/is_empty.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/facilities/is_empty_or_1.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/facilities/is_empty_variadic.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/facilities/overload.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/for.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/identity.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/inc.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iterate.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/bounds/lower1.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/bounds/lower2.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/bounds/lower3.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/bounds/lower4.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/bounds/lower5.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/bounds/upper1.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/bounds/upper2.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/bounds/upper3.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/bounds/upper4.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/bounds/upper5.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/finish.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/iter/forward1.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/iter/forward2.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/iter/forward3.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/iter/forward4.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/iter/forward5.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/iter/reverse1.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/iter/reverse2.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/iter/reverse3.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/iter/reverse4.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/iter/reverse5.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/local.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/rlocal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/self.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/detail/start.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/iterate.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/local.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/iteration/self.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/library.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/limits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/adt.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/append.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/at.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/cat.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/detail/dmc/fold_left.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/detail/edg/fold_left.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/detail/edg/fold_right.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/detail/fold_left.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/detail/fold_right.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/enum.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/filter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/first_n.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/fold_left.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/fold_right.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/for_each.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/for_each_i.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/for_each_product.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/rest_n.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/reverse.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/size.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/to_array.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/to_seq.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/to_tuple.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/list/transform.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/logical.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/logical/and.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/logical/bitand.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/logical/bitnor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/logical/bitor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/logical/bitxor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/logical/bool.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/logical/compl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/logical/nor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/logical/not.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/logical/or.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/logical/xor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/max.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/min.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/punctuation.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/punctuation/comma.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/punctuation/comma_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/punctuation/detail/is_begin_parens.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/punctuation/is_begin_parens.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/punctuation/paren.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/punctuation/paren_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/punctuation/remove_parens.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repeat.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repeat_2nd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repeat_3rd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repeat_from_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repeat_from_to_2nd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repeat_from_to_3rd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition/deduce_r.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition/deduce_z.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition/detail/dmc/for.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition/detail/edg/for.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition/detail/for.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition/detail/msvc/for.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition/enum.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition/enum_binary_params.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition/enum_params.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition/enum_params_with_a_default.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition/enum_params_with_defaults.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition/enum_shifted.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition/enum_shifted_binary_params.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition/enum_shifted_params.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition/enum_trailing.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition/enum_trailing_binary_params.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition/enum_trailing_params.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition/for.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition/repeat.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/repetition/repeat_from_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/selection.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/selection/max.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/selection/min.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/cat.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/detail/binary_transform.hpp (78%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/detail/is_empty.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/detail/split.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/preprocessor/seq/detail/to_list_msvc.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/elem.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/enum.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/filter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/first_n.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/fold_left.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/fold_right.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/for_each.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/for_each_i.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/for_each_product.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/insert.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/pop_back.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/pop_front.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/push_back.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/push_front.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/remove.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/replace.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/rest_n.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/reverse.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/seq.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/size.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/subseq.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/to_array.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/to_list.hpp (80%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/to_tuple.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/transform.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/seq/variadic_seq_to_seq.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/slot.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/slot/counter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/slot/detail/counter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/slot/detail/def.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/slot/detail/shared.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/slot/detail/slot1.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/slot/detail/slot2.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/slot/detail/slot3.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/slot/detail/slot4.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/slot/detail/slot5.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/slot/slot.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/stringize.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/tuple.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/tuple/detail/is_single_return.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/tuple/eat.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/tuple/elem.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/tuple/enum.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/tuple/insert.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/tuple/pop_back.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/tuple/pop_front.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/tuple/push_back.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/tuple/push_front.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/tuple/rem.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/tuple/remove.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/tuple/replace.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/tuple/reverse.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/tuple/size.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/tuple/to_array.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/tuple/to_list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/tuple/to_seq.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/variadic.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/variadic/detail/is_single_return.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/variadic/elem.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/variadic/size.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/variadic/to_array.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/variadic/to_list.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/variadic/to_seq.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/variadic/to_tuple.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/while.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/preprocessor/wstringize.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/program_options.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/program_options/cmdline.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/program_options/config.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/program_options/detail/cmdline.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/program_options/detail/config_file.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/program_options/detail/convert.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/program_options/detail/parsers.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/program_options/detail/utf8_codecvt_facet.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/program_options/detail/value_semantic.hpp (92%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/program_options/environment_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/program_options/eof_iterator.hpp (96%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/program_options/errors.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/program_options/option.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/program_options/options_description.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/program_options/parsers.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/program_options/positional_options.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/program_options/value_semantic.hpp (96%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/program_options/variables_map.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/program_options/version.hpp (81%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/all.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/assert.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/deduce_mat.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/deduce_quat.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/deduce_scalar.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/deduce_vec.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/detail/cofactor_impl.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/detail/determinant_impl.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/detail/mat_assign.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/detail/quat_assign.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/detail/remove_const.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/detail/swizzle_traits.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/detail/transp_impl.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/detail/vec_assign.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/enable_if.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/error.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_assign2.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_assign3.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_assign4.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_operations2.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_operations3.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_operations4.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/gen/swizzle2.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/gen/swizzle3.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/gen/swizzle4.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_assign2.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_assign3.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_assign4.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_mat_operations2.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_mat_operations3.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_mat_operations4.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_operations2.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_operations3.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_operations4.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/inline.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/map.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/map_mat_mat.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/map_mat_vec.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/map_vec_mat.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/mat.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/mat_access.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/mat_operations.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/mat_operations2.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/mat_operations3.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/mat_operations4.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/mat_traits.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/mat_traits_array.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/mat_traits_defaults.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/math.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/operations.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/quat.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/quat_access.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/quat_operations.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/quat_traits.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/quat_traits_array.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/quat_traits_defaults.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/quat_vec_operations.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/scalar_traits.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/static_assert.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/swizzle.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/swizzle2.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/swizzle3.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/swizzle4.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/throw_exception.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/to_string.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/vec.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/vec_access.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/vec_mat_operations.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/vec_mat_operations2.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/vec_mat_operations3.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/vec_mat_operations4.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/vec_operations.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/vec_operations2.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/vec_operations3.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/vec_operations4.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/vec_traits.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/vec_traits_array.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/qvm/vec_traits_defaults.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/additive_combine.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/bernoulli_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/beta_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/binomial_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/cauchy_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/chi_squared_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/detail/auto_link.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/detail/config.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/detail/const_mod.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/detail/disable_warnings.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/detail/enable_warnings.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/detail/generator_bits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/detail/generator_seed_seq.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/random/detail/int_float_pair.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/detail/integer_log2.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/detail/iterator_mixin.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/detail/large_arithmetic.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/detail/operators.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/detail/polynomial.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/detail/ptr_helper.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/detail/seed.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/detail/seed_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/detail/signed_unsigned_tools.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/detail/uniform_int_float.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/detail/vector_io.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/discard_block.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/discrete_distribution.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/random/exponential_distribution.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/extreme_value_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/fisher_f_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/gamma_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/generate_canonical.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/geometric_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/hyperexponential_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/independent_bits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/inversive_congruential.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/lagged_fibonacci.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/laplace_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/linear_congruential.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/linear_feedback_shift.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/lognormal_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/mersenne_twister.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/negative_binomial_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/non_central_chi_squared_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/normal_distribution.hpp (78%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/piecewise_constant_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/piecewise_linear_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/poisson_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/random_device.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/random_number_generator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/ranlux.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/seed_seq.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/shuffle_order.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/shuffle_output.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/student_t_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/subtract_with_carry.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/taus88.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/triangle_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/uniform_01.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/uniform_int.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/uniform_int_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/uniform_on_sphere.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/uniform_real.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/uniform_real_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/uniform_smallint.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/variate_generator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/weibull_distribution.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/random/xor_combine.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/range.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/adaptor/adjacent_filtered.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/adaptor/argument_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/adaptor/copied.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/adaptor/define_adaptor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/adaptor/filtered.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/adaptor/formatted.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/adaptor/indexed.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/adaptor/indirected.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/adaptor/map.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/adaptor/replaced.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/adaptor/replaced_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/adaptor/reversed.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/adaptor/sliced.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/adaptor/strided.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/adaptor/tokenized.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/adaptor/transformed.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/adaptor/type_erased.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/adaptor/uniqued.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/adaptors.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/adjacent_find.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/binary_search.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/copy.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/copy_backward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/count.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/count_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/equal_range.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/fill.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/fill_n.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/find.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/find_end.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/find_first_of.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/find_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/for_each.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/generate.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/heap_algorithm.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/inplace_merge.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/lexicographical_compare.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/lower_bound.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/max_element.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/merge.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/min_element.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/mismatch.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/nth_element.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/partial_sort.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/partial_sort_copy.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/partition.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/permutation.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/random_shuffle.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/remove.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/remove_copy.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/remove_copy_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/remove_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/replace.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/replace_copy.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/replace_copy_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/replace_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/reverse.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/reverse_copy.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/rotate.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/rotate_copy.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/search.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/search_n.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/set_algorithm.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/sort.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/stable_partition.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/stable_sort.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/swap_ranges.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/transform.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/unique.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/unique_copy.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm/upper_bound.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm_ext.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm_ext/copy_n.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm_ext/erase.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm_ext/for_each.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm_ext/insert.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm_ext/iota.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm_ext/is_sorted.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm_ext/overwrite.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm_ext/push_back.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/algorithm_ext/push_front.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/any_range.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/as_array.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/as_literal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/atl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/begin.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/category.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/combine.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/concepts.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/config.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/const_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/const_reverse_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/counting_range.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/any_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/any_iterator_buffer.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/any_iterator_interface.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/any_iterator_wrapper.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/as_literal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/begin.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/collection_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/collection_traits_detail.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/combine_cxx03.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/combine_cxx11.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/combine_no_rvalue.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/combine_rvalue.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/common.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/default_constructible_unary_fn.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/demote_iterator_traversal_tag.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/detail_str.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/difference_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/empty.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/end.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/extract_optional_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/has_member_size.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/implementation_help.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/join_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/microsoft.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/misc_concept.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/msvc_has_iterator_workaround.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/range_return.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/remove_extent.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/safe_bool.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/sfinae.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/size_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/sizer.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/str_types.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/detail/value_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/difference_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/distance.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/empty.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/end.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/functions.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/has_range_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/irange.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/istream_range.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/iterator_range.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/iterator_range_core.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/iterator_range_hash.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/iterator_range_io.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/join.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/metafunctions.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/mfc.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/mfc_map.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/mutable_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/numeric.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/pointer.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/range_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/rbegin.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/reference.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/rend.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/result_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/reverse_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/reverse_result_iterator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/size.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/size_type.hpp (95%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/sub_range.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/traversal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/range/value_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/rational.hpp (54%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/ref.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/scoped_array.hpp (87%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/scoped_ptr.hpp (87%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/shared_ptr.hpp (85%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/smart_ptr/allocate_local_shared_array.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/smart_ptr/allocate_shared_array.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/smart_ptr/atomic_shared_ptr.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/bad_weak_ptr.hpp (83%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/atomic_count.hpp (96%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/atomic_count_gcc.hpp (95%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/atomic_count_gcc_x86.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/atomic_count_nt.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/atomic_count_pt.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/atomic_count_solaris.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/atomic_count_spin.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/atomic_count_std_atomic.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/atomic_count_sync.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/atomic_count_win32.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/lightweight_mutex.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/local_counted_base.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/local_sp_deleter.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/lwm_nop.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/lwm_pthreads.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/lwm_win32_cs.hpp (73%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/operator_bool.hpp (81%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/quick_allocator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/shared_count.hpp (90%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_convertible.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_base.hpp (92%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_base_acc_ia64.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_base_aix.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_base_clang.hpp (92%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_base_cw_ppc.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_base_cw_x86.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_base_gcc_ia64.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_base_gcc_ppc.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_base_gcc_sparc.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_base_nt.hpp (96%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_base_pt.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_base_snc_ps3.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_base_solaris.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_base_spin.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_base_sync.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_base_vacpp_ppc.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_base_w32.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_counted_impl.hpp (89%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_disable_deprecated.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_forward.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_has_sync.hpp (84%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_interlocked.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_noexcept.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/sp_nullptr_t.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/spinlock.hpp (94%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/spinlock_gcc_arm.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/spinlock_nt.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/spinlock_pool.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/spinlock_pt.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/spinlock_std_atomic.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/spinlock_sync.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/spinlock_w32.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/detail/yield_k.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/enable_shared_from_raw.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/enable_shared_from_this.hpp (73%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/intrusive_ptr.hpp (81%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/intrusive_ref_counter.hpp (87%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/smart_ptr/local_shared_ptr.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/smart_ptr/make_local_shared.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/smart_ptr/make_local_shared_array.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/smart_ptr/make_local_shared_object.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/make_shared.hpp (88%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/smart_ptr/make_shared_array.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/smart_ptr/make_shared_object.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/make_unique.hpp (67%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/smart_ptr/owner_less.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/scoped_array.hpp (78%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/scoped_ptr.hpp (80%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/shared_array.hpp (79%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/shared_ptr.hpp (77%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/smart_ptr/weak_ptr.hpp (74%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/static_assert.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/swap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/system/api_config.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/system/config.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/system/cygwin_error.hpp (92%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/system/detail/error_code.ipp (65%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/system/detail/local_free_on_destruction.hpp (92%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/system/error_code.hpp (71%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/system/linux_error.hpp (96%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/system/system_error.hpp (84%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/system/windows_error.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/throw_exception.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/timer.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/token_functions.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/token_iterator.hpp (96%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/tokenizer.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/tuple/detail/tuple_basic.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/tuple/tuple.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/tuple/tuple_comparison.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/tuple/tuple_io.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_index.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_index/ctti_type_index.hpp (99%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_index/detail/compile_time_type_info.hpp (88%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_index/detail/ctti_register_class.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_index/detail/stl_register_class.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/boost_shared_ptr_cast.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/detail/runtime_cast_impl.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/pointer_cast.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/reference_cast.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/register_runtime_class.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/std_shared_ptr_cast.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_index/stl_type_index.hpp (94%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_index/type_index_facade.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/add_const.hpp (91%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/add_cv.hpp (91%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/add_lvalue_reference.hpp (80%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/add_pointer.hpp (91%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/add_reference.hpp (92%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/add_rvalue_reference.hpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/add_volatile.hpp (90%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/aligned_storage.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/alignment_of.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/alignment_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/arithmetic_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/array_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/broken_compiler_spec.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/common_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/composite_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/conditional.hpp (81%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/config.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/conversion_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/copy_cv.hpp (87%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/cv_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/decay.hpp (92%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/declval.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/bool_trait_def.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/bool_trait_undef.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/common_arithmetic_type.hpp (95%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/common_type_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/composite_member_pointer_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/composite_pointer_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/config.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/has_binary_operator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/has_postfix_operator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/has_prefix_operator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/ice_and.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/ice_eq.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/ice_not.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/ice_or.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/is_function_ptr_helper.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/is_function_ptr_tester.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/mp_defer.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/template_arity_spec.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/detail/yes_no_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/extent.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/floating_point_promotion.hpp (84%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/function_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_bit_and.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_bit_and_assign.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_bit_or.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_bit_or_assign.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_bit_xor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_bit_xor_assign.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_complement.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_dereference.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_divides.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_divides_assign.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_greater.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_greater_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_left_shift.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_left_shift_assign.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_less.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_less_equal.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_logical_and.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_logical_not.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_logical_or.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_minus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_minus_assign.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_modulus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_modulus_assign.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_multiplies.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_multiplies_assign.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_negate.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_new_operator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_not_equal_to.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_nothrow_assign.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_nothrow_constructor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_nothrow_copy.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_nothrow_destructor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_operator.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_plus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_plus_assign.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_post_decrement.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_post_increment.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_pre_decrement.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_pre_increment.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_right_shift.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_right_shift_assign.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_trivial_assign.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_trivial_constructor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_trivial_copy.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_trivial_destructor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_trivial_move_assign.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_trivial_move_constructor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_unary_minus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_unary_plus.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/has_virtual_destructor.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/ice.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/integral_constant.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/integral_promotion.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/intrinsics.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_abstract.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_arithmetic.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_array.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_assignable.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_base_and_derived.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_base_of.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_base_of_tr1.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_class.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_complex.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_compound.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_const.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_constructible.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_convertible.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_copy_assignable.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_copy_constructible.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_default_constructible.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_destructible.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_empty.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_enum.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_final.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_float.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_floating_point.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_function.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_fundamental.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_integral.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_lvalue_reference.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_member_function_pointer.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_member_object_pointer.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_member_pointer.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_nothrow_move_assignable.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_nothrow_move_constructible.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_object.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_pod.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_pointer.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_polymorphic.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_reference.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_rvalue_reference.hpp (95%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_same.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_scalar.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_signed.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_stateless.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_union.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_unsigned.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_virtual_base_of.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_void.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/is_volatile.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/make_signed.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/make_unsigned.hpp (97%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/type_traits/make_void.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/object_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/promote.hpp (83%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/rank.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/reference_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/remove_all_extents.hpp (92%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/remove_bounds.hpp (83%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/remove_const.hpp (90%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/remove_cv.hpp (92%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/type_traits/remove_cv_ref.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/remove_extent.hpp (92%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/remove_pointer.hpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/remove_reference.hpp (92%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/remove_volatile.hpp (90%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/same_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/transform_traits.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/type_identity.hpp (78%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/type_traits/type_with_alignment.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility.hpp (90%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/addressof.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/base_from_member.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/binary.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/compare_pointees.hpp (87%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/declval.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/detail/in_place_factory_prefix.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/detail/in_place_factory_suffix.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/detail/result_of_iterate.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/empty_deleter.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/enable_if.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/explicit_operator_bool.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/identity_type.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/in_place_factory.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/result_of.hpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/string_ref.hpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/string_ref_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/string_view.hpp (89%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/string_view_fwd.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/swap.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/typed_in_place_factory.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/utility/value_init.hpp (100%)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/apply_visitor.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/bad_visit.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/apply_visitor_binary.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/apply_visitor_delayed.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/apply_visitor_unary.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/backup_holder.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/cast_storage.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/config.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/element_index.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/enable_recursive.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/enable_recursive_fwd.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/forced_return.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/generic_result_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/has_result_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/hash_variant.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/initializer.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/make_variant_list.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/move.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/multivisitors_cpp11_based.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/multivisitors_cpp14_based.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/multivisitors_preprocessor_based.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/over_sequence.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/substitute.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/substitute_fwd.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/variant_io.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/detail/visitation_impl.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/get.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/multivisitors.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/polymorphic_get.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/recursive_variant.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/recursive_wrapper.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/recursive_wrapper_fwd.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/static_visitor.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/variant.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/variant_fwd.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/variant/visitor_ptr.hpp
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/version.hpp (94%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/boost/visit_each.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/filesystem/src/codecvt_error_category.cpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/filesystem/src/operations.cpp (93%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/filesystem/src/path.cpp (90%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/filesystem/src/path_traits.cpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/filesystem/src/portability.cpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/filesystem/src/unique_path.cpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/filesystem/src/utf8_codecvt_facet.cpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/filesystem/src/windows_file_codecvt.cpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/filesystem/src/windows_file_codecvt.hpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/program_options/src/cmdline.cpp (98%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/program_options/src/config_file.cpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/program_options/src/convert.cpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/program_options/src/options_description.cpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/program_options/src/parsers.cpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/program_options/src/positional_options.cpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/program_options/src/split.cpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/program_options/src/utf8_codecvt_facet.cpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/program_options/src/value_semantic.cpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/program_options/src/variables_map.cpp (97%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/program_options/src/winmain.cpp (100%)
 rename contrib/libboost/{boost_1_62_0 => boost_1_65_0}/libs/system/src/error_code.cpp (100%)

diff --git a/cmake/find_boost.cmake b/cmake/find_boost.cmake
index a7f72d8c68e..72693bafe8e 100644
--- a/cmake/find_boost.cmake
+++ b/cmake/find_boost.cmake
@@ -3,7 +3,7 @@ option (USE_INTERNAL_BOOST_LIBRARY "Set to FALSE to use system boost library ins
 if (NOT USE_INTERNAL_BOOST_LIBRARY)
     set (Boost_USE_STATIC_LIBS ${USE_STATIC_LIBRARIES})
     set (BOOST_ROOT "/usr/local")
-    find_package (Boost 1.60 COMPONENTS program_options system filesystem regex thread)
+    find_package (Boost 1.60 COMPONENTS program_options system filesystem thread)
     # incomplete, no include search, who use it?
     if (NOT Boost_FOUND)
         #    # Try to find manually.
@@ -24,7 +24,7 @@ if (NOT Boost_SYSTEM_LIBRARY)
     set (Boost_PROGRAM_OPTIONS_LIBRARY boost_program_options_internal)
     set (Boost_SYSTEM_LIBRARY boost_system_internal)
     set (Boost_FILESYSTEM_LIBRARY boost_filesystem_internal)
-    set (Boost_INCLUDE_DIRS "${ClickHouse_SOURCE_DIR}/contrib/libboost/boost_1_62_0/")
+    set (Boost_INCLUDE_DIRS "${ClickHouse_SOURCE_DIR}/contrib/libboost/boost_1_65_0/")
 endif ()
 
 message (STATUS "Using Boost: ${Boost_INCLUDE_DIRS} : ${Boost_PROGRAM_OPTIONS_LIBRARY},${Boost_SYSTEM_LIBRARY},${Boost_FILESYSTEM_LIBRARY}")
diff --git a/contrib/libboost/CMakeLists.txt b/contrib/libboost/CMakeLists.txt
index 8c630ee1dba..908ddfc1e43 100644
--- a/contrib/libboost/CMakeLists.txt
+++ b/contrib/libboost/CMakeLists.txt
@@ -2,54 +2,31 @@ add_definitions(-Wno-unused-variable)
 add_definitions(-Wno-deprecated-declarations)
 
 add_library(boost_program_options_internal
-boost_1_62_0/libs/program_options/src/cmdline.cpp
-boost_1_62_0/libs/program_options/src/config_file.cpp
-boost_1_62_0/libs/program_options/src/convert.cpp
-boost_1_62_0/libs/program_options/src/options_description.cpp
-boost_1_62_0/libs/program_options/src/parsers.cpp
-boost_1_62_0/libs/program_options/src/positional_options.cpp
-boost_1_62_0/libs/program_options/src/split.cpp
-boost_1_62_0/libs/program_options/src/utf8_codecvt_facet.cpp
-boost_1_62_0/libs/program_options/src/value_semantic.cpp
-boost_1_62_0/libs/program_options/src/variables_map.cpp
-boost_1_62_0/libs/program_options/src/winmain.cpp)
+boost_1_65_0/libs/program_options/src/cmdline.cpp
+boost_1_65_0/libs/program_options/src/config_file.cpp
+boost_1_65_0/libs/program_options/src/convert.cpp
+boost_1_65_0/libs/program_options/src/options_description.cpp
+boost_1_65_0/libs/program_options/src/parsers.cpp
+boost_1_65_0/libs/program_options/src/positional_options.cpp
+boost_1_65_0/libs/program_options/src/split.cpp
+boost_1_65_0/libs/program_options/src/utf8_codecvt_facet.cpp
+boost_1_65_0/libs/program_options/src/value_semantic.cpp
+boost_1_65_0/libs/program_options/src/variables_map.cpp
+boost_1_65_0/libs/program_options/src/winmain.cpp)
 
 add_library(boost_filesystem_internal
-boost_1_62_0/libs/filesystem/src/codecvt_error_category.cpp
-boost_1_62_0/libs/filesystem/src/operations.cpp
-boost_1_62_0/libs/filesystem/src/path.cpp
-boost_1_62_0/libs/filesystem/src/path_traits.cpp
-boost_1_62_0/libs/filesystem/src/portability.cpp
-boost_1_62_0/libs/filesystem/src/unique_path.cpp
-boost_1_62_0/libs/filesystem/src/utf8_codecvt_facet.cpp
-boost_1_62_0/libs/filesystem/src/windows_file_codecvt.cpp)
+boost_1_65_0/libs/filesystem/src/codecvt_error_category.cpp
+boost_1_65_0/libs/filesystem/src/operations.cpp
+boost_1_65_0/libs/filesystem/src/path.cpp
+boost_1_65_0/libs/filesystem/src/path_traits.cpp
+boost_1_65_0/libs/filesystem/src/portability.cpp
+boost_1_65_0/libs/filesystem/src/unique_path.cpp
+boost_1_65_0/libs/filesystem/src/utf8_codecvt_facet.cpp
+boost_1_65_0/libs/filesystem/src/windows_file_codecvt.cpp)
 
 add_library(boost_system_internal
-boost_1_62_0/libs/system/src/error_code.cpp)
-
-add_library(boost_test_internal
-boost_1_62_0/libs/test/src/compiler_log_formatter.cpp
-boost_1_62_0/libs/test/src/cpp_main.cpp
-boost_1_62_0/libs/test/src/debug.cpp
-boost_1_62_0/libs/test/src/decorator.cpp
-boost_1_62_0/libs/test/src/execution_monitor.cpp
-boost_1_62_0/libs/test/src/framework.cpp
-boost_1_62_0/libs/test/src/junit_log_formatter.cpp
-boost_1_62_0/libs/test/src/plain_report_formatter.cpp
-boost_1_62_0/libs/test/src/progress_monitor.cpp
-boost_1_62_0/libs/test/src/results_collector.cpp
-boost_1_62_0/libs/test/src/results_reporter.cpp
-boost_1_62_0/libs/test/src/test_main.cpp
-boost_1_62_0/libs/test/src/test_tools.cpp
-boost_1_62_0/libs/test/src/test_tree.cpp
-boost_1_62_0/libs/test/src/unit_test_log.cpp
-boost_1_62_0/libs/test/src/unit_test_main.cpp
-boost_1_62_0/libs/test/src/unit_test_monitor.cpp
-boost_1_62_0/libs/test/src/unit_test_parameters.cpp
-boost_1_62_0/libs/test/src/xml_log_formatter.cpp
-boost_1_62_0/libs/test/src/xml_report_formatter.cpp)
+boost_1_65_0/libs/system/src/error_code.cpp)
 
 target_include_directories (boost_program_options_internal BEFORE PUBLIC ${Boost_INCLUDE_DIRS})
 target_include_directories (boost_filesystem_internal BEFORE PUBLIC ${Boost_INCLUDE_DIRS})
 target_include_directories (boost_system_internal BEFORE PUBLIC ${Boost_INCLUDE_DIRS})
-target_include_directories (boost_test_internal BEFORE PUBLIC ${Boost_INCLUDE_DIRS})
diff --git a/contrib/libboost/boost_1_62_0/boost/align/align_down.hpp b/contrib/libboost/boost_1_62_0/boost/align/align_down.hpp
deleted file mode 100644
index f437f8e5b38..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/align/align_down.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
-(c) 2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
-
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
-*/
-#ifndef BOOST_ALIGN_ALIGN_DOWN_HPP
-#define BOOST_ALIGN_ALIGN_DOWN_HPP
-
-#include <boost/align/detail/align_down.hpp>
-#include <boost/align/align_down_forward.hpp>
-
-namespace boost {
-namespace alignment {
-
-BOOST_CONSTEXPR inline std::size_t align_down(std::size_t value,
-    std::size_t alignment) BOOST_NOEXCEPT
-{
-    return value & ~(alignment - 1);
-}
-
-} /* .alignment */
-} /* .boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/align_down_forward.hpp b/contrib/libboost/boost_1_62_0/boost/align/align_down_forward.hpp
deleted file mode 100644
index 6d124e89011..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/align/align_down_forward.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
-(c) 2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
-
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
-*/
-#ifndef BOOST_ALIGN_ALIGN_DOWN_FORWARD_HPP
-#define BOOST_ALIGN_ALIGN_DOWN_FORWARD_HPP
-
-#include <boost/config.hpp>
-#include <cstddef>
-
-namespace boost {
-namespace alignment {
-
-BOOST_CONSTEXPR std::size_t align_down(std::size_t value,
-    std::size_t alignment) BOOST_NOEXCEPT;
-
-} /* .alignment */
-} /* .boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/align_up.hpp b/contrib/libboost/boost_1_62_0/boost/align/align_up.hpp
deleted file mode 100644
index b1cec1911e4..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/align/align_up.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
-(c) 2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
-
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
-*/
-#ifndef BOOST_ALIGN_ALIGN_UP_HPP
-#define BOOST_ALIGN_ALIGN_UP_HPP
-
-#include <boost/align/detail/align_up.hpp>
-#include <boost/align/align_up_forward.hpp>
-
-namespace boost {
-namespace alignment {
-
-BOOST_CONSTEXPR inline std::size_t align_up(std::size_t value,
-    std::size_t alignment) BOOST_NOEXCEPT
-{
-    return (value + alignment - 1) & ~(alignment - 1);
-}
-
-} /* .alignment */
-} /* .boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/align_up_forward.hpp b/contrib/libboost/boost_1_62_0/boost/align/align_up_forward.hpp
deleted file mode 100644
index 47fdfcd0ba3..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/align/align_up_forward.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
-(c) 2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
-
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
-*/
-#ifndef BOOST_ALIGN_ALIGN_UP_FORWARD_HPP
-#define BOOST_ALIGN_ALIGN_UP_FORWARD_HPP
-
-#include <boost/config.hpp>
-#include <cstddef>
-
-namespace boost {
-namespace alignment {
-
-BOOST_CONSTEXPR std::size_t align_up(std::size_t value,
-    std::size_t alignment) BOOST_NOEXCEPT;
-
-} /* .alignment */
-} /* .boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/aligned_delete_forward.hpp b/contrib/libboost/boost_1_62_0/boost/align/aligned_delete_forward.hpp
deleted file mode 100644
index 7334bebdefd..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/align/aligned_delete_forward.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
-(c) 2014-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
-
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
-*/
-#ifndef BOOST_ALIGN_ALIGNED_DELETE_FORWARD_HPP
-#define BOOST_ALIGN_ALIGNED_DELETE_FORWARD_HPP
-
-namespace boost {
-namespace alignment {
-
-struct aligned_delete;
-
-} /* .alignment */
-} /* .boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/alignment_of_forward.hpp b/contrib/libboost/boost_1_62_0/boost/align/alignment_of_forward.hpp
deleted file mode 100644
index 7ab227528bd..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/align/alignment_of_forward.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
-
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
-*/
-#ifndef BOOST_ALIGN_ALIGNMENT_OF_FORWARD_HPP
-#define BOOST_ALIGN_ALIGNMENT_OF_FORWARD_HPP
-
-namespace boost {
-namespace alignment {
-
-template<class T>
-struct alignment_of;
-
-} /* .alignment */
-} /* .boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/align_cxx11.hpp b/contrib/libboost/boost_1_62_0/boost/align/detail/align_cxx11.hpp
deleted file mode 100644
index a95b84c70f8..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/align_cxx11.hpp
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
-
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
-*/
-#ifndef BOOST_ALIGN_DETAIL_ALIGN_CXX11_HPP
-#define BOOST_ALIGN_DETAIL_ALIGN_CXX11_HPP
-
-#include <memory>
-
-namespace boost {
-namespace alignment {
-
-using std::align;
-
-} /* .alignment */
-} /* .boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/align_down.hpp b/contrib/libboost/boost_1_62_0/boost/align/detail/align_down.hpp
deleted file mode 100644
index 97e1c1d3eb6..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/align_down.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
-(c) 2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
-
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
-*/
-#ifndef BOOST_ALIGN_DETAIL_ALIGN_DOWN_HPP
-#define BOOST_ALIGN_DETAIL_ALIGN_DOWN_HPP
-
-#include <boost/align/detail/is_alignment.hpp>
-#include <boost/align/align_down_forward.hpp>
-#include <boost/assert.hpp>
-
-namespace boost {
-namespace alignment {
-
-inline void* align_down(void* ptr, std::size_t alignment) BOOST_NOEXCEPT
-{
-    BOOST_ASSERT(detail::is_alignment(alignment));
-    return (void*)(align_down((std::size_t)ptr, alignment));
-}
-
-} /* .alignment */
-} /* .boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/align_up.hpp b/contrib/libboost/boost_1_62_0/boost/align/detail/align_up.hpp
deleted file mode 100644
index e956f7a0462..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/align_up.hpp
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
-(c) 2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
-
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
-*/
-#ifndef BOOST_ALIGN_DETAIL_ALIGN_UP_HPP
-#define BOOST_ALIGN_DETAIL_ALIGN_UP_HPP
-
-#include <boost/align/detail/is_alignment.hpp>
-#include <boost/align/align_up_forward.hpp>
-#include <boost/assert.hpp>
-
-namespace boost {
-namespace alignment {
-
-inline void* align_up(void* ptr, std::size_t alignment) BOOST_NOEXCEPT
-{
-    BOOST_ASSERT(detail::is_alignment(alignment));
-    return (void*)(align_up((std::size_t)ptr, alignment));
-}
-
-} /* .alignment */
-} /* .boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/assume_aligned.hpp b/contrib/libboost/boost_1_62_0/boost/align/detail/assume_aligned.hpp
deleted file mode 100644
index a1c632b94d3..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/assume_aligned.hpp
+++ /dev/null
@@ -1,17 +0,0 @@
-/*
-(c) 2015 NumScale SAS
-(c) 2015 LRI UMR 8623 CNRS/University Paris Sud XI
-
-(c) 2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
-
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
-*/
-#ifndef BOOST_ALIGN_DETAIL_ASSUME_ALIGNED_HPP
-#define BOOST_ALIGN_DETAIL_ASSUME_ALIGNED_HPP
-
-#define BOOST_ALIGN_ASSUME_ALIGNED(p, n)
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/assume_aligned_gcc.hpp b/contrib/libboost/boost_1_62_0/boost/align/detail/assume_aligned_gcc.hpp
deleted file mode 100644
index fc6d76a07fa..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/assume_aligned_gcc.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
-(c) 2015 NumScale SAS
-(c) 2015 LRI UMR 8623 CNRS/University Paris Sud XI
-
-(c) 2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
-
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
-*/
-#ifndef BOOST_ALIGN_DETAIL_ASSUME_ALIGNED_GCC_HPP
-#define BOOST_ALIGN_DETAIL_ASSUME_ALIGNED_GCC_HPP
-
-#define BOOST_ALIGN_ASSUME_ALIGNED(p, n) \
-(p) = (__typeof__(p))(__builtin_assume_aligned((p), (n)))
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/assume_aligned_intel.hpp b/contrib/libboost/boost_1_62_0/boost/align/detail/assume_aligned_intel.hpp
deleted file mode 100644
index 1944f3de514..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/assume_aligned_intel.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-/*
-(c) 2015 NumScale SAS
-(c) 2015 LRI UMR 8623 CNRS/University Paris Sud XI
-
-(c) 2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
-
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
-*/
-#ifndef BOOST_ALIGN_DETAIL_ASSUME_ALIGNED_INTEL_HPP
-#define BOOST_ALIGN_DETAIL_ASSUME_ALIGNED_INTEL_HPP
-
-#define BOOST_ALIGN_ASSUME_ALIGNED(p, n) \
-__assume_aligned((p), (n))
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/assume_aligned_msvc.hpp b/contrib/libboost/boost_1_62_0/boost/align/detail/assume_aligned_msvc.hpp
deleted file mode 100644
index e953333b02b..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/assume_aligned_msvc.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
-(c) 2015 NumScale SAS
-(c) 2015 LRI UMR 8623 CNRS/University Paris Sud XI
-
-(c) 2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
-
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
-*/
-#ifndef BOOST_ALIGN_DETAIL_ASSUME_ALIGNED_MSVC_HPP
-#define BOOST_ALIGN_DETAIL_ASSUME_ALIGNED_MSVC_HPP
-
-#include <cstddef>
-
-#define BOOST_ALIGN_ASSUME_ALIGNED(p, n) \
-__assume(((std::size_t)(p) & ((n) - 1)) == 0)
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/is_aligned.hpp b/contrib/libboost/boost_1_62_0/boost/align/detail/is_aligned.hpp
deleted file mode 100644
index e7c7dd60a07..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/is_aligned.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
-
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
-*/
-#ifndef BOOST_ALIGN_DETAIL_IS_ALIGNED_HPP
-#define BOOST_ALIGN_DETAIL_IS_ALIGNED_HPP
-
-#include <boost/align/detail/is_alignment.hpp>
-#include <boost/align/is_aligned_forward.hpp>
-#include <boost/assert.hpp>
-
-namespace boost {
-namespace alignment {
-
-inline bool is_aligned(const void* ptr, std::size_t alignment)
-    BOOST_NOEXCEPT
-{
-    BOOST_ASSERT(detail::is_alignment(alignment));
-    return is_aligned((std::size_t)ptr, alignment);
-}
-
-inline bool is_aligned(std::size_t alignment, const void* ptr)
-    BOOST_NOEXCEPT
-{
-    BOOST_ASSERT(detail::is_alignment(alignment));
-    return is_aligned((std::size_t)ptr, alignment);
-}
-
-} /* .alignment */
-} /* .boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/is_alignment.hpp b/contrib/libboost/boost_1_62_0/boost/align/detail/is_alignment.hpp
deleted file mode 100644
index 12d8df974f4..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/is_alignment.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
-
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
-*/
-#ifndef BOOST_ALIGN_DETAIL_IS_ALIGNMENT_HPP
-#define BOOST_ALIGN_DETAIL_IS_ALIGNMENT_HPP
-
-#include <boost/config.hpp>
-#include <cstddef>
-
-namespace boost {
-namespace alignment {
-namespace detail {
-
-BOOST_CONSTEXPR inline bool is_alignment(std::size_t value)
-    BOOST_NOEXCEPT
-{
-    return (value > 0) && ((value & (value - 1)) == 0);
-}
-
-} /* .detail */
-} /* .alignment */
-} /* .boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/is_aligned.hpp b/contrib/libboost/boost_1_62_0/boost/align/is_aligned.hpp
deleted file mode 100644
index cbace960775..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/align/is_aligned.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
-
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
-*/
-#ifndef BOOST_ALIGN_IS_ALIGNED_HPP
-#define BOOST_ALIGN_IS_ALIGNED_HPP
-
-#include <boost/align/detail/is_aligned.hpp>
-#include <boost/align/is_aligned_forward.hpp>
-
-namespace boost {
-namespace alignment {
-
-BOOST_CONSTEXPR inline bool is_aligned(std::size_t value,
-    std::size_t alignment) BOOST_NOEXCEPT
-{
-    return (value & (alignment - 1)) == 0;
-}
-
-} /* .alignment */
-} /* .boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/is_aligned_forward.hpp b/contrib/libboost/boost_1_62_0/boost/align/is_aligned_forward.hpp
deleted file mode 100644
index d1bcbc19ddf..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/align/is_aligned_forward.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
-(c) 2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
-
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
-*/
-#ifndef BOOST_ALIGN_IS_ALIGNED_FORWARD_HPP
-#define BOOST_ALIGN_IS_ALIGNED_FORWARD_HPP
-
-#include <boost/config.hpp>
-#include <cstddef>
-
-namespace boost {
-namespace alignment {
-
-BOOST_CONSTEXPR bool is_aligned(std::size_t value,
-    std::size_t alignment) BOOST_NOEXCEPT;
-
-} /* .alignment */
-} /* .boost */
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/algorithm.hpp b/contrib/libboost/boost_1_62_0/boost/container/detail/algorithm.hpp
deleted file mode 100644
index 67e78763454..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/container/detail/algorithm.hpp
+++ /dev/null
@@ -1,35 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Ion Gaztanaga 2014-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/libs/container for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#ifndef BOOST_CONTAINER_DETAIL_ALGORITHM_HPP
-#define BOOST_CONTAINER_DETAIL_ALGORITHM_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#  include <boost/config.hpp>
-#endif
-
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#  pragma once
-#endif
-
-#include <boost/intrusive/detail/algorithm.hpp>
-
-namespace boost {
-namespace container {
-
-using boost::intrusive::algo_equal;
-using boost::intrusive::algo_lexicographical_compare;
-
-}  //namespace container {
-}  //namespace boost {
-
-#endif   //#ifndef BOOST_CONTAINER_DETAIL_ALGORITHM_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/hash_table.hpp b/contrib/libboost/boost_1_62_0/boost/container/detail/hash_table.hpp
deleted file mode 100644
index 4bc5c901de5..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/container/detail/hash_table.hpp
+++ /dev/null
@@ -1,383 +0,0 @@
-/*
-template <class Value, unsigned int Options = 0, class Hash = hash<Value>, class Pred = equal_to<Value>,
-          class Allocator = allocator<Value> >
-class hash_set
-{
-public:
-    // types
-    typedef Value                                                      key_type;
-    typedef key_type                                                   value_type;
-    typedef Hash                                                       hasher;
-    typedef Pred                                                       key_equal;
-    typedef Allocator                                                      allocator_type;
-    typedef value_type&                                                reference;
-    typedef const value_type&                                          const_reference;
-    typedef typename allocator_traits<allocator_type>::pointer         pointer;
-    typedef typename allocator_traits<allocator_type>::const_pointer   const_pointer;
-    typedef typename allocator_traits<allocator_type>::size_type       size_type;
-    typedef typename allocator_traits<allocator_type>::difference_type difference_type;
-
-    typedef /unspecified/ iterator;
-    typedef /unspecified/ const_iterator;
-    typedef /unspecified/ local_iterator;
-    typedef /unspecified/ const_local_iterator;
-
-    hash_set()
-        noexcept(
-            is_nothrow_default_constructible<hasher>::value &&
-            is_nothrow_default_constructible<key_equal>::value &&
-            is_nothrow_default_constructible<allocator_type>::value);
-    explicit hash_set(size_type n, const hasher& hf = hasher(),
-                           const key_equal& eql = key_equal(),
-                           const allocator_type& a = allocator_type());
-    template <class InputIterator>
-        hash_set(InputIterator f, InputIterator l,
-                      size_type n = 0, const hasher& hf = hasher(),
-                      const key_equal& eql = key_equal(),
-                      const allocator_type& a = allocator_type());
-    explicit hash_set(const allocator_type&);
-    hash_set(const hash_set&);
-    hash_set(const hash_set&, const Allocator&);
-    hash_set(hash_set&&)
-        noexcept(
-            is_nothrow_move_constructible<hasher>::value &&
-            is_nothrow_move_constructible<key_equal>::value &&
-            is_nothrow_move_constructible<allocator_type>::value);
-    hash_set(hash_set&&, const Allocator&);
-    hash_set(initializer_list<value_type>, size_type n = 0,
-                  const hasher& hf = hasher(), const key_equal& eql = key_equal(),
-                  const allocator_type& a = allocator_type());
-    ~hash_set();
-    hash_set& operator=(const hash_set&);
-    hash_set& operator=(hash_set&&)
-        noexcept(
-            allocator_type::propagate_on_container_move_assignment::value &&
-            is_nothrow_move_assignable<allocator_type>::value &&
-            is_nothrow_move_assignable<hasher>::value &&
-            is_nothrow_move_assignable<key_equal>::value);
-    hash_set& operator=(initializer_list<value_type>);
-
-    allocator_type get_allocator() const noexcept;
-
-    bool      empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
-
-    iterator       begin() noexcept;
-    iterator       end() noexcept;
-    const_iterator begin()  const noexcept;
-    const_iterator end()    const noexcept;
-    const_iterator cbegin() const noexcept;
-    const_iterator cend()   const noexcept;
-
-    template <class... Args>
-        pair<iterator, bool> emplace(BOOST_FWD_REF(Args)... args);
-    template <class... Args>
-        iterator emplace_hint(const_iterator position, BOOST_FWD_REF(Args)... args);
-    pair<iterator, bool> insert(const value_type& obj);
-    pair<iterator, bool> insert(value_type&& obj);
-    iterator insert(const_iterator hint, const value_type& obj);
-    iterator insert(const_iterator hint, value_type&& obj);
-    template <class InputIterator>
-        void insert(InputIterator first, InputIterator last);
-    void insert(initializer_list<value_type>);
-
-    iterator erase(const_iterator position);
-    size_type erase(const key_type& k);
-    iterator erase(const_iterator first, const_iterator last);
-    void clear() noexcept;
-
-    void swap(hash_set&)
-        noexcept(
-            (!allocator_type::propagate_on_container_swap::value ||
-             __is_nothrow_swappable<allocator_type>::value) &&
-            __is_nothrow_swappable<hasher>::value &&
-            __is_nothrow_swappable<key_equal>::value);
-
-    hasher hash_function() const;
-    key_equal key_eq() const;
-
-    iterator       find(const key_type& k);
-    const_iterator find(const key_type& k) const;
-    size_type count(const key_type& k) const;
-    pair<iterator, iterator>             equal_range(const key_type& k);
-    pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
-
-    size_type bucket_count() const noexcept;
-    size_type max_bucket_count() const noexcept;
-
-    size_type bucket_size(size_type n) const;
-    size_type bucket(const key_type& k) const;
-
-    local_iterator       begin(size_type n);
-    local_iterator       end(size_type n);
-    const_local_iterator begin(size_type n) const;
-    const_local_iterator end(size_type n) const;
-    const_local_iterator cbegin(size_type n) const;
-    const_local_iterator cend(size_type n) const;
-
-    float load_factor() const noexcept;
-    float max_load_factor() const noexcept;
-    void max_load_factor(float z);
-    void rehash(size_type n);
-    void reserve(size_type n);
-};
-
-template <class Key, class T, unsigned int Options = 0, class Hash = hash<Key>, class Pred = equal_to<Key>,
-          class Allocator = allocator<pair<const Key, T> > >
-class hash_map
-{
-public:
-    // types
-    typedef Key                                                        key_type;
-    typedef T                                                          mapped_type;
-    typedef Hash                                                       hasher;
-    typedef Pred                                                       key_equal;
-    typedef Allocator                                                      allocator_type;
-    typedef pair<const key_type, mapped_type>                          value_type;
-    typedef value_type&                                                reference;
-    typedef const value_type&                                          const_reference;
-    typedef typename allocator_traits<allocator_type>::pointer         pointer;
-    typedef typename allocator_traits<allocator_type>::const_pointer   const_pointer;
-    typedef typename allocator_traits<allocator_type>::size_type       size_type;
-    typedef typename allocator_traits<allocator_type>::difference_type difference_type;
-
-    typedef /unspecified/ iterator;
-    typedef /unspecified/ const_iterator;
-    typedef /unspecified/ local_iterator;
-    typedef /unspecified/ const_local_iterator;
-
-    hash_map()
-        noexcept(
-            is_nothrow_default_constructible<hasher>::value &&
-            is_nothrow_default_constructible<key_equal>::value &&
-            is_nothrow_default_constructible<allocator_type>::value);
-    explicit hash_map(size_type n, const hasher& hf = hasher(),
-                           const key_equal& eql = key_equal(),
-                           const allocator_type& a = allocator_type());
-    template <class InputIterator>
-        hash_map(InputIterator f, InputIterator l,
-                      size_type n = 0, const hasher& hf = hasher(),
-                      const key_equal& eql = key_equal(),
-                      const allocator_type& a = allocator_type());
-    explicit hash_map(const allocator_type&);
-    hash_map(const hash_map&);
-    hash_map(const hash_map&, const Allocator&);
-    hash_map(hash_map&&)
-        noexcept(
-            is_nothrow_move_constructible<hasher>::value &&
-            is_nothrow_move_constructible<key_equal>::value &&
-            is_nothrow_move_constructible<allocator_type>::value);
-    hash_map(hash_map&&, const Allocator&);
-    hash_map(initializer_list<value_type>, size_type n = 0,
-                  const hasher& hf = hasher(), const key_equal& eql = key_equal(),
-                  const allocator_type& a = allocator_type());
-    ~hash_map();
-    hash_map& operator=(const hash_map&);
-    hash_map& operator=(hash_map&&)
-        noexcept(
-            allocator_type::propagate_on_container_move_assignment::value &&
-            is_nothrow_move_assignable<allocator_type>::value &&
-            is_nothrow_move_assignable<hasher>::value &&
-            is_nothrow_move_assignable<key_equal>::value);
-    hash_map& operator=(initializer_list<value_type>);
-
-    allocator_type get_allocator() const noexcept;
-
-    bool      empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
-
-    iterator       begin() noexcept;
-    iterator       end() noexcept;
-    const_iterator begin()  const noexcept;
-    const_iterator end()    const noexcept;
-    const_iterator cbegin() const noexcept;
-    const_iterator cend()   const noexcept;
-
-    template <class... Args>
-        pair<iterator, bool> emplace(BOOST_FWD_REF(Args)... args);
-    template <class... Args>
-        iterator emplace_hint(const_iterator position, BOOST_FWD_REF(Args)... args);
-    pair<iterator, bool> insert(const value_type& obj);
-    template <class P>
-        pair<iterator, bool> insert(P&& obj);
-    iterator insert(const_iterator hint, const value_type& obj);
-    template <class P>
-        iterator insert(const_iterator hint, P&& obj);
-    template <class InputIterator>
-        void insert(InputIterator first, InputIterator last);
-    void insert(initializer_list<value_type>);
-
-    iterator erase(const_iterator position);
-    size_type erase(const key_type& k);
-    iterator erase(const_iterator first, const_iterator last);
-    void clear() noexcept;
-
-    void swap(hash_map&)
-        noexcept(
-            (!allocator_type::propagate_on_container_swap::value ||
-             __is_nothrow_swappable<allocator_type>::value) &&
-            __is_nothrow_swappable<hasher>::value &&
-            __is_nothrow_swappable<key_equal>::value);
-
-    hasher hash_function() const;
-    key_equal key_eq() const;
-
-    iterator       find(const key_type& k);
-    const_iterator find(const key_type& k) const;
-    size_type count(const key_type& k) const;
-    pair<iterator, iterator>             equal_range(const key_type& k);
-    pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
-
-    mapped_type& operator[](const key_type& k);
-    mapped_type& operator[](key_type&& k);
-
-    mapped_type&       at(const key_type& k);
-    const mapped_type& at(const key_type& k) const;
-
-    size_type bucket_count() const noexcept;
-    size_type max_bucket_count() const noexcept;
-
-    size_type bucket_size(size_type n) const;
-    size_type bucket(const key_type& k) const;
-
-    local_iterator       begin(size_type n);
-    local_iterator       end(size_type n);
-    const_local_iterator begin(size_type n) const;
-    const_local_iterator end(size_type n) const;
-    const_local_iterator cbegin(size_type n) const;
-    const_local_iterator cend(size_type n) const;
-
-    float load_factor() const noexcept;
-    float max_load_factor() const noexcept;
-    void max_load_factor(float z);
-    void rehash(size_type n);
-    void reserve(size_type n);
-};
-
-*/
-
-template <class Key, class Value, class KeyOfValue, unsigned int Options = 0, class Hash = hash<Key>, class Pred = equal_to<Key>,
-          class Allocator = allocator<Value> >
-class hash_table
-{
-public:
-    // types
-    typedef Value                                                      key_type;
-    typedef key_type                                                   value_type;
-    typedef Hash                                                       hasher;
-    typedef Pred                                                       key_equal;
-    typedef Allocator                                                      allocator_type;
-    typedef value_type&                                                reference;
-    typedef const value_type&                                          const_reference;
-    typedef typename allocator_traits<allocator_type>::pointer         pointer;
-    typedef typename allocator_traits<allocator_type>::const_pointer   const_pointer;
-    typedef typename allocator_traits<allocator_type>::size_type       size_type;
-    typedef typename allocator_traits<allocator_type>::difference_type difference_type;
-
-    typedef /unspecified/ iterator;
-    typedef /unspecified/ const_iterator;
-    typedef /unspecified/ local_iterator;
-    typedef /unspecified/ const_local_iterator;
-
-    hash_set()
-        noexcept(
-            is_nothrow_default_constructible<hasher>::value &&
-            is_nothrow_default_constructible<key_equal>::value &&
-            is_nothrow_default_constructible<allocator_type>::value);
-    explicit hash_set(size_type n, const hasher& hf = hasher(),
-                           const key_equal& eql = key_equal(),
-                           const allocator_type& a = allocator_type());
-    template <class InputIterator>
-        hash_set(InputIterator f, InputIterator l,
-                      size_type n = 0, const hasher& hf = hasher(),
-                      const key_equal& eql = key_equal(),
-                      const allocator_type& a = allocator_type());
-    explicit hash_set(const allocator_type&);
-    hash_set(const hash_set&);
-    hash_set(const hash_set&, const Allocator&);
-    hash_set(hash_set&&)
-        noexcept(
-            is_nothrow_move_constructible<hasher>::value &&
-            is_nothrow_move_constructible<key_equal>::value &&
-            is_nothrow_move_constructible<allocator_type>::value);
-    hash_set(hash_set&&, const Allocator&);
-    hash_set(initializer_list<value_type>, size_type n = 0,
-                  const hasher& hf = hasher(), const key_equal& eql = key_equal(),
-                  const allocator_type& a = allocator_type());
-    ~hash_set();
-    hash_set& operator=(const hash_set&);
-    hash_set& operator=(hash_set&&)
-        noexcept(
-            allocator_type::propagate_on_container_move_assignment::value &&
-            is_nothrow_move_assignable<allocator_type>::value &&
-            is_nothrow_move_assignable<hasher>::value &&
-            is_nothrow_move_assignable<key_equal>::value);
-    hash_set& operator=(initializer_list<value_type>);
-
-    allocator_type get_allocator() const noexcept;
-
-    bool      empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
-
-    iterator       begin() noexcept;
-    iterator       end() noexcept;
-    const_iterator begin()  const noexcept;
-    const_iterator end()    const noexcept;
-    const_iterator cbegin() const noexcept;
-    const_iterator cend()   const noexcept;
-
-    template <class... Args>
-        pair<iterator, bool> emplace(BOOST_FWD_REF(Args)... args);
-    template <class... Args>
-        iterator emplace_hint(const_iterator position, BOOST_FWD_REF(Args)... args);
-    pair<iterator, bool> insert(const value_type& obj);
-    pair<iterator, bool> insert(value_type&& obj);
-    iterator insert(const_iterator hint, const value_type& obj);
-    iterator insert(const_iterator hint, value_type&& obj);
-    template <class InputIterator>
-        void insert(InputIterator first, InputIterator last);
-    void insert(initializer_list<value_type>);
-
-    iterator erase(const_iterator position);
-    size_type erase(const key_type& k);
-    iterator erase(const_iterator first, const_iterator last);
-    void clear() noexcept;
-
-    void swap(hash_set&)
-        noexcept(
-            (!allocator_type::propagate_on_container_swap::value ||
-             __is_nothrow_swappable<allocator_type>::value) &&
-            __is_nothrow_swappable<hasher>::value &&
-            __is_nothrow_swappable<key_equal>::value);
-
-    hasher hash_function() const;
-    key_equal key_eq() const;
-
-    iterator       find(const key_type& k);
-    const_iterator find(const key_type& k) const;
-    size_type count(const key_type& k) const;
-    pair<iterator, iterator>             equal_range(const key_type& k);
-    pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
-
-    size_type bucket_count() const noexcept;
-    size_type max_bucket_count() const noexcept;
-
-    size_type bucket_size(size_type n) const;
-    size_type bucket(const key_type& k) const;
-
-    local_iterator       begin(size_type n);
-    local_iterator       end(size_type n);
-    const_local_iterator begin(size_type n) const;
-    const_local_iterator end(size_type n) const;
-    const_local_iterator cbegin(size_type n) const;
-    const_local_iterator cend(size_type n) const;
-
-    float load_factor() const noexcept;
-    float max_load_factor() const noexcept;
-    void max_load_factor(float z);
-    void rehash(size_type n);
-    void reserve(size_type n);
-};
diff --git a/contrib/libboost/boost_1_62_0/boost/core/addressof.hpp b/contrib/libboost/boost_1_62_0/boost/core/addressof.hpp
deleted file mode 100644
index 889b5825e19..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/core/addressof.hpp
+++ /dev/null
@@ -1,162 +0,0 @@
-// Copyright (C) 2002 Brad King (brad.king@kitware.com)
-//                    Douglas Gregor (gregod@cs.rpi.edu)
-//
-// Copyright (C) 2002, 2008, 2013 Peter Dimov
-//
-// 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)
-
-// For more information, see http://www.boost.org
-
-#ifndef BOOST_CORE_ADDRESSOF_HPP
-#define BOOST_CORE_ADDRESSOF_HPP
-
-# include <boost/config.hpp>
-# include <boost/detail/workaround.hpp>
-# include <cstddef>
-
-namespace boost
-{
-
-namespace detail
-{
-
-template<class T> struct addr_impl_ref
-{
-    T & v_;
-
-    BOOST_FORCEINLINE addr_impl_ref( T & v ): v_( v ) {}
-    BOOST_FORCEINLINE operator T& () const { return v_; }
-
-private:
-    addr_impl_ref & operator=(const addr_impl_ref &);
-};
-
-template<class T> struct addressof_impl
-{
-    static BOOST_FORCEINLINE T * f( T & v, long )
-    {
-        return reinterpret_cast<T*>(
-            &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
-    }
-
-    static BOOST_FORCEINLINE T * f( T * v, int )
-    {
-        return v;
-    }
-};
-
-#if !defined( BOOST_NO_CXX11_NULLPTR )
-
-#if !defined( BOOST_NO_CXX11_DECLTYPE ) && ( ( defined( __clang__ ) && !defined( _LIBCPP_VERSION ) ) || defined( __INTEL_COMPILER ) )
-
-    typedef decltype(nullptr) addr_nullptr_t;
-
-#else
-
-    typedef std::nullptr_t addr_nullptr_t;
-
-#endif
-
-template<> struct addressof_impl< addr_nullptr_t >
-{
-    typedef addr_nullptr_t T;
-
-    static BOOST_FORCEINLINE T * f( T & v, int )
-    {
-        return &v;
-    }
-};
-
-template<> struct addressof_impl< addr_nullptr_t const >
-{
-    typedef addr_nullptr_t const T;
-
-    static BOOST_FORCEINLINE T * f( T & v, int )
-    {
-        return &v;
-    }
-};
-
-template<> struct addressof_impl< addr_nullptr_t volatile >
-{
-    typedef addr_nullptr_t volatile T;
-
-    static BOOST_FORCEINLINE T * f( T & v, int )
-    {
-        return &v;
-    }
-};
-
-template<> struct addressof_impl< addr_nullptr_t const volatile >
-{
-    typedef addr_nullptr_t const volatile T;
-
-    static BOOST_FORCEINLINE T * f( T & v, int )
-    {
-        return &v;
-    }
-};
-
-#endif
-
-} // namespace detail
-
-template<class T>
-BOOST_FORCEINLINE
-T * addressof( T & v )
-{
-#if (defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x610 ) ) ) || (defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5120))
-
-    return boost::detail::addressof_impl<T>::f( v, 0 );
-
-#else
-
-    return boost::detail::addressof_impl<T>::f( boost::detail::addr_impl_ref<T>( v ), 0 );
-
-#endif
-}
-
-#if defined( __SUNPRO_CC ) && BOOST_WORKAROUND( __SUNPRO_CC, BOOST_TESTED_AT( 0x590 ) )
-
-namespace detail
-{
-
-template<class T> struct addressof_addp
-{
-    typedef T * type;
-};
-
-} // namespace detail
-
-template< class T, std::size_t N >
-BOOST_FORCEINLINE
-typename detail::addressof_addp< T[N] >::type addressof( T (&t)[N] )
-{
-    return &t;
-}
-
-#endif
-
-// Borland doesn't like casting an array reference to a char reference
-// but these overloads work around the problem.
-#if defined( __BORLANDC__ ) && BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-template<typename T,std::size_t N>
-BOOST_FORCEINLINE
-T (*addressof(T (&t)[N]))[N]
-{
-   return reinterpret_cast<T(*)[N]>(&t);
-}
-
-template<typename T,std::size_t N>
-BOOST_FORCEINLINE
-const T (*addressof(const T (&t)[N]))[N]
-{
-   return reinterpret_cast<const T(*)[N]>(&t);
-}
-#endif
-
-} // namespace boost
-
-#endif // BOOST_CORE_ADDRESSOF_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/core/checked_delete.hpp b/contrib/libboost/boost_1_62_0/boost/core/checked_delete.hpp
deleted file mode 100644
index b086e03e88a..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/core/checked_delete.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-#ifndef BOOST_CORE_CHECKED_DELETE_HPP
-#define BOOST_CORE_CHECKED_DELETE_HPP
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  boost/checked_delete.hpp
-//
-//  Copyright (c) 2002, 2003 Peter Dimov
-//  Copyright (c) 2003 Daniel Frey
-//  Copyright (c) 2003 Howard Hinnant
-//
-//  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/core/doc/html/core/checked_delete.html for documentation.
-//
-
-namespace boost
-{
-
-// verify that types are complete for increased safety
-
-template<class T> inline void checked_delete(T * x)
-{
-    // intentionally complex - simplification causes regressions
-    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
-    (void) sizeof(type_must_be_complete);
-    delete x;
-}
-
-template<class T> inline void checked_array_delete(T * x)
-{
-    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
-    (void) sizeof(type_must_be_complete);
-    delete [] x;
-}
-
-template<class T> struct checked_deleter
-{
-    typedef void result_type;
-    typedef T * argument_type;
-
-    void operator()(T * x) const
-    {
-        // boost:: disables ADL
-        boost::checked_delete(x);
-    }
-};
-
-template<class T> struct checked_array_deleter
-{
-    typedef void result_type;
-    typedef T * argument_type;
-
-    void operator()(T * x) const
-    {
-        boost::checked_array_delete(x);
-    }
-};
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_CORE_CHECKED_DELETE_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/core/demangle.hpp b/contrib/libboost/boost_1_62_0/boost/core/demangle.hpp
deleted file mode 100644
index f13c26a7f4d..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/core/demangle.hpp
+++ /dev/null
@@ -1,131 +0,0 @@
-#ifndef BOOST_CORE_DEMANGLE_HPP_INCLUDED
-#define BOOST_CORE_DEMANGLE_HPP_INCLUDED
-
-// core::demangle
-//
-// Copyright 2014 Peter Dimov
-// Copyright 2014 Andrey Semashev
-//
-// 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
-
-#include <boost/config.hpp>
-#include <string>
-
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-# pragma once
-#endif
-
-// __has_include is currently supported by GCC and Clang. However GCC 4.9 may have issues and
-// returns 1 for 'defined( __has_include )', while '__has_include' is actually not supported:
-// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63662
-#if defined( __has_include ) && (!defined( BOOST_GCC ) || (__GNUC__ + 0) >= 5)
-# if __has_include(<cxxabi.h>)
-#  define BOOST_CORE_HAS_CXXABI_H
-# endif
-#elif defined( __GLIBCXX__ ) || defined( __GLIBCPP__ )
-# define BOOST_CORE_HAS_CXXABI_H
-#endif
-
-#if defined( BOOST_CORE_HAS_CXXABI_H )
-# include <cxxabi.h>
-// For some archtectures (mips, mips64, x86, x86_64) cxxabi.h in Android NDK is implemented by gabi++ library
-// (https://android.googlesource.com/platform/ndk/+/master/sources/cxx-stl/gabi++/), which does not implement
-// abi::__cxa_demangle(). We detect this implementation by checking the include guard here.
-# if defined( __GABIXX_CXXABI_H__ )
-#  undef BOOST_CORE_HAS_CXXABI_H
-# else
-#  include <cstdlib>
-#  include <cstddef>
-# endif
-#endif
-
-namespace boost
-{
-
-namespace core
-{
-
-inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT;
-inline void demangle_free( char const * name ) BOOST_NOEXCEPT;
-
-class scoped_demangled_name
-{
-private:
-    char const * m_p;
-
-public:
-    explicit scoped_demangled_name( char const * name ) BOOST_NOEXCEPT :
-        m_p( demangle_alloc( name ) )
-    {
-    }
-
-    ~scoped_demangled_name() BOOST_NOEXCEPT
-    {
-        demangle_free( m_p );
-    }
-
-    char const * get() const BOOST_NOEXCEPT
-    {
-        return m_p;
-    }
-
-    BOOST_DELETED_FUNCTION(scoped_demangled_name( scoped_demangled_name const& ))
-    BOOST_DELETED_FUNCTION(scoped_demangled_name& operator= ( scoped_demangled_name const& ))
-};
-
-
-#if defined( BOOST_CORE_HAS_CXXABI_H )
-
-inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT
-{
-    int status = 0;
-    std::size_t size = 0;
-    return abi::__cxa_demangle( name, NULL, &size, &status );
-}
-
-inline void demangle_free( char const * name ) BOOST_NOEXCEPT
-{
-    std::free( const_cast< char* >( name ) );
-}
-
-inline std::string demangle( char const * name )
-{
-    scoped_demangled_name demangled_name( name );
-    char const * const p = demangled_name.get();
-    if( p )
-    {
-        return p;
-    }
-    else
-    {
-        return name;
-    }
-}
-
-#else
-
-inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT
-{
-    return name;
-}
-
-inline void demangle_free( char const * ) BOOST_NOEXCEPT
-{
-}
-
-inline std::string demangle( char const * name )
-{
-    return name;
-}
-
-#endif
-
-} // namespace core
-
-} // namespace boost
-
-#undef BOOST_CORE_HAS_CXXABI_H
-
-#endif // #ifndef BOOST_CORE_DEMANGLE_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/core/enable_if.hpp b/contrib/libboost/boost_1_62_0/boost/core/enable_if.hpp
deleted file mode 100644
index 5dcef1e0354..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/core/enable_if.hpp
+++ /dev/null
@@ -1,128 +0,0 @@
-// Boost enable_if library
-
-// Copyright 2003 (c) The Trustees of Indiana University.
-
-// 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)
-
-//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
-//             Jeremiah Willcock (jewillco at osl.iu.edu)
-//             Andrew Lumsdaine (lums at osl.iu.edu)
-
-
-#ifndef BOOST_CORE_ENABLE_IF_HPP
-#define BOOST_CORE_ENABLE_IF_HPP
-
-#include "boost/config.hpp"
-
-// Even the definition of enable_if causes problems on some compilers,
-// so it's macroed out for all compilers that do not support SFINAE
-
-#ifndef BOOST_NO_SFINAE
-
-namespace boost
-{
-  template<typename T, typename R=void>
-  struct enable_if_has_type
-  {
-    typedef R type;
-  };
- 
-  template <bool B, class T = void>
-  struct enable_if_c {
-    typedef T type;
-  };
-
-  template <class T>
-  struct enable_if_c<false, T> {};
-
-  template <class Cond, class T = void> 
-  struct enable_if : public enable_if_c<Cond::value, T> {};
-
-  template <bool B, class T>
-  struct lazy_enable_if_c {
-    typedef typename T::type type;
-  };
-
-  template <class T>
-  struct lazy_enable_if_c<false, T> {};
-
-  template <class Cond, class T> 
-  struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
-
-
-  template <bool B, class T = void>
-  struct disable_if_c {
-    typedef T type;
-  };
-
-  template <class T>
-  struct disable_if_c<true, T> {};
-
-  template <class Cond, class T = void> 
-  struct disable_if : public disable_if_c<Cond::value, T> {};
-
-  template <bool B, class T>
-  struct lazy_disable_if_c {
-    typedef typename T::type type;
-  };
-
-  template <class T>
-  struct lazy_disable_if_c<true, T> {};
-
-  template <class Cond, class T> 
-  struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
-
-} // namespace boost
-
-#else
-
-namespace boost {
-
-  namespace detail { typedef void enable_if_default_T; }
-
-  template <typename T>
-  struct enable_if_does_not_work_on_this_compiler;
-
-  template<typename T, typename R=void>
-  struct enable_if_has_type : enable_if_does_not_work_on_this_compiler<T>
-  { };
-
-  template <bool B, class T = detail::enable_if_default_T>
-  struct enable_if_c : enable_if_does_not_work_on_this_compiler<T>
-  { };
-
-  template <bool B, class T = detail::enable_if_default_T> 
-  struct disable_if_c : enable_if_does_not_work_on_this_compiler<T>
-  { };
-
-  template <bool B, class T = detail::enable_if_default_T> 
-  struct lazy_enable_if_c : enable_if_does_not_work_on_this_compiler<T>
-  { };
-
-  template <bool B, class T = detail::enable_if_default_T> 
-  struct lazy_disable_if_c : enable_if_does_not_work_on_this_compiler<T>
-  { };
-
-  template <class Cond, class T = detail::enable_if_default_T> 
-  struct enable_if : enable_if_does_not_work_on_this_compiler<T>
-  { };
-
-  template <class Cond, class T = detail::enable_if_default_T> 
-  struct disable_if : enable_if_does_not_work_on_this_compiler<T>
-  { };
-
-  template <class Cond, class T = detail::enable_if_default_T> 
-  struct lazy_enable_if : enable_if_does_not_work_on_this_compiler<T>
-  { };
-
-  template <class Cond, class T = detail::enable_if_default_T> 
-  struct lazy_disable_if : enable_if_does_not_work_on_this_compiler<T>
-  { };
-
-} // namespace boost
-
-#endif // BOOST_NO_SFINAE
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/core/explicit_operator_bool.hpp b/contrib/libboost/boost_1_62_0/boost/core/explicit_operator_bool.hpp
deleted file mode 100644
index a8936e2cd67..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/core/explicit_operator_bool.hpp
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- *          Copyright Andrey Semashev 2007 - 2013.
- * 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)
- */
-
-/*!
- * \file   explicit_operator_bool.hpp
- * \author Andrey Semashev
- * \date   08.03.2009
- *
- * This header defines a compatibility macro that implements an unspecified
- * \c bool operator idiom, which is superseded with explicit conversion operators in
- * C++11.
- */
-
-#ifndef BOOST_CORE_EXPLICIT_OPERATOR_BOOL_HPP
-#define BOOST_CORE_EXPLICIT_OPERATOR_BOOL_HPP
-
-#include <boost/config.hpp>
-
-#ifdef BOOST_HAS_PRAGMA_ONCE
-#pragma once
-#endif
-
-#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
-
-/*!
- * \brief The macro defines an explicit operator of conversion to \c bool
- *
- * The macro should be used inside the definition of a class that has to
- * support the conversion. The class should also implement <tt>operator!</tt>,
- * in terms of which the conversion operator will be implemented.
- */
-#define BOOST_EXPLICIT_OPERATOR_BOOL()\
-    BOOST_FORCEINLINE explicit operator bool () const\
-    {\
-        return !this->operator! ();\
-    }
-
-/*!
- * \brief The macro defines a noexcept explicit operator of conversion to \c bool
- *
- * The macro should be used inside the definition of a class that has to
- * support the conversion. The class should also implement <tt>operator!</tt>,
- * in terms of which the conversion operator will be implemented.
- */
-#define BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()\
-    BOOST_FORCEINLINE explicit operator bool () const BOOST_NOEXCEPT\
-    {\
-        return !this->operator! ();\
-    }
-
-/*!
- * \brief The macro defines a constexpr explicit operator of conversion to \c bool
- *
- * The macro should be used inside the definition of a class that has to
- * support the conversion. The class should also implement <tt>operator!</tt>,
- * in terms of which the conversion operator will be implemented.
- */
-#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\
-    BOOST_FORCEINLINE BOOST_CONSTEXPR explicit operator bool () const BOOST_NOEXCEPT\
-    {\
-        return !this->operator! ();\
-    }
-
-#else // !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
-
-#if (defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)) && !defined(BOOST_NO_COMPILER_CONFIG)
-// Sun C++ 5.3 can't handle the safe_bool idiom, so don't use it
-#define BOOST_NO_UNSPECIFIED_BOOL
-#endif // (defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)) && !defined(BOOST_NO_COMPILER_CONFIG)
-
-#if !defined(BOOST_NO_UNSPECIFIED_BOOL)
-
-namespace boost {
-
-namespace detail {
-
-#if !defined(_MSC_VER) && !defined(__IBMCPP__)
-
-    struct unspecified_bool
-    {
-        // NOTE TO THE USER: If you see this in error messages then you tried
-        // to apply an unsupported operator on the object that supports
-        // explicit conversion to bool.
-        struct OPERATORS_NOT_ALLOWED;
-        static void true_value(OPERATORS_NOT_ALLOWED*) {}
-    };
-    typedef void (*unspecified_bool_type)(unspecified_bool::OPERATORS_NOT_ALLOWED*);
-
-#else
-
-    // MSVC and VACPP are too eager to convert pointer to function to void* even though they shouldn't
-    struct unspecified_bool
-    {
-        // NOTE TO THE USER: If you see this in error messages then you tried
-        // to apply an unsupported operator on the object that supports
-        // explicit conversion to bool.
-        struct OPERATORS_NOT_ALLOWED;
-        void true_value(OPERATORS_NOT_ALLOWED*) {}
-    };
-    typedef void (unspecified_bool::*unspecified_bool_type)(unspecified_bool::OPERATORS_NOT_ALLOWED*);
-
-#endif
-
-} // namespace detail
-
-} // namespace boost
-
-#define BOOST_EXPLICIT_OPERATOR_BOOL()\
-    BOOST_FORCEINLINE operator boost::detail::unspecified_bool_type () const\
-    {\
-        return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\
-    }
-
-#define BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()\
-    BOOST_FORCEINLINE operator boost::detail::unspecified_bool_type () const BOOST_NOEXCEPT\
-    {\
-        return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\
-    }
-
-#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\
-    BOOST_FORCEINLINE BOOST_CONSTEXPR operator boost::detail::unspecified_bool_type () const BOOST_NOEXCEPT\
-    {\
-        return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\
-    }
-
-#else // !defined(BOOST_NO_UNSPECIFIED_BOOL)
-
-#define BOOST_EXPLICIT_OPERATOR_BOOL()\
-    BOOST_FORCEINLINE operator bool () const\
-    {\
-        return !this->operator! ();\
-    }
-
-#define BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()\
-    BOOST_FORCEINLINE operator bool () const BOOST_NOEXCEPT\
-    {\
-        return !this->operator! ();\
-    }
-
-#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\
-    BOOST_FORCEINLINE BOOST_CONSTEXPR operator bool () const BOOST_NOEXCEPT\
-    {\
-        return !this->operator! ();\
-    }
-
-#endif // !defined(BOOST_NO_UNSPECIFIED_BOOL)
-
-#endif // !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
-
-#endif // BOOST_CORE_EXPLICIT_OPERATOR_BOOL_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/core/ignore_unused.hpp b/contrib/libboost/boost_1_62_0/boost/core/ignore_unused.hpp
deleted file mode 100644
index 994e5f64763..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/core/ignore_unused.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
-//
-// 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)
-
-#ifndef BOOST_CORE_IGNORE_UNUSED_HPP
-#define BOOST_CORE_IGNORE_UNUSED_HPP
-
-#include <boost/config.hpp>
-
-namespace boost {
-
-#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
-
-template <typename... Ts>
-BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(Ts const& ...)
-{}
-
-template <typename... Ts>
-BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused()
-{}
-
-#else
-
-template <typename T1>
-BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1 const&)
-{}
-
-template <typename T1, typename T2>
-BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1 const&, T2 const&)
-{}
-
-template <typename T1, typename T2, typename T3>
-BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1 const&, T2 const&, T3 const&)
-{}
-
-template <typename T1, typename T2, typename T3, typename T4>
-BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1 const&, T2 const&, T3 const&, T4 const&)
-{}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1 const&, T2 const&, T3 const&, T4 const&, T5 const&)
-{}
-
-template <typename T1>
-BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused()
-{}
-
-template <typename T1, typename T2>
-BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused()
-{}
-
-template <typename T1, typename T2, typename T3>
-BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused()
-{}
-
-template <typename T1, typename T2, typename T3, typename T4>
-BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused()
-{}
-
-template <typename T1, typename T2, typename T3, typename T4, typename T5>
-BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused()
-{}
-
-#endif
-
-} // namespace boost
-
-#endif // BOOST_CORE_IGNORE_UNUSED_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/core/is_same.hpp b/contrib/libboost/boost_1_62_0/boost/core/is_same.hpp
deleted file mode 100644
index f373c654d5e..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/core/is_same.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-#ifndef BOOST_CORE_IS_SAME_HPP_INCLUDED
-#define BOOST_CORE_IS_SAME_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-// is_same<T1,T2>::value is true when T1 == T2
-//
-// Copyright 2014 Peter Dimov
-//
-// 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
-
-#include <boost/config.hpp>
-
-namespace boost
-{
-
-namespace core
-{
-
-template< class T1, class T2 > struct is_same
-{
-    BOOST_STATIC_CONSTANT( bool, value = false );
-};
-
-template< class T > struct is_same< T, T >
-{
-    BOOST_STATIC_CONSTANT( bool, value = true );
-};
-
-} // namespace core
-
-} // namespace boost
-
-#endif // #ifndef BOOST_CORE_IS_SAME_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/core/lightweight_test.hpp b/contrib/libboost/boost_1_62_0/boost/core/lightweight_test.hpp
deleted file mode 100644
index cdc8a72d8b7..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/core/lightweight_test.hpp
+++ /dev/null
@@ -1,171 +0,0 @@
-#ifndef BOOST_CORE_LIGHTWEIGHT_TEST_HPP
-#define BOOST_CORE_LIGHTWEIGHT_TEST_HPP
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-//
-//  boost/core/lightweight_test.hpp - lightweight test library
-//
-//  Copyright (c) 2002, 2009, 2014 Peter Dimov
-//  Copyright (2) Beman Dawes 2010, 2011
-//  Copyright (3) Ion Gaztanaga 2013
-//
-//  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
-//
-
-#include <boost/assert.hpp>
-#include <boost/current_function.hpp>
-#include <boost/core/no_exceptions_support.hpp>
-#include <iostream>
-
-//  IDE's like Visual Studio perform better if output goes to std::cout or
-//  some other stream, so allow user to configure output stream:
-#ifndef BOOST_LIGHTWEIGHT_TEST_OSTREAM
-# define BOOST_LIGHTWEIGHT_TEST_OSTREAM std::cerr
-#endif
-
-namespace boost
-{
-
-namespace detail
-{
-
-struct report_errors_reminder
-{
-    bool called_report_errors_function;
-
-    report_errors_reminder() : called_report_errors_function(false) {}
-
-    ~report_errors_reminder()
-    {
-        BOOST_ASSERT(called_report_errors_function);  // verify report_errors() was called  
-    }
-};
-
-inline report_errors_reminder& report_errors_remind()
-{
-    static report_errors_reminder r;
-    return r;
-}
-
-inline int & test_errors()
-{
-    static int x = 0;
-    report_errors_remind();
-    return x;
-}
-
-inline void test_failed_impl(char const * expr, char const * file, int line, char const * function)
-{
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM
-      << file << "(" << line << "): test '" << expr << "' failed in function '"
-      << function << "'" << std::endl;
-    ++test_errors();
-}
-
-inline void error_impl(char const * msg, char const * file, int line, char const * function)
-{
-    BOOST_LIGHTWEIGHT_TEST_OSTREAM
-      << file << "(" << line << "): " << msg << " in function '"
-      << function << "'" << std::endl;
-    ++test_errors();
-}
-
-inline void throw_failed_impl(char const * excep, char const * file, int line, char const * function)
-{
-   BOOST_LIGHTWEIGHT_TEST_OSTREAM
-    << file << "(" << line << "): Exception '" << excep << "' not thrown in function '"
-    << function << "'" << std::endl;
-   ++test_errors();
-}
-
-template<class T, class U> inline void test_eq_impl( char const * expr1, char const * expr2,
-  char const * file, int line, char const * function, T const & t, U const & u )
-{
-    if( t == u )
-    {
-        report_errors_remind();
-    }
-    else
-    {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM
-            << file << "(" << line << "): test '" << expr1 << " == " << expr2
-            << "' failed in function '" << function << "': "
-            << "'" << t << "' != '" << u << "'" << std::endl;
-        ++test_errors();
-    }
-}
-
-template<class T, class U> inline void test_ne_impl( char const * expr1, char const * expr2,
-  char const * file, int line, char const * function, T const & t, U const & u )
-{
-    if( t != u )
-    {
-        report_errors_remind();
-    }
-    else
-    {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM
-            << file << "(" << line << "): test '" << expr1 << " != " << expr2
-            << "' failed in function '" << function << "': "
-            << "'" << t << "' == '" << u << "'" << std::endl;
-        ++test_errors();
-    }
-}
-
-} // namespace detail
-
-inline int report_errors()
-{
-    boost::detail::report_errors_remind().called_report_errors_function = true;
-
-    int errors = boost::detail::test_errors();
-
-    if( errors == 0 )
-    {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM
-          << "No errors detected." << std::endl;
-        return 0;
-    }
-    else
-    {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM
-          << errors << " error" << (errors == 1? "": "s") << " detected." << std::endl;
-        return 1;
-    }
-}
-
-} // namespace boost
-
-#define BOOST_TEST(expr) ((expr)? (void)0: ::boost::detail::test_failed_impl(#expr, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION))
-
-#define BOOST_ERROR(msg) ( ::boost::detail::error_impl(msg, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )
-
-#define BOOST_TEST_EQ(expr1,expr2) ( ::boost::detail::test_eq_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
-#define BOOST_TEST_NE(expr1,expr2) ( ::boost::detail::test_ne_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
-
-#ifndef BOOST_NO_EXCEPTIONS
-   #define BOOST_TEST_THROWS( EXPR, EXCEP )                    \
-      try {                                                    \
-         EXPR;                                                 \
-         ::boost::detail::throw_failed_impl                    \
-         (#EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
-      }                                                        \
-      catch(EXCEP const&) {                                    \
-      }                                                        \
-      catch(...) {                                             \
-         ::boost::detail::throw_failed_impl                    \
-         (#EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
-      }                                                        \
-   //
-#else
-   #define BOOST_TEST_THROWS( EXPR, EXCEP )
-#endif
-
-#endif // #ifndef BOOST_CORE_LIGHTWEIGHT_TEST_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/core/lightweight_test_trait.hpp b/contrib/libboost/boost_1_62_0/boost/core/lightweight_test_trait.hpp
deleted file mode 100644
index 0e2aab4435d..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/core/lightweight_test_trait.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-#ifndef BOOST_CORE_LIGHTWEIGHT_TEST_TRAIT_HPP
-#define BOOST_CORE_LIGHTWEIGHT_TEST_TRAIT_HPP
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER)
-# pragma once
-#endif
-
-// boost/core/lightweight_test_trait.hpp
-//
-// BOOST_TEST_TRAIT_TRUE, BOOST_TEST_TRAIT_FALSE
-//
-// Copyright 2014 Peter Dimov
-//
-// 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
-
-#include <boost/core/lightweight_test.hpp>
-#include <boost/core/typeinfo.hpp>
-
-namespace boost
-{
-
-namespace detail
-{
-
-template< class T > inline void test_trait_impl( char const * trait, void (*)( T ),
-  bool expected, char const * file, int line, char const * function )
-{
-    if( T::value == expected )
-    {
-        report_errors_remind();
-    }
-    else
-    {
-        BOOST_LIGHTWEIGHT_TEST_OSTREAM
-            << file << "(" << line << "): predicate '" << trait << "' ["
-            << boost::core::demangled_name( BOOST_CORE_TYPEID(T) ) << "]"
-            << " test failed in function '" << function
-            << "' (should have been " << ( expected? "true": "false" ) << ")"
-            << std::endl;
-
-        ++test_errors();
-    }
-}
-
-} // namespace detail
-
-} // namespace boost
-
-#define BOOST_TEST_TRAIT_TRUE(type) ( ::boost::detail::test_trait_impl(#type, (void(*)type)0, true, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )
-#define BOOST_TEST_TRAIT_FALSE(type) ( ::boost::detail::test_trait_impl(#type, (void(*)type)0, false, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )
-
-#endif // #ifndef BOOST_CORE_LIGHTWEIGHT_TEST_TRAIT_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/core/no_exceptions_support.hpp b/contrib/libboost/boost_1_62_0/boost/core/no_exceptions_support.hpp
deleted file mode 100644
index a697f01a526..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/core/no_exceptions_support.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-#ifndef BOOST_CORE_NO_EXCEPTIONS_SUPPORT_HPP
-#define BOOST_CORE_NO_EXCEPTIONS_SUPPORT_HPP
-
-#if defined(_MSC_VER)
-#  pragma once
-#endif
-
-//----------------------------------------------------------------------
-// (C) Copyright 2004 Pavel Vozenilek.
-// 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)
-//
-//
-// This file contains helper macros used when exception support may be
-// disabled (as indicated by macro BOOST_NO_EXCEPTIONS).
-//
-// Before picking up these macros you may consider using RAII techniques
-// to deal with exceptions - their syntax can be always the same with 
-// or without exception support enabled.
-//----------------------------------------------------------------------
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#if !(defined BOOST_NO_EXCEPTIONS)
-#    define BOOST_TRY { try
-#    define BOOST_CATCH(x) catch(x)
-#    define BOOST_RETHROW throw;
-#    define BOOST_CATCH_END }
-#else
-#    if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-#        define BOOST_TRY { if ("")
-#        define BOOST_CATCH(x) else if (!"")
-#    else
-#        define BOOST_TRY { if (true)
-#        define BOOST_CATCH(x) else if (false)
-#    endif
-#    define BOOST_RETHROW
-#    define BOOST_CATCH_END }
-#endif
-
-
-#endif 
diff --git a/contrib/libboost/boost_1_62_0/boost/core/noncopyable.hpp b/contrib/libboost/boost_1_62_0/boost/core/noncopyable.hpp
deleted file mode 100644
index 6ae8c244dd4..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/core/noncopyable.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//  Boost noncopyable.hpp header file  --------------------------------------//
-
-//  (C) Copyright Beman Dawes 1999-2003. 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/utility for documentation.
-
-#ifndef BOOST_CORE_NONCOPYABLE_HPP
-#define BOOST_CORE_NONCOPYABLE_HPP
-
-#include <boost/config.hpp>
-
-namespace boost {
-
-//  Private copy constructor and copy assignment ensure classes derived from
-//  class noncopyable cannot be copied.
-
-//  Contributed by Dave Abrahams
-
-namespace noncopyable_  // protection from unintended ADL
-{
-  class noncopyable
-  {
-  protected:
-#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS)
-      BOOST_CONSTEXPR noncopyable() = default;
-      ~noncopyable() = default;
-#else
-      noncopyable() {}
-      ~noncopyable() {}
-#endif
-#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
-      noncopyable( const noncopyable& ) = delete;
-      noncopyable& operator=( const noncopyable& ) = delete;
-#else
-  private:  // emphasize the following members are private
-      noncopyable( const noncopyable& );
-      noncopyable& operator=( const noncopyable& );
-#endif
-  };
-}
-
-typedef noncopyable_::noncopyable noncopyable;
-
-} // namespace boost
-
-#endif  // BOOST_CORE_NONCOPYABLE_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/core/null_deleter.hpp b/contrib/libboost/boost_1_62_0/boost/core/null_deleter.hpp
deleted file mode 100644
index f0af59034ef..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/core/null_deleter.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- *          Copyright Andrey Semashev 2007 - 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)
- */
-/*!
- * \file   null_deleter.hpp
- * \author Andrey Semashev
- * \date   22.04.2007
- *
- * This header contains a \c null_deleter implementation. This is an empty
- * function object that receives a pointer and does nothing with it.
- * Such empty deletion strategy may be convenient, for example, when
- * constructing <tt>shared_ptr</tt>s that point to some object that should not be
- * deleted (i.e. a variable on the stack or some global singleton, like <tt>std::cout</tt>).
- */
-
-#ifndef BOOST_CORE_NULL_DELETER_HPP
-#define BOOST_CORE_NULL_DELETER_HPP
-
-#include <boost/config.hpp>
-
-#ifdef BOOST_HAS_PRAGMA_ONCE
-#pragma once
-#endif
-
-namespace boost {
-
-//! A function object that does nothing and can be used as an empty deleter for \c shared_ptr
-struct null_deleter
-{
-    //! Function object result type
-    typedef void result_type;
-    /*!
-     * Does nothing
-     */
-    template< typename T >
-    void operator() (T*) const BOOST_NOEXCEPT {}
-};
-
-} // namespace boost
-
-#endif // BOOST_CORE_NULL_DELETER_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/core/ref.hpp b/contrib/libboost/boost_1_62_0/boost/core/ref.hpp
deleted file mode 100644
index 47dc8580078..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/core/ref.hpp
+++ /dev/null
@@ -1,301 +0,0 @@
-#ifndef BOOST_CORE_REF_HPP
-#define BOOST_CORE_REF_HPP
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-#include <boost/config.hpp>
-#include <boost/utility/addressof.hpp>
-#include <boost/detail/workaround.hpp>
-
-//
-//  ref.hpp - ref/cref, useful helper functions
-//
-//  Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
-//  Copyright (C) 2001, 2002 Peter Dimov
-//  Copyright (C) 2002 David Abrahams
-//
-//  Copyright (C) 2014 Glen Joseph Fernandes
-//  glenfe at live dot com
-//  Copyright (C) 2014 Agustin Berge
-//
-// 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/core/doc/html/core/ref.html for documentation.
-//
-
-/**
- @file
-*/
-
-/**
- Boost namespace.
-*/
-namespace boost
-{
-
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )
-
-    struct ref_workaround_tag {};
-
-#endif
-
-// reference_wrapper
-
-/**
- @brief Contains a reference to an object of type `T`.
-
- `reference_wrapper` is primarily used to "feed" references to
- function templates (algorithms) that take their parameter by
- value. It provides an implicit conversion to `T&`, which
- usually allows the function templates to work on references
- unmodified.
-*/
-template<class T> class reference_wrapper
-{
-public:
-    /**
-     Type `T`.
-    */
-    typedef T type;
-
-    /**
-     Constructs a `reference_wrapper` object that stores a
-     reference to `t`.
-
-     @remark Does not throw.
-    */
-    BOOST_FORCEINLINE explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}
-
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )
-
-    BOOST_FORCEINLINE explicit reference_wrapper( T & t, ref_workaround_tag ): t_( boost::addressof( t ) ) {}
-
-#endif
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-    /**
-     @remark Construction from a temporary object is disabled.
-    */
-    BOOST_DELETED_FUNCTION(reference_wrapper(T&& t))
-public:
-#endif
-
-    /**
-     @return The stored reference.
-     @remark Does not throw.
-    */
-    BOOST_FORCEINLINE operator T& () const { return *t_; }
-
-    /**
-     @return The stored reference.
-     @remark Does not throw.
-    */
-    BOOST_FORCEINLINE T& get() const { return *t_; }
-
-    /**
-     @return A pointer to the object referenced by the stored
-       reference.
-     @remark Does not throw.
-    */
-    BOOST_FORCEINLINE T* get_pointer() const { return t_; }
-
-private:
-
-    T* t_;
-};
-
-// ref
-
-/**
- @cond
-*/
-#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) )
-#  define BOOST_REF_CONST
-#else
-#  define BOOST_REF_CONST const
-#endif
-/**
- @endcond
-*/
-
-/**
- @return `reference_wrapper<T>(t)`
- @remark Does not throw.
-*/
-template<class T> BOOST_FORCEINLINE reference_wrapper<T> BOOST_REF_CONST ref( T & t )
-{
-#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )
-
-    return reference_wrapper<T>( t, ref_workaround_tag() );
-
-#else
-
-    return reference_wrapper<T>( t );
-
-#endif
-}
-
-// cref
-
-/**
- @return `reference_wrapper<T const>(t)`
- @remark Does not throw.
-*/
-template<class T> BOOST_FORCEINLINE reference_wrapper<T const> BOOST_REF_CONST cref( T const & t )
-{
-    return reference_wrapper<T const>(t);
-}
-
-#undef BOOST_REF_CONST
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-
-/**
- @cond
-*/
-#if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
-#  define BOOST_REF_DELETE
-#else
-#  define BOOST_REF_DELETE = delete
-#endif
-/**
- @endcond
-*/
-
-/**
- @remark Construction from a temporary object is disabled.
-*/
-template<class T> void ref(T const&&) BOOST_REF_DELETE;
-
-/**
- @remark Construction from a temporary object is disabled.
-*/
-template<class T> void cref(T const&&) BOOST_REF_DELETE;
-
-#undef BOOST_REF_DELETE
-
-#endif
-
-// is_reference_wrapper
-
-/**
- @brief Determine if a type `T` is an instantiation of
- `reference_wrapper`.
-
- The value static constant will be true if the type `T` is a
- specialization of `reference_wrapper`.
-*/
-template<typename T> struct is_reference_wrapper
-{
-    BOOST_STATIC_CONSTANT( bool, value = false );
-};
-
-/**
- @cond
-*/
-template<typename T> struct is_reference_wrapper< reference_wrapper<T> >
-{
-    BOOST_STATIC_CONSTANT( bool, value = true );
-};
-
-#if !defined(BOOST_NO_CV_SPECIALIZATIONS)
-
-template<typename T> struct is_reference_wrapper< reference_wrapper<T> const >
-{
-    BOOST_STATIC_CONSTANT( bool, value = true );
-};
-
-template<typename T> struct is_reference_wrapper< reference_wrapper<T> volatile >
-{
-    BOOST_STATIC_CONSTANT( bool, value = true );
-};
-
-template<typename T> struct is_reference_wrapper< reference_wrapper<T> const volatile >
-{
-    BOOST_STATIC_CONSTANT( bool, value = true );
-};
-
-#endif // !defined(BOOST_NO_CV_SPECIALIZATIONS)
-
-/**
- @endcond
-*/
-
-
-// unwrap_reference
-
-/**
- @brief Find the type in a `reference_wrapper`.
-
- The `typedef` type is `T::type` if `T` is a
- `reference_wrapper`, `T` otherwise.
-*/
-template<typename T> struct unwrap_reference
-{
-    typedef T type;
-};
-
-/**
- @cond
-*/
-template<typename T> struct unwrap_reference< reference_wrapper<T> >
-{
-    typedef T type;
-};
-
-#if !defined(BOOST_NO_CV_SPECIALIZATIONS)
-
-template<typename T> struct unwrap_reference< reference_wrapper<T> const >
-{
-    typedef T type;
-};
-
-template<typename T> struct unwrap_reference< reference_wrapper<T> volatile >
-{
-    typedef T type;
-};
-
-template<typename T> struct unwrap_reference< reference_wrapper<T> const volatile >
-{
-    typedef T type;
-};
-
-#endif // !defined(BOOST_NO_CV_SPECIALIZATIONS)
-
-/**
- @endcond
-*/
-
-// unwrap_ref
-
-/**
- @return `unwrap_reference<T>::type&(t)`
- @remark Does not throw.
-*/
-template<class T> BOOST_FORCEINLINE typename unwrap_reference<T>::type& unwrap_ref( T & t )
-{
-    return t;
-}
-
-// get_pointer
-
-/**
- @cond
-*/
-template<class T> BOOST_FORCEINLINE T* get_pointer( reference_wrapper<T> const & r )
-{
-    return r.get_pointer();
-}
-/**
- @endcond
-*/
-
-} // namespace boost
-
-#endif // #ifndef BOOST_CORE_REF_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/core/scoped_enum.hpp b/contrib/libboost/boost_1_62_0/boost/core/scoped_enum.hpp
deleted file mode 100644
index 56dd0ede439..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/core/scoped_enum.hpp
+++ /dev/null
@@ -1,194 +0,0 @@
-//  scoped_enum.hpp  ---------------------------------------------------------//
-
-//  Copyright Beman Dawes, 2009
-//  Copyright (C) 2011-2012 Vicente J. Botet Escriba
-//  Copyright (C) 2012 Anthony Williams
-
-//  Distributed under the Boost Software License, Version 1.0.
-//  See http://www.boost.org/LICENSE_1_0.txt
-
-#ifndef BOOST_CORE_SCOPED_ENUM_HPP
-#define BOOST_CORE_SCOPED_ENUM_HPP
-
-#include <boost/config.hpp>
-
-#ifdef BOOST_HAS_PRAGMA_ONCE
-#pragma once
-#endif
-
-namespace boost
-{
-
-#ifdef BOOST_NO_CXX11_SCOPED_ENUMS
-
-  /**
-   * Meta-function to get the native enum type associated to an enum class or its emulation.
-   */
-  template <typename EnumType>
-  struct native_type
-  {
-    /**
-     * The member typedef type names the native enum type associated to the scoped enum,
-     * which is it self if the compiler supports scoped enums or EnumType::enum_type if it is an emulated scoped enum.
-     */
-    typedef typename EnumType::enum_type type;
-  };
-
-  /**
-   * Casts a scoped enum to its underlying type.
-   *
-   * This function is useful when working with scoped enum classes, which doens't implicitly convert to the underlying type.
-   * @param v A scoped enum.
-   * @returns The underlying type.
-   * @throws No-throws.
-   */
-  template <typename UnderlyingType, typename EnumType>
-  inline
-  BOOST_CONSTEXPR UnderlyingType underlying_cast(EnumType v) BOOST_NOEXCEPT
-  {
-    return v.get_underlying_value_();
-  }
-
-  /**
-   * Casts a scoped enum to its native enum type.
-   *
-   * This function is useful to make programs portable when the scoped enum emulation can not be use where native enums can.
-   *
-   * EnumType the scoped enum type
-   *
-   * @param v A scoped enum.
-   * @returns The native enum value.
-   * @throws No-throws.
-   */
-  template <typename EnumType>
-  inline
-  BOOST_CONSTEXPR typename EnumType::enum_type native_value(EnumType e) BOOST_NOEXCEPT
-  {
-    return e.get_native_value_();
-  }
-
-#else  // BOOST_NO_CXX11_SCOPED_ENUMS
-
-  template <typename EnumType>
-  struct native_type
-  {
-    typedef EnumType type;
-  };
-
-  template <typename UnderlyingType, typename EnumType>
-  inline
-  BOOST_CONSTEXPR UnderlyingType underlying_cast(EnumType v) BOOST_NOEXCEPT
-  {
-    return static_cast<UnderlyingType>(v);
-  }
-
-  template <typename EnumType>
-  inline
-  BOOST_CONSTEXPR EnumType native_value(EnumType e) BOOST_NOEXCEPT
-  {
-    return e;
-  }
-
-#endif // BOOST_NO_CXX11_SCOPED_ENUMS
-}
-
-
-#ifdef BOOST_NO_CXX11_SCOPED_ENUMS
-
-#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
-
-#define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR \
-     explicit BOOST_CONSTEXPR operator underlying_type() const BOOST_NOEXCEPT { return get_underlying_value_(); }
-
-#else
-
-#define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR
-
-#endif
-
-/**
- * Start a declaration of a scoped enum.
- *
- * @param EnumType The new scoped enum.
- * @param UnderlyingType The underlying type.
- */
-#define BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType, UnderlyingType)    \
-    struct EnumType {                                                   \
-        typedef void is_boost_scoped_enum_tag;                          \
-        typedef UnderlyingType underlying_type;                         \
-        EnumType() BOOST_NOEXCEPT {}                                    \
-        explicit BOOST_CONSTEXPR EnumType(underlying_type v) BOOST_NOEXCEPT : v_(v) {}                 \
-        BOOST_CONSTEXPR underlying_type get_underlying_value_() const BOOST_NOEXCEPT { return v_; }    \
-        BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR                \
-    private:                                                            \
-        underlying_type v_;                                             \
-        typedef EnumType self_type;                                     \
-    public:                                                             \
-        enum enum_type
-
-#define BOOST_SCOPED_ENUM_DECLARE_END2() \
-        BOOST_CONSTEXPR enum_type get_native_value_() const BOOST_NOEXCEPT { return enum_type(v_); } \
-        friend BOOST_CONSTEXPR bool operator ==(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==enum_type(rhs.v_); } \
-        friend BOOST_CONSTEXPR bool operator ==(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==rhs; } \
-        friend BOOST_CONSTEXPR bool operator ==(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs==enum_type(rhs.v_); } \
-        friend BOOST_CONSTEXPR bool operator !=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=enum_type(rhs.v_); } \
-        friend BOOST_CONSTEXPR bool operator !=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=rhs; } \
-        friend BOOST_CONSTEXPR bool operator !=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs!=enum_type(rhs.v_); } \
-        friend BOOST_CONSTEXPR bool operator <(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<enum_type(rhs.v_); } \
-        friend BOOST_CONSTEXPR bool operator <(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<rhs; } \
-        friend BOOST_CONSTEXPR bool operator <(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<enum_type(rhs.v_); } \
-        friend BOOST_CONSTEXPR bool operator <=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=enum_type(rhs.v_); } \
-        friend BOOST_CONSTEXPR bool operator <=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=rhs; } \
-        friend BOOST_CONSTEXPR bool operator <=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<=enum_type(rhs.v_); } \
-        friend BOOST_CONSTEXPR bool operator >(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>enum_type(rhs.v_); } \
-        friend BOOST_CONSTEXPR bool operator >(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>rhs; } \
-        friend BOOST_CONSTEXPR bool operator >(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>enum_type(rhs.v_); } \
-        friend BOOST_CONSTEXPR bool operator >=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=enum_type(rhs.v_); } \
-        friend BOOST_CONSTEXPR bool operator >=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=rhs; } \
-        friend BOOST_CONSTEXPR bool operator >=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>=enum_type(rhs.v_); } \
-    };
-
-#define BOOST_SCOPED_ENUM_DECLARE_END(EnumType) \
-    ; \
-    BOOST_CONSTEXPR EnumType(enum_type v) BOOST_NOEXCEPT : v_(v) {}                 \
-    BOOST_SCOPED_ENUM_DECLARE_END2()
-
-/**
- * Starts a declaration of a scoped enum with the default int underlying type.
- *
- * @param EnumType The new scoped enum.
- */
-#define BOOST_SCOPED_ENUM_DECLARE_BEGIN(EnumType) \
-  BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType,int)
-
-/**
- * Name of the native enum type.
- *
- * @param EnumType The new scoped enum.
- */
-#define BOOST_SCOPED_ENUM_NATIVE(EnumType) EnumType::enum_type
-/**
- * Forward declares an scoped enum.
- *
- * @param EnumType The scoped enum.
- */
-#define BOOST_SCOPED_ENUM_FORWARD_DECLARE(EnumType) struct EnumType
-
-#else  // BOOST_NO_CXX11_SCOPED_ENUMS
-
-#define BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType,UnderlyingType) enum class EnumType : UnderlyingType
-#define BOOST_SCOPED_ENUM_DECLARE_BEGIN(EnumType) enum class EnumType
-#define BOOST_SCOPED_ENUM_DECLARE_END2()
-#define BOOST_SCOPED_ENUM_DECLARE_END(EnumType) ;
-
-#define BOOST_SCOPED_ENUM_NATIVE(EnumType) EnumType
-#define BOOST_SCOPED_ENUM_FORWARD_DECLARE(EnumType) enum class EnumType
-
-#endif  // BOOST_NO_CXX11_SCOPED_ENUMS
-
-// Deprecated macros
-#define BOOST_SCOPED_ENUM_START(name) BOOST_SCOPED_ENUM_DECLARE_BEGIN(name)
-#define BOOST_SCOPED_ENUM_END BOOST_SCOPED_ENUM_DECLARE_END2()
-#define BOOST_SCOPED_ENUM(name) BOOST_SCOPED_ENUM_NATIVE(name)
-
-#endif  // BOOST_CORE_SCOPED_ENUM_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/core/swap.hpp b/contrib/libboost/boost_1_62_0/boost/core/swap.hpp
deleted file mode 100644
index baa1be970df..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/core/swap.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-// Copyright (C) 2007, 2008 Steven Watanabe, Joseph Gauterin, Niels Dekker
-//
-// 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)
-// For more information, see http://www.boost.org
-
-
-#ifndef BOOST_CORE_SWAP_HPP
-#define BOOST_CORE_SWAP_HPP
-
-// Note: the implementation of this utility contains various workarounds:
-// - swap_impl is put outside the boost namespace, to avoid infinite
-// recursion (causing stack overflow) when swapping objects of a primitive
-// type.
-// - swap_impl has a using-directive, rather than a using-declaration,
-// because some compilers (including MSVC 7.1, Borland 5.9.3, and
-// Intel 8.1) don't do argument-dependent lookup when it has a
-// using-declaration instead.
-// - boost::swap has two template arguments, instead of one, to
-// avoid ambiguity when swapping objects of a Boost type that does
-// not have its own boost::swap overload.
-
-#include <utility> //for std::swap (C++11)
-#include <algorithm> //for std::swap (C++98)
-#include <cstddef> //for std::size_t
-#include <boost/config.hpp>
-
-namespace boost_swap_impl
-{
-  template<class T>
-  BOOST_GPU_ENABLED
-  void swap_impl(T& left, T& right)
-  {
-    using namespace std;//use std::swap if argument dependent lookup fails
-    swap(left,right);
-  }
-
-  template<class T, std::size_t N>
-  BOOST_GPU_ENABLED
-  void swap_impl(T (& left)[N], T (& right)[N])
-  {
-    for (std::size_t i = 0; i < N; ++i)
-    {
-      ::boost_swap_impl::swap_impl(left[i], right[i]);
-    }
-  }
-}
-
-namespace boost
-{
-  template<class T1, class T2>
-  BOOST_GPU_ENABLED
-  void swap(T1& left, T2& right)
-  {
-    ::boost_swap_impl::swap_impl(left, right);
-  }
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/core/typeinfo.hpp b/contrib/libboost/boost_1_62_0/boost/core/typeinfo.hpp
deleted file mode 100644
index e67b4a3198b..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/core/typeinfo.hpp
+++ /dev/null
@@ -1,151 +0,0 @@
-#ifndef BOOST_CORE_TYPEINFO_HPP_INCLUDED
-#define BOOST_CORE_TYPEINFO_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//  core::typeinfo, BOOST_CORE_TYPEID
-//
-//  Copyright 2007, 2014 Peter Dimov
-//
-//  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)
-
-#include <boost/config.hpp>
-
-#if defined( BOOST_NO_TYPEID )
-
-#include <boost/current_function.hpp>
-#include <functional>
-
-namespace boost
-{
-
-namespace core
-{
-
-class typeinfo
-{
-private:
-
-    typeinfo( typeinfo const& );
-    typeinfo& operator=( typeinfo const& );
-
-    char const * name_;
-
-public:
-
-    explicit typeinfo( char const * name ): name_( name )
-    {
-    }
-
-    bool operator==( typeinfo const& rhs ) const
-    {
-        return this == &rhs;
-    }
-
-    bool operator!=( typeinfo const& rhs ) const
-    {
-        return this != &rhs;
-    }
-
-    bool before( typeinfo const& rhs ) const
-    {
-        return std::less< typeinfo const* >()( this, &rhs );
-    }
-
-    char const* name() const
-    {
-        return name_;
-    }
-};
-
-inline char const * demangled_name( core::typeinfo const & ti )
-{
-    return ti.name();
-}
-
-} // namespace core
-
-namespace detail
-{
-
-template<class T> struct core_typeid_
-{
-    static boost::core::typeinfo ti_;
-
-    static char const * name()
-    {
-        return BOOST_CURRENT_FUNCTION;
-    }
-};
-
-#if defined(__SUNPRO_CC)
-// see #4199, the Sun Studio compiler gets confused about static initialization 
-// constructor arguments. But an assignment works just fine. 
-template<class T> boost::core::typeinfo core_typeid_< T >::ti_ = core_typeid_< T >::name();
-#else
-template<class T> boost::core::typeinfo core_typeid_< T >::ti_(core_typeid_< T >::name());
-#endif
-
-template<class T> struct core_typeid_< T & >: core_typeid_< T >
-{
-};
-
-template<class T> struct core_typeid_< T const >: core_typeid_< T >
-{
-};
-
-template<class T> struct core_typeid_< T volatile >: core_typeid_< T >
-{
-};
-
-template<class T> struct core_typeid_< T const volatile >: core_typeid_< T >
-{
-};
-
-} // namespace detail
-
-} // namespace boost
-
-#define BOOST_CORE_TYPEID(T) (boost::detail::core_typeid_<T>::ti_)
-
-#else
-
-#include <boost/core/demangle.hpp>
-#include <typeinfo>
-
-namespace boost
-{
-
-namespace core
-{
-
-#if defined( BOOST_NO_STD_TYPEINFO )
-
-typedef ::type_info typeinfo;
-
-#else
-
-typedef std::type_info typeinfo;
-
-#endif
-
-inline std::string demangled_name( core::typeinfo const & ti )
-{
-    return core::demangle( ti.name() );
-}
-
-} // namespace core
-
-} // namespace boost
-
-#define BOOST_CORE_TYPEID(T) typeid(T)
-
-#endif
-
-#endif  // #ifndef BOOST_CORE_TYPEINFO_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/core/underlying_type.hpp b/contrib/libboost/boost_1_62_0/boost/core/underlying_type.hpp
deleted file mode 100644
index 7ecba313f45..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/core/underlying_type.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//  underlying_type.hpp  ---------------------------------------------------------//
-
-//  Copyright Beman Dawes, 2009
-//  Copyright (C) 2011-2012 Vicente J. Botet Escriba
-//  Copyright (C) 2012 Anthony Williams
-//  Copyright (C) 2014 Andrey Semashev
-
-//  Distributed under the Boost Software License, Version 1.0.
-//  See http://www.boost.org/LICENSE_1_0.txt
-
-#ifndef BOOST_CORE_UNDERLYING_TYPE_HPP
-#define BOOST_CORE_UNDERLYING_TYPE_HPP
-
-#include <boost/config.hpp>
-
-// GCC 4.7 and later seem to provide std::underlying_type
-#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) || (defined(BOOST_GCC) && BOOST_GCC >= 40700 && defined(__GXX_EXPERIMENTAL_CXX0X__))
-#include <type_traits>
-#define BOOST_DETAIL_HAS_STD_UNDERLYING_TYPE
-#endif
-
-#ifdef BOOST_HAS_PRAGMA_ONCE
-#pragma once
-#endif
-
-namespace boost {
-
-namespace detail {
-
-template< typename EnumType, typename Void = void >
-struct underlying_type_impl;
-
-#if defined(BOOST_NO_CXX11_SCOPED_ENUMS)
-
-// Support for boost/core/scoped_enum.hpp
-template< typename EnumType >
-struct underlying_type_impl< EnumType, typename EnumType::is_boost_scoped_enum_tag >
-{
-    /**
-     * The member typedef type names the underlying type of EnumType. It is EnumType::underlying_type when the EnumType is an emulated scoped enum,
-     */
-    typedef typename EnumType::underlying_type type;
-};
-
-#endif
-
-#if defined(BOOST_DETAIL_HAS_STD_UNDERLYING_TYPE)
-
-template< typename EnumType, typename Void >
-struct underlying_type_impl
-{
-    typedef typename std::underlying_type< EnumType >::type type;
-};
-
-#endif
-
-} // namespace detail
-
-#if !defined(BOOST_NO_CXX11_SCOPED_ENUMS) && !defined(BOOST_DETAIL_HAS_STD_UNDERLYING_TYPE)
-#define BOOST_NO_UNDERLYING_TYPE
-#endif
-
-/**
- * Meta-function to get the underlying type of a scoped enum.
- *
- * Requires EnumType must be an enum type or the emulation of a scoped enum.
- * If BOOST_NO_UNDERLYING_TYPE is defined, the implementation will not be able
- * to deduce the underlying type of enums. The user is expected to specialize
- * this trait in this case.
- */
-template< typename EnumType >
-struct underlying_type :
-    public detail::underlying_type_impl< EnumType >
-{
-};
-
-} // namespace boost
-
-#endif  // BOOST_CORE_UNDERLYING_TYPE_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/N3757.hpp b/contrib/libboost/boost_1_62_0/boost/exception/N3757.hpp
deleted file mode 100644
index 23b06066b13..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/exception/N3757.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//Copyright (c) 2006-2013 Emil Dotchevski and Reverge Studios, Inc.
-
-//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 UUID_9011016A11A711E3B46CD9FA6088709B
-#define UUID_9011016A11A711E3B46CD9FA6088709B
-#if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
-#pragma GCC system_header
-#endif
-#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
-#pragma warning(push,1)
-#endif
-
-#include <boost/exception/info.hpp>
-#include <boost/exception/get_error_info.hpp>
-
-namespace
-boost
-    {
-    //Here we're using the boost::error_info machinery to store the info in the exception
-    //object. Within the context of N3757, this is strictly an implementation detail.
-
-    template <class Tag>
-    inline
-    void
-    exception::
-    set( typename Tag::type const & v )
-        {
-        exception_detail::set_info(*this,error_info<Tag,typename Tag::type>(v));
-        }
-
-    template <class Tag>
-    inline
-    typename Tag::type const *
-    exception::
-    get() const
-        {
-        return get_error_info<error_info<Tag,typename Tag::type> >(*this);
-        }
-    }
-
-#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
-#pragma warning(pop)
-#endif
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/integer/common_factor_rt.hpp b/contrib/libboost/boost_1_62_0/boost/integer/common_factor_rt.hpp
deleted file mode 100644
index c2b54db8e8d..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/integer/common_factor_rt.hpp
+++ /dev/null
@@ -1,460 +0,0 @@
-//  Boost common_factor_rt.hpp header file  ----------------------------------//
-
-//  (C) Copyright Daryle Walker and Paul Moore 2001-2002.  Permission to copy,
-//  use, modify, sell and distribute this software is granted provided this
-//  copyright notice appears in all copies.  This software is provided "as is"
-//  without express or implied warranty, and with no claim as to its suitability
-//  for any purpose. 
-
-// boostinspect:nolicense (don't complain about the lack of a Boost license)
-// (Paul Moore hasn't been in contact for years, so there's no way to change the
-// license.)
-
-//  See http://www.boost.org for updates, documentation, and revision history. 
-
-#ifndef BOOST_INTEGER_COMMON_FACTOR_RT_HPP
-#define BOOST_INTEGER_COMMON_FACTOR_RT_HPP
-
-#include <boost/integer_fwd.hpp>  // self include
-
-#include <boost/config.hpp>  // for BOOST_NESTED_TEMPLATE, etc.
-#include <boost/limits.hpp>  // for std::numeric_limits
-#include <climits>           // for CHAR_MIN
-#include <boost/detail/workaround.hpp>
-
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127 4244)  // Conditional expression is constant
-#endif
-
-namespace boost
-{
-namespace integer
-{
-
-
-//  Forward declarations for function templates  -----------------------------//
-
-template < typename IntegerType >
-    IntegerType  gcd( IntegerType const &a, IntegerType const &b );
-
-template < typename IntegerType >
-    IntegerType  lcm( IntegerType const &a, IntegerType const &b );
-
-
-//  Greatest common divisor evaluator class declaration  ---------------------//
-
-template < typename IntegerType >
-class gcd_evaluator
-{
-public:
-    // Types
-    typedef IntegerType  result_type, first_argument_type, second_argument_type;
-
-    // Function object interface
-    result_type  operator ()( first_argument_type const &a,
-     second_argument_type const &b ) const;
-
-};  // boost::integer::gcd_evaluator
-
-
-//  Least common multiple evaluator class declaration  -----------------------//
-
-template < typename IntegerType >
-class lcm_evaluator
-{
-public:
-    // Types
-    typedef IntegerType  result_type, first_argument_type, second_argument_type;
-
-    // Function object interface
-    result_type  operator ()( first_argument_type const &a,
-     second_argument_type const &b ) const;
-
-};  // boost::integer::lcm_evaluator
-
-
-//  Implementation details  --------------------------------------------------//
-
-namespace detail
-{
-    // Greatest common divisor for rings (including unsigned integers)
-    template < typename RingType >
-    RingType
-    gcd_euclidean
-    (
-        RingType a,
-        RingType b
-    )
-    {
-        // Avoid repeated construction
-        #ifndef __BORLANDC__
-        RingType const  zero = static_cast<RingType>( 0 );
-        #else
-        RingType  zero = static_cast<RingType>( 0 );
-        #endif
-
-        // Reduce by GCD-remainder property [GCD(a,b) == GCD(b,a MOD b)]
-        while ( true )
-        {
-            if ( a == zero )
-                return b;
-            b %= a;
-
-            if ( b == zero )
-                return a;
-            a %= b;
-        }
-    }
-
-    // Greatest common divisor for (signed) integers
-    template < typename IntegerType >
-    inline
-    IntegerType
-    gcd_integer
-    (
-        IntegerType const &  a,
-        IntegerType const &  b
-    )
-    {
-        // Avoid repeated construction
-        IntegerType const  zero = static_cast<IntegerType>( 0 );
-        IntegerType const  result = gcd_euclidean( a, b );
-
-        return ( result < zero ) ? static_cast<IntegerType>(-result) : result;
-    }
-
-    // Greatest common divisor for unsigned binary integers
-    template < typename BuiltInUnsigned >
-    BuiltInUnsigned
-    gcd_binary
-    (
-        BuiltInUnsigned  u,
-        BuiltInUnsigned  v
-    )
-    {
-        if ( u && v )
-        {
-            // Shift out common factors of 2
-            unsigned  shifts = 0;
-
-            while ( !(u & 1u) && !(v & 1u) )
-            {
-                ++shifts;
-                u >>= 1;
-                v >>= 1;
-            }
-
-            // Start with the still-even one, if any
-            BuiltInUnsigned  r[] = { u, v };
-            unsigned         which = static_cast<bool>( u & 1u );
-
-            // Whittle down the values via their differences
-            do
-            {
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
-                while ( !(r[ which ] & 1u) )
-                {
-                    r[ which ] = (r[which] >> 1);
-                }
-#else
-                // Remove factors of two from the even one
-                while ( !(r[ which ] & 1u) )
-                {
-                    r[ which ] >>= 1;
-                }
-#endif
-
-                // Replace the larger of the two with their difference
-                if ( r[!which] > r[which] )
-                {
-                    which ^= 1u;
-                }
-
-                r[ which ] -= r[ !which ];
-            }
-            while ( r[which] );
-
-            // Shift-in the common factor of 2 to the residues' GCD
-            return r[ !which ] << shifts;
-        }
-        else
-        {
-            // At least one input is zero, return the other
-            // (adding since zero is the additive identity)
-            // or zero if both are zero.
-            return u + v;
-        }
-    }
-
-    // Least common multiple for rings (including unsigned integers)
-    template < typename RingType >
-    inline
-    RingType
-    lcm_euclidean
-    (
-        RingType const &  a,
-        RingType const &  b
-    )
-    {
-        RingType const  zero = static_cast<RingType>( 0 );
-        RingType const  temp = gcd_euclidean( a, b );
-
-        return ( temp != zero ) ? ( a / temp * b ) : zero;
-    }
-
-    // Least common multiple for (signed) integers
-    template < typename IntegerType >
-    inline
-    IntegerType
-    lcm_integer
-    (
-        IntegerType const &  a,
-        IntegerType const &  b
-    )
-    {
-        // Avoid repeated construction
-        IntegerType const  zero = static_cast<IntegerType>( 0 );
-        IntegerType const  result = lcm_euclidean( a, b );
-
-        return ( result < zero ) ? static_cast<IntegerType>(-result) : result;
-    }
-
-    // Function objects to find the best way of computing GCD or LCM
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-    template < typename T, bool IsSpecialized, bool IsSigned >
-    struct gcd_optimal_evaluator_helper_t
-    {
-        T  operator ()( T const &a, T const &b )
-        {
-            return gcd_euclidean( a, b );
-        }
-    };
-
-    template < typename T >
-    struct gcd_optimal_evaluator_helper_t< T, true, true >
-    {
-        T  operator ()( T const &a, T const &b )
-        {
-            return gcd_integer( a, b );
-        }
-    };
-
-    template < typename T >
-    struct gcd_optimal_evaluator
-    {
-        T  operator ()( T const &a, T const &b )
-        {
-            typedef ::std::numeric_limits<T>  limits_type;
-
-            typedef gcd_optimal_evaluator_helper_t<T,
-             limits_type::is_specialized, limits_type::is_signed>  helper_type;
-
-            helper_type  solver;
-
-            return solver( a, b );
-        }
-    };
-#else // BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-    template < typename T >
-    struct gcd_optimal_evaluator
-    {
-        T  operator ()( T const &a, T const &b )
-        {
-            return gcd_integer( a, b );
-        }
-    };
-#endif
-
-    // Specialize for the built-in integers
-#define BOOST_PRIVATE_GCD_UF( Ut )                  \
-    template < >  struct gcd_optimal_evaluator<Ut>  \
-    {  Ut  operator ()( Ut a, Ut b ) const  { return gcd_binary( a, b ); }  }
-
-    BOOST_PRIVATE_GCD_UF( unsigned char );
-    BOOST_PRIVATE_GCD_UF( unsigned short );
-    BOOST_PRIVATE_GCD_UF( unsigned );
-    BOOST_PRIVATE_GCD_UF( unsigned long );
-
-#ifdef BOOST_HAS_LONG_LONG
-    BOOST_PRIVATE_GCD_UF( boost::ulong_long_type );
-#elif defined(BOOST_HAS_MS_INT64)
-    BOOST_PRIVATE_GCD_UF( unsigned __int64 );
-#endif
-
-#if CHAR_MIN == 0
-    BOOST_PRIVATE_GCD_UF( char ); // char is unsigned
-#endif
-
-#undef BOOST_PRIVATE_GCD_UF
-
-#define BOOST_PRIVATE_GCD_SF( St, Ut )                            \
-    template < >  struct gcd_optimal_evaluator<St>                \
-    {  St  operator ()( St a, St b ) const  { Ut const  a_abs =   \
-    static_cast<Ut>( a < 0 ? -a : +a ), b_abs = static_cast<Ut>(  \
-    b < 0 ? -b : +b ); return static_cast<St>(                    \
-    gcd_optimal_evaluator<Ut>()(a_abs, b_abs) ); }  }
-
-    BOOST_PRIVATE_GCD_SF( signed char, unsigned char );
-    BOOST_PRIVATE_GCD_SF( short, unsigned short );
-    BOOST_PRIVATE_GCD_SF( int, unsigned );
-    BOOST_PRIVATE_GCD_SF( long, unsigned long );
-
-#if CHAR_MIN < 0
-    BOOST_PRIVATE_GCD_SF( char, unsigned char ); // char is signed
-#endif
-
-#ifdef BOOST_HAS_LONG_LONG
-    BOOST_PRIVATE_GCD_SF( boost::long_long_type, boost::ulong_long_type );
-#elif defined(BOOST_HAS_MS_INT64)
-    BOOST_PRIVATE_GCD_SF( __int64, unsigned __int64 );
-#endif
-
-#undef BOOST_PRIVATE_GCD_SF
-
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-    template < typename T, bool IsSpecialized, bool IsSigned >
-    struct lcm_optimal_evaluator_helper_t
-    {
-        T  operator ()( T const &a, T const &b )
-        {
-            return lcm_euclidean( a, b );
-        }
-    };
-
-    template < typename T >
-    struct lcm_optimal_evaluator_helper_t< T, true, true >
-    {
-        T  operator ()( T const &a, T const &b )
-        {
-            return lcm_integer( a, b );
-        }
-    };
-
-    template < typename T >
-    struct lcm_optimal_evaluator
-    {
-        T  operator ()( T const &a, T const &b )
-        {
-            typedef ::std::numeric_limits<T>  limits_type;
-
-            typedef lcm_optimal_evaluator_helper_t<T,
-             limits_type::is_specialized, limits_type::is_signed>  helper_type;
-
-            helper_type  solver;
-
-            return solver( a, b );
-        }
-    };
-#else // BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-    template < typename T >
-    struct lcm_optimal_evaluator
-    {
-        T  operator ()( T const &a, T const &b )
-        {
-            return lcm_integer( a, b );
-        }
-    };
-#endif
-
-    // Functions to find the GCD or LCM in the best way
-    template < typename T >
-    inline
-    T
-    gcd_optimal
-    (
-        T const &  a,
-        T const &  b
-    )
-    {
-        gcd_optimal_evaluator<T>  solver;
-
-        return solver( a, b );
-    }
-
-    template < typename T >
-    inline
-    T
-    lcm_optimal
-    (
-        T const &  a,
-        T const &  b
-    )
-    {
-        lcm_optimal_evaluator<T>  solver;
-
-        return solver( a, b );
-    }
-
-}  // namespace detail
-
-
-//  Greatest common divisor evaluator member function definition  ------------//
-
-template < typename IntegerType >
-inline
-typename gcd_evaluator<IntegerType>::result_type
-gcd_evaluator<IntegerType>::operator ()
-(
-    first_argument_type const &   a,
-    second_argument_type const &  b
-) const
-{
-    return detail::gcd_optimal( a, b );
-}
-
-
-//  Least common multiple evaluator member function definition  --------------//
-
-template < typename IntegerType >
-inline
-typename lcm_evaluator<IntegerType>::result_type
-lcm_evaluator<IntegerType>::operator ()
-(
-    first_argument_type const &   a,
-    second_argument_type const &  b
-) const
-{
-    return detail::lcm_optimal( a, b );
-}
-
-
-//  Greatest common divisor and least common multiple function definitions  --//
-
-template < typename IntegerType >
-inline
-IntegerType
-gcd
-(
-    IntegerType const &  a,
-    IntegerType const &  b
-)
-{
-    gcd_evaluator<IntegerType>  solver;
-
-    return solver( a, b );
-}
-
-template < typename IntegerType >
-inline
-IntegerType
-lcm
-(
-    IntegerType const &  a,
-    IntegerType const &  b
-)
-{
-    lcm_evaluator<IntegerType>  solver;
-
-    return solver( a, b );
-}
-
-
-}  // namespace integer
-}  // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif  // BOOST_INTEGER_COMMON_FACTOR_RT_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/to_raw_pointer.hpp b/contrib/libboost/boost_1_62_0/boost/intrusive/detail/to_raw_pointer.hpp
deleted file mode 100644
index 8ea884959d9..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/to_raw_pointer.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-/////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Ion Gaztanaga  2014-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/libs/intrusive for documentation.
-//
-/////////////////////////////////////////////////////////////////////////////
-
-#ifndef BOOST_INTRUSIVE_DETAIL_TO_RAW_POINTER_HPP
-#define BOOST_INTRUSIVE_DETAIL_TO_RAW_POINTER_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#  include <boost/config.hpp>
-#endif
-
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#  pragma once
-#endif
-
-#include <boost/intrusive/detail/config_begin.hpp>
-#include <boost/intrusive/detail/workaround.hpp>
-#include <boost/intrusive/detail/pointer_element.hpp>
-
-namespace boost {
-namespace intrusive {
-namespace detail {
-
-template <class T>
-BOOST_INTRUSIVE_FORCEINLINE T* to_raw_pointer(T* p)
-{  return p; }
-
-template <class Pointer>
-BOOST_INTRUSIVE_FORCEINLINE typename boost::intrusive::pointer_element<Pointer>::type*
-to_raw_pointer(const Pointer &p)
-{  return boost::intrusive::detail::to_raw_pointer(p.operator->());  }
-
-} //namespace detail
-} //namespace intrusive
-} //namespace boost
-
-#include <boost/intrusive/detail/config_end.hpp>
-
-#endif //BOOST_INTRUSIVE_DETAIL_UTILITIES_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/math/common_factor_ct.hpp b/contrib/libboost/boost_1_62_0/boost/math/common_factor_ct.hpp
deleted file mode 100644
index bf58b94eb2a..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/math/common_factor_ct.hpp
+++ /dev/null
@@ -1,97 +0,0 @@
-//  Boost common_factor_ct.hpp header file  ----------------------------------//
-
-//  (C) Copyright Daryle Walker and Stephen Cleary 2001-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 updates, documentation, and revision history. 
-
-#ifndef BOOST_MATH_COMMON_FACTOR_CT_HPP
-#define BOOST_MATH_COMMON_FACTOR_CT_HPP
-
-#include <boost/math_fwd.hpp>  // self include
-#include <boost/config.hpp>  // for BOOST_STATIC_CONSTANT, etc.
-#include <boost/mpl/integral_c.hpp>
-
-namespace boost
-{
-namespace math
-{
-
-//  Implementation details  --------------------------------------------------//
-
-namespace detail
-{
-    // Build GCD with Euclid's recursive algorithm
-    template < static_gcd_type Value1, static_gcd_type Value2 >
-    struct static_gcd_helper_t
-    {
-    private:
-        BOOST_STATIC_CONSTANT( static_gcd_type, new_value1 = Value2 );
-        BOOST_STATIC_CONSTANT( static_gcd_type, new_value2 = Value1 % Value2 );
-
-        #ifndef __BORLANDC__
-        #define BOOST_DETAIL_GCD_HELPER_VAL(Value) static_cast<static_gcd_type>(Value)
-        #else
-        typedef static_gcd_helper_t  self_type;
-        #define BOOST_DETAIL_GCD_HELPER_VAL(Value)  (self_type:: Value )
-        #endif
-
-        typedef static_gcd_helper_t< BOOST_DETAIL_GCD_HELPER_VAL(new_value1),
-         BOOST_DETAIL_GCD_HELPER_VAL(new_value2) >  next_step_type;
-
-        #undef BOOST_DETAIL_GCD_HELPER_VAL
-
-    public:
-        BOOST_STATIC_CONSTANT( static_gcd_type, value = next_step_type::value );
-    };
-
-    // Non-recursive case
-    template < static_gcd_type Value1 >
-    struct static_gcd_helper_t< Value1, 0UL >
-    {
-        BOOST_STATIC_CONSTANT( static_gcd_type, value = Value1 );
-    };
-
-    // Build the LCM from the GCD
-    template < static_gcd_type Value1, static_gcd_type Value2 >
-    struct static_lcm_helper_t
-    {
-        typedef static_gcd_helper_t<Value1, Value2>  gcd_type;
-
-        BOOST_STATIC_CONSTANT( static_gcd_type, value = Value1 / gcd_type::value
-         * Value2 );
-    };
-
-    // Special case for zero-GCD values
-    template < >
-    struct static_lcm_helper_t< 0UL, 0UL >
-    {
-        BOOST_STATIC_CONSTANT( static_gcd_type, value = 0UL );
-    };
-
-}  // namespace detail
-
-
-//  Compile-time greatest common divisor evaluator class declaration  --------//
-
-template < static_gcd_type Value1, static_gcd_type Value2 >
-struct static_gcd : public mpl::integral_c<static_gcd_type, (detail::static_gcd_helper_t<Value1, Value2>::value) >
-{
-};  // boost::math::static_gcd
-
-
-//  Compile-time least common multiple evaluator class declaration  ----------//
-
-template < static_gcd_type Value1, static_gcd_type Value2 >
-struct static_lcm : public mpl::integral_c<static_gcd_type, (detail::static_lcm_helper_t<Value1, Value2>::value) >
-{
-};  // boost::math::static_lcm
-
-
-}  // namespace math
-}  // namespace boost
-
-
-#endif  // BOOST_MATH_COMMON_FACTOR_CT_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/math/common_factor_rt.hpp b/contrib/libboost/boost_1_62_0/boost/math/common_factor_rt.hpp
deleted file mode 100644
index 42320b62c23..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/math/common_factor_rt.hpp
+++ /dev/null
@@ -1,428 +0,0 @@
-//  (C) Copyright Jeremy William Murphy 2016.
-
-//  Use, modification and distribution are subject to the
-//  Boost Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_MATH_COMMON_FACTOR_RT_HPP
-#define BOOST_MATH_COMMON_FACTOR_RT_HPP
-
-#include <boost/assert.hpp>
-#include <boost/core/enable_if.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/type_traits.hpp>
-
-#include <boost/config.hpp>  // for BOOST_NESTED_TEMPLATE, etc.
-#include <boost/limits.hpp>  // for std::numeric_limits
-#include <climits>           // for CHAR_MIN
-#include <boost/detail/workaround.hpp>
-#include <iterator>
-#include <algorithm>
-#include <limits>
-
-#if (defined(BOOST_MSVC) || (defined(__clang__) && defined(__c2__)) || (defined(BOOST_INTEL) && defined(_MSC_VER))) && (defined(_M_IX86) || defined(_M_X64))
-#include <intrin.h>
-#endif
-
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4127 4244)  // Conditional expression is constant
-#endif
-
-namespace boost {
-   namespace math {
-
-      template <class T, bool a = is_unsigned<T>::value || (std::numeric_limits<T>::is_specialized && !std::numeric_limits<T>::is_signed)>
-      struct gcd_traits_abs_defaults
-      {
-         inline static const T& abs(const T& val) { return val; }
-      };
-      template <class T>
-      struct gcd_traits_abs_defaults<T, false>
-      {
-         inline static T abs(const T& val)
-         {
-            using std::abs;
-            return abs(val);
-         }
-      };
-
-      template <class T>
-      struct gcd_traits_defaults : public gcd_traits_abs_defaults<T>
-      {
-         BOOST_FORCEINLINE static unsigned make_odd(T& val)
-         {
-            unsigned r = 0;
-            while(!(val & 1u))
-            {
-               val >>= 1;
-               ++r;
-            }
-            return r;
-         }
-         inline static bool less(const T& a, const T& b)
-         {
-            return a < b;
-         }
-
-         enum method_type
-         {
-            method_euclid = 0,
-            method_binary = 1,
-            method_mixed = 2,
-         };
-
-         static const method_type method =
-            boost::has_right_shift_assign<T>::value && boost::has_left_shift_assign<T>::value && boost::has_less<T>::value && boost::has_modulus<T>::value
-            ? method_mixed :
-            boost::has_right_shift_assign<T>::value && boost::has_left_shift_assign<T>::value && boost::has_less<T>::value
-            ? method_binary : method_euclid;
-      };
-      //
-      // Default gcd_traits just inherits from defaults:
-      //
-      template <class T>
-      struct gcd_traits : public gcd_traits_defaults<T> {};
-      //
-      // Special handling for polynomials:
-      //
-      namespace tools {
-         template <class T>
-         class polynomial;
-      }
-
-      template <class T>
-      struct gcd_traits<boost::math::tools::polynomial<T> > : public gcd_traits_defaults<T>
-      {
-         static const boost::math::tools::polynomial<T>& abs(const boost::math::tools::polynomial<T>& val) { return val; }
-      };
-      //
-      // Some platforms have fast bitscan operations, that allow us to implement
-      // make_odd much more efficiently:
-      //
-#if (defined(BOOST_MSVC) || (defined(__clang__) && defined(__c2__)) || (defined(BOOST_INTEL) && defined(_MSC_VER))) && (defined(_M_IX86) || defined(_M_X64))
-#pragma intrinsic(_BitScanForward,)
-      template <>
-      struct gcd_traits<unsigned long> : public gcd_traits_defaults<unsigned long>
-      {
-         BOOST_FORCEINLINE static unsigned find_lsb(unsigned long val)
-         {
-            unsigned long result;
-            _BitScanForward(&result, val);
-            return result;
-         }
-         BOOST_FORCEINLINE static unsigned make_odd(unsigned long& val)
-         {
-            unsigned result = find_lsb(val);
-            val >>= result;
-            return result;
-         }
-      };
-
-#ifdef _M_X64
-#pragma intrinsic(_BitScanForward64)
-      template <>
-      struct gcd_traits<unsigned __int64> : public gcd_traits_defaults<unsigned __int64>
-      {
-         BOOST_FORCEINLINE static unsigned find_lsb(unsigned __int64 mask)
-         {
-            unsigned long result;
-            _BitScanForward64(&result, mask);
-            return result;
-         }
-         BOOST_FORCEINLINE static unsigned make_odd(unsigned __int64& val)
-         {
-            unsigned result = find_lsb(val);
-            val >>= result;
-            return result;
-         }
-      };
-#endif
-      //
-      // Other integer type are trivial adaptations of the above,
-      // this works for signed types too, as by the time these functions
-      // are called, all values are > 0.
-      //
-      template <> struct gcd_traits<long> : public gcd_traits_defaults<long> 
-      { BOOST_FORCEINLINE static unsigned make_odd(long& val){ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
-      template <> struct gcd_traits<unsigned int> : public gcd_traits_defaults<unsigned int> 
-      { BOOST_FORCEINLINE static unsigned make_odd(unsigned int& val){ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
-      template <> struct gcd_traits<int> : public gcd_traits_defaults<int> 
-      { BOOST_FORCEINLINE static unsigned make_odd(int& val){ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
-      template <> struct gcd_traits<unsigned short> : public gcd_traits_defaults<unsigned short> 
-      { BOOST_FORCEINLINE static unsigned make_odd(unsigned short& val){ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
-      template <> struct gcd_traits<short> : public gcd_traits_defaults<short> 
-      { BOOST_FORCEINLINE static unsigned make_odd(short& val){ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
-      template <> struct gcd_traits<unsigned char> : public gcd_traits_defaults<unsigned char> 
-      { BOOST_FORCEINLINE static unsigned make_odd(unsigned char& val){ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
-      template <> struct gcd_traits<signed char> : public gcd_traits_defaults<signed char> 
-      { BOOST_FORCEINLINE static signed make_odd(signed char& val){ signed result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
-      template <> struct gcd_traits<char> : public gcd_traits_defaults<char> 
-      { BOOST_FORCEINLINE static unsigned make_odd(char& val){ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
-      template <> struct gcd_traits<wchar_t> : public gcd_traits_defaults<wchar_t> 
-      { BOOST_FORCEINLINE static unsigned make_odd(wchar_t& val){ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
-#ifdef _M_X64
-      template <> struct gcd_traits<__int64> : public gcd_traits_defaults<__int64> 
-      { BOOST_FORCEINLINE static unsigned make_odd(__int64& val){ unsigned result = gcd_traits<unsigned __int64>::find_lsb(val); val >>= result; return result; } };
-#endif
-
-#elif defined(BOOST_GCC) || defined(__clang__) || (defined(BOOST_INTEL) && defined(__GNUC__))
-
-      template <>
-      struct gcd_traits<unsigned> : public gcd_traits_defaults<unsigned>
-      {
-         BOOST_FORCEINLINE static unsigned find_lsb(unsigned mask)
-         {
-            return __builtin_ctz(mask);
-         }
-         BOOST_FORCEINLINE static unsigned make_odd(unsigned& val)
-         {
-            unsigned result = find_lsb(val);
-            val >>= result;
-            return result;
-         }
-      };
-      template <>
-      struct gcd_traits<unsigned long> : public gcd_traits_defaults<unsigned long>
-      {
-         BOOST_FORCEINLINE static unsigned find_lsb(unsigned long mask)
-         {
-            return __builtin_ctzl(mask);
-         }
-         BOOST_FORCEINLINE static unsigned make_odd(unsigned long& val)
-         {
-            unsigned result = find_lsb(val);
-            val >>= result;
-            return result;
-         }
-      };
-      template <>
-      struct gcd_traits<boost::ulong_long_type> : public gcd_traits_defaults<boost::ulong_long_type>
-      {
-         BOOST_FORCEINLINE static unsigned find_lsb(boost::ulong_long_type mask)
-         {
-            return __builtin_ctzll(mask);
-         }
-         BOOST_FORCEINLINE static unsigned make_odd(boost::ulong_long_type& val)
-         {
-            unsigned result = find_lsb(val);
-            val >>= result;
-            return result;
-         }
-      };
-      //
-      // Other integer type are trivial adaptations of the above,
-      // this works for signed types too, as by the time these functions
-      // are called, all values are > 0.
-      //
-      template <> struct gcd_traits<boost::long_long_type> : public gcd_traits_defaults<boost::long_long_type>
-      {
-         BOOST_FORCEINLINE static unsigned make_odd(boost::long_long_type& val) { unsigned result = gcd_traits<boost::ulong_long_type>::find_lsb(val); val >>= result; return result; }
-      };
-      template <> struct gcd_traits<long> : public gcd_traits_defaults<long>
-      {
-         BOOST_FORCEINLINE static unsigned make_odd(long& val) { unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; }
-      };
-      template <> struct gcd_traits<int> : public gcd_traits_defaults<int>
-      {
-         BOOST_FORCEINLINE static unsigned make_odd(int& val) { unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; }
-      };
-      template <> struct gcd_traits<unsigned short> : public gcd_traits_defaults<unsigned short>
-      {
-         BOOST_FORCEINLINE static unsigned make_odd(unsigned short& val) { unsigned result = gcd_traits<unsigned>::find_lsb(val); val >>= result; return result; }
-      };
-      template <> struct gcd_traits<short> : public gcd_traits_defaults<short>
-      {
-         BOOST_FORCEINLINE static unsigned make_odd(short& val) { unsigned result = gcd_traits<unsigned>::find_lsb(val); val >>= result; return result; }
-      };
-      template <> struct gcd_traits<unsigned char> : public gcd_traits_defaults<unsigned char>
-      {
-         BOOST_FORCEINLINE static unsigned make_odd(unsigned char& val) { unsigned result = gcd_traits<unsigned>::find_lsb(val); val >>= result; return result; }
-      };
-      template <> struct gcd_traits<signed char> : public gcd_traits_defaults<signed char>
-      {
-         BOOST_FORCEINLINE static signed make_odd(signed char& val) { signed result = gcd_traits<unsigned>::find_lsb(val); val >>= result; return result; }
-      };
-      template <> struct gcd_traits<char> : public gcd_traits_defaults<char>
-      {
-         BOOST_FORCEINLINE static unsigned make_odd(char& val) { unsigned result = gcd_traits<unsigned>::find_lsb(val); val >>= result; return result; }
-      };
-      template <> struct gcd_traits<wchar_t> : public gcd_traits_defaults<wchar_t>
-      {
-         BOOST_FORCEINLINE static unsigned make_odd(wchar_t& val) { unsigned result = gcd_traits<unsigned>::find_lsb(val); val >>= result; return result; }
-      };
-#endif
-
-namespace detail
-{
-    
-   //
-   // The Mixed Binary Euclid Algorithm
-   // Sidi Mohamed Sedjelmaci
-   // Electronic Notes in Discrete Mathematics 35 (2009) 169�176
-   //
-   template <class T>
-   T mixed_binary_gcd(T u, T v)
-   {
-      using std::swap;
-      if(gcd_traits<T>::less(u, v))
-         swap(u, v);
-
-      unsigned shifts = 0;
-
-      if(!u)
-         return v;
-      if(!v)
-         return u;
-
-      shifts = std::min(gcd_traits<T>::make_odd(u), gcd_traits<T>::make_odd(v));
-
-      while(gcd_traits<T>::less(1, v))
-      {
-         u %= v;
-         v -= u;
-         if(!u)
-            return v << shifts;
-         if(!v)
-            return u << shifts;
-         gcd_traits<T>::make_odd(u);
-         gcd_traits<T>::make_odd(v);
-         if(gcd_traits<T>::less(u, v))
-            swap(u, v);
-      }
-      return (v == 1 ? v : u) << shifts;
-   }
-
-    /** Stein gcd (aka 'binary gcd')
-     * 
-     * From Mathematics to Generic Programming, Alexander Stepanov, Daniel Rose
-     */
-    template <typename SteinDomain>
-    SteinDomain Stein_gcd(SteinDomain m, SteinDomain n)
-    {
-        using std::swap;
-        BOOST_ASSERT(m >= 0);
-        BOOST_ASSERT(n >= 0);
-        if (m == SteinDomain(0))
-            return n;
-        if (n == SteinDomain(0))
-            return m;
-        // m > 0 && n > 0
-        int d_m = gcd_traits<SteinDomain>::make_odd(m);
-        int d_n = gcd_traits<SteinDomain>::make_odd(n);
-        // odd(m) && odd(n)
-        while (m != n)
-        {
-            if (n > m)
-                swap(n, m);
-            m -= n;
-            gcd_traits<SteinDomain>::make_odd(m);
-        }
-        // m == n
-        m <<= std::min(d_m, d_n);
-        return m;
-    }
-
-    
-    /** Euclidean algorithm
-     * 
-     * From Mathematics to Generic Programming, Alexander Stepanov, Daniel Rose
-     * 
-     */
-    template <typename EuclideanDomain>
-    inline EuclideanDomain Euclid_gcd(EuclideanDomain a, EuclideanDomain b)
-    {
-        using std::swap;
-        while (b != EuclideanDomain(0))
-        {
-            a %= b;
-            swap(a, b);
-        }
-        return a;
-    }
-
-
-    template <typename T>
-    inline BOOST_DEDUCED_TYPENAME enable_if_c<gcd_traits<T>::method == gcd_traits<T>::method_mixed, T>::type
-       optimal_gcd_select(T const &a, T const &b)
-    {
-       return detail::mixed_binary_gcd(a, b);
-    }
-
-    template <typename T>
-    inline BOOST_DEDUCED_TYPENAME enable_if_c<gcd_traits<T>::method == gcd_traits<T>::method_binary, T>::type
-       optimal_gcd_select(T const &a, T const &b)
-    {
-       return detail::Stein_gcd(a, b);
-    }
-
-    template <typename T>
-    inline BOOST_DEDUCED_TYPENAME enable_if_c<gcd_traits<T>::method == gcd_traits<T>::method_euclid, T>::type
-       optimal_gcd_select(T const &a, T const &b)
-    {
-       return detail::Euclid_gcd(a, b);
-    }
-
-    template <class T>
-    inline T lcm_imp(const T& a, const T& b)
-    {
-       T temp = boost::math::detail::optimal_gcd_select(a, b);
-#if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500)
-       return (temp != T(0)) ? T(a / temp * b) : T(0);
-#else
-       return temp ? T(a / temp * b) : T(0);
-#endif
-    }
-
-} // namespace detail
-
-
-template <typename Integer>
-inline Integer gcd(Integer const &a, Integer const &b)
-{
-    return detail::optimal_gcd_select(static_cast<Integer>(gcd_traits<Integer>::abs(a)), static_cast<Integer>(gcd_traits<Integer>::abs(b)));
-}
-
-template <typename Integer>
-inline Integer lcm(Integer const &a, Integer const &b)
-{
-   return detail::lcm_imp(static_cast<Integer>(gcd_traits<Integer>::abs(a)), static_cast<Integer>(gcd_traits<Integer>::abs(b)));
-}
-
-/**
- * Knuth, The Art of Computer Programming: Volume 2, Third edition, 1998
- * Chapter 4.5.2, Algorithm C: Greatest common divisor of n integers.
- *
- * Knuth counts down from n to zero but we naturally go from first to last.
- * We also return the termination position because it might be useful to know.
- * 
- * Partly by quirk, partly by design, this algorithm is defined for n = 1, 
- * because the gcd of {x} is x. It is not defined for n = 0.
- * 
- * @tparam  I   Input iterator.
- * @return  The gcd of the range and the iterator position at termination.
- */
-template <typename I>
-std::pair<typename std::iterator_traits<I>::value_type, I>
-gcd_range(I first, I last)
-{
-    BOOST_ASSERT(first != last);
-    typedef typename std::iterator_traits<I>::value_type T;
-    
-    T d = *first++;
-    while (d != T(1) && first != last)
-    {
-        d = gcd(d, *first);
-        first++;
-    }
-    return std::make_pair(d, first);
-}
-
-}  // namespace math
-}  // namespace boost
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#endif  // BOOST_MATH_COMMON_FACTOR_RT_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_i0.hpp b/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_i0.hpp
deleted file mode 100644
index 676eb715114..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_i0.hpp
+++ /dev/null
@@ -1,129 +0,0 @@
-//  Copyright (c) 2006 Xiaogang Zhang
-//  Use, modification and distribution are subject to the
-//  Boost Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_MATH_BESSEL_I0_HPP
-#define BOOST_MATH_BESSEL_I0_HPP
-
-#ifdef _MSC_VER
-#pragma once
-#endif
-
-#include <boost/math/tools/rational.hpp>
-#include <boost/math/tools/big_constant.hpp>
-#include <boost/assert.hpp>
-
-// Modified Bessel function of the first kind of order zero
-// minimax rational approximations on intervals, see
-// Blair and Edwards, Chalk River Report AECL-4928, 1974
-
-namespace boost { namespace math { namespace detail{
-
-template <typename T>
-T bessel_i0(T x);
-
-template <class T>
-struct bessel_i0_initializer
-{
-   struct init
-   {
-      init()
-      {
-         do_init();
-      }
-      static void do_init()
-      {
-         bessel_i0(T(1));
-      }
-      void force_instantiate()const{}
-   };
-   static const init initializer;
-   static void force_instantiate()
-   {
-      initializer.force_instantiate();
-   }
-};
-
-template <class T>
-const typename bessel_i0_initializer<T>::init bessel_i0_initializer<T>::initializer;
-
-template <typename T>
-T bessel_i0(T x)
-{
-    bessel_i0_initializer<T>::force_instantiate();
-
-    static const T P1[] = {
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.2335582639474375249e+15)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -5.5050369673018427753e+14)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -3.2940087627407749166e+13)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -8.4925101247114157499e+11)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.1912746104985237192e+10)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.0313066708737980747e+08)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -5.9545626019847898221e+05)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.4125195876041896775e+03)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -7.0935347449210549190e+00)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.5453977791786851041e-02)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.5172644670688975051e-05)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -3.0517226450451067446e-08)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.6843448573468483278e-11)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.5982226675653184646e-14)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -5.2487866627945699800e-18)),
-    };
-    static const T Q1[] = {
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.2335582639474375245e+15)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 7.8858692566751002988e+12)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.2207067397808979846e+10)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.0377081058062166144e+07)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -4.8527560179962773045e+03)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.0)),
-    };
-    static const T P2[] = {
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.2210262233306573296e-04)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.3067392038106924055e-02)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -4.4700805721174453923e-01)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 5.5674518371240761397e+00)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.3517945679239481621e+01)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 3.1611322818701131207e+01)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -9.6090021968656180000e+00)),
-    };
-    static const T Q2[] = {
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -5.5194330231005480228e-04)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 3.2547697594819615062e-02)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.1151759188741312645e+00)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.3982595353892851542e+01)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -6.0228002066743340583e+01)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 8.5539563258012929600e+01)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -3.1446690275135491500e+01)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.0)),
-    };
-    T value, factor, r;
-
-    BOOST_MATH_STD_USING
-    using namespace boost::math::tools;
-
-    BOOST_ASSERT(x >= 0); // negative x is handled before we get here
-    if (x == 0)
-    {
-        return static_cast<T>(1);
-    }
-    if (x <= 15)                        // x in (0, 15]
-    {
-        T y = x * x;
-        value = evaluate_polynomial(P1, y) / evaluate_polynomial(Q1, y);
-    }
-    else                                // x in (15, \infty)
-    {
-        T y = 1 / x - T(1) / 15;
-        r = evaluate_polynomial(P2, y) / evaluate_polynomial(Q2, y);
-        factor = exp(x) / sqrt(x);
-        value = factor * r;
-    }
-
-    return value;
-}
-
-}}} // namespaces
-
-#endif // BOOST_MATH_BESSEL_I0_HPP
-
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_i1.hpp b/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_i1.hpp
deleted file mode 100644
index b85bc675463..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_i1.hpp
+++ /dev/null
@@ -1,133 +0,0 @@
-//  Copyright (c) 2006 Xiaogang Zhang
-//  Use, modification and distribution are subject to the
-//  Boost Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_MATH_BESSEL_I1_HPP
-#define BOOST_MATH_BESSEL_I1_HPP
-
-#ifdef _MSC_VER
-#pragma once
-#endif
-
-#include <boost/math/tools/rational.hpp>
-#include <boost/math/tools/big_constant.hpp>
-#include <boost/assert.hpp>
-
-// Modified Bessel function of the first kind of order one
-// minimax rational approximations on intervals, see
-// Blair and Edwards, Chalk River Report AECL-4928, 1974
-
-namespace boost { namespace math { namespace detail{
-
-template <typename T>
-T bessel_i1(T x);
-
-template <class T>
-struct bessel_i1_initializer
-{
-   struct init
-   {
-      init()
-      {
-         do_init();
-      }
-      static void do_init()
-      {
-         bessel_i1(T(1));
-      }
-      void force_instantiate()const{}
-   };
-   static const init initializer;
-   static void force_instantiate()
-   {
-      initializer.force_instantiate();
-   }
-};
-
-template <class T>
-const typename bessel_i1_initializer<T>::init bessel_i1_initializer<T>::initializer;
-
-template <typename T>
-T bessel_i1(T x)
-{
-
-    bessel_i1_initializer<T>::force_instantiate();
-
-    static const T P1[] = {
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.4577180278143463643e+15)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.7732037840791591320e+14)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -6.9876779648010090070e+12)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.3357437682275493024e+11)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.4828267606612366099e+09)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.0588550724769347106e+07)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -5.1894091982308017540e+04)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.8225946631657315931e+02)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -4.7207090827310162436e-01)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -9.1746443287817501309e-04)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.3466829827635152875e-06)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.4831904935994647675e-09)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.1928788903603238754e-12)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -6.5245515583151902910e-16)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.9705291802535139930e-19)),
-    };
-    static const T Q1[] = {
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.9154360556286927285e+15)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 9.7887501377547640438e+12)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.4386907088588283434e+10)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.1594225856856884006e+07)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -5.1326864679904189920e+03)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.0)),
-    };
-    static const T P2[] = {
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.4582087408985668208e-05)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -8.9359825138577646443e-04)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2.9204895411257790122e-02)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -3.4198728018058047439e-01)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.3960118277609544334e+00)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.9746376087200685843e+00)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 8.5591872901933459000e-01)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -6.0437159056137599999e-02)),
-    };
-    static const T Q2[] = {
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 3.7510433111922824643e-05)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.2835624489492512649e-03)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 7.4212010813186530069e-02)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -8.5017476463217924408e-01)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 3.2593714889036996297e+00)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -3.8806586721556593450e+00)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.0)),
-    };
-    T value, factor, r, w;
-
-    BOOST_MATH_STD_USING
-    using namespace boost::math::tools;
-
-    BOOST_ASSERT(x >= 0); // negative x is handled before we get here
-    w = abs(x);
-    if (x == 0)
-    {
-        return static_cast<T>(0);
-    }
-    if (w <= 15)                        // w in (0, 15]
-    {
-        T y = x * x;
-        r = evaluate_polynomial(P1, y) / evaluate_polynomial(Q1, y);
-        factor = w;
-        value = factor * r;
-    }
-    else                                // w in (15, \infty)
-    {
-        T y = 1 / w - T(1) / 15;
-        r = evaluate_polynomial(P2, y) / evaluate_polynomial(Q2, y);
-        factor = exp(w) / sqrt(w);
-        value = factor * r;
-    }
-
-    return value;
-}
-
-}}} // namespaces
-
-#endif // BOOST_MATH_BESSEL_I1_HPP
-
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_k0.hpp b/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_k0.hpp
deleted file mode 100644
index 42041dc6737..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_k0.hpp
+++ /dev/null
@@ -1,158 +0,0 @@
-//  Copyright (c) 2006 Xiaogang Zhang
-//  Use, modification and distribution are subject to the
-//  Boost Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_MATH_BESSEL_K0_HPP
-#define BOOST_MATH_BESSEL_K0_HPP
-
-#ifdef _MSC_VER
-#pragma once
-#pragma warning(push)
-#pragma warning(disable:4702) // Unreachable code (release mode only warning)
-#endif
-
-#include <boost/math/tools/rational.hpp>
-#include <boost/math/tools/big_constant.hpp>
-#include <boost/math/policies/error_handling.hpp>
-#include <boost/assert.hpp>
-
-// Modified Bessel function of the second kind of order zero
-// minimax rational approximations on intervals, see
-// Russon and Blair, Chalk River Report AECL-3461, 1969
-
-namespace boost { namespace math { namespace detail{
-
-template <typename T, typename Policy>
-T bessel_k0(T x, const Policy&);
-
-template <class T, class Policy>
-struct bessel_k0_initializer
-{
-   struct init
-   {
-      init()
-      {
-         do_init();
-      }
-      static void do_init()
-      {
-         bessel_k0(T(1), Policy());
-      }
-      void force_instantiate()const{}
-   };
-   static const init initializer;
-   static void force_instantiate()
-   {
-      initializer.force_instantiate();
-   }
-};
-
-template <class T, class Policy>
-const typename bessel_k0_initializer<T, Policy>::init bessel_k0_initializer<T, Policy>::initializer;
-
-template <typename T, typename Policy>
-T bessel_k0(T x, const Policy& pol)
-{
-    BOOST_MATH_INSTRUMENT_CODE(x);
-
-    bessel_k0_initializer<T, Policy>::force_instantiate();
-
-    static const T P1[] = {
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2.4708152720399552679e+03)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 5.9169059852270512312e+03)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 4.6850901201934832188e+02)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.1999463724910714109e+01)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.3166052564989571850e-01)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 5.8599221412826100000e-04))
-    };
-    static const T Q1[] = {
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2.1312714303849120380e+04)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.4994418972832303646e+02)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.0))
-    };
-    static const T P2[] = {
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.6128136304458193998e+06)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -3.7333769444840079748e+05)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.7984434409411765813e+04)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.9501657892958843865e+02)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.6414452837299064100e+00))
-    };
-    static const T Q2[] = {
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.6128136304458193998e+06)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2.9865713163054025489e+04)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.5064972445877992730e+02)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.0))
-    };
-    static const T P3[] = {
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.1600249425076035558e+02)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2.3444738764199315021e+03)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.8321525870183537725e+04)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 7.1557062783764037541e+04)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.5097646353289914539e+05)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.7398867902565686251e+05)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.0577068948034021957e+05)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 3.1075408980684392399e+04)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 3.6832589957340267940e+03)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.1394980557384778174e+02))
-    };
-    static const T Q3[] = {
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 9.2556599177304839811e+01)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.8821890840982713696e+03)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.4847228371802360957e+04)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 5.8824616785857027752e+04)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.2689839587977598727e+05)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.5144644673520157801e+05)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 9.7418829762268075784e+04)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 3.1474655750295278825e+04)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 4.4329628889746408858e+03)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2.0013443064949242491e+02)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.0))
-    };
-    T value, factor, r, r1, r2;
-
-    BOOST_MATH_STD_USING
-    using namespace boost::math::tools;
-
-    static const char* function = "boost::math::bessel_k0<%1%>(%1%,%1%)";
-
-    if (x < 0)
-    {
-       return policies::raise_domain_error<T>(function,
-            "Got x = %1%, but argument x must be non-negative, complex number result not supported", x, pol);
-    }
-    if (x == 0)
-    {
-       return policies::raise_overflow_error<T>(function, 0, pol);
-    }
-    if (x <= 1)                         // x in (0, 1]
-    {
-        T y = x * x;
-        r1 = evaluate_polynomial(P1, y) / evaluate_polynomial(Q1, y);
-        r2 = evaluate_polynomial(P2, y) / evaluate_polynomial(Q2, y);
-        factor = log(x);
-        value = r1 - factor * r2;
-    }
-    else                                // x in (1, \infty)
-    {
-        T y = 1 / x;
-        r = evaluate_polynomial(P3, y) / evaluate_polynomial(Q3, y);
-        factor = exp(-x) / sqrt(x);
-        value = factor * r;
-        BOOST_MATH_INSTRUMENT_CODE("y = " << y);
-        BOOST_MATH_INSTRUMENT_CODE("r = " << r);
-        BOOST_MATH_INSTRUMENT_CODE("factor = " << factor);
-        BOOST_MATH_INSTRUMENT_CODE("value = " << value);
-    }
-
-    return value;
-}
-
-}}} // namespaces
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_MATH_BESSEL_K0_HPP
-
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_k1.hpp b/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_k1.hpp
deleted file mode 100644
index c0c5478520f..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_k1.hpp
+++ /dev/null
@@ -1,154 +0,0 @@
-//  Copyright (c) 2006 Xiaogang Zhang
-//  Use, modification and distribution are subject to the
-//  Boost Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_MATH_BESSEL_K1_HPP
-#define BOOST_MATH_BESSEL_K1_HPP
-
-#ifdef _MSC_VER
-#pragma once
-#pragma warning(push)
-#pragma warning(disable:4702) // Unreachable code (release mode only warning)
-#endif
-
-#include <boost/math/tools/rational.hpp>
-#include <boost/math/tools/big_constant.hpp>
-#include <boost/math/policies/error_handling.hpp>
-#include <boost/assert.hpp>
-
-// Modified Bessel function of the second kind of order one
-// minimax rational approximations on intervals, see
-// Russon and Blair, Chalk River Report AECL-3461, 1969
-
-namespace boost { namespace math { namespace detail{
-
-template <typename T, typename Policy>
-T bessel_k1(T x, const Policy&);
-
-template <class T, class Policy>
-struct bessel_k1_initializer
-{
-   struct init
-   {
-      init()
-      {
-         do_init();
-      }
-      static void do_init()
-      {
-         bessel_k1(T(1), Policy());
-      }
-      void force_instantiate()const{}
-   };
-   static const init initializer;
-   static void force_instantiate()
-   {
-      initializer.force_instantiate();
-   }
-};
-
-template <class T, class Policy>
-const typename bessel_k1_initializer<T, Policy>::init bessel_k1_initializer<T, Policy>::initializer;
-
-template <typename T, typename Policy>
-T bessel_k1(T x, const Policy& pol)
-{
-    bessel_k1_initializer<T, Policy>::force_instantiate();
-
-    static const T P1[] = {
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.2149374878243304548e+06)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 7.1938920065420586101e+05)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.7733324035147015630e+05)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 7.1885382604084798576e+03)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 9.9991373567429309922e+01)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 4.8127070456878442310e-01))
-    };
-    static const T Q1[] = {
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.2149374878243304548e+06)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 3.7264298672067697862e+04)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.8143915754538725829e+02)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.0))
-    };
-    static const T P2[] = {
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 0.0)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.3531161492785421328e+06)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -1.4758069205414222471e+05)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -4.5051623763436087023e+03)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -5.3103913335180275253e+01)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.2795590826955002390e-01))
-    };
-    static const T Q2[] = {
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -2.7062322985570842656e+06)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 4.3117653211351080007e+04)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, -3.0507151578787595807e+02)),
-        static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.0))
-    };
-    static const T P3[] = {
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2.2196792496874548962e+00)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 4.4137176114230414036e+01)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 3.4122953486801312910e+02)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.3319486433183221990e+03)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2.8590657697910288226e+03)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 3.4540675585544584407e+03)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2.3123742209168871550e+03)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 8.1094256146537402173e+02)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.3182609918569941308e+02)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 7.5584584631176030810e+00)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 6.4257745859173138767e-02))
-    };
-    static const T Q3[] = {
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.7710478032601086579e+00)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 3.4552228452758912848e+01)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2.5951223655579051357e+02)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 9.6929165726802648634e+02)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.9448440788918006154e+03)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 2.1181000487171943810e+03)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.2082692316002348638e+03)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 3.3031020088765390854e+02)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 3.6001069306861518855e+01)),
-         static_cast<T>(BOOST_MATH_BIG_CONSTANT(T, 64, 1.0))
-    };
-    T value, factor, r, r1, r2;
-
-    BOOST_MATH_STD_USING
-    using namespace boost::math::tools;
-
-    static const char* function = "boost::math::bessel_k1<%1%>(%1%,%1%)";
-
-    if (x < 0)
-    {
-       return policies::raise_domain_error<T>(function,
-            "Got x = %1%, but argument x must be non-negative, complex number result not supported.", x, pol);
-    }
-    if (x == 0)
-    {
-       return policies::raise_overflow_error<T>(function, 0, pol);
-    }
-    if (x <= 1)                         // x in (0, 1]
-    {
-        T y = x * x;
-        r1 = evaluate_polynomial(P1, y) /  evaluate_polynomial(Q1, y);
-        r2 = evaluate_polynomial(P2, y) /  evaluate_polynomial(Q2, y);
-        factor = log(x);
-        value = (r1 + factor * r2) / x;
-    }
-    else                                // x in (1, \infty)
-    {
-        T y = 1 / x;
-        r = evaluate_polynomial(P3, y) /  evaluate_polynomial(Q3, y);
-        factor = exp(-x) / sqrt(x);
-        value = factor * r;
-    }
-
-    return value;
-}
-
-}}} // namespaces
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-#endif // BOOST_MATH_BESSEL_K1_HPP
-
diff --git a/contrib/libboost/boost_1_62_0/boost/move/algo/detail/basic_op.hpp b/contrib/libboost/boost_1_62_0/boost/move/algo/detail/basic_op.hpp
deleted file mode 100644
index ea0ce1b8e0e..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/move/algo/detail/basic_op.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Ion Gaztanaga 2015-2016.
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// See http://www.boost.org/libs/move for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-#ifndef BOOST_MOVE_ALGO_BASIC_OP
-#define BOOST_MOVE_ALGO_BASIC_OP
-
-#ifndef BOOST_CONFIG_HPP
-#  include <boost/config.hpp>
-#endif
-#
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#  pragma once
-#endif
-
-#include <boost/move/utility_core.hpp>
-#include <boost/move/adl_move_swap.hpp>
-#include <boost/move/detail/iterator_traits.hpp>
-
-namespace boost {
-namespace movelib {
-
-struct forward_t{};
-struct backward_t{};
-struct three_way_t{};
-
-struct move_op
-{
-   template <class SourceIt, class DestinationIt>
-   void operator()(SourceIt source, DestinationIt dest)
-   {  *dest = ::boost::move(*source);  }
-
-   template <class SourceIt, class DestinationIt>
-   DestinationIt operator()(forward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
-   {  return ::boost::move(first, last, dest_begin);  }
-
-   template <class SourceIt, class DestinationIt>
-   DestinationIt operator()(backward_t, SourceIt first, SourceIt last, DestinationIt dest_last)
-   {  return ::boost::move_backward(first, last, dest_last);  }
-
-   template <class SourceIt, class DestinationIt1, class DestinationIt2>
-   void operator()(three_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it)
-   {
-      *dest2it = boost::move(*dest1it);
-      *dest1it = boost::move(*srcit);
-   }
-};
-
-struct swap_op
-{
-   template <class SourceIt, class DestinationIt>
-   void operator()(SourceIt source, DestinationIt dest)
-   {  boost::adl_move_swap(*dest, *source);  }
-
-   template <class SourceIt, class DestinationIt>
-   DestinationIt operator()(forward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
-   {  return boost::adl_move_swap_ranges(first, last, dest_begin);  }
-
-   template <class SourceIt, class DestinationIt>
-   DestinationIt operator()(backward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
-   {  return boost::adl_move_swap_ranges_backward(first, last, dest_begin);  }
-
-   template <class SourceIt, class DestinationIt1, class DestinationIt2>
-   void operator()(three_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it)
-   {
-      typename ::boost::movelib::iterator_traits<SourceIt>::value_type tmp(boost::move(*dest2it));
-      *dest2it = boost::move(*dest1it);
-      *dest1it = boost::move(*srcit);
-      *srcit = boost::move(tmp);
-   }
-};
-
-}} //namespace boost::movelib
-
-#endif   //BOOST_MOVE_ALGO_BASIC_OP
diff --git a/contrib/libboost/boost_1_62_0/boost/move/algo/detail/bufferless_merge_sort.hpp b/contrib/libboost/boost_1_62_0/boost/move/algo/detail/bufferless_merge_sort.hpp
deleted file mode 100644
index a8e2763d7cd..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/move/algo/detail/bufferless_merge_sort.hpp
+++ /dev/null
@@ -1,120 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Ion Gaztanaga 2015-2016.
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// See http://www.boost.org/libs/move for documentation.
-//
-//////////////////////////////////////////////////////////////////////////////
-
-//! \file
-
-#ifndef BOOST_MOVE_ALGO_BUFFERLESS_MERGE_SORT_HPP
-#define BOOST_MOVE_ALGO_BUFFERLESS_MERGE_SORT_HPP
-
-#ifndef BOOST_CONFIG_HPP
-#  include <boost/config.hpp>
-#endif
-#
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#  pragma once
-#endif
-
-#include <boost/move/detail/config_begin.hpp>
-#include <boost/move/detail/workaround.hpp>
-
-#include <boost/move/utility_core.hpp>
-#include <boost/move/adl_move_swap.hpp>
-
-#include <boost/move/algo/move.hpp>
-#include <boost/move/algo/detail/merge.hpp>
-
-#include <boost/move/detail/iterator_traits.hpp>
-#include <boost/move/algo/detail/insertion_sort.hpp>
-#include <cassert>
-
-namespace boost {
-namespace movelib {
-// @cond
-namespace detail_bufferless_mergesort {
-
-static const std::size_t UnbufferedMergeSortInsertionSortThreshold = 16;
-
-//A in-placed version based on:
-//Jyrki Katajainen, Tomi Pasanen, Jukka Teuhola.
-//``Practical in-place mergesort''. Nordic Journal of Computing, 1996.
-
-template<class RandIt, class Compare>
-void bufferless_merge_sort(RandIt first, RandIt last, Compare comp);
-
-template<class RandIt, class Compare>
-void swap_sort(RandIt const first, RandIt const last, RandIt const buffer_first, RandIt const buffer_last, Compare comp, bool buffer_at_right)
-{
-   typedef typename iterator_traits<RandIt>::size_type size_type;
-   if (size_type(last - first) > UnbufferedMergeSortInsertionSortThreshold) {
-      RandIt m = first + (last - first) / 2;
-      bufferless_merge_sort(first, m, comp);
-      bufferless_merge_sort(m, last, comp);
-      if(buffer_at_right){
-         //Use antistable to minimize movements (if equal, move first half elements 
-         //to maximize the chance last half elements are already in place.
-         boost::movelib::swap_merge_right(first, m, last, buffer_last, boost::movelib::antistable<Compare>(comp));
-      }
-      else{
-         boost::movelib::swap_merge_left(buffer_first, first, m, last, comp);
-      }
-   }
-   else
-      boost::movelib::insertion_sort_swap(first, last, buffer_first, comp);
-}
-
-template<class RandIt, class Compare>
-void bufferless_merge_sort(RandIt const first, RandIt const last, Compare comp)
-{
-   typedef typename iterator_traits<RandIt>::size_type size_type;
-   size_type len = size_type(last - first);
-   if (len > size_type(UnbufferedMergeSortInsertionSortThreshold)) {
-      len /= 2;
-      RandIt h = last - len;  //ceil(half)
-      RandIt f = h - len;     //ceil(first)
-      swap_sort(f, h, h, last, comp, true);     //[h, last) contains sorted elements
-
-      //Divide unsorted first half in two
-      len = size_type(h - first);
-      while (len > size_type(UnbufferedMergeSortInsertionSortThreshold)) {
-         len /= 2;
-         RandIt n = h;  //new end
-         h = n - len;   //ceil(half')
-         f = h - len;   //ceil(first')
-         swap_sort(h, n, f, h, comp, false); // the first half of the previous working area [f, h)
-                                             //contains sorted elements: working area in the middle [h, n)
-         //Now merge small (left) sorted with big (right) sorted (buffer is between them)
-         swap_merge_with_right_placed(f, h, h, n, last, comp); 
-      }
-
-      boost::movelib::insertion_sort(first, h, comp);
-      boost::movelib::merge_bufferless(first, h, last, comp);
-   }
-   else{
-      boost::movelib::insertion_sort(first, last, comp);
-   }
-}
-
-}  //namespace detail_bufferless_mergesort {
-
-// @endcond
-
-//Unstable bufferless merge sort
-template<class RandIt, class Compare>
-void bufferless_merge_sort(RandIt first, RandIt last, Compare comp)
-{
-   detail_bufferless_mergesort::bufferless_merge_sort(first, last, comp);
-}
-
-}}   //namespace boost::movelib
-
-#include <boost/move/detail/config_end.hpp>
-
-#endif //#ifndef BOOST_MOVE_ALGO_BUFFERLESS_MERGE_SORT_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/next_prior.hpp b/contrib/libboost/boost_1_62_0/boost/next_prior.hpp
deleted file mode 100644
index 7854ec436a4..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/next_prior.hpp
+++ /dev/null
@@ -1,165 +0,0 @@
-//  Boost next_prior.hpp header file  ---------------------------------------//
-
-//  (C) Copyright Dave Abrahams and Daniel Walker 1999-2003. 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/utility for documentation.
-
-//  Revision History
-//  13 Dec 2003  Added next(x, n) and prior(x, n) (Daniel Walker)
-
-#ifndef BOOST_NEXT_PRIOR_HPP_INCLUDED
-#define BOOST_NEXT_PRIOR_HPP_INCLUDED
-
-#include <iterator>
-#if defined(_MSC_VER) && _MSC_VER <= 1310
-#include <boost/mpl/and.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#endif
-#include <boost/type_traits/is_unsigned.hpp>
-#include <boost/type_traits/integral_promotion.hpp>
-#include <boost/type_traits/make_signed.hpp>
-#include <boost/type_traits/has_plus.hpp>
-#include <boost/type_traits/has_plus_assign.hpp>
-#include <boost/type_traits/has_minus.hpp>
-#include <boost/type_traits/has_minus_assign.hpp>
-
-namespace boost {
-
-//  Helper functions for classes like bidirectional iterators not supporting
-//  operator+ and operator-
-//
-//  Usage:
-//    const std::list<T>::iterator p = get_some_iterator();
-//    const std::list<T>::iterator prev = boost::prior(p);
-//    const std::list<T>::iterator next = boost::next(prev, 2);
-
-//  Contributed by Dave Abrahams
-
-namespace next_prior_detail {
-
-template< typename T, typename Distance, bool HasPlus = has_plus< T, Distance >::value >
-struct next_impl2
-{
-    static T call(T x, Distance n)
-    {
-        std::advance(x, n);
-        return x;
-    }
-};
-
-template< typename T, typename Distance >
-struct next_impl2< T, Distance, true >
-{
-    static T call(T x, Distance n)
-    {
-        return x + n;
-    }
-};
-
-
-template< typename T, typename Distance, bool HasPlusAssign = has_plus_assign< T, Distance >::value >
-struct next_impl1 :
-    public next_impl2< T, Distance >
-{
-};
-
-template< typename T, typename Distance >
-struct next_impl1< T, Distance, true >
-{
-    static T call(T x, Distance n)
-    {
-        x += n;
-        return x;
-    }
-};
-
-
-template<
-    typename T,
-    typename Distance,
-    typename PromotedDistance = typename integral_promotion< Distance >::type,
-#if !defined(_MSC_VER) || _MSC_VER > 1310
-    bool IsUInt = is_unsigned< PromotedDistance >::value
-#else
-    // MSVC 7.1 has problems with applying is_unsigned to non-integral types
-    bool IsUInt = mpl::and_< is_integral< PromotedDistance >, is_unsigned< PromotedDistance > >::value
-#endif
->
-struct prior_impl3
-{
-    static T call(T x, Distance n)
-    {
-        std::advance(x, -n);
-        return x;
-    }
-};
-
-template< typename T, typename Distance, typename PromotedDistance >
-struct prior_impl3< T, Distance, PromotedDistance, true >
-{
-    static T call(T x, Distance n)
-    {
-        typedef typename make_signed< PromotedDistance >::type signed_distance;
-        std::advance(x, -static_cast< signed_distance >(static_cast< PromotedDistance >(n)));
-        return x;
-    }
-};
-
-
-template< typename T, typename Distance, bool HasMinus = has_minus< T, Distance >::value >
-struct prior_impl2 :
-    public prior_impl3< T, Distance >
-{
-};
-
-template< typename T, typename Distance >
-struct prior_impl2< T, Distance, true >
-{
-    static T call(T x, Distance n)
-    {
-        return x - n;
-    }
-};
-
-
-template< typename T, typename Distance, bool HasMinusAssign = has_minus_assign< T, Distance >::value >
-struct prior_impl1 :
-    public prior_impl2< T, Distance >
-{
-};
-
-template< typename T, typename Distance >
-struct prior_impl1< T, Distance, true >
-{
-    static T call(T x, Distance n)
-    {
-        x -= n;
-        return x;
-    }
-};
-
-} // namespace next_prior_detail
-
-template <class T>
-inline T next(T x) { return ++x; }
-
-template <class T, class Distance>
-inline T next(T x, Distance n)
-{
-    return next_prior_detail::next_impl1< T, Distance >::call(x, n);
-}
-
-template <class T>
-inline T prior(T x) { return --x; }
-
-template <class T, class Distance>
-inline T prior(T x, Distance n)
-{
-    return next_prior_detail::prior_impl1< T, Distance >::call(x, n);
-}
-
-} // namespace boost
-
-#endif  // BOOST_NEXT_PRIOR_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/optional.hpp b/contrib/libboost/boost_1_62_0/boost/optional.hpp
deleted file mode 100644
index 40cf12e6560..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/optional.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-// Copyright (C) 2003, Fernando Luis Cacciola Carballal.
-//
-// 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)
-//
-// See http://www.boost.org/libs/optional for documentation.
-//
-// You are welcome to contact the author at:
-//  fernando_cacciola@hotmail.com
-//
-#ifndef BOOST_OPTIONAL_FLC_19NOV2002_HPP
-#define BOOST_OPTIONAL_FLC_19NOV2002_HPP
-
-#include "boost/optional/optional.hpp"
-
-#endif
-
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/clone_allocator.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/clone_allocator.hpp
deleted file mode 100644
index 6d396e808a5..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/clone_allocator.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_CLONE_ALLOCATOR_HPP
-#define BOOST_PTR_CONTAINER_CLONE_ALLOCATOR_HPP
-
-#include <boost/assert.hpp>
-#include <boost/checked_delete.hpp>
-#include <typeinfo>
-
-namespace boost
-{
-    /////////////////////////////////////////////////////////////////////////
-    // Clonable concept 
-    /////////////////////////////////////////////////////////////////////////
-    
-    template< class T >
-    inline T* new_clone( const T& r )
-    {
-        //
-        // @remark: if you get a compile-error here,
-        //          it is most likely because you did not
-        //          define new_clone( const T& ) in the namespace
-        //          of T.
-        //
-        T* res = new T( r );
-        BOOST_ASSERT( typeid(r) == typeid(*res) &&
-                      "Default new_clone() sliced object!" );
-        return res;
-    }
-
-    template< class T >
-    inline T* new_clone( const T* r )
-    {
-        return r ? new_clone( *r ) : 0;
-    }
-
-    // 
-    // @remark: to make new_clone() work
-    //          with scope_ptr/shared_ptr ect.
-    //          simply overload for those types
-    //          in the appropriate namespace.
-    // 
-    
-    template< class T >
-    inline void delete_clone( const T* r )
-    {
-        checked_delete( r );
-    }
-
-    /////////////////////////////////////////////////////////////////////////
-    // CloneAllocator concept
-    /////////////////////////////////////////////////////////////////////////
-    
-    struct heap_clone_allocator
-    {
-        template< class U >
-        static U* allocate_clone( const U& r )
-        {
-            return new_clone( r );
-        }
-
-        template< class U >
-        static void deallocate_clone( const U* r )
-        {
-            delete_clone( r );
-        }
-
-    };
-
-
-    
-    struct view_clone_allocator
-    {
-        template< class U >
-        static U* allocate_clone( const U& r )
-        {
-            return const_cast<U*>(&r);
-        }
-
-        template< class U >
-        static void deallocate_clone( const U* /*r*/ )
-        {
-            // do nothing
-        }
-    };
-
-} // namespace 'boost'
-
-#endif
-
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/associative_ptr_container.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/associative_ptr_container.hpp
deleted file mode 100644
index c2033fa39d8..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/associative_ptr_container.hpp
+++ /dev/null
@@ -1,411 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. 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/ptr_container/
-//
-
-
-#ifndef BOOST_PTR_CONTAINER_DETAIL_ASSOCIATIVE_PTR_CONTAINER_HPP
-#define BOOST_PTR_CONTAINER_DETAIL_ASSOCIATIVE_PTR_CONTAINER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/ptr_container/detail/reversible_ptr_container.hpp>
-
-namespace boost
-{
-
-namespace ptr_container_detail
-{
-    template
-    <
-        class Config,
-        class CloneAllocator
-    >
-    class associative_ptr_container :
-        public reversible_ptr_container<Config,CloneAllocator>
-    {
-        typedef reversible_ptr_container<Config,CloneAllocator>
-                                base_type;
-
-        typedef BOOST_DEDUCED_TYPENAME base_type::scoped_deleter
-                                scoped_deleter;
-
-        typedef BOOST_DEDUCED_TYPENAME Config::container_type
-                                container_type;
-    public: // typedefs
-        typedef BOOST_DEDUCED_TYPENAME Config::key_type
-                                key_type;
-        typedef BOOST_DEDUCED_TYPENAME Config::key_compare
-                                key_compare;
-        typedef BOOST_DEDUCED_TYPENAME Config::value_compare
-                                value_compare;
-        typedef BOOST_DEDUCED_TYPENAME Config::hasher
-                                hasher;
-        typedef BOOST_DEDUCED_TYPENAME Config::key_equal
-                                key_equal;
-        typedef BOOST_DEDUCED_TYPENAME Config::iterator
-                                iterator;
-        typedef BOOST_DEDUCED_TYPENAME Config::const_iterator
-                                const_iterator;
-        typedef BOOST_DEDUCED_TYPENAME Config::local_iterator
-                                local_iterator;
-        typedef BOOST_DEDUCED_TYPENAME Config::const_local_iterator
-                                const_local_iterator;
-        typedef BOOST_DEDUCED_TYPENAME base_type::size_type
-                                size_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::reference
-                                reference;
-        typedef BOOST_DEDUCED_TYPENAME base_type::const_reference
-                    const_reference;
-
-    public: // foundation
-        associative_ptr_container()
-        { }
-
-        template< class SizeType >
-        associative_ptr_container( SizeType n, unordered_associative_container_tag tag )
-          : base_type( n, tag )
-        { }
-
-        template< class Compare, class Allocator >
-        associative_ptr_container( const Compare& comp,
-                                   const Allocator& a )
-         : base_type( comp, a, container_type() )
-        { }
-        
-        template< class Hash, class Pred, class Allocator >
-        associative_ptr_container( const Hash& hash,
-                                   const Pred& pred,
-                                   const Allocator& a )
-         : base_type( hash, pred, a )
-        { }
-
-        template< class InputIterator, class Compare, class Allocator >
-        associative_ptr_container( InputIterator first, InputIterator last,
-                                   const Compare& comp,
-                                   const Allocator& a )
-         : base_type( first, last, comp, a, container_type() )
-        { }
-        
-        template< class InputIterator, class Hash, class Pred, class Allocator >
-        associative_ptr_container( InputIterator first, InputIterator last,
-                                   const Hash& hash,
-                                   const Pred& pred,
-                                   const Allocator& a )
-         : base_type( first, last, hash, pred, a )
-        { }
-        
-        template< class PtrContainer >
-        explicit associative_ptr_container( std::auto_ptr<PtrContainer> r )
-         : base_type( r )
-        { }
-
-        associative_ptr_container( const associative_ptr_container& r )
-         : base_type( r.begin(), r.end(), container_type() )
-        { }
-        
-        template< class C, class V >
-        associative_ptr_container( const associative_ptr_container<C,V>& r )
-         : base_type( r.begin(), r.end(), container_type() )
-        { }
-        
-        template< class PtrContainer >
-        associative_ptr_container& operator=( std::auto_ptr<PtrContainer> r ) // nothrow
-        {
-           base_type::operator=( r );
-           return *this;
-        }
-        
-        associative_ptr_container& operator=( associative_ptr_container r ) // strong
-        {
-           this->swap( r );
-           return *this;   
-        }
-
-    public: // associative container interface
-        key_compare key_comp() const
-        {
-            return this->base().key_comp();
-        }
-
-        value_compare value_comp() const
-        {
-            return this->base().value_comp();
-        }
-
-        iterator erase( iterator before ) // nothrow
-        {
-            BOOST_ASSERT( !this->empty() );
-            BOOST_ASSERT( before != this->end() );
-
-            this->remove( before );                      // nothrow
-            iterator res( before );                      // nothrow
-            ++res;                                       // nothrow
-            this->base().erase( before.base() );         // nothrow
-            return res;                                  // nothrow
-        }
-
-        size_type erase( const key_type& x ) // nothrow
-        {
-            iterator i( this->base().find( x ) );       
-                                                        // nothrow
-            if( i == this->end() )                      // nothrow
-                return 0u;                              // nothrow
-            this->remove( i );                          // nothrow
-            return this->base().erase( x );             // nothrow 
-        }
-
-        iterator erase( iterator first,
-                        iterator last ) // nothrow
-        {
-            iterator res( last );                                // nothrow
-            if( res != this->end() )
-                ++res;                                           // nothrow
-
-            this->remove( first, last );                         // nothrow
-            this->base().erase( first.base(), last.base() );     // nothrow
-            return res;                                          // nothrow
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else    
-        template< class Range >
-        BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_convertible<Range&,key_type&>, 
-                                                  iterator >::type
-        erase( const Range& r )
-        {
-            return erase( boost::begin(r), boost::end(r) );
-        }
-
-#endif
-
-    protected:
-
-        template< class AssociatePtrCont >
-        void multi_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator object,
-                             AssociatePtrCont& from ) // strong
-        {
-            BOOST_ASSERT( (void*)&from != (void*)this );
-            BOOST_ASSERT( !from.empty() && "Cannot transfer from empty container" );
-
-            this->base().insert( *object.base() );     // strong
-            from.base().erase( object.base() );        // nothrow
-        }
-
-        template< class AssociatePtrCont >
-        size_type multi_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator first,
-                                  BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator last,
-                                  AssociatePtrCont& from ) // basic
-        {
-            BOOST_ASSERT( (void*)&from != (void*)this );
- 
-            size_type res = 0;
-            for( ; first != last; )
-            {
-                BOOST_ASSERT( first != from.end() );
-                this->base().insert( *first.base() );     // strong
-                BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator 
-                    to_delete( first );
-                ++first;
-                from.base().erase( to_delete.base() );    // nothrow
-                ++res;
-            }
-
-            return res;
-        }
-
-        template< class AssociatePtrCont >
-        bool single_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator object,
-                              AssociatePtrCont& from ) // strong
-        {
-            BOOST_ASSERT( (void*)&from != (void*)this );
-            BOOST_ASSERT( !from.empty() && "Cannot transfer from empty container" );
-
-            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool> p =
-                this->base().insert( *object.base() );     // strong
-            if( p.second )
-                from.base().erase( object.base() );        // nothrow
-
-            return p.second;
-        }
-
-        template< class AssociatePtrCont >
-        size_type single_transfer( BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator first,
-                                   BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator last,
-                                   AssociatePtrCont& from ) // basic
-        {
-            BOOST_ASSERT( (void*)&from != (void*)this );
-
-            size_type res = 0;
-            for( ; first != last; )
-            {
-                BOOST_ASSERT( first != from.end() );
-                std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool> p =
-                    this->base().insert( *first.base() );     // strong
-                BOOST_DEDUCED_TYPENAME AssociatePtrCont::iterator 
-                    to_delete( first );
-                ++first;
-                if( p.second )
-                {
-                    from.base().erase( to_delete.base() );   // nothrow
-                    ++res;
-                }
-            }
-            return res;
-        }
-        
-        reference front()
-        {
-            BOOST_ASSERT( !this->empty() );
-            BOOST_ASSERT( *this->begin().base() != 0 );
-            return *this->begin(); 
-        }
-
-        const_reference front() const
-        {
-            return const_cast<associative_ptr_container*>(this)->front();
-        }
-
-        reference back()
-        {
-            BOOST_ASSERT( !this->empty() );
-            BOOST_ASSERT( *(--this->end()).base() != 0 );
-            return *--this->end(); 
-        }
-
-        const_reference back() const
-        {
-            return const_cast<associative_ptr_container*>(this)->back();
-        }
-
-    protected: // unordered interface
-        hasher hash_function() const
-        {
-            return this->base().hash_function();
-        }
-
-        key_equal key_eq() const
-        {
-            return this->base().key_eq();
-        }
-        
-        size_type bucket_count() const
-        {
-            return this->base().bucket_count();
-        }
-        
-        size_type max_bucket_count() const
-        {
-            return this->base().max_bucket_count();
-        }
-        
-        size_type bucket_size( size_type n ) const
-        {
-            return this->base().bucket_size( n );
-        }
-        
-        float load_factor() const
-        {
-            return this->base().load_factor();
-        }
-        
-        float max_load_factor() const
-        {
-            return this->base().max_load_factor();
-        }
-        
-        void max_load_factor( float factor )
-        {
-            return this->base().max_load_factor( factor );
-        }
-        
-        void rehash( size_type n )
-        {
-            this->base().rehash( n );
-        }
-
-    public:
-#if BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(70190006))
-        iterator begin()
-        {
-            return base_type::begin();
-        }
-
-        const_iterator begin() const
-        {
-            return base_type::begin();
-        }
-
-        iterator end()
-        {
-            return base_type::end();
-        }
-
-        const_iterator end() const
-        {
-            return base_type::end();
-        }
-
-        const_iterator cbegin() const
-        {
-            return base_type::cbegin();
-        }
-
-        const_iterator cend() const
-        {
-            return base_type::cend();
-        }
-#else
-         using base_type::begin;
-         using base_type::end;
-         using base_type::cbegin;
-         using base_type::cend;
-#endif
-
-    protected:
-        local_iterator begin( size_type n )
-        {
-            return local_iterator( this->base().begin( n ) );
-        }
-        
-        const_local_iterator begin( size_type n ) const
-        {
-            return const_local_iterator( this->base().begin( n ) );
-        }
-        
-        local_iterator end( size_type n )
-        {
-            return local_iterator( this->base().end( n ) );
-        }
-        
-        const_local_iterator end( size_type n ) const
-        {
-            return const_local_iterator( this->base().end( n ) );
-        }
-        
-        const_local_iterator cbegin( size_type n ) const
-        {
-            return const_local_iterator( this->base().cbegin( n ) );
-        }
-        
-        const_local_iterator cend( size_type n )
-        {
-            return const_local_iterator( this->base().cend( n ) );
-        }
-
-     }; // class 'associative_ptr_container'
-    
-} // namespace 'ptr_container_detail'
-    
-} // namespace 'boost'
-
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/default_deleter.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/default_deleter.hpp
deleted file mode 100755
index 44647990cb1..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/default_deleter.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-// (C) Copyright Jonathan Turkanis 2004-2005.
-// 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.)
-
-// Contains the definition of move_ptrs::default_deleter, the default
-// Deleter template argument to move_ptr. Uses a technique of Daniel
-// Wallin to capture the type of a pointer at the time the deleter 
-// is constructed, so that move_ptrs can delete objects of incomplete 
-// type by default.
-
-#ifndef BOOST_MOVE_PTR_DEFAULT_DELETER_HPP_INCLUDED
-#define BOOST_MOVE_PTR_DEFAULT_DELETER_HPP_INCLUDED 
-
-#include <boost/checked_delete.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/type_traits/is_array.hpp>
-#include <boost/type_traits/remove_bounds.hpp>
-
-namespace boost { namespace ptr_container_detail { namespace move_ptrs {
-
-namespace ptr_container_detail {
-
-template<typename T>
-struct deleter_base {
-    typedef void (*deleter)(T*);
-    deleter_base(deleter d) { delete_ = d; }
-    void operator() (T* t) const { delete_(t); }
-    static deleter delete_;
-};
-
-template<class T>
-typename deleter_base<T>::deleter 
-deleter_base<T>::delete_;
-
-template<typename T>
-struct scalar_deleter : deleter_base<T> {
-    typedef deleter_base<T> base;
-    scalar_deleter() : base(do_delete) { }
-    static void do_delete(T* t) { checked_delete(t); }
-};
-
-template<typename T>
-struct array_deleter 
-    : deleter_base<typename remove_bounds<T>::type>
-{
-    typedef typename remove_bounds<T>::type element_type;
-    typedef deleter_base<element_type> base;
-    array_deleter() : base(do_delete) { }
-    static void do_delete(element_type* t) { checked_array_delete(t); }
-};
-
-} // End namespace ptr_container_detail.
-
-template<typename T>
-struct default_deleter
-    : mpl::if_<
-          is_array<T>,
-          ptr_container_detail::array_deleter<T>,
-          ptr_container_detail::scalar_deleter<T>
-      >::type
-{ 
-    default_deleter() { }
-    template<typename TT>
-    default_deleter(default_deleter<TT> tt) { }
-};
-
-} } } // End namespaces ptr_container_detail, move_ptrs, boost.
-
-#endif // #ifndef BOOST_MOVE_PTR_DEFAULT_DELETER_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/is_convertible.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/is_convertible.hpp
deleted file mode 100755
index fd177819250..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/is_convertible.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-// (C) Copyright Thorsten Ottosen 2005
-// (C) Copyright Howard Hinnant 2004
-// (C) Copyright Jonathan Turkanis 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.)
-
-//
-// Contains type traits machinery for incomplete arrays. MPL compatibility
-// is included for completeness, but is not necessary for the current 
-// application.
-// 
-
-#ifndef BOOST_MOVE_PTR_ARRAYS_HPP_INCLUDED
-#define BOOST_MOVE_PTR_ARRAYS_HPP_INCLUDED
-
-#include <boost/config.hpp> // BOOST_STATIC_CONSTANT.
-#include <boost/mpl/aux_/lambda_support.hpp>
-#include <boost/mpl/and.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/type_traits/is_array.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/remove_bounds.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/utility/enable_if.hpp>
-
-namespace boost { namespace ptr_container_detail { namespace move_ptrs {
-
-// From Howard Hinnant.
-template<typename T, typename U>
-struct is_array_convertible {
-    typedef typename remove_bounds<T>::type      t_element; 
-    typedef typename remove_bounds<U>::type      u_element; 
-    typedef typename remove_cv<t_element>::type  t_base; 
-    typedef typename remove_cv<u_element>::type  u_base; 
-    typedef typename 
-            mpl::and_<
-                is_array<T>,
-                is_array<U>,
-                is_same<t_base, u_base>,
-                is_convertible<t_element*, u_element*>
-            >::type                                     type;
-    BOOST_STATIC_CONSTANT(bool, value = type::value);
-    BOOST_MPL_AUX_LAMBDA_SUPPORT(2, is_array_convertible, (T, U))
-};
-
-template<typename T, typename U>
-struct is_smart_ptr_convertible 
-    : mpl::if_<
-          is_array<T>,
-          is_array_convertible<T, U>,
-          is_convertible<T*, U*> 
-      >::type
-    { };
-
-#ifndef BOOST_NO_SFINAE
-    template<typename Src, typename Tgt, typename T = void>
-    struct enable_if_convertible 
-        : enable_if< 
-              is_smart_ptr_convertible<Src, Tgt>,
-              T
-          >
-        { };
-#else
-    template<typename Src, typename Tgt, class T >
-    struct enable_if_convertible : mpl::identity<T> { };
-#endif
-
-} } }         // End namespaces ptr_container_detail, move_ptrs, boost.
-
-#endif      // #ifndef BOOST_MOVE_PTR_ARRAYS_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/map_iterator.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/map_iterator.hpp
deleted file mode 100644
index e3ff4f2b499..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/map_iterator.hpp
+++ /dev/null
@@ -1,132 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_MAP_ITERATOR_HPP
-#define BOOST_PTR_CONTAINER_MAP_ITERATOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/config.hpp>
-#include <boost/iterator/iterator_adaptor.hpp>
-#include <boost/utility/compare_pointees.hpp>
-#include <utility>
-
-#if defined(BOOST_MSVC)  
-# pragma warning(push)  
-# pragma warning(disable:4512)    // Assignment operator could not be generated.  
-#endif 
-
-namespace boost
-{ 
-    namespace ptr_container_detail
-    {
-        template< class F, class S >
-        struct ref_pair
-        {
-            typedef F first_type;
-            typedef S second_type;
-
-            const F& first;
-            S        second;
-
-            template< class F2, class S2 >
-            ref_pair( const std::pair<F2,S2>& p )
-            : first(p.first), second(static_cast<S>(p.second))
-            { }
-
-            template< class RP >
-            ref_pair( const RP* rp )
-            : first(rp->first), second(rp->second)
-            { }
-            
-            const ref_pair* const operator->() const
-            {
-                return this;
-            }
-
-            friend inline bool operator==( ref_pair l, ref_pair r )
-            {
-                return l.first == r.first && 
-                       boost::equal_pointees( l.second, r.second );
-            }
-
-            friend inline bool operator!=( ref_pair l, ref_pair r )
-            {
-                return !( l == r );
-            }
-
-            friend inline bool operator<( ref_pair l, ref_pair r )
-            {
-                if( l.first == r.first )
-                    return boost::less_pointees( l.second, r.second );
-                else 
-                    return l.first < r.first;
-            }
-
-            friend inline bool operator>( ref_pair l, ref_pair r )
-            {
-                return r < l;
-            }
-
-            friend inline bool operator<=( ref_pair l, ref_pair r )
-            {
-                return !(r < l);
-            }
-
-            friend inline bool operator>=( ref_pair l, ref_pair r )
-            {
-                return !(l < r);
-            }
-
-        };
-    }
-    
-    template< 
-              class I, // base iterator 
-              class F, // first type, key type
-              class S  // second type, mapped type
-            > 
-    class ptr_map_iterator : 
-        public boost::iterator_adaptor< ptr_map_iterator<I,F,S>, I, 
-                                        ptr_container_detail::ref_pair<F,S>, 
-                                        use_default, 
-                                        ptr_container_detail::ref_pair<F,S> >
-    {
-        typedef boost::iterator_adaptor< ptr_map_iterator<I,F,S>, I, 
-                                         ptr_container_detail::ref_pair<F,S>,
-                                         use_default, 
-                                         ptr_container_detail::ref_pair<F,S> > 
-            base_type;
-
-
-    public:
-        ptr_map_iterator() : base_type()                                 
-        { }
-        
-        explicit ptr_map_iterator( const I& i ) : base_type(i)
-        { }
-
-        template< class I2, class F2, class S2 >
-            ptr_map_iterator( const ptr_map_iterator<I2,F2,S2>& r ) 
-         : base_type(r.base())
-        { }
-        
-   }; // class 'ptr_map_iterator'
-
-}
-
-#if defined(BOOST_MSVC)  
-# pragma warning(pop)  
-#endif 
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/meta_functions.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/meta_functions.hpp
deleted file mode 100644
index 16ceb44ee1a..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/meta_functions.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2008. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_DETAIL_META_FUNCTIONS
-#define BOOST_PTR_CONTAINER_DETAIL_META_FUNCTIONS
-
-#include <boost/mpl/identity.hpp>
-#include <boost/mpl/eval_if.hpp>
-
-namespace boost
-{
-namespace ptr_container_detail
-{
-    template< class T >
-    struct select_value_compare
-    {
-        typedef typename T::value_compare type;
-    };
-
-    template< class T >
-    struct select_key_compare
-    {
-        typedef typename T::key_compare type;
-    };
-
-    template< class T >
-    struct select_hasher
-    {
-        typedef typename T::hasher type;
-    };
-
-    template< class T >
-    struct select_key_equal
-    {
-        typedef typename T::key_equal type;
-    };
-
-    template< class T >
-    struct select_iterator
-    {
-        typedef typename T::iterator type;
-    };
-    
-    template< class T >
-    struct select_local_iterator
-    {
-        typedef typename T::local_iterator type;
-    };
-
-    template< class T >
-    struct select_const_local_iterator
-    {
-        typedef typename T::const_local_iterator type;
-    };
-}
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/move.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/move.hpp
deleted file mode 100755
index bf07d5f5636..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/move.hpp
+++ /dev/null
@@ -1,44 +0,0 @@
-// (C) Copyright Daniel Wallin 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.)
-
-// Contains the definitions of the class template move_source and the function
-// template move, which together make move pointers moveable.
-
-#ifndef BOOST_MOVE_HPP_INCLUDED
-#define BOOST_MOVE_HPP_INCLUDED
-
-namespace boost { namespace ptr_container_detail {
-
-namespace move_ptrs {
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)    
-#pragma warning(push)    
-#pragma warning(disable:4512)  
-#endif  
-    
-template<typename Ptr>
-class move_source {
-public:
-    move_source(Ptr& ptr) : ptr_(ptr) {}
-    Ptr& ptr() const { return ptr_; }
-private:
-    Ptr& ptr_;
-    move_source(const Ptr&);
-};
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)    
-#pragma warning(pop)    
-#endif  
-
-} // End namespace move_ptrs.
-
-
-template<typename T>
-move_ptrs::move_source<T> move(T& x) 
-{ return move_ptrs::move_source<T>(x); }
-
-} // namespace 'ptr_container_detail'
-} // End namespace boost.
-
-#endif // #ifndef BOOST_MOVE_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/reversible_ptr_container.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/reversible_ptr_container.hpp
deleted file mode 100644
index 47c3903f466..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/reversible_ptr_container.hpp
+++ /dev/null
@@ -1,752 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. 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/ptr_container/
-//
-
-
-#ifndef BOOST_PTR_CONTAINER_DETAIL_REVERSIBLE_PTR_CONTAINER_HPP
-#define BOOST_PTR_CONTAINER_DETAIL_REVERSIBLE_PTR_CONTAINER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/ptr_container/detail/throw_exception.hpp>
-#include <boost/ptr_container/detail/scoped_deleter.hpp>
-#include <boost/ptr_container/detail/static_move_ptr.hpp>
-#include <boost/ptr_container/exception.hpp>
-#include <boost/ptr_container/clone_allocator.hpp>
-#include <boost/ptr_container/nullable.hpp>
-
-#ifdef BOOST_NO_SFINAE
-#else
-#include <boost/range/functions.hpp>
-#endif
-
-#include <boost/config.hpp>
-#include <boost/iterator/reverse_iterator.hpp>
-#include <boost/range/iterator.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_pointer.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <typeinfo>
-#include <memory>
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)  
-#pragma warning(push)  
-#pragma warning(disable:4127)
-#endif  
-
-namespace boost
-{
-
-namespace ptr_container_detail
-{
-    template< class CloneAllocator >
-    struct clone_deleter
-    {
-        template< class T >
-        void operator()( const T* p ) const
-        {
-            CloneAllocator::deallocate_clone( p );
-        }
-    };
-
-    template< class T >
-    struct is_pointer_or_integral
-    {
-        BOOST_STATIC_CONSTANT(bool, value = is_pointer<T>::value || is_integral<T>::value );
-    };
-
-    struct is_pointer_or_integral_tag {};
-    struct is_range_tag {};
-    struct sequence_tag {};
-    struct fixed_length_sequence_tag : sequence_tag {};
-    struct associative_container_tag {};
-    struct ordered_associative_container_tag : associative_container_tag {};
-    struct unordered_associative_container_tag : associative_container_tag {};
-    
-
-    
-    template
-    < 
-        class Config, 
-        class CloneAllocator
-    >
-    class reversible_ptr_container 
-    {
-    private:
-        BOOST_STATIC_CONSTANT( bool, allow_null = Config::allow_null );
-        
-        typedef BOOST_DEDUCED_TYPENAME Config::value_type Ty_;
-
-        template< bool allow_null_values >
-        struct null_clone_allocator
-        {
-            template< class Iter >
-            static Ty_* allocate_clone_from_iterator( Iter i )
-            { 
-                return allocate_clone( Config::get_const_pointer( i ) );
-            }
-            
-            static Ty_* allocate_clone( const Ty_* x )
-            {
-                if( allow_null_values )
-                {
-                    if( x == 0 )
-                        return 0;
-                }
-                else
-                {
-                    BOOST_ASSERT( x != 0 && "Cannot insert clone of null!" );
-                }
-
-                Ty_* res = CloneAllocator::allocate_clone( *x );
-                BOOST_ASSERT( typeid(*res) == typeid(*x) &&
-                              "CloneAllocator::allocate_clone() does not clone the "
-                              "object properly. Check that new_clone() is implemented"
-                              " correctly" );
-                return res;
-            }
-            
-            static void deallocate_clone( const Ty_* x )
-            {
-                if( allow_null_values )
-                {
-                    if( x == 0 )
-                        return;
-                }
-
-                CloneAllocator::deallocate_clone( x );
-            }
-        };
-
-        typedef BOOST_DEDUCED_TYPENAME Config::void_container_type  Cont;
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))    
-        typedef  null_clone_allocator<reversible_ptr_container::allow_null> 
-                                                                    null_cloner_type;
-#else
-        typedef null_clone_allocator<allow_null>                    null_cloner_type;
-#endif        
-        typedef clone_deleter<null_cloner_type>                     Deleter;
-
-        Cont      c_;
-
-    public:
-        Cont&       base()               { return c_; }
-    protected: // having this public could break encapsulation
-        const Cont& base() const         { return c_; }        
-        
-    public: // typedefs
-        typedef  Ty_*          value_type;
-        typedef  Ty_*          pointer;
-        typedef  Ty_&          reference;
-        typedef  const Ty_&    const_reference;
-        
-        typedef  BOOST_DEDUCED_TYPENAME Config::iterator 
-                                   iterator;
-        typedef  BOOST_DEDUCED_TYPENAME Config::const_iterator
-                                   const_iterator;
-        typedef  boost::reverse_iterator< iterator > 
-                                   reverse_iterator;  
-        typedef  boost::reverse_iterator< const_iterator >     
-                                   const_reverse_iterator;
-        typedef  BOOST_DEDUCED_TYPENAME Cont::difference_type
-                                   difference_type; 
-        typedef  BOOST_DEDUCED_TYPENAME Cont::size_type
-                                   size_type;
-        typedef  BOOST_DEDUCED_TYPENAME Config::allocator_type
-                                   allocator_type;
-        typedef CloneAllocator     clone_allocator_type;
-        typedef ptr_container_detail::static_move_ptr<Ty_,Deleter> 
-                                   auto_type;
-            
-    protected: 
-            
-        typedef ptr_container_detail::scoped_deleter<Ty_,null_cloner_type>
-                                   scoped_deleter;
-        typedef BOOST_DEDUCED_TYPENAME Cont::iterator
-                                   ptr_iterator; 
-        typedef BOOST_DEDUCED_TYPENAME Cont::const_iterator
-                                   ptr_const_iterator; 
-    private:
-
-        template< class InputIterator >  
-        void copy( InputIterator first, InputIterator last ) 
-        {
-            std::copy( first, last, begin() );
-        }
-        
-        void copy( const reversible_ptr_container& r )
-        { 
-            copy( r.begin(), r.end() );
-        }
-        
-        void copy_clones_and_release( scoped_deleter& sd ) // nothrow
-        {
-            BOOST_ASSERT( size_type( std::distance( sd.begin(), sd.end() ) ) == c_.size() );
-            std::copy( sd.begin(), sd.end(), c_.begin() );
-            sd.release(); 
-        }
-        
-        template< class ForwardIterator >
-        void clone_assign( ForwardIterator first, 
-                           ForwardIterator last ) // strong 
-        {
-            BOOST_ASSERT( first != last );
-            scoped_deleter sd( first, last );      // strong
-            copy_clones_and_release( sd );         // nothrow
-        }
-
-        template< class ForwardIterator >
-        void clone_back_insert( ForwardIterator first,
-                                ForwardIterator last )
-        {
-            BOOST_ASSERT( first != last );
-            scoped_deleter sd( first, last );
-            insert_clones_and_release( sd, end() );
-        }
-        
-        void remove_all() 
-        {
-            remove( begin(), end() ); 
-        }
-
-    protected:
-
-        void insert_clones_and_release( scoped_deleter& sd, 
-                                        iterator where ) // strong
-        {
-            //
-            // 'c_.insert' always provides the strong guarantee for T* elements
-            // since a copy constructor of a pointer cannot throw
-            //
-            c_.insert( where.base(), 
-                       sd.begin(), sd.end() ); 
-            sd.release();
-        }
-
-        void insert_clones_and_release( scoped_deleter& sd ) // strong
-        {
-            c_.insert( sd.begin(), sd.end() );
-            sd.release();
-        }
-
-        template< class U >
-        void remove( U* ptr )
-        {
-            null_policy_deallocate_clone( ptr );
-        }
-        
-        template< class I >
-        void remove( I i )
-        { 
-            null_policy_deallocate_clone( Config::get_const_pointer(i) );
-        }
-
-        template< class I >
-        void remove( I first, I last ) 
-        {
-            for( ; first != last; ++first )
-                remove( first );
-        }
-
-        static void enforce_null_policy( const Ty_* x, const char* msg )
-        {
-            if( !allow_null )
-            {
-                BOOST_PTR_CONTAINER_THROW_EXCEPTION( 0 == x && "null not allowed", 
-                                                     bad_pointer, msg );
-            }
-        }
-
-        static Ty_* null_policy_allocate_clone( const Ty_* x )
-        {
-            return null_cloner_type::allocate_clone( x );
-        }
-
-        static void null_policy_deallocate_clone( const Ty_* x )
-        {
-            null_cloner_type::deallocate_clone( x );
-        }
-
-    private:
-        template< class ForwardIterator >
-        ForwardIterator advance( ForwardIterator begin, size_type n ) 
-        {
-            ForwardIterator iter = begin;
-            std::advance( iter, n );
-            return iter;
-        }        
-
-        template< class I >
-        void constructor_impl( I first, I last, std::input_iterator_tag ) // basic
-        {
-            while( first != last )
-            {
-                insert( end(), null_cloner_type::allocate_clone_from_iterator(first) );
-                ++first;
-            }
-        }
-
-        template< class I >
-        void constructor_impl( I first, I last, std::forward_iterator_tag ) // strong
-        {
-            if( first == last )
-                return;
-            clone_back_insert( first, last );
-        }
-
-        template< class I >
-        void associative_constructor_impl( I first, I last ) // strong
-        {
-            if( first == last )
-                return;
-
-            scoped_deleter sd( first, last );
-            insert_clones_and_release( sd );             
-        }
-
-    public: // foundation! should be protected!
-        reversible_ptr_container()
-        { }
-
-        template< class SizeType >
-        reversible_ptr_container( SizeType n, unordered_associative_container_tag )
-          : c_( n )
-        { }
-
-        template< class SizeType >
-        reversible_ptr_container( SizeType n, fixed_length_sequence_tag )
-          : c_( n )
-        { }
-
-        template< class SizeType >
-        reversible_ptr_container( SizeType n, const allocator_type& a, 
-                                  fixed_length_sequence_tag )
-          : c_( n, a )
-        { }
-        
-        explicit reversible_ptr_container( const allocator_type& a ) 
-         : c_( a )
-        { }
-        
-        template< class PtrContainer >
-        explicit reversible_ptr_container( std::auto_ptr<PtrContainer> clone )                
-        { 
-            swap( *clone ); 
-        }
-
-        reversible_ptr_container( const reversible_ptr_container& r ) 
-        {
-            constructor_impl( r.begin(), r.end(), std::forward_iterator_tag() ); 
-        }
-
-        template< class C, class V >
-        reversible_ptr_container( const reversible_ptr_container<C,V>& r ) 
-        {
-            constructor_impl( r.begin(), r.end(), std::forward_iterator_tag() ); 
-        }
-
-        template< class PtrContainer >
-        reversible_ptr_container& operator=( std::auto_ptr<PtrContainer> clone ) // nothrow
-        {
-            swap( *clone );
-            return *this;
-        }
-
-        reversible_ptr_container& operator=( reversible_ptr_container r ) // strong 
-        {
-            swap( r );
-            return *this;
-        }
-        
-        // overhead: null-initilization of container pointer (very cheap compared to cloning)
-        // overhead: 1 heap allocation (very cheap compared to cloning)
-        template< class InputIterator >
-        reversible_ptr_container( InputIterator first, 
-                                  InputIterator last,
-                                  const allocator_type& a = allocator_type() ) // basic, strong
-          : c_( a )
-        { 
-            constructor_impl( first, last, 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-#else
-                              BOOST_DEDUCED_TYPENAME
-#endif                              
-                              iterator_category<InputIterator>::type() );
-        }
-
-        template< class Compare >
-        reversible_ptr_container( const Compare& comp,
-                                  const allocator_type& a )
-          : c_( comp, a ) {}
-
-        template< class ForwardIterator >
-        reversible_ptr_container( ForwardIterator first,
-                                  ForwardIterator last,
-                                  fixed_length_sequence_tag )
-          : c_( std::distance(first,last) )
-        {
-            constructor_impl( first, last, 
-                              std::forward_iterator_tag() );
-        }
-
-        template< class SizeType, class InputIterator >
-        reversible_ptr_container( SizeType n,
-                                  InputIterator first,
-                                  InputIterator last,
-                                  fixed_length_sequence_tag )
-          : c_( n )
-        {
-            constructor_impl( first, last, 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-#else
-                              BOOST_DEDUCED_TYPENAME
-#endif                              
-                              iterator_category<InputIterator>::type() );
-        }
-
-        template< class Compare >
-        reversible_ptr_container( const Compare& comp,
-                                  const allocator_type& a,
-                                  associative_container_tag )
-          : c_( comp, a )
-        { }
-                
-        template< class InputIterator >
-        reversible_ptr_container( InputIterator first,
-                                  InputIterator last,
-                                  associative_container_tag )
-        {
-            associative_constructor_impl( first, last );
-        }
-        
-        template< class InputIterator, class Compare >
-        reversible_ptr_container( InputIterator first,
-                                  InputIterator last,
-                                  const Compare& comp,
-                                  const allocator_type& a,
-                                  associative_container_tag )
-          : c_( comp, a ) 
-        {
-            associative_constructor_impl( first, last );
-        }
-
-        explicit reversible_ptr_container( size_type n )
-          : c_( n ) {}
-
-        template< class Hash, class Pred >
-        reversible_ptr_container( const Hash& h,
-                                  const Pred& pred,
-                                  const allocator_type& a )
-          : c_( h, pred, a ) {}
-
-        template< class InputIterator, class Hash, class Pred >
-        reversible_ptr_container( InputIterator first,
-                                  InputIterator last,
-                                  const Hash& h,
-                                  const Pred& pred,
-                                  const allocator_type& a )
-          : c_( h, pred, a )
-        {
-            associative_constructor_impl( first, last );
-        }
-
-    public:        
-        ~reversible_ptr_container()
-        { 
-            remove_all();
-        }
-        
-    public:
-        
-        allocator_type get_allocator() const                   
-        {
-            return c_.get_allocator(); 
-        }
- 
-    public: // container requirements
-        iterator begin()            
-            { return iterator( c_.begin() ); }
-        const_iterator begin() const      
-            { return const_iterator( c_.begin() ); }
-        iterator end()              
-            { return iterator( c_.end() ); }
-        const_iterator end() const        
-            { return const_iterator( c_.end() ); }
-        
-        reverse_iterator rbegin()           
-            { return reverse_iterator( this->end() ); } 
-        const_reverse_iterator rbegin() const     
-            { return const_reverse_iterator( this->end() ); } 
-        reverse_iterator rend()             
-            { return reverse_iterator( this->begin() ); } 
-        const_reverse_iterator rend() const       
-            { return const_reverse_iterator( this->begin() ); } 
-
-        const_iterator cbegin() const      
-            { return const_iterator( c_.begin() ); }
-        const_iterator cend() const             
-            { return const_iterator( c_.end() ); }
-
-        const_reverse_iterator crbegin() const      
-            { return const_reverse_iterator( this->end() ); }
-        const_reverse_iterator crend() const             
-            { return const_reverse_iterator( this->begin() ); }
-
-        void swap( reversible_ptr_container& r ) // nothrow
-        { 
-            c_.swap( r.c_ );
-        }
-          
-        size_type size() const // nothrow
-        {
-            return c_.size();
-        }
-
-        size_type max_size() const // nothrow
-        {
-            return c_.max_size(); 
-        }
-        
-        bool empty() const // nothrow
-        {
-            return c_.empty();
-        }
-
-    public: // optional container requirements
-
-        bool operator==( const reversible_ptr_container& r ) const // nothrow
-        { 
-            if( size() != r.size() )
-                return false;
-            else
-                return std::equal( begin(), end(), r.begin() );
-        }
-
-        bool operator!=( const reversible_ptr_container& r ) const // nothrow
-        {
-            return !(*this == r);
-        }
-        
-        bool operator<( const reversible_ptr_container& r ) const // nothrow 
-        {
-             return std::lexicographical_compare( begin(), end(), r.begin(), r.end() );
-        }
-
-        bool operator<=( const reversible_ptr_container& r ) const // nothrow 
-        {
-            return !(r < *this);
-        }
-
-        bool operator>( const reversible_ptr_container& r ) const // nothrow 
-        {
-            return r < *this;
-        }
-
-        bool operator>=( const reversible_ptr_container& r ) const // nothrow 
-        {
-            return !(*this < r);
-        }
-
-    public: // modifiers
-
-        iterator insert( iterator before, Ty_* x )
-        {
-            enforce_null_policy( x, "Null pointer in 'insert()'" );
-
-            auto_type ptr( x );                            // nothrow
-            iterator res( c_.insert( before.base(), x ) ); // strong, commit
-            ptr.release();                                 // nothrow
-            return res;
-        }
-
-        template< class U >
-        iterator insert( iterator before, std::auto_ptr<U> x )
-        {
-            return insert( before, x.release() );
-        }
-
-        iterator erase( iterator x ) // nothrow
-        {
-            BOOST_ASSERT( !empty() );
-            BOOST_ASSERT( x != end() );
-
-            remove( x );
-            return iterator( c_.erase( x.base() ) );
-        }
-
-        iterator erase( iterator first, iterator last ) // nothrow
-        {
-            remove( first, last );
-            return iterator( c_.erase( first.base(),
-                                       last.base() ) );
-        }
-
-        template< class Range >
-        iterator erase( const Range& r )
-        {
-            return erase( boost::begin(r), boost::end(r) );
-        }
-
-        void clear()
-        {
-            remove_all();
-            c_.clear();
-        }
-        
-    public: // access interface
-        
-        auto_type release( iterator where )
-        { 
-            BOOST_ASSERT( where != end() );
-            
-            BOOST_PTR_CONTAINER_THROW_EXCEPTION( empty(), bad_ptr_container_operation,
-                                                 "'release()' on empty container" ); 
-            
-            auto_type ptr( Config::get_pointer( where ) );  // nothrow
-            c_.erase( where.base() );                       // nothrow
-            return boost::ptr_container_detail::move( ptr ); 
-        }
-
-        auto_type replace( iterator where, Ty_* x ) // strong  
-        { 
-            BOOST_ASSERT( where != end() );
-
-            enforce_null_policy( x, "Null pointer in 'replace()'" );
-            
-            auto_type ptr( x );
-            
-            BOOST_PTR_CONTAINER_THROW_EXCEPTION( empty(), bad_ptr_container_operation,
-                                                 "'replace()' on empty container" );
-
-            auto_type old( Config::get_pointer( where ) );  // nothrow            
-            const_cast<void*&>(*where.base()) = ptr.release();                
-            return boost::ptr_container_detail::move( old );
-        }
-
-        template< class U >
-        auto_type replace( iterator where, std::auto_ptr<U> x )
-        {
-            return replace( where, x.release() ); 
-        }
-
-        auto_type replace( size_type idx, Ty_* x ) // strong
-        {
-            enforce_null_policy( x, "Null pointer in 'replace()'" );
-            
-            auto_type ptr( x ); 
-            
-            BOOST_PTR_CONTAINER_THROW_EXCEPTION( idx >= size(), bad_index, 
-                                                 "'replace()' out of bounds" );
-            
-            auto_type old( static_cast<Ty_*>( c_[idx] ) ); // nothrow
-            c_[idx] = ptr.release();                       // nothrow, commit
-            return boost::ptr_container_detail::move( old );
-        } 
-
-        template< class U >
-        auto_type replace( size_type idx, std::auto_ptr<U> x )
-        {
-            return replace( idx, x.release() );
-        }
-                
-    }; // 'reversible_ptr_container'
-
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))    
-#define BOOST_PTR_CONTAINER_DEFINE_RELEASE( base_type ) \
-    typename base_type::auto_type                   \
-    release( typename base_type::iterator i )       \
-    {                                               \
-        return boost::ptr_container_detail::move(base_type::release(i)); \
-    }                                               
-#else
-#define BOOST_PTR_CONTAINER_DEFINE_RELEASE( base_type ) \
-    using base_type::release;
-#endif
-    
-    //
-    // two-phase lookup of template functions 
-    // is buggy on most compilers, so we use a macro instead
-    //
-#define BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( PC, base_type, this_type ) \
-    explicit PC( std::auto_ptr<this_type> r )       \
-    : base_type ( r ) { }                           \
-                                                    \
-    PC& operator=( std::auto_ptr<this_type> r )     \
-    {                                               \
-        base_type::operator=( r );                  \
-        return *this;                               \
-    }                                               \
-                                                    \
-    std::auto_ptr<this_type> release()              \
-    {                                               \
-      std::auto_ptr<this_type> ptr( new this_type );\
-      this->swap( *ptr );                           \
-      return ptr;                                   \
-    }                                               \
-    BOOST_PTR_CONTAINER_DEFINE_RELEASE( base_type ) \
-                                                    \
-    std::auto_ptr<this_type> clone() const          \
-    {                                               \
-       return std::auto_ptr<this_type>( new this_type( this->begin(), this->end() ) ); \
-    }
-
-#define BOOST_PTR_CONTAINER_DEFINE_COPY_CONSTRUCTORS( PC, base_type ) \
-                                                                      \
-    template< class U >                                               \
-    PC( const PC<U>& r ) : base_type( r ) { }                         \
-                                                                      \
-    PC& operator=( PC r )                                             \
-    {                                                                 \
-        this->swap( r );                                              \
-        return *this;                                                 \
-    }                                                                 \
-                                                                           
-
-#define BOOST_PTR_CONTAINER_DEFINE_CONSTRUCTORS( PC, base_type )                       \
-    typedef BOOST_DEDUCED_TYPENAME base_type::iterator        iterator;                \
-    typedef BOOST_DEDUCED_TYPENAME base_type::size_type       size_type;               \
-    typedef BOOST_DEDUCED_TYPENAME base_type::const_reference const_reference;         \
-    typedef BOOST_DEDUCED_TYPENAME base_type::allocator_type  allocator_type;          \
-    PC() {}                                                                            \
-    explicit PC( const allocator_type& a ) : base_type(a) {}                           \
-    template< class InputIterator >                                                    \
-    PC( InputIterator first, InputIterator last ) : base_type( first, last ) {}        \
-    template< class InputIterator >                                                    \
-    PC( InputIterator first, InputIterator last,                                       \
-        const allocator_type& a ) : base_type( first, last, a ) {}  
-                 
-#define BOOST_PTR_CONTAINER_DEFINE_NON_INHERITED_MEMBERS( PC, base_type, this_type )           \
-   BOOST_PTR_CONTAINER_DEFINE_CONSTRUCTORS( PC, base_type )                                    \
-   BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( PC, base_type, this_type )
-
-#define BOOST_PTR_CONTAINER_DEFINE_SEQEUENCE_MEMBERS( PC, base_type, this_type )  \
-    BOOST_PTR_CONTAINER_DEFINE_NON_INHERITED_MEMBERS( PC, base_type, this_type )  \
-    BOOST_PTR_CONTAINER_DEFINE_COPY_CONSTRUCTORS( PC, base_type )
-
-} // namespace 'ptr_container_detail'
-
-    //
-    // @remark: expose movability of internal move-pointer
-    //
-    namespace ptr_container
-    {        
-        using ptr_container_detail::move;
-    }
-
-} // namespace 'boost'  
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)  
-#pragma warning(pop)  
-#endif  
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/scoped_deleter.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/scoped_deleter.hpp
deleted file mode 100755
index a2e7aba2ea6..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/scoped_deleter.hpp
+++ /dev/null
@@ -1,121 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_SCOPED_DELETER_HPP
-#define BOOST_PTR_CONTAINER_SCOPED_DELETER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <iterator>
-#include <cstddef>
-#include <boost/scoped_array.hpp>
-
-namespace boost
-{
-
-    namespace ptr_container_detail
-    {
-        template< class T, class CloneAllocator >
-        class scoped_deleter
-        {
-            typedef std::size_t size_type;
-            scoped_array<T*>  ptrs_;
-            size_type         stored_; 
-            bool              released_;
-            
-        public:
-            scoped_deleter( T** a, size_type size ) 
-                : ptrs_( a ), stored_( size ), released_( false )
-            { 
-                BOOST_ASSERT( a );
-            }
-            
-            scoped_deleter( size_type size ) 
-                : ptrs_( new T*[size] ), stored_( 0 ), 
-                 released_( false )
-            {
-                BOOST_ASSERT( size > 0 );
-            }
-
-
-            
-            scoped_deleter( size_type n, const T& x ) // strong
-                : ptrs_( new T*[n] ), stored_(0),
-                  released_( false )
-            {
-                for( size_type i = 0; i != n; i++ )
-                    add( CloneAllocator::allocate_clone( &x ) );
-                BOOST_ASSERT( stored_ > 0 );
-            }
-
-
-            
-            template< class InputIterator >
-            scoped_deleter ( InputIterator first, InputIterator last  ) // strong
-                : ptrs_( new T*[ std::distance(first,last) ] ),
-                  stored_(0),
-                  released_( false )
-            {
-                for( ; first != last; ++first )
-                    add( CloneAllocator::allocate_clone_from_iterator( first ) );
-                BOOST_ASSERT( stored_ > 0 );
-            }
-
-            
-            
-            ~scoped_deleter()
-            {
-                if ( !released_ )
-                {
-                    for( size_type i = 0u; i != stored_; ++i )
-                        CloneAllocator::deallocate_clone( ptrs_[i] ); 
-                }
-            }
-            
-            
-            
-            void add( T* t )
-            {
-                BOOST_ASSERT( ptrs_.get() != 0 );
-                ptrs_[stored_] = t;
-                ++stored_;
-            }
-            
-            
-            
-            void release()
-            {
-                released_ = true;
-            }
-            
-            
-            
-            T** begin()
-            {
-                BOOST_ASSERT( ptrs_.get() != 0 );
-                return &ptrs_[0];
-            }
-            
-            
-            
-            T** end()
-            {
-                BOOST_ASSERT( ptrs_.get() != 0 );
-                return &ptrs_[stored_];
-            }
-            
-        }; // class 'scoped_deleter'
-    }
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/serialize_ptr_map_adapter.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/serialize_ptr_map_adapter.hpp
deleted file mode 100644
index a85bf4c8bcf..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/serialize_ptr_map_adapter.hpp
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright Sebastian Ramacher, 2007.
-// 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_PTR_CONTAINER_DETAIL_SERIALIZE_PTR_MAP_ADAPTER_HPP
-#define BOOST_PTR_CONTAINER_DETAIL_SERIALIZE_PTR_MAP_ADAPTER_HPP
-
-#include <boost/ptr_container/ptr_map_adapter.hpp>
-#include <boost/ptr_container/detail/serialize_xml_names.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/nvp.hpp> 
-
-namespace boost 
-{
-
-namespace serialization 
-{
-
-template<class Archive, class T, class VoidPtrMap, class CloneAllocator, bool Ordered>
-void save(Archive& ar, const ptr_container_detail::ptr_map_adapter_base<T, VoidPtrMap, CloneAllocator,Ordered>& c, unsigned int /*version*/)
-{
-    typedef ptr_container_detail::ptr_map_adapter_base<T, VoidPtrMap, CloneAllocator,Ordered> container;
-    typedef BOOST_DEDUCED_TYPENAME container::const_iterator const_iterator;
-
-    ar << boost::serialization::make_nvp( ptr_container_detail::count(), 
-                                          ptr_container_detail::serialize_as_const(c.size()) );
-
-    const_iterator i = c.begin(), e = c.end();
-    for(; i != e; ++i)
-    {
-        ar << boost::serialization::make_nvp( ptr_container_detail::first(), i->first );
-        ar << boost::serialization::make_nvp( ptr_container_detail::second(),
-                                              ptr_container_detail::serialize_as_const(i->second) );
-    }
-}
-
-template<class Archive, class T, class VoidPtrMap, class CloneAllocator, bool Ordered>
-void load(Archive& ar, ptr_map_adapter<T, VoidPtrMap, CloneAllocator,Ordered>& c, unsigned int /*version*/)
-{
-    typedef ptr_map_adapter<T, VoidPtrMap, CloneAllocator,Ordered> container;
-    typedef BOOST_DEDUCED_TYPENAME container::key_type key_type;
-    typedef BOOST_DEDUCED_TYPENAME container::size_type size_type;
-    typedef BOOST_DEDUCED_TYPENAME container::iterator iterator;
-
-    c.clear();
-    size_type n;
-    ar >> boost::serialization::make_nvp( ptr_container_detail::count(), n );
-
-    for(size_type i = 0u; i != n; ++i)
-    {
-        key_type key;
-        T* value;
-        ar >> boost::serialization::make_nvp( ptr_container_detail::first(), key );
-        ar >> boost::serialization::make_nvp( ptr_container_detail::second(), value );
-        std::pair<iterator, bool> p = c.insert(key, value);
-        ar.reset_object_address(&p.first->first, &key); 
-    }
-}
-
-template<class Archive, class T, class VoidPtrMap, class CloneAllocator, bool Ordered>
-void load(Archive& ar, ptr_multimap_adapter<T, VoidPtrMap, CloneAllocator,Ordered>& c, unsigned int /*version*/)
-{
-    typedef ptr_multimap_adapter<T, VoidPtrMap, CloneAllocator,Ordered> container;
-    typedef BOOST_DEDUCED_TYPENAME container::key_type key_type;
-    typedef BOOST_DEDUCED_TYPENAME container::size_type size_type;
-    typedef BOOST_DEDUCED_TYPENAME container::iterator iterator;
-
-    c.clear();
-    size_type n;
-    ar >> boost::serialization::make_nvp( ptr_container_detail::count(), n );
-
-    for(size_type i = 0u; i != n; ++i)
-    {
-        key_type key;
-        T* value;
-        ar >> boost::serialization::make_nvp( ptr_container_detail::first(), key );
-        ar >> boost::serialization::make_nvp( ptr_container_detail::second(), value );
-        iterator p = c.insert(key, value);
-        ar.reset_object_address(&p->first, &key);
-    }
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/serialize_reversible_cont.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/serialize_reversible_cont.hpp
deleted file mode 100644
index 5aeddfea264..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/serialize_reversible_cont.hpp
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright Sebastian Ramacher, 2007.
-// 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_PTR_CONTAINER_DETAIL_SERIALIZE_REVERSIBLE_PTR_CONTAINER_HPP
-#define BOOST_PTR_CONTAINER_DETAIL_SERIALIZE_REVERSIBLE_PTR_CONTAINER_HPP
-
-#include <boost/ptr_container/detail/reversible_ptr_container.hpp>
-#include <boost/ptr_container/detail/serialize_xml_names.hpp>
-#include <boost/serialization/split_free.hpp>
-#include <boost/serialization/nvp.hpp>
-
-namespace boost 
-{
-
-namespace ptr_container_detail
-{
-
-template<class Archive, class Config, class CloneAllocator>
-void save_helper(Archive& ar, const ptr_container_detail::reversible_ptr_container<Config, CloneAllocator>& c)
-{
-    typedef ptr_container_detail::reversible_ptr_container<Config, CloneAllocator> container_type;
-    typedef BOOST_DEDUCED_TYPENAME container_type::const_iterator const_iterator;
-    typedef BOOST_DEDUCED_TYPENAME container_type::value_type value_type;
-
-    const_iterator i = c.begin(), e = c.end();
-    for(; i != e; ++i)
-        ar << boost::serialization::make_nvp( ptr_container_detail::item(), 
-                ptr_container_detail::serialize_as_const(static_cast<value_type>(*i.base()))); 
-    }
-
-template<class Archive, class Config, class CloneAllocator>
-void load_helper(Archive& ar, ptr_container_detail::reversible_ptr_container<Config, CloneAllocator>& c,
-                 BOOST_DEDUCED_TYPENAME ptr_container_detail::reversible_ptr_container<Config, CloneAllocator>::size_type n)
-{
-    typedef ptr_container_detail::reversible_ptr_container<Config, CloneAllocator> container_type;
-    typedef BOOST_DEDUCED_TYPENAME container_type::size_type size_type;
-    typedef BOOST_DEDUCED_TYPENAME container_type::value_type value_type;
-
-    //
-    // Called after an appropriate reserve on c.
-    //
-
-    c.clear();            
-    for(size_type i = 0u; i != n; ++i)
-    {
-        //
-        // Remark: pointers are not tracked,
-        // so we need not call ar.reset_object_address(v, u)
-        //
-        value_type ptr;
-        ar >> boost::serialization::make_nvp( ptr_container_detail::item(), ptr ); 
-        c.insert(c.end(), ptr);
-    }
-}
-
-} // namespace ptr_container_detail
-
-namespace serialization 
-{
-
-template<class Archive, class Config, class CloneAllocator>
-void save(Archive& ar, const ptr_container_detail::reversible_ptr_container<Config, CloneAllocator>& c, unsigned int /*version*/)
-{   
-    ar << boost::serialization::make_nvp( ptr_container_detail::count(), 
-                                          ptr_container_detail::serialize_as_const(c.size()) );
-    ptr_container_detail::save_helper(ar, c);
-}
-
-template<class Archive, class Config, class CloneAllocator>
-void load(Archive& ar, ptr_container_detail::reversible_ptr_container<Config, CloneAllocator>& c, unsigned int /*version*/)
-{
-    typedef ptr_container_detail::reversible_ptr_container<Config, CloneAllocator> container_type;
-    typedef BOOST_DEDUCED_TYPENAME container_type::size_type size_type;
-    
-    size_type n;
-    ar >> boost::serialization::make_nvp( ptr_container_detail::count(), n );
-    ptr_container_detail::load_helper(ar, c, n);
-    
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/serialize_xml_names.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/serialize_xml_names.hpp
deleted file mode 100644
index d260198568b..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/serialize_xml_names.hpp
+++ /dev/null
@@ -1,32 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2007. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_DETAIL_SERIALIZE_XML_NAMES
-#define BOOST_PTR_CONTAINER_DETAIL_SERIALIZE_XML_NAMES
-
-namespace boost
-{
-    namespace ptr_container_detail
-    {
-        inline const char* count()  { return "count"; }
-        inline const char* item()   { return "item"; }
-        inline const char* first()  { return "first"; }
-        inline const char* second() { return "second"; }
-
-        template<class T>
-        inline T const& serialize_as_const(T const& r)
-        {
-            return r;
-        }
-    }
-}
-#endif
-
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/static_move_ptr.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/static_move_ptr.hpp
deleted file mode 100644
index 6af3461a369..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/static_move_ptr.hpp
+++ /dev/null
@@ -1,211 +0,0 @@
-// (C) Copyright Thorsten Ottosen 2005.
-// (C) Copyright Jonathan Turkanis 2004.
-// (C) Copyright Daniel Wallin 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.)
-
-// Implementation of the move_ptr from the "Move Proposal" 
-// (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1377.htm) 
-// enhanced to support custom deleters and safe boolean conversions.
-//
-// The implementation is based on an implementation by Daniel Wallin, at
-// "http://aspn.activestate.com/ASPN/Mail/Message/Attachments/boost/
-// 400DC271.1060903@student.umu.se/move_ptr.hpp". The current was adapted 
-// by Jonathan Turkanis to incorporating ideas of Howard Hinnant and 
-// Rani Sharoni. 
-
-#ifndef BOOST_STATIC_MOVE_PTR_HPP_INCLUDED
-#define BOOST_STATIC_MOVE_PTR_HPP_INCLUDED
-
-#include <boost/config.hpp> // Member template friends, put size_t in std.
-#include <cstddef>          // size_t
-#include <boost/compressed_pair.hpp> 
-#include <boost/ptr_container/detail/default_deleter.hpp>       
-#include <boost/ptr_container/detail/is_convertible.hpp>       
-#include <boost/ptr_container/detail/move.hpp>       
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/add_reference.hpp>
-#include <boost/type_traits/is_array.hpp>
-
-#if defined(BOOST_MSVC)
-#pragma warning(push)
-#pragma warning(disable:4521)        // Multiple copy constuctors.
-#endif
-
-namespace boost { namespace ptr_container_detail {
-
-    
-template< typename T, 
-          typename Deleter = 
-              move_ptrs::default_deleter<T> >
-class static_move_ptr 
-{
-public:
-
-    typedef typename remove_bounds<T>::type             element_type;
-    typedef Deleter                                     deleter_type;
-
-private:
-    
-    struct safe_bool_helper { int x; };
-    typedef int safe_bool_helper::* safe_bool;
-    typedef boost::compressed_pair<element_type*, Deleter> impl_type;
-
-public:
-    typedef typename impl_type::second_reference        deleter_reference;
-    typedef typename impl_type::second_const_reference  deleter_const_reference;
-
-        // Constructors
-
-    static_move_ptr() : impl_(0) { }
-
-    static_move_ptr(const static_move_ptr& p)
-        : impl_(p.get(), p.get_deleter())    
-        { 
-            const_cast<static_move_ptr&>(p).release();
-        }
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))    
-    static_move_ptr( const move_ptrs::move_source<static_move_ptr<T,Deleter> >& src )
-#else
-    static_move_ptr( const move_ptrs::move_source<static_move_ptr>& src )
-#endif    
-            : impl_(src.ptr().get(), src.ptr().get_deleter())
-            {
-                src.ptr().release();
-            }
-    
-    template<typename TT>
-    explicit static_move_ptr(TT* tt) 
-        : impl_(tt, Deleter()) 
-        { }
-
-        // Destructor
-
-    ~static_move_ptr() { if (ptr()) get_deleter()(ptr()); }
-
-        // Assignment
-
-    static_move_ptr& operator=(static_move_ptr rhs)
-        {
-            rhs.swap(*this);
-            return *this;
-        }
-
-        // Smart pointer interface
-
-    element_type* get() const { return ptr(); }
-
-    element_type& operator*() 
-        { 
-            /*BOOST_STATIC_ASSERT(!is_array);*/ return *ptr(); 
-        }
-
-    const element_type& operator*() const 
-        { 
-            /*BOOST_STATIC_ASSERT(!is_array);*/ return *ptr(); 
-        }
-
-    element_type* operator->()  
-        { 
-            /*BOOST_STATIC_ASSERT(!is_array);*/ return ptr(); 
-        }    
-
-    const element_type* operator->() const 
-        { 
-            /*BOOST_STATIC_ASSERT(!is_array);*/ return ptr(); 
-        }    
-
-
-    element_type* release()
-        {
-            element_type* result = ptr();
-            ptr() = 0;
-            return result;
-        }
-
-    void reset()
-        {
-            if (ptr()) get_deleter()(ptr());
-            ptr() = 0;
-        }
-
-    template<typename TT>
-    void reset(TT* tt) 
-        {
-            static_move_ptr(tt).swap(*this);
-        }
-
-    template<typename TT, typename DD>
-    void reset(TT* tt, DD dd) 
-        {
-            static_move_ptr(tt, dd).swap(*this);
-        }
-
-    operator safe_bool() const { return ptr() ? &safe_bool_helper::x : 0; }
-
-    void swap(static_move_ptr& p) { impl_.swap(p.impl_); }
-
-    deleter_reference get_deleter() { return impl_.second(); }
-
-    deleter_const_reference get_deleter() const { return impl_.second(); }
-private:
-    template<typename TT, typename DD>
-    void check(const static_move_ptr<TT, DD>& ptr)
-        {
-            typedef move_ptrs::is_smart_ptr_convertible<TT, T> convertible;
-            BOOST_STATIC_ASSERT(convertible::value);
-        }   
-
-#if defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) || defined(BOOST_NO_SFINAE)
-// give up on this behavior
-#else 
-
-    template<typename Ptr> struct cant_move_from_const;
-
-    template<typename TT, typename DD> 
-    struct cant_move_from_const< const static_move_ptr<TT, DD> > { 
-        typedef typename static_move_ptr<TT, DD>::error type; 
-    };
-
-    template<typename Ptr> 
-    static_move_ptr(Ptr&, typename cant_move_from_const<Ptr>::type = 0);
-
-
-public:
-    static_move_ptr(static_move_ptr&);
-
-    
-private:
-    template<typename TT, typename DD>
-    static_move_ptr( static_move_ptr<TT, DD>&,
-                     typename 
-                     move_ptrs::enable_if_convertible<
-                         TT, T, static_move_ptr&
-                     >::type::type* = 0 );
-
-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING || BOOST_NO_SFINAE
-
-//#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS
-//    template<typename TT, typename DD>
-//    friend class static_move_ptr;
-//#else
-    public:
-//#endif
-    typename impl_type::first_reference 
-    ptr() { return impl_.first(); } 
-
-    typename impl_type::first_const_reference 
-    ptr() const { return impl_.first(); }
-
-    impl_type impl_;
-};
-
-} // namespace ptr_container_detail
-} // End namespace boost.
-
-#if defined(BOOST_MSVC)
-#pragma warning(pop) // #pragma warning(disable:4251)
-#endif
-
-#endif      // #ifndef BOOST_STATIC_MOVE_PTR_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/throw_exception.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/throw_exception.hpp
deleted file mode 100755
index bb467f2bd93..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/throw_exception.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_DETAIL_THROW_EXCEPTION
-#define BOOST_PTR_CONTAINER_DETAIL_THROW_EXCEPTION
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-
-#ifdef BOOST_NO_EXCEPTIONS
-#define BOOST_PTR_CONTAINER_NO_EXCEPTIONS
-#endif
-
-#ifdef BOOST_PTR_CONTAINER_NO_EXCEPTIONS
-
-#define BOOST_PTR_CONTAINER_THROW_EXCEPTION( If, Ex, Msg ) BOOST_ASSERT( !(If) && Msg ) 
-
-#else
-
-#define BOOST_PTR_CONTAINER_THROW_EXCEPTION( If, Ex, Msg ) if( (If) ) throw Ex ( Msg )
-
-#endif // BOOST_PTR_CONTAINER_NO_EXCEPTIONS
-
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/void_ptr_iterator.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/void_ptr_iterator.hpp
deleted file mode 100755
index 937ffb4aa21..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/detail/void_ptr_iterator.hpp
+++ /dev/null
@@ -1,229 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_DETAIL_VOID_PTR_ITERATOR_HPP
-#define BOOST_PTR_CONTAINER_DETAIL_VOID_PTR_ITERATOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/config.hpp>
-#include <boost/iterator/iterator_traits.hpp>
-#include <boost/type_traits/remove_const.hpp>
-
-namespace boost
-{
-        template
-        < 
-            class VoidIter, 
-            class T
-        >
-        class void_ptr_iterator
-        {
-        public:
-            typedef BOOST_DEDUCED_TYPENAME boost::remove_const<T>::type        
-                             value_type;
-            typedef T&       reference;
-            typedef T*       pointer;
-
-            typedef  BOOST_DEDUCED_TYPENAME iterator_difference<VoidIter>::type
-                             difference_type;           
-            typedef  BOOST_DEDUCED_TYPENAME iterator_category<VoidIter>::type
-                             iterator_category;           
-        private:
-
-            VoidIter iter_;
-
-        public:
-            void_ptr_iterator() : iter_()
-            { }
-
-            void_ptr_iterator( VoidIter r ) : iter_(r)
-            { }
-
-            //
-            // Remark: passing by value breaks vc7.1 
-            //
-            template< class MutableIterator, class MutableT >
-            void_ptr_iterator( const void_ptr_iterator<MutableIterator,MutableT>& r )
-#ifdef BOOST_NO_SFINAE
-                         : iter_( VoidIter(const_cast<void**>(&*r.base())) )
-#else
-
-             : iter_(r.base())
-#endif
-            { }
-
-            T& operator*() const
-            {
-                return *static_cast<T*>( *iter_ );
-            }
-
-            T* operator->() const
-            {
-                return static_cast<T*>( *iter_ );
-            }
-            
-            void_ptr_iterator& operator++()
-            {
-                ++iter_;
-                return *this;
-            }
-
-            void_ptr_iterator operator++(int)
-            {
-                void_ptr_iterator res = *this;
-                ++iter_;
-                return res;
-            }
-
-            void_ptr_iterator& operator--()
-            {
-                --iter_;
-                return *this;
-            }
-
-            void_ptr_iterator operator--(int)
-            {
-                void_ptr_iterator res = *this;
-                --iter_;
-                return res;
-            }
-
-            void_ptr_iterator& operator+=( difference_type n )
-            {
-                iter_ += n;
-                return *this;
-            }
-
-            void_ptr_iterator& operator-=( difference_type n )
-            {
-                iter_ -= n;
-                return *this;
-            }
-
-            T& operator[]( difference_type n ) const
-            {
-                return *static_cast<T*>( *(iter_ + n) );
-            }
-
-            VoidIter base() const
-            {
-                return iter_;
-            }
-
-        }; // class 'void_ptr_iterator'
-
-        template< class VoidIter, class T >
-        inline void_ptr_iterator<VoidIter,T> 
-        operator+( void_ptr_iterator<VoidIter,T> l, 
-                   BOOST_DEDUCED_TYPENAME void_ptr_iterator<VoidIter,T>::difference_type n )
-        {
-            l += n;
-            return l;
-        }
-
-        template< class VoidIter, class T >
-        inline void_ptr_iterator<VoidIter,T> 
-        operator+( BOOST_DEDUCED_TYPENAME void_ptr_iterator<VoidIter,T>::difference_type n, 
-                   void_ptr_iterator<VoidIter,T> r ) 
-
-        {
-            r += n;
-            return r;
-        }
-
-        template< class VoidIter, class T >
-        inline void_ptr_iterator<VoidIter,T> 
-        operator-( void_ptr_iterator<VoidIter,T> l, 
-                   BOOST_DEDUCED_TYPENAME void_ptr_iterator<VoidIter,T>::difference_type n )
-        {
-            l -= n;
-            return l;
-        }
-
-        template< class VoidIter, class T >
-        inline void_ptr_iterator<VoidIter,T> 
-        operator-( BOOST_DEDUCED_TYPENAME void_ptr_iterator<VoidIter,T>::difference_type n, 
-                   void_ptr_iterator<VoidIter,T> r ) 
-
-        {
-            r -= n;
-            return r;
-        }
-
-        template< class VoidIter, class T, class VoidIterU, class U >
-        inline BOOST_DEDUCED_TYPENAME void_ptr_iterator<VoidIter,T>::difference_type
-        operator-( void_ptr_iterator<VoidIter,T> l,
-                   void_ptr_iterator<VoidIterU,U> r ) 
-
-        {
-            return l.base() - r.base();
-        }
-
-
-
-        template< class VoidIterT, class T, class VoidIterU, class U >
-        inline bool operator==( const void_ptr_iterator<VoidIterT,T>& l,
-                                const void_ptr_iterator<VoidIterU,U>& r )
-        {
-            return l.base() == r.base();
-        }
-
-
-        
-        template< class VoidIterT, class T, class VoidIterU, class U >
-        inline bool operator!=( const void_ptr_iterator<VoidIterT,T>& l,
-                                const void_ptr_iterator<VoidIterU,U>& r )
-        {
-            return l.base() != r.base();
-        }
-
-
-
-        template< class VoidIterT, class T, class VoidIterU, class U >
-        inline bool operator<( const void_ptr_iterator<VoidIterT,T>& l,
-                               const void_ptr_iterator<VoidIterU,U>& r )
-        {
-            return l.base() < r.base();
-        }
-
-
-        
-        template< class VoidIterT, class T, class VoidIterU, class U >
-        inline bool operator<=( const void_ptr_iterator<VoidIterT,T>& l,
-                               const void_ptr_iterator<VoidIterU,U>& r )
-        {
-            return l.base() <= r.base();
-        }
-
-
-        
-        template< class VoidIterT, class T, class VoidIterU, class U >
-        inline bool operator>( const void_ptr_iterator<VoidIterT,T>& l,
-                               const void_ptr_iterator<VoidIterU,U>& r )
-        {
-            return l.base() > r.base();
-        }
-
-
-        
-        template< class VoidIterT, class T, class VoidIterU, class U >
-        inline bool operator>=( const void_ptr_iterator<VoidIterT,T>& l,
-                               const void_ptr_iterator<VoidIterU,U>& r )
-        {
-            return l.base() >= r.base();
-        }
-
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/exception.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/exception.hpp
deleted file mode 100755
index d9a5ffeaf55..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/exception.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_EXCEPTION_HPP
-#define BOOST_PTR_CONTAINER_EXCEPTION_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <exception>
-
-namespace boost
-{
-    class bad_ptr_container_operation : public std::exception
-    {
-        const char* what_;
-    public:
-        bad_ptr_container_operation( const char* what ) : what_( what )
-        { }
-        
-        virtual const char* what() const throw()
-        {
-            return what_;
-        }
-    };
-
-
-    
-    class bad_index : public bad_ptr_container_operation
-    {
-    public:
-        bad_index( const char* what ) : bad_ptr_container_operation( what )
-        { }
-    };
-
-
-
-    class bad_pointer : public bad_ptr_container_operation
-    {
-    public:
-        bad_pointer() : bad_ptr_container_operation( "Null pointer not allowed in a pointer container!" )
-        { }
-        
-        bad_pointer( const char* text ) : bad_ptr_container_operation( text )
-        { }
-    };
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/indirect_fun.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/indirect_fun.hpp
deleted file mode 100644
index 0c5726509c4..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/indirect_fun.hpp
+++ /dev/null
@@ -1,151 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2007. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_INDIRECT_FUN_HPP
-#define BOOST_PTR_CONTAINER_INDIRECT_FUN_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-    #pragma once
-#endif
-
-#include <boost/config.hpp>
-
-#ifdef BOOST_NO_SFINAE
-#else
-#include <boost/utility/result_of.hpp>
-#include <boost/pointee.hpp>
-#endif // BOOST_NO_SFINAE
-
-#include <boost/assert.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_void.hpp>
-#include <functional>
-
-
-namespace boost
-{
-
-    namespace ptr_container_detail
-    {
-        template <typename Type, typename Dummy>
-        struct make_lazy
-        {
-            typedef typename Type::type type;
-        };
-    }
-    
-    template
-    < 
-              class Fun
-#ifdef BOOST_NO_SFINAE
-            , class Result = bool
-#endif        
-    >
-    class indirect_fun
-    {
-        Fun fun;
-    public:
-        indirect_fun() : fun(Fun())
-        { }
-        
-        indirect_fun( Fun f ) : fun(f)
-        { }
-    
-        template< class T >
-#ifdef BOOST_NO_SFINAE
-        Result    
-#else            
-        typename boost::result_of< const Fun( typename pointee<T>::type& ) >::type 
-#endif            
-        operator()( const T& r ) const
-        { 
-            return fun( *r );
-        }
-    
-        template< class T, class U >
-#ifdef BOOST_NO_SFINAE
-        Result    
-#else                        
-        typename boost::result_of< const Fun( typename pointee<T>::type&,
-                                              typename pointee<U>::type& ) >::type
-#endif            
-        operator()( const T& r, const U& r2 ) const
-        { 
-            return fun( *r, *r2 ); 
-        }
-    };
-
-    template< class Fun >
-    inline indirect_fun<Fun> make_indirect_fun( Fun f )
-    {
-        return indirect_fun<Fun>( f );
-    }
-
-
-    template
-    < 
-        class Fun, 
-        class Arg1, 
-        class Arg2 = Arg1 
-#ifdef BOOST_NO_SFINAE
-      , class Result = bool   
-#endif           
-    >
-    class void_ptr_indirect_fun
-    {
-        Fun fun;
-                
-    public:
-        
-        void_ptr_indirect_fun() : fun(Fun())
-        { }
-
-        void_ptr_indirect_fun( Fun f ) : fun(f)
-        { }
-        
-        template< class Void >
-#ifdef BOOST_NO_SFINAE
-        Result    
-#else            
-        typename ptr_container_detail::make_lazy<
-            boost::result_of<const Fun(const Arg1&)>, Void>::type
-#endif            
-        operator()( const Void* r ) const
-        { 
-            BOOST_STATIC_ASSERT(boost::is_void<Void>::value);
-            BOOST_ASSERT( r != 0 );
-            return fun( * static_cast<const Arg1*>( r ) );
-        }
-
-        template< class Void >
-#ifdef BOOST_NO_SFINAE
-        Result    
-#else                    
-        typename ptr_container_detail::make_lazy<
-            boost::result_of<const Fun(const Arg1&, const Arg2&)>, Void>::type
-#endif            
-        operator()( const Void* l, const Void* r ) const
-        { 
-            BOOST_STATIC_ASSERT(boost::is_void<Void>::value);
-            BOOST_ASSERT( l != 0 && r != 0 );
-            return fun( * static_cast<const Arg1*>( l ), * static_cast<const Arg2*>( r ) );
-        }
-    };
-
-    template< class Arg, class Fun >
-    inline void_ptr_indirect_fun<Fun,Arg> make_void_ptr_indirect_fun( Fun f )
-    {
-        return void_ptr_indirect_fun<Fun,Arg>( f );
-    }
-     
-} // namespace 'boost'
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/nullable.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/nullable.hpp
deleted file mode 100755
index b3e4603d1ed..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/nullable.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. 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/ptr_container/
-//
-
-
-#ifndef BOOST_INDIRECT_CONTAINER_NULLABLE_HPP
-#define BOOST_INDIRECT_CONTAINER_NULLABLE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/type_traits/detail/yes_no_type.hpp>
-#include <boost/mpl/eval_if.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/config.hpp>
-
-namespace boost
-{
-    
-    template< class T >
-    struct nullable
-    {
-        typedef T type;
-    };   
-
-    namespace ptr_container_detail
-    {
-        template< class T >
-        type_traits::yes_type is_nullable( const nullable<T>* );
-
-        type_traits::no_type is_nullable( ... );        
-    }
-
-    template< class T >
-    struct is_nullable
-    {
-    private:
-            BOOST_STATIC_CONSTANT( T*, var );
-    public:
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)  
-#pragma warning(push)  
-#pragma warning(disable:6334)  
-#endif  
-
-            BOOST_STATIC_CONSTANT(bool, value = sizeof( ptr_container_detail::is_nullable( var ) ) 
-                                                == sizeof( type_traits::yes_type ) );
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)  
-#pragma warning(pop)  
-#endif  
-            
-    };
-    
-    template< class T >
-    struct remove_nullable
-    {
-        typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< is_nullable<T>,
-                                                      T,
-                                            mpl::identity<T> >::type
-            type;
-    };
-
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_array.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_array.hpp
deleted file mode 100644
index 9ab6473e3dc..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_array.hpp
+++ /dev/null
@@ -1,234 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_ARRAY_HPP
-#define BOOST_PTR_CONTAINER_PTR_ARRAY_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/array.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/ptr_container/ptr_sequence_adapter.hpp>
-
-namespace boost
-{
-
-    namespace ptr_container_detail
-    {
-        template
-        <
-            class T,
-            size_t N,
-            class Allocator = int // dummy
-        >
-        class ptr_array_impl : public boost::array<T,N>
-        {
-        public:
-            typedef Allocator allocator_type;
-
-            ptr_array_impl( Allocator /*a*/ = Allocator() )
-            {
-                this->assign( 0 );
-            }
-
-            ptr_array_impl( size_t, T*, Allocator /*a*/ = Allocator() )
-            {
-                this->assign( 0 );
-            }
-        };
-    }
-
-    template
-    <
-        class T,
-        size_t N,
-        class CloneAllocator = heap_clone_allocator
-    >
-    class ptr_array : public
-        ptr_sequence_adapter< T,
-                              ptr_container_detail::ptr_array_impl<void*,N>,
-                              CloneAllocator >
-    {
-    private:
-        typedef ptr_sequence_adapter< T,
-                                      ptr_container_detail::ptr_array_impl<void*,N>,
-                                      CloneAllocator >
-            base_class;
-
-        typedef BOOST_DEDUCED_TYPENAME remove_nullable<T>::type U;
-
-        typedef ptr_array<T,N,CloneAllocator>
-                          this_type;
-
-    public:
-        typedef std::size_t size_type;
-        typedef U*          value_type;
-        typedef U*          pointer;
-        typedef U&          reference;
-        typedef const U&    const_reference;
-        typedef BOOST_DEDUCED_TYPENAME base_class::auto_type
-                            auto_type;
-
-    public: // constructors
-        ptr_array() : base_class()
-        { }
-
-        ptr_array( const ptr_array& r )
-        {
-            size_t i = 0;
-            for( ; i != N; ++i )
-                this->base()[i] = this->null_policy_allocate_clone( 
-                                        static_cast<const T*>( &r[i] ) ); 
-        }
-
-        template< class U >
-        ptr_array( const ptr_array<U,N>& r )
-        {
-            size_t i = 0;
-            for( ; i != N; ++i )
-                this->base()[i] = this->null_policy_allocate_clone( 
-                                        static_cast<const T*>( &r[i] ) ); 
-        }
-
-        explicit ptr_array( std::auto_ptr<this_type> r )
-        : base_class( r ) { }
-
-        ptr_array& operator=( ptr_array r )
-        {
-            this->swap( r );
-            return *this;            
-        }
-
-        ptr_array& operator=( std::auto_ptr<this_type> r )
-        {
-            base_class::operator=(r);
-            return *this;
-        }
-
-        std::auto_ptr<this_type> release()
-        {
-            std::auto_ptr<this_type> ptr( new this_type );
-            this->swap( *ptr );
-            return ptr;
-        }
-
-        std::auto_ptr<this_type> clone() const
-        {
-            std::auto_ptr<this_type> pa( new this_type );
-            for( size_t i = 0; i != N; ++i )
-            {
-                if( ! is_null(i) )
-                    pa->replace( i, this->null_policy_allocate_clone( &(*this)[i] ) ); 
-            }
-            return pa;
-        }
-
-    private: // hide some members
-        using base_class::insert;
-        using base_class::erase;
-        using base_class::push_back;
-        using base_class::push_front;
-        using base_class::pop_front;
-        using base_class::pop_back;
-        using base_class::transfer;
-        using base_class::get_allocator;
-
-    public: // compile-time interface
-
-        template< size_t idx >
-        auto_type replace( U* r ) // strong
-        {
-            BOOST_STATIC_ASSERT( idx < N );
-
-            this->enforce_null_policy( r, "Null pointer in 'ptr_array::replace()'" );
-
-            auto_type res( static_cast<U*>( this->base()[idx] ) ); // nothrow
-            this->base()[idx] = r;                                 // nothrow
-            return boost::ptr_container::move(res);                // nothrow 
-        }
-
-        template< size_t idx, class V >
-        auto_type replace( std::auto_ptr<V> r )
-        {
-            return replace<idx>( r.release() );
-        }
-
-        auto_type replace( size_t idx, U* r ) // strong
-        {
-            this->enforce_null_policy( r, "Null pointer in 'ptr_array::replace()'" );
-
-            auto_type ptr( r );
-
-            BOOST_PTR_CONTAINER_THROW_EXCEPTION( idx >= N, bad_index,
-                                                 "'replace()' aout of bounds" );
-
-            auto_type res( static_cast<U*>( this->base()[idx] ) ); // nothrow
-            this->base()[idx] = ptr.release();                     // nothrow
-            return boost::ptr_container::move(res);                // nothrow 
-        }
-
-        template< class V >
-        auto_type replace( size_t idx, std::auto_ptr<V> r )
-        {
-            return replace( idx, r.release() );
-        }
-
-        using base_class::at;
-
-        template< size_t idx >
-        T& at()
-        {
-            BOOST_STATIC_ASSERT( idx < N );
-            return (*this)[idx];
-        }
-
-        template< size_t idx >
-        const T& at() const
-        {
-            BOOST_STATIC_ASSERT( idx < N );
-            return (*this)[idx];
-        }
-
-        bool is_null( size_t idx ) const
-        {
-            return base_class::is_null(idx);
-        }
-
-        template< size_t idx >
-        bool is_null() const
-        {
-            BOOST_STATIC_ASSERT( idx < N );
-            return this->base()[idx] == 0;
-        }
-    };
-
-    //////////////////////////////////////////////////////////////////////////////
-    // clonability
-
-    template< typename T, size_t size, typename CA >
-    inline ptr_array<T,size,CA>* new_clone( const ptr_array<T,size,CA>& r )
-    {
-        return r.clone().release();
-    }
-
-    /////////////////////////////////////////////////////////////////////////
-    // swap
-
-    template< typename T, size_t size, typename CA >
-    inline void swap( ptr_array<T,size,CA>& l, ptr_array<T,size,CA>& r )
-    {
-        l.swap(r);
-    }
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_circular_buffer.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_circular_buffer.hpp
deleted file mode 100644
index bfd1be603ba..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_circular_buffer.hpp
+++ /dev/null
@@ -1,531 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2008. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_CIRCULAR_BUFFER_HPP
-#define BOOST_PTR_CONTAINER_PTR_CIRCULAR_BUFFER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/circular_buffer.hpp>
-#include <boost/ptr_container/ptr_sequence_adapter.hpp>
-
-namespace boost
-{
-
-    template
-    < 
-        class T, 
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator<void*>
-    >
-    class ptr_circular_buffer : public 
-        ptr_sequence_adapter< T, 
-                              boost::circular_buffer<void*,Allocator>, 
-                              CloneAllocator >
-    {  
-        typedef ptr_sequence_adapter< T, 
-                                      boost::circular_buffer<void*,Allocator>, 
-                                      CloneAllocator > 
-            base_type;
-
-        typedef boost::circular_buffer<void*,Allocator>         circular_buffer_type;
-        typedef ptr_circular_buffer<T,CloneAllocator,Allocator> this_type;
-        
-    public: // typedefs
-        typedef typename base_type::value_type     value_type;
-        typedef value_type*                        pointer;
-        typedef const value_type*                  const_pointer;
-        typedef typename base_type::size_type      size_type;
-        typedef typename base_type::allocator_type allocator_type;
-        typedef typename base_type::iterator       iterator;
-        typedef typename base_type::const_iterator const_iterator;
-        typedef typename base_type::auto_type      auto_type;
-        
-        typedef std::pair<pointer,size_type>                  array_range;
-        typedef std::pair<const_pointer,size_type>            const_array_range;
-        typedef typename circular_buffer_type::capacity_type  capacity_type;
-
-    public: // constructors
-        ptr_circular_buffer()
-        { }
-
-        explicit ptr_circular_buffer( capacity_type n )
-          : base_type( n, ptr_container_detail::fixed_length_sequence_tag() )
-        { }
-        
-        ptr_circular_buffer( capacity_type n,
-                             const allocator_type& alloc )
-          : base_type( n, alloc, ptr_container_detail::fixed_length_sequence_tag() )
-        { }
-
-        template< class ForwardIterator >
-        ptr_circular_buffer( ForwardIterator first, ForwardIterator last )
-          : base_type( first, last, ptr_container_detail::fixed_length_sequence_tag() )
-        { }
-
-        template< class InputIterator >
-        ptr_circular_buffer( capacity_type n, InputIterator first, InputIterator last )
-          : base_type( n, first, last, ptr_container_detail::fixed_length_sequence_tag() )
-        { }
-
-        ptr_circular_buffer( const ptr_circular_buffer& r )
-          : base_type( r.size(), r.begin(), r.end(), 
-                       ptr_container_detail::fixed_length_sequence_tag() )
-        { }
-
-        template< class U >
-        ptr_circular_buffer( const ptr_circular_buffer<U>& r )
-          : base_type( r.size(), r.begin(), r.end(), 
-                       ptr_container_detail::fixed_length_sequence_tag() )
-        { }
-
-        ptr_circular_buffer& operator=( ptr_circular_buffer r )
-        {
-            this->swap( r );
-            return *this;
-        }
-
-        BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_circular_buffer,
-                                                      base_type, this_type )
-            
-    public: // allocators
-        allocator_type& get_allocator() 
-        {
-            return this->base().get_allocator();
-        }
-
-        allocator_type get_allocator() const
-        {
-            return this->base().get_allocator();
-        }
-
-    public: // circular buffer functions
-        array_range array_one() // nothrow
-        {
-            typename circular_buffer_type::array_range r = this->base().array_one();
-            return array_range( reinterpret_cast<pointer>(r.first), r.second );
-        }
-
-        const_array_range array_one() const // nothrow
-        {
-            typename circular_buffer_type::const_array_range r = this->base().array_one();
-            return const_array_range( reinterpret_cast<const_pointer>(r.first), r.second );
-        }
-
-        array_range array_two() // nothrow
-        {
-            typename circular_buffer_type::array_range r = this->base().array_two();
-            return array_range( reinterpret_cast<pointer>(r.first), r.second );
-        }
-
-        const_array_range array_two() const // nothrow
-        {
-            typename circular_buffer_type::const_array_range r = this->base().array_two();
-            return const_array_range( reinterpret_cast<const_pointer>(r.first), r.second );
-        }
-
-        pointer linearize() // nothrow
-        {
-            return reinterpret_cast<pointer>(this->base().linearize());
-        }
-
-        bool full() const // nothrow
-        {
-            return this->base().full();
-        }
-
-        size_type reserve() const // nothrow
-        {
-            return this->base().reserve();
-        }
-
-        void reserve( size_type n ) // strong
-        {
-            if( capacity() < n )
-                set_capacity( n );
-        }
-
-        capacity_type capacity() const // nothrow
-        {
-            return this->base().capacity();
-        }
-
-        void set_capacity( capacity_type new_capacity ) // strong
-        {
-            if( this->size() > new_capacity )
-            {
-                this->erase( this->begin() + new_capacity, this->end() );
-            }
-            this->base().set_capacity( new_capacity );
-        }
-
-        void rset_capacity( capacity_type new_capacity ) // strong
-        {
-            if( this->size() > new_capacity )
-            {
-                this->erase( this->begin(), 
-                             this->begin() + (this->size()-new_capacity) );
-            }
-            this->base().rset_capacity( new_capacity );
-        }
-
-        void resize( size_type size ) // basic
-        {
-            size_type old_size = this->size();
-            if( old_size > size )
-            {
-                this->erase( boost::next( this->begin(), size ), this->end() );  
-            }
-            else if( size > old_size )
-            {
-                for( ; old_size != size; ++old_size )
-                    this->push_back( new BOOST_DEDUCED_TYPENAME 
-                                     boost::remove_pointer<value_type>::type() ); 
-            }
-
-            BOOST_ASSERT( this->size() == size );
-        }
-
-        void resize( size_type size, value_type to_clone ) // basic
-        {
-            size_type old_size = this->size();
-            if( old_size > size )
-            {
-                this->erase( boost::next( this->begin(), size ), this->end() );  
-            }
-            else if( size > old_size )
-            {
-                for( ; old_size != size; ++old_size )
-                    this->push_back( this->null_policy_allocate_clone( to_clone ) ); 
-            }
-
-            BOOST_ASSERT( this->size() == size );        
-        }
-
-        void rresize( size_type size ) // basic
-        {
-            size_type old_size = this->size();
-            if( old_size > size )
-            {
-                this->erase( this->begin(), 
-                             boost::next( this->begin(), old_size - size ) );  
-            }
-            else if( size > old_size )
-            {
-                for( ; old_size != size; ++old_size )
-                    this->push_front( new BOOST_DEDUCED_TYPENAME 
-                                      boost::remove_pointer<value_type>::type() ); 
-            }
-
-            BOOST_ASSERT( this->size() == size );
-        }
-
-        void rresize( size_type size, value_type to_clone ) // basic
-        {
-            size_type old_size = this->size();
-            if( old_size > size )
-            {
-                this->erase( this->begin(), 
-                             boost::next( this->begin(), old_size - size ) );  
-            }
-            else if( size > old_size )
-            {
-                for( ; old_size != size; ++old_size )
-                    this->push_front( this->null_policy_allocate_clone( to_clone ) ); 
-            }
-
-            BOOST_ASSERT( this->size() == size );
-        }           
-
-        template< class InputIterator >
-        void assign( InputIterator first, InputIterator last ) // strong
-        { 
-            ptr_circular_buffer temp( first, last );
-            this->swap( temp );
-        }
-
-        template< class Range >
-        void assign( const Range& r ) // strong
-        {
-            assign( boost::begin(r), boost::end(r ) );
-        }
-
-        void assign( size_type n, value_type to_clone ) // strong
-        {
-            ptr_circular_buffer temp( n );
-            for( size_type i = 0u; i != n; ++i )
-               temp.push_back( this->null_policy_allocate_clone( to_clone ) );
-            this->swap( temp ); 
-        }
-        
-        void assign( capacity_type capacity, size_type n, 
-                     value_type to_clone ) // basic
-        {
-            this->assign( (std::min)(n,capacity), to_clone );
-        }
-
-        template< class InputIterator >
-        void assign( capacity_type capacity, 
-                     InputIterator first, InputIterator last ) // basic
-        {
-            this->assign( first, last );
-            this->set_capacity( capacity );
-        }
-
-        void push_back( value_type ptr ) // nothrow
-        {
-            BOOST_ASSERT( capacity() > 0 );   
-            this->enforce_null_policy( ptr, "Null pointer in 'push_back()'" );
-         
-            auto_type old_ptr;
-            if( full() )
-                old_ptr.reset( &*this->begin() );
-            this->base().push_back( ptr );            
-        }
-
-        template< class U >
-        void push_back( std::auto_ptr<U> ptr ) // nothrow
-        {
-            push_back( ptr.release() ); 
-        }
-
-        void push_front( value_type ptr ) // nothrow
-        {
-            BOOST_ASSERT( capacity() > 0 );
-            this->enforce_null_policy( ptr, "Null pointer in 'push_front()'" );
-
-            auto_type old_ptr;
-            if( full() )
-                old_ptr.reset( &*(--this->end()) );
-            this->base().push_front( ptr );            
-        }
-
-        template< class U >
-        void push_front( std::auto_ptr<U> ptr ) // nothrow
-        {
-            push_front( ptr.release() ); 
-        }
-
-        iterator insert( iterator pos, value_type ptr ) // nothrow
-        {
-            BOOST_ASSERT( capacity() > 0 );
-            this->enforce_null_policy( ptr, "Null pointer in 'insert()'" );
-
-            auto_type new_ptr( ptr );
-            iterator b = this->begin();
-            if( full() && pos == b )
-                return b;
-            
-            auto_type old_ptr;
-            if( full() )
-                old_ptr.reset( &*this->begin() );
-
-            new_ptr.release();
-            return this->base().insert( pos.base(), ptr );
-        }
-
-        template< class U >
-        iterator insert( iterator pos, std::auto_ptr<U> ptr ) // nothrow
-        {
-            return insert( pos, ptr.release() );
-        }
-
-        template< class InputIterator >
-        void insert( iterator pos, InputIterator first, InputIterator last ) // basic
-        {
-            for( ; first != last; ++first, ++pos )
-                pos = insert( pos, this->null_policy_allocate_clone( &*first ) );                
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else
-        template< class Range >
-        BOOST_DEDUCED_TYPENAME
-        boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type
-        insert( iterator before, const Range& r )
-        {
-            insert( before, boost::begin(r), boost::end(r) );
-        }
-
-#endif
-           
-        iterator rinsert( iterator pos, value_type ptr ) // nothrow
-        {
-            BOOST_ASSERT( capacity() > 0 );
-            this->enforce_null_policy( ptr, "Null pointer in 'rinsert()'" );
-
-            auto_type new_ptr( ptr );
-            iterator b = this->end();
-            if (full() && pos == b)
-                return b;
-            
-            auto_type old_ptr;
-            if( full() )
-                old_ptr.reset( &this->back() );
-
-            new_ptr.release();
-            return this->base().rinsert( pos.base(), ptr );
-        }
-
-        template< class U >
-        iterator rinsert( iterator pos, std::auto_ptr<U> ptr ) // nothrow
-        {
-            return rinsert( pos, ptr.release() );
-        }
-
- 
-        template< class InputIterator >
-        void rinsert( iterator pos, InputIterator first, InputIterator last ) // basic
-        {
-            for( ; first != last; ++first, ++pos )
-                pos = rinsert( pos, this->null_policy_allocate_clone( &*first ) );                
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else
-        template< class Range >
-        BOOST_DEDUCED_TYPENAME
-        boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type
-        rinsert( iterator before, const Range& r )
-        {
-            rinsert( before, boost::begin(r), boost::end(r) );
-        }
-
-#endif
-
-        iterator rerase( iterator pos ) // nothrow
-        {
-            BOOST_ASSERT( !this->empty() );
-            BOOST_ASSERT( pos != this->end() );
-
-            this->remove( pos );
-            return iterator( this->base().rerase( pos.base() ) );
-        }
-
-        iterator rerase( iterator first, iterator last ) // nothrow
-        {
-            this->remove( first, last );
-            return iterator( this->base().rerase( first.base(),
-                                                  last.base() ) );
-        }
-
-        template< class Range >
-        iterator rerase( const Range& r ) // nothrow
-        {
-            return rerase( boost::begin(r), boost::end(r) );
-        }
-
-        void rotate( const_iterator new_begin ) // nothrow
-        {
-            this->base().rotate( new_begin.base() );
-        }
-
-    public: // transfer        
-        template< class PtrSeqAdapter >
-        void transfer( iterator before, 
-                       BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator first, 
-                       BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator last, 
-                       PtrSeqAdapter& from ) // nothrow
-        {
-            BOOST_ASSERT( (void*)&from != (void*)this );
-            if( from.empty() )
-                return;
-            for( BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator begin = first; 
-                 begin != last;  ++begin, ++before )
-                before = insert( before, &*begin );          // nothrow
-            from.base().erase( first.base(), last.base() );  // nothrow
-        }
-
-        template< class PtrSeqAdapter >
-        void transfer( iterator before, 
-                       BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator object, 
-                       PtrSeqAdapter& from ) // nothrow
-        {
-            BOOST_ASSERT( (void*)&from != (void*)this );
-            if( from.empty() )
-                return;
-            insert( before, &*object );          // nothrow 
-            from.base().erase( object.base() );  // nothrow 
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else
-        
-        template< class PtrSeqAdapter, class Range >
-        BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range,
-                      BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator > >::type
-        transfer( iterator before, const Range& r, PtrSeqAdapter& from ) // nothrow
-        {
-            transfer( before, boost::begin(r), boost::end(r), from );
-        }
-
-#endif
-        template< class PtrSeqAdapter >
-        void transfer( iterator before, PtrSeqAdapter& from ) // nothrow
-        {
-            transfer( before, from.begin(), from.end(), from );            
-        }
-
-    public: // C-array support
-    
-        void transfer( iterator before, value_type* from, 
-                       size_type size, bool delete_from = true ) // nothrow 
-        {
-            BOOST_ASSERT( from != 0 );
-            if( delete_from )
-            {
-                BOOST_DEDUCED_TYPENAME base_type::scoped_deleter 
-                    deleter( from, size );                         // nothrow
-                for( size_type i = 0u; i != size; ++i, ++before )
-                    before = insert( before, *(from+i) );          // nothrow
-                deleter.release();                                 // nothrow
-            }
-            else
-            {
-                for( size_type i = 0u; i != size; ++i, ++before )
-                    before = insert( before, *(from+i) );          // nothrow
-           }
-        }
-
-        value_type* c_array() // nothrow
-        {
-            if( this->empty() )
-                return 0;
-            this->linearize();
-            T** res = reinterpret_cast<T**>( &this->begin().base()[0] );
-            return res;
-        }
-
-    };
-
-    //////////////////////////////////////////////////////////////////////////////
-    // clonability
-
-    template< typename T, typename CA, typename A >
-    inline ptr_circular_buffer<T,CA,A>* new_clone( const ptr_circular_buffer<T,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-
-    /////////////////////////////////////////////////////////////////////////
-    // swap
-
-    template< typename T, typename CA, typename A >
-    inline void swap( ptr_circular_buffer<T,CA,A>& l, ptr_circular_buffer<T,CA,A>& r )
-    {
-        l.swap(r);
-    }
-    
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_container.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_container.hpp
deleted file mode 100644
index 6b1c92d515a..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_container.hpp
+++ /dev/null
@@ -1,31 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2008. 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/ptr_container/
-//
- 
-#ifndef BOOST_PTR_CONTAINER_HPP
-#define BOOST_PTR_CONTAINER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/ptr_container/ptr_array.hpp>
-#include <boost/ptr_container/ptr_deque.hpp>
-#include <boost/ptr_container/ptr_list.hpp>
-#include <boost/ptr_container/ptr_map.hpp>
-#include <boost/ptr_container/ptr_set.hpp>
-#include <boost/ptr_container/ptr_vector.hpp>
-#include <boost/ptr_container/ptr_unordered_map.hpp>
-#include <boost/ptr_container/ptr_unordered_set.hpp>
-#include <boost/ptr_container/ptr_circular_buffer.hpp>
-#include <boost/ptr_container/ptr_inserter.hpp>
-
-#endif
-
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_deque.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_deque.hpp
deleted file mode 100644
index 0223fc79a4c..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_deque.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_DEQUE_HPP
-#define BOOST_PTR_CONTAINER_PTR_DEQUE_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <deque>
-#include <boost/ptr_container/ptr_sequence_adapter.hpp>
-
-namespace boost
-{
-    
-    template
-    < 
-        class T, 
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator<void*>
-    >
-    class ptr_deque : public 
-        ptr_sequence_adapter< T,
-                              std::deque<void*,Allocator>,     
-                              CloneAllocator >
-    {
-         typedef   ptr_sequence_adapter< T,
-                                         std::deque<void*,Allocator>,     
-                                         CloneAllocator >
-          base_class;
-
-         typedef ptr_deque<T,CloneAllocator,Allocator> this_type; 
-         
-    public:
-
-      BOOST_PTR_CONTAINER_DEFINE_SEQEUENCE_MEMBERS( ptr_deque,
-                                                    base_class,
-                                                    this_type )
-    };
-
-    //////////////////////////////////////////////////////////////////////////////
-    // clonability
-    
-    template< typename T, typename CA, typename A >
-    inline ptr_deque<T,CA,A>* new_clone( const ptr_deque<T,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-
-    /////////////////////////////////////////////////////////////////////////
-    // swap
-
-    template< typename T, typename CA, typename A >
-    inline void swap( ptr_deque<T,CA,A>& l, ptr_deque<T,CA,A>& r )
-    {
-        l.swap(r);
-    }
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_inserter.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_inserter.hpp
deleted file mode 100644
index 71d1b60e700..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_inserter.hpp
+++ /dev/null
@@ -1,258 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2008. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_INSERTER_HPP
-#define BOOST_PTR_CONTAINER_PTR_INSERTER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-    #pragma once
-#endif
-
-#include <boost/config.hpp>
-#include <iterator>
-#include <memory>
-
-namespace boost
-{
-namespace ptr_container
-{
-    template< class PtrContainer >
-    class ptr_back_insert_iterator;
-
-    template< class PtrContainer >
-    class ptr_front_insert_iterator;
-    
-    template< class PtrContainer >
-    class ptr_insert_iterator;
-
-    template< class PtrContainer >
-    ptr_back_insert_iterator<PtrContainer> 
-    ptr_back_inserter( PtrContainer& cont );
-
-    template< class PtrContainer >
-    ptr_front_insert_iterator<PtrContainer> 
-    ptr_front_inserter( PtrContainer& cont );
-
-    template< class PtrContainer >
-    ptr_insert_iterator<PtrContainer> 
-    ptr_inserter( PtrContainer& cont, typename PtrContainer::iterator before );
-
-    //////////////////////////////////////////////////////////////////////////
-    // Implementation
-    ////////////////////////////////////////////////////////////////////////// 
-
-
-    template< class PtrContainer >
-    class ptr_back_insert_iterator :
-        public std::iterator<std::output_iterator_tag,void,void,void,void>
-    {
-    public:
-        typedef PtrContainer container_type;
-
-    public:
-        explicit ptr_back_insert_iterator( PtrContainer& cont )
-        : container(&cont)
-        { }
-
-        ptr_back_insert_iterator& 
-        operator=( typename PtrContainer::value_type r )
-        {
-            typename PtrContainer::value_type obj = 0;
-            if( r != 0 )
-                obj = container_type::clone_allocator_type::allocate_clone(*r);
-
-            container->push_back( obj );
-            return *this;
-        }
-
-        template< class T >
-        ptr_back_insert_iterator& 
-        operator=( std::auto_ptr<T> r )
-        {
-            container->push_back( r );
-            return *this;
-        }
-
-        ptr_back_insert_iterator& 
-        operator=( typename PtrContainer::const_reference r )
-        {
-            container->push_back( container_type::clone_allocator_type::
-                                  allocate_clone(r) );
-            return *this;
-        }
-
-        ptr_back_insert_iterator& operator*()
-        { 
-            return *this;
-        }
-
-        ptr_back_insert_iterator& operator++()
-        { 
-            return *this;
-        }
-
-        ptr_back_insert_iterator operator++(int)
-        { 
-            return *this;
-        }
-        
-    protected:
-        PtrContainer* container;
-    };
-
-
-    
-    template< class PtrContainer >
-    class ptr_front_insert_iterator :
-        public std::iterator<std::output_iterator_tag,void,void,void,void>
-    {
-    public:
-        typedef PtrContainer container_type;
-
-    public:
-        explicit ptr_front_insert_iterator( PtrContainer& cont )
-        : container(&cont)
-        { }
-
-        ptr_front_insert_iterator& 
-        operator=( typename PtrContainer::value_type r )
-        {
-            typename PtrContainer::value_type obj = 0;
-            if( r != 0 )
-                obj = container_type::clone_allocator_type::allocate_clone(*r);
-
-            container->push_front( obj );
-            return *this;
-        }
-
-        template< class T >
-        ptr_front_insert_iterator& 
-        operator=( std::auto_ptr<T> r )
-        {
-            container->push_front( r );
-            return *this;
-        }
-        
-        ptr_front_insert_iterator& 
-        operator=( typename PtrContainer::const_reference r )
-        {
-            container->push_front( container_type::clone_allocator_type::
-                                   allocate_clone(r) );
-            return *this;
-        }
-
-        ptr_front_insert_iterator& operator*()
-        { 
-            return *this;
-        }
-
-        ptr_front_insert_iterator& operator++()
-        { 
-            return *this;
-        }
-
-        ptr_front_insert_iterator operator++(int)
-        { 
-            return *this;
-        }
-        
-    protected:
-        PtrContainer* container;
-    };
-
-
-    
-    template< class PtrContainer >
-    class ptr_insert_iterator :
-        public std::iterator<std::output_iterator_tag,void,void,void,void>
-    {
-    public:
-        typedef PtrContainer container_type;
-
-    public:
-        ptr_insert_iterator( PtrContainer& cont,
-                               typename PtrContainer::iterator before )
-        : container(&cont), iter(before)
-        { }
-
-        ptr_insert_iterator& 
-        operator=( typename PtrContainer::value_type r )
-        {
-            typename PtrContainer::value_type obj = 0;
-            if( r != 0 )
-                obj = container_type::clone_allocator_type::allocate_clone(*r);
-
-            iter = container->insert( iter, obj );
-            return *this;
-        }
-
-        template< class T >
-        ptr_insert_iterator& 
-        operator=( std::auto_ptr<T> r )
-        {
-            iter = container->insert( iter, r );
-            return *this;
-        }
-        
-        ptr_insert_iterator& 
-        operator=( typename PtrContainer::const_reference r )
-        {
-            iter = container->insert( iter, container_type::clone_allocator_type::
-                                            allocate_clone(r) );
-            return *this;
-        }
-
-        ptr_insert_iterator& operator*()
-        { 
-            return *this;
-        }
-
-        ptr_insert_iterator& operator++()
-        { 
-            return *this;
-        }
-
-        ptr_insert_iterator operator++(int)
-        { 
-            return *this;
-        }
-        
-    protected:
-        PtrContainer*                    container;
-        typename PtrContainer::iterator  iter;
-    };
-
-    template< class PtrContainer >
-    inline ptr_back_insert_iterator<PtrContainer> 
-    ptr_back_inserter( PtrContainer& cont )
-    {
-        return ptr_back_insert_iterator<PtrContainer>( cont );
-    }
-
-    template< class PtrContainer >
-    inline ptr_front_insert_iterator<PtrContainer> 
-    ptr_front_inserter( PtrContainer& cont )
-    {
-        return ptr_front_insert_iterator<PtrContainer>( cont );
-    }
-
-    template< class PtrContainer >
-    inline ptr_insert_iterator<PtrContainer> 
-    ptr_inserter( PtrContainer& cont, 
-                    typename PtrContainer::iterator before )
-    {
-        return ptr_insert_iterator<PtrContainer>( cont, before );
-    }
-    
-} // namespace 'ptr_container'
-} // namespace 'boost'
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_list.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_list.hpp
deleted file mode 100644
index 7c900fa2212..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_list.hpp
+++ /dev/null
@@ -1,110 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_LIST_HPP
-#define BOOST_PTR_CONTAINER_PTR_LIST_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/ptr_container/ptr_sequence_adapter.hpp>
-#include <list>
-
-namespace boost
-{
-
-    template
-    < 
-        class T, 
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator<void*>
-    >
-    class ptr_list : public 
-        ptr_sequence_adapter< T, 
-                              std::list<void*,Allocator>, 
-                              CloneAllocator >
-    {
-        typedef    ptr_sequence_adapter< T, 
-                                         std::list<void*,Allocator>, 
-                                         CloneAllocator >
-            base_class;
-
-        typedef ptr_list<T,CloneAllocator,Allocator>  this_type;
-        
-    public:
-        BOOST_PTR_CONTAINER_DEFINE_SEQEUENCE_MEMBERS( ptr_list, 
-                                                      base_class,
-                                                      this_type )
-
-        typedef BOOST_DEDUCED_TYPENAME base_class::value_type value_type;
-        
-    public:
-        using base_class::merge;
-        
-        void merge( ptr_list& x )                                 
-        {
-            merge( x, std::less<T>() );
-        }
-
-        template< typename Compare > 
-        void merge( ptr_list& x, Compare comp )                   
-        {
-            this->base().merge( x.base(), void_ptr_indirect_fun<Compare,T>( comp ) ); }
-
-        void sort()                                                    
-        { 
-            sort( std::less<T>() ); 
-        };
-
-        template< typename Compare > 
-        void sort( Compare comp )                             
-        {
-            this->base().sort( void_ptr_indirect_fun<Compare,T>( comp ) );
-        }
-
-        template< class Pred >
-        void erase_if( iterator first, iterator last, Pred pred )
-        {
-            base_class::erase_if( first, last, pred );
-        }
-        
-        template< class Pred >
-        void erase_if( Pred pred )
-        {
-            this->base().remove_if( BOOST_DEDUCED_TYPENAME base_class:: 
-                    BOOST_NESTED_TEMPLATE void_ptr_delete_if<Pred,value_type>
-                                    (pred) );
-        } 
-
-    }; // class 'ptr_list'
-
-    //////////////////////////////////////////////////////////////////////////////
-    // clonability
-
-    template< typename T, typename CA, typename A >
-    inline ptr_list<T,CA,A>* new_clone( const ptr_list<T,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-    
-    /////////////////////////////////////////////////////////////////////////
-    // swap
-
-    template< typename T, typename CA, typename A >
-    inline void swap( ptr_list<T,CA,A>& l, ptr_list<T,CA,A>& r )
-    {
-        l.swap(r);
-    }
-}
-
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_map.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_map.hpp
deleted file mode 100644
index cbd39d7b1a9..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_map.hpp
+++ /dev/null
@@ -1,165 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_MAP_HPP
-#define BOOST_PTR_CONTAINER_PTR_MAP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <map>
-#include <boost/ptr_container/ptr_map_adapter.hpp>
-
-namespace boost
-{
-    
-    template
-    < 
-        class Key, 
-        class T, 
-        class Compare        = std::less<Key>,
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator< std::pair<const Key,void*> >
-    >
-    class ptr_map : 
-        public ptr_map_adapter<T,std::map<Key,void*,
-                               Compare,Allocator>,CloneAllocator>
-    {
-        typedef ptr_map_adapter<T,std::map<Key,void*,
-                                Compare,Allocator>,CloneAllocator>
-            base_type;
-
-        typedef ptr_map<Key,T,Compare,CloneAllocator,Allocator> this_type;
-        
-    public:
-        ptr_map()
-        { }
-        
-        explicit ptr_map( const Compare& comp,
-                          const Allocator& a  = Allocator() ) 
-          : base_type( comp, a ) { }
-
-        template< class InputIterator >
-        ptr_map( InputIterator first, InputIterator last )
-          : base_type( first, last )
-        { }
-        
-        template< class InputIterator >
-        ptr_map( InputIterator first, InputIterator last, 
-                 const Compare& comp,
-                 const Allocator& a  = Allocator() )
-          : base_type( first, last, comp, a ) 
-        { }
-
-        BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_map, base_type, 
-                                                      this_type )
-
-        template< class U >
-        ptr_map( const ptr_map<Key,U>& r ) : base_type( r )
-        { }
-
-        ptr_map& operator=( ptr_map r )
-        {
-            this->swap( r );
-            return *this;
-        }
-    };
-    
-
-
-    template
-    < 
-        class Key, 
-        class T, 
-        class Compare        = std::less<Key>, 
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator< std::pair<const Key,void*> >
-    >
-    class ptr_multimap : 
-        public ptr_multimap_adapter<T,std::multimap<Key,void*,
-                                    Compare,Allocator>,CloneAllocator>
-    {
-        typedef ptr_multimap_adapter<T,std::multimap<Key,void*,
-                                     Compare,Allocator>,CloneAllocator>
-             base_type;
-
-        typedef ptr_multimap<Key,T,Compare,CloneAllocator,Allocator> this_type;
-        
-    public:
-        ptr_multimap()
-        { }
-        
-        explicit ptr_multimap( const Compare& comp,
-                               const Allocator& a  = Allocator() ) 
-          : base_type( comp, a ) { }
-
-        template< class InputIterator >
-        ptr_multimap( InputIterator first, InputIterator last )
-          : base_type( first,  last )
-        { }
-        
-        template< class InputIterator >
-        ptr_multimap( InputIterator first, InputIterator last,
-                      const Compare& comp,
-                      const Allocator& a  = Allocator() )
-          : base_type( first, last, comp, a ) 
-        { }
-
-        BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_multimap, 
-                                                      base_type,
-                                                      this_type )
-
-        template< class U >
-        ptr_multimap( const ptr_multimap<Key,U>& r ) : base_type( r )
-        { }
-
-        ptr_multimap& operator=( ptr_multimap r )
-        {
-            this->swap( r );
-            return *this;
-        }
-    };
-
-    //////////////////////////////////////////////////////////////////////////////
-    // clonability
-
-    template< class K, class T, class C, class CA, class A >
-    inline ptr_map<K,T,C,CA,A>* new_clone( const ptr_map<K,T,C,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-
-    template< class K, class T, class C, class CA, class A >
-    inline ptr_multimap<K,T,C,CA,A>* new_clone( const ptr_multimap<K,T,C,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-
-    /////////////////////////////////////////////////////////////////////////
-    // swap
-
-    template< typename K, typename T, typename C, typename CA, typename A >
-    inline void swap( ptr_map<K,T,C,CA,A>& l, ptr_map<K,T,C,CA,A>& r )
-    {
-        l.swap(r);
-    }
-
-    template< typename K, typename T, typename C, typename CA, typename A >
-    inline void swap( ptr_multimap<K,T,C,CA,A>& l, ptr_multimap<K,T,C,CA,A>& r )
-    {
-        l.swap(r);
-    }
-
-
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_map_adapter.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_map_adapter.hpp
deleted file mode 100644
index f3ce83af897..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_map_adapter.hpp
+++ /dev/null
@@ -1,874 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_DETAIL_PTR_MAP_ADAPTER_HPP
-#define BOOST_PTR_CONTAINER_DETAIL_PTR_MAP_ADAPTER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/ptr_container/detail/map_iterator.hpp>
-#include <boost/ptr_container/detail/associative_ptr_container.hpp>
-#include <boost/ptr_container/detail/meta_functions.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/range/iterator_range.hpp>
-
-namespace boost
-{
-namespace ptr_container_detail
-{
-
-    template
-    < 
-        class T,
-        class VoidPtrMap,
-        bool  Ordered
-    >
-    struct map_config
-    {
-        typedef BOOST_DEDUCED_TYPENAME remove_nullable<T>::type
-                     U;
-        typedef VoidPtrMap 
-                     void_container_type;
-        
-        typedef BOOST_DEDUCED_TYPENAME VoidPtrMap::allocator_type
-                     allocator_type;
-        
-       typedef BOOST_DEDUCED_TYPENAME 
-           mpl::eval_if_c<Ordered, 
-                          select_value_compare<VoidPtrMap>, 
-                          mpl::identity<void> >::type
-                    value_compare;
-
-       typedef BOOST_DEDUCED_TYPENAME 
-           mpl::eval_if_c<Ordered, 
-                          select_key_compare<VoidPtrMap>, 
-                          mpl::identity<void> >::type
-                    key_compare;
-
-       typedef BOOST_DEDUCED_TYPENAME 
-           mpl::eval_if_c<Ordered,
-                          mpl::identity<void>,
-                          select_hasher<VoidPtrMap> >::type
-                    hasher;
-
-       typedef BOOST_DEDUCED_TYPENAME 
-           mpl::eval_if_c<Ordered,
-                          mpl::identity<void>,
-                          select_key_equal<VoidPtrMap> >::type
-                    key_equal;
-
-       typedef BOOST_DEDUCED_TYPENAME 
-           mpl::if_c<Ordered,
-                     ptr_container_detail::ordered_associative_container_tag,
-                     ptr_container_detail::unordered_associative_container_tag>::type
-                    container_type;
-        
-        typedef BOOST_DEDUCED_TYPENAME VoidPtrMap::key_type
-                     key_type;
-        
-        typedef U    value_type;
-
-        typedef ptr_map_iterator< BOOST_DEDUCED_TYPENAME VoidPtrMap::iterator, key_type, U* const >
-                     iterator;
-        
-        typedef ptr_map_iterator< BOOST_DEDUCED_TYPENAME VoidPtrMap::const_iterator, key_type, const U* const>
-                     const_iterator;
-        
-        typedef ptr_map_iterator<
-           BOOST_DEDUCED_TYPENAME 
-             mpl::eval_if_c<Ordered, 
-                            select_iterator<VoidPtrMap>,
-                            select_local_iterator<VoidPtrMap> >::type,
-             key_type, U* const >
-                    local_iterator;
-
-       typedef ptr_map_iterator<
-           BOOST_DEDUCED_TYPENAME 
-             mpl::eval_if_c<Ordered, 
-                            select_iterator<VoidPtrMap>,
-                            select_const_local_iterator<VoidPtrMap> >::type,
-             key_type, const U* const >
-                    const_local_iterator;  
-       
-        template< class Iter >
-        static U* get_pointer( Iter i )
-        {
-            return i->second;
-        }
-
-        template< class Iter >
-        static const U* get_const_pointer( Iter i )
-        {
-            return i->second;
-        }
-
-        BOOST_STATIC_CONSTANT( bool, allow_null = boost::is_nullable<T>::value );
-    };
-    
-    
-
-    template
-    < 
-        class T,
-        class VoidPtrMap, 
-        class CloneAllocator,
-        bool  Ordered
-    >
-    class ptr_map_adapter_base : 
-        public ptr_container_detail::associative_ptr_container< map_config<T,VoidPtrMap,Ordered>,
-                                                    CloneAllocator >
-    {
-        typedef ptr_container_detail::associative_ptr_container< map_config<T,VoidPtrMap,Ordered>,
-                                                     CloneAllocator > 
-            base_type;
-
-        typedef map_config<T,VoidPtrMap,Ordered>                           config;
-        typedef ptr_map_adapter_base<T,VoidPtrMap,CloneAllocator,Ordered>  this_type;
-        
-    public:
-
-        typedef BOOST_DEDUCED_TYPENAME base_type::allocator_type
-                    allocator_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::iterator
-                    iterator;
-        typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator
-                    const_iterator;
-        typedef BOOST_DEDUCED_TYPENAME base_type::size_type
-                    size_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::key_type
-                    key_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::auto_type
-                    auto_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::value_type 
-                    mapped_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::reference
-                    mapped_reference;
-        typedef BOOST_DEDUCED_TYPENAME base_type::const_reference
-                    const_mapped_reference;
-        typedef BOOST_DEDUCED_TYPENAME iterator_value<iterator>::type
-                    value_type;
-        typedef value_type
-                    reference;
-        typedef BOOST_DEDUCED_TYPENAME iterator_value<const_iterator>::type
-                    const_reference;
-        typedef value_type 
-                    pointer;
-        typedef const_reference 
-                    const_pointer;
-
-    private:
-        const_mapped_reference lookup( const key_type& key ) const
-        {
-           const_iterator i = this->find( key );
-           if( i != this->end() )
-               return *i->second;
-           else                                           
-               BOOST_PTR_CONTAINER_THROW_EXCEPTION( true, bad_ptr_container_operation,
-                                                    "'ptr_map/multimap::at()' could"
-                                                    " not find key" );
-        }
-
-        struct eraser // scope guard
-        {
-            bool            released_;
-            VoidPtrMap*     m_;
-            const key_type& key_;
-
-            eraser( VoidPtrMap* m, const key_type& key ) 
-              : released_(false), m_(m), key_(key)
-            {}
-
-            ~eraser() 
-            {
-                if( !released_ )
-                    m_->erase(key_);
-            }
-
-            void release() { released_ = true; }
-
-        private:  
-            eraser& operator=(const eraser&);  
-        };
-
-        mapped_reference insert_lookup( const key_type& key )
-        {
-            void*& ref = this->base()[key];
-            if( ref )
-            {
-                return *static_cast<mapped_type>(ref);
-            }
-            else
-            {
-                eraser e(&this->base(),key);      // nothrow
-                mapped_type res = new T();        // strong 
-                ref = res;                        // nothrow
-                e.release();                      // nothrow
-                return *res;
-            }
-          }
-        
-    public:
-
-        ptr_map_adapter_base()
-        { }
-
-        template< class SizeType >
-        explicit ptr_map_adapter_base( SizeType n, 
-                                       ptr_container_detail::unordered_associative_container_tag tag )
-        : base_type( n, tag )
-        { }
-
-        template< class Compare, class Allocator >
-        ptr_map_adapter_base( const Compare& comp,
-                              const Allocator& a ) 
-        : base_type( comp, a ) 
-        { }
-
-        template< class Hash, class Pred, class Allocator >
-        ptr_map_adapter_base( const Hash& hash,
-                              const Pred& pred,
-                              const Allocator& a )
-         : base_type( hash, pred, a )
-        { }
-                
-        template< class InputIterator >
-        ptr_map_adapter_base( InputIterator first, InputIterator last )
-         : base_type( first, last )
-        { }
-                
-        template< class InputIterator, class Comp >
-        ptr_map_adapter_base( InputIterator first, InputIterator last,
-                              const Comp& comp,
-                              const allocator_type& a = allocator_type() )
-        : base_type( first, last, comp, a )
-        { }
-
-        template< class InputIterator, class Hash, class Pred, class Allocator >
-        ptr_map_adapter_base( InputIterator first, InputIterator last,
-                              const Hash& hash,
-                              const Pred& pred,
-                              const Allocator& a )
-         : base_type( first, last, hash, pred, a )
-        { }
-                
-        template< class PtrContainer >
-        explicit ptr_map_adapter_base( std::auto_ptr<PtrContainer> clone ) 
-        : base_type( clone )
-        { }
-        
-        template< typename PtrContainer >
-        ptr_map_adapter_base& operator=( std::auto_ptr<PtrContainer> clone )    
-        {
-            base_type::operator=( clone );
-            return *this;
-        }        
-
-        iterator find( const key_type& x )                                                
-        {                                                                            
-            return iterator( this->base().find( x ) );                                
-        }                                                                            
-
-        const_iterator find( const key_type& x ) const                                    
-        {                                                                            
-            return const_iterator( this->base().find( x ) );                          
-        }                                                                            
-
-        size_type count( const key_type& x ) const                                        
-        {                                                                            
-            return this->base().count( x );                                           
-        }                                                                            
-                                                                                     
-        iterator lower_bound( const key_type& x )                                         
-        {                                                                            
-            return iterator( this->base().lower_bound( x ) );                         
-        }                                                                            
-                                                                                     
-        const_iterator lower_bound( const key_type& x ) const                             
-        {                                                                            
-            return const_iterator( this->base().lower_bound( x ) );                   
-        }                                                                            
-                                                                                     
-        iterator upper_bound( const key_type& x )                                         
-        {                                                                            
-            return iterator( this->base().upper_bound( x ) );                         
-        }                                                                            
-                                                                                     
-        const_iterator upper_bound( const key_type& x ) const                             
-        {                                                                            
-            return const_iterator( this->base().upper_bound( x ) );                   
-        }                                                                            
-                                                                                     
-        iterator_range<iterator> equal_range( const key_type& x )                    
-        {                                                                            
-            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,
-                      BOOST_DEDUCED_TYPENAME base_type::ptr_iterator>
-                 p = this->base().equal_range( x );   
-            return make_iterator_range( iterator( p.first ), iterator( p.second ) );      
-        }                                                                            
-                                                                                     
-        iterator_range<const_iterator> equal_range( const key_type& x ) const  
-        {                                                                            
-            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator,
-                      BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator> 
-                p = this->base().equal_range( x ); 
-            return make_iterator_range( const_iterator( p.first ), 
-                                        const_iterator( p.second ) );    
-        }                                                                            
-                                                                                     
-        mapped_reference at( const key_type& key )  
-        {   
-            return const_cast<mapped_reference>( lookup( key ) ); 
-        }
-                                                                                     
-        const_mapped_reference at( const key_type& key ) const
-        {                                                                            
-            return lookup( key );
-        }
-
-        mapped_reference operator[]( const key_type& key )
-        {
-            return insert_lookup( key );
-        }              
-
-        auto_type replace( iterator where, mapped_type x ) // strong  
-        { 
-            BOOST_ASSERT( where != this->end() );
-
-            this->enforce_null_policy( x, "Null pointer in 'replace()'" );
-
-            auto_type ptr( x );
-
-            BOOST_PTR_CONTAINER_THROW_EXCEPTION( this->empty(),
-                                                 bad_ptr_container_operation,
-                                                 "'replace()' on empty container" );
-
-            auto_type old( where->second );       // nothrow
-            where.base()->second = ptr.release(); // nothrow, commit
-            return boost::ptr_container::move( old );
-        }
-
-        template< class U >
-        auto_type replace( iterator where, std::auto_ptr<U> x )
-        {
-            return replace( where, x.release() );
-        }
-
-    protected:
-        size_type bucket( const key_type& key ) const
-        {
-            return this->base().bucket( key );
-        }
-    };
-    
-} // ptr_container_detail
-
-    /////////////////////////////////////////////////////////////////////////
-    // ptr_map_adapter
-    /////////////////////////////////////////////////////////////////////////
-    
-    template
-    < 
-        class T,
-        class VoidPtrMap, 
-        class CloneAllocator = heap_clone_allocator,
-        bool  Ordered        = true
-    >
-    class ptr_map_adapter : 
-        public ptr_container_detail::ptr_map_adapter_base<T,VoidPtrMap,CloneAllocator,Ordered>
-    {
-        typedef ptr_container_detail::ptr_map_adapter_base<T,VoidPtrMap,CloneAllocator,Ordered> 
-            base_type;
-    
-    public:    
-        typedef BOOST_DEDUCED_TYPENAME base_type::iterator 
-                     iterator;       
-        typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator
-                     const_iterator;
-        typedef BOOST_DEDUCED_TYPENAME base_type::size_type
-                    size_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::key_type
-                    key_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::const_reference
-                    const_reference;
-        typedef BOOST_DEDUCED_TYPENAME base_type::auto_type
-                    auto_type;
-        typedef BOOST_DEDUCED_TYPENAME VoidPtrMap::allocator_type 
-                    allocator_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::mapped_type
-                    mapped_type;
-    private:
-
-        void safe_insert( const key_type& key, auto_type ptr ) // strong
-        {
-            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool>
-                res = 
-                this->base().insert( std::make_pair( key, ptr.get() ) ); // strong, commit      
-            if( res.second )                                             // nothrow     
-                ptr.release();                                           // nothrow
-        }
-
-        template< class II >                                               
-        void map_basic_clone_and_insert( II first, II last )                  
-        {       
-            while( first != last )                                            
-            {                                            
-                if( this->find( first->first ) == this->end() )
-                {
-                    const_reference p = *first.base();     // nothrow                    
-                    auto_type ptr( this->null_policy_allocate_clone( p.second ) ); 
-                                                           // strong 
-                    this->safe_insert( p.first, 
-                                       boost::ptr_container::move( ptr ) );
-                                                           // strong, commit 
-                }
-                ++first;                                                      
-            }                                                                 
-        }
-    
-    public:
-        ptr_map_adapter( )
-        { }
-
-        template< class Comp >
-        explicit ptr_map_adapter( const Comp& comp,
-                                  const allocator_type& a ) 
-          : base_type( comp, a ) { }
-
-        template< class Hash, class Pred, class Allocator >
-        ptr_map_adapter( const Hash& hash,
-                         const Pred& pred,
-                         const Allocator& a )
-         : base_type( hash, pred, a )
-        { }
-                
-        template< class InputIterator >
-        ptr_map_adapter( InputIterator first, InputIterator last )
-        {
-            map_basic_clone_and_insert( first, last ); 
-        }
-               
-        template< class InputIterator, class Comp >
-        ptr_map_adapter( InputIterator first, InputIterator last, 
-                         const Comp& comp,
-                         const allocator_type& a = allocator_type() )
-          : base_type( comp, a ) 
-        {
-            map_basic_clone_and_insert( first, last );
-        }
-
-        template< class InputIterator, class Hash, class Pred, class Allocator >
-        ptr_map_adapter( InputIterator first, InputIterator last,
-                         const Hash& hash,
-                         const Pred& pred,
-                         const Allocator& a )
-          : base_type( hash, pred, a )
-        {
-            map_basic_clone_and_insert( first, last ); 
-        }
-                
-        ptr_map_adapter( const ptr_map_adapter& r )
-        {
-            map_basic_clone_and_insert( r.begin(), r.end() );      
-        }
-        
-        template< class Key, class U, class CA, bool b >
-        ptr_map_adapter( const ptr_map_adapter<Key,U,CA,b>& r )
-        {
-            map_basic_clone_and_insert( r.begin(), r.end() );      
-        }
-        
-        template< class U >
-        ptr_map_adapter( std::auto_ptr<U> r ) : base_type( r )
-        { }
-
-        ptr_map_adapter& operator=( ptr_map_adapter r )
-        {
-            this->swap( r );
-            return *this;
-        }
-
-        template< class U >
-        ptr_map_adapter& operator=( std::auto_ptr<U> r )
-        {  
-            base_type::operator=( r );
-            return *this;
-        }
-
-        using base_type::release;
-
-        template< typename InputIterator >
-        void insert( InputIterator first, InputIterator last ) // basic
-        {
-            map_basic_clone_and_insert( first, last );
-        }
-
-        template< class Range >
-        void insert( const Range& r )
-        {
-            insert( boost::begin(r), boost::end(r) );
-        }
-
-    private:
-        std::pair<iterator,bool> insert_impl( const key_type& key, mapped_type x ) // strong
-        {
-            this->enforce_null_policy( x, "Null pointer in ptr_map_adapter::insert()" );
-            auto_type ptr( x );                                         // nothrow
-
-            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool>
-                 res = this->base().insert( std::make_pair( key, x ) ); // strong, commit      
-            if( res.second )                                            // nothrow     
-                ptr.release();                                          // nothrow
-            return std::make_pair( iterator( res.first ), res.second ); // nothrow        
-        }
-
-        iterator insert_impl( iterator before, const key_type& key, mapped_type x ) // strong
-        {
-            this->enforce_null_policy( x, 
-                  "Null pointer in 'ptr_map_adapter::insert()'" );
-            auto_type ptr( x );         // nothrow
-            BOOST_DEDUCED_TYPENAME base_type::ptr_iterator
-                res = this->base().insert( before.base(), std::make_pair( key, x ) );
-                                        // strong, commit        
-            ptr.release();              // notrow
-            return iterator( res );                       
-        }
-        
-    public:
-        
-        std::pair<iterator,bool> insert( key_type& key, mapped_type x )
-        {
-            return insert_impl( key, x );
-        }
-
-        template< class U >
-        std::pair<iterator,bool> insert( const key_type& key, std::auto_ptr<U> x )
-        {
-            return insert_impl( key, x.release() );
-        }
-
-        template< class F, class S >
-        iterator insert( iterator before, ptr_container_detail::ref_pair<F,S> p ) // strong
-        {
-            this->enforce_null_policy( p.second, 
-                  "Null pointer in 'ptr_map_adapter::insert()'" );
- 
-            auto_type ptr( this->null_policy_allocate_clone( p.second ) ); 
-            BOOST_DEDUCED_TYPENAME base_type::ptr_iterator
-                result = this->base().insert( before.base(), 
-                                     std::make_pair(p.first,ptr.get()) ); // strong
-            if( ptr.get() == result->second )
-                ptr.release();
-    
-            return iterator( result );
-        }
-
-        iterator insert( iterator before, key_type& key, mapped_type x ) // strong
-        {
-            return insert_impl( before, key, x );
-        }
-
-        template< class U >
-        iterator insert( iterator before, const key_type& key, std::auto_ptr<U> x ) // strong
-        {
-            return insert_impl( before, key, x.release() );
-        }
-        
-        template< class PtrMapAdapter >
-        bool transfer( BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator object, 
-                       PtrMapAdapter& from ) // strong
-        {
-            return this->single_transfer( object, from );
-        }
-
-        template< class PtrMapAdapter >
-        size_type transfer( BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator first, 
-                            BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator last, 
-                            PtrMapAdapter& from ) // basic
-        {
-            return this->single_transfer( first, last, from );
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else    
-
-        template< class PtrMapAdapter, class Range >
-        BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range,
-                            BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator >,
-                                                            size_type >::type
-        transfer( const Range& r, PtrMapAdapter& from ) // basic
-        {
-            return transfer( boost::begin(r), boost::end(r), from );
-        }
-        
-#endif
-
-        template< class PtrMapAdapter >
-        size_type transfer( PtrMapAdapter& from ) // basic
-        {
-            return transfer( from.begin(), from.end(), from );
-        }
-  };
-  
-  /////////////////////////////////////////////////////////////////////////
-  // ptr_multimap_adapter
-  /////////////////////////////////////////////////////////////////////////
-
-    template
-    < 
-        class T,
-        class VoidPtrMultiMap, 
-        class CloneAllocator = heap_clone_allocator,
-        bool  Ordered        = true
-    >
-    class ptr_multimap_adapter : 
-        public ptr_container_detail::ptr_map_adapter_base<T,VoidPtrMultiMap,CloneAllocator,Ordered>
-    {
-        typedef ptr_container_detail::ptr_map_adapter_base<T,VoidPtrMultiMap,CloneAllocator,Ordered>
-             base_type;
-
-    public: // typedefs
-        typedef BOOST_DEDUCED_TYPENAME base_type::iterator           
-                       iterator;                 
-        typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator     
-                       const_iterator;           
-        typedef BOOST_DEDUCED_TYPENAME base_type::size_type
-                       size_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::key_type
-                       key_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::const_reference
-                       const_reference;
-        typedef BOOST_DEDUCED_TYPENAME base_type::mapped_type
-                    mapped_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::auto_type
-                    auto_type;            
-        typedef BOOST_DEDUCED_TYPENAME VoidPtrMultiMap::allocator_type 
-                    allocator_type;
-    private:
-
-        void safe_insert( const key_type& key, auto_type ptr ) // strong
-        {
-            this->base().insert( 
-                           std::make_pair( key, ptr.get() ) ); // strong, commit      
-            ptr.release();                                     // nothrow
-        }
-        
-        template< typename II >                                               
-        void map_basic_clone_and_insert( II first, II last )                  
-        {                                                         
-            while( first != last )                                            
-            {                                            
-                const_reference pair = *first.base();     // nothrow                     
-                auto_type ptr( this->null_policy_allocate_clone( pair.second ) );    
-                                                          // strong
-                safe_insert( pair.first, 
-                             boost::ptr_container::move( ptr ) );
-                                                          // strong, commit 
-                ++first;                                                      
-            }                                                                 
-        }
-        
-    public:
-
-        ptr_multimap_adapter()
-        { }
-
-        template< class SizeType >
-        ptr_multimap_adapter( SizeType n, 
-                              ptr_container_detail::unordered_associative_container_tag tag )
-          : base_type( n, tag )
-        { }
-
-        template< class Comp >
-        explicit ptr_multimap_adapter( const Comp& comp,
-                                       const allocator_type& a )
-          : base_type( comp, a ) { }
-
-        template< class Hash, class Pred, class Allocator >
-        ptr_multimap_adapter( const Hash& hash,
-                              const Pred& pred,
-                              const Allocator& a )
-         : base_type( hash, pred, a )
-        { }
-
-        template< class InputIterator >
-        ptr_multimap_adapter( InputIterator first, InputIterator last )
-        {
-            map_basic_clone_and_insert( first, last );
-        }
-        
-        template< class InputIterator, class Comp >
-        ptr_multimap_adapter( InputIterator first, InputIterator last,
-                              const Comp& comp,
-                              const allocator_type& a )
-          : base_type( comp, a )
-        {
-            map_basic_clone_and_insert( first, last );
-        }
-
-        template< class InputIterator, class Hash, class Pred, class Allocator >
-        ptr_multimap_adapter( InputIterator first, InputIterator last,
-                              const Hash& hash,
-                              const Pred& pred,
-                              const Allocator& a )
-         : base_type( hash, pred, a )
-        {
-            map_basic_clone_and_insert( first, last ); 
-        }
-
-        ptr_multimap_adapter( const ptr_multimap_adapter& r )
-        {
-            map_basic_clone_and_insert( r.begin(), r.end() );      
-        }
-        
-        template< class Key, class U, class CA, bool b >
-        ptr_multimap_adapter( const ptr_multimap_adapter<Key,U,CA,b>& r )
-        {
-            map_basic_clone_and_insert( r.begin(), r.end() );      
-        }
-        
-        template< class U >
-        explicit ptr_multimap_adapter( std::auto_ptr<U> r ) : base_type( r )
-        { }
-
-        ptr_multimap_adapter& operator=( ptr_multimap_adapter r )
-        {
-            this->swap( r );
-            return *this;
-        }
-
-        template< class U >
-        ptr_multimap_adapter& operator=( std::auto_ptr<U> r )
-        {  
-            base_type::operator=( r );
-            return *this;
-        }
-
-        using base_type::release;
-
-    private:
-        iterator insert_impl( const key_type& key, mapped_type x ) // strong
-        {
-            this->enforce_null_policy( x, 
-                  "Null pointer in 'ptr_multimap_adapter::insert()'" );
-            auto_type ptr( x );         // nothrow
-            BOOST_DEDUCED_TYPENAME base_type::ptr_iterator
-                res = this->base().insert( std::make_pair( key, x ) );
-                                        // strong, commit        
-            ptr.release();              // notrow
-            return iterator( res );           
-        }
-
-        iterator insert_impl( iterator before, const key_type& key, mapped_type x ) // strong
-        {
-            this->enforce_null_policy( x, 
-                  "Null pointer in 'ptr_multimap_adapter::insert()'" );
-            auto_type ptr( x );         // nothrow
-            BOOST_DEDUCED_TYPENAME base_type::ptr_iterator
-                res = this->base().insert( before.base(), 
-                                           std::make_pair( key, x ) );
-                                        // strong, commit        
-            ptr.release();              // notrow
-            return iterator( res );                       
-        }
-
-    public:
-        template< typename InputIterator >
-        void insert( InputIterator first, InputIterator last ) // basic
-        {
-            map_basic_clone_and_insert( first, last );
-        }
-
-        template< class Range >
-        void insert( const Range& r )
-        {
-            insert( boost::begin(r), boost::end(r) );
-        }
-
-        iterator insert( key_type& key, mapped_type x ) // strong
-        {
-            return insert_impl( key, x );
-        }
-
-        template< class U >
-        iterator insert( const key_type& key, std::auto_ptr<U> x )
-        {
-            return insert_impl( key, x.release() );
-        }
-
-        template< class F, class S >
-        iterator insert( iterator before, ptr_container_detail::ref_pair<F,S> p ) // strong
-        {
-            this->enforce_null_policy( p.second, 
-                  "Null pointer in 'ptr_multimap_adapter::insert()'" );
-            iterator res = insert_impl( before, p.first, 
-                                        this->null_policy_allocate_clone( p.second ) );
-            return res;
-        }
-
-        iterator insert( iterator before, key_type& key, mapped_type x ) // strong
-        {
-            return insert_impl( before, key, x );
-        }
-
-        template< class U >
-        iterator insert( iterator before, const key_type& key, std::auto_ptr<U> x ) // strong
-        {
-            return insert_impl( before, key, x.release() );
-        }
-        
-        template< class PtrMapAdapter >
-        void transfer( BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator object, 
-                       PtrMapAdapter& from ) // strong
-        {
-            this->multi_transfer( object, from );
-        }
-
-        template< class PtrMapAdapter >
-        size_type transfer( BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator first, 
-                            BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator last, 
-                            PtrMapAdapter& from ) // basic
-        {
-            return this->multi_transfer( first, last, from );
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else    
-
-        template<  class PtrMapAdapter, class Range >
-        BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range,
-                            BOOST_DEDUCED_TYPENAME PtrMapAdapter::iterator >,
-                                                            size_type >::type
-        transfer( const Range& r, PtrMapAdapter& from ) // basic
-        {
-            return transfer( boost::begin(r), boost::end(r), from );
-        }
-
-#endif        
-        template< class PtrMapAdapter >
-        void transfer( PtrMapAdapter& from ) // basic
-        {
-            transfer( from.begin(), from.end(), from );
-            BOOST_ASSERT( from.empty() );
-        }
-
-    };
-
-    template< class I, class F, class S >
-    inline bool is_null( const ptr_map_iterator<I,F,S>& i )
-    {
-        return i->second == 0;
-    }
-    
-} // namespace 'boost'  
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_sequence_adapter.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_sequence_adapter.hpp
deleted file mode 100644
index a7717ed8e8e..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_sequence_adapter.hpp
+++ /dev/null
@@ -1,775 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_SEQUENCE_ADAPTER_HPP
-#define BOOST_PTR_CONTAINER_PTR_SEQUENCE_ADAPTER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-
-#include <boost/ptr_container/detail/reversible_ptr_container.hpp>
-#include <boost/ptr_container/indirect_fun.hpp>
-#include <boost/ptr_container/detail/void_ptr_iterator.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-#include <boost/type_traits/is_same.hpp>
-
-
-namespace boost
-{   
-namespace ptr_container_detail
-{    
-    template
-    < 
-        class T, 
-        class VoidPtrSeq
-    >
-    struct sequence_config
-    {
-        typedef BOOST_DEDUCED_TYPENAME remove_nullable<T>::type
-                    U;
-        typedef VoidPtrSeq
-                    void_container_type;
-
-        typedef BOOST_DEDUCED_TYPENAME VoidPtrSeq::allocator_type
-                    allocator_type;
-        
-        typedef U   value_type;
-
-        typedef void_ptr_iterator<
-                        BOOST_DEDUCED_TYPENAME VoidPtrSeq::iterator, U > 
-                    iterator;
-       
-        typedef void_ptr_iterator<
-                        BOOST_DEDUCED_TYPENAME VoidPtrSeq::const_iterator, const U >
-                    const_iterator;
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-
-        template< class Iter >
-        static U* get_pointer( Iter i )
-        {
-            return static_cast<U*>( *i.base() );
-        }
-        
-#else
-        template< class Iter >
-        static U* get_pointer( void_ptr_iterator<Iter,U> i )
-        {
-            return static_cast<U*>( *i.base() );
-        }
-
-        template< class Iter >
-        static U* get_pointer( Iter i )
-        {
-            return &*i;
-        }
-#endif        
-
-#if defined(BOOST_NO_SFINAE) && !BOOST_WORKAROUND(__MWERKS__, <= 0x3003)
-
-        template< class Iter >
-        static const U* get_const_pointer( Iter i )
-        {
-            return static_cast<const U*>( *i.base() );
-        }
-        
-#else // BOOST_NO_SFINAE
-
-#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003)
-        template< class Iter >
-        static const U* get_const_pointer( void_ptr_iterator<Iter,U> i )
-        {
-            return static_cast<const U*>( *i.base() );
-        }
-#else // BOOST_WORKAROUND
-        template< class Iter >
-        static const U* get_const_pointer( void_ptr_iterator<Iter,const U> i )
-        {
-            return static_cast<const U*>( *i.base() );
-        }
-#endif // BOOST_WORKAROUND
-
-        template< class Iter >
-        static const U* get_const_pointer( Iter i )
-        {
-            return &*i;
-        }
-#endif // BOOST_NO_SFINAE
-
-        BOOST_STATIC_CONSTANT(bool, allow_null = boost::is_nullable<T>::value );
-    };
-    
-} // ptr_container_detail
-
-
-    template< class Iterator, class T >
-    inline bool is_null( void_ptr_iterator<Iterator,T> i )
-    {
-        return *i.base() == 0;
-    }
-
-
-    
-    template
-    < 
-        class T,
-        class VoidPtrSeq, 
-        class CloneAllocator = heap_clone_allocator
-    >
-    class ptr_sequence_adapter : public 
-        ptr_container_detail::reversible_ptr_container< ptr_container_detail::sequence_config<T,VoidPtrSeq>, 
-                                            CloneAllocator >
-    {
-        typedef ptr_container_detail::reversible_ptr_container< ptr_container_detail::sequence_config<T,VoidPtrSeq>,
-                                                    CloneAllocator >
-             base_type;
-        
-        typedef ptr_sequence_adapter<T,VoidPtrSeq,CloneAllocator>                         
-            this_type;
-
-    protected:
-        typedef BOOST_DEDUCED_TYPENAME base_type::scoped_deleter scoped_deleter;
-         
-    public:
-        typedef BOOST_DEDUCED_TYPENAME base_type::value_type  value_type; 
-        typedef BOOST_DEDUCED_TYPENAME base_type::reference   reference; 
-        typedef BOOST_DEDUCED_TYPENAME base_type::const_reference 
-                                                              const_reference;
-        typedef BOOST_DEDUCED_TYPENAME base_type::auto_type   auto_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::clone_allocator_type
-                                                              clone_allocator_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::iterator    iterator;          
-        typedef BOOST_DEDUCED_TYPENAME base_type::size_type   size_type;  
-        typedef BOOST_DEDUCED_TYPENAME base_type::allocator_type  
-                                                              allocator_type;
-                
-        ptr_sequence_adapter()
-        { }
-
-        template< class Allocator >
-        explicit ptr_sequence_adapter( const Allocator& a )
-          : base_type( a )
-        { }
-
-        template< class SizeType >
-        ptr_sequence_adapter( SizeType n, 
-                              ptr_container_detail::fixed_length_sequence_tag tag )
-          : base_type( n, tag )
-        { }
-
-        template< class SizeType, class Allocator >
-        ptr_sequence_adapter( SizeType n, const Allocator& a, 
-                              ptr_container_detail::fixed_length_sequence_tag tag )
-          : base_type( n, a, tag )
-        { }
-
-        template< class InputIterator >
-        ptr_sequence_adapter( InputIterator first, InputIterator last )
-          : base_type( first, last )
-        { }
-
-        template< class InputIterator, class Allocator >
-        ptr_sequence_adapter( InputIterator first, InputIterator last,
-                              const Allocator& a )
-          : base_type( first, last, a )
-        { }
-
-        template< class ForwardIterator >
-        ptr_sequence_adapter( ForwardIterator first,
-                              ForwardIterator last,
-                              ptr_container_detail::fixed_length_sequence_tag tag )
-          : base_type( first, last,  tag )
-        { }
-
-        template< class SizeType, class ForwardIterator >
-        ptr_sequence_adapter( SizeType n,
-                              ForwardIterator first,
-                              ForwardIterator last,
-                              ptr_container_detail::fixed_length_sequence_tag tag )
-          : base_type( n, first, last,  tag )
-        { }
-
-        ptr_sequence_adapter( const ptr_sequence_adapter& r )
-          : base_type( r )
-        { }
-        
-        template< class U >
-        ptr_sequence_adapter( const ptr_sequence_adapter<U,VoidPtrSeq,CloneAllocator>& r )
-          : base_type( r )
-        { }
-        
-        ptr_sequence_adapter( const ptr_sequence_adapter& r,
-                              ptr_container_detail::fixed_length_sequence_tag tag )
-          : base_type( r, tag )
-        { }
-        
-        template< class U >
-        ptr_sequence_adapter( const ptr_sequence_adapter<U,VoidPtrSeq,CloneAllocator>& r,
-                              ptr_container_detail::fixed_length_sequence_tag tag )
-          : base_type( r, tag )
-        { }
-        
-        template< class PtrContainer >
-        explicit ptr_sequence_adapter( std::auto_ptr<PtrContainer> clone )
-          : base_type( clone )
-        { }
-
-        ptr_sequence_adapter& operator=( const ptr_sequence_adapter r )
-        {
-            this->swap( r );
-            return *this; 
-        }
-        
-        template< class PtrContainer >
-        ptr_sequence_adapter& operator=( std::auto_ptr<PtrContainer> clone )    
-        {
-            base_type::operator=( clone );
-            return *this;
-        }
-
-        /////////////////////////////////////////////////////////////
-        // modifiers
-        /////////////////////////////////////////////////////////////
-
-        void push_back( value_type x )  // strong               
-        {
-            this->enforce_null_policy( x, "Null pointer in 'push_back()'" );
-
-            auto_type ptr( x );           // notrow
-            this->base().push_back( x );  // strong, commit
-            ptr.release();                // nothrow
-        }
-
-        template< class U >
-        void push_back( std::auto_ptr<U> x )
-        {
-            push_back( x.release() );
-        }
-        
-        void push_front( value_type x )                
-        {
-            this->enforce_null_policy( x, "Null pointer in 'push_front()'" );
-
-            auto_type ptr( x );           // nothrow
-            this->base().push_front( x ); // strong, commit
-            ptr.release();                // nothrow
-        }
-
-        template< class U >
-        void push_front( std::auto_ptr<U> x )
-        {
-            push_front( x.release() );
-        }
-
-        auto_type pop_back()
-        {
-            BOOST_ASSERT( !this->empty() && 
-                          "'pop_back()' on empty container" );
-            auto_type ptr( static_cast<value_type>( this->base().back() ) );      
-                                                       // nothrow
-            this->base().pop_back();                   // nothrow
-            return ptr_container_detail::move( ptr );  // nothrow
-        }
-
-        auto_type pop_front()
-        {
-            BOOST_ASSERT( !this->empty() &&
-                          "'pop_front()' on empty container" ); 
-            auto_type ptr( static_cast<value_type>( this->base().front() ) ); 
-                                         // nothrow 
-            this->base().pop_front();    // nothrow
-            return ptr_container_detail::move( ptr ); 
-        }
-        
-        reference front()        
-        { 
-            BOOST_ASSERT( !this->empty() &&
-                          "accessing 'front()' on empty container" );
-
-            BOOST_ASSERT( !::boost::is_null( this->begin() ) );
-            return *this->begin(); 
-        }
-
-        const_reference front() const  
-        {
-            return const_cast<ptr_sequence_adapter*>(this)->front();
-        }
-
-        reference back()
-        {
-            BOOST_ASSERT( !this->empty() &&
-                          "accessing 'back()' on empty container" );
-            BOOST_ASSERT( !::boost::is_null( --this->end() ) );
-            return *--this->end(); 
-        }
-
-        const_reference back() const
-        {
-            return const_cast<ptr_sequence_adapter*>(this)->back();
-        }
-
-    public: // deque/vector inerface
-        
-        reference operator[]( size_type n ) // nothrow 
-        {
-            BOOST_ASSERT( n < this->size() );
-            BOOST_ASSERT( !this->is_null( n ) );
-            return *static_cast<value_type>( this->base()[n] ); 
-        }
-        
-        const_reference operator[]( size_type n ) const // nothrow  
-        { 
-            BOOST_ASSERT( n < this->size() ); 
-            BOOST_ASSERT( !this->is_null( n ) );
-            return *static_cast<value_type>( this->base()[n] );
-        }
-        
-        reference at( size_type n )
-        {
-            BOOST_PTR_CONTAINER_THROW_EXCEPTION( n >= this->size(), bad_index, 
-                                                 "'at()' out of bounds" );
-            BOOST_ASSERT( !this->is_null( n ) );
-            return (*this)[n];
-        }
-        
-        const_reference at( size_type n ) const
-        {
-            BOOST_PTR_CONTAINER_THROW_EXCEPTION( n >= this->size(), bad_index, 
-                                                 "'at()' out of bounds" );
-            BOOST_ASSERT( !this->is_null( n ) );
-            return (*this)[n]; 
-        }
-        
-    public: // vector interface
-        
-        size_type capacity() const
-        {
-            return this->base().capacity();
-        }
-        
-        void reserve( size_type n )
-        {
-            this->base().reserve( n ); 
-        }
-
-        void reverse()
-        {
-            this->base().reverse(); 
-        }
-
-    public: // assign, insert, transfer
-
-        // overhead: 1 heap allocation (very cheap compared to cloning)
-        template< class InputIterator >
-        void assign( InputIterator first, InputIterator last ) // strong
-        { 
-            base_type temp( first, last );
-            this->swap( temp );
-        }
-
-        template< class Range >
-        void assign( const Range& r ) // strong
-        {
-            assign( boost::begin(r), boost::end(r ) );
-        }
-
-    private:
-        template< class I >
-        void insert_impl( iterator before, I first, I last, std::input_iterator_tag ) // strong
-        {
-            ptr_sequence_adapter temp(first,last);  // strong
-            transfer( before, temp );               // strong, commit
-        }
-
-        template< class I >
-        void insert_impl( iterator before, I first, I last, std::forward_iterator_tag ) // strong
-        {
-            if( first == last ) 
-                return;
-            scoped_deleter sd( first, last );                // strong
-            this->insert_clones_and_release( sd, before );   // strong, commit 
-        }
-
-    public:
-
-        using base_type::insert;
-        
-        template< class InputIterator >
-        void insert( iterator before, InputIterator first, InputIterator last ) // strong
-        {
-            insert_impl( before, first, last, BOOST_DEDUCED_TYPENAME
-                         iterator_category<InputIterator>::type() );
-        } 
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else
-        template< class Range >
-        BOOST_DEDUCED_TYPENAME
-        boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type
-        insert( iterator before, const Range& r )
-        {
-            insert( before, boost::begin(r), boost::end(r) );
-        }
-
-#endif
-        
-        template< class PtrSeqAdapter >
-        void transfer( iterator before, 
-                       BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator first, 
-                       BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator last, 
-                       PtrSeqAdapter& from ) // strong
-        {
-            BOOST_ASSERT( (void*)&from != (void*)this );
-            if( from.empty() )
-                return;
-            this->base().
-                insert( before.base(), first.base(), last.base() ); // strong
-            from.base().erase( first.base(), last.base() );         // nothrow
-        }
-
-        template< class PtrSeqAdapter >
-        void transfer( iterator before, 
-                       BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator object, 
-                       PtrSeqAdapter& from ) // strong
-        {
-            BOOST_ASSERT( (void*)&from != (void*)this );
-            if( from.empty() )
-                return;
-            this->base().insert( before.base(), *object.base() ); // strong 
-            from.base().erase( object.base() );                  // nothrow 
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else
-        
-        template< class PtrSeqAdapter, class Range >
-        BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range,
-                      BOOST_DEDUCED_TYPENAME PtrSeqAdapter::iterator > >::type
-        transfer( iterator before, const Range& r, PtrSeqAdapter& from ) // strong
-        {
-            transfer( before, boost::begin(r), boost::end(r), from );
-        }
-
-#endif
-        template< class PtrSeqAdapter >
-        void transfer( iterator before, PtrSeqAdapter& from ) // strong
-        {
-            BOOST_ASSERT( (void*)&from != (void*)this );
-            if( from.empty() )
-                return;
-            this->base().
-                insert( before.base(),
-                        from.begin().base(), from.end().base() ); // strong
-            from.base().clear();                                  // nothrow
-        }
-
-    public: // C-array support
-    
-        void transfer( iterator before, value_type* from, 
-                       size_type size, bool delete_from = true ) // strong 
-        {
-            BOOST_ASSERT( from != 0 );
-            if( delete_from )
-            {
-                BOOST_DEDUCED_TYPENAME base_type::scoped_deleter 
-                    deleter( from, size );                                // nothrow
-                this->base().insert( before.base(), from, from + size );  // strong
-                deleter.release();                                        // nothrow
-            }
-            else
-            {
-                this->base().insert( before.base(), from, from + size ); // strong
-            }
-        }
-
-        value_type* c_array() // nothrow
-        {
-            if( this->empty() )
-                return 0;
-            T** res = reinterpret_cast<T**>( &this->begin().base()[0] );
-            return res;
-        }
-
-    public: // null functions
-         
-        bool is_null( size_type idx ) const
-        {
-            BOOST_ASSERT( idx < this->size() );
-            return this->base()[idx] == 0;
-        }
-
-    public: // resize
-
-        void resize( size_type size ) // basic
-        {
-            size_type old_size = this->size();
-            if( old_size > size )
-            {
-                this->erase( boost::next( this->begin(), size ), this->end() );  
-            }
-            else if( size > old_size )
-            {
-                for( ; old_size != size; ++old_size )
-                    this->push_back( new BOOST_DEDUCED_TYPENAME 
-                                     boost::remove_pointer<value_type>::type() ); 
-            }
-
-            BOOST_ASSERT( this->size() == size );
-        }
-
-        void resize( size_type size, value_type to_clone ) // basic
-        {
-            size_type old_size = this->size();
-            if( old_size > size )
-            {
-                this->erase( boost::next( this->begin(), size ), this->end() );  
-            }
-            else if( size > old_size )
-            {
-                for( ; old_size != size; ++old_size )
-                    this->push_back( this->null_policy_allocate_clone( to_clone ) ); 
-            }
-
-            BOOST_ASSERT( this->size() == size );        
-        }
-
-        void rresize( size_type size ) // basic
-        {
-            size_type old_size = this->size();
-            if( old_size > size )
-            {
-                this->erase( this->begin(), 
-                             boost::next( this->begin(), old_size - size ) );  
-            }
-            else if( size > old_size )
-            {
-                for( ; old_size != size; ++old_size )
-                    this->push_front( new BOOST_DEDUCED_TYPENAME 
-                                      boost::remove_pointer<value_type>::type() ); 
-            }
-
-            BOOST_ASSERT( this->size() == size );
-        }
-
-        void rresize( size_type size, value_type to_clone ) // basic
-        {
-            size_type old_size = this->size();
-            if( old_size > size )
-            {
-                this->erase( this->begin(), 
-                             boost::next( this->begin(), old_size - size ) );  
-            }
-            else if( size > old_size )
-            {
-                for( ; old_size != size; ++old_size )
-                    this->push_front( this->null_policy_allocate_clone( to_clone ) ); 
-            }
-
-            BOOST_ASSERT( this->size() == size );
-        }           
-                
-    public: // algorithms
-
-        void sort( iterator first, iterator last )
-        {
-            sort( first, last, std::less<T>() );
-        }
-        
-        void sort()
-        {
-            sort( this->begin(), this->end() );
-        }
-
-        template< class Compare >
-        void sort( iterator first, iterator last, Compare comp )
-        {
-            BOOST_ASSERT( first <= last && "out of range sort()" );
-            BOOST_ASSERT( this->begin() <= first && "out of range sort()" );
-            BOOST_ASSERT( last <= this->end() && "out of range sort()" ); 
-            // some static assert on the arguments of the comparison
-            std::sort( first.base(), last.base(), 
-                       void_ptr_indirect_fun<Compare,T>(comp) );
-        }
-        
-        template< class Compare >
-        void sort( Compare comp )
-        {
-            sort( this->begin(), this->end(), comp );
-        }
-        
-        void unique( iterator first, iterator last )
-        {
-            unique( first, last, std::equal_to<T>() );
-        }
-        
-        void unique()
-        {
-            unique( this->begin(), this->end() );
-        }
-
-    private:
-        struct is_not_zero_ptr
-        {
-            template< class U >
-            bool operator()( const U* r ) const
-            {
-                return r != 0;
-            }
-        };
-
-    protected:
-        template< class Fun, class Arg1 >
-        class void_ptr_delete_if 
-        {
-            Fun fun;
-        public:
-        
-            void_ptr_delete_if() : fun(Fun())
-            { }
-        
-            void_ptr_delete_if( Fun f ) : fun(f)
-            { }
-        
-            bool operator()( void* r ) const
-            {
-               BOOST_ASSERT( r != 0 );
-               Arg1 arg1 = static_cast<Arg1>(r);
-               if( fun( *arg1 ) )
-               { 
-                   clone_allocator_type::deallocate_clone( arg1 );
-                   return true;
-               }
-               return false;
-            }
-        };
-
-    private:
-        void compact_and_erase_nulls( iterator first, iterator last ) // nothrow
-        {
-            typename base_type::ptr_iterator p = std::stable_partition( 
-                                                    first.base(), 
-                                                    last.base(), 
-                                                    is_not_zero_ptr() );
-            this->base().erase( p, this->end().base() );
-            
-        }
-
-        void range_check_impl( iterator first, iterator last, 
-                               std::bidirectional_iterator_tag )
-        { /* do nothing */ }
-
-        void range_check_impl( iterator first, iterator last,
-                               std::random_access_iterator_tag )
-        {
-            BOOST_ASSERT( first <= last && "out of range unique()/erase_if()" );
-            BOOST_ASSERT( this->begin() <= first && "out of range unique()/erase_if()" );
-            BOOST_ASSERT( last <= this->end() && "out of range unique()/erase_if)(" );             
-        }
-        
-        void range_check( iterator first, iterator last )
-        {
-            range_check_impl( first, last, 
-                              BOOST_DEDUCED_TYPENAME iterator_category<iterator>::type() );
-        }
-        
-    public:
-        
-        template< class Compare >
-        void unique( iterator first, iterator last, Compare comp )
-        {
-            range_check(first,last);
-            
-            iterator prev = first;
-            iterator next = first;
-            ++next;
-            for( ; next != last; ++next )
-            {
-                BOOST_ASSERT( !::boost::is_null(prev) );
-                BOOST_ASSERT( !::boost::is_null(next) );
-                if( comp( *prev, *next ) )
-                {
-                    this->remove( next ); // delete object
-                    *next.base() = 0;     // mark pointer as deleted
-                }
-                else
-                {
-                    prev = next;
-                }
-                // ++next
-            }
-
-            compact_and_erase_nulls( first, last );
-        }
-        
-        template< class Compare >
-        void unique( Compare comp )
-        {
-            unique( this->begin(), this->end(), comp );
-        }
-
-        template< class Pred >
-        void erase_if( iterator first, iterator last, Pred pred )
-        {
-            range_check(first,last);
-            this->base().erase( std::remove_if( first.base(), last.base(), 
-                                                void_ptr_delete_if<Pred,value_type>(pred) ),
-                                last.base() );  
-        }
-        
-        template< class Pred >
-        void erase_if( Pred pred )
-        {
-            erase_if( this->begin(), this->end(), pred );
-        }
-
-
-        void merge( iterator first, iterator last, 
-                    ptr_sequence_adapter& from )
-        {
-             merge( first, last, from, std::less<T>() );
-        }
-        
-        template< class BinPred >
-        void merge( iterator first, iterator last, 
-                    ptr_sequence_adapter& from, BinPred pred )
-        {
-            void_ptr_indirect_fun<BinPred,T>  bin_pred(pred);
-            size_type                         current_size = this->size(); 
-            this->transfer( this->end(), first, last, from );
-            typename base_type::ptr_iterator middle = this->begin().base();
-            std::advance(middle,current_size); 
-            std::inplace_merge( this->begin().base(),
-                                middle,
-                                this->end().base(),
-                                bin_pred );
-        }
-        
-        void merge( ptr_sequence_adapter& r )
-        {
-            merge( r, std::less<T>() );
-            BOOST_ASSERT( r.empty() );
-        }
-        
-        template< class BinPred >
-        void merge( ptr_sequence_adapter& r, BinPred pred )
-        {
-            merge( r.begin(), r.end(), r, pred );
-            BOOST_ASSERT( r.empty() );    
-        }
-        
-    };
-
-
-} // namespace 'boost'  
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_set.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_set.hpp
deleted file mode 100644
index 74bfa412105..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_set.hpp
+++ /dev/null
@@ -1,155 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_SET_HPP
-#define BOOST_PTR_CONTAINER_PTR_SET_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/ptr_container/indirect_fun.hpp>
-#include <boost/ptr_container/ptr_set_adapter.hpp>
-#include <set>
-
-namespace boost
-{
-
-    template
-    < 
-        class Key, 
-        class Compare        = std::less<Key>,
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator<void*>
-    >
-    class ptr_set : 
-        public ptr_set_adapter< Key, 
-                                std::set<void*,void_ptr_indirect_fun<Compare,Key>,Allocator>,
-                                CloneAllocator, true >
-    {
-        typedef ptr_set_adapter< Key, std::set<void*,void_ptr_indirect_fun<Compare,Key>,Allocator>,
-                                 CloneAllocator, true >
-             base_type;
-
-        typedef ptr_set<Key,Compare,CloneAllocator,Allocator> this_type;
-        
-    public:
-        ptr_set()
-        { }
-        
-        explicit ptr_set( const Compare& comp,
-                          const Allocator& a = Allocator() ) 
-         : base_type( comp, a ) 
-        { }
-
-        template< typename InputIterator >
-        ptr_set( InputIterator first, InputIterator last )
-         : base_type( first, last )
-        { }
-
-        template< typename InputIterator >
-        ptr_set( InputIterator first, InputIterator last, 
-                 const Compare& comp,
-                 const Allocator& a = Allocator() ) 
-         : base_type( first, last, comp, a )
-        { }
-
-        BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_set,
-                                                      base_type,
-                                                      this_type )
-        
-        BOOST_PTR_CONTAINER_DEFINE_COPY_CONSTRUCTORS( ptr_set, base_type )
-                
-    };
-        
-        
-        
-    template
-    < 
-        class Key, 
-        class Compare        = std::less<Key>,
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator<void*>
-    >
-    class ptr_multiset : 
-        public ptr_multiset_adapter< Key,
-                                     std::multiset<void*,void_ptr_indirect_fun<Compare,Key>,Allocator>,
-                                     CloneAllocator, true >
-    {
-        typedef ptr_multiset_adapter< Key,
-                                      std::multiset<void*,void_ptr_indirect_fun<Compare,Key>,Allocator>,
-                                      CloneAllocator, true >
-              base_type;
-        typedef ptr_multiset<Key,Compare,CloneAllocator,Allocator> this_type;
-        
-    public:
-        ptr_multiset()
-        { }
-        
-        explicit ptr_multiset( const Compare& comp,
-                               const Allocator& a    = Allocator() )
-         : base_type( comp, a ) 
-        { }
-
-        template< typename InputIterator >
-        ptr_multiset( InputIterator first, InputIterator last )
-         : base_type( first, last )
-        { }
-
-        template< typename InputIterator >
-        ptr_multiset( InputIterator first, InputIterator last,
-                      const Compare& comp,
-                      const Allocator& a  = Allocator() )
-         : base_type( first, last, comp, a ) 
-        { }
-
-        BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_multiset, 
-                                                      base_type,
-                                                      this_type )
-        
-        BOOST_PTR_CONTAINER_DEFINE_COPY_CONSTRUCTORS( ptr_multiset, 
-                                                      base_type )     
-
-    };
-
-    /////////////////////////////////////////////////////////////////////////
-    // clonability
-
-    template< typename K, typename C, typename CA, typename A >
-    inline ptr_set<K,C,CA,A>* new_clone( const ptr_set<K,C,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-
-    template< typename K, typename C, typename CA, typename A >
-    inline ptr_multiset<K,C,CA,A>* new_clone( const ptr_multiset<K,C,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-    
-    /////////////////////////////////////////////////////////////////////////
-    // swap
-
-    template< typename K, typename C, typename CA, typename A >
-    inline void swap( ptr_set<K,C,CA,A>& l, ptr_set<K,C,CA,A>& r )
-    {
-        l.swap(r);
-    }
-
-    template< typename K, typename C, typename CA, typename A >
-    inline void swap( ptr_multiset<K,C,CA,A>& l, ptr_multiset<K,C,CA,A>& r )
-    {
-        l.swap(r);
-    }
-
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_set_adapter.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_set_adapter.hpp
deleted file mode 100644
index 4b6aacd6044..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_set_adapter.hpp
+++ /dev/null
@@ -1,692 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_SET_ADAPTER_HPP
-#define BOOST_PTR_CONTAINER_PTR_SET_ADAPTER_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/ptr_container/detail/associative_ptr_container.hpp>
-#include <boost/ptr_container/detail/meta_functions.hpp>
-#include <boost/ptr_container/detail/void_ptr_iterator.hpp>
-#include <boost/range/iterator_range.hpp>
-
-namespace boost
-{
-namespace ptr_container_detail
-{
-    template
-    < 
-        class Key,
-        class VoidPtrSet,
-        bool  Ordered
-    >
-    struct set_config
-    {
-       typedef VoidPtrSet 
-                    void_container_type;
-
-       typedef BOOST_DEDUCED_TYPENAME VoidPtrSet::allocator_type 
-                    allocator_type;
-
-       typedef Key  value_type;
-
-       typedef value_type 
-                    key_type;
-
-       typedef BOOST_DEDUCED_TYPENAME 
-           mpl::eval_if_c<Ordered, 
-                          select_value_compare<VoidPtrSet>, 
-                          mpl::identity<void> >::type
-                    value_compare;
-
-       typedef value_compare 
-                    key_compare;
-
-       typedef BOOST_DEDUCED_TYPENAME 
-           mpl::eval_if_c<Ordered,
-                          mpl::identity<void>,
-                          select_hasher<VoidPtrSet> >::type
-                    hasher;
-
-       typedef BOOST_DEDUCED_TYPENAME 
-           mpl::eval_if_c<Ordered,
-                          mpl::identity<void>,
-                          select_key_equal<VoidPtrSet> >::type
-                    key_equal;
-
-       typedef BOOST_DEDUCED_TYPENAME 
-           mpl::if_c<Ordered,
-                     ordered_associative_container_tag,
-                     unordered_associative_container_tag>::type
-                    container_type;
-
-       typedef void_ptr_iterator<
-                       BOOST_DEDUCED_TYPENAME VoidPtrSet::iterator, Key > 
-                    iterator;
-
-       typedef void_ptr_iterator<
-                        BOOST_DEDUCED_TYPENAME VoidPtrSet::const_iterator, const Key >
-                    const_iterator;
-
-       typedef void_ptr_iterator<
-           BOOST_DEDUCED_TYPENAME 
-             mpl::eval_if_c<Ordered, 
-                            select_iterator<VoidPtrSet>,
-                            select_local_iterator<VoidPtrSet> >::type,
-             Key >
-                    local_iterator;
-
-       typedef void_ptr_iterator<
-           BOOST_DEDUCED_TYPENAME 
-             mpl::eval_if_c<Ordered, 
-                            select_iterator<VoidPtrSet>,
-                            select_const_local_iterator<VoidPtrSet> >::type,
-             const Key >
-                    const_local_iterator;           
-       
-       template< class Iter >
-       static Key* get_pointer( Iter i )
-       {
-           return static_cast<Key*>( *i.base() );
-       }
-
-       template< class Iter >
-       static const Key* get_const_pointer( Iter i )
-       {
-           return static_cast<const Key*>( *i.base() );
-       }
-
-       BOOST_STATIC_CONSTANT(bool, allow_null = false );
-    };
-
- 
-    
-    template
-    < 
-        class Key,
-        class VoidPtrSet, 
-        class CloneAllocator = heap_clone_allocator,
-        bool  Ordered        = true
-    >
-    class ptr_set_adapter_base 
-        : public ptr_container_detail::associative_ptr_container< set_config<Key,VoidPtrSet,Ordered>,
-                                                      CloneAllocator >
-    {
-        typedef ptr_container_detail::associative_ptr_container< set_config<Key,VoidPtrSet,Ordered>,
-                                                     CloneAllocator >
-              base_type;
-    public:  
-        typedef BOOST_DEDUCED_TYPENAME base_type::iterator 
-                      iterator;
-        typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator 
-                      const_iterator;
-        typedef Key   key_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::size_type
-                      size_type;
-
-    public:
-        ptr_set_adapter_base() 
-        { }
-
-        template< class SizeType >
-        ptr_set_adapter_base( SizeType n, 
-                              ptr_container_detail::unordered_associative_container_tag tag )
-          : base_type( n, tag )
-        { }
-                
-        template< class Compare, class Allocator >
-        ptr_set_adapter_base( const Compare& comp,
-                              const Allocator& a ) 
-         : base_type( comp, a ) 
-        { }
-
-        template< class Hash, class Pred, class Allocator >
-        ptr_set_adapter_base( const Hash& hash,
-                              const Pred& pred,
-                              const Allocator& a )
-         : base_type( hash, pred, a )
-        { }
-
-        template< class InputIterator, class Compare, class Allocator >
-        ptr_set_adapter_base( InputIterator first, InputIterator last,
-                              const Compare& comp,
-                              const Allocator& a ) 
-         : base_type( first, last, comp, a ) 
-        { }
-
-        template< class InputIterator, class Hash, class Pred, class Allocator >
-        ptr_set_adapter_base( InputIterator first, InputIterator last,
-                              const Hash& hash,
-                              const Pred& pred,
-                              const Allocator& a )
-         : base_type( first, last, hash, pred, a )
-        { }
-               
-        template< class U, class Set, class CA, bool b >
-        ptr_set_adapter_base( const ptr_set_adapter_base<U,Set,CA,b>& r )
-          : base_type( r )
-        { }
-
-        ptr_set_adapter_base( const ptr_set_adapter_base& r )
-          : base_type( r )
-        { }
-                
-        template< class PtrContainer >
-        explicit ptr_set_adapter_base( std::auto_ptr<PtrContainer> clone )
-         : base_type( clone )
-        { }
-        
-        ptr_set_adapter_base& operator=( ptr_set_adapter_base r ) 
-        {
-            this->swap( r );
-            return *this;
-        }
-        
-        template< typename PtrContainer >
-        ptr_set_adapter_base& operator=( std::auto_ptr<PtrContainer> clone )    
-        {
-            base_type::operator=( clone );
-            return *this;
-        }
-
-        using base_type::erase;
-        
-        size_type erase( const key_type& x ) // nothrow
-        {
-            key_type* key = const_cast<key_type*>(&x);
-            iterator i( this->base().find( key ) );       
-            if( i == this->end() )                                  // nothrow
-                return 0u;                                          // nothrow
-            key = static_cast<key_type*>(*i.base());                // nothrow
-            size_type res = this->base().erase( key );              // nothrow 
-            this->remove( key );                                    // nothrow
-            return res;
-        }
-
-
-        iterator find( const key_type& x )                                                
-        {                                                                            
-            return iterator( this->base().
-                             find( const_cast<key_type*>(&x) ) );            
-        }                                                                            
-
-        const_iterator find( const key_type& x ) const                                    
-        {                                                                            
-            return const_iterator( this->base().
-                                   find( const_cast<key_type*>(&x) ) );                  
-        }                                                                            
-
-        size_type count( const key_type& x ) const                                        
-        {                                                                            
-            return this->base().count( const_cast<key_type*>(&x) );                      
-        }                                                                            
-                                                                                     
-        iterator lower_bound( const key_type& x )                                         
-        {                                                                            
-            return iterator( this->base().
-                             lower_bound( const_cast<key_type*>(&x) ) );                   
-        }                                                                            
-                                                                                     
-        const_iterator lower_bound( const key_type& x ) const                             
-        {                                                                            
-            return const_iterator( this->base().
-                                   lower_bound( const_cast<key_type*>(&x) ) );       
-        }                                                                            
-                                                                                     
-        iterator upper_bound( const key_type& x )                                         
-        {                                                                            
-            return iterator( this->base().
-                             upper_bound( const_cast<key_type*>(&x) ) );           
-        }                                                                            
-                                                                                     
-        const_iterator upper_bound( const key_type& x ) const                             
-        {                                                                            
-            return const_iterator( this->base().
-                                   upper_bound( const_cast<key_type*>(&x) ) );             
-        }                                                                            
-                                                                                     
-        iterator_range<iterator> equal_range( const key_type& x )                    
-        {                                                                            
-            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,
-                      BOOST_DEDUCED_TYPENAME base_type::ptr_iterator> 
-                p = this->base().
-                equal_range( const_cast<key_type*>(&x) );   
-            return make_iterator_range( iterator( p.first ), 
-                                        iterator( p.second ) );      
-        }                                                                            
-                                                                                     
-        iterator_range<const_iterator> equal_range( const key_type& x ) const  
-        {                                                                            
-            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator,
-                      BOOST_DEDUCED_TYPENAME base_type::ptr_const_iterator> 
-                p = this->base().
-                equal_range( const_cast<key_type*>(&x) ); 
-            return make_iterator_range( const_iterator( p.first ), 
-                                        const_iterator( p.second ) );    
-        }    
-
-    protected:
-        size_type bucket( const key_type& key ) const
-        {
-            return this->base().bucket( const_cast<key_type*>(&key) );
-        }
-    };
-
-} // ptr_container_detail
-
-    /////////////////////////////////////////////////////////////////////////
-    // ptr_set_adapter
-    /////////////////////////////////////////////////////////////////////////
-  
-    template
-    <
-        class Key,
-        class VoidPtrSet, 
-        class CloneAllocator = heap_clone_allocator,
-        bool  Ordered        = true
-    >
-    class ptr_set_adapter : 
-        public ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrSet,CloneAllocator,Ordered>
-    {
-        typedef ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrSet,CloneAllocator,Ordered> 
-            base_type;
-    
-    public: // typedefs
-       
-        typedef BOOST_DEDUCED_TYPENAME base_type::iterator
-                     iterator;                 
-        typedef BOOST_DEDUCED_TYPENAME base_type::const_iterator
-                     const_iterator;                 
-        typedef BOOST_DEDUCED_TYPENAME base_type::size_type
-                     size_type;    
-        typedef Key  key_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::auto_type
-                     auto_type;
-        typedef BOOST_DEDUCED_TYPENAME VoidPtrSet::allocator_type
-                     allocator_type;        
-    private:
-        
-        template< typename II >                                               
-        void set_basic_clone_and_insert( II first, II last ) // basic                 
-        {                                                                     
-            while( first != last )                                            
-            {           
-                if( this->find( *first ) == this->end() )
-                    insert( CloneAllocator::allocate_clone( *first ) ); // strong, commit
-                ++first;                                                      
-            }                                                                 
-        }                         
-
-    public:
-        ptr_set_adapter()
-        { }
-
-        template< class SizeType >
-        ptr_set_adapter( SizeType n, 
-                         ptr_container_detail::unordered_associative_container_tag tag )
-          : base_type( n, tag )
-        { }
-        
-        template< class Comp >
-        explicit ptr_set_adapter( const Comp& comp,
-                                  const allocator_type& a ) 
-          : base_type( comp, a ) 
-        {
-            BOOST_ASSERT( this->empty() ); 
-        }
-
-        template< class Hash, class Pred, class Allocator >
-        ptr_set_adapter( const Hash& hash,
-                         const Pred& pred,
-                         const Allocator& a )
-         : base_type( hash, pred, a )
-        { }
-
-        template< class InputIterator >
-        ptr_set_adapter( InputIterator first, InputIterator last )
-         : base_type( first, last )
-        { }
-
-        template< class InputIterator, class Compare, class Allocator >
-        ptr_set_adapter( InputIterator first, InputIterator last, 
-                         const Compare& comp,
-                         const Allocator a = Allocator() )
-          : base_type( comp, a )
-        {
-            BOOST_ASSERT( this->empty() );
-            set_basic_clone_and_insert( first, last );
-        }
-
-        template< class InputIterator, class Hash, class Pred, class Allocator >
-        ptr_set_adapter( InputIterator first, InputIterator last,
-                         const Hash& hash,
-                         const Pred& pred,
-                         const Allocator& a )
-          : base_type( first, last, hash, pred, a )
-        { }
-
-        explicit ptr_set_adapter( const ptr_set_adapter& r )
-          : base_type( r )
-        { }
-
-        template< class U, class Set, class CA, bool b >
-        explicit ptr_set_adapter( const ptr_set_adapter<U,Set,CA,b>& r )
-          : base_type( r )
-        { }
-        
-        template< class PtrContainer >
-        explicit ptr_set_adapter( std::auto_ptr<PtrContainer> clone )
-         : base_type( clone )
-        { }
-
-        template< class U, class Set, class CA, bool b >
-        ptr_set_adapter& operator=( const ptr_set_adapter<U,Set,CA,b>& r ) 
-        {
-            base_type::operator=( r );
-            return *this;
-        }
-
-        template< class T >
-        void operator=( std::auto_ptr<T> r ) 
-        {
-            base_type::operator=( r );
-        }
-
-        std::pair<iterator,bool> insert( key_type* x ) // strong                      
-        {       
-            this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" );
-            
-            auto_type ptr( x );                                
-            std::pair<BOOST_DEDUCED_TYPENAME base_type::ptr_iterator,bool>
-                 res = this->base().insert( x );       
-            if( res.second )                                                 
-                ptr.release();                                                  
-            return std::make_pair( iterator( res.first ), res.second );     
-        }
-
-        template< class U >
-        std::pair<iterator,bool> insert( std::auto_ptr<U> x )
-        {
-            return insert( x.release() );
-        }
-
-        
-        iterator insert( iterator where, key_type* x ) // strong
-        {
-            this->enforce_null_policy( x, "Null pointer in 'ptr_set::insert()'" );
-
-            auto_type ptr( x );                                
-            BOOST_DEDUCED_TYPENAME base_type::ptr_iterator 
-                res = this->base().insert( where.base(), x );
-            if( *res == x )                                                 
-                ptr.release();                                                  
-            return iterator( res);
-        }
-
-        template< class U >
-        iterator insert( iterator where, std::auto_ptr<U> x )
-        {
-            return insert( where, x.release() );
-        }
-        
-        template< typename InputIterator >
-        void insert( InputIterator first, InputIterator last ) // basic
-        {
-            set_basic_clone_and_insert( first, last );
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else    
-        
-        template< class Range >
-        BOOST_DEDUCED_TYPENAME
-        boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type
-        insert( const Range& r )
-        {
-            insert( boost::begin(r), boost::end(r) );
-        }
-
-#endif        
-
-        template< class PtrSetAdapter >
-        bool transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator object, 
-                       PtrSetAdapter& from ) // strong
-        {
-            return this->single_transfer( object, from );
-        }
-
-        template< class PtrSetAdapter >
-        size_type 
-        transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator first, 
-                  BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator last, 
-                  PtrSetAdapter& from ) // basic
-        {
-            return this->single_transfer( first, last, from );
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else    
-
-        template< class PtrSetAdapter, class Range >
-        BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range,
-                            BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator >,
-                                                            size_type >::type
-        transfer( const Range& r, PtrSetAdapter& from ) // basic
-        {
-            return transfer( boost::begin(r), boost::end(r), from );
-        }
-
-#endif
-
-        template< class PtrSetAdapter >
-        size_type transfer( PtrSetAdapter& from ) // basic
-        {
-            return transfer( from.begin(), from.end(), from );
-        }
-
-    };
-    
-    /////////////////////////////////////////////////////////////////////////
-    // ptr_multiset_adapter
-    /////////////////////////////////////////////////////////////////////////
-
-    template
-    < 
-        class Key,
-        class VoidPtrMultiSet, 
-        class CloneAllocator = heap_clone_allocator,
-        bool Ordered         = true 
-    >
-    class ptr_multiset_adapter : 
-        public ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrMultiSet,CloneAllocator,Ordered>
-    {
-         typedef ptr_container_detail::ptr_set_adapter_base<Key,VoidPtrMultiSet,CloneAllocator,Ordered> base_type;
-    
-    public: // typedefs
-    
-        typedef BOOST_DEDUCED_TYPENAME base_type::iterator   
-                       iterator;          
-        typedef BOOST_DEDUCED_TYPENAME base_type::size_type
-                       size_type;
-        typedef Key    key_type;
-        typedef BOOST_DEDUCED_TYPENAME base_type::auto_type
-                       auto_type;
-        typedef BOOST_DEDUCED_TYPENAME VoidPtrMultiSet::allocator_type
-                       allocator_type;        
-    private:
-        template< typename II >                                               
-        void set_basic_clone_and_insert( II first, II last ) // basic                 
-        {               
-            while( first != last )                                            
-            {           
-                insert( CloneAllocator::allocate_clone( *first ) ); // strong, commit                              
-                ++first;                                                     
-            }                                                                 
-        }                         
-    
-    public:
-        ptr_multiset_adapter()
-        { }
-
-        template< class SizeType >
-        ptr_multiset_adapter( SizeType n, 
-                              ptr_container_detail::unordered_associative_container_tag tag )
-          : base_type( n, tag )
-        { }
-
-        template< class Comp >
-        explicit ptr_multiset_adapter( const Comp& comp,
-                                       const allocator_type& a )
-        : base_type( comp, a ) 
-        { }
-
-        template< class Hash, class Pred, class Allocator >
-        ptr_multiset_adapter( const Hash& hash,
-                              const Pred& pred,
-                              const Allocator& a )
-         : base_type( hash, pred, a )
-        { }
-
-        template< class InputIterator >
-        ptr_multiset_adapter( InputIterator first, InputIterator last )
-         : base_type( first, last )
-        { }
-        
-        template< class InputIterator, class Comp >
-        ptr_multiset_adapter( InputIterator first, InputIterator last,
-                              const Comp& comp,
-                              const allocator_type& a = allocator_type() )
-        : base_type( comp, a ) 
-        {
-            set_basic_clone_and_insert( first, last );
-        }
-
-        template< class InputIterator, class Hash, class Pred, class Allocator >
-        ptr_multiset_adapter( InputIterator first, InputIterator last,
-                              const Hash& hash,
-                              const Pred& pred,
-                              const Allocator& a )
-         : base_type( first, last, hash, pred, a )
-        { }
-                
-        template< class U, class Set, class CA, bool b >
-        explicit ptr_multiset_adapter( const ptr_multiset_adapter<U,Set,CA,b>& r )
-          : base_type( r )
-        { }
-        
-        template< class PtrContainer >
-        explicit ptr_multiset_adapter( std::auto_ptr<PtrContainer> clone )
-         : base_type( clone )
-        { }
-
-        template< class U, class Set, class CA, bool b >
-        ptr_multiset_adapter& operator=( const ptr_multiset_adapter<U,Set,CA,b>& r ) 
-        {
-            base_type::operator=( r );
-            return *this;
-        }
-        
-        template< class T >
-        void operator=( std::auto_ptr<T> r ) 
-        {
-            base_type::operator=( r ); 
-        }
-
-        iterator insert( iterator before, key_type* x ) // strong  
-        {
-            return base_type::insert( before, x ); 
-        } 
-
-        template< class U >
-        iterator insert( iterator before, std::auto_ptr<U> x )
-        {
-            return insert( before, x.release() );
-        }
-    
-        iterator insert( key_type* x ) // strong                                      
-        {   
-            this->enforce_null_policy( x, "Null pointer in 'ptr_multiset::insert()'" );
-    
-            auto_type ptr( x );                                
-            BOOST_DEDUCED_TYPENAME base_type::ptr_iterator
-                 res = this->base().insert( x );                         
-            ptr.release();                                                      
-            return iterator( res );                                             
-        }
-
-        template< class U >
-        iterator insert( std::auto_ptr<U> x )
-        {
-            return insert( x.release() );
-        }
-    
-        template< typename InputIterator >
-        void insert( InputIterator first, InputIterator last ) // basic
-        {
-            set_basic_clone_and_insert( first, last );
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else    
-        
-        template< class Range >
-        BOOST_DEDUCED_TYPENAME
-        boost::disable_if< ptr_container_detail::is_pointer_or_integral<Range> >::type
-        insert( const Range& r )
-        {
-            insert( boost::begin(r), boost::end(r) );
-        }
-
-#endif
-
-        template< class PtrSetAdapter >
-        void transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator object, 
-                       PtrSetAdapter& from ) // strong
-        {
-            this->multi_transfer( object, from );
-        }
-
-        template< class PtrSetAdapter >
-        size_type transfer( BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator first, 
-                            BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator last, 
-                            PtrSetAdapter& from ) // basic
-        {
-            return this->multi_transfer( first, last, from );
-        }
-
-#if defined(BOOST_NO_SFINAE) || defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
-#else    
-        
-        template< class PtrSetAdapter, class Range >
-        BOOST_DEDUCED_TYPENAME boost::disable_if< boost::is_same< Range,
-                       BOOST_DEDUCED_TYPENAME PtrSetAdapter::iterator >, size_type >::type
-        transfer(  const Range& r, PtrSetAdapter& from ) // basic
-        {
-            return transfer( boost::begin(r), boost::end(r), from );
-        }
-
-#endif        
-
-        template< class PtrSetAdapter >
-        void transfer( PtrSetAdapter& from ) // basic
-        {
-            transfer( from.begin(), from.end(), from );
-            BOOST_ASSERT( from.empty() );
-        }
-        
-    };
-
-} // namespace 'boost'  
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_unordered_map.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_unordered_map.hpp
deleted file mode 100644
index b881584a42d..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_unordered_map.hpp
+++ /dev/null
@@ -1,248 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2008. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_UNORDERED_MAP_HPP
-#define BOOST_PTR_CONTAINER_PTR_UNORDERED_MAP_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/unordered_map.hpp>
-#include <boost/ptr_container/ptr_map_adapter.hpp>
-
-namespace boost
-{
-    
-    template
-    < 
-        class Key, 
-        class T, 
-        class Hash           = boost::hash<Key>,
-        class Pred           = std::equal_to<Key>,
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator< std::pair<const Key,void*> >
-    >
-    class ptr_unordered_map : 
-        public ptr_map_adapter<T,boost::unordered_map<Key,void*,Hash,Pred,Allocator>,
-                               CloneAllocator,false>
-    {
-        typedef ptr_map_adapter<T,boost::unordered_map<Key,void*,Hash,Pred,Allocator>,
-                               CloneAllocator,false>
-            base_type;
-
-        typedef ptr_unordered_map<Key,T,Hash,Pred,CloneAllocator,Allocator> this_type;
-
-    public:
-        typedef typename base_type::size_type size_type;
-        
-    private:
-        using base_type::lower_bound;
-        using base_type::upper_bound;
-        using base_type::rbegin;
-        using base_type::rend;
-        using base_type::crbegin;
-        using base_type::crend;
-        using base_type::key_comp;
-        using base_type::value_comp;
-        using base_type::front;
-        using base_type::back;
-        
-    public:
-        using base_type::begin;
-        using base_type::end;
-        using base_type::cbegin;
-        using base_type::cend;
-        using base_type::bucket_count;
-        using base_type::max_bucket_count;
-        using base_type::bucket_size;
-        using base_type::bucket;
-        using base_type::load_factor;
-        using base_type::max_load_factor;
-        using base_type::rehash;
-        using base_type::key_eq;
-        using base_type::hash_function;
-        
-    public:
-        ptr_unordered_map()
-        { }
-
-        explicit ptr_unordered_map( size_type n )
-        : base_type( n, ptr_container_detail::unordered_associative_container_tag() )
-        { }
-        
-        ptr_unordered_map( size_type n,
-                           const Hash& comp,
-                           const Pred& pred   = Pred(),                                         
-                           const Allocator& a = Allocator() )
-         : base_type( n, comp, pred, a ) 
-        { }
-
-        template< typename InputIterator >
-        ptr_unordered_map( InputIterator first, InputIterator last )
-         : base_type( first, last )
-        { }
-        
-        template< typename InputIterator >
-        ptr_unordered_map( InputIterator first, InputIterator last,
-                           const Hash& comp,
-                           const Pred& pred   = Pred(),
-                           const Allocator& a = Allocator() )
-         : base_type( first, last, comp, pred, a ) 
-        { }
-
-        BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_unordered_map, 
-                                                      base_type, 
-                                                      this_type )
-
-        template< class U >
-        ptr_unordered_map( const ptr_unordered_map<Key,U>& r ) : base_type( r )
-        { }
-
-        ptr_unordered_map& operator=( ptr_unordered_map r )
-        {
-            this->swap( r );
-            return *this;
-        }
-    };
-    
-
-
-    template
-    < 
-        class Key, 
-        class T, 
-        class Hash           = boost::hash<Key>,
-        class Pred           = std::equal_to<Key>,
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator< std::pair<const Key,void*> >
-    >
-    class ptr_unordered_multimap : 
-        public ptr_multimap_adapter<T,boost::unordered_multimap<Key,void*,Hash,Pred,Allocator>,
-                                    CloneAllocator,false>
-    {
-        typedef ptr_multimap_adapter<T,boost::unordered_multimap<Key,void*,Hash,Pred,Allocator>,
-                                     CloneAllocator,false>
-            base_type;
-
-        typedef ptr_unordered_multimap<Key,T,Hash,Pred,CloneAllocator,Allocator> this_type;
-
-    public:
-        typedef typename base_type::size_type size_type;
-        
-    private:
-        using base_type::lower_bound;
-        using base_type::upper_bound;
-        using base_type::rbegin;
-        using base_type::rend;
-        using base_type::crbegin;
-        using base_type::crend;
-        using base_type::key_comp;
-        using base_type::value_comp;
-        using base_type::front;
-        using base_type::back;
-        
-    public:
-        using base_type::begin;
-        using base_type::end;
-        using base_type::cbegin;
-        using base_type::cend;
-        using base_type::bucket_count;
-        using base_type::max_bucket_count;
-        using base_type::bucket_size;
-        using base_type::bucket;
-        using base_type::load_factor;
-        using base_type::max_load_factor;
-        using base_type::rehash;
-        using base_type::key_eq;
-        using base_type::hash_function;
-        
-    public:
-        ptr_unordered_multimap()
-        { }
-
-        explicit ptr_unordered_multimap( size_type n )
-        : base_type( n, ptr_container_detail::unordered_associative_container_tag() )
-        { }
-        
-        ptr_unordered_multimap( size_type n,
-                                const Hash& comp,
-                                const Pred& pred   = Pred(),                                         
-                                const Allocator& a = Allocator() )
-         : base_type( n, comp, pred, a ) 
-        { }
-
-        template< typename InputIterator >
-        ptr_unordered_multimap( InputIterator first, InputIterator last )
-         : base_type( first, last )
-        { }
-        
-        template< typename InputIterator >
-        ptr_unordered_multimap( InputIterator first, InputIterator last,
-                                const Hash& comp,
-                                const Pred& pred   = Pred(),
-                                const Allocator& a = Allocator() )
-         : base_type( first, last, comp, pred, a ) 
-        { }
-
-        BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_unordered_multimap, 
-                                                      base_type, 
-                                                      this_type )
-
-        template< class U >
-        ptr_unordered_multimap( const ptr_unordered_multimap<Key,U>& r ) : base_type( r )
-        { }
-
-        ptr_unordered_multimap& operator=( ptr_unordered_multimap r )
-        {
-            this->swap( r );
-            return *this;
-        }
-    };
-    
-    //////////////////////////////////////////////////////////////////////////////
-    // clonability
-
-    template< class K, class T, class H, class P, class CA, class A >
-    inline ptr_unordered_map<K,T,H,P,CA,A>* 
-    new_clone( const ptr_unordered_map<K,T,H,P,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-
-    template< class K, class T, class H, class P, class CA, class A >
-    inline ptr_unordered_multimap<K,T,H,P,CA,A>* 
-    new_clone( const ptr_unordered_multimap<K,T,H,P,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-
-    /////////////////////////////////////////////////////////////////////////
-    // swap
-
-    template< class K, class T, class H, class P, class CA, class A >
-    inline void swap( ptr_unordered_map<K,T,H,P,CA,A>& l, 
-                      ptr_unordered_map<K,T,H,P,CA,A>& r )
-    {
-        l.swap(r);
-    }
-
-    template< class K, class T, class H, class P, class CA, class A >
-    inline void swap( ptr_unordered_multimap<K,T,H,P,CA,A>& l, 
-                      ptr_unordered_multimap<K,T,H,P,CA,A>& r )
-    {
-        l.swap(r);
-    }
-
-
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_unordered_set.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_unordered_set.hpp
deleted file mode 100644
index 49ec464ebb2..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_unordered_set.hpp
+++ /dev/null
@@ -1,240 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2008. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_UNORDERED_SET_HPP
-#define BOOST_PTR_CONTAINER_PTR_UNORDERED_SET_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <boost/ptr_container/indirect_fun.hpp>
-#include <boost/ptr_container/ptr_set_adapter.hpp>
-#include <boost/unordered_set.hpp>
-
-namespace boost
-{
-
-    template
-    < 
-        class Key, 
-        class Hash           = boost::hash<Key>,
-        class Pred           = std::equal_to<Key>,
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator<void*>
-    >
-    class ptr_unordered_set : 
-        public ptr_set_adapter< Key, 
-                                boost::unordered_set<void*,void_ptr_indirect_fun<Hash,Key>,
-                                                     void_ptr_indirect_fun<Pred,Key>,Allocator>,
-                                CloneAllocator, false >
-    {
-        typedef ptr_set_adapter< Key, 
-                                 boost::unordered_set<void*,void_ptr_indirect_fun<Hash,Key>,
-                                 void_ptr_indirect_fun<Pred,Key>,Allocator>,
-                                 CloneAllocator, false >
-             base_type;
-
-        typedef ptr_unordered_set<Key,Hash,Pred,CloneAllocator,Allocator> this_type;
-
-    public:
-        typedef typename base_type::size_type size_type;
-
-    private:
-        using base_type::lower_bound;
-        using base_type::upper_bound;
-        using base_type::rbegin;
-        using base_type::rend;
-        using base_type::crbegin;
-        using base_type::crend;
-        using base_type::key_comp;
-        using base_type::value_comp;
-        using base_type::front;
-        using base_type::back;
-        
-    public:
-        using base_type::begin;
-        using base_type::end;
-        using base_type::cbegin;
-        using base_type::cend;
-        using base_type::bucket_count;
-        using base_type::max_bucket_count;
-        using base_type::bucket_size;
-        using base_type::bucket;
-        using base_type::load_factor;
-        using base_type::max_load_factor;
-        using base_type::rehash;
-        using base_type::key_eq;
-        using base_type::hash_function;
-        
-    public:
-        ptr_unordered_set()
-        {}
-
-        explicit ptr_unordered_set( size_type n )
-        : base_type( n, ptr_container_detail::unordered_associative_container_tag() )
-        { }
-        
-        ptr_unordered_set( size_type n,
-                           const Hash& comp,
-                           const Pred& pred   = Pred(),                                         
-                           const Allocator& a = Allocator() )
-         : base_type( n, comp, pred, a ) 
-        { }
-
-        template< typename InputIterator >
-        ptr_unordered_set( InputIterator first, InputIterator last )
-         : base_type( first, last )
-        { }
-
-        template< typename InputIterator >
-        ptr_unordered_set( InputIterator first, InputIterator last,
-                           const Hash& comp,
-                           const Pred& pred   = Pred(),
-                           const Allocator& a = Allocator() )
-         : base_type( first, last, comp, pred, a ) 
-        { }
-
-        BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_unordered_set,
-                                                      base_type,
-                                                      this_type )
-        
-        BOOST_PTR_CONTAINER_DEFINE_COPY_CONSTRUCTORS( ptr_unordered_set, 
-                                                      base_type )
-                
-    };
-        
-        
-    template
-    < 
-        class Key, 
-        class Hash           = boost::hash<Key>,
-        class Pred           = std::equal_to<Key>,
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator<void*>
-    >
-    class ptr_unordered_multiset : 
-          public ptr_multiset_adapter< Key, 
-                                boost::unordered_multiset<void*,void_ptr_indirect_fun<Hash,Key>,
-                                                                void_ptr_indirect_fun<Pred,Key>,Allocator>,
-                                            CloneAllocator, false >
-    {
-      typedef ptr_multiset_adapter< Key, 
-              boost::unordered_multiset<void*,void_ptr_indirect_fun<Hash,Key>,
-                                        void_ptr_indirect_fun<Pred,Key>,Allocator>,
-                                        CloneAllocator, false >
-              base_type;
-        typedef ptr_unordered_multiset<Key,Hash,Pred,CloneAllocator,Allocator> this_type;
-
-    public:
-        typedef typename base_type::size_type size_type;
-
-    private:
-        using base_type::lower_bound;
-        using base_type::upper_bound;
-        using base_type::rbegin;
-        using base_type::rend;
-        using base_type::crbegin;
-        using base_type::crend;
-        using base_type::key_comp;
-        using base_type::value_comp;
-        using base_type::front;
-        using base_type::back;
-        
-    public:
-        using base_type::begin;
-        using base_type::end;
-        using base_type::cbegin;
-        using base_type::cend;
-        using base_type::bucket_count;
-        using base_type::max_bucket_count;
-        using base_type::bucket_size;
-        using base_type::bucket;
-        using base_type::load_factor;
-        using base_type::max_load_factor;
-        using base_type::rehash;
-        using base_type::key_eq;
-        using base_type::hash_function;
-        
-    public:
-        ptr_unordered_multiset()
-        { }
-        
-        explicit ptr_unordered_multiset( size_type n )
-         : base_type( n, ptr_container_detail::unordered_associative_container_tag() ) 
-        { }
-
-        ptr_unordered_multiset( size_type n,
-                                const Hash& comp,
-                                const Pred& pred   = Pred(),                                         
-                                const Allocator& a = Allocator() )
-         : base_type( n, comp, pred, a ) 
-        { }
-
-        template< typename InputIterator >
-        ptr_unordered_multiset( InputIterator first, InputIterator last )
-         : base_type( first, last )
-        { }
-
-        template< typename InputIterator >
-        ptr_unordered_multiset( InputIterator first, InputIterator last,
-                                const Hash& comp,
-                                const Pred& pred   = Pred(),
-                                const Allocator& a = Allocator() )
-         : base_type( first, last, comp, pred, a ) 
-        { }
-
-        BOOST_PTR_CONTAINER_DEFINE_RELEASE_AND_CLONE( ptr_unordered_multiset, 
-                                                      base_type,
-                                                      this_type )
-         
-        BOOST_PTR_CONTAINER_DEFINE_COPY_CONSTRUCTORS( ptr_unordered_multiset, 
-                                                      base_type )     
-
-    };
-
-    /////////////////////////////////////////////////////////////////////////
-    // clonability
-
-    template< typename K, typename H, typename P, typename CA, typename A >
-    inline ptr_unordered_set<K,H,P,CA,A>* 
-    new_clone( const ptr_unordered_set<K,H,P,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-
-    template< typename K, typename H, typename P, typename CA, typename A >
-    inline ptr_unordered_multiset<K,H,P,CA,A>* 
-    new_clone( const ptr_unordered_multiset<K,H,P,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-    
-    /////////////////////////////////////////////////////////////////////////
-    // swap
-
-    template< typename K, typename H, typename P, typename CA, typename A >
-    inline void swap( ptr_unordered_set<K,H,P,CA,A>& l, 
-                      ptr_unordered_set<K,H,P,CA,A>& r )
-    {
-        l.swap(r);
-    }
-
-    template< typename K, typename H, typename P, typename CA, typename A >
-    inline void swap( ptr_unordered_multiset<K,H,P,CA,A>& l, 
-                      ptr_unordered_multiset<K,H,P,CA,A>& r )
-    {
-        l.swap(r);
-    }
-
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_vector.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_vector.hpp
deleted file mode 100644
index ee42095bce3..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/ptr_vector.hpp
+++ /dev/null
@@ -1,77 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2003-2005. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_PTR_VECTOR_HPP
-#define BOOST_PTR_CONTAINER_PTR_VECTOR_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <vector>
-#include <boost/ptr_container/ptr_sequence_adapter.hpp>
-
-namespace boost
-{
-
-    template
-    < 
-        class T, 
-        class CloneAllocator = heap_clone_allocator,
-        class Allocator      = std::allocator<void*>
-    >
-    class ptr_vector : public 
-        ptr_sequence_adapter< T, 
-                              std::vector<void*,Allocator>, 
-                              CloneAllocator >
-    {  
-        typedef ptr_sequence_adapter< T, 
-                                      std::vector<void*,Allocator>, 
-                                      CloneAllocator > 
-            base_class;
-
-        typedef ptr_vector<T,CloneAllocator,Allocator> this_type;
-        
-    public:
-
-        BOOST_PTR_CONTAINER_DEFINE_SEQEUENCE_MEMBERS( ptr_vector, 
-                                                      base_class,
-                                                      this_type )
-        
-        explicit ptr_vector( size_type n,
-                             const allocator_type& alloc = allocator_type() )
-          : base_class(alloc)
-        {
-            this->base().reserve( n );
-        }        
-    };
-
-    //////////////////////////////////////////////////////////////////////////////
-    // clonability
-
-    template< typename T, typename CA, typename A >
-    inline ptr_vector<T,CA,A>* new_clone( const ptr_vector<T,CA,A>& r )
-    {
-        return r.clone().release();
-    }
-
-    /////////////////////////////////////////////////////////////////////////
-    // swap
-
-    template< typename T, typename CA, typename A >
-    inline void swap( ptr_vector<T,CA,A>& l, ptr_vector<T,CA,A>& r )
-    {
-        l.swap(r);
-    }
-    
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_array.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_array.hpp
deleted file mode 100644
index a602016adf4..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_array.hpp
+++ /dev/null
@@ -1,47 +0,0 @@
-// Copyright Sebastian Ramacher, 2007.
-// 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_PTR_CONTAINER_SERIALIZE_PTR_ARRAY_HPP
-#define BOOST_PTR_CONTAINER_SERIALIZE_PTR_ARRAY_HPP
-
-#include <boost/ptr_container/detail/serialize_reversible_cont.hpp>
-#include <boost/ptr_container/ptr_array.hpp>
-
-namespace boost 
-{
-
-namespace serialization 
-{
-
-template<class Archive, class T, std::size_t N, class CloneAllocator>
-void save(Archive& ar, const ptr_array<T, N, CloneAllocator>& c, unsigned int /*version*/)
-{
-    ptr_container_detail::save_helper(ar, c);
-}
-
-template<class Archive, class T, std::size_t N, class CloneAllocator>
-void load(Archive& ar, ptr_array<T, N, CloneAllocator>& c, unsigned int /*version*/)
-{
-    typedef ptr_array<T, N, CloneAllocator> container_type;
-    typedef BOOST_DEDUCED_TYPENAME container_type::size_type size_type;
-    
-    for(size_type i = 0u; i != N; ++i)
-    {
-        T* p;
-        ar >> boost::serialization::make_nvp( ptr_container_detail::item(), p );
-        c.replace(i, p);
-    }
-}
-
-template<class Archive, class T, std::size_t N, class CloneAllocator>
-void serialize(Archive& ar, ptr_array<T, N, CloneAllocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_circular_buffer.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_circular_buffer.hpp
deleted file mode 100644
index 019a8b5a1fa..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_circular_buffer.hpp
+++ /dev/null
@@ -1,46 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2008. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_SERIALIZE_PTR_CIRCULAR_BUFFER_HPP
-#define BOOST_PTR_CONTAINER_SERIALIZE_PTR_CIRCULAR_BUFFER_HPP
-
-#include <boost/ptr_container/detail/serialize_reversible_cont.hpp>
-#include <boost/ptr_container/ptr_circular_buffer.hpp>
-
-namespace boost 
-{
-
-namespace serialization 
-{
-
-template<class Archive, class T, class CloneAllocator, class Allocator>
-void load(Archive& ar, ptr_circular_buffer<T, CloneAllocator, Allocator>& c, unsigned int version)
-{
-    typedef ptr_circular_buffer<T, CloneAllocator, Allocator> container_type;
-    typedef BOOST_DEDUCED_TYPENAME container_type::size_type size_type;
-    
-    size_type n;
-    ar >> boost::serialization::make_nvp( ptr_container_detail::count(), n );
-    c.reserve(n);
-    
-    ptr_container_detail::load_helper(ar, c, n);
-}
-
-template<class Archive, class T, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_circular_buffer<T, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_container.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_container.hpp
deleted file mode 100644
index 22ab592cc2c..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_container.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright Sebastian Ramacher, 2007.
-// 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_PTR_CONTAINER_SERIALIZE_HPP
-#define BOOST_PTR_CONTAINER_SERIALIZE_HPP
-
-#include <boost/ptr_container/serialize_ptr_array.hpp>
-#include <boost/ptr_container/serialize_ptr_deque.hpp>
-#include <boost/ptr_container/serialize_ptr_list.hpp>
-#include <boost/ptr_container/serialize_ptr_map.hpp>
-#include <boost/ptr_container/serialize_ptr_set.hpp>
-#include <boost/ptr_container/serialize_ptr_vector.hpp>
-#include <boost/ptr_container/serialize_ptr_unordered_set.hpp>
-#include <boost/ptr_container/serialize_ptr_unordered_map.hpp>
-#include <boost/ptr_container/serialize_ptr_circular_buffer.hpp>
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_deque.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_deque.hpp
deleted file mode 100644
index fe1b5c46d4b..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_deque.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright Sebastian Ramacher, 2007.
-// 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_PTR_CONTAINER_SERIALIZE_PTR_DEQUE_HPP
-#define BOOST_PTR_CONTAINER_SERIALIZE_PTR_DEQUE_HPP
-
-#include <boost/ptr_container/detail/serialize_reversible_cont.hpp>
-#include <boost/ptr_container/ptr_deque.hpp>
-
-namespace boost 
-{
-
-namespace serialization 
-{
-
-template<class Archive, class T, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_deque<T, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_list.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_list.hpp
deleted file mode 100644
index e25f26445d2..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_list.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright Sebastian Ramacher, 2007.
-// 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_PTR_CONTAINER_SERIALIZE_PTR_LIST_HPP
-#define BOOST_PTR_CONTAINER_SERIALIZE_PTR_LIST_HPP
-
-#include <boost/ptr_container/detail/serialize_reversible_cont.hpp>
-#include <boost/ptr_container/ptr_list.hpp>
-
-namespace boost 
-{
-
-namespace serialization 
-{
-
-template<class Archive, class T, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_list<T, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_map.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_map.hpp
deleted file mode 100644
index ee7439d1072..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_map.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright Sebastian Ramacher, 2007.
-// 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_PTR_CONTAINER_SERIALIZE_PTR_MAP_HPP
-#define BOOST_PTR_CONTAINER_SERIALIZE_PTR_MAP_HPP
-
-#include <boost/ptr_container/detail/serialize_ptr_map_adapter.hpp>
-#include <boost/ptr_container/ptr_map.hpp>
-
-namespace boost 
-{
-
-namespace serialization 
-{
-
-template<class Archive, class Key, class T, class Compare, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_map<Key, T, Compare, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-template<class Archive, class Key, class T, class Compare, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_multimap<Key, T, Compare, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_set.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_set.hpp
deleted file mode 100644
index 6c9dfd5b06f..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_set.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright Sebastian Ramacher, 2007.
-// 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_PTR_CONTAINER_SERIALIZE_PTR_SET_HPP
-#define BOOST_PTR_CONTAINER_SERIALIZE_PTR_SET_HPP
-
-#include <boost/ptr_container/detail/serialize_reversible_cont.hpp>
-#include <boost/ptr_container/ptr_set.hpp>
-
-namespace boost 
-{
-
-namespace serialization 
-{
-
-template<class Archive, class T, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_set<T, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-template<class Archive, class T, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_multiset<T, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_unordered_map.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_unordered_map.hpp
deleted file mode 100644
index 1dcf842596f..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_unordered_map.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2008. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_SERIALIZE_UNORDERED_PTR_MAP_HPP
-#define BOOST_PTR_CONTAINER_SERIALIZE_UNORDERED_PTR_MAP_HPP
-
-#include <boost/ptr_container/detail/serialize_ptr_map_adapter.hpp>
-#include <boost/ptr_container/ptr_unordered_map.hpp>
-
-namespace boost 
-{
-
-namespace serialization 
-{
-
-template<class Archive, class Key, class T, class Hash, class Pred, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_unordered_map<Key, T, Hash, Pred, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-template<class Archive, class Key, class T, class Hash, class Pred, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_unordered_multimap<Key, T, Hash, Pred, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_unordered_set.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_unordered_set.hpp
deleted file mode 100644
index ac0f5f6d79d..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_unordered_set.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//
-// Boost.Pointer Container
-//
-//  Copyright Thorsten Ottosen 2008. 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/ptr_container/
-//
-
-#ifndef BOOST_PTR_CONTAINER_SERIALIZE_PTR_UNORDERED_SET_HPP
-#define BOOST_PTR_CONTAINER_SERIALIZE_PTR_UNORDERED_SET_HPP
-
-#include <boost/ptr_container/detail/serialize_reversible_cont.hpp>
-#include <boost/ptr_container/ptr_unordered_set.hpp>
-
-namespace boost 
-{
-
-namespace serialization 
-{
-
-template<class Archive, class T, class Hash, class Pred, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_unordered_set<T, Hash, Pred, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-template<class Archive, class T, class Hash, class Pred, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_unordered_multiset<T, Hash, Pred, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_vector.hpp b/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_vector.hpp
deleted file mode 100644
index a25066a8e87..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/ptr_container/serialize_ptr_vector.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright Sebastian Ramacher, 2007.
-// 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_PTR_CONTAINER_SERIALIZE_PTR_VECTOR_HPP
-#define BOOST_PTR_CONTAINER_SERIALIZE_PTR_VECTOR_HPP
-
-#include <boost/ptr_container/detail/serialize_reversible_cont.hpp>
-#include <boost/ptr_container/ptr_vector.hpp>
-
-namespace boost 
-{
-
-namespace serialization 
-{
-
-template<class Archive, class T, class CloneAllocator, class Allocator>
-void load(Archive& ar, ptr_vector<T, CloneAllocator, Allocator>& c, unsigned int /*version*/)
-{
-    typedef ptr_vector<T, CloneAllocator, Allocator> container_type;
-    typedef BOOST_DEDUCED_TYPENAME container_type::size_type size_type;
-    
-    size_type n;
-    ar >> boost::serialization::make_nvp( ptr_container_detail::count(), n );
-    c.reserve(n);
-    
-    ptr_container_detail::load_helper(ar, c, n);
-}
-
-template<class Archive, class T, class CloneAllocator, class Allocator>
-void serialize(Archive& ar, ptr_vector<T, CloneAllocator, Allocator>& c, const unsigned int version)
-{
-   split_free(ar, c, version);
-}
-
-} // namespace serialization
-} // namespace boost
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/random/exponential_distribution.hpp b/contrib/libboost/boost_1_62_0/boost/random/exponential_distribution.hpp
deleted file mode 100644
index 53eaa93865a..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/random/exponential_distribution.hpp
+++ /dev/null
@@ -1,182 +0,0 @@
-/* boost random/exponential_distribution.hpp header file
- *
- * Copyright Jens Maurer 2000-2001
- * 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$
- *
- * Revision history
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_EXPONENTIAL_DISTRIBUTION_HPP
-#define BOOST_RANDOM_EXPONENTIAL_DISTRIBUTION_HPP
-
-#include <boost/config/no_tr1/cmath.hpp>
-#include <iosfwd>
-#include <boost/assert.hpp>
-#include <boost/limits.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/uniform_01.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * The exponential distribution is a model of \random_distribution with
- * a single parameter lambda.
- *
- * It has \f$\displaystyle p(x) = \lambda e^{-\lambda x}\f$
- */
-template<class RealType = double>
-class exponential_distribution
-{
-public:
-    typedef RealType input_type;
-    typedef RealType result_type;
-
-    class param_type
-    {
-    public:
-
-        typedef exponential_distribution distribution_type;
-
-        /**
-         * Constructs parameters with a given lambda.
-         *
-         * Requires: lambda > 0
-         */
-        param_type(RealType lambda_arg = RealType(1.0))
-          : _lambda(lambda_arg) { BOOST_ASSERT(_lambda > RealType(0)); }
-
-        /** Returns the lambda parameter of the distribution. */
-        RealType lambda() const { return _lambda; }
-
-        /** Writes the parameters to a @c std::ostream. */
-        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
-        {
-            os << parm._lambda;
-            return os;
-        }
-        
-        /** Reads the parameters from a @c std::istream. */
-        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
-        {
-            is >> parm._lambda;
-            return is;
-        }
-
-        /** Returns true if the two sets of parameters are equal. */
-        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        { return lhs._lambda == rhs._lambda; }
-
-        /** Returns true if the two sets of parameters are different. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-
-    private:
-        RealType _lambda;
-    };
-
-    /**
-     * Constructs an exponential_distribution with a given lambda.
-     *
-     * Requires: lambda > 0
-     */
-    explicit exponential_distribution(RealType lambda_arg = RealType(1.0))
-      : _lambda(lambda_arg) { BOOST_ASSERT(_lambda > RealType(0)); }
-
-    /**
-     * Constructs an exponential_distribution from its parameters
-     */
-    explicit exponential_distribution(const param_type& parm)
-      : _lambda(parm.lambda()) {}
-
-    // compiler-generated copy ctor and assignment operator are fine
-
-    /** Returns the lambda parameter of the distribution. */
-    RealType lambda() const { return _lambda; }
-
-    /** Returns the smallest value that the distribution can produce. */
-    RealType min BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    { return RealType(0); }
-    /** 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(_lambda); }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm) { _lambda = parm.lambda(); }
-
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { }
-
-    /**
-     * Returns a random variate distributed according to the
-     * exponential distribution.
-     */
-    template<class Engine>
-    result_type operator()(Engine& eng) const
-    { 
-        using std::log;
-        return -result_type(1) /
-            _lambda * log(result_type(1)-uniform_01<RealType>()(eng));
-    }
-
-    /**
-     * Returns a random variate distributed according to the exponential
-     * distribution with parameters specified by param.
-     */
-    template<class Engine>
-    result_type operator()(Engine& eng, const param_type& parm) const
-    { 
-        return exponential_distribution(parm)(eng);
-    }
-
-    /** Writes the distribution to a std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, exponential_distribution, ed)
-    {
-        os << ed._lambda;
-        return os;
-    }
-
-    /** Reads the distribution from a std::istream. */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, exponential_distribution, ed)
-    {
-        is >> ed._lambda;
-        return is;
-    }
-
-    /**
-     * Returns true iff the two distributions will produce identical
-     * sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(exponential_distribution, lhs, rhs)
-    { return lhs._lambda == rhs._lambda; }
-    
-    /**
-     * Returns true iff the two distributions will produce different
-     * sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(exponential_distribution)
-
-private:
-    result_type _lambda;
-};
-
-} // namespace random
-
-using random::exponential_distribution;
-
-} // namespace boost
-
-#endif // BOOST_RANDOM_EXPONENTIAL_DISTRIBUTION_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/allocate_shared_array.hpp b/contrib/libboost/boost_1_62_0/boost/smart_ptr/allocate_shared_array.hpp
deleted file mode 100644
index 1ae5cc78327..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/allocate_shared_array.hpp
+++ /dev/null
@@ -1,181 +0,0 @@
-/*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License,
- * Version 1.0. (See accompanying file LICENSE_1_0.txt
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#ifndef BOOST_SMART_PTR_ALLOCATE_SHARED_ARRAY_HPP
-#define BOOST_SMART_PTR_ALLOCATE_SHARED_ARRAY_HPP
-
-#include <boost/smart_ptr/detail/array_count_impl.hpp>
-#include <boost/smart_ptr/detail/sp_if_array.hpp>
-
-namespace boost {
-    template<class T, class A>
-    inline typename boost::detail::sp_if_array<T>::type
-    allocate_shared(const A& allocator, std::size_t size) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        typedef boost::detail::ms_init_tag R1;
-        typedef boost::detail::as_allocator<A, T, R1> A1;
-        typedef boost::detail::ms_in_allocator_tag D1;
-        std::size_t n1 = size * boost::detail::array_total<T1>::size;
-        T1* p1 = 0;
-        T2* p2 = 0;
-        D1 d1;
-        A1 a1(allocator, size, &p2);
-        shared_ptr<T> s1(p1, d1, a1);
-        A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
-        a2->set(0);
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-        boost::detail::as_init(allocator, p2, n1);
-#else
-        boost::detail::ms_init(p2, n1);
-#endif
-        a2->set(p2);
-        p1 = reinterpret_cast<T1*>(p2);
-        return shared_ptr<T>(s1, p1);
-    }
-
-    template<class T, class A>
-    inline typename boost::detail::sp_if_size_array<T>::type
-    allocate_shared(const A& allocator) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        typedef boost::detail::ms_init_tag R1;
-        typedef boost::detail::as_allocator<A, T, R1> A1;
-        typedef boost::detail::ms_in_allocator_tag D1;
-        enum {
-            N = boost::detail::array_total<T>::size
-        };
-        T1* p1 = 0;
-        T2* p2 = 0;
-        D1 d1;
-        A1 a1(allocator, &p2);
-        shared_ptr<T> s1(p1, d1, a1);
-        A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
-        a2->set(0);
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-        boost::detail::as_init(allocator, p2, N);
-#else
-        boost::detail::ms_init(p2, N);
-#endif
-        a2->set(p2);
-        p1 = reinterpret_cast<T1*>(p2);
-        return shared_ptr<T>(s1, p1);
-    }
-
-    template<class T, class A>
-    inline typename boost::detail::sp_if_array<T>::type
-    allocate_shared(const A& allocator, std::size_t size,
-        const typename boost::detail::array_inner<T>::type& value) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        typedef const T2 T3;
-        typedef boost::detail::ms_init_tag R1;
-        typedef boost::detail::as_allocator<A, T, R1> A1;
-        typedef boost::detail::ms_in_allocator_tag D1;
-        enum {
-            M = boost::detail::array_total<T1>::size
-        };
-        std::size_t n1 = M * size;
-        T1* p1 = 0;
-        T2* p2 = 0;
-        T3* p3 = reinterpret_cast<T3*>(&value);
-        D1 d1;
-        A1 a1(allocator, size, &p2);
-        shared_ptr<T> s1(p1, d1, a1);
-        A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
-        a2->set(0);
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-        boost::detail::as_init<T2, A, M>(allocator, p2, n1, p3);
-#else
-        boost::detail::ms_init<T2, M>(p2, n1, p3);
-#endif
-        a2->set(p2);
-        p1 = reinterpret_cast<T1*>(p2);
-        return shared_ptr<T>(s1, p1);
-    }
-
-    template<class T, class A>
-    inline typename boost::detail::sp_if_size_array<T>::type
-    allocate_shared(const A& allocator, 
-        const typename boost::detail::array_inner<T>::type& value) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        typedef const T2 T3;
-        typedef boost::detail::ms_init_tag R1;
-        typedef boost::detail::as_allocator<A, T, R1> A1;
-        typedef boost::detail::ms_in_allocator_tag D1;
-        enum {
-            N = boost::detail::array_total<T>::size,
-            M = boost::detail::array_total<T1>::size
-        };
-        T1* p1 = 0;
-        T2* p2 = 0;
-        T3* p3 = reinterpret_cast<T3*>(&value);
-        D1 d1;
-        A1 a1(allocator, &p2);
-        shared_ptr<T> s1(p1, d1, a1);
-        A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
-        a2->set(0);
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-        boost::detail::as_init<T2, A, M>(allocator, p2, N, p3);
-#else
-        boost::detail::ms_init<T2,  M>(p2, N, p3);
-#endif
-        a2->set(p2);
-        p1 = reinterpret_cast<T1*>(p2);
-        return shared_ptr<T>(s1, p1);
-    }
-
-    template<class T, class A>
-    inline typename boost::detail::sp_if_array<T>::type
-    allocate_shared_noinit(const A& allocator, std::size_t size) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        typedef boost::detail::ms_noinit_tag R1;
-        typedef boost::detail::as_allocator<A, T, R1> A1;
-        typedef boost::detail::ms_in_allocator_tag D1;
-        std::size_t n1 = size * boost::detail::array_total<T1>::size;
-        T1* p1 = 0;
-        T2* p2 = 0;
-        D1 d1;
-        A1 a1(allocator, size, &p2);
-        shared_ptr<T> s1(p1, d1, a1);
-        A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
-        a2->set(0);
-        boost::detail::ms_noinit(p2, n1);
-        a2->set(p2);
-        p1 = reinterpret_cast<T1*>(p2);
-        return shared_ptr<T>(s1, p1);
-    }
-
-    template<class T, class A>
-    inline typename boost::detail::sp_if_size_array<T>::type
-    allocate_shared_noinit(const A& allocator) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        typedef boost::detail::ms_noinit_tag R1;
-        typedef boost::detail::as_allocator<A, T, R1> A1;
-        typedef boost::detail::ms_in_allocator_tag D1;
-        enum {
-            N = boost::detail::array_total<T>::size
-        };
-        T1* p1 = 0;
-        T2* p2 = 0;
-        D1 d1;
-        A1 a1(allocator, &p2);
-        shared_ptr<T> s1(p1, d1, a1);
-        A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
-        a2->set(0);
-        boost::detail::ms_noinit(p2, N);
-        a2->set(p2);
-        p1 = reinterpret_cast<T1*>(p2);
-        return shared_ptr<T>(s1, p1);
-    }
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/array_allocator.hpp b/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/array_allocator.hpp
deleted file mode 100644
index 71479967bc1..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/array_allocator.hpp
+++ /dev/null
@@ -1,318 +0,0 @@
-/*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_ALLOCATOR_HPP
-#define BOOST_SMART_PTR_DETAIL_ARRAY_ALLOCATOR_HPP
-
-#include <boost/align/align.hpp>
-#include <boost/smart_ptr/detail/array_traits.hpp>
-#include <boost/smart_ptr/detail/array_utility.hpp>
-#include <boost/type_traits/alignment_of.hpp>
-
-namespace boost {
-    namespace detail {
-        struct ms_init_tag   { };
-        struct ms_noinit_tag { };
-
-        template<class T>
-        struct ms_allocator_state;
-
-        template<class T>
-        struct ms_allocator_state<T[]> {
-            typedef typename array_base<T>::type type;
-
-            ms_allocator_state(std::size_t size_,
-                type** result_)
-                : size(size_ * array_total<T>::size),
-                  result(result_) {
-            }
-
-            std::size_t size;
-
-            union {
-                type** result;
-                type* object;
-            };
-        };
-
-        template<class T, std::size_t N>
-        struct ms_allocator_state<T[N]> {
-            typedef typename array_base<T>::type type;
-
-            ms_allocator_state(type** result_)
-                : result(result_) {
-            }
-
-            enum {
-                size = array_total<T[N]>::size
-            };
-
-            union {
-                type** result;
-                type* object;
-            };
-        };
-
-        template<class A, class T, class R>
-        class as_allocator
-            : public A {
-            template<class A_, class T_, class R_>
-            friend class as_allocator;
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-            typedef std::allocator_traits<A> AT;
-            typedef typename AT::template rebind_alloc<char> CA;
-            typedef typename AT::template rebind_traits<char> CT;
-#else
-            typedef typename A::template rebind<char>::other CA;
-#endif
-
-        public:
-            typedef A allocator_type;
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-            typedef typename AT::value_type value_type;
-            typedef typename AT::pointer pointer;
-            typedef typename AT::const_pointer const_pointer;
-            typedef typename AT::void_pointer void_pointer;
-            typedef typename AT::const_void_pointer const_void_pointer;
-            typedef typename AT::size_type size_type;
-            typedef typename AT::difference_type difference_type;
-#else
-            typedef typename A::value_type value_type;
-            typedef typename A::pointer pointer;
-            typedef typename A::const_pointer const_pointer;
-            typedef typename A::size_type size_type;
-            typedef typename A::difference_type difference_type;
-            typedef typename A::reference reference;
-            typedef typename A::const_reference const_reference;
-            typedef void* void_pointer;
-            typedef const void* const_void_pointer;
-#endif
-
-            template<class U>
-            struct rebind {
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-                typedef as_allocator<typename AT::
-                    template rebind_alloc<U>, T, R> other;
-#else
-                typedef as_allocator<typename A::
-                    template rebind<U>::other, T, R> other;
-#endif
-            };
-
-            typedef typename array_base<T>::type type;
-
-            as_allocator(const A& allocator_, type** result)
-                : A(allocator_),
-                  data(result) {
-            }
-
-            as_allocator(const A& allocator_, std::size_t size,
-                type** result)
-                : A(allocator_),
-                  data(size, result) {
-            }
-
-            template<class U>
-            as_allocator(const as_allocator<U, T, R>& other)
-                : A(other.allocator()),
-                  data(other.data) {
-            }
-
-            pointer allocate(size_type count, const_void_pointer = 0) {
-                enum {
-                    M = boost::alignment_of<type>::value
-                };
-                std::size_t n1 = count * sizeof(value_type);
-                std::size_t n2 = data.size * sizeof(type);
-                std::size_t n3 = n2 + M;
-                CA ca(allocator());
-                void* p1 = ca.allocate(n1 + n3);
-                void* p2 = static_cast<char*>(p1) + n1;
-                (void)boost::alignment::align(M, n2, p2, n3);
-                *data.result = static_cast<type*>(p2);
-                return static_cast<value_type*>(p1);
-            }
-
-            void deallocate(pointer memory, size_type count) {
-                enum {
-                    M = boost::alignment_of<type>::value
-                };
-                std::size_t n1 = count * sizeof(value_type);
-                std::size_t n2 = data.size * sizeof(type) + M;
-                char* p1 = reinterpret_cast<char*>(memory);
-                CA ca(allocator());
-                ca.deallocate(p1, n1 + n2);
-            }
-
-            const A& allocator() const {
-                return static_cast<const A&>(*this);
-            }
-
-            A& allocator() {
-                return static_cast<A&>(*this);
-            }
-
-            void set(type* memory) {
-                data.object = memory;
-            }
-
-            void operator()() {
-                if (data.object) {
-                    R tag;
-                    release(tag);
-                }
-            }
-
-        private:
-            void release(ms_init_tag) {
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-                as_destroy(allocator(), data.object, data.size);
-#else
-                ms_destroy(data.object, data.size);
-#endif
-            }
-
-            void release(ms_noinit_tag) {
-                ms_destroy(data.object, data.size);
-            }
-
-            ms_allocator_state<T> data;
-        };
-
-        template<class A1, class A2, class T, class R>
-        bool operator==(const as_allocator<A1, T, R>& a1,
-            const as_allocator<A2, T, R>& a2) {
-            return a1.allocator() == a2.allocator();
-        }
-
-        template<class A1, class A2, class T, class R>
-        bool operator!=(const as_allocator<A1, T, R>& a1,
-            const as_allocator<A2, T, R>& a2) {
-            return a1.allocator() != a2.allocator();
-        }
-
-        template<class T, class Y = char>
-        class ms_allocator;
-
-        template<class T, class Y>
-        class ms_allocator {
-            template<class T_, class Y_>
-            friend class ms_allocator;
-
-        public:
-            typedef typename array_base<T>::type type;
-
-            typedef Y value_type;
-            typedef Y* pointer;
-            typedef const Y* const_pointer;
-            typedef std::size_t size_type;
-            typedef std::ptrdiff_t difference_type;
-            typedef Y& reference;
-            typedef const Y& const_reference;
-
-            template<class U>
-            struct rebind {
-                typedef ms_allocator<T, U> other;
-            };
-
-            ms_allocator(type** result)
-                : data(result) {
-            }
-
-            ms_allocator(std::size_t size, type** result)
-                : data(size, result) {
-            }
-
-            template<class U>
-            ms_allocator(const ms_allocator<T, U>& other)
-                : data(other.data) {
-            }
-
-            pointer allocate(size_type count, const void* = 0) {
-                enum {
-                    M = boost::alignment_of<type>::value
-                };
-                std::size_t n1 = count * sizeof(Y);
-                std::size_t n2 = data.size * sizeof(type);
-                std::size_t n3 = n2 + M;
-                void* p1 = ::operator new(n1 + n3);
-                void* p2 = static_cast<char*>(p1) + n1;
-                (void)boost::alignment::align(M, n2, p2, n3);
-                *data.result = static_cast<type*>(p2);
-                return static_cast<Y*>(p1);
-            }
-
-            void deallocate(pointer memory, size_type) {
-                void* p1 = memory;
-                ::operator delete(p1);
-            }
-
-#if defined(BOOST_NO_CXX11_ALLOCATOR)
-            pointer address(reference value) const {
-                return &value;
-            }
-
-            const_pointer address(const_reference value) const {
-                return &value;
-            }
-
-            size_type max_size() const {
-                enum {
-                    N = static_cast<std::size_t>(-1) / sizeof(Y)
-                };
-                return N;
-            }
-
-            void construct(pointer memory, const_reference value) {
-                void* p1 = memory;
-                ::new(p1) Y(value);
-            }
-
-            void destroy(pointer memory) {
-                (void)memory;
-                memory->~Y();
-            }
-#endif
-
-            void set(type* memory) {
-                data.object = memory;
-            }
-
-            void operator()() {
-                if (data.object) {
-                    ms_destroy(data.object, data.size);
-                }
-            }
-
-        private:
-            ms_allocator_state<T> data;
-        };
-
-        template<class T, class Y1, class Y2>
-        bool operator==(const ms_allocator<T, Y1>&,
-            const ms_allocator<T, Y2>&) {
-            return true;
-        }
-
-        template<class T, class Y1, class Y2>
-        bool operator!=(const ms_allocator<T, Y1>&,
-            const ms_allocator<T, Y2>&) {
-            return false;
-        }
-
-        class ms_in_allocator_tag {
-        public:
-            void operator()(const void*) {
-            }
-        };
-    }
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/array_count_impl.hpp b/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/array_count_impl.hpp
deleted file mode 100644
index b7c9617f0b1..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/array_count_impl.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-/*
- * Copyright (c) 2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_COUNT_IMPL_HPP
-#define BOOST_SMART_PTR_DETAIL_ARRAY_COUNT_IMPL_HPP
-
-#include <boost/smart_ptr/detail/array_allocator.hpp>
-#include <boost/smart_ptr/detail/sp_counted_impl.hpp>
-
-namespace boost {
-    namespace detail {
-        template<class P, class A>
-        class sp_counted_impl_pda<P, ms_in_allocator_tag, A>
-            : public sp_counted_base {
-            typedef ms_in_allocator_tag D;
-            typedef sp_counted_impl_pda<P, D, A> Y;
-        public:
-            sp_counted_impl_pda(P, D, const A& allocator_)
-                : allocator(allocator_) {
-            }
-
-            virtual void dispose() {
-                allocator();
-            }
-
-            virtual void destroy() {
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-                typedef typename std::allocator_traits<A>::
-                    template rebind_alloc<Y> YA;
-                typedef typename std::allocator_traits<A>::
-                    template rebind_traits<Y> YT;
-#else
-                typedef typename A::template rebind<Y>::other YA;
-#endif
-                YA a1(allocator);
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-                YT::destroy(a1, this);
-                YT::deallocate(a1, this, 1);
-#else
-                this->~Y();
-                a1.deallocate(this, 1);
-#endif                
-            }
-
-            virtual void* get_deleter(const sp_typeinfo&) {
-                return &reinterpret_cast<char&>(allocator);
-            }
-
-            virtual void* get_untyped_deleter() {
-                return &reinterpret_cast<char&>(allocator);
-            }
-
-        private:
-            sp_counted_impl_pda(const sp_counted_impl_pda&);
-            sp_counted_impl_pda& operator=(const sp_counted_impl_pda&);
-
-            A allocator;
-        };
-    }
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/array_traits.hpp b/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/array_traits.hpp
deleted file mode 100644
index 819c5ba619d..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/array_traits.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_TRAITS_HPP
-#define BOOST_SMART_PTR_DETAIL_ARRAY_TRAITS_HPP
-
-#include <boost/type_traits/remove_cv.hpp>
-
-namespace boost {
-    namespace detail {
-        template<class T>
-        struct array_base {
-            typedef typename boost::remove_cv<T>::type type;
-        };
-
-        template<class T>
-        struct array_base<T[]> {
-            typedef typename array_base<T>::type type;
-        };
-
-        template<class T, std::size_t N>
-        struct array_base<T[N]> {
-            typedef typename array_base<T>::type type;
-        };
-
-        template<class T>
-        struct array_total {
-            enum {
-                size = 1
-            };
-        };
-
-        template<class T, std::size_t N>
-        struct array_total<T[N]> {
-            enum {
-                size = N * array_total<T>::size
-            };
-        };
-
-        template<class T>
-        struct array_inner;
-
-        template<class T>
-        struct array_inner<T[]> {
-            typedef T type;
-        };
-
-        template<class T, std::size_t N>
-        struct array_inner<T[N]> {
-            typedef T type;
-        };
-    }
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/array_utility.hpp b/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/array_utility.hpp
deleted file mode 100644
index 84029a1d771..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/array_utility.hpp
+++ /dev/null
@@ -1,214 +0,0 @@
-/*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License,
- * Version 1.0. (See accompanying file LICENSE_1_0.txt
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#ifndef BOOST_SMART_PTR_DETAIL_ARRAY_UTILITY_HPP
-#define BOOST_SMART_PTR_DETAIL_ARRAY_UTILITY_HPP
-
-#include <boost/config.hpp>
-#include <boost/type_traits/has_trivial_constructor.hpp>
-#include <boost/type_traits/has_trivial_destructor.hpp>
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-#include <memory>
-#endif
-
-namespace boost {
-    namespace detail {
-        typedef boost::true_type  ms_is_trivial;
-        typedef boost::false_type ms_no_trivial;
-
-        template<class T>
-        inline void ms_destroy(T*, std::size_t, ms_is_trivial) {
-        }
-
-        template<class T>
-        inline void ms_destroy(T* memory, std::size_t size, ms_no_trivial) {
-            for (std::size_t i = size; i > 0;) {
-                memory[--i].~T();
-            }
-        }
-
-        template<class T>
-        inline void ms_destroy(T* memory, std::size_t size) {
-            boost::has_trivial_destructor<T> trivial;
-            ms_destroy(memory, size, trivial);
-        }
-
-        template<class T>
-        inline void ms_init(T* memory, std::size_t size, ms_is_trivial) {
-            for (std::size_t i = 0; i < size; i++) {
-                void* p1 = memory + i;
-                ::new(p1) T();
-            }
-        }
-
-        template<class T>
-        inline void ms_init(T* memory, std::size_t size, ms_no_trivial) {
-#if !defined(BOOST_NO_EXCEPTIONS)
-            std::size_t i = 0;
-            try {
-                for (; i < size; i++) {
-                    void* p1 = memory + i;
-                    ::new(p1) T();
-                }
-            } catch (...) {
-                ms_destroy(memory, i);
-                throw;
-            }
-#else
-            for (std::size_t i = 0; i < size; i++) {
-                void* p1 = memory + i;
-                ::new(p1) T();
-            }
-#endif
-        }
-
-        template<class T>
-        inline void ms_init(T* memory, std::size_t size) {
-            boost::has_trivial_default_constructor<T> trivial;
-            ms_init(memory, size, trivial);
-        }
-
-        template<class T, std::size_t N>
-        inline void ms_init(T* memory, std::size_t size, const T* list) {
-#if !defined(BOOST_NO_EXCEPTIONS)
-            std::size_t i = 0;
-            try {
-                for (; i < size; i++) {
-                    void* p1 = memory + i;
-                    ::new(p1) T(list[i % N]);
-                }
-            } catch (...) {
-                ms_destroy(memory, i);
-                throw;
-            }
-#else
-            for (std::size_t i = 0; i < size; i++) {
-                void* p1 = memory + i;
-                ::new(p1) T(list[i % N]);
-            }
-#endif
-        }
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-        template<class T, class A>
-        inline void as_destroy(const A& allocator, T* memory,
-            std::size_t size) {
-            typedef typename std::allocator_traits<A>::
-                template rebind_alloc<T> TA;
-            typedef typename std::allocator_traits<A>::
-                template rebind_traits<T> TT;
-            TA a2(allocator);
-            for (std::size_t i = size; i > 0;) {
-                TT::destroy(a2, &memory[--i]);
-            }
-        }
-
-        template<class T, class A>
-        inline void as_init(const A& allocator, T* memory, std::size_t size,
-            ms_is_trivial) {
-            typedef typename std::allocator_traits<A>::
-                template rebind_alloc<T> TA;
-            typedef typename std::allocator_traits<A>::
-                template rebind_traits<T> TT;
-            TA a2(allocator);
-            for (std::size_t i = 0; i < size; i++) {
-                TT::construct(a2, memory + i);
-            }
-        }
-
-        template<class T, class A>
-        inline void as_init(const A& allocator, T* memory, std::size_t size,
-            ms_no_trivial) {
-            typedef typename std::allocator_traits<A>::
-                template rebind_alloc<T> TA;
-            typedef typename std::allocator_traits<A>::
-                template rebind_traits<T> TT;
-            TA a2(allocator);
-#if !defined(BOOST_NO_EXCEPTIONS)
-            std::size_t i = 0;
-            try {
-                for (; i < size; i++) {
-                    TT::construct(a2, memory + i);
-                }
-            } catch (...) {
-                as_destroy(a2, memory, i);
-                throw;
-            }
-#else
-            for (std::size_t i = 0; i < size; i++) {
-                TT::construct(a2, memory + i);
-            }
-#endif
-        }
-
-        template<class T, class A>
-        inline void as_init(const A& allocator, T* memory, std::size_t size) {
-            boost::has_trivial_default_constructor<T> trivial;
-            as_init(allocator, memory, size, trivial);
-        }
-
-        template<class T, class A, std::size_t N>
-        inline void as_init(const A& allocator, T* memory, std::size_t size,
-            const T* list) {
-            typedef typename std::allocator_traits<A>::
-                template rebind_alloc<T> TA;
-            typedef typename std::allocator_traits<A>::
-                template rebind_traits<T> TT;
-            TA a2(allocator);
-#if !defined(BOOST_NO_EXCEPTIONS)
-            std::size_t i = 0;
-            try {
-                for (; i < size; i++) {
-                    TT::construct(a2, memory + i, list[i % N]);
-                }
-            } catch (...) {
-                as_destroy(a2, memory, i);
-                throw;
-            }
-#else
-            for (std::size_t i = 0; i < size; i++) {
-                TT::construct(a2, memory + i, list[i % N]);
-            }
-#endif
-        }
-#endif
-
-        template<class T>
-        inline void ms_noinit(T*, std::size_t, ms_is_trivial) {
-        }
-
-        template<class T>
-        inline void ms_noinit(T* memory, std::size_t size, ms_no_trivial) {
-#if !defined(BOOST_NO_EXCEPTIONS)
-            std::size_t i = 0;
-            try {
-                for (; i < size; i++) {
-                    void* p1 = memory + i;
-                    ::new(p1) T;
-                }
-            } catch (...) {
-                ms_destroy(memory, i);
-                throw;
-            }
-#else
-            for (std::size_t i = 0; i < size; i++) {
-                void* p1 = memory + i;
-                ::new(p1) T;
-            }
-#endif
-        }
-
-        template<class T>
-        inline void ms_noinit(T* memory, std::size_t size) {
-            boost::has_trivial_default_constructor<T> trivial;
-            ms_noinit(memory, size, trivial);
-        }
-    }
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_if_array.hpp b/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_if_array.hpp
deleted file mode 100644
index 9a2c1e0baaf..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_if_array.hpp
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes 
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#ifndef BOOST_SMART_PTR_DETAIL_SP_IF_ARRAY_HPP
-#define BOOST_SMART_PTR_DETAIL_SP_IF_ARRAY_HPP
-
-#include <boost/smart_ptr/shared_ptr.hpp>
-
-namespace boost {
-    namespace detail {
-        template<class T>
-        struct sp_if_array;
-
-        template<class T>
-        struct sp_if_array<T[]> {
-            typedef boost::shared_ptr<T[]> type;
-        };
-
-        template<class T>
-        struct sp_if_size_array;
-
-        template<class T, std::size_t N>
-        struct sp_if_size_array<T[N]> {
-            typedef boost::shared_ptr<T[N]> type;
-        };
-    }
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/make_shared_array.hpp b/contrib/libboost/boost_1_62_0/boost/smart_ptr/make_shared_array.hpp
deleted file mode 100644
index c48f5070b6b..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/make_shared_array.hpp
+++ /dev/null
@@ -1,158 +0,0 @@
-/*
- * Copyright (c) 2012-2014 Glen Joseph Fernandes
- * glenfe at live dot com
- *
- * Distributed under the Boost Software License,
- * Version 1.0. (See accompanying file LICENSE_1_0.txt
- * or copy at http://boost.org/LICENSE_1_0.txt)
- */
-#ifndef BOOST_SMART_PTR_MAKE_SHARED_ARRAY_HPP
-#define BOOST_SMART_PTR_MAKE_SHARED_ARRAY_HPP
-
-#include <boost/smart_ptr/detail/array_count_impl.hpp>
-#include <boost/smart_ptr/detail/sp_if_array.hpp>
-
-namespace boost {
-    template<class T>
-    inline typename boost::detail::sp_if_array<T>::type
-    make_shared(std::size_t size) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        typedef boost::detail::ms_allocator<T> A1;
-        typedef boost::detail::ms_in_allocator_tag D1;
-        std::size_t n1 = size * boost::detail::array_total<T1>::size;
-        T1* p1 = 0;
-        T2* p2 = 0;
-        D1 d1;
-        A1 a1(size, &p2);
-        shared_ptr<T> s1(p1, d1, a1);
-        A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
-        a2->set(0);
-        boost::detail::ms_init(p2, n1);
-        a2->set(p2);
-        p1 = reinterpret_cast<T1*>(p2);
-        return shared_ptr<T>(s1, p1);
-    }
-
-    template<class T>
-    inline typename boost::detail::sp_if_size_array<T>::type
-    make_shared() {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        typedef boost::detail::ms_allocator<T> A1;
-        typedef boost::detail::ms_in_allocator_tag D1;
-        enum {
-            N = boost::detail::array_total<T>::size
-        };
-        T1* p1 = 0;
-        T2* p2 = 0;
-        D1 d1;
-        A1 a1(&p2);
-        shared_ptr<T> s1(p1, d1, a1);
-        A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
-        a2->set(0);
-        boost::detail::ms_init(p2, N);
-        a2->set(p2);
-        p1 = reinterpret_cast<T1*>(p2);
-        return shared_ptr<T>(s1, p1);
-    }
-
-    template<class T>
-    inline typename boost::detail::sp_if_array<T>::type
-    make_shared(std::size_t size,
-        const typename boost::detail::array_inner<T>::type& value) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        typedef const T2 T3;
-        typedef boost::detail::ms_allocator<T> A1;
-        typedef boost::detail::ms_in_allocator_tag D1;
-        enum {
-            M = boost::detail::array_total<T1>::size
-        };
-        std::size_t n1 = M * size;
-        T1* p1 = 0;
-        T2* p2 = 0;
-        T3* p3 = reinterpret_cast<T3*>(&value);
-        D1 d1;
-        A1 a1(size, &p2);
-        shared_ptr<T> s1(p1, d1, a1);
-        A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
-        a2->set(0);
-        boost::detail::ms_init<T2, M>(p2, n1, p3);
-        a2->set(p2);
-        p1 = reinterpret_cast<T1*>(p2);
-        return shared_ptr<T>(s1, p1);
-    }
-
-    template<class T>
-    inline typename boost::detail::sp_if_size_array<T>::type
-    make_shared(const typename boost::detail::array_inner<T>::type& value) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        typedef const T2 T3;
-        typedef boost::detail::ms_allocator<T> A1;
-        typedef boost::detail::ms_in_allocator_tag D1;
-        enum {
-            M = boost::detail::array_total<T1>::size,
-            N = boost::detail::array_total<T>::size
-        };
-        T1* p1 = 0;
-        T2* p2 = 0;
-        T3* p3 = reinterpret_cast<T3*>(&value);
-        D1 d1;
-        A1 a1(&p2);
-        shared_ptr<T> s1(p1, d1, a1);
-        A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
-        a2->set(0);
-        boost::detail::ms_init<T2, M>(p2, N, p3);
-        a2->set(p2);
-        p1 = reinterpret_cast<T1*>(p2);
-        return shared_ptr<T>(s1, p1);
-    }
-
-    template<class T>
-    inline typename boost::detail::sp_if_array<T>::type
-    make_shared_noinit(std::size_t size) {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        typedef boost::detail::ms_allocator<T> A1;
-        typedef boost::detail::ms_in_allocator_tag D1;
-        std::size_t n1 = size * boost::detail::array_total<T1>::size;
-        T1* p1 = 0;
-        T2* p2 = 0;
-        D1 d1;
-        A1 a1(size, &p2);
-        shared_ptr<T> s1(p1, d1, a1);
-        A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
-        a2->set(0);
-        boost::detail::ms_noinit(p2, n1);
-        a2->set(p2);
-        p1 = reinterpret_cast<T1*>(p2);
-        return shared_ptr<T>(s1, p1);
-    }
-
-    template<class T>
-    inline typename boost::detail::sp_if_size_array<T>::type
-    make_shared_noinit() {
-        typedef typename boost::detail::array_inner<T>::type T1;
-        typedef typename boost::detail::array_base<T1>::type T2;
-        typedef boost::detail::ms_allocator<T> A1;
-        typedef boost::detail::ms_in_allocator_tag D1;
-        enum {
-            N = boost::detail::array_total<T>::size
-        };
-        T1* p1 = 0;
-        T2* p2 = 0;
-        D1 d1;
-        A1 a1(&p2);
-        shared_ptr<T> s1(p1, d1, a1);
-        A1* a2 = static_cast<A1*>(s1._internal_get_untyped_deleter());
-        a2->set(0);
-        boost::detail::ms_noinit(p2, N);
-        a2->set(p2);
-        p1 = reinterpret_cast<T1*>(p2);
-        return shared_ptr<T>(s1, p1);
-    }
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/make_shared_object.hpp b/contrib/libboost/boost_1_62_0/boost/smart_ptr/make_shared_object.hpp
deleted file mode 100644
index 62372fa7ef9..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/make_shared_object.hpp
+++ /dev/null
@@ -1,1131 +0,0 @@
-#ifndef BOOST_SMART_PTR_MAKE_SHARED_OBJECT_HPP_INCLUDED
-#define BOOST_SMART_PTR_MAKE_SHARED_OBJECT_HPP_INCLUDED
-
-//  make_shared_object.hpp
-//
-//  Copyright (c) 2007, 2008, 2012 Peter Dimov
-//
-//  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/smart_ptr/make_shared.html
-//  for documentation.
-
-#include <boost/config.hpp>
-#include <boost/smart_ptr/shared_ptr.hpp>
-#include <boost/smart_ptr/detail/sp_forward.hpp>
-#include <boost/type_traits/type_with_alignment.hpp>
-#include <boost/type_traits/alignment_of.hpp>
-#include <cstddef>
-#include <new>
-
-namespace boost
-{
-
-namespace detail
-{
-
-template< std::size_t N, std::size_t A > struct sp_aligned_storage
-{
-    union type
-    {
-        char data_[ N ];
-        typename boost::type_with_alignment< A >::type align_;
-    };
-};
-
-template< class T > class sp_ms_deleter
-{
-private:
-
-    typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
-
-    bool initialized_;
-    storage_type storage_;
-
-private:
-
-    void destroy()
-    {
-        if( initialized_ )
-        {
-#if defined( __GNUC__ )
-
-            // fixes incorrect aliasing warning
-            T * p = reinterpret_cast< T* >( storage_.data_ );
-            p->~T();
-
-#else
-
-            reinterpret_cast< T* >( storage_.data_ )->~T();
-
-#endif
-
-            initialized_ = false;
-        }
-    }
-
-public:
-
-    sp_ms_deleter() BOOST_NOEXCEPT : initialized_( false )
-    {
-    }
-
-    template<class A> explicit sp_ms_deleter( A const & ) BOOST_NOEXCEPT : initialized_( false )
-    {
-    }
-
-    // optimization: do not copy storage_
-    sp_ms_deleter( sp_ms_deleter const & ) BOOST_NOEXCEPT : initialized_( false )
-    {
-    }
-
-    ~sp_ms_deleter()
-    {
-        destroy();
-    }
-
-    void operator()( T * )
-    {
-        destroy();
-    }
-
-    static void operator_fn( T* ) // operator() can't be static
-    {
-    }
-
-    void * address() BOOST_NOEXCEPT
-    {
-        return storage_.data_;
-    }
-
-    void set_initialized() BOOST_NOEXCEPT
-    {
-        initialized_ = true;
-    }
-};
-
-template< class T, class A > class sp_as_deleter
-{
-private:
-
-    typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
-
-    storage_type storage_;
-    A a_;
-    bool initialized_;
-
-private:
-
-    void destroy()
-    {
-        if( initialized_ )
-        {
-            T * p = reinterpret_cast< T* >( storage_.data_ );
-
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-            std::allocator_traits<A>::destroy( a_, p );
-
-#else
-
-            p->~T();
-
-#endif
-
-            initialized_ = false;
-        }
-    }
-
-public:
-
-    sp_as_deleter( A const & a ) BOOST_NOEXCEPT : a_( a ), initialized_( false )
-    {
-    }
-
-    // optimization: do not copy storage_
-    sp_as_deleter( sp_as_deleter const & r ) BOOST_NOEXCEPT : a_( r.a_), initialized_( false )
-    {
-    }
-
-    ~sp_as_deleter()
-    {
-        destroy();
-    }
-
-    void operator()( T * )
-    {
-        destroy();
-    }
-
-    static void operator_fn( T* ) // operator() can't be static
-    {
-    }
-
-    void * address() BOOST_NOEXCEPT
-    {
-        return storage_.data_;
-    }
-
-    void set_initialized() BOOST_NOEXCEPT
-    {
-        initialized_ = true;
-    }
-};
-
-template< class T > struct sp_if_not_array
-{
-    typedef boost::shared_ptr< T > type;
-};
-
-#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
-
-template< class T > struct sp_if_not_array< T[] >
-{
-};
-
-#if !defined( __BORLANDC__ ) || !BOOST_WORKAROUND( __BORLANDC__, < 0x600 )
-
-template< class T, std::size_t N > struct sp_if_not_array< T[N] >
-{
-};
-
-#endif
-
-#endif
-
-} // namespace detail
-
-#if !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING )
-# define BOOST_SP_MSD( T ) boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >()
-#else
-# define BOOST_SP_MSD( T ) boost::detail::sp_ms_deleter< T >()
-#endif
-
-// _noinit versions
-
-template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared_noinit()
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T;
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared_noinit( A const & a )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T;
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-#if !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-// Variadic templates, rvalue reference
-
-template< class T, class... Args > typename boost::detail::sp_if_not_array< T >::type make_shared( Args && ... args )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( boost::detail::sp_forward<Args>( args )... );
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class... Args > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, Args && ... args )
-{
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-    typedef typename std::allocator_traits<A>::template rebind_alloc<T> A2;
-    A2 a2( a );
-
-    typedef boost::detail::sp_as_deleter< T, A2 > D;
-
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag<D>(), a2 );
-
-#else
-
-    typedef boost::detail::sp_ms_deleter< T > D;
-
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag<D>(), a );
-
-#endif
-
-    D * pd = static_cast< D* >( pt._internal_get_untyped_deleter() );
-    void * pv = pd->address();
-
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-    std::allocator_traits<A2>::construct( a2, static_cast< T* >( pv ), boost::detail::sp_forward<Args>( args )... );
-
-#else
-
-    ::new( pv ) T( boost::detail::sp_forward<Args>( args )... );
-
-#endif
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-#else // !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-// Common zero-argument versions
-
-template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared()
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T();
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T();
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-// For example MSVC 10.0
-
-template< class T, class A1 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::detail::sp_forward<A1>( a1 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( 
-        boost::detail::sp_forward<A1>( a1 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( 
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( 
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( 
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 ), 
-        boost::detail::sp_forward<A5>( a5 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( 
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 ), 
-        boost::detail::sp_forward<A5>( a5 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 ), 
-        boost::detail::sp_forward<A5>( a5 ), 
-        boost::detail::sp_forward<A6>( a6 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( 
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 ), 
-        boost::detail::sp_forward<A5>( a5 ), 
-        boost::detail::sp_forward<A6>( a6 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 ), 
-        boost::detail::sp_forward<A5>( a5 ), 
-        boost::detail::sp_forward<A6>( a6 ), 
-        boost::detail::sp_forward<A7>( a7 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( 
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 ), 
-        boost::detail::sp_forward<A5>( a5 ), 
-        boost::detail::sp_forward<A6>( a6 ), 
-        boost::detail::sp_forward<A7>( a7 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 ), 
-        boost::detail::sp_forward<A5>( a5 ), 
-        boost::detail::sp_forward<A6>( a6 ), 
-        boost::detail::sp_forward<A7>( a7 ), 
-        boost::detail::sp_forward<A8>( a8 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( 
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 ), 
-        boost::detail::sp_forward<A5>( a5 ), 
-        boost::detail::sp_forward<A6>( a6 ), 
-        boost::detail::sp_forward<A7>( a7 ), 
-        boost::detail::sp_forward<A8>( a8 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T(
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 ), 
-        boost::detail::sp_forward<A5>( a5 ), 
-        boost::detail::sp_forward<A6>( a6 ), 
-        boost::detail::sp_forward<A7>( a7 ), 
-        boost::detail::sp_forward<A8>( a8 ), 
-        boost::detail::sp_forward<A9>( a9 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( 
-        boost::detail::sp_forward<A1>( a1 ), 
-        boost::detail::sp_forward<A2>( a2 ), 
-        boost::detail::sp_forward<A3>( a3 ), 
-        boost::detail::sp_forward<A4>( a4 ), 
-        boost::detail::sp_forward<A5>( a5 ), 
-        boost::detail::sp_forward<A6>( a6 ), 
-        boost::detail::sp_forward<A7>( a7 ), 
-        boost::detail::sp_forward<A8>( a8 ), 
-        boost::detail::sp_forward<A9>( a9 )
-        );
-
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-#else // !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-// C++03 version
-
-template< class T, class A1 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( a1 );
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( a1 );
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( a1, a2 );
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( a1, a2 );
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( a1, a2, a3 );
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( a1, a2, a3 );
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( a1, a2, a3, a4 );
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( a1, a2, a3, a4 );
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( a1, a2, a3, a4, a5 );
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( a1, a2, a3, a4, a5 );
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( a1, a2, a3, a4, a5, a6 );
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( a1, a2, a3, a4, a5, a6 );
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7 );
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8 );
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
-typename boost::detail::sp_if_not_array< T >::type make_shared( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
-typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
-{
-    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
-
-    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
-
-    void * pv = pd->address();
-
-    ::new( pv ) T( a1, a2, a3, a4, a5, a6, a7, a8, a9 );
-    pd->set_initialized();
-
-    T * pt2 = static_cast< T* >( pv );
-
-    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
-    return boost::shared_ptr< T >( pt, pt2 );
-}
-
-#endif // !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-#endif // !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
-
-#undef BOOST_SP_MSD
-
-} // namespace boost
-
-#endif // #ifndef BOOST_SMART_PTR_MAKE_SHARED_OBJECT_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/owner_less.hpp b/contrib/libboost/boost_1_62_0/boost/smart_ptr/owner_less.hpp
deleted file mode 100644
index 6899325bd61..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/owner_less.hpp
+++ /dev/null
@@ -1,57 +0,0 @@
-#ifndef BOOST_SMART_PTR_OWNER_LESS_HPP_INCLUDED
-#define BOOST_SMART_PTR_OWNER_LESS_HPP_INCLUDED
-
-//
-//  owner_less.hpp
-//
-//  Copyright (c) 2008 Frank Mori Hess
-//
-//  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/smart_ptr/smart_ptr.htm for documentation.
-//
-
-#include <functional>
-
-namespace boost
-{
-  template<typename T> class shared_ptr;
-  template<typename T> class weak_ptr;
-
-  namespace detail
-  {
-    template<typename T, typename U>
-      struct generic_owner_less : public std::binary_function<T, T, bool>
-    {
-      bool operator()(const T &lhs, const T &rhs) const
-      {
-        return lhs.owner_before(rhs);
-      }
-      bool operator()(const T &lhs, const U &rhs) const
-      {
-        return lhs.owner_before(rhs);
-      }
-      bool operator()(const U &lhs, const T &rhs) const
-      {
-        return lhs.owner_before(rhs);
-      }
-    };
-  } // namespace detail
-
-  template<typename T> struct owner_less;
-
-  template<typename T>
-    struct owner_less<shared_ptr<T> >:
-    public detail::generic_owner_less<shared_ptr<T>, weak_ptr<T> >
-  {};
-
-  template<typename T>
-    struct owner_less<weak_ptr<T> >:
-    public detail::generic_owner_less<weak_ptr<T>, shared_ptr<T> >
-  {};
-
-} // namespace boost
-
-#endif  // #ifndef BOOST_SMART_PTR_OWNER_LESS_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/system/windows_error.hpp b/contrib/libboost/boost_1_62_0/boost/system/windows_error.hpp
deleted file mode 100644
index 9d9d206c6b1..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/system/windows_error.hpp
+++ /dev/null
@@ -1,126 +0,0 @@
-//  boost/system/windows_error.hpp  ------------------------------------------//
-
-//  Copyright Beman Dawes 2007
-
-//  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 library home page at http://www.boost.org/libs/system
-
-#ifndef BOOST_WINDOWS_ERROR_HPP
-#define BOOST_WINDOWS_ERROR_HPP
-
-//  This header is effectively empty for compiles on operating systems where
-//  it is not applicable.
-
-#include <boost/system/config.hpp>
-
-#ifdef BOOST_WINDOWS_API
-
-#include <boost/system/error_code.hpp>
-
-// Neither MinGW or Cygwin versions of winerror.h work if used alone, so on
-// either of those platforms include the full windows.h
-
-#if defined(__MINGW32__) || defined(__CYGWIN__)
-#include <windows.h>
-#else
-#include <winerror.h>
-#endif
-
-namespace boost
-{
-  namespace system
-  {
-
-    //  Microsoft Windows  ---------------------------------------------------//
-
-    //  To construct an error_code after a API error:
-    //
-    //      error_code( ::GetLastError(), system_category() )
-
-    namespace windows_error
-    {
-      enum windows_error_code
-      {
-        success = 0,
-        // These names and values are based on Windows winerror.h
-        invalid_function = ERROR_INVALID_FUNCTION,
-        file_not_found = ERROR_FILE_NOT_FOUND,
-        path_not_found = ERROR_PATH_NOT_FOUND,
-        too_many_open_files = ERROR_TOO_MANY_OPEN_FILES,
-        access_denied = ERROR_ACCESS_DENIED,
-        invalid_handle = ERROR_INVALID_HANDLE,
-        arena_trashed = ERROR_ARENA_TRASHED,
-        not_enough_memory = ERROR_NOT_ENOUGH_MEMORY,
-        invalid_block = ERROR_INVALID_BLOCK,
-        bad_environment = ERROR_BAD_ENVIRONMENT,
-        bad_format = ERROR_BAD_FORMAT,
-        invalid_access = ERROR_INVALID_ACCESS,
-        outofmemory = ERROR_OUTOFMEMORY,
-        invalid_drive = ERROR_INVALID_DRIVE,
-        current_directory = ERROR_CURRENT_DIRECTORY,
-        not_same_device = ERROR_NOT_SAME_DEVICE,
-        no_more_files = ERROR_NO_MORE_FILES,
-        write_protect = ERROR_WRITE_PROTECT,
-        bad_unit = ERROR_BAD_UNIT,
-        not_ready = ERROR_NOT_READY,
-        bad_command = ERROR_BAD_COMMAND,
-        crc = ERROR_CRC,
-        bad_length = ERROR_BAD_LENGTH,
-        seek = ERROR_SEEK,
-        not_dos_disk = ERROR_NOT_DOS_DISK,
-        sector_not_found = ERROR_SECTOR_NOT_FOUND,
-        out_of_paper = ERROR_OUT_OF_PAPER,
-        write_fault = ERROR_WRITE_FAULT,
-        read_fault = ERROR_READ_FAULT,
-        gen_failure = ERROR_GEN_FAILURE,
-        sharing_violation = ERROR_SHARING_VIOLATION,
-        lock_violation = ERROR_LOCK_VIOLATION,
-        wrong_disk = ERROR_WRONG_DISK,
-        sharing_buffer_exceeded = ERROR_SHARING_BUFFER_EXCEEDED,
-        handle_eof = ERROR_HANDLE_EOF,
-        handle_disk_full= ERROR_HANDLE_DISK_FULL,
-        rem_not_list = ERROR_REM_NOT_LIST,
-        dup_name = ERROR_DUP_NAME,
-        bad_net_path = ERROR_BAD_NETPATH,
-        network_busy = ERROR_NETWORK_BUSY,
-        // ...
-        file_exists = ERROR_FILE_EXISTS,
-        cannot_make = ERROR_CANNOT_MAKE,
-        // ...
-        broken_pipe = ERROR_BROKEN_PIPE,
-        open_failed = ERROR_OPEN_FAILED,
-        buffer_overflow = ERROR_BUFFER_OVERFLOW,
-        disk_full= ERROR_DISK_FULL,
-        // ...
-        lock_failed = ERROR_LOCK_FAILED,
-        busy = ERROR_BUSY,
-        cancel_violation = ERROR_CANCEL_VIOLATION,
-        already_exists = ERROR_ALREADY_EXISTS
-        // ...
-
-        // TODO: add more Windows errors
-      };
-
-    }  // namespace windows
-
-# ifndef BOOST_SYSTEM_NO_DEPRECATED
-    namespace windows = windows_error;
-# endif
-
-    template<> struct is_error_code_enum<windows_error::windows_error_code>
-      { static const bool value = true; };
-
-    namespace windows_error
-    {
-      inline error_code make_error_code( windows_error_code e )
-        { return error_code( e, system_category() ); }
-    }
-
-  }  // namespace system
-}  // namespace boost
-
-#endif  // BOOST_WINDOWS_API
-
-#endif  // BOOST_WINDOWS_ERROR_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/auto_unit_test.hpp b/contrib/libboost/boost_1_62_0/boost/test/auto_unit_test.hpp
deleted file mode 100644
index 99acd162abe..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/auto_unit_test.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (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
-//! @brief Deprecated header.
-//! @deprecated Use @c boost/test/unit_test.hpp instead.
-// ***************************************************************************
-
-#ifndef BOOST_TEST_AUTO_UNIT_TEST_HPP_071894GER
-#define BOOST_TEST_AUTO_UNIT_TEST_HPP_071894GER
-
-#include <boost/test/unit_test.hpp>
-
-#endif // BOOST_TEST_AUTO_UNIT_TEST_HPP_071894GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/config.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/config.hpp
deleted file mode 100644
index 7a9d03be983..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/config.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//  (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
-//!@brief common dataset macros
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_CONFIG_HPP_112611GER
-#define BOOST_TEST_DATA_CONFIG_HPP_112611GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/detail/throw_exception.hpp>
-
-// STL
-#include <stdexcept> // for std::logic_error
-
-// availability on features: preprocessed by doxygen
-
-#if defined(BOOST_NO_CXX11_HDR_RANDOM) || defined(BOOST_TEST_DOXYGEN_DOC__)
-//! Defined when the random dataset feature is not available
-#define BOOST_TEST_NO_RANDOM_DATASET_AVAILABLE
-
-#endif
-
-#if defined(BOOST_NO_CXX11_HDR_TUPLE) || defined(BOOST_TEST_DOXYGEN_DOC__)
-
-//! Defined when grid composition of datasets is not available
-#define BOOST_TEST_NO_GRID_COMPOSITION_AVAILABLE
-
-//! Defined when zip composition of datasets is not available
-#define BOOST_TEST_NO_ZIP_COMPOSITION_AVAILABLE
-
-#endif
-
-//____________________________________________________________________________//
-
-#define BOOST_TEST_DS_ERROR( msg )        BOOST_TEST_I_THROW( std::logic_error( msg ) )
-#define BOOST_TEST_DS_ASSERT( cond, msg ) BOOST_TEST_I_ASSRT( cond, std::logic_error( msg ) )
-
-#endif // BOOST_TEST_DATA_CONFIG_HPP_112611GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/dataset.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/dataset.hpp
deleted file mode 100644
index 3f576ab357c..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/dataset.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-//  (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
-//!@brief dataset interfaces
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_DATASET_HPP_102211GER
-#define BOOST_TEST_DATA_DATASET_HPP_102211GER
-
-// Boost.Test
-#include <boost/test/data/monomorphic.hpp>
-
-#endif // BOOST_TEST_DATA_DATASET_HPP_102211GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/for_each_sample.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/for_each_sample.hpp
deleted file mode 100644
index 4785b038cc7..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/for_each_sample.hpp
+++ /dev/null
@@ -1,117 +0,0 @@
-//  (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
-/// Defines for_each_sample algorithm
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_FOR_EACH_SAMPLE_HPP_102211GER
-#define BOOST_TEST_DATA_FOR_EACH_SAMPLE_HPP_102211GER
-
-// Boost.Test
-#include <boost/test/data/config.hpp>
-#include <boost/test/data/size.hpp>
-#include <boost/test/data/index_sequence.hpp>
-#include <boost/test/data/monomorphic/sample_merge.hpp>
-#include <boost/test/data/monomorphic/fwd.hpp>
-
-// STL
-#include <tuple>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-// needed for std::min
-#include <algorithm>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace data {
-
-// ************************************************************************** //
-// **************              data::invoke_action             ************** //
-// ************************************************************************** //
-
-template<typename Action, typename T>
-inline void
-invoke_action( Action const& action, T && arg, std::false_type /* is_tuple */ )
-{
-    action( std::forward<T>(arg) );
-}
-
-//____________________________________________________________________________//
-
-template<typename Action, typename T, std::size_t ...I>
-inline void
-invoke_action_impl( Action const& action,
-                    T && args,
-                    index_sequence<I...> const& )
-{
-    action( std::get<I>(std::forward<T>(args))... );
-}
-
-//____________________________________________________________________________//
-
-template<typename Action, typename T>
-inline void
-invoke_action( Action const& action, T&& args, std::true_type /* is_tuple */ )
-{
-    invoke_action_impl( action,
-                        std::forward<T>(args),
-                        typename make_index_sequence< 0,
-                                                      std::tuple_size<typename std::decay<T>::type>::value
-                                                    >::type{} );
-
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                for_each_sample               ************** //
-// ************************************************************************** //
-
-template<typename DataSet, typename Action>
-inline typename std::enable_if<monomorphic::is_dataset<DataSet>::value,void>::type
-for_each_sample( DataSet &&         samples,
-                 Action const&      act,
-                 data::size_t       number_of_samples = BOOST_TEST_DS_INFINITE_SIZE )
-{
-    data::size_t size = (std::min)( samples.size(), number_of_samples );
-    BOOST_TEST_DS_ASSERT( !size.is_inf(), "Dataset has infinite size. Please specify the number of samples" );
-
-    auto it = samples.begin();
-
-    while( size-- > 0 ) {
-        invoke_action( act,
-                       *it,
-                       typename monomorphic::ds_detail::is_tuple<decltype(*it)>::type());
-        ++it;
-    }
-}
-
-//____________________________________________________________________________//
-
-template<typename DataSet, typename Action>
-inline typename std::enable_if<!monomorphic::is_dataset<DataSet>::value,void>::type
-for_each_sample( DataSet &&     samples,
-                 Action const&      act,
-                 data::size_t       number_of_samples = BOOST_TEST_DS_INFINITE_SIZE )
-{
-    data::for_each_sample( data::make( std::forward<DataSet>(samples) ),
-                           act,
-                           number_of_samples );
-}
-
-} // namespace data
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_DATA_FOR_EACH_SAMPLE_HPP_102211GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/generators.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/generators.hpp
deleted file mode 100644
index e9bd4c17b58..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/generators.hpp
+++ /dev/null
@@ -1,19 +0,0 @@
-//  (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
-//!@brief specific generators
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_MONOMORPHIC_GENERATORS_HPP_112011GER
-#define BOOST_TEST_DATA_MONOMORPHIC_GENERATORS_HPP_112011GER
-
-// Boost.Test
-#include <boost/test/data/monomorphic/generators/xrange.hpp>
-
-#endif // BOOST_TEST_DATA_MONOMORPHIC_GENERATORS_HPP_112011GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/index_sequence.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/index_sequence.hpp
deleted file mode 100644
index 21af7e504ce..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/index_sequence.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-//  (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
-/// Defines c++14 index_sequence implementation
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_INDEX_SEQUENCE_HPP
-#define BOOST_TEST_DATA_INDEX_SEQUENCE_HPP
-
-// Boost.Test
-#include <boost/test/data/config.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace data {
-
-// ************************************************************************** //
-// **************             data::index_sequence             ************** //
-// ************************************************************************** //
-
-template <std::size_t... Ns>
-struct index_sequence {};
-
-template<typename IS1, typename IS2>
-struct merge_index_sequence;
-
-template <std::size_t... Ns1, std::size_t... Ns2>
-struct merge_index_sequence<index_sequence<Ns1...>, index_sequence<Ns2...>> {
-    typedef index_sequence<Ns1..., Ns2...> type;
-};
-
-template <std::size_t B, std::size_t E, typename Enabler = void>
-struct make_index_sequence {
-    typedef typename merge_index_sequence<typename make_index_sequence<B,(B+E)/2>::type,
-                                          typename make_index_sequence<(B+E)/2,E>::type>::type type;
-};
-
-template <std::size_t B, std::size_t E>
-struct make_index_sequence<B,E,typename std::enable_if<E==B+1,void>::type> {
-    typedef index_sequence<B> type;
-};
-
-template <typename... T>
-using index_sequence_for = typename make_index_sequence<0, sizeof...(T)>::type;
-
-} // namespace data
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_DATA_INDEX_SEQUENCE_HPP
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic.hpp
deleted file mode 100644
index 31d7b01b32a..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic.hpp
+++ /dev/null
@@ -1,27 +0,0 @@
-//  (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
-//!@brief Monomorphic dataset interfaces
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_MONOMORPHIC_HPP_102211GER
-#define BOOST_TEST_DATA_MONOMORPHIC_HPP_102211GER
-
-// Boost.Test
-#include <boost/test/data/monomorphic/array.hpp>
-#include <boost/test/data/monomorphic/collection.hpp>
-#include <boost/test/data/monomorphic/initializer_list.hpp>
-#include <boost/test/data/monomorphic/generate.hpp>
-#include <boost/test/data/monomorphic/generators.hpp>
-#include <boost/test/data/monomorphic/grid.hpp>
-#include <boost/test/data/monomorphic/join.hpp>
-#include <boost/test/data/monomorphic/singleton.hpp>
-#include <boost/test/data/monomorphic/zip.hpp>
-
-#endif // BOOST_TEST_DATA_MONOMORPHIC_HPP_102211GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/array.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/array.hpp
deleted file mode 100644
index 6f7ed8eb3b4..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/array.hpp
+++ /dev/null
@@ -1,83 +0,0 @@
-//  (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
-///Defines monomorphic dataset based on C type arrays
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_MONOMORPHIC_ARRAY_HPP_121411GER
-#define BOOST_TEST_DATA_MONOMORPHIC_ARRAY_HPP_121411GER
-
-// Boost.Test
-#include <boost/test/data/config.hpp>
-#include <boost/test/data/monomorphic/fwd.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace data {
-namespace monomorphic {
-
-// ************************************************************************** //
-// **************                     array                    ************** //
-// ************************************************************************** //
-
-/// Dataset view of a C array
-template<typename T>
-class array {
-public:
-    typedef T sample;
-
-    enum { arity = 1 };
-
-    typedef T const* iterator;
-
-    // Constructor
-    array( T const* arr_, std::size_t size_ )
-    : m_arr( arr_ )
-    , m_size( size_ )
-    {}
-
-    // dataset interface
-    data::size_t    size() const    { return m_size; }
-    iterator        begin() const   { return m_arr; }
-
-private:
-    // Data members
-    T const*        m_arr;
-    std::size_t     m_size;
-};
-
-//____________________________________________________________________________//
-
-//! An array dataset is a dataset
-template<typename T>
-struct is_dataset<array<T>> : mpl::true_ {};
-
-} // namespace monomorphic
-
-//____________________________________________________________________________//
-
-//! @overload boost::unit_test::data::make()
-template<typename T, std::size_t size>
-inline monomorphic::array<typename boost::remove_const<T>::type>
-make( T (&a)[size] )
-{
-    return monomorphic::array<typename boost::remove_const<T>::type>( a, size );
-}
-
-} // namespace data
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_DATA_MONOMORPHIC_ARRAY_HPP_121411GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/collection.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/collection.hpp
deleted file mode 100644
index 49e81458bf9..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/collection.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-//  (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
-///Defines monomorphic dataset based on forward iterable sequence
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_MONOMORPHIC_COLLECTION_HPP_102211GER
-#define BOOST_TEST_DATA_MONOMORPHIC_COLLECTION_HPP_102211GER
-
-// Boost.Test
-#include <boost/test/data/config.hpp>
-#include <boost/test/data/monomorphic/fwd.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace data {
-namespace monomorphic {
-
-// ************************************************************************** //
-// **************                  collection                  ************** //
-// ************************************************************************** //
-
-
-//!@brief Dataset from a forward iterable container (collection)
-//!
-//! This dataset is applicable to any container implementing a forward iterator. Note that
-//! container with one element will be considered as singletons.
-//! This dataset is constructible with the @ref boost::unit_test::data::make function.
-template<typename C>
-class collection {
-    typedef typename boost::decay<C>::type col_type;
-public:
-    typedef typename col_type::value_type sample;
-
-    enum { arity = 1 };
-
-    typedef typename col_type::const_iterator iterator;
-
-    //! Constructor consumed a temporary collection or stores a reference 
-    explicit        collection( C&& col ) : m_col( std::forward<C>(col) ) {}
-
-    //! Move constructor
-    collection( collection&& c ) : m_col( std::forward<C>( c.m_col ) ) {}
-
-    //! Returns the underlying collection
-    C const&        col() const             { return m_col; }
-
-    //! dataset interface
-    data::size_t    size() const            { return m_col.size(); }
-    iterator        begin() const           { return m_col.begin(); }
-
-private:
-    // Data members
-    C               m_col;
-};
-
-//____________________________________________________________________________//
-
-//! A collection from a forward iterable container is a dataset.
-template<typename C>
-struct is_dataset<collection<C>> : mpl::true_ {};
-
-} // namespace monomorphic
-
-//____________________________________________________________________________//
-
-//! @overload boost::unit_test::data::make()
-template<typename C>
-inline typename std::enable_if<is_forward_iterable<C>::value,monomorphic::collection<C>>::type
-make( C&& c )
-{
-    return monomorphic::collection<C>( std::forward<C>(c) );
-}
-
-} // namespace data
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_DATA_MONOMORPHIC_COLLECTION_HPP_102211GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/fwd.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/fwd.hpp
deleted file mode 100644
index cf6d3b00006..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/fwd.hpp
+++ /dev/null
@@ -1,180 +0,0 @@
-//  (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
-/// Forward declares monomorphic datasets interfaces
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_MONOMORPHIC_FWD_HPP_102212GER
-#define BOOST_TEST_DATA_MONOMORPHIC_FWD_HPP_102212GER
-
-// Boost.Test
-#include <boost/test/data/config.hpp>
-#include <boost/test/data/size.hpp>
-
-#include <boost/test/utils/is_forward_iterable.hpp>
-
-// Boost
-#include <boost/type_traits/remove_const.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/is_array.hpp>
-#include <boost/mpl/bool.hpp>
-
-// STL
-#include <tuple>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-// STL
-#include <initializer_list>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace data {
-
-namespace monomorphic {
-
-
-#if !defined(BOOST_TEST_DOXYGEN_DOC__)
-
-template<typename T, typename Specific>
-class dataset;
-
-template<typename T>
-class singleton;
-
-template<typename C>
-class collection;
-
-template<typename T>
-class array;
-
-template<typename T>
-class init_list;
-
-#endif
-
-// ************************************************************************** //
-// **************            monomorphic::is_dataset           ************** //
-// ************************************************************************** //
-
-//! Helper metafunction indicating if the specified type is a dataset.
-template<typename DataSet>
-struct is_dataset : mpl::false_ {};
-
-//____________________________________________________________________________//
-
-//! A reference to a dataset is a dataset
-template<typename DataSet>
-struct is_dataset<DataSet&> : is_dataset<DataSet> {};
-
-//____________________________________________________________________________//
-
-//! A const dataset is a dataset
-template<typename DataSet>
-struct is_dataset<DataSet const> : is_dataset<DataSet> {};
-
-} // namespace monomorphic
-
-// ************************************************************************** //
-// **************                  data::make                  ************** //
-// ************************************************************************** //
-
-//! @brief Creates a dataset from a value, a collection or an array
-//!
-//! This function has several overloads:
-//! @code
-//! // returns ds if ds is already a dataset
-//! template <typename DataSet> DataSet make(DataSet&& ds); 
-//!
-//! // creates a singleton dataset, for non forward iterable and non dataset type T
-//! // (a C string is not considered as a sequence).
-//! template <typename T> monomorphic::singleton<T> make(T&& v); 
-//! monomorphic::singleton<char*> make( char* str );
-//! monomorphic::singleton<char const*> make( char const* str );
-//!
-//! // creates a collection dataset, for forward iterable and non dataset type C
-//! template <typename C> monomorphic::collection<C> make(C && c);
-//!
-//! // creates an array dataset
-//! template<typename T, std::size_t size> monomorphic::array<T> make( T (&a)[size] );
-//! @endcode
-template<typename DataSet>
-inline typename std::enable_if<monomorphic::is_dataset<DataSet>::value,DataSet>::type
-make(DataSet&& ds)
-{
-    return std::forward<DataSet>( ds );
-}
-
-//____________________________________________________________________________//
-
-// warning: doxygen is apparently unable to handle @overload from different files, so if the overloads
-// below are not declared with @overload in THIS file, they do not appear in the documentation.
-
-//! @overload boost::unit_test::data::make()
-template<typename T>
-inline typename std::enable_if<!is_forward_iterable<T>::value && 
-                               !monomorphic::is_dataset<T>::value &&
-                               !is_array<typename remove_reference<T>::type>::value, 
-                               monomorphic::singleton<T>>::type
-make( T&& v );
-
-//____________________________________________________________________________//
-
-//! @overload boost::unit_test::data::make()
-template<typename C>
-inline typename std::enable_if<is_forward_iterable<C>::value,monomorphic::collection<C>>::type
-make( C&& c );
-
-//____________________________________________________________________________//
-
-//! @overload boost::unit_test::data::make()
-template<typename T, std::size_t size>
-inline monomorphic::array< typename boost::remove_const<T>::type >
-make( T (&a)[size] );
-
-//____________________________________________________________________________//
-
-//! @overload boost::unit_test::data::make()
-inline monomorphic::singleton<char*>
-make( char* str );
-
-//____________________________________________________________________________//
-
-//! @overload boost::unit_test::data::make()
-inline monomorphic::singleton<char const*>
-make( char const* str );
-
-//____________________________________________________________________________//
-
-//! @overload boost::unit_test::data::make()
-template<typename T>
-inline monomorphic::init_list<T>
-make( std::initializer_list<T>&& );
-
-//____________________________________________________________________________//
-
-namespace result_of {
-
-//! Result of the make call.
-template<typename DataSet>
-struct make {
-    typedef decltype( data::make( declval<DataSet>() ) ) type;
-};
-
-} // namespace result_of
-
-} // namespace data
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_DATA_MONOMORPHIC_FWD_HPP_102212GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/generate.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/generate.hpp
deleted file mode 100644
index af3b5c0bb90..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/generate.hpp
+++ /dev/null
@@ -1,109 +0,0 @@
-//  (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
-/// Defines generic interface for monomorphic dataset based on generator
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_MONOMORPHIC_GENERATE_HPP_112011GER
-#define BOOST_TEST_DATA_MONOMORPHIC_GENERATE_HPP_112011GER
-
-// Boost.Test
-#include <boost/test/data/config.hpp>
-#include <boost/test/data/monomorphic/fwd.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace data {
-namespace monomorphic {
-
-// ************************************************************************** //
-// **************                  generated_by                ************** //
-// ************************************************************************** //
-
-/*!@brief Generators interface
- *
- * This class implements the dataset concept over a generator. Examples of generators are:
- * - xrange_t
- * - random_t
- *
- * The generator concept is the following:
- * - the type of the generated samples is given by field @c sample
- * - the member function @c capacity should return the size of the collection being generated (potentially infinite)
- * - the member function @c next should change the state of the generator to the next generated value
- * - the member function @c reset should put the state of the object in the same state as right after its instanciation
- */
-template<typename Generator>
-class generated_by {
-public:
-    typedef typename Generator::sample sample;
-
-    enum { arity = 1 };
-
-    struct iterator {
-        // Constructor
-        explicit    iterator( Generator& gen )
-        : m_gen( &gen )
-        {
-            if(m_gen->capacity() > 0) {
-                m_gen->reset();
-                ++*this;
-            }
-        }
-
-        // forward iterator interface
-        sample const&   operator*() const   { return m_curr_sample; }
-        void            operator++()        { m_curr_sample = m_gen->next(); }
-
-    private:
-        // Data members
-        Generator*  m_gen;
-        sample      m_curr_sample;
-    };
-
-    typedef Generator generator_type;
-
-    // Constructor
-    explicit        generated_by( Generator&& G )
-    : m_generator( std::forward<Generator>(G) )
-    {}
-
-    // Move constructor
-    generated_by( generated_by&& rhs )
-    : m_generator( std::forward<Generator>(rhs.m_generator) )
-    {}
-
-    //! Size of the underlying dataset
-    data::size_t    size() const            { return m_generator.capacity(); }
-
-    //! Iterator on the beginning of the dataset
-    iterator        begin() const           { return iterator( boost::ref(const_cast<Generator&>(m_generator)) ); }
-
-private:
-    // Data members
-    Generator       m_generator;
-};
-
-//____________________________________________________________________________//
-
-//! A generated dataset is a dataset.
-template<typename Generator>
-struct is_dataset<generated_by<Generator>> : mpl::true_ {};
-
-} // namespace monomorphic
-} // namespace data
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_DATA_MONOMORPHIC_GENERATE_HPP_112011GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/generators.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/generators.hpp
deleted file mode 100644
index 108d4ba58db..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/generators.hpp
+++ /dev/null
@@ -1,20 +0,0 @@
-//  (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
-///Defines specific generators
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_MONOMORPHIC_GENERATORS_HPP_112011GER
-#define BOOST_TEST_DATA_MONOMORPHIC_GENERATORS_HPP_112011GER
-
-// Boost.Test
-#include <boost/test/data/monomorphic/generators/xrange.hpp>
-#include <boost/test/data/monomorphic/generators/random.hpp>
-
-#endif // BOOST_TEST_DATA_MONOMORPHIC_GENERATORS_HPP_112011GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/generators/keywords.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/generators/keywords.hpp
deleted file mode 100644
index de6a4e89e5f..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/generators/keywords.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//  (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
-/// Keywords used in generator interfaces
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_MONOMORPHIC_GENERATORS_KEYWORDS_HPP_101512GER
-#define BOOST_TEST_DATA_MONOMORPHIC_GENERATORS_KEYWORDS_HPP_101512GER
-
-// Boost.Test
-#include <boost/test/data/config.hpp>
-#include <boost/test/utils/named_params.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace data {
-
-namespace {
-nfp::keyword<struct begin_t>    begin;
-nfp::keyword<struct end_t>      end;
-nfp::keyword<struct step_t>     step;
-} // local namespace
-
-} // namespace data
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_DATA_MONOMORPHIC_GENERATORS_KEYWORDS_HPP_101512GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/generators/random.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/generators/random.hpp
deleted file mode 100644
index 24a1df3c64a..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/generators/random.hpp
+++ /dev/null
@@ -1,198 +0,0 @@
-//  (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
-//!@brief Random generator
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_MONOMORPHIC_GENERATORS_RANDOM_HPP_101512GER
-#define BOOST_TEST_DATA_MONOMORPHIC_GENERATORS_RANDOM_HPP_101512GER
-
-// Boost.Test
-#include <boost/test/data/config.hpp>
-
-
-
-
-#if !defined(BOOST_TEST_NO_RANDOM_DATASET_AVAILABLE) || defined(BOOST_TEST_DOXYGEN_DOC__)
-
-#include <boost/test/data/monomorphic/generate.hpp>
-#include <boost/test/data/monomorphic/generators/keywords.hpp>
-
-// STL
-#include <random>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace data {
-
-namespace {
-nfp::keyword<struct seed_t>         seed;
-nfp::keyword<struct distribution_t> distribution;
-nfp::keyword<struct engine_t>       engine;
-} // local namespace
-
-namespace monomorphic {
-
-namespace ds_detail {
-template<typename SampleType>
-struct default_distribution {
-    typedef typename mpl::if_<std::is_integral<SampleType>,
-                              std::uniform_int_distribution<SampleType>,
-                              std::uniform_real_distribution<SampleType>>::type type;
-};
-
-} // namespace ds_detail
-
-// ************************************************************************** //
-// **************                   random_t                   ************** //
-// ************************************************************************** //
-
-/*!@brief Generator for the random sequences
- *
- * This class implements the generator concept (see @ref boost::unit_test::data::monomorphic::generated_by) for implementing
- * a random number generator.
- */
-template<typename SampleType        = double, 
-         typename DistributionType  = typename ds_detail::default_distribution<SampleType>::type,
-         typename EngineType        = std::default_random_engine>
-class random_t {
-public:
-    typedef SampleType          sample;
-    typedef DistributionType    distr_type;
-    typedef EngineType          engine_type;
-
-    random_t()
-    : m_distribution()
-    , m_engine( std::random_device()() )
-    {}
-    explicit random_t( distr_type&& d )
-    : m_distribution( std::forward<distr_type>(d) )
-    , m_engine( std::random_device()() ){}
-    random_t( engine_type&& e, distr_type&& d )
-    : m_distribution( std::forward<distr_type>(d) )
-    , m_engine( std::forward<engine_type>(e) ){}
-
-    // Generator interface
-    data::size_t        capacity() const    { return BOOST_TEST_DS_INFINITE_SIZE; }
-    SampleType          next() 
-    {
-        return m_distribution( m_engine );
-    }
-    void                reset()             {}
-    
-    //! Sets the seed of the pseudo-random number engine.
-    template<typename SeedType>
-    void seed( SeedType&& seed )            { m_engine.seed( std::forward<SeedType>( seed ) ); }
-
-private:
-    // Data members
-    DistributionType    m_distribution;
-    EngineType          m_engine;
-};
-
-//____________________________________________________________________________//
-
-} // namespace monomorphic
-
-
-//! @brief Returns an infinite sequence of random numbers. 
-//!
-//! The following overloads are available:
-//! @code
-//! auto d = random();
-//! auto d = random(begin, end);
-//! auto d = random(params);
-//! @endcode
-//! 
-//!   
-//! - The first overload uses the default distribution, which is uniform and which elements 
-//!   are @c double type (the values are in [0, 1) ). 
-//! - The second overload generates numbers in the given interval. The distribution is uniform (in [begin, end) 
-//!   for real numbers, and in [begin, end] for integers). The type of the distribution is deduced from the type
-//!   of the @c begin and @c end parameters.
-//! - The third overload generates numbers using the named parameter inside @c params , which are:
-//!   - @c distribution: the distribution used. In this overload, since the type of the samples cannot be deduced, 
-//!     the samples are of type @c double and the distribution is uniform real in [0, 1).
-//!   - @c seed: the seed for generating the values
-//!   - @c engine: the random number generator engine
-//!
-//! The function returns an object that implements the dataset API.
-//! @note This function is available only for C++11 capable compilers.
-inline monomorphic::generated_by< monomorphic::random_t<>> random()
-{
-    return monomorphic::generated_by<monomorphic::random_t<>>( monomorphic::random_t<>() );
-}
-
-//____________________________________________________________________________//
-
-/// @overload boost::unit_test::data::random()
-template<typename SampleType>
-inline monomorphic::generated_by< monomorphic::random_t<SampleType>>
-random( SampleType begin, SampleType end )
-{
-    typedef monomorphic::random_t<SampleType> Gen;
-    typedef typename Gen::distr_type distr_type;
-    return monomorphic::generated_by<Gen>( Gen( distr_type(begin,end) ) );
-}
-
-//____________________________________________________________________________//
-
-namespace ds_detail {
-template<typename Params>
-struct random_gen_type {
-    typedef typename nfp::param_type<Params,decltype(distribution),std::uniform_real_distribution<>>::type distr_type;
-    typedef typename nfp::param_type<Params,decltype(engine),std::default_random_engine>::type engine_type;
-    typedef typename distr_type::result_type sample_type;
-
-    typedef monomorphic::random_t<sample_type,distr_type,engine_type> type;
-};
-
-}
-
-
-/// @overload boost::unit_test::data::random()
-template<typename Params>
-inline monomorphic::generated_by<typename ds_detail::random_gen_type<Params>::type>
-random( Params const& params )
-{
-    typedef typename ds_detail::random_gen_type<Params>::type Gen;
-    typedef typename Gen::distr_type distr_type;
-    typedef typename Gen::engine_type engine_type;
-
-    std::random_device rd;
-    engine_type E;
-//    engine_type E( rd );
-    if( params.has(engine) )
-        E = params[engine];
-
-    distr_type D;
-    if( params.has(distribution) )
-        D = params[distribution];
-
-    Gen G( std::move(E), std::move(D) );
-
-    if( params.has(seed) )
-        G.seed( params[seed] );
-
-    return monomorphic::generated_by<Gen>( std::move(G) );
-}
-
-} // namespace data
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_NO_RANDOM_DATASET_AVAILABLE
-
-
-#endif // BOOST_TEST_DATA_MONOMORPHIC_GENERATORS_RANDOM_HPP_101512GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/generators/xrange.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/generators/xrange.hpp
deleted file mode 100644
index 02da352adf9..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/generators/xrange.hpp
+++ /dev/null
@@ -1,224 +0,0 @@
-//  (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
-///Defines range generator
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_MONOMORPHIC_GENERATORS_XRANGE_HPP_112011GER
-#define BOOST_TEST_DATA_MONOMORPHIC_GENERATORS_XRANGE_HPP_112011GER
-
-// Boost.Test
-#include <boost/test/data/config.hpp>
-
-#include <boost/test/data/monomorphic/generators/keywords.hpp>
-#include <boost/test/data/monomorphic/generate.hpp>
-
-// Boost
-#include <boost/optional.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_unsigned.hpp>
-
-// STL
-#include <limits>
-#include <cmath>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace data {
-namespace monomorphic {
-
-// ************************************************************************** //
-// **************             monomorphic::xrange_t            ************** //
-// ************************************************************************** //
-
-
-/*!@brief Generator for the range sequences
- *
- * This class implements the generator concept (see @ref boost::unit_test::data::monomorphic::generated_by) for implementing
- * a range like sequence of numbers.
- */
-template<typename SampleType, typename StepType=SampleType>
-class xrange_t {
-public:
-    typedef SampleType sample;
-
-    xrange_t( SampleType const& begin_, StepType const& step_, data::size_t size_ )
-    : m_begin( begin_ )
-    , m_curr( begin_ )
-    , m_step( step_ )
-    , m_index( 0 )
-    , m_size( size_ )
-    {}
-
-    // Generator interface
-    data::size_t    capacity() const { return m_size; }
-    SampleType      next()
-    {
-        if( m_index == m_size )
-            return m_curr;
-
-        SampleType res = m_curr;
-
-        m_curr += m_step;
-        ++m_index;
-
-        return res;
-    }
-    void                reset()
-    {
-        m_curr  = m_begin;
-        m_index = 0;
-    }
-
-private:
-    // Data members
-    SampleType      m_begin;
-    SampleType      m_curr;
-    StepType        m_step;
-    data::size_t    m_index;
-    data::size_t    m_size;
-};
-
-//____________________________________________________________________________//
-
-namespace ds_detail {
-
-template<typename SampleType, typename StepType=SampleType>
-struct make_xrange {
-    static StepType    abs( StepType s, boost::true_type* )   { return s; }
-    static StepType    abs( StepType s, boost::false_type* )  { return std::abs(s); }
-
-    typedef xrange_t<SampleType, StepType> range_gen;
-
-    template<typename Params>
-    static generated_by<range_gen>
-    _( Params const& params )
-    {
-        SampleType           begin_val  = params.has( data::begin )  ? params[data::begin] : SampleType();
-        optional<SampleType> end_val    = params.has( data::end )    ? params[data::end]   : optional<SampleType>();
-        StepType             step_val   = params.has( data::step )   ? params[data::step]  : 1;
-
-        BOOST_TEST_DS_ASSERT( step_val != 0, "Range step can't be zero" );
-
-        data::size_t size;
-        if( !end_val.is_initialized() )
-            size = BOOST_TEST_DS_INFINITE_SIZE;
-        else {
-            BOOST_TEST_DS_ASSERT( (step_val < 0) ^ (begin_val < *end_val), "Invalid step direction" );
-
-            SampleType  abs_distance    = step_val < 0 ? begin_val - *end_val : *end_val-begin_val;
-            StepType    abs_step        = make_xrange::abs(step_val, (typename boost::is_unsigned<StepType>::type*)0 );
-            std::size_t s = static_cast<std::size_t>(abs_distance/abs_step);
-
-            if( static_cast<SampleType>(s*abs_step) < abs_distance )
-                s++;
-
-            size = s;
-        }
-
-        return generated_by<range_gen>( range_gen( begin_val, step_val, size ) );
-    }
-};
-
-} // namespace ds_detail
-} // namespace monomorphic
-
-//____________________________________________________________________________//
-
-//! Creates a range (sequence) dataset.
-//!
-//! The following overloads are available:
-//! @code
-//! auto d = xrange();
-//! auto d = xrange(end_val);
-//! auto d = xrange(end_val, param);
-//! auto d = xrange(begin_val, end_val);
-//! auto d = xrange(begin_val, end_val, step_val);
-//! auto d = xrange(param);
-//! @endcode
-//!
-//! - @c begin_val indicates the start of the sequence (default to 0).
-//! - @c end_val is the end of the sequence. If ommited, the dataset has infinite size.\n
-//! - @c step_val is the step between two consecutive elements of the sequence, and defaults to 1.\n
-//! - @c param is the named parameters that describe the sequence. The following parameters are accepted:
-//!   - @c begin: same meaning @c begin_val
-//!   - @c end: same meaning as @c end_val
-//!   - @c step: same meaning as @c step_val
-//!
-//!
-//! The returned value is an object that implements the dataset API.
-//!
-//! @note the step size cannot be null, and it should be positive if @c begin_val < @c end_val, negative otherwise.
-template<typename SampleType, typename Params>
-inline monomorphic::generated_by<monomorphic::xrange_t<SampleType>>
-xrange( Params const& params )
-{
-    return monomorphic::ds_detail::make_xrange<SampleType>::_( params );
-}
-
-//____________________________________________________________________________//
-
-/// @overload boost::unit_test::data::xrange()
-template<typename SampleType>
-inline monomorphic::generated_by<monomorphic::xrange_t<SampleType>>
-xrange( SampleType const& end_val )
-{
-    return monomorphic::ds_detail::make_xrange<SampleType>::_( data::end=end_val );
-}
-
-//____________________________________________________________________________//
-
-/// @overload boost::unit_test::data::xrange()
-template<typename SampleType, typename Params>
-inline typename enable_if_c<nfp::is_named_param_pack<Params>::value,
-                            monomorphic::generated_by<monomorphic::xrange_t<SampleType>>>::type
-xrange( SampleType const& end_val, Params const& params )
-{
-    return monomorphic::ds_detail::make_xrange<SampleType>::_(( params, data::end=end_val ));
-}
-
-//____________________________________________________________________________//
-
-/// @overload boost::unit_test::data::xrange()
-template<typename SampleType>
-inline monomorphic::generated_by<monomorphic::xrange_t<SampleType>>
-xrange( SampleType const& begin_val, SampleType const& end_val )
-{
-    return monomorphic::ds_detail::make_xrange<SampleType>::_((
-                data::begin=begin_val,
-                data::end=end_val ));
-}
-
-//____________________________________________________________________________//
-
-
-
-/// @overload boost::unit_test::data::xrange()
-template<typename SampleType,typename StepType>
-inline monomorphic::generated_by<monomorphic::xrange_t<SampleType>>
-xrange( SampleType const& begin_val, SampleType const& end_val, StepType const& step_val )
-{
-    return monomorphic::ds_detail::make_xrange<SampleType,StepType>::_(( 
-                data::begin=begin_val, 
-                data::end=end_val,
-                data::step=step_val ));
-}
-
-//____________________________________________________________________________//
-
-} // namespace data
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_DATA_MONOMORPHIC_GENERATORS_XRANGE_HPP_112011GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/grid.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/grid.hpp
deleted file mode 100644
index 3e1b36abad4..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/grid.hpp
+++ /dev/null
@@ -1,181 +0,0 @@
-//  (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
-/// Defines monomorphic dataset n+m dimentional *. Samples in this
-/// dataset is grid of elements in DataSet1 and DataSet2. There will be total
-/// |DataSet1| * |DataSet2| samples
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_MONOMORPHIC_GRID_HPP_101512GER
-#define BOOST_TEST_DATA_MONOMORPHIC_GRID_HPP_101512GER
-
-// Boost.Test
-#include <boost/test/data/config.hpp>
-
-#if !defined(BOOST_TEST_NO_GRID_COMPOSITION_AVAILABLE) || defined(BOOST_TEST_DOXYGEN_DOC__)
-
-#include <boost/test/data/monomorphic/fwd.hpp>
-#include <boost/test/data/monomorphic/sample_merge.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace data {
-namespace monomorphic {
-
-// ************************************************************************** //
-// **************                       grid                    ************** //
-// ************************************************************************** //
-
-
-//! Implements the dataset resulting from a cartesian product/grid operation on datasets.
-//!
-//! The arity of the resulting dataset is the sum of the arity of its operands.
-template<typename DataSet1, typename DataSet2>
-class grid {
-    typedef typename boost::decay<DataSet1>::type   dataset1_decay;
-    typedef typename boost::decay<DataSet2>::type   dataset2_decay;
-
-    typedef typename dataset1_decay::iterator       dataset1_iter;
-    typedef typename dataset2_decay::iterator       dataset2_iter;
-
-public:
-
-    struct iterator {
-        // Constructor
-        explicit    iterator( dataset1_iter iter1, DataSet2 const& ds2 )
-        : m_iter1( std::move( iter1 ) )
-        , m_iter2( std::move( ds2.begin() ) )
-        , m_ds2( &ds2 )
-        , m_ds2_pos( 0 )
-        {}
-
-        using iterator_sample = decltype(
-            sample_merge( *std::declval<dataset1_iter>(),
-                          *std::declval<dataset2_iter>()) );
-
-        // forward iterator interface
-        auto            operator*() const -> iterator_sample {
-            return sample_merge( *m_iter1, *m_iter2 );
-        }
-        void            operator++()
-        {
-            ++m_ds2_pos;
-            if( m_ds2_pos != m_ds2->size() )
-                ++m_iter2;
-            else {
-                m_ds2_pos = 0;
-                ++m_iter1;
-                m_iter2 = std::move( m_ds2->begin() );
-            }
-        }
-
-    private:
-        // Data members
-        dataset1_iter   m_iter1;
-        dataset2_iter   m_iter2;
-        dataset2_decay const* m_ds2;
-        data::size_t    m_ds2_pos;
-    };
-
-public:
-    enum { arity = boost::decay<DataSet1>::type::arity + boost::decay<DataSet2>::type::arity };
-
-    //! Constructor
-    grid( DataSet1&& ds1, DataSet2&& ds2 )
-    : m_ds1( std::forward<DataSet1>( ds1 ) )
-    , m_ds2( std::forward<DataSet2>( ds2 ) )
-    {}
-
-    //! Move constructor
-    grid( grid&& j )
-    : m_ds1( std::forward<DataSet1>( j.m_ds1 ) )
-    , m_ds2( std::forward<DataSet2>( j.m_ds2 ) )
-    {}
-
-    // dataset interface
-    data::size_t    size() const    { return m_ds1.size() * m_ds2.size(); }
-    iterator        begin() const   { return iterator( m_ds1.begin(), m_ds2 ); }
-
-private:
-    // Data members
-    DataSet1             m_ds1;
-    DataSet2             m_ds2;
-};
-
-//____________________________________________________________________________//
-
-// A grid dataset is a dataset
-template<typename DataSet1, typename DataSet2>
-struct is_dataset<grid<DataSet1,DataSet2>> : mpl::true_ {};
-
-//____________________________________________________________________________//
-
-namespace result_of {
-
-/// Result type of the grid operation on dataset.
-template<typename DS1Gen, typename DS2Gen>
-struct grid {
-    typedef monomorphic::grid<typename DS1Gen::type,typename DS2Gen::type> type;
-};
-
-} // namespace result_of
-
-//____________________________________________________________________________//
-
-//! Grid operation
-template<typename DataSet1, typename DataSet2>
-inline typename boost::lazy_enable_if_c<is_dataset<DataSet1>::value && is_dataset<DataSet2>::value,
-                                        result_of::grid<mpl::identity<DataSet1>,mpl::identity<DataSet2>>
->::type
-operator*( DataSet1&& ds1, DataSet2&& ds2 )
-{
-    BOOST_TEST_DS_ASSERT( !ds1.size().is_inf() && !ds2.size().is_inf(), "Grid axes can't have infinite size" );
-
-    return grid<DataSet1,DataSet2>( std::forward<DataSet1>( ds1 ),  std::forward<DataSet2>( ds2 ) );
-}
-
-//____________________________________________________________________________//
-
-//! @overload boost::unit_test::data::operator*
-template<typename DataSet1, typename DataSet2>
-inline typename boost::lazy_enable_if_c<is_dataset<DataSet1>::value && !is_dataset<DataSet2>::value,
-                                        result_of::grid<mpl::identity<DataSet1>,data::result_of::make<DataSet2>>
->::type
-operator*( DataSet1&& ds1, DataSet2&& ds2 )
-{
-    return std::forward<DataSet1>(ds1) * data::make(std::forward<DataSet2>(ds2));
-}
-
-//____________________________________________________________________________//
-
-//! @overload boost::unit_test::data::operator*
-template<typename DataSet1, typename DataSet2>
-inline typename boost::lazy_enable_if_c<!is_dataset<DataSet1>::value && is_dataset<DataSet2>::value,
-                                        result_of::grid<data::result_of::make<DataSet1>,mpl::identity<DataSet2>>
->::type
-operator*( DataSet1&& ds1, DataSet2&& ds2 )
-{
-    return data::make(std::forward<DataSet1>(ds1)) * std::forward<DataSet2>(ds2);
-}
-
-} // namespace monomorphic
-
-} // namespace data
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_NO_GRID_COMPOSITION_AVAILABLE
-
-#endif // BOOST_TEST_DATA_MONOMORPHIC_GRID_HPP_101512GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/initializer_list.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/initializer_list.hpp
deleted file mode 100644
index 32215973964..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/initializer_list.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-//  (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
-///Defines monomorphic dataset based on C++11 initializer_list template
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_MONOMORPHIC_INITIALIZATION_LIST_HPP_091515GER
-#define BOOST_TEST_DATA_MONOMORPHIC_INITIALIZATION_LIST_HPP_091515GER
-
-// Boost.Test
-#include <boost/test/data/config.hpp>
-#include <boost/test/data/monomorphic/fwd.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace data {
-namespace monomorphic {
-
-// ************************************************************************** //
-// **************                     array                    ************** //
-// ************************************************************************** //
-
-/// Dataset view of a C array
-template<typename T>
-class init_list {
-public:
-    typedef T sample;
-
-    enum { arity = 1 };
-
-    typedef T const* iterator;
-
-    //! Constructor swallows initializer_list
-    init_list( std::initializer_list<T>&& il )
-    : m_data( std::forward<std::initializer_list<T>>( il ) )
-    {}
-
-    //! dataset interface
-    data::size_t    size() const    { return m_data.size(); }
-    iterator        begin() const   { return m_data.begin(); }
-
-private:
-    // Data members
-    std::initializer_list<T> m_data;    
-};
-
-//____________________________________________________________________________//
-
-//! An array dataset is a dataset
-template<typename T>
-struct is_dataset<init_list<T>> : mpl::true_ {};
-
-} // namespace monomorphic
-
-//____________________________________________________________________________//
-
-//! @overload boost::unit_test::data::make()
-template<typename T>
-inline monomorphic::init_list<T>
-make( std::initializer_list<T>&& il )
-{
-    return monomorphic::init_list<T>( std::forward<std::initializer_list<T>>( il ) );
-}
-
-} // namespace data
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_DATA_MONOMORPHIC_INITIALIZATION_LIST_HPP_091515GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/join.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/join.hpp
deleted file mode 100644
index f817994dd3f..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/join.hpp
+++ /dev/null
@@ -1,148 +0,0 @@
-//  (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
-//! Defines dataset join operation
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_MONOMORPHIC_JOIN_HPP_112711GER
-#define BOOST_TEST_DATA_MONOMORPHIC_JOIN_HPP_112711GER
-
-// Boost.Test
-#include <boost/test/data/config.hpp>
-#include <boost/test/data/monomorphic/fwd.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace data {
-namespace monomorphic {
-
-// ************************************************************************** //
-// **************                      join                    ************** //
-// ************************************************************************** //
-
-//! Defines a new dataset from the concatenation of two datasets
-//!
-//! The size of the resulting dataset is the sum of the two underlying datasets. The arity of the datasets
-//! should match.
-template<typename DataSet1, typename DataSet2>
-class join {
-    typedef typename boost::decay<DataSet1>::type   dataset1_decay;
-    typedef typename boost::decay<DataSet2>::type   dataset2_decay;
-
-    typedef typename dataset1_decay::iterator       dataset1_iter;
-    typedef typename dataset2_decay::iterator       dataset2_iter;
-public:
-    typedef typename dataset1_decay::sample         sample;
-
-    enum { arity = dataset1_decay::arity };
-
-    struct iterator {
-        // Constructor
-        explicit    iterator( dataset1_iter it1, dataset2_iter it2, data::size_t first_size )
-        : m_it1( std::move( it1 ) )
-        , m_it2( std::move( it2 ) )
-        , m_first_size( first_size )
-        {}
-
-        // forward iterator interface
-        sample const&       operator*() const   { return m_first_size > 0 ? *m_it1 : *m_it2; }
-        void                operator++()        { if( m_first_size > 0 ) { --m_first_size; ++m_it1; } else ++m_it2; }
-
-    private:
-        // Data members
-        dataset1_iter       m_it1;
-        dataset2_iter       m_it2;
-        data::size_t        m_first_size;
-    };
-
-    //! Constructor 
-    join( DataSet1&& ds1, DataSet2&& ds2 )
-    : m_ds1( std::forward<DataSet1>( ds1 ) )
-    , m_ds2( std::forward<DataSet2>( ds2 ) )
-    {}
-
-    //! Move constructor
-    join( join&& j )
-    : m_ds1( std::forward<DataSet1>( j.m_ds1 ) )
-    , m_ds2( std::forward<DataSet2>( j.m_ds2 ) )
-    {}
-
-    //! dataset interface
-    data::size_t    size() const    { return m_ds1.size() + m_ds2.size(); }
-    iterator        begin() const   { return iterator( m_ds1.begin(), m_ds2.begin(), m_ds1.size() ); }
-
-private:
-    // Data members
-    DataSet1        m_ds1;
-    DataSet2        m_ds2;
-};
-
-//____________________________________________________________________________//
-
-// A joined dataset  is a dataset.
-template<typename DataSet1, typename DataSet2>
-struct is_dataset<join<DataSet1,DataSet2>> : mpl::true_ {};
-
-//____________________________________________________________________________//
-
-namespace result_of {
-
-//! Result type of the join operation on datasets.
-template<typename DataSet1Gen, typename DataSet2Gen>
-struct join {
-    typedef monomorphic::join<typename DataSet1Gen::type,typename DataSet2Gen::type> type;
-};
-
-} // namespace result_of
-
-//____________________________________________________________________________//
-
-template<typename DataSet1, typename DataSet2>
-inline typename boost::lazy_enable_if_c<is_dataset<DataSet1>::value && is_dataset<DataSet2>::value,
-                                        result_of::join<mpl::identity<DataSet1>,mpl::identity<DataSet2>>
->::type
-operator+( DataSet1&& ds1, DataSet2&& ds2 )
-{
-    return join<DataSet1,DataSet2>( std::forward<DataSet1>( ds1 ),  std::forward<DataSet2>( ds2 ) );
-}
-
-//____________________________________________________________________________//
-
-template<typename DataSet1, typename DataSet2>
-inline typename boost::lazy_enable_if_c<is_dataset<DataSet1>::value && !is_dataset<DataSet2>::value,
-                                        result_of::join<mpl::identity<DataSet1>,data::result_of::make<DataSet2>>
->::type
-operator+( DataSet1&& ds1, DataSet2&& ds2 )
-{
-    return std::forward<DataSet1>( ds1 ) + data::make( std::forward<DataSet2>( ds2 ) );
-}
-
-//____________________________________________________________________________//
-
-template<typename DataSet1, typename DataSet2>
-inline typename boost::lazy_enable_if_c<!is_dataset<DataSet1>::value && is_dataset<DataSet2>::value,
-                                        result_of::join<data::result_of::make<DataSet1>,mpl::identity<DataSet2>>
->::type
-operator+( DataSet1&& ds1, DataSet2&& ds2 )
-{
-    return data::make( std::forward<DataSet1>(ds1) ) + std::forward<DataSet2>( ds2 );
-}
-
-} // namespace monomorphic
-} // namespace data
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_DATA_MONOMORPHIC_JOIN_HPP_112711GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/sample_merge.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/sample_merge.hpp
deleted file mode 100644
index d7535beff76..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/sample_merge.hpp
+++ /dev/null
@@ -1,103 +0,0 @@
-//  (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
-/// Defines helper routines and types for merging monomorphic samples
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_MONOMORPHIC_SAMPLE_MERGE_HPP
-#define BOOST_TEST_DATA_MONOMORPHIC_SAMPLE_MERGE_HPP
-
-// Boost.Test
-#include <boost/test/data/config.hpp>
-#include <boost/test/data/index_sequence.hpp>
-
-#include <boost/test/data/monomorphic/fwd.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-namespace boost {
-namespace unit_test {
-namespace data {
-namespace monomorphic {
-
-//____________________________________________________________________________//
-
-namespace ds_detail {
-
-template <class T>
-struct is_tuple : std::false_type {};
-
-template <class ...T>
-struct is_tuple<std::tuple<T...>> : std::true_type {};
-
-template <class T>
-struct is_tuple<T&&> : is_tuple<typename std::decay<T>::type> {};
-
-template <class T>
-struct is_tuple<T&> : is_tuple<typename std::decay<T>::type> {};
-
-template<typename T>
-inline auto as_tuple_impl_xvalues( T const & arg, std::false_type  /* is_rvalue_ref */ )
-  -> decltype(std::tuple<T const&>(arg)) {
-    //return std::tuple<T const&>(arg);
-    return std::forward_as_tuple(arg);
-}
-
-template<typename T>
-inline auto as_tuple_impl_xvalues( T && arg, std::true_type  /* is_rvalue_ref */ )
-  -> decltype(std::make_tuple(std::forward<T>(arg))) {
-    return std::make_tuple(std::forward<T>(arg));
-}
-
-
-template<typename T>
-inline auto as_tuple_impl( T && arg, std::false_type  /* is_tuple = nullptr */ )
-  -> decltype(as_tuple_impl_xvalues(std::forward<T>(arg),
-              typename std::is_rvalue_reference<T&&>::type())) {
-    return as_tuple_impl_xvalues(std::forward<T>(arg),
-                                 typename std::is_rvalue_reference<T&&>::type());
-}
-
-//____________________________________________________________________________//
-
-template<typename T>
-inline T &&
-as_tuple_impl(T && arg, std::true_type  /* is_tuple */ ) {
-    return std::forward<T>(arg);
-}
-
-template<typename T>
-inline auto as_tuple( T && arg )
-  -> decltype( as_tuple_impl(std::forward<T>(arg),
-                             typename ds_detail::is_tuple<T>::type()) ) {
-  return as_tuple_impl(std::forward<T>(arg),
-                       typename ds_detail::is_tuple<T>::type());
-}
-
-//____________________________________________________________________________//
-
-} // namespace ds_detail
-
-template<typename T1, typename T2>
-inline auto
-sample_merge( T1 && a1, T2 && a2 )
-    -> decltype( std::tuple_cat(ds_detail::as_tuple(std::forward<T1>(a1)),
-                                ds_detail::as_tuple(std::forward<T2>(a2)) ) ) {
-    return std::tuple_cat(ds_detail::as_tuple(std::forward<T1>(a1)),
-                          ds_detail::as_tuple(std::forward<T2>(a2)));
-}
-
-} // namespace monomorphic
-} // namespace data
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_DATA_MONOMORPHIC_SAMPLE_MERGE_HPP
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/singleton.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/singleton.hpp
deleted file mode 100644
index 586487a6d7b..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/singleton.hpp
+++ /dev/null
@@ -1,119 +0,0 @@
-//  (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
-/// Defines single element monomorphic dataset
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_MONOMORPHIC_SINGLETON_HPP_102211GER
-#define BOOST_TEST_DATA_MONOMORPHIC_SINGLETON_HPP_102211GER
-
-// Boost.Test
-#include <boost/test/data/config.hpp>
-#include <boost/test/data/monomorphic/fwd.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace data {
-namespace monomorphic {
-
-// ************************************************************************** //
-// **************                    singleton                  ************** //
-// ************************************************************************** //
-
-/// Models a single element data set
-template<typename T>
-class singleton {
-public:
-    typedef typename boost::decay<T>::type sample;
-
-    enum { arity = 1 };
-
-    struct iterator {
-        // Constructor
-        explicit            iterator( singleton<T> const* owner ) 
-        : m_owner( owner ) 
-        {}
-
-        // forward iterator interface 
-        sample const&       operator*() const   { return m_owner->value(); }
-        void                operator++() {}
-
-    private:
-        singleton<T> const* m_owner;
-    };
-
-    //! Constructor
-    explicit        singleton( T&& value ) : m_value( std::forward<T>( value ) ) {}
-
-    //! Move constructor
-    singleton( singleton&& s ) : m_value( std::forward<T>( s.m_value ) ) {}
-
-    //! Value access method
-    T const&        value() const   { return m_value; }
-
-    //! dataset interface
-    data::size_t    size() const    { return 1; }
-    iterator        begin() const   { return iterator( this ); }
-
-private:
-    // Data members
-    T               m_value;
-};
-
-//____________________________________________________________________________//
-
-// a singleton is a dataset
-template<typename T>
-struct is_dataset<singleton<T>> : mpl::true_ {};
-
-//____________________________________________________________________________//
-
-} // namespace monomorphic
-
-/// @overload boost::unit_test::data::make()
-template<typename T>
-inline typename std::enable_if<!is_forward_iterable<T>::value && 
-                               !monomorphic::is_dataset<T>::value &&
-                               !boost::is_array<typename boost::remove_reference<T>::type>::value, 
-                               monomorphic::singleton<T>
->::type
-make( T&& v )
-{
-    return monomorphic::singleton<T>( std::forward<T>( v ) );
-}
-
-//____________________________________________________________________________//
-
-/// @overload boost::unit_test::data::make
-inline monomorphic::singleton<char*>
-make( char* str )
-{
-    return monomorphic::singleton<char*>( std::move(str) );
-}
-
-//____________________________________________________________________________//
-
-/// @overload boost::unit_test::data::make
-inline monomorphic::singleton<char const*>
-make( char const* str )
-{
-    return monomorphic::singleton<char const*>( std::move(str) );
-}
-
-} // namespace data
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_DATA_MONOMORPHIC_SINGLETON_HPP_102211GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/zip.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/zip.hpp
deleted file mode 100644
index 5fc65d0e20b..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/monomorphic/zip.hpp
+++ /dev/null
@@ -1,194 +0,0 @@
-//  (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
-/// Defines monomorphic dataset based on zipping of 2 other monomorphic datasets
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_MONOMORPHIC_ZIP_HPP_102211GER
-#define BOOST_TEST_DATA_MONOMORPHIC_ZIP_HPP_102211GER
-
-// Boost.Test
-#include <boost/test/data/config.hpp>
-
-#if !defined(BOOST_TEST_NO_ZIP_COMPOSITION_AVAILABLE) || defined(BOOST_TEST_DOXYGEN_DOC__)
-
-#include <boost/test/data/monomorphic/fwd.hpp>
-#include <boost/test/data/monomorphic/sample_merge.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-
-namespace boost {
-namespace unit_test {
-namespace data {
-namespace monomorphic {
-
-// ************************************************************************** //
-// **************                       zip                    ************** //
-// ************************************************************************** //
-
-//! Zip datasets
-//!
-//! A zip of two datasets is a dataset whose arity is the sum of the operand datasets arity. The size is given by
-//! the function creating the instance (see @c operator^ on datasets).
-template<typename DataSet1, typename DataSet2>
-class zip {
-    typedef typename boost::decay<DataSet1>::type   dataset1_decay;
-    typedef typename boost::decay<DataSet2>::type   dataset2_decay;
-
-    typedef typename dataset1_decay::iterator       dataset1_iter;
-    typedef typename dataset2_decay::iterator       dataset2_iter;
-
-public:
-    enum { arity = dataset1_decay::arity + dataset2_decay::arity };
-
-    struct iterator {
-        // Constructor
-        explicit    iterator( dataset1_iter iter1, dataset2_iter iter2 )
-        : m_iter1( std::move( iter1 ) )
-        , m_iter2( std::move( iter2 ) )
-        {}
-
-        using iterator_sample = decltype(
-            sample_merge( *std::declval<dataset1_iter>(),
-                          *std::declval<dataset2_iter>()) );
-
-        // forward iterator interface
-        auto            operator*() const -> iterator_sample {
-            return sample_merge( *m_iter1, *m_iter2 );
-        }
-        void            operator++()        { ++m_iter1; ++m_iter2; }
-
-    private:
-        // Data members
-        dataset1_iter   m_iter1;
-        dataset2_iter   m_iter2;
-    };
-
-    typedef typename iterator::iterator_sample   sample;
-
-    //! Constructor
-    //!
-    //! The datasets are moved and not copied.
-    zip( DataSet1&& ds1, DataSet2&& ds2, data::size_t size )
-    : m_ds1( std::forward<DataSet1>( ds1 ) )
-    , m_ds2( std::forward<DataSet2>( ds2 ) )
-    , m_size( size )
-    {}
-
-    //! Move constructor
-    zip( zip&& j )
-    : m_ds1( std::forward<DataSet1>( j.m_ds1 ) )
-    , m_ds2( std::forward<DataSet2>( j.m_ds2 ) )
-    , m_size( j.m_size )
-    {}
-
-    // dataset interface
-    data::size_t    size() const    { return m_size; }
-    iterator        begin() const   { return iterator( m_ds1.begin(), m_ds2.begin() ); }
-
-private:
-    // Data members
-    DataSet1        m_ds1;
-    DataSet2        m_ds2;
-    data::size_t    m_size;
-};
-
-//____________________________________________________________________________//
-
-//! Zipped datasets results in a dataset.
-template<typename DataSet1, typename DataSet2>
-struct is_dataset<zip<DataSet1,DataSet2>> : mpl::true_ {};
-
-//____________________________________________________________________________//
-
-namespace ds_detail {
-
-//! Handles the sise of the resulting zipped dataset.
-template<typename DataSet1, typename DataSet2>
-inline data::size_t
-zip_size( DataSet1&& ds1, DataSet2&& ds2 )
-{
-    data::size_t ds1_size = ds1.size();
-    data::size_t ds2_size = ds2.size();
-
-    if( ds1_size == ds2_size )
-        return ds1_size;
-
-    if( ds1_size == 1 || ds1_size.is_inf() )
-        return ds2_size;
-
-    if( ds2_size == 1  || ds2_size.is_inf() )
-        return ds1_size;
-
-    BOOST_TEST_DS_ERROR( "Can't zip datasets of different sizes" );
-}
-
-} // namespace ds_detail
-
-//____________________________________________________________________________//
-
-namespace result_of {
-
-//! Result type of the zip operator.
-template<typename DS1Gen, typename DS2Gen>
-struct zip {
-    typedef monomorphic::zip<typename DS1Gen::type,typename DS2Gen::type> type;
-};
-
-} // namespace result_of
-
-//____________________________________________________________________________//
-
-//! Overload operator for zip support
-template<typename DataSet1, typename DataSet2>
-inline typename boost::lazy_enable_if_c<is_dataset<DataSet1>::value && is_dataset<DataSet2>::value,
-                                        result_of::zip<mpl::identity<DataSet1>,mpl::identity<DataSet2>>
->::type
-operator^( DataSet1&& ds1, DataSet2&& ds2 )
-{
-    return zip<DataSet1,DataSet2>( std::forward<DataSet1>( ds1 ),
-                                   std::forward<DataSet2>( ds2 ),
-                                   ds_detail::zip_size( ds1, ds2 ) );
-}
-
-//____________________________________________________________________________//
-
-//! @overload boost::unit_test::data::monomorphic::operator^()
-template<typename DataSet1, typename DataSet2>
-inline typename boost::lazy_enable_if_c<is_dataset<DataSet1>::value && !is_dataset<DataSet2>::value,
-                                        result_of::zip<mpl::identity<DataSet1>,data::result_of::make<DataSet2>>
->::type
-operator^( DataSet1&& ds1, DataSet2&& ds2 )
-{
-    return std::forward<DataSet1>( ds1 ) ^ data::make( std::forward<DataSet2>( ds2 ) );
-}
-
-//____________________________________________________________________________//
-
-//! @overload boost::unit_test::data::monomorphic::operator^()
-template<typename DataSet1, typename DataSet2>
-inline typename boost::lazy_enable_if_c<!is_dataset<DataSet1>::value && is_dataset<DataSet2>::value,
-                                        result_of::zip<data::result_of::make<DataSet1>,mpl::identity<DataSet2>>
->::type
-operator^( DataSet1&& ds1, DataSet2&& ds2 )
-{
-    return data::make( std::forward<DataSet1>( ds1 ) ) ^ std::forward<DataSet2>( ds2 );
-}
-
-} // namespace monomorphic
-} // namespace data
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_NO_ZIP_COMPOSITION_AVAILABLE
-
-#endif // BOOST_TEST_DATA_MONOMORPHIC_ZIP_HPP_102211GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/size.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/size.hpp
deleted file mode 100644
index 3e9ba96795d..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/size.hpp
+++ /dev/null
@@ -1,145 +0,0 @@
-//  (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
-//!@brief simple dataset size abstraction (can be infinite)
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_SIZE_HPP_102211GER
-#define BOOST_TEST_DATA_SIZE_HPP_102211GER
-
-// Boost.Test
-#include <boost/test/data/config.hpp>
-
-// STL
-#include <iosfwd>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace data {
-
-// ************************************************************************** //
-// **************                    size_t                    ************** //
-// ************************************************************************** //
-
-//! Utility for handling the size of a datasets
-class size_t {
-    struct dummy { void nonnull() {} };
-    typedef void (dummy::*safe_bool)();
-public:
-    // Constructors
-    size_t( std::size_t s = 0 )         : m_value( s ), m_infinity( false ) {}
-    explicit        size_t( bool )      : m_value( 0 ), m_infinity( true ) {}
-    template<typename T>
-    size_t( T v )                       : m_value( static_cast<std::size_t>(v) ), m_infinity( false ) {}
-
-    // Access methods
-    std::size_t     value() const       { return m_value; }
-    bool            is_inf() const      { return m_infinity; }
-    operator        safe_bool() const   { return is_inf() || m_value != 0 ? &dummy::nonnull : 0; }
-
-    // Unary operators
-    data::size_t    operator--()        { if( !is_inf() ) m_value--; return *this; }
-    data::size_t    operator--(int)     { data::size_t res(*this); if( !is_inf() ) m_value--; return res; }
-    data::size_t    operator++()        { if( !is_inf() ) m_value++; return *this; }
-    data::size_t    operator++(int)     { data::size_t res(*this); if( !is_inf() ) m_value++; return res; }
-
-    // Binary operators
-    data::size_t&   operator+=( std::size_t rhs ) { if( !is_inf() ) m_value += rhs; return *this; }
-    data::size_t&   operator+=( data::size_t rhs )
-    {
-        if( !is_inf() ) {
-            if( rhs.is_inf() )
-                *this = rhs;
-            else
-                m_value += rhs.value();
-        }
-        return *this;
-    }
-    data::size_t&   operator-=( std::size_t rhs ) { if( !is_inf() ) m_value -= rhs; return *this; }
-    data::size_t&   operator-=( data::size_t rhs )
-    {
-        if( !is_inf() ) {
-            if( value() < rhs.value() )
-                m_value = 0;
-            else
-                m_value -= rhs.value();
-        }
-        return *this;
-    }
-
-private:
-    // Data members
-    std::size_t     m_value;
-    bool            m_infinity;
-};
-
-namespace { const data::size_t BOOST_TEST_DS_INFINITE_SIZE( true ); }
-
-//____________________________________________________________________________//
-
-// Binary operators
-inline bool operator>(data::size_t lhs, std::size_t rhs)    { return lhs.is_inf()  || (lhs.value() > rhs); }
-inline bool operator>(std::size_t lhs, data::size_t rhs)    { return !rhs.is_inf() && (lhs > rhs.value()); }
-inline bool operator>(data::size_t lhs, data::size_t rhs)   { return lhs.is_inf() ^ rhs.is_inf() ? lhs.is_inf() : lhs.value() > rhs.value(); }
-
-inline bool operator>=(data::size_t lhs, std::size_t rhs )  { return lhs.is_inf()  || (lhs.value() >= rhs); }
-inline bool operator>=(std::size_t lhs, data::size_t rhs)   { return !rhs.is_inf() && (lhs >= rhs.value()); }
-inline bool operator>=(data::size_t lhs, data::size_t rhs)  { return lhs.is_inf() ^ rhs.is_inf() ? lhs.is_inf() : lhs.value() >= rhs.value(); }
-
-inline bool operator<(data::size_t lhs, std::size_t rhs)    { return !lhs.is_inf() && (lhs.value() < rhs); }
-inline bool operator<(std::size_t lhs, data::size_t rhs)    { return rhs.is_inf()  || (lhs < rhs.value()); }
-inline bool operator<(data::size_t lhs, data::size_t rhs)   { return lhs.is_inf() ^ rhs.is_inf() ? rhs.is_inf() : lhs.value() < rhs.value(); }
-
-inline bool operator<=(data::size_t lhs, std::size_t rhs)   { return !lhs.is_inf() && (lhs.value() <= rhs); }
-inline bool operator<=(std::size_t lhs, data::size_t rhs)   { return rhs.is_inf()  || (lhs <= rhs.value()); }
-inline bool operator<=(data::size_t lhs, data::size_t rhs)  { return lhs.is_inf() ^ rhs.is_inf() ? rhs.is_inf() : lhs.value() <= rhs.value(); }
-
-inline bool operator==(data::size_t lhs, std::size_t rhs)   { return !lhs.is_inf() && (lhs.value() == rhs); }
-inline bool operator==(std::size_t lhs, data::size_t rhs)   { return !rhs.is_inf() && (lhs == rhs.value()); }
-inline bool operator==(data::size_t lhs, data::size_t rhs)  { return !(lhs.is_inf() ^ rhs.is_inf()) && lhs.value() == rhs.value(); }
-
-inline bool operator!=(data::size_t lhs, std::size_t rhs)   { return lhs.is_inf() || (lhs.value() != rhs); }
-inline bool operator!=(std::size_t lhs, data::size_t rhs)   { return rhs.is_inf() || (lhs != rhs.value()); }
-inline bool operator!=(data::size_t lhs, data::size_t rhs)  { return lhs.is_inf() ^ rhs.is_inf() || lhs.value() != rhs.value(); }
-
-inline data::size_t operator+(data::size_t lhs, std::size_t rhs)  { return lhs.is_inf() ? lhs : data::size_t( lhs.value()+rhs ); }
-inline data::size_t operator+(std::size_t lhs, data::size_t rhs)  { return rhs.is_inf() ? rhs : data::size_t( lhs+rhs.value() ); }
-inline data::size_t operator+(data::size_t lhs, data::size_t rhs) { return lhs.is_inf() || rhs.is_inf() ? data::size_t(true) : data::size_t( lhs.value()+rhs.value() ); }
-
-inline data::size_t operator*(data::size_t lhs, std::size_t rhs)  { return lhs.is_inf() ? lhs : data::size_t( lhs.value()*rhs ); }
-inline data::size_t operator*(std::size_t lhs, data::size_t rhs)  { return rhs.is_inf() ? rhs : data::size_t( lhs*rhs.value() ); }
-inline data::size_t operator*(data::size_t lhs, data::size_t rhs) { return lhs.is_inf() || rhs.is_inf() ? data::size_t(true) : data::size_t( lhs.value()*rhs.value() ); }
-
-//____________________________________________________________________________//
-
-template<typename CharT1, typename Tr>
-inline std::basic_ostream<CharT1,Tr>&
-operator<<( std::basic_ostream<CharT1,Tr>& os, data::size_t const& s )
-{
-    if( s.is_inf() )
-        os << "infinity";
-    else
-        os << s.value();
-
-    return os;
-}
-
-//____________________________________________________________________________//
-
-} // namespace data
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_DATA_SIZE_HPP_102211GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/data/test_case.hpp b/contrib/libboost/boost_1_62_0/boost/test/data/test_case.hpp
deleted file mode 100644
index dd9de141c4e..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/data/test_case.hpp
+++ /dev/null
@@ -1,320 +0,0 @@
-//  (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
-//!@brief test case family based on data generator
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DATA_TEST_CASE_HPP_102211GER
-#define BOOST_TEST_DATA_TEST_CASE_HPP_102211GER
-
-// Boost.Test
-#include <boost/test/data/config.hpp>
-#include <boost/test/data/dataset.hpp>
-#include <boost/test/data/for_each_sample.hpp>
-
-// Boost
-#include <boost/preprocessor/repetition/enum_params.hpp>
-#include <boost/preprocessor/repetition/enum_binary_params.hpp>
-#include <boost/preprocessor/repetition/repeat_from_to.hpp>
-
-#include <boost/preprocessor/variadic/to_seq.hpp>
-#include <boost/preprocessor/variadic/size.hpp>
-#include <boost/preprocessor/cat.hpp>
-#include <boost/preprocessor/seq/for_each_i.hpp>
-#include <boost/preprocessor/seq/for_each.hpp>
-#include <boost/preprocessor/seq/enum.hpp>
-#include <boost/preprocessor/control/iif.hpp>
-#include <boost/preprocessor/comparison/equal.hpp>
-
-#include <boost/bind.hpp>
-
-#include <boost/type_traits/is_copy_constructible.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-#include <boost/test/tools/detail/print_helper.hpp>
-#include <boost/test/utils/string_cast.hpp>
-
-#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) \
-   && !defined(BOOST_TEST_DATASET_MAX_ARITY)
-# define BOOST_TEST_DATASET_MAX_ARITY 10
-#endif
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace data {
-
-namespace ds_detail {
-
-// ************************************************************************** //
-// **************                     seed                     ************** //
-// ************************************************************************** //
-
-struct seed {
-    template<typename DataSet>
-    typename data::result_of::make<DataSet>::type
-    operator->*( DataSet&& ds ) const
-    {
-        return data::make( std::forward<DataSet>( ds ) );
-    }
-};
-
-
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && \
-    !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
-    !defined(BOOST_NO_CXX11_DECLTYPE) && \
-    !defined(BOOST_NO_CXX11_TRAILING_RESULT_TYPES) && \
-    !defined(BOOST_NO_CXX11_SMART_PTR)
-
-#define BOOST_TEST_DATASET_VARIADIC
-template <class T>
-struct parameter_holder {
-    std::shared_ptr<T> value;
-
-    parameter_holder(T && value_)
-        : value(std::make_shared<T>(std::move(value_)))
-    {}
-
-    operator T const&() const {
-        return *value;
-    }
-};
-
-template <class T>
-parameter_holder<typename std::remove_reference<T>::type>
-boost_bind_rvalue_holder_helper_impl(T&& value, boost::false_type /* is copy constructible */) {
-    return parameter_holder<typename std::remove_reference<T>::type>(std::forward<T>(value));
-}
-
-template <class T>
-T&& boost_bind_rvalue_holder_helper_impl(T&& value, boost::true_type /* is copy constructible */) {
-    return std::forward<T>(value);
-}
-
-template <class T>
-auto boost_bind_rvalue_holder_helper(T&& value)
-  -> decltype(boost_bind_rvalue_holder_helper_impl(
-                  std::forward<T>(value),
-                  typename boost::is_copy_constructible<typename std::remove_reference<T>::type>::type()))
-{
-    // need to use boost::is_copy_constructible because std::is_copy_constructible is broken on MSVC12
-    return boost_bind_rvalue_holder_helper_impl(
-              std::forward<T>(value),
-              typename boost::is_copy_constructible<typename std::remove_reference<T>::type>::type());
-}
-
-#endif
-
-
-// ************************************************************************** //
-// **************                 test_case_gen                ************** //
-// ************************************************************************** //
-
-template<typename TestCase,typename DataSet>
-class test_case_gen : public test_unit_generator {
-public:
-    // Constructor
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    test_case_gen( const_string tc_name, const_string tc_file, std::size_t tc_line, DataSet&& ds )
-    : m_tc_name( ut_detail::normalize_test_case_name( tc_name ) )
-    , m_tc_file( tc_file )
-    , m_tc_line( tc_line )
-    , m_tc_index( 0 )
-    {
-        data::for_each_sample( std::forward<DataSet>( ds ), *this );
-    }
-    test_case_gen( test_case_gen&& gen )
-    : m_tc_name( gen.m_tc_name )
-    , m_tc_file( gen.m_tc_file )
-    , m_tc_line( gen.m_tc_line )
-    , m_tc_index( gen.m_tc_index )
-    , m_test_cases( std::move(gen.m_test_cases) )
-    {}
-#else
-    test_case_gen( const_string tc_name, const_string tc_file, std::size_t tc_line, DataSet const& ds )
-    : m_tc_name( ut_detail::normalize_test_case_name( tc_name ) )
-    , m_tc_file( tc_file )    
-    , m_tc_line( tc_line )
-    , m_tc_index( 0 )
-    {
-        data::for_each_sample( ds, *this );
-    }
-#endif
-
-    virtual test_unit* next() const
-    {
-        if( m_test_cases.empty() )
-            return 0;
-
-        test_unit* res = m_test_cases.front();
-        m_test_cases.pop_front();
-
-        return res;
-    }
-
-#if !defined(BOOST_TEST_DATASET_VARIADIC)
-    // see BOOST_TEST_DATASET_MAX_ARITY to increase the default supported arity
-#define TC_MAKE(z,arity,_)                                                              \
-    template<BOOST_PP_ENUM_PARAMS(arity, typename Arg)>                                 \
-    void    operator()( BOOST_PP_ENUM_BINARY_PARAMS(arity, Arg, const& arg) ) const     \
-    {                                                                                   \
-        m_test_cases.push_back( new test_case( genTestCaseName(), m_tc_file, m_tc_line, \
-           boost::bind( &TestCase::template test_method<BOOST_PP_ENUM_PARAMS(arity,Arg)>,\
-           BOOST_PP_ENUM_PARAMS(arity, arg) ) ) );                                      \
-    }                                                                                   \
-
-    BOOST_PP_REPEAT_FROM_TO(1, BOOST_TEST_DATASET_MAX_ARITY, TC_MAKE, _)
-#else
-    template<typename ...Arg>
-    void    operator()(Arg&& ... arg) const
-    {
-        m_test_cases.push_back(
-            new test_case( genTestCaseName(),
-                           m_tc_file,
-                           m_tc_line,
-                           boost::bind( &TestCase::template test_method<Arg...>,
-                                        boost_bind_rvalue_holder_helper(std::forward<Arg>(arg))...)));
-    }
-#endif
-
-private:
-    std::string  genTestCaseName() const
-    {
-        return "_" + utils::string_cast(m_tc_index++);
-    }
-
-    // Data members
-    std::string                     m_tc_name;
-    const_string                    m_tc_file;
-    std::size_t                     m_tc_line;
-    mutable std::size_t             m_tc_index;
-    mutable std::list<test_unit*>   m_test_cases;
-};
-
-//____________________________________________________________________________//
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-template<typename TestCase,typename DataSet>
-test_case_gen<TestCase,DataSet>
-make_test_case_gen( const_string tc_name, const_string tc_file, std::size_t tc_line, DataSet&& ds )
-{
-    return test_case_gen<TestCase,DataSet>( tc_name, tc_file, tc_line, std::forward<DataSet>(ds) );
-}
-#else
-template<typename TestCase,typename DataSet>
-test_case_gen<TestCase,DataSet>
-make_test_case_gen( const_string tc_name, const_string tc_file, std::size_t tc_line, DataSet const& ds )
-{
-    return test_case_gen<TestCase,DataSet>( tc_name, tc_file, tc_line, ds );
-}
-#endif
-
-//____________________________________________________________________________//
-
-} // namespace ds_detail
-
-// ************************************************************************** //
-// **************             BOOST_DATA_TEST_CASE             ************** //
-// ************************************************************************** //
-
-#define BOOST_DATA_TEST_CASE_PARAM(r, _, i, param)  (BOOST_PP_CAT(Arg, i) const& param)
-#define BOOST_DATA_TEST_CONTEXT(r, _, param)  << BOOST_STRINGIZE(param) << " = " << boost::test_tools::tt_detail::print_helper(param) << "; "
-
-#define BOOST_DATA_TEST_CASE_PARAMS( params )                           \
-    BOOST_PP_SEQ_ENUM(                                                  \
-        BOOST_PP_SEQ_FOR_EACH_I(BOOST_DATA_TEST_CASE_PARAM, _, params)) \
-/**/
-
-#define BOOST_DATA_TEST_CASE_IMPL(arity, F, test_name, dataset, params) \
-struct BOOST_PP_CAT(test_name, case) : public F {                       \
-    template<BOOST_PP_ENUM_PARAMS(arity, typename Arg)>                 \
-    static void test_method( BOOST_DATA_TEST_CASE_PARAMS( params ) )    \
-    {                                                                   \
-        BOOST_TEST_CHECKPOINT('"' << #test_name << "\" fixture entry.");\
-        BOOST_PP_CAT(test_name, case) t;                                \
-        BOOST_TEST_CHECKPOINT('"' << #test_name << "\" entry.");        \
-        BOOST_TEST_CONTEXT( ""                                          \
-            BOOST_PP_SEQ_FOR_EACH(BOOST_DATA_TEST_CONTEXT, _, params))  \
-        t._impl(BOOST_PP_SEQ_ENUM(params));                             \
-        BOOST_TEST_CHECKPOINT('"' << #test_name << "\" exit.");         \
-    }                                                                   \
-private:                                                                \
-    template<BOOST_PP_ENUM_PARAMS(arity, typename Arg)>                 \
-    void _impl(BOOST_DATA_TEST_CASE_PARAMS( params ));                  \
-};                                                                      \
-                                                                        \
-BOOST_AUTO_TEST_SUITE( test_name )                                      \
-                                                                        \
-BOOST_AUTO_TU_REGISTRAR( BOOST_PP_CAT(test_name, case) )(               \
-    boost::unit_test::data::ds_detail::make_test_case_gen<              \
-                                      BOOST_PP_CAT(test_name, case)>(   \
-          BOOST_STRINGIZE( test_name ),                                 \
-          __FILE__, __LINE__,                                           \
-          boost::unit_test::data::ds_detail::seed{} ->* dataset ),      \
-    boost::unit_test::decorator::collector::instance() );               \
-                                                                        \
-BOOST_AUTO_TEST_SUITE_END()                                             \
-                                                                        \
-    template<BOOST_PP_ENUM_PARAMS(arity, typename Arg)>                 \
-    void BOOST_PP_CAT(test_name, case)::_impl(                          \
-                                BOOST_DATA_TEST_CASE_PARAMS( params ) ) \
-/**/
-
-#define BOOST_DATA_TEST_CASE_WITH_PARAMS( F, test_name, dataset, ... )  \
-    BOOST_DATA_TEST_CASE_IMPL( BOOST_PP_VARIADIC_SIZE(__VA_ARGS__),     \
-                               F, test_name, dataset,                   \
-                               BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__) )  \
-/**/
-#define BOOST_DATA_TEST_CASE_NO_PARAMS( F, test_name, dataset )         \
-    BOOST_DATA_TEST_CASE_WITH_PARAMS( F, test_name, dataset, sample )   \
-/**/
-
-#if BOOST_PP_VARIADICS_MSVC
-
-#define BOOST_DATA_TEST_CASE( ... )                                     \
-    BOOST_PP_CAT(                                                       \
-    BOOST_PP_IIF(BOOST_PP_EQUAL(BOOST_PP_VARIADIC_SIZE(__VA_ARGS__),2), \
-                     BOOST_DATA_TEST_CASE_NO_PARAMS,                    \
-                     BOOST_DATA_TEST_CASE_WITH_PARAMS) (                \
-                        BOOST_AUTO_TEST_CASE_FIXTURE, __VA_ARGS__), )   \
-/**/
-
-#define BOOST_DATA_TEST_CASE_F( F, ... )                                \
-    BOOST_PP_CAT(                                                       \
-    BOOST_PP_IIF(BOOST_PP_EQUAL(BOOST_PP_VARIADIC_SIZE(__VA_ARGS__),2), \
-                     BOOST_DATA_TEST_CASE_NO_PARAMS,                    \
-                     BOOST_DATA_TEST_CASE_WITH_PARAMS) (                \
-                        F, __VA_ARGS__), )                              \
-/**/
-
-#else
-
-#define BOOST_DATA_TEST_CASE( ... )                                     \
-    BOOST_PP_IIF(BOOST_PP_EQUAL(BOOST_PP_VARIADIC_SIZE(__VA_ARGS__),2), \
-                     BOOST_DATA_TEST_CASE_NO_PARAMS,                    \
-                     BOOST_DATA_TEST_CASE_WITH_PARAMS) (                \
-                        BOOST_AUTO_TEST_CASE_FIXTURE, __VA_ARGS__)      \
-/**/
-
-#define BOOST_DATA_TEST_CASE_F( F, ... )                                \
-    BOOST_PP_IIF(BOOST_PP_EQUAL(BOOST_PP_VARIADIC_SIZE(__VA_ARGS__),2), \
-                     BOOST_DATA_TEST_CASE_NO_PARAMS,                    \
-                     BOOST_DATA_TEST_CASE_WITH_PARAMS) (                \
-                        F, __VA_ARGS__)                                 \
-/**/
-#endif
-
-} // namespace data
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_DATA_TEST_CASE_HPP_102211GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/debug.hpp b/contrib/libboost/boost_1_62_0/boost/test/debug.hpp
deleted file mode 100644
index a8ccae0b970..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/debug.hpp
+++ /dev/null
@@ -1,138 +0,0 @@
-//  (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
-//! @brief defines portable debug interfaces
-//!
-//! Intended to standardize interface of programs with debuggers
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DEBUG_API_HPP_112006GER
-#define BOOST_TEST_DEBUG_API_HPP_112006GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
-
-// Boost
-#include <boost/function/function1.hpp>
-
-// STL
-#include <string>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-/// Contains debugger and debug C Runtime interfaces
-namespace debug {
-
-/// @defgroup DebuggerInterface Debugger and debug C Runtime portable interfaces
-/// @{
-/// These interfaces are intended to be used by application to:
-/// - check if we are running under debugger
-/// - attach the debugger to itself
-///
-/// Unfortunately these actions differ widely between different debuggers available in a field. These interface present generalized standard form of
-/// performing these actions. Implementation depends a lot on the environment application is running in and thus there are several custom implementations
-/// supported by the Boost.Test
-///
-/// In addition here you find interfaces for memory leaks detection and reporting.
-///
-/// All these interfaces are defined in namespace boost::debug
-
-// ************************************************************************** //
-/// Checks if programs runs under debugger
-
-/// @returns true if current process is under debugger. False otherwise
-// ************************************************************************** //
-bool BOOST_TEST_DECL under_debugger();
-
-// ************************************************************************** //
-/// Cause program to break execution in debugger at call point
-// ************************************************************************** //
-
-void BOOST_TEST_DECL debugger_break();
-
-// ************************************************************************** //
-/// Collection of data, which is used by debugger starter routine
-// ************************************************************************** //
-
-struct dbg_startup_info {
-    long                    pid;                ///< pid of a program to attach to
-    bool                    break_or_continue;  ///< what to do after debugger is attached
-    unit_test::const_string binary_path;        ///< path to executable for current process
-    unit_test::const_string display;            ///< if debugger has a GUI, which display to use (on UNIX)
-    unit_test::const_string init_done_lock;     ///< path to a uniquely named lock file, which is used to pause current application while debugger is being initialized
-};
-
-/// Signature of debugger starter routine. Takes an instance of dbg_startup_into as only argument
-typedef boost::function<void (dbg_startup_info const&)> dbg_starter;
-
-// ************************************************************************** //
-/// Specifies which debugger to use when attaching and optionally what routine to use to start that debugger
-
-/// There are  many different debuggers available for different platforms. Some of them also can be used in a different setups/configuratins.
-/// For example, gdb can be used in plain text mode, inside ddd, inside (x)emacs or in a separate xterm window.
-/// Boost.Test identifies each configuration with unique string.
-/// Also different debuggers configurations require different routines which is specifically tailored to start that debugger configuration.
-/// Boost.Test comes with set of predefined configuration names and corresponding routines for these configurations:
-///   - TODO
-///
-/// You can use this routine to select which one of the predefined debugger configurations to use in which case you do not need to provide starter
-/// routine (the one provided by Boost.Test will be used). You can also use this routine to select your own debugger by providing unique configuration
-/// id and starter routine for this configuration.
-///
-/// @param[in] dbg_id   Unique id for debugger configuration (for example, gdb)
-/// @param[in] s        Optional starter routine for selected configuration (use only you want to define your own configuration)
-/// @returns            Id of previously selected debugger configuration
-std::string BOOST_TEST_DECL set_debugger( unit_test::const_string dbg_id, dbg_starter s = dbg_starter() );
-
-// ************************************************************************** //
-/// Attaches debugger to the current process
-
-/// Using  currently selected debugger, this routine attempts to attach the debugger to this process.
-/// @param[in] break_or_continue tells what we wan to do after the debugger is attached. If true - process execution breaks
-///                              in the point in invocation of this function. Otherwise execution continues, but now it is
-///                              under the debugger
-/// @returns true if debugger successfully attached. False otherwise
-// ************************************************************************** //
-
-bool BOOST_TEST_DECL attach_debugger( bool break_or_continue = true );
-
-// ************************************************************************** //
-/// Switches on/off memory leaks detection
-
-/// On platforms where memory leak detection is possible inside of running application (at the moment this is only Windows family) you can
-/// switch this feature on and off using this interface. In addition you can specify the name of the file to write a report into. Otherwise
-/// the report is going to be generated in standard error stream.
-/// @param[in] on_off boolean switch
-/// @param[in] report_file file, where the report should be directed to
-// ************************************************************************** //
-
-void BOOST_TEST_DECL detect_memory_leaks( bool on_off, unit_test::const_string report_file = unit_test::const_string() );
-
-// ************************************************************************** //
-/// Causes program to break execution in debugger at specific allocation point
-
-/// On some platforms/memory managers (at the moment only on Windows/Visual Studio) one can tell a C Runtime to break
-/// on specific memory allocation. This can be used in combination with memory leak detection (which reports leaked memory
-/// allocation number) to locate the place where leak initiated.
-/// @param[in] mem_alloc_order_num Specific memory allocation number
-// ************************************************************************** //
-
-void BOOST_TEST_DECL break_memory_alloc( long mem_alloc_order_num );
-
-} // namespace debug
-/// @}
-
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/test/debug_config.hpp b/contrib/libboost/boost_1_62_0/boost/test/debug_config.hpp
deleted file mode 100644
index 894d78e65ab..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/debug_config.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//  (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
-//! @brief user's config for Boost.Test debugging support
-//!
-//! This file is intended to be edited by end user to specify varios macros, which configure debugger interface
-//! Alterntively you can set these parameters in your own sources/makefiles
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DEBUG_CONFIG_HPP_112006GER
-#define BOOST_TEST_DEBUG_CONFIG_HPP_112006GER
-
-// ';' separated list of supported debuggers
-// #define BOOST_TEST_DBG_LIST gdb;dbx
-
-// maximum size of /proc/pid/stat file
-// #define BOOST_TEST_STAT_LINE_MAX
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/test/detail/config.hpp b/contrib/libboost/boost_1_62_0/boost/test/detail/config.hpp
deleted file mode 100644
index db9b5d2b928..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/detail/config.hpp
+++ /dev/null
@@ -1,127 +0,0 @@
-//  (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
-//!@brief a central place for global configuration switches
-// ***************************************************************************
-
-#ifndef BOOST_TEST_CONFIG_HPP_071894GER
-#define BOOST_TEST_CONFIG_HPP_071894GER
-
-// Boost
-#include <boost/config.hpp> // compilers workarounds
-#include <boost/detail/workaround.hpp>
-
-#if defined(_WIN32) && !defined(BOOST_DISABLE_WIN32) &&                  \
-    (!defined(__COMO__) && !defined(__MWERKS__) && !defined(__GNUC__) || \
-    BOOST_WORKAROUND(__MWERKS__, >= 0x3000))
-#  define BOOST_SEH_BASED_SIGNAL_HANDLING
-#endif
-
-#if defined(__COMO__) && defined(_MSC_VER)
-// eh.h uses type_info without declaring it.
-class type_info;
-#  define BOOST_SEH_BASED_SIGNAL_HANDLING
-#endif
-
-//____________________________________________________________________________//
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570)) || \
-    BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))     || \
-    (defined __sgi && BOOST_WORKAROUND(_COMPILER_VERSION, BOOST_TESTED_AT(730)))
-#  define BOOST_TEST_SHIFTED_LINE
-#endif
-
-//____________________________________________________________________________//
-
-#if defined(BOOST_MSVC) || (defined(__BORLANDC__) && !defined(BOOST_DISABLE_WIN32))
-#  define BOOST_TEST_CALL_DECL __cdecl
-#else
-#  define BOOST_TEST_CALL_DECL /**/
-#endif
-
-//____________________________________________________________________________//
-
-#if !defined(BOOST_NO_STD_LOCALE) && !defined(__MWERKS__)
-#  define BOOST_TEST_USE_STD_LOCALE 1
-#endif
-
-//____________________________________________________________________________//
-
-#if BOOST_WORKAROUND(__BORLANDC__, <= 0x570)            || \
-    BOOST_WORKAROUND( __COMO__, <= 0x433 )              || \
-    BOOST_WORKAROUND( __INTEL_COMPILER, <= 800 )        || \
-    defined(__sgi) && _COMPILER_VERSION <= 730          || \
-    BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))  || \
-    defined(__DECCXX)                                   || \
-    defined(__DMC__)
-#  define BOOST_TEST_NO_PROTECTED_USING
-#endif
-
-//____________________________________________________________________________//
-
-#if defined(__GNUC__) || BOOST_WORKAROUND(BOOST_MSVC, == 1400)
-#define BOOST_TEST_PROTECTED_VIRTUAL virtual
-#else
-#define BOOST_TEST_PROTECTED_VIRTUAL
-#endif
-
-//____________________________________________________________________________//
-
-#if !defined(__BORLANDC__) && !BOOST_WORKAROUND( __SUNPRO_CC, < 0x5100 )
-#define BOOST_TEST_SUPPORT_TOKEN_ITERATOR 1
-#endif
-
-//____________________________________________________________________________//
-
-#if defined(BOOST_ALL_DYN_LINK) && !defined(BOOST_TEST_DYN_LINK)
-#  define BOOST_TEST_DYN_LINK
-#endif
-
-#if defined(BOOST_TEST_INCLUDED)
-#  undef BOOST_TEST_DYN_LINK
-#endif
-
-#if defined(BOOST_TEST_DYN_LINK)
-#  define BOOST_TEST_ALTERNATIVE_INIT_API
-
-#  ifdef BOOST_TEST_SOURCE
-#    define BOOST_TEST_DECL BOOST_SYMBOL_EXPORT
-#  else
-#    define BOOST_TEST_DECL BOOST_SYMBOL_IMPORT
-#  endif  // BOOST_TEST_SOURCE
-#else
-#  define BOOST_TEST_DECL
-#endif
-
-#if !defined(BOOST_TEST_MAIN) && defined(BOOST_AUTO_TEST_MAIN)
-#define BOOST_TEST_MAIN BOOST_AUTO_TEST_MAIN
-#endif
-
-#if !defined(BOOST_TEST_MAIN) && defined(BOOST_TEST_MODULE)
-#define BOOST_TEST_MAIN BOOST_TEST_MODULE
-#endif
-
-
-
-#ifndef BOOST_PP_VARIADICS /* we can change this only if not already defined) */
-
-#ifdef __PGI
-#define BOOST_PP_VARIADICS 1
-#endif
-
-#if BOOST_CLANG
-#define BOOST_PP_VARIADICS 1
-#endif
-
-#if defined(BOOST_GCC) && (BOOST_GCC >= 4 * 10000 + 8 * 100)
-#define BOOST_PP_VARIADICS 1
-#endif
-
-#endif /* ifndef BOOST_PP_VARIADICS */
-
-#endif // BOOST_TEST_CONFIG_HPP_071894GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/detail/enable_warnings.hpp b/contrib/libboost/boost_1_62_0/boost/test/detail/enable_warnings.hpp
deleted file mode 100644
index 45afb319446..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/detail/enable_warnings.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-//  (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
-//!@brief enable previously suppressed warnings
-// ***************************************************************************
-
-#ifdef BOOST_MSVC
-# pragma warning(default: 4511) // copy constructor can't not be generated
-# pragma warning(default: 4512) // assignment operator can't not be generated
-# pragma warning(default: 4100) // unreferenced formal parameter
-# pragma warning(default: 4996) // <symbol> was declared deprecated
-# pragma warning(default: 4355) // 'this' : used in base member initializer list
-# pragma warning(default: 4706) // assignment within conditional expression
-# pragma warning(default: 4251) // class 'A<T>' needs to have dll-interface to be used by clients of class 'B'
-# pragma warning(default: 4127) // conditional expression is constant
-# pragma warning(default: 4290) // C++ exception specification ignored except to ...
-# pragma warning(default: 4180) // qualifier applied to function type has no meaning; ignored
-# pragma warning(default: 4275) // non dll-interface class ... used as base for dll-interface class ...
-# pragma warning(default: 4267) // 'var' : conversion from 'size_t' to 'type', possible loss of data
-# pragma warning(default: 4511) // 'class' : copy constructor could not be generated
-# pragma warning(pop)
-#endif
-
-#if BOOST_CLANG
-#pragma clang diagnostic pop
-#endif
-
-#if defined(BOOST_GCC) && (BOOST_GCC >= 4 * 10000 + 6 * 100)
-# pragma GCC diagnostic pop
-#endif
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/detail/fwd_decl.hpp b/contrib/libboost/boost_1_62_0/boost/test/detail/fwd_decl.hpp
deleted file mode 100644
index 944d52267d2..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/detail/fwd_decl.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//  (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
-//!@brief contains forward eclarations for Boost.Test data types
-// ***************************************************************************
-
-#ifndef BOOST_TEST_FWD_DECL_HPP_011605GER
-#define BOOST_TEST_FWD_DECL_HPP_011605GER
-
-namespace boost {
-
-class  execution_monitor;
-class  execution_exception;
-
-namespace unit_test {
-
-class  test_unit;
-class  test_case;
-class  test_suite;
-class  master_test_suite_t;
-
-class  test_tree_visitor;
-class  test_observer;
-
-// singletons
-class  unit_test_monitor_t;
-class  unit_test_log_t;
-
-class  unit_test_log_formatter;
-struct log_entry_data;
-struct log_checkpoint_data;
-
-class lazy_ostream;
-
-} // namespace unit_test
-
-} // namespace boost
-
-#endif // BOOST_TEST_FWD_DECL_HPP_011605GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/detail/global_typedef.hpp b/contrib/libboost/boost_1_62_0/boost/test/detail/global_typedef.hpp
deleted file mode 100644
index b9cfeb5206a..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/detail/global_typedef.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-//  (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
-//!@brief some trivial global typedefs
-// ***************************************************************************
-
-#ifndef BOOST_TEST_GLOBAL_TYPEDEF_HPP_021005GER
-#define BOOST_TEST_GLOBAL_TYPEDEF_HPP_021005GER
-
-#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
-#include <boost/test/detail/workaround.hpp>
-
-#define BOOST_TEST_L( s )         ::boost::unit_test::const_string( s, sizeof( s ) - 1 )
-#define BOOST_TEST_STRINGIZE( s ) BOOST_TEST_L( BOOST_STRINGIZE( s ) )
-#define BOOST_TEST_EMPTY_STRING   BOOST_TEST_L( "" )
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-typedef unsigned long   counter_t;
-
-//____________________________________________________________________________//
-
-enum report_level  { INV_REPORT_LEVEL, CONFIRMATION_REPORT, SHORT_REPORT, DETAILED_REPORT, NO_REPORT };
-
-//____________________________________________________________________________//
-
-//! Indicates the output format for the loggers or the test tree printing
-enum output_format { OF_INVALID,
-                     OF_CLF,      ///< compiler log format
-                     OF_XML,      ///< XML format for report and log,
-                     OF_JUNIT,    ///< JUNIT format for report and log,
-                     OF_CUSTOM_LOGGER, ///< User specified logger.
-                     OF_DOT       ///< dot format for output content
-};
-
-//____________________________________________________________________________//
-
-enum test_unit_type { TUT_CASE = 0x01, TUT_SUITE = 0x10, TUT_ANY = 0x11 };
-
-//____________________________________________________________________________//
-
-enum assertion_result { AR_FAILED, AR_PASSED, AR_TRIGGERED };
-
-//____________________________________________________________________________//
-
-typedef unsigned long   test_unit_id;
-
-const test_unit_id INV_TEST_UNIT_ID  = 0xFFFFFFFF;
-const test_unit_id MAX_TEST_CASE_ID  = 0xFFFFFFFE;
-const test_unit_id MIN_TEST_CASE_ID  = 0x00010000;
-const test_unit_id MAX_TEST_SUITE_ID = 0x0000FF00;
-const test_unit_id MIN_TEST_SUITE_ID = 0x00000001;
-
-//____________________________________________________________________________//
-
-namespace ut_detail {
-
-inline test_unit_type
-test_id_2_unit_type( test_unit_id id )
-{
-    return (id & 0xFFFF0000) != 0 ? TUT_CASE : TUT_SUITE;
-}
-
-//____________________________________________________________________________//
-
-} // namespace ut_detail
-
-// helper templates to prevent ODR violations
-template<class T>
-struct static_constant {
-    static T value;
-};
-
-template<class T>
-T static_constant<T>::value;
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-} // namespace boost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_GLOBAL_TYPEDEF_HPP_021005GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/detail/log_level.hpp b/contrib/libboost/boost_1_62_0/boost/test/detail/log_level.hpp
deleted file mode 100644
index abdecea7ec9..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/detail/log_level.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//  (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
-//!@brief shared definition for unit test log levels
-// ***************************************************************************
-
-#ifndef BOOST_TEST_LOG_LEVEL_HPP_011605GER
-#define BOOST_TEST_LOG_LEVEL_HPP_011605GER
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                   log levels                 ************** //
-// ************************************************************************** //
-
-//  each log level includes all subsequent higher loging levels
-enum            log_level {
-    invalid_log_level        = -1,
-    log_successful_tests     = 0,
-    log_test_units           = 1,
-    log_messages             = 2,
-    log_warnings             = 3,
-    log_all_errors           = 4, // reported by unit test macros
-    log_cpp_exception_errors = 5, // uncaught C++ exceptions
-    log_system_errors        = 6, // including timeouts, signals, traps
-    log_fatal_errors         = 7, // including unit test macros or
-                                  // fatal system errors
-    log_nothing              = 8
-};
-
-} // namespace unit_test
-} // namespace boost
-
-#endif // BOOST_TEST_LOG_LEVEL_HPP_011605GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/detail/pp_variadic.hpp b/contrib/libboost/boost_1_62_0/boost/test/detail/pp_variadic.hpp
deleted file mode 100644
index a443744daaa..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/detail/pp_variadic.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-//  (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
-//!@brief few helpers for working with variadic macros
-// ***************************************************************************
-
-#ifndef BOOST_TEST_PP_VARIADIC_HPP_021515GER
-#define BOOST_TEST_PP_VARIADIC_HPP_021515GER
-
-// Boost
-#include <boost/preprocessor/control/iif.hpp>
-#include <boost/preprocessor/comparison/equal.hpp>
-#include <boost/preprocessor/variadic/size.hpp>
-
-//____________________________________________________________________________//
-
-#if BOOST_PP_VARIADICS
-
-#if BOOST_PP_VARIADICS_MSVC
-#  define BOOST_TEST_INVOKE_VARIADIC( tool, ... ) BOOST_PP_CAT( tool (__VA_ARGS__), )
-#else
-#  define BOOST_TEST_INVOKE_VARIADIC( tool, ... ) tool (__VA_ARGS__)
-#endif
-
-//____________________________________________________________________________//
-
-/// if sizeof(__VA_ARGS__) == N: F1(__VA_ARGS__)
-/// else:                        F2(__VA_ARGS__)
-#define BOOST_TEST_INVOKE_IF_N_ARGS( N, F1, F2, ... )               \
-    BOOST_TEST_INVOKE_VARIADIC(                                     \
-        BOOST_PP_IIF(                                               \
-            BOOST_PP_EQUAL(BOOST_PP_VARIADIC_SIZE(__VA_ARGS__), N), \
-            F1,                                                     \
-            F2),                                                    \
-        __VA_ARGS__ )                                               \
-/**/
-
-//____________________________________________________________________________//
-
-#endif  /* BOOST_PP_VARIADICS */
-
-#endif // BOOST_TEST_PP_VARIADIC_HPP_021515GER
-
-// EOF
diff --git a/contrib/libboost/boost_1_62_0/boost/test/detail/suppress_warnings.hpp b/contrib/libboost/boost_1_62_0/boost/test/detail/suppress_warnings.hpp
deleted file mode 100644
index 4badf207581..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/detail/suppress_warnings.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//  (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
-//!@brief suppress some warnings
-// ***************************************************************************
-
-#ifdef BOOST_MSVC
-# pragma warning(push)
-# pragma warning(disable: 4511) // copy constructor can't not be generated
-# pragma warning(disable: 4512) // assignment operator can't not be generated
-# pragma warning(disable: 4100) // unreferenced formal parameter
-# pragma warning(disable: 4996) // <symbol> was declared deprecated
-# pragma warning(disable: 4355) // 'this' : used in base member initializer list
-# pragma warning(disable: 4706) // assignment within conditional expression
-# pragma warning(disable: 4251) // class 'A<T>' needs to have dll-interface to be used by clients of class 'B'
-# pragma warning(disable: 4127) // conditional expression is constant
-# pragma warning(disable: 4290) // C++ exception specification ignored except to ...
-# pragma warning(disable: 4180) // qualifier applied to function type has no meaning; ignored
-# pragma warning(disable: 4275) // non dll-interface class ... used as base for dll-interface class ...
-# pragma warning(disable: 4267) // 'var' : conversion from 'size_t' to 'type', possible loss of data
-# pragma warning(disable: 4511) // 'class' : copy constructor could not be generated
-#endif
-
-#if BOOST_CLANG
-# pragma clang diagnostic push
-# pragma clang diagnostic ignored "-Wvariadic-macros"
-#endif
-
-#if defined(BOOST_GCC) && (BOOST_GCC >= 4 * 10000 + 6 * 100)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wvariadic-macros"
-#endif
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/detail/throw_exception.hpp b/contrib/libboost/boost_1_62_0/boost/test/detail/throw_exception.hpp
deleted file mode 100644
index 1568ec3c291..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/detail/throw_exception.hpp
+++ /dev/null
@@ -1,71 +0,0 @@
-//  (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
-//!@brief contains wrappers, which allows to build Boost.Test with no exception
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DETAIL_THROW_EXCEPTION_HPP
-#define BOOST_TEST_DETAIL_THROW_EXCEPTION_HPP
-
-// Boost
-#include <boost/config.hpp> // BOOST_NO_EXCEPTION
-
-#ifdef BOOST_NO_EXCEPTION
-// C RUNTIME
-#include <stdlib.h>
-
-#endif
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace ut_detail {
-
-#ifdef BOOST_NO_EXCEPTIONS
-
-template<typename E>
-BOOST_NORETURN inline void
-throw_exception(E const& e) { abort(); }
-
-#define BOOST_TEST_I_TRY
-#define BOOST_TEST_I_CATCH( T, var ) for(T const& var = *(T*)0; false;)
-#define BOOST_TEST_I_CATCH0( T ) if(0)
-#define BOOST_TEST_I_CATCHALL() if(0)
-#define BOOST_TEST_I_RETHROW
-
-#else
-
-template<typename E>
-BOOST_NORETURN inline void
-throw_exception(E const& e) { throw e; }
-
-#define BOOST_TEST_I_TRY try
-#define BOOST_TEST_I_CATCH( T, var ) catch( T const& var )
-#define BOOST_TEST_I_CATCH0( T ) catch( T const& )
-#define BOOST_TEST_I_CATCHALL() catch(...)
-#define BOOST_TEST_I_RETHROW throw
-#endif
-
-//____________________________________________________________________________//
-
-#define BOOST_TEST_I_THROW( E ) unit_test::ut_detail::throw_exception( E )
-#define BOOST_TEST_I_ASSRT( cond, ex ) if( cond ) {} else BOOST_TEST_I_THROW( ex )
-
-
-} // namespace ut_detail
-} // namespace unit_test
-} // namespace boost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_DETAIL_THROW_EXCEPTION_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/detail/workaround.hpp b/contrib/libboost/boost_1_62_0/boost/test/detail/workaround.hpp
deleted file mode 100644
index 4ba3a7e9346..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/detail/workaround.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-//  (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
-//!@brief contains mics. workarounds
-// ***************************************************************************
-
-#ifndef BOOST_TEST_WORKAROUND_HPP_021005GER
-#define BOOST_TEST_WORKAROUND_HPP_021005GER
-
-// Boost
-#include <boost/config.hpp> // compilers workarounds and std::ptrdiff_t
-
-// STL
-#include <iterator>     // for std::distance
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace ut_detail {
-
-#ifdef BOOST_NO_STD_DISTANCE
-template <class T>
-std::ptrdiff_t distance( T const& x_, T const& y_ )
-{
-    std::ptrdiff_t res = 0;
-
-    std::distance( x_, y_, res );
-
-    return res;
-}
-
-//____________________________________________________________________________//
-
-#else
-using std::distance;
-#endif
-
-template <class T> inline void ignore_unused_variable_warning(const T&) {}
-
-} // namespace ut_detail
-} // namespace unit_test
-} // namespace boost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_WORKAROUND_HPP_021005GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/execution_monitor.hpp b/contrib/libboost/boost_1_62_0/boost/test/execution_monitor.hpp
deleted file mode 100644
index 3a203d15f90..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/execution_monitor.hpp
+++ /dev/null
@@ -1,531 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001.
-//  (C) Copyright Beman Dawes 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
-//!@brief Defines public interface of the Execution Monitor and related classes
-// ***************************************************************************
-
-#ifndef BOOST_TEST_EXECUTION_MONITOR_HPP_071894GER
-#define BOOST_TEST_EXECUTION_MONITOR_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/fwd_decl.hpp>
-#include <boost/test/detail/throw_exception.hpp>
-
-#include <boost/test/utils/class_properties.hpp>
-
-// Boost
-#include <boost/shared_ptr.hpp>
-#include <boost/scoped_array.hpp>
-#include <boost/type.hpp>
-#include <boost/cstdlib.hpp>
-#include <boost/function/function0.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-#ifdef BOOST_SEH_BASED_SIGNAL_HANDLING
-
-// for the FP constants and control routines
-#include <float.h>
-
-#ifndef EM_INVALID
-#define EM_INVALID _EM_INVALID
-#endif
-
-#ifndef EM_DENORMAL
-#define EM_DENORMAL _EM_DENORMAL
-#endif
-
-#ifndef EM_ZERODIVIDE
-#define EM_ZERODIVIDE _EM_ZERODIVIDE
-#endif
-
-#ifndef EM_OVERFLOW
-#define EM_OVERFLOW _EM_OVERFLOW
-#endif
-
-#ifndef EM_UNDERFLOW
-#define EM_UNDERFLOW _EM_UNDERFLOW
-#endif
-
-#ifndef MCW_EM
-#define MCW_EM _MCW_EM
-#endif
-
-#else // based on ISO C standard
-
-#if !defined(BOOST_NO_FENV_H)
-  #include <boost/detail/fenv.hpp>
-#endif
-
-#endif
-
-
-// Additional macro documentations not being generated without this hack
-#ifdef BOOST_TEST_DOXYGEN_DOC__
-
-//! Disables the support of the alternative stack
-//! during the compilation of the Boost.test framework. This is especially useful
-//! in case it is not possible to detect the lack of alternative stack support for
-//! your compiler (for instance, ESXi).
-#define BOOST_TEST_DISABLE_ALT_STACK
-
-#endif
-
-//____________________________________________________________________________//
-
-namespace boost {
-
-/// @defgroup ExecutionMonitor Function Execution Monitor
-/// @{
-/// @section Intro Introduction
-/// Sometimes we need to call a function and make sure that no user or system originated exceptions are being thrown by it. Uniform exception reporting
-/// is also may be convenient. That's the purpose of the Boost.Test's Execution Monitor.
-///
-/// The Execution Monitor is a lower-level component of the Boost Test Library. It is the base for implementing all other Boost.Test components, but also
-/// can be used standalone to get controlled execution of error-prone functions with a uniform error notification. The Execution Monitor calls a user-supplied
-/// function in a controlled environment, relieving users from messy error detection.
-///
-/// The Execution Monitor usage is demonstrated in the example exec_mon_example.
-///
-/// @section DesignRationale Design Rationale
-///
-/// The Execution Monitor design assumes that it can be used when no (or almost no) memory available. Also the Execution Monitor is intended to be portable to as many platforms as possible.
-///
-/// @section UserGuide User's guide
-/// The Execution Monitor is designed to solve the problem of executing potentially dangerous function that may result in any number of error conditions,
-/// in monitored environment that should prevent any undesirable exceptions to propagate out of function call and produce consistent result report for all outcomes.
-/// The Execution Monitor is able to produce informative report for all standard C++ exceptions and intrinsic types. All other exceptions are reported as unknown.
-/// If you prefer different message for your exception type or need to perform any action, the Execution Monitor supports custom exception translators.
-/// There are several other parameters of the monitored environment can be configured by setting appropriate properties of the Execution Monitor.
-///
-/// All symbols in the Execution Monitor implementation are located in the namespace boost. To use the Execution Monitor you need to:
-/// -# include @c boost/test/execution_monitor.hpp
-/// -# Make an instance of execution_monitor.
-/// -# Optionally register custom exception translators for exception classes which require special processing.
-///
-/// @subsection FuncExec Monitored function execution
-///
-/// The class execution_monitor can monitor functions with the following signatures:
-/// - int ()
-/// - void ()
-///
-/// This function is expected to be self sufficient part of your application. You can't pass any arguments to this function directly. Instead you
-/// should bind them into executable nullary function using bind function (either standard or boost variant). Neither you can return any other value,
-/// but an integer result code. If necessary you can bind output parameters by reference or use some other more complicated nullary functor, which
-/// maintains state. This includes class methods, static class methods etc.
-///
-/// To start the monitored function, invoke the method execution_monitor::execute and pass the monitored function as an argument. If the call succeeds,
-/// the method returns the result code produced by the monitored function. If any of the following conditions occur:
-/// - Uncaught C++ exception
-/// - Hardware or software signal, trap, or other exception
-/// - Timeout reached
-/// - Debug assert event occurred (under Microsoft Visual C++ or compatible compiler)
-///
-/// then the method throws the execution_exception. The exception contains unique error_code value identifying the error condition and the detailed message
-/// that can be used to report the error.
-///
-/// @subsection Reporting Errors reporting and translation
-///
-/// If you need to report an error inside monitored function execution you have to throw an exception. Do not use the execution_exception - it's not intended
-/// to be used for this purpose. The simplest choice is to use one of the following C++ types as an exception:
-/// - C string
-/// - std:string
-/// - any exception class in std::exception hierarchy
-/// - boost::exception
-///
-/// execution_monitor will catch and report these types of exceptions. If exception is thrown which is unknown to execution_monitor, it can only
-/// report the fact of the exception. So in case if you prefer to use your own exception types or can't govern what exceptions are generated by monitored
-/// function and would like to see proper error message in a report, execution_monitor can be configured with custom "translator" routine, which will have
-/// a chance to either record the fact of the exception itself or translate it into one of standard exceptions and rethrow (or both). The translator routine
-/// is registered per exception type and is invoked when exception of this class (or one inherited from it) is thrown inside monitored routine. You can
-/// register as many independent translators as you like. See execution_monitor::register_exception_translator specification for requirements on translator
-/// function.
-///
-/// Finally, if you need to abort the monitored function execution without reporting any errors, you can throw an exception execution_aborted. As a result
-/// the execution is aborted and zero result code is produced by the method execution_monitor::execute.
-///
-/// @subsection Parameters Supported parameters
-///
-/// The Execution Monitor behavior is configurable through the set of parameters (properties) associated with the instance of the monitor. See execution_monitor
-/// specification for a list of supported parameters and their semantic.
-
-// ************************************************************************** //
-// **************        detail::translator_holder_base        ************** //
-// ************************************************************************** //
-
-namespace detail {
-
-class translator_holder_base;
-typedef boost::shared_ptr<translator_holder_base> translator_holder_base_ptr;
-
-class BOOST_TEST_DECL translator_holder_base {
-protected:
-    typedef boost::unit_test::const_string const_string;
-public:
-    // Constructor
-    translator_holder_base( translator_holder_base_ptr next, const_string tag )
-    : m_next( next )
-    , m_tag( std::string() + tag )
-    {
-    }
-
-    // Destructor
-    virtual     ~translator_holder_base() {}
-
-    // translator holder interface
-    // invokes the function F inside the try/catch guarding against specific exception
-    virtual int operator()( boost::function<int ()> const& F ) = 0;
-
-    // erases specific translator holder from the chain
-    translator_holder_base_ptr erase( translator_holder_base_ptr this_, const_string tag )
-    {
-        if( m_next )
-            m_next = m_next->erase( m_next, tag );
-
-        return m_tag == tag ? m_next : this_;
-    }
-#ifndef BOOST_NO_RTTI
-    virtual translator_holder_base_ptr erase( translator_holder_base_ptr this_, std::type_info const& ) = 0;
-    template<typename ExceptionType>
-    translator_holder_base_ptr erase( translator_holder_base_ptr this_, boost::type<ExceptionType>* = 0 )
-    {
-        if( m_next )
-            m_next = m_next->erase<ExceptionType>( m_next );
-
-        return erase( this_, typeid(ExceptionType) );
-    }
-#endif
-
-protected:
-    // Data members
-    translator_holder_base_ptr  m_next;
-    std::string                 m_tag;
-};
-
-} // namespace detail
-
-// ************************************************************************** //
-/// @class execution_exception
-/// @brief This class is used to report any kind of an failure during execution of a monitored function inside of execution_monitor
-///
-/// The instance of this class is thrown out of execution_monitor::execute invocation when failure is detected. Regardless of a kind of failure occurred
-/// the instance will provide a uniform way to catch and report it.
-///
-/// One important design rationale for this class is that we should be ready to work after fatal memory corruptions or out of memory conditions. To facilitate
-/// this class never allocates any memory and assumes that strings it refers to are either some constants or live in a some kind of persistent (preallocated) memory.
-// ************************************************************************** //
-
-class BOOST_TEST_DECL execution_exception {
-    typedef boost::unit_test::const_string const_string;
-public:
-    /// These values are sometimes used as program return codes.
-    /// The particular values have been chosen to avoid conflicts with
-    /// commonly used program return codes: values < 100 are often user
-    /// assigned, values > 255 are sometimes used to report system errors.
-    /// Gaps in values allow for orderly expansion.
-    ///
-    /// @note(1) Only uncaught C++ exceptions are treated as errors.
-    /// If a function catches a C++ exception, it never reaches
-    /// the execution_monitor.
-    ///
-    /// The implementation decides what is a system_fatal_error and what is
-    /// just a system_exception. Fatal errors are so likely to have corrupted
-    /// machine state (like a stack overflow or addressing exception) that it
-    /// is unreasonable to continue execution.
-    ///
-    /// @note(2) These errors include Unix signals and Windows structured
-    /// exceptions. They are often initiated by hardware traps.
-    enum error_code {
-        no_error               = 0,   ///< for completeness only; never returned
-        user_error             = 200, ///< user reported non-fatal error
-        cpp_exception_error    = 205, ///< see note (1) above
-        system_error           = 210, ///< see note (2) above
-        timeout_error          = 215, ///< only detectable on certain platforms
-        user_fatal_error       = 220, ///< user reported fatal error
-        system_fatal_error     = 225  ///< see note (2) above
-    };
-
-    /// Simple model for the location of failure in a source code
-    struct BOOST_TEST_DECL location {
-        explicit    location( char const* file_name = 0, size_t line_num = 0, char const* func = 0 );
-
-        const_string    m_file_name;    ///< File name
-        size_t          m_line_num;     ///< Line number
-        const_string    m_function;     ///< Function name
-    };
-
-    /// @name Constructors
-
-    /// Constructs instance based on message, location and error code
-
-    /// @param[in] ec           error code
-    /// @param[in] what_msg     error message
-    /// @param[in] location     error location
-    execution_exception( error_code ec, const_string what_msg, location const& location );
-
-    /// @name Access methods
-
-    /// Exception error code
-    error_code      code() const    { return m_error_code; }
-    /// Exception message
-    const_string    what() const    { return m_what; }
-    /// Exception location
-    location const& where() const   { return m_location; }
-    ///@}
-
-private:
-    // Data members
-    error_code      m_error_code;
-    const_string    m_what;
-    location        m_location;
-}; // execution_exception
-
-// ************************************************************************** //
-/// @brief Function execution monitor
-
-/// This class is used to uniformly detect and report an occurrence of several types of signals and exceptions, reducing various
-/// errors to a uniform execution_exception that is returned to a caller.
-///
-/// The executiom_monitor behavior can be customized through a set of public parameters (properties) associated with the execution_monitor instance.
-/// All parameters are implemented as public unit_test::readwrite_property data members of the class execution_monitor.
-// ************************************************************************** //
-
-class BOOST_TEST_DECL execution_monitor {
-    typedef boost::unit_test::const_string const_string;
-public:
-
-    /// Default constructor initializes all execution monitor properties
-    execution_monitor();
-
-    /// Should monitor catch system errors.
-    ///
-    /// The @em p_catch_system_errors property is a boolean flag (default value is true) specifying whether or not execution_monitor should trap system
-    /// errors/system level exceptions/signals, which would cause program to crash in a regular case (without execution_monitor).
-    /// Set this property to false, for example, if you wish to force coredump file creation. The Unit Test Framework provides a
-    /// runtime parameter @c \-\-catch_system_errors=yes to alter the behavior in monitored test cases.
-    unit_test::readwrite_property<bool> p_catch_system_errors;
-
-    ///  Should monitor try to attach debugger in case of caught system error.
-    ///
-    /// The @em p_auto_start_dbg property is a boolean flag (default value is false) specifying whether or not execution_monitor should try to attach debugger
-    /// in case system error is caught.
-    unit_test::readwrite_property<bool> p_auto_start_dbg;
-
-
-    ///  Specifies the seconds that elapse before a timer_error occurs.
-    ///
-    /// The @em p_timeout property is an integer timeout (in seconds) for monitored function execution. Use this parameter to monitor code with possible deadlocks
-    /// or indefinite loops. This feature is only available for some operating systems (not yet Microsoft Windows).
-    unit_test::readwrite_property<unsigned>  p_timeout;
-
-    ///  Should monitor use alternative stack for the signal catching.
-    ///
-    /// The @em p_use_alt_stack property is a boolean flag (default value is false) specifying whether or not execution_monitor should use an alternative stack
-    /// for the sigaction based signal catching. When enabled the signals are delivered to the execution_monitor on a stack different from current execution
-    /// stack, which is safer in case if it is corrupted by monitored function. For more details on alternative stack handling see appropriate manuals.
-    unit_test::readwrite_property<bool> p_use_alt_stack;
-
-    /// Should monitor try to detect hardware floating point exceptions (!= 0), and which specific exception to catch.
-    ///
-    /// The @em p_detect_fp_exceptions property is a boolean flag (default value is false) specifying whether or not execution_monitor should install hardware
-    /// traps for the floating point exception on platforms where it's supported.
-    unit_test::readwrite_property<unsigned> p_detect_fp_exceptions;
-
-
-    // @name Monitoring entry points
-
-    /// @brief Execution monitor entry point for functions returning integer value
-    ///
-    /// This method executes supplied function F inside a try/catch block and also may include other unspecified platform dependent error detection code.
-    ///
-    /// This method throws an execution_exception on an uncaught C++ exception, a hardware or software signal, trap, or other user exception.
-    ///
-    /// @note execute() doesn't consider it an error for F to return a non-zero value.
-    /// @param[in] F  Function to monitor
-    /// @returns  value returned by function call F().
-    /// @see vexecute
-    int         execute( boost::function<int ()> const& F );
-
-    /// @brief Execution monitor entry point for functions returning void
-    ///
-    /// This method is semantically identical to execution_monitor::execute, but des't produce any result code.
-    /// @param[in] F  Function to monitor
-    /// @see execute
-    void         vexecute( boost::function<void ()> const& F );
-    // @}
-
-    // @name Exception translator registration
-
-    /// @brief Registers custom (user supplied) exception translator
-
-    /// This method template registers a translator for an exception type specified as a first template argument. For example
-    /// @code
-    ///    void myExceptTr( MyException const& ex ) { /*do something with the exception here*/}
-    ///    em.register_exception_translator<MyException>( myExceptTr );
-    /// @endcode
-    /// The translator should be any unary function/functor object which accepts MyException const&. This can be free standing function
-    /// or bound class method. The second argument is an optional string tag you can associate with this translator routine. The only reason
-    /// to specify the tag is if you plan to erase the translator eventually. This can be useful in scenario when you reuse the same
-    /// execution_monitor instance to monitor different routines and need to register a translator specific to the routine being monitored.
-    /// While it is possible to erase the translator based on an exception type it was registered for, tag string provides simpler way of doing this.
-    /// @tparam ExceptionType type of the exception we register a translator for
-    /// @tparam ExceptionTranslator type of the translator we register for this exception
-    /// @param[in] tr         translator function object with the signature <em> void (ExceptionType const&)</em>
-    /// @param[in] tag        tag associated with this translator
-    template<typename ExceptionType, typename ExceptionTranslator>
-    void        register_exception_translator( ExceptionTranslator const& tr, const_string tag = const_string(), boost::type<ExceptionType>* = 0 );
-
-    /// @brief Erases custom exception translator based on a tag
-
-    /// Use the same tag as the one used during translator registration
-    /// @param[in] tag  tag associated with translator you wants to erase
-    void        erase_exception_translator( const_string tag )
-    {
-        m_custom_translators = m_custom_translators->erase( m_custom_translators, tag );
-    }
-#ifndef BOOST_NO_RTTI
-    /// @brief Erases custom exception translator based on an exception type
-    ///
-    /// tparam ExceptionType Exception type for which you want to erase the translator
-    template<typename ExceptionType>
-    void        erase_exception_translator( boost::type<ExceptionType>* = 0 )
-    {
-        m_custom_translators = m_custom_translators->erase<ExceptionType>( m_custom_translators );
-    }
-    //@}
-#endif
-
-private:
-    // implementation helpers
-    int         catch_signals( boost::function<int ()> const& F );
-
-    // Data members
-    detail::translator_holder_base_ptr  m_custom_translators;
-    boost::scoped_array<char>           m_alt_stack;
-}; // execution_monitor
-
-// ************************************************************************** //
-// **************          detail::translator_holder           ************** //
-// ************************************************************************** //
-
-namespace detail {
-
-template<typename ExceptionType, typename ExceptionTranslator>
-class translator_holder : public translator_holder_base
-{
-public:
-    explicit    translator_holder( ExceptionTranslator const& tr, translator_holder_base_ptr& next, const_string tag = const_string() )
-    : translator_holder_base( next, tag ), m_translator( tr ) {}
-
-    // translator holder interface
-    virtual int operator()( boost::function<int ()> const& F )
-    {
-        BOOST_TEST_I_TRY {
-            return m_next ? (*m_next)( F ) : F();
-        }
-        BOOST_TEST_I_CATCH( ExceptionType, e ) {
-            m_translator( e );
-            return boost::exit_exception_failure;
-        }
-    }
-#ifndef BOOST_NO_RTTI
-    virtual translator_holder_base_ptr erase( translator_holder_base_ptr this_, std::type_info const& ti )
-    {
-        return ti == typeid(ExceptionType) ? m_next : this_;
-    }
-#endif
-
-private:
-    // Data members
-    ExceptionTranslator m_translator;
-};
-
-} // namespace detail
-
-template<typename ExceptionType, typename ExceptionTranslator>
-void
-execution_monitor::register_exception_translator( ExceptionTranslator const& tr, const_string tag, boost::type<ExceptionType>* )
-{
-    m_custom_translators.reset(
-        new detail::translator_holder<ExceptionType,ExceptionTranslator>( tr, m_custom_translators, tag ) );
-}
-
-// ************************************************************************** //
-/// @class execution_aborted
-/// @brief This is a trivial default constructible class. Use it to report graceful abortion of a monitored function execution.
-// ************************************************************************** //
-
-struct execution_aborted {};
-
-// ************************************************************************** //
-// **************                  system_error                ************** //
-// ************************************************************************** //
-
-class system_error {
-public:
-    // Constructor
-    explicit    system_error( char const* exp );
-
-    long const          p_errno;
-    char const* const   p_failed_exp;
-};
-
-//!@internal
-#define BOOST_TEST_SYS_ASSERT( cond ) BOOST_TEST_I_ASSRT( cond, ::boost::system_error( BOOST_STRINGIZE( exp ) ) )
-
-// ************************************************************************** //
-// **************Floating point exception management interface ************** //
-// ************************************************************************** //
-
-namespace fpe {
-
-enum masks {
-    BOOST_FPE_OFF       = 0,
-
-#ifdef BOOST_SEH_BASED_SIGNAL_HANDLING
-    BOOST_FPE_DIVBYZERO = EM_ZERODIVIDE,
-    BOOST_FPE_INEXACT   = EM_INEXACT,
-    BOOST_FPE_INVALID   = EM_INVALID,
-    BOOST_FPE_OVERFLOW  = EM_OVERFLOW,
-    BOOST_FPE_UNDERFLOW = EM_UNDERFLOW|EM_DENORMAL,
-
-    BOOST_FPE_ALL       = MCW_EM,
-#elif defined(BOOST_NO_FENV_H) || defined(BOOST_CLANG)
-    BOOST_FPE_ALL       = 1,
-#else
-    BOOST_FPE_DIVBYZERO = FE_DIVBYZERO,
-    BOOST_FPE_INEXACT   = FE_INEXACT,
-    BOOST_FPE_INVALID   = FE_INVALID,
-    BOOST_FPE_OVERFLOW  = FE_OVERFLOW,
-    BOOST_FPE_UNDERFLOW = FE_UNDERFLOW,
-
-    BOOST_FPE_ALL       = FE_ALL_EXCEPT,
-#endif
-    BOOST_FPE_INV       = BOOST_FPE_ALL+1
-};
-
-//____________________________________________________________________________//
-
-// return the previous set of enabled exceptions when successful, and BOOST_FPE_INV otherwise
-unsigned BOOST_TEST_DECL enable( unsigned mask );
-unsigned BOOST_TEST_DECL disable( unsigned mask );
-
-//____________________________________________________________________________//
-
-} // namespace fpe
-
-///@}
-
-}  // namespace boost
-
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/test/floating_point_comparison.hpp b/contrib/libboost/boost_1_62_0/boost/test/floating_point_comparison.hpp
deleted file mode 100644
index e8892744773..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/floating_point_comparison.hpp
+++ /dev/null
@@ -1,14 +0,0 @@
-//  (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
-//! @brief Deprecated header
-//! @deprecated Use boost/test/tools/floating_point_comparison.hpp instead
-// ***************************************************************************
-
-// Boost.Test
-#include <boost/test/tools/floating_point_comparison.hpp>
diff --git a/contrib/libboost/boost_1_62_0/boost/test/framework.hpp b/contrib/libboost/boost_1_62_0/boost/test/framework.hpp
deleted file mode 100644
index f94bcf125d6..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/framework.hpp
+++ /dev/null
@@ -1,276 +0,0 @@
-//  (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
-//!@brief Defines Unit Test Framework mono-state interfaces.
-//! The framework interfaces are based on Monostate design pattern.
-// ***************************************************************************
-
-#ifndef BOOST_TEST_FRAMEWORK_HPP_020805GER
-#define BOOST_TEST_FRAMEWORK_HPP_020805GER
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/fwd_decl.hpp>
-#include <boost/test/detail/throw_exception.hpp>
-
-#include <boost/test/utils/trivial_singleton.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-// STL
-#include <stdexcept>
-
-//____________________________________________________________________________//
-
-namespace boost {
-
-/// Main namespace for the Unit Test Framework interfaces and implementation
-namespace unit_test {
-
-// ************************************************************************** //
-// **************              init_unit_test_func             ************** //
-// ************************************************************************** //
-
-/// Test module initialization routine signature
-
-/// Different depending on whether BOOST_TEST_ALTERNATIVE_INIT_API is defined or not
-#ifdef BOOST_TEST_ALTERNATIVE_INIT_API
-typedef bool        (*init_unit_test_func)();
-#else
-typedef test_suite* (*init_unit_test_func)( int, char* [] );
-#endif
-
-// ************************************************************************** //
-// **************                   framework                  ************** //
-// ************************************************************************** //
-
-/// Namespace of the Unit Test Framework mono-state
-namespace framework {
-
-/// @name Unit Test Framework initialization and shutdown
-/// @{
-
-/// @brief This function performs initialization of the framework mono-state.
-///
-/// It needs to be called every time before the test is started.
-/// @param[in] init_func test module initialization routine
-/// @param[in] argc command line arguments collection
-/// @param[in] argv command line arguments collection
-BOOST_TEST_DECL void                init( init_unit_test_func init_func, int argc, char* argv[] );
-
-/// This function applies all the decorators and figures out default run status. This argument facilitates an
-/// ability of the test cases to prepare some other test units (primarily used internally for self testing).
-/// @param[in] tu Optional id of the test unit representing root of test tree. If absent, master test suite is used
-BOOST_TEST_DECL void                finalize_setup_phase( test_unit_id tu = INV_TEST_UNIT_ID);
-
-/// This function returns true when testing is in progress (setup is finished).
-BOOST_TEST_DECL bool                test_in_progress();
-
-/// This function shuts down the framework and clears up its mono-state.
-///
-/// It needs to be at the very end of test module execution
-BOOST_TEST_DECL void    shutdown();
-/// @}
-
-/// @name Test unit registration
-/// @{
-
-/// Provides both read and write access to current "leaf" auto test suite during the test unit registration phase.
-///
-/// During auto-registration phase the framework maintain a FIFO queue of test units being registered. New test units become children
-/// of the current "leaf" test suite and if this is test suite it is pushed back into queue and becomes a new leaf.
-/// When test suite registration is completed, a test suite is popped from the back of the queue. Only automatically registered test suites
-/// should be added to this queue. Master test suite is always a zero element in this queue, so if no other test suites are registered
-/// all test cases are added to master test suite.
-
-/// This function facilitates all three possible actions:
-///    - if no argument are provided it returns the current queue leaf test suite
-///    - if test suite is provided and no second argument are set, test suite is added to the queue
-///    - if no test suite are provided and last argument is false, the semantic of this function is similar to queue pop: last element is popped from the queue
-/// @param[in] ts test suite to push back to the queue
-/// @param[in] push_or_pop should we push ts to the queue or pop leaf test suite instead
-/// @returns a reference to the currently active/"leaf" test suite
-BOOST_TEST_DECL test_suite&         current_auto_test_suite( test_suite* ts = 0, bool push_or_pop = true );
-
-/// This function add new test case into the global collection of test units the framework aware of.
-
-/// This function also assignes unique test unit id for every test case. Later on one can use this id to locate
-/// the test case if necessary. This is the way for the framework to maintain weak references between test units.
-/// @param[in]  tc  test case to register
-BOOST_TEST_DECL void                register_test_unit( test_case* tc );
-
-/// This function add new test suite into the global collection of test units the framework aware of.
-
-/// This function also assignes unique test unit id for every test suite. Later on one can use this id to locate
-/// the test case if necessary. This is the way for the framework to maintain weak references between test units.
-/// @param[in]  ts  test suite to register
-BOOST_TEST_DECL void                register_test_unit( test_suite* ts );
-
-/// This function removes the test unit from the collection of known test units and destroys the test unit object.
-
-/// This function also assigns unique test unit id for every test case. Later on one can use this id to located
-/// the test case if necessary. This is the way for the framework to maintain weak references between test units.
-/// @param[in]  tu  test unit to deregister
-BOOST_TEST_DECL void                deregister_test_unit( test_unit* tu );
-
-// This function clears up the framework mono-state.
-
-/// After this call the framework can be reinitialized to perform a second test run during the same program lifetime.
-BOOST_TEST_DECL void                clear();
-/// @}
-
-/// @name Test observer registration
-/// @{
-/// Adds new test execution observer object into the framework's list of test observers.
-
-/// Observer lifetime should exceed the the testing execution timeframe
-/// @param[in]  to  test observer object to add
-BOOST_TEST_DECL void                register_observer( test_observer& to );
-
-/// Excldes the observer object form the framework's list of test observers
-/// @param[in]  to  test observer object to exclude
-BOOST_TEST_DECL void                deregister_observer( test_observer& to );
-
-/// @}
-
-/// @name Assertion/uncaught exception context support
-/// @{
-/// Context accessor
-struct BOOST_TEST_DECL context_generator {
-    context_generator() : m_curr_frame( 0 ) {}
-
-    /// Is there any context?
-    bool            is_empty() const;
-
-    /// Give me next frame; empty - last frame
-    const_string    next() const;
-
-private:
-    // Data members
-    mutable unsigned m_curr_frame;
-};
-
-/// Records context frame message.
-
-/// Some context frames are sticky - they can only explicitly cleared by specifying context id. Other (non sticky) context frames cleared after every assertion.
-/// @param[in] context_descr context frame message
-/// @param[in] sticky is this sticky frame or not
-/// @returns id of the newly created frame
-BOOST_TEST_DECL int                 add_context( lazy_ostream const& context_descr, bool sticky );
-/// Erases context frame (when test exits context scope)
-
-/// If context_id is passed clears that specific context frame identified by this id, otherwise clears all non sticky contexts.
-BOOST_TEST_DECL void                clear_context( int context_id = -1 );
-/// Produces an instance of small "delegate" object, which facilitates access to collected context.
-BOOST_TEST_DECL context_generator   get_context();
-/// @}
-
-/// @name Access to registered test units.
-/// @{
-/// This function provides access to the master test suite.
-
-/// There is only only master test suite per test module.
-/// @returns a reference the master test suite instance
-BOOST_TEST_DECL master_test_suite_t& master_test_suite();
-
-/// This function provides an access to the test case currently being executed.
-
-/// This function is only valid during test execution phase.
-/// @see current_test_case_id
-BOOST_TEST_DECL test_case const&    current_test_case();
-
-/// This function provides an access to an id of the test case currently being executed.
-
-/// This function safer than current_test_case, cause if wont throw if no test case is being executed.
-/// @see current_test_case
-BOOST_TEST_DECL test_unit_id        current_test_case_id(); /* safe version of above */
-
-/// This function provides access to a test unit by id and type combination. It will throw if no test unit located.
-/// @param[in]  tu_id    id of a test unit to locate
-/// @param[in]  tu_type  type of a test unit to locate
-/// @returns located test unit
-BOOST_TEST_DECL test_unit&          get( test_unit_id tu_id, test_unit_type tu_type );
-
-/// This function template provides access to a typed test unit by id
-
-/// It will throw if you specify incorrect test unit type
-/// @tparam UnitType compile time type of test unit to get (test_suite or test_case)
-/// @param  id id of test unit to get
-template<typename UnitType>
-inline UnitType&                    get( test_unit_id id )
-{
-    return static_cast<UnitType&>( get( id, static_cast<test_unit_type>(UnitType::type) ) );
-}
-///@}
-
-/// @name Test initiation interface
-/// @{
-
-/// Initiates test execution
-
-/// This function is used to start the test execution from a specific "root" test unit.
-/// If no root provided, test is started from master test suite. This second argument facilitates an ability of the test cases to
-/// start some other test units (primarily used internally for self testing).
-/// @param[in] tu Optional id of the test unit or test unit itself from which the test is started. If absent, master test suite is used
-/// @param[in] continue_test true == continue test if it was already started, false == restart the test from scratch regardless
-BOOST_TEST_DECL void                run( test_unit_id tu = INV_TEST_UNIT_ID, bool continue_test = true );
-/// Initiates test execution. Same as other overload
-BOOST_TEST_DECL void                run( test_unit const* tu, bool continue_test = true );
-/// @}
-
-/// @name Test events dispatchers
-/// @{
-/// Reports results of assertion to all test observers
-BOOST_TEST_DECL void                assertion_result( unit_test::assertion_result ar );
-/// Reports uncaught exception to all test observers
-BOOST_TEST_DECL void                exception_caught( execution_exception const& );
-/// Reports aborted test unit to all test observers
-BOOST_TEST_DECL void                test_unit_aborted( test_unit const& );
-/// @}
-
-namespace impl {
-// exclusively for self test
-BOOST_TEST_DECL void                setup_for_execution( test_unit const& );
-BOOST_TEST_DECL void                setup_loggers( );
-} // namespace impl
-
-// ************************************************************************** //
-// **************                framework errors              ************** //
-// ************************************************************************** //
-
-/// This exception type is used to report internal Boost.Test framework errors.
-struct BOOST_TEST_DECL internal_error : public std::runtime_error {
-    internal_error( const_string m ) : std::runtime_error( std::string( m.begin(), m.size() ) ) {}
-};
-
-//____________________________________________________________________________//
-
-/// This exception type is used to report test module setup errors.
-struct BOOST_TEST_DECL setup_error : public std::runtime_error {
-    setup_error( const_string m ) : std::runtime_error( std::string( m.begin(), m.size() ) ) {}
-};
-
-#define BOOST_TEST_SETUP_ASSERT( cond, msg ) BOOST_TEST_I_ASSRT( cond, unit_test::framework::setup_error( msg ) )
-
-//____________________________________________________________________________//
-
-struct nothing_to_test {
-    explicit    nothing_to_test( int rc ) : m_result_code( rc ) {}
-
-    int         m_result_code;
-};
-
-//____________________________________________________________________________//
-
-} // namespace framework
-} // unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_FRAMEWORK_HPP_020805GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/impl/compiler_log_formatter.ipp b/contrib/libboost/boost_1_62_0/boost/test/impl/compiler_log_formatter.ipp
deleted file mode 100644
index c5aa6afe932..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/impl/compiler_log_formatter.ipp
+++ /dev/null
@@ -1,290 +0,0 @@
-//  (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 : implements compiler like Log formatter
-// ***************************************************************************
-
-#ifndef BOOST_TEST_COMPILER_LOG_FORMATTER_IPP_020105GER
-#define BOOST_TEST_COMPILER_LOG_FORMATTER_IPP_020105GER
-
-// Boost.Test
-#include <boost/test/output/compiler_log_formatter.hpp>
-
-#include <boost/test/framework.hpp>
-#include <boost/test/execution_monitor.hpp>
-#include <boost/test/unit_test_parameters.hpp>
-
-#include <boost/test/tree/test_unit.hpp>
-
-#include <boost/test/utils/basic_cstring/io.hpp>
-#include <boost/test/utils/lazy_ostream.hpp>
-#include <boost/test/utils/setcolor.hpp>
-
-
-// Boost
-#include <boost/version.hpp>
-
-// STL
-#include <iostream>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace output {
-
-// ************************************************************************** //
-// **************            compiler_log_formatter            ************** //
-// ************************************************************************** //
-
-namespace {
-
-std::string
-test_phase_identifier()
-{
-    return framework::test_in_progress() ? framework::current_test_case().full_name() : std::string( "Test setup" );
-}
-
-} // local namespace
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::log_start( std::ostream& output, counter_t test_cases_amount )
-{
-    m_color_output = runtime_config::get<bool>( runtime_config::COLOR_OUTPUT );
-
-    if( test_cases_amount > 0 )
-        output  << "Running " << test_cases_amount << " test "
-                << (test_cases_amount > 1 ? "cases" : "case") << "...\n";
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::log_finish( std::ostream& ostr )
-{
-    ostr.flush();
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::log_build_info( std::ostream& output )
-{
-    output  << "Platform: " << BOOST_PLATFORM            << '\n'
-            << "Compiler: " << BOOST_COMPILER            << '\n'
-            << "STL     : " << BOOST_STDLIB              << '\n'
-            << "Boost   : " << BOOST_VERSION/100000      << "."
-                            << BOOST_VERSION/100 % 1000  << "."
-                            << BOOST_VERSION % 100       << std::endl;
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::test_unit_start( std::ostream& output, test_unit const& tu )
-{
-    BOOST_TEST_SCOPE_SETCOLOR( m_color_output, output, term_attr::BRIGHT, term_color::BLUE );
-
-    print_prefix( output, tu.p_file_name, tu.p_line_num );
-
-    output << "Entering test " << tu.p_type_name << " \"" << tu.p_name << "\"" << std::endl;
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::test_unit_finish( std::ostream& output, test_unit const& tu, unsigned long elapsed )
-{
-    BOOST_TEST_SCOPE_SETCOLOR( m_color_output, output, term_attr::BRIGHT, term_color::BLUE );
-
-    print_prefix( output, tu.p_file_name, tu.p_line_num );
-
-    output << "Leaving test " << tu.p_type_name << " \"" << tu.p_name << "\"";
-
-    if( elapsed > 0 ) {
-        output << "; testing time: ";
-        if( elapsed % 1000 == 0 )
-            output << elapsed/1000 << "ms";
-        else
-            output << elapsed << "us";
-    }
-
-    output << std::endl;
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::test_unit_skipped( std::ostream& output, test_unit const& tu, const_string reason )
-{
-    BOOST_TEST_SCOPE_SETCOLOR( m_color_output, output, term_attr::BRIGHT, term_color::YELLOW );
-
-    print_prefix( output, tu.p_file_name, tu.p_line_num );
-
-    output  << "Test " << tu.p_type_name << " \"" << tu.full_name() << "\"" << " is skipped because " << reason << std::endl;
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::log_exception_start( std::ostream& output, log_checkpoint_data const& checkpoint_data, execution_exception const& ex )
-{
-    execution_exception::location const& loc = ex.where();
-
-    print_prefix( output, loc.m_file_name, loc.m_line_num );
-
-    {
-        BOOST_TEST_SCOPE_SETCOLOR( m_color_output, output, term_attr::BLINK, term_color::RED );
-
-        output << "fatal error: in \"" << (loc.m_function.is_empty() ? test_phase_identifier() : loc.m_function ) << "\": "
-               << ex.what();
-    }
-
-    if( !checkpoint_data.m_file_name.is_empty() ) {
-        output << '\n';
-        print_prefix( output, checkpoint_data.m_file_name, checkpoint_data.m_line_num );
-
-        BOOST_TEST_SCOPE_SETCOLOR( m_color_output, output, term_attr::BRIGHT, term_color::CYAN );
-
-        output << "last checkpoint";
-        if( !checkpoint_data.m_message.empty() )
-            output << ": " << checkpoint_data.m_message;
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::log_exception_finish( std::ostream& output )
-{
-    output << std::endl;
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::log_entry_start( std::ostream& output, log_entry_data const& entry_data, log_entry_types let )
-{
-    using namespace utils;
-
-    switch( let ) {
-        case BOOST_UTL_ET_INFO:
-            print_prefix( output, entry_data.m_file_name, entry_data.m_line_num );
-            if( m_color_output )
-                output << setcolor( term_attr::BRIGHT, term_color::GREEN );
-            output << "info: ";
-            break;
-        case BOOST_UTL_ET_MESSAGE:
-            if( m_color_output )
-                output << setcolor( term_attr::BRIGHT, term_color::CYAN );
-            break;
-        case BOOST_UTL_ET_WARNING:
-            print_prefix( output, entry_data.m_file_name, entry_data.m_line_num );
-            if( m_color_output )
-                output << setcolor( term_attr::BRIGHT, term_color::YELLOW );
-            output << "warning: in \"" << test_phase_identifier() << "\": ";
-            break;
-        case BOOST_UTL_ET_ERROR:
-            print_prefix( output, entry_data.m_file_name, entry_data.m_line_num );
-            if( m_color_output )
-                output << setcolor( term_attr::BRIGHT, term_color::RED );
-            output << "error: in \"" << test_phase_identifier() << "\": ";
-            break;
-        case BOOST_UTL_ET_FATAL_ERROR:
-            print_prefix( output, entry_data.m_file_name, entry_data.m_line_num );
-            if( m_color_output )
-                output << setcolor( term_attr::BLINK, term_color::RED );
-            output << "fatal error: in \"" << test_phase_identifier() << "\": ";
-            break;
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::log_entry_value( std::ostream& output, const_string value )
-{
-    output << value;
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::log_entry_value( std::ostream& output, lazy_ostream const& value )
-{
-    output << value;
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::log_entry_finish( std::ostream& output )
-{
-    if( m_color_output )
-        output << utils::setcolor();
-
-    output << std::endl;
-}
-
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::print_prefix( std::ostream& output, const_string file_name, std::size_t line_num )
-{
-    if( !file_name.empty() ) {
-#ifdef __APPLE_CC__
-        // Xcode-compatible logging format, idea by Richard Dingwall at
-        // <http://richarddingwall.name/2008/06/01/using-the-boost-unit-test-framework-with-xcode-3/>.
-        output << file_name << ':' << line_num << ": ";
-#else
-        output << file_name << '(' << line_num << "): ";
-#endif
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::entry_context_start( std::ostream& output, log_level l )
-{
-    output << (l == log_successful_tests ? "\nAssertion" : "\nFailure" ) << " occurred in a following context:";
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::entry_context_finish( std::ostream& output )
-{
-    output.flush();
-}
-
-//____________________________________________________________________________//
-
-void
-compiler_log_formatter::log_entry_context( std::ostream& output, const_string context_descr )
-{
-    output << "\n    " << context_descr;
-}
-
-//____________________________________________________________________________//
-
-} // namespace output
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_COMPILER_LOG_FORMATTER_IPP_020105GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/impl/cpp_main.ipp b/contrib/libboost/boost_1_62_0/boost/test/impl/cpp_main.ipp
deleted file mode 100644
index aaa5cabfc51..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/impl/cpp_main.ipp
+++ /dev/null
@@ -1,136 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001.
-//  (C) Copyright Beman Dawes 1995-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 : main function implementation for Program Executon Monitor
-// ***************************************************************************
-
-#ifndef BOOST_TEST_CPP_MAIN_IPP_012205GER
-#define BOOST_TEST_CPP_MAIN_IPP_012205GER
-
-// Boost.Test
-#include <boost/test/execution_monitor.hpp>
-#include <boost/test/detail/config.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp>
-
-// Boost
-#include <boost/cstdlib.hpp>    // for exit codes
-#include <boost/config.hpp>     // for workarounds
-
-// STL
-#include <iostream>
-#include <cstdlib>      // std::getenv
-#include <cstring>      // std::strerror
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-#ifdef BOOST_NO_STDC_NAMESPACE
-namespace std { using ::getenv; using ::strerror; }
-#endif
-
-namespace {
-
-struct cpp_main_caller {
-    cpp_main_caller( int (*cpp_main_func)( int argc, char* argv[] ), int argc, char** argv )
-    : m_cpp_main_func( cpp_main_func )
-    , m_argc( argc )
-    , m_argv( argv ) {}
-
-    int     operator()() { return (*m_cpp_main_func)( m_argc, m_argv ); }
-
-private:
-    // Data members
-    int     (*m_cpp_main_func)( int argc, char* argv[] );
-    int     m_argc;
-    char**  m_argv;
-};
-
-} // local namespace
-
-// ************************************************************************** //
-// **************             prg_exec_monitor_main            ************** //
-// ************************************************************************** //
-
-namespace boost {
-
-int BOOST_TEST_DECL
-prg_exec_monitor_main( int (*cpp_main)( int argc, char* argv[] ), int argc, char* argv[] )
-{
-    int result = 0;
-
-    BOOST_TEST_I_TRY {
-        boost::unit_test::const_string p( std::getenv( "BOOST_TEST_CATCH_SYSTEM_ERRORS" ) );
-        ::boost::execution_monitor ex_mon;
-
-        ex_mon.p_catch_system_errors.value = p != "no";
-
-        result = ex_mon.execute( cpp_main_caller( cpp_main, argc, argv ) );
-
-        if( result == 0 )
-            result = ::boost::exit_success;
-        else if( result != ::boost::exit_success ) {
-            std::cout << "\n**** error return code: " << result << std::endl;
-            result = ::boost::exit_failure;
-        }
-    }
-    BOOST_TEST_I_CATCH( ::boost::execution_exception, exex ) {
-        std::cout << "\n**** exception(" << exex.code() << "): " << exex.what() << std::endl;
-        result = ::boost::exit_exception_failure;
-    }
-    BOOST_TEST_I_CATCH( ::boost::system_error, ex ) {
-        std::cout << "\n**** failed to initialize execution monitor."
-                  << "\n**** expression at fault: " << ex.p_failed_exp
-                  << "\n**** error(" << ex.p_errno << "): " << std::strerror( ex.p_errno ) << std::endl;
-        result = ::boost::exit_exception_failure;
-    }
-
-    if( result != ::boost::exit_success ) {
-        std::cerr << "******** errors detected; see standard output for details ********" << std::endl;
-    }
-    else {
-        //  Some prefer a confirming message when all is well, while others don't
-        //  like the clutter.  Use an environment variable to avoid command
-        //  line argument modifications; for use in production programs
-        //  that's a no-no in some organizations.
-        ::boost::unit_test::const_string p( std::getenv( "BOOST_PRG_MON_CONFIRM" ) );
-        if( p != "no" ) {
-            std::cerr << std::flush << "no errors detected" << std::endl;
-        }
-    }
-
-    return result;
-}
-
-} // namespace boost
-
-#if !defined(BOOST_TEST_DYN_LINK) && !defined(BOOST_TEST_NO_MAIN)
-
-// ************************************************************************** //
-// **************        main function for tests using lib     ************** //
-// ************************************************************************** //
-
-int cpp_main( int argc, char* argv[] );  // prototype for user's cpp_main()
-
-int BOOST_TEST_CALL_DECL
-main( int argc, char* argv[] )
-{
-    return ::boost::prg_exec_monitor_main( &cpp_main, argc, argv );
-}
-
-//____________________________________________________________________________//
-
-#endif // !BOOST_TEST_DYN_LINK && !BOOST_TEST_NO_MAIN
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_CPP_MAIN_IPP_012205GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/impl/debug.ipp b/contrib/libboost/boost_1_62_0/boost/test/impl/debug.ipp
deleted file mode 100644
index f547052ded8..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/impl/debug.ipp
+++ /dev/null
@@ -1,1009 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001.
-//  Use, modification, and distribution are subject to the
-//  Boost Software License, Version 1.0. (See accompanying file
-//  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 : debug interfaces implementation
-// ***************************************************************************
-
-#ifndef BOOST_TEST_DEBUG_API_IPP_112006GER
-#define BOOST_TEST_DEBUG_API_IPP_112006GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/detail/workaround.hpp>
-#include <boost/test/detail/global_typedef.hpp>
-
-#include <boost/test/debug.hpp>
-#include <boost/test/debug_config.hpp>
-
-// Implementation on Windows
-#if defined(_WIN32) && !defined(UNDER_CE) && !defined(BOOST_DISABLE_WIN32) // ******* WIN32
-
-#  define BOOST_WIN32_BASED_DEBUG
-
-// SYSTEM API
-#  include <windows.h>
-#  include <winreg.h>
-#  include <cstdio>
-#  include <cstring>
-
-#  if !defined(NDEBUG) && defined(_MSC_VER)
-#    define BOOST_MS_CRT_BASED_DEBUG
-#    include <crtdbg.h>
-#  endif
-
-
-#  ifdef BOOST_NO_STDC_NAMESPACE
-namespace std { using ::memset; using ::sprintf; }
-#  endif
-
-#elif defined(unix) || defined(__unix) // ********************* UNIX
-
-#  define BOOST_UNIX_BASED_DEBUG
-
-// Boost.Test
-#include <boost/test/utils/class_properties.hpp>
-#include <boost/test/utils/algorithm.hpp>
-
-// STL
-#include <cstring>  // std::memcpy
-#include <map>
-#include <cstdio>
-#include <stdarg.h> // !! ?? cstdarg
-
-// SYSTEM API
-#  include <unistd.h>
-#  include <signal.h>
-#  include <fcntl.h>
-
-#  include <sys/types.h>
-#  include <sys/stat.h>
-#  include <sys/wait.h>
-#  include <sys/time.h>
-#  include <stdio.h>
-#  include <stdlib.h>
-
-#  if defined(sun) || defined(__sun)
-
-#    define BOOST_SUN_BASED_DEBUG
-
-#    ifndef BOOST_TEST_DBG_LIST
-#      define BOOST_TEST_DBG_LIST dbx;gdb
-#    endif
-
-#    define BOOST_TEST_CNL_DBG  dbx
-#    define BOOST_TEST_GUI_DBG  dbx-ddd
-
-#    include <procfs.h>
-
-#  elif defined(linux) || defined(__linux)
-
-#    define BOOST_LINUX_BASED_DEBUG
-
-#    include <sys/ptrace.h>
-
-#    ifndef BOOST_TEST_STAT_LINE_MAX
-#      define BOOST_TEST_STAT_LINE_MAX 500
-#    endif
-
-#    ifndef BOOST_TEST_DBG_LIST
-#      define BOOST_TEST_DBG_LIST gdb
-#    endif
-
-#    define BOOST_TEST_CNL_DBG  gdb
-#    define BOOST_TEST_GUI_DBG  gdb-xterm
-
-#  endif
-
-#endif
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace debug {
-
-using unit_test::const_string;
-
-// ************************************************************************** //
-// **************                debug::info_t                 ************** //
-// ************************************************************************** //
-
-namespace {
-
-#if defined(BOOST_WIN32_BASED_DEBUG) // *********************** WIN32
-
-template<typename T>
-inline void
-dyn_symbol( T& res, char const* module_name, char const* symbol_name )
-{
-    HMODULE m = ::GetModuleHandleA( module_name );
-
-    if( !m )
-        m = ::LoadLibraryA( module_name );
-
-    res = reinterpret_cast<T>( ::GetProcAddress( m, symbol_name ) );
-}
-
-//____________________________________________________________________________//
-
-static struct info_t {
-    typedef BOOL (WINAPI* IsDebuggerPresentT)();
-    typedef LONG (WINAPI* RegQueryValueExT)( HKEY, char const* /*LPTSTR*/, LPDWORD, LPDWORD, LPBYTE, LPDWORD );
-    typedef LONG (WINAPI* RegOpenKeyT)( HKEY, char const* /*LPCTSTR*/, PHKEY );
-    typedef LONG (WINAPI* RegCloseKeyT)( HKEY );
-
-    info_t();
-
-    IsDebuggerPresentT  m_is_debugger_present;
-    RegOpenKeyT         m_reg_open_key;
-    RegQueryValueExT    m_reg_query_value;
-    RegCloseKeyT        m_reg_close_key;
-
-} s_info;
-
-//____________________________________________________________________________//
-
-info_t::info_t()
-{
-    dyn_symbol( m_is_debugger_present, "kernel32", "IsDebuggerPresent" );
-    dyn_symbol( m_reg_open_key, "advapi32", "RegOpenKeyA" );
-    dyn_symbol( m_reg_query_value, "advapi32", "RegQueryValueExA" );
-    dyn_symbol( m_reg_close_key, "advapi32", "RegCloseKey" );
-}
-
-//____________________________________________________________________________//
-
-#elif defined(BOOST_UNIX_BASED_DEBUG)
-
-// ************************************************************************** //
-// **************                   fd_holder                  ************** //
-// ************************************************************************** //
-
-struct fd_holder {
-    explicit fd_holder( int fd ) : m_fd( fd ) {}
-    ~fd_holder()
-    {
-        if( m_fd != -1 )
-            ::close( m_fd );
-    }
-
-    operator int() { return m_fd; }
-
-private:
-    // Data members
-    int m_fd;
-};
-
-
-// ************************************************************************** //
-// **************                 process_info                 ************** //
-// ************************************************************************** //
-
-struct process_info {
-    // Constructor
-    explicit        process_info( int pid );
-
-    // access methods
-    int             parent_pid() const  { return m_parent_pid; }
-    const_string    binary_name() const { return m_binary_name; }
-    const_string    binary_path() const { return m_binary_path; }
-
-private:
-    // Data members
-    int             m_parent_pid;
-    const_string    m_binary_name;
-    const_string    m_binary_path;
-
-#if defined(BOOST_SUN_BASED_DEBUG)
-    struct psinfo   m_psi;
-    char            m_binary_path_buff[500+1]; // !! ??
-#elif defined(BOOST_LINUX_BASED_DEBUG)
-    char            m_stat_line[BOOST_TEST_STAT_LINE_MAX+1];
-    char            m_binary_path_buff[500+1]; // !! ??
-#endif
-};
-
-//____________________________________________________________________________//
-
-process_info::process_info( int pid )
-: m_parent_pid( 0 )
-{
-#if defined(BOOST_SUN_BASED_DEBUG)
-    char fname_buff[30];
-
-    ::snprintf( fname_buff, sizeof(fname_buff), "/proc/%d/psinfo", pid );
-
-    fd_holder psinfo_fd( ::open( fname_buff, O_RDONLY ) );
-
-    if( psinfo_fd == -1 )
-        return;
-
-    if( ::read( psinfo_fd, &m_psi, sizeof(m_psi) ) == -1 )
-        return;
-
-    m_parent_pid = m_psi.pr_ppid;
-
-    m_binary_name.assign( m_psi.pr_fname );
-
-    //-------------------------- //
-
-    ::snprintf( fname_buff, sizeof(fname_buff), "/proc/%d/as", pid );
-
-    fd_holder as_fd( ::open( fname_buff, O_RDONLY ) );
-    uintptr_t   binary_name_pos;
-
-    // !! ?? could we avoid reading whole m_binary_path_buff?
-    if( as_fd == -1 ||
-        ::lseek( as_fd, m_psi.pr_argv, SEEK_SET ) == -1 ||
-        ::read ( as_fd, &binary_name_pos, sizeof(binary_name_pos) ) == -1 ||
-        ::lseek( as_fd, binary_name_pos, SEEK_SET ) == -1 ||
-        ::read ( as_fd, m_binary_path_buff, sizeof(m_binary_path_buff) ) == -1 )
-        return;
-
-    m_binary_path.assign( m_binary_path_buff );
-
-#elif defined(BOOST_LINUX_BASED_DEBUG)
-    char fname_buff[30];
-
-    ::snprintf( fname_buff, sizeof(fname_buff), "/proc/%d/stat", pid );
-
-    fd_holder psinfo_fd( ::open( fname_buff, O_RDONLY ) );
-
-    if( psinfo_fd == -1 )
-        return;
-
-    ssize_t num_read = ::read( psinfo_fd, m_stat_line, sizeof(m_stat_line)-1 );
-    if( num_read == -1 )
-        return;
-
-    m_stat_line[num_read] = 0;
-
-    char const* name_beg = m_stat_line;
-    while( *name_beg && *name_beg != '(' )
-        ++name_beg;
-
-    char const* name_end = name_beg+1;
-    while( *name_end && *name_end != ')' )
-        ++name_end;
-
-    std::sscanf( name_end+1, "%*s%d", &m_parent_pid );
-
-    m_binary_name.assign( name_beg+1, name_end );
-
-    ::snprintf( fname_buff, sizeof(fname_buff), "/proc/%d/exe", pid );
-    num_read = ::readlink( fname_buff, m_binary_path_buff, sizeof(m_binary_path_buff)-1 );
-
-    if( num_read == -1 )
-        return;
-
-    m_binary_path_buff[num_read] = 0;
-    m_binary_path.assign( m_binary_path_buff, num_read );
-#endif
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************             prepare_window_title             ************** //
-// ************************************************************************** //
-
-static char*
-prepare_window_title( dbg_startup_info const& dsi )
-{
-    typedef unit_test::const_string str_t;
-
-    static char title_str[50];
-
-    str_t path_sep( "\\/" );
-
-    str_t::iterator  it = unit_test::utils::find_last_of( dsi.binary_path.begin(), dsi.binary_path.end(),
-                                                          path_sep.begin(), path_sep.end() );
-
-    if( it == dsi.binary_path.end() )
-        it = dsi.binary_path.begin();
-    else
-        ++it;
-
-    ::snprintf( title_str, sizeof(title_str), "%*s %ld", (int)(dsi.binary_path.end()-it), it, dsi.pid );
-
-    return title_str;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                  save_execlp                 ************** //
-// ************************************************************************** //
-
-typedef unit_test::basic_cstring<char> mbuffer;
-
-inline char*
-copy_arg( mbuffer& dest, const_string arg )
-{
-    if( dest.size() < arg.size()+1 )
-        return 0;
-
-    char* res = dest.begin();
-
-    std::memcpy( res, arg.begin(), arg.size()+1 );
-
-    dest.trim_left( arg.size()+1 );
-
-    return res;
-}
-
-//____________________________________________________________________________//
-
-bool
-safe_execlp( char const* file, ... )
-{
-    static char* argv_buff[200];
-
-    va_list     args;
-    char const* arg;
-
-    // first calculate actual number of arguments
-    int         num_args = 2; // file name and 0 at least
-
-    va_start( args, file );
-    while( !!(arg = va_arg( args, char const* )) )
-        num_args++;
-    va_end( args );
-
-    // reserve space for the argument pointers array
-    char**      argv_it  = argv_buff;
-    mbuffer     work_buff( reinterpret_cast<char*>(argv_buff), sizeof(argv_buff) );
-    work_buff.trim_left( num_args * sizeof(char*) );
-
-    // copy all the argument values into local storage
-    if( !(*argv_it++ = copy_arg( work_buff, file )) )
-        return false;
-
-    printf( "!! %s\n", file );
-
-    va_start( args, file );
-    while( !!(arg = va_arg( args, char const* )) ) {
-        printf( "!! %s\n", arg );
-        if( !(*argv_it++ = copy_arg( work_buff, arg )) ) {
-            va_end( args );
-            return false;
-        }
-    }
-    va_end( args );
-
-    *argv_it = 0;
-
-    return ::execvp( file, argv_buff ) != -1;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************            start_debugger_in_emacs           ************** //
-// ************************************************************************** //
-
-static void
-start_debugger_in_emacs( dbg_startup_info const& dsi, char const* emacs_name, char const* dbg_command )
-{
-    char const* title = prepare_window_title( dsi );
-
-    if( !title )
-        return;
-
-    dsi.display.is_empty()
-        ? safe_execlp( emacs_name, "-title", title, "--eval", dbg_command, 0 )
-        : safe_execlp( emacs_name, "-title", title, "-display", dsi.display.begin(), "--eval", dbg_command, 0 );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                 gdb starters                 ************** //
-// ************************************************************************** //
-
-static char const*
-prepare_gdb_cmnd_file( dbg_startup_info const& dsi )
-{
-    // prepare pid value
-    char pid_buff[16];
-    ::snprintf( pid_buff, sizeof(pid_buff), "%ld", dsi.pid );
-    unit_test::const_string pid_str( pid_buff );
-
-    static char cmd_file_name[] = "/tmp/btl_gdb_cmd_XXXXXX"; // !! ??
-
-    // prepare commands
-    fd_holder cmd_fd( ::mkstemp( cmd_file_name ) );
-
-    if( cmd_fd == -1 )
-        return 0;
-
-#define WRITE_STR( str )  if( ::write( cmd_fd, str.begin(), str.size() ) == -1 ) return 0;
-#define WRITE_CSTR( str ) if( ::write( cmd_fd, str, sizeof( str )-1 ) == -1 ) return 0;
-
-    WRITE_CSTR( "file " );
-    WRITE_STR( dsi.binary_path );
-    WRITE_CSTR( "\nattach " );
-    WRITE_STR( pid_str );
-    WRITE_CSTR( "\nshell unlink " );
-    WRITE_STR( dsi.init_done_lock );
-    WRITE_CSTR( "\ncont" );
-    if( dsi.break_or_continue )
-        WRITE_CSTR( "\nup 4" );
-
-    WRITE_CSTR( "\necho \\n" ); // !! ??
-    WRITE_CSTR( "\nlist -" );
-    WRITE_CSTR( "\nlist" );
-    WRITE_CSTR( "\nshell unlink " );
-    WRITE_CSTR( cmd_file_name );
-
-    return cmd_file_name;
-}
-
-//____________________________________________________________________________//
-
-static void
-start_gdb_in_console( dbg_startup_info const& dsi )
-{
-    char const* cmnd_file_name = prepare_gdb_cmnd_file( dsi );
-
-    if( !cmnd_file_name )
-        return;
-
-    safe_execlp( "gdb", "-q", "-x", cmnd_file_name, 0 );
-}
-
-//____________________________________________________________________________//
-
-static void
-start_gdb_in_xterm( dbg_startup_info const& dsi )
-{
-    char const* title           = prepare_window_title( dsi );
-    char const* cmnd_file_name  = prepare_gdb_cmnd_file( dsi );
-
-    if( !title || !cmnd_file_name )
-        return;
-
-    safe_execlp( "xterm", "-T", title, "-display", dsi.display.begin(),
-                    "-bg", "black", "-fg", "white", "-geometry", "88x30+10+10", "-fn", "9x15", "-e",
-                 "gdb", "-q", "-x", cmnd_file_name, 0 );
-}
-
-//____________________________________________________________________________//
-
-static void
-start_gdb_in_emacs( dbg_startup_info const& dsi )
-{
-    char const* cmnd_file_name  = prepare_gdb_cmnd_file( dsi );
-    if( !cmnd_file_name )
-        return;
-
-    char dbg_cmd_buff[500]; // !! ??
-    ::snprintf( dbg_cmd_buff, sizeof(dbg_cmd_buff), "(progn (gdb \"gdb -q -x %s\"))", cmnd_file_name );
-
-    start_debugger_in_emacs( dsi, "emacs", dbg_cmd_buff );
-}
-
-//____________________________________________________________________________//
-
-static void
-start_gdb_in_xemacs( dbg_startup_info const& )
-{
-    // !! ??
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                 dbx starters                 ************** //
-// ************************************************************************** //
-
-static char const*
-prepare_dbx_cmd_line( dbg_startup_info const& dsi, bool list_source = true )
-{
-    static char cmd_line_buff[500]; // !! ??
-
-    ::snprintf( cmd_line_buff, sizeof(cmd_line_buff), "unlink %s;cont;%s%s",
-                   dsi.init_done_lock.begin(),
-                   dsi.break_or_continue ? "up 2;": "",
-                   list_source ? "echo \" \";list -w3;" : "" );
-
-    return cmd_line_buff;
-}
-
-//____________________________________________________________________________//
-
-static void
-start_dbx_in_console( dbg_startup_info const& dsi )
-{
-    char pid_buff[16];
-    ::snprintf( pid_buff, sizeof(pid_buff), "%ld", dsi.pid );
-
-    safe_execlp( "dbx", "-q", "-c", prepare_dbx_cmd_line( dsi ), dsi.binary_path.begin(), pid_buff, 0 );
-}
-
-//____________________________________________________________________________//
-
-static void
-start_dbx_in_xterm( dbg_startup_info const& dsi )
-{
-    char const* title = prepare_window_title( dsi );
-    if( !title )
-        return;
-
-    char pid_buff[16]; // !! ??
-    ::snprintf( pid_buff, sizeof(pid_buff), "%ld", dsi.pid );
-
-    safe_execlp( "xterm", "-T", title, "-display", dsi.display.begin(),
-                    "-bg", "black", "-fg", "white", "-geometry", "88x30+10+10", "-fn", "9x15", "-e",
-                 "dbx", "-q", "-c", prepare_dbx_cmd_line( dsi ), dsi.binary_path.begin(), pid_buff, 0 );
-}
-
-//____________________________________________________________________________//
-
-static void
-start_dbx_in_emacs( dbg_startup_info const& /*dsi*/ )
-{
-//    char dbg_cmd_buff[500]; // !! ??
-//
-//    ::snprintf( dbg_cmd_buff, sizeof(dbg_cmd_buff), "(progn (dbx \"dbx -q -c cont %s %ld\"))", dsi.binary_path.begin(), dsi.pid );
-
-//    start_debugger_in_emacs( dsi, "emacs", dbg_cmd_buff );
-}
-
-//____________________________________________________________________________//
-
-static void
-start_dbx_in_xemacs( dbg_startup_info const& )
-{
-    // !! ??
-}
-
-//____________________________________________________________________________//
-
-static void
-start_dbx_in_ddd( dbg_startup_info const& dsi )
-{
-    char const* title = prepare_window_title( dsi );
-    if( !title )
-        return;
-
-    char pid_buff[16]; // !! ??
-    ::snprintf( pid_buff, sizeof(pid_buff), "%ld", dsi.pid );
-
-    safe_execlp( "ddd", "-display", dsi.display.begin(),
-                 "--dbx", "-q", "-c", prepare_dbx_cmd_line( dsi, false ), dsi.binary_path.begin(), pid_buff, 0 );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                debug::info_t                 ************** //
-// ************************************************************************** //
-
-static struct info_t {
-    // Constructor
-    info_t();
-
-    // Public properties
-    unit_test::readwrite_property<std::string>  p_dbg;
-
-    // Data members
-    std::map<std::string,dbg_starter>           m_dbg_starter_reg;
-} s_info;
-
-//____________________________________________________________________________//
-
-info_t::info_t()
-{
-    p_dbg.value = ::getenv( "DISPLAY" )
-        ? std::string( BOOST_STRINGIZE( BOOST_TEST_GUI_DBG ) )
-        : std::string( BOOST_STRINGIZE( BOOST_TEST_CNL_DBG ) );
-
-    m_dbg_starter_reg[std::string("gdb")]           = &start_gdb_in_console;
-    m_dbg_starter_reg[std::string("gdb-emacs")]     = &start_gdb_in_emacs;
-    m_dbg_starter_reg[std::string("gdb-xterm")]     = &start_gdb_in_xterm;
-    m_dbg_starter_reg[std::string("gdb-xemacs")]    = &start_gdb_in_xemacs;
-
-    m_dbg_starter_reg[std::string("dbx")]           = &start_dbx_in_console;
-    m_dbg_starter_reg[std::string("dbx-emacs")]     = &start_dbx_in_emacs;
-    m_dbg_starter_reg[std::string("dbx-xterm")]     = &start_dbx_in_xterm;
-    m_dbg_starter_reg[std::string("dbx-xemacs")]    = &start_dbx_in_xemacs;
-    m_dbg_starter_reg[std::string("dbx-ddd")]       = &start_dbx_in_ddd;
-}
-
-//____________________________________________________________________________//
-
-#endif
-
-} // local namespace
-
-// ************************************************************************** //
-// **************  check if program is running under debugger  ************** //
-// ************************************************************************** //
-
-bool
-under_debugger()
-{
-#if defined(BOOST_WIN32_BASED_DEBUG) // *********************** WIN32
-
-    return !!s_info.m_is_debugger_present && s_info.m_is_debugger_present();
-
-#elif defined(BOOST_UNIX_BASED_DEBUG) // ********************** UNIX
-
-    // !! ?? could/should we cache the result somehow?
-    const_string    dbg_list = BOOST_TEST_STRINGIZE( BOOST_TEST_DBG_LIST );
-
-    pid_t pid = ::getpid();
-
-    while( pid != 0 ) {
-        process_info pi( pid );
-
-        // !! ?? should we use tokenizer here instead?
-        if( dbg_list.find( pi.binary_name() ) != const_string::npos )
-            return true;
-
-        pid = (pi.parent_pid() == pid ? 0 : pi.parent_pid());
-    }
-
-    return false;
-
-#else // ****************************************************** default
-
-    return false;
-
-#endif
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************       cause program to break execution       ************** //
-// **************           in debugger at call point          ************** //
-// ************************************************************************** //
-
-void
-debugger_break()
-{
-    // !! ?? auto-start debugger?
-
-#if defined(BOOST_WIN32_BASED_DEBUG) // *********************** WIN32
-
-#if defined(__GNUC__) && !defined(__MINGW32__)   ||  \
-    defined(__INTEL_COMPILER)
-#   define BOOST_DEBUG_BREAK    __debugbreak
-#else
-#   define BOOST_DEBUG_BREAK    DebugBreak
-#endif
-
-#ifndef __MINGW32__
-    if( !under_debugger() ) {
-        __try {
-            __try {
-                BOOST_DEBUG_BREAK();
-            }
-            __except( UnhandledExceptionFilter(GetExceptionInformation()) )
-            {
-                // User opted to ignore the breakpoint
-                return;
-            }
-        }
-        __except (EXCEPTION_EXECUTE_HANDLER)
-        {
-            // If we got here, the user has pushed Debug. Debugger is already attached to our process and we
-            // continue to let the another BOOST_DEBUG_BREAK to be called.
-        }
-    }
-#endif
-
-    BOOST_DEBUG_BREAK();
-
-#elif defined(BOOST_UNIX_BASED_DEBUG) // ********************** UNIX
-
-    ::kill( ::getpid(), SIGTRAP );
-
-#else // ****************************************************** default
-
-#endif
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************            console debugger setup            ************** //
-// ************************************************************************** //
-
-#if defined(BOOST_UNIX_BASED_DEBUG) // ************************ UNIX
-
-std::string
-set_debugger( unit_test::const_string dbg_id, dbg_starter s )
-{
-    std::string old = s_info.p_dbg;
-
-    assign_op( s_info.p_dbg.value, dbg_id, 0 );
-
-    if( !!s )
-        s_info.m_dbg_starter_reg[s_info.p_dbg.get()] = s;
-
-    return old;
-}
-
-#else  // ***************************************************** default
-
-std::string
-set_debugger( unit_test::const_string, dbg_starter )
-{
-    return std::string();
-}
-
-#endif
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************    attach debugger to the current process    ************** //
-// ************************************************************************** //
-
-#if defined(BOOST_WIN32_BASED_DEBUG)
-
-struct safe_handle_helper
-{
-    HANDLE& handle;
-    safe_handle_helper(HANDLE &handle_) : handle(handle_) {}
-
-    void close_handle()
-    {
-        if( handle != INVALID_HANDLE_VALUE )
-        {
-            ::CloseHandle( handle );
-            handle = INVALID_HANDLE_VALUE;
-        }
-    }
-
-    ~safe_handle_helper() 
-    {
-        close_handle();
-    }
-};
-#endif
-
-bool
-attach_debugger( bool break_or_continue )
-{
-    if( under_debugger() )
-        return false;
-
-#if defined(BOOST_WIN32_BASED_DEBUG) // *********************** WIN32
-
-    const int MAX_CMD_LINE = 200;
-
-    // *************************************************** //
-    // Debugger "ready" event
-
-    SECURITY_ATTRIBUTES attr;
-    attr.nLength                = sizeof(attr);
-    attr.lpSecurityDescriptor   = NULL;
-    attr.bInheritHandle         = true;
-
-    // manual resettable, initially non signaled, unnamed event,
-    // that will signal me that debugger initialization is done
-    HANDLE dbg_init_done_ev = ::CreateEvent(
-        &attr,          // pointer to security attributes
-        true,           // flag for manual-reset event
-        false,          // flag for initial state
-        NULL            // pointer to event-object name
-    );
-
-    if( !dbg_init_done_ev )
-        return false;
-        
-    safe_handle_helper safe_handle_obj( dbg_init_done_ev );
-
-    // *************************************************** //
-    // Debugger command line format
-
-    HKEY reg_key;
-
-    if( !s_info.m_reg_open_key || (*s_info.m_reg_open_key)(
-            HKEY_LOCAL_MACHINE,                                         // handle of open key
-            "Software\\Microsoft\\Windows NT\\CurrentVersion\\AeDebug", // name of subkey to open
-            &reg_key ) != ERROR_SUCCESS )                               // address of handle of open key
-        return false;
-
-    char  format[MAX_CMD_LINE];
-    DWORD format_size = MAX_CMD_LINE;
-    DWORD type = REG_SZ;
-
-    bool b_read_key = s_info.m_reg_query_value && 
-          ((*s_info.m_reg_query_value)(
-            reg_key,                            // handle of open key
-            "Debugger",                         // name of subkey to query
-            0,                                  // reserved
-            &type,                              // value type
-            (LPBYTE)format,                     // buffer for returned string
-            &format_size ) == ERROR_SUCCESS );  // in: buffer size; out: actual size of returned string
-
-    if( !s_info.m_reg_close_key || (*s_info.m_reg_close_key)( reg_key ) != ERROR_SUCCESS )
-        return false;
-        
-    if( !b_read_key )
-        return false;
-
-    // *************************************************** //
-    // Debugger command line
-
-    char cmd_line[MAX_CMD_LINE];
-    std::sprintf( cmd_line, format, ::GetCurrentProcessId(), dbg_init_done_ev );
-
-    // *************************************************** //
-    // Debugger window parameters
-
-    STARTUPINFOA    startup_info;
-    std::memset( &startup_info, 0, sizeof(startup_info) );
-
-    startup_info.cb             = sizeof(startup_info);
-    startup_info.dwFlags        = STARTF_USESHOWWINDOW;
-    startup_info.wShowWindow    = SW_SHOWNORMAL;
-
-    // debugger process s_info
-    PROCESS_INFORMATION debugger_info;
-
-    bool created = !!::CreateProcessA(
-        NULL,           // pointer to name of executable module; NULL - use the one in command line
-        cmd_line,       // pointer to command line string
-        NULL,           // pointer to process security attributes; NULL - debugger's handle can't be inherited
-        NULL,           // pointer to thread security attributes; NULL - debugger's handle can't be inherited
-        true,           // debugger inherit opened handles
-        0,              // priority flags; 0 - normal priority
-        NULL,           // pointer to new environment block; NULL - use this process environment
-        NULL,           // pointer to current directory name; NULL - use this process correct directory
-        &startup_info,  // pointer to STARTUPINFO that specifies main window appearance
-        &debugger_info  // pointer to PROCESS_INFORMATION that will contain the new process identification
-    );
-
-    bool debugger_run_ok = false;
-    if( created )
-    {
-        DWORD ret_code = ::WaitForSingleObject( dbg_init_done_ev, INFINITE );
-        debugger_run_ok = ( ret_code == WAIT_OBJECT_0 );
-    }
-
-    safe_handle_obj.close_handle();
-
-    if( !created || !debugger_run_ok )
-        return false;
-
-    if( break_or_continue )
-        debugger_break();
-
-    return true;
-
-#elif defined(BOOST_UNIX_BASED_DEBUG) // ********************** UNIX
-
-    char init_done_lock_fn[] = "/tmp/btl_dbg_init_done_XXXXXX";
-    fd_holder init_done_lock_fd( ::mkstemp( init_done_lock_fn ) );
-
-    if( init_done_lock_fd == -1 )
-        return false;
-
-    pid_t child_pid = fork();
-
-    if( child_pid == -1 )
-        return false;
-
-    if( child_pid != 0 ) { // parent process - here we will start the debugger
-        dbg_startup_info dsi;
-
-        process_info pi( child_pid );
-        if( pi.binary_path().is_empty() )
-            ::exit( -1 );
-
-        dsi.pid                 = child_pid;
-        dsi.break_or_continue   = break_or_continue;
-        dsi.binary_path         = pi.binary_path();
-        dsi.display             = ::getenv( "DISPLAY" );
-        dsi.init_done_lock      = init_done_lock_fn;
-
-        dbg_starter starter = s_info.m_dbg_starter_reg[s_info.p_dbg];
-        if( !!starter )
-            starter( dsi );
-
-        ::perror( "Boost.Test execution monitor failed to start a debugger:" );
-
-        ::exit( -1 );
-    }
-
-    // child process - here we will continue our test module execution ; // !! ?? should it be vice versa
-
-    while( ::access( init_done_lock_fn, F_OK ) == 0 ) {
-        struct timeval to = { 0, 100 };
-
-        ::select( 0, 0, 0, 0, &to );
-    }
-
-//    char dummy;
-//    while( ::read( init_done_lock_fd, &dummy, sizeof(char) ) == 0 );
-
-    if( break_or_continue )
-        debugger_break();
-
-    return true;
-
-#else // ****************************************************** default
-
-    return false;
-
-#endif
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************   switch on/off detect memory leaks feature  ************** //
-// ************************************************************************** //
-
-void
-detect_memory_leaks( bool on_off, unit_test::const_string report_file )
-{
-    unit_test::ut_detail::ignore_unused_variable_warning( on_off );
-
-#ifdef BOOST_MS_CRT_BASED_DEBUG
-    int flags = _CrtSetDbgFlag( _CRTDBG_REPORT_FLAG );
-
-    if( !on_off )
-        flags &= ~_CRTDBG_LEAK_CHECK_DF;
-    else  {
-        flags |= _CRTDBG_LEAK_CHECK_DF;
-        _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
-
-        if( report_file.is_empty() )
-            _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
-        else {
-            HANDLE hreport_f = ::CreateFileA( report_file.begin(),
-                                              GENERIC_WRITE, FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
-            _CrtSetReportFile(_CRT_WARN, hreport_f );
-        }
-    }
-
-    _CrtSetDbgFlag ( flags );
-#else
-    unit_test::ut_detail::ignore_unused_variable_warning( report_file );
-#endif // BOOST_MS_CRT_BASED_DEBUG
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************      cause program to break execution in     ************** //
-// **************     debugger at specific allocation point    ************** //
-// ************************************************************************** //
-
-void
-break_memory_alloc( long mem_alloc_order_num )
-{
-    unit_test::ut_detail::ignore_unused_variable_warning( mem_alloc_order_num );
-
-#ifdef BOOST_MS_CRT_BASED_DEBUG
-    // only set the value if one was supplied (do not use default used by UTF just as a indicator to enable leak detection)
-    if( mem_alloc_order_num > 1 )
-        _CrtSetBreakAlloc( mem_alloc_order_num );
-#endif // BOOST_MS_CRT_BASED_DEBUG
-}
-
-//____________________________________________________________________________//
-
-} // namespace debug
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_DEBUG_API_IPP_112006GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/impl/decorator.ipp b/contrib/libboost/boost_1_62_0/boost/test/impl/decorator.ipp
deleted file mode 100644
index 74d42b22a25..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/impl/decorator.ipp
+++ /dev/null
@@ -1,202 +0,0 @@
-//  (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 : unit test decorators implementation
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TREE_DECORATOR_IPP_091911GER
-#define BOOST_TEST_TREE_DECORATOR_IPP_091911GER
-
-// Boost.Test
-#include <boost/test/tree/decorator.hpp>
-#include <boost/test/tree/test_unit.hpp>
-
-#include <boost/test/framework.hpp>
-#if BOOST_TEST_SUPPORT_TOKEN_ITERATOR
-#include <boost/test/utils/iterator/token_iterator.hpp>
-#endif
-
-#include <boost/test/detail/throw_exception.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace decorator {
-
-// ************************************************************************** //
-// **************             decorator::collector             ************** //
-// ************************************************************************** //
-
-collector&
-collector::operator*( base const& d )
-{
-    m_tu_decorators.push_back( d.clone() );
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-void
-collector::store_in( test_unit& tu )
-{
-    tu.p_decorators.value.insert( tu.p_decorators.value.end(), m_tu_decorators.begin(), m_tu_decorators.end() );
-}
-
-//____________________________________________________________________________//
-
-void
-collector::reset()
-{
-    m_tu_decorators.clear();
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               decorator::base                ************** //
-// ************************************************************************** //
-
-collector&
-base::operator*() const
-{
-    return collector::instance() * *this;
-}
-
-// ************************************************************************** //
-// **************               decorator::label               ************** //
-// ************************************************************************** //
-
-void
-label::apply( test_unit& tu )
-{
-    tu.add_label( m_label );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************         decorator::expected_failures         ************** //
-// ************************************************************************** //
-
-void
-expected_failures::apply( test_unit& tu )
-{
-    tu.increase_exp_fail( m_exp_fail );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************              decorator::timeout              ************** //
-// ************************************************************************** //
-
-void
-timeout::apply( test_unit& tu )
-{
-    tu.p_timeout.value = m_timeout;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************            decorator::description            ************** //
-// ************************************************************************** //
-
-void
-description::apply( test_unit& tu )
-{
-    tu.p_description.value += m_description;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************             decorator::depends_on            ************** //
-// ************************************************************************** //
-
-void
-depends_on::apply( test_unit& tu )
-{
-#if !BOOST_TEST_SUPPORT_TOKEN_ITERATOR
-    BOOST_TEST_SETUP_ASSERT( false, "depends_on decorator is not supported on this platform" );
-#else
-    utils::string_token_iterator tit( m_dependency, (utils::dropped_delimeters = "/", utils::kept_delimeters = utils::dt_none) );
-
-    test_unit* dep = &framework::master_test_suite();
-    while( tit != utils::string_token_iterator() ) {
-        BOOST_TEST_SETUP_ASSERT( dep->p_type == TUT_SUITE, std::string( "incorrect dependency specification " ) + m_dependency );
-
-        test_unit_id next_id = static_cast<test_suite*>(dep)->get( *tit );
-
-        BOOST_TEST_SETUP_ASSERT( next_id != INV_TEST_UNIT_ID,
-                                 std::string( "incorrect dependency specification " ) + m_dependency );
-
-        dep = &framework::get( next_id, TUT_ANY );
-        ++tit;
-    }
-
-    tu.depends_on( dep );
-#endif
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************    decorator::enable_if/enabled/disabled     ************** //
-// ************************************************************************** //
-
-void
-enable_if_impl::apply_impl( test_unit& tu, bool condition )
-{
-    BOOST_TEST_SETUP_ASSERT(tu.p_default_status == test_unit::RS_INHERIT,
-                            "Can't apply multiple enabled/disabled decorators "
-                            "to the same test unit " + tu.full_name());
-
-    tu.p_default_status.value = condition ? test_unit::RS_ENABLED : test_unit::RS_DISABLED;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************              decorator::fixture              ************** //
-// ************************************************************************** //
-
-void
-fixture_t::apply( test_unit& tu )
-{
-    tu.p_fixtures.value.push_back( m_impl );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************            decorator::depends_on             ************** //
-// ************************************************************************** //
-
-void
-precondition::apply( test_unit& tu )
-{
-    tu.add_precondition( m_precondition );
-}
-
-//____________________________________________________________________________//
-
-} // namespace decorator
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TREE_DECORATOR_IPP_091911GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/impl/execution_monitor.ipp b/contrib/libboost/boost_1_62_0/boost/test/impl/execution_monitor.ipp
deleted file mode 100644
index ce6c6c7eb9a..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/impl/execution_monitor.ipp
+++ /dev/null
@@ -1,1436 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001.
-//  (C) Copyright Beman Dawes and Ullrich Koethe 1995-2001.
-//  Use, modification, and distribution are subject to the
-//  Boost Software License, Version 1.0. (See accompanying file
-//  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 : provides execution monitor implementation for all supported
-//  configurations, including Microsoft structured exception based, unix signals
-//  based and special workarounds for borland
-//
-//  Note that when testing requirements or user wishes preclude use of this
-//  file as a separate compilation unit, it may be included as a header file.
-//
-//  Header dependencies are deliberately restricted to reduce coupling to other
-//  boost libraries.
-// ***************************************************************************
-
-#ifndef BOOST_TEST_EXECUTION_MONITOR_IPP_012205GER
-#define BOOST_TEST_EXECUTION_MONITOR_IPP_012205GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/detail/workaround.hpp>
-#include <boost/test/detail/throw_exception.hpp>
-#include <boost/test/execution_monitor.hpp>
-#include <boost/test/debug.hpp>
-
-// Boost
-#include <boost/cstdlib.hpp>    // for exit codes
-#include <boost/config.hpp>     // for workarounds
-#include <boost/core/ignore_unused.hpp> // for ignore_unused
-#ifndef BOOST_NO_EXCEPTION
-#include <boost/exception/get_error_info.hpp> // for get_error_info
-#include <boost/exception/current_exception_cast.hpp> // for current_exception_cast
-#endif
-
-// STL
-#include <string>               // for std::string
-#include <new>                  // for std::bad_alloc
-#include <typeinfo>             // for std::bad_cast, std::bad_typeid
-#include <exception>            // for std::exception, std::bad_exception
-#include <stdexcept>            // for std exception hierarchy
-#include <cstring>              // for C string API
-#include <cassert>              // for assert
-#include <cstddef>              // for NULL
-#include <cstdio>               // for vsnprintf
-#include <cstdarg>              // for varargs
-
-#include <iostream>              // for varargs
-
-#ifdef BOOST_NO_STDC_NAMESPACE
-namespace std { using ::strerror; using ::strlen; using ::strncat; }
-#endif
-
-// to use vsnprintf
-#if defined(__SUNPRO_CC) || defined(__SunOS)
-#  include <stdio.h>
-#  include <stdarg.h>
-using std::va_list;
-#endif
-
-// to use vsnprintf
-#if defined(__QNXNTO__)
-#  include <stdio.h>
-using std::va_list;
-#endif
-
-#ifdef BOOST_SEH_BASED_SIGNAL_HANDLING
-#  include <windows.h>
-
-#  if defined(__MWERKS__) || (defined(_MSC_VER) && !defined(UNDER_CE))
-#    include <eh.h>
-#  endif
-
-#  if defined(__BORLANDC__) && __BORLANDC__ >= 0x560 || defined(__MWERKS__)
-#    include <stdint.h>
-#  endif
-
-#  if defined(__BORLANDC__) && __BORLANDC__ < 0x560
-    typedef unsigned uintptr_t;
-#  endif
-
-#  if defined(UNDER_CE) && BOOST_WORKAROUND(_MSC_VER,  < 1500 )
-   typedef void* uintptr_t;
-#  elif defined(UNDER_CE)
-#  include <crtdefs.h>
-#  endif
-
-#  if !defined(NDEBUG) && defined(_MSC_VER) && !defined(UNDER_CE)
-#    include <crtdbg.h>
-#    define BOOST_TEST_CRT_HOOK_TYPE    _CRT_REPORT_HOOK
-#    define BOOST_TEST_CRT_ASSERT       _CRT_ASSERT
-#    define BOOST_TEST_CRT_ERROR        _CRT_ERROR
-#    define BOOST_TEST_CRT_SET_HOOK(H)  _CrtSetReportHook(H)
-#  else
-#    define BOOST_TEST_CRT_HOOK_TYPE    void*
-#    define BOOST_TEST_CRT_ASSERT       2
-#    define BOOST_TEST_CRT_ERROR        1
-#    define BOOST_TEST_CRT_SET_HOOK(H)  (void*)(H)
-#  endif
-
-#  if (!BOOST_WORKAROUND(_MSC_VER,  >= 1400 ) && \
-      !defined(BOOST_COMO)) || defined(UNDER_CE)
-
-typedef void* _invalid_parameter_handler;
-
-inline _invalid_parameter_handler
-_set_invalid_parameter_handler( _invalid_parameter_handler arg )
-{
-    return arg;
-}
-
-#  endif
-
-#  if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0564)) || defined(UNDER_CE)
-
-namespace { void _set_se_translator( void* ) {} }
-
-#  endif
-
-#elif defined(BOOST_HAS_SIGACTION)
-
-#  define BOOST_SIGACTION_BASED_SIGNAL_HANDLING
-
-#  include <unistd.h>
-#  include <signal.h>
-#  include <setjmp.h>
-
-#  if defined(__FreeBSD__)
-
-#    include <osreldate.h>
-
-#    ifndef SIGPOLL
-#      define SIGPOLL SIGIO
-#    endif
-
-#    if (__FreeBSD_version < 70100)
-
-#      define ILL_ILLADR 0 // ILL_RESAD_FAULT
-#      define ILL_PRVOPC ILL_PRIVIN_FAULT
-#      define ILL_ILLOPN 2 // ILL_RESOP_FAULT
-#      define ILL_COPROC ILL_FPOP_FAULT
-
-#      define BOOST_TEST_LIMITED_SIGNAL_DETAILS
-
-#    endif
-#  endif
-
-#  if defined(__ANDROID__)
-#    include <android/api-level.h>
-#  endif
-
-// documentation of BOOST_TEST_DISABLE_ALT_STACK in execution_monitor.hpp
-#  if !defined(__CYGWIN__) && !defined(__QNXNTO__) && !defined(__bgq__) && \
-   (!defined(__ANDROID__) || __ANDROID_API__ >= 8) && \
-   !defined(BOOST_TEST_DISABLE_ALT_STACK)
-#    define BOOST_TEST_USE_ALT_STACK
-#  endif
-
-#  if defined(SIGPOLL) && !defined(__CYGWIN__)                              && \
-      !(defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__))  && \
-      !defined(__NetBSD__)                                                  && \
-      !defined(__QNXNTO__)
-#    define BOOST_TEST_CATCH_SIGPOLL
-#  endif
-
-#  ifdef BOOST_TEST_USE_ALT_STACK
-#    define BOOST_TEST_ALT_STACK_SIZE SIGSTKSZ
-#  endif
-
-
-#else
-
-#  define BOOST_NO_SIGNAL_HANDLING
-
-#endif
-
-#ifndef UNDER_CE
-#include <errno.h>
-#endif
-
-#if !defined(BOOST_NO_TYPEID) && !defined(BOOST_NO_RTTI)
-#  include <boost/core/demangle.hpp>
-#endif
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-
-// ************************************************************************** //
-// **************                 throw_exception              ************** //
-// ************************************************************************** //
-
-#ifdef BOOST_NO_EXCEPTION
-void throw_exception( std::exception const & e ) { abort(); }
-#endif
-
-// ************************************************************************** //
-// **************                  report_error                ************** //
-// ************************************************************************** //
-
-namespace detail {
-
-#ifdef __BORLANDC__
-#  define BOOST_TEST_VSNPRINTF( a1, a2, a3, a4 ) std::vsnprintf( (a1), (a2), (a3), (a4) )
-#elif BOOST_WORKAROUND(_MSC_VER, <= 1310) || \
-      BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3000)) || \
-      defined(UNDER_CE)
-#  define BOOST_TEST_VSNPRINTF( a1, a2, a3, a4 ) _vsnprintf( (a1), (a2), (a3), (a4) )
-#else
-#  define BOOST_TEST_VSNPRINTF( a1, a2, a3, a4 ) vsnprintf( (a1), (a2), (a3), (a4) )
-#endif
-
-#ifndef BOOST_NO_EXCEPTION
-
-template <typename ErrorInfo>
-typename ErrorInfo::value_type
-extract( boost::exception const* ex )
-{
-    if( !ex )
-        return 0;
-
-    typename ErrorInfo::value_type const * val = boost::get_error_info<ErrorInfo>( *ex );
-
-    return val ? *val : 0;
-}
-
-//____________________________________________________________________________//
-
-static void
-report_error( execution_exception::error_code ec, boost::exception const* be, char const* format, va_list* args )
-{
-    static const int REPORT_ERROR_BUFFER_SIZE = 4096;
-    static char buf[REPORT_ERROR_BUFFER_SIZE];
-
-    BOOST_TEST_VSNPRINTF( buf, sizeof(buf)-1, format, *args );
-    buf[sizeof(buf)-1] = 0;
-
-    va_end( *args );
-
-    BOOST_TEST_I_THROW(execution_exception( ec, buf, execution_exception::location( extract<throw_file>( be ),
-                                                                                    (size_t)extract<throw_line>( be ),
-                                                                                    extract<throw_function>( be ) ) ));
-}
-
-//____________________________________________________________________________//
-
-static void
-report_error( execution_exception::error_code ec, boost::exception const* be, char const* format, ... )
-{
-    va_list args;
-    va_start( args, format );
-
-    report_error( ec, be, format, &args );
-}
-
-#endif
-
-//____________________________________________________________________________//
-
-static void
-report_error( execution_exception::error_code ec, char const* format, ... )
-{
-    va_list args;
-    va_start( args, format );
-
-    report_error( ec, 0, format, &args );
-}
-
-//____________________________________________________________________________//
-
-template<typename Tr,typename Functor>
-inline int
-do_invoke( Tr const& tr, Functor const& F )
-{
-    return tr ? (*tr)( F ) : F();
-}
-
-//____________________________________________________________________________//
-
-struct fpe_except_guard {
-    explicit fpe_except_guard( unsigned detect_fpe )
-    : m_detect_fpe( detect_fpe )
-    {
-        // prepare fp exceptions control
-        m_previosly_enabled = fpe::disable( fpe::BOOST_FPE_ALL );
-        if( m_previosly_enabled != fpe::BOOST_FPE_INV && detect_fpe != fpe::BOOST_FPE_OFF )
-            fpe::enable( detect_fpe );
-    }
-    ~fpe_except_guard()
-    {
-        if( m_detect_fpe != fpe::BOOST_FPE_OFF )
-            fpe::disable( m_detect_fpe );
-        if( m_previosly_enabled != fpe::BOOST_FPE_INV )
-            fpe::enable( m_previosly_enabled );
-    }
-
-    unsigned m_detect_fpe;
-    unsigned m_previosly_enabled;
-};
-
-
-// ************************************************************************** //
-// **************                  typeid_name                 ************** //
-// ************************************************************************** //
-
-#if !defined(BOOST_NO_TYPEID) && !defined(BOOST_NO_RTTI)
-template<typename T>
-std::string
-typeid_name( T const& t )
-{
-    return boost::core::demangle(typeid(t).name());
-}
-#endif
-
-} // namespace detail
-
-#if defined(BOOST_SIGACTION_BASED_SIGNAL_HANDLING)
-
-// ************************************************************************** //
-// **************       Sigaction based signal handling        ************** //
-// ************************************************************************** //
-
-namespace detail {
-
-// ************************************************************************** //
-// **************    boost::detail::system_signal_exception    ************** //
-// ************************************************************************** //
-
-class system_signal_exception {
-public:
-    // Constructor
-    system_signal_exception()
-    : m_sig_info( 0 )
-    , m_context( 0 )
-    {}
-
-    // Access methods
-    void        operator()( siginfo_t* i, void* c )
-    {
-        m_sig_info  = i;
-        m_context   = c;
-    }
-    void        report() const;
-
-private:
-    // Data members
-    siginfo_t*  m_sig_info; // system signal detailed info
-    void*       m_context;  // signal context
-};
-
-//____________________________________________________________________________//
-
-void
-system_signal_exception::report() const
-{
-    if( !m_sig_info )
-        return; // no error actually occur?
-
-    switch( m_sig_info->si_code ) {
-    case SI_USER:
-        report_error( execution_exception::system_error,
-                      "signal: generated by kill() (or family); uid=%d; pid=%d",
-                      (int)m_sig_info->si_uid, (int)m_sig_info->si_pid );
-        break;
-    case SI_QUEUE:
-        report_error( execution_exception::system_error,
-                      "signal: sent by sigqueue()" );
-        break;
-    case SI_TIMER:
-        report_error( execution_exception::system_error,
-                      "signal: the expiration of a timer set by timer_settimer()" );
-        break;
-    case SI_ASYNCIO:
-        report_error( execution_exception::system_error,
-                      "signal: generated by the completion of an asynchronous I/O request" );
-        break;
-    case SI_MESGQ:
-        report_error( execution_exception::system_error,
-                      "signal: generated by the the arrival of a message on an empty message queue" );
-        break;
-    default:
-        break;
-    }
-
-    switch( m_sig_info->si_signo ) {
-    case SIGILL:
-        switch( m_sig_info->si_code ) {
-#ifndef BOOST_TEST_LIMITED_SIGNAL_DETAILS
-        case ILL_ILLOPC:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: illegal opcode; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case ILL_ILLTRP:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: illegal trap; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case ILL_PRVREG:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: privileged register; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case ILL_BADSTK:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: internal stack error; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-#endif
-        case ILL_ILLOPN:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: illegal operand; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case ILL_ILLADR:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: illegal addressing mode; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case ILL_PRVOPC:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: privileged opcode; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case ILL_COPROC:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: co-processor error; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        default:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: SIGILL, si_code: %d (illegal instruction; address of failing instruction: 0x%08lx)",
-                          m_sig_info->si_addr, m_sig_info->si_code );
-            break;
-        }
-        break;
-
-    case SIGFPE:
-        switch( m_sig_info->si_code ) {
-        case FPE_INTDIV:
-            report_error( execution_exception::system_error,
-                          "signal: integer divide by zero; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case FPE_INTOVF:
-            report_error( execution_exception::system_error,
-                          "signal: integer overflow; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case FPE_FLTDIV:
-            report_error( execution_exception::system_error,
-                          "signal: floating point divide by zero; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case FPE_FLTOVF:
-            report_error( execution_exception::system_error,
-                          "signal: floating point overflow; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case FPE_FLTUND:
-            report_error( execution_exception::system_error,
-                          "signal: floating point underflow; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case FPE_FLTRES:
-            report_error( execution_exception::system_error,
-                          "signal: floating point inexact result; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case FPE_FLTINV:
-            report_error( execution_exception::system_error,
-                          "signal: invalid floating point operation; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        case FPE_FLTSUB:
-            report_error( execution_exception::system_error,
-                          "signal: subscript out of range; address of failing instruction: 0x%08lx",
-                          m_sig_info->si_addr );
-            break;
-        default:
-            report_error( execution_exception::system_error,
-                          "signal: SIGFPE, si_code: %d (errnoneous arithmetic operations; address of failing instruction: 0x%08lx)",
-                          m_sig_info->si_addr, m_sig_info->si_code );
-            break;
-        }
-        break;
-
-    case SIGSEGV:
-        switch( m_sig_info->si_code ) {
-#ifndef BOOST_TEST_LIMITED_SIGNAL_DETAILS
-        case SEGV_MAPERR:
-            report_error( execution_exception::system_fatal_error,
-                          "memory access violation at address: 0x%08lx: no mapping at fault address",
-                          m_sig_info->si_addr );
-            break;
-        case SEGV_ACCERR:
-            report_error( execution_exception::system_fatal_error,
-                          "memory access violation at address: 0x%08lx: invalid permissions",
-                          m_sig_info->si_addr );
-            break;
-#endif
-        default:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: SIGSEGV, si_code: %d (memory access violation at address: 0x%08lx)",
-                          m_sig_info->si_addr, m_sig_info->si_code );
-            break;
-        }
-        break;
-
-    case SIGBUS:
-        switch( m_sig_info->si_code ) {
-#ifndef BOOST_TEST_LIMITED_SIGNAL_DETAILS
-        case BUS_ADRALN:
-            report_error( execution_exception::system_fatal_error,
-                          "memory access violation at address: 0x%08lx: invalid address alignment",
-                          m_sig_info->si_addr );
-            break;
-        case BUS_ADRERR:
-            report_error( execution_exception::system_fatal_error,
-                          "memory access violation at address: 0x%08lx: non-existent physical address",
-                          m_sig_info->si_addr );
-            break;
-        case BUS_OBJERR:
-            report_error( execution_exception::system_fatal_error,
-                          "memory access violation at address: 0x%08lx: object specific hardware error",
-                          m_sig_info->si_addr );
-            break;
-#endif
-        default:
-            report_error( execution_exception::system_fatal_error,
-                          "signal: SIGSEGV, si_code: %d (memory access violation at address: 0x%08lx)",
-                          m_sig_info->si_addr, m_sig_info->si_code );
-            break;
-        }
-        break;
-
-#if defined(BOOST_TEST_CATCH_SIGPOLL)
-
-    case SIGPOLL:
-        switch( m_sig_info->si_code ) {
-#ifndef BOOST_TEST_LIMITED_SIGNAL_DETAILS
-        case POLL_IN:
-            report_error( execution_exception::system_error,
-                          "data input available; band event %d",
-                          (int)m_sig_info->si_band );
-            break;
-        case POLL_OUT:
-            report_error( execution_exception::system_error,
-                          "output buffers available; band event %d",
-                          (int)m_sig_info->si_band );
-            break;
-        case POLL_MSG:
-            report_error( execution_exception::system_error,
-                          "input message available; band event %d",
-                          (int)m_sig_info->si_band );
-            break;
-        case POLL_ERR:
-            report_error( execution_exception::system_error,
-                          "i/o error; band event %d",
-                          (int)m_sig_info->si_band );
-            break;
-        case POLL_PRI:
-            report_error( execution_exception::system_error,
-                          "high priority input available; band event %d",
-                          (int)m_sig_info->si_band );
-            break;
-#if defined(POLL_ERR) && defined(POLL_HUP) && (POLL_ERR - POLL_HUP)
-        case POLL_HUP:
-            report_error( execution_exception::system_error,
-                          "device disconnected; band event %d",
-                          (int)m_sig_info->si_band );
-            break;
-#endif
-#endif
-        default:
-            report_error( execution_exception::system_error,
-                          "signal: SIGPOLL, si_code: %d (asynchronous I/O event occurred; band event %d)",
-                          (int)m_sig_info->si_band, m_sig_info->si_code );
-            break;
-        }
-        break;
-
-#endif
-
-    case SIGABRT:
-        report_error( execution_exception::system_error,
-                      "signal: SIGABRT (application abort requested)" );
-        break;
-
-    case SIGALRM:
-        report_error( execution_exception::timeout_error,
-                      "signal: SIGALRM (timeout while executing function)" );
-        break;
-
-    default:
-        report_error( execution_exception::system_error,
-                      "unrecognized signal %d", m_sig_info->si_signo );
-    }
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************         boost::detail::signal_action         ************** //
-// ************************************************************************** //
-
-// Forward declaration
-extern "C" {
-static void boost_execution_monitor_jumping_signal_handler( int sig, siginfo_t* info, void* context );
-static void boost_execution_monitor_attaching_signal_handler( int sig, siginfo_t* info, void* context );
-}
-
-class signal_action {
-    typedef struct sigaction* sigaction_ptr;
-public:
-    //Constructor
-    signal_action();
-    signal_action( int sig, bool install, bool attach_dbg, char* alt_stack );
-    ~signal_action();
-
-private:
-    // Data members
-    int                 m_sig;
-    bool                m_installed;
-    struct sigaction    m_new_action;
-    struct sigaction    m_old_action;
-};
-
-//____________________________________________________________________________//
-
-signal_action::signal_action()
-: m_installed( false )
-{}
-
-//____________________________________________________________________________//
-
-signal_action::signal_action( int sig, bool install, bool attach_dbg, char* alt_stack )
-: m_sig( sig )
-, m_installed( install )
-{
-    if( !install )
-        return;
-
-    std::memset( &m_new_action, 0, sizeof(struct sigaction) );
-
-    BOOST_TEST_SYS_ASSERT( ::sigaction( m_sig , sigaction_ptr(), &m_new_action ) != -1 );
-
-    if( m_new_action.sa_sigaction || m_new_action.sa_handler ) {
-        m_installed = false;
-        return;
-    }
-
-    m_new_action.sa_flags     |= SA_SIGINFO;
-    m_new_action.sa_sigaction  = attach_dbg ? &boost_execution_monitor_attaching_signal_handler
-                                            : &boost_execution_monitor_jumping_signal_handler;
-    BOOST_TEST_SYS_ASSERT( sigemptyset( &m_new_action.sa_mask ) != -1 );
-
-#ifdef BOOST_TEST_USE_ALT_STACK
-    if( alt_stack )
-        m_new_action.sa_flags |= SA_ONSTACK;
-#endif
-
-    BOOST_TEST_SYS_ASSERT( ::sigaction( m_sig, &m_new_action, &m_old_action ) != -1 );
-}
-
-//____________________________________________________________________________//
-
-signal_action::~signal_action()
-{
-    if( m_installed )
-        ::sigaction( m_sig, &m_old_action , sigaction_ptr() );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************        boost::detail::signal_handler         ************** //
-// ************************************************************************** //
-
-class signal_handler {
-public:
-    // Constructor
-    explicit signal_handler( bool catch_system_errors, bool detect_fpe, unsigned timeout, bool attach_dbg, char* alt_stack );
-
-    // Destructor
-    ~signal_handler();
-
-    // access methods
-    static sigjmp_buf&      jump_buffer()
-    {
-        assert( !!s_active_handler );
-
-        return s_active_handler->m_sigjmp_buf;
-    }
-
-    static system_signal_exception&  sys_sig()
-    {
-        assert( !!s_active_handler );
-
-        return s_active_handler->m_sys_sig;
-    }
-
-private:
-    // Data members
-    signal_handler*         m_prev_handler;
-    unsigned                m_timeout;
-
-    // Note: We intentionality do not catch SIGCHLD. Users have to deal with it themselves
-    signal_action           m_ILL_action;
-    signal_action           m_FPE_action;
-    signal_action           m_SEGV_action;
-    signal_action           m_BUS_action;
-    signal_action           m_CHLD_action;
-    signal_action           m_POLL_action;
-    signal_action           m_ABRT_action;
-    signal_action           m_ALRM_action;
-
-    sigjmp_buf              m_sigjmp_buf;
-    system_signal_exception m_sys_sig;
-
-    static signal_handler*  s_active_handler;
-};
-
-// !! need to be placed in thread specific storage
-typedef signal_handler* signal_handler_ptr;
-signal_handler* signal_handler::s_active_handler = signal_handler_ptr();
-
-//____________________________________________________________________________//
-
-signal_handler::signal_handler( bool catch_system_errors, bool detect_fpe, unsigned timeout, bool attach_dbg, char* alt_stack )
-: m_prev_handler( s_active_handler )
-, m_timeout( timeout )
-, m_ILL_action ( SIGILL , catch_system_errors, attach_dbg, alt_stack )
-, m_FPE_action ( SIGFPE , detect_fpe         , attach_dbg, alt_stack )
-, m_SEGV_action( SIGSEGV, catch_system_errors, attach_dbg, alt_stack )
-, m_BUS_action ( SIGBUS , catch_system_errors, attach_dbg, alt_stack )
-#ifdef BOOST_TEST_CATCH_SIGPOLL
-, m_POLL_action( SIGPOLL, catch_system_errors, attach_dbg, alt_stack )
-#endif
-, m_ABRT_action( SIGABRT, catch_system_errors, attach_dbg, alt_stack )
-, m_ALRM_action( SIGALRM, timeout > 0        , attach_dbg, alt_stack )
-{
-    s_active_handler = this;
-
-    if( m_timeout > 0 ) {
-        ::alarm( 0 );
-        ::alarm( timeout );
-    }
-
-#ifdef BOOST_TEST_USE_ALT_STACK
-    if( alt_stack ) {
-        stack_t sigstk;
-        std::memset( &sigstk, 0, sizeof(stack_t) );
-
-        BOOST_TEST_SYS_ASSERT( ::sigaltstack( 0, &sigstk ) != -1 );
-
-        if( sigstk.ss_flags & SS_DISABLE ) {
-            sigstk.ss_sp    = alt_stack;
-            sigstk.ss_size  = BOOST_TEST_ALT_STACK_SIZE;
-            sigstk.ss_flags = 0;
-            BOOST_TEST_SYS_ASSERT( ::sigaltstack( &sigstk, 0 ) != -1 );
-        }
-    }
-#endif
-}
-
-//____________________________________________________________________________//
-
-signal_handler::~signal_handler()
-{
-    assert( s_active_handler == this );
-
-    if( m_timeout > 0 )
-        ::alarm( 0 );
-
-#ifdef BOOST_TEST_USE_ALT_STACK
-#ifdef __GNUC__
-    // We shouldn't need to explicitly initialize all the members here,
-    // but gcc warns if we don't, so add initializers for each of the
-    // members specified in the POSIX std:
-    stack_t sigstk = { 0, 0, 0 };
-#else
-    stack_t sigstk = { };
-#endif
-
-    sigstk.ss_size  = MINSIGSTKSZ;
-    sigstk.ss_flags = SS_DISABLE;
-    if( ::sigaltstack( &sigstk, 0 ) == -1 ) {
-        int error_n = errno;
-        std::cerr << "******** errors disabling the alternate stack:" << std::endl
-                  << "\t#error:" << error_n << std::endl
-                  << "\t" << std::strerror( error_n ) << std::endl;
-    }
-#endif
-
-    s_active_handler = m_prev_handler;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************       execution_monitor_signal_handler       ************** //
-// ************************************************************************** //
-
-extern "C" {
-
-static void boost_execution_monitor_jumping_signal_handler( int sig, siginfo_t* info, void* context )
-{
-    signal_handler::sys_sig()( info, context );
-
-    siglongjmp( signal_handler::jump_buffer(), sig );
-}
-
-//____________________________________________________________________________//
-
-static void boost_execution_monitor_attaching_signal_handler( int sig, siginfo_t* info, void* context )
-{
-    if( !debug::attach_debugger( false ) )
-        boost_execution_monitor_jumping_signal_handler( sig, info, context );
-
-    // debugger attached; it will handle the signal
-    BOOST_TEST_SYS_ASSERT( ::signal( sig, SIG_DFL ) != SIG_ERR );
-}
-
-//____________________________________________________________________________//
-
-}
-
-} // namespace detail
-
-// ************************************************************************** //
-// **************        execution_monitor::catch_signals      ************** //
-// ************************************************************************** //
-
-int
-execution_monitor::catch_signals( boost::function<int ()> const& F )
-{
-    using namespace detail;
-
-#if defined(__CYGWIN__)
-    p_catch_system_errors.value = false;
-#endif
-
-#ifdef BOOST_TEST_USE_ALT_STACK
-    if( !!p_use_alt_stack && !m_alt_stack )
-        m_alt_stack.reset( new char[BOOST_TEST_ALT_STACK_SIZE] );
-#else
-    p_use_alt_stack.value = false;
-#endif
-
-    signal_handler local_signal_handler( p_catch_system_errors,
-                                         p_catch_system_errors || (p_detect_fp_exceptions != fpe::BOOST_FPE_OFF),
-                                         p_timeout,
-                                         p_auto_start_dbg,
-                                         !p_use_alt_stack ? 0 : m_alt_stack.get() );
-
-    if( !sigsetjmp( signal_handler::jump_buffer(), 1 ) )
-        return detail::do_invoke( m_custom_translators , F );
-    else
-        BOOST_TEST_I_THROW( local_signal_handler.sys_sig() );
-}
-
-//____________________________________________________________________________//
-
-#elif defined(BOOST_SEH_BASED_SIGNAL_HANDLING)
-
-// ************************************************************************** //
-// **************   Microsoft structured exception handling    ************** //
-// ************************************************************************** //
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0564))
-namespace { void _set_se_translator( void* ) {} }
-#endif
-
-namespace detail {
-
-// ************************************************************************** //
-// **************    boost::detail::system_signal_exception    ************** //
-// ************************************************************************** //
-
-class system_signal_exception {
-public:
-    // Constructor
-    explicit            system_signal_exception( execution_monitor* em )
-    : m_em( em )
-    , m_se_id( 0 )
-    , m_fault_address( 0 )
-    , m_dir( false )
-    {}
-
-    void                report() const;
-    int                 operator()( unsigned id, _EXCEPTION_POINTERS* exps );
-
-private:
-    // Data members
-    execution_monitor*  m_em;
-
-    unsigned            m_se_id;
-    void*               m_fault_address;
-    bool                m_dir;
-};
-
-//____________________________________________________________________________//
-
-#if BOOST_WORKAROUND( BOOST_MSVC, <= 1310)
-static void
-seh_catch_preventer( unsigned /* id */, _EXCEPTION_POINTERS* /* exps */ )
-{
-    throw;
-}
-#endif
-
-//____________________________________________________________________________//
-
-int
-system_signal_exception::operator()( unsigned id, _EXCEPTION_POINTERS* exps )
-{
-    const unsigned MSFT_CPP_EXCEPT = 0xE06d7363; // EMSC
-
-    // C++ exception - allow to go through
-    if( id == MSFT_CPP_EXCEPT )
-        return EXCEPTION_CONTINUE_SEARCH;
-
-    // FPE detection is enabled, while system exception detection is not - check if this is actually FPE
-    if( !m_em->p_catch_system_errors ) {
-        if( !m_em->p_detect_fp_exceptions )
-            return EXCEPTION_CONTINUE_SEARCH;
-
-        switch( id ) {
-        case EXCEPTION_FLT_DIVIDE_BY_ZERO:
-        case EXCEPTION_FLT_STACK_CHECK:
-        case EXCEPTION_FLT_DENORMAL_OPERAND:
-        case EXCEPTION_FLT_INEXACT_RESULT:
-        case EXCEPTION_FLT_OVERFLOW:
-        case EXCEPTION_FLT_UNDERFLOW:
-        case EXCEPTION_FLT_INVALID_OPERATION:
-        case STATUS_FLOAT_MULTIPLE_FAULTS:
-        case STATUS_FLOAT_MULTIPLE_TRAPS:
-            break;
-        default:
-            return EXCEPTION_CONTINUE_SEARCH;
-        }
-    }
-
-    if( !!m_em->p_auto_start_dbg && debug::attach_debugger( false ) ) {
-        m_em->p_catch_system_errors.value = false;
-#if BOOST_WORKAROUND( BOOST_MSVC, <= 1310)
-        _set_se_translator( &seh_catch_preventer );
-#endif
-        return EXCEPTION_CONTINUE_EXECUTION;
-    }
-
-    m_se_id = id;
-    if( m_se_id == EXCEPTION_ACCESS_VIOLATION && exps->ExceptionRecord->NumberParameters == 2 ) {
-        m_fault_address = (void*)exps->ExceptionRecord->ExceptionInformation[1];
-        m_dir           = exps->ExceptionRecord->ExceptionInformation[0] == 0;
-    }
-
-    return EXCEPTION_EXECUTE_HANDLER;
-}
-
-//____________________________________________________________________________//
-
-void
-system_signal_exception::report() const
-{
-    switch( m_se_id ) {
-    // cases classified as system_fatal_error
-    case EXCEPTION_ACCESS_VIOLATION: {
-        if( !m_fault_address )
-            detail::report_error( execution_exception::system_fatal_error, "memory access violation" );
-        else
-            detail::report_error(
-                execution_exception::system_fatal_error,
-                    "memory access violation occurred at address 0x%08lx, while attempting to %s",
-                    m_fault_address,
-                    m_dir ? " read inaccessible data"
-                          : " write to an inaccessible (or protected) address"
-                    );
-        break;
-    }
-
-    case EXCEPTION_ILLEGAL_INSTRUCTION:
-        detail::report_error( execution_exception::system_fatal_error, "illegal instruction" );
-        break;
-
-    case EXCEPTION_PRIV_INSTRUCTION:
-        detail::report_error( execution_exception::system_fatal_error, "tried to execute an instruction whose operation is not allowed in the current machine mode" );
-        break;
-
-    case EXCEPTION_IN_PAGE_ERROR:
-        detail::report_error( execution_exception::system_fatal_error, "access to a memory page that is not present" );
-        break;
-
-    case EXCEPTION_STACK_OVERFLOW:
-        detail::report_error( execution_exception::system_fatal_error, "stack overflow" );
-        break;
-
-    case EXCEPTION_NONCONTINUABLE_EXCEPTION:
-        detail::report_error( execution_exception::system_fatal_error, "tried to continue execution after a non continuable exception occurred" );
-        break;
-
-    // cases classified as (non-fatal) system_trap
-    case EXCEPTION_DATATYPE_MISALIGNMENT:
-        detail::report_error( execution_exception::system_error, "data misalignment" );
-        break;
-
-    case EXCEPTION_INT_DIVIDE_BY_ZERO:
-        detail::report_error( execution_exception::system_error, "integer divide by zero" );
-        break;
-
-    case EXCEPTION_INT_OVERFLOW:
-        detail::report_error( execution_exception::system_error, "integer overflow" );
-        break;
-
-    case EXCEPTION_ARRAY_BOUNDS_EXCEEDED:
-        detail::report_error( execution_exception::system_error, "array bounds exceeded" );
-        break;
-
-    case EXCEPTION_FLT_DIVIDE_BY_ZERO:
-        detail::report_error( execution_exception::system_error, "floating point divide by zero" );
-        break;
-
-    case EXCEPTION_FLT_STACK_CHECK:
-        detail::report_error( execution_exception::system_error,
-                              "stack overflowed or underflowed as the result of a floating-point operation" );
-        break;
-
-    case EXCEPTION_FLT_DENORMAL_OPERAND:
-        detail::report_error( execution_exception::system_error,
-                              "operand of floating point operation is denormal" );
-        break;
-
-    case EXCEPTION_FLT_INEXACT_RESULT:
-        detail::report_error( execution_exception::system_error,
-                              "result of a floating-point operation cannot be represented exactly" );
-        break;
-
-    case EXCEPTION_FLT_OVERFLOW:
-        detail::report_error( execution_exception::system_error,
-                              "exponent of a floating-point operation is greater than the magnitude allowed by the corresponding type" );
-        break;
-
-    case EXCEPTION_FLT_UNDERFLOW:
-        detail::report_error( execution_exception::system_error,
-                              "exponent of a floating-point operation is less than the magnitude allowed by the corresponding type" );
-        break;
-
-    case EXCEPTION_FLT_INVALID_OPERATION:
-        detail::report_error( execution_exception::system_error, "floating point error" );
-        break;
-
-    case STATUS_FLOAT_MULTIPLE_FAULTS:
-        detail::report_error( execution_exception::system_error, "multiple floating point errors" );
-        break;
-
-    case STATUS_FLOAT_MULTIPLE_TRAPS:
-        detail::report_error( execution_exception::system_error, "multiple floating point errors" );
-        break;
-
-    case EXCEPTION_BREAKPOINT:
-        detail::report_error( execution_exception::system_error, "breakpoint encountered" );
-        break;
-
-    default:
-        detail::report_error( execution_exception::system_error, "unrecognized exception. Id: 0x%08lx", m_se_id );
-        break;
-    }
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************          assert_reporting_function           ************** //
-// ************************************************************************** //
-
-int BOOST_TEST_CALL_DECL
-assert_reporting_function( int reportType, char* userMessage, int* )
-{
-    // write this way instead of switch to avoid unreachable statements
-    if( reportType == BOOST_TEST_CRT_ASSERT || reportType == BOOST_TEST_CRT_ERROR )
-        detail::report_error( reportType == BOOST_TEST_CRT_ASSERT ? execution_exception::user_error : execution_exception::system_error, userMessage );
-
-    return 0;
-} // assert_reporting_function
-
-//____________________________________________________________________________//
-
-void BOOST_TEST_CALL_DECL
-invalid_param_handler( wchar_t const* /* expr */,
-                       wchar_t const* /* func */,
-                       wchar_t const* /* file */,
-                       unsigned       /* line */,
-                       uintptr_t      /* reserved */)
-{
-    detail::report_error( execution_exception::user_error,
-                          "Invalid parameter detected by C runtime library" );
-}
-
-//____________________________________________________________________________//
-
-} // namespace detail
-
-// ************************************************************************** //
-// **************        execution_monitor::catch_signals      ************** //
-// ************************************************************************** //
-
-int
-execution_monitor::catch_signals( boost::function<int ()> const& F )
-{
-    _invalid_parameter_handler old_iph = _invalid_parameter_handler();
-    BOOST_TEST_CRT_HOOK_TYPE old_crt_hook = 0;
-
-    if( p_catch_system_errors ) {
-        old_crt_hook = BOOST_TEST_CRT_SET_HOOK( &detail::assert_reporting_function );
-
-        old_iph = _set_invalid_parameter_handler(
-            reinterpret_cast<_invalid_parameter_handler>( &detail::invalid_param_handler ) );
-    } else if( !p_detect_fp_exceptions ) {
-#if BOOST_WORKAROUND( BOOST_MSVC, <= 1310)
-        _set_se_translator( &detail::seh_catch_preventer );
-#endif
-    }
-
-    detail::system_signal_exception SSE( this );
-
-    int ret_val = 0;
-    // clang windows workaround: this not available in __finally scope
-    bool l_catch_system_errors = p_catch_system_errors;
-
-    __try {
-        __try {
-            ret_val = detail::do_invoke( m_custom_translators, F );
-        }
-        __except( SSE( GetExceptionCode(), GetExceptionInformation() ) ) {
-            throw SSE;
-        }
-    }
-    __finally {
-        if( l_catch_system_errors ) {
-            BOOST_TEST_CRT_SET_HOOK( old_crt_hook );
-
-           _set_invalid_parameter_handler( old_iph );
-        }
-    }
-
-    return ret_val;
-}
-
-//____________________________________________________________________________//
-
-#else  // default signal handler
-
-namespace detail {
-
-class system_signal_exception {
-public:
-    void   report() const {}
-};
-
-} // namespace detail
-
-int
-execution_monitor::catch_signals( boost::function<int ()> const& F )
-{
-    return detail::do_invoke( m_custom_translators , F );
-}
-
-//____________________________________________________________________________//
-
-#endif  // choose signal handler
-
-// ************************************************************************** //
-// **************              execution_monitor               ************** //
-// ************************************************************************** //
-
-execution_monitor::execution_monitor()
-: p_catch_system_errors( true )
-, p_auto_start_dbg( false )
-, p_timeout( 0 )
-, p_use_alt_stack( true )
-, p_detect_fp_exceptions( fpe::BOOST_FPE_OFF )
-{}
-
-//____________________________________________________________________________//
-
-int
-execution_monitor::execute( boost::function<int ()> const& F )
-{
-    if( debug::under_debugger() )
-        p_catch_system_errors.value = false;
-
-    BOOST_TEST_I_TRY {
-        detail::fpe_except_guard G( p_detect_fp_exceptions );
-        unit_test::ut_detail::ignore_unused_variable_warning( G );
-
-        return catch_signals( F );
-    }
-
-#ifndef BOOST_NO_EXCEPTIONS
-
-    //  Catch-clause reference arguments are a bit different from function
-    //  arguments (ISO 15.3 paragraphs 18 & 19).  Apparently const isn't
-    //  required.  Programmers ask for const anyhow, so we supply it.  That's
-    //  easier than answering questions about non-const usage.
-
-    catch( char const* ex )
-      { detail::report_error( execution_exception::cpp_exception_error,
-                              "C string: %s", ex ); }
-    catch( std::string const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error,
-                              "std::string: %s", ex.c_str() ); }
-
-    //  std:: exceptions
-#if defined(BOOST_NO_TYPEID) || defined(BOOST_NO_RTTI)
-#define CATCH_AND_REPORT_STD_EXCEPTION( ex_name )                           \
-    catch( ex_name const& ex )                                              \
-       { detail::report_error( execution_exception::cpp_exception_error,    \
-                          current_exception_cast<boost::exception const>(), \
-                          #ex_name ": %s", ex.what() ); }                   \
-/**/
-#else
-#define CATCH_AND_REPORT_STD_EXCEPTION( ex_name )                           \
-    catch( ex_name const& ex )                                              \
-        { detail::report_error( execution_exception::cpp_exception_error,   \
-                          current_exception_cast<boost::exception const>(), \
-                          "%s: %s", detail::typeid_name(ex).c_str(), ex.what() ); } \
-/**/
-#endif
-
-    CATCH_AND_REPORT_STD_EXCEPTION( std::bad_alloc )
-
-#if BOOST_WORKAROUND(__BORLANDC__, <= 0x0551)
-    CATCH_AND_REPORT_STD_EXCEPTION( std::bad_cast )
-    CATCH_AND_REPORT_STD_EXCEPTION( std::bad_typeid )
-#else
-    CATCH_AND_REPORT_STD_EXCEPTION( std::bad_cast )
-    CATCH_AND_REPORT_STD_EXCEPTION( std::bad_typeid )
-#endif
-
-    CATCH_AND_REPORT_STD_EXCEPTION( std::bad_exception )
-    CATCH_AND_REPORT_STD_EXCEPTION( std::domain_error )
-    CATCH_AND_REPORT_STD_EXCEPTION( std::invalid_argument )
-    CATCH_AND_REPORT_STD_EXCEPTION( std::length_error )
-    CATCH_AND_REPORT_STD_EXCEPTION( std::out_of_range )
-    CATCH_AND_REPORT_STD_EXCEPTION( std::range_error )
-    CATCH_AND_REPORT_STD_EXCEPTION( std::overflow_error )
-    CATCH_AND_REPORT_STD_EXCEPTION( std::underflow_error )
-    CATCH_AND_REPORT_STD_EXCEPTION( std::logic_error )
-    CATCH_AND_REPORT_STD_EXCEPTION( std::runtime_error )
-    CATCH_AND_REPORT_STD_EXCEPTION( std::exception )
-#undef CATCH_AND_REPORT_STD_EXCEPTION
-
-    catch( boost::exception const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error,
-                              &ex,
-#if defined(BOOST_NO_TYPEID) || defined(BOOST_NO_RTTI)
-                              "unknown boost::exception" ); }
-#else
-                              typeid(ex).name()          ); }
-#endif
-
-    // system errors
-    catch( system_error const& ex )
-      { detail::report_error( execution_exception::cpp_exception_error,
-                              "system_error produced by: %s: %s", ex.p_failed_exp, std::strerror( ex.p_errno ) ); }
-    catch( detail::system_signal_exception const& ex )
-      { ex.report(); }
-
-    // not an error
-    catch( execution_aborted const& )
-      { return 0; }
-
-    // just forward
-    catch( execution_exception const& )
-      { throw; }
-
-    // unknown error
-    catch( ... )
-      { detail::report_error( execution_exception::cpp_exception_error, "unknown type" ); }
-
-#endif // !BOOST_NO_EXCEPTION
-
-    return 0;  // never reached; supplied to quiet compiler warnings
-} // execute
-
-//____________________________________________________________________________//
-
-namespace detail {
-
-struct forward {
-    explicit    forward( boost::function<void ()> const& F ) : m_F( F ) {}
-
-    int         operator()() { m_F(); return 0; }
-
-    boost::function<void ()> const& m_F;
-};
-
-} // namespace detail
-void
-execution_monitor::vexecute( boost::function<void ()> const& F )
-{
-    execute( detail::forward( F ) );
-}
-
-// ************************************************************************** //
-// **************                  system_error                ************** //
-// ************************************************************************** //
-
-system_error::system_error( char const* exp )
-#ifdef UNDER_CE
-: p_errno( GetLastError() )
-#else
-: p_errno( errno )
-#endif
-, p_failed_exp( exp )
-{}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************              execution_exception             ************** //
-// ************************************************************************** //
-
-execution_exception::execution_exception( error_code ec_, const_string what_msg_, location const& location_ )
-: m_error_code( ec_ )
-, m_what( what_msg_.empty() ? BOOST_TEST_L( "uncaught exception, system error or abort requested" ) : what_msg_ )
-, m_location( location_ )
-{}
-
-//____________________________________________________________________________//
-
-execution_exception::location::location( char const* file_name, size_t line_num, char const* func )
-: m_file_name( file_name ? file_name : "unknown location" )
-, m_line_num( line_num )
-, m_function( func )
-{}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************Floating point exception management interface ************** //
-// ************************************************************************** //
-
-namespace fpe {
-
-unsigned
-enable( unsigned mask )
-{
-    boost::ignore_unused(mask);
-
-#if defined(UNDER_CE)
-    /* Not Implemented in Windows CE */
-    return 0;
-#elif defined(BOOST_SEH_BASED_SIGNAL_HANDLING)
-    _clearfp();
-
-#if BOOST_WORKAROUND( BOOST_MSVC, <= 1310)
-    unsigned old_cw = ::_controlfp( 0, 0 );
-    ::_controlfp( old_cw & ~mask, BOOST_FPE_ALL );
-#else
-    unsigned old_cw;
-    if( ::_controlfp_s( &old_cw, 0, 0 ) != 0 )
-        return BOOST_FPE_INV;
-
-    // Set the control word
-    if( ::_controlfp_s( 0, old_cw & ~mask, BOOST_FPE_ALL ) != 0 )
-        return BOOST_FPE_INV;
-#endif
-
-    return ~old_cw & BOOST_FPE_ALL;
-#elif defined(__GLIBC__) && defined(__USE_GNU) && !defined(BOOST_CLANG) && !defined(BOOST_NO_FENV_H)
-    feclearexcept(BOOST_FPE_ALL);
-    int res = feenableexcept( mask );
-    return res == -1 ? (unsigned)BOOST_FPE_INV : (unsigned)res;
-#else
-    /* Not Implemented  */
-    return 0;
-#endif
-}
-
-//____________________________________________________________________________//
-
-unsigned
-disable( unsigned mask )
-{
-    boost::ignore_unused(mask);
-
-#if defined(UNDER_CE)
-    /* Not Implemented in Windows CE */
-    return 0;
-#elif defined(BOOST_SEH_BASED_SIGNAL_HANDLING)
-    _clearfp();
-
-#if BOOST_WORKAROUND( BOOST_MSVC, <= 1310)
-    unsigned old_cw = ::_controlfp( 0, 0 );
-    ::_controlfp( old_cw | mask, BOOST_FPE_ALL );
-#else
-    unsigned old_cw;
-    if( ::_controlfp_s( &old_cw, 0, 0 ) != 0 )
-        return BOOST_FPE_INV;
-
-    // Set the control word
-    if( ::_controlfp_s( 0, old_cw | mask, BOOST_FPE_ALL ) != 0 )
-        return BOOST_FPE_INV;
-#endif
-
-    return ~old_cw & BOOST_FPE_ALL;
-#elif defined(__GLIBC__) && defined(__USE_GNU) && !defined(BOOST_CLANG) && !defined(BOOST_NO_FENV_H)
-    feclearexcept(BOOST_FPE_ALL);
-    int res = fedisableexcept( mask );
-    return res == -1 ? (unsigned)BOOST_FPE_INV : (unsigned)res;
-#else
-    /* Not Implemented */
-    return BOOST_FPE_INV;
-#endif
-}
-
-//____________________________________________________________________________//
-
-} // namespace fpe
-
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_EXECUTION_MONITOR_IPP_012205GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/impl/framework.ipp b/contrib/libboost/boost_1_62_0/boost/test/impl/framework.ipp
deleted file mode 100644
index a513c612e1c..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/impl/framework.ipp
+++ /dev/null
@@ -1,1491 +0,0 @@
-//  (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 : implements framework API - main driver for the test
-// ***************************************************************************
-
-#ifndef BOOST_TEST_FRAMEWORK_IPP_021005GER
-#define BOOST_TEST_FRAMEWORK_IPP_021005GER
-
-// Boost.Test
-#include <boost/test/framework.hpp>
-#include <boost/test/execution_monitor.hpp>
-#include <boost/test/debug.hpp>
-#include <boost/test/unit_test_parameters.hpp>
-
-#include <boost/test/unit_test_log.hpp>
-#include <boost/test/unit_test_log_formatter.hpp>
-#include <boost/test/unit_test_monitor.hpp>
-#include <boost/test/results_collector.hpp>
-#include <boost/test/progress_monitor.hpp>
-#include <boost/test/results_reporter.hpp>
-
-#include <boost/test/tree/observer.hpp>
-#include <boost/test/tree/test_unit.hpp>
-#include <boost/test/tree/visitor.hpp>
-#include <boost/test/tree/traverse.hpp>
-#include <boost/test/tree/test_case_counter.hpp>
-
-#if BOOST_TEST_SUPPORT_TOKEN_ITERATOR
-#include <boost/test/utils/iterator/token_iterator.hpp>
-#endif
-
-#include <boost/test/utils/foreach.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp>
-#include <boost/test/utils/basic_cstring/compare.hpp>
-
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/throw_exception.hpp>
-
-// Boost
-#include <boost/timer.hpp>
-#include <boost/bind.hpp>
-
-// STL
-#include <limits>
-#include <map>
-#include <set>
-#include <cstdlib>
-#include <ctime>
-#include <numeric>
-
-#ifdef BOOST_NO_STDC_NAMESPACE
-namespace std { using ::time; using ::srand; }
-#endif
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace framework {
-namespace impl {
-
-// ************************************************************************** //
-// **************            order detection helpers           ************** //
-// ************************************************************************** //
-
-struct order_info {
-    order_info() : depth(-1) {}
-
-    int                         depth;
-    std::vector<test_unit_id>   dependant_siblings;
-};
-
-typedef std::set<test_unit_id> tu_id_set;
-typedef std::map<test_unit_id,order_info> order_info_per_tu; // !! ?? unordered map
-
-//____________________________________________________________________________//
-
-static test_unit_id
-get_tu_parent( test_unit_id tu_id )
-{
-    return framework::get( tu_id, TUT_ANY ).p_parent_id;
-}
-
-//____________________________________________________________________________//
-
-static int
-tu_depth( test_unit_id tu_id, test_unit_id master_tu_id, order_info_per_tu& tuoi )
-{
-    if( tu_id == master_tu_id )
-        return 0;
-
-    order_info& info = tuoi[tu_id];
-
-    if( info.depth == -1 )
-        info.depth = tu_depth( get_tu_parent( tu_id ), master_tu_id, tuoi ) + 1;
-
-    return info.depth;
-}
-
-//____________________________________________________________________________//
-
-static void
-collect_dependant_siblings( test_unit_id from, test_unit_id to, test_unit_id master_tu_id, order_info_per_tu& tuoi )
-{
-    int from_depth  = tu_depth( from, master_tu_id, tuoi );
-    int to_depth    = tu_depth( to, master_tu_id, tuoi );
-
-    while(from_depth > to_depth) {
-        from = get_tu_parent( from );
-        --from_depth;
-    }
-
-    while(from_depth < to_depth) {
-        to = get_tu_parent( to );
-        --to_depth;
-    }
-
-    while(true) {
-        test_unit_id from_parent = get_tu_parent( from );
-        test_unit_id to_parent = get_tu_parent( to );
-        if( from_parent == to_parent )
-            break;
-        from = from_parent;
-        to   = to_parent;
-    }
-
-    tuoi[from].dependant_siblings.push_back( to );
-}
-
-//____________________________________________________________________________//
-
-static counter_t
-assign_sibling_rank( test_unit_id tu_id, order_info_per_tu& tuoi )
-{
-    test_unit& tu = framework::get( tu_id, TUT_ANY );
-
-    BOOST_TEST_SETUP_ASSERT( tu.p_sibling_rank != (std::numeric_limits<counter_t>::max)(),
-                             "Cyclic dependency detected involving test unit \"" + tu.full_name() + "\"" );
-
-    if( tu.p_sibling_rank != 0 )
-        return tu.p_sibling_rank;
-
-    order_info const& info = tuoi[tu_id];
-
-    // indicate in progress
-    tu.p_sibling_rank.value = (std::numeric_limits<counter_t>::max)();
-
-    counter_t new_rank = 1;
-    BOOST_TEST_FOREACH( test_unit_id, sibling_id, info.dependant_siblings )
-        new_rank = (std::max)(new_rank, assign_sibling_rank( sibling_id, tuoi ) + 1);
-
-    return tu.p_sibling_rank.value = new_rank;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************            test_init call wrapper            ************** //
-// ************************************************************************** //
-
-static void
-invoke_init_func( init_unit_test_func init_func )
-{
-#ifdef BOOST_TEST_ALTERNATIVE_INIT_API
-    BOOST_TEST_I_ASSRT( (*init_func)(), std::runtime_error( "test module initialization failed" ) );
-#else
-    test_suite*  manual_test_units = (*init_func)( framework::master_test_suite().argc, framework::master_test_suite().argv );
-
-    if( manual_test_units )
-        framework::master_test_suite().add( manual_test_units );
-#endif
-}
-
-// ************************************************************************** //
-// **************                  name_filter                 ************** //
-// ************************************************************************** //
-
-class name_filter : public test_tree_visitor {
-    struct component {
-        component( const_string name ) // has to be implicit
-        {
-            if( name == "*" )
-                m_kind  = SFK_ALL;
-            else if( first_char( name ) == '*' && last_char( name ) == '*' ) {
-                m_kind  = SFK_SUBSTR;
-                m_name  = name.substr( 1, name.size()-1 );
-            }
-            else if( first_char( name ) == '*' ) {
-                m_kind  = SFK_TRAILING;
-                m_name  = name.substr( 1 );
-            }
-            else if( last_char( name ) == '*' ) {
-                m_kind  = SFK_LEADING;
-                m_name  = name.substr( 0, name.size()-1 );
-            }
-            else {
-                m_kind  = SFK_MATCH;
-                m_name  = name;
-            }
-        }
-
-        bool            pass( test_unit const& tu ) const
-        {
-            const_string name( tu.p_name );
-
-            switch( m_kind ) {
-            default:
-            case SFK_ALL:
-                return true;
-            case SFK_LEADING:
-                return name.substr( 0, m_name.size() ) == m_name;
-            case SFK_TRAILING:
-                return name.size() >= m_name.size() && name.substr( name.size() - m_name.size() ) == m_name;
-            case SFK_SUBSTR:
-                return name.find( m_name ) != const_string::npos;
-            case SFK_MATCH:
-                return m_name == tu.p_name.get();
-            }
-        }
-        enum kind { SFK_ALL, SFK_LEADING, SFK_TRAILING, SFK_SUBSTR, SFK_MATCH };
-
-        kind            m_kind;
-        const_string    m_name;
-    };
-
-public:
-    // Constructor
-    name_filter( test_unit_id_list& targ_list, const_string filter_expr ) : m_targ_list( targ_list ), m_depth( 0 )
-    {
-#ifdef BOOST_TEST_SUPPORT_TOKEN_ITERATOR
-        utils::string_token_iterator tit( filter_expr, (utils::dropped_delimeters = "/",
-                                                        utils::kept_delimeters = utils::dt_none) );
-
-        while( tit != utils::string_token_iterator() ) {
-            m_components.push_back(
-                std::vector<component>( utils::string_token_iterator( *tit, (utils::dropped_delimeters = ",",
-                                                                             utils::kept_delimeters = utils::dt_none) ),
-                                        utils::string_token_iterator() ) );
-
-            ++tit;
-        }
-#endif
-    }
-
-private:
-    bool            filter_unit( test_unit const& tu )
-    {
-        // skip master test suite
-        if( m_depth == 0 )
-            return true;
-
-        // corresponding name filters are at level m_depth-1
-        std::vector<component> const& filters = m_components[m_depth-1];
-
-        // look for match
-        using namespace boost::placeholders;
-        return std::find_if( filters.begin(), filters.end(), bind( &component::pass, _1, boost::ref(tu) ) ) != filters.end();
-    }
-
-    // test_tree_visitor interface
-    virtual void    visit( test_case const& tc )
-    {
-        // make sure we only accept test cases if we match last component of the filter
-        if( m_depth == m_components.size() && filter_unit( tc ) )
-            m_targ_list.push_back( tc.p_id ); // found a test case
-    }
-    virtual bool    test_suite_start( test_suite const& ts )
-    {
-        if( !filter_unit( ts ) )
-            return false;
-
-        if( m_depth < m_components.size() ) {
-            ++m_depth;
-            return true;
-        }
-
-        m_targ_list.push_back( ts.p_id ); // found a test suite
-
-        return false;
-    }
-    virtual void    test_suite_finish( test_suite const& /*ts*/ )
-    {
-        --m_depth;
-    }
-
-    // Data members
-    typedef std::vector<std::vector<component> > components_per_level;
-
-    components_per_level    m_components;
-    test_unit_id_list&      m_targ_list;
-    unsigned                m_depth;
-};
-
-// ************************************************************************** //
-// **************                 label_filter                 ************** //
-// ************************************************************************** //
-
-class label_filter : public test_tree_visitor {
-public:
-    label_filter( test_unit_id_list& targ_list, const_string label )
-    : m_targ_list( targ_list )
-    , m_label( label )
-    {}
-
-private:
-    // test_tree_visitor interface
-    virtual bool    visit( test_unit const& tu )
-    {
-        if( tu.has_label( m_label ) ) {
-            // found a test unit; add it to list of tu to enable with children and stop recursion in case of suites
-            m_targ_list.push_back( tu.p_id );
-            return false;
-        }
-
-        return true;
-    }
-
-    // Data members
-    test_unit_id_list&  m_targ_list;
-    const_string        m_label;
-};
-
-// ************************************************************************** //
-// **************                set_run_status                ************** //
-// ************************************************************************** //
-
-class set_run_status : public test_tree_visitor {
-public:
-    explicit set_run_status( test_unit::run_status rs, test_unit_id_list* dep_collector = 0 )
-    : m_new_status( rs )
-    , m_dep_collector( dep_collector )
-    {}
-
-private:
-    // test_tree_visitor interface
-    virtual bool    visit( test_unit const& tu )
-    {
-        const_cast<test_unit&>(tu).p_run_status.value = m_new_status == test_unit::RS_INVALID ? tu.p_default_status : m_new_status;
-
-        if( m_dep_collector ) {
-            BOOST_TEST_FOREACH( test_unit_id, dep_id, tu.p_dependencies.get() ) {
-                test_unit const& dep = framework::get( dep_id, TUT_ANY );
-
-                if( dep.p_run_status == tu.p_run_status )
-                    continue;
-
-                BOOST_TEST_FRAMEWORK_MESSAGE( "Including test " << dep.p_type_name << ' ' << dep.full_name() <<
-                                              " as a dependency of test " << tu.p_type_name << ' ' << tu.full_name() );
-
-                m_dep_collector->push_back( dep_id );
-            }
-        }
-        return true;
-    }
-
-    // Data members
-    test_unit::run_status   m_new_status;
-    test_unit_id_list*      m_dep_collector;
-};
-
-// ************************************************************************** //
-// **************                 parse_filters                ************** //
-// ************************************************************************** //
-
-static void
-add_filtered_test_units( test_unit_id master_tu_id, const_string filter, test_unit_id_list& targ )
-{
-    // Choose between two kinds of filters
-    if( filter[0] == '@' ) {
-        filter.trim_left( 1 );
-        label_filter lf( targ, filter );
-        traverse_test_tree( master_tu_id, lf, true );
-    }
-    else {
-        name_filter nf( targ, filter );
-        traverse_test_tree( master_tu_id, nf, true );
-    }
-}
-
-//____________________________________________________________________________//
-
-static bool
-parse_filters( test_unit_id master_tu_id, test_unit_id_list& tu_to_enable, test_unit_id_list& tu_to_disable )
-{
-    // 10. collect tu to enable and disable based on filters
-    bool had_selector_filter = false;
-
-    std::vector<std::string> const& filters = runtime_config::get<std::vector<std::string> >( runtime_config::RUN_FILTERS );
-
-    BOOST_TEST_FOREACH( const_string, filter, filters ) {
-        BOOST_TEST_SETUP_ASSERT( !filter.is_empty(), "Invalid filter specification" );
-
-        // each --run_test command may also be separated by a ':' (environment variable)
-        utils::string_token_iterator t_filter_it( filter, (utils::dropped_delimeters = ":",
-                                                           utils::kept_delimeters = utils::dt_none) );
-
-        while( t_filter_it != utils::string_token_iterator() ) {
-            const_string filter_token = *t_filter_it;
-
-            enum { SELECTOR, ENABLER, DISABLER } filter_type = SELECTOR;
-
-            // 11. Deduce filter type
-            if( filter_token[0] == '!' || filter_token[0] == '+' ) {
-                filter_type = filter_token[0] == '+' ? ENABLER : DISABLER;
-                filter_token.trim_left( 1 );
-                BOOST_TEST_SETUP_ASSERT( !filter_token.is_empty(), "Invalid filter specification" );
-            }
-
-            had_selector_filter |= filter_type == SELECTOR;
-
-            // 12. Add test units to corresponding list
-            switch( filter_type ) {
-            case SELECTOR:
-            case ENABLER:  add_filtered_test_units( master_tu_id, filter_token, tu_to_enable ); break;
-            case DISABLER: add_filtered_test_units( master_tu_id, filter_token, tu_to_disable ); break;
-            }
-
-            ++t_filter_it;
-        }
-    }
-
-    return had_selector_filter;
-}
-
-//____________________________________________________________________________//
-
-} // namespace impl
-
-// ************************************************************************** //
-// **************               framework::state               ************** //
-// ************************************************************************** //
-
-unsigned const TIMEOUT_EXCEEDED = static_cast<unsigned>( -1 );
-
-class state {
-public:
-    state()
-    : m_curr_test_case( INV_TEST_UNIT_ID )
-    , m_next_test_case_id( MIN_TEST_CASE_ID )
-    , m_next_test_suite_id( MIN_TEST_SUITE_ID )
-    , m_test_in_progress( false )
-    , m_context_idx( 0 )
-    , m_log_sinks( )
-    , m_report_sink( std::cerr )
-    {
-    }
-
-    ~state() { clear(); }
-
-    void            clear()
-    {
-        while( !m_test_units.empty() ) {
-            test_unit_store::value_type const& tu     = *m_test_units.begin();
-            test_unit const*                   tu_ptr = tu.second;
-
-            // the delete will erase this element from map
-            if( ut_detail::test_id_2_unit_type( tu.second->p_id ) == TUT_SUITE )
-                delete static_cast<test_suite const*>(tu_ptr);
-            else
-                delete static_cast<test_case const*>(tu_ptr);
-        }
-    }
-
-    void            set_tu_id( test_unit& tu, test_unit_id id ) { tu.p_id.value = id; }
-
-    //////////////////////////////////////////////////////////////////
-
-    // Validates the dependency graph and deduces the sibling dependency rank for each child
-    void       deduce_siblings_order( test_unit_id tu_id, test_unit_id master_tu_id, impl::order_info_per_tu& tuoi )
-    {
-        test_unit& tu = framework::get( tu_id, TUT_ANY );
-
-        // collect all sibling dependancy from tu own list
-        BOOST_TEST_FOREACH( test_unit_id, dep_id, tu.p_dependencies.get() )
-            collect_dependant_siblings( tu_id, dep_id, master_tu_id, tuoi );
-
-        if( tu.p_type != TUT_SUITE )
-            return;
-
-        test_suite& ts = static_cast<test_suite&>(tu);
-
-        // recursive call to children first
-        BOOST_TEST_FOREACH( test_unit_id, chld_id, ts.m_children )
-            deduce_siblings_order( chld_id, master_tu_id, tuoi );
-
-        ts.m_ranked_children.clear();
-        BOOST_TEST_FOREACH( test_unit_id, chld_id, ts.m_children ) {
-            counter_t rank = assign_sibling_rank( chld_id, tuoi );
-            ts.m_ranked_children.insert( std::make_pair( rank, chld_id ) );
-        }
-    }
-
-    //////////////////////////////////////////////////////////////////
-
-    // Finalize default run status:
-    //  1) inherit run status from parent where applicable
-    //  2) if any of test units in test suite enabled enable it as well
-    bool            finalize_default_run_status( test_unit_id tu_id, test_unit::run_status parent_status )
-    {
-        test_unit& tu = framework::get( tu_id, TUT_ANY );
-
-        if( tu.p_default_status == test_suite::RS_INHERIT )
-            tu.p_default_status.value = parent_status;
-
-        // go through list of children
-        if( tu.p_type == TUT_SUITE ) {
-            bool has_enabled_child = false;
-            BOOST_TEST_FOREACH( test_unit_id, chld_id, static_cast<test_suite const&>(tu).m_children )
-                has_enabled_child |= finalize_default_run_status( chld_id, tu.p_default_status );
-
-            tu.p_default_status.value = has_enabled_child ? test_suite::RS_ENABLED : test_suite::RS_DISABLED;
-        }
-
-        return tu.p_default_status == test_suite::RS_ENABLED;
-    }
-
-    //////////////////////////////////////////////////////////////////
-
-    bool            finalize_run_status( test_unit_id tu_id )
-    {
-        test_unit& tu = framework::get( tu_id, TUT_ANY );
-
-        // go through list of children
-        if( tu.p_type == TUT_SUITE ) {
-            bool has_enabled_child = false;
-            BOOST_TEST_FOREACH( test_unit_id, chld_id, static_cast<test_suite const&>(tu).m_children)
-                has_enabled_child |= finalize_run_status( chld_id );
-
-            tu.p_run_status.value = has_enabled_child ? test_suite::RS_ENABLED : test_suite::RS_DISABLED;
-        }
-
-        return tu.is_enabled();
-    }
-
-    //////////////////////////////////////////////////////////////////
-
-    void            deduce_run_status( test_unit_id master_tu_id )
-    {
-        using namespace framework::impl;
-        test_unit_id_list tu_to_enable;
-        test_unit_id_list tu_to_disable;
-
-        // 10. If there are any filters supplied, figure out lists of test units to enable/disable
-        bool had_selector_filter = !runtime_config::get<std::vector<std::string> >( runtime_config::RUN_FILTERS ).empty() &&
-                                   parse_filters( master_tu_id, tu_to_enable, tu_to_disable );
-
-        // 20. Set the stage: either use default run status or disable all test units
-        set_run_status initial_setter( had_selector_filter ? test_unit::RS_DISABLED : test_unit::RS_INVALID );
-        traverse_test_tree( master_tu_id, initial_setter, true );
-
-        // 30. Apply all selectors and enablers.
-        while( !tu_to_enable.empty() ) {
-            test_unit& tu = framework::get( tu_to_enable.back(), TUT_ANY );
-
-            tu_to_enable.pop_back();
-
-            // 35. Ignore test units which already enabled
-            if( tu.is_enabled() )
-                continue;
-
-            // set new status and add all dependencies into tu_to_enable
-            set_run_status enabler( test_unit::RS_ENABLED, &tu_to_enable );
-            traverse_test_tree( tu.p_id, enabler, true );
-        }
-
-        // 40. Apply all disablers
-        while( !tu_to_disable.empty() ) {
-            test_unit const& tu = framework::get( tu_to_disable.back(), TUT_ANY );
-
-            tu_to_disable.pop_back();
-
-            // 35. Ignore test units which already disabled
-            if( !tu.is_enabled() )
-                continue;
-
-            set_run_status disabler( test_unit::RS_DISABLED );
-            traverse_test_tree( tu.p_id, disabler, true );
-        }
-
-        // 50. Make sure parents of enabled test units are also enabled
-        finalize_run_status( master_tu_id );
-    }
-
-    //////////////////////////////////////////////////////////////////
-
-    typedef unit_test_monitor_t::error_level execution_result;
-
-    // Random generator using the std::rand function (seeded prior to the call)
-    struct random_generator_helper {
-      size_t operator()(size_t i) const {
-        return std::rand() % i;
-      }
-    };
-
-      // Executed the test tree with the root at specified test unit
-    execution_result execute_test_tree( test_unit_id tu_id,
-                                        unsigned timeout = 0,
-                                        random_generator_helper const * const p_random_generator = 0)
-    {
-        test_unit const& tu = framework::get( tu_id, TUT_ANY );
-
-        execution_result result = unit_test_monitor_t::test_ok;
-
-        if( !tu.is_enabled() )
-            return result;
-
-        // 10. Check preconditions, including zero time left for execution and
-        // successful execution of all dependencies
-        if( timeout == TIMEOUT_EXCEEDED ) {
-            // notify all observers about skipped test unit
-            BOOST_TEST_FOREACH( test_observer*, to, m_observers )
-                to->test_unit_skipped( tu, "timeout for the test unit is exceeded" );
-
-            return unit_test_monitor_t::os_timeout;
-        }
-        else if( timeout == 0 || timeout > tu.p_timeout ) // deduce timeout for this test unit
-            timeout = tu.p_timeout;
-
-        test_tools::assertion_result const precondition_res = tu.check_preconditions();
-        if( !precondition_res ) {
-            // notify all observers about skipped test unit
-            BOOST_TEST_FOREACH( test_observer*, to, m_observers )
-                to->test_unit_skipped( tu, precondition_res.message() );
-
-            return unit_test_monitor_t::precondition_failure;
-        }
-
-        // 20. Notify all observers about the start of the test unit
-        BOOST_TEST_FOREACH( test_observer*, to, m_observers )
-            to->test_unit_start( tu );
-
-        // 30. Execute setup fixtures if any; any failure here leads to test unit abortion
-        BOOST_TEST_FOREACH( test_unit_fixture_ptr, F, tu.p_fixtures.get() ) {
-            result = unit_test_monitor.execute_and_translate( boost::bind( &test_unit_fixture::setup, F ) );
-            if( result != unit_test_monitor_t::test_ok )
-                break;
-        }
-
-        // This is the time we are going to spend executing the test unit
-        unsigned long elapsed = 0;
-
-        if( result == unit_test_monitor_t::test_ok ) {
-            // 40. We are going to time the execution
-            boost::timer tu_timer;
-
-            if( tu.p_type == TUT_SUITE ) {
-                test_suite const& ts = static_cast<test_suite const&>( tu );
-
-                if( runtime_config::get<unsigned>( runtime_config::RANDOM_SEED ) == 0 ) {
-                    typedef std::pair<counter_t,test_unit_id> value_type;
-
-                    BOOST_TEST_FOREACH( value_type, chld, ts.m_ranked_children ) {
-                        unsigned chld_timeout = child_timeout( timeout, tu_timer.elapsed() );
-
-                        result = (std::min)( result, execute_test_tree( chld.second, chld_timeout ) );
-
-                        if( unit_test_monitor.is_critical_error( result ) )
-                            break;
-                    }
-                }
-                else {
-                    // Go through ranges of chldren with the same dependency rank and shuffle them
-                    // independently. Execute each subtree in this order
-                    test_unit_id_list children_with_the_same_rank;
-
-                    typedef test_suite::children_per_rank::const_iterator it_type;
-                    it_type it = ts.m_ranked_children.begin();
-                    while( it != ts.m_ranked_children.end() ) {
-                        children_with_the_same_rank.clear();
-
-                        std::pair<it_type,it_type> range = ts.m_ranked_children.equal_range( it->first );
-                        it = range.first;
-                        while( it != range.second ) {
-                            children_with_the_same_rank.push_back( it->second );
-                            it++;
-                        }
-
-                        const random_generator_helper& rand_gen = p_random_generator ? *p_random_generator : random_generator_helper();
-
-                        std::random_shuffle( children_with_the_same_rank.begin(), children_with_the_same_rank.end(), rand_gen );
-
-                        BOOST_TEST_FOREACH( test_unit_id, chld, children_with_the_same_rank ) {
-                            unsigned chld_timeout = child_timeout( timeout, tu_timer.elapsed() );
-
-                            result = (std::min)( result, execute_test_tree( chld, chld_timeout, &rand_gen ) );
-
-                            if( unit_test_monitor.is_critical_error( result ) )
-                                break;
-                        }
-                    }
-                }
-
-                elapsed = static_cast<unsigned long>( tu_timer.elapsed() * 1e6 );
-            }
-            else { // TUT_CASE
-                test_case const& tc = static_cast<test_case const&>( tu );
-
-                // setup contexts
-                m_context_idx = 0;
-
-                // setup current test case
-                test_unit_id bkup = m_curr_test_case;
-                m_curr_test_case = tc.p_id;
-
-                // execute the test case body
-                result = unit_test_monitor.execute_and_translate( tc.p_test_func, timeout );
-                elapsed = static_cast<unsigned long>( tu_timer.elapsed() * 1e6 );
-
-                // cleanup leftover context
-                m_context.clear();
-
-                // restore state and abort if necessary
-                m_curr_test_case = bkup;
-            }
-        }
-
-        // if run error is critical skip teardown, who knows what the state of the program at this point
-        if( !unit_test_monitor.is_critical_error( result ) ) {
-            // execute teardown fixtures if any in reverse order
-            BOOST_TEST_REVERSE_FOREACH( test_unit_fixture_ptr, F, tu.p_fixtures.get() ) {
-                result = (std::min)( result, unit_test_monitor.execute_and_translate( boost::bind( &test_unit_fixture::teardown, F ), 0 ) );
-
-                if( unit_test_monitor.is_critical_error( result ) )
-                    break;
-            }
-        }
-
-        // notify all observers about abortion
-        if( unit_test_monitor.is_critical_error( result ) ) {
-            BOOST_TEST_FOREACH( test_observer*, to, m_observers )
-                to->test_aborted();
-        }
-
-        // notify all observers about completion
-        BOOST_TEST_REVERSE_FOREACH( test_observer*, to, m_observers )
-            to->test_unit_finish( tu, elapsed );
-
-        return result;
-    }
-
-    //////////////////////////////////////////////////////////////////
-
-    unsigned child_timeout( unsigned tu_timeout, double elapsed )
-    {
-      if( tu_timeout == 0U )
-          return 0U;
-
-      unsigned elpsed_sec = static_cast<unsigned>(elapsed); // rounding to number of whole seconds
-
-      return tu_timeout > elpsed_sec ? tu_timeout - elpsed_sec : TIMEOUT_EXCEEDED;
-    }
-
-    struct priority_order {
-        bool operator()( test_observer* lhs, test_observer* rhs ) const
-        {
-            return (lhs->priority() < rhs->priority()) || ((lhs->priority() == rhs->priority()) && (lhs < rhs));
-        }
-    };
-
-    // Data members
-    typedef std::map<test_unit_id,test_unit*>       test_unit_store;
-    typedef std::set<test_observer*,priority_order> observer_store;
-    struct context_frame {
-        context_frame( std::string const& d, int id, bool sticky )
-        : descr( d )
-        , frame_id( id )
-        , is_sticky( sticky )
-        {}
-
-        std::string descr;
-        int         frame_id;
-        bool        is_sticky;
-    };
-    typedef std::vector<context_frame> context_data;
-
-    master_test_suite_t* m_master_test_suite;
-    std::vector<test_suite*> m_auto_test_suites;
-
-    test_unit_id    m_curr_test_case;
-    test_unit_store m_test_units;
-
-    test_unit_id    m_next_test_case_id;
-    test_unit_id    m_next_test_suite_id;
-
-    bool            m_test_in_progress;
-
-    observer_store  m_observers;
-    context_data    m_context;
-    int             m_context_idx;
-
-    boost::execution_monitor m_aux_em;
-
-    std::map<output_format, runtime_config::stream_holder> m_log_sinks;
-    runtime_config::stream_holder m_report_sink;
-};
-
-//____________________________________________________________________________//
-
-namespace impl {
-namespace {
-
-#if defined(__CYGWIN__)
-framework::state& s_frk_state() { static framework::state* the_inst = 0; if(!the_inst) the_inst = new framework::state; return *the_inst; }
-#else
-framework::state& s_frk_state() { static framework::state the_inst; return the_inst; }
-#endif
-
-} // local namespace
-
-void
-setup_for_execution( test_unit const& tu )
-{
-    s_frk_state().deduce_run_status( tu.p_id );
-}
-
-struct sum_to_first_only {
-    sum_to_first_only() : is_first(true) {}
-    template <class T, class U>
-    T operator()(T const& l_, U const& r_) {
-        if(is_first) {
-            is_first = false;
-            return l_ + r_.first;
-        }
-        return l_ + ", " + r_.first;
-    }
-
-    bool is_first;
-};
-
-void
-setup_loggers()
-{
-
-    BOOST_TEST_I_TRY {
-
-
-
-#ifdef BOOST_TEST_SUPPORT_TOKEN_ITERATOR
-    bool has_combined_logger = runtime_config::has( runtime_config::COMBINED_LOGGER )
-        && !runtime_config::get< std::vector<std::string> >( runtime_config::COMBINED_LOGGER ).empty();
-#else
-    bool has_combined_logger = false;
-#endif
-
-    if( !has_combined_logger ) {
-        unit_test_log.set_threshold_level( runtime_config::get<log_level>( runtime_config::LOG_LEVEL ) );
-        const output_format format = runtime_config::get<output_format>( runtime_config::LOG_FORMAT );
-        unit_test_log.set_format( format );
-
-        runtime_config::stream_holder& stream_logger = s_frk_state().m_log_sinks[format];
-        if( runtime_config::has( runtime_config::LOG_SINK ) )
-            stream_logger.setup( runtime_config::get<const_string>( runtime_config::LOG_SINK ) );
-        unit_test_log.set_stream( stream_logger.ref() );
-    }
-    else
-    {
-
-        const std::vector<std::string>& v_output_format = runtime_config::get< std::vector<std::string> >( runtime_config::COMBINED_LOGGER ) ;
-
-        static const std::pair<const char*, log_level> all_log_levels[] = {
-            std::make_pair( "all"           , log_successful_tests ),
-            std::make_pair( "success"       , log_successful_tests ),
-            std::make_pair( "test_suite"    , log_test_units ),
-            std::make_pair( "unit_scope"    , log_test_units ),
-            std::make_pair( "message"       , log_messages ),
-            std::make_pair( "warning"       , log_warnings ),
-            std::make_pair( "error"         , log_all_errors ),
-            std::make_pair( "cpp_exception" , log_cpp_exception_errors ),
-            std::make_pair( "system_error"  , log_system_errors ),
-            std::make_pair( "fatal_error"   , log_fatal_errors ),
-            std::make_pair( "nothing"       , log_nothing )
-        };
-
-        static const std::pair<const char*, output_format> all_formats[] = {
-            std::make_pair( "HRF"  , OF_CLF ),
-            std::make_pair( "CLF"  , OF_CLF ),
-            std::make_pair( "XML"  , OF_XML ),
-            std::make_pair( "JUNIT", OF_JUNIT )
-        };
-
-
-      bool is_first = true;
-
-      BOOST_TEST_FOREACH( const_string, current_multi_config, v_output_format ) {
-
-#ifdef BOOST_TEST_SUPPORT_TOKEN_ITERATOR
-            utils::string_token_iterator current_config( current_multi_config, (utils::dropped_delimeters = ":",
-                                                                                utils::kept_delimeters = utils::dt_none) );
-
-            for( ; current_config != utils::string_token_iterator() ; ++current_config) {
-
-                utils::string_token_iterator current_format_specs( *current_config, (utils::keep_empty_tokens,
-                                                                                     utils::dropped_delimeters = ",",
-                                                                                     utils::kept_delimeters = utils::dt_none) );
-
-                output_format format = OF_INVALID ; // default
-                if( current_format_specs != utils::string_token_iterator() &&
-                    current_format_specs->size() ) {
-
-                    for(size_t elem=0; elem < sizeof(all_formats)/sizeof(all_formats[0]); elem++) {
-                        if(const_string(all_formats[elem].first) == *current_format_specs) {
-                            format = all_formats[elem].second;
-                            break;
-                        }
-                    }
-                }
-
-                BOOST_TEST_I_ASSRT( format != OF_INVALID,
-                                    boost::runtime::access_to_missing_argument()
-                                        << "Unable to determine the logger type from '"
-                                        << *current_config
-                                        << "'. Possible choices are: "
-                                        << std::accumulate(all_formats,
-                                                           all_formats + sizeof(all_formats)/sizeof(all_formats[0]),
-                                                           std::string(""),
-                                                           sum_to_first_only())
-                                  );
-
-                // activates this format
-                if( is_first ) {
-                    unit_test_log.set_format( format );
-                }
-                else {
-                    unit_test_log.add_format( format );
-                }
-                is_first = false;
-
-                unit_test_log_formatter * const formatter = unit_test_log.get_formatter(format);
-                BOOST_TEST_SETUP_ASSERT( formatter, "Logger setup error" );
-
-                log_level formatter_log_level = invalid_log_level;
-                if( !current_format_specs->size() ) {
-                    formatter_log_level = formatter->get_log_level(); // default log level given by the formatter
-                }
-                else if( ++current_format_specs != utils::string_token_iterator() ) {
-
-                    for(size_t elem=0; elem < sizeof(all_log_levels)/sizeof(all_log_levels[0]); elem++) {
-                        if(const_string(all_log_levels[elem].first) == *current_format_specs) {
-                            formatter_log_level = all_log_levels[elem].second;
-                            break;
-                        }
-                    }
-                }
-
-
-                BOOST_TEST_I_ASSRT( formatter_log_level != invalid_log_level,
-                                    boost::runtime::access_to_missing_argument()
-                                        << "Unable to determine the log level from '"
-                                        << *current_config
-                                        << "'. Possible choices are: "
-                                        << std::accumulate(all_log_levels,
-                                                           all_log_levels + sizeof(all_log_levels)/sizeof(all_log_levels[0]),
-                                                           std::string(""),
-                                                           sum_to_first_only())
-                                   );
-
-                unit_test_log.set_threshold_level( format, formatter_log_level );
-
-                runtime_config::stream_holder& stream_logger = s_frk_state().m_log_sinks[format];
-                if( ++current_format_specs != utils::string_token_iterator() &&
-                    current_format_specs->size() ) {
-                    stream_logger.setup( *current_format_specs );
-                }
-                else {
-                    stream_logger.setup( formatter->get_default_stream_description() );
-                }
-                unit_test_log.set_stream( format, stream_logger.ref() );
-
-        }
-#endif
-      }
-
-    }
-    }
-    BOOST_TEST_I_CATCH( boost::runtime::init_error, ex ) {
-        BOOST_TEST_SETUP_ASSERT( false, ex.msg );
-    }
-    BOOST_TEST_I_CATCH( boost::runtime::input_error, ex ) {
-        std::cerr << ex.msg << "\n\n";
-
-        BOOST_TEST_I_THROW( framework::nothing_to_test( boost::exit_exception_failure ) );
-    }
-
-
-}
-
-//____________________________________________________________________________//
-
-} // namespace impl
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                framework::init               ************** //
-// ************************************************************************** //
-
-void
-init( init_unit_test_func init_func, int argc, char* argv[] )
-{
-    using namespace impl;
-
-    // 10. Set up runtime parameters
-    runtime_config::init( argc, argv );
-
-    // 20. Set the desired log level, format and sink
-    impl::setup_loggers();
-
-    // 30. Set the desired report level, format and sink
-    results_reporter::set_level( runtime_config::get<report_level>( runtime_config::REPORT_LEVEL ) );
-    results_reporter::set_format( runtime_config::get<output_format>( runtime_config::REPORT_FORMAT ) );
-
-    if( runtime_config::has( runtime_config::REPORT_SINK ) )
-        s_frk_state().m_report_sink.setup( runtime_config::get<const_string>( runtime_config::REPORT_SINK ) );
-    results_reporter::set_stream( s_frk_state().m_report_sink.ref() );
-
-    // 40. Register default test observers
-    register_observer( results_collector );
-    register_observer( unit_test_log );
-
-    if( runtime_config::get<bool>( runtime_config::SHOW_PROGRESS ) ) {
-        progress_monitor.set_stream( std::cout ); // defaults to stdout
-        register_observer( progress_monitor );
-    }
-
-    // 50. Set up memory leak detection
-    unsigned long detect_mem_leak = runtime_config::get<unsigned long>( runtime_config::DETECT_MEM_LEAKS );
-    if( detect_mem_leak > 0 ) {
-        debug::detect_memory_leaks( true, runtime_config::get<std::string>( runtime_config::REPORT_MEM_LEAKS ) );
-        debug::break_memory_alloc( (long)detect_mem_leak );
-    }
-
-    // 60. Initialize master unit test suite
-    master_test_suite().argc = argc;
-    master_test_suite().argv = argv;
-
-    // 70. Invoke test module initialization routine
-    BOOST_TEST_I_TRY {
-        s_frk_state().m_aux_em.vexecute( boost::bind( &impl::invoke_init_func, init_func ) );
-    }
-    BOOST_TEST_I_CATCH( execution_exception, ex )  {
-        BOOST_TEST_SETUP_ASSERT( false, ex.what() );
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-finalize_setup_phase( test_unit_id master_tu_id )
-{
-    if( master_tu_id == INV_TEST_UNIT_ID )
-        master_tu_id = master_test_suite().p_id;
-
-    // 10. Apply all decorators to the auto test units
-    class apply_decorators : public test_tree_visitor {
-    private:
-        // test_tree_visitor interface
-        virtual bool    visit( test_unit const& tu )
-        {
-            BOOST_TEST_FOREACH( decorator::base_ptr, d, tu.p_decorators.get() )
-                d->apply( const_cast<test_unit&>(tu) );
-
-            return true;
-        }
-    } ad;
-    traverse_test_tree( master_tu_id, ad, true );
-
-    // 20. Finalize setup phase
-    impl::order_info_per_tu tuoi;
-    impl::s_frk_state().deduce_siblings_order( master_tu_id, master_tu_id, tuoi );
-    impl::s_frk_state().finalize_default_run_status( master_tu_id, test_unit::RS_INVALID );
-}
-
-// ************************************************************************** //
-// **************               test_in_progress               ************** //
-// ************************************************************************** //
-
-bool
-test_in_progress()
-{
-    return impl::s_frk_state().m_test_in_progress;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************             framework::shutdown              ************** //
-// ************************************************************************** //
-
-void
-shutdown()
-{
-    // eliminating some fake memory leak reports. See for more details:
-    // http://connect.microsoft.com/VisualStudio/feedback/details/106937/memory-leaks-reported-by-debug-crt-inside-typeinfo-name
-
-#  if BOOST_WORKAROUND(BOOST_MSVC,  <= 1600 ) && !defined(_DLL) && defined(_DEBUG)
-#  if BOOST_WORKAROUND(BOOST_MSVC,  < 1600 )
-#define _Next next
-#define _MemPtr memPtr
-#endif
-   __type_info_node* pNode   = __type_info_root_node._Next;
-   __type_info_node* tmpNode = &__type_info_root_node;
-
-   for( ; pNode!=NULL; pNode = tmpNode ) {
-      tmpNode = pNode->_Next;
-      delete pNode->_MemPtr;
-      delete pNode;
-   }
-#  if BOOST_WORKAROUND(BOOST_MSVC,  < 1600 )
-#undef _Next
-#undef _MemPtr
-#endif
-#  endif
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************              register_test_unit              ************** //
-// ************************************************************************** //
-
-void
-register_test_unit( test_case* tc )
-{
-    BOOST_TEST_SETUP_ASSERT( tc->p_id == INV_TEST_UNIT_ID, BOOST_TEST_L( "test case already registered" ) );
-
-    test_unit_id new_id = impl::s_frk_state().m_next_test_case_id;
-
-    BOOST_TEST_SETUP_ASSERT( new_id != MAX_TEST_CASE_ID, BOOST_TEST_L( "too many test cases" ) );
-
-    typedef state::test_unit_store::value_type map_value_type;
-
-    impl::s_frk_state().m_test_units.insert( map_value_type( new_id, tc ) );
-    impl::s_frk_state().m_next_test_case_id++;
-
-    impl::s_frk_state().set_tu_id( *tc, new_id );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************              register_test_unit              ************** //
-// ************************************************************************** //
-
-void
-register_test_unit( test_suite* ts )
-{
-    BOOST_TEST_SETUP_ASSERT( ts->p_id == INV_TEST_UNIT_ID, BOOST_TEST_L( "test suite already registered" ) );
-
-    test_unit_id new_id = impl::s_frk_state().m_next_test_suite_id;
-
-    BOOST_TEST_SETUP_ASSERT( new_id != MAX_TEST_SUITE_ID, BOOST_TEST_L( "too many test suites" ) );
-
-    typedef state::test_unit_store::value_type map_value_type;
-
-    impl::s_frk_state().m_test_units.insert( map_value_type( new_id, ts ) );
-    impl::s_frk_state().m_next_test_suite_id++;
-
-    impl::s_frk_state().set_tu_id( *ts, new_id );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************             deregister_test_unit             ************** //
-// ************************************************************************** //
-
-void
-deregister_test_unit( test_unit* tu )
-{
-    impl::s_frk_state().m_test_units.erase( tu->p_id );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                     clear                    ************** //
-// ************************************************************************** //
-
-void
-clear()
-{
-    impl::s_frk_state().clear();
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               register_observer              ************** //
-// ************************************************************************** //
-
-void
-register_observer( test_observer& to )
-{
-    impl::s_frk_state().m_observers.insert( &to );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************              deregister_observer             ************** //
-// ************************************************************************** //
-
-void
-deregister_observer( test_observer& to )
-{
-    impl::s_frk_state().m_observers.erase( &to );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                  add_context                 ************** //
-// ************************************************************************** //
-
-int
-add_context( ::boost::unit_test::lazy_ostream const& context_descr, bool sticky )
-{
-    std::stringstream buffer;
-    context_descr( buffer );
-    int res_idx  = impl::s_frk_state().m_context_idx++;
-
-    impl::s_frk_state().m_context.push_back( state::context_frame( buffer.str(), res_idx, sticky ) );
-
-    return res_idx;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                 clear_context                ************** //
-// ************************************************************************** //
-
-struct frame_with_id {
-    explicit frame_with_id( int id ) : m_id( id ) {}
-
-    bool    operator()( state::context_frame const& f )
-    {
-        return f.frame_id == m_id;
-    }
-    int     m_id;
-};
-
-//____________________________________________________________________________//
-
-void
-clear_context( int frame_id )
-{
-    if( frame_id == -1 ) {   // clear all non sticky frames
-        for( int i=static_cast<int>(impl::s_frk_state().m_context.size())-1; i>=0; i-- )
-            if( !impl::s_frk_state().m_context[i].is_sticky )
-                impl::s_frk_state().m_context.erase( impl::s_frk_state().m_context.begin()+i );
-    }
-
-    else { // clear specific frame
-        state::context_data::iterator it =
-            std::find_if( impl::s_frk_state().m_context.begin(), impl::s_frk_state().m_context.end(), frame_with_id( frame_id ) );
-
-        if( it != impl::s_frk_state().m_context.end() ) // really an internal error if this is not true
-            impl::s_frk_state().m_context.erase( it );
-    }
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                  get_context                 ************** //
-// ************************************************************************** //
-
-context_generator
-get_context()
-{
-    return context_generator();
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               context_generator              ************** //
-// ************************************************************************** //
-
-bool
-context_generator::is_empty() const
-{
-    return impl::s_frk_state().m_context.empty();
-}
-
-//____________________________________________________________________________//
-
-const_string
-context_generator::next() const
-{
-    return m_curr_frame < impl::s_frk_state().m_context.size() ? impl::s_frk_state().m_context[m_curr_frame++].descr : const_string();
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               master_test_suite              ************** //
-// ************************************************************************** //
-
-master_test_suite_t&
-master_test_suite()
-{
-    if( !impl::s_frk_state().m_master_test_suite )
-        impl::s_frk_state().m_master_test_suite = new master_test_suite_t;
-
-    return *impl::s_frk_state().m_master_test_suite;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************            current_auto_test_suite           ************** //
-// ************************************************************************** //
-
-test_suite&
-current_auto_test_suite( test_suite* ts, bool push_or_pop )
-{
-    if( impl::s_frk_state().m_auto_test_suites.empty() )
-        impl::s_frk_state().m_auto_test_suites.push_back( &framework::master_test_suite() );
-
-    if( !push_or_pop )
-        impl::s_frk_state().m_auto_test_suites.pop_back();
-    else if( ts )
-        impl::s_frk_state().m_auto_test_suites.push_back( ts );
-
-    return *impl::s_frk_state().m_auto_test_suites.back();
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               current_test_case              ************** //
-// ************************************************************************** //
-
-test_case const&
-current_test_case()
-{
-    return get<test_case>( impl::s_frk_state().m_curr_test_case );
-}
-
-//____________________________________________________________________________//
-
-test_unit_id
-current_test_case_id()
-{
-    return impl::s_frk_state().m_curr_test_case;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                framework::get                ************** //
-// ************************************************************************** //
-
-test_unit&
-get( test_unit_id id, test_unit_type t )
-{
-    test_unit* res = impl::s_frk_state().m_test_units[id];
-
-    BOOST_TEST_I_ASSRT( (res->p_type & t) != 0, internal_error( "Invalid test unit type" ) );
-
-    return *res;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                framework::run                ************** //
-// ************************************************************************** //
-
-void
-run( test_unit_id id, bool continue_test )
-{
-    if( id == INV_TEST_UNIT_ID )
-        id = master_test_suite().p_id;
-
-    // Figure out run status for execution phase
-    impl::s_frk_state().deduce_run_status( id );
-
-    test_case_counter tcc;
-    traverse_test_tree( id, tcc );
-
-    BOOST_TEST_SETUP_ASSERT( tcc.p_count != 0 , runtime_config::get<std::vector<std::string> >( runtime_config::RUN_FILTERS ).empty()
-        ? BOOST_TEST_L( "test tree is empty" )
-        : BOOST_TEST_L( "no test cases matching filter or all test cases were disabled" ) );
-
-    bool    was_in_progress     = framework::test_in_progress();
-    bool    call_start_finish   = !continue_test || !was_in_progress;
-
-    impl::s_frk_state().m_test_in_progress = true;
-
-    if( call_start_finish ) {
-        BOOST_TEST_FOREACH( test_observer*, to, impl::s_frk_state().m_observers ) {
-            BOOST_TEST_I_TRY {
-                impl::s_frk_state().m_aux_em.vexecute( boost::bind( &test_observer::test_start, to, tcc.p_count ) );
-            }
-            BOOST_TEST_I_CATCH( execution_exception, ex ) {
-                BOOST_TEST_SETUP_ASSERT( false, ex.what() );
-            }
-        }
-    }
-
-    unsigned seed = runtime_config::get<unsigned>( runtime_config::RANDOM_SEED );
-    switch( seed ) {
-    case 0:
-        break;
-    case 1:
-        seed = static_cast<unsigned>( std::rand() ^ std::time( 0 ) ); // better init using std::rand() ^ ...
-    default:
-        BOOST_TEST_FRAMEWORK_MESSAGE( "Test cases order is shuffled using seed: " << seed );
-        std::srand( seed );
-    }
-
-    impl::s_frk_state().execute_test_tree( id );
-
-    if( call_start_finish ) {
-        BOOST_TEST_REVERSE_FOREACH( test_observer*, to, impl::s_frk_state().m_observers )
-            to->test_finish();
-    }
-
-    impl::s_frk_state().m_test_in_progress = was_in_progress;
-}
-
-//____________________________________________________________________________//
-
-void
-run( test_unit const* tu, bool continue_test )
-{
-    run( tu->p_id, continue_test );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               assertion_result               ************** //
-// ************************************************************************** //
-
-void
-assertion_result( unit_test::assertion_result ar )
-{
-    BOOST_TEST_FOREACH( test_observer*, to, impl::s_frk_state().m_observers )
-        to->assertion_result( ar );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               exception_caught               ************** //
-// ************************************************************************** //
-
-void
-exception_caught( execution_exception const& ex )
-{
-    BOOST_TEST_FOREACH( test_observer*, to, impl::s_frk_state().m_observers )
-        to->exception_caught( ex );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               test_unit_aborted              ************** //
-// ************************************************************************** //
-
-void
-test_unit_aborted( test_unit const& tu )
-{
-    BOOST_TEST_FOREACH( test_observer*, to, impl::s_frk_state().m_observers )
-        to->test_unit_aborted( tu );
-}
-
-//____________________________________________________________________________//
-
-} // namespace framework
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_FRAMEWORK_IPP_021005GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/impl/junit_log_formatter.ipp b/contrib/libboost/boost_1_62_0/boost/test/impl/junit_log_formatter.ipp
deleted file mode 100644
index a07ee5e2b0f..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/impl/junit_log_formatter.ipp
+++ /dev/null
@@ -1,627 +0,0 @@
-//  (C) Copyright 2016 Raffi Enficiaud.
-//  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
-///@brief Contains the implementatoin of the Junit log formatter (OF_JUNIT)
-// ***************************************************************************
-
-#ifndef BOOST_TEST_JUNIT_LOG_FORMATTER_IPP__
-#define BOOST_TEST_JUNIT_LOG_FORMATTER_IPP__
-
-// Boost.Test
-#include <boost/test/output/junit_log_formatter.hpp>
-#include <boost/test/execution_monitor.hpp>
-#include <boost/test/framework.hpp>
-#include <boost/test/tree/test_unit.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp>
-#include <boost/test/utils/xml_printer.hpp>
-#include <boost/test/utils/string_cast.hpp>
-#include <boost/test/framework.hpp>
-
-#include <boost/test/tree/visitor.hpp>
-#include <boost/test/tree/test_case_counter.hpp>
-#include <boost/test/tree/traverse.hpp>
-#include <boost/test/results_collector.hpp>
-
-#include <boost/test/utils/algorithm.hpp>
-#include <boost/test/utils/string_cast.hpp>
-
-//#include <boost/test/results_reporter.hpp>
-
-
-// Boost
-#include <boost/version.hpp>
-
-// STL
-#include <iostream>
-#include <fstream>
-#include <set>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace output {
-
-
-struct s_replace_chars {
-  template <class T>
-  void operator()(T& to_replace)
-  {
-    if(to_replace == '/')
-      to_replace = '.';
-    else if(to_replace == ' ')
-      to_replace = '_';
-  }
-};
-
-inline std::string tu_name_normalize(std::string full_name)
-{
-  // maybe directly using normalize_test_case_name instead?
-  std::for_each(full_name.begin(), full_name.end(), s_replace_chars());
-  return full_name;
-}
-
-const_string file_basename(const_string filename) {
-
-    const_string path_sep( "\\/" );
-    const_string::iterator it = unit_test::utils::find_last_of( filename.begin(), filename.end(),
-                                                                path_sep.begin(), path_sep.end() );
-    if( it != filename.end() )
-        filename.trim_left( it + 1 );
-
-    return filename;
-
-}
-
-// ************************************************************************** //
-// **************               junit_log_formatter              ************** //
-// ************************************************************************** //
-
-void
-junit_log_formatter::log_start( std::ostream& ostr, counter_t test_cases_amount)
-{
-    map_tests.clear();
-    list_path_to_root.clear();
-    root_id = INV_TEST_UNIT_ID;
-}
-
-//____________________________________________________________________________//
-
-class junit_result_helper : public test_tree_visitor {
-public:
-    explicit junit_result_helper(
-        std::ostream& stream,
-        test_unit const& ts,
-        junit_log_formatter::map_trace_t const& mt,
-        bool display_build_info )
-    : m_stream(stream)
-    , m_ts( ts )
-    , m_map_test( mt )
-    , m_id( 0 )
-    , m_display_build_info(display_build_info)
-    { }
-
-    void add_log_entry(std::string const& entry_type,
-                       test_case const& tc,
-                       junit_impl::junit_log_helper::assertion_entry const& log) const
-    {
-        m_stream
-            << "<" << entry_type
-            << " message" << utils::attr_value() << log.logentry_message
-            << " type" << utils::attr_value() << log.logentry_type
-            << ">";
-
-        if(!log.output.empty()) {
-            m_stream << utils::cdata() << "\n" + log.output;
-        }
-
-        m_stream << "</" << entry_type << ">";
-    }
-
-    void    visit( test_case const& tc )
-    {
-        test_results const& tr = results_collector.results( tc.p_id );
-
-        junit_impl::junit_log_helper detailed_log;
-        bool need_skipping_reason = false;
-        bool skipped = false;
-
-        junit_log_formatter::map_trace_t::const_iterator it_element(m_map_test.find(tc.p_id));
-        if( it_element != m_map_test.end() )
-        {
-            detailed_log = it_element->second;
-        }
-        else
-        {
-            need_skipping_reason = true;
-        }
-
-        std::string classname;
-        test_unit_id id(tc.p_parent_id);
-        while( id != m_ts.p_id ) {
-            test_unit const& tu = boost::unit_test::framework::get( id, TUT_ANY );
-
-            if(need_skipping_reason)
-            {
-                test_results const& tr_parent = results_collector.results( id );
-                if( tr_parent.p_skipped )
-                {
-                    skipped = true;
-                    detailed_log.system_out+= "- disabled: " + tu.full_name() + "\n";
-                }
-                junit_log_formatter::map_trace_t::const_iterator it_element_stack(m_map_test.find(id));
-                if( it_element_stack != m_map_test.end() )
-                {
-                    detailed_log.system_out+= "- skipping decision: '" + it_element_stack->second.system_out + "'";
-                    detailed_log.system_out = "SKIPPING decision stack:\n" + detailed_log.system_out;
-                    need_skipping_reason = false;
-                }
-            }
-
-            classname = tu_name_normalize(tu.p_name) + "." + classname;
-            id = tu.p_parent_id;
-        }
-
-        // removes the trailing dot
-        if(!classname.empty() && *classname.rbegin() == '.') {
-            classname.erase(classname.size()-1);
-        }
-
-        //
-        // test case header
-
-        // total number of assertions
-        m_stream << "<testcase assertions" << utils::attr_value() << tr.p_assertions_passed + tr.p_assertions_failed;
-
-        // class name
-        if(!classname.empty())
-            m_stream << " classname" << utils::attr_value() << classname;
-
-        // test case name and time taken
-        m_stream
-            << " name"      << utils::attr_value() << tu_name_normalize(tc.p_name)
-            << " time"      << utils::attr_value() << double(tr.p_duration_microseconds) * 1E-6
-            << ">" << std::endl;
-
-        if( tr.p_skipped || skipped ) {
-            m_stream << "<skipped/>" << std::endl;
-        }
-        else {
-
-          for(std::vector< junit_impl::junit_log_helper::assertion_entry >::const_iterator it(detailed_log.assertion_entries.begin());
-              it != detailed_log.assertion_entries.end();
-              ++it)
-          {
-              if(it->log_entry == junit_impl::junit_log_helper::assertion_entry::log_entry_failure) {
-                  add_log_entry("failure", tc, *it);
-              }
-              else if(it->log_entry == junit_impl::junit_log_helper::assertion_entry::log_entry_error) {
-                  add_log_entry("error", tc, *it);
-              }
-          }
-        }
-
-        // system-out + all info/messages
-        std::string system_out = detailed_log.system_out;
-        for(std::vector< junit_impl::junit_log_helper::assertion_entry >::const_iterator it(detailed_log.assertion_entries.begin());
-            it != detailed_log.assertion_entries.end();
-            ++it)
-        {
-            if(it->log_entry != junit_impl::junit_log_helper::assertion_entry::log_entry_info)
-                continue;
-            system_out += it->output;
-        }
-
-        if(!system_out.empty()) {
-            m_stream
-                << "<system-out>"
-                << utils::cdata() << system_out
-                << "</system-out>"
-                << std::endl;
-        }
-
-        // system-err output + test case informations
-        std::string system_err = detailed_log.system_err;
-        {
-            // test case information (redundant but useful)
-            std::ostringstream o;
-            o   << "Test case:" << std::endl
-                << "- name: " << tc.full_name() << std::endl
-                << "- description: '" << tc.p_description << "'" << std::endl
-                << "- file: " << file_basename(tc.p_file_name) << std::endl
-                << "- line: " << tc.p_line_num << std::endl
-                ;
-            system_err = o.str() + system_err;
-        }
-        m_stream
-            << "<system-err>"
-            << utils::cdata() << system_err
-            << "</system-err>"
-            << std::endl;
-
-        m_stream << "</testcase>" << std::endl;
-    }
-
-    bool    test_suite_start( test_suite const& ts )
-    {
-        // unique test suite, without s, nesting not supported in CI
-        if( m_ts.p_id != ts.p_id )
-            return true;
-
-        test_results const& tr = results_collector.results( ts.p_id );
-
-        m_stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << std::endl;
-        m_stream << "<testsuite";
-
-        m_stream
-          // << "disabled=\"" << tr.p_test_cases_skipped << "\" "
-          << " tests"     << utils::attr_value() << tr.p_test_cases_passed
-          << " skipped"   << utils::attr_value() << tr.p_test_cases_skipped
-          << " errors"    << utils::attr_value() << tr.p_test_cases_aborted
-          << " failures"  << utils::attr_value() << tr.p_test_cases_failed
-          << " id"        << utils::attr_value() << m_id++
-          << " name"      << utils::attr_value() << tu_name_normalize(ts.p_name)
-          << " time"      << utils::attr_value() << (tr.p_duration_microseconds * 1E-6)
-          << ">" << std::endl;
-
-        if(m_display_build_info)
-        {
-            m_stream  << "<properties>" << std::endl;
-            m_stream  << "<property name=\"platform\" value" << utils::attr_value() << BOOST_PLATFORM << std::endl;
-            m_stream  << "<property name=\"compiler\" value" << utils::attr_value() << BOOST_COMPILER << std::endl;
-            m_stream  << "<property name=\"stl\" value" << utils::attr_value() << BOOST_STDLIB << std::endl;
-
-            std::ostringstream o;
-            o << BOOST_VERSION/100000 << "." << BOOST_VERSION/100 % 1000 << "." << BOOST_VERSION % 100;
-            m_stream  << "<property name=\"boost\" value" << utils::attr_value() << o.str() << std::endl;
-            m_stream  << "</properties>" << std::endl;
-        }
-
-        return true; // indicates that the children should also be parsed
-    }
-
-    virtual void    test_suite_finish( test_suite const& ts )
-    {
-        if( m_ts.p_id != ts.p_id )
-            return;
-        m_stream << "</testsuite>";
-    }
-
-private:
-    // Data members
-    std::ostream& m_stream;
-    test_unit const& m_ts;
-    junit_log_formatter::map_trace_t const& m_map_test;
-    size_t m_id;
-    bool m_display_build_info;
-};
-
-
-
-void
-junit_log_formatter::log_finish( std::ostream& ostr )
-{
-    junit_result_helper ch( ostr, boost::unit_test::framework::get( root_id, TUT_SUITE ), map_tests, m_display_build_info );
-    traverse_test_tree( root_id, ch, true ); // last is to ignore disabled suite special handling
-
-    return;
-}
-
-//____________________________________________________________________________//
-
-void
-junit_log_formatter::log_build_info( std::ostream& ostr )
-{
-    m_display_build_info = true;
-}
-
-//____________________________________________________________________________//
-
-void
-junit_log_formatter::test_unit_start( std::ostream& ostr, test_unit const& tu )
-{
-    if(list_path_to_root.empty())
-        root_id = tu.p_id;
-    list_path_to_root.push_back( tu.p_id );
-    map_tests.insert(std::make_pair(tu.p_id, junit_impl::junit_log_helper())); // current_test_case_id not working here
-}
-
-
-
-//____________________________________________________________________________//
-
-void
-junit_log_formatter::test_unit_finish( std::ostream& ostr, test_unit const& tu, unsigned long elapsed )
-{
-    // the time is already stored in the result_reporter
-    assert( tu.p_id == list_path_to_root.back() );
-    list_path_to_root.pop_back();
-}
-
-void
-junit_log_formatter::test_unit_aborted( std::ostream& os, test_unit const& tu )
-{
-    assert( tu.p_id == list_path_to_root.back() );
-    //list_path_to_root.pop_back();
-}
-
-//____________________________________________________________________________//
-
-void
-junit_log_formatter::test_unit_skipped( std::ostream& ostr, test_unit const& tu, const_string reason )
-{
-    if(tu.p_type == TUT_CASE)
-    {
-        junit_impl::junit_log_helper& v = map_tests[tu.p_id];
-        v.system_out.assign(reason.begin(), reason.end());
-    }
-    else
-    {
-        junit_impl::junit_log_helper& v = map_tests[tu.p_id];
-        v.system_out.assign(reason.begin(), reason.end());
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-junit_log_formatter::log_exception_start( std::ostream& ostr, log_checkpoint_data const& checkpoint_data, execution_exception const& ex )
-{
-    std::ostringstream o;
-    execution_exception::location const& loc = ex.where();
-
-    m_is_last_assertion_or_error = false;
-
-    if(!list_path_to_root.empty())
-    {
-        junit_impl::junit_log_helper& last_entry = map_tests[list_path_to_root.back()];
-
-        junit_impl::junit_log_helper::assertion_entry entry;
-
-        entry.logentry_message = "unexpected exception";
-        entry.log_entry = junit_impl::junit_log_helper::assertion_entry::log_entry_error;
-
-        switch(ex.code())
-        {
-        case execution_exception::cpp_exception_error:
-            entry.logentry_type = "uncaught exception";
-            break;
-        case execution_exception::timeout_error:
-            entry.logentry_type = "execution timeout";
-            break;
-        case execution_exception::user_error:
-            entry.logentry_type = "user, assert() or CRT error";
-            break;
-        case execution_exception::user_fatal_error:
-            // Looks like never used
-            entry.logentry_type = "user fatal error";
-            break;
-        case execution_exception::system_error:
-            entry.logentry_type = "system error";
-            break;
-        case execution_exception::system_fatal_error:
-            entry.logentry_type = "system fatal error";
-            break;
-        default:
-            entry.logentry_type = "no error"; // not sure how to handle this one
-            break;
-        }
-
-        o << "UNCAUGHT EXCEPTION:" << std::endl;
-        if( !loc.m_function.is_empty() )
-            o << "- function: \""   << loc.m_function << "\"" << std::endl;
-
-        o << "- file: " << file_basename(loc.m_file_name) << std::endl
-          << "- line: " << loc.m_line_num << std::endl
-          << std::endl;
-
-        o << "\nEXCEPTION STACK TRACE: --------------\n" << ex.what()
-          << "\n-------------------------------------";
-
-        if( !checkpoint_data.m_file_name.is_empty() ) {
-            o << std::endl << std::endl
-              << "Last checkpoint:" << std::endl
-              << "- message: \"" << checkpoint_data.m_message << "\"" << std::endl
-              << "- file: " << file_basename(checkpoint_data.m_file_name) << std::endl
-              << "- line: " << checkpoint_data.m_line_num << std::endl
-            ;
-        }
-
-        entry.output = o.str();
-
-        last_entry.assertion_entries.push_back(entry);
-    }
-
-    // check what to do with this one
-}
-
-//____________________________________________________________________________//
-
-void
-junit_log_formatter::log_exception_finish( std::ostream& ostr )
-{
-    // sealing the last entry
-    assert(!map_tests[list_path_to_root.back()].assertion_entries.back().sealed);
-    map_tests[list_path_to_root.back()].assertion_entries.back().sealed = true;
-}
-
-//____________________________________________________________________________//
-
-void
-junit_log_formatter::log_entry_start( std::ostream& ostr, log_entry_data const& entry_data, log_entry_types let )
-{
-    junit_impl::junit_log_helper& last_entry = map_tests[list_path_to_root.back()];
-    m_is_last_assertion_or_error = true;
-    switch(let)
-    {
-      case unit_test_log_formatter::BOOST_UTL_ET_INFO:
-      case unit_test_log_formatter::BOOST_UTL_ET_MESSAGE:
-      case unit_test_log_formatter::BOOST_UTL_ET_WARNING:
-      {
-        std::ostringstream o;
-
-        junit_impl::junit_log_helper::assertion_entry entry;
-        entry.log_entry = junit_impl::junit_log_helper::assertion_entry::log_entry_info;
-        entry.logentry_message = "info";
-        entry.logentry_type = "message";
-
-        o << (let == unit_test_log_formatter::BOOST_UTL_ET_WARNING ?
-              "WARNING:" : (let == unit_test_log_formatter::BOOST_UTL_ET_MESSAGE ?
-                            "MESSAGE:" : "INFO:"))
-             << std::endl
-          << "- file   : " << file_basename(entry_data.m_file_name) << std::endl
-          << "- line   : " << entry_data.m_line_num << std::endl
-          << "- message: "; // no CR
-
-        entry.output += o.str();
-        last_entry.assertion_entries.push_back(entry);
-        break;
-      }
-      default:
-      case unit_test_log_formatter::BOOST_UTL_ET_ERROR:
-      case unit_test_log_formatter::BOOST_UTL_ET_FATAL_ERROR:
-      {
-        std::ostringstream o;
-        junit_impl::junit_log_helper::assertion_entry entry;
-        entry.log_entry = junit_impl::junit_log_helper::assertion_entry::log_entry_failure;
-        entry.logentry_message = "failure";
-        entry.logentry_type = (let == unit_test_log_formatter::BOOST_UTL_ET_ERROR ? "assertion error" : "fatal error");
-
-        o << "ASSERTION FAILURE:" << std::endl
-          << "- file   : " << file_basename(entry_data.m_file_name) << std::endl
-          << "- line   : " << entry_data.m_line_num << std::endl
-          << "- message: " ; // no CR
-
-        entry.output += o.str();
-        last_entry.assertion_entries.push_back(entry);
-        break;
-      }
-    }
-
-}
-
-      //____________________________________________________________________________//
-
-
-
-//____________________________________________________________________________//
-
-void
-junit_log_formatter::log_entry_value( std::ostream& ostr, const_string value )
-{
-    assert(map_tests[list_path_to_root.back()].assertion_entries.empty() || !map_tests[list_path_to_root.back()].assertion_entries.back().sealed);
-    junit_impl::junit_log_helper& last_entry = map_tests[list_path_to_root.back()];
-    std::ostringstream o;
-    utils::print_escaped_cdata( o, value );
-
-    if(!last_entry.assertion_entries.empty())
-    {
-        junit_impl::junit_log_helper::assertion_entry& log_entry = last_entry.assertion_entries.back();
-        log_entry.output += value;
-    }
-    else
-    {
-        // this may be a message coming from another observer
-        // the prefix is set in the log_entry_start
-        last_entry.system_out += value;
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-junit_log_formatter::log_entry_finish( std::ostream& ostr )
-{
-    assert(map_tests[list_path_to_root.back()].assertion_entries.empty() || !map_tests[list_path_to_root.back()].assertion_entries.back().sealed);
-    junit_impl::junit_log_helper& last_entry = map_tests[list_path_to_root.back()];
-    if(!last_entry.assertion_entries.empty()) {
-        junit_impl::junit_log_helper::assertion_entry& log_entry = last_entry.assertion_entries.back();
-        log_entry.output += "\n\n"; // quote end, CR
-        log_entry.sealed = true;
-    }
-    else {
-        last_entry.system_out += "\n\n"; // quote end, CR
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-junit_log_formatter::entry_context_start( std::ostream& ostr, log_level )
-{
-    std::vector< junit_impl::junit_log_helper::assertion_entry > &v_failure_or_error = map_tests[list_path_to_root.back()].assertion_entries;
-    assert(!v_failure_or_error.back().sealed);
-
-    if(m_is_last_assertion_or_error)
-    {
-        v_failure_or_error.back().output += "\n- context:\n";
-    }
-    else
-    {
-        v_failure_or_error.back().output += "\n\nCONTEXT:\n";
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-junit_log_formatter::entry_context_finish( std::ostream& ostr )
-{
-    // no op, may be removed
-    assert(!map_tests[list_path_to_root.back()].assertion_entries.back().sealed);
-}
-
-//____________________________________________________________________________//
-
-void
-junit_log_formatter::log_entry_context( std::ostream& ostr, const_string context_descr )
-{
-    assert(!map_tests[list_path_to_root.back()].assertion_entries.back().sealed);
-    map_tests[list_path_to_root.back()].assertion_entries.back().output += (m_is_last_assertion_or_error ? "  - '": "- '") + std::string(context_descr.begin(), context_descr.end()) + "'\n"; // quote end
-}
-
-//____________________________________________________________________________//
-
-
-std::string
-junit_log_formatter::get_default_stream_description() const {
-    std::string name = framework::master_test_suite().p_name.value;
-
-    static const std::string to_replace[] =  { " ", "\"", "/", "\\", ":"};
-    static const std::string replacement[] = { "_", "_" , "_", "_" , "_"};
-
-    name = unit_test::utils::replace_all_occurrences_of(
-        name,
-        to_replace, to_replace + sizeof(to_replace)/sizeof(to_replace[0]),
-        replacement, replacement + sizeof(replacement)/sizeof(replacement[0]));
-
-    std::ifstream check_init((name + ".xml").c_str());
-    if(!check_init)
-        return name + ".xml";
-
-    int index = 0;
-    for(; index < 100; index++) {
-      std::string candidate = name + "_" + utils::string_cast(index) + ".xml";
-      std::ifstream file(candidate.c_str());
-      if(!file)
-          return candidate;
-    }
-
-    return name + ".xml";
-}
-
-} // namespace output
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_junit_log_formatter_IPP_020105GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/impl/plain_report_formatter.ipp b/contrib/libboost/boost_1_62_0/boost/test/impl/plain_report_formatter.ipp
deleted file mode 100644
index 262083eeaab..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/impl/plain_report_formatter.ipp
+++ /dev/null
@@ -1,207 +0,0 @@
-//  (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 : plain report formatter definition
-// ***************************************************************************
-
-#ifndef BOOST_TEST_PLAIN_REPORT_FORMATTER_IPP_020105GER
-#define BOOST_TEST_PLAIN_REPORT_FORMATTER_IPP_020105GER
-
-// Boost.Test
-#include <boost/test/output/plain_report_formatter.hpp>
-#include <boost/test/utils/custom_manip.hpp>
-#include <boost/test/results_collector.hpp>
-#include <boost/test/unit_test_parameters.hpp>
-
-#include <boost/test/tree/test_unit.hpp>
-
-#include <boost/test/utils/basic_cstring/io.hpp>
-#include <boost/test/utils/setcolor.hpp>
-
-// STL
-#include <iomanip>
-#include <boost/config/no_tr1/cmath.hpp>
-#include <iostream>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-# ifdef BOOST_NO_STDC_NAMESPACE
-namespace std { using ::log10; }
-# endif
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace output {
-
-namespace {
-
-typedef utils::custom_manip<struct quote_t> quote;
-
-template<typename T>
-inline std::ostream&
-operator<<( utils::custom_printer<quote> const& p, T const& value )
-{
-    *p << '"' << value << '"';
-
-    return *p;
-}
-
-//____________________________________________________________________________//
-
-void
-print_stat_value( std::ostream& ostr, counter_t v, counter_t indent, counter_t total, const_string name, const_string res )
-{
-    if( v == 0 )
-        return;
-
-    if( total > 0 )
-        ostr << std::setw( static_cast<int>(indent) ) << "" << v << ' ' << name << ( v != 1 ? "s" : "" )
-             << " out of " << total << ' ' << res << '\n';
-    else
-        ostr << std::setw( static_cast<int>(indent) ) << "" << v << ' ' << res << ' ' << name << ( v != 1 ? "s" : "" ) << '\n';
-}
-
-//____________________________________________________________________________//
-
-} // local namespace
-
-// ************************************************************************** //
-// **************             plain_report_formatter           ************** //
-// ************************************************************************** //
-
-void
-plain_report_formatter::results_report_start( std::ostream& ostr )
-{
-    m_indent = 0;
-    m_color_output = runtime_config::get<bool>( runtime_config::COLOR_OUTPUT );
-    ostr << '\n';
-}
-
-//____________________________________________________________________________//
-
-void
-plain_report_formatter::results_report_finish( std::ostream& ostr )
-{
-    ostr.flush();
-}
-
-//____________________________________________________________________________//
-
-void
-plain_report_formatter::test_unit_report_start( test_unit const& tu, std::ostream& ostr )
-{
-    test_results const& tr = results_collector.results( tu.p_id );
-
-    const_string descr;
-
-    if( tr.passed() )
-        descr = "has passed";
-    else if( tr.p_skipped )
-        descr = "was skipped";
-    else if( tr.p_aborted )
-        descr = "was aborted";
-    else
-        descr = "has failed";
-
-    ostr << std::setw( static_cast<int>(m_indent) ) << ""
-         << "Test " << tu.p_type_name << ' ' << quote() << tu.full_name() << ' ' << descr;
-
-    if( tr.p_skipped ) {
-        ostr  << "\n";
-        m_indent += 2;
-        return;
-    }
-
-    counter_t total_assertions  = tr.p_assertions_passed + tr.p_assertions_failed;
-    counter_t total_tc          = tr.p_test_cases_passed + tr.p_test_cases_warned + tr.p_test_cases_failed + tr.p_test_cases_skipped;
-
-    if( total_assertions > 0 || total_tc > 0 || tr.p_warnings_failed > 0)
-        ostr << " with:";
-
-    ostr << '\n';
-    m_indent += 2;
-
-    print_stat_value( ostr, tr.p_test_cases_passed , m_indent, total_tc        , "test case", "passed" );
-    print_stat_value( ostr, tr.p_test_cases_warned , m_indent, total_tc        , "test case", "passed with warnings" );
-    print_stat_value( ostr, tr.p_test_cases_failed , m_indent, total_tc        , "test case", "failed" );
-    print_stat_value( ostr, tr.p_test_cases_skipped, m_indent, total_tc        , "test case", "skipped" );
-    print_stat_value( ostr, tr.p_test_cases_aborted, m_indent, total_tc        , "test case", "aborted" );
-    print_stat_value( ostr, tr.p_assertions_passed , m_indent, total_assertions, "assertion", "passed" );
-    print_stat_value( ostr, tr.p_assertions_failed , m_indent, total_assertions, "assertion", "failed" );
-    print_stat_value( ostr, tr.p_warnings_failed   , m_indent, 0               , "warning"  , "failed" );
-    print_stat_value( ostr, tr.p_expected_failures , m_indent, 0               , "failure"  , "expected" );
-
-    ostr << '\n';
-}
-
-//____________________________________________________________________________//
-
-void
-plain_report_formatter::test_unit_report_finish( test_unit const&, std::ostream& )
-{
-    m_indent -= 2;
-}
-
-//____________________________________________________________________________//
-
-void
-plain_report_formatter::do_confirmation_report( test_unit const& tu, std::ostream& ostr )
-{
-    test_results const& tr = results_collector.results( tu.p_id );
-
-    if( tr.passed() ) {
-        BOOST_TEST_SCOPE_SETCOLOR( m_color_output, ostr, term_attr::BRIGHT, term_color::GREEN );
-
-        ostr << "*** No errors detected\n";
-        return;
-    }
-
-    BOOST_TEST_SCOPE_SETCOLOR( m_color_output, ostr, term_attr::BRIGHT, term_color::RED );
-
-    if( tr.p_skipped ) {
-        ostr << "*** The test " << tu.p_type_name << ' ' << quote() << tu.full_name() << " was skipped"
-             << "; see standard output for details\n";
-        return;
-    }
-
-    if( tr.p_aborted ) {
-        ostr << "*** The test " << tu.p_type_name << ' ' << quote() << tu.full_name() << " was aborted"
-             << "; see standard output for details\n";
-    }
-
-    if( tr.p_assertions_failed == 0 ) {
-        if( !tr.p_aborted )
-            ostr << "*** Errors were detected in the test " << tu.p_type_name << ' ' << quote() << tu.full_name()
-                 << "; see standard output for details\n";
-        return;
-    }
-
-    counter_t num_failures = tr.p_assertions_failed;
-
-    ostr << "*** " << num_failures << " failure" << ( num_failures != 1 ? "s are" : " is" ) << " detected";
-
-    if( tr.p_expected_failures > 0 )
-        ostr << " (" << tr.p_expected_failures << " failure" << ( tr.p_expected_failures != 1 ? "s are" : " is" ) << " expected)";
-
-    ostr << " in the test " << tu.p_type_name << " " << quote() << tu.full_name() << "\n";
-}
-
-//____________________________________________________________________________//
-
-} // namespace output
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_PLAIN_REPORT_FORMATTER_IPP_020105GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/impl/progress_monitor.ipp b/contrib/libboost/boost_1_62_0/boost/test/impl/progress_monitor.ipp
deleted file mode 100644
index 7fb3baf8f07..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/impl/progress_monitor.ipp
+++ /dev/null
@@ -1,185 +0,0 @@
-//  (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 : implements simple text based progress monitor
-// ***************************************************************************
-
-#ifndef BOOST_TEST_PROGRESS_MONITOR_IPP_020105GER
-#define BOOST_TEST_PROGRESS_MONITOR_IPP_020105GER
-
-// Boost.Test
-#include <boost/test/progress_monitor.hpp>
-#include <boost/test/unit_test_parameters.hpp>
-
-#include <boost/test/utils/setcolor.hpp>
-
-#include <boost/test/tree/test_unit.hpp>
-#include <boost/test/tree/test_case_counter.hpp>
-#include <boost/test/tree/traverse.hpp>
-
-// Boost
-#include <boost/scoped_ptr.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                progress_monitor              ************** //
-// ************************************************************************** //
-
-struct progress_display {
-    progress_display( counter_t expected_count, std::ostream& os )
-    : m_os(os)
-    , m_count( 0 )
-    , m_expected_count( expected_count )
-    , m_next_tic_count( 0 )
-    , m_tic( 0 )
-    {
-
-        m_os << "\n0%   10   20   30   40   50   60   70   80   90   100%"
-             << "\n|----|----|----|----|----|----|----|----|----|----|"
-             << std::endl;
-
-        if( !m_expected_count ) 
-            m_expected_count = 1;  // prevent divide by zero
-    }
-
-    unsigned long  operator+=( unsigned long increment )
-    {
-        if( (m_count += increment) < m_next_tic_count )
-            return m_count;
-
-        // use of floating point ensures that both large and small counts
-        // work correctly.  static_cast<>() is also used several places
-        // to suppress spurious compiler warnings. 
-        unsigned int tics_needed =  static_cast<unsigned int>(
-            (static_cast<double>(m_count)/m_expected_count)*50.0 );
-
-        do {
-            m_os << '*' << std::flush;
-        } while( ++m_tic < tics_needed );
-
-        m_next_tic_count = static_cast<unsigned long>((m_tic/50.0) * m_expected_count);
-
-        if( m_count == m_expected_count ) {
-            if( m_tic < 51 )
-                m_os << '*';
-
-            m_os << std::endl;
-        }
-
-        return m_count;
-    }
-    unsigned long   operator++()           { return operator+=( 1 ); }
-    unsigned long   count() const          { return m_count; }
-
-private:
-    BOOST_DELETED_FUNCTION(progress_display(progress_display const&))
-    BOOST_DELETED_FUNCTION(progress_display& operator=(progress_display const&))
-
-    std::ostream&   m_os;  // may not be present in all imps
-
-    unsigned long   m_count;
-    unsigned long   m_expected_count;
-    unsigned long   m_next_tic_count;
-    unsigned int    m_tic;
-};
-
-namespace {
-
-struct progress_monitor_impl {
-    // Constructor
-    progress_monitor_impl()
-    : m_stream( &std::cout )
-    , m_color_output( false )
-    {
-    }
-
-    std::ostream*                   m_stream;
-    scoped_ptr<progress_display>    m_progress_display;
-    bool                            m_color_output;
-};
-
-progress_monitor_impl& s_pm_impl() { static progress_monitor_impl the_inst; return the_inst; }
-
-#define PM_SCOPED_COLOR() \
-    BOOST_TEST_SCOPE_SETCOLOR( s_pm_impl().m_color_output, *s_pm_impl().m_stream, term_attr::BRIGHT, term_color::MAGENTA )
-
-} // local namespace
-
-//____________________________________________________________________________//
-
-void
-progress_monitor_t::test_start( counter_t test_cases_amount )
-{
-    s_pm_impl().m_color_output = runtime_config::get<bool>( runtime_config::COLOR_OUTPUT );
-
-    PM_SCOPED_COLOR();
-
-    s_pm_impl().m_progress_display.reset( new progress_display( test_cases_amount, *s_pm_impl().m_stream ) );
-}
-
-//____________________________________________________________________________//
-
-void
-progress_monitor_t::test_aborted()
-{
-    PM_SCOPED_COLOR();
-
-    (*s_pm_impl().m_progress_display) += s_pm_impl().m_progress_display->count();
-}
-
-//____________________________________________________________________________//
-
-void
-progress_monitor_t::test_unit_finish( test_unit const& tu, unsigned long )
-{
-    PM_SCOPED_COLOR();
-
-    if( tu.p_type == TUT_CASE )
-        ++(*s_pm_impl().m_progress_display);
-}
-
-//____________________________________________________________________________//
-
-void
-progress_monitor_t::test_unit_skipped( test_unit const& tu, const_string /*reason*/ )
-{
-    PM_SCOPED_COLOR();
-
-    test_case_counter tcc;
-    traverse_test_tree( tu, tcc );
-
-    (*s_pm_impl().m_progress_display) += tcc.p_count;
-}
-
-//____________________________________________________________________________//
-
-void
-progress_monitor_t::set_stream( std::ostream& ostr )
-{
-    s_pm_impl().m_stream = &ostr;
-}
-
-//____________________________________________________________________________//
-
-#undef PM_SCOPED_COLOR
-
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_PROGRESS_MONITOR_IPP_020105GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/impl/results_collector.ipp b/contrib/libboost/boost_1_62_0/boost/test/impl/results_collector.ipp
deleted file mode 100644
index daee8bc3bf8..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/impl/results_collector.ipp
+++ /dev/null
@@ -1,279 +0,0 @@
-//  (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 : implements Unit Test results collecting facility.
-// ***************************************************************************
-
-#ifndef BOOST_TEST_RESULTS_COLLECTOR_IPP_021105GER
-#define BOOST_TEST_RESULTS_COLLECTOR_IPP_021105GER
-
-// Boost.Test
-#include <boost/test/unit_test_log.hpp>
-#include <boost/test/results_collector.hpp>
-#include <boost/test/framework.hpp>
-
-#include <boost/test/tree/test_unit.hpp>
-#include <boost/test/tree/visitor.hpp>
-#include <boost/test/tree/test_case_counter.hpp>
-#include <boost/test/tree/traverse.hpp>
-
-// Boost
-#include <boost/cstdlib.hpp>
-
-// STL
-#include <map>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                 test_results                 ************** //
-// ************************************************************************** //
-
-test_results::test_results()
-{
-    clear();
-}
-
-//____________________________________________________________________________//
-
-bool
-test_results::passed() const
-{
-    return  !p_skipped                                  &&
-            p_test_cases_failed == 0                    &&
-            p_assertions_failed <= p_expected_failures  &&
-            p_test_cases_skipped == 0                   &&
-            !p_aborted;
-}
-
-//____________________________________________________________________________//
-
-int
-test_results::result_code() const
-{
-    return passed() ? exit_success
-           : ( (p_assertions_failed > p_expected_failures || p_skipped )
-                    ? exit_test_failure
-                    : exit_exception_failure );
-}
-
-//____________________________________________________________________________//
-
-void
-test_results::operator+=( test_results const& tr )
-{
-    p_assertions_passed.value   += tr.p_assertions_passed;
-    p_assertions_failed.value   += tr.p_assertions_failed;
-    p_warnings_failed.value     += tr.p_warnings_failed;
-    p_test_cases_passed.value   += tr.p_test_cases_passed;
-    p_test_cases_warned.value   += tr.p_test_cases_warned;
-    p_test_cases_failed.value   += tr.p_test_cases_failed;
-    p_test_cases_skipped.value  += tr.p_test_cases_skipped;
-    p_test_cases_aborted.value  += tr.p_test_cases_aborted;
-    p_duration_microseconds.value += tr.p_duration_microseconds;
-}
-
-//____________________________________________________________________________//
-
-void
-test_results::clear()
-{
-    p_assertions_passed.value   = 0;
-    p_assertions_failed.value   = 0;
-    p_warnings_failed.value     = 0;
-    p_expected_failures.value   = 0;
-    p_test_cases_passed.value   = 0;
-    p_test_cases_warned.value   = 0;
-    p_test_cases_failed.value   = 0;
-    p_test_cases_skipped.value  = 0;
-    p_test_cases_aborted.value  = 0;
-    p_duration_microseconds.value= 0;
-    p_aborted.value             = false;
-    p_skipped.value             = false;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               results_collector              ************** //
-// ************************************************************************** //
-
-namespace {
-
-struct results_collector_impl {
-    std::map<test_unit_id,test_results> m_results_store;
-};
-
-results_collector_impl& s_rc_impl() { static results_collector_impl the_inst; return the_inst; }
-
-} // local namespace
-
-//____________________________________________________________________________//
-
-void
-results_collector_t::test_start( counter_t )
-{
-    s_rc_impl().m_results_store.clear();
-}
-
-//____________________________________________________________________________//
-
-void
-results_collector_t::test_unit_start( test_unit const& tu )
-{
-    // init test_results entry
-    test_results& tr = s_rc_impl().m_results_store[tu.p_id];
-
-    tr.clear();
-
-    tr.p_expected_failures.value = tu.p_expected_failures;
-}
-
-//____________________________________________________________________________//
-
-class results_collect_helper : public test_tree_visitor {
-public:
-    explicit results_collect_helper( test_results& tr, test_unit const& ts ) : m_tr( tr ), m_ts( ts ) {}
-
-    void    visit( test_case const& tc )
-    {
-        test_results const& tr = results_collector.results( tc.p_id );
-        m_tr += tr;
-
-        if( tr.passed() ) {
-            if( tr.p_warnings_failed )
-                m_tr.p_test_cases_warned.value++;
-            else
-                m_tr.p_test_cases_passed.value++;
-        }
-        else if( tr.p_skipped )
-            m_tr.p_test_cases_skipped.value++;
-        else {
-            if( tr.p_aborted )
-                m_tr.p_test_cases_aborted.value++;
-
-            m_tr.p_test_cases_failed.value++;
-        }
-    }
-    bool    test_suite_start( test_suite const& ts )
-    {
-        if( m_ts.p_id == ts.p_id )
-            return true;
-
-        m_tr += results_collector.results( ts.p_id );
-        return false;
-    }
-
-private:
-    // Data members
-    test_results&       m_tr;
-    test_unit const&    m_ts;
-};
-
-//____________________________________________________________________________//
-
-void
-results_collector_t::test_unit_finish( test_unit const& tu, unsigned long elapsed_in_microseconds )
-{
-    if( tu.p_type == TUT_SUITE ) {
-        results_collect_helper ch( s_rc_impl().m_results_store[tu.p_id], tu );
-
-        traverse_test_tree( tu, ch );
-    }
-    else {
-        test_results & tr = s_rc_impl().m_results_store[tu.p_id];
-        tr.p_duration_microseconds.value = elapsed_in_microseconds;
-
-        bool num_failures_match = tr.p_aborted || tr.p_assertions_failed >= tr.p_expected_failures;
-        if( !num_failures_match )
-            BOOST_TEST_FRAMEWORK_MESSAGE( "Test case " << tu.full_name() << " has fewer failures than expected" );
-
-        bool check_any_assertions = tr.p_aborted || (tr.p_assertions_failed != 0) || (tr.p_assertions_passed != 0);
-        if( !check_any_assertions )
-            BOOST_TEST_FRAMEWORK_MESSAGE( "Test case " << tu.full_name() << " did not check any assertions" );
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-results_collector_t::test_unit_skipped( test_unit const& tu, const_string /*reason*/ )
-{
-    test_results& tr = s_rc_impl().m_results_store[tu.p_id];
-
-    tr.clear();
-
-    tr.p_skipped.value = true;
-
-    if( tu.p_type == TUT_SUITE ) {
-        test_case_counter tcc;
-        traverse_test_tree( tu, tcc );
-
-        tr.p_test_cases_skipped.value = tcc.p_count;
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-results_collector_t::assertion_result( unit_test::assertion_result ar )
-{
-    test_results& tr = s_rc_impl().m_results_store[framework::current_test_case_id()];
-
-    switch( ar ) {
-    case AR_PASSED: tr.p_assertions_passed.value++; break;
-    case AR_FAILED: tr.p_assertions_failed.value++; break;
-    case AR_TRIGGERED: tr.p_warnings_failed.value++; break;
-    }
-
-    if( tr.p_assertions_failed == 1 )
-        first_failed_assertion();
-}
-
-//____________________________________________________________________________//
-
-void
-results_collector_t::exception_caught( execution_exception const& )
-{
-    test_results& tr = s_rc_impl().m_results_store[framework::current_test_case_id()];
-
-    tr.p_assertions_failed.value++;
-}
-
-//____________________________________________________________________________//
-
-void
-results_collector_t::test_unit_aborted( test_unit const& tu )
-{
-    s_rc_impl().m_results_store[tu.p_id].p_aborted.value = true;
-}
-
-//____________________________________________________________________________//
-
-test_results const&
-results_collector_t::results( test_unit_id id ) const
-{
-    return s_rc_impl().m_results_store[id];
-}
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_RESULTS_COLLECTOR_IPP_021105GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/impl/results_reporter.ipp b/contrib/libboost/boost_1_62_0/boost/test/impl/results_reporter.ipp
deleted file mode 100644
index 87c1172e127..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/impl/results_reporter.ipp
+++ /dev/null
@@ -1,197 +0,0 @@
-//  (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 : result reporting facilties
-// ***************************************************************************
-
-#ifndef BOOST_TEST_RESULTS_REPORTER_IPP_020105GER
-#define BOOST_TEST_RESULTS_REPORTER_IPP_020105GER
-
-// Boost.Test
-#include <boost/test/results_reporter.hpp>
-#include <boost/test/results_collector.hpp>
-#include <boost/test/framework.hpp>
-
-#include <boost/test/output/plain_report_formatter.hpp>
-#include <boost/test/output/xml_report_formatter.hpp>
-
-#include <boost/test/tree/visitor.hpp>
-#include <boost/test/tree/test_unit.hpp>
-#include <boost/test/tree/traverse.hpp>
-
-// Boost
-#include <boost/scoped_ptr.hpp>
-#include <boost/io/ios_state.hpp>
-typedef ::boost::io::ios_base_all_saver io_saver_type;
-
-// STL
-#include <iostream>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace results_reporter {
-
-// ************************************************************************** //
-// **************        result reporter implementation        ************** //
-// ************************************************************************** //
-
-namespace {
-
-struct results_reporter_impl : test_tree_visitor {
-    // Constructor
-    results_reporter_impl()
-    : m_stream( &std::cerr )
-    , m_stream_state_saver( new io_saver_type( std::cerr ) )
-    , m_report_level( CONFIRMATION_REPORT )
-    , m_formatter( new output::plain_report_formatter )
-    {}
-
-    // test tree visitor interface implementation
-    void    visit( test_case const& tc )
-    {
-        m_formatter->test_unit_report_start( tc, *m_stream );
-        m_formatter->test_unit_report_finish( tc, *m_stream );
-    }
-    bool    test_suite_start( test_suite const& ts )
-    {
-        m_formatter->test_unit_report_start( ts, *m_stream );
-
-        if( m_report_level == DETAILED_REPORT && !results_collector.results( ts.p_id ).p_skipped )
-            return true;
-
-        m_formatter->test_unit_report_finish( ts, *m_stream );
-        return false;
-    }
-    void    test_suite_finish( test_suite const& ts )
-    {
-        m_formatter->test_unit_report_finish( ts, *m_stream );
-    }
-
-    typedef scoped_ptr<io_saver_type> saver_ptr;
-
-    // Data members
-    std::ostream*       m_stream;
-    saver_ptr           m_stream_state_saver;
-    report_level        m_report_level;
-    scoped_ptr<format>  m_formatter;
-};
-
-results_reporter_impl& s_rr_impl() { static results_reporter_impl the_inst; return the_inst; }
-
-} // local namespace
-
-// ************************************************************************** //
-// **************              report configuration            ************** //
-// ************************************************************************** //
-
-void
-set_level( report_level l )
-{
-    if( l != INV_REPORT_LEVEL )
-        s_rr_impl().m_report_level = l;
-}
-
-//____________________________________________________________________________//
-
-void
-set_stream( std::ostream& ostr )
-{
-    s_rr_impl().m_stream = &ostr;
-    s_rr_impl().m_stream_state_saver.reset( new io_saver_type( ostr ) );
-}
-
-//____________________________________________________________________________//
-
-std::ostream&
-get_stream()
-{
-    return *s_rr_impl().m_stream;
-}
-
-//____________________________________________________________________________//
-
-void
-set_format( output_format rf )
-{
-    switch( rf ) {
-    default:
-    case OF_CLF:
-        set_format( new output::plain_report_formatter );
-        break;
-    case OF_XML:
-        set_format( new output::xml_report_formatter );
-        break;
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-set_format( results_reporter::format* f )
-{
-    if( f )
-        s_rr_impl().m_formatter.reset( f );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               report initiation              ************** //
-// ************************************************************************** //
-
-void
-make_report( report_level l, test_unit_id id )
-{
-    if( l == INV_REPORT_LEVEL )
-        l = s_rr_impl().m_report_level;
-
-    if( l == NO_REPORT )
-        return;
-
-    if( id == INV_TEST_UNIT_ID )
-        id = framework::master_test_suite().p_id;
-
-    s_rr_impl().m_stream_state_saver->restore();
-
-    report_level bkup = s_rr_impl().m_report_level;
-    s_rr_impl().m_report_level = l;
-
-    s_rr_impl().m_formatter->results_report_start( *s_rr_impl().m_stream );
-
-    switch( l ) {
-    case CONFIRMATION_REPORT:
-        s_rr_impl().m_formatter->do_confirmation_report( framework::get<test_unit>( id ), *s_rr_impl().m_stream );
-        break;
-    case SHORT_REPORT:
-    case DETAILED_REPORT:
-        traverse_test_tree( id, s_rr_impl() );
-        break;
-    default:
-        break;
-    }
-
-    s_rr_impl().m_formatter->results_report_finish( *s_rr_impl().m_stream );
-    s_rr_impl().m_report_level = bkup;
-}
-
-//____________________________________________________________________________//
-
-} // namespace results_reporter
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_RESULTS_REPORTER_IPP_020105GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/impl/test_main.ipp b/contrib/libboost/boost_1_62_0/boost/test/impl/test_main.ipp
deleted file mode 100644
index 6adc5bb9c23..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/impl/test_main.ipp
+++ /dev/null
@@ -1,65 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001.
-//  (C) Copyright Beman Dawes 1995-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
-/// @brief Implements main function for Test Execution Monitor.
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TEST_MAIN_IPP_012205GER
-#define BOOST_TEST_TEST_MAIN_IPP_012205GER
-
-// Boost.Test
-#include <boost/test/framework.hpp>
-#include <boost/test/test_tools.hpp>
-#include <boost/test/unit_test_suite.hpp>
-
-// Boost
-#include <boost/cstdlib.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-extern int test_main( int argc, char* argv[] );    // prototype for user's test_main()
-
-struct test_main_caller {
-    test_main_caller( int argc, char** argv ) : m_argc( argc ), m_argv( argv ) {}
-
-    void operator()() {
-        int test_main_result = test_main( m_argc, m_argv );
-
-        // translate a test_main non-success return into a test error
-        BOOST_CHECK( test_main_result == 0 || test_main_result == boost::exit_success );
-    }
-
-private:
-    // Data members
-    int      m_argc;
-    char**   m_argv;
-};
-
-// ************************************************************************** //
-// **************                   test main                  ************** //
-// ************************************************************************** //
-
-::boost::unit_test::test_suite*
-init_unit_test_suite( int argc, char* argv[] ) {
-    using namespace ::boost::unit_test;
-
-    framework::master_test_suite().p_name.value = "Test Program";
-
-    framework::master_test_suite().add( BOOST_TEST_CASE( test_main_caller( argc, argv ) ) );
-
-    return 0;
-}
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TEST_MAIN_IPP_012205GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/impl/test_tools.ipp b/contrib/libboost/boost_1_62_0/boost/test/impl/test_tools.ipp
deleted file mode 100644
index a6b20a77291..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/impl/test_tools.ipp
+++ /dev/null
@@ -1,794 +0,0 @@
-//  (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 : supplies offline implementation for the Test Tools
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TEST_TOOLS_IPP_012205GER
-#define BOOST_TEST_TEST_TOOLS_IPP_012205GER
-
-// Boost.Test
-#include <boost/test/unit_test_log.hpp>
-#include <boost/test/tools/context.hpp>
-#include <boost/test/tools/output_test_stream.hpp>
-
-#include <boost/test/tools/detail/fwd.hpp>
-#include <boost/test/tools/detail/print_helper.hpp>
-
-#include <boost/test/framework.hpp>
-#include <boost/test/tree/test_unit.hpp>
-#include <boost/test/execution_monitor.hpp> // execution_aborted
-
-#include <boost/test/detail/throw_exception.hpp>
-
-#include <boost/test/utils/algorithm.hpp>
-
-// Boost
-#include <boost/config.hpp>
-
-// STL
-#include <fstream>
-#include <string>
-#include <cstring>
-#include <cctype>
-#include <cwchar>
-#include <stdexcept>
-#include <vector>
-#include <utility>
-#include <ios>
-
-// !! should we use #include <cstdarg>
-#include <stdarg.h>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-# ifdef BOOST_NO_STDC_NAMESPACE
-namespace std { using ::strcmp; using ::strlen; using ::isprint; }
-#if !defined( BOOST_NO_CWCHAR )
-namespace std { using ::wcscmp; }
-#endif
-# endif
-
-namespace boost {
-namespace test_tools {
-namespace tt_detail {
-
-// ************************************************************************** //
-// **************                print_log_value               ************** //
-// ************************************************************************** //
-
-void
-print_log_value<char>::operator()( std::ostream& ostr, char t )
-{
-    if( (std::isprint)( static_cast<unsigned char>(t) ) )
-        ostr << '\'' << t << '\'';
-    else
-        ostr << std::hex
-#if BOOST_TEST_USE_STD_LOCALE
-        << std::showbase
-#else
-        << "0x"
-#endif
-        << static_cast<int>(t);
-}
-
-//____________________________________________________________________________//
-
-void
-print_log_value<unsigned char>::operator()( std::ostream& ostr, unsigned char t )
-{
-    ostr << std::hex
-        // showbase is only available for new style streams:
-#if BOOST_TEST_USE_STD_LOCALE
-        << std::showbase
-#else
-        << "0x"
-#endif
-        << static_cast<int>(t);
-}
-
-//____________________________________________________________________________//
-
-void
-print_log_value<char const*>::operator()( std::ostream& ostr, char const* t )
-{
-    ostr << ( t ? t : "null string" );
-}
-
-//____________________________________________________________________________//
-
-void
-print_log_value<wchar_t const*>::operator()( std::ostream& ostr, wchar_t const* t )
-{
-    ostr << ( t ? t : L"null string" );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************            TOOL BOX Implementation           ************** //
-// ************************************************************************** //
-
-using ::boost::unit_test::lazy_ostream;
-
-static char const* check_str [] = { " == ", " != ", " < " , " <= ", " > " , " >= " };
-static char const* rever_str [] = { " != ", " == ", " >= ", " > " , " <= ", " < "  };
-
-template<typename OutStream>
-void
-format_report( OutStream& os, assertion_result const& pr, unit_test::lazy_ostream const& assertion_descr,
-               tool_level tl, check_type ct,
-               std::size_t num_args, va_list args,
-               char const*  prefix, char const*  suffix )
-{
-    using namespace unit_test;
-
-    switch( ct ) {
-    case CHECK_PRED:
-        os << prefix << assertion_descr << suffix;
-
-        if( !pr.has_empty_message() )
-            os << ". " << pr.message();
-        break;
-
-    case CHECK_BUILT_ASSERTION: {
-        os << prefix << assertion_descr << suffix;
-
-        if( tl != PASS ) {
-            const_string details_message = pr.message();
-
-            if( !details_message.is_empty() ) {
-                os << details_message;
-            }
-        }
-        break;
-    }
-
-    case CHECK_MSG:
-        if( tl == PASS )
-            os << prefix << "'" << assertion_descr << "'" << suffix;
-        else
-            os << assertion_descr;
-
-        if( !pr.has_empty_message() )
-            os << ". " << pr.message();
-        break;
-
-    case CHECK_EQUAL:
-    case CHECK_NE:
-    case CHECK_LT:
-    case CHECK_LE:
-    case CHECK_GT:
-    case CHECK_GE: {
-        char const*         arg1_descr  = va_arg( args, char const* );
-        lazy_ostream const* arg1_val    = va_arg( args, lazy_ostream const* );
-        char const*         arg2_descr  = va_arg( args, char const* );
-        lazy_ostream const* arg2_val    = va_arg( args, lazy_ostream const* );
-
-        os << prefix << arg1_descr << check_str[ct-CHECK_EQUAL] << arg2_descr << suffix;
-
-        if( tl != PASS )
-            os << " [" << *arg1_val << rever_str[ct-CHECK_EQUAL] << *arg2_val << "]" ;
-
-        if( !pr.has_empty_message() )
-            os << ". " << pr.message();
-        break;
-    }
-
-    case CHECK_CLOSE:
-    case CHECK_CLOSE_FRACTION: {
-        char const*         arg1_descr  = va_arg( args, char const* );
-        lazy_ostream const* arg1_val    = va_arg( args, lazy_ostream const* );
-        char const*         arg2_descr  = va_arg( args, char const* );
-        lazy_ostream const* arg2_val    = va_arg( args, lazy_ostream const* );
-        /* toler_descr = */               va_arg( args, char const* );
-        lazy_ostream const* toler_val   = va_arg( args, lazy_ostream const* );
-
-        os << "difference{" << pr.message()
-                            << "} between " << arg1_descr << "{" << *arg1_val
-                            << "} and "               << arg2_descr << "{" << *arg2_val
-                            << ( tl == PASS ? "} doesn't exceed " : "} exceeds " )
-                            << *toler_val;
-        if( ct == CHECK_CLOSE )
-            os << "%";
-        break;
-    }
-    case CHECK_SMALL: {
-        char const*         arg1_descr  = va_arg( args, char const* );
-        lazy_ostream const* arg1_val    = va_arg( args, lazy_ostream const* );
-        /* toler_descr = */               va_arg( args, char const* );
-        lazy_ostream const* toler_val   = va_arg( args, lazy_ostream const* );
-
-        os << "absolute value of " << arg1_descr << "{" << *arg1_val << "}"
-                                   << ( tl == PASS ? " doesn't exceed " : " exceeds " )
-                                   << *toler_val;
-
-        if( !pr.has_empty_message() )
-            os << ". " << pr.message();
-        break;
-    }
-
-    case CHECK_PRED_WITH_ARGS: {
-        std::vector< std::pair<char const*, lazy_ostream const*> > args_copy;
-        args_copy.reserve( num_args );
-        for( std::size_t i = 0; i < num_args; ++i ) {
-            char const* desc = va_arg( args, char const* );
-            lazy_ostream const* value = va_arg( args, lazy_ostream const* );
-            args_copy.push_back( std::make_pair( desc, value ) );
-        }
-
-        os << prefix << assertion_descr;
-
-        // print predicate call description
-        os << "( ";
-        for( std::size_t i = 0; i < num_args; ++i ) {
-            os << args_copy[i].first;
-
-            if( i != num_args-1 )
-                os << ", ";
-        }
-        os << " )" << suffix;
-
-        if( tl != PASS ) {
-            os << " for ( ";
-            for( std::size_t i = 0; i < num_args; ++i ) {
-                os << *args_copy[i].second;
-
-                if( i != num_args-1 )
-                    os << ", ";
-            }
-            os << " )";
-        }
-
-        if( !pr.has_empty_message() )
-            os << ". " << pr.message();
-        break;
-    }
-
-    case CHECK_EQUAL_COLL: {
-        char const* left_begin_descr    = va_arg( args, char const* );
-        char const* left_end_descr      = va_arg( args, char const* );
-        char const* right_begin_descr   = va_arg( args, char const* );
-        char const* right_end_descr     = va_arg( args, char const* );
-
-        os << prefix << "{ " << left_begin_descr  << ", " << left_end_descr  << " } == { "
-                             << right_begin_descr << ", " << right_end_descr << " }"
-           << suffix;
-
-        if( !pr.has_empty_message() )
-            os << ". " << pr.message();
-        break;
-    }
-
-    case CHECK_BITWISE_EQUAL: {
-        char const* left_descr    = va_arg( args, char const* );
-        char const* right_descr   = va_arg( args, char const* );
-
-        os << prefix << left_descr  << " =.= " << right_descr << suffix;
-
-        if( !pr.has_empty_message() )
-            os << ". " << pr.message();
-        break;
-    }
-    }
-}
-
-//____________________________________________________________________________//
-
-bool
-report_assertion( assertion_result const&   ar,
-                  lazy_ostream const&       assertion_descr,
-                  const_string              file_name,
-                  std::size_t               line_num,
-                  tool_level                tl,
-                  check_type                ct,
-                  std::size_t               num_args, ... )
-{
-    using namespace unit_test;
-
-    BOOST_TEST_I_ASSRT( framework::current_test_case_id() != INV_TEST_UNIT_ID,
-                        std::runtime_error( "Can't use testing tools outside of test case implementation." ) );
-
-    if( !!ar )
-        tl = PASS;
-
-    log_level    ll;
-    char const*  prefix;
-    char const*  suffix;
-
-    switch( tl ) {
-    case PASS:
-        ll      = log_successful_tests;
-        prefix  = "check ";
-        suffix  = " has passed";
-        break;
-    case WARN:
-        ll      = log_warnings;
-        prefix  = "condition ";
-        suffix  = " is not satisfied";
-        break;
-    case CHECK:
-        ll      = log_all_errors;
-        prefix  = "check ";
-        suffix  = " has failed";
-        break;
-    case REQUIRE:
-        ll      = log_fatal_errors;
-        prefix  = "critical check ";
-        suffix  = " has failed";
-        break;
-    default:
-        return true;
-    }
-
-    unit_test_log << unit_test::log::begin( file_name, line_num ) << ll;
-    va_list args;
-    va_start( args, num_args );
-
-    format_report( unit_test_log, ar, assertion_descr, tl, ct, num_args, args, prefix, suffix );
-
-    va_end( args );
-    unit_test_log << unit_test::log::end();
-
-    switch( tl ) {
-    case PASS:
-        framework::assertion_result( AR_PASSED );
-        return true;
-
-    case WARN:
-        framework::assertion_result( AR_TRIGGERED );
-        return false;
-
-    case CHECK:
-        framework::assertion_result( AR_FAILED );
-        return false;
-
-    case REQUIRE:
-        framework::assertion_result( AR_FAILED );
-
-        framework::test_unit_aborted( framework::current_test_case() );
-
-        BOOST_TEST_I_THROW( execution_aborted() );
-    }
-
-    return true;
-}
-
-//____________________________________________________________________________//
-
-assertion_result
-format_assertion_result( const_string expr_val, const_string details )
-{
-    assertion_result res(false);
-
-    bool starts_new_line = first_char( expr_val ) == '\n';
-
-    if( !starts_new_line && !expr_val.is_empty() )
-        res.message().stream() << " [" << expr_val << "]";
-
-    if( !details.is_empty() ) {
-        if( first_char(details) != '[' )
-            res.message().stream() << ". ";
-        else
-            res.message().stream() << " ";
-
-        res.message().stream() << details;
-    }
-
-    if( starts_new_line )
-        res.message().stream() << "." << expr_val;
-
-    return res;
-}
-
-//____________________________________________________________________________//
-
-BOOST_TEST_DECL std::string
-prod_report_format( assertion_result const& ar, unit_test::lazy_ostream const& assertion_descr, check_type ct, std::size_t num_args, ... )
-{
-    std::ostringstream msg_buff;
-
-    va_list args;
-    va_start( args, num_args );
-
-    format_report( msg_buff, ar, assertion_descr, CHECK, ct, num_args, args, "assertion ", " failed" );
-
-    va_end( args );
-
-    return msg_buff.str();
-}
-
-//____________________________________________________________________________//
-
-assertion_result
-equal_impl( char const* left, char const* right )
-{
-    return (left && right) ? std::strcmp( left, right ) == 0 : (left == right);
-}
-
-//____________________________________________________________________________//
-
-#if !defined( BOOST_NO_CWCHAR )
-
-assertion_result
-equal_impl( wchar_t const* left, wchar_t const* right )
-{
-    return (left && right) ? std::wcscmp( left, right ) == 0 : (left == right);
-}
-
-#endif // !defined( BOOST_NO_CWCHAR )
-
-//____________________________________________________________________________//
-
-bool
-is_defined_impl( const_string symbol_name, const_string symbol_value )
-{
-    symbol_value.trim_left( 2 );
-    return symbol_name != symbol_value;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                 context_frame                ************** //
-// ************************************************************************** //
-
-context_frame::context_frame( ::boost::unit_test::lazy_ostream const& context_descr )
-: m_frame_id( unit_test::framework::add_context( context_descr, true ) )
-{
-}
-
-//____________________________________________________________________________//
-
-context_frame::~context_frame()
-{
-    unit_test::framework::clear_context( m_frame_id );
-}
-
-//____________________________________________________________________________//
-
-context_frame::operator bool()
-{
-    return true;
-}
-
-//____________________________________________________________________________//
-
-} // namespace tt_detail
-
-// ************************************************************************** //
-// **************               output_test_stream             ************** //
-// ************************************************************************** //
-
-struct output_test_stream::Impl
-{
-    std::fstream    m_pattern;
-    bool            m_match_or_save;
-    bool            m_text_or_binary;
-    std::string     m_synced_string;
-
-    char            get_char()
-    {
-        char res;
-        do {
-            m_pattern.get( res );
-        } while( m_text_or_binary && res == '\r' && !m_pattern.fail() && !m_pattern.eof() );
-
-        return res;
-    }
-
-    void            check_and_fill( assertion_result& res )
-    {
-        if( !res.p_predicate_value )
-            res.message() << "Output content: \"" << m_synced_string << '\"';
-    }
-};
-
-//____________________________________________________________________________//
-
-output_test_stream::output_test_stream( const_string pattern_file_name, bool match_or_save, bool text_or_binary )
-: m_pimpl( new Impl )
-{
-    if( !pattern_file_name.is_empty() ) {
-        std::ios::openmode m = match_or_save ? std::ios::in : std::ios::out;
-        if( !text_or_binary )
-            m |= std::ios::binary;
-
-        m_pimpl->m_pattern.open( pattern_file_name.begin(), m );
-
-        if( !m_pimpl->m_pattern.is_open() )
-            BOOST_TEST_FRAMEWORK_MESSAGE( "Can't open pattern file " << pattern_file_name << " for " << (match_or_save ? "reading" : "writing") );
-    }
-
-    m_pimpl->m_match_or_save    = match_or_save;
-    m_pimpl->m_text_or_binary   = text_or_binary;
-}
-
-//____________________________________________________________________________//
-
-output_test_stream::~output_test_stream()
-{
-    delete m_pimpl;
-}
-
-//____________________________________________________________________________//
-
-assertion_result
-output_test_stream::is_empty( bool flush_stream )
-{
-    sync();
-
-    assertion_result res( m_pimpl->m_synced_string.empty() );
-
-    m_pimpl->check_and_fill( res );
-
-    if( flush_stream )
-        flush();
-
-    return res;
-}
-
-//____________________________________________________________________________//
-
-assertion_result
-output_test_stream::check_length( std::size_t length_, bool flush_stream )
-{
-    sync();
-
-    assertion_result res( m_pimpl->m_synced_string.length() == length_ );
-
-    m_pimpl->check_and_fill( res );
-
-    if( flush_stream )
-        flush();
-
-    return res;
-}
-
-//____________________________________________________________________________//
-
-assertion_result
-output_test_stream::is_equal( const_string arg, bool flush_stream )
-{
-    sync();
-
-    assertion_result res( const_string( m_pimpl->m_synced_string ) == arg );
-
-    m_pimpl->check_and_fill( res );
-
-    if( flush_stream )
-        flush();
-
-    return res;
-}
-
-//____________________________________________________________________________//
-
-std::string pretty_print_log(std::string str) {
-
-    static const std::string to_replace[] = { "\r", "\n" };
-    static const std::string replacement[] = { "\\r", "\\n" };
-
-    return unit_test::utils::replace_all_occurrences_of(
-        str,
-        to_replace, to_replace + sizeof(to_replace)/sizeof(to_replace[0]),
-        replacement, replacement + sizeof(replacement)/sizeof(replacement[0]));
-}
-
-assertion_result
-output_test_stream::match_pattern( bool flush_stream )
-{
-    const std::string::size_type n_chars_presuffix = 10;
-    sync();
-
-    assertion_result result( true );
-
-    const std::string stream_string_repr = get_stream_string_representation();
-
-    if( !m_pimpl->m_pattern.is_open() ) {
-        result = false;
-        result.message() << "Pattern file can't be opened!";
-    }
-    else {
-        if( m_pimpl->m_match_or_save ) {
-
-            int offset = 0;
-            std::vector<char> last_elements;
-            for ( std::string::size_type i = 0; static_cast<int>(i + offset) < static_cast<int>(stream_string_repr.length()); ++i ) {
-                char c = m_pimpl->get_char();
-
-                if( last_elements.size() <= n_chars_presuffix ) {
-                    last_elements.push_back( c );
-                }
-                else {
-                    last_elements[ i % last_elements.size() ] = c;
-                }
-
-                bool is_same = !m_pimpl->m_pattern.fail() &&
-                         !m_pimpl->m_pattern.eof()  &&
-                         (stream_string_repr[i+offset] == c);
-
-                if( !is_same ) {
-
-                    result = false;
-
-                    std::string::size_type prefix_size  = (std::min)( i + offset, n_chars_presuffix );
-
-                    std::string::size_type suffix_size  = (std::min)( stream_string_repr.length() - i - offset,
-                                                                      n_chars_presuffix );
-
-                    // try to log area around the mismatch
-                    std::string substr = stream_string_repr.substr(0, i+offset);
-                    std::size_t line = std::count(substr.begin(), substr.end(), '\n');
-                    std::size_t column = i + offset - substr.rfind('\n');
-
-                    result.message()
-                        << "Mismatch at position " << i
-                        << " (line " << line
-                        << ", column " << column
-                        << "): '" << pretty_print_log(std::string(1, stream_string_repr[i+offset])) << "' != '" << pretty_print_log(std::string(1, c)) << "' :\n";
-
-                    // we already escape this substring because we need its actual size for the pretty print
-                    // of the difference location.
-                    std::string sub_str_prefix(pretty_print_log(stream_string_repr.substr( i + offset - prefix_size, prefix_size )));
-
-                    // we need this substring as is because we compute the best matching substrings on it.
-                    std::string sub_str_suffix(stream_string_repr.substr( i + offset, suffix_size));
-                    result.message() << "... " << sub_str_prefix + pretty_print_log(sub_str_suffix) << " ..." << '\n';
-
-                    result.message() << "... ";
-                    for( std::size_t j = 0; j < last_elements.size() ; j++ )
-                        result.message() << pretty_print_log(std::string(1, last_elements[(i + j + 1) % last_elements.size()]));
-
-                    std::vector<char> last_elements_ordered;
-                    last_elements_ordered.push_back(c);
-                    for( std::string::size_type counter = 0; counter < suffix_size - 1 ; counter++ ) {
-                        char c2 = m_pimpl->get_char();
-
-                        if( m_pimpl->m_pattern.fail() || m_pimpl->m_pattern.eof() )
-                            break;
-
-                        result.message() << pretty_print_log(std::string(1, c2));
-
-                        last_elements_ordered.push_back(c2);
-                    }
-
-                    // tries to find the best substring matching in the remainder of the
-                    // two strings
-                    std::size_t max_nb_char_in_common = 0;
-                    std::size_t best_pattern_start_index = 0;
-                    std::size_t best_stream_start_index = 0;
-                    for( std::size_t pattern_start_index = best_pattern_start_index;
-                         pattern_start_index < last_elements_ordered.size();
-                         pattern_start_index++ ) {
-                        for( std::size_t stream_start_index = best_stream_start_index;
-                             stream_start_index < sub_str_suffix.size();
-                             stream_start_index++ ) {
-
-                            std::size_t max_size = (std::min)( last_elements_ordered.size() - pattern_start_index, sub_str_suffix.size() - stream_start_index );
-                            if( max_nb_char_in_common > max_size )
-                                break; // safely break to go to the outer loop
-
-                            std::size_t nb_char_in_common = 0;
-                            for( std::size_t k = 0; k < max_size; k++) {
-                                if( last_elements_ordered[pattern_start_index + k] == sub_str_suffix[stream_start_index + k] )
-                                    nb_char_in_common ++;
-                                else
-                                    break; // we take fully macthing substring only
-                            }
-
-                            if( nb_char_in_common > max_nb_char_in_common ) {
-                                max_nb_char_in_common = nb_char_in_common;
-                                best_pattern_start_index = pattern_start_index;
-                                best_stream_start_index = stream_start_index;
-                            }
-                        }
-                    }
-
-                    // indicates with more precision the location of the mismatchs in ascii arts ...
-                    result.message() << " ...\n... ";
-                    for( std::string::size_type j = 0; j < sub_str_prefix.size(); j++) {
-                        result.message() << ' ';
-                    }
-
-                    for( std::size_t k = 0; k < (std::max)(best_pattern_start_index, best_stream_start_index); k++ ) { // 1 is for the current char c
-                        std::string s1(pretty_print_log(std::string(1, last_elements_ordered[(std::min)(k, best_pattern_start_index)])));
-                        std::string s2(pretty_print_log(std::string(1, sub_str_suffix[(std::min)(k, best_stream_start_index)])));
-                        for( int h = (std::max)(s1.size(), s2.size()); h > 0; h--)
-                          result.message() << "~";
-                    }
-                    result.message() << "\n";
-
-                    // first char is a replicat of c, so we do not copy it.
-                    for(std::string::size_type counter = 0; counter < last_elements_ordered.size() - 1 ; counter++)
-                        last_elements[ (i + 1 + counter) % last_elements.size() ] = last_elements_ordered[counter + 1];
-
-                    i += last_elements_ordered.size()-1;
-                    offset += best_stream_start_index - best_pattern_start_index;
-
-                }
-
-            }
-
-            // not needed anymore
-            /*
-            if(offset > 0 && false) {
-                m_pimpl->m_pattern.ignore(
-                    static_cast<std::streamsize>( offset ));
-            }
-            */
-        }
-        else {
-            m_pimpl->m_pattern.write( stream_string_repr.c_str(),
-                                      static_cast<std::streamsize>( stream_string_repr.length() ) );
-            m_pimpl->m_pattern.flush();
-        }
-    }
-
-    if( flush_stream )
-        flush();
-
-    return result;
-}
-
-//____________________________________________________________________________//
-
-void
-output_test_stream::flush()
-{
-    m_pimpl->m_synced_string.erase();
-
-#ifndef BOOST_NO_STRINGSTREAM
-    str( std::string() );
-#else
-    seekp( 0, std::ios::beg );
-#endif
-}
-
-
-std::string
-output_test_stream::get_stream_string_representation() const {
-    return m_pimpl->m_synced_string;
-}
-
-//____________________________________________________________________________//
-
-std::size_t
-output_test_stream::length()
-{
-    sync();
-
-    return m_pimpl->m_synced_string.length();
-}
-
-//____________________________________________________________________________//
-
-void
-output_test_stream::sync()
-{
-#ifdef BOOST_NO_STRINGSTREAM
-    m_pimpl->m_synced_string.assign( str(), pcount() );
-    freeze( false );
-#else
-    m_pimpl->m_synced_string = str();
-#endif
-}
-
-//____________________________________________________________________________//
-
-} // namespace test_tools
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TEST_TOOLS_IPP_012205GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/impl/test_tree.ipp b/contrib/libboost/boost_1_62_0/boost/test/impl/test_tree.ipp
deleted file mode 100644
index d45f7b32b52..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/impl/test_tree.ipp
+++ /dev/null
@@ -1,460 +0,0 @@
-//  (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
-/// Provides core implementation for Unit Test Framework.
-/// Extensions can be provided in separate files
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_SUITE_IPP_012205GER
-#define BOOST_TEST_UNIT_TEST_SUITE_IPP_012205GER
-
-// Boost.Test
-#include <boost/detail/workaround.hpp>
-
-#include <boost/test/framework.hpp>
-#include <boost/test/results_collector.hpp>
-
-#include <boost/test/tree/test_unit.hpp>
-#include <boost/test/tree/visitor.hpp>
-#include <boost/test/tree/traverse.hpp>
-#include <boost/test/tree/auto_registration.hpp>
-#include <boost/test/tree/global_fixture.hpp>
-
-#include <boost/test/utils/foreach.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp>
-
-#include <boost/test/unit_test_parameters.hpp>
-
-// Boost
-#include <boost/timer.hpp>
-
-// STL
-#include <algorithm>
-#include <vector>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                   test_unit                  ************** //
-// ************************************************************************** //
-
-test_unit::test_unit( const_string name, const_string file_name, std::size_t line_num, test_unit_type t )
-: p_type( t )
-, p_type_name( t == TUT_CASE ? "case" : "suite" )
-, p_file_name( file_name )
-, p_line_num( line_num )
-, p_id( INV_TEST_UNIT_ID )
-, p_parent_id( INV_TEST_UNIT_ID )
-, p_name( std::string( name.begin(), name.size() ) )
-, p_timeout( 0 )
-, p_expected_failures( 0 )
-, p_default_status( RS_INHERIT )
-, p_run_status( RS_INVALID )
-, p_sibling_rank(0)
-{
-}
-
-//____________________________________________________________________________//
-
-test_unit::test_unit( const_string module_name )
-: p_type( TUT_SUITE )
-, p_type_name( "module" )
-, p_line_num( 0 )
-, p_id( INV_TEST_UNIT_ID )
-, p_parent_id( INV_TEST_UNIT_ID )
-, p_name( std::string( module_name.begin(), module_name.size() ) )
-, p_timeout( 0 )
-, p_expected_failures( 0 )
-, p_default_status( RS_INHERIT )
-, p_run_status( RS_INVALID )
-, p_sibling_rank(0)
-{
-}
-
-//____________________________________________________________________________//
-
-test_unit::~test_unit()
-{
-    framework::deregister_test_unit( this );
-}
-
-//____________________________________________________________________________//
-
-void
-test_unit::depends_on( test_unit* tu )
-{
-    BOOST_TEST_SETUP_ASSERT( p_id != framework::master_test_suite().p_id, 
-                             "Can't add dependency to the master test suite" );
-
-    p_dependencies.value.push_back( tu->p_id );
-}
-
-//____________________________________________________________________________//
-
-void
-test_unit::add_precondition( precondition_t const& pc )
-{
-    p_preconditions.value.push_back( pc );
-}
-
-//____________________________________________________________________________//
-
-test_tools::assertion_result
-test_unit::check_preconditions() const
-{
-    BOOST_TEST_FOREACH( test_unit_id, dep_id, p_dependencies.get() ) {
-        test_unit const& dep = framework::get( dep_id, TUT_ANY );
-
-        if( !dep.is_enabled() ) {
-            test_tools::assertion_result res(false);
-            res.message() << "dependency test " << dep.p_type_name << " \"" << dep.full_name() << "\" is disabled";
-            return res;
-        }
-
-        test_results const& test_rslt = unit_test::results_collector.results( dep_id );
-        if( !test_rslt.passed() ) {
-            test_tools::assertion_result res(false);
-            res.message() << "dependency test " << dep.p_type_name << " \"" << dep.full_name() << "\" has failed";
-            return res;
-        }
-
-        if( test_rslt.p_test_cases_skipped > 0 ) {
-            test_tools::assertion_result res(false);
-            res.message() << "dependency test " << dep.p_type_name << " \"" << dep.full_name() << "\" has skipped test cases";
-            return res;
-        }
-    }
-
-    BOOST_TEST_FOREACH( precondition_t, precondition, p_preconditions.get() ) {
-        test_tools::assertion_result res = precondition( p_id );
-        if( !res ) {
-            test_tools::assertion_result res_out(false);
-            res_out.message() << "precondition failed";
-            if( !res.has_empty_message() )
-                res_out.message() << ": " << res.message();
-            return res_out;
-        }
-    }
-
-    return true;
-}
-
-//____________________________________________________________________________//
-
-void
-test_unit::increase_exp_fail( counter_t num )
-{
-    p_expected_failures.value += num;
-
-    if( p_parent_id != INV_TEST_UNIT_ID )
-        framework::get<test_suite>( p_parent_id ).increase_exp_fail( num );
-}
-
-//____________________________________________________________________________//
-
-std::string
-test_unit::full_name() const
-{
-    if( p_parent_id == INV_TEST_UNIT_ID || p_parent_id == framework::master_test_suite().p_id )
-        return p_name;
-
-    std::string res = framework::get<test_suite>( p_parent_id ).full_name();
-    res.append("/");
-
-    res.append( p_name );
-
-    return res;
-}
-
-//____________________________________________________________________________//
-
-void
-test_unit::add_label( const_string l )
-{
-    p_labels.value.push_back( std::string() + l );
-}
-
-//____________________________________________________________________________//
-
-bool
-test_unit::has_label( const_string l ) const
-{
-    return std::find( p_labels->begin(), p_labels->end(), l ) != p_labels->end();
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                   test_case                  ************** //
-// ************************************************************************** //
-
-test_case::test_case( const_string name, boost::function<void ()> const& test_func )
-: test_unit( name, "", 0, static_cast<test_unit_type>(type) )
-, p_test_func( test_func )
-{
-    framework::register_test_unit( this );
-}
-
-//____________________________________________________________________________//
-
-test_case::test_case( const_string name, const_string file_name, std::size_t line_num, boost::function<void ()> const& test_func )
-: test_unit( name, file_name, line_num, static_cast<test_unit_type>(type) )
-, p_test_func( test_func )
-{
-    framework::register_test_unit( this );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                  test_suite                  ************** //
-// ************************************************************************** //
-
-//____________________________________________________________________________//
-
-test_suite::test_suite( const_string name, const_string file_name, std::size_t line_num )
-: test_unit( name, file_name, line_num, static_cast<test_unit_type>(type) )
-{
-    framework::register_test_unit( this );
-}
-
-//____________________________________________________________________________//
-
-test_suite::test_suite( const_string module_name )
-: test_unit( module_name )
-{
-    framework::register_test_unit( this );
-}
-
-//____________________________________________________________________________//
-
-void
-test_suite::add( test_unit* tu, counter_t expected_failures, unsigned timeout )
-{
-    tu->p_timeout.value = timeout;
-
-    m_children.push_back( tu->p_id );
-    tu->p_parent_id.value = p_id;
-
-    if( tu->p_expected_failures != 0 )
-        increase_exp_fail( tu->p_expected_failures );
-
-    if( expected_failures )
-        tu->increase_exp_fail( expected_failures );
-}
-
-//____________________________________________________________________________//
-
-void
-test_suite::add( test_unit_generator const& gen, unsigned timeout )
-{
-    test_unit* tu;
-    while((tu = gen.next()) != 0)
-        add( tu, 0, timeout );
-}
-
-//____________________________________________________________________________//
-
-void
-test_suite::add( test_unit_generator const& gen, decorator::collector& decorators )
-{
-    test_unit* tu;
-    while((tu = gen.next()) != 0) {
-        decorators.store_in( *tu );
-        add( tu, 0 );
-    }
-
-    decorators.reset();
-}
-
-//____________________________________________________________________________//
-
-void
-test_suite::remove( test_unit_id id )
-{
-    test_unit_id_list::iterator it = std::find( m_children.begin(), m_children.end(), id );
-
-    if( it != m_children.end() )
-        m_children.erase( it );
-}
-
-//____________________________________________________________________________//
-
-test_unit_id
-test_suite::get( const_string tu_name ) const
-{
-    BOOST_TEST_FOREACH( test_unit_id, id, m_children ) {
-        if( tu_name == framework::get( id, ut_detail::test_id_2_unit_type( id ) ).p_name.get() )
-            return id;
-    }
-
-    return INV_TEST_UNIT_ID;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               master_test_suite              ************** //
-// ************************************************************************** //
-
-master_test_suite_t::master_test_suite_t()
-: test_suite( "Master Test Suite" )
-, argc( 0 )
-, argv( 0 )
-{
-    p_default_status.value = RS_ENABLED;
-}
-
-// ************************************************************************** //
-// **************               traverse_test_tree             ************** //
-// ************************************************************************** //
-
-void
-traverse_test_tree( test_case const& tc, test_tree_visitor& V, bool ignore_status )
-{
-    if( tc.is_enabled() || ignore_status )
-        V.visit( tc );
-}
-
-//____________________________________________________________________________//
-
-void
-traverse_test_tree( test_suite const& suite, test_tree_visitor& V, bool ignore_status )
-{
-    // skip disabled test suite unless we asked to ignore this condition
-    if( !ignore_status && !suite.is_enabled() )
-        return;
-
-    // Invoke test_suite_start callback
-    if( !V.test_suite_start( suite ) )
-        return;
-
-    // Recurse into children
-    std::size_t total_children = suite.m_children.size();
-    for( std::size_t i=0; i < total_children; ) {
-        // this statement can remove the test unit from this list
-        traverse_test_tree( suite.m_children[i], V, ignore_status );
-        if( total_children > suite.m_children.size() )
-            total_children = suite.m_children.size();
-        else
-            ++i;
-    }
-
-    // Invoke test_suite_finish callback
-    V.test_suite_finish( suite );
-}
-
-//____________________________________________________________________________//
-
-void
-traverse_test_tree( test_unit_id id, test_tree_visitor& V, bool ignore_status )
-{
-    if( ut_detail::test_id_2_unit_type( id ) == TUT_CASE )
-        traverse_test_tree( framework::get<test_case>( id ), V, ignore_status );
-    else
-        traverse_test_tree( framework::get<test_suite>( id ), V, ignore_status );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               object generators              ************** //
-// ************************************************************************** //
-
-namespace ut_detail {
-
-std::string
-normalize_test_case_name( const_string name )
-{
-    std::string norm_name( name.begin(), name.size() );
-
-    if( name[0] == '&' )
-        norm_name = norm_name.substr( 1 );
-        
-    std::replace(norm_name.begin(), norm_name.end(), ' ', '_'); 
-
-    return norm_name;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************           auto_test_unit_registrar           ************** //
-// ************************************************************************** //
-
-auto_test_unit_registrar::auto_test_unit_registrar( test_case* tc, decorator::collector& decorators, counter_t exp_fail )
-{
-    framework::current_auto_test_suite().add( tc, exp_fail );
-
-    decorators.store_in( *tc );
-    decorators.reset();
-}
-
-//____________________________________________________________________________//
-
-auto_test_unit_registrar::auto_test_unit_registrar( const_string ts_name, const_string ts_file, std::size_t ts_line, decorator::collector& decorators )
-{
-    test_unit_id id = framework::current_auto_test_suite().get( ts_name );
-
-    test_suite* ts;
-
-    if( id != INV_TEST_UNIT_ID ) {
-        ts = &framework::get<test_suite>( id );
-        BOOST_ASSERT( ts->p_parent_id == framework::current_auto_test_suite().p_id );
-    }
-    else {
-        ts = new test_suite( ts_name, ts_file, ts_line );
-        framework::current_auto_test_suite().add( ts );
-    }
-
-    decorators.store_in( *ts );
-    decorators.reset();
-
-    framework::current_auto_test_suite( ts );
-}
-
-//____________________________________________________________________________//
-
-auto_test_unit_registrar::auto_test_unit_registrar( test_unit_generator const& tc_gen, decorator::collector& decorators )
-{
-    framework::current_auto_test_suite().add( tc_gen, decorators );
-}
-
-//____________________________________________________________________________//
-
-auto_test_unit_registrar::auto_test_unit_registrar( int )
-{
-    framework::current_auto_test_suite( 0, false );
-}
-
-//____________________________________________________________________________//
-
-} // namespace ut_detail
-
-// ************************************************************************** //
-// **************                global_fixture                ************** //
-// ************************************************************************** //
-
-global_fixture::global_fixture()
-{
-    framework::register_observer( *this );
-}
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UNIT_TEST_SUITE_IPP_012205GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/impl/unit_test_log.ipp b/contrib/libboost/boost_1_62_0/boost/test/impl/unit_test_log.ipp
deleted file mode 100644
index 5f3fa6510d5..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/impl/unit_test_log.ipp
+++ /dev/null
@@ -1,675 +0,0 @@
-//  (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 : implemets Unit Test Log
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_LOG_IPP_012205GER
-#define BOOST_TEST_UNIT_TEST_LOG_IPP_012205GER
-
-// Boost.Test
-#include <boost/test/unit_test_log.hpp>
-#include <boost/test/unit_test_log_formatter.hpp>
-#include <boost/test/execution_monitor.hpp>
-#include <boost/test/framework.hpp>
-#include <boost/test/unit_test_parameters.hpp>
-
-#include <boost/test/utils/basic_cstring/compare.hpp>
-#include <boost/test/utils/foreach.hpp>
-
-#include <boost/test/output/compiler_log_formatter.hpp>
-#include <boost/test/output/xml_log_formatter.hpp>
-#include <boost/test/output/junit_log_formatter.hpp>
-
-// Boost
-#include <boost/shared_ptr.hpp>
-#include <boost/io/ios_state.hpp>
-typedef ::boost::io::ios_base_all_saver io_saver_type;
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************             entry_value_collector            ************** //
-// ************************************************************************** //
-
-namespace ut_detail {
-
-entry_value_collector const&
-entry_value_collector::operator<<( lazy_ostream const& v ) const
-{
-    unit_test_log << v;
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-entry_value_collector const&
-entry_value_collector::operator<<( const_string v ) const
-{
-    unit_test_log << v;
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-entry_value_collector::~entry_value_collector()
-{
-    if( m_last )
-        unit_test_log << log::end();
-}
-
-//____________________________________________________________________________//
-
-} // namespace ut_detail
-
-// ************************************************************************** //
-// **************                 unit_test_log                ************** //
-// ************************************************************************** //
-
-namespace {
-
-// log data
-struct unit_test_log_data_helper_impl {
-  typedef boost::shared_ptr<unit_test_log_formatter> formatter_ptr;
-  typedef boost::shared_ptr<io_saver_type>           saver_ptr;
-
-  bool                m_enabled;
-  output_format       m_format;
-  std::ostream*       m_stream;
-  saver_ptr           m_stream_state_saver;
-  formatter_ptr       m_log_formatter;
-  bool                m_entry_in_progress;
-
-  unit_test_log_data_helper_impl(unit_test_log_formatter* p_log_formatter, output_format format, bool enabled = false)
-    : m_enabled( enabled )
-    , m_format( format )
-    , m_stream( &std::cout )
-    , m_stream_state_saver( new io_saver_type( std::cout ) )
-    , m_log_formatter()
-    , m_entry_in_progress( false )
-  {
-    m_log_formatter.reset(p_log_formatter);
-    m_log_formatter->set_log_level(log_all_errors);
-  }
-
-  // helper functions
-  std::ostream&       stream()
-  {
-      return *m_stream;
-  }
-
-  log_level get_log_level() const
-  {
-      return m_log_formatter->get_log_level();
-  }
-};
-
-struct unit_test_log_impl {
-    // Constructor
-    unit_test_log_impl()
-    {
-      m_log_formatter_data.push_back( unit_test_log_data_helper_impl(new output::compiler_log_formatter, OF_CLF, true) ); // only this one is active by default,
-      m_log_formatter_data.push_back( unit_test_log_data_helper_impl(new output::xml_log_formatter, OF_XML, false) );
-      m_log_formatter_data.push_back( unit_test_log_data_helper_impl(new output::junit_log_formatter, OF_JUNIT, false) );
-    }
-
-    typedef std::vector<unit_test_log_data_helper_impl> v_formatter_data_t;
-    v_formatter_data_t m_log_formatter_data;
-
-    // entry data
-    log_entry_data      m_entry_data;
-
-    bool has_entry_in_progress() const {
-        BOOST_TEST_FOREACH( unit_test_log_data_helper_impl const&, current_logger_data, m_log_formatter_data ) {
-            if( current_logger_data.m_entry_in_progress )
-                return true;
-        }
-        return false;
-    }
-
-    // check point data
-    log_checkpoint_data m_checkpoint_data;
-
-    void                set_checkpoint( const_string file, std::size_t line_num, const_string msg )
-    {
-        assign_op( m_checkpoint_data.m_message, msg, 0 );
-        m_checkpoint_data.m_file_name   = file;
-        m_checkpoint_data.m_line_num    = line_num;
-    }
-};
-
-unit_test_log_impl& s_log_impl() { static unit_test_log_impl the_inst; return the_inst; }
-
-} // local namespace
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::test_start( counter_t test_cases_amount )
-{
-    BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-      if( !current_logger_data.m_enabled || current_logger_data.get_log_level() == log_nothing )
-          continue;
-
-      current_logger_data.m_log_formatter->log_start( current_logger_data.stream(), test_cases_amount );
-
-      if( runtime_config::get<bool>( runtime_config::BUILD_INFO ) )
-          current_logger_data.m_log_formatter->log_build_info( current_logger_data.stream() );
-
-      current_logger_data.m_entry_in_progress = false;
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::test_finish()
-{
-    BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-      if( !current_logger_data.m_enabled || current_logger_data.get_log_level() == log_nothing )
-          continue;
-
-      current_logger_data.m_log_formatter->log_finish( current_logger_data.stream() );
-
-      current_logger_data.stream().flush();
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::test_aborted()
-{
-    BOOST_TEST_LOG_ENTRY( log_messages ) << "Test is aborted";
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::test_unit_start( test_unit const& tu )
-{
-    if( s_log_impl().has_entry_in_progress() )
-        *this << log::end();
-    BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-        if( !current_logger_data.m_enabled || current_logger_data.get_log_level() > log_test_units )
-            continue;
-        current_logger_data.m_log_formatter->test_unit_start( current_logger_data.stream(), tu );
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::test_unit_finish( test_unit const& tu, unsigned long elapsed )
-{
-    s_log_impl().m_checkpoint_data.clear();
-
-    if( s_log_impl().has_entry_in_progress() )
-        *this << log::end();
-
-    BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-
-        if( !current_logger_data.m_enabled || current_logger_data.get_log_level() > log_test_units )
-            continue;
-
-        current_logger_data.m_log_formatter->test_unit_finish( current_logger_data.stream(), tu, elapsed );
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::test_unit_skipped( test_unit const& tu, const_string reason )
-{
-    if( s_log_impl().has_entry_in_progress() )
-        *this << log::end();
-
-    BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-        if( !current_logger_data.m_enabled || current_logger_data.get_log_level() > log_test_units )
-            continue;
-
-        current_logger_data.m_log_formatter->test_unit_skipped( current_logger_data.stream(), tu, reason );
-    }
-}
-
-void
-unit_test_log_t::test_unit_aborted( test_unit const& tu )
-{
-    if( s_log_impl().has_entry_in_progress() )
-        *this << log::end();
-
-    BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-        if( !current_logger_data.m_enabled || current_logger_data.get_log_level() > log_test_units )
-            continue;
-
-        current_logger_data.m_log_formatter->test_unit_aborted(current_logger_data.stream(), tu );
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::exception_caught( execution_exception const& ex )
-{
-    log_level l =
-        ex.code() <= execution_exception::cpp_exception_error   ? log_cpp_exception_errors :
-        (ex.code() <= execution_exception::timeout_error        ? log_system_errors
-                                                                : log_fatal_errors );
-
-    if( s_log_impl().has_entry_in_progress() )
-        *this << log::end();
-
-    BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-
-      if( current_logger_data.m_enabled && l >= current_logger_data.get_log_level() ) {
-
-          current_logger_data.m_log_formatter->log_exception_start( current_logger_data.stream(), s_log_impl().m_checkpoint_data, ex );
-
-          log_entry_context( l );
-
-          current_logger_data.m_log_formatter->log_exception_finish( current_logger_data.stream() );
-      }
-    }
-    clear_entry_context();
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::set_checkpoint( const_string file, std::size_t line_num, const_string msg )
-{
-    s_log_impl().set_checkpoint( file, line_num, msg );
-}
-
-//____________________________________________________________________________//
-
-char
-set_unix_slash( char in )
-{
-    return in == '\\' ? '/' : in;
-}
-
-unit_test_log_t&
-unit_test_log_t::operator<<( log::begin const& b )
-{
-    if( s_log_impl().has_entry_in_progress() )
-        *this << log::end();
-
-    BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-        if( current_logger_data.m_enabled ) {
-            current_logger_data.m_stream_state_saver->restore();
-        }
-    }
-
-    s_log_impl().m_entry_data.clear();
-
-    assign_op( s_log_impl().m_entry_data.m_file_name, b.m_file_name, 0 );
-
-    // normalize file name
-    std::transform( s_log_impl().m_entry_data.m_file_name.begin(), s_log_impl().m_entry_data.m_file_name.end(),
-                    s_log_impl().m_entry_data.m_file_name.begin(),
-                    &set_unix_slash );
-
-    s_log_impl().m_entry_data.m_line_num = b.m_line_num;
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-unit_test_log_t&
-unit_test_log_t::operator<<( log::end const& )
-{
-    if( s_log_impl().has_entry_in_progress() ) {
-        log_entry_context( s_log_impl().m_entry_data.m_level );
-
-        BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-            if( current_logger_data.m_enabled && current_logger_data.m_entry_in_progress ) {
-                current_logger_data.m_log_formatter->log_entry_finish( current_logger_data.stream() );
-            }
-            current_logger_data.m_entry_in_progress = false;
-        }
-    }
-
-    clear_entry_context();
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-unit_test_log_t&
-unit_test_log_t::operator<<( log_level l )
-{
-    s_log_impl().m_entry_data.m_level = l;
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-ut_detail::entry_value_collector
-unit_test_log_t::operator()( log_level l )
-{
-    *this << l;
-
-    return ut_detail::entry_value_collector();
-}
-
-//____________________________________________________________________________//
-
-bool
-unit_test_log_t::log_entry_start(output_format log_format)
-{
-    BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-
-        if( current_logger_data.m_format != log_format )
-            continue;
-
-        if( current_logger_data.m_entry_in_progress )
-            return true;
-
-        if( !current_logger_data.m_enabled )
-            return false;
-
-        switch( s_log_impl().m_entry_data.m_level ) {
-        case log_successful_tests:
-            current_logger_data.m_log_formatter->log_entry_start( current_logger_data.stream(), s_log_impl().m_entry_data,
-                                                  unit_test_log_formatter::BOOST_UTL_ET_INFO );
-            break;
-        case log_messages:
-            current_logger_data.m_log_formatter->log_entry_start( current_logger_data.stream(), s_log_impl().m_entry_data,
-                                                  unit_test_log_formatter::BOOST_UTL_ET_MESSAGE );
-            break;
-        case log_warnings:
-            current_logger_data.m_log_formatter->log_entry_start( current_logger_data.stream(), s_log_impl().m_entry_data,
-                                                  unit_test_log_formatter::BOOST_UTL_ET_WARNING );
-            break;
-        case log_all_errors:
-        case log_cpp_exception_errors:
-        case log_system_errors:
-            current_logger_data.m_log_formatter->log_entry_start( current_logger_data.stream(), s_log_impl().m_entry_data,
-                                                  unit_test_log_formatter::BOOST_UTL_ET_ERROR );
-            break;
-        case log_fatal_errors:
-            current_logger_data.m_log_formatter->log_entry_start( current_logger_data.stream(), s_log_impl().m_entry_data,
-                                                  unit_test_log_formatter::BOOST_UTL_ET_FATAL_ERROR );
-            break;
-        case log_nothing:
-        case log_test_units:
-        case invalid_log_level:
-            return false;
-        }
-
-        current_logger_data.m_entry_in_progress = true;
-        return true;
-    }
-
-    return false;
-}
-
-//____________________________________________________________________________//
-
-unit_test_log_t&
-unit_test_log_t::operator<<( const_string value )
-{
-    BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-        if( current_logger_data.m_enabled && s_log_impl().m_entry_data.m_level >= current_logger_data.get_log_level() && !value.empty() && log_entry_start(current_logger_data.m_format) )
-            current_logger_data.m_log_formatter->log_entry_value( current_logger_data.stream(), value );
-
-    }
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-unit_test_log_t&
-unit_test_log_t::operator<<( lazy_ostream const& value )
-{
-    BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-        if( current_logger_data.m_enabled && s_log_impl().m_entry_data.m_level >= current_logger_data.get_log_level() && !value.empty() && log_entry_start(current_logger_data.m_format) )
-            current_logger_data.m_log_formatter->log_entry_value( current_logger_data.stream(), value );
-    }
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::log_entry_context( log_level l )
-{
-    framework::context_generator const& context = framework::get_context();
-    if( context.is_empty() )
-        return;
-
-    const_string frame;
-
-    BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-        if( current_logger_data.m_enabled ) {
-            current_logger_data.m_log_formatter->entry_context_start( current_logger_data.stream(), l );
-        }
-    }
-
-    while( !(frame=context.next()).is_empty() )
-    {
-        BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-            if( current_logger_data.m_enabled ) {
-                current_logger_data.m_log_formatter->log_entry_context( current_logger_data.stream(), frame );
-            }
-        }
-    }
-
-    BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-        if( current_logger_data.m_enabled ) {
-            current_logger_data.m_log_formatter->entry_context_finish( current_logger_data.stream() );
-        }
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::clear_entry_context()
-{
-    framework::clear_context();
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::set_stream( std::ostream& str )
-{
-    if( s_log_impl().has_entry_in_progress() )
-        return;
-
-    BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-        current_logger_data.m_stream = &str;
-        current_logger_data.m_stream_state_saver.reset( new io_saver_type( str ) );
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::set_stream( output_format log_format, std::ostream& str )
-{
-    if( s_log_impl().has_entry_in_progress() )
-        return;
-
-    BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-        if( current_logger_data.m_format == log_format) {
-            current_logger_data.m_stream = &str;
-            current_logger_data.m_stream_state_saver.reset( new io_saver_type( str ) );
-            break;
-        }
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::set_threshold_level( log_level lev )
-{
-    if( s_log_impl().has_entry_in_progress() || lev == invalid_log_level )
-        return;
-
-    BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-        current_logger_data.m_log_formatter->set_log_level( lev );
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::set_threshold_level( output_format log_format, log_level lev )
-{
-    if( s_log_impl().has_entry_in_progress() || lev == invalid_log_level )
-        return;
-
-    BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-        if( current_logger_data.m_format == log_format) {
-            current_logger_data.m_log_formatter->set_log_level( lev );
-            break;
-        }
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::set_format( output_format log_format )
-{
-    if( s_log_impl().has_entry_in_progress() )
-        return;
-
-    BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-        current_logger_data.m_enabled = current_logger_data.m_format == log_format;
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-unit_test_log_t::add_format( output_format log_format )
-{
-    if( s_log_impl().has_entry_in_progress() )
-        return;
-
-    BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-        if( current_logger_data.m_format == log_format) {
-            current_logger_data.m_enabled = true;
-            break;
-        }
-    }
-}
-
-//____________________________________________________________________________//
-
-unit_test_log_formatter*
-unit_test_log_t::get_formatter( output_format log_format ) {
-    BOOST_TEST_FOREACH( unit_test_log_data_helper_impl&, current_logger_data, s_log_impl().m_log_formatter_data ) {
-        if( current_logger_data.m_format == log_format) {
-            return current_logger_data.m_log_formatter.get();
-        }
-    }
-    return 0;
-}
-
-
-void
-unit_test_log_t::add_formatter( unit_test_log_formatter* the_formatter )
-{
-    // remove only user defined logger
-    for(unit_test_log_impl::v_formatter_data_t::iterator it(s_log_impl().m_log_formatter_data.begin()),
-            ite(s_log_impl().m_log_formatter_data.end());
-        it != ite;
-        ++it)
-    {
-        if( it->m_format == OF_CUSTOM_LOGGER) {
-            s_log_impl().m_log_formatter_data.erase(it);
-            break;
-        }
-    }
-
-    if( the_formatter ) {
-        s_log_impl().m_log_formatter_data.push_back( unit_test_log_data_helper_impl(the_formatter, OF_CUSTOM_LOGGER, true) );
-    }
-}
-
-void
-unit_test_log_t::set_formatter( unit_test_log_formatter* the_formatter )
-{
-    // remove only user defined logger
-    log_level current_level = invalid_log_level;
-    std::ostream *current_stream = 0;
-    output_format previous_format = OF_INVALID;
-    for(unit_test_log_impl::v_formatter_data_t::iterator it(s_log_impl().m_log_formatter_data.begin()),
-            ite(s_log_impl().m_log_formatter_data.end());
-        it != ite;
-        ++it)
-    {
-        if( it->m_enabled ) {
-            if( current_level == invalid_log_level || it->m_format < previous_format || it->m_format == OF_CUSTOM_LOGGER) {
-                current_level = it->get_log_level();
-                current_stream = &(it->stream());
-                previous_format = it->m_format;
-            }
-        }
-    }
-
-    if( the_formatter ) {
-        add_formatter(the_formatter);
-        set_format(OF_CUSTOM_LOGGER);
-        set_threshold_level(OF_CUSTOM_LOGGER, current_level);
-        set_stream(OF_CUSTOM_LOGGER, *current_stream);
-    }
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************            unit_test_log_formatter           ************** //
-// ************************************************************************** //
-
-void
-unit_test_log_formatter::log_entry_value( std::ostream& ostr, lazy_ostream const& value )
-{
-    log_entry_value( ostr, (wrap_stringstream().ref() << value).str() );
-}
-
-void
-unit_test_log_formatter::set_log_level(log_level new_log_level)
-{
-    m_log_level = new_log_level;
-}
-
-log_level
-unit_test_log_formatter::get_log_level() const
-{
-    return m_log_level;
-}
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UNIT_TEST_LOG_IPP_012205GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/impl/unit_test_main.ipp b/contrib/libboost/boost_1_62_0/boost/test/impl/unit_test_main.ipp
deleted file mode 100644
index db61930652a..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/impl/unit_test_main.ipp
+++ /dev/null
@@ -1,295 +0,0 @@
-//  (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 : main function implementation for Unit Test Framework
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_MAIN_IPP_012205GER
-#define BOOST_TEST_UNIT_TEST_MAIN_IPP_012205GER
-
-// Boost.Test
-#include <boost/test/framework.hpp>
-#include <boost/test/results_collector.hpp>
-#include <boost/test/results_reporter.hpp>
-
-#include <boost/test/tree/visitor.hpp>
-#include <boost/test/tree/test_unit.hpp>
-#include <boost/test/tree/traverse.hpp>
-
-#include <boost/test/unit_test_parameters.hpp>
-
-#include <boost/test/utils/foreach.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp>
-
-// Boost
-#include <boost/cstdlib.hpp>
-
-// STL
-#include <cstdio>
-#include <stdexcept>
-#include <iostream>
-#include <iomanip>
-#include <set>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-namespace ut_detail {
-
-// ************************************************************************** //
-// **************             hrf_content_reporter             ************** //
-// ************************************************************************** //
-
-struct hrf_content_reporter : test_tree_visitor {
-    explicit        hrf_content_reporter( std::ostream& os ) : m_os( os ), m_indent( -4 ) {} // skip master test suite
-
-private:
-    void            report_test_unit( test_unit const& tu )
-    {
-        m_os << std::setw( m_indent ) << "" << tu.p_name;
-        m_os << (tu.p_default_status == test_unit::RS_ENABLED ? "*" : " ");
-        //m_os << '[' << tu.p_sibling_rank << ']';
-        if( !tu.p_description->empty() )
-            m_os << ": " << tu.p_description;
-
-        m_os << "\n";
-    }
-    virtual void    visit( test_case const& tc ) { report_test_unit( tc ); }
-    virtual bool    test_suite_start( test_suite const& ts )
-    {
-        if( m_indent >= 0 )
-            report_test_unit( ts );
-        m_indent += 4;
-        return true;
-    }
-    virtual void    test_suite_finish( test_suite const& )
-    {
-        m_indent -= 4;
-    }
-
-    // Data members
-    std::ostream&   m_os;
-    int             m_indent;
-};
-
-// ************************************************************************** //
-// **************             dot_content_reporter             ************** //
-// ************************************************************************** //
-
-struct dot_content_reporter : test_tree_visitor {
-    explicit        dot_content_reporter( std::ostream& os ) : m_os( os ) {}
-
-private:
-    void            report_test_unit( test_unit const& tu )
-    {
-        bool master_ts = tu.p_parent_id == INV_TEST_UNIT_ID;
-
-        m_os << "tu" << tu.p_id;
-
-        m_os << (master_ts ? "[shape=ellipse,peripheries=2" : "[shape=Mrecord" );
-
-        m_os << ",fontname=Helvetica";
-
-        m_os << (tu.p_default_status == test_unit::RS_ENABLED ? ",color=green" : ",color=yellow");
-
-        if( master_ts )
-            m_os << ",label=\"" << tu.p_name << "\"];\n";
-        else {
-            m_os << ",label=\"" << tu.p_name << "|" << tu.p_file_name << "(" << tu.p_line_num << ")";
-            if( tu.p_timeout > 0  )
-                m_os << "|timeout=" << tu.p_timeout;
-            if( tu.p_expected_failures != 0  )
-                m_os << "|expected failures=" << tu.p_expected_failures;
-            if( !tu.p_labels->empty() ) {
-                m_os << "|labels:";
-
-                BOOST_TEST_FOREACH( std::string const&, l, tu.p_labels.get() )
-                    m_os << " @" << l;
-            }
-            m_os << "\"];\n";
-        }
-
-        if( !master_ts )
-            m_os << "tu" << tu.p_parent_id << " -> " << "tu" << tu.p_id << ";\n";
-
-        BOOST_TEST_FOREACH( test_unit_id, dep_id, tu.p_dependencies.get() ) {
-            test_unit const& dep = framework::get( dep_id, TUT_ANY );
-
-            m_os << "tu" << tu.p_id << " -> " << "tu" << dep.p_id << "[color=red,style=dotted,constraint=false];\n";
-        }
-
-    }
-    virtual void    visit( test_case const& tc )
-    { 
-        report_test_unit( tc );
-    }
-    virtual bool    test_suite_start( test_suite const& ts )
-    {
-        if( ts.p_parent_id == INV_TEST_UNIT_ID )
-            m_os << "digraph G {rankdir=LR;\n";
-
-        report_test_unit( ts );
-
-        m_os << "{\n";
-
-        return true;
-    }
-    virtual void    test_suite_finish( test_suite const& ts )
-    {
-        m_os << "}\n";
-        if( ts.p_parent_id == INV_TEST_UNIT_ID )
-            m_os << "}\n";
-    }
-
-    std::ostream&   m_os;
-};
-
-// ************************************************************************** //
-// **************               labels_collector               ************** //
-// ************************************************************************** //
-
-struct labels_collector : test_tree_visitor {
-    std::set<std::string> const& labels() const { return m_labels; }
-
-private:
-    virtual bool            visit( test_unit const& tu ) 
-    {
-        m_labels.insert( tu.p_labels->begin(), tu.p_labels->end() );
-        return true;
-    }
-
-    // Data members
-    std::set<std::string>   m_labels;
-};
-
-} // namespace ut_detail
-
-// ************************************************************************** //
-// **************                  unit_test_main              ************** //
-// ************************************************************************** //
-
-int BOOST_TEST_DECL
-unit_test_main( init_unit_test_func init_func, int argc, char* argv[] )
-{
-    int result_code = 0;
-
-    BOOST_TEST_I_TRY {
-        framework::init( init_func, argc, argv );
-
-        if( runtime_config::get<bool>( runtime_config::WAIT_FOR_DEBUGGER ) ) {
-            results_reporter::get_stream() << "Press any key to continue..." << std::endl;
-
-            // getchar is defined as a macro in uClibc. Use parenthesis to fix
-            // gcc bug 58952 for gcc <= 4.8.2.
-            (std::getchar)();
-            results_reporter::get_stream() << "Continuing..." << std::endl;
-        }
-
-        framework::finalize_setup_phase();
-
-        output_format list_cont = runtime_config::get<output_format>( runtime_config::LIST_CONTENT );
-        if( list_cont != unit_test::OF_INVALID ) {
-            if( list_cont == unit_test::OF_DOT ) {
-                ut_detail::dot_content_reporter reporter( results_reporter::get_stream() );
-
-                traverse_test_tree( framework::master_test_suite().p_id, reporter, true );
-            }
-            else {
-                ut_detail::hrf_content_reporter reporter( results_reporter::get_stream() );
-
-                traverse_test_tree( framework::master_test_suite().p_id, reporter, true );
-            }
-
-            return boost::exit_success;
-        }
-
-        if( runtime_config::get<bool>( runtime_config::LIST_LABELS ) ) {
-            ut_detail::labels_collector collector;
-
-            traverse_test_tree( framework::master_test_suite().p_id, collector, true );
-
-            results_reporter::get_stream() << "Available labels:\n  ";
-            std::copy( collector.labels().begin(), collector.labels().end(), 
-                       std::ostream_iterator<std::string>( results_reporter::get_stream(), "\n  " ) );
-            results_reporter::get_stream() << "\n";
-
-            return boost::exit_success;
-        }
-
-        framework::run();
-
-        results_reporter::make_report();
-
-        result_code = !runtime_config::get<bool>( runtime_config::RESULT_CODE )
-                        ? boost::exit_success
-                        : results_collector.results( framework::master_test_suite().p_id ).result_code();
-    }
-    BOOST_TEST_I_CATCH( framework::nothing_to_test, ex ) {
-        result_code = ex.m_result_code;
-    }
-    BOOST_TEST_I_CATCH( framework::internal_error, ex ) {
-        results_reporter::get_stream() << "Boost.Test framework internal error: " << ex.what() << std::endl;
-
-        result_code = boost::exit_exception_failure;
-    }
-    BOOST_TEST_I_CATCH( framework::setup_error, ex ) {
-        results_reporter::get_stream() << "Test setup error: " << ex.what() << std::endl;
-
-        result_code = boost::exit_exception_failure;
-    }
-    BOOST_TEST_I_CATCHALL() {
-        results_reporter::get_stream() << "Boost.Test framework internal error: unknown reason" << std::endl;
-
-        result_code = boost::exit_exception_failure;
-    }
-
-    framework::shutdown();
-
-    return result_code;
-}
-
-} // namespace unit_test
-} // namespace boost
-
-#if !defined(BOOST_TEST_DYN_LINK) && !defined(BOOST_TEST_NO_MAIN)
-
-// ************************************************************************** //
-// **************        main function for tests using lib     ************** //
-// ************************************************************************** //
-
-int BOOST_TEST_CALL_DECL
-main( int argc, char* argv[] )
-{
-    // prototype for user's unit test init function
-#ifdef BOOST_TEST_ALTERNATIVE_INIT_API
-    extern bool init_unit_test();
-
-    boost::unit_test::init_unit_test_func init_func = &init_unit_test;
-#else
-    extern ::boost::unit_test::test_suite* init_unit_test_suite( int argc, char* argv[] );
-
-    boost::unit_test::init_unit_test_func init_func = &init_unit_test_suite;
-#endif
-
-    return ::boost::unit_test::unit_test_main( init_func, argc, argv );
-}
-
-#endif // !BOOST_TEST_DYN_LINK && !BOOST_TEST_NO_MAIN
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UNIT_TEST_MAIN_IPP_012205GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/impl/unit_test_monitor.ipp b/contrib/libboost/boost_1_62_0/boost/test/impl/unit_test_monitor.ipp
deleted file mode 100644
index 304c8f1c045..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/impl/unit_test_monitor.ipp
+++ /dev/null
@@ -1,75 +0,0 @@
-//  (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 : implements specific subclass of Executon Monitor used by Unit
-//  Test Framework to monitor test cases run.
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_MONITOR_IPP_012205GER
-#define BOOST_TEST_UNIT_TEST_MONITOR_IPP_012205GER
-
-// Boost.Test
-#include <boost/test/unit_test_monitor.hpp>
-#include <boost/test/framework.hpp>
-#include <boost/test/tree/test_unit.hpp>
-#include <boost/test/unit_test_parameters.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************               unit_test_monitor              ************** //
-// ************************************************************************** //
-
-unit_test_monitor_t::error_level
-unit_test_monitor_t::execute_and_translate( boost::function<void ()> const& func, unsigned timeout )
-{
-    BOOST_TEST_I_TRY {
-        p_catch_system_errors.value     = runtime_config::get<bool>( runtime_config::CATCH_SYS_ERRORS );
-        p_timeout.value                 = timeout;
-        p_auto_start_dbg.value          = runtime_config::get<bool>( runtime_config::AUTO_START_DBG );
-        p_use_alt_stack.value           = runtime_config::get<bool>( runtime_config::USE_ALT_STACK );
-        p_detect_fp_exceptions.value    = runtime_config::get<bool>( runtime_config::DETECT_FP_EXCEPT );
-
-        vexecute( func );
-    }
-    BOOST_TEST_I_CATCH( execution_exception, ex ) {
-        framework::exception_caught( ex );
-        framework::test_unit_aborted( framework::current_test_case() );
-
-        // translate execution_exception::error_code to error_level
-        switch( ex.code() ) {
-        case execution_exception::no_error:             return test_ok;
-        case execution_exception::user_error:           return unexpected_exception;
-        case execution_exception::cpp_exception_error:  return unexpected_exception;
-        case execution_exception::system_error:         return os_exception;
-        case execution_exception::timeout_error:        return os_timeout;
-        case execution_exception::user_fatal_error:
-        case execution_exception::system_fatal_error:   return fatal_error;
-        default:                                        return unexpected_exception;
-        }
-    }
-
-    return test_ok;
-}
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UNIT_TEST_MONITOR_IPP_012205GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/impl/unit_test_parameters.ipp b/contrib/libboost/boost_1_62_0/boost/test/impl/unit_test_parameters.ipp
deleted file mode 100644
index f49079ea3ed..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/impl/unit_test_parameters.ipp
+++ /dev/null
@@ -1,749 +0,0 @@
-//  (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 : simple implementation for Unit Test Framework parameter
-//  handling routines. May be rewritten in future to use some kind of
-//  command-line arguments parsing facility and environment variable handling
-//  facility
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_PARAMETERS_IPP_012205GER
-#define BOOST_TEST_UNIT_TEST_PARAMETERS_IPP_012205GER
-
-// Boost.Test
-#include <boost/test/unit_test_parameters.hpp>
-
-#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
-#include <boost/test/utils/basic_cstring/compare.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp>
-#include <boost/test/utils/iterator/token_iterator.hpp>
-
-#include <boost/test/debug.hpp>
-#include <boost/test/framework.hpp>
-
-#include <boost/test/detail/log_level.hpp>
-#include <boost/test/detail/throw_exception.hpp>
-
-// Boost.Runtime.Param
-#include <boost/test/utils/runtime/parameter.hpp>
-#include <boost/test/utils/runtime/argument.hpp>
-#include <boost/test/utils/runtime/finalize.hpp>
-#include <boost/test/utils/runtime/cla/parser.hpp>
-#include <boost/test/utils/runtime/env/fetch.hpp>
-
-// Boost
-#include <boost/config.hpp>
-#include <boost/test/detail/suppress_warnings.hpp>
-#include <boost/test/detail/enable_warnings.hpp>
-#include <boost/optional.hpp>
-#include <boost/cstdlib.hpp>
-
-// STL
-#include <cstdlib>
-#include <iostream>
-#include <fstream>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-# ifdef BOOST_NO_STDC_NAMESPACE
-namespace std { using ::getenv; using ::strncmp; using ::strcmp; }
-# endif
-
-namespace boost {
-namespace unit_test {
-
-namespace rt = boost::runtime;
-
-// ************************************************************************** //
-// **************                 runtime_config               ************** //
-// ************************************************************************** //
-
-namespace runtime_config {
-
-// UTF parameters
-std::string AUTO_START_DBG    = "auto_start_dbg";
-std::string BREAK_EXEC_PATH   = "break_exec_path";
-std::string BUILD_INFO        = "build_info";
-std::string CATCH_SYS_ERRORS  = "catch_system_errors";
-std::string COLOR_OUTPUT      = "color_output";
-std::string DETECT_FP_EXCEPT  = "detect_fp_exceptions";
-std::string DETECT_MEM_LEAKS  = "detect_memory_leaks";
-std::string LIST_CONTENT      = "list_content";
-std::string LIST_LABELS       = "list_labels";
-std::string LOG_FORMAT        = "log_format";
-std::string LOG_LEVEL         = "log_level";
-std::string LOG_SINK          = "log_sink";
-std::string COMBINED_LOGGER   = "logger";
-std::string OUTPUT_FORMAT     = "output_format";
-std::string RANDOM_SEED       = "random";
-std::string REPORT_FORMAT     = "report_format";
-std::string REPORT_LEVEL      = "report_level";
-std::string REPORT_MEM_LEAKS  = "report_memory_leaks_to";
-std::string REPORT_SINK       = "report_sink";
-std::string RESULT_CODE       = "result_code";
-std::string RUN_FILTERS       = "run_test";
-std::string SAVE_TEST_PATTERN = "save_pattern";
-std::string SHOW_PROGRESS     = "show_progress";
-std::string USE_ALT_STACK     = "use_alt_stack";
-std::string WAIT_FOR_DEBUGGER = "wait_for_debugger";
-
-std::string HELP              = "help";
-std::string USAGE             = "usage";
-
-//____________________________________________________________________________//
-
-namespace {
-
-void
-register_parameters( rt::parameters_store& store )
-{
-    rt::option auto_start_dbg( AUTO_START_DBG, (
-        rt::description = "Automatically attaches debugger in case of system level failure (signal).",
-        rt::env_var = "BOOST_TEST_AUTO_START_DBG",
-
-        rt::help = "Option " + AUTO_START_DBG + " specifies whether Boost.Test should attempt "
-                   "to attach a debugger when fatal system error occurs. At the moment this feature "
-                   "is only available on a few selected platforms: Win32 and *nix. There is a "
-                   "default debugger configured for these platforms. You can manually configure "
-                   "different debugger. For more details on how to configure the debugger see the "
-                   "Boost.Test debug API, specifically the function boost::debug::set_debugger."
-    ));
-
-    auto_start_dbg.add_cla_id( "--", AUTO_START_DBG, "=" );
-    auto_start_dbg.add_cla_id( "-", "d", " " );
-    store.add( auto_start_dbg );
-
-    ///////////////////////////////////////////////
-
-    rt::parameter<std::string> break_exec_path( BREAK_EXEC_PATH, (
-        rt::description = "For the exception safety testing allows to break at specific execution path.",
-        rt::env_var = "BOOST_TEST_BREAK_EXEC_PATH"
-#ifndef BOOST_NO_CXX11_LAMBDAS
-        ,
-        rt::callback = [](rt::cstring) {
-            BOOST_TEST_SETUP_ASSERT( false, "parameter break_exec_path is disabled in this release" );
-        }
-#endif
-    ));
-
-    break_exec_path.add_cla_id( "--", BREAK_EXEC_PATH, "=" );
-    store.add( break_exec_path );
-
-    ///////////////////////////////////////////////
-
-    rt::option build_info( BUILD_INFO, (
-        rt::description = "Displays library build information.",
-        rt::env_var = "BOOST_TEST_BUILD_INFO",
-        rt::help = "Option " + BUILD_INFO + " displays library build information, including: platform, "
-                   "compiler, STL version and Boost version."
-    ));
-
-    ///////////////////////////////////////////////
-
-    build_info.add_cla_id( "--", BUILD_INFO, "=" );
-    build_info.add_cla_id( "-", "i", " " );
-    store.add( build_info );
-
-
-    rt::option catch_sys_errors( CATCH_SYS_ERRORS, (
-        rt::description = "Allows to switch between catching and ignoring system errors (signals).",
-        rt::env_var = "BOOST_TEST_CATCH_SYSTEM_ERRORS",
-        rt::default_value =
-#ifdef BOOST_TEST_DEFAULTS_TO_CORE_DUMP
-            false,
-#else
-            true,
-#endif
-        rt::help = "If option " + CATCH_SYS_ERRORS + " has value no the frameworks does not attempt to catch "
-                   "asynchronous system failure events (signals on *NIX platforms or structured exceptions on Windows). "
-                   " Default value is "
-#ifdef BOOST_TEST_DEFAULTS_TO_CORE_DUMP
-                    "no."
-#else
-                    "true."
-#endif
-    ));
-
-    catch_sys_errors.add_cla_id( "--", CATCH_SYS_ERRORS, "=", true );
-    catch_sys_errors.add_cla_id( "-", "s", " " );
-    store.add( catch_sys_errors );
-
-    ///////////////////////////////////////////////
-
-    rt::option color_output( COLOR_OUTPUT, (
-        rt::description = "Enables color output of the framework log and report messages.",
-        rt::env_var = "BOOST_TEST_COLOR_OUTPUT",
-        rt::help = "The framework is able to produce color output on systems which supports it. "
-                   "To enable this behavior set this option to yes. By default the framework "
-                   "does not produces color output."
-    ));
-
-    color_output.add_cla_id( "--", COLOR_OUTPUT, "=", true );
-    color_output.add_cla_id( "-", "x", " " );
-    store.add( color_output );
-
-    ///////////////////////////////////////////////
-
-    rt::option detect_fp_except( DETECT_FP_EXCEPT, (
-        rt::description = "Enables/disables floating point exceptions traps.",
-        rt::env_var = "BOOST_TEST_DETECT_FP_EXCEPTIONS",
-        rt::help = "Option " + DETECT_FP_EXCEPT + " enables/disables hardware traps for the floating "
-                   "point exceptions (if supported on your platfrom)."
-    ));
-
-    detect_fp_except.add_cla_id( "--", DETECT_FP_EXCEPT, "=", true );
-    store.add( detect_fp_except );
-
-    ///////////////////////////////////////////////
-
-    rt::parameter<unsigned long> detect_mem_leaks( DETECT_MEM_LEAKS, (
-        rt::description = "Turns on/off memory leaks detection (optionally breaking on specified alloc order number).",
-        rt::env_var = "BOOST_TEST_DETECT_MEMORY_LEAK",
-        rt::default_value = 1L,
-        rt::optional_value = 1L,
-        rt::value_hint = "<alloc order number>",
-        rt::help = "Parameter " + DETECT_MEM_LEAKS + " enables/disables memory leaks detection. "
-                   "This parameter has optional long integer value. The default value is 1, which "
-                   "enables the memory leak detection. The value 0 disables memory leak detection. "
-                   "Any value N greater than 1 is treated as leak allocation number and tells the "
-                   "framework to setup runtime breakpoint at Nth heap allocation. If value is "
-                   "omitted the default value is assumed."
-    ));
-
-    detect_mem_leaks.add_cla_id( "--", DETECT_MEM_LEAKS, "=" );
-    store.add( detect_mem_leaks );
-
-    ///////////////////////////////////////////////
-
-    rt::enum_parameter<unit_test::output_format> list_content( LIST_CONTENT, (
-        rt::description = "Lists the content of test tree - names of all test suites and test cases.",
-        rt::env_var = "BOOST_TEST_LIST_CONTENT",
-        rt::default_value = OF_INVALID,
-        rt::optional_value = OF_CLF,
-        rt::enum_values<unit_test::output_format>::value =
-#if defined(BOOST_TEST_CLA_NEW_API)
-        {
-            { "HRF", OF_CLF },
-            { "DOT", OF_DOT }
-        },
-#else
-        rt::enum_values_list<unit_test::output_format>()
-            ( "HRF", OF_CLF )
-            ( "DOT", OF_DOT )
-        ,
-#endif
-        rt::help = "Parameter " + LIST_CONTENT + " instructs the framework to list the content "
-                   "of the test module instead of executing the test cases. Parameter accepts "
-                   "optional string value indicating the format of the output. Currently the "
-                   "framework supports two formats: human readable format (HRF) and dot graph "
-                   "format (DOT). If value is omitted HRF value is assumed."
-    ));
-    list_content.add_cla_id( "--", LIST_CONTENT, "=" );
-    store.add( list_content );
-
-    ///////////////////////////////////////////////
-
-    rt::option list_labels( LIST_LABELS, (
-        rt::description = "Lists all available labels.",
-        rt::env_var = "BOOST_TEST_LIST_LABELS",
-        rt::help = "Option " + LIST_LABELS + " instructs the framework to list all the the labels "
-                   "defined in the test module instead of executing the test cases."
-    ));
-
-    list_labels.add_cla_id( "--", LIST_LABELS, "=" );
-    store.add( list_labels );
-
-    ///////////////////////////////////////////////
-
-    rt::enum_parameter<unit_test::output_format> log_format( LOG_FORMAT, (
-        rt::description = "Specifies log format.",
-        rt::env_var = "BOOST_TEST_LOG_FORMAT",
-        rt::default_value = OF_CLF,
-        rt::enum_values<unit_test::output_format>::value =
-#if defined(BOOST_TEST_CLA_NEW_API)
-        {
-            { "HRF", OF_CLF },
-            { "CLF", OF_CLF },
-            { "XML", OF_XML },
-            { "JUNIT", OF_JUNIT },
-        },
-#else
-        rt::enum_values_list<unit_test::output_format>()
-            ( "HRF", OF_CLF )
-            ( "CLF", OF_CLF )
-            ( "XML", OF_XML )
-            ( "JUNIT", OF_JUNIT )
-        ,
-#endif
-        rt::help = "Parameter " + LOG_FORMAT + " allows to set the frameowrk's log format to one "
-                   "of the formats supplied by the framework. The only acceptable values for this "
-                   "parameter are the names of the output formats supplied by the framework. By "
-                   "default the framework uses human readable format (HRF) for testing log. This "
-                   "format is similar to compiler error format. Alternatively you can specify XML "
-                   "or JUNIT as log format, which are easier to process by testing automation tools."
-    ));
-
-    log_format.add_cla_id( "--", LOG_FORMAT, "=" );
-    log_format.add_cla_id( "-", "f", " " );
-    store.add( log_format );
-
-    ///////////////////////////////////////////////
-
-    rt::enum_parameter<unit_test::log_level> log_level( LOG_LEVEL, (
-        rt::description = "Specifies log level.",
-        rt::env_var = "BOOST_TEST_LOG_LEVEL",
-        rt::default_value = log_all_errors,
-        rt::enum_values<unit_test::log_level>::value =
-#if defined(BOOST_TEST_CLA_NEW_API)
-        {
-            { "all"           , log_successful_tests },
-            { "success"       , log_successful_tests },
-            { "test_suite"    , log_test_units },
-            { "unit_scope"    , log_test_units },
-            { "message"       , log_messages },
-            { "warning"       , log_warnings },
-            { "error"         , log_all_errors },
-            { "cpp_exception" , log_cpp_exception_errors },
-            { "system_error"  , log_system_errors },
-            { "fatal_error"   , log_fatal_errors },
-            { "nothing"       , log_nothing }
-        },
-#else
-        rt::enum_values_list<unit_test::log_level>()
-            ( "all"           , log_successful_tests )
-            ( "success"       , log_successful_tests )
-            ( "test_suite"    , log_test_units )
-            ( "unit_scope"    , log_test_units )
-            ( "message"       , log_messages )
-            ( "warning"       , log_warnings )
-            ( "error"         , log_all_errors )
-            ( "cpp_exception" , log_cpp_exception_errors )
-            ( "system_error"  , log_system_errors )
-            ( "fatal_error"   , log_fatal_errors )
-            ( "nothing"       , log_nothing )
-        ,
-#endif
-        rt::help = "Parameter " + LOG_LEVEL + " allows to set the framework's log level. "
-                   "Log level defines the verbosity of testing log produced by a testing "
-                   "module. The verbosity ranges from a complete log, when all assertions "
-                   "(both successful and failing) are reported, all notifications about "
-                   "test units start and finish are included, to an empty log when nothing "
-                   "is reported to a testing log stream."
-    ));
-
-    log_level.add_cla_id( "--", LOG_LEVEL, "=" );
-    log_level.add_cla_id( "-", "l", " " );
-    store.add( log_level );
-
-    ///////////////////////////////////////////////
-
-    rt::parameter<std::string> log_sink( LOG_SINK, (
-        rt::description = "Specifies log sink: stdout(default), stderr or file name.",
-        rt::env_var = "BOOST_TEST_LOG_SINK",
-        rt::value_hint = "<stderr|stdout|file name>",
-        rt::help = "Parameter " + LOG_SINK + " allows to set the log sink - location "
-                   "where we report the log to, thus it allows to easily redirect the "
-                   "test logs to file or standard streams. By default testing log is "
-                   "directed to standard output."
-    ));
-
-    log_sink.add_cla_id( "--", LOG_SINK, "=" );
-    log_sink.add_cla_id( "-", "k", " " );
-    store.add( log_sink );
-
-    ///////////////////////////////////////////////
-
-    rt::enum_parameter<unit_test::output_format> output_format( OUTPUT_FORMAT, (
-        rt::description = "Specifies output format (both log and report).",
-        rt::env_var = "BOOST_TEST_OUTPUT_FORMAT",
-        rt::enum_values<unit_test::output_format>::value =
-#if defined(BOOST_TEST_CLA_NEW_API)
-        {
-            { "HRF", OF_CLF },
-            { "CLF", OF_CLF },
-            { "XML", OF_XML }
-        },
-#else
-        rt::enum_values_list<unit_test::output_format>()
-            ( "HRF", OF_CLF )
-            ( "CLF", OF_CLF )
-            ( "XML", OF_XML )
-        ,
-#endif
-        rt::help = "Parameter " + OUTPUT_FORMAT + " combines an effect of " + REPORT_FORMAT +
-                   " and " + LOG_FORMAT + " parameters. This parameter has higher priority "
-                   "than either one of them. In other words if this parameter is specified "
-                   "it overrides the value of other two parameters. This parameter does not "
-                   "have a default value. The only acceptable values are string names of "
-                   "output formats: HRF - human readable format and XML - XML formats for "
-                   "automation tools processing."
-    ));
-
-    output_format.add_cla_id( "--", OUTPUT_FORMAT, "=" );
-    output_format.add_cla_id( "-", "o", " " );
-    store.add( output_format );
-
-    /////////////////////////////////////////////// combined logger option
-
-    rt::parameter<std::string,rt::REPEATABLE_PARAM> combined_logger( COMBINED_LOGGER, (
-        rt::description = "Specifies log level and sink for one or several log format",
-        rt::env_var = "BOOST_TEST_LOGGER",
-        rt::value_hint = "log_format:log_level:log_sink",
-        rt::help = "Parameter " + COMBINED_LOGGER + " allows to specify the logger type, level and sink\n"
-                   "in one command."
-    ));
-
-    combined_logger.add_cla_id( "--", COMBINED_LOGGER, "=" );
-    store.add( combined_logger );
-
-    ///////////////////////////////////////////////
-
-    rt::parameter<unsigned> random_seed( RANDOM_SEED, (
-        rt::description = "Allows to switch between sequential and random order of test units execution."
-                          " Optionally allows to specify concrete seed for random number generator.",
-        rt::env_var = "BOOST_TEST_RANDOM",
-        rt::default_value = 0U,
-        rt::optional_value = 1U,
-        rt::value_hint = "<seed>",
-        rt::help = "Parameter " + RANDOM_SEED + " instructs the framework to execute the "
-                   "test cases in random order. This parameter accepts optional unsigned "
-                   "integer argument. By default test cases are executed in some specific "
-                   "order defined by order of test units in test files and dependency between "
-                   "test units. If parameter is specified without the argument value testing "
-                   "order is randomized based on current time. Alternatively you can specify "
-                   "any positive value greater than 1 and it will be used as random seed for "
-                   "the run."
-    ));
-
-    random_seed.add_cla_id( "--", RANDOM_SEED, "=" );
-    store.add( random_seed );
-
-    ///////////////////////////////////////////////
-
-    rt::enum_parameter<unit_test::output_format> report_format( REPORT_FORMAT, (
-        rt::description = "Specifies report format.",
-        rt::env_var = "BOOST_TEST_REPORT_FORMAT",
-        rt::default_value = OF_CLF,
-        rt::enum_values<unit_test::output_format>::value =
-#if defined(BOOST_TEST_CLA_NEW_API)
-        {
-            { "HRF", OF_CLF },
-            { "CLF", OF_CLF },
-            { "XML", OF_XML }
-        },
-#else
-        rt::enum_values_list<unit_test::output_format>()
-            ( "HRF", OF_CLF )
-            ( "CLF", OF_CLF )
-            ( "XML", OF_XML )
-        ,
-#endif
-        rt::help = "Parameter " + REPORT_FORMAT + " allows to set the framework's report format "
-                   "to one of the formats supplied by the framework. The only acceptable values "
-                   "for this parameter are the names of the output formats. By default the framework "
-                   "uses human readable format (HRF) for results reporting. Alternatively you can "
-                   "specify XML as report format. This format is easier to process by testing "
-                   "automation tools."
-    ));
-
-    report_format.add_cla_id( "--", REPORT_FORMAT, "=" );
-    report_format.add_cla_id( "-", "m", " " );
-    store.add( report_format );
-
-    ///////////////////////////////////////////////
-
-    rt::enum_parameter<unit_test::report_level> report_level( REPORT_LEVEL, (
-        rt::description = "Specifies report level.",
-        rt::env_var = "BOOST_TEST_REPORT_LEVEL",
-        rt::default_value = CONFIRMATION_REPORT,
-        rt::enum_values<unit_test::report_level>::value =
-#if defined(BOOST_TEST_CLA_NEW_API)
-        {
-            { "confirm",  CONFIRMATION_REPORT },
-            { "short",    SHORT_REPORT },
-            { "detailed", DETAILED_REPORT },
-            { "no",       NO_REPORT }
-        },
-#else
-        rt::enum_values_list<unit_test::report_level>()
-            ( "confirm",  CONFIRMATION_REPORT )
-            ( "short",    SHORT_REPORT )
-            ( "detailed", DETAILED_REPORT )
-            ( "no",       NO_REPORT )
-        ,
-#endif
-        rt::help = "Parameter " + REPORT_LEVEL + " allows to set the verbosity level of the "
-                   "testing result report generated by the framework. Use value 'no' to "
-                   "eliminate the results report completely."
-    ));
-
-    report_level.add_cla_id( "--", REPORT_LEVEL, "=" );
-    report_level.add_cla_id( "-", "r", " " );
-    store.add( report_level );
-
-    ///////////////////////////////////////////////
-
-    rt::parameter<std::string> report_mem_leaks( REPORT_MEM_LEAKS, (
-        rt::description = "File where to report memory leaks to.",
-        rt::env_var = "BOOST_TEST_REPORT_MEMORY_LEAKS_TO",
-        rt::default_value = std::string(),
-        rt::value_hint = "<file name>",
-        rt::help = "Parameter " + REPORT_MEM_LEAKS + " allows to specify a file where to report "
-                   "memory leaks to. The parameter does not have default value. If it is not specified, "
-                   "memory leaks (if any) are reported to the standard error stream."
-    ));
-
-    report_mem_leaks.add_cla_id( "--", REPORT_MEM_LEAKS, "=" );
-    store.add( report_mem_leaks );
-
-    ///////////////////////////////////////////////
-
-    rt::parameter<std::string> report_sink( REPORT_SINK, (
-        rt::description = "Specifies report sink: stderr(default), stdout or file name.",
-        rt::env_var = "BOOST_TEST_REPORT_SINK",
-        rt::value_hint = "<stderr|stdout|file name>",
-        rt::help = "Parameter " + REPORT_SINK + " allows to set the result report sink - "
-                   "the location where the framework writes the result report to, thus it "
-                   "allows to easily redirect the result report to a file or a standard "
-                   "stream. By default the testing result report is directed to the "
-                   "standard error stream."
-    ));
-
-    report_sink.add_cla_id( "--", REPORT_SINK, "=" );
-    report_sink.add_cla_id( "-", "e", " " );
-    store.add( report_sink );
-
-    ///////////////////////////////////////////////
-
-    rt::option result_code( RESULT_CODE, (
-        rt::description = "Disables test modules's result code generation.",
-        rt::env_var = "BOOST_TEST_RESULT_CODE",
-        rt::default_value = true,
-        rt::help = "The 'no' argument value for the parameter " + RESULT_CODE + " instructs the "
-                   "framework to always return zero result code. This can be used for test programs "
-                   "executed within IDE. By default this parameter has value 'yes'."
-    ));
-
-    result_code.add_cla_id( "--", RESULT_CODE, "=", true );
-    result_code.add_cla_id( "-", "c", " " );
-    store.add( result_code );
-
-    ///////////////////////////////////////////////
-
-    rt::parameter<std::string,rt::REPEATABLE_PARAM> tests_to_run( RUN_FILTERS, (
-        rt::description = "Filters, which test units to include or exclude from test module execution.",
-        rt::env_var = "BOOST_TEST_RUN_FILTERS",
-        rt::value_hint = "<test unit filter>",
-        rt::help = "Parameter " + RUN_FILTERS + " allows to filter which test units to execute during "
-                   "testing. The framework supports both 'selection filters', which allow to select "
-                   "which test units to enable from the set of available test units, and 'disabler "
-                   "filters', which allow to disable some test units. The __UTF__ also supports "
-                   "enabling/disabling test units at compile time. These settings identify the default "
-                   "set of test units to run. Parameter " + RUN_FILTERS + " is used to change this default. "
-                   "This parameter is repeatable, so you can specify more than one filter if necessary."
-    ));
-
-    tests_to_run.add_cla_id( "--", RUN_FILTERS, "=" );
-    tests_to_run.add_cla_id( "-", "t", " " );
-    store.add( tests_to_run );
-
-    ///////////////////////////////////////////////
-
-    rt::option save_test_pattern( SAVE_TEST_PATTERN, (
-        rt::description = "Allows to switch between saving or matching test pattern file.",
-        rt::env_var = "BOOST_TEST_SAVE_PATTERN",
-        rt::help = "Parameter " + SAVE_TEST_PATTERN + " facilitates switching mode of operation for "
-                   "testing output streams.\n\nThis parameter serves no particular purpose within the "
-                   "framework itself. It can be used by test modules relying on output_test_stream to "
-                   "implement testing logic. Default mode is 'match' (false)."
-    ));
-
-    save_test_pattern.add_cla_id( "--", SAVE_TEST_PATTERN, "=" );
-    store.add( save_test_pattern );
-
-    ///////////////////////////////////////////////
-
-    rt::option show_progress( SHOW_PROGRESS, (
-        rt::description = "Turns on progress display.",
-        rt::env_var = "BOOST_TEST_SHOW_PROGRESS",
-        rt::help = "Parameter " + SHOW_PROGRESS + " instructs the framework to display test progress "
-                   "information. By default the test progress is not shown."
-    ));
-
-    show_progress.add_cla_id( "--", SHOW_PROGRESS, "=" );
-    show_progress.add_cla_id( "-", "p", " " );
-    store.add( show_progress );
-
-    ///////////////////////////////////////////////
-
-    rt::option use_alt_stack( USE_ALT_STACK, (
-        rt::description = "Turns on/off usage of an alternative stack for signal handling.",
-        rt::env_var = "BOOST_TEST_USE_ALT_STACK",
-        rt::default_value = true,
-        rt::help = "Parameter " + USE_ALT_STACK + " instructs the framework to use alternative "
-                   "stack for signals processing, on platforms where they are supported. The feature "
-                   "is enabled by default, but can be disabled using this parameter."
-    ));
-
-    use_alt_stack.add_cla_id( "--", USE_ALT_STACK, "=", true );
-    store.add( use_alt_stack );
-
-    ///////////////////////////////////////////////
-
-    rt::option wait_for_debugger( WAIT_FOR_DEBUGGER, (
-        rt::description = "Forces test module to wait for button to be pressed before starting test run.",
-        rt::env_var = "BOOST_TEST_WAIT_FOR_DEBUGGER",
-        rt::help = "Parameter " + WAIT_FOR_DEBUGGER + " instructs the framework to pause before starting "
-                   "test units execution, so that you can attach a debugger to running test module. By "
-                   "default this parameters turned off."
-    ));
-
-    wait_for_debugger.add_cla_id( "--", WAIT_FOR_DEBUGGER, "=" );
-    wait_for_debugger.add_cla_id( "-", "w", " " );
-    store.add( wait_for_debugger );
-
-    ///////////////////////////////////////////////
-
-    rt::parameter<std::string> help( HELP, (
-        rt::description = "Help for framework parameters.",
-        rt::optional_value = std::string(),
-        rt::value_hint = "<parameter name>",
-        rt::help = "Parameter " + HELP + " displays help on the framework's parameters. "
-                   "The parameter accepts an optional argument value. If present, an argument value is "
-                   "interpreted as a parameter name (name guessing works as well, so for example "
-                   "--help=rand displays help on the parameter random). If the parameter name is unknown "
-                   "or ambiguous error is reported. If argument value is absent, a summary of all "
-                   "framework's parameter is displayed."
-    ));
-    help.add_cla_id( "--", HELP, "=" );
-    store.add( help );
-
-    ///////////////////////////////////////////////
-
-    rt::option usage( USAGE, (
-        rt::description = "Short message explaining usage of Boost.Test parameters."
-    ));
-    usage.add_cla_id( "-", "?", " " );
-    store.add( usage );
-}
-
-static rt::arguments_store  s_arguments_store;
-static rt::parameters_store s_parameters_store;
-
-//____________________________________________________________________________//
-
-} // local namespace
-
-void
-init( int& argc, char** argv )
-{
-    shared_ptr<rt::cla::parser> parser;
-
-    BOOST_TEST_I_TRY {
-        // Initialize parameters list
-        if( s_parameters_store.is_empty() )
-            register_parameters( s_parameters_store );
-
-        // Clear up arguments store just in case (of multiple init invocations)
-        s_arguments_store.clear();
-
-        // Parse CLA they take precedence over  environment
-        parser.reset( new rt::cla::parser( s_parameters_store, (rt::end_of_params = "--", rt::negation_prefix = "no_") ) );
-        argc = parser->parse( argc, argv, s_arguments_store );
-
-        // Try to fetch missing arguments from environment
-        rt::env::fetch_absent( s_parameters_store, s_arguments_store );
-
-        // Set arguments to default values if defined and perform all the validations
-        rt::finalize_arguments( s_parameters_store, s_arguments_store );
-
-        // Report help if requested
-        if( runtime_config::get<bool>( USAGE ) ) {
-            parser->usage( std::cerr );
-            BOOST_TEST_I_THROW( framework::nothing_to_test( boost::exit_success ) );
-        }
-        else if( s_arguments_store.has( HELP ) ) {
-            parser->help( std::cerr, s_parameters_store, runtime_config::get<std::string>( HELP ) );
-            BOOST_TEST_I_THROW( framework::nothing_to_test( boost::exit_success ) );
-        }
-
-        // A bit of business logic: output_format takes precedence over log/report formats
-        if( s_arguments_store.has( OUTPUT_FORMAT ) ) {
-            unit_test::output_format of = s_arguments_store.get<unit_test::output_format>( OUTPUT_FORMAT );
-            s_arguments_store.set( REPORT_FORMAT, of );
-            s_arguments_store.set( LOG_FORMAT, of );
-        }
-
-    }
-    BOOST_TEST_I_CATCH( rt::init_error, ex ) {
-        BOOST_TEST_SETUP_ASSERT( false, ex.msg );
-    }
-    BOOST_TEST_I_CATCH( rt::ambiguous_param, ex ) {
-        std::cerr << ex.msg << "\n Did you mean one of these?\n";
-
-        BOOST_TEST_FOREACH( rt::cstring, name, ex.m_amb_candidates )
-            std::cerr << "   " << name << "\n";
-
-        BOOST_TEST_I_THROW( framework::nothing_to_test( boost::exit_exception_failure ) );
-    }
-    BOOST_TEST_I_CATCH( rt::unrecognized_param, ex ) {
-        std::cerr << ex.msg << "\n";
-
-        if( !ex.m_typo_candidates.empty() ) {
-            std::cerr << " Did you mean one of these?\n";
-
-            BOOST_TEST_FOREACH( rt::cstring, name, ex.m_typo_candidates )
-                std::cerr << "   " << name << "\n";
-        }
-        else if( parser ) {
-            std::cerr << "\n";
-            parser->usage( std::cerr );
-        }
-
-        BOOST_TEST_I_THROW( framework::nothing_to_test( boost::exit_exception_failure ) );
-    }
-    BOOST_TEST_I_CATCH( rt::input_error, ex ) {
-        std::cerr << ex.msg << "\n\n";
-
-        if( parser )
-            parser->usage( std::cerr, ex.param_name );
-
-        BOOST_TEST_I_THROW( framework::nothing_to_test( boost::exit_exception_failure ) );
-    }
-}
-
-//____________________________________________________________________________//
-
-rt::arguments_store const&
-argument_store()
-{
-    return s_arguments_store;
-}
-
-//____________________________________________________________________________//
-
-bool
-save_pattern()
-{
-    return runtime_config::get<bool>( SAVE_TEST_PATTERN );
-}
-
-//____________________________________________________________________________//
-
-} // namespace runtime_config
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UNIT_TEST_PARAMETERS_IPP_012205GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/impl/xml_log_formatter.ipp b/contrib/libboost/boost_1_62_0/boost/test/impl/xml_log_formatter.ipp
deleted file mode 100644
index 81284020ddc..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/impl/xml_log_formatter.ipp
+++ /dev/null
@@ -1,223 +0,0 @@
-//  (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 : implements OF_XML Log formatter
-// ***************************************************************************
-
-#ifndef BOOST_TEST_XML_LOG_FORMATTER_IPP_020105GER
-#define BOOST_TEST_XML_LOG_FORMATTER_IPP_020105GER
-
-// Boost.Test
-#include <boost/test/output/xml_log_formatter.hpp>
-#include <boost/test/execution_monitor.hpp>
-#include <boost/test/framework.hpp>
-#include <boost/test/tree/test_unit.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp>
-#include <boost/test/utils/xml_printer.hpp>
-
-// Boost
-#include <boost/version.hpp>
-
-// STL
-#include <iostream>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace output {
-
-static const_string tu_type_name( test_unit const& tu )
-{
-    return tu.p_type == TUT_CASE ? "TestCase" : "TestSuite";
-}
-
-// ************************************************************************** //
-// **************               xml_log_formatter              ************** //
-// ************************************************************************** //
-
-void
-xml_log_formatter::log_start( std::ostream& ostr, counter_t )
-{
-    ostr  << "<TestLog>";
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::log_finish( std::ostream& ostr )
-{
-    ostr  << "</TestLog>";
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::log_build_info( std::ostream& ostr )
-{
-    ostr  << "<BuildInfo"
-            << " platform"  << utils::attr_value() << BOOST_PLATFORM
-            << " compiler"  << utils::attr_value() << BOOST_COMPILER
-            << " stl"       << utils::attr_value() << BOOST_STDLIB
-            << " boost=\""  << BOOST_VERSION/100000     << "."
-                            << BOOST_VERSION/100 % 1000 << "."
-                            << BOOST_VERSION % 100      << '\"'
-            << "/>";
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::test_unit_start( std::ostream& ostr, test_unit const& tu )
-{
-    ostr << "<" << tu_type_name( tu ) << " name" << utils::attr_value() << tu.p_name.get();
-
-    if( !tu.p_file_name.empty() )
-        ostr << BOOST_TEST_L( " file" ) << utils::attr_value() << tu.p_file_name
-             << BOOST_TEST_L( " line" ) << utils::attr_value() << tu.p_line_num;
-
-    ostr << ">";
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::test_unit_finish( std::ostream& ostr, test_unit const& tu, unsigned long elapsed )
-{
-    if( tu.p_type == TUT_CASE )
-        ostr << "<TestingTime>" << elapsed << "</TestingTime>";
-
-    ostr << "</" << tu_type_name( tu ) << ">";
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::test_unit_skipped( std::ostream& ostr, test_unit const& tu, const_string reason )
-{
-    ostr << "<" << tu_type_name( tu )
-         << " name"    << utils::attr_value() << tu.p_name
-         << " skipped" << utils::attr_value() << "yes"
-         << " reason"  << utils::attr_value() << reason
-         << "/>";
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::log_exception_start( std::ostream& ostr, log_checkpoint_data const& checkpoint_data, execution_exception const& ex )
-{
-    execution_exception::location const& loc = ex.where();
-
-    ostr << "<Exception file" << utils::attr_value() << loc.m_file_name
-         << " line"           << utils::attr_value() << loc.m_line_num;
-
-    if( !loc.m_function.is_empty() )
-        ostr << " function"   << utils::attr_value() << loc.m_function;
-
-    ostr << ">" << utils::cdata() << ex.what();
-
-    if( !checkpoint_data.m_file_name.is_empty() ) {
-        ostr << "<LastCheckpoint file" << utils::attr_value() << checkpoint_data.m_file_name
-             << " line"                << utils::attr_value() << checkpoint_data.m_line_num
-             << ">"
-             << utils::cdata() << checkpoint_data.m_message
-             << "</LastCheckpoint>";
-    }
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::log_exception_finish( std::ostream& ostr )
-{
-    ostr << "</Exception>";
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::log_entry_start( std::ostream& ostr, log_entry_data const& entry_data, log_entry_types let )
-{
-    static literal_string xml_tags[] = { "Info", "Message", "Warning", "Error", "FatalError" };
-
-    m_curr_tag = xml_tags[let];
-    ostr << '<' << m_curr_tag
-         << BOOST_TEST_L( " file" ) << utils::attr_value() << entry_data.m_file_name
-         << BOOST_TEST_L( " line" ) << utils::attr_value() << entry_data.m_line_num
-         << BOOST_TEST_L( "><![CDATA[" );
-
-    m_value_closed = false;
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::log_entry_value( std::ostream& ostr, const_string value )
-{
-    utils::print_escaped_cdata( ostr, value );
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::log_entry_finish( std::ostream& ostr )
-{
-    if( !m_value_closed ) {
-        ostr << BOOST_TEST_L( "]]>" );
-        m_value_closed = true;
-    }
-
-    ostr << BOOST_TEST_L( "</" ) << m_curr_tag << BOOST_TEST_L( ">" );
-
-    m_curr_tag.clear();
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::entry_context_start( std::ostream& ostr, log_level )
-{
-    if( !m_value_closed ) {
-        ostr << BOOST_TEST_L( "]]>" );
-        m_value_closed = true;
-    }
-
-    ostr << BOOST_TEST_L( "<Context>" );
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::entry_context_finish( std::ostream& ostr )
-{
-    ostr << BOOST_TEST_L( "</Context>" );
-}
-
-//____________________________________________________________________________//
-
-void
-xml_log_formatter::log_entry_context( std::ostream& ostr, const_string context_descr )
-{
-    ostr << BOOST_TEST_L( "<Frame>" ) << utils::cdata() << context_descr << BOOST_TEST_L( "</Frame>" );
-}
-
-//____________________________________________________________________________//
-
-} // namespace output
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_XML_LOG_FORMATTER_IPP_020105GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/impl/xml_report_formatter.ipp b/contrib/libboost/boost_1_62_0/boost/test/impl/xml_report_formatter.ipp
deleted file mode 100644
index 424ef4ba446..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/impl/xml_report_formatter.ipp
+++ /dev/null
@@ -1,111 +0,0 @@
-//  (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
-// ***************************************************************************
-
-#ifndef BOOST_TEST_XML_REPORT_FORMATTER_IPP_020105GER
-#define BOOST_TEST_XML_REPORT_FORMATTER_IPP_020105GER
-
-// Boost.Test
-#include <boost/test/results_collector.hpp>
-#include <boost/test/output/xml_report_formatter.hpp>
-
-#include <boost/test/tree/test_unit.hpp>
-#include <boost/test/utils/xml_printer.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace output {
-
-void
-xml_report_formatter::results_report_start( std::ostream& ostr )
-{
-    ostr << "<TestResult>";
-}
-
-//____________________________________________________________________________//
-
-void
-xml_report_formatter::results_report_finish( std::ostream& ostr )
-{
-    ostr << "</TestResult>";
-}
-
-
-//____________________________________________________________________________//
-
-void
-xml_report_formatter::test_unit_report_start( test_unit const& tu, std::ostream& ostr )
-{
-    test_results const& tr = results_collector.results( tu.p_id );
-
-    const_string descr;
-
-    if( tr.passed() )
-        descr = "passed";
-    else if( tr.p_skipped )
-        descr = "skipped";
-    else if( tr.p_aborted )
-        descr = "aborted";
-    else
-        descr = "failed";
-
-    ostr << '<' << ( tu.p_type == TUT_CASE ? "TestCase" : "TestSuite" )
-         << " name"                     << utils::attr_value() << tu.p_name.get()
-         << " result"                   << utils::attr_value() << descr
-         << " assertions_passed"        << utils::attr_value() << tr.p_assertions_passed
-         << " assertions_failed"        << utils::attr_value() << tr.p_assertions_failed
-         << " warnings_failed"          << utils::attr_value() << tr.p_warnings_failed
-         << " expected_failures"        << utils::attr_value() << tr.p_expected_failures;
-
-    if( tu.p_type == TUT_SUITE ) {
-        ostr << " test_cases_passed"    << utils::attr_value() << tr.p_test_cases_passed
-             << " test_cases_passed_with_warnings" << utils::attr_value() << tr.p_test_cases_warned
-             << " test_cases_failed"    << utils::attr_value() << tr.p_test_cases_failed
-             << " test_cases_skipped"   << utils::attr_value() << tr.p_test_cases_skipped
-             << " test_cases_aborted"   << utils::attr_value() << tr.p_test_cases_aborted;
-    }
-
-    ostr << '>';
-}
-
-//____________________________________________________________________________//
-
-void
-xml_report_formatter::test_unit_report_finish( test_unit const& tu, std::ostream& ostr )
-{
-    ostr << "</" << ( tu.p_type == TUT_CASE ? "TestCase" : "TestSuite" ) << '>';
-}
-
-//____________________________________________________________________________//
-
-void
-xml_report_formatter::do_confirmation_report( test_unit const& tu, std::ostream& ostr )
-{
-    test_unit_report_start( tu, ostr );
-    test_unit_report_finish( tu, ostr );
-}
-
-//____________________________________________________________________________//
-
-} // namespace output
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_XML_REPORT_FORMATTER_IPP_020105GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/included/execution_monitor.hpp b/contrib/libboost/boost_1_62_0/boost/test/included/execution_monitor.hpp
deleted file mode 100644
index cff2adc9a01..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/included/execution_monitor.hpp
+++ /dev/null
@@ -1,21 +0,0 @@
-//  (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 : included variant of Execution Monitor to be used independently
-// ***************************************************************************
-
-#ifndef BOOST_INCLUDED_EXECUTION_MONITOR_HPP_051410GER
-#define BOOST_INCLUDED_EXECUTION_MONITOR_HPP_051410GER
-
-#include <boost/test/impl/execution_monitor.ipp>
-#include <boost/test/impl/debug.ipp>
-
-#endif // BOOST_INCLUDED_EXECUTION_MONITOR_HPP_051410GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/included/prg_exec_monitor.hpp b/contrib/libboost/boost_1_62_0/boost/test/included/prg_exec_monitor.hpp
deleted file mode 100644
index ff48ce5594e..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/included/prg_exec_monitor.hpp
+++ /dev/null
@@ -1,25 +0,0 @@
-//  (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 : included (vs. linked ) version of Program Execution Monitor
-// ***************************************************************************
-
-#ifndef BOOST_INCLUDED_PRG_EXEC_MONITOR_HPP_071894GER
-#define BOOST_INCLUDED_PRG_EXEC_MONITOR_HPP_071894GER
-
-#include <boost/test/impl/execution_monitor.ipp>
-#include <boost/test/impl/debug.ipp>
-#include <boost/test/impl/cpp_main.ipp>
-
-#define BOOST_TEST_INCLUDED
-#include <boost/test/prg_exec_monitor.hpp>
-
-#endif // BOOST_INCLUDED_PRG_EXEC_MONITOR_HPP_071894GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/included/test_exec_monitor.hpp b/contrib/libboost/boost_1_62_0/boost/test/included/test_exec_monitor.hpp
deleted file mode 100644
index 34b6ef44dd0..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/included/test_exec_monitor.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//  (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
-/// @brief Included (vs. linked) version of Test Execution Monitor
-// ***************************************************************************
-
-#ifndef BOOST_INCLUDED_TEST_EXEC_MONITOR_HPP_071894GER
-#define BOOST_INCLUDED_TEST_EXEC_MONITOR_HPP_071894GER
-
-#include <boost/test/impl/compiler_log_formatter.ipp>
-#include <boost/test/impl/junit_log_formatter.ipp>
-#include <boost/test/impl/debug.ipp>
-#include <boost/test/impl/decorator.ipp>
-#include <boost/test/impl/execution_monitor.ipp>
-#include <boost/test/impl/framework.ipp>
-#include <boost/test/impl/plain_report_formatter.ipp>
-#include <boost/test/impl/progress_monitor.ipp>
-#include <boost/test/impl/results_collector.ipp>
-#include <boost/test/impl/results_reporter.ipp>
-#include <boost/test/impl/test_main.ipp>
-#include <boost/test/impl/test_tools.ipp>
-#include <boost/test/impl/test_tree.ipp>
-#include <boost/test/impl/unit_test_log.ipp>
-#include <boost/test/impl/unit_test_main.ipp>
-#include <boost/test/impl/unit_test_monitor.ipp>
-#include <boost/test/impl/unit_test_parameters.ipp>
-#include <boost/test/impl/xml_log_formatter.ipp>
-#include <boost/test/impl/xml_report_formatter.ipp>
-
-#define BOOST_TEST_INCLUDED
-#include <boost/test/test_exec_monitor.hpp>
-
-#endif // BOOST_INCLUDED_TEST_EXEC_MONITOR_HPP_071894GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/included/unit_test.hpp b/contrib/libboost/boost_1_62_0/boost/test/included/unit_test.hpp
deleted file mode 100644
index 8835acd455f..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/included/unit_test.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-//  (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
-//!@brief Included (vs. linked) version of Unit Test Framework
-// ***************************************************************************
-
-#ifndef BOOST_INCLUDED_UNIT_TEST_FRAMEWORK_HPP_071894GER
-#define BOOST_INCLUDED_UNIT_TEST_FRAMEWORK_HPP_071894GER
-
-#include <boost/test/impl/compiler_log_formatter.ipp>
-#include <boost/test/impl/junit_log_formatter.ipp>
-#include <boost/test/impl/debug.ipp>
-#include <boost/test/impl/decorator.ipp>
-#include <boost/test/impl/framework.ipp>
-#include <boost/test/impl/execution_monitor.ipp>
-#include <boost/test/impl/plain_report_formatter.ipp>
-#include <boost/test/impl/progress_monitor.ipp>
-#include <boost/test/impl/results_collector.ipp>
-#include <boost/test/impl/results_reporter.ipp>
-#include <boost/test/impl/test_tools.ipp>
-#include <boost/test/impl/test_tree.ipp>
-#include <boost/test/impl/unit_test_log.ipp>
-#include <boost/test/impl/unit_test_main.ipp>
-#include <boost/test/impl/unit_test_monitor.ipp>
-#include <boost/test/impl/unit_test_parameters.ipp>
-#include <boost/test/impl/xml_log_formatter.ipp>
-#include <boost/test/impl/junit_log_formatter.ipp>
-#include <boost/test/impl/xml_report_formatter.ipp>
-
-#define BOOST_TEST_INCLUDED
-#include <boost/test/unit_test.hpp>
-
-#endif // BOOST_INCLUDED_UNIT_TEST_FRAMEWORK_HPP_071894GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/included/unit_test_framework.hpp b/contrib/libboost/boost_1_62_0/boost/test/included/unit_test_framework.hpp
deleted file mode 100644
index 5bf366ad800..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/included/unit_test_framework.hpp
+++ /dev/null
@@ -1,12 +0,0 @@
-//  (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
-/// @deprecated
-// ***************************************************************************
-
-#include <boost/test/included/unit_test.hpp>
diff --git a/contrib/libboost/boost_1_62_0/boost/test/minimal.hpp b/contrib/libboost/boost_1_62_0/boost/test/minimal.hpp
deleted file mode 100644
index c52295309e9..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/minimal.hpp
+++ /dev/null
@@ -1,156 +0,0 @@
-//  (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
-/// @brief Deprecated implementation of simple minimal testing
-/// @deprecated
-/// To convert to Unit Test Framework simply rewrite:
-/// @code
-/// #include <boost/test/minimal.hpp>
-///
-/// int test_main( int, char *[] )
-/// {
-///   ...
-/// }
-/// @endcode
-/// as
-/// @code
-/// #include <boost/test/included/unit_test.hpp>
-///
-/// BOOST_AUTO_TEST_CASE(test_main)
-/// {
-///   ...
-/// }
-/// @endcode
-// ***************************************************************************
-
-#ifndef BOOST_TEST_MINIMAL_HPP_071894GER
-#define BOOST_TEST_MINIMAL_HPP_071894GER
-
-#define BOOST_CHECK(exp)       \
-  ( (exp)                      \
-      ? static_cast<void>(0)   \
-      : boost::minimal_test::report_error(#exp,__FILE__,__LINE__, BOOST_CURRENT_FUNCTION) )
-
-#define BOOST_REQUIRE(exp)     \
-  ( (exp)                      \
-      ? static_cast<void>(0)   \
-      : boost::minimal_test::report_critical_error(#exp,__FILE__,__LINE__,BOOST_CURRENT_FUNCTION))
-
-#define BOOST_ERROR( msg_ )    \
-        boost::minimal_test::report_error( (msg_),__FILE__,__LINE__, BOOST_CURRENT_FUNCTION, true )
-#define BOOST_FAIL( msg_ )     \
-        boost::minimal_test::report_critical_error( (msg_),__FILE__,__LINE__, BOOST_CURRENT_FUNCTION, true )
-
-//____________________________________________________________________________//
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/impl/execution_monitor.ipp>
-#include <boost/test/impl/debug.ipp>
-#include <boost/test/utils/class_properties.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp>
-
-// Boost
-#include <boost/cstdlib.hpp>            // for exit codes
-#include <boost/current_function.hpp>   // for BOOST_CURRENT_FUNCTION
-
-// STL
-#include <iostream>                     // std::cerr, std::endl
-#include <string>                       // std::string
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-int test_main( int argc, char* argv[] );  // prototype for users test_main()
-
-namespace boost {
-namespace minimal_test {
-
-typedef boost::unit_test::const_string const_string;
-
-inline unit_test::counter_t& errors_counter() { static unit_test::counter_t ec = 0; return ec; }
-
-inline void
-report_error( const char* msg, const char* file, int line, const_string func_name, bool is_msg = false )
-{
-    ++errors_counter();
-    std::cerr << file << "(" << line << "): ";
-
-    if( is_msg )
-        std::cerr << msg;
-    else
-        std::cerr << "test " << msg << " failed";
-
-    if( func_name != "(unknown)" )
-        std::cerr << " in function: '" << func_name << "'";
-
-    std::cerr << std::endl;
-}
-
-inline void
-report_critical_error( const char* msg, const char* file, int line, const_string func_name, bool is_msg = false )
-{
-    report_error( msg, file, line, func_name, is_msg );
-
-    throw boost::execution_aborted();
-}
-
-class caller {
-public:
-    // constructor
-    caller( int argc, char** argv )
-    : m_argc( argc ), m_argv( argv ) {}
-
-    // execution monitor hook implementation
-    int operator()() { return test_main( m_argc, m_argv ); }
-
-private:
-    // Data members
-    int         m_argc;
-    char**      m_argv;
-}; // monitor
-
-} // namespace minimal_test
-} // namespace boost
-
-//____________________________________________________________________________//
-
-int BOOST_TEST_CALL_DECL main( int argc, char* argv[] )
-{
-    using namespace boost::minimal_test;
-
-    try {
-        ::boost::execution_monitor ex_mon;
-        int run_result = ex_mon.execute( caller( argc, argv ) );
-
-        BOOST_CHECK( run_result == 0 || run_result == boost::exit_success );
-    }
-    catch( boost::execution_exception const& exex ) {
-        if( exex.code() != boost::execution_exception::no_error )
-            BOOST_ERROR( (std::string( "exception \"" ) + exex.what() + "\" caught").c_str() );
-        std::cerr << "\n**** Testing aborted.";
-    }
-
-    if( boost::minimal_test::errors_counter() != 0 ) {
-        std::cerr << "\n**** " << errors_counter()
-                  << " error" << (errors_counter() > 1 ? "s" : "" ) << " detected\n";
-
-        return boost::exit_test_failure;
-    }
-
-    std::cout << "\n**** no errors detected\n";
-
-    return boost::exit_success;
-}
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_MINIMAL_HPP_071894GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/output/compiler_log_formatter.hpp b/contrib/libboost/boost_1_62_0/boost/test/output/compiler_log_formatter.hpp
deleted file mode 100644
index cb6172aab68..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/output/compiler_log_formatter.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-//  (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
-/// @brief Contains the formatter for the Human Readable Format (HRF)
-// ***************************************************************************
-
-#ifndef BOOST_TEST_COMPILER_LOG_FORMATTER_HPP_020105GER
-#define BOOST_TEST_COMPILER_LOG_FORMATTER_HPP_020105GER
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/unit_test_log_formatter.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace output {
-
-// ************************************************************************** //
-// **************             compiler_log_formatter           ************** //
-// ************************************************************************** //
-
-//!@brief Log formatter for the Human Readable Format (HRF) log format
-class BOOST_TEST_DECL compiler_log_formatter : public unit_test_log_formatter {
-public:
-    compiler_log_formatter() : m_color_output( false ) {}
-
-    // Formatter interface
-    void    log_start( std::ostream&, counter_t test_cases_amount );
-    void    log_finish( std::ostream& );
-    void    log_build_info( std::ostream& );
-
-    void    test_unit_start( std::ostream&, test_unit const& tu );
-    void    test_unit_finish( std::ostream&, test_unit const& tu, unsigned long elapsed );
-    void    test_unit_skipped( std::ostream&, test_unit const& tu, const_string reason );
-
-    void    log_exception_start( std::ostream&, log_checkpoint_data const&, execution_exception const& ex );
-    void    log_exception_finish( std::ostream& );
-
-    void    log_entry_start( std::ostream&, log_entry_data const&, log_entry_types let );
-    void    log_entry_value( std::ostream&, const_string value );
-    void    log_entry_value( std::ostream&, lazy_ostream const& value );
-    void    log_entry_finish( std::ostream& );
-
-    void    entry_context_start( std::ostream&, log_level );
-    void    log_entry_context( std::ostream&, const_string );
-    void    entry_context_finish( std::ostream& );
-
-protected:
-    virtual void    print_prefix( std::ostream&, const_string file, std::size_t line );
-
-    // Data members
-    bool    m_color_output;
-};
-
-} // namespace output
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_COMPILER_LOG_FORMATTER_HPP_020105GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/output/junit_log_formatter.hpp b/contrib/libboost/boost_1_62_0/boost/test/output/junit_log_formatter.hpp
deleted file mode 100644
index b6e818e37f1..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/output/junit_log_formatter.hpp
+++ /dev/null
@@ -1,135 +0,0 @@
-//  (C) Copyright 2016 Raffi Enficiaud.
-//  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
-///@brief Contains the definition of the Junit log formatter (OF_JUNIT)
-// ***************************************************************************
-
-#ifndef BOOST_TEST_JUNIT_LOG_FORMATTER__
-#define BOOST_TEST_JUNIT_LOG_FORMATTER__
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/unit_test_log_formatter.hpp>
-#include <boost/test/tree/test_unit.hpp>
-
-//#include <boost/test/results_collector.hpp>
-
-// STL
-#include <cstddef> // std::size_t
-#include <map>
-#include <list>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace output {
-
-
-  namespace junit_impl {
-
-    // helper for the JUnit logger
-    struct junit_log_helper
-    {
-      struct assertion_entry {
-
-        enum log_entry_t {
-          log_entry_info,
-          log_entry_error,
-          log_entry_failure
-        };
-
-        assertion_entry() : sealed(false)
-        {}
-
-        std::string logentry_message;
-        std::string logentry_type; // the one that will get expanded in the final junit (failure, error)
-        std::string output;        // additional information/message generated by the assertion
-
-        log_entry_t log_entry;     // the type associated to the assertion (or error)
-
-        bool sealed;               // indicates if the entry can accept additional information
-      };
-
-      std::string system_out;      // sysout: additional information
-      std::string system_err;      // syserr: additional information
-
-      // list of failure, errors and messages (assertions message and the full log)
-      std::vector< assertion_entry > assertion_entries;
-
-    };
-  }
-
-// ************************************************************************** //
-// **************               junit_log_formatter              ************** //
-// ************************************************************************** //
-
-/// JUnit logger class
-class junit_log_formatter : public unit_test_log_formatter {
-public:
-
-    junit_log_formatter() : m_display_build_info(false)
-    {
-      this->m_log_level = log_successful_tests;
-    }
-
-    // Formatter interface
-    void    log_start( std::ostream&, counter_t test_cases_amount );
-    void    log_finish( std::ostream& );
-    void    log_build_info( std::ostream& );
-
-    void    test_unit_start( std::ostream&, test_unit const& tu );
-    void    test_unit_finish( std::ostream&, test_unit const& tu, unsigned long elapsed );
-    void    test_unit_skipped( std::ostream&, test_unit const& tu, const_string reason );
-    void    test_unit_aborted( std::ostream& os, test_unit const& tu );
-
-    void    log_exception_start( std::ostream&, log_checkpoint_data const&, execution_exception const& ex );
-    void    log_exception_finish( std::ostream& );
-
-    void    log_entry_start( std::ostream&, log_entry_data const&, log_entry_types let );
-
-    using   unit_test_log_formatter::log_entry_value; // bring base class functions into overload set
-    void    log_entry_value( std::ostream&, const_string value );
-    void    log_entry_finish( std::ostream& );
-
-    void    entry_context_start( std::ostream&, log_level );
-    void    log_entry_context( std::ostream&, const_string );
-    void    entry_context_finish( std::ostream& );
-
-    //! Discards changes in the log level
-    virtual void        set_log_level(log_level )
-    {
-    }
-
-    //! Instead of a regular stream, returns a file name corresponding to
-    //! the current master test suite. If the file already exists, adds an index
-    //! to it.
-    virtual std::string  get_default_stream_description() const;
-
-
-private:
-    typedef std::map<test_unit_id, junit_impl::junit_log_helper> map_trace_t;
-    map_trace_t map_tests;
-
-    std::list<test_unit_id> list_path_to_root;
-    test_unit_id root_id;
-    bool m_display_build_info;
-    bool m_is_last_assertion_or_error; // true if failure, false if error
-
-    friend class junit_result_helper;
-};
-
-} // namespace output
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_JUNIT_LOG_FORMATTER__
diff --git a/contrib/libboost/boost_1_62_0/boost/test/output/plain_report_formatter.hpp b/contrib/libboost/boost_1_62_0/boost/test/output/plain_report_formatter.hpp
deleted file mode 100644
index 8c509645977..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/output/plain_report_formatter.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-//  (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 : plain report formatter implementation
-// ***************************************************************************
-
-#ifndef BOOST_TEST_PLAIN_REPORT_FORMATTER_HPP_020105GER
-#define BOOST_TEST_PLAIN_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 {
-
-// ************************************************************************** //
-// **************             plain_report_formatter           ************** //
-// ************************************************************************** //
-
-class plain_report_formatter : public results_reporter::format {
-public:
-    plain_report_formatter() : m_indent( 0 ), m_color_output( false ) {}
-
-    // 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 );
-
-private:
-    // Data members
-    counter_t m_indent;
-    bool    m_color_output;
-};
-
-} // namespace output
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_PLAIN_REPORT_FORMATTER_HPP_020105GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/output/xml_log_formatter.hpp b/contrib/libboost/boost_1_62_0/boost/test/output/xml_log_formatter.hpp
deleted file mode 100644
index 4d848a04250..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/output/xml_log_formatter.hpp
+++ /dev/null
@@ -1,72 +0,0 @@
-//  (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 : contains OF_XML Log formatter definition
-// ***************************************************************************
-
-#ifndef BOOST_TEST_XML_LOG_FORMATTER_020105GER
-#define BOOST_TEST_XML_LOG_FORMATTER_020105GER
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/unit_test_log_formatter.hpp>
-
-// STL
-#include <cstddef> // std::size_t
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace output {
-
-// ************************************************************************** //
-// **************               xml_log_formatter              ************** //
-// ************************************************************************** //
-
-class xml_log_formatter : public unit_test_log_formatter {
-public:
-    // Formatter interface
-    void    log_start( std::ostream&, counter_t test_cases_amount );
-    void    log_finish( std::ostream& );
-    void    log_build_info( std::ostream& );
-
-    void    test_unit_start( std::ostream&, test_unit const& tu );
-    void    test_unit_finish( std::ostream&, test_unit const& tu, unsigned long elapsed );
-    void    test_unit_skipped( std::ostream&, test_unit const& tu, const_string reason );
-
-    void    log_exception_start( std::ostream&, log_checkpoint_data const&, execution_exception const& ex );
-    void    log_exception_finish( std::ostream& );
-
-    void    log_entry_start( std::ostream&, log_entry_data const&, log_entry_types let );
-    using   unit_test_log_formatter::log_entry_value; // bring base class functions into overload set
-    void    log_entry_value( std::ostream&, const_string value );
-    void    log_entry_finish( std::ostream& );
-
-    void    entry_context_start( std::ostream&, log_level );
-    void    log_entry_context( std::ostream&, const_string );
-    void    entry_context_finish( std::ostream& );
-
-private:
-    // Data members
-    const_string    m_curr_tag;
-    bool            m_value_closed;
-};
-
-} // namespace output
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_XML_LOG_FORMATTER_020105GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/output/xml_report_formatter.hpp b/contrib/libboost/boost_1_62_0/boost/test/output/xml_report_formatter.hpp
deleted file mode 100644
index ca5e47182f1..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/output/xml_report_formatter.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//  (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
diff --git a/contrib/libboost/boost_1_62_0/boost/test/output_test_stream.hpp b/contrib/libboost/boost_1_62_0/boost/test/output_test_stream.hpp
deleted file mode 100644
index 26eaf320ac4..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/output_test_stream.hpp
+++ /dev/null
@@ -1,14 +0,0 @@
-//  (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
-//!@brief Deprecated header.
-//!@deprecated Use boost/test/tools/output_test_stream.hpp instead
-// ***************************************************************************
-
-// Boost.Test
-#include <boost/test/tools/output_test_stream.hpp>
diff --git a/contrib/libboost/boost_1_62_0/boost/test/parameterized_test.hpp b/contrib/libboost/boost_1_62_0/boost/test/parameterized_test.hpp
deleted file mode 100644
index b94e7ec8b3e..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/parameterized_test.hpp
+++ /dev/null
@@ -1,172 +0,0 @@
-//  (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
-//!@brief generators and helper macros for parameterized tests
-// ***************************************************************************
-
-#ifndef BOOST_TEST_PARAMETERIZED_TEST_HPP_021102GER
-#define BOOST_TEST_PARAMETERIZED_TEST_HPP_021102GER
-
-// Boost.Test
-#include <boost/test/unit_test_suite.hpp>
-
-// Boost
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/remove_const.hpp>
-
-#include <boost/bind.hpp>
-#include <boost/function/function1.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-#define BOOST_PARAM_TEST_CASE( function, begin, end )                      \
-boost::unit_test::make_test_case( function,                                \
-                                  BOOST_TEST_STRINGIZE( function ),        \
-                                  __FILE__, __LINE__,                      \
-                                  (begin), (end) )                         \
-/**/
-
-#define BOOST_PARAM_CLASS_TEST_CASE( function, tc_instance, begin, end )   \
-boost::unit_test::make_test_case( function,                                \
-                                  BOOST_TEST_STRINGIZE( function ),        \
-                                  __FILE__, __LINE__,                      \
-                                  (tc_instance),                           \
-                                  (begin), (end) )                         \
-/**/
-
-namespace boost {
-namespace unit_test {
-
-namespace ut_detail {
-
-// ************************************************************************** //
-// **************           param_test_case_generator          ************** //
-// ************************************************************************** //
-
-template<typename ParamType, typename ParamIter>
-class param_test_case_generator : public test_unit_generator {
-public:
-    param_test_case_generator( boost::function<void (ParamType)> const& test_func,
-                               const_string                             tc_name,
-                               const_string                             tc_file,
-                               std::size_t                              tc_line,
-                               ParamIter                                par_begin,
-                               ParamIter                                par_end )
-    : m_test_func( test_func )
-    , m_tc_name( ut_detail::normalize_test_case_name( tc_name ) )
-    , m_tc_file( tc_file )
-    , m_tc_line( tc_line )
-    , m_par_begin( par_begin )
-    , m_par_end( par_end )
-    {}
-
-    virtual test_unit* next() const
-    {
-        if( m_par_begin == m_par_end )
-            return (test_unit*)0;
-
-        test_unit* res = new test_case( m_tc_name, m_tc_file, m_tc_line, boost::bind( m_test_func, *m_par_begin ) );
-
-        ++m_par_begin;
-
-        return res;
-    }
-
-private:
-    // Data members
-    boost::function<void (ParamType)>    m_test_func;
-    std::string             m_tc_name;
-    const_string            m_tc_file;
-    std::size_t             m_tc_line;
-    mutable ParamIter       m_par_begin;
-    ParamIter               m_par_end;
-};
-
-//____________________________________________________________________________//
-
-template<typename UserTestCase,typename ParamType>
-struct user_param_tc_method_invoker {
-    typedef void (UserTestCase::*test_method)( ParamType );
-
-    // Constructor
-    user_param_tc_method_invoker( shared_ptr<UserTestCase> inst, test_method test_method )
-    : m_inst( inst ), m_test_method( test_method ) {}
-
-    void operator()( ParamType p ) { ((*m_inst).*m_test_method)( p ); }
-
-    // Data members
-    shared_ptr<UserTestCase> m_inst;
-    test_method              m_test_method;
-};
-
-//____________________________________________________________________________//
-
-} // namespace ut_detail
-
-template<typename ParamType, typename ParamIter>
-inline ut_detail::param_test_case_generator<ParamType,ParamIter>
-make_test_case( boost::function<void (ParamType)> const& test_func,
-                const_string                             tc_name,
-                const_string                             tc_file,
-                std::size_t                              tc_line,
-                ParamIter                                par_begin,
-                ParamIter                                par_end )
-{
-    return ut_detail::param_test_case_generator<ParamType,ParamIter>( test_func, tc_name, tc_file, tc_line, par_begin, par_end );
-}
-
-//____________________________________________________________________________//
-
-template<typename ParamType, typename ParamIter>
-inline ut_detail::param_test_case_generator<
-    BOOST_DEDUCED_TYPENAME remove_const<BOOST_DEDUCED_TYPENAME remove_reference<ParamType>::type>::type,ParamIter>
-make_test_case( void (*test_func)( ParamType ),
-                const_string  tc_name,
-                const_string  tc_file,
-                std::size_t   tc_line,
-                ParamIter     par_begin,
-                ParamIter     par_end )
-{
-    typedef BOOST_DEDUCED_TYPENAME remove_const<BOOST_DEDUCED_TYPENAME remove_reference<ParamType>::type>::type param_value_type;
-    return ut_detail::param_test_case_generator<param_value_type,ParamIter>( test_func, tc_name, tc_file, tc_line, par_begin, par_end );
-}
-
-//____________________________________________________________________________//
-
-template<typename UserTestCase,typename ParamType, typename ParamIter>
-inline ut_detail::param_test_case_generator<
-    BOOST_DEDUCED_TYPENAME remove_const<BOOST_DEDUCED_TYPENAME remove_reference<ParamType>::type>::type,ParamIter>
-make_test_case( void (UserTestCase::*test_method )( ParamType ),
-                const_string                           tc_name,
-                const_string                           tc_file,
-                std::size_t                            tc_line,
-                boost::shared_ptr<UserTestCase> const& user_test_case,
-                ParamIter                              par_begin,
-                ParamIter                              par_end )
-{
-    typedef BOOST_DEDUCED_TYPENAME remove_const<BOOST_DEDUCED_TYPENAME remove_reference<ParamType>::type>::type param_value_type;
-    return ut_detail::param_test_case_generator<param_value_type,ParamIter>(
-               ut_detail::user_param_tc_method_invoker<UserTestCase,ParamType>( user_test_case, test_method ),
-               tc_name,
-               tc_file,
-               tc_line,
-               par_begin,
-               par_end );
-}
-
-//____________________________________________________________________________//
-
-} // unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_PARAMETERIZED_TEST_HPP_021102GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/predicate_result.hpp b/contrib/libboost/boost_1_62_0/boost/test/predicate_result.hpp
deleted file mode 100644
index 9b573637138..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/predicate_result.hpp
+++ /dev/null
@@ -1,14 +0,0 @@
-//  (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
-/// @brief Deprecated header
-/// @deprecated Use boost/test/tools/assertion_result.hpp instead
-// ***************************************************************************
-
-// Boost.Test
-#include <boost/test/tools/assertion_result.hpp>
diff --git a/contrib/libboost/boost_1_62_0/boost/test/prg_exec_monitor.hpp b/contrib/libboost/boost_1_62_0/boost/test/prg_exec_monitor.hpp
deleted file mode 100644
index f072e215dbe..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/prg_exec_monitor.hpp
+++ /dev/null
@@ -1,81 +0,0 @@
-//  (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
-/// @brief Entry point for the end user into the Program Execution Monitor.
-///
-/// Use this header to forward declare function prg_exec_monitor_main and to automatically define a main
-/// function for you. If you prefer to use your own main you are free to do so, but you need to define
-/// BOOST_TEST_NO_MAIN before incuding this header. To initiate your main program body execution you
-/// would use statement like this:
-/// @code ::boost::prg_exec_monitor_main( &my_main, argc, argv ); @endcode
-/// Also this header facilitate auto linking with the Program Execution Monitor library if this feature
-/// is supported
-// ***************************************************************************
-
-#ifndef BOOST_PRG_EXEC_MONITOR_HPP_071894GER
-#define BOOST_PRG_EXEC_MONITOR_HPP_071894GER
-
-#include <boost/test/detail/config.hpp>
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                 Auto Linking                 ************** //
-// ************************************************************************** //
-
-// Automatically link to the correct build variant where possible.
-#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_TEST_NO_LIB) && \
-    !defined(BOOST_TEST_SOURCE) && !defined(BOOST_TEST_INCLUDED)
-#  define BOOST_LIB_NAME boost_prg_exec_monitor
-
-// If we're importing code from a dll, then tell auto_link.hpp about it:
-#  if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_TEST_DYN_LINK)
-#    define BOOST_DYN_LINK
-#  endif
-
-#  include <boost/config/auto_link.hpp>
-
-#endif  // auto-linking disabled
-
-// ************************************************************************** //
-// **************               prg_exec_monitor_main          ************** //
-// ************************************************************************** //
-
-namespace boost {
-
-/// @brief Wrapper around the main function
-///
-/// Call this routine instead of your own main body implementation directly. This routine impements all the monitoring
-/// functionality. THe monitor behavior is configurable by using the environment variable BOOST_TEST_CATCH_SYSTEM_ERRORS.
-/// If set to string value "no", the monitor will not attempt to catch system errors (signals)
-/// @param[in] cpp_main main function body. Should have the same signature as regular main function
-/// @param[in] argc, argv command line arguments
-int BOOST_TEST_DECL prg_exec_monitor_main( int (*cpp_main)( int argc, char* argv[] ), int argc, char* argv[] );
-
-} // boost
-
-#if defined(BOOST_TEST_DYN_LINK) && !defined(BOOST_TEST_NO_MAIN)
-
-// ************************************************************************** //
-// **************        main function for tests using dll     ************** //
-// ************************************************************************** //
-
-// prototype for user's cpp_main()
-int cpp_main( int argc, char* argv[] );
-
-int BOOST_TEST_CALL_DECL
-main( int argc, char* argv[] )
-{
-    return ::boost::prg_exec_monitor_main( &cpp_main, argc, argv );
-}
-
-//____________________________________________________________________________//
-
-#endif // BOOST_TEST_DYN_LINK && !BOOST_TEST_NO_MAIN
-
-#endif // BOOST_PRG_EXEC_MONITOR_HPP_071894GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/progress_monitor.hpp b/contrib/libboost/boost_1_62_0/boost/test/progress_monitor.hpp
deleted file mode 100644
index e480ac669dc..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/progress_monitor.hpp
+++ /dev/null
@@ -1,66 +0,0 @@
-//  (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
-/// @brief defines simple text based progress monitor
-// ***************************************************************************
-
-#ifndef BOOST_TEST_PROGRESS_MONITOR_HPP_020105GER
-#define BOOST_TEST_PROGRESS_MONITOR_HPP_020105GER
-
-// Boost.Test
-#include <boost/test/tree/observer.hpp>
-#include <boost/test/utils/trivial_singleton.hpp>
-
-// STL
-#include <iosfwd>   // for std::ostream&
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                progress_monitor              ************** //
-// ************************************************************************** //
-
-/// This class implements test observer interface and updates test progress as test units finish or get aborted
-class BOOST_TEST_DECL progress_monitor_t : public test_observer, public singleton<progress_monitor_t> {
-public:
-    /// @name Test observer interface
-    /// @{
-    virtual void    test_start( counter_t test_cases_amount );
-    virtual void    test_aborted();
-
-    virtual void    test_unit_finish( test_unit const&, unsigned long );
-    virtual void    test_unit_skipped( test_unit const&, const_string );
-
-    virtual int     priority() { return 3; }
-    /// @}
-
-    /// @name Configuration
-    /// @{
-    void            set_stream( std::ostream& );
-    /// @}
-
-private:
-    BOOST_TEST_SINGLETON_CONS( progress_monitor_t )
-}; // progress_monitor_t
-
-BOOST_TEST_SINGLETON_INST( progress_monitor )
-
-} // namespace unit_test
-} // namespace boost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_PROGRESS_MONITOR_HPP_020105GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/results_collector.hpp b/contrib/libboost/boost_1_62_0/boost/test/results_collector.hpp
deleted file mode 100644
index 7d2c2bee58d..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/results_collector.hpp
+++ /dev/null
@@ -1,140 +0,0 @@
-//  (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
-/// @brief Defines testing result collector components
-///
-/// Defines classes for keeping track (@ref test_results) and collecting
-/// (@ref results_collector_t) the states of the test units.
-// ***************************************************************************
-
-#ifndef BOOST_TEST_RESULTS_COLLECTOR_HPP_071894GER
-#define BOOST_TEST_RESULTS_COLLECTOR_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/tree/observer.hpp>
-
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/fwd_decl.hpp>
-
-#include <boost/test/utils/trivial_singleton.hpp>
-#include <boost/test/utils/class_properties.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-namespace {
-
-// ************************************************************************** //
-/// First failed assertion debugger hook
-///
-/// This function is a placeholder where user can set a breakpoint in debugger to catch the
-/// very first assertion failure in each test case
-// ************************************************************************** //
-inline void first_failed_assertion() {}
-}
-
-// ************************************************************************** //
-/// @brief Collection of attributes constituting test unit results
-///
-/// This class is a collection of attributes describing a test result.
-///
-/// The attributes presented as public properties on
-/// an instance of the class. In addition summary conclusion methods are presented to generate simple answer to pass/fail question
-
-class BOOST_TEST_DECL test_results {
-public:
-    test_results();
-
-    /// Type representing counter like public property
-    typedef BOOST_READONLY_PROPERTY( counter_t, (results_collector_t)
-                                                (test_results)
-                                                (results_collect_helper) ) counter_prop;
-    /// Type representing boolean like public property
-    typedef BOOST_READONLY_PROPERTY( bool,      (results_collector_t)
-                                                (test_results)
-                                                (results_collect_helper) ) bool_prop;
-
-    counter_prop    p_assertions_passed;        //!< Number of successful assertions
-    counter_prop    p_assertions_failed;        //!< Number of failing assertions
-    counter_prop    p_warnings_failed;          //!< Number of warnings
-    counter_prop    p_expected_failures;
-    counter_prop    p_test_cases_passed;        //!< Number of successfull test cases
-    counter_prop    p_test_cases_warned;        //!< Number of warnings in test cases
-    counter_prop    p_test_cases_failed;        //!< Number of failing test cases
-    counter_prop    p_test_cases_skipped;       //!< Number of skipped test cases
-    counter_prop    p_test_cases_aborted;       //!< Number of aborted test cases
-    counter_prop    p_duration_microseconds;    //!< Duration of the test in microseconds
-    bool_prop       p_aborted;                  //!< Indicates that the test unit execution has been aborted
-    bool_prop       p_skipped;                  //!< Indicates that the test unit execution has been skipped
-
-    /// Returns true if test unit passed
-    bool            passed() const;
-
-    /// Produces result code for the test unit execution
-    ///
-    /// This methhod return one of the result codes defined in @c boost/cstdlib.hpp
-    /// @returns
-    ///   - @c boost::exit_success on success,
-    ///   - @c boost::exit_exception_failure in case test unit
-    ///     was aborted for any reason (incuding uncaught exception)
-    ///   - and @c boost::exit_test_failure otherwise
-    int             result_code() const;
-
-    //! Combines the results of the current instance with another
-    //!
-    //! Only the counters are updated and the @c p_aborted and @c p_skipped are left unchanged.
-    void            operator+=( test_results const& );
-
-    //! Resets the current state of the result
-    void            clear();
-};
-
-// ************************************************************************** //
-/// @brief Collects and combines the test results
-///
-/// This class collects and combines the results of the test unit during the execution of the
-/// test tree. The results_collector_t::results() function combines the test results on a subtree
-/// of the test tree.
-///
-/// @see boost::unit_test::test_observer
-class BOOST_TEST_DECL results_collector_t : public test_observer, public singleton<results_collector_t> {
-public:
-
-    virtual void        test_start( counter_t );
-
-    virtual void        test_unit_start( test_unit const& );
-    virtual void        test_unit_finish( test_unit const&, unsigned long );
-    virtual void        test_unit_skipped( test_unit const&, const_string );
-    virtual void        test_unit_aborted( test_unit const& );
-
-    virtual void        assertion_result( unit_test::assertion_result );
-    virtual void        exception_caught( execution_exception const& );
-
-    virtual int         priority() { return 2; }
-
-    /// Results access per test unit
-    ///
-    /// @param[in] tu_id id of a test unit
-    test_results const& results( test_unit_id tu_id ) const;
-
-private:
-    BOOST_TEST_SINGLETON_CONS( results_collector_t )
-};
-
-BOOST_TEST_SINGLETON_INST( results_collector )
-
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_RESULTS_COLLECTOR_HPP_071894GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/results_reporter.hpp b/contrib/libboost/boost_1_62_0/boost/test/results_reporter.hpp
deleted file mode 100644
index 6f8d8f1105f..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/results_reporter.hpp
+++ /dev/null
@@ -1,122 +0,0 @@
-//  (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
-/// @brief defines testing result reporter interfaces
-///
-/// This file defines interfaces that are responsible for results reporting. Interface is presented in a form of
-/// free standing function implemented in namespace result_reporter
-// ***************************************************************************
-
-#ifndef BOOST_TEST_RESULTS_REPORTER_HPP_021205GER
-#define BOOST_TEST_RESULTS_REPORTER_HPP_021205GER
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/fwd_decl.hpp>
-
-// STL
-#include <iosfwd>   // for std::ostream&
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-/// Namespace for results reporter interfaces
-namespace results_reporter {
-
-// ************************************************************************** //
-/// @brief Results report formatter interface
-///
-/// This is abstract interface for the report formatter used by results reporter routines.
-/// You can define a custom formatter by implementing this interface and setting the formatter using set_format function.
-/// This is usually done during test module initialization
-// ************************************************************************** //
-
-class BOOST_TEST_DECL format {
-public:
-    // Destructor
-    virtual ~format() {}
-
-    virtual void    results_report_start( std::ostream& ostr ) = 0;
-    virtual void    results_report_finish( std::ostream& ostr ) = 0;
-
-    virtual void    test_unit_report_start( test_unit const&, std::ostream& ostr ) = 0;
-    virtual void    test_unit_report_finish( test_unit const&, std::ostream& ostr ) = 0;
-
-    virtual void    do_confirmation_report( test_unit const&, std::ostream& ostr ) = 0;
-};
-
-// ************************************************************************** //
-/// @name report configuration
-// ************************************************************************** //
-
-/// Sets reporting level
-
-/// There are only four possible levels for results report:
-/// - confirmation report (boost::unit_test::CONFIRMATION_REPORT). This report level only produces short confirmation
-///   message about test module pass/fail status
-/// - short report (boost::unit_test::SHORT_REPORT). This report level produces short summary report for failed/passed
-///   assertions and test units.
-/// - detailed report (boost::unit_test::DETAILED_REPORT). This report level produces detailed report per test unit for
-///   passed/failed assertions and uncaught exceptions
-/// - no report (boost::unit_test::NO_REPORT). This report level produces no results report. This is used for test modules
-///   running as part of some kind of continues integration framework
-/// @param[in] l report level
-BOOST_TEST_DECL void    set_level( report_level l );
-
-/// Sets output stream for results reporting
-
-/// By default std::cerr is used. Use this function to set a different stream. The framework
-/// refers to the stream by reference, so you need to make sure the stream object lifetime exceeds the testing main scope.
-BOOST_TEST_DECL void    set_stream( std::ostream& );
-
-/// Sets one of the predefined formats
-
-/// The framework implements two results report formats:
-/// - plain human readable format (boost::unit_test::OF_CLF)
-/// - XML format (boost::unit_test::OF_XML)
-/// @param[in] of one of the presefined enumeration values for output formats
-BOOST_TEST_DECL void    set_format( output_format of );
-
-/// Sets custom report formatter
-
-/// The framework takes ownership of the pointer passed as an argument. So this should be a pointer to
-/// a heap allocated object
-/// @param[in] f pointer to heap allocated instance of custom report formatter class
-BOOST_TEST_DECL void    set_format( results_reporter::format* f );
-
-/// @brief Access to configured results reporter stream
-///
-/// Use this stream to report additional information abut test module execution
-BOOST_TEST_DECL std::ostream& get_stream();
-
-/// @}
-
-// ************************************************************************** //
-// **************               report initiation              ************** //
-// ************************************************************************** //
-
-BOOST_TEST_DECL void    make_report( report_level l = INV_REPORT_LEVEL, test_unit_id = INV_TEST_UNIT_ID );
-inline void             confirmation_report( test_unit_id id = INV_TEST_UNIT_ID )
-{ make_report( CONFIRMATION_REPORT, id ); }
-inline void             short_report( test_unit_id id = INV_TEST_UNIT_ID )
-{ make_report( SHORT_REPORT, id ); }
-inline void             detailed_report( test_unit_id id = INV_TEST_UNIT_ID )
-{ make_report( DETAILED_REPORT, id ); }
-
-} // namespace results_reporter
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_RESULTS_REPORTER_HPP_021205GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/test_case_template.hpp b/contrib/libboost/boost_1_62_0/boost/test/test_case_template.hpp
deleted file mode 100644
index c01bd0738a2..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/test_case_template.hpp
+++ /dev/null
@@ -1,13 +0,0 @@
-//  (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
-/// @brief Deprecated header.
-/// @deprecated Use @c boost/test/unit_test.hpp instead
-// ***************************************************************************
-
-#include <boost/test/unit_test.hpp>
diff --git a/contrib/libboost/boost_1_62_0/boost/test/test_exec_monitor.hpp b/contrib/libboost/boost_1_62_0/boost/test/test_exec_monitor.hpp
deleted file mode 100644
index 04508093352..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/test_exec_monitor.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//  (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
-/// @brief Deprecated implementation of Test Execution Monitor
-///
-/// To convert to Unit Test Framework simply rewrite:
-/// @code
-/// #include <boost/test/test_exec_monitor.hpp>
-///
-/// int test_main( int, char *[] )
-/// {
-///   ...
-/// }
-/// @endcode
-/// as
-/// @code
-/// #include <boost/test/unit_test.hpp>
-///
-/// BOOST_AUTO_TEST_CASE(test_main)
-/// {
-///   ...
-/// }
-/// @endcode
-/// and link with boost_unit_test_framework library *instead of* boost_test_exec_monitor
-// ***************************************************************************
-
-#ifndef BOOST_TEST_EXEC_MONITOR_HPP_071894GER
-#define BOOST_TEST_EXEC_MONITOR_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/test_tools.hpp>
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                 Auto Linking                 ************** //
-// ************************************************************************** //
-
-// Automatically link to the correct build variant where possible.
-#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_TEST_NO_LIB) && \
-    !defined(BOOST_TEST_SOURCE) && !defined(BOOST_TEST_INCLUDED)
-
-#  define BOOST_LIB_NAME boost_test_exec_monitor
-#  include <boost/config/auto_link.hpp>
-
-#endif  // auto-linking disabled
-
-#endif // BOOST_TEST_EXEC_MONITOR_HPP_071894GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/test_tools.hpp b/contrib/libboost/boost_1_62_0/boost/test/test_tools.hpp
deleted file mode 100644
index a542d5fcdee..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/test_tools.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//  (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
-/// @brief test tools compatibility header
-///
-/// This file is used to select the test tools implementation and includes all the necessary headers
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TOOLS_HPP_111812GER
-#define BOOST_TEST_TOOLS_HPP_111812GER
-
-#include <boost/config.hpp>
-
-// brings some compiler configuration like BOOST_PP_VARIADICS
-#include <boost/test/detail/config.hpp>
-
-#include <boost/preprocessor/config/config.hpp>
-
-#if    defined(BOOST_NO_CXX11_VARIADIC_MACROS) \
-    || defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) \
-    || defined(BOOST_NO_CXX11_DECLTYPE)
-#  define BOOST_TEST_MACRO_LIMITED_SUPPORT
-#endif
-
-// Boost.Test
-// #define BOOST_TEST_NO_OLD_TOOLS
-
-#if     defined(BOOST_TEST_MACRO_LIMITED_SUPPORT) \
-    &&  (   !BOOST_PP_VARIADICS \
-         || !(__cplusplus >= 201103L) && defined(BOOST_NO_CXX11_VARIADIC_MACROS))
-#  define BOOST_TEST_NO_NEW_TOOLS
-#endif
-
-// #define BOOST_TEST_TOOLS_UNDER_DEBUGGER
-// #define BOOST_TEST_TOOLS_DEBUGGABLE
-
-#include <boost/test/tools/context.hpp>
-
-#ifndef BOOST_TEST_NO_OLD_TOOLS
-#  include <boost/test/tools/old/interface.hpp>
-#  include <boost/test/tools/old/impl.hpp>
-
-#  include <boost/test/tools/detail/print_helper.hpp>
-#endif
-
-#ifndef BOOST_TEST_NO_NEW_TOOLS
-#  include <boost/test/tools/interface.hpp>
-#  include <boost/test/tools/assertion.hpp>
-#  include <boost/test/tools/fpc_op.hpp>
-#  include <boost/test/tools/collection_comparison_op.hpp>
-#  include <boost/test/tools/cstring_comparison_op.hpp>
-
-#  include <boost/test/tools/detail/fwd.hpp>
-#  include <boost/test/tools/detail/print_helper.hpp>
-#  include <boost/test/tools/detail/it_pair.hpp>
-
-#  include <boost/test/tools/detail/bitwise_manip.hpp>
-#  include <boost/test/tools/detail/tolerance_manip.hpp>
-#  include <boost/test/tools/detail/per_element_manip.hpp>
-#  include <boost/test/tools/detail/lexicographic_manip.hpp>
-#endif
-
-#endif // BOOST_TEST_TOOLS_HPP_111812GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/assertion.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/assertion.hpp
deleted file mode 100644
index cca2f52beb4..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/assertion.hpp
+++ /dev/null
@@ -1,410 +0,0 @@
-//  (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
-//!@brief Defines framework for automated assertion construction
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TOOLS_ASSERTION_HPP_100911GER
-#define BOOST_TEST_TOOLS_ASSERTION_HPP_100911GER
-
-// Boost.Test
-#include <boost/test/tools/assertion_result.hpp>
-#include <boost/test/tools/detail/print_helper.hpp>
-#include <boost/test/tools/detail/fwd.hpp>
-
-// Boost
-#include <boost/type.hpp>
-#include <boost/type_traits/decay.hpp>
-#include <boost/mpl/assert.hpp>
-#include <boost/utility/declval.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/remove_const.hpp>
-
-// STL
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-#include <utility>
-#endif
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace test_tools {
-namespace assertion {
-
-// ************************************************************************** //
-// **************             assertion::operators             ************** //
-// ************************************************************************** //
-// precedence 4: ->*, .*
-// precedence 5: *, /, %
-// precedence 6: +, -
-// precedence 7: << , >>
-// precedence 8: <, <=, > and >=
-// precedence 9: == and !=
-// precedence 10: bitwise AND
-// precedence 11: bitwise XOR
-// precedence 12: bitwise OR
-// precedence 13: logical AND
-//  disabled
-// precedence 14: logical OR
-//  disabled
-// precedence 15: ternary conditional
-//  disabled
-// precedence 16: = and OP= operators
-// precedence 17: throw operator
-//  not supported
-// precedence 18: comma
-//  not supported
-
-namespace op {
-
-#define BOOST_TEST_FOR_EACH_COMP_OP(action) \
-    action( < , LT, >= )                    \
-    action( <=, LE, >  )                    \
-    action( > , GT, <= )                    \
-    action( >=, GE, <  )                    \
-    action( ==, EQ, != )                    \
-    action( !=, NE, == )                    \
-/**/
-
-//____________________________________________________________________________//
-
-#ifndef BOOST_NO_CXX11_DECLTYPE
-
-#define BOOST_TEST_FOR_EACH_CONST_OP(action)\
-    action(->*, MEMP, ->* )                 \
-                                            \
-    action( * , MUL, * )                    \
-    action( / , DIV, / )                    \
-    action( % , MOD, % )                    \
-                                            \
-    action( + , ADD, + )                    \
-    action( - , SUB, - )                    \
-                                            \
-    action( <<, LSH, << )                   \
-    action( >>, RSH, >> )                   \
-                                            \
-    BOOST_TEST_FOR_EACH_COMP_OP(action)     \
-                                            \
-    action( & , BAND, & )                   \
-    action( ^ , XOR, ^ )                    \
-    action( | , BOR, | )                    \
-/**/
-
-#else
-
-#define BOOST_TEST_FOR_EACH_CONST_OP(action)\
-    BOOST_TEST_FOR_EACH_COMP_OP(action)     \
-/**/
-
-#endif
-
-//____________________________________________________________________________//
-
-#define BOOST_TEST_FOR_EACH_MUT_OP(action)  \
-    action( = , SET , =  )                  \
-    action( +=, IADD, += )                  \
-    action( -=, ISUB, -= )                  \
-    action( *=, IMUL, *= )                  \
-    action( /=, IDIV, /= )                  \
-    action( %=, IMOD, %= )                  \
-    action(<<=, ILSH, <<=)                  \
-    action(>>=, IRSH, >>=)                  \
-    action( &=, IAND, &= )                  \
-    action( ^=, IXOR, ^= )                  \
-    action( |=, IOR , |= )                  \
-/**/
-
-//____________________________________________________________________________//
-
-#ifndef BOOST_NO_CXX11_DECLTYPE
-#   define DEDUCE_RESULT_TYPE( oper )                                   \
-    decltype(boost::declval<Lhs>() oper boost::declval<Rhs>() ) optype; \
-    typedef typename boost::remove_reference<optype>::type              \
-/**/
-#else
-#   define DEDUCE_RESULT_TYPE( oper ) bool
-#endif
-
-#define DEFINE_CONST_OPER( oper, name, rev )        \
-template<typename Lhs, typename Rhs,                \
-         typename Enabler=void>                     \
-struct name {                                       \
-    typedef DEDUCE_RESULT_TYPE( oper ) result_type; \
-                                                    \
-    static result_type                              \
-    eval( Lhs const& lhs, Rhs const& rhs )          \
-    {                                               \
-        return lhs oper rhs;                        \
-    }                                               \
-                                                    \
-    template<typename PrevExprType>                 \
-    static void                                     \
-    report( std::ostream&       ostr,               \
-            PrevExprType const& lhs,                \
-            Rhs const&          rhs)                \
-    {                                               \
-        lhs.report( ostr );                         \
-        ostr << revert()                            \
-             << tt_detail::print_helper( rhs );     \
-    }                                               \
-                                                    \
-    static char const* revert()                     \
-    { return " " #rev " "; }                        \
-};                                                  \
-/**/
-
-BOOST_TEST_FOR_EACH_CONST_OP( DEFINE_CONST_OPER )
-
-#undef DEDUCE_RESULT_TYPE
-#undef DEFINE_CONST_OPER
-
-//____________________________________________________________________________//
-
-} // namespace op
-
-// ************************************************************************** //
-// **************          assertion::expression_base          ************** //
-// ************************************************************************** //
-// Defines expression operators
-
-template<typename Lhs, typename Rhs, typename OP> class binary_expr;
-
-template<typename ExprType,typename ValType>
-class expression_base {
-public:
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    template<typename T>
-    struct RhsT : remove_const<typename remove_reference<T>::type> {};
-    
-#define ADD_OP_SUPPORT( oper, name, _ )                         \
-    template<typename T>                                        \
-    binary_expr<ExprType,T,                                     \
-        op::name<ValType,typename RhsT<T>::type> >              \
-    operator oper( T&& rhs )                                    \
-    {                                                           \
-        return binary_expr<ExprType,T,                          \
-         op::name<ValType,typename RhsT<T>::type> >             \
-            ( std::forward<ExprType>(                           \
-                *static_cast<ExprType*>(this) ),                \
-              std::forward<T>(rhs) );                           \
-    }                                                           \
-/**/
-#else
-
-#define ADD_OP_SUPPORT( oper, name, _ )                         \
-    template<typename T>                                        \
-    binary_expr<ExprType,typename boost::decay<T const>::type,  \
-        op::name<ValType,typename boost::decay<T const>::type> >\
-    operator oper( T const& rhs ) const                         \
-    {                                                           \
-        typedef typename boost::decay<T const>::type Rhs;       \
-        return binary_expr<ExprType,Rhs,op::name<ValType,Rhs> > \
-            ( *static_cast<ExprType const*>(this),              \
-              rhs );                                            \
-    }                                                           \
-/**/
-#endif
-
-    BOOST_TEST_FOR_EACH_CONST_OP( ADD_OP_SUPPORT )
-    #undef ADD_OP_SUPPORT
-
-#ifndef BOOST_NO_CXX11_AUTO_DECLARATIONS
-    // Disabled operators
-    template<typename T>
-    ExprType&
-    operator ||( T const& /*rhs*/ )
-    {
-        BOOST_MPL_ASSERT_MSG(false, CANT_USE_LOGICAL_OPERATOR_OR_WITHIN_THIS_TESTING_TOOL, () );
-
-        return *static_cast<ExprType*>(this);
-    }
-
-    template<typename T>
-    ExprType&
-    operator &&( T const& /*rhs*/ )
-    {
-        BOOST_MPL_ASSERT_MSG(false, CANT_USE_LOGICAL_OPERATOR_AND_WITHIN_THIS_TESTING_TOOL, () );
-
-        return *static_cast<ExprType*>(this);
-    }
-
-    operator bool()
-    {
-        BOOST_MPL_ASSERT_MSG(false, CANT_USE_TERNARY_OPERATOR_WITHIN_THIS_TESTING_TOOL, () );
-
-        return false;
-    }
-#endif
-};
-
-// ************************************************************************** //
-// **************            assertion::value_expr             ************** //
-// ************************************************************************** //
-// simple value expression
-
-template<typename T>
-class value_expr : public expression_base<value_expr<T>,typename remove_const<typename remove_reference<T>::type>::type> {
-public:
-    // Public types
-    typedef T                   result_type;
-
-    // Constructor
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    value_expr( value_expr&& ve )
-    : m_value( std::forward<T>(ve.m_value) )
-    {}
-    explicit                    value_expr( T&& val )
-    : m_value( std::forward<T>(val) )
-    {}
-#else
-    explicit                    value_expr( T const& val )
-    : m_value( val )
-    {}
-#endif
-
-    // Specific expression interface
-    T const&                    value() const
-    {
-        return m_value;
-    }
-    void                        report( std::ostream& ostr ) const
-    {
-        ostr << tt_detail::print_helper( m_value );
-    }
-
-    // Mutating operators
-#define ADD_OP_SUPPORT( OPER, ID, _ )   \
-    template<typename U>                \
-    value_expr<T>&                      \
-    operator OPER( U const& rhs )       \
-    {                                   \
-        m_value OPER rhs;               \
-                                        \
-        return *this;                   \
-    }                                   \
-/**/
-
-    BOOST_TEST_FOR_EACH_MUT_OP( ADD_OP_SUPPORT )
-#undef ADD_OP_SUPPORT
-
-    // expression interface
-    assertion_result            evaluate( bool no_message = false ) const
-    {
-        assertion_result res( value() );
-        if( no_message || res )
-            return res;
-
-        format_message( res.message(), value() );
-
-        return tt_detail::format_assertion_result( "", res.message().str() );
-    }
-
-private:
-    template<typename U>
-    static void format_message( wrap_stringstream& ostr, U const& v )   { ostr << "[(bool)" << v << " is false]"; }
-    static void format_message( wrap_stringstream& /*ostr*/, bool /*v*/ )       {}
-    static void format_message( wrap_stringstream& /*ostr*/, assertion_result const& /*v*/ ) {}
-
-    // Data members
-    T                           m_value;
-};
-
-// ************************************************************************** //
-// **************            assertion::binary_expr            ************** //
-// ************************************************************************** //
-// binary expression
-
-template<typename LExpr, typename Rhs, typename OP>
-class binary_expr : public expression_base<binary_expr<LExpr,Rhs,OP>,typename OP::result_type> {
-public:
-    // Public types
-    typedef typename OP::result_type result_type;
-
-    // Constructor
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    binary_expr( binary_expr&& be )
-    : m_lhs( std::forward<LExpr>(be.m_lhs) )
-    , m_rhs( std::forward<Rhs>(be.m_rhs) )
-    {}
-    binary_expr( LExpr&& lhs, Rhs&& rhs )
-    : m_lhs( std::forward<LExpr>(lhs) )
-    , m_rhs( std::forward<Rhs>(rhs) )
-    {}
-#else
-    binary_expr( LExpr const& lhs, Rhs const& rhs )
-    : m_lhs( lhs )
-    , m_rhs( rhs )
-    {}
-#endif
-
-    // Specific expression interface
-    result_type                 value() const
-    {
-        return OP::eval( m_lhs.value(), m_rhs );
-    }
-    void                        report( std::ostream& ostr ) const
-    {
-        return OP::report( ostr, m_lhs, m_rhs );
-    }
-
-    assertion_result            evaluate( bool no_message = false ) const
-    {
-        assertion_result const expr_res( value() );
-        if( no_message || expr_res )
-            return expr_res;
-
-        wrap_stringstream buff;
-        report( buff.stream() );
-
-        return tt_detail::format_assertion_result( buff.stream().str(), expr_res.message() );
-    }
-
-    // To support custom manipulators
-    LExpr const&                lhs() const     { return m_lhs; }
-    Rhs const&                  rhs() const     { return m_rhs; }
-private:
-    // Data members
-    LExpr                       m_lhs;
-    Rhs                         m_rhs;
-};
-
-// ************************************************************************** //
-// **************               assertion::seed                ************** //
-// ************************************************************************** //
-// seed added ot the input expression to form an assertion expression
-
-class seed {
-public:
-    // ->* is highest precedence left to right operator
-    template<typename T>
-    value_expr<T>
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    operator->*( T&& v ) const
-    {
-        return value_expr<T>( std::forward<T>( v ) );
-    }
-#else
-    operator->*( T const& v )  const
-    {
-        return value_expr<T>( v );
-    }
-#endif
-};
-
-#undef BOOST_TEST_FOR_EACH_CONST_OP
-
-} // namespace assertion
-} // namespace test_tools
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TOOLS_ASSERTION_HPP_100911GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/assertion_result.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/assertion_result.hpp
deleted file mode 100644
index 85eea741f74..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/assertion_result.hpp
+++ /dev/null
@@ -1,90 +0,0 @@
-//  (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
-/// Enhanced result for test predicate that include message explaining failure
-// ***************************************************************************
-
-#ifndef BOOST_TEST_PREDICATE_RESULT_HPP_012705GER
-#define BOOST_TEST_PREDICATE_RESULT_HPP_012705GER
-
-// Boost.Test
-#include <boost/test/utils/class_properties.hpp>
-#include <boost/test/utils/wrap_stringstream.hpp>
-#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
-
-// Boost
-#include <boost/shared_ptr.hpp>
-#include <boost/detail/workaround.hpp>
-
-// STL
-#include <cstddef>          // for std::size_t
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace test_tools {
-
-// ************************************************************************** //
-// **************                assertion_result              ************** //
-// ************************************************************************** //
-
-//!@brief Type used for storing the result of an assertion.
-class BOOST_TEST_DECL assertion_result {
-
-    //!@internal
-    typedef unit_test::const_string      const_string;
-
-    //!@internal
-    struct dummy { void nonnull() {} };
-
-    //!@internal
-    typedef void (dummy::*safe_bool)();
-
-public:
-    // Constructor
-    assertion_result( bool pv_ )
-    : p_predicate_value( pv_ )
-    {}
-
-    template<typename BoolConvertable>
-    assertion_result( BoolConvertable const& pv_ ) : p_predicate_value( !!pv_ ) {}
-
-    // Access methods
-    bool                operator!() const           { return !p_predicate_value; }
-    void                operator=( bool pv_ )       { p_predicate_value.value = pv_; }
-    operator            safe_bool() const           { return !!p_predicate_value ? &dummy::nonnull : 0; }
-
-    // Public properties
-    BOOST_READONLY_PROPERTY( bool, (assertion_result) ) p_predicate_value;
-
-    // Access methods
-    bool                has_empty_message() const   { return !m_message; }
-    wrap_stringstream&  message()
-    {
-        if( !m_message )
-            m_message.reset( new wrap_stringstream );
-
-        return *m_message;
-    }
-    const_string        message() const                   { return !m_message ? const_string() : const_string( m_message->str() ); }
-
-private:
-    // Data members
-    shared_ptr<wrap_stringstream> m_message;
-};
-
-typedef assertion_result predicate_result;
-
-} // namespace test_tools
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_PREDICATE_RESULT_HPP_012705GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/collection_comparison_op.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/collection_comparison_op.hpp
deleted file mode 100644
index 9d5a7d8f7bb..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/collection_comparison_op.hpp
+++ /dev/null
@@ -1,378 +0,0 @@
-//  (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
-//!@brief Collection comparison with enhanced reporting
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TOOLS_COLLECTION_COMPARISON_OP_HPP_050815GER
-#define BOOST_TEST_TOOLS_COLLECTION_COMPARISON_OP_HPP_050815GER
-
-// Boost.Test
-#include <boost/test/tools/assertion.hpp>
-
-#include <boost/test/utils/is_forward_iterable.hpp>
-
-// Boost
-#include <boost/mpl/bool.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/decay.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace test_tools {
-namespace assertion {
-
-// ************************************************************************** //
-// ************* selectors for specialized comparizon routines ************** //
-// ************************************************************************** //
-
-template<typename T>
-struct specialized_compare : public mpl::false_ {};
-
-#define BOOST_TEST_SPECIALIZED_COLLECTION_COMPARE(Col)          \
-namespace boost { namespace test_tools { namespace assertion {  \
-template<>                                                      \
-struct specialized_compare<Col> : public mpl::true_ {};         \
-}}}                                                             \
-/**/
-
-// ************************************************************************** //
-// **************            lexicographic_compare             ************** //
-// ************************************************************************** //
-
-namespace op {
-
-template <typename OP, bool can_be_equal, bool prefer_shorter,
-          typename Lhs, typename Rhs>
-inline assertion_result
-lexicographic_compare( Lhs const& lhs, Rhs const& rhs )
-{
-    assertion_result ar( true );
-
-    typename Lhs::const_iterator first1 = lhs.begin();
-    typename Rhs::const_iterator first2 = rhs.begin();
-    typename Lhs::const_iterator last1  = lhs.end();
-    typename Rhs::const_iterator last2  = rhs.end();
-    std::size_t                  pos    = 0;
-
-    for( ; (first1 != last1) && (first2 != last2); ++first1, ++first2, ++pos ) {
-        assertion_result const& element_ar = OP::eval(*first1, *first2);
-        if( !can_be_equal && element_ar )
-            return ar; // a < b
-
-        assertion_result const& reverse_ar = OP::eval(*first2, *first1);
-        if( element_ar && !reverse_ar )
-            return ar; // a<=b and !(b<=a) => a < b => return true
-
-        if( element_ar || !reverse_ar )
-            continue; // (a<=b and b<=a) or (!(a<b) and !(b<a)) => a == b => keep looking
-
-        // !(a<=b) and b<=a => b < a => return false
-        ar = false;
-        ar.message() << "\nFailure at position " << pos << ": "
-                     << tt_detail::print_helper(*first1)
-                     << OP::revert()
-                     << tt_detail::print_helper(*first2)
-                     << ". " << element_ar.message();
-        return ar;
-    }
-
-
-    if( first1 != last1 ) {
-        if( prefer_shorter ) {
-            ar = false;
-            ar.message() << "\nFirst collection has extra trailing elements.";
-        }
-    }
-    else if( first2 != last2 ) {
-        if( !prefer_shorter ) {
-            ar = false;
-            ar.message() << "\nSecond collection has extra trailing elements.";
-        }
-    }
-    else if( !can_be_equal ) {
-        ar = false;
-        ar.message() << "\nCollections appear to be equal.";
-    }
-
-    return ar;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               equality_compare               ************** //
-// ************************************************************************** //
-
-template <typename OP, typename Lhs, typename Rhs>
-inline assertion_result
-element_compare( Lhs const& lhs, Rhs const& rhs )
-{
-    assertion_result ar( true );
-
-    if( lhs.size() != rhs.size() ) {
-        ar = false;
-        ar.message() << "\nCollections size mismatch: " << lhs.size() << " != " << rhs.size();
-        return ar;
-    }
-
-    typename Lhs::const_iterator left  = lhs.begin();
-    typename Rhs::const_iterator right = rhs.begin();
-    std::size_t                  pos   = 0;
-
-    for( ; pos < lhs.size(); ++left, ++right, ++pos ) {
-        assertion_result const element_ar = OP::eval( *left, *right );
-        if( element_ar )
-            continue;
-
-        ar = false;
-        ar.message() << "\nMismatch at position " << pos << ": "
-                     << tt_detail::print_helper(*left)
-                     << OP::revert()
-                     << tt_detail::print_helper(*right)
-                     << ". " << element_ar.message();
-    }
-
-    return ar;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************             non_equality_compare             ************** //
-// ************************************************************************** //
-
-template <typename OP, typename Lhs, typename Rhs>
-inline assertion_result
-non_equality_compare( Lhs const& lhs, Rhs const& rhs )
-{
-    assertion_result ar( true );
-
-    if( lhs.size() != rhs.size() )
-        return ar;
-
-    typename Lhs::const_iterator left  = lhs.begin();
-    typename Rhs::const_iterator right = rhs.begin();
-    typename Lhs::const_iterator end   = lhs.end();
-
-    for( ; left != end; ++left, ++right ) {
-        if( OP::eval( *left, *right ) )
-            return ar;
-    }
-
-    ar = false;
-    ar.message() << "\nCollections appear to be equal";
-
-    return ar;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                   cctraits                   ************** //
-// ************************************************************************** //
-// set of collection comparison traits per comparison OP
-
-template<typename OP>
-struct cctraits;
-
-template<typename Lhs, typename Rhs>
-struct cctraits<op::EQ<Lhs, Rhs> > {
-    typedef specialized_compare<Lhs> is_specialized;
-};
-
-template<typename Lhs, typename Rhs>
-struct cctraits<op::NE<Lhs, Rhs> > {
-    typedef specialized_compare<Lhs> is_specialized;
-};
-
-template<typename Lhs, typename Rhs>
-struct cctraits<op::LT<Lhs, Rhs> > {
-    static const bool can_be_equal = false;
-    static const bool prefer_short = true;
-
-    typedef specialized_compare<Lhs> is_specialized;
-};
-
-template<typename Lhs, typename Rhs>
-struct cctraits<op::LE<Lhs, Rhs> > {
-    static const bool can_be_equal = true;
-    static const bool prefer_short = true;
-
-    typedef specialized_compare<Lhs> is_specialized;
-};
-
-template<typename Lhs, typename Rhs>
-struct cctraits<op::GT<Lhs, Rhs> > {
-    static const bool can_be_equal = false;
-    static const bool prefer_short = false;
-
-    typedef specialized_compare<Lhs> is_specialized;
-};
-
-template<typename Lhs, typename Rhs>
-struct cctraits<op::GE<Lhs, Rhs> > {
-    static const bool can_be_equal = true;
-    static const bool prefer_short = false;
-
-    typedef specialized_compare<Lhs> is_specialized;
-};
-
-// ************************************************************************** //
-// **************              compare_collections             ************** //
-// ************************************************************************** //
-// Overloaded set of functions dispatching to specific implementation of comparison
-
-template <typename Lhs, typename Rhs, typename L, typename R>
-inline assertion_result
-compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::EQ<L, R> >*, mpl::true_ )
-{
-    return assertion::op::element_compare<op::EQ<L, R> >( lhs, rhs );
-}
-
-//____________________________________________________________________________//
-
-template <typename Lhs, typename Rhs, typename L, typename R>
-inline assertion_result
-compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::EQ<L, R> >*, mpl::false_ )
-{
-    return lhs == rhs;
-}
-
-//____________________________________________________________________________//
-
-template <typename Lhs, typename Rhs, typename L, typename R>
-inline assertion_result
-compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::NE<L, R> >*, mpl::true_ )
-{
-    return assertion::op::non_equality_compare<op::NE<L, R> >( lhs, rhs );
-}
-
-//____________________________________________________________________________//
-
-template <typename Lhs, typename Rhs, typename L, typename R>
-inline assertion_result
-compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::NE<L, R> >*, mpl::false_ )
-{
-    return lhs != rhs;
-}
-
-//____________________________________________________________________________//
-
-template <typename OP, typename Lhs, typename Rhs>
-inline assertion_result
-lexicographic_compare( Lhs const& lhs, Rhs const& rhs )
-{
-    return assertion::op::lexicographic_compare<OP, cctraits<OP>::can_be_equal, cctraits<OP>::prefer_short>( lhs, rhs );
-}
-
-//____________________________________________________________________________//
-
-template <typename Lhs, typename Rhs, typename OP>
-inline assertion_result
-compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<OP>*, mpl::true_ )
-{
-    return lexicographic_compare<OP>( lhs, rhs );
-}
-
-//____________________________________________________________________________//
-
-template <typename Lhs, typename Rhs, typename L, typename R>
-inline assertion_result
-compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::LT<L, R> >*, mpl::false_ )
-{
-    return lhs < rhs;
-}
-
-//____________________________________________________________________________//
-
-template <typename Lhs, typename Rhs, typename L, typename R>
-inline assertion_result
-compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::LE<L, R> >*, mpl::false_ )
-{
-    return lhs <= rhs;
-}
-
-//____________________________________________________________________________//
-
-template <typename Lhs, typename Rhs, typename L, typename R>
-inline assertion_result
-compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::GT<L, R> >*, mpl::false_ )
-{
-    return lhs > rhs;
-}
-
-//____________________________________________________________________________//
-
-template <typename Lhs, typename Rhs, typename L, typename R>
-inline assertion_result
-compare_collections( Lhs const& lhs, Rhs const& rhs, boost::type<op::GE<L, R> >*, mpl::false_ )
-{
-    return lhs >= rhs;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// ********* specialization of comparison operators for collections ********* //
-// ************************************************************************** //
-
-#define DEFINE_COLLECTION_COMPARISON( oper, name, rev )             \
-template<typename Lhs,typename Rhs>                                 \
-struct name<Lhs,Rhs,typename boost::enable_if_c<                    \
-    unit_test::is_forward_iterable<Lhs>::value &&                   \
-    unit_test::is_forward_iterable<Rhs>::value>::type> {            \
-public:                                                             \
-    typedef assertion_result result_type;                           \
-                                                                    \
-    typedef name<Lhs, Rhs> OP;                                      \
-    typedef typename                                                \
-        mpl::if_c<is_same<typename decay<Lhs>::type,                \
-                          typename decay<Rhs>::type>::value,        \
-                  typename cctraits<OP>::is_specialized,            \
-                  mpl::false_>::type is_specialized;                \
-                                                                    \
-    typedef name<typename Lhs::value_type,                          \
-                 typename Rhs::value_type> elem_op;                 \
-                                                                    \
-    static assertion_result                                         \
-    eval( Lhs const& lhs, Rhs const& rhs)                           \
-    {                                                               \
-        return assertion::op::compare_collections( lhs, rhs,        \
-            (boost::type<elem_op>*)0,                               \
-            is_specialized() );                                     \
-    }                                                               \
-                                                                    \
-    template<typename PrevExprType>                                 \
-    static void                                                     \
-    report( std::ostream&,                                          \
-            PrevExprType const&,                                    \
-            Rhs const& ) {}                                         \
-                                                                    \
-    static char const* revert()                                     \
-    { return " " #rev " "; }                                        \
-                                                                    \
-};                                                                  \
-/**/
-
-BOOST_TEST_FOR_EACH_COMP_OP( DEFINE_COLLECTION_COMPARISON )
-#undef DEFINE_COLLECTION_COMPARISON
-
-//____________________________________________________________________________//
-
-} // namespace op
-} // namespace assertion
-} // namespace test_tools
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TOOLS_COLLECTION_COMPARISON_OP_HPP_050815GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/context.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/context.hpp
deleted file mode 100644
index 71650065ef4..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/context.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//  (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: 74248 $
-//
-//  Description : test tools context interfaces
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TOOLS_CONTEXT_HPP_111712GER
-#define BOOST_TEST_TOOLS_CONTEXT_HPP_111712GER
-
-// Boost.Test
-#include <boost/test/utils/lazy_ostream.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace test_tools {
-namespace tt_detail {
-
-// ************************************************************************** //
-// **************                 context_frame                ************** //
-// ************************************************************************** //
-
-struct BOOST_TEST_DECL context_frame {
-    explicit    context_frame( ::boost::unit_test::lazy_ostream const& context_descr );
-    ~context_frame();
-
-    operator    bool();
-
-private:
-    // Data members
-    int         m_frame_id;
-};
-
-//____________________________________________________________________________//
-
-#define BOOST_TEST_INFO( context_descr )                                                        \
-    ::boost::unit_test::framework::add_context( BOOST_TEST_LAZY_MSG( context_descr ) , false )  \
-/**/
-
-//____________________________________________________________________________//
-
-#define BOOST_TEST_CONTEXT( context_descr )                                                     \
-    if( ::boost::test_tools::tt_detail::context_frame BOOST_JOIN( context_frame_, __LINE__ ) =  \
-        ::boost::test_tools::tt_detail::context_frame( BOOST_TEST_LAZY_MSG( context_descr ) ) ) \
-/**/
-
-//____________________________________________________________________________//
-
-} // namespace tt_detail
-} // namespace test_tools
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TOOLS_CONTEXT_HPP_111712GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/cstring_comparison_op.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/cstring_comparison_op.hpp
deleted file mode 100644
index 0aaf997b5da..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/cstring_comparison_op.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-//  (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
-//!@brief C string comparison with enhanced reporting
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TOOLS_CSTRING_COMPARISON_OP_HPP_050815GER
-#define BOOST_TEST_TOOLS_CSTRING_COMPARISON_OP_HPP_050815GER
-
-// Boost.Test
-#include <boost/test/tools/assertion.hpp>
-
-#include <boost/test/utils/is_cstring.hpp>
-#include <boost/test/utils/basic_cstring/compare.hpp>
-
-// Boost
-#include <boost/utility/enable_if.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace test_tools {
-namespace assertion {
-namespace op {
-
-
-
-// ************************************************************************** //
-// **************               string_compare                 ************** //
-// ************************************************************************** //
-
-#define DEFINE_CSTRING_COMPARISON( oper, name, rev )                \
-template<typename Lhs,typename Rhs>                                 \
-struct name<Lhs,Rhs,typename boost::enable_if_c<                    \
-    unit_test::is_cstring<Lhs>::value &&                            \
-    unit_test::is_cstring<Rhs>::value>::type> {                     \
-    typedef typename boost::add_const<                              \
-                typename remove_pointer<                            \
-                    typename decay<Lhs>::type>::type>::type         \
-        lhs_char_type;                                              \
-    typedef typename boost::add_const<                              \
-                typename remove_pointer<                            \
-                    typename decay<Rhs>::type>::type>::type         \
-        rhs_char_type;                                              \
-public:                                                             \
-    typedef assertion_result result_type;                           \
-                                                                    \
-    static bool                                                     \
-    eval( Lhs const& lhs, Rhs const& rhs)                           \
-    {                                                               \
-        return unit_test::basic_cstring<lhs_char_type>(lhs) oper    \
-               unit_test::basic_cstring<rhs_char_type>(rhs);        \
-    }                                                               \
-                                                                    \
-    template<typename PrevExprType>                                 \
-    static void                                                     \
-    report( std::ostream&       ostr,                               \
-            PrevExprType const& lhs,                                \
-            Rhs const&          rhs)                                \
-    {                                                               \
-        lhs.report( ostr );                                         \
-        ostr << revert()                                            \
-             << tt_detail::print_helper( rhs );                     \
-    }                                                               \
-                                                                    \
-    static char const* revert()                                     \
-    { return " " #rev " "; }                                        \
-};                                                                  \
-/**/
-
-BOOST_TEST_FOR_EACH_COMP_OP( DEFINE_CSTRING_COMPARISON )
-#undef DEFINE_CSTRING_COMPARISON
-
-//____________________________________________________________________________//
-
-} // namespace op
-} // namespace assertion
-} // namespace test_tools
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TOOLS_CSTRING_COMPARISON_OP_HPP_050815GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/detail/bitwise_manip.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/detail/bitwise_manip.hpp
deleted file mode 100644
index f8c9685c107..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/detail/bitwise_manip.hpp
+++ /dev/null
@@ -1,123 +0,0 @@
-//  (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
-//! Bitwise comparison manipulator implementation
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TOOLS_DETAIL_BITWISE_MANIP_HPP_012705GER
-#define BOOST_TEST_TOOLS_DETAIL_BITWISE_MANIP_HPP_012705GER
-
-// Boost Test
-#include <boost/test/tools/detail/fwd.hpp>
-#include <boost/test/tools/detail/indirections.hpp>
-
-#include <boost/test/tools/assertion_result.hpp>
-#include <boost/test/tools/assertion.hpp>
-
-// STL
-#include <climits>          // for CHAR_BIT
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace test_tools {
-
-// ************************************************************************** //
-// **************        bitwise comparison manipulator        ************** //
-// ************************************************************************** //
-
-//! Bitwise comparison manipulator
-struct bitwise {};
-
-//____________________________________________________________________________//
-
-inline int
-operator<<( unit_test::lazy_ostream const&, bitwise )   { return 0; }
-
-//____________________________________________________________________________//
-
-namespace tt_detail {
-
-/*!@brief Bitwise comparison of two operands
- *
- * This class constructs an @ref assertion_result that contains precise bit comparison information.
- * In particular the location of the mismatches (if any) are printed in the assertion result. 
- */
-template<typename Lhs, typename Rhs, typename E>
-inline assertion_result
-bitwise_compare(Lhs const& lhs, Rhs const& rhs, E const& expr )
-{
-    assertion_result    pr( true );
-
-    std::size_t left_bit_size  = sizeof(Lhs)*CHAR_BIT;
-    std::size_t right_bit_size = sizeof(Rhs)*CHAR_BIT;
-
-    static Lhs const leftOne( 1 );
-    static Rhs const rightOne( 1 );
-
-    std::size_t total_bits = left_bit_size < right_bit_size ? left_bit_size : right_bit_size;
-
-    for( std::size_t counter = 0; counter < total_bits; ++counter ) {
-        if( (lhs & ( leftOne << counter )) != (rhs & (rightOne << counter)) ) {
-            if( pr ) {
-                pr.message() << " [";
-                expr.report( pr.message().stream() );
-                pr.message() << "]. Bitwise comparison failed";
-                pr = false;
-            }
-            pr.message() << "\nMismatch at position " << counter;
-        }
-    }
-
-    if( left_bit_size != right_bit_size ) {
-        if( pr ) {
-            pr.message() << " [";
-            expr.report( pr.message().stream() );
-            pr.message() << "]. Bitwise comparison failed";
-            pr = false;
-        }
-        pr.message() << "\nOperands bit sizes mismatch: " << left_bit_size << " != " << right_bit_size;
-    }
-
-    return pr;
-}
-
-//____________________________________________________________________________//
-
-//! Returns an assertion_result using the bitwise comparison out of an expression
-//!
-//! This is used as a modifer of the normal operator<< on expressions to use the
-//! bitwise comparison. 
-//!
-//! @note Available only for compilers supporting the @c auto declaration. 
-template<typename T1, typename T2, typename T3, typename T4>
-inline assertion_result
-operator<<(assertion_evaluate_t<assertion::binary_expr<T1,T2,assertion::op::EQ<T3,T4> > > const& ae, bitwise )
-{
-    return bitwise_compare( ae.m_e.lhs().value(), ae.m_e.rhs(), ae.m_e );
-}
-
-//____________________________________________________________________________//
-
-inline check_type
-operator<<( assertion_type const& , bitwise )
-{
-    return CHECK_BUILT_ASSERTION;
-}
-
-//____________________________________________________________________________//
-
-} // namespace tt_detail
-} // namespace test_tools
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TOOLS_DETAIL_BITWISE_MANIP_HPP_012705GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/detail/expression_holder.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/detail/expression_holder.hpp
deleted file mode 100644
index 694a2d5f4ec..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/detail/expression_holder.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-//  (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: 74248 $
-//
-//  Description : toolbox implementation details
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TOOLS_DETAIL_EXPRESSION_HOLDER_HPP_012705GER
-#define BOOST_TEST_TOOLS_DETAIL_EXPRESSION_HOLDER_HPP_012705GER
-
-#ifdef BOOST_NO_CXX11_AUTO_DECLARATIONS
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace test_tools {
-namespace tt_detail {
-
-// ************************************************************************** //
-// **************         tt_detail::expression_holder         ************** //
-// ************************************************************************** //
-
-class expression_holder {
-public:
-    virtual                     ~expression_holder() {}
-    virtual assertion_result    evaluate( bool no_message = false )  const = 0;
-};
-
-//____________________________________________________________________________//
-
-template<typename E>
-class  expression_holder_t: public expression_holder {
-public:
-    explicit                    expression_holder_t( E const& e ) : m_expr( e ) {}
-
-private:
-    virtual assertion_result    evaluate( bool no_message = false )  const { return m_expr.evaluate( no_message ); }
-
-    E                           m_expr;
-};
-
-//____________________________________________________________________________//
-
-template<typename E>
-expression_holder_t<E>
-hold_expression( E const& e )
-{
-    return expression_holder_t<E>( e );
-}
-
-//____________________________________________________________________________//
-
-} // namespace tt_detail
-} // namespace test_tools
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif
-
-#endif // BOOST_TEST_TOOLS_DETAIL_EXPRESSION_HOLDER_HPP_012705GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/detail/fwd.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/detail/fwd.hpp
deleted file mode 100644
index 339ab39eda8..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/detail/fwd.hpp
+++ /dev/null
@@ -1,121 +0,0 @@
-//  (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: 74248 $
-//
-//  Description : toolbox implementation types and forward declarations
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TOOLS_DETAIL_FWD_HPP_012705GER
-#define BOOST_TEST_TOOLS_DETAIL_FWD_HPP_012705GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp>
-
-// STL
-#include <cstddef>          // for std::size_t
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-class lazy_ostream;
-
-} // namespace unit_test
-
-namespace test_tools {
-
-using unit_test::const_string;
-class assertion_result;
-
-//____________________________________________________________________________//
-
-namespace tt_detail {
-
-inline bool dummy_cond() { return false; }
-
-// ************************************************************************** //
-// **************        types of supported assertions         ************** //
-// ************************************************************************** //
-
-//____________________________________________________________________________//
-
-enum check_type {
-    CHECK_PRED,
-    CHECK_MSG,
-    CHECK_EQUAL,
-    CHECK_NE,
-    CHECK_LT,
-    CHECK_LE,
-    CHECK_GT,
-    CHECK_GE,
-    CHECK_CLOSE,
-    CHECK_CLOSE_FRACTION,
-    CHECK_SMALL,
-    CHECK_BITWISE_EQUAL,
-    CHECK_PRED_WITH_ARGS,
-    CHECK_EQUAL_COLL,
-    CHECK_BUILT_ASSERTION
-};
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************        levels of supported assertions        ************** //
-// ************************************************************************** //
-
-enum tool_level {
-    WARN, CHECK, REQUIRE, PASS
-};
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************         Tools offline implementation         ************** //
-// ************************************************************************** //
-
-BOOST_TEST_DECL bool
-report_assertion( assertion_result const& pr, unit_test::lazy_ostream const& assertion_descr,
-                  const_string file_name, std::size_t line_num,
-                  tool_level tl, check_type ct,
-                  std::size_t num_args, ... );
-
-//____________________________________________________________________________//
-
-BOOST_TEST_DECL assertion_result
-format_assertion_result( const_string expr_val, const_string details );
-
-//____________________________________________________________________________//
-
-BOOST_TEST_DECL assertion_result
-format_fpc_report( const_string expr_val, const_string details );
-
-//____________________________________________________________________________//
-
-BOOST_TEST_DECL bool
-is_defined_impl( const_string symbol_name, const_string symbol_value );
-
-//____________________________________________________________________________//
-
-BOOST_TEST_DECL assertion_result
-equal_impl( char const* left, char const* right );
-
-//____________________________________________________________________________//
-
-} // namespace tt_detail
-} // namespace test_tools
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TOOLS_DETAIL_FWD_HPP_012705GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/detail/indirections.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/detail/indirections.hpp
deleted file mode 100644
index 836218d98d8..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/detail/indirections.hpp
+++ /dev/null
@@ -1,94 +0,0 @@
-//  (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: 74248 $
-//
-//  Description : inidiration interfaces to support manipulators and message output
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TOOLS_DETAIL_INDIRECTIONS_HPP_112812GER
-#define BOOST_TEST_TOOLS_DETAIL_INDIRECTIONS_HPP_112812GER
-
-// Boost.Test
-#include <boost/test/tools/detail/fwd.hpp>
-
-#include <boost/test/tools/assertion_result.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace test_tools {
-namespace tt_detail {
-
-// ************************************************************************** //
-// **************        assertion_evaluate indirection        ************** //
-// ************************************************************************** //
-
-template<typename E>
-struct assertion_evaluate_t {
-    assertion_evaluate_t( E const& e ) : m_e( e ) {}
-    operator assertion_result() { return m_e.evaluate( true ); }
-
-    E const& m_e;
-};
-
-//____________________________________________________________________________//
-
-template<typename E>
-inline assertion_evaluate_t<E>
-assertion_evaluate( E const& e ) { return assertion_evaluate_t<E>( e ); }
-
-//____________________________________________________________________________//
-
-template<typename E, typename T>
-inline assertion_evaluate_t<E>
-operator<<( assertion_evaluate_t<E> const& ae, T const& ) { return ae; }
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************          assertion_text indirection          ************** //
-// ************************************************************************** //
-
-template<typename T>
-inline unit_test::lazy_ostream const&
-assertion_text( unit_test::lazy_ostream const& /*et*/, T const& m ) { return m; }
-
-//____________________________________________________________________________//
-
-inline unit_test::lazy_ostream const&
-assertion_text( unit_test::lazy_ostream const& et, int ) { return et; }
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************        assertion_evaluate indirection        ************** //
-// ************************************************************************** //
-
-struct assertion_type {
-    operator check_type() { return CHECK_MSG; }
-};
-
-//____________________________________________________________________________//
-
-template<typename T>
-inline assertion_type
-operator<<( assertion_type const& at, T const& ) { return at; }
-
-//____________________________________________________________________________//
-
-} // namespace tt_detail
-} // namespace test_tools
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TOOLS_DETAIL_INDIRECTIONS_HPP_112812GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/detail/it_pair.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/detail/it_pair.hpp
deleted file mode 100644
index 4352fd464ff..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/detail/it_pair.hpp
+++ /dev/null
@@ -1,74 +0,0 @@
-//  (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: 74248 $
-//
-//  Description : support for backward compatible collection comparison interface
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TOOLS_DETAIL_IT_PAIR_HPP_112812GER
-#define BOOST_TEST_TOOLS_DETAIL_IT_PAIR_HPP_112812GER
-
-#ifdef BOOST_TEST_NO_OLD_TOOLS
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace test_tools {
-namespace tt_detail {
-
-// ************************************************************************** //
-// **************       backward compatibility support         ************** //
-// ************************************************************************** //
-
-template<typename It>
-struct it_pair {
-    typedef It const_iterator;
-    typedef typename std::iterator_traits<It>::value_type value_type;
-
-    it_pair( It const& b, It const& e ) : m_begin( b ), m_size( 0 )
-    {
-        It tmp = b;
-        while( tmp != e ) { ++m_size; ++tmp; }
-    }
-
-    It      begin() const   { return m_begin; }
-    It      end() const     { return m_begin + m_size; }
-    size_t  size() const    { return m_size; }
-
-private:
-    It      m_begin;
-    size_t  m_size;
-};
-
-//____________________________________________________________________________//
-
-template<typename It>
-it_pair<It>
-make_it_pair( It const& b, It const& e ) { return it_pair<It>( b, e ); }
-
-//____________________________________________________________________________//
-
-template<typename T>
-it_pair<T const*>
-make_it_pair( T const* b, T const* e ) { return it_pair<T const*>( b, e ); }
-
-//____________________________________________________________________________//
-
-} // namespace tt_detail
-} // namespace test_tools
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_NO_OLD_TOOLS
-
-#endif // BOOST_TEST_TOOLS_DETAIL_IT_PAIR_HPP_112812GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/detail/lexicographic_manip.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/detail/lexicographic_manip.hpp
deleted file mode 100644
index f6ffff7a34c..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/detail/lexicographic_manip.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-//  (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
-//! Lexicographic comparison manipulator implementation
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TOOLS_DETAIL_LEXICOGRAPHIC_MANIP_HPP_050815GER
-#define BOOST_TEST_TOOLS_DETAIL_LEXICOGRAPHIC_MANIP_HPP_050815GER
-
-// Boost Test
-#include <boost/test/tools/detail/fwd.hpp>
-#include <boost/test/tools/detail/indirections.hpp>
-
-#include <boost/test/tools/assertion.hpp>
-#include <boost/test/tools/collection_comparison_op.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace test_tools {
-
-// ************************************************************************** //
-// **************      per element comparison manipulator      ************** //
-// ************************************************************************** //
-
-//! Lexicographic comparison manipulator, for containers
-struct lexicographic {};
-
-//____________________________________________________________________________//
-
-inline int
-operator<<( unit_test::lazy_ostream const&, lexicographic )   { return 0; }
-
-//____________________________________________________________________________//
-
-namespace tt_detail {
-
-template<typename T1, typename T2, typename OP>
-inline assertion_result
-operator<<(assertion_evaluate_t<assertion::binary_expr<T1,T2,OP> > const& ae, lexicographic )
-{
-    typedef typename OP::elem_op elem_op;
-    return assertion::op::lexicographic_compare<elem_op>( ae.m_e.lhs().value(), ae.m_e.rhs() );
-}
-
-//____________________________________________________________________________//
-
-inline check_type
-operator<<( assertion_type const&, lexicographic )
-{
-    return CHECK_BUILT_ASSERTION;
-}
-
-//____________________________________________________________________________//
-
-} // namespace tt_detail
-} // namespace test_tools
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TOOLS_DETAIL_LEXICOGRAPHIC_MANIP_HPP_050815GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/detail/per_element_manip.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/detail/per_element_manip.hpp
deleted file mode 100644
index 4a9aebbaaac..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/detail/per_element_manip.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-//  (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
-//! Per element comparison manipulator implementation
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TOOLS_DETAIL_PER_ELEMENT_MANIP_HPP_050815GER
-#define BOOST_TEST_TOOLS_DETAIL_PER_ELEMENT_MANIP_HPP_050815GER
-
-// Boost Test
-#include <boost/test/tools/detail/fwd.hpp>
-#include <boost/test/tools/detail/indirections.hpp>
-
-#include <boost/test/tools/assertion.hpp>
-#include <boost/test/tools/collection_comparison_op.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace test_tools {
-
-// ************************************************************************** //
-// **************      per element comparison manipulator      ************** //
-// ************************************************************************** //
-
-//! Per element comparison manipulator, for containers
-struct per_element {};
-
-//____________________________________________________________________________//
-
-inline int
-operator<<( unit_test::lazy_ostream const&, per_element )   { return 0; }
-
-//____________________________________________________________________________//
-
-namespace tt_detail {
-
-template<typename T1, typename T2, typename OP>
-inline assertion_result
-operator<<(assertion_evaluate_t<assertion::binary_expr<T1,T2,OP> > const& ae, per_element )
-{
-    typedef typename OP::elem_op elem_op;
-    return assertion::op::element_compare<elem_op>( ae.m_e.lhs().value(), ae.m_e.rhs() );
-}
-
-//____________________________________________________________________________//
-
-inline check_type
-operator<<( assertion_type const&, per_element )
-{
-    return CHECK_BUILT_ASSERTION;
-}
-
-//____________________________________________________________________________//
-
-} // namespace tt_detail
-} // namespace test_tools
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TOOLS_DETAIL_PER_ELEMENT_MANIP_HPP_050815GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/detail/print_helper.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/detail/print_helper.hpp
deleted file mode 100644
index 39ab707f364..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/detail/print_helper.hpp
+++ /dev/null
@@ -1,205 +0,0 @@
-//  (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: 74248 $
-//
-//  Description : defines level of indiration facilitating workarounds for non printable types
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TOOLS_IMPL_COMMON_HPP_012705GER
-#define BOOST_TEST_TOOLS_IMPL_COMMON_HPP_012705GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/workaround.hpp>
-
-// Boost
-#include <boost/mpl/or.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_array.hpp>
-#include <boost/type_traits/is_function.hpp>
-#include <boost/type_traits/is_abstract.hpp>
-#include <boost/type_traits/has_left_shift.hpp>
-
-#include <limits>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace test_tools {
-namespace tt_detail {
-
-// ************************************************************************** //
-// **************                print_log_value               ************** //
-// ************************************************************************** //
-
-template<typename T>
-struct print_log_value {
-    BOOST_STATIC_ASSERT_MSG( (boost::has_left_shift<std::ostream,T>::value),
-                             "Type has to implement operator<< to be printable");
-
-    void    operator()( std::ostream& ostr, T const& t )
-    {
-        typedef typename mpl::or_<is_array<T>,is_function<T>,is_abstract<T> >::type cant_use_nl;
-
-        std::streamsize old_precision = set_precision( ostr, cant_use_nl() );
-
-        ostr << t;
-
-        if( old_precision != (std::streamsize)-1 )
-            ostr.precision( old_precision );
-    }
-
-    std::streamsize set_precision( std::ostream& ostr, mpl::false_ )
-    {
-        if( std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::radix == 2 )
-            return ostr.precision( 2 + std::numeric_limits<T>::digits * 301/1000 );
-        else if ( std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::radix == 10 ) {
-#ifdef BOOST_NO_CXX11_NUMERIC_LIMITS
-            // (was BOOST_NO_NUMERIC_LIMITS_LOWEST but now deprecated).
-            // No support for std::numeric_limits<double>::max_digits10,
-            // so guess that a couple of guard digits more than digits10 will display any difference.
-            return ostr.precision( 2 + std::numeric_limits<T>::digits10 );
-#else
-            // std::numeric_limits<double>::max_digits10; IS supported.
-            // Any noisy or guard digits needed to display any difference are included in max_digits10.
-            return ostr.precision( std::numeric_limits<T>::max_digits10 );
-#endif
-        }
-        // else if T is not specialized for std::numeric_limits<>,
-        // then will just get the default precision of 6 digits.
-        return (std::streamsize)-1;
-    }
-
-    std::streamsize set_precision( std::ostream&, mpl::true_ ) { return (std::streamsize)-1; }
-};
-
-//____________________________________________________________________________//
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-template<typename T, std::size_t N >
-struct print_log_value< T[N] > {
-    void    operator()( std::ostream& ostr, T const* t )
-    {
-        ostr << t;
-    }
-};
-#endif
-
-//____________________________________________________________________________//
-
-template<>
-struct BOOST_TEST_DECL print_log_value<bool> {
-    void    operator()( std::ostream& ostr, bool t )
-    {
-         ostr << std::boolalpha << t;
-    }
-};
-
-//____________________________________________________________________________//
-
-template<>
-struct BOOST_TEST_DECL print_log_value<char> {
-    void    operator()( std::ostream& ostr, char t );
-};
-
-//____________________________________________________________________________//
-
-template<>
-struct BOOST_TEST_DECL print_log_value<unsigned char> {
-    void    operator()( std::ostream& ostr, unsigned char t );
-};
-
-//____________________________________________________________________________//
-
-template<>
-struct BOOST_TEST_DECL print_log_value<char const*> {
-    void    operator()( std::ostream& ostr, char const* t );
-};
-
-//____________________________________________________________________________//
-
-template<>
-struct BOOST_TEST_DECL print_log_value<wchar_t const*> {
-    void    operator()( std::ostream& ostr, wchar_t const* t );
-};
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                 print_helper                 ************** //
-// ************************************************************************** //
-// Adds level of indirection to the output operation, allowing us to customize
-// it for types that do not support operator << directly or for any other reason
-
-template<typename T>
-struct print_helper_t {
-    explicit    print_helper_t( T const& t ) : m_t( t ) {}
-
-    T const&    m_t;
-};
-
-//____________________________________________________________________________//
-
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-// Borland suffers premature pointer decay passing arrays by reference
-template<typename T, std::size_t N >
-struct print_helper_t< T[N] > {
-    explicit    print_helper_t( T const * t ) : m_t( t ) {}
-
-    T const *   m_t;
-};
-#endif
-
-//____________________________________________________________________________//
-
-template<typename T>
-inline print_helper_t<T>
-print_helper( T const& t )
-{
-    return print_helper_t<T>( t );
-}
-
-//____________________________________________________________________________//
-
-template<typename T>
-inline std::ostream&
-operator<<( std::ostream& ostr, print_helper_t<T> const& ph )
-{
-    print_log_value<T>()( ostr, ph.m_t );
-
-    return ostr;
-}
-
-//____________________________________________________________________________//
-
-} // namespace tt_detail
-
-// ************************************************************************** //
-// **************       BOOST_TEST_DONT_PRINT_LOG_VALUE        ************** //
-// ************************************************************************** //
-
-#define BOOST_TEST_DONT_PRINT_LOG_VALUE( the_type )         \
-namespace boost{ namespace test_tools{ namespace tt_detail{ \
-template<>                                                  \
-struct print_log_value<the_type > {                         \
-    void    operator()( std::ostream&, the_type const& ) {} \
-};                                                          \
-}}}                                                         \
-/**/
-
-} // namespace test_tools
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TOOLS_IMPL_COMMON_HPP_012705GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/detail/tolerance_manip.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/detail/tolerance_manip.hpp
deleted file mode 100644
index e07b0435913..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/detail/tolerance_manip.hpp
+++ /dev/null
@@ -1,130 +0,0 @@
-//  (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
-//! @brief Floating point comparison tolerance manipulators
-//! 
-//! This file defines several manipulators for floating point comparison. These
-//! manipulators are intended to be used with BOOST_TEST.
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TOOLS_DETAIL_TOLERANCE_MANIP_HPP_012705GER
-#define BOOST_TEST_TOOLS_DETAIL_TOLERANCE_MANIP_HPP_012705GER
-
-// Boost Test
-#include <boost/test/tools/detail/fwd.hpp>
-#include <boost/test/tools/detail/indirections.hpp>
-
-#include <boost/test/tools/fpc_tolerance.hpp>
-#include <boost/test/tools/floating_point_comparison.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace test_tools {
-namespace tt_detail {
-
-// ************************************************************************** //
-// **************           fpc tolerance manipulator          ************** //
-// ************************************************************************** //
-
-template<typename FPT>
-struct tolerance_manip {
-    explicit tolerance_manip( FPT const & tol ) : m_value( tol ) {}
-
-    FPT m_value;
-};
-
-//____________________________________________________________________________//
-
-struct tolerance_manip_delay {};
-
-template<typename FPT>
-inline tolerance_manip<FPT>
-operator%( FPT v, tolerance_manip_delay const& )
-{
-    BOOST_STATIC_ASSERT_MSG( (fpc::tolerance_based<FPT>::value), 
-                             "tolerance should be specified using a floating points type" );
-
-    return tolerance_manip<FPT>( FPT(v / 100) );
-}
-
-//____________________________________________________________________________//
-
-template<typename E, typename FPT>
-inline assertion_result
-operator<<(assertion_evaluate_t<E> const& ae, tolerance_manip<FPT> const& tol)
-{
-    local_fpc_tolerance<FPT> lt( tol.m_value );
-
-    return ae.m_e.evaluate();
-}
-
-//____________________________________________________________________________//
-
-template<typename FPT>
-inline int
-operator<<( unit_test::lazy_ostream const&, tolerance_manip<FPT> const& )   { return 0; }
-
-//____________________________________________________________________________//
-
-template<typename FPT>
-inline check_type
-operator<<( assertion_type const& /*at*/, tolerance_manip<FPT> const& )         { return CHECK_BUILT_ASSERTION; }
-
-//____________________________________________________________________________//
-
-} // namespace tt_detail
-
-
-/*! Tolerance manipulator
- *
- * These functions return a manipulator that can be used in conjunction with BOOST_TEST
- * in order to specify the tolerance with which floating point comparisons are made.
- */
-template<typename FPT>
-inline tt_detail::tolerance_manip<FPT>
-tolerance( FPT v )
-{
-    BOOST_STATIC_ASSERT_MSG( (fpc::tolerance_based<FPT>::value), 
-                             "tolerance only for floating points" );
-
-    return tt_detail::tolerance_manip<FPT>( v );
-}
-
-//____________________________________________________________________________//
-
-//! @overload tolerance( FPT v )
-template<typename FPT>
-inline tt_detail::tolerance_manip<FPT>
-tolerance( fpc::percent_tolerance_t<FPT> v )
-{
-    BOOST_STATIC_ASSERT_MSG( (fpc::tolerance_based<FPT>::value), 
-                             "tolerance only for floating points" );
-
-    return tt_detail::tolerance_manip<FPT>( static_cast<FPT>(v.m_value / 100) );
-}
-
-//____________________________________________________________________________//
-
-//! @overload tolerance( FPT v )
-inline tt_detail::tolerance_manip_delay
-tolerance()
-{
-    return tt_detail::tolerance_manip_delay();
-}
-
-//____________________________________________________________________________//
-
-} // namespace test_tools
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TOOLS_DETAIL_TOLERANCE_MANIP_HPP_012705GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/floating_point_comparison.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/floating_point_comparison.hpp
deleted file mode 100644
index d704a41092c..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/floating_point_comparison.hpp
+++ /dev/null
@@ -1,315 +0,0 @@
-//  (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 
-//!@brief algorithms for comparing floating point values
-// ***************************************************************************
-
-#ifndef BOOST_TEST_FLOATING_POINT_COMPARISON_HPP_071894GER
-#define BOOST_TEST_FLOATING_POINT_COMPARISON_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/tools/assertion_result.hpp>
-
-// Boost
-#include <boost/limits.hpp>  // for std::numeric_limits
-#include <boost/static_assert.hpp>
-#include <boost/assert.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/type_traits/is_floating_point.hpp>
-#include <boost/type_traits/is_array.hpp>
-#include <boost/type_traits/conditional.hpp>
-#include <boost/utility/enable_if.hpp>
-
-// STL
-#include <iosfwd>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace math {
-namespace fpc {
-
-// ************************************************************************** //
-// **************              fpc::tolerance_based            ************** //
-// ************************************************************************** //
-
-
-//! @internal
-//! Protects the instanciation of std::numeric_limits from non-supported types (eg. T=array)
-template <typename T, bool enabled>
-struct tolerance_based_delegate;
-
-template <typename T>
-struct tolerance_based_delegate<T, false> : mpl::false_ {};
-
-template <typename T>
-struct tolerance_based_delegate<T, true>
-: mpl::bool_<
-    is_floating_point<T>::value ||
-    (!std::numeric_limits<T>::is_integer && std::numeric_limits<T>::is_specialized && !std::numeric_limits<T>::is_exact)>
-{};
-
-
-/*!@brief Indicates if a type can be compared using a tolerance scheme
- *
- * This is a metafunction that should evaluate to @c mpl::true_ if the type
- * @c T can be compared using a tolerance based method, typically for floating point
- * types.
- *
- * This metafunction can be specialized further to declare user types that are
- * floating point (eg. boost.multiprecision).
- */
-template <typename T>
-struct tolerance_based : tolerance_based_delegate<T, !is_array<T>::value >::type {};
-
-// ************************************************************************** //
-// **************                 fpc::strength                ************** //
-// ************************************************************************** //
-
-//! Method for comparing floating point numbers
-enum strength {
-    FPC_STRONG, //!< "Very close"   - equation 2' in docs, the default
-    FPC_WEAK    //!< "Close enough" - equation 3' in docs.
-};
-
-
-// ************************************************************************** //
-// **************         tolerance presentation types         ************** //
-// ************************************************************************** //
-
-template<typename FPT>
-struct percent_tolerance_t {
-    explicit    percent_tolerance_t( FPT v ) : m_value( v ) {}
-
-    FPT m_value;
-};
-
-//____________________________________________________________________________//
-
-template<typename FPT>
-inline std::ostream& operator<<( std::ostream& out, percent_tolerance_t<FPT> t )
-{
-    return out << t.m_value;
-}
-
-//____________________________________________________________________________//
-
-template<typename FPT>
-inline percent_tolerance_t<FPT>
-percent_tolerance( FPT v )
-{
-    return percent_tolerance_t<FPT>( v );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                    details                   ************** //
-// ************************************************************************** //
-
-namespace fpc_detail {
-
-// FPT is Floating-Point Type: float, double, long double or User-Defined.
-template<typename FPT>
-inline FPT
-fpt_abs( FPT fpv ) 
-{
-    return fpv < static_cast<FPT>(0) ? -fpv : fpv;
-}
-
-//____________________________________________________________________________//
-
-template<typename FPT>
-struct fpt_specialized_limits
-{
-  static FPT    min_value() { return (std::numeric_limits<FPT>::min)(); }
-  static FPT    max_value() { return (std::numeric_limits<FPT>::max)(); }
-};
-
-template<typename FPT>
-struct fpt_non_specialized_limits
-{
-  static FPT    min_value() { return static_cast<FPT>(0); }
-  static FPT    max_value() { return static_cast<FPT>(1000000); } // for our purposes it doesn't really matter what value is returned here
-};
-
-template<typename FPT>
-struct fpt_limits : boost::conditional<std::numeric_limits<FPT>::is_specialized,
-                                       fpt_specialized_limits<FPT>,
-                                       fpt_non_specialized_limits<FPT>
-                                      >::type
-{};
-
-//____________________________________________________________________________//
-
-// both f1 and f2 are unsigned here
-template<typename FPT>
-inline FPT
-safe_fpt_division( FPT f1, FPT f2 )
-{
-    // Avoid overflow.
-    if( (f2 < static_cast<FPT>(1))  && (f1 > f2*fpt_limits<FPT>::max_value()) )
-        return fpt_limits<FPT>::max_value();
-
-    // Avoid underflow.
-    if( (f1 == static_cast<FPT>(0)) ||
-        ((f2 > static_cast<FPT>(1)) && (f1 < f2*fpt_limits<FPT>::min_value())) )
-        return static_cast<FPT>(0);
-
-    return f1/f2;
-}
-
-//____________________________________________________________________________//
-
-template<typename FPT, typename ToleranceType>
-inline FPT
-fraction_tolerance( ToleranceType tolerance )
-{
-  return static_cast<FPT>(tolerance);
-} 
-
-//____________________________________________________________________________//
-
-template<typename FPT2, typename FPT>
-inline FPT2
-fraction_tolerance( percent_tolerance_t<FPT> tolerance )
-{
-    return FPT2(tolerance.m_value)*FPT2(0.01); 
-}
-
-//____________________________________________________________________________//
-
-} // namespace fpc_detail
-
-// ************************************************************************** //
-// **************             close_at_tolerance               ************** //
-// ************************************************************************** //
-
-
-/*!@brief Predicate for comparing floating point numbers
- *
- * This predicate is used to compare floating point numbers. In addition the comparison produces maximum 
- * related differnce, which can be used to generate detailed error message
- * The methods for comparing floating points are detailed in the documentation. The method is chosen
- * by the @ref boost::math::fpc::strength given at construction.
- */
-template<typename FPT>
-class close_at_tolerance {
-public:
-    // Public typedefs
-    typedef bool result_type;
-
-    // Constructor
-    template<typename ToleranceType>
-    explicit    close_at_tolerance( ToleranceType tolerance, fpc::strength fpc_strength = FPC_STRONG ) 
-    : m_fraction_tolerance( fpc_detail::fraction_tolerance<FPT>( tolerance ) )
-    , m_strength( fpc_strength )
-    , m_tested_rel_diff( 0 )
-    {
-        BOOST_ASSERT_MSG( m_fraction_tolerance >= FPT(0), "tolerance must not be negative!" ); // no reason for tolerance to be negative
-    }
-
-    // Access methods
-    //! Returns the tolerance
-    FPT                 fraction_tolerance() const  { return m_fraction_tolerance; }
-
-    //! Returns the comparison method
-    fpc::strength       strength() const            { return m_strength; }
-
-    //! Returns the failing fraction
-    FPT                 tested_rel_diff() const     { return m_tested_rel_diff; }
-
-    /*! Compares two floating point numbers a and b such that their "left" relative difference |a-b|/a and/or
-     * "right" relative difference |a-b|/b does not exceed specified relative (fraction) tolerance.
-     *
-     *  @param[in] left first floating point number to be compared
-     *  @param[in] right second floating point number to be compared
-     *
-     * What is reported by @c tested_rel_diff in case of failure depends on the comparison method:
-     * - for @c FPC_STRONG: the max of the two fractions
-     * - for @c FPC_WEAK: the min of the two fractions
-     * The rationale behind is to report the tolerance to set in order to make a test pass.
-     */
-    bool                operator()( FPT left, FPT right ) const
-    {
-        FPT diff              = fpc_detail::fpt_abs<FPT>( left - right );
-        FPT fraction_of_right = fpc_detail::safe_fpt_division( diff, fpc_detail::fpt_abs( right ) );
-        FPT fraction_of_left  = fpc_detail::safe_fpt_division( diff, fpc_detail::fpt_abs( left ) );
-
-        FPT max_rel_diff = (std::max)( fraction_of_left, fraction_of_right );
-        FPT min_rel_diff = (std::min)( fraction_of_left, fraction_of_right );
-
-        m_tested_rel_diff = m_strength == FPC_STRONG ? max_rel_diff : min_rel_diff;
-
-        return m_tested_rel_diff <= m_fraction_tolerance;
-    }
-
-private:
-    // Data members
-    FPT                 m_fraction_tolerance;
-    fpc::strength       m_strength;
-    mutable FPT         m_tested_rel_diff;
-};
-
-// ************************************************************************** //
-// **************            small_with_tolerance              ************** //
-// ************************************************************************** //
-
-
-/*!@brief Predicate for comparing floating point numbers against 0
- *
- * Serves the same purpose as boost::math::fpc::close_at_tolerance, but used when one
- * of the operand is null. 
- */
-template<typename FPT>
-class small_with_tolerance {
-public:
-    // Public typedefs
-    typedef bool result_type;
-
-    // Constructor
-    explicit    small_with_tolerance( FPT tolerance ) // <= absolute tolerance
-    : m_tolerance( tolerance )
-    {
-        BOOST_ASSERT( m_tolerance >= FPT(0) ); // no reason for the tolerance to be negative
-    }
-
-    // Action method
-    bool        operator()( FPT fpv ) const
-    {
-        return fpc::fpc_detail::fpt_abs( fpv ) <= m_tolerance;
-    }
-
-private:
-    // Data members
-    FPT         m_tolerance;
-};
-
-// ************************************************************************** //
-// **************                  is_small                    ************** //
-// ************************************************************************** //
-
-template<typename FPT>
-inline bool
-is_small( FPT fpv, FPT tolerance )
-{
-    return small_with_tolerance<FPT>( tolerance )( fpv );
-}
-
-//____________________________________________________________________________//
-
-} // namespace fpc
-} // namespace math
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_FLOATING_POINT_COMAPARISON_HPP_071894GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/fpc_op.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/fpc_op.hpp
deleted file mode 100644
index da143aa9f38..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/fpc_op.hpp
+++ /dev/null
@@ -1,224 +0,0 @@
-//  (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
-//!@brief Floating point comparison with enhanced reporting
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TOOLS_FPC_OP_HPP_050915GER
-#define BOOST_TEST_TOOLS_FPC_OP_HPP_050915GER
-
-// Boost.Test
-#include <boost/test/tools/assertion.hpp>
-
-#include <boost/test/tools/floating_point_comparison.hpp>
-#include <boost/test/tools/fpc_tolerance.hpp>
-
-// Boost
-#include <boost/type_traits/common_type.hpp>
-#include <boost/utility/enable_if.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace test_tools {
-namespace assertion {
-namespace op {
-
-// ************************************************************************** //
-// **************                   fpctraits                  ************** //
-// ************************************************************************** //
-// set of floating point comparison traits per comparison OP
-
-template<typename OP>
-struct fpctraits {
-    static const bool cmp_direct = true;
-};
-
-template <typename Lhs, typename Rhs>
-struct fpctraits<op::NE<Lhs,Rhs> > {
-    static const bool cmp_direct = false;
-};
-
-template <typename Lhs, typename Rhs>
-struct fpctraits<op::LT<Lhs,Rhs> > {
-    static const bool cmp_direct = false;
-};
-
-template <typename Lhs, typename Rhs>
-struct fpctraits<op::GT<Lhs,Rhs> > {
-    static const bool cmp_direct = false;
-};
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// ************** set of overloads to select correct fpc algo  ************** //
-// ************************************************************************** //
-// we really only care about EQ vs NE. All other comparisons use direct first
-// and then need EQ. For example a < b (tolerance t) IFF a < b OR a == b (tolerance t)
-
-template <typename FPT, typename Lhs, typename Rhs, typename OP>
-inline assertion_result
-compare_fpv( Lhs const& lhs, Rhs const& rhs, OP* )
-{
-    fpc::close_at_tolerance<FPT> P( fpc_tolerance<FPT>(), fpc::FPC_STRONG );
-
-    assertion_result ar( P( lhs, rhs ) );
-    if( !ar )
-        ar.message() << "Relative difference exceeds tolerance ["
-                     << P.tested_rel_diff() << " > " << P.fraction_tolerance() << ']';
-    return ar;
-}
-
-//____________________________________________________________________________//
-
-template <typename FPT, typename OP>
-inline assertion_result
-compare_fpv_near_zero( FPT const& fpv, OP* )
-{
-    fpc::small_with_tolerance<FPT> P( fpc_tolerance<FPT>() );
-
-    assertion_result ar( P( fpv ) );
-    if( !ar )
-        ar.message() << "Absolute value exceeds tolerance [|" << fpv << "| > "<< fpc_tolerance<FPT>() << ']';
-
-    return ar;
-}
-
-//____________________________________________________________________________//
-
-template <typename FPT, typename Lhs, typename Rhs>
-inline assertion_result
-compare_fpv( Lhs const& lhs, Rhs const& rhs, op::NE<Lhs,Rhs>* )
-{
-    fpc::close_at_tolerance<FPT> P( fpc_tolerance<FPT>(), fpc::FPC_WEAK );
-
-    assertion_result ar( !P( lhs, rhs ) );
-    if( !ar )
-        ar.message() << "Relative difference is within tolerance ["
-                     << P.tested_rel_diff() << " < " << fpc_tolerance<FPT>() << ']';
-
-    return ar;
-}
-
-//____________________________________________________________________________//
-
-template <typename FPT, typename Lhs, typename Rhs>
-inline assertion_result
-compare_fpv_near_zero( FPT const& fpv, op::NE<Lhs,Rhs>* )
-{
-    fpc::small_with_tolerance<FPT> P( fpc_tolerance<FPT>() );
-
-    assertion_result ar( !P( fpv ) );
-    if( !ar )
-        ar.message() << "Absolute value is within tolerance [|" << fpv << "| < "<< fpc_tolerance<FPT>() << ']';
-    return ar;
-}
-
-//____________________________________________________________________________//
-
-template <typename FPT, typename Lhs, typename Rhs>
-inline assertion_result
-compare_fpv( Lhs const& lhs, Rhs const& rhs, op::LT<Lhs,Rhs>* )
-{
-    return lhs >= rhs ? assertion_result( false ) : compare_fpv<FPT>( lhs, rhs, (op::NE<Lhs,Rhs>*)0 );
-}
-
-template <typename FPT, typename Lhs, typename Rhs>
-inline assertion_result
-compare_fpv_near_zero( FPT const& fpv, op::LT<Lhs,Rhs>* )
-{
-    return fpv >= 0 ? assertion_result( false ) : compare_fpv_near_zero( fpv, (op::NE<Lhs,Rhs>*)0 );
-}
-
-//____________________________________________________________________________//
-
-template <typename FPT, typename Lhs, typename Rhs>
-inline assertion_result
-compare_fpv( Lhs const& lhs, Rhs const& rhs, op::GT<Lhs,Rhs>* )
-{
-    return lhs <= rhs ? assertion_result( false ) : compare_fpv<FPT>( lhs, rhs, (op::NE<Lhs,Rhs>*)0 );
-}
-
-template <typename FPT, typename Lhs, typename Rhs>
-inline assertion_result
-compare_fpv_near_zero( FPT const& fpv, op::GT<Lhs,Rhs>* )
-{
-    return fpv <= 0 ? assertion_result( false ) : compare_fpv_near_zero( fpv, (op::NE<Lhs,Rhs>*)0 );
-}
-
-
-//____________________________________________________________________________//
-
-#define DEFINE_FPV_COMPARISON( oper, name, rev )                        \
-template<typename Lhs,typename Rhs>                                     \
-struct name<Lhs,Rhs,typename boost::enable_if_c<                        \
-    (fpc::tolerance_based<Lhs>::value &&                                \
-     fpc::tolerance_based<Rhs>::value)>::type> {                        \
-public:                                                                 \
-    typedef typename common_type<Lhs,Rhs>::type FPT;                    \
-    typedef name<Lhs,Rhs> OP;                                           \
-                                                                        \
-    typedef assertion_result result_type;                               \
-                                                                        \
-    static bool                                                         \
-    eval_direct( Lhs const& lhs, Rhs const& rhs )                       \
-    {                                                                   \
-        return lhs oper rhs;                                            \
-    }                                                                   \
-                                                                        \
-    static assertion_result                                             \
-    eval( Lhs const& lhs, Rhs const& rhs )                              \
-    {                                                                   \
-        if( lhs == 0 )                                                  \
-            return compare_fpv_near_zero( rhs, (OP*)0 );                \
-                                                                        \
-        if( rhs == 0 )                                                  \
-            return compare_fpv_near_zero( lhs, (OP*)0 );                \
-                                                                        \
-        bool direct_res = eval_direct( lhs, rhs );                      \
-                                                                        \
-        if( (direct_res && fpctraits<OP>::cmp_direct) ||                \
-            fpc_tolerance<FPT>() == FPT(0) )                            \
-            return direct_res;                                          \
-                                                                        \
-        return compare_fpv<FPT>( lhs, rhs, (OP*)0 );                    \
-    }                                                                   \
-                                                                        \
-    template<typename PrevExprType>                                     \
-    static void                                                         \
-    report( std::ostream&       ostr,                                   \
-            PrevExprType const& lhs,                                    \
-            Rhs const&          rhs )                                   \
-    {                                                                   \
-        lhs.report( ostr );                                             \
-        ostr << revert()                                                \
-             << tt_detail::print_helper( rhs );                         \
-    }                                                                   \
-                                                                        \
-    static char const* revert()                                         \
-    { return " " #rev " "; }                                            \
-};                                                                      \
-/**/
-
-BOOST_TEST_FOR_EACH_COMP_OP( DEFINE_FPV_COMPARISON )
-#undef DEFINE_FPV_COMPARISON
-
-//____________________________________________________________________________//
-
-} // namespace op
-} // namespace assertion
-} // namespace test_tools
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TOOLS_FPC_OP_HPP_050915GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/fpc_tolerance.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/fpc_tolerance.hpp
deleted file mode 100644
index c862a17e75a..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/fpc_tolerance.hpp
+++ /dev/null
@@ -1,103 +0,0 @@
-//  (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: 74248 $
-//
-//  Description : FPC tools tolerance holder
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TOOLS_FPC_TOLERANCE_HPP_121612GER
-#define BOOST_TEST_TOOLS_FPC_TOLERANCE_HPP_121612GER
-
-// Boost Test
-#include <boost/test/tree/decorator.hpp>
-#include <boost/test/tools/floating_point_comparison.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace test_tools {
-
-namespace fpc = math::fpc;
-
-// ************************************************************************** //
-// **************     floating point comparison tolerance      ************** //
-// ************************************************************************** //
-
-template<typename FPT>
-inline FPT&
-fpc_tolerance()
-{
-    static FPT s_value = 0;
-    return s_value;
-}
-
-//____________________________________________________________________________//
-
-template<typename FPT>
-struct local_fpc_tolerance {
-    local_fpc_tolerance( FPT fraction_tolerance ) : m_old_tolerance( fpc_tolerance<FPT>() )
-    {
-        fpc_tolerance<FPT>() = fraction_tolerance;
-    }
-
-    ~local_fpc_tolerance()
-    {
-        if( m_old_tolerance != (FPT)-1 )
-            fpc_tolerance<FPT>() = m_old_tolerance;
-    }
-
-private:
-    // Data members
-    FPT         m_old_tolerance;
-};
-
-//____________________________________________________________________________//
-
-} // namespace test_tools
-
-// ************************************************************************** //
-// **************             decorator::tolerance             ************** //
-// ************************************************************************** //
-
-namespace unit_test {
-namespace decorator {
-
-template<typename FPT>
-inline fixture_t
-tolerance( FPT v )
-{
-    return fixture_t( test_unit_fixture_ptr(
-        new unit_test::class_based_fixture<test_tools::local_fpc_tolerance<FPT>,FPT>( v ) ) );
-}
-
-//____________________________________________________________________________//
-
-template<typename FPT>
-inline fixture_t
-tolerance( test_tools::fpc::percent_tolerance_t<FPT> v )
-{
-    return fixture_t( test_unit_fixture_ptr(
-        new unit_test::class_based_fixture<test_tools::local_fpc_tolerance<FPT>,FPT>( boost::math::fpc::fpc_detail::fraction_tolerance<FPT>( v ) ) ) );
-}
-
-//____________________________________________________________________________//
-
-} // namespace decorator
-
-using decorator::tolerance;
-
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TOOLS_FPC_TOLERANCE_HPP_121612GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/interface.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/interface.hpp
deleted file mode 100644
index 5e84f1c6d4e..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/interface.hpp
+++ /dev/null
@@ -1,369 +0,0 @@
-//  (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: 81247 $
-//
-//  Description : contains definition for all test tools in test toolbox
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TOOLS_INTERFACE_HPP_111712GER
-#define BOOST_TEST_TOOLS_INTERFACE_HPP_111712GER
-
-// Boost.Test
-#include <boost/test/unit_test_log.hpp>
-#ifdef BOOST_TEST_TOOLS_DEBUGGABLE
-#include <boost/test/debug.hpp>
-#endif
-#ifdef BOOST_NO_CXX11_AUTO_DECLARATIONS
-#include <boost/test/tools/detail/expression_holder.hpp>
-#endif
-
-#include <boost/test/detail/pp_variadic.hpp>
-
-#ifdef BOOST_TEST_NO_OLD_TOOLS
-#include <boost/preprocessor/seq/to_tuple.hpp>
-
-#include <iterator>
-#endif // BOOST_TEST_NO_OLD_TOOLS
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               BOOST_TEST_<level>             ************** //
-// ************************************************************************** //
-
-#define BOOST_TEST_BUILD_ASSERTION( P )             \
-    (::boost::test_tools::assertion::seed()->*P)    \
-/**/
-
-//____________________________________________________________________________//
-
-// Implementation based on direct predicate evaluation
-#define BOOST_TEST_TOOL_DIRECT_IMPL( P, level, M )              \
-do {                                                            \
-    ::boost::test_tools::assertion_result res = (P);            \
-    report_assertion(                                           \
-        res,                                                    \
-        BOOST_TEST_LAZY_MSG( M ),                               \
-        BOOST_TEST_L(__FILE__),                                 \
-        static_cast<std::size_t>(__LINE__),                     \
-        ::boost::test_tools::tt_detail::level,                  \
-        ::boost::test_tools::tt_detail::CHECK_MSG,              \
-        0 );                                                    \
-} while( ::boost::test_tools::tt_detail::dummy_cond() )         \
-/**/
-
-//____________________________________________________________________________//
-
-// Implementation based on expression template construction
-#define BOOST_TEST_TOOL_ET_IMPL( P, level )                     \
-do {                                                            \
-    BOOST_TEST_PASSPOINT();                                     \
-                                                                \
-    ::boost::test_tools::tt_detail::                            \
-    report_assertion(                                           \
-      BOOST_TEST_BUILD_ASSERTION( P ).evaluate(),               \
-      BOOST_TEST_LAZY_MSG( BOOST_TEST_STRINGIZE( P ) ),         \
-      BOOST_TEST_L(__FILE__),                                   \
-      static_cast<std::size_t>(__LINE__),                       \
-      ::boost::test_tools::tt_detail::level,                    \
-      ::boost::test_tools::tt_detail::CHECK_BUILT_ASSERTION,    \
-      0 );                                                      \
-} while( ::boost::test_tools::tt_detail::dummy_cond() )         \
-/**/
-
-//____________________________________________________________________________//
-
-// Implementation based on expression template construction with extra tool arguments
-#define BOOST_TEST_TOOL_ET_IMPL_EX( P, level, arg )             \
-do {                                                            \
-    BOOST_TEST_PASSPOINT();                                     \
-                                                                \
-    ::boost::test_tools::tt_detail::                            \
-    report_assertion(                                           \
-      ::boost::test_tools::tt_detail::assertion_evaluate(       \
-        BOOST_TEST_BUILD_ASSERTION( P ) )                       \
-          << arg,                                               \
-      ::boost::test_tools::tt_detail::assertion_text(           \
-          BOOST_TEST_LAZY_MSG( BOOST_TEST_STRINGIZE(P) ),       \
-          BOOST_TEST_LAZY_MSG( arg ) ),                         \
-      BOOST_TEST_L(__FILE__),                                   \
-      static_cast<std::size_t>(__LINE__),                       \
-      ::boost::test_tools::tt_detail::level,                    \
-      ::boost::test_tools::tt_detail::assertion_type()          \
-          << arg,                                               \
-      0 );                                                      \
-} while( ::boost::test_tools::tt_detail::dummy_cond() )         \
-/**/
-
-//____________________________________________________________________________//
-
-#ifdef BOOST_TEST_TOOLS_UNDER_DEBUGGER
-
-#define BOOST_TEST_TOOL_UNIV( level, P )                                    \
-    BOOST_TEST_TOOL_DIRECT_IMPL( P, level, BOOST_TEST_STRINGIZE( P ) )      \
-/**/
-
-#define BOOST_TEST_TOOL_UNIV_EX( level, P, ... )                            \
-    BOOST_TEST_TOOL_UNIV( level, P )                                        \
-/**/
-
-#elif defined(BOOST_TEST_TOOLS_DEBUGGABLE)
-
-#define BOOST_TEST_TOOL_UNIV( level, P )                                    \
-do {                                                                        \
-    if( ::boost::debug::under_debugger() )                                  \
-        BOOST_TEST_TOOL_DIRECT_IMPL( P, level, BOOST_TEST_STRINGIZE( P ) ); \
-    else                                                                    \
-        BOOST_TEST_TOOL_ET_IMPL( P, level );                                \
-} while( ::boost::test_tools::tt_detail::dummy_cond() )                     \
-/**/
-
-#define BOOST_TEST_TOOL_UNIV_EX( level, P, ... )                            \
-    BOOST_TEST_TOOL_UNIV( level, P )                                        \
-/**/
-
-#else
-
-#define BOOST_TEST_TOOL_UNIV( level, P )                                    \
-    BOOST_TEST_TOOL_ET_IMPL( P, level )                                     \
-/**/
-
-#define BOOST_TEST_TOOL_UNIV_EX( level, P, ... )                            \
-    BOOST_TEST_TOOL_ET_IMPL_EX( P, level, __VA_ARGS__ )                     \
-/**/
-
-#endif
-
-//____________________________________________________________________________//
-
-#define BOOST_TEST_WARN( ... )              BOOST_TEST_INVOKE_IF_N_ARGS(    \
-    2, BOOST_TEST_TOOL_UNIV, BOOST_TEST_TOOL_UNIV_EX, WARN, __VA_ARGS__ )   \
-/**/
-#define BOOST_TEST_CHECK( ... )             BOOST_TEST_INVOKE_IF_N_ARGS(    \
-    2, BOOST_TEST_TOOL_UNIV, BOOST_TEST_TOOL_UNIV_EX, CHECK, __VA_ARGS__ )  \
-/**/
-#define BOOST_TEST_REQUIRE( ... )           BOOST_TEST_INVOKE_IF_N_ARGS(    \
-    2, BOOST_TEST_TOOL_UNIV, BOOST_TEST_TOOL_UNIV_EX, REQUIRE, __VA_ARGS__ )\
-/**/
-
-#define BOOST_TEST( ... )                   BOOST_TEST_INVOKE_IF_N_ARGS(    \
-    2, BOOST_TEST_TOOL_UNIV, BOOST_TEST_TOOL_UNIV_EX, CHECK, __VA_ARGS__ )  \
-/**/
-
-//____________________________________________________________________________//
-
-#define BOOST_TEST_ERROR( M )               BOOST_CHECK_MESSAGE( false, M )
-#define BOOST_TEST_FAIL( M )                BOOST_REQUIRE_MESSAGE( false, M )
-
-//____________________________________________________________________________//
-
-#define BOOST_TEST_IS_DEFINED( symb ) ::boost::test_tools::tt_detail::is_defined_impl( symb, BOOST_STRINGIZE(= symb) )
-
-//____________________________________________________________________________//
-
-#ifdef BOOST_TEST_NO_OLD_TOOLS
-
-#ifdef BOOST_TEST_TOOLS_UNDER_DEBUGGER
-
-#define BOOST_CHECK_THROW_IMPL(S, E, TL, Ppassed, Mpassed, Pcaught, Mcaught)\
-do { try {                                                                  \
-    S;                                                                      \
-    BOOST_TEST_TOOL_DIRECT_IMPL( Ppassed, TL, Mpassed );                    \
-} catch( E ) {                                                              \
-    BOOST_TEST_TOOL_DIRECT_IMPL( Pcaught, TL, Mcaught );                    \
-}} while( ::boost::test_tools::tt_detail::dummy_cond() )                    \
-/**/
-
-#elif defined(BOOST_TEST_TOOLS_DEBUGGABLE)
-
-#define BOOST_CHECK_THROW_IMPL(S, E, TL, Ppassed, Mpassed, Pcaught, Mcaught)\
-do { try {                                                                  \
-    if( ::boost::debug::under_debugger() )                                  \
-        BOOST_TEST_PASSPOINT();                                             \
-    S;                                                                      \
-    BOOST_TEST_TOOL_DIRECT_IMPL( Ppassed, TL, Mpassed );                    \
-} catch( E ) {                                                              \
-    BOOST_TEST_TOOL_DIRECT_IMPL( Pcaught, TL, Mcaught );                    \
-}} while( ::boost::test_tools::tt_detail::dummy_cond() )                    \
-/**/
-
-#else
-
-#define BOOST_CHECK_THROW_IMPL(S, E, TL, Ppassed, Mpassed, Pcaught, Mcaught)\
-do { try {                                                                  \
-    BOOST_TEST_PASSPOINT();                                                 \
-    S;                                                                      \
-    BOOST_TEST_TOOL_DIRECT_IMPL( Ppassed, TL, Mpassed );                    \
-} catch( E ) {                                                              \
-    BOOST_TEST_TOOL_DIRECT_IMPL( Pcaught, TL, Mcaught );                    \
-}} while( ::boost::test_tools::tt_detail::dummy_cond() )                    \
-/**/
-
-#endif
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_THROW( S, E )                                            \
-    BOOST_CHECK_THROW_IMPL(S, E const&, WARN,                               \
-            false, "exception " BOOST_STRINGIZE(E) " is expected",          \
-            true , "exception " BOOST_STRINGIZE(E) " is caught" )           \
-/**/
-#define BOOST_CHECK_THROW( S, E )                                           \
-    BOOST_CHECK_THROW_IMPL(S, E const&, CHECK,                              \
-            false, "exception " BOOST_STRINGIZE(E) " is expected",          \
-            true , "exception " BOOST_STRINGIZE(E) " is caught" )           \
-/**/
-#define BOOST_REQUIRE_THROW( S, E )                                         \
-    BOOST_CHECK_THROW_IMPL(S, E const&, REQUIRE,                            \
-            false, "exception " BOOST_STRINGIZE(E) " is expected",          \
-            true , "exception " BOOST_STRINGIZE(E) " is caught" )           \
-/**/
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_EXCEPTION( S, E, P )                                     \
-    BOOST_CHECK_THROW_IMPL(S, E const& ex, WARN,                            \
-            false, "exception " BOOST_STRINGIZE(E) " is expected",          \
-            P(ex), "incorrect exception " BOOST_STRINGIZE(E) " is caught" ) \
-/**/
-#define BOOST_CHECK_EXCEPTION( S, E, P )                                    \
-    BOOST_CHECK_THROW_IMPL(S, E const& ex, CHECK,                           \
-            false, "exception " BOOST_STRINGIZE(E) " is expected",          \
-            P(ex), "incorrect exception " BOOST_STRINGIZE(E) " is caught" ) \
-/**/
-#define BOOST_REQUIRE_EXCEPTION( S, E, P )                                  \
-    BOOST_CHECK_THROW_IMPL(S, E const& ex, REQUIRE,                         \
-            false, "exception " BOOST_STRINGIZE(E) " is expected",          \
-            P(ex), "incorrect exception " BOOST_STRINGIZE(E) " is caught" ) \
-/**/
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_NO_THROW( S )                                            \
-    BOOST_CHECK_THROW_IMPL(S, ..., WARN,                                    \
-            true , "no exceptions thrown by " BOOST_STRINGIZE( S ),         \
-            false, "exception thrown by " BOOST_STRINGIZE( S ) )            \
-/**/
-#define BOOST_CHECK_NO_THROW( S )                                           \
-    BOOST_CHECK_THROW_IMPL(S, ..., CHECK,                                   \
-            true , "no exceptions thrown by " BOOST_STRINGIZE( S ),         \
-            false, "exception thrown by " BOOST_STRINGIZE( S ) )            \
-/**/
-#define BOOST_REQUIRE_NO_THROW( S )                                         \
-    BOOST_CHECK_THROW_IMPL(S, ..., REQUIRE,                                 \
-            true , "no exceptions thrown by " BOOST_STRINGIZE( S ),         \
-            false, "exception thrown by " BOOST_STRINGIZE( S ) )            \
-/**/
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_MESSAGE( P, M )          BOOST_TEST_TOOL_DIRECT_IMPL( P, WARN, M )
-#define BOOST_CHECK_MESSAGE( P, M )         BOOST_TEST_TOOL_DIRECT_IMPL( P, CHECK, M )
-#define BOOST_REQUIRE_MESSAGE( P, M )       BOOST_TEST_TOOL_DIRECT_IMPL( P, REQUIRE, M )
-
-//____________________________________________________________________________//
-
-////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////   DEPRECATED TOOLS   /////////////////////////////
-
-#define BOOST_WARN( P )                     BOOST_TEST_WARN( P )
-#define BOOST_CHECK( P )                    BOOST_TEST_CHECK( P )
-#define BOOST_REQUIRE( P )                  BOOST_TEST_REQUIRE( P )
-
-//____________________________________________________________________________//
-
-#define BOOST_ERROR( M )                    BOOST_TEST_ERROR( M )
-#define BOOST_FAIL( M )                     BOOST_TEST_FAIL( M )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_EQUAL( L, R )            BOOST_TEST_WARN( L == R )
-#define BOOST_CHECK_EQUAL( L, R )           BOOST_TEST_CHECK( L == R )
-#define BOOST_REQUIRE_EQUAL( L, R )         BOOST_TEST_REQUIRE( L == R )
-
-#define BOOST_WARN_NE( L, R )               BOOST_TEST_WARN( L != R )
-#define BOOST_CHECK_NE( L, R )              BOOST_TEST_CHECK( L != R )
-#define BOOST_REQUIRE_NE( L, R )            BOOST_TEST_REQUIRE( L != R )
-
-#define BOOST_WARN_LT( L, R )               BOOST_TEST_WARN( L < R )
-#define BOOST_CHECK_LT( L, R )              BOOST_TEST_CHECK( L < R )
-#define BOOST_REQUIRE_LT( L, R )            BOOST_TEST_REQUIRE( L < R )
-
-#define BOOST_WARN_LE( L, R )               BOOST_TEST_WARN( L <= R )
-#define BOOST_CHECK_LE( L, R )              BOOST_TEST_CHECK( L <= R )
-#define BOOST_REQUIRE_LE( L, R )            BOOST_TEST_REQUIRE( L <= R )
-
-#define BOOST_WARN_GT( L, R )               BOOST_TEST_WARN( L > R )
-#define BOOST_CHECK_GT( L, R )              BOOST_TEST_CHECK( L > R )
-#define BOOST_REQUIRE_GT( L, R )            BOOST_TEST_REQUIRE( L > R )
-
-#define BOOST_WARN_GE( L, R )               BOOST_TEST_WARN( L >= R )
-#define BOOST_CHECK_GE( L, R )              BOOST_TEST_CHECK( L >= R )
-#define BOOST_REQUIRE_GE( L, R )            BOOST_TEST_REQUIRE( L >= R )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_CLOSE( L, R, T )         BOOST_TEST_WARN( L == R, T % ::boost::test_tools::tolerance() )
-#define BOOST_CHECK_CLOSE( L, R, T )        BOOST_TEST_CHECK( L == R, T % ::boost::test_tools::tolerance() )
-#define BOOST_REQUIRE_CLOSE( L, R, T )      BOOST_TEST_REQUIRE( L == R, T % ::boost::test_tools::tolerance() )
-
-#define BOOST_WARN_CLOSE_FRACTION(L, R, T)  BOOST_TEST_WARN( L == R, ::boost::test_tools::tolerance( T ) )
-#define BOOST_CHECK_CLOSE_FRACTION(L, R, T) BOOST_TEST_CHECK( L == R, ::boost::test_tools::tolerance( T ) )
-#define BOOST_REQUIRE_CLOSE_FRACTION(L,R,T) BOOST_TEST_REQUIRE( L == R, ::boost::test_tools::tolerance( T ) )
-
-#define BOOST_WARN_SMALL( FPV, T )          BOOST_TEST_WARN( FPV == 0., ::boost::test_tools::tolerance( T ) )
-#define BOOST_CHECK_SMALL( FPV, T )         BOOST_TEST_CHECK( FPV == 0., ::boost::test_tools::tolerance( T ) )
-#define BOOST_REQUIRE_SMALL( FPV, T )       BOOST_TEST_REQUIRE( FPV == 0., ::boost::test_tools::tolerance( T ) )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_EQUAL_COLLECTIONS( L_begin, L_end, R_begin, R_end )              \
-    BOOST_TEST_WARN( ::boost::test_tools::tt_detail::make_it_pair(L_begin, L_end) ==\
-                     ::boost::test_tools::tt_detail::make_it_pair(R_begin, R_end),  \
-                     ::boost::test_tools::per_element() )                           \
-/**/
-
-#define BOOST_CHECK_EQUAL_COLLECTIONS( L_begin, L_end, R_begin, R_end )              \
-    BOOST_TEST_CHECK( ::boost::test_tools::tt_detail::make_it_pair(L_begin, L_end) ==\
-                      ::boost::test_tools::tt_detail::make_it_pair(R_begin, R_end),  \
-                      ::boost::test_tools::per_element() )                           \
-/**/
-
-#define BOOST_REQUIRE_EQUAL_COLLECTIONS( L_begin, L_end, R_begin, R_end )              \
-    BOOST_TEST_REQUIRE( ::boost::test_tools::tt_detail::make_it_pair(L_begin, L_end) ==\
-                        ::boost::test_tools::tt_detail::make_it_pair(R_begin, R_end),  \
-                        ::boost::test_tools::per_element() )                           \
-/**/
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_BITWISE_EQUAL( L, R )    BOOST_TEST_WARN( L == R, ::boost::test_tools::bitwise() )
-#define BOOST_CHECK_BITWISE_EQUAL( L, R )   BOOST_TEST_CHECK( L == R, ::boost::test_tools::bitwise() )
-#define BOOST_REQUIRE_BITWISE_EQUAL( L, R ) BOOST_TEST_REQUIRE( L == R, ::boost::test_tools::bitwise() )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_PREDICATE( P, ARGS )     BOOST_TEST_WARN( P BOOST_PP_SEQ_TO_TUPLE(ARGS) )
-#define BOOST_CHECK_PREDICATE( P, ARGS )    BOOST_TEST_CHECK( P BOOST_PP_SEQ_TO_TUPLE(ARGS) )
-#define BOOST_REQUIRE_PREDICATE( P, ARGS )  BOOST_TEST_REQUIRE( P BOOST_PP_SEQ_TO_TUPLE(ARGS) )
-
-//____________________________________________________________________________//
-
-#define BOOST_IS_DEFINED( symb ) ::boost::test_tools::tt_detail::is_defined_impl( #symb, BOOST_STRINGIZE(= symb) )
-
-//____________________________________________________________________________//
-
-#endif // BOOST_TEST_NO_OLD_TOOLS
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TOOLS_INTERFACE_HPP_111712GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/old/impl.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/old/impl.hpp
deleted file mode 100644
index b975f61b38a..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/old/impl.hpp
+++ /dev/null
@@ -1,358 +0,0 @@
-//  (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: 74248 $
-//
-//  Description : implementation details for old toolbox
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TOOLS_OLD_IMPL_HPP_012705GER
-#define BOOST_TEST_TOOLS_OLD_IMPL_HPP_012705GER
-
-// Boost.Test
-#include <boost/test/unit_test_log.hpp>
-#include <boost/test/tools/assertion_result.hpp>
-#include <boost/test/tools/floating_point_comparison.hpp>
-
-#include <boost/test/tools/detail/fwd.hpp>
-#include <boost/test/tools/detail/print_helper.hpp>
-
-// Boost
-#include <boost/limits.hpp>
-#include <boost/numeric/conversion/conversion_traits.hpp> // for numeric::conversion_traits
-#include <boost/type_traits/is_array.hpp>
-
-#include <boost/preprocessor/repetition/repeat.hpp>
-#include <boost/preprocessor/arithmetic/add.hpp>
-
-// STL
-#include <cstddef>          // for std::size_t
-#include <climits>          // for CHAR_BIT
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace test_tools {
-namespace tt_detail {
-
-// ************************************************************************** //
-// **************          old TOOLBOX Implementation          ************** //
-// ************************************************************************** //
-
-// This function adds level of indirection, but it makes sure we evaluate predicate
-// arguments only once
-
-#ifndef BOOST_TEST_PROD
-#define TEMPL_PARAMS( z, m, dummy ) , typename BOOST_JOIN( Arg, m )
-
-#define FUNC_PARAMS( z, m, dummy )                                                  \
- , BOOST_JOIN( Arg, m ) const& BOOST_JOIN( arg, m )                                 \
- , char const* BOOST_JOIN( BOOST_JOIN( arg, m ), _descr )                           \
-/**/
-
-#define PRED_PARAMS( z, m, dummy ) BOOST_PP_COMMA_IF( m ) BOOST_JOIN( arg, m )
-
-#define ARG_INFO( z, m, dummy )                                                     \
- , BOOST_JOIN( BOOST_JOIN( arg, m ), _descr )                                       \
- , &static_cast<const unit_test::lazy_ostream&>(unit_test::lazy_ostream::instance() \
-        << ::boost::test_tools::tt_detail::print_helper( BOOST_JOIN( arg, m ) ))    \
-/**/
-
-#define IMPL_FRWD( z, n, dummy )                                                    \
-template<typename Pred                                                              \
-         BOOST_PP_REPEAT_ ## z( BOOST_PP_ADD( n, 1 ), TEMPL_PARAMS, _ )>            \
-inline bool                                                                         \
-check_frwd( Pred P, unit_test::lazy_ostream const& assertion_descr,                 \
-            const_string file_name, std::size_t line_num,                           \
-            tool_level tl, check_type ct                                            \
-            BOOST_PP_REPEAT_ ## z( BOOST_PP_ADD( n, 1 ), FUNC_PARAMS, _ )           \
-)                                                                                   \
-{                                                                                   \
-    return                                                                          \
-    report_assertion( P( BOOST_PP_REPEAT_ ## z(BOOST_PP_ADD(n, 1), PRED_PARAMS,_) ),\
-                assertion_descr, file_name, line_num, tl, ct,                       \
-                BOOST_PP_ADD( n, 1 )                                                \
-                BOOST_PP_REPEAT_ ## z( BOOST_PP_ADD( n, 1 ), ARG_INFO, _ )          \
-    );                                                                              \
-}                                                                                   \
-/**/
-
-#ifndef BOOST_TEST_MAX_PREDICATE_ARITY
-#define BOOST_TEST_MAX_PREDICATE_ARITY 5
-#endif
-
-BOOST_PP_REPEAT( BOOST_TEST_MAX_PREDICATE_ARITY, IMPL_FRWD, _ )
-
-#undef TEMPL_PARAMS
-#undef FUNC_PARAMS
-#undef PRED_INFO
-#undef ARG_INFO
-#undef IMPL_FRWD
-
-#endif
-
-//____________________________________________________________________________//
-
-template <class Left, class Right>
-inline assertion_result equal_impl( Left const& left, Right const& right )
-{
-    return left == right;
-}
-
-//____________________________________________________________________________//
-
-inline assertion_result equal_impl( char* left, char const* right ) { return equal_impl( static_cast<char const*>(left), static_cast<char const*>(right) ); }
-inline assertion_result equal_impl( char const* left, char* right ) { return equal_impl( static_cast<char const*>(left), static_cast<char const*>(right) ); }
-inline assertion_result equal_impl( char* left, char* right )       { return equal_impl( static_cast<char const*>(left), static_cast<char const*>(right) ); }
-
-#if !defined( BOOST_NO_CWCHAR )
-assertion_result        BOOST_TEST_DECL equal_impl( wchar_t const* left, wchar_t const* right );
-inline assertion_result equal_impl( wchar_t* left, wchar_t const* right ) { return equal_impl( static_cast<wchar_t const*>(left), static_cast<wchar_t const*>(right) ); }
-inline assertion_result equal_impl( wchar_t const* left, wchar_t* right ) { return equal_impl( static_cast<wchar_t const*>(left), static_cast<wchar_t const*>(right) ); }
-inline assertion_result equal_impl( wchar_t* left, wchar_t* right )       { return equal_impl( static_cast<wchar_t const*>(left), static_cast<wchar_t const*>(right) ); }
-#endif
-
-//____________________________________________________________________________//
-
-struct equal_impl_frwd {
-    template <typename Left, typename Right>
-    inline assertion_result
-    call_impl( Left const& left, Right const& right, mpl::false_ ) const
-    {
-        return equal_impl( left, right );
-    }
-
-    template <typename Left, typename Right>
-    inline assertion_result
-    call_impl( Left const& left, Right const& right, mpl::true_ ) const
-    {
-        return (*this)( right, &left[0] );
-    }
-
-    template <typename Left, typename Right>
-    inline assertion_result
-    operator()( Left const& left, Right const& right ) const
-    {
-        typedef typename is_array<Left>::type left_is_array;
-        return call_impl( left, right, left_is_array() );
-    }
-};
-
-//____________________________________________________________________________//
-
-struct ne_impl {
-    template <class Left, class Right>
-    assertion_result operator()( Left const& left, Right const& right )
-    {
-        return !equal_impl_frwd()( left, right );
-    }
-};
-
-//____________________________________________________________________________//
-
-struct lt_impl {
-    template <class Left, class Right>
-    assertion_result operator()( Left const& left, Right const& right )
-    {
-        return left < right;
-    }
-};
-
-//____________________________________________________________________________//
-
-struct le_impl {
-    template <class Left, class Right>
-    assertion_result operator()( Left const& left, Right const& right )
-    {
-        return left <= right;
-    }
-};
-
-//____________________________________________________________________________//
-
-struct gt_impl {
-    template <class Left, class Right>
-    assertion_result operator()( Left const& left, Right const& right )
-    {
-        return left > right;
-    }
-};
-
-//____________________________________________________________________________//
-
-struct ge_impl {
-    template <class Left, class Right>
-    assertion_result operator()( Left const& left, Right const& right )
-    {
-        return left >= right;
-    }
-};
-
-//____________________________________________________________________________//
-
-struct equal_coll_impl {
-    template <typename Left, typename Right>
-    assertion_result operator()( Left left_begin, Left left_end, Right right_begin, Right right_end )
-    {
-        assertion_result    pr( true );
-        std::size_t         pos = 0;
-
-        for( ; left_begin != left_end && right_begin != right_end; ++left_begin, ++right_begin, ++pos ) {
-            if( *left_begin != *right_begin ) {
-                pr = false;
-                pr.message() << "\nMismatch at position " << pos << ": "
-                  << ::boost::test_tools::tt_detail::print_helper(*left_begin)
-                  << " != "
-                  << ::boost::test_tools::tt_detail::print_helper(*right_begin);
-            }
-        }
-
-        if( left_begin != left_end ) {
-            std::size_t r_size = pos;
-            while( left_begin != left_end ) {
-                ++pos;
-                ++left_begin;
-            }
-
-            pr = false;
-            pr.message() << "\nCollections size mismatch: " << pos << " != " << r_size;
-        }
-
-        if( right_begin != right_end ) {
-            std::size_t l_size = pos;
-            while( right_begin != right_end ) {
-                ++pos;
-                ++right_begin;
-            }
-
-            pr = false;
-            pr.message() << "\nCollections size mismatch: " << l_size << " != " << pos;
-        }
-
-        return pr;
-    }
-};
-
-//____________________________________________________________________________//
-
-struct bitwise_equal_impl {
-    template <class Left, class Right>
-    assertion_result    operator()( Left const& left, Right const& right )
-    {
-        assertion_result    pr( true );
-
-        std::size_t left_bit_size  = sizeof(Left)*CHAR_BIT;
-        std::size_t right_bit_size = sizeof(Right)*CHAR_BIT;
-
-        static Left const leftOne( 1 );
-        static Right const rightOne( 1 );
-
-        std::size_t total_bits = left_bit_size < right_bit_size ? left_bit_size : right_bit_size;
-
-        for( std::size_t counter = 0; counter < total_bits; ++counter ) {
-            if( ( left & ( leftOne << counter ) ) != ( right & ( rightOne << counter ) ) ) {
-                pr = false;
-                pr.message() << "\nMismatch at position " << counter;
-            }
-        }
-
-        if( left_bit_size != right_bit_size ) {
-            pr = false;
-            pr.message() << "\nOperands bit sizes mismatch: " << left_bit_size << " != " << right_bit_size;
-        }
-
-        return pr;
-    }
-};
-
-//____________________________________________________________________________//
-
-template<typename FPT1, typename FPT2>
-struct comp_supertype {
-    // deduce "better" type from types of arguments being compared
-    // if one type is floating and the second integral we use floating type and
-    // value of integral type is promoted to the floating. The same for float and double
-    // But we don't want to compare two values of integral types using this tool.
-    typedef typename numeric::conversion_traits<FPT1,FPT2>::supertype type;
-    BOOST_STATIC_ASSERT_MSG( !is_integral<type>::value, "Only floating-point types can be compared!");
-};
-
-} // namespace tt_detail
-
-namespace fpc = math::fpc;
-
-// ************************************************************************** //
-// **************               check_is_close                 ************** //
-// ************************************************************************** //
-
-struct BOOST_TEST_DECL check_is_close_t {
-    // Public typedefs
-    typedef assertion_result result_type;
-
-    template<typename FPT1, typename FPT2, typename ToleranceType>
-    assertion_result
-    operator()( FPT1 left, FPT2 right, ToleranceType tolerance ) const
-    {
-        fpc::close_at_tolerance<typename tt_detail::comp_supertype<FPT1,FPT2>::type> pred( tolerance, fpc::FPC_STRONG );
-
-        assertion_result ar( pred( left, right ) );
-
-        if( !ar )
-            ar.message() << pred.tested_rel_diff();
-
-        return ar;
-    }
-};
-
-//____________________________________________________________________________//
-
-template<typename FPT1, typename FPT2, typename ToleranceType>
-inline assertion_result
-check_is_close( FPT1 left, FPT2 right, ToleranceType tolerance )
-{
-    return check_is_close_t()( left, right, tolerance );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               check_is_small                 ************** //
-// ************************************************************************** //
-
-struct BOOST_TEST_DECL check_is_small_t {
-    // Public typedefs
-    typedef bool result_type;
-
-    template<typename FPT>
-    bool
-    operator()( FPT fpv, FPT tolerance ) const
-    {
-        return fpc::is_small( fpv, tolerance );
-    }
-};
-
-//____________________________________________________________________________//
-
-template<typename FPT>
-inline bool
-check_is_small( FPT fpv, FPT tolerance )
-{
-    return fpc::is_small( fpv, tolerance );
-}
-
-//____________________________________________________________________________//
-
-} // namespace test_tools
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TOOLS_OLD_IMPL_HPP_012705GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/old/interface.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/old/interface.hpp
deleted file mode 100644
index 2d6f8b78c0c..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/old/interface.hpp
+++ /dev/null
@@ -1,282 +0,0 @@
-//  (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: 81247 $
-//
-//  Description : contains definition for all test tools in old test toolbox
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TOOLS_OLD_INTERFACE_HPP_111712GER
-#define BOOST_TEST_TOOLS_OLD_INTERFACE_HPP_111712GER
-
-// Boost
-#include <boost/preprocessor/seq/for_each.hpp>
-#include <boost/preprocessor/seq/size.hpp>
-#include <boost/preprocessor/seq/to_tuple.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                    TOOL BOX                  ************** //
-// ************************************************************************** //
-
-// In macros below following argument abbreviations are used:
-// P - predicate
-// M - message
-// S - statement
-// E - exception
-// L - left argument
-// R - right argument
-// TL - tool level
-// CT - check type
-// ARGS - arguments list (as PP sequence)
-
-// frwd_type:
-// 0 - args exists and need to be forwarded; call check_frwd
-// 1 - args exists, but do not need to be forwarded; call report_assertion directly
-// 2 - no arguments; call report_assertion directly
-
-#define BOOST_TEST_TOOL_PASS_PRED0( P, ARGS ) P
-#define BOOST_TEST_TOOL_PASS_PRED1( P, ARGS ) P BOOST_PP_SEQ_TO_TUPLE(ARGS)
-#define BOOST_TEST_TOOL_PASS_PRED2( P, ARGS ) P
-
-#define BOOST_TEST_TOOL_PASS_ARG( r, _, arg ) , arg, BOOST_STRINGIZE( arg )
-#define BOOST_TEST_TOOL_PASS_ARG_DSCR( r, _, arg ) , BOOST_STRINGIZE( arg )
-
-#define BOOST_TEST_TOOL_PASS_ARGS0( ARGS ) \
-    BOOST_PP_SEQ_FOR_EACH( BOOST_TEST_TOOL_PASS_ARG, _, ARGS )
-#define BOOST_TEST_TOOL_PASS_ARGS1( ARGS ) \
-    , BOOST_PP_SEQ_SIZE(ARGS) BOOST_PP_SEQ_FOR_EACH( BOOST_TEST_TOOL_PASS_ARG_DSCR, _, ARGS )
-#define BOOST_TEST_TOOL_PASS_ARGS2( ARGS ) \
-    , 0
-
-#define BOOST_TEST_TOOL_IMPL( frwd_type, P, assertion_descr, TL, CT, ARGS )     \
-do {                                                                            \
-    BOOST_TEST_PASSPOINT();                                                     \
-    ::boost::test_tools::tt_detail::                                            \
-    BOOST_PP_IF( frwd_type, report_assertion, check_frwd ) (                    \
-        BOOST_JOIN( BOOST_TEST_TOOL_PASS_PRED, frwd_type )( P, ARGS ),          \
-        BOOST_TEST_LAZY_MSG( assertion_descr ),                                 \
-        BOOST_TEST_L(__FILE__),                                                 \
-        static_cast<std::size_t>(__LINE__),                                     \
-        ::boost::test_tools::tt_detail::TL,                                     \
-        ::boost::test_tools::tt_detail::CT                                      \
-        BOOST_JOIN( BOOST_TEST_TOOL_PASS_ARGS, frwd_type )( ARGS ) );           \
-} while( ::boost::test_tools::tt_detail::dummy_cond() )                         \
-/**/
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN( P )                     BOOST_TEST_TOOL_IMPL( 2, \
-    (P), BOOST_TEST_STRINGIZE( P ), WARN, CHECK_PRED, _ )
-#define BOOST_CHECK( P )                    BOOST_TEST_TOOL_IMPL( 2, \
-    (P), BOOST_TEST_STRINGIZE( P ), CHECK, CHECK_PRED, _ )
-#define BOOST_REQUIRE( P )                  BOOST_TEST_TOOL_IMPL( 2, \
-    (P), BOOST_TEST_STRINGIZE( P ), REQUIRE, CHECK_PRED, _ )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_MESSAGE( P, M )          BOOST_TEST_TOOL_IMPL( 2, (P), M, WARN, CHECK_MSG, _ )
-#define BOOST_CHECK_MESSAGE( P, M )         BOOST_TEST_TOOL_IMPL( 2, (P), M, CHECK, CHECK_MSG, _ )
-#define BOOST_REQUIRE_MESSAGE( P, M )       BOOST_TEST_TOOL_IMPL( 2, (P), M, REQUIRE, CHECK_MSG, _ )
-
-//____________________________________________________________________________//
-
-#define BOOST_ERROR( M )                    BOOST_CHECK_MESSAGE( false, M )
-#define BOOST_FAIL( M )                     BOOST_REQUIRE_MESSAGE( false, M )
-
-//____________________________________________________________________________//
-
-#define BOOST_CHECK_THROW_IMPL( S, E, P, postfix, TL )                                   \
-do {                                                                                    \
-    try {                                                                               \
-        BOOST_TEST_PASSPOINT();                                                         \
-        S;                                                                              \
-        BOOST_TEST_TOOL_IMPL( 2, false, "exception " BOOST_STRINGIZE(E) " expected but not raised", \
-                              TL, CHECK_MSG, _ );                                       \
-    } catch( E const& ex ) {                                                            \
-        ::boost::unit_test::ut_detail::ignore_unused_variable_warning( ex );            \
-        BOOST_TEST_TOOL_IMPL( 2, P, \
-                              "exception \"" BOOST_STRINGIZE( E )"\" raised as expected" postfix,           \
-                              TL, CHECK_MSG, _  );                                      \
-    }                                                                                   \
-} while( ::boost::test_tools::tt_detail::dummy_cond() )                                 \
-/**/
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_THROW( S, E )            BOOST_CHECK_THROW_IMPL( S, E, true, "", WARN )
-#define BOOST_CHECK_THROW( S, E )           BOOST_CHECK_THROW_IMPL( S, E, true, "", CHECK )
-#define BOOST_REQUIRE_THROW( S, E )         BOOST_CHECK_THROW_IMPL( S, E, true, "", REQUIRE )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_EXCEPTION( S, E, P )     BOOST_CHECK_THROW_IMPL( S, E, P( ex ), \
-              ": validation on the raised exception through predicate \"" BOOST_STRINGIZE(P) "\"", WARN )
-#define BOOST_CHECK_EXCEPTION( S, E, P )    BOOST_CHECK_THROW_IMPL( S, E, P( ex ), \
-              ": validation on the raised exception through predicate \"" BOOST_STRINGIZE(P) "\"", CHECK )
-#define BOOST_REQUIRE_EXCEPTION( S, E, P )  BOOST_CHECK_THROW_IMPL( S, E, P( ex ), \
-              ": validation on the raised exception through predicate \"" BOOST_STRINGIZE(P) "\"", REQUIRE )
-
-//____________________________________________________________________________//
-
-#define BOOST_CHECK_NO_THROW_IMPL( S, TL )                                              \
-do {                                                                                    \
-    try {                                                                               \
-        S;                                                                              \
-        BOOST_TEST_TOOL_IMPL( 2, true, "no exceptions thrown by " BOOST_STRINGIZE( S ), \
-                              TL, CHECK_MSG, _ );                                       \
-    } catch( ... ) {                                                                    \
-        BOOST_TEST_TOOL_IMPL( 2, false, "unexpected exception thrown by " BOOST_STRINGIZE( S ),    \
-                              TL, CHECK_MSG, _ );                                       \
-    }                                                                                   \
-} while( ::boost::test_tools::tt_detail::dummy_cond() )                                 \
-/**/
-
-#define BOOST_WARN_NO_THROW( S )            BOOST_CHECK_NO_THROW_IMPL( S, WARN )
-#define BOOST_CHECK_NO_THROW( S )           BOOST_CHECK_NO_THROW_IMPL( S, CHECK )
-#define BOOST_REQUIRE_NO_THROW( S )         BOOST_CHECK_NO_THROW_IMPL( S, REQUIRE )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_EQUAL( L, R )            BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::tt_detail::equal_impl_frwd(), "", WARN, CHECK_EQUAL, (L)(R) )
-#define BOOST_CHECK_EQUAL( L, R )           BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::tt_detail::equal_impl_frwd(), "", CHECK, CHECK_EQUAL, (L)(R) )
-#define BOOST_REQUIRE_EQUAL( L, R )         BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::tt_detail::equal_impl_frwd(), "", REQUIRE, CHECK_EQUAL, (L)(R) )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_NE( L, R )               BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::tt_detail::ne_impl(), "", WARN, CHECK_NE, (L)(R) )
-#define BOOST_CHECK_NE( L, R )              BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::tt_detail::ne_impl(), "", CHECK, CHECK_NE, (L)(R) )
-#define BOOST_REQUIRE_NE( L, R )            BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::tt_detail::ne_impl(), "", REQUIRE, CHECK_NE, (L)(R) )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_LT( L, R )               BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::tt_detail::lt_impl(), "", WARN, CHECK_LT, (L)(R) )
-#define BOOST_CHECK_LT( L, R )              BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::tt_detail::lt_impl(), "", CHECK, CHECK_LT, (L)(R) )
-#define BOOST_REQUIRE_LT( L, R )            BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::tt_detail::lt_impl(), "", REQUIRE, CHECK_LT, (L)(R) )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_LE( L, R )               BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::tt_detail::le_impl(), "", WARN, CHECK_LE, (L)(R) )
-#define BOOST_CHECK_LE( L, R )              BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::tt_detail::le_impl(), "", CHECK, CHECK_LE, (L)(R) )
-#define BOOST_REQUIRE_LE( L, R )            BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::tt_detail::le_impl(), "", REQUIRE, CHECK_LE, (L)(R) )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_GT( L, R )               BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::tt_detail::gt_impl(), "", WARN, CHECK_GT, (L)(R) )
-#define BOOST_CHECK_GT( L, R )              BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::tt_detail::gt_impl(), "", CHECK, CHECK_GT, (L)(R) )
-#define BOOST_REQUIRE_GT( L, R )            BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::tt_detail::gt_impl(), "", REQUIRE, CHECK_GT, (L)(R) )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_GE( L, R )               BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::tt_detail::ge_impl(), "", WARN, CHECK_GE, (L)(R) )
-#define BOOST_CHECK_GE( L, R )              BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::tt_detail::ge_impl(), "", CHECK, CHECK_GE, (L)(R) )
-#define BOOST_REQUIRE_GE( L, R )            BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::tt_detail::ge_impl(), "", REQUIRE, CHECK_GE, (L)(R) )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_CLOSE( L, R, T )         BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::check_is_close_t(), "", WARN, CHECK_CLOSE, (L)(R)(::boost::math::fpc::percent_tolerance(T)) )
-#define BOOST_CHECK_CLOSE( L, R, T )        BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::check_is_close_t(), "", CHECK, CHECK_CLOSE, (L)(R)(::boost::math::fpc::percent_tolerance(T)) )
-#define BOOST_REQUIRE_CLOSE( L, R, T )      BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::check_is_close_t(), "", REQUIRE, CHECK_CLOSE, (L)(R)(::boost::math::fpc::percent_tolerance(T)) )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_CLOSE_FRACTION(L, R, T)  BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::check_is_close_t(), "", WARN, CHECK_CLOSE_FRACTION, (L)(R)(T) )
-#define BOOST_CHECK_CLOSE_FRACTION(L, R, T) BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::check_is_close_t(), "", CHECK, CHECK_CLOSE_FRACTION, (L)(R)(T) )
-#define BOOST_REQUIRE_CLOSE_FRACTION(L,R,T) BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::check_is_close_t(), "", REQUIRE, CHECK_CLOSE_FRACTION, (L)(R)(T) )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_SMALL( FPV, T )          BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::check_is_small_t(), "", WARN, CHECK_SMALL, (FPV)(T) )
-#define BOOST_CHECK_SMALL( FPV, T )         BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::check_is_small_t(), "", CHECK, CHECK_SMALL, (FPV)(T) )
-#define BOOST_REQUIRE_SMALL( FPV, T )       BOOST_TEST_TOOL_IMPL( 0, \
-    ::boost::test_tools::check_is_small_t(), "", REQUIRE, CHECK_SMALL, (FPV)(T) )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_PREDICATE( P, ARGS )     BOOST_TEST_TOOL_IMPL( 0, \
-    P, BOOST_TEST_STRINGIZE( P ), WARN, CHECK_PRED_WITH_ARGS, ARGS )
-#define BOOST_CHECK_PREDICATE( P, ARGS )    BOOST_TEST_TOOL_IMPL( 0, \
-    P, BOOST_TEST_STRINGIZE( P ), CHECK, CHECK_PRED_WITH_ARGS, ARGS )
-#define BOOST_REQUIRE_PREDICATE( P, ARGS )  BOOST_TEST_TOOL_IMPL( 0, \
-    P, BOOST_TEST_STRINGIZE( P ), REQUIRE, CHECK_PRED_WITH_ARGS, ARGS )
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_EQUAL_COLLECTIONS( L_begin, L_end, R_begin, R_end )                  \
-    BOOST_TEST_TOOL_IMPL( 1, ::boost::test_tools::tt_detail::equal_coll_impl(),         \
-        "", WARN, CHECK_EQUAL_COLL, (L_begin)(L_end)(R_begin)(R_end) )                  \
-/**/
-#define BOOST_CHECK_EQUAL_COLLECTIONS( L_begin, L_end, R_begin, R_end )                 \
-    BOOST_TEST_TOOL_IMPL( 1, ::boost::test_tools::tt_detail::equal_coll_impl(),         \
-        "", CHECK, CHECK_EQUAL_COLL, (L_begin)(L_end)(R_begin)(R_end) )                 \
-/**/
-#define BOOST_REQUIRE_EQUAL_COLLECTIONS( L_begin, L_end, R_begin, R_end )               \
-    BOOST_TEST_TOOL_IMPL( 1, ::boost::test_tools::tt_detail::equal_coll_impl(),         \
-        "", REQUIRE, CHECK_EQUAL_COLL, (L_begin)(L_end)(R_begin)(R_end) )               \
-/**/
-
-//____________________________________________________________________________//
-
-#define BOOST_WARN_BITWISE_EQUAL( L, R )    BOOST_TEST_TOOL_IMPL( 1, \
-    ::boost::test_tools::tt_detail::bitwise_equal_impl(), "", WARN, CHECK_BITWISE_EQUAL, (L)(R) )
-#define BOOST_CHECK_BITWISE_EQUAL( L, R )   BOOST_TEST_TOOL_IMPL( 1, \
-    ::boost::test_tools::tt_detail::bitwise_equal_impl(), "", CHECK, CHECK_BITWISE_EQUAL, (L)(R) )
-#define BOOST_REQUIRE_BITWISE_EQUAL( L, R ) BOOST_TEST_TOOL_IMPL( 1, \
-    ::boost::test_tools::tt_detail::bitwise_equal_impl(), "", REQUIRE, CHECK_BITWISE_EQUAL, (L)(R) )
-
-//____________________________________________________________________________//
-
-#define BOOST_IS_DEFINED( symb ) ::boost::test_tools::tt_detail::is_defined_impl( #symb, BOOST_STRINGIZE(= symb) )
-
-//____________________________________________________________________________//
-
-#ifdef BOOST_TEST_NO_NEW_TOOLS
-
-#define BOOST_TEST_WARN( P )                BOOST_WARN( P )
-#define BOOST_TEST_CHECK( P )               BOOST_CHECK( P )
-#define BOOST_TEST_REQUIRE( P )             BOOST_REQUIRE( P )
-
-#define BOOST_TEST( P )                     BOOST_CHECK( P )
-
-#endif
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TOOLS_OLD_INTERFACE_HPP_111712GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tools/output_test_stream.hpp b/contrib/libboost/boost_1_62_0/boost/test/tools/output_test_stream.hpp
deleted file mode 100644
index 2abbf7b5219..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tools/output_test_stream.hpp
+++ /dev/null
@@ -1,107 +0,0 @@
-//  (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
-/// @brief output_test_stream class definition
-// ***************************************************************************
-
-#ifndef BOOST_TEST_OUTPUT_TEST_STREAM_HPP_012705GER
-#define BOOST_TEST_OUTPUT_TEST_STREAM_HPP_012705GER
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/utils/wrap_stringstream.hpp>
-#include <boost/test/tools/assertion_result.hpp>
-
-// STL
-#include <cstddef>          // for std::size_t
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************               output_test_stream             ************** //
-// ************************************************************************** //
-
-
-
-namespace boost {
-namespace test_tools {
-
-//! Class to be used to simplify testing of ostream-based output operations
-class BOOST_TEST_DECL output_test_stream : public wrap_stringstream::wrapped_stream {
-    typedef unit_test::const_string const_string;
-public:
-    //! Constructor
-    //!
-    //!@param[in] pattern_file_name indicates the name of the file for matching. If the
-    //!           string is empty, the standard input or output streams are used instead
-    //!           (depending on match_or_save)
-    //!@param[in] match_or_save if true, the pattern file will be read, otherwise it will be
-    //!           written
-    //!@param[in] text_or_binary if false, opens the stream in binary mode. Otherwise the stream
-    //!           is opened with default flags and the carriage returns are ignored.
-    explicit        output_test_stream( const_string    pattern_file_name = const_string(),
-                                        bool            match_or_save     = true,
-                                        bool            text_or_binary    = true );
-
-    // Destructor
-    virtual ~output_test_stream();
-
-    //! Checks if the stream is empty
-    //!
-    //!@param[in] flush_stream if true, flushes the stream after the call
-    virtual assertion_result    is_empty( bool flush_stream = true );
-
-    //! Checks the length of the stream
-    //!
-    //!@param[in] length target length
-    //!@param[in] flush_stream if true, flushes the stream after the call. Set to false to call
-    //!           additional checks on the same content.
-    virtual assertion_result    check_length( std::size_t length, bool flush_stream = true );
-
-    //! Checks the content of the stream against a string
-    //!
-    //!@param[in] arg_ the target stream
-    //!@param[in] flush_stream if true, flushes the stream after the call.
-    virtual assertion_result    is_equal( const_string arg_, bool flush_stream = true );
-
-    //! Checks the content of the stream against a pattern file
-    //!
-    //!@param[in] flush_stream if true, flushes/resets the stream after the call.
-    virtual assertion_result    match_pattern( bool flush_stream = true );
-
-    //! Flushes the stream
-    void            flush();
-
-protected:
-
-    //! Returns the string representation of the stream
-    //!
-    //! May be overriden in order to mutate the string before the matching operations.
-    virtual std::string get_stream_string_representation() const;
-
-private:
-    // helper functions
-
-    //! Length of the stream
-    std::size_t     length();
-
-    //! Synching the stream into an internal string representation
-    virtual void    sync();
-
-    struct Impl;
-    Impl*           m_pimpl;
-};
-
-} // namespace test_tools
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_OUTPUT_TEST_STREAM_HPP_012705GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tree/auto_registration.hpp b/contrib/libboost/boost_1_62_0/boost/test/tree/auto_registration.hpp
deleted file mode 100644
index a3fe32fda7f..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tree/auto_registration.hpp
+++ /dev/null
@@ -1,53 +0,0 @@
-//  (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: 74640 $
-//
-//  Description : defines auto_test_unit_registrar
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TREE_AUTO_REGISTRATION_HPP_100211GER
-#define BOOST_TEST_TREE_AUTO_REGISTRATION_HPP_100211GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/tree/decorator.hpp>
-#include <boost/test/tree/test_unit.hpp>
-
-// STL
-#include <list>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace ut_detail {
-
-// ************************************************************************** //
-// **************           auto_test_unit_registrar           ************** //
-// ************************************************************************** //
-
-struct BOOST_TEST_DECL auto_test_unit_registrar {
-    // Constructors
-                auto_test_unit_registrar( test_case* tc, decorator::collector& decorators, counter_t exp_fail = 0 );
-    explicit    auto_test_unit_registrar( const_string ts_name, const_string ts_file, std::size_t ts_line, decorator::collector& decorators );
-    explicit    auto_test_unit_registrar( test_unit_generator const& tc_gen, decorator::collector& decorators );
-    explicit    auto_test_unit_registrar( int );
-};
-
-} // namespace ut_detail
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TREE_AUTO_REGISTRATION_HPP_100211GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tree/decorator.hpp b/contrib/libboost/boost_1_62_0/boost/test/tree/decorator.hpp
deleted file mode 100644
index 27c46682a0c..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tree/decorator.hpp
+++ /dev/null
@@ -1,277 +0,0 @@
-//  (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: 62016 $
-//
-//  Description : defines decorators to be using with auto registered test units
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TREE_DECORATOR_HPP_091911GER
-#define BOOST_TEST_TREE_DECORATOR_HPP_091911GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/detail/global_typedef.hpp>
-
-#include <boost/test/tree/fixture.hpp>
-
-#include <boost/test/tools/assertion_result.hpp>
-
-#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
-#include <boost/test/utils/trivial_singleton.hpp>
-
-// Boost
-#include <boost/shared_ptr.hpp>
-#include <boost/function/function0.hpp>
-#include <boost/function/function1.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-// STL
-#include <vector>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-class test_unit;
-
-namespace decorator {
-
-// ************************************************************************** //
-// **************             decorator::collector             ************** //
-// ************************************************************************** //
-
-class base;
-typedef boost::shared_ptr<base> base_ptr;
-
-class BOOST_TEST_DECL collector : public singleton<collector> {
-public:
-    collector&              operator*( base const& d );
-
-    void                    store_in( test_unit& tu );
-
-    void                    reset();
-
-private:
-    BOOST_TEST_SINGLETON_CONS( collector )
-
-    // Data members
-    std::vector<base_ptr>   m_tu_decorators;
-};
-
-// ************************************************************************** //
-// **************               decorator::base                ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL base {
-public:
-    // composition interface
-    collector&              operator*() const;
-
-    // application interface
-    virtual void            apply( test_unit& tu ) = 0;
-
-    // deep cloning interface
-    virtual base_ptr        clone() const = 0;
-
-protected:
-    virtual ~base() {}
-};
-
-// ************************************************************************** //
-// **************               decorator::label               ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL label : public decorator::base {
-public:
-    explicit                label( const_string l ) : m_label( l ) {}
-
-private:
-    // decorator::base interface
-    virtual void            apply( test_unit& tu );
-    virtual base_ptr        clone() const { return base_ptr(new label( m_label )); }
-
-    // Data members
-    const_string            m_label;
-};
-
-// ************************************************************************** //
-// **************         decorator::expected_failures         ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL expected_failures : public decorator::base {
-public:
-    explicit                expected_failures( counter_t ef ) : m_exp_fail( ef ) {}
-
-private:
-    // decorator::base interface
-    virtual void            apply( test_unit& tu );
-    virtual base_ptr        clone() const { return base_ptr(new expected_failures( m_exp_fail )); }
-
-    // Data members
-    counter_t               m_exp_fail;
-};
-
-// ************************************************************************** //
-// **************              decorator::timeout              ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL timeout : public decorator::base {
-public:
-    explicit                timeout( unsigned t ) : m_timeout( t ) {}
-
-private:
-    // decorator::base interface
-    virtual void            apply( test_unit& tu );
-    virtual base_ptr        clone() const { return base_ptr(new timeout( m_timeout )); }
-
-    // Data members
-    unsigned                m_timeout;
-};
-
-// ************************************************************************** //
-// **************            decorator::description            ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL description : public decorator::base {
-public:
-    explicit                description( const_string descr ) : m_description( descr ) {}
-
-private:
-    // decorator::base interface
-    virtual void            apply( test_unit& tu );
-    virtual base_ptr        clone() const { return base_ptr(new description( m_description )); }
-
-    // Data members
-    const_string            m_description;
-};
-
-// ************************************************************************** //
-// **************            decorator::depends_on             ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL depends_on : public decorator::base {
-public:
-    explicit                depends_on( const_string dependency ) : m_dependency( dependency ) {}
-
-private:
-    // decorator::base interface
-    virtual void            apply( test_unit& tu );
-    virtual base_ptr        clone() const { return base_ptr(new depends_on( m_dependency )); }
-
-    // Data members
-    const_string            m_dependency;
-};
-
-// ************************************************************************** //
-// **************    decorator::enable_if/enabled/disabled     ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL enable_if_impl : public decorator::base {
-protected:
-    void                    apply_impl( test_unit& tu, bool condition );
-};
-
-template<bool condition>
-class enable_if : public enable_if_impl {
-private:
-    // decorator::base interface
-    virtual void            apply( test_unit& tu )   { this->apply_impl( tu, condition ); }
-    virtual base_ptr        clone() const            { return base_ptr(new enable_if<condition>()); }
-};
-
-typedef enable_if<true> enabled;
-typedef enable_if<false> disabled;
-
-// ************************************************************************** //
-// **************              decorator::fixture              ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL fixture_t : public decorator::base {
-public:
-    // Constructor
-    explicit                fixture_t( test_unit_fixture_ptr impl ) : m_impl( impl ) {}
-
-private:
-    // decorator::base interface
-    virtual void            apply( test_unit& tu );
-    virtual base_ptr        clone() const { return base_ptr(new fixture_t( m_impl )); }
-
-    // Data members
-    test_unit_fixture_ptr m_impl;
-};
-
-//____________________________________________________________________________//
-
-template<typename F>
-inline fixture_t
-fixture()
-{
-    return fixture_t( test_unit_fixture_ptr( new unit_test::class_based_fixture<F>() ) );
-}
-
-//____________________________________________________________________________//
-
-template<typename F, typename Arg>
-inline fixture_t
-fixture( Arg const& arg )
-{
-    return fixture_t( test_unit_fixture_ptr( new unit_test::class_based_fixture<F,Arg>( arg ) ) );
-}
-
-//____________________________________________________________________________//
-
-inline fixture_t
-fixture( boost::function<void()> const& setup, boost::function<void()> const& teardown = boost::function<void()>() )
-{
-    return fixture_t( test_unit_fixture_ptr( new unit_test::function_based_fixture( setup, teardown ) ) );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************            decorator::depends_on             ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL precondition : public decorator::base {
-public:
-    typedef boost::function<test_tools::assertion_result (test_unit_id)>   predicate_t;
-
-    explicit                precondition( predicate_t p ) : m_precondition( p ) {}
-
-private:
-    // decorator::base interface
-    virtual void            apply( test_unit& tu );
-    virtual base_ptr        clone() const { return base_ptr(new precondition( m_precondition )); }
-
-    // Data members
-    predicate_t             m_precondition;
-};
-
-} // namespace decorator
-
-using decorator::label;
-using decorator::expected_failures;
-using decorator::timeout;
-using decorator::description;
-using decorator::depends_on;
-using decorator::enable_if;
-using decorator::enabled;
-using decorator::disabled;
-using decorator::fixture;
-using decorator::precondition;
-
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TREE_DECORATOR_HPP_091911GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tree/fixture.hpp b/contrib/libboost/boost_1_62_0/boost/test/tree/fixture.hpp
deleted file mode 100644
index 7bca5a8de3c..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tree/fixture.hpp
+++ /dev/null
@@ -1,116 +0,0 @@
-//  (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: 74640 $
-//
-//  Description : defines fixture interface and object makers
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TREE_FIXTURE_HPP_100311GER
-#define BOOST_TEST_TREE_FIXTURE_HPP_100311GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-
-// Boost
-#include <boost/shared_ptr.hpp>
-#include <boost/scoped_ptr.hpp>
-#include <boost/function/function0.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************               test_unit_fixture              ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL test_unit_fixture {
-public:
-    virtual ~test_unit_fixture() {}
-
-    // Fixture interface
-    virtual void    setup() = 0;
-    virtual void    teardown() = 0;
-};
-
-typedef shared_ptr<test_unit_fixture> test_unit_fixture_ptr;
-
-// ************************************************************************** //
-// **************              class_based_fixture             ************** //
-// ************************************************************************** //
-
-template<typename F, typename Arg=void>
-class class_based_fixture : public test_unit_fixture {
-public:
-    // Constructor
-    explicit class_based_fixture( Arg const& arg ) : m_inst(), m_arg( arg ) {}
-
-private:
-    // Fixture interface
-    virtual void    setup()         { m_inst.reset( new F( m_arg ) ); }
-    virtual void    teardown()      { m_inst.reset(); }
-
-    // Data members
-    scoped_ptr<F>   m_inst;
-    Arg             m_arg;
-};
-
-//____________________________________________________________________________//
-
-template<typename F>
-class class_based_fixture<F,void> : public test_unit_fixture {
-public:
-    // Constructor
-    class_based_fixture() : m_inst( 0 ) {}
-
-private:
-    // Fixture interface
-    virtual void    setup()         { m_inst.reset( new F ); }
-    virtual void    teardown()      { m_inst.reset(); }
-
-    // Data members
-    scoped_ptr<F>   m_inst;
-};
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************            function_based_fixture            ************** //
-// ************************************************************************** //
-
-class function_based_fixture : public test_unit_fixture {
-public:
-    // Constructor
-    function_based_fixture( boost::function<void ()> const& setup_, boost::function<void ()> const& teardown_ )
-    : m_setup( setup_ )
-    , m_teardown( teardown_ )
-    {
-    }
-
-private:
-    // Fixture interface
-    virtual void                setup()     { if( m_setup ) m_setup(); }
-    virtual void                teardown()  { if( m_teardown ) m_teardown(); }
-
-    // Data members
-    boost::function<void ()>    m_setup;
-    boost::function<void ()>    m_teardown;
-};
-
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TREE_FIXTURE_HPP_100311GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tree/global_fixture.hpp b/contrib/libboost/boost_1_62_0/boost/test/tree/global_fixture.hpp
deleted file mode 100644
index 21145959297..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tree/global_fixture.hpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//  (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
-/// Defines global_fixture
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TREE_GLOBAL_FIXTURE_HPP_091911GER
-#define BOOST_TEST_TREE_GLOBAL_FIXTURE_HPP_091911GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/detail/global_typedef.hpp>
-
-#include <boost/test/tree/observer.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                global_fixture                ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL global_fixture : public test_observer {
-public:
-    // Constructor
-    global_fixture();
-};
-
-//____________________________________________________________________________//
-
-namespace ut_detail {
-
-template<typename F>
-struct global_fixture_impl : public global_fixture {
-    // Constructor
-    global_fixture_impl() : m_fixture( 0 )    {}
-
-    // test observer interface
-    virtual void    test_start( counter_t ) { m_fixture = new F; }
-    virtual void    test_finish()           { delete m_fixture; m_fixture = 0; }
-    virtual void    test_aborted()          { delete m_fixture; m_fixture = 0; }
-
-private:
-    // Data members
-    F*  m_fixture;
-};
-
-} // namespace ut_detail
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TREE_GLOBAL_FIXTURE_HPP_091911GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tree/observer.hpp b/contrib/libboost/boost_1_62_0/boost/test/tree/observer.hpp
deleted file mode 100644
index 4db930fb074..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tree/observer.hpp
+++ /dev/null
@@ -1,116 +0,0 @@
-//  (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
-//!@brief defines abstract interface for test observer
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TEST_OBSERVER_HPP_021005GER
-#define BOOST_TEST_TEST_OBSERVER_HPP_021005GER
-
-// Boost.Test
-#include <boost/test/detail/fwd_decl.hpp>
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/config.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                 test_observer                ************** //
-// ************************************************************************** //
-
-/// @brief Generic test observer interface
-///
-/// This interface is used by observers in order to receive notifications from the
-/// Boost.Test framework on the current execution state.
-///
-/// Several observers can be running at the same time, and it is not unusual to
-/// have interactions among them. The test_observer#priority member function allows the specification
-/// of a particular order among them (lowest priority executed first, except specified otherwise).
-///
-class BOOST_TEST_DECL test_observer {
-public:
-
-    //! Called before the framework starts executing the test cases
-    //!
-    //! @param[in] number_of_test_cases indicates the number of test cases. Only active
-    //! test cases are taken into account.
-    //!
-    virtual void    test_start( counter_t /* number_of_test_cases */ ) {}
-
-
-    //! Called after the framework ends executing the test cases
-    //!
-    //! @note The call is made with a reversed priority order.
-    virtual void    test_finish() {}
-
-    //! Called when a critical error is detected
-    //!
-    //! The critical errors are mainly the signals sent by the system and caught by the Boost.Test framework.
-    //! Since the running binary may be in incoherent/instable state, the test execution is aborted and all remaining
-    //! tests are discarded.
-    //!
-    //! @note may be called before test_observer::test_unit_finish()
-    virtual void    test_aborted() {}
-
-    //! Called before the framework starts executing a test unit
-    //!
-    //! @param[in] test_unit the test being executed
-    virtual void    test_unit_start( test_unit const& /* test */) {}
-
-    //! Called at each end of a test unit.
-    //!
-    //! @param elapsed duration of the test unit in microseconds.
-    virtual void    test_unit_finish( test_unit const& /* test */, unsigned long /* elapsed */ ) {}
-    virtual void    test_unit_skipped( test_unit const& tu, const_string ) { test_unit_skipped( tu ); }
-    virtual void    test_unit_skipped( test_unit const& ) {} ///< backward compatibility
-
-    //! Called when a test unit indicates a fatal error.
-    //!
-    //! A fatal error happens when
-    //! - a strong assertion (with @c REQUIRE) fails, which indicates that the test case cannot continue
-    //! - an unexpected exception is caught by the Boost.Test framework
-    virtual void    test_unit_aborted( test_unit const& ) {}
-
-    virtual void    assertion_result( unit_test::assertion_result ar )
-    {
-        switch( ar ) {
-        case AR_PASSED: assertion_result( true ); break;
-        case AR_FAILED: assertion_result( false ); break;
-        case AR_TRIGGERED: break;
-        default: break;
-        }
-    }
-
-    //! Called when an exception is intercepted
-    //!
-    //! In case an exception is intercepted, this call happens before the call
-    //! to @ref test_unit_aborted in order to log
-    //! additional data about the exception.
-    virtual void    exception_caught( execution_exception const& ) {}
-
-    virtual int     priority() { return 0; }
-
-protected:
-    //! Deprecated
-    virtual void    assertion_result( bool /* passed */ ) {}
-
-    BOOST_TEST_PROTECTED_VIRTUAL ~test_observer() {}
-};
-
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TEST_OBSERVER_HPP_021005GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tree/test_case_counter.hpp b/contrib/libboost/boost_1_62_0/boost/test/tree/test_case_counter.hpp
deleted file mode 100644
index a74f37f152e..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tree/test_case_counter.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//  (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
-/// Defines @ref test_case_counter
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TREE_TEST_CASE_COUNTER_HPP_100211GER
-#define BOOST_TEST_TREE_TEST_CASE_COUNTER_HPP_100211GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/utils/class_properties.hpp>
-
-#include <boost/test/tree/test_unit.hpp>
-#include <boost/test/tree/visitor.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                test_case_counter             ************** //
-// ************************************************************************** //
-
-///! Counts the number of enabled test cases
-class test_case_counter : public test_tree_visitor {
-public:
-    // Constructor
-    test_case_counter() : p_count( 0 ) {}
-
-    BOOST_READONLY_PROPERTY( counter_t, (test_case_counter)) p_count;
-private:
-    // test tree visitor interface
-    virtual void    visit( test_case const& tc )                { if( tc.is_enabled() ) ++p_count.value; }
-    virtual bool    test_suite_start( test_suite const& ts )    { return ts.is_enabled(); }
-};
-
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TREE_TEST_CASE_COUNTER_HPP_100211GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tree/test_case_template.hpp b/contrib/libboost/boost_1_62_0/boost/test/tree/test_case_template.hpp
deleted file mode 100644
index 56871b7b6b5..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tree/test_case_template.hpp
+++ /dev/null
@@ -1,144 +0,0 @@
-//  (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: -1 $
-//
-//  Description : defines template_test_case_gen
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TREE_TEST_CASE_TEMPLATE_HPP_091911GER
-#define BOOST_TEST_TREE_TEST_CASE_TEMPLATE_HPP_091911GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/fwd_decl.hpp>
-#include <boost/test/detail/workaround.hpp>
-
-#include <boost/test/utils/class_properties.hpp>
-
-#include <boost/test/tree/observer.hpp>
-
-
-// Boost
-#include <boost/shared_ptr.hpp>
-#include <boost/mpl/for_each.hpp>
-#include <boost/mpl/identity.hpp>
-#include <boost/type.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/function/function0.hpp>
-
-#ifndef BOOST_NO_RTTI
-#include <typeinfo> // for typeid
-#else
-#include <boost/current_function.hpp>
-#endif
-
-// STL
-#include <string>   // for std::string
-#include <list>     // for std::list
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace ut_detail {
-
-// ************************************************************************** //
-// **************          test_case_template_invoker          ************** //
-// ************************************************************************** //
-
-template<typename TestCaseTemplate,typename TestType>
-class test_case_template_invoker {
-public:
-    void    operator()()    { TestCaseTemplate::run( (boost::type<TestType>*)0 ); }
-};
-
-// ************************************************************************** //
-// **************           generate_test_case_4_type          ************** //
-// ************************************************************************** //
-
-template<typename Generator,typename TestCaseTemplate>
-struct generate_test_case_4_type {
-    explicit    generate_test_case_4_type( const_string tc_name, const_string tc_file, std::size_t tc_line, Generator& G )
-    : m_test_case_name( tc_name )
-    , m_test_case_file( tc_file )
-    , m_test_case_line( tc_line )
-    , m_holder( G )
-    {}
-
-    template<typename TestType>
-    void        operator()( mpl::identity<TestType> )
-    {
-        std::string full_name;
-        assign_op( full_name, m_test_case_name, 0 );
-        full_name += '<';
-#ifndef BOOST_NO_RTTI
-         full_name += typeid(TestType).name();
-#else
-        full_name += BOOST_CURRENT_FUNCTION;
-#endif
-        if( boost::is_const<TestType>::value )
-            full_name += "_const";
-        full_name += '>';
-
-        m_holder.m_test_cases.push_back( new test_case( ut_detail::normalize_test_case_name( full_name ),
-                                                        m_test_case_file,
-                                                        m_test_case_line,
-                                                        test_case_template_invoker<TestCaseTemplate,TestType>() ) );
-    }
-
-private:
-    // Data members
-    const_string    m_test_case_name;
-    const_string    m_test_case_file;
-    std::size_t     m_test_case_line;
-    Generator&      m_holder;
-};
-
-// ************************************************************************** //
-// **************              test_case_template              ************** //
-// ************************************************************************** //
-
-template<typename TestCaseTemplate,typename TestTypesList>
-class template_test_case_gen : public test_unit_generator {
-public:
-    // Constructor
-    template_test_case_gen( const_string tc_name, const_string tc_file, std::size_t tc_line )
-    {
-        typedef generate_test_case_4_type<template_test_case_gen<TestCaseTemplate,TestTypesList>,TestCaseTemplate> single_test_gen;
-
-        mpl::for_each<TestTypesList,mpl::make_identity<mpl::_> >( single_test_gen( tc_name, tc_file, tc_line, *this ) );
-    }
-
-    virtual test_unit* next() const
-    {
-        if( m_test_cases.empty() )
-            return 0;
-
-        test_unit* res = m_test_cases.front();
-        m_test_cases.pop_front();
-
-        return res;
-    }
-
-    // Data members
-    mutable std::list<test_unit*> m_test_cases;
-};
-
-} // namespace ut_detail
-} // unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TREE_TEST_CASE_TEMPLATE_HPP_091911GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tree/test_unit.hpp b/contrib/libboost/boost_1_62_0/boost/test/tree/test_unit.hpp
deleted file mode 100644
index 273fa14ff3d..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tree/test_unit.hpp
+++ /dev/null
@@ -1,275 +0,0 @@
-//  (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
-/// Defines @ref boost::unit_test::test_unit "test_unit", @ref boost::unit_test::test_case "test_case",
-/// @ref boost::unit_test::test_suite "test_suite" and @ref boost::unit_test::master_test_suite_t "master_test_suite_t"
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TREE_TEST_UNIT_HPP_100211GER
-#define BOOST_TEST_TREE_TEST_UNIT_HPP_100211GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/fwd_decl.hpp>
-
-#include <boost/test/tree/decorator.hpp>
-#include <boost/test/tree/fixture.hpp>
-
-#include <boost/test/tools/assertion_result.hpp>
-
-#include <boost/test/utils/class_properties.hpp>
-
-// Boost
-#include <boost/function/function0.hpp>
-#include <boost/function/function1.hpp>
-
-// STL
-#include <vector>
-#include <string>
-#include <map>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-namespace framework {
-class state;
-}
-
-// ************************************************************************** //
-// **************                   test_unit                  ************** //
-// ************************************************************************** //
-
-typedef std::vector<test_unit_id> test_unit_id_list;
-
-class BOOST_TEST_DECL test_unit {
-public:
-    enum { type = TUT_ANY };
-    enum run_status { RS_DISABLED, RS_ENABLED, RS_INHERIT, RS_INVALID };
-
-    typedef std::vector<test_unit_id>                                       id_list;
-    typedef std::vector<test_unit_fixture_ptr>                              fixture_list_t;
-    typedef BOOST_READONLY_PROPERTY(test_unit_id,(framework::state))        id_t;
-    typedef BOOST_READONLY_PROPERTY(test_unit_id,(test_suite))              parent_id_t;
-    typedef BOOST_READONLY_PROPERTY(id_list,(test_unit))                    id_list_t;
-    typedef std::vector<decorator::base_ptr>                                decor_list_t;
-    typedef BOOST_READONLY_PROPERTY(std::vector<std::string>,(test_unit))   label_list_t;
-
-    typedef boost::function<test_tools::assertion_result (test_unit_id)>    precondition_t;
-    typedef BOOST_READONLY_PROPERTY(std::vector<precondition_t>,(test_unit)) precond_list_t;
-
-    // preconditions management
-    void                                depends_on( test_unit* tu );
-    void                                add_precondition( precondition_t const& );
-    test_tools::assertion_result        check_preconditions() const;
-
-    // labels management
-    void                                add_label( const_string l );
-    bool                                has_label( const_string l ) const;
-
-    // helper access methods
-    void                                increase_exp_fail( counter_t num );
-    bool                                is_enabled() const    { return p_run_status == RS_ENABLED; }
-    std::string                         full_name() const;
-
-    // Public r/o properties
-    test_unit_type const                p_type;                 ///< type for this test unit
-    const_string const                  p_type_name;            ///< "case"/"suite"/"module"
-    const_string const                  p_file_name;
-    std::size_t const                   p_line_num;
-    id_t                                p_id;                   ///< unique id for this test unit
-    parent_id_t                         p_parent_id;            ///< parent test suite id
-    label_list_t                        p_labels;               ///< list of labels associated with this test unit
-
-    id_list_t                           p_dependencies;         ///< list of test units this one depends on
-    precond_list_t                      p_preconditions;        ///< user supplied preconditions for this test unit;
-
-    // Public r/w properties
-    readwrite_property<std::string>     p_name;                 ///< name for this test unit
-    readwrite_property<std::string>     p_description;          ///< description for this test unit
-    readwrite_property<unsigned>        p_timeout;              ///< timeout for the test unit execution in seconds
-    readwrite_property<counter_t>       p_expected_failures;    ///< number of expected failures in this test unit
-
-    readwrite_property<run_status>      p_default_status;       ///< run status obtained by this unit during setup phase
-    readwrite_property<run_status>      p_run_status;           ///< run status assigned to this unit before execution phase after applying all filters
-
-    readwrite_property<counter_t>       p_sibling_rank;         ///< rank of this test unit amoung siblings of the same parent
-
-    readwrite_property<decor_list_t>    p_decorators;           ///< automatically assigned decorators; execution is delayed till framework::finalize_setup_phase function
-    readwrite_property<fixture_list_t>  p_fixtures;             ///< fixtures associated with this test unit
-
-protected:
-    ~test_unit();
-    // Constructor
-    test_unit( const_string tu_name, const_string tc_file, std::size_t tc_line, test_unit_type t );
-    // Master test suite constructor
-    explicit                            test_unit( const_string module_name );
-
-private:
-};
-
-// ************************************************************************** //
-// **************              test_unit_generator             ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL test_unit_generator {
-public:
-    virtual test_unit*  next() const = 0;
-
-protected:
-    BOOST_TEST_PROTECTED_VIRTUAL ~test_unit_generator() {}
-};
-
-// ************************************************************************** //
-// **************                   test_case                  ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL test_case : public test_unit {
-public:
-    enum { type = TUT_CASE };
-
-    // Constructor
-    test_case( const_string tc_name, boost::function<void ()> const& test_func );
-    test_case( const_string tc_name, const_string tc_file, std::size_t tc_line, boost::function<void ()> const& test_func );
-
-    // Public property
-    typedef BOOST_READONLY_PROPERTY(boost::function<void ()>,(test_case))  test_func;
-
-    test_func   p_test_func;
-
-private:
-    friend class framework::state;
-    ~test_case() {}
-};
-
-// ************************************************************************** //
-// **************                  test_suite                  ************** //
-// ************************************************************************** //
-
-//! Class representing test suites
-class BOOST_TEST_DECL test_suite : public test_unit {
-public:
-    enum { type = TUT_SUITE };
-
-    // Constructor
-    explicit        test_suite( const_string ts_name, const_string ts_file, std::size_t ts_line );
-
-    // test unit list management
-
-    /*!@brief Adds a test unit to a test suite.
-     *
-     * It is possible to specify the timeout and the expected failures.
-     */
-    void            add( test_unit* tu, counter_t expected_failures = 0, unsigned timeout = 0 );
-
-    /// @overload
-    void            add( test_unit_generator const& gen, unsigned timeout = 0 );
-
-    /// @overload
-    void            add( test_unit_generator const& gen, decorator::collector& decorators );
-
-    //! Removes a test from the test suite.
-    void            remove( test_unit_id id );
-
-
-    // access methods
-    test_unit_id    get( const_string tu_name ) const;
-    std::size_t     size() const { return m_children.size(); }
-
-protected:
-    // Master test suite constructor
-    explicit        test_suite( const_string module_name );
-
-    friend BOOST_TEST_DECL
-    void            traverse_test_tree( test_suite const&, test_tree_visitor&, bool );
-    friend class    framework::state;
-    virtual         ~test_suite() {}
-
-    typedef std::multimap<counter_t,test_unit_id> children_per_rank;
-    // Data members
-
-    test_unit_id_list   m_children;
-    children_per_rank   m_ranked_children; ///< maps child sibling rank to list of children with that rank
-};
-
-// ************************************************************************** //
-// **************               master_test_suite              ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL master_test_suite_t : public test_suite {
-public:
-    master_test_suite_t();
-
-    // Data members
-    int      argc;
-    char**   argv;
-};
-
-// ************************************************************************** //
-// **************            user_tc_method_invoker            ************** //
-// ************************************************************************** //
-
-namespace ut_detail {
-
-BOOST_TEST_DECL std::string normalize_test_case_name( const_string tu_name );
-
-//____________________________________________________________________________//
-
-template<typename InstanceType,typename UserTestCase>
-struct user_tc_method_invoker {
-    typedef void (UserTestCase::*TestMethod )();
-
-    user_tc_method_invoker( shared_ptr<InstanceType> inst, TestMethod test_method )
-    : m_inst( inst ), m_test_method( test_method ) {}
-
-    void operator()() { ((*m_inst).*m_test_method)(); }
-
-    shared_ptr<InstanceType> m_inst;
-    TestMethod               m_test_method;
-};
-
-} // namespace ut_detail
-
-// ************************************************************************** //
-// **************                make_test_case                ************** //
-// ************************************************************************** //
-
-inline test_case*
-make_test_case( boost::function<void ()> const& test_func, const_string tc_name, const_string tc_file, std::size_t tc_line )
-{
-    return new test_case( ut_detail::normalize_test_case_name( tc_name ), tc_file, tc_line, test_func );
-}
-
-//____________________________________________________________________________//
-
-template<typename UserTestCase, typename InstanceType>
-inline test_case*
-make_test_case( void (UserTestCase::*           test_method )(),
-                const_string                    tc_name,
-                const_string                    tc_file,
-                std::size_t                     tc_line,
-                boost::shared_ptr<InstanceType> user_test_case )
-{
-    return new test_case( ut_detail::normalize_test_case_name( tc_name ),
-                          tc_file,
-                          tc_line,
-                          ut_detail::user_tc_method_invoker<InstanceType,UserTestCase>( user_test_case, test_method ) );
-}
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TREE_TEST_UNIT_HPP_100211GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tree/traverse.hpp b/contrib/libboost/boost_1_62_0/boost/test/tree/traverse.hpp
deleted file mode 100644
index d27917cacea..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tree/traverse.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//  (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: -1 $
-//
-//  Description : defines traverse_test_tree algorithm
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TREE_TRAVERSE_HPP_100211GER
-#define BOOST_TEST_TREE_TRAVERSE_HPP_100211GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-
-#include <boost/test/tree/test_unit.hpp>
-#include <boost/test/tree/visitor.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************               traverse_test_tree             ************** //
-// ************************************************************************** //
-
-BOOST_TEST_DECL void    traverse_test_tree( test_case const&, test_tree_visitor&, bool ignore_status = false );
-BOOST_TEST_DECL void    traverse_test_tree( test_suite const&, test_tree_visitor&, bool ignore_status = false );
-BOOST_TEST_DECL void    traverse_test_tree( test_unit_id     , test_tree_visitor&, bool ignore_status = false );
-
-//____________________________________________________________________________//
-
-inline void
-traverse_test_tree( test_unit const& tu, test_tree_visitor& V, bool ignore_status = false )
-{
-    if( tu.p_type == TUT_CASE )
-        traverse_test_tree( static_cast<test_case const&>( tu ), V, ignore_status );
-    else
-        traverse_test_tree( static_cast<test_suite const&>( tu ), V, ignore_status );
-}
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TREE_TRAVERSE_HPP_100211GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/tree/visitor.hpp b/contrib/libboost/boost_1_62_0/boost/test/tree/visitor.hpp
deleted file mode 100644
index 8f1bae5c92b..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/tree/visitor.hpp
+++ /dev/null
@@ -1,52 +0,0 @@
-//  (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: -1 $
-//
-//  Description : defines test_tree_visitor
-// ***************************************************************************
-
-#ifndef BOOST_TEST_TREE_VISITOR_HPP_100211GER
-#define BOOST_TEST_TREE_VISITOR_HPP_100211GER
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-
-#include <boost/test/tree/test_unit.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************               test_tree_visitor              ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL test_tree_visitor {
-public:
-    // test tree visitor interface
-    virtual bool    visit( test_unit const& )               { return true; }
-    virtual void    visit( test_case const& tc )            { visit( (test_unit const&)tc ); }
-    virtual bool    test_suite_start( test_suite const& ts ){ return visit( (test_unit const&)ts ); }
-    virtual void    test_suite_finish( test_suite const& )  {}
-
-protected:
-    BOOST_TEST_PROTECTED_VIRTUAL ~test_tree_visitor() {}
-};
-
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_TREE_VISITOR_HPP_100211GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/unit_test.hpp b/contrib/libboost/boost_1_62_0/boost/test/unit_test.hpp
deleted file mode 100644
index e6a236a1b5b..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/unit_test.hpp
+++ /dev/null
@@ -1,70 +0,0 @@
-//  (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
-/// @brief Entry point into the Unit Test Framework
-///
-/// This header should be the only header necessary to include to start using the framework
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_HPP_071894GER
-#define BOOST_TEST_UNIT_TEST_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/test_tools.hpp>
-#include <boost/test/unit_test_suite.hpp>
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                 Auto Linking                 ************** //
-// ************************************************************************** //
-
-#if !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_TEST_NO_LIB) && \
-    !defined(BOOST_TEST_SOURCE) && !defined(BOOST_TEST_INCLUDED)
-#  define BOOST_LIB_NAME boost_unit_test_framework
-
-#  if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_TEST_DYN_LINK)
-#    define BOOST_DYN_LINK
-#  endif
-
-#  include <boost/config/auto_link.hpp>
-
-#endif  // auto-linking disabled
-
-// ************************************************************************** //
-// **************                  unit_test_main              ************** //
-// ************************************************************************** //
-
-namespace boost { namespace unit_test {
-
-int BOOST_TEST_DECL unit_test_main( init_unit_test_func init_func, int argc, char* argv[] );
-
-}
-
-// !! ?? to remove
-namespace unit_test_framework=unit_test;
-
-}
-
-#if defined(BOOST_TEST_DYN_LINK) && defined(BOOST_TEST_MAIN) && !defined(BOOST_TEST_NO_MAIN)
-
-// ************************************************************************** //
-// **************        main function for tests using dll     ************** //
-// ************************************************************************** //
-
-int BOOST_TEST_CALL_DECL
-main( int argc, char* argv[] )
-{
-    return ::boost::unit_test::unit_test_main( &init_unit_test, argc, argv );
-}
-
-//____________________________________________________________________________//
-
-#endif // BOOST_TEST_DYN_LINK && BOOST_TEST_MAIN && !BOOST_TEST_NO_MAIN
-
-#endif // BOOST_TEST_UNIT_TEST_HPP_071894GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/unit_test_log.hpp b/contrib/libboost/boost_1_62_0/boost/test/unit_test_log.hpp
deleted file mode 100644
index ba998b0ca40..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/unit_test_log.hpp
+++ /dev/null
@@ -1,273 +0,0 @@
-//  (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
-/// @brief defines singleton class unit_test_log and all manipulators.
-/// unit_test_log has output stream like interface. It's implementation is
-/// completely hidden with pimple idiom
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_LOG_HPP_071894GER
-#define BOOST_TEST_UNIT_TEST_LOG_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/tree/observer.hpp>
-
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/log_level.hpp>
-#include <boost/test/detail/fwd_decl.hpp>
-
-#include <boost/test/utils/wrap_stringstream.hpp>
-#include <boost/test/utils/trivial_singleton.hpp>
-#include <boost/test/utils/lazy_ostream.hpp>
-
-// Boost
-
-// STL
-#include <iosfwd>   // for std::ostream&
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                log manipulators              ************** //
-// ************************************************************************** //
-
-namespace log {
-
-struct BOOST_TEST_DECL begin {
-    begin( const_string fn, std::size_t ln )
-    : m_file_name( fn )
-    , m_line_num( ln )
-    {}
-
-    const_string m_file_name;
-    std::size_t m_line_num;
-};
-
-struct end {};
-
-} // namespace log
-
-// ************************************************************************** //
-// **************             entry_value_collector            ************** //
-// ************************************************************************** //
-
-namespace ut_detail {
-
-class BOOST_TEST_DECL entry_value_collector {
-public:
-    // Constructors
-    entry_value_collector() : m_last( true ) {}
-    entry_value_collector( entry_value_collector const& rhs ) : m_last( true ) { rhs.m_last = false; }
-    ~entry_value_collector();
-
-    // collection interface
-    entry_value_collector const& operator<<( lazy_ostream const& ) const;
-    entry_value_collector const& operator<<( const_string ) const;
-
-private:
-    // Data members
-    mutable bool    m_last;
-};
-
-} // namespace ut_detail
-
-// ************************************************************************** //
-// **************                 unit_test_log                ************** //
-// ************************************************************************** //
-
-/// @brief Manages the sets of loggers, their streams and log levels
-///
-/// The Boost.Test framework allows for having several formatters/loggers at the same time, each of which
-/// having their own log level and output stream.
-///
-/// This class serves the purpose of
-/// - exposing an interface to the test framework (as a boost::unit_test::test_observer)
-/// - exposing an interface to the testing tools
-/// - managing several loggers
-///
-/// @note Accesses to the functions exposed by this class are made through the singleton
-///   @c boost::unit_test::unit_test_log.
-///
-/// Users/developers willing to implement their own formatter need to:
-/// - implement a boost::unit_test::unit_test_log_formatter that will output the desired format
-/// - register the formatter during a eg. global fixture using the method @c set_formatter (though the framework singleton).
-///
-/// @warning this observer has a higher priority than the @ref boost::unit_test::results_collector_t. This means
-/// that the various @ref boost::unit_test::test_results associated to each test unit may not be available at the time
-/// the @c test_unit_start, @c test_unit_finish ... are called.
-///
-/// @see
-/// - boost::unit_test::test_observer
-/// - boost::unit_test::unit_test_log_formatter
-class BOOST_TEST_DECL unit_test_log_t : public test_observer, public singleton<unit_test_log_t> {
-public:
-    // test_observer interface implementation
-    virtual void        test_start( counter_t test_cases_amount );
-    virtual void        test_finish();
-    virtual void        test_aborted();
-
-    virtual void        test_unit_start( test_unit const& );
-    virtual void        test_unit_finish( test_unit const&, unsigned long elapsed );
-    virtual void        test_unit_skipped( test_unit const&, const_string );
-    virtual void        test_unit_aborted( test_unit const& );
-
-    virtual void        exception_caught( execution_exception const& ex );
-
-    virtual int         priority() { return 1; }
-
-    // log configuration methods
-    //! Sets the stream for all loggers
-    //!
-    //! This will override the log sink/stream of all loggers, whether enabled or not.
-    void                set_stream( std::ostream& );
-
-    //! Sets the stream for specific logger
-    //!
-    //! @note Has no effect if the specified format is not found
-    //! @par Since Boost 1.62
-    void                set_stream( output_format, std::ostream& );
-
-    //! Sets the threshold level for all loggers/formatters.
-    //!
-    //! This will override the log level of all loggers, whether enabled or not.
-    void                set_threshold_level( log_level );
-
-    //! Sets the threshold/log level of a specific format
-    //!
-    //! @note Has no effect if the specified format is not found
-    //! @par Since Boost 1.62
-    void                set_threshold_level( output_format, log_level );
-
-    //! Add a format to the set of loggers
-    //!
-    //! Adding a logger means that the specified logger is enabled. The log level is managed by the formatter itself
-    //! and specifies what events are forwarded to the underlying formatter.
-    //! @par Since Boost 1.62
-    void                add_format( output_format );
-
-    //! Sets the format of the logger
-    //!
-    //! This will become the only active format of the logs.
-    void                set_format( output_format );
-
-    //! Returns the logger instance for a specific format.
-    //!
-    //! @returns the logger/formatter instance, or @c (unit_test_log_formatter*)0 if the format is not found.
-    //! @par Since Boost 1.62
-    unit_test_log_formatter* get_formatter( output_format );
-
-    //! Sets the logger instance
-    //!
-    //! The specified logger becomes the unique active one. The custom log formatter has the
-    //! format @c OF_CUSTOM_LOGGER. If such a format exists already, its formatter gets replaced by the one
-    //! given in argument.
-    //!
-    //! The log level and output stream of the new formatter are taken from the currently active logger. In case
-    //! several loggers are active, the order of priority is CUSTOM, HRF, XML, and JUNIT.
-    //! If (unit_test_log_formatter*)0 is given as argument, the custom logger (if any) is removed.
-    //!
-    //! @note The ownership of the pointer is transfered to the Boost.Test framework. This call is equivalent to
-    //! - a call to @c add_formatter
-    //! - a call to @c set_format(OF_CUSTOM_LOGGER)
-    //! - a configuration of the newly added logger with a previously configured stream and log level.
-    void                set_formatter( unit_test_log_formatter* );
-
-    //! Adds a custom log formatter to the set of formatters
-    //!
-    //! The specified logger is added with the format @c OF_CUSTOM_LOGGER, such that it can
-    //! be futher selected or its stream/log level can be specified.
-    //! If there is already a custom logger (with @c OF_CUSTOM_LOGGER), then
-    //! the existing one gets replaced by the one given in argument.
-    //! The provided logger is added with an enabled state.
-    //! If (unit_test_log_formatter*)0 is given as argument, the custom logger (if any) is removed and
-    //! no other action is performed.
-    //!
-    //! @note The ownership of the pointer is transfered to the Boost.Test framework.
-    //! @par Since Boost 1.62
-    void                add_formatter( unit_test_log_formatter* the_formatter );
-
-    // test progress logging
-    void                set_checkpoint( const_string file, std::size_t line_num, const_string msg = const_string() );
-
-    // entry logging
-    unit_test_log_t&    operator<<( log::begin const& );        // begin entry
-    unit_test_log_t&    operator<<( log::end const& );          // end entry
-    unit_test_log_t&    operator<<( log_level );                // set entry level
-    unit_test_log_t&    operator<<( const_string );             // log entry value
-    unit_test_log_t&    operator<<( lazy_ostream const& );      // log entry value
-
-    ut_detail::entry_value_collector operator()( log_level );   // initiate entry collection
-
-private:
-    // Implementation helpers
-    bool                log_entry_start(output_format log_format);
-    void                log_entry_context( log_level l );
-    void                clear_entry_context();
-
-    BOOST_TEST_SINGLETON_CONS( unit_test_log_t )
-}; // unit_test_log_t
-
-BOOST_TEST_SINGLETON_INST( unit_test_log )
-
-// helper macros
-#define BOOST_TEST_LOG_ENTRY( ll )                                                  \
-    (::boost::unit_test::unit_test_log                                              \
-        << ::boost::unit_test::log::begin( BOOST_TEST_L(__FILE__), __LINE__ ))(ll)  \
-/**/
-
-} // namespace unit_test
-} // namespace boost
-
-// ************************************************************************** //
-// **************       Unit test log interface helpers        ************** //
-// ************************************************************************** //
-
-// messages sent by the framework
-#define BOOST_TEST_FRAMEWORK_MESSAGE( M )                       \
-   (::boost::unit_test::unit_test_log                           \
-        << ::boost::unit_test::log::begin(                      \
-                "boost.test framework",                         \
-                __LINE__ ))                                     \
-             ( ::boost::unit_test::log_messages )               \
-    << BOOST_TEST_LAZY_MSG( M )                                 \
-/**/
-
-
-#define BOOST_TEST_MESSAGE( M )                                 \
-    BOOST_TEST_LOG_ENTRY( ::boost::unit_test::log_messages )    \
-    << BOOST_TEST_LAZY_MSG( M )                                 \
-/**/
-
-//____________________________________________________________________________//
-
-#define BOOST_TEST_PASSPOINT()                                  \
-    ::boost::unit_test::unit_test_log.set_checkpoint(           \
-        BOOST_TEST_L(__FILE__),                                 \
-        static_cast<std::size_t>(__LINE__) )                    \
-/**/
-
-//____________________________________________________________________________//
-
-#define BOOST_TEST_CHECKPOINT( M )                              \
-    ::boost::unit_test::unit_test_log.set_checkpoint(           \
-        BOOST_TEST_L(__FILE__),                                 \
-        static_cast<std::size_t>(__LINE__),                     \
-        (::boost::wrap_stringstream().ref() << M).str() )       \
-/**/
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UNIT_TEST_LOG_HPP_071894GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/unit_test_log_formatter.hpp b/contrib/libboost/boost_1_62_0/boost/test/unit_test_log_formatter.hpp
deleted file mode 100644
index 5a9d6bada51..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/unit_test_log_formatter.hpp
+++ /dev/null
@@ -1,320 +0,0 @@
-//  (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
-/// @brief Defines unit test log formatter interface
-///
-/// You can define a class with implements this interface and use an instance of it
-/// as a Unit Test Framework log formatter
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_LOG_FORMATTER_HPP_071894GER
-#define BOOST_TEST_UNIT_TEST_LOG_FORMATTER_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/detail/log_level.hpp>
-#include <boost/test/detail/fwd_decl.hpp>
-
-// STL
-#include <iosfwd>
-#include <string> // for std::string
-#include <iostream>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-/// Collection of log entry attributes
-// ************************************************************************** //
-
-struct BOOST_TEST_DECL log_entry_data {
-    log_entry_data()
-    {
-        m_file_name.reserve( 200 );
-    }
-
-    std::string     m_file_name; ///< log entry file name
-    std::size_t     m_line_num;  ///< log entry line number
-    log_level       m_level;     ///< log entry level
-
-    void clear()
-    {
-        m_file_name.erase();
-        m_line_num      = 0;
-        m_level     = log_nothing;
-    }
-};
-
-// ************************************************************************** //
-/// Collection of log checkpoint attributes
-// ************************************************************************** //
-
-struct BOOST_TEST_DECL log_checkpoint_data
-{
-    const_string    m_file_name; ///< log checkpoint file name
-    std::size_t     m_line_num;  ///< log checkpoint file name
-    std::string     m_message;   ///< log checkpoint message
-
-    void clear()
-    {
-        m_file_name.clear();
-        m_line_num  = 0;
-        m_message   = std::string();
-    }
-};
-
-// ************************************************************************** //
-/// @brief Abstract Unit Test Framework log formatter interface
-///
-/// During the test module execution Unit Test Framework can report messages about success
-/// or failure of assertions, which test suites are being run and more (specifically which
-/// messages are reported depends on log level threshold selected by the user).
-///
-/// All these messages constitute Unit Test Framework log. There are many ways (formats) to present
-/// these messages to the user.
-///
-/// Boost.Test comes with three formats:
-/// - Compiler-like log format: intended for human consumption/diagnostic
-/// - XML based log format:  intended for processing by automated regression test systems.
-/// - JUNIT based log format:  intended for processing by automated regression test systems.
-///
-/// If you want to produce some other format you need to implement class with specific interface and use
-/// method @c unit_test_log_t::set_formatter during a test module initialization to set an active formatter.
-/// The class unit_test_log_formatter defines this interface.
-///
-/// This interface requires you to format all possible messages being produced in the log.
-/// These includes error messages about failed assertions, messages about caught exceptions and
-/// information messages about test units being started/ended. All the methods in this interface takes
-/// a reference to standard stream as a first argument. This is where final messages needs to be directed
-/// to. Also you are given all the information necessary to produce a message.
-///
-/// @par Since Boost 1.62:
-/// - Each formatter may indicate the default output stream. This is convenient for instance for streams intended
-///   for automated processing that indicate a file. See @c get_default_stream_description for more details.
-/// - Each formatter may manage its own log level through the getter/setter @c get_log_level and @c set_log_level .
-///
-/// @see
-/// - boost::unit_test::test_observer for an indication of the calls of the test observer interface
-class BOOST_TEST_DECL unit_test_log_formatter {
-public:
-    /// Types of log entries (messages written into a log)
-    enum log_entry_types { BOOST_UTL_ET_INFO,       ///< Information message from the framework
-                           BOOST_UTL_ET_MESSAGE,    ///< Information message from the user
-                           BOOST_UTL_ET_WARNING,    ///< Warning (non error) condition notification message
-                           BOOST_UTL_ET_ERROR,      ///< Non fatal error notification message
-                           BOOST_UTL_ET_FATAL_ERROR ///< Fatal error notification message
-    };
-
-    //! Constructor
-    unit_test_log_formatter()
-        : m_log_level(log_all_errors)
-    {}
-
-    // Destructor
-    virtual             ~unit_test_log_formatter() {}
-
-    // @name Test start/finish
-
-    /// Invoked at the beginning of test module execution
-    ///
-    /// @param[in] os   output stream to write a messages to
-    /// @param[in] test_cases_amount total test case amount to be run
-    /// @see log_finish
-    virtual void        log_start( std::ostream& os, counter_t test_cases_amount ) = 0;
-
-    /// Invoked at the end of test module execution
-    ///
-    /// @param[in] os   output stream to write a messages into
-    /// @see log_start
-    virtual void        log_finish( std::ostream& os ) = 0;
-
-    /// Invoked when Unit Test Framework build information is requested
-    ///
-    /// @param[in] os   output stream to write a messages into
-    virtual void        log_build_info( std::ostream& os ) = 0;
-    // @}
-
-    // @name Test unit start/finish
-
-    /// Invoked when test unit starts (either test suite or test case)
-    ///
-    /// @param[in] os   output stream to write a messages into
-    /// @param[in] tu   test unit being started
-    /// @see test_unit_finish
-    virtual void        test_unit_start( std::ostream& os, test_unit const& tu ) = 0;
-
-    /// Invoked when test unit finishes
-    ///
-    /// @param[in] os   output stream to write a messages into
-    /// @param[in] tu   test unit being finished
-    /// @param[in] elapsed time in microseconds spend executing this test unit
-    /// @see test_unit_start
-    virtual void        test_unit_finish( std::ostream& os, test_unit const& tu, unsigned long elapsed ) = 0;
-
-    /// Invoked if test unit skipped for any reason
-    ///
-    /// @param[in] os   output stream to write a messages into
-    /// @param[in] tu   skipped test unit
-    /// @param[in] reason explanation why was it skipped
-    virtual void        test_unit_skipped( std::ostream& os, test_unit const& tu, const_string reason )
-    {
-        test_unit_skipped( os, tu );
-    }
-
-    /// Deprecated version of this interface
-    virtual void        test_unit_skipped( std::ostream& os, test_unit const& tu ) {}
-
-    /// Invoked when a test unit is aborted
-    virtual void        test_unit_aborted( std::ostream& os, test_unit const& tu ) {}
-
-    // @}
-
-    // @name Uncaught exception report
-
-    /// Invoked when Unit Test Framework detects uncaught exception
-    ///
-    /// The framwork calls this function when an uncaught exception it detected.
-    /// This call is followed by context information:
-    /// - one call to @c entry_context_start,
-    /// - as many calls to @c log_entry_context as there are context entries
-    /// - one call to @c entry_context_finish
-    ///
-    /// The logging of the exception information is finilized by a call to @c log_exception_finish.
-    ///
-    /// @param[in] os   output stream to write a messages into
-    /// @param[in] lcd  information about the last checkpoint before the exception was triggered
-    /// @param[in] ex   information about the caught exception
-    /// @see log_exception_finish
-    virtual void        log_exception_start( std::ostream& os, log_checkpoint_data const& lcd, execution_exception const& ex ) = 0;
-
-    /// Invoked when Unit Test Framework detects uncaught exception
-    ///
-    /// Call to this function finishes uncaught exception report.
-    /// @param[in] os   output stream to write a messages into
-    /// @see log_exception_start
-    virtual void        log_exception_finish( std::ostream& os ) = 0;
-    // @}
-
-    // @name Regular log entry
-
-    /// Invoked by Unit Test Framework to start new log entry
-
-    /// Call to this function starts new log entry. It is followed by series of log_entry_value calls and finally call to log_entry_finish.
-    /// A log entry may consist of one or more values being reported. Some of these values will be plain strings, while others can be complicated
-    /// expressions in a form of "lazy" expression template lazy_ostream.
-    /// @param[in] os   output stream to write a messages into
-    /// @param[in] led  log entry attributes
-    /// @param[in] let  log entry type log_entry_finish
-    /// @see log_entry_value, log_entry_finish
-    ///
-    /// @note call to this function may happen before any call to test_unit_start or all calls to test_unit_finish as the
-    /// framework might log errors raised during global initialization/shutdown.
-    virtual void        log_entry_start( std::ostream& os, log_entry_data const& led, log_entry_types let ) = 0;
-
-    /// Invoked by Unit Test Framework to report a log entry content
-    ///
-    /// This is one of two overloaded methods to report log entry content. This one is used to report plain string value.
-    /// @param[in] os   output stream to write a messages into.
-    /// @param[in] value log entry string value
-    /// @see log_entry_start, log_entry_finish
-    virtual void        log_entry_value( std::ostream& os, const_string value ) = 0;
-
-    /// Invoked by Unit Test Framework to report a log entry content
-
-    /// This is one of two overloaded methods to report log entry content. This one is used to report some complicated expression passed as
-    /// an expression template lazy_ostream. In most cases default implementation provided by the framework should work as is (it just converts
-    /// the lazy expression into a string.
-    /// @param[in] os   output stream to write a messages into
-    /// @param[in] value log entry "lazy" value
-    /// @see log_entry_start, log_entry_finish
-    virtual void        log_entry_value( std::ostream& os, lazy_ostream const& value ); // there is a default impl
-
-    /// Invoked by Unit Test Framework to finish a log entry report
-
-    /// @param[in] os   output stream to write a messages into
-    /// @see log_entry_start, log_entry_start
-    virtual void        log_entry_finish( std::ostream& os ) = 0;
-    // @}
-
-    // @name Log entry context report
-
-    /// Invoked by Unit Test Framework to start log entry context report
-
-    /// Unit Test Framework logs for failed assertions and uncaught exceptions context if one was defined by a test module.
-    /// Context consists of multiple "scopes" identified by description messages assigned by the test module using
-    /// BOOST_TEST_INFO/BOOST_TEST_CONTEXT statements.
-    /// @param[in] os   output stream to write a messages into
-    /// @param[in] l    entry log_level, to be used to fine tune the message
-    /// @see log_entry_context, entry_context_finish
-    virtual void        entry_context_start( std::ostream& os, log_level l ) = 0;
-
-    /// Invoked by Unit Test Framework to report log entry context "scope" description
-
-    /// Each "scope" description is reported by separate call to log_entry_context.
-    /// @param[in] os   output stream to write a messages into
-    /// @param[in] value  context "scope" description
-    /// @see log_entry_start, entry_context_finish
-    virtual void        log_entry_context( std::ostream& os, const_string value ) = 0;
-
-    /// Invoked by Unit Test Framework to finish log entry context report
-
-    /// @param[in] os   output stream to write a messages into
-    /// @see log_entry_start, entry_context_context
-    virtual void        entry_context_finish( std::ostream& os ) = 0;
-    // @}
-
-    // @name Log level management
-
-    /// Sets the log level of the logger/formatter
-    ///
-    /// Some loggers need to manage the log level by their own. This
-    /// member function let the implementation decide of that.
-    /// @par Since Boost 1.62
-    virtual void        set_log_level(log_level new_log_level);
-
-    /// Returns the log level of the logger/formatter
-    /// @par Since Boost 1.62
-    virtual log_level   get_log_level() const;
-    // @}
-
-
-    // @name Stream management
-
-    /// Returns a default stream for this logger.
-    ///
-    /// The returned string describes the stream as if it was passed from
-    /// the command line @c "--log_sink" parameter. With that regards, @b stdout and @b stderr
-    /// have special meaning indicating the standard output or error stream respectively.
-    ///
-    /// @par Since Boost 1.62
-    virtual std::string  get_default_stream_description() const
-    {
-        return "stdout";
-    }
-
-    // @}
-
-
-protected:
-    log_level           m_log_level;
-
-};
-
-} // namespace unit_test
-} // namespace boost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UNIT_TEST_LOG_FORMATTER_HPP_071894GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/unit_test_monitor.hpp b/contrib/libboost/boost_1_62_0/boost/test/unit_test_monitor.hpp
deleted file mode 100644
index 1f937fa6744..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/unit_test_monitor.hpp
+++ /dev/null
@@ -1,60 +0,0 @@
-//  (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
-/// @brief defines specific version of execution monitor used to managed run unit of test cases
-///
-/// Translates execution exception into error level
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_MONITOR_HPP_020905GER
-#define BOOST_TEST_UNIT_TEST_MONITOR_HPP_020905GER
-
-// Boost.Test
-#include <boost/test/execution_monitor.hpp>
-#include <boost/test/detail/fwd_decl.hpp>
-#include <boost/test/utils/trivial_singleton.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************               unit_test_monitor              ************** //
-// ************************************************************************** //
-
-class BOOST_TEST_DECL unit_test_monitor_t : public singleton<unit_test_monitor_t>, public execution_monitor {
-public:
-    enum error_level {
-        test_ok                 =  0,
-        precondition_failure    = -1,
-        unexpected_exception    = -2,
-        os_exception            = -3,
-        os_timeout              = -4,
-        fatal_error             = -5  // includes both system and user
-    };
-
-    static bool is_critical_error( error_level e ) { return e <= fatal_error; }
-
-    // monitor method
-    error_level execute_and_translate( boost::function<void ()> const& func, unsigned timeout = 0 );
-
-private:
-    BOOST_TEST_SINGLETON_CONS( unit_test_monitor_t )
-};
-
-BOOST_TEST_SINGLETON_INST( unit_test_monitor )
-
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UNIT_TEST_MONITOR_HPP_020905GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/unit_test_parameters.hpp b/contrib/libboost/boost_1_62_0/boost/test/unit_test_parameters.hpp
deleted file mode 100644
index d6fecf0b8a1..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/unit_test_parameters.hpp
+++ /dev/null
@@ -1,134 +0,0 @@
-//  (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
-/// @brief Provides access to various Unit Test Framework runtime parameters
-///
-/// Primarily for use by the framework itself
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_PARAMETERS_HPP_071894GER
-#define BOOST_TEST_UNIT_TEST_PARAMETERS_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/detail/global_typedef.hpp>
-#include <boost/test/utils/runtime/argument.hpp>
-#include	<boost/make_shared.hpp>
-
-// STL
-#include <iostream>
-#include <fstream>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace runtime_config {
-
-// ************************************************************************** //
-// **************                 runtime_config               ************** //
-// ************************************************************************** //
-
-// UTF parameters
-BOOST_TEST_DECL extern std::string AUTO_START_DBG;
-BOOST_TEST_DECL extern std::string BREAK_EXEC_PATH;
-BOOST_TEST_DECL extern std::string BUILD_INFO;
-BOOST_TEST_DECL extern std::string CATCH_SYS_ERRORS;
-BOOST_TEST_DECL extern std::string COLOR_OUTPUT;
-BOOST_TEST_DECL extern std::string DETECT_FP_EXCEPT;
-BOOST_TEST_DECL extern std::string DETECT_MEM_LEAKS;
-BOOST_TEST_DECL extern std::string LIST_CONTENT;
-BOOST_TEST_DECL extern std::string LIST_LABELS;
-BOOST_TEST_DECL extern std::string COMBINED_LOGGER;
-BOOST_TEST_DECL extern std::string LOG_FORMAT;
-BOOST_TEST_DECL extern std::string LOG_LEVEL;
-BOOST_TEST_DECL extern std::string LOG_SINK;
-BOOST_TEST_DECL extern std::string OUTPUT_FORMAT;
-BOOST_TEST_DECL extern std::string RANDOM_SEED;
-BOOST_TEST_DECL extern std::string REPORT_FORMAT;
-BOOST_TEST_DECL extern std::string REPORT_LEVEL;
-BOOST_TEST_DECL extern std::string REPORT_MEM_LEAKS;
-BOOST_TEST_DECL extern std::string REPORT_SINK;
-BOOST_TEST_DECL extern std::string RESULT_CODE;
-BOOST_TEST_DECL extern std::string RUN_FILTERS;
-BOOST_TEST_DECL extern std::string SAVE_TEST_PATTERN;
-BOOST_TEST_DECL extern std::string SHOW_PROGRESS;
-BOOST_TEST_DECL extern std::string USE_ALT_STACK;
-BOOST_TEST_DECL extern std::string WAIT_FOR_DEBUGGER;
-
-BOOST_TEST_DECL void init( int& argc, char** argv );
-
-// ************************************************************************** //
-// **************              runtime_param::get              ************** //
-// ************************************************************************** //
-
-/// Access to arguments
-BOOST_TEST_DECL runtime::arguments_store const& argument_store();
-
-template<typename T>
-inline T const&
-get( runtime::cstring parameter_name )
-{
-    return argument_store().get<T>( parameter_name );
-}
-
-inline bool has( runtime::cstring parameter_name )
-{
-    return argument_store().has( parameter_name );
-}
-
-/// For public access
-BOOST_TEST_DECL bool save_pattern();
-
-// ************************************************************************** //
-// **************                  stream_holder               ************** //
-// ************************************************************************** //
-
-class stream_holder {
-public:
-    // Constructor
-    explicit        stream_holder( std::ostream& default_stream = std::cout)
-    : m_stream( &default_stream )
-    {
-    }
-
-    void            setup( const const_string& stream_name )
-    {
-        if(stream_name.empty())
-            return;
-
-        if( stream_name == "stderr" )
-            m_stream = &std::cerr;
-        else if( stream_name == "stdout" )
-            m_stream = &std::cout;
-        else {
-            m_file = boost::make_shared<std::ofstream>();
-            m_file->open( std::string(stream_name.begin(), stream_name.end()).c_str() );
-            m_stream = m_file.get();
-        }
-    }
-
-    // Access methods
-    std::ostream&   ref() const { return *m_stream; }
-
-private:
-    // Data members
-    boost::shared_ptr<std::ofstream>   m_file;
-    std::ostream*   m_stream;
-};
-
-} // namespace runtime_config
-} // namespace unit_test
-} // namespace boost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UNIT_TEST_PARAMETERS_HPP_071894GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/unit_test_suite.hpp b/contrib/libboost/boost_1_62_0/boost/test/unit_test_suite.hpp
deleted file mode 100644
index 1dbcece78ab..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/unit_test_suite.hpp
+++ /dev/null
@@ -1,366 +0,0 @@
-//  (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
-/// @brief Defines Unit Test Framework public API
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UNIT_TEST_SUITE_HPP_071894GER
-#define BOOST_TEST_UNIT_TEST_SUITE_HPP_071894GER
-
-// Boost.Test
-#include <boost/test/framework.hpp>
-#include <boost/test/tree/auto_registration.hpp>
-#include <boost/test/tree/test_case_template.hpp>
-#include <boost/test/tree/global_fixture.hpp>
-
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-
-#include <boost/test/detail/pp_variadic.hpp>
-
-
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************    Non-auto (explicit) test case interface   ************** //
-// ************************************************************************** //
-
-#define BOOST_TEST_CASE( test_function )                                   \
-boost::unit_test::make_test_case( boost::function<void ()>(test_function), \
-                                  BOOST_TEST_STRINGIZE( test_function ),   \
-                                  __FILE__, __LINE__ )
-#define BOOST_CLASS_TEST_CASE( test_function, tc_instance )                \
-boost::unit_test::make_test_case( (test_function),                         \
-                                  BOOST_TEST_STRINGIZE( test_function ),   \
-                                  __FILE__, __LINE__, tc_instance )
-
-// ************************************************************************** //
-// **************               BOOST_TEST_SUITE               ************** //
-// ************************************************************************** //
-
-#define BOOST_TEST_SUITE( testsuite_name ) \
-( new boost::unit_test::test_suite( testsuite_name, __FILE__, __LINE__ ) )
-
-// ************************************************************************** //
-// **************             BOOST_AUTO_TEST_SUITE            ************** //
-// ************************************************************************** //
-
-#define BOOST_AUTO_TEST_SUITE_WITH_DECOR( suite_name, decorators )      \
-namespace suite_name {                                                  \
-BOOST_AUTO_TU_REGISTRAR( suite_name )(                                  \
-    BOOST_STRINGIZE( suite_name ),                                      \
-    __FILE__, __LINE__,                                                 \
-    decorators );                                                       \
-/**/
-
-#define BOOST_AUTO_TEST_SUITE_NO_DECOR( suite_name )                    \
-    BOOST_AUTO_TEST_SUITE_WITH_DECOR(                                   \
-        suite_name,                                                     \
-        boost::unit_test::decorator::collector::instance() )            \
-/**/
-
-#if BOOST_PP_VARIADICS
-#define BOOST_AUTO_TEST_SUITE( ... )                                    \
-    BOOST_TEST_INVOKE_IF_N_ARGS( 1,                                     \
-        BOOST_AUTO_TEST_SUITE_NO_DECOR,                                 \
-        BOOST_AUTO_TEST_SUITE_WITH_DECOR,                               \
-        __VA_ARGS__)                                                    \
-/**/
-
-#else /* BOOST_PP_VARIADICS */
-
-#define BOOST_AUTO_TEST_SUITE( suite_name )                             \
-    BOOST_AUTO_TEST_SUITE_NO_DECOR( suite_name )                        \
-/**/
-
-
-#endif /* BOOST_PP_VARIADICS */
-
-// ************************************************************************** //
-// **************            BOOST_FIXTURE_TEST_SUITE          ************** //
-// ************************************************************************** //
-
-#define BOOST_FIXTURE_TEST_SUITE_WITH_DECOR(suite_name, F, decorators)  \
-    BOOST_AUTO_TEST_SUITE_WITH_DECOR( suite_name, decorators )          \
-typedef F BOOST_AUTO_TEST_CASE_FIXTURE;                                 \
-/**/
-
-#define BOOST_FIXTURE_TEST_SUITE_NO_DECOR( suite_name, F )              \
-    BOOST_AUTO_TEST_SUITE_NO_DECOR( suite_name )                        \
-typedef F BOOST_AUTO_TEST_CASE_FIXTURE;                                 \
-/**/
-
-#if BOOST_PP_VARIADICS
-
-#define BOOST_FIXTURE_TEST_SUITE( ... )                                 \
-    BOOST_TEST_INVOKE_IF_N_ARGS( 2,                                     \
-        BOOST_FIXTURE_TEST_SUITE_NO_DECOR,                              \
-        BOOST_FIXTURE_TEST_SUITE_WITH_DECOR,                            \
-        __VA_ARGS__)                                                    \
-/**/
-
-#else /* BOOST_PP_VARIADICS */
-
-#define BOOST_FIXTURE_TEST_SUITE( suite_name, F  )                      \
-   BOOST_FIXTURE_TEST_SUITE_NO_DECOR( suite_name, F )                   \
-/**/
-
-
-#endif /* BOOST_PP_VARIADICS */
-
-
-// ************************************************************************** //
-// **************           BOOST_AUTO_TEST_SUITE_END          ************** //
-// ************************************************************************** //
-
-#define BOOST_AUTO_TEST_SUITE_END()                                     \
-BOOST_AUTO_TU_REGISTRAR( BOOST_JOIN( end_suite, __LINE__ ) )( 1 );      \
-}                                                                       \
-/**/
-
-// ************************************************************************** //
-// **************    BOOST_AUTO_TEST_CASE_EXPECTED_FAILURES    ************** //
-// ************************************************************************** //
-
-/// @deprecated use decorator instead
-#define BOOST_AUTO_TEST_CASE_EXPECTED_FAILURES( test_name, n )          \
-BOOST_TEST_DECORATOR( * boost::unit_test::expected_failures( n ) )      \
-/**/
-
-// ************************************************************************** //
-// **************            BOOST_FIXTURE_TEST_CASE           ************** //
-// ************************************************************************** //
-
-#define BOOST_FIXTURE_TEST_CASE_WITH_DECOR( test_name, F, decorators )  \
-struct test_name : public F { void test_method(); };                    \
-                                                                        \
-static void BOOST_AUTO_TC_INVOKER( test_name )()                        \
-{                                                                       \
-    BOOST_TEST_CHECKPOINT('"' << #test_name << "\" fixture entry.");    \
-    test_name t;                                                        \
-    BOOST_TEST_CHECKPOINT('"' << #test_name << "\" entry.");            \
-    t.test_method();                                                    \
-    BOOST_TEST_CHECKPOINT('"' << #test_name << "\" exit.");             \
-}                                                                       \
-                                                                        \
-struct BOOST_AUTO_TC_UNIQUE_ID( test_name ) {};                         \
-                                                                        \
-BOOST_AUTO_TU_REGISTRAR( test_name )(                                   \
-    boost::unit_test::make_test_case(                                   \
-        &BOOST_AUTO_TC_INVOKER( test_name ),                            \
-        #test_name, __FILE__, __LINE__ ),                               \
-        decorators );                                                   \
-                                                                        \
-void test_name::test_method()                                           \
-/**/
-
-#define BOOST_FIXTURE_TEST_CASE_NO_DECOR( test_name, F )                \
-BOOST_FIXTURE_TEST_CASE_WITH_DECOR( test_name, F,                       \
-    boost::unit_test::decorator::collector::instance() )                \
-/**/
-
-#if BOOST_PP_VARIADICS
-
-#define BOOST_FIXTURE_TEST_CASE( ... )                                  \
-    BOOST_TEST_INVOKE_IF_N_ARGS( 2,                                     \
-        BOOST_FIXTURE_TEST_CASE_NO_DECOR,                               \
-        BOOST_FIXTURE_TEST_CASE_WITH_DECOR,                             \
-         __VA_ARGS__)                                                   \
-/**/
-
-#else /* BOOST_PP_VARIADICS */
-
-#define BOOST_FIXTURE_TEST_CASE( test_name, F )                         \
-     BOOST_FIXTURE_TEST_CASE_NO_DECOR(test_name, F)                     \
-/**/
-
-
-#endif /* BOOST_PP_VARIADICS */
-
-// ************************************************************************** //
-// **************             BOOST_AUTO_TEST_CASE             ************** //
-// ************************************************************************** //
-
-#define BOOST_AUTO_TEST_CASE_NO_DECOR( test_name )                      \
-    BOOST_FIXTURE_TEST_CASE_NO_DECOR( test_name,                        \
-        BOOST_AUTO_TEST_CASE_FIXTURE )                                  \
-/**/
-
-#define BOOST_AUTO_TEST_CASE_WITH_DECOR( test_name, decorators )        \
-    BOOST_FIXTURE_TEST_CASE_WITH_DECOR( test_name,                      \
-        BOOST_AUTO_TEST_CASE_FIXTURE, decorators )                      \
-/**/
-
-#if BOOST_PP_VARIADICS
-
-#define BOOST_AUTO_TEST_CASE( ... )                                     \
-    BOOST_TEST_INVOKE_IF_N_ARGS( 1,                                     \
-        BOOST_AUTO_TEST_CASE_NO_DECOR,                                  \
-        BOOST_AUTO_TEST_CASE_WITH_DECOR,                                \
-         __VA_ARGS__)                                                   \
-/**/
-
-#else /* BOOST_PP_VARIADICS */
-
-#define BOOST_AUTO_TEST_CASE( test_name )                               \
-    BOOST_AUTO_TEST_CASE_NO_DECOR( test_name )                          \
-/**/
-
-
-#endif /* BOOST_PP_VARIADICS */
-
-// ************************************************************************** //
-// **************       BOOST_FIXTURE_TEST_CASE_TEMPLATE       ************** //
-// ************************************************************************** //
-
-#define BOOST_FIXTURE_TEST_CASE_TEMPLATE( test_name, type_name, TL, F ) \
-template<typename type_name>                                            \
-struct test_name : public F                                             \
-{ void test_method(); };                                                \
-                                                                        \
-struct BOOST_AUTO_TC_INVOKER( test_name ) {                             \
-    template<typename TestType>                                         \
-    static void run( boost::type<TestType>* = 0 )                       \
-    {                                                                   \
-        BOOST_TEST_CHECKPOINT('"' << #test_name <<"\" fixture entry."); \
-        test_name<TestType> t;                                          \
-        BOOST_TEST_CHECKPOINT('"' << #test_name << "\" entry.");        \
-        t.test_method();                                                \
-        BOOST_TEST_CHECKPOINT('"' << #test_name << "\" exit.");         \
-    }                                                                   \
-};                                                                      \
-                                                                        \
-BOOST_AUTO_TU_REGISTRAR( test_name )(                                   \
-    boost::unit_test::ut_detail::template_test_case_gen<                \
-        BOOST_AUTO_TC_INVOKER( test_name ),TL >(                        \
-          BOOST_STRINGIZE( test_name ), __FILE__, __LINE__ ),           \
-    boost::unit_test::decorator::collector::instance() );               \
-                                                                        \
-template<typename type_name>                                            \
-void test_name<type_name>::test_method()                                \
-/**/
-
-// ************************************************************************** //
-// **************        BOOST_AUTO_TEST_CASE_TEMPLATE         ************** //
-// ************************************************************************** //
-
-#define BOOST_AUTO_TEST_CASE_TEMPLATE( test_name, type_name, TL )       \
-BOOST_FIXTURE_TEST_CASE_TEMPLATE( test_name, type_name, TL,             \
-    BOOST_AUTO_TEST_CASE_FIXTURE )                                      \
-/**/
-
-// ************************************************************************** //
-// **************           BOOST_TEST_CASE_TEMPLATE           ************** //
-// ************************************************************************** //
-
-#define BOOST_TEST_CASE_TEMPLATE( name, typelist )                      \
-    boost::unit_test::ut_detail::template_test_case_gen<name,typelist>( \
-        BOOST_TEST_STRINGIZE( name ), __FILE__, __LINE__ )              \
-/**/
-
-// ************************************************************************** //
-// **************      BOOST_TEST_CASE_TEMPLATE_FUNCTION       ************** //
-// ************************************************************************** //
-
-#define BOOST_TEST_CASE_TEMPLATE_FUNCTION( name, type_name )            \
-template<typename type_name>                                            \
-void BOOST_JOIN( name, _impl )( boost::type<type_name>* );              \
-                                                                        \
-struct name {                                                           \
-    template<typename TestType>                                         \
-    static void run( boost::type<TestType>* frwrd = 0 )                 \
-    {                                                                   \
-       BOOST_JOIN( name, _impl )( frwrd );                              \
-    }                                                                   \
-};                                                                      \
-                                                                        \
-template<typename type_name>                                            \
-void BOOST_JOIN( name, _impl )( boost::type<type_name>* )               \
-/**/
-
-// ************************************************************************** //
-// **************              BOOST_GLOBAL_FIXTURE            ************** //
-// ************************************************************************** //
-
-#define BOOST_GLOBAL_FIXTURE( F ) \
-static boost::unit_test::ut_detail::global_fixture_impl<F> BOOST_JOIN( gf_, F ) \
-/**/
-
-// ************************************************************************** //
-// **************             BOOST_TEST_DECORATOR             ************** //
-// ************************************************************************** //
-
-#define BOOST_TEST_DECORATOR( D )                                       \
-static boost::unit_test::decorator::collector const&                    \
-BOOST_JOIN(decorator_collector,__LINE__) = D;                           \
-/**/
-
-// ************************************************************************** //
-// **************         BOOST_AUTO_TEST_CASE_FIXTURE         ************** //
-// ************************************************************************** //
-
-namespace boost { namespace unit_test { namespace ut_detail {
-
-struct nil_t {};
-
-} // namespace ut_detail
-} // unit_test
-} // namespace boost
-
-// Intentionally is in global namespace, so that FIXTURE_TEST_SUITE can reset it in user code.
-typedef ::boost::unit_test::ut_detail::nil_t BOOST_AUTO_TEST_CASE_FIXTURE;
-
-// ************************************************************************** //
-// **************   Auto registration facility helper macros   ************** //
-// ************************************************************************** //
-
-#define BOOST_AUTO_TU_REGISTRAR( test_name )                    \
-static boost::unit_test::ut_detail::auto_test_unit_registrar    \
-BOOST_JOIN( BOOST_JOIN( test_name, _registrar ), __LINE__ )     \
-/**/
-#define BOOST_AUTO_TC_INVOKER( test_name )      BOOST_JOIN( test_name, _invoker )
-#define BOOST_AUTO_TC_UNIQUE_ID( test_name )    BOOST_JOIN( test_name, _id )
-
-// ************************************************************************** //
-// **************                BOOST_TEST_MAIN               ************** //
-// ************************************************************************** //
-
-#if defined(BOOST_TEST_MAIN)
-
-#ifdef BOOST_TEST_ALTERNATIVE_INIT_API
-bool init_unit_test()                   {
-#else
-::boost::unit_test::test_suite*
-init_unit_test_suite( int, char* [] )   {
-#endif
-
-#ifdef BOOST_TEST_MODULE
-    using namespace ::boost::unit_test;
-    assign_op( framework::master_test_suite().p_name.value, BOOST_TEST_STRINGIZE( BOOST_TEST_MODULE ).trim( "\"" ), 0 );
-
-#endif
-
-#ifdef BOOST_TEST_ALTERNATIVE_INIT_API
-    return true;
-}
-#else
-    return 0;
-}
-#endif
-
-#endif
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-
-#endif // BOOST_TEST_UNIT_TEST_SUITE_HPP_071894GER
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/algorithm.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/algorithm.hpp
deleted file mode 100644
index a5491816eba..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/algorithm.hpp
+++ /dev/null
@@ -1,320 +0,0 @@
-//  (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
-/// Addition to STL algorithms
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_ALGORITHM_HPP
-#define BOOST_TEST_UTILS_ALGORITHM_HPP
-
-// STL
-#include <utility>
-#include <algorithm> // std::find
-#include <functional> // std::bind1st
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace utils {
-
-/// @brief this algorithm search through two collections for first mismatch position that get returned as a pair
-/// of iterators, first pointing to the mismatch position in first collection, second iterator in second one
-///
-/// @param first1 - first collection begin iterator
-/// @param last1 - first collection end iterator
-/// @param first2 - second collection begin iterator
-/// @param last2 - second collection end iterator
-template <class InputIter1, class InputIter2>
-inline std::pair<InputIter1, InputIter2>
-mismatch( InputIter1 first1, InputIter1 last1,
-          InputIter2 first2, InputIter2 last2 )
-{
-    while( first1 != last1 && first2 != last2 && *first1 == *first2 ) {
-        ++first1;
-        ++first2;
-    }
-
-    return std::pair<InputIter1, InputIter2>(first1, first2);
-}
-
-//____________________________________________________________________________//
-
-/// @brief this algorithm search through two collections for first mismatch position that get returned as a pair
-/// of iterators, first pointing to the mismatch position in first collection, second iterator in second one. This algorithms
-/// uses supplied predicate for collection elements comparison
-///
-/// @param first1 - first collection begin iterator
-/// @param last1 - first collection end iterator
-/// @param first2 - second collection begin iterator
-/// @param last2 - second collection end iterator
-/// @param pred - predicate to be used for search
-template <class InputIter1, class InputIter2, class Predicate>
-inline std::pair<InputIter1, InputIter2>
-mismatch( InputIter1 first1, InputIter1 last1,
-          InputIter2 first2, InputIter2 last2,
-          Predicate pred )
-{
-    while( first1 != last1 && first2 != last2 && pred( *first1, *first2 ) ) {
-        ++first1;
-        ++first2;
-    }
-
-    return std::pair<InputIter1, InputIter2>(first1, first2);
-}
-
-//____________________________________________________________________________//
-
-/// @brief this algorithm search through first collection for first element that does not belong a second one
-///
-/// @param first1 - first collection begin iterator
-/// @param last1 - first collection end iterator
-/// @param first2 - second collection begin iterator
-/// @param last2 - second collection end iterator
-template<class ForwardIterator1, class ForwardIterator2>
-inline ForwardIterator1
-find_first_not_of( ForwardIterator1 first1, ForwardIterator1 last1,
-                   ForwardIterator2 first2, ForwardIterator2 last2 )
-{
-    while( first1 != last1 ) {
-        if( std::find( first2, last2, *first1 ) == last2 )
-            break;
-        ++first1;
-    }
-
-    return first1;
-}
-
-//____________________________________________________________________________//
-
-/// @brief this algorithm search through first collection for first element that does not satisfy binary
-/// predicate in conjunction will any element in second collection
-///
-/// @param first1 - first collection begin iterator
-/// @param last1 - first collection end iterator
-/// @param first2 - second collection begin iterator
-/// @param last2 - second collection end iterator
-/// @param pred - predicate to be used for search
-template<class ForwardIterator1, class ForwardIterator2, class Predicate>
-inline ForwardIterator1
-find_first_not_of( ForwardIterator1 first1, ForwardIterator1 last1,
-                   ForwardIterator2 first2, ForwardIterator2 last2,
-                   Predicate pred )
-{
-    while( first1 != last1 ) {
-        if( std::find_if( first2, last2, std::bind1st( pred, *first1 ) ) == last2 )
-            break;
-        ++first1;
-    }
-
-    return first1;
-}
-
-//____________________________________________________________________________//
-
-/// @brief this algorithm search through first collection for last element that belongs to a second one
-///
-/// @param first1 - first collection begin iterator
-/// @param last1 - first collection end iterator
-/// @param first2 - second collection begin iterator
-/// @param last2 - second collection end iterator
-template<class BidirectionalIterator1, class ForwardIterator2>
-inline BidirectionalIterator1
-find_last_of( BidirectionalIterator1 first1, BidirectionalIterator1 last1,
-              ForwardIterator2 first2, ForwardIterator2 last2 )
-{
-    if( first1 == last1 || first2 == last2 )
-        return last1;
-
-    BidirectionalIterator1 it1 = last1;
-    while( --it1 != first1 && std::find( first2, last2, *it1 ) == last2 ) {}
-
-    return it1 == first1 && std::find( first2, last2, *it1 ) == last2 ? last1 : it1;
-}
-
-//____________________________________________________________________________//
-
-/// @brief this algorithm search through first collection for last element that satisfy binary
-/// predicate in conjunction will at least one element in second collection
-///
-/// @param first1 - first collection begin iterator
-/// @param last1 - first collection end iterator
-/// @param first2 - second collection begin iterator
-/// @param last2 - second collection end iterator
-/// @param pred - predicate to be used for search
-template<class BidirectionalIterator1, class ForwardIterator2, class Predicate>
-inline BidirectionalIterator1
-find_last_of( BidirectionalIterator1 first1, BidirectionalIterator1 last1,
-              ForwardIterator2 first2, ForwardIterator2 last2,
-              Predicate pred )
-{
-    if( first1 == last1 || first2 == last2 )
-        return last1;
-
-    BidirectionalIterator1 it1 = last1;
-    while( --it1 != first1 && std::find_if( first2, last2, std::bind1st( pred, *it1 ) ) == last2 ) {}
-
-    return it1 == first1 && std::find_if( first2, last2, std::bind1st( pred, *it1 ) ) == last2 ? last1 : it1;
-}
-
-//____________________________________________________________________________//
-
-/// @brief this algorithm search through first collection for last element that does not belong to a second one
-///
-/// @param first1 - first collection begin iterator
-/// @param last1 - first collection end iterator
-/// @param first2 - second collection begin iterator
-/// @param last2 - second collection end iterator
-template<class BidirectionalIterator1, class ForwardIterator2>
-inline BidirectionalIterator1
-find_last_not_of( BidirectionalIterator1 first1, BidirectionalIterator1 last1,
-                  ForwardIterator2 first2, ForwardIterator2 last2 )
-{
-    if( first1 == last1 || first2 == last2 )
-        return last1;
-
-    BidirectionalIterator1 it1 = last1;
-    while( --it1 != first1 && std::find( first2, last2, *it1 ) != last2 ) {}
-
-    return it1 == first1 && std::find( first2, last2, *it1 ) != last2 ? last1 : it1;
-}
-
-//____________________________________________________________________________//
-
-/// @brief this algorithm search through first collection for last element that does not satisfy binary
-/// predicate in conjunction will any element in second collection
-///
-/// @param first1 - first collection begin iterator
-/// @param last1 - first collection end iterator
-/// @param first2 - second collection begin iterator
-/// @param last2 - second collection end iterator
-/// @param pred - predicate to be used for search
-template<class BidirectionalIterator1, class ForwardIterator2, class Predicate>
-inline BidirectionalIterator1
-find_last_not_of( BidirectionalIterator1 first1, BidirectionalIterator1 last1,
-                  ForwardIterator2 first2, ForwardIterator2 last2,
-                  Predicate pred )
-{
-    if( first1 == last1 || first2 == last2 )
-        return last1;
-
-    BidirectionalIterator1 it1 = last1;
-    while( --it1 != first1 && std::find_if( first2, last2, std::bind1st( pred, *it1 ) ) != last2 ) {}
-
-    return it1 == first1 && std::find_if( first2, last2, std::bind1st( pred, *it1 ) ) == last2 ? last1 : it1;
-}
-
-//____________________________________________________________________________//
-
-
-/// @brief This algorithm replaces all occurrences of a set of substrings by another substrings
-///
-/// @param str - string of operation
-/// @param first1 - iterator to the beginning of the substrings to replace
-/// @param last1 - iterator to the end of the substrings to replace
-/// @param first2 - iterator to the beginning of the substrings to replace with
-/// @param last2 - iterator to the end of the substrings to replace with
-template<class StringClass, class ForwardIterator>
-inline StringClass
-replace_all_occurrences_of( StringClass str,
-                            ForwardIterator first1, ForwardIterator last1,
-                            ForwardIterator first2, ForwardIterator last2)
-{
-    for(; first1 != last1 && first2 != last2; ++first1, ++first2) {
-        std::size_t found = str.find( *first1 );
-        while( found != StringClass::npos ) {
-            str.replace(found, first1->size(), *first2 );
-            found = str.find( *first1, found + first2->size() );
-        }
-    }
-
-    return str;
-}
-
-/// @brief This algorithm replaces all occurrences of a string with basic wildcards
-/// with another (optionally containing wildcards as well).
-///
-/// @param str - string to transform
-/// @param it_string_to_find - iterator to the beginning of the substrings to replace
-/// @param it_string_to_find_end - iterator to the end of the substrings to replace
-/// @param it_string_to_replace - iterator to the beginning of the substrings to replace with
-/// @param it_string_to_replace_end - iterator to the end of the substrings to replace with
-///
-/// The wildcard is the symbol '*'. Only a unique wildcard per string is supported. The replacement
-/// string may also contain a wildcard, in which case it is considered as a placeholder to the content
-/// of the wildcard in the source string.
-/// Example:
-/// - In order to replace the occurrences of @c 'time=\"some-variable-value\"' to a constant string,
-///   one may use @c 'time=\"*\"' as the string to search for, and 'time=\"0.0\"' as the replacement string.
-/// - In order to replace the occurrences of 'file.cpp(XX)' per 'file.cpp:XX', where XX is a variable to keep,
-///   on may use @c 'file.cpp(*)' as the string to search for, and 'file.cpp:*' as the replacement string.
-template<class StringClass, class ForwardIterator>
-inline StringClass
-replace_all_occurrences_with_wildcards(
-    StringClass str,
-    ForwardIterator it_string_to_find, ForwardIterator it_string_to_find_end,
-    ForwardIterator it_string_to_replace, ForwardIterator it_string_to_replace_end)
-{
-    for(; it_string_to_find != it_string_to_find_end && it_string_to_replace != it_string_to_replace_end;
-        ++it_string_to_find, ++ it_string_to_replace) {
-
-        std::size_t wildcard_pos = it_string_to_find->find("*");
-        if(wildcard_pos == StringClass::npos) {
-            ForwardIterator it_to_find_current_end(it_string_to_find);
-            ForwardIterator it_to_replace_current_end(it_string_to_replace);
-            str = replace_all_occurrences_of(
-                str,
-                it_string_to_find, ++it_to_find_current_end,
-                it_string_to_replace, ++it_to_replace_current_end);
-            continue;
-        }
-
-        std::size_t wildcard_pos_replace = it_string_to_replace->find("*");
-
-        std::size_t found_begin = str.find( it_string_to_find->substr(0, wildcard_pos) );
-        while( found_begin != StringClass::npos ) {
-            std::size_t found_end = str.find(it_string_to_find->substr(wildcard_pos+1), found_begin + wildcard_pos + 1); // to simplify
-            if( found_end != StringClass::npos ) {
-
-                if( wildcard_pos_replace == StringClass::npos ) {
-                    StringClass replace_content = *it_string_to_replace;
-                    str.replace(
-                        found_begin,
-                        found_end + (it_string_to_find->size() - wildcard_pos - 1 ) - found_begin,
-                        replace_content);
-                } else {
-                    StringClass replace_content =
-                        it_string_to_replace->substr(0, wildcard_pos_replace)
-                        + str.substr(found_begin + wildcard_pos,
-                                     found_end - found_begin - wildcard_pos)
-                        + it_string_to_replace->substr(wildcard_pos_replace+1) ;
-                    str.replace(
-                        found_begin,
-                        found_end + (it_string_to_find->size() - wildcard_pos - 1 ) - found_begin,
-                        replace_content);
-
-                }
-            }
-
-            // may adapt the restart to the replacement and be more efficient
-            found_begin = str.find( it_string_to_find->substr(0, wildcard_pos), found_begin + 1 );
-       }
-    }
-
-    return str;
-}
-
-} // namespace utils
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_ALGORITHM_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/assign_op.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/assign_op.hpp
deleted file mode 100644
index 89d8bfa9568..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/assign_op.hpp
+++ /dev/null
@@ -1,39 +0,0 @@
-//  (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 : overloadable assignment
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_ASSIGN_OP_HPP
-#define BOOST_TEST_UTILS_ASSIGN_OP_HPP
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************             generic assign operator          ************** //
-// ************************************************************************** //
-
-// generic
-template<typename T,typename S>
-inline void
-assign_op( T& t, S const& s, long )
-{
-    t = s;
-}
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-} // namespace boost
-
-#endif // BOOST_TEST_UTILS_ASSIGN_OP_HPP
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/basic_cstring/basic_cstring.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/basic_cstring/basic_cstring.hpp
deleted file mode 100644
index d6259990e06..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/basic_cstring/basic_cstring.hpp
+++ /dev/null
@@ -1,738 +0,0 @@
-//  (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 : class basic_cstring wraps C string and provide std_string like
-//                interface
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_BASIC_CSTRING_HPP
-#define BOOST_TEST_UTILS_BASIC_CSTRING_HPP
-
-// Boost.Test
-#include <boost/test/utils/basic_cstring/basic_cstring_fwd.hpp>
-#include <boost/test/utils/basic_cstring/bcs_char_traits.hpp>
-
-// Boost
-#include <boost/type_traits/remove_cv.hpp>
-
-// STL
-#include <string>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                basic_cstring                 ************** //
-// ************************************************************************** //
-
-template<typename CharT>
-class basic_cstring {
-    typedef basic_cstring<CharT>                        self_type;
-public:
-    // Subtypes
-    typedef ut_detail::bcs_char_traits<CharT>           traits_type;
-    typedef typename ut_detail::bcs_char_traits<CharT>::std_string  std_string;
-
-    typedef CharT                                       value_type;
-    typedef typename remove_cv<value_type>::type        value_ret_type;
-    typedef value_type*                                 pointer;
-    typedef value_type const*                           const_pointer;
-    typedef value_type&                                 reference;
-    typedef const value_type&                           const_reference;
-    typedef std::size_t                                 size_type;
-    typedef std::ptrdiff_t                              difference_type;
-
-    typedef value_type const*                           const_iterator;
-    typedef value_type*                                 iterator;
-
-    // !! should also present reverse_iterator, const_reverse_iterator
-
-#if !BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
-    enum npos_type { npos = static_cast<size_type>(-1) };
-#else
-    // IBM/VisualAge version 6 is not able to handle enums larger than 4 bytes.
-    // But size_type is 8 bytes in 64bit mode.
-    static const size_type npos = -1 ;
-#endif
-
-    static pointer  null_str();
-
-    // Constructors; default copy constructor is generated by compiler
-    basic_cstring();
-    basic_cstring( std_string const& s );
-    basic_cstring( pointer s );
-    template<typename LenType>
-    basic_cstring( pointer s, LenType len ) : m_begin( s ), m_end( m_begin + len ) {}
-    basic_cstring( pointer first, pointer last );
-
-    // data access methods
-    value_ret_type  operator[]( size_type index ) const;
-    value_ret_type  at( size_type index ) const;
-
-    // size operators
-    size_type       size() const;
-    bool            is_empty() const;
-    void            clear();
-    void            resize( size_type new_len );
-
-    // !! only for STL container conformance use is_empty instead
-    bool            empty() const;
-
-    // Trimming
-    self_type&      trim_right( size_type trim_size );
-    self_type&      trim_left( size_type trim_size );
-    self_type&      trim_right( iterator it );
-    self_type&      trim_left( iterator it );
-#if !BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(800))
-    self_type&      trim_left( self_type exclusions = self_type() ) ;
-    self_type&      trim_right( self_type exclusions = self_type() ) ;
-    self_type&      trim( self_type exclusions = self_type() ) ;
-#else
-    // VA C++/XL C++ v6 and v8 has in this case a problem with the default arguments.
-    self_type&      trim_left( self_type exclusions );
-    self_type&      trim_right( self_type exclusions );
-    self_type&      trim( self_type exclusions );
-    self_type&      trim_left()     { return trim_left( self_type() ); }
-    self_type&      trim_right()    { return trim_right( self_type() ); }
-    self_type&      trim()          { return trim( self_type() ); }
-#endif
-
-    // Assignment operators
-    basic_cstring&  operator=( self_type const& s );
-    basic_cstring&  operator=( std_string const& s );
-    basic_cstring&  operator=( pointer s );
-
-    template<typename CharT2>
-    basic_cstring&  assign( basic_cstring<CharT2> const& s )
-    {
-        return *this = basic_cstring<CharT>( s.begin(), s.end() );
-    }
-    template<typename PosType, typename LenType>
-    basic_cstring&  assign( self_type const& s, PosType pos, LenType len )
-    {
-        return *this = self_type( s.m_begin + pos, len );
-    }
-
-    basic_cstring&  assign( std_string const& s );
-    template<typename PosType, typename LenType>
-    basic_cstring&  assign( std_string const& s, PosType pos, LenType len )
-    {
-        return *this = self_type( s.c_str() + pos, len );
-    }
-    basic_cstring&  assign( pointer s );
-    template<typename LenType>
-    basic_cstring&  assign( pointer s, LenType len )
-    {
-        return *this = self_type( s, len );
-    }
-    basic_cstring&  assign( pointer f, pointer l );
-
-    // swapping
-    void            swap( self_type& s );
-
-    // Iterators
-    iterator        begin();
-    const_iterator  begin() const;
-    iterator        end();
-    const_iterator  end() const;
-
-    // !! should have rbegin, rend
-
-    // substring search operation
-    size_type       find( basic_cstring ) const;
-    size_type       rfind( basic_cstring ) const;
-    self_type       substr( size_type beg_index, size_type end_index = npos ) const;
-
-private:
-    static self_type default_trim_ex();
-
-    // Data members
-    iterator        m_begin;
-    iterator        m_end;
-};
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::pointer
-basic_cstring<CharT>::null_str()
-{
-    static CharT null = 0;
-    return &null;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline
-basic_cstring<CharT>::basic_cstring()
-: m_begin( null_str() )
-, m_end( m_begin )
-{
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline
-basic_cstring<CharT>::basic_cstring( std_string const& s )
-: m_begin( s.c_str() )
-, m_end( m_begin + s.size() )
-{
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline
-basic_cstring<CharT>::basic_cstring( pointer s )
-: m_begin( s ? s : null_str() )
-, m_end  ( m_begin + (s ? traits_type::length( s ) : 0 ) )
-{
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline
-basic_cstring<CharT>::basic_cstring( pointer first, pointer last )
-: m_begin( first )
-, m_end( last )
-{
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::value_ret_type
-basic_cstring<CharT>::operator[]( size_type index ) const
-{
-    return m_begin[index];
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::value_ret_type
-basic_cstring<CharT>::at( size_type index ) const
-{
-    if( m_begin + index >= m_end )
-        return static_cast<value_type>(0);
-
-    return m_begin[index];
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::size_type
-basic_cstring<CharT>::size() const
-{
-    return static_cast<size_type>(m_end - m_begin);
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline bool
-basic_cstring<CharT>::is_empty() const
-{
-    return m_end == m_begin;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline bool
-basic_cstring<CharT>::empty() const
-{
-    return is_empty();
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline void
-basic_cstring<CharT>::clear()
-{
-    m_begin = m_end;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline void
-basic_cstring<CharT>::resize( size_type new_len )
-{
-    if( m_begin + new_len < m_end )
-        m_end = m_begin + new_len;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::trim_left( size_type trim_size )
-{
-    m_begin += trim_size;
-    if( m_end <= m_begin )
-        clear();
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::trim_left( iterator it )
-{
-    m_begin = it;
-    if( m_end <= m_begin )
-        clear();
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::trim_left( basic_cstring exclusions )
-{
-    if( exclusions.is_empty() )
-        exclusions = default_trim_ex();
-
-    iterator it;
-    for( it = begin(); it != end(); ++it ) {
-        if( traits_type::find( exclusions.begin(), exclusions.size(), *it ) == reinterpret_cast<pointer>(0) )
-            break;
-    }
-
-    return trim_left( it );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::trim_right( size_type trim_size )
-{
-    m_end  -= trim_size;
-    if( m_end <= m_begin )
-        clear();
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::trim_right( iterator it )
-{
-    m_end = it;
-    if( m_end <= m_begin )
-        clear();
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::trim_right( basic_cstring exclusions )
-{
-    if( exclusions.is_empty() )
-        exclusions = default_trim_ex();
-
-    iterator it;
-
-    for( it = end()-1; it != begin()-1; --it ) {
-        if( self_type::traits_type::find( exclusions.begin(),  exclusions.size(), *it ) == reinterpret_cast<pointer>(0) )
-            break;
-    }
-
-    return trim_right( it+1 );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::trim( basic_cstring exclusions )
-{
-    trim_left( exclusions );
-    trim_right( exclusions );
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::operator=( basic_cstring<CharT> const& s )
-{
-    m_begin = s.m_begin;
-    m_end   = s.m_end;
-
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::operator=( std_string const& s )
-{
-    return *this = self_type( s );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::operator=( pointer s )
-{
-    return *this = self_type( s );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::assign( std_string const& s )
-{
-    return *this = self_type( s );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::assign( pointer s )
-{
-    return *this = self_type( s );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>&
-basic_cstring<CharT>::assign( pointer f, pointer l )
-{
-    return *this = self_type( f, l );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline void
-basic_cstring<CharT>::swap( basic_cstring<CharT>& s )
-{
-    // do not want to include alogrithm
-    pointer tmp1    = m_begin;
-    pointer tmp2    = m_end;
-
-    m_begin         = s.m_begin;
-    m_end           = s.m_end;
-
-    s.m_begin       = tmp1;
-    s.m_end         = tmp2;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::iterator
-basic_cstring<CharT>::begin()
-{
-    return m_begin;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::const_iterator
-basic_cstring<CharT>::begin() const
-{
-    return m_begin;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::iterator
-basic_cstring<CharT>::end()
-{
-    return m_end;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::const_iterator
-basic_cstring<CharT>::end() const
-{
-    return m_end;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::size_type
-basic_cstring<CharT>::find( basic_cstring<CharT> str ) const
-{
-    if( str.is_empty() || str.size() > size() )
-        return static_cast<size_type>(npos);
-
-    const_iterator it   = begin();
-    const_iterator last = end() - str.size() + 1;
-
-    while( it != last ) {
-        if( traits_type::compare( it, str.begin(), str.size() ) == 0 )
-            break;
-
-        ++it;
-    }
-
-    return it == last ? npos : static_cast<size_type>(it - begin());
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::size_type
-basic_cstring<CharT>::rfind( basic_cstring<CharT> str ) const
-{
-    if( str.is_empty() || str.size() > size() )
-        return static_cast<size_type>(npos);
-
-    const_iterator it   = end() - str.size();
-    const_iterator last = begin()-1;
-
-    while( it != last ) {
-        if( traits_type::compare( it, str.begin(), str.size() ) == 0 )
-            break;
-
-        --it;
-    }
-
-    return it == last ? static_cast<size_type>(npos) : static_cast<size_type>(it - begin());
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>
-basic_cstring<CharT>::substr( size_type beg_index, size_type end_index ) const
-{
-    return beg_index > size()
-            ?       self_type()
-            : end_index > size()
-                ?   self_type( m_begin + beg_index, m_end )
-                :   self_type( m_begin + beg_index, m_begin + end_index );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline basic_cstring<CharT>
-basic_cstring<CharT>::default_trim_ex()
-{
-    static CharT ws[3] = { CharT(' '), CharT('\t'), CharT('\n') }; // !! wide case
-
-    return self_type( ws, 3 );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************             comparison operators             ************** //
-// ************************************************************************** //
-
-template<typename CharT1,typename CharT2>
-inline bool
-operator==( basic_cstring<CharT1> const& s1, basic_cstring<CharT2> const& s2 )
-{
-    typedef typename basic_cstring<CharT1>::traits_type traits_type;
-    return s1.size() == s2.size() &&
-               traits_type::compare( s1.begin(), s2.begin(), s1.size() ) == 0;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT1,typename CharT2>
-inline bool
-operator==( basic_cstring<CharT1> const& s1, CharT2* s2 )
-{
-#if !defined(__DMC__)
-    return s1 == basic_cstring<CharT2>( s2 );
-#else
-    return s1 == basic_cstring<CharT2 const>( s2 );
-#endif
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline bool
-operator==( basic_cstring<CharT> const& s1, typename basic_cstring<CharT>::std_string const& s2 )
-{
-    return s1 == basic_cstring<CharT>( s2 );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT1,typename CharT2>
-inline bool
-operator==( CharT1* s2, basic_cstring<CharT2> const& s1 )
-{
-    return s1 == s2;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline bool
-operator==( typename basic_cstring<CharT>::std_string const& s2, basic_cstring<CharT> const& s1 )
-{
-    return s1 == s2;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline bool
-operator!=( basic_cstring<CharT> const& s1, CharT* s2 )
-{
-    return !(s1 == s2);
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline bool
-operator!=( CharT* s2, basic_cstring<CharT> const& s1 )
-{
-    return !(s1 == s2);
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline bool
-operator!=( basic_cstring<CharT> const& s1, basic_cstring<CharT> const& s2 )
-{
-    return !(s1 == s2);
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline bool
-operator!=( basic_cstring<CharT> const& s1, typename basic_cstring<CharT>::std_string const& s2 )
-{
-    return !(s1 == s2);
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT>
-inline bool
-operator!=( typename basic_cstring<CharT>::std_string const& s2, basic_cstring<CharT> const& s1 )
-{
-    return !(s1 == s2);
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                  first_char                  ************** //
-// ************************************************************************** //
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::value_ret_type
-first_char( basic_cstring<CharT> source )
-{
-    typedef typename basic_cstring<CharT>::value_ret_type res_type;
-
-    return source.is_empty() ? static_cast<res_type>(0) : *source.begin();
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                  last_char                   ************** //
-// ************************************************************************** //
-
-template<typename CharT>
-inline typename basic_cstring<CharT>::value_ret_type
-last_char( basic_cstring<CharT> source )
-{
-    typedef typename basic_cstring<CharT>::value_ret_type res_type;
-
-    return source.is_empty() ? static_cast<res_type>(0) : *(source.end()-1);
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                  assign_op                   ************** //
-// ************************************************************************** //
-
-template<typename CharT1, typename CharT2>
-inline void
-assign_op( std::basic_string<CharT1>& target, basic_cstring<CharT2> src, int )
-{
-    target.assign( src.begin(), src.size() );
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT1, typename CharT2>
-inline std::basic_string<CharT1>&
-operator+=( std::basic_string<CharT1>& target, basic_cstring<CharT2> const& str )
-{
-    target.append( str.begin(), str.end() );
-    return target;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT1, typename CharT2>
-inline std::basic_string<CharT1>
-operator+( std::basic_string<CharT1> const& lhs, basic_cstring<CharT2> const& rhs )
-{
-    std::basic_string<CharT1> res( lhs );
-
-    res.append( rhs.begin(), rhs.end() );
-    return res;
-}
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-
-} // namespace boost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_BASIC_CSTRING_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/basic_cstring/basic_cstring_fwd.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/basic_cstring/basic_cstring_fwd.hpp
deleted file mode 100644
index f0622263d19..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/basic_cstring/basic_cstring_fwd.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-//  (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 : basic_cstring class wrap C string and provide std_string like
-//                interface
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_BASIC_CSTRING_FWD_HPP
-#define BOOST_TEST_UTILS_BASIC_CSTRING_FWD_HPP
-
-#include <boost/detail/workaround.hpp>
-
-namespace boost {
-
-namespace unit_test {
-
-template<typename CharT> class      basic_cstring;
-typedef basic_cstring<char const>   const_string;
-#if BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590041))
-typedef const_string                literal_string;
-#else
-typedef const_string const          literal_string;
-#endif
-
-typedef char const* const           c_literal_string;
-
-} // namespace unit_test
-
-} // namespace boost
-
-#endif // BOOST_TEST_UTILS_BASIC_CSTRING_FWD_HPP
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/basic_cstring/bcs_char_traits.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/basic_cstring/bcs_char_traits.hpp
deleted file mode 100644
index eb77f474c75..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/basic_cstring/bcs_char_traits.hpp
+++ /dev/null
@@ -1,150 +0,0 @@
-//  (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 : generic char traits class; wraps std::char_traits
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_BCS_CHAR_TRAITS_HPP
-#define BOOST_TEST_UTILS_BCS_CHAR_TRAITS_HPP
-
-// Boost
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/test/detail/config.hpp>
-#include <boost/type_traits/add_const.hpp>
-
-// STL
-#include <string>                       // std::char_traits
-#include <cstddef>                      // std::size_t
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-
-namespace unit_test {
-
-namespace ut_detail {
-
-template<typename CharT> struct bcs_base_char           { typedef CharT type; };
-
-template<> struct bcs_base_char<char const>             { typedef char type; };
-template<> struct bcs_base_char<unsigned char>          { typedef char type; };
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-template<> struct bcs_base_char<unsigned char const>    { typedef char type; };
-#endif
-
-template<> struct bcs_base_char<wchar_t const>          { typedef wchar_t type; };
-
-// ************************************************************************** //
-// **************               bcs_char_traits                ************** //
-// ************************************************************************** //
-
-template<typename CharT>
-struct bcs_char_traits_impl
-{
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-    typedef CharT const const_char;
-#else
-    typedef typename boost::add_const<CharT>::type const_char;
-#endif
-    static bool eq( CharT c1, CharT c2 )
-    {
-        return c1 == c2;
-    }
-    static bool lt( CharT c1, CharT c2 )
-    {
-        return c1 < c2;
-    }
-
-    static int compare( const_char* cstr1, const_char* cstr2, std::size_t n )
-    {
-        while( n > 0 ) {
-            if( !eq( *cstr1, *cstr2 ) )
-                return lt( *cstr1, *cstr2 ) ? -1 : 1;
-            ++cstr1;
-            ++cstr2;
-            --n;
-        }
-
-        return 0;
-    }
-
-    static std::size_t length( const_char* cstr )
-    {
-        const_char null_char = CharT();
-
-        const_char* ptr = cstr;
-        while( !eq( *ptr, null_char ) )
-            ++ptr;
-
-        return ptr - cstr;
-    }
-
-    static const_char* find( const_char* s, std::size_t n, CharT c )
-    {
-        while( n > 0 ) {
-            if( eq( *s, c ) )
-                return s;
-
-            ++s;
-            --n;
-        }
-        return 0;
-    }
-};
-
-#ifdef BOOST_CLASSIC_IOSTREAMS
-template<typename CharT>
-struct char_traits_with_find : std::string_char_traits<CharT> {
-    static CharT const* find( CharT const* s, std::size_t n, CharT c )
-    {
-        while( n > 0 ) {
-            if( eq( *s, c ) )
-                return s;
-
-            ++s;
-            --n;
-        }
-        return 0;
-    }
-};
-
-template<> struct bcs_char_traits_impl<char> : public char_traits_with_find<char> {};
-template<> struct bcs_char_traits_impl<wchar_t> : public char_traits_with_find<wchar_t> {};
-#else
-template<> struct bcs_char_traits_impl<char> : public std::char_traits<char> {};
-template<> struct bcs_char_traits_impl<wchar_t> : public std::char_traits<wchar_t> {};
-#endif
-
-template<typename CharT>
-class bcs_char_traits : public bcs_char_traits_impl<CharT> {
-    typedef typename ut_detail::bcs_base_char<CharT>::type                              the_base_char;
-public:
-#ifdef BOOST_CLASSIC_IOSTREAMS
-    typedef std::basic_string<the_base_char, std::string_char_traits<the_base_char> >   std_string;
-#else
-    typedef std::basic_string<the_base_char, std::char_traits<the_base_char> >          std_string;
-#endif
-};
-
-} // namespace ut_detail
-
-} // namespace unit_test
-
-} // namespace boost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_BCS_CHAR_TRAITS_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/basic_cstring/compare.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/basic_cstring/compare.hpp
deleted file mode 100644
index b416b1f2b94..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/basic_cstring/compare.hpp
+++ /dev/null
@@ -1,147 +0,0 @@
-//  (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 : class basic_cstring comparisons implementation
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_BASIC_CSTRING_COMPARE_HPP
-#define BOOST_TEST_UTILS_BASIC_CSTRING_COMPARE_HPP
-
-// Boost.Test
-#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
-
-// STL
-#include <functional>
-#include <cctype>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-# if defined(BOOST_NO_STDC_NAMESPACE) && !BOOST_WORKAROUND(__BORLANDC__, <= 0x570)
-namespace std { using ::toupper; }
-# endif
-
-namespace boost {
-
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                case_ins_compare              ************** //
-// ************************************************************************** //
-
-namespace ut_detail {
-
-template<class CharT>
-struct case_ins
-{
-    static bool         eq( CharT c1, CharT c2 ) { return (std::toupper)( c1 ) == (std::toupper)( c2 ); }
-    static bool         lt( CharT c1, CharT c2 ) { return (std::toupper)( c1 ) <  (std::toupper)( c2 ); }
-
-    static int          compare( CharT const* s1, CharT const* s2, std::size_t n )
-    {
-        for( std::size_t i = 0; i < n; ++i ) {
-            if( !eq( s1[i], s2[i] ) )
-                return lt( s1[i], s2[i] ) ? -1 : 1;
-        }
-        return 0;
-    }
-};
-
-} // namespace ut_detail
-
-// ************************************************************************** //
-// **************                  case_ins_eq                 ************** //
-// ************************************************************************** //
-
-template<class CharT>
-inline bool
-case_ins_eq( basic_cstring<CharT> x, basic_cstring<CharT> y )
-{
-    return x.size() == y.size() && ut_detail::case_ins<CharT>::compare( x.begin(), y.begin(), x.size() ) == 0;
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                 case_ins_less                ************** //
-// ************************************************************************** //
-
-template<class CharT>
-class case_ins_less : public std::binary_function<basic_cstring<CharT>,basic_cstring<CharT>,bool>
-{
-public:
-    bool operator()( basic_cstring<CharT> x, basic_cstring<CharT> y ) const
-    {
-        return x.size() != y.size()
-                ? x.size() < y.size()
-                : ut_detail::case_ins<CharT>::compare( x.begin(), y.begin(), x.size() ) < 0;
-    }
-};
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                 operators <,>                ************** //
-// ************************************************************************** //
-
-template<class CharT>
-inline bool
-operator <( boost::unit_test::basic_cstring<CharT> const& x,
-            boost::unit_test::basic_cstring<CharT> const& y )
-{
-    typedef typename boost::unit_test::basic_cstring<CharT>::traits_type traits_type;
-    return x.size() != y.size()
-            ? x.size() < y.size()
-            : traits_type::compare( x.begin(), y.begin(), x.size() ) < 0;
-}
-
-//____________________________________________________________________________//
-
-template<class CharT>
-inline bool
-operator <=( boost::unit_test::basic_cstring<CharT> const& x,
-            boost::unit_test::basic_cstring<CharT> const& y )
-{
-    return !(y < x);
-}
-
-//____________________________________________________________________________//
-
-template<class CharT>
-inline bool
-operator >( boost::unit_test::basic_cstring<CharT> const& x,
-            boost::unit_test::basic_cstring<CharT> const& y )
-{
-    return y < x;
-}
-
-//____________________________________________________________________________//
-
-template<class CharT>
-inline bool
-operator >=( boost::unit_test::basic_cstring<CharT> const& x,
-            boost::unit_test::basic_cstring<CharT> const& y )
-{
-    return !(x < y);
-}
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-
-} // namespace boost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_BASIC_CSTRING_COMPARE_HPP_071894GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/basic_cstring/io.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/basic_cstring/io.hpp
deleted file mode 100644
index 02ccb126f8c..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/basic_cstring/io.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-//  (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 : basic_cstring i/o implementation
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_BASIC_CSTRING_IO_HPP
-#define BOOST_TEST_UTILS_BASIC_CSTRING_IO_HPP
-
-// Boost.Test
-#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
-
-// STL
-#include <iosfwd>
-#include <string>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-
-namespace unit_test {
-
-#ifdef BOOST_CLASSIC_IOSTREAMS
-
-template<typename CharT>
-inline std::ostream&
-operator<<( std::ostream& os, basic_cstring<CharT> const& str )
-{
-    typedef typename ut_detail::bcs_base_char<CharT>::type char_type;
-    char_type const* const beg = reinterpret_cast<char_type const* const>( str.begin() );
-    char_type const* const end = reinterpret_cast<char_type const* const>( str.end() );
-    os << std::basic_string<char_type>( beg, end - beg );
-
-    return os;
-}
-
-#else
-
-template<typename CharT1, typename Tr,typename CharT2>
-inline std::basic_ostream<CharT1,Tr>&
-operator<<( std::basic_ostream<CharT1,Tr>& os, basic_cstring<CharT2> const& str )
-{
-    CharT1 const* const beg = reinterpret_cast<CharT1 const*>( str.begin() ); // !!
-    CharT1 const* const end = reinterpret_cast<CharT1 const*>( str.end() );
-    os << std::basic_string<CharT1,Tr>( beg, end - beg );
-
-    return os;
-}
-
-#endif
-
-//____________________________________________________________________________//
-
-
-} // namespace unit_test
-
-} // namespace boost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_BASIC_CSTRING_IO_HPP_071894GER
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/class_properties.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/class_properties.hpp
deleted file mode 100644
index d4f3db3f2d8..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/class_properties.hpp
+++ /dev/null
@@ -1,195 +0,0 @@
-//  (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 : simple facility that mimmic notion of read-only read-write
-//  properties in C++ classes. Original idea by Henrik Ravn.
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_CLASS_PROPERTIES_HPP
-#define BOOST_TEST_UTILS_CLASS_PROPERTIES_HPP
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-
-// Boost
-#if !BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
-#include <boost/preprocessor/seq/for_each.hpp>
-#endif
-#include <boost/call_traits.hpp>
-#include <boost/type_traits/add_pointer.hpp>
-#include <boost/type_traits/add_const.hpp>
-#include <boost/utility/addressof.hpp>
-
-// STL
-#include <iosfwd>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                 class_property               ************** //
-// ************************************************************************** //
-
-template<class PropertyType>
-class class_property {
-protected:
-    typedef typename call_traits<PropertyType>::const_reference     read_access_t;
-    typedef typename call_traits<PropertyType>::param_type          write_param_t;
-    typedef typename add_pointer<typename add_const<PropertyType>::type>::type address_res_t;
-public:
-    // Constructor
-                    class_property() : value( PropertyType() ) {}
-    explicit        class_property( write_param_t init_value )
-    : value( init_value ) {}
-
-    // Access methods
-    operator        read_access_t() const   { return value; }
-    read_access_t   get() const             { return value; }
-    bool            operator!() const       { return !value; }
-    address_res_t   operator&() const       { return &value; }
-
-    // Data members
-#ifndef BOOST_TEST_NO_PROTECTED_USING
-protected:
-#endif
-    PropertyType        value;
-};
-
-//____________________________________________________________________________//
-
-#ifdef BOOST_CLASSIC_IOSTREAMS
-
-template<class PropertyType>
-inline std::ostream&
-operator<<( std::ostream& os, class_property<PropertyType> const& p )
-
-#else
-
-template<typename CharT1, typename Tr,class PropertyType>
-inline std::basic_ostream<CharT1,Tr>&
-operator<<( std::basic_ostream<CharT1,Tr>& os, class_property<PropertyType> const& p )
-
-#endif
-{
-    return os << p.get();
-}
-
-//____________________________________________________________________________//
-
-#define DEFINE_PROPERTY_FREE_BINARY_OPERATOR( op )                              \
-template<class PropertyType>                                                    \
-inline bool                                                                     \
-operator op( PropertyType const& lhs, class_property<PropertyType> const& rhs ) \
-{                                                                               \
-    return lhs op rhs.get();                                                    \
-}                                                                               \
-template<class PropertyType>                                                    \
-inline bool                                                                     \
-operator op( class_property<PropertyType> const& lhs, PropertyType const& rhs ) \
-{                                                                               \
-    return lhs.get() op rhs;                                                    \
-}                                                                               \
-template<class PropertyType>                                                    \
-inline bool                                                                     \
-operator op( class_property<PropertyType> const& lhs,                           \
-             class_property<PropertyType> const& rhs )                          \
-{                                                                               \
-    return lhs.get() op rhs.get();                                              \
-}                                                                               \
-/**/
-
-DEFINE_PROPERTY_FREE_BINARY_OPERATOR( == )
-DEFINE_PROPERTY_FREE_BINARY_OPERATOR( != )
-
-#undef DEFINE_PROPERTY_FREE_BINARY_OPERATOR
-
-// ************************************************************************** //
-// **************               readonly_property              ************** //
-// ************************************************************************** //
-
-template<class PropertyType>
-class readonly_property : public class_property<PropertyType> {
-    typedef class_property<PropertyType>         base_prop;
-    typedef typename base_prop::address_res_t    arrow_res_t;
-protected:
-    typedef typename base_prop::write_param_t    write_param_t;
-public:
-    // Constructor
-                    readonly_property() {}
-    explicit        readonly_property( write_param_t init_value ) : base_prop( init_value ) {}
-
-    // access methods
-    arrow_res_t     operator->() const      { return boost::addressof( base_prop::value ); }
-};
-
-//____________________________________________________________________________//
-
-#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
-
-#define BOOST_READONLY_PROPERTY( property_type, friends ) boost::unit_test::readwrite_property<property_type >
-
-#else
-
-#define BOOST_READONLY_PROPERTY_DECLARE_FRIEND(r, data, elem) friend class elem;
-
-#define BOOST_READONLY_PROPERTY( property_type, friends )                           \
-class BOOST_JOIN( readonly_property, __LINE__ )                                     \
-: public boost::unit_test::readonly_property<property_type > {                      \
-    typedef boost::unit_test::readonly_property<property_type > base_prop;          \
-    BOOST_PP_SEQ_FOR_EACH( BOOST_READONLY_PROPERTY_DECLARE_FRIEND, ' ', friends )   \
-    typedef base_prop::write_param_t  write_param_t;                                \
-public:                                                                             \
-                BOOST_JOIN( readonly_property, __LINE__ )() {}                      \
-    explicit    BOOST_JOIN( readonly_property, __LINE__ )( write_param_t init_v  )  \
-    : base_prop( init_v ) {}                                                        \
-}                                                                                   \
-/**/
-
-#endif
-
-// ************************************************************************** //
-// **************              readwrite_property              ************** //
-// ************************************************************************** //
-
-template<class PropertyType>
-class readwrite_property : public class_property<PropertyType> {
-    typedef class_property<PropertyType>                base_prop;
-    typedef typename add_pointer<PropertyType>::type    arrow_res_t;
-    typedef typename base_prop::address_res_t           const_arrow_res_t;
-    typedef typename base_prop::write_param_t           write_param_t;
-public:
-                    readwrite_property() : base_prop() {}
-    explicit        readwrite_property( write_param_t init_value ) : base_prop( init_value ) {}
-
-    // access methods
-    void            set( write_param_t v )  { base_prop::value = v; }
-    arrow_res_t     operator->()            { return boost::addressof( base_prop::value ); }
-    const_arrow_res_t operator->() const    { return boost::addressof( base_prop::value ); }
-
-#ifndef BOOST_TEST_NO_PROTECTED_USING
-    using           base_prop::value;
-#endif
-};
-
-//____________________________________________________________________________//
-
-} // unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#undef BOOST_TEST_NO_PROTECTED_USING
-
-#endif // BOOST_TEST_UTILS_CLASS_PROPERTIES_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/custom_manip.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/custom_manip.hpp
deleted file mode 100644
index d5ddaf5c077..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/custom_manip.hpp
+++ /dev/null
@@ -1,61 +0,0 @@
-//  (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 : simple helpers for creating cusom output manipulators
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_CUSTOM_MANIP_HPP
-#define BOOST_TEST_UTILS_CUSTOM_MANIP_HPP
-
-// STL
-#include <iosfwd>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace utils {
-
-// ************************************************************************** //
-// **************          custom manipulators helpers         ************** //
-// ************************************************************************** //
-
-template<typename Manip>
-struct custom_printer {
-    explicit custom_printer( std::ostream& ostr ) : m_ostr( &ostr ) {}
-
-    std::ostream& operator*() const { return *m_ostr; }
-
-private:
-    std::ostream* const m_ostr;
-};
-
-//____________________________________________________________________________//
-
-template<typename Uniq> struct custom_manip {};
-
-//____________________________________________________________________________//
-
-template<typename Uniq>
-inline custom_printer<custom_manip<Uniq> >
-operator<<( std::ostream& ostr, custom_manip<Uniq> const& ) { return custom_printer<custom_manip<Uniq> >( ostr ); }
-
-//____________________________________________________________________________//
-
-} // namespace utils
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_CUSTOM_MANIP_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/foreach.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/foreach.hpp
deleted file mode 100644
index 68462ae7193..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/foreach.hpp
+++ /dev/null
@@ -1,316 +0,0 @@
-//  (C) Copyright Eric Niebler 2004-2005
-//  (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 : this is an abridged version of an excelent BOOST_FOREACH facility
-//  presented by Eric Niebler. I am so fond of it so I can't wait till it
-//  going to be accepted into Boost. Also I need version with less number of dependencies
-//  and more portable. This version doesn't support rvalues and will reeveluate it's
-//  parameters, but should be good enough for my purposes.
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_FOREACH_HPP
-#define BOOST_TEST_UTILS_FOREACH_HPP
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-
-// Boost
-#include <boost/type.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/test/detail/workaround.hpp>
-
-#include <boost/type_traits/is_const.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace for_each {
-
-// ************************************************************************** //
-// **************                  static_any                  ************** //
-// ************************************************************************** //
-
-struct static_any_base
-{
-    operator bool() const { return false; }
-};
-
-//____________________________________________________________________________//
-
-template<typename Iter>
-struct static_any : static_any_base
-{
-    static_any( Iter const& t ) : m_it( t ) {}
-
-    mutable Iter m_it;
-};
-
-//____________________________________________________________________________//
-
-typedef static_any_base const& static_any_t;
-
-//____________________________________________________________________________//
-
-template<typename Iter>
-inline Iter&
-static_any_cast( static_any_t a, Iter* = 0 )
-{
-    return static_cast<Iter&>( static_cast<static_any<Iter> const&>( a ).m_it );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                   is_const                   ************** //
-// ************************************************************************** //
-
-template<typename C>
-inline is_const<C>
-is_const_coll( C& )
-{
-    return is_const<C>();
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                     begin                    ************** //
-// ************************************************************************** //
-
-template<typename C>
-inline static_any<BOOST_DEDUCED_TYPENAME C::iterator>
-begin( C& t, mpl::false_ )
-{
-    return static_any<BOOST_DEDUCED_TYPENAME C::iterator>( t.begin() );
-}
-
-//____________________________________________________________________________//
-
-template<typename C>
-inline static_any<BOOST_DEDUCED_TYPENAME C::const_iterator>
-begin( C const& t, mpl::true_ )
-{
-    return static_any<BOOST_DEDUCED_TYPENAME C::const_iterator>( t.begin() );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                      end                     ************** //
-// ************************************************************************** //
-
-template<typename C>
-inline static_any<BOOST_DEDUCED_TYPENAME C::iterator>
-end( C& t, mpl::false_ )
-{
-    return static_any<BOOST_DEDUCED_TYPENAME C::iterator>( t.end() );
-}
-
-//____________________________________________________________________________//
-
-template<typename C>
-inline static_any<BOOST_DEDUCED_TYPENAME C::const_iterator>
-end( C const& t, mpl::true_ )
-{
-    return static_any<BOOST_DEDUCED_TYPENAME C::const_iterator>( t.end() );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                      done                    ************** //
-// ************************************************************************** //
-
-template<typename C>
-inline bool
-done( static_any_t cur, static_any_t end, C&, mpl::false_ )
-{
-    return  static_any_cast<BOOST_DEDUCED_TYPENAME C::iterator>( cur ) ==
-            static_any_cast<BOOST_DEDUCED_TYPENAME C::iterator>( end );
-}
-
-//____________________________________________________________________________//
-
-template<typename C>
-inline bool
-done( static_any_t cur, static_any_t end, C const&, mpl::true_ )
-{
-    return  static_any_cast<BOOST_DEDUCED_TYPENAME C::const_iterator>( cur ) ==
-            static_any_cast<BOOST_DEDUCED_TYPENAME C::const_iterator>( end );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                      next                    ************** //
-// ************************************************************************** //
-
-template<typename C>
-inline void
-next( static_any_t cur, C&, mpl::false_ )
-{
-    ++static_any_cast<BOOST_DEDUCED_TYPENAME C::iterator>( cur );
-}
-
-//____________________________________________________________________________//
-
-template<typename C>
-inline void
-next( static_any_t cur, C const&, mpl::true_ )
-{
-    ++static_any_cast<BOOST_DEDUCED_TYPENAME C::const_iterator>( cur );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                      prev                    ************** //
-// ************************************************************************** //
-
-template<typename C>
-inline void
-prev( static_any_t cur, C&, mpl::false_ )
-{
-    --static_any_cast<BOOST_DEDUCED_TYPENAME C::iterator>( cur );
-}
-
-//____________________________________________________________________________//
-
-template<typename C>
-inline void
-prev( static_any_t cur, C const&, mpl::true_ )
-{
-    --static_any_cast<BOOST_DEDUCED_TYPENAME C::const_iterator>( cur );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                      deref                   ************** //
-// ************************************************************************** //
-
-template<class RefType,typename C>
-inline RefType
-deref( static_any_t cur, C&, ::boost::type<RefType>, mpl::false_ )
-{
-    return *static_any_cast<BOOST_DEDUCED_TYPENAME C::iterator>( cur );
-}
-
-//____________________________________________________________________________//
-
-template<class RefType,typename C>
-inline RefType
-deref( static_any_t cur, C const&, ::boost::type<RefType>, mpl::true_ )
-{
-    return *static_any_cast<BOOST_DEDUCED_TYPENAME C::const_iterator>( cur );
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************              BOOST_TEST_FOREACH              ************** //
-// ************************************************************************** //
-
-#define BOOST_TEST_FE_ANY                   ::boost::unit_test::for_each::static_any_t
-#define BOOST_TEST_FE_IS_CONST( COL )       ::boost::unit_test::for_each::is_const_coll( COL )
-
-#define BOOST_TEST_FE_BEG( COL )            \
-    ::boost::unit_test::for_each::begin(    \
-        COL,                                \
-        BOOST_TEST_FE_IS_CONST( COL ) )     \
-/**/
-
-#define BOOST_TEST_FE_END( COL )            \
-    ::boost::unit_test::for_each::end(      \
-        COL,                                \
-        BOOST_TEST_FE_IS_CONST( COL ) )     \
-/**/
-
-#define BOOST_TEST_FE_DONE( COL )           \
-    ::boost::unit_test::for_each::done(     \
-        BOOST_TEST_FE_CUR_VAR,              \
-        BOOST_TEST_FE_END_VAR,              \
-        COL,                                \
-        BOOST_TEST_FE_IS_CONST( COL ) )     \
-/**/
-
-#define BOOST_TEST_FE_NEXT( COL )           \
-    ::boost::unit_test::for_each::next(     \
-        BOOST_TEST_FE_CUR_VAR,              \
-        COL,                                \
-        BOOST_TEST_FE_IS_CONST( COL ) )     \
-/**/
-
-#define BOOST_TEST_FE_PREV( COL )           \
-    ::boost::unit_test::for_each::prev(     \
-        BOOST_TEST_FE_CUR_VAR,              \
-        COL,                                \
-        BOOST_TEST_FE_IS_CONST( COL ) )     \
-/**/
-
-#define BOOST_FOREACH_NOOP(COL)             \
-    ((void)&(COL))
-
-#define BOOST_TEST_FE_DEREF( COL, RefType ) \
-    ::boost::unit_test::for_each::deref(    \
-        BOOST_TEST_FE_CUR_VAR,              \
-        COL,                                \
-        ::boost::type<RefType >(),          \
-        BOOST_TEST_FE_IS_CONST( COL ) )     \
-/**/
-
-#if BOOST_WORKAROUND( BOOST_MSVC, == 1310 )
-#define BOOST_TEST_LINE_NUM
-#else
-#define BOOST_TEST_LINE_NUM     __LINE__
-#endif
-
-#define BOOST_TEST_FE_CUR_VAR   BOOST_JOIN( _fe_cur_, BOOST_TEST_LINE_NUM )
-#define BOOST_TEST_FE_END_VAR   BOOST_JOIN( _fe_end_, BOOST_TEST_LINE_NUM )
-#define BOOST_TEST_FE_CON_VAR   BOOST_JOIN( _fe_con_, BOOST_TEST_LINE_NUM )
-
-#define BOOST_TEST_FOREACH( RefType, var, COL )                                             \
-if( BOOST_TEST_FE_ANY BOOST_TEST_FE_CUR_VAR = BOOST_TEST_FE_BEG( COL ) ) {} else            \
-if( BOOST_TEST_FE_ANY BOOST_TEST_FE_END_VAR = BOOST_TEST_FE_END( COL ) ) {} else            \
-for( bool BOOST_TEST_FE_CON_VAR = true;                                                     \
-          BOOST_TEST_FE_CON_VAR && !BOOST_TEST_FE_DONE( COL );                              \
-          BOOST_TEST_FE_CON_VAR ? BOOST_TEST_FE_NEXT( COL ) : BOOST_FOREACH_NOOP( COL ))    \
-                                                                                            \
-    if( (BOOST_TEST_FE_CON_VAR = false, false) ) {} else                                    \
-    for( RefType var = BOOST_TEST_FE_DEREF( COL, RefType );                                 \
-         !BOOST_TEST_FE_CON_VAR; BOOST_TEST_FE_CON_VAR = true )                             \
-/**/
-
-#define BOOST_TEST_REVERSE_FOREACH( RefType, var, COL )                                     \
-if( BOOST_TEST_FE_ANY BOOST_TEST_FE_CUR_VAR = BOOST_TEST_FE_END( COL ) ) {} else            \
-if( BOOST_TEST_FE_ANY BOOST_TEST_FE_END_VAR = BOOST_TEST_FE_BEG( COL ) ) {} else            \
-for( bool BOOST_TEST_FE_CON_VAR = true;                                                     \
-          BOOST_TEST_FE_CON_VAR && !BOOST_TEST_FE_DONE( COL ); )                            \
-                                                                                            \
-    if( (BOOST_TEST_FE_CON_VAR = false, false) ) {} else                                    \
-    if( (BOOST_TEST_FE_PREV( COL ), false) ) {} else                                        \
-    for( RefType var = BOOST_TEST_FE_DEREF( COL, RefType );                                 \
-         !BOOST_TEST_FE_CON_VAR; BOOST_TEST_FE_CON_VAR = true )                             \
-/**/
-
-//____________________________________________________________________________//
-
-} // namespace for_each
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_FOREACH_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/is_cstring.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/is_cstring.hpp
deleted file mode 100644
index 75af0f348d2..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/is_cstring.hpp
+++ /dev/null
@@ -1,58 +0,0 @@
-//  (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 : defines the is_cstring type trait
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_IS_CSTRING_HPP
-#define BOOST_TEST_UTILS_IS_CSTRING_HPP
-
-// Boost
-#include <boost/mpl/bool.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/decay.hpp>
-#include <boost/type_traits/remove_pointer.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                  is_cstring                  ************** //
-// ************************************************************************** //
-
-namespace ut_detail {
-
-template<typename T>
-struct is_cstring_impl : public mpl::false_ {};
-
-template<typename T>
-struct is_cstring_impl<T const*> : public is_cstring_impl<T*> {};
-
-template<typename T>
-struct is_cstring_impl<T const* const> : public is_cstring_impl<T*> {};
-
-template<>
-struct is_cstring_impl<char*> : public mpl::true_ {};
-
-template<>
-struct is_cstring_impl<wchar_t*> : public mpl::true_ {};
-
-} // namespace ut_detail
-
-template<typename T>
-struct is_cstring : public ut_detail::is_cstring_impl<typename decay<T>::type> {};
-
-} // namespace unit_test
-} // namespace boost
-
-#endif // BOOST_TEST_UTILS_IS_CSTRING_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/is_forward_iterable.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/is_forward_iterable.hpp
deleted file mode 100644
index a7259b82c37..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/is_forward_iterable.hpp
+++ /dev/null
@@ -1,166 +0,0 @@
-//  (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
-//! Defines the is_forward_iterable collection type trait
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_IS_FORWARD_ITERABLE_HPP
-#define BOOST_TEST_UTILS_IS_FORWARD_ITERABLE_HPP
-
-#if defined(BOOST_NO_CXX11_DECLTYPE) || \
-    defined(BOOST_NO_CXX11_NULLPTR) || \
-    defined(BOOST_NO_CXX11_TRAILING_RESULT_TYPES)
-
-  // some issues with boost.config
-  #if !defined(BOOST_MSVC) || BOOST_MSVC_FULL_VER < 170061030 /* VC2012 upd 5 */
-    #define BOOST_TEST_FWD_ITERABLE_CXX03
-  #endif
-#endif
-
-#if defined(BOOST_TEST_FWD_ITERABLE_CXX03)
-// Boost
-#include <boost/mpl/bool.hpp>
-
-// STL
-#include <list>
-#include <vector>
-#include <map>
-#include <set>
-
-#else
-
-// Boost
-#include <boost/utility/declval.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/test/utils/is_cstring.hpp>
-
-// STL
-#include <utility>
-#include <type_traits>
-
-#endif
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************             is_forward_iterable              ************** //
-// ************************************************************************** //
-
-#if defined(BOOST_TEST_FWD_ITERABLE_CXX03) && !defined(BOOST_TEST_DOXYGEN_DOC__)
-template<typename T>
-struct is_forward_iterable : public mpl::false_ {};
-
-template<typename T>
-struct is_forward_iterable<T const> : public is_forward_iterable<T> {};
-
-template<typename T>
-struct is_forward_iterable<T&> : public is_forward_iterable<T> {};
-
-template<typename T, typename A>
-struct is_forward_iterable< std::vector<T, A> > : public mpl::true_ {};
-
-template<typename T, typename A>
-struct is_forward_iterable< std::list<T, A> > : public mpl::true_ {};
-
-template<typename K, typename V, typename C, typename A>
-struct is_forward_iterable< std::map<K, V, C, A> > : public mpl::true_ {};
-
-template<typename K, typename C, typename A>
-struct is_forward_iterable< std::set<K, C, A> > : public mpl::true_ {};
-
-#else
-
-namespace ut_detail {
-
-template<typename T>
-struct is_present : public mpl::true_ {};
-
-//____________________________________________________________________________//
-
-// some compiler do not implement properly decltype non expression involving members (eg. VS2013)
-// a workaround is to use -> decltype syntax.
-template <class T>
-struct has_member_size {
-private:
-    struct nil_t {};
-    template<typename U> static auto  test( U* ) -> decltype(boost::declval<U>().size());
-    template<typename>   static nil_t test( ... );
-
-public:
-    static bool const value = !std::is_same< decltype(test<T>( nullptr )), nil_t>::value;
-};
-
-//____________________________________________________________________________//
-
-template <class T>
-struct has_member_begin {
-private:
-    struct nil_t {};
-    template<typename U>  static auto  test( U* ) -> decltype(boost::declval<U>().begin());
-    template<typename>    static nil_t test( ... );
-public:
-    static bool const value = !std::is_same< decltype(test<T>( nullptr )), nil_t>::value;
-};
-
-//____________________________________________________________________________//
-
-template <class T>
-struct has_member_end {
-private:
-    struct nil_t {};
-    template<typename U>  static auto  test( U* ) -> decltype(boost::declval<U>().end());
-    template<typename>    static nil_t test( ... );
-public:
-    static bool const value = !std::is_same< decltype(test<T>( nullptr )), nil_t>::value;
-};
-
-//____________________________________________________________________________//
-
-template <class T, class enabled = void>
-struct is_forward_iterable_impl : std::false_type {
-};
-
-//____________________________________________________________________________//
-
-template <class T>
-struct is_forward_iterable_impl<
-    T,
-    typename std::enable_if<
-    is_present<typename T::const_iterator>::value &&
-    is_present<typename T::value_type>::value &&
-    has_member_size<T>::value &&
-    has_member_begin<T>::value &&
-    has_member_end<T>::value &&
-    !is_cstring<T>::value
-    >::type
-> : std::true_type
-{};
-
-//____________________________________________________________________________//
-
-} // namespace ut_detail
-
-/*! Indicates that a specific type implements the forward iterable concept. */
-template<typename T>
-struct is_forward_iterable {
-    typedef typename std::remove_reference<T>::type T_ref;
-    typedef ut_detail::is_forward_iterable_impl<T_ref> is_fwd_it_t;
-    typedef mpl::bool_<is_fwd_it_t::value> type;
-    enum { value = is_fwd_it_t::value };
-};
-
-#endif /* defined(BOOST_TEST_FWD_ITERABLE_CXX03) */
-
-} // namespace unit_test
-} // namespace boost
-
-#endif // BOOST_TEST_UTILS_IS_FORWARD_ITERABLE_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/iterator/input_iterator_facade.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/iterator/input_iterator_facade.hpp
deleted file mode 100644
index d695ee3a87e..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/iterator/input_iterator_facade.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-//  (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
-//! Input iterator facade
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_INPUT_ITERATOR_FACADE_HPP
-#define BOOST_TEST_UTILS_INPUT_ITERATOR_FACADE_HPP
-
-// Boost
-#include <boost/iterator/iterator_facade.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace utils {
-
-// ************************************************************************** //
-// **************          input_iterator_core_access          ************** //
-// ************************************************************************** //
-
-class input_iterator_core_access
-{
-#if defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x551))
-public:
-#else
-    template <class I, class V, class R, class TC> friend class input_iterator_facade;
-#endif
-
-    template <class Facade>
-    static bool get( Facade& f )
-    {
-        return f.get();
-    }
-
-private:
-    // objects of this class are useless
-    input_iterator_core_access(); //undefined
-};
-
-// ************************************************************************** //
-// **************            input_iterator_facade             ************** //
-// ************************************************************************** //
-
-template<typename Derived,
-         typename ValueType,
-         typename Reference = ValueType const&,
-         typename Traversal = single_pass_traversal_tag>
-class input_iterator_facade : public iterator_facade<Derived,ValueType,Traversal,Reference>
-{
-public:
-    // Constructor
-    input_iterator_facade() : m_valid( false ), m_value() {}
-
-protected: // provide access to the Derived
-    void                init()
-    {
-        m_valid = true;
-        increment();
-    }
-
-    // Data members
-    mutable bool        m_valid;
-    ValueType           m_value;
-
-private:
-    friend class boost::iterator_core_access;
-
-    // iterator facade interface implementation
-    void                increment()
-    {
-        // we make post-end incrementation indefinetly safe
-        if( m_valid )
-            m_valid = input_iterator_core_access::get( *static_cast<Derived*>(this) );
-    }
-    Reference           dereference() const
-    {
-        return m_value;
-    }
-
-    // iterator facade interface implementation
-    bool                equal( input_iterator_facade const& rhs ) const
-    {
-        // two invalid iterator equals, inequal otherwise
-        return !m_valid && !rhs.m_valid;
-    }
-};
-
-} // namespace utils
-} // namespace unit_test
-} // namespace boost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_INPUT_ITERATOR_FACADE_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/iterator/token_iterator.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/iterator/token_iterator.hpp
deleted file mode 100644
index abc530041d9..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/iterator/token_iterator.hpp
+++ /dev/null
@@ -1,417 +0,0 @@
-//  (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 : token iterator for string and range tokenization
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_TOKEN_ITERATOR_HPP
-#define BOOST_TEST_UTILS_TOKEN_ITERATOR_HPP
-
-// Boost
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/iterator/iterator_categories.hpp>
-#include <boost/iterator/iterator_traits.hpp>
-
-#include <boost/test/utils/iterator/input_iterator_facade.hpp>
-#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
-#include <boost/test/utils/named_params.hpp>
-#include <boost/test/utils/foreach.hpp>
-
-// STL
-#include <iosfwd>
-#include <cctype>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-#ifdef BOOST_NO_STDC_NAMESPACE
-namespace std{ using ::ispunct; using ::isspace; }
-#endif
-
-namespace boost {
-namespace unit_test {
-namespace utils {
-
-// ************************************************************************** //
-// **************               ti_delimeter_type              ************** //
-// ************************************************************************** //
-
-enum ti_delimeter_type {
-    dt_char,        // character is delimeter if it among explicit list of some characters
-    dt_ispunct,     // character is delimeter if it satisfies ispunct functor
-    dt_isspace,     // character is delimeter if it satisfies isspace functor
-    dt_none         // no character is delimeter
-};
-
-namespace ut_detail {
-
-// ************************************************************************** //
-// **************             default_char_compare             ************** //
-// ************************************************************************** //
-
-template<typename CharT>
-class default_char_compare {
-public:
-    bool operator()( CharT c1, CharT c2 )
-    {
-#ifdef BOOST_CLASSIC_IOSTREAMS
-        return std::string_char_traits<CharT>::eq( c1, c2 );
-#else
-        return std::char_traits<CharT>::eq( c1, c2 );
-#endif
-    }
-};
-
-// ************************************************************************** //
-// **************                 delim_policy                 ************** //
-// ************************************************************************** //
-
-template<typename CharT,typename CharCompare>
-class delim_policy {
-    typedef basic_cstring<CharT const> cstring;
-public:
-    // Constructor
-    explicit    delim_policy( ti_delimeter_type type_ = dt_char, cstring delimeters_ = cstring() )
-    : m_type( type_ )
-    {
-        set_delimeters( delimeters_ );
-    }
-
-    void        set_delimeters( ti_delimeter_type type_ ) { m_type = type_; }
-    void        set_delimeters( cstring delimeters_ )
-    {
-        m_delimeters = delimeters_;
-
-        if( !m_delimeters.is_empty() )
-            m_type = dt_char;
-    }
-    void        set_delimeters( nfp::nil ) {}
-    bool        operator()( CharT c )
-    {
-        switch( m_type ) {
-        case dt_char: {
-            BOOST_TEST_FOREACH( CharT, delim, m_delimeters )
-                if( CharCompare()( delim, c ) )
-                    return true;
-
-            return false;
-        }
-        case dt_ispunct:
-            return (std::ispunct)( c ) != 0;
-        case dt_isspace:
-            return (std::isspace)( c ) != 0;
-        case dt_none:
-            return false;
-        }
-
-        return false;
-    }
-
-private:
-    // Data members
-    cstring             m_delimeters;
-    ti_delimeter_type   m_type;
-};
-
-// ************************************************************************** //
-// **************                 token_assigner               ************** //
-// ************************************************************************** //
-
-template<typename TraversalTag>
-struct token_assigner {
-#if BOOST_WORKAROUND( BOOST_DINKUMWARE_STDLIB, < 306 )
-    template<typename Iterator, typename C, typename T>
-    static void assign( Iterator b, Iterator e, std::basic_string<C,T>& t )
-    { for( ; b != e; ++b ) t += *b; }
-
-    template<typename Iterator, typename C>
-    static void assign( Iterator b, Iterator e, basic_cstring<C>& t )  { t.assign( b, e ); }
-#else
-    template<typename Iterator, typename Token>
-    static void assign( Iterator b, Iterator e, Token& t )  { t.assign( b, e ); }
-#endif
-    template<typename Iterator, typename Token>
-    static void append_move( Iterator& b, Token& )          { ++b; }
-};
-
-//____________________________________________________________________________//
-
-template<>
-struct token_assigner<single_pass_traversal_tag> {
-    template<typename Iterator, typename Token>
-    static void assign( Iterator /*b*/, Iterator /*e*/, Token& /*t*/ )  {}
-
-    template<typename Iterator, typename Token>
-    static void append_move( Iterator& b, Token& t )        { t += *b; ++b; }
-};
-
-} // namespace ut_detail
-
-// ************************************************************************** //
-// **************                  modifiers                   ************** //
-// ************************************************************************** //
-
-namespace {
-nfp::keyword<struct dropped_delimeters_t >           dropped_delimeters;
-nfp::keyword<struct kept_delimeters_t >              kept_delimeters;
-nfp::typed_keyword<bool,struct keep_empty_tokens_t > keep_empty_tokens;
-nfp::typed_keyword<std::size_t,struct max_tokens_t > max_tokens;
-}
-
-// ************************************************************************** //
-// **************             token_iterator_base              ************** //
-// ************************************************************************** //
-
-template<typename Derived,
-         typename CharT,
-         typename CharCompare   = ut_detail::default_char_compare<CharT>,
-         typename ValueType     = basic_cstring<CharT const>,
-         typename Reference     = basic_cstring<CharT const>,
-         typename Traversal     = forward_traversal_tag>
-class token_iterator_base
-: public input_iterator_facade<Derived,ValueType,Reference,Traversal> {
-    typedef basic_cstring<CharT const>                                      cstring;
-    typedef ut_detail::delim_policy<CharT,CharCompare>                      delim_policy;
-    typedef input_iterator_facade<Derived,ValueType,Reference,Traversal>    base;
-
-protected:
-    // Constructor
-    explicit    token_iterator_base()
-    : m_is_dropped( dt_isspace )
-    , m_is_kept( dt_ispunct )
-    , m_keep_empty_tokens( false )
-    , m_tokens_left( static_cast<std::size_t>(-1) )
-    , m_token_produced( false )
-    {
-    }
-
-    template<typename Modifier>
-    void
-    apply_modifier( Modifier const& m )
-    {
-        if( m.has( dropped_delimeters ) )
-            m_is_dropped.set_delimeters( m[dropped_delimeters] );
-
-        if( m.has( kept_delimeters ) )
-            m_is_kept.set_delimeters( m[kept_delimeters] );
-
-        if( m.has( keep_empty_tokens ) )
-            m_keep_empty_tokens = true;
-
-        nfp::opt_assign( m_tokens_left, m, max_tokens );
-    }
-
-    template<typename Iter>
-    bool                    get( Iter& begin, Iter end )
-    {
-        typedef ut_detail::token_assigner<BOOST_DEDUCED_TYPENAME iterator_traversal<Iter>::type> Assigner;
-        Iter check_point;
-
-        this->m_value.clear();
-
-        if( !m_keep_empty_tokens ) {
-            while( begin != end && m_is_dropped( *begin ) )
-                ++begin;
-
-            if( begin == end )
-                return false;
-
-            check_point = begin;
-
-            if( m_tokens_left == 1 )
-                while( begin != end )
-                    Assigner::append_move( begin, this->m_value );
-            else if( m_is_kept( *begin ) )
-                Assigner::append_move( begin, this->m_value );
-            else
-                while( begin != end && !m_is_dropped( *begin ) && !m_is_kept( *begin ) )
-                    Assigner::append_move( begin, this->m_value );
-
-            --m_tokens_left;
-        }
-        else { // m_keep_empty_tokens is true
-            check_point = begin;
-
-            if( begin == end ) {
-                if( m_token_produced )
-                    return false;
-
-                m_token_produced = true;
-            }
-            if( m_is_kept( *begin ) ) {
-                if( m_token_produced )
-                    Assigner::append_move( begin, this->m_value );
-
-                m_token_produced = !m_token_produced;
-            }
-            else if( !m_token_produced && m_is_dropped( *begin ) )
-                m_token_produced = true;
-            else {
-                if( m_is_dropped( *begin ) )
-                    check_point = ++begin;
-
-                while( begin != end && !m_is_dropped( *begin ) && !m_is_kept( *begin ) )
-                    Assigner::append_move( begin, this->m_value );
-
-                m_token_produced = true;
-            }
-        }
-
-        Assigner::assign( check_point, begin, this->m_value );
-
-        return true;
-    }
-
-private:
-    // Data members
-    delim_policy            m_is_dropped;
-    delim_policy            m_is_kept;
-    bool                    m_keep_empty_tokens;
-    std::size_t             m_tokens_left;
-    bool                    m_token_produced;
-};
-
-// ************************************************************************** //
-// **************          basic_string_token_iterator         ************** //
-// ************************************************************************** //
-
-template<typename CharT,
-         typename CharCompare = ut_detail::default_char_compare<CharT> >
-class basic_string_token_iterator
-: public token_iterator_base<basic_string_token_iterator<CharT,CharCompare>,CharT,CharCompare> {
-    typedef basic_cstring<CharT const> cstring;
-    typedef token_iterator_base<basic_string_token_iterator<CharT,CharCompare>,CharT,CharCompare> base;
-public:
-    explicit    basic_string_token_iterator() {}
-    explicit    basic_string_token_iterator( cstring src )
-    : m_src( src )
-    {
-        this->init();
-    }
-
-    template<typename Src, typename Modifier>
-    basic_string_token_iterator( Src src, Modifier const& m )
-    : m_src( src )
-    {
-        this->apply_modifier( m );
-
-        this->init();
-    }
-
-private:
-    friend class input_iterator_core_access;
-
-    // input iterator implementation
-    bool        get()
-    {
-        typename cstring::iterator begin = m_src.begin();
-        bool res = base::get( begin, m_src.end() );
-
-        m_src.assign( begin, m_src.end() );
-
-        return res;
-    }
-
-    // Data members
-    cstring     m_src;
-};
-
-typedef basic_string_token_iterator<char>       string_token_iterator;
-typedef basic_string_token_iterator<wchar_t>    wstring_token_iterator;
-
-// ************************************************************************** //
-// **************              range_token_iterator            ************** //
-// ************************************************************************** //
-
-template<typename Iter,
-         typename CharCompare = ut_detail::default_char_compare<BOOST_DEDUCED_TYPENAME iterator_value<Iter>::type>,
-         typename ValueType   = std::basic_string<BOOST_DEDUCED_TYPENAME iterator_value<Iter>::type>,
-         typename Reference   = ValueType const&>
-class range_token_iterator
-: public token_iterator_base<range_token_iterator<Iter,CharCompare,ValueType,Reference>,
-                             typename iterator_value<Iter>::type,CharCompare,ValueType,Reference> {
-    typedef basic_cstring<typename ValueType::value_type> cstring;
-    typedef token_iterator_base<range_token_iterator<Iter,CharCompare,ValueType,Reference>,
-                                typename iterator_value<Iter>::type,CharCompare,ValueType,Reference> base;
-public:
-    explicit    range_token_iterator() {}
-    explicit    range_token_iterator( Iter begin, Iter end = Iter() )
-    : m_begin( begin ), m_end( end )
-    {
-        this->init();
-    }
-    range_token_iterator( range_token_iterator const& rhs )
-    : base( rhs )
-    {
-        if( this->m_valid ) {
-            m_begin = rhs.m_begin;
-            m_end   = rhs.m_end;
-        }
-    }
-
-    template<typename Modifier>
-    range_token_iterator( Iter begin, Iter end, Modifier const& m )
-    : m_begin( begin ), m_end( end )
-    {
-        this->apply_modifier( m );
-
-        this->init();
-    }
-
-private:
-    friend class input_iterator_core_access;
-
-    // input iterator implementation
-    bool        get()
-    {
-        return base::get( m_begin, m_end );
-    }
-
-    // Data members
-    Iter m_begin;
-    Iter m_end;
-};
-
-// ************************************************************************** //
-// **************            make_range_token_iterator         ************** //
-// ************************************************************************** //
-
-template<typename Iter>
-inline range_token_iterator<Iter>
-make_range_token_iterator( Iter begin, Iter end = Iter() )
-{
-    return range_token_iterator<Iter>( begin, end );
-}
-
-//____________________________________________________________________________//
-
-template<typename Iter,typename Modifier>
-inline range_token_iterator<Iter>
-make_range_token_iterator( Iter begin, Iter end, Modifier const& m )
-{
-    return range_token_iterator<Iter>( begin, end, m );
-}
-
-//____________________________________________________________________________//
-
-} // namespace utils
-} // namespace unit_test
-} // namespace boost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_TOKEN_ITERATOR_HPP
-
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/lazy_ostream.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/lazy_ostream.hpp
deleted file mode 100644
index 26bd8ed3856..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/lazy_ostream.hpp
+++ /dev/null
@@ -1,128 +0,0 @@
-//  (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.
-//
-//  Description : contains definition for all test tools in test toolbox
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_LAZY_OSTREAM_HPP
-#define BOOST_TEST_UTILS_LAZY_OSTREAM_HPP
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-
-// STL
-#include <iosfwd>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                  lazy_ostream                ************** //
-// ************************************************************************** //
-
-namespace boost {
-namespace unit_test {
-
-class lazy_ostream {
-public:
-    virtual                 ~lazy_ostream()                                         {}
-
-    static lazy_ostream&    instance()                                              { static lazy_ostream inst; return inst; }
-
-    friend std::ostream&    operator<<( std::ostream& ostr, lazy_ostream const& o ) { return o( ostr ); }
-
-    // access method
-    bool                    empty() const                                           { return m_empty; }
-
-    // actual printing interface; to be accessed only by this class and children
-    virtual std::ostream&   operator()( std::ostream& ostr ) const                  { return ostr; }
-protected:
-    explicit                lazy_ostream( bool p_empty = true ) : m_empty( p_empty )    {}
-
-private:
-    // Data members
-    bool                    m_empty;
-};
-
-//____________________________________________________________________________//
-
-template<typename PrevType, typename T, typename StorageT=T const&>
-class lazy_ostream_impl : public lazy_ostream {
-public:
-    lazy_ostream_impl( PrevType const& prev, T const& value )
-    : lazy_ostream( false )
-    , m_prev( prev )
-    , m_value( value )
-    {
-    }
-
-    virtual std::ostream&   operator()( std::ostream& ostr ) const
-    {
-        return m_prev(ostr) << m_value;
-    }
-private:
-    // Data members
-    PrevType const&         m_prev;
-    StorageT                m_value;
-};
-
-//____________________________________________________________________________//
-
-template<typename T>
-inline lazy_ostream_impl<lazy_ostream,T>
-operator<<( lazy_ostream const& prev, T const& v )
-{
-    return lazy_ostream_impl<lazy_ostream,T>( prev, v );
-}
-
-//____________________________________________________________________________//
-
-template<typename PrevPrevType, typename TPrev, typename T>
-inline lazy_ostream_impl<lazy_ostream_impl<PrevPrevType,TPrev>,T>
-operator<<( lazy_ostream_impl<PrevPrevType,TPrev> const& prev, T const& v )
-{
-    typedef lazy_ostream_impl<PrevPrevType,TPrev> PrevType;
-    return lazy_ostream_impl<PrevType,T>( prev, v );
-}
-
-//____________________________________________________________________________//
-
-#if BOOST_TEST_USE_STD_LOCALE
-
-template<typename R,typename S>
-inline lazy_ostream_impl<lazy_ostream,R& (BOOST_TEST_CALL_DECL *)(S&),R& (BOOST_TEST_CALL_DECL *)(S&)>
-operator<<( lazy_ostream const& prev, R& (BOOST_TEST_CALL_DECL *man)(S&) )
-{
-    typedef R& (BOOST_TEST_CALL_DECL * ManipType)(S&);
-
-    return lazy_ostream_impl<lazy_ostream,ManipType,ManipType>( prev, man );
-}
-
-//____________________________________________________________________________//
-
-template<typename PrevPrevType, typename TPrev,typename R,typename S>
-inline lazy_ostream_impl<lazy_ostream_impl<PrevPrevType,TPrev>,R& (BOOST_TEST_CALL_DECL *)(S&),R& (BOOST_TEST_CALL_DECL *)(S&)>
-operator<<( lazy_ostream_impl<PrevPrevType,TPrev> const& prev, R& (BOOST_TEST_CALL_DECL *man)(S&) )
-{
-    typedef R& (BOOST_TEST_CALL_DECL * ManipType)(S&);
-
-    return lazy_ostream_impl<lazy_ostream_impl<PrevPrevType,TPrev>,ManipType,ManipType>( prev, man );
-}
-
-//____________________________________________________________________________//
-
-#endif
-
-#define BOOST_TEST_LAZY_MSG( M ) (::boost::unit_test::lazy_ostream::instance() << M)
-
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_LAZY_OSTREAM_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/named_params.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/named_params.hpp
deleted file mode 100644
index 88b8a883fea..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/named_params.hpp
+++ /dev/null
@@ -1,388 +0,0 @@
-//  (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 : named function parameters library
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_NAMED_PARAM
-#define BOOST_TEST_UTILS_NAMED_PARAM
-
-// Boost
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-// Boost.Test
-#include <boost/test/utils/rtti.hpp>
-#include <boost/test/utils/assign_op.hpp>
-
-#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-
-#include <boost/test/detail/throw_exception.hpp>
-
-// Boost
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/or.hpp>
-#include <boost/type_traits/is_same.hpp>
-#include <boost/type_traits/remove_cv.hpp>
-#include <boost/utility/enable_if.hpp>
-#include <boost/mpl/bool.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace nfp { // named function parameters
-
-// ************************************************************************** //
-// **************             forward declarations             ************** //
-// ************************************************************************** //
-
-template<typename unique_id, bool required>                     struct keyword;
-template<typename T, typename unique_id, bool required = false> struct typed_keyword;
-
-template<typename T, typename unique_id, typename RefType=T&>   struct named_parameter;
-template<typename NP1,typename NP2>                             struct named_parameter_combine;
-
-// ************************************************************************** //
-// **************              is_named_param_pack             ************** //
-// ************************************************************************** //
-
-/// is_named_param_pack<T>::value is true if T is parameters pack
-
-template<typename T>
-struct is_named_param_pack : public mpl::false_ {};
-
-template<typename T, typename unique_id, typename RefType>
-struct is_named_param_pack<named_parameter<T,unique_id,RefType> > : public mpl::true_ {};
-
-template<typename NP, typename Rest>
-struct is_named_param_pack<named_parameter_combine<NP,Rest> > : public mpl::true_ {};
-
-// ************************************************************************** //
-// **************                  param_type                  ************** //
-// ************************************************************************** //
-
-/// param_type<Params,Keyword,Default>::type is is the type of the parameter
-/// corresponding to the Keyword (if parameter is present) or Default
-
-template<typename NP, typename Keyword, typename DefaultType=void>
-struct param_type
-: mpl::if_<typename is_same<typename NP::id,typename Keyword::id>::type,
-           typename remove_cv<typename NP::data_type>::type,
-           DefaultType> {};
-
-template<typename NP, typename Rest, typename Keyword, typename DefaultType>
-struct param_type<named_parameter_combine<NP,Rest>,Keyword,DefaultType>
-: mpl::if_<typename is_same<typename NP::id,typename Keyword::id>::type,
-           typename remove_cv<typename NP::data_type>::type,
-           typename param_type<Rest,Keyword,DefaultType>::type> {};
-
-// ************************************************************************** //
-// **************                  has_param                   ************** //
-// ************************************************************************** //
-
-/// has_param<Params,Keyword>::value is true id Params has parameter corresponding
-/// to the Keyword
-
-template<typename NP, typename Keyword>
-struct has_param : is_same<typename NP::id,typename Keyword::id> {};
-
-template<typename NP, typename Rest, typename Keyword>
-struct has_param<named_parameter_combine<NP,Rest>,Keyword>
-: mpl::or_<typename is_same<typename NP::id,typename Keyword::id>::type,
-           typename has_param<Rest,Keyword>::type> {};
-
-// ************************************************************************** //
-// **************          access_to_invalid_parameter         ************** //
-// ************************************************************************** //
-
-namespace nfp_detail {
-
-struct access_to_invalid_parameter {};
-
-//____________________________________________________________________________//
-
-inline void
-report_access_to_invalid_parameter( bool v )
-{
-    BOOST_TEST_I_ASSRT( !v, access_to_invalid_parameter() );
-}
-
-} // namespace nfp_detail
-
-// ************************************************************************** //
-// **************                      nil                     ************** //
-// ************************************************************************** //
-
-struct nil {
-    template<typename T>
-#if defined(__GNUC__) || defined(__HP_aCC) || defined(__EDG__) || defined(__SUNPRO_CC)
-    operator T() const
-#else
-    operator T const&() const
-#endif
-    { nfp_detail::report_access_to_invalid_parameter(true); static T* v = 0; return *v; }
-
-    template<typename T>
-    T any_cast() const
-    { nfp_detail::report_access_to_invalid_parameter(true); static typename remove_reference<T>::type* v = 0; return *v; }
-
-    template<typename Arg1>
-    nil operator()( Arg1 const& )
-    { nfp_detail::report_access_to_invalid_parameter(true); return nil(); }
-
-    template<typename Arg1,typename Arg2>
-    nil operator()( Arg1 const&, Arg2 const& )
-    { nfp_detail::report_access_to_invalid_parameter(true); return nil(); }
-
-    template<typename Arg1,typename Arg2,typename Arg3>
-    nil operator()( Arg1 const&, Arg2 const&, Arg3 const& )
-    { nfp_detail::report_access_to_invalid_parameter(true); return nil(); }
-
-    // Visitation support
-    template<typename Visitor>
-    void            apply_to( Visitor& /*v*/ ) const {}
-
-    static nil&     inst() { static nil s_inst; return s_inst; }
-private:
-    nil() {}
-};
-
-// ************************************************************************** //
-// **************             named_parameter_base             ************** //
-// ************************************************************************** //
-
-namespace nfp_detail {
-
-template<typename Derived>
-struct named_parameter_base {
-    template<typename NP>
-    named_parameter_combine<NP,Derived>
-    operator,( NP const& np ) const { return named_parameter_combine<NP,Derived>( np, *static_cast<Derived const*>(this) ); }
-};
-
-} // namespace nfp_detail
-
-// ************************************************************************** //
-// **************            named_parameter_combine           ************** //
-// ************************************************************************** //
-
-template<typename NP, typename Rest = nil>
-struct named_parameter_combine
-: Rest
-, nfp_detail::named_parameter_base<named_parameter_combine<NP,Rest> > {
-    typedef typename NP::ref_type  res_type;
-    typedef named_parameter_combine<NP,Rest> self_type;
-
-    // Constructor
-    named_parameter_combine( NP const& np, Rest const& r )
-    : Rest( r )
-    , m_param( np )
-    {
-    }
-
-    // Access methods
-    res_type    operator[]( keyword<typename NP::id,true> kw ) const    { return m_param[kw]; }
-    res_type    operator[]( keyword<typename NP::id,false> kw ) const   { return m_param[kw]; }
-    using       Rest::operator[];
-
-    bool        has( keyword<typename NP::id,false> kw ) const          { return m_param.has( kw ); }
-    using       Rest::has;
-
-    void        erase( keyword<typename NP::id,false> kw ) const        { m_param.erase( kw ); }
-    using       Rest::erase;
-
-    using       nfp_detail::named_parameter_base<named_parameter_combine<NP,Rest> >::operator,;
-
-    // Visitation support
-    template<typename Visitor>
-    void            apply_to( Visitor& V ) const
-    {
-        m_param.apply_to( V );
-
-        Rest::apply_to( V );
-    }
-private:
-    // Data members
-    NP          m_param;
-};
-
-// ************************************************************************** //
-// **************                named_parameter               ************** //
-// ************************************************************************** //
-
-template<typename T, typename unique_id, typename RefType>
-struct named_parameter
-: nfp_detail::named_parameter_base<named_parameter<T,unique_id,RefType> >
-{
-    typedef T               data_type;
-    typedef RefType         ref_type;
-    typedef unique_id       id;
-
-    // Constructor
-    explicit        named_parameter( ref_type v )
-    : m_value( v )
-    , m_erased( false )
-    {}
-    named_parameter( named_parameter const& np )
-    : m_value( np.m_value )
-    , m_erased( np.m_erased )
-    {}
-
-    // Access methods
-    ref_type        operator[]( keyword<unique_id,true> ) const     { return m_erased ? nil::inst().template any_cast<ref_type>() :  m_value; }
-    ref_type        operator[]( keyword<unique_id,false> ) const    { return m_erased ? nil::inst().template any_cast<ref_type>() :  m_value; }
-    template<typename UnknownId>
-    nil             operator[]( keyword<UnknownId,false> ) const    { return nil::inst(); }
-
-    bool            has( keyword<unique_id,false> ) const           { return !m_erased; }
-    template<typename UnknownId>
-    bool            has( keyword<UnknownId,false> ) const           { return false; }
-
-    void            erase( keyword<unique_id,false> ) const         { m_erased = true; }
-    template<typename UnknownId>
-    void            erase( keyword<UnknownId,false> ) const         {}
-
-    // Visitation support
-    template<typename Visitor>
-    void            apply_to( Visitor& V ) const
-    {
-        V.set_parameter( rtti::type_id<unique_id>(), m_value );
-    }
-
-private:
-    // Data members
-    ref_type        m_value;
-    mutable bool    m_erased;
-};
-
-// ************************************************************************** //
-// **************                   no_params                  ************** //
-// ************************************************************************** //
-
-typedef named_parameter<char, struct no_params_type_t,char> no_params_type;
-
-namespace {
-no_params_type no_params( '\0' );
-} // local namespace
-
-// ************************************************************************** //
-// **************                    keyword                   ************** //
-// ************************************************************************** //
-
-template<typename unique_id, bool required = false>
-struct keyword {
-    typedef unique_id id;
-
-    template<typename T>
-    named_parameter<T const,unique_id>
-    operator=( T const& t ) const       { return named_parameter<T const,unique_id>( t ); }
-
-    template<typename T>
-    named_parameter<T,unique_id>
-    operator=( T& t ) const             { return named_parameter<T,unique_id>( t ); }
-
-    named_parameter<char const*,unique_id,char const*>
-    operator=( char const* t ) const    { return named_parameter<char const*,unique_id,char const*>( t ); }
-};
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                 typed_keyword                ************** //
-// ************************************************************************** //
-
-template<typename T, typename unique_id, bool required>
-struct typed_keyword : keyword<unique_id,required> {
-    named_parameter<T const,unique_id>
-    operator=( T const& t ) const       { return named_parameter<T const,unique_id>( t ); }
-
-    named_parameter<T,unique_id>
-    operator=( T& t ) const             { return named_parameter<T,unique_id>( t ); }
-};
-
-//____________________________________________________________________________//
-
-template<typename unique_id, bool required>
-struct typed_keyword<bool,unique_id,required>
-: keyword<unique_id,required>
-, named_parameter<bool,unique_id,bool> {
-    typedef unique_id id;
-
-    typed_keyword() : named_parameter<bool,unique_id,bool>( true ) {}
-
-    named_parameter<bool,unique_id,bool>
-    operator!() const           { return named_parameter<bool,unique_id,bool>( false ); }
-};
-
-// ************************************************************************** //
-// **************                  opt_assign                  ************** //
-// ************************************************************************** //
-
-template<typename T, typename Params, typename Keyword>
-inline typename enable_if_c<!has_param<Params,Keyword>::value,void>::type
-opt_assign( T& /*target*/, Params const& /*p*/, Keyword /*k*/ )
-{
-}
-
-//____________________________________________________________________________//
-
-template<typename T, typename Params, typename Keyword>
-inline typename enable_if_c<has_param<Params,Keyword>::value,void>::type
-opt_assign( T& target, Params const& p, Keyword k )
-{
-    using namespace unit_test;
-
-    assign_op( target, p[k], static_cast<int>(0) );
-}
-
-// ************************************************************************** //
-// **************                    opt_get                   ************** //
-// ************************************************************************** //
-
-template<typename T, typename Params, typename Keyword>
-inline T
-opt_get( Params const& p, Keyword k, T default_val )
-{
-    opt_assign( default_val, p, k );
-
-    return default_val;
-}
-
-// ************************************************************************** //
-// **************                    opt_get                   ************** //
-// ************************************************************************** //
-
-template<typename Params, typename NP>
-inline typename enable_if_c<!has_param<Params,keyword<typename NP::id> >::value,
-named_parameter_combine<NP,Params> >::type
-opt_append( Params const& params, NP const& np )
-{
-    return (params,np);
-}
-
-//____________________________________________________________________________//
-
-template<typename Params, typename NP>
-inline typename enable_if_c<has_param<Params,keyword<typename NP::id> >::value,Params>::type
-opt_append( Params const& params, NP const& )
-{
-    return params;
-}
-
-} // namespace nfp
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_NAMED_PARAM
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/nullstream.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/nullstream.hpp
deleted file mode 100644
index 27b17fae14f..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/nullstream.hpp
+++ /dev/null
@@ -1,103 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001.
-//  (C) Copyright Daryle Walker 2000-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 : simulate /dev/null stream
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_NULLSTREAM_HPP
-#define BOOST_TEST_UTILS_NULLSTREAM_HPP
-
-// STL
-#include <ostream>    // for std::basic_ostream
-#include <streambuf>  // for std::basic_streambuf
-#include <string>     // for std::char_traits
-
-// Boost
-#include <boost/utility/base_from_member.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-
-// ************************************************************************** //
-// **************                 basic_nullbuf                ************** //
-// ************************************************************************** //
-//  Class for a buffer that reads nothing and writes to nothing.
-//  Idea from an Usenet post by Tom <the_wid@my-deja.com> at
-//  27 Oct 2000 14:06:21 GMT on comp.lang.c++.
-
-template<typename CharType, class CharTraits = ::std::char_traits<CharType> >
-class basic_nullbuf : public ::std::basic_streambuf<CharType, CharTraits> {
-    typedef ::std::basic_streambuf<CharType, CharTraits>  base_type;
-public:
-    // Types
-    typedef typename base_type::char_type    char_type;
-    typedef typename base_type::traits_type  traits_type;
-    typedef typename base_type::int_type     int_type;
-    typedef typename base_type::pos_type     pos_type;
-    typedef typename base_type::off_type     off_type;
-
-    // Use automatic default constructor and destructor
-
-protected:
-    // The default implementations of the miscellaneous virtual
-    // member functions are sufficient.
-
-    // The default implementations of the input & putback virtual
-    // member functions, being nowhere but EOF, are sufficient.
-
-    // The output virtual member functions need to be changed to
-    // accept anything without any problems, instead of being at EOF.
-    virtual  ::std::streamsize  xsputn( char_type const* /*s*/, ::std::streamsize n )   { return n; } // "s" is unused
-    virtual  int_type           overflow( int_type c = traits_type::eof() )         { return traits_type::not_eof( c ); }
-};
-
-typedef basic_nullbuf<char>      nullbuf;
-typedef basic_nullbuf<wchar_t>  wnullbuf;
-
-// ************************************************************************** //
-// **************               basic_onullstream              ************** //
-// ************************************************************************** //
-//  Output streams based on basic_nullbuf.
-
-#ifdef BOOST_MSVC
-# pragma warning(push)
-# pragma warning(disable: 4355) // 'this' : used in base member initializer list
-#endif
-
-template< typename CharType, class CharTraits = ::std::char_traits<CharType> >
-class basic_onullstream : private boost::base_from_member<basic_nullbuf<CharType, CharTraits> >
-                        , public ::std::basic_ostream<CharType, CharTraits> {
-    typedef boost::base_from_member<basic_nullbuf<CharType, CharTraits> >   pbase_type;
-    typedef ::std::basic_ostream<CharType, CharTraits>                      base_type;
-public:
-    // Constructor
-    basic_onullstream() : pbase_type(), base_type( &this->pbase_type::member ) {}
-};
-
-#ifdef BOOST_MSVC
-# pragma warning(default: 4355)
-# pragma warning(pop)
-#endif
-
-typedef basic_onullstream<char>      onullstream;
-typedef basic_onullstream<wchar_t>  wonullstream;
-
-}  // namespace boost
-
-//____________________________________________________________________________//
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif  // BOOST_TEST_UTILS_NULLSTREAM_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/rtti.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/rtti.hpp
deleted file mode 100644
index b230692d803..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/rtti.hpp
+++ /dev/null
@@ -1,63 +0,0 @@
-//  (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 : simple facilities for accessing type information at runtime
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_RTTI_HPP
-#define BOOST_TEST_UTILS_RTTI_HPP
-
-// C Runtime
-#include <cstddef>
-
-namespace boost {
-namespace rtti {
-
-// ************************************************************************** //
-// **************                   rtti::type_id              ************** //
-// ************************************************************************** //
-
-typedef std::ptrdiff_t id_t;
-
-namespace rtti_detail {
-
-template<typename T>
-struct rttid_holder {
-    static id_t id() { return reinterpret_cast<id_t>( &inst() ); }
-
-private:
-    struct rttid {};
-
-    static rttid const& inst() { static rttid s_inst; return s_inst; }
-};
-
-} // namespace rtti_detail
-
-//____________________________________________________________________________//
-
-template<typename T>
-inline id_t
-type_id()
-{
-    return rtti_detail::rttid_holder<T>::id();
-}
-
-//____________________________________________________________________________//
-
-#define BOOST_RTTI_SWITCH( type_id_ ) if( ::boost::rtti::id_t switch_by_id = type_id_ )
-#define BOOST_RTTI_CASE( type )       if( switch_by_id == ::boost::rtti::type_id<type>() )
-
-//____________________________________________________________________________//
-
-} // namespace rtti
-} // namespace boost
-
-#endif // BOOST_TEST_UTILS_RTTI_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/argument.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/argument.hpp
deleted file mode 100644
index 879ee96f9f0..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/argument.hpp
+++ /dev/null
@@ -1,131 +0,0 @@
-//  (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 : model of actual argument (both typed and abstract interface)
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_RUNTIME_ARGUMENT_HPP
-#define BOOST_TEST_UTILS_RUNTIME_ARGUMENT_HPP
-
-// Boost.Test Runtime parameters
-#include <boost/test/utils/runtime/fwd.hpp>
-#include <boost/test/utils/runtime/errors.hpp>
-
-// Boost.Test
-#include <boost/test/utils/class_properties.hpp>
-#include <boost/test/utils/rtti.hpp>
-#include <boost/test/utils/basic_cstring/compare.hpp>
-#include <boost/test/detail/throw_exception.hpp>
-
-// STL
-#include <cassert>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-namespace boost {
-namespace runtime {
-
-// ************************************************************************** //
-// **************              runtime::argument               ************** //
-// ************************************************************************** //
-
-class argument {
-public:
-    // Constructor
-    argument( rtti::id_t value_type )
-    : p_value_type( value_type )
-    {}
-
-    // Destructor
-    virtual     ~argument()  {}
-
-    // Public properties
-    rtti::id_t const    p_value_type;
-};
-
-// ************************************************************************** //
-// **************             runtime::typed_argument          ************** //
-// ************************************************************************** //
-
-template<typename T>
-class typed_argument : public argument {
-public:
-    // Constructor
-    explicit typed_argument( T const& v )
-    : argument( rtti::type_id<T>() )
-    , p_value( v )
-    {}
-
-    unit_test::readwrite_property<T>    p_value;
-};
-
-// ************************************************************************** //
-// **************           runtime::arguments_store          ************** //
-// ************************************************************************** //
-
-class arguments_store {
-public:
-    typedef std::map<cstring, argument_ptr> storage_type;
-
-    /// Returns number of arguments in the store; mostly used for testing
-    std::size_t size() const        { return m_arguments.size(); }
-
-    /// Clears the store for reuse
-    void        clear()             { m_arguments.clear(); }
-
-    /// Returns true if there is an argument corresponding to the specified parameter name
-    bool        has( cstring parameter_name ) const
-    {
-        return m_arguments.find( parameter_name ) != m_arguments.end();
-    }
-
-    /// Provides types access to argument value by parameter name
-    template<typename T>
-    T const&    get( cstring parameter_name ) const {
-        return const_cast<arguments_store*>(this)->get<T>( parameter_name );
-    }
-
-    template<typename T>
-    T&          get( cstring parameter_name ) {
-        storage_type::const_iterator found = m_arguments.find( parameter_name );
-        BOOST_TEST_I_ASSRT( found != m_arguments.end(),
-                            access_to_missing_argument() 
-                                << "There is no argument provided for parameter "
-                                << parameter_name );
-
-        argument_ptr arg = found->second;
-
-        BOOST_TEST_I_ASSRT( arg->p_value_type == rtti::type_id<T>(),
-                            arg_type_mismatch()
-                                << "Access with invalid type for argument corresponding to parameter "
-                                << parameter_name );
-
-        return static_cast<typed_argument<T>&>( *arg ).p_value.value;
-    }
-
-    /// Set's the argument value for specified parameter name
-    template<typename T>
-    void        set( cstring parameter_name, T const& value )
-    {
-        m_arguments[parameter_name] = argument_ptr( new typed_argument<T>( value ) );
-    }
-
-private:
-    // Data members
-    storage_type            m_arguments;
-};
-
-} // namespace runtime
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_RUNTIME_ARGUMENT_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/argument_factory.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/argument_factory.hpp
deleted file mode 100644
index f3448f8cc4a..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/argument_factory.hpp
+++ /dev/null
@@ -1,242 +0,0 @@
-//  (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 : argument factories for different kinds of parameters
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_RUNTIME_ARGUMENT_FACTORY_HPP
-#define BOOST_TEST_UTILS_RUNTIME_ARGUMENT_FACTORY_HPP
-
-// Boost.Test Runtime parameters
-#include <boost/test/utils/runtime/errors.hpp>
-#include <boost/test/utils/runtime/argument.hpp>
-
-// Boost.Test
-#include <boost/test/utils/basic_cstring/io.hpp>
-#include <boost/test/utils/basic_cstring/compare.hpp>
-#include <boost/test/utils/string_cast.hpp>
-
-// Boost
-#include <boost/function/function2.hpp>
-
-// STL
-#include <vector>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-namespace boost {
-namespace runtime {
-
-// ************************************************************************** //
-// **************          runtime::value_interpreter          ************** //
-// ************************************************************************** //
-
-template<typename ValueType, bool is_enum>
-struct value_interpreter;
-
-//____________________________________________________________________________//
-
-template<typename ValueType>
-struct value_interpreter<ValueType, false> {
-    template<typename Modifiers>
-    explicit    value_interpreter( Modifiers const& ) {}
-
-    ValueType interpret( cstring param_name, cstring source ) const
-    {
-        ValueType res;
-        if( !unit_test::utils::string_as<ValueType>( source, res ) )
-            BOOST_TEST_I_THROW( format_error( param_name ) << source <<
-                                " can't be interpreted as value of parameter " << param_name << "." );
-        return res;
-    }
-};
-
-//____________________________________________________________________________//
-
-template<>
-struct value_interpreter<std::string, false> {
-    template<typename Modifiers>
-    explicit    value_interpreter( Modifiers const& ) {}
-
-    std::string interpret( cstring, cstring source ) const
-    {
-        return std::string( source.begin(), source.size() );
-    }
-};
-
-//____________________________________________________________________________//
-
-template<>
-struct value_interpreter<cstring, false> {
-    template<typename Modifiers>
-    explicit    value_interpreter( Modifiers const& ) {}
-
-    cstring interpret( cstring, cstring source ) const
-    {
-        return source;
-    }
-};
-
-//____________________________________________________________________________//
-
-template<>
-struct value_interpreter<bool, false> {
-    template<typename Modifiers>
-    explicit    value_interpreter( Modifiers const& ) {}
-
-    bool    interpret( cstring param_name, cstring source ) const
-    {
-        static cstring const s_YES( "YES" );
-        static cstring const s_Y( "Y" );
-        static cstring const s_NO( "NO" );
-        static cstring const s_N( "N" );
-        static cstring const s_TRUE( "TRUE" );
-        static cstring const s_FALSE( "FALSE" );
-        static cstring const s_one( "1" );
-        static cstring const s_zero( "0" );
-
-        source.trim();
-
-        if( source.is_empty() ||
-            case_ins_eq( source, s_YES ) ||
-            case_ins_eq( source, s_Y ) ||
-            case_ins_eq( source, s_one ) ||
-            case_ins_eq( source, s_TRUE ) )
-            return true;
-
-        if( case_ins_eq( source, s_NO ) ||
-            case_ins_eq( source, s_N ) ||
-            case_ins_eq( source, s_zero ) ||
-            case_ins_eq( source, s_FALSE ) )
-            return false;
-
-        BOOST_TEST_I_THROW( format_error( param_name ) << source << " can't be interpreted as bool value." );
-    }
-};
-
-//____________________________________________________________________________//
-
-template<typename EnumType>
-struct value_interpreter<EnumType, true> {
-    template<typename Modifiers>
-    explicit        value_interpreter( Modifiers const& m )
-#if defined(BOOST_TEST_CLA_NEW_API)
-    : m_name_to_value( m[enum_values<EnumType>::value] )
-    {
-    }
-#else
-    {
-        std::vector<std::pair<cstring,EnumType> > const& values = m[enum_values<EnumType>::value];
-
-        m_name_to_value.insert( values.begin(), values.end() );
-    }
-#endif
-
-    EnumType        interpret( cstring param_name, cstring source ) const
-    {
-        typename std::map<cstring,EnumType>::const_iterator found = m_name_to_value.find( source );
-
-        BOOST_TEST_I_ASSRT( found != m_name_to_value.end(),
-                            format_error( param_name ) << source <<
-                            " is not a valid enumeration value name for parameter " << param_name << "." );
-
-        return found->second;
-    }
-
-private:
-    // Data members
-    std::map<cstring,EnumType>  m_name_to_value;
-};
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************           runtime::argument_factory          ************** //
-// ************************************************************************** //
-
-template<typename ValueType, bool is_enum, bool repeatable>
-class argument_factory;
-
-//____________________________________________________________________________//
-
-template<typename ValueType, bool is_enum>
-class argument_factory<ValueType, is_enum, false> {
-public:
-    template<typename Modifiers>
-    explicit    argument_factory( Modifiers const& m )
-    : m_interpreter( m )
-    , m_optional_value( nfp::opt_get( m, optional_value, ValueType() ) )
-    , m_default_value( nfp::opt_get( m, default_value, ValueType() ) )
-    {
-    }
-
-    void        produce_argument( cstring source, cstring param_name, arguments_store& store ) const
-    {
-        store.set( param_name, source.empty() ? m_optional_value : m_interpreter.interpret( param_name, source ) );
-    }
-
-    void        produce_default( cstring param_name, arguments_store& store ) const
-    {
-        store.set( param_name, m_default_value );
-    }
-
-private:
-    // Data members
-    typedef value_interpreter<ValueType, is_enum> interp_t;
-    interp_t    m_interpreter;
-    ValueType   m_optional_value;
-    ValueType   m_default_value;
-};
-
-//____________________________________________________________________________//
-
-template<typename ValueType, bool is_enum>
-class argument_factory<ValueType, is_enum, true> {
-public:
-    template<typename Modifiers>
-    explicit    argument_factory( Modifiers const& m )
-    : m_interpreter( m )
-    {
-    }
-
-    void        produce_argument( cstring source, cstring param_name, arguments_store& store ) const
-    {
-        ValueType value = m_interpreter.interpret( param_name, source );
-
-        if( store.has( param_name ) ) {
-            std::vector<ValueType>& values = store.get<std::vector<ValueType> >( param_name );
-            values.push_back( value );
-        }
-        else {
-            std::vector<ValueType> values( 1, value );
-
-            store.set( param_name, values );
-        }
-
-    }
-    void        produce_default( cstring param_name, arguments_store& store ) const
-    {
-        store.set( param_name, std::vector<ValueType>() );
-    }
-
-private:
-    // Data members
-    value_interpreter<ValueType, is_enum> m_interpreter;
-};
-
-//____________________________________________________________________________//
-
-} // namespace runtime
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_RUNTIME_ARGUMENT_FACTORY_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/cla/argv_traverser.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/cla/argv_traverser.hpp
deleted file mode 100644
index 10fb67bde4d..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/cla/argv_traverser.hpp
+++ /dev/null
@@ -1,105 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001.
-//  Use, modification, and distribution are subject to the
-//  Boost Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : defines facility to hide input traversing details
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_RUNTIME_CLA_ARGV_TRAVERSER_HPP
-#define BOOST_TEST_UTILS_RUNTIME_CLA_ARGV_TRAVERSER_HPP
-
-// Boost.Test Runtime parameters
-#include <boost/test/utils/runtime/fwd.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-namespace boost {
-namespace runtime {
-namespace cla {
-
-// ************************************************************************** //
-// **************          runtime::cla::argv_traverser        ************** //
-// ************************************************************************** //
-
-class argv_traverser {
-    typedef char const** argv_type;
-public:
-    /// Constructs traverser based on argc/argv pair
-    /// argv is taken "by reference" and later can be
-    /// updated in remainder method
-    argv_traverser( int argc, argv_type argv )
-    : m_argc( argc )
-    , m_curr_token( 0 )
-    , m_token_size( 0 )
-    , m_argv( argv )
-    {
-        // save program name
-        save_token();
-    }
-
-    /// Returns new argc
-    int         remainder()
-    {
-        return m_argc;
-    }
-
-    /// Returns true, if we reached end on input
-    bool        eoi() const
-    {
-        return m_curr_token == m_argc;
-    }
-
-    /// Returns current token in the input
-    cstring     current_token()
-    {
-        if( eoi() )
-            return cstring();
-
-        return cstring( m_argv[m_curr_token], m_token_size );
-    }
-
-    /// Saves current token for remainder
-    void        save_token()
-    {
-        ++m_curr_token;
-
-        if( !eoi() )
-            m_token_size = ::strlen( m_argv[m_curr_token] );
-    }
-
-    /// Commit current token and iterate to next one
-    void        next_token()
-    {
-        if( !eoi() ) {
-            for( std::size_t i = m_curr_token; i < m_argc-1; ++i )
-                m_argv[i] = m_argv[i + 1];
-
-            --m_argc;
-
-            m_token_size = ::strlen( m_argv[m_curr_token] );
-        }
-    }
-
-private:
-
-    // Data members
-    std::size_t m_argc;         // total number of arguments
-    std::size_t m_curr_token;   // current token index in argv
-    std::size_t m_token_size;   // current token size
-    argv_type   m_argv;         // all arguments
-};
-
-} // namespace cla
-} // namespace runtime
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_RUNTIME_CLA_ARGV_TRAVERSER_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/cla/parser.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/cla/parser.hpp
deleted file mode 100644
index effde33a52f..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/cla/parser.hpp
+++ /dev/null
@@ -1,491 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001.
-//  Use, modification, and distribution are subject to the
-//  Boost Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//!@file
-//!@brief CLA parser
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_RUNTIME_CLA_PARSER_HPP
-#define BOOST_TEST_UTILS_RUNTIME_CLA_PARSER_HPP
-
-// Boost.Test Runtime parameters
-#include <boost/test/utils/runtime/argument.hpp>
-#include <boost/test/utils/runtime/modifier.hpp>
-#include <boost/test/utils/runtime/parameter.hpp>
-
-#include <boost/test/utils/runtime/cla/argv_traverser.hpp>
-
-// Boost.Test
-#include <boost/test/utils/foreach.hpp>
-#include <boost/test/utils/algorithm.hpp>
-#include <boost/test/detail/throw_exception.hpp>
-
-#include <boost/algorithm/cxx11/all_of.hpp> // !! ?? unnecessary after cxx11
-
-// STL
-// !! ?? #include <unordered_set>
-#include <set>
-#include <iostream>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-namespace boost {
-namespace runtime {
-namespace cla {
-
-// ************************************************************************** //
-// **************         runtime::cla::parameter_trie         ************** //
-// ************************************************************************** //
-
-namespace rt_cla_detail {
-
-struct parameter_trie;
-typedef shared_ptr<parameter_trie> parameter_trie_ptr;
-typedef std::map<char,parameter_trie_ptr> trie_per_char;
-typedef std::vector<boost::reference_wrapper<parameter_cla_id const> > param_cla_id_list;
-
-struct parameter_trie {
-    parameter_trie() : m_has_final_candidate( false ) {}
-
-    /// If subtrie corresponding to the char c exists returns it otherwise creates new
-    parameter_trie_ptr  make_subtrie( char c )
-    {
-        trie_per_char::const_iterator it = m_subtrie.find( c );
-
-        if( it == m_subtrie.end() )
-            it = m_subtrie.insert( std::make_pair( c, parameter_trie_ptr( new parameter_trie ) ) ).first;
-
-        return it->second;
-    }
-
-    /// Creates series of sub-tries per characters in a string
-    parameter_trie_ptr  make_subtrie( cstring s )
-    {
-        parameter_trie_ptr res;
-
-        BOOST_TEST_FOREACH( char, c, s )
-            res = (res ? res->make_subtrie( c ) : make_subtrie( c ));
-
-        return res;
-    }
-
-    /// Registers candidate parameter for this subtrie. If final, it needs to be unique
-    void                add_candidate_id( parameter_cla_id const& param_id, basic_param_ptr param_candidate, bool final )
-    {
-        BOOST_TEST_I_ASSRT( !m_has_final_candidate && (!final || m_id_candidates.empty()),
-          conflicting_param() << "Parameter cla id " << param_id.m_tag << " conflicts with the "
-                              << "parameter cla id " << m_id_candidates.back().get().m_tag );
-
-        m_has_final_candidate = final;
-        m_id_candidates.push_back( ref(param_id) );
-
-        if( m_id_candidates.size() == 1 )
-            m_param_candidate = param_candidate;
-        else
-            m_param_candidate.reset();
-    }
-
-    /// Gets subtrie for specified char if present or nullptr otherwise
-    parameter_trie_ptr  get_subtrie( char c ) const
-    {
-        trie_per_char::const_iterator it = m_subtrie.find( c );
-
-        return it != m_subtrie.end() ? it->second : parameter_trie_ptr();
-    }
-
-    // Data members
-    trie_per_char       m_subtrie;
-    param_cla_id_list   m_id_candidates;
-    basic_param_ptr     m_param_candidate;
-    bool                m_has_final_candidate;
-};
-
-// ************************************************************************** //
-// **************      runtime::cla::report_foreing_token      ************** //
-// ************************************************************************** //
-
-static void 
-report_foreing_token( cstring program_name, cstring token )
-{
-    std::cerr << "Boost.Test WARNING: token \"" << token << "\" does not correspond to the Boost.Test argument \n"
-              << "                    and should be placed after all Boost.Test arguments and the -- separator.\n"
-              << "                    For example: " << program_name << " --random -- " << token << "\n"; 
-}
-
-} // namespace rt_cla_detail
-
-// ************************************************************************** //
-// **************             runtime::cla::parser             ************** //
-// ************************************************************************** //
-
-class parser {
-public:
-    /// Initializes a parser and builds internal trie representation used for
-    /// parsing based on the supplied parameters
-#ifndef BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
-    template<typename Modifiers=nfp::no_params_type>
-    parser( parameters_store const& parameters, Modifiers const& m = nfp::no_params )
-#else
-    template<typename Modifiers>
-    parser( parameters_store const& parameters, Modifiers const& m )
-#endif
-    {
-        nfp::opt_assign( m_end_of_param_indicator, m, end_of_params );
-        nfp::opt_assign( m_negation_prefix, m, negation_prefix );
-
-        BOOST_TEST_I_ASSRT( algorithm::all_of( m_end_of_param_indicator.begin(),
-                                               m_end_of_param_indicator.end(),
-                                               parameter_cla_id::valid_prefix_char ),
-                            invalid_cla_id() << "End of parameters indicator can only consist of prefix characters." );
-
-        BOOST_TEST_I_ASSRT( algorithm::all_of( m_negation_prefix.begin(),
-                                               m_negation_prefix.end(),
-                                               parameter_cla_id::valid_name_char ),
-                            invalid_cla_id() << "Negation prefix can only consist of prefix characters." );
-
-        build_trie( parameters );
-    }
-
-    // input processing method
-    int
-    parse( int argc, char** argv, runtime::arguments_store& res )
-    {
-        // save program name for help message
-        m_program_name = argv[0];
-        cstring path_sep( "\\/" );
-
-        cstring::iterator it = unit_test::utils::find_last_of( m_program_name.begin(), m_program_name.end(),
-                                                                path_sep.begin(), path_sep.end() );
-        if( it != m_program_name.end() )
-            m_program_name.trim_left( it + 1 );
-
-        // Set up the traverser
-        argv_traverser tr( argc, (char const**)argv );
-
-        // Loop till we reach end of input
-        while( !tr.eoi() ) {
-            cstring curr_token = tr.current_token();
-
-            cstring prefix;
-            cstring name;
-            cstring value_separator;
-            bool    negative_form = false;
-
-            // Perform format validations and split the argument into prefix, name and separator
-            // False return value indicates end of params indicator is met
-            if( !validate_token_format( curr_token, prefix, name, value_separator, negative_form ) ) {
-                // get rid of "end of params" token
-                tr.next_token();
-                break;
-            }
-
-            // Locate trie corresponding to found prefix and skip it in the input
-            trie_ptr curr_trie = m_param_trie[prefix];
-
-            if( !curr_trie ) {
-                //  format_error() << "Unrecognized parameter prefix in the argument " << tr.current_token()
-                rt_cla_detail::report_foreing_token( m_program_name, curr_token );
-                tr.save_token();
-                continue;
-            }
-
-            curr_token.trim_left( prefix.size() );
-
-            // Locate parameter based on a name and skip it in the input
-            locate_result locate_res = locate_parameter( curr_trie, name, curr_token );
-            parameter_cla_id const& found_id    = locate_res.first;
-            basic_param_ptr         found_param = locate_res.second;
-
-            if( negative_form ) {
-                BOOST_TEST_I_ASSRT( found_id.m_negatable,
-                                    format_error( found_param->p_name ) 
-                                        << "Parameter tag " << found_id.m_tag << " is not negatable." );
-
-                curr_token.trim_left( m_negation_prefix.size() );
-            }
-
-            curr_token.trim_left( name.size() );
-
-            cstring value;
-
-            // Skip validations if parameter has optional value and we are at the end of token
-            if( !value_separator.is_empty() || !found_param->p_has_optional_value ) {
-                // Validate and skip value separator in the input
-                BOOST_TEST_I_ASSRT( found_id.m_value_separator == value_separator,
-                                    format_error( found_param->p_name ) 
-                                        << "Invalid separator for the parameter "
-                                        << found_param->p_name
-                                        << " in the argument " << tr.current_token() );
-
-                curr_token.trim_left( value_separator.size() );
-
-                // Deduce value source
-                value = curr_token;
-                if( value.is_empty() ) {
-                    tr.next_token();
-                    value = tr.current_token();
-                }
-
-                BOOST_TEST_I_ASSRT( !value.is_empty(),
-                                    format_error( found_param->p_name )
-                                        << "Missing an argument value for the parameter "
-                                        << found_param->p_name
-                                        << " in the argument " << tr.current_token() );
-            }
-
-            // Validate against argument duplication
-            BOOST_TEST_I_ASSRT( !res.has( found_param->p_name ) || found_param->p_repeatable,
-                                duplicate_arg( found_param->p_name )
-                                    << "Duplicate argument value for the parameter "
-                                    << found_param->p_name
-                                    << " in the argument " << tr.current_token() );
-
-            // Produce argument value
-            found_param->produce_argument( value, negative_form, res );
-
-            tr.next_token();
-        }
-
-        // generate the remainder and return it's size
-        return tr.remainder();
-    }
-
-    // help/usage
-    void
-    usage( std::ostream& ostr, cstring param_name = cstring() )
-    {
-        if( !param_name.is_empty() ) {
-            basic_param_ptr param = locate_parameter( m_param_trie[help_prefix], param_name, "" ).second;
-            param->usage( ostr, m_negation_prefix );
-        }
-        else {
-            ostr << "Usage: " << m_program_name << " [Boost.Test argument]... ";
-            if( !m_end_of_param_indicator.empty() )
-                ostr << m_end_of_param_indicator << " [custom test module argument]...";
-            ostr << "\n";
-        }
-
-        ostr << "\nFor detailed help on Boost.Test parameters use:\n"
-             << "  " << m_program_name << " --help\n"
-             << "or\n"
-             << "  " << m_program_name << " --help=<parameter name>\n";
-    }
-
-    void
-    help( std::ostream& ostr, parameters_store const& parameters, cstring param_name )
-    {
-        if( !param_name.is_empty() ) {
-            basic_param_ptr param = locate_parameter( m_param_trie[help_prefix], param_name, "" ).second;
-            param->help( ostr, m_negation_prefix );
-            return;
-        }
-
-        ostr << "Usage: " << m_program_name << " [Boost.Test argument]... ";
-        if( !m_end_of_param_indicator.empty() )
-            ostr << m_end_of_param_indicator << " [custom test module argument]...";
-
-        ostr << "\n\nBoost.Test arguments correspond to parameters listed below. "
-                "All parameters are optional. You can use specify parameter value either "
-                "as a command line argument or as a value of corresponding environment "
-                "variable. In case if argument for the same parameter is specified in both "
-                "places, command line is taking precedence. Command line argument format "
-                "supports parameter name guessing, so you can use any unambiguous "
-                "prefix to identify a parameter.";
-        if( !m_end_of_param_indicator.empty() )
-            ostr << " All the arguments after the " << m_end_of_param_indicator << " are ignored by the Boost.Test.";
-
-        ostr << "\n\nBoost.Test supports following parameters:\n";
-
-        BOOST_TEST_FOREACH( parameters_store::storage_type::value_type const&, v, parameters.all() ) {
-            basic_param_ptr param = v.second;
-
-            param->usage( ostr, m_negation_prefix );
-        }
-
-        ostr << "\nUse --help=<parameter name> to display detailed help for specific parameter.\n";
-    }
-
-private:
-    typedef rt_cla_detail::parameter_trie_ptr   trie_ptr;
-    typedef rt_cla_detail::trie_per_char        trie_per_char;
-    typedef std::map<cstring,trie_ptr>          str_to_trie;
-
-    void
-    build_trie( parameters_store const& parameters )
-    {
-        // Iterate over all parameters
-        BOOST_TEST_FOREACH( parameters_store::storage_type::value_type const&, v, parameters.all() ) {
-            basic_param_ptr param = v.second;
-
-            // Register all parameter's ids in trie.
-            BOOST_TEST_FOREACH( parameter_cla_id const&, id, param->cla_ids() ) {
-                // This is the trie corresponding to the prefix.
-                trie_ptr next_trie = m_param_trie[id.m_prefix];
-                if( !next_trie )
-                    next_trie = m_param_trie[id.m_prefix] = trie_ptr( new rt_cla_detail::parameter_trie );
-
-                // Build the trie, by following name's characters
-                // and register this parameter as candidate on each level
-                for( size_t index = 0; index < id.m_tag.size(); ++index ) {
-                    next_trie = next_trie->make_subtrie( id.m_tag[index] );
-
-                    next_trie->add_candidate_id( id, param, index == (id.m_tag.size() - 1) );
-                }
-            }
-        }
-    }
-
-    bool
-    validate_token_format( cstring token, cstring& prefix, cstring& name, cstring& separator, bool& negative_form )
-    {
-        // Match prefix
-        cstring::iterator it = token.begin();
-        while( it != token.end() && parameter_cla_id::valid_prefix_char( *it ) )
-            ++it;
-
-        prefix.assign( token.begin(), it );
-
-        if( prefix.empty() )
-            return true;
-
-        // Match name
-        while( it != token.end() && parameter_cla_id::valid_name_char( *it ) )
-            ++it;
-
-        name.assign( prefix.end(), it );
-
-        if( name.empty() ) {
-            if( prefix == m_end_of_param_indicator )
-                return false;
-
-            BOOST_TEST_I_THROW( format_error() << "Invalid format for an actual argument " << token );
-        }
-
-        // Match value separator
-        while( it != token.end() && parameter_cla_id::valid_separator_char( *it ) )
-            ++it;
-
-        separator.assign( name.end(), it );
-
-        // Match negation prefix
-        negative_form = !m_negation_prefix.empty() && ( name.substr( 0, m_negation_prefix.size() ) == m_negation_prefix );
-        if( negative_form )
-            name.trim_left( m_negation_prefix.size() );
-
-        return true;
-    }
-
-    // C++03: cannot have references as types
-    typedef std::pair<parameter_cla_id, basic_param_ptr> locate_result;
-
-    locate_result
-    locate_parameter( trie_ptr curr_trie, cstring name, cstring token )
-    {
-        std::vector<trie_ptr> typo_candidates;
-        std::vector<trie_ptr> next_typo_candidates;
-        trie_ptr next_trie;
-
-        BOOST_TEST_FOREACH( char, c, name ) {
-            if( curr_trie ) {
-                // locate next subtrie corresponding to the char
-                next_trie = curr_trie->get_subtrie( c );
-
-                if( next_trie )
-                    curr_trie = next_trie;
-                else {
-                    // Initiate search for typo candicates. We will account for 'wrong char' typo
-                    // 'missing char' typo and 'extra char' typo
-                    BOOST_TEST_FOREACH( trie_per_char::value_type const&, typo_cand, curr_trie->m_subtrie ) {
-                        // 'wrong char' typo
-                        typo_candidates.push_back( typo_cand.second );
-
-                        // 'missing char' typo
-                        if( (next_trie = typo_cand.second->get_subtrie( c )) )
-                            typo_candidates.push_back( next_trie );
-                    }
-
-                    // 'extra char' typo
-                    typo_candidates.push_back( curr_trie );
-
-                    curr_trie.reset();
-                }
-            }
-            else {
-                // go over existing typo candidates and see if they are still viable
-                BOOST_TEST_FOREACH( trie_ptr, typo_cand, typo_candidates ) {
-                    trie_ptr next_typo_cand = typo_cand->get_subtrie( c );
-
-                    if( next_typo_cand )
-                        next_typo_candidates.push_back( next_typo_cand );
-                }
-
-                next_typo_candidates.swap( typo_candidates );
-                next_typo_candidates.clear();
-            }
-        }
-
-        if( !curr_trie ) {
-            std::vector<cstring> typo_candidate_names;
-            std::set<parameter_cla_id const*> unique_typo_candidate; // !! ?? unordered_set
-            typo_candidate_names.reserve( typo_candidates.size() );
-// !! ??            unique_typo_candidate.reserve( typo_candidates.size() );
-
-            BOOST_TEST_FOREACH( trie_ptr, trie_cand, typo_candidates ) {
-                // avoid ambiguos candidate trie
-                if( trie_cand->m_id_candidates.size() > 1 )
-                    continue;
-
-                BOOST_TEST_FOREACH( parameter_cla_id const&, param_cand, trie_cand->m_id_candidates ) {
-                    if( !unique_typo_candidate.insert( &param_cand ).second )
-                        continue;
-
-                    typo_candidate_names.push_back( param_cand.m_tag );
-                }
-            }
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-            BOOST_TEST_I_THROW( unrecognized_param( std::move(typo_candidate_names) )
-                                << "An unrecognized parameter in the argument "
-                                << token );
-#else
-            BOOST_TEST_I_THROW( unrecognized_param( typo_candidate_names )
-                                << "An unrecognized parameter in the argument "
-                                << token );
-#endif
-        }
-
-        if( curr_trie->m_id_candidates.size() > 1 ) {
-            std::vector<cstring> amb_names;
-            BOOST_TEST_FOREACH( parameter_cla_id const&, param_id, curr_trie->m_id_candidates )
-                amb_names.push_back( param_id.m_tag );
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-            BOOST_TEST_I_THROW( ambiguous_param( std::move( amb_names ) )
-                                << "An ambiguous parameter name in the argument " << token );
-#else
-            BOOST_TEST_I_THROW( ambiguous_param( amb_names )
-                                << "An ambiguous parameter name in the argument " << token );
-#endif
-        }
-
-        return locate_result( curr_trie->m_id_candidates.back().get(), curr_trie->m_param_candidate );
-    }
-
-    // Data members
-    cstring     m_program_name;
-    std::string m_end_of_param_indicator;
-    std::string m_negation_prefix;
-    str_to_trie m_param_trie;
-};
-
-} // namespace cla
-} // namespace runtime
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_RUNTIME_CLA_PARSER_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/env/fetch.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/env/fetch.hpp
deleted file mode 100644
index 97d54d4905f..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/env/fetch.hpp
+++ /dev/null
@@ -1,108 +0,0 @@
-//  (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 : implements fetching absent parameter athuments from environment
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_RUNTIME_ENV_FETCH_HPP
-#define BOOST_TEST_UTILS_RUNTIME_ENV_FETCH_HPP
-
-// Boost.Test Runtime parameters
-#include <boost/test/utils/runtime/parameter.hpp>
-#include <boost/test/utils/runtime/argument.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-// C Runtime
-#include <stdlib.h>
-
-namespace boost {
-namespace runtime {
-namespace env {
-
-namespace env_detail {
-
-#ifndef UNDER_CE
-
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4996) // getenv
-#endif
-
-inline std::pair<cstring,bool>
-sys_read_var( cstring var_name )
-{
-    using namespace std;
-    char const* res = getenv( var_name.begin() );
-
-    return std::make_pair( cstring(res), res != NULL );
-}
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#else
-
-inline std::pair<cstring,bool>
-sys_read_var( cstring var_name )
-{
-    return std::make_pair( cstring(), false );
-}
-
-#endif
-
-//____________________________________________________________________________//
-
-template<typename ReadFunc>
-inline void
-fetch_absent( parameters_store const& params, runtime::arguments_store& args, ReadFunc read_func )
-{
-    BOOST_TEST_FOREACH( parameters_store::storage_type::value_type const&, v, params.all() ) {
-        basic_param_ptr param = v.second;
-
-        if( args.has( param->p_name ) || param->p_env_var.empty() )
-            continue;
-
-        std::pair<cstring,bool> value = read_func( param->p_env_var );
-
-        if( !value.second )
-            continue;
-
-        // Validate against unexpected empty value
-        BOOST_TEST_I_ASSRT( !value.first.is_empty() || param->p_has_optional_value,
-            format_error( param->p_name ) 
-                << "Missing an argument value for the parameter " << param->p_name
-                << " in the environment." );
-
-        // Produce argument value
-        param->produce_argument( value.first, false, args );
-
-    }
-}
-
-//____________________________________________________________________________//
-
-} // namespace env_detail
-
-inline void
-fetch_absent( parameters_store const& params, runtime::arguments_store& args )
-{
-    env_detail::fetch_absent( params, args, &env_detail::sys_read_var );
-}
-
-} // namespace env
-} // namespace runtime
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_RUNTIME_ENV_FETCH_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/errors.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/errors.hpp
deleted file mode 100644
index 37f8d9371b9..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/errors.hpp
+++ /dev/null
@@ -1,195 +0,0 @@
-//  (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 : defines runtime parameters setup error
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_RUNTIME_INIT_ERROR_HPP
-#define BOOST_TEST_UTILS_RUNTIME_INIT_ERROR_HPP
-
-// Boost.Test Runtime parameters
-#include <boost/test/utils/runtime/fwd.hpp>
-
-// Boost.Test
-#include <boost/test/utils/string_cast.hpp>
-
-// Boost.Test
-#include <boost/config.hpp>
-
-// STL
-#include <exception>
-#include <vector>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-namespace boost {
-namespace runtime {
-
-// ************************************************************************** //
-// **************             runtime::param_error             ************** //
-// ************************************************************************** //
-
-class param_error : public std::exception {
-public:
-    ~param_error() BOOST_NOEXCEPT_OR_NOTHROW {}
-
-    virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW
-    {
-        return msg.c_str();
-    }
-
-    cstring     param_name;
-    std::string msg;
-
-protected:
-    explicit    param_error( cstring param_name_ ) : param_name( param_name_) {}
-};
-
-//____________________________________________________________________________//
-
-class init_error : public param_error {
-protected:
-    explicit    init_error( cstring param_name ) : param_error( param_name ) {}
-    ~init_error() BOOST_NOEXCEPT_OR_NOTHROW {}
-};
-
-class input_error : public param_error {
-protected:
-    explicit    input_error( cstring param_name ) : param_error( param_name ) {}
-    ~input_error() BOOST_NOEXCEPT_OR_NOTHROW {}
-};
-
-//____________________________________________________________________________//
-
-template<typename Derived, typename Base>
-class specific_param_error : public Base {
-protected:
-    explicit    specific_param_error( cstring param_name ) : Base( param_name ) {}
-    ~specific_param_error() BOOST_NOEXCEPT_OR_NOTHROW {}
-
-public:
-
-//____________________________________________________________________________//
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
-    !defined(BOOST_NO_CXX11_REF_QUALIFIERS)
-
-    Derived operator<<(char const* val) &&
-    {
-        this->msg.append( val );
-
-        return reinterpret_cast<Derived&&>(*this);
-    }
-
-    //____________________________________________________________________________//
-
-    template<typename T>
-    Derived operator<<(T const& val) &&
-    {
-        this->msg.append( unit_test::utils::string_cast( val ) );
-
-        return reinterpret_cast<Derived&&>(*this);
-    }
-
-    //____________________________________________________________________________//
-
-#else
-
-    Derived const& operator<<(char const* val) const
-    {
-        const_cast<specific_param_error<Derived, Base>&>(*this).msg.append( val );
-
-        return static_cast<Derived const&>(*this);
-    }
-
-    //____________________________________________________________________________//
-
-    template<typename T>
-    Derived const& operator<<(T const& val) const
-    {
-        const_cast<specific_param_error<Derived, Base>&>(*this).msg.append( unit_test::utils::string_cast( val ) );
-
-        return static_cast<Derived const&>(*this);
-    }
-
-    //____________________________________________________________________________//
-
-#endif
-
-};
-
-
-
-// ************************************************************************** //
-// **************           specific exception types           ************** //
-// ************************************************************************** //
-
-#define SPECIFIC_EX_TYPE( type, base )                  \
-class type : public specific_param_error<type,base> {   \
-public:                                                 \
-    explicit type( cstring param_name = cstring() )     \
-    : specific_param_error<type,base>( param_name )     \
-    {}                                                  \
-}                                                       \
-/**/
-
-SPECIFIC_EX_TYPE( invalid_cla_id, init_error );
-SPECIFIC_EX_TYPE( duplicate_param, init_error );
-SPECIFIC_EX_TYPE( conflicting_param, init_error );
-SPECIFIC_EX_TYPE( unknown_param, init_error );
-SPECIFIC_EX_TYPE( access_to_missing_argument, init_error );
-SPECIFIC_EX_TYPE( arg_type_mismatch, init_error );
-SPECIFIC_EX_TYPE( invalid_param_spec, init_error );
-
-SPECIFIC_EX_TYPE( format_error, input_error );
-SPECIFIC_EX_TYPE( duplicate_arg, input_error );
-SPECIFIC_EX_TYPE( missing_req_arg, input_error );
-
-#undef SPECIFIC_EX_TYPE
-
-class ambiguous_param : public specific_param_error<ambiguous_param, input_error> {
-public:
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    explicit    ambiguous_param( std::vector<cstring>&& amb_candidates )
-    : specific_param_error<ambiguous_param,input_error>( "" )
-    , m_amb_candidates( std::move( amb_candidates ) ) {}
-#else
-    explicit    ambiguous_param( std::vector<cstring> const& amb_candidates )
-    : specific_param_error<ambiguous_param,input_error>( "" )
-    , m_amb_candidates( amb_candidates ) {}
-#endif
-    ~ambiguous_param() BOOST_NOEXCEPT_OR_NOTHROW {}
-
-    std::vector<cstring> m_amb_candidates;
-};
-
-class unrecognized_param : public specific_param_error<unrecognized_param, input_error> {
-public:
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    explicit    unrecognized_param( std::vector<cstring>&& type_candidates )
-    : specific_param_error<unrecognized_param,input_error>( "" )
-    , m_typo_candidates( std::move( type_candidates ) ) {}
-#else
-    explicit    unrecognized_param( std::vector<cstring> const& type_candidates )
-    : specific_param_error<unrecognized_param,input_error>( "" )
-    , m_typo_candidates( type_candidates ) {}
-#endif
-    ~unrecognized_param() BOOST_NOEXCEPT_OR_NOTHROW {}
-
-    std::vector<cstring> m_typo_candidates;
-};
-
-} // namespace runtime
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_RUNTIME_INIT_ERROR_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/finalize.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/finalize.hpp
deleted file mode 100644
index 181428550c1..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/finalize.hpp
+++ /dev/null
@@ -1,56 +0,0 @@
-//  (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 : runtime parameters initialization final step
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_RUNTIME_FINALIZE_HPP
-#define BOOST_TEST_UTILS_RUNTIME_FINALIZE_HPP
-
-// Boost.Test Runtime parameters
-#include <boost/test/utils/runtime/parameter.hpp>
-#include <boost/test/utils/runtime/argument.hpp>
-
-// Boost.Test
-#include <boost/test/utils/foreach.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-namespace boost {
-namespace runtime {
-
-inline void
-finalize_arguments( parameters_store const& params, runtime::arguments_store& args )
-{
-    BOOST_TEST_FOREACH( parameters_store::storage_type::value_type const&, v, params.all() ) {
-        basic_param_ptr param = v.second;
-
-        if( !args.has( param->p_name ) ) {
-            if( param->p_has_default_value )
-                param->produce_default( args );
-
-            if( !args.has( param->p_name ) ) {
-                BOOST_TEST_I_ASSRT( param->p_optional,
-                    missing_req_arg( param->p_name ) << "Missing argument for required parameter " << param->p_name << "." );
-            }
-        }
-
-        if( args.has( param->p_name ) && !!param->p_callback )
-            param->p_callback( param->p_name );
-    }
-}
-
-} // namespace runtime
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_RUNTIME_FINALIZE_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/fwd.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/fwd.hpp
deleted file mode 100644
index 17ae8812226..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/fwd.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-//  (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 : runtime parameters forward declaration
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_RUNTIME_FWD_HPP
-#define BOOST_TEST_UTILS_RUNTIME_FWD_HPP
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp> // operator<<(boost::runtime::cstring)
-
-// Boost
-#include <boost/shared_ptr.hpp>
-
-// STL
-#include <map>
-
-namespace boost {
-namespace runtime {
-
-typedef unit_test::const_string     cstring;
-
-class argument;
-typedef shared_ptr<argument> argument_ptr;
-
-template<typename T> class typed_argument;
-
-class basic_param;
-typedef shared_ptr<basic_param> basic_param_ptr;
-
-} // namespace runtime
-} // namespace boost
-
-#endif // BOOST_TEST_UTILS_RUNTIME_FWD_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/modifier.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/modifier.hpp
deleted file mode 100644
index f4f5a42baa8..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/modifier.hpp
+++ /dev/null
@@ -1,106 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2001.
-//  Use, modification, and distribution are subject to the
-//  Boost Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : parameter modifiers
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_RUNTIME_MODIFIER_HPP
-#define BOOST_TEST_UTILS_RUNTIME_MODIFIER_HPP
-
-// Boost.Test Runtime parameters
-#include <boost/test/utils/runtime/fwd.hpp>
-
-// Boost.Test
-#include <boost/test/utils/named_params.hpp>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-
-// New CLA API available only for some C++11 compilers
-#if    !defined(BOOST_NO_CXX11_AUTO_DECLARATIONS) \
-    && !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) \
-    && !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) \
-    && !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
-#define BOOST_TEST_CLA_NEW_API
-#endif
-
-namespace boost {
-namespace runtime {
-
-// ************************************************************************** //
-// **************         environment variable modifiers       ************** //
-// ************************************************************************** //
-
-namespace {
-
-#ifdef BOOST_TEST_CLA_NEW_API
-auto const& description     = unit_test::static_constant<nfp::typed_keyword<cstring,struct description_t>>::value;
-auto const& help            = unit_test::static_constant<nfp::typed_keyword<cstring,struct help_t>>::value;
-auto const& env_var         = unit_test::static_constant<nfp::typed_keyword<cstring,struct env_var_t>>::value;
-auto const& end_of_params   = unit_test::static_constant<nfp::typed_keyword<cstring,struct end_of_params_t>>::value;
-auto const& negation_prefix = unit_test::static_constant<nfp::typed_keyword<cstring,struct neg_prefix_t>>::value;
-auto const& value_hint      = unit_test::static_constant<nfp::typed_keyword<cstring,struct value_hint_t>>::value;
-auto const& optional_value  = unit_test::static_constant<nfp::keyword<struct optional_value_t>>::value;
-auto const& default_value   = unit_test::static_constant<nfp::keyword<struct default_value_t>>::value;
-auto const& callback        = unit_test::static_constant<nfp::keyword<struct callback_t>>::value;
-
-template<typename EnumType>
-using enum_values = unit_test::static_constant<
-  nfp::typed_keyword<std::initializer_list<std::pair<const cstring,EnumType>>, struct enum_values_t>
->;
-
-#else
-
-nfp::typed_keyword<cstring,struct description_t> description;
-nfp::typed_keyword<cstring,struct help_t> help;
-nfp::typed_keyword<cstring,struct env_var_t> env_var;
-nfp::typed_keyword<cstring,struct end_of_params_t> end_of_params;
-nfp::typed_keyword<cstring,struct neg_prefix_t> negation_prefix;
-nfp::typed_keyword<cstring,struct value_hint_t> value_hint;
-nfp::keyword<struct optional_value_t> optional_value;
-nfp::keyword<struct default_value_t> default_value;
-nfp::keyword<struct callback_t> callback;
-
-template<typename EnumType>
-struct enum_values_list {
-    typedef std::pair<cstring,EnumType> ElemT;
-    typedef std::vector<ElemT> ValuesT;
-
-    enum_values_list const&
-    operator()( cstring k, EnumType v ) const
-    {
-        const_cast<enum_values_list*>(this)->m_values.push_back( ElemT( k, v ) );
-
-        return *this;
-    }
-
-    operator ValuesT const&() const { return m_values; }
-
-private:
-    ValuesT m_values;
-};
-
-template<typename EnumType>
-struct enum_values : unit_test::static_constant<
-  nfp::typed_keyword<enum_values_list<EnumType>, struct enum_values_t> >
-{
-};
-
-#endif
-
-} // local namespace
-
-} // namespace runtime
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_RUNTIME_MODIFIER_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/parameter.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/parameter.hpp
deleted file mode 100644
index c1986884938..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/runtime/parameter.hpp
+++ /dev/null
@@ -1,472 +0,0 @@
-//  (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 : formal parameter definition
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_RUNTIME_PARAMETER_HPP
-#define BOOST_TEST_UTILS_RUNTIME_PARAMETER_HPP
-
-// Boost.Test Runtime parameters
-#include <boost/test/utils/runtime/fwd.hpp>
-#include <boost/test/utils/runtime/modifier.hpp>
-#include <boost/test/utils/runtime/argument.hpp>
-#include <boost/test/utils/runtime/argument_factory.hpp>
-
-// Boost.Test
-#include <boost/test/utils/class_properties.hpp>
-#include <boost/test/utils/foreach.hpp>
-
-// Boost
-#include <boost/function/function2.hpp>
-#include <boost/algorithm/cxx11/all_of.hpp>
-
-// STL
-#include <algorithm>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-namespace boost {
-namespace runtime {
-
-// ************************************************************************** //
-// **************           runtime::parameter_cla_id          ************** //
-// ************************************************************************** //
-// set of attributes identifying the parameter in the command line
-
-struct parameter_cla_id {
-    parameter_cla_id( cstring prefix, cstring tag, cstring value_separator, bool negatable )
-    : m_prefix( prefix.begin(), prefix.size() )
-    , m_tag( tag.begin(), tag.size() )
-    , m_value_separator( value_separator.begin(), value_separator.size() )
-    , m_negatable( negatable )
-    {
-
-        BOOST_TEST_I_ASSRT( algorithm::all_of( m_prefix.begin(), m_prefix.end(), valid_prefix_char ),
-                            invalid_cla_id() << "Parameter " << m_tag
-                                             << " has invalid characters in prefix." );
-
-        BOOST_TEST_I_ASSRT( algorithm::all_of( m_tag.begin(), m_tag.end(), valid_name_char ),
-                            invalid_cla_id() << "Parameter " << m_tag
-                                             << " has invalid characters in name." );
-
-        BOOST_TEST_I_ASSRT( algorithm::all_of( m_value_separator.begin(), m_value_separator.end(), valid_separator_char ),
-                            invalid_cla_id() << "Parameter " << m_tag
-                                             << " has invalid characters in value separator." );
-    }
-
-    static bool             valid_prefix_char( char c )
-    {
-        return c == '-' || c == '/' ;
-    }
-    static bool             valid_separator_char( char c )
-    {
-        return c == '=' || c == ':' || c == ' ' || c == '\0';
-    }
-    static bool             valid_name_char( char c )
-    {
-        return std::isalnum( c ) || c == '+' || c == '_' || c == '?';
-    }
-
-    std::string             m_prefix;
-    std::string             m_tag;
-    std::string             m_value_separator;
-    bool                    m_negatable;
-};
-
-typedef std::vector<parameter_cla_id> param_cla_ids;
-
-// ************************************************************************** //
-// **************             runtime::basic_param             ************** //
-// ************************************************************************** //
-
-cstring const help_prefix("////");
-
-class basic_param {
-    typedef function<void (cstring)>            callback_type;
-    typedef unit_test::readwrite_property<bool> bool_property;
-
-protected:
-    /// Constructor with modifiers
-    template<typename Modifiers>
-    basic_param( cstring name, bool is_optional, bool is_repeatable, Modifiers const& m )
-    : p_name( name.begin(), name.end() )
-    , p_description( nfp::opt_get( m, description, std::string() ) )
-    , p_help( nfp::opt_get( m, runtime::help, std::string() ) )
-    , p_env_var( nfp::opt_get( m, env_var, std::string() ) )
-    , p_value_hint( nfp::opt_get( m, value_hint, std::string() ) )
-    , p_optional( is_optional )
-    , p_repeatable( is_repeatable )
-    , p_has_optional_value( m.has( optional_value ) )
-    , p_has_default_value( m.has( default_value ) || is_repeatable )
-    , p_callback( nfp::opt_get( m, callback, callback_type() ) )
-    {
-        add_cla_id( help_prefix, name, ":" );
-    }
-
-public:
-    virtual                 ~basic_param() {}
-
-    // Pubic properties
-    std::string const       p_name;
-    std::string const       p_description;
-    std::string const       p_help;
-    std::string const       p_env_var;
-    std::string const       p_value_hint;
-    bool const              p_optional;
-    bool const              p_repeatable;
-    bool_property           p_has_optional_value;
-    bool_property           p_has_default_value;
-    callback_type const     p_callback;
-
-    /// interface for cloning typed parameters
-    virtual basic_param_ptr clone() const = 0;
-
-    /// Access methods
-    param_cla_ids const&    cla_ids() const { return m_cla_ids; }
-    void                    add_cla_id( cstring prefix, cstring tag, cstring value_separator )
-    {
-        add_cla_id_impl( prefix, tag, value_separator, false, true );
-    }
-
-    /// interface for producing argument values for this parameter
-    virtual void            produce_argument( cstring token, bool negative_form, arguments_store& store ) const = 0;
-    virtual void            produce_default( arguments_store& store ) const = 0;
-
-    /// interfaces for help message reporting
-    virtual void            usage( std::ostream& ostr, cstring negation_prefix_ )
-    {
-        ostr     << "Parameter: " << p_name << '\n';
-        if( !p_description.empty() )
-            ostr << ' ' << p_description << '\n';
-
-        ostr     << " Command line formats:\n";
-        BOOST_TEST_FOREACH( parameter_cla_id const&, id, cla_ids() ) {
-            if( id.m_prefix == help_prefix )
-                continue;
-
-            ostr << "   " << id.m_prefix;
-            if( id.m_negatable )
-                cla_name_help( ostr, id.m_tag, negation_prefix_ );
-            else
-                cla_name_help( ostr, id.m_tag, "" );
-
-            bool optional_value_ = false;
-
-            if( p_has_optional_value ) {
-                optional_value_ = true;
-                ostr << '[';
-            }
-
-            if( id.m_value_separator.empty() )
-                ostr << ' ';
-            else {
-                ostr << id.m_value_separator;
-            }
-
-            value_help( ostr );
-
-            if( optional_value_ )
-                ostr << ']';
-
-            ostr << '\n';
-        }
-        if( !p_env_var.empty() )
-            ostr << " Environment variable: " << p_env_var << '\n';
-    }
-
-    virtual void            help( std::ostream& ostr, cstring negation_prefix_ )
-    {
-        usage( ostr, negation_prefix_ );
-
-        if( !p_help.empty() )
-            ostr << '\n' << p_help << '\n';
-    }
-
-protected:
-    void                    add_cla_id_impl( cstring prefix,
-                                             cstring tag,
-                                             cstring value_separator,
-                                             bool negatable,
-                                             bool validate_value_separator )
-    {
-        BOOST_TEST_I_ASSRT( !tag.is_empty(),
-                            invalid_cla_id() << "Parameter can't have an empty name." );
-
-        BOOST_TEST_I_ASSRT( !prefix.is_empty(),
-                            invalid_cla_id() << "Parameter " << tag
-                                             << " can't have an empty prefix." );
-
-        BOOST_TEST_I_ASSRT( !value_separator.is_empty(),
-                            invalid_cla_id() << "Parameter " << tag
-                                             << " can't have an empty value separator." );
-
-        // We trim value separator from all the spaces, so token end will indicate separator
-        value_separator.trim();
-        BOOST_TEST_I_ASSRT( !validate_value_separator || !value_separator.is_empty() || !p_has_optional_value,
-                            invalid_cla_id() << "Parameter " << tag
-                                             << " with optional value attribute can't use space as value separator." );
-
-        m_cla_ids.push_back( parameter_cla_id( prefix, tag, value_separator, negatable ) );
-    }
-
-private:
-    /// interface for usage/help customization
-    virtual void            cla_name_help( std::ostream& ostr, cstring cla_tag, cstring negation_prefix_ ) const
-    {
-        ostr << cla_tag;
-    }
-    virtual void            value_help( std::ostream& ostr ) const
-    {
-        if( p_value_hint.empty() )
-            ostr << "<value>";
-        else
-            ostr << p_value_hint;
-    }
-
-    // Data members
-    param_cla_ids       m_cla_ids;
-};
-
-// ************************************************************************** //
-// **************              runtime::parameter              ************** //
-// ************************************************************************** //
-
-enum args_amount {
-    OPTIONAL_PARAM,   // 0-1
-    REQUIRED_PARAM,   // exactly 1
-    REPEATABLE_PARAM  // 0-N
-};
-
-//____________________________________________________________________________//
-
-template<typename ValueType, args_amount a = runtime::OPTIONAL_PARAM, bool is_enum = false>
-class parameter : public basic_param {
-public:
-    /// Constructor with modifiers
-#ifndef BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
-    template<typename Modifiers=nfp::no_params_type>
-    parameter( cstring name, Modifiers const& m = nfp::no_params )
-#else
-    template<typename Modifiers>
-    parameter( cstring name, Modifiers const& m )
-#endif
-    : basic_param( name, a != runtime::REQUIRED_PARAM, a == runtime::REPEATABLE_PARAM, m )
-    , m_arg_factory( m )
-    {
-        BOOST_TEST_I_ASSRT( !m.has( default_value ) || a == runtime::OPTIONAL_PARAM,
-                            invalid_param_spec() << "Parameter " << name
-                                                 << " is not optional and can't have default_value." );
-
-        BOOST_TEST_I_ASSRT( !m.has( optional_value ) || !this->p_repeatable,
-                            invalid_param_spec() << "Parameter " << name
-                                                 << " is repeatable and can't have optional_value." );
-    }
-
-private:
-    virtual basic_param_ptr clone() const
-    {
-        return basic_param_ptr( new parameter( *this ) );
-    }
-    virtual void    produce_argument( cstring token, bool , arguments_store& store ) const
-    {
-        m_arg_factory.produce_argument( token, this->p_name, store );
-    }
-    virtual void    produce_default( arguments_store& store ) const
-    {
-        if( !this->p_has_default_value )
-            return;
-
-        m_arg_factory.produce_default( this->p_name, store );
-    }
-
-    // Data members
-    typedef argument_factory<ValueType, is_enum, a == runtime::REPEATABLE_PARAM> factory_t;
-    factory_t       m_arg_factory;
-};
-
-//____________________________________________________________________________//
-
-class option : public basic_param {
-public:
-    /// Constructor with modifiers
-#ifndef BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
-    template<typename Modifiers=nfp::no_params_type>
-    option( cstring name, Modifiers const& m = nfp::no_params )
-#else
-    template<typename Modifiers>
-    option( cstring name, Modifiers const& m )
-#endif
-    : basic_param( name, true, false, nfp::opt_append( nfp::opt_append( m, optional_value = true), default_value = false) )
-    , m_arg_factory( nfp::opt_append( nfp::opt_append( m, optional_value = true), default_value = false) )
-    {
-    }
-
-    void            add_cla_id( cstring prefix, cstring tag, cstring value_separator, bool negatable = false )
-    {
-        add_cla_id_impl( prefix, tag, value_separator, negatable, false );
-    }
-
-private:
-    virtual basic_param_ptr clone() const
-    {
-        return basic_param_ptr( new option( *this ) );
-    }
-
-    virtual void    produce_argument( cstring token, bool negative_form, arguments_store& store ) const
-    {
-        if( token.empty() )
-            store.set( p_name, !negative_form );
-        else {
-            BOOST_TEST_I_ASSRT( !negative_form,
-                                format_error( p_name ) << "Can't set value to negative form of the argument." );
-
-            m_arg_factory.produce_argument( token, p_name, store );
-        }
-    }
-
-    virtual void    produce_default( arguments_store& store ) const
-    {
-        m_arg_factory.produce_default( p_name, store );
-    }
-    virtual void    cla_name_help( std::ostream& ostr, cstring cla_tag, cstring negation_prefix_ ) const
-    {
-        if( negation_prefix_.is_empty() )
-            ostr << cla_tag;
-        else
-            ostr << '[' << negation_prefix_ << ']' << cla_tag;
-    }
-    virtual void    value_help( std::ostream& ostr ) const
-    {
-        if( p_value_hint.empty() )
-            ostr << "<boolean value>";
-        else
-            ostr << p_value_hint;
-    }
-
-    // Data members
-    typedef argument_factory<bool, false, false> factory_t;
-    factory_t       m_arg_factory;
-};
-
-//____________________________________________________________________________//
-
-template<typename EnumType, args_amount a = runtime::OPTIONAL_PARAM>
-class enum_parameter : public parameter<EnumType, a, true> {
-    typedef parameter<EnumType, a, true> base;
-public:
-    /// Constructor with modifiers
-#ifndef BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
-    template<typename Modifiers=nfp::no_params_type>
-    enum_parameter( cstring name, Modifiers const& m = nfp::no_params )
-#else
-    template<typename Modifiers>
-    enum_parameter( cstring name, Modifiers const& m )
-#endif
-    : base( name, m )
-    {
-#ifdef BOOST_TEST_CLA_NEW_API
-        auto const& values = m[enum_values<EnumType>::value];
-        auto it = values.begin();
-#else
-        std::vector<std::pair<cstring, EnumType> > const& values = m[enum_values<EnumType>::value];
-        typename std::vector<std::pair<cstring, EnumType> >::const_iterator it = values.begin();
-#endif
-        while( it != values.end() ) {
-            m_valid_names.push_back( it->first );
-            ++it;
-        }
-    }
-
-private:
-    virtual basic_param_ptr clone() const
-    {
-        return basic_param_ptr( new enum_parameter( *this ) );
-    }
-
-    virtual void    value_help( std::ostream& ostr ) const
-    {
-        if( this->p_value_hint.empty() ) {
-            ostr << "<";
-            bool first = true;
-            BOOST_TEST_FOREACH( cstring, name, m_valid_names ) {
-                if( first )
-                    first = false;
-                else
-                    ostr << '|';
-                ostr << name;
-            }
-            ostr << ">";
-        }
-        else
-            ostr << this->p_value_hint;
-    }
-
-    // Data members
-    std::vector<cstring>    m_valid_names;
-};
-
-
-// ************************************************************************** //
-// **************           runtime::parameters_store          ************** //
-// ************************************************************************** //
-
-class parameters_store {
-    struct lg_compare {
-        bool operator()( cstring lh, cstring rh ) const
-        {
-            return std::lexicographical_compare(lh.begin(), lh.end(),
-                                                rh.begin(), rh.end());
-        }
-    };
-public:
-
-    typedef std::map<cstring, basic_param_ptr, lg_compare> storage_type;
-
-    /// Adds parameter into the persistent store
-    void                    add( basic_param const& in )
-    {
-        basic_param_ptr p = in.clone();
-
-        BOOST_TEST_I_ASSRT( m_parameters.insert( std::make_pair( cstring(p->p_name), p ) ).second,
-                            duplicate_param() << "Parameter " << p->p_name << " is duplicate." );
-    }
-
-    /// Returns true if there is no parameters registered
-    bool                    is_empty() const    { return m_parameters.empty(); }
-    /// Returns map of all the registered parameter
-    storage_type const&     all() const         { return m_parameters; }
-    /// Returns true if parameter with psecified name is registered
-    bool                    has( cstring name ) const
-    {
-        return m_parameters.find( name ) != m_parameters.end();
-    }
-    /// Returns map of all the registered parameter
-    basic_param_ptr         get( cstring name ) const
-    {
-        storage_type::const_iterator const& found = m_parameters.find( name );
-        BOOST_TEST_I_ASSRT( found != m_parameters.end(),
-                            unknown_param() << "Parameter " << name << " is unknown." );
-
-        return found->second;
-    }
-
-private:
-    // Data members
-    storage_type            m_parameters;
-};
-
-} // namespace runtime
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_RUNTIME_PARAMETER_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/setcolor.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/setcolor.hpp
deleted file mode 100644
index c70209038a7..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/setcolor.hpp
+++ /dev/null
@@ -1,126 +0,0 @@
-//  (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 : contains definition for setcolor iostream manipulator
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_SETCOLOR_HPP
-#define BOOST_TEST_UTILS_SETCOLOR_HPP
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-
-// STL
-#include <iostream>
-#include <cstdio>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace utils {
-
-// ************************************************************************** //
-// **************                    term_attr                 ************** //
-// ************************************************************************** //
-
-struct term_attr { enum _ {
-    NORMAL    = 0,
-    BRIGHT    = 1,
-    DIM       = 2,
-    UNDERLINE = 4,
-    BLINK     = 5,
-    REVERSE   = 7,
-    CROSSOUT  = 9
-}; };
-
-// ************************************************************************** //
-// **************                   term_color                 ************** //
-// ************************************************************************** //
-
-struct term_color { enum _ {
-    BLACK    = 0,
-    RED      = 1,
-    GREEN    = 2,
-    YELLOW   = 3,
-    BLUE     = 4,
-    MAGENTA  = 5,
-    CYAN     = 6,
-    WHITE    = 7,
-    ORIGINAL = 9
-}; };
-
-// ************************************************************************** //
-// **************                    setcolor                  ************** //
-// ************************************************************************** //
-
-class setcolor {
-public:
-    // Constructor
-    explicit    setcolor( term_attr::_  attr = term_attr::NORMAL,
-                          term_color::_ fg   = term_color::ORIGINAL,
-                          term_color::_ bg   = term_color::ORIGINAL )
-    {
-        m_command_size = std::sprintf( m_control_command, "%c[%d;%d;%dm", 0x1B, attr, fg + 30, bg + 40 );
-    }
-
-    friend std::ostream&
-    operator<<( std::ostream& os, setcolor const& sc )
-    {
-        return os.write( sc.m_control_command, sc.m_command_size );
-    }
-
-private:
-    // Data members
-    char        m_control_command[13];
-    int         m_command_size;
-};
-
-// ************************************************************************** //
-// **************                 scope_setcolor               ************** //
-// ************************************************************************** //
-
-struct scope_setcolor {
-    scope_setcolor() : m_os( 0 ) {}
-    explicit    scope_setcolor( std::ostream& os,
-                                term_attr::_  attr = term_attr::NORMAL,
-                                term_color::_ fg   = term_color::ORIGINAL,
-                                term_color::_ bg   = term_color::ORIGINAL )
-    : m_os( &os )
-    {
-        os << setcolor( attr, fg, bg );
-    }
-    ~scope_setcolor()
-    {
-        if( m_os )
-            *m_os << setcolor();
-    }
-private:
-    // Data members
-    std::ostream* m_os;
-};
-
-#define BOOST_TEST_SCOPE_SETCOLOR( is_color_output, os, attr, color )   \
-    utils::scope_setcolor const& sc = is_color_output                   \
-           ? utils::scope_setcolor( os, utils::attr, utils::color )     \
-           : utils::scope_setcolor();                                   \
-    ut_detail::ignore_unused_variable_warning( sc )                     \
-/**/
-
-} // namespace utils
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_SETCOLOR_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/string_cast.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/string_cast.hpp
deleted file mode 100644
index 3c069a84034..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/string_cast.hpp
+++ /dev/null
@@ -1,69 +0,0 @@
-//  (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 : trivial utility to cast to/from strings
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_STRING_CAST_HPP
-#define BOOST_TEST_UTILS_STRING_CAST_HPP
-
-// Boost.Test
-#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
-
-// STL
-#include <sstream>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace utils {
-
-// ************************************************************************** //
-// **************                  string_cast                 ************** //
-// ************************************************************************** //
-
-template<typename T>
-inline std::string
-string_cast( T const& t )
-{
-    std::ostringstream buff;
-    buff << t;
-    return buff.str();
-}
-
-//____________________________________________________________________________//
-
-// ************************************************************************** //
-// **************                  string_as                 ************** //
-// ************************************************************************** //
-
-template<typename T>
-inline bool
-string_as( const_string str, T& res )
-{
-    std::istringstream buff( std::string( str.begin(), str.end() ) );
-    buff >> res;
-
-    return !buff.fail() && buff.eof();
-}
-
-//____________________________________________________________________________//
-
-} // namespace utils
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_STRING_CAST_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/trivial_singleton.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/trivial_singleton.hpp
deleted file mode 100644
index ac612b63930..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/trivial_singleton.hpp
+++ /dev/null
@@ -1,79 +0,0 @@
-//  (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 : simple helpers for creating cusom output manipulators
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_TRIVIAL_SIGNLETON_HPP
-#define BOOST_TEST_UTILS_TRIVIAL_SIGNLETON_HPP
-
-// Boost.Test
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-// Boost
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-
-// ************************************************************************** //
-// **************                   singleton                  ************** //
-// ************************************************************************** //
-
-template<typename Derived>
-class singleton {
-public:
-    static Derived& instance() { static Derived the_inst; return the_inst; }
-
-    BOOST_DELETED_FUNCTION(singleton(singleton const&))
-    BOOST_DELETED_FUNCTION(singleton& operator=(singleton const&))
-
-protected:
-    BOOST_DEFAULTED_FUNCTION(singleton(), {})
-    BOOST_DEFAULTED_FUNCTION(~singleton(), {})
-};
-
-//____________________________________________________________________________//
-
-#define BOOST_TEST_SINGLETON_CONS( type )       \
-friend class boost::unit_test::singleton<type>; \
-type() {}                                       \
-/**/
-
-#if BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
-
-#define BOOST_TEST_SINGLETON_INST( inst ) \
-template class unit_test::singleton< BOOST_JOIN( inst, _t ) > ; \
-namespace { BOOST_JOIN( inst, _t)& inst = BOOST_JOIN( inst, _t)::instance(); }
-
-#elif defined(__APPLE_CC__) && defined(__GNUC__) && __GNUC__ < 4
-#define BOOST_TEST_SINGLETON_INST( inst ) \
-static BOOST_JOIN( inst, _t)& inst = BOOST_JOIN (inst, _t)::instance();
-
-#else
-
-#define BOOST_TEST_SINGLETON_INST( inst ) \
-namespace { BOOST_JOIN( inst, _t)& inst = BOOST_JOIN( inst, _t)::instance(); }
-
-#endif
-
-//____________________________________________________________________________//
-
-} // namespace unit_test
-} // namespace boost
-
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_TRIVIAL_SIGNLETON_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/wrap_stringstream.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/wrap_stringstream.hpp
deleted file mode 100644
index 425d7ed75bf..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/wrap_stringstream.hpp
+++ /dev/null
@@ -1,162 +0,0 @@
-//  (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 : wraps strstream and stringstream (depends with one is present)
-//                to provide the unified interface
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_WRAP_STRINGSTREAM_HPP
-#define BOOST_TEST_UTILS_WRAP_STRINGSTREAM_HPP
-
-// Boost.Test
-#include <boost/test/detail/config.hpp>
-
-// STL
-#ifdef BOOST_NO_STRINGSTREAM
-#include <strstream>        // for std::ostrstream
-#else
-#include <sstream>          // for std::ostringstream
-#endif // BOOST_NO_STRINGSTREAM
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-
-// ************************************************************************** //
-// **************            basic_wrap_stringstream           ************** //
-// ************************************************************************** //
-
-template<typename CharT>
-class basic_wrap_stringstream {
-public:
-#if defined(BOOST_CLASSIC_IOSTREAMS)
-    typedef std::ostringstream               wrapped_stream;
-#elif defined(BOOST_NO_STRINGSTREAM)
-    typedef std::basic_ostrstream<CharT>     wrapped_stream;
-#else
-    typedef std::basic_ostringstream<CharT>  wrapped_stream;
-#endif // BOOST_NO_STRINGSTREAM
-    // Access methods
-    basic_wrap_stringstream&        ref();
-    wrapped_stream&                 stream();
-    std::basic_string<CharT> const& str();
-
-private:
-    // Data members
-    wrapped_stream                  m_stream;
-    std::basic_string<CharT>        m_str;
-};
-
-//____________________________________________________________________________//
-
-template <typename CharT, typename T>
-inline basic_wrap_stringstream<CharT>&
-operator<<( basic_wrap_stringstream<CharT>& targ, T const& t )
-{
-    targ.stream() << t;
-    return targ;
-}
-
-//____________________________________________________________________________//
-
-template <typename CharT>
-inline typename basic_wrap_stringstream<CharT>::wrapped_stream&
-basic_wrap_stringstream<CharT>::stream()
-{
-    return m_stream;
-}
-
-//____________________________________________________________________________//
-
-template <typename CharT>
-inline basic_wrap_stringstream<CharT>&
-basic_wrap_stringstream<CharT>::ref()
-{
-    return *this;
-}
-
-//____________________________________________________________________________//
-
-template <typename CharT>
-inline std::basic_string<CharT> const&
-basic_wrap_stringstream<CharT>::str()
-{
-
-#ifdef BOOST_NO_STRINGSTREAM
-    m_str.assign( m_stream.str(), m_stream.pcount() );
-    m_stream.freeze( false );
-#else
-    m_str = m_stream.str();
-#endif
-
-    return m_str;
-}
-
-//____________________________________________________________________________//
-
-template <typename CharT>
-inline basic_wrap_stringstream<CharT>&
-operator<<( basic_wrap_stringstream<CharT>& targ, basic_wrap_stringstream<CharT>& src )
-{
-    targ << src.str();
-    return targ;
-}
-
-//____________________________________________________________________________//
-
-#if BOOST_TEST_USE_STD_LOCALE
-
-template <typename CharT>
-inline basic_wrap_stringstream<CharT>&
-operator<<( basic_wrap_stringstream<CharT>& targ, std::ios_base& (BOOST_TEST_CALL_DECL *man)(std::ios_base&) )
-{
-    targ.stream() << man;
-    return targ;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT,typename Elem,typename Tr>
-inline basic_wrap_stringstream<CharT>&
-operator<<( basic_wrap_stringstream<CharT>& targ, std::basic_ostream<Elem,Tr>& (BOOST_TEST_CALL_DECL *man)(std::basic_ostream<Elem, Tr>&) )
-{
-    targ.stream() << man;
-    return targ;
-}
-
-//____________________________________________________________________________//
-
-template<typename CharT,typename Elem,typename Tr>
-inline basic_wrap_stringstream<CharT>&
-operator<<( basic_wrap_stringstream<CharT>& targ, std::basic_ios<Elem, Tr>& (BOOST_TEST_CALL_DECL *man)(std::basic_ios<Elem, Tr>&) )
-{
-    targ.stream() << man;
-    return targ;
-}
-
-//____________________________________________________________________________//
-
-#endif
-
-// ************************************************************************** //
-// **************               wrap_stringstream              ************** //
-// ************************************************************************** //
-
-typedef basic_wrap_stringstream<char>       wrap_stringstream;
-typedef basic_wrap_stringstream<wchar_t>    wrap_wstringstream;
-
-}  // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif  // BOOST_TEST_UTILS_WRAP_STRINGSTREAM_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/test/utils/xml_printer.hpp b/contrib/libboost/boost_1_62_0/boost/test/utils/xml_printer.hpp
deleted file mode 100644
index ffaf8fcc057..00000000000
--- a/contrib/libboost/boost_1_62_0/boost/test/utils/xml_printer.hpp
+++ /dev/null
@@ -1,143 +0,0 @@
-//  (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 : common code used by any agent serving as OF_XML printer
-// ***************************************************************************
-
-#ifndef BOOST_TEST_UTILS_XML_PRINTER_HPP
-#define BOOST_TEST_UTILS_XML_PRINTER_HPP
-
-// Boost.Test
-#include <boost/test/utils/basic_cstring/basic_cstring.hpp>
-#include <boost/test/utils/custom_manip.hpp>
-#include <boost/test/utils/foreach.hpp>
-#include <boost/test/utils/basic_cstring/io.hpp>
-
-// Boost
-#include <boost/config.hpp>
-
-// STL
-#include <iostream>
-
-#include <boost/test/detail/suppress_warnings.hpp>
-
-//____________________________________________________________________________//
-
-namespace boost {
-namespace unit_test {
-namespace utils {
-
-// ************************************************************************** //
-// **************               xml print helpers              ************** //
-// ************************************************************************** //
-
-inline void
-print_escaped( std::ostream& where_to, const_string value )
-{
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) && !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
-    static std::map<char,char const*> const char_type{{
-        {'<' , "lt"},
-        {'>' , "gt"},
-        {'&' , "amp"},
-        {'\'', "apos"},
-        {'"' , "quot"}
-    }};
-#else
-    static std::map<char,char const*> char_type;
-
-    if( char_type.empty() ) {
-        char_type['<'] = "lt";
-        char_type['>'] = "gt";
-        char_type['&'] = "amp";
-        char_type['\'']= "apos";
-        char_type['"'] = "quot";
-    }
-#endif
-
-    BOOST_TEST_FOREACH( char, c, value ) {
-        std::map<char,char const*>::const_iterator found_ref = char_type.find( c );
-
-        if( found_ref != char_type.end() )
-            where_to << '&' << found_ref->second << ';';
-        else
-            where_to << c;
-    }
-}
-
-//____________________________________________________________________________//
-
-inline void
-print_escaped( std::ostream& where_to, std::string const& value )
-{
-    print_escaped( where_to, const_string( value ) );
-}
-
-//____________________________________________________________________________//
-
-template<typename T>
-inline void
-print_escaped( std::ostream& where_to, T const& value )
-{
-    where_to << value;
-}
-
-//____________________________________________________________________________//
-
-inline void
-print_escaped_cdata( std::ostream& where_to, const_string value )
-{
-    static const_string cdata_end( "]]>" );
-
-    const_string::size_type pos = value.find( cdata_end );
-    if( pos == const_string::npos )
-        where_to << value;
-    else {
-        where_to << value.substr( 0, pos+2 ) << cdata_end
-                 << BOOST_TEST_L( "<![CDATA[" ) << value.substr( pos+2 );
-    }
-}
-
-//____________________________________________________________________________//
-
-typedef custom_manip<struct attr_value_t> attr_value;
-
-template<typename T>
-inline std::ostream&
-operator<<( custom_printer<attr_value> const& p, T const& value )
-{
-    *p << "=\"";
-    print_escaped( *p, value );
-    *p << '"';
-
-    return *p;
-}
-
-//____________________________________________________________________________//
-
-typedef custom_manip<struct cdata_t> cdata;
-
-inline std::ostream&
-operator<<( custom_printer<cdata> const& p, const_string value )
-{
-    *p << BOOST_TEST_L( "<![CDATA[" );
-    print_escaped_cdata( *p, value );
-    return  *p << BOOST_TEST_L( "]]>" );
-}
-
-//____________________________________________________________________________//
-
-} // namespace utils
-} // namespace unit_test
-} // namespace boost
-
-#include <boost/test/detail/enable_warnings.hpp>
-
-#endif // BOOST_TEST_UTILS_XML_PRINTER_HPP
diff --git a/contrib/libboost/boost_1_62_0/libs/test/src/compiler_log_formatter.cpp b/contrib/libboost/boost_1_62_0/libs/test/src/compiler_log_formatter.cpp
deleted file mode 100644
index e1508c2f1e5..00000000000
--- a/contrib/libboost/boost_1_62_0/libs/test/src/compiler_log_formatter.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2010.
-//  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 : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/compiler_log_formatter.ipp>
-
-// EOF
diff --git a/contrib/libboost/boost_1_62_0/libs/test/src/cpp_main.cpp b/contrib/libboost/boost_1_62_0/libs/test/src/cpp_main.cpp
deleted file mode 100644
index ab92ba5e790..00000000000
--- a/contrib/libboost/boost_1_62_0/libs/test/src/cpp_main.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2010.
-//  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 : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/cpp_main.ipp>
-
-// EOF
-
diff --git a/contrib/libboost/boost_1_62_0/libs/test/src/debug.cpp b/contrib/libboost/boost_1_62_0/libs/test/src/debug.cpp
deleted file mode 100644
index 04c6e0a10d9..00000000000
--- a/contrib/libboost/boost_1_62_0/libs/test/src/debug.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2006-2010.
-//  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 : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/debug.ipp>
-
-// ***************************************************************************
-//  Revision History :
-//  
-//  $Log$
-// ***************************************************************************
-
-// EOF
diff --git a/contrib/libboost/boost_1_62_0/libs/test/src/decorator.cpp b/contrib/libboost/boost_1_62_0/libs/test/src/decorator.cpp
deleted file mode 100644
index 3972407d66d..00000000000
--- a/contrib/libboost/boost_1_62_0/libs/test/src/decorator.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 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/libs/test for the library home page.
-//
-//  File        : $RCSfile$
-//
-//  Version     : $Revision$
-//
-//  Description : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/decorator.ipp>
-
-// EOF
diff --git a/contrib/libboost/boost_1_62_0/libs/test/src/execution_monitor.cpp b/contrib/libboost/boost_1_62_0/libs/test/src/execution_monitor.cpp
deleted file mode 100644
index e7fdfb91397..00000000000
--- a/contrib/libboost/boost_1_62_0/libs/test/src/execution_monitor.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2010.
-//  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 : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/execution_monitor.ipp>
-
-// EOF
diff --git a/contrib/libboost/boost_1_62_0/libs/test/src/framework.cpp b/contrib/libboost/boost_1_62_0/libs/test/src/framework.cpp
deleted file mode 100644
index 52e76148350..00000000000
--- a/contrib/libboost/boost_1_62_0/libs/test/src/framework.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2010.
-//  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 : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/framework.ipp>
-
-// EOF
diff --git a/contrib/libboost/boost_1_62_0/libs/test/src/junit_log_formatter.cpp b/contrib/libboost/boost_1_62_0/libs/test/src/junit_log_formatter.cpp
deleted file mode 100644
index 0cac80465b7..00000000000
--- a/contrib/libboost/boost_1_62_0/libs/test/src/junit_log_formatter.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-//  (C) Copyright 2016 Raffi Enficiaud.
-//  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.
-//
-// forward to impl
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/junit_log_formatter.ipp>
-
-// EOF
diff --git a/contrib/libboost/boost_1_62_0/libs/test/src/plain_report_formatter.cpp b/contrib/libboost/boost_1_62_0/libs/test/src/plain_report_formatter.cpp
deleted file mode 100644
index 95cf64fd63b..00000000000
--- a/contrib/libboost/boost_1_62_0/libs/test/src/plain_report_formatter.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2010.
-//  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 : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/plain_report_formatter.ipp>
-
-// EOF
diff --git a/contrib/libboost/boost_1_62_0/libs/test/src/progress_monitor.cpp b/contrib/libboost/boost_1_62_0/libs/test/src/progress_monitor.cpp
deleted file mode 100644
index 1d4afc7a5af..00000000000
--- a/contrib/libboost/boost_1_62_0/libs/test/src/progress_monitor.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2010.
-//  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 : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/progress_monitor.ipp>
-
-// EOF
diff --git a/contrib/libboost/boost_1_62_0/libs/test/src/results_collector.cpp b/contrib/libboost/boost_1_62_0/libs/test/src/results_collector.cpp
deleted file mode 100644
index 5d8e0b7dd2a..00000000000
--- a/contrib/libboost/boost_1_62_0/libs/test/src/results_collector.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2010.
-//  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 : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/results_collector.ipp>
-
-// EOF
diff --git a/contrib/libboost/boost_1_62_0/libs/test/src/results_reporter.cpp b/contrib/libboost/boost_1_62_0/libs/test/src/results_reporter.cpp
deleted file mode 100644
index 205cba5f837..00000000000
--- a/contrib/libboost/boost_1_62_0/libs/test/src/results_reporter.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2010.
-//  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 : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/results_reporter.ipp>
-
-// EOF
diff --git a/contrib/libboost/boost_1_62_0/libs/test/src/test_main.cpp b/contrib/libboost/boost_1_62_0/libs/test/src/test_main.cpp
deleted file mode 100644
index f7ae352d256..00000000000
--- a/contrib/libboost/boost_1_62_0/libs/test/src/test_main.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2010.
-//  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
-/// @brief forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/test_main.ipp>
-
-// EOF
diff --git a/contrib/libboost/boost_1_62_0/libs/test/src/test_tools.cpp b/contrib/libboost/boost_1_62_0/libs/test/src/test_tools.cpp
deleted file mode 100644
index d9d2960373d..00000000000
--- a/contrib/libboost/boost_1_62_0/libs/test/src/test_tools.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2010.
-//  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 : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/test_tools.ipp>
-
-// EOF
diff --git a/contrib/libboost/boost_1_62_0/libs/test/src/test_tree.cpp b/contrib/libboost/boost_1_62_0/libs/test/src/test_tree.cpp
deleted file mode 100644
index bc273ed965b..00000000000
--- a/contrib/libboost/boost_1_62_0/libs/test/src/test_tree.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2010.
-//  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 : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/test_tree.ipp>
-
-// EOF
diff --git a/contrib/libboost/boost_1_62_0/libs/test/src/unit_test_log.cpp b/contrib/libboost/boost_1_62_0/libs/test/src/unit_test_log.cpp
deleted file mode 100644
index c09437cbd9b..00000000000
--- a/contrib/libboost/boost_1_62_0/libs/test/src/unit_test_log.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2010.
-//  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 : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/unit_test_log.ipp>
-
-// EOF
diff --git a/contrib/libboost/boost_1_62_0/libs/test/src/unit_test_main.cpp b/contrib/libboost/boost_1_62_0/libs/test/src/unit_test_main.cpp
deleted file mode 100644
index 74b0b84c639..00000000000
--- a/contrib/libboost/boost_1_62_0/libs/test/src/unit_test_main.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2010.
-//  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 : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/unit_test_main.ipp>
-
-// EOF
diff --git a/contrib/libboost/boost_1_62_0/libs/test/src/unit_test_monitor.cpp b/contrib/libboost/boost_1_62_0/libs/test/src/unit_test_monitor.cpp
deleted file mode 100644
index ffc646195df..00000000000
--- a/contrib/libboost/boost_1_62_0/libs/test/src/unit_test_monitor.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2010.
-//  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 : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/unit_test_monitor.ipp>
-
-// EOF
diff --git a/contrib/libboost/boost_1_62_0/libs/test/src/unit_test_parameters.cpp b/contrib/libboost/boost_1_62_0/libs/test/src/unit_test_parameters.cpp
deleted file mode 100644
index e82694e34b9..00000000000
--- a/contrib/libboost/boost_1_62_0/libs/test/src/unit_test_parameters.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2010.
-//  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 : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/unit_test_parameters.ipp>
-
-// EOF
diff --git a/contrib/libboost/boost_1_62_0/libs/test/src/xml_log_formatter.cpp b/contrib/libboost/boost_1_62_0/libs/test/src/xml_log_formatter.cpp
deleted file mode 100644
index ca497a9f39f..00000000000
--- a/contrib/libboost/boost_1_62_0/libs/test/src/xml_log_formatter.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2010.
-//  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 : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/xml_log_formatter.ipp>
-
-// EOF
diff --git a/contrib/libboost/boost_1_62_0/libs/test/src/xml_report_formatter.cpp b/contrib/libboost/boost_1_62_0/libs/test/src/xml_report_formatter.cpp
deleted file mode 100644
index 18ff1d86577..00000000000
--- a/contrib/libboost/boost_1_62_0/libs/test/src/xml_report_formatter.cpp
+++ /dev/null
@@ -1,18 +0,0 @@
-//  (C) Copyright Gennadiy Rozental 2005-2010.
-//  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 : forwarding source
-// ***************************************************************************
-
-#define BOOST_TEST_SOURCE
-#include <boost/test/impl/xml_report_formatter.ipp>
-
-// EOF
diff --git a/contrib/libboost/boost_1_62_0/LICENSE_1_0.txt b/contrib/libboost/boost_1_65_0/LICENSE_1_0.txt
similarity index 100%
rename from contrib/libboost/boost_1_62_0/LICENSE_1_0.txt
rename to contrib/libboost/boost_1_65_0/LICENSE_1_0.txt
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/algorithm.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/algorithm.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/algorithm.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/algorithm.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/clamp.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/clamp.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/clamp.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/clamp.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/all_of.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/all_of.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/all_of.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/all_of.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/any_of.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/any_of.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/any_of.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/any_of.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/copy_if.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/copy_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/copy_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/copy_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/copy_n.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/copy_n.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/copy_n.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/copy_n.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/find_if_not.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/find_if_not.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/find_if_not.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/find_if_not.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/iota.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/iota.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/iota.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/iota.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/is_partitioned.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/is_partitioned.hpp
similarity index 84%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/is_partitioned.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/is_partitioned.hpp
index cb6c71e33b7..c0076b932bc 100644
--- a/contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/is_partitioned.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/is_partitioned.hpp
@@ -18,7 +18,8 @@
 namespace boost { namespace algorithm {
 
 /// \fn is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p )
-/// \brief Tests to see if a sequence is partitioned according to a predicate
+/// \brief Tests to see if a sequence is partitioned according to a predicate. 
+///	   In other words, all the items in the sequence that satisfy the predicate are at the beginning of the sequence.
 /// 
 /// \param first    The start of the input sequence
 /// \param last     One past the end of the input sequence
@@ -39,7 +40,8 @@ bool is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p
 }
 
 /// \fn is_partitioned ( const Range &r, UnaryPredicate p )
-/// \brief Generates an increasing sequence of values, and stores them in the input Range.
+/// \brief Tests to see if a sequence is partitioned according to a predicate. 
+///	   In other words, all the items in the sequence that satisfy the predicate are at the beginning of the sequence.
 /// 
 /// \param r        The input range
 /// \param p        The predicate to test the values with
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/is_permutation.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/is_permutation.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/is_permutation.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/is_permutation.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/is_sorted.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/is_sorted.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/is_sorted.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/is_sorted.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/none_of.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/none_of.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/none_of.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/none_of.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/one_of.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/one_of.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/one_of.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/one_of.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/partition_copy.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/partition_copy.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/partition_copy.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/partition_copy.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/partition_point.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/partition_point.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/cxx11/partition_point.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/cxx11/partition_point.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/cxx14/equal.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx14/equal.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/cxx14/equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/cxx14/equal.hpp
index f1539f885ce..9f97be1d626 100644
--- a/contrib/libboost/boost_1_62_0/boost/algorithm/cxx14/equal.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx14/equal.hpp
@@ -13,7 +13,6 @@
 #define BOOST_ALGORITHM_EQUAL_HPP
 
 #include <algorithm>    // for std::equal
-#include <functional>   // for std::binary_function
 #include <iterator>
 
 namespace boost { namespace algorithm {
@@ -21,7 +20,7 @@ namespace boost { namespace algorithm {
 namespace detail {
 
     template <class T1, class T2>
-    struct eq : public std::binary_function<T1, T2, bool> {
+    struct eq {
         bool operator () ( const T1& v1, const T2& v2 ) const { return v1 == v2 ;}
         };
     
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/cxx14/is_permutation.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx14/is_permutation.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/cxx14/is_permutation.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/cxx14/is_permutation.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/cxx14/mismatch.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx14/mismatch.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/cxx14/mismatch.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/cxx14/mismatch.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/exclusive_scan.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/exclusive_scan.hpp
new file mode 100644
index 00000000000..03ecea52ecf
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/exclusive_scan.hpp
@@ -0,0 +1,52 @@
+/*
+   Copyright (c) Marshall Clow 2017.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
+*/
+
+/// \file  exclusive_scan.hpp
+/// \brief ???
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_EXCLUSIVE_SCAN_HPP
+#define BOOST_ALGORITHM_EXCLUSIVE_SCAN_HPP
+
+#include <functional>     // for std::plus
+#include <iterator>       // for std::iterator_traits
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/value_type.hpp>
+
+namespace boost { namespace algorithm {
+
+template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
+OutputIterator exclusive_scan(InputIterator first, InputIterator last,
+                              OutputIterator result, T init, BinaryOperation bOp)
+{
+    if (first != last)
+    {
+        T saved = init;
+        do
+        {
+            init = bOp(init, *first);
+            *result = saved;
+            saved = init;
+            ++result;
+        } while (++first != last);
+    }
+    return result;
+}
+
+template<class InputIterator, class OutputIterator, class T>
+OutputIterator exclusive_scan(InputIterator first, InputIterator last,
+                              OutputIterator result, T init)
+{
+	typedef typename std::iterator_traits<InputIterator>::value_type VT;
+    return exclusive_scan(first, last, result, init, std::plus<VT>());
+}
+
+}} // namespace boost and algorithm
+
+#endif // BOOST_ALGORITHM_EXCLUSIVE_SCAN_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/for_each_n.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/for_each_n.hpp
new file mode 100644
index 00000000000..b8134cc06ac
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/for_each_n.hpp
@@ -0,0 +1,37 @@
+/*
+   Copyright (c) Marshall Clow 2017.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
+*/
+
+/// \file  for_each_n.hpp
+/// \brief Apply a functor to the elements of a sequence
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_FOR_EACH_N_HPP
+#define BOOST_ALGORITHM_FOR_EACH_N_HPP
+
+#include <utility>      // for std::pair
+
+namespace boost { namespace algorithm {
+
+/// \fn for_each_n(InputIterator first, Size n, Function f);
+/// \return first + n
+///
+/// \param first    The start of the first range.
+/// \param n        One past the end of the first range.
+/// \param f        A functor to apply to the elements of the sequence
+/// \note           If f returns a result, the result is ignored.
+template<class InputIterator, class Size, class Function>
+InputIterator for_each_n(InputIterator first, Size n, Function f)
+{
+    for ( ; n > 0; --n, ++first )
+        f(*first);
+
+    return first;
+}
+
+}} // namespace boost and algorithm
+
+#endif // BOOST_ALGORITHM_FOR_EACH_N_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/inclusive_scan.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/inclusive_scan.hpp
new file mode 100644
index 00000000000..cd015f100fb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/inclusive_scan.hpp
@@ -0,0 +1,60 @@
+/*
+   Copyright (c) Marshall Clow 2017.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
+*/
+
+/// \file  transform_reduce.hpp
+/// \brief Combine the (transformed) elements of a sequence (or two) into a single value.
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP
+#define BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP
+
+#include <functional>     // for std::plus
+#include <iterator>       // for std::iterator_traits
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/value_type.hpp>
+
+namespace boost { namespace algorithm {
+
+template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
+OutputIterator inclusive_scan(InputIterator first, InputIterator last,
+                              OutputIterator result, BinaryOperation bOp, T init)
+{
+    for (; first != last; ++first, (void) ++result) {
+        init = bOp(init, *first);
+        *result = init;
+        }
+    return result;
+}
+
+
+template<class InputIterator, class OutputIterator, class BinaryOperation>
+OutputIterator inclusive_scan(InputIterator first, InputIterator last,
+                              OutputIterator result, BinaryOperation bOp)
+{
+    if (first != last) {
+        typename std::iterator_traits<InputIterator>::value_type init = *first;
+        *result++ = init;
+        if (++first != last)
+            return inclusive_scan(first, last, result, bOp, init);
+        }
+
+    return result;
+}
+
+template<class InputIterator, class OutputIterator>
+OutputIterator inclusive_scan(InputIterator first, InputIterator last,
+                   OutputIterator result)
+{
+    typedef typename std::iterator_traits<InputIterator>::value_type VT;
+    return inclusive_scan(first, last, result, std::plus<VT>());
+}
+
+}} // namespace boost and algorithm
+
+#endif // BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/reduce.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/reduce.hpp
new file mode 100644
index 00000000000..f47695b53a6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/reduce.hpp
@@ -0,0 +1,72 @@
+/*
+   Copyright (c) Marshall Clow 2017.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
+*/
+
+/// \file  reduce.hpp
+/// \brief Combine the elements of a sequence into a single value
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_REDUCE_HPP
+#define BOOST_ALGORITHM_REDUCE_HPP
+
+#include <functional>     // for std::plus
+#include <iterator>       // for std::iterator_traits
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/value_type.hpp>
+
+namespace boost { namespace algorithm {
+
+template<class InputIterator, class T, class BinaryOperation>
+T reduce(InputIterator first, InputIterator last, T init, BinaryOperation bOp)
+{
+    ;
+    for (; first != last; ++first)
+        init = bOp(init, *first);
+    return init;
+}
+
+template<class InputIterator, class T>
+T reduce(InputIterator first, InputIterator last, T init)
+{
+	typedef typename std::iterator_traits<InputIterator>::value_type VT;
+    return reduce(first, last, init, std::plus<VT>());
+}
+
+template<class InputIterator>
+typename std::iterator_traits<InputIterator>::value_type
+reduce(InputIterator first, InputIterator last)
+{
+    return reduce(first, last,
+       typename std::iterator_traits<InputIterator>::value_type());
+}
+
+template<class Range>
+typename boost::range_value<Range>::type
+reduce(const Range &r)
+{
+    return reduce(boost::begin(r), boost::end(r));
+}
+
+//	Not sure that this won't be ambiguous (1)
+template<class Range, class T>
+T reduce(const Range &r, T init)
+{
+    return reduce(boost::begin (r), boost::end (r), init);
+}
+
+
+//	Not sure that this won't be ambiguous (2)
+template<class Range, class T, class BinaryOperation>
+T reduce(const Range &r, T init, BinaryOperation bOp)
+{
+    return reduce(boost::begin(r), boost::end(r), init, bOp);
+}
+
+}} // namespace boost and algorithm
+
+#endif // BOOST_ALGORITHM_REDUCE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/transform_exclusive_scan.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/transform_exclusive_scan.hpp
new file mode 100644
index 00000000000..d3b4329a0a1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/transform_exclusive_scan.hpp
@@ -0,0 +1,46 @@
+/*
+   Copyright (c) Marshall Clow 2017.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
+*/
+
+/// \file  transform_exclusive_scan.hpp
+/// \brief ????
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_TRANSFORM_EXCLUSIVE_SCAN_HPP
+#define BOOST_ALGORITHM_TRANSFORM_EXCLUSIVE_SCAN_HPP
+
+#include <functional>     // for std::plus
+#include <iterator>       // for std::iterator_traits
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/value_type.hpp>
+
+namespace boost { namespace algorithm {
+
+template<class InputIterator, class OutputIterator, class T,
+         class BinaryOperation, class UnaryOperation>
+OutputIterator transform_exclusive_scan(InputIterator first, InputIterator last,
+                                        OutputIterator result, T init,
+                                        BinaryOperation bOp, UnaryOperation uOp)
+{
+    if (first != last)
+    {
+        T saved = init;
+        do
+        {
+            init = bOp(init, uOp(*first));
+            *result = saved;
+            saved = init;
+            ++result;
+        } while (++first != last);
+    }
+    return result;
+}
+
+}} // namespace boost and algorithm
+
+#endif // BOOST_ALGORITHM_TRANSFORM_EXCLUSIVE_SCAN_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/transform_inclusive_scan.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/transform_inclusive_scan.hpp
new file mode 100644
index 00000000000..476c117f927
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/transform_inclusive_scan.hpp
@@ -0,0 +1,58 @@
+/*
+   Copyright (c) Marshall Clow 2017.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
+*/
+
+/// \file  transform_reduce.hpp
+/// \brief Combine the (transformed) elements of a sequence (or two) into a single value.
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP
+#define BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP
+
+#include <functional>     // for std::plus
+#include <iterator>       // for std::iterator_traits
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/value_type.hpp>
+
+namespace boost { namespace algorithm {
+
+template<class InputIterator, class OutputIterator,
+         class BinaryOperation, class UnaryOperation, class T>
+OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
+                                        OutputIterator result,
+                                        BinaryOperation bOp, UnaryOperation uOp,
+                                        T init)
+{
+    for (; first != last; ++first, (void) ++result) {
+        init = bOp(init, uOp(*first));
+        *result = init;
+        }
+
+    return result;
+}
+
+template<class InputIterator, class OutputIterator,
+         class BinaryOperation, class UnaryOperation>
+OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
+                                        OutputIterator result,
+                                        BinaryOperation bOp, UnaryOperation uOp)
+{
+    if (first != last) {
+        typename std::iterator_traits<InputIterator>::value_type init = uOp(*first);
+        *result++ = init;
+        if (++first != last)
+            return transform_inclusive_scan(first, last, result, bOp, uOp, init);
+        }
+
+    return result;
+}
+
+
+}} // namespace boost and algorithm
+
+#endif // BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/transform_reduce.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/transform_reduce.hpp
new file mode 100644
index 00000000000..7ebde7d3255
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/algorithm/cxx17/transform_reduce.hpp
@@ -0,0 +1,55 @@
+/*
+   Copyright (c) Marshall Clow 2017.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE10.txt or copy at http://www.boost.org/LICENSE10.txt)
+*/
+
+/// \file  transform_reduce.hpp
+/// \brief Combine the (transformed) elements of a sequence (or two) into a single value.
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP
+#define BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP
+
+#include <functional>     // for std::plus
+#include <iterator>       // for std::iterator_traits
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/value_type.hpp>
+
+namespace boost { namespace algorithm {
+
+template<class InputIterator1, class InputIterator2, class T,
+         class BinaryOperation1, class BinaryOperation2>
+T transform_reduce(InputIterator1 first1, InputIterator1 last1,
+                   InputIterator2 first2, T init,
+                 BinaryOperation1 bOp1, BinaryOperation2 bOp2)
+{
+    for (; first1 != last1; ++first1, (void) ++first2)
+        init = bOp1(init, bOp2(*first1, *first2));
+    return init;
+}
+
+template<class InputIterator, class T,
+         class BinaryOperation, class UnaryOperation>
+T transform_reduce(InputIterator first, InputIterator last,
+                   T init, BinaryOperation bOp, UnaryOperation uOp)
+{
+    for (; first != last; ++first)
+        init = bOp(init, uOp(*first));
+    return init;
+}
+
+template<class InputIterator1, class InputIterator2, class T>
+T transform_reduce(InputIterator1 first1, InputIterator1 last1,
+                   InputIterator2 first2, T init)
+{
+    return transform_reduce(first1, last1, first2, init,
+                            std::plus<T>(), std::multiplies<T>());
+}
+
+}} // namespace boost and algorithm
+
+#endif // BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/gather.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/gather.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/gather.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/gather.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/hex.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/hex.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/hex.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/hex.hpp
index 739e89f2f01..b8335843a88 100644
--- a/contrib/libboost/boost_1_62_0/boost/algorithm/hex.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/algorithm/hex.hpp
@@ -73,7 +73,7 @@ namespace detail {
         else if ( c >= 'A' && c <= 'F' ) retval = c - 'A' + 10;
         else if ( c >= 'a' && c <= 'f' ) retval = c - 'a' + 10;
         else BOOST_THROW_EXCEPTION (non_hex_input() << bad_char (c));
-        return retval;
+        return static_cast<char>(retval);
         }
 
 //  My own iterator_traits class.
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/is_palindrome.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/is_palindrome.hpp
similarity index 91%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/is_palindrome.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/is_palindrome.hpp
index cc63e180755..09881109a37 100644
--- a/contrib/libboost/boost_1_62_0/boost/algorithm/is_palindrome.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/algorithm/is_palindrome.hpp
@@ -35,7 +35,7 @@ namespace boost {  namespace algorithm {
 ///     For other sequences function will return false.
 ///     Complexity: O(N).
 template <typename BidirectionalIterator, typename Predicate>
-bool is_palindrome(BidirectionalIterator begin, BidirectionalIterator end, Predicate p )
+bool is_palindrome(BidirectionalIterator begin, BidirectionalIterator end, Predicate p)
 {
     if(begin == end)
     {
@@ -63,7 +63,7 @@ bool is_palindrome(BidirectionalIterator begin, BidirectionalIterator end, Predi
 /// \return true if the entire sequence is palindrome
 ///
 /// \param begin    The start of the input sequence
-/// \param end		One past the end of the input sequence
+/// \param end	    One past the end of the input sequence
 ///
 /// \note This function will return true for empty sequences and for palindromes.
 ///     For other sequences function will return false.
@@ -71,26 +71,8 @@ bool is_palindrome(BidirectionalIterator begin, BidirectionalIterator end, Predi
 template <typename BidirectionalIterator>
 bool is_palindrome(BidirectionalIterator begin, BidirectionalIterator end)
 {
-    if(begin == end)
-    {
-        return true;
-    }
-
-    --end;
-    while(begin != end)
-    {
-        if(!(*begin == *end))
-        {
-            return false;
-        }
-        ++begin;
-        if(begin == end)
-        {
-            break;
-        }
-        --end;
-    }
-    return true;
+    return is_palindrome(begin, end,
+                         std::equal_to<typename std::iterator_traits<BidirectionalIterator>::value_type> ());
 }
 
 /// \fn is_palindrome ( const R& range )
@@ -122,7 +104,6 @@ bool is_palindrome(const R& range, Predicate p)
     return is_palindrome(boost::begin(range), boost::end(range), p);
 }
 
-
 /// \fn is_palindrome ( const char* str )
 /// \return true if the entire sequence is palindrome
 ///
@@ -138,7 +119,6 @@ bool is_palindrome(const char* str)
     return is_palindrome(str, str + strlen(str));
 }
 
-
 /// \fn is_palindrome ( const char* str, Predicate p )
 /// \return true if the entire sequence is palindrome
 ///
@@ -155,7 +135,6 @@ bool is_palindrome(const char* str, Predicate p)
 	    return true;
     return is_palindrome(str, str + strlen(str), p);
 }
-
 }}
 
 #endif // BOOST_ALGORITHM_IS_PALINDROME_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/algorithm/is_partitioned_until.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/is_partitioned_until.hpp
new file mode 100644
index 00000000000..42683e1d8e5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/algorithm/is_partitioned_until.hpp
@@ -0,0 +1,63 @@
+/*
+   Copyright (c) Alexander Zaitsev <zamazan4ik@gmail.by>, 2017.
+
+   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)
+*/
+
+/// \file  is_partitioned_until.hpp
+/// \brief Tell if a sequence is partitioned
+/// \author Alexander Zaitsev
+
+#ifndef BOOST_ALGORITHM_IS_PARTITIONED_UNTIL_HPP
+#define BOOST_ALGORITHM_IS_PARTITIONED_UNTIL_HPP
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+
+namespace boost { namespace algorithm {
+
+/// \fn is_partitioned_until ( InputIterator first, InputIterator last, UnaryPredicate p )
+/// \brief Tests to see if a sequence is partitioned according to a predicate. 
+///	   In other words, all the items in the sequence that satisfy the predicate are at the beginning of the sequence.
+///
+/// \param first    The start of the input sequence
+/// \param last     One past the end of the input sequence
+/// \param p        The predicate to test the values with
+///
+/// \note Returns the first iterator 'it' in the sequence [first, last) for which is_partitioned(first, it, p) is false.
+///     Returns last if the entire sequence is partitioned.
+///     Complexity: O(N).
+template <typename InputIterator, typename UnaryPredicate>
+InputIterator is_partitioned_until ( InputIterator first, InputIterator last, UnaryPredicate p )
+{
+//  Run through the part that satisfy the predicate
+    for ( ; first != last; ++first )
+        if ( !p (*first))
+            break;
+//  Now the part that does not satisfy the predicate
+    for ( ; first != last; ++first )
+        if ( p (*first))
+            return first;
+    return last;
+}
+
+/// \fn is_partitioned_until ( const Range &r, UnaryPredicate p )
+/// \brief Tests to see if a sequence is partitioned according to a predicate. 
+///	   In other words, all the items in the sequence that satisfy the predicate are at the beginning of the sequence.
+///
+/// \param r        The input range
+/// \param p        The predicate to test the values with
+///
+/// \note Returns the first iterator 'it' in the sequence [first, last) for which is_partitioned(first, it, p) is false.
+///     Returns last if the entire sequence is partitioned.
+///     Complexity: O(N).
+template <typename Range, typename UnaryPredicate>
+typename boost::range_iterator<const Range>::type is_partitioned_until ( const Range &r, UnaryPredicate p )
+{
+    return boost::algorithm::is_partitioned_until (boost::begin(r), boost::end(r), p);
+}
+
+}}
+
+#endif  // BOOST_ALGORITHM_IS_PARTITIONED_UNTIL_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/minmax.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/minmax.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/minmax.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/minmax.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/minmax_element.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/minmax_element.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/minmax_element.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/minmax_element.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/searching/boyer_moore.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/searching/boyer_moore.hpp
similarity index 95%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/searching/boyer_moore.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/searching/boyer_moore.hpp
index 65a809dd4f4..192d4dec25b 100644
--- a/contrib/libboost/boost_1_62_0/boost/algorithm/searching/boyer_moore.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/algorithm/searching/boyer_moore.hpp
@@ -152,8 +152,8 @@ Requirements:
         
 
         template<typename Iter, typename Container>
-        void compute_bm_prefix ( Iter pat_first, Iter pat_last, Container &prefix ) {
-            const std::size_t count = std::distance ( pat_first, pat_last );
+        void compute_bm_prefix ( Iter first, Iter last, Container &prefix ) {
+            const std::size_t count = std::distance ( first, last );
             BOOST_ASSERT ( count > 0 );
             BOOST_ASSERT ( prefix.size () == count );
                             
@@ -161,26 +161,26 @@ Requirements:
             std::size_t k = 0;
             for ( std::size_t i = 1; i < count; ++i ) {
                 BOOST_ASSERT ( k < count );
-                while ( k > 0 && ( pat_first[k] != pat_first[i] )) {
+                while ( k > 0 && ( first[k] != first[i] )) {
                     BOOST_ASSERT ( k < count );
                     k = prefix [ k - 1 ];
                     }
                     
-                if ( pat_first[k] == pat_first[i] )
+                if ( first[k] == first[i] )
                     k++;
                 prefix [ i ] = k;
                 }
             }
 
-        void build_suffix_table ( patIter pat_first, patIter pat_last ) {
-            const std::size_t count = (std::size_t) std::distance ( pat_first, pat_last );
+        void build_suffix_table ( patIter first, patIter last ) {
+            const std::size_t count = (std::size_t) std::distance ( first, last );
             
             if ( count > 0 ) {  // empty pattern
                 std::vector<typename std::iterator_traits<patIter>::value_type> reversed(count);
-                (void) std::reverse_copy ( pat_first, pat_last, reversed.begin ());
+                (void) std::reverse_copy ( first, last, reversed.begin ());
                 
                 std::vector<difference_type> prefix (count);
-                compute_bm_prefix ( pat_first, pat_last, prefix );
+                compute_bm_prefix ( first, last, prefix );
         
                 std::vector<difference_type> prefix_reversed (count);
                 compute_bm_prefix ( reversed.begin (), reversed.end (), prefix_reversed );
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/searching/boyer_moore_horspool.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/searching/boyer_moore_horspool.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/searching/boyer_moore_horspool.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/searching/boyer_moore_horspool.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/searching/detail/bm_traits.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/searching/detail/bm_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/searching/detail/bm_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/searching/detail/bm_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/searching/detail/debugging.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/searching/detail/debugging.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/searching/detail/debugging.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/searching/detail/debugging.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/searching/knuth_morris_pratt.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/searching/knuth_morris_pratt.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/searching/knuth_morris_pratt.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/searching/knuth_morris_pratt.hpp
index c890c9cac09..5b5b64a729a 100644
--- a/contrib/libboost/boost_1_62_0/boost/algorithm/searching/knuth_morris_pratt.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/algorithm/searching/knuth_morris_pratt.hpp
@@ -155,9 +155,9 @@ namespace boost { namespace algorithm {
     
 
         void preKmp ( patIter first, patIter last ) {
-           const /*std::size_t*/ int count = std::distance ( first, last );
+           const difference_type count = std::distance ( first, last );
         
-           int i, j;
+           difference_type i, j;
         
            i = 0;
            j = skip_[0] = -1;
@@ -177,7 +177,7 @@ namespace boost { namespace algorithm {
         void init_skip_table ( patIter first, patIter last ) {
             const difference_type count = std::distance ( first, last );
     
-            int j;
+            difference_type j;
             skip_ [ 0 ] = -1;
             for ( int i = 1; i <= count; ++i ) {
                 j = skip_ [ i - 1 ];
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/sort_subrange.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/sort_subrange.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/sort_subrange.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/sort_subrange.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/case_conv.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/case_conv.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/case_conv.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/case_conv.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/classification.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/classification.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/classification.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/classification.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/compare.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/compare.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/compare.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/compare.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/concept.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/concept.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/concept.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/concept.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/config.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/config.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/config.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/config.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/constants.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/constants.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/constants.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/constants.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/case_conv.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/case_conv.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/case_conv.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/case_conv.hpp
index 42621c74f06..233912ca0f2 100644
--- a/contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/case_conv.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/case_conv.hpp
@@ -30,8 +30,10 @@ namespace boost {
 
             // a tolower functor
             template<typename CharT>
-            struct to_lowerF : public std::unary_function<CharT, CharT>
+            struct to_lowerF
             {
+                typedef CharT argument_type;
+                typedef CharT result_type;
                 // Constructor
                 to_lowerF( const std::locale& Loc ) : m_Loc( &Loc ) {}
 
@@ -50,8 +52,10 @@ namespace boost {
 
             // a toupper functor
             template<typename CharT>
-            struct to_upperF : public std::unary_function<CharT, CharT>
+            struct to_upperF
             {
+                typedef CharT argument_type;
+                typedef CharT result_type;
                 // Constructor
                 to_upperF( const std::locale& Loc ) : m_Loc( &Loc ) {}
 
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/classification.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/classification.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/classification.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/classification.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/find_format.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/find_format.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/find_format.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/find_format.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/find_format_all.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/find_format_all.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/find_format_all.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/find_format_all.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/find_format_store.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/find_format_store.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/find_format_store.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/find_format_store.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/find_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/find_iterator.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/find_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/find_iterator.hpp
index 9b78a0f7e11..4f90a98fc02 100644
--- a/contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/find_iterator.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/find_iterator.hpp
@@ -40,7 +40,7 @@ namespace boost {
             // Protected construction/destruction
 
                 // Default constructor
-                find_iterator_base() {};
+                find_iterator_base() {}
                 // Copy construction
                 find_iterator_base( const find_iterator_base& Other ) :
                     m_Finder(Other.m_Finder) {}
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/finder.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/finder.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/finder.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/finder.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/finder_regex.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/finder_regex.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/finder_regex.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/finder_regex.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/formatter.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/formatter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/formatter.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/formatter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/formatter_regex.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/formatter_regex.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/formatter_regex.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/formatter_regex.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/predicate.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/predicate.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/predicate.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/predicate.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/replace_storage.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/replace_storage.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/replace_storage.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/replace_storage.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/sequence.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/sequence.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/sequence.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/sequence.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/trim.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/trim.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/trim.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/trim.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/util.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/util.hpp
similarity index 95%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/util.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/util.hpp
index cf4a8b1c8cd..7844b6723cc 100644
--- a/contrib/libboost/boost_1_62_0/boost/algorithm/string/detail/util.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/algorithm/string/detail/util.hpp
@@ -89,9 +89,10 @@ namespace boost {
             template< 
                 typename SeqT, 
                 typename IteratorT=BOOST_STRING_TYPENAME SeqT::const_iterator >
-            struct copy_iterator_rangeF : 
-                public std::unary_function< iterator_range<IteratorT>, SeqT >
+            struct copy_iterator_rangeF
             {
+                typedef iterator_range<IteratorT> argument_type;
+                typedef SeqT result_type;
                 SeqT operator()( const iterator_range<IteratorT>& Range ) const
                 {
                     return copy_range<SeqT>(Range);
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/erase.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/erase.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/erase.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/erase.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/find.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/find.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/find.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/find.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/find_format.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/find_format.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/find_format.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/find_format.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/find_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/find_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/find_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/find_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/finder.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/finder.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/finder.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/finder.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/formatter.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/formatter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/formatter.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/formatter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/iter_find.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/iter_find.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/iter_find.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/iter_find.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/join.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/join.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/join.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/join.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/predicate.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/predicate.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/predicate.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/predicate.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/predicate_facade.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/predicate_facade.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/predicate_facade.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/predicate_facade.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/regex.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/regex.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/regex.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/regex.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/regex_find_format.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/regex_find_format.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/regex_find_format.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/regex_find_format.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/replace.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/replace.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/replace.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/replace.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/sequence_traits.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/sequence_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/sequence_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/sequence_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/split.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/split.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/split.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/split.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/std/list_traits.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/std/list_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/std/list_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/std/list_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/std/rope_traits.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/std/rope_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/std/rope_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/std/rope_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/std/slist_traits.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/std/slist_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/std/slist_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/std/slist_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/std/string_traits.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/std/string_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/std/string_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/std/string_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/std_containers_traits.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/std_containers_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/std_containers_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/std_containers_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/trim.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/trim.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/trim.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/trim.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/trim_all.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/trim_all.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/trim_all.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/trim_all.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string/yes_no_type.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string/yes_no_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string/yes_no_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string/yes_no_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/algorithm/string_regex.hpp b/contrib/libboost/boost_1_65_0/boost/algorithm/string_regex.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/algorithm/string_regex.hpp
rename to contrib/libboost/boost_1_65_0/boost/algorithm/string_regex.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/align/align.hpp b/contrib/libboost/boost_1_65_0/boost/align/align.hpp
similarity index 60%
rename from contrib/libboost/boost_1_62_0/boost/align/align.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/align.hpp
index 3582dcc051b..ee4371091cb 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/align.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/align.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_ALIGN_HPP
 #define BOOST_ALIGN_ALIGN_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/align/align_down.hpp b/contrib/libboost/boost_1_65_0/boost/align/align_down.hpp
new file mode 100644
index 00000000000..355844f8aa2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/align/align_down.hpp
@@ -0,0 +1,25 @@
+/*
+Copyright 2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_ALIGN_DOWN_HPP
+#define BOOST_ALIGN_ALIGN_DOWN_HPP
+
+#include <boost/align/detail/align_down.hpp>
+
+namespace boost {
+namespace alignment {
+
+BOOST_CONSTEXPR inline std::size_t
+align_down(std::size_t value, std::size_t alignment) BOOST_NOEXCEPT
+{
+    return value & ~(alignment - 1);
+}
+
+} /* alignment */
+} /* boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/align/align_up.hpp b/contrib/libboost/boost_1_65_0/boost/align/align_up.hpp
new file mode 100644
index 00000000000..6401ea848a6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/align/align_up.hpp
@@ -0,0 +1,25 @@
+/*
+Copyright 2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_ALIGN_UP_HPP
+#define BOOST_ALIGN_ALIGN_UP_HPP
+
+#include <boost/align/detail/align_up.hpp>
+
+namespace boost {
+namespace alignment {
+
+BOOST_CONSTEXPR inline std::size_t
+align_up(std::size_t value, std::size_t alignment) BOOST_NOEXCEPT
+{
+    return (value + alignment - 1) & ~(alignment - 1);
+}
+
+} /* alignment */
+} /* boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/aligned_alloc.hpp b/contrib/libboost/boost_1_65_0/boost/align/aligned_alloc.hpp
similarity index 88%
rename from contrib/libboost/boost_1_62_0/boost/align/aligned_alloc.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/aligned_alloc.hpp
index 7f2c0bb363a..42128f1b24a 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/aligned_alloc.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/aligned_alloc.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_ALIGNED_ALLOC_HPP
 #define BOOST_ALIGN_ALIGNED_ALLOC_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/align/aligned_allocator.hpp b/contrib/libboost/boost_1_65_0/boost/align/aligned_allocator.hpp
similarity index 77%
rename from contrib/libboost/boost_1_62_0/boost/align/aligned_allocator.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/aligned_allocator.hpp
index b70ed54230f..6176bc27c0e 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/aligned_allocator.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/aligned_allocator.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_ALIGNED_ALLOCATOR_HPP
 #define BOOST_ALIGN_ALIGNED_ALLOCATOR_HPP
@@ -29,8 +28,7 @@ namespace alignment {
 
 template<class T, std::size_t Alignment>
 class aligned_allocator {
-    BOOST_STATIC_ASSERT(detail::
-        is_alignment_constant<Alignment>::value);
+    BOOST_STATIC_ASSERT(detail::is_alignment_constant<Alignment>::value);
 
 public:
     typedef T value_type;
@@ -74,12 +72,12 @@ public:
     }
 
     pointer allocate(size_type size, const_void_pointer = 0) {
-        void* p = 0;
-        if (size > 0) {
-            p = aligned_alloc(min_align, sizeof(T) * size);
-            if (!p) {
-                boost::throw_exception(std::bad_alloc());
-            }
+        if (size == 0) {
+            return 0;
+        }
+        void* p = aligned_alloc(min_align, sizeof(T) * size);
+        if (!p) {
+            boost::throw_exception(std::bad_alloc());
         }
         return static_cast<T*>(p);
     }
@@ -125,8 +123,7 @@ public:
 
 template<std::size_t Alignment>
 class aligned_allocator<void, Alignment> {
-    BOOST_STATIC_ASSERT(detail::
-        is_alignment_constant<Alignment>::value);
+    BOOST_STATIC_ASSERT(detail::is_alignment_constant<Alignment>::value);
 
 public:
     typedef void value_type;
@@ -139,21 +136,23 @@ public:
     };
 };
 
-template<class T1, class T2, std::size_t Alignment>
-inline bool operator==(const aligned_allocator<T1, Alignment>&,
-    const aligned_allocator<T2, Alignment>&) BOOST_NOEXCEPT
+template<class T, class U, std::size_t Alignment>
+inline bool
+operator==(const aligned_allocator<T, Alignment>&,
+    const aligned_allocator<U, Alignment>&) BOOST_NOEXCEPT
 {
     return true;
 }
 
-template<class T1, class T2, std::size_t Alignment>
-inline bool operator!=(const aligned_allocator<T1, Alignment>&,
-    const aligned_allocator<T2, Alignment>&) BOOST_NOEXCEPT
+template<class T, class U, std::size_t Alignment>
+inline bool
+operator!=(const aligned_allocator<T, Alignment>&,
+    const aligned_allocator<U, Alignment>&) BOOST_NOEXCEPT
 {
     return false;
 }
 
-} /* .alignment */
-} /* .boost */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/aligned_allocator_adaptor.hpp b/contrib/libboost/boost_1_65_0/boost/align/aligned_allocator_adaptor.hpp
similarity index 65%
rename from contrib/libboost/boost_1_62_0/boost/align/aligned_allocator_adaptor.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/aligned_allocator_adaptor.hpp
index b6ddd9c369e..c9fae1cf202 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/aligned_allocator_adaptor.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/aligned_allocator_adaptor.hpp
@@ -1,21 +1,20 @@
 /*
-(c) 2014-2016 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014-2016 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_ALIGNED_ALLOCATOR_ADAPTOR_HPP
 #define BOOST_ALIGN_ALIGNED_ALLOCATOR_ADAPTOR_HPP
 
-#include <boost/align/detail/addressof.hpp>
 #include <boost/align/detail/is_alignment_constant.hpp>
 #include <boost/align/detail/max_align.hpp>
 #include <boost/align/detail/max_size.hpp>
 #include <boost/align/align.hpp>
 #include <boost/align/aligned_allocator_adaptor_forward.hpp>
 #include <boost/align/alignment_of.hpp>
+#include <boost/core/pointer_traits.hpp>
 #include <boost/static_assert.hpp>
 #include <new>
 
@@ -33,39 +32,25 @@ namespace alignment {
 template<class Allocator, std::size_t Alignment>
 class aligned_allocator_adaptor
     : public Allocator {
-    BOOST_STATIC_ASSERT(detail::
-        is_alignment_constant<Alignment>::value);
+    BOOST_STATIC_ASSERT(detail::is_alignment_constant<Alignment>::value);
 
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
     typedef std::allocator_traits<Allocator> traits;
-
-    typedef typename traits::
-        template rebind_alloc<char> char_alloc;
-
-    typedef typename traits::
-        template rebind_traits<char> char_traits;
-
+    typedef typename traits::template rebind_alloc<char> char_alloc;
+    typedef typename traits::template rebind_traits<char> char_traits;
     typedef typename char_traits::pointer char_ptr;
 #else
-    typedef typename Allocator::
-        template rebind<char>::other char_alloc;
-
+    typedef typename Allocator::template rebind<char>::other char_alloc;
     typedef typename char_alloc::pointer char_ptr;
 #endif
 
 public:
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    typedef typename traits::value_type value_type;
-    typedef typename traits::size_type size_type;
-#else
     typedef typename Allocator::value_type value_type;
-    typedef typename Allocator::size_type size_type;
-#endif
-
     typedef value_type* pointer;
     typedef const value_type* const_pointer;
     typedef void* void_pointer;
     typedef const void* const_void_pointer;
+    typedef std::size_t size_type;
     typedef std::ptrdiff_t difference_type;
 
 private:
@@ -78,11 +63,11 @@ public:
     template<class U>
     struct rebind {
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
-        typedef aligned_allocator_adaptor<typename traits::
-            template rebind_alloc<U>, Alignment> other;
+        typedef aligned_allocator_adaptor<typename traits::template
+            rebind_alloc<U>, Alignment> other;
 #else
-        typedef aligned_allocator_adaptor<typename Allocator::
-            template rebind<U>::other, Alignment> other;
+        typedef aligned_allocator_adaptor<typename Allocator::template
+            rebind<U>::other, Alignment> other;
 #endif
     };
 
@@ -121,9 +106,9 @@ public:
         std::size_t n = s + min_align - 1;
         char_alloc a(base());
         char_ptr p = a.allocate(sizeof p + n);
-        void* r = detail::addressof(*p) + sizeof p;
+        void* r = boost::pointer_traits<char_ptr>::to_address(p) + sizeof p;
         (void)align(min_align, s, r, n);
-        ::new((void*)(static_cast<char_ptr*>(r) - 1)) char_ptr(p);
+        ::new(static_cast<void*>(static_cast<char_ptr*>(r) - 1)) char_ptr(p);
         return static_cast<pointer>(r);
     }
 
@@ -140,39 +125,38 @@ public:
 #else
         char_ptr p = a.allocate(sizeof p + n, h);
 #endif
-        void* r = detail::addressof(*p) + sizeof p;
+        void* r = boost::pointer_traits<char_ptr>::to_address(p) + sizeof p;
         (void)align(min_align, s, r, n);
-        ::new((void*)(static_cast<char_ptr*>(r) - 1)) char_ptr(p);
+        ::new(static_cast<void*>(static_cast<char_ptr*>(r) - 1)) char_ptr(p);
         return static_cast<pointer>(r);
     }
 
     void deallocate(pointer ptr, size_type size) {
-        char_ptr* p = (char_ptr*)ptr - 1;
+        char_ptr* p = reinterpret_cast<char_ptr*>(ptr) - 1;
         char_ptr r = *p;
         p->~char_ptr();
         char_alloc a(base());
-        a.deallocate(r, sizeof r + size * sizeof(value_type) +
-            min_align - 1);
+        a.deallocate(r, sizeof r + size * sizeof(value_type) + min_align - 1);
     }
 };
 
-template<class A1, class A2, std::size_t Alignment>
-inline bool operator==(const aligned_allocator_adaptor<A1,
-    Alignment>& a, const aligned_allocator_adaptor<A2,
-    Alignment>& b) BOOST_NOEXCEPT
+template<class A, class B, std::size_t Alignment>
+inline bool
+operator==(const aligned_allocator_adaptor<A, Alignment>& a,
+    const aligned_allocator_adaptor<B, Alignment>& b) BOOST_NOEXCEPT
 {
     return a.base() == b.base();
 }
 
-template<class A1, class A2, std::size_t Alignment>
-inline bool operator!=(const aligned_allocator_adaptor<A1,
-    Alignment>& a, const aligned_allocator_adaptor<A2,
-    Alignment>& b) BOOST_NOEXCEPT
+template<class A, class B, std::size_t Alignment>
+inline bool
+operator!=(const aligned_allocator_adaptor<A, Alignment>& a,
+    const aligned_allocator_adaptor<B, Alignment>& b) BOOST_NOEXCEPT
 {
     return !(a == b);
 }
 
-} /* .alignment */
-} /* .boost */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/aligned_allocator_adaptor_forward.hpp b/contrib/libboost/boost_1_65_0/boost/align/aligned_allocator_adaptor_forward.hpp
similarity index 59%
rename from contrib/libboost/boost_1_62_0/boost/align/aligned_allocator_adaptor_forward.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/aligned_allocator_adaptor_forward.hpp
index d606f099208..f762cd1c3ab 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/aligned_allocator_adaptor_forward.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/aligned_allocator_adaptor_forward.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_ALIGNED_ALLOCATOR_ADAPTOR_FORWARD_HPP
 #define BOOST_ALIGN_ALIGNED_ALLOCATOR_ADAPTOR_FORWARD_HPP
@@ -17,7 +16,7 @@ namespace alignment {
 template<class Allocator, std::size_t Alignment = 1>
 class aligned_allocator_adaptor;
 
-} /* .alignment */
-} /* .boost */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/aligned_allocator_forward.hpp b/contrib/libboost/boost_1_65_0/boost/align/aligned_allocator_forward.hpp
similarity index 56%
rename from contrib/libboost/boost_1_62_0/boost/align/aligned_allocator_forward.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/aligned_allocator_forward.hpp
index 41f917f38c1..23add71aaac 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/aligned_allocator_forward.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/aligned_allocator_forward.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_ALIGNED_ALLOCATOR_FORWARD_HPP
 #define BOOST_ALIGN_ALIGNED_ALLOCATOR_FORWARD_HPP
@@ -17,7 +16,7 @@ namespace alignment {
 template<class T, std::size_t Alignment = 1>
 class aligned_allocator;
 
-} /* .alignment */
-} /* .boost */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/aligned_delete.hpp b/contrib/libboost/boost_1_65_0/boost/align/aligned_delete.hpp
similarity index 71%
rename from contrib/libboost/boost_1_62_0/boost/align/aligned_delete.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/aligned_delete.hpp
index 97b1c4b6ad6..385bd557af9 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/aligned_delete.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/aligned_delete.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_ALIGNED_DELETE_HPP
 #define BOOST_ALIGN_ALIGNED_DELETE_HPP
@@ -26,7 +25,7 @@ struct aligned_delete {
     }
 };
 
-} /* .alignment */
-} /* .boost */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_65_0/boost/align/aligned_delete_forward.hpp b/contrib/libboost/boost_1_65_0/boost/align/aligned_delete_forward.hpp
new file mode 100644
index 00000000000..d5b766d7f0a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/align/aligned_delete_forward.hpp
@@ -0,0 +1,19 @@
+/*
+Copyright 2014-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_ALIGNED_DELETE_FORWARD_HPP
+#define BOOST_ALIGN_ALIGNED_DELETE_FORWARD_HPP
+
+namespace boost {
+namespace alignment {
+
+struct aligned_delete;
+
+} /* alignment */
+} /* boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/alignment_of.hpp b/contrib/libboost/boost_1_65_0/boost/align/alignment_of.hpp
similarity index 82%
rename from contrib/libboost/boost_1_62_0/boost/align/alignment_of.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/alignment_of.hpp
index 3dd2eb5b418..488df0b9e0e 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/alignment_of.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/alignment_of.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014-2016 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014-2016 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_ALIGNMENT_OF_HPP
 #define BOOST_ALIGN_ALIGNMENT_OF_HPP
@@ -39,14 +38,15 @@ namespace alignment {
 
 template<class T>
 struct alignment_of
-    : detail::alignment_of<typename detail::element_type<T>::type> { };
+    : detail::alignment_of<typename
+        detail::element_type<T>::type>::type { };
 
 #if !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)
 template<class T>
 constexpr std::size_t alignment_of_v = alignment_of<T>::value;
 #endif
 
-} /* .alignment */
-} /* .boost */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_65_0/boost/align/alignment_of_forward.hpp b/contrib/libboost/boost_1_65_0/boost/align/alignment_of_forward.hpp
new file mode 100644
index 00000000000..31db15f23c6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/align/alignment_of_forward.hpp
@@ -0,0 +1,20 @@
+/*
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_ALIGNMENT_OF_FORWARD_HPP
+#define BOOST_ALIGN_ALIGNMENT_OF_FORWARD_HPP
+
+namespace boost {
+namespace alignment {
+
+template<class T>
+struct alignment_of;
+
+} /* alignment */
+} /* boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/assume_aligned.hpp b/contrib/libboost/boost_1_65_0/boost/align/assume_aligned.hpp
similarity index 69%
rename from contrib/libboost/boost_1_62_0/boost/align/assume_aligned.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/assume_aligned.hpp
index 8d9f6ccf434..22e5103654e 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/assume_aligned.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/assume_aligned.hpp
@@ -1,13 +1,12 @@
 /*
-(c) 2015 NumScale SAS
-(c) 2015 LRI UMR 8623 CNRS/University Paris Sud XI
+Copyright 2015 NumScale SAS
+Copyright 2015 LRI UMR 8623 CNRS/University Paris Sud XI
 
-(c) 2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_ASSUME_ALIGNED_HPP
 #define BOOST_ALIGN_ASSUME_ALIGNED_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/addressof.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/addressof.hpp
similarity index 65%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/addressof.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/addressof.hpp
index 50731a70d02..a314830bed7 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/addressof.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/addressof.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_ADDRESSOF_HPP
 #define BOOST_ALIGN_DETAIL_ADDRESSOF_HPP
@@ -27,8 +26,8 @@ using std::addressof;
 using boost::addressof;
 #endif
 
-} /* .detail */
-} /* .alignment */
-} /* .boost */
+} /* detail */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/align.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/align.hpp
similarity index 53%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/align.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/align.hpp
index 77055e03289..905940ad77a 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/align.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/align.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014-2016 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014-2016 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_ALIGN_HPP
 #define BOOST_ALIGN_DETAIL_ALIGN_HPP
@@ -15,13 +14,14 @@ http://boost.org/LICENSE_1_0.txt
 namespace boost {
 namespace alignment {
 
-inline void* align(std::size_t alignment, std::size_t size,
-    void*& ptr, std::size_t& space)
+inline void*
+align(std::size_t alignment, std::size_t size, void*& ptr,
+    std::size_t& space)
 {
     BOOST_ASSERT(detail::is_alignment(alignment));
     if (size <= space) {
-        char* p = (char*)(((std::size_t)ptr + alignment - 1) &
-            ~(alignment - 1));
+        char* p = reinterpret_cast<char*>(~(alignment - 1) &
+            (reinterpret_cast<std::size_t>(ptr) + alignment - 1));
         std::size_t n = space - (p - static_cast<char*>(ptr));
         if (size <= n) {
             ptr = p;
@@ -32,7 +32,7 @@ inline void* align(std::size_t alignment, std::size_t size,
     return 0;
 }
 
-} /* .alignment */
-} /* .boost */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_65_0/boost/align/detail/align_cxx11.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/align_cxx11.hpp
new file mode 100644
index 00000000000..637541ab408
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/align_cxx11.hpp
@@ -0,0 +1,21 @@
+/*
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGN_CXX11_HPP
+#define BOOST_ALIGN_DETAIL_ALIGN_CXX11_HPP
+
+#include <memory>
+
+namespace boost {
+namespace alignment {
+
+using std::align;
+
+} /* alignment */
+} /* boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/align/detail/align_down.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/align_down.hpp
new file mode 100644
index 00000000000..de3c80d06d3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/align_down.hpp
@@ -0,0 +1,28 @@
+/*
+Copyright 2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGN_DOWN_HPP
+#define BOOST_ALIGN_DETAIL_ALIGN_DOWN_HPP
+
+#include <boost/align/detail/is_alignment.hpp>
+#include <boost/assert.hpp>
+
+namespace boost {
+namespace alignment {
+
+inline void*
+align_down(void* ptr, std::size_t alignment) BOOST_NOEXCEPT
+{
+    BOOST_ASSERT(detail::is_alignment(alignment));
+    return reinterpret_cast<void*>(~(alignment - 1) &
+        reinterpret_cast<std::size_t>(ptr));
+}
+
+} /* alignment */
+} /* boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/align/detail/align_up.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/align_up.hpp
new file mode 100644
index 00000000000..ac11f8964fb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/align_up.hpp
@@ -0,0 +1,28 @@
+/*
+Copyright 2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ALIGN_UP_HPP
+#define BOOST_ALIGN_DETAIL_ALIGN_UP_HPP
+
+#include <boost/align/detail/is_alignment.hpp>
+#include <boost/assert.hpp>
+
+namespace boost {
+namespace alignment {
+
+inline void*
+align_up(void* ptr, std::size_t alignment) BOOST_NOEXCEPT
+{
+    BOOST_ASSERT(detail::is_alignment(alignment));
+    return reinterpret_cast<void*>(~(alignment - 1) &
+        (reinterpret_cast<std::size_t>(ptr) + alignment - 1));
+}
+
+} /* alignment */
+} /* boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/aligned_alloc.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/aligned_alloc.hpp
similarity index 52%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/aligned_alloc.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/aligned_alloc.hpp
index 0488847bbd2..69da19659a6 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/aligned_alloc.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/aligned_alloc.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_HPP
 #define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_HPP
@@ -18,35 +17,36 @@ http://boost.org/LICENSE_1_0.txt
 namespace boost {
 namespace alignment {
 
-inline void* aligned_alloc(std::size_t alignment, std::size_t size)
-    BOOST_NOEXCEPT
+inline void*
+aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
 {
     BOOST_ASSERT(detail::is_alignment(alignment));
     enum {
-        min_align = alignment_of<void*>::value
+        N = alignment_of<void*>::value
     };
-    if (alignment < min_align) {
-        alignment = min_align;
+    if (alignment < N) {
+        alignment = N;
     }
-    std::size_t n = size + alignment - min_align;
-    void* r = 0;
+    std::size_t n = size + alignment - N;
     void* p = std::malloc(sizeof(void*) + n);
     if (p) {
-        r = static_cast<char*>(p) + sizeof p;
+        void* r = static_cast<char*>(p) + sizeof(void*);
         (void)align(alignment, size, r, n);
         *(static_cast<void**>(r) - 1) = p;
+        p = r;
     }
-    return r;
+    return p;
 }
 
-inline void aligned_free(void* ptr) BOOST_NOEXCEPT
+inline void
+aligned_free(void* ptr) BOOST_NOEXCEPT
 {
     if (ptr) {
         std::free(*(static_cast<void**>(ptr) - 1));
     }
 }
 
-} /* .alignment */
-} /* .boost */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/aligned_alloc_android.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/aligned_alloc_android.hpp
similarity index 53%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/aligned_alloc_android.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/aligned_alloc_android.hpp
index 0ed28a45eb9..4119fbd9bce 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/aligned_alloc_android.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/aligned_alloc_android.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_ANDROID_HPP
 #define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_ANDROID_HPP
@@ -16,19 +15,20 @@ http://boost.org/LICENSE_1_0.txt
 namespace boost {
 namespace alignment {
 
-inline void* aligned_alloc(std::size_t alignment, std::size_t size)
-    BOOST_NOEXCEPT
+inline void*
+aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
 {
     BOOST_ASSERT(detail::is_alignment(alignment));
     return ::memalign(alignment, size);
 }
 
-inline void aligned_free(void* ptr) BOOST_NOEXCEPT
+inline void
+aligned_free(void* ptr) BOOST_NOEXCEPT
 {
     ::free(ptr);
 }
 
-} /* .alignment */
-} /* .boost */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/aligned_alloc_macos.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/aligned_alloc_macos.hpp
similarity index 63%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/aligned_alloc_macos.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/aligned_alloc_macos.hpp
index 0bdb7c2eb10..76366fa5c10 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/aligned_alloc_macos.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/aligned_alloc_macos.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_MACOS_HPP
 #define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_MACOS_HPP
@@ -16,8 +15,8 @@ http://boost.org/LICENSE_1_0.txt
 namespace boost {
 namespace alignment {
 
-inline void* aligned_alloc(std::size_t alignment, std::size_t size)
-    BOOST_NOEXCEPT
+inline void*
+aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
 {
     BOOST_ASSERT(detail::is_alignment(alignment));
     if (size == 0) {
@@ -33,12 +32,13 @@ inline void* aligned_alloc(std::size_t alignment, std::size_t size)
     return p;
 }
 
-inline void aligned_free(void* ptr) BOOST_NOEXCEPT
+inline void
+aligned_free(void* ptr) BOOST_NOEXCEPT
 {
     ::free(ptr);
 }
 
-} /* .alignment */
-} /* .boost */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/aligned_alloc_msvc.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/aligned_alloc_msvc.hpp
similarity index 54%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/aligned_alloc_msvc.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/aligned_alloc_msvc.hpp
index abeccfc4e41..45c57c99151 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/aligned_alloc_msvc.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/aligned_alloc_msvc.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_MSVC_HPP
 #define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_MSVC_HPP
@@ -16,19 +15,20 @@ http://boost.org/LICENSE_1_0.txt
 namespace boost {
 namespace alignment {
 
-inline void* aligned_alloc(std::size_t alignment, std::size_t size)
-    BOOST_NOEXCEPT
+inline void*
+aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
 {
     BOOST_ASSERT(detail::is_alignment(alignment));
     return ::_aligned_malloc(size, alignment);
 }
 
-inline void aligned_free(void* ptr) BOOST_NOEXCEPT
+inline void
+aligned_free(void* ptr) BOOST_NOEXCEPT
 {
     ::_aligned_free(ptr);
 }
 
-} /* .alignment */
-} /* .boost */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/aligned_alloc_posix.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/aligned_alloc_posix.hpp
similarity index 61%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/aligned_alloc_posix.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/aligned_alloc_posix.hpp
index 931b0c4bd65..78fc842d205 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/aligned_alloc_posix.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/aligned_alloc_posix.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_POSIX_HPP
 #define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_POSIX_HPP
@@ -16,8 +15,8 @@ http://boost.org/LICENSE_1_0.txt
 namespace boost {
 namespace alignment {
 
-inline void* aligned_alloc(std::size_t alignment, std::size_t size)
-    BOOST_NOEXCEPT
+inline void*
+aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
 {
     BOOST_ASSERT(detail::is_alignment(alignment));
     if (alignment < sizeof(void*)) {
@@ -30,12 +29,13 @@ inline void* aligned_alloc(std::size_t alignment, std::size_t size)
     return p;
 }
 
-inline void aligned_free(void* ptr) BOOST_NOEXCEPT
+inline void
+aligned_free(void* ptr) BOOST_NOEXCEPT
 {
     ::free(ptr);
 }
 
-} /* .alignment */
-} /* .boost */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/aligned_alloc_sunos.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/aligned_alloc_sunos.hpp
similarity index 53%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/aligned_alloc_sunos.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/aligned_alloc_sunos.hpp
index 5039c733c6d..0948b40e392 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/aligned_alloc_sunos.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/aligned_alloc_sunos.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_SUNOS_HPP
 #define BOOST_ALIGN_DETAIL_ALIGNED_ALLOC_SUNOS_HPP
@@ -16,19 +15,20 @@ http://boost.org/LICENSE_1_0.txt
 namespace boost {
 namespace alignment {
 
-inline void* aligned_alloc(std::size_t alignment, std::size_t size)
-    BOOST_NOEXCEPT
+inline void*
+aligned_alloc(std::size_t alignment, std::size_t size) BOOST_NOEXCEPT
 {
     BOOST_ASSERT(detail::is_alignment(alignment));
     return ::memalign(alignment, size);
 }
 
-inline void aligned_free(void* ptr) BOOST_NOEXCEPT
+inline void
+aligned_free(void* ptr) BOOST_NOEXCEPT
 {
     ::free(ptr);
 }
 
-} /* .alignment */
-} /* .boost */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/alignment_of.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/alignment_of.hpp
similarity index 50%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/alignment_of.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/alignment_of.hpp
index f3f6192899a..b6fc3dcdcf7 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/alignment_of.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/alignment_of.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_HPP
 #define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_HPP
@@ -16,17 +15,17 @@ namespace alignment {
 namespace detail {
 
 template<class T>
-struct alignof_helper {
+struct offset_value {
     char value;
     T object;
 };
 
 template<class T>
 struct alignment_of
-    : min_size<sizeof(T), sizeof(alignof_helper<T>) - sizeof(T)> { };
+    : min_size<sizeof(T), sizeof(offset_value<T>) - sizeof(T)> { };
 
-} /* .detail */
-} /* .alignment */
-} /* .boost */
+} /* detail */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/alignment_of_clang.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/alignment_of_clang.hpp
similarity index 62%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/alignment_of_clang.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/alignment_of_clang.hpp
index f550156d734..95773e5ea31 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/alignment_of_clang.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/alignment_of_clang.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CLANG_HPP
 #define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CLANG_HPP
@@ -20,8 +19,8 @@ template<class T>
 struct alignment_of
     : integral_constant<std::size_t, __alignof(T)> { };
 
-} /* .detail */
-} /* .alignment */
-} /* .boost */
+} /* detail */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/alignment_of_codegear.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/alignment_of_codegear.hpp
similarity index 63%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/alignment_of_codegear.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/alignment_of_codegear.hpp
index 8948309d889..ea6f9042423 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/alignment_of_codegear.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/alignment_of_codegear.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CODEGEAR_HPP
 #define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CODEGEAR_HPP
@@ -20,8 +19,8 @@ template<class T>
 struct alignment_of
     : integral_constant<std::size_t, alignof(T)> { };
 
-} /* .detail */
-} /* .alignment */
-} /* .boost */
+} /* detail */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/alignment_of_cxx11.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/alignment_of_cxx11.hpp
similarity index 52%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/alignment_of_cxx11.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/alignment_of_cxx11.hpp
index cbe2d9e7a8c..05c7429385c 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/alignment_of_cxx11.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/alignment_of_cxx11.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CXX11_HPP
 #define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_CXX11_HPP
@@ -17,8 +16,8 @@ namespace detail {
 
 using std::alignment_of;
 
-} /* .detail */
-} /* .alignment */
-} /* .boost */
+} /* detail */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/alignment_of_gcc.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/alignment_of_gcc.hpp
similarity index 62%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/alignment_of_gcc.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/alignment_of_gcc.hpp
index ffd8294fe32..66a63a50b12 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/alignment_of_gcc.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/alignment_of_gcc.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_GCC_HPP
 #define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_GCC_HPP
@@ -20,8 +19,8 @@ template<class T>
 struct alignment_of
     : integral_constant<std::size_t, __alignof__(T)> { };
 
-} /* .detail */
-} /* .alignment */
-} /* .boost */
+} /* detail */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/alignment_of_msvc.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/alignment_of_msvc.hpp
similarity index 50%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/alignment_of_msvc.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/alignment_of_msvc.hpp
index cdd7c477ce0..440b840db45 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/alignment_of_msvc.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/alignment_of_msvc.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_ALIGNMENT_OF_MSVC_HPP
 #define BOOST_ALIGN_DETAIL_ALIGNMENT_OF_MSVC_HPP
@@ -16,7 +15,7 @@ namespace alignment {
 namespace detail {
 
 template<class T>
-struct alignof_helper {
+struct offset_value {
     T first;
     char value;
     T second;
@@ -24,11 +23,10 @@ struct alignof_helper {
 
 template<class T>
 struct alignment_of
-    : min_size<sizeof(T),
-        sizeof(alignof_helper<T>) - (sizeof(T) << 1)> { };
+    : min_size<sizeof(T), sizeof(offset_value<T>) - (sizeof(T) << 1)> { };
 
-} /* .detail */
-} /* .alignment */
-} /* .boost */
+} /* detail */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_65_0/boost/align/detail/assume_aligned.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/assume_aligned.hpp
new file mode 100644
index 00000000000..d218d8c64ed
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/assume_aligned.hpp
@@ -0,0 +1,16 @@
+/*
+Copyright 2015 NumScale SAS
+Copyright 2015 LRI UMR 8623 CNRS/University Paris Sud XI
+
+Copyright 2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ASSUME_ALIGNED_HPP
+#define BOOST_ALIGN_DETAIL_ASSUME_ALIGNED_HPP
+
+#define BOOST_ALIGN_ASSUME_ALIGNED(ptr, alignment)
+
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/assume_aligned_clang.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/assume_aligned_clang.hpp
similarity index 53%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/assume_aligned_clang.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/assume_aligned_clang.hpp
index d57cf4f8e5a..4c7159fa28e 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/assume_aligned_clang.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/assume_aligned_clang.hpp
@@ -1,17 +1,16 @@
 /*
-(c) 2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_ASSUME_ALIGNED_CLANG_HPP
 #define BOOST_ALIGN_DETAIL_ASSUME_ALIGNED_CLANG_HPP
 
 #if __has_builtin(__builtin_assume_aligned)
 #define BOOST_ALIGN_ASSUME_ALIGNED(p, n) \
-(p) = (__typeof__(p))(__builtin_assume_aligned((p), (n)))
+(p) = static_cast<__typeof__(p)>(__builtin_assume_aligned((p), (n)))
 #else
 #define BOOST_ALIGN_ASSUME_ALIGNED(p, n)
 #endif
diff --git a/contrib/libboost/boost_1_65_0/boost/align/detail/assume_aligned_gcc.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/assume_aligned_gcc.hpp
new file mode 100644
index 00000000000..117344447ae
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/assume_aligned_gcc.hpp
@@ -0,0 +1,17 @@
+/*
+Copyright 2015 NumScale SAS
+Copyright 2015 LRI UMR 8623 CNRS/University Paris Sud XI
+
+Copyright 2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ASSUME_ALIGNED_GCC_HPP
+#define BOOST_ALIGN_DETAIL_ASSUME_ALIGNED_GCC_HPP
+
+#define BOOST_ALIGN_ASSUME_ALIGNED(p, n) \
+(p) = static_cast<__typeof__(p)>(__builtin_assume_aligned((p), (n)))
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/align/detail/assume_aligned_intel.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/assume_aligned_intel.hpp
new file mode 100644
index 00000000000..6792ce005ce
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/assume_aligned_intel.hpp
@@ -0,0 +1,17 @@
+/*
+Copyright 2015 NumScale SAS
+Copyright 2015 LRI UMR 8623 CNRS/University Paris Sud XI
+
+Copyright 2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ASSUME_ALIGNED_INTEL_HPP
+#define BOOST_ALIGN_DETAIL_ASSUME_ALIGNED_INTEL_HPP
+
+#define BOOST_ALIGN_ASSUME_ALIGNED(ptr, alignment) \
+__assume_aligned((ptr), (alignment))
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/align/detail/assume_aligned_msvc.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/assume_aligned_msvc.hpp
new file mode 100644
index 00000000000..75ac7e12429
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/assume_aligned_msvc.hpp
@@ -0,0 +1,19 @@
+/*
+Copyright 2015 NumScale SAS
+Copyright 2015 LRI UMR 8623 CNRS/University Paris Sud XI
+
+Copyright 2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_ASSUME_ALIGNED_MSVC_HPP
+#define BOOST_ALIGN_DETAIL_ASSUME_ALIGNED_MSVC_HPP
+
+#include <cstddef>
+
+#define BOOST_ALIGN_ASSUME_ALIGNED(ptr, alignment) \
+__assume((reinterpret_cast<std::size_t>(ptr) & ((alignment) - 1)) == 0)
+
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/element_type.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/element_type.hpp
similarity index 60%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/element_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/element_type.hpp
index 69995e1613c..5b2b732da0a 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/element_type.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/element_type.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_ELEMENT_TYPE_HPP
 #define BOOST_ALIGN_DETAIL_ELEMENT_TYPE_HPP
@@ -49,45 +48,44 @@ struct remove_all_extents {
 };
 
 template<class T>
-struct remove_all_extents<T[]>
-    : remove_all_extents<T> { };
+struct remove_all_extents<T[]> {
+    typedef typename remove_all_extents<T>::type type;
+};
 
 template<class T, std::size_t N>
-struct remove_all_extents<T[N]>
-    : remove_all_extents<T> { };
+struct remove_all_extents<T[N]> {
+    typedef typename remove_all_extents<T>::type type;
+};
 
 template<class T>
-struct remove_const {
+struct remove_cv {
     typedef T type;
 };
 
 template<class T>
-struct remove_const<const T> {
+struct remove_cv<const T> {
     typedef T type;
 };
 
 template<class T>
-struct remove_volatile {
+struct remove_cv<volatile T> {
     typedef T type;
 };
 
 template<class T>
-struct remove_volatile<volatile T> {
+struct remove_cv<const volatile T> {
     typedef T type;
 };
-
-template<class T>
-struct remove_cv
-    : remove_volatile<typename remove_const<T>::type> { };
 #endif
 
 template<class T>
-struct element_type
-    : remove_cv<typename remove_all_extents<typename
-        remove_reference<T>::type>::type> { };
+struct element_type {
+    typedef typename remove_cv<typename remove_all_extents<typename
+        remove_reference<T>::type>::type>::type type;
+};
 
-} /* .detail */
-} /* .alignment */
-} /* .boost */
+} /* detail */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/integral_constant.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/integral_constant.hpp
similarity index 70%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/integral_constant.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/integral_constant.hpp
index 1ad67e330fe..860096783e9 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/integral_constant.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/integral_constant.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014-2016 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014-2016 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_INTEGRAL_CONSTANT_HPP
 #define BOOST_ALIGN_DETAIL_INTEGRAL_CONSTANT_HPP
@@ -37,10 +36,13 @@ struct integral_constant {
 
     BOOST_STATIC_CONSTEXPR T value = Value;
 };
+
+template<class T, T Value>
+BOOST_CONSTEXPR_OR_CONST T integral_constant<T, Value>::value;
 #endif
 
-} /* .detail */
-} /* .alignment */
-} /* .boost */
+} /* detail */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_65_0/boost/align/detail/is_aligned.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/is_aligned.hpp
new file mode 100644
index 00000000000..61982c46856
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/is_aligned.hpp
@@ -0,0 +1,34 @@
+/*
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_IS_ALIGNED_HPP
+#define BOOST_ALIGN_DETAIL_IS_ALIGNED_HPP
+
+#include <boost/align/detail/is_alignment.hpp>
+#include <boost/assert.hpp>
+
+namespace boost {
+namespace alignment {
+
+inline bool
+is_aligned(const void* ptr, std::size_t alignment) BOOST_NOEXCEPT
+{
+    BOOST_ASSERT(detail::is_alignment(alignment));
+    return (reinterpret_cast<std::size_t>(ptr) & (alignment - 1)) == 0;
+}
+
+inline bool
+is_aligned(std::size_t alignment, const void* ptr) BOOST_NOEXCEPT
+{
+    BOOST_ASSERT(detail::is_alignment(alignment));
+    return (reinterpret_cast<std::size_t>(ptr) & (alignment - 1)) == 0;
+}
+
+} /* alignment */
+} /* boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/align/detail/is_alignment.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/is_alignment.hpp
new file mode 100644
index 00000000000..542fbe46942
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/is_alignment.hpp
@@ -0,0 +1,28 @@
+/*
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_ALIGN_DETAIL_IS_ALIGNMENT_HPP
+#define BOOST_ALIGN_DETAIL_IS_ALIGNMENT_HPP
+
+#include <boost/config.hpp>
+#include <cstddef>
+
+namespace boost {
+namespace alignment {
+namespace detail {
+
+BOOST_CONSTEXPR inline bool
+is_alignment(std::size_t value) BOOST_NOEXCEPT
+{
+    return (value > 0) && ((value & (value - 1)) == 0);
+}
+
+} /* detail */
+} /* alignment */
+} /* boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/is_alignment_constant.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/is_alignment_constant.hpp
similarity index 64%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/is_alignment_constant.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/is_alignment_constant.hpp
index eb709b7bc2e..0ded62857ee 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/is_alignment_constant.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/is_alignment_constant.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_IS_ALIGNMENT_CONSTANT_HPP
 #define BOOST_ALIGN_DETAIL_IS_ALIGNMENT_CONSTANT_HPP
@@ -20,8 +19,8 @@ template<std::size_t N>
 struct is_alignment_constant
     : integral_constant<bool, (N > 0) && ((N & (N - 1)) == 0)> { };
 
-} /* .detail */
-} /* .alignment */
-} /* .boost */
+} /* detail */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/max_align.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/max_align.hpp
similarity index 63%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/max_align.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/max_align.hpp
index d91de0dab5d..9c09fec9c96 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/max_align.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/max_align.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_MAX_ALIGN_HPP
 #define BOOST_ALIGN_DETAIL_MAX_ALIGN_HPP
@@ -20,8 +19,8 @@ template<class A, class B>
 struct max_align
     : max_size<alignment_of<A>::value, alignment_of<B>::value> { };
 
-} /* .detail */
-} /* .alignment */
-} /* .boost */
+} /* detail */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/max_objects.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/max_objects.hpp
similarity index 64%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/max_objects.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/max_objects.hpp
index 27d377c5c24..9fdd30e1187 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/max_objects.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/max_objects.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_MAX_OBJECTS_HPP
 #define BOOST_ALIGN_DETAIL_MAX_OBJECTS_HPP
@@ -21,8 +20,8 @@ struct max_objects
     : integral_constant<std::size_t,
         ~static_cast<std::size_t>(0) / sizeof(T)> { };
 
-} /* .detail */
-} /* .alignment */
-} /* .boost */
+} /* detail */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/max_size.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/max_size.hpp
similarity index 62%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/max_size.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/max_size.hpp
index 555aa2c258c..22cefdbec55 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/max_size.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/max_size.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_MAX_SIZE_HPP
 #define BOOST_ALIGN_DETAIL_MAX_SIZE_HPP
@@ -20,8 +19,8 @@ template<std::size_t A, std::size_t B>
 struct max_size
     : integral_constant<std::size_t, (A > B) ? A : B> { };
 
-} /* .detail */
-} /* .alignment */
-} /* .boost */
+} /* detail */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/align/detail/min_size.hpp b/contrib/libboost/boost_1_65_0/boost/align/detail/min_size.hpp
similarity index 62%
rename from contrib/libboost/boost_1_62_0/boost/align/detail/min_size.hpp
rename to contrib/libboost/boost_1_65_0/boost/align/detail/min_size.hpp
index b20d3cdeaf7..5b478fdaf06 100644
--- a/contrib/libboost/boost_1_62_0/boost/align/detail/min_size.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/align/detail/min_size.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_ALIGN_DETAIL_MIN_SIZE_HPP
 #define BOOST_ALIGN_DETAIL_MIN_SIZE_HPP
@@ -20,8 +19,8 @@ template<std::size_t A, std::size_t B>
 struct min_size
     : integral_constant<std::size_t, (A < B) ? A : B> { };
 
-} /* .detail */
-} /* .alignment */
-} /* .boost */
+} /* detail */
+} /* alignment */
+} /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_65_0/boost/align/is_aligned.hpp b/contrib/libboost/boost_1_65_0/boost/align/is_aligned.hpp
new file mode 100644
index 00000000000..c8266d0eae5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/align/is_aligned.hpp
@@ -0,0 +1,26 @@
+/*
+Copyright 2014 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+
+*/
+#ifndef BOOST_ALIGN_IS_ALIGNED_HPP
+#define BOOST_ALIGN_IS_ALIGNED_HPP
+
+#include <boost/align/detail/is_aligned.hpp>
+
+namespace boost {
+namespace alignment {
+
+BOOST_CONSTEXPR inline bool
+is_aligned(std::size_t value, std::size_t alignment) BOOST_NOEXCEPT
+{
+    return (value & (alignment - 1)) == 0;
+}
+
+} /* alignment */
+} /* boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/aligned_storage.hpp b/contrib/libboost/boost_1_65_0/boost/aligned_storage.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/aligned_storage.hpp
rename to contrib/libboost/boost_1_65_0/boost/aligned_storage.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/any.hpp b/contrib/libboost/boost_1_65_0/boost/any.hpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/boost/any.hpp
rename to contrib/libboost/boost_1_65_0/boost/any.hpp
index 437de2c0231..9f6b3132744 100644
--- a/contrib/libboost/boost_1_62_0/boost/any.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/any.hpp
@@ -16,7 +16,7 @@
 
 #include <algorithm>
 
-#include "boost/config.hpp"
+#include <boost/config.hpp>
 #include <boost/type_index.hpp>
 #include <boost/type_traits/remove_reference.hpp>
 #include <boost/type_traits/decay.hpp>
@@ -27,6 +27,7 @@
 #include <boost/throw_exception.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/utility/enable_if.hpp>
+#include <boost/core/addressof.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/is_const.hpp>
 #include <boost/mpl/if.hpp>
@@ -244,7 +245,9 @@ namespace boost
     ValueType * any_cast(any * operand) BOOST_NOEXCEPT
     {
         return operand && operand->type() == boost::typeindex::type_id<ValueType>()
-            ? &static_cast<any::holder<BOOST_DEDUCED_TYPENAME remove_cv<ValueType>::type> *>(operand->content)->held
+            ? boost::addressof(
+                static_cast<any::holder<BOOST_DEDUCED_TYPENAME remove_cv<ValueType>::type> *>(operand->content)->held
+              )
             : 0;
     }
 
@@ -260,7 +263,7 @@ namespace boost
         typedef BOOST_DEDUCED_TYPENAME remove_reference<ValueType>::type nonref;
 
 
-        nonref * result = any_cast<nonref>(&operand);
+        nonref * result = any_cast<nonref>(boost::addressof(operand));
         if(!result)
             boost::throw_exception(bad_any_cast());
 
@@ -274,7 +277,14 @@ namespace boost
             BOOST_DEDUCED_TYPENAME boost::add_reference<ValueType>::type
         >::type ref_type;
 
+#ifdef BOOST_MSVC
+#   pragma warning(push)
+#   pragma warning(disable: 4172) // "returning address of local variable or temporary" but *result is not local!
+#endif
         return static_cast<ref_type>(*result);
+#ifdef BOOST_MSVC
+#   pragma warning(pop)
+#endif
     }
 
     template<typename ValueType>
@@ -306,7 +316,9 @@ namespace boost
     template<typename ValueType>
     inline ValueType * unsafe_any_cast(any * operand) BOOST_NOEXCEPT
     {
-        return &static_cast<any::holder<ValueType> *>(operand->content)->held;
+        return boost::addressof(
+            static_cast<any::holder<ValueType> *>(operand->content)->held
+        );
     }
 
     template<typename ValueType>
diff --git a/contrib/libboost/boost_1_62_0/boost/array.hpp b/contrib/libboost/boost_1_65_0/boost/array.hpp
similarity index 82%
rename from contrib/libboost/boost_1_62_0/boost/array.hpp
rename to contrib/libboost/boost_1_65_0/boost/array.hpp
index fa06fa9a5f1..210c0721254 100644
--- a/contrib/libboost/boost_1_62_0/boost/array.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/array.hpp
@@ -13,6 +13,7 @@
  * accompanying file LICENSE_1_0.txt or copy at
  * http://www.boost.org/LICENSE_1_0.txt)
  *
+ *  9 Jan 2013 - (mtc) Added constexpr
  * 14 Apr 2012 - (mtc) Added support for boost::hash
  * 28 Dec 2010 - (mtc) Added cbegin and cend (and crbegin and crend) for C++Ox compatibility.
  * 10 Mar 2010 - (mtc) fill method added, matching resolution of the standard library working group.
@@ -42,12 +43,12 @@
 #include <cstddef>
 #include <stdexcept>
 #include <boost/assert.hpp>
+#include <boost/static_assert.hpp>
 #include <boost/swap.hpp>
 
 // Handles broken standard libraries better than <iterator>
 #include <boost/detail/iterator.hpp>
 #include <boost/throw_exception.hpp>
-#include <boost/functional/hash_fwd.hpp>
 #include <algorithm>
 
 // FIXES for broken compilers
@@ -81,15 +82,9 @@ namespace boost {
         const_iterator cend() const { return elems+N; }
 
         // reverse iterator support
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
+#if !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
         typedef std::reverse_iterator<iterator> reverse_iterator;
         typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-#elif defined(_MSC_VER) && (_MSC_VER == 1300) && defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB == 310)
-        // workaround for broken reverse_iterator in VC7
-        typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, iterator,
-                                      reference, iterator, reference> > reverse_iterator;
-        typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, const_iterator,
-                                      const_reference, iterator, reference> > const_reverse_iterator;
 #elif defined(_RWSTD_NO_CLASS_PARTIAL_SPEC) 
         typedef std::reverse_iterator<iterator, std::random_access_iterator_tag, 
               value_type, reference, iterator, difference_type> reverse_iterator; 
@@ -120,19 +115,17 @@ namespace boost {
         // operator[]
         reference operator[](size_type i) 
         { 
-            BOOST_ASSERT_MSG( i < N, "out of range" );
-            return elems[i];
+            return BOOST_ASSERT_MSG( i < N, "out of range" ), elems[i]; 
         }
         
-        const_reference operator[](size_type i) const 
+        /*BOOST_CONSTEXPR*/ const_reference operator[](size_type i) const 
         {     
-            BOOST_ASSERT_MSG( i < N, "out of range" );
-            return elems[i]; 
+            return BOOST_ASSERT_MSG( i < N, "out of range" ), elems[i]; 
         }
 
         // at() with range check
-        reference at(size_type i) { rangecheck(i); return elems[i]; }
-        const_reference at(size_type i) const { rangecheck(i); return elems[i]; }
+        reference                           at(size_type i)       { return rangecheck(i), elems[i]; }
+        /*BOOST_CONSTEXPR*/ const_reference at(size_type i) const { return rangecheck(i), elems[i]; }
     
         // front() and back()
         reference front() 
@@ -140,7 +133,7 @@ namespace boost {
             return elems[0]; 
         }
         
-        const_reference front() const 
+        BOOST_CONSTEXPR const_reference front() const 
         {
             return elems[0];
         }
@@ -150,15 +143,15 @@ namespace boost {
             return elems[N-1]; 
         }
         
-        const_reference back() const 
+        BOOST_CONSTEXPR const_reference back() const 
         { 
             return elems[N-1]; 
         }
 
         // size is constant
-        static size_type size() { return N; }
-        static bool empty() { return false; }
-        static size_type max_size() { return N; }
+        static BOOST_CONSTEXPR size_type size() { return N; }
+        static BOOST_CONSTEXPR bool empty() { return false; }
+        static BOOST_CONSTEXPR size_type max_size() { return N; }
         enum { static_size = N };
 
         // swap (note: linear complexity)
@@ -189,16 +182,12 @@ namespace boost {
         }
 
         // check range (may be private because it is static)
-        static void rangecheck (size_type i) {
-            if (i >= size()) {
-                std::out_of_range e("array<>: index out of range");
-                boost::throw_exception(e);
-            }
+        static BOOST_CONSTEXPR bool rangecheck (size_type i) {
+            return i > size() ? boost::throw_exception(std::out_of_range ("array<>: index out of range")), true : true;
         }
 
     };
 
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
     template< class T >
     class array< T, 0 > {
 
@@ -222,15 +211,9 @@ namespace boost {
         const_iterator cend() const { return cbegin(); }
 
         // reverse iterator support
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
+#if !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
         typedef std::reverse_iterator<iterator> reverse_iterator;
         typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-#elif defined(_MSC_VER) && (_MSC_VER == 1300) && defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB == 310)
-        // workaround for broken reverse_iterator in VC7
-        typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, iterator,
-                                      reference, iterator, reference> > reverse_iterator;
-        typedef std::reverse_iterator<std::_Ptrit<value_type, difference_type, const_iterator,
-                                      const_reference, iterator, reference> > const_reverse_iterator;
 #elif defined(_RWSTD_NO_CLASS_PARTIAL_SPEC) 
         typedef std::reverse_iterator<iterator, std::random_access_iterator_tag, 
               value_type, reference, iterator, difference_type> reverse_iterator; 
@@ -264,14 +247,14 @@ namespace boost {
             return failed_rangecheck();
         }
 
-        const_reference operator[](size_type /*i*/) const
+        /*BOOST_CONSTEXPR*/ const_reference operator[](size_type /*i*/) const
         {
             return failed_rangecheck();
         }
 
         // at() with range check
         reference at(size_type /*i*/)               {   return failed_rangecheck(); }
-        const_reference at(size_type /*i*/) const   {   return failed_rangecheck(); }
+        /*BOOST_CONSTEXPR*/ const_reference at(size_type /*i*/) const   { return failed_rangecheck(); }
 
         // front() and back()
         reference front()
@@ -279,7 +262,7 @@ namespace boost {
             return failed_rangecheck();
         }
 
-        const_reference front() const
+        BOOST_CONSTEXPR const_reference front() const
         {
             return failed_rangecheck();
         }
@@ -289,15 +272,15 @@ namespace boost {
             return failed_rangecheck();
         }
 
-        const_reference back() const
+        BOOST_CONSTEXPR const_reference back() const
         {
             return failed_rangecheck();
         }
 
         // size is constant
-        static size_type size() { return 0; }
-        static bool empty() { return true; }
-        static size_type max_size() { return 0; }
+        static BOOST_CONSTEXPR size_type size() { return 0; }
+        static BOOST_CONSTEXPR bool empty() { return true; }
+        static BOOST_CONSTEXPR size_type max_size() { return 0; }
         enum { static_size = 0 };
 
         void swap (array<T,0>& /*y*/) {
@@ -335,7 +318,6 @@ namespace boost {
 #endif
             }
     };
-#endif
 
     // comparisons
     template<class T, std::size_t N>
@@ -391,7 +373,7 @@ namespace boost {
 
    // Specific for boost::array: simply returns its elems data member.
    template <typename T, std::size_t N>
-   typename const detail::c_array<T,N>::type& get_c_array(const boost::array<T,N>& arg)
+   typename detail::c_array<T,N>::type const& get_c_array(const boost::array<T,N>& arg)
    {
        return arg.elems;
    }
@@ -429,6 +411,7 @@ namespace boost {
     }
 #endif
 
+    template <class It> std::size_t hash_range(It, It);
 
     template<class T, std::size_t N>
     std::size_t hash_value(const array<T,N>& arr)
@@ -436,8 +419,36 @@ namespace boost {
         return boost::hash_range(arr.begin(), arr.end());
     }
 
+   template <size_t Idx, typename T, size_t N>
+   T &get(boost::array<T,N> &arr) BOOST_NOEXCEPT {
+       BOOST_STATIC_ASSERT_MSG ( Idx < N, "boost::get<>(boost::array &) index out of range" );
+       return arr[Idx];
+       }
+    
+   template <size_t Idx, typename T, size_t N>
+   const T &get(const boost::array<T,N> &arr) BOOST_NOEXCEPT {
+       BOOST_STATIC_ASSERT_MSG ( Idx < N, "boost::get<>(const boost::array &) index out of range" );
+       return arr[Idx];
+       }
+
 } /* namespace boost */
 
+#ifndef BOOST_NO_CXX11_HDR_ARRAY
+//  If we don't have std::array, I'm assuming that we don't have std::get
+namespace std {
+   template <size_t Idx, typename T, size_t N>
+   T &get(boost::array<T,N> &arr) BOOST_NOEXCEPT {
+       BOOST_STATIC_ASSERT_MSG ( Idx < N, "std::get<>(boost::array &) index out of range" );
+       return arr[Idx];
+       }
+    
+   template <size_t Idx, typename T, size_t N>
+   const T &get(const boost::array<T,N> &arr) BOOST_NOEXCEPT {
+       BOOST_STATIC_ASSERT_MSG ( Idx < N, "std::get<>(const boost::array &) index out of range" );
+       return arr[Idx];
+       }
+}
+#endif
 
 #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)  
 # pragma warning(pop)  
diff --git a/contrib/libboost/boost_1_62_0/boost/assert.hpp b/contrib/libboost/boost_1_65_0/boost/assert.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/assert.hpp
rename to contrib/libboost/boost_1_65_0/boost/assert.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/bind.hpp b/contrib/libboost/boost_1_65_0/boost/bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/bind/apply.hpp b/contrib/libboost/boost_1_65_0/boost/bind/apply.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/bind/apply.hpp
rename to contrib/libboost/boost_1_65_0/boost/bind/apply.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/bind/arg.hpp b/contrib/libboost/boost_1_65_0/boost/bind/arg.hpp
similarity index 82%
rename from contrib/libboost/boost_1_62_0/boost/bind/arg.hpp
rename to contrib/libboost/boost_1_65_0/boost/bind/arg.hpp
index a74b8298bea..cb52e6689f7 100644
--- a/contrib/libboost/boost_1_62_0/boost/bind/arg.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/bind/arg.hpp
@@ -21,20 +21,27 @@
 
 #include <boost/config.hpp>
 #include <boost/is_placeholder.hpp>
-#include <boost/static_assert.hpp>
 
 namespace boost
 {
 
+template<bool Eq> struct _arg_eq
+{
+};
+
+template<> struct _arg_eq<true>
+{
+    typedef void type;
+};
+
 template< int I > struct arg
 {
     BOOST_CONSTEXPR arg()
     {
     }
 
-    template< class T > BOOST_CONSTEXPR arg( T const & /* t */ )
+    template< class T > BOOST_CONSTEXPR arg( T const & /* t */, typename _arg_eq< I == is_placeholder<T>::value >::type * = 0 )
     {
-        BOOST_STATIC_ASSERT( I == is_placeholder<T>::value );
     }
 };
 
diff --git a/contrib/libboost/boost_1_62_0/boost/bind/bind.hpp b/contrib/libboost/boost_1_65_0/boost/bind/bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/bind/bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/bind/bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/bind/bind_cc.hpp b/contrib/libboost/boost_1_65_0/boost/bind/bind_cc.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/bind/bind_cc.hpp
rename to contrib/libboost/boost_1_65_0/boost/bind/bind_cc.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/bind/bind_mf2_cc.hpp b/contrib/libboost/boost_1_65_0/boost/bind/bind_mf2_cc.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/bind/bind_mf2_cc.hpp
rename to contrib/libboost/boost_1_65_0/boost/bind/bind_mf2_cc.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/bind/bind_mf_cc.hpp b/contrib/libboost/boost_1_65_0/boost/bind/bind_mf_cc.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/bind/bind_mf_cc.hpp
rename to contrib/libboost/boost_1_65_0/boost/bind/bind_mf_cc.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/bind/bind_template.hpp b/contrib/libboost/boost_1_65_0/boost/bind/bind_template.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/bind/bind_template.hpp
rename to contrib/libboost/boost_1_65_0/boost/bind/bind_template.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/bind/make_adaptable.hpp b/contrib/libboost/boost_1_65_0/boost/bind/make_adaptable.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/bind/make_adaptable.hpp
rename to contrib/libboost/boost_1_65_0/boost/bind/make_adaptable.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/bind/mem_fn.hpp b/contrib/libboost/boost_1_65_0/boost/bind/mem_fn.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/bind/mem_fn.hpp
rename to contrib/libboost/boost_1_65_0/boost/bind/mem_fn.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/bind/mem_fn_cc.hpp b/contrib/libboost/boost_1_65_0/boost/bind/mem_fn_cc.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/bind/mem_fn_cc.hpp
rename to contrib/libboost/boost_1_65_0/boost/bind/mem_fn_cc.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/bind/mem_fn_template.hpp b/contrib/libboost/boost_1_65_0/boost/bind/mem_fn_template.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/bind/mem_fn_template.hpp
rename to contrib/libboost/boost_1_65_0/boost/bind/mem_fn_template.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/bind/mem_fn_vw.hpp b/contrib/libboost/boost_1_65_0/boost/bind/mem_fn_vw.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/bind/mem_fn_vw.hpp
rename to contrib/libboost/boost_1_65_0/boost/bind/mem_fn_vw.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/bind/placeholders.hpp b/contrib/libboost/boost_1_65_0/boost/bind/placeholders.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/bind/placeholders.hpp
rename to contrib/libboost/boost_1_65_0/boost/bind/placeholders.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/bind/protect.hpp b/contrib/libboost/boost_1_65_0/boost/bind/protect.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/bind/protect.hpp
rename to contrib/libboost/boost_1_65_0/boost/bind/protect.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/bind/storage.hpp b/contrib/libboost/boost_1_65_0/boost/bind/storage.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/bind/storage.hpp
rename to contrib/libboost/boost_1_65_0/boost/bind/storage.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/blank.hpp b/contrib/libboost/boost_1_65_0/boost/blank.hpp
new file mode 100644
index 00000000000..d0fe5abca56
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/blank.hpp
@@ -0,0 +1,106 @@
+//-----------------------------------------------------------------------------
+// boost blank.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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_BLANK_HPP
+#define BOOST_BLANK_HPP
+
+#include "boost/blank_fwd.hpp"
+
+#if !defined(BOOST_NO_IOSTREAM)
+#include <iosfwd> // for std::basic_ostream forward declare
+#include "boost/detail/templated_streams.hpp"
+#endif // BOOST_NO_IOSTREAM
+
+#include "boost/mpl/bool.hpp"
+#include "boost/type_traits/is_empty.hpp"
+#include "boost/type_traits/is_pod.hpp"
+#include "boost/type_traits/is_stateless.hpp"
+
+namespace boost {
+
+struct blank
+{
+};
+
+// type traits specializations
+//
+
+template <>
+struct is_pod< blank >
+    : mpl::true_
+{
+};
+
+template <>
+struct is_empty< blank >
+    : mpl::true_
+{
+};
+
+template <>
+struct is_stateless< blank >
+    : mpl::true_
+{
+};
+
+// relational operators
+//
+
+inline bool operator==(const blank&, const blank&)
+{
+    return true;
+}
+
+inline bool operator<=(const blank&, const blank&)
+{
+    return true;
+}
+
+inline bool operator>=(const blank&, const blank&)
+{
+    return true;
+}
+
+inline bool operator!=(const blank&, const blank&)
+{
+    return false;
+}
+
+inline bool operator<(const blank&, const blank&)
+{
+    return false;
+}
+
+inline bool operator>(const blank&, const blank&)
+{
+    return false;
+}
+
+// streaming support
+//
+#if !defined(BOOST_NO_IOSTREAM)
+
+BOOST_TEMPLATED_STREAM_TEMPLATE(E,T)
+inline BOOST_TEMPLATED_STREAM(ostream, E,T)& operator<<(
+      BOOST_TEMPLATED_STREAM(ostream, E,T)& out
+    , const blank&
+    )
+{
+    // (output nothing)
+    return out;
+}
+
+#endif // BOOST_NO_IOSTREAM
+
+} // namespace boost
+
+#endif // BOOST_BLANK_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/blank_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/blank_fwd.hpp
new file mode 100644
index 00000000000..8bfe97c4699
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/blank_fwd.hpp
@@ -0,0 +1,22 @@
+//-----------------------------------------------------------------------------
+// boost blank_fwd.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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_BLANK_FWD_HPP
+#define BOOST_BLANK_FWD_HPP
+
+namespace boost {
+
+struct blank;
+
+} // namespace boost
+
+#endif // BOOST_BLANK_FWD_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/call_traits.hpp b/contrib/libboost/boost_1_65_0/boost/call_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/call_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/call_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/cerrno.hpp b/contrib/libboost/boost_1_65_0/boost/cerrno.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/cerrno.hpp
rename to contrib/libboost/boost_1_65_0/boost/cerrno.hpp
index 6f2669846d3..57278f5ceed 100644
--- a/contrib/libboost/boost_1_62_0/boost/cerrno.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/cerrno.hpp
@@ -7,8 +7,8 @@
 
 //  See library home page at http://www.boost.org/libs/system
 
-#ifndef BOOST_CERRNO_HPP
-#define BOOST_CERRNO_HPP
+#ifndef BOOST_SYSTEM_CERRNO_HPP
+#define BOOST_SYSTEM_CERRNO_HPP
 
 #include <cerrno>
 
diff --git a/contrib/libboost/boost_1_62_0/boost/checked_delete.hpp b/contrib/libboost/boost_1_65_0/boost/checked_delete.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/checked_delete.hpp
rename to contrib/libboost/boost_1_65_0/boost/checked_delete.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/compressed_pair.hpp b/contrib/libboost/boost_1_65_0/boost/compressed_pair.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/compressed_pair.hpp
rename to contrib/libboost/boost_1_65_0/boost/compressed_pair.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/concept/assert.hpp b/contrib/libboost/boost_1_65_0/boost/concept/assert.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/concept/assert.hpp
rename to contrib/libboost/boost_1_65_0/boost/concept/assert.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/concept/detail/backward_compatibility.hpp b/contrib/libboost/boost_1_65_0/boost/concept/detail/backward_compatibility.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/concept/detail/backward_compatibility.hpp
rename to contrib/libboost/boost_1_65_0/boost/concept/detail/backward_compatibility.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/concept/detail/borland.hpp b/contrib/libboost/boost_1_65_0/boost/concept/detail/borland.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/concept/detail/borland.hpp
rename to contrib/libboost/boost_1_65_0/boost/concept/detail/borland.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/concept/detail/concept_def.hpp b/contrib/libboost/boost_1_65_0/boost/concept/detail/concept_def.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/concept/detail/concept_def.hpp
rename to contrib/libboost/boost_1_65_0/boost/concept/detail/concept_def.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/concept/detail/concept_undef.hpp b/contrib/libboost/boost_1_65_0/boost/concept/detail/concept_undef.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/concept/detail/concept_undef.hpp
rename to contrib/libboost/boost_1_65_0/boost/concept/detail/concept_undef.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/concept/detail/general.hpp b/contrib/libboost/boost_1_65_0/boost/concept/detail/general.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/concept/detail/general.hpp
rename to contrib/libboost/boost_1_65_0/boost/concept/detail/general.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/concept/detail/has_constraints.hpp b/contrib/libboost/boost_1_65_0/boost/concept/detail/has_constraints.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/concept/detail/has_constraints.hpp
rename to contrib/libboost/boost_1_65_0/boost/concept/detail/has_constraints.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/concept/detail/msvc.hpp b/contrib/libboost/boost_1_65_0/boost/concept/detail/msvc.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/concept/detail/msvc.hpp
rename to contrib/libboost/boost_1_65_0/boost/concept/detail/msvc.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/concept/requires.hpp b/contrib/libboost/boost_1_65_0/boost/concept/requires.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/concept/requires.hpp
rename to contrib/libboost/boost_1_65_0/boost/concept/requires.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/concept/usage.hpp b/contrib/libboost/boost_1_65_0/boost/concept/usage.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/concept/usage.hpp
rename to contrib/libboost/boost_1_65_0/boost/concept/usage.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/concept_check.hpp b/contrib/libboost/boost_1_65_0/boost/concept_check.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/concept_check.hpp
rename to contrib/libboost/boost_1_65_0/boost/concept_check.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config.hpp b/contrib/libboost/boost_1_65_0/boost/config.hpp
similarity index 90%
rename from contrib/libboost/boost_1_62_0/boost/config.hpp
rename to contrib/libboost/boost_1_65_0/boost/config.hpp
index d49bb27cd5f..f00a9805790 100644
--- a/contrib/libboost/boost_1_62_0/boost/config.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config.hpp
@@ -32,7 +32,7 @@
 
 // if we don't have a compiler config set, try and find one:
 #if !defined(BOOST_COMPILER_CONFIG) && !defined(BOOST_NO_COMPILER_CONFIG) && !defined(BOOST_NO_CONFIG)
-#  include <boost/config/select_compiler_config.hpp>
+#  include <boost/config/detail/select_compiler_config.hpp>
 #endif
 // if we have a compiler config, include it now:
 #ifdef BOOST_COMPILER_CONFIG
@@ -41,7 +41,7 @@
 
 // if we don't have a std library config set, try and find one:
 #if !defined(BOOST_STDLIB_CONFIG) && !defined(BOOST_NO_STDLIB_CONFIG) && !defined(BOOST_NO_CONFIG) && defined(__cplusplus)
-#  include <boost/config/select_stdlib_config.hpp>
+#  include <boost/config/detail/select_stdlib_config.hpp>
 #endif
 // if we have a std library config, include it now:
 #ifdef BOOST_STDLIB_CONFIG
@@ -50,7 +50,7 @@
 
 // if we don't have a platform config set, try and find one:
 #if !defined(BOOST_PLATFORM_CONFIG) && !defined(BOOST_NO_PLATFORM_CONFIG) && !defined(BOOST_NO_CONFIG)
-#  include <boost/config/select_platform_config.hpp>
+#  include <boost/config/detail/select_platform_config.hpp>
 #endif
 // if we have a platform config, include it now:
 #ifdef BOOST_PLATFORM_CONFIG
@@ -58,7 +58,7 @@
 #endif
 
 // get config suffix code:
-#include <boost/config/suffix.hpp>
+#include <boost/config/detail/suffix.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
diff --git a/contrib/libboost/boost_1_62_0/boost/config/abi/borland_prefix.hpp b/contrib/libboost/boost_1_65_0/boost/config/abi/borland_prefix.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/abi/borland_prefix.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/abi/borland_prefix.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/abi/borland_suffix.hpp b/contrib/libboost/boost_1_65_0/boost/config/abi/borland_suffix.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/abi/borland_suffix.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/abi/borland_suffix.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/abi/msvc_prefix.hpp b/contrib/libboost/boost_1_65_0/boost/config/abi/msvc_prefix.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/abi/msvc_prefix.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/abi/msvc_prefix.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/abi/msvc_suffix.hpp b/contrib/libboost/boost_1_65_0/boost/config/abi/msvc_suffix.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/abi/msvc_suffix.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/abi/msvc_suffix.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/abi_prefix.hpp b/contrib/libboost/boost_1_65_0/boost/config/abi_prefix.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/abi_prefix.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/abi_prefix.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/abi_suffix.hpp b/contrib/libboost/boost_1_65_0/boost/config/abi_suffix.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/abi_suffix.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/abi_suffix.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/auto_link.hpp b/contrib/libboost/boost_1_65_0/boost/config/auto_link.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/config/auto_link.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/auto_link.hpp
index 56a16b0b389..c71e8035dda 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/auto_link.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/auto_link.hpp
@@ -161,10 +161,15 @@ BOOST_LIB_VERSION:    The Boost version, in the form x_y, for Boost version x.y.
      // vc12:
 #    define BOOST_LIB_TOOLSET "vc120"
 
-# elif defined(BOOST_MSVC)
+#  elif defined(BOOST_MSVC) && (BOOST_MSVC < 1910)
 
-   // vc14:
-#  define BOOST_LIB_TOOLSET "vc140"
+     // vc14:
+#    define BOOST_LIB_TOOLSET "vc140"
+
+#  elif defined(BOOST_MSVC)
+
+     // vc14.1:
+#    define BOOST_LIB_TOOLSET "vc141"
 
 #  elif defined(__BORLANDC__)
 
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/borland.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/borland.hpp
similarity index 95%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/borland.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/borland.hpp
index ccd930ea53a..fa891def419 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/compiler/borland.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/borland.hpp
@@ -185,6 +185,7 @@
 #define BOOST_NO_CXX11_RVALUE_REFERENCES
 #define BOOST_NO_CXX11_SCOPED_ENUMS
 #define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_SFINAE_EXPR
 #define BOOST_NO_CXX11_TEMPLATE_ALIASES
 #define BOOST_NO_CXX11_UNICODE_LITERALS    // UTF-8 still not supported
 #define BOOST_NO_CXX11_VARIADIC_TEMPLATES
@@ -227,6 +228,17 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
 #if __BORLANDC__ >= 0x590
 #  define BOOST_HAS_TR1_HASH
 
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/clang.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/clang.hpp
similarity index 92%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/clang.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/clang.hpp
index 150e3c0d521..157a94d267e 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/compiler/clang.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/clang.hpp
@@ -27,6 +27,10 @@
 #define __has_attribute(x) 0
 #endif
 
+#ifndef __has_cpp_attribute
+#define __has_cpp_attribute(x) 0
+#endif
+
 #if !__has_feature(cxx_exceptions) && !defined(BOOST_NO_EXCEPTIONS)
 #  define BOOST_NO_EXCEPTIONS
 #endif
@@ -57,7 +61,7 @@
 #define BOOST_HAS_NRVO
 
 // Branch prediction hints
-#if defined(__has_builtin)
+#if !defined (__c2__) && defined(__has_builtin)
 #if __has_builtin(__builtin_expect)
 #define BOOST_LIKELY(x) __builtin_expect(x, 1)
 #define BOOST_UNLIKELY(x) __builtin_expect(x, 0)
@@ -282,6 +286,20 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+
+// Clang 3.9+ in c++1z
+#if !__has_cpp_attribute(fallthrough) || __cplusplus < 201406L
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
+#if __cplusplus < 201103L
+#define BOOST_NO_CXX11_SFINAE_EXPR
+#endif
+
 #if __cplusplus < 201400
 // All versions with __cplusplus above this value seem to support this:
 #  define BOOST_NO_CXX14_DIGIT_SEPARATORS
@@ -292,6 +310,11 @@
 #define BOOST_UNREACHABLE_RETURN(x) __builtin_unreachable();
 #endif
 
+#if (__clang_major__ == 3) && (__clang_minor__ == 0)
+// Apparently a clang bug:
+#  define BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
+#endif
+
 // Clang has supported the 'unused' attribute since the first release.
 #define BOOST_ATTRIBUTE_UNUSED __attribute__((__unused__))
 
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/codegear.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/codegear.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/codegear.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/codegear.hpp
index e2f6061b373..44ca8428e47 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/compiler/codegear.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/codegear.hpp
@@ -112,6 +112,7 @@
 #define BOOST_NO_CXX11_RAW_LITERALS
 #define BOOST_NO_CXX11_RVALUE_REFERENCES
 #define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_SFINAE_EXPR
 #define BOOST_NO_CXX11_TEMPLATE_ALIASES
 #define BOOST_NO_CXX11_UNICODE_LITERALS
 #define BOOST_NO_CXX11_VARIADIC_TEMPLATES
@@ -153,6 +154,19 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
 //
 // TR1 macros:
 //
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/comeau.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/comeau.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/comeau.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/comeau.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/common_edg.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/common_edg.hpp
similarity index 91%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/common_edg.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/common_edg.hpp
index c09faeb0dd9..d49ceb68e2b 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/compiler/common_edg.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/common_edg.hpp
@@ -95,6 +95,7 @@
 #define BOOST_NO_CXX11_RVALUE_REFERENCES
 #define BOOST_NO_CXX11_SCOPED_ENUMS
 #define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_SFINAE_EXPR
 #define BOOST_NO_CXX11_STATIC_ASSERT
 #define BOOST_NO_CXX11_TEMPLATE_ALIASES
 #define BOOST_NO_CXX11_UNICODE_LITERALS
@@ -137,6 +138,17 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
 #ifdef c_plusplus
 // EDG has "long long" in non-strict mode
 // However, some libraries have insufficient "long long" support
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/compaq_cxx.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/compaq_cxx.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/compaq_cxx.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/compaq_cxx.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/cray.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/cray.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/cray.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/cray.hpp
index 837f815234a..eab52877517 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/compiler/cray.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/cray.hpp
@@ -39,6 +39,7 @@
 #define BOOST_NO_CXX11_TEMPLATE_ALIASES
 #define BOOST_NO_CXX11_STATIC_ASSERT
 #define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_SFINAE_EXPR
 #define BOOST_NO_CXX11_SCOPED_ENUMS
 #define BOOST_NO_CXX11_RVALUE_REFERENCES
 #define BOOST_NO_CXX11_RANGE_BASED_FOR
diff --git a/contrib/libboost/boost_1_65_0/boost/config/compiler/diab.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/diab.hpp
new file mode 100644
index 00000000000..0de72d06aa6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/diab.hpp
@@ -0,0 +1,19 @@
+//  (C) Copyright Brian Kuhl 2016.
+//  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)
+
+// Check this is a recent EDG based compiler, otherwise we don't support it here:
+
+
+#ifndef __EDG_VERSION__
+#     error "Unknown Diab compiler version - please run the configure tests and report the results"
+#endif
+
+#include "boost/config/compiler/common_edg.hpp"
+
+#define BOOST_HAS_LONG_LONG
+#define BOOST_NO_TWO_PHASE_NAME_LOOKUP
+#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#define BOOST_NO_CXX11_HDR_CODECVT
+#define BOOST_COMPILER "Wind River Diab " BOOST_STRINGIZE(__VERSION_NUMBER__)
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/digitalmars.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/digitalmars.hpp
similarity index 90%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/digitalmars.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/digitalmars.hpp
index c344aae0442..e4c5afddd2d 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/compiler/digitalmars.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/digitalmars.hpp
@@ -71,6 +71,7 @@
 #define BOOST_NO_CXX11_RVALUE_REFERENCES
 #define BOOST_NO_CXX11_SCOPED_ENUMS
 #define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_SFINAE_EXPR
 #define BOOST_NO_CXX11_STATIC_ASSERT
 #define BOOST_NO_CXX11_TEMPLATE_ALIASES
 #define BOOST_NO_CXX11_UNICODE_LITERALS
@@ -113,6 +114,17 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
 #if (__DMC__ <= 0x840)
 #error "Compiler not supported or configured - please reconfigure"
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/gcc.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/gcc.hpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/gcc.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/gcc.hpp
index e319d049580..d1cfed7a323 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/compiler/gcc.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/gcc.hpp
@@ -253,6 +253,7 @@
 #if (BOOST_GCC_VERSION < 40800) || !defined(BOOST_GCC_CXX11)
 #  define BOOST_NO_CXX11_ALIGNAS
 #  define BOOST_NO_CXX11_THREAD_LOCAL
+#  define BOOST_NO_CXX11_SFINAE_EXPR
 #endif
 
 // C++0x features in 4.8.1 and later
@@ -287,6 +288,28 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
+#if __GNUC__ >= 7
+#  define BOOST_FALLTHROUGH __attribute__((fallthrough))
+#endif
+
+#ifdef __MINGW32__
+// Currently (June 2017) thread_local is broken on mingw for all current compiler releases, see
+// https://sourceforge.net/p/mingw-w64/bugs/527/
+// Not setting this causes program termination on thread exit.
+#define BOOST_NO_CXX11_THREAD_LOCAL
+#endif
+
 //
 // Unused attribute:
 #if __GNUC__ >= 4
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/gcc_xml.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/gcc_xml.hpp
similarity index 88%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/gcc_xml.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/gcc_xml.hpp
index b56c78628cd..2b47585ab86 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/compiler/gcc_xml.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/gcc_xml.hpp
@@ -46,6 +46,7 @@
 #  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
 #  define BOOST_NO_CXX11_SCOPED_ENUMS
 #  define BOOST_NO_SFINAE_EXPR
+#  define BOOST_NO_CXX11_SFINAE_EXPR
 #  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
 #  define BOOST_NO_CXX11_LAMBDAS
 #  define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
@@ -91,6 +92,17 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
 #define BOOST_COMPILER "GCC-XML C++ version " __GCCXML__
 
 
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/greenhills.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/greenhills.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/greenhills.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/greenhills.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/hp_acc.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/hp_acc.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/hp_acc.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/hp_acc.hpp
index a773b8c442e..9df18eaf672 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/compiler/hp_acc.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/hp_acc.hpp
@@ -114,6 +114,7 @@
 #define BOOST_NO_CXX11_RVALUE_REFERENCES
 #define BOOST_NO_CXX11_SCOPED_ENUMS
 #define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_SFINAE_EXPR
 #define BOOST_NO_CXX11_STATIC_ASSERT
 #define BOOST_NO_CXX11_TEMPLATE_ALIASES
 #define BOOST_NO_CXX11_UNICODE_LITERALS
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/intel.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/intel.hpp
similarity index 96%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/intel.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/intel.hpp
index 80969e9edd2..f55189a0ab9 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/compiler/intel.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/intel.hpp
@@ -35,15 +35,24 @@
 
 #endif
 
-#else
+#if (__INTEL_COMPILER <= 1600) && !defined(BOOST_NO_CXX14_VARIABLE_TEMPLATES)
+#  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
+#endif
+
+#else // defined(_MSC_VER)
 
 #include <boost/config/compiler/gcc.hpp>
 
 #undef BOOST_GCC_VERSION
 #undef BOOST_GCC_CXX11
 
+// Broken in all versions up to 17 (newer versions not tested)
+#if (__INTEL_COMPILER <= 1700) && !defined(BOOST_NO_CXX14_CONSTEXPR)
+#  define BOOST_NO_CXX14_CONSTEXPR
 #endif
 
+#endif // defined(_MSC_VER)
+
 #undef BOOST_COMPILER
 
 #if defined(__INTEL_COMPILER)
@@ -88,7 +97,7 @@
 #  define BOOST_INTEL_LINUX BOOST_INTEL
 #endif
 
-#else
+#else // defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1500) && (defined(_MSC_VER) || defined(__GNUC__))
 
 #include <boost/config/compiler/common_edg.hpp>
 
@@ -406,6 +415,11 @@ template<> struct assert_intrinsic_wchar_t<unsigned short> {};
 #  undef BOOST_NO_SFINAE_EXPR
 #endif
 
+// BOOST_NO_CXX11_SFINAE_EXPR
+#if (BOOST_INTEL_CXX_VERSION >= 1500) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40800)) && !defined(_MSC_VER)
+#  undef BOOST_NO_CXX11_SFINAE_EXPR
+#endif
+
 // BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
 #if (BOOST_INTEL_CXX_VERSION >= 1500) && (!defined(BOOST_INTEL_GCC_VERSION) || (BOOST_INTEL_GCC_VERSION >= 40500)) && (!defined(_MSC_VER) || (_MSC_FULL_VER >= 180020827))
 // This is available in earlier Intel releases, but breaks Multiprecision:
@@ -479,7 +493,7 @@ template<> struct assert_intrinsic_wchar_t<unsigned short> {};
 #  undef BOOST_NO_CXX11_FINAL
 #endif
 
-#endif
+#endif // defined(BOOST_INTEL_STDCXX0X)
 
 //
 // Broken in all versions up to 15:
@@ -526,10 +540,10 @@ template<> struct assert_intrinsic_wchar_t<unsigned short> {};
 #  define BOOST_HAS_INT128
 #endif
 
-#endif
+#endif // defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 1500) && (defined(_MSC_VER) || defined(__GNUC__))
 //
 // last known and checked version:
-#if (BOOST_INTEL_CXX_VERSION > 1500)
+#if (BOOST_INTEL_CXX_VERSION > 1700)
 #  if defined(BOOST_ASSERT_CONFIG)
 #     error "Unknown compiler version - please run the configure tests and report the results"
 #  elif defined(_MSC_VER)
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/kai.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/kai.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/kai.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/kai.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/metrowerks.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/metrowerks.hpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/metrowerks.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/metrowerks.hpp
index 3c5e22868a4..99ff0f5eeaf 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/compiler/metrowerks.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/metrowerks.hpp
@@ -113,6 +113,7 @@
 #define BOOST_NO_CXX11_RAW_LITERALS
 #define BOOST_NO_CXX11_SCOPED_ENUMS
 #define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_SFINAE_EXPR
 #define BOOST_NO_CXX11_STATIC_ASSERT
 #define BOOST_NO_CXX11_TEMPLATE_ALIASES
 #define BOOST_NO_CXX11_UNICODE_LITERALS
@@ -156,6 +157,17 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
 #define BOOST_COMPILER "Metrowerks CodeWarrior C++ version " BOOST_STRINGIZE(BOOST_COMPILER_VERSION)
 
 //
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/mpw.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/mpw.hpp
similarity index 90%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/mpw.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/mpw.hpp
index 084f9e154fe..d9544345ac0 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/compiler/mpw.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/mpw.hpp
@@ -62,6 +62,7 @@
 #define BOOST_NO_CXX11_RVALUE_REFERENCES
 #define BOOST_NO_CXX11_SCOPED_ENUMS
 #define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_SFINAE_EXPR
 #define BOOST_NO_CXX11_STATIC_ASSERT
 #define BOOST_NO_CXX11_TEMPLATE_ALIASES
 #define BOOST_NO_CXX11_UNICODE_LITERALS
@@ -105,6 +106,17 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
 //
 // versions check:
 // we don't support MPW prior to version 8.9:
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/nvcc.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/nvcc.hpp
similarity index 57%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/nvcc.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/nvcc.hpp
index 5a047070afe..43039b5c257 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/compiler/nvcc.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/nvcc.hpp
@@ -22,3 +22,30 @@
 #if !defined(__CUDACC_VER__) || (__CUDACC_VER__ < 70500)
 #   define BOOST_NO_CXX11_VARIADIC_TEMPLATES
 #endif
+// The same bug is back again in 8.0:
+#if (__CUDACC_VER__ > 80000) && (__CUDACC_VER__ < 80100)
+#   define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#endif
+// Most recent CUDA (8.0) has no constexpr support in msvc mode:
+#if defined(_MSC_VER)
+#  define BOOST_NO_CXX11_CONSTEXPR
+#endif
+
+#ifdef __CUDACC__
+//
+// When compiing .cu files, there's a bunch of stuff that doesn't work with msvc:
+//
+#if defined(_MSC_VER)
+#  define BOOST_NO_CXX14_DIGIT_SEPARATORS
+#  define BOOST_NO_CXX11_UNICODE_LITERALS
+#endif
+//
+// And this one effects the NVCC front end,
+// See https://svn.boost.org/trac/boost/ticket/13049
+//
+#if (__CUDACC_VER__ >= 80000) && (__CUDACC_VER__ < 80100)
+#  define BOOST_NO_CXX11_NOEXCEPT
+#endif
+
+#endif
+
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/pathscale.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/pathscale.hpp
similarity index 85%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/pathscale.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/pathscale.hpp
index a5e65af49bd..94b3f91d07c 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/compiler/pathscale.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/pathscale.hpp
@@ -12,7 +12,12 @@
 #  define BOOST_COMPILER "PathScale EKOPath C++ Compiler version " __PATHSCALE__
 #endif
 
-#if __PATHCC__ >= 4
+#if __PATHCC__ >= 6 
+// PathCC is based on clang, and supports the __has_*() builtins used 
+// to detect features in clang.hpp. Since the clang toolset is much 
+// better maintained, it is more convenient to reuse its definitions. 
+#  include "boost/config/compiler/clang.hpp"
+#elif __PATHCC__ >= 4 
 #  define BOOST_MSVC6_MEMBER_TEMPLATES
 #  define BOOST_HAS_UNISTD_H
 #  define BOOST_HAS_STDINT_H
@@ -37,6 +42,7 @@
 #  define BOOST_NO_CXX11_TEMPLATE_ALIASES
 #  define BOOST_NO_CXX11_STATIC_ASSERT
 #  define BOOST_NO_SFINAE_EXPR
+#  define BOOST_NO_CXX11_SFINAE_EXPR
 #  define BOOST_NO_CXX11_SCOPED_ENUMS
 #  define BOOST_NO_CXX11_RVALUE_REFERENCES
 #  define BOOST_NO_CXX11_RANGE_BASED_FOR
@@ -112,4 +118,15 @@
 #if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
+
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/pgi.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/pgi.hpp
similarity index 92%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/pgi.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/pgi.hpp
index fa2d5e402d5..4c402ba0d6c 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/compiler/pgi.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/pgi.hpp
@@ -88,6 +88,7 @@
 #define BOOST_NO_CXX11_RVALUE_REFERENCES
 #define BOOST_NO_CXX11_SCOPED_ENUMS
 #define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_SFINAE_EXPR
 #define BOOST_NO_CXX11_STATIC_ASSERT
 #define BOOST_NO_SWPRINTF
 #define BOOST_NO_CXX11_TEMPLATE_ALIASES
@@ -150,6 +151,17 @@
 #if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
+
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
 //
 // version check:
 // probably nothing to do here?
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/sgi_mipspro.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/sgi_mipspro.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/sgi_mipspro.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/sgi_mipspro.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/sunpro_cc.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/sunpro_cc.hpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/sunpro_cc.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/sunpro_cc.hpp
index 8f07e0e9a2a..2453e7cfc1f 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/compiler/sunpro_cc.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/sunpro_cc.hpp
@@ -141,6 +141,7 @@
 //
 #  define BOOST_HAS_LONG_LONG
 
+#define BOOST_NO_CXX11_SFINAE_EXPR
 
 // C++ 14:
 #if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
@@ -152,7 +153,7 @@
 #if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
 #  define BOOST_NO_CXX14_CONSTEXPR
 #endif
-#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304)
+#if !defined(__cpp_decltype_auto) || (__cpp_decltype_auto < 201304) || (__cplusplus < 201402L)
 #  define BOOST_NO_CXX14_DECLTYPE_AUTO
 #endif
 #if (__cplusplus < 201304) // There's no SD6 check for this....
@@ -171,6 +172,17 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
 // Turn on threading support for Solaris 12.
 // Ticket #11972
 #if (__SUNPRO_CC >= 0x5140) && defined(__SunOS_5_12) && !defined(BOOST_HAS_THREADS)
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/vacpp.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/vacpp.hpp
similarity index 92%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/vacpp.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/vacpp.hpp
index 3fbed9fafe4..683c167dbf7 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/compiler/vacpp.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/vacpp.hpp
@@ -114,6 +114,7 @@
 #  define BOOST_NO_CXX11_SCOPED_ENUMS
 #endif
 #define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_SFINAE_EXPR
 #define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
 #if ! __IBMCPP_STATIC_ASSERT
 #  define BOOST_NO_CXX11_STATIC_ASSERT
@@ -161,3 +162,14 @@
 #if !defined(__cpp_variable_templates) || (__cpp_variable_templates < 201304)
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
+
+// C++17
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606)
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#endif
+#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603)
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/visualc.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/visualc.hpp
similarity index 91%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/visualc.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/visualc.hpp
index 72caff4974f..c0557de7123 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/compiler/visualc.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/visualc.hpp
@@ -107,7 +107,7 @@
 //
 // TR1 features:
 //
-#if _MSC_VER >= 1700
+#if (_MSC_VER >= 1700) && defined(_HAS_CXX17) && (_HAS_CXX17 > 0)
 // # define BOOST_HAS_TR1_HASH			// don't know if this is true yet.
 // # define BOOST_HAS_TR1_TYPE_TRAITS	// don't know if this is true yet.
 # define BOOST_HAS_TR1_UNORDERED_MAP
@@ -190,6 +190,12 @@
 #  define BOOST_NO_CXX11_CONSTEXPR
 #endif
 
+// C++14 features supported by VC++ 14.1 (Visual Studio 2017)
+//
+#if (_MSC_VER < 1910)
+#  define BOOST_NO_CXX14_AGGREGATE_NSDMI
+#endif
+
 // MSVC including version 14 has not yet completely
 // implemented value-initialization, as is reported:
 // "VC++ does not value-initialize members of derived classes without
@@ -210,13 +216,32 @@
 // C++ 11:
 //
 #define BOOST_NO_TWO_PHASE_NAME_LOOKUP
-//
+#define BOOST_NO_CXX11_SFINAE_EXPR
 // C++ 14:
-#if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304)
-#  define BOOST_NO_CXX14_AGGREGATE_NSDMI
-#endif
-#if !defined(__cpp_constexpr) || (__cpp_constexpr < 201304)
 #  define BOOST_NO_CXX14_CONSTEXPR
+// C++ 17:
+#define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#define BOOST_NO_CXX17_INLINE_VARIABLES
+#define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+
+//
+// Things that don't work in clr mode:
+//
+#ifdef _M_CEE
+#ifndef BOOST_NO_CXX11_THREAD_LOCAL
+#  define BOOST_NO_CXX11_THREAD_LOCAL
+#endif
+#ifndef BOOST_NO_SFINAE_EXPR
+#  define BOOST_NO_SFINAE_EXPR
+#endif
+#ifndef BOOST_NO_CXX11_REF_QUALIFIERS
+#  define BOOST_NO_CXX11_REF_QUALIFIERS
+#endif
+#endif
+#ifdef _M_CEE_PURE
+#ifndef BOOST_NO_CXX11_CONSTEXPR
+#  define BOOST_NO_CXX11_CONSTEXPR
+#endif
 #endif
 
 //
@@ -283,8 +308,10 @@
 #     define BOOST_COMPILER_VERSION 11.0
 #   elif _MSC_VER < 1900
 #     define BOOST_COMPILER_VERSION 12.0
-#   elif _MSC_VER < 2000
+#   elif _MSC_VER < 1910
 #     define BOOST_COMPILER_VERSION 14.0
+#   elif _MSC_VER < 1920
+#     define BOOST_COMPILER_VERSION 14.1
 #   else
 #     define BOOST_COMPILER_VERSION _MSC_VER
 #   endif
@@ -294,8 +321,8 @@
 #endif
 
 //
-// last known and checked version is 19.00.23026 (VC++ 2015 RTM):
-#if (_MSC_VER > 1900)
+// last known and checked version is 19.10.25017 (VC++ 2017):
+#if (_MSC_VER > 1910)
 #  if defined(BOOST_ASSERT_CONFIG)
 #     error "Unknown compiler version - please run the configure tests and report the results"
 #  else
diff --git a/contrib/libboost/boost_1_62_0/boost/config/compiler/xlcpp.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/xlcpp.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/config/compiler/xlcpp.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/compiler/xlcpp.hpp
index 2aaafc3b665..b267f49bad8 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/compiler/xlcpp.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/xlcpp.hpp
@@ -23,6 +23,10 @@
 #define __has_extension __has_feature
 #endif
 
+#ifndef __has_cpp_attribute
+#define __has_cpp_attribute(x) 0
+#endif
+
 #if !__has_feature(cxx_exceptions) && !defined(BOOST_NO_EXCEPTIONS)
 #  define BOOST_NO_EXCEPTIONS
 #endif
@@ -238,6 +242,16 @@
 #  define BOOST_NO_CXX14_VARIABLE_TEMPLATES
 #endif
 
+#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606)
+#  define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#endif
+
+// Clang 3.9+ in c++1z
+#if !__has_cpp_attribute(fallthrough) || __cplusplus < 201406L
+#  define BOOST_NO_CXX17_INLINE_VARIABLES
+#  define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+#endif
+
 #if !__has_feature(cxx_thread_local)
 #  define BOOST_NO_CXX11_THREAD_LOCAL
 #endif
diff --git a/contrib/libboost/boost_1_65_0/boost/config/compiler/xlcpp_zos.hpp b/contrib/libboost/boost_1_65_0/boost/config/compiler/xlcpp_zos.hpp
new file mode 100644
index 00000000000..c554903a0ba
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/config/compiler/xlcpp_zos.hpp
@@ -0,0 +1,168 @@
+//  Copyright (c) 2017 Dynatrace
+//
+//  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.
+
+//  Compiler setup for IBM z/OS XL C/C++ compiler.
+
+// Oldest compiler version currently supported is 2.1 (V2R1)
+#if !defined(__IBMCPP__) || !defined(__COMPILER_VER__) || __COMPILER_VER__ < 0x42010000
+#  error "Compiler not supported or configured - please reconfigure"
+#endif
+
+#if __COMPILER_VER__ > 0x42010000
+#  if defined(BOOST_ASSERT_CONFIG)
+#     error "Unknown compiler version - please run the configure tests and report the results"
+#  endif
+#endif
+
+#define BOOST_COMPILER "IBM z/OS XL C/C++ version " BOOST_STRINGIZE(__COMPILER_VER__)
+#define BOOST_XLCPP_ZOS __COMPILER_VER__
+
+// -------------------------------------
+
+#include <features.h> // For __UU, __C99, __TR1, ...
+
+#if !defined(__IBMCPP_DEFAULTED_AND_DELETED_FUNCTIONS)
+#  define BOOST_NO_CXX11_DELETED_FUNCTIONS
+#  define BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+#  define BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS
+#endif
+
+// -------------------------------------
+
+#if defined(__UU) || defined(__C99) || defined(__TR1)
+#  define BOOST_HAS_LOG1P
+#  define BOOST_HAS_EXPM1
+#endif
+
+#if defined(__C99) || defined(__TR1)
+#  define BOOST_HAS_STDINT_H
+#else
+#  define BOOST_NO_FENV_H
+#endif
+
+// -------------------------------------
+
+#define BOOST_HAS_NRVO
+
+#if !defined(__RTTI_ALL__)
+#  define BOOST_NO_RTTI
+#endif
+
+#if !defined(_CPPUNWIND) && !defined(__EXCEPTIONS)
+#  define BOOST_NO_EXCEPTIONS
+#endif
+
+#if defined(_LONG_LONG) || defined(__IBMCPP_C99_LONG_LONG) || defined(__LL)
+#  define BOOST_HAS_LONG_LONG
+#else
+#  define BOOST_NO_LONG_LONG
+#endif
+
+#if defined(_LONG_LONG) || defined(__IBMCPP_C99_LONG_LONG) || defined(__LL) || defined(_LP64)
+#  define BOOST_HAS_MS_INT64
+#endif
+
+#define BOOST_NO_SFINAE_EXPR
+#define BOOST_NO_CXX11_SFINAE_EXPR
+
+#if defined(__IBMCPP_VARIADIC_TEMPLATES)
+#  define BOOST_HAS_VARIADIC_TMPL
+#else
+#  define BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#  define BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS
+#endif
+
+#if defined(__IBMCPP_STATIC_ASSERT)
+#  define BOOST_HAS_STATIC_ASSERT
+#else
+#  define BOOST_NO_CXX11_STATIC_ASSERT
+#endif
+
+#if defined(__IBMCPP_RVALUE_REFERENCES)
+#  define BOOST_HAS_RVALUE_REFS
+#else
+#  define BOOST_NO_CXX11_RVALUE_REFERENCES
+#endif
+
+#if !defined(__IBMCPP_SCOPED_ENUM)
+#  define BOOST_NO_CXX11_SCOPED_ENUMS
+#endif
+
+#define BOOST_NO_CXX11_FIXED_LENGTH_VARIADIC_TEMPLATE_EXPANSION_PACKS
+#define BOOST_NO_CXX11_TEMPLATE_ALIASES
+#define BOOST_NO_CXX11_LOCAL_CLASS_TEMPLATE_PARAMETERS
+
+#if !defined(__IBMCPP_EXPLICIT_CONVERSION_OPERATORS)
+#  define BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+#endif
+
+#if !defined(__IBMCPP_DECLTYPE)
+#  define BOOST_NO_CXX11_DECLTYPE
+#else
+#  define BOOST_HAS_DECLTYPE
+#endif
+#define BOOST_NO_CXX11_DECLTYPE_N3276
+
+#if !defined(__IBMCPP_INLINE_NAMESPACE)
+#  define BOOST_NO_CXX11_INLINE_NAMESPACES
+#endif
+
+#if !defined(__IBMCPP_AUTO_TYPEDEDUCTION)
+#  define BOOST_NO_CXX11_AUTO_MULTIDECLARATIONS
+#  define BOOST_NO_CXX11_AUTO_DECLARATIONS
+#  define BOOST_NO_CXX11_TRAILING_RESULT_TYPES
+#endif
+
+#if !defined(__IBM_CHAR32_T__)
+#  define BOOST_NO_CXX11_CHAR32_T
+#endif
+#if !defined(__IBM_CHAR16_T__)
+#  define BOOST_NO_CXX11_CHAR16_T
+#endif
+
+#if !defined(__IBMCPP_CONSTEXPR)
+#  define BOOST_NO_CXX11_CONSTEXPR
+#endif
+
+#define BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+#define BOOST_NO_CXX11_UNICODE_LITERALS
+#define BOOST_NO_CXX11_RAW_LITERALS
+#define BOOST_NO_CXX11_RANGE_BASED_FOR
+#define BOOST_NO_CXX11_NULLPTR
+#define BOOST_NO_CXX11_NOEXCEPT
+#define BOOST_NO_CXX11_LAMBDAS
+#define BOOST_NO_CXX11_USER_DEFINED_LITERALS
+#define BOOST_NO_CXX11_THREAD_LOCAL
+#define BOOST_NO_CXX11_REF_QUALIFIERS
+#define BOOST_NO_CXX11_FINAL
+#define BOOST_NO_CXX11_ALIGNAS
+#define BOOST_NO_CXX14_VARIABLE_TEMPLATES
+#define BOOST_NO_CXX14_RETURN_TYPE_DEDUCTION
+#define BOOST_NO_CXX14_AGGREGATE_NSDMI
+#define BOOST_NO_CXX14_INITIALIZED_LAMBDA_CAPTURES
+#define BOOST_NO_CXX14_GENERIC_LAMBDAS
+#define BOOST_NO_CXX14_DIGIT_SEPARATORS
+#define BOOST_NO_CXX14_DECLTYPE_AUTO
+#define BOOST_NO_CXX14_CONSTEXPR
+#define BOOST_NO_CXX14_BINARY_LITERALS
+#define BOOST_NO_CXX17_STRUCTURED_BINDINGS
+#define BOOST_NO_CXX17_INLINE_VARIABLES
+#define BOOST_NO_CXX17_FOLD_EXPRESSIONS
+
+// -------------------------------------
+
+#if defined(__IBM_ATTRIBUTES)
+#  define BOOST_FORCEINLINE inline __attribute__ ((__always_inline__))
+#  define BOOST_NOINLINE __attribute__ ((__noinline__))
+// No BOOST_ALIGNMENT - explicit alignment support is broken (V2R1).
+#endif
+
+extern "builtin" long __builtin_expect(long, long);
+
+#define BOOST_LIKELY(x) __builtin_expect((x) && true, 1)
+#define BOOST_UNLIKELY(x) __builtin_expect((x) && true, 0)
diff --git a/contrib/libboost/boost_1_62_0/boost/config/posix_features.hpp b/contrib/libboost/boost_1_65_0/boost/config/detail/posix_features.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/posix_features.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/detail/posix_features.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/select_compiler_config.hpp b/contrib/libboost/boost_1_65_0/boost/config/detail/select_compiler_config.hpp
similarity index 92%
rename from contrib/libboost/boost_1_62_0/boost/config/select_compiler_config.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/detail/select_compiler_config.hpp
index 7a757084281..97d47c1c56e 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/select_compiler_config.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/detail/select_compiler_config.hpp
@@ -48,6 +48,10 @@
 //  Digital Mars C++
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/digitalmars.hpp"
 
+#elif defined __DCC__
+//  Wind River Diab C++
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/diab.hpp"
+
 # elif defined(__GNUC__) && !defined(__ibmxl__)
 //  GNU C++:
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/gcc.hpp"
@@ -92,8 +96,12 @@
 //  MPW MrCpp or SCpp
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/mpw.hpp"
 
+#elif defined(__IBMCPP__) && defined(__COMPILER_VER__) && defined(__MVS__)
+//  IBM z/OS XL C/C++
+#   define BOOST_COMPILER_CONFIG "boost/config/compiler/xlcpp_zos.hpp"
+
 #elif defined(__ibmxl__)
-// IBM XL C/C++ for Linux (Little Endian)
+//  IBM XL C/C++ for Linux (Little Endian)
 #   define BOOST_COMPILER_CONFIG "boost/config/compiler/xlcpp.hpp"
 
 #elif defined(__IBMCPP__)
@@ -140,6 +148,8 @@
 #include <boost/config/compiler/sunpro_cc.hpp>
 #include <boost/config/compiler/hp_acc.hpp>
 #include <boost/config/compiler/mpw.hpp>
+#include <boost/config/compiler/xlcpp_zos.hpp>
+#include <boost/config/compiler/xlcpp.hpp>
 #include <boost/config/compiler/vacpp.hpp>
 #include <boost/config/compiler/pgi.hpp>
 #include <boost/config/compiler/visualc.hpp>
diff --git a/contrib/libboost/boost_1_62_0/boost/config/select_platform_config.hpp b/contrib/libboost/boost_1_65_0/boost/config/detail/select_platform_config.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/config/select_platform_config.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/detail/select_platform_config.hpp
index 62fd818b935..b36eca57a24 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/select_platform_config.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/detail/select_platform_config.hpp
@@ -53,8 +53,12 @@
 // MacOS
 #  define BOOST_PLATFORM_CONFIG "boost/config/platform/macos.hpp"
 
+#elif defined(__TOS_MVS__)
+// IBM z/OS
+#  define BOOST_PLATFORM_CONFIG "boost/config/platform/zos.hpp"
+
 #elif defined(__IBMCPP__) || defined(_AIX)
-// IBM
+// IBM AIX
 #  define BOOST_PLATFORM_CONFIG "boost/config/platform/aix.hpp"
 
 #elif defined(__amigaos__)
@@ -97,7 +101,7 @@
 #     define BOOST_HAS_UNISTD_H
 #  endif
 
-#  include <boost/config/posix_features.hpp>
+#  include <boost/config/detail/posix_features.hpp>
 
 #  endif
 
@@ -122,6 +126,7 @@
 #  include "boost/config/platform/win32.hpp"
 #  include "boost/config/platform/beos.hpp"
 #  include "boost/config/platform/macos.hpp"
+#  include "boost/config/platform/zos.hpp"
 #  include "boost/config/platform/aix.hpp"
 #  include "boost/config/platform/amigaos.hpp"
 #  include "boost/config/platform/qnxnto.hpp"
@@ -129,7 +134,7 @@
 #  include "boost/config/platform/symbian.hpp" 
 #  include "boost/config/platform/cray.hpp" 
 #  include "boost/config/platform/vms.hpp" 
-#  include <boost/config/posix_features.hpp>
+#  include <boost/config/detail/posix_features.hpp>
 
 
 
diff --git a/contrib/libboost/boost_1_62_0/boost/config/select_stdlib_config.hpp b/contrib/libboost/boost_1_65_0/boost/config/detail/select_stdlib_config.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/config/select_stdlib_config.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/detail/select_stdlib_config.hpp
index e270a8813a7..8db778c86ba 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/select_stdlib_config.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/detail/select_stdlib_config.hpp
@@ -66,6 +66,10 @@
 // MSL standard lib:
 #  define BOOST_STDLIB_CONFIG "boost/config/stdlib/msl.hpp"
 
+#elif defined(__IBMCPP__) && defined(__COMPILER_VER__) && defined(__MVS__)
+// IBM z/OS XL C/C++
+#  define BOOST_STDLIB_CONFIG "boost/config/stdlib/xlcpp_zos.hpp"
+
 #elif defined(__IBMCPP__)
 // take the default VACPP std lib
 #  define BOOST_STDLIB_CONFIG "boost/config/stdlib/vacpp.hpp"
@@ -98,6 +102,7 @@
 #  include "boost/config/stdlib/libstdcpp3.hpp"
 #  include "boost/config/stdlib/sgi.hpp"
 #  include "boost/config/stdlib/msl.hpp"
+#  include "boost/config/stdlib/xlcpp_zos.hpp"
 #  include "boost/config/stdlib/vacpp.hpp"
 #  include "boost/config/stdlib/modena.hpp"
 #  include "boost/config/stdlib/dinkumware.hpp"
diff --git a/contrib/libboost/boost_1_62_0/boost/config/suffix.hpp b/contrib/libboost/boost_1_65_0/boost/config/detail/suffix.hpp
similarity index 96%
rename from contrib/libboost/boost_1_62_0/boost/config/suffix.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/detail/suffix.hpp
index eeaec2bf693..6abec22f58f 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/suffix.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/detail/suffix.hpp
@@ -583,6 +583,25 @@ namespace std{ using ::type_info; }
 #  define BOOST_GPU_ENABLED
 #  endif
 
+// BOOST_RESTRICT ---------------------------------------------//
+// Macro to use in place of 'restrict' keyword variants
+#if !defined(BOOST_RESTRICT)
+#  if defined(_MSC_VER)
+#    define BOOST_RESTRICT __restrict
+#    if !defined(BOOST_NO_RESTRICT_REFERENCES) && (_MSC_FULL_VER < 190023026)
+#      define BOOST_NO_RESTRICT_REFERENCES
+#    endif
+#  elif defined(__GNUC__) && __GNUC__ > 3
+     // Clang also defines __GNUC__ (as 4)
+#    define BOOST_RESTRICT __restrict__
+#  else
+#    define BOOST_RESTRICT
+#    if !defined(BOOST_NO_RESTRICT_REFERENCES)
+#      define BOOST_NO_RESTRICT_REFERENCES
+#    endif
+#  endif
+#endif
+
 // BOOST_FORCEINLINE ---------------------------------------------//
 // Macro to use in place of 'inline' to force a function to be inline
 #if !defined(BOOST_FORCEINLINE)
@@ -604,7 +623,7 @@ namespace std{ using ::type_info; }
 #  elif defined(__GNUC__) && __GNUC__ > 3
      // Clang also defines __GNUC__ (as 4)
 #    if defined(__CUDACC__)
-       // nvcc doesn't always parse __noinline__, 
+       // nvcc doesn't always parse __noinline__,
        // see: https://svn.boost.org/trac/boost/ticket/9392
 #      define BOOST_NOINLINE __attribute__ ((noinline))
 #    else
@@ -624,7 +643,7 @@ namespace std{ using ::type_info; }
 #    define BOOST_NORETURN __declspec(noreturn)
 #  elif defined(__GNUC__)
 #    define BOOST_NORETURN __attribute__ ((__noreturn__))
-#  elif defined(__has_attribute) && defined(__SUNPRO_CC)
+#  elif defined(__has_attribute) && defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x5130)
 #    if __has_attribute(noreturn)
 #      define BOOST_NORETURN [[noreturn]]
 #    endif
@@ -657,15 +676,17 @@ namespace std{ using ::type_info; }
 
 // Type and data alignment specification
 //
-#if !defined(BOOST_NO_CXX11_ALIGNAS)
-#  define BOOST_ALIGNMENT(x) alignas(x)
-#elif defined(_MSC_VER)
-#  define BOOST_ALIGNMENT(x) __declspec(align(x))
-#elif defined(__GNUC__)
-#  define BOOST_ALIGNMENT(x) __attribute__ ((__aligned__(x)))
-#else
-#  define BOOST_NO_ALIGNMENT
-#  define BOOST_ALIGNMENT(x)
+#if !defined(BOOST_ALIGNMENT)
+#  if !defined(BOOST_NO_CXX11_ALIGNAS)
+#    define BOOST_ALIGNMENT(x) alignas(x)
+#  elif defined(_MSC_VER)
+#    define BOOST_ALIGNMENT(x) __declspec(align(x))
+#  elif defined(__GNUC__)
+#    define BOOST_ALIGNMENT(x) __attribute__ ((__aligned__(x)))
+#  else
+#    define BOOST_NO_ALIGNMENT
+#    define BOOST_ALIGNMENT(x)
+#  endif
 #endif
 
 // Lack of non-public defaulted functions is implied by the lack of any defaulted functions
diff --git a/contrib/libboost/boost_1_62_0/boost/config/no_tr1/cmath.hpp b/contrib/libboost/boost_1_65_0/boost/config/no_tr1/cmath.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/no_tr1/cmath.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/no_tr1/cmath.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/no_tr1/complex.hpp b/contrib/libboost/boost_1_65_0/boost/config/no_tr1/complex.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/no_tr1/complex.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/no_tr1/complex.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/no_tr1/functional.hpp b/contrib/libboost/boost_1_65_0/boost/config/no_tr1/functional.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/no_tr1/functional.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/no_tr1/functional.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/no_tr1/memory.hpp b/contrib/libboost/boost_1_65_0/boost/config/no_tr1/memory.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/no_tr1/memory.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/no_tr1/memory.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/no_tr1/utility.hpp b/contrib/libboost/boost_1_65_0/boost/config/no_tr1/utility.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/no_tr1/utility.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/no_tr1/utility.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/platform/aix.hpp b/contrib/libboost/boost_1_65_0/boost/config/platform/aix.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/config/platform/aix.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/platform/aix.hpp
index 894ef42ce91..a48e2320618 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/platform/aix.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/platform/aix.hpp
@@ -26,7 +26,7 @@
 //#define BOOST_HAS_PTHREAD_YIELD
 
 // boilerplate code:
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
 
 
 
diff --git a/contrib/libboost/boost_1_62_0/boost/config/platform/amigaos.hpp b/contrib/libboost/boost_1_65_0/boost/config/platform/amigaos.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/platform/amigaos.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/platform/amigaos.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/platform/beos.hpp b/contrib/libboost/boost_1_65_0/boost/config/platform/beos.hpp
similarity index 91%
rename from contrib/libboost/boost_1_62_0/boost/config/platform/beos.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/platform/beos.hpp
index 48c3d8dc5ba..6158c1c20be 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/platform/beos.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/platform/beos.hpp
@@ -20,7 +20,7 @@
 #endif
 
 // boilerplate code:
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
  
 
 
diff --git a/contrib/libboost/boost_1_62_0/boost/config/platform/bsd.hpp b/contrib/libboost/boost_1_65_0/boost/config/platform/bsd.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/config/platform/bsd.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/platform/bsd.hpp
index a0142978eb7..79e74a080a8 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/platform/bsd.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/platform/bsd.hpp
@@ -77,7 +77,7 @@
 
 // boilerplate code:
 #define BOOST_HAS_UNISTD_H
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
 
 
 
diff --git a/contrib/libboost/boost_1_62_0/boost/config/platform/cloudabi.hpp b/contrib/libboost/boost_1_65_0/boost/config/platform/cloudabi.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/platform/cloudabi.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/platform/cloudabi.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/platform/cray.hpp b/contrib/libboost/boost_1_65_0/boost/config/platform/cray.hpp
similarity index 89%
rename from contrib/libboost/boost_1_62_0/boost/config/platform/cray.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/platform/cray.hpp
index 5c476e4160c..103e9c06204 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/platform/cray.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/platform/cray.hpp
@@ -12,7 +12,7 @@
 
 // boilerplate code:
 #define BOOST_HAS_UNISTD_H
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
 
 
 
diff --git a/contrib/libboost/boost_1_62_0/boost/config/platform/cygwin.hpp b/contrib/libboost/boost_1_65_0/boost/config/platform/cygwin.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/config/platform/cygwin.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/platform/cygwin.hpp
index b7ef572fa64..8ecc4a4af5c 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/platform/cygwin.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/platform/cygwin.hpp
@@ -23,7 +23,7 @@
 #  define BOOST_HAS_SCHED_YIELD
 #  define BOOST_HAS_GETTIMEOFDAY
 #  define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
-#  define BOOST_HAS_SIGACTION
+//#  define BOOST_HAS_SIGACTION
 #else
 #  if !defined(BOOST_HAS_WINTHREADS)
 #     define BOOST_HAS_WINTHREADS
@@ -43,7 +43,7 @@
 #define BOOST_NO_FENV_H
 
 // boilerplate code:
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
 
 //
 // Cygwin lies about XSI conformance, there is no nl_types.h:
@@ -51,7 +51,6 @@
 #ifdef BOOST_HAS_NL_TYPES_H
 #  undef BOOST_HAS_NL_TYPES_H
 #endif
- 
 
 
 
diff --git a/contrib/libboost/boost_1_62_0/boost/config/platform/haiku.hpp b/contrib/libboost/boost_1_65_0/boost/config/platform/haiku.hpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/boost/config/platform/haiku.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/platform/haiku.hpp
index 750866c47db..04244c5677f 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/platform/haiku.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/platform/haiku.hpp
@@ -28,4 +28,4 @@
 #define BOOST_HAS_GETTIMEOFDAY
 
 // boilerplate code:
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
diff --git a/contrib/libboost/boost_1_62_0/boost/config/platform/hpux.hpp b/contrib/libboost/boost_1_65_0/boost/config/platform/hpux.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/config/platform/hpux.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/platform/hpux.hpp
index 19ce68e5973..222622e7ee5 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/platform/hpux.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/platform/hpux.hpp
@@ -43,7 +43,7 @@
 
 // boilerplate code:
 #define BOOST_HAS_UNISTD_H
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
 
 // the following are always available:
 #ifndef BOOST_HAS_GETTIMEOFDAY
diff --git a/contrib/libboost/boost_1_62_0/boost/config/platform/irix.hpp b/contrib/libboost/boost_1_65_0/boost/config/platform/irix.hpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/boost/config/platform/irix.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/platform/irix.hpp
index aeae49c8b49..0acb651552e 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/platform/irix.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/platform/irix.hpp
@@ -25,7 +25,7 @@
 
 // boilerplate code:
 #define BOOST_HAS_UNISTD_H
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
 
 
 
diff --git a/contrib/libboost/boost_1_62_0/boost/config/platform/linux.hpp b/contrib/libboost/boost_1_65_0/boost/config/platform/linux.hpp
similarity index 89%
rename from contrib/libboost/boost_1_62_0/boost/config/platform/linux.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/platform/linux.hpp
index 8c43c7b6d3c..c4eef8f80cb 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/platform/linux.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/platform/linux.hpp
@@ -24,8 +24,9 @@
 #if defined(__GLIBC__) && ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 1)))
    // <stdint.h> defines int64_t unconditionally, but <sys/types.h> defines
    // int64_t only if __GNUC__.  Thus, assume a fully usable <stdint.h>
-   // only when using GCC.
-#  if defined __GNUC__
+   // only when using GCC.  Update 2017: this appears not to be the case for
+   // recent glibc releases, see bug report: https://svn.boost.org/trac/boost/ticket/13045
+#  if defined(__GNUC__) || ((__GLIBC__ > 2) || ((__GLIBC__ == 2) && (__GLIBC_MINOR__ >= 5)))
 #    define BOOST_HAS_STDINT_H
 #  endif
 #endif
@@ -71,7 +72,7 @@
 
 // boilerplate code:
 #define BOOST_HAS_UNISTD_H
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
 #if defined(__USE_GNU) && !defined(__ANDROID__) && !defined(ANDROID)
 #define BOOST_HAS_PTHREAD_YIELD
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/config/platform/macos.hpp b/contrib/libboost/boost_1_65_0/boost/config/platform/macos.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/config/platform/macos.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/platform/macos.hpp
index 5be4e3b3da2..ed7dc15f282 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/platform/macos.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/platform/macos.hpp
@@ -25,7 +25,7 @@
 // to replace the platform-native BSD one. G++ users
 // should also always be able to do this on MaxOS X.
 //
-#  include <boost/config/posix_features.hpp>
+#  include <boost/config/detail/posix_features.hpp>
 #  ifndef BOOST_HAS_STDINT_H
 #     define BOOST_HAS_STDINT_H
 #  endif
diff --git a/contrib/libboost/boost_1_62_0/boost/config/platform/qnxnto.hpp b/contrib/libboost/boost_1_65_0/boost/config/platform/qnxnto.hpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/boost/config/platform/qnxnto.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/platform/qnxnto.hpp
index b1377c8d2c3..d0298cb4ecb 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/platform/qnxnto.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/platform/qnxnto.hpp
@@ -10,7 +10,7 @@
 #define BOOST_PLATFORM "QNX"
 
 #define BOOST_HAS_UNISTD_H
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
 
 // QNX claims XOpen version 5 compatibility, but doesn't have an nl_types.h
 // or log1p and expm1:
diff --git a/contrib/libboost/boost_1_62_0/boost/config/platform/solaris.hpp b/contrib/libboost/boost_1_65_0/boost/config/platform/solaris.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/config/platform/solaris.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/platform/solaris.hpp
index 6e4efc9e56e..51ffe67f331 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/platform/solaris.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/platform/solaris.hpp
@@ -14,7 +14,7 @@
 
 // boilerplate code:
 #define BOOST_HAS_UNISTD_H
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
 
 //
 // pthreads don't actually work with gcc unless _PTHREADS is defined:
diff --git a/contrib/libboost/boost_1_62_0/boost/config/platform/symbian.hpp b/contrib/libboost/boost_1_65_0/boost/config/platform/symbian.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/config/platform/symbian.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/platform/symbian.hpp
index e02a7782dec..f814d00b5b7 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/platform/symbian.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/platform/symbian.hpp
@@ -24,7 +24,7 @@
 #include <stdlib.h>
 #endif// boilerplate code:
 #  define BOOST_HAS_UNISTD_H
-#  include <boost/config/posix_features.hpp>
+#  include <boost/config/detail/posix_features.hpp>
 // S60 SDK defines _POSIX_VERSION as POSIX.1
 #  ifndef BOOST_HAS_STDINT_H
 #    define BOOST_HAS_STDINT_H
diff --git a/contrib/libboost/boost_1_62_0/boost/config/platform/vms.hpp b/contrib/libboost/boost_1_65_0/boost/config/platform/vms.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/platform/vms.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/platform/vms.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/platform/vxworks.hpp b/contrib/libboost/boost_1_65_0/boost/config/platform/vxworks.hpp
similarity index 91%
rename from contrib/libboost/boost_1_62_0/boost/config/platform/vxworks.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/platform/vxworks.hpp
index cdda0158ad1..a7f571c4996 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/platform/vxworks.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/platform/vxworks.hpp
@@ -180,7 +180,7 @@
   // Luckily, at the moment there seems to be none!
 #endif
 
-// These #defines allow posix_features to work, since vxWorks doesn't
+// These #defines allow detail/posix_features to work, since vxWorks doesn't
 // #define them itself for DKMs (for RTPs on the contrary it does):
 #ifdef _WRS_KERNEL
 #  ifndef _POSIX_TIMERS
@@ -286,10 +286,8 @@ inline ssize_t readlink(const char*, char*, size_t){
   return -1;
 }
 
-// vxWorks claims to implement gettimeofday in sys/time.h
-// but nevertheless does not provide it! See
-// https://support.windriver.com/olsPortal/faces/maintenance/techtipDetail_noHeader.jspx?docId=16442&contentId=WR_TECHTIP_006256
-// We implement a surrogate version here via clock_gettime:
+#if (_WRS_VXWORKS_MAJOR < 7)
+
 inline int gettimeofday(struct timeval *tv, void * /*tzv*/) {
   struct timespec ts;
   clock_gettime(CLOCK_MONOTONIC, &ts);
@@ -297,6 +295,8 @@ inline int gettimeofday(struct timeval *tv, void * /*tzv*/) {
   tv->tv_usec = ts.tv_nsec / 1000;
   return 0;
 }
+#endif
+
 
 // vxWorks does provide neither struct tms nor function times()!
 // We implement an empty dummy-function, simply setting the user
@@ -327,6 +327,7 @@ inline clock_t times(struct tms *t){
   return ticks;
 }
 
+extern void 	bzero	    (void *, size_t);    // FD_ZERO uses bzero() but doesn't include strings.h
 } // extern "C"
 
 // Put the selfmade functions into the std-namespace, just in case
@@ -349,21 +350,43 @@ namespace std {
 // Include signal.h which might contain a typo to be corrected here
 #include <signal.h>
 
-#define getpagesize()    sysconf(_SC_PAGESIZE)         // getpagesize is deprecated anyway!
+inline int getpagesize() { return sysconf(_SC_PAGESIZE); }         // getpagesize is deprecated anyway!
 #ifndef S_ISSOCK
 #  define S_ISSOCK(mode) ((mode & S_IFMT) == S_IFSOCK) // Is file a socket?
 #endif
-#define lstat(p, b)      stat(p, b)                    // lstat() == stat(), as vxWorks has no symlinks!
+inline int lstat(p, b) { return stat(p, b); }  // lstat() == stat(), as vxWorks has no symlinks!
 #ifndef FPE_FLTINV
 #  define FPE_FLTINV     (FPE_FLTSUB+1)                // vxWorks has no FPE_FLTINV, so define one as a dummy
 #endif
 #if !defined(BUS_ADRALN) && defined(BUS_ADRALNR)
 #  define BUS_ADRALN     BUS_ADRALNR                   // Correct a supposed typo in vxWorks' <signal.h>
 #endif
-//typedef int              locale_t;                     // locale_t is a POSIX-extension, currently unpresent in vxWorks!
+typedef int              locale_t;                     // locale_t is a POSIX-extension, currently not present in vxWorks!
 
 // #include boilerplate code:
-#include <boost/config/posix_features.hpp>
+#include <boost/config/detail/posix_features.hpp>
 
 // vxWorks lies about XSI conformance, there is no nl_types.h:
 #undef BOOST_HAS_NL_TYPES_H
+
+// vxWorks 7 adds C++11 support 
+// however it is optional, and does not match exactly the support determined
+// by examining Dinkum STL version and GCC version (or ICC and DCC) 
+
+#ifndef _WRS_CONFIG_LANG_LIB_CPLUS_CPLUS_USER_2011
+#  define BOOST_NO_CXX11_HDR_ARRAY
+#  define BOOST_NO_CXX11_HDR_TYPEINDEX 
+#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#  define BOOST_NO_CXX11_HDR_TUPLE 
+#  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_SMART_PTR 
+#  define BOOST_NO_CXX11_STD_ALIGN
+#  define BOOST_NO_CXX11_HDR_UNORDERED_SET 
+#  define BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#  define BOOST_NO_CXX11_HDR_UNORDERED_MAP
+#  define BOOST_NO_CXX11_HDR_FUNCTIONAL 
+#  define BOOST_NO_CXX11_HDR_ATOMIC
+#else
+#  define BOOST_NO_CXX11_NULLPTR
+#endif
+
diff --git a/contrib/libboost/boost_1_62_0/boost/config/platform/win32.hpp b/contrib/libboost/boost_1_65_0/boost/config/platform/win32.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/platform/win32.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/platform/win32.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/config/platform/zos.hpp b/contrib/libboost/boost_1_65_0/boost/config/platform/zos.hpp
new file mode 100644
index 00000000000..fa77999edc7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/config/platform/zos.hpp
@@ -0,0 +1,32 @@
+//  Copyright (c) 2017 Dynatrace
+//
+//  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.
+
+//  Platform setup for IBM z/OS.
+
+#define BOOST_PLATFORM "IBM z/OS"
+
+#include <features.h> // For __UU, __C99, __TR1, ...
+
+#if defined(__UU)
+#  define BOOST_HAS_GETTIMEOFDAY
+#endif
+
+#if defined(_OPEN_THREADS) || defined(__SUSV3_THR)
+#  define BOOST_HAS_PTHREADS
+#  define BOOST_HAS_PTHREAD_MUTEXATTR_SETTYPE
+#  define BOOST_HAS_THREADS
+#endif
+
+#if defined(__SUSV3) || defined(__SUSV3_THR)
+#  define BOOST_HAS_SCHED_YIELD
+#endif
+
+#define BOOST_HAS_SIGACTION
+#define BOOST_HAS_UNISTD_H
+#define BOOST_HAS_DIRENT_H
+#define BOOST_HAS_NL_TYPES_H
diff --git a/contrib/libboost/boost_1_62_0/boost/config/requires_threads.hpp b/contrib/libboost/boost_1_65_0/boost/config/requires_threads.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/requires_threads.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/requires_threads.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/stdlib/dinkumware.hpp b/contrib/libboost/boost_1_65_0/boost/config/stdlib/dinkumware.hpp
similarity index 81%
rename from contrib/libboost/boost_1_62_0/boost/config/stdlib/dinkumware.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/stdlib/dinkumware.hpp
index af8ddda528d..daac5dfb435 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/stdlib/dinkumware.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/stdlib/dinkumware.hpp
@@ -147,16 +147,36 @@
 #  define BOOST_NO_CXX11_STD_ALIGN
 #endif
 
+// Before 650 std::pointer_traits has a broken rebind template
+#if !defined(_CPPLIB_VER) || _CPPLIB_VER < 650
+#  define BOOST_NO_CXX11_POINTER_TRAITS
+#elif defined(BOOST_MSVC) && BOOST_MSVC < 1910
+#  define BOOST_NO_CXX11_POINTER_TRAITS
+#endif
+
 #if defined(__has_include)
 #if !__has_include(<shared_mutex>)
 #  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
-#elif __cplusplus < 201402
+#elif (__cplusplus < 201402) && !defined(_MSC_VER)
 #  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
 #endif
 #elif !defined(_CPPLIB_VER) || (_CPPLIB_VER < 650)
 #  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
 #endif
 
+// C++14 features
+#if !defined(_CPPLIB_VER) || (_CPPLIB_VER < 650)
+#  define BOOST_NO_CXX14_STD_EXCHANGE
+#endif
+
+// C++17 features
+#if !defined(_CPPLIB_VER) || (_CPPLIB_VER < 650) || !defined(BOOST_MSVC) || (BOOST_MSVC < 1910) || !defined(_HAS_CXX17) || (_HAS_CXX17 == 0)
+#  define BOOST_NO_CXX17_STD_APPLY
+#endif
+#if !defined(_CPPLIB_VER) || (_CPPLIB_VER < 650)
+#  define BOOST_NO_CXX17_STD_INVOKE
+#endif
+
 #if defined(BOOST_INTEL) && (BOOST_INTEL <= 1400)
 // Intel's compiler can't handle this header yet:
 #  define BOOST_NO_CXX11_HDR_ATOMIC
@@ -177,14 +197,47 @@
 #endif
 
 #if defined(_CPPLIB_VER) && (_CPPLIB_VER >= 650)
-// If _HAS_AUTO_PTR_ETC is defined to 0, std::auto_ptr is not available.
+// If _HAS_AUTO_PTR_ETC is defined to 0, std::auto_ptr and std::random_shuffle are not available.
 // See https://www.visualstudio.com/en-us/news/vs2015-vs.aspx#C++
 // and http://blogs.msdn.com/b/vcblog/archive/2015/06/19/c-11-14-17-features-in-vs-2015-rtm.aspx
 #  if defined(_HAS_AUTO_PTR_ETC) && (_HAS_AUTO_PTR_ETC == 0)
 #    define BOOST_NO_AUTO_PTR
+#    define BOOST_NO_CXX98_RANDOM_SHUFFLE
+#    define BOOST_NO_CXX98_FUNCTION_BASE
+#    define BOOST_NO_CXX98_BINDERS
 #  endif
 #endif
 
+
+//
+// Things not supported by the CLR:
+#ifdef _M_CEE
+#ifndef BOOST_NO_CXX11_HDR_MUTEX
+#  define BOOST_NO_CXX11_HDR_MUTEX
+#endif
+#ifndef BOOST_NO_CXX11_HDR_ATOMIC
+#  define BOOST_NO_CXX11_HDR_ATOMIC
+#endif
+#ifndef BOOST_NO_CXX11_HDR_FUTURE
+#  define BOOST_NO_CXX11_HDR_FUTURE
+#endif
+#ifndef BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+#  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+#endif
+#ifndef BOOST_NO_CXX11_HDR_THREAD
+#  define BOOST_NO_CXX11_HDR_THREAD
+#endif
+#ifndef BOOST_NO_CXX14_HDR_SHARED_MUTEX
+#  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
+#endif
+#ifndef BOOST_NO_CXX14_STD_EXCHANGE
+#  define BOOST_NO_CXX14_STD_EXCHANGE
+#endif
+#ifndef BOOST_NO_FENV_H
+#  define BOOST_NO_FENV_H
+#endif
+#endif
+
 #ifdef _CPPLIB_VER
 #  define BOOST_DINKUMWARE_STDLIB _CPPLIB_VER
 #else
diff --git a/contrib/libboost/boost_1_62_0/boost/config/stdlib/libcomo.hpp b/contrib/libboost/boost_1_65_0/boost/config/stdlib/libcomo.hpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/boost/config/stdlib/libcomo.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/stdlib/libcomo.hpp
index 941498d0767..ce83f082ccb 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/stdlib/libcomo.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/stdlib/libcomo.hpp
@@ -55,6 +55,7 @@
 #  define BOOST_NO_CXX11_HDR_UNORDERED_SET
 #  define BOOST_NO_CXX11_NUMERIC_LIMITS
 #  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_POINTER_TRAITS
 #  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
 #  define BOOST_NO_CXX11_SMART_PTR
 #  define BOOST_NO_CXX11_HDR_FUNCTIONAL
@@ -72,6 +73,13 @@
 #  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
 #endif
 
+// C++14 features
+#  define BOOST_NO_CXX14_STD_EXCHANGE
+
+// C++17 features
+#  define BOOST_NO_CXX17_STD_APPLY
+#  define BOOST_NO_CXX17_STD_INVOKE
+
 //
 // Intrinsic type_traits support.
 // The SGI STL has it's own __type_traits class, which
diff --git a/contrib/libboost/boost_1_62_0/boost/config/stdlib/libcpp.hpp b/contrib/libboost/boost_1_65_0/boost/config/stdlib/libcpp.hpp
similarity index 74%
rename from contrib/libboost/boost_1_62_0/boost/config/stdlib/libcpp.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/stdlib/libcpp.hpp
index 096b8c0de2c..9c58965f80a 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/stdlib/libcpp.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/stdlib/libcpp.hpp
@@ -29,13 +29,18 @@
 // aliases since members rebind_alloc and rebind_traits require it.
 #if defined(_LIBCPP_HAS_NO_TEMPLATE_ALIASES)
 #    define BOOST_NO_CXX11_ALLOCATOR
+#    define BOOST_NO_CXX11_POINTER_TRAITS
 #endif
 
 #if __cplusplus < 201103
-#  define BOOST_NO_CXX11_HDR_ARRAY
+//
+// These two appear to be somewhat useable in C++03 mode, there may be others...
+//
+//#  define BOOST_NO_CXX11_HDR_ARRAY
+//#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
+
 #  define BOOST_NO_CXX11_HDR_CODECVT
 #  define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
-#  define BOOST_NO_CXX11_HDR_FORWARD_LIST
 #  define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
 #  define BOOST_NO_CXX11_HDR_MUTEX
 #  define BOOST_NO_CXX11_HDR_RANDOM
@@ -49,6 +54,7 @@
 #  define BOOST_NO_CXX11_HDR_UNORDERED_SET
 #  define BOOST_NO_CXX11_NUMERIC_LIMITS
 #  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_POINTER_TRAITS
 #  define BOOST_NO_CXX11_SMART_PTR
 #  define BOOST_NO_CXX11_HDR_FUNCTIONAL
 #  define BOOST_NO_CXX11_STD_ALIGN
@@ -75,6 +81,28 @@
 #define BOOST_NO_STD_MESSAGES
 #endif
 
+// C++14 features
+#if (_LIBCPP_VERSION < 3700) || (__cplusplus <= 201402L)
+#  define BOOST_NO_CXX14_STD_EXCHANGE
+#endif
+
+// C++17 features
+#if (_LIBCPP_VERSION < 3700) || (__cplusplus <= 201402L)
+#  define BOOST_NO_CXX17_STD_INVOKE
+#endif
+#if (_LIBCPP_VERSION < 4000) || (__cplusplus <= 201402L)
+#  define BOOST_NO_CXX17_STD_APPLY
+#endif
+#if (_LIBCPP_VERSION > 4000) && (__cplusplus > 201402L) && !defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
+#  define BOOST_NO_AUTO_PTR
+#endif
+#if (_LIBCPP_VERSION > 4000) && (__cplusplus > 201402L) && !defined(_LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE)
+#  define BOOST_NO_CXX98_RANDOM_SHUFFLE
+#endif
+#if (_LIBCPP_VERSION > 4000) && (__cplusplus > 201402L) && !defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
+#  define BOOST_NO_CXX98_BINDERS
+#endif
+
 #if (_LIBCPP_VERSION <= 1101) && !defined(BOOST_NO_CXX11_THREAD_LOCAL)
 // This is a bit of a sledgehammer, because really it's just libc++abi that has no
 // support for thread_local, leading to linker errors such as
diff --git a/contrib/libboost/boost_1_62_0/boost/config/stdlib/libstdcpp3.hpp b/contrib/libboost/boost_1_65_0/boost/config/stdlib/libstdcpp3.hpp
similarity index 85%
rename from contrib/libboost/boost_1_62_0/boost/config/stdlib/libstdcpp3.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/stdlib/libstdcpp3.hpp
index 1d8f6ccbceb..9adbc8f171e 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/stdlib/libstdcpp3.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/stdlib/libstdcpp3.hpp
@@ -98,10 +98,11 @@
 #if defined(__GXX_EXPERIMENTAL_CXX0X__) || (__cplusplus >= 201103)
 #  define BOOST_LIBSTDCXX11
 #endif
+
 //
 //  Decide which version of libstdc++ we have, normally
-//  stdlibc++ C++0x support is detected via __GNUC__, __GNUC_MINOR__, and possibly
-//  __GNUC_PATCHLEVEL__ at the suggestion of Jonathan Wakely, one of the stdlibc++
+//  libstdc++ C++0x support is detected via __GNUC__, __GNUC_MINOR__, and possibly
+//  __GNUC_PATCHLEVEL__ at the suggestion of Jonathan Wakely, one of the libstdc++
 //  developers. He also commented:
 //
 //       "I'm not sure how useful __GLIBCXX__ is for your purposes, for instance in
@@ -109,7 +110,7 @@
 //       Although 4.3.0 was released earlier than 4.2.4, it has better C++0x support
 //       than any release in the 4.2 series."
 //
-//  Another resource for understanding stdlibc++ features is:
+//  Another resource for understanding libstdc++ features is:
 //  http://gcc.gnu.org/onlinedocs/libstdc++/manual/status.html#manual.intro.status.standard.200x
 //
 //  However, using the GCC version number fails when the compiler is clang since this
@@ -122,7 +123,9 @@
 //
 #ifdef __clang__
 
-#if __has_include(<experimental/any>)
+#if __has_include(<experimental/memory_resource>)
+#  define BOOST_LIBSTDCXX_VERSION 60100
+#elif __has_include(<experimental/any>)
 #  define BOOST_LIBSTDCXX_VERSION 50100
 #elif __has_include(<shared_mutex>)
 #  define BOOST_LIBSTDCXX_VERSION 40900
@@ -139,6 +142,38 @@
 #elif __has_include(<array>)
 #  define BOOST_LIBSTDCXX_VERSION 40300
 #endif
+
+#if (BOOST_LIBSTDCXX_VERSION < 50100)
+// libstdc++ does not define this function as it's deprecated in C++11, but clang still looks for it,
+// defining it here is a terrible cludge, but should get things working:
+extern "C" char *gets (char *__s);
+#endif
+//
+// clang is unable to parse some GCC headers, add those workarounds here:
+//
+#if BOOST_LIBSTDCXX_VERSION < 50000
+#  define BOOST_NO_CXX11_HDR_REGEX
+#endif
+//
+// GCC 4.7.x has no __cxa_thread_atexit which
+// thread_local objects require for cleanup:
+//
+#if BOOST_LIBSTDCXX_VERSION < 40800
+#  define BOOST_NO_CXX11_THREAD_LOCAL
+#endif
+//
+// Early clang versions can handle <chrono>, not exactly sure which versions
+// but certainly up to clang-3.8 and gcc-4.6:
+//
+#if (__clang_major__ < 5)
+#  if BOOST_LIBSTDCXX_VERSION < 40800
+#     define BOOST_NO_CXX11_HDR_FUTURE
+#     define BOOST_NO_CXX11_HDR_MUTEX
+#     define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+#     define BOOST_NO_CXX11_HDR_CHRONO
+#  endif
+#endif
+
 //
 //  GCC 4.8 and 9 add working versions of <atomic> and <regex> respectively.
 //  However, we have no test for these as the headers were present but broken
@@ -218,9 +253,10 @@
 //
 #if (BOOST_LIBSTDCXX_VERSION < 40700) || !defined(BOOST_LIBSTDCXX11)
 // Note that although <chrono> existed prior to 4.7, "steady_clock" is spelled "monotonic_clock"
-// so 4.7.0 is the first truely conforming one.
+// so 4.7.0 is the first truly conforming one.
 #  define BOOST_NO_CXX11_HDR_CHRONO
 #  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_POINTER_TRAITS
 #endif
 //  C++0x features in GCC 4.8.0 and later
 //
@@ -236,6 +272,9 @@
 // even for the simplest patterns such as "\d" or "[0-9]". This is the case at least in gcc up to 4.8, inclusively.
 #  define BOOST_NO_CXX11_HDR_REGEX
 #endif
+#if (BOOST_LIBSTDCXX_VERSION < 40900) || (__cplusplus <= 201103)
+#  define BOOST_NO_CXX14_STD_EXCHANGE
+#endif
 
 #if defined(__clang_major__) && ((__clang_major__ < 3) || ((__clang_major__ == 3) && (__clang_minor__ < 7)))
 // As of clang-3.6, libstdc++ header <atomic> throws up errors with clang:
@@ -251,6 +290,16 @@
 #  define BOOST_NO_CXX11_STD_ALIGN
 #endif
 
+//
+//  C++17 features in GCC 6.1 and later
+//
+#if (BOOST_LIBSTDCXX_VERSION < 60100) || (__cplusplus <= 201402L)
+#  define BOOST_NO_CXX17_STD_INVOKE
+#endif
+#if (BOOST_LIBSTDCXX_VERSION < 70100) || (__cplusplus <= 201402L)
+#  define BOOST_NO_CXX17_STD_APPLY
+#endif
+
 #if defined(__has_include)
 #if !__has_include(<shared_mutex>)
 #  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
diff --git a/contrib/libboost/boost_1_62_0/boost/config/stdlib/modena.hpp b/contrib/libboost/boost_1_65_0/boost/config/stdlib/modena.hpp
similarity index 91%
rename from contrib/libboost/boost_1_62_0/boost/config/stdlib/modena.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/stdlib/modena.hpp
index 7a85e0cd57c..98bdc3fb3ed 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/stdlib/modena.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/stdlib/modena.hpp
@@ -44,6 +44,7 @@
 #  define BOOST_NO_CXX11_HDR_UNORDERED_SET
 #  define BOOST_NO_CXX11_NUMERIC_LIMITS
 #  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_POINTER_TRAITS
 #  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
 #  define BOOST_NO_CXX11_SMART_PTR
 #  define BOOST_NO_CXX11_HDR_FUNCTIONAL
@@ -61,6 +62,13 @@
 #  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
 #endif
 
+// C++14 features
+#  define BOOST_NO_CXX14_STD_EXCHANGE
+
+// C++17 features
+#  define BOOST_NO_CXX17_STD_APPLY
+#  define BOOST_NO_CXX17_STD_INVOKE
+
 #define BOOST_STDLIB "Modena C++ standard library"
 
 
diff --git a/contrib/libboost/boost_1_62_0/boost/config/stdlib/msl.hpp b/contrib/libboost/boost_1_65_0/boost/config/stdlib/msl.hpp
similarity index 91%
rename from contrib/libboost/boost_1_62_0/boost/config/stdlib/msl.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/stdlib/msl.hpp
index dd2775e10cd..9606a9aeca6 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/stdlib/msl.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/stdlib/msl.hpp
@@ -34,7 +34,7 @@
 #    define BOOST_HAS_UNISTD_H
 #  endif
    // boilerplate code:
-#  include <boost/config/posix_features.hpp>
+#  include <boost/config/detail/posix_features.hpp>
 #endif
 
 #if defined(_MWMT) || _MSL_THREADSAFE
@@ -68,6 +68,7 @@
 #  define BOOST_NO_CXX11_HDR_UNORDERED_SET
 #  define BOOST_NO_CXX11_NUMERIC_LIMITS
 #  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_POINTER_TRAITS
 #  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
 #  define BOOST_NO_CXX11_SMART_PTR
 #  define BOOST_NO_CXX11_HDR_FUNCTIONAL
@@ -85,4 +86,11 @@
 #  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
 #endif
 
+// C++14 features
+#  define BOOST_NO_CXX14_STD_EXCHANGE
+
+// C++17 features
+#  define BOOST_NO_CXX17_STD_APPLY
+#  define BOOST_NO_CXX17_STD_INVOKE
+
 #define BOOST_STDLIB "Metrowerks Standard Library version " BOOST_STRINGIZE(__MSL_CPP__)
diff --git a/contrib/libboost/boost_1_62_0/boost/config/stdlib/roguewave.hpp b/contrib/libboost/boost_1_65_0/boost/config/stdlib/roguewave.hpp
similarity index 96%
rename from contrib/libboost/boost_1_62_0/boost/config/stdlib/roguewave.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/stdlib/roguewave.hpp
index 97a2b0b90b6..380d0ff375c 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/stdlib/roguewave.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/stdlib/roguewave.hpp
@@ -180,6 +180,7 @@
 #  define BOOST_NO_CXX11_HDR_UNORDERED_SET
 #  define BOOST_NO_CXX11_NUMERIC_LIMITS
 #  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_POINTER_TRAITS
 #  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
 #  define BOOST_NO_CXX11_SMART_PTR
 #  define BOOST_NO_CXX11_HDR_FUNCTIONAL
@@ -196,3 +197,10 @@
 #else
 #  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
 #endif
+
+// C++14 features
+#  define BOOST_NO_CXX14_STD_EXCHANGE
+
+// C++17 features
+#  define BOOST_NO_CXX17_STD_APPLY
+#  define BOOST_NO_CXX17_STD_INVOKE
diff --git a/contrib/libboost/boost_1_62_0/boost/config/stdlib/sgi.hpp b/contrib/libboost/boost_1_65_0/boost/config/stdlib/sgi.hpp
similarity index 95%
rename from contrib/libboost/boost_1_62_0/boost/config/stdlib/sgi.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/stdlib/sgi.hpp
index c8052717ceb..5016ff627bb 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/stdlib/sgi.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/stdlib/sgi.hpp
@@ -138,6 +138,7 @@
 #  define BOOST_NO_CXX11_HDR_UNORDERED_SET
 #  define BOOST_NO_CXX11_NUMERIC_LIMITS
 #  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_POINTER_TRAITS
 #  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
 #  define BOOST_NO_CXX11_SMART_PTR
 #  define BOOST_NO_CXX11_HDR_FUNCTIONAL
@@ -155,4 +156,11 @@
 #  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
 #endif
 
-#define BOOST_STDLIB "SGI standard library"
\ No newline at end of file
+// C++14 features
+#  define BOOST_NO_CXX14_STD_EXCHANGE
+
+// C++17 features
+#  define BOOST_NO_CXX17_STD_APPLY
+#  define BOOST_NO_CXX17_STD_INVOKE
+
+#define BOOST_STDLIB "SGI standard library"
diff --git a/contrib/libboost/boost_1_62_0/boost/config/stdlib/stlport.hpp b/contrib/libboost/boost_1_65_0/boost/config/stdlib/stlport.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/config/stdlib/stlport.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/stdlib/stlport.hpp
index bbc4176c900..81e6ccf016a 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/stdlib/stlport.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/stdlib/stlport.hpp
@@ -228,6 +228,7 @@ namespace boost { using std::min; using std::max; }
 #  define BOOST_NO_CXX11_HDR_UNORDERED_SET
 #  define BOOST_NO_CXX11_NUMERIC_LIMITS
 #  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_POINTER_TRAITS
 #  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
 #  define BOOST_NO_CXX11_SMART_PTR
 #  define BOOST_NO_CXX11_HDR_FUNCTIONAL
@@ -245,4 +246,11 @@ namespace boost { using std::min; using std::max; }
 #  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
 #endif
 
+// C++14 features
+#  define BOOST_NO_CXX14_STD_EXCHANGE
+
+// C++17 features
+#  define BOOST_NO_CXX17_STD_APPLY
+#  define BOOST_NO_CXX17_STD_INVOKE
+
 #define BOOST_STDLIB "STLPort standard library version " BOOST_STRINGIZE(__SGI_STL_PORT)
diff --git a/contrib/libboost/boost_1_62_0/boost/config/stdlib/vacpp.hpp b/contrib/libboost/boost_1_65_0/boost/config/stdlib/vacpp.hpp
similarity index 91%
rename from contrib/libboost/boost_1_62_0/boost/config/stdlib/vacpp.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/stdlib/vacpp.hpp
index 4ccd0d24663..c159af259fe 100644
--- a/contrib/libboost/boost_1_62_0/boost/config/stdlib/vacpp.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/stdlib/vacpp.hpp
@@ -44,6 +44,7 @@
 #  define BOOST_NO_CXX11_HDR_UNORDERED_SET
 #  define BOOST_NO_CXX11_NUMERIC_LIMITS
 #  define BOOST_NO_CXX11_ALLOCATOR
+#  define BOOST_NO_CXX11_POINTER_TRAITS
 #  define BOOST_NO_CXX11_ATOMIC_SMART_PTR
 #  define BOOST_NO_CXX11_SMART_PTR
 #  define BOOST_NO_CXX11_HDR_FUNCTIONAL
@@ -61,4 +62,11 @@
 #  define BOOST_NO_CXX14_HDR_SHARED_MUTEX
 #endif
 
+// C++14 features
+#  define BOOST_NO_CXX14_STD_EXCHANGE
+
+// C++17 features
+#  define BOOST_NO_CXX17_STD_APPLY
+#  define BOOST_NO_CXX17_STD_INVOKE
+
 #define BOOST_STDLIB "Visual Age default standard library"
diff --git a/contrib/libboost/boost_1_65_0/boost/config/stdlib/xlcpp_zos.hpp b/contrib/libboost/boost_1_65_0/boost/config/stdlib/xlcpp_zos.hpp
new file mode 100644
index 00000000000..dce40f50902
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/config/stdlib/xlcpp_zos.hpp
@@ -0,0 +1,59 @@
+//  Copyright (c) 2017 Dynatrace
+//
+//  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.
+
+//  Standard library setup for IBM z/OS XL C/C++ compiler.
+
+// Oldest library version currently supported is 2.1 (V2R1)
+#if __TARGET_LIB__ < 0x42010000
+#  error "Library version not supported or configured - please reconfigure"
+#endif
+
+#if __TARGET_LIB__ > 0x42010000
+#  if defined(BOOST_ASSERT_CONFIG)
+#     error "Unknown library version - please run the configure tests and report the results"
+#  endif
+#endif
+
+#define BOOST_STDLIB "IBM z/OS XL C/C++ standard library"
+
+#define BOOST_HAS_MACRO_USE_FACET
+
+#define BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#define BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+
+#define BOOST_NO_CXX11_ADDRESSOF
+#define BOOST_NO_CXX11_SMART_PTR
+#define BOOST_NO_CXX11_ATOMIC_SMART_PTR
+#define BOOST_NO_CXX11_NUMERIC_LIMITS
+#define BOOST_NO_CXX11_ALLOCATOR
+#define BOOST_NO_CXX11_POINTER_TRAITS
+#define BOOST_NO_CXX11_HDR_FUNCTIONAL
+#define BOOST_NO_CXX11_HDR_UNORDERED_SET
+#define BOOST_NO_CXX11_HDR_UNORDERED_MAP
+#define BOOST_NO_CXX11_HDR_TYPEINDEX
+#define BOOST_NO_CXX11_HDR_TUPLE
+#define BOOST_NO_CXX11_HDR_THREAD
+#define BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+#define BOOST_NO_CXX11_HDR_REGEX
+#define BOOST_NO_CXX11_HDR_RATIO
+#define BOOST_NO_CXX11_HDR_RANDOM
+#define BOOST_NO_CXX11_HDR_MUTEX
+#define BOOST_NO_CXX11_HDR_FUTURE
+#define BOOST_NO_CXX11_HDR_FORWARD_LIST
+#define BOOST_NO_CXX11_HDR_CONDITION_VARIABLE
+#define BOOST_NO_CXX11_HDR_CODECVT
+#define BOOST_NO_CXX11_HDR_CHRONO
+#define BOOST_NO_CXX11_HDR_ATOMIC
+#define BOOST_NO_CXX11_HDR_ARRAY
+#define BOOST_NO_CXX11_STD_ALIGN
+
+#define BOOST_NO_CXX14_STD_EXCHANGE
+#define BOOST_NO_CXX14_HDR_SHARED_MUTEX
+
+#define BOOST_NO_CXX17_STD_INVOKE
+#define BOOST_NO_CXX17_STD_APPLY
diff --git a/contrib/libboost/boost_1_62_0/boost/config/user.hpp b/contrib/libboost/boost_1_65_0/boost/config/user.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/user.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/user.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/config/warning_disable.hpp b/contrib/libboost/boost_1_65_0/boost/config/warning_disable.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/config/warning_disable.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/warning_disable.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/workaround.hpp b/contrib/libboost/boost_1_65_0/boost/config/workaround.hpp
similarity index 81%
rename from contrib/libboost/boost_1_62_0/boost/detail/workaround.hpp
rename to contrib/libboost/boost_1_65_0/boost/config/workaround.hpp
index 40b3423b374..0ce8108c2e0 100644
--- a/contrib/libboost/boost_1_62_0/boost/detail/workaround.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/config/workaround.hpp
@@ -2,29 +2,29 @@
 // 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 WORKAROUND_DWA2002126_HPP
-# define WORKAROUND_DWA2002126_HPP
+#ifndef BOOST_CONFIG_WORKAROUND_HPP
+#define BOOST_CONFIG_WORKAROUND_HPP
 
 // Compiler/library version workaround macro
 //
 // Usage:
 //
-//     #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-//        // workaround for eVC4 and VC6
-//        ... // workaround code here
-//     #endif
+//   #if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
+//      // workaround for eVC4 and VC6
+//      ... // workaround code here
+//   #endif
 //
 // When BOOST_STRICT_CONFIG is defined, expands to 0. Otherwise, the
 // first argument must be undefined or expand to a numeric
 // value. The above expands to:
 //
-//     (BOOST_MSVC) != 0 && (BOOST_MSVC) < 1300
+//   (BOOST_MSVC) != 0 && (BOOST_MSVC) < 1300
 //
-// When used for workarounds that apply to the latest known version 
-// and all earlier versions of a compiler, the following convention 
+// When used for workarounds that apply to the latest known version
+// and all earlier versions of a compiler, the following convention
 // should be observed:
 //
-//     #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1301))
+//   #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1301))
 //
 // The version number in this case corresponds to the last version in
 // which the workaround was known to have been required. When
@@ -36,7 +36,7 @@
 // to BOOST_TESTED_AT().  This can be used to locate workarounds which
 // may be obsoleted by newer versions.
 
-# ifndef BOOST_STRICT_CONFIG
+#ifndef BOOST_STRICT_CONFIG
 
 #include <boost/config.hpp>
 
@@ -85,6 +85,16 @@
 #else
 #define __GNUC_PATCHLEVEL___WORKAROUND_GUARD 0
 #endif
+#ifndef BOOST_GCC
+#define BOOST_GCC_WORKAROUND_GUARD 1
+#else
+#define BOOST_GCC_WORKAROUND_GUARD 0
+#endif
+#ifndef BOOST_XLCPP_ZOS
+#define BOOST_XLCPP_ZOS_WORKAROUND_GUARD 1
+#else
+#define BOOST_XLCPP_ZOS_WORKAROUND_GUARD 0
+#endif
 #ifndef __IBMCPP__
 #define __IBMCPP___WORKAROUND_GUARD 1
 #else
@@ -230,38 +240,38 @@
 // Always define to zero, if it's used it'll be defined my MPL:
 #define BOOST_MPL_CFG_GCC_WORKAROUND_GUARD 0
 
-#  define BOOST_WORKAROUND(symbol, test)                \
-         ((symbol ## _WORKAROUND_GUARD + 0 == 0) &&     \
-         (symbol != 0) && (1 % (( (symbol test) ) + 1)))
+#define BOOST_WORKAROUND(symbol, test)                \
+       ((symbol ## _WORKAROUND_GUARD + 0 == 0) &&     \
+       (symbol != 0) && (1 % (( (symbol test) ) + 1)))
 //                              ^ ^           ^ ^
 // The extra level of parenthesis nesting above, along with the
 // BOOST_OPEN_PAREN indirection below, is required to satisfy the
 // broken preprocessor in MWCW 8.3 and earlier.
 //
 // The basic mechanism works as follows:
-//      (symbol test) + 1        =>   if (symbol test) then 2 else 1
-//      1 % ((symbol test) + 1)  =>   if (symbol test) then 1 else 0
+//   (symbol test) + 1        =>   if (symbol test) then 2 else 1
+//   1 % ((symbol test) + 1)  =>   if (symbol test) then 1 else 0
 //
 // The complication with % is for cooperation with BOOST_TESTED_AT().
 // When "test" is BOOST_TESTED_AT(x) and
 // BOOST_DETECT_OUTDATED_WORKAROUNDS is #defined,
 //
-//      symbol test              =>   if (symbol <= x) then 1 else -1
-//      (symbol test) + 1        =>   if (symbol <= x) then 2 else 0
-//      1 % ((symbol test) + 1)  =>   if (symbol <= x) then 1 else divide-by-zero
+//   symbol test              =>   if (symbol <= x) then 1 else -1
+//   (symbol test) + 1        =>   if (symbol <= x) then 2 else 0
+//   1 % ((symbol test) + 1)  =>   if (symbol <= x) then 1 else divide-by-zero
 //
 
-#  ifdef BOOST_DETECT_OUTDATED_WORKAROUNDS
-#   define BOOST_OPEN_PAREN (
-#   define BOOST_TESTED_AT(value)  > value) ?(-1): BOOST_OPEN_PAREN 1
-#  else
-#   define BOOST_TESTED_AT(value) != ((value)-(value))
-#  endif
+#ifdef BOOST_DETECT_OUTDATED_WORKAROUNDS
+#  define BOOST_OPEN_PAREN (
+#  define BOOST_TESTED_AT(value)  > value) ?(-1): BOOST_OPEN_PAREN 1
+#else
+#  define BOOST_TESTED_AT(value) != ((value)-(value))
+#endif
 
-# else
+#else
 
-#  define BOOST_WORKAROUND(symbol, test) 0
+#define BOOST_WORKAROUND(symbol, test) 0
 
-# endif 
+#endif
 
-#endif // WORKAROUND_DWA2002126_HPP
+#endif // BOOST_CONFIG_WORKAROUND_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/container/adaptive_pool.hpp b/contrib/libboost/boost_1_65_0/boost/container/adaptive_pool.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/adaptive_pool.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/adaptive_pool.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/allocator.hpp b/contrib/libboost/boost_1_65_0/boost/container/allocator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/allocator.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/allocator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/allocator_traits.hpp b/contrib/libboost/boost_1_65_0/boost/container/allocator_traits.hpp
similarity index 85%
rename from contrib/libboost/boost_1_62_0/boost/container/allocator_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/allocator_traits.hpp
index e6a882e5941..b08f601461c 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/allocator_traits.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/allocator_traits.hpp
@@ -289,18 +289,18 @@ struct allocator_traits
 
    //! <b>Returns</b>: <code>a.allocate(n)</code>
    //!
-   static pointer allocate(Allocator &a, size_type n)
+   BOOST_CONTAINER_FORCEINLINE static pointer allocate(Allocator &a, size_type n)
    {  return a.allocate(n);  }
 
    //! <b>Returns</b>: <code>a.deallocate(p, n)</code>
    //!
    //! <b>Throws</b>: Nothing
-   static void deallocate(Allocator &a, pointer p, size_type n)
+   BOOST_CONTAINER_FORCEINLINE static void deallocate(Allocator &a, pointer p, size_type n)
    {  a.deallocate(p, n);  }
 
    //! <b>Effects</b>: calls <code>a.allocate(n, p)</code> if that call is well-formed;
    //! otherwise, invokes <code>a.allocate(n)</code>
-   static pointer allocate(Allocator &a, size_type n, const_void_pointer p)
+   BOOST_CONTAINER_FORCEINLINE static pointer allocate(Allocator &a, size_type n, const_void_pointer p)
    {
       const bool value = boost::container::container_detail::
          has_member_function_callable_with_allocate
@@ -312,7 +312,7 @@ struct allocator_traits
    //! <b>Effects</b>: calls <code>a.destroy(p)</code> if that call is well-formed;
    //! otherwise, invokes <code>p->~T()</code>.
    template<class T>
-   static void destroy(Allocator &a, T*p) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE static void destroy(Allocator &a, T*p) BOOST_NOEXCEPT_OR_NOTHROW
    {
       typedef T* destroy_pointer;
       const bool value = boost::container::container_detail::
@@ -324,7 +324,7 @@ struct allocator_traits
 
    //! <b>Returns</b>: <code>a.max_size()</code> if that expression is well-formed; otherwise,
    //! <code>numeric_limits<size_type>::max()</code>.
-   static size_type max_size(const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE static size_type max_size(const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
    {
       const bool value = allocator_traits_detail::has_max_size<Allocator, size_type (Allocator::*)() const>::value;
       container_detail::bool_<value> flag;
@@ -333,7 +333,7 @@ struct allocator_traits
 
    //! <b>Returns</b>: <code>a.select_on_container_copy_construction()</code> if that expression is well-formed;
    //! otherwise, a.
-   static BOOST_CONTAINER_DOC1ST(Allocator,
+   BOOST_CONTAINER_FORCEINLINE static BOOST_CONTAINER_DOC1ST(Allocator,
       typename container_detail::if_c
          < allocator_traits_detail::has_select_on_container_copy_construction<Allocator BOOST_MOVE_I Allocator (Allocator::*)() const>::value
          BOOST_MOVE_I Allocator BOOST_MOVE_I const Allocator & >::type)
@@ -347,9 +347,9 @@ struct allocator_traits
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
       //! <b>Effects</b>: calls <code>a.construct(p, std::forward<Args>(args)...)</code> if that call is well-formed;
-      //! otherwise, invokes <code>::new (static_cast<void*>(p)) T(std::forward<Args>(args)...)</code>
+      //! otherwise, invokes <code>`placement new` (static_cast<void*>(p)) T(std::forward<Args>(args)...)</code>
       template <class T, class ...Args>
-      static void construct(Allocator & a, T* p, BOOST_FWD_REF(Args)... args)
+      BOOST_CONTAINER_FORCEINLINE static void construct(Allocator & a, T* p, BOOST_FWD_REF(Args)... args)
       {
          static const bool value = ::boost::move_detail::and_
             < container_detail::is_not_std_allocator<Allocator>
@@ -363,7 +363,7 @@ struct allocator_traits
 
    //! <b>Returns</b>: <code>a.storage_is_unpropagable(p)</code> if is_partially_propagable::value is true; otherwise,
    //! <code>false</code>.
-   static bool storage_is_unpropagable(const Allocator &a, pointer p) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE static bool storage_is_unpropagable(const Allocator &a, pointer p) BOOST_NOEXCEPT_OR_NOTHROW
    {
       container_detail::bool_<is_partially_propagable::value> flag;
       return allocator_traits::priv_storage_is_unpropagable(flag, a, p);
@@ -371,7 +371,7 @@ struct allocator_traits
 
    //! <b>Returns</b>: <code>true</code> if <code>is_always_equal::value == true</code>, otherwise,
    //! <code>a == b</code>.
-   static bool equal(const Allocator &a, const Allocator &b) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE static bool equal(const Allocator &a, const Allocator &b) BOOST_NOEXCEPT_OR_NOTHROW
    {
       container_detail::bool_<is_always_equal::value> flag;
       return allocator_traits::priv_equal(flag, a, b);
@@ -379,46 +379,46 @@ struct allocator_traits
 
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    private:
-   static pointer priv_allocate(container_detail::true_type, Allocator &a, size_type n, const_void_pointer p)
+   BOOST_CONTAINER_FORCEINLINE static pointer priv_allocate(container_detail::true_type, Allocator &a, size_type n, const_void_pointer p)
    {  return a.allocate(n, p);  }
 
-   static pointer priv_allocate(container_detail::false_type, Allocator &a, size_type n, const_void_pointer)
+   BOOST_CONTAINER_FORCEINLINE static pointer priv_allocate(container_detail::false_type, Allocator &a, size_type n, const_void_pointer)
    {  return a.allocate(n);  }
 
    template<class T>
-   static void priv_destroy(container_detail::true_type, Allocator &a, T* p) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE static void priv_destroy(container_detail::true_type, Allocator &a, T* p) BOOST_NOEXCEPT_OR_NOTHROW
    {  a.destroy(p);  }
 
    template<class T>
-   static void priv_destroy(container_detail::false_type, Allocator &, T* p) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE static void priv_destroy(container_detail::false_type, Allocator &, T* p) BOOST_NOEXCEPT_OR_NOTHROW
    {  p->~T(); (void)p;  }
 
-   static size_type priv_max_size(container_detail::true_type, const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE static size_type priv_max_size(container_detail::true_type, const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
    {  return a.max_size();  }
 
-   static size_type priv_max_size(container_detail::false_type, const Allocator &) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE static size_type priv_max_size(container_detail::false_type, const Allocator &) BOOST_NOEXCEPT_OR_NOTHROW
    {  return size_type(-1)/sizeof(value_type);  }
 
-   static Allocator priv_select_on_container_copy_construction(container_detail::true_type, const Allocator &a)
+   BOOST_CONTAINER_FORCEINLINE static Allocator priv_select_on_container_copy_construction(container_detail::true_type, const Allocator &a)
    {  return a.select_on_container_copy_construction();  }
 
-   static const Allocator &priv_select_on_container_copy_construction(container_detail::false_type, const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE static const Allocator &priv_select_on_container_copy_construction(container_detail::false_type, const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
    {  return a;  }
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
       template<class T, class ...Args>
-      static void priv_construct(container_detail::true_type, Allocator &a, T *p, BOOST_FWD_REF(Args) ...args)
+      BOOST_CONTAINER_FORCEINLINE static void priv_construct(container_detail::true_type, Allocator &a, T *p, BOOST_FWD_REF(Args) ...args)
       {  a.construct( p, ::boost::forward<Args>(args)...);  }
 
       template<class T, class ...Args>
-      static void priv_construct(container_detail::false_type, Allocator &, T *p, BOOST_FWD_REF(Args) ...args)
+      BOOST_CONTAINER_FORCEINLINE static void priv_construct(container_detail::false_type, Allocator &, T *p, BOOST_FWD_REF(Args) ...args)
       {  ::new((void*)p, boost_container_new_t()) T(::boost::forward<Args>(args)...); }
    #else // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
       public:
 
       #define BOOST_CONTAINER_ALLOCATOR_TRAITS_CONSTRUCT_IMPL(N) \
       template<class T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-      static void construct(Allocator &a, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+      BOOST_CONTAINER_FORCEINLINE static void construct(Allocator &a, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
       {\
          static const bool value = ::boost::move_detail::and_ \
             < container_detail::is_not_std_allocator<Allocator> \
@@ -438,11 +438,11 @@ struct allocator_traits
       /////////////////////////////////
       #define BOOST_CONTAINER_ALLOCATOR_TRAITS_PRIV_CONSTRUCT_IMPL(N) \
       template<class T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-      static void priv_construct(container_detail::true_type, Allocator &a, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+      BOOST_CONTAINER_FORCEINLINE static void priv_construct(container_detail::true_type, Allocator &a, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
       {  a.construct( p BOOST_MOVE_I##N BOOST_MOVE_FWD##N );  }\
       \
       template<class T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-      static void priv_construct(container_detail::false_type, Allocator &, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+      BOOST_CONTAINER_FORCEINLINE static void priv_construct(container_detail::false_type, Allocator &, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
       {  ::new((void*)p, boost_container_new_t()) T(BOOST_MOVE_FWD##N); }\
       //
       BOOST_MOVE_ITERATE_0TO8(BOOST_CONTAINER_ALLOCATOR_TRAITS_PRIV_CONSTRUCT_IMPL)
@@ -451,19 +451,19 @@ struct allocator_traits
    #endif   // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
    template<class T>
-   static void priv_construct(container_detail::false_type, Allocator &, T *p, const ::boost::container::default_init_t&)
+   BOOST_CONTAINER_FORCEINLINE static void priv_construct(container_detail::false_type, Allocator &, T *p, const ::boost::container::default_init_t&)
    {  ::new((void*)p, boost_container_new_t()) T; }
 
-   static bool priv_storage_is_unpropagable(container_detail::true_type, const Allocator &a, pointer p)
+   BOOST_CONTAINER_FORCEINLINE static bool priv_storage_is_unpropagable(container_detail::true_type, const Allocator &a, pointer p)
    {  return a.storage_is_unpropagable(p);  }
 
-   static bool priv_storage_is_unpropagable(container_detail::false_type, const Allocator &, pointer)
+   BOOST_CONTAINER_FORCEINLINE static bool priv_storage_is_unpropagable(container_detail::false_type, const Allocator &, pointer)
    {  return false;  }
 
-   static bool priv_equal(container_detail::true_type,  const Allocator &, const Allocator &)
+   BOOST_CONTAINER_FORCEINLINE static bool priv_equal(container_detail::true_type,  const Allocator &, const Allocator &)
    {  return true;  }
 
-   static bool priv_equal(container_detail::false_type, const Allocator &a, const Allocator &b)
+   BOOST_CONTAINER_FORCEINLINE static bool priv_equal(container_detail::false_type, const Allocator &a, const Allocator &b)
    {  return a == b;  }
 
    #endif   //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
diff --git a/contrib/libboost/boost_1_62_0/boost/container/container_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/container/container_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/container_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/container_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/deque.hpp b/contrib/libboost/boost_1_65_0/boost/container/deque.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/container/deque.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/deque.hpp
index 255cd9399d4..b838f6e4eb7 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/deque.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/deque.hpp
@@ -31,11 +31,11 @@
 #include <boost/container/detail/alloc_helpers.hpp>
 #include <boost/container/detail/copy_move_algo.hpp>
 #include <boost/container/detail/iterator.hpp>
-#include <boost/container/detail/iterator_to_raw_pointer.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
 #include <boost/container/detail/iterators.hpp>
 #include <boost/container/detail/min_max.hpp>
 #include <boost/container/detail/mpl.hpp>
-#include <boost/container/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/detail/type_traits.hpp>
 // move
 #include <boost/move/adl_move_swap.hpp>
@@ -1649,7 +1649,7 @@ class deque : protected deque_base<Allocator>
       if (this->members_.m_start.m_cur != this->members_.m_start.m_last - 1) {
          allocator_traits_type::destroy
             ( this->alloc()
-            , container_detail::to_raw_pointer(this->members_.m_start.m_cur)
+            , boost::movelib::to_raw_pointer(this->members_.m_start.m_cur)
             );
          ++this->members_.m_start.m_cur;
       }
@@ -1669,7 +1669,7 @@ class deque : protected deque_base<Allocator>
          --this->members_.m_finish.m_cur;
          allocator_traits_type::destroy
             ( this->alloc()
-            , container_detail::to_raw_pointer(this->members_.m_finish.m_cur)
+            , boost::movelib::to_raw_pointer(this->members_.m_finish.m_cur)
             );
       }
       else
@@ -1916,7 +1916,7 @@ class deque : protected deque_base<Allocator>
 
    T *priv_push_back_simple_pos() const
    {
-      return container_detail::to_raw_pointer(this->members_.m_finish.m_cur);
+      return boost::movelib::to_raw_pointer(this->members_.m_finish.m_cur);
    }
 
    void priv_push_back_simple_commit()
@@ -1931,7 +1931,7 @@ class deque : protected deque_base<Allocator>
    }
 
    T *priv_push_front_simple_pos() const
-   {  return container_detail::to_raw_pointer(this->members_.m_start.m_cur) - 1;  }
+   {  return boost::movelib::to_raw_pointer(this->members_.m_start.m_cur) - 1;  }
 
    void priv_push_front_simple_commit()
    {  --this->members_.m_start.m_cur;   }
@@ -1940,7 +1940,7 @@ class deque : protected deque_base<Allocator>
    {
       if(!Base::traits_t::trivial_dctr){
          for(;p != p2; ++p){
-            allocator_traits_type::destroy(this->alloc(), container_detail::iterator_to_raw_pointer(p));
+            allocator_traits_type::destroy(this->alloc(), boost::movelib::iterator_to_raw_pointer(p));
          }
       }
    }
@@ -1949,7 +1949,7 @@ class deque : protected deque_base<Allocator>
    {
       if(!Base::traits_t::trivial_dctr){
          for(;p != p2; ++p){
-            allocator_traits_type::destroy(this->alloc(), container_detail::iterator_to_raw_pointer(p));
+            allocator_traits_type::destroy(this->alloc(), boost::movelib::iterator_to_raw_pointer(p));
          }
       }
    }
@@ -2133,7 +2133,7 @@ class deque : protected deque_base<Allocator>
       this->members_.m_finish.m_cur = this->members_.m_finish.m_last - 1;
       allocator_traits_type::destroy
          ( this->alloc()
-         , container_detail::to_raw_pointer(this->members_.m_finish.m_cur)
+         , boost::movelib::to_raw_pointer(this->members_.m_finish.m_cur)
          );
    }
 
@@ -2145,7 +2145,7 @@ class deque : protected deque_base<Allocator>
    {
       allocator_traits_type::destroy
          ( this->alloc()
-         , container_detail::to_raw_pointer(this->members_.m_start.m_cur)
+         , boost::movelib::to_raw_pointer(this->members_.m_start.m_cur)
          );
       this->priv_deallocate_node(this->members_.m_start.m_first);
       this->members_.m_start.priv_set_node(this->members_.m_start.m_node + 1);
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/adaptive_node_pool.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/adaptive_node_pool.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/adaptive_node_pool.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/adaptive_node_pool.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/adaptive_node_pool_impl.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/adaptive_node_pool_impl.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/adaptive_node_pool_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/adaptive_node_pool_impl.hpp
index 24c81dda3b8..54db19dff2b 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/detail/adaptive_node_pool_impl.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/detail/adaptive_node_pool_impl.hpp
@@ -28,10 +28,10 @@
 // container/detail
 #include <boost/container/detail/pool_common.hpp>
 #include <boost/container/detail/iterator.hpp>
-#include <boost/container/detail/iterator_to_raw_pointer.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
 #include <boost/container/detail/math_functions.hpp>
 #include <boost/container/detail/mpl.hpp>
-#include <boost/container/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/detail/type_traits.hpp>
 // intrusive
 #include <boost/intrusive/pointer_traits.hpp>
@@ -378,7 +378,7 @@ class private_adaptive_node_pool_impl
 
    //!Returns the segment manager. Never throws
    segment_manager_base_type* get_segment_manager_base()const
-   {  return container_detail::to_raw_pointer(mp_segment_mngr_base);  }
+   {  return boost::movelib::to_raw_pointer(mp_segment_mngr_base);  }
 
    //!Allocates array of count elements. Can throw
    void *allocate_node()
@@ -390,7 +390,7 @@ class private_adaptive_node_pool_impl
          free_nodes_t &free_nodes = m_block_container.begin()->free_nodes;
          BOOST_ASSERT(!free_nodes.empty());
          const size_type free_nodes_count = free_nodes.size();
-         void *first_node = container_detail::to_raw_pointer(free_nodes.pop_front());
+         void *first_node = boost::movelib::to_raw_pointer(free_nodes.pop_front());
          if(free_nodes.empty()){
             block_container_traits_t::erase_first(m_block_container);
          }
@@ -401,7 +401,7 @@ class private_adaptive_node_pool_impl
       else{
          multiallocation_chain chain;
          this->priv_append_from_new_blocks(1, chain, IsAlignOnly());
-         return container_detail::to_raw_pointer(chain.pop_front());
+         return boost::movelib::to_raw_pointer(chain.pop_front());
       }
    }
 
@@ -492,7 +492,7 @@ class private_adaptive_node_pool_impl
          free_nodes_iterator itf(nodes.begin()), itbf(itbb);
          size_type splice_node_count = size_type(-1);
          while(itf != ite){
-            void *pElem = container_detail::to_raw_pointer(container_detail::iterator_to_raw_pointer(itf));
+            void *pElem = boost::movelib::to_raw_pointer(boost::movelib::iterator_to_raw_pointer(itf));
             block_info_t &block_info = *this->priv_block_from_node(pElem);
             BOOST_ASSERT(block_info.free_nodes.size() < m_real_num_node);
             ++splice_node_count;
@@ -631,7 +631,7 @@ class private_adaptive_node_pool_impl
          BOOST_ASSERT(to_deallocate->free_nodes.size() == mp_impl->m_real_num_node);
          BOOST_ASSERT(0 == to_deallocate->hdr_offset);
          hdr_offset_holder *hdr_off_holder =
-            mp_impl->priv_first_subblock_from_block(container_detail::to_raw_pointer(to_deallocate));
+            mp_impl->priv_first_subblock_from_block(boost::movelib::to_raw_pointer(to_deallocate));
          m_chain.push_back(hdr_off_holder);
       }
 
@@ -763,7 +763,7 @@ class private_adaptive_node_pool_impl
       //First add all possible nodes to the chain
       const size_type left = total_elements - chain.size();
       const size_type max_chain = (num_node < left) ? num_node : left;
-      mem_address = static_cast<char *>(container_detail::to_raw_pointer
+      mem_address = static_cast<char *>(boost::movelib::to_raw_pointer
          (chain.incorporate_after(chain.last(), void_pointer(mem_address), m_real_node_size, max_chain)));
       //Now store remaining nodes in the free list
       if(const size_type max_free = num_node - max_chain){
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/addressof.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/addressof.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/addressof.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/addressof.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/advanced_insert_int.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/advanced_insert_int.hpp
similarity index 96%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/advanced_insert_int.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/advanced_insert_int.hpp
index 278cd1b3f1d..20adb523a6e 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/detail/advanced_insert_int.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/detail/advanced_insert_int.hpp
@@ -31,7 +31,7 @@
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/iterator.hpp>
 #include <boost/container/detail/iterators.hpp>
-#include <boost/container/detail/iterator_to_raw_pointer.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 #include <boost/move/detail/fwd_macros.hpp>
 #endif
@@ -107,8 +107,8 @@ struct insert_n_copies_proxy
 
    void copy_n_and_update(Allocator &, Iterator p, size_type n) const
    {
-	   for (; 0 < n; --n, ++p){
-		   *p = v_;
+      for (; 0 < n; --n, ++p){
+         *p = v_;
       }
    }
 
@@ -157,7 +157,7 @@ struct insert_copy_proxy
    void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
-      alloc_traits::construct( a, iterator_to_raw_pointer(p), v_);
+      alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), v_);
    }
 
    void copy_n_and_update(Allocator &, Iterator p, size_type n) const
@@ -184,7 +184,7 @@ struct insert_move_proxy
    void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
-      alloc_traits::construct( a, iterator_to_raw_pointer(p), ::boost::move(v_) );
+      alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::move(v_) );
    }
 
    void copy_n_and_update(Allocator &, Iterator p, size_type n) const
@@ -240,7 +240,7 @@ struct insert_nonmovable_emplace_proxy
    void priv_uninitialized_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, size_type n)
    {
       BOOST_ASSERT(n == 1); (void)n;
-      alloc_traits::construct( a, iterator_to_raw_pointer(p), ::boost::forward<Args>(get<IdxPack>(this->args_))... );
+      alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::forward<Args>(get<IdxPack>(this->args_))... );
    }
 
    protected:
@@ -354,7 +354,7 @@ struct insert_nonmovable_emplace_proxy##N\
    void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n)\
    {\
       BOOST_ASSERT(n == 1); (void)n;\
-      alloc_traits::construct(a, iterator_to_raw_pointer(p) BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\
+      alloc_traits::construct(a, boost::movelib::iterator_to_raw_pointer(p) BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\
    }\
    \
    void copy_n_and_update(Allocator &, Iterator, size_type)\
diff --git a/contrib/libboost/boost_1_65_0/boost/container/detail/algorithm.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/algorithm.hpp
new file mode 100644
index 00000000000..11844220e1c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/container/detail/algorithm.hpp
@@ -0,0 +1,157 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2014-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/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_CONTAINER_DETAIL_ALGORITHM_HPP
+#define BOOST_CONTAINER_DETAIL_ALGORITHM_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/intrusive/detail/algorithm.hpp>
+
+namespace boost {
+namespace container {
+
+using boost::intrusive::algo_equal;
+using boost::intrusive::algo_lexicographical_compare;
+
+template<class Func>
+class binder1st
+{
+   public:
+	typedef typename Func::second_argument_type  argument_type;
+	typedef typename Func::result_type           result_type;
+
+	binder1st(const Func& func, const typename Func::first_argument_type& arg)
+   	: op(func), value(arg)
+	{}
+
+	result_type operator()(const argument_type& arg) const
+   {	return op(value, arg);  }
+
+	result_type operator()(argument_type& arg) const
+   {  return op(value, arg);   }
+
+   private:
+	Func op;
+	typename Func::first_argument_type value;
+};
+
+template<class Func, class T> 
+inline binder1st<Func> bind1st(const Func& func, const T& arg)
+{	return boost::container::binder1st<Func>(func, arg);  }
+
+template<class Func>
+class binder2nd
+{
+   public:
+	typedef typename Func::first_argument_type   argument_type;
+	typedef typename Func::result_type           result_type;
+
+	binder2nd(const Func& func, const typename Func::second_argument_type& arg)
+	   : op(func), value(arg)
+   {}
+
+	result_type operator()(const argument_type& arg) const
+   {  return op(arg, value);  }
+
+	result_type operator()(argument_type& arg) const
+	{  return op(arg, value);  }
+
+   private:
+	Func op;
+	typename Func::second_argument_type value;
+};
+
+template<class Func, class T>
+inline binder2nd<Func> bind2nd(const Func& func, const T& arg)
+{
+   return (boost::container::binder2nd<Func>(func, arg));
+}
+
+template<class Func>
+class unary_negate
+{
+   public:
+   typedef typename Func::argument_type   argument_type;
+   typedef typename Func::result_type     result_type;
+
+	explicit unary_negate(const Func& func)
+		: m_func(func)
+   {}
+
+	bool operator()(const typename Func::argument_type& arg) const
+	{  return !m_func(arg);  }
+
+   private:
+	Func m_func;
+};
+
+template<class Func> inline
+unary_negate<Func> not1(const Func& func)
+{
+   return boost::container::unary_negate<Func>(func);
+}
+
+template<class InputIt, class UnaryPredicate>
+InputIt find_if(InputIt first, InputIt last, UnaryPredicate p)
+{
+   for (; first != last; ++first) {
+      if (p(*first)) {
+         return first;
+      }
+   }
+   return last;
+}
+
+template<class InputIt, class ForwardIt, class BinaryPredicate>
+InputIt find_first_of(InputIt first1, InputIt last1, ForwardIt first2, ForwardIt last2, BinaryPredicate p)
+{
+   for (; first1 != last1; ++first1) {
+      for (ForwardIt it = first2; it != last2; ++it) {
+         if (p(*first1, *it)) {
+            return first1;
+         }
+      }
+   }
+   return last1;
+}
+
+template<class ForwardIt1, class ForwardIt2, class BinaryPredicate>
+ForwardIt1 search(ForwardIt1 first1, ForwardIt1 last1,
+                        ForwardIt2 first2, ForwardIt2 last2, BinaryPredicate p)
+{
+   for (; ; ++first1) {
+      ForwardIt1 it = first1;
+      for (ForwardIt2 it2 = first2; ; ++it, ++it2) {
+         if (it2 == last2) {
+            return first1;
+         }
+         if (it == last1) {
+            return last1;
+         }
+         if (!p(*it, *it2)) {
+            break;
+         }
+      }
+   }
+}
+
+}  //namespace container {
+}  //namespace boost {
+
+#endif   //#ifndef BOOST_CONTAINER_DETAIL_ALGORITHM_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/alloc_helpers.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/alloc_helpers.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/alloc_helpers.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/alloc_helpers.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/alloc_lib.h b/contrib/libboost/boost_1_65_0/boost/container/detail/alloc_lib.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/alloc_lib.h
rename to contrib/libboost/boost_1_65_0/boost/container/detail/alloc_lib.h
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/allocation_type.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/allocation_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/allocation_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/allocation_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/allocator_version_traits.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/allocator_version_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/allocator_version_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/allocator_version_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/auto_link.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/auto_link.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/auto_link.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/auto_link.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/block_list.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/block_list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/block_list.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/block_list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/block_slist.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/block_slist.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/block_slist.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/block_slist.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/compare_functors.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/compare_functors.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/compare_functors.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/compare_functors.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/config_begin.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/config_begin.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/config_begin.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/config_begin.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/config_end.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/config_end.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/config_end.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/config_end.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/construct_in_place.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/construct_in_place.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/construct_in_place.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/construct_in_place.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/copy_move_algo.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/copy_move_algo.hpp
similarity index 84%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/copy_move_algo.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/copy_move_algo.hpp
index ead93c6035d..9044960e79e 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/detail/copy_move_algo.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/detail/copy_move_algo.hpp
@@ -22,7 +22,7 @@
 #include <boost/container/allocator_traits.hpp>
 // container/detail
 #include <boost/container/detail/iterator.hpp>
-#include <boost/container/detail/iterator_to_raw_pointer.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/construct_in_place.hpp>
@@ -178,7 +178,7 @@ inline F memmove(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
    typedef typename boost::container::iterator_traits<I>::value_type value_type;
    typename boost::container::iterator_traits<I>::difference_type n = boost::container::iterator_distance(f, l);
    if(n){
-      std::memmove((iterator_to_raw_pointer)(r), (iterator_to_raw_pointer)(f), sizeof(value_type)*n);
+      std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
       boost::container::iterator_advance(r, n);
    }
    return r;
@@ -186,12 +186,13 @@ inline F memmove(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
 
 template
    <typename I, // I models InputIterator
+    typename U, // U models unsigned integral constant
     typename F> // F models ForwardIterator
-F memmove_n(I f, typename boost::container::iterator_traits<I>::difference_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+F memmove_n(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {
    typedef typename boost::container::iterator_traits<I>::value_type value_type;
    if(n){
-      std::memmove((iterator_to_raw_pointer)(r), (iterator_to_raw_pointer)(f), sizeof(value_type)*n);
+      std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
       boost::container::iterator_advance(r, n);
    }
    return r;
@@ -199,12 +200,13 @@ F memmove_n(I f, typename boost::container::iterator_traits<I>::difference_type
 
 template
    <typename I, // I models InputIterator
+    typename U, // U models unsigned integral constant
     typename F> // F models ForwardIterator
-I memmove_n_source(I f, typename boost::container::iterator_traits<I>::difference_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+I memmove_n_source(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {
    if(n){
       typedef typename boost::container::iterator_traits<I>::value_type value_type;
-      std::memmove((iterator_to_raw_pointer)(r), (iterator_to_raw_pointer)(f), sizeof(value_type)*n);
+      std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
       boost::container::iterator_advance(f, n);
    }
    return f;
@@ -212,12 +214,13 @@ I memmove_n_source(I f, typename boost::container::iterator_traits<I>::differenc
 
 template
    <typename I, // I models InputIterator
+    typename U, // U models unsigned integral constant
     typename F> // F models ForwardIterator
-I memmove_n_source_dest(I f, typename boost::container::iterator_traits<I>::difference_type n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
+I memmove_n_source_dest(I f, U n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
 {
    typedef typename boost::container::iterator_traits<I>::value_type value_type;
    if(n){
-      std::memmove((iterator_to_raw_pointer)(r), (iterator_to_raw_pointer)(f), sizeof(value_type)*n);
+      std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
       boost::container::iterator_advance(f, n);
       boost::container::iterator_advance(r, n);
    }
@@ -292,13 +295,13 @@ inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F
    F back = r;
    BOOST_TRY{
       while (f != l) {
-         allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), boost::move(*f));
+         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), boost::move(*f));
          ++f; ++r;
       }
    }
    BOOST_CATCH(...){
       for (; back != r; ++back){
-         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
+         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
       BOOST_RETHROW;
    }
@@ -332,18 +335,18 @@ template
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
 inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F, F>::type
-   uninitialized_move_alloc_n(Allocator &a, I f, typename boost::container::iterator_traits<I>::difference_type n, F r)
+   uninitialized_move_alloc_n(Allocator &a, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
 {
    F back = r;
    BOOST_TRY{
       while (n--) {
-         allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), boost::move(*f));
+         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), boost::move(*f));
          ++f; ++r;
       }
    }
    BOOST_CATCH(...){
       for (; back != r; ++back){
-         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
+         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
       BOOST_RETHROW;
    }
@@ -356,7 +359,7 @@ template
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
 inline typename container_detail::enable_if_memtransfer_copy_constructible<I, F, F>::type
-   uninitialized_move_alloc_n(Allocator &, I f, typename boost::container::iterator_traits<I>::difference_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+   uninitialized_move_alloc_n(Allocator &, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return container_detail::memmove_n(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -377,18 +380,18 @@ template
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
 inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F, I>::type
-   uninitialized_move_alloc_n_source(Allocator &a, I f, typename boost::container::iterator_traits<I>::difference_type n, F r)
+   uninitialized_move_alloc_n_source(Allocator &a, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
 {
    F back = r;
    BOOST_TRY{
       while (n--) {
-         allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), boost::move(*f));
+         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), boost::move(*f));
          ++f; ++r;
       }
    }
    BOOST_CATCH(...){
       for (; back != r; ++back){
-         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
+         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
       BOOST_RETHROW;
    }
@@ -401,7 +404,7 @@ template
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
 inline typename container_detail::enable_if_memtransfer_copy_constructible<I, F, I>::type
-   uninitialized_move_alloc_n_source(Allocator &, I f, typename boost::container::iterator_traits<I>::difference_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+   uninitialized_move_alloc_n_source(Allocator &, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return container_detail::memmove_n_source(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -427,13 +430,13 @@ inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F
    F back = r;
    BOOST_TRY{
       while (f != l) {
-         allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), *f);
+         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), *f);
          ++f; ++r;
       }
    }
    BOOST_CATCH(...){
       for (; back != r; ++back){
-         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
+         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
       BOOST_RETHROW;
    }
@@ -467,18 +470,18 @@ template
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
 inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F, F>::type
-   uninitialized_copy_alloc_n(Allocator &a, I f, typename boost::container::iterator_traits<I>::difference_type n, F r)
+   uninitialized_copy_alloc_n(Allocator &a, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
 {
    F back = r;
    BOOST_TRY{
       while (n--) {
-         allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), *f);
+         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), *f);
          ++f; ++r;
       }
    }
    BOOST_CATCH(...){
       for (; back != r; ++back){
-         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
+         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
       BOOST_RETHROW;
    }
@@ -491,7 +494,7 @@ template
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
 inline typename container_detail::enable_if_memtransfer_copy_constructible<I, F, F>::type
-   uninitialized_copy_alloc_n(Allocator &, I f, typename boost::container::iterator_traits<I>::difference_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+   uninitialized_copy_alloc_n(Allocator &, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return container_detail::memmove_n(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -512,18 +515,18 @@ template
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
 inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F, I>::type
-   uninitialized_copy_alloc_n_source(Allocator &a, I f, typename boost::container::iterator_traits<I>::difference_type n, F r)
+   uninitialized_copy_alloc_n_source(Allocator &a, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
 {
    F back = r;
    BOOST_TRY{
       while (n--) {
-         boost::container::construct_in_place(a, container_detail::iterator_to_raw_pointer(r), f);
+         boost::container::construct_in_place(a, boost::movelib::iterator_to_raw_pointer(r), f);
          ++f; ++r;
       }
    }
    BOOST_CATCH(...){
       for (; back != r; ++back){
-         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
+         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
       BOOST_RETHROW;
    }
@@ -536,7 +539,7 @@ template
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
 inline typename container_detail::enable_if_memtransfer_copy_constructible<I, F, I>::type
-   uninitialized_copy_alloc_n_source(Allocator &, I f, typename boost::container::iterator_traits<I>::difference_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+   uninitialized_copy_alloc_n_source(Allocator &, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return container_detail::memmove_n_source(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -556,18 +559,18 @@ template
    <typename Allocator,
     typename F> // F models ForwardIterator
 inline typename container_detail::disable_if_memzero_initializable<F, F>::type
-   uninitialized_value_init_alloc_n(Allocator &a, typename allocator_traits<Allocator>::difference_type n, F r)
+   uninitialized_value_init_alloc_n(Allocator &a, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
 {
    F back = r;
    BOOST_TRY{
       while (n--) {
-         allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r));
+         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r));
          ++r;
       }
    }
    BOOST_CATCH(...){
       for (; back != r; ++back){
-         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
+         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
       BOOST_RETHROW;
    }
@@ -579,10 +582,10 @@ template
    <typename Allocator,
     typename F> // F models ForwardIterator
 inline typename container_detail::enable_if_memzero_initializable<F, F>::type
-   uninitialized_value_init_alloc_n(Allocator &, typename allocator_traits<Allocator>::difference_type n, F r)
+   uninitialized_value_init_alloc_n(Allocator &, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
 {
    typedef typename boost::container::iterator_traits<F>::value_type value_type;
-   std::memset((void*)container_detail::iterator_to_raw_pointer(r), 0, sizeof(value_type)*n);
+   std::memset((void*)boost::movelib::iterator_to_raw_pointer(r), 0, sizeof(value_type)*n);
    boost::container::iterator_advance(r, n);
    return r;
 }
@@ -603,18 +606,18 @@ inline typename container_detail::enable_if_memzero_initializable<F, F>::type
 template
    <typename Allocator,
     typename F> // F models ForwardIterator
-inline F uninitialized_default_init_alloc_n(Allocator &a, typename allocator_traits<Allocator>::difference_type n, F r)
+inline F uninitialized_default_init_alloc_n(Allocator &a, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
 {
    F back = r;
    BOOST_TRY{
       while (n--) {
-         allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), default_init);
+         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), default_init);
          ++r;
       }
    }
    BOOST_CATCH(...){
       for (; back != r; ++back){
-         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
+         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
       BOOST_RETHROW;
    }
@@ -644,13 +647,13 @@ inline void uninitialized_fill_alloc(Allocator &a, F f, F l, const T &t)
    F back = f;
    BOOST_TRY{
       while (f != l) {
-         allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(f), t);
+         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(f), t);
          ++f;
       }
    }
    BOOST_CATCH(...){
       for (; back != l; ++back){
-         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
+         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
       BOOST_RETHROW;
    }
@@ -675,18 +678,18 @@ template
    <typename Allocator,
     typename T,
     typename F> // F models ForwardIterator
-inline F uninitialized_fill_alloc_n(Allocator &a, const T &v, typename allocator_traits<Allocator>::difference_type n, F r)
+inline F uninitialized_fill_alloc_n(Allocator &a, const T &v, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
 {
    F back = r;
    BOOST_TRY{
       while (n--) {
-         allocator_traits<Allocator>::construct(a, container_detail::iterator_to_raw_pointer(r), v);
+         allocator_traits<Allocator>::construct(a, boost::movelib::iterator_to_raw_pointer(r), v);
          ++r;
       }
    }
    BOOST_CATCH(...){
       for (; back != r; ++back){
-         allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(back));
+         allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(back));
       }
       BOOST_RETHROW;
    }
@@ -728,9 +731,10 @@ inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, F>
 
 template
 <typename I,   // I models InputIterator
+typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
 inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, F>::type
-   copy_n(I f, typename boost::container::iterator_traits<I>::difference_type n, F r)
+   copy_n(I f, U n, F r)
 {
    while (n--) {
       *r = *f;
@@ -741,9 +745,10 @@ inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, F
 
 template
 <typename I,   // I models InputIterator
+typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
 inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, F>::type
-   copy_n(I f, typename boost::container::iterator_traits<I>::difference_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+   copy_n(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return container_detail::memmove_n(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -754,9 +759,10 @@ inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, F>
 
 template
 <typename I,   // I models InputIterator
+typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
 inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, I>::type
-   copy_n_source(I f, typename boost::container::iterator_traits<I>::difference_type n, F r)
+   copy_n_source(I f, U n, F r)
 {
    while (n--) {
       boost::container::assign_in_place(r, f);
@@ -767,9 +773,10 @@ inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, I
 
 template
 <typename I,   // I models InputIterator
+typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
 inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, I>::type
-   copy_n_source(I f, typename boost::container::iterator_traits<I>::difference_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+   copy_n_source(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return container_detail::memmove_n_source(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -780,9 +787,10 @@ inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, I>
 
 template
 <typename I,   // I models InputIterator
+typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
 inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, I>::type
-   copy_n_source_dest(I f, typename boost::container::iterator_traits<I>::difference_type n, F &r)
+   copy_n_source_dest(I f, U n, F &r)
 {
    while (n--) {
       *r = *f;
@@ -793,9 +801,10 @@ inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, I
 
 template
 <typename I,   // I models InputIterator
+typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
 inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, I>::type
-   copy_n_source_dest(I f, typename boost::container::iterator_traits<I>::difference_type n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
+   copy_n_source_dest(I f, U n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return container_detail::memmove_n_source_dest(f, n, r);  }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -832,9 +841,10 @@ inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, F>
 
 template
 <typename I,   // I models InputIterator
+typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
 inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, F>::type
-   move_n(I f, typename boost::container::iterator_traits<I>::difference_type n, F r)
+   move_n(I f, U n, F r)
 {
    while (n--) {
       *r = ::boost::move(*f);
@@ -845,9 +855,10 @@ inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, F
 
 template
 <typename I,   // I models InputIterator
+typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
 inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, F>::type
-   move_n(I f, typename boost::container::iterator_traits<I>::difference_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+   move_n(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return container_detail::memmove_n(f, n, r); }
 
 
@@ -879,7 +890,7 @@ inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, F>
    typedef typename boost::container::iterator_traits<I>::value_type value_type;
    const typename boost::container::iterator_traits<I>::difference_type n = boost::container::iterator_distance(f, l);
    r -= n;
-   std::memmove((container_detail::iterator_to_raw_pointer)(r), (container_detail::iterator_to_raw_pointer)(f), sizeof(value_type)*n);
+   std::memmove((boost::movelib::iterator_to_raw_pointer)(r), (boost::movelib::iterator_to_raw_pointer)(f), sizeof(value_type)*n);
    return r;
 }
 
@@ -891,9 +902,10 @@ inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, F>
 
 template
 <typename I    // I models InputIterator
+,typename U    // U models unsigned integral constant
 ,typename F>   // F models ForwardIterator
 inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, I>::type
-   move_n_source_dest(I f, typename boost::container::iterator_traits<I>::difference_type n, F &r)
+   move_n_source_dest(I f, U n, F &r)
 {
    while (n--) {
       *r = ::boost::move(*f);
@@ -904,9 +916,10 @@ inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, I
 
 template
 <typename I    // I models InputIterator
+,typename U    // U models unsigned integral constant
 ,typename F>   // F models ForwardIterator
 inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, I>::type
-   move_n_source_dest(I f, typename boost::container::iterator_traits<I>::difference_type n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
+   move_n_source_dest(I f, U n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return container_detail::memmove_n_source_dest(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -917,9 +930,10 @@ inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, I>
 
 template
 <typename I    // I models InputIterator
+,typename U    // U models unsigned integral constant
 ,typename F>   // F models ForwardIterator
 inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, I>::type
-   move_n_source(I f, typename boost::container::iterator_traits<I>::difference_type n, F r)
+   move_n_source(I f, U n, F r)
 {
    while (n--) {
       *r = ::boost::move(*f);
@@ -930,9 +944,10 @@ inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, I
 
 template
 <typename I    // I models InputIterator
+,typename U    // U models unsigned integral constant
 ,typename F>   // F models ForwardIterator
 inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, I>::type
-   move_n_source(I f, typename boost::container::iterator_traits<I>::difference_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+   move_n_source(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return container_detail::memmove_n_source(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -948,8 +963,9 @@ template
 inline typename container_detail::disable_if_trivially_destructible<I, void>::type
    destroy_alloc_n(Allocator &a, I f, U n)
 {
-   while(n--){
-      allocator_traits<Allocator>::destroy(a, container_detail::iterator_to_raw_pointer(f));
+   while(n){
+      --n;
+      allocator_traits<Allocator>::destroy(a, boost::movelib::iterator_to_raw_pointer(f));
       ++f;
    }
 }
@@ -1006,9 +1022,9 @@ inline typename container_detail::enable_if_c
    storage_type storage;
 
    const std::size_t n_i_bytes = sizeof(value_type)*n_i;
-   void *const large_ptr = static_cast<void*>(container_detail::iterator_to_raw_pointer(large_range_f));
-   void *const short_ptr = static_cast<void*>(container_detail::iterator_to_raw_pointer(short_range_f));
-   void *const stora_ptr = static_cast<void*>(container_detail::iterator_to_raw_pointer(storage));
+   void *const large_ptr = static_cast<void*>(boost::movelib::iterator_to_raw_pointer(large_range_f));
+   void *const short_ptr = static_cast<void*>(boost::movelib::iterator_to_raw_pointer(short_range_f));
+   void *const stora_ptr = static_cast<void*>(boost::movelib::iterator_to_raw_pointer(storage));
    std::memcpy(stora_ptr, large_ptr, n_i_bytes);
    std::memcpy(large_ptr, short_ptr, n_i_bytes);
    std::memcpy(short_ptr, stora_ptr, n_i_bytes);
@@ -1037,8 +1053,8 @@ inline typename container_detail::enable_if_c
    const std::size_t sizeof_storage = sizeof(storage);
 
    std::size_t n_i_bytes = sizeof(value_type)*n_i;
-   char *large_ptr = static_cast<char*>(static_cast<void*>(container_detail::iterator_to_raw_pointer(large_range_f)));
-   char *short_ptr = static_cast<char*>(static_cast<void*>(container_detail::iterator_to_raw_pointer(short_range_f)));
+   char *large_ptr = static_cast<char*>(static_cast<void*>(boost::movelib::iterator_to_raw_pointer(large_range_f)));
+   char *short_ptr = static_cast<char*>(static_cast<void*>(boost::movelib::iterator_to_raw_pointer(short_range_f)));
    char *stora_ptr = static_cast<char*>(static_cast<void*>(&storage));
 
    std::size_t szt_times = n_i_bytes/sizeof_storage;
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/destroyers.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/destroyers.hpp
similarity index 96%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/destroyers.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/destroyers.hpp
index 52b44c0363a..b110561a4a2 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/detail/destroyers.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/detail/destroyers.hpp
@@ -25,7 +25,7 @@
 #include <boost/container/detail/workaround.hpp>
 
 #include <boost/container/allocator_traits.hpp>
-#include <boost/container/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/detail/version_type.hpp>
 
 namespace boost {
@@ -152,7 +152,7 @@ struct scoped_destroy_deallocator
    ~scoped_destroy_deallocator()
    {
       if(m_ptr){
-         AllocTraits::destroy(m_alloc, container_detail::to_raw_pointer(m_ptr));
+         AllocTraits::destroy(m_alloc, boost::movelib::to_raw_pointer(m_ptr));
          priv_deallocate(m_ptr, alloc_version());
       }
    }
@@ -202,7 +202,7 @@ struct scoped_destructor_n
    ~scoped_destructor_n()
    {
       if(!m_p) return;
-      value_type *raw_ptr = container_detail::to_raw_pointer(m_p);
+      value_type *raw_ptr = boost::movelib::to_raw_pointer(m_p);
       while(m_n--){
          AllocTraits::destroy(m_a, raw_ptr++);
       }
@@ -317,7 +317,7 @@ class allocator_destroyer
 
    void operator()(const pointer &p)
    {
-      AllocTraits::destroy(a_, container_detail::to_raw_pointer(p));
+      AllocTraits::destroy(a_, boost::movelib::to_raw_pointer(p));
       this->priv_deallocate(p, alloc_version());
    }
 };
@@ -339,7 +339,7 @@ class allocator_destroyer_and_chain_builder
 
    void operator()(const typename Allocator::pointer &p)
    {
-      allocator_traits<Allocator>::destroy(a_, container_detail::to_raw_pointer(p));
+      allocator_traits<Allocator>::destroy(a_, boost::movelib::to_raw_pointer(p));
       c_.push_back(p);
    }
 };
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/dispatch_uses_allocator.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/dispatch_uses_allocator.hpp
similarity index 87%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/dispatch_uses_allocator.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/dispatch_uses_allocator.hpp
index fdf203cef88..946fdf615bb 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/detail/dispatch_uses_allocator.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/detail/dispatch_uses_allocator.hpp
@@ -287,7 +287,7 @@ template< typename ConstructAlloc, typename ArgAlloc, class Pair \
         , template<class, class, class, class, class, class, class, class, class, class> class BoostTuple \
          BOOST_MOVE_I_IF(BOOST_MOVE_OR(N,M)) BOOST_MOVE_CLASS##N BOOST_MOVE_I_IF(BOOST_MOVE_AND(N,M)) BOOST_MOVE_CLASSQ##M > \
 typename container_detail::enable_if< container_detail::is_pair<Pair> >::type\
-   dispatch_uses_allocator( ConstructAlloc & construct_alloc, ArgAlloc & arg_alloc, Pair* pair, piecewise_construct_t\
+   dispatch_uses_allocator( ConstructAlloc & construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, Pair* pair, piecewise_construct_t\
       , BoostTuple<BOOST_MOVE_TARG##N  BOOST_MOVE_I##N BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,N),::boost::tuples::null_type)> p\
       , BoostTuple<BOOST_MOVE_TARGQ##M BOOST_MOVE_I##M BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,M),::boost::tuples::null_type)> q)\
 {\
@@ -313,7 +313,7 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
 
    template< typename ConstructAlloc, typename ArgAlloc, class Pair
            , template<class ...> class Tuple, class... Args1, class... Args2, size_t... Indexes1, size_t... Indexes2>
-   void dispatch_uses_allocator_index( ConstructAlloc & construct_alloc, ArgAlloc & arg_alloc, Pair* pair
+   void dispatch_uses_allocator_index( ConstructAlloc & construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, Pair* pair
                                     , Tuple<Args1...>& t1, Tuple<Args2...>& t2, index_tuple<Indexes1...>, index_tuple<Indexes2...>)
    {
       (void)t1; (void)t2;
@@ -331,7 +331,7 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
    template< typename ConstructAlloc, typename ArgAlloc, class Pair
            , template<class ...> class Tuple, class... Args1, class... Args2>
    typename container_detail::enable_if< container_detail::is_pair<Pair> >::type
-      dispatch_uses_allocator( ConstructAlloc & construct_alloc, ArgAlloc & arg_alloc, Pair* pair, piecewise_construct_t
+      dispatch_uses_allocator( ConstructAlloc & construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, Pair* pair, piecewise_construct_t
                              , Tuple<Args1...> t1, Tuple<Args2...> t2)
    {
       (dispatch_uses_allocator_index)( construct_alloc, arg_alloc, pair, t1, t2
@@ -347,7 +347,7 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
            , template<class, class, class, class, class, class, class, class, class, class> class StdTuple\
             BOOST_MOVE_I_IF(BOOST_MOVE_OR(N,M)) BOOST_MOVE_CLASS##N BOOST_MOVE_I_IF(BOOST_MOVE_AND(N,M)) BOOST_MOVE_CLASSQ##M > \
    typename container_detail::enable_if< container_detail::is_pair<Pair> >::type\
-      dispatch_uses_allocator(ConstructAlloc & construct_alloc, ArgAlloc & arg_alloc, Pair* pair, piecewise_construct_t\
+      dispatch_uses_allocator(ConstructAlloc & construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, Pair* pair, piecewise_construct_t\
                            , StdTuple<BOOST_MOVE_TARG##N  BOOST_MOVE_I##N BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,N),::std::tr1::_Nil)> p\
                            , StdTuple<BOOST_MOVE_TARGQ##M BOOST_MOVE_I##M BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,M),::std::tr1::_Nil)> q)\
    {\
@@ -382,7 +382,7 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
             BOOST_MOVE_I_IF(BOOST_MOVE_OR(N,M)) BOOST_MOVE_CLASS##N BOOST_MOVE_I_IF(BOOST_MOVE_AND(N,M)) BOOST_MOVE_CLASSQ##M > \
    typename container_detail::enable_if< container_detail::is_pair<Pair> >::type\
       dispatch_uses_allocator\
-         ( ConstructAlloc & construct_alloc, ArgAlloc & arg_alloc, Pair* pair, piecewise_construct_t\
+         ( ConstructAlloc & construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, Pair* pair, piecewise_construct_t\
          , StdTuple<BOOST_MOVE_TARG##N  BOOST_MOVE_I##N BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(BOOST_MOVE_ADD(_VARIADIC_MAX, 3),N),::std::_Nil) > p\
          , StdTuple<BOOST_MOVE_TARGQ##M BOOST_MOVE_I##M BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(BOOST_MOVE_ADD(_VARIADIC_MAX, 3),M),::std::_Nil) > q)\
    {\
@@ -406,6 +406,52 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
 
 #endif   //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+template < typename ConstructAlloc
+         , typename ArgAlloc
+         , class Pair, class KeyType, class ... Args>
+typename container_detail::enable_if< container_detail::is_pair<Pair>, void >::type
+   dispatch_uses_allocator
+   (ConstructAlloc & construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, Pair* p, try_emplace_t, BOOST_FWD_REF(KeyType) k, BOOST_FWD_REF(Args) ...args)
+{
+   (dispatch_uses_allocator)(construct_alloc, arg_alloc, container_detail::addressof(p->first), ::boost::forward<KeyType>(k));
+   BOOST_TRY{
+      (dispatch_uses_allocator)(construct_alloc, arg_alloc, container_detail::addressof(p->second), ::boost::forward<Args>(args)...);
+   }
+   BOOST_CATCH(...) {
+      allocator_traits<ConstructAlloc>::destroy(construct_alloc, container_detail::addressof(p->first));
+      BOOST_RETHROW
+   }
+   BOOST_CATCH_END
+}
+
+#else
+
+#define BOOST_CONTAINER_DISPATCH_USES_ALLOCATOR_PAIR_TRY_EMPLACE_CODE(N) \
+   template <typename ConstructAlloc, typename ArgAlloc, class Pair, class KeyType BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
+   inline typename container_detail::enable_if\
+      < container_detail::is_pair<Pair>, void >::type\
+      dispatch_uses_allocator\
+      (ConstructAlloc &construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, Pair* p, try_emplace_t, \
+       BOOST_FWD_REF(KeyType) k BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   {\
+      (dispatch_uses_allocator)(construct_alloc, arg_alloc, container_detail::addressof(p->first), ::boost::forward<KeyType>(k));\
+      BOOST_TRY{\
+         (dispatch_uses_allocator)(construct_alloc, arg_alloc, container_detail::addressof(p->second) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      }\
+      BOOST_CATCH(...) {\
+         allocator_traits<ConstructAlloc>::destroy(construct_alloc, container_detail::addressof(p->first));\
+         BOOST_RETHROW\
+      }\
+      BOOST_CATCH_END\
+   }\
+//
+BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_DISPATCH_USES_ALLOCATOR_PAIR_TRY_EMPLACE_CODE)
+#undef BOOST_CONTAINER_DISPATCH_USES_ALLOCATOR_PAIR_TRY_EMPLACE_CODE
+
+#endif   //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
 }  //namespace container_detail
 
 }} // namespace boost { namespace container {
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/dlmalloc.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/dlmalloc.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/dlmalloc.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/dlmalloc.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/flat_tree.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/flat_tree.hpp
similarity index 81%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/flat_tree.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/flat_tree.hpp
index db73c410a97..9aab87308a9 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/detail/flat_tree.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/detail/flat_tree.hpp
@@ -28,25 +28,30 @@
 
 #include <boost/container/detail/pair.hpp>
 #include <boost/container/vector.hpp>
+#include <boost/container/allocator_traits.hpp>
+
 #include <boost/container/detail/value_init.hpp>
 #include <boost/container/detail/destroyers.hpp>
 #include <boost/container/detail/algorithm.hpp> //algo_equal(), algo_lexicographical_compare
 #include <boost/container/detail/iterator.hpp>
 #include <boost/container/detail/is_sorted.hpp>
-#include <boost/container/allocator_traits.hpp>
+#include <boost/container/detail/type_traits.hpp>
+#include <boost/container/detail/iterators.hpp>
+
 #ifdef BOOST_CONTAINER_VECTOR_ITERATOR_IS_POINTER
 #include <boost/intrusive/pointer_traits.hpp>
 #endif
-#include <boost/container/detail/type_traits.hpp>
-#include <boost/container/detail/iterators.hpp>
+#include <boost/intrusive/detail/minimal_pair_header.hpp>      //pair
+
 #include <boost/move/make_unique.hpp>
+#include <boost/move/iterator.hpp>
 #include <boost/move/adl_move_swap.hpp>
+#include <boost/move/algo/adaptive_sort.hpp>
+
 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 #include <boost/move/detail/fwd_macros.hpp>
 #endif
 
-#include <boost/intrusive/detail/minimal_pair_header.hpp>      //pair
-#include <boost/move/iterator.hpp>
 
 namespace boost {
 namespace container {
@@ -105,14 +110,17 @@ template <class Value, class KeyOfValue,
           class Compare, class Allocator>
 class flat_tree
 {
-   typedef boost::container::vector<Value, Allocator>    vector_t;
+   public:
+   typedef boost::container::vector<Value, Allocator>    sequence_type;
+
+   private:
    typedef Allocator                                     allocator_t;
    typedef allocator_traits<Allocator>                   allocator_traits_type;
 
    public:
    typedef flat_tree_value_compare<Compare, Value, KeyOfValue> value_compare;
 
- private:
+   private:
    struct Data
       //Inherit from value_compare to do EBO
       : public value_compare
@@ -121,48 +129,48 @@ class flat_tree
 
       public:
       Data()
-         : value_compare(), m_vect()
-      {}
-
-      explicit Data(const Data &d)
-         : value_compare(static_cast<const value_compare&>(d)), m_vect(d.m_vect)
-      {}
-
-      Data(BOOST_RV_REF(Data) d)
-         : value_compare(boost::move(static_cast<value_compare&>(d))), m_vect(boost::move(d.m_vect))
-      {}
-
-      Data(const Data &d, const Allocator &a)
-         : value_compare(static_cast<const value_compare&>(d)), m_vect(d.m_vect, a)
-      {}
-
-      Data(BOOST_RV_REF(Data) d, const Allocator &a)
-         : value_compare(boost::move(static_cast<value_compare&>(d))), m_vect(boost::move(d.m_vect), a)
-      {}
-
-      explicit Data(const Compare &comp)
-         : value_compare(comp), m_vect()
-      {}
-
-      Data(const Compare &comp, const allocator_t &alloc)
-         : value_compare(comp), m_vect(alloc)
+         : value_compare(), m_seq()
       {}
 
       explicit Data(const allocator_t &alloc)
-         : value_compare(), m_vect(alloc)
+         : value_compare(), m_seq(alloc)
+      {}
+
+      explicit Data(const Compare &comp)
+         : value_compare(comp), m_seq()
+      {}
+
+      Data(const Compare &comp, const allocator_t &alloc)
+         : value_compare(comp), m_seq(alloc)
+      {}
+
+      explicit Data(const Data &d)
+         : value_compare(static_cast<const value_compare&>(d)), m_seq(d.m_seq)
+      {}
+
+      Data(BOOST_RV_REF(Data) d)
+         : value_compare(boost::move(static_cast<value_compare&>(d))), m_seq(boost::move(d.m_seq))
+      {}
+
+      Data(const Data &d, const Allocator &a)
+         : value_compare(static_cast<const value_compare&>(d)), m_seq(d.m_seq, a)
+      {}
+
+      Data(BOOST_RV_REF(Data) d, const Allocator &a)
+         : value_compare(boost::move(static_cast<value_compare&>(d))), m_seq(boost::move(d.m_seq), a)
       {}
 
       Data& operator=(BOOST_COPY_ASSIGN_REF(Data) d)
       {
          this->value_compare::operator=(d);
-         m_vect = d.m_vect;
+         m_seq = d.m_seq;
          return *this;
       }
 
       Data& operator=(BOOST_RV_REF(Data) d)
       {
          this->value_compare::operator=(boost::move(static_cast<value_compare &>(d)));
-         m_vect = boost::move(d.m_vect);
+         m_seq = boost::move(d.m_seq);
          return *this;
       }
 
@@ -170,10 +178,10 @@ class flat_tree
       {
          value_compare& mycomp    = *this, & othercomp = d;
          boost::adl_move_swap(mycomp, othercomp);
-         this->m_vect.swap(d.m_vect);
+         this->m_seq.swap(d.m_seq);
       }
 
-      vector_t m_vect;
+      sequence_type m_seq;
    };
 
    Data m_data;
@@ -181,23 +189,23 @@ class flat_tree
 
    public:
 
-   typedef typename vector_t::value_type              value_type;
-   typedef typename vector_t::pointer                 pointer;
-   typedef typename vector_t::const_pointer           const_pointer;
-   typedef typename vector_t::reference               reference;
-   typedef typename vector_t::const_reference         const_reference;
-   typedef typename KeyOfValue::type                  key_type;
-   typedef Compare                                    key_compare;
-   typedef typename vector_t::allocator_type          allocator_type;
-   typedef typename vector_t::size_type               size_type;
-   typedef typename vector_t::difference_type         difference_type;
-   typedef typename vector_t::iterator                iterator;
-   typedef typename vector_t::const_iterator          const_iterator;
-   typedef typename vector_t::reverse_iterator        reverse_iterator;
-   typedef typename vector_t::const_reverse_iterator  const_reverse_iterator;
+   typedef typename sequence_type::value_type               value_type;
+   typedef typename sequence_type::pointer                  pointer;
+   typedef typename sequence_type::const_pointer            const_pointer;
+   typedef typename sequence_type::reference                reference;
+   typedef typename sequence_type::const_reference          const_reference;
+   typedef typename KeyOfValue::type                        key_type;
+   typedef Compare                                          key_compare;
+   typedef typename sequence_type::allocator_type           allocator_type;
+   typedef typename sequence_type::size_type                size_type;
+   typedef typename sequence_type::difference_type          difference_type;
+   typedef typename sequence_type::iterator                 iterator;
+   typedef typename sequence_type::const_iterator           const_iterator;
+   typedef typename sequence_type::reverse_iterator         reverse_iterator;
+   typedef typename sequence_type::const_reverse_iterator   const_reverse_iterator;
 
    //!Standard extension
-   typedef allocator_type                             stored_allocator_type;
+   typedef allocator_type                                   stored_allocator_type;
 
    private:
    typedef allocator_traits<stored_allocator_type> stored_allocator_traits;
@@ -211,14 +219,14 @@ class flat_tree
       : m_data(comp)
    { }
 
-   BOOST_CONTAINER_FORCEINLINE flat_tree(const Compare& comp, const allocator_type& a)
-      : m_data(comp, a)
-   { }
-
    BOOST_CONTAINER_FORCEINLINE explicit flat_tree(const allocator_type& a)
       : m_data(a)
    { }
 
+   BOOST_CONTAINER_FORCEINLINE flat_tree(const Compare& comp, const allocator_type& a)
+      : m_data(comp, a)
+   { }
+
    BOOST_CONTAINER_FORCEINLINE flat_tree(const flat_tree& x)
       :  m_data(x.m_data)
    { }
@@ -237,46 +245,92 @@ class flat_tree
    { }
 
    template <class InputIterator>
-   flat_tree( ordered_range_t, InputIterator first, InputIterator last
-            , const Compare& comp     = Compare()
-            , const allocator_type& a = allocator_type())
-      : m_data(comp, a)
+   BOOST_CONTAINER_FORCEINLINE
+   flat_tree( ordered_range_t, InputIterator first, InputIterator last)
+      : m_data()
    {
-      this->m_data.m_vect.insert(this->m_data.m_vect.end(), first, last);
-      BOOST_ASSERT((is_sorted)(this->m_data.m_vect.cbegin(), this->m_data.m_vect.cend(), this->priv_value_comp()));
+      this->m_data.m_seq.insert(this->m_data.m_seq.end(), first, last);
+      BOOST_ASSERT((is_sorted)(this->m_data.m_seq.cbegin(), this->m_data.m_seq.cend(), this->priv_value_comp()));
    }
 
    template <class InputIterator>
-   flat_tree( ordered_unique_range_t, InputIterator first, InputIterator last
-            , const Compare& comp     = Compare()
-            , const allocator_type& a = allocator_type())
-      : m_data(comp, a)
+   BOOST_CONTAINER_FORCEINLINE
+   flat_tree( ordered_range_t, InputIterator first, InputIterator last, const Compare& comp)
+      : m_data(comp)
    {
-      this->m_data.m_vect.insert(this->m_data.m_vect.end(), first, last);
-      BOOST_ASSERT((is_sorted_and_unique)(this->m_data.m_vect.cbegin(), this->m_data.m_vect.cend(), this->priv_value_comp()));
+      this->m_data.m_seq.insert(this->m_data.m_seq.end(), first, last);
+      BOOST_ASSERT((is_sorted)(this->m_data.m_seq.cbegin(), this->m_data.m_seq.cend(), this->priv_value_comp()));
    }
 
    template <class InputIterator>
-   flat_tree( bool unique_insertion
-            , InputIterator first, InputIterator last
-            , const Compare& comp     = Compare()
-            , const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE
+   flat_tree( ordered_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
       : m_data(comp, a)
    {
-      //Use cend() as hint to achieve linear time for
-      //ordered ranges as required by the standard
-      //for the constructor
-      //Call end() every iteration as reallocation might have invalidated iterators
-      if(unique_insertion){
-         for ( ; first != last; ++first){
-            this->insert_unique(this->cend(), *first);
-         }
-      }
-      else{
-         for ( ; first != last; ++first){
-            this->insert_equal(this->cend(), *first);
-         }
-      }
+      this->m_data.m_seq.insert(this->m_data.m_seq.end(), first, last);
+      BOOST_ASSERT((is_sorted)(this->m_data.m_seq.cbegin(), this->m_data.m_seq.cend(), this->priv_value_comp()));
+   }
+
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_tree( ordered_unique_range_t, InputIterator first, InputIterator last)
+      : m_data()
+   {
+      this->m_data.m_seq.insert(this->m_data.m_seq.end(), first, last);
+      BOOST_ASSERT((is_sorted_and_unique)(this->m_data.m_seq.cbegin(), this->m_data.m_seq.cend(), this->priv_value_comp()));
+   }
+
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_tree( ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp)
+      : m_data(comp)
+   {
+      this->m_data.m_seq.insert(this->m_data.m_seq.end(), first, last);
+      BOOST_ASSERT((is_sorted_and_unique)(this->m_data.m_seq.cbegin(), this->m_data.m_seq.cend(), this->priv_value_comp()));
+   }
+
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_tree( ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : m_data(comp, a)
+   {
+      this->m_data.m_seq.insert(this->m_data.m_seq.end(), first, last);
+      BOOST_ASSERT((is_sorted_and_unique)(this->m_data.m_seq.cbegin(), this->m_data.m_seq.cend(), this->priv_value_comp()));
+   }
+
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_tree( bool unique_insertion, InputIterator first, InputIterator last)
+      : m_data()
+   {
+      this->priv_range_insertion_construct(unique_insertion, first, last);
+   }
+
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_tree( bool unique_insertion, InputIterator first, InputIterator last
+            , const Compare& comp)
+      : m_data(comp)
+   {
+      this->priv_range_insertion_construct(unique_insertion, first, last);
+   }
+
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_tree( bool unique_insertion, InputIterator first, InputIterator last
+            , const allocator_type& a)
+      : m_data(a)
+   {
+      this->priv_range_insertion_construct(unique_insertion, first, last);
+   }
+
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_tree( bool unique_insertion, InputIterator first, InputIterator last
+            , const Compare& comp, const allocator_type& a)
+      : m_data(comp, a)
+   {
+      this->priv_range_insertion_construct(unique_insertion, first, last);
    }
 
    BOOST_CONTAINER_FORCEINLINE ~flat_tree()
@@ -312,31 +366,31 @@ class flat_tree
    { return this->m_data; }
 
    BOOST_CONTAINER_FORCEINLINE allocator_type get_allocator() const
-   { return this->m_data.m_vect.get_allocator(); }
+   { return this->m_data.m_seq.get_allocator(); }
 
    BOOST_CONTAINER_FORCEINLINE const stored_allocator_type &get_stored_allocator() const
-   {  return this->m_data.m_vect.get_stored_allocator(); }
+   {  return this->m_data.m_seq.get_stored_allocator(); }
 
    BOOST_CONTAINER_FORCEINLINE stored_allocator_type &get_stored_allocator()
-   {  return this->m_data.m_vect.get_stored_allocator(); }
+   {  return this->m_data.m_seq.get_stored_allocator(); }
 
    BOOST_CONTAINER_FORCEINLINE iterator begin()
-   { return this->m_data.m_vect.begin(); }
+   { return this->m_data.m_seq.begin(); }
 
    BOOST_CONTAINER_FORCEINLINE const_iterator begin() const
    { return this->cbegin(); }
 
    BOOST_CONTAINER_FORCEINLINE const_iterator cbegin() const
-   { return this->m_data.m_vect.begin(); }
+   { return this->m_data.m_seq.begin(); }
 
    BOOST_CONTAINER_FORCEINLINE iterator end()
-   { return this->m_data.m_vect.end(); }
+   { return this->m_data.m_seq.end(); }
 
    BOOST_CONTAINER_FORCEINLINE const_iterator end() const
    { return this->cend(); }
 
    BOOST_CONTAINER_FORCEINLINE const_iterator cend() const
-   { return this->m_data.m_vect.end(); }
+   { return this->m_data.m_seq.end(); }
 
    BOOST_CONTAINER_FORCEINLINE reverse_iterator rbegin()
    { return reverse_iterator(this->end()); }
@@ -357,13 +411,13 @@ class flat_tree
    { return const_reverse_iterator(this->cbegin()); }
 
    BOOST_CONTAINER_FORCEINLINE bool empty() const
-   { return this->m_data.m_vect.empty(); }
+   { return this->m_data.m_seq.empty(); }
 
    BOOST_CONTAINER_FORCEINLINE size_type size() const
-   { return this->m_data.m_vect.size(); }
+   { return this->m_data.m_seq.size(); }
 
    BOOST_CONTAINER_FORCEINLINE size_type max_size() const
-   { return this->m_data.m_vect.max_size(); }
+   { return this->m_data.m_seq.max_size(); }
 
    BOOST_CONTAINER_FORCEINLINE void swap(flat_tree& other)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
@@ -395,21 +449,20 @@ class flat_tree
    iterator insert_equal(const value_type& val)
    {
       iterator i = this->upper_bound(KeyOfValue()(val));
-      i = this->m_data.m_vect.insert(i, val);
+      i = this->m_data.m_seq.insert(i, val);
       return i;
    }
 
    iterator insert_equal(BOOST_RV_REF(value_type) mval)
    {
       iterator i = this->upper_bound(KeyOfValue()(mval));
-      i = this->m_data.m_vect.insert(i, boost::move(mval));
+      i = this->m_data.m_seq.insert(i, boost::move(mval));
       return i;
    }
 
    iterator insert_unique(const_iterator hint, const value_type& val)
    {
       BOOST_ASSERT(this->priv_in_range_or_end(hint));
-      std::pair<iterator,bool> ret;
       insert_commit_data data;
       return this->priv_insert_unique_prepare(hint, KeyOfValue()(val), data)
             ? this->priv_insert_commit(data, val)
@@ -419,7 +472,6 @@ class flat_tree
    iterator insert_unique(const_iterator hint, BOOST_RV_REF(value_type) val)
    {
       BOOST_ASSERT(this->priv_in_range_or_end(hint));
-      std::pair<iterator,bool> ret;
       insert_commit_data data;
       return this->priv_insert_unique_prepare(hint, KeyOfValue()(val), data)
          ? this->priv_insert_commit(data, boost::move(val))
@@ -511,7 +563,7 @@ class flat_tree
          >::type * = 0
       #endif
       )
-   {   this->m_data.m_vect.merge(first, last, static_cast<const value_compare &>(this->m_data));   }
+   {   this->m_data.m_seq.merge(first, last, static_cast<const value_compare &>(this->m_data));   }
 
    template <class InIt>
    void insert_unique(ordered_unique_range_t, InIt first, InIt last
@@ -540,7 +592,7 @@ class flat_tree
          >::type * = 0
       #endif
       )
-   {   this->m_data.m_vect.merge_unique(first, last, static_cast<const value_compare &>(this->m_data));   }
+   {   this->m_data.m_seq.merge_unique(first, last, static_cast<const value_compare &>(this->m_data));   }
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
@@ -608,7 +660,7 @@ class flat_tree
          typedef typename emplace_functor_type<try_emplace_t, KeyType, Args...>::type func_t;
          typedef emplace_iterator<value_type, func_t, difference_type> it_t;
          func_t func(try_emplace_t(), ::boost::forward<KeyType>(key), ::boost::forward<Args>(args)...);
-         ret.first = this->m_data.m_vect.insert(data.position, it_t(func), it_t());
+         ret.first = this->m_data.m_seq.insert(data.position, it_t(func), it_t());
       }
       return ret;
    }
@@ -677,7 +729,7 @@ class flat_tree
          typedef typename emplace_functor_type<try_emplace_t, KeyType BOOST_MOVE_I##N BOOST_MOVE_TARG##N>::type func_t;\
          typedef emplace_iterator<value_type, func_t, difference_type> it_t;\
          func_t func(try_emplace_t(), ::boost::forward<KeyType>(key) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-         ret.first = this->m_data.m_vect.insert(data.position, it_t(func), it_t());\
+         ret.first = this->m_data.m_seq.insert(data.position, it_t(func), it_t());\
       }\
       return ret;\
    }\
@@ -704,29 +756,29 @@ class flat_tree
          typedef typename emplace_functor_type<KeyType, M>::type func_t;
          typedef emplace_iterator<value_type, func_t, difference_type> it_t;
          func_t func(boost::forward<KeyType>(key), boost::forward<M>(obj));
-         ret.first = this->m_data.m_vect.insert(data.position, it_t(func), it_t());
+         ret.first = this->m_data.m_seq.insert(data.position, it_t(func), it_t());
       }
       return ret;
    }
 
    BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator position)
-   {  return this->m_data.m_vect.erase(position);  }
+   {  return this->m_data.m_seq.erase(position);  }
 
    size_type erase(const key_type& k)
    {
       std::pair<iterator,iterator > itp = this->equal_range(k);
       size_type ret = static_cast<size_type>(itp.second-itp.first);
       if (ret){
-         this->m_data.m_vect.erase(itp.first, itp.second);
+         this->m_data.m_seq.erase(itp.first, itp.second);
       }
       return ret;
    }
 
    BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator first, const_iterator last)
-   {  return this->m_data.m_vect.erase(first, last);  }
+   {  return this->m_data.m_seq.erase(first, last);  }
 
    BOOST_CONTAINER_FORCEINLINE void clear()
-   {  this->m_data.m_vect.clear();  }
+   {  this->m_data.m_seq.clear();  }
 
    //! <b>Effects</b>: Tries to deallocate the excess of memory created
    //    with previous allocations. The size of the vector is unchanged
@@ -735,19 +787,19 @@ class flat_tree
    //!
    //! <b>Complexity</b>: Linear to size().
    BOOST_CONTAINER_FORCEINLINE void shrink_to_fit()
-   {  this->m_data.m_vect.shrink_to_fit();  }
+   {  this->m_data.m_seq.shrink_to_fit();  }
 
    BOOST_CONTAINER_FORCEINLINE iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
-   {  return this->m_data.m_vect.nth(n);   }
+   {  return this->m_data.m_seq.nth(n);   }
 
    BOOST_CONTAINER_FORCEINLINE const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
-   {  return this->m_data.m_vect.nth(n);   }
+   {  return this->m_data.m_seq.nth(n);   }
 
    BOOST_CONTAINER_FORCEINLINE size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
-   {  return this->m_data.m_vect.index_of(p);   }
+   {  return this->m_data.m_seq.index_of(p);   }
 
    BOOST_CONTAINER_FORCEINLINE size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
-   {  return this->m_data.m_vect.index_of(p);   }
+   {  return this->m_data.m_seq.index_of(p);   }
 
    // set operations:
    iterator find(const key_type& k)
@@ -795,7 +847,7 @@ class flat_tree
 
    void merge_unique(flat_tree& source)
    {
-      this->m_data.m_vect.merge_unique
+      this->m_data.m_seq.merge_unique
          ( boost::make_move_iterator(source.begin())
          , boost::make_move_iterator(source.end())
          , static_cast<const value_compare &>(this->m_data));
@@ -803,7 +855,7 @@ class flat_tree
 
    void merge_equal(flat_tree& source)
    {
-      this->m_data.m_vect.merge
+      this->m_data.m_seq.merge
          ( boost::make_move_iterator(source.begin())
          , boost::make_move_iterator(source.end())
          , static_cast<const value_compare &>(this->m_data));
@@ -834,10 +886,61 @@ class flat_tree
    {  return this->priv_lower_bound_range(this->cbegin(), this->cend(), k);  }
 
    BOOST_CONTAINER_FORCEINLINE size_type capacity() const
-   { return this->m_data.m_vect.capacity(); }
+   { return this->m_data.m_seq.capacity(); }
 
    BOOST_CONTAINER_FORCEINLINE void reserve(size_type cnt)
-   { this->m_data.m_vect.reserve(cnt);   }
+   { this->m_data.m_seq.reserve(cnt);   }
+
+   BOOST_CONTAINER_FORCEINLINE sequence_type extract_sequence()
+   {
+      return boost::move(m_data.m_seq);
+   }
+
+   BOOST_CONTAINER_FORCEINLINE sequence_type &get_sequence_ref()
+   {
+      return m_data.m_seq;
+   }
+
+   void adopt_sequence_equal(BOOST_RV_REF(sequence_type) seq)
+   {
+      sequence_type &tseq = m_data.m_seq;
+      boost::movelib::adaptive_sort
+         ( boost::movelib::iterator_to_raw_pointer(seq.begin())
+         , boost::movelib::iterator_to_raw_pointer(seq.end())
+         , this->priv_value_comp()
+         , boost::movelib::iterator_to_raw_pointer(tseq.begin() + tseq.size())
+         , tseq.capacity() - tseq.size());
+      tseq = boost::move(seq);
+   }
+
+   void adopt_sequence_equal(ordered_range_t, BOOST_RV_REF(sequence_type) seq)
+   {
+      BOOST_ASSERT((is_sorted)(seq.cbegin(), seq.cend(), this->priv_value_comp()));
+      sequence_type &tseq = m_data.m_seq;
+      tseq = boost::move(seq);
+   }
+
+   void adopt_sequence_unique(BOOST_RV_REF(sequence_type) seq)
+   {
+      sequence_type &tseq = m_data.m_seq;
+      boost::movelib::adaptive_sort
+         ( boost::movelib::iterator_to_raw_pointer(seq.begin())
+         , boost::movelib::iterator_to_raw_pointer(seq.end())
+         , this->priv_value_comp()
+         , boost::movelib::iterator_to_raw_pointer(tseq.begin() + tseq.size())
+         , tseq.capacity() - tseq.size());
+      seq.erase( boost::movelib::unique
+                  (seq.begin(), seq.end(), boost::movelib::negate<value_compare>(this->m_data.get_comp()))
+               , seq.cend());
+      tseq = boost::move(seq);
+   }
+
+   void adopt_sequence_unique(ordered_unique_range_t, BOOST_RV_REF(sequence_type) seq)
+   {
+      BOOST_ASSERT((is_sorted_and_unique)(seq.cbegin(), seq.cend(), this->priv_value_comp()));
+      sequence_type &tseq = m_data.m_seq;
+      tseq = boost::move(seq);
+   }
 
    BOOST_CONTAINER_FORCEINLINE friend bool operator==(const flat_tree& x, const flat_tree& y)
    {
@@ -866,6 +969,25 @@ class flat_tree
 
    private:
 
+   template <class InputIterator>
+   void priv_range_insertion_construct( bool unique_insertion, InputIterator first, InputIterator last)
+   {
+      //Use cend() as hint to achieve linear time for
+      //ordered ranges as required by the standard
+      //for the constructor
+      //Call end() every iteration as reallocation might have invalidated iterators
+      if(unique_insertion){
+         for ( ; first != last; ++first){
+            this->insert_unique(this->cend(), *first);
+         }
+      }
+      else{
+         for ( ; first != last; ++first){
+            this->insert_equal(this->cend(), *first);
+         }
+      }
+   }
+
    BOOST_CONTAINER_FORCEINLINE bool priv_in_range_or_end(const_iterator pos) const
    {
       return (this->begin() <= pos) && (pos <= this->end());
@@ -965,7 +1087,7 @@ class flat_tree
    BOOST_CONTAINER_FORCEINLINE iterator priv_insert_commit
       (insert_commit_data &commit_data, BOOST_FWD_REF(Convertible) convertible)
    {
-      return this->m_data.m_vect.insert
+      return this->m_data.m_seq.insert
          ( commit_data.position
          , boost::forward<Convertible>(convertible));
    }
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/function_detector.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/function_detector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/function_detector.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/function_detector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/is_sorted.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/is_sorted.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/is_sorted.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/is_sorted.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/iterator.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/to_raw_pointer.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/iterator_to_raw_pointer.hpp
similarity index 70%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/to_raw_pointer.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/iterator_to_raw_pointer.hpp
index 0b4445a942f..8c7c8800357 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/detail/to_raw_pointer.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/detail/iterator_to_raw_pointer.hpp
@@ -7,8 +7,8 @@
 // See http://www.boost.org/libs/container for documentation.
 //
 //////////////////////////////////////////////////////////////////////////////
-#ifndef BOOST_CONTAINER_DETAIL_TO_RAW_POINTER_HPP
-#define BOOST_CONTAINER_DETAIL_TO_RAW_POINTER_HPP
+#ifndef BOOST_CONTAINER_DETAIL_ITERATOR_TO_RAW_POINTER_HPP
+#define BOOST_CONTAINER_DETAIL_ITERATOR_TO_RAW_POINTER_HPP
 
 #ifndef BOOST_CONFIG_HPP
 #  include <boost/config.hpp>
@@ -18,16 +18,16 @@
 #  pragma once
 #endif
 
-#include <boost/intrusive/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
 
 namespace boost {
 namespace container {
 namespace container_detail {
 
-using ::boost::intrusive::detail::to_raw_pointer;
+using ::boost::movelib::iterator_to_raw_pointer;
 
 }  //namespace container_detail {
 }  //namespace container {
 }  //namespace boost {
 
-#endif   //#ifndef BOOST_CONTAINER_DETAIL_TO_RAW_POINTER_HPP
+#endif   //#ifndef BOOST_CONTAINER_DETAIL_ITERATOR_TO_RAW_POINTER_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/iterators.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/iterators.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/iterators.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/iterators.hpp
index d3b353a461c..11ffaae65e8 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/detail/iterators.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/detail/iterators.hpp
@@ -809,6 +809,7 @@ class iterator_from_iiterator
    typedef typename types_t::value_type          value_type;
 
    BOOST_CONTAINER_FORCEINLINE iterator_from_iiterator()
+      : m_iit()
    {}
 
    BOOST_CONTAINER_FORCEINLINE explicit iterator_from_iiterator(IIterator iit) BOOST_NOEXCEPT_OR_NOTHROW
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/math_functions.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/math_functions.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/math_functions.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/math_functions.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/min_max.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/min_max.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/min_max.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/min_max.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/minimal_char_traits_header.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/minimal_char_traits_header.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/minimal_char_traits_header.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/minimal_char_traits_header.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/mpl.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/mpl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/mpl.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/mpl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/multiallocation_chain.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/multiallocation_chain.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/multiallocation_chain.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/multiallocation_chain.hpp
index 32f87c8ae9b..bce1b8651f6 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/detail/multiallocation_chain.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/detail/multiallocation_chain.hpp
@@ -24,7 +24,7 @@
 // container
 #include <boost/container/container_fwd.hpp>
 // container/detail
-#include <boost/container/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/detail/transform_iterator.hpp>
 #include <boost/container/detail/type_traits.hpp>
 // intrusive
@@ -63,7 +63,7 @@ class basic_multiallocation_chain
       pointer_traits<node_ptr>                              node_ptr_traits;
 
    static node & to_node(const VoidPointer &p)
-   {  return *static_cast<node*>(static_cast<void*>(container_detail::to_raw_pointer(p)));  }
+   {  return *static_cast<node*>(static_cast<void*>(boost::movelib::to_raw_pointer(p)));  }
 
    static VoidPointer from_node(node &n)
    {  return node_ptr_traits::pointer_to(n);  }
@@ -152,7 +152,7 @@ class basic_multiallocation_chain
          char_ptr prev_elem = elem;
          elem += unit_bytes;
          for(size_type i = 0; i != num_units-1; ++i, elem += unit_bytes){
-            ::new (container_detail::to_raw_pointer(prev_elem)) void_pointer(elem);
+            ::new (boost::movelib::to_raw_pointer(prev_elem)) void_pointer(elem);
             prev_elem = elem;
          }
          slist_impl_.incorporate_after(after_this, to_node_ptr(b), to_node_ptr(prev_elem), num_units);
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/mutex.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/mutex.hpp
similarity index 96%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/mutex.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/mutex.hpp
index 82e8810d0ac..9743614c233 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/detail/mutex.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/detail/mutex.hpp
@@ -1,14 +1,9 @@
-// Copyright (C) 2000 Stephen Cleary
-//
-// 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 updates, documentation, and revision history.
-
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gaztanaga 2007-2013. Distributed under the Boost
+// (C) Copyright Stephen Cleary 2000 
+// (C) Copyright Ion Gaztanaga  2015-2017.
+//
+// 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)
 //
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/next_capacity.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/next_capacity.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/next_capacity.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/next_capacity.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/node_alloc_holder.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/node_alloc_holder.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/node_alloc_holder.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/node_alloc_holder.hpp
index 7ef5d2883e9..b6e602e8841 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/detail/node_alloc_holder.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/detail/node_alloc_holder.hpp
@@ -30,10 +30,10 @@
 #include <boost/container/detail/allocator_version_traits.hpp>
 #include <boost/container/detail/construct_in_place.hpp>
 #include <boost/container/detail/destroyers.hpp>
-#include <boost/container/detail/iterator_to_raw_pointer.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/placement_new.hpp>
-#include <boost/container/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/version_type.hpp>
 // intrusive
@@ -106,23 +106,23 @@ struct node_alloc_holder
       : members_(a)
    {}
 
+   //Constructors for associative containers
+   node_alloc_holder(const value_compare &c, const ValAlloc &a)
+      : members_(a, c)
+   {}
+
    explicit node_alloc_holder(const node_alloc_holder &x)
       : members_(NodeAllocTraits::select_on_container_copy_construction(x.node_alloc()))
    {}
 
+   node_alloc_holder(const node_alloc_holder &x, const value_compare &c)
+      : members_(NodeAllocTraits::select_on_container_copy_construction(x.node_alloc()), c)
+   {}
+
    explicit node_alloc_holder(BOOST_RV_REF(node_alloc_holder) x)
       : members_(boost::move(x.node_alloc()))
    {  this->icont().swap(x.icont());  }
 
-   //Constructors for associative containers
-   explicit node_alloc_holder(const value_compare &c, const ValAlloc &a)
-      : members_(a, c)
-   {}
-
-   explicit node_alloc_holder(const value_compare &c, const node_alloc_holder &x)
-      : members_(NodeAllocTraits::select_on_container_copy_construction(x.node_alloc()), c)
-   {}
-
    explicit node_alloc_holder(const value_compare &c)
       : members_(c)
    {}
@@ -171,7 +171,7 @@ struct node_alloc_holder
       node_deallocator.release();
       //This does not throw
       typedef typename Node::hook_type hook_type;
-      ::new(static_cast<hook_type*>(container_detail::to_raw_pointer(p)), boost_container_new_t()) hook_type;
+      ::new(static_cast<hook_type*>(boost::movelib::to_raw_pointer(p)), boost_container_new_t()) hook_type;
       return (p);
    }
 
@@ -189,7 +189,7 @@ struct node_alloc_holder
           BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
       node_deallocator.release();\
       typedef typename Node::hook_type hook_type;\
-      ::new(static_cast<hook_type*>(container_detail::to_raw_pointer(p)), boost_container_new_t()) hook_type;\
+      ::new(static_cast<hook_type*>(boost::movelib::to_raw_pointer(p)), boost_container_new_t()) hook_type;\
       return (p);\
    }\
    //
@@ -207,7 +207,7 @@ struct node_alloc_holder
       node_deallocator.release();
       //This does not throw
       typedef typename Node::hook_type hook_type;
-      ::new(static_cast<hook_type*>(container_detail::to_raw_pointer(p)), boost_container_new_t()) hook_type;
+      ::new(static_cast<hook_type*>(boost::movelib::to_raw_pointer(p)), boost_container_new_t()) hook_type;
       return (p);
    }
 
@@ -230,13 +230,13 @@ struct node_alloc_holder
       node_deallocator.release();
       //This does not throw
       typedef typename Node::hook_type hook_type;
-      ::new(static_cast<hook_type*>(container_detail::to_raw_pointer(p)), boost_container_new_t()) hook_type;
+      ::new(static_cast<hook_type*>(boost::movelib::to_raw_pointer(p)), boost_container_new_t()) hook_type;
       return (p);
    }
 
    void destroy_node(const NodePtr &nodep)
    {
-      allocator_traits<NodeAlloc>::destroy(this->node_alloc(), container_detail::to_raw_pointer(nodep));
+      allocator_traits<NodeAlloc>::destroy(this->node_alloc(), boost::movelib::to_raw_pointer(nodep));
       this->deallocate_one(nodep);
    }
 
@@ -266,7 +266,7 @@ struct node_alloc_holder
             Deallocator node_deallocator(NodePtr(), nalloc);
             container_detail::scoped_destructor<NodeAlloc> sdestructor(nalloc, 0);
             while(n--){
-               p = container_detail::iterator_to_raw_pointer(itbeg);
+               p = boost::movelib::iterator_to_raw_pointer(itbeg);
                node_deallocator.set(p);
                ++itbeg;
                //This can throw
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/node_pool.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/node_pool.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/node_pool.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/node_pool.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/node_pool_impl.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/node_pool_impl.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/node_pool_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/node_pool_impl.hpp
index 4febf19e905..024bf306c5f 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/detail/node_pool_impl.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/detail/node_pool_impl.hpp
@@ -25,7 +25,7 @@
 #include <boost/container/detail/math_functions.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/pool_common.hpp>
-#include <boost/container/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/detail/type_traits.hpp>
 
 #include <boost/intrusive/pointer_traits.hpp>
@@ -92,7 +92,7 @@ class private_node_pool_impl
 
    //!Returns the segment manager. Never throws
    segment_manager_base_type* get_segment_manager_base()const
-   {  return container_detail::to_raw_pointer(mp_segment_mngr_base);  }
+   {  return boost::movelib::to_raw_pointer(mp_segment_mngr_base);  }
 
    void *allocate_node()
    {  return this->priv_alloc_node();  }
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/pair.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/pair.hpp
similarity index 89%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/pair.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/pair.hpp
index 096f79561e1..4755e569b21 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/detail/pair.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/detail/pair.hpp
@@ -35,16 +35,62 @@
 
 #include <boost/intrusive/detail/minimal_pair_header.hpp>      //pair
 #include <boost/move/utility_core.hpp>
-#include<boost/move/detail/fwd_macros.hpp>
+#include <boost/move/detail/fwd_macros.hpp>
 
 namespace boost {
 namespace tuples {
 
 struct null_type;
 
+template <
+  class T0, class T1, class T2,
+  class T3, class T4, class T5,
+  class T6, class T7, class T8,
+  class T9>
+class tuple;
+
 }  //namespace tuples {
 }  //namespace boost {
 
+namespace boost {
+namespace container {
+namespace pair_impl {
+
+template <class TupleClass>
+struct is_boost_tuple
+{
+   static const bool value = false;
+};
+
+template <
+  class T0, class T1, class T2,
+  class T3, class T4, class T5,
+  class T6, class T7, class T8,
+  class T9>
+struct is_boost_tuple< boost::tuples::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >
+{
+   static const bool value = true;
+};
+
+template<class Tuple>
+struct disable_if_boost_tuple
+   : boost::container::container_detail::disable_if< is_boost_tuple<Tuple> >
+{};
+
+template<class T>
+struct is_tuple_null
+{
+   static const bool value = false;
+};
+
+template<>
+struct is_tuple_null<boost::tuples::null_type>
+{
+   static const bool value = true;
+};
+
+}}}
+
 #if defined(BOOST_MSVC) && (_CPPLIB_VER == 520)
 //MSVC 2010 tuple marker
 namespace std { namespace tr1 { struct _Nil; }}
@@ -66,7 +112,8 @@ namespace container {
    };
 
    template <int Dummy>
-   ::std::piecewise_construct_t *std_piecewise_construct_holder<Dummy>::dummy;
+   ::std::piecewise_construct_t *std_piecewise_construct_holder<Dummy>::dummy =
+      reinterpret_cast< ::std::piecewise_construct_t *>(0x01234);  //Avoid sanitizer errors on references to null pointers
 
 typedef const std::piecewise_construct_t & piecewise_construct_t;
 
@@ -84,8 +131,17 @@ typedef unspecified piecewise_construct_t;
 //! piecewise_construct_t
 static piecewise_construct_t piecewise_construct = BOOST_CONTAINER_DOC1ST(unspecified, *std_piecewise_construct_holder<>::dummy);
 
+///@cond
+
 namespace container_detail {
 
+struct piecewise_construct_use
+{
+   //Avoid warnings of unused "piecewise_construct"
+   piecewise_construct_use()
+   {  (void)&::boost::container::piecewise_construct;   }
+};
+
 template <class T1, class T2>
 struct pair;
 
@@ -130,6 +186,8 @@ struct pair_nat;
 template<typename T, typename U, typename V>
 void get(T); //to enable ADL
 
+///@endcond
+
 template <class T1, class T2>
 struct pair
 {
@@ -224,7 +282,12 @@ struct pair
             BOOST_MOVE_I_IF(BOOST_MOVE_OR(N,M)) BOOST_MOVE_CLASS##N BOOST_MOVE_I_IF(BOOST_MOVE_AND(N,M)) BOOST_MOVE_CLASSQ##M > \
    pair( piecewise_construct_t\
        , BoostTuple<BOOST_MOVE_TARG##N  BOOST_MOVE_I##N BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,N),::boost::tuples::null_type)> p\
-       , BoostTuple<BOOST_MOVE_TARGQ##M BOOST_MOVE_I##M BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,M),::boost::tuples::null_type)> q)\
+       , BoostTuple<BOOST_MOVE_TARGQ##M BOOST_MOVE_I##M BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,M),::boost::tuples::null_type)> q\
+       , typename container_detail::enable_if_c\
+         < pair_impl::is_boost_tuple< BoostTuple<BOOST_MOVE_TARG##N  BOOST_MOVE_I##N BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,N),::boost::tuples::null_type)> >::value &&\
+           !(pair_impl::is_tuple_null<BOOST_MOVE_LAST_TARG##N>::value || pair_impl::is_tuple_null<BOOST_MOVE_LAST_TARGQ##M>::value) \
+         >::type* = 0\
+       )\
       : first(BOOST_MOVE_TMPL_GET##N), second(BOOST_MOVE_TMPL_GETQ##M)\
    { (void)p; (void)q; }\
    //
@@ -242,7 +305,8 @@ struct pair
       {  (void) t1; (void)t2; }
 
       public:
-      template<template<class ...> class Tuple, class... Args1, class... Args2>
+      template< template<class ...> class Tuple, class... Args1, class... Args2
+              , class = typename pair_impl::disable_if_boost_tuple< Tuple<Args1...> >::type>
       pair(piecewise_construct_t, Tuple<Args1...> t1, Tuple<Args2...> t2)
          : pair(t1, t2, typename build_number_seq<sizeof...(Args1)>::type(), typename build_number_seq<sizeof...(Args2)>::type())
       {}
@@ -258,7 +322,8 @@ struct pair
       {  (void)t; return T(::boost::forward<Args>(get<Indexes>(t))...);  }
 
       public:
-      template<template<class ...> class Tuple, class... Args1, class... Args2>
+      template< template<class ...> class Tuple, class... Args1, class... Args2
+              , class = typename pair_impl::disable_if_boost_tuple< Tuple<Args1...> >::type>
       pair(piecewise_construct_t, Tuple<Args1...> t1, Tuple<Args2...> t2)
          : first  (build_from_args<first_type> (::boost::move(t1)))
          , second (build_from_args<second_type>(::boost::move(t2)))
@@ -416,36 +481,6 @@ inline void swap(pair<T1, T2>& x, pair<T1, T2>& y)
 }  //namespace container_detail {
 }  //namespace container {
 
-
-//Without this specialization recursive flat_(multi)map instantiation fails
-//because is_enum needs to instantiate the recursive pair, leading to a compilation error).
-//This breaks the cycle clearly stating that pair is not an enum avoiding any instantiation.
-template<class T>
-struct is_enum;
-
-template<class T, class U>
-struct is_enum< ::boost::container::container_detail::pair<T, U> >
-{
-   static const bool value = false;
-};
-
-template<class T, class U>
-struct is_enum< ::std::pair<T, U> >
-{
-   static const bool value = false;
-};
-
-template <class T>
-struct is_class;
-
-//This specialization is needed to avoid instantiation of pair in
-//is_class, and allow recursive maps.
-template <class T1, class T2>
-struct is_class< ::boost::container::container_detail::pair<T1, T2> >
-{
-   static const bool value = true;
-};
-
 #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
 
 template<class T1, class T2>
diff --git a/contrib/libboost/boost_1_65_0/boost/container/detail/pair_key_mapped_of_value.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/pair_key_mapped_of_value.hpp
new file mode 100644
index 00000000000..6112b87826c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/container/detail/pair_key_mapped_of_value.hpp
@@ -0,0 +1,55 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2013. 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/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_PAIR_KEY_MAPPED_OF_VALUE_HPP
+#define BOOST_CONTAINER_PAIR_KEY_MAPPED_OF_VALUE_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+
+namespace boost {
+namespace container {
+
+template<class Key, class Mapped>
+struct pair_key_mapped_of_value
+{
+   typedef Key    key_type;
+   typedef Mapped mapped_type;
+
+   template<class Pair>
+   const key_type & key_of_value(const Pair &p) const
+   {  return p.first;  }
+
+   template<class Pair>
+   const mapped_type & mapped_of_value(const Pair &p) const
+   {  return p.second;  }
+
+   template<class Pair>
+   key_type & key_of_value(Pair &p) const
+   {  return const_cast<key_type&>(p.first);  }
+
+   template<class Pair>
+   mapped_type & mapped_of_value(Pair &p) const
+   {  return p.second;  }
+
+};
+
+}}
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   // BOOST_CONTAINER_PAIR_KEY_MAPPED_OF_VALUE_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/placement_new.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/placement_new.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/placement_new.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/placement_new.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/pool_common.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/pool_common.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/pool_common.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/pool_common.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/pool_common_alloc.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/pool_common_alloc.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/pool_common_alloc.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/pool_common_alloc.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/pool_resource.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/pool_resource.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/pool_resource.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/pool_resource.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/singleton.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/singleton.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/singleton.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/singleton.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/std_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/std_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/std_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/std_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/transform_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/transform_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/transform_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/transform_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/tree.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/tree.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/tree.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/tree.hpp
index 853d0ad8435..99baf3a2573 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/detail/tree.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/detail/tree.hpp
@@ -493,7 +493,7 @@ class tree
    typedef boost::container::reverse_iterator
       <const_iterator>                                const_reverse_iterator;
    typedef node_handle
-      < Node, value_type, allocator_type, void>       node_type;
+      < NodeAlloc, void>                              node_type;
    typedef insert_return_type_base
       <iterator, node_type>                           insert_return_type;
 
@@ -509,7 +509,11 @@ class tree
       : AllocHolder()
    {}
 
-   BOOST_CONTAINER_FORCEINLINE explicit tree(const key_compare& comp, const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE explicit tree(const key_compare& comp)
+      : AllocHolder(ValComp(comp))
+   {}
+
+   BOOST_CONTAINER_FORCEINLINE explicit tree(const key_compare& comp, const allocator_type& a)
       : AllocHolder(ValComp(comp), a)
    {}
 
@@ -518,85 +522,110 @@ class tree
    {}
 
    template <class InputIterator>
-   tree(bool unique_insertion, InputIterator first, InputIterator last, const key_compare& comp,
-          const allocator_type& a
-      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::enable_if_or
-         < void
-         , container_detail::is_same<alloc_version, version_1>
-         , container_detail::is_input_iterator<InputIterator>
-         >::type * = 0
-      #endif
-         )
+   tree(bool unique_insertion, InputIterator first, InputIterator last)
+      : AllocHolder(value_compare(key_compare()))
+   {
+      this->tree_construct(unique_insertion, first, last);
+      //AllocHolder clears in case of exception
+   }
+
+   template <class InputIterator>
+   tree(bool unique_insertion, InputIterator first, InputIterator last, const key_compare& comp)
+      : AllocHolder(value_compare(comp))
+   {
+      this->tree_construct(unique_insertion, first, last);
+      //AllocHolder clears in case of exception
+   }
+
+   template <class InputIterator>
+   tree(bool unique_insertion, InputIterator first, InputIterator last, const key_compare& comp, const allocator_type& a)
       : AllocHolder(value_compare(comp), a)
+   {
+      this->tree_construct(unique_insertion, first, last);
+      //AllocHolder clears in case of exception
+   }
+
+   //construct with ordered range
+   template <class InputIterator>
+   tree( ordered_range_t, InputIterator first, InputIterator last)
+      : AllocHolder(value_compare(key_compare()))
+   {
+      this->tree_construct(ordered_range_t(), first, last);
+   }
+
+   template <class InputIterator>
+   tree( ordered_range_t, InputIterator first, InputIterator last, const key_compare& comp)
+      : AllocHolder(value_compare(comp))
+   {
+      this->tree_construct(ordered_range_t(), first, last);
+   }
+
+   template <class InputIterator>
+   tree( ordered_range_t, InputIterator first, InputIterator last
+         , const key_compare& comp, const allocator_type& a)
+      : AllocHolder(value_compare(comp), a)
+   {
+      this->tree_construct(ordered_range_t(), first, last);
+   }
+
+   private:
+
+   template <class InputIterator>
+   void tree_construct(bool unique_insertion, InputIterator first, InputIterator last)
    {
       //Use cend() as hint to achieve linear time for
       //ordered ranges as required by the standard
       //for the constructor
-      const const_iterator end_it(this->cend());
       if(unique_insertion){
-         for ( ; first != last; ++first){
-            this->insert_unique_convertible(end_it, *first);
-         }
-      }
-      else{
-         for ( ; first != last; ++first){
-            this->insert_equal_convertible(end_it, *first);
-         }
-      }
-   }
-
-   template <class InputIterator>
-   tree(bool unique_insertion, InputIterator first, InputIterator last, const key_compare& comp,
-          const allocator_type& a
-      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_if_or
-         < void
-         , container_detail::is_same<alloc_version, version_1>
-         , container_detail::is_input_iterator<InputIterator>
-         >::type * = 0
-      #endif
-         )
-      : AllocHolder(value_compare(comp), a)
-   {
-      if(unique_insertion){
-         //Use cend() as hint to achieve linear time for
-         //ordered ranges as required by the standard
-         //for the constructor
          const const_iterator end_it(this->cend());
          for ( ; first != last; ++first){
             this->insert_unique_convertible(end_it, *first);
          }
       }
       else{
-         //Optimized allocation and construction
-         this->allocate_many_and_construct
-            ( first, boost::container::iterator_distance(first, last)
-            , insert_equal_end_hint_functor<Node, Icont>(this->icont()));
+         this->tree_construct_non_unique(first, last);
       }
    }
 
    template <class InputIterator>
-   tree( ordered_range_t, InputIterator first, InputIterator last
-         , const key_compare& comp = key_compare(), const allocator_type& a = allocator_type()
-         #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+   void tree_construct_non_unique(InputIterator first, InputIterator last
+      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
       , typename container_detail::enable_if_or
          < void
          , container_detail::is_same<alloc_version, version_1>
          , container_detail::is_input_iterator<InputIterator>
          >::type * = 0
-         #endif
+      #endif
          )
-      : AllocHolder(value_compare(comp), a)
    {
+      //Use cend() as hint to achieve linear time for
+      //ordered ranges as required by the standard
+      //for the constructor
+      const const_iterator end_it(this->cend());
       for ( ; first != last; ++first){
-         this->push_back_impl(*first);
+         this->insert_equal_convertible(end_it, *first);
       }
    }
 
    template <class InputIterator>
-   tree( ordered_range_t, InputIterator first, InputIterator last
-         , const key_compare& comp = key_compare(), const allocator_type& a = allocator_type()
+   void tree_construct_non_unique(InputIterator first, InputIterator last
+      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+      , typename container_detail::disable_if_or
+         < void
+         , container_detail::is_same<alloc_version, version_1>
+         , container_detail::is_input_iterator<InputIterator>
+         >::type * = 0
+      #endif
+         )
+   {
+      //Optimized allocation and construction
+      this->allocate_many_and_construct
+         ( first, boost::container::iterator_distance(first, last)
+         , insert_equal_end_hint_functor<Node, Icont>(this->icont()));
+   }
+
+   template <class InputIterator>
+   void tree_construct( ordered_range_t, InputIterator first, InputIterator last
          #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
       , typename container_detail::disable_if_or
          < void
@@ -605,16 +634,34 @@ class tree
          >::type * = 0
          #endif
          )
-      : AllocHolder(value_compare(comp), a)
    {
       //Optimized allocation and construction
       this->allocate_many_and_construct
          ( first, boost::container::iterator_distance(first, last)
          , container_detail::push_back_functor<Node, Icont>(this->icont()));
+      //AllocHolder clears in case of exception
    }
 
+   template <class InputIterator>
+   void tree_construct( ordered_range_t, InputIterator first, InputIterator last
+         #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+      , typename container_detail::enable_if_or
+         < void
+         , container_detail::is_same<alloc_version, version_1>
+         , container_detail::is_input_iterator<InputIterator>
+         >::type * = 0
+         #endif
+         )
+   {
+      for ( ; first != last; ++first){
+         this->push_back_impl(*first);
+      }
+   }
+
+   public:
+
    BOOST_CONTAINER_FORCEINLINE tree(const tree& x)
-      :  AllocHolder(x.value_comp(), x)
+      :  AllocHolder(x, x.value_comp())
    {
       this->icont().clone_from
          (x.icont(), typename AllocHolder::cloner(*this), Destroyer(this->node_alloc()));
@@ -630,6 +677,7 @@ class tree
    {
       this->icont().clone_from
          (x.icont(), typename AllocHolder::cloner(*this), Destroyer(this->node_alloc()));
+      //AllocHolder clears in case of exception
    }
 
    tree(BOOST_RV_REF(tree) x, const allocator_type &a)
@@ -642,6 +690,7 @@ class tree
          this->icont().clone_from
             (boost::move(x.icont()), typename AllocHolder::move_cloner(*this), Destroyer(this->node_alloc()));
       }
+      //AllocHolder clears in case of exception
    }
 
    BOOST_CONTAINER_FORCEINLINE ~tree()
@@ -1142,7 +1191,7 @@ class tree
             this->insert_unique_check(hint, KeyOfValue()(nh.value()), data);
          if(ret.second){
             irt.inserted = true;
-            irt.position = iterator(this->icont().insert_unique_commit(*nh.get_node_pointer(), data));
+            irt.position = iterator(this->icont().insert_unique_commit(*nh.get(), data));
             nh.release();
          }
          else{
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/type_traits.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/type_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/type_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/type_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/value_init.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/value_init.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/value_init.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/value_init.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/variadic_templates_tools.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/variadic_templates_tools.hpp
similarity index 87%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/variadic_templates_tools.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/variadic_templates_tools.hpp
index f5101c577c3..e9fa9cd15aa 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/detail/variadic_templates_tools.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/detail/variadic_templates_tools.hpp
@@ -136,21 +136,25 @@ typename get_impl<I, tuple<Values...> >::const_type get(const tuple<Values...>&
 // in a function call.
 ////////////////////////////////////////////////////
 
-template<std::size_t ... Indexes>
-struct index_tuple{};
+template<std::size_t...> struct index_tuple{ typedef index_tuple type; };
 
-template<std::size_t Num, typename Tuple = index_tuple<> >
-struct build_number_seq;
+template<class S1, class S2> struct concat_index_tuple;
 
-template<std::size_t Num, std::size_t ... Indexes>
-struct build_number_seq<Num, index_tuple<Indexes...> >
-   : build_number_seq<Num - 1, index_tuple<Indexes..., sizeof...(Indexes)> >
+template<std::size_t... I1, std::size_t... I2>
+struct concat_index_tuple<index_tuple<I1...>, index_tuple<I2...>>
+  : index_tuple<I1..., (sizeof...(I1)+I2)...>{};
+
+template<std::size_t N> struct build_number_seq;
+
+template<std::size_t N> 
+struct build_number_seq
+   : concat_index_tuple<typename build_number_seq<N/2>::type
+                       ,typename build_number_seq<N - N/2 >::type
+   >::type
 {};
 
-template<std::size_t ... Indexes>
-struct build_number_seq<0, index_tuple<Indexes...> >
-{  typedef index_tuple<Indexes...> type;  };
-
+template<> struct build_number_seq<0> : index_tuple<>{};
+template<> struct build_number_seq<1> : index_tuple<0>{};
 
 }}}   //namespace boost { namespace container { namespace container_detail {
 
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/version_type.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/version_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/version_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/version_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/workaround.hpp b/contrib/libboost/boost_1_65_0/boost/container/detail/workaround.hpp
similarity index 92%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/workaround.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/detail/workaround.hpp
index 64ecd6fd6b5..816d3cc84de 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/detail/workaround.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/detail/workaround.hpp
@@ -49,6 +49,10 @@
    #define BOOST_CONTAINER_FALLTHOUGH BOOST_FALLTHOUGH;
 #endif
 
+#if defined(BOOST_MSVC) && (_MSC_VER < 1400)
+   #define BOOST_CONTAINER_TEMPLATED_CONVERSION_OPERATOR_BROKEN
+#endif
+
 #if !defined(BOOST_NO_CXX11_HDR_TUPLE) || (defined(BOOST_MSVC) && (BOOST_MSVC == 1700 || BOOST_MSVC == 1600))
 #define BOOST_CONTAINER_PAIR_TEST_HAS_HEADER_TUPLE
 #endif
@@ -103,6 +107,9 @@
 #elif defined(BOOST_MSVC) && defined(_DEBUG)
    //"__forceinline" and MSVC seems to have some bugs in debug mode
    #define BOOST_CONTAINER_FORCEINLINE inline
+#elif defined(__GNUC__) && ((__GNUC__ < 4) || (__GNUC__ == 4 && (__GNUC_MINOR__ < 5)))
+   //Older GCCs have problems with forceinline
+   #define BOOST_CONTAINER_FORCEINLINE inline
 #else
    #define BOOST_CONTAINER_FORCEINLINE BOOST_FORCEINLINE
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/container/flat_map.hpp b/contrib/libboost/boost_1_65_0/boost/container/flat_map.hpp
similarity index 75%
rename from contrib/libboost/boost_1_62_0/boost/container/flat_map.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/flat_map.hpp
index b842101feb3..56f12ecbe84 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/flat_map.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/flat_map.hpp
@@ -59,14 +59,15 @@ class flat_multimap;
 namespace container_detail{
 
 template<class D, class S>
-BOOST_CONTAINER_FORCEINLINE static D &force(const S &s)
-{  return *const_cast<D*>((reinterpret_cast<const D*>(&s))); }
+BOOST_CONTAINER_FORCEINLINE static D &force(S &s)
+{  return *reinterpret_cast<D*>(&s); }
 
 template<class D, class S>
-BOOST_CONTAINER_FORCEINLINE static D force_copy(S s)
+BOOST_CONTAINER_FORCEINLINE static D force_copy(const S &s)
 {
-   D *vp = reinterpret_cast<D *>(&s);
-   return D(*vp);
+   const D *const vp = reinterpret_cast<const D *>(&s);
+   D ret_val(*vp);
+   return ret_val;
 }
 
 }  //namespace container_detail{
@@ -144,13 +145,15 @@ class flat_map
          <typename allocator_traits<Allocator>::pointer>::reverse_iterator          reverse_iterator_impl;
    typedef typename container_detail::get_flat_tree_iterators
          <typename allocator_traits<Allocator>::pointer>::const_reverse_iterator    const_reverse_iterator_impl;
+
    public:
    typedef typename impl_tree_t::stored_allocator_type   impl_stored_allocator_type;
+   typedef typename impl_tree_t::sequence_type           impl_sequence_type;
 
-   impl_tree_t &tree()
+   BOOST_CONTAINER_FORCEINLINE impl_tree_t &tree()
    {  return m_flat_tree;  }
 
-   const impl_tree_t &tree() const
+   BOOST_CONTAINER_FORCEINLINE const impl_tree_t &tree() const
    {  return m_flat_tree;  }
 
    private:
@@ -182,8 +185,11 @@ class flat_map
    typedef BOOST_CONTAINER_IMPDEF(reverse_iterator_impl)                            reverse_iterator;
    typedef BOOST_CONTAINER_IMPDEF(const_reverse_iterator_impl)                      const_reverse_iterator;
    typedef BOOST_CONTAINER_IMPDEF(impl_value_type)                                  movable_value_type;
+   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::sequence_type)                   sequence_type;
+
+   //Allocator::value_type must be std::pair<Key, T>
+   BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
 
-   public:
    //////////////////////////////////////////////
    //
    //          construct/copy/destroy
@@ -193,106 +199,183 @@ class flat_map
    //! <b>Effects</b>: Default constructs an empty flat_map.
    //!
    //! <b>Complexity</b>: Constant.
-   flat_map()  BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
-                                 container_detail::is_nothrow_default_constructible<Compare>::value)
+   flat_map() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
+                                container_detail::is_nothrow_default_constructible<Compare>::value)
       : m_flat_tree()
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified allocator.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE explicit flat_map(const allocator_type& a)
+      : m_flat_tree(container_detail::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified
+   //! comparison object.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE explicit flat_map(const Compare& comp)
+      : m_flat_tree(comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified
    //! comparison object and allocator.
    //!
    //! <b>Complexity</b>: Constant.
-   explicit flat_map(const Compare& comp, const allocator_type& a = allocator_type())
-      : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE flat_map(const Compare& comp, const allocator_type& a)
+      : m_flat_tree(comp, container_detail::force<const impl_allocator_type>(a))
+   {}
 
-   //! <b>Effects</b>: Constructs an empty flat_map using the specified allocator.
-   //!
-   //! <b>Complexity</b>: Constant.
-   explicit flat_map(const allocator_type& a)
-      : m_flat_tree(container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
-
-   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
-   //! allocator, and inserts elements from the range [first ,last ).
+   //! <b>Effects</b>: Constructs an empty flat_map and
+   //! and inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   flat_map(InputIterator first, InputIterator last, const Compare& comp = Compare(),
-         const allocator_type& a = allocator_type())
-      : m_flat_tree(true, first, last, comp, container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE flat_map(InputIterator first, InputIterator last)
+      : m_flat_tree(true, first, last)
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified
    //! allocator, and inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   flat_map(InputIterator first, InputIterator last, const allocator_type& a)
-      : m_flat_tree(true, first, last, Compare(), container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE flat_map(InputIterator first, InputIterator last, const allocator_type& a)
+      : m_flat_tree(true, first, last, container_detail::force<const impl_allocator_type>(a))
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
-   //! allocator, and inserts elements from the ordered unique range [first ,last). This function
+   //! and inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE flat_map(InputIterator first, InputIterator last, const Compare& comp)
+      : m_flat_tree(true, first, last, comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! allocator, and inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE flat_map(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : m_flat_tree(true, first, last, comp, container_detail::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map
+   //! and inserts elements from the ordered range [first ,last). This function
    //! is more efficient than the normal range creation for ordered ranges.
    //!
-   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
-   //! unique values.
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
    //!
    //! <b>Complexity</b>: Linear in N.
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   flat_map( ordered_unique_range_t, InputIterator first, InputIterator last
-           , const Compare& comp = Compare(), const allocator_type& a = allocator_type())
-      : m_flat_tree(ordered_unique_range, first, last, comp, a)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE
+   flat_map(ordered_unique_range_t, InputIterator first, InputIterator last)
+      : m_flat_tree(ordered_range, first, last)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! inserts elements from the ordered range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_map(ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp)
+      : m_flat_tree(ordered_range, first, last, comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! allocator, and inserts elements from the ordered range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_map(ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : m_flat_tree(ordered_range, first, last, comp, a)
+   {}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
-   //! allocator, and inserts elements from the range [il.begin() ,il.end()).
+   //! <b>Effects</b>: Constructs an empty flat_map and
+   //! inserts elements from the range [il.begin() ,il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
-   flat_map(std::initializer_list<value_type> il, const Compare& comp = Compare(),
-          const allocator_type& a = allocator_type())
-     : m_flat_tree(true, il.begin(), il.end(), comp, container_detail::force<impl_allocator_type>(a))
-   {
-       //value_type must be std::pair<Key, T>
-       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE flat_map(std::initializer_list<value_type> il)
+     : m_flat_tree(true, il.begin(), il.end())
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified
    //! allocator, and inserts elements from the range [il.begin() ,il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
-   flat_map(std::initializer_list<value_type> il, const allocator_type& a)
-     : m_flat_tree(true, il.begin(), il.end(), Compare(), container_detail::force<impl_allocator_type>(a))
-   {
-       //value_type must be std::pair<Key, T>
-       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE flat_map(std::initializer_list<value_type> il, const allocator_type& a)
+     : m_flat_tree(true, il.begin(), il.end(), container_detail::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! inserts elements from the range [il.begin() ,il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE flat_map(std::initializer_list<value_type> il, const Compare& comp)
+     : m_flat_tree(true, il.begin(), il.end(), comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! allocator, and inserts elements from the range [il.begin() ,il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE flat_map(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+     : m_flat_tree(true, il.begin(), il.end(), comp, container_detail::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using and
+   //! inserts elements from the ordered unique range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE flat_map(ordered_unique_range_t, std::initializer_list<value_type> il)
+     : m_flat_tree(ordered_unique_range, il.begin(), il.end())
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! inserts elements from the ordered unique range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE flat_map(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp)
+     : m_flat_tree(ordered_unique_range, il.begin(), il.end(), comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
    //! allocator, and inserts elements from the ordered unique range [il.begin(), il.end()). This function
@@ -304,24 +387,17 @@ class flat_map
    //! <b>Complexity</b>: Linear in N.
    //!
    //! <b>Note</b>: Non-standard extension.
-   flat_map(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp = Compare(),
-          const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE flat_map(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
      : m_flat_tree(ordered_unique_range, il.begin(), il.end(), comp, a)
-   {
-       //value_type must be std::pair<Key, T>
-       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 #endif
 
    //! <b>Effects</b>: Copy constructs a flat_map.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_map(const flat_map& x)
+   BOOST_CONTAINER_FORCEINLINE flat_map(const flat_map& x)
       : m_flat_tree(x.m_flat_tree)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Move constructs a flat_map.
    //!   Constructs *this using x's resources.
@@ -329,39 +405,30 @@ class flat_map
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Postcondition</b>: x is emptied.
-   flat_map(BOOST_RV_REF(flat_map) x)
+   BOOST_CONTAINER_FORCEINLINE flat_map(BOOST_RV_REF(flat_map) x)
       BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
       : m_flat_tree(boost::move(x.m_flat_tree))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Copy constructs a flat_map using the specified allocator.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_map(const flat_map& x, const allocator_type &a)
+   BOOST_CONTAINER_FORCEINLINE flat_map(const flat_map& x, const allocator_type &a)
       : m_flat_tree(x.m_flat_tree, a)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Move constructs a flat_map using the specified allocator.
    //!   Constructs *this using x's resources.
    //!
    //! <b>Complexity</b>: Constant if x.get_allocator() == a, linear otherwise.
-   flat_map(BOOST_RV_REF(flat_map) x, const allocator_type &a)
+   BOOST_CONTAINER_FORCEINLINE flat_map(BOOST_RV_REF(flat_map) x, const allocator_type &a)
       : m_flat_tree(boost::move(x.m_flat_tree), a)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Makes *this a copy of x.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_map& operator=(BOOST_COPY_ASSIGN_REF(flat_map) x)
+   BOOST_CONTAINER_FORCEINLINE flat_map& operator=(BOOST_COPY_ASSIGN_REF(flat_map) x)
    {  m_flat_tree = x.m_flat_tree;   return *this;  }
 
    //! <b>Effects</b>: Move constructs a flat_map.
@@ -373,7 +440,7 @@ class flat_map
    //! <b>Complexity</b>: Constant if allocator_traits_type::
    //!   propagate_on_container_move_assignment is true or
    //!   this->get>allocator() == x.get_allocator(). Linear otherwise.
-   flat_map& operator=(BOOST_RV_REF(flat_map) x)
+   BOOST_CONTAINER_FORCEINLINE flat_map& operator=(BOOST_RV_REF(flat_map) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
                            boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
@@ -393,7 +460,7 @@ class flat_map
    //!   was passed to the object's constructor.
    //!
    //! <b>Complexity</b>: Constant.
-   allocator_type get_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE allocator_type get_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<allocator_type>(m_flat_tree.get_allocator()); }
 
    //! <b>Effects</b>: Returns a reference to the internal allocator.
@@ -403,7 +470,7 @@ class flat_map
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension.
-   stored_allocator_type &get_stored_allocator() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE stored_allocator_type &get_stored_allocator() BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
 
    //! <b>Effects</b>: Returns a reference to the internal allocator.
@@ -413,8 +480,8 @@ class flat_map
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension.
-   const stored_allocator_type &get_stored_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
+   BOOST_CONTAINER_FORCEINLINE const stored_allocator_type &get_stored_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
+      { return container_detail::force<const stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
 
    //////////////////////////////////////////////
    //
@@ -427,7 +494,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   iterator begin() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE iterator begin() BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<iterator>(m_flat_tree.begin()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
@@ -435,7 +502,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_iterator begin() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE const_iterator begin() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_iterator>(m_flat_tree.begin()); }
 
    //! <b>Effects</b>: Returns an iterator to the end of the container.
@@ -443,7 +510,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   iterator end() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE iterator end() BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<iterator>(m_flat_tree.end()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
@@ -451,7 +518,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_iterator end() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE const_iterator end() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_iterator>(m_flat_tree.end()); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning
@@ -460,7 +527,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rbegin() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE reverse_iterator rbegin() BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<reverse_iterator>(m_flat_tree.rbegin()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
@@ -469,7 +536,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rbegin() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE const_reverse_iterator rbegin() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.rbegin()); }
 
    //! <b>Effects</b>: Returns a reverse_iterator pointing to the end
@@ -478,7 +545,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   reverse_iterator rend() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE reverse_iterator rend() BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<reverse_iterator>(m_flat_tree.rend()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
@@ -487,7 +554,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator rend() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE const_reverse_iterator rend() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.rend()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container.
@@ -495,7 +562,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cbegin() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE const_iterator cbegin() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_iterator>(m_flat_tree.cbegin()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the container.
@@ -503,7 +570,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cend() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE const_iterator cend() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_iterator>(m_flat_tree.cend()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning
@@ -512,7 +579,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crbegin() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE const_reverse_iterator crbegin() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.crbegin()); }
 
    //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end
@@ -521,7 +588,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_reverse_iterator crend() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE const_reverse_iterator crend() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.crend()); }
 
    //////////////////////////////////////////////
@@ -535,7 +602,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   bool empty() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE bool empty() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.empty(); }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the container.
@@ -543,7 +610,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   size_type size() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE size_type size() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.size(); }
 
    //! <b>Effects</b>: Returns the largest possible size of the container.
@@ -551,7 +618,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.max_size(); }
 
    //! <b>Effects</b>: Number of elements for which memory has been allocated.
@@ -560,7 +627,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   size_type capacity() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE size_type capacity() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.capacity(); }
 
    //! <b>Effects</b>: If n is less than or equal to capacity(), this call has no
@@ -572,7 +639,7 @@ class flat_map
    //!
    //! <b>Note</b>: If capacity() is less than "cnt", iterators and references to
    //!   to values might be invalidated.
-   void reserve(size_type cnt)
+   BOOST_CONTAINER_FORCEINLINE void reserve(size_type cnt)
       { m_flat_tree.reserve(cnt);   }
 
    //! <b>Effects</b>: Tries to deallocate the excess of memory created
@@ -581,7 +648,7 @@ class flat_map
    //! <b>Throws</b>: If memory allocation throws, or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to size().
-   void shrink_to_fit()
+   BOOST_CONTAINER_FORCEINLINE void shrink_to_fit()
       { m_flat_tree.shrink_to_fit(); }
 
    //////////////////////////////////////////////
@@ -608,8 +675,8 @@ class flat_map
    mapped_type &operator[](key_type &&k) ;
    #elif defined(BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN)
       //in compilers like GCC 3.4, we can't catch temporaries
-      mapped_type& operator[](const key_type &k)         {  return this->priv_subscript(k);  }
-      mapped_type& operator[](BOOST_RV_REF(key_type) k)  {  return this->priv_subscript(::boost::move(k));  }
+      BOOST_CONTAINER_FORCEINLINE mapped_type& operator[](const key_type &k)         {  return this->priv_subscript(k);  }
+      BOOST_CONTAINER_FORCEINLINE mapped_type& operator[](BOOST_RV_REF(key_type) k)  {  return this->priv_subscript(::boost::move(k));  }
    #else
       BOOST_MOVE_CONVERSION_AWARE_CATCH( operator[] , key_type, mapped_type&, this->priv_subscript)
    #endif
@@ -705,19 +772,19 @@ class flat_map
    }
 
    //! @copydoc ::boost::container::flat_set::nth(size_type)
-   iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {  return container_detail::force_copy<iterator>(m_flat_tree.nth(n));  }
 
    //! @copydoc ::boost::container::flat_set::nth(size_type) const
-   const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
    {  return container_detail::force_copy<iterator>(m_flat_tree.nth(n));  }
 
    //! @copydoc ::boost::container::flat_set::index_of(iterator)
-   size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
    {  return m_flat_tree.index_of(container_detail::force_copy<impl_iterator>(p));  }
 
    //! @copydoc ::boost::container::flat_set::index_of(const_iterator) const
-   size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
    {  return m_flat_tree.index_of(container_detail::force_copy<impl_const_iterator>(p));  }
 
    //! Returns: A reference to the element whose key is equivalent to x.
@@ -769,7 +836,7 @@ class flat_map
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
-   std::pair<iterator,bool> emplace(BOOST_FWD_REF(Args)... args)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> emplace(BOOST_FWD_REF(Args)... args)
    {  return container_detail::force_copy< std::pair<iterator, bool> >(m_flat_tree.emplace_unique(boost::forward<Args>(args)...)); }
 
    //! <b>Effects</b>: Inserts an object of type T constructed with
@@ -785,7 +852,7 @@ class flat_map
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
-   iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
    {
       return container_detail::force_copy<iterator>
          (m_flat_tree.emplace_hint_unique( container_detail::force_copy<impl_const_iterator>(hint)
@@ -869,14 +936,14 @@ class flat_map
 
    #define BOOST_CONTAINER_FLAT_MAP_EMPLACE_CODE(N) \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   std::pair<iterator,bool> emplace(BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> emplace(BOOST_MOVE_UREF##N)\
    {\
       return container_detail::force_copy< std::pair<iterator, bool> >\
          (m_flat_tree.emplace_unique(BOOST_MOVE_FWD##N));\
    }\
    \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {\
       return container_detail::force_copy<iterator>(m_flat_tree.emplace_hint_unique\
          (container_detail::force_copy<impl_const_iterator>(hint) BOOST_MOVE_I##N BOOST_MOVE_FWD##N));\
@@ -921,9 +988,9 @@ class flat_map
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   std::pair<iterator,bool> insert(const value_type& x)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> insert(const value_type& x)
    {  return container_detail::force_copy<std::pair<iterator,bool> >(
-         m_flat_tree.insert_unique(container_detail::force<impl_value_type>(x))); }
+         m_flat_tree.insert_unique(container_detail::force<const impl_value_type>(x))); }
 
    //! <b>Effects</b>: Inserts a new value_type move constructed from the pair if and
    //! only if there is no element in the container with key equivalent to the key of x.
@@ -936,7 +1003,7 @@ class flat_map
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x)
    {  return container_detail::force_copy<std::pair<iterator,bool> >(
       m_flat_tree.insert_unique(boost::move(container_detail::force<impl_value_type>(x)))); }
 
@@ -951,7 +1018,7 @@ class flat_map
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   std::pair<iterator,bool> insert(BOOST_RV_REF(movable_value_type) x)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> insert(BOOST_RV_REF(movable_value_type) x)
    {
       return container_detail::force_copy<std::pair<iterator,bool> >
       (m_flat_tree.insert_unique(boost::move(x)));
@@ -968,11 +1035,11 @@ class flat_map
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, const value_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, const value_type& x)
    {
       return container_detail::force_copy<iterator>(
          m_flat_tree.insert_unique( container_detail::force_copy<impl_const_iterator>(p)
-                                  , container_detail::force<impl_value_type>(x)));
+                                  , container_detail::force<const impl_value_type>(x)));
    }
 
    //! <b>Effects</b>: Inserts an element move constructed from x in the container.
@@ -984,7 +1051,7 @@ class flat_map
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
    {
       return container_detail::force_copy<iterator>
          (m_flat_tree.insert_unique( container_detail::force_copy<impl_const_iterator>(p)
@@ -1000,7 +1067,7 @@ class flat_map
    //!   right before p) plus insertion linear to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, BOOST_RV_REF(movable_value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, BOOST_RV_REF(movable_value_type) x)
    {
       return container_detail::force_copy<iterator>(
          m_flat_tree.insert_unique(container_detail::force_copy<impl_const_iterator>(p), boost::move(x)));
@@ -1016,7 +1083,7 @@ class flat_map
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last)
+   BOOST_CONTAINER_FORCEINLINE void insert(InputIterator first, InputIterator last)
    {  m_flat_tree.insert_unique(first, last);  }
 
    //! <b>Requires</b>: first, last are not iterators into *this.
@@ -1035,7 +1102,7 @@ class flat_map
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   void insert(ordered_unique_range_t, InputIterator first, InputIterator last)
+   BOOST_CONTAINER_FORCEINLINE void insert(ordered_unique_range_t, InputIterator first, InputIterator last)
       {  m_flat_tree.insert_unique(ordered_unique_range, first, last); }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -1046,7 +1113,7 @@ class flat_map
    //!   search time plus N*size() insertion time.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   void insert(std::initializer_list<value_type> il)
+   BOOST_CONTAINER_FORCEINLINE void insert(std::initializer_list<value_type> il)
    {  m_flat_tree.insert_unique(il.begin(), il.end());  }
 
    //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
@@ -1062,7 +1129,7 @@ class flat_map
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    //!
    //! <b>Note</b>: Non-standard extension.
-   void insert(ordered_unique_range_t, std::initializer_list<value_type> il)
+   BOOST_CONTAINER_FORCEINLINE void insert(ordered_unique_range_t, std::initializer_list<value_type> il)
    {  m_flat_tree.insert_unique(ordered_unique_range, il.begin(), il.end()); }
 #endif
 
@@ -1109,7 +1176,7 @@ class flat_map
    //!
    //! <b>Note</b>: Invalidates elements with keys
    //!   not less than the erased element.
-   iterator erase(const_iterator p)
+   BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator p)
    {
       return container_detail::force_copy<iterator>
          (m_flat_tree.erase(container_detail::force_copy<impl_const_iterator>(p)));
@@ -1121,7 +1188,7 @@ class flat_map
    //!
    //! <b>Complexity</b>: Logarithmic search time plus erasure time
    //!   linear to the elements with bigger keys.
-   size_type erase(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE size_type erase(const key_type& x)
       { return m_flat_tree.erase(x); }
 
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
@@ -1132,7 +1199,7 @@ class flat_map
    //!
    //! <b>Complexity</b>: Logarithmic search time plus erasure time
    //!   linear to the elements with bigger keys.
-   iterator erase(const_iterator first, const_iterator last)
+   BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator first, const_iterator last)
    {
       return container_detail::force_copy<iterator>(
          m_flat_tree.erase( container_detail::force_copy<impl_const_iterator>(first)
@@ -1144,7 +1211,7 @@ class flat_map
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   void swap(flat_map& x)
+   BOOST_CONTAINER_FORCEINLINE void swap(flat_map& x)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
                                  && boost::container::container_detail::is_nothrow_swappable<Compare>::value )
    { m_flat_tree.swap(x.m_flat_tree); }
@@ -1154,7 +1221,7 @@ class flat_map
    //! <b>Postcondition</b>: size() == 0.
    //!
    //! <b>Complexity</b>: linear in size().
-   void clear() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE void clear() BOOST_NOEXCEPT_OR_NOTHROW
       { m_flat_tree.clear(); }
 
    //////////////////////////////////////////////
@@ -1167,14 +1234,14 @@ class flat_map
    //!   of which a was constructed.
    //!
    //! <b>Complexity</b>: Constant.
-   key_compare key_comp() const
+   BOOST_CONTAINER_FORCEINLINE key_compare key_comp() const
       { return container_detail::force_copy<key_compare>(m_flat_tree.key_comp()); }
 
    //! <b>Effects</b>: Returns an object of value_compare constructed out
    //!   of the comparison object.
    //!
    //! <b>Complexity</b>: Constant.
-   value_compare value_comp() const
+   BOOST_CONTAINER_FORCEINLINE value_compare value_comp() const
       { return value_compare(container_detail::force_copy<key_compare>(m_flat_tree.key_comp())); }
 
    //////////////////////////////////////////////
@@ -1187,102 +1254,135 @@ class flat_map
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator find(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator find(const key_type& x)
       { return container_detail::force_copy<iterator>(m_flat_tree.find(x)); }
 
    //! <b>Returns</b>: A const_iterator pointing to an element with the key
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   const_iterator find(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE const_iterator find(const key_type& x) const
       { return container_detail::force_copy<const_iterator>(m_flat_tree.find(x)); }
 
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   size_type count(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE size_type count(const key_type& x) const
       {  return static_cast<size_type>(m_flat_tree.find(x) != m_flat_tree.end());  }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator lower_bound(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator lower_bound(const key_type& x)
       {  return container_detail::force_copy<iterator>(m_flat_tree.lower_bound(x)); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key not
    //!   less than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   const_iterator lower_bound(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE const_iterator lower_bound(const key_type& x) const
       {  return container_detail::force_copy<const_iterator>(m_flat_tree.lower_bound(x)); }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator upper_bound(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator upper_bound(const key_type& x)
       {  return container_detail::force_copy<iterator>(m_flat_tree.upper_bound(x)); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key not
    //!   less than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   const_iterator upper_bound(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE const_iterator upper_bound(const key_type& x) const
       {  return container_detail::force_copy<const_iterator>(m_flat_tree.upper_bound(x)); }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic.
-   std::pair<iterator,iterator> equal_range(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,iterator> equal_range(const key_type& x)
       {  return container_detail::force_copy<std::pair<iterator,iterator> >(m_flat_tree.lower_bound_range(x)); }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic.
-   std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
       {  return container_detail::force_copy<std::pair<const_iterator,const_iterator> >(m_flat_tree.lower_bound_range(x)); }
 
+   //! <b>Effects</b>: Extracts the internal sequence container.
+   //!
+   //! <b>Complexity</b>: Same as the move constructor of sequence_type, usually constant.
+   //!
+   //! <b>Postcondition</b>: this->empty()
+   //!
+   //! <b>Throws</b>: If secuence_type's move constructor throws 
+   BOOST_CONTAINER_FORCEINLINE sequence_type extract_sequence()
+   {
+      return boost::move(container_detail::force<sequence_type>(m_flat_tree.get_sequence_ref()));
+   }
+
+   //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
+   //!   one passed externally using the move assignment. Erases non-unique elements.
+   //!
+   //! <b>Complexity</b>: Assuming O(1) move assignment, O(NlogN) with N = seq.size()
+   //!
+   //! <b>Throws</b>: If the comparison or the move constructor throws
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence(BOOST_RV_REF(sequence_type) seq)
+   {  this->m_flat_tree.adopt_sequence_unique(boost::move(container_detail::force<impl_sequence_type>(seq)));  }
+
+   //! <b>Requires</b>: seq shall be ordered according to this->compare()
+   //!   and shall contain unique elements.
+   //!
+   //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
+   //!   one passed externally using the move assignment.
+   //!
+   //! <b>Complexity</b>: Assuming O(1) move assignment, O(1)
+   //!
+   //! <b>Throws</b>: If the move assignment throws
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence(ordered_unique_range_t, BOOST_RV_REF(sequence_type) seq)
+   {  this->m_flat_tree.adopt_sequence_unique(ordered_unique_range_t(), boost::move(container_detail::force<impl_sequence_type>(seq)));  }
+
    //! <b>Effects</b>: Returns true if x and y are equal
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator==(const flat_map& x, const flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator==(const flat_map& x, const flat_map& y)
    {  return x.size() == y.size() && ::boost::container::algo_equal(x.begin(), x.end(), y.begin());  }
 
    //! <b>Effects</b>: Returns true if x and y are unequal
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator!=(const flat_map& x, const flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator!=(const flat_map& x, const flat_map& y)
    {  return !(x == y); }
 
    //! <b>Effects</b>: Returns true if x is less than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator<(const flat_map& x, const flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator<(const flat_map& x, const flat_map& y)
    {  return ::boost::container::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());  }
 
    //! <b>Effects</b>: Returns true if x is greater than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator>(const flat_map& x, const flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator>(const flat_map& x, const flat_map& y)
    {  return y < x;  }
 
    //! <b>Effects</b>: Returns true if x is equal or less than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator<=(const flat_map& x, const flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator<=(const flat_map& x, const flat_map& y)
    {  return !(y < x);  }
 
    //! <b>Effects</b>: Returns true if x is equal or greater than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator>=(const flat_map& x, const flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator>=(const flat_map& x, const flat_map& y)
    {  return !(x < y);  }
 
    //! <b>Effects</b>: x.swap(y)
    //!
    //! <b>Complexity</b>: Constant.
-   friend void swap(flat_map& x, flat_map& y)
+   BOOST_CONTAINER_FORCEINLINE friend void swap(flat_map& x, flat_map& y)
    {  x.swap(y);  }
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -1401,11 +1501,12 @@ class flat_multimap
          <typename allocator_traits<Allocator>::pointer>::const_reverse_iterator    const_reverse_iterator_impl;
    public:
    typedef typename impl_tree_t::stored_allocator_type   impl_stored_allocator_type;
+   typedef typename impl_tree_t::sequence_type           impl_sequence_type;
 
-   impl_tree_t &tree()
+   BOOST_CONTAINER_FORCEINLINE impl_tree_t &tree()
    {  return m_flat_tree;  }
 
-   const impl_tree_t &tree() const
+   BOOST_CONTAINER_FORCEINLINE const impl_tree_t &tree() const
    {  return m_flat_tree;  }
 
    private:
@@ -1437,6 +1538,10 @@ class flat_multimap
    typedef BOOST_CONTAINER_IMPDEF(reverse_iterator_impl)                            reverse_iterator;
    typedef BOOST_CONTAINER_IMPDEF(const_reverse_iterator_impl)                      const_reverse_iterator;
    typedef BOOST_CONTAINER_IMPDEF(impl_value_type)                                  movable_value_type;
+   typedef typename BOOST_CONTAINER_IMPDEF(tree_t::sequence_type)                   sequence_type;
+
+   //Allocator::value_type must be std::pair<Key, T>
+   BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
 
    //////////////////////////////////////////////
    //
@@ -1447,63 +1552,109 @@ class flat_multimap
    //! <b>Effects</b>: Default constructs an empty flat_map.
    //!
    //! <b>Complexity</b>: Constant.
-   flat_multimap() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
-                                     container_detail::is_nothrow_default_constructible<Compare>::value)
+   BOOST_CONTAINER_FORCEINLINE flat_multimap()
+      BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
+                        container_detail::is_nothrow_default_constructible<Compare>::value)
       : m_flat_tree()
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified allocator.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE explicit flat_multimap(const allocator_type& a)
+      : m_flat_tree(container_detail::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison
+   //!   object .
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE explicit flat_multimap(const Compare& comp)
+      : m_flat_tree(comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison
    //!   object and allocator.
    //!
    //! <b>Complexity</b>: Constant.
-   explicit flat_multimap(const Compare& comp,
-                          const allocator_type& a = allocator_type())
-      : m_flat_tree(comp, container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(const Compare& comp, const allocator_type& a)
+      : m_flat_tree(comp, container_detail::force<const impl_allocator_type>(a))
+   {}
 
-   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified allocator.
-   //!
-   //! <b>Complexity</b>: Constant.
-   explicit flat_multimap(const allocator_type& a)
-      : m_flat_tree(container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
-
-   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object
-   //!   and allocator, and inserts elements from the range [first ,last ).
+   //! <b>Effects</b>: Constructs an empty flat_multimap
+   //!   and inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   flat_multimap(InputIterator first, InputIterator last,
-            const Compare& comp        = Compare(),
-            const allocator_type& a = allocator_type())
-      : m_flat_tree(false, first, last, comp, container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(InputIterator first, InputIterator last)
+      : m_flat_tree(false, first, last)
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_multimap using the specified
    //!   allocator, and inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap(InputIterator first, InputIterator last, const allocator_type& a)
-      : m_flat_tree(false, first, last, Compare(), container_detail::force<impl_allocator_type>(a))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+      : m_flat_tree(false, first, last, container_detail::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object
+   //!   and inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(InputIterator first, InputIterator last, const Compare& comp)
+      : m_flat_tree(false, first, last, comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object
+   //!   and allocator, and inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : m_flat_tree(false, first, last, comp, container_detail::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap
+   //! and inserts elements from the ordered range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(ordered_range_t, InputIterator first, InputIterator last)
+      : m_flat_tree(ordered_range, first, last)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object and
+   //! inserts elements from the ordered range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp)
+      : m_flat_tree(ordered_range, first, last, comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object and
    //! allocator, and inserts elements from the ordered range [first ,last). This function
@@ -1515,39 +1666,79 @@ class flat_multimap
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   flat_multimap(ordered_range_t, InputIterator first, InputIterator last,
-            const Compare& comp        = Compare(),
-            const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
       : m_flat_tree(ordered_range, first, last, comp, a)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
-   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //! <b>Effects</b>: Constructs an empty flat_map and
+   //! inserts elements from the range [il.begin(), il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
-   flat_multimap(std::initializer_list<value_type> il, const Compare& comp = Compare(), const allocator_type& a = allocator_type())
-      : m_flat_tree(false, il.begin(), il.end(), comp, container_detail::force<impl_allocator_type>(a))
-   {
-       //value_type must be std::pair<Key, T>
-       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(std::initializer_list<value_type> il)
+      : m_flat_tree(false, il.begin(), il.end())
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_map using the specified
    //! allocator, and inserts elements from the range [il.begin(), il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap(std::initializer_list<value_type> il, const allocator_type& a)
-      : m_flat_tree(false, il.begin(), il.end(), Compare(), container_detail::force<impl_allocator_type>(a))
-   {
-       //value_type must be std::pair<Key, T>
-       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+      : m_flat_tree(false, il.begin(), il.end(), container_detail::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(std::initializer_list<value_type> il, const Compare& comp)
+      : m_flat_tree(false, il.begin(), il.end(), comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_map using the specified comparison object and
+   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+      : m_flat_tree(false, il.begin(), il.end(), comp, container_detail::force<const impl_allocator_type>(a))
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap and
+   //! inserts elements from the ordered range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(ordered_range_t, std::initializer_list<value_type> il)
+      : m_flat_tree(ordered_range, il.begin(), il.end())
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object and
+   //! inserts elements from the ordered range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp)
+      : m_flat_tree(ordered_range, il.begin(), il.end(), comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty flat_multimap using the specified comparison object and
    //! allocator, and inserts elements from the ordered range [il.begin(), il.end()). This function
@@ -1558,68 +1749,59 @@ class flat_multimap
    //! <b>Complexity</b>: Linear in N.
    //!
    //! <b>Note</b>: Non-standard extension.
-   flat_multimap(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp = Compare(),
-                 const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE
+   flat_multimap(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
       : m_flat_tree(ordered_range, il.begin(), il.end(), comp, a)
-   {
-       //value_type must be std::pair<Key, T>
-       BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 #endif
 
    //! <b>Effects</b>: Copy constructs a flat_multimap.
    //!
    //! <b>Complexity</b>: Linear in x.size().
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap(const flat_multimap& x)
       : m_flat_tree(x.m_flat_tree)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Move constructs a flat_multimap. Constructs *this using x's resources.
    //!
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Postcondition</b>: x is emptied.
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap(BOOST_RV_REF(flat_multimap) x)
       BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
       : m_flat_tree(boost::move(x.m_flat_tree))
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Copy constructs a flat_multimap using the specified allocator.
    //!
    //! <b>Complexity</b>: Linear in x.size().
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap(const flat_multimap& x, const allocator_type &a)
       : m_flat_tree(x.m_flat_tree, a)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Move constructs a flat_multimap using the specified allocator.
    //!                 Constructs *this using x's resources.
    //!
    //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise.
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap(BOOST_RV_REF(flat_multimap) x, const allocator_type &a)
       : m_flat_tree(boost::move(x.m_flat_tree), a)
-   {
-      //value_type must be std::pair<Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Makes *this a copy of x.
    //!
    //! <b>Complexity</b>: Linear in x.size().
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap& operator=(BOOST_COPY_ASSIGN_REF(flat_multimap) x)
       {  m_flat_tree = x.m_flat_tree;   return *this;  }
 
    //! <b>Effects</b>: this->swap(x.get()).
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap& operator=(BOOST_RV_REF(flat_multimap) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
@@ -1630,6 +1812,7 @@ class flat_multimap
    //! <b>Effects</b>: Assign content of il to *this
    //!
    //! <b>Complexity</b>: Linear in il.size().
+   BOOST_CONTAINER_FORCEINLINE
    flat_multimap& operator=(std::initializer_list<value_type> il)
    {
       this->clear();
@@ -1642,6 +1825,7 @@ class flat_multimap
    //!   was passed to the object's constructor.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    allocator_type get_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<allocator_type>(m_flat_tree.get_allocator()); }
 
@@ -1652,6 +1836,7 @@ class flat_multimap
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE
    stored_allocator_type &get_stored_allocator() BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
 
@@ -1662,8 +1847,9 @@ class flat_multimap
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE
    const stored_allocator_type &get_stored_allocator() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return container_detail::force<stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
+      { return container_detail::force<const stored_allocator_type>(m_flat_tree.get_stored_allocator()); }
 
    //////////////////////////////////////////////
    //
@@ -1676,6 +1862,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    iterator begin() BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<iterator>(m_flat_tree.begin()); }
 
@@ -1684,6 +1871,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_iterator begin() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_iterator>(m_flat_tree.begin()); }
 
@@ -1692,6 +1880,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    iterator end() BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<iterator>(m_flat_tree.end()); }
 
@@ -1700,6 +1889,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_iterator end() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_iterator>(m_flat_tree.end()); }
 
@@ -1709,6 +1899,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    reverse_iterator rbegin() BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<reverse_iterator>(m_flat_tree.rbegin()); }
 
@@ -1718,6 +1909,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_reverse_iterator rbegin() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.rbegin()); }
 
@@ -1727,6 +1919,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    reverse_iterator rend() BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<reverse_iterator>(m_flat_tree.rend()); }
 
@@ -1736,6 +1929,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_reverse_iterator rend() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.rend()); }
 
@@ -1744,6 +1938,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_iterator cbegin() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_iterator>(m_flat_tree.cbegin()); }
 
@@ -1752,6 +1947,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_iterator cend() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_iterator>(m_flat_tree.cend()); }
 
@@ -1761,6 +1957,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_reverse_iterator crbegin() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.crbegin()); }
 
@@ -1770,6 +1967,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    const_reverse_iterator crend() const BOOST_NOEXCEPT_OR_NOTHROW
       { return container_detail::force_copy<const_reverse_iterator>(m_flat_tree.crend()); }
 
@@ -1784,6 +1982,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    bool empty() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.empty(); }
 
@@ -1792,6 +1991,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    size_type size() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.size(); }
 
@@ -1800,6 +2000,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.max_size(); }
 
@@ -1809,6 +2010,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    size_type capacity() const BOOST_NOEXCEPT_OR_NOTHROW
       { return m_flat_tree.capacity(); }
 
@@ -1821,6 +2023,7 @@ class flat_multimap
    //!
    //! <b>Note</b>: If capacity() is less than "cnt", iterators and references to
    //!   to values might be invalidated.
+   BOOST_CONTAINER_FORCEINLINE
    void reserve(size_type cnt)
       { m_flat_tree.reserve(cnt);   }
 
@@ -1830,22 +2033,27 @@ class flat_multimap
    //! <b>Throws</b>: If memory allocation throws, or T's copy constructor throws.
    //!
    //! <b>Complexity</b>: Linear to size().
+   BOOST_CONTAINER_FORCEINLINE
    void shrink_to_fit()
       { m_flat_tree.shrink_to_fit(); }
 
    //! @copydoc ::boost::container::flat_set::nth(size_type)
+   BOOST_CONTAINER_FORCEINLINE
    iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {  return container_detail::force_copy<iterator>(m_flat_tree.nth(n));  }
 
    //! @copydoc ::boost::container::flat_set::nth(size_type) const
+   BOOST_CONTAINER_FORCEINLINE
    const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
    {  return container_detail::force_copy<iterator>(m_flat_tree.nth(n));  }
 
    //! @copydoc ::boost::container::flat_set::index_of(iterator)
+   BOOST_CONTAINER_FORCEINLINE
    size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
    {  return m_flat_tree.index_of(container_detail::force_copy<impl_iterator>(p));  }
 
    //! @copydoc ::boost::container::flat_set::index_of(const_iterator) const
+   BOOST_CONTAINER_FORCEINLINE
    size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
    {  return m_flat_tree.index_of(container_detail::force_copy<impl_const_iterator>(p));  }
 
@@ -1860,6 +2068,7 @@ class flat_multimap
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
+   BOOST_CONTAINER_FORCEINLINE
    iterator emplace(BOOST_FWD_REF(Args)... args)
    {  return container_detail::force_copy<iterator>(m_flat_tree.emplace_equal(boost::forward<Args>(args)...)); }
 
@@ -1876,6 +2085,7 @@ class flat_multimap
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
+   BOOST_CONTAINER_FORCEINLINE
    iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
    {
       return container_detail::force_copy<iterator>(m_flat_tree.emplace_hint_equal
@@ -1886,11 +2096,11 @@ class flat_multimap
 
    #define BOOST_CONTAINER_FLAT_MULTIMAP_EMPLACE_CODE(N) \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace(BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace(BOOST_MOVE_UREF##N)\
    {  return container_detail::force_copy<iterator>(m_flat_tree.emplace_equal(BOOST_MOVE_FWD##N));  }\
    \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {\
       return container_detail::force_copy<iterator>(m_flat_tree.emplace_hint_equal\
          (container_detail::force_copy<impl_const_iterator>(hint) BOOST_MOVE_I##N BOOST_MOVE_FWD##N));\
@@ -1908,10 +2118,10 @@ class flat_multimap
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const value_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const value_type& x)
    {
       return container_detail::force_copy<iterator>(
-         m_flat_tree.insert_equal(container_detail::force<impl_value_type>(x)));
+         m_flat_tree.insert_equal(container_detail::force<const impl_value_type>(x)));
    }
 
    //! <b>Effects</b>: Inserts a new value move-constructed from x and returns
@@ -1921,7 +2131,7 @@ class flat_multimap
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(BOOST_RV_REF(value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(BOOST_RV_REF(value_type) x)
    { return container_detail::force_copy<iterator>(m_flat_tree.insert_equal(boost::move(x))); }
 
    //! <b>Effects</b>: Inserts a new value move-constructed from x and returns
@@ -1931,7 +2141,7 @@ class flat_multimap
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(BOOST_RV_REF(impl_value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(BOOST_RV_REF(impl_value_type) x)
       { return container_detail::force_copy<iterator>(m_flat_tree.insert_equal(boost::move(x))); }
 
    //! <b>Effects</b>: Inserts a copy of x in the container.
@@ -1945,11 +2155,11 @@ class flat_multimap
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, const value_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, const value_type& x)
    {
       return container_detail::force_copy<iterator>
          (m_flat_tree.insert_equal( container_detail::force_copy<impl_const_iterator>(p)
-                                  , container_detail::force<impl_value_type>(x)));
+                                  , container_detail::force<const impl_value_type>(x)));
    }
 
    //! <b>Effects</b>: Inserts a value move constructed from x in the container.
@@ -1963,7 +2173,7 @@ class flat_multimap
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
    {
       return container_detail::force_copy<iterator>
          (m_flat_tree.insert_equal(container_detail::force_copy<impl_const_iterator>(p)
@@ -1981,7 +2191,7 @@ class flat_multimap
    //!   to the elements with bigger keys than x.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   iterator insert(const_iterator p, BOOST_RV_REF(impl_value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, BOOST_RV_REF(impl_value_type) x)
    {
       return container_detail::force_copy<iterator>(
          m_flat_tree.insert_equal(container_detail::force_copy<impl_const_iterator>(p), boost::move(x)));
@@ -1996,7 +2206,7 @@ class flat_multimap
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last)
+   BOOST_CONTAINER_FORCEINLINE void insert(InputIterator first, InputIterator last)
       {  m_flat_tree.insert_equal(first, last); }
 
    //! <b>Requires</b>: first, last are not iterators into *this.
@@ -2014,7 +2224,7 @@ class flat_multimap
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   void insert(ordered_range_t, InputIterator first, InputIterator last)
+   BOOST_CONTAINER_FORCEINLINE void insert(ordered_range_t, InputIterator first, InputIterator last)
       {  m_flat_tree.insert_equal(ordered_range, first, last); }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -2024,7 +2234,7 @@ class flat_multimap
    //!   search time plus N*size() insertion time.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   void insert(std::initializer_list<value_type> il)
+   BOOST_CONTAINER_FORCEINLINE void insert(std::initializer_list<value_type> il)
    {  m_flat_tree.insert_equal(il.begin(), il.end()); }
 
    //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate.
@@ -2039,7 +2249,7 @@ class flat_multimap
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    //!
    //! <b>Note</b>: Non-standard extension.
-   void insert(ordered_range_t, std::initializer_list<value_type> il)
+   BOOST_CONTAINER_FORCEINLINE void insert(ordered_range_t, std::initializer_list<value_type> il)
    {  m_flat_tree.insert_equal(ordered_range, il.begin(), il.end());  }
 #endif
 
@@ -2057,22 +2267,22 @@ class flat_multimap
    //!
    //! <b>Complexity</b>: N log(a.size() + N) (N has the value source.size())
    template<class C2>
-   void merge(flat_multimap<Key, T, C2, Allocator>& source)
+   BOOST_CONTAINER_FORCEINLINE void merge(flat_multimap<Key, T, C2, Allocator>& source)
    {  m_flat_tree.merge_equal(source.tree());   }
 
    //! @copydoc ::boost::container::flat_multimap::merge(flat_multimap<Key, T, C2, Allocator>&)
    template<class C2>
-   void merge(BOOST_RV_REF_BEG flat_multimap<Key, T, C2, Allocator> BOOST_RV_REF_END source)
+   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_multimap<Key, T, C2, Allocator> BOOST_RV_REF_END source)
    {  return this->merge(static_cast<flat_multimap<Key, T, C2, Allocator>&>(source)); }
 
    //! @copydoc ::boost::container::flat_multimap::merge(flat_multimap<Key, T, C2, Allocator>&)
    template<class C2>
-   void merge(flat_map<Key, T, C2, Allocator>& source)
+   BOOST_CONTAINER_FORCEINLINE void merge(flat_map<Key, T, C2, Allocator>& source)
    {  m_flat_tree.merge_equal(source.tree());   }
 
-   //! @copydoc ::boost::container::flat_multimap::merge(flat_multimap<Key, T, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_multimap::merge(flat_map<Key, T, C2, Allocator>&)
    template<class C2>
-   void merge(BOOST_RV_REF_BEG flat_map<Key, T, C2, Allocator> BOOST_RV_REF_END source)
+   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_map<Key, T, C2, Allocator> BOOST_RV_REF_END source)
    {  return this->merge(static_cast<flat_map<Key, T, C2, Allocator>&>(source)); }
 
    //! <b>Effects</b>: Erases the element pointed to by p.
@@ -2085,7 +2295,7 @@ class flat_multimap
    //!
    //! <b>Note</b>: Invalidates elements with keys
    //!   not less than the erased element.
-   iterator erase(const_iterator p)
+   BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator p)
    {
       return container_detail::force_copy<iterator>(
          m_flat_tree.erase(container_detail::force_copy<impl_const_iterator>(p)));
@@ -2097,7 +2307,7 @@ class flat_multimap
    //!
    //! <b>Complexity</b>: Logarithmic search time plus erasure time
    //!   linear to the elements with bigger keys.
-   size_type erase(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE size_type erase(const key_type& x)
       { return m_flat_tree.erase(x); }
 
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
@@ -2108,7 +2318,7 @@ class flat_multimap
    //!
    //! <b>Complexity</b>: Logarithmic search time plus erasure time
    //!   linear to the elements with bigger keys.
-   iterator erase(const_iterator first, const_iterator last)
+   BOOST_CONTAINER_FORCEINLINE iterator erase(const_iterator first, const_iterator last)
    {
       return container_detail::force_copy<iterator>
          (m_flat_tree.erase( container_detail::force_copy<impl_const_iterator>(first)
@@ -2120,7 +2330,7 @@ class flat_multimap
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   void swap(flat_multimap& x)
+   BOOST_CONTAINER_FORCEINLINE void swap(flat_multimap& x)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
                                  && boost::container::container_detail::is_nothrow_swappable<Compare>::value )
    { m_flat_tree.swap(x.m_flat_tree); }
@@ -2130,7 +2340,7 @@ class flat_multimap
    //! <b>Postcondition</b>: size() == 0.
    //!
    //! <b>Complexity</b>: linear in size().
-   void clear() BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE void clear() BOOST_NOEXCEPT_OR_NOTHROW
       { m_flat_tree.clear(); }
 
    //////////////////////////////////////////////
@@ -2143,14 +2353,14 @@ class flat_multimap
    //!   of which a was constructed.
    //!
    //! <b>Complexity</b>: Constant.
-   key_compare key_comp() const
+   BOOST_CONTAINER_FORCEINLINE key_compare key_comp() const
       { return container_detail::force_copy<key_compare>(m_flat_tree.key_comp()); }
 
    //! <b>Effects</b>: Returns an object of value_compare constructed out
    //!   of the comparison object.
    //!
    //! <b>Complexity</b>: Constant.
-   value_compare value_comp() const
+   BOOST_CONTAINER_FORCEINLINE value_compare value_comp() const
       { return value_compare(container_detail::force_copy<key_compare>(m_flat_tree.key_comp())); }
 
    //////////////////////////////////////////////
@@ -2163,102 +2373,134 @@ class flat_multimap
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator find(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator find(const key_type& x)
       { return container_detail::force_copy<iterator>(m_flat_tree.find(x)); }
 
    //! <b>Returns</b>: An const_iterator pointing to an element with the key
    //!   equivalent to x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   const_iterator find(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE const_iterator find(const key_type& x) const
       { return container_detail::force_copy<const_iterator>(m_flat_tree.find(x)); }
 
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   size_type count(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE size_type count(const key_type& x) const
       { return m_flat_tree.count(x); }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   iterator lower_bound(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator lower_bound(const key_type& x)
       {  return container_detail::force_copy<iterator>(m_flat_tree.lower_bound(x)); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key
    //!   not less than k, or a.end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator lower_bound(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE const_iterator lower_bound(const key_type& x) const
       {  return container_detail::force_copy<const_iterator>(m_flat_tree.lower_bound(x));  }
 
    //! <b>Returns</b>: An iterator pointing to the first element with key not less
    //!   than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   iterator upper_bound(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE iterator upper_bound(const key_type& x)
       {return container_detail::force_copy<iterator>(m_flat_tree.upper_bound(x)); }
 
    //! <b>Returns</b>: A const iterator pointing to the first element with key
    //!   not less than x, or end() if such an element is not found.
    //!
    //! <b>Complexity</b>: Logarithmic
-   const_iterator upper_bound(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE const_iterator upper_bound(const key_type& x) const
       {  return container_detail::force_copy<const_iterator>(m_flat_tree.upper_bound(x)); }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<iterator,iterator> equal_range(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,iterator> equal_range(const key_type& x)
       {  return container_detail::force_copy<std::pair<iterator,iterator> >(m_flat_tree.equal_range(x));   }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
       {  return container_detail::force_copy<std::pair<const_iterator,const_iterator> >(m_flat_tree.equal_range(x));   }
 
+   //! <b>Effects</b>: Extracts the internal sequence container.
+   //!
+   //! <b>Complexity</b>: Same as the move constructor of sequence_type, usually constant.
+   //!
+   //! <b>Postcondition</b>: this->empty()
+   //!
+   //! <b>Throws</b>: If secuence_type's move constructor throws 
+   BOOST_CONTAINER_FORCEINLINE sequence_type extract_sequence()
+   {
+      return boost::move(container_detail::force<sequence_type>(m_flat_tree.get_sequence_ref()));
+   }
+
+   //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
+   //!   one passed externally using the move assignment.
+   //!
+   //! <b>Complexity</b>: Assuming O(1) move assignment, O(NlogN) with N = seq.size()
+   //!
+   //! <b>Throws</b>: If the comparison or the move constructor throws
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence(BOOST_RV_REF(sequence_type) seq)
+   {  this->m_flat_tree.adopt_sequence_equal(boost::move(container_detail::force<impl_sequence_type>(seq)));  }
+
+   //! <b>Requires</b>: seq shall be ordered according to this->compare().
+   //!
+   //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
+   //!   one passed externally using the move assignment.
+   //!
+   //! <b>Complexity</b>: Assuming O(1) move assignment, O(1)
+   //!
+   //! <b>Throws</b>: If the move assignment throws
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence(ordered_range_t, BOOST_RV_REF(sequence_type) seq)
+   {  this->m_flat_tree.adopt_sequence_equal(ordered_range_t(), boost::move(container_detail::force<impl_sequence_type>(seq)));  }
+
    //! <b>Effects</b>: Returns true if x and y are equal
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator==(const flat_multimap& x, const flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator==(const flat_multimap& x, const flat_multimap& y)
    {  return x.size() == y.size() && ::boost::container::algo_equal(x.begin(), x.end(), y.begin());  }
 
    //! <b>Effects</b>: Returns true if x and y are unequal
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator!=(const flat_multimap& x, const flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator!=(const flat_multimap& x, const flat_multimap& y)
    {  return !(x == y); }
 
    //! <b>Effects</b>: Returns true if x is less than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator<(const flat_multimap& x, const flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator<(const flat_multimap& x, const flat_multimap& y)
    {  return ::boost::container::algo_lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());  }
 
    //! <b>Effects</b>: Returns true if x is greater than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator>(const flat_multimap& x, const flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator>(const flat_multimap& x, const flat_multimap& y)
    {  return y < x;  }
 
    //! <b>Effects</b>: Returns true if x is equal or less than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator<=(const flat_multimap& x, const flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator<=(const flat_multimap& x, const flat_multimap& y)
    {  return !(y < x);  }
 
    //! <b>Effects</b>: Returns true if x is equal or greater than y
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
-   friend bool operator>=(const flat_multimap& x, const flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend bool operator>=(const flat_multimap& x, const flat_multimap& y)
    {  return !(x < y);  }
 
    //! <b>Effects</b>: x.swap(y)
    //!
    //! <b>Complexity</b>: Constant.
-   friend void swap(flat_multimap& x, flat_multimap& y)
+   BOOST_CONTAINER_FORCEINLINE friend void swap(flat_multimap& x, flat_multimap& y)
    {  x.swap(y);  }
 };
 
diff --git a/contrib/libboost/boost_1_62_0/boost/container/flat_set.hpp b/contrib/libboost/boost_1_65_0/boost/container/flat_set.hpp
similarity index 77%
rename from contrib/libboost/boost_1_62_0/boost/container/flat_set.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/flat_set.hpp
index fa27006177d..9e39be8e782 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/flat_set.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/flat_set.hpp
@@ -114,6 +114,7 @@ class flat_set
    typedef typename BOOST_CONTAINER_IMPDEF(base_t::const_iterator)                     const_iterator;
    typedef typename BOOST_CONTAINER_IMPDEF(base_t::reverse_iterator)                   reverse_iterator;
    typedef typename BOOST_CONTAINER_IMPDEF(base_t::const_reverse_iterator)             const_reverse_iterator;
+   typedef typename BOOST_CONTAINER_IMPDEF(base_t::sequence_type)                      sequence_type;
 
    public:
    //////////////////////////////////////////////
@@ -125,47 +126,112 @@ class flat_set
    //! <b>Effects</b>: Default constructs an empty container.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    explicit flat_set() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
                                          container_detail::is_nothrow_default_constructible<Compare>::value)
       : base_t()
    {}
 
    //! <b>Effects</b>: Constructs an empty container using the specified
-   //! comparison object and allocator.
+   //! comparison object.
    //!
    //! <b>Complexity</b>: Constant.
-   explicit flat_set(const Compare& comp,
-                     const allocator_type& a = allocator_type())
-      : base_t(comp, a)
+   BOOST_CONTAINER_FORCEINLINE
+   explicit flat_set(const Compare& comp)
+      : base_t(comp)
    {}
 
    //! <b>Effects</b>: Constructs an empty container using the specified allocator.
    //!
    //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
    explicit flat_set(const allocator_type& a)
       : base_t(a)
    {}
 
+   //! <b>Effects</b>: Constructs an empty container using the specified
+   //! comparison object and allocator.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE
+   flat_set(const Compare& comp, const allocator_type& a)
+      : base_t(comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty container and
+   //! inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! comp and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_set(InputIterator first, InputIterator last)
+      : base_t(true, first, last)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty container using the specified
+   //! allocator, and inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! comp and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_set(InputIterator first, InputIterator last, const allocator_type& a)
+      : base_t(true, first, last, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
+   //! inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! comp and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_set(InputIterator first, InputIterator last, const Compare& comp)
+      : base_t(true, first, last, comp)
+   {}
+
    //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
    //! allocator, and inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
    //! comp and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   flat_set(InputIterator first, InputIterator last,
-            const Compare& comp = Compare(),
-            const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE
+   flat_set(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
       : base_t(true, first, last, comp, a)
    {}
 
-   //! <b>Effects</b>: Constructs an empty container using the specified
-   //! allocator, and inserts elements from the range [first ,last ).
+   //! <b>Effects</b>: Constructs an empty container and
+   //! inserts elements from the ordered unique range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
    //!
-   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   flat_set(InputIterator first, InputIterator last, const allocator_type& a)
-      : base_t(true, first, last, Compare(), a)
+   BOOST_CONTAINER_FORCEINLINE
+   flat_set(ordered_unique_range_t, InputIterator first, InputIterator last)
+      : base_t(ordered_unique_range, first, last)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
+   //! inserts elements from the ordered unique range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE
+   flat_set(ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp)
+      : base_t(ordered_unique_range, first, last, comp)
    {}
 
    //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
@@ -179,21 +245,19 @@ class flat_set
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   flat_set(ordered_unique_range_t, InputIterator first, InputIterator last,
-            const Compare& comp = Compare(),
-            const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE
+   flat_set(ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
       : base_t(ordered_unique_range, first, last, comp, a)
    {}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-   //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
-   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //! <b>Effects</b>: Constructs an empty container and
+   //! inserts elements from the range [il.begin(), il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
    //! comp and otherwise N logN, where N is il.begin() - il.end().
-   flat_set(std::initializer_list<value_type> il, const Compare& comp = Compare(),
-            const allocator_type& a = allocator_type())
-      : base_t(true, il.begin(), il.end(), comp, a)
+   BOOST_CONTAINER_FORCEINLINE flat_set(std::initializer_list<value_type> il)
+      : base_t(true, il.begin(), il.end())
    {}
 
    //! <b>Effects</b>: Constructs an empty container using the specified
@@ -201,8 +265,54 @@ class flat_set
    //!
    //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
    //! comp and otherwise N logN, where N is il.begin() - il.end().
-   flat_set(std::initializer_list<value_type> il, const allocator_type& a)
-      : base_t(true, il.begin(), il.end(), Compare(), a)
+   BOOST_CONTAINER_FORCEINLINE flat_set(std::initializer_list<value_type> il, const allocator_type& a)
+      : base_t(true, il.begin(), il.end(), a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
+   //! inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
+   //! comp and otherwise N logN, where N is il.begin() - il.end().
+   BOOST_CONTAINER_FORCEINLINE flat_set(std::initializer_list<value_type> il, const Compare& comp)
+      : base_t(true, il.begin(), il.end(), comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
+   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
+   //! comp and otherwise N logN, where N is il.begin() - il.end().
+   BOOST_CONTAINER_FORCEINLINE flat_set(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+      : base_t(true, il.begin(), il.end(), comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
+   //! inserts elements from the ordered unique range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE flat_set(ordered_unique_range_t, std::initializer_list<value_type> il)
+      : base_t(ordered_unique_range, il.begin(), il.end())
+   {}
+
+   //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
+   //! inserts elements from the ordered unique range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE flat_set(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp)
+      : base_t(ordered_unique_range, il.begin(), il.end(), comp)
    {}
 
    //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
@@ -215,8 +325,7 @@ class flat_set
    //! <b>Complexity</b>: Linear in N.
    //!
    //! <b>Note</b>: Non-standard extension.
-   flat_set(ordered_unique_range_t, std::initializer_list<value_type> il,
-            const Compare& comp = Compare(), const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE flat_set(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
       : base_t(ordered_unique_range, il.begin(), il.end(), comp, a)
    {}
 #endif
@@ -224,7 +333,7 @@ class flat_set
    //! <b>Effects</b>: Copy constructs the container.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_set(const flat_set& x)
+   BOOST_CONTAINER_FORCEINLINE flat_set(const flat_set& x)
       : base_t(static_cast<const base_t&>(x))
    {}
 
@@ -233,7 +342,7 @@ class flat_set
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Postcondition</b>: x is emptied.
-   flat_set(BOOST_RV_REF(flat_set) x)
+   BOOST_CONTAINER_FORCEINLINE flat_set(BOOST_RV_REF(flat_set) x)
       BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
       : base_t(BOOST_MOVE_BASE(base_t, x))
    {}
@@ -241,7 +350,7 @@ class flat_set
    //! <b>Effects</b>: Copy constructs a container using the specified allocator.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_set(const flat_set& x, const allocator_type &a)
+   BOOST_CONTAINER_FORCEINLINE flat_set(const flat_set& x, const allocator_type &a)
       : base_t(static_cast<const base_t&>(x), a)
    {}
 
@@ -249,14 +358,14 @@ class flat_set
    //!                 Constructs *this using x's resources.
    //!
    //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise
-   flat_set(BOOST_RV_REF(flat_set) x, const allocator_type &a)
+   BOOST_CONTAINER_FORCEINLINE flat_set(BOOST_RV_REF(flat_set) x, const allocator_type &a)
       : base_t(BOOST_MOVE_BASE(base_t, x), a)
    {}
 
    //! <b>Effects</b>: Makes *this a copy of x.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   flat_set& operator=(BOOST_COPY_ASSIGN_REF(flat_set) x)
+   BOOST_CONTAINER_FORCEINLINE flat_set& operator=(BOOST_COPY_ASSIGN_REF(flat_set) x)
    {  return static_cast<flat_set&>(this->base_t::operator=(static_cast<const base_t&>(x)));  }
 
    //! <b>Throws</b>: If allocator_traits_type::propagate_on_container_move_assignment
@@ -265,7 +374,7 @@ class flat_set
    //! <b>Complexity</b>: Constant if allocator_traits_type::
    //!   propagate_on_container_move_assignment is true or
    //!   this->get>allocator() == x.get_allocator(). Linear otherwise.
-   flat_set& operator=(BOOST_RV_REF(flat_set) x)
+   BOOST_CONTAINER_FORCEINLINE flat_set& operator=(BOOST_RV_REF(flat_set) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
                            boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
@@ -469,7 +578,7 @@ class flat_set
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
-   std::pair<iterator,bool> emplace(BOOST_FWD_REF(Args)... args)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> emplace(BOOST_FWD_REF(Args)... args)
    {  return this->base_t::emplace_unique(boost::forward<Args>(args)...); }
 
    //! <b>Effects</b>: Inserts an object of type Key constructed with
@@ -485,18 +594,18 @@ class flat_set
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
-   iterator emplace_hint(const_iterator p, BOOST_FWD_REF(Args)... args)
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator p, BOOST_FWD_REF(Args)... args)
    {  return this->base_t::emplace_hint_unique(p, boost::forward<Args>(args)...); }
 
    #else // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
    #define BOOST_CONTAINER_FLAT_SET_EMPLACE_CODE(N) \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   std::pair<iterator,bool> emplace(BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> emplace(BOOST_MOVE_UREF##N)\
    {  return this->base_t::emplace_unique(BOOST_MOVE_FWD##N);  }\
    \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {  return this->base_t::emplace_hint_unique(hint BOOST_MOVE_I##N BOOST_MOVE_FWD##N); }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_FLAT_SET_EMPLACE_CODE)
@@ -575,7 +684,7 @@ class flat_set
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last)
+   BOOST_CONTAINER_FORCEINLINE void insert(InputIterator first, InputIterator last)
       {  this->base_t::insert_unique(first, last);  }
 
    //! <b>Requires</b>: first, last are not iterators into *this and
@@ -590,7 +699,7 @@ class flat_set
    //!
    //! <b>Note</b>: Non-standard extension. If an element is inserted it might invalidate elements.
    template <class InputIterator>
-   void insert(ordered_unique_range_t, InputIterator first, InputIterator last)
+   BOOST_CONTAINER_FORCEINLINE void insert(ordered_unique_range_t, InputIterator first, InputIterator last)
       {  this->base_t::insert_unique(ordered_unique_range, first, last);  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -601,7 +710,7 @@ class flat_set
    //!   search time plus N*size() insertion time.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   void insert(std::initializer_list<value_type> il)
+   BOOST_CONTAINER_FORCEINLINE void insert(std::initializer_list<value_type> il)
    {  this->base_t::insert_unique(il.begin(), il.end()); }
 
    //! <b>Requires</b>: Range [il.begin(), il.end()) must be ordered according to the predicate
@@ -614,7 +723,7 @@ class flat_set
    //!   search time plus N*size() insertion time.
    //!
    //! <b>Note</b>: Non-standard extension. If an element is inserted it might invalidate elements.
-   void insert(ordered_unique_range_t, std::initializer_list<value_type> il)
+   BOOST_CONTAINER_FORCEINLINE void insert(ordered_unique_range_t, std::initializer_list<value_type> il)
    {  this->base_t::insert_unique(ordered_unique_range, il.begin(), il.end()); }
 #endif
 
@@ -623,7 +732,7 @@ class flat_set
    BOOST_CONTAINER_FORCEINLINE void merge(flat_set<Key, C2, Allocator>& source)
    {  this->base_t::merge_unique(source.tree());   }
 
-   //! @copydoc ::boost::container::flat_map::merge(flat_set<Key, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_set::merge(flat_set<Key, C2, Allocator>&)
    template<class C2>
    BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_set<Key, C2, Allocator> BOOST_RV_REF_END source)
    {  return this->merge(static_cast<flat_set<Key, C2, Allocator>&>(source));   }
@@ -633,7 +742,7 @@ class flat_set
    BOOST_CONTAINER_FORCEINLINE void merge(flat_multiset<Key, C2, Allocator>& source)
    {  this->base_t::merge_unique(source.tree());   }
 
-   //! @copydoc ::boost::container::flat_map::merge(flat_multiset<Key, C2, Allocator>&)
+   //! @copydoc ::boost::container::flat_set::merge(flat_multiset<Key, C2, Allocator>&)
    template<class C2>
    BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_multiset<Key, C2, Allocator> BOOST_RV_REF_END source)
    {  return this->merge(static_cast<flat_multiset<Key, C2, Allocator>&>(source));   }
@@ -765,7 +874,7 @@ class flat_set
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   size_type count(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE size_type count(const key_type& x) const
    {  return static_cast<size_type>(this->base_t::find(x) != this->base_t::cend());  }
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -798,13 +907,13 @@ class flat_set
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
    {  return this->base_t::lower_bound_range(x);  }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<iterator,iterator> equal_range(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,iterator> equal_range(const key_type& x)
    {  return this->base_t::lower_bound_range(x);  }
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -844,16 +953,46 @@ class flat_set
    //! <b>Complexity</b>: Constant.
    friend void swap(flat_set& x, flat_set& y);
 
+   //! <b>Effects</b>: Extracts the internal sequence container.
+   //!
+   //! <b>Complexity</b>: Same as the move constructor of sequence_type, usually constant.
+   //!
+   //! <b>Postcondition</b>: this->empty()
+   //!
+   //! <b>Throws</b>: If secuence_type's move constructor throws 
+   sequence_type extract_sequence();
+
    #endif   //#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
 
+   //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
+   //!   one passed externally using the move assignment. Erases non-unique elements.
+   //!
+   //! <b>Complexity</b>: Assuming O(1) move assignment, O(NlogN) with N = seq.size()
+   //!
+   //! <b>Throws</b>: If the comparison or the move constructor throws
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence(BOOST_RV_REF(sequence_type) seq)
+   {  this->base_t::adopt_sequence_unique(boost::move(seq));  }
+
+   //! <b>Requires</b>: seq shall be ordered according to this->compare()
+   //!   and shall contain unique elements.
+   //!
+   //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
+   //!   one passed externally using the move assignment.
+   //!
+   //! <b>Complexity</b>: Assuming O(1) move assignment, O(1)
+   //!
+   //! <b>Throws</b>: If the move assignment throws
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence(ordered_unique_range_t, BOOST_RV_REF(sequence_type) seq)
+   {  this->base_t::adopt_sequence_unique(ordered_unique_range_t(), boost::move(seq));  }
+
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
    template<class KeyType>
-   std::pair<iterator, bool> priv_insert(BOOST_FWD_REF(KeyType) x)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator, bool> priv_insert(BOOST_FWD_REF(KeyType) x)
    {  return this->base_t::insert_unique(::boost::forward<KeyType>(x));  }
 
    template<class KeyType>
-   iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
+   BOOST_CONTAINER_FORCEINLINE iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
    {  return this->base_t::insert_unique(p, ::boost::forward<KeyType>(x)); }
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 };
@@ -939,40 +1078,55 @@ class flat_multiset
    typedef typename BOOST_CONTAINER_IMPDEF(base_t::const_iterator)                     const_iterator;
    typedef typename BOOST_CONTAINER_IMPDEF(base_t::reverse_iterator)                   reverse_iterator;
    typedef typename BOOST_CONTAINER_IMPDEF(base_t::const_reverse_iterator)             const_reverse_iterator;
+   typedef typename BOOST_CONTAINER_IMPDEF(base_t::sequence_type)                      sequence_type;
 
    //! @copydoc ::boost::container::flat_set::flat_set()
-   explicit flat_multiset() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
+   BOOST_CONTAINER_FORCEINLINE explicit flat_multiset() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
                                               container_detail::is_nothrow_default_constructible<Compare>::value)
       : base_t()
    {}
 
-   //! @copydoc ::boost::container::flat_set::flat_set(const Compare&, const allocator_type&)
-   explicit flat_multiset(const Compare& comp,
-                          const allocator_type& a = allocator_type())
-      : base_t(comp, a)
+   //! @copydoc ::boost::container::flat_set::flat_set(const Compare&)
+   BOOST_CONTAINER_FORCEINLINE explicit flat_multiset(const Compare& comp)
+      : base_t(comp)
    {}
 
    //! @copydoc ::boost::container::flat_set::flat_set(const allocator_type&)
-   explicit flat_multiset(const allocator_type& a)
+   BOOST_CONTAINER_FORCEINLINE explicit flat_multiset(const allocator_type& a)
       : base_t(a)
    {}
 
-   //! @copydoc ::boost::container::flat_set::flat_set(InputIterator, InputIterator, const Compare& comp, const allocator_type&)
+   //! @copydoc ::boost::container::flat_set::flat_set(const Compare&, const allocator_type&)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(const Compare& comp, const allocator_type& a)
+      : base_t(comp, a)
+   {}
+
+   //! @copydoc ::boost::container::flat_set::flat_set(InputIterator, InputIterator)
    template <class InputIterator>
-   flat_multiset(InputIterator first, InputIterator last,
-                 const Compare& comp        = Compare(),
-                 const allocator_type& a = allocator_type())
-      : base_t(false, first, last, comp, a)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(InputIterator first, InputIterator last)
+      : base_t(false, first, last)
    {}
 
    //! @copydoc ::boost::container::flat_set::flat_set(InputIterator, InputIterator, const allocator_type&)
    template <class InputIterator>
-   flat_multiset(InputIterator first, InputIterator last, const allocator_type& a)
-      : base_t(false, first, last, Compare(), a)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(InputIterator first, InputIterator last, const allocator_type& a)
+      : base_t(false, first, last, a)
    {}
 
-   //! <b>Effects</b>: Constructs an empty flat_multiset using the specified comparison object and
-   //! allocator, and inserts elements from the ordered range [first ,last ). This function
+   //! @copydoc ::boost::container::flat_set::flat_set(InputIterator, InputIterator, const Compare& comp)
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(InputIterator first, InputIterator last, const Compare& comp)
+      : base_t(false, first, last, comp)
+   {}
+
+   //! @copydoc ::boost::container::flat_set::flat_set(InputIterator, InputIterator, const Compare& comp, const allocator_type&)
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : base_t(false, first, last, comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multiset and
+   //! inserts elements from the ordered range [first ,last ). This function
    //! is more efficient than the normal range creation for ordered ranges.
    //!
    //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
@@ -981,22 +1135,83 @@ class flat_multiset
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   flat_multiset(ordered_range_t, InputIterator first, InputIterator last,
-                 const Compare& comp        = Compare(),
-                 const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(ordered_range_t, InputIterator first, InputIterator last)
+      : base_t(ordered_range, first, last)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multiset using the specified comparison object and
+   //! inserts elements from the ordered range [first ,last ). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp)
+      : base_t(ordered_range, first, last, comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty flat_multiset using the specified comparison object and
+   //! allocator, and inserts elements from the ordered range [first, last ). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
       : base_t(ordered_range, first, last, comp, a)
    {}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-   //! @copydoc ::boost::container::flat_set::flat_set(std::initializer_list<value_type>, const Compare& comp, const allocator_type&)
-   flat_multiset(std::initializer_list<value_type> il, const Compare& comp = Compare(),
-            const allocator_type& a = allocator_type())
-      : base_t(false, il.begin(), il.end(), comp, a)
+   //! @copydoc ::boost::container::flat_set::flat_set(std::initializer_list<value_type)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(std::initializer_list<value_type> il)
+      : base_t(false, il.begin(), il.end())
    {}
 
    //! @copydoc ::boost::container::flat_set::flat_set(std::initializer_list<value_type>, const allocator_type&)
-   flat_multiset(std::initializer_list<value_type> il, const allocator_type& a)
-      : base_t(false, il.begin(), il.end(), Compare(), a)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(std::initializer_list<value_type> il, const allocator_type& a)
+      : base_t(false, il.begin(), il.end(), a)
+   {}
+
+   //! @copydoc ::boost::container::flat_set::flat_set(std::initializer_list<value_type>, const Compare& comp)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(std::initializer_list<value_type> il, const Compare& comp)
+      : base_t(false, il.begin(), il.end(), comp)
+   {}
+
+   //! @copydoc ::boost::container::flat_set::flat_set(std::initializer_list<value_type>, const Compare& comp, const allocator_type&)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+      : base_t(false, il.begin(), il.end(), comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty containerand
+   //! inserts elements from the ordered unique range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(ordered_range_t, std::initializer_list<value_type> il)
+      : base_t(ordered_range, il.begin(), il.end())
+   {}
+
+   //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
+   //! inserts elements from the ordered unique range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp)
+      : base_t(ordered_range, il.begin(), il.end(), comp)
    {}
 
    //! <b>Effects</b>: Constructs an empty container using the specified comparison object and
@@ -1008,39 +1223,38 @@ class flat_multiset
    //! <b>Complexity</b>: Linear in N.
    //!
    //! <b>Note</b>: Non-standard extension.
-   flat_multiset(ordered_range_t, std::initializer_list<value_type> il,
-            const Compare& comp = Compare(), const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
       : base_t(ordered_range, il.begin(), il.end(), comp, a)
    {}
 #endif
 
    //! @copydoc ::boost::container::flat_set::flat_set(const flat_set &)
-   flat_multiset(const flat_multiset& x)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(const flat_multiset& x)
       : base_t(static_cast<const base_t&>(x))
    {}
 
    //! @copydoc ::boost::container::flat_set::flat_set(flat_set &&)
-   flat_multiset(BOOST_RV_REF(flat_multiset) x)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(BOOST_RV_REF(flat_multiset) x)
       BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
       : base_t(boost::move(static_cast<base_t&>(x)))
    {}
 
    //! @copydoc ::boost::container::flat_set::flat_set(const flat_set &, const allocator_type &)
-   flat_multiset(const flat_multiset& x, const allocator_type &a)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(const flat_multiset& x, const allocator_type &a)
       : base_t(static_cast<const base_t&>(x), a)
    {}
 
    //! @copydoc ::boost::container::flat_set::flat_set(flat_set &&, const allocator_type &)
-   flat_multiset(BOOST_RV_REF(flat_multiset) x, const allocator_type &a)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset(BOOST_RV_REF(flat_multiset) x, const allocator_type &a)
       : base_t(BOOST_MOVE_BASE(base_t, x), a)
    {}
 
    //! @copydoc ::boost::container::flat_set::operator=(const flat_set &)
-   flat_multiset& operator=(BOOST_COPY_ASSIGN_REF(flat_multiset) x)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset& operator=(BOOST_COPY_ASSIGN_REF(flat_multiset) x)
    {  return static_cast<flat_multiset&>(this->base_t::operator=(static_cast<const base_t&>(x)));  }
 
    //! @copydoc ::boost::container::flat_set::operator=(flat_set &&)
-   flat_multiset& operator=(BOOST_RV_REF(flat_multiset) x)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset& operator=(BOOST_RV_REF(flat_multiset) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
                            boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
@@ -1140,7 +1354,7 @@ class flat_multiset
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
-   iterator emplace(BOOST_FWD_REF(Args)... args)
+   BOOST_CONTAINER_FORCEINLINE iterator emplace(BOOST_FWD_REF(Args)... args)
    {  return this->base_t::emplace_equal(boost::forward<Args>(args)...); }
 
    //! <b>Effects</b>: Inserts an object of type Key constructed with
@@ -1155,18 +1369,18 @@ class flat_multiset
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class... Args>
-   iterator emplace_hint(const_iterator p, BOOST_FWD_REF(Args)... args)
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator p, BOOST_FWD_REF(Args)... args)
    {  return this->base_t::emplace_hint_equal(p, boost::forward<Args>(args)...); }
 
    #else // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
    #define BOOST_CONTAINER_FLAT_MULTISET_EMPLACE_CODE(N) \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace(BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace(BOOST_MOVE_UREF##N)\
    {  return this->base_t::emplace_equal(BOOST_MOVE_FWD##N);  }\
    \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {  return this->base_t::emplace_hint_equal(hint BOOST_MOVE_I##N BOOST_MOVE_FWD##N); }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_FLAT_MULTISET_EMPLACE_CODE)
@@ -1233,7 +1447,7 @@ class flat_multiset
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last)
+   BOOST_CONTAINER_FORCEINLINE void insert(InputIterator first, InputIterator last)
       {  this->base_t::insert_equal(first, last);  }
 
    //! <b>Requires</b>: first, last are not iterators into *this and
@@ -1247,7 +1461,7 @@ class flat_multiset
    //!
    //! <b>Note</b>: Non-standard extension. If an element is inserted it might invalidate elements.
    template <class InputIterator>
-   void insert(ordered_range_t, InputIterator first, InputIterator last)
+   BOOST_CONTAINER_FORCEINLINE void insert(ordered_range_t, InputIterator first, InputIterator last)
       {  this->base_t::insert_equal(ordered_range, first, last);  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -1257,7 +1471,7 @@ class flat_multiset
    //!   search time plus N*size() insertion time.
    //!
    //! <b>Note</b>: If an element is inserted it might invalidate elements.
-   void insert(std::initializer_list<value_type> il)
+   BOOST_CONTAINER_FORCEINLINE void insert(std::initializer_list<value_type> il)
    {  this->base_t::insert_equal(il.begin(), il.end()); }
 
    //! <b>Requires</b>: Range [il.begin(), il.end()) must be ordered according to the predicate.
@@ -1269,7 +1483,7 @@ class flat_multiset
    //!   search time plus N*size() insertion time.
    //!
    //! <b>Note</b>: Non-standard extension. If an element is inserted it might invalidate elements.
-   void insert(ordered_range_t, std::initializer_list<value_type> il)
+   BOOST_CONTAINER_FORCEINLINE void insert(ordered_range_t, std::initializer_list<value_type> il)
    {  this->base_t::insert_equal(ordered_range, il.begin(), il.end()); }
 #endif
 
@@ -1392,16 +1606,45 @@ class flat_multiset
    //! <b>Complexity</b>: Constant.
    friend void swap(flat_multiset& x, flat_multiset& y);
 
+   //! <b>Effects</b>: Extracts the internal sequence container.
+   //!
+   //! <b>Complexity</b>: Same as the move constructor of sequence_type, usually constant.
+   //!
+   //! <b>Postcondition</b>: this->empty()
+   //!
+   //! <b>Throws</b>: If secuence_type's move constructor throws 
+   sequence_type extract_sequence();
+
    #endif   //#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
 
+   //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
+   //!   one passed externally using the move assignment.
+   //!
+   //! <b>Complexity</b>: Assuming O(1) move assignment, O(NlogN) with N = seq.size()
+   //!
+   //! <b>Throws</b>: If the comparison or the move constructor throws
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence(BOOST_RV_REF(sequence_type) seq)
+   {  this->base_t::adopt_sequence_equal(boost::move(seq));  }
+
+   //! <b>Requires</b>: seq shall be ordered according to this->compare()
+   //!
+   //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
+   //!   one passed externally using the move assignment.
+   //!
+   //! <b>Complexity</b>: Assuming O(1) move assignment, O(1)
+   //!
+   //! <b>Throws</b>: If the move assignment throws
+   BOOST_CONTAINER_FORCEINLINE void adopt_sequence(ordered_range_t, BOOST_RV_REF(sequence_type) seq)
+   {  this->base_t::adopt_sequence_equal(ordered_range_t(), boost::move(seq));  }
+
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
    template <class KeyType>
-   iterator priv_insert(BOOST_FWD_REF(KeyType) x)
+   BOOST_CONTAINER_FORCEINLINE iterator priv_insert(BOOST_FWD_REF(KeyType) x)
    {  return this->base_t::insert_equal(::boost::forward<KeyType>(x));  }
 
    template <class KeyType>
-   iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
+   BOOST_CONTAINER_FORCEINLINE iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
    {  return this->base_t::insert_equal(p, ::boost::forward<KeyType>(x)); }
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 };
diff --git a/contrib/libboost/boost_1_62_0/boost/container/list.hpp b/contrib/libboost/boost_1_65_0/boost/container/list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/list.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/map.hpp b/contrib/libboost/boost_1_65_0/boost/container/map.hpp
similarity index 84%
rename from contrib/libboost/boost_1_62_0/boost/container/map.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/map.hpp
index 5520fb45ba8..33e0331eb09 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/map.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/map.hpp
@@ -31,6 +31,8 @@
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/value_init.hpp>
 #include <boost/container/detail/pair.hpp>
+#include <boost/container/detail/pair_key_mapped_of_value.hpp>
+
 // move
 #include <boost/move/traits.hpp>
 #include <boost/move/utility_core.hpp>
@@ -53,34 +55,6 @@
 namespace boost {
 namespace container {
 
-///@cond
-
-template<class Key, class Mapped>
-struct pair_key_mapped_of_value
-{
-   typedef Key    key_type;
-   typedef Mapped mapped_type;
-
-   template<class Pair>
-   const key_type & key_of_value(const Pair &p) const
-   {  return p.first;  }
-
-   template<class Pair>
-   const mapped_type & mapped_of_value(const Pair &p) const
-   {  return p.second;  }
-
-   template<class Pair>
-   key_type & key_of_value(Pair &p) const
-   {  return const_cast<key_type&>(p.first);  }
-
-   template<class Pair>
-   mapped_type & mapped_of_value(Pair &p) const
-   {  return p.second;  }
-
-};
-
-///@endcond
-
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
 
 //! A map is a kind of associative container that supports unique keys (contains at
@@ -132,7 +106,7 @@ class map
    typedef Key                                                                      key_type;
    typedef ::boost::container::allocator_traits<Allocator>                          allocator_traits_type;
    typedef T                                                                        mapped_type;
-   typedef std::pair<const Key, T>                                                  value_type;
+   typedef typename boost::container::allocator_traits<Allocator>::value_type       value_type;
    typedef typename boost::container::allocator_traits<Allocator>::pointer          pointer;
    typedef typename boost::container::allocator_traits<Allocator>::const_pointer    const_pointer;
    typedef typename boost::container::allocator_traits<Allocator>::reference        reference;
@@ -150,14 +124,15 @@ class map
    typedef std::pair<key_type, mapped_type>                                         nonconst_value_type;
    typedef BOOST_CONTAINER_IMPDEF(movable_value_type_impl)                          movable_value_type;
    typedef BOOST_CONTAINER_IMPDEF(node_handle<
-      typename base_t::node_type::container_node_type
-      BOOST_MOVE_I value_type
-      BOOST_MOVE_I allocator_type
+      typename base_t::stored_allocator_type
       BOOST_MOVE_I pair_key_mapped_of_value
          <key_type BOOST_MOVE_I mapped_type> >)                                     node_type;
    typedef BOOST_CONTAINER_IMPDEF
       (insert_return_type_base<iterator BOOST_MOVE_I node_type>)                    insert_return_type;
 
+   //allocator_type::value_type type must be std::pair<CONST Key, T>
+   BOOST_STATIC_ASSERT((container_detail::is_same<typename allocator_type::value_type, std::pair<const Key, T> >::value));
+
    //////////////////////////////////////////////
    //
    //          construct/copy/destroy
@@ -171,62 +146,99 @@ class map
    map() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
                            container_detail::is_nothrow_default_constructible<Compare>::value)
       : base_t()
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Constructs an empty map using the specified comparison object
    //! and allocator.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_FORCEINLINE 
-   explicit map(const Compare& comp, const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE map(const Compare& comp, const allocator_type& a)
       : base_t(comp, a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
+
+   //! <b>Effects</b>: Constructs an empty map using the specified comparison object.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE explicit map(const Compare& comp)
+      : base_t(comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty map using the specified allocator.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_FORCEINLINE 
-   explicit map(const allocator_type& a)
+   BOOST_CONTAINER_FORCEINLINE explicit map(const allocator_type& a)
       : base_t(a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
-   //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
-   //! allocator, and inserts elements from the range [first ,last ).
+   //! <b>Effects</b>: Constructs an empty map and
+   //! inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE 
-   map(InputIterator first, InputIterator last, const Compare& comp = Compare(),
-         const allocator_type& a = allocator_type())
-      : base_t(true, first, last, comp, a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE map(InputIterator first, InputIterator last)
+      : base_t(true, first, last)
+   {}
 
    //! <b>Effects</b>: Constructs an empty map using the specified 
    //! allocator, and inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE 
-   map(InputIterator first, InputIterator last, const allocator_type& a)
+   BOOST_CONTAINER_FORCEINLINE map(InputIterator first, InputIterator last, const allocator_type& a)
       : base_t(true, first, last, Compare(), a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
+
+   //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
+   //! inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE map(InputIterator first, InputIterator last, const Compare& comp)
+      : base_t(true, first, last, comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
+   //! allocator, and inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE map(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : base_t(true, first, last, comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty map and
+   //! inserts elements from the ordered unique range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE map( ordered_unique_range_t, InputIterator first, InputIterator last)
+      : base_t(ordered_range, first, last)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
+   //! inserts elements from the ordered unique range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE map( ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp)
+      : base_t(ordered_range, first, last, comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
    //! allocator, and inserts elements from the ordered unique range [first ,last). This function
@@ -239,43 +251,76 @@ class map
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE 
-   map( ordered_unique_range_t, InputIterator first, InputIterator last
-      , const Compare& comp = Compare(), const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE map( ordered_unique_range_t, InputIterator first, InputIterator last
+      , const Compare& comp, const allocator_type& a)
       : base_t(ordered_range, first, last, comp, a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   //! <b>Effects</b>: Constructs an empty map and
+   //! inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted according
+   //! to the predicate and otherwise N logN, where N is il.first() - il.end().
+   BOOST_CONTAINER_FORCEINLINE map(std::initializer_list<value_type> il)
+      : base_t(true, il.begin(), il.end())
+   {}
+
    //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
-   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //! inserts elements from the range [il.begin(), il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is il.first() - il.end().
-   BOOST_CONTAINER_FORCEINLINE 
-   map(std::initializer_list<value_type> il, const Compare& comp = Compare(), const allocator_type& a = allocator_type())
-      : base_t(true, il.begin(), il.end(), comp, a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   //! the predicate and otherwise N logN, where N is il.first() - il.end().
+   BOOST_CONTAINER_FORCEINLINE map(std::initializer_list<value_type> il, const Compare& comp)
+      : base_t(true, il.begin(), il.end(), comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty map using the specified
    //! allocator, and inserts elements from the range [il.begin(), il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is il.first() - il.end().
-   BOOST_CONTAINER_FORCEINLINE 
-   map(std::initializer_list<value_type> il, const allocator_type& a)
+   //! the predicate and otherwise N logN, where N is il.first() - il.end().
+   BOOST_CONTAINER_FORCEINLINE map(std::initializer_list<value_type> il, const allocator_type& a)
       : base_t(true, il.begin(), il.end(), Compare(), a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
-   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
+   //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
+   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is il.first() - il.end().
+   BOOST_CONTAINER_FORCEINLINE map(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+      : base_t(true, il.begin(), il.end(), comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty map and inserts elements from the ordered unique range [il.begin(), il.end()).
+   //! This function is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE map(ordered_unique_range_t, std::initializer_list<value_type> il)
+      : base_t(ordered_range, il.begin(), il.end())
+   {}
+
+   //! <b>Effects</b>: Constructs an empty map using the specified comparison object,
+   //!  and inserts elements from the ordered unique range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE map(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp)
+      : base_t(ordered_range, il.begin(), il.end(), comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
    //! allocator, and inserts elements from the ordered unique range [il.begin(), il.end()). This function
    //! is more efficient than the normal range creation for ordered ranges.
    //!
@@ -285,51 +330,36 @@ class map
    //! <b>Complexity</b>: Linear in N.
    //!
    //! <b>Note</b>: Non-standard extension.
-   BOOST_CONTAINER_FORCEINLINE 
-   map(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp = Compare(),
-       const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE map( ordered_unique_range_t, std::initializer_list<value_type> il
+                                  , const Compare& comp, const allocator_type& a)
       : base_t(ordered_range, il.begin(), il.end(), comp, a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {} 
+
 #endif
 
    //! <b>Effects</b>: Copy constructs a map.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   BOOST_CONTAINER_FORCEINLINE 
-   map(const map& x)
+   BOOST_CONTAINER_FORCEINLINE map(const map& x)
       : base_t(static_cast<const base_t&>(x))
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Move constructs a map. Constructs *this using x's resources.
    //!
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Postcondition</b>: x is emptied.
-   BOOST_CONTAINER_FORCEINLINE 
-   map(BOOST_RV_REF(map) x)
+   BOOST_CONTAINER_FORCEINLINE map(BOOST_RV_REF(map) x)
       BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
       : base_t(BOOST_MOVE_BASE(base_t, x))
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Copy constructs a map using the specified allocator.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   BOOST_CONTAINER_FORCEINLINE 
-   map(const map& x, const allocator_type &a)
+   BOOST_CONTAINER_FORCEINLINE map(const map& x, const allocator_type &a)
       : base_t(static_cast<const base_t&>(x), a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Move constructs a map using the specified allocator.
    //!                 Constructs *this using x's resources.
@@ -337,19 +367,14 @@ class map
    //! <b>Complexity</b>: Constant if x == x.get_allocator(), linear otherwise.
    //!
    //! <b>Postcondition</b>: x is emptied.
-   BOOST_CONTAINER_FORCEINLINE 
-   map(BOOST_RV_REF(map) x, const allocator_type &a)
+   BOOST_CONTAINER_FORCEINLINE map(BOOST_RV_REF(map) x, const allocator_type &a)
       : base_t(BOOST_MOVE_BASE(base_t, x), a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Makes *this a copy of x.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   BOOST_CONTAINER_FORCEINLINE 
-   map& operator=(BOOST_COPY_ASSIGN_REF(map) x)
+   BOOST_CONTAINER_FORCEINLINE map& operator=(BOOST_COPY_ASSIGN_REF(map) x)
    {  return static_cast<map&>(this->base_t::operator=(static_cast<const base_t&>(x)));  }
 
    //! <b>Effects</b>: this->swap(x.get()).
@@ -360,8 +385,7 @@ class map
    //! <b>Complexity</b>: Constant if allocator_traits_type::
    //!   propagate_on_container_move_assignment is true or
    //!   this->get>allocator() == x.get_allocator(). Linear otherwise.
-   BOOST_CONTAINER_FORCEINLINE 
-   map& operator=(BOOST_RV_REF(map) x)
+   BOOST_CONTAINER_FORCEINLINE map& operator=(BOOST_RV_REF(map) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
                            boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
@@ -370,8 +394,7 @@ class map
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    //! <b>Effects</b>: Assign content of il to *this.
    //!
-   BOOST_CONTAINER_FORCEINLINE 
-   map& operator=(std::initializer_list<value_type> il)
+   BOOST_CONTAINER_FORCEINLINE map& operator=(std::initializer_list<value_type> il)
    {
        this->clear();
        insert(il.begin(), il.end());
@@ -716,7 +739,7 @@ class map
    //!
    //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t
    //!   is inserted right before p.
-   iterator insert(const_iterator p, BOOST_RV_REF(nonconst_value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, BOOST_RV_REF(nonconst_value_type) x)
    { return this->try_emplace(p, boost::move(x.first), boost::move(x.second)); }
 
    //! <b>Effects</b>: Move constructs a new value from x if and only if there is
@@ -728,7 +751,7 @@ class map
    //!
    //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t
    //!   is inserted right before p.
-   iterator insert(const_iterator p, BOOST_RV_REF(movable_value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, BOOST_RV_REF(movable_value_type) x)
    { return this->try_emplace(p, boost::move(x.first), boost::move(x.second)); }
 
    //! <b>Effects</b>: Inserts a copy of x in the container.
@@ -746,7 +769,7 @@ class map
    //! <b>Returns</b>: An iterator pointing to the element with key equivalent to the key of x.
    //!
    //! <b>Complexity</b>: Logarithmic.
-   iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator p, BOOST_RV_REF(value_type) x)
    { return this->base_t::insert_unique(p, boost::move(x)); }
 
    //! <b>Requires</b>: first, last are not iterators into *this.
@@ -1225,7 +1248,7 @@ class multimap
 
    typedef Key                                                                      key_type;
    typedef T                                                                        mapped_type;
-   typedef std::pair<const Key, T>                                                  value_type;
+   typedef typename boost::container::allocator_traits<Allocator>::value_type       value_type;
    typedef typename boost::container::allocator_traits<Allocator>::pointer          pointer;
    typedef typename boost::container::allocator_traits<Allocator>::const_pointer    const_pointer;
    typedef typename boost::container::allocator_traits<Allocator>::reference        reference;
@@ -1243,12 +1266,13 @@ class multimap
    typedef std::pair<key_type, mapped_type>                                         nonconst_value_type;
    typedef BOOST_CONTAINER_IMPDEF(movable_value_type_impl)                          movable_value_type;
    typedef BOOST_CONTAINER_IMPDEF(node_handle<
-      typename base_t::node_type::container_node_type
-      BOOST_MOVE_I value_type
-      BOOST_MOVE_I allocator_type
+      typename base_t::stored_allocator_type
       BOOST_MOVE_I pair_key_mapped_of_value
          <key_type BOOST_MOVE_I mapped_type> >)                                     node_type;
 
+   //allocator_type::value_type type must be std::pair<CONST Key, T>
+   BOOST_STATIC_ASSERT((container_detail::is_same<typename allocator_type::value_type, std::pair<const Key, T> >::value));
+
    //////////////////////////////////////////////
    //
    //          construct/copy/destroy
@@ -1258,66 +1282,102 @@ class multimap
    //! <b>Effects</b>: Default constructs an empty multimap.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_FORCEINLINE
-   multimap() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
-                                container_detail::is_nothrow_default_constructible<Compare>::value)
+   BOOST_CONTAINER_FORCEINLINE multimap()
+      BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
+                        container_detail::is_nothrow_default_constructible<Compare>::value)
       : base_t()
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
-   //! <b>Effects</b>: Constructs an empty multimap using the specified allocator.
-   //!
-   //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_FORCEINLINE
-   explicit multimap(const Compare& comp, const allocator_type& a = allocator_type())
-      : base_t(comp, a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
-
-   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison
+   //! <b>Effects</b>: Constructs an empty multimap using the specified allocator
    //!   object and allocator.
    //!
    //! <b>Complexity</b>: Constant.
-   BOOST_CONTAINER_FORCEINLINE
-   explicit multimap(const allocator_type& a)
+   BOOST_CONTAINER_FORCEINLINE explicit multimap(const allocator_type& a)
       : base_t(a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
-   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object
-   //!   and allocator, and inserts elements from the range [first ,last ).
+   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE explicit multimap(const Compare& comp)
+      : base_t(comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison and allocator.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE multimap(const Compare& comp, const allocator_type& a)
+      : base_t(comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty multimap and
+   //! inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE
-   multimap(InputIterator first, InputIterator last,
-            const Compare& comp = Compare(),
-            const allocator_type& a = allocator_type())
-      : base_t(false, first, last, comp, a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   BOOST_CONTAINER_FORCEINLINE multimap(InputIterator first, InputIterator last)
+      : base_t(false, first, last)
+   {}
 
    //! <b>Effects</b>: Constructs an empty multimap using the specified 
    //! allocator, and inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
    BOOST_CONTAINER_FORCEINLINE multimap(InputIterator first, InputIterator last, const allocator_type& a)
       : base_t(false, first, last, Compare(), a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
+
+   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object and
+   //! inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE multimap(InputIterator first, InputIterator last, const Compare& comp)
+      : base_t(false, first, last, comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object
+   //!   and allocator, and inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE multimap(InputIterator first, InputIterator last,
+            const Compare& comp, const allocator_type& a)
+      : base_t(false, first, last, comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty multimap and
+   //! inserts elements from the ordered range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE multimap(ordered_range_t, InputIterator first, InputIterator last)
+      : base_t(ordered_range, first, last)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object and
+   //! inserts elements from the ordered range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE multimap(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp)
+      : base_t(ordered_range, first, last, comp)
+   {}
 
    //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object and
    //! allocator, and inserts elements from the ordered range [first ,last). This function
@@ -1329,41 +1389,51 @@ class multimap
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   BOOST_CONTAINER_FORCEINLINE multimap(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp = Compare(),
-         const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE multimap(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp,
+         const allocator_type& a)
       : base_t(ordered_range, first, last, comp, a)
    {}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object and
-   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //! <b>Effects</b>: Constructs an empty multimap and
+   //! and inserts elements from the range [il.begin(), il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is il.first() - il.end().
-   BOOST_CONTAINER_FORCEINLINE
-   multimap(std::initializer_list<value_type> il, const Compare& comp = Compare(),
-           const allocator_type& a = allocator_type())
-      : base_t(false, il.begin(), il.end(), comp, a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   //! the predicate and otherwise N logN, where N is il.first() - il.end().
+   BOOST_CONTAINER_FORCEINLINE multimap(std::initializer_list<value_type> il)
+      : base_t(false, il.begin(), il.end())
+   {}
 
    //! <b>Effects</b>: Constructs an empty multimap using the specified
    //! allocator, and inserts elements from the range [il.begin(), il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is il.first() - il.end().
-   BOOST_CONTAINER_FORCEINLINE
-   multimap(std::initializer_list<value_type> il, const allocator_type& a)
+   //! the predicate and otherwise N logN, where N is il.first() - il.end().
+   BOOST_CONTAINER_FORCEINLINE multimap(std::initializer_list<value_type> il, const allocator_type& a)
       : base_t(false, il.begin(), il.end(), Compare(), a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
-   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
-   //! allocator, and inserts elements from the ordered range [il.begin(), il.end()). This function
+   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object and
+   //! inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is il.first() - il.end().
+   BOOST_CONTAINER_FORCEINLINE multimap(std::initializer_list<value_type> il, const Compare& comp)
+      : base_t(false, il.begin(), il.end(), comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object and
+   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is il.first() - il.end().
+   BOOST_CONTAINER_FORCEINLINE multimap(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+      : base_t(false, il.begin(), il.end(), comp, a)
+   {}
+
+
+   //! <b>Effects</b>: Constructs an empty map and
+   //! inserts elements from the ordered range [il.begin(), il.end()). This function
    //! is more efficient than the normal range creation for ordered ranges.
    //!
    //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate.
@@ -1371,14 +1441,36 @@ class multimap
    //! <b>Complexity</b>: Linear in N.
    //!
    //! <b>Note</b>: Non-standard extension.
-   BOOST_CONTAINER_FORCEINLINE
-   multimap(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp = Compare(),
-       const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE multimap(ordered_range_t, std::initializer_list<value_type> il)
+      : base_t(ordered_range, il.begin(), il.end())
+   {}
+
+   //! <b>Effects</b>: Constructs an empty map using the specified comparison object and
+   //! inserts elements from the ordered range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE multimap(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp)
+      : base_t(ordered_range, il.begin(), il.end(), comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty map and
+   //! inserts elements from the ordered range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE multimap(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
       : base_t(ordered_range, il.begin(), il.end(), comp, a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
+
 #endif
 
    //! <b>Effects</b>: Copy constructs a multimap.
@@ -1386,10 +1478,7 @@ class multimap
    //! <b>Complexity</b>: Linear in x.size().
    BOOST_CONTAINER_FORCEINLINE multimap(const multimap& x)
       : base_t(static_cast<const base_t&>(x))
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Move constructs a multimap. Constructs *this using x's resources.
    //!
@@ -1399,20 +1488,14 @@ class multimap
    BOOST_CONTAINER_FORCEINLINE multimap(BOOST_RV_REF(multimap) x)
       BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
       : base_t(BOOST_MOVE_BASE(base_t, x))
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Copy constructs a multimap.
    //!
    //! <b>Complexity</b>: Linear in x.size().
    BOOST_CONTAINER_FORCEINLINE multimap(const multimap& x, const allocator_type &a)
       : base_t(static_cast<const base_t&>(x), a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Move constructs a multimap using the specified allocator.
    //!                 Constructs *this using x's resources.
@@ -1421,10 +1504,7 @@ class multimap
    //! <b>Postcondition</b>: x is emptied.
    BOOST_CONTAINER_FORCEINLINE multimap(BOOST_RV_REF(multimap) x, const allocator_type &a)
       : base_t(BOOST_MOVE_BASE(base_t, x), a)
-   {
-      //A type must be std::pair<CONST Key, T>
-      BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value));
-   }
+   {}
 
    //! <b>Effects</b>: Makes *this a copy of x.
    //!
@@ -1708,7 +1788,7 @@ class multimap
    //!
    //! <b>Complexity</b>: N log(a.size() + N) (N has the value source.size())
    template<class C2>
-   void merge(multimap<Key, T, C2, Allocator, Options>& source)
+   BOOST_CONTAINER_FORCEINLINE void merge(multimap<Key, T, C2, Allocator, Options>& source)
    {
       typedef container_detail::tree
          <value_type_impl, select_1st_t, C2, Allocator, Options> base2_t;
@@ -1717,12 +1797,12 @@ class multimap
 
    //! @copydoc ::boost::container::multimap::merge(multimap<Key, T, C2, Allocator, Options>&)
    template<class C2>
-   void merge(BOOST_RV_REF_BEG multimap<Key, T, C2, Allocator, Options> BOOST_RV_REF_END source)
+   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG multimap<Key, T, C2, Allocator, Options> BOOST_RV_REF_END source)
    {  return this->merge(static_cast<multimap<Key, T, C2, Allocator, Options>&>(source)); }
 
    //! @copydoc ::boost::container::multimap::merge(multimap<Key, T, C2, Allocator, Options>&)
    template<class C2>
-   void merge(map<Key, T, C2, Allocator, Options>& source)
+   BOOST_CONTAINER_FORCEINLINE void merge(map<Key, T, C2, Allocator, Options>& source)
    {
       typedef container_detail::tree
          <value_type_impl, select_1st_t, C2, Allocator, Options> base2_t;
@@ -1731,7 +1811,7 @@ class multimap
 
    //! @copydoc ::boost::container::multimap::merge(multimap<Key, T, C2, Allocator, Options>&)
    template<class C2>
-   void merge(BOOST_RV_REF_BEG map<Key, T, C2, Allocator, Options> BOOST_RV_REF_END source)
+   BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG map<Key, T, C2, Allocator, Options> BOOST_RV_REF_END source)
    {  return this->merge(static_cast<map<Key, T, C2, Allocator, Options>&>(source)); }
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
diff --git a/contrib/libboost/boost_1_62_0/boost/container/new_allocator.hpp b/contrib/libboost/boost_1_65_0/boost/container/new_allocator.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/container/new_allocator.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/new_allocator.hpp
index 9304a9cfa46..51065efa73a 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/new_allocator.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/new_allocator.hpp
@@ -140,9 +140,9 @@ class new_allocator
    //!Throws std::bad_alloc if there is no enough memory
    pointer allocate(size_type count)
    {
-	   if(BOOST_UNLIKELY(count > this->max_size()))
-	      throw_bad_alloc();
-	   return static_cast<T*>(::operator new(count*sizeof(T)));
+      if(BOOST_UNLIKELY(count > this->max_size()))
+         throw_bad_alloc();
+      return static_cast<T*>(::operator new(count*sizeof(T)));
    }
 
    //!Deallocates previously allocated memory.
diff --git a/contrib/libboost/boost_1_62_0/boost/container/node_allocator.hpp b/contrib/libboost/boost_1_65_0/boost/container/node_allocator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/node_allocator.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/node_allocator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/node_handle.hpp b/contrib/libboost/boost_1_65_0/boost/container/node_handle.hpp
similarity index 68%
rename from contrib/libboost/boost_1_62_0/boost/container/node_handle.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/node_handle.hpp
index 300b4713ada..594a09c99e3 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/node_handle.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/node_handle.hpp
@@ -23,7 +23,7 @@
 #include <boost/container/detail/workaround.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/container/detail/placement_new.hpp>
-#include <boost/container/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/allocator_traits.hpp>
 #include <boost/container/detail/mpl.hpp>
 
@@ -40,20 +40,34 @@ namespace container {
 
 ///@cond
 
-template<class Value, class KeyMapped, bool keymapped_is_void = container_detail::is_same<KeyMapped, void>::value>
+template<class Value, class KeyMapped>
 struct node_handle_keymapped_traits
+{
+   typedef typename KeyMapped::key_type      key_type;
+   typedef typename KeyMapped::mapped_type   mapped_type;
+};
+
+template<class Value>
+struct node_handle_keymapped_traits<Value, void>
 {
    typedef Value key_type;
    typedef Value mapped_type;
 };
 
-template<class Value, class KeyMapped>
-struct node_handle_keymapped_traits<Value, KeyMapped, false>
+class node_handle_friend
 {
-   typedef typename KeyMapped::key_type      key_type;
-   typedef typename KeyMapped::mapped_type   mapped_type;
+   public:
+
+   template<class NH>
+   BOOST_CONTAINER_FORCEINLINE static void destroy_alloc(NH &nh) BOOST_NOEXCEPT
+   {  nh.destroy_alloc();  }
+
+   template<class NH>
+   BOOST_CONTAINER_FORCEINLINE static typename NH::node_pointer &get_node_pointer(NH &nh) BOOST_NOEXCEPT
+   {  return nh.get_node_pointer();  }
 };
 
+
 ///@endcond
 
 //! A node_handle is an object that accepts ownership of a single element from an associative container.
@@ -73,73 +87,63 @@ struct node_handle_keymapped_traits<Value, KeyMapped, false>
 //! 
 //! If a node handle is not empty, then it contains an allocator that is equal to the allocator of the container
 //! when the element was extracted. If a node handle is empty, it contains no allocator.
-template <class NodeType, class Value, class Allocator, class KeyMapped = void>
+template <class NodeAllocator, class KeyMapped = void>
 class node_handle
 {
-   typedef node_handle_keymapped_traits<Value, KeyMapped> keymapped_t;
+   typedef NodeAllocator                                          nallocator_type;
+   typedef allocator_traits<NodeAllocator>                        nator_traits;
+   typedef typename nator_traits::value_type                      priv_node_t;
+   typedef typename priv_node_t::value_type                       priv_value_t;
+   typedef node_handle_keymapped_traits<priv_value_t, KeyMapped>  keymapped_t;
 
    public:
-   typedef Value                                                  value_type;
+   typedef priv_value_t                                           value_type;
    typedef typename keymapped_t::key_type                         key_type;
    typedef typename keymapped_t::mapped_type                      mapped_type;
-   typedef Allocator                                              allocator_type;
-   typedef NodeType                                               container_node_type;
+   typedef typename nator_traits::template portable_rebind_alloc
+      <value_type>::type                                          allocator_type;
+
+   typedef priv_node_t                                            container_node_type;
+   friend class node_handle_friend;
 
    ///@cond
    private:
    BOOST_MOVABLE_BUT_NOT_COPYABLE(node_handle)
 
-   typedef allocator_traits<allocator_type>                                   ator_traits;
-   typedef typename ator_traits::template portable_rebind_alloc
-      <container_node_type>::type                                             nallocator_type;
-   typedef allocator_traits<nallocator_type>                                  node_ator_traits;
-   typedef typename node_ator_traits::pointer                                 node_pointer;
+   typedef typename nator_traits::pointer                         node_pointer;
    typedef ::boost::aligned_storage
-      <sizeof(allocator_type), boost::alignment_of<nallocator_type>::value>   nalloc_storage_t;
+      < sizeof(nallocator_type)
+      , boost::alignment_of<nallocator_type>::value>              nalloc_storage_t;
 
    node_pointer      m_ptr;
    nalloc_storage_t  m_nalloc_storage;
 
    void move_construct_alloc(nallocator_type &al)
-   {  ::new(m_nalloc_storage.address(), boost_container_new_t()) allocator_type(::boost::move(al));   }
+   {  ::new(m_nalloc_storage.address(), boost_container_new_t()) nallocator_type(::boost::move(al));   }
 
-   void destroy_node()
+   void destroy_deallocate_node()
    {
-      node_ator_traits::destroy(this->node_alloc(), container_detail::to_raw_pointer(m_ptr));
-      node_ator_traits::deallocate(this->node_alloc(), m_ptr, 1u);
+      nator_traits::destroy(this->node_alloc(), boost::movelib::to_raw_pointer(m_ptr));
+      nator_traits::deallocate(this->node_alloc(), m_ptr, 1u);
    }
 
    template<class OtherNodeHandle>
    void move_construct_end(OtherNodeHandle &nh)
    {
       if(m_ptr){
-         ::new (m_nalloc_storage.address(), boost_container_new_t()) allocator_type(::boost::move(nh.node_alloc()));
-         nh.destroy_alloc();
-         nh.get_node_pointer() = node_pointer();
+         ::new (m_nalloc_storage.address(), boost_container_new_t()) nallocator_type(::boost::move(nh.node_alloc()));
+         node_handle_friend::destroy_alloc(nh);
+         node_handle_friend::get_node_pointer(nh) = node_pointer();
       }
       BOOST_ASSERT(nh.empty());
    }
 
-   public:
+   void destroy_alloc() BOOST_NOEXCEPT
+   {  static_cast<nallocator_type*>(m_nalloc_storage.address())->~nallocator_type();  }
 
-   void destroy_alloc()
-   {  static_cast<allocator_type*>(m_nalloc_storage.address())->~allocator_type();  }
-
-   node_pointer &get_node_pointer()
+   node_pointer &get_node_pointer() BOOST_NOEXCEPT
    {  return m_ptr;  }
 
-   nallocator_type &node_alloc()
-   {  return *static_cast<nallocator_type*>(m_nalloc_storage.address()); }
-
-   node_pointer release()
-   {
-      node_pointer p(m_ptr);
-      m_ptr = node_pointer();
-      if(p)
-         this->destroy_alloc();
-      return p;
-   }
-
    ///@endcond
 
    public:
@@ -147,13 +151,13 @@ class node_handle
    //!
    //! <b>Postcondition</b>: this->empty()
    BOOST_CXX14_CONSTEXPR node_handle() BOOST_NOEXCEPT
-      :  m_ptr(), m_nalloc_storage()
-   {  BOOST_ASSERT(this->empty()); }
+      :  m_ptr()
+   { }
 
    //! <b>Effects</b>: Constructs a node_handle object initializing internal pointer with p.
-   //!   If p != nullptr copy constructs internal allocator al.
+   //!   If p != nullptr copy constructs internal allocator from al.
    node_handle(node_pointer p, const nallocator_type &al) BOOST_NOEXCEPT
-      :  m_ptr(p), m_nalloc_storage()
+      :  m_ptr(p)
    {
       if(m_ptr){
          ::new (m_nalloc_storage.address(), boost_container_new_t()) nallocator_type(al);
@@ -169,12 +173,12 @@ class node_handle
    //! <b>Note</b>: Two node_handle's are related if only one of KeyMapped template parameter
    //!   of a node handle is void.
    template<class KeyMapped2>
-   node_handle( BOOST_RV_REF_BEG node_handle<NodeType, Value, Allocator, KeyMapped2> BOOST_RV_REF_END nh
+   node_handle( BOOST_RV_REF_BEG node_handle<NodeAllocator, KeyMapped2> BOOST_RV_REF_END nh
                , typename container_detail::enable_if_c
                   < ((unsigned)container_detail::is_same<KeyMapped,  void>::value +
                      (unsigned)container_detail::is_same<KeyMapped2, void>::value) == 1u
-                  >::type* = 0)
-      :  m_ptr(nh.get_node_pointer()), m_nalloc_storage()
+                  >::type* = 0) BOOST_NOEXCEPT
+      :  m_ptr(nh.get())
    {  this->move_construct_end(nh);  }
 
    //! <b>Effects</b>: Constructs a node_handle object initializing internal pointer with nh's internal pointer
@@ -183,43 +187,44 @@ class node_handle
    //!
    //! <b>Postcondition</b>: nh.empty()
    node_handle (BOOST_RV_REF(node_handle) nh) BOOST_NOEXCEPT
-      : m_ptr(nh.m_ptr), m_nalloc_storage()
+      : m_ptr(nh.m_ptr)
    {  this->move_construct_end(nh);  }
 
    //! <b>Effects</b>: If !this->empty(), destroys the value_type subobject in the container_node_type object
    //!   pointed to by c by calling allocator_traits<impl_defined>::destroy, then deallocates m_ptr by calling
-   //!   ator_traits::rebind_traits<container_node_type>::deallocate.
-   ~node_handle () BOOST_NOEXCEPT
+   //!   nator_traits::rebind_traits<container_node_type>::deallocate.
+   ~node_handle() BOOST_NOEXCEPT
    {
       if(!this->empty()){
-         this->destroy_node();
+         this->destroy_deallocate_node();
          this->destroy_alloc();
       }
    }
 
-   //! <b>Requires</b>: Either this->empty(), or ator_traits::propagate_on_container_move_assignment is true, or
+   //! <b>Requires</b>: Either this->empty(), or nator_traits::propagate_on_container_move_assignment is true, or
    //!   node_alloc() == nh.node_alloc().
    //!
    //! <b>Effects</b>: If m_ptr != nullptr, destroys the value_type subobject in the container_node_type object
-   //!   pointed to by m_ptr by calling ator_traits::destroy, then deallocates m_ptr by calling ator_-
-   //!   traits::rebind_traits<container_node_type>::deallocate. Assigns nh.m_ptr to m_ptr. If this->empty()
-   //!   or ator_traits::propagate_on_container_move_assignment is true, move assigns nh.node_alloc() to
+   //!   pointed to by m_ptr by calling nator_traits::destroy, then deallocates m_ptr by calling
+   //!   nator_traits::deallocate. Assigns nh.m_ptr to m_ptr. If this->empty()
+   //!   or nator_traits::propagate_on_container_move_assignment is true, move assigns nh.node_alloc() to
    //!   node_alloc(). Assigns nullptr to nh.m_ptr and assigns nullopt to nh.node_alloc().
+   //!
    //! <b>Returns</b>: *this.
    //!
    //! <b>Throws</b>: Nothing.
-   node_handle & operator=(BOOST_RV_REF(node_handle) nh)
+   node_handle & operator=(BOOST_RV_REF(node_handle) nh) BOOST_NOEXCEPT
    {
-      BOOST_ASSERT(this->empty() || nh.empty() || ator_traits::propagate_on_container_move_assignment::value 
-                   || ator_traits::equal(node_alloc(), nh.node_alloc()));
+      BOOST_ASSERT(this->empty() || nator_traits::propagate_on_container_move_assignment::value 
+                   || nator_traits::equal(node_alloc(), nh.node_alloc()));
 
       bool const was_this_non_null = !this->empty();
       bool const was_nh_non_null   = !nh.empty();
 
       if(was_nh_non_null){
          if(was_this_non_null){
-            this->destroy_node();
-            if(ator_traits::propagate_on_container_move_assignment::value){
+            this->destroy_deallocate_node();
+            if(nator_traits::propagate_on_container_move_assignment::value){
                this->node_alloc() = ::boost::move(nh.node_alloc());
             }
          }
@@ -231,7 +236,7 @@ class node_handle
          nh.destroy_alloc();
       }
       else if(was_this_non_null){
-         this->destroy_node();
+         this->destroy_deallocate_node();
          this->destroy_alloc();
          m_ptr = node_pointer();
       }
@@ -307,23 +312,23 @@ class node_handle
       return !this->m_ptr;
    }
 
-   //! <b>Requires</b>: this->empty(), or nh.empty(), or ator_traits::propagate_on_container_swap is true, or
+   //! <b>Requires</b>: this->empty(), or nh.empty(), or nator_traits::propagate_on_container_swap is true, or
    //!   node_alloc() == nh.node_alloc().
    //!
-   //! <b>Effects</b>: Calls swap(m_ptr, nh.m_ptr). If this->empty(), or nh.empty(), or ator_traits::propagate_on_-
+   //! <b>Effects</b>: Calls swap(m_ptr, nh.m_ptr). If this->empty(), or nh.empty(), or nator_traits::propagate_on_-
    //!   container_swap is true calls swap(node_alloc(), nh.node_alloc()).
    void swap(node_handle &nh)
-      BOOST_NOEXCEPT_IF(ator_traits::propagate_on_container_swap::value || ator_traits::is_always_equal::value)
+      BOOST_NOEXCEPT_IF(nator_traits::propagate_on_container_swap::value || nator_traits::is_always_equal::value)
    {
-      BOOST_ASSERT(this->empty() || nh.empty() || ator_traits::propagate_on_container_swap::value
-                   || ator_traits::equal(node_alloc(), nh.node_alloc()));
+      BOOST_ASSERT(this->empty() || nh.empty() || nator_traits::propagate_on_container_swap::value
+                   || nator_traits::equal(node_alloc(), nh.node_alloc()));
 
       bool const was_this_non_null = !this->empty();
       bool const was_nh_non_null   = !nh.empty();
 
       if(was_nh_non_null){
          if(was_this_non_null){
-            if(ator_traits::propagate_on_container_swap){
+            if(nator_traits::propagate_on_container_swap::value){
                ::boost::adl_move_swap(this->node_alloc(), nh.node_alloc());
             }
          }
@@ -334,11 +339,53 @@ class node_handle
       }
       else if(was_this_non_null){
          nh.move_construct_alloc(this->node_alloc());
-         nh.destroy_alloc();
+         this->destroy_alloc();
       }
       ::boost::adl_move_swap(m_ptr, nh.m_ptr);
    }
 
+   //! <b>Effects</b>: If this->empty() returns nullptr, otherwise returns m_ptr
+   //!   resets m_ptr to nullptr and destroys the internal allocator.
+   //!
+   //! <b>Postcondition</b>: this->empty()
+   //!
+   //! <b>Note</b>: Non-standard extensions
+   node_pointer release() BOOST_NOEXCEPT
+   {
+      node_pointer p(m_ptr);
+      m_ptr = node_pointer();
+      if(p)
+         this->destroy_alloc();
+      return p;
+   }
+
+   //! <b>Effects</b>: Returns m_ptr.
+   //!
+   //! <b>Note</b>: Non-standard extensions
+   node_pointer get() const BOOST_NOEXCEPT
+   {
+      return m_ptr;
+   }
+
+   //! <b>Effects</b>: Returns a reference to the internal node allocator.
+   //!
+   //! <b>Note</b>: Non-standard extensions
+   nallocator_type &node_alloc() BOOST_NOEXCEPT
+   {
+      BOOST_ASSERT(!empty());
+      return *static_cast<nallocator_type*>(m_nalloc_storage.address());
+   }
+
+
+   //! <b>Effects</b>: Returns a reference to the internal node allocator.
+   //!
+   //! <b>Note</b>: Non-standard extensions
+   const nallocator_type &node_alloc() const BOOST_NOEXCEPT
+   {
+      BOOST_ASSERT(!empty());
+      return *static_cast<const nallocator_type*>(m_nalloc_storage.address());
+   }
+
    //! <b>Effects</b>: x.swap(y).
    //!
    friend void swap(node_handle & x, node_handle & y) BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT(x.swap(y)))
diff --git a/contrib/libboost/boost_1_62_0/boost/container/options.hpp b/contrib/libboost/boost_1_65_0/boost/container/options.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/options.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/options.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/pmr/deque.hpp b/contrib/libboost/boost_1_65_0/boost/container/pmr/deque.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/pmr/deque.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/pmr/deque.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/pmr/flat_map.hpp b/contrib/libboost/boost_1_65_0/boost/container/pmr/flat_map.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/pmr/flat_map.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/pmr/flat_map.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/pmr/flat_set.hpp b/contrib/libboost/boost_1_65_0/boost/container/pmr/flat_set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/pmr/flat_set.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/pmr/flat_set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/pmr/global_resource.hpp b/contrib/libboost/boost_1_65_0/boost/container/pmr/global_resource.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/pmr/global_resource.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/pmr/global_resource.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/pmr/list.hpp b/contrib/libboost/boost_1_65_0/boost/container/pmr/list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/pmr/list.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/pmr/list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/pmr/map.hpp b/contrib/libboost/boost_1_65_0/boost/container/pmr/map.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/pmr/map.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/pmr/map.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/pmr/memory_resource.hpp b/contrib/libboost/boost_1_65_0/boost/container/pmr/memory_resource.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/pmr/memory_resource.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/pmr/memory_resource.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/pmr/monotonic_buffer_resource.hpp b/contrib/libboost/boost_1_65_0/boost/container/pmr/monotonic_buffer_resource.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/pmr/monotonic_buffer_resource.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/pmr/monotonic_buffer_resource.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/pmr/polymorphic_allocator.hpp b/contrib/libboost/boost_1_65_0/boost/container/pmr/polymorphic_allocator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/pmr/polymorphic_allocator.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/pmr/polymorphic_allocator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/pmr/pool_options.hpp b/contrib/libboost/boost_1_65_0/boost/container/pmr/pool_options.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/pmr/pool_options.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/pmr/pool_options.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/pmr/resource_adaptor.hpp b/contrib/libboost/boost_1_65_0/boost/container/pmr/resource_adaptor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/pmr/resource_adaptor.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/pmr/resource_adaptor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/pmr/set.hpp b/contrib/libboost/boost_1_65_0/boost/container/pmr/set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/pmr/set.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/pmr/set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/pmr/slist.hpp b/contrib/libboost/boost_1_65_0/boost/container/pmr/slist.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/pmr/slist.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/pmr/slist.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/pmr/small_vector.hpp b/contrib/libboost/boost_1_65_0/boost/container/pmr/small_vector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/pmr/small_vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/pmr/small_vector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/pmr/stable_vector.hpp b/contrib/libboost/boost_1_65_0/boost/container/pmr/stable_vector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/pmr/stable_vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/pmr/stable_vector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/pmr/string.hpp b/contrib/libboost/boost_1_65_0/boost/container/pmr/string.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/pmr/string.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/pmr/string.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/pmr/synchronized_pool_resource.hpp b/contrib/libboost/boost_1_65_0/boost/container/pmr/synchronized_pool_resource.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/pmr/synchronized_pool_resource.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/pmr/synchronized_pool_resource.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/pmr/unsynchronized_pool_resource.hpp b/contrib/libboost/boost_1_65_0/boost/container/pmr/unsynchronized_pool_resource.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/pmr/unsynchronized_pool_resource.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/pmr/unsynchronized_pool_resource.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/pmr/vector.hpp b/contrib/libboost/boost_1_65_0/boost/container/pmr/vector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/pmr/vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/pmr/vector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/scoped_allocator.hpp b/contrib/libboost/boost_1_65_0/boost/container/scoped_allocator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/scoped_allocator.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/scoped_allocator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/scoped_allocator_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/container/scoped_allocator_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/scoped_allocator_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/scoped_allocator_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/set.hpp b/contrib/libboost/boost_1_65_0/boost/container/set.hpp
similarity index 77%
rename from contrib/libboost/boost_1_62_0/boost/container/set.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/set.hpp
index 5cf0f964a5f..8730b1c89ad 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/set.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/set.hpp
@@ -112,48 +112,105 @@ class set
    //! <b>Effects</b>: Default constructs an empty set.
    //!
    //! <b>Complexity</b>: Constant.
-   set() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
-                           container_detail::is_nothrow_default_constructible<Compare>::value)
+   
+   BOOST_CONTAINER_FORCEINLINE set()
+      BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
+                        container_detail::is_nothrow_default_constructible<Compare>::value)
       : base_t()
    {}
 
+   //! <b>Effects</b>: Constructs an empty set using the specified allocator object.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE explicit set(const allocator_type& a)
+      : base_t(a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty set using the specified comparison object.
+   //!
+   //! <b>Complexity</b>: Constant.
+   BOOST_CONTAINER_FORCEINLINE explicit set(const Compare& comp)
+      : base_t(comp)
+   {}
+
    //! <b>Effects</b>: Constructs an empty set using the specified comparison object
    //! and allocator.
    //!
    //! <b>Complexity</b>: Constant.
-   explicit set(const Compare& comp,
-                const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE set(const Compare& comp, const allocator_type& a)
       : base_t(comp, a)
    {}
 
-   //! <b>Effects</b>: Constructs an empty set using the specified allocator object.
-   //!
-   //! <b>Complexity</b>: Constant.
-   explicit set(const allocator_type& a)
-      : base_t(a)
-   {}
-
-   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
-   //! allocator, and inserts elements from the range [first ,last ).
+   //! <b>Effects</b>: Constructs an empty set using and
+   //! inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   set(InputIterator first, InputIterator last, const Compare& comp = Compare(),
-         const allocator_type& a = allocator_type())
-      : base_t(true, first, last, comp, a)
+   BOOST_CONTAINER_FORCEINLINE set(InputIterator first, InputIterator last)
+      : base_t(true, first, last)
    {}
 
    //! <b>Effects</b>: Constructs an empty set using the specified
    //! allocator, and inserts elements from the range [first ,last ).
    //!
    //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
-   //! comp and otherwise N logN, where N is last - first.
+   //! the predicate and otherwise N logN, where N is last - first.
    template <class InputIterator>
-   set(InputIterator first, InputIterator last, const allocator_type& a)
+   BOOST_CONTAINER_FORCEINLINE set(InputIterator first, InputIterator last, const allocator_type& a)
       : base_t(true, first, last, key_compare(), a)
    {}
 
+   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
+   //! inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE set(InputIterator first, InputIterator last, const Compare& comp)
+      : base_t(true, first, last, comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
+   //! allocator, and inserts elements from the range [first ,last ).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using
+   //! the predicate and otherwise N logN, where N is last - first.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE set(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : base_t(true, first, last, comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty set and
+   //! inserts elements from the ordered unique range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE set( ordered_unique_range_t, InputIterator first, InputIterator last)
+      : base_t(ordered_range, first, last)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
+   //! inserts elements from the ordered unique range [first ,last). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE set( ordered_unique_range_t, InputIterator first, InputIterator last, const Compare& comp )
+      : base_t(ordered_range, first, last, comp)
+   {}
+
    //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
    //! allocator, and inserts elements from the ordered unique range [first ,last). This function
    //! is more efficient than the normal range creation for ordered ranges.
@@ -165,30 +222,76 @@ class set
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   set( ordered_unique_range_t, InputIterator first, InputIterator last
-      , const Compare& comp = Compare(), const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE set( ordered_unique_range_t, InputIterator first, InputIterator last
+      , const Compare& comp, const allocator_type& a)
       : base_t(ordered_range, first, last, comp, a)
    {}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
-   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //! <b>Effects</b>: Constructs an empty set and
+   //! inserts elements from the range [il.begin(), il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
-   //! comp and otherwise N logN, where N is il.begin() - il.end().
-   set(std::initializer_list<value_type> il, const Compare& comp = Compare(), const allocator_type& a = allocator_type())
-      : base_t(true, il.begin(), il.end(), comp, a)
+   //! the predicate and otherwise N logN, where N is il.begin() - il.end().
+   BOOST_CONTAINER_FORCEINLINE set(std::initializer_list<value_type> il)
+      : base_t(true, il.begin(), il.end())
    {}
 
    //! <b>Effects</b>: Constructs an empty set using the specified
    //! allocator, and inserts elements from the range [il.begin(), il.end()).
    //!
    //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
-   //! comp and otherwise N logN, where N is il.begin() - il.end().
-   set(std::initializer_list<value_type> il, const allocator_type& a)
+   //! the predicate and otherwise N logN, where N is il.begin() - il.end().
+   BOOST_CONTAINER_FORCEINLINE set(std::initializer_list<value_type> il, const allocator_type& a)
       : base_t(true, il.begin(), il.end(), Compare(), a)
    {}
 
+   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
+   //! inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
+   //! the predicate and otherwise N logN, where N is il.begin() - il.end().
+   BOOST_CONTAINER_FORCEINLINE set(std::initializer_list<value_type> il, const Compare& comp )
+      : base_t(true, il.begin(), il.end(), comp)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
+   //! allocator, and inserts elements from the range [il.begin(), il.end()).
+   //!
+   //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using
+   //! the predicate and otherwise N logN, where N is il.begin() - il.end().
+   BOOST_CONTAINER_FORCEINLINE set(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+      : base_t(true, il.begin(), il.end(), comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty set and
+   //! inserts elements from the ordered unique range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE set( ordered_unique_range_t, std::initializer_list<value_type> il)
+      : base_t(ordered_range, il.begin(), il.end())
+   {}
+
+   //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
+   //! inserts elements from the ordered unique range [il.begin(), il.end()). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be
+   //! unique values.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   BOOST_CONTAINER_FORCEINLINE set( ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp)
+      : base_t(ordered_range, il.begin(), il.end(), comp)
+   {}
+
    //! <b>Effects</b>: Constructs an empty set using the specified comparison object and
    //! allocator, and inserts elements from the ordered unique range [il.begin(), il.end()). This function
    //! is more efficient than the normal range creation for ordered ranges.
@@ -199,8 +302,7 @@ class set
    //! <b>Complexity</b>: Linear in N.
    //!
    //! <b>Note</b>: Non-standard extension.
-   set( ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp = Compare()
-      , const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE set( ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
       : base_t(ordered_range, il.begin(), il.end(), comp, a)
    {}
 #endif
@@ -208,7 +310,7 @@ class set
    //! <b>Effects</b>: Copy constructs a set.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   set(const set& x)
+   BOOST_CONTAINER_FORCEINLINE set(const set& x)
       : base_t(static_cast<const base_t&>(x))
    {}
 
@@ -217,7 +319,7 @@ class set
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Postcondition</b>: x is emptied.
-   set(BOOST_RV_REF(set) x)
+   BOOST_CONTAINER_FORCEINLINE set(BOOST_RV_REF(set) x)
       BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
       : base_t(BOOST_MOVE_BASE(base_t, x))
    {}
@@ -225,7 +327,7 @@ class set
    //! <b>Effects</b>: Copy constructs a set using the specified allocator.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   set(const set& x, const allocator_type &a)
+   BOOST_CONTAINER_FORCEINLINE set(const set& x, const allocator_type &a)
       : base_t(static_cast<const base_t&>(x), a)
    {}
 
@@ -233,14 +335,14 @@ class set
    //!                 Constructs *this using x's resources.
    //!
    //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise.
-   set(BOOST_RV_REF(set) x, const allocator_type &a)
+   BOOST_CONTAINER_FORCEINLINE set(BOOST_RV_REF(set) x, const allocator_type &a)
       : base_t(BOOST_MOVE_BASE(base_t, x), a)
    {}
 
    //! <b>Effects</b>: Makes *this a copy of x.
    //!
    //! <b>Complexity</b>: Linear in x.size().
-   set& operator=(BOOST_COPY_ASSIGN_REF(set) x)
+   BOOST_CONTAINER_FORCEINLINE set& operator=(BOOST_COPY_ASSIGN_REF(set) x)
    {  return static_cast<set&>(this->base_t::operator=(static_cast<const base_t&>(x)));  }
 
    //! <b>Effects</b>: this->swap(x.get()).
@@ -251,7 +353,7 @@ class set
    //! <b>Complexity</b>: Constant if allocator_traits_type::
    //!   propagate_on_container_move_assignment is true or
    //!   this->get>allocator() == x.get_allocator(). Linear otherwise.
-   set& operator=(BOOST_RV_REF(set) x)
+   BOOST_CONTAINER_FORCEINLINE set& operator=(BOOST_RV_REF(set) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
                            boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
@@ -424,7 +526,7 @@ class set
    //!
    //! <b>Complexity</b>: Logarithmic.
    template <class... Args>
-   std::pair<iterator,bool> emplace(BOOST_FWD_REF(Args)... args)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> emplace(BOOST_FWD_REF(Args)... args)
    {  return this->base_t::emplace_unique(boost::forward<Args>(args)...); }
 
    //! <b>Effects</b>:  Inserts an object of type Key constructed with
@@ -437,18 +539,18 @@ class set
    //!
    //! <b>Complexity</b>: Logarithmic.
    template <class... Args>
-   iterator emplace_hint(const_iterator p, BOOST_FWD_REF(Args)... args)
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator p, BOOST_FWD_REF(Args)... args)
    {  return this->base_t::emplace_hint_unique(p, boost::forward<Args>(args)...); }
 
    #else // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
    #define BOOST_CONTAINER_SET_EMPLACE_CODE(N) \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   std::pair<iterator,bool> emplace(BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,bool> emplace(BOOST_MOVE_UREF##N)\
    {  return this->base_t::emplace_unique(BOOST_MOVE_FWD##N);  }\
    \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {  return this->base_t::emplace_hint_unique(hint BOOST_MOVE_I##N BOOST_MOVE_FWD##N); }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_SET_EMPLACE_CODE)
@@ -513,7 +615,7 @@ class set
    //!
    //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last)
+   BOOST_CONTAINER_FORCEINLINE void insert(InputIterator first, InputIterator last)
    {  this->base_t::insert_unique(first, last);  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -521,16 +623,16 @@ class set
    //!   if there is no element with key equivalent to the key of that element.
    //!
    //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from il.begin() to il.end())
-   void insert(std::initializer_list<value_type> il)
+   BOOST_CONTAINER_FORCEINLINE void insert(std::initializer_list<value_type> il)
    {  this->base_t::insert_unique(il.begin(), il.end()); }
 #endif
 
    //! @copydoc ::boost::container::map::insert(node_type&&)
-   insert_return_type insert(BOOST_RV_REF_BEG_IF_CXX11 node_type BOOST_RV_REF_END_IF_CXX11 nh)
+   BOOST_CONTAINER_FORCEINLINE insert_return_type insert(BOOST_RV_REF_BEG_IF_CXX11 node_type BOOST_RV_REF_END_IF_CXX11 nh)
    {  return this->base_t::insert_unique_node(boost::move(nh));  }
 
    //! @copydoc ::boost::container::map::insert(const_iterator, node_type&&)
-   insert_return_type insert(const_iterator hint, BOOST_RV_REF_BEG_IF_CXX11 node_type BOOST_RV_REF_END_IF_CXX11 nh)
+   BOOST_CONTAINER_FORCEINLINE insert_return_type insert(const_iterator hint, BOOST_RV_REF_BEG_IF_CXX11 node_type BOOST_RV_REF_END_IF_CXX11 nh)
    {  return this->base_t::insert_unique_node(hint, boost::move(nh));  }
 
    //! @copydoc ::boost::container::map::merge(map<Key, T, C2, Allocator, Options>&)
@@ -586,6 +688,12 @@ class set
    //! <b>Complexity</b>: log(size())+N where N is the distance from first to last.
    iterator erase(const_iterator first, const_iterator last);
 
+   //! @copydoc ::boost::container::map::extract(const_iterator)
+   node_type extract(const_iterator p);
+
+   //! @copydoc ::boost::container::map::extract(const key_type&)
+   node_type extract(const key_type& x);
+
    //! <b>Effects</b>: Swaps the contents of *this and x.
    //!
    //! <b>Throws</b>: Nothing.
@@ -631,13 +739,13 @@ class set
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   size_type count(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE size_type count(const key_type& x) const
    {  return static_cast<size_type>(this->base_t::find(x) != this->base_t::cend());  }
 
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!
    //! <b>Complexity</b>: log(size())+count(k)
-   size_type count(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE size_type count(const key_type& x)
    {  return static_cast<size_type>(this->base_t::find(x) != this->base_t::end());  }
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -671,13 +779,13 @@ class set
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<iterator,iterator> equal_range(const key_type& x)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator,iterator> equal_range(const key_type& x)
    {  return this->base_t::lower_bound_range(x);  }
 
    //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).
    //!
    //! <b>Complexity</b>: Logarithmic
-   std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
+   BOOST_CONTAINER_FORCEINLINE std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const
    {  return this->base_t::lower_bound_range(x);  }
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -737,11 +845,11 @@ class set
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
    template <class KeyType>
-   std::pair<iterator, bool> priv_insert(BOOST_FWD_REF(KeyType) x)
+   BOOST_CONTAINER_FORCEINLINE std::pair<iterator, bool> priv_insert(BOOST_FWD_REF(KeyType) x)
    {  return this->base_t::insert_unique(::boost::forward<KeyType>(x));  }
 
    template <class KeyType>
-   iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
+   BOOST_CONTAINER_FORCEINLINE iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
    {  return this->base_t::insert_unique(p, ::boost::forward<KeyType>(x)); }
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 };
@@ -829,36 +937,79 @@ class multiset
    //////////////////////////////////////////////
 
    //! @copydoc ::boost::container::set::set()
-   multiset() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
-                                container_detail::is_nothrow_default_constructible<Compare>::value)
+   BOOST_CONTAINER_FORCEINLINE multiset()
+      BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
+                        container_detail::is_nothrow_default_constructible<Compare>::value)
       : base_t()
    {}
 
-   //! @copydoc ::boost::container::set::set(const Compare&, const allocator_type&)
-   explicit multiset(const Compare& comp,
-                     const allocator_type& a = allocator_type())
-      : base_t(comp, a)
-   {}
-
    //! @copydoc ::boost::container::set::set(const allocator_type&)
-   explicit multiset(const allocator_type& a)
+   BOOST_CONTAINER_FORCEINLINE explicit multiset(const allocator_type& a)
       : base_t(a)
    {}
 
-   //! @copydoc ::boost::container::set::set(InputIterator, InputIterator, const Compare& comp, const allocator_type&)
+   //! @copydoc ::boost::container::set::set(const Compare&)
+   BOOST_CONTAINER_FORCEINLINE explicit multiset(const Compare& comp)
+      : base_t(comp)
+   {}
+
+   //! @copydoc ::boost::container::set::set(const Compare&, const allocator_type&)
+   BOOST_CONTAINER_FORCEINLINE multiset(const Compare& comp, const allocator_type& a)
+      : base_t(comp, a)
+   {}
+
+   //! @copydoc ::boost::container::set::set(InputIterator, InputIterator)
    template <class InputIterator>
-   multiset(InputIterator first, InputIterator last,
-            const Compare& comp = Compare(),
-            const allocator_type& a = allocator_type())
-      : base_t(false, first, last, comp, a)
+   BOOST_CONTAINER_FORCEINLINE multiset(InputIterator first, InputIterator last)
+      : base_t(false, first, last)
    {}
 
    //! @copydoc ::boost::container::set::set(InputIterator, InputIterator, const allocator_type&)
    template <class InputIterator>
-   multiset(InputIterator first, InputIterator last, const allocator_type& a)
+   BOOST_CONTAINER_FORCEINLINE multiset(InputIterator first, InputIterator last, const allocator_type& a)
       : base_t(false, first, last, key_compare(), a)
    {}
 
+   //! @copydoc ::boost::container::set::set(InputIterator, InputIterator, const Compare&)
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE multiset(InputIterator first, InputIterator last, const Compare& comp)
+      : base_t(false, first, last, comp)
+   {}
+
+   //! @copydoc ::boost::container::set::set(InputIterator, InputIterator, const Compare&, const allocator_type&)
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE multiset(InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
+      : base_t(false, first, last, comp, a)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty multiset and
+   //! and inserts elements from the ordered range [first ,last ). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE multiset( ordered_range_t, InputIterator first, InputIterator last )
+      : base_t(ordered_range, first, last)
+   {}
+
+   //! <b>Effects</b>: Constructs an empty multiset using the specified comparison object and
+   //! inserts elements from the ordered range [first ,last ). This function
+   //! is more efficient than the normal range creation for ordered ranges.
+   //!
+   //! <b>Requires</b>: [first ,last) must be ordered according to the predicate.
+   //!
+   //! <b>Complexity</b>: Linear in N.
+   //!
+   //! <b>Note</b>: Non-standard extension.
+   template <class InputIterator>
+   BOOST_CONTAINER_FORCEINLINE multiset( ordered_range_t, InputIterator first, InputIterator last, const Compare& comp)
+      : base_t(ordered_range, first, last, comp)
+   {}
+
    //! <b>Effects</b>: Constructs an empty multiset using the specified comparison object and
    //! allocator, and inserts elements from the ordered range [first ,last ). This function
    //! is more efficient than the normal range creation for ordered ranges.
@@ -869,56 +1020,74 @@ class multiset
    //!
    //! <b>Note</b>: Non-standard extension.
    template <class InputIterator>
-   multiset( ordered_range_t, InputIterator first, InputIterator last
-           , const Compare& comp = Compare()
-           , const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE multiset( ordered_range_t, InputIterator first, InputIterator last, const Compare& comp, const allocator_type& a)
       : base_t(ordered_range, first, last, comp, a)
    {}
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-   //! @copydoc ::boost::container::set::set(std::initializer_list<value_type>, const Compare& comp, const allocator_type&)
-   multiset(std::initializer_list<value_type> il, const Compare& comp = Compare(), const allocator_type& a = allocator_type())
-      : base_t(false, il.begin(), il.end(), comp, a)
+   //! @copydoc ::boost::container::set::set(std::initializer_list<value_type>)
+   BOOST_CONTAINER_FORCEINLINE multiset(std::initializer_list<value_type> il)
+      : base_t(false, il.begin(), il.end())
    {}
 
    //! @copydoc ::boost::container::set::set(std::initializer_list<value_type>, const allocator_type&)
-   multiset(std::initializer_list<value_type> il, const allocator_type& a)
+   BOOST_CONTAINER_FORCEINLINE multiset(std::initializer_list<value_type> il, const allocator_type& a)
       : base_t(false, il.begin(), il.end(), Compare(), a)
    {}
 
-   //! @copydoc ::boost::container::set::set(ordered_unique_range_t, std::initializer_list<value_type>, const Compare& comp, const allocator_type&)
-   multiset(ordered_unique_range_t, std::initializer_list<value_type> il, const Compare& comp = Compare(), const allocator_type& a = allocator_type())
+   //! @copydoc ::boost::container::set::set(std::initializer_list<value_type>, const Compare&)
+   BOOST_CONTAINER_FORCEINLINE multiset(std::initializer_list<value_type> il, const Compare& comp)
+      : base_t(false, il.begin(), il.end(), comp)
+   {}
+
+   //! @copydoc ::boost::container::set::set(std::initializer_list<value_type>, const Compare&, const allocator_type&)
+   BOOST_CONTAINER_FORCEINLINE multiset(std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
+      : base_t(false, il.begin(), il.end(), comp, a)
+   {}
+
+   //! @copydoc ::boost::container::set::set(ordered_unique_range_t, std::initializer_list<value_type>)
+   BOOST_CONTAINER_FORCEINLINE multiset(ordered_range_t, std::initializer_list<value_type> il)
+      : base_t(ordered_range, il.begin(), il.end())
+   {}
+
+   //! @copydoc ::boost::container::set::set(ordered_unique_range_t, std::initializer_list<value_type>, const Compare&)
+   BOOST_CONTAINER_FORCEINLINE multiset(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp)
+      : base_t(ordered_range, il.begin(), il.end(), comp)
+   {}
+
+   //! @copydoc ::boost::container::set::set(ordered_unique_range_t, std::initializer_list<value_type>, const Compare&, const allocator_type&)
+   BOOST_CONTAINER_FORCEINLINE multiset(ordered_range_t, std::initializer_list<value_type> il, const Compare& comp, const allocator_type& a)
       : base_t(ordered_range, il.begin(), il.end(), comp, a)
    {}
 #endif
 
    //! @copydoc ::boost::container::set::set(const set &)
-   multiset(const multiset& x)
+   BOOST_CONTAINER_FORCEINLINE multiset(const multiset& x)
       : base_t(static_cast<const base_t&>(x))
    {}
 
    //! @copydoc ::boost::container::set::set(set &&)
-   multiset(BOOST_RV_REF(multiset) x)
+   BOOST_CONTAINER_FORCEINLINE multiset(BOOST_RV_REF(multiset) x)
       BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
       : base_t(BOOST_MOVE_BASE(base_t, x))
    {}
 
    //! @copydoc ::boost::container::set::set(const set &, const allocator_type &)
-   multiset(const multiset& x, const allocator_type &a)
+   BOOST_CONTAINER_FORCEINLINE multiset(const multiset& x, const allocator_type &a)
       : base_t(static_cast<const base_t&>(x), a)
    {}
 
    //! @copydoc ::boost::container::set::set(set &&, const allocator_type &)
-   multiset(BOOST_RV_REF(multiset) x, const allocator_type &a)
+   BOOST_CONTAINER_FORCEINLINE multiset(BOOST_RV_REF(multiset) x, const allocator_type &a)
       : base_t(BOOST_MOVE_BASE(base_t, x), a)
    {}
 
    //! @copydoc ::boost::container::set::operator=(const set &)
-   multiset& operator=(BOOST_COPY_ASSIGN_REF(multiset) x)
+   BOOST_CONTAINER_FORCEINLINE multiset& operator=(BOOST_COPY_ASSIGN_REF(multiset) x)
    {  return static_cast<multiset&>(this->base_t::operator=(static_cast<const base_t&>(x)));  }
 
    //! @copydoc ::boost::container::set::operator=(set &&)
-   multiset& operator=(BOOST_RV_REF(multiset) x)
+   BOOST_CONTAINER_FORCEINLINE multiset& operator=(BOOST_RV_REF(multiset) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
                            boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
@@ -999,7 +1168,7 @@ class multiset
    //!
    //! <b>Complexity</b>: Logarithmic.
    template <class... Args>
-   iterator emplace(BOOST_FWD_REF(Args)... args)
+   BOOST_CONTAINER_FORCEINLINE iterator emplace(BOOST_FWD_REF(Args)... args)
    {  return this->base_t::emplace_equal(boost::forward<Args>(args)...); }
 
    //! <b>Effects</b>: Inserts an object of type Key constructed with
@@ -1011,18 +1180,18 @@ class multiset
    //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t
    //!   is inserted right before p.
    template <class... Args>
-   iterator emplace_hint(const_iterator p, BOOST_FWD_REF(Args)... args)
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator p, BOOST_FWD_REF(Args)... args)
    {  return this->base_t::emplace_hint_equal(p, boost::forward<Args>(args)...); }
 
    #else // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
    #define BOOST_CONTAINER_MULTISET_EMPLACE_CODE(N) \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace(BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace(BOOST_MOVE_UREF##N)\
    {  return this->base_t::emplace_equal(BOOST_MOVE_FWD##N);  }\
    \
    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N \
-   iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+   BOOST_CONTAINER_FORCEINLINE iterator emplace_hint(const_iterator hint BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {  return this->base_t::emplace_hint_equal(hint BOOST_MOVE_I##N BOOST_MOVE_FWD##N); }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_MULTISET_EMPLACE_CODE)
@@ -1079,21 +1248,21 @@ class multiset
    //!
    //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last)
    template <class InputIterator>
-   void insert(InputIterator first, InputIterator last)
+   BOOST_CONTAINER_FORCEINLINE void insert(InputIterator first, InputIterator last)
    {  this->base_t::insert_equal(first, last);  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
    //! @copydoc ::boost::container::set::insert(std::initializer_list<value_type>)
-   void insert(std::initializer_list<value_type> il)
+   BOOST_CONTAINER_FORCEINLINE void insert(std::initializer_list<value_type> il)
    {  this->base_t::insert_equal(il.begin(), il.end());  }
 #endif
 
    //! @copydoc ::boost::container::multimap::insert(node_type&&)
-   iterator insert(BOOST_RV_REF_BEG_IF_CXX11 node_type BOOST_RV_REF_END_IF_CXX11 nh)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(BOOST_RV_REF_BEG_IF_CXX11 node_type BOOST_RV_REF_END_IF_CXX11 nh)
    {  return this->base_t::insert_equal_node(boost::move(nh));  }
 
    //! @copydoc ::boost::container::multimap::insert(const_iterator, node_type&&)
-   iterator insert(const_iterator hint, BOOST_RV_REF_BEG_IF_CXX11 node_type BOOST_RV_REF_END_IF_CXX11 nh)
+   BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator hint, BOOST_RV_REF_BEG_IF_CXX11 node_type BOOST_RV_REF_END_IF_CXX11 nh)
    {  return this->base_t::insert_equal_node(hint, boost::move(nh));  }
 
    //! @copydoc ::boost::container::multimap::merge(multimap<Key, T, C2, Allocator, Options>&)
@@ -1135,6 +1304,12 @@ class multiset
    //! @copydoc ::boost::container::set::erase(const_iterator,const_iterator)
    iterator erase(const_iterator first, const_iterator last);
 
+   //! @copydoc ::boost::container::multimap::extract(const_iterator)
+   node_type extract(const_iterator p);
+
+   //! @copydoc ::boost::container::multimap::extract(const key_type&)
+   node_type extract(const key_type& x);
+
    //! @copydoc ::boost::container::set::swap
    void swap(multiset& x)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
@@ -1219,11 +1394,11 @@ class multiset
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
    template <class KeyType>
-   iterator priv_insert(BOOST_FWD_REF(KeyType) x)
+   BOOST_CONTAINER_FORCEINLINE iterator priv_insert(BOOST_FWD_REF(KeyType) x)
    {  return this->base_t::insert_equal(::boost::forward<KeyType>(x));  }
 
    template <class KeyType>
-   iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
+   BOOST_CONTAINER_FORCEINLINE iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x)
    {  return this->base_t::insert_equal(p, ::boost::forward<KeyType>(x)); }
 
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
diff --git a/contrib/libboost/boost_1_62_0/boost/container/slist.hpp b/contrib/libboost/boost_1_65_0/boost/container/slist.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/slist.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/slist.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/small_vector.hpp b/contrib/libboost/boost_1_65_0/boost/container/small_vector.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/container/small_vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/small_vector.hpp
index e23b54f8ac6..804740cc72e 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/small_vector.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/small_vector.hpp
@@ -387,8 +387,8 @@ class small_vector_base
          this->steal_resources(x);
       }
       else{
-         this->assign( boost::make_move_iterator(container_detail::iterator_to_raw_pointer(x.begin()))
-                     , boost::make_move_iterator(container_detail::iterator_to_raw_pointer(x.end  ()))
+         this->assign( boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(x.begin()))
+                     , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(x.end  ()))
                      );
       }
    }
@@ -507,7 +507,7 @@ class small_vector : public small_vector_base<T, Allocator>
 
    public:
    BOOST_CONTAINER_FORCEINLINE small_vector()
-	   BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value)
+      BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value)
       : base_type(initial_capacity_t(), internal_capacity())
    {}
 
diff --git a/contrib/libboost/boost_1_62_0/boost/container/stable_vector.hpp b/contrib/libboost/boost_1_65_0/boost/container/stable_vector.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/container/stable_vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/stable_vector.hpp
index 5d6dc0f2286..cf156e04def 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/stable_vector.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/stable_vector.hpp
@@ -44,7 +44,7 @@
 #include <boost/container/detail/iterator.hpp>
 #include <boost/container/detail/iterators.hpp>
 #include <boost/container/detail/placement_new.hpp>
-#include <boost/container/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/detail/type_traits.hpp>
 // intrusive
 #include <boost/intrusive/pointer_traits.hpp>
@@ -1975,7 +1975,7 @@ class stable_vector
          , container_detail::addressof(p->value)
          , it);
       //This does not throw
-      ::new(static_cast<node_base_type*>(container_detail::to_raw_pointer(p)), boost_container_new_t())
+      ::new(static_cast<node_base_type*>(boost::movelib::to_raw_pointer(p)), boost_container_new_t())
          node_base_type(index_traits_type::ptr_to_node_base_ptr(*up_index));
    }
 
@@ -1988,7 +1988,7 @@ class stable_vector
          , container_detail::addressof(p->value)
          , ::boost::forward<ValueConvertible>(value_convertible));
       //This does not throw
-      ::new(static_cast<node_base_type*>(container_detail::to_raw_pointer(p)), boost_container_new_t()) node_base_type;
+      ::new(static_cast<node_base_type*>(boost::movelib::to_raw_pointer(p)), boost_container_new_t()) node_base_type;
    }
 
    void priv_swap_members(stable_vector &x)
diff --git a/contrib/libboost/boost_1_62_0/boost/container/static_vector.hpp b/contrib/libboost/boost_1_65_0/boost/container/static_vector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/static_vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/static_vector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/string.hpp b/contrib/libboost/boost_1_65_0/boost/container/string.hpp
similarity index 83%
rename from contrib/libboost/boost_1_62_0/boost/container/string.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/string.hpp
index 1e47abaaf07..24056781c96 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/string.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/string.hpp
@@ -35,20 +35,23 @@
 #include <boost/container/detail/min_max.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/next_capacity.hpp>
-#include <boost/container/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/detail/version_type.hpp>
+#include <boost/container/detail/type_traits.hpp>
+#include <boost/container/detail/minimal_char_traits_header.hpp>
+#include <boost/container/detail/algorithm.hpp>
+
+#include <boost/intrusive/pointer_traits.hpp>
 
 #include <boost/move/utility_core.hpp>
 #include <boost/move/adl_move_swap.hpp>
+#include <boost/move/traits.hpp>
+
 #include <boost/static_assert.hpp>
-#include <boost/intrusive/pointer_traits.hpp>
 #include <boost/core/no_exceptions_support.hpp>
-#include <boost/container/detail/minimal_char_traits_header.hpp>
 #include <boost/functional/hash.hpp>
 
-
 #include <algorithm>
-#include <functional>   //bind2nd, etc.
 #include <iosfwd>
 #include <istream>
 #include <ostream>
@@ -56,8 +59,12 @@
 #include <locale>
 #include <cstddef>
 #include <climits>
-#include <boost/container/detail/type_traits.hpp>
-#include <boost/move/traits.hpp>
+
+//std
+#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+#include <initializer_list>   //for std::initializer_list
+#endif
+
 
 namespace boost {
 namespace container {
@@ -301,14 +308,14 @@ class basic_string_base
    {
       allocator_traits_type::construct
          ( this->alloc()
-         , container_detail::to_raw_pointer(p)
+         , boost::movelib::to_raw_pointer(p)
          , value
          );
    }
 
    void destroy(pointer p, size_type n)
    {
-      value_type *raw_p = container_detail::to_raw_pointer(p);
+      value_type *raw_p = boost::movelib::to_raw_pointer(p);
       for(; n--; ++raw_p){
          allocator_traits_type::destroy( this->alloc(), raw_p);
       }
@@ -318,7 +325,7 @@ class basic_string_base
    {
       allocator_traits_type::destroy
          ( this->alloc()
-         , container_detail::to_raw_pointer(p)
+         , boost::movelib::to_raw_pointer(p)
          );
    }
 
@@ -534,8 +541,8 @@ class basic_string
 
       bool operator()(const typename Tr::char_type& x) const
       {
-         return std::find_if(m_first, m_last,
-                        std::bind1st(Eq_traits<Tr>(), x)) == m_last;
+         return boost::container::find_if(m_first, m_last,
+                        boost::container::bind1st(Eq_traits<Tr>(), x)) == m_last;
       }
    };
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -615,6 +622,17 @@ class basic_string
       this->assign(s.begin(), s.end());
    }
 
+   //! <b>Effects</b>: Same as basic_string(sv.data(), sv.size(), a).
+   //!
+   //! <b>Throws</b>: If allocator_type's default constructor or allocation throws.
+   template<template <class, class> class BasicStringView>
+   explicit basic_string(BasicStringView<CharT, Traits> sv, const Allocator& a = Allocator())
+      :  base_t(allocator_traits_type::select_on_container_copy_construction(a))
+   {
+      this->priv_terminate_string();
+      this->assign(sv);
+   }
+
    //! <b>Effects</b>: Move constructor. Moves s's resources to *this.
    //!
    //! <b>Throws</b>: Nothing.
@@ -780,6 +798,17 @@ class basic_string
       this->assign(f, l);
    }
 
+   #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   //! <b>Effects</b>: Same as basic_string(il.begin(), il.end(), a).
+   //!
+   basic_string(std::initializer_list<value_type> il, const allocator_type& a = allocator_type())
+      : base_t(a)
+   {
+      this->priv_terminate_string();
+      this->assign(il.begin(), il.end());
+   }
+   #endif
+
    //! <b>Effects</b>: Destroys the basic_string. All used memory is deallocated.
    //!
    //! <b>Throws</b>: Nothing.
@@ -852,13 +881,30 @@ class basic_string
    }
 
    //! <b>Effects</b>: Assignment from a null-terminated c-string.
+   //!
    basic_string& operator=(const CharT* s)
    { return this->assign(s, s + Traits::length(s)); }
 
-   //! <b>Effects</b>: Assignment from character.
+   //! <b>Effects</b>: Returns *this = basic_string(1, c).
+   //!
    basic_string& operator=(CharT c)
    { return this->assign(static_cast<size_type>(1), c); }
 
+   //! <b>Effects</b>: Equivalent to return assign(sv).
+   //!
+   template<template <class, class> class BasicStringView>
+   basic_string& operator=(BasicStringView<CharT, Traits> sv)
+   { return this->assign(sv.data(), sv.size()); }
+
+   #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   //! <b>Effects</b>: Returns *this = basic_string(il);
+   //!
+   basic_string& operator=(std::initializer_list<CharT> il)
+   {
+      return this->assign(il.begin(), il.end());
+   }
+   #endif
+
    //! <b>Effects</b>: Returns a copy of the internal allocator.
    //!
    //! <b>Throws</b>: If allocator's copy constructor throws.
@@ -1112,8 +1158,8 @@ class basic_string
             size_type long_storage = this->priv_long_storage();
             size_type long_size    = this->priv_long_size();
             //Shrink from allocated buffer to the internal one, including trailing null
-            Traits::copy( container_detail::to_raw_pointer(this->priv_short_addr())
-                        , container_detail::to_raw_pointer(long_addr)
+            Traits::copy( boost::movelib::to_raw_pointer(this->priv_short_addr())
+                        , boost::movelib::to_raw_pointer(long_addr)
                         , long_size+1);
             this->is_short(true);
             this->alloc().deallocate(long_addr, long_storage);
@@ -1256,6 +1302,14 @@ class basic_string
    basic_string& operator+=(const basic_string& s)
    {  return this->append(s); }
 
+   //! <b>Effects</b>: Same as `return append(sv)`.
+   //!
+   template<template<class, class> class BasicStringView>
+   basic_string& operator+=(BasicStringView<CharT, Traits> sv)
+   {
+      return this->append(sv);
+   }
+
    //! <b>Effects</b>: Calls append(s).
    //!
    //! <b>Returns</b>: *this
@@ -1268,12 +1322,27 @@ class basic_string
    basic_string& operator+=(CharT c)
    {  this->push_back(c); return *this;   }
 
+   #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   //! <b>Effects</b>: Returns append(il)
+   //!
+   basic_string& operator+=(std::initializer_list<CharT> il)
+   {
+      return this->append(il);
+   }
+   #endif
+
    //! <b>Effects</b>: Calls append(str.data(), str.size()).
    //!
    //! <b>Returns</b>: *this
    basic_string& append(const basic_string& s)
    {  return this->append(s.begin(), s.end());  }
 
+   //! <b>Effects</b>: Same as return append(sv.data(), sv.size()).
+   //!
+   template<template<class, class> class BasicStringView>
+   basic_string& append(BasicStringView<CharT, Traits> sv)
+   {  return this->append(sv.data(), sv.size());  }
+
    //! <b>Requires</b>: pos <= str.size()
    //!
    //! <b>Effects</b>: Determines the effective length rlen of the string to append
@@ -1282,7 +1351,7 @@ class basic_string
    //! <b>Throws</b>: If memory allocation throws and out_of_range if pos > str.size()
    //!
    //! <b>Returns</b>: *this
-   basic_string& append(const basic_string& s, size_type pos, size_type n)
+   basic_string& append(const basic_string& s, size_type pos, size_type n = npos)
    {
       if (pos > s.size())
          throw_out_of_range("basic_string::append out of range position");
@@ -1326,7 +1395,17 @@ class basic_string
    basic_string& append(InputIter first, InputIter last)
    {  this->insert(this->end(), first, last);   return *this;  }
 
+   #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   //! <b>Effects</b>: Returns append(il.begin(), il.size()).
+   //!
+   basic_string& append(std::initializer_list<CharT> il)
+   {
+      return this->append(il.begin(), il.size());
+   }
+   #endif
+
    //! <b>Effects</b>: Equivalent to append(static_cast<size_type>(1), c).
+   //!
    void push_back(CharT c)
    {
       const size_type old_size = this->priv_size();
@@ -1348,6 +1427,13 @@ class basic_string
    basic_string& assign(const basic_string& s)
    {  return this->operator=(s); }
 
+   //! <b>Effects</b>: Equivalent to return assign(sv.data(), sv.size()).
+   //!
+   //! <b>Returns</b>: *this
+   template<template <class, class> class BasicStringView>
+   basic_string& assign(BasicStringView<CharT, Traits> sv)
+   {  return this->operator=(sv); }
+
    //! <b>Effects</b>: The function replaces the string controlled by *this
    //!    with a string of length str.size() whose elements are a copy of the string
    //!   controlled by str. Leaves str in a valid but unspecified state.
@@ -1406,7 +1492,7 @@ class basic_string
     {
        size_type n = static_cast<size_type>(last - first);
        this->reserve(n);
-       CharT* ptr = container_detail::to_raw_pointer(this->priv_addr());
+       CharT* ptr = boost::movelib::to_raw_pointer(this->priv_addr());
        Traits::copy(ptr, first, n);
        this->priv_construct_null(ptr + n);
        this->priv_size(n);
@@ -1425,7 +1511,7 @@ class basic_string
    {
       size_type cur = 0;
       const pointer addr = this->priv_addr();
-      CharT *ptr = container_detail::to_raw_pointer(addr);
+      CharT *ptr = boost::movelib::to_raw_pointer(addr);
       const size_type old_size = this->priv_size();
       while (first != last && cur != old_size) {
          Traits::assign(*ptr, *first);
@@ -1440,6 +1526,15 @@ class basic_string
       return *this;
    }
 
+   #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   //! <b>Effects</b>: Returns assign(il.begin(), il.size()).
+   //!
+   basic_string& assign(std::initializer_list<CharT> il)
+   {
+      return this->assign(il.begin(), il.size());
+   }
+   #endif
+
    //! <b>Requires</b>: pos <= size().
    //!
    //! <b>Effects</b>: Calls insert(pos, str.data(), str.size()).
@@ -1466,7 +1561,7 @@ class basic_string
    //! <b>Throws</b>: If memory allocation throws or out_of_range if pos1 > size() or pos2 > str.size().
    //!
    //! <b>Returns</b>: *this
-   basic_string& insert(size_type pos1, const basic_string& s, size_type pos2, size_type n)
+   basic_string& insert(size_type pos1, const basic_string& s, size_type pos2, size_type n = npos)
    {
       const size_type sz = this->size();
       const size_type str_size = s.size();
@@ -1475,7 +1570,7 @@ class basic_string
       size_type len = container_detail::min_value(n, str_size - pos2);
       if (sz > this->max_size() - len)
          throw_length_error("basic_string::insert max_size() exceeded");
-      const CharT *beg_ptr = container_detail::to_raw_pointer(s.begin()) + pos2;
+      const CharT *beg_ptr = boost::movelib::to_raw_pointer(s.begin()) + pos2;
       const CharT *end_ptr = beg_ptr + len;
       this->insert(this->priv_addr() + pos1, beg_ptr, end_ptr);
       return *this;
@@ -1537,6 +1632,12 @@ class basic_string
       return *this;
    }
 
+   //! <b>Effects</b>: Same as `return insert(pos, sv.data(), sv.size())`.
+   //!
+   template<template<class, class> class BasicStringView>
+   basic_string& insert(size_type pos, BasicStringView<CharT, Traits> sv)
+   {  return this->insert(pos, sv.data(), sv.size());  }
+
    //! <b>Requires</b>: p is a valid iterator on *this.
    //!
    //! <b>Effects</b>: inserts a copy of c before the character referred to by p.
@@ -1549,7 +1650,6 @@ class basic_string
       return this->priv_addr() + new_offset;
    }
 
-
    //! <b>Requires</b>: p is a valid iterator on *this.
    //!
    //! <b>Effects</b>: Inserts n copies of c before the character referred to by p.
@@ -1630,10 +1730,10 @@ class basic_string
                                        pointer_past_last, pointer_past_last);
 
                this->priv_size(old_size+n);
-               Traits::move(const_cast<CharT*>(container_detail::to_raw_pointer(p + n)),
-                           container_detail::to_raw_pointer(p),
+               Traits::move(const_cast<CharT*>(boost::movelib::to_raw_pointer(p + n)),
+                           boost::movelib::to_raw_pointer(p),
                            (elems_after - n) + 1);
-               this->priv_copy(first, last, const_cast<CharT*>(container_detail::to_raw_pointer(p)));
+               this->priv_copy(first, last, const_cast<CharT*>(boost::movelib::to_raw_pointer(p)));
             }
             else {
                ForwardIter mid = first;
@@ -1646,7 +1746,7 @@ class basic_string
                   (p, const_iterator(old_start + old_length + 1),
                   old_start + newer_size);
                this->priv_size(newer_size + elems_after);
-               this->priv_copy(first, mid, const_cast<CharT*>(container_detail::to_raw_pointer(p)));
+               this->priv_copy(first, mid, const_cast<CharT*>(boost::movelib::to_raw_pointer(p)));
             }
          }
          else{
@@ -1673,9 +1773,9 @@ class basic_string
             else{
                //value_type is POD, so backwards expansion is much easier
                //than with vector<T>
-               value_type * const oldbuf     = container_detail::to_raw_pointer(old_start);
-               value_type * const newbuf     = container_detail::to_raw_pointer(new_start);
-               const value_type *const pos   = container_detail::to_raw_pointer(p);
+               value_type * const oldbuf     = boost::movelib::to_raw_pointer(old_start);
+               value_type * const newbuf     = boost::movelib::to_raw_pointer(new_start);
+               const value_type *const pos   = boost::movelib::to_raw_pointer(p);
                const size_type before  = pos - oldbuf;
 
                //First move old data
@@ -1695,6 +1795,17 @@ class basic_string
    }
    #endif
 
+   #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   //! <b>Effects</b>: As if by insert(p, il.begin(), il.end()).
+   //!
+   //! <b>Returns</b>: An iterator which refers to the copy of the first inserted
+   //!   character, or p if i1 is empty.
+   iterator insert(const_iterator p, std::initializer_list<CharT> il)
+   {
+      return this->insert(p, il.begin(), il.end());
+   }
+   #endif
+
    //! <b>Effects</b>: Removes the last element from the container.
    //!
    //! <b>Throws</b>: Nothing.
@@ -1736,10 +1847,10 @@ class basic_string
    iterator erase(const_iterator p) BOOST_NOEXCEPT_OR_NOTHROW
    {
       // The move includes the terminating null.
-      CharT * const ptr = const_cast<CharT*>(container_detail::to_raw_pointer(p));
+      CharT * const ptr = const_cast<CharT*>(boost::movelib::to_raw_pointer(p));
       const size_type old_size = this->priv_size();
       Traits::move(ptr,
-                   container_detail::to_raw_pointer(p + 1),
+                   boost::movelib::to_raw_pointer(p + 1),
                    old_size - (p - this->priv_addr()));
       this->priv_size(old_size-1);
       return iterator(ptr);
@@ -1755,12 +1866,12 @@ class basic_string
    //!   the other elements being erased. If no such element exists, end() is returned.
    iterator erase(const_iterator first, const_iterator last) BOOST_NOEXCEPT_OR_NOTHROW
    {
-      CharT * f = const_cast<CharT*>(container_detail::to_raw_pointer(first));
+      CharT * f = const_cast<CharT*>(boost::movelib::to_raw_pointer(first));
       if (first != last) { // The move includes the terminating null.
          const size_type num_erased = last - first;
          const size_type old_size = this->priv_size();
          Traits::move(f,
-                      container_detail::to_raw_pointer(last),
+                      boost::movelib::to_raw_pointer(last),
                       (old_size + 1)-(last - this->priv_addr()));
          const size_type new_length = old_size - num_erased;
          this->priv_size(new_length);
@@ -1801,6 +1912,14 @@ class basic_string
                           , str.begin(), str.end());
    }
 
+   //! <b>Effects</b>: Calls `return replace(pos1, n1, sv.data(), sv.size());`.
+   //!
+   template<template<class, class> class BasicStringView>
+   basic_string& replace(size_type pos1, size_type n1, BasicStringView<CharT, Traits> sv)
+   {
+      return this->replace(pos1, n1, sv.data(), sv.size());
+   }
+
    //! <b>Requires</b>: pos1 <= size() and pos2 <= str.size().
    //!
    //! <b>Effects</b>: Determines the effective length rlen of the string to be
@@ -1811,18 +1930,26 @@ class basic_string
    //!
    //! <b>Returns</b>: *this
    basic_string& replace(size_type pos1, size_type n1,
-                         const basic_string& str, size_type pos2, size_type n2)
+                         const basic_string& str, size_type pos2, size_type n2 = npos)
    {
-      if (pos1 > this->size() || pos2 > str.size())
+      if (pos2 > str.size())
          throw_out_of_range("basic_string::replace out of range position");
-      const size_type len1 = container_detail::min_value(n1, this->size() - pos1);
-      const size_type len2 = container_detail::min_value(n2, str.size() - pos2);
-      if (this->size() - len1 >= this->max_size() - len2)
-         throw_length_error("basic_string::replace max_size() exceeded");
-      const pointer addr    = this->priv_addr();
-      const pointer straddr = str.priv_addr();
-      return this->replace(addr + pos1, addr + pos1 + len1,
-                     straddr + pos2, straddr + pos2 + len2);
+      return this->replace(pos1, n1, str.data()+pos2, container_detail::min_value(n2, str.size() - pos2));
+   }
+
+   //! <b>Throws</b>: out_of_range if pos1 > size() or pos2 > sv.size().
+   //!
+   //! <b>Effects</b>: Determines the effective length rlen of the string to be inserted as the
+   //!   smaller of n2 and sv.size() - pos2 and calls `replace(pos1, n1, sv.data() + pos2, rlen)`.
+   //!
+   //! <b>Returns</b>: *this.
+   template<template<class, class> class BasicStringView>
+   basic_string& replace(size_type pos1, size_type n1, BasicStringView<CharT, Traits> sv,
+                         size_type pos2, size_type n2 = npos)
+   {
+      if (pos2 > sv.size())
+         throw_out_of_range("basic_string::replace out of range position");
+      return this->replace(pos1, n1, sv.data()+pos2, container_detail::min_value(n2, sv.size() - pos2));
    }
 
    //! <b>Requires</b>: pos1 <= size() and s points to an array of at least n2 elements of CharT.
@@ -1836,7 +1963,7 @@ class basic_string
    //!   the original string controlled by *this beginning at position pos + xlen.
    //!
    //! <b>Throws</b>: if memory allocation throws, out_of_range if pos1 > size() or length_error
-   //!   if the length of the  resulting string would exceed max_size()
+   //!   if the length of the resulting string would exceed max_size()
    //!
    //! <b>Returns</b>: *this
    basic_string& replace(size_type pos1, size_type n1, const CharT* s, size_type n2)
@@ -1844,10 +1971,11 @@ class basic_string
       if (pos1 > this->size())
          throw_out_of_range("basic_string::replace out of range position");
       const size_type len = container_detail::min_value(n1, this->size() - pos1);
-      if (n2 > this->max_size() || size() - len >= this->max_size() - n2)
+      const size_type max_size = this->max_size();
+      if (n2 > max_size || (this->size() - len) >= (max_size - n2))
          throw_length_error("basic_string::replace max_size() exceeded");
-      const pointer addr    = this->priv_addr();
-      return this->replace(addr + pos1, addr + pos1 + len, s, s + n2);
+      const pointer addr = this->priv_addr() + pos1;
+      return this->replace(addr, addr + len, s, s + n2);
    }
 
    //! <b>Requires</b>: pos1 <= size() and s points to an array of at least n2 elements of CharT.
@@ -1866,15 +1994,7 @@ class basic_string
    //! <b>Returns</b>: *this
    basic_string& replace(size_type pos, size_type n1, const CharT* s)
    {
-      if (pos > this->size())
-         throw_out_of_range("basic_string::replace out of range position");
-      const size_type len = container_detail::min_value(n1, this->size() - pos);
-      const size_type n2 = Traits::length(s);
-      if (n2 > this->max_size() || this->size() - len >= this->max_size() - n2)
-         throw_length_error("basic_string::replace max_size() exceeded");
-      const pointer addr    = this->priv_addr();
-      return this->replace(addr + pos, addr + pos + len,
-                     s, s + Traits::length(s));
+      return this->replace(pos, n1, s, Traits::length(s));
    }
 
    //! <b>Requires</b>: pos1 <= size().
@@ -1904,7 +2024,7 @@ class basic_string
    //!
    //! <b>Returns</b>: *this
    basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str)
-   { return this->replace(i1, i2, str.begin(), str.end()); }
+   { return this->replace(i1, i2, str.data(), str.data()+str.size()); }
 
    //! <b>Requires</b>: [begin(),i1) and [i1,i2) are valid ranges and
    //!   s points to an array of at least n elements
@@ -1939,11 +2059,11 @@ class basic_string
    {
       const size_type len = static_cast<size_type>(i2 - i1);
       if (len >= n) {
-         Traits::assign(const_cast<CharT*>(container_detail::to_raw_pointer(i1)), n, c);
+         Traits::assign(const_cast<CharT*>(boost::movelib::to_raw_pointer(i1)), n, c);
          erase(i1 + n, i2);
       }
       else {
-         Traits::assign(const_cast<CharT*>(container_detail::to_raw_pointer(i1)), len, c);
+         Traits::assign(const_cast<CharT*>(boost::movelib::to_raw_pointer(i1)), len, c);
          insert(i2, n - len, c);
       }
       return *this;
@@ -1968,7 +2088,7 @@ class basic_string
       )
    {
       for ( ; i1 != i2 && j1 != j2; ++i1, ++j1){
-         Traits::assign(*const_cast<CharT*>(container_detail::to_raw_pointer(i1)), *j1);
+         Traits::assign(*const_cast<CharT*>(boost::movelib::to_raw_pointer(i1)), *j1);
       }
 
       if (j1 == j2)
@@ -1991,19 +2111,45 @@ class basic_string
       difference_type n = boost::container::iterator_distance(j1, j2);
       const difference_type len = i2 - i1;
       if (len >= n) {
-         this->priv_copy(j1, j2, const_cast<CharT*>(container_detail::to_raw_pointer(i1)));
+         this->priv_copy(j1, j2, const_cast<CharT*>(boost::movelib::to_raw_pointer(i1)));
          this->erase(i1 + n, i2);
       }
       else {
          ForwardIter m = j1;
          boost::container::iterator_advance(m, len);
-         this->priv_copy(j1, m, const_cast<CharT*>(container_detail::to_raw_pointer(i1)));
+         this->priv_copy(j1, m, const_cast<CharT*>(boost::movelib::to_raw_pointer(i1)));
          this->insert(i2, m, j2);
       }
       return *this;
    }
    #endif
 
+   //! <b>Requires</b>: [begin(), i1) and [i1, i2) are valid ranges.
+   //!
+   //! <b>Effects</b>: Calls `replace(i1 - begin(), i2 - i1, sv).`.
+   //!
+   //! <b>Returns</b>: *this.
+   template<template <class, class> class BasicStringView>
+   basic_string& replace(const_iterator i1, const_iterator i2, BasicStringView<CharT, Traits> sv)
+   {
+      return this->replace( static_cast<size_type>(i1 - this->cbegin())
+                          , static_cast<size_type>(i2 - i1), sv);
+   }
+
+   #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+   //! <b>Requires</b>: [begin(), i1) and [i1, i2) are valid ranges.
+   //!
+   //! <b>Effects</b>: Calls replace(i1 - begin(), i2 - i1, il.begin(), il.size()).
+   //!
+   //! <b>Returns</b>: *this.
+   basic_string& replace(const_iterator i1, const_iterator i2, std::initializer_list<CharT> il)
+   {
+      return this->replace( static_cast<size_type>(i1 - this->cbegin())
+                          , static_cast<size_type>(i2 - i1)
+                          , il.begin(), il.size());
+   }
+   #endif
+
    //! <b>Requires</b>: pos <= size()
    //!
    //! <b>Effects</b>: Determines the effective length rlen of the string to copy as the
@@ -2020,7 +2166,7 @@ class basic_string
       if (pos > this->size())
          throw_out_of_range("basic_string::copy out of range position");
       const size_type len = container_detail::min_value(n, this->size() - pos);
-      Traits::copy(s, container_detail::to_raw_pointer(this->priv_addr() + pos), len);
+      Traits::copy(s, boost::movelib::to_raw_pointer(this->priv_addr() + pos), len);
       return len;
    }
 
@@ -2049,7 +2195,7 @@ class basic_string
    //!
    //! <b>Complexity</b>: constant time.
    const CharT* c_str() const BOOST_NOEXCEPT_OR_NOTHROW
-   {  return container_detail::to_raw_pointer(this->priv_addr()); }
+   {  return boost::movelib::to_raw_pointer(this->priv_addr()); }
 
    //! <b>Requires</b>: The program shall not alter any of the values stored in the character array.
    //!
@@ -2057,7 +2203,32 @@ class basic_string
    //!
    //! <b>Complexity</b>: constant time.
    const CharT* data()  const BOOST_NOEXCEPT_OR_NOTHROW
-   {  return container_detail::to_raw_pointer(this->priv_addr()); }
+   {  return boost::movelib::to_raw_pointer(this->priv_addr()); }
+
+   //! <b>Returns</b>: A pointer p such that p + i == &operator[](i) for each i in [0,size()].
+   //!
+   //! <b>Complexity</b>: constant time.
+   CharT* data()  BOOST_NOEXCEPT_OR_NOTHROW
+   {  return boost::movelib::to_raw_pointer(this->priv_addr()); }
+
+   #ifndef BOOST_CONTAINER_TEMPLATED_CONVERSION_OPERATOR_BROKEN
+   //! <b>Returns</b>: a string_view to the characters in the string.
+   //!
+   //! <b>Complexity</b>: constant time.
+   template<template <class, class> class BasicStringView>
+   operator BasicStringView<CharT, Traits>() const BOOST_NOEXCEPT_OR_NOTHROW
+   { return this->to_view< BasicStringView<CharT, Traits> >(); }
+   #endif
+
+   //! <b>Returns</b>: a string_view to the characters in the string.
+   //!
+   //! <b>Complexity</b>: constant time.
+   //!
+   //! <b>Note</b>: This function is available to write portable code for compilers
+   //!   that don't support templated conversion operators.
+   template<class BasicStringView>
+   BasicStringView to_view() const BOOST_NOEXCEPT_OR_NOTHROW
+   { return BasicStringView(this->data(), this->size()); }
 
    //////////////////////////////////////////////
    //
@@ -2066,7 +2237,8 @@ class basic_string
    //////////////////////////////////////////////
 
    //! <b>Effects</b>: Determines the lowest position xpos, if possible, such that both
-   //!   of the following conditions obtain: 19 pos <= xpos and xpos + str.size() <= size();
+   //!   of the following conditions hold:
+   //!   1) pos <= xpos and xpos + str.size() <= size();
    //!   2) traits::eq(at(xpos+I), str.at(I)) for all elements I of the string controlled by str.
    //!
    //! <b>Throws</b>: Nothing
@@ -2075,6 +2247,18 @@ class basic_string
    size_type find(const basic_string& s, size_type pos = 0) const
    { return find(s.c_str(), pos, s.size()); }
 
+   //! <b>Effects</b>: Determines the lowest position xpos, if possible, such that both
+   //!   of the following conditions hold:
+   //!   1) pos <= xpos and xpos + sv.size() <= size();
+   //!   2) traits::eq(at(xpos+I), sv.at(I)) for all elements I of the string controlled by sv.
+   //!
+   //! <b>Throws</b>: Nothing
+   //!
+   //! <b>Returns</b>: xpos if the function can determine such a value for xpos. Otherwise, returns npos.
+   template<template <class, class> class BasicStringView>
+   size_type find(BasicStringView<CharT, Traits> sv, size_type pos = 0) const
+   { return find(sv.data(), pos, sv.size()); }
+
    //! <b>Requires</b>: s points to an array of at least n elements of CharT.
    //!
    //! <b>Throws</b>: Nothing
@@ -2088,8 +2272,8 @@ class basic_string
          const pointer addr = this->priv_addr();
          pointer finish = addr + this->priv_size();
          const const_iterator result =
-            std::search(container_detail::to_raw_pointer(addr + pos),
-                   container_detail::to_raw_pointer(finish),
+            boost::container::search(boost::movelib::to_raw_pointer(addr + pos),
+                   boost::movelib::to_raw_pointer(finish),
                    s, s + n, Eq_traits<Traits>());
          return result != finish ? result - begin() : npos;
       }
@@ -2115,8 +2299,8 @@ class basic_string
          const pointer addr    = this->priv_addr();
          pointer finish = addr + sz;
          const const_iterator result =
-            std::find_if(addr + pos, finish,
-                  std::bind2nd(Eq_traits<Traits>(), c));
+            boost::container::find_if(addr + pos, finish,
+                  boost::container::bind2nd(Eq_traits<Traits>(), c));
          return result != finish ? result - begin() : npos;
       }
    }
@@ -2132,6 +2316,18 @@ class basic_string
    size_type rfind(const basic_string& str, size_type pos = npos) const
       { return rfind(str.c_str(), pos, str.size()); }
 
+   //! <b>Effects</b>: Determines the highest position xpos, if possible, such
+   //!   that both of the following conditions obtain:
+   //!   a) xpos <= pos and xpos + sv.size() <= size();
+   //!   b) traits::eq(at(xpos+I), sv.at(I)) for all elements I of the string controlled by sv.
+   //!
+   //! <b>Throws</b>: Nothing
+   //!
+   //! <b>Returns</b>: xpos if the function can determine such a value for xpos. Otherwise, returns npos.
+   template<template <class, class> class BasicStringView>
+   size_type rfind(BasicStringView<CharT, Traits> sv, size_type pos = npos) const
+      { return rfind(sv.data(), pos, sv.size()); }
+
    //! <b>Requires</b>: s points to an array of at least n elements of CharT.
    //!
    //! <b>Throws</b>: Nothing
@@ -2175,8 +2371,8 @@ class basic_string
       else {
          const const_iterator last = begin() + container_detail::min_value(len - 1, pos) + 1;
          const_reverse_iterator rresult =
-            std::find_if(const_reverse_iterator(last), rend(),
-                  std::bind2nd(Eq_traits<Traits>(), c));
+            boost::container::find_if(const_reverse_iterator(last), rend(),
+                  boost::container::bind2nd(Eq_traits<Traits>(), c));
          return rresult != rend() ? (rresult.base() - 1) - begin() : npos;
       }
    }
@@ -2188,8 +2384,19 @@ class basic_string
    //! <b>Throws</b>: Nothing
    //!
    //! <b>Returns</b>: xpos if the function can determine such a value for xpos. Otherwise, returns npos.
-   size_type find_first_of(const basic_string& s, size_type pos = 0) const
-      { return find_first_of(s.c_str(), pos, s.size()); }
+   size_type find_first_of(const basic_string& str, size_type pos = 0) const
+      { return this->find_first_of(str.c_str(), pos, str.size()); }
+
+   //! <b>Effects</b>: Determines the lowest position xpos, if possible, such that both of the
+   //!   following conditions obtain: a) pos <= xpos and xpos < size();
+   //!   b) traits::eq(at(xpos), sv.at(I)) for some element I of the string controlled by sv.
+   //!
+   //! <b>Throws</b>: Nothing
+   //!
+   //! <b>Returns</b>: xpos if the function can determine such a value for xpos. Otherwise, returns npos.
+   template<template <class, class> class BasicStringView>
+   size_type find_first_of(BasicStringView<CharT, Traits> sv, size_type pos = 0) const
+      { return this->find_first_of(sv.data(), pos, sv.size()); }
 
    //! <b>Requires</b>: s points to an array of at least n elements of CharT.
    //!
@@ -2204,7 +2411,7 @@ class basic_string
       else {
          const pointer addr    = this->priv_addr();
          pointer finish = addr + sz;
-         const_iterator result = std::find_first_of
+         const_iterator result = boost::container::find_first_of
             (addr + pos, finish, s, s + n, Eq_traits<Traits>());
          return result != finish ? result - this->begin() : npos;
       }
@@ -2216,7 +2423,7 @@ class basic_string
    //!
    //! <b>Returns</b>: find_first_of(basic_string(s), pos).
    size_type find_first_of(const CharT* s, size_type pos = 0) const
-      { return find_first_of(s, pos, Traits::length(s)); }
+      { return this->find_first_of(s, pos, Traits::length(s)); }
 
    //! <b>Requires</b>: s points to an array of at least traits::length(s) + 1 elements of CharT.
    //!
@@ -2224,7 +2431,7 @@ class basic_string
    //!
    //! <b>Returns</b>: find_first_of(basic_string<CharT,traits,Allocator>(1,c), pos).
    size_type find_first_of(CharT c, size_type pos = 0) const
-    { return find(c, pos); }
+    { return this->find(c, pos); }
 
    //! <b>Effects</b>: Determines the highest position xpos, if possible, such that both of
    //!   the following conditions obtain: a) xpos <= pos and xpos < size(); b)
@@ -2234,7 +2441,18 @@ class basic_string
    //!
    //! <b>Returns</b>: xpos if the function can determine such a value for xpos. Otherwise, returns npos.
    size_type find_last_of(const basic_string& str, size_type pos = npos) const
-      { return find_last_of(str.c_str(), pos, str.size()); }
+      { return this->find_last_of(str.c_str(), pos, str.size()); }
+
+   //! <b>Effects</b>: Determines the highest position xpos, if possible, such that both of
+   //!   the following conditions obtain: a) xpos <= pos and xpos < size(); b)
+   //!   traits::eq(at(xpos), str.at(I)) for some element I of the string controlled by str.
+   //!
+   //! <b>Throws</b>: Nothing
+   //!
+   //! <b>Returns</b>: xpos if the function can determine such a value for xpos. Otherwise, returns npos.
+   template<template <class, class> class BasicStringView>
+   size_type find_last_of(BasicStringView<CharT, Traits> sv, size_type pos = npos) const
+      { return this->find_last_of(sv.data(), pos, sv.size()); }
 
    //! <b>Requires</b>: s points to an array of at least n elements of CharT.
    //!
@@ -2251,7 +2469,7 @@ class basic_string
          const pointer addr    = this->priv_addr();
          const const_iterator last = addr + container_detail::min_value(len - 1, pos) + 1;
          const const_reverse_iterator rresult =
-            std::find_first_of(const_reverse_iterator(last), rend(),
+            boost::container::find_first_of(const_reverse_iterator(last), rend(),
                                s, s + n, Eq_traits<Traits>());
          return rresult != rend() ? (rresult.base() - 1) - addr : npos;
       }
@@ -2282,6 +2500,18 @@ class basic_string
    size_type find_first_not_of(const basic_string& str, size_type pos = 0) const
       { return find_first_not_of(str.c_str(), pos, str.size()); }
 
+   //! <b>Effects</b>: Determines the lowest position xpos, if possible, such that
+   //!   both of the following conditions obtain:
+   //!   a) pos <= xpos and xpos < size(); b) traits::eq(at(xpos), sv.at(I)) for no
+   //!   element I of the string controlled by sv.
+   //!
+   //! <b>Throws</b>: Nothing
+   //!
+   //! <b>Returns</b>: xpos if the function can determine such a value for xpos. Otherwise, returns npos.
+   template<template <class, class> class BasicStringView>
+   size_type find_first_not_of(BasicStringView<CharT, Traits> sv, size_type pos = 0) const
+      { return find_first_not_of(sv.data(), pos, sv.size()); }
+
    //! <b>Requires</b>: s points to an array of at least traits::length(s) + 1 elements of CharT.
    //!
    //! <b>Throws</b>: Nothing
@@ -2294,7 +2524,7 @@ class basic_string
       else {
          const pointer addr   = this->priv_addr();
          const pointer finish = addr + this->priv_size();
-         const const_iterator result = std::find_if
+         const const_iterator result = boost::container::find_if
             (addr + pos, finish, Not_within_traits<Traits>(s, s + n));
          return result != finish ? result - addr : npos;
       }
@@ -2319,8 +2549,8 @@ class basic_string
          const pointer addr   = this->priv_addr();
          const pointer finish = addr + this->priv_size();
          const const_iterator result
-            = std::find_if(addr + pos, finish,
-                     std::not1(std::bind2nd(Eq_traits<Traits>(), c)));
+            = boost::container::find_if(addr + pos, finish,
+                     boost::container::not1(boost::container::bind2nd(Eq_traits<Traits>(), c)));
          return result != finish ? result - begin() : npos;
       }
    }
@@ -2335,6 +2565,17 @@ class basic_string
    size_type find_last_not_of(const basic_string& str, size_type pos = npos) const
       { return find_last_not_of(str.c_str(), pos, str.size()); }
 
+   //! <b>Effects</b>: Determines the highest position xpos, if possible, such that
+   //!   both of the following conditions obtain: a) xpos <= pos and xpos < size();
+   //!   b) traits::eq(at(xpos), sv.at(I)) for no element I of the string controlled by sv.
+   //!
+   //! <b>Throws</b>: Nothing
+   //!
+   //! <b>Returns</b>: xpos if the function can determine such a value for xpos. Otherwise, returns npos.
+   template<template <class, class> class BasicStringView>
+   size_type find_last_not_of(BasicStringView<CharT, Traits> sv, size_type pos = npos) const
+      { return find_last_not_of(sv.data(), pos, sv.size()); }
+
    //! <b>Requires</b>: s points to an array of at least n elements of CharT.
    //!
    //! <b>Throws</b>: Nothing
@@ -2349,7 +2590,7 @@ class basic_string
       else {
          const const_iterator last = begin() + container_detail::min_value(len - 1, pos) + 1;
          const const_reverse_iterator rresult =
-            std::find_if(const_reverse_iterator(last), rend(),
+            boost::container::find_if(const_reverse_iterator(last), rend(),
                     Not_within_traits<Traits>(s, s + n));
          return rresult != rend() ? (rresult.base() - 1) - begin() : npos;
       }
@@ -2375,8 +2616,8 @@ class basic_string
       else {
          const const_iterator last = begin() + container_detail::min_value(len - 1, pos) + 1;
          const const_reverse_iterator rresult =
-            std::find_if(const_reverse_iterator(last), rend(),
-                  std::not1(std::bind2nd(Eq_traits<Traits>(), c)));
+            boost::container::find_if(const_reverse_iterator(last), rend(),
+                  boost::container::not1(boost::container::bind2nd(Eq_traits<Traits>(), c)));
          return rresult != rend() ? (rresult.base() - 1) - begin() : npos;
       }
    }
@@ -2398,7 +2639,7 @@ class basic_string
                           addr + pos + container_detail::min_value(n, size() - pos), this->alloc());
    }
 
-   //! <b>Effects</b>: Determines the effective length rlen of the string to copy as
+   //! <b>Effects</b>: Determines the effective length rlen of the string to compare as
    //!   the smaller of size() and str.size(). The function then compares the two strings by
    //!   calling traits::compare(data(), str.data(), rlen).
    //!
@@ -2414,10 +2655,21 @@ class basic_string
       return s_compare(addr, addr + this->priv_size(), str_addr, str_addr + str.priv_size());
    }
 
+   //! <b>Throws</b>: Nothing
+   //!
+   //! <b>Returns</b>: compare(basic_string(sv)).
+   template<template <class, class> class BasicStringView>
+   int compare(BasicStringView<CharT,Traits> sv) const
+   {
+      const pointer addr = this->priv_addr();
+      return s_compare(addr, addr + this->priv_size(), sv.data(), sv.data() + sv.size());
+   }
+
    //! <b>Requires</b>: pos1 <= size()
    //!
-   //! <b>Effects</b>: Determines the effective length rlen of the string to copy as
-   //!   the smaller of
+   //! <b>Effects</b>: Determines the effective length rlen of the string to compare as
+   //!   the smaller of (this->size() - pos1), n1 and str.size(). The function then compares the two strings by
+   //!   calling traits::compare(data()+pos1, str.data(), rlen).
    //!
    //! <b>Throws</b>: out_of_range if pos1 > size()
    //!
@@ -2433,6 +2685,22 @@ class basic_string
                         str_addr, str_addr + str.priv_size());
    }
 
+   //! <b>Requires</b>: pos1 <= size()
+   //!
+   //! <b>Throws</b>: out_of_range if pos1 > size()
+   //!
+   //! <b>Returns</b>:basic_string(*this,pos1,n1).compare(sv).
+   template<template <class, class> class BasicStringView>
+   int compare(size_type pos1, size_type n1, BasicStringView<CharT,Traits> sv) const
+   {
+      if (pos1 > this->size())
+         throw_out_of_range("basic_string::compare out of range position");
+      const pointer addr    = this->priv_addr() + pos1;
+      const CharT* str_addr = sv.data();
+      return s_compare(addr, addr + container_detail::min_value(n1, this->size() - pos1),
+                       str_addr, str_addr + sv.size());
+   }
+
    //! <b>Requires</b>: pos1 <= size() and pos2 <= str.size()
    //!
    //! <b>Effects</b>: Determines the effective length rlen of the string to copy as
@@ -2441,16 +2709,33 @@ class basic_string
    //! <b>Throws</b>: out_of_range if pos1 > size() or pos2 > str.size()
    //!
    //! <b>Returns</b>: basic_string(*this, pos1, n1).compare(basic_string(str, pos2, n2)).
-   int compare(size_type pos1, size_type n1, const basic_string& str, size_type pos2, size_type n2) const
+   int compare(size_type pos1, size_type n1, const basic_string& str, size_type pos2, size_type n2 = npos) const
    {
       if (pos1 > this->size() || pos2 > str.size())
          throw_out_of_range("basic_string::compare out of range position");
-      const pointer addr     = this->priv_addr();
-      const pointer str_addr = str.priv_addr();
-      return s_compare(addr + pos1,
-                        addr + pos1 + container_detail::min_value(n1, this->size() - pos1),
-                        str_addr + pos2,
-                        str_addr + pos2 + container_detail::min_value(n2, str.size() - pos2));
+      const pointer addr     = this->priv_addr() + pos1;
+      const pointer str_addr = str.priv_addr() + pos2;
+      return s_compare(addr, addr + container_detail::min_value(n1, this->size() - pos1),
+                        str_addr, str_addr + container_detail::min_value(n2, str.size() - pos2));
+   }
+
+   //! <b>Requires</b>: pos1 <= size() and pos2 <= str.size()
+   //!
+   //! <b>Effects</b>: Determines the effective length rlen of the string to copy as
+   //!   the smaller of
+   //!
+   //! <b>Throws</b>: out_of_range if pos1 > size() or pos2 > sv.size()
+   //!
+   //! <b>Returns</b>: basic_string(*this, pos1, n1).compare(BasicStringView<CharT, Traits>(sv, pos2, n2)).
+   template<template <class, class> class BasicStringView>
+   int compare(size_type pos1, size_type n1, BasicStringView<CharT,Traits> sv, size_type pos2, size_type n2) const
+   {
+      if (pos1 > this->size() || pos2 > sv.size())
+         throw_out_of_range("basic_string::compare out of range position");
+      const pointer addr     = this->priv_addr() + pos1;
+      const CharT * str_addr = sv.data() + pos2;
+      return s_compare(addr, addr + container_detail::min_value(n1, this->size() - pos1),
+                       str_addr, str_addr + container_detail::min_value(n2, sv.size() - pos2));
    }
 
    //! <b>Throws</b>: Nothing
@@ -2462,7 +2747,6 @@ class basic_string
       return s_compare(addr, addr + this->priv_size(), s, s + Traits::length(s));
    }
 
-
    //! <b>Requires</b>: pos1 > size() and s points to an array of at least n2 elements of CharT.
    //!
    //! <b>Throws</b>: out_of_range if pos1 > size()
@@ -2515,13 +2799,13 @@ class basic_string
       }
    }
 
-   static int s_compare(const_pointer f1, const_pointer l1,
-                        const_pointer f2, const_pointer l2)
+   template<class It1, class It2>
+   static int s_compare(It1 f1, It1 l1, It2 f2, It2 l2)
    {
       const difference_type n1 = l1 - f1;
       const difference_type n2 = l2 - f2;
-      const int cmp = Traits::compare(container_detail::to_raw_pointer(f1),
-                                      container_detail::to_raw_pointer(f2),
+      const int cmp = Traits::compare(boost::movelib::to_raw_pointer(f1),
+                                      boost::movelib::to_raw_pointer(f2),
                                       container_detail::min_value(n1, n2));
       return cmp != 0 ? cmp : (n1 < n2 ? -1 : (n1 > n2 ? 1 : 0));
    }
@@ -2542,8 +2826,8 @@ class basic_string
          real_cap = long_size+1;
          const pointer ret = this->allocation_command(allocate_new, long_size+1, real_cap, reuse);
          //Copy and update
-         Traits::copy( container_detail::to_raw_pointer(ret)
-                     , container_detail::to_raw_pointer(this->priv_long_addr())
+         Traits::copy( boost::movelib::to_raw_pointer(ret)
+                     , boost::movelib::to_raw_pointer(this->priv_long_addr())
                      , long_size+1);
          this->priv_long_addr(ret);
          this->priv_storage(real_cap);
@@ -2753,8 +3037,7 @@ template <class CharT, class Traits, class Allocator> inline
 
 template <class CharT, class Traits, class Allocator>
 inline bool
-operator==(const basic_string<CharT,Traits,Allocator>& x,
-           const basic_string<CharT,Traits,Allocator>& y)
+operator==(const basic_string<CharT,Traits,Allocator>& x, const basic_string<CharT,Traits,Allocator>& y)
 {
    return x.size() == y.size() &&
           Traits::compare(x.data(), y.data(), x.size()) == 0;
@@ -2776,10 +3059,25 @@ operator==(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
    return x.size() == n && Traits::compare(x.data(), s, n) == 0;
 }
 
+template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
+inline bool
+operator==( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allocator>& y)
+{
+   return x.size() == y.size() &&
+          Traits::compare(x.data(), y.data(), x.size()) == 0;
+}
+
+template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
+inline bool
+operator==( const basic_string<CharT,Traits,Allocator>& x, BasicStringView<CharT,Traits> y)
+{
+   return x.size() == y.size() &&
+          Traits::compare(x.data(), y.data(), x.size()) == 0;
+}
+
 template <class CharT, class Traits, class Allocator>
 inline bool
-operator!=(const basic_string<CharT,Traits,Allocator>& x,
-           const basic_string<CharT,Traits,Allocator>& y)
+operator!=(const basic_string<CharT,Traits,Allocator>& x, const basic_string<CharT,Traits,Allocator>& y)
    {  return !(x == y);  }
 
 template <class CharT, class Traits, class Allocator>
@@ -2793,15 +3091,22 @@ operator!=(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
    {  return !(x == s);   }
 
 
-// Operator< (and also >, <=, and >=).
+template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
+inline bool
+operator!=( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allocator>& y)
+   {  return !(x == y);  }
 
+template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
+inline bool
+operator!=( const basic_string<CharT,Traits,Allocator>& x, BasicStringView<CharT,Traits> y)
+   {  return !(x == y);  }
+
+// Operator< (and also >, <=, and >=).
 template <class CharT, class Traits, class Allocator>
 inline bool
 operator<(const basic_string<CharT,Traits,Allocator>& x, const basic_string<CharT,Traits,Allocator>& y)
 {
    return x.compare(y) < 0;
-//   return basic_string<CharT,Traits,Allocator>
-//      ::s_compare(x.begin(), x.end(), y.begin(), y.end()) < 0;
 }
 
 template <class CharT, class Traits, class Allocator>
@@ -2809,26 +3114,28 @@ inline bool
 operator<(const CharT* s, const basic_string<CharT,Traits,Allocator>& y)
 {
    return y.compare(s) > 0;
-//   basic_string<CharT,Traits,Allocator>::size_type n = Traits::length(s);
-//   return basic_string<CharT,Traits,Allocator>
-//          ::s_compare(s, s + n, y.begin(), y.end()) < 0;
 }
 
 template <class CharT, class Traits, class Allocator>
 inline bool
-operator<(const basic_string<CharT,Traits,Allocator>& x,
-          const CharT* s)
+operator<(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
 {
    return x.compare(s) < 0;
-//   basic_string<CharT,Traits,Allocator>::size_type n = Traits::length(s);
-//   return basic_string<CharT,Traits,Allocator>
-//      ::s_compare(x.begin(), x.end(), s, s + n) < 0;
 }
 
+template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
+inline bool
+operator<( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allocator>& y)
+   {  return y.compare(x) > 0;  }
+
+template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
+inline bool
+operator<(  const basic_string<CharT,Traits,Allocator>& x, BasicStringView<CharT,Traits> y)
+   {  return x.compare(y) < 0;  }
+
 template <class CharT, class Traits, class Allocator>
 inline bool
-operator>(const basic_string<CharT,Traits,Allocator>& x,
-          const basic_string<CharT,Traits,Allocator>& y) {
+operator>(const basic_string<CharT,Traits,Allocator>& x, const basic_string<CharT,Traits,Allocator>& y) {
    return y < x;
 }
 
@@ -2845,10 +3152,19 @@ operator>(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
    return s < x;
 }
 
+template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
+inline bool
+operator>( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allocator>& y)
+   {  return y < x;  }
+
+template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
+inline bool
+operator>( const basic_string<CharT,Traits,Allocator>& x, BasicStringView<CharT,Traits> y)
+   {  return y < x;  }
+
 template <class CharT, class Traits, class Allocator>
 inline bool
-operator<=(const basic_string<CharT,Traits,Allocator>& x,
-           const basic_string<CharT,Traits,Allocator>& y)
+operator<=(const basic_string<CharT,Traits,Allocator>& x, const basic_string<CharT,Traits,Allocator>& y)
 {
   return !(y < x);
 }
@@ -2863,6 +3179,17 @@ inline bool
 operator<=(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
    {  return !(s < x);  }
 
+
+template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
+inline bool
+operator<=( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allocator>& y)
+   {  return !(y < x);  }
+
+template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
+inline bool
+operator<=( const basic_string<CharT,Traits,Allocator>& x, BasicStringView<CharT,Traits> y)
+   {  return !(y < x);  }
+
 template <class CharT, class Traits, class Allocator>
 inline bool
 operator>=(const basic_string<CharT,Traits,Allocator>& x,
@@ -2879,6 +3206,16 @@ inline bool
 operator>=(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
    {  return !(x < s);  }
 
+template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
+inline bool
+operator>=( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allocator>& y)
+   {  return !(x < y);  }
+
+template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
+inline bool
+operator>=( const basic_string<CharT,Traits,Allocator>& x, BasicStringView<CharT,Traits> y)
+   {  return !(x < y);  }
+
 // Swap.
 template <class CharT, class Traits, class Allocator>
 inline void swap(basic_string<CharT,Traits,Allocator>& x, basic_string<CharT,Traits,Allocator>& y)
diff --git a/contrib/libboost/boost_1_62_0/boost/container/throw_exception.hpp b/contrib/libboost/boost_1_65_0/boost/container/throw_exception.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/throw_exception.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/throw_exception.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/uses_allocator.hpp b/contrib/libboost/boost_1_65_0/boost/container/uses_allocator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/container/uses_allocator.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/uses_allocator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/container/uses_allocator_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/container/uses_allocator_fwd.hpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/boost/container/uses_allocator_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/uses_allocator_fwd.hpp
index d8fe67fbfef..42a5b904f00 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/uses_allocator_fwd.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/uses_allocator_fwd.hpp
@@ -30,8 +30,8 @@ namespace container {
       static ::std::allocator_arg_t *dummy;
    };
 
-   template <int Dummy>
-   ::std::allocator_arg_t *std_allocator_arg_holder<Dummy>::dummy;
+   template <int Dummy>                                             //Silence null-reference compiler warnings
+   ::std::allocator_arg_t *std_allocator_arg_holder<Dummy>::dummy = reinterpret_cast< ::std::allocator_arg_t * >(0x1234);
 
 typedef const std::allocator_arg_t & allocator_arg_t;
 
diff --git a/contrib/libboost/boost_1_62_0/boost/container/vector.hpp b/contrib/libboost/boost_1_65_0/boost/container/vector.hpp
similarity index 95%
rename from contrib/libboost/boost_1_62_0/boost/container/vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/container/vector.hpp
index 5d4ab308cac..5ec669ba990 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/vector.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/container/vector.hpp
@@ -36,10 +36,10 @@
 #include <boost/container/detail/destroyers.hpp>
 #include <boost/container/detail/iterator.hpp>
 #include <boost/container/detail/iterators.hpp>
-#include <boost/container/detail/iterator_to_raw_pointer.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/next_capacity.hpp>
-#include <boost/container/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/version_type.hpp>
 // intrusive
@@ -54,6 +54,10 @@
 #include <boost/move/detail/fwd_macros.hpp>
 #endif
 #include <boost/move/detail/move_helpers.hpp>
+// move/algo
+#include <boost/move/algo/adaptive_merge.hpp>
+#include <boost/move/algo/unique.hpp>
+#include <boost/move/algo/predicate.hpp>
 // other
 #include <boost/core/no_exceptions_support.hpp>
 #include <boost/assert.hpp>
@@ -609,7 +613,7 @@ struct vector_alloc_holder<Allocator, version_0>
       , m_size(holder.m_size) //Size is initialized here so vector should only call uninitialized_xxx after this
    {
       ::boost::container::uninitialized_move_alloc_n
-         (this->alloc(), container_detail::to_raw_pointer(holder.start()), m_size, container_detail::to_raw_pointer(this->start()));
+         (this->alloc(), boost::movelib::to_raw_pointer(holder.start()), m_size, boost::movelib::to_raw_pointer(this->start()));
    }
 
    template<class OtherAllocator, class OtherAllocatorVersion>
@@ -621,7 +625,7 @@ struct vector_alloc_holder<Allocator, version_0>
       const size_type n = holder.m_size;
       this->priv_first_allocation(n);
       ::boost::container::uninitialized_move_alloc_n
-         (this->alloc(), container_detail::to_raw_pointer(holder.start()), n, container_detail::to_raw_pointer(this->start()));
+         (this->alloc(), boost::movelib::to_raw_pointer(holder.start()), n, boost::movelib::to_raw_pointer(this->start()));
    }
 
    BOOST_CONTAINER_FORCEINLINE void priv_first_allocation(size_type cap)
@@ -675,8 +679,8 @@ struct vector_alloc_holder<Allocator, version_0>
    void priv_deep_swap(vector_alloc_holder<OtherAllocator, OtherAllocatorVersion> &x)
    {
       const size_type MaxTmpStorage = sizeof(value_type)*Allocator::internal_capacity;
-      value_type *const first_this = container_detail::to_raw_pointer(this->start());
-      value_type *const first_x = container_detail::to_raw_pointer(x.start());
+      value_type *const first_this = boost::movelib::to_raw_pointer(this->start());
+      value_type *const first_x = boost::movelib::to_raw_pointer(x.start());
 
       if(this->m_size < x.m_size){
          boost::container::deep_swap_alloc_n<MaxTmpStorage>(this->alloc(), first_this, this->m_size, first_x, x.m_size);
@@ -1186,7 +1190,7 @@ class vector
       if (first == last){
          //There are no more elements in the sequence, erase remaining
          T* const end_pos = this->priv_raw_end();
-         const size_type n = static_cast<size_type>(end_pos - container_detail::iterator_to_raw_pointer(cur));
+         const size_type n = static_cast<size_type>(end_pos - boost::movelib::iterator_to_raw_pointer(cur));
          this->priv_destroy_last_n(n);
       }
       else{
@@ -1735,9 +1739,10 @@ class vector
    {
       if (BOOST_LIKELY(this->room_enough())){
          //There is more memory, just construct a new object at the end
-         allocator_traits_type::construct(this->m_holder.alloc(), this->priv_raw_end(), ::boost::forward<Args>(args)...);
+         T* const p = this->priv_raw_end();
+         allocator_traits_type::construct(this->m_holder.alloc(), p, ::boost::forward<Args>(args)...);
          ++this->m_holder.m_size;
-         return *this->priv_raw_end();
+         return *p;
       }
       else{
          typedef container_detail::insert_emplace_proxy<Allocator, T*, Args...> type;
@@ -1793,10 +1798,11 @@ class vector
    BOOST_CONTAINER_FORCEINLINE reference emplace_back(BOOST_MOVE_UREF##N)\
    {\
       if (BOOST_LIKELY(this->room_enough())){\
+         T* const p = this->priv_raw_end();\
          allocator_traits_type::construct (this->m_holder.alloc()\
             , this->priv_raw_end() BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
          ++this->m_holder.m_size;\
-         return *this->priv_raw_end();\
+         return *p;\
       }\
       else{\
          typedef container_detail::insert_emplace_proxy_arg##N<Allocator, T* BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
@@ -1848,7 +1854,7 @@ class vector
    //! <b>Complexity</b>: Amortized constant time.
    void push_back(T &&x);
    #else
-   BOOST_CONTAINER_FORCEINLINE BOOST_MOVE_CONVERSION_AWARE_CATCH(push_back, T, void, priv_push_back)
+   BOOST_MOVE_CONVERSION_AWARE_CATCH(push_back, T, void, priv_push_back)
    #endif
 
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -2003,7 +2009,7 @@ class vector
    {
       BOOST_ASSERT(this->priv_in_range(position));
       const pointer p = vector_iterator_get_ptr(position);
-      T *const pos_ptr = container_detail::to_raw_pointer(p);
+      T *const pos_ptr = boost::movelib::to_raw_pointer(p);
       T *const beg_ptr = this->priv_raw_begin();
       T *const new_end_ptr = ::boost::container::move(pos_ptr + 1, beg_ptr + this->m_holder.m_size, pos_ptr);
       //Move elements forward and destroy last
@@ -2023,9 +2029,9 @@ class vector
          (first < last && this->priv_in_range(first) && this->priv_in_range_or_end(last)));
       if (first != last){
          T* const old_end_ptr = this->priv_raw_end();
-         T* const first_ptr = container_detail::to_raw_pointer(vector_iterator_get_ptr(first));
-         T* const last_ptr  = container_detail::to_raw_pointer(vector_iterator_get_ptr(last));
-         T* const ptr = container_detail::to_raw_pointer(boost::container::move(last_ptr, old_end_ptr, first_ptr));
+         T* const first_ptr = boost::movelib::to_raw_pointer(vector_iterator_get_ptr(first));
+         T* const last_ptr  = boost::movelib::to_raw_pointer(vector_iterator_get_ptr(last));
+         T* const ptr = boost::movelib::to_raw_pointer(boost::container::move(last_ptr, old_end_ptr, first_ptr));
          this->priv_destroy_last_n(old_end_ptr - ptr);
       }
       return iterator(vector_iterator_get_ptr(first));
@@ -2238,37 +2244,15 @@ class vector
             p = this->m_holder.allocation_command(allocate_new, new_size, new_cap, p);
             this->priv_merge_in_new_buffer(UniqueBool(), first, n, comp, p, new_cap);
          }
-         else if(!UniqueBool::value && free_c >= n){
-            typedef container_detail::vector_merge_cursor<T, size_type, BidirIt, Compare> inserter_t;
-            T* const pbeg = this->priv_raw_begin();
-            return this->priv_insert_ordered_at(n, inserter_t(pbeg, pbeg + s, last, comp));
-         }
-         else{ //UniqueBool::value == true and free_c >= n
-            std::size_t remaining = n;
-            static const std::size_t PosCount = 64u;
-            size_type positions[PosCount];
-            size_type *indexes = 0;
-            while(remaining){
-               //Query for room to store indexes in the remaining buffer
-               boost::uintptr_t const szt_align_mask = container_detail::alignment_of<size_type>::value - 1;
-               boost::uintptr_t const addr = boost::uintptr_t(this->priv_raw_begin() + s + n);
-               boost::uintptr_t const capaddr = boost::uintptr_t(this->priv_raw_begin() + c);
-               boost::uintptr_t const aligned_addr = (addr + szt_align_mask) & ~szt_align_mask;
-               indexes =  reinterpret_cast<size_type *>(aligned_addr);
-               std::size_t index_capacity = (aligned_addr >= capaddr) ? 0u : (capaddr - addr)/sizeof(size_type);
-
-               //Capacity is constant, we're not going to change it
-               if(index_capacity < PosCount){
-                  indexes =  positions; 
-                  index_capacity = PosCount;
-               }
-               if(index_capacity > remaining)
-                  index_capacity = remaining;
-               BidirIt limit = first;
-               boost::container::iterator_advance(limit, index_capacity);
-               this->priv_insert_ordered_range(UniqueBool(), index_capacity, first, limit, indexes, comp);
-               first = limit;
-               remaining -= index_capacity;
+         else{
+            T *raw_pos = boost::movelib::iterator_to_raw_pointer(this->insert(this->cend(), first, last));
+            T *raw_beg = this->priv_raw_begin();
+            T *raw_end = this->priv_raw_end();
+            boost::movelib::adaptive_merge(raw_beg, raw_pos, raw_end, comp, raw_end, free_c - n);
+            if(UniqueBool::value){
+               size_type const count =
+                  static_cast<size_type>(raw_end - boost::movelib::unique(raw_beg, raw_end, boost::movelib::negate<Compare>(comp)));
+               this->priv_destroy_last_n(count);
             }
          }
       }
@@ -2277,53 +2261,6 @@ class vector
       }
    }
 
-   template <class UniqueBool, class BidirIt, class Compare>
-   void priv_insert_ordered_range
-      (UniqueBool, size_type const n, BidirIt first, BidirIt const last, size_type positions[], Compare comp)
-   {
-      //Linear: at most N + M -1 comparisons
-      //Log: MlogN
-      //Average
-      //Linear: N + M - 2
-      //Log: MlogN
-      //N+M - 2
-      //N
-      //(N+M)/2 < MlogN
-      //(N/M+1)/2 <= logN
-      //bool const linear = !s || !n || (s <= n) || ((s+n)/n/2 < logN);
-      size_type const s = this->size();
-      size_type remaining = n;
-      T* const pbeg = this->priv_raw_begin();
-      T* const pend = pbeg + s;
-      T* pcur = pbeg;
-      size_type *position = positions;
-      size_type added_in_middle = 0;
-      if(first != last && pcur != pend){
-         while(1){
-            //maintain stability moving external values only if they are strictly less
-            if(comp(*first, *pcur)) { 
-               *position = static_cast<size_type>(pcur - pbeg);
-               BOOST_ASSERT((position == positions) || (*(position-1) == size_type(-1)) || (*(position-1) <= *position));
-               ++position;
-               ++added_in_middle;
-               --remaining;
-               if(++first == last)  break;
-            }
-            else if(UniqueBool::value && !comp(*pcur, *first)){
-               *position = size_type(-1);
-               ++position;
-               --remaining;
-               if(++first == last)  break;
-            }
-            else{
-               if(++pcur == pend)   break;
-            }
-         }
-      }
-      this->insert_ordered_at(added_in_middle, position, first);
-      this->insert(this->cend(), remaining, first, last);
-   }
-
    template<class UniqueBool, class FwdIt, class Compare>
    void priv_merge_in_new_buffer
       (UniqueBool, FwdIt first, size_type n, Compare comp, pointer new_storage, size_type const new_cap)
@@ -2335,7 +2272,7 @@ class vector
       T* pbeg  = this->priv_raw_begin();
       size_type const old_size = this->size();
       T* const pend = pbeg + old_size;
-      T* d_first = container_detail::to_raw_pointer(new_storage);
+      T* d_first = boost::movelib::to_raw_pointer(new_storage);
       size_type added = n;
       //Merge in new buffer loop
       while(1){
@@ -2371,7 +2308,7 @@ class vector
       //Nothrow operations
       pointer const old_p     = this->m_holder.start();
       size_type const old_cap = this->m_holder.capacity();
-      boost::container::destroy_alloc_n(a, container_detail::to_raw_pointer(old_p), old_size);
+      boost::container::destroy_alloc_n(a, boost::movelib::to_raw_pointer(old_p), old_size);
       a.deallocate(old_p, old_cap);
       this->m_holder.m_size = old_size + added;
       this->m_holder.start(new_storage);
@@ -2442,8 +2379,8 @@ class vector
       }
       //Else do a one by one move
       else{
-         this->assign( boost::make_move_iterator(container_detail::iterator_to_raw_pointer(x.begin()))
-                     , boost::make_move_iterator(container_detail::iterator_to_raw_pointer(x.end()  ))
+         this->assign( boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(x.begin()))
+                     , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(x.end()  ))
                      );
       }
       //Move allocator if needed
@@ -2512,8 +2449,8 @@ class vector
          }
          //... and move-insert the remaining range
          sml.insert( sml.cend()
-                   , boost::make_move_iterator(container_detail::iterator_to_raw_pointer(big.nth(common_elements)))
-                   , boost::make_move_iterator(container_detail::iterator_to_raw_pointer(big.end()))
+                   , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(big.nth(common_elements)))
+                   , boost::make_move_iterator(boost::movelib::iterator_to_raw_pointer(big.end()))
                    );
          //Destroy remaining elements
          big.erase(big.nth(common_elements), big.cend());
@@ -2538,7 +2475,7 @@ class vector
       pointer const p = allocator_traits_type::allocate(this->m_holder.alloc(), new_cap, this->m_holder.m_start);
       //We will reuse insert code, so create a dummy input iterator
       this->priv_forward_range_insert_new_allocation
-         ( container_detail::to_raw_pointer(p), new_cap, this->priv_raw_end(), 0, this->priv_dummy_empty_proxy());
+         ( boost::movelib::to_raw_pointer(p), new_cap, this->priv_raw_end(), 0, this->priv_dummy_empty_proxy());
    }
 
    void priv_reserve_no_capacity(size_type new_cap, version_2)
@@ -2559,7 +2496,7 @@ class vector
          this->m_holder.capacity(real_cap);
       }
       else{ //If there is no forward expansion, move objects, we will reuse insertion code
-         T * const new_mem = container_detail::to_raw_pointer(ret);
+         T * const new_mem = boost::movelib::to_raw_pointer(ret);
          T * const ins_pos = this->priv_raw_end();
          if(reuse){   //Backwards (and possibly forward) expansion
             #ifdef BOOST_CONTAINER_VECTOR_ALLOC_STATS
@@ -2689,7 +2626,7 @@ class vector
             ++this->num_alloc;
             #endif
             this->priv_forward_range_insert_new_allocation
-               ( container_detail::to_raw_pointer(p), sz
+               ( boost::movelib::to_raw_pointer(p), sz
                , this->priv_raw_begin(), 0, this->priv_dummy_empty_proxy());
          }
       }
@@ -2733,11 +2670,11 @@ class vector
    {
       //Check if we have enough memory or try to expand current memory
       const size_type n_pos = pos - this->m_holder.start();
-      T *const raw_pos = container_detail::to_raw_pointer(pos);
+      T *const raw_pos = boost::movelib::to_raw_pointer(pos);
 
       const size_type new_cap = this->m_holder.next_capacity(n);
       //Pass the hint so that allocators can take advantage of this.
-      T * const new_buf = container_detail::to_raw_pointer
+      T * const new_buf = boost::movelib::to_raw_pointer
          (allocator_traits_type::allocate(this->m_holder.alloc(), new_cap, this->m_holder.m_start));
       #ifdef BOOST_CONTAINER_VECTOR_ALLOC_STATS
       ++this->num_alloc;
@@ -2752,7 +2689,7 @@ class vector
       (const pointer &pos, const size_type n, const InsertionProxy insert_range_proxy, version_2)
    {
       //Check if we have enough memory or try to expand current memory
-      T *const raw_pos = container_detail::to_raw_pointer(pos);
+      T *const raw_pos = boost::movelib::to_raw_pointer(pos);
       const size_type n_pos = raw_pos - this->priv_raw_begin();
 
       //There is not enough memory, allocate a new
@@ -2779,7 +2716,7 @@ class vector
             ++this->num_expand_bwd;
             #endif
             this->priv_forward_range_insert_expand_backwards
-               (container_detail::to_raw_pointer(ret), real_cap, raw_pos, n, insert_range_proxy);
+               (boost::movelib::to_raw_pointer(ret), real_cap, raw_pos, n, insert_range_proxy);
          }
       }
       //New buffer
@@ -2788,7 +2725,7 @@ class vector
          ++this->num_alloc;
          #endif
          this->priv_forward_range_insert_new_allocation
-            ( container_detail::to_raw_pointer(ret), real_cap, raw_pos, n, insert_range_proxy);
+            ( boost::movelib::to_raw_pointer(ret), real_cap, raw_pos, n, insert_range_proxy);
       }
 
       return iterator(this->m_holder.start() + n_pos);
@@ -2808,7 +2745,7 @@ class vector
       }
       else{
          //Expand forward
-         T *const raw_pos = container_detail::to_raw_pointer(pos);
+         T *const raw_pos = boost::movelib::to_raw_pointer(pos);
          const size_type n_pos = raw_pos - this->priv_raw_begin();
          this->priv_forward_range_insert_expand_forward(raw_pos, n, insert_range_proxy);
          return iterator(this->m_holder.start() + n_pos);
@@ -2924,10 +2861,10 @@ class vector
    }
 
    private:
-   T *priv_raw_begin() const
-   {  return container_detail::to_raw_pointer(m_holder.start());  }
+   BOOST_CONTAINER_FORCEINLINE T *priv_raw_begin() const
+   {  return boost::movelib::to_raw_pointer(m_holder.start());  }
 
-   T* priv_raw_end() const
+   BOOST_CONTAINER_FORCEINLINE T* priv_raw_end() const
    {  return this->priv_raw_begin() + this->m_holder.m_size;  }
 
    template <class InsertionProxy>
@@ -3120,7 +3057,7 @@ class vector
             }
             else{ //If trivial destructor, we can uninitialized copy + copy in a single uninitialized copy
                ::boost::container::uninitialized_move_alloc_n
-                  (this->m_holder.alloc(), pos, old_finish - pos, new_start + before_plus_new);
+                  (this->m_holder.alloc(), pos, static_cast<size_type>(old_finish - pos), new_start + before_plus_new);
                this->m_holder.m_size = new_size;
                old_values_destroyer.release();
             }
diff --git a/contrib/libboost/boost_1_62_0/boost/cstdint.hpp b/contrib/libboost/boost_1_65_0/boost/cstdint.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/cstdint.hpp
rename to contrib/libboost/boost_1_65_0/boost/cstdint.hpp
index bf7097ec8cb..31b67417ae7 100644
--- a/contrib/libboost/boost_1_62_0/boost/cstdint.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/cstdint.hpp
@@ -374,7 +374,7 @@ namespace boost
     || (defined(_XOPEN_UNIX) && (_XOPEN_UNIX+0 > 0) && !defined(__UCLIBC__)) \
     || defined(__CYGWIN__) \
     || defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__) \
-    || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(sun)
+    || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || (defined(sun) && !defined(BOOST_HAS_STDINT_H)) || defined(INTPTR_MAX)
 
 namespace boost {
     using ::intptr_t;
@@ -422,6 +422,20 @@ INT#_C macros if they're not already defined (John Maddock).
 #if defined(__GNUC__) && (__GNUC__ >= 4)
 #pragma GCC system_header
 #endif
+//
+// Undef the macros as a precaution, since we may get here if <stdint.h> has failed
+// to define them all, see https://svn.boost.org/trac/boost/ticket/12786
+//
+#undef INT8_C
+#undef INT16_C
+#undef INT32_C
+#undef INT64_C
+#undef INTMAX_C
+#undef UINT8_C
+#undef UINT16_C
+#undef UINT32_C
+#undef UINT64_C
+#undef UINTMAX_C
 
 #include <limits.h>
 # define BOOST__STDC_CONSTANT_MACROS_DEFINED
diff --git a/contrib/libboost/boost_1_62_0/boost/cstdlib.hpp b/contrib/libboost/boost_1_65_0/boost/cstdlib.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/cstdlib.hpp
rename to contrib/libboost/boost_1_65_0/boost/cstdlib.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/current_function.hpp b/contrib/libboost/boost_1_65_0/boost/current_function.hpp
similarity index 86%
rename from contrib/libboost/boost_1_62_0/boost/current_function.hpp
rename to contrib/libboost/boost_1_65_0/boost/current_function.hpp
index 5c113f80932..86955cb041b 100644
--- a/contrib/libboost/boost_1_62_0/boost/current_function.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/current_function.hpp
@@ -28,7 +28,11 @@ namespace detail
 inline void current_function_helper()
 {
 
-#if defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600)) || defined(__ghs__)
+#if defined( BOOST_DISABLE_CURRENT_FUNCTION )
+
+# define BOOST_CURRENT_FUNCTION "(unknown)"
+
+#elif defined(__GNUC__) || (defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || (defined(__ICC) && (__ICC >= 600)) || defined(__ghs__)
 
 # define BOOST_CURRENT_FUNCTION __PRETTY_FUNCTION__
 
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/algorithm.hpp b/contrib/libboost/boost_1_65_0/boost/detail/algorithm.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/algorithm.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/algorithm.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/allocator_utilities.hpp b/contrib/libboost/boost_1_65_0/boost/detail/allocator_utilities.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/allocator_utilities.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/allocator_utilities.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/atomic_count.hpp b/contrib/libboost/boost_1_65_0/boost/detail/atomic_count.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/atomic_count.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/atomic_count.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/atomic_redef_macros.hpp b/contrib/libboost/boost_1_65_0/boost/detail/atomic_redef_macros.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/atomic_redef_macros.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/atomic_redef_macros.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/atomic_undef_macros.hpp b/contrib/libboost/boost_1_65_0/boost/detail/atomic_undef_macros.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/atomic_undef_macros.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/atomic_undef_macros.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/basic_pointerbuf.hpp b/contrib/libboost/boost_1_65_0/boost/detail/basic_pointerbuf.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/basic_pointerbuf.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/basic_pointerbuf.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/binary_search.hpp b/contrib/libboost/boost_1_65_0/boost/detail/binary_search.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/binary_search.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/binary_search.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/bitmask.hpp b/contrib/libboost/boost_1_65_0/boost/detail/bitmask.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/bitmask.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/bitmask.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/call_traits.hpp b/contrib/libboost/boost_1_65_0/boost/detail/call_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/call_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/call_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/catch_exceptions.hpp b/contrib/libboost/boost_1_65_0/boost/detail/catch_exceptions.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/catch_exceptions.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/catch_exceptions.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/compressed_pair.hpp b/contrib/libboost/boost_1_65_0/boost/detail/compressed_pair.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/compressed_pair.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/compressed_pair.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/container_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/detail/container_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/container_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/container_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/dynamic_bitset.hpp b/contrib/libboost/boost_1_65_0/boost/detail/dynamic_bitset.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/dynamic_bitset.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/dynamic_bitset.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/endian.hpp b/contrib/libboost/boost_1_65_0/boost/detail/endian.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/endian.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/endian.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/fenv.hpp b/contrib/libboost/boost_1_65_0/boost/detail/fenv.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/fenv.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/fenv.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/has_default_constructor.hpp b/contrib/libboost/boost_1_65_0/boost/detail/has_default_constructor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/has_default_constructor.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/has_default_constructor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/identifier.hpp b/contrib/libboost/boost_1_65_0/boost/detail/identifier.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/identifier.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/identifier.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/indirect_traits.hpp b/contrib/libboost/boost_1_65_0/boost/detail/indirect_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/indirect_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/indirect_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/interlocked.hpp b/contrib/libboost/boost_1_65_0/boost/detail/interlocked.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/interlocked.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/interlocked.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/is_incrementable.hpp b/contrib/libboost/boost_1_65_0/boost/detail/is_incrementable.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/is_incrementable.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/is_incrementable.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/is_sorted.hpp b/contrib/libboost/boost_1_65_0/boost/detail/is_sorted.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/is_sorted.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/is_sorted.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/is_xxx.hpp b/contrib/libboost/boost_1_65_0/boost/detail/is_xxx.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/is_xxx.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/is_xxx.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/iterator.hpp b/contrib/libboost/boost_1_65_0/boost/detail/iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/lcast_precision.hpp b/contrib/libboost/boost_1_65_0/boost/detail/lcast_precision.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/detail/lcast_precision.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/lcast_precision.hpp
index 93abce18ce6..2be88fd87fc 100644
--- a/contrib/libboost/boost_1_62_0/boost/detail/lcast_precision.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/detail/lcast_precision.hpp
@@ -125,6 +125,7 @@ inline std::streamsize lcast_get_precision(T* = 0)
             limits::radix == 10 && limits::digits10 > 0;
         std::streamsize const streamsize_max =
             (boost::integer_traits<std::streamsize>::max)();
+        (void)streamsize_max;
 
         if(is_specialized_bin)
         { // Floating-point types with
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/lightweight_main.hpp b/contrib/libboost/boost_1_65_0/boost/detail/lightweight_main.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/lightweight_main.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/lightweight_main.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/lightweight_mutex.hpp b/contrib/libboost/boost_1_65_0/boost/detail/lightweight_mutex.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/lightweight_mutex.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/lightweight_mutex.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/lightweight_test.hpp b/contrib/libboost/boost_1_65_0/boost/detail/lightweight_test.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/lightweight_test.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/lightweight_test.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/lightweight_test_report.hpp b/contrib/libboost/boost_1_65_0/boost/detail/lightweight_test_report.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/lightweight_test_report.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/lightweight_test_report.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/lightweight_thread.hpp b/contrib/libboost/boost_1_65_0/boost/detail/lightweight_thread.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/lightweight_thread.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/lightweight_thread.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/named_template_params.hpp b/contrib/libboost/boost_1_65_0/boost/detail/named_template_params.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/named_template_params.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/named_template_params.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/no_exceptions_support.hpp b/contrib/libboost/boost_1_65_0/boost/detail/no_exceptions_support.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/no_exceptions_support.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/no_exceptions_support.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/numeric_traits.hpp b/contrib/libboost/boost_1_65_0/boost/detail/numeric_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/numeric_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/numeric_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/ob_compressed_pair.hpp b/contrib/libboost/boost_1_65_0/boost/detail/ob_compressed_pair.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/ob_compressed_pair.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/ob_compressed_pair.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/quick_allocator.hpp b/contrib/libboost/boost_1_65_0/boost/detail/quick_allocator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/quick_allocator.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/quick_allocator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/reference_content.hpp b/contrib/libboost/boost_1_65_0/boost/detail/reference_content.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/reference_content.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/reference_content.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/scoped_enum_emulation.hpp b/contrib/libboost/boost_1_65_0/boost/detail/scoped_enum_emulation.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/scoped_enum_emulation.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/scoped_enum_emulation.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/select_type.hpp b/contrib/libboost/boost_1_65_0/boost/detail/select_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/select_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/select_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/sp_typeinfo.hpp b/contrib/libboost/boost_1_65_0/boost/detail/sp_typeinfo.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/sp_typeinfo.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/sp_typeinfo.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/templated_streams.hpp b/contrib/libboost/boost_1_65_0/boost/detail/templated_streams.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/templated_streams.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/templated_streams.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/utf8_codecvt_facet.hpp b/contrib/libboost/boost_1_65_0/boost/detail/utf8_codecvt_facet.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/utf8_codecvt_facet.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/utf8_codecvt_facet.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/utf8_codecvt_facet.ipp b/contrib/libboost/boost_1_65_0/boost/detail/utf8_codecvt_facet.ipp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/utf8_codecvt_facet.ipp
rename to contrib/libboost/boost_1_65_0/boost/detail/utf8_codecvt_facet.ipp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/GetCurrentProcess.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/GetCurrentProcess.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/GetCurrentProcess.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/GetCurrentProcess.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/GetCurrentThread.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/GetCurrentThread.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/GetCurrentThread.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/GetCurrentThread.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/GetLastError.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/GetLastError.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/GetLastError.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/GetLastError.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/GetProcessTimes.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/GetProcessTimes.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/GetProcessTimes.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/GetProcessTimes.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/GetThreadTimes.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/GetThreadTimes.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/GetThreadTimes.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/GetThreadTimes.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/access_rights.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/access_rights.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/access_rights.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/access_rights.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/apc.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/apc.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/apc.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/apc.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/basic_types.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/basic_types.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/basic_types.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/basic_types.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/character_code_conversion.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/character_code_conversion.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/character_code_conversion.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/character_code_conversion.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/condition_variable.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/condition_variable.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/condition_variable.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/condition_variable.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/config.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/config.hpp
similarity index 86%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/config.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/config.hpp
index 1f08c2a88e2..9254eb912bd 100644
--- a/contrib/libboost/boost_1_62_0/boost/detail/winapi/config.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/detail/winapi/config.hpp
@@ -54,7 +54,10 @@
 #endif
 #endif
 
-#if defined(BOOST_USE_WINDOWS_H)
+#define BOOST_DETAIL_WINAPI_MAKE_NTDDI_VERSION2(x) x##0000
+#define BOOST_DETAIL_WINAPI_MAKE_NTDDI_VERSION(x) BOOST_DETAIL_WINAPI_MAKE_NTDDI_VERSION2(x)
+
+#if defined(BOOST_USE_WINDOWS_H) || defined(BOOST_WINAPI_DEFINE_VERSION_MACROS)
 // We have to define the version macros so that windows.h provides the necessary symbols
 #if !defined(_WIN32_WINNT)
 #define _WIN32_WINNT BOOST_USE_WINAPI_VERSION
@@ -62,6 +65,9 @@
 #if !defined(WINVER)
 #define WINVER BOOST_USE_WINAPI_VERSION
 #endif
+#if !defined(NTDDI_VERSION)
+#define NTDDI_VERSION BOOST_DETAIL_WINAPI_MAKE_NTDDI_VERSION(BOOST_USE_WINAPI_VERSION)
+#endif
 #endif
 
 #include <boost/config.hpp>
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/critical_section.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/critical_section.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/critical_section.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/critical_section.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/crypt.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/crypt.hpp
similarity index 80%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/crypt.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/crypt.hpp
index 0650845179d..95c2cf8f3c6 100644
--- a/contrib/libboost/boost_1_62_0/boost/detail/winapi/crypt.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/detail/winapi/crypt.hpp
@@ -98,10 +98,23 @@ CryptGenRandom(
     boost::detail::winapi::DWORD_ dwLen,
     boost::detail::winapi::BYTE_ *pbBuffer);
 
+#if defined(_MSC_VER) && (_MSC_VER+0) >= 1500 &&\
+    (\
+        (defined(NTDDI_VERSION) && (NTDDI_VERSION+0) < BOOST_DETAIL_WINAPI_MAKE_NTDDI_VERSION(BOOST_WINAPI_VERSION_WINXP)) ||\
+        (!defined(NTDDI_VERSION) && BOOST_USE_WINAPI_VERSION < BOOST_WINAPI_VERSION_WINXP)\
+    )
+// Standalone MS Windows SDK 6.0A and later provide a different declaration of CryptReleaseContext for Windows 2000 and older.
+// This is not the case for (a) MinGW and MinGW-w64 and (b) MSVC 7.1 and 8, which are shipped with their own Windows SDK.
+BOOST_SYMBOL_IMPORT boost::detail::winapi::BOOL_ WINAPI
+CryptReleaseContext(
+    boost::detail::winapi::HCRYPTPROV_ hProv,
+    boost::detail::winapi::ULONG_PTR_ dwFlags);
+#else
 BOOST_SYMBOL_IMPORT boost::detail::winapi::BOOL_ WINAPI
 CryptReleaseContext(
     boost::detail::winapi::HCRYPTPROV_ hProv,
     boost::detail::winapi::DWORD_ dwFlags);
+#endif
 }
 #endif // !defined( BOOST_USE_WINDOWS_H )
 
@@ -134,15 +147,23 @@ const DWORD_ CRYPT_SILENT_          = 64;
 #endif
 
 #if !defined( BOOST_NO_ANSI_APIS )
-using ::CryptEnumProvidersA;
 using ::CryptAcquireContextA;
 #endif
-using ::CryptEnumProvidersW;
 using ::CryptAcquireContextW;
 using ::CryptGenRandom;
-using ::CryptReleaseContext;
 
 #if !defined( BOOST_NO_ANSI_APIS )
+BOOST_FORCEINLINE BOOL_ CryptEnumProvidersA(
+    DWORD_ dwIndex,
+    DWORD_ *pdwReserved,
+    DWORD_ dwFlags,
+    DWORD_ *pdwProvType,
+    LPSTR_ szProvName,
+    DWORD_ *pcbProvName)
+{
+    return ::CryptEnumProvidersA(dwIndex, pdwReserved, dwFlags, pdwProvType, winapi::detail::cast_ptr(szProvName), pcbProvName);
+}
+
 BOOST_FORCEINLINE BOOL_ crypt_enum_providers(
     DWORD_ dwIndex,
     DWORD_ *pdwReserved,
@@ -165,6 +186,17 @@ BOOST_FORCEINLINE BOOL_ crypt_acquire_context(
 }
 #endif
 
+BOOST_FORCEINLINE BOOL_ CryptEnumProvidersW(
+    DWORD_ dwIndex,
+    DWORD_ *pdwReserved,
+    DWORD_ dwFlags,
+    DWORD_ *pdwProvType,
+    LPWSTR_ szProvName,
+    DWORD_ *pcbProvName)
+{
+    return ::CryptEnumProvidersW(dwIndex, pdwReserved, dwFlags, pdwProvType, winapi::detail::cast_ptr(szProvName), pcbProvName);
+}
+
 BOOST_FORCEINLINE BOOL_ crypt_enum_providers(
     DWORD_ dwIndex,
     DWORD_ *pdwReserved,
@@ -186,6 +218,11 @@ BOOST_FORCEINLINE BOOL_ crypt_acquire_context(
     return ::CryptAcquireContextW(phProv, szContainer, szProvider, dwProvType, dwFlags);
 }
 
+BOOST_FORCEINLINE BOOL_ CryptReleaseContext(HCRYPTPROV_ hProv, DWORD_ dwFlags)
+{
+    return ::CryptReleaseContext(hProv, dwFlags);
+}
+
 }
 }
 }
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/dbghelp.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/dbghelp.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/dbghelp.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/dbghelp.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/detail/winapi/debugapi.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/debugapi.hpp
new file mode 100644
index 00000000000..188345c823d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/detail/winapi/debugapi.hpp
@@ -0,0 +1,79 @@
+//  debugapi.hpp  --------------------------------------------------------------
+//
+//  Copyright 2017 Vinnie Falco
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+
+#ifndef BOOST_DETAIL_WINAPI_DEBUGAPI_HPP
+#define BOOST_DETAIL_WINAPI_DEBUGAPI_HPP
+
+#include <boost/detail/winapi/basic_types.hpp>
+#include <boost/detail/winapi/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if !defined( BOOST_USE_WINDOWS_H )
+extern "C" {
+
+#if (BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_NT4)
+
+BOOST_SYMBOL_IMPORT
+boost::detail::winapi::BOOL_
+WINAPI
+IsDebuggerPresent(
+    BOOST_DETAIL_WINAPI_VOID
+    );
+
+#endif
+
+BOOST_SYMBOL_IMPORT
+boost::detail::winapi::VOID_
+WINAPI
+OutputDebugStringA(
+    boost::detail::winapi::LPCSTR_
+    );
+
+BOOST_SYMBOL_IMPORT
+boost::detail::winapi::VOID_
+WINAPI
+OutputDebugStringW(
+    boost::detail::winapi::LPCWSTR_
+    );
+
+}
+#endif // extern "C"
+
+namespace boost {
+namespace detail {
+namespace winapi {
+
+#if (BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_NT4)
+using ::IsDebuggerPresent;
+#endif
+
+using ::OutputDebugStringA;
+using ::OutputDebugStringW;
+
+inline
+void
+output_debug_string(char const* s)
+{
+    ::OutputDebugStringA(s);
+}
+
+inline
+void
+output_debug_string(wchar_t const* s)
+{
+    ::OutputDebugStringW(s);
+}
+
+}
+}
+}
+
+#endif // BOOST_DETAIL_WINAPI_DEBUGAPI_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/detail/cast_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/detail/cast_ptr.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/detail/cast_ptr.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/detail/cast_ptr.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/directory_management.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/directory_management.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/directory_management.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/directory_management.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/dll.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/dll.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/dll.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/dll.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/environment.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/environment.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/environment.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/environment.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/error_codes.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/error_codes.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/error_codes.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/error_codes.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/error_handling.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/error_handling.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/error_handling.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/error_handling.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/event.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/event.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/event.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/event.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/file_management.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/file_management.hpp
similarity index 90%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/file_management.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/file_management.hpp
index 4c28bec5b6d..b90b7ee07b6 100644
--- a/contrib/libboost/boost_1_62_0/boost/detail/winapi/file_management.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/detail/winapi/file_management.hpp
@@ -157,6 +157,12 @@ SetFilePointer(
     boost::detail::winapi::LONG_ lpDistanceToMove,
     boost::detail::winapi::PLONG_ lpDistanceToMoveHigh,
     boost::detail::winapi::DWORD_ dwMoveMethod);
+
+struct _BY_HANDLE_FILE_INFORMATION;
+BOOST_SYMBOL_IMPORT boost::detail::winapi::BOOL_ WINAPI
+GetFileInformationByHandle(
+    boost::detail::winapi::HANDLE_ hFile,
+    ::_BY_HANDLE_FILE_INFORMATION* lpFileInformation);
 }
 #endif
 
@@ -236,6 +242,24 @@ const DWORD_ FILE_END_ = 2;
 
 #endif // defined( BOOST_USE_WINDOWS_H )
 
+// Some of these constants are not defined by Windows SDK in MinGW or older MSVC
+const DWORD_ FILE_FLAG_WRITE_THROUGH_ = 0x80000000;
+const DWORD_ FILE_FLAG_OVERLAPPED_ = 0x40000000;
+const DWORD_ FILE_FLAG_NO_BUFFERING_ = 0x20000000;
+const DWORD_ FILE_FLAG_RANDOM_ACCESS_ = 0x10000000;
+const DWORD_ FILE_FLAG_SEQUENTIAL_SCAN_ = 0x08000000;
+const DWORD_ FILE_FLAG_DELETE_ON_CLOSE_ = 0x04000000;
+const DWORD_ FILE_FLAG_BACKUP_SEMANTICS_ = 0x02000000;
+const DWORD_ FILE_FLAG_POSIX_SEMANTICS_ = 0x01000000;
+const DWORD_ FILE_FLAG_SESSION_AWARE_ = 0x00800000;
+const DWORD_ FILE_FLAG_OPEN_REPARSE_POINT_ = 0x00200000;
+const DWORD_ FILE_FLAG_OPEN_NO_RECALL_ = 0x00100000;
+const DWORD_ FILE_FLAG_FIRST_PIPE_INSTANCE_ = 0x00080000;
+
+#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WIN8
+const DWORD_ FILE_FLAG_OPEN_REQUIRING_OPLOCK_ = 0x00040000;
+#endif
+
 // This constant is not defined in Windows SDK up until 6.0A
 const DWORD_ FILE_ATTRIBUTE_VIRTUAL_ = 0x00010000;
 
@@ -358,6 +382,19 @@ typedef struct BOOST_DETAIL_WINAPI_MAY_ALIAS _WIN32_FIND_DATAW {
 #endif
 } WIN32_FIND_DATAW_, *PWIN32_FIND_DATAW_, *LPWIN32_FIND_DATAW_;
 
+typedef struct BOOST_DETAIL_WINAPI_MAY_ALIAS _BY_HANDLE_FILE_INFORMATION {
+    DWORD_ dwFileAttributes;
+    FILETIME_ ftCreationTime;
+    FILETIME_ ftLastAccessTime;
+    FILETIME_ ftLastWriteTime;
+    DWORD_ dwVolumeSerialNumber;
+    DWORD_ nFileSizeHigh;
+    DWORD_ nFileSizeLow;
+    DWORD_ nNumberOfLinks;
+    DWORD_ nFileIndexHigh;
+    DWORD_ nFileIndexLow;
+} BY_HANDLE_FILE_INFORMATION_, *PBY_HANDLE_FILE_INFORMATION_, *LPBY_HANDLE_FILE_INFORMATION_;
+
 BOOST_FORCEINLINE HANDLE_ FindFirstFileW(LPCWSTR_ lpFileName, WIN32_FIND_DATAW_* lpFindFileData)
 {
     return ::FindFirstFileW(lpFileName, reinterpret_cast< ::_WIN32_FIND_DATAW* >(lpFindFileData));
@@ -504,6 +541,11 @@ BOOST_FORCEINLINE DWORD_ get_file_attributes(LPCWSTR_ lpFileName)
     return ::GetFileAttributesW(lpFileName);
 }
 
+BOOST_FORCEINLINE BOOL_ GetFileInformationByHandle(HANDLE_ h, BY_HANDLE_FILE_INFORMATION_* info)
+{
+    return ::GetFileInformationByHandle(h, reinterpret_cast< ::_BY_HANDLE_FILE_INFORMATION* >(info));
+}
+
 }
 }
 }
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/file_mapping.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/file_mapping.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/file_mapping.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/file_mapping.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/get_current_process.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/get_current_process.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/get_current_process.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/get_current_process.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/get_current_process_id.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/get_current_process_id.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/get_current_process_id.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/get_current_process_id.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/get_current_thread.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/get_current_thread.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/get_current_thread.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/get_current_thread.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/get_current_thread_id.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/get_current_thread_id.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/get_current_thread_id.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/get_current_thread_id.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/get_last_error.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/get_last_error.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/get_last_error.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/get_last_error.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/get_process_times.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/get_process_times.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/get_process_times.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/get_process_times.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/get_system_directory.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/get_system_directory.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/get_system_directory.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/get_system_directory.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/get_thread_times.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/get_thread_times.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/get_thread_times.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/get_thread_times.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/handle_info.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/handle_info.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/handle_info.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/handle_info.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/handles.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/handles.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/handles.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/handles.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/heap_memory.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/heap_memory.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/heap_memory.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/heap_memory.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/init_once.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/init_once.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/init_once.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/init_once.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/jobs.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/jobs.hpp
similarity index 86%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/jobs.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/jobs.hpp
index 233df17ec44..3c3bf0872b1 100644
--- a/contrib/libboost/boost_1_62_0/boost/detail/winapi/jobs.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/detail/winapi/jobs.hpp
@@ -27,30 +27,40 @@ BOOST_SYMBOL_IMPORT boost::detail::winapi::BOOL_ WINAPI AssignProcessToJobObject
     boost::detail::winapi::HANDLE_ hJob,
     boost::detail::winapi::HANDLE_ hProcess);
 
+#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WINXP
 BOOST_SYMBOL_IMPORT boost::detail::winapi::BOOL_ WINAPI IsProcessInJob(
     boost::detail::winapi::HANDLE_ ProcessHandle,
     boost::detail::winapi::HANDLE_ JobHandle,
     boost::detail::winapi::PBOOL_ Result);
+#endif
 
 BOOST_SYMBOL_IMPORT boost::detail::winapi::BOOL_ WINAPI TerminateJobObject(
     boost::detail::winapi::HANDLE_ hJob,
     boost::detail::winapi::UINT_ uExitCode);
+} // extern "C"
+#endif // !defined( BOOST_USE_WINDOWS_H )
 
+// MinGW does not declare OpenJobObjectA/W in headers but exports them from libraries
+#if !defined( BOOST_USE_WINDOWS_H ) || defined( BOOST_WINAPI_IS_MINGW )
+extern "C" {
+#if !defined( BOOST_NO_ANSI_APIS )
 BOOST_SYMBOL_IMPORT boost::detail::winapi::HANDLE_ WINAPI OpenJobObjectA(
     boost::detail::winapi::DWORD_ dwDesiredAccess,
     boost::detail::winapi::BOOL_ bInheritHandles,
     boost::detail::winapi::LPCSTR_ lpName);
+#endif
 
 BOOST_SYMBOL_IMPORT boost::detail::winapi::HANDLE_ WINAPI OpenJobObjectW(
     boost::detail::winapi::DWORD_ dwDesiredAccess,
     boost::detail::winapi::BOOL_ bInheritHandles,
     boost::detail::winapi::LPCWSTR_ lpName);
 } // extern "C"
-#endif // !defined( BOOST_USE_WINDOWS_H )
+#endif // !defined( BOOST_USE_WINDOWS_H ) || defined( BOOST_WINAPI_IS_MINGW )
 
 namespace boost { namespace detail { namespace winapi {
 
-#if defined( BOOST_USE_WINDOWS_H )
+// MinGW does not define job constants
+#if defined( BOOST_USE_WINDOWS_H ) && !defined( BOOST_WINAPI_IS_MINGW )
 const DWORD_ JOB_OBJECT_ASSIGN_PROCESS_ = JOB_OBJECT_ASSIGN_PROCESS;
 const DWORD_ JOB_OBJECT_SET_ATTRIBUTES_ = JOB_OBJECT_SET_ATTRIBUTES;
 const DWORD_ JOB_OBJECT_QUERY_ = JOB_OBJECT_QUERY;
@@ -73,7 +83,9 @@ using ::OpenJobObjectA;
 using ::OpenJobObjectW;
 
 using ::AssignProcessToJobObject;
+#if BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WINXP
 using ::IsProcessInJob;
+#endif
 using ::TerminateJobObject;
 
 #if !defined( BOOST_NO_ANSI_APIS )
@@ -105,7 +117,7 @@ BOOST_FORCEINLINE HANDLE_ create_job_object(LPSECURITY_ATTRIBUTES_ lpJobAttribut
 
 BOOST_FORCEINLINE HANDLE_ open_job_object(DWORD_ dwDesiredAccess, BOOL_ bInheritHandles, LPCWSTR_ lpName)
 {
-    return OpenJobObjectW(dwDesiredAccess, bInheritHandles, lpName);
+    return ::OpenJobObjectW(dwDesiredAccess, bInheritHandles, lpName);
 }
 
 } // namespace winapi
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/limits.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/limits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/limits.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/limits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/local_memory.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/local_memory.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/local_memory.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/local_memory.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/memory.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/memory.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/memory.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/memory.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/mutex.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/mutex.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/mutex.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/mutex.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/overlapped.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/overlapped.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/overlapped.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/overlapped.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/page_protection_flags.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/page_protection_flags.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/page_protection_flags.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/page_protection_flags.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/pipes.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/pipes.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/pipes.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/pipes.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/priority_class.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/priority_class.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/priority_class.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/priority_class.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/process.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/process.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/process.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/process.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/security.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/security.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/security.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/security.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/semaphore.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/semaphore.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/semaphore.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/semaphore.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/shell.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/shell.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/shell.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/shell.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/show_window.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/show_window.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/show_window.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/show_window.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/srw_lock.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/srw_lock.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/srw_lock.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/srw_lock.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/detail/winapi/stack_backtrace.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/stack_backtrace.hpp
new file mode 100644
index 00000000000..637be6cdf48
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/detail/winapi/stack_backtrace.hpp
@@ -0,0 +1,55 @@
+//  stack_backtrace.hpp  --------------------------------------------------------------
+//
+//  Copyright 2017 Andrey Semashev
+//
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_DETAIL_WINAPI_STACK_BACKTRACE_HPP_INCLUDED_
+#define BOOST_DETAIL_WINAPI_STACK_BACKTRACE_HPP_INCLUDED_
+
+#include <boost/detail/winapi/basic_types.hpp>
+#include <boost/detail/winapi/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+// MinGW does not provide RtlCaptureStackBackTrace
+#if !defined( BOOST_WINAPI_IS_MINGW )
+
+// Note: RtlCaptureStackBackTrace is available in WinXP SP1 and later, but we don't discriminate SP versions
+#if (BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WINXP)
+
+// Windows SDK shipped with MSVC 7.1 and 8 does not declare RtlCaptureStackBackTrace in headers but allows to link with it
+#if !defined( BOOST_USE_WINDOWS_H ) || (defined(_MSC_VER) && (_MSC_VER+0) < 1500)
+extern "C" {
+
+BOOST_SYMBOL_IMPORT
+boost::detail::winapi::WORD_
+NTAPI
+RtlCaptureStackBackTrace(
+    boost::detail::winapi::DWORD_ FramesToSkip,
+    boost::detail::winapi::DWORD_ FramesToCapture,
+    boost::detail::winapi::PVOID_* BackTrace,
+    boost::detail::winapi::PDWORD_ BackTraceHash
+    );
+
+} // extern "C"
+#endif
+
+namespace boost {
+namespace detail {
+namespace winapi {
+
+using ::RtlCaptureStackBackTrace;
+
+}
+}
+}
+
+#endif // (BOOST_USE_WINAPI_VERSION >= BOOST_WINAPI_VERSION_WINXP)
+
+#endif // !defined( BOOST_WINAPI_IS_MINGW )
+
+#endif // BOOST_DETAIL_WINAPI_STACK_BACKTRACE_HPP_INCLUDED_
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/synchronization.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/synchronization.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/synchronization.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/synchronization.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/system.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/system.hpp
similarity index 90%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/system.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/system.hpp
index 93a5eeb11c8..bdfff662f8c 100644
--- a/contrib/libboost/boost_1_62_0/boost/detail/winapi/system.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/detail/winapi/system.hpp
@@ -17,6 +17,12 @@
 #pragma once
 #endif
 
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+// nonstandard extension used : nameless struct/union
+#pragma warning(disable: 4201)
+#endif
+
 #if !defined( BOOST_USE_WINDOWS_H )
 extern "C" {
 struct _SYSTEM_INFO;
@@ -70,4 +76,8 @@ BOOST_FORCEINLINE VOID_ GetNativeSystemInfo(LPSYSTEM_INFO_ lpSystemInfo)
 }
 }
 
+#if defined(BOOST_MSVC)
+#pragma warning(pop)
+#endif
+
 #endif // BOOST_DETAIL_WINAPI_SYSTEM_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/thread.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/thread.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/thread.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/thread.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/thread_pool.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/thread_pool.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/thread_pool.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/thread_pool.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/time.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/time.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/time.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/time.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/timers.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/timers.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/timers.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/timers.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/tls.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/tls.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/tls.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/tls.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/wait.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/wait.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/wait.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/wait.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/detail/winapi/waitable_timer.hpp b/contrib/libboost/boost_1_65_0/boost/detail/winapi/waitable_timer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/detail/winapi/waitable_timer.hpp
rename to contrib/libboost/boost_1_65_0/boost/detail/winapi/waitable_timer.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/detail/workaround.hpp b/contrib/libboost/boost_1_65_0/boost/detail/workaround.hpp
new file mode 100644
index 00000000000..fb961158804
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/detail/workaround.hpp
@@ -0,0 +1,10 @@
+// Copyright David Abrahams 2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+#ifndef WORKAROUND_DWA2002126_HPP
+#define WORKAROUND_DWA2002126_HPP
+
+#include <boost/config/workaround.hpp>
+
+#endif // WORKAROUND_DWA2002126_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/all.hpp b/contrib/libboost/boost_1_65_0/boost/exception/all.hpp
similarity index 77%
rename from contrib/libboost/boost_1_62_0/boost/exception/all.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/all.hpp
index 32eb15051f0..58b02d00c11 100644
--- a/contrib/libboost/boost_1_62_0/boost/exception/all.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/exception/all.hpp
@@ -5,13 +5,8 @@
 
 #ifndef UUID_316FDA946C0D11DEA9CBAE5255D89593
 #define UUID_316FDA946C0D11DEA9CBAE5255D89593
-#if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
-#pragma GCC system_header
-#endif
-#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
-#pragma warning(push,1)
-#endif
 
+#include <boost/config.hpp>
 #include <boost/exception/diagnostic_information.hpp>
 #include <boost/exception/error_info.hpp>
 #include <boost/exception/exception.hpp>
@@ -29,8 +24,4 @@
 #include <boost/exception/errinfo_nested_exception.hpp>
 #include <boost/exception_ptr.hpp>
 #endif
-
-#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
-#pragma warning(pop)
-#endif
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/current_exception_cast.hpp b/contrib/libboost/boost_1_65_0/boost/exception/current_exception_cast.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/exception/current_exception_cast.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/current_exception_cast.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/detail/clone_current_exception.hpp b/contrib/libboost/boost_1_65_0/boost/exception/detail/clone_current_exception.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/exception/detail/clone_current_exception.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/detail/clone_current_exception.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/detail/error_info_impl.hpp b/contrib/libboost/boost_1_65_0/boost/exception/detail/error_info_impl.hpp
similarity index 60%
rename from contrib/libboost/boost_1_62_0/boost/exception/detail/error_info_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/detail/error_info_impl.hpp
index dbe0afdb217..6c48d61ab35 100644
--- a/contrib/libboost/boost_1_62_0/boost/exception/detail/error_info_impl.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/exception/detail/error_info_impl.hpp
@@ -5,6 +5,14 @@
 
 #ifndef UUID_CE6983AC753411DDA764247956D89593
 #define UUID_CE6983AC753411DDA764247956D89593
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#include <boost/type_traits/is_nothrow_move_constructible.hpp>
+#endif
+#include <utility>
+#include <string>
+
 #if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
 #pragma GCC system_header
 #endif
@@ -12,10 +20,6 @@
 #pragma warning(push,1)
 #endif
 
-#include <boost/config.hpp>
-#include <utility>
-#include <string>
-
 namespace
 boost
     {
@@ -28,8 +32,7 @@ boost
             public:
 
             virtual std::string name_value_string() const = 0;
-
-            protected:
+            virtual error_info_base * clone() const = 0;
 
             virtual
             ~error_info_base() throw()
@@ -43,39 +46,53 @@ boost
     error_info:
         public exception_detail::error_info_base
         {
-		public:
-
+        error_info_base *
+        clone() const
+            {
+            return new error_info<Tag,T>(*this);
+            }
+        public:
         typedef T value_type;
-
-        error_info( value_type const & value );
+        error_info( value_type const & v ):
+            v_(v)
+            {
+            }
+#if (__GNUC__*100+__GNUC_MINOR__!=406) //workaround for g++ bug
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-        error_info( error_info const & );
-        error_info( value_type && value ) BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(value_type(std::move(value))));
-        error_info( error_info && x ) BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(value_type(std::move(x.value_))));
+        error_info( error_info const & x ):
+            v_(x.v_)
+            {
+            }
+        error_info( T && v ) BOOST_NOEXCEPT_IF(boost::is_nothrow_move_constructible<T>::value):
+            v_(std::move(v))
+            {
+            }
+        error_info( error_info && x ) BOOST_NOEXCEPT_IF(boost::is_nothrow_move_constructible<T>::value):
+            v_(std::move(x.v_))
+            {
+            }
 #endif
-        ~error_info() throw();
-
+#endif
+        ~error_info() throw()
+            {
+            }
         value_type const &
         value() const
             {
-            return value_;
+            return v_;
             }
-
         value_type &
         value()
             {
-            return value_;
+            return v_;
             }
-
-		private:
+        private:
         error_info & operator=( error_info const & );
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
         error_info & operator=( error_info && x );
 #endif
-
         std::string name_value_string() const;
-
-        value_type value_;
+        value_type v_;
         };
     }
 
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/detail/exception_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/exception/detail/exception_ptr.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/exception/detail/exception_ptr.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/detail/exception_ptr.hpp
index cac64e6ab36..8e19f0d9df3 100644
--- a/contrib/libboost/boost_1_62_0/boost/exception/detail/exception_ptr.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/exception/detail/exception_ptr.hpp
@@ -5,12 +5,6 @@
 
 #ifndef UUID_618474C2DE1511DEB74A388C56D89593
 #define UUID_618474C2DE1511DEB74A388C56D89593
-#if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
-#pragma GCC system_header
-#endif
-#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
-#pragma warning(push,1)
-#endif
 
 #include <boost/config.hpp>
 #ifdef BOOST_NO_EXCEPTIONS
@@ -19,8 +13,8 @@
 #include <boost/exception/exception.hpp>
 #include <boost/exception/info.hpp>
 #include <boost/exception/diagnostic_information.hpp>
-#include <boost/exception/detail/type_info.hpp>
 #include <boost/exception/detail/clone_current_exception.hpp>
+#include <boost/exception/detail/type_info.hpp>
 #ifndef BOOST_NO_RTTI
 #include <boost/core/demangle.hpp>
 #endif
@@ -30,6 +24,13 @@
 #include <ios>
 #include <stdlib.h>
 
+#if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#pragma GCC system_header
+#endif
+#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#pragma warning(push,1)
+#endif
+
 namespace
 boost
     {
@@ -394,7 +395,7 @@ boost
                         {
                         return exception_detail::current_exception_std_exception(e);
                         }
-#ifndef BOOST_NO_TYPEID
+        #ifndef BOOST_NO_TYPEID
                     catch(
                     std::bad_cast & e )
                         {
@@ -405,7 +406,7 @@ boost
                         {
                         return exception_detail::current_exception_std_exception(e);
                         }
-#endif
+        #endif
                     catch(
                     std::bad_exception & e )
                         {
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/detail/is_output_streamable.hpp b/contrib/libboost/boost_1_65_0/boost/exception/detail/is_output_streamable.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/exception/detail/is_output_streamable.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/detail/is_output_streamable.hpp
index 847f3484b84..10e5c5163ee 100644
--- a/contrib/libboost/boost_1_62_0/boost/exception/detail/is_output_streamable.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/exception/detail/is_output_streamable.hpp
@@ -5,6 +5,9 @@
 
 #ifndef UUID_898984B4076411DD973EDFA055D89593
 #define UUID_898984B4076411DD973EDFA055D89593
+
+#include <ostream>
+
 #if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
 #pragma GCC system_header
 #endif
@@ -12,8 +15,6 @@
 #pragma warning(push,1)
 #endif
 
-#include <ostream>
-
 namespace
 boost
     {
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/detail/object_hex_dump.hpp b/contrib/libboost/boost_1_65_0/boost/exception/detail/object_hex_dump.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/exception/detail/object_hex_dump.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/detail/object_hex_dump.hpp
index 53c8bf6f360..267bf0bf3e1 100644
--- a/contrib/libboost/boost_1_62_0/boost/exception/detail/object_hex_dump.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/exception/detail/object_hex_dump.hpp
@@ -5,12 +5,6 @@
 
 #ifndef UUID_6F463AC838DF11DDA3E6909F56D89593
 #define UUID_6F463AC838DF11DDA3E6909F56D89593
-#if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
-#pragma GCC system_header
-#endif
-#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
-#pragma warning(push,1)
-#endif
 
 #include <boost/exception/detail/type_info.hpp>
 #include <iomanip>
@@ -19,6 +13,13 @@
 #include <sstream>
 #include <cstdlib>
 
+#if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#pragma GCC system_header
+#endif
+#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#pragma warning(push,1)
+#endif
+
 namespace
 boost
     {
diff --git a/contrib/libboost/boost_1_65_0/boost/exception/detail/shared_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/exception/detail/shared_ptr.hpp
new file mode 100644
index 00000000000..51febe8c8fb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/exception/detail/shared_ptr.hpp
@@ -0,0 +1,17 @@
+//Copyright (c) 2006-2008 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_837060E885AF11E68DA91D15E31AC075
+#define UUID_837060E885AF11E68DA91D15E31AC075
+
+#ifdef BOOST_EXCEPTION_MINI_BOOST
+#include  <memory>
+namespace boost { namespace exception_detail { using std::shared_ptr; } }
+#else
+#include <boost/shared_ptr.hpp>
+namespace boost { namespace exception_detail { using boost::shared_ptr; } }
+#endif
+
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/detail/type_info.hpp b/contrib/libboost/boost_1_65_0/boost/exception/detail/type_info.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/exception/detail/type_info.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/detail/type_info.hpp
index b8c7d48baed..739ac5748e2 100644
--- a/contrib/libboost/boost_1_62_0/boost/exception/detail/type_info.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/exception/detail/type_info.hpp
@@ -5,6 +5,13 @@
 
 #ifndef UUID_C3E1741C754311DDB2834CCA55D89593
 #define UUID_C3E1741C754311DDB2834CCA55D89593
+
+#include <boost/config.hpp>
+#include <boost/core/typeinfo.hpp>
+#include <boost/core/demangle.hpp>
+#include <boost/current_function.hpp>
+#include <string>
+
 #if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
 #pragma GCC system_header
 #endif
@@ -12,12 +19,6 @@
 #pragma warning(push,1)
 #endif
 
-#include <boost/core/typeinfo.hpp>
-#include <boost/core/demangle.hpp>
-#include <boost/current_function.hpp>
-#include <boost/config.hpp>
-#include <string>
-
 namespace
 boost
     {
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/diagnostic_information.hpp b/contrib/libboost/boost_1_65_0/boost/exception/diagnostic_information.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/exception/diagnostic_information.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/diagnostic_information.hpp
index 305e8edd61f..48f06a0fb98 100644
--- a/contrib/libboost/boost_1_62_0/boost/exception/diagnostic_information.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/exception/diagnostic_information.hpp
@@ -5,12 +5,6 @@
 
 #ifndef UUID_0552D49838DD11DD90146B8956D89593
 #define UUID_0552D49838DD11DD90146B8956D89593
-#if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
-#pragma GCC system_header
-#endif
-#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
-#pragma warning(push,1)
-#endif
 
 #include <boost/config.hpp>
 #include <boost/exception/get_error_info.hpp>
@@ -22,9 +16,18 @@
 #include <exception>
 #include <sstream>
 #include <string>
-
 #ifndef BOOST_NO_EXCEPTIONS
 #include <boost/exception/current_exception_cast.hpp>
+#endif
+
+#if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#pragma GCC system_header
+#endif
+#if defined(_MSC_VER) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
+#pragma warning(push,1)
+#endif
+
+#ifndef BOOST_NO_EXCEPTIONS
 namespace
 boost
     {
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/enable_current_exception.hpp b/contrib/libboost/boost_1_65_0/boost/exception/enable_current_exception.hpp
similarity index 72%
rename from contrib/libboost/boost_1_62_0/boost/exception/enable_current_exception.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/enable_current_exception.hpp
index 988105378cc..495cc90a598 100644
--- a/contrib/libboost/boost_1_62_0/boost/exception/enable_current_exception.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/exception/enable_current_exception.hpp
@@ -3,4 +3,9 @@
 //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 UUID_851700A4F7CF11E6B2EE06DD14915323
+#define UUID_851700A4F7CF11E6B2EE06DD14915323
+
 #include <boost/exception/exception.hpp>
+
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/enable_error_info.hpp b/contrib/libboost/boost_1_65_0/boost/exception/enable_error_info.hpp
similarity index 72%
rename from contrib/libboost/boost_1_62_0/boost/exception/enable_error_info.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/enable_error_info.hpp
index 988105378cc..202217af66a 100644
--- a/contrib/libboost/boost_1_62_0/boost/exception/enable_error_info.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/exception/enable_error_info.hpp
@@ -3,4 +3,9 @@
 //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 UUID_A0F7404AF7CF11E6908227DD14915323
+#define UUID_A0F7404AF7CF11E6908227DD14915323
+
 #include <boost/exception/exception.hpp>
+
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/errinfo_api_function.hpp b/contrib/libboost/boost_1_65_0/boost/exception/errinfo_api_function.hpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/boost/exception/errinfo_api_function.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/errinfo_api_function.hpp
index 481c61314e3..0cbbdb90cac 100644
--- a/contrib/libboost/boost_1_62_0/boost/exception/errinfo_api_function.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/exception/errinfo_api_function.hpp
@@ -6,7 +6,7 @@
 #ifndef UUID_DDFBB4546C1211DEA4659E9055D89593
 #define UUID_DDFBB4546C1211DEA4659E9055D89593
 
-#include "boost/exception/error_info.hpp"
+#include <boost/exception/error_info.hpp>
 
 namespace
 boost
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/errinfo_at_line.hpp b/contrib/libboost/boost_1_65_0/boost/exception/errinfo_at_line.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/exception/errinfo_at_line.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/errinfo_at_line.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/errinfo_errno.hpp b/contrib/libboost/boost_1_65_0/boost/exception/errinfo_errno.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/exception/errinfo_errno.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/errinfo_errno.hpp
index 657b5f76d53..ebd8f25fbc3 100644
--- a/contrib/libboost/boost_1_62_0/boost/exception/errinfo_errno.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/exception/errinfo_errno.hpp
@@ -5,6 +5,11 @@
 
 #ifndef UUID_F0EE17BE6C1211DE87FF459155D89593
 #define UUID_F0EE17BE6C1211DE87FF459155D89593
+
+#include <boost/exception/info.hpp>
+#include <errno.h>
+#include <string.h>
+
 #if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
 #pragma GCC system_header
 #endif
@@ -13,10 +18,6 @@
 #pragma warning(disable:4996)
 #endif
 
-#include "boost/exception/info.hpp"
-#include <errno.h>
-#include <string.h>
-
 namespace
 boost
     {
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/errinfo_file_handle.hpp b/contrib/libboost/boost_1_65_0/boost/exception/errinfo_file_handle.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/exception/errinfo_file_handle.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/errinfo_file_handle.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/errinfo_file_name.hpp b/contrib/libboost/boost_1_65_0/boost/exception/errinfo_file_name.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/exception/errinfo_file_name.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/errinfo_file_name.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/errinfo_file_open_mode.hpp b/contrib/libboost/boost_1_65_0/boost/exception/errinfo_file_open_mode.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/exception/errinfo_file_open_mode.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/errinfo_file_open_mode.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/errinfo_nested_exception.hpp b/contrib/libboost/boost_1_65_0/boost/exception/errinfo_nested_exception.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/exception/errinfo_nested_exception.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/errinfo_nested_exception.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/errinfo_type_info_name.hpp b/contrib/libboost/boost_1_65_0/boost/exception/errinfo_type_info_name.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/exception/errinfo_type_info_name.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/errinfo_type_info_name.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/error_info.hpp b/contrib/libboost/boost_1_65_0/boost/exception/error_info.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/exception/error_info.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/error_info.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/exception.hpp b/contrib/libboost/boost_1_65_0/boost/exception/exception.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/exception/exception.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/exception.hpp
index 213af3dbb80..c0fdaf9e552 100644
--- a/contrib/libboost/boost_1_62_0/boost/exception/exception.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/exception/exception.hpp
@@ -12,6 +12,14 @@
 #pragma warning(push,1)
 #endif
 
+#ifdef BOOST_EXCEPTION_MINI_BOOST
+#include  <memory>
+namespace boost { namespace exception_detail { using std::shared_ptr; } }
+#else
+namespace boost { template <class T> class shared_ptr; };
+namespace boost { namespace exception_detail { using boost::shared_ptr; } }
+#endif
+
 namespace
 boost
     {
@@ -144,9 +152,6 @@ boost
 # endif
 #endif
 
-    template <class T>
-    class shared_ptr;
-
     namespace
     exception_detail
         {
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/get_error_info.hpp b/contrib/libboost/boost_1_65_0/boost/exception/get_error_info.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/exception/get_error_info.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/get_error_info.hpp
index 96be7632cb2..831717df596 100644
--- a/contrib/libboost/boost_1_62_0/boost/exception/get_error_info.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/exception/get_error_info.hpp
@@ -5,6 +5,14 @@
 
 #ifndef UUID_1A590226753311DD9E4CCF6156D89593
 #define UUID_1A590226753311DD9E4CCF6156D89593
+
+#include <boost/config.hpp>
+#include <boost/exception/exception.hpp>
+#include <boost/exception/detail/error_info_impl.hpp>
+#include <boost/exception/detail/type_info.hpp>
+#include <boost/exception/detail/shared_ptr.hpp>
+#include <boost/assert.hpp>
+
 #if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
 #pragma GCC system_header
 #endif
@@ -12,11 +20,6 @@
 #pragma warning(push,1)
 #endif
 
-#include <boost/exception/exception.hpp>
-#include <boost/exception/detail/error_info_impl.hpp>
-#include <boost/exception/detail/type_info.hpp>
-#include <boost/shared_ptr.hpp>
-
 namespace
 boost
     {
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/info.hpp b/contrib/libboost/boost_1_65_0/boost/exception/info.hpp
similarity index 69%
rename from contrib/libboost/boost_1_62_0/boost/exception/info.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/info.hpp
index f955e09845b..f7ac50ecfcd 100644
--- a/contrib/libboost/boost_1_62_0/boost/exception/info.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/exception/info.hpp
@@ -5,6 +5,14 @@
 
 #ifndef UUID_8D22C4CA9CC811DCAA9133D256D89593
 #define UUID_8D22C4CA9CC811DCAA9133D256D89593
+
+#include <boost/config.hpp>
+#include <boost/exception/exception.hpp>
+#include <boost/exception/to_string_stub.hpp>
+#include <boost/exception/detail/error_info_impl.hpp>
+#include <boost/exception/detail/shared_ptr.hpp>
+#include <map>
+
 #if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
 #pragma GCC system_header
 #endif
@@ -12,13 +20,6 @@
 #pragma warning(push,1)
 #endif
 
-#include <boost/exception/exception.hpp>
-#include <boost/exception/to_string_stub.hpp>
-#include <boost/exception/detail/error_info_impl.hpp>
-#include <boost/shared_ptr.hpp>
-#include <boost/config.hpp>
-#include <map>
-
 namespace
 boost
     {
@@ -38,45 +39,6 @@ boost
         return '[' + error_info_name(x) + "] = " + to_string_stub(x.value()) + '\n';
         }
 
-    template <class Tag,class T>
-    inline
-    error_info<Tag,T>::
-    error_info( value_type const & value ):
-        value_(value)
-        {
-        }
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-	template <class Tag,class T>
-    inline
-    error_info<Tag,T>::
-	error_info( error_info const & x ):
-		value_(x.value_)
-		{
-		}
-    template <class Tag,class T>
-    inline
-    error_info<Tag,T>::
-	error_info( value_type && value ) BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(value_type(std::move(value)))):
-		value_(std::move(value))
-		{
-		}
-	template <class Tag,class T>
-    inline
-    error_info<Tag,T>::
-	error_info( error_info && x ) BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(value_type(std::move(x.value_)))):
-		value_(std::move(x.value_))
-		{
-		}
-#endif
-
-    template <class Tag,class T>
-    inline
-    error_info<Tag,T>::
-    ~error_info() throw()
-        {
-        }
-
     template <class Tag,class T>
     inline
     std::string
@@ -180,7 +142,11 @@ boost
                 refcount_ptr<error_info_container> p;
                 error_info_container_impl * c=new error_info_container_impl;
                 p.adopt(c);
-                c->info_ = info_;
+                for( error_info_map::const_iterator i=info_.begin(),e=info_.end(); i!=e; ++i )
+                    {
+                    shared_ptr<error_info_base> cp(i->second->clone());
+                    c->info_.insert(std::make_pair(i->first,cp));
+                    }
                 return p;
                 }
             };
@@ -202,79 +168,79 @@ boost
 #ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
         template <class E,class Tag,class T>
         E const & set_info( E const &, error_info<Tag,T> && );
-		template <class T>
-		class set_info_rv;
-		template <class Tag,class T>
-		class
-		set_info_rv<error_info<Tag,T> >
-			{
-			template <class E,class Tag1,class T1>
-			friend E const & set_info( E const &, error_info<Tag1,T1> && );
-			template <class E>
-			static
-			E const &
-			set( E const & x, error_info<Tag,T> && v )
-				{
-				typedef error_info<Tag,T> error_info_tag_t;
-				shared_ptr<error_info_tag_t> p( new error_info_tag_t(std::move(v)) );
-				exception_detail::error_info_container * c=x.data_.get();
-				if( !c )
-					x.data_.adopt(c=new exception_detail::error_info_container_impl);
-				c->set(p,BOOST_EXCEPTION_STATIC_TYPEID(error_info_tag_t));
-				return x;
-				}
-			};
-		template <>
-		class
-		set_info_rv<throw_function>
-			{
-			template <class E,class Tag1,class T1>
-			friend E const & set_info( E const &, error_info<Tag1,T1> && );
-			template <class E>
-			static
-			E const &
-			set( E const & x, throw_function && y )
-				{
-				x.throw_function_=y.v_;
-				return x;
-				}
-			};
-		template <>
-		class
-		set_info_rv<throw_file>
-			{
-			template <class E,class Tag1,class T1>
-			friend E const & set_info( E const &, error_info<Tag1,T1> && );
-			template <class E>
-			static
-			E const &
-			set( E const & x, throw_file && y )
-				{
-				x.throw_file_=y.v_;
-				return x;
-				}
-			};
-		template <>
-		class
-		set_info_rv<throw_line>
-			{
-			template <class E,class Tag1,class T1>
-			friend E const & set_info( E const &, error_info<Tag1,T1> && );
-			template <class E>
-			static
-			E const &
-			set( E const & x, throw_line && y )
-				{
-				x.throw_line_=y.v_;
-				return x;
-				}
-			};
+        template <class T>
+        struct set_info_rv;
+        template <class Tag,class T>
+        struct
+        set_info_rv<error_info<Tag,T> >
+            {
+            template <class E,class Tag1,class T1>
+            friend E const & set_info( E const &, error_info<Tag1,T1> && );
+            template <class E>
+            static
+            E const &
+            set( E const & x, error_info<Tag,T> && v )
+                {
+                typedef error_info<Tag,T> error_info_tag_t;
+                shared_ptr<error_info_tag_t> p( new error_info_tag_t(std::move(v)) );
+                exception_detail::error_info_container * c=x.data_.get();
+                if( !c )
+                    x.data_.adopt(c=new exception_detail::error_info_container_impl);
+                c->set(p,BOOST_EXCEPTION_STATIC_TYPEID(error_info_tag_t));
+                return x;
+                }
+            };
+        template <>
+        struct
+        set_info_rv<throw_function>
+            {
+            template <class E,class Tag1,class T1>
+            friend E const & set_info( E const &, error_info<Tag1,T1> && );
+            template <class E>
+            static
+            E const &
+            set( E const & x, throw_function && y )
+                {
+                x.throw_function_=y.v_;
+                return x;
+                }
+            };
+        template <>
+        struct
+        set_info_rv<throw_file>
+            {
+            template <class E,class Tag1,class T1>
+            friend E const & set_info( E const &, error_info<Tag1,T1> && );
+            template <class E>
+            static
+            E const &
+            set( E const & x, throw_file && y )
+                {
+                x.throw_file_=y.v_;
+                return x;
+                }
+            };
+        template <>
+        struct
+        set_info_rv<throw_line>
+            {
+            template <class E,class Tag1,class T1>
+            friend E const & set_info( E const &, error_info<Tag1,T1> && );
+            template <class E>
+            static
+            E const &
+            set( E const & x, throw_line && y )
+                {
+                x.throw_line_=y.v_;
+                return x;
+                }
+            };
         template <class E,class Tag,class T>
         inline
         E const &
         set_info( E const & x, error_info<Tag,T> && v )
             {
-			return set_info_rv<error_info<Tag,T> >::template set<E>(x,std::move(v));
+            return set_info_rv<error_info<Tag,T> >::template set<E>(x,std::move(v));
             }
 #endif
 
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/info_tuple.hpp b/contrib/libboost/boost_1_65_0/boost/exception/info_tuple.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/exception/info_tuple.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/info_tuple.hpp
index 70154fd2787..7c16d751516 100644
--- a/contrib/libboost/boost_1_62_0/boost/exception/info_tuple.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/exception/info_tuple.hpp
@@ -5,6 +5,10 @@
 
 #ifndef UUID_63EE924290FB11DC87BB856555D89593
 #define UUID_63EE924290FB11DC87BB856555D89593
+
+#include <boost/exception/info.hpp>
+#include <boost/tuple/tuple.hpp>
+
 #if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
 #pragma GCC system_header
 #endif
@@ -12,9 +16,6 @@
 #pragma warning(push,1)
 #endif
 
-#include <boost/exception/info.hpp>
-#include <boost/tuple/tuple.hpp>
-
 namespace
 boost
     {
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/to_string.hpp b/contrib/libboost/boost_1_65_0/boost/exception/to_string.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/exception/to_string.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/to_string.hpp
index 68541d2b8cf..51425b10d16 100644
--- a/contrib/libboost/boost_1_62_0/boost/exception/to_string.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/exception/to_string.hpp
@@ -5,6 +5,11 @@
 
 #ifndef UUID_7E48761AD92811DC9011477D56D89593
 #define UUID_7E48761AD92811DC9011477D56D89593
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/exception/detail/is_output_streamable.hpp>
+#include <sstream>
+
 #if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
 #pragma GCC system_header
 #endif
@@ -12,10 +17,6 @@
 #pragma warning(push,1)
 #endif
 
-#include <boost/utility/enable_if.hpp>
-#include <boost/exception/detail/is_output_streamable.hpp>
-#include <sstream>
-
 namespace
 boost
     {
diff --git a/contrib/libboost/boost_1_62_0/boost/exception/to_string_stub.hpp b/contrib/libboost/boost_1_65_0/boost/exception/to_string_stub.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/exception/to_string_stub.hpp
rename to contrib/libboost/boost_1_65_0/boost/exception/to_string_stub.hpp
index b6ab31cf869..8ff5e47fd63 100644
--- a/contrib/libboost/boost_1_62_0/boost/exception/to_string_stub.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/exception/to_string_stub.hpp
@@ -5,6 +5,11 @@
 
 #ifndef UUID_E788439ED9F011DCB181F25B55D89593
 #define UUID_E788439ED9F011DCB181F25B55D89593
+
+#include <boost/exception/to_string.hpp>
+#include <boost/exception/detail/object_hex_dump.hpp>
+#include <boost/assert.hpp>
+
 #if (__GNUC__*100+__GNUC_MINOR__>301) && !defined(BOOST_EXCEPTION_ENABLE_WARNINGS)
 #pragma GCC system_header
 #endif
@@ -12,10 +17,6 @@
 #pragma warning(push,1)
 #endif
 
-#include <boost/exception/to_string.hpp>
-#include <boost/exception/detail/object_hex_dump.hpp>
-#include <boost/assert.hpp>
-
 namespace
 boost
     {
diff --git a/contrib/libboost/boost_1_62_0/boost/filesystem.hpp b/contrib/libboost/boost_1_65_0/boost/filesystem.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/filesystem.hpp
rename to contrib/libboost/boost_1_65_0/boost/filesystem.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/filesystem/config.hpp b/contrib/libboost/boost_1_65_0/boost/filesystem/config.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/filesystem/config.hpp
rename to contrib/libboost/boost_1_65_0/boost/filesystem/config.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/filesystem/convenience.hpp b/contrib/libboost/boost_1_65_0/boost/filesystem/convenience.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/filesystem/convenience.hpp
rename to contrib/libboost/boost_1_65_0/boost/filesystem/convenience.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/filesystem/detail/macro_value.hpp b/contrib/libboost/boost_1_65_0/boost/filesystem/detail/macro_value.hpp
new file mode 100644
index 00000000000..2c4a16a628e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/filesystem/detail/macro_value.hpp
@@ -0,0 +1,44 @@
+//  boost/filesystem/detail/macro_value.hpp  -------------------------------------------//
+
+//  (C) Copyright John Maddock 2001 - 2003 
+//  (C) Copyright Jens Maurer 2001 
+//  (C) Copyright Peter Dimov 2001 
+//  (C) Copyright Darin Adler 2001 
+//  (C) Copyright Beman Dawes 2002 
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+//  Library home page: http://www.boost.org/libs/filesystem
+
+//--------------------------------------------------------------------------------------// 
+
+#ifndef BOOST_FILESYSTEM_MACRO_VALUE_HPP
+#define BOOST_FILESYSTEM_MACRO_VALUE_HPP
+
+#include <boost/config.hpp>
+#include <boost/assert.hpp>
+#include <cstdlib>
+
+namespace boost
+{
+  namespace detail
+  {
+    inline const char* macro_value(const char* name, const char* value)
+    {
+      static const char* no_value = "[no value]";
+      static const char* not_defined = "[not defined]";
+
+      BOOST_ASSERT_MSG(name, "name argument must not be a null pointer");
+      BOOST_ASSERT_MSG(value, "value argument must not be a null pointer");
+
+      return strcmp(name, value + 1) 
+        ? ((*value && *(value+1)) ? (value+1) : no_value)
+        : not_defined; // name == value+1 so the macro is not defined
+    }
+  }  // detail
+}  // boost
+
+#define BOOST_MACRO_VALUE(X) boost::detail::macro_value(#X, BOOST_STRINGIZE(=X))
+
+#endif  // BOOST_FILESYSTEM_MACRO_VALUE_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/filesystem/detail/utf8_codecvt_facet.hpp b/contrib/libboost/boost_1_65_0/boost/filesystem/detail/utf8_codecvt_facet.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/filesystem/detail/utf8_codecvt_facet.hpp
rename to contrib/libboost/boost_1_65_0/boost/filesystem/detail/utf8_codecvt_facet.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/filesystem/exception.hpp b/contrib/libboost/boost_1_65_0/boost/filesystem/exception.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/filesystem/exception.hpp
rename to contrib/libboost/boost_1_65_0/boost/filesystem/exception.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/filesystem/fstream.hpp b/contrib/libboost/boost_1_65_0/boost/filesystem/fstream.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/filesystem/fstream.hpp
rename to contrib/libboost/boost_1_65_0/boost/filesystem/fstream.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/filesystem/operations.hpp b/contrib/libboost/boost_1_65_0/boost/filesystem/operations.hpp
similarity index 96%
rename from contrib/libboost/boost_1_62_0/boost/filesystem/operations.hpp
rename to contrib/libboost/boost_1_65_0/boost/filesystem/operations.hpp
index 47bc07476be..b0ea42a308a 100644
--- a/contrib/libboost/boost_1_62_0/boost/filesystem/operations.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/filesystem/operations.hpp
@@ -921,8 +921,8 @@ namespace detail
     friend BOOST_FILESYSTEM_DECL void detail::directory_iterator_increment(directory_iterator& it,
       system::error_code* ec);
 
-    // shared_ptr provides shallow-copy semantics required for InputIterators.
-    // m_imp.get()==0 indicates the end iterator.
+    // shared_ptr provides the shallow-copy semantics required for single pass iterators
+    // (i.e. InputIterators). The end iterator is indicated by !m_imp || !m_imp->handle
     boost::shared_ptr< detail::dir_itr_imp >  m_imp;
 
     friend class boost::iterator_core_access;
@@ -939,7 +939,11 @@ namespace detail
     void increment() { detail::directory_iterator_increment(*this, 0); }
 
     bool equal(const directory_iterator& rhs) const
-      { return m_imp == rhs.m_imp; }
+    { 
+      return m_imp == rhs.m_imp
+        || (!m_imp && rhs.m_imp && !rhs.m_imp->handle)
+        || (!rhs.m_imp && m_imp && !m_imp->handle);
+    }
 
   };  // directory_iterator
 
@@ -1029,41 +1033,43 @@ namespace filesystem
       //  taking symlinks and options into account.
 
       if ((m_options & symlink_option::_detail_no_push) == symlink_option::_detail_no_push)
-        m_options &= ~symlink_option::_detail_no_push;
-
-      else
       {
-        // Logic for following predicate was contributed by Daniel Aarno to handle cyclic
-        // symlinks correctly and efficiently, fixing ticket #5652.
-        //   if (((m_options & symlink_option::recurse) == symlink_option::recurse
-        //         || !is_symlink(m_stack.top()->symlink_status()))
-        //       && is_directory(m_stack.top()->status())) ...
-        // The predicate code has since been rewritten to pass error_code arguments,
-        // per ticket #5653.
+        m_options &= ~symlink_option::_detail_no_push;
+        return false;
+      }
 
-        file_status symlink_stat;
+      file_status symlink_stat;
 
-        if ((m_options & symlink_option::recurse) != symlink_option::recurse)
+      // if we are not recursing into symlinks, we are going to have to know if the
+      // stack top is a symlink, so get symlink_status and verify no error occurred 
+      if ((m_options & symlink_option::recurse) != symlink_option::recurse)
+      {
+        symlink_stat = m_stack.top()->symlink_status(ec);
+        if (ec)
+          return false;
+      }
+
+      // Logic for following predicate was contributed by Daniel Aarno to handle cyclic
+      // symlinks correctly and efficiently, fixing ticket #5652.
+      //   if (((m_options & symlink_option::recurse) == symlink_option::recurse
+      //         || !is_symlink(m_stack.top()->symlink_status()))
+      //       && is_directory(m_stack.top()->status())) ...
+      // The predicate code has since been rewritten to pass error_code arguments,
+      // per ticket #5653.
+
+      if ((m_options & symlink_option::recurse) == symlink_option::recurse
+        || !is_symlink(symlink_stat))
+      {
+        file_status stat = m_stack.top()->status(ec);
+        if (ec || !is_directory(stat))
+          return false;
+
+        directory_iterator next(m_stack.top()->path(), ec);
+        if (!ec && next != directory_iterator())
         {
-          symlink_stat = m_stack.top()->symlink_status(ec);
-          if (ec)
-            return false;
-        }
-
-        if ((m_options & symlink_option::recurse) == symlink_option::recurse
-          || !is_symlink(symlink_stat))
-        {
-          file_status stat = m_stack.top()->status(ec);
-          if (ec || !is_directory(stat))
-            return false;
-
-          directory_iterator next(m_stack.top()->path(), ec);
-          if (!ec && next != directory_iterator())
-          {
-            m_stack.push(next);
-            ++m_level;
-            return true;
-          }
+          m_stack.push(next);
+          ++m_level;
+          return true;
         }
       }
       return false;
@@ -1254,8 +1260,9 @@ namespace filesystem
 
   private:
 
-    // shared_ptr provides shallow-copy semantics required for InputIterators.
-    // m_imp.get()==0 indicates the end iterator.
+    // shared_ptr provides the shallow-copy semantics required for single pass iterators
+    // (i.e. InputIterators).
+    // The end iterator is indicated by !m_imp || m_imp->m_stack.empty()
     boost::shared_ptr< detail::recur_dir_itr_imp >  m_imp;
 
     friend class boost::iterator_core_access;
@@ -1281,7 +1288,11 @@ namespace filesystem
     }
 
     bool equal(const recursive_directory_iterator& rhs) const
-      { return m_imp == rhs.m_imp; }
+    {
+      return m_imp == rhs.m_imp
+        || (!m_imp && rhs.m_imp && rhs.m_imp->m_stack.empty())
+        || (!rhs.m_imp && m_imp && m_imp->m_stack.empty())        ;
+    }
 
   };  // recursive directory iterator
 
diff --git a/contrib/libboost/boost_1_62_0/boost/filesystem/path.hpp b/contrib/libboost/boost_1_65_0/boost/filesystem/path.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/filesystem/path.hpp
rename to contrib/libboost/boost_1_65_0/boost/filesystem/path.hpp
index af5bfcc8c29..65e27b17dac 100644
--- a/contrib/libboost/boost_1_62_0/boost/filesystem/path.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/filesystem/path.hpp
@@ -62,10 +62,14 @@ namespace filesystem
 
 # ifdef BOOST_WINDOWS_API
     typedef wchar_t                        value_type;
+    BOOST_STATIC_CONSTEXPR value_type      separator = L'/';
     BOOST_STATIC_CONSTEXPR value_type      preferred_separator = L'\\';
+    BOOST_STATIC_CONSTEXPR value_type      dot = L'.';
 # else 
     typedef char                           value_type;
+    BOOST_STATIC_CONSTEXPR value_type      separator = '/';
     BOOST_STATIC_CONSTEXPR value_type      preferred_separator = '/';
+    BOOST_STATIC_CONSTEXPR value_type      dot = '.';
 # endif
     typedef std::basic_string<value_type>  string_type;  
     typedef std::codecvt<wchar_t, char,
@@ -455,7 +459,7 @@ namespace filesystem
     //  Experimental generic function returning generic formatted path (i.e. separators
     //  are forward slashes). Motivation: simpler than a family of generic_*string
     //  functions.
-    path generic() const
+    path generic_path() const
     {
 #   ifdef BOOST_WINDOWS_API
       path tmp;
@@ -509,6 +513,8 @@ namespace filesystem
     //  -----  query  -----
 
     bool empty() const BOOST_NOEXCEPT{ return m_pathname.empty(); }
+    bool filename_is_dot() const;
+    bool filename_is_dot_dot() const;
     bool has_root_path() const       { return has_root_directory() || has_root_name(); }
     bool has_root_name() const       { return !root_name().empty(); }
     bool has_root_directory() const  { return !root_directory().empty(); }
@@ -570,6 +576,7 @@ namespace filesystem
     path&  remove_leaf()            { return remove_filename(); }
     path   leaf() const             { return filename(); }
     path   branch_path() const      { return parent_path(); }
+    path   generic() const          { return generic_path(); }
     bool   has_leaf() const         { return !m_pathname.empty(); }
     bool   has_branch_path() const  { return !parent_path().empty(); }
     bool   is_complete() const      { return is_absolute(); }
@@ -737,10 +744,6 @@ namespace filesystem
 
   }; // path::reverse_iterator
 
-  inline path::reverse_iterator path::rbegin() const { return reverse_iterator(end()); }
-  inline path::reverse_iterator path::rend() const   { return reverse_iterator(begin()); }
-
-
   //------------------------------------------------------------------------------------//
   //                                                                                    //
   //                              non-member functions                                  //
@@ -809,7 +812,7 @@ namespace filesystem
     p = str;
     return is;
   }
-  
+ 
   //  name_checks
 
   //  These functions are holdovers from version 1. It isn't clear they have much
@@ -821,6 +824,54 @@ namespace filesystem
   BOOST_FILESYSTEM_DECL bool portable_directory_name(const std::string & name);
   BOOST_FILESYSTEM_DECL bool portable_file_name(const std::string & name);
   BOOST_FILESYSTEM_DECL bool native(const std::string & name);
+
+  namespace detail
+  {
+    //  For POSIX, is_directory_separator() and is_element_separator() are identical since
+    //  a forward slash is the only valid directory separator and also the only valid
+    //  element separator. For Windows, forward slash and back slash are the possible
+    //  directory separators, but colon (example: "c:foo") is also an element separator.
+
+    inline bool is_directory_separator(path::value_type c) BOOST_NOEXCEPT
+    {
+      return c == path::separator
+#     ifdef BOOST_WINDOWS_API
+        || c == path::preferred_separator
+#     endif
+      ;
+    }
+    inline bool is_element_separator(path::value_type c) BOOST_NOEXCEPT
+    {
+      return c == path::separator
+#     ifdef BOOST_WINDOWS_API
+        || c == path::preferred_separator || c == L':'
+#     endif
+      ;
+    }
+  }  // namespace detail
+
+  //------------------------------------------------------------------------------------//
+  //                  class path miscellaneous function implementations                 //
+  //------------------------------------------------------------------------------------//
+
+  inline path::reverse_iterator path::rbegin() const { return reverse_iterator(end()); }
+  inline path::reverse_iterator path::rend() const   { return reverse_iterator(begin()); }
+
+  inline bool path::filename_is_dot() const
+  {
+    // implicit dot is tricky, so actually call filename(); see path::filename() example
+    // in reference.html 
+    path p(filename());
+    return p.size() == 1 && *p.c_str() == dot;
+  }
+
+  inline bool path::filename_is_dot_dot() const
+  {
+    return size() >= 2 && m_pathname[size()-1] == dot && m_pathname[size()-2] == dot
+      && (m_pathname.size() == 2 || detail::is_element_separator(m_pathname[size()-3]));
+      // use detail::is_element_separator() rather than detail::is_directory_separator
+      // to deal with "c:.." edge case on Windows when ':' acts as a separator
+  }
  
 //--------------------------------------------------------------------------------------//
 //                     class path member template implementation                        //
diff --git a/contrib/libboost/boost_1_62_0/boost/filesystem/path_traits.hpp b/contrib/libboost/boost_1_65_0/boost/filesystem/path_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/filesystem/path_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/filesystem/path_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/filesystem/string_file.hpp b/contrib/libboost/boost_1_65_0/boost/filesystem/string_file.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/filesystem/string_file.hpp
rename to contrib/libboost/boost_1_65_0/boost/filesystem/string_file.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/function.hpp b/contrib/libboost/boost_1_65_0/boost/function.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function.hpp
rename to contrib/libboost/boost_1_65_0/boost/function.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/function/detail/function_iterate.hpp b/contrib/libboost/boost_1_65_0/boost/function/detail/function_iterate.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function/detail/function_iterate.hpp
rename to contrib/libboost/boost_1_65_0/boost/function/detail/function_iterate.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/function/detail/gen_maybe_include.pl b/contrib/libboost/boost_1_65_0/boost/function/detail/gen_maybe_include.pl
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function/detail/gen_maybe_include.pl
rename to contrib/libboost/boost_1_65_0/boost/function/detail/gen_maybe_include.pl
diff --git a/contrib/libboost/boost_1_62_0/boost/function/detail/maybe_include.hpp b/contrib/libboost/boost_1_65_0/boost/function/detail/maybe_include.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function/detail/maybe_include.hpp
rename to contrib/libboost/boost_1_65_0/boost/function/detail/maybe_include.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/function/detail/prologue.hpp b/contrib/libboost/boost_1_65_0/boost/function/detail/prologue.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function/detail/prologue.hpp
rename to contrib/libboost/boost_1_65_0/boost/function/detail/prologue.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/function/function0.hpp b/contrib/libboost/boost_1_65_0/boost/function/function0.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function/function0.hpp
rename to contrib/libboost/boost_1_65_0/boost/function/function0.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/function/function1.hpp b/contrib/libboost/boost_1_65_0/boost/function/function1.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function/function1.hpp
rename to contrib/libboost/boost_1_65_0/boost/function/function1.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/function/function10.hpp b/contrib/libboost/boost_1_65_0/boost/function/function10.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function/function10.hpp
rename to contrib/libboost/boost_1_65_0/boost/function/function10.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/function/function2.hpp b/contrib/libboost/boost_1_65_0/boost/function/function2.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function/function2.hpp
rename to contrib/libboost/boost_1_65_0/boost/function/function2.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/function/function3.hpp b/contrib/libboost/boost_1_65_0/boost/function/function3.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function/function3.hpp
rename to contrib/libboost/boost_1_65_0/boost/function/function3.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/function/function4.hpp b/contrib/libboost/boost_1_65_0/boost/function/function4.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function/function4.hpp
rename to contrib/libboost/boost_1_65_0/boost/function/function4.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/function/function5.hpp b/contrib/libboost/boost_1_65_0/boost/function/function5.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function/function5.hpp
rename to contrib/libboost/boost_1_65_0/boost/function/function5.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/function/function6.hpp b/contrib/libboost/boost_1_65_0/boost/function/function6.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function/function6.hpp
rename to contrib/libboost/boost_1_65_0/boost/function/function6.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/function/function7.hpp b/contrib/libboost/boost_1_65_0/boost/function/function7.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function/function7.hpp
rename to contrib/libboost/boost_1_65_0/boost/function/function7.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/function/function8.hpp b/contrib/libboost/boost_1_65_0/boost/function/function8.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function/function8.hpp
rename to contrib/libboost/boost_1_65_0/boost/function/function8.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/function/function9.hpp b/contrib/libboost/boost_1_65_0/boost/function/function9.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function/function9.hpp
rename to contrib/libboost/boost_1_65_0/boost/function/function9.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/function/function_base.hpp b/contrib/libboost/boost_1_65_0/boost/function/function_base.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function/function_base.hpp
rename to contrib/libboost/boost_1_65_0/boost/function/function_base.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/function/function_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/function/function_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function/function_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/function/function_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/function/function_template.hpp b/contrib/libboost/boost_1_65_0/boost/function/function_template.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/function/function_template.hpp
rename to contrib/libboost/boost_1_65_0/boost/function/function_template.hpp
index 82c81d76973..7984c8323fe 100644
--- a/contrib/libboost/boost_1_62_0/boost/function/function_template.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/function/function_template.hpp
@@ -656,17 +656,6 @@ namespace boost {
     BOOST_FUNCTION_TEMPLATE_PARMS
   >
   class BOOST_FUNCTION_FUNCTION : public function_base
-
-#if BOOST_FUNCTION_NUM_ARGS == 1
-
-    , public std::unary_function<T0,R>
-
-#elif BOOST_FUNCTION_NUM_ARGS == 2
-
-    , public std::binary_function<T0,T1,R>
-
-#endif
-
   {
   public:
 #ifndef BOOST_NO_VOID_RETURNS
diff --git a/contrib/libboost/boost_1_62_0/boost/function/function_typeof.hpp b/contrib/libboost/boost_1_65_0/boost/function/function_typeof.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function/function_typeof.hpp
rename to contrib/libboost/boost_1_65_0/boost/function/function_typeof.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/function/gen_function_N.pl b/contrib/libboost/boost_1_65_0/boost/function/gen_function_N.pl
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function/gen_function_N.pl
rename to contrib/libboost/boost_1_65_0/boost/function/gen_function_N.pl
diff --git a/contrib/libboost/boost_1_62_0/boost/function_equal.hpp b/contrib/libboost/boost_1_65_0/boost/function_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/function_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/function_equal.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/components.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/components.hpp
new file mode 100644
index 00000000000..6f22098d581
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/components.hpp
@@ -0,0 +1,424 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_COMPONENTS_HPP_INCLUDED
+#define BOOST_FT_COMPONENTS_HPP_INCLUDED
+
+#include <cstddef>
+
+#include <boost/config.hpp>
+
+#include <boost/detail/workaround.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+#include <boost/type_traits/integral_constant.hpp>
+
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/integral_c.hpp>
+#include <boost/mpl/vector/vector0.hpp>
+
+#if BOOST_WORKAROUND(__BORLANDC__, <= 0x565)
+#   include <boost/type_traits/remove_cv.hpp>
+
+#   include <boost/mpl/identity.hpp>
+#   include <boost/mpl/bitand.hpp>
+#   include <boost/mpl/vector/vector10.hpp>
+#   include <boost/mpl/front.hpp>
+#   include <boost/mpl/begin.hpp>
+#   include <boost/mpl/advance.hpp>
+#   include <boost/mpl/iterator_range.hpp>
+#   include <boost/mpl/joint_view.hpp>
+#   include <boost/mpl/equal_to.hpp>
+#   include <boost/mpl/copy.hpp>
+#   include <boost/mpl/front_inserter.hpp>
+
+#   include <boost/function_types/detail/classifier.hpp>
+#endif
+
+#ifndef BOOST_FT_NO_CV_FUNC_SUPPORT
+#   include <boost/mpl/remove.hpp>
+#endif
+
+#include <boost/function_types/config/config.hpp>
+
+#   if   BOOST_FT_MAX_ARITY < 10
+#     include <boost/mpl/vector/vector10.hpp>
+#   elif BOOST_FT_MAX_ARITY < 20
+#     include <boost/mpl/vector/vector20.hpp>
+#   elif BOOST_FT_MAX_ARITY < 30
+#     include <boost/mpl/vector/vector30.hpp>
+#   elif BOOST_FT_MAX_ARITY < 40
+#     include <boost/mpl/vector/vector40.hpp>
+#   elif BOOST_FT_MAX_ARITY < 50
+#     include <boost/mpl/vector/vector50.hpp>
+#   endif
+
+#include <boost/function_types/detail/class_transform.hpp>
+#include <boost/function_types/property_tags.hpp>
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+namespace boost 
+{ 
+  namespace function_types 
+  {
+
+    using mpl::placeholders::_;
+
+    template< typename T, typename ClassTypeTransform = add_reference<_> > 
+    struct components;
+
+    namespace detail 
+    {
+      template<typename T, typename L> struct components_impl;
+#if BOOST_WORKAROUND(__BORLANDC__, <= 0x565)
+      template<typename T, typename OrigT, typename L> struct components_bcc;
+#endif
+    }
+
+    template<typename T, typename ClassTypeTransform> 
+    struct components
+#if !BOOST_WORKAROUND(__BORLANDC__, <= 0x565)
+      : detail::components_impl<T, ClassTypeTransform>
+#else
+      : detail::components_bcc<typename remove_cv<T>::type,T,
+            ClassTypeTransform>
+#endif
+    { 
+      typedef components<T,ClassTypeTransform> type;
+
+      BOOST_MPL_AUX_LAMBDA_SUPPORT(2,components,(T,ClassTypeTransform))
+    };
+
+// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+
+  namespace detail {
+
+    struct components_mpl_sequence_tag; 
+
+    struct components_non_func_base
+    {
+      typedef mpl::vector0<> types;
+      typedef void function_arity;
+
+      typedef detail::constant<0> bits;
+      typedef detail::constant<0> mask;
+
+      typedef components_mpl_sequence_tag tag;
+    };
+
+    template
+    < typename Components
+    , typename IfTagged
+    , typename ThenTag
+    , typename DefaultBase = components_non_func_base
+    >
+    struct retagged_if
+      : mpl::if_
+        < detail::represents_impl<Components, IfTagged>
+        , detail::changed_tag<Components,IfTagged,ThenTag>
+        , DefaultBase
+        >::type
+    { };
+
+    // We detect plain function types and function references as function 
+    // pointers by recursive instantiation of components_impl. 
+    // The third specialization of components_impl makes sure the recursion 
+    // terminates (when adding pointers).
+    template<typename T, typename L>
+    struct components_impl
+      : detail::retagged_if
+        < detail::components_impl<T*,L>
+        , pointer_tag, /* --> */ function_tag >
+    { };
+    template<typename T, typename L>
+    struct components_impl<T&, L>
+      : detail::retagged_if
+        < detail::components_impl<T*,L>
+        , pointer_tag, /* --> */ reference_tag >
+    { };
+
+#if !BOOST_FT_NO_CV_FUNC_SUPPORT
+    // Retry the type with a member pointer attached to detect cv functions
+    class a_class;
+
+    template<typename Base, typename T, typename L>
+    struct cv_func_base
+      : detail::retagged_if<Base,member_pointer_tag,function_tag>
+    {
+      typedef typename
+        mpl::remove
+          < typename Base::types
+          , typename detail::class_transform<a_class,L>::type>::type
+      types;
+    };
+
+    template<typename T, typename L>
+    struct components_impl<T*, L>
+      : mpl::if_
+        < detail::represents_impl< detail::components_impl<T a_class::*, L>
+                                 , member_pointer_tag >
+        , detail::cv_func_base< detail::components_impl<T a_class::*, L>, T, L>
+        , components_non_func_base
+        >::type
+    { };
+
+    template<typename T, typename L>
+    struct components_impl<T a_class::*, L>
+      : components_non_func_base
+    { };
+#else
+    template<typename T, typename L>
+    struct components_impl<T*, L>
+      : components_non_func_base
+    { }; 
+#endif
+
+    template<typename T, typename L>
+    struct components_impl<T* const, L> 
+      : components_impl<T*,L>
+    { };
+
+    template<typename T, typename L>
+    struct components_impl<T* volatile, L> 
+      : components_impl<T*,L>
+    { };
+
+    template<typename T, typename L>
+    struct components_impl<T* const volatile, L> 
+      : components_impl<T*,L>
+    { };
+
+    template<typename T, typename L>
+    struct components_impl<T const, L> 
+      : components_impl<T,L>
+    { };
+
+    template<typename T, typename L>
+    struct components_impl<T volatile, L> 
+      : components_impl<T,L>
+    { };
+
+    template<typename T, typename L>
+    struct components_impl<T const volatile, L> 
+      : components_impl<T,L>
+    { };
+
+
+    template<typename T, class C>
+    struct member_obj_ptr_result
+    { typedef T & type; };
+
+    template<typename T, class C>
+    struct member_obj_ptr_result<T, C const>
+    { typedef T const & type; };
+
+    template<typename T, class C>
+    struct member_obj_ptr_result<T, C volatile>
+    { typedef T volatile & type; };
+
+    template<typename T, class C>
+    struct member_obj_ptr_result<T, C const volatile>
+    { typedef T const volatile & type; };
+
+    template<typename T, class C>
+    struct member_obj_ptr_result<T &, C>
+    { typedef T & type; };
+
+    template<typename T, class C>
+    struct member_obj_ptr_result<T &, C const>
+    { typedef T & type; };
+
+    template<typename T, class C>
+    struct member_obj_ptr_result<T &, C volatile>
+    { typedef T & type; };
+
+    template<typename T, class C>
+    struct member_obj_ptr_result<T &, C const volatile>
+    { typedef T & type; };
+
+    template<typename T, class C, typename L>
+    struct member_obj_ptr_components
+      : member_object_pointer_base
+    {
+      typedef function_types::components<T C::*, L> type;
+      typedef components_mpl_sequence_tag tag;
+
+      typedef mpl::integral_c<std::size_t,1> function_arity;
+
+      typedef mpl::vector2< typename detail::member_obj_ptr_result<T,C>::type,
+          typename detail::class_transform<C,L>::type > types;
+    };
+
+#if !BOOST_WORKAROUND(__BORLANDC__, <= 0x565)
+#   define BOOST_FT_variations BOOST_FT_pointer|BOOST_FT_member_pointer
+
+    template<typename T, class C, typename L>
+    struct components_impl<T C::*, L>
+      : member_obj_ptr_components<T,C,L>
+    { };
+
+#else  
+#   define BOOST_FT_variations BOOST_FT_pointer
+
+    // This workaround removes the member pointer from the type to allow 
+    // detection of member function pointers with BCC. 
+    template<typename T, typename C, typename L>
+    struct components_impl<T C::*, L>
+      : detail::retagged_if
+        < detail::components_impl<typename boost::remove_cv<T>::type *, L>
+        , pointer_tag, /* --> */ member_function_pointer_tag
+        , member_obj_ptr_components<T,C,L> >
+    { };
+
+    // BCC lets us test the cv-qualification of a function type by template 
+    // partial specialization - so we use this bug feature to find out the 
+    // member function's cv-qualification (unfortunately there are some 
+    // invisible modifiers that impose some limitations on these types even if
+    // we remove the qualifiers, So we cannot exploit the same bug to make the 
+    // library work for cv-qualified function types).
+    template<typename T> struct encode_cv
+    { typedef char (& type)[1]; BOOST_STATIC_CONSTANT(std::size_t, value = 1); };
+    template<typename T> struct encode_cv<T const *>
+    { typedef char (& type)[2]; BOOST_STATIC_CONSTANT(std::size_t, value = 2); };
+    template<typename T> struct encode_cv<T volatile *>
+    { typedef char (& type)[3]; BOOST_STATIC_CONSTANT(std::size_t, value = 3); };
+    template<typename T> struct encode_cv<T const volatile *> 
+    { typedef char (& type)[4]; BOOST_STATIC_CONSTANT(std::size_t, value = 4); };
+
+    // For member function pointers we have to use a function template (partial
+    // template specialization for a member pointer drops the cv qualification 
+    // of the function type).
+    template<typename T, typename C>
+    typename encode_cv<T *>::type mfp_cv_tester(T C::*);
+
+    template<typename T> struct encode_mfp_cv
+    { 
+      BOOST_STATIC_CONSTANT(std::size_t, value = 
+          sizeof(detail::mfp_cv_tester((T)0L))); 
+    };
+
+    // Associate bits with the CV codes above.
+    template<std::size_t> struct cv_tag_mfp_impl;
+
+    template<typename T> struct cv_tag_mfp
+      : detail::cv_tag_mfp_impl
+        < ::boost::function_types::detail::encode_mfp_cv<T>::value >
+    { };
+
+    template<> struct cv_tag_mfp_impl<1> : non_cv              { };
+    template<> struct cv_tag_mfp_impl<2> : const_non_volatile  { };
+    template<> struct cv_tag_mfp_impl<3> : volatile_non_const  { };
+    template<> struct cv_tag_mfp_impl<4> : cv_qualified        { };
+
+    // Metafunction to decode the cv code and apply it to a type.
+    // We add a pointer, because otherwise cv-qualifiers won't stick (another bug).
+    template<typename T, std::size_t CV> struct decode_cv;
+
+    template<typename T> struct decode_cv<T,1> : mpl::identity<T *>          {};
+    template<typename T> struct decode_cv<T,2> : mpl::identity<T const *>    {};
+    template<typename T> struct decode_cv<T,3> : mpl::identity<T volatile *> {};
+    template<typename T> struct decode_cv<T,4> 
+                                         : mpl::identity<T const volatile *> {};
+
+    // The class type transformation comes after adding cv-qualifiers. We have
+    // wrap it to remove the pointer added in decode_cv_impl.
+    template<typename T, typename L> struct bcc_class_transform_impl;
+    template<typename T, typename L> struct bcc_class_transform_impl<T *, L>
+      : class_transform<T,L> 
+    { };
+
+    template<typename T, typename D, typename L> struct bcc_class_transform 
+      : bcc_class_transform_impl
+        < typename decode_cv
+          < T
+          , ::boost::function_types::detail::encode_mfp_cv<D>::value 
+          >::type
+        , L
+        > 
+    { };
+
+    // After extracting the member pointee from the type the class type is still
+    // in the type (somewhere -- you won't see with RTTI, that is) and that type
+    // is flagged unusable and *not* identical to the nonmember function type.
+    // We can, however, decompose this type via components_impl but surprisingly
+    // a pointer to the const qualified class type pops up again as the first 
+    // parameter type. 
+    // We have to replace this type with the properly cv-qualified and 
+    // transformed class type, integrate the cv qualification into the bits.
+    template<typename Base, typename MFP, typename OrigT, typename L>
+    struct mfp_components;
+
+
+    template<typename Base, typename T, typename C, typename OrigT, typename L>
+    struct mfp_components<Base,T C::*,OrigT,L> 
+    {
+    private:
+      typedef typename mpl::front<typename Base::types>::type result_type;
+      typedef typename detail::bcc_class_transform<C,OrigT,L>::type class_type;
+
+      typedef mpl::vector2<result_type, class_type> result_and_class_type;
+
+      typedef typename 
+        mpl::advance
+        < typename mpl::begin<typename Base::types>::type
+        , typename mpl::if_
+          < mpl::equal_to< typename detail::classifier<OrigT>::function_arity
+                         , typename Base::function_arity >
+          , mpl::integral_c<int,2> , mpl::integral_c<int,1> 
+          >::type
+        >::type
+      from;
+      typedef typename mpl::end<typename Base::types>::type to;
+
+      typedef mpl::iterator_range<from,to> param_types;
+
+      typedef mpl::joint_view< result_and_class_type, param_types> types_view;
+    public:
+
+      typedef typename 
+        mpl::reverse_copy<types_view, mpl::front_inserter< mpl::vector0<> > >::type 
+      types;
+
+      typedef typename 
+        function_types::tag< Base, detail::cv_tag_mfp<OrigT> >::bits 
+      bits;
+
+      typedef typename Base::mask mask;
+
+      typedef typename detail::classifier<OrigT>::function_arity function_arity;
+
+      typedef components_mpl_sequence_tag tag;
+    };
+
+    // Now put it all together: detect cv-qualification of function types and do
+    // the weird transformations above for member function pointers.
+    template<typename T, typename OrigT, typename L>
+    struct components_bcc
+      : mpl::if_
+        < detail::represents_impl< detail::components_impl<T,L>
+                                 , member_function_pointer_tag>
+        , detail::mfp_components<detail::components_impl<T,L>,T,OrigT,L>
+        , detail::components_impl<T,L>
+        >::type
+    { };
+
+#endif // end of BORLAND WORKAROUND
+
+#define BOOST_FT_al_path boost/function_types/detail/components_impl
+#include <boost/function_types/detail/pp_loop.hpp>
+
+  } } // namespace function_types::detail
+
+} // namespace ::boost
+
+#include <boost/function_types/detail/components_as_mpl_sequence.hpp>
+#include <boost/function_types/detail/retag_default_cc.hpp>
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/config/cc_names.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/config/cc_names.hpp
new file mode 100644
index 00000000000..ab69d646249
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/config/cc_names.hpp
@@ -0,0 +1,31 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_CONFIG_CC_NAMES_HPP_INCLUDED
+#define BOOST_FT_CONFIG_CC_NAMES_HPP_INCLUDED
+
+#define BOOST_FT_BUILTIN_CC_NAMES \
+  (( IMPLICIT           , implicit_cc , BOOST_PP_EMPTY                ))\
+  (( CDECL              , cdecl_cc    , BOOST_PP_IDENTITY(__cdecl   ) ))\
+  (( STDCALL            , stdcall_cc  , BOOST_PP_IDENTITY(__stdcall ) ))\
+  (( PASCAL             , pascal_cc   , BOOST_PP_IDENTITY(pascal    ) ))\
+  (( FASTCALL           , fastcall_cc , BOOST_PP_IDENTITY(__fastcall) ))\
+  (( CLRCALL            , clrcall_cc  , BOOST_PP_IDENTITY(__clrcall ) ))\
+  (( THISCALL           , thiscall_cc , BOOST_PP_IDENTITY(__thiscall) ))\
+  (( IMPLICIT_THISCALL  , thiscall_cc , BOOST_PP_EMPTY                )) 
+
+// append user-defined cc names to builtin ones
+#ifdef BOOST_FT_CC_NAMES 
+#   define BOOST_FT_CC_NAMES_SEQ BOOST_FT_BUILTIN_CC_NAMES BOOST_FT_CC_NAMES
+#   define BOOST_FT_CC_PREPROCESSING 1
+#else
+#   define BOOST_FT_CC_NAMES_SEQ BOOST_FT_BUILTIN_CC_NAMES
+#endif
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/config/compiler.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/config/compiler.hpp
new file mode 100644
index 00000000000..151c8567403
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/config/compiler.hpp
@@ -0,0 +1,116 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_CONFIG_COMPILER_HPP_INCLUDED
+#define BOOST_FT_CONFIG_COMPILER_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if defined(BOOST_MSVC)
+
+#   if BOOST_MSVC < 1310
+#     error "unsupported compiler version"
+#   endif
+
+#   ifdef BOOST_FT_AUTODETECT_CALLING_CONVENTIONS
+
+      // enable clrcall calling covention (call to .NET managed code) when
+      // compiling with /clr 
+#     if BOOST_MSVC >= 1400 && defined(__cplusplus_cli)
+#       ifndef BOOST_FT_CC_CLRCALL
+#       define BOOST_FT_CC_CLRCALL callable_builtin
+#       endif
+#     endif
+
+      // Intel x86 architecture specific calling conventions
+#     ifdef _M_IX86
+#       define BOOST_FT_COMMON_X86_CCs callable_builtin
+#       if BOOST_MSVC < 1400
+          // version 7.1 is missing a keyword to specify the thiscall cc ...
+#         ifndef BOOST_FT_CC_IMPLICIT_THISCALL
+#         define BOOST_FT_CC_IMPLICIT_THISCALL non_variadic|member|callable_builtin
+#         ifndef BOOST_FT_CONFIG_OK
+#           pragma message("INFO| /Gd /Gr /Gz will compiler options will cause")
+#           pragma message("INFO| a compile error.")
+#           pragma message("INFO| Reconfigure Boost.FunctionTypes in this case.")
+#           pragma message("INFO| This message can be suppressed by defining")
+#           pragma message("INFO| BOOST_FT_CONFIG_OK.")
+#         endif
+#         endif
+#       else 
+          // ...introduced in version 8
+#         ifndef BOOST_FT_CC_THISCALL
+#         define BOOST_FT_CC_THISCALL non_variadic|member|callable_builtin
+#         endif
+#       endif
+#     endif
+#   endif
+
+#elif defined(__GNUC__) && !defined(BOOST_INTEL_LINUX)
+
+#   if __GNUC__ < 3
+#     error "unsupported compiler version"
+#   endif
+
+#   ifdef BOOST_FT_AUTODETECT_CALLING_CONVENTIONS
+
+#     if defined(__i386__)
+#       // see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=20439
+#       // see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=29328
+#       if BOOST_WORKAROUND(__GNUC__,BOOST_TESTED_AT(4))
+#         ifndef BOOST_FT_CC_IMPLICIT 
+#         define BOOST_FT_CC_IMPLICIT member|callable_builtin
+#         endif
+#         define BOOST_FT_COMMON_X86_CCs non_member|callable_builtin
+#       else
+#         define BOOST_FT_COMMON_X86_CCs callable_builtin
+#       endif
+#     else
+#       ifndef BOOST_FT_CC_IMPLICIT
+#       define BOOST_FT_CC_IMPLICIT callable_builtin
+#       endif
+#     endif
+#   endif
+
+#   if (defined(BOOST_FT_CC_CDECL) || defined(BOOST_FT_COMMON_X86_CCs)) \
+        && !defined(__cdecl)
+#     define __cdecl __attribute__((__cdecl__))
+#   endif
+#   if (defined(BOOST_FT_CC_STDCALL) || defined(BOOST_FT_COMMON_X86_CCs)) \
+        && !defined(__stdcall)
+#     define __stdcall __attribute__((__stdcall__))
+#   endif
+#   if (defined(BOOST_FT_CC_FASTCALL) || defined(BOOST_FT_COMMON_X86_CCs)) \
+        && !defined(__fastcall)
+#     define __fastcall __attribute__((__fastcall__))
+#   endif
+
+#elif defined(__BORLANDC__)
+
+#   if __BORLANDC__ < 0x550
+#     error "unsupported compiler version"
+#   elif __BORLANDC__ > 0x565
+#     pragma message("WARNING: library untested with this compiler version")
+#   endif
+
+#   ifdef BOOST_FT_AUTODETECT_CALLING_CONVENTIONS
+#     define BOOST_FT_COMMON_X86_CCs callable_builtin
+#   endif
+
+    // syntactic specialities of cc specifier
+#   define BOOST_FT_SYNTAX(result,lparen,cc_spec,type_mod,name,rparen) \
+                        result() cc_spec() lparen() type_mod() name() rparen()
+#else
+    // only enable default calling convention
+#   define BOOST_FT_CC_IMPLICIT callable_builtin
+#endif
+
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/config/config.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/config/config.hpp
new file mode 100644
index 00000000000..7ec8e1e8fe6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/config/config.hpp
@@ -0,0 +1,59 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_CONFIG_HPP_INCLUDED
+#define BOOST_FT_CONFIG_HPP_INCLUDED
+
+#include <boost/function_types/config/compiler.hpp>
+#include <boost/function_types/config/cc_names.hpp>
+
+// maximum allowed arity
+#ifndef BOOST_FT_MAX_ARITY
+#define BOOST_FT_MAX_ARITY 20
+#endif
+
+// the most common calling conventions for x86 architecture can be enabled at
+// once in the compiler config
+#ifdef BOOST_FT_COMMON_X86_CCs
+#   ifndef BOOST_FT_CC_CDECL
+#   define BOOST_FT_CC_CDECL BOOST_FT_COMMON_X86_CCs
+#   endif
+#   ifndef BOOST_FT_CC_STDCALL
+#   define BOOST_FT_CC_STDCALL non_variadic|BOOST_FT_COMMON_X86_CCs
+#   endif
+#   ifndef BOOST_FT_CC_FASTCALL
+#   define BOOST_FT_CC_FASTCALL non_variadic|BOOST_FT_COMMON_X86_CCs
+#   endif
+#endif
+
+// where to place the cc specifier (the common way)
+#ifndef BOOST_FT_SYNTAX
+#   define BOOST_FT_SYNTAX(result,lparen,cc_spec,type_mod,name,rparen) \
+                        result() lparen() cc_spec() type_mod() name() rparen()
+#endif
+
+// param for nullary functions
+// set to "void" for compilers that require nullary functions to read 
+// "R (void)" in template partial specialization
+#ifndef BOOST_FT_NULLARY_PARAM
+#define BOOST_FT_NULLARY_PARAM 
+#endif
+
+// there is a pending defect report on cv qualified function types, so support
+// for these types is disabled, unless for compilers where it's known to work
+#ifndef BOOST_FT_NO_CV_FUNC_SUPPORT
+#define BOOST_FT_NO_CV_FUNC_SUPPORT 1
+#endif
+
+// full preprocessing implies preprocessing of the ccs
+#if defined(BOOST_FT_PREPROCESSING_MODE) && !defined(BOOST_FT_CC_PREPROCESSING)
+#   define BOOST_FT_CC_PREPROCESSING 1
+#endif
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/class_transform.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/class_transform.hpp
new file mode 100644
index 00000000000..27b97b3ff7f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/class_transform.hpp
@@ -0,0 +1,60 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_DETAIL_CLASS_TRANSFORM_HPP_INCLUDED
+#define BOOST_FT_DETAIL_CLASS_TRANSFORM_HPP_INCLUDED
+
+#include <boost/mpl/apply.hpp>
+#include <boost/mpl/always.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/placeholders.hpp>
+
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/add_pointer.hpp>
+#include <boost/type_traits/add_reference.hpp>
+
+namespace boost { namespace function_types { namespace detail {
+
+using mpl::placeholders::_;
+
+// Transformation metafunction for the class type of member function pointers.
+template<typename T, typename L>
+struct class_transform
+{ typedef typename mpl::apply1<L,T>::type type; };
+
+
+// We can short-circuit the mechanism implemented in the primary template for 
+// the most common lambda expression and save both the "un-lambdaing" and the
+// type traits invocation (we know that T can only be a class type).
+
+template<typename T> struct class_transform< T, mpl::identity<_> >
+{ typedef T type; };
+
+template<typename T> struct class_transform< T, add_reference<_> > 
+{ typedef T & type; };
+
+template<typename T> struct class_transform< T, add_pointer<_> >
+{ typedef T * type; };
+
+template<typename T> struct class_transform< T, remove_cv<_> >
+{ typedef typename boost::remove_cv<T>::type type; };
+
+template<typename T> struct class_transform< T, add_reference< remove_cv<_> > >
+{ typedef typename boost::remove_cv<T>::type & type; };
+
+template<typename T> struct class_transform< T, add_pointer< remove_cv<_> > >
+{ typedef typename boost::remove_cv<T>::type * type; };
+
+template<typename T, typename U> struct class_transform< T, mpl::always<U> >
+{ typedef U type; };
+
+
+} } } // namespace ::boost::function_types::detail
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier.hpp
new file mode 100644
index 00000000000..b5c5e71ebe5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier.hpp
@@ -0,0 +1,87 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_DETAIL_CLASSIFIER_HPP_INCLUDED
+#define BOOST_FT_DETAIL_CLASSIFIER_HPP_INCLUDED
+
+#include <boost/type.hpp>
+#include <boost/config.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/add_reference.hpp>
+
+#include <boost/function_types/config/config.hpp>
+#include <boost/function_types/property_tags.hpp>
+
+namespace boost { namespace function_types { namespace detail {
+
+template<typename T> struct classifier;
+
+template<std::size_t S> struct char_array { typedef char (&type)[S]; };
+
+template<bits_t Flags, bits_t CCID, std::size_t Arity> struct encode_charr
+{
+  typedef typename char_array<
+    ::boost::function_types::detail::encode_charr_impl<Flags,CCID,Arity>::value 
+  >::type type;
+};
+
+#if defined(BOOST_MSVC) || (defined(__BORLANDC__) && !defined(BOOST_DISABLE_WIN32))
+#   define BOOST_FT_DECL __cdecl
+#else
+#   define BOOST_FT_DECL /**/
+#endif
+
+char BOOST_FT_DECL classifier_impl(...);
+
+#define BOOST_FT_variations BOOST_FT_function|BOOST_FT_pointer|\
+                            BOOST_FT_member_pointer
+
+#define BOOST_FT_type_function(cc,name) BOOST_FT_SYNTAX( \
+    R BOOST_PP_EMPTY,BOOST_PP_LPAREN,cc,* BOOST_PP_EMPTY,name,BOOST_PP_RPAREN)
+
+#define BOOST_FT_type_function_pointer(cc,name) BOOST_FT_SYNTAX( \
+    R BOOST_PP_EMPTY,BOOST_PP_LPAREN,cc,** BOOST_PP_EMPTY,name,BOOST_PP_RPAREN)
+
+#define BOOST_FT_type_member_function_pointer(cc,name) BOOST_FT_SYNTAX( \
+    R BOOST_PP_EMPTY,BOOST_PP_LPAREN,cc,T0::** BOOST_PP_EMPTY,name,BOOST_PP_RPAREN)
+
+#define BOOST_FT_al_path boost/function_types/detail/classifier_impl
+#include <boost/function_types/detail/pp_loop.hpp>
+
+template<typename T> struct classifier_bits
+{
+  static typename boost::add_reference<T>::type tester;
+
+  BOOST_STATIC_CONSTANT(bits_t,value = (bits_t)sizeof(
+    boost::function_types::detail::classifier_impl(& tester) 
+  )-1);
+};
+
+template<typename T> struct classifier
+{
+  typedef detail::constant<
+    ::boost::function_types::detail::decode_bits<
+      ::boost::function_types::detail::classifier_bits<T>::value
+    >::tag_bits > 
+  bits;
+
+  typedef detail::full_mask mask;
+ 
+  typedef detail::constant<
+    ::boost::function_types::detail::decode_bits<
+      ::boost::function_types::detail::classifier_bits<T>::value
+    >::arity > 
+  function_arity;
+};
+
+
+
+} } } // namespace ::boost::function_types::detail
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity10_0.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity10_0.hpp
new file mode 100644
index 00000000000..e27f3c2d67a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity10_0.hpp
@@ -0,0 +1,55 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+template< typename R >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,0> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (BOOST_FT_nullary_param BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , typename T0 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,1> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , typename T0 , typename T1 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,2> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , typename T0 , typename T1 , typename T2 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,3> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,4> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,5> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,6> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,7> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,8> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,9> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,10> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 BOOST_FT_ell) BOOST_FT_cv);
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity10_1.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity10_1.hpp
new file mode 100644
index 00000000000..cca8027a006
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity10_1.hpp
@@ -0,0 +1,52 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+template< typename R , typename T0 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,1> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) ( BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , typename T0 , typename T1 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,2> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , typename T0 , typename T1 , typename T2 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,3> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,4> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,5> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,6> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,7> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,8> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,9> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,10> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 BOOST_FT_ell) BOOST_FT_cv);
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity20_0.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity20_0.hpp
new file mode 100644
index 00000000000..f7a25169e49
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity20_0.hpp
@@ -0,0 +1,53 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/classifier_impl/arity10_0.hpp>
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,11> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,12> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,13> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,14> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,15> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,16> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,17> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,18> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,19> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,20> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 BOOST_FT_ell) BOOST_FT_cv);
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity20_1.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity20_1.hpp
new file mode 100644
index 00000000000..1cee2ba35ac
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity20_1.hpp
@@ -0,0 +1,53 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/classifier_impl/arity10_1.hpp>
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,11> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,12> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,13> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,14> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,15> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,16> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,17> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,18> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,19> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,20> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 BOOST_FT_ell) BOOST_FT_cv);
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity30_0.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity30_0.hpp
new file mode 100644
index 00000000000..6bc60f86e80
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity30_0.hpp
@@ -0,0 +1,53 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/classifier_impl/arity20_0.hpp>
+template< typename R , 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 , typename T20 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,21> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,22> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,23> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,24> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,25> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,26> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,27> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,28> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,29> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,30> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 BOOST_FT_ell) BOOST_FT_cv);
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity30_1.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity30_1.hpp
new file mode 100644
index 00000000000..743c263bef0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity30_1.hpp
@@ -0,0 +1,53 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/classifier_impl/arity20_1.hpp>
+template< typename R , 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 , typename T20 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,21> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,22> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,23> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,24> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,25> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,26> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,27> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,28> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,29> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,30> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 BOOST_FT_ell) BOOST_FT_cv);
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity40_0.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity40_0.hpp
new file mode 100644
index 00000000000..161ac1751e6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity40_0.hpp
@@ -0,0 +1,53 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/classifier_impl/arity30_0.hpp>
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,31> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,32> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,33> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,34> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,35> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,36> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,37> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,38> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,39> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,40> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 BOOST_FT_ell) BOOST_FT_cv);
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity40_1.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity40_1.hpp
new file mode 100644
index 00000000000..e3a99887d46
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity40_1.hpp
@@ -0,0 +1,53 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/classifier_impl/arity30_1.hpp>
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,31> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,32> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,33> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,34> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,35> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,36> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,37> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,38> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,39> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,40> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 BOOST_FT_ell) BOOST_FT_cv);
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity50_0.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity50_0.hpp
new file mode 100644
index 00000000000..d05719a3f90
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity50_0.hpp
@@ -0,0 +1,53 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/classifier_impl/arity40_0.hpp>
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,41> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,42> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,43> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,44> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,45> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,46> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,47> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,48> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 , typename T48 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,49> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 , typename T48 , typename T49 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,50> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 , T49 BOOST_FT_ell) BOOST_FT_cv);
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity50_1.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity50_1.hpp
new file mode 100644
index 00000000000..944eabaa066
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/arity50_1.hpp
@@ -0,0 +1,52 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/classifier_impl/arity40_1.hpp>
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,41> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,42> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,43> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,44> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,45> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,46> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,47> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,48> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 , typename T48 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,49> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 BOOST_FT_ell) BOOST_FT_cv);
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 , typename T48 , typename T49 >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,50> ::type
+classifier_impl(BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 , T49 BOOST_FT_ell) BOOST_FT_cv);
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/master.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/master.hpp
new file mode 100644
index 00000000000..00b722e3456
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/classifier_impl/master.hpp
@@ -0,0 +1,33 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+#if BOOST_FT_ARITY_LOOP_PREFIX
+
+#   ifndef BOOST_FT_DETAIL_CLASSIFIER_IMPL_MASTER_HPP_INCLUDED
+#   define BOOST_FT_DETAIL_CLASSIFIER_IMPL_MASTER_HPP_INCLUDED
+#     include <boost/preprocessor/facilities/identity.hpp>
+#   endif
+
+#   define BOOST_FT_type_name
+
+#elif BOOST_FT_ARITY_LOOP_IS_ITERATING
+
+template< BOOST_FT_tplargs(BOOST_PP_IDENTITY(typename)) >
+typename encode_charr<BOOST_FT_flags,BOOST_FT_cc_id,BOOST_FT_arity>::type
+classifier_impl(BOOST_FT_type);
+
+#elif BOOST_FT_ARITY_LOOP_SUFFIX
+
+#   undef BOOST_FT_type_name
+
+#else
+#   error "attempt to use arity loop master file without loop"
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_as_mpl_sequence.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_as_mpl_sequence.hpp
new file mode 100644
index 00000000000..637b1b52bb5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_as_mpl_sequence.hpp
@@ -0,0 +1,138 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_DETAIL_COMPONENTS_AS_MPL_SEQUENCE_HPP_INCLUDED
+#define BOOST_FT_DETAIL_COMPONENTS_AS_MPL_SEQUENCE_HPP_INCLUDED
+
+#include <boost/mpl/size_fwd.hpp>
+#include <boost/mpl/empty_fwd.hpp>
+#include <boost/mpl/front_fwd.hpp>
+#include <boost/mpl/back_fwd.hpp>
+#include <boost/mpl/at_fwd.hpp>
+#include <boost/mpl/begin_end_fwd.hpp>
+#include <boost/mpl/clear_fwd.hpp>
+#include <boost/mpl/push_front_fwd.hpp>
+#include <boost/mpl/pop_front_fwd.hpp>
+#include <boost/mpl/push_back_fwd.hpp>
+#include <boost/mpl/pop_back_fwd.hpp>
+
+namespace boost { namespace mpl {
+
+template<> struct size_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S > struct apply
+    : mpl::size <typename S::types>
+  { };
+};
+template<> struct empty_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S > struct apply
+    : mpl::empty <typename S::types>
+  { };
+};
+template<> struct front_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S > struct apply
+    : mpl::front <typename S::types>
+  { };
+};
+template<> struct back_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S > struct apply
+    : mpl::back <typename S::types>
+  { };
+};
+template<> struct at_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S, typename N > struct apply
+    : mpl::at <typename S::types, N >
+  { };
+};
+template<> struct begin_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S > struct apply
+    : mpl::begin <typename S::types>
+  { };
+};
+template<> struct end_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S > struct apply
+    : mpl::end <typename S::types>
+  { };
+};
+template<> struct clear_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S >
+  struct apply
+    : S
+  {
+    typedef apply type;
+    typedef typename mpl::clear< typename S::types >::type types;
+  };
+};
+template<>
+struct push_front_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S, typename T >
+  struct apply
+    : S
+  { 
+    typedef apply type;
+    typedef typename mpl::push_front< typename S::types, T >::type types;
+  };
+};
+template<>
+struct pop_front_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S >
+  struct apply
+    : S
+  {
+    typedef apply type;
+    typedef typename mpl::pop_front< typename S::types >::type types; 
+  };
+};
+template<>
+struct push_back_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S, typename T >
+  struct apply
+    : S
+  {
+    typedef apply type;
+    typedef typename mpl::push_back< typename S::types, T >::type types; 
+  };
+};
+template<>
+struct pop_back_impl
+< function_types::detail::components_mpl_sequence_tag >
+{
+  template< typename S >
+  struct apply
+    : S
+  {
+    typedef apply type;
+    typedef typename mpl::pop_back< typename S::types >::type types; 
+  };
+};
+
+} } // namespace ::boost::mpl
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity10_0.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity10_0.hpp
new file mode 100644
index 00000000000..f96c6a9f73c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity10_0.hpp
@@ -0,0 +1,132 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+template< typename R, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (BOOST_FT_nullary_param BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (BOOST_FT_nullary_param BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,0> function_arity;
+typedef mpl::vector1< R BOOST_FT_nullary_param > types;
+};
+template< typename R , typename T0, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,1> function_arity;
+typedef mpl::vector2< R , T0 > types;
+};
+template< typename R , typename T0 , typename T1, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,2> function_arity;
+typedef mpl::vector3< R , T0 , T1 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,3> function_arity;
+typedef mpl::vector4< R , T0 , T1 , T2 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,4> function_arity;
+typedef mpl::vector5< R , T0 , T1 , T2 , T3 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,5> function_arity;
+typedef mpl::vector6< R , T0 , T1 , T2 , T3 , T4 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,6> function_arity;
+typedef mpl::vector7< R , T0 , T1 , T2 , T3 , T4 , T5 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,7> function_arity;
+typedef mpl::vector8< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,8> function_arity;
+typedef mpl::vector9< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,9> function_arity;
+typedef mpl::vector10< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,10> function_arity;
+typedef mpl::vector11< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
+};
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity10_1.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity10_1.hpp
new file mode 100644
index 00000000000..1b06a97a78f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity10_1.hpp
@@ -0,0 +1,122 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+template< typename R , typename T0, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) ( BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) ( BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,1> function_arity;
+typedef mpl::vector2< R, typename class_transform<T0 BOOST_FT_cv, L> ::type > types;
+};
+template< typename R , typename T0 , typename T1, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,2> function_arity;
+typedef mpl::vector3< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,3> function_arity;
+typedef mpl::vector4< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,4> function_arity;
+typedef mpl::vector5< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,5> function_arity;
+typedef mpl::vector6< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,6> function_arity;
+typedef mpl::vector7< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,7> function_arity;
+typedef mpl::vector8< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,8> function_arity;
+typedef mpl::vector9< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,9> function_arity;
+typedef mpl::vector10< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 > types;
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,10> function_arity;
+typedef mpl::vector11< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 > types;
+};
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity20_0.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity20_0.hpp
new file mode 100644
index 00000000000..f6b2ca8a442
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity20_0.hpp
@@ -0,0 +1,123 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/components_impl/arity10_0.hpp>
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,11> function_arity;
+typedef mpl::vector12< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
+};
+template< typename R , 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 L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,12> function_arity;
+typedef mpl::vector13< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
+};
+template< typename R , 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 L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,13> function_arity;
+typedef mpl::vector14< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
+};
+template< typename R , 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 L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,14> function_arity;
+typedef mpl::vector15< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
+};
+template< typename R , 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 L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,15> function_arity;
+typedef mpl::vector16< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
+};
+template< typename R , 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 L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,16> function_arity;
+typedef mpl::vector17< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
+};
+template< typename R , 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 L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,17> function_arity;
+typedef mpl::vector18< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
+};
+template< typename R , 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 L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,18> function_arity;
+typedef mpl::vector19< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
+};
+template< typename R , 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 L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,19> function_arity;
+typedef mpl::vector20< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
+};
+template< typename R , 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, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,20> function_arity;
+typedef mpl::vector21< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
+};
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity20_1.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity20_1.hpp
new file mode 100644
index 00000000000..1688e6b3ed2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity20_1.hpp
@@ -0,0 +1,123 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/components_impl/arity10_1.hpp>
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,11> function_arity;
+typedef mpl::vector12< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 > types;
+};
+template< typename R , 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 L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,12> function_arity;
+typedef mpl::vector13< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 > types;
+};
+template< typename R , 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 L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,13> function_arity;
+typedef mpl::vector14< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 > types;
+};
+template< typename R , 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 L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,14> function_arity;
+typedef mpl::vector15< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 > types;
+};
+template< typename R , 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 L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,15> function_arity;
+typedef mpl::vector16< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 > types;
+};
+template< typename R , 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 L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,16> function_arity;
+typedef mpl::vector17< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 > types;
+};
+template< typename R , 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 L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,17> function_arity;
+typedef mpl::vector18< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 > types;
+};
+template< typename R , 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 L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,18> function_arity;
+typedef mpl::vector19< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 > types;
+};
+template< typename R , 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 L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,19> function_arity;
+typedef mpl::vector20< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 > types;
+};
+template< typename R , 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, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,20> function_arity;
+typedef mpl::vector21< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 > types;
+};
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity30_0.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity30_0.hpp
new file mode 100644
index 00000000000..e85eb3a09cb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity30_0.hpp
@@ -0,0 +1,123 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/components_impl/arity20_0.hpp>
+template< typename R , 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 , typename T20, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,21> function_arity;
+typedef mpl::vector22< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 > types;
+};
+template< typename R , 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 , typename T20 , typename T21, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,22> function_arity;
+typedef mpl::vector23< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,23> function_arity;
+typedef mpl::vector24< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,24> function_arity;
+typedef mpl::vector25< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,25> function_arity;
+typedef mpl::vector26< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,26> function_arity;
+typedef mpl::vector27< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,27> function_arity;
+typedef mpl::vector28< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,28> function_arity;
+typedef mpl::vector29< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,29> function_arity;
+typedef mpl::vector30< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,30> function_arity;
+typedef mpl::vector31< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 > types;
+};
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity30_1.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity30_1.hpp
new file mode 100644
index 00000000000..290d21efa74
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity30_1.hpp
@@ -0,0 +1,123 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/components_impl/arity20_1.hpp>
+template< typename R , 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 , typename T20, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,21> function_arity;
+typedef mpl::vector22< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 > types;
+};
+template< typename R , 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 , typename T20 , typename T21, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,22> function_arity;
+typedef mpl::vector23< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,23> function_arity;
+typedef mpl::vector24< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,24> function_arity;
+typedef mpl::vector25< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,25> function_arity;
+typedef mpl::vector26< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,26> function_arity;
+typedef mpl::vector27< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,27> function_arity;
+typedef mpl::vector28< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,28> function_arity;
+typedef mpl::vector29< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,29> function_arity;
+typedef mpl::vector30< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,30> function_arity;
+typedef mpl::vector31< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 > types;
+};
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity40_0.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity40_0.hpp
new file mode 100644
index 00000000000..f1a2410173d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity40_0.hpp
@@ -0,0 +1,123 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/components_impl/arity30_0.hpp>
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,31> function_arity;
+typedef mpl::vector32< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,32> function_arity;
+typedef mpl::vector33< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,33> function_arity;
+typedef mpl::vector34< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,34> function_arity;
+typedef mpl::vector35< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,35> function_arity;
+typedef mpl::vector36< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,36> function_arity;
+typedef mpl::vector37< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,37> function_arity;
+typedef mpl::vector38< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,38> function_arity;
+typedef mpl::vector39< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,39> function_arity;
+typedef mpl::vector40< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,40> function_arity;
+typedef mpl::vector41< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 > types;
+};
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity40_1.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity40_1.hpp
new file mode 100644
index 00000000000..e1741cbbac7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity40_1.hpp
@@ -0,0 +1,123 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/components_impl/arity30_1.hpp>
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,31> function_arity;
+typedef mpl::vector32< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,32> function_arity;
+typedef mpl::vector33< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,33> function_arity;
+typedef mpl::vector34< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,34> function_arity;
+typedef mpl::vector35< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,35> function_arity;
+typedef mpl::vector36< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,36> function_arity;
+typedef mpl::vector37< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,37> function_arity;
+typedef mpl::vector38< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,38> function_arity;
+typedef mpl::vector39< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,39> function_arity;
+typedef mpl::vector40< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,40> function_arity;
+typedef mpl::vector41< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 > types;
+};
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity50_0.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity50_0.hpp
new file mode 100644
index 00000000000..693a05dfe15
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity50_0.hpp
@@ -0,0 +1,123 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/components_impl/arity40_0.hpp>
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,41> function_arity;
+typedef mpl::vector42< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,42> function_arity;
+typedef mpl::vector43< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,43> function_arity;
+typedef mpl::vector44< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,44> function_arity;
+typedef mpl::vector45< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,45> function_arity;
+typedef mpl::vector46< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,46> function_arity;
+typedef mpl::vector47< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,47> function_arity;
+typedef mpl::vector48< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,48> function_arity;
+typedef mpl::vector49< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 , typename T48, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,49> function_arity;
+typedef mpl::vector50< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 , typename T48 , typename T49, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 , T49 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 , T49 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,50> function_arity;
+typedef mpl::vector51< R , T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 , T49 > types;
+};
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity50_1.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity50_1.hpp
new file mode 100644
index 00000000000..9bc16162426
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/arity50_1.hpp
@@ -0,0 +1,123 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/components_impl/arity40_1.hpp>
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,41> function_arity;
+typedef mpl::vector42< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,42> function_arity;
+typedef mpl::vector43< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,43> function_arity;
+typedef mpl::vector44< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,44> function_arity;
+typedef mpl::vector45< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,45> function_arity;
+typedef mpl::vector46< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,46> function_arity;
+typedef mpl::vector47< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,47> function_arity;
+typedef mpl::vector48< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,48> function_arity;
+typedef mpl::vector49< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 , typename T48, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,49> function_arity;
+typedef mpl::vector50< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 > types;
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 , typename T48 , typename T49, typename L>
+struct components_impl<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 , T49 BOOST_FT_ell) BOOST_FT_cv, L>
+{
+typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+typedef constant<BOOST_FT_full_mask> mask;
+typedef function_types::components<BOOST_FT_syntax(BOOST_FT_cc, BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 , T49 BOOST_FT_ell) BOOST_FT_cv, L> type;
+typedef components_mpl_sequence_tag tag;
+typedef mpl::integral_c<std::size_t,50> function_arity;
+typedef mpl::vector51< R, typename class_transform<T0 BOOST_FT_cv, L> ::type , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 , T49 > types;
+};
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/master.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/master.hpp
new file mode 100644
index 00000000000..cd83726231b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/components_impl/master.hpp
@@ -0,0 +1,61 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+#if   BOOST_FT_ARITY_LOOP_PREFIX
+
+#   ifndef BOOST_FT_DETAIL_COMPONENTS_IMPL_MASTER_HPP_INCLUDED
+#   define BOOST_FT_DETAIL_COMPONENTS_IMPL_MASTER_HPP_INCLUDED
+#     include <boost/preprocessor/cat.hpp>
+#     include <boost/preprocessor/facilities/empty.hpp>
+#     include <boost/preprocessor/facilities/identity.hpp>
+#     include <boost/preprocessor/arithmetic/dec.hpp>
+#     include <boost/preprocessor/punctuation/comma_if.hpp>
+#   endif
+
+#   define BOOST_FT_type_name
+
+#   if !BOOST_FT_mfp
+
+#     define BOOST_FT_types \
+          R BOOST_PP_COMMA_IF(BOOST_FT_arity) BOOST_FT_params(BOOST_PP_EMPTY)
+#   else
+
+#     define BOOST_FT_types \
+          R, typename class_transform<T0 BOOST_FT_cv, L>::type \
+          BOOST_PP_COMMA_IF(BOOST_PP_DEC(BOOST_FT_arity)) \
+          BOOST_FT_params(BOOST_PP_EMPTY)
+
+#   endif
+
+#elif BOOST_FT_ARITY_LOOP_IS_ITERATING
+
+template< BOOST_FT_tplargs(BOOST_PP_IDENTITY(typename)), typename L>
+struct components_impl<BOOST_FT_type, L>
+{
+  typedef encode_bits<BOOST_FT_flags,BOOST_FT_cc_id> bits;
+  typedef constant<BOOST_FT_full_mask> mask;
+
+  typedef function_types::components<BOOST_FT_type, L> type;
+  typedef components_mpl_sequence_tag tag;
+
+  typedef mpl::integral_c<std::size_t,BOOST_FT_arity> function_arity;
+
+  typedef BOOST_PP_CAT(mpl::vector,BOOST_FT_n)< BOOST_FT_types > types;
+};
+
+#elif BOOST_FT_ARITY_LOOP_SUFFIX
+
+#   undef BOOST_FT_types
+#   undef BOOST_FT_type_name
+
+#else
+#   error "attempt to use arity loop master file without loop"
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/cv_traits.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/cv_traits.hpp
new file mode 100644
index 00000000000..4e15fa480cc
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/cv_traits.hpp
@@ -0,0 +1,132 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_DETAIL_CV_TRAITS_HPP_INCLUDED
+#define BOOST_FT_DETAIL_CV_TRAITS_HPP_INCLUDED
+
+#include <cstddef>
+#include <boost/detail/workaround.hpp>
+
+#if BOOST_WORKAROUND(__BORLANDC__, <= 0x582)
+#   include <boost/type_traits/remove_cv.hpp>
+#   include <boost/type_traits/remove_pointer.hpp>
+#   include <boost/type_traits/remove_reference.hpp>
+#endif
+
+#include <boost/function_types/property_tags.hpp>
+
+namespace boost { namespace function_types { namespace detail {
+
+#if !BOOST_WORKAROUND(__BORLANDC__, <= 0x582)
+
+template<typename T> struct cv_traits 
+{ typedef non_cv tag; typedef T type; };
+template<typename T> struct cv_traits<T &>     
+{ typedef non_cv tag; typedef T type; };
+template<typename T> struct cv_traits<T *>    
+{ typedef non_cv tag; typedef T type; };
+template<typename T> struct cv_traits<T * const> 
+{ typedef non_cv tag; typedef T type; };
+template<typename T> struct cv_traits<T * volatile> 
+{ typedef non_cv tag; typedef T type; };
+template<typename T> struct cv_traits<T * const volatile> 
+{ typedef non_cv tag; typedef T type; };
+
+template<typename T> struct cv_traits<T const> 
+{ typedef const_non_volatile tag; typedef T type; };
+template<typename T> struct cv_traits<T const &>
+{ typedef const_non_volatile tag; typedef T type; };
+template<typename T> struct cv_traits<T const *> 
+{ typedef const_non_volatile tag; typedef T type; };
+template<typename T> struct cv_traits<T const * const> 
+{ typedef const_non_volatile tag; typedef T type; };
+template<typename T> struct cv_traits<T const * volatile> 
+{ typedef const_non_volatile tag; typedef T type; };
+template<typename T> struct cv_traits<T const * const volatile> 
+{ typedef const_non_volatile tag; typedef T type; };
+
+template<typename T> struct cv_traits<T volatile>  
+{ typedef volatile_non_const tag; typedef T type; };
+template<typename T> struct cv_traits<T volatile &>  
+{ typedef volatile_non_const tag; typedef T type; };
+template<typename T> struct cv_traits<T volatile *> 
+{ typedef volatile_non_const tag; typedef T type; };
+template<typename T> struct cv_traits<T volatile * const> 
+{ typedef volatile_non_const tag; typedef T type; };
+template<typename T> struct cv_traits<T volatile * volatile> 
+{ typedef volatile_non_const tag; typedef T type; };
+template<typename T> struct cv_traits<T volatile * const volatile> 
+{ typedef volatile_non_const tag; typedef T type; };
+
+template<typename T> struct cv_traits<T const volatile>   
+{ typedef cv_qualified tag; typedef T type; };
+template<typename T> struct cv_traits<T const volatile &>
+{ typedef cv_qualified tag; typedef T type; };
+template<typename T> struct cv_traits<T const volatile *>
+{ typedef cv_qualified tag; typedef T type; };
+template<typename T> struct cv_traits<T const volatile * const>
+{ typedef cv_qualified tag; typedef T type; };
+template<typename T> struct cv_traits<T const volatile * volatile>
+{ typedef cv_qualified tag; typedef T type; };
+template<typename T> struct cv_traits<T const volatile * const volatile>
+{ typedef cv_qualified tag; typedef T type; };
+
+#else
+template<std::size_t> struct cv_tag_impl;
+
+template<> struct cv_tag_impl<1> { typedef non_cv type;};
+template<> struct cv_tag_impl<2> { typedef const_non_volatile type; };
+template<> struct cv_tag_impl<3> { typedef volatile_non_const type; };
+template<> struct cv_tag_impl<4> { typedef cv_qualified type; };
+
+typedef char (& case_1)[1];
+typedef char (& case_2)[2];
+typedef char (& case_3)[3];
+typedef char (& case_4)[4];
+
+template<typename T> case_1 switch_cv(T *);
+template<typename T> case_2 switch_cv(T const *);
+template<typename T> case_3 switch_cv(T volatile *);
+template<typename T> case_4 switch_cv(T const volatile *);
+
+template<typename T> T                * ref_to_ptr(T &);
+template<typename T> T const          * ref_to_ptr(T const &);
+template<typename T> T volatile       * ref_to_ptr(T volatile &);
+template<typename T> T const volatile * ref_to_ptr(T const volatile &);
+
+template<typename T> T                * ref_to_ptr(T * const volatile &);
+
+template<typename T>
+struct cv_code
+{
+  static T _t;
+  BOOST_STATIC_CONSTANT(std::size_t, value = 
+      sizeof(::boost::function_types::detail::switch_cv(
+         ::boost::function_types::detail::ref_to_ptr(_t) ) ));
+};
+
+template<typename T> struct cv_traits 
+{
+  typedef typename boost::function_types::detail::cv_tag_impl< 
+    ::boost::function_types::detail::cv_code<T>::value >::type
+  tag;
+
+  // may require Boost.TypeTraits broken compiler specializations
+  // to work
+  typedef typename boost::remove_cv<
+              typename boost::remove_pointer<
+                  typename boost::remove_reference<T>::type 
+              >::type 
+          >::type type; 
+};
+#endif
+
+} } } // namespace boost::function_types::detail
+
+#endif
+ 
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/encoding/aliases_def.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/encoding/aliases_def.hpp
new file mode 100644
index 00000000000..4d4833179c2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/encoding/aliases_def.hpp
@@ -0,0 +1,16 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusions
+
+#define callable_builtin BOOST_FT_callable_builtin
+#define member           BOOST_FT_member_pointer
+#define non_member       BOOST_FT_non_member
+#define variadic         BOOST_FT_variadic
+#define non_variadic     BOOST_FT_non_variadic
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/encoding/aliases_undef.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/encoding/aliases_undef.hpp
new file mode 100644
index 00000000000..1d4e577d80a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/encoding/aliases_undef.hpp
@@ -0,0 +1,16 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusions
+
+#undef callable_builtin
+#undef member
+#undef non_member
+#undef variadic
+#undef non_variadic
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/encoding/def.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/encoding/def.hpp
new file mode 100644
index 00000000000..08074fb38ba
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/encoding/def.hpp
@@ -0,0 +1,51 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusions
+
+// Type encoding:
+//
+// bit 0: callable builtin
+// bit 1: non member
+// bit 2: naked function
+// bit 3: pointer
+// bit 4: reference
+// bit 5: member pointer
+// bit 6: member function pointer
+// bit 7: member object pointer
+
+#define BOOST_FT_type_mask                            0x000000ff // 1111 1111 
+#define BOOST_FT_callable_builtin                     0x00000001 // 0000 0001
+#define BOOST_FT_non_member                           0x00000002 // 0000 0010
+#define BOOST_FT_function                             0x00000007 // 0000 0111
+#define BOOST_FT_pointer                              0x0000000b // 0000 1011
+#define BOOST_FT_reference                            0x00000013 // 0001 0011
+#define BOOST_FT_non_member_callable_builtin          0x00000003 // 0000 0011
+#define BOOST_FT_member_pointer                       0x00000020 // 0010 0000
+#define BOOST_FT_member_function_pointer              0x00000061 // 0110 0001
+#define BOOST_FT_member_object_pointer                0x000000a3 // 1010 0001
+#define BOOST_FT_member_object_pointer_flags          0x000002a3
+
+#define BOOST_FT_variadic                             0x00000100
+#define BOOST_FT_non_variadic                         0x00000200
+#define BOOST_FT_variadic_mask                        0x00000300
+
+#define BOOST_FT_const                                0x00000400
+#define BOOST_FT_volatile                             0x00000800
+
+#define BOOST_FT_default_cc                           0x00008000
+#define BOOST_FT_cc_mask                              0x00ff8000
+
+#define BOOST_FT_kind_mask                            0x000000fc 
+
+#define BOOST_FT_flags_mask                           0x00000fff
+#define BOOST_FT_full_mask                            0x00ff0fff
+
+#define BOOST_FT_arity_shift                          24
+#define BOOST_FT_arity_mask                           0x7f000000
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/encoding/undef.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/encoding/undef.hpp
new file mode 100644
index 00000000000..1920d6fcb1e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/encoding/undef.hpp
@@ -0,0 +1,38 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+#undef BOOST_FT_type_mask
+#undef BOOST_FT_kind_mask
+#undef BOOST_FT_callable_builtin
+#undef BOOST_FT_non_member
+#undef BOOST_FT_function
+#undef BOOST_FT_pointer
+#undef BOOST_FT_reference
+#undef BOOST_FT_non_member_callable_builtin
+#undef BOOST_FT_member_pointer
+#undef BOOST_FT_member_function_pointer
+#undef BOOST_FT_member_object_pointer
+#undef BOOST_FT_member_object_pointer_flags
+
+#undef BOOST_FT_variadic
+#undef BOOST_FT_non_variadic
+#undef BOOST_FT_variadic_mask
+
+#undef BOOST_FT_const
+#undef BOOST_FT_volatile
+
+#undef BOOST_FT_default_cc
+#undef BOOST_FT_cc_mask
+
+#undef BOOST_FT_flags_mask
+#undef BOOST_FT_full_mask
+
+#undef BOOST_FT_arity_mask
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_arity_loop.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_arity_loop.hpp
new file mode 100644
index 00000000000..b6dbff59f31
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_arity_loop.hpp
@@ -0,0 +1,149 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+#ifndef BOOST_FT_PREPROCESSING_MODE
+// input:  BOOST_FT_mfp        0 or 1 <=> member function pointer?
+// input:  BOOST_FT_type_name  BOOST_FT_type --> "R (* ..._type_name)()" (pass2)
+#endif
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+#ifdef __WAVE__
+#   pragma wave option(preserve: 0)
+#endif
+
+#ifndef BOOST_FT_ARITY_LOOP_IS_ITERATING
+
+#   define BOOST_FT_AL_PREPROCESSED \
+        BOOST_FT_AL_FILE(BOOST_FT_al_path,BOOST_FT_FROM_ARITY,BOOST_FT_mfp)
+
+#   define BOOST_FT_AL_FILE(base_path,max_arity,mfp) \
+        BOOST_FT_AL_FILE_I(base_path,max_arity,mfp)
+#   define BOOST_FT_AL_FILE_I(base_path,max_arity,mfp) \
+        <base_path/arity ## max_arity ## _ ## mfp.hpp>
+
+#   if !defined(BOOST_FT_PREPROCESSING_MODE)
+
+#     if BOOST_FT_MAX_ARITY < 10
+#       define BOOST_FT_FROM_ARITY 0 
+#     elif BOOST_FT_MAX_ARITY < 20
+#       define BOOST_FT_FROM_ARITY 10
+#     elif BOOST_FT_MAX_ARITY < 30
+#       define BOOST_FT_FROM_ARITY 20
+#     elif BOOST_FT_MAX_ARITY < 40
+#       define BOOST_FT_FROM_ARITY 30
+#     endif
+
+#     if BOOST_FT_FROM_ARITY
+#       include BOOST_FT_AL_PREPROCESSED
+#     endif
+
+#   elif !defined(BOOST_FT_FROM_ARITY) // single pass preprocessing
+#     define BOOST_FT_FROM_ARITY 0
+
+#   elif BOOST_FT_FROM_ARITY > 0       // arity20 includes arity10
+BOOST_PP_EXPAND(#) include BOOST_FT_AL_PREPROCESSED
+#   endif
+
+#   undef BOOST_FT_AL_PREPROCESSED
+
+#   undef BOOST_FT_AL_FILE
+#   undef BOOST_FT_AL_FILE_I
+
+#   if BOOST_FT_MAX_ARITY > BOOST_FT_FROM_ARITY
+
+#     ifndef BOOST_FT_DETAIL_ARITY_LOOP_HPP_INCLUDED
+#     define BOOST_FT_DETAIL_ARITY_LOOP_HPP_INCLUDED
+#         include <boost/preprocessor/cat.hpp>
+#         include <boost/preprocessor/tuple/eat.hpp>
+#         include <boost/preprocessor/control/if.hpp>
+#         include <boost/preprocessor/arithmetic/inc.hpp>
+#         include <boost/preprocessor/facilities/empty.hpp>
+#         include <boost/preprocessor/facilities/expand.hpp>
+#         include <boost/preprocessor/iteration/iterate.hpp>
+#         include <boost/preprocessor/repetition/enum_params.hpp>
+#         include <boost/preprocessor/repetition/enum_shifted_params.hpp>
+#         include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#     endif
+
+#     define BOOST_FT_AL_INCLUDE_FILE <BOOST_FT_al_path/master.hpp>
+
+#     define BOOST_FT_ARITY_LOOP_PREFIX 1
+#     include BOOST_FT_AL_INCLUDE_FILE
+#     undef  BOOST_FT_ARITY_LOOP_PREFIX
+
+#     if !BOOST_PP_IS_ITERATING
+#       define BOOST_PP_FILENAME_1 BOOST_FT_AL_INCLUDE_FILE
+#     elif BOOST_PP_ITERATION_DEPTH() == 1
+#       define BOOST_PP_FILENAME_2 BOOST_FT_AL_INCLUDE_FILE
+#     else
+#       error "loops nested too deeply"
+#     endif
+
+#     define BOOST_FT_arity BOOST_PP_ITERATION()
+#     define BOOST_FT_n     BOOST_PP_INC(BOOST_FT_arity)
+
+#     define BOOST_FT_type \
+          BOOST_FT_syntax(BOOST_FT_cc,BOOST_FT_type_name BOOST_PP_EMPTY)\
+               (BOOST_FT_params(BOOST_PP_EMPTY) BOOST_FT_ell) BOOST_FT_cv
+
+#     define BOOST_FT_tplargs(prefx) \
+          prefx() R BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_FT_arity,prefx() T)
+
+#     if !BOOST_FT_mfp
+
+#       define BOOST_FT_params(prefx) \
+            BOOST_PP_IF(BOOST_FT_arity,BOOST_PP_ENUM_PARAMS, \
+                BOOST_FT_nullary_param BOOST_PP_TUPLE_EAT(2))( \
+                    BOOST_FT_arity,prefx() T) 
+#     else
+
+#       define BOOST_FT_params(prefx) \
+            BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_FT_arity,prefx() T)
+
+#     endif
+
+#     if !BOOST_FT_FROM_ARITY 
+#       define BOOST_PP_ITERATION_LIMITS (BOOST_FT_mfp, BOOST_FT_MAX_ARITY)
+#     else
+#       define BOOST_PP_ITERATION_LIMITS \
+            (BOOST_FT_FROM_ARITY+1, BOOST_FT_MAX_ARITY)
+#     endif
+
+#     define BOOST_FT_ARITY_LOOP_IS_ITERATING 1
+#     include BOOST_PP_ITERATE()
+#     undef  BOOST_FT_ARITY_LOOP_IS_ITERATING
+
+#     undef BOOST_FT_arity
+#     undef BOOST_FT_params
+#     undef BOOST_FT_tplargs
+#     undef BOOST_FT_type
+
+#     define BOOST_FT_ARITY_LOOP_SUFFIX 1
+#     include BOOST_FT_AL_INCLUDE_FILE
+#     undef  BOOST_FT_ARITY_LOOP_SUFFIX
+
+#     undef BOOST_FT_AL_INCLUDE_FILE
+#   endif
+
+#   undef BOOST_FT_FROM_ARITY
+
+#else
+#   error "attempt to nest arity loops"
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_cc_loop/master.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_cc_loop/master.hpp
new file mode 100644
index 00000000000..60e958cec75
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_cc_loop/master.hpp
@@ -0,0 +1,136 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusions
+
+#ifdef __WAVE__
+// this file has been generated from the master.hpp file in the same directory
+#   pragma wave option(preserve: 0)
+#endif
+
+
+#if !BOOST_PP_IS_ITERATING
+
+#   ifndef BOOST_FT_DETAIL_CC_LOOP_MASTER_HPP_INCLUDED
+#   define BOOST_FT_DETAIL_CC_LOOP_MASTER_HPP_INCLUDED
+#     include <boost/function_types/config/cc_names.hpp>
+
+#     include <boost/preprocessor/cat.hpp>
+#     include <boost/preprocessor/seq/size.hpp>
+#     include <boost/preprocessor/seq/elem.hpp>
+#     include <boost/preprocessor/tuple/elem.hpp>
+#     include <boost/preprocessor/iteration/iterate.hpp>
+#     include <boost/preprocessor/facilities/expand.hpp>
+#     include <boost/preprocessor/arithmetic/inc.hpp>
+#   endif
+
+#   include <boost/function_types/detail/encoding/def.hpp>
+#   include <boost/function_types/detail/encoding/aliases_def.hpp>
+
+#   define  BOOST_PP_FILENAME_1 \
+        <boost/function_types/detail/pp_cc_loop/master.hpp>
+#   define  BOOST_PP_ITERATION_LIMITS \
+        (0,BOOST_PP_SEQ_SIZE(BOOST_FT_CC_NAMES_SEQ)-1)
+#   include BOOST_PP_ITERATE()
+#   if !defined(BOOST_FT_config_valid) && BOOST_FT_CC_PREPROCESSING
+#     define BOOST_FT_cc_id 1
+#     define BOOST_FT_cc_name implicit_cc
+#     define BOOST_FT_cc BOOST_PP_EMPTY
+#     define BOOST_FT_cond callable_builtin
+#     include BOOST_FT_cc_file
+#     undef BOOST_FT_cond
+#     undef BOOST_FT_cc_name
+#     undef BOOST_FT_cc
+#     undef BOOST_FT_cc_id
+#   elif !defined(BOOST_FT_config_valid) // and generating preprocessed file
+BOOST_PP_EXPAND(#) ifndef BOOST_FT_config_valid
+BOOST_PP_EXPAND(#)   define BOOST_FT_cc_id 1
+BOOST_PP_EXPAND(#)   define BOOST_FT_cc_name implicit_cc
+BOOST_PP_EXPAND(#)   define BOOST_FT_cc BOOST_PP_EMPTY
+BOOST_PP_EXPAND(#)   define BOOST_FT_cond callable_builtin
+#define _()
+BOOST_PP_EXPAND(#)   include BOOST_FT_cc_file
+#undef _
+BOOST_PP_EXPAND(#)   undef BOOST_FT_cond
+BOOST_PP_EXPAND(#)   undef BOOST_FT_cc_name
+BOOST_PP_EXPAND(#)   undef BOOST_FT_cc
+BOOST_PP_EXPAND(#)   undef BOOST_FT_cc_id
+BOOST_PP_EXPAND(#) else
+BOOST_PP_EXPAND(#)   undef BOOST_FT_config_valid
+BOOST_PP_EXPAND(#) endif
+
+#   else
+#     undef BOOST_FT_config_valid
+#   endif
+
+#   include <boost/function_types/detail/encoding/aliases_undef.hpp>
+#   include <boost/function_types/detail/encoding/undef.hpp>
+
+#elif BOOST_FT_CC_PREPROCESSING
+
+#   define BOOST_FT_cc_id  BOOST_PP_INC(BOOST_PP_FRAME_ITERATION(1))
+#   define BOOST_FT_cc_inf \
+        BOOST_PP_SEQ_ELEM(BOOST_PP_FRAME_ITERATION(1),BOOST_FT_CC_NAMES_SEQ)
+
+#   define BOOST_FT_cc_pp_name BOOST_PP_TUPLE_ELEM(3,0,BOOST_FT_cc_inf)
+#   define BOOST_FT_cc_name    BOOST_PP_TUPLE_ELEM(3,1,BOOST_FT_cc_inf)
+#   define BOOST_FT_cc         BOOST_PP_TUPLE_ELEM(3,2,BOOST_FT_cc_inf)
+
+#   define BOOST_FT_cond BOOST_PP_CAT(BOOST_FT_CC_,BOOST_FT_cc_pp_name)
+
+#   if BOOST_FT_cond
+#     define BOOST_FT_config_valid 1
+#     include BOOST_FT_cc_file
+#   endif
+
+#   undef BOOST_FT_cond
+
+#   undef BOOST_FT_cc_pp_name
+#   undef BOOST_FT_cc_name
+#   undef BOOST_FT_cc
+
+#   undef BOOST_FT_cc_id
+#   undef BOOST_FT_cc_inf
+
+#else // if generating preprocessed file
+BOOST_PP_EXPAND(#) define BOOST_FT_cc_id BOOST_PP_INC(BOOST_PP_ITERATION())
+
+#   define BOOST_FT_cc_inf \
+        BOOST_PP_SEQ_ELEM(BOOST_PP_ITERATION(),BOOST_FT_CC_NAMES_SEQ)
+
+#   define BOOST_FT_cc_pp_name BOOST_PP_TUPLE_ELEM(3,0,BOOST_FT_cc_inf)
+
+#   define BOOST_FT_CC_DEF(name,index) \
+        name BOOST_PP_TUPLE_ELEM(3,index,BOOST_FT_cc_inf)
+BOOST_PP_EXPAND(#) define BOOST_FT_CC_DEF(BOOST_FT_cc_name,1)
+BOOST_PP_EXPAND(#) define BOOST_FT_CC_DEF(BOOST_FT_cc,2)
+#   undef  BOOST_FT_CC_DEF
+
+#   define BOOST_FT_cc_cond_v BOOST_PP_CAT(BOOST_FT_CC_,BOOST_FT_cc_pp_name)
+BOOST_PP_EXPAND(#) define BOOST_FT_cond BOOST_FT_cc_cond_v
+#   undef  BOOST_FT_cc_cond_v
+
+#   undef BOOST_FT_cc_pp_name
+#   undef BOOST_FT_cc_inf
+
+BOOST_PP_EXPAND(#) if BOOST_FT_cond
+BOOST_PP_EXPAND(#)   define BOOST_FT_config_valid 1
+#define _()
+BOOST_PP_EXPAND(#)   include BOOST_FT_cc_file
+#undef _
+BOOST_PP_EXPAND(#) endif
+
+BOOST_PP_EXPAND(#) undef BOOST_FT_cond
+
+BOOST_PP_EXPAND(#) undef BOOST_FT_cc_name
+BOOST_PP_EXPAND(#) undef BOOST_FT_cc
+
+BOOST_PP_EXPAND(#) undef BOOST_FT_cc_id
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_cc_loop/preprocessed.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_cc_loop/preprocessed.hpp
new file mode 100644
index 00000000000..da4079c6ad2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_cc_loop/preprocessed.hpp
@@ -0,0 +1,120 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusions
+
+// this file has been generated from the master.hpp file in the same directory
+# define BOOST_FT_cc_id 1
+# define BOOST_FT_cc_name implicit_cc
+# define BOOST_FT_cc BOOST_PP_EMPTY
+# define BOOST_FT_cond BOOST_FT_CC_IMPLICIT
+# if BOOST_FT_cond
+# define BOOST_FT_config_valid 1
+# include BOOST_FT_cc_file
+# endif
+# undef BOOST_FT_cond
+# undef BOOST_FT_cc_name
+# undef BOOST_FT_cc
+# undef BOOST_FT_cc_id
+# define BOOST_FT_cc_id 2
+# define BOOST_FT_cc_name cdecl_cc
+# define BOOST_FT_cc BOOST_PP_IDENTITY(__cdecl )
+# define BOOST_FT_cond BOOST_FT_CC_CDECL
+# if BOOST_FT_cond
+# define BOOST_FT_config_valid 1
+# include BOOST_FT_cc_file
+# endif
+# undef BOOST_FT_cond
+# undef BOOST_FT_cc_name
+# undef BOOST_FT_cc
+# undef BOOST_FT_cc_id
+# define BOOST_FT_cc_id 3
+# define BOOST_FT_cc_name stdcall_cc
+# define BOOST_FT_cc BOOST_PP_IDENTITY(__stdcall )
+# define BOOST_FT_cond BOOST_FT_CC_STDCALL
+# if BOOST_FT_cond
+# define BOOST_FT_config_valid 1
+# include BOOST_FT_cc_file
+# endif
+# undef BOOST_FT_cond
+# undef BOOST_FT_cc_name
+# undef BOOST_FT_cc
+# undef BOOST_FT_cc_id
+# define BOOST_FT_cc_id 4
+# define BOOST_FT_cc_name pascal_cc
+# define BOOST_FT_cc BOOST_PP_IDENTITY(pascal )
+# define BOOST_FT_cond BOOST_FT_CC_PASCAL
+# if BOOST_FT_cond
+# define BOOST_FT_config_valid 1
+# include BOOST_FT_cc_file
+# endif
+# undef BOOST_FT_cond
+# undef BOOST_FT_cc_name
+# undef BOOST_FT_cc
+# undef BOOST_FT_cc_id
+# define BOOST_FT_cc_id 5
+# define BOOST_FT_cc_name fastcall_cc
+# define BOOST_FT_cc BOOST_PP_IDENTITY(__fastcall)
+# define BOOST_FT_cond BOOST_FT_CC_FASTCALL
+# if BOOST_FT_cond
+# define BOOST_FT_config_valid 1
+# include BOOST_FT_cc_file
+# endif
+# undef BOOST_FT_cond
+# undef BOOST_FT_cc_name
+# undef BOOST_FT_cc
+# undef BOOST_FT_cc_id
+# define BOOST_FT_cc_id 6
+# define BOOST_FT_cc_name clrcall_cc
+# define BOOST_FT_cc BOOST_PP_IDENTITY(__clrcall )
+# define BOOST_FT_cond BOOST_FT_CC_CLRCALL
+# if BOOST_FT_cond
+# define BOOST_FT_config_valid 1
+# include BOOST_FT_cc_file
+# endif
+# undef BOOST_FT_cond
+# undef BOOST_FT_cc_name
+# undef BOOST_FT_cc
+# undef BOOST_FT_cc_id
+# define BOOST_FT_cc_id 7
+# define BOOST_FT_cc_name thiscall_cc
+# define BOOST_FT_cc BOOST_PP_IDENTITY(__thiscall)
+# define BOOST_FT_cond BOOST_FT_CC_THISCALL
+# if BOOST_FT_cond
+# define BOOST_FT_config_valid 1
+# include BOOST_FT_cc_file
+# endif
+# undef BOOST_FT_cond
+# undef BOOST_FT_cc_name
+# undef BOOST_FT_cc
+# undef BOOST_FT_cc_id
+# define BOOST_FT_cc_id 8
+# define BOOST_FT_cc_name thiscall_cc
+# define BOOST_FT_cc BOOST_PP_EMPTY
+# define BOOST_FT_cond BOOST_FT_CC_IMPLICIT_THISCALL
+# if BOOST_FT_cond
+# define BOOST_FT_config_valid 1
+# include BOOST_FT_cc_file
+# endif
+# undef BOOST_FT_cond
+# undef BOOST_FT_cc_name
+# undef BOOST_FT_cc
+# undef BOOST_FT_cc_id
+# ifndef BOOST_FT_config_valid
+# define BOOST_FT_cc_id 1
+# define BOOST_FT_cc_name implicit_cc
+# define BOOST_FT_cc BOOST_PP_EMPTY
+# define BOOST_FT_cond 0x00000001
+# include BOOST_FT_cc_file
+# undef BOOST_FT_cond
+# undef BOOST_FT_cc_name
+# undef BOOST_FT_cc
+# undef BOOST_FT_cc_id
+# else
+# undef BOOST_FT_config_valid
+# endif
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_loop.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_loop.hpp
new file mode 100644
index 00000000000..7d8c347c99d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_loop.hpp
@@ -0,0 +1,80 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusions
+
+#ifndef BOOST_FT_DETAIL_PP_LOOP_HPP_INCLUDED
+#define BOOST_FT_DETAIL_PP_LOOP_HPP_INCLUDED
+#   include <boost/preprocessor/facilities/expand.hpp>
+#   include <boost/preprocessor/facilities/empty.hpp>
+#   include <boost/preprocessor/punctuation/paren.hpp>
+#endif
+
+#include <boost/function_types/detail/encoding/def.hpp>
+#include <boost/function_types/detail/encoding/aliases_def.hpp>
+
+#if defined(BOOST_FT_PREPROCESSING_MODE)
+#   define BOOST_FT_loop <boost/function_types/detail/pp_cc_loop/master.hpp>
+#else
+#   define BOOST_FT_loop \
+        <boost/function_types/detail/pp_cc_loop/preprocessed.hpp>
+#endif
+
+#if defined(BOOST_FT_al_path)
+
+#   define BOOST_FT_cc_file \
+        <boost/function_types/detail/pp_variate_loop/preprocessed.hpp>
+#   define BOOST_FT_variate_file \
+        <boost/function_types/detail/pp_arity_loop.hpp>
+
+#   ifndef BOOST_FT_type_function
+#   define BOOST_FT_type_function(cc,name) BOOST_FT_SYNTAX( \
+      R BOOST_PP_EMPTY,BOOST_PP_EMPTY,cc,BOOST_PP_EMPTY,name,BOOST_PP_EMPTY)
+#   endif
+#   ifndef BOOST_FT_type_function_pointer
+#   define BOOST_FT_type_function_pointer(cc,name) BOOST_FT_SYNTAX( \
+      R BOOST_PP_EMPTY,BOOST_PP_LPAREN,cc,* BOOST_PP_EMPTY,name,BOOST_PP_RPAREN)
+#   endif
+#   ifndef BOOST_FT_type_function_reference
+#   define BOOST_FT_type_function_reference(cc,name) BOOST_FT_SYNTAX( \
+      R BOOST_PP_EMPTY,BOOST_PP_LPAREN,cc,& BOOST_PP_EMPTY,name,BOOST_PP_RPAREN)
+#   endif
+#   ifndef BOOST_FT_type_member_function_pointer
+#   define BOOST_FT_type_member_function_pointer(cc,name) BOOST_FT_SYNTAX( \
+      R BOOST_PP_EMPTY,BOOST_PP_LPAREN,cc,T0::* BOOST_PP_EMPTY,name,BOOST_PP_RPAREN)
+#   endif
+
+#   include BOOST_FT_loop
+
+#   undef BOOST_FT_type_function
+#   undef BOOST_FT_type_function_pointer
+#   undef BOOST_FT_type_function_reference
+#   undef BOOST_FT_type_member_function_pointer
+
+#   undef BOOST_FT_variations
+#   undef BOOST_FT_variate_file
+#   undef BOOST_FT_cc_file
+#   undef BOOST_FT_al_path
+
+#elif defined(BOOST_FT_cc_file)
+
+#   include BOOST_FT_loop
+#   undef BOOST_FT_cc_file
+
+#else
+
+#   error "argument missing"
+
+#endif
+
+#undef BOOST_FT_loop
+
+#include <boost/function_types/detail/encoding/aliases_undef.hpp>
+#include <boost/function_types/detail/encoding/undef.hpp>
+
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_retag_default_cc/master.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_retag_default_cc/master.hpp
new file mode 100644
index 00000000000..865efce519c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_retag_default_cc/master.hpp
@@ -0,0 +1,103 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is guarded externally
+
+#ifdef __WAVE__
+// this file has been generated from the master.hpp file in the same directory
+#   pragma wave option(preserve: 0)
+#endif
+
+#if !defined(BOOST_PP_VALUE)
+#   include <boost/preprocessor/slot/slot.hpp>
+#   include <boost/preprocessor/iteration/self.hpp>
+
+#   include <boost/function_types/detail/encoding/def.hpp>
+#   include <boost/function_types/detail/encoding/aliases_def.hpp>
+
+namespace boost { namespace function_types {
+
+namespace detail
+{
+  template<class Tag, class RefTag> struct selector_bits
+  {
+#   define  BOOST_PP_VALUE non_member|member|non_variadic|variadic
+#   include BOOST_PP_ASSIGN_SLOT(1)
+
+    BOOST_STATIC_CONSTANT(bits_t, value = (
+        (::boost::function_types::detail::bits<Tag>::value & BOOST_FT_default_cc) 
+      | (::boost::function_types::detail::bits<RefTag>::value & BOOST_PP_SLOT(1))
+    ));
+  };
+
+  template<bits_t SelectorBits> struct default_cc_tag; 
+  
+  template<class Tag, class RefTag> struct retag_default_cc
+    : detail::compound_tag
+      < Tag, detail::default_cc_tag< 
+          ::boost::function_types::detail::selector_bits<Tag,RefTag>::value > >
+  { };
+
+  template<bits_t SelectorBits> struct default_cc_tag
+  {
+    typedef null_tag::bits bits;
+    typedef null_tag::mask mask;
+  };
+
+  class test_class;
+  typedef constant<BOOST_FT_cc_mask> cc_mask_constant;
+
+#   define BOOST_FT_self \
+      <boost/function_types/detail/pp_retag_default_cc/master.hpp>
+
+#   define  default_cc_ BOOST_FT_default_cc
+
+#   define  BOOST_PP_VALUE default_cc_|non_member|non_variadic
+#   define  BOOST_FT_tester void (*tester)()
+#   define  BOOST_PP_INDIRECT_SELF BOOST_FT_self
+#   include BOOST_PP_INCLUDE_SELF()
+
+#   define  BOOST_PP_VALUE default_cc_|non_member|variadic
+#   define  BOOST_FT_tester void (*tester)(...)
+#   define  BOOST_PP_INDIRECT_SELF BOOST_FT_self
+#   include BOOST_PP_INCLUDE_SELF()
+
+#   define  BOOST_PP_VALUE default_cc_|member|non_variadic
+#   define  BOOST_FT_tester void (test_class::*tester)()
+#   define  BOOST_PP_INDIRECT_SELF BOOST_FT_self
+#   include BOOST_PP_INCLUDE_SELF()
+
+#   define  BOOST_PP_VALUE default_cc_|member|variadic
+#   define  BOOST_FT_tester void (test_class::*tester)(...)
+#   define  BOOST_PP_INDIRECT_SELF BOOST_FT_self
+#   include BOOST_PP_INCLUDE_SELF()
+
+#   undef   default_cc_
+
+#   undef BOOST_FT_self
+
+} } } // namespace ::boost::function_types::detail
+
+#   include <boost/function_types/detail/encoding/aliases_undef.hpp>
+#   include <boost/function_types/detail/encoding/undef.hpp>
+
+#else // if defined(BOOST_PP_VALUE)
+
+#   include BOOST_PP_ASSIGN_SLOT(1)
+
+  template<> struct default_cc_tag<BOOST_PP_SLOT(1)> 
+  {
+    typedef BOOST_FT_tester;
+    typedef mpl::bitand_<components<tester>::bits,cc_mask_constant> bits;
+    typedef cc_mask_constant mask;
+  };
+
+#   undef BOOST_FT_tester
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_retag_default_cc/preprocessed.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_retag_default_cc/preprocessed.hpp
new file mode 100644
index 00000000000..72666d0f277
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_retag_default_cc/preprocessed.hpp
@@ -0,0 +1,59 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is guarded externally
+
+// this file has been generated from the master.hpp file in the same directory
+namespace boost { namespace function_types {
+namespace detail
+{
+template<class Tag, class RefTag> struct selector_bits
+{
+BOOST_STATIC_CONSTANT(bits_t, value = (
+(::boost::function_types::detail::bits<Tag> ::value & 0x00008000) 
+| (::boost::function_types::detail::bits<RefTag> ::value & 802)
+));
+};
+template<bits_t SelectorBits> struct default_cc_tag; 
+template<class Tag, class RefTag> struct retag_default_cc
+: detail::compound_tag
+< Tag, detail::default_cc_tag< 
+::boost::function_types::detail::selector_bits<Tag,RefTag> ::value > >
+{ };
+template<bits_t SelectorBits> struct default_cc_tag
+{
+typedef null_tag::bits bits;
+typedef null_tag::mask mask;
+};
+class test_class;
+typedef constant<0x00ff8000> cc_mask_constant;
+template< > struct default_cc_tag<33282> 
+{
+typedef void ( *tester)();
+typedef mpl::bitand_<components<tester> ::bits,cc_mask_constant> bits;
+typedef cc_mask_constant mask;
+};
+template< > struct default_cc_tag<33026> 
+{
+typedef void ( *tester)( ... );
+typedef mpl::bitand_<components<tester> ::bits,cc_mask_constant> bits;
+typedef cc_mask_constant mask;
+};
+template< > struct default_cc_tag<33312> 
+{
+typedef void (test_class:: *tester)();
+typedef mpl::bitand_<components<tester> ::bits,cc_mask_constant> bits;
+typedef cc_mask_constant mask;
+};
+template< > struct default_cc_tag<33056> 
+{
+typedef void (test_class:: *tester)( ... );
+typedef mpl::bitand_<components<tester> ::bits,cc_mask_constant> bits;
+typedef cc_mask_constant mask;
+};
+} } } 
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_tags/cc_tag.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_tags/cc_tag.hpp
new file mode 100644
index 00000000000..81f1d89e743
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_tags/cc_tag.hpp
@@ -0,0 +1,17 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusions
+
+  struct BOOST_FT_cc_name
+  {
+    typedef detail::encode_bits<0,BOOST_FT_cc_id> bits;
+    typedef detail::constant<BOOST_FT_cc_mask> mask;
+  };
+
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_tags/master.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_tags/master.hpp
new file mode 100644
index 00000000000..9cce212fcd6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_tags/master.hpp
@@ -0,0 +1,126 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is guarded externally
+
+#ifdef __WAVE__
+// this file has been generated from the master.hpp file in the same directory
+#   pragma wave option(preserve: 0)
+#endif
+
+#if !defined(BOOST_FT_PREPROCESSING_MODE) || defined(BOOST_FT_CONFIG_HPP_INCLUDED)
+#   error "this file used with two-pass preprocessing, only"
+#endif
+
+#include <boost/preprocessor/slot/slot.hpp>
+#include <boost/function_types/detail/encoding/def.hpp>
+
+namespace boost { namespace function_types {
+
+typedef detail::property_tag<BOOST_FT_non_variadic,BOOST_FT_variadic_mask> non_variadic;
+typedef detail::property_tag<BOOST_FT_variadic,BOOST_FT_variadic_mask>     variadic;
+                                                                       
+typedef detail::property_tag<0,BOOST_FT_const>                     non_const;
+typedef detail::property_tag<BOOST_FT_const,BOOST_FT_const>        const_qualified;
+                                                                       
+typedef detail::property_tag<0,BOOST_FT_volatile>                  non_volatile;
+typedef detail::property_tag<BOOST_FT_volatile,BOOST_FT_volatile>  volatile_qualified; 
+
+typedef detail::property_tag<BOOST_FT_default_cc,BOOST_FT_cc_mask> default_cc;
+
+#define BOOST_PP_VALUE BOOST_FT_const|BOOST_FT_volatile 
+#include BOOST_PP_ASSIGN_SLOT(1)
+
+typedef detail::property_tag<0                , BOOST_PP_SLOT(1)> non_cv;
+typedef detail::property_tag<BOOST_FT_const   , BOOST_PP_SLOT(1)> const_non_volatile;
+typedef detail::property_tag<BOOST_FT_volatile, BOOST_PP_SLOT(1)> volatile_non_const;
+typedef detail::property_tag<BOOST_PP_SLOT(1) , BOOST_PP_SLOT(1)> cv_qualified;
+
+namespace detail {
+
+  typedef constant<BOOST_FT_full_mask> full_mask;
+
+  template <bits_t Flags, bits_t CCID> struct encode_bits_impl
+  {
+    BOOST_STATIC_CONSTANT( bits_t, value = 
+      Flags | (BOOST_FT_default_cc * CCID) << 1 );
+  };
+
+  template <bits_t Flags, bits_t CCID, std::size_t Arity> 
+  struct encode_charr_impl
+  {
+    BOOST_STATIC_CONSTANT(std::size_t, value = (std::size_t)(1+
+      Flags | (BOOST_FT_default_cc * CCID) << 1 | Arity << BOOST_FT_arity_shift
+    ));
+  };
+
+  template <bits_t Bits> struct decode_bits
+  {
+    BOOST_STATIC_CONSTANT(bits_t, flags = Bits & BOOST_FT_flags_mask);
+
+    BOOST_STATIC_CONSTANT(bits_t, cc_id = 
+      ( (Bits & BOOST_FT_full_mask) / BOOST_FT_default_cc) >> 1 
+    );
+
+    BOOST_STATIC_CONSTANT(bits_t, tag_bits = (Bits & BOOST_FT_full_mask));
+
+    BOOST_STATIC_CONSTANT(std::size_t, arity = (std::size_t)
+      (Bits >> BOOST_FT_arity_shift) 
+    );
+  };
+
+  template <bits_t LHS_bits, bits_t LHS_mask, bits_t RHS_bits, bits_t RHS_mask>
+  struct tag_ice
+  {
+    BOOST_STATIC_CONSTANT(bool, match =
+      RHS_bits == (LHS_bits & RHS_mask & (RHS_bits |~BOOST_FT_type_mask))
+    );
+
+    BOOST_STATIC_CONSTANT(bits_t, combined_bits = 
+      (LHS_bits & ~RHS_mask) | RHS_bits
+    );
+
+    BOOST_STATIC_CONSTANT(bits_t, combined_mask =
+      LHS_mask | RHS_mask
+    );
+
+    BOOST_STATIC_CONSTANT(bits_t, extracted_bits =
+      LHS_bits & RHS_mask
+    );
+
+  };
+
+#define BOOST_FT_mask BOOST_FT_type_mask
+  typedef property_tag<BOOST_FT_callable_builtin,BOOST_FT_mask>            callable_builtin_tag;
+  typedef property_tag<BOOST_FT_non_member_callable_builtin,BOOST_FT_mask> nonmember_callable_builtin_tag;
+  typedef property_tag<BOOST_FT_function,BOOST_FT_mask>       function_tag;
+  typedef property_tag<BOOST_FT_reference,BOOST_FT_mask>      reference_tag;
+  typedef property_tag<BOOST_FT_pointer,BOOST_FT_mask>        pointer_tag;
+  typedef property_tag<BOOST_FT_member_function_pointer,BOOST_FT_mask> member_function_pointer_tag;
+  typedef property_tag<BOOST_FT_member_object_pointer,BOOST_FT_mask> member_object_pointer_tag;
+  typedef property_tag<BOOST_FT_member_object_pointer_flags,BOOST_FT_full_mask> member_object_pointer_base;
+  typedef property_tag<BOOST_FT_member_pointer,BOOST_FT_mask> member_pointer_tag;
+#undef  BOOST_FT_mask 
+
+#define BOOST_PP_VALUE BOOST_FT_function|BOOST_FT_non_variadic|BOOST_FT_default_cc
+#include BOOST_PP_ASSIGN_SLOT(1)
+#define BOOST_PP_VALUE BOOST_FT_type_mask|BOOST_FT_variadic_mask|BOOST_FT_cc_mask
+#include BOOST_PP_ASSIGN_SLOT(2)
+
+  typedef property_tag< BOOST_PP_SLOT(1) , BOOST_PP_SLOT(2) > nv_dcc_func;
+
+#define BOOST_PP_VALUE \
+    BOOST_FT_member_function_pointer|BOOST_FT_non_variadic|BOOST_FT_default_cc
+#include BOOST_PP_ASSIGN_SLOT(1)
+
+  typedef property_tag< BOOST_PP_SLOT(1) , BOOST_PP_SLOT(2) > nv_dcc_mfp;
+
+} // namespace detail
+
+} } // namespace ::boost::function_types
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_tags/preprocessed.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_tags/preprocessed.hpp
new file mode 100644
index 00000000000..823c3cc1cde
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_tags/preprocessed.hpp
@@ -0,0 +1,77 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is guarded externally
+
+// this file has been generated from the master.hpp file in the same directory
+namespace boost { namespace function_types {
+typedef detail::property_tag<0x00000200,0x00000300> non_variadic;
+typedef detail::property_tag<0x00000100,0x00000300> variadic;
+typedef detail::property_tag<0,0x00000400> non_const;
+typedef detail::property_tag<0x00000400,0x00000400> const_qualified;
+typedef detail::property_tag<0,0x00000800> non_volatile;
+typedef detail::property_tag<0x00000800,0x00000800> volatile_qualified; 
+typedef detail::property_tag<0x00008000,0x00ff8000> default_cc;
+typedef detail::property_tag<0 , 3072> non_cv;
+typedef detail::property_tag<0x00000400 , 3072> const_non_volatile;
+typedef detail::property_tag<0x00000800, 3072> volatile_non_const;
+typedef detail::property_tag<3072 , 3072> cv_qualified;
+namespace detail {
+typedef constant<0x00ff0fff> full_mask;
+template <bits_t Flags, bits_t CCID> struct encode_bits_impl
+{
+BOOST_STATIC_CONSTANT( bits_t, value = 
+Flags | (0x00008000 * CCID) << 1 );
+};
+template <bits_t Flags, bits_t CCID, std::size_t Arity> 
+struct encode_charr_impl
+{
+BOOST_STATIC_CONSTANT(std::size_t, value = (std::size_t)(1+
+Flags | (0x00008000 * CCID) << 1 | Arity << 24
+));
+};
+template <bits_t Bits> struct decode_bits
+{
+BOOST_STATIC_CONSTANT(bits_t, flags = Bits & 0x00000fff);
+BOOST_STATIC_CONSTANT(bits_t, cc_id = 
+( (Bits & 0x00ff0fff) / 0x00008000) >> 1 
+);
+BOOST_STATIC_CONSTANT(bits_t, tag_bits = (Bits & 0x00ff0fff));
+BOOST_STATIC_CONSTANT(std::size_t, arity = (std::size_t)
+(Bits >> 24) 
+);
+};
+template <bits_t LHS_bits, bits_t LHS_mask, bits_t RHS_bits, bits_t RHS_mask>
+struct tag_ice
+{
+BOOST_STATIC_CONSTANT(bool, match =
+RHS_bits == (LHS_bits & RHS_mask & (RHS_bits | ~0x000000ff))
+);
+BOOST_STATIC_CONSTANT(bits_t, combined_bits = 
+(LHS_bits & ~RHS_mask) | RHS_bits
+);
+BOOST_STATIC_CONSTANT(bits_t, combined_mask =
+LHS_mask | RHS_mask
+);
+BOOST_STATIC_CONSTANT(bits_t, extracted_bits =
+LHS_bits & RHS_mask
+);
+};
+typedef property_tag<0x00000001,0x000000ff> callable_builtin_tag;
+typedef property_tag<0x00000003,0x000000ff> nonmember_callable_builtin_tag;
+typedef property_tag<0x00000007,0x000000ff> function_tag;
+typedef property_tag<0x00000013,0x000000ff> reference_tag;
+typedef property_tag<0x0000000b,0x000000ff> pointer_tag;
+typedef property_tag<0x00000061,0x000000ff> member_function_pointer_tag;
+typedef property_tag<0x000000a3,0x000000ff> member_object_pointer_tag;
+typedef property_tag<0x000002a3,0x00ff0fff> member_object_pointer_base;
+typedef property_tag<0x00000020,0x000000ff> member_pointer_tag;
+typedef property_tag< 33287 , 16745471 > nv_dcc_func;
+typedef property_tag< 33377 , 16745471 > nv_dcc_mfp;
+} 
+} } 
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_variate_loop/master.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_variate_loop/master.hpp
new file mode 100644
index 00000000000..50263429d70
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_variate_loop/master.hpp
@@ -0,0 +1,152 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifdef __WAVE__
+// this file has been generated from the master.hpp file in the same directory
+#   pragma wave option(preserve: 0)
+#endif
+
+#if !defined(BOOST_FT_PREPROCESSING_MODE)
+#   error "this file is only for two-pass preprocessing"
+#endif
+
+#if !defined(BOOST_PP_VALUE)
+#   include <boost/preprocessor/slot/slot.hpp>
+#   include <boost/preprocessor/facilities/empty.hpp>
+#   include <boost/preprocessor/facilities/expand.hpp>
+#   include <boost/function_types/detail/encoding/def.hpp>
+
+BOOST_PP_EXPAND(#) define BOOST_FT_mfp 0
+BOOST_PP_EXPAND(#) define BOOST_FT_syntax BOOST_FT_type_function
+
+#   define  BOOST_PP_VALUE \
+      BOOST_FT_function|BOOST_FT_non_variadic
+#   include __FILE__
+#   define  BOOST_PP_VALUE \
+      BOOST_FT_function|BOOST_FT_variadic
+#   include __FILE__
+
+BOOST_PP_EXPAND(#) if !BOOST_FT_NO_CV_FUNC_SUPPORT
+#   define  BOOST_PP_VALUE \
+      BOOST_FT_function|BOOST_FT_non_variadic|BOOST_FT_const
+#   include __FILE__
+#   define  BOOST_PP_VALUE \
+      BOOST_FT_function|BOOST_FT_variadic|BOOST_FT_const
+#   include __FILE__
+#   define  BOOST_PP_VALUE \
+      BOOST_FT_function|BOOST_FT_non_variadic|BOOST_FT_volatile
+#   include __FILE__
+#   define  BOOST_PP_VALUE \
+      BOOST_FT_function|BOOST_FT_variadic|BOOST_FT_volatile
+#   include __FILE__
+#   define  BOOST_PP_VALUE \
+      BOOST_FT_function|BOOST_FT_non_variadic|BOOST_FT_const|BOOST_FT_volatile
+#   include __FILE__
+#   define  BOOST_PP_VALUE \
+      BOOST_FT_function|BOOST_FT_variadic|BOOST_FT_const|BOOST_FT_volatile
+#   include __FILE__
+BOOST_PP_EXPAND(#) endif
+
+
+BOOST_PP_EXPAND(#) undef  BOOST_FT_syntax
+BOOST_PP_EXPAND(#) define BOOST_FT_syntax BOOST_FT_type_function_pointer
+
+#   define  BOOST_PP_VALUE \
+      BOOST_FT_pointer|BOOST_FT_non_variadic
+#   include __FILE__
+#   define  BOOST_PP_VALUE \
+      BOOST_FT_pointer|BOOST_FT_variadic
+#   include __FILE__
+
+BOOST_PP_EXPAND(#) undef  BOOST_FT_syntax
+BOOST_PP_EXPAND(#) define BOOST_FT_syntax BOOST_FT_type_function_reference
+
+#   define BOOST_PP_VALUE \
+      BOOST_FT_reference|BOOST_FT_non_variadic
+#   include __FILE__
+#   define BOOST_PP_VALUE \
+      BOOST_FT_reference|BOOST_FT_variadic
+#   include __FILE__
+
+BOOST_PP_EXPAND(#) undef  BOOST_FT_syntax
+BOOST_PP_EXPAND(#) undef  BOOST_FT_mfp
+
+BOOST_PP_EXPAND(#) define BOOST_FT_mfp 1
+BOOST_PP_EXPAND(#) define BOOST_FT_syntax BOOST_FT_type_member_function_pointer
+
+#   define  BOOST_PP_VALUE \
+      BOOST_FT_member_function_pointer|BOOST_FT_non_variadic
+#   include __FILE__
+#   define  BOOST_PP_VALUE \
+      BOOST_FT_member_function_pointer|BOOST_FT_variadic
+#   include __FILE__
+#   define  BOOST_PP_VALUE \
+      BOOST_FT_member_function_pointer|BOOST_FT_non_variadic|BOOST_FT_const
+#   include __FILE__
+#   define  BOOST_PP_VALUE \
+      BOOST_FT_member_function_pointer|BOOST_FT_variadic|BOOST_FT_const
+#   include __FILE__
+#   define  BOOST_PP_VALUE \
+      BOOST_FT_member_function_pointer|BOOST_FT_non_variadic|BOOST_FT_volatile
+#   include __FILE__
+#   define  BOOST_PP_VALUE \
+      BOOST_FT_member_function_pointer|BOOST_FT_variadic|BOOST_FT_volatile
+#   include __FILE__
+#   define  BOOST_PP_VALUE \
+      BOOST_FT_member_function_pointer|BOOST_FT_non_variadic|BOOST_FT_const|BOOST_FT_volatile
+#   include __FILE__
+#   define  BOOST_PP_VALUE \
+      BOOST_FT_member_function_pointer|BOOST_FT_variadic|BOOST_FT_const|BOOST_FT_volatile
+#   include __FILE__
+
+BOOST_PP_EXPAND(#) undef  BOOST_FT_syntax
+BOOST_PP_EXPAND(#) undef  BOOST_FT_mfp
+
+#   include <boost/function_types/detail/encoding/undef.hpp>
+#else 
+
+#   include BOOST_PP_ASSIGN_SLOT(1)
+
+#   define  BOOST_PP_VALUE BOOST_PP_SLOT(1) & BOOST_FT_kind_mask
+#   include BOOST_PP_ASSIGN_SLOT(2)
+
+BOOST_PP_EXPAND(#) if !!(BOOST_PP_SLOT(2) & (BOOST_FT_variations))
+BOOST_PP_EXPAND(#) if (BOOST_PP_SLOT(1) & (BOOST_FT_cond)) == (BOOST_FT_cond)
+
+#   if ( BOOST_PP_SLOT(1) & (BOOST_FT_variadic) )
+BOOST_PP_EXPAND(#)   define BOOST_FT_ell ...
+BOOST_PP_EXPAND(#)   define BOOST_FT_nullary_param
+#   else
+BOOST_PP_EXPAND(#)   define BOOST_FT_ell
+BOOST_PP_EXPAND(#)   define BOOST_FT_nullary_param BOOST_FT_NULLARY_PARAM
+#   endif
+
+#   if !( BOOST_PP_SLOT(1) & (BOOST_FT_volatile) )
+#     if !( BOOST_PP_SLOT(1) & (BOOST_FT_const) )
+BOOST_PP_EXPAND(#)   define BOOST_FT_cv 
+#     else
+BOOST_PP_EXPAND(#)   define BOOST_FT_cv const
+#     endif
+#   else
+#     if !( BOOST_PP_SLOT(1) & (BOOST_FT_const) )
+BOOST_PP_EXPAND(#)   define BOOST_FT_cv volatile
+#     else
+BOOST_PP_EXPAND(#)   define BOOST_FT_cv const volatile
+#     endif
+#   endif
+BOOST_PP_EXPAND(#)   define BOOST_FT_flags BOOST_PP_SLOT(1)
+BOOST_PP_EXPAND(#)   include BOOST_FT_variate_file
+
+BOOST_PP_EXPAND(#)   undef BOOST_FT_cv
+BOOST_PP_EXPAND(#)   undef BOOST_FT_ell
+BOOST_PP_EXPAND(#)   undef BOOST_FT_nullary_param
+BOOST_PP_EXPAND(#)   undef BOOST_FT_flags
+BOOST_PP_EXPAND(#) endif
+BOOST_PP_EXPAND(#) endif
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_variate_loop/preprocessed.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_variate_loop/preprocessed.hpp
new file mode 100644
index 00000000000..7e7c4f91fa9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/pp_variate_loop/preprocessed.hpp
@@ -0,0 +1,283 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// this file has been generated from the master.hpp file in the same directory
+# define BOOST_FT_mfp 0
+# define BOOST_FT_syntax BOOST_FT_type_function
+# if ! ! (4 & (BOOST_FT_variations))
+# if (519 & (BOOST_FT_cond)) == (BOOST_FT_cond)
+# define BOOST_FT_ell
+# define BOOST_FT_nullary_param BOOST_FT_NULLARY_PARAM
+# define BOOST_FT_cv 
+# define BOOST_FT_flags 519
+# include BOOST_FT_variate_file
+# undef BOOST_FT_cv
+# undef BOOST_FT_ell
+# undef BOOST_FT_nullary_param
+# undef BOOST_FT_flags
+# endif
+# endif
+# if ! ! (4 & (BOOST_FT_variations))
+# if (263 & (BOOST_FT_cond)) == (BOOST_FT_cond)
+# define BOOST_FT_ell ...
+# define BOOST_FT_nullary_param
+# define BOOST_FT_cv 
+# define BOOST_FT_flags 263
+# include BOOST_FT_variate_file
+# undef BOOST_FT_cv
+# undef BOOST_FT_ell
+# undef BOOST_FT_nullary_param
+# undef BOOST_FT_flags
+# endif
+# endif
+# if !BOOST_FT_NO_CV_FUNC_SUPPORT
+# if ! ! (4 & (BOOST_FT_variations))
+# if (1543 & (BOOST_FT_cond)) == (BOOST_FT_cond)
+# define BOOST_FT_ell
+# define BOOST_FT_nullary_param BOOST_FT_NULLARY_PARAM
+# define BOOST_FT_cv const
+# define BOOST_FT_flags 1543
+# include BOOST_FT_variate_file
+# undef BOOST_FT_cv
+# undef BOOST_FT_ell
+# undef BOOST_FT_nullary_param
+# undef BOOST_FT_flags
+# endif
+# endif
+# if ! ! (4 & (BOOST_FT_variations))
+# if (1287 & (BOOST_FT_cond)) == (BOOST_FT_cond)
+# define BOOST_FT_ell ...
+# define BOOST_FT_nullary_param
+# define BOOST_FT_cv const
+# define BOOST_FT_flags 1287
+# include BOOST_FT_variate_file
+# undef BOOST_FT_cv
+# undef BOOST_FT_ell
+# undef BOOST_FT_nullary_param
+# undef BOOST_FT_flags
+# endif
+# endif
+# if ! ! (4 & (BOOST_FT_variations))
+# if (2567 & (BOOST_FT_cond)) == (BOOST_FT_cond)
+# define BOOST_FT_ell
+# define BOOST_FT_nullary_param BOOST_FT_NULLARY_PARAM
+# define BOOST_FT_cv volatile
+# define BOOST_FT_flags 2567
+# include BOOST_FT_variate_file
+# undef BOOST_FT_cv
+# undef BOOST_FT_ell
+# undef BOOST_FT_nullary_param
+# undef BOOST_FT_flags
+# endif
+# endif
+# if ! ! (4 & (BOOST_FT_variations))
+# if (2311 & (BOOST_FT_cond)) == (BOOST_FT_cond)
+# define BOOST_FT_ell ...
+# define BOOST_FT_nullary_param
+# define BOOST_FT_cv volatile
+# define BOOST_FT_flags 2311
+# include BOOST_FT_variate_file
+# undef BOOST_FT_cv
+# undef BOOST_FT_ell
+# undef BOOST_FT_nullary_param
+# undef BOOST_FT_flags
+# endif
+# endif
+# if ! ! (4 & (BOOST_FT_variations))
+# if (3591 & (BOOST_FT_cond)) == (BOOST_FT_cond)
+# define BOOST_FT_ell
+# define BOOST_FT_nullary_param BOOST_FT_NULLARY_PARAM
+# define BOOST_FT_cv const volatile
+# define BOOST_FT_flags 3591
+# include BOOST_FT_variate_file
+# undef BOOST_FT_cv
+# undef BOOST_FT_ell
+# undef BOOST_FT_nullary_param
+# undef BOOST_FT_flags
+# endif
+# endif
+# if ! ! (4 & (BOOST_FT_variations))
+# if (3335 & (BOOST_FT_cond)) == (BOOST_FT_cond)
+# define BOOST_FT_ell ...
+# define BOOST_FT_nullary_param
+# define BOOST_FT_cv const volatile
+# define BOOST_FT_flags 3335
+# include BOOST_FT_variate_file
+# undef BOOST_FT_cv
+# undef BOOST_FT_ell
+# undef BOOST_FT_nullary_param
+# undef BOOST_FT_flags
+# endif
+# endif
+# endif
+# undef BOOST_FT_syntax
+# define BOOST_FT_syntax BOOST_FT_type_function_pointer
+# if ! ! (8 & (BOOST_FT_variations))
+# if (523 & (BOOST_FT_cond)) == (BOOST_FT_cond)
+# define BOOST_FT_ell
+# define BOOST_FT_nullary_param BOOST_FT_NULLARY_PARAM
+# define BOOST_FT_cv 
+# define BOOST_FT_flags 523
+# include BOOST_FT_variate_file
+# undef BOOST_FT_cv
+# undef BOOST_FT_ell
+# undef BOOST_FT_nullary_param
+# undef BOOST_FT_flags
+# endif
+# endif
+# if ! ! (8 & (BOOST_FT_variations))
+# if (267 & (BOOST_FT_cond)) == (BOOST_FT_cond)
+# define BOOST_FT_ell ...
+# define BOOST_FT_nullary_param
+# define BOOST_FT_cv 
+# define BOOST_FT_flags 267
+# include BOOST_FT_variate_file
+# undef BOOST_FT_cv
+# undef BOOST_FT_ell
+# undef BOOST_FT_nullary_param
+# undef BOOST_FT_flags
+# endif
+# endif
+# undef BOOST_FT_syntax
+# define BOOST_FT_syntax BOOST_FT_type_function_reference
+# if ! ! (16 & (BOOST_FT_variations))
+# if (531 & (BOOST_FT_cond)) == (BOOST_FT_cond)
+# define BOOST_FT_ell
+# define BOOST_FT_nullary_param BOOST_FT_NULLARY_PARAM
+# define BOOST_FT_cv 
+# define BOOST_FT_flags 531
+# include BOOST_FT_variate_file
+# undef BOOST_FT_cv
+# undef BOOST_FT_ell
+# undef BOOST_FT_nullary_param
+# undef BOOST_FT_flags
+# endif
+# endif
+# if ! ! (16 & (BOOST_FT_variations))
+# if (275 & (BOOST_FT_cond)) == (BOOST_FT_cond)
+# define BOOST_FT_ell ...
+# define BOOST_FT_nullary_param
+# define BOOST_FT_cv 
+# define BOOST_FT_flags 275
+# include BOOST_FT_variate_file
+# undef BOOST_FT_cv
+# undef BOOST_FT_ell
+# undef BOOST_FT_nullary_param
+# undef BOOST_FT_flags
+# endif
+# endif
+# undef BOOST_FT_syntax
+# undef BOOST_FT_mfp
+# define BOOST_FT_mfp 1
+# define BOOST_FT_syntax BOOST_FT_type_member_function_pointer
+# if ! ! (96 & (BOOST_FT_variations))
+# if (609 & (BOOST_FT_cond)) == (BOOST_FT_cond)
+# define BOOST_FT_ell
+# define BOOST_FT_nullary_param BOOST_FT_NULLARY_PARAM
+# define BOOST_FT_cv 
+# define BOOST_FT_flags 609
+# include BOOST_FT_variate_file
+# undef BOOST_FT_cv
+# undef BOOST_FT_ell
+# undef BOOST_FT_nullary_param
+# undef BOOST_FT_flags
+# endif
+# endif
+# if ! ! (96 & (BOOST_FT_variations))
+# if (353 & (BOOST_FT_cond)) == (BOOST_FT_cond)
+# define BOOST_FT_ell ...
+# define BOOST_FT_nullary_param
+# define BOOST_FT_cv 
+# define BOOST_FT_flags 353
+# include BOOST_FT_variate_file
+# undef BOOST_FT_cv
+# undef BOOST_FT_ell
+# undef BOOST_FT_nullary_param
+# undef BOOST_FT_flags
+# endif
+# endif
+# if ! ! (96 & (BOOST_FT_variations))
+# if (1633 & (BOOST_FT_cond)) == (BOOST_FT_cond)
+# define BOOST_FT_ell
+# define BOOST_FT_nullary_param BOOST_FT_NULLARY_PARAM
+# define BOOST_FT_cv const
+# define BOOST_FT_flags 1633
+# include BOOST_FT_variate_file
+# undef BOOST_FT_cv
+# undef BOOST_FT_ell
+# undef BOOST_FT_nullary_param
+# undef BOOST_FT_flags
+# endif
+# endif
+# if ! ! (96 & (BOOST_FT_variations))
+# if (1377 & (BOOST_FT_cond)) == (BOOST_FT_cond)
+# define BOOST_FT_ell ...
+# define BOOST_FT_nullary_param
+# define BOOST_FT_cv const
+# define BOOST_FT_flags 1377
+# include BOOST_FT_variate_file
+# undef BOOST_FT_cv
+# undef BOOST_FT_ell
+# undef BOOST_FT_nullary_param
+# undef BOOST_FT_flags
+# endif
+# endif
+# if ! ! (96 & (BOOST_FT_variations))
+# if (2657 & (BOOST_FT_cond)) == (BOOST_FT_cond)
+# define BOOST_FT_ell
+# define BOOST_FT_nullary_param BOOST_FT_NULLARY_PARAM
+# define BOOST_FT_cv volatile
+# define BOOST_FT_flags 2657
+# include BOOST_FT_variate_file
+# undef BOOST_FT_cv
+# undef BOOST_FT_ell
+# undef BOOST_FT_nullary_param
+# undef BOOST_FT_flags
+# endif
+# endif
+# if ! ! (96 & (BOOST_FT_variations))
+# if (2401 & (BOOST_FT_cond)) == (BOOST_FT_cond)
+# define BOOST_FT_ell ...
+# define BOOST_FT_nullary_param
+# define BOOST_FT_cv volatile
+# define BOOST_FT_flags 2401
+# include BOOST_FT_variate_file
+# undef BOOST_FT_cv
+# undef BOOST_FT_ell
+# undef BOOST_FT_nullary_param
+# undef BOOST_FT_flags
+# endif
+# endif
+# if ! ! (96 & (BOOST_FT_variations))
+# if (3681 & (BOOST_FT_cond)) == (BOOST_FT_cond)
+# define BOOST_FT_ell
+# define BOOST_FT_nullary_param BOOST_FT_NULLARY_PARAM
+# define BOOST_FT_cv const volatile
+# define BOOST_FT_flags 3681
+# include BOOST_FT_variate_file
+# undef BOOST_FT_cv
+# undef BOOST_FT_ell
+# undef BOOST_FT_nullary_param
+# undef BOOST_FT_flags
+# endif
+# endif
+# if ! ! (96 & (BOOST_FT_variations))
+# if (3425 & (BOOST_FT_cond)) == (BOOST_FT_cond)
+# define BOOST_FT_ell ...
+# define BOOST_FT_nullary_param
+# define BOOST_FT_cv const volatile
+# define BOOST_FT_flags 3425
+# include BOOST_FT_variate_file
+# undef BOOST_FT_cv
+# undef BOOST_FT_ell
+# undef BOOST_FT_nullary_param
+# undef BOOST_FT_flags
+# endif
+# endif
+# undef BOOST_FT_syntax
+# undef BOOST_FT_mfp
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/retag_default_cc.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/retag_default_cc.hpp
new file mode 100644
index 00000000000..c8926f6dfcc
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/retag_default_cc.hpp
@@ -0,0 +1,23 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_DETAIL_RETAG_DEFAULT_CC_HPP_INCLUDED
+#define BOOST_FT_DETAIL_RETAG_DEFAULT_CC_HPP_INCLUDED
+
+#include <boost/mpl/bitand.hpp>
+
+#include <boost/function_types/components.hpp>
+
+#if defined(BOOST_FT_PREPROCESSING_MODE)
+#   include <boost/function_types/detail/pp_retag_default_cc/master.hpp>
+#else
+#   include <boost/function_types/detail/pp_retag_default_cc/preprocessed.hpp>
+#endif
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize.hpp
new file mode 100644
index 00000000000..0b15cbbed21
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize.hpp
@@ -0,0 +1,79 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_DETAIL_SYNTHESIZE_HPP_INCLUDED
+#define BOOST_FT_DETAIL_SYNTHESIZE_HPP_INCLUDED
+
+#include <cstddef>
+
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/size.hpp>
+
+#include <boost/function_types/config/config.hpp>
+#include <boost/function_types/property_tags.hpp>
+#include <boost/function_types/detail/cv_traits.hpp>
+#include <boost/function_types/detail/retag_default_cc.hpp>
+
+namespace boost { namespace function_types { namespace detail {
+
+template<bits_t Flags, bits_t CCID, std::size_t Size>
+struct synthesize_impl_o
+{
+  template<typename Seq> struct synthesize_impl_i { };
+};
+
+template<typename Seq, bits_t Bits>
+struct synthesize_impl
+  : detail::synthesize_impl_o
+    < ::boost::function_types::detail::decode_bits<Bits>::flags
+    , ::boost::function_types::detail::decode_bits<Bits>::cc_id
+    , ::boost::mpl::size<Seq>::value
+    >
+    ::template synthesize_impl_i<Seq>
+{ };
+
+template<typename Seq, typename Tag>
+struct synthesize_func
+  : detail::synthesize_impl
+    < Seq
+    , ::boost::function_types::detail::bits
+      < detail::retag_default_cc
+        < function_types::tag<nv_dcc_func, Tag> > 
+      >::value 
+    >
+{ };
+
+template<typename Seq, typename Tag>
+struct synthesize_mfp
+  : detail::synthesize_impl
+    < Seq 
+    , ::boost::function_types::detail::bits
+      < detail::retag_default_cc
+        < function_types::tag
+          < typename detail::cv_traits< typename mpl::at_c<Seq,1>::type >::tag
+          , nv_dcc_mfp, Tag
+        > >
+      >::value
+    >
+{ };
+
+template<typename S, typename R = typename mpl::at_c<S,0>::type,
+    typename C = typename mpl::at_c<S,1>::type>
+struct synthesize_mop
+{
+  typedef R C::* type;
+};
+
+#define BOOST_FT_variations BOOST_FT_function|BOOST_FT_member_pointer
+#define BOOST_FT_al_path boost/function_types/detail/synthesize_impl
+#include <boost/function_types/detail/pp_loop.hpp>
+
+} } } // namespace ::boost::function_types::detail
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity10_0.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity10_0.hpp
new file mode 100644
index 00000000000..ad22e5047ae
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity10_0.hpp
@@ -0,0 +1,334 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# define BOOST_FT_make_type(flags,cc,arity) BOOST_FT_make_type_impl(flags,cc,arity)
+# define BOOST_FT_make_type_impl(flags,cc,arity) make_type_ ## flags ## _ ## cc ## _ ## arity
+template< typename R >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,0)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (BOOST_FT_nullary_param BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 1 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,0) 
+< typename mpl::deref< iter_0 > ::type 
+> ::type type;
+};
+};
+template< typename R , typename T0 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,1)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 2 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,1) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+> ::type type;
+};
+};
+template< typename R , typename T0 , typename T1 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,2)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 3 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,2) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+> ::type type;
+};
+};
+template< typename R , typename T0 , typename T1 , typename T2 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,3)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 4 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,3) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+> ::type type;
+};
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,4)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 5 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,4) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+> ::type type;
+};
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,5)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 6 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,5) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+> ::type type;
+};
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,6)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 7 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,6) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+> ::type type;
+};
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,7)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 8 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,7) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+> ::type type;
+};
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,8)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 9 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,8) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+> ::type type;
+};
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,9)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 10 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,9) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+> ::type type;
+};
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,10)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 11 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,10) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+> ::type type;
+};
+};
+# undef BOOST_FT_make_type
+# undef BOOST_FT_make_type_impl
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity10_1.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity10_1.hpp
new file mode 100644
index 00000000000..bbd5963fa0e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity10_1.hpp
@@ -0,0 +1,326 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# define BOOST_FT_make_type(flags,cc,arity) BOOST_FT_make_type_impl(flags,cc,arity)
+# define BOOST_FT_make_type_impl(flags,cc,arity) make_type_ ## flags ## _ ## cc ## _ ## arity
+template< typename R , typename T0 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,1)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) ( BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 2 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,1) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+> ::type type;
+};
+};
+template< typename R , typename T0 , typename T1 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,2)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 3 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,2) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+> ::type type;
+};
+};
+template< typename R , typename T0 , typename T1 , typename T2 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,3)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 4 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,3) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+> ::type type;
+};
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,4)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 5 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,4) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+> ::type type;
+};
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,5)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 6 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,5) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+> ::type type;
+};
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,6)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 7 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,6) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+> ::type type;
+};
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,7)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 8 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,7) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+> ::type type;
+};
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,8)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 9 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,8) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+> ::type type;
+};
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,9)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 10 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,9) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+> ::type type;
+};
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,10)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 11 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,10) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+> ::type type;
+};
+};
+# undef BOOST_FT_make_type
+# undef BOOST_FT_make_type_impl
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity20_0.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity20_0.hpp
new file mode 100644
index 00000000000..cb62e691151
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity20_0.hpp
@@ -0,0 +1,517 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/synthesize_impl/arity10_0.hpp>
+# define BOOST_FT_make_type(flags,cc,arity) BOOST_FT_make_type_impl(flags,cc,arity)
+# define BOOST_FT_make_type_impl(flags,cc,arity) make_type_ ## flags ## _ ## cc ## _ ## arity
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,11)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 12 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,11) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+> ::type type;
+};
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,12)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 13 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,12) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,13)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 14 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,13) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,14)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 15 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,14) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,15)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 16 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,15) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,16)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 17 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,16) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,17)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 18 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,17) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,18)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 19 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,18) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,19)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 20 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,19) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,20)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 21 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,20) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+> ::type type;
+};
+};
+# undef BOOST_FT_make_type
+# undef BOOST_FT_make_type_impl
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity20_1.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity20_1.hpp
new file mode 100644
index 00000000000..1c5e1e747cc
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity20_1.hpp
@@ -0,0 +1,527 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/synthesize_impl/arity10_1.hpp>
+# define BOOST_FT_make_type(flags,cc,arity) BOOST_FT_make_type_impl(flags,cc,arity)
+# define BOOST_FT_make_type_impl(flags,cc,arity) make_type_ ## flags ## _ ## cc ## _ ## arity
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,11)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 12 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,11) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+> ::type type;
+};
+};
+template< typename R , typename T0 , typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 , typename T7 , typename T8 , typename T9 , typename T10 , typename T11 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,12)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 13 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,12) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,13)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 14 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,13) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,14)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 15 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,14) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,15)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 16 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,15) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,16)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 17 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,16) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,17)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 18 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,17) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,18)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 19 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,18) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,19)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 20 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,19) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,20)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 21 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,20) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+> ::type type;
+};
+};
+# undef BOOST_FT_make_type
+# undef BOOST_FT_make_type_impl
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity30_0.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity30_0.hpp
new file mode 100644
index 00000000000..63a64f0df58
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity30_0.hpp
@@ -0,0 +1,717 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/synthesize_impl/arity20_0.hpp>
+# define BOOST_FT_make_type(flags,cc,arity) BOOST_FT_make_type_impl(flags,cc,arity)
+# define BOOST_FT_make_type_impl(flags,cc,arity) make_type_ ## flags ## _ ## cc ## _ ## arity
+template< typename R , 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 , typename T20 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,21)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 22 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,21) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,22)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 23 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,22) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,23)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 24 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,23) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,24)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 25 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,24) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,25)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 26 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,25) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,26)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 27 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,26) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,27)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 28 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,27) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,28)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 29 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,28) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,29)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 30 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,29) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,30)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 31 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,30) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+> ::type type;
+};
+};
+# undef BOOST_FT_make_type
+# undef BOOST_FT_make_type_impl
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity30_1.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity30_1.hpp
new file mode 100644
index 00000000000..6cba73ea9af
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity30_1.hpp
@@ -0,0 +1,727 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/synthesize_impl/arity20_1.hpp>
+# define BOOST_FT_make_type(flags,cc,arity) BOOST_FT_make_type_impl(flags,cc,arity)
+# define BOOST_FT_make_type_impl(flags,cc,arity) make_type_ ## flags ## _ ## cc ## _ ## arity
+template< typename R , 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 , typename T20 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,21)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 22 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,21) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,22)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 23 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,22) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,23)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 24 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,23) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,24)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 25 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,24) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,25)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 26 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,25) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,26)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 27 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,26) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,27)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 28 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,27) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,28)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 29 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,28) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,29)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 30 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,29) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,30)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 31 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,30) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+> ::type type;
+};
+};
+# undef BOOST_FT_make_type
+# undef BOOST_FT_make_type_impl
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity40_0.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity40_0.hpp
new file mode 100644
index 00000000000..b065757024d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity40_0.hpp
@@ -0,0 +1,917 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/synthesize_impl/arity30_0.hpp>
+# define BOOST_FT_make_type(flags,cc,arity) BOOST_FT_make_type_impl(flags,cc,arity)
+# define BOOST_FT_make_type_impl(flags,cc,arity) make_type_ ## flags ## _ ## cc ## _ ## arity
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,31)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 32 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,31) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,32)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 33 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,32) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,33)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 34 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,33) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,34)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 35 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,34) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,35)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 36 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,35) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,36)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 37 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,36) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,37)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 38 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,37) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,38)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 39 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,38) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,39)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 40 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,39) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,40)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 41 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,40) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+> ::type type;
+};
+};
+# undef BOOST_FT_make_type
+# undef BOOST_FT_make_type_impl
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity40_1.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity40_1.hpp
new file mode 100644
index 00000000000..c9f21941b8a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity40_1.hpp
@@ -0,0 +1,927 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/synthesize_impl/arity30_1.hpp>
+# define BOOST_FT_make_type(flags,cc,arity) BOOST_FT_make_type_impl(flags,cc,arity)
+# define BOOST_FT_make_type_impl(flags,cc,arity) make_type_ ## flags ## _ ## cc ## _ ## arity
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,31)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 32 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,31) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,32)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 33 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,32) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,33)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 34 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,33) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,34)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 35 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,34) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,35)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 36 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,35) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,36)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 37 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,36) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,37)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 38 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,37) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,38)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 39 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,38) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,39)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 40 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,39) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,40)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 41 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,40) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+> ::type type;
+};
+};
+# undef BOOST_FT_make_type
+# undef BOOST_FT_make_type_impl
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity50_0.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity50_0.hpp
new file mode 100644
index 00000000000..b1ad7b14c27
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity50_0.hpp
@@ -0,0 +1,1117 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/synthesize_impl/arity40_0.hpp>
+# define BOOST_FT_make_type(flags,cc,arity) BOOST_FT_make_type_impl(flags,cc,arity)
+# define BOOST_FT_make_type_impl(flags,cc,arity) make_type_ ## flags ## _ ## cc ## _ ## arity
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,41)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 42 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+typedef typename mpl::next< iter_40 > ::type iter_41;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,41) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+, typename mpl::deref< iter_41 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,42)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 43 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+typedef typename mpl::next< iter_40 > ::type iter_41;
+typedef typename mpl::next< iter_41 > ::type iter_42;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,42) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+, typename mpl::deref< iter_41 > ::type
+, typename mpl::deref< iter_42 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,43)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 44 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+typedef typename mpl::next< iter_40 > ::type iter_41;
+typedef typename mpl::next< iter_41 > ::type iter_42;
+typedef typename mpl::next< iter_42 > ::type iter_43;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,43) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+, typename mpl::deref< iter_41 > ::type
+, typename mpl::deref< iter_42 > ::type
+, typename mpl::deref< iter_43 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,44)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 45 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+typedef typename mpl::next< iter_40 > ::type iter_41;
+typedef typename mpl::next< iter_41 > ::type iter_42;
+typedef typename mpl::next< iter_42 > ::type iter_43;
+typedef typename mpl::next< iter_43 > ::type iter_44;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,44) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+, typename mpl::deref< iter_41 > ::type
+, typename mpl::deref< iter_42 > ::type
+, typename mpl::deref< iter_43 > ::type
+, typename mpl::deref< iter_44 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,45)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 46 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+typedef typename mpl::next< iter_40 > ::type iter_41;
+typedef typename mpl::next< iter_41 > ::type iter_42;
+typedef typename mpl::next< iter_42 > ::type iter_43;
+typedef typename mpl::next< iter_43 > ::type iter_44;
+typedef typename mpl::next< iter_44 > ::type iter_45;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,45) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+, typename mpl::deref< iter_41 > ::type
+, typename mpl::deref< iter_42 > ::type
+, typename mpl::deref< iter_43 > ::type
+, typename mpl::deref< iter_44 > ::type
+, typename mpl::deref< iter_45 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,46)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 47 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+typedef typename mpl::next< iter_40 > ::type iter_41;
+typedef typename mpl::next< iter_41 > ::type iter_42;
+typedef typename mpl::next< iter_42 > ::type iter_43;
+typedef typename mpl::next< iter_43 > ::type iter_44;
+typedef typename mpl::next< iter_44 > ::type iter_45;
+typedef typename mpl::next< iter_45 > ::type iter_46;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,46) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+, typename mpl::deref< iter_41 > ::type
+, typename mpl::deref< iter_42 > ::type
+, typename mpl::deref< iter_43 > ::type
+, typename mpl::deref< iter_44 > ::type
+, typename mpl::deref< iter_45 > ::type
+, typename mpl::deref< iter_46 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,47)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 48 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+typedef typename mpl::next< iter_40 > ::type iter_41;
+typedef typename mpl::next< iter_41 > ::type iter_42;
+typedef typename mpl::next< iter_42 > ::type iter_43;
+typedef typename mpl::next< iter_43 > ::type iter_44;
+typedef typename mpl::next< iter_44 > ::type iter_45;
+typedef typename mpl::next< iter_45 > ::type iter_46;
+typedef typename mpl::next< iter_46 > ::type iter_47;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,47) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+, typename mpl::deref< iter_41 > ::type
+, typename mpl::deref< iter_42 > ::type
+, typename mpl::deref< iter_43 > ::type
+, typename mpl::deref< iter_44 > ::type
+, typename mpl::deref< iter_45 > ::type
+, typename mpl::deref< iter_46 > ::type
+, typename mpl::deref< iter_47 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,48)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 49 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+typedef typename mpl::next< iter_40 > ::type iter_41;
+typedef typename mpl::next< iter_41 > ::type iter_42;
+typedef typename mpl::next< iter_42 > ::type iter_43;
+typedef typename mpl::next< iter_43 > ::type iter_44;
+typedef typename mpl::next< iter_44 > ::type iter_45;
+typedef typename mpl::next< iter_45 > ::type iter_46;
+typedef typename mpl::next< iter_46 > ::type iter_47;
+typedef typename mpl::next< iter_47 > ::type iter_48;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,48) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+, typename mpl::deref< iter_41 > ::type
+, typename mpl::deref< iter_42 > ::type
+, typename mpl::deref< iter_43 > ::type
+, typename mpl::deref< iter_44 > ::type
+, typename mpl::deref< iter_45 > ::type
+, typename mpl::deref< iter_46 > ::type
+, typename mpl::deref< iter_47 > ::type
+, typename mpl::deref< iter_48 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 , typename T48 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,49)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 50 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+typedef typename mpl::next< iter_40 > ::type iter_41;
+typedef typename mpl::next< iter_41 > ::type iter_42;
+typedef typename mpl::next< iter_42 > ::type iter_43;
+typedef typename mpl::next< iter_43 > ::type iter_44;
+typedef typename mpl::next< iter_44 > ::type iter_45;
+typedef typename mpl::next< iter_45 > ::type iter_46;
+typedef typename mpl::next< iter_46 > ::type iter_47;
+typedef typename mpl::next< iter_47 > ::type iter_48;
+typedef typename mpl::next< iter_48 > ::type iter_49;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,49) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+, typename mpl::deref< iter_41 > ::type
+, typename mpl::deref< iter_42 > ::type
+, typename mpl::deref< iter_43 > ::type
+, typename mpl::deref< iter_44 > ::type
+, typename mpl::deref< iter_45 > ::type
+, typename mpl::deref< iter_46 > ::type
+, typename mpl::deref< iter_47 > ::type
+, typename mpl::deref< iter_48 > ::type
+, typename mpl::deref< iter_49 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 , typename T48 , typename T49 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,50)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T0 , T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 , T49 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 51 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+typedef typename mpl::next< iter_40 > ::type iter_41;
+typedef typename mpl::next< iter_41 > ::type iter_42;
+typedef typename mpl::next< iter_42 > ::type iter_43;
+typedef typename mpl::next< iter_43 > ::type iter_44;
+typedef typename mpl::next< iter_44 > ::type iter_45;
+typedef typename mpl::next< iter_45 > ::type iter_46;
+typedef typename mpl::next< iter_46 > ::type iter_47;
+typedef typename mpl::next< iter_47 > ::type iter_48;
+typedef typename mpl::next< iter_48 > ::type iter_49;
+typedef typename mpl::next< iter_49 > ::type iter_50;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,50) 
+< typename mpl::deref< iter_0 > ::type 
+, typename mpl::deref< iter_1 > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+, typename mpl::deref< iter_41 > ::type
+, typename mpl::deref< iter_42 > ::type
+, typename mpl::deref< iter_43 > ::type
+, typename mpl::deref< iter_44 > ::type
+, typename mpl::deref< iter_45 > ::type
+, typename mpl::deref< iter_46 > ::type
+, typename mpl::deref< iter_47 > ::type
+, typename mpl::deref< iter_48 > ::type
+, typename mpl::deref< iter_49 > ::type
+, typename mpl::deref< iter_50 > ::type
+> ::type type;
+};
+};
+# undef BOOST_FT_make_type
+# undef BOOST_FT_make_type_impl
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity50_1.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity50_1.hpp
new file mode 100644
index 00000000000..2915c412d7f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/arity50_1.hpp
@@ -0,0 +1,1127 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+// input:  BOOST_FT_syntax     type macro to use
+// input:  BOOST_FT_cc         empty or cc specifier 
+// input:  BOOST_FT_ell        empty or "..."
+// input:  BOOST_FT_cv         empty or cv qualifiers
+// input:  BOOST_FT_flags      single decimal integer encoding the flags
+// output: BOOST_FT_n          number of component types (arity+1)
+// output: BOOST_FT_arity      current arity
+// output: BOOST_FT_type       macro that expands to the type
+// output: BOOST_FT_tplargs(p) template arguments with given prefix
+// output: BOOST_FT_params(p)  parameters with given prefix
+
+# include <boost/function_types/detail/synthesize_impl/arity40_1.hpp>
+# define BOOST_FT_make_type(flags,cc,arity) BOOST_FT_make_type_impl(flags,cc,arity)
+# define BOOST_FT_make_type_impl(flags,cc,arity) make_type_ ## flags ## _ ## cc ## _ ## arity
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,41)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 42 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+typedef typename mpl::next< iter_40 > ::type iter_41;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,41) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+, typename mpl::deref< iter_41 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,42)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 43 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+typedef typename mpl::next< iter_40 > ::type iter_41;
+typedef typename mpl::next< iter_41 > ::type iter_42;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,42) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+, typename mpl::deref< iter_41 > ::type
+, typename mpl::deref< iter_42 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,43)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 44 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+typedef typename mpl::next< iter_40 > ::type iter_41;
+typedef typename mpl::next< iter_41 > ::type iter_42;
+typedef typename mpl::next< iter_42 > ::type iter_43;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,43) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+, typename mpl::deref< iter_41 > ::type
+, typename mpl::deref< iter_42 > ::type
+, typename mpl::deref< iter_43 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,44)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 45 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+typedef typename mpl::next< iter_40 > ::type iter_41;
+typedef typename mpl::next< iter_41 > ::type iter_42;
+typedef typename mpl::next< iter_42 > ::type iter_43;
+typedef typename mpl::next< iter_43 > ::type iter_44;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,44) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+, typename mpl::deref< iter_41 > ::type
+, typename mpl::deref< iter_42 > ::type
+, typename mpl::deref< iter_43 > ::type
+, typename mpl::deref< iter_44 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,45)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 46 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+typedef typename mpl::next< iter_40 > ::type iter_41;
+typedef typename mpl::next< iter_41 > ::type iter_42;
+typedef typename mpl::next< iter_42 > ::type iter_43;
+typedef typename mpl::next< iter_43 > ::type iter_44;
+typedef typename mpl::next< iter_44 > ::type iter_45;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,45) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+, typename mpl::deref< iter_41 > ::type
+, typename mpl::deref< iter_42 > ::type
+, typename mpl::deref< iter_43 > ::type
+, typename mpl::deref< iter_44 > ::type
+, typename mpl::deref< iter_45 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,46)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 47 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+typedef typename mpl::next< iter_40 > ::type iter_41;
+typedef typename mpl::next< iter_41 > ::type iter_42;
+typedef typename mpl::next< iter_42 > ::type iter_43;
+typedef typename mpl::next< iter_43 > ::type iter_44;
+typedef typename mpl::next< iter_44 > ::type iter_45;
+typedef typename mpl::next< iter_45 > ::type iter_46;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,46) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+, typename mpl::deref< iter_41 > ::type
+, typename mpl::deref< iter_42 > ::type
+, typename mpl::deref< iter_43 > ::type
+, typename mpl::deref< iter_44 > ::type
+, typename mpl::deref< iter_45 > ::type
+, typename mpl::deref< iter_46 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,47)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 48 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+typedef typename mpl::next< iter_40 > ::type iter_41;
+typedef typename mpl::next< iter_41 > ::type iter_42;
+typedef typename mpl::next< iter_42 > ::type iter_43;
+typedef typename mpl::next< iter_43 > ::type iter_44;
+typedef typename mpl::next< iter_44 > ::type iter_45;
+typedef typename mpl::next< iter_45 > ::type iter_46;
+typedef typename mpl::next< iter_46 > ::type iter_47;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,47) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+, typename mpl::deref< iter_41 > ::type
+, typename mpl::deref< iter_42 > ::type
+, typename mpl::deref< iter_43 > ::type
+, typename mpl::deref< iter_44 > ::type
+, typename mpl::deref< iter_45 > ::type
+, typename mpl::deref< iter_46 > ::type
+, typename mpl::deref< iter_47 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,48)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 49 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+typedef typename mpl::next< iter_40 > ::type iter_41;
+typedef typename mpl::next< iter_41 > ::type iter_42;
+typedef typename mpl::next< iter_42 > ::type iter_43;
+typedef typename mpl::next< iter_43 > ::type iter_44;
+typedef typename mpl::next< iter_44 > ::type iter_45;
+typedef typename mpl::next< iter_45 > ::type iter_46;
+typedef typename mpl::next< iter_46 > ::type iter_47;
+typedef typename mpl::next< iter_47 > ::type iter_48;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,48) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+, typename mpl::deref< iter_41 > ::type
+, typename mpl::deref< iter_42 > ::type
+, typename mpl::deref< iter_43 > ::type
+, typename mpl::deref< iter_44 > ::type
+, typename mpl::deref< iter_45 > ::type
+, typename mpl::deref< iter_46 > ::type
+, typename mpl::deref< iter_47 > ::type
+, typename mpl::deref< iter_48 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 , typename T48 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,49)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 50 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+typedef typename mpl::next< iter_40 > ::type iter_41;
+typedef typename mpl::next< iter_41 > ::type iter_42;
+typedef typename mpl::next< iter_42 > ::type iter_43;
+typedef typename mpl::next< iter_43 > ::type iter_44;
+typedef typename mpl::next< iter_44 > ::type iter_45;
+typedef typename mpl::next< iter_45 > ::type iter_46;
+typedef typename mpl::next< iter_46 > ::type iter_47;
+typedef typename mpl::next< iter_47 > ::type iter_48;
+typedef typename mpl::next< iter_48 > ::type iter_49;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,49) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+, typename mpl::deref< iter_41 > ::type
+, typename mpl::deref< iter_42 > ::type
+, typename mpl::deref< iter_43 > ::type
+, typename mpl::deref< iter_44 > ::type
+, typename mpl::deref< iter_45 > ::type
+, typename mpl::deref< iter_46 > ::type
+, typename mpl::deref< iter_47 > ::type
+, typename mpl::deref< iter_48 > ::type
+, typename mpl::deref< iter_49 > ::type
+> ::type type;
+};
+};
+template< typename R , 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 , typename T20 , typename T21 , typename T22 , typename T23 , typename T24 , typename T25 , typename T26 , typename T27 , typename T28 , typename T29 , typename T30 , typename T31 , typename T32 , typename T33 , typename T34 , typename T35 , typename T36 , typename T37 , typename T38 , typename T39 , typename T40 , typename T41 , typename T42 , typename T43 , typename T44 , typename T45 , typename T46 , typename T47 , typename T48 , typename T49 >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,50)
+{
+typedef BOOST_FT_syntax(BOOST_FT_cc,type BOOST_PP_EMPTY) (T1 , T2 , T3 , T4 , T5 , T6 , T7 , T8 , T9 , T10 , T11 , T12 , T13 , T14 , T15 , T16 , T17 , T18 , T19 , T20 , T21 , T22 , T23 , T24 , T25 , T26 , T27 , T28 , T29 , T30 , T31 , T32 , T33 , T34 , T35 , T36 , T37 , T38 , T39 , T40 , T41 , T42 , T43 , T44 , T45 , T46 , T47 , T48 , T49 BOOST_FT_ell) BOOST_FT_cv ;
+};
+template< > 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, 51 > 
+{ 
+template<typename S> struct synthesize_impl_i
+{
+private:
+typedef typename mpl::begin<S> ::type iter_0;
+typedef typename mpl::next< iter_0 > ::type iter_1;
+typedef typename mpl::next< iter_1 > ::type iter_2;
+typedef typename mpl::next< iter_2 > ::type iter_3;
+typedef typename mpl::next< iter_3 > ::type iter_4;
+typedef typename mpl::next< iter_4 > ::type iter_5;
+typedef typename mpl::next< iter_5 > ::type iter_6;
+typedef typename mpl::next< iter_6 > ::type iter_7;
+typedef typename mpl::next< iter_7 > ::type iter_8;
+typedef typename mpl::next< iter_8 > ::type iter_9;
+typedef typename mpl::next< iter_9 > ::type iter_10;
+typedef typename mpl::next< iter_10 > ::type iter_11;
+typedef typename mpl::next< iter_11 > ::type iter_12;
+typedef typename mpl::next< iter_12 > ::type iter_13;
+typedef typename mpl::next< iter_13 > ::type iter_14;
+typedef typename mpl::next< iter_14 > ::type iter_15;
+typedef typename mpl::next< iter_15 > ::type iter_16;
+typedef typename mpl::next< iter_16 > ::type iter_17;
+typedef typename mpl::next< iter_17 > ::type iter_18;
+typedef typename mpl::next< iter_18 > ::type iter_19;
+typedef typename mpl::next< iter_19 > ::type iter_20;
+typedef typename mpl::next< iter_20 > ::type iter_21;
+typedef typename mpl::next< iter_21 > ::type iter_22;
+typedef typename mpl::next< iter_22 > ::type iter_23;
+typedef typename mpl::next< iter_23 > ::type iter_24;
+typedef typename mpl::next< iter_24 > ::type iter_25;
+typedef typename mpl::next< iter_25 > ::type iter_26;
+typedef typename mpl::next< iter_26 > ::type iter_27;
+typedef typename mpl::next< iter_27 > ::type iter_28;
+typedef typename mpl::next< iter_28 > ::type iter_29;
+typedef typename mpl::next< iter_29 > ::type iter_30;
+typedef typename mpl::next< iter_30 > ::type iter_31;
+typedef typename mpl::next< iter_31 > ::type iter_32;
+typedef typename mpl::next< iter_32 > ::type iter_33;
+typedef typename mpl::next< iter_33 > ::type iter_34;
+typedef typename mpl::next< iter_34 > ::type iter_35;
+typedef typename mpl::next< iter_35 > ::type iter_36;
+typedef typename mpl::next< iter_36 > ::type iter_37;
+typedef typename mpl::next< iter_37 > ::type iter_38;
+typedef typename mpl::next< iter_38 > ::type iter_39;
+typedef typename mpl::next< iter_39 > ::type iter_40;
+typedef typename mpl::next< iter_40 > ::type iter_41;
+typedef typename mpl::next< iter_41 > ::type iter_42;
+typedef typename mpl::next< iter_42 > ::type iter_43;
+typedef typename mpl::next< iter_43 > ::type iter_44;
+typedef typename mpl::next< iter_44 > ::type iter_45;
+typedef typename mpl::next< iter_45 > ::type iter_46;
+typedef typename mpl::next< iter_46 > ::type iter_47;
+typedef typename mpl::next< iter_47 > ::type iter_48;
+typedef typename mpl::next< iter_48 > ::type iter_49;
+typedef typename mpl::next< iter_49 > ::type iter_50;
+public:
+typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,50) 
+< typename mpl::deref< iter_0 > ::type 
+, typename detail::cv_traits< 
+typename mpl::deref< iter_1 > ::type > ::type
+, typename mpl::deref< iter_2 > ::type
+, typename mpl::deref< iter_3 > ::type
+, typename mpl::deref< iter_4 > ::type
+, typename mpl::deref< iter_5 > ::type
+, typename mpl::deref< iter_6 > ::type
+, typename mpl::deref< iter_7 > ::type
+, typename mpl::deref< iter_8 > ::type
+, typename mpl::deref< iter_9 > ::type
+, typename mpl::deref< iter_10 > ::type
+, typename mpl::deref< iter_11 > ::type
+, typename mpl::deref< iter_12 > ::type
+, typename mpl::deref< iter_13 > ::type
+, typename mpl::deref< iter_14 > ::type
+, typename mpl::deref< iter_15 > ::type
+, typename mpl::deref< iter_16 > ::type
+, typename mpl::deref< iter_17 > ::type
+, typename mpl::deref< iter_18 > ::type
+, typename mpl::deref< iter_19 > ::type
+, typename mpl::deref< iter_20 > ::type
+, typename mpl::deref< iter_21 > ::type
+, typename mpl::deref< iter_22 > ::type
+, typename mpl::deref< iter_23 > ::type
+, typename mpl::deref< iter_24 > ::type
+, typename mpl::deref< iter_25 > ::type
+, typename mpl::deref< iter_26 > ::type
+, typename mpl::deref< iter_27 > ::type
+, typename mpl::deref< iter_28 > ::type
+, typename mpl::deref< iter_29 > ::type
+, typename mpl::deref< iter_30 > ::type
+, typename mpl::deref< iter_31 > ::type
+, typename mpl::deref< iter_32 > ::type
+, typename mpl::deref< iter_33 > ::type
+, typename mpl::deref< iter_34 > ::type
+, typename mpl::deref< iter_35 > ::type
+, typename mpl::deref< iter_36 > ::type
+, typename mpl::deref< iter_37 > ::type
+, typename mpl::deref< iter_38 > ::type
+, typename mpl::deref< iter_39 > ::type
+, typename mpl::deref< iter_40 > ::type
+, typename mpl::deref< iter_41 > ::type
+, typename mpl::deref< iter_42 > ::type
+, typename mpl::deref< iter_43 > ::type
+, typename mpl::deref< iter_44 > ::type
+, typename mpl::deref< iter_45 > ::type
+, typename mpl::deref< iter_46 > ::type
+, typename mpl::deref< iter_47 > ::type
+, typename mpl::deref< iter_48 > ::type
+, typename mpl::deref< iter_49 > ::type
+, typename mpl::deref< iter_50 > ::type
+> ::type type;
+};
+};
+# undef BOOST_FT_make_type
+# undef BOOST_FT_make_type_impl
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/master.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/master.hpp
new file mode 100644
index 00000000000..49d38ef4d49
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/synthesize_impl/master.hpp
@@ -0,0 +1,87 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+// no include guards, this file is intended for multiple inclusion
+
+#if   BOOST_FT_ARITY_LOOP_PREFIX
+
+#   ifndef BOOST_FT_DETAIL_SYNTHESIZE_IMPL_MASTER_HPP_INCLUDED
+#   define BOOST_FT_DETAIL_SYNTHESIZE_IMPL_MASTER_HPP_INCLUDED
+#     include <boost/preprocessor/cat.hpp>
+#     include <boost/preprocessor/arithmetic/dec.hpp>
+#     include <boost/preprocessor/iteration/local.hpp>
+#     include <boost/preprocessor/facilities/empty.hpp>
+#     include <boost/preprocessor/facilities/identity.hpp>
+#   endif
+
+#   define BOOST_FT_type_name type
+
+#   ifdef BOOST_FT_flags
+#     define BOOST_FT_make_type(flags,cc,arity) BOOST_FT_make_type_impl(flags,cc,arity)
+#     define BOOST_FT_make_type_impl(flags,cc,arity) make_type_ ## flags ## _ ## cc ## _ ## arity
+#   else
+BOOST_PP_EXPAND(#) define BOOST_FT_make_type(flags,cc,arity) BOOST_FT_make_type_impl(flags,cc,arity)
+BOOST_PP_EXPAND(#) define BOOST_FT_make_type_impl(flags,cc,arity) make_type_ ## flags ## _ ## cc ## _ ## arity
+#   endif
+
+#   define BOOST_FT_iter(i) BOOST_PP_CAT(iter_,i)
+
+#elif BOOST_FT_ARITY_LOOP_IS_ITERATING
+
+template< BOOST_FT_tplargs(BOOST_PP_IDENTITY(typename)) >
+struct BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,BOOST_FT_arity)
+{
+  typedef BOOST_FT_type ;
+};
+
+template<> 
+struct synthesize_impl_o< BOOST_FT_flags, BOOST_FT_cc_id, BOOST_FT_n > 
+{ 
+  template<typename S> struct synthesize_impl_i
+  {
+  private:
+    typedef typename mpl::begin<S>::type BOOST_FT_iter(0);
+#   if BOOST_FT_n > 1
+#     define BOOST_PP_LOCAL_MACRO(i) typedef typename mpl::next< \
+          BOOST_FT_iter(BOOST_PP_DEC(i)) >::type BOOST_FT_iter(i);
+#     define BOOST_PP_LOCAL_LIMITS (1,BOOST_FT_n-1)
+#     include BOOST_PP_LOCAL_ITERATE()
+#   endif
+  public:
+    typedef typename detail::BOOST_FT_make_type(BOOST_FT_flags,BOOST_FT_cc_id,BOOST_FT_arity) 
+    < typename mpl::deref< BOOST_FT_iter(0) >::type 
+#   if BOOST_FT_mfp
+    , typename detail::cv_traits< 
+          typename mpl::deref< BOOST_FT_iter(1) >::type >::type
+#   endif
+#   if BOOST_FT_n > (BOOST_FT_mfp+1)
+#     define BOOST_PP_LOCAL_LIMITS (BOOST_FT_mfp+1,BOOST_FT_n-1)
+#     define BOOST_PP_LOCAL_MACRO(i) \
+        , typename mpl::deref< BOOST_FT_iter(i) >::type
+#     include BOOST_PP_LOCAL_ITERATE()
+#   endif
+    >::type type;
+  };
+};
+
+#elif BOOST_FT_ARITY_LOOP_SUFFIX
+
+#   ifdef BOOST_FT_flags
+#     undef BOOST_FT_make_type
+#     undef BOOST_FT_make_type_impl
+#   else
+BOOST_PP_EXPAND(#) undef BOOST_FT_make_type
+BOOST_PP_EXPAND(#) undef BOOST_FT_make_type_impl
+#   endif
+#   undef BOOST_FT_iter
+#   undef BOOST_FT_type_name
+
+#else
+#   error "attempt to use arity loop master file without loop"
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/detail/to_sequence.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/detail/to_sequence.hpp
new file mode 100644
index 00000000000..54854dbfac8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/detail/to_sequence.hpp
@@ -0,0 +1,45 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_DETAIL_TO_SEQUENCE_HPP_INCLUDED
+#define BOOST_FT_DETAIL_TO_SEQUENCE_HPP_INCLUDED
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/type_traits/add_reference.hpp>
+
+#include <boost/function_types/is_callable_builtin.hpp>
+
+namespace boost { namespace function_types { namespace detail {
+
+// wrap first arguments in components, if callable builtin type
+template<typename T>
+struct to_sequence
+{
+  typedef typename
+   mpl::eval_if
+   < is_callable_builtin<T>
+   , to_sequence< components<T> >
+   , mpl::identity< T >
+   >::type
+  type;
+};
+
+// reduce template instantiations, if possible
+template<typename T, typename U>
+struct to_sequence< components<T,U> > 
+{
+  typedef typename components<T,U>::types type;
+};
+
+} } } // namespace ::boost::function_types::detail
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/function_arity.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/function_arity.hpp
new file mode 100644
index 00000000000..a81001be3fb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/function_arity.hpp
@@ -0,0 +1,36 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_FUNCTION_ARITY_HPP_INCLUDED
+#define BOOST_FT_FUNCTION_ARITY_HPP_INCLUDED
+
+#include <boost/blank.hpp>
+#include <boost/mpl/if.hpp>
+
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+#include <boost/function_types/is_callable_builtin.hpp>
+#include <boost/function_types/components.hpp>
+
+namespace boost 
+{ 
+  namespace function_types 
+  {
+    template<typename T> struct function_arity
+      : mpl::if_
+        < function_types::is_callable_builtin<T>
+        , typename components<T>::function_arity, boost::blank
+        >::type
+    {
+      BOOST_MPL_AUX_LAMBDA_SUPPORT(1,function_arity,(T)) 
+    };
+  }
+}
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/function_pointer.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/function_pointer.hpp
new file mode 100644
index 00000000000..cb139187f0d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/function_pointer.hpp
@@ -0,0 +1,30 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_FUNCTION_POINTER_HPP_INCLUDED
+#define BOOST_FT_FUNCTION_POINTER_HPP_INCLUDED
+
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+#include <boost/function_types/function_type.hpp>
+
+namespace boost 
+{ 
+  namespace function_types 
+  {
+    template<typename Types, typename Tag = null_tag> struct function_pointer
+    {
+      typedef typename function_types::function_type<Types,Tag>::type * type;
+
+      BOOST_MPL_AUX_LAMBDA_SUPPORT(2,function_pointer,(Types,Tag))
+    };
+  } 
+} 
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/function_reference.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/function_reference.hpp
new file mode 100644
index 00000000000..3eceae00ea3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/function_reference.hpp
@@ -0,0 +1,30 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_FUNCTION_REFERENCE_HPP_INCLUDED
+#define BOOST_FT_FUNCTION_REFERENCE_HPP_INCLUDED
+
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+#include <boost/function_types/function_type.hpp>
+
+namespace boost 
+{ 
+  namespace function_types 
+  {
+    template<typename Types, typename Tag = null_tag> struct function_reference
+    {
+      typedef typename function_types::function_type<Types,Tag>::type & type;
+
+      BOOST_MPL_AUX_LAMBDA_SUPPORT(2,function_reference,(Types,Tag))
+    };
+  } 
+} 
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/function_type.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/function_type.hpp
new file mode 100644
index 00000000000..afe3654a7c7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/function_type.hpp
@@ -0,0 +1,28 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_FUNCTION_TYPE_HPP_INCLUDED
+#define BOOST_FT_FUNCTION_TYPE_HPP_INCLUDED
+
+#include <boost/function_types/detail/synthesize.hpp>
+#include <boost/function_types/detail/to_sequence.hpp>
+
+namespace boost 
+{ 
+  namespace function_types 
+  {
+    template<typename Types, typename Tag = null_tag> struct function_type
+      : detail::synthesize_func<typename detail::to_sequence<Types>::type, Tag>
+    {
+      BOOST_MPL_AUX_LAMBDA_SUPPORT(2,function_type,(Types,Tag))
+    };
+  }
+}
+
+#endif
+ 
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/is_callable_builtin.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/is_callable_builtin.hpp
new file mode 100644
index 00000000000..3b826ea5805
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/is_callable_builtin.hpp
@@ -0,0 +1,33 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_IS_CALLABLE_BUILTIN_HPP_INCLUDED
+#define BOOST_FT_IS_CALLABLE_BUILTIN_HPP_INCLUDED
+
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+#include <boost/function_types/components.hpp>
+
+namespace boost 
+{ 
+  namespace function_types 
+  {
+    template< typename T, typename Tag = null_tag > 
+    struct is_callable_builtin
+      : function_types::represents
+        < function_types::components<T>
+        , function_types::tag<Tag, detail::callable_builtin_tag> 
+        >
+    { 
+      BOOST_MPL_AUX_LAMBDA_SUPPORT(2,is_callable_builtin,(T,Tag))
+    };
+  }
+}
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/is_function.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/is_function.hpp
new file mode 100644
index 00000000000..09f75b1c18d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/is_function.hpp
@@ -0,0 +1,32 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_IS_FUNCTION_HPP_INCLUDED
+#define BOOST_FT_IS_FUNCTION_HPP_INCLUDED
+
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+#include <boost/function_types/components.hpp>
+
+namespace boost 
+{ 
+  namespace function_types 
+  {
+    template< typename T, typename Tag = null_tag > 
+    struct is_function
+      : function_types::represents
+        < function_types::components<T>
+        , function_types::tag<Tag ,detail::function_tag> 
+        >
+    { 
+      BOOST_MPL_AUX_LAMBDA_SUPPORT(2,is_function,(T,Tag))
+    };
+  }
+} 
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/is_function_pointer.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/is_function_pointer.hpp
new file mode 100644
index 00000000000..67a04026f4a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/is_function_pointer.hpp
@@ -0,0 +1,32 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_IS_FUNCTION_POINTER_HPP_INCLUDED
+#define BOOST_FT_IS_FUNCTION_POINTER_HPP_INCLUDED
+
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+#include <boost/function_types/components.hpp>
+
+namespace boost 
+{ 
+  namespace function_types 
+  {
+    template< typename T, typename Tag = null_tag > 
+    struct is_function_pointer
+      : function_types::represents
+        < function_types::components<T>
+        , function_types::tag<Tag ,detail::pointer_tag> 
+        >
+    { 
+      BOOST_MPL_AUX_LAMBDA_SUPPORT(2,is_function_pointer,(T,Tag))
+    };
+  }
+}
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/is_function_reference.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/is_function_reference.hpp
new file mode 100644
index 00000000000..6bf908dc5de
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/is_function_reference.hpp
@@ -0,0 +1,32 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_IS_FUNCTION_REFERENCE_HPP_INCLUDED
+#define BOOST_FT_IS_FUNCTION_REFERENCE_HPP_INCLUDED
+
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+#include <boost/function_types/components.hpp>
+
+namespace boost 
+{ 
+  namespace function_types 
+  {
+    template< typename T, typename Tag = null_tag > 
+    struct is_function_reference
+      : function_types::represents
+        < function_types::components<T>
+        , function_types::tag<Tag ,detail::reference_tag> >
+    { 
+      BOOST_MPL_AUX_LAMBDA_SUPPORT(2,is_function_reference,(T,Tag))
+    };
+  }
+} 
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/is_member_function_pointer.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/is_member_function_pointer.hpp
new file mode 100644
index 00000000000..ef547657a37
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/is_member_function_pointer.hpp
@@ -0,0 +1,31 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED
+#define BOOST_FT_IS_MEMBER_FUNCTION_POINTER_HPP_INCLUDED
+
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+#include <boost/function_types/components.hpp>
+
+namespace boost 
+{ 
+  namespace function_types 
+  {
+    template< typename T, typename Tag = null_tag > 
+    struct is_member_function_pointer
+      : function_types::represents
+        < function_types::components<T>
+        , function_types::tag<Tag ,detail::member_function_pointer_tag> >
+    { 
+      BOOST_MPL_AUX_LAMBDA_SUPPORT(2,is_member_function_pointer,(T,Tag))
+    };
+  }
+} 
+#endif 
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/is_member_object_pointer.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/is_member_object_pointer.hpp
new file mode 100644
index 00000000000..10bc89a1633
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/is_member_object_pointer.hpp
@@ -0,0 +1,32 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_IS_MEMBER_OBJECT_POINTER_HPP_INCLUDED
+#define BOOST_FT_IS_MEMBER_OBJECT_POINTER_HPP_INCLUDED
+
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+#include <boost/function_types/components.hpp>
+
+namespace boost 
+{ 
+  namespace function_types 
+  {
+    template< typename T > 
+    struct is_member_object_pointer
+      : function_types::detail::represents_impl
+        < function_types::components<T>
+        , detail::member_object_pointer_tag >
+    { 
+      BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_member_object_pointer,(T))
+    };
+  }
+} 
+
+#endif 
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/is_member_pointer.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/is_member_pointer.hpp
new file mode 100644
index 00000000000..db1da29dc45
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/is_member_pointer.hpp
@@ -0,0 +1,32 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_IS_MEMBER_POINTER_HPP_INCLUDED
+#define BOOST_FT_IS_MEMBER_POINTER_HPP_INCLUDED
+
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+#include <boost/function_types/components.hpp>
+
+namespace boost 
+{ 
+  namespace function_types 
+  {
+    template< typename T, typename Tag = null_tag > 
+    struct is_member_pointer
+      : function_types::represents
+        < function_types::components<T>
+        , function_types::tag<Tag ,detail::member_pointer_tag> 
+        >
+    {
+      BOOST_MPL_AUX_LAMBDA_SUPPORT(2,is_member_pointer,(T,Tag))
+    };
+  } 
+} 
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/is_nonmember_callable_builtin.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/is_nonmember_callable_builtin.hpp
new file mode 100644
index 00000000000..61052858b73
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/is_nonmember_callable_builtin.hpp
@@ -0,0 +1,33 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_IS_NONMEMBER_CALLABLE_BUILTIN_HPP_INCLUDED
+#define BOOST_FT_IS_NONMEMBER_CALLABLE_BUILTIN_HPP_INCLUDED
+
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+#include <boost/function_types/components.hpp>
+
+namespace boost 
+{ 
+  namespace function_types 
+  {
+    template< typename T, typename Tag = null_tag > 
+    struct is_nonmember_callable_builtin
+      : function_types::represents
+        < function_types::components<T>
+        , function_types::tag<Tag,detail::nonmember_callable_builtin_tag> 
+        >
+    { 
+      BOOST_MPL_AUX_LAMBDA_SUPPORT(2,is_nonmember_callable_builtin,(T,Tag))
+    };
+  }
+} 
+
+#endif 
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/member_function_pointer.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/member_function_pointer.hpp
new file mode 100644
index 00000000000..104271f103e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/member_function_pointer.hpp
@@ -0,0 +1,31 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_MEMBER_FUNCTION_POINTER_HPP_INCLUDED
+#define BOOST_FT_MEMBER_FUNCTION_POINTER_HPP_INCLUDED
+
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+#include <boost/function_types/detail/synthesize.hpp>
+#include <boost/function_types/detail/to_sequence.hpp>
+
+namespace boost 
+{ 
+  namespace function_types 
+  {
+    template<typename Types, typename Tag = null_tag> 
+    struct member_function_pointer
+      : detail::synthesize_mfp< typename detail::to_sequence<Types>::type, Tag >
+    { 
+      BOOST_MPL_AUX_LAMBDA_SUPPORT(2,member_function_pointer,(Types,Tag))
+    };
+  } 
+} 
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/member_object_pointer.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/member_object_pointer.hpp
new file mode 100644
index 00000000000..1951654550e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/member_object_pointer.hpp
@@ -0,0 +1,32 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_MEMBER_OBJECT_POINTER_HPP_INCLUDED
+#define BOOST_FT_MEMBER_OBJECT_POINTER_HPP_INCLUDED
+
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+#include <boost/function_types/detail/synthesize.hpp>
+#include <boost/function_types/detail/to_sequence.hpp>
+
+namespace boost 
+{ 
+  namespace function_types 
+  {
+    template<typename Types> 
+    struct member_object_pointer
+      : detail::synthesize_mop< typename detail::to_sequence<Types>::type >
+    { 
+      BOOST_MPL_AUX_LAMBDA_SUPPORT(1,member_object_pointer,(Types))
+    };
+  } 
+} 
+
+#endif
+
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/parameter_types.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/parameter_types.hpp
new file mode 100644
index 00000000000..227ad27325b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/parameter_types.hpp
@@ -0,0 +1,53 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_PARAMETER_TYPES_HPP_INCLUDED
+#define BOOST_FT_PARAMETER_TYPES_HPP_INCLUDED
+
+#include <boost/blank.hpp>
+#include <boost/mpl/if.hpp>
+
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+#include <boost/mpl/pop_front.hpp>
+
+#include <boost/function_types/is_callable_builtin.hpp>
+#include <boost/function_types/components.hpp>
+
+namespace boost 
+{ 
+  namespace function_types 
+  {
+    using mpl::placeholders::_;
+ 
+    template< typename T, typename ClassTypeTransform = add_reference<_> >
+    struct parameter_types;
+
+    namespace detail
+    {
+      template<typename T, typename ClassTypeTransform> 
+      struct parameter_types_impl
+        : mpl::pop_front
+          < typename function_types::components<T,ClassTypeTransform>::types 
+          >::type
+      { };
+    }
+
+    template<typename T, typename ClassTypeTransform> struct parameter_types
+      : mpl::if_
+        < function_types::is_callable_builtin<T>
+        , detail::parameter_types_impl<T,ClassTypeTransform>, boost::blank
+        >::type
+    {
+      BOOST_MPL_AUX_LAMBDA_SUPPORT(2,parameter_types,(T,ClassTypeTransform)) 
+    };
+  }
+}
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/property_tags.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/property_tags.hpp
new file mode 100644
index 00000000000..c2158d352d3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/property_tags.hpp
@@ -0,0 +1,147 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_DETAIL_TAGS_HPP_INCLUDED
+#define BOOST_FT_DETAIL_TAGS_HPP_INCLUDED
+
+#include <cstddef>
+
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/mpl/bitxor.hpp>
+
+
+namespace boost { namespace function_types { 
+
+namespace detail 
+{
+  typedef long bits_t;
+
+  template<bits_t Value> struct constant 
+    : boost::integral_constant<bits_t,Value> 
+  { };
+
+  template<bits_t Bits, bits_t Mask> struct property_tag 
+  {
+    typedef constant<Bits> bits;
+    typedef constant<Mask> mask;
+  };
+
+  template<typename T> struct bits : T::bits { };
+  template<typename T> struct mask : T::mask { };
+
+  // forward declaration, defined in pp_tags
+  template<bits_t Bits, bits_t CCID> struct encode_bits_impl; 
+
+  // forward declaration, defined in pp_tags
+  template<bits_t LHS_bits, bits_t LHS_mask, 
+           bits_t RHS_bits, bits_t RHS_mask> 
+  struct tag_ice;
+ 
+  // forward declaration, defined in retag_default_cc 
+  template<class Tag, class RegTag = Tag> struct retag_default_cc; 
+ 
+  template<bits_t Bits, bits_t CCID> struct encode_bits
+    : constant< 
+        ::boost::function_types::detail::encode_bits_impl<Bits,CCID>::value 
+      >
+  { };
+
+  template<class LHS, class RHS> struct compound_tag
+  {
+    typedef constant<
+      ::boost::function_types::detail::tag_ice
+        < ::boost::function_types::detail::bits<LHS>::value
+        , ::boost::function_types::detail::mask<LHS>::value
+        , ::boost::function_types::detail::bits<RHS>::value
+        , ::boost::function_types::detail::mask<RHS>::value
+        >::combined_bits 
+    > bits;
+
+    typedef constant< 
+      ::boost::function_types::detail::tag_ice
+        < ::boost::function_types::detail::bits<LHS>::value
+        , ::boost::function_types::detail::mask<LHS>::value
+        , ::boost::function_types::detail::bits<RHS>::value
+        , ::boost::function_types::detail::mask<RHS>::value
+        >::combined_mask 
+    > mask; 
+  };
+
+  template <class Base, class PropOld, class PropNew>
+  struct changed_tag
+    : Base
+  {
+    typedef mpl::bitxor_
+        <typename Base::bits, typename PropOld::bits, typename PropNew::bits>
+    bits;
+  };
+
+  template<class Tag, class QueryTag> struct represents_impl
+    : boost::integral_constant<bool,
+        ::boost::function_types::detail::tag_ice
+          < ::boost::function_types::detail::bits<Tag>::value
+          , ::boost::function_types::detail::mask<Tag>::value
+          , ::boost::function_types::detail::bits<QueryTag>::value
+          , ::boost::function_types::detail::mask<QueryTag>::value
+          >::match
+      >
+  { };
+
+} // namespace detail
+
+typedef detail::property_tag<0,0> null_tag;
+
+template<class Tag1, class Tag2, class Tag3 = null_tag, class Tag4 = null_tag>
+struct tag
+  : detail::compound_tag< detail::compound_tag<Tag1,Tag2>, 
+        detail::compound_tag<Tag3,Tag4> >
+{ };
+
+template<class Tag1, class Tag2, class Tag3> struct tag<Tag1,Tag2,Tag3,null_tag>
+  : detail::compound_tag<detail::compound_tag<Tag1,Tag2>,Tag3>
+{ };
+template<class Tag1, class Tag2> struct tag<Tag1,Tag2,null_tag,null_tag>
+  : detail::compound_tag<Tag1,Tag2>
+{ };
+template<class Tag1> struct tag<Tag1,null_tag,null_tag,null_tag>
+  : Tag1
+{ };
+
+
+template<class Tag, class QueryTag> struct represents
+  : detail::represents_impl<Tag, detail::retag_default_cc<QueryTag,Tag> >
+{ };
+
+
+template<class Tag, class QueryTag> struct extract
+{ 
+  typedef detail::constant<
+    ::boost::function_types::detail::tag_ice
+      < ::boost::function_types::detail::bits<Tag>::value
+      , ::boost::function_types::detail::mask<Tag>::value
+      , ::boost::function_types::detail::bits<QueryTag>::value
+      , ::boost::function_types::detail::mask<QueryTag>::value
+      >::extracted_bits 
+  > bits;
+
+  typedef detail::constant< 
+    ::boost::function_types::detail::mask<QueryTag>::value
+  > mask; 
+};
+
+} } // namespace ::boost::function_types
+
+#include <boost/function_types/detail/pp_tags/preprocessed.hpp>
+
+namespace boost { namespace function_types {
+#define BOOST_FT_cc_file <boost/function_types/detail/pp_tags/cc_tag.hpp>
+#include <boost/function_types/detail/pp_loop.hpp>
+} } // namespace boost::function_types
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/function_types/result_type.hpp b/contrib/libboost/boost_1_65_0/boost/function_types/result_type.hpp
new file mode 100644
index 00000000000..db642c88c6d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/function_types/result_type.hpp
@@ -0,0 +1,48 @@
+
+// (C) Copyright Tobias Schwinger
+//
+// Use modification and distribution are subject to the boost Software License,
+// Version 1.0. (See http://www.boost.org/LICENSE_1_0.txt).
+
+//------------------------------------------------------------------------------
+
+#ifndef BOOST_FT_RESULT_TYPE_HPP_INCLUDED
+#define BOOST_FT_RESULT_TYPE_HPP_INCLUDED
+
+#include <boost/blank.hpp>
+#include <boost/mpl/if.hpp>
+
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+#include <boost/mpl/at.hpp>
+
+#include <boost/function_types/is_callable_builtin.hpp>
+#include <boost/function_types/components.hpp>
+
+namespace boost 
+{ 
+  namespace function_types 
+  {
+    template< typename T > struct result_type;
+
+    namespace detail
+    {
+      template<typename T> struct result_type_impl
+        : mpl::at_c
+          < typename function_types::components<T>::types, 0 >
+      { };
+    }
+
+    template<typename T> struct result_type
+      : mpl::if_
+        < function_types::is_callable_builtin<T>
+        , detail::result_type_impl<T>, boost::blank
+        >::type
+    { 
+      BOOST_MPL_AUX_LAMBDA_SUPPORT(1,result_type,(T)) 
+    };
+  }
+}
+
+#endif
+
diff --git a/contrib/libboost/boost_1_62_0/boost/functional/factory.hpp b/contrib/libboost/boost_1_65_0/boost/functional/factory.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/functional/factory.hpp
rename to contrib/libboost/boost_1_65_0/boost/functional/factory.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/functional/forward_adapter.hpp b/contrib/libboost/boost_1_65_0/boost/functional/forward_adapter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/functional/forward_adapter.hpp
rename to contrib/libboost/boost_1_65_0/boost/functional/forward_adapter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/functional/hash.hpp b/contrib/libboost/boost_1_65_0/boost/functional/hash.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/functional/hash.hpp
rename to contrib/libboost/boost_1_65_0/boost/functional/hash.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/functional/hash/detail/float_functions.hpp b/contrib/libboost/boost_1_65_0/boost/functional/hash/detail/float_functions.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/functional/hash/detail/float_functions.hpp
rename to contrib/libboost/boost_1_65_0/boost/functional/hash/detail/float_functions.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/functional/hash/detail/hash_float.hpp b/contrib/libboost/boost_1_65_0/boost/functional/hash/detail/hash_float.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/functional/hash/detail/hash_float.hpp
rename to contrib/libboost/boost_1_65_0/boost/functional/hash/detail/hash_float.hpp
index eb9264f7373..9fb81684595 100644
--- a/contrib/libboost/boost_1_62_0/boost/functional/hash/detail/hash_float.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/functional/hash/detail/hash_float.hpp
@@ -179,7 +179,7 @@ namespace boost
                 hash_float_combine(seed, part);
             }
 
-            hash_float_combine(seed, exp);
+            hash_float_combine(seed, static_cast<std::size_t>(exp));
 
             return seed;
         }
diff --git a/contrib/libboost/boost_1_62_0/boost/functional/hash/detail/limits.hpp b/contrib/libboost/boost_1_65_0/boost/functional/hash/detail/limits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/functional/hash/detail/limits.hpp
rename to contrib/libboost/boost_1_65_0/boost/functional/hash/detail/limits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/functional/hash/extensions.hpp b/contrib/libboost/boost_1_65_0/boost/functional/hash/extensions.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/functional/hash/extensions.hpp
rename to contrib/libboost/boost_1_65_0/boost/functional/hash/extensions.hpp
index eafaefe85dc..cb3c85623b6 100644
--- a/contrib/libboost/boost_1_62_0/boost/functional/hash/extensions.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/functional/hash/extensions.hpp
@@ -254,7 +254,7 @@ namespace boost
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 
     template <class T> struct hash
-        : std::unary_function<T, std::size_t>
+        : boost::hash_detail::hash_base<T>
     {
 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
         std::size_t operator()(T const& val) const
@@ -271,7 +271,7 @@ namespace boost
 
 #if BOOST_WORKAROUND(__DMC__, <= 0x848)
     template <class T, unsigned int n> struct hash<T[n]>
-        : std::unary_function<T[n], std::size_t>
+        : boost::hash_detail::hash_base<T[n]>
     {
         std::size_t operator()(const T* val) const
         {
@@ -296,7 +296,7 @@ namespace boost
         {
             template <class T>
             struct inner
-                : std::unary_function<T, std::size_t>
+                : boost::hash_detail::hash_base<T>
             {
 #if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING)
                 std::size_t operator()(T const& val) const
diff --git a/contrib/libboost/boost_1_62_0/boost/functional/hash/hash.hpp b/contrib/libboost/boost_1_65_0/boost/functional/hash/hash.hpp
similarity index 90%
rename from contrib/libboost/boost_1_62_0/boost/functional/hash/hash.hpp
rename to contrib/libboost/boost_1_65_0/boost/functional/hash/hash.hpp
index 0a8ceeb4742..b461f5f0d77 100644
--- a/contrib/libboost/boost_1_62_0/boost/functional/hash/hash.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/functional/hash/hash.hpp
@@ -62,6 +62,18 @@ namespace boost
 {
     namespace hash_detail
     {
+#if defined(_HAS_AUTO_PTR_ETC) && !_HAS_AUTO_PTR_ETC
+        template <typename T>
+        struct hash_base
+        {
+            typedef T argument_type;
+            typedef std::size_t result_type;
+        };
+#else
+        template <typename T>
+        struct hash_base : std::unary_function<T, std::size_t> {};
+#endif
+
         struct enable_hash_value { typedef std::size_t type; };
 
         template <typename T> struct basic_numbers {};
@@ -95,6 +107,16 @@ namespace boost
             boost::hash_detail::enable_hash_value {};
 #endif
 
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+        template <> struct basic_numbers<char16_t> :
+            boost::hash_detail::enable_hash_value {};
+#endif
+
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+        template <> struct basic_numbers<char32_t> :
+            boost::hash_detail::enable_hash_value {};
+#endif
+
         // long_numbers is defined like this to allow for separate
         // specialization for long_long and int128_type, in case
         // they conflict.
@@ -168,10 +190,10 @@ namespace boost
         template <class T>
         inline std::size_t hash_value_signed(T val)
         {
-             const int size_t_bits = std::numeric_limits<std::size_t>::digits;
+             const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits;
              // ceiling(std::numeric_limits<T>::digits / size_t_bits) - 1
              const int length = (std::numeric_limits<T>::digits - 1)
-                 / size_t_bits;
+                 / static_cast<int>(size_t_bits);
 
              std::size_t seed = 0;
              T positive = val < 0 ? -1 - val : val;
@@ -189,10 +211,10 @@ namespace boost
         template <class T>
         inline std::size_t hash_value_unsigned(T val)
         {
-             const int size_t_bits = std::numeric_limits<std::size_t>::digits;
+             const unsigned int size_t_bits = std::numeric_limits<std::size_t>::digits;
              // ceiling(std::numeric_limits<T>::digits / size_t_bits) - 1
              const int length = (std::numeric_limits<T>::digits - 1)
-                 / size_t_bits;
+                 / static_cast<int>(size_t_bits);
 
              std::size_t seed = 0;
 
@@ -236,7 +258,7 @@ namespace boost
         inline void hash_combine_impl(boost::uint64_t& h,
                 boost::uint64_t k)
         {
-            const uint64_t m = UINT64_C(0xc6a4a7935bd1e995);
+            const boost::uint64_t m = UINT64_C(0xc6a4a7935bd1e995);
             const int r = 47;
 
             k *= m;
@@ -419,7 +441,7 @@ namespace boost
 
 #define BOOST_HASH_SPECIALIZE(type) \
     template <> struct hash<type> \
-         : public std::unary_function<type, std::size_t> \
+         : public boost::hash_detail::hash_base<type> \
     { \
         std::size_t operator()(type v) const \
         { \
@@ -429,7 +451,7 @@ namespace boost
 
 #define BOOST_HASH_SPECIALIZE_REF(type) \
     template <> struct hash<type> \
-         : public std::unary_function<type, std::size_t> \
+         : public boost::hash_detail::hash_base<type> \
     { \
         std::size_t operator()(type const& v) const \
         { \
@@ -443,6 +465,12 @@ namespace boost
     BOOST_HASH_SPECIALIZE(unsigned char)
 #if !defined(BOOST_NO_INTRINSIC_WCHAR_T)
     BOOST_HASH_SPECIALIZE(wchar_t)
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+    BOOST_HASH_SPECIALIZE(char16_t)
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+    BOOST_HASH_SPECIALIZE(char32_t)
 #endif
     BOOST_HASH_SPECIALIZE(short)
     BOOST_HASH_SPECIALIZE(unsigned short)
@@ -456,9 +484,15 @@ namespace boost
     BOOST_HASH_SPECIALIZE(long double)
 
     BOOST_HASH_SPECIALIZE_REF(std::string)
-#if !defined(BOOST_NO_STD_WSTRING)
+#if !defined(BOOST_NO_STD_WSTRING) && !defined(BOOST_NO_INTRINSIC_WCHAR_T)
     BOOST_HASH_SPECIALIZE_REF(std::wstring)
 #endif
+#if !defined(BOOST_NO_CXX11_CHAR16_T)
+    BOOST_HASH_SPECIALIZE_REF(std::basic_string<char16_t>)
+#endif
+#if !defined(BOOST_NO_CXX11_CHAR32_T)
+    BOOST_HASH_SPECIALIZE_REF(std::basic_string<char32_t>)
+#endif
 
 #if !defined(BOOST_NO_LONG_LONG)
     BOOST_HASH_SPECIALIZE(boost::long_long_type)
@@ -483,7 +517,7 @@ namespace boost
 
     template <class T>
     struct hash<T*>
-        : public std::unary_function<T*, std::size_t>
+        : public boost::hash_detail::hash_base<T*>
     {
         std::size_t operator()(T* v) const
         {
@@ -516,7 +550,7 @@ namespace boost
         {
             template <class T>
             struct inner
-                : public std::unary_function<T, std::size_t>
+                : public boost::hash_detail::hash_base<T>
             {
                 std::size_t operator()(T val) const
                 {
diff --git a/contrib/libboost/boost_1_62_0/boost/functional/hash/hash_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/functional/hash/hash_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/functional/hash/hash_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/functional/hash/hash_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/functional/hash_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/functional/hash_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/functional/hash_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/functional/hash_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/functional/lightweight_forward_adapter.hpp b/contrib/libboost/boost_1_65_0/boost/functional/lightweight_forward_adapter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/functional/lightweight_forward_adapter.hpp
rename to contrib/libboost/boost_1_65_0/boost/functional/lightweight_forward_adapter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/functional/overloaded_function.hpp b/contrib/libboost/boost_1_65_0/boost/functional/overloaded_function.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/functional/overloaded_function.hpp
rename to contrib/libboost/boost_1_65_0/boost/functional/overloaded_function.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/functional/overloaded_function/config.hpp b/contrib/libboost/boost_1_65_0/boost/functional/overloaded_function/config.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/functional/overloaded_function/config.hpp
rename to contrib/libboost/boost_1_65_0/boost/functional/overloaded_function/config.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/functional/overloaded_function/detail/base.hpp b/contrib/libboost/boost_1_65_0/boost/functional/overloaded_function/detail/base.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/functional/overloaded_function/detail/base.hpp
rename to contrib/libboost/boost_1_65_0/boost/functional/overloaded_function/detail/base.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/functional/overloaded_function/detail/function_type.hpp b/contrib/libboost/boost_1_65_0/boost/functional/overloaded_function/detail/function_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/functional/overloaded_function/detail/function_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/functional/overloaded_function/detail/function_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/functional/value_factory.hpp b/contrib/libboost/boost_1_65_0/boost/functional/value_factory.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/functional/value_factory.hpp
rename to contrib/libboost/boost_1_65_0/boost/functional/value_factory.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry.hpp b/contrib/libboost/boost_1_65_0/boost/geometry.hpp
new file mode 100644
index 00000000000..a4756e71463
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry.hpp
@@ -0,0 +1,19 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2011 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2011 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2011 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_HPP
+#define BOOST_GEOMETRY_HPP
+
+#include <boost/geometry/geometry.hpp>
+
+#endif // BOOST_GEOMETRY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/append.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/append.hpp
new file mode 100644
index 00000000000..5cfad0c520f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/append.hpp
@@ -0,0 +1,370 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_APPEND_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_APPEND_HPP
+
+
+#include <boost/range.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/num_interior_rings.hpp>
+#include <boost/geometry/algorithms/detail/convert_point_to_point.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/mutable_range.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/geometries/variant.hpp>
+#include <boost/geometry/util/range.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace append
+{
+
+template <typename Geometry, typename Point>
+struct append_no_action
+{
+    static inline void apply(Geometry& , Point const& ,
+                int = 0, int = 0)
+    {
+    }
+};
+
+template <typename Geometry, typename Point>
+struct append_point
+{
+    static inline void apply(Geometry& geometry, Point const& point,
+                int = 0, int = 0)
+    {
+        typename geometry::point_type<Geometry>::type copy;
+        geometry::detail::conversion::convert_point_to_point(point, copy);
+        traits::push_back<Geometry>::apply(geometry, copy);
+    }
+};
+
+
+template <typename Geometry, typename Range>
+struct append_range
+{
+    typedef typename boost::range_value<Range>::type point_type;
+
+    static inline void apply(Geometry& geometry, Range const& range,
+                int = 0, int = 0)
+    {
+        for (typename boost::range_iterator<Range const>::type
+            it = boost::begin(range);
+             it != boost::end(range);
+             ++it)
+        {
+            append_point<Geometry, point_type>::apply(geometry, *it);
+        }
+    }
+};
+
+
+template <typename Polygon, typename Point>
+struct point_to_polygon
+{
+    typedef typename ring_type<Polygon>::type ring_type;
+
+    static inline void apply(Polygon& polygon, Point const& point,
+                int ring_index, int = 0)
+    {
+        if (ring_index == -1)
+        {
+            append_point<ring_type, Point>::apply(
+                        exterior_ring(polygon), point);
+        }
+        else if (ring_index < int(num_interior_rings(polygon)))
+        {
+            append_point<ring_type, Point>::apply(
+                        range::at(interior_rings(polygon), ring_index), point);
+        }
+    }
+};
+
+
+template <typename Polygon, typename Range>
+struct range_to_polygon
+{
+    typedef typename ring_type<Polygon>::type ring_type;
+
+    static inline void apply(Polygon& polygon, Range const& range,
+                int ring_index, int = 0)
+    {
+        if (ring_index == -1)
+        {
+            append_range<ring_type, Range>::apply(
+                        exterior_ring(polygon), range);
+        }
+        else if (ring_index < int(num_interior_rings(polygon)))
+        {
+            append_range<ring_type, Range>::apply(
+                        range::at(interior_rings(polygon), ring_index), range);
+        }
+    }
+};
+
+
+}} // namespace detail::append
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+namespace splitted_dispatch
+{
+
+template <typename Tag, typename Geometry, typename Point>
+struct append_point
+    : detail::append::append_no_action<Geometry, Point>
+{};
+
+template <typename Geometry, typename Point>
+struct append_point<linestring_tag, Geometry, Point>
+    : detail::append::append_point<Geometry, Point>
+{};
+
+template <typename Geometry, typename Point>
+struct append_point<ring_tag, Geometry, Point>
+    : detail::append::append_point<Geometry, Point>
+{};
+
+
+template <typename Polygon, typename Point>
+struct append_point<polygon_tag, Polygon, Point>
+        : detail::append::point_to_polygon<Polygon, Point>
+{};
+
+
+template <typename Tag, typename Geometry, typename Range>
+struct append_range
+    : detail::append::append_no_action<Geometry, Range>
+{};
+
+template <typename Geometry, typename Range>
+struct append_range<linestring_tag, Geometry, Range>
+    : detail::append::append_range<Geometry, Range>
+{};
+
+template <typename Geometry, typename Range>
+struct append_range<ring_tag, Geometry, Range>
+    : detail::append::append_range<Geometry, Range>
+{};
+
+
+template <typename Polygon, typename Range>
+struct append_range<polygon_tag, Polygon, Range>
+        : detail::append::range_to_polygon<Polygon, Range>
+{};
+
+} // namespace splitted_dispatch
+
+
+// Default: append a range (or linestring or ring or whatever) to any geometry
+template
+<
+    typename Geometry, typename RangeOrPoint,
+    typename TagRangeOrPoint = typename tag<RangeOrPoint>::type
+>
+struct append
+    : splitted_dispatch::append_range<typename tag<Geometry>::type, Geometry, RangeOrPoint>
+{};
+
+// Specialization for point to append a point to any geometry
+template <typename Geometry, typename RangeOrPoint>
+struct append<Geometry, RangeOrPoint, point_tag>
+    : splitted_dispatch::append_point<typename tag<Geometry>::type, Geometry, RangeOrPoint>
+{};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace append
+{
+
+template <typename MultiGeometry, typename RangeOrPoint>
+struct append_to_multigeometry
+{
+    static inline void apply(MultiGeometry& multigeometry,
+                             RangeOrPoint const& range_or_point,
+                             int ring_index, int multi_index)
+    {
+
+        dispatch::append
+            <
+                typename boost::range_value<MultiGeometry>::type,
+                RangeOrPoint
+            >::apply(range::at(multigeometry, multi_index), range_or_point, ring_index);
+    }
+};
+
+}} // namespace detail::append
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+namespace splitted_dispatch
+{
+
+template <typename Geometry, typename Point>
+struct append_point<multi_point_tag, Geometry, Point>
+    : detail::append::append_point<Geometry, Point>
+{};
+
+template <typename Geometry, typename Range>
+struct append_range<multi_point_tag, Geometry, Range>
+    : detail::append::append_range<Geometry, Range>
+{};
+
+template <typename MultiGeometry, typename RangeOrPoint>
+struct append_point<multi_linestring_tag, MultiGeometry, RangeOrPoint>
+    : detail::append::append_to_multigeometry<MultiGeometry, RangeOrPoint>
+{};
+
+template <typename MultiGeometry, typename RangeOrPoint>
+struct append_range<multi_linestring_tag, MultiGeometry, RangeOrPoint>
+    : detail::append::append_to_multigeometry<MultiGeometry, RangeOrPoint>
+{};
+
+template <typename MultiGeometry, typename RangeOrPoint>
+struct append_point<multi_polygon_tag, MultiGeometry, RangeOrPoint>
+    : detail::append::append_to_multigeometry<MultiGeometry, RangeOrPoint>
+{};
+
+template <typename MultiGeometry, typename RangeOrPoint>
+struct append_range<multi_polygon_tag, MultiGeometry, RangeOrPoint>
+    : detail::append::append_to_multigeometry<MultiGeometry, RangeOrPoint>
+{};
+
+} // namespace splitted_dispatch
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_variant {
+
+template <typename Geometry>
+struct append
+{
+    template <typename RangeOrPoint>
+    static inline void apply(Geometry& geometry,
+                             RangeOrPoint const& range_or_point,
+                             int ring_index,
+                             int multi_index)
+    {
+        concepts::check<Geometry>();
+        dispatch::append<Geometry, RangeOrPoint>::apply(geometry,
+                                                        range_or_point,
+                                                        ring_index,
+                                                        multi_index);
+    }
+};
+
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct append<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename RangeOrPoint>
+    struct visitor: boost::static_visitor<void>
+    {
+        RangeOrPoint const& m_range_or_point;
+        int m_ring_index;
+        int m_multi_index;
+
+        visitor(RangeOrPoint const& range_or_point,
+                int ring_index,
+                int multi_index):
+            m_range_or_point(range_or_point),
+            m_ring_index(ring_index),
+            m_multi_index(multi_index)
+        {}
+
+        template <typename Geometry>
+        void operator()(Geometry& geometry) const
+        {
+            append<Geometry>::apply(geometry,
+                                    m_range_or_point,
+                                    m_ring_index,
+                                    m_multi_index);
+        }
+    };
+
+    template <typename RangeOrPoint>
+    static inline void apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>& variant_geometry,
+                             RangeOrPoint const& range_or_point,
+                             int ring_index,
+                             int multi_index)
+    {
+        boost::apply_visitor(
+            visitor<RangeOrPoint>(
+                range_or_point,
+                ring_index,
+                multi_index
+            ),
+            variant_geometry
+        );
+    }
+};
+
+} // namespace resolve_variant;
+
+
+/*!
+\brief Appends one or more points to a linestring, ring, polygon, multi-geometry
+\ingroup append
+\tparam Geometry \tparam_geometry
+\tparam RangeOrPoint Either a range or a point, fullfilling Boost.Range concept or Boost.Geometry Point Concept
+\param geometry \param_geometry
+\param range_or_point The point or range to add
+\param ring_index The index of the ring in case of a polygon:
+    exterior ring (-1, the default) or  interior ring index
+\param multi_index The index of the geometry to which the points are appended
+
+\qbk{[include reference/algorithms/append.qbk]}
+}
+ */
+template <typename Geometry, typename RangeOrPoint>
+inline void append(Geometry& geometry, RangeOrPoint const& range_or_point,
+                   int ring_index = -1, int multi_index = 0)
+{
+    resolve_variant::append<Geometry>
+                   ::apply(geometry, range_or_point, ring_index, multi_index);
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_APPEND_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/area.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/area.hpp
new file mode 100644
index 00000000000..18aea240361
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/area.hpp
@@ -0,0 +1,329 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_AREA_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_AREA_HPP
+
+#include <boost/concept_check.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/range/functions.hpp>
+#include <boost/range/metafunctions.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/point_order.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/algorithms/detail/calculate_null.hpp>
+#include <boost/geometry/algorithms/detail/calculate_sum.hpp>
+// #include <boost/geometry/algorithms/detail/throw_on_empty_input.hpp>
+#include <boost/geometry/algorithms/detail/multi_sum.hpp>
+
+#include <boost/geometry/strategies/area.hpp>
+#include <boost/geometry/strategies/default_area_result.hpp>
+
+#include <boost/geometry/strategies/concepts/area_concept.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/order_as_direction.hpp>
+#include <boost/geometry/views/closeable_view.hpp>
+#include <boost/geometry/views/reversible_view.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace area
+{
+
+struct box_area
+{
+    template <typename Box, typename Strategy>
+    static inline typename coordinate_type<Box>::type
+    apply(Box const& box, Strategy const&)
+    {
+        // Currently only works for 2D Cartesian boxes
+        assert_dimension<Box, 2>();
+
+        return (get<max_corner, 0>(box) - get<min_corner, 0>(box))
+             * (get<max_corner, 1>(box) - get<min_corner, 1>(box));
+    }
+};
+
+
+template
+<
+    iterate_direction Direction,
+    closure_selector Closure
+>
+struct ring_area
+{
+    template <typename Ring, typename Strategy>
+    static inline typename Strategy::return_type
+    apply(Ring const& ring, Strategy const& strategy)
+    {
+        BOOST_CONCEPT_ASSERT( (geometry::concepts::AreaStrategy<Strategy>) );
+        assert_dimension<Ring, 2>();
+
+        // Ignore warning (because using static method sometimes) on strategy
+        boost::ignore_unused_variable_warning(strategy);
+
+        // An open ring has at least three points,
+        // A closed ring has at least four points,
+        // if not, there is no (zero) area
+        if (boost::size(ring)
+                < core_detail::closure::minimum_ring_size<Closure>::value)
+        {
+            return typename Strategy::return_type();
+        }
+
+        typedef typename reversible_view<Ring const, Direction>::type rview_type;
+        typedef typename closeable_view
+            <
+                rview_type const, Closure
+            >::type view_type;
+        typedef typename boost::range_iterator<view_type const>::type iterator_type;
+
+        rview_type rview(ring);
+        view_type view(rview);
+        typename Strategy::state_type state;
+        iterator_type it = boost::begin(view);
+        iterator_type end = boost::end(view);
+
+        for (iterator_type previous = it++;
+            it != end;
+            ++previous, ++it)
+        {
+            strategy.apply(*previous, *it, state);
+        }
+
+        return strategy.result(state);
+    }
+};
+
+
+}} // namespace detail::area
+
+
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Geometry,
+    typename Tag = typename tag<Geometry>::type
+>
+struct area : detail::calculate_null
+{
+    template <typename Strategy>
+    static inline typename Strategy::return_type apply(Geometry const& geometry, Strategy const& strategy)
+    {
+        return calculate_null::apply<typename Strategy::return_type>(geometry, strategy);
+    }
+};
+
+
+template <typename Geometry>
+struct area<Geometry, box_tag> : detail::area::box_area
+{};
+
+
+template <typename Ring>
+struct area<Ring, ring_tag>
+    : detail::area::ring_area
+        <
+            order_as_direction<geometry::point_order<Ring>::value>::value,
+            geometry::closure<Ring>::value
+        >
+{};
+
+
+template <typename Polygon>
+struct area<Polygon, polygon_tag> : detail::calculate_polygon_sum
+{
+    template <typename Strategy>
+    static inline typename Strategy::return_type apply(Polygon const& polygon, Strategy const& strategy)
+    {
+        return calculate_polygon_sum::apply<
+            typename Strategy::return_type,
+            detail::area::ring_area
+                <
+                    order_as_direction<geometry::point_order<Polygon>::value>::value,
+                    geometry::closure<Polygon>::value
+                >
+            >(polygon, strategy);
+    }
+};
+
+
+template <typename MultiGeometry>
+struct area<MultiGeometry, multi_polygon_tag> : detail::multi_sum
+{
+    template <typename Strategy>
+    static inline typename Strategy::return_type
+    apply(MultiGeometry const& multi, Strategy const& strategy)
+    {
+        return multi_sum::apply
+               <
+                   typename Strategy::return_type,
+                   area<typename boost::range_value<MultiGeometry>::type>
+               >(multi, strategy);
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_variant {
+
+template <typename Geometry>
+struct area
+{
+    template <typename Strategy>
+    static inline typename Strategy::return_type apply(Geometry const& geometry,
+                                                       Strategy const& strategy)
+    {
+        return dispatch::area<Geometry>::apply(geometry, strategy);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct area<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Strategy>
+    struct visitor: boost::static_visitor<typename Strategy::return_type>
+    {
+        Strategy const& m_strategy;
+
+        visitor(Strategy const& strategy): m_strategy(strategy) {}
+
+        template <typename Geometry>
+        typename Strategy::return_type operator()(Geometry const& geometry) const
+        {
+            return area<Geometry>::apply(geometry, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline typename Strategy::return_type
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(strategy), geometry);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief \brief_calc{area}
+\ingroup area
+\details \details_calc{area}. \details_default_strategy
+
+The area algorithm calculates the surface area of all geometries having a surface, namely
+box, polygon, ring, multipolygon. The units are the square of the units used for the points
+defining the surface. If subject geometry is defined in meters, then area is calculated
+in square meters.
+
+The area calculation can be done in all three common coordinate systems, Cartesian, Spherical
+and Geographic as well.
+
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\return \return_calc{area}
+
+\qbk{[include reference/algorithms/area.qbk]}
+\qbk{[heading Examples]}
+\qbk{[area] [area_output]}
+*/
+template <typename Geometry>
+inline typename default_area_result<Geometry>::type area(Geometry const& geometry)
+{
+    concepts::check<Geometry const>();
+
+    // TODO put this into a resolve_strategy stage
+    //      (and take the return type from resolve_variant)
+    typedef typename point_type<Geometry>::type point_type;
+    typedef typename strategy::area::services::default_strategy
+        <
+            typename cs_tag<point_type>::type,
+            point_type
+        >::type strategy_type;
+
+    // detail::throw_on_empty_input(geometry);
+
+    return resolve_variant::area<Geometry>::apply(geometry, strategy_type());
+}
+
+/*!
+\brief \brief_calc{area} \brief_strategy
+\ingroup area
+\details \details_calc{area} \brief_strategy. \details_strategy_reasons
+\tparam Geometry \tparam_geometry
+\tparam Strategy \tparam_strategy{Area}
+\param geometry \param_geometry
+\param strategy \param_strategy{area}
+\return \return_calc{area}
+
+\qbk{distinguish,with strategy}
+
+\qbk{
+[include reference/algorithms/area.qbk]
+
+[heading Example]
+[area_with_strategy]
+[area_with_strategy_output]
+
+[heading Available Strategies]
+\* [link geometry.reference.strategies.strategy_area_surveyor Surveyor (cartesian)]
+\* [link geometry.reference.strategies.strategy_area_spherical Spherical]
+[/link geometry.reference.strategies.strategy_area_geographic Geographic]
+}
+ */
+template <typename Geometry, typename Strategy>
+inline typename Strategy::return_type area(
+        Geometry const& geometry, Strategy const& strategy)
+{
+    concepts::check<Geometry const>();
+
+    // detail::throw_on_empty_input(geometry);
+
+    return resolve_variant::area<Geometry>::apply(geometry, strategy);
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_AREA_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/assign.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/assign.hpp
new file mode 100644
index 00000000000..589a5c545bd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/assign.hpp
@@ -0,0 +1,379 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Samuel Debionne, Grenoble, France.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_ASSIGN_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_ASSIGN_HPP
+
+
+#include <cstddef>
+
+#include <boost/concept/requires.hpp>
+#include <boost/concept_check.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/numeric/conversion/bounds.hpp>
+#include <boost/numeric/conversion/cast.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/detail/assign_box_corners.hpp>
+#include <boost/geometry/algorithms/detail/assign_indexed_point.hpp>
+#include <boost/geometry/algorithms/detail/assign_values.hpp>
+#include <boost/geometry/algorithms/convert.hpp>
+#include <boost/geometry/algorithms/append.hpp>
+#include <boost/geometry/algorithms/clear.hpp>
+#include <boost/geometry/arithmetic/arithmetic.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/util/for_each_coordinate.hpp>
+
+namespace boost { namespace geometry
+{
+
+/*!
+\brief Assign a range of points to a linestring, ring or polygon
+\note The point-type of the range might be different from the point-type of the geometry
+\ingroup assign
+\tparam Geometry \tparam_geometry
+\tparam Range \tparam_range_point
+\param geometry \param_geometry
+\param range \param_range_point
+
+\qbk{
+[heading Notes]
+[note Assign automatically clears the geometry before assigning (use append if you don't want that)]
+[heading Example]
+[assign_points] [assign_points_output]
+
+[heading See also]
+\* [link geometry.reference.algorithms.append append]
+}
+ */
+template <typename Geometry, typename Range>
+inline void assign_points(Geometry& geometry, Range const& range)
+{
+    concepts::check<Geometry>();
+
+    clear(geometry);
+    geometry::append(geometry, range, -1, 0);
+}
+
+
+/*!
+\brief assign to a box inverse infinite
+\details The assign_inverse function initialize a 2D or 3D box with large coordinates, the
+min corner is very large, the max corner is very small. This is a convenient starting point to
+collect the minimum bounding box of a geometry.
+\ingroup assign
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+
+\qbk{
+[heading Example]
+[assign_inverse] [assign_inverse_output]
+
+[heading See also]
+\* [link geometry.reference.algorithms.make.make_inverse make_inverse]
+}
+ */
+template <typename Geometry>
+inline void assign_inverse(Geometry& geometry)
+{
+    concepts::check<Geometry>();
+
+    dispatch::assign_inverse
+        <
+            typename tag<Geometry>::type,
+            Geometry
+        >::apply(geometry);
+}
+
+/*!
+\brief assign zero values to a box, point
+\ingroup assign
+\details The assign_zero function initializes a 2D or 3D point or box with coordinates of zero
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+
+ */
+template <typename Geometry>
+inline void assign_zero(Geometry& geometry)
+{
+    concepts::check<Geometry>();
+
+    dispatch::assign_zero
+        <
+            typename tag<Geometry>::type,
+            Geometry
+        >::apply(geometry);
+}
+
+/*!
+\brief Assign two coordinates to a geometry (usually a 2D point)
+\ingroup assign
+\tparam Geometry \tparam_geometry
+\tparam Type \tparam_numeric to specify the coordinates
+\param geometry \param_geometry
+\param c1 \param_x
+\param c2 \param_y
+
+\qbk{distinguish, 2 coordinate values}
+\qbk{
+[heading Example]
+[assign_2d_point] [assign_2d_point_output]
+
+[heading See also]
+\* [link geometry.reference.algorithms.make.make_2_2_coordinate_values make]
+}
+ */
+template <typename Geometry, typename Type>
+inline void assign_values(Geometry& geometry, Type const& c1, Type const& c2)
+{
+    concepts::check<Geometry>();
+
+    dispatch::assign
+        <
+            typename tag<Geometry>::type,
+            Geometry,
+            geometry::dimension<Geometry>::type::value
+        >::apply(geometry, c1, c2);
+}
+
+/*!
+\brief Assign three values to a geometry (usually a 3D point)
+\ingroup assign
+\tparam Geometry \tparam_geometry
+\tparam Type \tparam_numeric to specify the coordinates
+\param geometry \param_geometry
+\param c1 \param_x
+\param c2 \param_y
+\param c3 \param_z
+
+\qbk{distinguish, 3 coordinate values}
+\qbk{
+[heading Example]
+[assign_3d_point] [assign_3d_point_output]
+
+[heading See also]
+\* [link geometry.reference.algorithms.make.make_3_3_coordinate_values make]
+}
+ */
+template <typename Geometry, typename Type>
+inline void assign_values(Geometry& geometry,
+            Type const& c1, Type const& c2, Type const& c3)
+{
+    concepts::check<Geometry>();
+
+    dispatch::assign
+        <
+            typename tag<Geometry>::type,
+            Geometry,
+            geometry::dimension<Geometry>::type::value
+        >::apply(geometry, c1, c2, c3);
+}
+
+/*!
+\brief Assign four values to a geometry (usually a box or segment)
+\ingroup assign
+\tparam Geometry \tparam_geometry
+\tparam Type \tparam_numeric to specify the coordinates
+\param geometry \param_geometry
+\param c1 First coordinate (usually x1)
+\param c2 Second coordinate (usually y1)
+\param c3 Third coordinate (usually x2)
+\param c4 Fourth coordinate (usually y2)
+
+\qbk{distinguish, 4 coordinate values}
+ */
+template <typename Geometry, typename Type>
+inline void assign_values(Geometry& geometry,
+                Type const& c1, Type const& c2, Type const& c3, Type const& c4)
+{
+    concepts::check<Geometry>();
+
+    dispatch::assign
+        <
+            typename tag<Geometry>::type,
+            Geometry,
+            geometry::dimension<Geometry>::type::value
+        >::apply(geometry, c1, c2, c3, c4);
+}
+
+
+
+namespace resolve_variant
+{
+
+template <typename Geometry1, typename Geometry2>
+struct assign
+{
+    static inline void
+    apply(Geometry1& geometry1, const Geometry2& geometry2)
+    {
+        concepts::check<Geometry1>();
+        concepts::check<Geometry2 const>();
+        concepts::check_concepts_and_equal_dimensions<Geometry1, Geometry2 const>();
+            
+        static bool const same_point_order
+            = point_order<Geometry1>::value == point_order<Geometry2>::value;
+        BOOST_MPL_ASSERT_MSG
+        (
+            (same_point_order),
+            ASSIGN_IS_NOT_SUPPORTED_FOR_DIFFERENT_POINT_ORDER,
+            (types<Geometry1, Geometry2>)
+        );
+        static bool const same_closure
+            = closure<Geometry1>::value == closure<Geometry2>::value;
+        BOOST_MPL_ASSERT_MSG
+        (
+            (same_closure),
+            ASSIGN_IS_NOT_SUPPORTED_FOR_DIFFERENT_CLOSURE,
+            (types<Geometry1, Geometry2>)
+        );
+            
+        dispatch::convert<Geometry2, Geometry1>::apply(geometry2, geometry1);
+    }
+};
+    
+    
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
+struct assign<variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
+{
+    struct visitor: static_visitor<void>
+    {
+        Geometry2 const& m_geometry2;
+            
+        visitor(Geometry2 const& geometry2)
+        : m_geometry2(geometry2)
+        {}
+            
+        template <typename Geometry1>
+        result_type operator()(Geometry1& geometry1) const
+        {
+            return assign
+            <
+                Geometry1,
+                Geometry2
+            >::apply
+            (geometry1, m_geometry2);
+        }
+    };
+        
+    static inline void
+    apply(variant<BOOST_VARIANT_ENUM_PARAMS(T)>& geometry1,
+          Geometry2 const& geometry2)
+    {
+        return boost::apply_visitor(visitor(geometry2), geometry1);
+    }
+};
+    
+    
+template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct assign<Geometry1, variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    struct visitor: static_visitor<void>
+    {
+        Geometry1& m_geometry1;
+            
+        visitor(Geometry1 const& geometry1)
+        : m_geometry1(geometry1)
+        {}
+            
+        template <typename Geometry2>
+        result_type operator()(Geometry2 const& geometry2) const
+        {
+            return assign
+            <
+                Geometry1,
+                Geometry2
+            >::apply
+            (m_geometry1, geometry2);
+        }
+    };
+        
+    static inline void
+    apply(Geometry1& geometry1,
+          variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2)
+    {
+        return boost::apply_visitor(visitor(geometry1), geometry2);
+    }
+};
+    
+    
+template <BOOST_VARIANT_ENUM_PARAMS(typename T1), BOOST_VARIANT_ENUM_PARAMS(typename T2)>
+struct assign<variant<BOOST_VARIANT_ENUM_PARAMS(T1)>, variant<BOOST_VARIANT_ENUM_PARAMS(T2)> >
+{
+    struct visitor: static_visitor<void>
+    {
+        template <typename Geometry1, typename Geometry2>
+        result_type operator()(
+                                Geometry1& geometry1,
+                                Geometry2 const& geometry2) const
+        {
+            return assign
+            <
+                Geometry1,
+                Geometry2
+            >::apply
+            (geometry1, geometry2);
+        }
+    };
+        
+    static inline void
+    apply(variant<BOOST_VARIANT_ENUM_PARAMS(T1)>& geometry1,
+          variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2)
+    {
+        return boost::apply_visitor(visitor(), geometry1, geometry2);
+    }
+};
+    
+} // namespace resolve_variant
+    
+
+/*!
+\brief Assigns one geometry to another geometry
+\details The assign algorithm assigns one geometry, e.g. a BOX, to another
+geometry, e.g. a RING. This only works if it is possible and applicable.
+\ingroup assign
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry (target)
+\param geometry2 \param_geometry (source)
+
+\qbk{
+[heading Example]
+[assign] [assign_output]
+
+[heading See also]
+\* [link geometry.reference.algorithms.convert convert]
+}
+ */
+template <typename Geometry1, typename Geometry2>
+inline void assign(Geometry1& geometry1, Geometry2 const& geometry2)
+{
+    resolve_variant::assign<Geometry1, Geometry2>::apply(geometry1, geometry2);
+}
+
+
+}} // namespace boost::geometry
+
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_ASSIGN_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/buffer.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/buffer.hpp
new file mode 100644
index 00000000000..fd6f0fbe6a6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/buffer.hpp
@@ -0,0 +1,302 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_BUFFER_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_BUFFER_HPP
+
+#include <cstddef>
+
+#include <boost/numeric/conversion/cast.hpp>
+
+#include <boost/range.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/clear.hpp>
+#include <boost/geometry/algorithms/envelope.hpp>
+#include <boost/geometry/algorithms/is_empty.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+#include <boost/geometry/arithmetic/arithmetic.hpp>
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/geometries/box.hpp>
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/algorithms/detail/buffer/buffer_inserter.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace buffer
+{
+
+template <typename BoxIn, typename BoxOut, typename T, std::size_t C, std::size_t D, std::size_t N>
+struct box_loop
+{
+    typedef typename coordinate_type<BoxOut>::type coordinate_type;
+
+    static inline void apply(BoxIn const& box_in, T const& distance, BoxOut& box_out)
+    {
+        coordinate_type d = distance;
+        set<C, D>(box_out, get<C, D>(box_in) + d);
+        box_loop<BoxIn, BoxOut, T, C, D + 1, N>::apply(box_in, distance, box_out);
+    }
+};
+
+template <typename BoxIn, typename BoxOut, typename T, std::size_t C, std::size_t N>
+struct box_loop<BoxIn, BoxOut, T, C, N, N>
+{
+    static inline void apply(BoxIn const&, T const&, BoxOut&) {}
+};
+
+// Extends a box with the same amount in all directions
+template<typename BoxIn, typename BoxOut, typename T>
+inline void buffer_box(BoxIn const& box_in, T const& distance, BoxOut& box_out)
+{
+    assert_dimension_equal<BoxIn, BoxOut>();
+
+    static const std::size_t N = dimension<BoxIn>::value;
+
+    box_loop<BoxIn, BoxOut, T, min_corner, 0, N>::apply(box_in, -distance, box_out);
+    box_loop<BoxIn, BoxOut, T, max_corner, 0, N>::apply(box_in, distance, box_out);
+}
+
+
+
+}} // namespace detail::buffer
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Input,
+    typename Output,
+    typename TagIn = typename tag<Input>::type,
+    typename TagOut = typename tag<Output>::type
+>
+struct buffer: not_implemented<TagIn, TagOut>
+{};
+
+
+template <typename BoxIn, typename BoxOut>
+struct buffer<BoxIn, BoxOut, box_tag, box_tag>
+{
+    template <typename Distance>
+    static inline void apply(BoxIn const& box_in, Distance const& distance,
+                Distance const& , BoxOut& box_out)
+    {
+        detail::buffer::buffer_box(box_in, distance, box_out);
+    }
+};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_variant {
+
+template <typename Geometry>
+struct buffer
+{
+    template <typename Distance, typename GeometryOut>
+    static inline void apply(Geometry const& geometry,
+                             Distance const& distance,
+                             Distance const& chord_length,
+                             GeometryOut& out)
+    {
+        dispatch::buffer<Geometry, GeometryOut>::apply(geometry, distance, chord_length, out);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct buffer<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Distance, typename GeometryOut>
+    struct visitor: boost::static_visitor<void>
+    {
+        Distance const& m_distance;
+        Distance const& m_chord_length;
+        GeometryOut& m_out;
+
+        visitor(Distance const& distance,
+                Distance const& chord_length,
+                GeometryOut& out)
+        : m_distance(distance),
+          m_chord_length(chord_length),
+          m_out(out)
+        {}
+
+        template <typename Geometry>
+        void operator()(Geometry const& geometry) const
+        {
+            buffer<Geometry>::apply(geometry, m_distance, m_chord_length, m_out);
+        }
+    };
+
+    template <typename Distance, typename GeometryOut>
+    static inline void apply(
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry,
+        Distance const& distance,
+        Distance const& chord_length,
+        GeometryOut& out
+    )
+    {
+        boost::apply_visitor(visitor<Distance, GeometryOut>(distance, chord_length, out), geometry);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief \brief_calc{buffer}
+\ingroup buffer
+\details \details_calc{buffer, \det_buffer}.
+\tparam Input \tparam_geometry
+\tparam Output \tparam_geometry
+\tparam Distance \tparam_numeric
+\param geometry_in \param_geometry
+\param geometry_out \param_geometry
+\param distance The distance to be used for the buffer
+\param chord_length (optional) The length of the chord's in the generated arcs around points or bends
+
+\qbk{[include reference/algorithms/buffer.qbk]}
+ */
+template <typename Input, typename Output, typename Distance>
+inline void buffer(Input const& geometry_in, Output& geometry_out,
+            Distance const& distance, Distance const& chord_length = -1)
+{
+    concepts::check<Input const>();
+    concepts::check<Output>();
+
+    resolve_variant::buffer<Input>::apply(geometry_in, distance, chord_length, geometry_out);
+}
+
+/*!
+\brief \brief_calc{buffer}
+\ingroup buffer
+\details \details_calc{return_buffer, \det_buffer}. \details_return{buffer}.
+\tparam Input \tparam_geometry
+\tparam Output \tparam_geometry
+\tparam Distance \tparam_numeric
+\param geometry \param_geometry
+\param distance The distance to be used for the buffer
+\param chord_length (optional) The length of the chord's in the generated arcs
+    around points or bends (RESERVED, NOT YET USED)
+\return \return_calc{buffer}
+ */
+template <typename Output, typename Input, typename Distance>
+Output return_buffer(Input const& geometry, Distance const& distance, Distance const& chord_length = -1)
+{
+    concepts::check<Input const>();
+    concepts::check<Output>();
+
+    Output geometry_out;
+
+    resolve_variant::buffer<Input>::apply(geometry, distance, chord_length, geometry_out);
+
+    return geometry_out;
+}
+
+/*!
+\brief \brief_calc{buffer}
+\ingroup buffer
+\details \details_calc{buffer, \det_buffer}.
+\tparam GeometryIn \tparam_geometry
+\tparam MultiPolygon \tparam_geometry{MultiPolygon}
+\tparam DistanceStrategy A strategy defining distance (or radius)
+\tparam SideStrategy A strategy defining creation along sides
+\tparam JoinStrategy A strategy defining creation around convex corners
+\tparam EndStrategy A strategy defining creation at linestring ends
+\tparam PointStrategy A strategy defining creation around points
+\param geometry_in \param_geometry
+\param geometry_out output multi polygon (or std:: collection of polygons),
+    will contain a buffered version of the input geometry
+\param distance_strategy The distance strategy to be used
+\param side_strategy The side strategy to be used
+\param join_strategy The join strategy to be used
+\param end_strategy The end strategy to be used
+\param point_strategy The point strategy to be used
+
+\qbk{distinguish,with strategies}
+\qbk{[include reference/algorithms/buffer_with_strategies.qbk]}
+ */
+template
+<
+    typename GeometryIn,
+    typename MultiPolygon,
+    typename DistanceStrategy,
+    typename SideStrategy,
+    typename JoinStrategy,
+    typename EndStrategy,
+    typename PointStrategy
+>
+inline void buffer(GeometryIn const& geometry_in,
+                MultiPolygon& geometry_out,
+                DistanceStrategy const& distance_strategy,
+                SideStrategy const& side_strategy,
+                JoinStrategy const& join_strategy,
+                EndStrategy const& end_strategy,
+                PointStrategy const& point_strategy)
+{
+    typedef typename boost::range_value<MultiPolygon>::type polygon_type;
+    concepts::check<GeometryIn const>();
+    concepts::check<polygon_type>();
+
+    typedef typename point_type<GeometryIn>::type point_type;
+    typedef typename rescale_policy_type<point_type>::type rescale_policy_type;
+
+    geometry_out.clear();
+
+    if (geometry::is_empty(geometry_in))
+    {
+        // Then output geometry is kept empty as well
+        return;
+    }
+
+    model::box<point_type> box;
+    geometry::envelope(geometry_in, box);
+    geometry::buffer(box, box, distance_strategy.max_distance(join_strategy, end_strategy));
+
+    typename strategy::intersection::services::default_strategy
+        <
+            typename cs_tag<GeometryIn>::type
+        >::type intersection_strategy;
+
+    rescale_policy_type rescale_policy
+            = boost::geometry::get_rescale_policy<rescale_policy_type>(box);
+
+    detail::buffer::buffer_inserter<polygon_type>(geometry_in, range::back_inserter(geometry_out),
+                distance_strategy,
+                side_strategy,
+                join_strategy,
+                end_strategy,
+                point_strategy,
+                intersection_strategy,
+                rescale_policy);
+}
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_BUFFER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/centroid.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/centroid.hpp
new file mode 100644
index 00000000000..6a58033f376
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/centroid.hpp
@@ -0,0 +1,681 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2017 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014, 2015.
+// Modifications copyright (c) 2014-2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_CENTROID_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_CENTROID_HPP
+
+
+#include <cstddef>
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/range.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/exception.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/algorithms/convert.hpp>
+#include <boost/geometry/algorithms/detail/interior_iterator.hpp>
+#include <boost/geometry/algorithms/detail/point_on_border.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+#include <boost/geometry/strategies/centroid.hpp>
+#include <boost/geometry/strategies/concepts/centroid_concept.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/views/closeable_view.hpp>
+
+#include <boost/geometry/util/for_each_coordinate.hpp>
+#include <boost/geometry/util/select_coordinate_type.hpp>
+
+#include <boost/geometry/algorithms/is_empty.hpp>
+
+#include <boost/geometry/algorithms/detail/centroid/translating_transformer.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#if ! defined(BOOST_GEOMETRY_CENTROID_NO_THROW)
+
+/*!
+\brief Centroid Exception
+\ingroup centroid
+\details The centroid_exception is thrown if the free centroid function is called with
+    geometries for which the centroid cannot be calculated. For example: a linestring
+    without points, a polygon without points, an empty multi-geometry.
+\qbk{
+[heading See also]
+\* [link geometry.reference.algorithms.centroid the centroid function]
+}
+
+ */
+class centroid_exception : public geometry::exception
+{
+public:
+
+    /*!
+    \brief The default constructor
+    */
+    inline centroid_exception() {}
+
+    /*!
+    \brief Returns the explanatory string.
+    \return Pointer to a null-terminated string with explanatory information.
+    */
+    virtual char const* what() const throw()
+    {
+        return "Boost.Geometry Centroid calculation exception";
+    }
+};
+
+#endif
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace centroid
+{
+
+struct centroid_point
+{
+    template<typename Point, typename PointCentroid, typename Strategy>
+    static inline void apply(Point const& point, PointCentroid& centroid,
+            Strategy const&)
+    {
+        geometry::convert(point, centroid);
+    }
+};
+
+template
+<
+    typename Indexed,
+    typename Point,
+    std::size_t Dimension = 0,
+    std::size_t DimensionCount = dimension<Indexed>::type::value
+>
+struct centroid_indexed_calculator
+{
+    typedef typename select_coordinate_type
+        <
+            Indexed, Point
+        >::type coordinate_type;
+    static inline void apply(Indexed const& indexed, Point& centroid)
+    {
+        coordinate_type const c1 = get<min_corner, Dimension>(indexed);
+        coordinate_type const c2 = get<max_corner, Dimension>(indexed);
+        coordinate_type m = c1 + c2;
+        coordinate_type const two = 2;
+        m /= two;
+
+        set<Dimension>(centroid, m);
+
+        centroid_indexed_calculator
+            <
+                Indexed, Point, Dimension + 1
+            >::apply(indexed, centroid);
+    }
+};
+
+
+template<typename Indexed, typename Point, std::size_t DimensionCount>
+struct centroid_indexed_calculator<Indexed, Point, DimensionCount, DimensionCount>
+{
+    static inline void apply(Indexed const& , Point& )
+    {
+    }
+};
+
+
+struct centroid_indexed
+{
+    template<typename Indexed, typename Point, typename Strategy>
+    static inline void apply(Indexed const& indexed, Point& centroid,
+            Strategy const&)
+    {
+        centroid_indexed_calculator
+            <
+                Indexed, Point
+            >::apply(indexed, centroid);
+    }
+};
+
+
+// There is one thing where centroid is different from e.g. within.
+// If the ring has only one point, it might make sense that
+// that point is the centroid.
+template<typename Point, typename Range>
+inline bool range_ok(Range const& range, Point& centroid)
+{
+    std::size_t const n = boost::size(range);
+    if (n > 1)
+    {
+        return true;
+    }
+    else if (n <= 0)
+    {
+#if ! defined(BOOST_GEOMETRY_CENTROID_NO_THROW)
+        BOOST_THROW_EXCEPTION(centroid_exception());
+#else
+        return false;
+#endif
+    }
+    else // if (n == 1)
+    {
+        // Take over the first point in a "coordinate neutral way"
+        geometry::convert(*boost::begin(range), centroid);
+        return false;
+    }
+    //return true; // unreachable
+}
+
+/*!
+    \brief Calculate the centroid of a Ring or a Linestring.
+*/
+template <closure_selector Closure>
+struct centroid_range_state
+{
+    template<typename Ring, typename PointTransformer, typename Strategy>
+    static inline void apply(Ring const& ring,
+                             PointTransformer const& transformer,
+                             Strategy const& strategy,
+                             typename Strategy::state_type& state)
+    {
+        boost::ignore_unused(strategy);
+
+        typedef typename geometry::point_type<Ring const>::type point_type;
+        typedef typename closeable_view<Ring const, Closure>::type view_type;
+
+        typedef typename boost::range_iterator<view_type const>::type iterator_type;
+
+        view_type view(ring);
+        iterator_type it = boost::begin(view);
+        iterator_type end = boost::end(view);
+
+        if (it != end)
+        {
+            typename PointTransformer::result_type
+                previous_pt = transformer.apply(*it);
+
+            for ( ++it ; it != end ; ++it)
+            {
+                typename PointTransformer::result_type
+                    pt = transformer.apply(*it);
+
+                strategy.apply(static_cast<point_type const&>(previous_pt),
+                               static_cast<point_type const&>(pt),
+                               state);
+
+                previous_pt = pt;
+            }
+        }
+    }
+};
+
+template <closure_selector Closure>
+struct centroid_range
+{
+    template<typename Range, typename Point, typename Strategy>
+    static inline bool apply(Range const& range, Point& centroid,
+                             Strategy const& strategy)
+    {
+        if (range_ok(range, centroid))
+        {
+            // prepare translation transformer
+            translating_transformer<Range> transformer(*boost::begin(range));
+            
+            typename Strategy::state_type state;
+            centroid_range_state<Closure>::apply(range, transformer,
+                                                 strategy, state);
+            
+            if ( strategy.result(state, centroid) )
+            {
+                // translate the result back
+                transformer.apply_reverse(centroid);
+                return true;
+            }
+        }
+
+        return false;
+    }
+};
+
+
+/*!
+    \brief Centroid of a polygon.
+    \note Because outer ring is clockwise, inners are counter clockwise,
+    triangle approach is OK and works for polygons with rings.
+*/
+struct centroid_polygon_state
+{
+    template<typename Polygon, typename PointTransformer, typename Strategy>
+    static inline void apply(Polygon const& poly,
+                             PointTransformer const& transformer,
+                             Strategy const& strategy,
+                             typename Strategy::state_type& state)
+    {
+        typedef typename ring_type<Polygon>::type ring_type;
+        typedef centroid_range_state<geometry::closure<ring_type>::value> per_ring;
+
+        per_ring::apply(exterior_ring(poly), transformer, strategy, state);
+
+        typename interior_return_type<Polygon const>::type
+            rings = interior_rings(poly);
+
+        for (typename detail::interior_iterator<Polygon const>::type
+                it = boost::begin(rings); it != boost::end(rings); ++it)
+        {
+            per_ring::apply(*it, transformer, strategy, state);
+        }
+    }
+};
+
+struct centroid_polygon
+{
+    template<typename Polygon, typename Point, typename Strategy>
+    static inline bool apply(Polygon const& poly, Point& centroid,
+                             Strategy const& strategy)
+    {
+        if (range_ok(exterior_ring(poly), centroid))
+        {
+            // prepare translation transformer
+            translating_transformer<Polygon>
+                transformer(*boost::begin(exterior_ring(poly)));
+            
+            typename Strategy::state_type state;
+            centroid_polygon_state::apply(poly, transformer, strategy, state);
+            
+            if ( strategy.result(state, centroid) )
+            {
+                // translate the result back
+                transformer.apply_reverse(centroid);
+                return true;
+            }
+        }
+
+        return false;
+    }
+};
+
+
+/*!
+    \brief Building block of a multi-point, to be used as Policy in the
+        more generec centroid_multi
+*/
+struct centroid_multi_point_state
+{
+    template <typename Point, typename PointTransformer, typename Strategy>
+    static inline void apply(Point const& point,
+                             PointTransformer const& transformer,
+                             Strategy const& strategy,
+                             typename Strategy::state_type& state)
+    {
+        boost::ignore_unused(strategy);
+        strategy.apply(static_cast<Point const&>(transformer.apply(point)),
+                       state);
+    }
+};
+
+
+/*!
+    \brief Generic implementation which calls a policy to calculate the
+        centroid of the total of its single-geometries
+    \details The Policy is, in general, the single-version, with state. So
+        detail::centroid::centroid_polygon_state is used as a policy for this
+        detail::centroid::centroid_multi
+
+*/
+template <typename Policy>
+struct centroid_multi
+{
+    template <typename Multi, typename Point, typename Strategy>
+    static inline bool apply(Multi const& multi,
+                             Point& centroid,
+                             Strategy const& strategy)
+    {
+#if ! defined(BOOST_GEOMETRY_CENTROID_NO_THROW)
+        // If there is nothing in any of the ranges, it is not possible
+        // to calculate the centroid
+        if (geometry::is_empty(multi))
+        {
+            BOOST_THROW_EXCEPTION(centroid_exception());
+        }
+#endif
+
+        // prepare translation transformer
+        translating_transformer<Multi> transformer(multi);
+
+        typename Strategy::state_type state;
+
+        for (typename boost::range_iterator<Multi const>::type
+                it = boost::begin(multi);
+            it != boost::end(multi);
+            ++it)
+        {
+            Policy::apply(*it, transformer, strategy, state);
+        }
+
+        if ( strategy.result(state, centroid) )
+        {
+            // translate the result back
+            transformer.apply_reverse(centroid);
+            return true;
+        }
+        
+        return false;
+    }
+};
+
+
+template <typename Algorithm>
+struct centroid_linear_areal
+{
+    template <typename Geometry, typename Point, typename Strategy>
+    static inline void apply(Geometry const& geom,
+                             Point& centroid,
+                             Strategy const& strategy)
+    {
+        if ( ! Algorithm::apply(geom, centroid, strategy) )
+        {
+            geometry::point_on_border(centroid, geom);
+        }
+    }
+};
+
+
+}} // namespace detail::centroid
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Geometry,
+    typename Tag = typename tag<Geometry>::type
+>
+struct centroid: not_implemented<Tag>
+{};
+
+template <typename Geometry>
+struct centroid<Geometry, point_tag>
+    : detail::centroid::centroid_point
+{};
+
+template <typename Box>
+struct centroid<Box, box_tag>
+    : detail::centroid::centroid_indexed
+{};
+
+template <typename Segment>
+struct centroid<Segment, segment_tag>
+    : detail::centroid::centroid_indexed
+{};
+
+template <typename Ring>
+struct centroid<Ring, ring_tag>
+    : detail::centroid::centroid_linear_areal
+        <
+            detail::centroid::centroid_range<geometry::closure<Ring>::value>
+        >
+{};
+
+template <typename Linestring>
+struct centroid<Linestring, linestring_tag>
+    : detail::centroid::centroid_linear_areal
+        <
+            detail::centroid::centroid_range<closed>
+        >
+{};
+
+template <typename Polygon>
+struct centroid<Polygon, polygon_tag>
+    : detail::centroid::centroid_linear_areal
+        <
+            detail::centroid::centroid_polygon
+        >
+{};
+
+template <typename MultiLinestring>
+struct centroid<MultiLinestring, multi_linestring_tag>
+    : detail::centroid::centroid_linear_areal
+        <
+            detail::centroid::centroid_multi
+            <
+                detail::centroid::centroid_range_state<closed>
+            >
+        >
+{};
+
+template <typename MultiPolygon>
+struct centroid<MultiPolygon, multi_polygon_tag>
+    : detail::centroid::centroid_linear_areal
+        <
+            detail::centroid::centroid_multi
+            <
+                detail::centroid::centroid_polygon_state
+            >
+        >
+{};
+
+template <typename MultiPoint>
+struct centroid<MultiPoint, multi_point_tag>
+    : detail::centroid::centroid_multi
+        <
+            detail::centroid::centroid_multi_point_state
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_strategy {
+
+template <typename Geometry>
+struct centroid
+{
+    template <typename Point, typename Strategy>
+    static inline void apply(Geometry const& geometry, Point& out, Strategy const& strategy)
+    {
+        dispatch::centroid<Geometry>::apply(geometry, out, strategy);
+    }
+
+    template <typename Point>
+    static inline void apply(Geometry const& geometry, Point& out, default_strategy)
+    {
+        typedef typename strategy::centroid::services::default_strategy
+        <
+            typename cs_tag<Geometry>::type,
+            typename tag_cast
+                <
+                    typename tag<Geometry>::type,
+                    pointlike_tag,
+                    linear_tag,
+                    areal_tag
+                >::type,
+            dimension<Geometry>::type::value,
+            Point,
+            Geometry
+        >::type strategy_type;
+
+        dispatch::centroid<Geometry>::apply(geometry, out, strategy_type());
+    }
+};
+
+} // namespace resolve_strategy
+
+
+namespace resolve_variant {
+
+template <typename Geometry>
+struct centroid
+{
+    template <typename Point, typename Strategy>
+    static inline void apply(Geometry const& geometry, Point& out, Strategy const& strategy)
+    {
+        concepts::check_concepts_and_equal_dimensions<Point, Geometry const>();
+        resolve_strategy::centroid<Geometry>::apply(geometry, out, strategy);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct centroid<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Point, typename Strategy>
+    struct visitor: boost::static_visitor<void>
+    {
+        Point& m_out;
+        Strategy const& m_strategy;
+
+        visitor(Point& out, Strategy const& strategy)
+        : m_out(out), m_strategy(strategy)
+        {}
+
+        template <typename Geometry>
+        void operator()(Geometry const& geometry) const
+        {
+            centroid<Geometry>::apply(geometry, m_out, m_strategy);
+        }
+    };
+
+    template <typename Point, typename Strategy>
+    static inline void
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry,
+          Point& out,
+          Strategy const& strategy)
+    {
+        boost::apply_visitor(visitor<Point, Strategy>(out, strategy), geometry);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief \brief_calc{centroid} \brief_strategy
+\ingroup centroid
+\details \details_calc{centroid,geometric center (or: center of mass)}. \details_strategy_reasons
+\tparam Geometry \tparam_geometry
+\tparam Point \tparam_point
+\tparam Strategy \tparam_strategy{Centroid}
+\param geometry \param_geometry
+\param c \param_point \param_set{centroid}
+\param strategy \param_strategy{centroid}
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/centroid.qbk]}
+\qbk{[include reference/algorithms/centroid_strategies.qbk]}
+}
+
+*/
+template<typename Geometry, typename Point, typename Strategy>
+inline void centroid(Geometry const& geometry, Point& c,
+        Strategy const& strategy)
+{
+    resolve_variant::centroid<Geometry>::apply(geometry, c, strategy);
+}
+
+
+/*!
+\brief \brief_calc{centroid}
+\ingroup centroid
+\details \details_calc{centroid,geometric center (or: center of mass)}. \details_default_strategy
+\tparam Geometry \tparam_geometry
+\tparam Point \tparam_point
+\param geometry \param_geometry
+\param c The calculated centroid will be assigned to this point reference
+
+\qbk{[include reference/algorithms/centroid.qbk]}
+\qbk{
+[heading Example]
+[centroid]
+[centroid_output]
+}
+ */
+template<typename Geometry, typename Point>
+inline void centroid(Geometry const& geometry, Point& c)
+{
+    geometry::centroid(geometry, c, default_strategy());
+}
+
+
+/*!
+\brief \brief_calc{centroid}
+\ingroup centroid
+\details \details_calc{centroid,geometric center (or: center of mass)}. \details_return{centroid}.
+\tparam Point \tparam_point
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\return \return_calc{centroid}
+
+\qbk{[include reference/algorithms/centroid.qbk]}
+ */
+template<typename Point, typename Geometry>
+inline Point return_centroid(Geometry const& geometry)
+{
+    Point c;
+    geometry::centroid(geometry, c);
+    return c;
+}
+
+/*!
+\brief \brief_calc{centroid} \brief_strategy
+\ingroup centroid
+\details \details_calc{centroid,geometric center (or: center of mass)}. \details_return{centroid}. \details_strategy_reasons
+\tparam Point \tparam_point
+\tparam Geometry \tparam_geometry
+\tparam Strategy \tparam_strategy{centroid}
+\param geometry \param_geometry
+\param strategy \param_strategy{centroid}
+\return \return_calc{centroid}
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/centroid.qbk]}
+\qbk{[include reference/algorithms/centroid_strategies.qbk]}
+ */
+template<typename Point, typename Geometry, typename Strategy>
+inline Point return_centroid(Geometry const& geometry, Strategy const& strategy)
+{
+    Point c;
+    geometry::centroid(geometry, c, strategy);
+    return c;
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_CENTROID_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/clear.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/clear.hpp
new file mode 100644
index 00000000000..97f5efa4514
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/clear.hpp
@@ -0,0 +1,197 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_CLEAR_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_CLEAR_HPP
+
+
+#include <boost/type_traits/remove_const.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/mutable_range.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace clear
+{
+
+template <typename Geometry>
+struct collection_clear
+{
+    static inline void apply(Geometry& geometry)
+    {
+        traits::clear<Geometry>::apply(geometry);
+    }
+};
+
+template <typename Polygon>
+struct polygon_clear
+{
+    static inline void apply(Polygon& polygon)
+    {
+        traits::clear
+            <
+                typename boost::remove_reference
+                    <
+                        typename traits::interior_mutable_type<Polygon>::type
+                    >::type
+            >::apply(interior_rings(polygon));
+        traits::clear
+            <
+                typename boost::remove_reference
+                    <
+                        typename traits::ring_mutable_type<Polygon>::type
+                    >::type
+            >::apply(exterior_ring(polygon));
+    }
+};
+
+template <typename Geometry>
+struct no_action
+{
+    static inline void apply(Geometry& )
+    {
+    }
+};
+
+
+}} // namespace detail::clear
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Geometry,
+    typename Tag = typename tag_cast<typename tag<Geometry>::type, multi_tag>::type
+>
+struct clear: not_implemented<Tag>
+{};
+
+// Point/box/segment do not have clear. So specialize to do nothing.
+template <typename Geometry>
+struct clear<Geometry, point_tag>
+    : detail::clear::no_action<Geometry>
+{};
+
+template <typename Geometry>
+struct clear<Geometry, box_tag>
+    : detail::clear::no_action<Geometry>
+{};
+
+template <typename Geometry>
+struct clear<Geometry, segment_tag>
+    : detail::clear::no_action<Geometry>
+{};
+
+template <typename Geometry>
+struct clear<Geometry, linestring_tag>
+    : detail::clear::collection_clear<Geometry>
+{};
+
+template <typename Geometry>
+struct clear<Geometry, ring_tag>
+    : detail::clear::collection_clear<Geometry>
+{};
+
+
+// Polygon can (indirectly) use std for clear
+template <typename Polygon>
+struct clear<Polygon, polygon_tag>
+    : detail::clear::polygon_clear<Polygon>
+{};
+
+
+template <typename Geometry>
+struct clear<Geometry, multi_tag>
+    : detail::clear::collection_clear<Geometry>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_variant {
+
+template <typename Geometry>
+struct clear
+{
+    static inline void apply(Geometry& geometry)
+    {
+        dispatch::clear<Geometry>::apply(geometry);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct clear<variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    struct visitor: static_visitor<void>
+    {
+        template <typename Geometry>
+        inline void operator()(Geometry& geometry) const
+        {
+            clear<Geometry>::apply(geometry);
+        }
+    };
+
+    static inline void apply(variant<BOOST_VARIANT_ENUM_PARAMS(T)>& geometry)
+    {
+        boost::apply_visitor(visitor(), geometry);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief Clears a linestring, ring or polygon (exterior+interiors) or multi*
+\details Generic function to clear a geometry. All points will be removed from the collection or collections
+    making up the geometry. In most cases this is equivalent to the .clear() method of a std::vector<...>. In
+    the case of a polygon, this clear functionality is automatically called for the exterior ring, and for the
+    interior ring collection. In the case of a point, boxes and segments, nothing will happen.
+\ingroup clear
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry which will be cleared
+\note points and boxes cannot be cleared, instead they can be set to zero by "assign_zero"
+
+\qbk{[include reference/algorithms/clear.qbk]}
+*/
+template <typename Geometry>
+inline void clear(Geometry& geometry)
+{
+    concepts::check<Geometry>();
+
+    resolve_variant::clear<Geometry>::apply(geometry);
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_CLEAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/comparable_distance.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/comparable_distance.hpp
new file mode 100644
index 00000000000..6f009da3ed2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/comparable_distance.hpp
@@ -0,0 +1,25 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_COMPARABLE_DISTANCE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_COMPARABLE_DISTANCE_HPP
+
+#include <boost/geometry/algorithms/detail/comparable_distance/interface.hpp>
+#include <boost/geometry/algorithms/detail/comparable_distance/implementation.hpp>
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_COMPARABLE_DISTANCE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/convert.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/convert.hpp
new file mode 100644
index 00000000000..6a8ba1acb69
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/convert.hpp
@@ -0,0 +1,559 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_CONVERT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_CONVERT_HPP
+
+
+#include <cstddef>
+
+#include <boost/numeric/conversion/cast.hpp>
+#include <boost/range.hpp>
+#include <boost/type_traits/is_array.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/arithmetic/arithmetic.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+#include <boost/geometry/algorithms/append.hpp>
+#include <boost/geometry/algorithms/clear.hpp>
+#include <boost/geometry/algorithms/for_each.hpp>
+#include <boost/geometry/algorithms/detail/assign_values.hpp>
+#include <boost/geometry/algorithms/detail/assign_box_corners.hpp>
+#include <boost/geometry/algorithms/detail/assign_indexed_point.hpp>
+#include <boost/geometry/algorithms/detail/convert_point_to_point.hpp>
+#include <boost/geometry/algorithms/detail/convert_indexed_to_indexed.hpp>
+#include <boost/geometry/algorithms/detail/interior_iterator.hpp>
+
+#include <boost/geometry/views/closeable_view.hpp>
+#include <boost/geometry/views/reversible_view.hpp>
+
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/point_order.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+// Silence warning C4127: conditional expression is constant
+// Silence warning C4512: assignment operator could not be generated
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4127 4512)
+#endif
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace conversion
+{
+
+template
+<
+    typename Point,
+    typename Box,
+    std::size_t Index,
+    std::size_t Dimension,
+    std::size_t DimensionCount
+>
+struct point_to_box
+{
+    static inline void apply(Point const& point, Box& box)
+    {
+        typedef typename coordinate_type<Box>::type coordinate_type;
+
+        set<Index, Dimension>(box,
+                boost::numeric_cast<coordinate_type>(get<Dimension>(point)));
+        point_to_box
+            <
+                Point, Box,
+                Index, Dimension + 1, DimensionCount
+            >::apply(point, box);
+    }
+};
+
+
+template
+<
+    typename Point,
+    typename Box,
+    std::size_t Index,
+    std::size_t DimensionCount
+>
+struct point_to_box<Point, Box, Index, DimensionCount, DimensionCount>
+{
+    static inline void apply(Point const& , Box& )
+    {}
+};
+
+template <typename Box, typename Range, bool Close, bool Reverse>
+struct box_to_range
+{
+    static inline void apply(Box const& box, Range& range)
+    {
+        traits::resize<Range>::apply(range, Close ? 5 : 4);
+        assign_box_corners_oriented<Reverse>(box, range);
+        if (Close)
+        {
+            range::at(range, 4) = range::at(range, 0);
+        }
+    }
+};
+
+template <typename Segment, typename Range>
+struct segment_to_range
+{
+    static inline void apply(Segment const& segment, Range& range)
+    {
+        traits::resize<Range>::apply(range, 2);
+
+        typename boost::range_iterator<Range>::type it = boost::begin(range);
+
+        assign_point_from_index<0>(segment, *it);
+        ++it;
+        assign_point_from_index<1>(segment, *it);
+    }
+};
+
+template
+<
+    typename Range1,
+    typename Range2,
+    bool Reverse = false
+>
+struct range_to_range
+{
+    typedef typename reversible_view
+        <
+            Range1 const,
+            Reverse ? iterate_reverse : iterate_forward
+        >::type rview_type;
+    typedef typename closeable_view
+        <
+            rview_type const,
+            geometry::closure<Range1>::value
+        >::type view_type;
+
+    static inline void apply(Range1 const& source, Range2& destination)
+    {
+        geometry::clear(destination);
+
+        rview_type rview(source);
+
+        // We consider input always as closed, and skip last
+        // point for open output.
+        view_type view(rview);
+
+        typedef typename boost::range_size<Range1>::type size_type;
+        size_type n = boost::size(view);
+        if (geometry::closure<Range2>::value == geometry::open)
+        {
+            n--;
+        }
+
+        // If size == 0 && geometry::open <=> n = numeric_limits<size_type>::max()
+        // but ok, sice below it == end()
+
+        size_type i = 0;
+        for (typename boost::range_iterator<view_type const>::type it
+            = boost::begin(view);
+            it != boost::end(view) && i < n;
+            ++it, ++i)
+        {
+            geometry::append(destination, *it);
+        }
+    }
+};
+
+template <typename Polygon1, typename Polygon2>
+struct polygon_to_polygon
+{
+    typedef range_to_range
+        <
+            typename geometry::ring_type<Polygon1>::type,
+            typename geometry::ring_type<Polygon2>::type,
+            geometry::point_order<Polygon1>::value
+                != geometry::point_order<Polygon2>::value
+        > per_ring;
+
+    static inline void apply(Polygon1 const& source, Polygon2& destination)
+    {
+        // Clearing managed per ring, and in the resizing of interior rings
+
+        per_ring::apply(geometry::exterior_ring(source),
+            geometry::exterior_ring(destination));
+
+        // Container should be resizeable
+        traits::resize
+            <
+                typename boost::remove_reference
+                <
+                    typename traits::interior_mutable_type<Polygon2>::type
+                >::type
+            >::apply(interior_rings(destination), num_interior_rings(source));
+
+        typename interior_return_type<Polygon1 const>::type
+            rings_source = interior_rings(source);
+        typename interior_return_type<Polygon2>::type
+            rings_dest = interior_rings(destination);
+
+        typename detail::interior_iterator<Polygon1 const>::type
+            it_source = boost::begin(rings_source);
+        typename detail::interior_iterator<Polygon2>::type
+            it_dest = boost::begin(rings_dest);
+
+        for ( ; it_source != boost::end(rings_source); ++it_source, ++it_dest)
+        {
+            per_ring::apply(*it_source, *it_dest);
+        }
+    }
+};
+
+template <typename Single, typename Multi, typename Policy>
+struct single_to_multi: private Policy
+{
+    static inline void apply(Single const& single, Multi& multi)
+    {
+        traits::resize<Multi>::apply(multi, 1);
+        Policy::apply(single, *boost::begin(multi));
+    }
+};
+
+
+
+template <typename Multi1, typename Multi2, typename Policy>
+struct multi_to_multi: private Policy
+{
+    static inline void apply(Multi1 const& multi1, Multi2& multi2)
+    {
+        traits::resize<Multi2>::apply(multi2, boost::size(multi1));
+
+        typename boost::range_iterator<Multi1 const>::type it1
+                = boost::begin(multi1);
+        typename boost::range_iterator<Multi2>::type it2
+                = boost::begin(multi2);
+
+        for (; it1 != boost::end(multi1); ++it1, ++it2)
+        {
+            Policy::apply(*it1, *it2);
+        }
+    }
+};
+
+
+}} // namespace detail::conversion
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Geometry1, typename Geometry2,
+    typename Tag1 = typename tag_cast<typename tag<Geometry1>::type, multi_tag>::type,
+    typename Tag2 = typename tag_cast<typename tag<Geometry2>::type, multi_tag>::type,
+    std::size_t DimensionCount = dimension<Geometry1>::type::value,
+    bool UseAssignment = boost::is_same<Geometry1, Geometry2>::value
+                         && !boost::is_array<Geometry1>::value
+>
+struct convert: not_implemented<Tag1, Tag2, boost::mpl::int_<DimensionCount> >
+{};
+
+
+template
+<
+    typename Geometry1, typename Geometry2,
+    typename Tag,
+    std::size_t DimensionCount
+>
+struct convert<Geometry1, Geometry2, Tag, Tag, DimensionCount, true>
+{
+    // Same geometry type -> copy whole geometry
+    static inline void apply(Geometry1 const& source, Geometry2& destination)
+    {
+        destination = source;
+    }
+};
+
+
+template
+<
+    typename Geometry1, typename Geometry2,
+    std::size_t DimensionCount
+>
+struct convert<Geometry1, Geometry2, point_tag, point_tag, DimensionCount, false>
+    : detail::conversion::point_to_point<Geometry1, Geometry2, 0, DimensionCount>
+{};
+
+
+template
+<
+    typename Box1, typename Box2,
+    std::size_t DimensionCount
+>
+struct convert<Box1, Box2, box_tag, box_tag, DimensionCount, false>
+    : detail::conversion::indexed_to_indexed<Box1, Box2, 0, DimensionCount>
+{};
+
+
+template
+<
+    typename Segment1, typename Segment2,
+    std::size_t DimensionCount
+>
+struct convert<Segment1, Segment2, segment_tag, segment_tag, DimensionCount, false>
+    : detail::conversion::indexed_to_indexed<Segment1, Segment2, 0, DimensionCount>
+{};
+
+
+template <typename Segment, typename LineString, std::size_t DimensionCount>
+struct convert<Segment, LineString, segment_tag, linestring_tag, DimensionCount, false>
+    : detail::conversion::segment_to_range<Segment, LineString>
+{};
+
+
+template <typename Ring1, typename Ring2, std::size_t DimensionCount>
+struct convert<Ring1, Ring2, ring_tag, ring_tag, DimensionCount, false>
+    : detail::conversion::range_to_range
+        <
+            Ring1,
+            Ring2,
+            geometry::point_order<Ring1>::value
+                != geometry::point_order<Ring2>::value
+        >
+{};
+
+template <typename LineString1, typename LineString2, std::size_t DimensionCount>
+struct convert<LineString1, LineString2, linestring_tag, linestring_tag, DimensionCount, false>
+    : detail::conversion::range_to_range<LineString1, LineString2>
+{};
+
+template <typename Polygon1, typename Polygon2, std::size_t DimensionCount>
+struct convert<Polygon1, Polygon2, polygon_tag, polygon_tag, DimensionCount, false>
+    : detail::conversion::polygon_to_polygon<Polygon1, Polygon2>
+{};
+
+template <typename Box, typename Ring>
+struct convert<Box, Ring, box_tag, ring_tag, 2, false>
+    : detail::conversion::box_to_range
+        <
+            Box,
+            Ring,
+            geometry::closure<Ring>::value == closed,
+            geometry::point_order<Ring>::value == counterclockwise
+        >
+{};
+
+
+template <typename Box, typename Polygon>
+struct convert<Box, Polygon, box_tag, polygon_tag, 2, false>
+{
+    static inline void apply(Box const& box, Polygon& polygon)
+    {
+        typedef typename ring_type<Polygon>::type ring_type;
+
+        convert
+            <
+                Box, ring_type,
+                box_tag, ring_tag,
+                2, false
+            >::apply(box, exterior_ring(polygon));
+    }
+};
+
+
+template <typename Point, typename Box, std::size_t DimensionCount>
+struct convert<Point, Box, point_tag, box_tag, DimensionCount, false>
+{
+    static inline void apply(Point const& point, Box& box)
+    {
+        detail::conversion::point_to_box
+            <
+                Point, Box, min_corner, 0, DimensionCount
+            >::apply(point, box);
+        detail::conversion::point_to_box
+            <
+                Point, Box, max_corner, 0, DimensionCount
+            >::apply(point, box);
+    }
+};
+
+
+template <typename Ring, typename Polygon, std::size_t DimensionCount>
+struct convert<Ring, Polygon, ring_tag, polygon_tag, DimensionCount, false>
+{
+    static inline void apply(Ring const& ring, Polygon& polygon)
+    {
+        typedef typename ring_type<Polygon>::type ring_type;
+        convert
+            <
+                Ring, ring_type,
+                ring_tag, ring_tag,
+                DimensionCount, false
+            >::apply(ring, exterior_ring(polygon));
+    }
+};
+
+
+template <typename Polygon, typename Ring, std::size_t DimensionCount>
+struct convert<Polygon, Ring, polygon_tag, ring_tag, DimensionCount, false>
+{
+    static inline void apply(Polygon const& polygon, Ring& ring)
+    {
+        typedef typename ring_type<Polygon>::type ring_type;
+
+        convert
+            <
+                ring_type, Ring,
+                ring_tag, ring_tag,
+                DimensionCount, false
+            >::apply(exterior_ring(polygon), ring);
+    }
+};
+
+
+// Dispatch for multi <-> multi, specifying their single-version as policy.
+// Note that, even if the multi-types are mutually different, their single
+// version types might be the same and therefore we call boost::is_same again
+
+template <typename Multi1, typename Multi2, std::size_t DimensionCount>
+struct convert<Multi1, Multi2, multi_tag, multi_tag, DimensionCount, false>
+    : detail::conversion::multi_to_multi
+        <
+            Multi1,
+            Multi2,
+            convert
+                <
+                    typename boost::range_value<Multi1>::type,
+                    typename boost::range_value<Multi2>::type,
+                    typename single_tag_of
+                                <
+                                    typename tag<Multi1>::type
+                                >::type,
+                    typename single_tag_of
+                                <
+                                    typename tag<Multi2>::type
+                                >::type,
+                    DimensionCount
+                >
+        >
+{};
+
+
+template <typename Single, typename Multi, typename SingleTag, std::size_t DimensionCount>
+struct convert<Single, Multi, SingleTag, multi_tag, DimensionCount, false>
+    : detail::conversion::single_to_multi
+        <
+            Single,
+            Multi,
+            convert
+                <
+                    Single,
+                    typename boost::range_value<Multi>::type,
+                    typename tag<Single>::type,
+                    typename single_tag_of
+                                <
+                                    typename tag<Multi>::type
+                                >::type,
+                    DimensionCount,
+                    false
+                >
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_variant {
+
+template <typename Geometry1, typename Geometry2>
+struct convert
+{
+    static inline void apply(Geometry1 const& geometry1, Geometry2& geometry2)
+    {
+        concepts::check_concepts_and_equal_dimensions<Geometry1 const, Geometry2>();
+        dispatch::convert<Geometry1, Geometry2>::apply(geometry1, geometry2);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
+struct convert<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
+{
+    struct visitor: static_visitor<void>
+    {
+        Geometry2& m_geometry2;
+
+        visitor(Geometry2& geometry2)
+            : m_geometry2(geometry2)
+        {}
+
+        template <typename Geometry1>
+        inline void operator()(Geometry1 const& geometry1) const
+        {
+            convert<Geometry1, Geometry2>::apply(geometry1, m_geometry2);
+        }
+    };
+
+    static inline void apply(
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
+        Geometry2& geometry2
+    )
+    {
+        boost::apply_visitor(visitor(geometry2), geometry1);
+    }
+};
+
+}
+
+
+/*!
+\brief Converts one geometry to another geometry
+\details The convert algorithm converts one geometry, e.g. a BOX, to another
+geometry, e.g. a RING. This only works if it is possible and applicable.
+If the point-order is different, or the closure is different between two
+geometry types, it will be converted correctly by explicitly reversing the
+points or closing or opening the polygon rings.
+\ingroup convert
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry (source)
+\param geometry2 \param_geometry (target)
+
+\qbk{[include reference/algorithms/convert.qbk]}
+ */
+template <typename Geometry1, typename Geometry2>
+inline void convert(Geometry1 const& geometry1, Geometry2& geometry2)
+{
+    resolve_variant::convert<Geometry1, Geometry2>::apply(geometry1, geometry2);
+}
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_CONVERT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/convex_hull.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/convex_hull.hpp
new file mode 100644
index 00000000000..26bb8509e34
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/convex_hull.hpp
@@ -0,0 +1,375 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014, 2015.
+// Modifications copyright (c) 2014-2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_CONVEX_HULL_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_CONVEX_HULL_HPP
+
+#include <boost/array.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/point_order.hpp>
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/strategies/convex_hull.hpp>
+#include <boost/geometry/strategies/concepts/convex_hull_concept.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+
+#include <boost/geometry/views/detail/range_type.hpp>
+
+#include <boost/geometry/algorithms/is_empty.hpp>
+#include <boost/geometry/algorithms/detail/as_range.hpp>
+#include <boost/geometry/algorithms/detail/assign_box_corners.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace convex_hull
+{
+
+template <order_selector Order, closure_selector Closure>
+struct hull_insert
+{
+
+    // Member template function (to avoid inconvenient declaration
+    // of output-iterator-type, from hull_to_geometry)
+    template <typename Geometry, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(Geometry const& geometry,
+            OutputIterator out, Strategy const& strategy)
+    {
+        typename Strategy::state_type state;
+
+        strategy.apply(geometry, state);
+        strategy.result(state, out, Order == clockwise, Closure != open);
+        return out;
+    }
+};
+
+struct hull_to_geometry
+{
+    template <typename Geometry, typename OutputGeometry, typename Strategy>
+    static inline void apply(Geometry const& geometry, OutputGeometry& out,
+            Strategy const& strategy)
+    {
+        hull_insert
+            <
+                geometry::point_order<OutputGeometry>::value,
+                geometry::closure<OutputGeometry>::value
+            >::apply(geometry,
+                range::back_inserter(
+                    // Handle linestring, ring and polygon the same:
+                    detail::as_range
+                        <
+                            typename range_type<OutputGeometry>::type
+                        >(out)), strategy);
+    }
+};
+
+}} // namespace detail::convex_hull
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template
+<
+    typename Geometry,
+    typename Tag = typename tag<Geometry>::type
+>
+struct convex_hull
+    : detail::convex_hull::hull_to_geometry
+{};
+
+template <typename Box>
+struct convex_hull<Box, box_tag>
+{
+    template <typename OutputGeometry, typename Strategy>
+    static inline void apply(Box const& box, OutputGeometry& out,
+            Strategy const& )
+    {
+        static bool const Close
+            = geometry::closure<OutputGeometry>::value == closed;
+        static bool const Reverse
+            = geometry::point_order<OutputGeometry>::value == counterclockwise;
+
+        // A hull for boxes is trivial. Any strategy is (currently) skipped.
+        boost::array<typename point_type<Box>::type, 4> range;
+        geometry::detail::assign_box_corners_oriented<Reverse>(box, range);
+        geometry::append(out, range);
+        if (BOOST_GEOMETRY_CONDITION(Close))
+        {
+            geometry::append(out, *boost::begin(range));
+        }
+    }
+};
+
+
+
+template <order_selector Order, closure_selector Closure>
+struct convex_hull_insert
+    : detail::convex_hull::hull_insert<Order, Closure>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_strategy {
+
+struct convex_hull
+{
+    template <typename Geometry, typename OutputGeometry, typename Strategy>
+    static inline void apply(Geometry const& geometry,
+                             OutputGeometry& out,
+                             Strategy const& strategy)
+    {
+        BOOST_CONCEPT_ASSERT( (geometry::concepts::ConvexHullStrategy<Strategy>) );
+        dispatch::convex_hull<Geometry>::apply(geometry, out, strategy);
+    }
+
+    template <typename Geometry, typename OutputGeometry>
+    static inline void apply(Geometry const& geometry,
+                             OutputGeometry& out,
+                             default_strategy)
+    {
+        typedef typename strategy_convex_hull<
+            Geometry,
+            typename point_type<Geometry>::type
+        >::type strategy_type;
+
+        apply(geometry, out, strategy_type());
+    }
+};
+
+struct convex_hull_insert
+{
+    template <typename Geometry, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(Geometry const& geometry,
+                                       OutputIterator& out,
+                                       Strategy const& strategy)
+    {
+        BOOST_CONCEPT_ASSERT( (geometry::concepts::ConvexHullStrategy<Strategy>) );
+
+        return dispatch::convex_hull_insert<
+                   geometry::point_order<Geometry>::value,
+                   geometry::closure<Geometry>::value
+               >::apply(geometry, out, strategy);
+    }
+
+    template <typename Geometry, typename OutputIterator>
+    static inline OutputIterator apply(Geometry const& geometry,
+                                       OutputIterator& out,
+                                       default_strategy)
+    {
+        typedef typename strategy_convex_hull<
+            Geometry,
+            typename point_type<Geometry>::type
+        >::type strategy_type;
+
+        return apply(geometry, out, strategy_type());
+    }
+};
+
+} // namespace resolve_strategy
+
+
+namespace resolve_variant {
+
+template <typename Geometry>
+struct convex_hull
+{
+    template <typename OutputGeometry, typename Strategy>
+    static inline void apply(Geometry const& geometry, OutputGeometry& out, Strategy const& strategy)
+    {
+        concepts::check_concepts_and_equal_dimensions<
+            const Geometry,
+            OutputGeometry
+        >();
+
+        resolve_strategy::convex_hull::apply(geometry, out, strategy);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct convex_hull<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename OutputGeometry, typename Strategy>
+    struct visitor: boost::static_visitor<void>
+    {
+        OutputGeometry& m_out;
+        Strategy const& m_strategy;
+
+        visitor(OutputGeometry& out, Strategy const& strategy)
+        : m_out(out), m_strategy(strategy)
+        {}
+
+        template <typename Geometry>
+        void operator()(Geometry const& geometry) const
+        {
+            convex_hull<Geometry>::apply(geometry, m_out, m_strategy);
+        }
+    };
+
+    template <typename OutputGeometry, typename Strategy>
+    static inline void
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry,
+          OutputGeometry& out,
+          Strategy const& strategy)
+    {
+        boost::apply_visitor(visitor<OutputGeometry, Strategy>(out, strategy), geometry);
+    }
+};
+
+template <typename Geometry>
+struct convex_hull_insert
+{
+    template <typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(Geometry const& geometry, OutputIterator& out, Strategy const& strategy)
+    {
+        // Concept: output point type = point type of input geometry
+        concepts::check<Geometry const>();
+        concepts::check<typename point_type<Geometry>::type>();
+
+        return resolve_strategy::convex_hull_insert::apply(geometry, out, strategy);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct convex_hull_insert<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename OutputIterator, typename Strategy>
+    struct visitor: boost::static_visitor<OutputIterator>
+    {
+        OutputIterator& m_out;
+        Strategy const& m_strategy;
+
+        visitor(OutputIterator& out, Strategy const& strategy)
+        : m_out(out), m_strategy(strategy)
+        {}
+
+        template <typename Geometry>
+        OutputIterator operator()(Geometry const& geometry) const
+        {
+            return convex_hull_insert<Geometry>::apply(geometry, m_out, m_strategy);
+        }
+    };
+
+    template <typename OutputIterator, typename Strategy>
+    static inline OutputIterator
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry,
+          OutputIterator& out,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<OutputIterator, Strategy>(out, strategy), geometry);
+    }
+};
+
+} // namespace resolve_variant
+
+
+template<typename Geometry, typename OutputGeometry, typename Strategy>
+inline void convex_hull(Geometry const& geometry,
+            OutputGeometry& out, Strategy const& strategy)
+{
+    if (geometry::is_empty(geometry))
+    {
+        // Leave output empty
+        return;
+    }
+
+    resolve_variant::convex_hull<Geometry>::apply(geometry, out, strategy);
+}
+
+
+/*!
+\brief \brief_calc{convex hull}
+\ingroup convex_hull
+\details \details_calc{convex_hull,convex hull}.
+\tparam Geometry the input geometry type
+\tparam OutputGeometry the output geometry type
+\param geometry \param_geometry,  input geometry
+\param hull \param_geometry \param_set{convex hull}
+
+\qbk{[include reference/algorithms/convex_hull.qbk]}
+ */
+template<typename Geometry, typename OutputGeometry>
+inline void convex_hull(Geometry const& geometry,
+            OutputGeometry& hull)
+{
+    geometry::convex_hull(geometry, hull, default_strategy());
+}
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace convex_hull
+{
+
+
+template<typename Geometry, typename OutputIterator, typename Strategy>
+inline OutputIterator convex_hull_insert(Geometry const& geometry,
+            OutputIterator out, Strategy const& strategy)
+{
+    return resolve_variant::convex_hull_insert<Geometry>
+                          ::apply(geometry, out, strategy);
+}
+
+
+/*!
+\brief Calculate the convex hull of a geometry, output-iterator version
+\ingroup convex_hull
+\tparam Geometry the input geometry type
+\tparam OutputIterator: an output-iterator
+\param geometry the geometry to calculate convex hull from
+\param out an output iterator outputing points of the convex hull
+\note This overloaded version outputs to an output iterator.
+In this case, nothing is known about its point-type or
+    about its clockwise order. Therefore, the input point-type
+    and order are copied
+
+ */
+template<typename Geometry, typename OutputIterator>
+inline OutputIterator convex_hull_insert(Geometry const& geometry,
+            OutputIterator out)
+{
+    return convex_hull_insert(geometry, out, default_strategy());
+}
+
+
+}} // namespace detail::convex_hull
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_CONVEX_HULL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/correct.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/correct.hpp
new file mode 100644
index 00000000000..a572d921d51
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/correct.hpp
@@ -0,0 +1,375 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_CORRECT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_CORRECT_HPP
+
+
+#include <algorithm>
+#include <cstddef>
+#include <functional>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/range.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/detail/interior_iterator.hpp>
+
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/mutable_range.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/algorithms/area.hpp>
+#include <boost/geometry/algorithms/disjoint.hpp>
+#include <boost/geometry/algorithms/detail/multi_modify.hpp>
+#include <boost/geometry/util/order_as_direction.hpp>
+
+namespace boost { namespace geometry
+{
+
+// Silence warning C4127: conditional expression is constant
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4127)
+#endif
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace correct
+{
+
+template <typename Geometry>
+struct correct_nop
+{
+    template <typename Strategy>
+    static inline void apply(Geometry& , Strategy const& )
+    {}
+};
+
+
+template <typename Box, std::size_t Dimension, std::size_t DimensionCount>
+struct correct_box_loop
+{
+    typedef typename coordinate_type<Box>::type coordinate_type;
+
+    static inline void apply(Box& box)
+    {
+        if (get<min_corner, Dimension>(box) > get<max_corner, Dimension>(box))
+        {
+            // Swap the coordinates
+            coordinate_type max_value = get<min_corner, Dimension>(box);
+            coordinate_type min_value = get<max_corner, Dimension>(box);
+            set<min_corner, Dimension>(box, min_value);
+            set<max_corner, Dimension>(box, max_value);
+        }
+
+        correct_box_loop
+            <
+                Box, Dimension + 1, DimensionCount
+            >::apply(box);
+    }
+};
+
+
+
+template <typename Box, std::size_t DimensionCount>
+struct correct_box_loop<Box, DimensionCount, DimensionCount>
+{
+    static inline void apply(Box& )
+    {}
+
+};
+
+
+// Correct a box: make min/max correct
+template <typename Box>
+struct correct_box
+{
+    template <typename Strategy>
+    static inline void apply(Box& box, Strategy const& )
+    {
+        // Currently only for Cartesian coordinates
+        // (or spherical without crossing dateline)
+        // Future version: adapt using strategies
+        correct_box_loop
+            <
+                Box, 0, dimension<Box>::type::value
+            >::apply(box);
+    }
+};
+
+
+// Close a ring, if not closed
+template <typename Ring, template <typename> class Predicate>
+struct correct_ring
+{
+    typedef typename point_type<Ring>::type point_type;
+    typedef typename coordinate_type<Ring>::type coordinate_type;
+
+    typedef detail::area::ring_area
+            <
+                order_as_direction<geometry::point_order<Ring>::value>::value,
+                geometry::closure<Ring>::value
+            > ring_area_type;
+
+
+    template <typename Strategy>
+    static inline void apply(Ring& r, Strategy const& strategy)
+    {
+        // Check close-ness
+        if (boost::size(r) > 2)
+        {
+            // check if closed, if not, close it
+            bool const disjoint = geometry::disjoint(*boost::begin(r), *(boost::end(r) - 1));
+            closure_selector const s = geometry::closure<Ring>::value;
+
+            if (disjoint && (s == closed))
+            {
+                geometry::append(r, *boost::begin(r));
+            }
+            if (! disjoint && s != closed)
+            {
+                // Open it by removing last point
+                geometry::traits::resize<Ring>::apply(r, boost::size(r) - 1);
+            }
+        }
+        // Check area
+        typedef typename Strategy::return_type area_result_type;
+        Predicate<area_result_type> predicate;
+        area_result_type const zero = 0;
+        if (predicate(ring_area_type::apply(r, strategy), zero))
+        {
+            std::reverse(boost::begin(r), boost::end(r));
+        }
+    }
+};
+
+// Correct a polygon: normalizes all rings, sets outer ring clockwise, sets all
+// inner rings counter clockwise (or vice versa depending on orientation)
+template <typename Polygon>
+struct correct_polygon
+{
+    typedef typename ring_type<Polygon>::type ring_type;
+    
+    template <typename Strategy>
+    static inline void apply(Polygon& poly, Strategy const& strategy)
+    {
+        correct_ring
+            <
+                ring_type,
+                std::less
+            >::apply(exterior_ring(poly), strategy);
+
+        typename interior_return_type<Polygon>::type
+            rings = interior_rings(poly);
+        for (typename detail::interior_iterator<Polygon>::type
+                it = boost::begin(rings); it != boost::end(rings); ++it)
+        {
+            correct_ring
+                <
+                    ring_type,
+                    std::greater
+                >::apply(*it, strategy);
+        }
+    }
+};
+
+
+}} // namespace detail::correct
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct correct: not_implemented<Tag>
+{};
+
+template <typename Point>
+struct correct<Point, point_tag>
+    : detail::correct::correct_nop<Point>
+{};
+
+template <typename LineString>
+struct correct<LineString, linestring_tag>
+    : detail::correct::correct_nop<LineString>
+{};
+
+template <typename Segment>
+struct correct<Segment, segment_tag>
+    : detail::correct::correct_nop<Segment>
+{};
+
+
+template <typename Box>
+struct correct<Box, box_tag>
+    : detail::correct::correct_box<Box>
+{};
+
+template <typename Ring>
+struct correct<Ring, ring_tag>
+    : detail::correct::correct_ring
+        <
+            Ring,
+            std::less
+        >
+{};
+
+template <typename Polygon>
+struct correct<Polygon, polygon_tag>
+    : detail::correct::correct_polygon<Polygon>
+{};
+
+
+template <typename MultiPoint>
+struct correct<MultiPoint, multi_point_tag>
+    : detail::correct::correct_nop<MultiPoint>
+{};
+
+
+template <typename MultiLineString>
+struct correct<MultiLineString, multi_linestring_tag>
+    : detail::correct::correct_nop<MultiLineString>
+{};
+
+
+template <typename Geometry>
+struct correct<Geometry, multi_polygon_tag>
+    : detail::multi_modify
+        <
+            Geometry,
+            detail::correct::correct_polygon
+                <
+                    typename boost::range_value<Geometry>::type
+                >
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_variant {
+
+template <typename Geometry>
+struct correct
+{
+    template <typename Strategy>
+    static inline void apply(Geometry& geometry, Strategy const& strategy)
+    {
+        concepts::check<Geometry const>();
+        dispatch::correct<Geometry>::apply(geometry, strategy);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct correct<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Strategy>
+    struct visitor: boost::static_visitor<void>
+    {
+        Strategy const& m_strategy;
+
+        visitor(Strategy const& strategy): m_strategy(strategy) {}
+
+        template <typename Geometry>
+        void operator()(Geometry& geometry) const
+        {
+            correct<Geometry>::apply(geometry, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline void
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>& geometry, Strategy const& strategy)
+    {
+        boost::apply_visitor(visitor<Strategy>(strategy), geometry);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief Corrects a geometry
+\details Corrects a geometry: all rings which are wrongly oriented with respect
+    to their expected orientation are reversed. To all rings which do not have a
+    closing point and are typed as they should have one, the first point is
+    appended. Also boxes can be corrected.
+\ingroup correct
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry which will be corrected if necessary
+
+\qbk{[include reference/algorithms/correct.qbk]}
+*/
+template <typename Geometry>
+inline void correct(Geometry& geometry)
+{
+    typedef typename point_type<Geometry>::type point_type;
+
+    typedef typename strategy::area::services::default_strategy
+        <
+            typename cs_tag<point_type>::type,
+            point_type
+        >::type strategy_type;
+
+    resolve_variant::correct<Geometry>::apply(geometry, strategy_type());
+}
+
+/*!
+\brief Corrects a geometry
+\details Corrects a geometry: all rings which are wrongly oriented with respect
+    to their expected orientation are reversed. To all rings which do not have a
+    closing point and are typed as they should have one, the first point is
+    appended. Also boxes can be corrected.
+\ingroup correct
+\tparam Geometry \tparam_geometry
+\tparam Strategy \tparam_strategy{Area}
+\param geometry \param_geometry which will be corrected if necessary
+\param strategy \param_strategy{area}
+
+\qbk{distinguish,with strategy}
+
+\qbk{[include reference/algorithms/correct.qbk]}
+*/
+template <typename Geometry, typename Strategy>
+inline void correct(Geometry& geometry, Strategy const& strategy)
+{
+    resolve_variant::correct<Geometry>::apply(geometry, strategy);
+}
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_CORRECT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/covered_by.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/covered_by.hpp
new file mode 100644
index 00000000000..d68429673a6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/covered_by.hpp
@@ -0,0 +1,27 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2013, 2014, 2017.
+// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_COVERED_BY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_COVERED_BY_HPP
+
+
+#include <boost/geometry/algorithms/detail/covered_by/interface.hpp>
+#include <boost/geometry/algorithms/detail/covered_by/implementation.hpp>
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_COVERED_BY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/crosses.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/crosses.hpp
new file mode 100644
index 00000000000..c9e3651ab2f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/crosses.hpp
@@ -0,0 +1,267 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2014, 2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_CROSSES_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_CROSSES_HPP
+
+#include <cstddef>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/relate.hpp>
+#include <boost/geometry/algorithms/detail/relate/relate_impl.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename Tag1 = typename tag<Geometry1>::type,
+    typename Tag2 = typename tag<Geometry2>::type
+>
+struct crosses
+    : detail::relate::relate_impl
+        <
+            detail::de9im::static_mask_crosses_type,
+            Geometry1,
+            Geometry2
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_strategy
+{
+
+struct crosses
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        concepts::check<Geometry1 const>();
+        concepts::check<Geometry2 const>();
+
+        return dispatch::crosses<Geometry1, Geometry2>::apply(geometry1, geometry2, strategy);
+    }
+
+    template <typename Geometry1, typename Geometry2>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             default_strategy)
+    {
+        typedef typename strategy::relate::services::default_strategy
+            <
+                Geometry1,
+                Geometry2
+            >::type strategy_type;
+
+        return apply(geometry1, geometry2, strategy_type());
+    }
+};
+
+} // namespace resolve_strategy
+
+
+namespace resolve_variant
+{
+    template <typename Geometry1, typename Geometry2>
+    struct crosses
+    {
+        template <typename Strategy>
+        static inline bool apply(Geometry1 const& geometry1,
+                                 Geometry2 const& geometry2,
+                                 Strategy const& strategy)
+        {
+            return resolve_strategy::crosses::apply(geometry1, geometry2, strategy);
+        }
+    };
+    
+    
+    template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
+    struct crosses<variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
+    {
+        template <typename Strategy>
+        struct visitor: static_visitor<bool>
+        {
+            Geometry2 const& m_geometry2;
+            Strategy const& m_strategy;
+            
+            visitor(Geometry2 const& geometry2, Strategy const& strategy)
+                : m_geometry2(geometry2)
+                , m_strategy(strategy)
+            {}
+            
+            template <typename Geometry1>
+            result_type operator()(Geometry1 const& geometry1) const
+            {
+                return crosses
+                    <
+                        Geometry1,
+                        Geometry2
+                    >::apply(geometry1, m_geometry2, m_strategy);
+            }
+        };
+        
+        template <typename Strategy>
+        static inline bool apply(variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
+                                 Geometry2 const& geometry2,
+                                 Strategy const& strategy)
+        {
+            return boost::apply_visitor(visitor<Strategy>(geometry2, strategy), geometry1);
+        }
+    };
+    
+    
+    template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+    struct crosses<Geometry1, variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+    {
+        template <typename Strategy>
+        struct visitor: static_visitor<bool>
+        {
+            Geometry1 const& m_geometry1;
+            Strategy const& m_strategy;
+            
+            visitor(Geometry1 const& geometry1, Strategy const& strategy)
+                : m_geometry1(geometry1)
+                , m_strategy(strategy)
+            {}
+            
+            template <typename Geometry2>
+            result_type operator()(Geometry2 const& geometry2) const
+            {
+                return crosses
+                    <
+                        Geometry1,
+                        Geometry2
+                    >::apply(m_geometry1, geometry2, m_strategy);
+            }
+        };
+        
+        template <typename Strategy>
+        static inline bool apply(Geometry1 const& geometry1,
+                                 variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2,
+                                 Strategy const& strategy)
+        {
+            return boost::apply_visitor(visitor<Strategy>(geometry1, strategy), geometry2);
+        }
+    };
+    
+    
+    template <BOOST_VARIANT_ENUM_PARAMS(typename T1), BOOST_VARIANT_ENUM_PARAMS(typename T2)>
+    struct crosses<variant<BOOST_VARIANT_ENUM_PARAMS(T1)>, variant<BOOST_VARIANT_ENUM_PARAMS(T2)> >
+    {
+        template <typename Strategy>
+        struct visitor: static_visitor<bool>
+        {
+            Strategy const& m_strategy;
+
+            visitor(Strategy const& strategy)
+                : m_strategy(strategy)
+            {}
+
+            template <typename Geometry1, typename Geometry2>
+            result_type operator()(Geometry1 const& geometry1,
+                                   Geometry2 const& geometry2) const
+            {
+                return crosses
+                    <
+                        Geometry1,
+                        Geometry2
+                    >::apply(geometry1, geometry2, m_strategy);
+            }
+        };
+        
+        template <typename Strategy>
+        static inline bool apply(variant<BOOST_VARIANT_ENUM_PARAMS(T1)> const& geometry1,
+                                 variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2,
+                                  Strategy const& strategy)
+        {
+            return boost::apply_visitor(visitor<Strategy>(strategy), geometry1, geometry2);
+        }
+    };
+    
+} // namespace resolve_variant
+    
+    
+/*!
+\brief \brief_check2{crosses}
+\ingroup crosses
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Strategy \tparam_strategy{Crosses}
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param strategy \param_strategy{crosses}
+\return \return_check2{crosses}
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/crosses.qbk]}
+*/
+template <typename Geometry1, typename Geometry2, typename Strategy>
+inline bool crosses(Geometry1 const& geometry1,
+                    Geometry2 const& geometry2,
+                    Strategy const& strategy)
+{
+    return resolve_variant::crosses
+            <
+                Geometry1, Geometry2
+            >::apply(geometry1, geometry2, strategy);
+}
+
+/*!
+\brief \brief_check2{crosses}
+\ingroup crosses
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\return \return_check2{crosses}
+
+\qbk{[include reference/algorithms/crosses.qbk]}
+*/
+template <typename Geometry1, typename Geometry2>
+inline bool crosses(Geometry1 const& geometry1, Geometry2 const& geometry2)
+{
+    return resolve_variant::crosses
+            <
+                Geometry1, Geometry2
+            >::apply(geometry1, geometry2, default_strategy());
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_CROSSES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/as_range.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/as_range.hpp
new file mode 100644
index 00000000000..fef5156eeff
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/as_range.hpp
@@ -0,0 +1,105 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_AS_RANGE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_AS_RANGE_HPP
+
+
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/add_const_if_c.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename GeometryTag, typename Geometry, typename Range, bool IsConst>
+struct as_range
+{
+    static inline typename add_const_if_c<IsConst, Range>::type& get(
+            typename add_const_if_c<IsConst, Geometry>::type& input)
+    {
+        return input;
+    }
+};
+
+
+template <typename Geometry, typename Range, bool IsConst>
+struct as_range<polygon_tag, Geometry, Range, IsConst>
+{
+    static inline typename add_const_if_c<IsConst, Range>::type& get(
+            typename add_const_if_c<IsConst, Geometry>::type& input)
+    {
+        return exterior_ring(input);
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+// Will probably be replaced by the more generic "view_as", therefore in detail
+namespace detail
+{
+
+/*!
+\brief Function getting either the range (ring, linestring) itself
+or the outer ring (polygon)
+\details Utility to handle polygon's outer ring as a range
+\ingroup utility
+*/
+template <typename Range, typename Geometry>
+inline Range& as_range(Geometry& input)
+{
+    return dispatch::as_range
+        <
+            typename tag<Geometry>::type,
+            Geometry,
+            Range,
+            false
+        >::get(input);
+}
+
+
+/*!
+\brief Function getting either the range (ring, linestring) itself
+or the outer ring (polygon), const version
+\details Utility to handle polygon's outer ring as a range
+\ingroup utility
+*/
+template <typename Range, typename Geometry>
+inline Range const& as_range(Geometry const& input)
+{
+    return dispatch::as_range
+        <
+            typename tag<Geometry>::type,
+            Geometry,
+            Range,
+            true
+        >::get(input);
+}
+
+}
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_AS_RANGE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/assign_box_corners.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/assign_box_corners.hpp
new file mode 100644
index 00000000000..bd8b84afcf5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/assign_box_corners.hpp
@@ -0,0 +1,107 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_ASSIGN_BOX_CORNERS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_ASSIGN_BOX_CORNERS_HPP
+
+
+#include <cstddef>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/algorithms/detail/assign_values.hpp>
+#include <boost/geometry/util/range.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+// Note: this is moved to namespace detail because the names and parameter orders
+// are not yet 100% clear.
+
+/*!
+\brief Assign the four points of a 2D box
+\ingroup assign
+\note The order is crucial. Most logical is LOWER, UPPER and sub-order LEFT, RIGHT
+    so this is how it is implemented.
+\tparam Box \tparam_box
+\tparam Point \tparam_point
+\param box \param_box
+\param lower_left point being assigned to lower left coordinates of the box
+\param lower_right point being assigned to lower right coordinates of the box
+\param upper_left point being assigned to upper left coordinates of the box
+\param upper_right point being assigned to upper right coordinates of the box
+
+\qbk{
+[heading Example]
+[assign_box_corners] [assign_box_corners_output]
+}
+*/
+template <typename Box, typename Point>
+inline void assign_box_corners(Box const& box,
+        Point& lower_left, Point& lower_right,
+        Point& upper_left, Point& upper_right)
+{
+    concepts::check<Box const>();
+    concepts::check<Point>();
+
+    detail::assign::assign_box_2d_corner
+            <min_corner, min_corner>(box, lower_left);
+    detail::assign::assign_box_2d_corner
+            <max_corner, min_corner>(box, lower_right);
+    detail::assign::assign_box_2d_corner
+            <min_corner, max_corner>(box, upper_left);
+    detail::assign::assign_box_2d_corner
+            <max_corner, max_corner>(box, upper_right);
+}
+
+// Silence warning C4127: conditional expression is constant
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4127)
+#endif
+
+
+template <bool Reverse, typename Box, typename Range>
+inline void assign_box_corners_oriented(Box const& box, Range& corners)
+{
+    if (Reverse)
+    {
+        // make counterclockwise ll,lr,ur,ul
+        assign_box_corners(box,
+                           range::at(corners, 0), range::at(corners, 1),
+                           range::at(corners, 3), range::at(corners, 2));
+    }
+    else
+    {
+        // make clockwise ll,ul,ur,lr
+        assign_box_corners(box,
+                           range::at(corners, 0), range::at(corners, 3),
+                           range::at(corners, 1), range::at(corners, 2));
+    }
+}
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_ASSIGN_BOX_CORNERS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/assign_indexed_point.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/assign_indexed_point.hpp
new file mode 100644
index 00000000000..e5d9358c136
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/assign_indexed_point.hpp
@@ -0,0 +1,94 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_ASSIGN_INDEXED_POINT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_ASSIGN_INDEXED_POINT_HPP
+
+
+#include <cstddef>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/algorithms/detail/assign_values.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+/*!
+\brief Assign a box or segment with the value of a point
+\ingroup assign
+\tparam Index indicates which box-corner, min_corner (0) or max_corner (1)
+    or which point of segment (0/1)
+\tparam Point \tparam_point
+\tparam Geometry \tparam_box_or_segment
+\param point \param_point
+\param geometry \param_box_or_segment
+
+\qbk{
+[heading Example]
+[assign_point_to_index] [assign_point_to_index_output]
+}
+*/
+template <std::size_t Index, typename Geometry, typename Point>
+inline void assign_point_to_index(Point const& point, Geometry& geometry)
+{
+    concepts::check<Point const>();
+    concepts::check<Geometry>();
+
+    detail::assign::assign_point_to_index
+        <
+            Geometry, Point, Index, 0, dimension<Geometry>::type::value
+        >::apply(point, geometry);
+}
+
+
+/*!
+\brief Assign a point with a point of a box or segment
+\ingroup assign
+\tparam Index indicates which box-corner, min_corner (0) or max_corner (1)
+    or which point of segment (0/1)
+\tparam Geometry \tparam_box_or_segment
+\tparam Point \tparam_point
+\param geometry \param_box_or_segment
+\param point \param_point
+
+\qbk{
+[heading Example]
+[assign_point_from_index] [assign_point_from_index_output]
+}
+*/
+template <std::size_t Index, typename Point, typename Geometry>
+inline void assign_point_from_index(Geometry const& geometry, Point& point)
+{
+    concepts::check<Geometry const>();
+    concepts::check<Point>();
+
+    detail::assign::assign_point_from_index
+        <
+            Geometry, Point, Index, 0, dimension<Geometry>::type::value
+        >::apply(geometry, point);
+}
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_ASSIGN_INDEXED_POINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/assign_values.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/assign_values.hpp
new file mode 100644
index 00000000000..ef5691e97c0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/assign_values.hpp
@@ -0,0 +1,336 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_ASSIGN_VALUES_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_ASSIGN_VALUES_HPP
+
+
+#include <cstddef>
+
+#include <boost/concept/requires.hpp>
+#include <boost/concept_check.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/numeric/conversion/bounds.hpp>
+#include <boost/numeric/conversion/cast.hpp>
+
+#include <boost/geometry/arithmetic/arithmetic.hpp>
+#include <boost/geometry/algorithms/append.hpp>
+#include <boost/geometry/algorithms/clear.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+
+#include <boost/geometry/util/for_each_coordinate.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace assign
+{
+
+
+template <std::size_t Index, std::size_t Dimension, std::size_t DimensionCount>
+struct initialize
+{
+    template <typename Box>
+    static inline void apply(Box& box, typename coordinate_type<Box>::type const& value)
+    {
+        geometry::set<Index, Dimension>(box, value);
+        initialize<Index, Dimension + 1, DimensionCount>::apply(box, value);
+    }
+};
+
+
+template <std::size_t Index, std::size_t DimensionCount>
+struct initialize<Index, DimensionCount, DimensionCount>
+{
+    template <typename Box>
+    static inline void apply(Box&, typename coordinate_type<Box>::type const&)
+    {}
+};
+
+
+struct assign_zero_point
+{
+    template <typename Point>
+    static inline void apply(Point& point)
+    {
+        geometry::assign_value(point, 0);
+    }
+};
+
+
+struct assign_inverse_box_or_segment
+{
+
+    template <typename BoxOrSegment>
+    static inline void apply(BoxOrSegment& geometry)
+    {
+        typedef typename point_type<BoxOrSegment>::type point_type;
+        typedef typename coordinate_type<point_type>::type bound_type;
+
+        initialize<0, 0, dimension<BoxOrSegment>::type::value>::apply(
+            geometry, boost::numeric::bounds<bound_type>::highest()
+        );
+        initialize<1, 0, dimension<BoxOrSegment>::type::value>::apply(
+            geometry, boost::numeric::bounds<bound_type>::lowest()
+        );
+    }
+};
+
+
+struct assign_zero_box_or_segment
+{
+    template <typename BoxOrSegment>
+    static inline void apply(BoxOrSegment& geometry)
+    {
+        typedef typename coordinate_type<BoxOrSegment>::type coordinate_type;
+
+        initialize<0, 0, dimension<BoxOrSegment>::type::value>::apply(
+            geometry, coordinate_type()
+        );
+        initialize<1, 0, dimension<BoxOrSegment>::type::value>::apply(
+            geometry, coordinate_type()
+        );
+    }
+};
+
+
+template
+<
+    std::size_t Corner1, std::size_t Corner2,
+    typename Box, typename Point
+>
+inline void assign_box_2d_corner(Box const& box, Point& point)
+{
+    // Be sure both are 2-Dimensional
+    assert_dimension<Box, 2>();
+    assert_dimension<Point, 2>();
+
+    // Copy coordinates
+    typedef typename coordinate_type<Point>::type coordinate_type;
+
+    geometry::set<0>(point, boost::numeric_cast<coordinate_type>(get<Corner1, 0>(box)));
+    geometry::set<1>(point, boost::numeric_cast<coordinate_type>(get<Corner2, 1>(box)));
+}
+
+
+
+template
+<
+    typename Geometry, typename Point,
+    std::size_t Index,
+    std::size_t Dimension, std::size_t DimensionCount
+>
+struct assign_point_to_index
+{
+
+    static inline void apply(Point const& point, Geometry& geometry)
+    {
+        geometry::set<Index, Dimension>(geometry, boost::numeric_cast
+            <
+                typename coordinate_type<Geometry>::type
+            >(geometry::get<Dimension>(point)));
+
+        assign_point_to_index
+            <
+                Geometry, Point, Index, Dimension + 1, DimensionCount
+            >::apply(point, geometry);
+    }
+};
+
+template
+<
+    typename Geometry, typename Point,
+    std::size_t Index,
+    std::size_t DimensionCount
+>
+struct assign_point_to_index
+    <
+        Geometry, Point,
+        Index,
+        DimensionCount, DimensionCount
+    >
+{
+    static inline void apply(Point const& , Geometry& )
+    {
+    }
+};
+
+
+template
+<
+    typename Geometry, typename Point,
+    std::size_t Index,
+    std::size_t Dimension, std::size_t DimensionCount
+>
+struct assign_point_from_index
+{
+
+    static inline void apply(Geometry const& geometry, Point& point)
+    {
+        geometry::set<Dimension>( point, boost::numeric_cast
+            <
+                typename coordinate_type<Point>::type
+            >(geometry::get<Index, Dimension>(geometry)));
+
+        assign_point_from_index
+            <
+                Geometry, Point, Index, Dimension + 1, DimensionCount
+            >::apply(geometry, point);
+    }
+};
+
+template
+<
+    typename Geometry, typename Point,
+    std::size_t Index,
+    std::size_t DimensionCount
+>
+struct assign_point_from_index
+    <
+        Geometry, Point,
+        Index,
+        DimensionCount, DimensionCount
+    >
+{
+    static inline void apply(Geometry const&, Point&)
+    {
+    }
+};
+
+
+template <typename Geometry>
+struct assign_2d_box_or_segment
+{
+    typedef typename coordinate_type<Geometry>::type coordinate_type;
+
+    // Here we assign 4 coordinates to a box of segment
+    // -> Most logical is: x1,y1,x2,y2
+    // In case the user reverses x1/x2 or y1/y2, for a box, we could reverse them (THAT IS NOT IMPLEMENTED)
+
+    template <typename Type>
+    static inline void apply(Geometry& geometry,
+                Type const& x1, Type const& y1, Type const& x2, Type const& y2)
+    {
+        geometry::set<0, 0>(geometry, boost::numeric_cast<coordinate_type>(x1));
+        geometry::set<0, 1>(geometry, boost::numeric_cast<coordinate_type>(y1));
+        geometry::set<1, 0>(geometry, boost::numeric_cast<coordinate_type>(x2));
+        geometry::set<1, 1>(geometry, boost::numeric_cast<coordinate_type>(y2));
+    }
+};
+
+
+}} // namespace detail::assign
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename GeometryTag, typename Geometry, std::size_t DimensionCount>
+struct assign
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_OR_NOT_YET_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
+            , (types<Geometry>)
+        );
+};
+
+template <typename Point>
+struct assign<point_tag, Point, 2>
+{
+    typedef typename coordinate_type<Point>::type coordinate_type;
+
+    template <typename T>
+    static inline void apply(Point& point, T const& c1, T const& c2)
+    {
+        set<0>(point, boost::numeric_cast<coordinate_type>(c1));
+        set<1>(point, boost::numeric_cast<coordinate_type>(c2));
+    }
+};
+
+template <typename Point>
+struct assign<point_tag, Point, 3>
+{
+    typedef typename coordinate_type<Point>::type coordinate_type;
+
+    template <typename T>
+    static inline void apply(Point& point, T const& c1, T const& c2, T const& c3)
+    {
+        set<0>(point, boost::numeric_cast<coordinate_type>(c1));
+        set<1>(point, boost::numeric_cast<coordinate_type>(c2));
+        set<2>(point, boost::numeric_cast<coordinate_type>(c3));
+    }
+};
+
+template <typename Box>
+struct assign<box_tag, Box, 2>
+    : detail::assign::assign_2d_box_or_segment<Box>
+{};
+
+template <typename Segment>
+struct assign<segment_tag, Segment, 2>
+    : detail::assign::assign_2d_box_or_segment<Segment>
+{};
+
+
+
+template <typename GeometryTag, typename Geometry>
+struct assign_zero {};
+
+
+template <typename Point>
+struct assign_zero<point_tag, Point>
+    : detail::assign::assign_zero_point
+{};
+
+template <typename Box>
+struct assign_zero<box_tag, Box>
+    : detail::assign::assign_zero_box_or_segment
+{};
+
+template <typename Segment>
+struct assign_zero<segment_tag, Segment>
+    : detail::assign::assign_zero_box_or_segment
+{};
+
+
+template <typename GeometryTag, typename Geometry>
+struct assign_inverse {};
+
+template <typename Box>
+struct assign_inverse<box_tag, Box>
+    : detail::assign::assign_inverse_box_or_segment
+{};
+
+template <typename Segment>
+struct assign_inverse<segment_tag, Segment>
+    : detail::assign::assign_inverse_box_or_segment
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_ASSIGN_VALUES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/azimuth.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/azimuth.hpp
new file mode 100644
index 00000000000..a5863d7d242
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/azimuth.hpp
@@ -0,0 +1,148 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014, 2016, 2017.
+// Modifications copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_AZIMUTH_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_AZIMUTH_HPP
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/radian_access.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/formulas/spherical.hpp>
+#include <boost/geometry/formulas/vincenty_inverse.hpp>
+
+namespace boost { namespace geometry
+{
+
+// An azimuth is an angle between a vector/segment from origin to a point of
+// interest and a reference vector. Typically north-based azimuth is used.
+// North direction is used as a reference, angle is measured clockwise
+// (North - 0deg, East - 90deg). For consistency in 2d cartesian CS
+// the reference vector is Y axis, angle is measured clockwise.
+// http://en.wikipedia.org/wiki/Azimuth
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace detail_dispatch
+{
+
+template <typename ReturnType, typename Tag>
+struct azimuth
+    : not_implemented<Tag>
+{};
+
+template <typename ReturnType>
+struct azimuth<ReturnType, geographic_tag>
+{
+    template <typename P1, typename P2, typename Spheroid>
+    static inline ReturnType apply(P1 const& p1, P2 const& p2, Spheroid const& spheroid)
+    {
+        return geometry::formula::vincenty_inverse<ReturnType, false, true>().apply
+                    ( get_as_radian<0>(p1), get_as_radian<1>(p1),
+                      get_as_radian<0>(p2), get_as_radian<1>(p2),
+                      spheroid ).azimuth;
+    }
+
+    template <typename P1, typename P2>
+    static inline ReturnType apply(P1 const& p1, P2 const& p2)
+    {
+        return apply(p1, p2, srs::spheroid<ReturnType>());
+    }
+};
+
+template <typename ReturnType>
+struct azimuth<ReturnType, spherical_equatorial_tag>
+{
+    template <typename P1, typename P2, typename Sphere>
+    static inline ReturnType apply(P1 const& p1, P2 const& p2, Sphere const& /*unused*/)
+    {
+        return geometry::formula::spherical_azimuth<ReturnType, false>
+                    ( get_as_radian<0>(p1), get_as_radian<1>(p1),
+                      get_as_radian<0>(p2), get_as_radian<1>(p2)).azimuth;
+    }
+
+    template <typename P1, typename P2>
+    static inline ReturnType apply(P1 const& p1, P2 const& p2)
+    {
+        return apply(p1, p2, 0); // dummy model
+    }
+};
+
+template <typename ReturnType>
+struct azimuth<ReturnType, spherical_polar_tag>
+    : azimuth<ReturnType, spherical_equatorial_tag>
+{};
+
+template <typename ReturnType>
+struct azimuth<ReturnType, cartesian_tag>
+{
+    template <typename P1, typename P2, typename Plane>
+    static inline ReturnType apply(P1 const& p1, P2 const& p2, Plane const& /*unused*/)
+    {
+        ReturnType x = get<0>(p2) - get<0>(p1);
+        ReturnType y = get<1>(p2) - get<1>(p1);
+
+        // NOTE: azimuth 0 is at Y axis, increasing right
+        // as in spherical/geographic where 0 is at North axis
+        return atan2(x, y);
+    }
+
+    template <typename P1, typename P2>
+    static inline ReturnType apply(P1 const& p1, P2 const& p2)
+    {
+        return apply(p1, p2, 0); // dummy model
+    }
+};
+
+} // detail_dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+/// Calculate azimuth between two points.
+/// The result is in radians.
+template <typename ReturnType, typename Point1, typename Point2>
+inline ReturnType azimuth(Point1 const& p1, Point2 const& p2)
+{
+    return detail_dispatch::azimuth
+            <
+                ReturnType,
+                typename geometry::cs_tag<Point1>::type
+            >::apply(p1, p2);
+}
+
+/// Calculate azimuth between two points.
+/// The result is in radians.
+template <typename ReturnType, typename Point1, typename Point2, typename Model>
+inline ReturnType azimuth(Point1 const& p1, Point2 const& p2, Model const& model)
+{
+    return detail_dispatch::azimuth
+            <
+                ReturnType,
+                typename geometry::cs_tag<Point1>::type
+            >::apply(p1, p2, model);
+}
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_AZIMUTH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/buffer_inserter.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/buffer_inserter.hpp
new file mode 100644
index 00000000000..a149f1dd460
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/buffer_inserter.hpp
@@ -0,0 +1,1062 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012-2014 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_BUFFER_INSERTER_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_BUFFER_INSERTER_HPP
+
+#include <cstddef>
+#include <iterator>
+
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/numeric/conversion/cast.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/strategies/buffer.hpp>
+#include <boost/geometry/strategies/side.hpp>
+#include <boost/geometry/algorithms/detail/buffer/buffered_piece_collection.hpp>
+#include <boost/geometry/algorithms/detail/buffer/line_line_intersection.hpp>
+#include <boost/geometry/algorithms/detail/buffer/parallel_continue.hpp>
+
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/algorithms/num_interior_rings.hpp>
+#include <boost/geometry/algorithms/simplify.hpp>
+
+#include <boost/geometry/views/detail/normalized_view.hpp>
+
+#if defined(BOOST_GEOMETRY_BUFFER_SIMPLIFY_WITH_AX)
+#include <boost/geometry/strategies/cartesian/distance_projected_point_ax.hpp>
+#endif
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace buffer
+{
+
+template <typename Range, typename DistanceStrategy>
+inline void simplify_input(Range const& range,
+        DistanceStrategy const& distance,
+        Range& simplified)
+{
+    // We have to simplify the ring before to avoid very small-scaled
+    // features in the original (convex/concave/convex) being enlarged
+    // in a very large scale and causing issues (IP's within pieces).
+    // This might be reconsidered later. Simplifying with a very small
+    // distance (1%% of the buffer) will never be visible in the result,
+    // if it is using round joins. For miter joins they are even more
+    // sensitive to small scale input features, however the result will
+    // look better.
+    // It also gets rid of duplicate points
+#if ! defined(BOOST_GEOMETRY_BUFFER_SIMPLIFY_WITH_AX)
+    geometry::simplify(range, simplified, distance.simplify_distance());
+#else
+
+    typedef typename boost::range_value<Range>::type point_type;
+    typedef strategy::distance::detail::projected_point_ax<> ax_type;
+    typedef typename strategy::distance::services::return_type
+    <
+        strategy::distance::detail::projected_point_ax<>,
+        point_type,
+        point_type
+    >::type return_type;
+
+    typedef strategy::distance::detail::projected_point_ax_less
+    <
+        return_type
+    > comparator_type;
+
+    typedef strategy::simplify::detail::douglas_peucker
+    <
+        point_type,
+        strategy::distance::detail::projected_point_ax<>,
+        comparator_type
+    > dp_ax;
+
+    return_type max_distance(distance.simplify_distance() * 2.0,
+                             distance.simplify_distance());
+    comparator_type comparator(max_distance);
+    dp_ax strategy(comparator);
+
+    geometry::simplify(range, simplified, max_distance, strategy);
+#endif
+
+    if (boost::size(simplified) == 2
+        && geometry::equals(geometry::range::front(simplified),
+                geometry::range::back(simplified)))
+    {
+        traits::resize<Range>::apply(simplified, 1);
+    }
+}
+
+
+template <typename RingOutput>
+struct buffer_range
+{
+    typedef typename point_type<RingOutput>::type output_point_type;
+    typedef typename coordinate_type<RingOutput>::type coordinate_type;
+
+    template
+    <
+        typename Collection,
+        typename Point,
+        typename DistanceStrategy,
+        typename JoinStrategy,
+        typename EndStrategy,
+        typename RobustPolicy,
+        typename Strategy
+    >
+    static inline
+    void add_join(Collection& collection,
+            Point const& penultimate_input,
+            Point const& previous_input,
+            output_point_type const& prev_perp1,
+            output_point_type const& prev_perp2,
+            Point const& input,
+            output_point_type const& perp1,
+            output_point_type const& perp2,
+            geometry::strategy::buffer::buffer_side_selector side,
+            DistanceStrategy const& distance,
+            JoinStrategy const& join_strategy,
+            EndStrategy const& end_strategy,
+            RobustPolicy const& ,
+            Strategy const& strategy) // side strategy
+    {
+        output_point_type intersection_point;
+        geometry::assign_zero(intersection_point);
+
+        geometry::strategy::buffer::join_selector join
+                = get_join_type(penultimate_input, previous_input, input, strategy);
+        if (join == geometry::strategy::buffer::join_convex)
+        {
+            // Calculate the intersection-point formed by the two sides.
+            // It might be that the two sides are not convex, but continue
+            // or spikey, we then change the join-type
+            join = line_line_intersection::apply(
+                        perp1, perp2, prev_perp1, prev_perp2,
+                        intersection_point);
+
+        }
+
+        switch(join)
+        {
+            case geometry::strategy::buffer::join_continue :
+                // No join, we get two consecutive sides
+                break;
+            case geometry::strategy::buffer::join_concave :
+                {
+                    std::vector<output_point_type> range_out;
+                    range_out.push_back(prev_perp2);
+                    range_out.push_back(previous_input);
+                    collection.add_piece(geometry::strategy::buffer::buffered_concave, previous_input, range_out);
+
+                    range_out.clear();
+                    range_out.push_back(previous_input);
+                    range_out.push_back(perp1);
+                    collection.add_piece(geometry::strategy::buffer::buffered_concave, previous_input, range_out);
+                }
+                break;
+            case geometry::strategy::buffer::join_spike :
+                {
+                    // For linestrings, only add spike at one side to avoid
+                    // duplicates
+                    std::vector<output_point_type> range_out;
+                    end_strategy.apply(penultimate_input, prev_perp2, previous_input, perp1, side, distance, range_out);
+                    collection.add_endcap(end_strategy, range_out, previous_input);
+                    collection.set_current_ring_concave();
+                }
+                break;
+            case geometry::strategy::buffer::join_convex :
+                {
+                    // The corner is convex, we create a join
+                    // TODO (future) - avoid a separate vector, add the piece directly
+                    std::vector<output_point_type> range_out;
+                    if (join_strategy.apply(intersection_point,
+                                previous_input, prev_perp2, perp1,
+                                distance.apply(previous_input, input, side),
+                                range_out))
+                    {
+                        collection.add_piece(geometry::strategy::buffer::buffered_join,
+                                previous_input, range_out);
+                    }
+                }
+                break;
+        }
+    }
+
+    template <typename Strategy>
+    static inline geometry::strategy::buffer::join_selector get_join_type(
+            output_point_type const& p0,
+            output_point_type const& p1,
+            output_point_type const& p2,
+            Strategy const& strategy) // side strategy
+    {
+        int const side = strategy.apply(p0, p1, p2);
+        return side == -1 ? geometry::strategy::buffer::join_convex
+            :  side == 1  ? geometry::strategy::buffer::join_concave
+            :  parallel_continue
+                    (
+                        get<0>(p2) - get<0>(p1),
+                        get<1>(p2) - get<1>(p1),
+                        get<0>(p1) - get<0>(p0),
+                        get<1>(p1) - get<1>(p0)
+                    )  ? geometry::strategy::buffer::join_continue
+            : geometry::strategy::buffer::join_spike;
+    }
+
+    template
+    <
+        typename Collection,
+        typename Iterator,
+        typename DistanceStrategy,
+        typename SideStrategy,
+        typename JoinStrategy,
+        typename EndStrategy,
+        typename RobustPolicy,
+        typename Strategy
+    >
+    static inline geometry::strategy::buffer::result_code iterate(Collection& collection,
+                Iterator begin, Iterator end,
+                geometry::strategy::buffer::buffer_side_selector side,
+                DistanceStrategy const& distance_strategy,
+                SideStrategy const& side_strategy,
+                JoinStrategy const& join_strategy,
+                EndStrategy const& end_strategy,
+                RobustPolicy const& robust_policy,
+                Strategy const& strategy, // side strategy
+                output_point_type& first_p1,
+                output_point_type& first_p2,
+                output_point_type& last_p1,
+                output_point_type& last_p2)
+    {
+        boost::ignore_unused(side_strategy);
+
+        typedef typename std::iterator_traits
+        <
+            Iterator
+        >::value_type point_type;
+
+        point_type second_point, penultimate_point, ultimate_point; // last two points from begin/end
+
+        /*
+         * last.p1    last.p2  these are the "previous (last) perpendicular points"
+         * --------------
+         * |            |
+         * *------------*____  <- *prev
+         * pup          |    | p1           "current perpendicular point 1"
+         *              |    |
+         *              |    |       this forms a "side", a side is a piece
+         *              |    |
+         *              *____| p2
+         *
+         *              ^
+         *             *it
+         *
+         * pup: penultimate_point
+         */
+
+        geometry::strategy::buffer::result_code result = geometry::strategy::buffer::result_no_output;
+        bool first = true;
+
+        Iterator it = begin;
+
+        std::vector<output_point_type> generated_side;
+        generated_side.reserve(2);
+
+        for (Iterator prev = it++; it != end; ++it)
+        {
+            generated_side.clear();
+            geometry::strategy::buffer::result_code error_code
+                = side_strategy.apply(*prev, *it, side,
+                                distance_strategy, generated_side);
+
+            if (error_code == geometry::strategy::buffer::result_no_output)
+            {
+                // Because input is simplified, this is improbable,
+                // but it can happen for degenerate geometries
+                // Further handling of this side is skipped
+                continue;
+            }
+            else if (error_code == geometry::strategy::buffer::result_error_numerical)
+            {
+                return error_code;
+            }
+
+            BOOST_GEOMETRY_ASSERT(! generated_side.empty());
+
+            result = geometry::strategy::buffer::result_normal;
+
+            if (! first)
+            {
+                 add_join(collection,
+                        penultimate_point,
+                        *prev, last_p1, last_p2,
+                        *it, generated_side.front(), generated_side.back(),
+                        side,
+                        distance_strategy, join_strategy, end_strategy,
+                        robust_policy, strategy);
+            }
+
+            collection.add_side_piece(*prev, *it, generated_side, first);
+
+            penultimate_point = *prev;
+            ultimate_point = *it;
+            last_p1 = generated_side.front();
+            last_p2 = generated_side.back();
+            prev = it;
+            if (first)
+            {
+                first = false;
+                second_point = *it;
+                first_p1 = generated_side.front();
+                first_p2 = generated_side.back();
+            }
+        }
+        return result;
+    }
+};
+
+template
+<
+    typename Multi,
+    typename PolygonOutput,
+    typename Policy
+>
+struct buffer_multi
+{
+    template
+    <
+        typename Collection,
+        typename DistanceStrategy,
+        typename SideStrategy,
+        typename JoinStrategy,
+        typename EndStrategy,
+        typename PointStrategy,
+        typename RobustPolicy,
+        typename Strategy
+    >
+    static inline void apply(Multi const& multi,
+            Collection& collection,
+            DistanceStrategy const& distance_strategy,
+            SideStrategy const& side_strategy,
+            JoinStrategy const& join_strategy,
+            EndStrategy const& end_strategy,
+            PointStrategy const& point_strategy,
+            RobustPolicy const& robust_policy,
+            Strategy const& strategy) // side strategy
+    {
+        for (typename boost::range_iterator<Multi const>::type
+                it = boost::begin(multi);
+            it != boost::end(multi);
+            ++it)
+        {
+            Policy::apply(*it, collection,
+                distance_strategy, side_strategy,
+                join_strategy, end_strategy, point_strategy,
+                robust_policy, strategy);
+        }
+    }
+};
+
+struct visit_pieces_default_policy
+{
+    template <typename Collection>
+    static inline void apply(Collection const&, int)
+    {}
+};
+
+template
+<
+    typename OutputPointType,
+    typename Point,
+    typename Collection,
+    typename DistanceStrategy,
+    typename PointStrategy
+>
+inline void buffer_point(Point const& point, Collection& collection,
+        DistanceStrategy const& distance_strategy,
+        PointStrategy const& point_strategy)
+{
+    collection.start_new_ring();
+    std::vector<OutputPointType> range_out;
+    point_strategy.apply(point, distance_strategy, range_out);
+    collection.add_piece(geometry::strategy::buffer::buffered_point, range_out, false);
+    collection.set_piece_center(point);
+    collection.finish_ring(geometry::strategy::buffer::result_normal);
+}
+
+
+}} // namespace detail::buffer
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Tag,
+    typename RingInput,
+    typename RingOutput
+>
+struct buffer_inserter
+{};
+
+
+
+template
+<
+    typename Point,
+    typename RingOutput
+>
+struct buffer_inserter<point_tag, Point, RingOutput>
+{
+    template
+    <
+        typename Collection,
+        typename DistanceStrategy,
+        typename SideStrategy,
+        typename JoinStrategy,
+        typename EndStrategy,
+        typename PointStrategy,
+        typename RobustPolicy,
+        typename Strategy
+    >
+    static inline void apply(Point const& point, Collection& collection,
+            DistanceStrategy const& distance_strategy,
+            SideStrategy const& ,
+            JoinStrategy const& ,
+            EndStrategy const& ,
+            PointStrategy const& point_strategy,
+            RobustPolicy const& ,
+            Strategy const& ) // side strategy
+    {
+        detail::buffer::buffer_point
+        <
+            typename point_type<RingOutput>::type
+        >(point, collection, distance_strategy, point_strategy);
+    }
+};
+
+// Not a specialization, but called from specializations of ring and of polygon.
+// Calling code starts/finishes ring before/after apply
+template
+<
+    typename RingInput,
+    typename RingOutput
+>
+struct buffer_inserter_ring
+{
+    typedef typename point_type<RingOutput>::type output_point_type;
+
+    template
+    <
+        typename Collection,
+        typename Iterator,
+        typename DistanceStrategy,
+        typename SideStrategy,
+        typename JoinStrategy,
+        typename EndStrategy,
+        typename RobustPolicy,
+        typename Strategy
+    >
+    static inline geometry::strategy::buffer::result_code iterate(Collection& collection,
+                Iterator begin, Iterator end,
+                geometry::strategy::buffer::buffer_side_selector side,
+                DistanceStrategy const& distance_strategy,
+                SideStrategy const& side_strategy,
+                JoinStrategy const& join_strategy,
+                EndStrategy const& end_strategy,
+                RobustPolicy const& robust_policy,
+                Strategy const& strategy) // side strategy
+    {
+        output_point_type first_p1, first_p2, last_p1, last_p2;
+
+        typedef detail::buffer::buffer_range<RingOutput> buffer_range;
+
+        geometry::strategy::buffer::result_code result
+            = buffer_range::iterate(collection, begin, end,
+                side,
+                distance_strategy, side_strategy, join_strategy, end_strategy,
+                robust_policy, strategy,
+                first_p1, first_p2, last_p1, last_p2);
+
+        // Generate closing join
+        if (result == geometry::strategy::buffer::result_normal)
+        {
+            buffer_range::add_join(collection,
+                *(end - 2),
+                *(end - 1), last_p1, last_p2,
+                *(begin + 1), first_p1, first_p2,
+                side,
+                distance_strategy, join_strategy, end_strategy,
+                robust_policy, strategy);
+        }
+
+        // Buffer is closed automatically by last closing corner
+        return result;
+    }
+
+    template
+    <
+        typename Collection,
+        typename DistanceStrategy,
+        typename SideStrategy,
+        typename JoinStrategy,
+        typename EndStrategy,
+        typename PointStrategy,
+        typename RobustPolicy,
+        typename Strategy
+    >
+    static inline geometry::strategy::buffer::result_code apply(RingInput const& ring,
+            Collection& collection,
+            DistanceStrategy const& distance,
+            SideStrategy const& side_strategy,
+            JoinStrategy const& join_strategy,
+            EndStrategy const& end_strategy,
+            PointStrategy const& point_strategy,
+            RobustPolicy const& robust_policy,
+            Strategy const& strategy) // side strategy
+    {
+        RingInput simplified;
+        detail::buffer::simplify_input(ring, distance, simplified);
+
+        geometry::strategy::buffer::result_code code = geometry::strategy::buffer::result_no_output;
+
+        std::size_t n = boost::size(simplified);
+        std::size_t const min_points = core_detail::closure::minimum_ring_size
+            <
+                geometry::closure<RingInput>::value
+            >::value;
+
+        if (n >= min_points)
+        {
+            detail::normalized_view<RingInput const> view(simplified);
+            if (distance.negative())
+            {
+                // Walk backwards (rings will be reversed afterwards)
+                code = iterate(collection, boost::rbegin(view), boost::rend(view),
+                        geometry::strategy::buffer::buffer_side_right,
+                        distance, side_strategy, join_strategy, end_strategy,
+                        robust_policy, strategy);
+            }
+            else
+            {
+                code = iterate(collection, boost::begin(view), boost::end(view),
+                        geometry::strategy::buffer::buffer_side_left,
+                        distance, side_strategy, join_strategy, end_strategy,
+                        robust_policy, strategy);
+            }
+        }
+
+        if (code == geometry::strategy::buffer::result_no_output && n >= 1)
+        {
+            // Use point_strategy to buffer degenerated ring
+            detail::buffer::buffer_point<output_point_type>
+                (
+                    geometry::range::front(simplified),
+                    collection, distance, point_strategy
+                );
+        }
+        return code;
+    }
+};
+
+
+template
+<
+    typename RingInput,
+    typename RingOutput
+>
+struct buffer_inserter<ring_tag, RingInput, RingOutput>
+{
+    template
+    <
+        typename Collection,
+        typename DistanceStrategy,
+        typename SideStrategy,
+        typename JoinStrategy,
+        typename EndStrategy,
+        typename PointStrategy,
+        typename RobustPolicy,
+        typename Strategy
+    >
+    static inline geometry::strategy::buffer::result_code apply(RingInput const& ring,
+            Collection& collection,
+            DistanceStrategy const& distance,
+            SideStrategy const& side_strategy,
+            JoinStrategy const& join_strategy,
+            EndStrategy const& end_strategy,
+            PointStrategy const& point_strategy,
+            RobustPolicy const& robust_policy,
+            Strategy const& strategy) // side strategy
+    {
+        collection.start_new_ring();
+        geometry::strategy::buffer::result_code const code
+            = buffer_inserter_ring<RingInput, RingOutput>::apply(ring,
+                collection, distance,
+                side_strategy, join_strategy, end_strategy, point_strategy,
+                robust_policy, strategy);
+        collection.finish_ring(code);
+        return code;
+    }
+};
+
+template
+<
+    typename Linestring,
+    typename Polygon
+>
+struct buffer_inserter<linestring_tag, Linestring, Polygon>
+{
+    typedef typename ring_type<Polygon>::type output_ring_type;
+    typedef typename point_type<output_ring_type>::type output_point_type;
+    typedef typename point_type<Linestring>::type input_point_type;
+
+    template
+    <
+        typename Collection,
+        typename Iterator,
+        typename DistanceStrategy,
+        typename SideStrategy,
+        typename JoinStrategy,
+        typename EndStrategy,
+        typename RobustPolicy,
+        typename Strategy
+    >
+    static inline geometry::strategy::buffer::result_code iterate(Collection& collection,
+                Iterator begin, Iterator end,
+                geometry::strategy::buffer::buffer_side_selector side,
+                DistanceStrategy const& distance_strategy,
+                SideStrategy const& side_strategy,
+                JoinStrategy const& join_strategy,
+                EndStrategy const& end_strategy,
+                RobustPolicy const& robust_policy,
+                Strategy const& strategy, // side strategy
+                output_point_type& first_p1)
+    {
+        input_point_type const& ultimate_point = *(end - 1);
+        input_point_type const& penultimate_point = *(end - 2);
+
+        // For the end-cap, we need to have the last perpendicular point on the
+        // other side of the linestring. If it is the second pass (right),
+        // we have it already from the first phase (left).
+        // But for the first pass, we have to generate it
+        output_point_type reverse_p1;
+        if (side == geometry::strategy::buffer::buffer_side_right)
+        {
+            reverse_p1 = first_p1;
+        }
+        else
+        {
+            std::vector<output_point_type> generated_side;
+            geometry::strategy::buffer::result_code code
+                = side_strategy.apply(ultimate_point, penultimate_point,
+                    geometry::strategy::buffer::buffer_side_right,
+                    distance_strategy, generated_side);
+            if (code != geometry::strategy::buffer::result_normal)
+            {
+                // No output or numerical error
+                return code;
+            }
+            reverse_p1 = generated_side.front();
+        }
+
+        output_point_type first_p2, last_p1, last_p2;
+
+        geometry::strategy::buffer::result_code result
+            = detail::buffer::buffer_range<output_ring_type>::iterate(collection,
+                begin, end, side,
+                distance_strategy, side_strategy, join_strategy, end_strategy,
+                robust_policy, strategy,
+                first_p1, first_p2, last_p1, last_p2);
+
+        if (result == geometry::strategy::buffer::result_normal)
+        {
+            std::vector<output_point_type> range_out;
+            end_strategy.apply(penultimate_point, last_p2, ultimate_point, reverse_p1,
+                               side, distance_strategy, range_out);
+            collection.add_endcap(end_strategy, range_out, ultimate_point);
+        }
+        return result;
+    }
+
+    template
+    <
+        typename Collection,
+        typename DistanceStrategy,
+        typename SideStrategy,
+        typename JoinStrategy,
+        typename EndStrategy,
+        typename PointStrategy,
+        typename RobustPolicy,
+        typename Strategy
+    >
+    static inline geometry::strategy::buffer::result_code apply(Linestring const& linestring,
+            Collection& collection,
+            DistanceStrategy const& distance,
+            SideStrategy const& side_strategy,
+            JoinStrategy const& join_strategy,
+            EndStrategy const& end_strategy,
+            PointStrategy const& point_strategy,
+            RobustPolicy const& robust_policy,
+            Strategy const& strategy) // side strategy
+    {
+        Linestring simplified;
+        detail::buffer::simplify_input(linestring, distance, simplified);
+
+        geometry::strategy::buffer::result_code code = geometry::strategy::buffer::result_no_output;
+        std::size_t n = boost::size(simplified);
+        if (n > 1)
+        {
+            collection.start_new_ring();
+            output_point_type first_p1;
+            code = iterate(collection,
+                    boost::begin(simplified), boost::end(simplified),
+                    geometry::strategy::buffer::buffer_side_left,
+                    distance, side_strategy, join_strategy, end_strategy,
+                    robust_policy, strategy,
+                    first_p1);
+
+            if (code == geometry::strategy::buffer::result_normal)
+            {
+                code = iterate(collection,
+                        boost::rbegin(simplified), boost::rend(simplified),
+                        geometry::strategy::buffer::buffer_side_right,
+                        distance, side_strategy, join_strategy, end_strategy,
+                        robust_policy, strategy,
+                        first_p1);
+            }
+            collection.finish_ring(code);
+        }
+        if (code == geometry::strategy::buffer::result_no_output && n >= 1)
+        {
+            // Use point_strategy to buffer degenerated linestring
+            detail::buffer::buffer_point<output_point_type>
+                (
+                    geometry::range::front(simplified),
+                    collection, distance, point_strategy
+                );
+        }
+        return code;
+    }
+};
+
+
+template
+<
+    typename PolygonInput,
+    typename PolygonOutput
+>
+struct buffer_inserter<polygon_tag, PolygonInput, PolygonOutput>
+{
+private:
+    typedef typename ring_type<PolygonInput>::type input_ring_type;
+    typedef typename ring_type<PolygonOutput>::type output_ring_type;
+
+    typedef buffer_inserter_ring<input_ring_type, output_ring_type> policy;
+
+
+    template
+    <
+        typename Iterator,
+        typename Collection,
+        typename DistanceStrategy,
+        typename SideStrategy,
+        typename JoinStrategy,
+        typename EndStrategy,
+        typename PointStrategy,
+        typename RobustPolicy,
+        typename Strategy
+    >
+    static inline
+    void iterate(Iterator begin, Iterator end,
+            Collection& collection,
+            DistanceStrategy const& distance,
+            SideStrategy const& side_strategy,
+            JoinStrategy const& join_strategy,
+            EndStrategy const& end_strategy,
+            PointStrategy const& point_strategy,
+            RobustPolicy const& robust_policy,
+            Strategy const& strategy, // side strategy
+            bool is_interior)
+    {
+        for (Iterator it = begin; it != end; ++it)
+        {
+            collection.start_new_ring();
+            geometry::strategy::buffer::result_code const code
+                    = policy::apply(*it, collection, distance, side_strategy,
+                    join_strategy, end_strategy, point_strategy,
+                    robust_policy, strategy);
+
+            collection.finish_ring(code, is_interior);
+        }
+    }
+
+    template
+    <
+        typename InteriorRings,
+        typename Collection,
+        typename DistanceStrategy,
+        typename SideStrategy,
+        typename JoinStrategy,
+        typename EndStrategy,
+        typename PointStrategy,
+        typename RobustPolicy,
+        typename Strategy
+    >
+    static inline
+    void apply_interior_rings(InteriorRings const& interior_rings,
+            Collection& collection,
+            DistanceStrategy const& distance,
+            SideStrategy const& side_strategy,
+            JoinStrategy const& join_strategy,
+            EndStrategy const& end_strategy,
+            PointStrategy const& point_strategy,
+            RobustPolicy const& robust_policy,
+            Strategy const& strategy) // side strategy
+    {
+        iterate(boost::begin(interior_rings), boost::end(interior_rings),
+            collection, distance, side_strategy,
+            join_strategy, end_strategy, point_strategy,
+            robust_policy, strategy, true);
+    }
+
+public:
+    template
+    <
+        typename Collection,
+        typename DistanceStrategy,
+        typename SideStrategy,
+        typename JoinStrategy,
+        typename EndStrategy,
+        typename PointStrategy,
+        typename RobustPolicy,
+        typename Strategy
+    >
+    static inline void apply(PolygonInput const& polygon,
+            Collection& collection,
+            DistanceStrategy const& distance,
+            SideStrategy const& side_strategy,
+            JoinStrategy const& join_strategy,
+            EndStrategy const& end_strategy,
+            PointStrategy const& point_strategy,
+            RobustPolicy const& robust_policy,
+            Strategy const& strategy) // side strategy
+    {
+        {
+            collection.start_new_ring();
+
+            geometry::strategy::buffer::result_code const code
+                = policy::apply(exterior_ring(polygon), collection,
+                    distance, side_strategy,
+                    join_strategy, end_strategy, point_strategy,
+                    robust_policy, strategy);
+
+            collection.finish_ring(code, false,
+                    geometry::num_interior_rings(polygon) > 0u);
+        }
+
+        apply_interior_rings(interior_rings(polygon),
+                collection, distance, side_strategy,
+                join_strategy, end_strategy, point_strategy,
+                robust_policy, strategy);
+    }
+};
+
+
+template
+<
+    typename Multi,
+    typename PolygonOutput
+>
+struct buffer_inserter<multi_tag, Multi, PolygonOutput>
+    : public detail::buffer::buffer_multi
+             <
+                Multi,
+                PolygonOutput,
+                dispatch::buffer_inserter
+                <
+                    typename single_tag_of
+                                <
+                                    typename tag<Multi>::type
+                                >::type,
+                    typename boost::range_value<Multi const>::type,
+                    typename geometry::ring_type<PolygonOutput>::type
+                >
+            >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace buffer
+{
+
+template
+<
+    typename GeometryOutput,
+    typename GeometryInput,
+    typename OutputIterator,
+    typename DistanceStrategy,
+    typename SideStrategy,
+    typename JoinStrategy,
+    typename EndStrategy,
+    typename PointStrategy,
+    typename IntersectionStrategy,
+    typename RobustPolicy,
+    typename VisitPiecesPolicy
+>
+inline void buffer_inserter(GeometryInput const& geometry_input, OutputIterator out,
+        DistanceStrategy const& distance_strategy,
+        SideStrategy const& side_strategy,
+        JoinStrategy const& join_strategy,
+        EndStrategy const& end_strategy,
+        PointStrategy const& point_strategy,
+        IntersectionStrategy const& intersection_strategy,
+        RobustPolicy const& robust_policy,
+        VisitPiecesPolicy& visit_pieces_policy
+    )
+{
+    boost::ignore_unused(visit_pieces_policy);
+
+    typedef detail::buffer::buffered_piece_collection
+    <
+        typename geometry::ring_type<GeometryOutput>::type,
+        IntersectionStrategy,
+        RobustPolicy
+    > collection_type;
+    collection_type collection(intersection_strategy, robust_policy);
+    collection_type const& const_collection = collection;
+
+    bool const areal = boost::is_same
+        <
+            typename tag_cast<typename tag<GeometryInput>::type, areal_tag>::type,
+            areal_tag
+        >::type::value;
+    bool const linear = boost::is_same
+        <
+            typename tag_cast<typename tag<GeometryInput>::type, linear_tag>::type,
+            linear_tag
+        >::type::value;
+
+    dispatch::buffer_inserter
+        <
+            typename tag_cast
+                <
+                    typename tag<GeometryInput>::type,
+                    multi_tag
+                >::type,
+            GeometryInput,
+            GeometryOutput
+        >::apply(geometry_input, collection,
+            distance_strategy, side_strategy, join_strategy,
+            end_strategy, point_strategy,
+            robust_policy, intersection_strategy.get_side_strategy());
+
+    collection.get_turns();
+    collection.classify_turns(linear);
+    if (BOOST_GEOMETRY_CONDITION(areal))
+    {
+        collection.check_remaining_points(distance_strategy);
+    }
+
+    // Visit the piece collection. This does nothing (by default), but
+    // optionally a debugging tool can be attached (e.g. console or svg),
+    // or the piece collection can be unit-tested
+    // phase 0: turns (before discarded)
+    visit_pieces_policy.apply(const_collection, 0);
+
+    collection.discard_rings();
+    collection.block_turns();
+    collection.enrich();
+
+    // phase 1: turns (after enrichment/clustering)
+    visit_pieces_policy.apply(const_collection, 1);
+
+    collection.traverse();
+
+    // Reverse all offsetted rings / traversed rings if:
+    // - they were generated on the negative side (deflate) of polygons
+    // - the output is counter clockwise
+    // and avoid reversing twice
+    bool reverse = distance_strategy.negative() && areal;
+    if (BOOST_GEOMETRY_CONDITION(
+            geometry::point_order<GeometryOutput>::value == counterclockwise))
+    {
+        reverse = ! reverse;
+    }
+    if (reverse)
+    {
+        collection.reverse();
+    }
+
+    if (BOOST_GEOMETRY_CONDITION(distance_strategy.negative() && areal))
+    {
+        collection.discard_nonintersecting_deflated_rings();
+    }
+
+    collection.template assign<GeometryOutput>(out);
+
+    // Visit collection again
+    // phase 2: rings (after traversing)
+    visit_pieces_policy.apply(const_collection, 2);
+}
+
+template
+<
+    typename GeometryOutput,
+    typename GeometryInput,
+    typename OutputIterator,
+    typename DistanceStrategy,
+    typename SideStrategy,
+    typename JoinStrategy,
+    typename EndStrategy,
+    typename PointStrategy,
+    typename IntersectionStrategy,
+    typename RobustPolicy
+>
+inline void buffer_inserter(GeometryInput const& geometry_input, OutputIterator out,
+        DistanceStrategy const& distance_strategy,
+        SideStrategy const& side_strategy,
+        JoinStrategy const& join_strategy,
+        EndStrategy const& end_strategy,
+        PointStrategy const& point_strategy,
+        IntersectionStrategy const& intersection_strategy,
+        RobustPolicy const& robust_policy)
+{
+    detail::buffer::visit_pieces_default_policy visitor;
+    buffer_inserter<GeometryOutput>(geometry_input, out,
+        distance_strategy, side_strategy, join_strategy,
+        end_strategy, point_strategy,
+        intersection_strategy, robust_policy, visitor);
+}
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace detail::buffer
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_BUFFER_INSERTER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/buffer_policies.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/buffer_policies.hpp
new file mode 100644
index 00000000000..92dcdcc7b04
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/buffer_policies.hpp
@@ -0,0 +1,241 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012-2014 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017, Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_BUFFER_POLICIES_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_BUFFER_POLICIES_HPP
+
+#if ! defined(BOOST_GEOMETRY_NO_ROBUSTNESS)
+#  define BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION
+#endif
+
+#include <cstddef>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/algorithms/covered_by.hpp>
+#include <boost/geometry/algorithms/detail/overlay/backtrack_check_si.hpp>
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+
+#include <boost/geometry/strategies/buffer.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace buffer
+{
+
+
+enum intersection_location_type
+{
+    location_ok, inside_buffer, location_discard
+};
+
+class backtrack_for_buffer
+{
+public :
+    typedef detail::overlay::backtrack_state state_type;
+
+    template
+        <
+            typename Operation,
+            typename Rings,
+            typename Turns,
+            typename Geometry,
+            typename Strategy,
+            typename RobustPolicy,
+            typename Visitor
+        >
+    static inline void apply(std::size_t size_at_start,
+                Rings& rings, typename boost::range_value<Rings>::type& ring,
+                Turns& turns,
+                typename boost::range_value<Turns>::type const& /*turn*/,
+                Operation& operation,
+                detail::overlay::traverse_error_type /*traverse_error*/,
+                Geometry const& ,
+                Geometry const& ,
+                Strategy const& ,
+                RobustPolicy const& ,
+                state_type& state,
+                Visitor& /*visitor*/
+                )
+    {
+#if defined(BOOST_GEOMETRY_COUNT_BACKTRACK_WARNINGS)
+extern int g_backtrack_warning_count;
+g_backtrack_warning_count++;
+#endif
+//std::cout << "!";
+//std::cout << "WARNING " << traverse_error_string(traverse_error) << std::endl;
+
+        state.m_good = false;
+
+        // Make bad output clean
+        rings.resize(size_at_start);
+        ring.clear();
+
+        // Reject this as a starting point
+        operation.visited.set_rejected();
+
+        // And clear all visit info
+        clear_visit_info(turns);
+    }
+};
+
+struct buffer_overlay_visitor
+{
+public :
+    void print(char const* /*header*/)
+    {
+    }
+
+    template <typename Turns>
+    void print(char const* /*header*/, Turns const& /*turns*/, int /*turn_index*/)
+    {
+    }
+
+    template <typename Turns>
+    void print(char const* /*header*/, Turns const& /*turns*/, int /*turn_index*/, int /*op_index*/)
+    {
+    }
+
+    template <typename Turns>
+    void visit_turns(int , Turns const& ) {}
+
+    template <typename Clusters, typename Turns>
+    void visit_clusters(Clusters const& , Turns const& ) {}
+
+    template <typename Turns, typename Turn, typename Operation>
+    void visit_traverse(Turns const& /*turns*/, Turn const& /*turn*/, Operation const& /*op*/, const char* /*header*/)
+    {
+    }
+
+    template <typename Turns, typename Turn, typename Operation>
+    void visit_traverse_reject(Turns const& , Turn const& , Operation const& ,
+            detail::overlay::traverse_error_type )
+    {}
+};
+
+
+// Should follow traversal-turn-concept (enrichment, visit structure)
+// and adds index in piece vector to find it back
+template <typename Point, typename SegmentRatio>
+struct buffer_turn_operation
+    : public detail::overlay::traversal_turn_operation<Point, SegmentRatio>
+{
+    signed_size_type piece_index;
+    signed_size_type index_in_robust_ring;
+
+    inline buffer_turn_operation()
+        : piece_index(-1)
+        , index_in_robust_ring(-1)
+    {}
+};
+
+// Version for buffer including type of location, is_opposite, and helper variables
+template <typename Point, typename RobustPoint, typename SegmentRatio>
+struct buffer_turn_info
+    : public detail::overlay::turn_info
+        <
+            Point,
+            SegmentRatio,
+            buffer_turn_operation<Point, SegmentRatio>
+        >
+{
+    typedef Point point_type;
+    typedef RobustPoint robust_point_type;
+
+    std::size_t turn_index; // TODO: this might go if partition can operate on non-const input
+
+    RobustPoint robust_point;
+#if defined(BOOST_GEOMETRY_BUFFER_ENLARGED_CLUSTERS)
+    // Will (most probably) be removed later
+    RobustPoint mapped_robust_point; // alas... we still need to adapt our points, offsetting them 1 integer to be co-located with neighbours
+#endif
+
+
+    inline RobustPoint const& get_robust_point() const
+    {
+#if defined(BOOST_GEOMETRY_BUFFER_ENLARGED_CLUSTERS)
+        return mapped_robust_point;
+#endif
+        return robust_point;
+    }
+
+    intersection_location_type location;
+
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+    robust_point_type rob_pi, rob_pj, rob_qi, rob_qj;
+#endif
+
+    std::size_t count_within;
+
+    bool within_original;
+    std::size_t count_on_original_boundary;
+    signed_size_type count_in_original; // increased by +1 for in ext.ring, -1 for int.ring
+
+    std::size_t count_on_offsetted;
+    std::size_t count_on_helper;
+#if ! defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+    std::size_t count_within_near_offsetted;
+#endif
+
+    bool remove_on_multi;
+
+    // Obsolete:
+    std::size_t count_on_occupied;
+    std::size_t count_on_multi;
+
+    inline buffer_turn_info()
+        : turn_index(0)
+        , location(location_ok)
+        , count_within(0)
+        , within_original(false)
+        , count_on_original_boundary(0)
+        , count_in_original(0)
+        , count_on_offsetted(0)
+        , count_on_helper(0)
+#if ! defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+        , count_within_near_offsetted(0)
+#endif
+        , remove_on_multi(false)
+        , count_on_occupied(0)
+        , count_on_multi(0)
+    {}
+};
+
+struct buffer_operation_less
+{
+    template <typename Turn>
+    inline bool operator()(Turn const& left, Turn const& right) const
+    {
+        segment_identifier const& sl = left.seg_id;
+        segment_identifier const& sr = right.seg_id;
+
+        // Sort them descending
+        return sl == sr
+            ? left.fraction < right.fraction
+            : sl < sr;
+    }
+};
+
+}} // namespace detail::buffer
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_BUFFER_POLICIES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/buffered_piece_collection.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/buffered_piece_collection.hpp
new file mode 100644
index 00000000000..c0d906fe627
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/buffered_piece_collection.hpp
@@ -0,0 +1,1458 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012-2014 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2016-2017.
+// Modifications copyright (c) 2016-2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_BUFFERED_PIECE_COLLECTION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_BUFFERED_PIECE_COLLECTION_HPP
+
+#include <algorithm>
+#include <cstddef>
+#include <set>
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/algorithms/comparable_distance.hpp>
+#include <boost/geometry/algorithms/covered_by.hpp>
+#include <boost/geometry/algorithms/envelope.hpp>
+#include <boost/geometry/algorithms/is_convex.hpp>
+
+#include <boost/geometry/strategies/buffer.hpp>
+
+#include <boost/geometry/geometries/ring.hpp>
+
+#include <boost/geometry/algorithms/detail/buffer/buffered_ring.hpp>
+#include <boost/geometry/algorithms/detail/buffer/buffer_policies.hpp>
+#include <boost/geometry/algorithms/detail/overlay/cluster_info.hpp>
+#include <boost/geometry/algorithms/detail/buffer/get_piece_turns.hpp>
+#include <boost/geometry/algorithms/detail/buffer/turn_in_piece_visitor.hpp>
+#include <boost/geometry/algorithms/detail/buffer/turn_in_original_visitor.hpp>
+
+#include <boost/geometry/algorithms/detail/disjoint/point_box.hpp>
+#include <boost/geometry/algorithms/detail/overlay/add_rings.hpp>
+#include <boost/geometry/algorithms/detail/overlay/assign_parents.hpp>
+#include <boost/geometry/algorithms/detail/overlay/enrichment_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/enrich_intersection_points.hpp>
+#include <boost/geometry/algorithms/detail/overlay/ring_properties.hpp>
+#include <boost/geometry/algorithms/detail/overlay/traversal_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/traverse.hpp>
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+#include <boost/geometry/algorithms/detail/occupation_info.hpp>
+#include <boost/geometry/algorithms/detail/partition.hpp>
+#include <boost/geometry/algorithms/detail/sections/sectionalize.hpp>
+#include <boost/geometry/algorithms/detail/sections/section_box_policies.hpp>
+
+#include <boost/geometry/util/range.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace buffer
+{
+
+enum segment_relation_code
+{
+    segment_relation_on_left,
+    segment_relation_on_right,
+    segment_relation_within,
+    segment_relation_disjoint
+};
+
+/*
+ *  Terminology
+ *
+ *  Suppose we make a buffer (using blocked corners) of this rectangle:
+ *
+ *         +-------+
+ *         |       |
+ *         |  rect |
+ *         |       |
+ *         +-------+
+ *
+ * For the sides we get these four buffered side-pieces (marked with s)
+ * and four buffered corner pieces (marked with c)
+ *
+ *     c---+---s---+---c
+ *     |   | piece |   |     <- see below for details of the middle top-side-piece
+ *     +---+-------+---+
+ *     |   |       |   |
+ *     s   |  rect |   s     <- two side pieces left/right of rect
+ *     |   |       |   |
+ *     +---+-------+---+
+ *     |   | piece |   |     <- one side-piece below, and two corner pieces
+ *     c---+---s---+---c
+ *
+ *  The outer part of the picture above, using all pieces,
+ *    form together the offsetted ring (marked with o below)
+ *  The 8 pieces are part of the piece collection and use for inside-checks
+ *  The inner parts form (using 1 or 2 points per piece, often co-located)
+ *    form together the robust_polygons (marked with r below)
+ *  The remaining piece-segments are helper-segments (marked with h)
+ *
+ *     ooooooooooooooooo
+ *     o   h       h   o
+ *     ohhhrrrrrrrrrhhho
+ *     o   r       r   o
+ *     o   r       r   o
+ *     o   r       r   o
+ *     ohhhrrrrrrrrrhhho
+ *     o   h       h   o
+ *     ooooooooooooooooo
+ *
+ */
+
+
+template <typename Ring, typename IntersectionStrategy, typename RobustPolicy>
+struct buffered_piece_collection
+{
+    typedef buffered_piece_collection
+        <
+            Ring, IntersectionStrategy, RobustPolicy
+        > this_type;
+
+    typedef typename geometry::point_type<Ring>::type point_type;
+    typedef typename geometry::coordinate_type<Ring>::type coordinate_type;
+    typedef typename geometry::robust_point_type
+    <
+        point_type,
+        RobustPolicy
+    >::type robust_point_type;
+
+    // Robust ring/polygon type, always clockwise
+    typedef geometry::model::ring<robust_point_type> robust_ring_type;
+    typedef geometry::model::box<robust_point_type> robust_box_type;
+
+    typedef typename default_comparable_distance_result
+        <
+            robust_point_type
+        >::type robust_comparable_radius_type;
+
+    typedef typename IntersectionStrategy::side_strategy_type side_strategy_type;
+
+    typedef typename IntersectionStrategy::template area_strategy
+        <
+            point_type
+        >::type area_strategy_type;
+
+    typedef typename IntersectionStrategy::template area_strategy
+        <
+            robust_point_type
+        >::type robust_area_strategy_type;
+
+    typedef typename area_strategy_type::return_type area_result_type;
+    typedef typename robust_area_strategy_type::return_type robust_area_result_type;
+
+    typedef typename geometry::rescale_policy_type
+        <
+            typename geometry::point_type<Ring>::type
+        >::type rescale_policy_type;
+
+    typedef typename geometry::segment_ratio_type
+    <
+        point_type,
+        RobustPolicy
+    >::type segment_ratio_type;
+
+    typedef buffer_turn_info
+    <
+        point_type,
+        robust_point_type,
+        segment_ratio_type
+    > buffer_turn_info_type;
+
+    typedef buffer_turn_operation
+    <
+        point_type,
+        segment_ratio_type
+    > buffer_turn_operation_type;
+
+    typedef std::vector<buffer_turn_info_type> turn_vector_type;
+
+    struct robust_turn
+    {
+        std::size_t turn_index;
+        int operation_index;
+        robust_point_type point;
+        segment_identifier seg_id;
+        segment_ratio_type fraction;
+    };
+
+    struct piece
+    {
+        typedef robust_ring_type piece_robust_ring_type;
+        typedef geometry::section<robust_box_type, 1> section_type;
+
+        strategy::buffer::piece_type type;
+        signed_size_type index;
+
+        signed_size_type left_index; // points to previous piece of same ring
+        signed_size_type right_index; // points to next piece of same ring
+
+        // The next two members (1, 2) form together a complete clockwise ring
+        // for each piece (with one dupped point)
+        // The complete clockwise ring is also included as a robust ring (3)
+
+        // 1: half, part of offsetted_rings
+        segment_identifier first_seg_id;
+        signed_size_type last_segment_index; // no segment-identifier - it is the same as first_seg_id
+        signed_size_type offsetted_count; // part in robust_ring which is part of offsetted ring
+
+#if defined(BOOST_GEOMETRY_BUFFER_USE_HELPER_POINTS)
+        // 2: half, not part of offsetted rings - part of robust ring
+        std::vector<point_type> helper_points; // 4 points for side, 3 points for join - 0 points for flat-end
+#endif
+
+        bool is_convex;
+        bool is_monotonic_increasing[2]; // 0=x, 1=y
+        bool is_monotonic_decreasing[2]; // 0=x, 1=y
+
+        // Monotonic sections of pieces around points
+        std::vector<section_type> sections;
+
+        // Robust representations
+        // 3: complete ring
+        robust_ring_type robust_ring;
+
+        robust_box_type robust_envelope;
+        robust_box_type robust_offsetted_envelope;
+
+        std::vector<robust_turn> robust_turns; // Used only in insert_rescaled_piece_turns - we might use a map instead
+
+        robust_point_type robust_center;
+        robust_comparable_radius_type robust_min_comparable_radius;
+        robust_comparable_radius_type robust_max_comparable_radius;
+
+        piece()
+            : type(strategy::buffer::piece_type_unknown)
+            , index(-1)
+            , left_index(-1)
+            , right_index(-1)
+            , last_segment_index(-1)
+            , offsetted_count(-1)
+            , is_convex(false)
+            , robust_min_comparable_radius(0)
+            , robust_max_comparable_radius(0)
+        {
+            is_monotonic_increasing[0] = false;
+            is_monotonic_increasing[1] = false;
+            is_monotonic_decreasing[0] = false;
+            is_monotonic_decreasing[1] = false;
+        }
+    };
+
+    struct robust_original
+    {
+        typedef robust_ring_type original_robust_ring_type;
+        typedef geometry::sections<robust_box_type, 1> sections_type;
+
+        inline robust_original()
+            : m_is_interior(false)
+            , m_has_interiors(true)
+        {}
+
+        inline robust_original(robust_ring_type const& ring,
+                bool is_interior, bool has_interiors)
+            : m_ring(ring)
+            , m_is_interior(is_interior)
+            , m_has_interiors(has_interiors)
+        {
+            geometry::envelope(m_ring, m_box);
+
+            // create monotonic sections in x-dimension
+            // The dimension is critical because the direction is later used
+            // in the optimization for within checks using winding strategy
+            // and this strategy is scanning in x direction.
+            typedef boost::mpl::vector_c<std::size_t, 0> dimensions;
+            geometry::sectionalize<false, dimensions>(m_ring,
+                    detail::no_rescale_policy(), m_sections);
+        }
+
+        robust_ring_type m_ring;
+        robust_box_type m_box;
+        sections_type m_sections;
+
+        bool m_is_interior;
+        bool m_has_interiors;
+    };
+
+    typedef std::vector<piece> piece_vector_type;
+
+    piece_vector_type m_pieces;
+    turn_vector_type m_turns;
+    signed_size_type m_first_piece_index;
+
+    buffered_ring_collection<buffered_ring<Ring> > offsetted_rings; // indexed by multi_index
+    std::vector<robust_original> robust_originals; // robust representation of the original(s)
+    robust_ring_type current_robust_ring;
+    buffered_ring_collection<Ring> traversed_rings;
+    segment_identifier current_segment_id;
+
+    // Specificly for offsetted rings around points
+    // but also for large joins with many points
+    typedef geometry::sections<robust_box_type, 2> sections_type;
+    sections_type monotonic_sections;
+
+    // Define the clusters, mapping cluster_id -> turns
+    typedef std::map
+        <
+            signed_size_type,
+            detail::overlay::cluster_info
+        > cluster_type;
+
+    cluster_type m_clusters;
+
+    IntersectionStrategy m_intersection_strategy;
+    side_strategy_type m_side_strategy;
+    area_strategy_type m_area_strategy;
+    robust_area_strategy_type m_robust_area_strategy;
+    RobustPolicy const& m_robust_policy;
+
+    struct redundant_turn
+    {
+        inline bool operator()(buffer_turn_info_type const& turn) const
+        {
+            return turn.remove_on_multi;
+        }
+    };
+
+    buffered_piece_collection(IntersectionStrategy const& intersection_strategy,
+                              RobustPolicy const& robust_policy)
+        : m_first_piece_index(-1)
+        , m_intersection_strategy(intersection_strategy)
+        , m_side_strategy(intersection_strategy.get_side_strategy())
+        , m_area_strategy(intersection_strategy.template get_area_strategy<point_type>())
+        , m_robust_area_strategy(intersection_strategy.template get_area_strategy<robust_point_type>())
+        , m_robust_policy(robust_policy)
+    {}
+
+
+#if defined(BOOST_GEOMETRY_BUFFER_ENLARGED_CLUSTERS)
+    // Will (most probably) be removed later
+    template <typename OccupationMap>
+    inline void adapt_mapped_robust_point(OccupationMap const& map,
+            buffer_turn_info_type& turn, int distance) const
+    {
+        for (int x = -distance; x <= distance; x++)
+        {
+            for (int y = -distance; y <= distance; y++)
+            {
+                robust_point_type rp = turn.robust_point;
+                geometry::set<0>(rp, geometry::get<0>(rp) + x);
+                geometry::set<1>(rp, geometry::get<1>(rp) + y);
+                if (map.find(rp) != map.end())
+                {
+                    turn.mapped_robust_point = rp;
+                    return;
+                }
+            }
+        }
+    }
+#endif
+
+    inline void get_occupation(
+#if defined(BOOST_GEOMETRY_BUFFER_ENLARGED_CLUSTERS)
+        int distance = 0
+#endif
+    )
+    {
+        typedef occupation_info<angle_info<robust_point_type, coordinate_type> >
+                buffer_occupation_info;
+
+        typedef std::map
+        <
+            robust_point_type,
+            buffer_occupation_info,
+            geometry::less<robust_point_type>
+        > occupation_map_type;
+
+        occupation_map_type occupation_map;
+
+        // 1: Add all intersection points to occupation map
+        typedef typename boost::range_iterator<turn_vector_type>::type
+            iterator_type;
+
+        for (iterator_type it = boost::begin(m_turns);
+            it != boost::end(m_turns);
+            ++it)
+        {
+            if (it->location == location_ok)
+            {
+#if defined(BOOST_GEOMETRY_BUFFER_ENLARGED_CLUSTERS)
+                if (distance > 0 && ! occupation_map.empty())
+                {
+                    adapt_mapped_robust_point(occupation_map, *it, distance);
+                }
+#endif
+                occupation_map[it->get_robust_point()].count++;
+            }
+        }
+
+        // Remove all points with one or more u/u points from the map
+        // (Alternatively, we could NOT do this here and change all u/u
+        // behaviour in overlay. Currently nothing is done: each polygon is
+        // just followed there. We could also always switch polygons there. For
+        // buffer behaviour, where 3 pieces might meet of which 2 (or more) form
+        // a u/u turn, this last option would have been better, probably).
+        for (iterator_type it = boost::begin(m_turns);
+            it != boost::end(m_turns);
+            ++it)
+        {
+            if (it->both(detail::overlay::operation_union))
+            {
+                typename occupation_map_type::iterator mit =
+                            occupation_map.find(it->get_robust_point());
+
+                if (mit != occupation_map.end())
+                {
+                    occupation_map.erase(mit);
+                }
+            }
+        }
+
+        // 2: Remove all points from map which has only one
+        typename occupation_map_type::iterator it = occupation_map.begin();
+        while (it != occupation_map.end())
+        {
+            if (it->second.count <= 1)
+            {
+                typename occupation_map_type::iterator to_erase = it;
+                ++it;
+                occupation_map.erase(to_erase);
+            }
+            else
+            {
+                ++it;
+            }
+        }
+
+        if (occupation_map.empty())
+        {
+            return;
+        }
+
+        // 3: Add vectors (incoming->intersection-point,
+        //                 intersection-point -> outgoing)
+        //    for all (co-located) points still present in the map
+
+        for (iterator_type it = boost::begin(m_turns);
+            it != boost::end(m_turns);
+            ++it)
+        {
+            typename occupation_map_type::iterator mit =
+                        occupation_map.find(it->get_robust_point());
+
+            if (mit != occupation_map.end())
+            {
+                buffer_occupation_info& info = mit->second;
+                for (int i = 0; i < 2; i++)
+                {
+                    add_incoming_and_outgoing_angles(it->get_robust_point(), *it,
+                                m_pieces,
+                                i, it->operations[i].seg_id,
+                                info);
+                }
+
+                it->count_on_multi++;
+            }
+        }
+
+#if defined(BOOST_GEOMETRY_BUFFER_ENLARGED_CLUSTERS)
+        // X: Check rounding issues
+        if (distance == 0)
+        {
+            for (typename occupation_map_type::const_iterator it = occupation_map.begin();
+                it != occupation_map.end(); ++it)
+            {
+                if (it->second.has_rounding_issues(it->first))
+                {
+                    if(distance == 0)
+                    {
+                        get_occupation(distance + 1);
+                        return;
+                    }
+                }
+            }
+        }
+#endif
+
+        // Get left turns from all clusters
+        for (typename occupation_map_type::iterator it = occupation_map.begin();
+            it != occupation_map.end(); ++it)
+        {
+            it->second.get_left_turns(it->first, m_turns, m_side_strategy);
+        }
+    }
+
+    inline void classify_turns(bool linear)
+    {
+        for (typename boost::range_iterator<turn_vector_type>::type it =
+            boost::begin(m_turns); it != boost::end(m_turns); ++it)
+        {
+            if (it->count_within > 0)
+            {
+                it->location = inside_buffer;
+            }
+            if (it->count_on_original_boundary > 0 && ! linear)
+            {
+                it->location = inside_buffer;
+            }
+#if ! defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+            if (it->count_within_near_offsetted > 0)
+            {
+                // Within can have in rare cases a rounding issue. We don't discard this
+                // point, so it can be used to continue started rings in traversal. But
+                // will never start a new ring from this type of points.
+                it->operations[0].enriched.startable = false;
+                it->operations[1].enriched.startable = false;
+            }
+#endif
+        }
+    }
+
+    template <typename DistanceStrategy>
+    inline void check_remaining_points(DistanceStrategy const& distance_strategy)
+    {
+        // Check if a turn is inside any of the originals
+
+        turn_in_original_visitor<turn_vector_type> visitor(m_turns);
+        geometry::partition
+            <
+                robust_box_type,
+                include_turn_policy,
+                detail::partition::include_all_policy
+            >::apply(m_turns, robust_originals, visitor,
+                     turn_get_box(), turn_in_original_ovelaps_box(),
+                     original_get_box(), original_ovelaps_box());
+
+        bool const deflate = distance_strategy.negative();
+
+        for (typename boost::range_iterator<turn_vector_type>::type it =
+            boost::begin(m_turns); it != boost::end(m_turns); ++it)
+        {
+            buffer_turn_info_type& turn = *it;
+            if (turn.location == location_ok)
+            {
+                if (deflate && turn.count_in_original <= 0)
+                {
+                    // For deflate: it is not in original, discard
+                    turn.location = location_discard;
+                }
+                else if (! deflate && turn.count_in_original > 0)
+                {
+                    // For inflate: it is in original, discard
+                    turn.location = location_discard;
+                }
+            }
+        }
+    }
+
+    inline bool assert_indices_in_robust_rings() const
+    {
+        geometry::equal_to<robust_point_type> comparator;
+        for (typename boost::range_iterator<turn_vector_type const>::type it =
+            boost::begin(m_turns); it != boost::end(m_turns); ++it)
+        {
+            for (int i = 0; i < 2; i++)
+            {
+                robust_point_type const &p1
+                    = m_pieces[it->operations[i].piece_index].robust_ring
+                              [it->operations[i].index_in_robust_ring];
+                robust_point_type const &p2 = it->robust_point;
+                if (! comparator(p1, p2))
+                {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    inline void insert_rescaled_piece_turns()
+    {
+        // Add rescaled turn points to corresponding pieces
+        // (after this, each turn occurs twice)
+        std::size_t index = 0;
+        for (typename boost::range_iterator<turn_vector_type>::type it =
+            boost::begin(m_turns); it != boost::end(m_turns); ++it, ++index)
+        {
+            geometry::recalculate(it->robust_point, it->point, m_robust_policy);
+#if defined(BOOST_GEOMETRY_BUFFER_ENLARGED_CLUSTERS)
+            it->mapped_robust_point = it->robust_point;
+#endif
+
+            robust_turn turn;
+            it->turn_index = index;
+            turn.turn_index = index;
+            turn.point = it->robust_point;
+            for (int i = 0; i < 2; i++)
+            {
+                turn.operation_index = i;
+                turn.seg_id = it->operations[i].seg_id;
+                turn.fraction = it->operations[i].fraction;
+
+                piece& pc = m_pieces[it->operations[i].piece_index];
+                pc.robust_turns.push_back(turn);
+
+                // Take into account for the box (intersection points should fall inside,
+                // but in theory they can be one off because of rounding
+                geometry::expand(pc.robust_envelope, it->robust_point);
+                geometry::expand(pc.robust_offsetted_envelope, it->robust_point);
+            }
+        }
+
+#if ! defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+        // Insert all rescaled turn-points into these rings, to form a
+        // reliable integer-based ring. All turns can be compared (inside) to this
+        // rings to see if they are inside.
+
+        for (typename boost::range_iterator<piece_vector_type>::type
+                it = boost::begin(m_pieces); it != boost::end(m_pieces); ++it)
+        {
+            piece& pc = *it;
+            signed_size_type piece_segment_index = pc.first_seg_id.segment_index;
+            if (! pc.robust_turns.empty())
+            {
+                if (pc.robust_turns.size() > 1u)
+                {
+                    std::sort(pc.robust_turns.begin(), pc.robust_turns.end(), buffer_operation_less());
+                }
+                // Walk through them, in reverse to insert at right index
+                signed_size_type index_offset = static_cast<signed_size_type>(pc.robust_turns.size()) - 1;
+                for (typename boost::range_reverse_iterator<const std::vector<robust_turn> >::type
+                        rit = boost::const_rbegin(pc.robust_turns);
+                    rit != boost::const_rend(pc.robust_turns);
+                    ++rit, --index_offset)
+                {
+                    signed_size_type const index_in_vector = 1 + rit->seg_id.segment_index - piece_segment_index;
+                    BOOST_GEOMETRY_ASSERT
+                    (
+                        index_in_vector > 0
+                        && index_in_vector < pc.offsetted_count
+                    );
+
+                    pc.robust_ring.insert(boost::begin(pc.robust_ring) + index_in_vector, rit->point);
+                    pc.offsetted_count++;
+
+                    m_turns[rit->turn_index].operations[rit->operation_index].index_in_robust_ring = index_in_vector + index_offset;
+                }
+            }
+        }
+
+        BOOST_GEOMETRY_ASSERT(assert_indices_in_robust_rings());
+#endif
+    }
+
+    template <std::size_t Dimension>
+    static inline void determine_monotonicity(piece& pc,
+            robust_point_type const& current,
+            robust_point_type const& next)
+    {
+        if (geometry::get<Dimension>(current) >= geometry::get<Dimension>(next))
+        {
+            pc.is_monotonic_increasing[Dimension] = false;
+        }
+        if (geometry::get<Dimension>(current) <= geometry::get<Dimension>(next))
+        {
+            pc.is_monotonic_decreasing[Dimension] = false;
+        }
+    }
+
+    static inline void determine_properties(piece& pc)
+    {
+        pc.is_monotonic_increasing[0] = true;
+        pc.is_monotonic_increasing[1] = true;
+        pc.is_monotonic_decreasing[0] = true;
+        pc.is_monotonic_decreasing[1] = true;
+
+        pc.is_convex = geometry::is_convex(pc.robust_ring);
+
+        if (pc.offsetted_count < 2)
+        {
+            return;
+        }
+
+        typename robust_ring_type::const_iterator current = pc.robust_ring.begin();
+        typename robust_ring_type::const_iterator next = current + 1;
+
+        for (signed_size_type i = 1; i < pc.offsetted_count; i++)
+        {
+            determine_monotonicity<0>(pc, *current, *next);
+            determine_monotonicity<1>(pc, *current, *next);
+            current = next;
+            ++next;
+        }
+    }
+
+    void determine_properties()
+    {
+        for (typename piece_vector_type::iterator it = boost::begin(m_pieces);
+            it != boost::end(m_pieces);
+            ++it)
+        {
+            determine_properties(*it);
+        }
+    }
+
+    inline void reverse_negative_robust_rings()
+    {
+        for (typename piece_vector_type::iterator it = boost::begin(m_pieces);
+            it != boost::end(m_pieces);
+            ++it)
+        {
+            piece& pc = *it;
+            if (geometry::area(pc.robust_ring, m_robust_area_strategy) < 0)
+            {
+                // Rings can be ccw:
+                // - in a concave piece
+                // - in a line-buffer with a negative buffer-distance
+                std::reverse(pc.robust_ring.begin(), pc.robust_ring.end());
+            }
+        }
+    }
+
+    inline void prepare_buffered_point_piece(piece& pc)
+    {
+        // create monotonic sections in y-dimension
+        typedef boost::mpl::vector_c<std::size_t, 1> dimensions;
+        geometry::sectionalize<false, dimensions>(pc.robust_ring,
+                detail::no_rescale_policy(), pc.sections);
+
+        // Determine min/max radius
+        typedef geometry::model::referring_segment<robust_point_type const>
+            robust_segment_type;
+
+        typename robust_ring_type::const_iterator current = pc.robust_ring.begin();
+        typename robust_ring_type::const_iterator next = current + 1;
+
+        for (signed_size_type i = 1; i < pc.offsetted_count; i++)
+        {
+            robust_segment_type s(*current, *next);
+            robust_comparable_radius_type const d
+                = geometry::comparable_distance(pc.robust_center, s);
+
+            if (i == 1 || d < pc.robust_min_comparable_radius)
+            {
+                pc.robust_min_comparable_radius = d;
+            }
+            if (i == 1 || d > pc.robust_max_comparable_radius)
+            {
+                pc.robust_max_comparable_radius = d;
+            }
+
+            current = next;
+            ++next;
+        }
+    }
+
+    inline void prepare_buffered_point_pieces()
+    {
+        for (typename piece_vector_type::iterator it = boost::begin(m_pieces);
+            it != boost::end(m_pieces);
+            ++it)
+        {
+            if (it->type == geometry::strategy::buffer::buffered_point)
+            {
+                prepare_buffered_point_piece(*it);
+            }
+        }
+    }
+
+    inline void get_turns()
+    {
+        for(typename boost::range_iterator<sections_type>::type it
+                = boost::begin(monotonic_sections);
+            it != boost::end(monotonic_sections);
+            ++it)
+        {
+            enlarge_box(it->bounding_box, 1);
+        }
+
+        {
+            // Calculate the turns
+            piece_turn_visitor
+                <
+                    piece_vector_type,
+                    buffered_ring_collection<buffered_ring<Ring> >,
+                    turn_vector_type,
+                    IntersectionStrategy,
+                    RobustPolicy
+                > visitor(m_pieces, offsetted_rings, m_turns,
+                          m_intersection_strategy, m_robust_policy);
+
+            geometry::partition
+                <
+                    robust_box_type
+                >::apply(monotonic_sections, visitor,
+                         detail::section::get_section_box(),
+                         detail::section::overlaps_section_box());
+        }
+
+        insert_rescaled_piece_turns();
+
+        reverse_negative_robust_rings();
+
+        determine_properties();
+
+        prepare_buffered_point_pieces();
+
+        {
+            // Check if it is inside any of the pieces
+            turn_in_piece_visitor
+                <
+                    turn_vector_type, piece_vector_type
+                > visitor(m_turns, m_pieces);
+
+            geometry::partition
+                <
+                    robust_box_type
+                >::apply(m_turns, m_pieces, visitor,
+                         turn_get_box(), turn_ovelaps_box(),
+                         piece_get_box(), piece_ovelaps_box());
+
+        }
+    }
+
+    inline void start_new_ring()
+    {
+        signed_size_type const n = static_cast<signed_size_type>(offsetted_rings.size());
+        current_segment_id.source_index = 0;
+        current_segment_id.multi_index = n;
+        current_segment_id.ring_index = -1;
+        current_segment_id.segment_index = 0;
+
+        offsetted_rings.resize(n + 1);
+        current_robust_ring.clear();
+
+        m_first_piece_index = static_cast<signed_size_type>(boost::size(m_pieces));
+    }
+
+    inline void abort_ring()
+    {
+        // Remove all created pieces for this ring, sections, last offsetted
+        while (! m_pieces.empty()
+               && m_pieces.back().first_seg_id.multi_index
+               == current_segment_id.multi_index)
+        {
+            m_pieces.erase(m_pieces.end() - 1);
+        }
+
+        while (! monotonic_sections.empty()
+               && monotonic_sections.back().ring_id.multi_index
+               == current_segment_id.multi_index)
+        {
+            monotonic_sections.erase(monotonic_sections.end() - 1);
+        }
+
+        offsetted_rings.erase(offsetted_rings.end() - 1);
+        current_robust_ring.clear();
+
+        m_first_piece_index = -1;
+    }
+
+    inline void update_closing_point()
+    {
+        BOOST_GEOMETRY_ASSERT(! offsetted_rings.empty());
+        buffered_ring<Ring>& added = offsetted_rings.back();
+        if (! boost::empty(added))
+        {
+            range::back(added) = range::front(added);
+        }
+    }
+
+    inline void update_last_point(point_type const& p,
+            buffered_ring<Ring>& ring)
+    {
+        // For the first point of a new piece, and there were already
+        // points in the offsetted ring, for some piece types the first point
+        // is a duplicate of the last point of the previous piece.
+
+        // TODO: disable that, that point should not be added
+
+        // For now, it is made equal because due to numerical instability,
+        // it can be a tiny bit off, possibly causing a self-intersection
+
+        BOOST_GEOMETRY_ASSERT(boost::size(m_pieces) > 0);
+        if (! ring.empty()
+            && current_segment_id.segment_index
+                == m_pieces.back().first_seg_id.segment_index)
+        {
+            ring.back() = p;
+        }
+    }
+
+    inline void set_piece_center(point_type const& center)
+    {
+        BOOST_GEOMETRY_ASSERT(! m_pieces.empty());
+        geometry::recalculate(m_pieces.back().robust_center, center,
+                m_robust_policy);
+    }
+
+    inline void finish_ring(strategy::buffer::result_code code,
+                            bool is_interior = false, bool has_interiors = false)
+    {
+        if (code == strategy::buffer::result_error_numerical)
+        {
+            abort_ring();
+            return;
+        }
+
+        if (m_first_piece_index == -1)
+        {
+            return;
+        }
+
+        if (m_first_piece_index < static_cast<signed_size_type>(boost::size(m_pieces)))
+        {
+            // If piece was added
+            // Reassign left-of-first and right-of-last
+            geometry::range::at(m_pieces, m_first_piece_index).left_index
+                    = static_cast<signed_size_type>(boost::size(m_pieces)) - 1;
+            geometry::range::back(m_pieces).right_index = m_first_piece_index;
+        }
+        m_first_piece_index = -1;
+
+        update_closing_point();
+
+        if (! current_robust_ring.empty())
+        {
+            BOOST_GEOMETRY_ASSERT
+            (
+                geometry::equals(current_robust_ring.front(),
+                    current_robust_ring.back())
+            );
+
+            robust_originals.push_back(
+                robust_original(current_robust_ring,
+                    is_interior, has_interiors));
+        }
+    }
+
+    inline void set_current_ring_concave()
+    {
+        BOOST_GEOMETRY_ASSERT(boost::size(offsetted_rings) > 0);
+        offsetted_rings.back().has_concave = true;
+    }
+
+    inline signed_size_type add_point(point_type const& p)
+    {
+        BOOST_GEOMETRY_ASSERT(boost::size(offsetted_rings) > 0);
+
+        buffered_ring<Ring>& current_ring = offsetted_rings.back();
+        update_last_point(p, current_ring);
+
+        current_segment_id.segment_index++;
+        current_ring.push_back(p);
+        return static_cast<signed_size_type>(current_ring.size());
+    }
+
+    //-------------------------------------------------------------------------
+
+    inline piece& create_piece(strategy::buffer::piece_type type,
+            bool decrease_segment_index_by_one)
+    {
+        if (type == strategy::buffer::buffered_concave)
+        {
+            offsetted_rings.back().has_concave = true;
+        }
+
+        piece pc;
+        pc.type = type;
+        pc.index = static_cast<signed_size_type>(boost::size(m_pieces));
+
+        current_segment_id.piece_index = pc.index;
+
+        pc.first_seg_id = current_segment_id;
+
+
+        // Assign left/right (for first/last piece per ring they will be re-assigned later)
+        pc.left_index = pc.index - 1;
+        pc.right_index = pc.index + 1;
+
+        std::size_t const n = boost::size(offsetted_rings.back());
+        pc.first_seg_id.segment_index = decrease_segment_index_by_one ? n - 1 : n;
+        pc.last_segment_index = pc.first_seg_id.segment_index;
+
+        m_pieces.push_back(pc);
+        return m_pieces.back();
+    }
+
+    inline void init_rescale_piece(piece& pc, std::size_t helper_points_size)
+    {
+        if (pc.first_seg_id.segment_index < 0)
+        {
+            // This indicates an error situation: an earlier piece was empty
+            // It currently does not happen
+            // std::cout << "EMPTY " << pc.type << " " << pc.index << " " << pc.first_seg_id.multi_index << std::endl;
+            pc.offsetted_count = 0;
+            return;
+        }
+
+        BOOST_GEOMETRY_ASSERT(pc.first_seg_id.multi_index >= 0);
+        BOOST_GEOMETRY_ASSERT(pc.last_segment_index >= 0);
+
+        pc.offsetted_count = pc.last_segment_index - pc.first_seg_id.segment_index;
+        BOOST_GEOMETRY_ASSERT(pc.offsetted_count >= 0);
+
+        pc.robust_ring.reserve(pc.offsetted_count + helper_points_size);
+
+        // Add rescaled offsetted segments
+        {
+            buffered_ring<Ring> const& ring = offsetted_rings[pc.first_seg_id.multi_index];
+
+            typedef typename boost::range_iterator<const buffered_ring<Ring> >::type it_type;
+            for (it_type it = boost::begin(ring) + pc.first_seg_id.segment_index;
+                it != boost::begin(ring) + pc.last_segment_index;
+                ++it)
+            {
+                robust_point_type point;
+                geometry::recalculate(point, *it, m_robust_policy);
+                pc.robust_ring.push_back(point);
+            }
+        }
+    }
+
+    inline robust_point_type add_helper_point(piece& pc, const point_type& point)
+    {
+#if defined(BOOST_GEOMETRY_BUFFER_USE_HELPER_POINTS)
+        pc.helper_points.push_back(point);
+#endif
+
+        robust_point_type rob_point;
+        geometry::recalculate(rob_point, point, m_robust_policy);
+        pc.robust_ring.push_back(rob_point);
+        return rob_point;
+    }
+
+    // TODO: this is shared with sectionalize, move to somewhere else (assign?)
+    template <typename Box, typename Value>
+    inline void enlarge_box(Box& box, Value value)
+    {
+        geometry::set<0, 0>(box, geometry::get<0, 0>(box) - value);
+        geometry::set<0, 1>(box, geometry::get<0, 1>(box) - value);
+        geometry::set<1, 0>(box, geometry::get<1, 0>(box) + value);
+        geometry::set<1, 1>(box, geometry::get<1, 1>(box) + value);
+    }
+
+    inline void calculate_robust_envelope(piece& pc)
+    {
+        if (pc.offsetted_count == 0)
+        {
+            return;
+        }
+
+        geometry::envelope(pc.robust_ring, pc.robust_envelope);
+
+        geometry::assign_inverse(pc.robust_offsetted_envelope);
+        for (signed_size_type i = 0; i < pc.offsetted_count; i++)
+        {
+            geometry::expand(pc.robust_offsetted_envelope, pc.robust_ring[i]);
+        }
+
+        // Take roundings into account, enlarge boxes with 1 integer
+        enlarge_box(pc.robust_envelope, 1);
+        enlarge_box(pc.robust_offsetted_envelope, 1);
+    }
+
+    inline void sectionalize(piece& pc)
+    {
+
+        buffered_ring<Ring> const& ring = offsetted_rings.back();
+
+        typedef geometry::detail::sectionalize::sectionalize_part
+        <
+            point_type,
+            boost::mpl::vector_c<std::size_t, 0, 1> // x,y dimension
+        > sectionalizer;
+
+        // Create a ring-identifier. The source-index is the piece index
+        // The multi_index is as in this collection (the ring), but not used here
+        // The ring_index is not used
+        ring_identifier ring_id(pc.index, pc.first_seg_id.multi_index, -1);
+
+        sectionalizer::apply(monotonic_sections,
+            boost::begin(ring) + pc.first_seg_id.segment_index,
+            boost::begin(ring) + pc.last_segment_index,
+            m_robust_policy,
+            ring_id, 10);
+    }
+
+    inline void finish_piece(piece& pc)
+    {
+        init_rescale_piece(pc, 0u);
+        calculate_robust_envelope(pc);
+        sectionalize(pc);
+    }
+
+    inline void finish_piece(piece& pc,
+                    const point_type& point1,
+                    const point_type& point2,
+                    const point_type& point3)
+    {
+        init_rescale_piece(pc, 3u);
+        if (pc.offsetted_count == 0)
+        {
+            return;
+        }
+
+        add_helper_point(pc, point1);
+        robust_point_type mid_point = add_helper_point(pc, point2);
+        add_helper_point(pc, point3);
+        calculate_robust_envelope(pc);
+        sectionalize(pc);
+
+        current_robust_ring.push_back(mid_point);
+    }
+
+    inline void finish_piece(piece& pc,
+                    const point_type& point1,
+                    const point_type& point2,
+                    const point_type& point3,
+                    const point_type& point4)
+    {
+        init_rescale_piece(pc, 4u);
+        add_helper_point(pc, point1);
+        robust_point_type mid_point2 = add_helper_point(pc, point2);
+        robust_point_type mid_point1 = add_helper_point(pc, point3);
+        add_helper_point(pc, point4);
+        sectionalize(pc);
+        calculate_robust_envelope(pc);
+
+        // Add mid-points in other order to current helper_ring
+        current_robust_ring.push_back(mid_point1);
+        current_robust_ring.push_back(mid_point2);
+    }
+
+    inline void add_piece(strategy::buffer::piece_type type, point_type const& p,
+            point_type const& b1, point_type const& b2)
+    {
+        piece& pc = create_piece(type, false);
+        add_point(b1);
+        pc.last_segment_index = add_point(b2);
+        finish_piece(pc, b2, p, b1);
+    }
+
+    template <typename Range>
+    inline void add_range_to_piece(piece& pc, Range const& range, bool add_front)
+    {
+        BOOST_GEOMETRY_ASSERT(boost::size(range) != 0u);
+
+        typename Range::const_iterator it = boost::begin(range);
+
+        // If it follows a non-join (so basically the same piece-type) point b1 should be added.
+        // There should be two intersections later and it should be discarded.
+        // But for now we need it to calculate intersections
+        if (add_front)
+        {
+            add_point(*it);
+        }
+
+        for (++it; it != boost::end(range); ++it)
+        {
+            pc.last_segment_index = add_point(*it);
+        }
+    }
+
+
+    template <typename Range>
+    inline void add_piece(strategy::buffer::piece_type type, Range const& range,
+            bool decrease_segment_index_by_one)
+    {
+        piece& pc = create_piece(type, decrease_segment_index_by_one);
+
+        if (boost::size(range) > 0u)
+        {
+            add_range_to_piece(pc, range, offsetted_rings.back().empty());
+        }
+        finish_piece(pc);
+    }
+
+    template <typename Range>
+    inline void add_side_piece(point_type const& p1, point_type const& p2,
+            Range const& range, bool first)
+    {
+        BOOST_GEOMETRY_ASSERT(boost::size(range) >= 2u);
+
+        piece& pc = create_piece(strategy::buffer::buffered_segment, ! first);
+        add_range_to_piece(pc, range, first);
+        finish_piece(pc, range.back(), p2, p1, range.front());
+    }
+
+    template <typename Range>
+    inline void add_piece(strategy::buffer::piece_type type,
+            point_type const& p, Range const& range)
+    {
+        piece& pc = create_piece(type, true);
+
+        if (boost::size(range) > 0u)
+        {
+            add_range_to_piece(pc, range, offsetted_rings.back().empty());
+            finish_piece(pc, range.back(), p, range.front());
+        }
+        else
+        {
+            finish_piece(pc);
+        }
+    }
+
+    template <typename EndcapStrategy, typename Range>
+    inline void add_endcap(EndcapStrategy const& strategy, Range const& range,
+            point_type const& end_point)
+    {
+        boost::ignore_unused(strategy);
+
+        if (range.empty())
+        {
+            return;
+        }
+        strategy::buffer::piece_type pt = strategy.get_piece_type();
+        if (pt == strategy::buffer::buffered_flat_end)
+        {
+            // It is flat, should just be added, without helper segments
+            add_piece(pt, range, true);
+        }
+        else
+        {
+            // Normal case, it has an "inside", helper segments should be added
+            add_piece(pt, end_point, range);
+        }
+    }
+
+    //-------------------------------------------------------------------------
+
+    inline void enrich()
+    {
+        enrich_intersection_points<false, false, overlay_buffer>(m_turns,
+                    m_clusters, offsetted_rings, offsetted_rings,
+                    m_robust_policy, m_side_strategy);
+    }
+
+    // Discards all rings which do have not-OK intersection points only.
+    // Those can never be traversed and should not be part of the output.
+    inline void discard_rings()
+    {
+        for (typename boost::range_iterator<turn_vector_type const>::type it =
+            boost::begin(m_turns); it != boost::end(m_turns); ++it)
+        {
+            if (it->location != location_ok)
+            {
+                offsetted_rings[it->operations[0].seg_id.multi_index].has_discarded_intersections = true;
+                offsetted_rings[it->operations[1].seg_id.multi_index].has_discarded_intersections = true;
+            }
+            else
+            {
+                offsetted_rings[it->operations[0].seg_id.multi_index].has_accepted_intersections = true;
+                offsetted_rings[it->operations[1].seg_id.multi_index].has_accepted_intersections = true;
+            }
+        }
+    }
+
+    inline bool point_coveredby_original(point_type const& point)
+    {
+        robust_point_type any_point;
+        geometry::recalculate(any_point, point, m_robust_policy);
+
+        signed_size_type count_in_original = 0;
+
+        // Check of the robust point of this outputted ring is in
+        // any of the robust original rings
+        // This can go quadratic if the input has many rings, and there
+        // are many untouched deflated rings around
+        for (typename std::vector<robust_original>::const_iterator it
+            = robust_originals.begin();
+            it != robust_originals.end();
+            ++it)
+        {
+            robust_original const& original = *it;
+            if (detail::disjoint::disjoint_point_box(any_point,
+                    original.m_box))
+            {
+                continue;
+            }
+
+            int const geometry_code
+                = detail::within::point_in_geometry(any_point,
+                    original.m_ring);
+
+            if (geometry_code == -1)
+            {
+                // Outside, continue
+                continue;
+            }
+
+            // Apply for possibly nested interior rings
+            if (original.m_is_interior)
+            {
+                count_in_original--;
+            }
+            else if (original.m_has_interiors)
+            {
+                count_in_original++;
+            }
+            else
+            {
+                // Exterior ring without interior rings
+                return true;
+            }
+        }
+        return count_in_original > 0;
+    }
+
+    // For a deflate, all rings around inner rings which are untouched
+    // (no intersections/turns) and which are OUTSIDE the original should
+    // be discarded
+    inline void discard_nonintersecting_deflated_rings()
+    {
+        for(typename buffered_ring_collection<buffered_ring<Ring> >::iterator it
+            = boost::begin(offsetted_rings);
+            it != boost::end(offsetted_rings);
+            ++it)
+        {
+            buffered_ring<Ring>& ring = *it;
+            if (! ring.has_intersections()
+                && boost::size(ring) > 0u
+                && geometry::area(ring, m_area_strategy) < 0)
+            {
+                if (! point_coveredby_original(geometry::range::front(ring)))
+                {
+                    ring.is_untouched_outside_original = true;
+                }
+            }
+        }
+    }
+
+    inline void block_turns()
+    {
+        // To fix left-turn issues like #rt_u13
+        // But currently it causes more other issues than it fixes
+//        m_turns.erase
+//            (
+//                std::remove_if(boost::begin(m_turns), boost::end(m_turns),
+//                                redundant_turn()),
+//                boost::end(m_turns)
+//            );
+
+        for (typename boost::range_iterator<turn_vector_type>::type it =
+            boost::begin(m_turns); it != boost::end(m_turns); ++it)
+        {
+            buffer_turn_info_type& turn = *it;
+            if (turn.location != location_ok)
+            {
+                // Discard this turn (don't set it to blocked to avoid colocated
+                // clusters being discarded afterwards
+                turn.discarded = true;
+            }
+        }
+    }
+
+    inline void traverse()
+    {
+        typedef detail::overlay::traverse
+            <
+                false, false,
+                buffered_ring_collection<buffered_ring<Ring> >,
+                buffered_ring_collection<buffered_ring<Ring > >,
+                overlay_buffer,
+                backtrack_for_buffer
+            > traverser;
+
+        traversed_rings.clear();
+        buffer_overlay_visitor visitor;
+        traverser::apply(offsetted_rings, offsetted_rings,
+                        m_intersection_strategy, m_robust_policy,
+                        m_turns, traversed_rings,
+                        m_clusters, visitor);
+    }
+
+    inline void reverse()
+    {
+        for(typename buffered_ring_collection<buffered_ring<Ring> >::iterator it = boost::begin(offsetted_rings);
+            it != boost::end(offsetted_rings);
+            ++it)
+        {
+            if (! it->has_intersections())
+            {
+                std::reverse(it->begin(), it->end());
+            }
+        }
+        for (typename boost::range_iterator<buffered_ring_collection<Ring> >::type
+                it = boost::begin(traversed_rings);
+                it != boost::end(traversed_rings);
+                ++it)
+        {
+            std::reverse(it->begin(), it->end());
+        }
+
+    }
+
+    template <typename GeometryOutput, typename OutputIterator>
+    inline OutputIterator assign(OutputIterator out) const
+    {
+        typedef detail::overlay::ring_properties<point_type, area_result_type> properties;
+
+        std::map<ring_identifier, properties> selected;
+
+        // Select all rings which do not have any self-intersection
+        // Inner rings, for deflate, which do not have intersections, and
+        // which are outside originals, are skipped
+        // (other ones should be traversed)
+        signed_size_type index = 0;
+        for(typename buffered_ring_collection<buffered_ring<Ring> >::const_iterator it = boost::begin(offsetted_rings);
+            it != boost::end(offsetted_rings);
+            ++it, ++index)
+        {
+            if (! it->has_intersections()
+                && ! it->is_untouched_outside_original)
+            {
+                properties p = properties(*it, m_area_strategy);
+                if (p.valid)
+                {
+                    ring_identifier id(0, index, -1);
+                    selected[id] = p;
+                }
+            }
+        }
+
+        // Select all created rings
+        index = 0;
+        for (typename boost::range_iterator<buffered_ring_collection<Ring> const>::type
+                it = boost::begin(traversed_rings);
+                it != boost::end(traversed_rings);
+                ++it, ++index)
+        {
+            properties p = properties(*it, m_area_strategy);
+            if (p.valid)
+            {
+                ring_identifier id(2, index, -1);
+                selected[id] = p;
+            }
+        }
+
+        detail::overlay::assign_parents(offsetted_rings, traversed_rings, selected, m_intersection_strategy, true);
+        return detail::overlay::add_rings<GeometryOutput>(selected, offsetted_rings, traversed_rings, out);
+    }
+
+};
+
+
+}} // namespace detail::buffer
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_BUFFERED_PIECE_COLLECTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/buffered_ring.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/buffered_ring.hpp
new file mode 100644
index 00000000000..4fd24b14518
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/buffered_ring.hpp
@@ -0,0 +1,282 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_BUFFERED_RING
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_BUFFERED_RING
+
+
+#include <cstddef>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/point_order.hpp>
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/strategies/buffer.hpp>
+
+#include <boost/geometry/algorithms/within.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/copy_segments.hpp>
+#include <boost/geometry/algorithms/detail/overlay/copy_segment_point.hpp>
+#include <boost/geometry/algorithms/detail/overlay/enrichment_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_ring.hpp>
+#include <boost/geometry/algorithms/detail/overlay/traversal_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace buffer
+{
+
+struct buffered_ring_collection_tag : polygonal_tag, multi_tag
+{};
+
+
+template <typename Ring>
+struct buffered_ring : public Ring
+{
+    bool has_concave;
+    bool has_accepted_intersections;
+    bool has_discarded_intersections;
+    bool is_untouched_outside_original;
+
+    inline buffered_ring()
+        : has_concave(false)
+        , has_accepted_intersections(false)
+        , has_discarded_intersections(false)
+        , is_untouched_outside_original(false)
+    {}
+
+    inline bool discarded() const
+    {
+        return has_discarded_intersections && ! has_accepted_intersections;
+    }
+    inline bool has_intersections() const
+    {
+        return has_discarded_intersections || has_accepted_intersections;
+    }
+};
+
+// This is a collection now special for overlay (needs vector of rings)
+template <typename Ring>
+struct buffered_ring_collection : public std::vector<Ring>
+{
+};
+
+}} // namespace detail::buffer
+
+
+// Turn off concept checking (for now)
+namespace dispatch
+{
+template <typename Geometry, bool IsConst>
+struct check<Geometry, detail::buffer::buffered_ring_collection_tag, IsConst>
+{
+};
+
+}
+
+
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+// Register the types
+namespace traits
+{
+
+
+template <typename Ring>
+struct tag<geometry::detail::buffer::buffered_ring<Ring> >
+{
+    typedef ring_tag type;
+};
+
+
+template <typename Ring>
+struct point_order<geometry::detail::buffer::buffered_ring<Ring> >
+{
+    static const order_selector value = geometry::point_order<Ring>::value;
+};
+
+
+template <typename Ring>
+struct closure<geometry::detail::buffer::buffered_ring<Ring> >
+{
+    static const closure_selector value = geometry::closure<Ring>::value;
+};
+
+
+template <typename Ring>
+struct point_type<geometry::detail::buffer::buffered_ring_collection<Ring> >
+{
+    typedef typename geometry::point_type<Ring>::type type;
+};
+
+template <typename Ring>
+struct tag<geometry::detail::buffer::buffered_ring_collection<Ring> >
+{
+    typedef geometry::detail::buffer::buffered_ring_collection_tag type;
+};
+
+
+} // namespace traits
+
+
+
+
+namespace core_dispatch
+{
+
+template <typename Ring>
+struct ring_type
+<
+    detail::buffer::buffered_ring_collection_tag,
+    detail::buffer::buffered_ring_collection<Ring>
+>
+{
+    typedef Ring type;
+};
+
+
+// There is a specific tag, so this specialization cannot be placed in traits
+template <typename Ring>
+struct point_order<detail::buffer::buffered_ring_collection_tag,
+        geometry::detail::buffer::buffered_ring_collection
+        <
+            geometry::detail::buffer::buffered_ring<Ring>
+        > >
+{
+    static const order_selector value
+        = core_dispatch::point_order<ring_tag, Ring>::value;
+};
+
+
+}
+
+
+template <>
+struct single_tag_of<detail::buffer::buffered_ring_collection_tag>
+{
+    typedef ring_tag type;
+};
+
+
+namespace dispatch
+{
+
+template
+<
+    typename MultiRing,
+    bool Reverse,
+    typename SegmentIdentifier,
+    typename PointOut
+>
+struct copy_segment_point
+    <
+        detail::buffer::buffered_ring_collection_tag,
+        MultiRing,
+        Reverse,
+        SegmentIdentifier,
+        PointOut
+    >
+    : detail::copy_segments::copy_segment_point_multi
+        <
+            MultiRing,
+            SegmentIdentifier,
+            PointOut,
+            detail::copy_segments::copy_segment_point_range
+                <
+                    typename boost::range_value<MultiRing>::type,
+                    Reverse,
+                    SegmentIdentifier,
+                    PointOut
+                >
+        >
+{};
+
+
+template<bool Reverse>
+struct copy_segments
+    <
+        detail::buffer::buffered_ring_collection_tag,
+        Reverse
+    >
+    : detail::copy_segments::copy_segments_multi
+        <
+            detail::copy_segments::copy_segments_ring<Reverse>
+        >
+{};
+
+template <typename Point, typename MultiGeometry>
+struct within
+<
+    Point,
+    MultiGeometry,
+    point_tag,
+    detail::buffer::buffered_ring_collection_tag
+>
+{
+    template <typename Strategy>
+    static inline bool apply(Point const& point,
+                MultiGeometry const& multi, Strategy const& strategy)
+    {
+        return detail::within::point_in_geometry(point, multi, strategy) == 1;
+    }
+};
+
+
+template <typename Geometry>
+struct is_empty<Geometry, detail::buffer::buffered_ring_collection_tag>
+    : detail::is_empty::multi_is_empty<detail::is_empty::range_is_empty>
+{};
+
+
+template <typename Geometry>
+struct envelope<Geometry, detail::buffer::buffered_ring_collection_tag>
+    : detail::envelope::envelope_multi_range
+        <
+            detail::envelope::envelope_range
+        >
+{};
+
+
+} // namespace dispatch
+
+namespace detail { namespace overlay
+{
+
+template<>
+struct get_ring<detail::buffer::buffered_ring_collection_tag>
+{
+    template<typename MultiGeometry>
+    static inline typename ring_type<MultiGeometry>::type const& apply(
+                ring_identifier const& id,
+                MultiGeometry const& multi_ring)
+    {
+        BOOST_GEOMETRY_ASSERT
+            (
+                id.multi_index >= 0
+                && id.multi_index < int(boost::size(multi_ring))
+            );
+        return get_ring<ring_tag>::apply(id, multi_ring[id.multi_index]);
+    }
+};
+
+}}
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_BUFFERED_RING
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/get_piece_turns.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/get_piece_turns.hpp
new file mode 100644
index 00000000000..5c012e7151f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/get_piece_turns.hpp
@@ -0,0 +1,312 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_GET_PIECE_TURNS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_GET_PIECE_TURNS_HPP
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/equals.hpp>
+#include <boost/geometry/algorithms/expand.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/box_box.hpp>
+#include <boost/geometry/algorithms/detail/overlay/segment_identifier.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_turn_info.hpp>
+#include <boost/geometry/algorithms/detail/sections/section_functions.hpp>
+#include <boost/geometry/algorithms/detail/buffer/buffer_policies.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace buffer
+{
+
+
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+struct buffer_assign_turn
+{
+    static bool const include_no_turn = false;
+    static bool const include_degenerate = false;
+    static bool const include_opposite = false;
+
+    template
+    <
+        typename Info,
+        typename Point1,
+        typename Point2,
+        typename IntersectionInfo
+    >
+    static inline void apply(Info& info,
+                             Point1 const& /*p1*/,
+                             Point2 const& /*p2*/,
+                             IntersectionInfo const& iinfo)
+    {
+        info.rob_pi = iinfo.rpi();
+        info.rob_pj = iinfo.rpj();
+        info.rob_qi = iinfo.rqi();
+        info.rob_qj = iinfo.rqj();
+    }
+
+};
+#endif
+
+template
+<
+    typename Pieces,
+    typename Rings,
+    typename Turns,
+    typename IntersectionStrategy,
+    typename RobustPolicy
+>
+class piece_turn_visitor
+{
+    Pieces const& m_pieces;
+    Rings const& m_rings;
+    Turns& m_turns;
+    IntersectionStrategy const& m_intersection_strategy;
+    RobustPolicy const& m_robust_policy;
+
+    template <typename Piece>
+    inline bool is_adjacent(Piece const& piece1, Piece const& piece2) const
+    {
+        if (piece1.first_seg_id.multi_index != piece2.first_seg_id.multi_index)
+        {
+            return false;
+        }
+
+        return piece1.index == piece2.left_index
+            || piece1.index == piece2.right_index;
+    }
+
+    template <typename Piece>
+    inline bool is_on_same_convex_ring(Piece const& piece1, Piece const& piece2) const
+    {
+        if (piece1.first_seg_id.multi_index != piece2.first_seg_id.multi_index)
+        {
+            return false;
+        }
+
+        return ! m_rings[piece1.first_seg_id.multi_index].has_concave;
+    }
+
+    template <typename Range, typename Iterator>
+    inline void move_to_next_point(Range const& range, Iterator& next) const
+    {
+        ++next;
+        if (next == boost::end(range))
+        {
+            next = boost::begin(range) + 1;
+        }
+    }
+
+    template <typename Range, typename Iterator>
+    inline Iterator next_point(Range const& range, Iterator it) const
+    {
+        Iterator result = it;
+        move_to_next_point(range, result);
+        // TODO: we could use either piece-boundaries, or comparison with
+        // robust points, to check if the point equals the last one
+        while(geometry::equals(*it, *result))
+        {
+            move_to_next_point(range, result);
+        }
+        return result;
+    }
+
+    template <std::size_t Dimension, typename Iterator, typename Box>
+    inline void move_begin_iterator(Iterator& it_begin, Iterator it_beyond,
+                                    signed_size_type& index, int dir,
+                                    Box const& this_bounding_box,
+                                    Box const& other_bounding_box)
+    {
+        for(; it_begin != it_beyond
+                && it_begin + 1 != it_beyond
+                && detail::section::preceding<Dimension>(dir, *(it_begin + 1),
+                                                         this_bounding_box,
+                                                         other_bounding_box,
+                                                         m_robust_policy);
+            ++it_begin, index++)
+        {}
+    }
+
+    template <std::size_t Dimension, typename Iterator, typename Box>
+    inline void move_end_iterator(Iterator it_begin, Iterator& it_beyond,
+                                  int dir, Box const& this_bounding_box,
+                                  Box const& other_bounding_box)
+    {
+        while (it_beyond != it_begin
+            && it_beyond - 1 != it_begin
+            && it_beyond - 2 != it_begin)
+        {
+            if (detail::section::exceeding<Dimension>(dir, *(it_beyond - 2),
+                        this_bounding_box, other_bounding_box, m_robust_policy))
+            {
+                --it_beyond;
+            }
+            else
+            {
+                return;
+            }
+        }
+    }
+
+    template <typename Piece, typename Section>
+    inline void calculate_turns(Piece const& piece1, Piece const& piece2,
+        Section const& section1, Section const& section2)
+    {
+        typedef typename boost::range_value<Rings const>::type ring_type;
+        typedef typename boost::range_value<Turns const>::type turn_type;
+        typedef typename boost::range_iterator<ring_type const>::type iterator;
+
+        signed_size_type const piece1_first_index = piece1.first_seg_id.segment_index;
+        signed_size_type const piece2_first_index = piece2.first_seg_id.segment_index;
+        if (piece1_first_index < 0 || piece2_first_index < 0)
+        {
+            return;
+        }
+
+        // Get indices of part of offsetted_rings for this monotonic section:
+        signed_size_type const sec1_first_index = piece1_first_index + section1.begin_index;
+        signed_size_type const sec2_first_index = piece2_first_index + section2.begin_index;
+
+        // index of last point in section, beyond-end is one further
+        signed_size_type const sec1_last_index = piece1_first_index + section1.end_index;
+        signed_size_type const sec2_last_index = piece2_first_index + section2.end_index;
+
+        // get geometry and iterators over these sections
+        ring_type const& ring1 = m_rings[piece1.first_seg_id.multi_index];
+        iterator it1_first = boost::begin(ring1) + sec1_first_index;
+        iterator it1_beyond = boost::begin(ring1) + sec1_last_index + 1;
+
+        ring_type const& ring2 = m_rings[piece2.first_seg_id.multi_index];
+        iterator it2_first = boost::begin(ring2) + sec2_first_index;
+        iterator it2_beyond = boost::begin(ring2) + sec2_last_index + 1;
+
+        // Set begin/end of monotonic ranges, in both x/y directions
+        signed_size_type index1 = sec1_first_index;
+        move_begin_iterator<0>(it1_first, it1_beyond, index1,
+                    section1.directions[0], section1.bounding_box, section2.bounding_box);
+        move_end_iterator<0>(it1_first, it1_beyond,
+                    section1.directions[0], section1.bounding_box, section2.bounding_box);
+        move_begin_iterator<1>(it1_first, it1_beyond, index1,
+                    section1.directions[1], section1.bounding_box, section2.bounding_box);
+        move_end_iterator<1>(it1_first, it1_beyond,
+                    section1.directions[1], section1.bounding_box, section2.bounding_box);
+
+        signed_size_type index2 = sec2_first_index;
+        move_begin_iterator<0>(it2_first, it2_beyond, index2,
+                    section2.directions[0], section2.bounding_box, section1.bounding_box);
+        move_end_iterator<0>(it2_first, it2_beyond,
+                    section2.directions[0], section2.bounding_box, section1.bounding_box);
+        move_begin_iterator<1>(it2_first, it2_beyond, index2,
+                    section2.directions[1], section2.bounding_box, section1.bounding_box);
+        move_end_iterator<1>(it2_first, it2_beyond,
+                    section2.directions[1], section2.bounding_box, section1.bounding_box);
+
+        turn_type the_model;
+        the_model.operations[0].piece_index = piece1.index;
+        the_model.operations[0].seg_id = piece1.first_seg_id;
+        the_model.operations[0].seg_id.segment_index = index1; // override
+
+        iterator it1 = it1_first;
+        for (iterator prev1 = it1++;
+                it1 != it1_beyond;
+                prev1 = it1++, the_model.operations[0].seg_id.segment_index++)
+        {
+            the_model.operations[1].piece_index = piece2.index;
+            the_model.operations[1].seg_id = piece2.first_seg_id;
+            the_model.operations[1].seg_id.segment_index = index2; // override
+
+            iterator next1 = next_point(ring1, it1);
+
+            iterator it2 = it2_first;
+            for (iterator prev2 = it2++;
+                    it2 != it2_beyond;
+                    prev2 = it2++, the_model.operations[1].seg_id.segment_index++)
+            {
+                iterator next2 = next_point(ring2, it2);
+
+                // TODO: internally get_turn_info calculates robust points.
+                // But they are already calculated.
+                // We should be able to use them.
+                // this means passing them to this visitor,
+                // and iterating in sync with them...
+                typedef detail::overlay::get_turn_info
+                    <
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+                        buffer_assign_turn
+#else
+                        detail::overlay::assign_null_policy
+#endif
+                    > turn_policy;
+
+                turn_policy::apply(*prev1, *it1, *next1,
+                                    *prev2, *it2, *next2,
+                                    false, false, false, false,
+                                    the_model,
+                                    m_intersection_strategy,
+                                    m_robust_policy,
+                                    std::back_inserter(m_turns));
+            }
+        }
+    }
+
+public:
+
+    piece_turn_visitor(Pieces const& pieces,
+            Rings const& ring_collection,
+            Turns& turns,
+            IntersectionStrategy const& intersection_strategy,
+            RobustPolicy const& robust_policy)
+        : m_pieces(pieces)
+        , m_rings(ring_collection)
+        , m_turns(turns)
+        , m_intersection_strategy(intersection_strategy)
+        , m_robust_policy(robust_policy)
+    {}
+
+    template <typename Section>
+    inline bool apply(Section const& section1, Section const& section2,
+                    bool first = true)
+    {
+        boost::ignore_unused_variable_warning(first);
+
+        typedef typename boost::range_value<Pieces const>::type piece_type;
+        piece_type const& piece1 = m_pieces[section1.ring_id.source_index];
+        piece_type const& piece2 = m_pieces[section2.ring_id.source_index];
+
+        if ( piece1.index == piece2.index
+          || is_adjacent(piece1, piece2)
+          || is_on_same_convex_ring(piece1, piece2)
+          || detail::disjoint::disjoint_box_box(section1.bounding_box,
+                                                section2.bounding_box) )
+        {
+            return true;
+        }
+
+        calculate_turns(piece1, piece2, section1, section2);
+
+        return true;
+    }
+};
+
+
+}} // namespace detail::buffer
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_GET_PIECE_TURNS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/line_line_intersection.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/line_line_intersection.hpp
new file mode 100644
index 00000000000..618afe5fbae
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/line_line_intersection.hpp
@@ -0,0 +1,88 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012-2014 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_LINE_LINE_INTERSECTION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_LINE_LINE_INTERSECTION_HPP
+
+
+#include <boost/geometry/arithmetic/determinant.hpp>
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/strategies/buffer.hpp>
+#include <boost/geometry/algorithms/detail/buffer/parallel_continue.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace buffer
+{
+
+
+// TODO: once change this to proper strategy
+// It is different from current segment intersection because these are not segments but lines
+// If we have the Line concept, we can create a strategy
+// Assumes a convex corner
+struct line_line_intersection
+{
+
+    template <typename Point>
+    static inline strategy::buffer::join_selector apply(Point const& pi, Point const& pj,
+        Point const& qi, Point const& qj, Point& ip)
+    {
+        // See http://mathworld.wolfram.com/Line-LineIntersection.html
+        typedef typename coordinate_type<Point>::type coordinate_type;
+
+        coordinate_type const denominator
+            = determinant<coordinate_type>(get<0>(pi) - get<0>(pj),
+                get<1>(pi) - get<1>(pj),
+                get<0>(qi) - get<0>(qj),
+                get<1>(qi) - get<1>(qj));
+
+        // Even if the corner was checked before (so it is convex now), that
+        // was done on the original geometry. This function runs on the buffered
+        // geometries, where sides are generated and might be slightly off. In
+        // Floating Point, that slightly might just exceed the limit and we have
+        // to check it again.
+
+        // For round joins, it will not be used at all.
+        // For miter joints, there is a miter limit
+        // If segments are parallel/collinear we must be distinguish two cases:
+        // they continue each other, or they form a spike
+        if (math::equals(denominator, coordinate_type()))
+        {
+            return parallel_continue(get<0>(qj) - get<0>(qi),
+                                get<1>(qj) - get<1>(qi),
+                                get<0>(pj) - get<0>(pi),
+                                get<1>(pj) - get<1>(pi))
+                ? strategy::buffer::join_continue
+                : strategy::buffer::join_spike
+                ;
+        }
+
+        coordinate_type d1 = determinant<coordinate_type>(get<0>(pi), get<1>(pi), get<0>(pj), get<1>(pj));
+        coordinate_type d2 = determinant<coordinate_type>(get<0>(qi), get<1>(qi), get<0>(qj), get<1>(qj));
+
+        double const multiplier = 1.0 / denominator;
+
+        set<0>(ip, determinant<coordinate_type>(d1, get<0>(pi) - get<0>(pj), d2, get<0>(qi) - get<0>(qj)) * multiplier);
+        set<1>(ip, determinant<coordinate_type>(d1, get<1>(pi) - get<1>(pj), d2, get<1>(qi) - get<1>(qj)) * multiplier);
+
+        return strategy::buffer::join_convex;
+    }
+};
+
+
+}} // namespace detail::buffer
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_LINE_LINE_INTERSECTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/parallel_continue.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/parallel_continue.hpp
new file mode 100644
index 00000000000..119d64de74d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/parallel_continue.hpp
@@ -0,0 +1,33 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012-2014 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_PARALLEL_CONTINUE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_PARALLEL_CONTINUE_HPP
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace buffer
+{
+
+template <typename T>
+inline bool parallel_continue(T dx1, T dy1, T dx2, T dy2)
+{
+    T const dot = dx1 * dx2 + dy1 * dy2;
+    return dot > 0;
+}
+
+}} // namespace detail::buffer
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_PARALLEL_CONTINUE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/turn_in_original_visitor.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/turn_in_original_visitor.hpp
new file mode 100644
index 00000000000..e7cc97539f9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/turn_in_original_visitor.hpp
@@ -0,0 +1,277 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2016.
+// Modifications copyright (c) 2016 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_TURN_IN_ORIGINAL_VISITOR
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_TURN_IN_ORIGINAL_VISITOR
+
+
+#include <boost/core/ignore_unused.hpp>
+
+#include <boost/geometry/algorithms/expand.hpp>
+#include <boost/geometry/strategies/agnostic/point_in_poly_winding.hpp>
+#include <boost/geometry/strategies/buffer.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace buffer
+{
+
+struct original_get_box
+{
+    template <typename Box, typename Original>
+    static inline void apply(Box& total, Original const& original)
+    {
+        geometry::expand(total, original.m_box);
+    }
+};
+
+struct original_ovelaps_box
+{
+    template <typename Box, typename Original>
+    static inline bool apply(Box const& box, Original const& original)
+    {
+        return ! detail::disjoint::disjoint_box_box(box, original.m_box);
+    }
+};
+
+struct include_turn_policy
+{
+    template <typename Turn>
+    static inline bool apply(Turn const& turn)
+    {
+        return turn.location == location_ok;
+    }
+};
+
+struct turn_in_original_ovelaps_box
+{
+    template <typename Box, typename Turn>
+    static inline bool apply(Box const& box, Turn const& turn)
+    {
+        if (turn.location != location_ok || turn.within_original)
+        {
+            // Skip all points already processed
+            return false;
+        }
+
+        return ! geometry::detail::disjoint::disjoint_point_box(
+                    turn.robust_point, box);
+    }
+};
+
+//! Check if specified is in range of specified iterators
+//! Return value of strategy (true if we can bail out)
+template
+<
+    typename Strategy,
+    typename State,
+    typename Point,
+    typename Iterator
+>
+inline bool point_in_range(Strategy& strategy, State& state,
+        Point const& point, Iterator begin, Iterator end)
+{
+    boost::ignore_unused(strategy);
+
+    Iterator it = begin;
+    for (Iterator previous = it++; it != end; ++previous, ++it)
+    {
+        if (! strategy.apply(point, *previous, *it, state))
+        {
+            // We're probably on the boundary
+            return false;
+        }
+    }
+    return true;
+}
+
+template
+<
+    typename Strategy,
+    typename State,
+    typename Point,
+    typename CoordinateType,
+    typename Iterator
+>
+inline bool point_in_section(Strategy& strategy, State& state,
+        Point const& point, CoordinateType const& point_x,
+        Iterator begin, Iterator end,
+        int direction)
+{
+    if (direction == 0)
+    {
+        // Not a monotonic section, or no change in X-direction
+        return point_in_range(strategy, state, point, begin, end);
+    }
+
+    // We're in a monotonic section in x-direction
+    Iterator it = begin;
+
+    for (Iterator previous = it++; it != end; ++previous, ++it)
+    {
+        // Depending on sections.direction we can quit for this section
+        CoordinateType const previous_x = geometry::get<0>(*previous);
+
+        if (direction == 1 && point_x < previous_x)
+        {
+            // Section goes upwards, x increases, point is is below section
+            return true;
+        }
+        else if (direction == -1 && point_x > previous_x)
+        {
+            // Section goes downwards, x decreases, point is above section
+            return true;
+        }
+
+        if (! strategy.apply(point, *previous, *it, state))
+        {
+            // We're probably on the boundary
+            return false;
+        }
+    }
+    return true;
+}
+
+
+template <typename Point, typename Original>
+inline int point_in_original(Point const& point, Original const& original)
+{
+    // The winding strategy is scanning in x direction
+    // therefore it's critical to pass direction calculated
+    // for x dimension below.
+    typedef strategy::within::winding<Point> strategy_type;
+
+    typename strategy_type::state_type state;
+    strategy_type strategy;
+
+    if (boost::size(original.m_sections) == 0
+        || boost::size(original.m_ring) - boost::size(original.m_sections) < 16)
+    {
+        // There are no sections, or it does not profit to walk over sections
+        // instead of over points. Boundary of 16 is arbitrary but can influence
+        // performance
+        point_in_range(strategy, state, point,
+                original.m_ring.begin(), original.m_ring.end());
+        return strategy.result(state);
+    }
+
+    typedef typename Original::sections_type sections_type;
+    typedef typename boost::range_iterator<sections_type const>::type iterator_type;
+    typedef typename boost::range_value<sections_type const>::type section_type;
+    typedef typename geometry::coordinate_type<Point>::type coordinate_type;
+
+    coordinate_type const point_x = geometry::get<0>(point);
+
+    // Walk through all monotonic sections of this original
+    for (iterator_type it = boost::begin(original.m_sections);
+        it != boost::end(original.m_sections);
+        ++it)
+    {
+        section_type const& section = *it;
+
+        if (! section.duplicate
+            && section.begin_index < section.end_index
+            && point_x >= geometry::get<min_corner, 0>(section.bounding_box)
+            && point_x <= geometry::get<max_corner, 0>(section.bounding_box))
+        {
+            // x-coordinate of point overlaps with section
+            if (! point_in_section(strategy, state, point, point_x,
+                    boost::begin(original.m_ring) + section.begin_index,
+                    boost::begin(original.m_ring) + section.end_index + 1,
+                    section.directions[0]))
+            {
+                // We're probably on the boundary
+                break;
+            }
+        }
+    }
+
+    return strategy.result(state);
+}
+
+
+template <typename Turns>
+class turn_in_original_visitor
+{
+public:
+    turn_in_original_visitor(Turns& turns)
+        : m_mutable_turns(turns)
+    {}
+
+    template <typename Turn, typename Original>
+    inline bool apply(Turn const& turn, Original const& original, bool first = true)
+    {
+        boost::ignore_unused_variable_warning(first);
+
+        if (turn.location != location_ok || turn.within_original)
+        {
+            // Skip all points already processed
+            return true;
+        }
+
+        if (geometry::disjoint(turn.robust_point, original.m_box))
+        {
+            // Skip all disjoint
+            return true;
+        }
+
+        int const code = point_in_original(turn.robust_point, original);
+
+        if (code == -1)
+        {
+            return true;
+        }
+
+        Turn& mutable_turn = m_mutable_turns[turn.turn_index];
+
+        if (code == 0)
+        {
+            // On border of original: always discard
+            mutable_turn.location = location_discard;
+        }
+
+        // Point is inside an original ring
+        if (original.m_is_interior)
+        {
+            mutable_turn.count_in_original--;
+        }
+        else if (original.m_has_interiors)
+        {
+            mutable_turn.count_in_original++;
+        }
+        else
+        {
+            // It is an exterior ring and there are no interior rings.
+            // Then we are completely ready with this turn
+            mutable_turn.within_original = true;
+            mutable_turn.count_in_original = 1;
+        }
+
+        return true;
+    }
+
+private :
+    Turns& m_mutable_turns;
+};
+
+
+}} // namespace detail::buffer
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_TURN_IN_ORIGINAL_VISITOR
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/turn_in_piece_visitor.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/turn_in_piece_visitor.hpp
new file mode 100644
index 00000000000..d23a3b3fd62
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/buffer/turn_in_piece_visitor.hpp
@@ -0,0 +1,806 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2016.
+// Modifications copyright (c) 2016 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_TURN_IN_PIECE_VISITOR
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_TURN_IN_PIECE_VISITOR
+
+
+#include <boost/core/ignore_unused.hpp>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+
+#include <boost/geometry/arithmetic/dot_product.hpp>
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/algorithms/comparable_distance.hpp>
+#include <boost/geometry/algorithms/equals.hpp>
+#include <boost/geometry/algorithms/expand.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/point_box.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/box_box.hpp>
+#include <boost/geometry/algorithms/detail/overlay/segment_identifier.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_turn_info.hpp>
+#include <boost/geometry/policies/compare.hpp>
+#include <boost/geometry/strategies/buffer.hpp>
+#include <boost/geometry/algorithms/detail/buffer/buffer_policies.hpp>
+
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+#include <boost/geometry/strategies/cartesian/side_of_intersection.hpp>
+#endif
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace buffer
+{
+
+struct piece_get_box
+{
+    template <typename Box, typename Piece>
+    static inline void apply(Box& total, Piece const& piece)
+    {
+        geometry::expand(total, piece.robust_envelope);
+    }
+};
+
+struct piece_ovelaps_box
+{
+    template <typename Box, typename Piece>
+    static inline bool apply(Box const& box, Piece const& piece)
+    {
+        if (piece.type == strategy::buffer::buffered_flat_end
+            || piece.type == strategy::buffer::buffered_concave)
+        {
+            // Turns cannot be inside a flat end (though they can be on border)
+            // Neither we need to check if they are inside concave helper pieces
+
+            // Skip all pieces not used as soon as possible
+            return false;
+        }
+
+        return ! geometry::detail::disjoint::disjoint_box_box(box, piece.robust_envelope);
+    }
+};
+
+struct turn_get_box
+{
+    template <typename Box, typename Turn>
+    static inline void apply(Box& total, Turn const& turn)
+    {
+        geometry::expand(total, turn.robust_point);
+    }
+};
+
+struct turn_ovelaps_box
+{
+    template <typename Box, typename Turn>
+    static inline bool apply(Box const& box, Turn const& turn)
+    {
+        return ! geometry::detail::disjoint::disjoint_point_box(turn.robust_point, box);
+    }
+};
+
+
+enum analyse_result
+{
+    analyse_unknown,
+    analyse_continue,
+    analyse_disjoint,
+    analyse_within,
+    analyse_on_original_boundary,
+    analyse_on_offsetted
+#if ! defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+    , analyse_near_offsetted
+#endif
+};
+
+template <typename Point>
+inline bool in_box(Point const& previous,
+        Point const& current, Point const& point)
+{
+    // Get its box (TODO: this can be prepared-on-demand later)
+    typedef geometry::model::box<Point> box_type;
+    box_type box;
+    geometry::assign_inverse(box);
+    geometry::expand(box, previous);
+    geometry::expand(box, current);
+
+    return geometry::covered_by(point, box);
+}
+
+template <typename Point, typename Turn>
+inline analyse_result check_segment(Point const& previous,
+        Point const& current, Turn const& turn,
+        bool from_monotonic)
+{
+
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+    typedef geometry::model::referring_segment<Point const> segment_type;
+    segment_type const p(turn.rob_pi, turn.rob_pj);
+    segment_type const q(turn.rob_qi, turn.rob_qj);
+    segment_type const r(previous, current);
+    int const side = strategy::side::side_of_intersection::apply(p, q, r,
+                turn.robust_point);
+
+    if (side == 0)
+    {
+        return analyse_on_offsetted;
+    }
+    if (side == -1 && from_monotonic)
+    {
+        return analyse_within;
+    }
+    if (side == 1 && from_monotonic)
+    {
+        return analyse_disjoint;
+    }
+    return analyse_continue;
+
+#else
+
+    typedef typename strategy::side::services::default_strategy
+        <
+            typename cs_tag<Point>::type
+        >::type side_strategy;
+    typedef typename geometry::coordinate_type<Point>::type coordinate_type;
+
+    coordinate_type const twice_area
+        = side_strategy::template side_value
+            <
+                coordinate_type,
+                coordinate_type
+            >(previous, current, turn.robust_point);
+
+    if (twice_area == 0)
+    {
+        // Collinear, only on segment if it is covered by its bbox
+        if (in_box(previous, current, turn.robust_point))
+        {
+            return analyse_on_offsetted;
+        }
+    }
+    else if (twice_area < 0)
+    {
+        // It is in the triangle right-of the segment where the
+        // segment is the hypothenusa. Check if it is close
+        // (within rounding-area)
+        if (twice_area * twice_area < geometry::comparable_distance(previous, current)
+            && in_box(previous, current, turn.robust_point))
+        {
+            return analyse_near_offsetted;
+        }
+        else if (from_monotonic)
+        {
+            return analyse_within;
+        }
+    }
+    else if (twice_area > 0 && from_monotonic)
+    {
+        // Left of segment
+        return analyse_disjoint;
+    }
+
+    // Not monotonic, on left or right side: continue analysing
+    return analyse_continue;
+#endif
+}
+
+
+class analyse_turn_wrt_point_piece
+{
+public :
+    template <typename Turn, typename Piece>
+    static inline analyse_result apply(Turn const& turn, Piece const& piece)
+    {
+        typedef typename Piece::section_type section_type;
+        typedef typename Turn::robust_point_type point_type;
+        typedef typename geometry::coordinate_type<point_type>::type coordinate_type;
+
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+        typedef geometry::model::referring_segment<point_type const> segment_type;
+        segment_type const p(turn.rob_pi, turn.rob_pj);
+        segment_type const q(turn.rob_qi, turn.rob_qj);
+#else
+        typedef strategy::within::winding<point_type> strategy_type;
+
+        typename strategy_type::state_type state;
+        strategy_type strategy;
+        boost::ignore_unused(strategy);
+#endif
+
+        BOOST_GEOMETRY_ASSERT(! piece.sections.empty());
+
+        coordinate_type const point_x = geometry::get<0>(turn.robust_point);
+
+        for (std::size_t s = 0; s < piece.sections.size(); s++)
+        {
+            section_type const& section = piece.sections[s];
+            // If point within horizontal range of monotonic section:
+            if (! section.duplicate
+                && section.begin_index < section.end_index
+                && point_x >= geometry::get<min_corner, 0>(section.bounding_box) - 1
+                && point_x <= geometry::get<max_corner, 0>(section.bounding_box) + 1)
+            {
+                for (signed_size_type i = section.begin_index + 1; i <= section.end_index; i++)
+                {
+                    point_type const& previous = piece.robust_ring[i - 1];
+                    point_type const& current = piece.robust_ring[i];
+
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+
+                    // First check if it is in range - if it is not, the
+                    // expensive side_of_intersection does not need to be
+                    // applied
+                    coordinate_type x1 = geometry::get<0>(previous);
+                    coordinate_type x2 = geometry::get<0>(current);
+
+                    if (x1 > x2)
+                    {
+                        std::swap(x1, x2);
+                    }
+
+                    if (point_x >= x1 - 1 && point_x <= x2 + 1)
+                    {
+                        segment_type const r(previous, current);
+                        int const side = strategy::side::side_of_intersection::apply(p, q, r,
+                                    turn.robust_point);
+
+                        // Sections are monotonic in x-dimension
+                        if (side == 1)
+                        {
+                            // Left on segment
+                            return analyse_disjoint;
+                        }
+                        else if (side == 0)
+                        {
+                            // Collinear - TODO: check if really on segment
+                            return analyse_on_offsetted;
+                        }
+                    }
+#else
+                    analyse_result code = check_segment(previous, current, turn, false);
+                    if (code != analyse_continue)
+                    {
+                        return code;
+                    }
+
+                    // Get the state (to determine it is within), we don't have
+                    // to cover the on-segment case (covered above)
+                    strategy.apply(turn.robust_point, previous, current, state);
+#endif
+                }
+            }
+        }
+
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+        // It is nowhere outside, and not on segment, so it is within
+        return analyse_within;
+#else
+        int const code = strategy.result(state);
+        if (code == 1)
+        {
+            return analyse_within;
+        }
+        else if (code == -1)
+        {
+            return analyse_disjoint;
+        }
+
+        // Should normally not occur - on-segment is covered
+        return analyse_unknown;
+#endif
+    }
+
+};
+
+class analyse_turn_wrt_piece
+{
+    template <typename Point, typename Turn>
+    static inline analyse_result check_helper_segment(Point const& s1,
+                Point const& s2, Turn const& turn,
+                bool is_original,
+                Point const& offsetted)
+    {
+        boost::ignore_unused(offsetted);
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+        typedef geometry::model::referring_segment<Point const> segment_type;
+        segment_type const p(turn.rob_pi, turn.rob_pj);
+        segment_type const q(turn.rob_qi, turn.rob_qj);
+        segment_type const r(s1, s2);
+        int const side = strategy::side::side_of_intersection::apply(p, q, r,
+                    turn.robust_point);
+
+        if (side == 1)
+        {
+            // left of segment
+            return analyse_disjoint;
+        }
+        else if (side == 0)
+        {
+            // If is collinear, either on segment or before/after
+            typedef geometry::model::box<Point> box_type;
+
+            box_type box;
+            geometry::assign_inverse(box);
+            geometry::expand(box, s1);
+            geometry::expand(box, s2);
+
+            if (geometry::covered_by(turn.robust_point, box))
+            {
+                // Points on helper-segments are considered as within
+                // Points on original boundary are processed differently
+                return is_original
+                    ? analyse_on_original_boundary
+                    : analyse_within;
+            }
+
+            // It is collinear but not on the segment. Because these
+            // segments are convex, it is outside
+            // Unless the offsetted ring is collinear or concave w.r.t.
+            // helper-segment but that scenario is not yet supported
+            return analyse_disjoint;
+        }
+
+        // right of segment
+        return analyse_continue;
+#else
+        typedef typename strategy::side::services::default_strategy
+            <
+                typename cs_tag<Point>::type
+            >::type side_strategy;
+
+        switch(side_strategy::apply(s1, s2, turn.robust_point))
+        {
+            case 1 :
+                return analyse_disjoint; // left of segment
+            case 0 :
+                {
+                    // If is collinear, either on segment or before/after
+                    typedef geometry::model::box<Point> box_type;
+
+                    box_type box;
+                    geometry::assign_inverse(box);
+                    geometry::expand(box, s1);
+                    geometry::expand(box, s2);
+
+                    if (geometry::covered_by(turn.robust_point, box))
+                    {
+                        // It is on the segment
+                        if (! is_original
+                            && geometry::comparable_distance(turn.robust_point, offsetted) <= 1)
+                        {
+                            // It is close to the offsetted-boundary, take
+                            // any rounding-issues into account
+                            return analyse_near_offsetted;
+                        }
+
+                        // Points on helper-segments are considered as within
+                        // Points on original boundary are processed differently
+                        return is_original
+                            ? analyse_on_original_boundary
+                            : analyse_within;
+                    }
+
+                    // It is collinear but not on the segment. Because these
+                    // segments are convex, it is outside
+                    // Unless the offsetted ring is collinear or concave w.r.t.
+                    // helper-segment but that scenario is not yet supported
+                    return analyse_disjoint;
+                }
+                break;
+        }
+
+        // right of segment
+        return analyse_continue;
+#endif
+    }
+
+    template <typename Turn, typename Piece>
+    static inline analyse_result check_helper_segments(Turn const& turn, Piece const& piece)
+    {
+        typedef typename Turn::robust_point_type point_type;
+        geometry::equal_to<point_type> comparator;
+
+        point_type points[4];
+
+        signed_size_type helper_count = static_cast<signed_size_type>(piece.robust_ring.size())
+                                            - piece.offsetted_count;
+        if (helper_count == 4)
+        {
+            for (int i = 0; i < 4; i++)
+            {
+                points[i] = piece.robust_ring[piece.offsetted_count + i];
+            }
+        }
+        else if (helper_count == 3)
+        {
+            // Triangular piece, assign points but assign second twice
+            for (int i = 0; i < 4; i++)
+            {
+                int index = i < 2 ? i : i - 1;
+                points[i] = piece.robust_ring[piece.offsetted_count + index];
+            }
+        }
+        else
+        {
+            // Some pieces (e.g. around points) do not have helper segments.
+            // Others should have 3 (join) or 4 (side)
+            return analyse_continue;
+        }
+
+        // First check point-equality
+        point_type const& point = turn.robust_point;
+        if (comparator(point, points[0]) || comparator(point, points[3]))
+        {
+            return analyse_on_offsetted;
+        }
+        if (comparator(point, points[1]) || comparator(point, points[2]))
+        {
+            return analyse_on_original_boundary;
+        }
+
+        // Right side of the piece
+        analyse_result result
+            = check_helper_segment(points[0], points[1], turn,
+                    false, points[0]);
+        if (result != analyse_continue)
+        {
+            return result;
+        }
+
+        // Left side of the piece
+        result = check_helper_segment(points[2], points[3], turn,
+                    false, points[3]);
+        if (result != analyse_continue)
+        {
+            return result;
+        }
+
+        if (! comparator(points[1], points[2]))
+        {
+            // Side of the piece at side of original geometry
+            result = check_helper_segment(points[1], points[2], turn,
+                        true, point);
+            if (result != analyse_continue)
+            {
+                return result;
+            }
+        }
+
+        // We are within the \/ or |_| shaped piece, where the top is the
+        // offsetted ring.
+        if (! geometry::covered_by(point, piece.robust_offsetted_envelope))
+        {
+            // Not in offsetted-area. This makes a cheap check possible
+            typedef typename strategy::side::services::default_strategy
+                <
+                    typename cs_tag<point_type>::type
+                >::type side_strategy;
+
+            switch(side_strategy::apply(points[3], points[0], point))
+            {
+                case 1 : return analyse_disjoint;
+                case -1 : return analyse_within;
+                case 0 : return analyse_disjoint;
+            }
+        }
+
+        return analyse_continue;
+    }
+
+    template <typename Turn, typename Piece, typename Compare>
+    static inline analyse_result check_monotonic(Turn const& turn, Piece const& piece, Compare const& compare)
+    {
+        typedef typename Piece::piece_robust_ring_type ring_type;
+        typedef typename ring_type::const_iterator it_type;
+        it_type end = piece.robust_ring.begin() + piece.offsetted_count;
+        it_type it = std::lower_bound(piece.robust_ring.begin(),
+                    end,
+                    turn.robust_point,
+                    compare);
+
+        if (it != end
+            && it != piece.robust_ring.begin())
+        {
+            // iterator points to point larger than point
+            // w.r.t. specified direction, and prev points to a point smaller
+            // We now know if it is inside/outside
+            it_type prev = it - 1;
+            return check_segment(*prev, *it, turn, true);
+        }
+        return analyse_continue;
+    }
+
+public :
+    template <typename Turn, typename Piece>
+    static inline analyse_result apply(Turn const& turn, Piece const& piece)
+    {
+        typedef typename Turn::robust_point_type point_type;
+        analyse_result code = check_helper_segments(turn, piece);
+        if (code != analyse_continue)
+        {
+            return code;
+        }
+
+        geometry::equal_to<point_type> comparator;
+
+        if (piece.offsetted_count > 8)
+        {
+            // If the offset contains some points and is monotonic, we try
+            // to avoid walking all points linearly.
+            // We try it only once.
+            if (piece.is_monotonic_increasing[0])
+            {
+                code = check_monotonic(turn, piece, geometry::less<point_type, 0>());
+                if (code != analyse_continue) return code;
+            }
+            else if (piece.is_monotonic_increasing[1])
+            {
+                code = check_monotonic(turn, piece, geometry::less<point_type, 1>());
+                if (code != analyse_continue) return code;
+            }
+            else if (piece.is_monotonic_decreasing[0])
+            {
+                code = check_monotonic(turn, piece, geometry::greater<point_type, 0>());
+                if (code != analyse_continue) return code;
+            }
+            else if (piece.is_monotonic_decreasing[1])
+            {
+                code = check_monotonic(turn, piece, geometry::greater<point_type, 1>());
+                if (code != analyse_continue) return code;
+            }
+        }
+
+        // It is small or not monotonic, walk linearly through offset
+        // TODO: this will be combined with winding strategy
+
+        for (signed_size_type i = 1; i < piece.offsetted_count; i++)
+        {
+            point_type const& previous = piece.robust_ring[i - 1];
+            point_type const& current = piece.robust_ring[i];
+
+            // The robust ring can contain duplicates
+            // (on which any side or side-value would return 0)
+            if (! comparator(previous, current))
+            {
+                code = check_segment(previous, current, turn, false);
+                if (code != analyse_continue)
+                {
+                    return code;
+                }
+            }
+        }
+
+        return analyse_unknown;
+    }
+
+};
+
+
+template <typename Turns, typename Pieces>
+class turn_in_piece_visitor
+{
+    Turns& m_turns; // because partition is currently operating on const input only
+    Pieces const& m_pieces; // to check for piece-type
+
+    template <typename Operation, typename Piece>
+    inline bool skip(Operation const& op, Piece const& piece) const
+    {
+        if (op.piece_index == piece.index)
+        {
+            return true;
+        }
+        Piece const& pc = m_pieces[op.piece_index];
+        if (pc.left_index == piece.index || pc.right_index == piece.index)
+        {
+            if (pc.type == strategy::buffer::buffered_flat_end)
+            {
+                // If it is a flat end, don't compare against its neighbor:
+                // it will always be located on one of the helper segments
+                return true;
+            }
+            if (pc.type == strategy::buffer::buffered_concave)
+            {
+                // If it is concave, the same applies: the IP will be
+                // located on one of the helper segments
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+    // NOTE: this function returns a side value in {-1, 0, 1}
+    template <typename Turn, typename Piece>
+    static inline int turn_in_convex_piece(Turn const& turn,
+            Piece const& piece)
+    {
+        typedef typename Turn::robust_point_type point_type;
+        typedef typename Piece::piece_robust_ring_type ring_type;
+        typedef geometry::model::referring_segment<point_type const> segment;
+
+        segment const p(turn.rob_pi, turn.rob_pj);
+        segment const q(turn.rob_qi, turn.rob_qj);
+
+        typedef typename boost::range_iterator<ring_type const>::type iterator_type;
+        iterator_type it = boost::begin(piece.robust_ring);
+        iterator_type end = boost::end(piece.robust_ring);
+
+        // A robust ring is always closed, and always clockwise
+        for (iterator_type previous = it++; it != end; ++previous, ++it)
+        {
+            geometry::equal_to<point_type> comparator;
+            if (comparator(*previous, *it))
+            {
+                // Points are the same
+                continue;
+            }
+
+            segment r(*previous, *it);
+
+            int const side = strategy::side::side_of_intersection::apply(p, q, r,
+                        turn.robust_point);
+
+            if (side == 1)
+            {
+                // IP is left of segment, so it is outside
+                return -1; // outside
+            }
+            else if (side == 0)
+            {
+                // IP is collinear with segment. TODO: we should analyze this further
+                // For now we use the fallback point
+                if (in_box(*previous, *it, turn.robust_point))
+                {
+                    return 0;
+                }
+                else
+                {
+                    return -1; // outside
+                }
+            }
+        }
+        return 1; // inside
+    }
+#endif
+
+
+public:
+
+    inline turn_in_piece_visitor(Turns& turns, Pieces const& pieces)
+        : m_turns(turns)
+        , m_pieces(pieces)
+    {}
+
+    template <typename Turn, typename Piece>
+    inline bool apply(Turn const& turn, Piece const& piece, bool first = true)
+    {
+        boost::ignore_unused_variable_warning(first);
+
+        if (turn.count_within > 0)
+        {
+            // Already inside - no need to check again
+            return true;
+        }
+
+        if (piece.type == strategy::buffer::buffered_flat_end
+            || piece.type == strategy::buffer::buffered_concave)
+        {
+            // Turns cannot be located within flat-end or concave pieces
+            return true;
+        }
+
+        if (! geometry::covered_by(turn.robust_point, piece.robust_envelope))
+        {
+            // Easy check: if the turn is not in the envelope, we can safely return
+            return true;
+        }
+
+        if (skip(turn.operations[0], piece) || skip(turn.operations[1], piece))
+        {
+            return true;
+        }
+
+        // TODO: mutable_piece to make some on-demand preparations in analyse
+        Turn& mutable_turn = m_turns[turn.turn_index];
+
+        if (piece.type == geometry::strategy::buffer::buffered_point)
+        {
+            // Optimization for buffer around points: if distance from center
+            // is not between min/max radius, the result is clear
+            typedef typename default_comparable_distance_result
+                <
+                    typename Turn::robust_point_type
+                >::type distance_type;
+
+            distance_type const cd
+                = geometry::comparable_distance(piece.robust_center,
+                        turn.robust_point);
+
+            if (cd < piece.robust_min_comparable_radius)
+            {
+                mutable_turn.count_within++;
+                return true;
+            }
+            if (cd > piece.robust_max_comparable_radius)
+            {
+                return true;
+            }
+        }
+
+        analyse_result analyse_code =
+            piece.type == geometry::strategy::buffer::buffered_point
+                ? analyse_turn_wrt_point_piece::apply(turn, piece)
+                : analyse_turn_wrt_piece::apply(turn, piece);
+
+        switch(analyse_code)
+        {
+            case analyse_disjoint :
+                return true;
+            case analyse_on_offsetted :
+                mutable_turn.count_on_offsetted++; // value is not used anymore
+                return true;
+            case analyse_on_original_boundary :
+                mutable_turn.count_on_original_boundary++;
+                return true;
+            case analyse_within :
+                mutable_turn.count_within++;
+                return true;
+#if ! defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+            case analyse_near_offsetted :
+                mutable_turn.count_within_near_offsetted++;
+                return true;
+#endif
+            default :
+                break;
+        }
+
+#if defined(BOOST_GEOMETRY_BUFFER_USE_SIDE_OF_INTERSECTION)
+        // We don't know (yet)
+        int geometry_code = 0;
+        if (piece.is_convex)
+        {
+            geometry_code = turn_in_convex_piece(turn, piece);
+        }
+        else
+        {
+
+            // TODO: this point_in_geometry is a performance-bottleneck here and
+            // will be replaced completely by extending analyse_piece functionality
+            geometry_code = detail::within::point_in_geometry(turn.robust_point, piece.robust_ring);
+        }
+#else
+        int geometry_code = detail::within::point_in_geometry(turn.robust_point, piece.robust_ring);
+#endif
+
+        if (geometry_code == 1)
+        {
+            mutable_turn.count_within++;
+        }
+
+        return true;
+    }
+};
+
+
+}} // namespace detail::buffer
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_BUFFER_TURN_IN_PIECE_VISITOR
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/calculate_null.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/calculate_null.hpp
new file mode 100644
index 00000000000..3ebca835069
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/calculate_null.hpp
@@ -0,0 +1,38 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_CALCULATE_NULL_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_CALCULATE_NULL_HPP
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+struct calculate_null
+{
+    template<typename ReturnType, typename Geometry, typename Strategy>
+    static inline ReturnType apply(Geometry const& , Strategy const&)
+    {
+        return ReturnType();
+    }
+};
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_CALCULATE_NULL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/calculate_sum.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/calculate_sum.hpp
new file mode 100644
index 00000000000..732a2f57533
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/calculate_sum.hpp
@@ -0,0 +1,62 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2016.
+// Modifications copyright (c) 2016 Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_CALCULATE_SUM_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_CALCULATE_SUM_HPP
+
+#include <boost/range.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+
+class calculate_polygon_sum
+{
+    template <typename ReturnType, typename Policy, typename Rings, typename Strategy>
+    static inline ReturnType sum_interior_rings(Rings const& rings, Strategy const& strategy)
+    {
+        ReturnType sum = ReturnType(0);
+        for (typename boost::range_iterator<Rings const>::type
+                it = boost::begin(rings); it != boost::end(rings); ++it)
+        {
+            sum += Policy::apply(*it, strategy);
+        }
+        return sum;
+    }
+
+public :
+    template <typename ReturnType, typename Policy, typename Polygon, typename Strategy>
+    static inline ReturnType apply(Polygon const& poly, Strategy const& strategy)
+    {
+        return Policy::apply(exterior_ring(poly), strategy)
+            + sum_interior_rings<ReturnType, Policy>(interior_rings(poly), strategy)
+            ;
+    }
+};
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_CALCULATE_SUM_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/centroid/translating_transformer.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/centroid/translating_transformer.hpp
new file mode 100644
index 00000000000..56a7e3ec914
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/centroid/translating_transformer.hpp
@@ -0,0 +1,119 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_CENTROID_TRANSLATING_TRANSFORMER_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_CENTROID_TRANSLATING_TRANSFORMER_HPP
+
+
+#include <cstddef>
+
+#include <boost/core/addressof.hpp>
+#include <boost/core/ref.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/arithmetic/arithmetic.hpp>
+
+#include <boost/geometry/iterators/point_iterator.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace centroid
+{
+
+
+// NOTE: There is no need to translate in other coordinate systems than
+// cartesian. But if it was needed then one should translate using
+// CS-specific technique, e.g. in spherical/geographic a translation
+// vector should contain coordinates being multiplies of 2PI or 360 deg.
+template <typename Geometry,
+          typename CastedTag = typename tag_cast
+                                <
+                                    typename tag<Geometry>::type,
+                                    areal_tag
+                                >::type,
+    typename CSTag = typename cs_tag<Geometry>::type>
+struct translating_transformer
+{
+    typedef typename geometry::point_type<Geometry>::type point_type;
+    typedef boost::reference_wrapper<point_type const> result_type;
+
+    explicit translating_transformer(Geometry const&) {}
+    explicit translating_transformer(point_type const&) {}
+
+    result_type apply(point_type const& pt) const
+    {
+        return result_type(pt);
+    }
+
+    template <typename ResPt>
+    void apply_reverse(ResPt &) const {}
+};
+
+// Specialization for Areal Geometries in cartesian CS
+template <typename Geometry>
+struct translating_transformer<Geometry, areal_tag, cartesian_tag>
+{
+    typedef typename geometry::point_type<Geometry>::type point_type;
+    typedef point_type result_type;
+    
+    explicit translating_transformer(Geometry const& geom)
+        : m_origin(NULL)
+    {
+        geometry::point_iterator<Geometry const>
+            pt_it = geometry::points_begin(geom);
+        if ( pt_it != geometry::points_end(geom) )
+        {
+            m_origin = boost::addressof(*pt_it);
+        }
+    }
+
+    explicit translating_transformer(point_type const& origin)
+        : m_origin(boost::addressof(origin))
+    {}
+
+    result_type apply(point_type const& pt) const
+    {
+        point_type res = pt;
+        if ( m_origin )
+            geometry::subtract_point(res, *m_origin);
+        return res;
+    }
+
+    template <typename ResPt>
+    void apply_reverse(ResPt & res_pt) const
+    {
+        if ( m_origin )
+            geometry::add_point(res_pt, *m_origin);
+    }
+
+    const point_type * m_origin;
+};
+
+
+}} // namespace detail::centroid
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_CENTROID_TRANSLATING_TRANSFORMER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/check_iterator_range.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/check_iterator_range.hpp
new file mode 100644
index 00000000000..9bd1d7ae27e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/check_iterator_range.hpp
@@ -0,0 +1,71 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_CHECK_ITERATOR_RANGE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_CHECK_ITERATOR_RANGE_HPP
+
+#include <boost/core/ignore_unused.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+// Check whether (each element of) an iterator range satisfies a given
+// predicate.
+// The predicate must be implemented as having a static apply unary
+// method that returns a bool.
+// By default an empty range is accepted
+template <typename Predicate, bool AllowEmptyRange = true>
+struct check_iterator_range
+{
+    template <typename InputIterator>
+    static inline bool apply(InputIterator first, InputIterator beyond)
+    {
+        for (InputIterator it = first; it != beyond; ++it)
+        {
+            if (! Predicate::apply(*it))
+            {
+                return false;
+            }
+        }
+        return AllowEmptyRange || first != beyond;
+    }
+
+
+    // version where we can pass a predicate object
+    template <typename InputIterator>
+    static inline bool apply(InputIterator first,
+                             InputIterator beyond,
+                             Predicate const& predicate)
+    {
+        // in case predicate's apply method is static, MSVC will
+        // complain that predicate is not used
+        boost::ignore_unused(predicate);
+
+        for (InputIterator it = first; it != beyond; ++it)
+        {
+            if (! predicate.apply(*it))
+            {
+                return false;
+            }
+        }
+        return AllowEmptyRange || first != beyond;
+    }
+};
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_CHECK_ITERATOR_RANGE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/closest_feature/geometry_to_range.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/closest_feature/geometry_to_range.hpp
new file mode 100644
index 00000000000..4ac5ac69769
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/closest_feature/geometry_to_range.hpp
@@ -0,0 +1,145 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_CLOSEST_FEATURE_GEOMETRY_TO_RANGE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_CLOSEST_FEATURE_GEOMETRY_TO_RANGE_HPP
+
+#include <iterator>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace closest_feature
+{
+
+
+
+// returns the range iterator the realizes the closest
+// distance between the geometry and the element of the range
+class geometry_to_range
+{
+private:
+    template
+    <
+        typename Geometry,
+        typename RangeIterator,
+        typename Strategy,
+        typename Distance
+    >
+    static inline void apply(Geometry const& geometry,
+                             RangeIterator first,
+                             RangeIterator last,
+                             Strategy const& strategy,
+                             RangeIterator& it_min,
+                             Distance& dist_min)
+    {
+        BOOST_GEOMETRY_ASSERT( first != last );
+
+        Distance const zero = Distance(0);
+
+        // start with first distance
+        it_min = first;
+        dist_min = dispatch::distance
+            <
+                Geometry,
+                typename std::iterator_traits<RangeIterator>::value_type,
+                Strategy
+            >::apply(geometry, *it_min, strategy);
+
+        // check if other elements in the range are closer
+        for (RangeIterator it = ++first; it != last; ++it)
+        {
+            Distance dist = dispatch::distance
+                <
+                    Geometry,
+                    typename std::iterator_traits<RangeIterator>::value_type,
+                    Strategy
+                >::apply(geometry, *it, strategy);
+
+            if (geometry::math::equals(dist, zero))
+            {
+                dist_min = dist;
+                it_min = it;
+                return;
+            }
+            else if (dist < dist_min)
+            {
+                dist_min = dist;
+                it_min = it;
+            }
+        }
+    }
+
+public:
+    template
+    <
+        typename Geometry,
+        typename RangeIterator,
+        typename Strategy,
+        typename Distance
+    >    
+    static inline RangeIterator apply(Geometry const& geometry,
+                                      RangeIterator first,
+                                      RangeIterator last,
+                                      Strategy const& strategy,
+                                      Distance& dist_min)
+    {
+        RangeIterator it_min;
+        apply(geometry, first, last, strategy, it_min, dist_min);
+
+        return it_min;
+    }
+
+
+    template
+    <
+        typename Geometry,
+        typename RangeIterator,
+        typename Strategy
+    >    
+    static inline RangeIterator apply(Geometry const& geometry,
+                                      RangeIterator first,
+                                      RangeIterator last,
+                                      Strategy const& strategy)
+    {
+        typename strategy::distance::services::return_type
+            <
+                Strategy,
+                typename point_type<Geometry>::type,
+                typename point_type
+                    <
+                        typename std::iterator_traits
+                            <
+                                RangeIterator
+                            >::value_type
+                    >::type
+            >::type dist_min;
+
+        return apply(geometry, first, last, strategy, dist_min);
+    }
+};
+
+
+
+}} // namespace detail::closest_feature
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_CLOSEST_FEATURE_GEOMETRY_TO_RANGE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/closest_feature/point_to_range.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/closest_feature/point_to_range.hpp
new file mode 100644
index 00000000000..df678901386
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/closest_feature/point_to_range.hpp
@@ -0,0 +1,250 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_CLOSEST_FEATURE_POINT_TO_RANGE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_CLOSEST_FEATURE_POINT_TO_RANGE_HPP
+
+#include <utility>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/util/math.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace closest_feature
+{
+
+
+// returns the segment (pair of iterators) that realizes the closest
+// distance of the point to the range
+template
+<
+    typename Point,
+    typename Range,
+    closure_selector Closure,
+    typename Strategy
+>
+class point_to_point_range
+{
+protected:
+    typedef typename boost::range_iterator<Range const>::type iterator_type;
+
+    template <typename Distance>
+    static inline void apply(Point const& point,
+                             iterator_type first,
+                             iterator_type last,
+                             Strategy const& strategy,
+                             iterator_type& it_min1,
+                             iterator_type& it_min2,
+                             Distance& dist_min)
+    {
+        BOOST_GEOMETRY_ASSERT( first != last );
+
+        Distance const zero = Distance(0);
+
+        iterator_type it = first;
+        iterator_type prev = it++;
+        if (it == last)
+        {
+            it_min1 = it_min2 = first;
+            dist_min = strategy.apply(point, *first, *first);
+            return;
+        }
+
+        // start with first segment distance
+        dist_min = strategy.apply(point, *prev, *it);
+        iterator_type prev_min_dist = prev;
+
+        // check if other segments are closer
+        for (++prev, ++it; it != last; ++prev, ++it)
+        {
+            Distance dist = strategy.apply(point, *prev, *it);
+            if (geometry::math::equals(dist, zero))
+            {
+                dist_min = zero;
+                it_min1 = prev;
+                it_min2 = it;
+                return;
+            }
+            else if (dist < dist_min)
+            {
+                dist_min = dist;
+                prev_min_dist = prev;
+            }
+        }
+
+        it_min1 = it_min2 = prev_min_dist;
+        ++it_min2;
+    }
+
+public:
+    typedef typename std::pair<iterator_type, iterator_type> return_type;
+
+    template <typename Distance>
+    static inline return_type apply(Point const& point,
+                                    iterator_type first,
+                                    iterator_type last,
+                                    Strategy const& strategy,
+                                    Distance& dist_min)
+    {
+        iterator_type it_min1, it_min2;
+        apply(point, first, last, strategy, it_min1, it_min2, dist_min);
+
+        return std::make_pair(it_min1, it_min2);
+    }
+
+    static inline return_type apply(Point const& point,
+                                    iterator_type first,
+                                    iterator_type last,
+                                    Strategy const& strategy)
+    {
+        typename strategy::distance::services::return_type
+            <
+                Strategy,
+                Point,
+                typename boost::range_value<Range>::type
+            >::type dist_min;
+
+        return apply(point, first, last, strategy, dist_min);
+    }
+
+    template <typename Distance>
+    static inline return_type apply(Point const& point,
+                                    Range const& range,
+                                    Strategy const& strategy,
+                                    Distance& dist_min)
+    {
+        return apply(point,
+                     boost::begin(range),
+                     boost::end(range),
+                     strategy,
+                     dist_min);
+    }
+
+    static inline return_type apply(Point const& point,
+                                    Range const& range,
+                                    Strategy const& strategy)
+    {
+        return apply(point, boost::begin(range), boost::end(range), strategy);
+    }
+};
+
+
+
+// specialization for open ranges
+template <typename Point, typename Range, typename Strategy>
+class point_to_point_range<Point, Range, open, Strategy>
+    : point_to_point_range<Point, Range, closed, Strategy>
+{
+private:
+    typedef point_to_point_range<Point, Range, closed, Strategy> base_type;
+    typedef typename base_type::iterator_type iterator_type;
+
+    template <typename Distance>
+    static inline void apply(Point const& point,
+                             iterator_type first,
+                             iterator_type last,
+                             Strategy const& strategy,
+                             iterator_type& it_min1,
+                             iterator_type& it_min2,
+                             Distance& dist_min)
+    {
+        BOOST_GEOMETRY_ASSERT( first != last );
+
+        base_type::apply(point, first, last, strategy,
+                         it_min1, it_min2, dist_min);
+
+        iterator_type it_back = --last;
+        Distance const zero = Distance(0);
+        Distance dist = strategy.apply(point, *it_back, *first);
+
+        if (geometry::math::equals(dist, zero))
+        {
+            dist_min = zero;
+            it_min1 = it_back;
+            it_min2 = first;
+        }
+        else if (dist < dist_min)
+        {
+            dist_min = dist;
+            it_min1 = it_back;
+            it_min2 = first;
+        }
+    }    
+
+public:
+    typedef typename std::pair<iterator_type, iterator_type> return_type;
+
+    template <typename Distance>
+    static inline return_type apply(Point const& point,
+                                    iterator_type first,
+                                    iterator_type last,
+                                    Strategy const& strategy,
+                                    Distance& dist_min)
+    {
+        iterator_type it_min1, it_min2;
+
+        apply(point, first, last, strategy, it_min1, it_min2, dist_min);
+
+        return std::make_pair(it_min1, it_min2);
+    }
+
+    static inline return_type apply(Point const& point,
+                                    iterator_type first,
+                                    iterator_type last,
+                                    Strategy const& strategy)
+    {
+        typedef typename strategy::distance::services::return_type
+            <
+                Strategy,
+                Point,
+                typename boost::range_value<Range>::type
+            >::type distance_return_type;
+
+        distance_return_type dist_min;
+
+        return apply(point, first, last, strategy, dist_min);
+    }
+
+    template <typename Distance>
+    static inline return_type apply(Point const& point,
+                                    Range const& range,
+                                    Strategy const& strategy,
+                                    Distance& dist_min)
+    {
+        return apply(point,
+                     boost::begin(range),
+                     boost::end(range),
+                     strategy,
+                     dist_min);
+    }
+
+    static inline return_type apply(Point const& point,
+                                    Range const& range,
+                                    Strategy const& strategy)
+    {
+        return apply(point, boost::begin(range), boost::end(range), strategy);
+    }
+};
+
+
+}} // namespace detail::closest_feature
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_CLOSEST_FEATURE_POINT_TO_RANGE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/closest_feature/range_to_range.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/closest_feature/range_to_range.hpp
new file mode 100644
index 00000000000..26b8684828f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/closest_feature/range_to_range.hpp
@@ -0,0 +1,196 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_CLOSEST_FEATURE_RANGE_TO_RANGE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_CLOSEST_FEATURE_RANGE_TO_RANGE_HPP
+
+#include <cstddef>
+
+#include <iterator>
+#include <utility>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+#include <boost/geometry/index/rtree.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace closest_feature
+{
+
+
+// returns a pair of a objects where the first is an object of the
+// r-tree range and the second an object of the query range that
+// realizes the closest feature of the two ranges
+class range_to_range_rtree
+{
+private:
+    template
+    <
+        typename RTreeRangeIterator,
+        typename QueryRangeIterator,
+        typename Strategy,
+        typename RTreeValueType,
+        typename Distance
+    >
+    static inline void apply(RTreeRangeIterator rtree_first,
+                             RTreeRangeIterator rtree_last,
+                             QueryRangeIterator queries_first,
+                             QueryRangeIterator queries_last,
+                             Strategy const& strategy,
+                             RTreeValueType& rtree_min,
+                             QueryRangeIterator& qit_min,
+                             Distance& dist_min)
+    {
+        typedef index::rtree<RTreeValueType, index::linear<8> > rtree_type;
+
+        BOOST_GEOMETRY_ASSERT( rtree_first != rtree_last );
+        BOOST_GEOMETRY_ASSERT( queries_first != queries_last );
+
+        Distance const zero = Distance(0);
+        dist_min = zero;
+
+        // create -- packing algorithm
+        rtree_type rt(rtree_first, rtree_last);
+
+        RTreeValueType t_v;
+        bool first = true;
+
+        for (QueryRangeIterator qit = queries_first;
+             qit != queries_last; ++qit, first = false)
+        {
+            std::size_t n = rt.query(index::nearest(*qit, 1), &t_v);
+
+            BOOST_GEOMETRY_ASSERT( n > 0 );
+            // n above is unused outside BOOST_GEOMETRY_ASSERT,
+            // hence the call to boost::ignore_unused below
+            //
+            // however, t_v (initialized by the call to rt.query(...))
+            // is used below, which is why we cannot put the call to
+            // rt.query(...) inside BOOST_GEOMETRY_ASSERT
+            boost::ignore_unused(n);
+
+            Distance dist = dispatch::distance
+                <
+                    RTreeValueType,
+                    typename std::iterator_traits
+                        <
+                            QueryRangeIterator
+                        >::value_type,
+                    Strategy
+                >::apply(t_v, *qit, strategy);
+
+            if (first || dist < dist_min)
+            {
+                dist_min = dist;
+                rtree_min = t_v;
+                qit_min = qit;
+                if ( math::equals(dist_min, zero) )
+                {
+                    return;
+                }
+            }
+        }
+    }
+
+public:
+    template <typename RTreeRangeIterator, typename QueryRangeIterator>
+    struct return_type
+    {
+        typedef std::pair
+            <
+                typename std::iterator_traits<RTreeRangeIterator>::value_type,
+                QueryRangeIterator
+            > type;
+    };
+
+
+    template
+    <
+        typename RTreeRangeIterator,
+        typename QueryRangeIterator,
+        typename Strategy,
+        typename Distance
+    >
+    static inline typename return_type
+        <
+            RTreeRangeIterator, QueryRangeIterator
+        >::type apply(RTreeRangeIterator rtree_first,
+                      RTreeRangeIterator rtree_last,
+                      QueryRangeIterator queries_first,
+                      QueryRangeIterator queries_last,
+                      Strategy const& strategy,
+                      Distance& dist_min)
+    {
+        typedef typename std::iterator_traits
+            <
+                RTreeRangeIterator
+            >::value_type rtree_value_type;
+
+        rtree_value_type rtree_min;
+        QueryRangeIterator qit_min;
+
+        apply(rtree_first, rtree_last, queries_first, queries_last,
+              strategy, rtree_min, qit_min, dist_min);
+
+        return std::make_pair(rtree_min, qit_min);        
+    }
+
+
+    template
+    <
+        typename RTreeRangeIterator,
+        typename QueryRangeIterator,
+        typename Strategy
+    >
+    static inline typename return_type
+        <
+            RTreeRangeIterator, QueryRangeIterator
+        >::type apply(RTreeRangeIterator rtree_first,
+                      RTreeRangeIterator rtree_last,
+                      QueryRangeIterator queries_first,
+                      QueryRangeIterator queries_last,
+                      Strategy const& strategy)
+    {
+        typedef typename std::iterator_traits
+            <
+                RTreeRangeIterator
+            >::value_type rtree_value_type;
+
+        typename strategy::distance::services::return_type
+            <
+                Strategy,
+                typename point_type<rtree_value_type>::type,
+                typename point_type
+                    <
+                        typename std::iterator_traits
+                            <
+                                QueryRangeIterator
+                            >::value_type
+                    >::type
+            >::type dist_min;
+
+        return apply(rtree_first, rtree_last, queries_first, queries_last,
+                     strategy, dist_min);
+    }
+};
+
+
+}} // namespace detail::closest_feature
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_CLOSEST_FEATURE_RANGE_TO_RANGE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/comparable_distance/implementation.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/comparable_distance/implementation.hpp
new file mode 100644
index 00000000000..b6eb7a27f1e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/comparable_distance/implementation.hpp
@@ -0,0 +1,24 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_COMPARABLE_DISTANCE_IMPLEMENTATION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_COMPARABLE_DISTANCE_IMPLEMENTATION_HPP
+
+#include <boost/geometry/algorithms/detail/distance/implementation.hpp>
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_COMPARABLE_DISTANCE_IMPLEMENTATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/comparable_distance/interface.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/comparable_distance/interface.hpp
new file mode 100644
index 00000000000..3e48a05ba93
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/comparable_distance/interface.hpp
@@ -0,0 +1,363 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_COMPARABLE_DISTANCE_INTERFACE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_COMPARABLE_DISTANCE_INTERFACE_HPP
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/strategies/comparable_distance_result.hpp>
+#include <boost/geometry/strategies/default_comparable_distance_result.hpp>
+#include <boost/geometry/strategies/distance.hpp>
+
+#include <boost/geometry/algorithms/detail/distance/interface.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace resolve_strategy
+{
+
+struct comparable_distance
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline
+    typename comparable_distance_result<Geometry1, Geometry2, Strategy>::type
+    apply(Geometry1 const& geometry1,
+          Geometry2 const& geometry2,
+          Strategy const& strategy)
+    {
+        typedef typename strategy::distance::services::comparable_type
+            <
+                Strategy
+            >::type comparable_strategy_type;
+
+        return dispatch::distance
+            <
+                Geometry1, Geometry2, comparable_strategy_type
+            >::apply(geometry1,
+                     geometry2,
+                     strategy::distance::services::get_comparable
+                         <
+                             Strategy
+                         >::apply(strategy));
+    }
+
+    template <typename Geometry1, typename Geometry2>
+    static inline typename comparable_distance_result
+        <
+            Geometry1, Geometry2, default_strategy
+        >::type
+    apply(Geometry1 const& geometry1,
+          Geometry2 const& geometry2,
+          default_strategy)
+    {
+        typedef typename strategy::distance::services::comparable_type
+            <
+                typename detail::distance::default_strategy
+                    <
+                        Geometry1, Geometry2
+                    >::type
+            >::type comparable_strategy_type;
+
+        return dispatch::distance
+            <
+                Geometry1, Geometry2, comparable_strategy_type
+            >::apply(geometry1, geometry2, comparable_strategy_type());
+    }
+};
+
+} // namespace resolve_strategy
+
+
+namespace resolve_variant
+{
+
+
+template <typename Geometry1, typename Geometry2>
+struct comparable_distance
+{
+    template <typename Strategy>
+    static inline
+    typename comparable_distance_result<Geometry1, Geometry2, Strategy>::type
+    apply(Geometry1 const& geometry1,
+          Geometry2 const& geometry2,
+          Strategy const& strategy)
+    {
+        return resolve_strategy::comparable_distance::apply(geometry1,
+                                                            geometry2,
+                                                            strategy);
+    }
+};
+
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
+struct comparable_distance
+    <
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>,
+        Geometry2
+    >
+{
+    template <typename Strategy>
+    struct visitor: static_visitor
+        <
+            typename comparable_distance_result
+                <
+                    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>,
+                    Geometry2,
+                    Strategy
+                >::type
+        >
+    {
+        Geometry2 const& m_geometry2;
+        Strategy const& m_strategy;
+
+        visitor(Geometry2 const& geometry2,
+                Strategy const& strategy)
+            : m_geometry2(geometry2),
+              m_strategy(strategy)
+        {}
+
+        template <typename Geometry1>
+        typename comparable_distance_result
+            <
+                Geometry1, Geometry2, Strategy
+            >::type
+        operator()(Geometry1 const& geometry1) const
+        {
+            return comparable_distance
+                <
+                    Geometry1,
+                    Geometry2
+                >::template apply
+                    <
+                        Strategy
+                    >(geometry1, m_geometry2, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline typename comparable_distance_result
+        <
+            boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>,
+            Geometry2,
+            Strategy
+        >::type
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
+          Geometry2 const& geometry2,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(geometry2, strategy), geometry1);
+    }
+};
+
+
+template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct comparable_distance
+    <
+        Geometry1,
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>
+    >
+{
+    template <typename Strategy>
+    struct visitor: static_visitor
+        <
+            typename comparable_distance_result
+                <
+                    Geometry1,
+                    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>,
+                    Strategy
+                >::type
+        >
+    {
+        Geometry1 const& m_geometry1;
+        Strategy const& m_strategy;
+
+        visitor(Geometry1 const& geometry1,
+                Strategy const& strategy)
+            : m_geometry1(geometry1),
+              m_strategy(strategy)
+        {}
+
+        template <typename Geometry2>
+        typename comparable_distance_result
+            <
+                Geometry1, Geometry2, Strategy
+            >::type
+        operator()(Geometry2 const& geometry2) const
+        {
+            return comparable_distance
+                <
+                    Geometry1,
+                    Geometry2
+                >::template apply
+                    <
+                        Strategy
+                    >(m_geometry1, geometry2, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline typename comparable_distance_result
+        <
+            Geometry1,
+            boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>,
+            Strategy
+        >::type
+    apply(Geometry1 const& geometry1,
+          boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(geometry1, strategy), geometry2);
+    }
+};
+
+
+template
+<
+    BOOST_VARIANT_ENUM_PARAMS(typename T1),
+    BOOST_VARIANT_ENUM_PARAMS(typename T2)
+>
+struct comparable_distance
+    <
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)>,
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)>
+    >
+{
+    template <typename Strategy>
+    struct visitor: static_visitor
+        <
+            typename comparable_distance_result
+                <
+                    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)>,
+                    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)>,
+                    Strategy
+                >::type
+        >
+    {
+        Strategy const& m_strategy;
+
+        visitor(Strategy const& strategy)
+            : m_strategy(strategy)
+        {}
+
+        template <typename Geometry1, typename Geometry2>
+        typename comparable_distance_result
+            <
+                Geometry1, Geometry2, Strategy
+            >::type
+        operator()(Geometry1 const& geometry1, Geometry2 const& geometry2) const
+        {
+            return comparable_distance
+                <
+                    Geometry1,
+                    Geometry2
+                >::template apply
+                    <
+                        Strategy
+                    >(geometry1, geometry2, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline typename comparable_distance_result
+        <
+            boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)>,
+            boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)>,
+            Strategy
+        >::type
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)> const& geometry1,
+          boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(strategy), geometry1, geometry2);
+    }
+};
+
+} // namespace resolve_variant
+
+
+
+/*!
+\brief \brief_calc2{comparable distance measurement} \brief_strategy
+\ingroup distance
+\details The free function comparable_distance does not necessarily calculate the distance,
+    but it calculates a distance measure such that two distances are comparable to each other.
+    For example: for the Cartesian coordinate system, Pythagoras is used but the square root
+    is not taken, which makes it faster and the results of two point pairs can still be
+    compared to each other.
+\tparam Geometry1 first geometry type
+\tparam Geometry2 second geometry type
+\tparam Strategy \tparam_strategy{Distance}
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param strategy \param_strategy{distance}
+\return \return_calc{comparable distance}
+
+\qbk{distinguish,with strategy}
+ */
+template <typename Geometry1, typename Geometry2, typename Strategy>
+inline typename comparable_distance_result<Geometry1, Geometry2, Strategy>::type
+comparable_distance(Geometry1 const& geometry1, Geometry2 const& geometry2,
+                    Strategy const& strategy)
+{
+    concepts::check<Geometry1 const>();
+    concepts::check<Geometry2 const>();
+
+    return resolve_variant::comparable_distance
+        <
+            Geometry1,
+            Geometry2
+        >::apply(geometry1, geometry2, strategy);
+}
+
+
+
+/*!
+\brief \brief_calc2{comparable distance measurement}
+\ingroup distance
+\details The free function comparable_distance does not necessarily calculate the distance,
+    but it calculates a distance measure such that two distances are comparable to each other.
+    For example: for the Cartesian coordinate system, Pythagoras is used but the square root
+    is not taken, which makes it faster and the results of two point pairs can still be
+    compared to each other.
+\tparam Geometry1 first geometry type
+\tparam Geometry2 second geometry type
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\return \return_calc{comparable distance}
+
+\qbk{[include reference/algorithms/comparable_distance.qbk]}
+ */
+template <typename Geometry1, typename Geometry2>
+inline typename default_comparable_distance_result<Geometry1, Geometry2>::type
+comparable_distance(Geometry1 const& geometry1, Geometry2 const& geometry2)
+{
+    concepts::check<Geometry1 const>();
+    concepts::check<Geometry2 const>();
+
+    return geometry::comparable_distance(geometry1, geometry2, default_strategy());
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_COMPARABLE_DISTANCE_INTERFACE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/convert_indexed_to_indexed.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/convert_indexed_to_indexed.hpp
new file mode 100644
index 00000000000..fccdf4bb1db
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/convert_indexed_to_indexed.hpp
@@ -0,0 +1,80 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_CONVERT_INDEXED_TO_INDEXED_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_CONVERT_INDEXED_TO_INDEXED_HPP
+
+
+#include <cstddef>
+
+#include <boost/numeric/conversion/cast.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace conversion
+{
+
+
+template
+<
+    typename Source,
+    typename Destination,
+    std::size_t Dimension,
+    std::size_t DimensionCount
+>
+struct indexed_to_indexed
+{
+    static inline void apply(Source const& source, Destination& destination)
+    {
+        typedef typename coordinate_type<Destination>::type coordinate_type;
+
+        geometry::set<min_corner, Dimension>(destination,
+            boost::numeric_cast<coordinate_type>(
+                geometry::get<min_corner, Dimension>(source)));
+        geometry::set<max_corner, Dimension>(destination,
+            boost::numeric_cast<coordinate_type>(
+                geometry::get<max_corner, Dimension>(source)));
+
+        indexed_to_indexed
+            <
+                Source, Destination,
+                Dimension + 1, DimensionCount
+            >::apply(source, destination);
+    }
+};
+
+template
+<
+    typename Source,
+    typename Destination,
+    std::size_t DimensionCount
+>
+struct indexed_to_indexed<Source, Destination, DimensionCount, DimensionCount>
+{
+    static inline void apply(Source const& , Destination& )
+    {}
+};
+
+
+}} // namespace detail::conversion
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_CONVERT_INDEXED_TO_INDEXED_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/convert_point_to_point.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/convert_point_to_point.hpp
new file mode 100644
index 00000000000..c7d37b6ca43
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/convert_point_to_point.hpp
@@ -0,0 +1,68 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_CONVERT_POINT_TO_POINT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_CONVERT_POINT_TO_POINT_HPP
+
+// Note: extracted from "convert.hpp" to avoid circular references convert/append
+
+#include <cstddef>
+
+#include <boost/numeric/conversion/cast.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace conversion
+{
+
+
+template <typename Source, typename Destination, std::size_t Dimension, std::size_t DimensionCount>
+struct point_to_point
+{
+    static inline void apply(Source const& source, Destination& destination)
+    {
+        typedef typename coordinate_type<Destination>::type coordinate_type;
+
+        set<Dimension>(destination, boost::numeric_cast<coordinate_type>(get<Dimension>(source)));
+        point_to_point<Source, Destination, Dimension + 1, DimensionCount>::apply(source, destination);
+    }
+};
+
+template <typename Source, typename Destination, std::size_t DimensionCount>
+struct point_to_point<Source, Destination, DimensionCount, DimensionCount>
+{
+    static inline void apply(Source const& , Destination& )
+    {}
+};
+
+
+template <typename Source, typename Destination>
+inline void convert_point_to_point(Source const& source, Destination& destination)
+{
+    point_to_point<Source, Destination, 0, dimension<Destination>::value>::apply(source, destination);
+}
+
+
+
+}} // namespace detail::conversion
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_CONVERT_POINT_TO_POINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/counting.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/counting.hpp
new file mode 100644
index 00000000000..dc5bb26c10b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/counting.hpp
@@ -0,0 +1,107 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_COUNTING_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_COUNTING_HPP
+
+#include <cstddef>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/algorithms/detail/interior_iterator.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace counting
+{
+
+
+template <std::size_t D>
+struct other_count
+{
+    template <typename Geometry>
+    static inline std::size_t apply(Geometry const&)
+    {
+        return D;
+    }
+
+    template <typename Geometry>
+    static inline std::size_t apply(Geometry const&, bool)
+    {
+        return D;
+    }
+};
+
+
+template <typename RangeCount>
+struct polygon_count
+{
+    template <typename Polygon>
+    static inline std::size_t apply(Polygon const& poly)
+    {
+        std::size_t n = RangeCount::apply(exterior_ring(poly));
+
+        typename interior_return_type<Polygon const>::type
+            rings = interior_rings(poly);
+        for (typename detail::interior_iterator<Polygon const>::type
+                it = boost::begin(rings); it != boost::end(rings); ++it)
+        {
+            n += RangeCount::apply(*it);
+        }
+
+        return n;
+    }
+};
+
+
+template <typename SingleCount>
+struct multi_count
+{
+    template <typename MultiGeometry>
+    static inline std::size_t apply(MultiGeometry const& geometry)
+    {
+        std::size_t n = 0;
+        for (typename boost::range_iterator<MultiGeometry const>::type
+                 it = boost::begin(geometry);
+             it != boost::end(geometry);
+             ++it)
+        {
+            n += SingleCount::apply(*it);
+        }
+        return n;
+    }
+};
+
+
+}} // namespace detail::counting
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_COUNTING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/course.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/course.hpp
new file mode 100644
index 00000000000..37424941bdd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/course.hpp
@@ -0,0 +1,40 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_COURSE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_COURSE_HPP
+
+#include <boost/geometry/algorithms/detail/azimuth.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+/// Calculate course (bearing) between two points.
+///
+/// NOTE: left for convenience and temporary backward compatibility
+template <typename ReturnType, typename Point1, typename Point2>
+inline ReturnType course(Point1 const& p1, Point2 const& p2)
+{
+    return azimuth<ReturnType>(p1, p2);
+}
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_COURSE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/covered_by/implementation.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/covered_by/implementation.hpp
new file mode 100644
index 00000000000..3df8b7783dc
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/covered_by/implementation.hpp
@@ -0,0 +1,280 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2013, 2014, 2017.
+// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_COVERED_BY_IMPLEMENTATION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_COVERED_BY_IMPLEMENTATION_HPP
+
+
+#include <cstddef>
+
+#include <boost/geometry/algorithms/detail/covered_by/interface.hpp>
+#include <boost/geometry/algorithms/detail/within/implementation.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace covered_by {
+
+struct use_point_in_geometry
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        return detail::within::point_in_geometry(geometry1, geometry2, strategy) >= 0;
+    }
+};
+
+struct use_relate
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        typedef typename detail::de9im::static_mask_covered_by_type
+            <
+                Geometry1, Geometry2
+            >::type covered_by_mask;
+        return geometry::relate(geometry1, geometry2, covered_by_mask(), strategy);
+    }
+};
+
+}} // namespace detail::covered_by
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Point, typename Box>
+struct covered_by<Point, Box, point_tag, box_tag>
+{
+    template <typename Strategy>
+    static inline bool apply(Point const& point, Box const& box, Strategy const& strategy)
+    {
+        ::boost::ignore_unused_variable_warning(strategy);
+        return strategy.apply(point, box);
+    }
+};
+
+template <typename Box1, typename Box2>
+struct covered_by<Box1, Box2, box_tag, box_tag>
+{
+    template <typename Strategy>
+    static inline bool apply(Box1 const& box1, Box2 const& box2, Strategy const& strategy)
+    {
+        assert_dimension_equal<Box1, Box2>();
+        ::boost::ignore_unused_variable_warning(strategy);
+        return strategy.apply(box1, box2);
+    }
+};
+
+
+// P/P
+
+template <typename Point1, typename Point2>
+struct covered_by<Point1, Point2, point_tag, point_tag>
+    : public detail::covered_by::use_point_in_geometry
+{};
+
+template <typename Point, typename MultiPoint>
+struct covered_by<Point, MultiPoint, point_tag, multi_point_tag>
+    : public detail::covered_by::use_point_in_geometry
+{};
+
+template <typename MultiPoint, typename Point>
+struct covered_by<MultiPoint, Point, multi_point_tag, point_tag>
+    : public detail::within::multi_point_point
+{};
+
+template <typename MultiPoint1, typename MultiPoint2>
+struct covered_by<MultiPoint1, MultiPoint2, multi_point_tag, multi_point_tag>
+    : public detail::within::multi_point_multi_point
+{};
+
+// P/L
+
+template <typename Point, typename Segment>
+struct covered_by<Point, Segment, point_tag, segment_tag>
+    : public detail::covered_by::use_point_in_geometry
+{};
+
+template <typename Point, typename Linestring>
+struct covered_by<Point, Linestring, point_tag, linestring_tag>
+    : public detail::covered_by::use_point_in_geometry
+{};
+
+template <typename Point, typename MultiLinestring>
+struct covered_by<Point, MultiLinestring, point_tag, multi_linestring_tag>
+    : public detail::covered_by::use_point_in_geometry
+{};
+
+template <typename MultiPoint, typename Segment>
+struct covered_by<MultiPoint, Segment, multi_point_tag, segment_tag>
+    : public detail::within::multi_point_single_geometry<false>
+{};
+
+template <typename MultiPoint, typename Linestring>
+struct covered_by<MultiPoint, Linestring, multi_point_tag, linestring_tag>
+    : public detail::within::multi_point_single_geometry<false>
+{};
+
+template <typename MultiPoint, typename MultiLinestring>
+struct covered_by<MultiPoint, MultiLinestring, multi_point_tag, multi_linestring_tag>
+    : public detail::within::multi_point_multi_geometry<false>
+{};
+
+// P/A
+
+template <typename Point, typename Ring>
+struct covered_by<Point, Ring, point_tag, ring_tag>
+    : public detail::covered_by::use_point_in_geometry
+{};
+
+template <typename Point, typename Polygon>
+struct covered_by<Point, Polygon, point_tag, polygon_tag>
+    : public detail::covered_by::use_point_in_geometry
+{};
+
+template <typename Point, typename MultiPolygon>
+struct covered_by<Point, MultiPolygon, point_tag, multi_polygon_tag>
+    : public detail::covered_by::use_point_in_geometry
+{};
+
+template <typename MultiPoint, typename Ring>
+struct covered_by<MultiPoint, Ring, multi_point_tag, ring_tag>
+    : public detail::within::multi_point_single_geometry<false>
+{};
+
+template <typename MultiPoint, typename Polygon>
+struct covered_by<MultiPoint, Polygon, multi_point_tag, polygon_tag>
+    : public detail::within::multi_point_single_geometry<false>
+{};
+
+template <typename MultiPoint, typename MultiPolygon>
+struct covered_by<MultiPoint, MultiPolygon, multi_point_tag, multi_polygon_tag>
+    : public detail::within::multi_point_multi_geometry<false>
+{};
+
+// L/L
+
+template <typename Linestring1, typename Linestring2>
+struct covered_by<Linestring1, Linestring2, linestring_tag, linestring_tag>
+    : public detail::covered_by::use_relate
+{};
+
+template <typename Linestring, typename MultiLinestring>
+struct covered_by<Linestring, MultiLinestring, linestring_tag, multi_linestring_tag>
+    : public detail::covered_by::use_relate
+{};
+
+template <typename MultiLinestring, typename Linestring>
+struct covered_by<MultiLinestring, Linestring, multi_linestring_tag, linestring_tag>
+    : public detail::covered_by::use_relate
+{};
+
+template <typename MultiLinestring1, typename MultiLinestring2>
+struct covered_by<MultiLinestring1, MultiLinestring2, multi_linestring_tag, multi_linestring_tag>
+    : public detail::covered_by::use_relate
+{};
+
+// L/A
+
+template <typename Linestring, typename Ring>
+struct covered_by<Linestring, Ring, linestring_tag, ring_tag>
+    : public detail::covered_by::use_relate
+{};
+
+template <typename MultiLinestring, typename Ring>
+struct covered_by<MultiLinestring, Ring, multi_linestring_tag, ring_tag>
+    : public detail::covered_by::use_relate
+{};
+
+template <typename Linestring, typename Polygon>
+struct covered_by<Linestring, Polygon, linestring_tag, polygon_tag>
+    : public detail::covered_by::use_relate
+{};
+
+template <typename MultiLinestring, typename Polygon>
+struct covered_by<MultiLinestring, Polygon, multi_linestring_tag, polygon_tag>
+    : public detail::covered_by::use_relate
+{};
+
+template <typename Linestring, typename MultiPolygon>
+struct covered_by<Linestring, MultiPolygon, linestring_tag, multi_polygon_tag>
+    : public detail::covered_by::use_relate
+{};
+
+template <typename MultiLinestring, typename MultiPolygon>
+struct covered_by<MultiLinestring, MultiPolygon, multi_linestring_tag, multi_polygon_tag>
+    : public detail::covered_by::use_relate
+{};
+
+// A/A
+
+template <typename Ring1, typename Ring2>
+struct covered_by<Ring1, Ring2, ring_tag, ring_tag>
+    : public detail::covered_by::use_relate
+{};
+
+template <typename Ring, typename Polygon>
+struct covered_by<Ring, Polygon, ring_tag, polygon_tag>
+    : public detail::covered_by::use_relate
+{};
+
+template <typename Polygon, typename Ring>
+struct covered_by<Polygon, Ring, polygon_tag, ring_tag>
+    : public detail::covered_by::use_relate
+{};
+
+template <typename Polygon1, typename Polygon2>
+struct covered_by<Polygon1, Polygon2, polygon_tag, polygon_tag>
+    : public detail::covered_by::use_relate
+{};
+
+template <typename Ring, typename MultiPolygon>
+struct covered_by<Ring, MultiPolygon, ring_tag, multi_polygon_tag>
+    : public detail::covered_by::use_relate
+{};
+
+template <typename MultiPolygon, typename Ring>
+struct covered_by<MultiPolygon, Ring, multi_polygon_tag, ring_tag>
+    : public detail::covered_by::use_relate
+{};
+
+template <typename Polygon, typename MultiPolygon>
+struct covered_by<Polygon, MultiPolygon, polygon_tag, multi_polygon_tag>
+    : public detail::covered_by::use_relate
+{};
+
+template <typename MultiPolygon, typename Polygon>
+struct covered_by<MultiPolygon, Polygon, multi_polygon_tag, polygon_tag>
+    : public detail::covered_by::use_relate
+{};
+
+template <typename MultiPolygon1, typename MultiPolygon2>
+struct covered_by<MultiPolygon1, MultiPolygon2, multi_polygon_tag, multi_polygon_tag>
+    : public detail::covered_by::use_relate
+{};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_COVERED_BY_IMPLEMENTATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/covered_by/interface.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/covered_by/interface.hpp
new file mode 100644
index 00000000000..65990782107
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/covered_by/interface.hpp
@@ -0,0 +1,261 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2013, 2014, 2017.
+// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_COVERED_BY_INTERFACE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_COVERED_BY_INTERFACE_HPP
+
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/detail/within/interface.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/strategies/cartesian/point_in_box.hpp>
+#include <boost/geometry/strategies/cartesian/box_in_box.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename Tag1 = typename tag<Geometry1>::type,
+    typename Tag2 = typename tag<Geometry2>::type
+>
+struct covered_by
+    : not_implemented<Tag1, Tag2>
+{};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_strategy {
+
+struct covered_by
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        concepts::within::check
+            <
+                typename tag<Geometry1>::type,
+                typename tag<Geometry2>::type,
+                typename tag_cast<typename tag<Geometry2>::type, areal_tag>::type,
+                Strategy
+            >();
+        concepts::check<Geometry1 const>();
+        concepts::check<Geometry2 const>();
+        assert_dimension_equal<Geometry1, Geometry2>();
+
+        return dispatch::covered_by<Geometry1, Geometry2>::apply(geometry1,
+                                                                 geometry2,
+                                                                 strategy);
+    }
+
+    template <typename Geometry1, typename Geometry2>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             default_strategy)
+    {
+        typedef typename strategy::covered_by::services::default_strategy
+            <
+                Geometry1,
+                Geometry2
+            >::type strategy_type;
+
+        return covered_by::apply(geometry1, geometry2, strategy_type());
+    }
+};
+
+} // namespace resolve_strategy
+
+
+namespace resolve_variant {
+
+template <typename Geometry1, typename Geometry2>
+struct covered_by
+{
+    template <typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        return resolve_strategy::covered_by
+                               ::apply(geometry1, geometry2, strategy);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
+struct covered_by<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
+{
+    template <typename Strategy>
+    struct visitor: boost::static_visitor<bool>
+    {
+        Geometry2 const& m_geometry2;
+        Strategy const& m_strategy;
+
+        visitor(Geometry2 const& geometry2, Strategy const& strategy)
+        : m_geometry2(geometry2), m_strategy(strategy) {}
+
+        template <typename Geometry1>
+        bool operator()(Geometry1 const& geometry1) const
+        {
+            return covered_by<Geometry1, Geometry2>
+                   ::apply(geometry1, m_geometry2, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline bool
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
+          Geometry2 const& geometry2,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(geometry2, strategy), geometry1);
+    }
+};
+
+template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct covered_by<Geometry1, boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Strategy>
+    struct visitor: boost::static_visitor<bool>
+    {
+        Geometry1 const& m_geometry1;
+        Strategy const& m_strategy;
+
+        visitor(Geometry1 const& geometry1, Strategy const& strategy)
+        : m_geometry1(geometry1), m_strategy(strategy) {}
+
+        template <typename Geometry2>
+        bool operator()(Geometry2 const& geometry2) const
+        {
+            return covered_by<Geometry1, Geometry2>
+                   ::apply(m_geometry1, geometry2, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline bool
+    apply(Geometry1 const& geometry1,
+          boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(geometry1, strategy), geometry2);
+    }
+};
+
+template <
+    BOOST_VARIANT_ENUM_PARAMS(typename T1),
+    BOOST_VARIANT_ENUM_PARAMS(typename T2)
+>
+struct covered_by<
+    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)>,
+    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)>
+>
+{
+    template <typename Strategy>
+    struct visitor: boost::static_visitor<bool>
+    {
+        Strategy const& m_strategy;
+
+        visitor(Strategy const& strategy): m_strategy(strategy) {}
+
+        template <typename Geometry1, typename Geometry2>
+        bool operator()(Geometry1 const& geometry1,
+                        Geometry2 const& geometry2) const
+        {
+            return covered_by<Geometry1, Geometry2>
+                   ::apply(geometry1, geometry2, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline bool
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)> const& geometry1,
+          boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(strategy), geometry1, geometry2);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief \brief_check12{is inside or on border}
+\ingroup covered_by
+\details \details_check12{covered_by, is inside or on border}.
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry which might be inside or on the border of the second geometry
+\param geometry2 \param_geometry which might cover the first geometry
+\return true if geometry1 is inside of or on the border of geometry2,
+    else false
+\note The default strategy is used for covered_by detection
+
+\qbk{[include reference/algorithms/covered_by.qbk]}
+
+ */
+template<typename Geometry1, typename Geometry2>
+inline bool covered_by(Geometry1 const& geometry1, Geometry2 const& geometry2)
+{
+    return resolve_variant::covered_by<Geometry1, Geometry2>
+                          ::apply(geometry1, geometry2, default_strategy());
+}
+
+/*!
+\brief \brief_check12{is inside or on border} \brief_strategy
+\ingroup covered_by
+\details \details_check12{covered_by, is inside or on border}, \brief_strategy. \details_strategy_reasons
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry which might be inside or on the border of the second geometry
+\param geometry2 \param_geometry which might cover the first geometry
+\param strategy strategy to be used
+\return true if geometry1 is inside of or on the border of geometry2,
+    else false
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/covered_by.qbk]}
+
+*/
+template<typename Geometry1, typename Geometry2, typename Strategy>
+inline bool covered_by(Geometry1 const& geometry1, Geometry2 const& geometry2,
+        Strategy const& strategy)
+{
+    return resolve_variant::covered_by<Geometry1, Geometry2>
+                          ::apply(geometry1, geometry2, strategy);
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_COVERED_BY_INTERFACE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/direction_code.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/direction_code.hpp
new file mode 100644
index 00000000000..c5c52211095
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/direction_code.hpp
@@ -0,0 +1,256 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2015, 2017.
+// Modifications copyright (c) 2015-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DIRECITON_CODE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DIRECITON_CODE_HPP
+
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/select_coordinate_type.hpp>
+#include <boost/geometry/util/normalize_spheroidal_coordinates.hpp>
+
+#include <boost/mpl/assert.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+
+// TODO: remove
+template <std::size_t Index, typename Point1, typename Point2>
+inline int sign_of_difference(Point1 const& point1, Point2 const& point2)
+{
+    return
+        math::equals(geometry::get<Index>(point1), geometry::get<Index>(point2))
+        ?
+        0
+        :
+        (geometry::get<Index>(point1) > geometry::get<Index>(point2) ? 1 : -1);
+}
+
+
+template <typename Point, typename CSTag = typename cs_tag<Point>::type>
+struct direction_code_impl
+{
+    BOOST_MPL_ASSERT_MSG((false), NOT_IMPLEMENTED_FOR_THIS_CS, (CSTag));
+};
+
+template <typename Point>
+struct direction_code_impl<Point, cartesian_tag>
+{
+    template <typename Point1, typename Point2>
+    static inline int apply(Point1 const& segment_a, Point1 const& segment_b,
+                            Point2 const& p)
+    {
+        typedef typename geometry::select_coordinate_type
+            <
+                Point1, Point2
+            >::type calc_t;
+
+        if ( (math::equals(geometry::get<0>(segment_b), geometry::get<0>(segment_a))
+           && math::equals(geometry::get<1>(segment_b), geometry::get<1>(segment_a)))
+          || (math::equals(geometry::get<0>(segment_b), geometry::get<0>(p))
+           && math::equals(geometry::get<1>(segment_b), geometry::get<1>(p))) )
+        {
+            return 0;
+        }
+
+        calc_t x1 = geometry::get<0>(segment_b) - geometry::get<0>(segment_a);
+        calc_t y1 = geometry::get<1>(segment_b) - geometry::get<1>(segment_a);
+        calc_t x2 = geometry::get<0>(segment_b) - geometry::get<0>(p);
+        calc_t y2 = geometry::get<1>(segment_b) - geometry::get<1>(p);
+
+        calc_t ax = (std::min)(math::abs(x1), math::abs(x2));
+        calc_t ay = (std::min)(math::abs(y1), math::abs(y2));
+
+        int s1 = 0, s2 = 0;
+        if (ax >= ay)
+        {
+            s1 = x1 > 0 ? 1 : -1;
+            s2 = x2 > 0 ? 1 : -1;
+        }
+        else
+        {
+            s1 = y1 > 0 ? 1 : -1;
+            s2 = y2 > 0 ? 1 : -1;
+        }
+
+        return s1 == s2 ? -1 : 1;
+    }
+};
+
+template <typename Point>
+struct direction_code_impl<Point, spherical_equatorial_tag>
+{
+    template <typename Point1, typename Point2>
+    static inline int apply(Point1 const& segment_a, Point1 const& segment_b,
+                            Point2 const& p)
+    {
+        typedef typename coordinate_type<Point1>::type coord1_t;
+        typedef typename coordinate_type<Point2>::type coord2_t;
+        typedef typename coordinate_system<Point1>::type::units units_t;
+        typedef typename coordinate_system<Point2>::type::units units2_t;
+        BOOST_MPL_ASSERT_MSG((boost::is_same<units_t, units2_t>::value),
+                             NOT_IMPLEMENTED_FOR_DIFFERENT_UNITS,
+                             (units_t, units2_t));
+
+        typedef typename geometry::select_coordinate_type <Point1, Point2>::type calc_t;
+        typedef math::detail::constants_on_spheroid<coord1_t, units_t> constants1;
+        typedef math::detail::constants_on_spheroid<coord2_t, units_t> constants2;
+        typedef math::detail::constants_on_spheroid<calc_t, units_t> constants;
+
+        coord1_t const a0 = geometry::get<0>(segment_a);
+        coord1_t const a1 = geometry::get<1>(segment_a);
+        coord1_t const b0 = geometry::get<0>(segment_b);
+        coord1_t const b1 = geometry::get<1>(segment_b);
+        coord2_t const p0 = geometry::get<0>(p);
+        coord2_t const p1 = geometry::get<1>(p);
+        coord1_t const pi_half1 = constants1::max_latitude();
+        coord2_t const pi_half2 = constants2::max_latitude();
+        calc_t const pi = constants::half_period();
+        calc_t const pi_half = constants::max_latitude();
+        calc_t const c0 = 0;
+        
+        if ( (math::equals(b0, a0) && math::equals(b1, a1))
+          || (math::equals(b0, p0) && math::equals(b1, p1)) )
+        {
+            return 0;
+        }
+
+        bool const is_a_pole = math::equals(pi_half1, math::abs(a1));
+        bool const is_b_pole = math::equals(pi_half1, math::abs(b1));
+        bool const is_p_pole = math::equals(pi_half2, math::abs(p1));
+
+        if ( is_b_pole && ((is_a_pole && math::sign(b1) == math::sign(a1))
+                        || (is_p_pole && math::sign(b1) == math::sign(p1))) )
+        {
+            return 0;
+        }
+
+        // NOTE: as opposed to the implementation for cartesian CS
+        // here point b is the origin
+
+        calc_t const dlon1 = math::longitude_distance_signed<units_t>(b0, a0);
+        calc_t const dlon2 = math::longitude_distance_signed<units_t>(b0, p0);
+
+        bool is_antilon1 = false, is_antilon2 = false;
+        calc_t const dlat1 = latitude_distance_signed(b1, a1, dlon1, pi, is_antilon1);
+        calc_t const dlat2 = latitude_distance_signed(b1, p1, dlon2, pi, is_antilon2);
+
+        calc_t mx = is_a_pole || is_b_pole || is_p_pole ?
+                    c0 :
+                    (std::min)(is_antilon1 ? c0 : math::abs(dlon1),
+                               is_antilon2 ? c0 : math::abs(dlon2));
+        calc_t my = (std::min)(math::abs(dlat1),
+                               math::abs(dlat2));
+
+        int s1 = 0, s2 = 0;
+        if (mx >= my)
+        {
+            s1 = dlon1 > 0 ? 1 : -1;
+            s2 = dlon2 > 0 ? 1 : -1;
+        }
+        else
+        {
+            s1 = dlat1 > 0 ? 1 : -1;
+            s2 = dlat2 > 0 ? 1 : -1;
+        }
+
+        return s1 == s2 ? -1 : 1;
+    }
+
+    template <typename T>
+    static inline T latitude_distance_signed(T const& lat1, T const& lat2, T const& lon_ds, T const& pi, bool & is_antilon)
+    {
+        T const c0 = 0;
+
+        T res = lat2 - lat1;
+
+        is_antilon = math::equals(math::abs(lon_ds), pi);
+        if (is_antilon)
+        {
+            res = lat2 + lat1;
+            if (res >= c0)
+                res = pi - res;
+            else
+                res = -pi - res;
+        }
+
+        return res;
+    }
+};
+
+template <typename Point>
+struct direction_code_impl<Point, spherical_polar_tag>
+{
+    template <typename Point1, typename Point2>
+    static inline int apply(Point1 segment_a, Point1 segment_b,
+                            Point2 p)
+    {
+        typedef math::detail::constants_on_spheroid
+            <
+                typename coordinate_type<Point1>::type,
+                typename coordinate_system<Point1>::type::units
+            > constants1;
+        typedef math::detail::constants_on_spheroid
+            <
+                typename coordinate_type<Point2>::type,
+                typename coordinate_system<Point2>::type::units
+            > constants2;
+
+        geometry::set<1>(segment_a,
+            constants1::max_latitude() - geometry::get<1>(segment_a));
+        geometry::set<1>(segment_b,
+            constants1::max_latitude() - geometry::get<1>(segment_b));
+        geometry::set<1>(p,
+            constants2::max_latitude() - geometry::get<1>(p));
+
+        return direction_code_impl
+                <
+                    Point, spherical_equatorial_tag
+                >::apply(segment_a, segment_b, p);
+    }
+};
+
+template <typename Point>
+struct direction_code_impl<Point, geographic_tag>
+    : direction_code_impl<Point, spherical_equatorial_tag>
+{};
+
+// Gives sense of direction for point p, collinear w.r.t. segment (a,b)
+// Returns -1 if p goes backward w.r.t (a,b), so goes from b in direction of a
+// Returns 1 if p goes forward, so extends (a,b)
+// Returns 0 if p is equal with b, or if (a,b) is degenerate
+// Note that it does not do any collinearity test, that should be done before
+template <typename Point1, typename Point2>
+inline int direction_code(Point1 const& segment_a, Point1 const& segment_b,
+                          Point2 const& p)
+{
+    return direction_code_impl<Point1>::apply(segment_a, segment_b, p);
+}
+
+
+} // namespace detail
+#endif //DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DIRECITON_CODE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/areal_areal.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/areal_areal.hpp
new file mode 100644
index 00000000000..664c9953846
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/areal_areal.hpp
@@ -0,0 +1,180 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013-2017.
+// Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_AREAL_AREAL_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_AREAL_AREAL_HPP
+
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/algorithms/covered_by.hpp>
+#include <boost/geometry/algorithms/detail/for_each_range.hpp>
+#include <boost/geometry/algorithms/detail/point_on_border.hpp>
+
+#include <boost/geometry/algorithms/detail/disjoint/linear_linear.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace disjoint
+{
+
+
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct check_each_ring_for_within_call_covered_by
+{
+    /*!
+    \tparam Strategy point_in_geometry strategy
+    */
+    template <typename Point, typename Strategy>
+    static inline bool apply(Point const& p, Geometry const& g, Strategy const& strategy)
+    {
+        return geometry::covered_by(p, g, strategy);
+    }
+};
+
+template <typename Geometry>
+struct check_each_ring_for_within_call_covered_by<Geometry, box_tag>
+{
+    template <typename Point, typename Strategy>
+    static inline bool apply(Point const& p, Geometry const& g, Strategy const& )
+    {
+        return geometry::covered_by(p, g);
+    }
+};
+
+
+/*!
+\tparam Strategy point_in_geometry strategy
+*/
+template<typename Geometry, typename Strategy>
+struct check_each_ring_for_within
+{
+    bool not_disjoint;
+    Geometry const& m_geometry;
+    Strategy const& m_strategy;
+
+    inline check_each_ring_for_within(Geometry const& g,
+                                      Strategy const& strategy)
+        : not_disjoint(false)
+        , m_geometry(g)
+        , m_strategy(strategy)
+    {}
+
+    template <typename Range>
+    inline void apply(Range const& range)
+    {
+        typename point_type<Range>::type pt;
+        not_disjoint = not_disjoint
+                || ( geometry::point_on_border(pt, range)
+                  && check_each_ring_for_within_call_covered_by
+                        <
+                            Geometry
+                        >::apply(pt, m_geometry, m_strategy) );
+    }
+};
+
+
+/*!
+\tparam Strategy point_in_geometry strategy
+*/
+template <typename FirstGeometry, typename SecondGeometry, typename Strategy>
+inline bool rings_containing(FirstGeometry const& geometry1,
+                             SecondGeometry const& geometry2,
+                             Strategy const& strategy)
+{
+    check_each_ring_for_within
+        <
+            FirstGeometry, Strategy
+        > checker(geometry1, strategy);
+    geometry::detail::for_each_range(geometry2, checker);
+    return checker.not_disjoint;
+}
+
+
+
+template <typename Geometry1, typename Geometry2>
+struct general_areal
+{
+    /*!
+    \tparam Strategy relate (segments intersection) strategy
+    */
+    template <typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        if ( ! disjoint_linear<Geometry1, Geometry2>::apply(geometry1, geometry2, strategy) )
+        {
+            return false;
+        }
+
+        // If there is no intersection of segments, they might located
+        // inside each other
+
+        // We check that using a point on the border (external boundary),
+        // and see if that is contained in the other geometry. And vice versa.
+
+        if ( rings_containing(geometry1, geometry2,
+                              strategy.template get_point_in_geometry_strategy<Geometry2, Geometry1>())
+          || rings_containing(geometry2, geometry1,
+                              strategy.template get_point_in_geometry_strategy<Geometry1, Geometry2>()) )
+        {
+            return false;
+        }
+
+        return true;
+    }
+};
+
+
+}} // namespace detail::disjoint
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Areal1, typename Areal2>
+struct disjoint<Areal1, Areal2, 2, areal_tag, areal_tag, false>
+    : detail::disjoint::general_areal<Areal1, Areal2>
+{};
+
+
+template <typename Areal, typename Box>
+struct disjoint<Areal, Box, 2, areal_tag, box_tag, false>
+    : detail::disjoint::general_areal<Areal, Box>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_AREAL_AREAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/box_box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/box_box.hpp
new file mode 100644
index 00000000000..87618939b8c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/box_box.hpp
@@ -0,0 +1,184 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2015 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013-2017.
+// Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_BOX_BOX_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_BOX_BOX_HPP
+
+#include <cstddef>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/dispatch/disjoint.hpp>
+
+#include <boost/geometry/util/normalize_spheroidal_coordinates.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace disjoint
+{
+
+template
+<
+    typename Box1, typename Box2,
+    std::size_t Dimension = 0,
+    std::size_t DimensionCount = dimension<Box1>::value,
+    typename CSTag = typename tag_cast
+                        <
+                            typename cs_tag<Box1>::type,
+                            spherical_tag
+                        >::type
+>
+struct box_box
+{
+    template <typename Strategy>
+    static inline bool apply(Box1 const& box1, Box2 const& box2, Strategy const&)
+    {
+        return apply(box1, box2);
+    }
+
+    static inline bool apply(Box1 const& box1, Box2 const& box2)
+    {
+        if (get<max_corner, Dimension>(box1) < get<min_corner, Dimension>(box2))
+        {
+            return true;
+        }
+        if (get<min_corner, Dimension>(box1) > get<max_corner, Dimension>(box2))
+        {
+            return true;
+        }
+        return box_box
+            <
+                Box1, Box2,
+                Dimension + 1, DimensionCount
+            >::apply(box1, box2);
+    }
+};
+
+
+template <typename Box1, typename Box2, std::size_t DimensionCount, typename CSTag>
+struct box_box<Box1, Box2, DimensionCount, DimensionCount, CSTag>
+{
+    static inline bool apply(Box1 const& , Box2 const& )
+    {
+        return false;
+    }
+};
+
+
+template <typename Box1, typename Box2, std::size_t DimensionCount>
+struct box_box<Box1, Box2, 0, DimensionCount, spherical_tag>
+{
+    template <typename Strategy>
+    static inline bool apply(Box1 const& box1, Box2 const& box2, Strategy const&)
+    {
+        return apply(box1, box2);
+    }
+
+    static inline bool apply(Box1 const& box1, Box2 const& box2)
+    {
+        typedef typename geometry::select_most_precise
+            <
+                typename coordinate_type<Box1>::type,
+                typename coordinate_type<Box2>::type
+            >::type calc_t;
+        typedef typename coordinate_system<Box1>::type::units units_t;
+        typedef math::detail::constants_on_spheroid<calc_t, units_t> constants;
+
+        calc_t const b1_min = get<min_corner, 0>(box1);
+        calc_t const b1_max = get<max_corner, 0>(box1);
+        calc_t const b2_min = get<min_corner, 0>(box2);
+        calc_t const b2_max = get<max_corner, 0>(box2);
+
+        // min <= max <=> diff >= 0
+        calc_t const diff1 = b1_max - b1_min;
+        calc_t const diff2 = b2_max - b2_min;
+
+        // check the intersection if neither box cover the whole globe
+        if (diff1 < constants::period() && diff2 < constants::period())
+        {
+            // calculate positive longitude translation with b1_min as origin
+            calc_t const diff_min = math::longitude_distance_unsigned<units_t>(b1_min, b2_min);
+            calc_t const b2_min_transl = b1_min + diff_min; // always right of b1_min
+            calc_t b2_max_transl = b2_min_transl - constants::period() + diff2;
+
+            // if the translation is too close then use the original point
+            // note that math::abs(b2_max_transl - b2_max) takes values very
+            // close to k*2*constants::period() for k=0,1,2,...
+            if (math::abs(b2_max_transl - b2_max) < constants::period() / 2)
+            {
+                b2_max_transl = b2_max;
+            }
+
+            if (b2_min_transl > b1_max  // b2_min right of b1_max
+             && b2_max_transl < b1_min) // b2_max left of b1_min
+            {
+                return true;
+            }
+        }
+
+        return box_box
+            <
+                Box1, Box2,
+                1, DimensionCount
+            >::apply(box1, box2);
+    }
+};
+
+
+/*!
+    \brief Internal utility function to detect if boxes are disjoint
+    \note Is used from other algorithms, declared separately
+        to avoid circular references
+ */
+template <typename Box1, typename Box2>
+inline bool disjoint_box_box(Box1 const& box1, Box2 const& box2)
+{
+    return box_box<Box1, Box2>::apply(box1, box2);
+}
+
+
+}} // namespace detail::disjoint
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Box1, typename Box2, std::size_t DimensionCount>
+struct disjoint<Box1, Box2, DimensionCount, box_tag, box_tag, false>
+    : detail::disjoint::box_box<Box1, Box2, 0, DimensionCount>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_BOX_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/implementation.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/implementation.hpp
new file mode 100644
index 00000000000..3a3d9865d1d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/implementation.hpp
@@ -0,0 +1,37 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013-2017.
+// Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_IMPLEMENTATION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_IMPLEMENTATION_HPP
+
+
+#include <boost/geometry/algorithms/detail/disjoint/areal_areal.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/linear_areal.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/linear_linear.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/point_geometry.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/multipoint_geometry.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/point_point.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/point_box.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/box_box.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/segment_box.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/linear_segment_or_box.hpp>
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_IMPLEMENTATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/interface.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/interface.hpp
new file mode 100644
index 00000000000..64898e35fe3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/interface.hpp
@@ -0,0 +1,246 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013-2017.
+// Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_INTERFACE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_INTERFACE_HPP
+
+#include <cstddef>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/detail/relate/interface.hpp>
+#include <boost/geometry/algorithms/dispatch/disjoint.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/strategies/disjoint.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace resolve_strategy
+{
+
+struct disjoint
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        return dispatch::disjoint
+                <
+                    Geometry1, Geometry2
+                >::apply(geometry1, geometry2, strategy);
+    }
+
+    template <typename Geometry1, typename Geometry2>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             default_strategy)
+    {
+        typedef typename strategy::disjoint::services::default_strategy
+            <
+                Geometry1, Geometry2
+            >::type strategy_type;
+
+        return dispatch::disjoint
+                <
+                    Geometry1, Geometry2
+                >::apply(geometry1, geometry2, strategy_type());
+    }
+};
+
+} // namespace resolve_strategy
+
+
+namespace resolve_variant {
+
+template <typename Geometry1, typename Geometry2>
+struct disjoint
+{
+    template <typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        concepts::check_concepts_and_equal_dimensions
+            <
+                Geometry1 const,
+                Geometry2 const
+            >();
+
+        return resolve_strategy::disjoint::apply(geometry1, geometry2, strategy);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
+struct disjoint<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
+{
+    template <typename Strategy>
+    struct visitor: boost::static_visitor<bool>
+    {
+        Geometry2 const& m_geometry2;
+        Strategy const& m_strategy;
+
+        visitor(Geometry2 const& geometry2, Strategy const& strategy)
+            : m_geometry2(geometry2)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Geometry1>
+        bool operator()(Geometry1 const& geometry1) const
+        {
+            return disjoint<Geometry1, Geometry2>::apply(geometry1, m_geometry2, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline bool apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(geometry2, strategy), geometry1);
+    }
+};
+
+template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct disjoint<Geometry1, boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Strategy>
+    struct visitor: boost::static_visitor<bool>
+    {
+        Geometry1 const& m_geometry1;
+        Strategy const& m_strategy;
+
+        visitor(Geometry1 const& geometry1, Strategy const& strategy)
+            : m_geometry1(geometry1)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Geometry2>
+        bool operator()(Geometry2 const& geometry2) const
+        {
+            return disjoint<Geometry1, Geometry2>::apply(m_geometry1, geometry2, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2,
+                             Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(geometry1, strategy), geometry2);
+    }
+};
+
+template
+<
+    BOOST_VARIANT_ENUM_PARAMS(typename T1),
+    BOOST_VARIANT_ENUM_PARAMS(typename T2)
+>
+struct disjoint
+    <
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)>,
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)>
+    >
+{
+    template <typename Strategy>
+    struct visitor: boost::static_visitor<bool>
+    {
+        Strategy const& m_strategy;
+
+        visitor(Strategy const& strategy)
+            : m_strategy(strategy)
+        {}
+
+        template <typename Geometry1, typename Geometry2>
+        bool operator()(Geometry1 const& geometry1,
+                        Geometry2 const& geometry2) const
+        {
+            return disjoint<Geometry1, Geometry2>::apply(geometry1, geometry2, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline bool apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)> const& geometry1,
+                             boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2,
+                             Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(strategy), geometry1, geometry2);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief \brief_check2{are disjoint}
+\ingroup disjoint
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Strategy \tparam_strategy{Disjoint}
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param strategy \param_strategy{disjoint}
+\return \return_check2{are disjoint}
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/disjoint.qbk]}
+*/
+template <typename Geometry1, typename Geometry2, typename Strategy>
+inline bool disjoint(Geometry1 const& geometry1,
+                     Geometry2 const& geometry2,
+                     Strategy const& strategy)
+{
+    return resolve_variant::disjoint
+            <
+                Geometry1, Geometry2
+            >::apply(geometry1, geometry2, strategy);
+}
+
+
+/*!
+\brief \brief_check2{are disjoint}
+\ingroup disjoint
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\return \return_check2{are disjoint}
+
+\qbk{[include reference/algorithms/disjoint.qbk]}
+*/
+template <typename Geometry1, typename Geometry2>
+inline bool disjoint(Geometry1 const& geometry1,
+                     Geometry2 const& geometry2)
+{
+    return resolve_variant::disjoint
+            <
+                Geometry1, Geometry2
+            >::apply(geometry1, geometry2, default_strategy());
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_INTERFACE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/linear_areal.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/linear_areal.hpp
new file mode 100644
index 00000000000..e6077d3e7f1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/linear_areal.hpp
@@ -0,0 +1,301 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013-2017.
+// Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_LINEAR_AREAL_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_LINEAR_AREAL_HPP
+
+#include <iterator>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/covered_by.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/algorithms/detail/assign_indexed_point.hpp>
+#include <boost/geometry/algorithms/detail/check_iterator_range.hpp>
+#include <boost/geometry/algorithms/detail/point_on_border.hpp>
+
+#include <boost/geometry/algorithms/detail/disjoint/multirange_geometry.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/linear_segment_or_box.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/point_box.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/segment_box.hpp>
+
+#include <boost/geometry/algorithms/dispatch/disjoint.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace disjoint
+{
+
+template <typename Geometry1, typename Geometry2,
+          typename Tag1 = typename tag<Geometry1>::type,
+          typename Tag1OrMulti = typename tag_cast<Tag1, multi_tag>::type>
+struct disjoint_no_intersections_policy
+{
+    /*!
+    \tparam Strategy point_in_geometry strategy
+    */
+    template <typename Strategy>
+    static inline bool apply(Geometry1 const& g1, Geometry2 const& g2, Strategy const& strategy)
+    {
+        typedef typename point_type<Geometry1>::type point1_type;
+        point1_type p;
+        geometry::point_on_border(p, g1);
+
+        return !geometry::covered_by(p, g2, strategy);
+    }
+};
+
+template <typename Geometry1, typename Geometry2, typename Tag1>
+struct disjoint_no_intersections_policy<Geometry1, Geometry2, Tag1, multi_tag>
+{
+    /*!
+    \tparam Strategy point_in_geometry strategy
+    */
+    template <typename Strategy>
+    static inline bool apply(Geometry1 const& g1, Geometry2 const& g2, Strategy const& strategy)
+    {
+        // TODO: use partition or rtree on g2
+        typedef typename boost::range_iterator<Geometry1 const>::type iterator;
+        for ( iterator it = boost::begin(g1) ; it != boost::end(g1) ; ++it )
+        {
+            typedef typename boost::range_value<Geometry1 const>::type value_type;
+            if ( ! disjoint_no_intersections_policy<value_type const, Geometry2>
+                    ::apply(*it, g2, strategy) )
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+};
+
+
+template<typename Geometry1, typename Geometry2,
+         typename NoIntersectionsPolicy
+                    = disjoint_no_intersections_policy<Geometry1, Geometry2> >
+struct disjoint_linear_areal
+{
+    /*!
+    \tparam Strategy relate (segments intersection) strategy
+    */
+    template <typename Strategy>
+    static inline bool apply(Geometry1 const& g1, Geometry2 const& g2, Strategy const& strategy)
+    {
+        // if there are intersections - return false
+        if ( !disjoint_linear<Geometry1, Geometry2>::apply(g1, g2, strategy) )
+        {
+            return false;
+        }
+
+        return NoIntersectionsPolicy
+                ::apply(g1, g2,
+                        strategy.template get_point_in_geometry_strategy<Geometry1, Geometry2>());
+    }
+};
+
+
+
+
+template
+<
+    typename Segment,
+    typename Areal,
+    typename Tag = typename tag<Areal>::type
+>
+struct disjoint_segment_areal
+    : not_implemented<Segment, Areal>
+{};
+
+
+template <typename Segment, typename Polygon>
+class disjoint_segment_areal<Segment, Polygon, polygon_tag>
+{
+private:
+    template <typename InteriorRings, typename Strategy>
+    static inline
+    bool check_interior_rings(InteriorRings const& interior_rings,
+                              Segment const& segment,
+                              Strategy const& strategy)
+    {
+        typedef typename boost::range_value<InteriorRings>::type ring_type;
+
+        typedef unary_disjoint_geometry_to_query_geometry
+            <
+                Segment,
+                Strategy,
+                disjoint_range_segment_or_box
+                    <
+                        ring_type, closure<ring_type>::value, Segment
+                    >
+            > unary_predicate_type;
+                
+        return check_iterator_range
+            <
+                unary_predicate_type
+            >::apply(boost::begin(interior_rings),
+                     boost::end(interior_rings),
+                     unary_predicate_type(segment, strategy));
+    }
+
+
+public:
+    template <typename IntersectionStrategy>
+    static inline bool apply(Segment const& segment,
+                             Polygon const& polygon,
+                             IntersectionStrategy const& strategy)
+    {
+        typedef typename geometry::ring_type<Polygon>::type ring;
+
+        if ( !disjoint_range_segment_or_box
+                 <
+                     ring, closure<Polygon>::value, Segment
+                 >::apply(geometry::exterior_ring(polygon), segment, strategy) )
+        {
+            return false;
+        }
+
+        if ( !check_interior_rings(geometry::interior_rings(polygon), segment, strategy) )
+        {
+            return false;
+        }
+
+        typename point_type<Segment>::type p;
+        detail::assign_point_from_index<0>(segment, p);
+
+        return !geometry::covered_by(p, polygon,
+                    strategy.template get_point_in_geometry_strategy<Segment, Polygon>());
+    }
+};
+
+
+template <typename Segment, typename MultiPolygon>
+struct disjoint_segment_areal<Segment, MultiPolygon, multi_polygon_tag>
+{
+    template <typename IntersectionStrategy>
+    static inline bool apply(Segment const& segment, MultiPolygon const& multipolygon,
+                             IntersectionStrategy const& strategy)
+    {
+        return multirange_constant_size_geometry
+            <
+                MultiPolygon, Segment
+            >::apply(multipolygon, segment, strategy);
+    }
+};
+
+
+template <typename Segment, typename Ring>
+struct disjoint_segment_areal<Segment, Ring, ring_tag>
+{
+    template <typename IntersectionStrategy>
+    static inline bool apply(Segment const& segment,
+                             Ring const& ring,
+                             IntersectionStrategy const& strategy)
+    {
+        if ( !disjoint_range_segment_or_box
+                 <
+                     Ring, closure<Ring>::value, Segment
+                 >::apply(ring, segment, strategy) )
+        {
+            return false;
+        }
+
+        typename point_type<Segment>::type p;
+        detail::assign_point_from_index<0>(segment, p);
+
+        return !geometry::covered_by(p, ring,
+                    strategy.template get_point_in_geometry_strategy<Segment, Ring>());
+    }
+};
+
+
+}} // namespace detail::disjoint
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Linear, typename Areal>
+struct disjoint<Linear, Areal, 2, linear_tag, areal_tag, false>
+    : public detail::disjoint::disjoint_linear_areal<Linear, Areal>
+{};
+
+
+template <typename Areal, typename Linear>
+struct disjoint<Areal, Linear, 2, areal_tag, linear_tag, false>
+{
+    template <typename Strategy>
+    static inline bool apply(Areal const& areal, Linear const& linear,
+                             Strategy const& strategy)
+    {
+        return detail::disjoint::disjoint_linear_areal
+            <
+                Linear, Areal
+            >::apply(linear, areal, strategy);
+    }
+};
+
+
+template <typename Areal, typename Segment>
+struct disjoint<Areal, Segment, 2, areal_tag, segment_tag, false>
+{
+    template <typename Strategy>
+    static inline bool apply(Areal const& g1, Segment const& g2,
+                             Strategy const& strategy)
+    {
+        return detail::disjoint::disjoint_segment_areal
+            <
+                Segment, Areal
+            >::apply(g2, g1, strategy);
+    }
+};
+
+
+template <typename Segment, typename Areal>
+struct disjoint<Segment, Areal, 2, segment_tag, areal_tag, false>
+    : detail::disjoint::disjoint_segment_areal<Segment, Areal>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_LINEAR_AREAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/linear_linear.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/linear_linear.hpp
new file mode 100644
index 00000000000..989b8df2472
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/linear_linear.hpp
@@ -0,0 +1,191 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013-2017.
+// Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_LINEAR_LINEAR_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_LINEAR_LINEAR_HPP
+
+#include <cstddef>
+#include <deque>
+
+#include <boost/range.hpp>
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_turns.hpp>
+#include <boost/geometry/algorithms/detail/overlay/do_reverse.hpp>
+
+#include <boost/geometry/policies/disjoint_interrupt_policy.hpp>
+#include <boost/geometry/policies/robustness/no_rescale_policy.hpp>
+#include <boost/geometry/policies/robustness/segment_ratio_type.hpp>
+
+#include <boost/geometry/algorithms/dispatch/disjoint.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace disjoint
+{
+
+template <typename Segment1, typename Segment2>
+struct disjoint_segment
+{
+    template <typename Strategy>
+    static inline bool apply(Segment1 const& segment1, Segment2 const& segment2,
+                             Strategy const& strategy)
+    {
+        typedef typename point_type<Segment1>::type point_type;
+
+        // We don't need to rescale to detect disjointness
+        typedef no_rescale_policy rescale_policy_type;
+        rescale_policy_type robust_policy;
+
+        typedef segment_intersection_points
+            <
+                point_type,
+                typename segment_ratio_type
+                    <
+                        point_type,
+                        rescale_policy_type
+                    >::type
+            > intersection_return_type;
+
+        typedef policies::relate::segments_intersection_points
+            <
+                intersection_return_type
+            > intersection_policy;
+
+        intersection_return_type is = strategy.apply(segment1, segment2,
+                                                     intersection_policy(),
+                                                     robust_policy);
+
+        return is.count == 0;
+    }
+};
+
+
+struct assign_disjoint_policy
+{
+    // We want to include all points:
+    static bool const include_no_turn = true;
+    static bool const include_degenerate = true;
+    static bool const include_opposite = true;
+
+    // We don't assign extra info:
+    template
+    <
+        typename Info,
+        typename Point1,
+        typename Point2,
+        typename IntersectionInfo
+    >
+    static inline void apply(Info& , Point1 const& , Point2 const&,
+                IntersectionInfo const&)
+    {}
+};
+
+
+template <typename Geometry1, typename Geometry2>
+struct disjoint_linear
+{
+    template <typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        typedef typename geometry::point_type<Geometry1>::type point_type;
+        typedef detail::no_rescale_policy rescale_policy_type;
+        typedef typename geometry::segment_ratio_type
+            <
+                point_type, rescale_policy_type
+            >::type segment_ratio_type;
+        typedef overlay::turn_info
+            <
+                point_type,
+                segment_ratio_type,
+                typename detail::get_turns::turn_operation_type
+                        <
+                            Geometry1, Geometry2, segment_ratio_type
+                        >::type
+            > turn_info_type;
+
+        std::deque<turn_info_type> turns;
+
+        // Specify two policies:
+        // 1) Stop at any intersection
+        // 2) In assignment, include also degenerate points (which are normally skipped)
+        disjoint_interrupt_policy interrupt_policy;
+        dispatch::get_turns
+            <
+                typename geometry::tag<Geometry1>::type,
+                typename geometry::tag<Geometry2>::type,
+                Geometry1,
+                Geometry2,
+                overlay::do_reverse<geometry::point_order<Geometry1>::value>::value, // should be false
+                overlay::do_reverse<geometry::point_order<Geometry2>::value>::value, // should be false
+                detail::get_turns::get_turn_info_type
+                    <
+                        Geometry1, Geometry2, assign_disjoint_policy
+                    >
+            >::apply(0, geometry1, 1, geometry2,
+                     strategy, rescale_policy_type(), turns, interrupt_policy);
+
+        return !interrupt_policy.has_intersections;
+    }
+};
+
+
+}} // namespace detail::disjoint
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Linear1, typename Linear2>
+struct disjoint<Linear1, Linear2, 2, linear_tag, linear_tag, false>
+    : detail::disjoint::disjoint_linear<Linear1, Linear2>
+{};
+
+
+template <typename Segment1, typename Segment2>
+struct disjoint<Segment1, Segment2, 2, segment_tag, segment_tag, false>
+    : detail::disjoint::disjoint_segment<Segment1, Segment2>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_LINEAR_LINEAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/linear_segment_or_box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/linear_segment_or_box.hpp
new file mode 100644
index 00000000000..b4c71c8f305
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/linear_segment_or_box.hpp
@@ -0,0 +1,171 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013-2014.
+// Modifications copyright (c) 2013-2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_LINEAR_SEGMENT_OR_BOX_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_LINEAR_SEGMENT_OR_BOX_HPP
+
+#include <boost/range.hpp>
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/core/closure.hpp>
+
+#include <boost/geometry/geometries/segment.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/views/closeable_view.hpp>
+
+#include <boost/geometry/algorithms/detail/disjoint/multirange_geometry.hpp>
+#include <boost/geometry/algorithms/dispatch/disjoint.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace disjoint
+{
+
+
+template
+<
+    typename Range,
+    closure_selector Closure,
+    typename SegmentOrBox
+>
+struct disjoint_range_segment_or_box
+{
+    template <typename Strategy>
+    static inline bool apply(Range const& range,
+                             SegmentOrBox const& segment_or_box,
+                             Strategy const& strategy)
+    {
+        typedef typename closeable_view<Range const, Closure>::type view_type;
+
+        typedef typename ::boost::range_value<view_type>::type point_type;
+        typedef typename ::boost::range_iterator
+            <
+                view_type const
+            >::type const_iterator;
+
+        typedef typename ::boost::range_size<view_type>::type size_type;
+
+        typedef typename geometry::model::referring_segment
+            <
+                point_type const
+            > range_segment;
+
+        view_type view(range);
+
+        const size_type count = ::boost::size(view);
+
+        if ( count == 0 )
+        {
+            return false;
+        }
+        else if ( count == 1 )
+        {
+            return dispatch::disjoint
+                <
+                    point_type, SegmentOrBox
+                >::apply(geometry::range::front<view_type const>(view),
+                         segment_or_box,
+                         strategy.template get_point_in_geometry_strategy<Range, SegmentOrBox>());
+        }
+        else
+        {
+            const_iterator it0 = ::boost::begin(view);
+            const_iterator it1 = ::boost::begin(view) + 1;
+            const_iterator last = ::boost::end(view);
+
+            for ( ; it1 != last ; ++it0, ++it1 )
+            {
+                range_segment rng_segment(*it0, *it1);
+                if ( !dispatch::disjoint
+                         <
+                             range_segment, SegmentOrBox
+                         >::apply(rng_segment, segment_or_box, strategy) )
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+};
+
+
+
+
+template
+<
+    typename Linear,
+    typename SegmentOrBox,
+    typename Tag = typename tag<Linear>::type
+>
+struct disjoint_linear_segment_or_box
+    : not_implemented<Linear, SegmentOrBox>
+{};
+
+
+template <typename Linestring, typename SegmentOrBox>
+struct disjoint_linear_segment_or_box<Linestring, SegmentOrBox, linestring_tag>
+    : disjoint_range_segment_or_box<Linestring, closed, SegmentOrBox>
+{};
+
+
+template <typename MultiLinestring, typename SegmentOrBox>
+struct disjoint_linear_segment_or_box
+    <
+        MultiLinestring, SegmentOrBox, multi_linestring_tag
+    > : multirange_constant_size_geometry<MultiLinestring, SegmentOrBox>
+{};
+
+
+}} // namespace detail::disjoint
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Linear, typename Segment>
+struct disjoint<Linear, Segment, 2, linear_tag, segment_tag, false>
+    : detail::disjoint::disjoint_linear_segment_or_box<Linear, Segment>
+{};
+
+
+template <typename Linear, typename Box, std::size_t DimensionCount>
+struct disjoint<Linear, Box, DimensionCount, linear_tag, box_tag, false>
+    : detail::disjoint::disjoint_linear_segment_or_box<Linear, Box>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_LINEAR_SEGMENT_OR_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/multipoint_geometry.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/multipoint_geometry.hpp
new file mode 100644
index 00000000000..f8d3e3c593d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/multipoint_geometry.hpp
@@ -0,0 +1,531 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
+// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_MULTIPOINT_GEOMETRY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_MULTIPOINT_GEOMETRY_HPP
+
+#include <algorithm>
+#include <vector>
+
+#include <boost/range.hpp>
+#include <boost/mpl/assert.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/box.hpp>
+
+#include <boost/geometry/iterators/segment_iterator.hpp>
+
+#include <boost/geometry/algorithms/envelope.hpp>
+#include <boost/geometry/algorithms/expand.hpp>
+
+#include <boost/geometry/algorithms/detail/check_iterator_range.hpp>
+#include <boost/geometry/algorithms/detail/partition.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/box_box.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/multirange_geometry.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/point_box.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/point_point.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/point_geometry.hpp>
+#include <boost/geometry/algorithms/detail/relate/less.hpp>
+
+#include <boost/geometry/algorithms/dispatch/disjoint.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace disjoint
+{
+
+
+template <typename MultiPoint1, typename MultiPoint2>
+class multipoint_multipoint
+{
+private:
+    template <typename Iterator>
+    class unary_disjoint_predicate
+        : detail::relate::less
+    {
+    private:
+        typedef detail::relate::less base_type;
+
+    public:
+        unary_disjoint_predicate(Iterator first, Iterator last)
+            : base_type(), m_first(first), m_last(last)
+        {}
+
+        template <typename Point>
+        inline bool apply(Point const& point) const
+        {
+            return !std::binary_search(m_first,
+                                       m_last,
+                                       point,
+                                       static_cast<base_type const&>(*this));
+        }
+
+    private:
+        Iterator m_first, m_last;
+    };
+
+public:
+    static inline bool apply(MultiPoint1 const& multipoint1,
+                             MultiPoint2 const& multipoint2)
+    {
+        BOOST_GEOMETRY_ASSERT( boost::size(multipoint1) <= boost::size(multipoint2) );
+
+        typedef typename boost::range_value<MultiPoint1>::type point1_type;
+
+        std::vector<point1_type> points1(boost::begin(multipoint1),
+                                         boost::end(multipoint1));
+
+        std::sort(points1.begin(), points1.end(), detail::relate::less());
+
+        typedef unary_disjoint_predicate
+            <
+                typename std::vector<point1_type>::const_iterator
+            > predicate_type;
+
+        return check_iterator_range
+            <
+                predicate_type
+            >::apply(boost::begin(multipoint2),
+                     boost::end(multipoint2),
+                     predicate_type(points1.begin(), points1.end()));
+    }
+};
+
+
+template <typename MultiPoint, typename Linear>
+class multipoint_linear
+{
+private:
+    struct expand_box_point
+    {
+        template <typename Box, typename Point>
+        static inline void apply(Box& total, Point const& point)
+        {
+            geometry::expand(total, point);
+        }
+    };
+
+    template <typename EnvelopeStrategy>
+    struct expand_box_segment
+    {
+        explicit expand_box_segment(EnvelopeStrategy const& strategy)
+            : m_strategy(strategy)
+        {}
+
+        template <typename Box, typename Segment>
+        inline void apply(Box& total, Segment const& segment) const
+        {
+            geometry::expand(total,
+                             geometry::return_envelope<Box>(segment, m_strategy));
+        }
+
+        EnvelopeStrategy const& m_strategy;
+    };
+
+    struct overlaps_box_point
+    {
+        template <typename Box, typename Point>
+        static inline bool apply(Box const& box, Point const& point)
+        {
+            // The default strategy is enough in this case
+            return ! detail::disjoint::disjoint_point_box(point, box);
+        }
+    };
+
+    template <typename DisjointStrategy>
+    struct overlaps_box_segment
+    {
+        explicit overlaps_box_segment(DisjointStrategy const& strategy)
+            : m_strategy(strategy)
+        {}
+
+        template <typename Box, typename Segment>
+        inline bool apply(Box const& box, Segment const& segment) const
+        {
+            return ! dispatch::disjoint<Segment, Box>::apply(segment, box, m_strategy);
+        }
+
+        DisjointStrategy const& m_strategy;
+    };
+
+    template <typename PtSegStrategy>
+    class item_visitor_type
+    {
+    public:
+        item_visitor_type(PtSegStrategy const& strategy)
+            : m_intersection_found(false)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Item1, typename Item2>
+        inline bool apply(Item1 const& item1, Item2 const& item2)
+        {
+            if (! m_intersection_found
+                && ! dispatch::disjoint<Item1, Item2>::apply(item1, item2, m_strategy))
+            {
+                m_intersection_found = true;
+                return false;
+            }
+            return true;
+        }
+
+        inline bool intersection_found() const { return m_intersection_found; }
+
+    private:
+        bool m_intersection_found;
+        PtSegStrategy const& m_strategy;
+    };
+    // structs for partition -- end
+
+    class segment_range
+    {
+    public:
+        typedef geometry::segment_iterator<Linear const> const_iterator;
+        typedef const_iterator iterator;
+
+        segment_range(Linear const& linear)
+            : m_linear(linear)
+        {}
+
+        const_iterator begin() const
+        {
+            return geometry::segments_begin(m_linear);
+        }
+
+        const_iterator end() const
+        {
+            return geometry::segments_end(m_linear);
+        }
+
+    private:
+        Linear const& m_linear;
+    };
+
+public:
+    template <typename Strategy>
+    static inline bool apply(MultiPoint const& multipoint, Linear const& linear, Strategy const& strategy)
+    {
+        item_visitor_type<Strategy> visitor(strategy);
+
+        typedef typename Strategy::envelope_strategy_type envelope_strategy_type;
+        typedef typename Strategy::disjoint_strategy_type disjoint_strategy_type;
+
+        // TODO: disjoint Segment/Box may be called in partition multiple times
+        // possibly for non-cartesian segments which could be slow. We should consider
+        // passing a range of bounding boxes of segments after calculating them once.
+        // Alternatively instead of a range of segments a range of Segment/Envelope pairs
+        // should be passed, where envelope would be lazily calculated when needed the first time
+        geometry::partition
+            <
+                geometry::model::box<typename point_type<MultiPoint>::type>
+            >::apply(multipoint, segment_range(linear), visitor,
+                     expand_box_point(),
+                     overlaps_box_point(),
+                     expand_box_segment<envelope_strategy_type>(strategy.get_envelope_strategy()),
+                     overlaps_box_segment<disjoint_strategy_type>(strategy.get_disjoint_strategy()));
+
+        return ! visitor.intersection_found();
+    }
+
+    template <typename Strategy>
+    static inline bool apply(Linear const& linear, MultiPoint const& multipoint, Strategy const& strategy)
+    {
+        return apply(multipoint, linear, strategy);
+    }
+};
+
+
+template <typename MultiPoint, typename SingleGeometry>
+class multi_point_single_geometry
+{
+public:
+    template <typename Strategy>
+    static inline bool apply(MultiPoint const& multi_point, SingleGeometry const& single_geometry, Strategy const& strategy)
+    {
+        typedef typename point_type<MultiPoint>::type point1_type;
+        typedef typename point_type<SingleGeometry>::type point2_type;
+        typedef model::box<point2_type> box2_type;
+        
+        box2_type box2;
+        geometry::envelope(single_geometry, box2, strategy.get_envelope_strategy());
+        geometry::detail::expand_by_epsilon(box2);
+
+        typedef typename boost::range_const_iterator<MultiPoint>::type iterator;
+        for ( iterator it = boost::begin(multi_point) ; it != boost::end(multi_point) ; ++it )
+        {
+            // The default strategy is enough for Point/Box
+            if (! detail::disjoint::disjoint_point_box(*it, box2)
+                && ! dispatch::disjoint<point1_type, SingleGeometry>::apply(*it, single_geometry, strategy))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    template <typename Strategy>
+    static inline bool apply(SingleGeometry const& single_geometry, MultiPoint const& multi_point, Strategy const& strategy)
+    {
+        return apply(multi_point, single_geometry, strategy);
+    }
+};
+
+
+template <typename MultiPoint, typename MultiGeometry>
+class multi_point_multi_geometry
+{
+private:
+    struct expand_box_point
+    {
+        template <typename Box, typename Point>
+        static inline void apply(Box& total, Point const& point)
+        {
+            geometry::expand(total, point);
+        }
+    };
+
+    struct expand_box_box_pair
+    {
+        template <typename Box, typename BoxPair>
+        inline void apply(Box& total, BoxPair const& box_pair) const
+        {
+            geometry::expand(total, box_pair.first);
+        }
+    };
+
+    struct overlaps_box_point
+    {
+        template <typename Box, typename Point>
+        static inline bool apply(Box const& box, Point const& point)
+        {
+            // The default strategy is enough for Point/Box
+            return ! detail::disjoint::disjoint_point_box(point, box);
+        }
+    };
+
+    struct overlaps_box_box_pair
+    {
+        template <typename Box, typename BoxPair>
+        inline bool apply(Box const& box, BoxPair const& box_pair) const
+        {
+            // The default strategy is enough for Box/Box
+            return ! detail::disjoint::disjoint_box_box(box_pair.first, box);
+        }
+    };
+
+    template <typename PtSegStrategy>
+    class item_visitor_type
+    {
+    public:
+        item_visitor_type(MultiGeometry const& multi_geometry,
+                          PtSegStrategy const& strategy)
+            : m_intersection_found(false)
+            , m_multi_geometry(multi_geometry)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Point, typename BoxPair>
+        inline bool apply(Point const& point, BoxPair const& box_pair)
+        {
+            typedef typename boost::range_value<MultiGeometry>::type single_type;
+
+            // The default strategy is enough for Point/Box
+            if (! m_intersection_found
+                && ! detail::disjoint::disjoint_point_box(point, box_pair.first)
+                && ! dispatch::disjoint<Point, single_type>::apply(point, range::at(m_multi_geometry, box_pair.second), m_strategy))
+            {
+                m_intersection_found = true;
+                return false;
+            }
+            return true;
+        }
+
+        inline bool intersection_found() const { return m_intersection_found; }
+
+    private:
+        bool m_intersection_found;
+        MultiGeometry const& m_multi_geometry;
+        PtSegStrategy const& m_strategy;
+    };
+    // structs for partition -- end
+
+public:
+    template <typename Strategy>
+    static inline bool apply(MultiPoint const& multi_point, MultiGeometry const& multi_geometry, Strategy const& strategy)
+    {
+        typedef typename point_type<MultiPoint>::type point1_type;
+        typedef typename point_type<MultiGeometry>::type point2_type;
+        typedef model::box<point1_type> box1_type;
+        typedef model::box<point2_type> box2_type;
+        typedef std::pair<box2_type, std::size_t> box_pair_type;
+
+        typename Strategy::envelope_strategy_type const
+            envelope_strategy = strategy.get_envelope_strategy();
+        
+        std::size_t count2 = boost::size(multi_geometry);
+        std::vector<box_pair_type> boxes(count2);
+        for (std::size_t i = 0 ; i < count2 ; ++i)
+        {
+            geometry::envelope(range::at(multi_geometry, i), boxes[i].first, envelope_strategy);
+            geometry::detail::expand_by_epsilon(boxes[i].first);
+            boxes[i].second = i;
+        }
+
+        item_visitor_type<Strategy> visitor(multi_geometry, strategy);
+
+        geometry::partition
+            <
+                box1_type
+            >::apply(multi_point, boxes, visitor,
+                     expand_box_point(),
+                     overlaps_box_point(),
+                     expand_box_box_pair(),
+                     overlaps_box_box_pair());
+
+        return ! visitor.intersection_found();
+    }
+
+    template <typename Strategy>
+    static inline bool apply(MultiGeometry const& multi_geometry, MultiPoint const& multi_point, Strategy const& strategy)
+    {
+        return apply(multi_point, multi_geometry, strategy);
+    }
+};
+
+
+template <typename MultiPoint, typename Areal, typename Tag = typename tag<Areal>::type>
+struct multipoint_areal
+    : multi_point_single_geometry<MultiPoint, Areal>
+{};
+
+template <typename MultiPoint, typename Areal>
+struct multipoint_areal<MultiPoint, Areal, multi_polygon_tag>
+    : multi_point_multi_geometry<MultiPoint, Areal>
+{};
+
+
+}} // namespace detail::disjoint
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Point, typename MultiPoint, std::size_t DimensionCount>
+struct disjoint
+    <
+        Point, MultiPoint, DimensionCount, point_tag, multi_point_tag, false
+    > : detail::disjoint::multirange_constant_size_geometry<MultiPoint, Point>
+{};
+
+
+template <typename MultiPoint, typename Segment, std::size_t DimensionCount>
+struct disjoint
+    <
+        MultiPoint, Segment, DimensionCount, multi_point_tag, segment_tag, false
+    > : detail::disjoint::multirange_constant_size_geometry<MultiPoint, Segment>
+{};
+
+
+template <typename MultiPoint, typename Box, std::size_t DimensionCount>
+struct disjoint
+    <
+        MultiPoint, Box, DimensionCount, multi_point_tag, box_tag, false
+    > : detail::disjoint::multirange_constant_size_geometry<MultiPoint, Box>
+{};
+
+
+template
+<
+    typename MultiPoint1,
+    typename MultiPoint2,
+    std::size_t DimensionCount
+>
+struct disjoint
+    <
+        MultiPoint1, MultiPoint2, DimensionCount,
+        multi_point_tag, multi_point_tag, false
+    >
+{
+    template <typename Strategy>
+    static inline bool apply(MultiPoint1 const& multipoint1,
+                             MultiPoint2 const& multipoint2,
+                             Strategy const& )
+    {
+        if ( boost::size(multipoint2) < boost::size(multipoint1) )
+        {
+            return detail::disjoint::multipoint_multipoint
+                <
+                    MultiPoint2, MultiPoint1
+                >::apply(multipoint2, multipoint1);
+        } 
+
+        return detail::disjoint::multipoint_multipoint
+            <
+                MultiPoint1, MultiPoint2
+            >::apply(multipoint1, multipoint2);
+   }
+};
+
+
+template <typename Linear, typename MultiPoint, std::size_t DimensionCount>
+struct disjoint
+    <
+        Linear, MultiPoint, DimensionCount, linear_tag, multi_point_tag, false
+    > : detail::disjoint::multipoint_linear<MultiPoint, Linear>
+{};
+
+
+template <typename MultiPoint, typename Linear, std::size_t DimensionCount>
+struct disjoint
+    <
+        MultiPoint, Linear, DimensionCount, multi_point_tag, linear_tag, false
+    > : detail::disjoint::multipoint_linear<MultiPoint, Linear>
+{};
+
+
+template <typename Areal, typename MultiPoint, std::size_t DimensionCount>
+struct disjoint
+    <
+        Areal, MultiPoint, DimensionCount, areal_tag, multi_point_tag, false
+    > : detail::disjoint::multipoint_areal<MultiPoint, Areal>
+{};
+
+
+template <typename MultiPoint, typename Areal, std::size_t DimensionCount>
+struct disjoint
+    <
+        MultiPoint, Areal, DimensionCount, multi_point_tag, areal_tag, false
+    > : detail::disjoint::multipoint_areal<MultiPoint, Areal>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_MULTIPOINT_GEOMETRY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/multirange_geometry.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/multirange_geometry.hpp
new file mode 100644
index 00000000000..53fb1642afe
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/multirange_geometry.hpp
@@ -0,0 +1,94 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_MULTIRANGE_GEOMETRY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_MULTIRANGE_GEOMETRY_HPP
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/detail/check_iterator_range.hpp>
+#include <boost/geometry/algorithms/dispatch/disjoint.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace disjoint
+{
+
+
+template <typename Geometry, typename Strategy, typename BinaryPredicate>
+class unary_disjoint_geometry_to_query_geometry
+{
+public:
+    unary_disjoint_geometry_to_query_geometry(Geometry const& geometry,
+                                              Strategy const& strategy)
+        : m_geometry(geometry)
+        , m_strategy(strategy)
+    {}
+
+    template <typename QueryGeometry>
+    inline bool apply(QueryGeometry const& query_geometry) const
+    {
+        return BinaryPredicate::apply(query_geometry, m_geometry, m_strategy);
+    }
+
+private:
+    Geometry const& m_geometry;
+    Strategy const& m_strategy;
+};
+
+
+template<typename MultiRange, typename ConstantSizeGeometry>
+struct multirange_constant_size_geometry
+{
+    template <typename Strategy>
+    static inline bool apply(MultiRange const& multirange,
+                             ConstantSizeGeometry const& constant_size_geometry,
+                             Strategy const& strategy)
+    {
+        typedef unary_disjoint_geometry_to_query_geometry
+            <
+                ConstantSizeGeometry,
+                Strategy,
+                dispatch::disjoint
+                    <
+                        typename boost::range_value<MultiRange>::type,
+                        ConstantSizeGeometry
+                    >
+            > unary_predicate_type;
+
+        return detail::check_iterator_range
+            <
+                unary_predicate_type
+            >::apply(boost::begin(multirange), boost::end(multirange),
+                     unary_predicate_type(constant_size_geometry, strategy));
+    }
+
+    template <typename Strategy>
+    static inline bool apply(ConstantSizeGeometry const& constant_size_geometry,
+                             MultiRange const& multirange,
+                             Strategy const& strategy)
+    {
+        return apply(multirange, constant_size_geometry, strategy);
+    }
+};
+
+
+}} // namespace detail::disjoint
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_MULTIRANGE_GEOMETRY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/point_box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/point_box.hpp
new file mode 100644
index 00000000000..2e6773d2214
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/point_box.hpp
@@ -0,0 +1,83 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2015 Adam Wulkiewicz, Lodz, Poland
+
+// This file was modified by Oracle on 2013-2017.
+// Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_POINT_BOX_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_POINT_BOX_HPP
+
+#include <cstddef>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/dispatch/disjoint.hpp>
+#include <boost/geometry/strategies/disjoint.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace disjoint
+{
+
+
+/*!
+    \brief Internal utility function to detect if point/box are disjoint
+ */
+template <typename Point, typename Box>
+inline bool disjoint_point_box(Point const& point, Box const& box)
+{
+    typedef typename strategy::disjoint::services::default_strategy
+        <
+            Point, Box
+        >::type strategy_type;
+
+    // ! covered_by(point, box)
+    return ! strategy_type::apply(point, box);
+}
+
+
+}} // namespace detail::disjoint
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Point, typename Box, std::size_t DimensionCount>
+struct disjoint<Point, Box, DimensionCount, point_tag, box_tag, false>
+{
+    template <typename Strategy>
+    static inline bool apply(Point const& point, Box const& box, Strategy const& )
+    {
+        // ! covered_by(point, box)
+        return ! Strategy::apply(point, box);
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_POINT_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/point_geometry.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/point_geometry.hpp
new file mode 100644
index 00000000000..66bd7c26cee
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/point_geometry.hpp
@@ -0,0 +1,89 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2015 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013, 2014, 2015.
+// Modifications copyright (c) 2013-2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_POINT_GEOMETRY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_POINT_GEOMETRY_HPP
+
+#include <boost/geometry/algorithms/covered_by.hpp>
+
+#include <boost/geometry/algorithms/detail/disjoint/linear_linear.hpp>
+
+#include <boost/geometry/algorithms/dispatch/disjoint.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace disjoint
+{
+
+
+struct reverse_covered_by
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        return ! geometry::covered_by(geometry1, geometry2, strategy);
+    }
+};
+
+
+}} // namespace detail::disjoint
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template<typename Point, typename Linear, std::size_t DimensionCount>
+struct disjoint<Point, Linear, DimensionCount, point_tag, linear_tag, false>
+    : detail::disjoint::reverse_covered_by
+{};
+
+
+template <typename Point, typename Areal, std::size_t DimensionCount>
+struct disjoint<Point, Areal, DimensionCount, point_tag, areal_tag, false>
+    : detail::disjoint::reverse_covered_by
+{};
+
+
+template<typename Point, typename Segment, std::size_t DimensionCount>
+struct disjoint<Point, Segment, DimensionCount, point_tag, segment_tag, false>
+    : detail::disjoint::reverse_covered_by
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_POINT_GEOMETRY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/point_point.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/point_point.hpp
new file mode 100644
index 00000000000..13ac34d718e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/point_point.hpp
@@ -0,0 +1,247 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2015 Adam Wulkiewicz, Lodz, Poland
+
+// This file was modified by Oracle on 2013, 2014, 2015, 2017.
+// Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_POINT_POINT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_POINT_POINT_HPP
+
+#include <cstddef>
+
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/radian_access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_system.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+
+#include <boost/geometry/strategies/strategy_transform.hpp>
+
+#include <boost/geometry/geometries/helper_geometry.hpp>
+
+#include <boost/geometry/algorithms/transform.hpp>
+
+#include <boost/geometry/algorithms/detail/normalize.hpp>
+
+#include <boost/geometry/algorithms/dispatch/disjoint.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace disjoint
+{
+
+
+template <std::size_t Dimension, std::size_t DimensionCount>
+struct point_point_generic
+{
+    template <typename Point1, typename Point2, typename Strategy>
+    static inline bool apply(Point1 const& p1, Point2 const& p2, Strategy const& )
+    {
+        return apply(p1, p2);
+    }
+
+    template <typename Point1, typename Point2>
+    static inline bool apply(Point1 const& p1, Point2 const& p2)
+    {
+        if (! geometry::math::equals(get<Dimension>(p1), get<Dimension>(p2)))
+        {
+            return true;
+        }
+        return
+            point_point_generic<Dimension + 1, DimensionCount>::apply(p1, p2);
+    }
+};
+
+template <std::size_t DimensionCount>
+struct point_point_generic<DimensionCount, DimensionCount>
+{
+    template <typename Point1, typename Point2>
+    static inline bool apply(Point1 const&, Point2 const& )
+    {
+        return false;
+    }
+};
+
+
+class point_point_on_spheroid
+{
+private:
+    template <typename Point1, typename Point2, bool SameUnits>
+    struct are_same_points
+    {
+        static inline bool apply(Point1 const& point1, Point2 const& point2)
+        {
+            typedef typename helper_geometry<Point1>::type helper_point_type1;
+            typedef typename helper_geometry<Point2>::type helper_point_type2;
+
+            helper_point_type1 point1_normalized
+                = return_normalized<helper_point_type1>(point1);
+            helper_point_type2 point2_normalized
+                = return_normalized<helper_point_type2>(point2);
+
+            return point_point_generic
+                <
+                    0, dimension<Point1>::value
+                >::apply(point1_normalized, point2_normalized);
+        }
+    };
+
+    template <typename Point1, typename Point2>
+    struct are_same_points<Point1, Point2, false> // points have different units
+    {
+        static inline bool apply(Point1 const& point1, Point2 const& point2)
+        {
+            typedef typename geometry::select_most_precise
+                <
+                    typename fp_coordinate_type<Point1>::type,
+                    typename fp_coordinate_type<Point2>::type
+                >::type calculation_type;
+
+            typename helper_geometry
+                <
+                    Point1, calculation_type, radian
+                >::type helper_point1, helper_point2;
+
+            Point1 point1_normalized = return_normalized<Point1>(point1);
+            Point2 point2_normalized = return_normalized<Point2>(point2);
+
+            geometry::transform(point1_normalized, helper_point1);
+            geometry::transform(point2_normalized, helper_point2);
+
+            return point_point_generic
+                <
+                    0, dimension<Point1>::value
+                >::apply(helper_point1, helper_point2);
+        }
+    };
+
+public:
+    template <typename Point1, typename Point2, typename Strategy>
+    static inline bool apply(Point1 const& point1, Point2 const& point2, Strategy const& )
+    {
+        return apply(point1, point2);
+    }
+
+    template <typename Point1, typename Point2>
+    static inline bool apply(Point1 const& point1, Point2 const& point2)
+    {
+        return are_same_points
+            <
+                Point1,
+                Point2,
+                boost::is_same
+                    <
+                        typename coordinate_system<Point1>::type::units,
+                        typename coordinate_system<Point2>::type::units
+                    >::value
+            >::apply(point1, point2);
+    }
+};
+
+
+template
+<
+    typename Point1, typename Point2,
+    std::size_t Dimension, std::size_t DimensionCount,
+    typename CSTag1 = typename cs_tag<Point1>::type,
+    typename CSTag2 = CSTag1
+>
+struct point_point
+    : point_point<Point1, Point2, Dimension, DimensionCount, cartesian_tag>
+{};
+
+template
+<
+    typename Point1, typename Point2,
+    std::size_t Dimension, std::size_t DimensionCount
+>
+struct point_point
+    <
+        Point1, Point2, Dimension, DimensionCount, spherical_equatorial_tag
+    > : point_point_on_spheroid
+{};
+
+template
+<
+    typename Point1, typename Point2,
+    std::size_t Dimension, std::size_t DimensionCount
+>
+struct point_point
+    <
+        Point1, Point2, Dimension, DimensionCount, geographic_tag
+    > : point_point_on_spheroid
+{};
+
+template
+<
+    typename Point1, typename Point2,
+    std::size_t Dimension, std::size_t DimensionCount
+>
+struct point_point<Point1, Point2, Dimension, DimensionCount, cartesian_tag>
+    : point_point_generic<Dimension, DimensionCount>
+{};
+
+
+/*!
+    \brief Internal utility function to detect of points are disjoint
+    \note To avoid circular references
+ */
+template <typename Point1, typename Point2>
+inline bool disjoint_point_point(Point1 const& point1, Point2 const& point2)
+{
+    return point_point
+        <
+            Point1, Point2,
+            0, dimension<Point1>::type::value
+        >::apply(point1, point2);
+}
+
+
+}} // namespace detail::disjoint
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Point1, typename Point2, std::size_t DimensionCount>
+struct disjoint<Point1, Point2, DimensionCount, point_tag, point_tag, false>
+    : detail::disjoint::point_point<Point1, Point2, 0, DimensionCount>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_POINT_POINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/segment_box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/segment_box.hpp
new file mode 100644
index 00000000000..fe849e10918
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/disjoint/segment_box.hpp
@@ -0,0 +1,231 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013-2017.
+// Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_SEGMENT_BOX_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_SEGMENT_BOX_HPP
+
+#include <cstddef>
+
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/core/radian_access.hpp>
+
+#include <boost/geometry/algorithms/detail/assign_indexed_point.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/point_box.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/box_box.hpp>
+#include <boost/geometry/algorithms/detail/envelope/segment.hpp>
+#include <boost/geometry/algorithms/detail/normalize.hpp>
+#include <boost/geometry/algorithms/dispatch/disjoint.hpp>
+
+#include <boost/geometry/formulas/vertex_longitude.hpp>
+
+#include <boost/geometry/geometries/box.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace disjoint
+{
+
+template <typename CS_Tag>
+struct disjoint_segment_box_sphere_or_spheroid
+{
+private:
+
+    template <typename CT>
+    static inline void swap(CT& lon1,
+                            CT& lat1,
+                            CT& lon2,
+                            CT& lat2)
+    {
+        std::swap(lon1, lon2);
+        std::swap(lat1, lat2);
+    }
+
+
+public:
+
+    template <typename Segment, typename Box, typename Strategy>
+    static inline bool apply(Segment const& segment,
+                             Box const& box,
+                             Strategy const& azimuth_strategy)
+    {
+        assert_dimension_equal<Segment, Box>();
+
+        typedef typename point_type<Segment>::type segment_point_type;
+        typedef typename cs_tag<Segment>::type segment_cs_type;
+
+        segment_point_type p0, p1;
+        geometry::detail::assign_point_from_index<0>(segment, p0);
+        geometry::detail::assign_point_from_index<1>(segment, p1);
+
+        // Simplest cases first
+
+        // Case 1: if box contains one of segment's endpoints then they are not disjoint
+        if (! disjoint_point_box(p0, box) || ! disjoint_point_box(p1, box))
+        {
+            return false;
+        }
+
+        // Case 2: disjoint if bounding boxes are disjoint
+
+        typedef typename coordinate_type<segment_point_type>::type CT;
+
+        segment_point_type p0_normalized =
+                geometry::detail::return_normalized<segment_point_type>(p0);
+        segment_point_type p1_normalized =
+                geometry::detail::return_normalized<segment_point_type>(p1);
+
+        CT lon1 = geometry::get_as_radian<0>(p0_normalized);
+        CT lat1 = geometry::get_as_radian<1>(p0_normalized);
+        CT lon2 = geometry::get_as_radian<0>(p1_normalized);
+        CT lat2 = geometry::get_as_radian<1>(p1_normalized);
+
+        if (lon1 > lon2)
+        {
+            swap(lon1, lat1, lon2, lat2);
+        }
+
+        //Compute alp1 outside envelope and pass it to envelope_segment_impl
+        //in order for it to be used later in the algorithm
+        CT alp1;
+
+        azimuth_strategy.apply(lon1, lat1, lon2, lat2, alp1);
+
+        geometry::model::box<segment_point_type> box_seg;
+
+        geometry::detail::envelope::envelope_segment_impl<segment_cs_type>
+                ::template apply<geometry::radian>(lon1, lat1,
+                                                   lon2, lat2,
+                                                   box_seg,
+                                                   azimuth_strategy,
+                                                   alp1);
+        if (disjoint_box_box(box, box_seg))
+        {
+            return true;
+        }
+
+        // Case 3: test intersection by comparing angles
+
+        CT a_b0, a_b1, a_b2, a_b3;
+
+        CT b_lon_min = geometry::get_as_radian<geometry::min_corner, 0>(box);
+        CT b_lat_min = geometry::get_as_radian<geometry::min_corner, 1>(box);
+        CT b_lon_max = geometry::get_as_radian<geometry::max_corner, 0>(box);
+        CT b_lat_max = geometry::get_as_radian<geometry::max_corner, 1>(box);
+
+        azimuth_strategy.apply(lon1, lat1, b_lon_min, b_lat_min, a_b0);
+        azimuth_strategy.apply(lon1, lat1, b_lon_max, b_lat_min, a_b1);
+        azimuth_strategy.apply(lon1, lat1, b_lon_min, b_lat_max, a_b2);
+        azimuth_strategy.apply(lon1, lat1, b_lon_max, b_lat_max, a_b3);
+
+        bool b0 = alp1 > a_b0;
+        bool b1 = alp1 > a_b1;
+        bool b2 = alp1 > a_b2;
+        bool b3 = alp1 > a_b3;
+
+        // if not all box points on the same side of the segment then
+        // there is an intersection
+        if (!(b0 && b1 && b2 && b3) && (b0 || b1 || b2 || b3))
+        {
+            return false;
+        }
+
+        // Case 4: The only intersection case not covered above is when all four
+        // points of the box are above (below) the segment in northern (southern)
+        // hemisphere. Then we have to compute the vertex of the segment
+
+        CT vertex_lat;
+        CT lat_sum = lat1 + lat2;
+
+        if ((b0 && b1 && b2 && b3 && lat_sum > CT(0))
+                || (!(b0 && b1 && b2 && b3) && lat_sum < CT(0)))
+        {
+            CT b_lat_below; //latitude of box closest to equator
+
+            if (lat_sum > CT(0))
+            {
+                vertex_lat = geometry::get_as_radian<geometry::max_corner, 1>(box_seg);
+                b_lat_below = b_lat_min;
+            } else {
+                vertex_lat = geometry::get_as_radian<geometry::min_corner, 1>(box_seg);
+                b_lat_below = b_lat_max;
+            }
+
+            //optimization TODO: computing the spherical longitude should suffice for
+            // the majority of cases
+            CT vertex_lon = geometry::formula::vertex_longitude<CT, CS_Tag>
+                                    ::apply(lon1, lat1,
+                                            lon2, lat2,
+                                            vertex_lat,
+                                            alp1,
+                                            azimuth_strategy);
+
+            // Check if the vertex point is within the band defined by the
+            // minimum and maximum longitude of the box; if yes, then return
+            // false if the point is above the min latitude of the box; return
+            // true in all other cases
+            if (vertex_lon >= b_lon_min && vertex_lon <= b_lon_max
+                    && std::abs(vertex_lat) > std::abs(b_lat_below))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+};
+
+struct disjoint_segment_box
+{
+    template <typename Segment, typename Box, typename Strategy>
+    static inline bool apply(Segment const& segment,
+                             Box const& box,
+                             Strategy const& strategy)
+    {
+        return strategy.apply(segment, box);
+    }
+};
+
+}} // namespace detail::disjoint
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Segment, typename Box, std::size_t DimensionCount>
+struct disjoint<Segment, Box, DimensionCount, segment_tag, box_tag, false>
+        : detail::disjoint::disjoint_segment_box
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISJOINT_SEGMENT_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/backward_compatibility.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/backward_compatibility.hpp
new file mode 100644
index 00000000000..5b49e571ddf
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/backward_compatibility.hpp
@@ -0,0 +1,333 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_BACKWARD_COMPATIBILITY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_BACKWARD_COMPATIBILITY_HPP
+
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/tags.hpp>
+
+#include <boost/geometry/algorithms/assign.hpp>
+
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+
+#include <boost/geometry/algorithms/detail/distance/default_strategies.hpp>
+#include <boost/geometry/algorithms/detail/distance/point_to_geometry.hpp>
+#include <boost/geometry/algorithms/detail/distance/multipoint_to_geometry.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+template<typename Point, typename Segment, typename Strategy>
+struct point_to_segment
+{
+    static inline typename strategy::distance::services::return_type
+        <
+            Strategy,
+            Point,
+            typename point_type<Segment>::type
+        >::type
+    apply(Point const& point, Segment const& segment, Strategy const& )
+    {
+        typename detail::distance::default_ps_strategy
+            <
+                Point,
+                typename point_type<Segment>::type,
+                Strategy
+            >::type segment_strategy;
+
+        typename point_type<Segment>::type p[2];
+        geometry::detail::assign_point_from_index<0>(segment, p[0]);
+        geometry::detail::assign_point_from_index<1>(segment, p[1]);
+        return segment_strategy.apply(point, p[0], p[1]);
+    }
+};
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// Point-segment version 1, with point-point strategy
+template <typename Point, typename Segment, typename Strategy>
+struct distance
+<
+    Point, Segment, Strategy,
+    point_tag, segment_tag, strategy_tag_distance_point_point,
+    false
+> : detail::distance::point_to_segment<Point, Segment, Strategy>
+{};
+
+
+// Point-line version 1, where point-point strategy is specified
+template <typename Point, typename Linestring, typename Strategy>
+struct distance
+<
+    Point, Linestring, Strategy,
+    point_tag, linestring_tag, strategy_tag_distance_point_point,
+    false
+>
+{
+
+    static inline typename strategy::distance::services::return_type
+        <
+            Strategy, Point, typename point_type<Linestring>::type
+        >::type
+    apply(Point const& point,
+          Linestring const& linestring,
+          Strategy const&)
+    {
+        typedef typename detail::distance::default_ps_strategy
+                    <
+                        Point,
+                        typename point_type<Linestring>::type,
+                        Strategy
+                    >::type ps_strategy_type;
+
+        return detail::distance::point_to_range
+            <
+                Point, Linestring, closed, ps_strategy_type
+            >::apply(point, linestring, ps_strategy_type());
+    }
+};
+
+
+// Point-ring , where point-point strategy is specified
+template <typename Point, typename Ring, typename Strategy>
+struct distance
+<
+    Point, Ring, Strategy,
+    point_tag, ring_tag, strategy_tag_distance_point_point,
+    false
+>
+{
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy, Point, typename point_type<Ring>::type
+        >::type return_type;
+
+    static inline return_type apply(Point const& point,
+            Ring const& ring,
+            Strategy const&)
+    {
+        typedef typename detail::distance::default_ps_strategy
+            <
+                Point,
+                typename point_type<Ring>::type,
+                Strategy
+            >::type ps_strategy_type;
+
+        return detail::distance::point_to_ring
+            <
+                Point, Ring,
+                geometry::closure<Ring>::value,
+                ps_strategy_type
+            >::apply(point, ring, ps_strategy_type());
+    }
+};
+
+
+// Point-polygon , where point-point strategy is specified
+template <typename Point, typename Polygon, typename Strategy>
+struct distance
+<
+    Point, Polygon, Strategy,
+    point_tag, polygon_tag, strategy_tag_distance_point_point,
+    false
+>
+{
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy, Point, typename point_type<Polygon>::type
+        >::type return_type;
+
+    static inline return_type apply(Point const& point,
+                                    Polygon const& polygon,
+                                    Strategy const&)
+    {
+        typedef typename detail::distance::default_ps_strategy
+            <
+                Point,
+                typename point_type<Polygon>::type,
+                Strategy
+            >::type ps_strategy_type;
+
+        return detail::distance::point_to_polygon
+            <
+                Point,
+                Polygon,
+                geometry::closure<Polygon>::value,
+                ps_strategy_type
+            >::apply(point, polygon, ps_strategy_type());
+    }
+};
+
+
+
+
+template
+<
+    typename Point,
+    typename MultiGeometry,
+    typename MultiGeometryTag,
+    typename Strategy
+>
+struct distance
+    <
+        Point, MultiGeometry, Strategy,
+        point_tag, MultiGeometryTag,
+        strategy_tag_distance_point_point, false
+    >
+{
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy, Point, typename point_type<MultiGeometry>::type
+        >::type return_type;
+
+    static inline return_type apply(Point const& point,
+                                    MultiGeometry const& multigeometry,
+                                    Strategy const&)
+    {
+        typedef typename detail::distance::default_ps_strategy
+            <
+                Point,
+                typename point_type<MultiGeometry>::type,
+                Strategy
+            >::type ps_strategy_type;
+    
+        return distance
+            <
+                Point, MultiGeometry, ps_strategy_type,
+                point_tag, MultiGeometryTag,
+                strategy_tag_distance_point_segment, false
+            >::apply(point, multigeometry, ps_strategy_type());
+    }
+};
+
+
+template
+<
+    typename Geometry,
+    typename MultiPoint,
+    typename GeometryTag,
+    typename Strategy
+>
+struct distance
+    <
+        Geometry, MultiPoint, Strategy,
+        GeometryTag, multi_point_tag,
+        strategy_tag_distance_point_point, false
+    >
+{
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy,
+            typename point_type<MultiPoint>::type,
+            typename point_type<Geometry>::type
+        >::type return_type;
+
+    static inline return_type apply(Geometry const& geometry,
+                                    MultiPoint const& multipoint,
+                                    Strategy const&)
+    {
+        typedef typename detail::distance::default_ps_strategy
+            <
+                typename point_type<MultiPoint>::type,
+                typename point_type<Geometry>::type,
+                Strategy
+            >::type ps_strategy_type;
+    
+        return distance
+            <
+                Geometry, MultiPoint, ps_strategy_type,
+                GeometryTag, multi_point_tag,
+                strategy_tag_distance_point_segment, false
+            >::apply(geometry, multipoint, ps_strategy_type());
+    }
+};
+
+
+template
+<
+    typename MultiPoint,
+    typename MultiGeometry,
+    typename MultiGeometryTag,
+    typename Strategy
+>
+struct distance
+    <
+        MultiPoint, MultiGeometry, Strategy,
+        multi_point_tag, MultiGeometryTag,
+        strategy_tag_distance_point_point, false
+    >
+{
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy,
+            typename point_type<MultiPoint>::type, 
+            typename point_type<MultiGeometry>::type
+        >::type return_type;
+
+    static inline return_type apply(MultiPoint const& multipoint,
+                                    MultiGeometry const& multigeometry,
+                                    Strategy const&)
+    {
+        typedef typename detail::distance::default_ps_strategy
+            <
+                typename point_type<MultiPoint>::type,
+                typename point_type<MultiGeometry>::type,
+                Strategy
+            >::type ps_strategy_type;
+    
+        return distance
+            <
+                MultiPoint, MultiGeometry, ps_strategy_type,
+                multi_point_tag, MultiGeometryTag,
+                strategy_tag_distance_point_segment, false
+            >::apply(multipoint, multigeometry, ps_strategy_type());
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_BACKWARD_COMPATIBILITY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/box_to_box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/box_to_box.hpp
new file mode 100644
index 00000000000..44778e9e067
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/box_to_box.hpp
@@ -0,0 +1,60 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_BOX_TO_BOX_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_BOX_TO_BOX_HPP
+
+#include <boost/core/ignore_unused.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/tags.hpp>
+
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Box1, typename Box2, typename Strategy>
+struct distance
+    <
+        Box1, Box2, Strategy, box_tag, box_tag,
+        strategy_tag_distance_box_box, false
+    >
+{
+    static inline typename strategy::distance::services::return_type
+        <
+            Strategy,
+            typename point_type<Box1>::type,
+            typename point_type<Box2>::type
+        >::type
+    apply(Box1 const& box1, Box2 const& box2, Strategy const& strategy)
+    {
+        boost::ignore_unused(strategy);
+        return strategy.apply(box1, box2);
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_BOX_TO_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/default_strategies.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/default_strategies.hpp
new file mode 100644
index 00000000000..a01ace2b585
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/default_strategies.hpp
@@ -0,0 +1,137 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_DEFAULT_STRATEGIES_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_DEFAULT_STRATEGIES_HPP
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/reverse_dispatch.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+
+// Helper metafunction for default strategy retrieval
+template
+<
+    typename Geometry1,
+    typename Geometry2 = Geometry1,
+    typename Tag1 = typename tag_cast
+        <
+            typename tag<Geometry1>::type, pointlike_tag
+        >::type,
+    typename Tag2 = typename tag_cast
+        <
+            typename tag<Geometry2>::type, pointlike_tag
+        >::type,
+    bool Reverse = geometry::reverse_dispatch<Geometry1, Geometry2>::type::value
+>
+struct default_strategy
+    : strategy::distance::services::default_strategy
+          <
+              point_tag, segment_tag,
+              typename point_type<Geometry1>::type,
+              typename point_type<Geometry2>::type
+          >
+{};
+
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename Tag1,
+    typename Tag2
+>
+struct default_strategy<Geometry1, Geometry2, Tag1, Tag2, true>
+    : default_strategy<Geometry2, Geometry1, Tag2, Tag1, false>
+{};
+
+
+template <typename Pointlike1, typename Pointlike2>
+struct default_strategy
+    <
+        Pointlike1, Pointlike2,
+        pointlike_tag, pointlike_tag, false
+    > : strategy::distance::services::default_strategy
+          <
+              point_tag, point_tag,
+              typename point_type<Pointlike1>::type,
+              typename point_type<Pointlike2>::type
+          >
+{};
+
+
+template <typename Pointlike, typename Box>
+struct default_strategy<Pointlike, Box, pointlike_tag, box_tag, false>
+    : strategy::distance::services::default_strategy
+          <
+              point_tag, box_tag,
+              typename point_type<Pointlike>::type,
+              typename point_type<Box>::type
+          >
+{};
+
+
+template <typename Box1, typename Box2>
+struct default_strategy<Box1, Box2, box_tag, box_tag, false>
+    : strategy::distance::services::default_strategy
+          <
+              box_tag, box_tag,
+              typename point_type<Box1>::type,
+              typename point_type<Box2>::type
+          >
+{};
+
+
+
+// Helper metafunction for default point-segment strategy retrieval
+template <typename Geometry1, typename Geometry2, typename Strategy>
+struct default_ps_strategy
+    : strategy::distance::services::default_strategy
+          <
+              point_tag, segment_tag,
+              typename point_type<Geometry1>::type,
+              typename point_type<Geometry2>::type,
+              typename cs_tag<typename point_type<Geometry1>::type>::type,
+              typename cs_tag<typename point_type<Geometry2>::type>::type,
+              Strategy
+          >
+{};
+
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_DEFAULT_STRATEGIES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/geometry_to_segment_or_box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/geometry_to_segment_or_box.hpp
new file mode 100644
index 00000000000..d6de7cac91b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/geometry_to_segment_or_box.hpp
@@ -0,0 +1,464 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_GEOMETRY_TO_SEGMENT_OR_BOX_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_GEOMETRY_TO_SEGMENT_OR_BOX_HPP
+
+#include <iterator>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/tags.hpp>
+
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/algorithms/intersects.hpp>
+#include <boost/geometry/algorithms/num_points.hpp>
+
+#include <boost/geometry/iterators/point_iterator.hpp>
+#include <boost/geometry/iterators/segment_iterator.hpp>
+
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+
+#include <boost/geometry/algorithms/detail/closest_feature/geometry_to_range.hpp>
+#include <boost/geometry/algorithms/detail/closest_feature/point_to_range.hpp>
+
+#include <boost/geometry/algorithms/detail/distance/is_comparable.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+// closure of segment or box point range
+template
+<
+    typename SegmentOrBox,
+    typename Tag = typename tag<SegmentOrBox>::type
+>
+struct segment_or_box_point_range_closure
+    : not_implemented<SegmentOrBox>
+{};    
+
+template <typename Segment>
+struct segment_or_box_point_range_closure<Segment, segment_tag>
+{
+    static const closure_selector value = closed;
+};
+
+template <typename Box>
+struct segment_or_box_point_range_closure<Box, box_tag>
+{
+    static const closure_selector value = open;
+};
+
+
+
+template
+<
+    typename Geometry,
+    typename SegmentOrBox,
+    typename Strategy,
+    typename Tag = typename tag<Geometry>::type
+>
+class geometry_to_segment_or_box
+{
+private:
+    typedef typename point_type<SegmentOrBox>::type segment_or_box_point;
+
+    typedef typename strategy::distance::services::comparable_type
+       <
+           Strategy
+       >::type comparable_strategy;
+
+    typedef detail::closest_feature::point_to_point_range
+        <
+            typename point_type<Geometry>::type,
+            std::vector<segment_or_box_point>,
+            segment_or_box_point_range_closure<SegmentOrBox>::value,
+            comparable_strategy
+        > point_to_point_range;
+
+    typedef detail::closest_feature::geometry_to_range geometry_to_range;
+
+    typedef typename strategy::distance::services::return_type
+        <
+            comparable_strategy,
+            typename point_type<Geometry>::type,
+            segment_or_box_point
+        >::type comparable_return_type;
+
+
+    // assign the new minimum value for an iterator of the point range
+    // of a segment or a box
+    template
+    <
+        typename SegOrBox,
+        typename SegOrBoxTag = typename tag<SegOrBox>::type
+    >
+    struct assign_new_min_iterator
+        : not_implemented<SegOrBox>
+    {};
+
+    template <typename Segment>
+    struct assign_new_min_iterator<Segment, segment_tag>
+    {
+        template <typename Iterator>
+        static inline void apply(Iterator&, Iterator)
+        {
+        }
+    };
+
+    template <typename Box>
+    struct assign_new_min_iterator<Box, box_tag>
+    {
+        template <typename Iterator>
+        static inline void apply(Iterator& it_min, Iterator it)
+        {
+            it_min = it;
+        }
+    };
+
+
+    // assign the points of a segment or a box to a range
+    template
+    <
+        typename SegOrBox,
+        typename PointRange,
+        typename SegOrBoxTag = typename tag<SegOrBox>::type
+    >
+    struct assign_segment_or_box_points
+    {};
+
+    template <typename Segment, typename PointRange>
+    struct assign_segment_or_box_points<Segment, PointRange, segment_tag>
+    {
+        static inline void apply(Segment const& segment, PointRange& range)
+        {
+            detail::assign_point_from_index<0>(segment, range[0]);
+            detail::assign_point_from_index<1>(segment, range[1]);
+        }
+    };
+
+    template <typename Box, typename PointRange>
+    struct assign_segment_or_box_points<Box, PointRange, box_tag>
+    {
+        static inline void apply(Box const& box, PointRange& range)
+        {
+            detail::assign_box_corners_oriented<true>(box, range);
+        }
+    };
+
+
+public:
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy,
+            typename point_type<Geometry>::type,
+            segment_or_box_point
+        >::type return_type;
+
+    static inline return_type apply(Geometry const& geometry,
+                                    SegmentOrBox const& segment_or_box,
+                                    Strategy const& strategy,
+                                    bool check_intersection = true)
+    {
+        typedef geometry::point_iterator<Geometry const> point_iterator_type;
+        typedef geometry::segment_iterator
+            <
+                Geometry const
+            > segment_iterator_type;
+
+        typedef typename boost::range_const_iterator
+            <
+                std::vector<segment_or_box_point>
+            >::type seg_or_box_const_iterator;
+
+        typedef assign_new_min_iterator<SegmentOrBox> assign_new_value;
+
+
+        if (check_intersection
+            && geometry::intersects(geometry, segment_or_box))
+        {
+            return 0;
+        }
+
+        comparable_strategy cstrategy =
+            strategy::distance::services::get_comparable
+                <
+                    Strategy
+                >::apply(strategy);
+
+        // get all points of the segment or the box
+        std::vector<segment_or_box_point>
+            seg_or_box_points(geometry::num_points(segment_or_box));
+
+        assign_segment_or_box_points
+            <
+                SegmentOrBox, 
+                std::vector<segment_or_box_point>
+            >::apply(segment_or_box, seg_or_box_points);
+
+        // consider all distances of the points in the geometry to the
+        // segment or box
+        comparable_return_type cd_min1(0);
+        point_iterator_type pit_min;
+        seg_or_box_const_iterator it_min1 = boost::const_begin(seg_or_box_points);
+        seg_or_box_const_iterator it_min2 = it_min1;
+        ++it_min2;
+        bool first = true;
+
+        for (point_iterator_type pit = points_begin(geometry);
+             pit != points_end(geometry); ++pit, first = false)
+        {
+            comparable_return_type cd;
+            std::pair
+                <
+                    seg_or_box_const_iterator, seg_or_box_const_iterator
+                > it_pair
+                = point_to_point_range::apply(*pit,
+                                              boost::const_begin(seg_or_box_points),
+                                              boost::const_end(seg_or_box_points),
+                                              cstrategy,
+                                              cd);
+
+            if (first || cd < cd_min1)
+            {
+                cd_min1 = cd;
+                pit_min = pit;
+                assign_new_value::apply(it_min1, it_pair.first);
+                assign_new_value::apply(it_min2, it_pair.second);
+            }
+        }
+
+        // consider all distances of the points in the segment or box to the
+        // segments of the geometry
+        comparable_return_type cd_min2(0);
+        segment_iterator_type sit_min;
+        seg_or_box_const_iterator it_min;
+
+        first = true;
+        for (seg_or_box_const_iterator it = boost::const_begin(seg_or_box_points);
+             it != boost::const_end(seg_or_box_points); ++it, first = false)
+        {
+            comparable_return_type cd;
+            segment_iterator_type sit
+                = geometry_to_range::apply(*it,
+                                           segments_begin(geometry),
+                                           segments_end(geometry),
+                                           cstrategy,
+                                           cd);
+
+            if (first || cd < cd_min2)
+            {
+                cd_min2 = cd;
+                it_min = it;
+                sit_min = sit;
+            }
+        }
+
+        if (BOOST_GEOMETRY_CONDITION(is_comparable<Strategy>::value))
+        {
+            return (std::min)(cd_min1, cd_min2);
+        }
+
+        if (cd_min1 < cd_min2)
+        {
+            return strategy.apply(*pit_min, *it_min1, *it_min2);
+        }
+        else
+        {
+            return dispatch::distance
+                <
+                    segment_or_box_point,
+                    typename std::iterator_traits
+                        <
+                            segment_iterator_type
+                        >::value_type,
+                    Strategy
+                >::apply(*it_min, *sit_min, strategy);
+        }
+    }
+
+
+    static inline return_type
+    apply(SegmentOrBox const& segment_or_box, Geometry const& geometry, 
+          Strategy const& strategy, bool check_intersection = true)
+    {
+        return apply(geometry, segment_or_box, strategy, check_intersection);
+    }
+};
+
+
+
+template <typename MultiPoint, typename SegmentOrBox, typename Strategy>
+class geometry_to_segment_or_box
+    <
+        MultiPoint, SegmentOrBox, Strategy, multi_point_tag
+    >
+{
+private:
+    typedef detail::closest_feature::geometry_to_range base_type;
+
+    typedef typename boost::range_iterator
+        <
+            MultiPoint const
+        >::type iterator_type;
+
+    typedef detail::closest_feature::geometry_to_range geometry_to_range;
+
+public:
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy,
+            typename point_type<SegmentOrBox>::type,
+            typename point_type<MultiPoint>::type
+        >::type return_type;
+
+    static inline return_type apply(MultiPoint const& multipoint,
+                                    SegmentOrBox const& segment_or_box,
+                                    Strategy const& strategy)
+    {
+        namespace sds = strategy::distance::services;
+
+        typename sds::return_type
+            <
+                typename sds::comparable_type<Strategy>::type,
+                typename point_type<SegmentOrBox>::type,
+                typename point_type<MultiPoint>::type
+            >::type cd_min;
+
+        iterator_type it_min
+            = geometry_to_range::apply(segment_or_box,
+                                       boost::begin(multipoint),
+                                       boost::end(multipoint),
+                                       sds::get_comparable
+                                           <
+                                               Strategy
+                                           >::apply(strategy),
+                                       cd_min);
+
+        return
+            is_comparable<Strategy>::value
+            ?
+            cd_min
+            :
+            dispatch::distance
+                <
+                    typename point_type<MultiPoint>::type,
+                    SegmentOrBox,
+                    Strategy
+                >::apply(*it_min, segment_or_box, strategy);
+    }
+};
+
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Linear, typename Segment, typename Strategy>
+struct distance
+    <
+        Linear, Segment, Strategy, linear_tag, segment_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::geometry_to_segment_or_box<Linear, Segment, Strategy>
+{};
+
+
+template <typename Areal, typename Segment, typename Strategy>
+struct distance
+    <
+        Areal, Segment, Strategy, areal_tag, segment_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::geometry_to_segment_or_box<Areal, Segment, Strategy>
+{};
+
+
+template <typename Segment, typename Areal, typename Strategy>
+struct distance
+    <
+        Segment, Areal, Strategy, segment_tag, areal_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::geometry_to_segment_or_box<Areal, Segment, Strategy>
+{};
+
+
+template <typename Linear, typename Box, typename Strategy>
+struct distance
+    <
+        Linear, Box, Strategy, linear_tag, box_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::geometry_to_segment_or_box
+        <
+            Linear, Box, Strategy
+        >
+{};
+
+
+template <typename Areal, typename Box, typename Strategy>
+struct distance
+    <
+        Areal, Box, Strategy, areal_tag, box_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::geometry_to_segment_or_box<Areal, Box, Strategy>
+{};
+
+
+template <typename MultiPoint, typename Segment, typename Strategy>
+struct distance
+    <
+        MultiPoint, Segment, Strategy,
+        multi_point_tag, segment_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::geometry_to_segment_or_box
+        <
+            MultiPoint, Segment, Strategy
+        >
+{};
+
+
+template <typename MultiPoint, typename Box, typename Strategy>
+struct distance
+    <
+        MultiPoint, Box, Strategy,
+        multi_point_tag, box_tag,
+        strategy_tag_distance_point_box, false
+    > : detail::distance::geometry_to_segment_or_box
+        <
+            MultiPoint, Box, Strategy
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_GEOMETRY_TO_SEGMENT_OR_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/implementation.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/implementation.hpp
new file mode 100644
index 00000000000..7c009f4d79d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/implementation.hpp
@@ -0,0 +1,35 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_IMPLEMENTATION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_IMPLEMENTATION_HPP
+
+// the implementation details
+#include <boost/geometry/algorithms/detail/distance/point_to_geometry.hpp>
+#include <boost/geometry/algorithms/detail/distance/multipoint_to_geometry.hpp>
+#include <boost/geometry/algorithms/detail/distance/linear_to_linear.hpp>
+#include <boost/geometry/algorithms/detail/distance/linear_or_areal_to_areal.hpp>
+#include <boost/geometry/algorithms/detail/distance/geometry_to_segment_or_box.hpp>
+#include <boost/geometry/algorithms/detail/distance/segment_to_segment.hpp>
+#include <boost/geometry/algorithms/detail/distance/segment_to_box.hpp>
+#include <boost/geometry/algorithms/detail/distance/box_to_box.hpp>
+
+#include <boost/geometry/algorithms/detail/distance/backward_compatibility.hpp>
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_IMPLEMENTATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/interface.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/interface.hpp
new file mode 100644
index 00000000000..53d24d99207
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/interface.hpp
@@ -0,0 +1,403 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+// Copyright (c) 2014 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_INTERFACE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_INTERFACE_HPP
+
+#include <boost/concept_check.hpp>
+
+#include <boost/mpl/always.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/vector.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/default_distance_result.hpp>
+#include <boost/geometry/strategies/distance_result.hpp>
+
+#include <boost/geometry/algorithms/detail/throw_on_empty_input.hpp>
+#include <boost/geometry/algorithms/detail/distance/default_strategies.hpp>
+
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// If reversal is needed, perform it
+template
+<
+    typename Geometry1, typename Geometry2, typename Strategy,
+    typename Tag1, typename Tag2, typename StrategyTag
+>
+struct distance
+<
+    Geometry1, Geometry2, Strategy,
+    Tag1, Tag2, StrategyTag,
+    true
+>
+    : distance<Geometry2, Geometry1, Strategy, Tag2, Tag1, StrategyTag, false>
+{
+    typedef typename strategy::distance::services::return_type
+                     <
+                         Strategy,
+                         typename point_type<Geometry2>::type,
+                         typename point_type<Geometry1>::type
+                     >::type return_type;
+
+    static inline return_type apply(
+        Geometry1 const& g1,
+        Geometry2 const& g2,
+        Strategy const& strategy)
+    {
+        return distance
+            <
+                Geometry2, Geometry1, Strategy,
+                Tag2, Tag1, StrategyTag,
+                false
+            >::apply(g2, g1, strategy);
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_strategy
+{
+
+struct distance
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline typename distance_result<Geometry1, Geometry2, Strategy>::type
+    apply(Geometry1 const& geometry1,
+          Geometry2 const& geometry2,
+          Strategy const& strategy)
+    {
+        return dispatch::distance
+            <
+                Geometry1, Geometry2, Strategy
+            >::apply(geometry1, geometry2, strategy);
+    }
+
+    template <typename Geometry1, typename Geometry2>
+    static inline
+    typename distance_result<Geometry1, Geometry2, default_strategy>::type
+    apply(Geometry1 const& geometry1,
+          Geometry2 const& geometry2,
+          default_strategy)
+    {
+        typedef typename detail::distance::default_strategy
+            <
+                Geometry1, Geometry2
+            >::type strategy_type;
+
+        return dispatch::distance
+            <
+                Geometry1, Geometry2, strategy_type
+            >::apply(geometry1, geometry2, strategy_type());
+    }
+};
+
+} // namespace resolve_strategy
+
+
+namespace resolve_variant
+{
+
+
+template <typename Geometry1, typename Geometry2>
+struct distance
+{
+    template <typename Strategy>
+    static inline typename distance_result<Geometry1, Geometry2, Strategy>::type
+    apply(Geometry1 const& geometry1,
+          Geometry2 const& geometry2,
+          Strategy const& strategy)
+    {
+        return
+            resolve_strategy::distance::apply(geometry1, geometry2, strategy);
+    }
+};
+
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
+struct distance<variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
+{
+    template <typename Strategy>
+    struct visitor: static_visitor
+        <
+            typename distance_result
+                <
+                    variant<BOOST_VARIANT_ENUM_PARAMS(T)>,
+                    Geometry2,
+                    Strategy
+                >::type
+        >
+    {
+        Geometry2 const& m_geometry2;
+        Strategy const& m_strategy;
+
+        visitor(Geometry2 const& geometry2,
+                Strategy const& strategy)
+            : m_geometry2(geometry2),
+              m_strategy(strategy)
+        {}
+
+        template <typename Geometry1>
+        typename distance_result<Geometry1, Geometry2, Strategy>::type
+        operator()(Geometry1 const& geometry1) const
+        {
+            return distance
+                <
+                    Geometry1,
+                    Geometry2
+                >::template apply
+                    <
+                        Strategy
+                    >(geometry1, m_geometry2, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline typename distance_result
+        <
+            variant<BOOST_VARIANT_ENUM_PARAMS(T)>,
+            Geometry2,
+            Strategy
+        >::type
+    apply(variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
+          Geometry2 const& geometry2,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(geometry2, strategy), geometry1);
+    }
+};
+
+
+template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct distance<Geometry1, variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Strategy>
+    struct visitor: static_visitor
+        <
+            typename distance_result
+                <
+                    Geometry1,
+                    variant<BOOST_VARIANT_ENUM_PARAMS(T)>,
+                    Strategy
+                >::type
+        >
+    {
+        Geometry1 const& m_geometry1;
+        Strategy const& m_strategy;
+
+        visitor(Geometry1 const& geometry1,
+                Strategy const& strategy)
+            : m_geometry1(geometry1),
+              m_strategy(strategy)
+        {}
+
+        template <typename Geometry2>
+        typename distance_result<Geometry1, Geometry2, Strategy>::type
+        operator()(Geometry2 const& geometry2) const
+        {
+            return distance
+                <
+                    Geometry1,
+                    Geometry2
+                >::template apply
+                <
+                    Strategy
+                >(m_geometry1, geometry2, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline typename distance_result
+        <
+            Geometry1,
+            variant<BOOST_VARIANT_ENUM_PARAMS(T)>,
+            Strategy
+        >::type
+    apply(
+        Geometry1 const& geometry1,
+        const variant<BOOST_VARIANT_ENUM_PARAMS(T)>& geometry2,
+        Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(geometry1, strategy), geometry2);
+    }
+};
+
+
+template
+<
+    BOOST_VARIANT_ENUM_PARAMS(typename T1),
+    BOOST_VARIANT_ENUM_PARAMS(typename T2)
+>
+struct distance
+    <
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)>,
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)>
+    >
+{
+    template <typename Strategy>
+    struct visitor: static_visitor
+        <
+            typename distance_result
+                <
+                    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)>,
+                    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)>,
+                    Strategy
+                >::type
+        >
+    {
+        Strategy const& m_strategy;
+
+        visitor(Strategy const& strategy)
+            : m_strategy(strategy)
+        {}
+
+        template <typename Geometry1, typename Geometry2>
+        typename distance_result<Geometry1, Geometry2, Strategy>::type
+        operator()(Geometry1 const& geometry1, Geometry2 const& geometry2) const
+        {
+            return distance
+                <
+                    Geometry1,
+                    Geometry2
+                >::template apply
+                <
+                    Strategy
+                >(geometry1, geometry2, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline typename distance_result
+        <
+            boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)>,
+            boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)>,
+            Strategy
+        >::type
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)> const& geometry1,
+          boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(strategy), geometry1, geometry2);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief \brief_calc2{distance} \brief_strategy
+\ingroup distance
+\details
+\details \details_calc{area}. \brief_strategy. \details_strategy_reasons
+
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Strategy \tparam_strategy{Distance}
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param strategy \param_strategy{distance}
+\return \return_calc{distance}
+\note The strategy can be a point-point strategy. In case of distance point-line/point-polygon
+    it may also be a point-segment strategy.
+
+\qbk{distinguish,with strategy}
+
+\qbk{
+[heading Available Strategies]
+\* [link geometry.reference.strategies.strategy_distance_pythagoras Pythagoras (cartesian)]
+\* [link geometry.reference.strategies.strategy_distance_haversine Haversine (spherical)]
+\* [link geometry.reference.strategies.strategy_distance_cross_track Cross track (spherical\, point-to-segment)]
+\* [link geometry.reference.strategies.strategy_distance_projected_point Projected point (cartesian\, point-to-segment)]
+\* more (currently extensions): Vincenty\, Andoyer (geographic)
+}
+ */
+
+/*
+Note, in case of a Compilation Error:
+if you get:
+ - "Failed to specialize function template ..."
+ - "error: no matching function for call to ..."
+for distance, it is probably so that there is no specialization
+for return_type<...> for your strategy.
+*/
+template <typename Geometry1, typename Geometry2, typename Strategy>
+inline typename distance_result<Geometry1, Geometry2, Strategy>::type
+distance(Geometry1 const& geometry1,
+         Geometry2 const& geometry2,
+         Strategy const& strategy)
+{
+    concepts::check<Geometry1 const>();
+    concepts::check<Geometry2 const>();
+
+    detail::throw_on_empty_input(geometry1);
+    detail::throw_on_empty_input(geometry2);
+
+    return resolve_variant::distance
+               <
+                   Geometry1,
+                   Geometry2
+               >::apply(geometry1, geometry2, strategy);
+}
+
+
+/*!
+\brief \brief_calc2{distance}
+\ingroup distance
+\details The default strategy is used, corresponding to the coordinate system of the geometries
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\return \return_calc{distance}
+
+\qbk{[include reference/algorithms/distance.qbk]}
+ */
+template <typename Geometry1, typename Geometry2>
+inline typename default_distance_result<Geometry1, Geometry2>::type
+distance(Geometry1 const& geometry1,
+         Geometry2 const& geometry2)
+{
+    concepts::check<Geometry1 const>();
+    concepts::check<Geometry2 const>();
+
+    return geometry::distance(geometry1, geometry2, default_strategy());
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_INTERFACE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/is_comparable.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/is_comparable.hpp
new file mode 100644
index 00000000000..d13cc6c7404
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/is_comparable.hpp
@@ -0,0 +1,45 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHS_DETAIL_DISTANCE_IS_COMPARABLE_HPP
+#define BOOST_GEOMETRY_ALGORITHS_DETAIL_DISTANCE_IS_COMPARABLE_HPP
+
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+// metafunction to determine is a strategy is comparable or not
+template <typename Strategy>
+struct is_comparable
+    : boost::is_same
+        <
+            Strategy,
+            typename strategy::distance::services::comparable_type
+              <
+                  Strategy
+              >::type
+        >
+{};
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHS_DETAIL_DISTANCE_IS_COMPARABLE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/iterator_selector.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/iterator_selector.hpp
new file mode 100644
index 00000000000..363ec465a4d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/iterator_selector.hpp
@@ -0,0 +1,70 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHS_DETAIL_DISTANCE_ITERATOR_SELECTOR_HPP
+#define BOOST_GEOMETRY_ALGORITHS_DETAIL_DISTANCE_ITERATOR_SELECTOR_HPP
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/iterators/point_iterator.hpp>
+#include <boost/geometry/iterators/segment_iterator.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+// class to choose between point_iterator and segment_iterator
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct iterator_selector
+{
+    typedef geometry::segment_iterator<Geometry> iterator_type;
+
+    static inline iterator_type begin(Geometry& geometry)
+    {
+        return segments_begin(geometry);
+    }
+
+    static inline iterator_type end(Geometry& geometry)
+    {
+        return segments_end(geometry);
+    }
+};
+
+template <typename MultiPoint>
+struct iterator_selector<MultiPoint, multi_point_tag>
+{
+    typedef geometry::point_iterator<MultiPoint> iterator_type;
+
+    static inline iterator_type begin(MultiPoint& multipoint)
+    {
+        return points_begin(multipoint);
+    }
+
+    static inline iterator_type end(MultiPoint& multipoint)
+    {
+        return points_end(multipoint);
+    }
+};
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHS_DETAIL_DISTANCE_ITERATOR_SELECTOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/linear_or_areal_to_areal.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/linear_or_areal_to_areal.hpp
new file mode 100644
index 00000000000..b63104da7d0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/linear_or_areal_to_areal.hpp
@@ -0,0 +1,147 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_LINEAR_OR_AREAL_TO_AREAL_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_LINEAR_OR_AREAL_TO_AREAL_HPP
+
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+
+#include <boost/geometry/algorithms/intersects.hpp>
+
+#include <boost/geometry/algorithms/detail/distance/linear_to_linear.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+template <typename Linear, typename Areal, typename Strategy>
+struct linear_to_areal
+{
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy,
+            typename point_type<Linear>::type,
+            typename point_type<Areal>::type
+        >::type return_type;
+
+    static inline return_type apply(Linear const& linear,
+                                    Areal const& areal,
+                                    Strategy const& strategy)
+    {
+        if ( geometry::intersects(linear, areal) )
+        {
+            return 0;
+        }
+
+        return linear_to_linear
+            <
+                Linear, Areal, Strategy
+            >::apply(linear, areal, strategy, false);
+    }
+
+
+    static inline return_type apply(Areal const& areal,
+                                    Linear const& linear,
+                                    Strategy const& strategy)
+    {
+        return apply(linear, areal, strategy);
+    }
+};
+
+
+template <typename Areal1, typename Areal2, typename Strategy>
+struct areal_to_areal
+{
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy,
+            typename point_type<Areal1>::type,
+            typename point_type<Areal2>::type
+        >::type return_type;
+
+    static inline return_type apply(Areal1 const& areal1,
+                                    Areal2 const& areal2,
+                                    Strategy const& strategy)
+    {
+        if ( geometry::intersects(areal1, areal2) )
+        {
+            return 0;
+        }
+
+        return linear_to_linear
+            <
+                Areal1, Areal2, Strategy
+            >::apply(areal1, areal2, strategy, false);
+    }
+};
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Linear, typename Areal, typename Strategy>
+struct distance
+    <
+        Linear, Areal, Strategy,
+        linear_tag, areal_tag, 
+        strategy_tag_distance_point_segment, false
+    >
+    : detail::distance::linear_to_areal
+        <
+            Linear, Areal, Strategy
+        >
+{};
+
+
+template <typename Areal, typename Linear, typename Strategy>
+struct distance
+    <
+        Areal, Linear, Strategy,
+        areal_tag, linear_tag, 
+        strategy_tag_distance_point_segment, false
+    >
+    : detail::distance::linear_to_areal
+        <
+            Linear, Areal, Strategy
+        >
+{};
+
+
+template <typename Areal1, typename Areal2, typename Strategy>
+struct distance
+    <
+        Areal1, Areal2, Strategy,
+        areal_tag, areal_tag, 
+        strategy_tag_distance_point_segment, false
+    >
+    : detail::distance::areal_to_areal
+        <
+            Areal1, Areal2, Strategy
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_LINEAR_OR_AREAL_TO_AREAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/linear_to_linear.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/linear_to_linear.hpp
new file mode 100644
index 00000000000..e44b3728422
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/linear_to_linear.hpp
@@ -0,0 +1,123 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_LINEAR_TO_LINEAR_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_LINEAR_TO_LINEAR_HPP
+
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+
+#include <boost/geometry/iterators/point_iterator.hpp>
+#include <boost/geometry/iterators/segment_iterator.hpp>
+
+#include <boost/geometry/algorithms/num_points.hpp>
+#include <boost/geometry/algorithms/num_segments.hpp>
+
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+
+#include <boost/geometry/algorithms/detail/distance/range_to_geometry_rtree.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+template <typename Linear1, typename Linear2, typename Strategy>
+struct linear_to_linear
+{
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy,
+            typename point_type<Linear1>::type,
+            typename point_type<Linear2>::type
+        >::type return_type;
+
+    static inline return_type apply(Linear1 const& linear1,
+                                    Linear2 const& linear2,
+                                    Strategy const& strategy,
+                                    bool = false)
+    {
+        if (geometry::num_points(linear1) == 1)
+        {
+            return dispatch::distance
+                <
+                    typename point_type<Linear1>::type,
+                    Linear2,
+                    Strategy
+                >::apply(*points_begin(linear1), linear2, strategy);
+        }
+
+        if (geometry::num_points(linear2) == 1)
+        {
+            return dispatch::distance
+                <
+                    typename point_type<Linear2>::type,
+                    Linear1,
+                    Strategy
+                >::apply(*points_begin(linear2), linear1, strategy);
+        }
+
+        if (geometry::num_segments(linear2) < geometry::num_segments(linear1))
+        {
+            return point_or_segment_range_to_geometry_rtree
+                <
+                    geometry::segment_iterator<Linear2 const>,
+                    Linear1,
+                    Strategy
+                >::apply(geometry::segments_begin(linear2),
+                         geometry::segments_end(linear2),
+                         linear1,
+                         strategy);
+
+        }
+
+        return point_or_segment_range_to_geometry_rtree
+            <
+                geometry::segment_iterator<Linear1 const>,
+                Linear2,
+                Strategy
+            >::apply(geometry::segments_begin(linear1),
+                     geometry::segments_end(linear1),
+                     linear2,
+                     strategy);
+    }
+};
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Linear1, typename Linear2, typename Strategy>
+struct distance
+    <
+        Linear1, Linear2, Strategy,
+        linear_tag, linear_tag, 
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::linear_to_linear
+        <
+            Linear1, Linear2, Strategy
+        >
+{};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_LINEAR_TO_LINEAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/multipoint_to_geometry.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/multipoint_to_geometry.hpp
new file mode 100644
index 00000000000..ccd3aa462eb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/multipoint_to_geometry.hpp
@@ -0,0 +1,239 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_MULTIPOINT_TO_GEOMETRY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_MULTIPOINT_TO_GEOMETRY_HPP
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/tags.hpp>
+
+#include <boost/geometry/algorithms/covered_by.hpp>
+
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+
+#include <boost/geometry/algorithms/detail/check_iterator_range.hpp>
+#include <boost/geometry/algorithms/detail/distance/range_to_geometry_rtree.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+template <typename MultiPoint1, typename MultiPoint2, typename Strategy>
+struct multipoint_to_multipoint
+{
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy,
+            typename point_type<MultiPoint1>::type,
+            typename point_type<MultiPoint2>::type
+        >::type return_type;   
+
+    static inline return_type apply(MultiPoint1 const& multipoint1,
+                                    MultiPoint2 const& multipoint2,
+                                    Strategy const& strategy)
+    {
+        if (boost::size(multipoint2) < boost::size(multipoint1))
+
+        {
+            return point_or_segment_range_to_geometry_rtree
+                <
+                    typename boost::range_iterator<MultiPoint2 const>::type,
+                    MultiPoint1,
+                    Strategy
+                >::apply(boost::begin(multipoint2),
+                         boost::end(multipoint2),
+                         multipoint1,
+                         strategy);
+        }
+
+        return point_or_segment_range_to_geometry_rtree
+            <
+                typename boost::range_iterator<MultiPoint1 const>::type,
+                MultiPoint2,
+                Strategy
+            >::apply(boost::begin(multipoint1),
+                     boost::end(multipoint1),
+                     multipoint2,
+                     strategy);
+    }
+};
+
+
+template <typename MultiPoint, typename Linear, typename Strategy>
+struct multipoint_to_linear
+{
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy,
+            typename point_type<MultiPoint>::type,
+            typename point_type<Linear>::type
+        >::type return_type;
+
+    static inline return_type apply(MultiPoint const& multipoint,
+                                    Linear const& linear,
+                                    Strategy const& strategy)
+    {
+        return detail::distance::point_or_segment_range_to_geometry_rtree
+            <
+                typename boost::range_iterator<MultiPoint const>::type,
+                Linear,
+                Strategy
+            >::apply(boost::begin(multipoint),
+                     boost::end(multipoint),
+                     linear,
+                     strategy);
+    }
+
+    static inline return_type apply(Linear const& linear,
+                                    MultiPoint const& multipoint,
+                                    Strategy const& strategy)
+    {
+        return apply(multipoint, linear, strategy);
+    }
+};
+
+
+template <typename MultiPoint, typename Areal, typename Strategy>
+class multipoint_to_areal
+{
+private:
+    struct not_covered_by_areal
+    {
+        not_covered_by_areal(Areal const& areal)
+            : m_areal(areal)
+        {}
+
+        template <typename Point>
+        inline bool apply(Point const& point) const
+        {
+            return !geometry::covered_by(point, m_areal);
+        }
+
+        Areal const& m_areal;
+    };
+
+public:
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy,
+            typename point_type<MultiPoint>::type,
+            typename point_type<Areal>::type
+        >::type return_type;
+
+    static inline return_type apply(MultiPoint const& multipoint,
+                                    Areal const& areal,
+                                    Strategy const& strategy)
+    {
+        not_covered_by_areal predicate(areal);
+
+        if (check_iterator_range
+                <
+                    not_covered_by_areal, false
+                >::apply(boost::begin(multipoint),
+                         boost::end(multipoint),
+                         predicate))
+        {
+            return detail::distance::point_or_segment_range_to_geometry_rtree
+                <
+                    typename boost::range_iterator<MultiPoint const>::type,
+                    Areal,
+                    Strategy
+                >::apply(boost::begin(multipoint),
+                         boost::end(multipoint),
+                         areal,
+                         strategy);
+        }
+        return 0;
+    }
+
+    static inline return_type apply(Areal const& areal,
+                                    MultiPoint const& multipoint,
+                                    Strategy const& strategy)
+    {
+        return apply(multipoint, areal, strategy);
+    }
+};
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename MultiPoint1, typename MultiPoint2, typename Strategy>
+struct distance
+    <
+        MultiPoint1, MultiPoint2, Strategy,
+        multi_point_tag, multi_point_tag,
+        strategy_tag_distance_point_point, false
+    > : detail::distance::multipoint_to_multipoint
+        <
+            MultiPoint1, MultiPoint2, Strategy
+        >
+{};
+
+template <typename MultiPoint, typename Linear, typename Strategy>
+struct distance
+    <
+         MultiPoint, Linear, Strategy, multi_point_tag, linear_tag,
+         strategy_tag_distance_point_segment, false
+    > : detail::distance::multipoint_to_linear<MultiPoint, Linear, Strategy>
+{};
+
+
+template <typename Linear, typename MultiPoint, typename Strategy>
+struct distance
+    <
+         Linear, MultiPoint, Strategy, linear_tag, multi_point_tag,
+         strategy_tag_distance_point_segment, false
+    > : detail::distance::multipoint_to_linear<MultiPoint, Linear, Strategy>
+{};
+
+
+template <typename MultiPoint, typename Areal, typename Strategy>
+struct distance
+    <
+         MultiPoint, Areal, Strategy, multi_point_tag, areal_tag,
+         strategy_tag_distance_point_segment, false
+    > : detail::distance::multipoint_to_areal<MultiPoint, Areal, Strategy>
+{};
+
+
+template <typename Areal, typename MultiPoint, typename Strategy>
+struct distance
+    <
+         Areal, MultiPoint, Strategy, areal_tag, multi_point_tag,
+         strategy_tag_distance_point_segment, false
+    > : detail::distance::multipoint_to_areal<MultiPoint, Areal, Strategy>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_MULTIPOINT_TO_GEOMETRY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/point_to_geometry.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/point_to_geometry.hpp
new file mode 100644
index 00000000000..ab5de3d9b2f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/point_to_geometry.hpp
@@ -0,0 +1,518 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_POINT_TO_GEOMETRY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_POINT_TO_GEOMETRY_HPP
+
+#include <iterator>
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/range.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/tags.hpp>
+
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/algorithms/covered_by.hpp>
+#include <boost/geometry/algorithms/within.hpp>
+
+#include <boost/geometry/algorithms/detail/closest_feature/geometry_to_range.hpp>
+#include <boost/geometry/algorithms/detail/closest_feature/point_to_range.hpp>
+#include <boost/geometry/algorithms/detail/distance/is_comparable.hpp>
+#include <boost/geometry/algorithms/detail/distance/iterator_selector.hpp>
+
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+template <typename P1, typename P2, typename Strategy>
+struct point_to_point
+{
+    static inline
+    typename strategy::distance::services::return_type<Strategy, P1, P2>::type
+    apply(P1 const& p1, P2 const& p2, Strategy const& strategy)
+    {
+        boost::ignore_unused(strategy);
+        return strategy.apply(p1, p2);
+    }
+};
+
+
+template
+<
+    typename Point,
+    typename Range,
+    closure_selector Closure,
+    typename Strategy
+>
+class point_to_range
+{
+private:
+    typedef typename strategy::distance::services::comparable_type
+        <
+            Strategy
+        >::type comparable_strategy;
+
+    typedef detail::closest_feature::point_to_point_range
+        <
+            Point, Range, Closure, comparable_strategy
+        > point_to_point_range;
+
+public:
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy,
+            Point,
+            typename boost::range_value<Range>::type
+        >::type return_type;
+
+    static inline return_type apply(Point const& point, Range const& range,
+                                    Strategy const& strategy)
+    {
+        return_type const zero = return_type(0);
+
+        if (boost::size(range) == 0)
+        {
+            return zero;
+        }
+
+        namespace sds = strategy::distance::services;
+
+        typename sds::return_type
+            <
+                comparable_strategy,
+                Point,
+                typename point_type<Range>::type
+            >::type cd_min;
+
+        std::pair
+            <
+                typename boost::range_iterator<Range const>::type,
+                typename boost::range_iterator<Range const>::type
+            > it_pair
+            = point_to_point_range::apply(point,
+                                          boost::begin(range),
+                                          boost::end(range),
+                                          sds::get_comparable
+                                              <
+                                                  Strategy
+                                              >::apply(strategy),
+                                          cd_min);
+
+        return
+            is_comparable<Strategy>::value
+            ?
+            cd_min
+            :
+            strategy.apply(point, *it_pair.first, *it_pair.second);
+    }
+};
+
+
+template
+<
+    typename Point,
+    typename Ring,
+    closure_selector Closure,
+    typename Strategy
+>
+struct point_to_ring
+{
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy, Point, typename point_type<Ring>::type
+        >::type return_type;
+
+    static inline return_type apply(Point const& point,
+                                    Ring const& ring,
+                                    Strategy const& strategy)
+    {
+        if (geometry::within(point, ring))
+        {
+            return return_type(0);
+        }
+
+        return point_to_range
+            <
+                Point, Ring, closure<Ring>::value, Strategy
+            >::apply(point, ring, strategy);
+    }
+};
+
+
+template
+<
+    typename Point,
+    typename Polygon,
+    closure_selector Closure,
+    typename Strategy
+>
+class point_to_polygon
+{
+public:
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy, Point, typename point_type<Polygon>::type
+        >::type return_type;
+
+private:
+    typedef point_to_range
+        <
+            Point, typename ring_type<Polygon>::type, Closure, Strategy
+        > per_ring;
+
+    struct distance_to_interior_rings
+    {
+        template <typename InteriorRingIterator>
+        static inline return_type apply(Point const& point,
+                                        InteriorRingIterator first,
+                                        InteriorRingIterator last,
+                                        Strategy const& strategy)
+        {
+            for (InteriorRingIterator it = first; it != last; ++it)
+            {
+                if (geometry::within(point, *it))
+                {
+                    // the point is inside a polygon hole, so its distance
+                    // to the polygon its distance to the polygon's
+                    // hole boundary
+                    return per_ring::apply(point, *it, strategy);
+                }
+            }
+            return 0;
+        }
+
+        template <typename InteriorRings>
+        static inline return_type apply(Point const& point,
+                                        InteriorRings const& interior_rings,
+                                        Strategy const& strategy)
+        {
+            return apply(point,
+                         boost::begin(interior_rings),
+                         boost::end(interior_rings),
+                         strategy);
+        }
+    };
+
+
+public:
+    static inline return_type apply(Point const& point,
+                                    Polygon const& polygon,
+                                    Strategy const& strategy)
+    {
+        if (!geometry::covered_by(point, exterior_ring(polygon)))
+        {
+            // the point is outside the exterior ring, so its distance
+            // to the polygon is its distance to the polygon's exterior ring
+            return per_ring::apply(point, exterior_ring(polygon), strategy);
+        }
+
+        // Check interior rings
+        return distance_to_interior_rings::apply(point,
+                                                 interior_rings(polygon),
+                                                 strategy);
+    }
+};
+
+
+template
+<
+    typename Point,
+    typename MultiGeometry,
+    typename Strategy,
+    bool CheckCoveredBy = boost::is_same
+        <
+            typename tag<MultiGeometry>::type, multi_polygon_tag
+        >::value
+>
+class point_to_multigeometry
+{
+private:
+    typedef detail::closest_feature::geometry_to_range geometry_to_range;
+
+public:
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy,
+            Point,
+            typename point_type<MultiGeometry>::type
+        >::type return_type;
+
+    static inline return_type apply(Point const& point,
+                                    MultiGeometry const& multigeometry,
+                                    Strategy const& strategy)
+    {
+        typedef iterator_selector<MultiGeometry const> selector_type;
+
+        namespace sds = strategy::distance::services;
+
+        typename sds::return_type
+            <
+                typename sds::comparable_type<Strategy>::type,
+                Point,
+                typename point_type<MultiGeometry>::type
+            >::type cd;
+
+        typename selector_type::iterator_type it_min
+            = geometry_to_range::apply(point,
+                                       selector_type::begin(multigeometry),
+                                       selector_type::end(multigeometry),
+                                       sds::get_comparable
+                                           <
+                                               Strategy
+                                           >::apply(strategy),
+                                       cd);
+
+        return
+            is_comparable<Strategy>::value
+            ?
+            cd
+            :
+            dispatch::distance
+                <
+                    Point,
+                    typename std::iterator_traits
+                        <
+                            typename selector_type::iterator_type
+                        >::value_type,
+                    Strategy
+                >::apply(point, *it_min, strategy);
+    }
+};
+
+
+// this is called only for multipolygons, hence the change in the
+// template parameter name MultiGeometry to MultiPolygon
+template <typename Point, typename MultiPolygon, typename Strategy>
+struct point_to_multigeometry<Point, MultiPolygon, Strategy, true>
+{
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy,
+            Point,
+            typename point_type<MultiPolygon>::type
+        >::type return_type;
+
+    static inline return_type apply(Point const& point,
+                                    MultiPolygon const& multipolygon,
+                                    Strategy const& strategy)
+    {
+        if (geometry::covered_by(point, multipolygon))
+        {
+            return 0;
+        }
+
+        return point_to_multigeometry
+            <
+                Point, MultiPolygon, Strategy, false
+            >::apply(point, multipolygon, strategy);
+    }
+};
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// Point-point
+template <typename P1, typename P2, typename Strategy>
+struct distance
+    <
+        P1, P2, Strategy, point_tag, point_tag,
+        strategy_tag_distance_point_point, false
+    > : detail::distance::point_to_point<P1, P2, Strategy>
+{};
+
+
+// Point-line version 2, where point-segment strategy is specified
+template <typename Point, typename Linestring, typename Strategy>
+struct distance
+    <
+        Point, Linestring, Strategy, point_tag, linestring_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::point_to_range<Point, Linestring, closed, Strategy>
+{};
+
+
+// Point-ring , where point-segment strategy is specified
+template <typename Point, typename Ring, typename Strategy>
+struct distance
+    <
+        Point, Ring, Strategy, point_tag, ring_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::point_to_ring
+        <
+            Point, Ring, closure<Ring>::value, Strategy
+        >
+{};
+
+
+// Point-polygon , where point-segment strategy is specified
+template <typename Point, typename Polygon, typename Strategy>
+struct distance
+    <
+        Point, Polygon, Strategy, point_tag, polygon_tag, 
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::point_to_polygon
+        <
+            Point, Polygon, closure<Polygon>::value, Strategy
+        >
+{};
+
+
+// Point-segment version 2, with point-segment strategy
+template <typename Point, typename Segment, typename Strategy>
+struct distance
+    <
+        Point, Segment, Strategy, point_tag, segment_tag,
+        strategy_tag_distance_point_segment, false
+    >
+{
+    static inline typename strategy::distance::services::return_type
+        <
+            Strategy, Point, typename point_type<Segment>::type
+        >::type apply(Point const& point,
+                      Segment const& segment,
+                      Strategy const& strategy)
+    {
+        typename point_type<Segment>::type p[2];
+        geometry::detail::assign_point_from_index<0>(segment, p[0]);
+        geometry::detail::assign_point_from_index<1>(segment, p[1]);
+
+        boost::ignore_unused(strategy);
+        return strategy.apply(point, p[0], p[1]);
+    }
+};
+
+
+template <typename Point, typename Box, typename Strategy>
+struct distance
+    <
+         Point, Box, Strategy, point_tag, box_tag,
+         strategy_tag_distance_point_box, false
+    >
+{
+    static inline typename strategy::distance::services::return_type
+        <
+            Strategy, Point, typename point_type<Box>::type
+        >::type
+    apply(Point const& point, Box const& box, Strategy const& strategy)
+    {
+        boost::ignore_unused(strategy);
+        return strategy.apply(point, box);
+    }
+};
+
+
+template<typename Point, typename MultiPoint, typename Strategy>
+struct distance
+    <
+        Point, MultiPoint, Strategy, point_tag, multi_point_tag,
+        strategy_tag_distance_point_point, false
+    > : detail::distance::point_to_multigeometry
+        <
+            Point, MultiPoint, Strategy
+        >
+{};
+
+
+template<typename Point, typename MultiLinestring, typename Strategy>
+struct distance
+    <
+        Point, MultiLinestring, Strategy, point_tag, multi_linestring_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::point_to_multigeometry
+        <
+            Point, MultiLinestring, Strategy
+        >
+{};
+
+
+template<typename Point, typename MultiPolygon, typename Strategy>
+struct distance
+    <
+        Point, MultiPolygon, Strategy, point_tag, multi_polygon_tag,
+        strategy_tag_distance_point_segment, false
+    > : detail::distance::point_to_multigeometry
+        <
+            Point, MultiPolygon, Strategy
+        >
+{};
+
+
+template <typename Point, typename Linear, typename Strategy>
+struct distance
+    <
+         Point, Linear, Strategy, point_tag, linear_tag,
+         strategy_tag_distance_point_segment, false
+    > : distance
+        <
+            Point, Linear, Strategy,
+            point_tag, typename tag<Linear>::type,
+            strategy_tag_distance_point_segment, false
+        >
+{};
+
+
+template <typename Point, typename Areal, typename Strategy>
+struct distance
+    <
+         Point, Areal, Strategy, point_tag, areal_tag,
+         strategy_tag_distance_point_segment, false
+    > : distance
+        <
+            Point, Areal, Strategy,
+            point_tag, typename tag<Areal>::type,
+            strategy_tag_distance_point_segment, false
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_POINT_TO_GEOMETRY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/range_to_geometry_rtree.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/range_to_geometry_rtree.hpp
new file mode 100644
index 00000000000..6e78bee6949
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/range_to_geometry_rtree.hpp
@@ -0,0 +1,130 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_RANGE_TO_GEOMETRY_RTREE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_RANGE_TO_GEOMETRY_RTREE_HPP
+
+#include <iterator>
+#include <utility>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/iterators/has_one_element.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+
+#include <boost/geometry/algorithms/detail/closest_feature/range_to_range.hpp>
+#include <boost/geometry/algorithms/detail/distance/is_comparable.hpp>
+#include <boost/geometry/algorithms/detail/distance/iterator_selector.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+template
+<
+    typename PointOrSegmentIterator,
+    typename Geometry,
+    typename Strategy
+>
+class point_or_segment_range_to_geometry_rtree
+{
+private:
+    typedef typename std::iterator_traits
+        <
+            PointOrSegmentIterator
+        >::value_type point_or_segment_type;
+
+    typedef iterator_selector<Geometry const> selector_type;
+
+    typedef detail::closest_feature::range_to_range_rtree range_to_range;
+
+public:
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy,
+            typename point_type<point_or_segment_type>::type,
+            typename point_type<Geometry>::type
+        >::type return_type;
+
+    static inline return_type apply(PointOrSegmentIterator first,
+                                    PointOrSegmentIterator last,
+                                    Geometry const& geometry,
+                                    Strategy const& strategy)
+    {
+        namespace sds = strategy::distance::services;
+
+        BOOST_GEOMETRY_ASSERT( first != last );
+
+        if ( geometry::has_one_element(first, last) )
+        {
+            return dispatch::distance
+                <
+                    point_or_segment_type, Geometry, Strategy
+                >::apply(*first, geometry, strategy);
+        }
+
+        typename sds::return_type
+            <
+                typename sds::comparable_type<Strategy>::type,
+                typename point_type<point_or_segment_type>::type,
+                typename point_type<Geometry>::type
+            >::type cd_min;
+
+        std::pair
+            <
+                point_or_segment_type,
+                typename selector_type::iterator_type
+            > closest_features
+            = range_to_range::apply(first,
+                                    last,
+                                    selector_type::begin(geometry),
+                                    selector_type::end(geometry),
+                                    sds::get_comparable
+                                        <
+                                            Strategy
+                                        >::apply(strategy),
+                                    cd_min);
+
+        return
+            is_comparable<Strategy>::value
+            ?
+            cd_min
+            :
+            dispatch::distance
+                <
+                    point_or_segment_type,                    
+                    typename std::iterator_traits
+                        <
+                            typename selector_type::iterator_type
+                        >::value_type,
+                    Strategy
+                >::apply(closest_features.first,
+                         *closest_features.second,
+                         strategy);
+    }
+};
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_RANGE_TO_GEOMETRY_RTREE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/segment_to_box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/segment_to_box.hpp
new file mode 100644
index 00000000000..fa951524767
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/segment_to_box.hpp
@@ -0,0 +1,892 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_SEGMENT_TO_BOX_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_SEGMENT_TO_BOX_HPP
+
+#include <cstddef>
+
+#include <functional>
+#include <vector>
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/numeric/conversion/cast.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/calculation_type.hpp>
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/tags.hpp>
+
+#include <boost/geometry/policies/compare.hpp>
+
+#include <boost/geometry/algorithms/equals.hpp>
+#include <boost/geometry/algorithms/intersects.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/algorithms/detail/assign_box_corners.hpp>
+#include <boost/geometry/algorithms/detail/assign_indexed_point.hpp>
+#include <boost/geometry/algorithms/detail/distance/default_strategies.hpp>
+#include <boost/geometry/algorithms/detail/distance/is_comparable.hpp>
+
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+template
+<
+    typename Segment,
+    typename Box,
+    typename Strategy,
+    bool UsePointBoxStrategy = false
+>
+class segment_to_box_2D_generic
+{
+private:
+    typedef typename point_type<Segment>::type segment_point;
+    typedef typename point_type<Box>::type box_point;
+
+    typedef typename strategy::distance::services::comparable_type
+        <
+            Strategy
+        >::type comparable_strategy;
+
+    typedef detail::closest_feature::point_to_point_range
+        <
+            segment_point,
+            std::vector<box_point>,
+            open,
+            comparable_strategy
+        > point_to_point_range;
+
+    typedef typename strategy::distance::services::return_type
+        <
+            comparable_strategy, segment_point, box_point
+        >::type comparable_return_type;
+    
+public:
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy, segment_point, box_point
+        >::type return_type;
+
+    static inline return_type apply(Segment const& segment,
+                                    Box const& box,
+                                    Strategy const& strategy,
+                                    bool check_intersection = true)
+    {
+        if (check_intersection && geometry::intersects(segment, box))
+        {
+            return 0;
+        }
+
+        comparable_strategy cstrategy =
+            strategy::distance::services::get_comparable
+                <
+                    Strategy
+                >::apply(strategy);
+
+        // get segment points
+        segment_point p[2];
+        detail::assign_point_from_index<0>(segment, p[0]);
+        detail::assign_point_from_index<1>(segment, p[1]);
+
+        // get box points
+        std::vector<box_point> box_points(4);
+        detail::assign_box_corners_oriented<true>(box, box_points);
+ 
+        comparable_return_type cd[6];
+        for (unsigned int i = 0; i < 4; ++i)
+        {
+            cd[i] = cstrategy.apply(box_points[i], p[0], p[1]);
+        }
+
+        std::pair
+            <
+                typename std::vector<box_point>::const_iterator,
+                typename std::vector<box_point>::const_iterator
+            > bit_min[2];
+
+        bit_min[0] = point_to_point_range::apply(p[0],
+                                                 box_points.begin(),
+                                                 box_points.end(),
+                                                 cstrategy,
+                                                 cd[4]);
+        bit_min[1] = point_to_point_range::apply(p[1],
+                                                 box_points.begin(),
+                                                 box_points.end(),
+                                                 cstrategy,
+                                                 cd[5]);
+
+        unsigned int imin = 0;
+        for (unsigned int i = 1; i < 6; ++i)
+        {
+            if (cd[i] < cd[imin])
+            {
+                imin = i;
+            }
+        }
+
+        if (BOOST_GEOMETRY_CONDITION(is_comparable<Strategy>::value))
+        {
+            return cd[imin];
+        }
+
+        if (imin < 4)
+        {
+            return strategy.apply(box_points[imin], p[0], p[1]);
+        }
+        else
+        {
+            unsigned int bimin = imin - 4;
+            return strategy.apply(p[bimin],
+                                  *bit_min[bimin].first,
+                                  *bit_min[bimin].second);
+        }
+    }
+};
+
+
+template
+<
+    typename Segment,
+    typename Box,
+    typename Strategy
+>
+class segment_to_box_2D_generic<Segment, Box, Strategy, true>
+{
+private:
+    typedef typename point_type<Segment>::type segment_point;
+    typedef typename point_type<Box>::type box_point;
+
+    typedef typename strategy::distance::services::comparable_type
+        <
+            Strategy
+        >::type comparable_strategy;
+
+    typedef typename strategy::distance::services::return_type
+        <
+            comparable_strategy, segment_point, box_point
+        >::type comparable_return_type;
+
+    typedef typename detail::distance::default_strategy
+        <
+            segment_point, Box
+        >::type point_box_strategy;
+
+    typedef typename strategy::distance::services::comparable_type
+        <
+            point_box_strategy
+        >::type point_box_comparable_strategy;
+
+public:
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy, segment_point, box_point
+        >::type return_type;
+
+    static inline return_type apply(Segment const& segment,
+                                    Box const& box,
+                                    Strategy const& strategy,
+                                    bool check_intersection = true)
+    {
+        if (check_intersection && geometry::intersects(segment, box))
+        {
+            return 0;
+        }
+
+        comparable_strategy cstrategy =
+            strategy::distance::services::get_comparable
+                <
+                    Strategy
+                >::apply(strategy);
+        boost::ignore_unused(cstrategy);
+
+        // get segment points
+        segment_point p[2];
+        detail::assign_point_from_index<0>(segment, p[0]);
+        detail::assign_point_from_index<1>(segment, p[1]);
+
+        // get box points
+        std::vector<box_point> box_points(4);
+        detail::assign_box_corners_oriented<true>(box, box_points);
+ 
+        comparable_return_type cd[6];
+        for (unsigned int i = 0; i < 4; ++i)
+        {
+            cd[i] = cstrategy.apply(box_points[i], p[0], p[1]);
+        }
+
+        point_box_comparable_strategy pb_cstrategy;
+        boost::ignore_unused(pb_cstrategy);
+        cd[4] = pb_cstrategy.apply(p[0], box);
+        cd[5] = pb_cstrategy.apply(p[1], box);
+
+        unsigned int imin = 0;
+        for (unsigned int i = 1; i < 6; ++i)
+        {
+            if (cd[i] < cd[imin])
+            {
+                imin = i;
+            }
+        }
+
+        if (is_comparable<Strategy>::value)
+        {
+            return cd[imin];
+        }
+
+        if (imin < 4)
+        {
+            strategy.apply(box_points[imin], p[0], p[1]);
+        }
+        else
+        {
+            return point_box_strategy().apply(p[imin - 4], box);
+        }
+    }
+};
+
+
+
+
+template
+<
+    typename ReturnType,
+    typename SegmentPoint,
+    typename BoxPoint,
+    typename PPStrategy,
+    typename PSStrategy
+>
+class segment_to_box_2D
+{
+private:
+    template <typename Result>
+    struct cast_to_result
+    {
+        template <typename T>
+        static inline Result apply(T const& t)
+        {
+            return boost::numeric_cast<Result>(t);
+        }
+    };
+
+
+    template <typename T, bool IsLess /* true */>
+    struct compare_less_equal
+    {
+        typedef compare_less_equal<T, !IsLess> other;
+
+        template <typename T1, typename T2>
+        inline bool operator()(T1 const& t1, T2 const& t2) const
+        {
+            return std::less_equal<T>()(cast_to_result<T>::apply(t1),
+                                        cast_to_result<T>::apply(t2));
+        }
+    };
+
+    template <typename T>
+    struct compare_less_equal<T, false>
+    {
+        typedef compare_less_equal<T, true> other;
+
+        template <typename T1, typename T2>
+        inline bool operator()(T1 const& t1, T2 const& t2) const
+        {
+            return std::greater_equal<T>()(cast_to_result<T>::apply(t1),
+                                           cast_to_result<T>::apply(t2));
+        }
+    };
+
+
+    template <typename LessEqual>
+    struct other_compare
+    {
+        typedef typename LessEqual::other type;
+    };
+
+
+    // it is assumed here that p0 lies to the right of the box (so the
+    // entire segment lies to the right of the box)
+    template <typename LessEqual>
+    struct right_of_box
+    {
+        static inline ReturnType apply(SegmentPoint const& p0,
+                                       SegmentPoint const& p1,
+                                       BoxPoint const& bottom_right,
+                                       BoxPoint const& top_right,
+                                       PPStrategy const& pp_strategy,
+                                       PSStrategy const& ps_strategy)
+        {
+            boost::ignore_unused(pp_strategy, ps_strategy);
+
+            // the implementation below is written for non-negative slope
+            // segments
+            //
+            // for negative slope segments swap the roles of bottom_right
+            // and top_right and use greater_equal instead of less_equal.
+
+            typedef cast_to_result<ReturnType> cast;
+
+            LessEqual less_equal;
+
+            if (less_equal(geometry::get<1>(top_right), geometry::get<1>(p0)))
+            {
+                // closest box point is the top-right corner
+                return cast::apply(pp_strategy.apply(p0, top_right));
+            }
+            else if (less_equal(geometry::get<1>(bottom_right),
+                                geometry::get<1>(p0)))
+            {
+                // distance is realized between p0 and right-most
+                // segment of box
+                ReturnType diff = cast::apply(geometry::get<0>(p0))
+                    - cast::apply(geometry::get<0>(bottom_right));
+                return strategy::distance::services::result_from_distance
+                    <
+                        PSStrategy, BoxPoint, SegmentPoint
+                    >::apply(ps_strategy, math::abs(diff));
+            }
+            else
+            {
+                // distance is realized between the bottom-right
+                // corner of the box and the segment
+                return cast::apply(ps_strategy.apply(bottom_right, p0, p1));
+            }
+        }
+    };
+
+
+    // it is assumed here that p0 lies above the box (so the
+    // entire segment lies above the box)
+    template <typename LessEqual>
+    struct above_of_box
+    {
+        static inline ReturnType apply(SegmentPoint const& p0,
+                                       SegmentPoint const& p1,
+                                       BoxPoint const& top_left,
+                                       PSStrategy const& ps_strategy)
+        {
+            boost::ignore_unused(ps_strategy);
+
+            // the segment lies above the box
+
+            typedef cast_to_result<ReturnType> cast;
+
+            LessEqual less_equal;
+
+            // p0 is above the upper segment of the box
+            // (and inside its band)
+            if (less_equal(geometry::get<0>(top_left), geometry::get<0>(p0)))
+            {
+                ReturnType diff = cast::apply(geometry::get<1>(p0))
+                    - cast::apply(geometry::get<1>(top_left));
+                return strategy::distance::services::result_from_distance
+                    <
+                        PSStrategy, SegmentPoint, BoxPoint
+                    >::apply(ps_strategy, math::abs(diff));
+            }
+
+            // p0 is to the left of the box, but p1 is above the box
+            // in this case the distance is realized between the
+            // top-left corner of the box and the segment
+            return cast::apply(ps_strategy.apply(top_left, p0, p1));
+        }
+    };
+
+
+    template <typename LessEqual>
+    struct check_right_left_of_box
+    {
+        static inline bool apply(SegmentPoint const& p0,
+                                 SegmentPoint const& p1,
+                                 BoxPoint const& top_left,
+                                 BoxPoint const& top_right,
+                                 BoxPoint const& bottom_left,
+                                 BoxPoint const& bottom_right,
+                                 PPStrategy const& pp_strategy,
+                                 PSStrategy const& ps_strategy,
+                                 ReturnType& result)
+        {
+            // p0 lies to the right of the box
+            if (geometry::get<0>(p0) >= geometry::get<0>(top_right))
+            {
+                result = right_of_box
+                    <
+                        LessEqual
+                    >::apply(p0, p1, bottom_right, top_right,
+                             pp_strategy, ps_strategy);
+                return true;
+            }
+
+            // p1 lies to the left of the box
+            if (geometry::get<0>(p1) <= geometry::get<0>(bottom_left))
+            {
+                result = right_of_box
+                    <
+                        typename other_compare<LessEqual>::type
+                    >::apply(p1, p0, top_left, bottom_left,
+                             pp_strategy, ps_strategy);
+                return true;
+            }
+
+            return false;
+        }
+    };
+
+
+    template <typename LessEqual>
+    struct check_above_below_of_box
+    {
+        static inline bool apply(SegmentPoint const& p0,
+                                 SegmentPoint const& p1,
+                                 BoxPoint const& top_left,
+                                 BoxPoint const& top_right,
+                                 BoxPoint const& bottom_left,
+                                 BoxPoint const& bottom_right,
+                                 PSStrategy const& ps_strategy,
+                                 ReturnType& result)
+        {
+            // the segment lies below the box
+            if (geometry::get<1>(p1) < geometry::get<1>(bottom_left))
+            {
+                result = above_of_box
+                    <
+                        typename other_compare<LessEqual>::type
+                    >::apply(p1, p0, bottom_right, ps_strategy);
+                return true;
+            }
+
+            // the segment lies above the box
+            if (geometry::get<1>(p0) > geometry::get<1>(top_right))
+            {
+                result = above_of_box
+                    <
+                        LessEqual
+                    >::apply(p0, p1, top_left, ps_strategy);
+                return true;
+            }
+            return false;
+        }
+    };
+
+    struct check_generic_position
+    {
+        static inline bool apply(SegmentPoint const& p0,
+                                 SegmentPoint const& p1,
+                                 BoxPoint const& bottom_left0,
+                                 BoxPoint const& top_right0,
+                                 BoxPoint const& bottom_left1,
+                                 BoxPoint const& top_right1,
+                                 BoxPoint const& corner1,
+                                 BoxPoint const& corner2,
+                                 PSStrategy const& ps_strategy,
+                                 ReturnType& result)
+        {
+            typedef cast_to_result<ReturnType> cast;
+
+            ReturnType diff0 = cast::apply(geometry::get<0>(p1))
+                - cast::apply(geometry::get<0>(p0));
+            ReturnType t_min0 = cast::apply(geometry::get<0>(bottom_left0))
+                - cast::apply(geometry::get<0>(p0));
+            ReturnType t_max0 = cast::apply(geometry::get<0>(top_right0))
+                - cast::apply(geometry::get<0>(p0));
+
+            ReturnType diff1 = cast::apply(geometry::get<1>(p1))
+                - cast::apply(geometry::get<1>(p0));
+            ReturnType t_min1 = cast::apply(geometry::get<1>(bottom_left1))
+                - cast::apply(geometry::get<1>(p0));
+            ReturnType t_max1 = cast::apply(geometry::get<1>(top_right1))
+                - cast::apply(geometry::get<1>(p0));
+
+            if (diff1 < 0)
+            {
+                diff1 = -diff1;
+                t_min1 = -t_min1;
+                t_max1 = -t_max1;
+            }
+
+            //  t_min0 > t_max1
+            if (t_min0 * diff1 > t_max1 * diff0)
+            {
+                result = cast::apply(ps_strategy.apply(corner1, p0, p1));
+                return true;
+            }
+
+            //  t_max0 < t_min1
+            if (t_max0 * diff1 < t_min1 * diff0)
+            {
+                result = cast::apply(ps_strategy.apply(corner2, p0, p1));
+                return true;
+            }
+            return false;
+        }
+    };
+
+    static inline ReturnType
+    non_negative_slope_segment(SegmentPoint const& p0,
+                               SegmentPoint const& p1,
+                               BoxPoint const& top_left,
+                               BoxPoint const& top_right,
+                               BoxPoint const& bottom_left,
+                               BoxPoint const& bottom_right,
+                               PPStrategy const& pp_strategy,
+                               PSStrategy const& ps_strategy)
+    {
+        typedef compare_less_equal<ReturnType, true> less_equal;
+
+        // assert that the segment has non-negative slope
+        BOOST_GEOMETRY_ASSERT( ( math::equals(geometry::get<0>(p0), geometry::get<0>(p1))
+                              && geometry::get<1>(p0) < geometry::get<1>(p1))
+                            ||
+                               ( geometry::get<0>(p0) < geometry::get<0>(p1)
+                              && geometry::get<1>(p0) <= geometry::get<1>(p1) )
+                            || geometry::has_nan_coordinate(p0)
+                            || geometry::has_nan_coordinate(p1));
+
+        ReturnType result(0);
+
+        if (check_right_left_of_box
+                <
+                    less_equal
+                >::apply(p0, p1,
+                         top_left, top_right, bottom_left, bottom_right,
+                         pp_strategy, ps_strategy, result))
+        {
+            return result;
+        }
+
+        if (check_above_below_of_box
+                <
+                    less_equal
+                >::apply(p0, p1,
+                         top_left, top_right, bottom_left, bottom_right,
+                         ps_strategy, result))
+        {
+            return result;
+        }
+
+        if (check_generic_position::apply(p0, p1,
+                                          bottom_left, top_right,
+                                          bottom_left, top_right,
+                                          top_left, bottom_right,
+                                          ps_strategy, result))
+        {
+            return result;
+        }
+
+        // in all other cases the box and segment intersect, so return 0
+        return result;
+    }
+
+
+    static inline ReturnType
+    negative_slope_segment(SegmentPoint const& p0,
+                           SegmentPoint const& p1,
+                           BoxPoint const& top_left,
+                           BoxPoint const& top_right,
+                           BoxPoint const& bottom_left,
+                           BoxPoint const& bottom_right,
+                           PPStrategy const& pp_strategy,
+                           PSStrategy const& ps_strategy)
+    {
+        typedef compare_less_equal<ReturnType, false> greater_equal;
+
+        // assert that the segment has negative slope
+        BOOST_GEOMETRY_ASSERT( ( geometry::get<0>(p0) < geometry::get<0>(p1)
+                              && geometry::get<1>(p0) > geometry::get<1>(p1) )
+                            || geometry::has_nan_coordinate(p0)
+                            || geometry::has_nan_coordinate(p1) );
+
+        ReturnType result(0);
+
+        if (check_right_left_of_box
+                <
+                    greater_equal
+                >::apply(p0, p1,
+                         bottom_left, bottom_right, top_left, top_right,
+                         pp_strategy, ps_strategy, result))
+        {
+            return result;
+        }
+
+        if (check_above_below_of_box
+                <
+                    greater_equal
+                >::apply(p1, p0,
+                         top_right, top_left, bottom_right, bottom_left,
+                         ps_strategy, result))
+        {
+            return result;
+        }
+
+        if (check_generic_position::apply(p0, p1,
+                                          bottom_left, top_right,
+                                          top_right, bottom_left,
+                                          bottom_left, top_right,
+                                          ps_strategy, result))
+        {
+            return result;
+        }
+
+        // in all other cases the box and segment intersect, so return 0
+        return result;
+    }
+
+public:
+    static inline ReturnType apply(SegmentPoint const& p0,
+                                   SegmentPoint const& p1,
+                                   BoxPoint const& top_left,
+                                   BoxPoint const& top_right,
+                                   BoxPoint const& bottom_left,
+                                   BoxPoint const& bottom_right,
+                                   PPStrategy const& pp_strategy,
+                                   PSStrategy const& ps_strategy)
+    {
+        BOOST_GEOMETRY_ASSERT( geometry::less<SegmentPoint>()(p0, p1)
+                            || geometry::has_nan_coordinate(p0)
+                            || geometry::has_nan_coordinate(p1) );
+
+        if (geometry::get<0>(p0) < geometry::get<0>(p1)
+            && geometry::get<1>(p0) > geometry::get<1>(p1))
+        {
+            return negative_slope_segment(p0, p1,
+                                          top_left, top_right,
+                                          bottom_left, bottom_right,
+                                          pp_strategy, ps_strategy);
+        }
+
+        return non_negative_slope_segment(p0, p1,
+                                          top_left, top_right,
+                                          bottom_left, bottom_right,
+                                          pp_strategy, ps_strategy);
+    }
+};
+
+
+//=========================================================================
+
+
+template
+<
+    typename Segment,
+    typename Box,
+    typename std::size_t Dimension,
+    typename PPStrategy,
+    typename PSStrategy
+>
+class segment_to_box
+    : not_implemented<Segment, Box>
+{};
+
+
+template
+<
+    typename Segment,
+    typename Box,
+    typename PPStrategy,
+    typename PSStrategy
+>
+class segment_to_box<Segment, Box, 2, PPStrategy, PSStrategy>
+{
+private:
+    typedef typename point_type<Segment>::type segment_point;
+    typedef typename point_type<Box>::type box_point;
+
+    typedef typename strategy::distance::services::comparable_type
+        <
+            PPStrategy
+        >::type pp_comparable_strategy;
+
+    typedef typename strategy::distance::services::comparable_type
+        <
+            PSStrategy
+        >::type ps_comparable_strategy;
+
+    typedef typename strategy::distance::services::return_type
+        <
+            ps_comparable_strategy, segment_point, box_point
+        >::type comparable_return_type;
+public:
+    typedef typename strategy::distance::services::return_type
+        <
+            PSStrategy, segment_point, box_point
+        >::type return_type;
+
+    static inline return_type apply(Segment const& segment,
+                                    Box const& box,
+                                    PPStrategy const& pp_strategy,
+                                    PSStrategy const& ps_strategy)
+    {
+        segment_point p[2];
+        detail::assign_point_from_index<0>(segment, p[0]);
+        detail::assign_point_from_index<1>(segment, p[1]);
+
+        if (geometry::equals(p[0], p[1]))
+        {
+            typedef typename boost::mpl::if_
+                <
+                    boost::is_same
+                        <
+                            ps_comparable_strategy,
+                            PSStrategy
+                        >,
+                    typename strategy::distance::services::comparable_type
+                        <
+                            typename detail::distance::default_strategy
+                                <
+                                    segment_point, Box
+                                >::type
+                        >::type,
+                    typename detail::distance::default_strategy
+                        <
+                            segment_point, Box
+                        >::type
+                >::type point_box_strategy_type;
+
+            return dispatch::distance
+                <
+                    segment_point,
+                    Box,
+                    point_box_strategy_type
+                >::apply(p[0], box, point_box_strategy_type());
+        }
+
+        box_point top_left, top_right, bottom_left, bottom_right;
+        detail::assign_box_corners(box, bottom_left, bottom_right,
+                                   top_left, top_right);
+
+        if (geometry::less<segment_point>()(p[0], p[1]))
+        {
+            return segment_to_box_2D
+                <
+                    return_type,
+                    segment_point,
+                    box_point,
+                    PPStrategy,
+                    PSStrategy
+                >::apply(p[0], p[1],
+                         top_left, top_right, bottom_left, bottom_right,
+                         pp_strategy,
+                         ps_strategy);
+        }
+        else
+        {
+            return segment_to_box_2D
+                <
+                    return_type,
+                    segment_point,
+                    box_point,
+                    PPStrategy,
+                    PSStrategy
+                >::apply(p[1], p[0],
+                         top_left, top_right, bottom_left, bottom_right,
+                         pp_strategy,
+                         ps_strategy);
+        }
+    }
+};
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Segment, typename Box, typename Strategy>
+struct distance
+    <
+        Segment, Box, Strategy, segment_tag, box_tag,
+        strategy_tag_distance_point_segment, false
+    >
+{
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy,
+            typename point_type<Segment>::type,
+            typename point_type<Box>::type
+        >::type return_type;
+
+
+    static inline return_type apply(Segment const& segment,
+                                    Box const& box,
+                                    Strategy const& strategy)
+    {
+        assert_dimension_equal<Segment, Box>();
+
+        typedef typename boost::mpl::if_
+            <
+                boost::is_same
+                    <
+                        typename strategy::distance::services::comparable_type
+                            <
+                                Strategy
+                            >::type,
+                        Strategy
+                    >,
+                typename strategy::distance::services::comparable_type
+                    <
+                        typename detail::distance::default_strategy
+                            <
+                                typename point_type<Segment>::type,
+                                typename point_type<Box>::type
+                            >::type
+                    >::type,
+                typename detail::distance::default_strategy
+                    <
+                        typename point_type<Segment>::type,
+                        typename point_type<Box>::type
+                    >::type
+            >::type pp_strategy_type;
+
+
+        return detail::distance::segment_to_box
+            <
+                Segment,
+                Box,
+                dimension<Segment>::value,
+                pp_strategy_type,
+                Strategy
+            >::apply(segment, box, pp_strategy_type(), strategy);
+    }
+};
+
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_SEGMENT_TO_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/segment_to_segment.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/segment_to_segment.hpp
new file mode 100644
index 00000000000..bdf056d76e8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/distance/segment_to_segment.hpp
@@ -0,0 +1,152 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_SEGMENT_TO_SEGMENT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_SEGMENT_TO_SEGMENT_HPP
+
+#include <algorithm>
+#include <iterator>
+
+#include <boost/core/addressof.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/tags.hpp>
+
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/algorithms/intersects.hpp>
+
+#include <boost/geometry/algorithms/detail/distance/is_comparable.hpp>
+
+#include <boost/geometry/algorithms/dispatch/distance.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace distance
+{
+
+
+
+// compute segment-segment distance
+template<typename Segment1, typename Segment2, typename Strategy>
+class segment_to_segment
+{
+private:
+    typedef typename strategy::distance::services::comparable_type
+        <
+            Strategy
+        >::type comparable_strategy;
+
+    typedef typename strategy::distance::services::return_type
+        <
+            comparable_strategy,
+            typename point_type<Segment1>::type,
+            typename point_type<Segment2>::type
+        >::type comparable_return_type;
+
+public:
+    typedef typename strategy::distance::services::return_type
+        <
+            Strategy,
+            typename point_type<Segment1>::type,
+            typename point_type<Segment2>::type
+        >::type return_type;
+
+    static inline return_type
+    apply(Segment1 const& segment1, Segment2 const& segment2,
+          Strategy const& strategy)
+    {
+        if (geometry::intersects(segment1, segment2))
+        {
+            return 0;
+        }
+
+        typename point_type<Segment1>::type p[2];
+        detail::assign_point_from_index<0>(segment1, p[0]);
+        detail::assign_point_from_index<1>(segment1, p[1]);
+
+        typename point_type<Segment2>::type q[2];
+        detail::assign_point_from_index<0>(segment2, q[0]);
+        detail::assign_point_from_index<1>(segment2, q[1]);
+
+        comparable_strategy cstrategy =
+            strategy::distance::services::get_comparable
+                <
+                    Strategy
+                >::apply(strategy);
+
+        comparable_return_type d[4];
+        d[0] = cstrategy.apply(q[0], p[0], p[1]);
+        d[1] = cstrategy.apply(q[1], p[0], p[1]);
+        d[2] = cstrategy.apply(p[0], q[0], q[1]);
+        d[3] = cstrategy.apply(p[1], q[0], q[1]);
+
+        std::size_t imin = std::distance(boost::addressof(d[0]),
+                                         std::min_element(d, d + 4));
+
+        if (BOOST_GEOMETRY_CONDITION(is_comparable<Strategy>::value))
+        {
+            return d[imin];
+        }
+
+        switch (imin)
+        {
+        case 0:
+            return strategy.apply(q[0], p[0], p[1]);
+        case 1:
+            return strategy.apply(q[1], p[0], p[1]);
+        case 2:
+            return strategy.apply(p[0], q[0], q[1]);
+        default:
+            return strategy.apply(p[1], q[0], q[1]);
+        }
+    }
+};
+
+
+
+
+}} // namespace detail::distance
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+
+// segment-segment
+template <typename Segment1, typename Segment2, typename Strategy>
+struct distance
+    <
+        Segment1, Segment2, Strategy, segment_tag, segment_tag,
+        strategy_tag_distance_point_segment, false
+    >
+    : detail::distance::segment_to_segment<Segment1, Segment2, Strategy>
+{};
+
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_DISTANCE_SEGMENT_TO_SEGMENT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/box.hpp
new file mode 100644
index 00000000000..795f51392e3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/box.hpp
@@ -0,0 +1,172 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015, 2016.
+// Modifications copyright (c) 2015-2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_BOX_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_BOX_HPP
+
+#include <cstddef>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_system.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/views/detail/indexed_point_view.hpp>
+
+#include <boost/geometry/algorithms/detail/convert_point_to_point.hpp>
+#include <boost/geometry/algorithms/detail/normalize.hpp>
+#include <boost/geometry/algorithms/detail/envelope/transform_units.hpp>
+
+#include <boost/geometry/algorithms/dispatch/envelope.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace envelope
+{
+
+
+template
+<
+    std::size_t Index,
+    std::size_t Dimension,
+    std::size_t DimensionCount
+>
+struct envelope_indexed_box
+{
+    template <typename BoxIn, typename BoxOut>
+    static inline void apply(BoxIn const& box_in, BoxOut& mbr)
+    {
+        detail::indexed_point_view<BoxIn const, Index> box_in_corner(box_in);
+        detail::indexed_point_view<BoxOut, Index> mbr_corner(mbr);
+
+        detail::conversion::point_to_point
+            <
+                detail::indexed_point_view<BoxIn const, Index>,
+                detail::indexed_point_view<BoxOut, Index>,
+                Dimension,
+                DimensionCount
+            >::apply(box_in_corner, mbr_corner);
+    }
+};
+
+template
+<
+    std::size_t Index,
+    std::size_t DimensionCount
+>
+struct envelope_indexed_box_on_spheroid
+{
+    template <typename BoxIn, typename BoxOut>
+    static inline void apply(BoxIn const& box_in, BoxOut& mbr)
+    {
+        // transform() does not work with boxes of dimension higher
+        // than 2; to account for such boxes we transform the min/max
+        // points of the boxes using the indexed_point_view
+        detail::indexed_point_view<BoxIn const, Index> box_in_corner(box_in);
+        detail::indexed_point_view<BoxOut, Index> mbr_corner(mbr);
+
+        // first transform the units
+        transform_units(box_in_corner, mbr_corner);
+
+        // now transform the remaining coordinates
+        detail::conversion::point_to_point
+            <
+                detail::indexed_point_view<BoxIn const, Index>,
+                detail::indexed_point_view<BoxOut, Index>,
+                2,
+                DimensionCount
+            >::apply(box_in_corner, mbr_corner);
+    }
+};
+
+
+struct envelope_box
+{
+    template<typename BoxIn, typename BoxOut, typename Strategy>
+    static inline void apply(BoxIn const& box_in,
+                             BoxOut& mbr,
+                             Strategy const&)
+    {
+        envelope_indexed_box
+            <
+                min_corner, 0, dimension<BoxIn>::value
+            >::apply(box_in, mbr);
+
+        envelope_indexed_box
+            <
+                max_corner, 0, dimension<BoxIn>::value
+            >::apply(box_in, mbr);
+    }
+};
+
+
+struct envelope_box_on_spheroid
+{
+    template <typename BoxIn, typename BoxOut, typename Strategy>
+    static inline void apply(BoxIn const& box_in,
+                             BoxOut& mbr,
+                             Strategy const&)
+    {
+        BoxIn box_in_normalized = detail::return_normalized<BoxIn>(box_in);
+
+        envelope_indexed_box_on_spheroid
+            <
+                min_corner, dimension<BoxIn>::value
+            >::apply(box_in_normalized, mbr);
+
+        envelope_indexed_box_on_spheroid
+            <
+                max_corner, dimension<BoxIn>::value
+            >::apply(box_in_normalized, mbr);
+    }
+};
+
+
+}} // namespace detail::envelope
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Box, typename CS_Tag>
+struct envelope<Box, box_tag, CS_Tag>
+    : detail::envelope::envelope_box
+{};
+
+
+template <typename Box>
+struct envelope<Box, box_tag, spherical_equatorial_tag>
+    : detail::envelope::envelope_box_on_spheroid
+{};
+
+
+template <typename Box>
+struct envelope<Box, box_tag, geographic_tag>
+    : detail::envelope::envelope_box_on_spheroid
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/implementation.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/implementation.hpp
new file mode 100644
index 00000000000..d5497007910
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/implementation.hpp
@@ -0,0 +1,107 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015, 2016.
+// Modifications copyright (c) 2015-2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_IMPLEMENTATION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_IMPLEMENTATION_HPP
+
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/is_empty.hpp>
+
+#include <boost/geometry/algorithms/detail/envelope/box.hpp>
+#include <boost/geometry/algorithms/detail/envelope/linear.hpp>
+#include <boost/geometry/algorithms/detail/envelope/multipoint.hpp>
+#include <boost/geometry/algorithms/detail/envelope/point.hpp>
+#include <boost/geometry/algorithms/detail/envelope/range.hpp>
+#include <boost/geometry/algorithms/detail/envelope/segment.hpp>
+
+#include <boost/geometry/algorithms/dispatch/envelope.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace envelope
+{
+
+
+struct envelope_polygon
+{
+    template <typename Polygon, typename Box, typename Strategy>
+    static inline void apply(Polygon const& polygon, Box& mbr, Strategy const& strategy)
+    {
+        typename ring_return_type<Polygon const>::type ext_ring
+            = exterior_ring(polygon);
+
+        if (geometry::is_empty(ext_ring))
+        {
+            // if the exterior ring is empty, consider the interior rings
+            envelope_multi_range
+                <
+                    envelope_range
+                >::apply(interior_rings(polygon), mbr, strategy);
+        }
+        else
+        {
+            // otherwise, consider only the exterior ring
+            envelope_range::apply(ext_ring, mbr, strategy);
+        }
+    }
+};
+
+
+}} // namespace detail::envelope
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Ring>
+struct envelope<Ring, ring_tag>
+    : detail::envelope::envelope_range
+{};
+
+
+template <typename Polygon>
+struct envelope<Polygon, polygon_tag>
+    : detail::envelope::envelope_polygon
+{};
+
+
+template <typename MultiPolygon>
+struct envelope<MultiPolygon, multi_polygon_tag>
+    : detail::envelope::envelope_multi_range
+        <
+            detail::envelope::envelope_polygon
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_IMPLEMENTATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/initialize.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/initialize.hpp
new file mode 100644
index 00000000000..d8e252b53aa
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/initialize.hpp
@@ -0,0 +1,86 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_INITIALIZE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_INITIALIZE_HPP
+
+#include <cstddef>
+
+#include <boost/numeric/conversion/bounds.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace envelope
+{
+
+template <std::size_t Dimension, std::size_t DimensionCount>
+struct initialize_loop
+{
+    template <typename Box, typename CoordinateType>
+    static inline void apply(Box& box,
+                             CoordinateType min_value,
+                             CoordinateType max_value)
+    {
+        geometry::set<min_corner, Dimension>(box, min_value);
+        geometry::set<max_corner, Dimension>(box, max_value);
+
+        initialize_loop
+            <
+                Dimension + 1, DimensionCount
+            >::apply(box, min_value, max_value);
+    }
+};
+
+template <std::size_t DimensionCount>
+struct initialize_loop<DimensionCount, DimensionCount>
+{
+    template <typename Box, typename CoordinateType>
+    static inline void apply(Box&, CoordinateType, CoordinateType)
+    {
+    }
+};
+
+
+template
+<
+    typename Box,
+    std::size_t Dimension = 0,
+    std::size_t DimensionCount = dimension<Box>::value
+>
+struct initialize
+{
+    typedef typename coordinate_type<Box>::type coordinate_type;
+
+    static inline void apply(Box& box,
+        coordinate_type min_value
+            = boost::numeric::bounds<coordinate_type>::highest(),
+        coordinate_type max_value
+            = boost::numeric::bounds<coordinate_type>::lowest())
+    {
+        initialize_loop
+            <
+                Dimension, DimensionCount
+            >::apply(box, min_value, max_value);
+    }
+};
+
+}} // namespace detail::envelope
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_INITIALIZE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/interface.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/interface.hpp
new file mode 100644
index 00000000000..8e9c35b3955
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/interface.hpp
@@ -0,0 +1,224 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015, 2016, 2017.
+// Modifications copyright (c) 2015-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_INTERFACE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_INTERFACE_HPP
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/algorithms/dispatch/envelope.hpp>
+
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/strategies/envelope.hpp>
+#include <boost/geometry/strategies/cartesian/envelope_segment.hpp>
+#include <boost/geometry/strategies/spherical/envelope_segment.hpp>
+#include <boost/geometry/strategies/geographic/envelope_segment.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace resolve_strategy
+{
+
+template <typename Geometry>
+struct envelope
+{
+    template <typename Box, typename Strategy>
+    static inline void apply(Geometry const& geometry,
+                             Box& box,
+                             Strategy const& strategy)
+    {
+        dispatch::envelope<Geometry>::apply(geometry, box, strategy);
+    }
+
+    template <typename Box>
+    static inline void apply(Geometry const& geometry,
+                             Box& box,
+                             default_strategy)
+    {
+        typedef typename point_type<Geometry>::type point_type;
+        typedef typename coordinate_type<point_type>::type coordinate_type;
+
+        typedef typename strategy::envelope::services::default_strategy
+            <
+                typename cs_tag<point_type>::type,
+                coordinate_type
+            >::type strategy_type;
+
+        dispatch::envelope<Geometry>::apply(geometry, box, strategy_type());
+    }
+};
+
+} // namespace resolve_strategy
+
+namespace resolve_variant
+{
+
+template <typename Geometry>
+struct envelope
+{
+    template <typename Box, typename Strategy>
+    static inline void apply(Geometry const& geometry,
+                             Box& box,
+                             Strategy const& strategy)
+    {
+        concepts::check<Geometry const>();
+        concepts::check<Box>();
+
+        resolve_strategy::envelope<Geometry>::apply(geometry, box, strategy);
+    }
+};
+
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct envelope<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Box, typename Strategy>
+    struct visitor: boost::static_visitor<void>
+    {
+        Box& m_box;
+        Strategy const& m_strategy;
+
+        visitor(Box& box, Strategy const& strategy)
+            : m_box(box)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Geometry>
+        void operator()(Geometry const& geometry) const
+        {
+            envelope<Geometry>::apply(geometry, m_box, m_strategy);
+        }
+    };
+
+    template <typename Box, typename Strategy>
+    static inline void
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry,
+          Box& box,
+          Strategy const& strategy)
+    {
+        boost::apply_visitor(visitor<Box, Strategy>(box, strategy), geometry);
+    }
+};
+
+} // namespace resolve_variant
+
+/*!
+\brief \brief_calc{envelope (with strategy)}
+\ingroup envelope
+\details \details_calc{envelope,\det_envelope}.
+\tparam Geometry \tparam_geometry
+\tparam Box \tparam_box
+\tparam Strategy \tparam_strategy{Envelope}
+\param geometry \param_geometry
+\param mbr \param_box \param_set{envelope}
+\param strategy \param_strategy{envelope}
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/envelope.qbk]}
+\qbk{
+[heading Example]
+[envelope] [envelope_output]
+}
+*/
+template<typename Geometry, typename Box, typename Strategy>
+inline void envelope(Geometry const& geometry, Box& mbr, Strategy const& strategy)
+{
+    resolve_variant::envelope<Geometry>::apply(geometry, mbr, strategy);
+}
+
+/*!
+\brief \brief_calc{envelope}
+\ingroup envelope
+\details \details_calc{envelope,\det_envelope}.
+\tparam Geometry \tparam_geometry
+\tparam Box \tparam_box
+\param geometry \param_geometry
+\param mbr \param_box \param_set{envelope}
+
+\qbk{[include reference/algorithms/envelope.qbk]}
+\qbk{
+[heading Example]
+[envelope] [envelope_output]
+}
+*/
+template<typename Geometry, typename Box>
+inline void envelope(Geometry const& geometry, Box& mbr)
+{
+    resolve_variant::envelope<Geometry>::apply(geometry, mbr, default_strategy());
+}
+
+
+/*!
+\brief \brief_calc{envelope}
+\ingroup envelope
+\details \details_calc{return_envelope,\det_envelope}. \details_return{envelope}
+\tparam Box \tparam_box
+\tparam Geometry \tparam_geometry
+\tparam Strategy \tparam_strategy{Envelope}
+\param geometry \param_geometry
+\param strategy \param_strategy{envelope}
+\return \return_calc{envelope}
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/envelope.qbk]}
+\qbk{
+[heading Example]
+[return_envelope] [return_envelope_output]
+}
+*/
+template<typename Box, typename Geometry, typename Strategy>
+inline Box return_envelope(Geometry const& geometry, Strategy const& strategy)
+{
+    Box mbr;
+    resolve_variant::envelope<Geometry>::apply(geometry, mbr, strategy);
+    return mbr;
+}
+
+/*!
+\brief \brief_calc{envelope}
+\ingroup envelope
+\details \details_calc{return_envelope,\det_envelope}. \details_return{envelope}
+\tparam Box \tparam_box
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\return \return_calc{envelope}
+
+\qbk{[include reference/algorithms/envelope.qbk]}
+\qbk{
+[heading Example]
+[return_envelope] [return_envelope_output]
+}
+*/
+template<typename Box, typename Geometry>
+inline Box return_envelope(Geometry const& geometry)
+{
+    Box mbr;
+    resolve_variant::envelope<Geometry>::apply(geometry, mbr, default_strategy());
+    return mbr;
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_INTERFACE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/intersects_antimeridian.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/intersects_antimeridian.hpp
new file mode 100644
index 00000000000..47937bf7407
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/intersects_antimeridian.hpp
@@ -0,0 +1,78 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_INTERSECTS_ANTIMERIDIAN_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_INTERSECTS_ANTIMERIDIAN_HPP
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_system.hpp>
+
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/algorithms/detail/normalize.hpp>
+
+
+namespace boost { namespace geometry                  
+{
+
+namespace detail { namespace envelope
+{
+
+
+struct intersects_antimeridian
+{
+    template <typename Units, typename CoordinateType>
+    static inline bool apply(CoordinateType const& lon1,
+                             CoordinateType const& lat1,
+                             CoordinateType const& lon2,
+                             CoordinateType const& lat2)
+    {
+        typedef math::detail::constants_on_spheroid
+            <
+                CoordinateType, Units
+            > constants;
+    
+        return
+            math::equals(math::abs(lat1), constants::max_latitude())
+            ||
+            math::equals(math::abs(lat2), constants::max_latitude())
+            ||
+            math::larger(math::abs(lon1 - lon2), constants::half_period());
+    }
+
+    template <typename Segment>
+    static inline bool apply(Segment const& segment)
+    {
+        return apply(detail::indexed_point_view<Segment, 0>(segment),
+                     detail::indexed_point_view<Segment, 1>(segment));
+    }
+
+    template <typename Point>
+    static inline bool apply(Point const& p1, Point const& p2)
+    {
+        Point p1_normalized = detail::return_normalized<Point>(p1);
+        Point p2_normalized = detail::return_normalized<Point>(p2);
+
+        return apply
+            <
+                typename coordinate_system<Point>::type::units
+            >(geometry::get<0>(p1_normalized),
+              geometry::get<1>(p1_normalized),
+              geometry::get<0>(p2_normalized),
+              geometry::get<1>(p2_normalized));
+    }
+};
+
+
+}} // namespace detail::envelope
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_INTERSECTS_ANTIMERIDIAN_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/linear.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/linear.hpp
new file mode 100644
index 00000000000..09d8a76da55
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/linear.hpp
@@ -0,0 +1,114 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015, 2016.
+// Modifications copyright (c) 2015-2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_LINEAR_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_LINEAR_HPP
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/iterators/segment_iterator.hpp>
+
+#include <boost/geometry/algorithms/detail/envelope/range.hpp>
+
+#include <boost/geometry/algorithms/dispatch/envelope.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace envelope
+{
+
+
+struct envelope_linestring_on_spheroid
+{
+    template <typename Linestring, typename Box, typename Strategy>
+    static inline void apply(Linestring const& linestring,
+                             Box& mbr,
+                             Strategy const& strategy)
+    {
+        envelope_range::apply(geometry::segments_begin(linestring),
+                              geometry::segments_end(linestring),
+                              mbr,
+                              strategy);
+    }
+};
+
+
+}} // namespace detail::envelope
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Linestring, typename CS_Tag>
+struct envelope<Linestring, linestring_tag, CS_Tag>
+    : detail::envelope::envelope_range
+{};
+
+template <typename Linestring>
+struct envelope<Linestring, linestring_tag, spherical_equatorial_tag>
+    : detail::envelope::envelope_linestring_on_spheroid
+{};
+
+template <typename Linestring>
+struct envelope<Linestring, linestring_tag, geographic_tag>
+    : detail::envelope::envelope_linestring_on_spheroid
+{};
+
+
+template <typename MultiLinestring, typename CS_Tag>
+struct envelope
+    <
+        MultiLinestring, multi_linestring_tag, CS_Tag
+    > : detail::envelope::envelope_multi_range
+        <
+            detail::envelope::envelope_range
+        >
+{};
+
+template <typename MultiLinestring>
+struct envelope
+    <
+        MultiLinestring, multi_linestring_tag, spherical_equatorial_tag
+    > : detail::envelope::envelope_multi_range_on_spheroid
+        <
+            detail::envelope::envelope_linestring_on_spheroid
+        >
+{};
+
+template <typename MultiLinestring>
+struct envelope
+    <
+        MultiLinestring, multi_linestring_tag, geographic_tag
+    > : detail::envelope::envelope_multi_range_on_spheroid
+        <
+            detail::envelope::envelope_linestring_on_spheroid
+        >
+{};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_LINEAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/multipoint.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/multipoint.hpp
new file mode 100644
index 00000000000..efee4701c9d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/multipoint.hpp
@@ -0,0 +1,379 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015-2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_MULTIPOINT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_MULTIPOINT_HPP
+
+#include <cstddef>
+#include <algorithm>
+#include <utility>
+#include <vector>
+
+#include <boost/algorithm/minmax_element.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/coordinate_system.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/geometries/helper_geometry.hpp>
+
+#include <boost/geometry/algorithms/detail/normalize.hpp>
+
+#include <boost/geometry/algorithms/detail/envelope/box.hpp>
+#include <boost/geometry/algorithms/detail/envelope/initialize.hpp>
+#include <boost/geometry/algorithms/detail/envelope/range.hpp>
+#include <boost/geometry/algorithms/detail/expand/point.hpp>
+
+#include <boost/geometry/algorithms/dispatch/envelope.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace envelope
+{
+
+
+class envelope_multipoint_on_spheroid
+{
+private:
+    template <std::size_t Dim>
+    struct coordinate_less
+    {
+        template <typename Point>
+        inline bool operator()(Point const& point1, Point const& point2) const
+        {
+            return math::smaller(geometry::get<Dim>(point1),
+                                 geometry::get<Dim>(point2));
+        }
+    };
+
+    template <typename Constants, typename MultiPoint, typename OutputIterator>
+    static inline void analyze_point_coordinates(MultiPoint const& multipoint,
+                                                 bool& has_south_pole,
+                                                 bool& has_north_pole,
+                                                 OutputIterator oit)
+    {
+        typedef typename boost::range_value<MultiPoint>::type point_type;
+        typedef typename boost::range_iterator
+            <
+                MultiPoint const
+            >::type iterator_type;
+
+        // analyze point coordinates:
+        // (1) normalize point coordinates
+        // (2) check if any point is the north or the south pole
+        // (3) put all non-pole points in a container
+        //
+        // notice that at this point in the algorithm, we have at
+        // least two points on the spheroid
+        has_south_pole = false;
+        has_north_pole = false;
+
+        for (iterator_type it = boost::begin(multipoint);
+             it != boost::end(multipoint);
+             ++it)
+        {
+            point_type point = detail::return_normalized<point_type>(*it);
+
+            if (math::equals(geometry::get<1>(point),
+                             Constants::min_latitude()))
+            {
+                has_south_pole = true;
+            }
+            else if (math::equals(geometry::get<1>(point),
+                                  Constants::max_latitude()))
+            {
+                has_north_pole = true;
+            }
+            else
+            {
+                *oit++ = point;
+            }
+        }
+    }
+
+    template <typename SortedRange, typename Value>
+    static inline Value maximum_gap(SortedRange const& sorted_range,
+                                    Value& max_gap_left,
+                                    Value& max_gap_right)
+    {
+        typedef typename boost::range_iterator
+            <
+                SortedRange const
+            >::type iterator_type;
+
+        iterator_type it1 = boost::begin(sorted_range), it2 = it1;
+        ++it2;
+        max_gap_left = geometry::get<0>(*it1);
+        max_gap_right = geometry::get<0>(*it2);
+
+        Value max_gap = max_gap_right - max_gap_left;
+        for (++it1, ++it2; it2 != boost::end(sorted_range); ++it1, ++it2)
+        {
+            Value gap = geometry::get<0>(*it2) - geometry::get<0>(*it1);
+            if (math::larger(gap, max_gap))
+            {
+                max_gap_left = geometry::get<0>(*it1);
+                max_gap_right = geometry::get<0>(*it2);
+                max_gap = gap;
+            }
+        }
+
+        return max_gap;
+    }
+
+    template
+    <
+        typename Constants,
+        typename PointRange,
+        typename LongitudeLess,
+        typename CoordinateType
+    >
+    static inline void get_min_max_longitudes(PointRange& range,
+                                              LongitudeLess const& lon_less,
+                                              CoordinateType& lon_min,
+                                              CoordinateType& lon_max)
+    {
+        typedef typename boost::range_iterator
+            <
+                PointRange const
+            >::type iterator_type;
+
+        // compute min and max longitude values
+        std::pair<iterator_type, iterator_type> min_max_longitudes
+            = boost::minmax_element(boost::begin(range),
+                                    boost::end(range),
+                                    lon_less);
+
+        lon_min = geometry::get<0>(*min_max_longitudes.first);
+        lon_max = geometry::get<0>(*min_max_longitudes.second);
+
+        // if the longitude span is "large" compute the true maximum gap
+        if (math::larger(lon_max - lon_min, Constants::half_period()))
+        {
+            std::sort(boost::begin(range), boost::end(range), lon_less);
+
+            CoordinateType max_gap_left = 0, max_gap_right = 0;
+            CoordinateType max_gap
+                = maximum_gap(range, max_gap_left, max_gap_right);
+
+            CoordinateType complement_gap
+                = Constants::period() + lon_min - lon_max;
+
+            if (math::larger(max_gap, complement_gap))
+            {
+                lon_min = max_gap_right;
+                lon_max = max_gap_left + Constants::period();
+            }
+        }
+    }
+
+    template
+    <
+        typename Constants,
+        typename Iterator,
+        typename LatitudeLess,
+        typename CoordinateType
+    >
+    static inline void get_min_max_latitudes(Iterator const first,
+                                             Iterator const last,
+                                             LatitudeLess const& lat_less,
+                                             bool has_south_pole,
+                                             bool has_north_pole,
+                                             CoordinateType& lat_min,
+                                             CoordinateType& lat_max)
+    {
+        if (has_south_pole && has_north_pole)
+        {
+            lat_min = Constants::min_latitude();
+            lat_max = Constants::max_latitude();
+        }
+        else if (has_south_pole)
+        {
+            lat_min = Constants::min_latitude();
+            lat_max
+                = geometry::get<1>(*std::max_element(first, last, lat_less));
+        }
+        else if (has_north_pole)
+        {
+            lat_min
+                = geometry::get<1>(*std::min_element(first, last, lat_less));
+            lat_max = Constants::max_latitude();
+        }
+        else
+        {
+            std::pair<Iterator, Iterator> min_max_latitudes
+                = boost::minmax_element(first, last, lat_less);
+
+            lat_min = geometry::get<1>(*min_max_latitudes.first);
+            lat_max = geometry::get<1>(*min_max_latitudes.second);
+        }
+    }
+
+public:
+    template <typename MultiPoint, typename Box, typename Strategy>
+    static inline void apply(MultiPoint const& multipoint, Box& mbr, Strategy const& strategy)
+    {
+        typedef typename point_type<MultiPoint>::type point_type;
+        typedef typename coordinate_type<MultiPoint>::type coordinate_type;
+        typedef typename boost::range_iterator
+            <
+                MultiPoint const
+            >::type iterator_type;
+
+        typedef math::detail::constants_on_spheroid
+            <
+                coordinate_type,
+                typename coordinate_system<MultiPoint>::type::units
+            > constants;
+
+        if (boost::empty(multipoint))
+        {
+            initialize<Box, 0, dimension<Box>::value>::apply(mbr);
+            return;
+        }
+
+        initialize<Box, 0, 2>::apply(mbr);
+
+        if (boost::size(multipoint) == 1)
+        {
+            return dispatch::envelope
+                <
+                    typename boost::range_value<MultiPoint>::type
+                >::apply(range::front(multipoint), mbr, strategy);
+        }
+
+        // analyze the points and put the non-pole ones in the
+        // points vector
+        std::vector<point_type> points;
+        bool has_north_pole = false, has_south_pole = false;
+
+        analyze_point_coordinates<constants>(multipoint,
+                                             has_south_pole, has_north_pole,
+                                             std::back_inserter(points));
+
+        coordinate_type lon_min, lat_min, lon_max, lat_max;
+        if (points.size() == 1)
+        {
+            // we have one non-pole point and at least one pole point
+            lon_min = geometry::get<0>(range::front(points));
+            lon_max = geometry::get<0>(range::front(points));
+            lat_min = has_south_pole
+                ? constants::min_latitude()
+                : constants::max_latitude();
+            lat_max = has_north_pole
+                ? constants::max_latitude()
+                : constants::min_latitude();
+        }
+        else if (points.empty())
+        {
+            // all points are pole points
+            BOOST_GEOMETRY_ASSERT(has_south_pole || has_north_pole);
+            lon_min = coordinate_type(0);
+            lon_max = coordinate_type(0);
+            lat_min = has_south_pole
+                ? constants::min_latitude()
+                : constants::max_latitude();
+            lat_max = (has_north_pole)
+                ? constants::max_latitude()
+                : constants::min_latitude();
+        }
+        else
+        {
+            get_min_max_longitudes<constants>(points,
+                                              coordinate_less<0>(),
+                                              lon_min,
+                                              lon_max);
+
+            get_min_max_latitudes<constants>(points.begin(),
+                                             points.end(),
+                                             coordinate_less<1>(),
+                                             has_south_pole,
+                                             has_north_pole,
+                                             lat_min,
+                                             lat_max);
+        }
+
+        typedef typename helper_geometry
+            <
+                Box,
+                coordinate_type,
+                typename coordinate_system<MultiPoint>::type::units
+            >::type helper_box_type;
+
+        helper_box_type helper_mbr;
+
+        geometry::set<min_corner, 0>(helper_mbr, lon_min);
+        geometry::set<min_corner, 1>(helper_mbr, lat_min);
+        geometry::set<max_corner, 0>(helper_mbr, lon_max);
+        geometry::set<max_corner, 1>(helper_mbr, lat_max);
+
+        // now transform to output MBR (per index)
+        envelope_indexed_box_on_spheroid<min_corner, 2>::apply(helper_mbr, mbr);
+        envelope_indexed_box_on_spheroid<max_corner, 2>::apply(helper_mbr, mbr);
+
+        // compute envelope for higher coordinates
+        iterator_type it = boost::begin(multipoint);
+        envelope_one_point<2, dimension<Box>::value>::apply(*it, mbr, strategy);
+
+        for (++it; it != boost::end(multipoint); ++it)
+        {
+            detail::expand::point_loop
+                <
+                    strategy::compare::default_strategy,
+                    strategy::compare::default_strategy,
+                    2, dimension<Box>::value
+                >::apply(mbr, *it, strategy);
+        }
+    }
+};
+
+
+}} // namespace detail::envelope
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename MultiPoint, typename CSTag>
+struct envelope<MultiPoint, multi_point_tag, CSTag>
+    : detail::envelope::envelope_range
+{};
+
+template <typename MultiPoint>
+struct envelope<MultiPoint, multi_point_tag, spherical_equatorial_tag>
+    : detail::envelope::envelope_multipoint_on_spheroid
+{};
+
+template <typename MultiPoint>
+struct envelope<MultiPoint, multi_point_tag, geographic_tag>
+    : detail::envelope::envelope_multipoint_on_spheroid
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_MULTIPOINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/point.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/point.hpp
new file mode 100644
index 00000000000..ee0559bf5fb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/point.hpp
@@ -0,0 +1,128 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015, 2016.
+// Modifications copyright (c) 2015-2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_POINT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_POINT_HPP
+
+#include <cstddef>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_system.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/views/detail/indexed_point_view.hpp>
+
+#include <boost/geometry/algorithms/detail/convert_point_to_point.hpp>
+#include <boost/geometry/algorithms/detail/normalize.hpp>
+
+#include <boost/geometry/algorithms/detail/envelope/transform_units.hpp>
+
+#include <boost/geometry/algorithms/dispatch/envelope.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace envelope
+{
+
+
+template <std::size_t Dimension, std::size_t DimensionCount>
+struct envelope_one_point
+{
+    template <std::size_t Index, typename Point, typename Box>
+    static inline void apply(Point const& point, Box& mbr)
+    {
+        detail::indexed_point_view<Box, Index> box_corner(mbr);
+        detail::conversion::point_to_point
+            <
+                Point,
+                detail::indexed_point_view<Box, Index>,
+                Dimension,
+                DimensionCount
+            >::apply(point, box_corner);
+    }
+
+    template <typename Point, typename Box, typename Strategy>
+    static inline void apply(Point const& point, Box& mbr, Strategy const&)
+    {
+        apply<min_corner>(point, mbr);
+        apply<max_corner>(point, mbr);
+    }
+};
+
+
+struct envelope_point_on_spheroid
+{
+    template<typename Point, typename Box, typename Strategy>
+    static inline void apply(Point const& point, Box& mbr, Strategy const& strategy)
+    {
+        Point normalized_point = detail::return_normalized<Point>(point);
+
+        typename point_type<Box>::type box_point;
+
+        // transform units of input point to units of a box point
+        transform_units(normalized_point, box_point);
+
+        geometry::set<min_corner, 0>(mbr, geometry::get<0>(box_point));
+        geometry::set<min_corner, 1>(mbr, geometry::get<1>(box_point));
+
+        geometry::set<max_corner, 0>(mbr, geometry::get<0>(box_point));
+        geometry::set<max_corner, 1>(mbr, geometry::get<1>(box_point));
+
+        envelope_one_point
+            <
+                2, dimension<Point>::value
+            >::apply(normalized_point, mbr, strategy);
+    }
+};
+
+
+}} // namespace detail::envelope
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Point, typename CS_Tag>
+struct envelope<Point, point_tag, CS_Tag>
+    : detail::envelope::envelope_one_point<0, dimension<Point>::value>
+{};
+
+
+template <typename Point>
+struct envelope<Point, point_tag, spherical_equatorial_tag>
+    : detail::envelope::envelope_point_on_spheroid
+{};
+
+
+template <typename Point>
+struct envelope<Point, point_tag, geographic_tag>
+    : detail::envelope::envelope_point_on_spheroid
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_POINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/range.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/range.hpp
new file mode 100644
index 00000000000..b5591f61ab3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/range.hpp
@@ -0,0 +1,187 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015, 2016.
+// Modifications copyright (c) 2015-2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_RANGE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_RANGE_HPP
+
+#include <iterator>
+#include <vector>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/coordinate_dimension.hpp>
+
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/algorithms/is_empty.hpp>
+
+#include <boost/geometry/algorithms/detail/envelope/initialize.hpp>
+#include <boost/geometry/algorithms/detail/envelope/range_of_boxes.hpp>
+
+#include <boost/geometry/algorithms/detail/expand/box.hpp>
+#include <boost/geometry/algorithms/detail/expand/point.hpp>
+#include <boost/geometry/algorithms/detail/expand/segment.hpp>
+
+#include <boost/geometry/algorithms/dispatch/envelope.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace envelope
+{
+
+
+// implementation for simple ranges
+struct envelope_range
+{
+    template <typename Iterator, typename Box, typename Strategy>
+    static inline void apply(Iterator first,
+                             Iterator last,
+                             Box& mbr,
+                             Strategy const& strategy)
+    {
+        typedef typename std::iterator_traits<Iterator>::value_type value_type;
+
+        // initialize MBR
+        initialize<Box, 0, dimension<Box>::value>::apply(mbr);
+
+        Iterator it = first;
+        if (it != last)
+        {
+            // initialize box with first element in range
+            dispatch::envelope<value_type>::apply(*it, mbr, strategy);
+
+            // consider now the remaining elements in the range (if any)
+            for (++it; it != last; ++it)
+            {
+                dispatch::expand<Box, value_type>::apply(mbr, *it, strategy);
+            }
+        }
+    }
+
+    template <typename Range, typename Box, typename Strategy>
+    static inline void apply(Range const& range, Box& mbr, Strategy const& strategy)
+    {
+        return apply(boost::begin(range), boost::end(range), mbr, strategy);
+    }
+};
+
+
+// implementation for multi-ranges
+template <typename EnvelopePolicy>
+struct envelope_multi_range
+{
+    template <typename MultiRange, typename Box, typename Strategy>
+    static inline void apply(MultiRange const& multirange,
+                             Box& mbr,
+                             Strategy const& strategy)
+    {
+        typedef typename boost::range_iterator
+            <
+                MultiRange const
+            >::type iterator_type;
+
+        bool initialized = false;
+        for (iterator_type it = boost::begin(multirange);
+             it != boost::end(multirange);
+             ++it)
+        {
+            if (! geometry::is_empty(*it))
+            {
+                if (initialized)
+                {
+                    Box helper_mbr;
+                    EnvelopePolicy::apply(*it, helper_mbr, strategy);
+
+                    dispatch::expand<Box, Box>::apply(mbr, helper_mbr, strategy);
+                }
+                else
+                {
+                    // compute the initial envelope
+                    EnvelopePolicy::apply(*it, mbr, strategy);
+                    initialized = true;
+                }
+            }
+        }
+
+        if (! initialized)
+        {
+            // if not already initialized, initialize MBR
+            initialize<Box, 0, dimension<Box>::value>::apply(mbr);
+        }
+    }
+};
+
+
+// implementation for multi-range on a spheroid (longitude is periodic)
+template <typename EnvelopePolicy>
+struct envelope_multi_range_on_spheroid
+{
+    template <typename MultiRange, typename Box, typename Strategy>
+    static inline void apply(MultiRange const& multirange,
+                             Box& mbr,
+                             Strategy const& strategy)
+    {
+        typedef typename boost::range_iterator
+            <
+                MultiRange const
+            >::type iterator_type;
+
+        // due to the periodicity of longitudes we need to compute the boxes
+        // of all the single geometries and keep them in a container
+        std::vector<Box> boxes;
+        for (iterator_type it = boost::begin(multirange);
+             it != boost::end(multirange);
+             ++it)
+        {
+            if (! geometry::is_empty(*it))
+            {
+                Box helper_box;
+                EnvelopePolicy::apply(*it, helper_box, strategy);
+                boxes.push_back(helper_box);
+            }
+        }
+
+        // now we need to compute the envelope of the range of boxes
+        // (cannot be done in an incremental fashion as in the
+        // Cartesian coordinate system)
+        // if all single geometries are empty no boxes have been found
+        // and the MBR is simply initialized
+        if (! boxes.empty())
+        {
+            envelope_range_of_boxes::apply(boxes, mbr, strategy);
+        }
+        else
+        {
+            initialize<Box, 0, dimension<Box>::value>::apply(mbr);
+        }
+
+    }
+};
+
+
+}} // namespace detail::envelope
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_RANGE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/range_of_boxes.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/range_of_boxes.hpp
new file mode 100644
index 00000000000..f61fc422de7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/range_of_boxes.hpp
@@ -0,0 +1,331 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015-2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_RANGE_OF_BOXES_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_RANGE_OF_BOXES_HPP
+
+#include <cstddef>
+
+#include <algorithm>
+#include <vector>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/coordinate_system.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/algorithms/detail/convert_point_to_point.hpp>
+#include <boost/geometry/algorithms/detail/max_interval_gap.hpp>
+#include <boost/geometry/algorithms/detail/expand/indexed.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace envelope
+{
+
+
+template <typename T>
+class longitude_interval
+{
+    typedef T const& reference_type;
+
+public:
+    typedef T value_type;
+    typedef T difference_type;
+
+    longitude_interval(T const& left, T const& right)
+    {
+        m_end[0] = left;
+        m_end[1] = right;        
+    }
+
+    template <std::size_t Index>
+    reference_type get() const
+    {
+        return m_end[Index];
+    }
+
+    difference_type length() const
+    {
+        return get<1>() - get<0>();
+    }
+
+private:
+    T m_end[2];
+};
+
+
+template <typename Units>
+struct envelope_range_of_longitudes
+{
+    template <std::size_t Index>
+    struct longitude_less
+    {
+        template <typename Interval>
+        inline bool operator()(Interval const& i1, Interval const& i2) const
+        {
+            return math::smaller(i1.template get<Index>(),
+                                 i2.template get<Index>());
+        }
+    };
+
+    template <typename RangeOfLongitudeIntervals, typename Longitude>
+    static inline void apply(RangeOfLongitudeIntervals const& range,
+                             Longitude& lon_min, Longitude& lon_max)
+    {
+        typedef typename math::detail::constants_on_spheroid
+            <
+                Longitude, Units
+            > constants;
+
+        Longitude const zero = 0;
+        Longitude const period = constants::period();
+
+        lon_min = lon_max = zero;
+
+        // the range of longitude intervals can be empty if all input boxes
+        // degenerate to the north or south pole (or combination of the two)
+        // in this case the initialization values for lon_min and
+        // lon_max are valid choices
+        if (! boost::empty(range))
+        {
+            lon_min = std::min_element(boost::begin(range),
+                                       boost::end(range),
+                                       longitude_less<0>())->template get<0>();
+            lon_max = std::max_element(boost::begin(range),
+                                       boost::end(range),
+                                       longitude_less<1>())->template get<1>();
+
+            if (math::larger(lon_max - lon_min, constants::half_period()))
+            {
+                Longitude max_gap_left, max_gap_right;
+                Longitude max_gap = geometry::maximum_gap(range,
+                                                          max_gap_left,
+                                                          max_gap_right);
+
+                BOOST_GEOMETRY_ASSERT(! math::larger(lon_min, lon_max));
+                BOOST_GEOMETRY_ASSERT
+                    (! math::larger(lon_max, constants::max_longitude()));
+                BOOST_GEOMETRY_ASSERT
+                    (! math::smaller(lon_min, constants::min_longitude()));
+
+                BOOST_GEOMETRY_ASSERT
+                    (! math::larger(max_gap_left, max_gap_right));
+                BOOST_GEOMETRY_ASSERT
+                    (! math::larger(max_gap_right, constants::max_longitude()));
+                BOOST_GEOMETRY_ASSERT
+                    (! math::smaller(max_gap_left, constants::min_longitude()));
+
+                if (math::larger(max_gap, zero))
+                {
+                    Longitude wrapped_gap = period + lon_min - lon_max;
+                    if (math::larger(max_gap, wrapped_gap))
+                    {
+                        lon_min = max_gap_right;
+                        lon_max = max_gap_left + period;
+                    }
+                }
+            }
+        }
+    }
+};
+
+
+template <std::size_t Dimension, std::size_t DimensionCount>
+struct envelope_range_of_boxes_by_expansion
+{
+    template <typename RangeOfBoxes, typename Box, typename Strategy>
+    static inline void apply(RangeOfBoxes const& range_of_boxes,
+                             Box& mbr,
+                             Strategy const& strategy)
+    {
+        typedef typename boost::range_value<RangeOfBoxes>::type box_type;
+
+        typedef typename boost::range_iterator
+            <
+                RangeOfBoxes const
+            >::type iterator_type;
+
+        // first initialize MBR
+        detail::indexed_point_view<Box, min_corner> mbr_min(mbr);
+        detail::indexed_point_view<Box, max_corner> mbr_max(mbr);
+
+        detail::indexed_point_view<box_type const, min_corner>
+            first_box_min(range::front(range_of_boxes));
+
+        detail::indexed_point_view<box_type const, max_corner>
+            first_box_max(range::front(range_of_boxes));
+
+        detail::conversion::point_to_point
+            <
+                detail::indexed_point_view<box_type const, min_corner>,
+                detail::indexed_point_view<Box, min_corner>,
+                Dimension,
+                DimensionCount
+            >::apply(first_box_min, mbr_min);
+
+        detail::conversion::point_to_point
+            <
+                detail::indexed_point_view<box_type const, max_corner>,
+                detail::indexed_point_view<Box, max_corner>,
+                Dimension,
+                DimensionCount
+            >::apply(first_box_max, mbr_max);
+
+        // now expand using the remaining boxes
+        iterator_type it = boost::begin(range_of_boxes);
+        for (++it; it != boost::end(range_of_boxes); ++it)
+        {
+            detail::expand::indexed_loop
+                <
+                    strategy::compare::default_strategy,
+                    strategy::compare::default_strategy,
+                    min_corner,
+                    Dimension,
+                    DimensionCount
+                >::apply(mbr, *it, strategy);
+
+            detail::expand::indexed_loop
+                <
+                    strategy::compare::default_strategy,
+                    strategy::compare::default_strategy,
+                    max_corner,
+                    Dimension,
+                    DimensionCount
+                >::apply(mbr, *it, strategy);
+        }
+    }
+
+};
+
+
+struct envelope_range_of_boxes
+{
+    template <std::size_t Index>
+    struct latitude_less
+    {
+        template <typename Box>
+        inline bool operator()(Box const& box1, Box const& box2) const
+        {
+            return math::smaller(geometry::get<Index, 1>(box1),
+                                 geometry::get<Index, 1>(box2));
+        }
+    };
+
+    template <typename RangeOfBoxes, typename Box, typename Strategy>
+    static inline void apply(RangeOfBoxes const& range_of_boxes,
+                             Box& mbr,
+                             Strategy const& strategy)
+    {
+        // boxes in the range are assumed to be normalized already
+
+        typedef typename boost::range_value<RangeOfBoxes>::type box_type;
+        typedef typename coordinate_type<box_type>::type coordinate_type;
+        typedef typename coordinate_system<box_type>::type::units units_type;
+        typedef typename boost::range_iterator
+            <
+                RangeOfBoxes const
+            >::type iterator_type;
+
+        typedef math::detail::constants_on_spheroid
+            <
+                coordinate_type, units_type
+            > constants;
+
+        typedef longitude_interval<coordinate_type> interval_type;
+        typedef std::vector<interval_type> interval_range_type;
+
+        BOOST_GEOMETRY_ASSERT(! boost::empty(range_of_boxes));
+
+        iterator_type it_min = std::min_element(boost::begin(range_of_boxes),
+                                                boost::end(range_of_boxes),
+                                                latitude_less<min_corner>());
+        iterator_type it_max = std::max_element(boost::begin(range_of_boxes),
+                                                boost::end(range_of_boxes),
+                                                latitude_less<max_corner>());
+
+        coordinate_type const min_longitude = constants::min_longitude();
+        coordinate_type const max_longitude = constants::max_longitude();
+        coordinate_type const period = constants::period();
+
+        interval_range_type intervals;
+        for (iterator_type it = boost::begin(range_of_boxes);
+             it != boost::end(range_of_boxes);
+             ++it)
+        {
+            coordinate_type lat_min = geometry::get<min_corner, 1>(*it);
+            coordinate_type lat_max = geometry::get<max_corner, 1>(*it);
+            if (math::equals(lat_min, constants::max_latitude())
+                || math::equals(lat_max, constants::min_latitude()))
+            {
+                // if the box degenerates to the south or north pole
+                // just ignore it
+                continue;
+            }                             
+
+            coordinate_type lon_left = geometry::get<min_corner, 0>(*it);
+            coordinate_type lon_right = geometry::get<max_corner, 0>(*it);
+
+            if (math::larger(lon_right, max_longitude))
+            {
+                intervals.push_back(interval_type(lon_left, max_longitude));
+                intervals.push_back
+                    (interval_type(min_longitude, lon_right - period));
+            }
+            else
+            {
+                intervals.push_back(interval_type(lon_left, lon_right));
+            }
+        }
+
+        coordinate_type lon_min = 0;
+        coordinate_type lon_max = 0;
+        envelope_range_of_longitudes
+            <
+                units_type
+            >::apply(intervals, lon_min, lon_max);
+
+        // do not convert units; conversion will be performed at a
+        // higher level
+
+        // assign now the min/max longitude/latitude values
+        detail::indexed_point_view<Box, min_corner> mbr_min(mbr);
+        detail::indexed_point_view<Box, max_corner> mbr_max(mbr);
+
+        geometry::set<0>(mbr_min, lon_min);
+        geometry::set<1>(mbr_min, geometry::get<min_corner, 1>(*it_min));
+        geometry::set<0>(mbr_max, lon_max);
+        geometry::set<1>(mbr_max, geometry::get<max_corner, 1>(*it_max));
+
+        // what remains to be done is to compute the envelope range
+        // for the remaining dimensions (if any)
+        envelope_range_of_boxes_by_expansion
+            <
+                2, dimension<Box>::value
+            >::apply(range_of_boxes, mbr, strategy);
+    }
+};
+
+
+}} // namespace detail::envelope
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_RANGE_OF_BOXES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/segment.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/segment.hpp
new file mode 100644
index 00000000000..7e371949688
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/segment.hpp
@@ -0,0 +1,454 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015-2017.
+// Modifications copyright (c) 2015-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_SEGMENT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_SEGMENT_HPP
+
+#include <cstddef>
+#include <utility>
+
+#include <boost/numeric/conversion/cast.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/coordinate_system.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/srs.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/radian_access.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/geometries/helper_geometry.hpp>
+
+#include <boost/geometry/formulas/vertex_latitude.hpp>
+
+#include <boost/geometry/algorithms/detail/assign_indexed_point.hpp>
+
+#include <boost/geometry/algorithms/detail/envelope/point.hpp>
+#include <boost/geometry/algorithms/detail/envelope/transform_units.hpp>
+
+#include <boost/geometry/algorithms/detail/expand/point.hpp>
+
+#include <boost/geometry/algorithms/dispatch/envelope.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace envelope
+{
+
+template <typename CalculationType, typename CS_Tag>
+struct envelope_segment_call_vertex_latitude
+{
+    template <typename T1, typename T2, typename Strategy>
+    static inline CalculationType apply(T1 const& lat1,
+                                        T2 const& alp1,
+                                        Strategy const& )
+    {
+        return geometry::formula::vertex_latitude<CalculationType, CS_Tag>
+            ::apply(lat1, alp1);
+    }
+};
+
+template <typename CalculationType>
+struct envelope_segment_call_vertex_latitude<CalculationType, geographic_tag>
+{
+    template <typename T1, typename T2, typename Strategy>
+    static inline CalculationType apply(T1 const& lat1,
+                                        T2 const& alp1,
+                                        Strategy const& strategy)
+    {
+        return geometry::formula::vertex_latitude<CalculationType, geographic_tag>
+            ::apply(lat1, alp1, strategy.model());
+    }
+};
+
+template <typename CS_Tag>
+class envelope_segment_impl
+{
+private:
+
+    // degrees or radians
+    template <typename CalculationType>
+    static inline void swap(CalculationType& lon1,
+                            CalculationType& lat1,
+                            CalculationType& lon2,
+                            CalculationType& lat2)
+    {
+        std::swap(lon1, lon2);
+        std::swap(lat1, lat2);
+    }
+
+    // radians
+    template <typename CalculationType>
+    static inline bool contains_pi_half(CalculationType const& a1,
+                                        CalculationType const& a2)
+    {
+        // azimuths a1 and a2 are assumed to be in radians
+        BOOST_GEOMETRY_ASSERT(! math::equals(a1, a2));
+
+        static CalculationType const pi_half = math::half_pi<CalculationType>();
+
+        return (a1 < a2)
+                ? (a1 < pi_half && pi_half < a2)
+                : (a1 > pi_half && pi_half > a2);
+    }
+
+    // radians or degrees
+    template <typename Units, typename CoordinateType>
+    static inline bool crosses_antimeridian(CoordinateType const& lon1,
+                                            CoordinateType const& lon2)
+    {
+        typedef math::detail::constants_on_spheroid
+            <
+                CoordinateType, Units
+            > constants;
+
+        return math::abs(lon1 - lon2) > constants::half_period(); // > pi
+    }
+
+    // degrees or radians
+    template <typename Units, typename CalculationType, typename Strategy>
+    static inline void compute_box_corners(CalculationType& lon1,
+                                           CalculationType& lat1,
+                                           CalculationType& lon2,
+                                           CalculationType& lat2,
+                                           CalculationType a1,
+                                           CalculationType a2,
+                                           Strategy const& strategy)
+    {
+        // coordinates are assumed to be in radians
+        BOOST_GEOMETRY_ASSERT(lon1 <= lon2);
+
+        CalculationType lat1_rad = math::as_radian<Units>(lat1);
+        CalculationType lat2_rad = math::as_radian<Units>(lat2);
+
+        if (lat1 > lat2)
+        {
+            std::swap(lat1, lat2);
+            std::swap(lat1_rad, lat2_rad);
+            std::swap(a1, a2);
+        }
+
+        if (math::equals(a1, a2))
+        {
+            // the segment must lie on the equator or is very short
+            return;
+        }
+
+        if (contains_pi_half(a1, a2))
+        {
+            CalculationType p_max = envelope_segment_call_vertex_latitude
+                <CalculationType, CS_Tag>::apply(lat1_rad, a1, strategy);
+
+            CalculationType const mid_lat = lat1 + lat2;
+            if (mid_lat < 0)
+            {
+                // update using min latitude
+                CalculationType const lat_min_rad = -p_max;
+                CalculationType const lat_min
+                    = math::from_radian<Units>(lat_min_rad);
+
+                if (lat1 > lat_min)
+                {
+                    lat1 = lat_min;
+                }
+            }
+            else if (mid_lat > 0)
+            {
+                // update using max latitude
+                CalculationType const lat_max_rad = p_max;
+                CalculationType const lat_max
+                    = math::from_radian<Units>(lat_max_rad);
+
+                if (lat2 < lat_max)
+                {
+                    lat2 = lat_max;
+                }
+            }
+        }
+    }
+
+    template <typename Units, typename CalculationType>
+    static inline void special_cases(CalculationType& lon1,
+                                     CalculationType& lat1,
+                                     CalculationType& lon2,
+                                     CalculationType& lat2)
+    {
+        typedef math::detail::constants_on_spheroid
+            <
+                CalculationType, Units
+            > constants;
+
+        bool is_pole1 = math::equals(math::abs(lat1), constants::max_latitude());
+        bool is_pole2 = math::equals(math::abs(lat2), constants::max_latitude());
+
+        if (is_pole1 && is_pole2)
+        {
+            // both points are poles; nothing more to do:
+            // longitudes are already normalized to 0
+            // but just in case
+            lon1 = 0;
+            lon2 = 0;
+        }
+        else if (is_pole1 && !is_pole2)
+        {
+            // first point is a pole, second point is not:
+            // make the longitude of the first point the same as that
+            // of the second point
+            lon1 = lon2;
+        }
+        else if (!is_pole1 && is_pole2)
+        {
+            // second point is a pole, first point is not:
+            // make the longitude of the second point the same as that
+            // of the first point
+            lon2 = lon1;
+        }
+
+        if (lon1 == lon2)
+        {
+            // segment lies on a meridian
+            if (lat1 > lat2)
+            {
+                std::swap(lat1, lat2);
+            }
+            return;
+        }
+
+        BOOST_GEOMETRY_ASSERT(!is_pole1 && !is_pole2);
+
+        if (lon1 > lon2)
+        {
+            swap(lon1, lat1, lon2, lat2);
+        }
+
+        if (crosses_antimeridian<Units>(lon1, lon2))
+        {
+            lon1 += constants::period();
+            swap(lon1, lat1, lon2, lat2);
+        }
+    }
+
+    template
+    <
+        typename Units,
+        typename CalculationType,
+        typename Box
+    >
+    static inline void create_box(CalculationType lon1,
+                                  CalculationType lat1,
+                                  CalculationType lon2,
+                                  CalculationType lat2,
+                                  Box& mbr)
+    {
+        typedef typename coordinate_type<Box>::type box_coordinate_type;
+
+        typedef typename helper_geometry
+            <
+                Box, box_coordinate_type, Units
+            >::type helper_box_type;
+
+        helper_box_type radian_mbr;
+
+        geometry::set
+            <
+                min_corner, 0
+            >(radian_mbr, boost::numeric_cast<box_coordinate_type>(lon1));
+
+        geometry::set
+            <
+                min_corner, 1
+            >(radian_mbr, boost::numeric_cast<box_coordinate_type>(lat1));
+
+        geometry::set
+            <
+                max_corner, 0
+            >(radian_mbr, boost::numeric_cast<box_coordinate_type>(lon2));
+
+        geometry::set
+            <
+                max_corner, 1
+            >(radian_mbr, boost::numeric_cast<box_coordinate_type>(lat2));
+
+        transform_units(radian_mbr, mbr);
+    }
+
+
+    template <typename Units, typename CalculationType, typename Strategy>
+    static inline void apply(CalculationType& lon1,
+                             CalculationType& lat1,
+                             CalculationType& lon2,
+                             CalculationType& lat2,
+                             Strategy const& strategy)
+    {
+        special_cases<Units>(lon1, lat1, lon2, lat2);
+
+        CalculationType lon1_rad = math::as_radian<Units>(lon1);
+        CalculationType lat1_rad = math::as_radian<Units>(lat1);
+        CalculationType lon2_rad = math::as_radian<Units>(lon2);
+        CalculationType lat2_rad = math::as_radian<Units>(lat2);
+        CalculationType alp1, alp2;
+        strategy.apply(lon1_rad, lat1_rad, lon2_rad, lat2_rad, alp1, alp2);
+
+        compute_box_corners<Units>(lon1, lat1, lon2, lat2, alp1, alp2, strategy);
+    }
+
+    template <typename Units, typename CalculationType, typename Strategy>
+    static inline void apply(CalculationType& lon1,
+                             CalculationType& lat1,
+                             CalculationType& lon2,
+                             CalculationType& lat2,
+                             Strategy const& strategy,
+                             CalculationType alp1)
+    {
+        special_cases<Units>(lon1, lat1, lon2, lat2);
+
+        CalculationType lon1_rad = math::as_radian<Units>(lon1);
+        CalculationType lat1_rad = math::as_radian<Units>(lat1);
+        CalculationType lon2_rad = math::as_radian<Units>(lon2);
+        CalculationType lat2_rad = math::as_radian<Units>(lat2);
+        CalculationType alp2;
+        strategy.apply(lon2_rad, lat2_rad, lon1_rad, lat1_rad, alp2);
+        alp2 += math::pi<CalculationType>();
+
+        compute_box_corners<Units>(lon1, lat1, lon2, lat2, alp1, alp2, strategy);
+    }
+
+public:
+    template
+    <
+        typename Units,
+        typename CalculationType,
+        typename Box,
+        typename Strategy
+    >
+    static inline void apply(CalculationType lon1,
+                             CalculationType lat1,
+                             CalculationType lon2,
+                             CalculationType lat2,
+                             Box& mbr,
+                             Strategy const& strategy)
+    {
+        apply<Units>(lon1, lat1, lon2, lat2, strategy);
+        create_box<Units>(lon1, lat1, lon2, lat2, mbr);
+    }
+
+    template
+    <
+        typename Units,
+        typename CalculationType,
+        typename Box,
+        typename Strategy
+    >
+    static inline void apply(CalculationType lon1,
+                             CalculationType lat1,
+                             CalculationType lon2,
+                             CalculationType lat2,
+                             Box& mbr,
+                             Strategy const& strategy,
+                             CalculationType alp1)
+    {
+        apply<Units>(lon1, lat1, lon2, lat2, strategy, alp1);
+        create_box<Units>(lon1, lat1, lon2, lat2, mbr);
+    }
+};
+
+template <std::size_t Dimension, std::size_t DimensionCount>
+struct envelope_one_segment
+{
+    template<typename Point, typename Box, typename Strategy>
+    static inline void apply(Point const& p1,
+                             Point const& p2,
+                             Box& mbr,
+                             Strategy const& strategy)
+    {
+        envelope_one_point<Dimension, DimensionCount>::apply(p1, mbr, strategy);
+        detail::expand::point_loop
+            <
+                strategy::compare::default_strategy,
+                strategy::compare::default_strategy,
+                Dimension,
+                DimensionCount
+            >::apply(mbr, p2, strategy);
+    }
+};
+
+
+template <std::size_t DimensionCount>
+struct envelope_segment
+{
+    template <typename Point, typename Box, typename Strategy>
+    static inline void apply(Point const& p1,
+                             Point const& p2,
+                             Box& mbr,
+                             Strategy const& strategy)
+    {
+        // first compute the envelope range for the first two coordinates
+        strategy.apply(p1, p2, mbr);
+
+        // now compute the envelope range for coordinates of
+        // dimension 2 and higher
+        envelope_one_segment<2, DimensionCount>::apply(p1, p2, mbr, strategy);
+    }
+
+    template <typename Segment, typename Box>
+    static inline void apply(Segment const& segment, Box& mbr)
+    {
+        typename point_type<Segment>::type p[2];
+        detail::assign_point_from_index<0>(segment, p[0]);
+        detail::assign_point_from_index<1>(segment, p[1]);
+        apply(p[0], p[1], mbr);
+    }
+};
+
+}} // namespace detail::envelope
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Segment>
+struct envelope<Segment, segment_tag>
+{
+    template <typename Box, typename Strategy>
+    static inline void apply(Segment const& segment,
+                             Box& mbr,
+                             Strategy const& strategy)
+    {
+        typename point_type<Segment>::type p[2];
+        detail::assign_point_from_index<0>(segment, p[0]);
+        detail::assign_point_from_index<1>(segment, p[1]);
+        detail::envelope::envelope_segment
+            <
+               dimension<Segment>::value
+            >::apply(p[0], p[1], mbr, strategy);
+    }
+};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_SEGMENT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/transform_units.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/transform_units.hpp
new file mode 100644
index 00000000000..790f6e386bb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/envelope/transform_units.hpp
@@ -0,0 +1,103 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_TRANSFORM_UNITS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_TRANSFORM_UNITS_HPP
+
+#include <cstddef>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/strategies/strategy_transform.hpp>
+
+#include <boost/geometry/views/detail/indexed_point_view.hpp>
+#include <boost/geometry/views/detail/two_dimensional_view.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+#include <boost/geometry/algorithms/transform.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace envelope
+{
+
+
+template
+<
+    typename GeometryIn,
+    typename GeometryOut,
+    typename TagIn = typename tag<GeometryIn>::type,
+    typename TagOut = typename tag<GeometryOut>::type
+>
+struct transform_units_impl
+    : not_implemented<TagIn, TagOut>
+{};
+
+template <typename PointIn, typename PointOut>
+struct transform_units_impl<PointIn, PointOut, point_tag, point_tag>
+{
+    static inline void apply(PointIn const& point_in, PointOut& point_out)
+    {
+        detail::two_dimensional_view<PointIn const> view_in(point_in);
+        detail::two_dimensional_view<PointOut> view_out(point_out);
+
+        geometry::transform(view_in, view_out);
+    }
+};
+
+template <typename BoxIn, typename BoxOut>
+struct transform_units_impl<BoxIn, BoxOut, box_tag, box_tag>
+{
+    template <std::size_t Index>
+    static inline void apply(BoxIn const& box_in, BoxOut& box_out)
+    {
+        typedef detail::indexed_point_view<BoxIn const, Index> view_in_type;
+        typedef detail::indexed_point_view<BoxOut, Index> view_out_type;
+
+        view_in_type view_in(box_in);
+        view_out_type view_out(box_out);
+
+        transform_units_impl
+            <
+                view_in_type, view_out_type
+            >::apply(view_in, view_out);
+    }
+
+    static inline void apply(BoxIn const& box_in, BoxOut& box_out)
+    {
+        apply<min_corner>(box_in, box_out);
+        apply<max_corner>(box_in, box_out);
+    }
+};
+
+
+// Short utility to transform the units of the first two coordinates of
+// geometry_in to the units of geometry_out
+template <typename GeometryIn, typename GeometryOut>
+inline void transform_units(GeometryIn const& geometry_in,
+                            GeometryOut& geometry_out)
+{
+    transform_units_impl
+        <
+            GeometryIn, GeometryOut
+        >::apply(geometry_in, geometry_out);
+}
+
+
+}} // namespace detail::envelope
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost:geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_ENVELOPE_TRANSFORM_UNITS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/equals/collect_vectors.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/equals/collect_vectors.hpp
new file mode 100644
index 00000000000..9625f184264
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/equals/collect_vectors.hpp
@@ -0,0 +1,575 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2017 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_EQUALS_COLLECT_VECTORS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_EQUALS_COLLECT_VECTORS_HPP
+
+
+#include <boost/numeric/conversion/cast.hpp>
+
+#include <boost/geometry/algorithms/detail/interior_iterator.hpp>
+#include <boost/geometry/algorithms/detail/normalize.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/formulas/spherical.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/views/detail/normalized_view.hpp>
+
+#include <boost/geometry/strategies/cartesian/side_by_triangle.hpp>
+#include <boost/geometry/strategies/spherical/ssf.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+// TODO: dispatch only by SideStrategy instead of Geometry/CSTag?
+
+// Since these vectors (though ray would be a better name) are used in the
+// implementation of equals() for Areal geometries the internal representation
+// should be consistent with the side strategy.
+template
+<
+    typename T,
+    typename Geometry,
+    typename SideStrategy,
+    typename CSTag = typename cs_tag<Geometry>::type
+>
+struct collected_vector
+    : nyi::not_implemented_tag
+{};
+
+// compatible with side_by_triangle cartesian strategy
+template <typename T, typename Geometry, typename CT, typename CSTag>
+struct collected_vector
+    <
+        T, Geometry, strategy::side::side_by_triangle<CT>, CSTag
+    >
+{
+    typedef T type;
+    
+    inline collected_vector()
+    {}
+
+    inline collected_vector(T const& px, T const& py,
+                            T const& pdx, T const& pdy)
+        : x(px)
+        , y(py)
+        , dx(pdx)
+        , dy(pdy)
+        //, dx_0(dx)
+        //, dy_0(dy)
+    {}
+
+    template <typename Point>
+    inline collected_vector(Point const& p1, Point const& p2)
+        : x(get<0>(p1))
+        , y(get<1>(p1))
+        , dx(get<0>(p2) - x)
+        , dy(get<1>(p2) - y)
+        //, dx_0(dx)
+        //, dy_0(dy)
+    {}
+
+    bool normalize()
+    {
+        T magnitude = math::sqrt(
+            boost::numeric_cast<T>(dx * dx + dy * dy));
+
+        // NOTE: shouldn't here math::equals() be called?
+        if (magnitude > 0)
+        {
+            dx /= magnitude;
+            dy /= magnitude;
+            return true;
+        }
+
+        return false;
+    }
+
+    // For sorting
+    inline bool operator<(collected_vector const& other) const
+    {
+        if (math::equals(x, other.x))
+        {
+            if (math::equals(y, other.y))
+            {
+                if (math::equals(dx, other.dx))
+                {
+                    return dy < other.dy;
+                }
+                return dx < other.dx;
+            }
+            return y < other.y;
+        }
+        return x < other.x;
+    }
+
+    inline bool next_is_collinear(collected_vector const& other) const
+    {
+        return same_direction(other);
+    }
+
+    // For std::equals
+    inline bool operator==(collected_vector const& other) const
+    {
+        return math::equals(x, other.x)
+            && math::equals(y, other.y)
+            && same_direction(other);
+    }
+
+private:
+    inline bool same_direction(collected_vector const& other) const
+    {
+        // For high precision arithmetic, we have to be
+        // more relaxed then using ==
+        // Because 2/sqrt( (0,0)<->(2,2) ) == 1/sqrt( (0,0)<->(1,1) )
+        // is not always true (at least, it is not for ttmath)
+        return math::equals_with_epsilon(dx, other.dx)
+            && math::equals_with_epsilon(dy, other.dy);
+    }
+
+    T x, y;
+    T dx, dy;
+    //T dx_0, dy_0;
+};
+
+// Compatible with spherical_side_formula which currently
+// is the default spherical and geographical strategy
+template <typename T, typename Geometry, typename CT, typename CSTag>
+struct collected_vector
+    <
+        T, Geometry, strategy::side::spherical_side_formula<CT>, CSTag
+    >
+{
+    typedef T type;
+    
+    typedef typename coordinate_system<Geometry>::type cs_type;
+    typedef model::point<T, 2, cs_type> point_type;
+    typedef model::point<T, 3, cs::cartesian> vector_type;
+
+    collected_vector()
+    {}
+
+    template <typename Point>
+    collected_vector(Point const& p1, Point const& p2)
+        : origin(get<0>(p1), get<1>(p1))
+    {
+        origin = detail::return_normalized<point_type>(origin);
+
+        using namespace geometry::formula;
+        prev = sph_to_cart3d<vector_type>(p1);
+        next = sph_to_cart3d<vector_type>(p2);
+        direction = cross_product(prev, next);
+    }
+
+    bool normalize()
+    {
+        T magnitude_sqr = dot_product(direction, direction);
+
+        // NOTE: shouldn't here math::equals() be called?
+        if (magnitude_sqr > 0)
+        {
+            divide_value(direction, math::sqrt(magnitude_sqr));
+            return true;
+        }
+
+        return false;
+    }
+
+    bool operator<(collected_vector const& other) const
+    {
+        if (math::equals(get<0>(origin), get<0>(other.origin)))
+        {
+            if (math::equals(get<1>(origin), get<1>(other.origin)))
+            {
+                if (math::equals(get<0>(direction), get<0>(other.direction)))
+                {
+                    if (math::equals(get<1>(direction), get<1>(other.direction)))
+                    {
+                        return get<2>(direction) < get<2>(other.direction);
+                    }
+                    return get<1>(direction) < get<1>(other.direction);
+                }
+                return get<0>(direction) < get<0>(other.direction);
+            }
+            return get<1>(origin) < get<1>(other.origin);
+        }
+        return get<0>(origin) < get<0>(other.origin);
+    }
+
+    // For consistency with side and intersection strategies used by relops
+    // IMPORTANT: this method should be called for previous vector
+    // and next vector should be passed as parameter
+    bool next_is_collinear(collected_vector const& other) const
+    {
+        return formula::sph_side_value(direction, other.next) == 0;
+    }
+
+    // For std::equals
+    bool operator==(collected_vector const& other) const
+    {
+        return math::equals(get<0>(origin), get<0>(other.origin))
+            && math::equals(get<1>(origin), get<1>(other.origin))
+            && is_collinear(other);
+    }
+
+private:
+    // For consistency with side and intersection strategies used by relops
+    bool is_collinear(collected_vector const& other) const
+    {
+        return formula::sph_side_value(direction, other.prev) == 0
+            && formula::sph_side_value(direction, other.next) == 0;
+    }
+    
+    /*bool same_direction(collected_vector const& other) const
+    {
+        return math::equals_with_epsilon(get<0>(direction), get<0>(other.direction))
+            && math::equals_with_epsilon(get<1>(direction), get<1>(other.direction))
+            && math::equals_with_epsilon(get<2>(direction), get<2>(other.direction));
+    }*/
+
+    point_type origin; // used for sorting and equality check
+    vector_type direction; // used for sorting, only in operator<
+    vector_type prev; // used for collinearity check, only in operator==
+    vector_type next; // used for collinearity check
+};
+
+// Specialization for spherical polar
+template <typename T, typename Geometry, typename CT>
+struct collected_vector
+    <
+        T, Geometry,
+        strategy::side::spherical_side_formula<CT>,
+        spherical_polar_tag
+    >
+    : public collected_vector
+        <
+            T, Geometry,
+            strategy::side::spherical_side_formula<CT>,
+            spherical_equatorial_tag
+        >
+{
+    typedef collected_vector
+        <
+            T, Geometry,
+            strategy::side::spherical_side_formula<CT>,
+            spherical_equatorial_tag
+        > base_type;
+
+    collected_vector() {}
+
+    template <typename Point>
+    collected_vector(Point const& p1, Point const& p2)
+        : base_type(to_equatorial(p1), to_equatorial(p2))
+    {}
+
+private:
+    template <typename Point>
+    Point polar_to_equatorial(Point const& p)
+    {
+        typedef typename coordinate_type<Point>::type coord_type;
+
+        typedef math::detail::constants_on_spheroid
+            <
+                coord_type,
+                typename coordinate_system<Point>::type::units
+            > constants;
+
+        coord_type const pi_2 = constants::half_period() / 2;
+
+        Point res = p;
+        set<1>(res, pi_2 - get<1>(p));
+        return res;
+    }
+};
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace collect_vectors
+{
+
+
+template <typename Range, typename Collection>
+struct range_collect_vectors
+{
+    typedef typename boost::range_value<Collection>::type item_type;
+    typedef typename item_type::type calculation_type;
+
+    static inline void apply(Collection& collection, Range const& range)
+    {
+        typedef geometry::detail::normalized_view
+            <
+                Range const
+            > normalized_range_type;
+
+        apply_impl(collection, normalized_range_type(range));
+    }
+
+private:
+    template <typename NormalizedRange>
+    static inline void apply_impl(Collection& collection, NormalizedRange const& range)
+    {
+        if (boost::size(range) < 2)
+        {
+            return;
+        }
+
+        typedef typename boost::range_size<Collection>::type collection_size_t;
+        collection_size_t c_old_size = boost::size(collection);
+
+        typedef typename boost::range_iterator<NormalizedRange const>::type iterator;
+
+        bool is_first = true;
+        iterator it = boost::begin(range);
+
+        for (iterator prev = it++;
+            it != boost::end(range);
+            prev = it++)
+        {
+            typename boost::range_value<Collection>::type v(*prev, *it);
+
+            // Normalize the vector -> this results in points+direction
+            // and is comparible between geometries
+            // Avoid non-duplicate points (AND division by zero)
+            if (v.normalize())
+            {
+                // Avoid non-direction changing points
+                if (is_first || ! collection.back().next_is_collinear(v))
+                {
+                    collection.push_back(v);
+                }
+                is_first = false;
+            }
+        }
+
+        // If first one has same direction as last one, remove first one
+        collection_size_t collected_count = boost::size(collection) - c_old_size;
+        if ( collected_count > 1 )
+        {
+            typedef typename boost::range_iterator<Collection>::type c_iterator;
+            c_iterator first = range::pos(collection, c_old_size);
+
+            if (collection.back().next_is_collinear(*first) )
+            {
+                //collection.erase(first);
+                // O(1) instead of O(N)
+                *first = collection.back();
+                collection.pop_back();
+            }
+        }
+    }
+};
+
+
+// Default version (cartesian)
+template <typename Box, typename Collection, typename CSTag = typename cs_tag<Box>::type>
+struct box_collect_vectors
+{
+    // Calculate on coordinate type, but if it is integer,
+    // then use double
+    typedef typename boost::range_value<Collection>::type item_type;
+    typedef typename item_type::type calculation_type;
+
+    static inline void apply(Collection& collection, Box const& box)
+    {
+        typename point_type<Box>::type lower_left, lower_right,
+            upper_left, upper_right;
+        geometry::detail::assign_box_corners(box, lower_left, lower_right,
+            upper_left, upper_right);
+
+        typedef typename boost::range_value<Collection>::type item;
+
+        collection.push_back(item(get<0>(lower_left), get<1>(lower_left), 0, 1));
+        collection.push_back(item(get<0>(upper_left), get<1>(upper_left), 1, 0));
+        collection.push_back(item(get<0>(upper_right), get<1>(upper_right), 0, -1));
+        collection.push_back(item(get<0>(lower_right), get<1>(lower_right), -1, 0));
+    }
+};
+
+// NOTE: This is not fully correct because Box in spherical and geographic
+// cordinate systems cannot be seen as Polygon
+template <typename Box, typename Collection>
+struct box_collect_vectors<Box, Collection, spherical_equatorial_tag>
+{
+    static inline void apply(Collection& collection, Box const& box)
+    {
+        typename point_type<Box>::type lower_left, lower_right,
+                upper_left, upper_right;
+        geometry::detail::assign_box_corners(box, lower_left, lower_right,
+                upper_left, upper_right);
+
+        typedef typename boost::range_value<Collection>::type item;
+
+        collection.push_back(item(lower_left, upper_left));
+        collection.push_back(item(upper_left, upper_right));
+        collection.push_back(item(upper_right, lower_right));
+        collection.push_back(item(lower_right, lower_left));
+    }
+};
+
+template <typename Box, typename Collection>
+struct box_collect_vectors<Box, Collection, spherical_polar_tag>
+    : box_collect_vectors<Box, Collection, spherical_equatorial_tag>
+{};
+
+template <typename Box, typename Collection>
+struct box_collect_vectors<Box, Collection, geographic_tag>
+    : box_collect_vectors<Box, Collection, spherical_equatorial_tag>
+{};
+
+
+template <typename Polygon, typename Collection>
+struct polygon_collect_vectors
+{
+    static inline void apply(Collection& collection, Polygon const& polygon)
+    {
+        typedef typename geometry::ring_type<Polygon>::type ring_type;
+
+        typedef range_collect_vectors<ring_type, Collection> per_range;
+        per_range::apply(collection, exterior_ring(polygon));
+
+        typename interior_return_type<Polygon const>::type
+            rings = interior_rings(polygon);
+        for (typename detail::interior_iterator<Polygon const>::type
+                it = boost::begin(rings); it != boost::end(rings); ++it)
+        {
+            per_range::apply(collection, *it);
+        }
+    }
+};
+
+
+template <typename MultiGeometry, typename Collection, typename SinglePolicy>
+struct multi_collect_vectors
+{
+    static inline void apply(Collection& collection, MultiGeometry const& multi)
+    {
+        for (typename boost::range_iterator<MultiGeometry const>::type
+                it = boost::begin(multi);
+            it != boost::end(multi);
+            ++it)
+        {
+            SinglePolicy::apply(collection, *it);
+        }
+    }
+};
+
+
+}} // namespace detail::collect_vectors
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template
+<
+    typename Tag,
+    typename Collection,
+    typename Geometry
+>
+struct collect_vectors
+{
+    static inline void apply(Collection&, Geometry const&)
+    {}
+};
+
+
+template <typename Collection, typename Box>
+struct collect_vectors<box_tag, Collection, Box>
+    : detail::collect_vectors::box_collect_vectors<Box, Collection>
+{};
+
+
+
+template <typename Collection, typename Ring>
+struct collect_vectors<ring_tag, Collection, Ring>
+    : detail::collect_vectors::range_collect_vectors<Ring, Collection>
+{};
+
+
+template <typename Collection, typename LineString>
+struct collect_vectors<linestring_tag, Collection, LineString>
+    : detail::collect_vectors::range_collect_vectors<LineString, Collection>
+{};
+
+
+template <typename Collection, typename Polygon>
+struct collect_vectors<polygon_tag, Collection, Polygon>
+    : detail::collect_vectors::polygon_collect_vectors<Polygon, Collection>
+{};
+
+
+template <typename Collection, typename MultiPolygon>
+struct collect_vectors<multi_polygon_tag, Collection, MultiPolygon>
+    : detail::collect_vectors::multi_collect_vectors
+        <
+            MultiPolygon,
+            Collection,
+            detail::collect_vectors::polygon_collect_vectors
+            <
+                typename boost::range_value<MultiPolygon>::type,
+                Collection
+            >
+        >
+{};
+
+
+
+} // namespace dispatch
+#endif
+
+
+/*!
+    \ingroup collect_vectors
+    \tparam Collection Collection type, should be e.g. std::vector<>
+    \tparam Geometry geometry type
+    \param collection the collection of vectors
+    \param geometry the geometry to make collect_vectors
+*/
+template <typename Collection, typename Geometry>
+inline void collect_vectors(Collection& collection, Geometry const& geometry)
+{
+    concepts::check<Geometry const>();
+
+    dispatch::collect_vectors
+        <
+            typename tag<Geometry>::type,
+            Collection,
+            Geometry
+        >::apply(collection, geometry);
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_EQUALS_COLLECT_VECTORS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/equals/implementation.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/equals/implementation.hpp
new file mode 100644
index 00000000000..310059a4271
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/equals/implementation.hpp
@@ -0,0 +1,397 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014, 2015, 2016, 2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_EQUALS_IMPLEMENTATION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_EQUALS_IMPLEMENTATION_HPP
+
+
+#include <cstddef>
+#include <vector>
+
+#include <boost/range.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+
+// For trivial checks
+#include <boost/geometry/algorithms/area.hpp>
+#include <boost/geometry/algorithms/length.hpp>
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/select_coordinate_type.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+
+#include <boost/geometry/algorithms/detail/equals/collect_vectors.hpp>
+#include <boost/geometry/algorithms/detail/equals/interface.hpp>
+#include <boost/geometry/algorithms/detail/relate/relate_impl.hpp>
+#include <boost/geometry/algorithms/relate.hpp>
+
+#include <boost/geometry/views/detail/indexed_point_view.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace equals
+{
+
+
+template
+<
+    std::size_t Dimension,
+    std::size_t DimensionCount
+>
+struct point_point
+{
+    template <typename Point1, typename Point2, typename Strategy>
+    static inline bool apply(Point1 const& point1, Point2 const& point2, Strategy const& strategy)
+    {
+        return ! detail::disjoint::point_point
+            <
+                Point1, Point2,
+                Dimension, DimensionCount
+            >::apply(point1, point2, strategy);
+    }
+};
+
+
+template
+<
+    std::size_t Dimension,
+    std::size_t DimensionCount
+>
+struct box_box
+{
+    template <typename Box1, typename Box2, typename Strategy>
+    static inline bool apply(Box1 const& box1, Box2 const& box2, Strategy const& strategy)
+    {
+        if (!geometry::math::equals(get<min_corner, Dimension>(box1), get<min_corner, Dimension>(box2))
+            || !geometry::math::equals(get<max_corner, Dimension>(box1), get<max_corner, Dimension>(box2)))
+        {
+            return false;
+        }
+        return box_box<Dimension + 1, DimensionCount>::apply(box1, box2, strategy);
+    }
+};
+
+template <std::size_t DimensionCount>
+struct box_box<DimensionCount, DimensionCount>
+{
+    template <typename Box1, typename Box2, typename Strategy>
+    static inline bool apply(Box1 const& , Box2 const& , Strategy const& )
+    {
+        return true;
+    }
+};
+
+
+struct segment_segment
+{
+    template <typename Segment1, typename Segment2, typename Strategy>
+    static inline bool apply(Segment1 const& segment1, Segment2 const& segment2, Strategy const& )
+    {
+        return equals::equals_point_point(
+                    indexed_point_view<Segment1 const, 0>(segment1),
+                    indexed_point_view<Segment2 const, 0>(segment2) )
+                ? equals::equals_point_point(
+                    indexed_point_view<Segment1 const, 1>(segment1),
+                    indexed_point_view<Segment2 const, 1>(segment2) )
+                : ( equals::equals_point_point(
+                        indexed_point_view<Segment1 const, 0>(segment1),
+                        indexed_point_view<Segment2 const, 1>(segment2) )
+                 && equals::equals_point_point(
+                        indexed_point_view<Segment1 const, 1>(segment1),
+                        indexed_point_view<Segment2 const, 0>(segment2) )
+                  );
+    }
+};
+
+
+struct area_check
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        return geometry::math::equals(
+            geometry::area(geometry1,
+                           strategy.template get_area_strategy<Geometry1>()),
+            geometry::area(geometry2,
+                           strategy.template get_area_strategy<Geometry2>()));
+    }
+};
+
+
+struct length_check
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        return geometry::math::equals(
+            geometry::length(geometry1,
+                             strategy.template get_distance_strategy<Geometry1>()),
+            geometry::length(geometry2,
+                             strategy.template get_distance_strategy<Geometry2>()));
+    }
+};
+
+
+template <typename Geometry1, typename Geometry2, typename IntersectionStrategy>
+struct collected_vector
+{
+    typedef typename geometry::select_most_precise
+        <
+            typename select_coordinate_type
+                <
+                    Geometry1, Geometry2
+                >::type,
+            double
+        >::type calculation_type;
+
+    typedef geometry::collected_vector
+        <
+            calculation_type,
+            Geometry1,
+            typename IntersectionStrategy::side_strategy_type
+        > type;
+};
+
+template <typename TrivialCheck>
+struct equals_by_collection
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        if (! TrivialCheck::apply(geometry1, geometry2, strategy))
+        {
+            return false;
+        }
+
+        typedef typename collected_vector
+            <
+                Geometry1, Geometry2, Strategy
+            >::type collected_vector_type;
+
+        std::vector<collected_vector_type> c1, c2;
+
+        geometry::collect_vectors(c1, geometry1);
+        geometry::collect_vectors(c2, geometry2);
+
+        if (boost::size(c1) != boost::size(c2))
+        {
+            return false;
+        }
+
+        std::sort(c1.begin(), c1.end());
+        std::sort(c2.begin(), c2.end());
+
+        // Just check if these vectors are equal.
+        return std::equal(c1.begin(), c1.end(), c2.begin());
+    }
+};
+
+template<typename Geometry1, typename Geometry2>
+struct equals_by_relate
+    : detail::relate::relate_impl
+        <
+            detail::de9im::static_mask_equals_type,
+            Geometry1,
+            Geometry2
+        >
+{};
+
+// If collect_vectors which is a SideStrategy-dispatched optimization
+// is implemented in a way consistent with the Intersection/Side Strategy
+// then collect_vectors is used, otherwise relate is used.
+// NOTE: the result could be conceptually different for invalid
+// geometries in different coordinate systems because collect_vectors
+// and relate treat invalid geometries differently.
+template<typename TrivialCheck>
+struct equals_by_collection_or_relate
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        typedef typename boost::is_base_of
+            <
+                nyi::not_implemented_tag,
+                typename collected_vector
+                    <
+                        Geometry1, Geometry2, Strategy
+                    >::type
+            >::type enable_relate_type;
+
+        return apply(geometry1, geometry2, strategy, enable_relate_type());
+    }
+
+private:
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy,
+                             boost::false_type /*enable_relate*/)
+    {
+        return equals_by_collection<TrivialCheck>::apply(geometry1, geometry2, strategy);
+    }
+
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy,
+                             boost::true_type /*enable_relate*/)
+    {
+        return equals_by_relate<Geometry1, Geometry2>::apply(geometry1, geometry2, strategy);
+    }
+};
+
+
+}} // namespace detail::equals
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename P1, typename P2, std::size_t DimensionCount, bool Reverse>
+struct equals<P1, P2, point_tag, point_tag, DimensionCount, Reverse>
+    : detail::equals::point_point<0, DimensionCount>
+{};
+
+template <typename MultiPoint1, typename MultiPoint2, std::size_t DimensionCount, bool Reverse>
+struct equals<MultiPoint1, MultiPoint2, multi_point_tag, multi_point_tag, DimensionCount, Reverse>
+    : detail::equals::equals_by_relate<MultiPoint1, MultiPoint2>
+{};
+
+template <typename MultiPoint, typename Point, std::size_t DimensionCount, bool Reverse>
+struct equals<Point, MultiPoint, point_tag, multi_point_tag, DimensionCount, Reverse>
+    : detail::equals::equals_by_relate<Point, MultiPoint>
+{};
+
+template <typename Box1, typename Box2, std::size_t DimensionCount, bool Reverse>
+struct equals<Box1, Box2, box_tag, box_tag, DimensionCount, Reverse>
+    : detail::equals::box_box<0, DimensionCount>
+{};
+
+
+template <typename Ring1, typename Ring2, bool Reverse>
+struct equals<Ring1, Ring2, ring_tag, ring_tag, 2, Reverse>
+    : detail::equals::equals_by_collection_or_relate<detail::equals::area_check>
+{};
+
+
+template <typename Polygon1, typename Polygon2, bool Reverse>
+struct equals<Polygon1, Polygon2, polygon_tag, polygon_tag, 2, Reverse>
+    : detail::equals::equals_by_collection_or_relate<detail::equals::area_check>
+{};
+
+
+template <typename Polygon, typename Ring, bool Reverse>
+struct equals<Polygon, Ring, polygon_tag, ring_tag, 2, Reverse>
+    : detail::equals::equals_by_collection_or_relate<detail::equals::area_check>
+{};
+
+
+template <typename Ring, typename Box, bool Reverse>
+struct equals<Ring, Box, ring_tag, box_tag, 2, Reverse>
+    : detail::equals::equals_by_collection<detail::equals::area_check>
+{};
+
+
+template <typename Polygon, typename Box, bool Reverse>
+struct equals<Polygon, Box, polygon_tag, box_tag, 2, Reverse>
+    : detail::equals::equals_by_collection<detail::equals::area_check>
+{};
+
+template <typename Segment1, typename Segment2, std::size_t DimensionCount, bool Reverse>
+struct equals<Segment1, Segment2, segment_tag, segment_tag, DimensionCount, Reverse>
+    : detail::equals::segment_segment
+{};
+
+template <typename LineString1, typename LineString2, bool Reverse>
+struct equals<LineString1, LineString2, linestring_tag, linestring_tag, 2, Reverse>
+    : detail::equals::equals_by_relate<LineString1, LineString2>
+{};
+
+template <typename LineString, typename MultiLineString, bool Reverse>
+struct equals<LineString, MultiLineString, linestring_tag, multi_linestring_tag, 2, Reverse>
+    : detail::equals::equals_by_relate<LineString, MultiLineString>
+{};
+
+template <typename MultiLineString1, typename MultiLineString2, bool Reverse>
+struct equals<MultiLineString1, MultiLineString2, multi_linestring_tag, multi_linestring_tag, 2, Reverse>
+    : detail::equals::equals_by_relate<MultiLineString1, MultiLineString2>
+{};
+
+
+template <typename MultiPolygon1, typename MultiPolygon2, bool Reverse>
+struct equals
+    <
+        MultiPolygon1, MultiPolygon2,
+        multi_polygon_tag, multi_polygon_tag,
+        2,
+        Reverse
+    >
+    : detail::equals::equals_by_collection_or_relate<detail::equals::area_check>
+{};
+
+
+template <typename Polygon, typename MultiPolygon, bool Reverse>
+struct equals
+    <
+        Polygon, MultiPolygon,
+        polygon_tag, multi_polygon_tag,
+        2,
+        Reverse
+    >
+    : detail::equals::equals_by_collection_or_relate<detail::equals::area_check>
+{};
+
+template <typename MultiPolygon, typename Ring, bool Reverse>
+struct equals
+    <
+        MultiPolygon, Ring,
+        multi_polygon_tag, ring_tag,
+        2,
+        Reverse
+    >
+    : detail::equals::equals_by_collection_or_relate<detail::equals::area_check>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_EQUALS_IMPLEMENTATION_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/equals/interface.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/equals/interface.hpp
new file mode 100644
index 00000000000..eacf95e9fe4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/equals/interface.hpp
@@ -0,0 +1,317 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014, 2015, 2016, 2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_EQUALS_INTERFACE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_EQUALS_INTERFACE_HPP
+
+
+#include <cstddef>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/reverse_dispatch.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/strategies/relate.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename Tag1 = typename tag<Geometry1>::type,
+    typename Tag2 = typename tag<Geometry2>::type,
+    std::size_t DimensionCount = dimension<Geometry1>::type::value,
+    bool Reverse = reverse_dispatch<Geometry1, Geometry2>::type::value
+>
+struct equals: not_implemented<Tag1, Tag2>
+{};
+
+
+// If reversal is needed, perform it
+template
+<
+    typename Geometry1, typename Geometry2,
+    typename Tag1, typename Tag2,
+    std::size_t DimensionCount
+>
+struct equals<Geometry1, Geometry2, Tag1, Tag2, DimensionCount, true>
+    : equals<Geometry2, Geometry1, Tag2, Tag1, DimensionCount, false>
+{
+    template <typename Strategy>
+    static inline bool apply(Geometry1 const& g1, Geometry2 const& g2, Strategy const& strategy)
+    {
+        return equals
+            <
+                Geometry2, Geometry1,
+                Tag2, Tag1,
+                DimensionCount,
+                false
+            >::apply(g2, g1, strategy);
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_strategy
+{
+
+struct equals
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        return dispatch::equals
+            <
+                Geometry1, Geometry2
+            >::apply(geometry1, geometry2, strategy);
+    }
+
+    template <typename Geometry1, typename Geometry2>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             default_strategy)
+    {
+        typedef typename strategy::relate::services::default_strategy
+            <
+                Geometry1,
+                Geometry2
+            >::type strategy_type;
+
+        return dispatch::equals
+            <
+                Geometry1, Geometry2
+            >::apply(geometry1, geometry2, strategy_type());
+    }
+};
+
+} // namespace resolve_strategy
+
+
+namespace resolve_variant {
+
+template <typename Geometry1, typename Geometry2>
+struct equals
+{
+    template <typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        concepts::check_concepts_and_equal_dimensions
+            <
+                Geometry1 const,
+                Geometry2 const
+            >();
+
+        return resolve_strategy::equals
+                ::apply(geometry1, geometry2, strategy);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
+struct equals<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
+{
+    template <typename Strategy>
+    struct visitor: static_visitor<bool>
+    {
+        Geometry2 const& m_geometry2;
+        Strategy const& m_strategy;
+
+        visitor(Geometry2 const& geometry2, Strategy const& strategy)
+            : m_geometry2(geometry2)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Geometry1>
+        inline bool operator()(Geometry1 const& geometry1) const
+        {
+            return equals<Geometry1, Geometry2>
+                   ::apply(geometry1, m_geometry2, m_strategy);
+        }
+
+    };
+
+    template <typename Strategy>
+    static inline bool apply(
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
+        Geometry2 const& geometry2,
+        Strategy const& strategy
+    )
+    {
+        return boost::apply_visitor(visitor<Strategy>(geometry2, strategy), geometry1);
+    }
+};
+
+template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct equals<Geometry1, boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Strategy>
+    struct visitor: static_visitor<bool>
+    {
+        Geometry1 const& m_geometry1;
+        Strategy const& m_strategy;
+
+        visitor(Geometry1 const& geometry1, Strategy const& strategy)
+            : m_geometry1(geometry1)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Geometry2>
+        inline bool operator()(Geometry2 const& geometry2) const
+        {
+            return equals<Geometry1, Geometry2>
+                   ::apply(m_geometry1, geometry2, m_strategy);
+        }
+
+    };
+
+    template <typename Strategy>
+    static inline bool apply(
+        Geometry1 const& geometry1,
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2,
+        Strategy const& strategy
+    )
+    {
+        return boost::apply_visitor(visitor<Strategy>(geometry1, strategy), geometry2);
+    }
+};
+
+template <
+    BOOST_VARIANT_ENUM_PARAMS(typename T1),
+    BOOST_VARIANT_ENUM_PARAMS(typename T2)
+>
+struct equals<
+    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)>,
+    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)>
+>
+{
+    template <typename Strategy>
+    struct visitor: static_visitor<bool>
+    {
+        Strategy const& m_strategy;
+
+        visitor(Strategy const& strategy)
+            : m_strategy(strategy)
+        {}
+
+        template <typename Geometry1, typename Geometry2>
+        inline bool operator()(Geometry1 const& geometry1,
+                               Geometry2 const& geometry2) const
+        {
+            return equals<Geometry1, Geometry2>
+                   ::apply(geometry1, geometry2, m_strategy);
+        }
+
+    };
+
+    template <typename Strategy>
+    static inline bool apply(
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)> const& geometry1,
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2,
+        Strategy const& strategy
+    )
+    {
+        return boost::apply_visitor(visitor<Strategy>(strategy), geometry1, geometry2);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief \brief_check{are spatially equal}
+\details \details_check12{equals, is spatially equal}. Spatially equal means
+    that the same point set is included. A box can therefore be spatially equal
+    to a ring or a polygon, or a linestring can be spatially equal to a
+    multi-linestring or a segment. This only works theoretically, not all
+    combinations are implemented yet.
+\ingroup equals
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Strategy \tparam_strategy{Equals}
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param strategy \param_strategy{equals}
+\return \return_check2{are spatially equal}
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/equals.qbk]}
+ */
+template <typename Geometry1, typename Geometry2, typename Strategy>
+inline bool equals(Geometry1 const& geometry1,
+                   Geometry2 const& geometry2,
+                   Strategy const& strategy)
+{
+    return resolve_variant::equals
+            <
+                Geometry1, Geometry2
+            >::apply(geometry1, geometry2, strategy);
+}
+
+
+/*!
+\brief \brief_check{are spatially equal}
+\details \details_check12{equals, is spatially equal}. Spatially equal means
+    that the same point set is included. A box can therefore be spatially equal
+    to a ring or a polygon, or a linestring can be spatially equal to a
+    multi-linestring or a segment. This only works theoretically, not all
+    combinations are implemented yet.
+\ingroup equals
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\return \return_check2{are spatially equal}
+
+\qbk{[include reference/algorithms/equals.qbk]}
+ */
+template <typename Geometry1, typename Geometry2>
+inline bool equals(Geometry1 const& geometry1, Geometry2 const& geometry2)
+{
+    return resolve_variant::equals<Geometry1, Geometry2>
+                          ::apply(geometry1, geometry2, default_strategy());
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_EQUALS_INTERFACE_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/equals/point_point.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/equals/point_point.hpp
new file mode 100644
index 00000000000..12daa85e9de
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/equals/point_point.hpp
@@ -0,0 +1,52 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland
+
+// This file was modified by Oracle on 2013-2014.
+// Modifications copyright (c) 2013-2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_EQUALS_POINT_POINT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_EQUALS_POINT_POINT_HPP
+
+#include <boost/geometry/algorithms/detail/disjoint/point_point.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace equals
+{
+
+/*!
+    \brief Internal utility function to detect of points are disjoint
+    \note To avoid circular references
+ */
+template <typename Point1, typename Point2>
+inline bool equals_point_point(Point1 const& point1, Point2 const& point2)
+{
+    return ! detail::disjoint::disjoint_point_point(point1, point2);
+}
+
+
+}} // namespace detail::equals
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_EQUALS_POINT_POINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/box.hpp
new file mode 100644
index 00000000000..3edb23f5ae2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/box.hpp
@@ -0,0 +1,129 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2015, 2016.
+// Modifications copyright (c) 2015-2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_BOX_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_BOX_HPP
+
+#include <cstddef>
+#include <algorithm>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/detail/envelope/box.hpp>
+#include <boost/geometry/algorithms/detail/envelope/range_of_boxes.hpp>
+
+#include <boost/geometry/algorithms/detail/expand/indexed.hpp>
+
+#include <boost/geometry/algorithms/dispatch/expand.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace expand
+{
+
+
+struct box_on_spheroid
+{
+    template <typename BoxOut, typename BoxIn, typename Strategy>
+    static inline void apply(BoxOut& box_out,
+                             BoxIn const& box_in,
+                             Strategy const& strategy)
+    {
+        // normalize both boxes and convert box-in to be of type of box-out
+        BoxOut mbrs[2];
+        detail::envelope::envelope_box_on_spheroid::apply(box_in, mbrs[0], strategy);
+        detail::envelope::envelope_box_on_spheroid::apply(box_out, mbrs[1], strategy);
+
+        // compute the envelope of the two boxes
+        detail::envelope::envelope_range_of_boxes::apply(mbrs, box_out, strategy);
+    }
+};
+
+
+}} // namespace detail::expand
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// Box + box -> new box containing two input boxes
+template
+<
+    typename BoxOut, typename BoxIn,
+    typename StrategyLess, typename StrategyGreater,
+    typename CSTagOut, typename CSTag
+>
+struct expand
+    <
+        BoxOut, BoxIn,
+        StrategyLess, StrategyGreater,
+        box_tag, box_tag,
+        CSTagOut, CSTag
+    > : detail::expand::expand_indexed
+        <
+            0, dimension<BoxIn>::value, StrategyLess, StrategyGreater
+        >
+{
+    BOOST_MPL_ASSERT_MSG((boost::is_same<CSTagOut, CSTag>::value),
+                         COORDINATE_SYSTEMS_MUST_BE_THE_SAME,
+                         (types<CSTagOut, CSTag>()));
+};
+
+template
+<
+    typename BoxOut, typename BoxIn,
+    typename StrategyLess, typename StrategyGreater
+>
+struct expand
+    <
+        BoxOut, BoxIn,
+        StrategyLess, StrategyGreater,
+        box_tag, box_tag,
+        spherical_equatorial_tag, spherical_equatorial_tag
+    > : detail::expand::box_on_spheroid
+{};
+
+template
+<
+    typename BoxOut, typename BoxIn,
+    typename StrategyLess, typename StrategyGreater
+>
+struct expand
+    <
+        BoxOut, BoxIn,
+        StrategyLess, StrategyGreater,
+        box_tag, box_tag,
+        geographic_tag, geographic_tag
+    > : detail::expand::box_on_spheroid
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_INDEXED_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/implementation.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/implementation.hpp
new file mode 100644
index 00000000000..95de1b50496
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/implementation.hpp
@@ -0,0 +1,27 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_IMPLEMENTATION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_IMPLEMENTATION_HPP
+
+#include <boost/geometry/algorithms/detail/expand/point.hpp>
+#include <boost/geometry/algorithms/detail/expand/segment.hpp>
+#include <boost/geometry/algorithms/detail/expand/box.hpp>
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_IMPLEMENTATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/indexed.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/indexed.hpp
new file mode 100644
index 00000000000..28cf0e2e4fe
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/indexed.hpp
@@ -0,0 +1,147 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2015, 2016.
+// Modifications copyright (c) 2015-2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_INDEXED_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_INDEXED_HPP
+
+#include <cstddef>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/select_coordinate_type.hpp>
+
+#include <boost/geometry/strategies/compare.hpp>
+#include <boost/geometry/policies/compare.hpp>
+
+#include <boost/geometry/algorithms/dispatch/expand.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace expand
+{
+
+
+template
+<
+    typename StrategyLess, typename StrategyGreater,
+    std::size_t Index,
+    std::size_t Dimension, std::size_t DimensionCount
+>
+struct indexed_loop
+{
+    template <typename Box, typename Geometry, typename Strategy>
+    static inline void apply(Box& box, Geometry const& source, Strategy const& strategy)
+    {
+        typedef typename strategy::compare::detail::select_strategy
+            <
+                StrategyLess, 1, Box, Dimension
+            >::type less_type;
+
+        typedef typename strategy::compare::detail::select_strategy
+            <
+                StrategyGreater, -1, Box, Dimension
+            >::type greater_type;
+
+        typedef typename select_coordinate_type
+                <
+                    Box,
+                    Geometry
+                >::type coordinate_type;
+
+        less_type less;
+        greater_type greater;
+
+        coordinate_type const coord = get<Index, Dimension>(source);
+
+        if (less(coord, get<min_corner, Dimension>(box)))
+        {
+            set<min_corner, Dimension>(box, coord);
+        }
+
+        if (greater(coord, get<max_corner, Dimension>(box)))
+        {
+            set<max_corner, Dimension>(box, coord);
+        }
+
+        indexed_loop
+            <
+                StrategyLess, StrategyGreater,
+                Index, Dimension + 1, DimensionCount
+            >::apply(box, source, strategy);
+    }
+};
+
+
+template
+<
+    typename StrategyLess, typename StrategyGreater,
+    std::size_t Index, std::size_t DimensionCount
+>
+struct indexed_loop
+    <
+        StrategyLess, StrategyGreater,
+        Index, DimensionCount, DimensionCount
+    >
+{
+    template <typename Box, typename Geometry, typename Strategy>
+    static inline void apply(Box&, Geometry const&, Strategy const&) {}
+};
+
+
+
+// Changes a box such that the other box is also contained by the box
+template
+<
+    std::size_t Dimension, std::size_t DimensionCount,
+    typename StrategyLess, typename StrategyGreater
+>
+struct expand_indexed
+{
+    template <typename Box, typename Geometry, typename Strategy>
+    static inline void apply(Box& box,
+                             Geometry const& geometry,
+                             Strategy const& strategy)
+    {
+        indexed_loop
+            <
+                StrategyLess, StrategyGreater,
+                0, Dimension, DimensionCount
+            >::apply(box, geometry, strategy);
+
+        indexed_loop
+            <
+                StrategyLess, StrategyGreater,
+                1, Dimension, DimensionCount
+            >::apply(box, geometry, strategy);
+    }
+};
+
+
+}} // namespace detail::expand
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_INDEXED_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/interface.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/interface.hpp
new file mode 100644
index 00000000000..5aacd8e72a1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/interface.hpp
@@ -0,0 +1,199 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2015, 2016.
+// Modifications copyright (c) 2015-2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_INTERFACE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_INTERFACE_HPP
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/algorithms/dispatch/expand.hpp>
+
+#include <boost/geometry/strategies/default_strategy.hpp>
+
+#include <boost/geometry/strategies/envelope.hpp>
+#include <boost/geometry/strategies/cartesian/envelope_segment.hpp>
+#include <boost/geometry/strategies/spherical/envelope_segment.hpp>
+#include <boost/geometry/strategies/geographic/envelope_segment.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace resolve_strategy
+{
+
+template <typename Geometry>
+struct expand
+{
+    template <typename Box, typename Strategy>
+    static inline void apply(Box& box,
+                             Geometry const& geometry,
+                             Strategy const& strategy)
+    {
+        dispatch::expand<Box, Geometry>::apply(box, geometry, strategy);
+    }
+
+    template <typename Box>
+    static inline void apply(Box& box,
+                             Geometry const& geometry,
+                             default_strategy)
+    {
+        typedef typename point_type<Geometry>::type point_type;
+        typedef typename coordinate_type<point_type>::type coordinate_type;
+
+        typedef typename strategy::envelope::services::default_strategy
+                <
+                typename cs_tag<point_type>::type,
+                coordinate_type
+                >::type strategy_type;
+
+        dispatch::expand<Box, Geometry>::apply(box, geometry, strategy_type());
+    }
+};
+
+} //namespace resolve_strategy
+
+
+namespace resolve_variant
+{
+    
+template <typename Geometry>
+struct expand
+{
+    template <typename Box, typename Strategy>
+    static inline void apply(Box& box,
+                             Geometry const& geometry,
+                             Strategy const& strategy)
+    {
+        concepts::check<Box>();
+        concepts::check<Geometry const>();
+        concepts::check_concepts_and_equal_dimensions<Box, Geometry const>();
+        
+        resolve_strategy::expand<Geometry>::apply(box, geometry, strategy);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct expand<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Box, typename Strategy>
+    struct visitor: boost::static_visitor<void>
+    {
+        Box& m_box;
+        Strategy const& m_strategy;
+        
+        visitor(Box& box, Strategy const& strategy)
+            : m_box(box)
+            , m_strategy(strategy)
+        {}
+        
+        template <typename Geometry>
+        void operator()(Geometry const& geometry) const
+        {
+            return expand<Geometry>::apply(m_box, geometry, m_strategy);
+        }
+    };
+    
+    template <class Box, typename Strategy>
+    static inline void
+    apply(Box& box,
+          boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Box, Strategy>(box, strategy),
+                                    geometry);
+    }
+};
+    
+} // namespace resolve_variant
+    
+    
+/***
+*!
+\brief Expands a box using the extend (envelope) of another geometry (box, point)
+\ingroup expand
+\tparam Box type of the box
+\tparam Geometry of second geometry, to be expanded with the box
+\param box box to expand another geometry with, might be changed
+\param geometry other geometry
+\param strategy_less
+\param strategy_greater
+\note Strategy is currently ignored
+ *
+template
+<
+    typename Box, typename Geometry,
+    typename StrategyLess, typename StrategyGreater
+>
+inline void expand(Box& box, Geometry const& geometry,
+            StrategyLess const& strategy_less,
+            StrategyGreater const& strategy_greater)
+{
+    concepts::check_concepts_and_equal_dimensions<Box, Geometry const>();
+
+    dispatch::expand<Box, Geometry>::apply(box, geometry);
+}
+***/
+
+/*!
+\brief Expands (with strategy)
+\ingroup expand
+\tparam Box type of the box
+\tparam Geometry \tparam_geometry
+\tparam Strategy \tparam_strategy{expand}
+\param box box to be expanded using another geometry, mutable
+\param geometry \param_geometry geometry which envelope (bounding box)
+\param strategy \param_strategy{expand}
+will be added to the box
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/expand.qbk]}
+ */
+template <typename Box, typename Geometry, typename Strategy>
+inline void expand(Box& box, Geometry const& geometry, Strategy const& strategy)
+{
+
+    resolve_variant::expand<Geometry>::apply(box, geometry, strategy);
+}
+
+/*!
+\brief Expands a box using the bounding box (envelope) of another geometry
+(box, point)
+\ingroup expand
+\tparam Box type of the box
+\tparam Geometry \tparam_geometry
+\param box box to be expanded using another geometry, mutable
+\param geometry \param_geometry geometry which envelope (bounding box) will be
+added to the box
+
+\qbk{[include reference/algorithms/expand.qbk]}
+ */
+template <typename Box, typename Geometry>
+inline void expand(Box& box, Geometry const& geometry)
+{
+    resolve_variant::expand<Geometry>::apply(box, geometry, default_strategy());
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_INTERFACE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/point.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/point.hpp
new file mode 100644
index 00000000000..f0cbd1db02f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/point.hpp
@@ -0,0 +1,308 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2015, 2016.
+// Modifications copyright (c) 2015-2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_POINT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_POINT_HPP
+
+#include <cstddef>
+#include <algorithm>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_system.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/select_coordinate_type.hpp>
+
+#include <boost/geometry/strategies/compare.hpp>
+#include <boost/geometry/policies/compare.hpp>
+
+#include <boost/geometry/algorithms/detail/normalize.hpp>
+#include <boost/geometry/algorithms/detail/envelope/transform_units.hpp>
+
+#include <boost/geometry/algorithms/dispatch/expand.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace expand
+{
+
+
+template
+<
+    typename StrategyLess, typename StrategyGreater,
+    std::size_t Dimension, std::size_t DimensionCount
+>
+struct point_loop
+{
+    template <typename Box, typename Point, typename Strategy>
+    static inline void apply(Box& box, Point const& source, Strategy const& strategy)
+    {
+        typedef typename strategy::compare::detail::select_strategy
+            <
+                StrategyLess, 1, Point, Dimension
+            >::type less_type;
+
+        typedef typename strategy::compare::detail::select_strategy
+            <
+                StrategyGreater, -1, Point, Dimension
+            >::type greater_type;
+
+        typedef typename select_coordinate_type
+            <
+                Point, Box
+            >::type coordinate_type;
+
+        less_type less;
+        greater_type greater;
+
+        coordinate_type const coord = get<Dimension>(source);
+
+        if (less(coord, get<min_corner, Dimension>(box)))
+        {
+            set<min_corner, Dimension>(box, coord);
+        }
+
+        if (greater(coord, get<max_corner, Dimension>(box)))
+        {
+            set<max_corner, Dimension>(box, coord);
+        }
+
+        point_loop
+            <
+                StrategyLess, StrategyGreater, Dimension + 1, DimensionCount
+            >::apply(box, source, strategy);
+    }
+};
+
+
+template
+<
+    typename StrategyLess,
+    typename StrategyGreater,
+    std::size_t DimensionCount
+>
+struct point_loop
+    <
+        StrategyLess, StrategyGreater, DimensionCount, DimensionCount
+    >
+{
+    template <typename Box, typename Point, typename Strategy>
+    static inline void apply(Box&, Point const&, Strategy const&) {}
+};
+
+
+// implementation for the spherical equatorial and geographic coordinate systems
+template
+<
+    typename StrategyLess,
+    typename StrategyGreater,
+    std::size_t DimensionCount
+>
+struct point_loop_on_spheroid
+{
+    template <typename Box, typename Point, typename Strategy>
+    static inline void apply(Box& box,
+                             Point const& point,
+                             Strategy const& strategy)
+    {
+        typedef typename point_type<Box>::type box_point_type;
+        typedef typename coordinate_type<Box>::type box_coordinate_type;
+
+        typedef math::detail::constants_on_spheroid
+            <
+                box_coordinate_type,
+                typename coordinate_system<Box>::type::units
+            > constants;
+
+        // normalize input point and input box
+        Point p_normalized = detail::return_normalized<Point>(point);
+        detail::normalize(box, box);
+
+        // transform input point to be of the same type as the box point
+        box_point_type box_point;
+        detail::envelope::transform_units(p_normalized, box_point);
+
+        box_coordinate_type p_lon = geometry::get<0>(box_point);
+        box_coordinate_type p_lat = geometry::get<1>(box_point);
+
+        typename coordinate_type<Box>::type
+            b_lon_min = geometry::get<min_corner, 0>(box),
+            b_lat_min = geometry::get<min_corner, 1>(box),
+            b_lon_max = geometry::get<max_corner, 0>(box),
+            b_lat_max = geometry::get<max_corner, 1>(box);
+
+        if (math::equals(math::abs(p_lat), constants::max_latitude()))
+        {
+            // the point of expansion is the either the north or the
+            // south pole; the only important coordinate here is the
+            // pole's latitude, as the longitude can be anything;
+            // we, thus, take into account the point's latitude only and return
+            geometry::set<min_corner, 1>(box, (std::min)(p_lat, b_lat_min));
+            geometry::set<max_corner, 1>(box, (std::max)(p_lat, b_lat_max));
+            return;
+        }
+
+        if (math::equals(b_lat_min, b_lat_max)
+            && math::equals(math::abs(b_lat_min), constants::max_latitude()))
+        {
+            // the box degenerates to either the north or the south pole;
+            // the only important coordinate here is the pole's latitude, 
+            // as the longitude can be anything;
+            // we thus take into account the box's latitude only and return
+            geometry::set<min_corner, 0>(box, p_lon);
+            geometry::set<min_corner, 1>(box, (std::min)(p_lat, b_lat_min));
+            geometry::set<max_corner, 0>(box, p_lon);
+            geometry::set<max_corner, 1>(box, (std::max)(p_lat, b_lat_max));
+            return;
+        }
+
+        // update latitudes
+        b_lat_min = (std::min)(b_lat_min, p_lat);
+        b_lat_max = (std::max)(b_lat_max, p_lat);
+
+        // update longitudes
+        if (math::smaller(p_lon, b_lon_min))
+        {
+            box_coordinate_type p_lon_shifted = p_lon + constants::period();
+
+            if (math::larger(p_lon_shifted, b_lon_max))
+            {
+                // here we could check using: ! math::larger(.., ..)
+                if (math::smaller(b_lon_min - p_lon, p_lon_shifted - b_lon_max))
+                {
+                    b_lon_min = p_lon;
+                }
+                else
+                {
+                    b_lon_max = p_lon_shifted;
+                }
+            }
+        }
+        else if (math::larger(p_lon, b_lon_max))
+        {
+            // in this case, and since p_lon is normalized in the range
+            // (-180, 180], we must have that b_lon_max <= 180
+            if (b_lon_min < 0
+                && math::larger(p_lon - b_lon_max,
+                                constants::period() - p_lon + b_lon_min))
+            {
+                b_lon_min = p_lon;
+                b_lon_max += constants::period();
+            }
+            else
+            {
+                b_lon_max = p_lon;
+            }
+        }
+
+        geometry::set<min_corner, 0>(box, b_lon_min);
+        geometry::set<min_corner, 1>(box, b_lat_min);
+        geometry::set<max_corner, 0>(box, b_lon_max);
+        geometry::set<max_corner, 1>(box, b_lat_max);
+
+        point_loop
+            <
+                StrategyLess, StrategyGreater, 2, DimensionCount
+            >::apply(box, point, strategy);
+    }
+};
+
+
+}} // namespace detail::expand
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// Box + point -> new box containing also point
+template
+<
+    typename BoxOut, typename Point,
+    typename StrategyLess, typename StrategyGreater,
+    typename CSTagOut, typename CSTag
+>
+struct expand
+    <
+        BoxOut, Point,
+        StrategyLess, StrategyGreater,
+        box_tag, point_tag,
+        CSTagOut, CSTag
+    > : detail::expand::point_loop
+        <
+            StrategyLess, StrategyGreater, 0, dimension<Point>::value
+        >
+{
+    BOOST_MPL_ASSERT_MSG((boost::is_same<CSTagOut, CSTag>::value),
+                         COORDINATE_SYSTEMS_MUST_BE_THE_SAME,
+                         (types<CSTagOut, CSTag>()));
+};
+
+template
+<
+    typename BoxOut, typename Point,
+    typename StrategyLess, typename StrategyGreater
+>
+struct expand
+    <
+        BoxOut, Point,
+        StrategyLess, StrategyGreater,
+        box_tag, point_tag,
+        spherical_equatorial_tag, spherical_equatorial_tag
+    > : detail::expand::point_loop_on_spheroid
+        <
+            StrategyLess, StrategyGreater, dimension<Point>::value
+        >
+{};
+
+template
+<
+    typename BoxOut, typename Point,
+    typename StrategyLess, typename StrategyGreater
+>
+struct expand
+    <
+        BoxOut, Point,
+        StrategyLess, StrategyGreater,
+        box_tag, point_tag,
+        geographic_tag, geographic_tag
+    > : detail::expand::point_loop_on_spheroid
+        <
+            StrategyLess, StrategyGreater, dimension<Point>::value
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_POINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/segment.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/segment.hpp
new file mode 100644
index 00000000000..0570e944d4a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand/segment.hpp
@@ -0,0 +1,133 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2015, 2016.
+// Modifications copyright (c) 2015-2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_SEGMENT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_SEGMENT_HPP
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/detail/envelope/box.hpp>
+#include <boost/geometry/algorithms/detail/envelope/range_of_boxes.hpp>
+#include <boost/geometry/algorithms/detail/envelope/segment.hpp>
+
+#include <boost/geometry/algorithms/detail/expand/indexed.hpp>
+
+#include <boost/geometry/algorithms/dispatch/expand.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace expand
+{
+
+struct segment
+{
+    template <typename Box, typename Segment, typename Strategy>
+    static inline void apply(Box& box,
+                             Segment const& segment,
+                             Strategy const& strategy)
+    {
+        Box mbrs[2];
+
+        // compute the envelope of the segment
+        typename point_type<Segment>::type p[2];
+        detail::assign_point_from_index<0>(segment, p[0]);
+        detail::assign_point_from_index<1>(segment, p[1]);
+        detail::envelope::envelope_segment
+            <
+                dimension<Segment>::value
+            >::apply(p[0], p[1], mbrs[0], strategy);
+
+        // normalize the box
+        detail::envelope::envelope_box_on_spheroid::apply(box, mbrs[1], strategy);
+
+        // compute the envelope of the two boxes
+        detail::envelope::envelope_range_of_boxes::apply(mbrs, box, strategy);
+    }
+};
+
+
+}} // namespace detail::expand
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Box, typename Segment,
+    typename StrategyLess, typename StrategyGreater,
+    typename CSTagOut, typename CSTag
+>
+struct expand
+    <
+        Box, Segment,
+        StrategyLess, StrategyGreater,
+        box_tag, segment_tag,
+        CSTagOut, CSTag
+    > : detail::expand::expand_indexed
+        <
+            0, dimension<Segment>::value, StrategyLess, StrategyGreater
+        >
+{
+    BOOST_MPL_ASSERT_MSG((boost::is_same<CSTagOut, CSTag>::value),
+                         COORDINATE_SYSTEMS_MUST_BE_THE_SAME,
+                         (types<CSTagOut, CSTag>()));
+};
+
+template
+<
+    typename Box, typename Segment,
+    typename StrategyLess, typename StrategyGreater
+>
+struct expand
+    <
+        Box, Segment,
+        StrategyLess, StrategyGreater,
+        box_tag, segment_tag,
+        spherical_equatorial_tag, spherical_equatorial_tag
+    > : detail::expand::segment
+{};
+
+template
+<
+    typename Box, typename Segment,
+    typename StrategyLess, typename StrategyGreater
+>
+struct expand
+    <
+        Box, Segment,
+        StrategyLess, StrategyGreater,
+        box_tag, segment_tag,
+        geographic_tag, geographic_tag
+    > : detail::expand::segment
+{};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_SEGMENT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand_by_epsilon.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand_by_epsilon.hpp
new file mode 100644
index 00000000000..7af08ee371a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/expand_by_epsilon.hpp
@@ -0,0 +1,113 @@
+// Boost.Geometry
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_EXPAND_BY_EPSILON_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_EXPAND_BY_EPSILON_HPP
+
+#include <cstddef>
+#include <algorithm>
+
+#include <boost/type_traits/is_floating_point.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/views/detail/indexed_point_view.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace expand
+{
+
+template
+<
+    typename Point,
+    template <typename> class PlusOrMinus,
+    std::size_t I = 0,
+    std::size_t D = dimension<Point>::value,
+    bool Enable = boost::is_floating_point
+                    <
+                        typename coordinate_type<Point>::type
+                    >::value
+>
+struct corner_by_epsilon
+{
+    static inline void apply(Point & point)
+    {
+        typedef typename coordinate_type<Point>::type coord_type;
+        coord_type const coord = get<I>(point);
+        coord_type const eps = math::scaled_epsilon(coord);
+        
+        set<I>(point, PlusOrMinus<coord_type>()(coord, eps));
+
+        corner_by_epsilon<Point, PlusOrMinus, I+1>::apply(point);
+    }
+};
+
+template
+<
+    typename Point,
+    template <typename> class PlusOrMinus,
+    std::size_t I,
+    std::size_t D
+>
+struct corner_by_epsilon<Point, PlusOrMinus, I, D, false>
+{
+    static inline void apply(Point const&) {}
+};
+
+template
+<
+    typename Point,
+    template <typename> class PlusOrMinus,
+    std::size_t D,
+    bool Enable
+>
+struct corner_by_epsilon<Point, PlusOrMinus, D, D, Enable>
+{
+    static inline void apply(Point const&) {}
+};
+
+template
+<
+    typename Point,
+    template <typename> class PlusOrMinus,
+    std::size_t D
+>
+struct corner_by_epsilon<Point, PlusOrMinus, D, D, false>
+{
+    static inline void apply(Point const&) {}
+};
+
+} // namespace expand
+
+template <typename Box>
+inline void expand_by_epsilon(Box & box)
+{
+    typedef detail::indexed_point_view<Box, min_corner> min_type;
+    min_type min_point(box);
+    expand::corner_by_epsilon<min_type, std::minus>::apply(min_point);
+
+    typedef detail::indexed_point_view<Box, max_corner> max_type;
+    max_type max_point(box);
+    expand::corner_by_epsilon<max_type, std::plus>::apply(max_point);
+}
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXPAND_EXPAND_BY_EPSILON_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/extreme_points.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/extreme_points.hpp
new file mode 100644
index 00000000000..61e984ee3c4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/extreme_points.hpp
@@ -0,0 +1,543 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2013 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2013 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2013 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXTREME_POINTS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXTREME_POINTS_HPP
+
+
+#include <cstddef>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/detail/interior_iterator.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/iterators/ever_circling_iterator.hpp>
+
+#include <boost/geometry/algorithms/detail/assign_box_corners.hpp>
+
+#include <boost/geometry/strategies/side.hpp>
+
+#include <boost/geometry/util/math.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace extreme_points
+{
+
+template <std::size_t Dimension>
+struct compare
+{
+    template <typename Point>
+    inline bool operator()(Point const& lhs, Point const& rhs)
+    {
+        return geometry::get<Dimension>(lhs) < geometry::get<Dimension>(rhs);
+    }
+};
+
+
+template <std::size_t Dimension, typename PointType, typename CoordinateType>
+inline void move_along_vector(PointType& point, PointType const& extreme, CoordinateType const& base_value)
+{
+    // Moves a point along the vector (point, extreme) in the direction of the extreme  point
+    // This adapts the possibly uneven legs of the triangle (or trapezium-like shape)
+    //      _____extreme            _____
+    //     /     \                 /     \                                    .
+    //    /base   \         =>    /       \ point                             .
+    //             \ point                                                    .
+    //
+    // For so-called intruders, it can be used to adapt both legs to the level of "base"
+    // For the base, it can be used to adapt both legs to the level of the max-value of the intruders
+    // If there are 2 or more extreme values, use the one close to 'point' to have a correct vector
+
+    CoordinateType const value = geometry::get<Dimension>(point);
+    //if (geometry::math::equals(value, base_value))
+    if (value >= base_value)
+    {
+        return;
+    }
+
+    PointType vector = point;
+    subtract_point(vector, extreme);
+
+    CoordinateType const diff = geometry::get<Dimension>(vector);
+
+    // diff should never be zero
+    // because of the way our triangle/trapezium is build.
+    // We just return if it would be the case.
+    if (geometry::math::equals(diff, 0))
+    {
+        return;
+    }
+
+    CoordinateType const base_diff = base_value - geometry::get<Dimension>(extreme);
+
+    multiply_value(vector, base_diff);
+    divide_value(vector, diff);
+
+    // The real move:
+    point = extreme;
+    add_point(point, vector);
+}
+
+
+template <std::size_t Dimension, typename Range, typename CoordinateType>
+inline void move_along_vector(Range& range, CoordinateType const& base_value)
+{
+    if (range.size() >= 3)
+    {
+        move_along_vector<Dimension>(range.front(), *(range.begin() + 1), base_value);
+        move_along_vector<Dimension>(range.back(), *(range.rbegin() + 1), base_value);
+    }
+}
+
+
+template<typename Ring, std::size_t Dimension>
+struct extreme_points_on_ring
+{
+
+    typedef typename geometry::coordinate_type<Ring>::type coordinate_type;
+    typedef typename boost::range_iterator<Ring const>::type range_iterator;
+    typedef typename geometry::point_type<Ring>::type point_type;
+
+    template <typename CirclingIterator, typename Points>
+    static inline bool extend(CirclingIterator& it,
+            std::size_t n,
+            coordinate_type max_coordinate_value,
+            Points& points, int direction)
+    {
+        std::size_t safe_index = 0;
+        do
+        {
+            it += direction;
+
+            points.push_back(*it);
+
+            if (safe_index++ >= n)
+            {
+                // E.g.: ring is completely horizontal or vertical (= invalid, but we don't want to have an infinite loop)
+                return false;
+            }
+        } while (geometry::math::equals(geometry::get<Dimension>(*it), max_coordinate_value));
+
+        return true;
+    }
+
+    // Overload without adding to poinst
+    template <typename CirclingIterator>
+    static inline bool extend(CirclingIterator& it,
+            std::size_t n,
+            coordinate_type max_coordinate_value,
+            int direction)
+    {
+        std::size_t safe_index = 0;
+        do
+        {
+            it += direction;
+
+            if (safe_index++ >= n)
+            {
+                // E.g.: ring is completely horizontal or vertical (= invalid, but we don't want to have an infinite loop)
+                return false;
+            }
+        } while (geometry::math::equals(geometry::get<Dimension>(*it), max_coordinate_value));
+
+        return true;
+    }
+
+    template <typename CirclingIterator>
+    static inline bool extent_both_sides(Ring const& ring,
+            point_type extreme,
+            CirclingIterator& left,
+            CirclingIterator& right)
+    {
+        std::size_t const n = boost::size(ring);
+        coordinate_type const max_coordinate_value = geometry::get<Dimension>(extreme);
+
+        if (! extend(left, n, max_coordinate_value, -1))
+        {
+            return false;
+        }
+        if (! extend(right, n, max_coordinate_value, +1))
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    template <typename Collection, typename CirclingIterator>
+    static inline bool collect(Ring const& ring,
+            point_type extreme,
+            Collection& points,
+            CirclingIterator& left,
+            CirclingIterator& right)
+    {
+        std::size_t const n = boost::size(ring);
+        coordinate_type const max_coordinate_value = geometry::get<Dimension>(extreme);
+
+        // Collects first left, which is reversed (if more than one point) then adds the top itself, then right
+        if (! extend(left, n, max_coordinate_value, points, -1))
+        {
+            return false;
+        }
+        std::reverse(points.begin(), points.end());
+        points.push_back(extreme);
+        if (! extend(right, n, max_coordinate_value, points, +1))
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    template <typename Extremes, typename Intruders, typename CirclingIterator, typename SideStrategy>
+    static inline void get_intruders(Ring const& ring, CirclingIterator left, CirclingIterator right,
+            Extremes const& extremes,
+            Intruders& intruders,
+            SideStrategy const& strategy)
+    {
+        if (boost::size(extremes) < 3)
+        {
+            return;
+        }
+        coordinate_type const min_value = geometry::get<Dimension>(*std::min_element(boost::begin(extremes), boost::end(extremes), compare<Dimension>()));
+
+        // Also select left/right (if Dimension=1)
+        coordinate_type const other_min = geometry::get<1 - Dimension>(*std::min_element(boost::begin(extremes), boost::end(extremes), compare<1 - Dimension>()));
+        coordinate_type const other_max = geometry::get<1 - Dimension>(*std::max_element(boost::begin(extremes), boost::end(extremes), compare<1 - Dimension>()));
+
+        std::size_t defensive_check_index = 0; // in case we skip over left/right check, collect modifies right too
+        std::size_t const n = boost::size(ring);
+        while (left != right && defensive_check_index < n)
+        {
+            coordinate_type const coordinate = geometry::get<Dimension>(*right);
+            coordinate_type const other_coordinate = geometry::get<1 - Dimension>(*right);
+            if (coordinate > min_value && other_coordinate > other_min && other_coordinate < other_max)
+            {
+                int const factor = geometry::point_order<Ring>::value == geometry::clockwise ? 1 : -1;
+                int const first_side = strategy.apply(*right, extremes.front(), *(extremes.begin() + 1)) * factor;
+                int const last_side = strategy.apply(*right, *(extremes.rbegin() + 1), extremes.back()) * factor;
+
+                // If not lying left from any of the extemes side
+                if (first_side != 1 && last_side != 1)
+                {
+                    //std::cout << "first " << first_side << " last " << last_side << std::endl;
+
+                    // we start at this intrusion until it is handled, and don't affect our initial left iterator
+                    CirclingIterator left_intrusion_it = right;
+                    typename boost::range_value<Intruders>::type intruder;
+                    collect(ring, *right, intruder, left_intrusion_it, right);
+
+                    // Also moves these to base-level, makes sorting possible which can be done in case of self-tangencies
+                    // (we might postpone this action, it is often not necessary. However it is not time-consuming)
+                    move_along_vector<Dimension>(intruder, min_value);
+                    intruders.push_back(intruder);
+                    --right;
+                }
+            }
+            ++right;
+            defensive_check_index++;
+        }
+    }
+
+    template <typename Extremes, typename Intruders, typename SideStrategy>
+    static inline void get_intruders(Ring const& ring,
+            Extremes const& extremes,
+            Intruders& intruders,
+            SideStrategy const& strategy)
+    {
+        std::size_t const n = boost::size(ring);
+        if (n >= 3)
+        {
+            geometry::ever_circling_range_iterator<Ring const> left(ring);
+            geometry::ever_circling_range_iterator<Ring const> right(ring);
+            ++right;
+
+            get_intruders(ring, left, right, extremes, intruders, strategy);
+        }
+    }
+
+    template <typename Iterator, typename SideStrategy>
+    static inline bool right_turn(Ring const& ring, Iterator it, SideStrategy const& strategy)
+    {
+        typename std::iterator_traits<Iterator>::difference_type const index
+            = std::distance(boost::begin(ring), it);
+        geometry::ever_circling_range_iterator<Ring const> left(ring);
+        geometry::ever_circling_range_iterator<Ring const> right(ring);
+        left += index;
+        right += index;
+
+        if (! extent_both_sides(ring, *it, left, right))
+        {
+            return false;
+        }
+
+        int const factor = geometry::point_order<Ring>::value == geometry::clockwise ? 1 : -1;
+        int const first_side = strategy.apply(*(right - 1), *right, *left) * factor;
+        int const last_side = strategy.apply(*left, *(left + 1), *right) * factor;
+
+//std::cout << "Candidate at " << geometry::wkt(*it) << " first=" << first_side << " last=" << last_side << std::endl;
+
+        // Turn should not be left (actually, it should be right because extent removes horizontal/collinear cases)
+        return first_side != 1 && last_side != 1;
+    }
+
+
+    // Gets the extreme segments (top point plus neighbouring points), plus intruders, if any, on the same ring
+    template <typename Extremes, typename Intruders, typename SideStrategy>
+    static inline bool apply(Ring const& ring,
+                             Extremes& extremes,
+                             Intruders& intruders,
+                             SideStrategy const& strategy)
+    {
+        std::size_t const n = boost::size(ring);
+        if (n < 3)
+        {
+            return false;
+        }
+
+        // Get all maxima, usually one. In case of self-tangencies, or self-crossings,
+        // the max might be is not valid. A valid max should make a right turn
+        range_iterator max_it = boost::begin(ring);
+        compare<Dimension> smaller;
+        for (range_iterator it = max_it + 1; it != boost::end(ring); ++it)
+        {
+            if (smaller(*max_it, *it) && right_turn(ring, it, strategy))
+            {
+                max_it = it;
+            }
+        }
+
+        if (max_it == boost::end(ring))
+        {
+            return false;
+        }
+
+        typename std::iterator_traits<range_iterator>::difference_type const
+            index = std::distance(boost::begin(ring), max_it);
+//std::cout << "Extreme point lies at " << index << " having " << geometry::wkt(*max_it) << std::endl;
+
+        geometry::ever_circling_range_iterator<Ring const> left(ring);
+        geometry::ever_circling_range_iterator<Ring const> right(ring);
+        left += index;
+        right += index;
+
+        // Collect all points (often 3) in a temporary vector
+        std::vector<point_type> points;
+        points.reserve(3);
+        if (! collect(ring, *max_it, points, left, right))
+        {
+            return false;
+        }
+
+//std::cout << "Built vector of " << points.size() << std::endl;
+
+        coordinate_type const front_value = geometry::get<Dimension>(points.front());
+        coordinate_type const back_value = geometry::get<Dimension>(points.back());
+        coordinate_type const base_value = (std::max)(front_value, back_value);
+        if (front_value < back_value)
+        {
+            move_along_vector<Dimension>(points.front(), *(points.begin() + 1), base_value);
+        }
+        else
+        {
+            move_along_vector<Dimension>(points.back(), *(points.rbegin() + 1), base_value);
+        }
+
+        std::copy(points.begin(), points.end(), std::back_inserter(extremes));
+
+        get_intruders(ring, left, right, extremes, intruders, strategy);
+
+        return true;
+    }
+};
+
+
+
+
+
+}} // namespace detail::extreme_points
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template
+<
+    typename Geometry,
+    std::size_t Dimension,
+    typename GeometryTag = typename tag<Geometry>::type
+>
+struct extreme_points
+{};
+
+
+template<typename Ring, std::size_t Dimension>
+struct extreme_points<Ring, Dimension, ring_tag>
+    : detail::extreme_points::extreme_points_on_ring<Ring, Dimension>
+{};
+
+
+template<typename Polygon, std::size_t Dimension>
+struct extreme_points<Polygon, Dimension, polygon_tag>
+{
+    template <typename Extremes, typename Intruders, typename SideStrategy>
+    static inline bool apply(Polygon const& polygon, Extremes& extremes, Intruders& intruders,
+                             SideStrategy const& strategy)
+    {
+        typedef typename geometry::ring_type<Polygon>::type ring_type;
+        typedef detail::extreme_points::extreme_points_on_ring
+            <
+                ring_type, Dimension
+            > ring_implementation;
+
+        if (! ring_implementation::apply(geometry::exterior_ring(polygon),
+                                         extremes, intruders, strategy))
+        {
+            return false;
+        }
+
+        // For a polygon, its interior rings can contain intruders
+        typename interior_return_type<Polygon const>::type
+            rings = interior_rings(polygon);
+        for (typename detail::interior_iterator<Polygon const>::type
+                it = boost::begin(rings); it != boost::end(rings); ++it)
+        {
+            ring_implementation::get_intruders(*it, extremes,  intruders, strategy);
+        }
+
+        return true;
+    }
+};
+
+template<typename Box>
+struct extreme_points<Box, 1, box_tag>
+{
+    template <typename Extremes, typename Intruders, typename SideStrategy>
+    static inline bool apply(Box const& box, Extremes& extremes, Intruders& ,
+                             SideStrategy const& )
+    {
+        extremes.resize(4);
+        geometry::detail::assign_box_corners_oriented<false>(box, extremes);
+        // ll,ul,ur,lr, contains too exactly the right info
+        return true;
+    }
+};
+
+template<typename Box>
+struct extreme_points<Box, 0, box_tag>
+{
+    template <typename Extremes, typename Intruders, typename SideStrategy>
+    static inline bool apply(Box const& box, Extremes& extremes, Intruders& ,
+                             SideStrategy const& )
+    {
+        extremes.resize(4);
+        geometry::detail::assign_box_corners_oriented<false>(box, extremes);
+        // ll,ul,ur,lr, rotate one to start with UL and end with LL
+        std::rotate(extremes.begin(), extremes.begin() + 1, extremes.end());
+        return true;
+    }
+};
+
+template<typename MultiPolygon, std::size_t Dimension>
+struct extreme_points<MultiPolygon, Dimension, multi_polygon_tag>
+{
+    template <typename Extremes, typename Intruders, typename SideStrategy>
+    static inline bool apply(MultiPolygon const& multi, Extremes& extremes,
+                             Intruders& intruders, SideStrategy const& strategy)
+    {
+        // Get one for the very first polygon, that is (for the moment) enough.
+        // It is not guaranteed the "extreme" then, but for the current purpose
+        // (point_on_surface) it can just be this point.
+        if (boost::size(multi) >= 1)
+        {
+            return extreme_points
+                <
+                    typename boost::range_value<MultiPolygon const>::type,
+                    Dimension,
+                    polygon_tag
+                >::apply(*boost::begin(multi), extremes, intruders, strategy);
+        }
+
+        return false;
+    }
+};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+/*!
+\brief Returns extreme points (for Edge=1 in dimension 1, so the top,
+       for Edge=0 in dimension 0, the right side)
+\note We could specify a strategy (less/greater) to get bottom/left side too. However, until now we don't need that.
+ */
+template
+<
+    std::size_t Edge,
+    typename Geometry,
+    typename Extremes,
+    typename Intruders,
+    typename SideStrategy
+>
+inline bool extreme_points(Geometry const& geometry,
+                           Extremes& extremes,
+                           Intruders& intruders,
+                           SideStrategy const& strategy)
+{
+    concepts::check<Geometry const>();
+
+    // Extremes is not required to follow a geometry concept (but it should support an output iterator),
+    // but its elements should fulfil the point-concept
+    concepts::check<typename boost::range_value<Extremes>::type>();
+
+    // Intruders should contain collections which value type is point-concept
+    // Extremes might be anything (supporting an output iterator), but its elements should fulfil the point-concept
+    concepts::check
+        <
+            typename boost::range_value
+                <
+                    typename boost::range_value<Intruders>::type
+                >::type
+            const
+        >();
+
+    return dispatch::extreme_points
+            <
+                Geometry,
+                Edge
+            >::apply(geometry, extremes, intruders, strategy);
+}
+
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_EXTREME_POINTS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/for_each_range.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/for_each_range.hpp
new file mode 100644
index 00000000000..e8c92160f11
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/for_each_range.hpp
@@ -0,0 +1,201 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_FOR_EACH_RANGE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_FOR_EACH_RANGE_HPP
+
+
+#include <boost/mpl/assert.hpp>
+#include <boost/concept/requires.hpp>
+#include <boost/range.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/add_const_if_c.hpp>
+#include <boost/geometry/views/box_view.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace for_each
+{
+
+
+template <typename Range, typename Actor>
+struct fe_range_range
+{
+    static inline void apply(Range & range, Actor & actor)
+    {
+        actor.apply(range);
+    }
+};
+
+
+template <typename Polygon, typename Actor>
+struct fe_range_polygon
+{
+    static inline void apply(Polygon & polygon, Actor & actor)
+    {
+        actor.apply(exterior_ring(polygon));
+
+        // TODO: If some flag says true, also do the inner rings.
+        // for convex hull, it's not necessary
+    }
+};
+
+template <typename Box, typename Actor>
+struct fe_range_box
+{
+    static inline void apply(Box & box, Actor & actor)
+    {
+        actor.apply(box_view<typename boost::remove_const<Box>::type>(box));
+    }
+};
+
+template <typename Multi, typename Actor, typename SinglePolicy>
+struct fe_range_multi
+{
+    static inline void apply(Multi & multi, Actor & actor)
+    {
+        for ( typename boost::range_iterator<Multi>::type
+                it = boost::begin(multi); it != boost::end(multi); ++it)
+        {
+            SinglePolicy::apply(*it, actor);
+        }
+    }
+};
+
+}} // namespace detail::for_each
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template
+<
+    typename Geometry,
+    typename Actor,
+    typename Tag = typename tag<Geometry>::type
+>
+struct for_each_range
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_OR_NOT_YET_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
+            , (types<Geometry>)
+        );
+};
+
+
+template <typename Linestring, typename Actor>
+struct for_each_range<Linestring, Actor, linestring_tag>
+    : detail::for_each::fe_range_range<Linestring, Actor>
+{};
+
+
+template <typename Ring, typename Actor>
+struct for_each_range<Ring, Actor, ring_tag>
+    : detail::for_each::fe_range_range<Ring, Actor>
+{};
+
+
+template <typename Polygon, typename Actor>
+struct for_each_range<Polygon, Actor, polygon_tag>
+    : detail::for_each::fe_range_polygon<Polygon, Actor>
+{};
+
+
+template <typename Box, typename Actor>
+struct for_each_range<Box, Actor, box_tag>
+    : detail::for_each::fe_range_box<Box, Actor>
+{};
+
+
+template <typename MultiPoint, typename Actor>
+struct for_each_range<MultiPoint, Actor, multi_point_tag>
+    : detail::for_each::fe_range_range<MultiPoint, Actor>
+{};
+
+
+template <typename Geometry, typename Actor>
+struct for_each_range<Geometry, Actor, multi_linestring_tag>
+    : detail::for_each::fe_range_multi
+        <
+            Geometry,
+            Actor,
+            detail::for_each::fe_range_range
+                <
+                    typename add_const_if_c
+                        <
+                            boost::is_const<Geometry>::value,
+                            typename boost::range_value<Geometry>::type
+                        >::type,
+                    Actor
+                >
+        >
+{};
+
+
+template <typename Geometry, typename Actor>
+struct for_each_range<Geometry, Actor, multi_polygon_tag>
+    : detail::for_each::fe_range_multi
+        <
+            Geometry,
+            Actor,
+            detail::for_each::fe_range_polygon
+                <
+                    typename add_const_if_c
+                        <
+                            boost::is_const<Geometry>::value,
+                            typename boost::range_value<Geometry>::type
+                        >::type,
+                    Actor
+                >
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+namespace detail
+{
+
+template <typename Geometry, typename Actor>
+inline void for_each_range(Geometry const& geometry, Actor & actor)
+{
+    dispatch::for_each_range
+        <
+            Geometry const,
+            Actor
+        >::apply(geometry, actor);
+}
+
+
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_FOR_EACH_RANGE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/get_left_turns.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/get_left_turns.hpp
new file mode 100644
index 00000000000..e9f6a508596
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/get_left_turns.hpp
@@ -0,0 +1,318 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012-2014 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_GET_LEFT_TURNS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_GET_LEFT_TURNS_HPP
+
+#include <boost/geometry/core/assert.hpp>
+
+#include <boost/geometry/arithmetic/arithmetic.hpp>
+#include <boost/geometry/algorithms/detail/overlay/segment_identifier.hpp>
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+#include <boost/geometry/iterators/closing_iterator.hpp>
+#include <boost/geometry/iterators/ever_circling_iterator.hpp>
+#include <boost/geometry/strategies/side.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+// TODO: move this to /util/
+template <typename T>
+inline std::pair<T, T> ordered_pair(T const& first, T const& second)
+{
+    return first < second ? std::make_pair(first, second) : std::make_pair(second, first);
+}
+
+namespace left_turns
+{
+
+
+
+template <typename Vector>
+inline int get_quadrant(Vector const& vector)
+{
+    // Return quadrant as layouted in the code below:
+    // 3 | 0
+    // -----
+    // 2 | 1
+    return geometry::get<1>(vector) >= 0
+        ? (geometry::get<0>(vector)  < 0 ? 3 : 0)
+        : (geometry::get<0>(vector)  < 0 ? 2 : 1)
+        ;
+}
+
+template <typename Vector>
+inline int squared_length(Vector const& vector)
+{
+    return geometry::get<0>(vector) * geometry::get<0>(vector)
+         + geometry::get<1>(vector) * geometry::get<1>(vector)
+         ;
+}
+
+
+template <typename Point, typename SideStrategy>
+struct angle_less
+{
+    typedef Point vector_type;
+
+    angle_less(Point const& origin, SideStrategy const& strategy)
+        : m_origin(origin)
+        , m_strategy(strategy)
+    {}
+
+    template <typename Angle>
+    inline bool operator()(Angle const& p, Angle const& q) const
+    {
+        // Vector origin -> p and origin -> q
+        vector_type pv = p.point;
+        vector_type qv = q.point;
+        geometry::subtract_point(pv, m_origin);
+        geometry::subtract_point(qv, m_origin);
+
+        int const quadrant_p = get_quadrant(pv);
+        int const quadrant_q = get_quadrant(qv);
+        if (quadrant_p != quadrant_q)
+        {
+            return quadrant_p < quadrant_q;
+        }
+        // Same quadrant, check if p is located left of q
+        int const side = m_strategy.apply(m_origin, q.point, p.point);
+        if (side != 0)
+        {
+            return side == 1;
+        }
+        // Collinear, check if one is incoming, incoming angles come first
+        if (p.incoming != q.incoming)
+        {
+            return int(p.incoming) < int(q.incoming);
+        }
+        // Same quadrant/side/direction, return longest first
+        // TODO: maybe not necessary, decide this
+        int const length_p = squared_length(pv);
+        int const length_q = squared_length(qv);
+        if (length_p != length_q)
+        {
+            return squared_length(pv) > squared_length(qv);
+        }
+        // They are still the same. Just compare on seg_id
+        return p.seg_id < q.seg_id;
+    }
+
+private:
+    Point m_origin;
+    SideStrategy m_strategy;
+};
+
+template <typename Point, typename SideStrategy>
+struct angle_equal_to
+{
+    typedef Point vector_type;
+    
+    inline angle_equal_to(Point const& origin, SideStrategy const& strategy)
+        : m_origin(origin)
+        , m_strategy(strategy)
+    {}
+
+    template <typename Angle>
+    inline bool operator()(Angle const& p, Angle const& q) const
+    {
+        // Vector origin -> p and origin -> q
+        vector_type pv = p.point;
+        vector_type qv = q.point;
+        geometry::subtract_point(pv, m_origin);
+        geometry::subtract_point(qv, m_origin);
+
+        if (get_quadrant(pv) != get_quadrant(qv))
+        {
+            return false;
+        }
+        // Same quadrant, check if p/q are collinear
+        int const side = m_strategy.apply(m_origin, q.point, p.point);
+        return side == 0;
+    }
+
+private:
+    Point m_origin;
+    SideStrategy m_strategy;
+};
+
+template <typename AngleCollection, typename Turns>
+inline void get_left_turns(AngleCollection const& sorted_angles,
+        Turns& turns)
+{
+    std::set<std::size_t> good_incoming;
+    std::set<std::size_t> good_outgoing;
+
+    for (typename boost::range_iterator<AngleCollection const>::type it =
+        sorted_angles.begin(); it != sorted_angles.end(); ++it)
+    {
+        if (!it->blocked)
+        {
+            if (it->incoming)
+            {
+                good_incoming.insert(it->turn_index);
+            }
+            else
+            {
+                good_outgoing.insert(it->turn_index);
+            }
+        }
+    }
+
+    if (good_incoming.empty() || good_outgoing.empty())
+    {
+        return;
+    }
+
+    for (typename boost::range_iterator<AngleCollection const>::type it =
+        sorted_angles.begin(); it != sorted_angles.end(); ++it)
+    {
+        if (good_incoming.count(it->turn_index) == 0
+            || good_outgoing.count(it->turn_index) == 0)
+        {
+            turns[it->turn_index].remove_on_multi = true;
+        }
+    }
+}
+
+
+//! Returns the number of clusters
+template <typename Point, typename AngleCollection, typename SideStrategy>
+inline std::size_t assign_cluster_indices(AngleCollection& sorted, Point const& origin,
+                                          SideStrategy const& strategy)
+{
+    // Assign same cluster_index for all turns in same direction
+    BOOST_GEOMETRY_ASSERT(boost::size(sorted) >= 4u);
+
+    angle_equal_to<Point, SideStrategy> comparator(origin, strategy);
+    typename boost::range_iterator<AngleCollection>::type it = sorted.begin();
+
+    std::size_t cluster_index = 0;
+    it->cluster_index = cluster_index;
+    typename boost::range_iterator<AngleCollection>::type previous = it++;
+    for (; it != sorted.end(); ++it)
+    {
+        if (!comparator(*previous, *it))
+        {
+            cluster_index++;
+            previous = it;
+        }
+        it->cluster_index = cluster_index;
+    }
+    return cluster_index + 1;
+}
+
+template <typename AngleCollection>
+inline void block_turns(AngleCollection& sorted, std::size_t cluster_size)
+{
+    BOOST_GEOMETRY_ASSERT(boost::size(sorted) >= 4u && cluster_size > 0);
+
+    std::vector<std::pair<bool, bool> > directions;
+    for (std::size_t i = 0; i < cluster_size; i++)
+    {
+        directions.push_back(std::make_pair(false, false));
+    }
+
+    for (typename boost::range_iterator<AngleCollection const>::type it = sorted.begin();
+        it != sorted.end(); ++it)
+    {
+        if (it->incoming)
+        {
+            directions[it->cluster_index].first = true;
+        }
+        else
+        {
+            directions[it->cluster_index].second = true;
+        }
+    }
+
+    for (typename boost::range_iterator<AngleCollection>::type it = sorted.begin();
+        it != sorted.end(); ++it)
+    {
+        signed_size_type cluster_index = static_cast<signed_size_type>(it->cluster_index);
+        signed_size_type previous_index = cluster_index - 1;
+        if (previous_index < 0)
+        {
+            previous_index = cluster_size - 1;
+        }
+        signed_size_type next_index = cluster_index + 1;
+        if (next_index >= static_cast<signed_size_type>(cluster_size))
+        {
+            next_index = 0;
+        }
+
+        if (directions[cluster_index].first
+            && directions[cluster_index].second)
+        {
+            it->blocked = true;
+        }
+        else if (!directions[cluster_index].first
+            && directions[cluster_index].second
+            && directions[previous_index].second)
+        {
+            // Only outgoing, previous was also outgoing: block this one
+            it->blocked = true;
+        }
+        else if (directions[cluster_index].first
+            && !directions[cluster_index].second
+            && !directions[previous_index].first
+            && directions[previous_index].second)
+        {
+            // Only incoming, previous was only outgoing: block this one
+            it->blocked = true;
+        }
+        else if (directions[cluster_index].first
+            && !directions[cluster_index].second
+            && directions[next_index].first
+            && !directions[next_index].second)
+        {
+            // Only incoming, next also incoming, block this one
+            it->blocked = true;
+        }
+    }
+}
+
+#if defined(BOOST_GEOMETRY_BUFFER_ENLARGED_CLUSTERS)
+template <typename AngleCollection, typename Point>
+inline bool has_rounding_issues(AngleCollection const& angles, Point const& origin)
+{
+    for (typename boost::range_iterator<AngleCollection const>::type it =
+        angles.begin(); it != angles.end(); ++it)
+    {
+        // Vector origin -> p and origin -> q
+        typedef Point vector_type;
+        vector_type v = it->point;
+        geometry::subtract_point(v, origin);
+        return geometry::math::abs(geometry::get<0>(v)) <= 1
+            || geometry::math::abs(geometry::get<1>(v)) <= 1
+            ;
+    }
+    return false;
+}
+#endif
+
+
+}  // namespace left_turns
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_GET_LEFT_TURNS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/get_max_size.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/get_max_size.hpp
new file mode 100644
index 00000000000..8ac43e78b86
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/get_max_size.hpp
@@ -0,0 +1,64 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_GET_MAX_SIZE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_GET_MAX_SIZE_HPP
+
+
+#include <cstddef>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/util/math.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <typename Box, std::size_t Dimension>
+struct get_max_size_box
+{
+    static inline typename coordinate_type<Box>::type apply(Box const& box)
+    {
+        typename coordinate_type<Box>::type s
+            = geometry::math::abs(geometry::get<1, Dimension>(box) - geometry::get<0, Dimension>(box));
+
+        return (std::max)(s, get_max_size_box<Box, Dimension - 1>::apply(box));
+    }
+};
+
+template <typename Box>
+struct get_max_size_box<Box, 0>
+{
+    static inline typename coordinate_type<Box>::type apply(Box const& box)
+    {
+        return geometry::math::abs(geometry::get<1, 0>(box) - geometry::get<0, 0>(box));
+    }
+};
+
+// This might be implemented later on for other geometries too.
+// Not dispatched yet.
+template <typename Box>
+inline typename coordinate_type<Box>::type get_max_size(Box const& box)
+{
+    return get_max_size_box<Box, dimension<Box>::value - 1>::apply(box);
+}
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_GET_MAX_SIZE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/has_self_intersections.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/has_self_intersections.hpp
new file mode 100644
index 00000000000..c34bb217a62
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/has_self_intersections.hpp
@@ -0,0 +1,164 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2011-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_HAS_SELF_INTERSECTIONS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_HAS_SELF_INTERSECTIONS_HPP
+
+#include <deque>
+
+#include <boost/range.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_turns.hpp>
+#include <boost/geometry/algorithms/detail/overlay/self_turn_points.hpp>
+
+#include <boost/geometry/policies/disjoint_interrupt_policy.hpp>
+#include <boost/geometry/policies/robustness/robust_point_type.hpp>
+#include <boost/geometry/policies/robustness/segment_ratio_type.hpp>
+#include <boost/geometry/policies/robustness/get_rescale_policy.hpp>
+
+#ifdef BOOST_GEOMETRY_DEBUG_HAS_SELF_INTERSECTIONS
+#  include <boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp>
+#  include <boost/geometry/io/dsv/write.hpp>
+#endif
+
+
+namespace boost { namespace geometry
+{
+
+
+#if ! defined(BOOST_GEOMETRY_OVERLAY_NO_THROW)
+
+/*!
+\brief Overlay Invalid Input Exception
+\ingroup overlay
+\details The overlay_invalid_input_exception is thrown at invalid input
+ */
+class overlay_invalid_input_exception : public geometry::exception
+{
+public:
+
+    inline overlay_invalid_input_exception() {}
+
+    virtual char const* what() const throw()
+    {
+        return "Boost.Geometry Overlay invalid input exception";
+    }
+};
+
+#endif
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+template <typename Geometry, typename Strategy, typename RobustPolicy>
+inline bool has_self_intersections(Geometry const& geometry,
+        Strategy const& strategy,
+        RobustPolicy const& robust_policy,
+        bool throw_on_self_intersection = true)
+{
+    typedef typename point_type<Geometry>::type point_type;
+    typedef turn_info
+    <
+        point_type,
+        typename segment_ratio_type<point_type, RobustPolicy>::type
+    > turn_info;
+    std::deque<turn_info> turns;
+    detail::disjoint::disjoint_interrupt_policy policy;
+
+    detail::self_get_turn_points::self_turns<false, detail::overlay::assign_null_policy>(geometry, strategy, robust_policy, turns, policy);
+
+#ifdef BOOST_GEOMETRY_DEBUG_HAS_SELF_INTERSECTIONS
+    bool first = true;
+#endif
+    for(typename std::deque<turn_info>::const_iterator it = boost::begin(turns);
+        it != boost::end(turns); ++it)
+    {
+        turn_info const& info = *it;
+        bool const both_union_turn =
+            info.operations[0].operation == detail::overlay::operation_union
+            && info.operations[1].operation == detail::overlay::operation_union;
+        bool const both_intersection_turn =
+            info.operations[0].operation == detail::overlay::operation_intersection
+            && info.operations[1].operation == detail::overlay::operation_intersection;
+
+        bool const valid = (both_union_turn || both_intersection_turn)
+            && (info.method == detail::overlay::method_touch
+                || info.method == detail::overlay::method_touch_interior);
+
+        if (! valid)
+        {
+#ifdef BOOST_GEOMETRY_DEBUG_HAS_SELF_INTERSECTIONS
+            if (first)
+            {
+                std::cout << "turn points: " << std::endl;
+                first = false;
+            }
+            std::cout << method_char(info.method);
+            for (int i = 0; i < 2; i++)
+            {
+                std::cout << " " << operation_char(info.operations[i].operation);
+                std::cout << " " << info.operations[i].seg_id;
+            }
+            std::cout << " " << geometry::dsv(info.point) << std::endl;
+#endif
+
+#if ! defined(BOOST_GEOMETRY_OVERLAY_NO_THROW)
+            if (throw_on_self_intersection)
+            {
+                BOOST_THROW_EXCEPTION(overlay_invalid_input_exception());
+            }
+#endif
+            return true;
+        }
+
+    }
+    return false;
+}
+
+// For backward compatibility
+template <typename Geometry>
+inline bool has_self_intersections(Geometry const& geometry,
+                    bool throw_on_self_intersection = true)
+{
+    typedef typename geometry::point_type<Geometry>::type point_type;
+    typedef typename geometry::rescale_policy_type<point_type>::type
+        rescale_policy_type;
+
+    typename strategy::intersection::services::default_strategy
+        <
+            typename cs_tag<Geometry>::type
+        >::type strategy;
+
+    rescale_policy_type robust_policy
+            = geometry::get_rescale_policy<rescale_policy_type>(geometry);
+
+    return has_self_intersections(geometry, strategy, robust_policy,
+                                  throw_on_self_intersection);
+}
+
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_HAS_SELF_INTERSECTIONS_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/interior_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/interior_iterator.hpp
new file mode 100644
index 00000000000..3582773c3d0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/interior_iterator.hpp
@@ -0,0 +1,71 @@
+// Boost.Geometry
+
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERIOR_ITERATOR_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERIOR_ITERATOR_HPP
+
+#include <boost/range/iterator.hpp>
+#include <boost/range/value_type.hpp>
+
+#include <boost/geometry/core/interior_type.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+/*!
+\brief Structure defining the type of interior rings iterator
+\note If the Geometry is const, const iterator is defined.
+\tparam Geometry \tparam_geometry
+ */
+template <typename Geometry>
+struct interior_iterator
+{
+    typedef typename boost::range_iterator
+        <
+            typename geometry::interior_type<Geometry>::type        
+        >::type type;
+};
+
+template <typename BaseT, typename T>
+struct copy_const
+{
+    typedef T type;
+};
+
+template <typename BaseT, typename T>
+struct copy_const<BaseT const, T>
+{
+    typedef T const type;
+};
+
+template <typename Geometry>
+struct interior_ring_iterator
+{
+    typedef typename boost::range_iterator
+        <
+            typename copy_const
+                <
+                    typename geometry::interior_type<Geometry>::type,
+                    typename boost::range_value
+                        <
+                            typename geometry::interior_type<Geometry>::type
+                        >::type
+                >::type
+        >::type type;
+};
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERIOR_ITERATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersection/box_box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersection/box_box.hpp
new file mode 100644
index 00000000000..30c31ff1e56
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersection/box_box.hpp
@@ -0,0 +1,54 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTION_BOX_BOX_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTION_BOX_BOX_HPP
+
+
+#include <boost/geometry/algorithms/detail/intersection/interface.hpp>
+#include <boost/geometry/algorithms/detail/overlay/intersection_box_box.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template
+<
+    typename Box1, typename Box2, bool Reverse
+>
+struct intersection
+    <
+        Box1, Box2,
+        box_tag, box_tag,
+        Reverse
+    > : public detail::intersection::intersection_box_box
+            <
+                0, geometry::dimension<Box1>::value
+            >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTION_BOX_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersection/implementation.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersection/implementation.hpp
new file mode 100644
index 00000000000..d8fb2ec38c7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersection/implementation.hpp
@@ -0,0 +1,22 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTION_IMPLEMENTATION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTION_IMPLEMENTATION_HPP
+
+
+#include <boost/geometry/algorithms/detail/intersection/box_box.hpp>
+#include <boost/geometry/algorithms/detail/intersection/multi.hpp>
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTION_IMPLEMENTATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersection/interface.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersection/interface.hpp
new file mode 100644
index 00000000000..0efc9731b53
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersection/interface.hpp
@@ -0,0 +1,398 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014, 2017.
+// Modifications copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTION_INTERFACE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTION_INTERFACE_HPP
+
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/intersection_insert.hpp>
+#include <boost/geometry/policies/robustness/get_rescale_policy.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/util/range.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+// By default, all is forwarded to the intersection_insert-dispatcher
+template
+<
+    typename Geometry1, typename Geometry2,
+    typename Tag1 = typename geometry::tag<Geometry1>::type,
+    typename Tag2 = typename geometry::tag<Geometry2>::type,
+    bool Reverse = reverse_dispatch<Geometry1, Geometry2>::type::value
+>
+struct intersection
+{
+    template <typename RobustPolicy, typename GeometryOut, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+            Geometry2 const& geometry2,
+            RobustPolicy const& robust_policy,
+            GeometryOut& geometry_out,
+            Strategy const& strategy)
+    {
+        typedef typename boost::range_value<GeometryOut>::type OneOut;
+
+        intersection_insert
+            <
+                Geometry1, Geometry2, OneOut,
+                overlay_intersection
+            >::apply(geometry1, geometry2, robust_policy,
+                     range::back_inserter(geometry_out), strategy);
+
+        return true;
+    }
+
+};
+
+
+// If reversal is needed, perform it
+template
+<
+    typename Geometry1, typename Geometry2,
+    typename Tag1, typename Tag2
+>
+struct intersection
+<
+    Geometry1, Geometry2,
+    Tag1, Tag2,
+    true
+>
+    : intersection<Geometry2, Geometry1, Tag2, Tag1, false>
+{
+    template <typename RobustPolicy, typename GeometryOut, typename Strategy>
+    static inline bool apply(
+        Geometry1 const& g1,
+        Geometry2 const& g2,
+        RobustPolicy const& robust_policy,
+        GeometryOut& out,
+        Strategy const& strategy)
+    {
+        return intersection
+            <
+                Geometry2, Geometry1,
+                Tag2, Tag1,
+                false
+            >::apply(g2, g1, robust_policy, out, strategy);
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_strategy {
+
+struct intersection
+{
+    template
+    <
+        typename Geometry1,
+        typename Geometry2,
+        typename RobustPolicy,
+        typename GeometryOut,
+        typename Strategy
+    >
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             RobustPolicy const& robust_policy,
+                             GeometryOut & geometry_out,
+                             Strategy const& strategy)
+    {
+        return dispatch::intersection
+            <
+                Geometry1,
+                Geometry2
+            >::apply(geometry1, geometry2, robust_policy, geometry_out,
+                     strategy);
+    }
+
+    template
+    <
+        typename Geometry1,
+        typename Geometry2,
+        typename RobustPolicy,
+        typename GeometryOut
+    >
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             RobustPolicy const& robust_policy,
+                             GeometryOut & geometry_out,
+                             default_strategy)
+    {
+        typedef typename strategy::relate::services::default_strategy
+            <
+                Geometry1, Geometry2
+            >::type strategy_type;
+        
+        return dispatch::intersection
+            <
+                Geometry1,
+                Geometry2
+            >::apply(geometry1, geometry2, robust_policy, geometry_out,
+                     strategy_type());
+    }
+};
+
+} // resolve_strategy
+
+
+namespace resolve_variant
+{
+    
+template <typename Geometry1, typename Geometry2>
+struct intersection
+{
+    template <typename GeometryOut, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             GeometryOut& geometry_out,
+                             Strategy const& strategy)
+    {
+        concepts::check<Geometry1 const>();
+        concepts::check<Geometry2 const>();
+        
+        typedef typename geometry::rescale_overlay_policy_type
+            <
+                Geometry1,
+                Geometry2
+            >::type rescale_policy_type;
+        
+        rescale_policy_type robust_policy
+            = geometry::get_rescale_policy<rescale_policy_type>(geometry1,
+                                                                geometry2);
+        
+        return resolve_strategy::intersection::apply(geometry1,
+                                                     geometry2,
+                                                     robust_policy,
+                                                     geometry_out,
+                                                     strategy);
+    }
+};
+
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
+struct intersection<variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
+{
+    template <typename GeometryOut, typename Strategy>
+    struct visitor: static_visitor<bool>
+    {
+        Geometry2 const& m_geometry2;
+        GeometryOut& m_geometry_out;
+        Strategy const& m_strategy;
+        
+        visitor(Geometry2 const& geometry2,
+                GeometryOut& geometry_out,
+                Strategy const& strategy)
+            : m_geometry2(geometry2)
+            , m_geometry_out(geometry_out)
+            , m_strategy(strategy)
+        {}
+        
+        template <typename Geometry1>
+        bool operator()(Geometry1 const& geometry1) const
+        {
+            return intersection
+                <
+                    Geometry1,
+                    Geometry2
+                >::apply(geometry1, m_geometry2, m_geometry_out, m_strategy);
+        }
+    };
+    
+    template <typename GeometryOut, typename Strategy>
+    static inline bool
+    apply(variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
+          Geometry2 const& geometry2,
+          GeometryOut& geometry_out,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<GeometryOut, Strategy>(geometry2,
+                                                                   geometry_out,
+                                                                   strategy),
+                                    geometry1);
+    }
+};
+
+
+template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct intersection<Geometry1, variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename GeometryOut, typename Strategy>
+    struct visitor: static_visitor<bool>
+    {
+        Geometry1 const& m_geometry1;
+        GeometryOut& m_geometry_out;
+        Strategy const& m_strategy;
+        
+        visitor(Geometry1 const& geometry1,
+                GeometryOut& geometry_out,
+                Strategy const& strategy)
+            : m_geometry1(geometry1)
+            , m_geometry_out(geometry_out)
+            , m_strategy(strategy)
+        {}
+        
+        template <typename Geometry2>
+        bool operator()(Geometry2 const& geometry2) const
+        {
+            return intersection
+                <
+                    Geometry1,
+                    Geometry2
+                >::apply(m_geometry1, geometry2, m_geometry_out, m_strategy);
+        }
+    };
+    
+    template <typename GeometryOut, typename Strategy>
+    static inline bool
+    apply(Geometry1 const& geometry1,
+          variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2,
+          GeometryOut& geometry_out,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<GeometryOut, Strategy>(geometry1,
+                                                                   geometry_out,
+                                                                   strategy),
+                                    geometry2);
+    }
+};
+
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T1), BOOST_VARIANT_ENUM_PARAMS(typename T2)>
+struct intersection<variant<BOOST_VARIANT_ENUM_PARAMS(T1)>, variant<BOOST_VARIANT_ENUM_PARAMS(T2)> >
+{
+    template <typename GeometryOut, typename Strategy>
+    struct visitor: static_visitor<bool>
+    {
+        GeometryOut& m_geometry_out;
+        Strategy const& m_strategy;
+        
+        visitor(GeometryOut& geometry_out, Strategy const& strategy)
+            : m_geometry_out(geometry_out)
+            , m_strategy(strategy)
+        {}
+        
+        template <typename Geometry1, typename Geometry2>
+        bool operator()(Geometry1 const& geometry1,
+                        Geometry2 const& geometry2) const
+        {
+            return intersection
+                <
+                    Geometry1,
+                    Geometry2
+                >::apply(geometry1, geometry2, m_geometry_out, m_strategy);
+        }
+    };
+    
+    template <typename GeometryOut, typename Strategy>
+    static inline bool
+    apply(variant<BOOST_VARIANT_ENUM_PARAMS(T1)> const& geometry1,
+          variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2,
+          GeometryOut& geometry_out,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<GeometryOut, Strategy>(geometry_out,
+                                                                   strategy),
+                                    geometry1, geometry2);
+    }
+};
+    
+} // namespace resolve_variant
+    
+
+/*!
+\brief \brief_calc2{intersection}
+\ingroup intersection
+\details \details_calc2{intersection, spatial set theoretic intersection}.
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam GeometryOut Collection of geometries (e.g. std::vector, std::deque, boost::geometry::multi*) of which
+    the value_type fulfills a \p_l_or_c concept, or it is the output geometry (e.g. for a box)
+\tparam Strategy \tparam_strategy{Intersection}
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param geometry_out The output geometry, either a multi_point, multi_polygon,
+    multi_linestring, or a box (for intersection of two boxes)
+\param strategy \param_strategy{intersection}
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/intersection.qbk]}
+*/
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename GeometryOut,
+    typename Strategy
+>
+inline bool intersection(Geometry1 const& geometry1,
+                         Geometry2 const& geometry2,
+                         GeometryOut& geometry_out,
+                         Strategy const& strategy)
+{
+    return resolve_variant::intersection
+        <
+            Geometry1,
+            Geometry2
+        >::apply(geometry1, geometry2, geometry_out, strategy);
+}
+
+
+/*!
+\brief \brief_calc2{intersection}
+\ingroup intersection
+\details \details_calc2{intersection, spatial set theoretic intersection}.
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam GeometryOut Collection of geometries (e.g. std::vector, std::deque, boost::geometry::multi*) of which
+    the value_type fulfills a \p_l_or_c concept, or it is the output geometry (e.g. for a box)
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param geometry_out The output geometry, either a multi_point, multi_polygon,
+    multi_linestring, or a box (for intersection of two boxes)
+
+\qbk{[include reference/algorithms/intersection.qbk]}
+*/
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename GeometryOut
+>
+inline bool intersection(Geometry1 const& geometry1,
+                         Geometry2 const& geometry2,
+                         GeometryOut& geometry_out)
+{
+    return resolve_variant::intersection
+        <
+            Geometry1,
+            Geometry2
+        >::apply(geometry1, geometry2, geometry_out, default_strategy());
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTION_INTERFACE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersection/multi.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersection/multi.hpp
new file mode 100644
index 00000000000..88b49b0167f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersection/multi.hpp
@@ -0,0 +1,421 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014-2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTION_MULTI_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTION_MULTI_HPP
+
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/geometry_id.hpp>
+#include <boost/geometry/core/is_areal.hpp>
+#include <boost/geometry/core/point_order.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+// TODO: those headers probably may be removed
+#include <boost/geometry/algorithms/detail/overlay/get_ring.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_turns.hpp>
+#include <boost/geometry/algorithms/detail/overlay/copy_segments.hpp>
+#include <boost/geometry/algorithms/detail/overlay/copy_segment_point.hpp>
+#include <boost/geometry/algorithms/detail/overlay/select_rings.hpp>
+#include <boost/geometry/algorithms/detail/sections/range_by_section.hpp>
+#include <boost/geometry/algorithms/detail/sections/sectionalize.hpp>
+
+#include <boost/geometry/algorithms/detail/intersection/interface.hpp>
+
+#include <boost/geometry/algorithms/covered_by.hpp>
+#include <boost/geometry/algorithms/envelope.hpp>
+#include <boost/geometry/algorithms/num_points.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace intersection
+{
+
+
+template <typename PointOut>
+struct intersection_multi_linestring_multi_linestring_point
+{
+    template
+    <
+        typename MultiLinestring1, typename MultiLinestring2,
+        typename RobustPolicy,
+        typename OutputIterator, typename Strategy
+    >
+    static inline OutputIterator apply(MultiLinestring1 const& ml1,
+            MultiLinestring2 const& ml2,
+            RobustPolicy const& robust_policy,
+            OutputIterator out,
+            Strategy const& strategy)
+    {
+        // Note, this loop is quadratic w.r.t. number of linestrings per input.
+        // Future Enhancement: first do the sections of each, then intersect.
+        for (typename boost::range_iterator
+                <
+                    MultiLinestring1 const
+                >::type it1 = boost::begin(ml1);
+            it1 != boost::end(ml1);
+            ++it1)
+        {
+            for (typename boost::range_iterator
+                    <
+                        MultiLinestring2 const
+                    >::type it2 = boost::begin(ml2);
+                it2 != boost::end(ml2);
+                ++it2)
+            {
+                out = intersection_linestring_linestring_point<PointOut>
+                      ::apply(*it1, *it2, robust_policy, out, strategy);
+            }
+        }
+
+        return out;
+    }
+};
+
+
+template <typename PointOut>
+struct intersection_linestring_multi_linestring_point
+{
+    template
+    <
+        typename Linestring, typename MultiLinestring,
+        typename RobustPolicy,
+        typename OutputIterator, typename Strategy
+    >
+    static inline OutputIterator apply(Linestring const& linestring,
+            MultiLinestring const& ml,
+            RobustPolicy const& robust_policy,
+            OutputIterator out,
+            Strategy const& strategy)
+    {
+        for (typename boost::range_iterator
+                <
+                    MultiLinestring const
+                >::type it = boost::begin(ml);
+            it != boost::end(ml);
+            ++it)
+        {
+            out = intersection_linestring_linestring_point<PointOut>
+                  ::apply(linestring, *it, robust_policy, out, strategy);
+        }
+
+        return out;
+    }
+};
+
+
+// This loop is quite similar to the loop above, but beacuse the iterator
+// is second (above) or first (below) argument, it is not trivial to merge them.
+template
+<
+    bool ReverseAreal,
+    typename LineStringOut,
+    overlay_type OverlayType
+>
+struct intersection_of_multi_linestring_with_areal
+{
+    template
+    <
+        typename MultiLinestring, typename Areal,
+        typename RobustPolicy,
+        typename OutputIterator, typename Strategy
+    >
+    static inline OutputIterator apply(MultiLinestring const& ml, Areal const& areal,
+            RobustPolicy const& robust_policy,
+            OutputIterator out,
+            Strategy const& strategy)
+    {
+        for (typename boost::range_iterator
+                <
+                    MultiLinestring const
+                >::type it = boost::begin(ml);
+            it != boost::end(ml);
+            ++it)
+        {
+            out = intersection_of_linestring_with_areal
+                <
+                    ReverseAreal, LineStringOut, OverlayType
+                >::apply(*it, areal, robust_policy, out, strategy);
+        }
+
+        return out;
+
+    }
+};
+
+// This one calls the one above with reversed arguments
+template
+<
+    bool ReverseAreal,
+    typename LineStringOut,
+    overlay_type OverlayType
+>
+struct intersection_of_areal_with_multi_linestring
+{
+    template
+    <
+        typename Areal, typename MultiLinestring,
+        typename RobustPolicy,
+        typename OutputIterator, typename Strategy
+    >
+    static inline OutputIterator apply(Areal const& areal, MultiLinestring const& ml,
+            RobustPolicy const& robust_policy,
+            OutputIterator out,
+            Strategy const& strategy)
+    {
+        return intersection_of_multi_linestring_with_areal
+            <
+                ReverseAreal, LineStringOut, OverlayType
+            >::apply(ml, areal, robust_policy, out, strategy);
+    }
+};
+
+
+
+template <typename LinestringOut>
+struct clip_multi_linestring
+{
+    template
+    <
+        typename MultiLinestring, typename Box,
+        typename RobustPolicy,
+        typename OutputIterator, typename Strategy
+    >
+    static inline OutputIterator apply(MultiLinestring const& multi_linestring,
+            Box const& box,
+            RobustPolicy const& robust_policy,
+            OutputIterator out, Strategy const& )
+    {
+        typedef typename point_type<LinestringOut>::type point_type;
+        strategy::intersection::liang_barsky<Box, point_type> lb_strategy;
+        for (typename boost::range_iterator<MultiLinestring const>::type it
+            = boost::begin(multi_linestring);
+            it != boost::end(multi_linestring); ++it)
+        {
+            out = detail::intersection::clip_range_with_box
+                <LinestringOut>(box, *it, robust_policy, out, lb_strategy);
+        }
+        return out;
+    }
+};
+
+
+}} // namespace detail::intersection
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// Linear
+template
+<
+    typename MultiLinestring1, typename MultiLinestring2,
+    typename GeometryOut,
+    overlay_type OverlayType,
+    bool Reverse1, bool Reverse2, bool ReverseOut
+>
+struct intersection_insert
+    <
+        MultiLinestring1, MultiLinestring2,
+        GeometryOut,
+        OverlayType,
+        Reverse1, Reverse2, ReverseOut,
+        multi_linestring_tag, multi_linestring_tag, point_tag,
+        false, false, false
+    > : detail::intersection::intersection_multi_linestring_multi_linestring_point
+            <
+                GeometryOut
+            >
+{};
+
+
+template
+<
+    typename Linestring, typename MultiLinestring,
+    typename GeometryOut,
+    overlay_type OverlayType,
+    bool Reverse1, bool Reverse2, bool ReverseOut
+>
+struct intersection_insert
+    <
+        Linestring, MultiLinestring,
+        GeometryOut,
+        OverlayType,
+        Reverse1, Reverse2, ReverseOut,
+        linestring_tag, multi_linestring_tag, point_tag,
+        false, false, false
+    > : detail::intersection::intersection_linestring_multi_linestring_point
+            <
+                GeometryOut
+            >
+{};
+
+
+template
+<
+    typename MultiLinestring, typename Box,
+    typename GeometryOut,
+    overlay_type OverlayType,
+    bool Reverse1, bool Reverse2, bool ReverseOut
+>
+struct intersection_insert
+    <
+        MultiLinestring, Box,
+        GeometryOut,
+        OverlayType,
+        Reverse1, Reverse2, ReverseOut,
+        multi_linestring_tag, box_tag, linestring_tag,
+        false, true, false
+    > : detail::intersection::clip_multi_linestring
+            <
+                GeometryOut
+            >
+{};
+
+
+template
+<
+    typename Linestring, typename MultiPolygon,
+    typename GeometryOut,
+    overlay_type OverlayType,
+    bool ReverseLinestring, bool ReverseMultiPolygon, bool ReverseOut
+>
+struct intersection_insert
+    <
+        Linestring, MultiPolygon,
+        GeometryOut,
+        OverlayType,
+        ReverseLinestring, ReverseMultiPolygon, ReverseOut,
+        linestring_tag, multi_polygon_tag, linestring_tag,
+        false, true, false
+    > : detail::intersection::intersection_of_linestring_with_areal
+            <
+                ReverseMultiPolygon,
+                GeometryOut,
+                OverlayType
+            >
+{};
+
+
+// Derives from areal/mls because runtime arguments are in that order.
+// areal/mls reverses it itself to mls/areal
+template
+<
+    typename Polygon, typename MultiLinestring,
+    typename GeometryOut,
+    overlay_type OverlayType,
+    bool ReversePolygon, bool ReverseMultiLinestring, bool ReverseOut
+>
+struct intersection_insert
+    <
+        Polygon, MultiLinestring,
+        GeometryOut,
+        OverlayType,
+        ReversePolygon, ReverseMultiLinestring, ReverseOut,
+        polygon_tag, multi_linestring_tag, linestring_tag,
+        true, false, false
+    > : detail::intersection::intersection_of_areal_with_multi_linestring
+            <
+                ReversePolygon,
+                GeometryOut,
+                OverlayType
+            >
+{};
+
+
+template
+<
+    typename MultiLinestring, typename Ring,
+    typename GeometryOut,
+    overlay_type OverlayType,
+    bool ReverseMultiLinestring, bool ReverseRing, bool ReverseOut
+>
+struct intersection_insert
+    <
+        MultiLinestring, Ring,
+        GeometryOut,
+        OverlayType,
+        ReverseMultiLinestring, ReverseRing, ReverseOut,
+        multi_linestring_tag, ring_tag, linestring_tag,
+        false, true, false
+    > : detail::intersection::intersection_of_multi_linestring_with_areal
+            <
+                ReverseRing,
+                GeometryOut,
+                OverlayType
+            >
+{};
+
+template
+<
+    typename MultiLinestring, typename Polygon,
+    typename GeometryOut,
+    overlay_type OverlayType,
+    bool ReverseMultiLinestring, bool ReverseRing, bool ReverseOut
+>
+struct intersection_insert
+    <
+        MultiLinestring, Polygon,
+        GeometryOut,
+        OverlayType,
+        ReverseMultiLinestring, ReverseRing, ReverseOut,
+        multi_linestring_tag, polygon_tag, linestring_tag,
+        false, true, false
+    > : detail::intersection::intersection_of_multi_linestring_with_areal
+            <
+                ReverseRing,
+                GeometryOut,
+                OverlayType
+            >
+{};
+
+
+
+template
+<
+    typename MultiLinestring, typename MultiPolygon,
+    typename GeometryOut,
+    overlay_type OverlayType,
+    bool ReverseMultiLinestring, bool ReverseMultiPolygon, bool ReverseOut
+>
+struct intersection_insert
+    <
+        MultiLinestring, MultiPolygon,
+        GeometryOut,
+        OverlayType,
+        ReverseMultiLinestring, ReverseMultiPolygon, ReverseOut,
+        multi_linestring_tag, multi_polygon_tag, linestring_tag,
+        false, true, false
+    > : detail::intersection::intersection_of_multi_linestring_with_areal
+            <
+                ReverseMultiPolygon,
+                GeometryOut,
+                OverlayType
+            >
+{};
+
+
+} // namespace dispatch
+#endif
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTION_MULTI_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersects/implementation.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersects/implementation.hpp
new file mode 100644
index 00000000000..2379168e835
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersects/implementation.hpp
@@ -0,0 +1,88 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2013-2017.
+// Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTS_IMPLEMENTATION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTS_IMPLEMENTATION_HPP
+
+
+#include <deque>
+
+#include <boost/geometry/algorithms/detail/intersects/interface.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/implementation.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/self_turn_points.hpp>
+#include <boost/geometry/policies/disjoint_interrupt_policy.hpp>
+#include <boost/geometry/policies/robustness/no_rescale_policy.hpp>
+#include <boost/geometry/policies/robustness/segment_ratio_type.hpp>
+
+#include <boost/geometry/strategies/relate.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace intersects
+{
+
+template <typename Geometry>
+struct self_intersects
+{
+    static bool apply(Geometry const& geometry)
+    {
+        concepts::check<Geometry const>();
+
+        typedef typename geometry::point_type<Geometry>::type point_type;
+        typedef typename strategy::relate::services::default_strategy
+                <
+                    Geometry, Geometry
+                >::type strategy_type;
+        typedef detail::no_rescale_policy rescale_policy_type;
+
+        typedef detail::overlay::turn_info
+            <
+                point_type,
+                typename segment_ratio_type<point_type, rescale_policy_type>::type
+            > turn_info;
+
+        std::deque<turn_info> turns;
+
+        typedef detail::overlay::get_turn_info
+            <
+                detail::overlay::assign_null_policy
+            > turn_policy;
+
+        strategy_type strategy;
+        rescale_policy_type robust_policy;
+
+        detail::disjoint::disjoint_interrupt_policy policy;
+        detail::self_get_turn_points::get_turns
+            <
+                false, turn_policy
+            >::apply(geometry, strategy, robust_policy, turns, policy, 0);
+        return policy.has_intersections;
+    }
+};
+
+}} // namespace detail::intersects
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTS_IMPLEMENTATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersects/interface.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersects/interface.hpp
new file mode 100644
index 00000000000..8940a426f37
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/intersects/interface.hpp
@@ -0,0 +1,115 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2013-2017.
+// Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTS_INTERFACE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTS_INTERFACE_HPP
+
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/algorithms/detail/disjoint/interface.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace intersects
+{
+
+// Forward declaration
+template <typename Geometry>
+struct self_intersects;
+
+}} // namespace detail::intersects
+#endif // DOXYGEN_NO_DETAIL
+
+
+/*!
+\brief \brief_check{has at least one intersection (crossing or self-tangency)}
+\note This function can be called for one geometry (self-intersection) and
+    also for two geometries (intersection)
+\ingroup intersects
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\return \return_check{is self-intersecting}
+
+\qbk{distinguish,one geometry}
+\qbk{[def __one_parameter__]}
+\qbk{[include reference/algorithms/intersects.qbk]}
+*/
+template <typename Geometry>
+inline bool intersects(Geometry const& geometry)
+{
+    return detail::intersects::self_intersects<Geometry>::apply(geometry);
+}
+
+
+/*!
+\brief \brief_check2{have at least one intersection}
+\ingroup intersects
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Strategy \tparam_strategy{Intersects}
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param strategy \param_strategy{intersects}
+\return \return_check2{intersect each other}
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/intersects.qbk]}
+ */
+template <typename Geometry1, typename Geometry2, typename Strategy>
+inline bool intersects(Geometry1 const& geometry1,
+                       Geometry2 const& geometry2,
+                       Strategy const& strategy)
+{
+    concepts::check<Geometry1 const>();
+    concepts::check<Geometry2 const>();
+
+    return ! geometry::disjoint(geometry1, geometry2, strategy);
+}
+
+
+/*!
+\brief \brief_check2{have at least one intersection}
+\ingroup intersects
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\return \return_check2{intersect each other}
+
+\qbk{distinguish,two geometries}
+\qbk{[include reference/algorithms/intersects.qbk]}
+ */
+template <typename Geometry1, typename Geometry2>
+inline bool intersects(Geometry1 const& geometry1, Geometry2 const& geometry2)
+{
+    concepts::check<Geometry1 const>();
+    concepts::check<Geometry2 const>();
+
+    return ! geometry::disjoint(geometry1, geometry2);
+}
+
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_INTERSECTS_INTERFACE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/always_simple.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/always_simple.hpp
new file mode 100644
index 00000000000..5cec5e19247
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/always_simple.hpp
@@ -0,0 +1,85 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_ALWAYS_SIMPLE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_ALWAYS_SIMPLE_HPP
+
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/dispatch/is_simple.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace is_simple
+{
+
+
+template <typename Geometry>
+struct always_simple
+{
+    template <typename Strategy>
+    static inline bool apply(Geometry const&, Strategy const&)
+    {
+        return true;
+    }
+};
+
+
+}} // namespace detail::is_simple
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// A point is always simple
+template <typename Point>
+struct is_simple<Point, point_tag>
+    : detail::is_simple::always_simple<Point>
+{};
+
+
+// A valid segment is always simple.
+// A segment is a curve.
+// A curve is simple if it does not pass through the same point twice,
+// with the possible exception of its two endpoints
+//
+// Reference: OGC 06-103r4 (6.1.6.1)
+template <typename Segment>
+struct is_simple<Segment, segment_tag>
+    : detail::is_simple::always_simple<Segment>
+{};
+
+
+// A valid box is always simple
+// A box is a Polygon, and it satisfies the conditions for Polygon validity.
+//
+// Reference (for polygon validity): OGC 06-103r4 (6.1.11.1)
+template <typename Box>
+struct is_simple<Box, box_tag>
+    : detail::is_simple::always_simple<Box>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_ALWAYS_SIMPLE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/areal.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/areal.hpp
new file mode 100644
index 00000000000..d4d6db9bcea
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/areal.hpp
@@ -0,0 +1,157 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_AREAL_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_AREAL_HPP
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/detail/check_iterator_range.hpp>
+#include <boost/geometry/algorithms/detail/is_simple/failure_policy.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/has_duplicates.hpp>
+
+#include <boost/geometry/algorithms/dispatch/is_simple.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace is_simple
+{
+
+
+template <typename Ring>
+struct is_simple_ring
+{
+    template <typename Strategy>
+    static inline bool apply(Ring const& ring, Strategy const&)
+    {
+        return apply(ring);
+    }
+
+    static inline bool apply(Ring const& ring)
+    {
+        simplicity_failure_policy policy;
+        return ! boost::empty(ring)
+            && ! detail::is_valid::has_duplicates
+                    <
+                        Ring, geometry::closure<Ring>::value
+                    >::apply(ring, policy);
+    }
+};
+
+
+template <typename Polygon>
+class is_simple_polygon
+{
+private:
+    template <typename InteriorRings>
+    static inline
+    bool are_simple_interior_rings(InteriorRings const& interior_rings)
+    {
+        return
+            detail::check_iterator_range
+                <
+                    is_simple_ring
+                        <
+                            typename boost::range_value<InteriorRings>::type
+                        >
+                >::apply(boost::begin(interior_rings),
+                         boost::end(interior_rings));
+    }
+
+public:
+    template <typename Strategy>
+    static inline bool apply(Polygon const& polygon, Strategy const&)
+    {
+        return apply(polygon);
+    }
+
+    static inline bool apply(Polygon const& polygon)
+    {
+        return
+            is_simple_ring
+                <
+                    typename ring_type<Polygon>::type
+                >::apply(exterior_ring(polygon))
+            &&
+            are_simple_interior_rings(geometry::interior_rings(polygon));
+    }
+};
+
+
+}} // namespace detail::is_simple
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// A Ring is a Polygon.
+// A Polygon is always a simple geometric object provided that it is valid.
+//
+// Reference (for polygon validity): OGC 06-103r4 (6.1.11.1)
+template <typename Ring>
+struct is_simple<Ring, ring_tag>
+    : detail::is_simple::is_simple_ring<Ring>
+{};
+
+
+// A Polygon is always a simple geometric object provided that it is valid.
+//
+// Reference (for validity of Polygons): OGC 06-103r4 (6.1.11.1)
+template <typename Polygon>
+struct is_simple<Polygon, polygon_tag>
+    : detail::is_simple::is_simple_polygon<Polygon>
+{};
+
+
+// Not clear what the definition is.
+// Right now we consider a MultiPolygon as simple if it is valid.
+//
+// Reference (for validity of MultiPolygons): OGC 06-103r4 (6.1.14)
+template <typename MultiPolygon>
+struct is_simple<MultiPolygon, multi_polygon_tag>
+{
+    template <typename Strategy>
+    static inline bool apply(MultiPolygon const& multipolygon, Strategy const&)
+    {
+        return
+            detail::check_iterator_range
+                <
+                    detail::is_simple::is_simple_polygon
+                        <
+                            typename boost::range_value<MultiPolygon>::type
+                        >,
+                    true // allow empty multi-polygon
+                >::apply(boost::begin(multipolygon), boost::end(multipolygon));
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_AREAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/debug_print_boundary_points.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/debug_print_boundary_points.hpp
new file mode 100644
index 00000000000..196d89b925e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/debug_print_boundary_points.hpp
@@ -0,0 +1,113 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_DEBUG_PRINT_BOUNDARY_POINTS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_DEBUG_PRINT_BOUNDARY_POINTS_HPP
+
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/io/dsv/write.hpp>
+
+#include <boost/geometry/policies/compare.hpp>
+
+#include <boost/geometry/algorithms/equals.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+#endif // BOOST_GEOMETRY_TEST_DEBUG
+
+
+namespace boost { namespace geometry
+{
+
+namespace detail { namespace is_simple
+{
+
+
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+template <typename Linear, typename Tag = typename tag<Linear>::type>
+struct debug_boundary_points_printer
+    : not_implemented<Linear>
+{};
+
+template <typename Linestring>
+struct debug_boundary_points_printer<Linestring, linestring_tag>
+{
+    static inline void apply(Linestring const& linestring)
+    {
+        std::cout << "boundary points: ";
+        std::cout << " " << geometry::dsv(range::front(linestring));
+        std::cout << " " << geometry::dsv(range::back(linestring));
+        std::cout << std::endl << std::endl;
+    }
+};
+
+template <typename MultiLinestring>
+struct debug_boundary_points_printer<MultiLinestring, multi_linestring_tag>
+{
+    static inline void apply(MultiLinestring const& multilinestring)
+    {
+        typedef typename point_type<MultiLinestring>::type point_type;
+        typedef std::vector<point_type> point_vector;
+
+        point_vector boundary_points;
+        for (typename boost::range_iterator<MultiLinestring const>::type it
+                 = boost::begin(multilinestring);
+             it != boost::end(multilinestring); ++it)
+        {
+            if ( boost::size(*it) > 1
+                 && !geometry::equals(range::front(*it), range::back(*it)) )
+            {
+                boundary_points.push_back( range::front(*it) );
+                boundary_points.push_back( range::back(*it) );
+            }
+        }
+
+        std::sort(boundary_points.begin(), boundary_points.end(),
+                  geometry::less<point_type>());
+
+        std::cout << "boundary points: ";
+        for (typename point_vector::const_iterator
+                 pit = boundary_points.begin();
+             pit != boundary_points.end(); ++pit)
+        {
+            std::cout << " " << geometry::dsv(*pit);
+        }
+        std::cout << std::endl << std::endl;
+    }
+};
+
+
+template <typename Linear>
+inline void debug_print_boundary_points(Linear const& linear)
+{
+    debug_boundary_points_printer<Linear>::apply(linear);
+}
+#else
+template <typename Linear>
+inline void debug_print_boundary_points(Linear const&)
+{
+}
+#endif // BOOST_GEOMETRY_TEST_DEBUG
+
+
+}} // namespace detail::is_simple
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_DEBUG_PRINT_BOUNDARY_POINTS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/failure_policy.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/failure_policy.hpp
new file mode 100644
index 00000000000..6504edd1d5f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/failure_policy.hpp
@@ -0,0 +1,53 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_FAILURE_POLICY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_FAILURE_POLICY_HPP
+
+#include <boost/geometry/algorithms/validity_failure_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace is_simple
+{
+
+
+struct simplicity_failure_policy
+{
+    template <validity_failure_type Failure>
+    static inline bool apply()
+    {
+        return Failure == no_failure;
+    }
+
+    template <validity_failure_type Failure, typename Data>
+    static inline bool apply(Data const&)
+    {
+        return apply<Failure>();
+    }
+
+    template <validity_failure_type Failure, typename Data1, typename Data2>
+    static inline bool apply(Data1 const&, Data2 const&)
+    {
+        return apply<Failure>();
+    }
+};
+
+
+}} // namespace detail::is_simple
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_FAILURE_POLICY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/implementation.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/implementation.hpp
new file mode 100644
index 00000000000..e69b273ce3c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/implementation.hpp
@@ -0,0 +1,18 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_IMPLEMENTATION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_IMPLEMENTATION_HPP
+
+#include <boost/geometry/algorithms/detail/is_simple/always_simple.hpp>
+#include <boost/geometry/algorithms/detail/is_simple/areal.hpp>
+#include <boost/geometry/algorithms/detail/is_simple/linear.hpp>
+#include <boost/geometry/algorithms/detail/is_simple/multipoint.hpp>
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_IMPLEMENTATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/interface.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/interface.hpp
new file mode 100644
index 00000000000..af0127dc75c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/interface.hpp
@@ -0,0 +1,141 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_INTERFACE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_INTERFACE_HPP
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/algorithms/dispatch/is_simple.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/strategies/intersection.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace resolve_strategy
+{
+
+struct is_simple
+{
+    template <typename Geometry, typename Strategy>
+    static inline bool apply(Geometry const& geometry,
+                             Strategy const& strategy)
+    {
+        return dispatch::is_simple<Geometry>::apply(geometry, strategy);
+    }
+
+    template <typename Geometry>
+    static inline bool apply(Geometry const& geometry,
+                             default_strategy)
+    {
+        // NOTE: Currently the strategy is only used for Linear geometries
+        typedef typename strategy::intersection::services::default_strategy
+            <
+                typename cs_tag<Geometry>::type
+            >::type strategy_type;
+
+        return dispatch::is_simple<Geometry>::apply(geometry, strategy_type());
+    }
+};
+
+} // namespace resolve_strategy
+
+namespace resolve_variant
+{
+
+template <typename Geometry>
+struct is_simple
+{
+    template <typename Strategy>
+    static inline bool apply(Geometry const& geometry, Strategy const& strategy)
+    {
+        concepts::check<Geometry const>();
+
+        return resolve_strategy::is_simple::apply(geometry, strategy);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct is_simple<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Strategy>
+    struct visitor : boost::static_visitor<bool>
+    {
+        Strategy const& m_strategy;
+
+        visitor(Strategy const& strategy)
+            : m_strategy(strategy)
+        {}
+
+        template <typename Geometry>
+        bool operator()(Geometry const& geometry) const
+        {
+            return is_simple<Geometry>::apply(geometry, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline bool
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(strategy), geometry);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief \brief_check{is simple}
+\ingroup is_simple
+\tparam Geometry \tparam_geometry
+\tparam Strategy \tparam_strategy{Is_simple}
+\param geometry \param_geometry
+\param strategy \param_strategy{is_simple}
+\return \return_check{is simple}
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/is_simple.qbk]}
+*/
+template <typename Geometry, typename Strategy>
+inline bool is_simple(Geometry const& geometry, Strategy const& strategy)
+{
+    return resolve_variant::is_simple<Geometry>::apply(geometry, strategy);
+}
+
+
+/*!
+\brief \brief_check{is simple}
+\ingroup is_simple
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\return \return_check{is simple}
+
+\qbk{[include reference/algorithms/is_simple.qbk]}
+*/
+template <typename Geometry>
+inline bool is_simple(Geometry const& geometry)
+{
+    return resolve_variant::is_simple<Geometry>::apply(geometry, default_strategy());
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_INTERFACE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/linear.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/linear.hpp
new file mode 100644
index 00000000000..5acf56c5b1e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/linear.hpp
@@ -0,0 +1,363 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_LINEAR_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_LINEAR_HPP
+
+#include <algorithm>
+#include <deque>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/policies/predicate_based_interrupt_policy.hpp>
+#include <boost/geometry/policies/robustness/no_rescale_policy.hpp>
+#include <boost/geometry/policies/robustness/segment_ratio.hpp>
+
+#include <boost/geometry/algorithms/equals.hpp>
+#include <boost/geometry/algorithms/intersects.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/algorithms/detail/check_iterator_range.hpp>
+#include <boost/geometry/algorithms/detail/signed_size_type.hpp>
+
+#include <boost/geometry/algorithms/detail/disjoint/linear_linear.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_turn_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/self_turn_points.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/has_duplicates.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/has_spikes.hpp>
+
+#include <boost/geometry/algorithms/detail/is_simple/debug_print_boundary_points.hpp>
+#include <boost/geometry/algorithms/detail/is_simple/failure_policy.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/debug_print_turns.hpp>
+
+#include <boost/geometry/algorithms/dispatch/is_simple.hpp>
+
+#include <boost/geometry/strategies/intersection.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace is_simple
+{
+
+
+template <typename Turn>
+inline bool check_segment_indices(Turn const& turn,
+                                  signed_size_type last_index)
+{
+    return
+        (turn.operations[0].seg_id.segment_index == 0
+         && turn.operations[1].seg_id.segment_index == last_index)
+        ||
+        (turn.operations[0].seg_id.segment_index == 0
+         && turn.operations[1].seg_id.segment_index == last_index);
+}
+
+
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+class is_acceptable_turn
+    : not_implemented<Geometry>
+{};
+
+template <typename Linestring>
+class is_acceptable_turn<Linestring, linestring_tag>
+{
+public:
+    is_acceptable_turn(Linestring const& linestring)
+        : m_linestring(linestring)
+        , m_is_closed(geometry::equals(range::front(linestring),
+                                       range::back(linestring)))
+    {}
+
+    template <typename Turn>
+    inline bool apply(Turn const& turn) const
+    {
+        BOOST_GEOMETRY_ASSERT(boost::size(m_linestring) > 1);
+        return m_is_closed
+            && turn.method == overlay::method_none
+            && check_segment_indices(turn, boost::size(m_linestring) - 2)
+            && turn.operations[0].fraction.is_zero();
+    }
+
+private:
+    Linestring const& m_linestring;
+    bool const m_is_closed;
+};
+
+template <typename MultiLinestring>
+class is_acceptable_turn<MultiLinestring, multi_linestring_tag>
+{
+private:
+    typedef typename boost::range_value<MultiLinestring>::type linestring_type;
+    typedef is_acceptable_turn<linestring_type> base_type;
+
+    template <typename Point, typename Linestring>
+    static inline bool is_boundary_point_of(Point const& point,
+                                            Linestring const& linestring)
+    {
+        BOOST_GEOMETRY_ASSERT(boost::size(linestring) > 1);
+        return
+            ! geometry::equals(range::front(linestring),
+                               range::back(linestring))
+            &&
+            (geometry::equals(point, range::front(linestring))
+             || geometry::equals(point, range::back(linestring)));
+    }
+
+    template <typename Turn, typename Linestring>
+    static inline bool is_closing_point_of(Turn const& turn,
+                                           Linestring const& linestring)
+    {
+        BOOST_GEOMETRY_ASSERT(boost::size(linestring) > 1);
+        return
+            turn.method == overlay::method_none
+            &&
+            check_segment_indices(turn, boost::size(linestring) - 2)
+            &&
+            geometry::equals(range::front(linestring), range::back(linestring))
+            &&
+            turn.operations[0].fraction.is_zero();
+            ;
+    }
+
+    template <typename Linestring1, typename Linestring2>
+    static inline bool have_same_boundary_points(Linestring1 const& ls1,
+                                                 Linestring2 const& ls2)
+    {
+        return
+            geometry::equals(range::front(ls1), range::front(ls2))
+            ?
+            geometry::equals(range::back(ls1), range::back(ls2))
+            :
+            (geometry::equals(range::front(ls1), range::back(ls2))
+             &&
+             geometry::equals(range::back(ls1), range::front(ls2)))
+            ;
+    }
+
+public:
+    is_acceptable_turn(MultiLinestring const& multilinestring)
+        : m_multilinestring(multilinestring)
+    {}
+
+    template <typename Turn>
+    inline bool apply(Turn const& turn) const
+    {
+        linestring_type const& ls1 =
+            range::at(m_multilinestring, turn.operations[0].seg_id.multi_index);
+
+        linestring_type const& ls2 =
+            range::at(m_multilinestring, turn.operations[1].seg_id.multi_index);
+
+        if (turn.operations[0].seg_id.multi_index
+            == turn.operations[1].seg_id.multi_index)
+        {
+            return is_closing_point_of(turn, ls1);
+        }
+
+        return
+            is_boundary_point_of(turn.point, ls1)
+            && is_boundary_point_of(turn.point, ls2)
+            &&
+            ( boost::size(ls1) != 2
+              || boost::size(ls2) != 2
+              || ! have_same_boundary_points(ls1, ls2) );
+    }
+
+private:
+    MultiLinestring const& m_multilinestring;
+};
+
+
+template <typename Linear, typename Strategy>
+inline bool has_self_intersections(Linear const& linear, Strategy const& strategy)
+{
+    typedef typename point_type<Linear>::type point_type;
+
+    // compute self turns
+    typedef detail::overlay::turn_info
+        <
+            point_type,
+            geometry::segment_ratio
+                <
+                    typename geometry::coordinate_type<point_type>::type
+                >
+        > turn_info;
+
+    std::deque<turn_info> turns;
+
+    typedef detail::overlay::get_turn_info
+        <
+            detail::disjoint::assign_disjoint_policy
+        > turn_policy;
+
+    is_acceptable_turn<Linear> predicate(linear);
+    detail::overlay::predicate_based_interrupt_policy
+        <
+            is_acceptable_turn<Linear>
+        > interrupt_policy(predicate);
+
+    detail::self_get_turn_points::get_turns
+        <
+            false, turn_policy
+        >::apply(linear,
+                 strategy,
+                 detail::no_rescale_policy(),
+                 turns,
+                 interrupt_policy, 0);
+
+    detail::is_valid::debug_print_turns(turns.begin(), turns.end());
+    debug_print_boundary_points(linear);
+
+    return interrupt_policy.has_intersections;
+}
+
+
+template <typename Linestring, bool CheckSelfIntersections = true>
+struct is_simple_linestring
+{
+    template <typename Strategy>
+    static inline bool apply(Linestring const& linestring,
+                             Strategy const& strategy)
+    {
+        simplicity_failure_policy policy;
+        return ! boost::empty(linestring)
+            && ! detail::is_valid::has_duplicates
+                    <
+                        Linestring, closed
+                    >::apply(linestring, policy)
+            && ! detail::is_valid::has_spikes
+                    <
+                        Linestring, closed
+                    >::apply(linestring, policy, strategy.get_side_strategy());
+    }
+};
+
+template <typename Linestring>
+struct is_simple_linestring<Linestring, true>
+{
+    template <typename Strategy>
+    static inline bool apply(Linestring const& linestring,
+                             Strategy const& strategy)
+    {
+        return is_simple_linestring
+                <
+                    Linestring, false
+                >::apply(linestring, strategy)
+            && ! has_self_intersections(linestring, strategy);
+    }
+};
+
+
+template <typename MultiLinestring>
+struct is_simple_multilinestring
+{
+private:
+    template <typename Strategy>
+    struct per_linestring
+    {
+        per_linestring(Strategy const& strategy)
+            : m_strategy(strategy)
+        {}
+
+        template <typename Linestring>
+        inline bool apply(Linestring const& linestring) const
+        {
+            return detail::is_simple::is_simple_linestring
+                <
+                    Linestring,
+                    false // do not compute self-intersections
+                >::apply(linestring, m_strategy);
+        }
+
+        Strategy const& m_strategy;
+    };
+
+public:
+    template <typename Strategy>
+    static inline bool apply(MultiLinestring const& multilinestring,
+                             Strategy const& strategy)
+    {
+        typedef per_linestring<Strategy> per_ls;
+
+        // check each of the linestrings for simplicity
+        // but do not compute self-intersections yet; these will be
+        // computed for the entire multilinestring
+        if ( ! detail::check_iterator_range
+                 <
+                     per_ls, // do not compute self-intersections
+                     true // allow empty multilinestring
+                 >::apply(boost::begin(multilinestring),
+                          boost::end(multilinestring),
+                          per_ls(strategy))
+             )
+        {
+            return false;
+        }
+
+        return ! has_self_intersections(multilinestring, strategy);
+    }
+};
+
+
+
+}} // namespace detail::is_simple
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+// A linestring is a curve.
+// A curve is simple if it does not pass through the same point twice,
+// with the possible exception of its two endpoints
+//
+// Reference: OGC 06-103r4 (6.1.6.1)
+template <typename Linestring>
+struct is_simple<Linestring, linestring_tag>
+    : detail::is_simple::is_simple_linestring<Linestring>
+{};
+
+
+// A MultiLinestring is a MultiCurve
+// A MultiCurve is simple if all of its elements are simple and the
+// only intersections between any two elements occur at Points that
+// are on the boundaries of both elements.
+//
+// Reference: OGC 06-103r4 (6.1.8.1; Fig. 9)
+template <typename MultiLinestring>
+struct is_simple<MultiLinestring, multi_linestring_tag>
+    : detail::is_simple::is_simple_multilinestring<MultiLinestring>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_LINEAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/multipoint.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/multipoint.hpp
new file mode 100644
index 00000000000..61f0bc91309
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_simple/multipoint.hpp
@@ -0,0 +1,91 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_MULTIPOINT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_MULTIPOINT_HPP
+
+#include <algorithm>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/policies/compare.hpp>
+
+#include <boost/geometry/algorithms/detail/is_valid/has_duplicates.hpp>
+#include <boost/geometry/algorithms/detail/is_simple/failure_policy.hpp>
+
+#include <boost/geometry/algorithms/dispatch/is_simple.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace is_simple
+{
+
+
+template <typename MultiPoint>
+struct is_simple_multipoint
+{
+    template <typename Strategy>
+    static inline bool apply(MultiPoint const& multipoint, Strategy const&)
+    {
+        if (boost::empty(multipoint))
+        {
+            return true;
+        }
+
+        MultiPoint mp(multipoint);
+        std::sort(boost::begin(mp), boost::end(mp),
+                  geometry::less<typename point_type<MultiPoint>::type>());
+
+        simplicity_failure_policy policy;
+        return !detail::is_valid::has_duplicates
+            <
+                MultiPoint, closed
+            >::apply(mp, policy);
+    }
+};
+
+
+}} // namespace detail::is_simple
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// A MultiPoint is simple if no two Points in the MultiPoint are equal
+// (have identical coordinate values in X and Y)
+//
+// Reference: OGC 06-103r4 (6.1.5)
+template <typename MultiPoint>
+struct is_simple<MultiPoint, multi_point_tag>
+    : detail::is_simple::is_simple_multipoint<MultiPoint>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_SIMPLE_MULTIPOINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/box.hpp
new file mode 100644
index 00000000000..69a4d4e78ec
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/box.hpp
@@ -0,0 +1,115 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_BOX_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_BOX_HPP
+
+#include <cstddef>
+
+#include <boost/core/ignore_unused.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+
+#include <boost/geometry/algorithms/validity_failure_type.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/has_invalid_coordinate.hpp>
+#include <boost/geometry/algorithms/dispatch/is_valid.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace is_valid
+{
+
+template <typename Box, std::size_t I>
+struct has_valid_corners
+{
+    template <typename VisitPolicy>
+    static inline bool apply(Box const& box, VisitPolicy& visitor)
+    {
+        if (math::equals(geometry::get<geometry::min_corner, I-1>(box),
+                         geometry::get<geometry::max_corner, I-1>(box)))
+        {
+            return
+                visitor.template apply<failure_wrong_topological_dimension>();
+        }
+        else if (geometry::get<geometry::min_corner, I-1>(box)
+                 >
+                 geometry::get<geometry::max_corner, I-1>(box))
+        {
+            return visitor.template apply<failure_wrong_corner_order>();
+        }
+        return has_valid_corners<Box, I-1>::apply(box, visitor);
+    }
+};
+
+
+template <typename Box>
+struct has_valid_corners<Box, 0>
+{
+    template <typename VisitPolicy>
+    static inline bool apply(Box const&, VisitPolicy& visitor)
+    {
+        boost::ignore_unused(visitor);
+
+        return visitor.template apply<no_failure>();
+    }
+};
+
+
+template <typename Box>
+struct is_valid_box
+{
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(Box const& box, VisitPolicy& visitor, Strategy const&)
+    {
+        return
+            ! has_invalid_coordinate<Box>::apply(box, visitor)
+            &&
+            has_valid_corners<Box, dimension<Box>::value>::apply(box, visitor);
+    }
+};
+
+}} // namespace detail::is_valid
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// A box is always simple
+// A box is a Polygon, and it satisfies the conditions for Polygon validity.
+//
+// The only thing we have to check is whether the max corner lies in
+// the upper-right quadrant as defined by the min corner
+//
+// Reference (for polygon validity): OGC 06-103r4 (6.1.11.1)
+template <typename Box>
+struct is_valid<Box, box_tag>
+    : detail::is_valid::is_valid_box<Box>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/complement_graph.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/complement_graph.hpp
new file mode 100644
index 00000000000..f08e70242c5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/complement_graph.hpp
@@ -0,0 +1,239 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_COMPLEMENT_GRAPH_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_COMPLEMENT_GRAPH_HPP
+
+#include <cstddef>
+
+#include <set>
+#include <stack>
+#include <utility>
+#include <vector>
+
+#include <boost/core/addressof.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/policies/compare.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace detail { namespace is_valid
+{
+
+
+template <typename TurnPoint>
+class complement_graph_vertex
+{
+public:
+    complement_graph_vertex(std::size_t id)
+        : m_id(id)
+        , m_turn_point(NULL)
+    {}
+
+    complement_graph_vertex(TurnPoint const* turn_point,
+                            std::size_t expected_id)
+        : m_id(expected_id)
+        , m_turn_point(turn_point)
+    {}
+
+    inline std::size_t id() const { return m_id; }
+
+    inline bool operator<(complement_graph_vertex const& other) const
+    {
+        if ( m_turn_point != NULL && other.m_turn_point != NULL )
+        {
+            return geometry::less
+                <
+                    TurnPoint
+                >()(*m_turn_point, *other.m_turn_point);
+        }
+        if ( m_turn_point == NULL && other.m_turn_point == NULL )
+        {
+            return m_id < other.m_id;
+        }
+        return m_turn_point == NULL;
+    }
+
+private:
+    // the value of m_turn_point determines the type of the vertex
+    // non-NULL: vertex corresponds to an IP
+    // NULL    : vertex corresponds to a hole or outer space, and the id
+    //           is the ring id of the corresponding ring of the polygon
+    std::size_t m_id;
+    TurnPoint const* m_turn_point;
+};
+
+
+
+
+template <typename TurnPoint>
+class complement_graph
+{
+private:
+    typedef complement_graph_vertex<TurnPoint> vertex;
+    typedef std::set<vertex> vertex_container;
+
+public:
+    typedef typename vertex_container::const_iterator vertex_handle;
+
+private:
+    struct vertex_handle_less
+    {
+        inline bool operator()(vertex_handle v1, vertex_handle v2) const
+        {
+            return v1->id() < v2->id();
+        }
+    };
+
+    typedef std::set<vertex_handle, vertex_handle_less> neighbor_container;
+
+    class has_cycles_dfs_data
+    {
+    public:
+        has_cycles_dfs_data(std::size_t num_nodes)
+            : m_visited(num_nodes, false)
+            , m_parent_id(num_nodes, -1)
+        {}
+
+        inline signed_size_type parent_id(vertex_handle v) const
+        {
+            return m_parent_id[v->id()];
+        }
+
+        inline void set_parent_id(vertex_handle v, signed_size_type id)
+        {
+            m_parent_id[v->id()] = id;
+        }
+
+        inline bool visited(vertex_handle v) const
+        {
+            return m_visited[v->id()];
+        }
+
+        inline void set_visited(vertex_handle v, bool value)
+        {
+            m_visited[v->id()] = value;
+        }
+    private:
+        std::vector<bool> m_visited;
+        std::vector<signed_size_type> m_parent_id;
+    };
+
+
+    inline bool has_cycles(vertex_handle start_vertex,
+                           has_cycles_dfs_data& data) const
+    {
+        std::stack<vertex_handle> stack;
+        stack.push(start_vertex);
+
+        while ( !stack.empty() )
+        {
+            vertex_handle v = stack.top();
+            stack.pop();
+
+            data.set_visited(v, true);
+            for (typename neighbor_container::const_iterator nit
+                     = m_neighbors[v->id()].begin();
+                 nit != m_neighbors[v->id()].end(); ++nit)
+            {
+                if ( static_cast<signed_size_type>((*nit)->id()) != data.parent_id(v) )
+                {
+                    if ( data.visited(*nit) )
+                    {
+                        return true;
+                    }
+                    else
+                    {
+                        data.set_parent_id(*nit, static_cast<signed_size_type>(v->id()));
+                        stack.push(*nit);
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+public:
+    // num_rings: total number of rings, including the exterior ring
+    complement_graph(std::size_t num_rings)
+        : m_num_rings(num_rings)
+        , m_num_turns(0)
+        , m_vertices()
+        , m_neighbors(num_rings)
+    {}
+
+    // inserts a ring vertex in the graph and returns its handle
+    // ring id's are zero-based (so the first interior ring has id 1)
+    inline vertex_handle add_vertex(signed_size_type id)
+    {
+        return m_vertices.insert(vertex(static_cast<std::size_t>(id))).first;
+    }
+
+    // inserts an IP in the graph and returns its id
+    inline vertex_handle add_vertex(TurnPoint const& turn_point)
+    {
+        std::pair<vertex_handle, bool> res
+            = m_vertices.insert(vertex(boost::addressof(turn_point),
+                                       m_num_rings + m_num_turns)
+                                );
+
+        if ( res.second )
+        {
+            // a new element is inserted
+            m_neighbors.push_back(neighbor_container());
+            ++m_num_turns;
+        }
+        return res.first;
+    }
+
+    inline void add_edge(vertex_handle v1, vertex_handle v2)
+    {
+        BOOST_GEOMETRY_ASSERT( v1 != m_vertices.end() );
+        BOOST_GEOMETRY_ASSERT( v2 != m_vertices.end() );
+        m_neighbors[v1->id()].insert(v2);
+        m_neighbors[v2->id()].insert(v1);
+    }
+
+    inline bool has_cycles() const
+    {
+        // initialize all vertices as non-visited and with no parent set
+        // this is done by the constructor of has_cycles_dfs_data
+        has_cycles_dfs_data data(m_num_rings + m_num_turns);
+
+        // for each non-visited vertex, start a DFS from that vertex
+        for (vertex_handle it = m_vertices.begin();
+             it != m_vertices.end(); ++it)
+        {
+            if ( !data.visited(it) && has_cycles(it, data) )
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    template <typename OStream, typename TP>
+    friend inline
+    void debug_print_complement_graph(OStream&, complement_graph<TP> const&);
+
+private:
+    std::size_t m_num_rings, m_num_turns;
+    vertex_container m_vertices;
+    std::vector<neighbor_container> m_neighbors;
+};
+
+
+}} // namespace detail::is_valid
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_COMPLEMENT_GRAPH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/debug_complement_graph.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/debug_complement_graph.hpp
new file mode 100644
index 00000000000..60f597e2964
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/debug_complement_graph.hpp
@@ -0,0 +1,70 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_DEBUG_COMPLEMENT_GRAPH_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_DEBUG_COMPLEMENT_GRAPH_HPP
+
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+#include <iostream>
+#endif
+
+namespace boost { namespace geometry
+{
+
+namespace detail { namespace is_valid
+{
+
+
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+template <typename OutputStream, typename TurnPoint>
+inline void
+debug_print_complement_graph(OutputStream& os,
+                             complement_graph<TurnPoint> const& graph)
+{
+    typedef typename complement_graph<TurnPoint>::vertex_handle vertex_handle;
+
+    os << "num rings: " << graph.m_num_rings << std::endl;
+    os << "vertex ids: {";
+    for (vertex_handle it = graph.m_vertices.begin();
+         it != graph.m_vertices.end(); ++it)
+    {
+        os << " " << it->id();
+    }
+    os << " }" << std::endl;        
+
+    for (vertex_handle it = graph.m_vertices.begin();
+         it != graph.m_vertices.end(); ++it)
+    {
+        os << "neighbors of " << it->id() << ": {";
+        for (typename complement_graph
+                 <
+                     TurnPoint
+                 >::neighbor_container::const_iterator
+                 nit = graph.m_neighbors[it->id()].begin();
+             nit != graph.m_neighbors[it->id()].end(); ++nit)
+        {
+            os << " " << (*nit)->id();
+        }
+        os << "}" << std::endl;        
+    }
+}
+#else
+template <typename OutputStream, typename TurnPoint>
+inline void debug_print_complement_graph(OutputStream&,
+                                         complement_graph<TurnPoint> const&)
+{
+}
+#endif
+
+
+}} // namespace detail::is_valid
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_COMPLEMENT_GRAPH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/debug_print_turns.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/debug_print_turns.hpp
new file mode 100644
index 00000000000..ab99a9921b1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/debug_print_turns.hpp
@@ -0,0 +1,78 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_DEBUG_PRINT_TURNS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_DEBUG_PRINT_TURNS_HPP
+
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+#include <iostream>
+
+#include <boost/geometry/io/dsv/write.hpp>
+#include <boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp>
+#endif
+
+
+namespace boost { namespace geometry
+{
+
+namespace detail { namespace is_valid
+{
+
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+template <typename Turn>
+inline void debug_print_turn(Turn const& turn)
+{
+    std::cout << " ["
+              << geometry::method_char(turn.method)
+              << ","
+              << geometry::operation_char(turn.operations[0].operation)
+              << "/"
+              << geometry::operation_char(turn.operations[1].operation)
+              << " {"
+              << turn.operations[0].seg_id.multi_index
+              << ", "
+              << turn.operations[1].seg_id.multi_index
+              << "} {"
+              << turn.operations[0].seg_id.ring_index
+              << ", "
+              << turn.operations[1].seg_id.ring_index
+              << "} {"
+              << turn.operations[0].seg_id.segment_index
+              << ", "
+              << turn.operations[1].seg_id.segment_index
+              << "} "
+              << geometry::dsv(turn.point)
+              << "]";
+}
+
+template <typename TurnIterator>
+inline void debug_print_turns(TurnIterator first, TurnIterator beyond)
+{
+    std::cout << "turns:";
+    for (TurnIterator tit = first; tit != beyond; ++tit)
+    {
+        debug_print_turn(*tit);
+    }
+    std::cout << std::endl << std::endl;
+}
+#else
+template <typename Turn>
+inline void debug_print_turn(Turn const&)
+{}
+
+template <typename TurnIterator>
+inline void debug_print_turns(TurnIterator, TurnIterator)
+{}
+#endif // BOOST_GEOMETRY_TEST_DEBUG
+
+}} // namespace detail::is_valid
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_DEBUG_PRINT_TURNS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/debug_validity_phase.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/debug_validity_phase.hpp
new file mode 100644
index 00000000000..a10e0fe5966
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/debug_validity_phase.hpp
@@ -0,0 +1,68 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_DEBUG_VALIDITY_PHASE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_DEBUG_VALIDITY_PHASE_HPP
+
+#ifdef GEOMETRY_TEST_DEBUG
+#include <iostream>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+#endif
+
+
+namespace boost { namespace geometry
+{
+
+namespace detail { namespace is_valid
+{
+
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct debug_validity_phase
+{
+    static inline void apply(int)
+    {
+    }
+};
+
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+template <typename Polygon>
+struct debug_validity_phase<Polygon, polygon_tag>
+{
+    static inline void apply(int phase)
+    {
+        switch (phase)
+        {
+        case 1:
+            std::cout << "checking exterior ring..." << std::endl;
+            break;
+        case 2:
+            std::cout << "checking interior rings..." << std::endl;
+            break;
+        case 3:
+            std::cout << "computing and analyzing turns..." << std::endl;
+            break;
+        case 4:
+            std::cout << "checking if interior rings are inside "
+                      << "the exterior ring..." << std::endl;
+            break;
+        case 5:
+            std::cout << "checking connectivity of interior..." << std::endl;
+            break;
+        }
+    }
+};
+#endif
+
+}} // namespace detail::is_valid
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_DEBUG_VALIDITY_PHASE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/has_duplicates.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/has_duplicates.hpp
new file mode 100644
index 00000000000..685a4aac353
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/has_duplicates.hpp
@@ -0,0 +1,80 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_HAS_DUPLICATES_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_HAS_DUPLICATES_HPP
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/closure.hpp>
+
+#include <boost/geometry/policies/compare.hpp>
+#include <boost/geometry/policies/is_valid/default_policy.hpp>
+
+#include <boost/geometry/views/closeable_view.hpp>
+#include <boost/geometry/algorithms/validity_failure_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace is_valid
+{
+
+template <typename Range, closure_selector Closure>
+struct has_duplicates
+{
+    template <typename VisitPolicy>
+    static inline bool apply(Range const& range, VisitPolicy& visitor)
+    {
+        boost::ignore_unused(visitor);
+
+        typedef typename closeable_view<Range const, Closure>::type view_type;
+        typedef typename boost::range_const_iterator
+            <
+                view_type const
+            >::type const_iterator;
+
+        view_type view(range);
+
+        if ( boost::size(view) < 2 )
+        {
+            return ! visitor.template apply<no_failure>();
+        }
+
+        geometry::equal_to<typename boost::range_value<Range>::type> equal;
+
+        const_iterator it = boost::const_begin(view);
+        const_iterator next = it;
+        ++next;
+        for (; next != boost::const_end(view); ++it, ++next)
+        {
+            if ( equal(*it, *next) )
+            {
+                return ! visitor.template apply<failure_duplicate_points>(*it);
+            }
+        }
+        return ! visitor.template apply<no_failure>();
+    }
+};
+
+
+
+}} // namespace detail::is_valid
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_HAS_DUPLICATES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/has_invalid_coordinate.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/has_invalid_coordinate.hpp
new file mode 100644
index 00000000000..6e6823d62f3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/has_invalid_coordinate.hpp
@@ -0,0 +1,151 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_HAS_INVALID_COORDINATE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_HAS_INVALID_COORDINATE_HPP
+
+#include <cstddef>
+
+#include <boost/type_traits/is_floating_point.hpp>
+
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/util/has_non_finite_coordinate.hpp>
+
+#include <boost/geometry/iterators/point_iterator.hpp>
+#include <boost/geometry/views/detail/indexed_point_view.hpp>
+#include <boost/geometry/algorithms/detail/check_iterator_range.hpp>
+
+
+namespace boost { namespace geometry
+{
+    
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace is_valid
+{
+
+struct always_valid
+{
+    template <typename Geometry, typename VisitPolicy>
+    static inline bool apply(Geometry const&, VisitPolicy& visitor)
+    {
+        return ! visitor.template apply<no_failure>();
+    }
+};
+
+struct point_has_invalid_coordinate
+{
+    template <typename Point, typename VisitPolicy>
+    static inline bool apply(Point const& point, VisitPolicy& visitor)
+    {
+        boost::ignore_unused(visitor);
+
+        return
+            geometry::has_non_finite_coordinate(point)
+            ?
+            (! visitor.template apply<failure_invalid_coordinate>())
+            :
+            (! visitor.template apply<no_failure>());
+    }
+
+    template <typename Point>
+    static inline bool apply(Point const& point)
+    {
+        return geometry::has_non_finite_coordinate(point);
+    }
+};
+
+struct indexed_has_invalid_coordinate
+{
+    template <typename Geometry, typename VisitPolicy>
+    static inline bool apply(Geometry const& geometry, VisitPolicy& visitor)
+    {
+        geometry::detail::indexed_point_view<Geometry const, 0> p0(geometry);
+        geometry::detail::indexed_point_view<Geometry const, 1> p1(geometry);
+
+        return point_has_invalid_coordinate::apply(p0, visitor)
+            || point_has_invalid_coordinate::apply(p1, visitor);
+    }
+};
+
+
+struct range_has_invalid_coordinate
+{
+    struct point_has_valid_coordinates
+    {
+        template <typename Point>
+        static inline bool apply(Point const& point)
+        {
+            return ! point_has_invalid_coordinate::apply(point);
+        }
+    };
+
+    template <typename Geometry, typename VisitPolicy>
+    static inline bool apply(Geometry const& geometry, VisitPolicy& visitor)
+    {
+        boost::ignore_unused(visitor);
+
+        bool const has_valid_coordinates = detail::check_iterator_range
+            <
+                point_has_valid_coordinates,
+                true // do not consider an empty range as problematic
+            >::apply(geometry::points_begin(geometry),
+                     geometry::points_end(geometry));
+
+        return has_valid_coordinates
+            ?
+            (! visitor.template apply<no_failure>())
+            :
+            (! visitor.template apply<failure_invalid_coordinate>());
+    }
+};
+
+
+template
+<
+    typename Geometry,
+    typename Tag = typename tag<Geometry>::type,
+    bool HasFloatingPointCoordinates = boost::is_floating_point
+        <
+            typename coordinate_type<Geometry>::type
+        >::value
+>
+struct has_invalid_coordinate
+    : range_has_invalid_coordinate
+{};
+
+template <typename Geometry, typename Tag>
+struct has_invalid_coordinate<Geometry, Tag, false>
+    : always_valid
+{};
+
+template <typename Point>
+struct has_invalid_coordinate<Point, point_tag, true>
+    : point_has_invalid_coordinate
+{};
+
+template <typename Segment>
+struct has_invalid_coordinate<Segment, segment_tag, true>
+    : indexed_has_invalid_coordinate
+{};
+
+template <typename Box>
+struct has_invalid_coordinate<Box, box_tag, true>
+    : indexed_has_invalid_coordinate
+{};
+
+
+}} // namespace detail::is_valid
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_HAS_INVALID_COORDINATE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/has_spikes.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/has_spikes.hpp
new file mode 100644
index 00000000000..96efec79cdb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/has_spikes.hpp
@@ -0,0 +1,174 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_HAS_SPIKES_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_HAS_SPIKES_HPP
+
+#include <algorithm>
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/range.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/policies/is_valid/default_policy.hpp>
+
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/views/closeable_view.hpp>
+
+#include <boost/geometry/algorithms/equals.hpp>
+#include <boost/geometry/algorithms/validity_failure_type.hpp>
+#include <boost/geometry/algorithms/detail/point_is_spike_or_equal.hpp>
+#include <boost/geometry/io/dsv/write.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace is_valid
+{
+
+template <typename Point>
+struct equal_to
+{
+    Point const& m_point;
+
+    equal_to(Point const& point)
+        : m_point(point)
+    {}
+
+    template <typename OtherPoint>
+    inline bool operator()(OtherPoint const& other) const
+    {
+        return geometry::equals(m_point, other);
+    }
+};
+
+template <typename Point>
+struct not_equal_to
+{
+    Point const& m_point;
+
+    not_equal_to(Point const& point)
+        : m_point(point)
+    {}
+
+    template <typename OtherPoint>
+    inline bool operator()(OtherPoint const& other) const
+    {
+        return ! geometry::equals(other, m_point);
+    }
+};
+
+
+
+template <typename Range, closure_selector Closure>
+struct has_spikes
+{
+    template <typename Iterator>
+    static inline Iterator find_different_from_first(Iterator first,
+                                                     Iterator last)
+    {
+        typedef not_equal_to<typename point_type<Range>::type> not_equal;
+
+        BOOST_GEOMETRY_ASSERT(first != last);
+
+        Iterator second = first;
+        ++second;
+        return std::find_if(second, last, not_equal(*first));
+    }
+
+    template <typename VisitPolicy, typename SideStrategy>
+    static inline bool apply(Range const& range, VisitPolicy& visitor,
+                             SideStrategy const& strategy)
+    {
+        boost::ignore_unused(visitor);
+
+        typedef typename closeable_view<Range const, Closure>::type view_type;
+        typedef typename boost::range_iterator<view_type const>::type iterator; 
+
+        bool const is_linear
+            = boost::is_same<typename tag<Range>::type, linestring_tag>::value;
+
+        view_type const view(range);
+
+        iterator prev = boost::begin(view);
+
+        iterator cur = find_different_from_first(prev, boost::end(view));
+        if (cur == boost::end(view))
+        {
+            // the range has only one distinct point, so it
+            // cannot have a spike
+            return ! visitor.template apply<no_failure>();
+        }
+
+        iterator next = find_different_from_first(cur, boost::end(view));
+        if (next == boost::end(view))
+        {
+            // the range has only two distinct points, so it
+            // cannot have a spike
+            return ! visitor.template apply<no_failure>();
+        }
+
+        while (next != boost::end(view))
+        {
+            if ( geometry::detail::point_is_spike_or_equal(*prev, *next, *cur,
+                                                           strategy) )
+            {
+                return
+                    ! visitor.template apply<failure_spikes>(is_linear, *cur);
+            }
+            prev = cur;
+            cur = next;
+            next = find_different_from_first(cur, boost::end(view));
+        }
+
+        if (geometry::equals(range::front(view), range::back(view)))
+        {
+            iterator cur = boost::begin(view);
+            typename boost::range_reverse_iterator
+                <
+                    view_type const
+                >::type prev = find_different_from_first(boost::rbegin(view),
+                                                         boost::rend(view));
+
+            iterator next = find_different_from_first(cur, boost::end(view));
+            if (detail::point_is_spike_or_equal(*prev, *next, *cur, strategy))
+            {
+                return
+                    ! visitor.template apply<failure_spikes>(is_linear, *cur);
+            }
+            else
+            {
+                return ! visitor.template apply<no_failure>();
+            }
+        }
+
+        return ! visitor.template apply<no_failure>();
+    }
+};
+
+
+
+}} // namespace detail::is_valid
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_HAS_SPIKES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/has_valid_self_turns.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/has_valid_self_turns.hpp
new file mode 100644
index 00000000000..b36e9f38b75
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/has_valid_self_turns.hpp
@@ -0,0 +1,121 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_HAS_VALID_SELF_TURNS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_HAS_VALID_SELF_TURNS_HPP
+
+#include <vector>
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/policies/predicate_based_interrupt_policy.hpp>
+#include <boost/geometry/policies/robustness/segment_ratio_type.hpp>
+#include <boost/geometry/policies/robustness/get_rescale_policy.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/get_turn_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/self_turn_points.hpp>
+
+#include <boost/geometry/algorithms/detail/is_valid/is_acceptable_turn.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace is_valid
+{
+
+
+template
+<
+    typename Geometry,
+    typename IsAcceptableTurn = is_acceptable_turn<Geometry>
+>
+class has_valid_self_turns
+{
+private:
+    typedef typename point_type<Geometry>::type point_type;
+
+    typedef typename geometry::rescale_policy_type
+        <
+            point_type
+        >::type rescale_policy_type;
+
+    typedef detail::overlay::get_turn_info
+        <
+            detail::overlay::assign_null_policy
+        > turn_policy;
+
+public:
+    typedef detail::overlay::turn_info
+        <
+            point_type,
+            typename geometry::segment_ratio_type
+                <
+                    point_type,
+                    rescale_policy_type
+                >::type
+        > turn_type;
+
+    // returns true if all turns are valid
+    template <typename Turns, typename VisitPolicy, typename Strategy>
+    static inline bool apply(Geometry const& geometry,
+                             Turns& turns,
+                             VisitPolicy& visitor,
+                             Strategy const& strategy)
+    {
+        boost::ignore_unused(visitor);
+
+        rescale_policy_type robust_policy
+            = geometry::get_rescale_policy<rescale_policy_type>(geometry);
+
+        detail::overlay::stateless_predicate_based_interrupt_policy
+            <
+                IsAcceptableTurn
+            > interrupt_policy;
+
+        detail::self_get_turn_points::self_turns<false, turn_policy>(geometry,
+                                          strategy,
+                                          robust_policy,
+                                          turns,
+                                          interrupt_policy);
+
+        if (interrupt_policy.has_intersections)
+        {
+            BOOST_GEOMETRY_ASSERT(! boost::empty(turns));
+            return visitor.template apply<failure_self_intersections>(turns);
+        }
+        else
+        {
+            return visitor.template apply<no_failure>();
+        }
+    }
+
+    // returns true if all turns are valid
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(Geometry const& geometry, VisitPolicy& visitor, Strategy const& strategy)
+    {
+        std::vector<turn_type> turns;
+        return apply(geometry, turns, visitor, strategy);
+    }
+};
+
+
+}} // namespace detail::is_valid
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_HAS_VALID_SELF_TURNS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/implementation.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/implementation.hpp
new file mode 100644
index 00000000000..4a515a30736
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/implementation.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_IMPLEMENTATION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_IMPLEMENTATION_HPP
+
+#include <boost/geometry/algorithms/detail/is_valid/pointlike.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/linear.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/polygon.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/multipolygon.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/ring.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/segment.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/box.hpp>
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_IMPLEMENTATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/interface.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/interface.hpp
new file mode 100644
index 00000000000..ee013377c4b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/interface.hpp
@@ -0,0 +1,272 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_INTERFACE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_INTERFACE_HPP
+
+#include <sstream>
+#include <string>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/algorithms/dispatch/is_valid.hpp>
+#include <boost/geometry/policies/is_valid/default_policy.hpp>
+#include <boost/geometry/policies/is_valid/failing_reason_policy.hpp>
+#include <boost/geometry/policies/is_valid/failure_type_policy.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/strategies/intersection.hpp>
+
+
+namespace boost { namespace geometry
+{
+    
+namespace resolve_strategy
+{
+
+struct is_valid
+{
+    template <typename Geometry, typename VisitPolicy, typename Strategy>
+    static inline bool apply(Geometry const& geometry,
+                             VisitPolicy& visitor,
+                             Strategy const& strategy)
+    {
+        return dispatch::is_valid<Geometry>::apply(geometry, visitor, strategy);
+    }
+
+    template <typename Geometry, typename VisitPolicy>
+    static inline bool apply(Geometry const& geometry,
+                             VisitPolicy& visitor,
+                             default_strategy)
+    {
+        // NOTE: Currently the strategy is only used for Areal geometries
+        typedef typename strategy::intersection::services::default_strategy
+            <
+                typename cs_tag<Geometry>::type
+            >::type strategy_type;
+
+        return dispatch::is_valid<Geometry>::apply(geometry, visitor, strategy_type());
+    }
+};
+
+} // namespace resolve_strategy
+
+namespace resolve_variant
+{
+
+template <typename Geometry>
+struct is_valid
+{
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(Geometry const& geometry,
+                             VisitPolicy& visitor,
+                             Strategy const& strategy)
+    {
+        concepts::check<Geometry const>();
+
+        return resolve_strategy::is_valid::apply(geometry, visitor, strategy);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct is_valid<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename VisitPolicy, typename Strategy>
+    struct visitor : boost::static_visitor<bool>
+    {
+        visitor(VisitPolicy& policy, Strategy const& strategy)
+            : m_policy(policy)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Geometry>
+        bool operator()(Geometry const& geometry) const
+        {
+            return is_valid<Geometry>::apply(geometry, m_policy, m_strategy);
+        }
+
+        VisitPolicy& m_policy;
+        Strategy const& m_strategy;
+    };
+
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry,
+          VisitPolicy& policy_visitor,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<VisitPolicy, Strategy>(policy_visitor, strategy),
+                                    geometry);
+    }
+};
+
+} // namespace resolve_variant
+
+
+// Undocumented for now
+template <typename Geometry, typename VisitPolicy, typename Strategy>
+inline bool is_valid(Geometry const& geometry,
+                     VisitPolicy& visitor,
+                     Strategy const& strategy)
+{
+    return resolve_variant::is_valid<Geometry>::apply(geometry, visitor, strategy);
+}
+
+
+/*!
+\brief \brief_check{is valid (in the OGC sense)}
+\ingroup is_valid
+\tparam Geometry \tparam_geometry
+\tparam Strategy \tparam_strategy{Is_valid}
+\param geometry \param_geometry
+\param strategy \param_strategy{is_valid}
+\return \return_check{is valid (in the OGC sense);
+furthermore, the following geometries are considered valid:
+multi-geometries with no elements,
+linear geometries containing spikes,
+areal geometries with duplicate (consecutive) points}
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/is_valid.qbk]}
+*/
+template <typename Geometry, typename Strategy>
+inline bool is_valid(Geometry const& geometry, Strategy const& strategy)
+{
+    is_valid_default_policy<> visitor;
+    return resolve_variant::is_valid<Geometry>::apply(geometry, visitor, strategy);
+}
+
+/*!
+\brief \brief_check{is valid (in the OGC sense)}
+\ingroup is_valid
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\return \return_check{is valid (in the OGC sense);
+    furthermore, the following geometries are considered valid:
+    multi-geometries with no elements,
+    linear geometries containing spikes,
+    areal geometries with duplicate (consecutive) points}
+
+\qbk{[include reference/algorithms/is_valid.qbk]}
+*/
+template <typename Geometry>
+inline bool is_valid(Geometry const& geometry)
+{
+    return is_valid(geometry, default_strategy());
+}
+
+
+/*!
+\brief \brief_check{is valid (in the OGC sense)}
+\ingroup is_valid
+\tparam Geometry \tparam_geometry
+\tparam Strategy \tparam_strategy{Is_valid}
+\param geometry \param_geometry
+\param failure An enumeration value indicating that the geometry is
+    valid or not, and if not valid indicating the reason why
+\param strategy \param_strategy{is_valid}
+\return \return_check{is valid (in the OGC sense);
+    furthermore, the following geometries are considered valid:
+    multi-geometries with no elements,
+    linear geometries containing spikes,
+    areal geometries with duplicate (consecutive) points}
+
+\qbk{distinguish,with failure value and strategy}
+\qbk{[include reference/algorithms/is_valid_with_failure.qbk]}
+*/
+template <typename Geometry, typename Strategy>
+inline bool is_valid(Geometry const& geometry, validity_failure_type& failure, Strategy const& strategy)
+{
+    failure_type_policy<> visitor;
+    bool result = resolve_variant::is_valid<Geometry>::apply(geometry, visitor, strategy);
+    failure = visitor.failure();
+    return result;
+}
+
+/*!
+\brief \brief_check{is valid (in the OGC sense)}
+\ingroup is_valid
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\param failure An enumeration value indicating that the geometry is
+    valid or not, and if not valid indicating the reason why
+\return \return_check{is valid (in the OGC sense);
+    furthermore, the following geometries are considered valid:
+    multi-geometries with no elements,
+    linear geometries containing spikes,
+    areal geometries with duplicate (consecutive) points}
+
+\qbk{distinguish,with failure value}
+\qbk{[include reference/algorithms/is_valid_with_failure.qbk]}
+*/
+template <typename Geometry>
+inline bool is_valid(Geometry const& geometry, validity_failure_type& failure)
+{
+    return is_valid(geometry, failure, default_strategy());
+}
+
+
+/*!
+\brief \brief_check{is valid (in the OGC sense)}
+\ingroup is_valid
+\tparam Geometry \tparam_geometry
+\tparam Strategy \tparam_strategy{Is_valid}
+\param geometry \param_geometry
+\param message A string containing a message stating if the geometry
+    is valid or not, and if not valid a reason why
+\param strategy \param_strategy{is_valid}
+\return \return_check{is valid (in the OGC sense);
+    furthermore, the following geometries are considered valid:
+    multi-geometries with no elements,
+    linear geometries containing spikes,
+    areal geometries with duplicate (consecutive) points}
+
+\qbk{distinguish,with message and strategy}
+\qbk{[include reference/algorithms/is_valid_with_message.qbk]}
+*/
+template <typename Geometry, typename Strategy>
+inline bool is_valid(Geometry const& geometry, std::string& message, Strategy const& strategy)
+{
+    std::ostringstream stream;
+    failing_reason_policy<> visitor(stream);
+    bool result = resolve_variant::is_valid<Geometry>::apply(geometry, visitor, strategy);
+    message = stream.str();
+    return result;
+}
+
+/*!
+\brief \brief_check{is valid (in the OGC sense)}
+\ingroup is_valid
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\param message A string containing a message stating if the geometry
+    is valid or not, and if not valid a reason why
+\return \return_check{is valid (in the OGC sense);
+    furthermore, the following geometries are considered valid:
+    multi-geometries with no elements,
+    linear geometries containing spikes,
+    areal geometries with duplicate (consecutive) points}
+
+\qbk{distinguish,with message}
+\qbk{[include reference/algorithms/is_valid_with_message.qbk]}
+*/
+template <typename Geometry>
+inline bool is_valid(Geometry const& geometry, std::string& message)
+{
+    return is_valid(geometry, message, default_strategy());
+}
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_INTERFACE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/is_acceptable_turn.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/is_acceptable_turn.hpp
new file mode 100644
index 00000000000..fccc0ffdb72
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/is_acceptable_turn.hpp
@@ -0,0 +1,161 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_IS_ACCEPTABLE_TURN_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_IS_ACCEPTABLE_TURN_HPP
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/point_order.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace is_valid
+{
+
+
+template
+<
+    typename Geometry,
+    order_selector Order = geometry::point_order<Geometry>::value,
+    typename Tag = typename tag<Geometry>::type
+>
+struct acceptable_operation
+{};
+
+template <typename Polygon>
+struct acceptable_operation<Polygon, counterclockwise, polygon_tag>
+{
+    static const detail::overlay::operation_type value =
+        detail::overlay::operation_union;
+};
+
+template <typename Polygon>
+struct acceptable_operation<Polygon, clockwise, polygon_tag>
+{
+    static const detail::overlay::operation_type value =
+        detail::overlay::operation_intersection;
+};
+
+template <typename MultiPolygon>
+struct acceptable_operation<MultiPolygon, counterclockwise, multi_polygon_tag>
+{
+    static const detail::overlay::operation_type value =
+        detail::overlay::operation_intersection;
+};
+
+template <typename MultiPolygon>
+struct acceptable_operation<MultiPolygon, clockwise, multi_polygon_tag>
+{
+    static const detail::overlay::operation_type value =
+        detail::overlay::operation_union;
+};
+
+
+
+
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct is_acceptable_turn
+{};
+
+template <typename Ring>
+struct is_acceptable_turn<Ring, ring_tag>
+{
+    template <typename Turn>
+    static inline bool apply(Turn const&)
+    {
+        return false;
+    }
+};
+
+template <typename Polygon>
+class is_acceptable_turn<Polygon, polygon_tag>
+{
+protected:
+    template <typename Turn, typename Method, typename Operation>
+    static inline bool check_turn(Turn const& turn,
+                                  Method method,
+                                  Operation operation)
+    {
+        return turn.method == method
+            && turn.operations[0].operation == operation
+            && turn.operations[1].operation == operation;
+    }
+
+
+public:
+    template <typename Turn>
+    static inline bool apply(Turn const& turn)
+    {
+        using namespace detail::overlay;
+
+        if ( turn.operations[0].seg_id.ring_index
+             == turn.operations[1].seg_id.ring_index )
+        {
+            return false;
+        }
+
+        operation_type const op = acceptable_operation<Polygon>::value;
+
+        return check_turn(turn, method_touch_interior, op)
+            || check_turn(turn, method_touch, op)
+            ;
+    }
+};
+
+template <typename MultiPolygon>
+class is_acceptable_turn<MultiPolygon, multi_polygon_tag>
+    : is_acceptable_turn<typename boost::range_value<MultiPolygon>::type>
+{
+private:
+    typedef typename boost::range_value<MultiPolygon>::type polygon;
+    typedef is_acceptable_turn<polygon> base;
+
+public:
+    template <typename Turn>
+    static inline bool apply(Turn const& turn)
+    {
+        using namespace detail::overlay;
+
+        if ( turn.operations[0].seg_id.multi_index
+             == turn.operations[1].seg_id.multi_index )
+        {
+            return base::apply(turn);
+        }
+
+        operation_type const op = acceptable_operation<MultiPolygon>::value;
+        if ( base::check_turn(turn, method_touch_interior, op)
+          || base::check_turn(turn, method_touch, op))
+        {
+            return true;
+        }
+
+        // Turn is acceptable only in case of a touch(interior) and both lines
+        // (polygons) do not cross
+        return (turn.method == method_touch
+                || turn.method == method_touch_interior)
+                && turn.touch_only;
+    }
+};   
+
+
+}} // namespace detail::is_valid
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_IS_ACCEPTABLE_TURN_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/linear.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/linear.hpp
new file mode 100644
index 00000000000..39cb36ef5bf
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/linear.hpp
@@ -0,0 +1,186 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_LINEAR_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_LINEAR_HPP
+
+#include <cstddef>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/algorithms/equals.hpp>
+#include <boost/geometry/algorithms/validity_failure_type.hpp>
+#include <boost/geometry/algorithms/detail/check_iterator_range.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/has_invalid_coordinate.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/has_spikes.hpp>
+#include <boost/geometry/algorithms/detail/num_distinct_consecutive_points.hpp>
+
+#include <boost/geometry/algorithms/dispatch/is_valid.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace is_valid
+{
+
+
+template <typename Linestring>
+struct is_valid_linestring
+{
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(Linestring const& linestring,
+                             VisitPolicy& visitor,
+                             Strategy const& strategy)
+    {
+        if (has_invalid_coordinate<Linestring>::apply(linestring, visitor))
+        {
+            return false;
+        }
+
+        if (boost::size(linestring) < 2)
+        {
+            return visitor.template apply<failure_few_points>();
+        }
+
+        std::size_t num_distinct = detail::num_distinct_consecutive_points
+            <
+                Linestring,
+                3u,
+                true,
+                not_equal_to<typename point_type<Linestring>::type>
+            >::apply(linestring);
+
+        if (num_distinct < 2u)
+        {
+            return
+                visitor.template apply<failure_wrong_topological_dimension>();
+        }
+
+        if (num_distinct == 2u)
+        {
+            return visitor.template apply<no_failure>();
+        }
+
+        return ! has_spikes
+                    <
+                        Linestring, closed
+                    >::apply(linestring, visitor,
+                             strategy.get_side_strategy());
+    }
+};
+
+
+}} // namespace detail::is_valid
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// A linestring is a curve.
+// A curve is 1-dimensional so it has to have at least two distinct
+// points.
+// A curve is simple if it does not pass through the same point twice,
+// with the possible exception of its two endpoints
+//
+// There is an option here as to whether spikes are allowed for linestrings; 
+// here we pass this as an additional template parameter: allow_spikes
+// If allow_spikes is set to true, spikes are allowed, false otherwise.
+// By default, spikes are disallowed
+//
+// Reference: OGC 06-103r4 (6.1.6.1)
+template <typename Linestring, bool AllowEmptyMultiGeometries>
+struct is_valid
+    <
+        Linestring, linestring_tag, AllowEmptyMultiGeometries
+    > : detail::is_valid::is_valid_linestring<Linestring>
+{};
+
+
+// A MultiLinestring is a MultiCurve
+// A MultiCurve is simple if all of its elements are simple and the
+// only intersections between any two elements occur at Points that
+// are on the boundaries of both elements.
+//
+// Reference: OGC 06-103r4 (6.1.8.1; Fig. 9)
+template <typename MultiLinestring, bool AllowEmptyMultiGeometries>
+class is_valid
+    <
+        MultiLinestring, multi_linestring_tag, AllowEmptyMultiGeometries
+    >
+{
+private:
+    template <typename VisitPolicy, typename Strategy>
+    struct per_linestring
+    {
+        per_linestring(VisitPolicy& policy, Strategy const& strategy)
+            : m_policy(policy)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Linestring>
+        inline bool apply(Linestring const& linestring) const
+        {
+            return detail::is_valid::is_valid_linestring
+                <
+                    Linestring
+                >::apply(linestring, m_policy, m_strategy);
+        }
+
+        VisitPolicy& m_policy;
+        Strategy const& m_strategy;
+    };
+
+public:
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(MultiLinestring const& multilinestring,
+                             VisitPolicy& visitor,
+                             Strategy const& strategy)
+    {
+        if (BOOST_GEOMETRY_CONDITION(
+                AllowEmptyMultiGeometries && boost::empty(multilinestring)))
+        {
+            return visitor.template apply<no_failure>();
+        }
+
+        typedef per_linestring<VisitPolicy, Strategy> per_ls;
+
+        return detail::check_iterator_range
+            <
+                per_ls,
+                false // do not check for empty multilinestring (done above)
+            >::apply(boost::begin(multilinestring),
+                     boost::end(multilinestring),
+                     per_ls(visitor, strategy));
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_LINEAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/multipolygon.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/multipolygon.hpp
new file mode 100644
index 00000000000..ed24b138101
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/multipolygon.hpp
@@ -0,0 +1,402 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_MULTIPOLYGON_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_MULTIPOLYGON_HPP
+
+#include <deque>
+#include <vector>
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/iterator/filter_iterator.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/geometries/box.hpp>
+
+#include <boost/geometry/algorithms/validity_failure_type.hpp>
+#include <boost/geometry/algorithms/within.hpp>
+
+#include <boost/geometry/algorithms/detail/check_iterator_range.hpp>
+#include <boost/geometry/algorithms/detail/partition.hpp>
+
+#include <boost/geometry/algorithms/detail/is_valid/has_valid_self_turns.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/is_acceptable_turn.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/polygon.hpp>
+
+#include <boost/geometry/algorithms/detail/is_valid/debug_print_turns.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/debug_validity_phase.hpp>
+
+#include <boost/geometry/algorithms/dispatch/is_valid.hpp>
+
+#include <boost/geometry/strategies/intersection.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace is_valid
+{
+
+
+template <typename MultiPolygon, bool AllowEmptyMultiGeometries>
+class is_valid_multipolygon
+    : is_valid_polygon
+        <
+            typename boost::range_value<MultiPolygon>::type,
+            true // check only the validity of rings
+        >
+{
+private:
+    typedef is_valid_polygon
+        <
+            typename boost::range_value<MultiPolygon>::type,
+            true
+        > base;
+
+
+
+    template
+    <
+        typename PolygonIterator,
+        typename TurnIterator,
+        typename VisitPolicy,
+        typename Strategy
+    >
+    static inline
+    bool are_polygon_interiors_disjoint(PolygonIterator polygons_first,
+                                        PolygonIterator polygons_beyond,
+                                        TurnIterator turns_first,
+                                        TurnIterator turns_beyond,
+                                        VisitPolicy& visitor,
+                                        Strategy const& strategy)
+    {
+        boost::ignore_unused(visitor);
+
+        // collect all polygons that have crossing turns
+        std::set<signed_size_type> multi_indices;
+        for (TurnIterator tit = turns_first; tit != turns_beyond; ++tit)
+        {
+            if (! tit->touch_only)
+            {
+                multi_indices.insert(tit->operations[0].seg_id.multi_index);
+                multi_indices.insert(tit->operations[1].seg_id.multi_index);
+            }
+        }
+
+        typedef geometry::model::box<typename point_type<MultiPolygon>::type> box_type;
+        typedef typename base::template partition_item<PolygonIterator, box_type> item_type;
+
+        // put polygon iterators without turns in a vector
+        std::vector<item_type> polygon_iterators;
+        signed_size_type multi_index = 0;
+        for (PolygonIterator it = polygons_first; it != polygons_beyond;
+             ++it, ++multi_index)
+        {
+            if (multi_indices.find(multi_index) == multi_indices.end())
+            {
+                polygon_iterators.push_back(item_type(it));
+            }
+        }
+
+        // prepare strategies
+        typedef typename std::iterator_traits<PolygonIterator>::value_type polygon_type;
+        typedef typename Strategy::template point_in_geometry_strategy
+            <
+                polygon_type, polygon_type
+            >::type within_strategy_type;
+        within_strategy_type const within_strategy
+            = strategy.template get_point_in_geometry_strategy<polygon_type, polygon_type>();
+        typedef typename Strategy::envelope_strategy_type envelope_strategy_type;
+        envelope_strategy_type const envelope_strategy
+            = strategy.get_envelope_strategy();
+
+        // call partition to check if polygons are disjoint from each other
+        typename base::template item_visitor_type<within_strategy_type> item_visitor(within_strategy);
+
+        geometry::partition
+            <
+                geometry::model::box<typename point_type<MultiPolygon>::type>
+            >::apply(polygon_iterators, item_visitor,
+                     typename base::template expand_box<envelope_strategy_type>(envelope_strategy),
+                     typename base::template overlaps_box<envelope_strategy_type>(envelope_strategy));
+
+        if (item_visitor.items_overlap)
+        {
+            return visitor.template apply<failure_intersecting_interiors>();
+        }
+        else
+        {
+            return visitor.template apply<no_failure>();
+        }
+    }
+
+
+
+    class has_multi_index
+    {
+    public:
+        has_multi_index(signed_size_type multi_index)
+            : m_multi_index(multi_index)
+        {}
+
+        template <typename Turn>
+        inline bool operator()(Turn const& turn) const
+        {
+            return turn.operations[0].seg_id.multi_index == m_multi_index
+                && turn.operations[1].seg_id.multi_index == m_multi_index;
+        }
+
+    private:
+        signed_size_type const m_multi_index;
+    };
+
+
+
+    template <typename Predicate>
+    struct has_property_per_polygon
+    {
+        template
+        <
+            typename PolygonIterator,
+            typename TurnIterator,
+            typename VisitPolicy,
+            typename Strategy
+        >
+        static inline bool apply(PolygonIterator polygons_first,
+                                 PolygonIterator polygons_beyond,
+                                 TurnIterator turns_first,
+                                 TurnIterator turns_beyond,
+                                 VisitPolicy& visitor,
+                                 Strategy const& strategy)
+        {
+            signed_size_type multi_index = 0;
+            for (PolygonIterator it = polygons_first; it != polygons_beyond;
+                 ++it, ++multi_index)
+            {
+                has_multi_index index_predicate(multi_index);
+
+                typedef boost::filter_iterator
+                    <
+                        has_multi_index, TurnIterator
+                    > filtered_turn_iterator;
+
+                filtered_turn_iterator filtered_turns_first(index_predicate,
+                                                            turns_first,
+                                                            turns_beyond);
+
+                filtered_turn_iterator filtered_turns_beyond(index_predicate,
+                                                             turns_beyond,
+                                                             turns_beyond);
+
+                if (! Predicate::apply(*it,
+                                       filtered_turns_first,
+                                       filtered_turns_beyond,
+                                       visitor,
+                                       strategy))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+    };
+
+
+
+    template
+    <
+        typename PolygonIterator,
+        typename TurnIterator,
+        typename VisitPolicy,
+        typename Strategy
+    >
+    static inline bool have_holes_inside(PolygonIterator polygons_first,
+                                         PolygonIterator polygons_beyond,
+                                         TurnIterator turns_first,
+                                         TurnIterator turns_beyond,
+                                         VisitPolicy& visitor,
+                                         Strategy const& strategy)
+    {
+        return has_property_per_polygon
+            <
+                typename base::has_holes_inside
+            >::apply(polygons_first, polygons_beyond,
+                     turns_first, turns_beyond, visitor, strategy);
+    }
+
+
+
+    template
+    <
+        typename PolygonIterator,
+        typename TurnIterator,
+        typename VisitPolicy,
+        typename Strategy
+    >
+    static inline bool have_connected_interior(PolygonIterator polygons_first,
+                                               PolygonIterator polygons_beyond,
+                                               TurnIterator turns_first,
+                                               TurnIterator turns_beyond,
+                                               VisitPolicy& visitor,
+                                               Strategy const& strategy)
+    {
+        return has_property_per_polygon
+            <
+                typename base::has_connected_interior
+            >::apply(polygons_first, polygons_beyond,
+                     turns_first, turns_beyond, visitor, strategy);
+    }
+
+
+    template <typename VisitPolicy, typename Strategy>
+    struct per_polygon
+    {
+        per_polygon(VisitPolicy& policy, Strategy const& strategy)
+            : m_policy(policy)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Polygon>
+        inline bool apply(Polygon const& polygon) const
+        {
+            return base::apply(polygon, m_policy, m_strategy);
+        }
+
+        VisitPolicy& m_policy;
+        Strategy const& m_strategy;
+    };
+public:
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(MultiPolygon const& multipolygon,
+                             VisitPolicy& visitor,
+                             Strategy const& strategy)
+    {
+        typedef debug_validity_phase<MultiPolygon> debug_phase;
+
+        if (BOOST_GEOMETRY_CONDITION(
+                AllowEmptyMultiGeometries && boost::empty(multipolygon)))
+        {
+            return visitor.template apply<no_failure>();
+        }
+
+        // check validity of all polygons ring
+        debug_phase::apply(1);
+
+        if (! detail::check_iterator_range
+                  <
+                      per_polygon<VisitPolicy, Strategy>,
+                      false // do not check for empty multipolygon (done above)
+                  >::apply(boost::begin(multipolygon),
+                           boost::end(multipolygon),
+                           per_polygon<VisitPolicy, Strategy>(visitor, strategy)))
+        {
+            return false;
+        }
+
+
+        // compute turns and check if all are acceptable
+        debug_phase::apply(2);
+
+        typedef has_valid_self_turns<MultiPolygon> has_valid_turns;
+
+        std::deque<typename has_valid_turns::turn_type> turns;
+        bool has_invalid_turns =
+            ! has_valid_turns::apply(multipolygon, turns, visitor, strategy);
+        debug_print_turns(turns.begin(), turns.end());
+
+        if (has_invalid_turns)
+        {
+            return false;
+        }
+
+
+        // check if each polygon's interior rings are inside the
+        // exterior and not one inside the other
+        debug_phase::apply(3);
+
+        if (! have_holes_inside(boost::begin(multipolygon),
+                                boost::end(multipolygon),
+                                turns.begin(),
+                                turns.end(),
+                                visitor,
+                                strategy))
+        {
+            return false;
+        }
+
+
+        // check that each polygon's interior is connected
+        debug_phase::apply(4);
+
+        if (! have_connected_interior(boost::begin(multipolygon),
+                                      boost::end(multipolygon),
+                                      turns.begin(),
+                                      turns.end(),
+                                      visitor,
+                                      strategy))
+        {
+            return false;
+        }
+
+
+        // check if polygon interiors are disjoint
+        debug_phase::apply(5);
+        return are_polygon_interiors_disjoint(boost::begin(multipolygon),
+                                              boost::end(multipolygon),
+                                              turns.begin(),
+                                              turns.end(),
+                                              visitor,
+                                              strategy);
+    }
+};
+
+}} // namespace detail::is_valid
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// Not clear what the definition is.
+// Right now we check that each element is simple (in fact valid), and
+// that the MultiPolygon is also valid.
+//
+// Reference (for validity of MultiPolygons): OGC 06-103r4 (6.1.14)
+template <typename MultiPolygon, bool AllowEmptyMultiGeometries>
+struct is_valid
+    <
+        MultiPolygon, multi_polygon_tag, AllowEmptyMultiGeometries
+    > : detail::is_valid::is_valid_multipolygon
+        <
+            MultiPolygon, AllowEmptyMultiGeometries
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_MULTIPOLYGON_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/pointlike.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/pointlike.hpp
new file mode 100644
index 00000000000..f77f7a35eb9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/pointlike.hpp
@@ -0,0 +1,92 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_POINTLIKE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_POINTLIKE_HPP
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/validity_failure_type.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/has_invalid_coordinate.hpp>
+#include <boost/geometry/algorithms/dispatch/is_valid.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+// A point is always simple
+template <typename Point>
+struct is_valid<Point, point_tag>
+{
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(Point const& point, VisitPolicy& visitor, Strategy const&)
+    {
+        boost::ignore_unused(visitor);
+        return ! detail::is_valid::has_invalid_coordinate
+            <
+                Point
+            >::apply(point, visitor);
+    }
+};
+
+
+
+// A MultiPoint is simple if no two Points in the MultiPoint are equal
+// (have identical coordinate values in X and Y)
+//
+// Reference: OGC 06-103r4 (6.1.5)
+template <typename MultiPoint, bool AllowEmptyMultiGeometries>
+struct is_valid<MultiPoint, multi_point_tag, AllowEmptyMultiGeometries>
+{
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(MultiPoint const& multipoint,
+                             VisitPolicy& visitor,
+                             Strategy const&)
+    {
+        boost::ignore_unused(multipoint, visitor);
+
+        if (BOOST_GEOMETRY_CONDITION(
+                AllowEmptyMultiGeometries || !boost::empty(multipoint)))
+        {
+            // we allow empty multi-geometries, so an empty multipoint
+            // is considered valid
+            return ! detail::is_valid::has_invalid_coordinate
+                <
+                    MultiPoint
+                >::apply(multipoint, visitor);
+        }
+        else
+        {
+            // we do not allow an empty multipoint
+            return visitor.template apply<failure_few_points>();
+        }
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_POINTLIKE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/polygon.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/polygon.hpp
new file mode 100644
index 00000000000..5c6229b793f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/polygon.hpp
@@ -0,0 +1,531 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
+
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_POLYGON_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_POLYGON_HPP
+
+#include <cstddef>
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+#include <iostream>
+#endif // BOOST_GEOMETRY_TEST_DEBUG
+
+#include <algorithm>
+#include <deque>
+#include <iterator>
+#include <set>
+#include <vector>
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/geometries/box.hpp>
+
+#include <boost/geometry/iterators/point_iterator.hpp>
+
+#include <boost/geometry/algorithms/covered_by.hpp>
+#include <boost/geometry/algorithms/disjoint.hpp>
+#include <boost/geometry/algorithms/expand.hpp>
+#include <boost/geometry/algorithms/num_interior_rings.hpp>
+#include <boost/geometry/algorithms/validity_failure_type.hpp>
+#include <boost/geometry/algorithms/detail/point_on_border.hpp>
+#include <boost/geometry/algorithms/within.hpp>
+
+#include <boost/geometry/algorithms/detail/check_iterator_range.hpp>
+#include <boost/geometry/algorithms/detail/partition.hpp>
+
+#include <boost/geometry/algorithms/detail/is_valid/complement_graph.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/has_valid_self_turns.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/is_acceptable_turn.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/ring.hpp>
+
+#include <boost/geometry/algorithms/detail/is_valid/debug_print_turns.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/debug_validity_phase.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/debug_complement_graph.hpp>
+
+#include <boost/geometry/algorithms/dispatch/is_valid.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace is_valid
+{
+
+
+template <typename Polygon, bool CheckRingValidityOnly = false>
+class is_valid_polygon
+{
+protected:
+    typedef debug_validity_phase<Polygon> debug_phase;
+
+    template <typename VisitPolicy, typename Strategy>
+    struct per_ring
+    {
+        per_ring(VisitPolicy& policy, Strategy const& strategy)
+            : m_policy(policy)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Ring>
+        inline bool apply(Ring const& ring) const
+        {
+            return detail::is_valid::is_valid_ring
+                <
+                    Ring, false, true
+                >::apply(ring, m_policy, m_strategy);
+        }
+
+        VisitPolicy& m_policy;
+        Strategy const& m_strategy;
+    };
+
+    template <typename InteriorRings, typename VisitPolicy, typename Strategy>
+    static bool has_valid_interior_rings(InteriorRings const& interior_rings,
+                                         VisitPolicy& visitor,
+                                         Strategy const& strategy)
+    {
+        return
+            detail::check_iterator_range
+                <
+                    per_ring<VisitPolicy, Strategy>,
+                    true // allow for empty interior ring range
+                >::apply(boost::begin(interior_rings),
+                         boost::end(interior_rings),
+                         per_ring<VisitPolicy, Strategy>(visitor, strategy));
+    }
+
+    struct has_valid_rings
+    {
+        template <typename VisitPolicy, typename Strategy>
+        static inline bool apply(Polygon const& polygon,
+                                 VisitPolicy& visitor,
+                                 Strategy const& strategy)
+        {
+            typedef typename ring_type<Polygon>::type ring_type;
+
+            // check validity of exterior ring
+            debug_phase::apply(1);
+
+            if (! detail::is_valid::is_valid_ring
+                     <
+                         ring_type,
+                         false // do not check self intersections
+                     >::apply(exterior_ring(polygon), visitor, strategy))
+            {
+                return false;
+            }
+
+            // check validity of interior rings
+            debug_phase::apply(2);
+
+            return has_valid_interior_rings(geometry::interior_rings(polygon),
+                                            visitor,
+                                            strategy);
+        }
+    };
+
+
+    // Iterator value_type is a Ring or Polygon
+    template <typename Iterator, typename Box>
+    struct partition_item
+    {
+        explicit partition_item(Iterator it)
+            : m_it(it)
+            , m_is_initialized(false)
+        {}
+
+        Iterator get() const
+        {
+            return m_it;
+        }
+
+        template <typename EnvelopeStrategy>
+        Box const& get_envelope(EnvelopeStrategy const& strategy) const
+        {
+            if (! m_is_initialized)
+            {
+                m_box = geometry::return_envelope<Box>(*m_it, strategy);
+                m_is_initialized = true;
+            }
+            return m_box;
+        }
+
+    private:
+        Iterator m_it;
+        mutable Box m_box;
+        mutable bool m_is_initialized;
+    };
+
+    // structs for partition -- start
+    template <typename EnvelopeStrategy>
+    struct expand_box
+    {
+        explicit expand_box(EnvelopeStrategy const& strategy) : m_strategy(strategy) {}
+
+        template <typename Box, typename Iterator>
+        inline void apply(Box& total, partition_item<Iterator, Box> const& item) const
+        {
+            geometry::expand(total, item.get_envelope(m_strategy));
+        }
+
+        EnvelopeStrategy const& m_strategy;
+    };
+
+    template <typename EnvelopeStrategy>
+    struct overlaps_box
+    {
+        explicit overlaps_box(EnvelopeStrategy const& strategy) : m_strategy(strategy) {}
+
+        template <typename Box, typename Iterator>
+        inline bool apply(Box const& box, partition_item<Iterator, Box> const& item) const
+        {
+            return ! geometry::disjoint(item.get_envelope(m_strategy), box);
+        }
+
+        EnvelopeStrategy const& m_strategy;
+    };
+
+
+    template <typename WithinStrategy>
+    struct item_visitor_type
+    {
+        bool items_overlap;
+        WithinStrategy const& m_strategy;
+
+        explicit item_visitor_type(WithinStrategy const& strategy)
+            : items_overlap(false)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Item>
+        inline bool is_within(Item const& first, Item const& second)
+        {
+            typename point_type<Polygon>::type point;
+            typedef detail::point_on_border::point_on_range<true> pob;
+
+            // TODO: this should check for a point on the interior, instead
+            // of on border. Or it should check using the overlap function.
+
+            return pob::apply(point, points_begin(first), points_end(first))
+                    && geometry::within(point, second, m_strategy);
+        }
+
+        template <typename Iterator, typename Box>
+        inline bool apply(partition_item<Iterator, Box> const& item1,
+                          partition_item<Iterator, Box> const& item2)
+        {
+            if (! items_overlap
+                && (is_within(*item1.get(), *item2.get())
+                  || is_within(*item2.get(), *item1.get())))
+            {
+                items_overlap = true;
+                return false; // interrupt
+            }
+            return true;
+        }
+    };
+    // structs for partition -- end
+
+
+    template
+    <
+        typename RingIterator,
+        typename ExteriorRing,
+        typename TurnIterator,
+        typename VisitPolicy,
+        typename Strategy
+    >
+    static inline bool are_holes_inside(RingIterator rings_first,
+                                        RingIterator rings_beyond,
+                                        ExteriorRing const& exterior_ring,
+                                        TurnIterator turns_first,
+                                        TurnIterator turns_beyond,
+                                        VisitPolicy& visitor,
+                                        Strategy const& strategy)
+    {
+        boost::ignore_unused(visitor);
+
+        // collect the interior ring indices that have turns with the
+        // exterior ring
+        std::set<signed_size_type> ring_indices;
+        for (TurnIterator tit = turns_first; tit != turns_beyond; ++tit)
+        {
+            if (tit->operations[0].seg_id.ring_index == -1)
+            {
+                BOOST_GEOMETRY_ASSERT(tit->operations[1].seg_id.ring_index != -1);
+                ring_indices.insert(tit->operations[1].seg_id.ring_index);
+            }
+            else if (tit->operations[1].seg_id.ring_index == -1)
+            {
+                BOOST_GEOMETRY_ASSERT(tit->operations[0].seg_id.ring_index != -1);
+                ring_indices.insert(tit->operations[0].seg_id.ring_index);
+            }
+        }
+
+        // prepare strategy
+        typedef typename std::iterator_traits<RingIterator>::value_type inter_ring_type;
+        typename Strategy::template point_in_geometry_strategy
+            <
+                inter_ring_type, ExteriorRing
+            >::type const in_exterior_strategy
+            = strategy.template get_point_in_geometry_strategy<inter_ring_type, ExteriorRing>();
+
+        signed_size_type ring_index = 0;
+        for (RingIterator it = rings_first; it != rings_beyond;
+             ++it, ++ring_index)
+        {
+            // do not examine interior rings that have turns with the
+            // exterior ring
+            if (ring_indices.find(ring_index) == ring_indices.end()
+                && ! geometry::covered_by(range::front(*it), exterior_ring, in_exterior_strategy))
+            {
+                return visitor.template apply<failure_interior_rings_outside>();
+            }
+        }
+
+        // collect all rings (exterior and/or interior) that have turns
+        for (TurnIterator tit = turns_first; tit != turns_beyond; ++tit)
+        {
+            ring_indices.insert(tit->operations[0].seg_id.ring_index);
+            ring_indices.insert(tit->operations[1].seg_id.ring_index);
+        }
+
+        typedef geometry::model::box<typename point_type<Polygon>::type> box_type;
+        typedef partition_item<RingIterator, box_type> item_type;
+
+        // put iterators for interior rings without turns in a vector
+        std::vector<item_type> ring_iterators;
+        ring_index = 0;
+        for (RingIterator it = rings_first; it != rings_beyond;
+             ++it, ++ring_index)
+        {
+            if (ring_indices.find(ring_index) == ring_indices.end())
+            {
+                ring_iterators.push_back(item_type(it));
+            }
+        }
+
+        // prepare strategies
+        typedef typename Strategy::template point_in_geometry_strategy
+            <
+                inter_ring_type, inter_ring_type
+            >::type in_interior_strategy_type;
+        in_interior_strategy_type const in_interior_strategy
+            = strategy.template get_point_in_geometry_strategy<inter_ring_type, inter_ring_type>();
+        typedef typename Strategy::envelope_strategy_type envelope_strategy_type;
+        envelope_strategy_type const envelope_strategy
+            = strategy.get_envelope_strategy();
+
+        // call partition to check if interior rings are disjoint from
+        // each other
+        item_visitor_type<in_interior_strategy_type> item_visitor(in_interior_strategy);
+
+        geometry::partition
+            <
+                box_type
+            >::apply(ring_iterators, item_visitor,
+                     expand_box<envelope_strategy_type>(envelope_strategy),
+                     overlaps_box<envelope_strategy_type>(envelope_strategy));
+
+        if (item_visitor.items_overlap)
+        {
+            return visitor.template apply<failure_nested_interior_rings>();
+        }
+        else
+        {
+            return visitor.template apply<no_failure>();
+        }
+    }
+
+    template
+    <
+        typename InteriorRings,
+        typename ExteriorRing,
+        typename TurnIterator,
+        typename VisitPolicy,
+        typename Strategy
+    >
+    static inline bool are_holes_inside(InteriorRings const& interior_rings,
+                                        ExteriorRing const& exterior_ring,
+                                        TurnIterator first,
+                                        TurnIterator beyond,
+                                        VisitPolicy& visitor,
+                                        Strategy const& strategy)
+    {
+        return are_holes_inside(boost::begin(interior_rings),
+                                boost::end(interior_rings),
+                                exterior_ring,
+                                first,
+                                beyond,
+                                visitor,
+                                strategy);
+    }
+
+    struct has_holes_inside
+    {    
+        template <typename TurnIterator, typename VisitPolicy, typename Strategy>
+        static inline bool apply(Polygon const& polygon,
+                                 TurnIterator first,
+                                 TurnIterator beyond,
+                                 VisitPolicy& visitor,
+                                 Strategy const& strategy)
+        {
+            return are_holes_inside(geometry::interior_rings(polygon),
+                                    geometry::exterior_ring(polygon),
+                                    first,
+                                    beyond,
+                                    visitor,
+                                    strategy);
+        }
+    };
+
+
+
+
+    struct has_connected_interior
+    {
+        template <typename TurnIterator, typename VisitPolicy, typename Strategy>
+        static inline bool apply(Polygon const& polygon,
+                                 TurnIterator first,
+                                 TurnIterator beyond,
+                                 VisitPolicy& visitor,
+                                 Strategy const& )
+        {
+            boost::ignore_unused(visitor);
+
+            typedef typename std::iterator_traits
+                <
+                    TurnIterator
+                >::value_type turn_type;
+            typedef complement_graph<typename turn_type::point_type> graph;
+
+            graph g(geometry::num_interior_rings(polygon) + 1);
+            for (TurnIterator tit = first; tit != beyond; ++tit)
+            {
+                typename graph::vertex_handle v1 = g.add_vertex
+                    ( tit->operations[0].seg_id.ring_index + 1 );
+                typename graph::vertex_handle v2 = g.add_vertex
+                    ( tit->operations[1].seg_id.ring_index + 1 );
+                typename graph::vertex_handle vip = g.add_vertex(tit->point);
+
+                g.add_edge(v1, vip);
+                g.add_edge(v2, vip);
+            }
+
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+            debug_print_complement_graph(std::cout, g);
+#endif // BOOST_GEOMETRY_TEST_DEBUG
+
+            if (g.has_cycles())
+            {
+                return visitor.template apply<failure_disconnected_interior>();
+            }
+            else
+            {
+                return visitor.template apply<no_failure>();
+            }
+        }
+    };
+
+public:
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(Polygon const& polygon,
+                             VisitPolicy& visitor,
+                             Strategy const& strategy)
+    {
+        if (! has_valid_rings::apply(polygon, visitor, strategy))
+        {
+            return false;
+        }
+
+        if (BOOST_GEOMETRY_CONDITION(CheckRingValidityOnly))
+        {
+            return true;
+        }
+
+        // compute turns and check if all are acceptable
+        debug_phase::apply(3);
+
+        typedef has_valid_self_turns<Polygon> has_valid_turns;
+
+        std::deque<typename has_valid_turns::turn_type> turns;
+        bool has_invalid_turns
+            = ! has_valid_turns::apply(polygon, turns, visitor, strategy);
+        debug_print_turns(turns.begin(), turns.end());
+
+        if (has_invalid_turns)
+        {
+            return false;
+        }
+
+        // check if all interior rings are inside the exterior ring
+        debug_phase::apply(4);
+
+        if (! has_holes_inside::apply(polygon,
+                                      turns.begin(), turns.end(),
+                                      visitor,
+                                      strategy))
+        {
+            return false;
+        }
+
+        // check whether the interior of the polygon is a connected set
+        debug_phase::apply(5);
+
+        return has_connected_interior::apply(polygon,
+                                             turns.begin(),
+                                             turns.end(),
+                                             visitor,
+                                             strategy);
+    }
+};
+
+
+}} // namespace detail::is_valid
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// A Polygon is always a simple geometric object provided that it is valid.
+//
+// Reference (for validity of Polygons): OGC 06-103r4 (6.1.11.1)
+template <typename Polygon, bool AllowEmptyMultiGeometries>
+struct is_valid
+    <
+        Polygon, polygon_tag, AllowEmptyMultiGeometries
+    > : detail::is_valid::is_valid_polygon<Polygon>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_POLYGON_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/ring.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/ring.hpp
new file mode 100644
index 00000000000..0b959504301
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/ring.hpp
@@ -0,0 +1,237 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_RING_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_RING_HPP
+
+#include <deque>
+
+#include <boost/core/ignore_unused.hpp>
+
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/point_order.hpp>
+
+#include <boost/geometry/util/order_as_direction.hpp>
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/algorithms/equals.hpp>
+
+#include <boost/geometry/views/closeable_view.hpp>
+
+#include <boost/geometry/algorithms/area.hpp>
+#include <boost/geometry/algorithms/intersects.hpp>
+#include <boost/geometry/algorithms/validity_failure_type.hpp>
+#include <boost/geometry/algorithms/detail/num_distinct_consecutive_points.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/has_duplicates.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/has_invalid_coordinate.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/has_spikes.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/has_valid_self_turns.hpp>
+
+#include <boost/geometry/strategies/area.hpp>
+
+#ifdef BOOST_GEOMETRY_TEST_DEBUG
+#include <boost/geometry/io/dsv/write.hpp>
+#endif
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace is_valid
+{
+
+
+// struct to check whether a ring is topologically closed
+template <typename Ring, closure_selector Closure /* open */>
+struct is_topologically_closed
+{
+    template <typename VisitPolicy>
+    static inline bool apply(Ring const&, VisitPolicy& visitor)
+    {
+        boost::ignore_unused(visitor);
+
+        return visitor.template apply<no_failure>();
+    }
+};
+
+template <typename Ring>
+struct is_topologically_closed<Ring, closed>
+{
+    template <typename VisitPolicy>
+    static inline bool apply(Ring const& ring, VisitPolicy& visitor)
+    {
+        boost::ignore_unused(visitor);
+
+        if (geometry::equals(range::front(ring), range::back(ring)))
+        {
+            return visitor.template apply<no_failure>();
+        }
+        else
+        {
+            return visitor.template apply<failure_not_closed>();
+        }
+    }
+};
+
+
+
+template <typename ResultType, bool IsInteriorRing /* false */>
+struct ring_area_predicate
+{
+    typedef std::greater<ResultType> type;
+};
+
+template <typename ResultType>
+struct ring_area_predicate<ResultType, true>
+{
+    typedef std::less<ResultType> type;
+};
+
+
+
+template <typename Ring, bool IsInteriorRing>
+struct is_properly_oriented
+{
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(Ring const& ring, VisitPolicy& visitor,
+                             Strategy const& strategy)
+    {
+        boost::ignore_unused(visitor);
+
+        typedef typename point_type<Ring>::type point_type;
+
+        typedef detail::area::ring_area
+            <
+                order_as_direction<geometry::point_order<Ring>::value>::value,
+                geometry::closure<Ring>::value
+            > ring_area_type;
+
+        typedef typename Strategy::template area_strategy
+            <
+                point_type
+            >::type::return_type area_result_type;
+
+        typename ring_area_predicate
+            <
+                area_result_type, IsInteriorRing
+            >::type predicate;
+
+        // Check area
+        area_result_type const zero = 0;
+        area_result_type const area
+            = ring_area_type::apply(ring,
+                                    strategy.template get_area_strategy<point_type>());
+        if (predicate(area, zero))
+        {
+            return visitor.template apply<no_failure>();
+        }
+        else
+        {
+            return visitor.template apply<failure_wrong_orientation>();
+        }
+    }
+};
+
+
+
+template
+<
+    typename Ring,
+    bool CheckSelfIntersections = true,
+    bool IsInteriorRing = false
+>
+struct is_valid_ring
+{
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(Ring const& ring, VisitPolicy& visitor,
+                             Strategy const& strategy)
+    {
+        // return invalid if any of the following condition holds:
+        // (a) the ring's point coordinates are not invalid (e.g., NaN)
+        // (b) the ring's size is below the minimal one
+        // (c) the ring consists of at most two distinct points
+        // (d) the ring is not topologically closed
+        // (e) the ring has spikes
+        // (f) the ring has duplicate points (if AllowDuplicates is false)
+        // (g) the boundary of the ring has self-intersections
+        // (h) the order of the points is inconsistent with the defined order
+        //
+        // Note: no need to check if the area is zero. If this is the
+        // case, then the ring must have at least two spikes, which is
+        // checked by condition (d).
+
+        if (has_invalid_coordinate<Ring>::apply(ring, visitor))
+        {
+            return false;
+        }
+
+        closure_selector const closure = geometry::closure<Ring>::value;
+        typedef typename closeable_view<Ring const, closure>::type view_type;
+
+        if (boost::size(ring)
+            < core_detail::closure::minimum_ring_size<closure>::value)
+        {
+            return visitor.template apply<failure_few_points>();
+        }
+
+        view_type const view(ring);
+        if (detail::num_distinct_consecutive_points
+                <
+                    view_type, 4u, true,
+                    not_equal_to<typename point_type<Ring>::type>
+                >::apply(view)
+            < 4u)
+        {
+            return
+                visitor.template apply<failure_wrong_topological_dimension>();
+        }
+
+        return
+            is_topologically_closed<Ring, closure>::apply(ring, visitor)
+            && ! has_duplicates<Ring, closure>::apply(ring, visitor)
+            && ! has_spikes<Ring, closure>::apply(ring, visitor, strategy.get_side_strategy())
+            && (! CheckSelfIntersections
+                || has_valid_self_turns<Ring>::apply(ring, visitor, strategy))
+            && is_properly_oriented<Ring, IsInteriorRing>::apply(ring, visitor, strategy);
+    }
+};
+
+
+}} // namespace detail::is_valid
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+// A Ring is a Polygon with exterior boundary only.
+// The Ring's boundary must be a LinearRing (see OGC 06-103-r4,
+// 6.1.7.1, for the definition of LinearRing)
+//
+// Reference (for polygon validity): OGC 06-103r4 (6.1.11.1)
+template <typename Ring, bool AllowEmptyMultiGeometries>
+struct is_valid
+    <
+        Ring, ring_tag, AllowEmptyMultiGeometries
+    > : detail::is_valid::is_valid_ring<Ring>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_RING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/segment.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/segment.hpp
new file mode 100644
index 00000000000..30cbf7afdb3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/is_valid/segment.hpp
@@ -0,0 +1,83 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_SEGMENT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_SEGMENT_HPP
+
+#include <boost/core/ignore_unused.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/algorithms/equals.hpp>
+#include <boost/geometry/algorithms/validity_failure_type.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/has_invalid_coordinate.hpp>
+#include <boost/geometry/algorithms/dispatch/is_valid.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// A segment is a curve.
+// A curve is simple if it does not pass through the same point twice,
+// with the possible exception of its two endpoints
+// A curve is 1-dimensional, hence we have to check is the two
+// endpoints of the segment coincide, since in this case it is
+// 0-dimensional.
+//
+// Reference: OGC 06-103r4 (6.1.6.1)
+template <typename Segment>
+struct is_valid<Segment, segment_tag>
+{
+    template <typename VisitPolicy, typename Strategy>
+    static inline bool apply(Segment const& segment, VisitPolicy& visitor, Strategy const&)
+    {
+        boost::ignore_unused(visitor);
+
+        typename point_type<Segment>::type p[2];
+        detail::assign_point_from_index<0>(segment, p[0]);
+        detail::assign_point_from_index<1>(segment, p[1]);
+
+        if (detail::is_valid::has_invalid_coordinate
+                <
+                    Segment
+                >::apply(segment, visitor))
+        {
+            return false;
+        }
+        else if (! geometry::equals(p[0], p[1]))
+        {
+            return visitor.template apply<no_failure>();
+        }
+        else
+        {
+            return
+                visitor.template apply<failure_wrong_topological_dimension>();
+        }
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_IS_VALID_SEGMENT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/max_interval_gap.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/max_interval_gap.hpp
new file mode 100644
index 00000000000..e8a70a6b5f5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/max_interval_gap.hpp
@@ -0,0 +1,278 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_MAX_INTERVAL_GAP_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_MAX_INTERVAL_GAP_HPP
+
+#include <cstddef>
+#include <queue>
+#include <utility>
+#include <vector>
+
+#include <boost/core/ref.hpp>
+#include <boost/range.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/algorithms/detail/sweep.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace max_interval_gap
+{
+
+// the class Interval must provide the following:
+// * must define the type value_type
+// * must define the type difference_type
+// * must have the methods:
+//   value_type get<Index>() const
+//   difference_type length() const
+// where an Index value of 0 (resp., 1) refers to the left (resp.,
+// right) endpoint of the interval
+
+template <typename Interval>
+class sweep_event
+{
+public:
+    typedef Interval interval_type;
+    typedef typename Interval::value_type time_type;
+
+    sweep_event(Interval const& interval, bool start_event = true)
+        : m_interval(boost::cref(interval))
+        , m_start_event(start_event)
+    {}
+
+    inline bool is_start_event() const
+    {
+        return m_start_event;
+    }
+
+    inline interval_type const& interval() const
+    {
+        return m_interval;
+    }
+
+    inline time_type time() const
+    {
+        return (m_start_event)
+            ? interval().template get<0>()
+            : interval().template get<1>();
+    }
+
+    inline bool operator<(sweep_event const& other) const
+    {
+        if (! math::equals(time(), other.time()))
+        {
+            return time() < other.time();
+        }
+        // a start-event is before an end-event with the same event time
+        return is_start_event() && ! other.is_start_event();
+    }
+
+private:
+    boost::reference_wrapper<Interval const> m_interval;
+    bool m_start_event;
+};
+
+template <typename Event>
+struct event_greater
+{
+    inline bool operator()(Event const& event1, Event const& event2) const
+    {
+        return event2 < event1;
+    }
+};
+
+
+struct initialization_visitor
+{
+    template <typename Range, typename PriorityQueue, typename EventVisitor>
+    static inline void apply(Range const& range,
+                             PriorityQueue& queue,
+                             EventVisitor&)
+    {
+        BOOST_GEOMETRY_ASSERT(queue.empty());
+
+        // it is faster to build the queue directly from the entire
+        // range, rather than insert elements one after the other
+        PriorityQueue pq(boost::begin(range), boost::end(range));
+        std::swap(pq, queue);
+    }
+};
+
+
+template <typename Event>
+class event_visitor
+{
+    typedef typename Event::time_type event_time_type;
+    typedef typename Event::interval_type::difference_type difference_type;
+
+    typedef typename boost::remove_const
+        <
+            typename boost::remove_reference
+                <
+                    event_time_type
+                >::type
+        >::type bare_time_type;
+
+
+public:
+    event_visitor()
+        : m_overlap_count(0)
+        , m_max_gap_left(0)
+        , m_max_gap_right(0)
+    {}
+
+    template <typename PriorityQueue>
+    inline void apply(Event const& event, PriorityQueue& queue)
+    {
+        if (event.is_start_event())
+        {
+            ++m_overlap_count;
+            queue.push(Event(event.interval(), false));
+        }
+        else
+        {
+            --m_overlap_count;
+            if (m_overlap_count == 0 && ! queue.empty())
+            {
+                // we may have a gap
+                BOOST_GEOMETRY_ASSERT(queue.top().is_start_event());
+
+                event_time_type next_event_time
+                    = queue.top().interval().template get<0>();
+                difference_type gap = next_event_time - event.time();
+                if (gap > max_gap())
+                {
+                    m_max_gap_left = event.time();
+                    m_max_gap_right = next_event_time;
+                }
+            }
+        }
+    }
+
+    bare_time_type const& max_gap_left() const
+    {
+        return m_max_gap_left;
+    }
+
+    bare_time_type const& max_gap_right() const
+    {
+        return m_max_gap_right;
+    }
+
+    difference_type max_gap() const
+    {
+        return m_max_gap_right - m_max_gap_left;
+    }
+
+private:
+    std::size_t m_overlap_count;
+    bare_time_type m_max_gap_left, m_max_gap_right;
+};
+
+}} // namespace detail::max_interval_gap
+#endif // DOXYGEN_NO_DETAIL
+
+
+// Given a range of intervals I1, I2, ..., In, maximum_gap() returns
+// the maximum length of an interval M that satisfies the following
+// properties:
+//
+// 1. M.left >= min(I1, I2, ..., In)
+// 2. M.right <= max(I1, I2, ..., In)
+// 3. intersection(interior(M), Ik) is the empty set for all k=1, ..., n
+// 4. length(M) is maximal
+//
+// where M.left and M.right denote the left and right extreme values
+// for the interval M, and length(M) is equal to M.right - M.left.
+//
+// If M does not exist (or, alternatively, M is identified as the
+// empty set), 0 is returned.
+//
+// The algorithm proceeds for performing a sweep: the left endpoints
+// are inserted into a min-priority queue with the priority being the
+// value of the endpoint. The sweep algorithm maintains an "overlap
+// counter" that counts the number of overlaping intervals at any
+// specific sweep-time value.
+// There are two types of events encountered during the sweep:
+// (a) a start event: the left endpoint of an interval is found.
+//     In this case the overlap count is increased by one and the
+//     right endpoint of the interval in inserted into the event queue
+// (b) an end event: the right endpoint of an interval is found.
+//     In this case the overlap count is decreased by one. If the
+//     updated overlap count is 0, then we could expect to have a gap
+//     in-between intervals. This gap is measured as the (absolute)
+//     distance of the current interval right endpoint (being
+//     processed) to the upcoming left endpoint of the next interval
+//     to be processed (if such an interval exists). If the measured
+//     gap is greater than the current maximum gap, it is recorded.
+// The initial maximum gap is initialized to 0. This value is returned
+// if no gap is found during the sweeping procedure.
+
+template <typename RangeOfIntervals, typename T>
+inline typename boost::range_value<RangeOfIntervals>::type::difference_type
+maximum_gap(RangeOfIntervals const& range_of_intervals,
+            T& max_gap_left, T& max_gap_right)
+{
+    typedef typename boost::range_value<RangeOfIntervals>::type interval_type;
+    typedef detail::max_interval_gap::sweep_event<interval_type> event_type;
+
+    // create a min-priority queue for the events
+    std::priority_queue
+        <
+            event_type,
+            std::vector<event_type>, 
+            detail::max_interval_gap::event_greater<event_type>
+        > queue;
+
+    // define initialization and event-process visitors
+    detail::max_interval_gap::initialization_visitor init_visitor;
+    detail::max_interval_gap::event_visitor<event_type> sweep_visitor;
+
+    // perform the sweep
+    geometry::sweep(range_of_intervals,
+                    queue,
+                    init_visitor,
+                    sweep_visitor);
+
+    max_gap_left = sweep_visitor.max_gap_left();
+    max_gap_right = sweep_visitor.max_gap_right();
+    return sweep_visitor.max_gap();
+}
+
+template <typename RangeOfIntervals>
+inline typename boost::range_value<RangeOfIntervals>::type::difference_type
+maximum_gap(RangeOfIntervals const& range_of_intervals)
+{
+    typedef typename boost::remove_const
+        <
+            typename boost::remove_reference
+                <
+                    typename boost::range_value
+                        <
+                            RangeOfIntervals
+                        >::type::value_type
+                >::type
+        >::type value_type;
+
+    value_type left, right;
+
+    return maximum_gap(range_of_intervals, left, right);
+}
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_MAX_INTERVAL_GAP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/multi_modify.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/multi_modify.hpp
new file mode 100644
index 00000000000..23187f9323a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/multi_modify.hpp
@@ -0,0 +1,69 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_MULTI_MODIFY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_MULTI_MODIFY_HPP
+
+
+#include <boost/range.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+
+template <typename MultiGeometry, typename Policy>
+struct multi_modify
+{
+    static inline void apply(MultiGeometry& multi)
+    {
+        typedef typename boost::range_iterator<MultiGeometry>::type iterator_type;
+        for (iterator_type it = boost::begin(multi);
+            it != boost::end(multi);
+            ++it)
+        {
+            Policy::apply(*it);
+        }
+    }
+
+    template <typename Strategy>
+    static inline void apply(MultiGeometry& multi, Strategy const& strategy)
+    {
+        typedef typename boost::range_iterator<MultiGeometry>::type iterator_type;
+        for (iterator_type it = boost::begin(multi);
+            it != boost::end(multi);
+            ++it)
+        {
+            Policy::apply(*it, strategy);
+        }
+    }
+};
+
+
+} // namespace detail
+#endif
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_MULTI_MODIFY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/multi_modify_with_predicate.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/multi_modify_with_predicate.hpp
new file mode 100644
index 00000000000..c3787f9a109
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/multi_modify_with_predicate.hpp
@@ -0,0 +1,52 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_MULTI_MODIFY_WITH_PREDICATE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_MULTI_MODIFY_WITH_PREDICATE_HPP
+
+
+#include <boost/range.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <typename MultiGeometry, typename Predicate, typename Policy>
+struct multi_modify_with_predicate
+{
+    static inline void apply(MultiGeometry& multi, Predicate const& predicate)
+    {
+        typedef typename boost::range_iterator<MultiGeometry>::type iterator_type;
+        for (iterator_type it = boost::begin(multi);
+            it != boost::end(multi);
+            ++it)
+        {
+            Policy::apply(*it, predicate);
+        }
+    }
+};
+
+
+} // namespace detail
+#endif
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_MULTI_MODIFY_WITH_PREDICATE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/multi_sum.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/multi_sum.hpp
new file mode 100644
index 00000000000..af3f425c9c8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/multi_sum.hpp
@@ -0,0 +1,52 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_MULTI_SUM_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_MULTI_SUM_HPP
+
+#include <boost/range.hpp>
+
+
+namespace boost { namespace geometry
+{
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+struct multi_sum
+{
+    template <typename ReturnType, typename Policy, typename MultiGeometry, typename Strategy>
+    static inline ReturnType apply(MultiGeometry const& geometry, Strategy const& strategy)
+    {
+        ReturnType sum = ReturnType();
+        for (typename boost::range_iterator
+                <
+                    MultiGeometry const
+                >::type it = boost::begin(geometry);
+            it != boost::end(geometry);
+            ++it)
+        {
+            sum += Policy::apply(*it, strategy);
+        }
+        return sum;
+    }
+};
+
+
+} // namespace detail
+#endif
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_MULTI_SUM_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/normalize.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/normalize.hpp
new file mode 100644
index 00000000000..913fe324b74
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/normalize.hpp
@@ -0,0 +1,294 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_NORMALIZE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_NORMALIZE_HPP
+
+#include <cstddef>
+
+#include <boost/numeric/conversion/cast.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_system.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/normalize_spheroidal_coordinates.hpp>
+#include <boost/geometry/util/normalize_spheroidal_box_coordinates.hpp>
+
+#include <boost/geometry/views/detail/indexed_point_view.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace normalization
+{
+
+
+struct do_nothing
+{
+    template <typename GeometryIn, typename GeometryOut>
+    static inline void apply(GeometryIn const&, GeometryOut&)
+    {
+    }
+};
+
+
+template <std::size_t Dimension, std::size_t DimensionCount>
+struct assign_loop
+{
+    template <typename CoordinateType, typename PointIn, typename PointOut>
+    static inline void apply(CoordinateType const& longitude,
+                             CoordinateType const& latitude,
+                             PointIn const& point_in,
+                             PointOut& point_out)
+    {
+        geometry::set<Dimension>(point_out, boost::numeric_cast
+            <
+                typename coordinate_type<PointOut>::type
+            >(geometry::get<Dimension>(point_in)));
+
+        assign_loop
+            <
+                Dimension + 1, DimensionCount
+            >::apply(longitude, latitude, point_in, point_out);
+    }
+};
+
+template <std::size_t DimensionCount>
+struct assign_loop<DimensionCount, DimensionCount>
+{
+    template <typename CoordinateType, typename PointIn, typename PointOut>
+    static inline void apply(CoordinateType const&,
+                             CoordinateType const&,
+                             PointIn const&,
+                             PointOut&)
+    {
+    }
+};
+
+template <std::size_t DimensionCount>
+struct assign_loop<0, DimensionCount>
+{
+    template <typename CoordinateType, typename PointIn, typename PointOut>
+    static inline void apply(CoordinateType const& longitude,
+                             CoordinateType const& latitude,
+                             PointIn const& point_in,
+                             PointOut& point_out)
+    {
+        geometry::set<0>(point_out, boost::numeric_cast
+            <
+                typename coordinate_type<PointOut>::type
+            >(longitude));
+
+        assign_loop
+            <
+                1, DimensionCount
+            >::apply(longitude, latitude, point_in, point_out);
+    }
+};
+
+template <std::size_t DimensionCount>
+struct assign_loop<1, DimensionCount>
+{
+    template <typename CoordinateType, typename PointIn, typename PointOut>
+    static inline void apply(CoordinateType const& longitude,
+                             CoordinateType const& latitude,
+                             PointIn const& point_in,
+                             PointOut& point_out)
+    {
+        geometry::set<1>(point_out, boost::numeric_cast
+            <
+                typename coordinate_type<PointOut>::type
+            >(latitude));
+
+        assign_loop
+            <
+                2, DimensionCount
+            >::apply(longitude, latitude, point_in, point_out);
+    }
+};
+
+
+template <typename PointIn, typename PointOut>
+struct normalize_point
+{
+    static inline void apply(PointIn const& point_in, PointOut& point_out)
+    {
+        typedef typename coordinate_type<PointIn>::type in_coordinate_type;
+
+        in_coordinate_type longitude = geometry::get<0>(point_in);
+        in_coordinate_type latitude = geometry::get<1>(point_in);
+
+        math::normalize_spheroidal_coordinates
+            <
+                typename coordinate_system<PointIn>::type::units,
+                in_coordinate_type
+            >(longitude, latitude);
+
+        assign_loop
+            <
+                0, dimension<PointIn>::value
+            >::apply(longitude, latitude, point_in, point_out);
+    }
+};
+
+
+template <typename BoxIn, typename BoxOut>
+class normalize_box
+{
+    template <typename UnitsIn, typename UnitsOut, typename CoordinateInType>
+    static inline void apply_to_coordinates(CoordinateInType& lon_min,
+                                            CoordinateInType& lat_min,
+                                            CoordinateInType& lon_max,
+                                            CoordinateInType& lat_max,
+                                            BoxIn const& box_in,
+                                            BoxOut& box_out)
+    {
+        detail::indexed_point_view<BoxOut, min_corner> p_min_out(box_out);
+        assign_loop
+            <
+                0, dimension<BoxIn>::value
+            >::apply(lon_min,
+                     lat_min,
+                     detail::indexed_point_view
+                         <
+                             BoxIn const, min_corner
+                         >(box_in),
+                     p_min_out);
+
+        detail::indexed_point_view<BoxOut, max_corner> p_max_out(box_out);
+        assign_loop
+            <
+                0, dimension<BoxIn>::value
+            >::apply(lon_max,
+                     lat_max,
+                     detail::indexed_point_view
+                         <
+                             BoxIn const, max_corner
+                         >(box_in),
+                     p_max_out);
+    }
+
+public:
+    static inline void apply(BoxIn const& box_in, BoxOut& box_out)
+    {
+        typedef typename coordinate_type<BoxIn>::type in_coordinate_type;
+
+        in_coordinate_type lon_min = geometry::get<min_corner, 0>(box_in);
+        in_coordinate_type lat_min = geometry::get<min_corner, 1>(box_in);
+        in_coordinate_type lon_max = geometry::get<max_corner, 0>(box_in);
+        in_coordinate_type lat_max = geometry::get<max_corner, 1>(box_in);
+
+        math::normalize_spheroidal_box_coordinates
+            <
+                typename coordinate_system<BoxIn>::type::units,
+                in_coordinate_type
+            >(lon_min, lat_min, lon_max, lat_max);
+
+        apply_to_coordinates
+            <
+                typename coordinate_system<BoxIn>::type::units,
+                typename coordinate_system<BoxOut>::type::units
+            >(lon_min, lat_min, lon_max, lat_max, box_in, box_out);
+    }
+};
+
+
+}} // namespace detail::normalization
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename GeometryIn,
+    typename GeometryOut,
+    typename TagIn = typename tag<GeometryIn>::type,
+    typename TagOut = typename tag<GeometryOut>::type,
+    typename CSTagIn = typename cs_tag<GeometryIn>::type,
+    typename CSTagOut = typename cs_tag<GeometryOut>::type
+>
+struct normalize : detail::normalization::do_nothing
+{};
+
+
+template <typename PointIn, typename PointOut>
+struct normalize
+    <
+        PointIn, PointOut, point_tag, point_tag,
+        spherical_equatorial_tag, spherical_equatorial_tag
+    > : detail::normalization::normalize_point<PointIn, PointOut>
+{};
+
+
+template <typename PointIn, typename PointOut>
+struct normalize
+    <
+        PointIn, PointOut, point_tag, point_tag, geographic_tag, geographic_tag
+    > : detail::normalization::normalize_point<PointIn, PointOut>
+{};
+
+
+template <typename BoxIn, typename BoxOut>
+struct normalize
+    <
+        BoxIn, BoxOut, box_tag, box_tag,
+        spherical_equatorial_tag, spherical_equatorial_tag
+    > : detail::normalization::normalize_box<BoxIn, BoxOut>
+{};
+
+
+template <typename BoxIn, typename BoxOut>
+struct normalize
+    <
+        BoxIn, BoxOut, box_tag, box_tag, geographic_tag, geographic_tag
+    > : detail::normalization::normalize_box<BoxIn, BoxOut>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+
+template <typename GeometryIn, typename GeometryOut>
+inline void normalize(GeometryIn const& geometry_in, GeometryOut& geometry_out)
+{
+    dispatch::normalize
+        <
+            GeometryIn, GeometryOut
+        >::apply(geometry_in, geometry_out);
+}
+
+template <typename GeometryOut, typename GeometryIn>
+inline GeometryOut return_normalized(GeometryIn const& geometry_in)
+{
+    GeometryOut geometry_out;
+    detail::normalize(geometry_in, geometry_out);
+    return geometry_out;
+}
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_NORMALIZE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/not.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/not.hpp
new file mode 100644
index 00000000000..95cdfa24e62
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/not.hpp
@@ -0,0 +1,66 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015, 2017.
+// Modifications copyright (c) 2015-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_NOT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_NOT_HPP
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+
+
+/*!
+\brief Structure negating the result of specified policy
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Policy
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\return Negation of the result of the policy
+ */
+template <typename Policy>
+struct not_
+{
+    template <typename Geometry1, typename Geometry2>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2)
+    {
+        return ! Policy::apply(geometry1, geometry2);
+    }
+
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        return ! Policy::apply(geometry1, geometry2, strategy);
+    }
+};
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_NOT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/num_distinct_consecutive_points.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/num_distinct_consecutive_points.hpp
new file mode 100644
index 00000000000..16fba72fe01
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/num_distinct_consecutive_points.hpp
@@ -0,0 +1,93 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_NUM_DISTINCT_CONSECUTIVE_POINTS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_NUM_DISTINCT_CONSECUTIVE_POINTS_HPP
+
+#include <cstddef>
+
+#include <algorithm>
+
+#include <boost/range.hpp>
+
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+
+// returns the number of distinct values in the range;
+// return values are 0u through MaximumNumber, where MaximumNumber
+// corresponds to MaximumNumber or more distinct values
+//
+// FUTURE: take into account topologically closed ranges;
+//         add appropriate template parameter(s) to control whether
+//         the closing point for topologically closed ranges is to be
+//         accounted for separately or not
+template
+<
+    typename Range,
+    std::size_t MaximumNumber,
+    bool AllowDuplicates /* true */,
+    typename NotEqualTo
+>
+struct num_distinct_consecutive_points
+{
+    static inline std::size_t apply(Range const& range)
+    {
+        typedef typename boost::range_iterator<Range const>::type iterator;
+
+        std::size_t const size = boost::size(range);
+
+        if ( size < 2u )
+        {
+            return (size < MaximumNumber) ? size : MaximumNumber;
+        }
+
+        iterator current = boost::begin(range);
+        std::size_t counter(0);
+        do
+        {
+            ++counter;
+            iterator next = std::find_if(current,
+                                         boost::end(range),
+                                         NotEqualTo(*current));
+            current = next;
+        }
+        while ( current != boost::end(range) && counter <= MaximumNumber );
+
+        return counter;
+    }
+};
+
+
+template <typename Range, std::size_t MaximumNumber, typename NotEqualTo>
+struct num_distinct_consecutive_points<Range, MaximumNumber, false, NotEqualTo>
+{
+    static inline std::size_t apply(Range const& range)
+    {
+        std::size_t const size = boost::size(range);
+        return (size < MaximumNumber) ? size : MaximumNumber;
+    }
+};
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_NUM_DISTINCT_CONSECUTIVE_POINTS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/occupation_info.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/occupation_info.hpp
new file mode 100644
index 00000000000..fc74f0cc7fd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/occupation_info.hpp
@@ -0,0 +1,219 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012-2014 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OCCUPATION_INFO_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OCCUPATION_INFO_HPP
+
+#include <algorithm>
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/policies/compare.hpp>
+#include <boost/geometry/iterators/closing_iterator.hpp>
+
+#include <boost/geometry/algorithms/detail/get_left_turns.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <typename Point, typename T>
+struct angle_info
+{
+    typedef T angle_type;
+    typedef Point point_type;
+
+    segment_identifier seg_id;
+    std::size_t turn_index;
+    int operation_index;
+    std::size_t cluster_index;
+    Point intersection_point;
+    Point point; // either incoming or outgoing point
+    bool incoming;
+    bool blocked;
+    bool included;
+
+    inline angle_info()
+        : blocked(false)
+        , included(false)
+    {}
+};
+
+template <typename AngleInfo>
+class occupation_info
+{
+public :
+    typedef std::vector<AngleInfo> collection_type;
+
+    std::size_t count;
+
+    inline occupation_info()
+        : count(0)
+    {}
+
+    template <typename RobustPoint>
+    inline void add(RobustPoint const& incoming_point,
+                    RobustPoint const& outgoing_point,
+                    RobustPoint const& intersection_point,
+                    std::size_t turn_index, int operation_index,
+                    segment_identifier const& seg_id)
+    {
+        geometry::equal_to<RobustPoint> comparator;
+        if (comparator(incoming_point, intersection_point))
+        {
+            return;
+        }
+        if (comparator(outgoing_point, intersection_point))
+        {
+            return;
+        }
+
+        AngleInfo info;
+        info.seg_id = seg_id;
+        info.turn_index = turn_index;
+        info.operation_index = operation_index;
+        info.intersection_point = intersection_point;
+
+        {
+            info.point = incoming_point;
+            info.incoming = true;
+            m_angles.push_back(info);
+        }
+        {
+            info.point = outgoing_point;
+            info.incoming = false;
+            m_angles.push_back(info);
+        }
+    }
+
+    template <typename RobustPoint, typename Turns, typename SideStrategy>
+    inline void get_left_turns(RobustPoint const& origin, Turns& turns,
+                               SideStrategy const& strategy)
+    {
+        typedef detail::left_turns::angle_less
+            <
+                typename AngleInfo::point_type,
+                SideStrategy
+            > angle_less;
+
+        // Sort on angle
+        std::sort(m_angles.begin(), m_angles.end(), angle_less(origin, strategy));
+
+        // Group same-angled elements
+        std::size_t cluster_size = detail::left_turns::assign_cluster_indices(m_angles, origin);
+        // Block all turns on the right side of any turn
+        detail::left_turns::block_turns(m_angles, cluster_size);
+        detail::left_turns::get_left_turns(m_angles, turns);
+    }
+
+#if defined(BOOST_GEOMETRY_BUFFER_ENLARGED_CLUSTERS)
+    template <typename RobustPoint>
+    inline bool has_rounding_issues(RobustPoint const& origin) const
+    {
+        return detail::left_turns::has_rounding_issues(angles, origin);
+    }
+#endif
+
+private :
+    collection_type m_angles; // each turn splitted in incoming/outgoing vectors
+};
+
+template<typename Pieces>
+inline void move_index(Pieces const& pieces, signed_size_type& index, signed_size_type& piece_index, int direction)
+{
+    BOOST_GEOMETRY_ASSERT(direction == 1 || direction == -1);
+    BOOST_GEOMETRY_ASSERT(
+        piece_index >= 0
+        && piece_index < static_cast<signed_size_type>(boost::size(pieces)) );
+    BOOST_GEOMETRY_ASSERT(
+        index >= 0
+        && index < static_cast<signed_size_type>(boost::size(pieces[piece_index].robust_ring)));
+
+    // NOTE: both index and piece_index must be in valid range
+    // this means that then they could be of type std::size_t
+    // if the code below was refactored
+
+    index += direction;
+    if (direction == -1 && index < 0)
+    {
+        piece_index--;
+        if (piece_index < 0)
+        {
+            piece_index = boost::size(pieces) - 1;
+        }
+        index = boost::size(pieces[piece_index].robust_ring) - 1;
+    }
+    if (direction == 1
+        && index >= static_cast<signed_size_type>(boost::size(pieces[piece_index].robust_ring)))
+    {
+        piece_index++;
+        if (piece_index >= static_cast<signed_size_type>(boost::size(pieces)))
+        {
+            piece_index = 0;
+        }
+        index = 0;
+    }
+}
+
+
+template
+<
+    typename RobustPoint,
+    typename Turn,
+    typename Pieces,
+    typename Info
+>
+inline void add_incoming_and_outgoing_angles(
+                RobustPoint const& intersection_point, // rescaled
+                Turn const& turn,
+                Pieces const& pieces, // using rescaled offsets of it
+                int operation_index,
+                segment_identifier seg_id,
+                Info& info)
+{
+    segment_identifier real_seg_id = seg_id;
+    geometry::equal_to<RobustPoint> comparator;
+
+    // Move backward and forward
+    RobustPoint direction_points[2];
+    for (int i = 0; i < 2; i++)
+    {
+        signed_size_type index = turn.operations[operation_index].index_in_robust_ring;
+        signed_size_type piece_index = turn.operations[operation_index].piece_index;
+        while(comparator(pieces[piece_index].robust_ring[index], intersection_point))
+        {
+            move_index(pieces, index, piece_index, i == 0 ? -1 : 1);
+        }
+        direction_points[i] = pieces[piece_index].robust_ring[index];
+    }
+
+    info.add(direction_points[0], direction_points[1], intersection_point,
+        turn.turn_index, operation_index, real_seg_id);
+}
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OCCUPATION_INFO_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlaps/implementation.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlaps/implementation.hpp
new file mode 100644
index 00000000000..49f44bef81a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlaps/implementation.hpp
@@ -0,0 +1,156 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014, 2015, 2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAPS_IMPLEMENTATION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAPS_IMPLEMENTATION_HPP
+
+
+#include <cstddef>
+
+#include <boost/geometry/core/access.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/algorithms/relate.hpp>
+#include <boost/geometry/algorithms/detail/overlaps/interface.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlaps
+{
+
+template
+<
+    std::size_t Dimension,
+    std::size_t DimensionCount
+>
+struct box_box_loop
+{
+    template <typename Box1, typename Box2>
+    static inline void apply(Box1 const& b1, Box2 const& b2,
+            bool& overlaps, bool& one_in_two, bool& two_in_one)
+    {
+        assert_dimension_equal<Box1, Box2>();
+
+        typedef typename coordinate_type<Box1>::type coordinate_type1;
+        typedef typename coordinate_type<Box2>::type coordinate_type2;
+
+        coordinate_type1 const& min1 = get<min_corner, Dimension>(b1);
+        coordinate_type1 const& max1 = get<max_corner, Dimension>(b1);
+        coordinate_type2 const& min2 = get<min_corner, Dimension>(b2);
+        coordinate_type2 const& max2 = get<max_corner, Dimension>(b2);
+
+        // We might use the (not yet accepted) Boost.Interval
+        // submission in the future
+
+        // If:
+        // B1: |-------|
+        // B2:           |------|
+        // in any dimension -> no overlap
+        if (max1 <= min2 || min1 >= max2)
+        {
+            overlaps = false;
+            return;
+        }
+
+        // If:
+        // B1: |--------------------|
+        // B2:   |-------------|
+        // in all dimensions -> within, then no overlap
+        // B1: |--------------------|
+        // B2: |-------------|
+        // this is "within-touch" -> then no overlap. So use < and >
+        if (min1 < min2 || max1 > max2)
+        {
+            one_in_two = false;
+        }
+
+        // Same other way round
+        if (min2 < min1 || max2 > max1)
+        {
+            two_in_one = false;
+        }
+
+        box_box_loop
+            <
+                Dimension + 1,
+                DimensionCount
+            >::apply(b1, b2, overlaps, one_in_two, two_in_one);
+    }
+};
+
+template
+<
+    std::size_t DimensionCount
+>
+struct box_box_loop<DimensionCount, DimensionCount>
+{
+    template <typename Box1, typename Box2>
+    static inline void apply(Box1 const& , Box2 const&, bool&, bool&, bool&)
+    {
+    }
+};
+
+struct box_box
+{
+    template <typename Box1, typename Box2, typename Strategy>
+    static inline bool apply(Box1 const& b1, Box2 const& b2, Strategy const& /*strategy*/)
+    {
+        bool overlaps = true;
+        bool within1 = true;
+        bool within2 = true;
+        box_box_loop
+            <
+                0,
+                dimension<Box1>::type::value
+            >::apply(b1, b2, overlaps, within1, within2);
+
+        /*
+        \see http://docs.codehaus.org/display/GEOTDOC/02+Geometry+Relationships#02GeometryRelationships-Overlaps
+        where is stated that "inside" is not an "overlap",
+        this is true and is implemented as such.
+        */
+        return overlaps && ! within1 && ! within2;
+    }
+};
+
+}} // namespace detail::overlaps
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Box1, typename Box2>
+struct overlaps<Box1, Box2, box_tag, box_tag>
+    : detail::overlaps::box_box
+{};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAPS_IMPLEMENTATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlaps/interface.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlaps/interface.hpp
new file mode 100644
index 00000000000..f9f6a853fd7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlaps/interface.hpp
@@ -0,0 +1,124 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014, 2015, 2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAPS_INTERFACE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAPS_INTERFACE_HPP
+
+
+#include <cstddef>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/algorithms/detail/relate/relate_impl.hpp>
+
+#include <boost/geometry/strategies/relate.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename Tag1 = typename tag<Geometry1>::type,
+    typename Tag2 = typename tag<Geometry2>::type
+>
+struct overlaps
+    : detail::relate::relate_impl
+        <
+            detail::de9im::static_mask_overlaps_type,
+            Geometry1,
+            Geometry2
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+/*!
+\brief \brief_check2{overlap}
+\ingroup overlaps
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Strategy \tparam_strategy{Overlaps}
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param strategy \param_strategy{overlaps}
+\return \return_check2{overlap}
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/overlaps.qbk]}
+*/
+template <typename Geometry1, typename Geometry2, typename Strategy>
+inline bool overlaps(Geometry1 const& geometry1,
+                     Geometry2 const& geometry2,
+                     Strategy const& strategy)
+{
+    concepts::check<Geometry1 const>();
+    concepts::check<Geometry2 const>();
+
+    return dispatch::overlaps
+        <
+            Geometry1,
+            Geometry2
+        >::apply(geometry1, geometry2, strategy);
+}
+
+/*!
+\brief \brief_check2{overlap}
+\ingroup overlaps
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\return \return_check2{overlap}
+
+\qbk{[include reference/algorithms/overlaps.qbk]}
+*/
+template <typename Geometry1, typename Geometry2>
+inline bool overlaps(Geometry1 const& geometry1, Geometry2 const& geometry2)
+{
+    concepts::check<Geometry1 const>();
+    concepts::check<Geometry2 const>();
+
+    typedef typename strategy::relate::services::default_strategy
+            <
+                Geometry1,
+                Geometry2
+            >::type strategy_type;
+
+    return dispatch::overlaps
+        <
+            Geometry1,
+            Geometry2
+        >::apply(geometry1, geometry2, strategy_type());
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAPS_INTERFACE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/add_rings.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/add_rings.hpp
new file mode 100644
index 00000000000..fcb240941fc
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/add_rings.hpp
@@ -0,0 +1,161 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ADD_RINGS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ADD_RINGS_HPP
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/algorithms/area.hpp>
+#include <boost/geometry/algorithms/detail/overlay/convert_ring.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_ring.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+template
+<
+    typename GeometryOut,
+    typename Geometry1,
+    typename Geometry2,
+    typename RingCollection
+>
+inline void convert_and_add(GeometryOut& result,
+            Geometry1 const& geometry1, Geometry2 const& geometry2,
+            RingCollection const& collection,
+            ring_identifier id,
+            bool reversed, bool append)
+{
+    typedef typename geometry::tag<Geometry1>::type tag1;
+    typedef typename geometry::tag<Geometry2>::type tag2;
+    typedef typename geometry::tag<GeometryOut>::type tag_out;
+
+    if (id.source_index == 0)
+    {
+        convert_ring<tag_out>::apply(result,
+                    get_ring<tag1>::apply(id, geometry1),
+                    append, reversed);
+    }
+    else if (id.source_index == 1)
+    {
+        convert_ring<tag_out>::apply(result,
+                    get_ring<tag2>::apply(id, geometry2),
+                    append, reversed);
+    }
+    else if (id.source_index == 2)
+    {
+        convert_ring<tag_out>::apply(result,
+                    get_ring<void>::apply(id, collection),
+                    append, reversed);
+    }
+}
+
+template
+<
+    typename GeometryOut,
+    typename SelectionMap,
+    typename Geometry1,
+    typename Geometry2,
+    typename RingCollection,
+    typename OutputIterator
+>
+inline OutputIterator add_rings(SelectionMap const& map,
+            Geometry1 const& geometry1, Geometry2 const& geometry2,
+            RingCollection const& collection,
+            OutputIterator out)
+{
+    typedef typename SelectionMap::const_iterator iterator;
+    typedef typename SelectionMap::mapped_type property_type;
+    typedef typename property_type::area_type area_type;
+
+    area_type const zero = 0;
+    std::size_t const min_num_points = core_detail::closure::minimum_ring_size
+        <
+            geometry::closure
+                <
+                    typename boost::range_value
+                        <
+                            RingCollection const
+                        >::type
+                >::value
+        >::value;
+
+
+    for (iterator it = boost::begin(map);
+        it != boost::end(map);
+        ++it)
+    {
+        if (! it->second.discarded
+            && it->second.parent.source_index == -1)
+        {
+            GeometryOut result;
+            convert_and_add(result, geometry1, geometry2, collection,
+                    it->first, it->second.reversed, false);
+
+            // Add children
+            for (typename std::vector<ring_identifier>::const_iterator child_it
+                        = it->second.children.begin();
+                child_it != it->second.children.end();
+                ++child_it)
+            {
+                iterator mit = map.find(*child_it);
+                if (mit != map.end()
+                    && ! mit->second.discarded)
+                {
+                    convert_and_add(result, geometry1, geometry2, collection,
+                            *child_it, mit->second.reversed, true);
+                }
+            }
+
+            // Only add rings if they satisfy minimal requirements.
+            // This cannot be done earlier (during traversal), not
+            // everything is figured out yet (sum of positive/negative rings)
+            if (geometry::num_points(result) >= min_num_points
+                && math::larger(geometry::area(result), zero))
+            {
+                *out++ = result;
+            }
+        }
+    }
+    return out;
+}
+
+
+template
+<
+    typename GeometryOut,
+    typename SelectionMap,
+    typename Geometry,
+    typename RingCollection,
+    typename OutputIterator
+>
+inline OutputIterator add_rings(SelectionMap const& map,
+            Geometry const& geometry,
+            RingCollection const& collection,
+            OutputIterator out)
+{
+    Geometry empty;
+    return add_rings<GeometryOut>(map, geometry, empty, collection, out);
+}
+
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ADD_RINGS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/aggregate_operations.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/aggregate_operations.hpp
new file mode 100644
index 00000000000..106ecaad07c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/aggregate_operations.hpp
@@ -0,0 +1,252 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2016 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_AGGREGATE_OPERATIONS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_AGGREGATE_OPERATIONS_HPP
+
+#include <set>
+
+#include <boost/geometry/algorithms/detail/overlay/sort_by_side.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay { namespace sort_by_side
+{
+
+struct ring_with_direction
+{
+    ring_identifier ring_id;
+    direction_type direction;
+
+    std::size_t turn_index;
+    int operation_index;
+    operation_type operation;
+    signed_size_type region_id;
+    bool isolated;
+
+    inline bool operator<(ring_with_direction const& other) const
+    {
+        return this->ring_id != other.ring_id
+                ? this->ring_id < other.ring_id
+                : this->direction < other.direction;
+    }
+
+    ring_with_direction()
+        : direction(dir_unknown)
+        , turn_index(-1)
+        , operation_index(0)
+        , operation(operation_none)
+        , region_id(-1)
+        , isolated(false)
+    {}
+};
+
+struct rank_with_rings
+{
+    std::size_t rank;
+    std::set<ring_with_direction> rings;
+
+    rank_with_rings()
+        : rank(0)
+    {
+    }
+
+    inline bool all_equal(direction_type dir_type) const
+    {
+        for (std::set<ring_with_direction>::const_iterator it = rings.begin();
+             it != rings.end(); ++it)
+        {
+            if (it->direction != dir_type)
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    inline bool all_to() const
+    {
+        return all_equal(sort_by_side::dir_to);
+    }
+
+    inline bool all_from() const
+    {
+        return all_equal(sort_by_side::dir_from);
+    }
+
+    inline bool has_only(operation_type op) const
+    {
+        for (std::set<ring_with_direction>::const_iterator it = rings.begin();
+             it != rings.end(); ++it)
+        {
+            const ring_with_direction& rwd = *it;
+            if (rwd.operation != op)
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    //! Check if set has both op1 and op2, but no others
+    inline bool has_only_both(operation_type op1, operation_type op2) const
+    {
+        bool has1 = false;
+        bool has2 = false;
+        for (std::set<ring_with_direction>::const_iterator it = rings.begin();
+             it != rings.end(); ++it)
+        {
+            const ring_with_direction& rwd = *it;
+
+            if (rwd.operation == op1) { has1 = true; }
+            else if (rwd.operation == op2) { has2 = true; }
+            else { return false; }
+        }
+        return has1 && has2;
+    }
+
+    inline bool is_isolated() const
+    {
+        for (std::set<ring_with_direction>::const_iterator it = rings.begin();
+             it != rings.end(); ++it)
+        {
+            const ring_with_direction& rwd = *it;
+            if (! rwd.isolated)
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    inline bool has_unique_region_id() const
+    {
+        int region_id = -1;
+        for (std::set<ring_with_direction>::const_iterator it = rings.begin();
+             it != rings.end(); ++it)
+        {
+            const ring_with_direction& rwd = *it;
+            if (region_id == -1)
+            {
+                region_id = rwd.region_id;
+            }
+            else if (rwd.region_id != region_id)
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    inline int region_id() const
+    {
+        int region_id = -1;
+        for (std::set<ring_with_direction>::const_iterator it = rings.begin();
+             it != rings.end(); ++it)
+        {
+            const ring_with_direction& rwd = *it;
+            if (region_id == -1)
+            {
+                region_id = rwd.region_id;
+            }
+            else if (rwd.region_id != region_id)
+            {
+                return -1;
+            }
+        }
+        return region_id;
+    }
+
+    template <typename Turns>
+    inline bool traversable(Turns const& turns) const
+    {
+        typedef typename boost::range_value<Turns>::type turn_type;
+        typedef typename turn_type::turn_operation_type turn_operation_type;
+
+        for (std::set<ring_with_direction>::const_iterator it = rings.begin();
+             it != rings.end(); ++it)
+        {
+            const ring_with_direction& rwd = *it;
+            turn_type const& turn = turns[rwd.turn_index];
+            turn_operation_type const& op = turn.operations[rwd.operation_index];
+
+            // TODO: this is still necessary, but makes it order-dependent
+            // which should not be done.
+
+            // This would obsolete the whole function and should be solved
+            // in a different way
+            if (op.visited.finalized() || op.visited.visited())
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+};
+
+template <typename Sbs, typename Turns>
+inline void aggregate_operations(Sbs const& sbs, std::vector<rank_with_rings>& aggregation,
+                                 Turns const& turns,
+                                 operation_type target_operation)
+{
+    typedef typename boost::range_value<Turns>::type turn_type;
+    typedef typename turn_type::turn_operation_type turn_operation_type;
+
+    aggregation.clear();
+    for (std::size_t i = 0; i < sbs.m_ranked_points.size(); i++)
+    {
+        typename Sbs::rp const& ranked_point = sbs.m_ranked_points[i];
+
+        turn_type const& turn = turns[ranked_point.turn_index];
+
+        turn_operation_type const& op = turn.operations[ranked_point.operation_index];
+
+        if (! ((target_operation == operation_union && ranked_point.rank == 0)
+               || op.operation == target_operation
+               || op.operation == operation_continue
+               || (op.operation == operation_blocked && ranked_point.direction == dir_from)))
+        {
+            // Always take rank 0 (because self-turns are blocked)
+            // Don't consider union/blocked (aggregate is only used for intersections)
+            // Blocked is allowed for from
+            continue;
+        }
+
+        if (aggregation.empty() || aggregation.back().rank != ranked_point.rank)
+        {
+            rank_with_rings current;
+            current.rank = ranked_point.rank;
+            aggregation.push_back(current);
+        }
+
+        ring_with_direction rwd;
+        segment_identifier const& sid = ranked_point.seg_id;
+
+        rwd.ring_id = ring_identifier(sid.source_index, sid.multi_index, sid.ring_index);
+        rwd.direction = ranked_point.direction;
+        rwd.turn_index = ranked_point.turn_index;
+        rwd.operation_index = ranked_point.operation_index;
+        rwd.operation = op.operation;
+        rwd.region_id = op.enriched.region_id;
+        rwd.isolated = op.enriched.isolated;
+
+        aggregation.back().rings.insert(rwd);
+    }
+}
+
+
+}}} // namespace detail::overlay::sort_by_side
+#endif //DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_AGGREGATE_OPERATIONS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/append_no_duplicates.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/append_no_duplicates.hpp
new file mode 100644
index 00000000000..0fd1fe4de9f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/append_no_duplicates.hpp
@@ -0,0 +1,53 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_APPEND_NO_DUPLICATES_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_APPEND_NO_DUPLICATES_HPP
+
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/append.hpp>
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+template <typename Range, typename Point>
+inline void append_no_duplicates(Range& range, Point const& point, bool force = false)
+{
+    if (boost::size(range) == 0
+        || force
+        || ! geometry::detail::equals::equals_point_point(*(boost::end(range)-1), point))
+    {
+#ifdef BOOST_GEOMETRY_DEBUG_INTERSECTION
+        std::cout << "  add: ("
+            << geometry::get<0>(point) << ", " << geometry::get<1>(point) << ")"
+            << std::endl;
+#endif
+        geometry::append(range, point);
+    }
+}
+
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_APPEND_NO_DUPLICATES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/append_no_dups_or_spikes.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/append_no_dups_or_spikes.hpp
new file mode 100644
index 00000000000..fb738407984
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/append_no_dups_or_spikes.hpp
@@ -0,0 +1,164 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014, 2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_APPEND_NO_DUPS_OR_SPIKES_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_APPEND_NO_DUPS_OR_SPIKES_HPP
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/append.hpp>
+#include <boost/geometry/algorithms/detail/point_is_spike_or_equal.hpp>
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/range.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+// TODO: move this / rename this
+template <typename Point1, typename Point2, typename RobustPolicy>
+inline bool points_equal_or_close(Point1 const& point1,
+        Point2 const& point2,
+        RobustPolicy const& robust_policy)
+{
+    if (detail::equals::equals_point_point(point1, point2))
+    {
+        return true;
+    }
+
+    if (BOOST_GEOMETRY_CONDITION(! RobustPolicy::enabled))
+    {
+        return false;
+    }
+
+    // Try using specified robust policy
+    typedef typename geometry::robust_point_type
+    <
+        Point1,
+        RobustPolicy
+    >::type robust_point_type;
+
+    robust_point_type point1_rob, point2_rob;
+    geometry::recalculate(point1_rob, point1, robust_policy);
+    geometry::recalculate(point2_rob, point2, robust_policy);
+
+    return detail::equals::equals_point_point(point1_rob, point2_rob);
+}
+
+
+template <typename Range, typename Point, typename SideStrategy, typename RobustPolicy>
+inline void append_no_dups_or_spikes(Range& range, Point const& point,
+        SideStrategy const& strategy,
+        RobustPolicy const& robust_policy)
+{
+#ifdef BOOST_GEOMETRY_DEBUG_INTERSECTION
+    std::cout << "  add: ("
+        << geometry::get<0>(point) << ", " << geometry::get<1>(point) << ")"
+        << std::endl;
+#endif
+    // The code below this condition checks all spikes/dups
+    // for geometries >= 3 points.
+    // So we have to check the first potential duplicate differently
+    if (boost::size(range) == 1
+        && points_equal_or_close(*(boost::begin(range)), point, robust_policy))
+    {
+        return;
+    }
+
+    traits::push_back<Range>::apply(range, point);
+
+    // If a point is equal, or forming a spike, remove the pen-ultimate point
+    // because this one caused the spike.
+    // If so, the now-new-pen-ultimate point can again cause a spike
+    // (possibly at a corner). So keep doing this.
+    // Besides spikes it will also avoid adding duplicates.
+    while(boost::size(range) >= 3
+            && point_is_spike_or_equal(point,
+                *(boost::end(range) - 3),
+                *(boost::end(range) - 2),
+                strategy,
+                robust_policy))
+    {
+        // Use the Concept/traits, so resize and append again
+        traits::resize<Range>::apply(range, boost::size(range) - 2);
+        traits::push_back<Range>::apply(range, point);
+    }
+}
+
+template <typename Range, typename SideStrategy, typename RobustPolicy>
+inline void clean_closing_dups_and_spikes(Range& range,
+                SideStrategy const& strategy,
+                RobustPolicy const& robust_policy)
+{
+    std::size_t const minsize
+        = core_detail::closure::minimum_ring_size
+            <
+                geometry::closure<Range>::value
+            >::value;
+
+    if (boost::size(range) <= minsize)
+    {
+        return;
+    }
+
+    typedef typename boost::range_iterator<Range>::type iterator_type;
+    static bool const closed = geometry::closure<Range>::value == geometry::closed;
+
+// TODO: the following algorithm could be rewritten to first look for spikes
+// and then erase some number of points from the beginning of the Range
+
+    bool found = false;
+    do
+    {
+        found = false;
+        iterator_type first = boost::begin(range);
+        iterator_type second = first + 1;
+        iterator_type ultimate = boost::end(range) - 1;
+        if (BOOST_GEOMETRY_CONDITION(closed))
+        {
+            ultimate--;
+        }
+
+        // Check if closing point is a spike (this is so if the second point is
+        // considered as a spike w.r.t. the last segment)
+        if (point_is_spike_or_equal(*second, *ultimate, *first, strategy, robust_policy))
+        {
+            range::erase(range, first);
+            if (BOOST_GEOMETRY_CONDITION(closed))
+            {
+                // Remove closing last point
+                range::resize(range, boost::size(range) - 1);
+                // Add new closing point
+                range::push_back(range, range::front(range));
+            }
+            found = true;
+        }
+    } while(found && boost::size(range) > minsize);
+}
+
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_APPEND_NO_DUPS_OR_SPIKES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/assign_parents.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/assign_parents.hpp
new file mode 100644
index 00000000000..78160f52042
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/assign_parents.hpp
@@ -0,0 +1,404 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ASSIGN_PARENTS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ASSIGN_PARENTS_HPP
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/area.hpp>
+#include <boost/geometry/algorithms/envelope.hpp>
+#include <boost/geometry/algorithms/expand.hpp>
+#include <boost/geometry/algorithms/detail/partition.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_ring.hpp>
+#include <boost/geometry/algorithms/detail/overlay/range_in_geometry.hpp>
+#include <boost/geometry/algorithms/covered_by.hpp>
+
+#include <boost/geometry/geometries/box.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+
+template
+<
+    typename Item,
+    typename InnerGeometry,
+    typename Geometry1, typename Geometry2,
+    typename RingCollection,
+    typename Strategy
+>
+static inline bool within_selected_input(Item const& item2,
+        InnerGeometry const& inner_geometry,
+        ring_identifier const& outer_id,
+        Geometry1 const& geometry1, Geometry2 const& geometry2,
+        RingCollection const& collection,
+        Strategy const& strategy)
+{
+    typedef typename geometry::tag<Geometry1>::type tag1;
+    typedef typename geometry::tag<Geometry2>::type tag2;
+
+    // NOTE: range_in_geometry first checks the item2.point and then
+    // if this point is on boundary it checks points of inner_geometry
+    // ring until a point inside/outside other geometry ring is found
+    switch (outer_id.source_index)
+    {
+        // covered_by
+        case 0 :
+            return range_in_geometry(item2.point, inner_geometry,
+                get_ring<tag1>::apply(outer_id, geometry1), strategy) >= 0;
+        case 1 :
+            return range_in_geometry(item2.point, inner_geometry,
+                get_ring<tag2>::apply(outer_id, geometry2), strategy) >= 0;
+        case 2 :
+            return range_in_geometry(item2.point, inner_geometry,
+                get_ring<void>::apply(outer_id, collection), strategy) >= 0;
+    }
+    return false;
+}
+
+template
+<
+    typename Item,
+    typename Geometry1, typename Geometry2,
+    typename RingCollection,
+    typename Strategy
+>
+static inline bool within_selected_input(Item const& item2,
+        ring_identifier const& inner_id, ring_identifier const& outer_id,
+        Geometry1 const& geometry1, Geometry2 const& geometry2,
+        RingCollection const& collection,
+        Strategy const& strategy)
+{
+    typedef typename geometry::tag<Geometry1>::type tag1;
+    typedef typename geometry::tag<Geometry2>::type tag2;
+
+    switch (inner_id.source_index)
+    {
+        case 0 :
+            return within_selected_input(item2,
+               get_ring<tag1>::apply(inner_id, geometry1),
+               outer_id, geometry1, geometry2, collection, strategy);
+        case 1 :
+            return within_selected_input(item2,
+               get_ring<tag2>::apply(inner_id, geometry2),
+               outer_id, geometry1, geometry2, collection, strategy);
+        case 2 :
+            return within_selected_input(item2,
+                get_ring<void>::apply(inner_id, collection),
+                outer_id, geometry1, geometry2, collection, strategy);
+    }
+    return false;
+}
+
+
+template <typename Point, typename AreaType>
+struct ring_info_helper
+{
+    ring_identifier id;
+    AreaType real_area;
+    AreaType abs_area;
+    model::box<Point> envelope;
+
+    inline ring_info_helper()
+        : real_area(0), abs_area(0)
+    {}
+
+    inline ring_info_helper(ring_identifier i, AreaType const& a)
+        : id(i), real_area(a), abs_area(geometry::math::abs(a))
+    {}
+};
+
+
+struct ring_info_helper_get_box
+{
+    template <typename Box, typename InputItem>
+    static inline void apply(Box& total, InputItem const& item)
+    {
+        geometry::expand(total, item.envelope);
+    }
+};
+
+struct ring_info_helper_ovelaps_box
+{
+    template <typename Box, typename InputItem>
+    static inline bool apply(Box const& box, InputItem const& item)
+    {
+        return ! geometry::detail::disjoint::disjoint_box_box(box, item.envelope);
+    }
+};
+
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename Collection,
+    typename RingMap,
+    typename Strategy
+>
+struct assign_visitor
+{
+    typedef typename RingMap::mapped_type ring_info_type;
+
+    Geometry1 const& m_geometry1;
+    Geometry2 const& m_geometry2;
+    Collection const& m_collection;
+    RingMap& m_ring_map;
+    Strategy const& m_strategy;
+    bool m_check_for_orientation;
+
+    inline assign_visitor(Geometry1 const& g1, Geometry2 const& g2, Collection const& c,
+                          RingMap& map, Strategy const& strategy, bool check)
+        : m_geometry1(g1)
+        , m_geometry2(g2)
+        , m_collection(c)
+        , m_ring_map(map)
+        , m_strategy(strategy)
+        , m_check_for_orientation(check)
+    {}
+
+    template <typename Item>
+    inline bool apply(Item const& outer, Item const& inner, bool first = true)
+    {
+        if (first && outer.abs_area < inner.abs_area)
+        {
+            // Apply with reversed arguments
+            apply(inner, outer, false);
+            return true;
+        }
+
+        if (m_check_for_orientation
+         || (math::larger(outer.real_area, 0)
+          && math::smaller(inner.real_area, 0)))
+        {
+            ring_info_type& inner_in_map = m_ring_map[inner.id];
+
+            if (geometry::covered_by(inner_in_map.point, outer.envelope)
+               && within_selected_input(inner_in_map, inner.id, outer.id,
+                                        m_geometry1, m_geometry2, m_collection,
+                                        m_strategy)
+               )
+            {
+                // Assign a parent if there was no earlier parent, or the newly
+                // found parent is smaller than the previous one
+                if (inner_in_map.parent.source_index == -1
+                    || outer.abs_area < inner_in_map.parent_area)
+                {
+                    inner_in_map.parent = outer.id;
+                    inner_in_map.parent_area = outer.abs_area;
+                }
+            }
+        }
+
+        return true;
+    }
+};
+
+
+
+
+template
+<
+    typename Geometry1, typename Geometry2,
+    typename RingCollection,
+    typename RingMap,
+    typename Strategy
+>
+inline void assign_parents(Geometry1 const& geometry1,
+            Geometry2 const& geometry2,
+            RingCollection const& collection,
+            RingMap& ring_map,
+            Strategy const& strategy,
+            bool check_for_orientation = false)
+{
+    typedef typename geometry::tag<Geometry1>::type tag1;
+    typedef typename geometry::tag<Geometry2>::type tag2;
+
+    typedef typename RingMap::mapped_type ring_info_type;
+    typedef typename ring_info_type::point_type point_type;
+    typedef model::box<point_type> box_type;
+    typedef typename Strategy::template area_strategy
+        <
+            point_type
+        >::type::return_type area_result_type;
+
+    typedef typename RingMap::iterator map_iterator_type;
+
+    {
+        typedef ring_info_helper<point_type, area_result_type> helper;
+        typedef std::vector<helper> vector_type;
+        typedef typename boost::range_iterator<vector_type const>::type vector_iterator_type;
+
+        std::size_t count_total = ring_map.size();
+        std::size_t count_positive = 0;
+        std::size_t index_positive = 0; // only used if count_positive>0
+        std::size_t index = 0;
+
+        // Copy to vector (with new approach this might be obsolete as well, using the map directly)
+        vector_type vector(count_total);
+
+        for (map_iterator_type it = boost::begin(ring_map);
+            it != boost::end(ring_map); ++it, ++index)
+        {
+            vector[index] = helper(it->first, it->second.get_area());
+            helper& item = vector[index];
+            switch(it->first.source_index)
+            {
+                case 0 :
+                    geometry::envelope(get_ring<tag1>::apply(it->first, geometry1),
+                                       item.envelope, strategy.get_envelope_strategy());
+                    break;
+                case 1 :
+                    geometry::envelope(get_ring<tag2>::apply(it->first, geometry2),
+                                       item.envelope, strategy.get_envelope_strategy());
+                    break;
+                case 2 :
+                    geometry::envelope(get_ring<void>::apply(it->first, collection),
+                                       item.envelope, strategy.get_envelope_strategy());
+                    break;
+            }
+
+            // Expand envelope slightly
+            expand_by_epsilon(item.envelope);
+
+            if (item.real_area > 0)
+            {
+                count_positive++;
+                index_positive = index;
+            }
+        }
+
+        if (! check_for_orientation)
+        {
+            if (count_positive == count_total)
+            {
+                // Optimization for only positive rings
+                // -> no assignment of parents or reversal necessary, ready here.
+                return;
+            }
+
+            if (count_positive == 1)
+            {
+                // Optimization for one outer ring
+                // -> assign this as parent to all others (all interior rings)
+                // In unions, this is probably the most occuring case and gives
+                //    a dramatic improvement (factor 5 for star_comb testcase)
+                ring_identifier id_of_positive = vector[index_positive].id;
+                ring_info_type& outer = ring_map[id_of_positive];
+                index = 0;
+                for (vector_iterator_type it = boost::begin(vector);
+                    it != boost::end(vector); ++it, ++index)
+                {
+                    if (index != index_positive)
+                    {
+                        ring_info_type& inner = ring_map[it->id];
+                        inner.parent = id_of_positive;
+                        outer.children.push_back(it->id);
+                    }
+                }
+                return;
+            }
+        }
+
+        assign_visitor
+            <
+                Geometry1, Geometry2,
+                RingCollection, RingMap,
+                Strategy
+            > visitor(geometry1, geometry2, collection, ring_map, strategy, check_for_orientation);
+
+        geometry::partition
+            <
+                box_type
+            >::apply(vector, visitor, ring_info_helper_get_box(),
+                     ring_info_helper_ovelaps_box());
+    }
+
+    if (check_for_orientation)
+    {
+        for (map_iterator_type it = boost::begin(ring_map);
+            it != boost::end(ring_map); ++it)
+        {
+            if (geometry::math::equals(it->second.get_area(), 0))
+            {
+                it->second.discarded = true;
+            }
+            else if (it->second.parent.source_index >= 0
+                    && math::larger(it->second.get_area(), 0))
+            {
+                const ring_info_type& parent = ring_map[it->second.parent];
+
+                if (math::larger(parent.area, 0))
+                {
+                    // Discard positive inner ring with positive parent
+                    it->second.discarded = true;
+                }
+                // Remove parent ID from any positive inner ring
+                it->second.parent.source_index = -1;
+            }
+            else if (it->second.parent.source_index < 0
+                    && math::smaller(it->second.get_area(), 0))
+            {
+                // Reverse negative ring without parent
+                it->second.reversed = true;
+            }
+        }
+    }
+
+    // Assign childlist
+    for (map_iterator_type it = boost::begin(ring_map);
+        it != boost::end(ring_map); ++it)
+    {
+        if (it->second.parent.source_index >= 0)
+        {
+            ring_map[it->second.parent].children.push_back(it->first);
+        }
+    }
+}
+
+
+// Version for one geometry (called by buffer)
+template
+<
+    typename Geometry,
+    typename RingCollection,
+    typename RingMap,
+    typename Strategy
+>
+inline void assign_parents(Geometry const& geometry,
+            RingCollection const& collection,
+            RingMap& ring_map,
+            Strategy const& strategy,
+            bool check_for_orientation)
+{
+    // Call it with an empty geometry as second geometry (source_id == 1)
+    // (ring_map should be empty for source_id==1)
+
+    Geometry empty;
+    assign_parents(geometry, empty, collection, ring_map, strategy, check_for_orientation);
+}
+
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ASSIGN_PARENTS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/backtrack_check_si.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/backtrack_check_si.hpp
new file mode 100644
index 00000000000..9beb8ad64f0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/backtrack_check_si.hpp
@@ -0,0 +1,215 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017, Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_BACKTRACK_CHECK_SI_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_BACKTRACK_CHECK_SI_HPP
+
+#include <cstddef>
+#include <string>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+#include <boost/geometry/algorithms/detail/has_self_intersections.hpp>
+#if defined(BOOST_GEOMETRY_DEBUG_INTERSECTION) || defined(BOOST_GEOMETRY_OVERLAY_REPORT_WKT)
+#  include <boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp>
+#  include <boost/geometry/io/wkt/wkt.hpp>
+#endif
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+template <typename Turns>
+inline void clear_visit_info(Turns& turns)
+{
+    typedef typename boost::range_value<Turns>::type tp_type;
+
+    for (typename boost::range_iterator<Turns>::type
+        it = boost::begin(turns);
+        it != boost::end(turns);
+        ++it)
+    {
+        for (typename boost::range_iterator
+            <
+                typename tp_type::container_type
+            >::type op_it = boost::begin(it->operations);
+            op_it != boost::end(it->operations);
+            ++op_it)
+        {
+            op_it->visited.clear();
+        }
+    }
+}
+
+struct backtrack_state
+{
+    bool m_good;
+
+    inline backtrack_state() : m_good(true) {}
+    inline void reset() { m_good = true; }
+    inline bool good() const { return m_good; }
+};
+
+
+enum traverse_error_type
+{
+    traverse_error_none,
+    traverse_error_no_next_ip_at_start,
+    traverse_error_no_next_ip,
+    traverse_error_dead_end_at_start,
+    traverse_error_dead_end,
+    traverse_error_visit_again,
+    traverse_error_endless_loop
+};
+
+inline std::string traverse_error_string(traverse_error_type error)
+{
+    switch (error)
+    {
+        case traverse_error_none : return "";
+        case traverse_error_no_next_ip_at_start : return "No next IP at start";
+        case traverse_error_no_next_ip : return "No next IP";
+        case traverse_error_dead_end_at_start : return "Dead end at start";
+        case traverse_error_dead_end : return "Dead end";
+        case traverse_error_visit_again : return "Visit again";
+        case traverse_error_endless_loop : return "Endless loop";
+        default : return "";
+    }
+    return "";
+}
+
+
+template
+<
+    typename Geometry1,
+    typename Geometry2
+>
+class backtrack_check_self_intersections
+{
+    struct state : public backtrack_state
+    {
+        bool m_checked;
+        inline state()
+            : m_checked(true)
+        {}
+    };
+public :
+    typedef state state_type;
+
+    template
+    <
+        typename Operation,
+        typename Rings, typename Ring, typename Turns,
+        typename Strategy,
+        typename RobustPolicy,
+        typename Visitor
+    >
+    static inline void apply(std::size_t size_at_start,
+                             Rings& rings,
+                             Ring& ring,
+                             Turns& turns,
+                             typename boost::range_value<Turns>::type const& turn,
+                             Operation& operation,
+                             traverse_error_type traverse_error,
+                             Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy,
+                             RobustPolicy const& robust_policy,
+                             state_type& state,
+                             Visitor& visitor)
+    {
+        visitor.visit_traverse_reject(turns, turn, operation, traverse_error);
+
+        state.m_good = false;
+
+        // Check self-intersections and throw exception if appropriate
+        if (! state.m_checked)
+        {
+            state.m_checked = true;
+            has_self_intersections(geometry1, strategy, robust_policy);
+            has_self_intersections(geometry2, strategy, robust_policy);
+        }
+
+        // Make bad output clean
+        rings.resize(size_at_start);
+        geometry::traits::clear<typename boost::range_value<Rings>::type>::apply(ring);
+
+        // Reject this as a starting point
+        operation.visited.set_rejected();
+
+        // And clear all visit info
+        clear_visit_info(turns);
+    }
+};
+
+#ifdef BOOST_GEOMETRY_OVERLAY_REPORT_WKT
+template
+<
+    typename Geometry1,
+    typename Geometry2
+>
+class backtrack_debug
+{
+public :
+    typedef backtrack_state state_type;
+
+    template <typename Operation, typename Rings, typename Turns>
+    static inline void apply(std::size_t size_at_start,
+                Rings& rings, typename boost::range_value<Rings>::type& ring,
+                Turns& turns, Operation& operation,
+                std::string const& reason,
+                Geometry1 const& geometry1,
+                Geometry2 const& geometry2,
+                state_type& state
+                )
+    {
+        std::cout << " REJECT " << reason << std::endl;
+
+        state.m_good = false;
+
+        rings.resize(size_at_start);
+        ring.clear();
+        operation.visited.set_rejected();
+        clear_visit_info(turns);
+
+        int c = 0;
+        for (int i = 0; i < turns.size(); i++)
+        {
+            for (int j = 0; j < 2; j++)
+            {
+                if (turns[i].operations[j].visited.rejected())
+                {
+                    c++;
+                }
+            }
+        }
+        std::cout << "BACKTRACK (" << reason << " )"
+            << " " << c << " of " << turns.size() << " rejected"
+            << std::endl;
+        std::cout
+            << geometry::wkt(geometry1) << std::endl
+            << geometry::wkt(geometry2) << std::endl;
+    }
+};
+#endif // BOOST_GEOMETRY_OVERLAY_REPORT_WKT
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_BACKTRACK_CHECK_SI_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/check_enrich.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/check_enrich.hpp
new file mode 100644
index 00000000000..25e442982b1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/check_enrich.hpp
@@ -0,0 +1,168 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_CHECK_ENRICH_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_CHECK_ENRICH_HPP
+
+
+#include <cstddef>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/detail/ring_identifier.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+template<typename Turn>
+struct meta_turn
+{
+    int index;
+    Turn const* turn;
+    bool handled[2];
+
+    inline meta_turn(int i, Turn const& t)
+        : index(i), turn(&t)
+    {
+        handled[0] = false;
+        handled[1] = false;
+    }
+};
+
+
+template <typename MetaTurn>
+inline void display(MetaTurn const& meta_turn, std::string const& reason = "")
+{
+#ifdef BOOST_GEOMETRY_DEBUG_ENRICH
+    std::cout << meta_turn.index
+        << "\tMethods: " << method_char(meta_turn.turn->method)
+        << " operations: "  << operation_char(meta_turn.turn->operations[0].operation)
+                << operation_char(meta_turn.turn->operations[1].operation)
+        << " travels to " << meta_turn.turn->operations[0].enriched.travels_to_ip_index
+        << " and " << meta_turn.turn->operations[1].enriched.travels_to_ip_index
+        //<< " -> " << op_index
+        << " " << reason
+        << std::endl;
+#endif
+}
+
+
+template <typename MetaTurns, typename MetaTurn>
+inline void check_detailed(MetaTurns& meta_turns, MetaTurn const& meta_turn,
+            int op_index, int cycle, int start, operation_type for_operation,
+            bool& error)
+{
+    display(meta_turn);
+    int const ip_index = meta_turn.turn->operations[op_index].enriched.travels_to_ip_index;
+    if (ip_index >= 0)
+    {
+        bool found = false;
+
+        if (ip_index == start)
+        {
+            display(meta_turns[ip_index], " FINISH");
+            return;
+        }
+
+        // check on continuing, or on same-operation-on-same-geometry
+        if (! meta_turns[ip_index].handled[op_index]
+            && (meta_turns[ip_index].turn->operations[op_index].operation == operation_continue
+                || meta_turns[ip_index].turn->operations[op_index].operation == for_operation)
+            )
+        {
+            meta_turns[ip_index].handled[op_index] = true;
+            check_detailed(meta_turns, meta_turns[ip_index], op_index, cycle, start, for_operation, error);
+            found = true;
+        }
+        // check on other geometry
+        if (! found)
+        {
+            int const other_index = 1 - op_index;
+            if (! meta_turns[ip_index].handled[other_index]
+                && meta_turns[ip_index].turn->operations[other_index].operation == for_operation)
+            {
+                meta_turns[ip_index].handled[other_index] = true;
+                check_detailed(meta_turns, meta_turns[ip_index], other_index, cycle, start, for_operation, error);
+                found = true;
+            }
+        }
+
+        if (! found)
+        {
+            display(meta_turns[ip_index], " STOP");
+            error = true;
+#ifndef BOOST_GEOMETRY_DEBUG_ENRICH
+            //std::cout << " STOP";
+#endif
+        }
+    }
+}
+
+
+template <typename TurnPoints>
+inline bool check_graph(TurnPoints& turn_points, operation_type for_operation)
+{
+    typedef typename boost::range_value<TurnPoints>::type turn_point_type;
+
+    bool error = false;
+    int index = 0;
+
+    std::vector<meta_turn<turn_point_type> > meta_turns;
+    for (typename boost::range_iterator<TurnPoints const>::type
+            it = boost::begin(turn_points);
+         it != boost::end(turn_points);
+         ++it, ++index)
+    {
+        meta_turns.push_back(meta_turn<turn_point_type>(index, *it));
+    }
+
+    int cycle = 0;
+    for (typename boost::range_iterator<std::vector<meta_turn<turn_point_type> > > ::type
+            it = boost::begin(meta_turns);
+         it != boost::end(meta_turns);
+         ++it)
+    {
+        if (! (it->turn->blocked() || it->turn->discarded))
+        {
+            for (int i = 0 ; i < 2; i++)
+            {
+                if (! it->handled[i]
+                    && it->turn->operations[i].operation == for_operation)
+                {
+#ifdef BOOST_GEOMETRY_DEBUG_ENRICH
+                    std::cout << "CYCLE " << cycle << std::endl;
+#endif
+                    it->handled[i] = true;
+                    check_detailed(meta_turns, *it, i, cycle++, it->index, for_operation, error);
+#ifdef BOOST_GEOMETRY_DEBUG_ENRICH
+                    std::cout <<" END CYCLE " << it->index << std::endl;
+#endif
+                }
+            }
+        }
+    }
+    return error;
+}
+
+
+
+}} // namespace detail::overlay
+#endif //DOXYGEN_NO_DETAIL
+
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_CHECK_ENRICH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/clip_linestring.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/clip_linestring.hpp
new file mode 100644
index 00000000000..8cb37d6954a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/clip_linestring.hpp
@@ -0,0 +1,250 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_CLIP_LINESTRING_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_CLIP_LINESTRING_HPP
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/clear.hpp>
+#include <boost/geometry/algorithms/convert.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/append_no_duplicates.hpp>
+
+#include <boost/geometry/util/select_coordinate_type.hpp>
+#include <boost/geometry/geometries/segment.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace intersection
+{
+
+/*!
+    \brief Strategy: line clipping algorithm after Liang Barsky
+    \ingroup overlay
+    \details The Liang-Barsky line clipping algorithm clips a line with a clipping box.
+    It is slightly adapted in the sense that it returns which points are clipped
+    \tparam B input box type of clipping box
+    \tparam P input/output point-type of segments to be clipped
+    \note The algorithm is currently only implemented for 2D Cartesian points
+    \note Though it is implemented in namespace strategy, and theoretically another
+        strategy could be used, it is not (yet) updated to the general strategy concepts,
+        and not (yet) splitted into a file in folder strategies
+    \author Barend Gehrels, and the following recourses
+    - A tutorial: http://www.skytopia.com/project/articles/compsci/clipping.html
+    - a German applet (link broken): http://ls7-www.cs.uni-dortmund.de/students/projectgroups/acit/lineclip.shtml
+*/
+template<typename Box, typename Point>
+class liang_barsky
+{
+private:
+    typedef model::referring_segment<Point> segment_type;
+
+    template <typename CoordinateType, typename CalcType>
+    inline bool check_edge(CoordinateType const& p, CoordinateType const& q, CalcType& t1, CalcType& t2) const
+    {
+        bool visible = true;
+
+        if(p < 0)
+        {
+            CalcType const r = static_cast<CalcType>(q) / p;
+            if (r > t2)
+                visible = false;
+            else if (r > t1)
+                t1 = r;
+        }
+        else if(p > 0)
+        {
+            CalcType const r = static_cast<CalcType>(q) / p;
+            if (r < t1)
+                visible = false;
+            else if (r < t2)
+                t2 = r;
+        }
+        else
+        {
+            if (q < 0)
+                visible = false;
+        }
+
+        return visible;
+    }
+
+public:
+
+    inline bool clip_segment(Box const& b, segment_type& s, bool& sp1_clipped, bool& sp2_clipped) const
+    {
+        typedef typename select_coordinate_type<Box, Point>::type coordinate_type;
+        typedef typename select_most_precise<coordinate_type, double>::type calc_type;
+
+        calc_type t1 = 0;
+        calc_type t2 = 1;
+
+        coordinate_type const dx = get<1, 0>(s) - get<0, 0>(s);
+        coordinate_type const dy = get<1, 1>(s) - get<0, 1>(s);
+
+        coordinate_type const p1 = -dx;
+        coordinate_type const p2 = dx;
+        coordinate_type const p3 = -dy;
+        coordinate_type const p4 = dy;
+
+        coordinate_type const q1 = get<0, 0>(s) - get<min_corner, 0>(b);
+        coordinate_type const q2 = get<max_corner, 0>(b) - get<0, 0>(s);
+        coordinate_type const q3 = get<0, 1>(s) - get<min_corner, 1>(b);
+        coordinate_type const q4 = get<max_corner, 1>(b) - get<0, 1>(s);
+
+        if (check_edge(p1, q1, t1, t2)      // left
+            && check_edge(p2, q2, t1, t2)   // right
+            && check_edge(p3, q3, t1, t2)   // bottom
+            && check_edge(p4, q4, t1, t2))   // top
+        {
+            sp1_clipped = t1 > 0;
+            sp2_clipped = t2 < 1;
+
+            if (sp2_clipped)
+            {
+                set<1, 0>(s, get<0, 0>(s) + t2 * dx);
+                set<1, 1>(s, get<0, 1>(s) + t2 * dy);
+            }
+
+            if(sp1_clipped)
+            {
+                set<0, 0>(s, get<0, 0>(s) + t1 * dx);
+                set<0, 1>(s, get<0, 1>(s) + t1 * dy);
+            }
+
+            return true;
+        }
+
+        return false;
+    }
+
+    template<typename Linestring, typename OutputIterator>
+    inline void apply(Linestring& line_out, OutputIterator out) const
+    {
+        if (!boost::empty(line_out))
+        {
+            *out = line_out;
+            ++out;
+            geometry::clear(line_out);
+        }
+    }
+};
+
+
+}} // namespace strategy::intersection
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace intersection
+{
+
+/*!
+    \brief Clips a linestring with a box
+    \details A linestring is intersected (clipped) by the specified box
+    and the resulting linestring, or pieces of linestrings, are sent to the specified output operator.
+    \tparam OutputLinestring type of the output linestrings
+    \tparam OutputIterator an output iterator which outputs linestrings
+    \tparam Linestring linestring-type, for example a vector of points, matching the output-iterator type,
+         the points should also match the input-iterator type
+    \tparam Box box type
+    \tparam Strategy strategy, a clipping strategy which should implement the methods "clip_segment" and "apply"
+*/
+template
+<
+    typename OutputLinestring,
+    typename OutputIterator,
+    typename Range,
+    typename RobustPolicy,
+    typename Box,
+    typename Strategy
+>
+OutputIterator clip_range_with_box(Box const& b, Range const& range,
+            RobustPolicy const&,
+            OutputIterator out, Strategy const& strategy)
+{
+    if (boost::begin(range) == boost::end(range))
+    {
+        return out;
+    }
+
+    typedef typename point_type<OutputLinestring>::type point_type;
+
+    OutputLinestring line_out;
+
+    typedef typename boost::range_iterator<Range const>::type iterator_type;
+    iterator_type vertex = boost::begin(range);
+    for(iterator_type previous = vertex++;
+            vertex != boost::end(range);
+            ++previous, ++vertex)
+    {
+        point_type p1, p2;
+        geometry::convert(*previous, p1);
+        geometry::convert(*vertex, p2);
+
+        // Clip the segment. Five situations:
+        // 1. Segment is invisible, finish line if any (shouldn't occur)
+        // 2. Segment is completely visible. Add (p1)-p2 to line
+        // 3. Point 1 is invisible (clipped), point 2 is visible. Start new line from p1-p2...
+        // 4. Point 1 is visible, point 2 is invisible (clipped). End the line with ...p2
+        // 5. Point 1 and point 2 are both invisible (clipped). Start/finish an independant line p1-p2
+        //
+        // This results in:
+        // a. if p1 is clipped, start new line
+        // b. if segment is partly or completely visible, add the segment
+        // c. if p2 is clipped, end the line
+
+        bool c1 = false;
+        bool c2 = false;
+        model::referring_segment<point_type> s(p1, p2);
+
+        if (!strategy.clip_segment(b, s, c1, c2))
+        {
+            strategy.apply(line_out, out);
+        }
+        else
+        {
+            // a. If necessary, finish the line and add a start a new one
+            if (c1)
+            {
+                strategy.apply(line_out, out);
+            }
+
+            // b. Add p1 only if it is the first point, then add p2
+            if (boost::empty(line_out))
+            {
+                detail::overlay::append_no_duplicates(line_out, p1, true);
+            }
+            detail::overlay::append_no_duplicates(line_out, p2);
+
+            // c. If c2 is clipped, finish the line
+            if (c2)
+            {
+                strategy.apply(line_out, out);
+            }
+        }
+
+    }
+
+    // Add last part
+    strategy.apply(line_out, out);
+    return out;
+}
+
+}} // namespace detail::intersection
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_CLIP_LINESTRING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/cluster_info.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/cluster_info.hpp
new file mode 100644
index 00000000000..5b460919f16
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/cluster_info.hpp
@@ -0,0 +1,49 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2016 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_CLUSTER_INFO_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_CLUSTER_INFO_HPP
+
+
+#include <set>
+#include <boost/geometry/algorithms/detail/signed_size_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+struct cluster_info
+{
+    std::set<signed_size_type> turn_indices;
+
+    bool switch_source; // For clusters with a touch, conform turn_info uu
+
+    //! Number of open spaces (e.g. 2 for touch)
+    std::size_t open_count;
+
+    inline cluster_info()
+        : switch_source(false)
+        , open_count(0)
+    {}
+};
+
+
+}} // namespace detail::overlay
+#endif //DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_CLUSTER_INFO_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/convert_ring.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/convert_ring.hpp
new file mode 100644
index 00000000000..51955b515d1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/convert_ring.hpp
@@ -0,0 +1,110 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_CONVERT_RING_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_CONVERT_RING_HPP
+
+
+#include <boost/mpl/assert.hpp>
+#include <boost/range.hpp>
+#include <boost/range/algorithm/reverse.hpp>
+
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/algorithms/detail/ring_identifier.hpp>
+
+#include <boost/geometry/algorithms/convert.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+template<typename Tag>
+struct convert_ring
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_OR_NOT_YET_IMPLEMENTED_FOR_THIS_GEOMETRY_TAG
+            , (types<Tag>)
+        );
+};
+
+template<>
+struct convert_ring<ring_tag>
+{
+    template<typename Destination, typename Source>
+    static inline void apply(Destination& destination, Source const& source,
+                bool append, bool reverse)
+    {
+        if (! append)
+        {
+            geometry::convert(source, destination);
+            if (reverse)
+            {
+                boost::reverse(destination);
+            }
+        }
+    }
+};
+
+
+template<>
+struct convert_ring<polygon_tag>
+{
+    template<typename Destination, typename Source>
+    static inline void apply(Destination& destination, Source const& source,
+                bool append, bool reverse)
+    {
+        if (! append)
+        {
+            geometry::convert(source, exterior_ring(destination));
+            if (reverse)
+            {
+                boost::reverse(exterior_ring(destination));
+            }
+        }
+        else
+        {
+            // Avoid adding interior rings which are invalid
+            // because of its number of points:
+            std::size_t const min_num_points
+                    = core_detail::closure::minimum_ring_size
+                            <
+                                geometry::closure<Destination>::value
+                            >::value;
+
+            if (geometry::num_points(source) >= min_num_points)
+            {
+                interior_rings(destination).resize(
+                            interior_rings(destination).size() + 1);
+                geometry::convert(source, interior_rings(destination).back());
+                if (reverse)
+                {
+                    boost::reverse(interior_rings(destination).back());
+                }
+            }
+        }
+    }
+};
+
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_CONVERT_RING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/copy_segment_point.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/copy_segment_point.hpp
new file mode 100644
index 00000000000..0e9bfe2ea03
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/copy_segment_point.hpp
@@ -0,0 +1,400 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_COPY_SEGMENT_POINT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_COPY_SEGMENT_POINT_HPP
+
+
+#include <boost/array.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/algorithms/convert.hpp>
+#include <boost/geometry/algorithms/detail/signed_size_type.hpp>
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/util/range.hpp>
+#include <boost/geometry/iterators/ever_circling_iterator.hpp>
+#include <boost/geometry/views/closeable_view.hpp>
+#include <boost/geometry/views/reversible_view.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace copy_segments
+{
+
+
+template <typename Range, bool Reverse, typename SegmentIdentifier, typename PointOut>
+struct copy_segment_point_range
+{
+    static inline bool apply(Range const& range,
+            SegmentIdentifier const& seg_id, int offset,
+            PointOut& point)
+    {
+        typedef typename closeable_view
+        <
+            Range const,
+            closure<Range>::value
+        >::type cview_type;
+
+        typedef typename reversible_view
+        <
+            cview_type const,
+            Reverse ? iterate_reverse : iterate_forward
+        >::type rview_type;
+
+        cview_type cview(range);
+        rview_type view(cview);
+
+        typedef typename boost::range_iterator<rview_type>::type iterator;
+        geometry::ever_circling_iterator<iterator> it(boost::begin(view), boost::end(view),
+                    boost::begin(view) + seg_id.segment_index, true);
+
+        for (signed_size_type i = 0; i < offset; ++i, ++it)
+        {
+        }
+
+        geometry::convert(*it, point);
+        return true;
+    }
+};
+
+
+template <typename Polygon, bool Reverse, typename SegmentIdentifier, typename PointOut>
+struct copy_segment_point_polygon
+{
+    static inline bool apply(Polygon const& polygon,
+            SegmentIdentifier const& seg_id, int offset,
+            PointOut& point)
+    {
+        // Call ring-version with the right ring
+        return copy_segment_point_range
+            <
+                typename geometry::ring_type<Polygon>::type,
+                Reverse,
+                SegmentIdentifier,
+                PointOut
+            >::apply
+                (
+                    seg_id.ring_index < 0
+                        ? geometry::exterior_ring(polygon)
+                        : range::at(geometry::interior_rings(polygon), seg_id.ring_index),
+                    seg_id, offset,
+                    point
+                );
+    }
+};
+
+
+template <typename Box, bool Reverse, typename SegmentIdentifier, typename PointOut>
+struct copy_segment_point_box
+{
+    static inline bool apply(Box const& box,
+            SegmentIdentifier const& seg_id, int offset,
+            PointOut& point)
+    {
+        signed_size_type index = seg_id.segment_index;
+        for (int i = 0; i < offset; i++)
+        {
+            index++;
+        }
+
+        boost::array<typename point_type<Box>::type, 4> bp;
+        assign_box_corners_oriented<Reverse>(box, bp);
+        point = bp[index % 4];
+        return true;
+    }
+};
+
+
+template
+<
+    typename MultiGeometry,
+    typename SegmentIdentifier,
+    typename PointOut,
+    typename Policy
+>
+struct copy_segment_point_multi
+{
+    static inline bool apply(MultiGeometry const& multi,
+                             SegmentIdentifier const& seg_id, int offset,
+                             PointOut& point)
+    {
+
+        BOOST_GEOMETRY_ASSERT
+            (
+                seg_id.multi_index >= 0
+                && seg_id.multi_index < int(boost::size(multi))
+            );
+
+        // Call the single-version
+        return Policy::apply(range::at(multi, seg_id.multi_index), seg_id, offset, point);
+    }
+};
+
+
+}} // namespace detail::copy_segments
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template
+<
+    typename Tag,
+    typename GeometryIn,
+    bool Reverse,
+    typename SegmentIdentifier,
+    typename PointOut
+>
+struct copy_segment_point
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_OR_NOT_YET_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
+            , (types<GeometryIn>)
+        );
+};
+
+
+template <typename LineString, bool Reverse, typename SegmentIdentifier, typename PointOut>
+struct copy_segment_point<linestring_tag, LineString, Reverse, SegmentIdentifier, PointOut>
+    : detail::copy_segments::copy_segment_point_range
+        <
+            LineString, Reverse, SegmentIdentifier, PointOut
+        >
+{};
+
+
+template <typename Ring, bool Reverse, typename SegmentIdentifier, typename PointOut>
+struct copy_segment_point<ring_tag, Ring, Reverse, SegmentIdentifier, PointOut>
+    : detail::copy_segments::copy_segment_point_range
+        <
+            Ring, Reverse, SegmentIdentifier, PointOut
+        >
+{};
+
+template <typename Polygon, bool Reverse, typename SegmentIdentifier, typename PointOut>
+struct copy_segment_point<polygon_tag, Polygon, Reverse, SegmentIdentifier, PointOut>
+    : detail::copy_segments::copy_segment_point_polygon
+        <
+            Polygon, Reverse, SegmentIdentifier, PointOut
+        >
+{};
+
+
+template <typename Box, bool Reverse, typename SegmentIdentifier, typename PointOut>
+struct copy_segment_point<box_tag, Box, Reverse, SegmentIdentifier, PointOut>
+    : detail::copy_segments::copy_segment_point_box
+        <
+            Box, Reverse, SegmentIdentifier, PointOut
+        >
+{};
+
+
+template
+<
+    typename MultiGeometry,
+    bool Reverse,
+    typename SegmentIdentifier,
+    typename PointOut
+>
+struct copy_segment_point
+    <
+        multi_polygon_tag,
+        MultiGeometry,
+        Reverse,
+        SegmentIdentifier,
+        PointOut
+    >
+    : detail::copy_segments::copy_segment_point_multi
+        <
+            MultiGeometry,
+            SegmentIdentifier,
+            PointOut,
+            detail::copy_segments::copy_segment_point_polygon
+                <
+                    typename boost::range_value<MultiGeometry>::type,
+                    Reverse,
+                    SegmentIdentifier,
+                    PointOut
+                >
+        >
+{};
+
+template
+<
+    typename MultiGeometry,
+    bool Reverse,
+    typename SegmentIdentifier,
+    typename PointOut
+>
+struct copy_segment_point
+    <
+        multi_linestring_tag,
+        MultiGeometry,
+        Reverse,
+        SegmentIdentifier,
+        PointOut
+    >
+    : detail::copy_segments::copy_segment_point_multi
+        <
+            MultiGeometry,
+            SegmentIdentifier,
+            PointOut,
+            detail::copy_segments::copy_segment_point_range
+                <
+                    typename boost::range_value<MultiGeometry>::type,
+                    Reverse,
+                    SegmentIdentifier,
+                    PointOut
+                >
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+
+
+
+/*!
+    \brief Helper function, copies a point from a segment
+    \ingroup overlay
+ */
+template<bool Reverse, typename Geometry, typename SegmentIdentifier, typename PointOut>
+inline bool copy_segment_point(Geometry const& geometry,
+            SegmentIdentifier const& seg_id, int offset,
+            PointOut& point_out)
+{
+    concepts::check<Geometry const>();
+
+    return dispatch::copy_segment_point
+        <
+            typename tag<Geometry>::type,
+            Geometry,
+            Reverse,
+            SegmentIdentifier,
+            PointOut
+        >::apply(geometry, seg_id, offset, point_out);
+}
+
+
+/*!
+    \brief Helper function, to avoid the same construct several times,
+        copies a point, based on a source-index and two geometries
+    \ingroup overlay
+ */
+template
+<
+    bool Reverse1, bool Reverse2,
+    typename Geometry1, typename Geometry2,
+    typename SegmentIdentifier,
+    typename PointOut
+>
+inline bool copy_segment_point(Geometry1 const& geometry1, Geometry2 const& geometry2,
+            SegmentIdentifier const& seg_id, int offset,
+            PointOut& point_out)
+{
+    concepts::check<Geometry1 const>();
+    concepts::check<Geometry2 const>();
+
+    BOOST_GEOMETRY_ASSERT(seg_id.source_index == 0 || seg_id.source_index == 1);
+
+    if (seg_id.source_index == 0)
+    {
+        return dispatch::copy_segment_point
+            <
+                typename tag<Geometry1>::type,
+                Geometry1,
+                Reverse1,
+                SegmentIdentifier,
+                PointOut
+            >::apply(geometry1, seg_id, offset, point_out);
+    }
+    else if (seg_id.source_index == 1)
+    {
+        return dispatch::copy_segment_point
+            <
+                typename tag<Geometry2>::type,
+                Geometry2,
+                Reverse2,
+                SegmentIdentifier,
+                PointOut
+            >::apply(geometry2, seg_id, offset, point_out);
+    }
+    // Exception?
+    return false;
+}
+
+
+/*!
+    \brief Helper function, to avoid the same construct several times,
+        copies a point, based on a source-index and two geometries
+    \ingroup overlay
+ */
+template
+<
+    bool Reverse1, bool Reverse2,
+    typename Geometry1, typename Geometry2,
+    typename SegmentIdentifier,
+    typename PointOut
+>
+inline bool copy_segment_points(Geometry1 const& geometry1, Geometry2 const& geometry2,
+            SegmentIdentifier const& seg_id,
+            PointOut& point1, PointOut& point2)
+{
+    concepts::check<Geometry1 const>();
+    concepts::check<Geometry2 const>();
+
+    return copy_segment_point<Reverse1, Reverse2>(geometry1, geometry2, seg_id, 0, point1)
+        && copy_segment_point<Reverse1, Reverse2>(geometry1, geometry2, seg_id, 1, point2);
+}
+
+/*!
+    \brief Helper function, copies three points: two from the specified segment
+    (from, to) and the next one
+    \ingroup overlay
+ */
+template
+<
+    bool Reverse1, bool Reverse2,
+    typename Geometry1, typename Geometry2,
+    typename SegmentIdentifier,
+    typename PointOut
+>
+inline bool copy_segment_points(Geometry1 const& geometry1, Geometry2 const& geometry2,
+            SegmentIdentifier const& seg_id,
+            PointOut& point1, PointOut& point2, PointOut& point3)
+{
+    concepts::check<Geometry1 const>();
+    concepts::check<Geometry2 const>();
+
+    return copy_segment_point<Reverse1, Reverse2>(geometry1, geometry2, seg_id, 0, point1)
+        && copy_segment_point<Reverse1, Reverse2>(geometry1, geometry2, seg_id, 1, point2)
+        && copy_segment_point<Reverse1, Reverse2>(geometry1, geometry2, seg_id, 2, point3);
+}
+
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_COPY_SEGMENT_POINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/copy_segments.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/copy_segments.hpp
new file mode 100644
index 00000000000..c6f540a9788
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/copy_segments.hpp
@@ -0,0 +1,383 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014, 2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_COPY_SEGMENTS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_COPY_SEGMENTS_HPP
+
+
+#include <vector>
+
+#include <boost/array.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/range.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/iterators/ever_circling_iterator.hpp>
+#include <boost/geometry/views/closeable_view.hpp>
+#include <boost/geometry/views/reversible_view.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/append_no_duplicates.hpp>
+#include <boost/geometry/algorithms/detail/overlay/append_no_dups_or_spikes.hpp>
+#include <boost/geometry/algorithms/detail/signed_size_type.hpp>
+
+#include <boost/geometry/util/range.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace copy_segments
+{
+
+
+template <bool Reverse>
+struct copy_segments_ring
+{
+    template
+    <
+        typename Ring,
+        typename SegmentIdentifier,
+        typename SideStrategy,
+        typename RobustPolicy,
+        typename RangeOut
+    >
+    static inline void apply(Ring const& ring,
+            SegmentIdentifier const& seg_id,
+            signed_size_type to_index,
+            SideStrategy const& strategy,
+            RobustPolicy const& robust_policy,
+            RangeOut& current_output)
+    {
+        typedef typename closeable_view
+        <
+            Ring const,
+            closure<Ring>::value
+        >::type cview_type;
+
+        typedef typename reversible_view
+        <
+            cview_type const,
+            Reverse ? iterate_reverse : iterate_forward
+        >::type rview_type;
+
+        typedef typename boost::range_iterator<rview_type const>::type iterator;
+        typedef geometry::ever_circling_iterator<iterator> ec_iterator;
+
+
+        cview_type cview(ring);
+        rview_type view(cview);
+
+        // The problem: sometimes we want to from "3" to "2"
+        // -> end = "3" -> end == begin
+        // This is not convenient with iterators.
+
+        // So we use the ever-circling iterator and determine when to step out
+
+        signed_size_type const from_index = seg_id.segment_index + 1;
+
+        // Sanity check
+        BOOST_GEOMETRY_ASSERT(from_index < static_cast<signed_size_type>(boost::size(view)));
+
+        ec_iterator it(boost::begin(view), boost::end(view),
+                    boost::begin(view) + from_index);
+
+        // [2..4] -> 4 - 2 + 1 = 3 -> {2,3,4} -> OK
+        // [4..2],size=6 -> 6 - 4 + 2 + 1 = 5 -> {4,5,0,1,2} -> OK
+        // [1..1], travel the whole ring round
+        signed_size_type const count = from_index <= to_index
+            ? to_index - from_index + 1
+            : static_cast<signed_size_type>(boost::size(view))
+                - from_index + to_index + 1;
+
+        for (signed_size_type i = 0; i < count; ++i, ++it)
+        {
+            detail::overlay::append_no_dups_or_spikes(current_output, *it, strategy, robust_policy);
+        }
+    }
+};
+
+template <bool Reverse, bool RemoveSpikes = true>
+class copy_segments_linestring
+{
+private:
+    // remove spikes
+    template <typename RangeOut, typename Point, typename SideStrategy, typename RobustPolicy>
+    static inline void append_to_output(RangeOut& current_output,
+                                        Point const& point,
+                                        SideStrategy const& strategy,
+                                        RobustPolicy const& robust_policy,
+                                        boost::true_type const&)
+    {
+        detail::overlay::append_no_dups_or_spikes(current_output, point,
+                                                  strategy,
+                                                  robust_policy);
+    }
+
+    // keep spikes
+    template <typename RangeOut, typename Point, typename SideStrategy, typename RobustPolicy>
+    static inline void append_to_output(RangeOut& current_output,
+                                        Point const& point,
+                                        SideStrategy const&,
+                                        RobustPolicy const&,
+                                        boost::false_type const&)
+    {
+        detail::overlay::append_no_duplicates(current_output, point);
+    }
+
+public:
+    template
+    <
+        typename LineString,
+        typename SegmentIdentifier,
+        typename SideStrategy,
+        typename RobustPolicy,
+        typename RangeOut
+    >
+    static inline void apply(LineString const& ls,
+            SegmentIdentifier const& seg_id,
+            signed_size_type to_index,
+            SideStrategy const& strategy,
+            RobustPolicy const& robust_policy,
+            RangeOut& current_output)
+    {
+        signed_size_type const from_index = seg_id.segment_index + 1;
+
+        // Sanity check
+        if ( from_index > to_index
+          || from_index < 0
+          || to_index >= static_cast<signed_size_type>(boost::size(ls)) )
+        {
+            return;
+        }
+
+        signed_size_type const count = to_index - from_index + 1;
+
+        typename boost::range_iterator<LineString const>::type
+            it = boost::begin(ls) + from_index;
+
+        for (signed_size_type i = 0; i < count; ++i, ++it)
+        {
+            append_to_output(current_output, *it, strategy, robust_policy,
+                             boost::integral_constant<bool, RemoveSpikes>());
+        }
+    }
+};
+
+template <bool Reverse>
+struct copy_segments_polygon
+{
+    template
+    <
+        typename Polygon,
+        typename SegmentIdentifier,
+        typename SideStrategy,
+        typename RobustPolicy,
+        typename RangeOut
+    >
+    static inline void apply(Polygon const& polygon,
+            SegmentIdentifier const& seg_id,
+            signed_size_type to_index,
+            SideStrategy const& strategy,
+            RobustPolicy const& robust_policy,
+            RangeOut& current_output)
+    {
+        // Call ring-version with the right ring
+        copy_segments_ring<Reverse>::apply
+            (
+                seg_id.ring_index < 0
+                    ? geometry::exterior_ring(polygon)
+                    : range::at(geometry::interior_rings(polygon), seg_id.ring_index),
+                seg_id, to_index,
+                strategy,
+                robust_policy,
+                current_output
+            );
+    }
+};
+
+
+template <bool Reverse>
+struct copy_segments_box
+{
+    template
+    <
+        typename Box,
+        typename SegmentIdentifier,
+        typename SideStrategy,
+        typename RobustPolicy,
+        typename RangeOut
+    >
+    static inline void apply(Box const& box,
+            SegmentIdentifier const& seg_id,
+            signed_size_type to_index,
+            SideStrategy const& strategy,
+            RobustPolicy const& robust_policy,
+            RangeOut& current_output)
+    {
+        signed_size_type index = seg_id.segment_index + 1;
+        BOOST_GEOMETRY_ASSERT(index < 5);
+
+        signed_size_type const count = index <= to_index
+            ? to_index - index + 1
+            : 5 - index + to_index + 1;
+
+        // Create array of points, the fifth one closes it
+        boost::array<typename point_type<Box>::type, 5> bp;
+        assign_box_corners_oriented<Reverse>(box, bp);
+        bp[4] = bp[0];
+
+        // (possibly cyclic) copy to output
+        //    (see comments in ring-version)
+        for (signed_size_type i = 0; i < count; i++, index++)
+        {
+            detail::overlay::append_no_dups_or_spikes(current_output,
+                bp[index % 5], strategy, robust_policy);
+
+        }
+    }
+};
+
+
+template<typename Policy>
+struct copy_segments_multi
+{
+    template
+    <
+        typename MultiGeometry,
+        typename SegmentIdentifier,
+        typename SideStrategy,
+        typename RobustPolicy,
+        typename RangeOut
+    >
+    static inline void apply(MultiGeometry const& multi_geometry,
+            SegmentIdentifier const& seg_id,
+            signed_size_type to_index,
+            SideStrategy const& strategy,
+            RobustPolicy const& robust_policy,
+            RangeOut& current_output)
+    {
+
+        BOOST_GEOMETRY_ASSERT
+            (
+                seg_id.multi_index >= 0
+                && static_cast<std::size_t>(seg_id.multi_index) < boost::size(multi_geometry)
+            );
+
+        // Call the single-version
+        Policy::apply(range::at(multi_geometry, seg_id.multi_index),
+                      seg_id, to_index,
+                      strategy,
+                      robust_policy,
+                      current_output);
+    }
+};
+
+
+}} // namespace detail::copy_segments
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Tag,
+    bool Reverse
+>
+struct copy_segments : not_implemented<Tag>
+{};
+
+
+template <bool Reverse>
+struct copy_segments<ring_tag, Reverse>
+    : detail::copy_segments::copy_segments_ring<Reverse>
+{};
+
+
+template <bool Reverse>
+struct copy_segments<linestring_tag, Reverse>
+    : detail::copy_segments::copy_segments_linestring<Reverse>
+{};
+
+template <bool Reverse>
+struct copy_segments<polygon_tag, Reverse>
+    : detail::copy_segments::copy_segments_polygon<Reverse>
+{};
+
+
+template <bool Reverse>
+struct copy_segments<box_tag, Reverse>
+    : detail::copy_segments::copy_segments_box<Reverse>
+{};
+
+
+template<bool Reverse>
+struct copy_segments<multi_polygon_tag, Reverse>
+    : detail::copy_segments::copy_segments_multi
+        <
+            detail::copy_segments::copy_segments_polygon<Reverse>
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+/*!
+    \brief Copy segments from a geometry, starting with the specified segment (seg_id)
+        until the specified index (to_index)
+    \ingroup overlay
+ */
+template
+<
+    bool Reverse,
+    typename Geometry,
+    typename SegmentIdentifier,
+    typename SideStrategy,
+    typename RobustPolicy,
+    typename RangeOut
+>
+inline void copy_segments(Geometry const& geometry,
+            SegmentIdentifier const& seg_id,
+            signed_size_type to_index,
+            SideStrategy const& strategy,
+            RobustPolicy const& robust_policy,
+            RangeOut& range_out)
+{
+    concepts::check<Geometry const>();
+
+    dispatch::copy_segments
+        <
+            typename tag<Geometry>::type,
+            Reverse
+        >::apply(geometry, seg_id, to_index, strategy, robust_policy, range_out);
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_COPY_SEGMENTS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp
new file mode 100644
index 00000000000..0cc34255cac
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp
@@ -0,0 +1,66 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_DEBUG_TURN_INFO_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_DEBUG_TURN_INFO_HPP
+
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/visit_info.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+inline char method_char(detail::overlay::method_type const& method)
+{
+    using namespace detail::overlay;
+    switch(method)
+    {
+        case method_none : return '-';
+        case method_disjoint : return 'd';
+        case method_crosses : return 'i';
+        case method_touch : return 't';
+        case method_touch_interior : return 'm';
+        case method_collinear : return 'c';
+        case method_equal : return 'e';
+        case method_error : return '!';
+        default : return '?';
+    }
+}
+
+inline char operation_char(detail::overlay::operation_type const& operation)
+{
+    using namespace detail::overlay;
+    switch(operation)
+    {
+        case operation_none : return '-';
+        case operation_union : return 'u';
+        case operation_intersection : return 'i';
+        case operation_blocked : return 'x';
+        case operation_continue : return 'c';
+        case operation_opposite : return 'o';
+        default : return '?';
+    }
+}
+
+inline char visited_char(detail::overlay::visit_info const& v)
+{
+    if (v.rejected()) return 'R';
+    if (v.started()) return 's';
+    if (v.visited()) return 'v';
+    if (v.none()) return '-';
+    if (v.finished()) return 'f';
+    return '?';
+}
+
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_DEBUG_TURN_INFO_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/do_reverse.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/do_reverse.hpp
new file mode 100644
index 00000000000..15100f8d0b7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/do_reverse.hpp
@@ -0,0 +1,47 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2013 Adam Wulkiewicz, Lodz, Poland
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_DO_REVERSE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_DO_REVERSE_HPP
+
+#include <boost/geometry/core/point_order.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+// Metafunction helper for intersection and union
+template <order_selector Selector, bool Reverse = false>
+struct do_reverse {};
+
+template <>
+struct do_reverse<clockwise, false> : boost::false_type {};
+
+template <>
+struct do_reverse<clockwise, true> : boost::true_type {};
+
+template <>
+struct do_reverse<counterclockwise, false> : boost::true_type {};
+
+template <>
+struct do_reverse<counterclockwise, true> : boost::false_type {};
+
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_DO_REVERSE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/enrich_intersection_points.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/enrich_intersection_points.hpp
new file mode 100644
index 00000000000..47225328df5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/enrich_intersection_points.hpp
@@ -0,0 +1,452 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ENRICH_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ENRICH_HPP
+
+#include <cstddef>
+#include <algorithm>
+#include <map>
+#include <set>
+#include <vector>
+
+#ifdef BOOST_GEOMETRY_DEBUG_ENRICH
+#  include <iostream>
+#  include <boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp>
+#  include <boost/geometry/io/wkt/wkt.hpp>
+#  if ! defined(BOOST_GEOMETRY_DEBUG_IDENTIFIER)
+#    define BOOST_GEOMETRY_DEBUG_IDENTIFIER
+  #endif
+#endif
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/detail/ring_identifier.hpp>
+#include <boost/geometry/algorithms/detail/overlay/handle_colocations.hpp>
+#include <boost/geometry/algorithms/detail/overlay/handle_self_turns.hpp>
+#include <boost/geometry/algorithms/detail/overlay/is_self_turn.hpp>
+#include <boost/geometry/algorithms/detail/overlay/less_by_segment_ratio.hpp>
+#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
+#include <boost/geometry/policies/robustness/robust_type.hpp>
+
+#ifdef BOOST_GEOMETRY_DEBUG_ENRICH
+#  include <boost/geometry/algorithms/detail/overlay/check_enrich.hpp>
+#endif
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+// Sorts IP-s of this ring on segment-identifier, and if on same segment,
+//  on distance.
+// Then assigns for each IP which is the next IP on this segment,
+// plus the vertex-index to travel to, plus the next IP
+// (might be on another segment)
+template
+<
+    bool Reverse1, bool Reverse2,
+    typename Operations,
+    typename Turns,
+    typename Geometry1, typename Geometry2,
+    typename RobustPolicy,
+    typename SideStrategy
+>
+inline void enrich_sort(Operations& operations,
+            Turns const& turns,
+            operation_type for_operation,
+            Geometry1 const& geometry1,
+            Geometry2 const& geometry2,
+            RobustPolicy const& robust_policy,
+            SideStrategy const& strategy)
+{
+    std::sort(boost::begin(operations),
+            boost::end(operations),
+            less_by_segment_ratio
+                <
+                    Turns,
+                    typename boost::range_value<Operations>::type,
+                    Geometry1, Geometry2,
+                    RobustPolicy,
+                    SideStrategy,
+                    Reverse1, Reverse2
+                >(turns, for_operation, geometry1, geometry2, robust_policy, strategy));
+}
+
+
+template <typename Operations, typename Turns>
+inline void enrich_assign(Operations& operations, Turns& turns)
+{
+    typedef typename boost::range_value<Turns>::type turn_type;
+    typedef typename turn_type::turn_operation_type op_type;
+    typedef typename boost::range_iterator<Operations>::type iterator_type;
+
+
+    if (operations.size() > 0)
+    {
+        // Assign travel-to-vertex/ip index for each turning point.
+        // Iterator "next" is circular
+
+        geometry::ever_circling_range_iterator<Operations const> next(operations);
+        ++next;
+
+        for (iterator_type it = boost::begin(operations);
+             it != boost::end(operations); ++it)
+        {
+            turn_type& turn = turns[it->turn_index];
+            op_type& op = turn.operations[it->operation_index];
+
+            // Normal behaviour: next should point at next turn:
+            if (it->turn_index == next->turn_index)
+            {
+                ++next;
+            }
+
+            // Cluster behaviour: next should point after cluster, unless
+            // their seg_ids are not the same
+            while (turn.cluster_id != -1
+                   && it->turn_index != next->turn_index
+                   && turn.cluster_id == turns[next->turn_index].cluster_id
+                   && op.seg_id == turns[next->turn_index].operations[next->operation_index].seg_id)
+            {
+                ++next;
+            }
+
+            turn_type const& next_turn = turns[next->turn_index];
+            op_type const& next_op = next_turn.operations[next->operation_index];
+
+            op.enriched.travels_to_ip_index
+                    = static_cast<signed_size_type>(next->turn_index);
+            op.enriched.travels_to_vertex_index
+                    = next->subject->seg_id.segment_index;
+
+            if (op.seg_id.segment_index == next_op.seg_id.segment_index
+                    && op.fraction < next_op.fraction)
+            {
+                // Next turn is located further on same segment
+                // assign next_ip_index
+                // (this is one not circular therefore fraction is considered)
+                op.enriched.next_ip_index = static_cast<signed_size_type>(next->turn_index);
+            }
+        }
+    }
+
+    // DEBUG
+#ifdef BOOST_GEOMETRY_DEBUG_ENRICH
+    {
+        for (iterator_type it = boost::begin(operations);
+             it != boost::end(operations);
+             ++it)
+        {
+            op_type const& op = turns[it->turn_index]
+                .operations[it->operation_index];
+
+            std::cout << it->turn_index
+                << " cl=" << turns[it->turn_index].cluster_id
+                << " meth=" << method_char(turns[it->turn_index].method)
+                << " seg=" << op.seg_id
+                << " dst=" << op.fraction // needs define
+                << " op=" << operation_char(turns[it->turn_index].operations[0].operation)
+                << operation_char(turns[it->turn_index].operations[1].operation)
+                << " (" << operation_char(op.operation) << ")"
+                << " nxt=" << op.enriched.next_ip_index
+                << " / " << op.enriched.travels_to_ip_index
+                << " [vx " << op.enriched.travels_to_vertex_index << "]"
+                << std::boolalpha << turns[it->turn_index].discarded
+                << std::endl;
+                ;
+        }
+    }
+#endif
+    // END DEBUG
+
+}
+
+
+template <typename Turns, typename MappedVector>
+inline void create_map(Turns const& turns, MappedVector& mapped_vector)
+{
+    typedef typename boost::range_value<Turns>::type turn_type;
+    typedef typename turn_type::container_type container_type;
+    typedef typename MappedVector::mapped_type mapped_type;
+    typedef typename boost::range_value<mapped_type>::type indexed_type;
+
+    std::size_t index = 0;
+    for (typename boost::range_iterator<Turns const>::type
+            it = boost::begin(turns);
+         it != boost::end(turns);
+         ++it, ++index)
+    {
+        // Add all (non discarded) operations on this ring
+        // Blocked operations or uu on clusters (for intersection)
+        // should be included, to block potential paths in clusters
+        turn_type const& turn = *it;
+        if (turn.discarded)
+        {
+            continue;
+        }
+
+        std::size_t op_index = 0;
+        for (typename boost::range_iterator<container_type const>::type
+                op_it = boost::begin(turn.operations);
+            op_it != boost::end(turn.operations);
+            ++op_it, ++op_index)
+        {
+            ring_identifier const ring_id
+                (
+                    op_it->seg_id.source_index,
+                    op_it->seg_id.multi_index,
+                    op_it->seg_id.ring_index
+                );
+            mapped_vector[ring_id].push_back
+                (
+                    indexed_type(index, op_index, *op_it,
+                        it->operations[1 - op_index].seg_id)
+                );
+        }
+    }
+}
+
+template <typename Point1, typename Point2>
+inline typename geometry::coordinate_type<Point1>::type
+        distance_measure(Point1 const& a, Point2 const& b)
+{
+    // TODO: use comparable distance for point-point instead - but that
+    // causes currently cycling include problems
+    typedef typename geometry::coordinate_type<Point1>::type ctype;
+    ctype const dx = get<0>(a) - get<0>(b);
+    ctype const dy = get<1>(a) - get<1>(b);
+    return dx * dx + dy * dy;
+}
+
+template <typename Turns>
+inline void calculate_remaining_distance(Turns& turns)
+{
+    typedef typename boost::range_value<Turns>::type turn_type;
+    typedef typename turn_type::turn_operation_type op_type;
+
+    for (typename boost::range_iterator<Turns>::type
+            it = boost::begin(turns);
+         it != boost::end(turns);
+         ++it)
+    {
+        turn_type& turn = *it;
+        if (! turn.both(detail::overlay::operation_continue))
+        {
+           continue;
+        }
+
+        op_type& op0 = turn.operations[0];
+        op_type& op1 = turn.operations[1];
+
+        if (op0.remaining_distance != 0
+         || op1.remaining_distance != 0)
+        {
+            continue;
+        }
+
+        int const to_index0 = op0.enriched.get_next_turn_index();
+        int const to_index1 = op1.enriched.get_next_turn_index();
+        if (to_index1 >= 0
+                && to_index1 >= 0
+                && to_index0 != to_index1)
+        {
+            op0.remaining_distance = distance_measure(turn.point, turns[to_index0].point);
+            op1.remaining_distance = distance_measure(turn.point, turns[to_index1].point);
+        }
+    }
+}
+
+
+}} // namespace detail::overlay
+#endif //DOXYGEN_NO_DETAIL
+
+
+
+/*!
+\brief All intersection points are enriched with successor information
+\ingroup overlay
+\tparam Turns type of intersection container
+            (e.g. vector of "intersection/turn point"'s)
+\tparam Clusters type of cluster container
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam SideStrategy side strategy type
+\param turns container containing intersection points
+\param clusters container containing clusters
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param robust_policy policy to handle robustness issues
+\param strategy strategy
+ */
+template
+<
+    bool Reverse1, bool Reverse2,
+    overlay_type OverlayType,
+    typename Turns,
+    typename Clusters,
+    typename Geometry1, typename Geometry2,
+    typename RobustPolicy,
+    typename SideStrategy
+>
+inline void enrich_intersection_points(Turns& turns,
+    Clusters& clusters,
+    Geometry1 const& geometry1, Geometry2 const& geometry2,
+    RobustPolicy const& robust_policy,
+    SideStrategy const& strategy)
+{
+    static const detail::overlay::operation_type target_operation
+            = detail::overlay::operation_from_overlay<OverlayType>::value;
+    static const detail::overlay::operation_type opposite_operation
+            = target_operation == detail::overlay::operation_union
+            ? detail::overlay::operation_intersection
+            : detail::overlay::operation_union;
+
+    typedef typename boost::range_value<Turns>::type turn_type;
+    typedef typename turn_type::turn_operation_type op_type;
+    typedef detail::overlay::indexed_turn_operation
+        <
+            op_type
+        > indexed_turn_operation;
+
+    typedef std::map
+        <
+            ring_identifier,
+            std::vector<indexed_turn_operation>
+        > mapped_vector_type;
+
+    bool has_cc = false;
+    bool const has_colocations
+        = detail::overlay::handle_colocations<Reverse1, Reverse2, OverlayType>(turns,
+        clusters, geometry1, geometry2);
+
+    // Discard turns not part of target overlay
+    for (typename boost::range_iterator<Turns>::type
+            it = boost::begin(turns);
+         it != boost::end(turns);
+         ++it)
+    {
+        turn_type& turn = *it;
+
+        if (turn.both(detail::overlay::operation_none))
+        {
+            turn.discarded = true;
+            continue;
+        }
+
+        if (turn.both(opposite_operation))
+        {
+            // For intersections, remove uu to avoid the need to travel
+            // a union (during intersection) in uu/cc clusters (e.g. #31,#32,#33)
+            // Also, for union, discard ii
+            turn.discarded = true;
+            turn.cluster_id = -1;
+            continue;
+        }
+
+        if (detail::overlay::is_self_turn<OverlayType>(turn)
+            && turn.cluster_id < 0
+            && ! turn.both(target_operation))
+        {
+            // Only keep self-uu-turns or self-ii-turns
+           turn.discarded = true;
+           turn.cluster_id = -1;
+           continue;
+        }
+
+        if (! turn.discarded
+            && turn.both(detail::overlay::operation_continue))
+        {
+            has_cc = true;
+        }
+    }
+
+    detail::overlay::discard_closed_turns
+        <
+            OverlayType,
+            target_operation
+        >::apply(turns, geometry1, geometry2);
+    detail::overlay::discard_open_turns
+        <
+            OverlayType,
+            target_operation
+        >::apply(turns, geometry1, geometry2);
+
+    // Create a map of vectors of indexed operation-types to be able
+    // to sort intersection points PER RING
+    mapped_vector_type mapped_vector;
+
+    detail::overlay::create_map(turns, mapped_vector);
+
+    // No const-iterator; contents of mapped copy is temporary,
+    // and changed by enrich
+    for (typename mapped_vector_type::iterator mit
+        = mapped_vector.begin();
+        mit != mapped_vector.end();
+        ++mit)
+    {
+#ifdef BOOST_GEOMETRY_DEBUG_ENRICH
+    std::cout << "ENRICH-sort Ring "
+        << mit->first << std::endl;
+#endif
+        detail::overlay::enrich_sort<Reverse1, Reverse2>(
+                    mit->second, turns, target_operation,
+                    geometry1, geometry2,
+                    robust_policy, strategy);
+    }
+
+    for (typename mapped_vector_type::iterator mit
+        = mapped_vector.begin();
+        mit != mapped_vector.end();
+        ++mit)
+    {
+#ifdef BOOST_GEOMETRY_DEBUG_ENRICH
+    std::cout << "ENRICH-assign Ring "
+        << mit->first << std::endl;
+#endif
+        detail::overlay::enrich_assign(mit->second, turns);
+    }
+
+    if (has_colocations)
+    {
+        // First gather cluster properties (using even clusters with
+        // discarded turns - for open turns), then clean up clusters
+        detail::overlay::gather_cluster_properties
+            <
+                Reverse1,
+                Reverse2,
+                OverlayType
+            >(clusters, turns, target_operation,
+              geometry1, geometry2, strategy);
+
+        detail::overlay::cleanup_clusters(turns, clusters);
+    }
+
+    if (has_cc)
+    {
+        detail::overlay::calculate_remaining_distance(turns);
+    }
+
+#ifdef BOOST_GEOMETRY_DEBUG_ENRICH
+    //detail::overlay::check_graph(turns, for_operation);
+#endif
+
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ENRICH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/enrichment_info.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/enrichment_info.hpp
new file mode 100644
index 00000000000..fdffd665e43
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/enrichment_info.hpp
@@ -0,0 +1,82 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ENRICHMENT_INFO_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ENRICHMENT_INFO_HPP
+
+#include <boost/geometry/algorithms/detail/signed_size_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+/*!
+\brief Keeps info to enrich intersection info (per source)
+\details Class to keep information necessary for traversal phase (a phase
+    of the overlay process). The information is gathered during the
+    enrichment phase
+ */
+template<typename Point>
+struct enrichment_info
+{
+    inline enrichment_info()
+        : travels_to_vertex_index(-1)
+        , travels_to_ip_index(-1)
+        , next_ip_index(-1)
+        , startable(true)
+        , count_left(0)
+        , count_right(0)
+        , rank(-1)
+        , zone(-1)
+        , region_id(-1)
+        , isolated(false)
+    {}
+
+    inline signed_size_type get_next_turn_index() const
+    {
+        return next_ip_index == -1 ? travels_to_ip_index : next_ip_index;
+    }
+
+    // vertex to which is free travel after this IP,
+    // so from "segment_index+1" to "travels_to_vertex_index", without IP-s,
+    // can be -1
+    signed_size_type travels_to_vertex_index;
+
+    // same but now IP index, so "next IP index" but not on THIS segment
+    signed_size_type travels_to_ip_index;
+
+    // index of next IP on this segment, -1 if there is no one
+    signed_size_type next_ip_index;
+
+    bool startable; // Can be used to start in traverse
+
+    // Counts if polygons left/right of this operation
+    std::size_t count_left;
+    std::size_t count_right;
+    signed_size_type rank; // in cluster
+    signed_size_type zone; // open zone, in cluster
+    signed_size_type region_id;
+    bool isolated;
+};
+
+
+}} // namespace detail::overlay
+#endif //DOXYGEN_NO_DETAIL
+
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_ENRICHMENT_INFO_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/follow.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/follow.hpp
new file mode 100644
index 00000000000..589e12cc2bf
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/follow.hpp
@@ -0,0 +1,513 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014, 2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_FOLLOW_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_FOLLOW_HPP
+
+#include <cstddef>
+
+#include <boost/range.hpp>
+#include <boost/mpl/assert.hpp>
+
+#include <boost/geometry/algorithms/detail/point_on_border.hpp>
+#include <boost/geometry/algorithms/detail/overlay/append_no_duplicates.hpp>
+#include <boost/geometry/algorithms/detail/overlay/copy_segments.hpp>
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+
+#include <boost/geometry/algorithms/covered_by.hpp>
+#include <boost/geometry/algorithms/clear.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+namespace following
+{
+
+template <typename Turn, typename Operation>
+static inline bool is_entering(Turn const& /* TODO remove this parameter */, Operation const& op)
+{
+    // (Blocked means: blocked for polygon/polygon intersection, because
+    // they are reversed. But for polygon/line it is similar to continue)
+    return op.operation == operation_intersection
+        || op.operation == operation_continue
+        || op.operation == operation_blocked
+        ;
+}
+
+template
+<
+    typename Turn,
+    typename Operation,
+    typename LineString,
+    typename Polygon,
+    typename PtInPolyStrategy
+>
+static inline bool last_covered_by(Turn const& turn, Operation const& op,
+                LineString const& linestring, Polygon const& polygon,
+                PtInPolyStrategy const& strategy)
+{
+    return geometry::covered_by(range::at(linestring, op.seg_id.segment_index), polygon, strategy);
+}
+
+
+template
+<
+    typename Turn,
+    typename Operation,
+    typename LineString,
+    typename Polygon,
+    typename PtInPolyStrategy
+>
+static inline bool is_leaving(Turn const& turn, Operation const& op,
+                bool entered, bool first,
+                LineString const& linestring, Polygon const& polygon,
+                PtInPolyStrategy const& strategy)
+{
+    if (op.operation == operation_union)
+    {
+        return entered
+            || turn.method == method_crosses
+            || (first && last_covered_by(turn, op, linestring, polygon, strategy))
+            ;
+    }
+    return false;
+}
+
+
+template
+<
+    typename Turn,
+    typename Operation,
+    typename LineString,
+    typename Polygon,
+    typename PtInPolyStrategy
+>
+static inline bool is_staying_inside(Turn const& turn, Operation const& op,
+                bool entered, bool first,
+                LineString const& linestring, Polygon const& polygon,
+                PtInPolyStrategy const& strategy)
+{
+    if (turn.method == method_crosses)
+    {
+        // The normal case, this is completely covered with entering/leaving
+        // so stay out of this time consuming "covered_by"
+        return false;
+    }
+
+    if (is_entering(turn, op))
+    {
+        return entered || (first && last_covered_by(turn, op, linestring, polygon, strategy));
+    }
+
+    return false;
+}
+
+template
+<
+    typename Turn,
+    typename Operation,
+    typename Linestring,
+    typename Polygon,
+    typename PtInPolyStrategy
+>
+static inline bool was_entered(Turn const& turn, Operation const& op, bool first,
+                Linestring const& linestring, Polygon const& polygon,
+                PtInPolyStrategy const& strategy)
+{
+    if (first && (turn.method == method_collinear || turn.method == method_equal))
+    {
+        return last_covered_by(turn, op, linestring, polygon, strategy);
+    }
+    return false;
+}
+
+
+// Template specialization structure to call the right actions for the right type
+template <overlay_type OverlayType, bool RemoveSpikes = true>
+struct action_selector
+{
+    // If you get here the overlay type is not intersection or difference
+    // BOOST_MPL_ASSERT(false);
+};
+
+// Specialization for intersection, containing the implementation
+template <bool RemoveSpikes>
+struct action_selector<overlay_intersection, RemoveSpikes>
+{
+    template
+    <
+        typename OutputIterator,
+        typename LineStringOut,
+        typename LineString,
+        typename Point,
+        typename Operation,
+        typename SideStrategy,
+        typename RobustPolicy
+    >
+    static inline void enter(LineStringOut& current_piece,
+                LineString const& ,
+                segment_identifier& segment_id,
+                signed_size_type , Point const& point,
+                Operation const& operation,
+                SideStrategy const& ,
+                RobustPolicy const& ,
+                OutputIterator& )
+    {
+        // On enter, append the intersection point and remember starting point
+        // TODO: we don't check on spikes for linestrings (?). Consider this.
+        detail::overlay::append_no_duplicates(current_piece, point);
+        segment_id = operation.seg_id;
+    }
+
+    template
+    <
+        typename OutputIterator,
+        typename LineStringOut,
+        typename LineString,
+        typename Point,
+        typename Operation,
+        typename SideStrategy,
+        typename RobustPolicy
+    >
+    static inline void leave(LineStringOut& current_piece,
+                LineString const& linestring,
+                segment_identifier& segment_id,
+                signed_size_type index, Point const& point,
+                Operation const& ,
+                SideStrategy const& strategy,
+                RobustPolicy const& robust_policy,
+                OutputIterator& out)
+    {
+        // On leave, copy all segments from starting point, append the intersection point
+        // and add the output piece
+        detail::copy_segments::copy_segments_linestring
+            <
+                false, RemoveSpikes
+            >::apply(linestring, segment_id, index, strategy, robust_policy, current_piece);
+        detail::overlay::append_no_duplicates(current_piece, point);
+        if (::boost::size(current_piece) > 1)
+        {
+            *out++ = current_piece;
+        }
+
+        geometry::clear(current_piece);
+    }
+
+    template
+    <
+        typename OutputIterator,
+        typename LineStringOut,
+        typename LineString,
+        typename Point,
+        typename Operation
+    >
+    static inline void isolated_point(LineStringOut&,
+                LineString const&,
+                segment_identifier&,
+                signed_size_type, Point const& point,
+                Operation const& , OutputIterator& out)
+    {
+        LineStringOut isolated_point_ls;
+        geometry::append(isolated_point_ls, point);
+
+#ifndef BOOST_GEOMETRY_ALLOW_ONE_POINT_LINESTRINGS
+        geometry::append(isolated_point_ls, point);
+#endif // BOOST_GEOMETRY_ALLOW_ONE_POINT_LINESTRINGS
+
+        *out++ = isolated_point_ls;
+    }
+
+    static inline bool is_entered(bool entered)
+    {
+        return entered;
+    }
+
+    static inline bool included(int inside_value)
+    {
+        return inside_value >= 0; // covered_by
+    }
+
+};
+
+// Specialization for difference, which reverses these actions
+template <bool RemoveSpikes>
+struct action_selector<overlay_difference, RemoveSpikes>
+{
+    typedef action_selector<overlay_intersection, RemoveSpikes> normal_action;
+
+    template
+    <
+        typename OutputIterator,
+        typename LineStringOut,
+        typename LineString,
+        typename Point,
+        typename Operation,
+        typename SideStrategy,
+        typename RobustPolicy
+    >
+    static inline void enter(LineStringOut& current_piece,
+                LineString const& linestring,
+                segment_identifier& segment_id,
+                signed_size_type index, Point const& point,
+                Operation const& operation,
+                SideStrategy const& strategy,
+                RobustPolicy const& robust_policy,
+                OutputIterator& out)
+    {
+        normal_action::leave(current_piece, linestring, segment_id, index,
+                    point, operation, strategy, robust_policy, out);
+    }
+
+    template
+    <
+        typename OutputIterator,
+        typename LineStringOut,
+        typename LineString,
+        typename Point,
+        typename Operation,
+        typename SideStrategy,
+        typename RobustPolicy
+    >
+    static inline void leave(LineStringOut& current_piece,
+                LineString const& linestring,
+                segment_identifier& segment_id,
+                signed_size_type index, Point const& point,
+                Operation const& operation,
+                SideStrategy const& strategy,
+                RobustPolicy const& robust_policy,
+                OutputIterator& out)
+    {
+        normal_action::enter(current_piece, linestring, segment_id, index,
+                    point, operation, strategy, robust_policy, out);
+    }
+
+    template
+    <
+        typename OutputIterator,
+        typename LineStringOut,
+        typename LineString,
+        typename Point,
+        typename Operation
+    >
+    static inline void isolated_point(LineStringOut&,
+                LineString const&,
+                segment_identifier&,
+                signed_size_type, Point const&,
+                Operation const&, OutputIterator&)
+    {
+    }
+
+    static inline bool is_entered(bool entered)
+    {
+        return ! normal_action::is_entered(entered);
+    }
+
+    static inline bool included(int inside_value)
+    {
+        return ! normal_action::included(inside_value);
+    }
+
+};
+
+}
+
+/*!
+\brief Follows a linestring from intersection point to intersection point, outputting which
+    is inside, or outside, a ring or polygon
+\ingroup overlay
+ */
+template
+<
+    typename LineStringOut,
+    typename LineString,
+    typename Polygon,
+    overlay_type OverlayType,
+    bool RemoveSpikes = true
+>
+class follow
+{
+
+    template <typename Turn>
+    struct sort_on_segment
+    {
+        // In case of turn point at the same location, we want to have continue/blocked LAST
+        // because that should be followed (intersection) or skipped (difference).
+        inline int operation_order(Turn const& turn) const
+        {
+            operation_type const& operation = turn.operations[0].operation;
+            switch(operation)
+            {
+                case operation_opposite : return 0;
+                case operation_none : return 0;
+                case operation_union : return 1;
+                case operation_intersection : return 2;
+                case operation_blocked : return 3;
+                case operation_continue : return 4;
+            }
+            return -1;
+        };
+
+        inline bool use_operation(Turn const& left, Turn const& right) const
+        {
+            // If they are the same, OK.
+            return operation_order(left) < operation_order(right);
+        }
+
+        inline bool use_distance(Turn const& left, Turn const& right) const
+        {
+            return left.operations[0].fraction == right.operations[0].fraction
+                ? use_operation(left, right)
+                : left.operations[0].fraction < right.operations[0].fraction
+                ;
+        }
+
+        inline bool operator()(Turn const& left, Turn const& right) const
+        {
+            segment_identifier const& sl = left.operations[0].seg_id;
+            segment_identifier const& sr = right.operations[0].seg_id;
+
+            return sl == sr
+                ? use_distance(left, right)
+                : sl < sr
+                ;
+
+        }
+    };
+
+
+
+public :
+
+    static inline bool included(int inside_value)
+    {
+        return following::action_selector
+            <
+                OverlayType, RemoveSpikes
+            >::included(inside_value);
+    }
+
+    template
+    <
+        typename Turns,
+        typename OutputIterator,
+        typename RobustPolicy,
+        typename Strategy
+    >
+    static inline OutputIterator apply(LineString const& linestring, Polygon const& polygon,
+                detail::overlay::operation_type ,  // TODO: this parameter might be redundant
+                Turns& turns,
+                RobustPolicy const& robust_policy,
+                OutputIterator out,
+                Strategy const& strategy)
+    {
+        typedef typename boost::range_iterator<Turns>::type turn_iterator;
+        typedef typename boost::range_value<Turns>::type turn_type;
+        typedef typename boost::range_iterator
+            <
+                typename turn_type::container_type
+            >::type turn_operation_iterator_type;
+
+        typedef following::action_selector<OverlayType, RemoveSpikes> action;
+
+        typename Strategy::template point_in_geometry_strategy
+            <
+                LineString, Polygon
+            >::type const pt_in_poly_strategy
+            = strategy.template get_point_in_geometry_strategy<LineString, Polygon>();
+
+        // Sort intersection points on segments-along-linestring, and distance
+        // (like in enrich is done for poly/poly)
+        std::sort(boost::begin(turns), boost::end(turns), sort_on_segment<turn_type>());
+
+        LineStringOut current_piece;
+        geometry::segment_identifier current_segment_id(0, -1, -1, -1);
+
+        // Iterate through all intersection points (they are ordered along the line)
+        bool entered = false;
+        bool first = true;
+        for (turn_iterator it = boost::begin(turns); it != boost::end(turns); ++it)
+        {
+            turn_operation_iterator_type iit = boost::begin(it->operations);
+
+            if (following::was_entered(*it, *iit, first, linestring, polygon, pt_in_poly_strategy))
+            {
+                debug_traverse(*it, *iit, "-> Was entered");
+                entered = true;
+            }
+
+            if (following::is_staying_inside(*it, *iit, entered, first, linestring, polygon, pt_in_poly_strategy))
+            {
+                debug_traverse(*it, *iit, "-> Staying inside");
+
+                entered = true;
+            }
+            else if (following::is_entering(*it, *iit))
+            {
+                debug_traverse(*it, *iit, "-> Entering");
+
+                entered = true;
+                action::enter(current_piece, linestring, current_segment_id,
+                    iit->seg_id.segment_index, it->point, *iit,
+                    strategy, robust_policy,
+                    out);
+            }
+            else if (following::is_leaving(*it, *iit, entered, first, linestring, polygon, pt_in_poly_strategy))
+            {
+                debug_traverse(*it, *iit, "-> Leaving");
+
+                entered = false;
+                action::leave(current_piece, linestring, current_segment_id,
+                    iit->seg_id.segment_index, it->point, *iit,
+                    strategy, robust_policy,
+                    out);
+            }
+            first = false;
+        }
+
+        if (action::is_entered(entered))
+        {
+            detail::copy_segments::copy_segments_linestring
+                <
+                    false, RemoveSpikes
+                >::apply(linestring,
+                         current_segment_id,
+                         static_cast<signed_size_type>(boost::size(linestring) - 1),
+                         strategy, robust_policy,
+                         current_piece);
+        }
+
+        // Output the last one, if applicable
+        if (::boost::size(current_piece) > 1)
+        {
+            *out++ = current_piece;
+        }
+        return out;
+    }
+
+};
+
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_FOLLOW_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/follow_linear_linear.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/follow_linear_linear.hpp
new file mode 100644
index 00000000000..2a374bf0b09
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/follow_linear_linear.hpp
@@ -0,0 +1,557 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
+
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_FOLLOW_LINEAR_LINEAR_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_FOLLOW_LINEAR_LINEAR_HPP
+
+#include <cstddef>
+#include <algorithm>
+#include <iterator>
+
+#include <boost/range.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/copy_segments.hpp>
+#include <boost/geometry/algorithms/detail/overlay/follow.hpp>
+#include <boost/geometry/algorithms/detail/overlay/inconsistent_turns_exception.hpp>
+#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
+#include <boost/geometry/algorithms/detail/overlay/segment_identifier.hpp>
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+
+#include <boost/geometry/algorithms/detail/turns/debug_turn.hpp>
+
+#include <boost/geometry/algorithms/convert.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+namespace following { namespace linear
+{
+
+
+
+
+// follower for linear/linear geometries set operations
+
+template <typename Turn, typename Operation>
+static inline bool is_entering(Turn const& turn,
+                               Operation const& operation)
+{
+    if ( turn.method != method_touch && turn.method != method_touch_interior )
+    {
+        return false;
+    }
+    return operation.operation == operation_intersection;
+}
+
+
+
+template <typename Turn, typename Operation>
+static inline bool is_staying_inside(Turn const& turn,
+                                     Operation const& operation, 
+                                     bool entered)
+{
+    if ( !entered )
+    {
+        return false;
+    }
+
+    if ( turn.method != method_equal && turn.method != method_collinear )
+    {
+        return false;
+    }
+    return operation.operation == operation_continue;
+}
+
+
+
+template <typename Turn, typename Operation>
+static inline bool is_leaving(Turn const& turn,
+                              Operation const& operation,
+                              bool entered)
+{
+    if ( !entered )
+    {
+        return false;
+    }
+
+    if ( turn.method != method_touch
+         && turn.method != method_touch_interior
+         && turn.method != method_equal
+         && turn.method != method_collinear )
+    {
+        return false;
+    }
+
+    if ( operation.operation == operation_blocked )
+    {
+        return true;
+    }
+
+    if ( operation.operation != operation_union )
+    {
+        return false;
+    }
+
+    return operation.is_collinear;
+}
+
+
+
+template <typename Turn, typename Operation>
+static inline bool is_isolated_point(Turn const& turn,
+                                     Operation const& operation,
+                                     bool entered)
+{
+    if ( entered )
+    {
+        return false;
+    }
+
+    if ( turn.method == method_none )
+    {
+        BOOST_GEOMETRY_ASSERT( operation.operation == operation_continue );
+        return true;
+    }
+
+    if ( turn.method == method_crosses )
+    {
+        return true;
+    }
+
+    if ( turn.method != method_touch && turn.method != method_touch_interior )
+    {
+        return false;
+    }
+
+    if ( operation.operation == operation_blocked )
+    {
+        return true;
+    }
+
+    if ( operation.operation != operation_union )
+    {
+        return false;
+    }
+
+    return !operation.is_collinear;
+}
+
+
+
+
+
+
+
+
+
+template
+<
+    typename LinestringOut,
+    typename Linestring,
+    typename Linear,
+    overlay_type OverlayType,
+    bool FollowIsolatedPoints,
+    bool FollowContinueTurns
+>
+class follow_linestring_linear_linestring
+{
+protected:
+    // allow spikes (false indicates: do not remove spikes)
+    typedef following::action_selector<OverlayType, false> action;
+
+    template
+    <
+        typename TurnIterator,
+        typename TurnOperationIterator,
+        typename SegmentIdentifier,
+        typename OutputIterator,
+        typename SideStrategy
+    >
+    static inline OutputIterator
+    process_turn(TurnIterator it,
+                 TurnOperationIterator op_it,
+                 bool& entered,
+                 std::size_t& enter_count,
+                 Linestring const& linestring,
+                 LinestringOut& current_piece,
+                 SegmentIdentifier& current_segment_id,
+                 OutputIterator oit,
+                 SideStrategy const& strategy)
+    {
+        // We don't rescale linear/linear
+        detail::no_rescale_policy robust_policy;
+
+        if ( is_entering(*it, *op_it) )
+        {
+            detail::turns::debug_turn(*it, *op_it, "-> Entering");
+
+            entered = true;
+            if ( enter_count == 0 )
+            {
+                action::enter(current_piece, linestring,
+                              current_segment_id,
+                              op_it->seg_id.segment_index,
+                              it->point, *op_it, strategy, robust_policy, oit);
+            }
+            ++enter_count;
+        }
+        else if ( is_leaving(*it, *op_it, entered) )
+        {
+            detail::turns::debug_turn(*it, *op_it, "-> Leaving");
+
+            --enter_count;
+            if ( enter_count == 0 )
+            {
+                entered = false;
+                action::leave(current_piece, linestring,
+                              current_segment_id,
+                              op_it->seg_id.segment_index,
+                              it->point, *op_it, strategy, robust_policy, oit);
+            }
+        }
+        else if ( FollowIsolatedPoints
+                  && is_isolated_point(*it, *op_it, entered) )
+        {
+            detail::turns::debug_turn(*it, *op_it, "-> Isolated point");
+
+            action::isolated_point(current_piece, linestring,
+                                   current_segment_id,
+                                   op_it->seg_id.segment_index,
+                                   it->point, *op_it, oit);
+        }
+        else if ( FollowContinueTurns
+                  && is_staying_inside(*it, *op_it, entered) )
+        {
+            detail::turns::debug_turn(*it, *op_it, "-> Staying inside");
+
+            entered = true;
+        }
+        return oit;
+    }
+
+    template
+    <
+        typename SegmentIdentifier,
+        typename OutputIterator,
+        typename SideStrategy
+    >
+    static inline OutputIterator
+    process_end(bool entered,
+                Linestring const& linestring,
+                SegmentIdentifier const& current_segment_id,
+                LinestringOut& current_piece,
+                OutputIterator oit,
+                SideStrategy const& strategy)
+    {
+        if ( action::is_entered(entered) )
+        {
+            // We don't rescale linear/linear
+            detail::no_rescale_policy robust_policy;
+
+            detail::copy_segments::copy_segments_linestring
+                <
+                    false, false // do not reverse; do not remove spikes
+                >::apply(linestring,
+                         current_segment_id,
+                         static_cast<signed_size_type>(boost::size(linestring) - 1),
+                         strategy,
+                         robust_policy,
+                         current_piece);
+        }
+
+        // Output the last one, if applicable
+        if (::boost::size(current_piece) > 1)
+        {
+            *oit++ = current_piece;
+        }
+
+        return oit;
+    }
+
+public:
+    template <typename TurnIterator, typename OutputIterator, typename SideStrategy>
+    static inline OutputIterator
+    apply(Linestring const& linestring, Linear const&,
+          TurnIterator first, TurnIterator beyond,
+          OutputIterator oit,
+          SideStrategy const& strategy)
+    {
+        // Iterate through all intersection points (they are
+        // ordered along the each line)
+
+        LinestringOut current_piece;
+        geometry::segment_identifier current_segment_id(0, -1, -1, -1);
+
+        bool entered = false;
+        std::size_t enter_count = 0;
+
+        for (TurnIterator it = first; it != beyond; ++it)
+        {
+            oit = process_turn(it, boost::begin(it->operations),
+                               entered, enter_count, 
+                               linestring,
+                               current_piece, current_segment_id,
+                               oit,
+                               strategy);
+        }
+
+#if ! defined(BOOST_GEOMETRY_OVERLAY_NO_THROW)
+        if (enter_count != 0)
+        {
+            BOOST_THROW_EXCEPTION(inconsistent_turns_exception());
+        }
+#else
+        BOOST_GEOMETRY_ASSERT(enter_count == 0);
+#endif
+
+        return process_end(entered, linestring,
+                           current_segment_id, current_piece,
+                           oit,
+                           strategy);
+    }
+};
+
+
+
+
+template
+<
+    typename LinestringOut,
+    typename MultiLinestring,
+    typename Linear,
+    overlay_type OverlayType,
+    bool FollowIsolatedPoints,
+    bool FollowContinueTurns
+>
+class follow_multilinestring_linear_linestring
+    : follow_linestring_linear_linestring
+        <
+            LinestringOut,
+            typename boost::range_value<MultiLinestring>::type,
+            Linear,
+            OverlayType,
+            FollowIsolatedPoints,
+            FollowContinueTurns
+        >
+{
+protected:
+    typedef typename boost::range_value<MultiLinestring>::type Linestring;
+
+    typedef follow_linestring_linear_linestring
+        <
+            LinestringOut, Linestring, Linear,
+            OverlayType, FollowIsolatedPoints, FollowContinueTurns
+        > Base;
+
+    typedef following::action_selector<OverlayType> action;
+
+    typedef typename boost::range_iterator
+        <
+            MultiLinestring const
+        >::type linestring_iterator;
+
+
+    template <typename OutputIt, overlay_type OT>
+    struct copy_linestrings_in_range
+    {
+        static inline OutputIt
+        apply(linestring_iterator, linestring_iterator, OutputIt oit)
+        {
+            return oit;
+        }
+    };
+
+    template <typename OutputIt>
+    struct copy_linestrings_in_range<OutputIt, overlay_difference>
+    {
+        static inline OutputIt
+        apply(linestring_iterator first, linestring_iterator beyond,
+              OutputIt oit)
+        {
+            for (linestring_iterator ls_it = first; ls_it != beyond; ++ls_it)
+            {
+                LinestringOut line_out;
+                geometry::convert(*ls_it, line_out);
+                *oit++ = line_out;
+            }
+            return oit;
+        }
+    };
+
+    template <typename TurnIterator>
+    static inline signed_size_type get_multi_index(TurnIterator it)
+    {
+        return boost::begin(it->operations)->seg_id.multi_index;
+    }
+
+    class has_other_multi_id
+    {
+    private:
+        signed_size_type m_multi_id;
+
+    public:
+        has_other_multi_id(signed_size_type multi_id)
+            : m_multi_id(multi_id) {}
+
+        template <typename Turn>
+        bool operator()(Turn const& turn) const
+        {
+            return boost::begin(turn.operations)->seg_id.multi_index
+                != m_multi_id;
+        }
+    };
+
+public:
+    template <typename TurnIterator, typename OutputIterator, typename SideStrategy>
+    static inline OutputIterator
+    apply(MultiLinestring const& multilinestring, Linear const& linear,
+          TurnIterator first, TurnIterator beyond,
+          OutputIterator oit,
+          SideStrategy const& strategy)
+    {
+        BOOST_GEOMETRY_ASSERT( first != beyond );
+
+        typedef copy_linestrings_in_range
+            <
+                OutputIterator, OverlayType
+            > copy_linestrings;
+
+        linestring_iterator ls_first = boost::begin(multilinestring);
+        linestring_iterator ls_beyond = boost::end(multilinestring);
+
+        // Iterate through all intersection points (they are
+        // ordered along the each linestring)
+
+        signed_size_type current_multi_id = get_multi_index(first);
+
+        oit = copy_linestrings::apply(ls_first,
+                                      ls_first + current_multi_id,
+                                      oit);
+
+        TurnIterator per_ls_next = first;
+        do {
+            TurnIterator per_ls_current = per_ls_next;
+
+            // find turn with different multi-index
+            per_ls_next = std::find_if(per_ls_current, beyond,
+                                       has_other_multi_id(current_multi_id));
+
+            oit = Base::apply(*(ls_first + current_multi_id),
+                              linear, per_ls_current, per_ls_next, oit, strategy);
+
+            signed_size_type next_multi_id = -1;
+            linestring_iterator ls_next = ls_beyond;
+            if ( per_ls_next != beyond )
+            {
+                next_multi_id = get_multi_index(per_ls_next);
+                ls_next = ls_first + next_multi_id;
+            }
+            oit = copy_linestrings::apply(ls_first + current_multi_id + 1,
+                                          ls_next,
+                                          oit);
+
+            current_multi_id = next_multi_id;
+        }
+        while ( per_ls_next != beyond );
+
+        return oit;
+    }
+};
+
+
+
+
+
+
+template
+<
+    typename LinestringOut,
+    typename Geometry1,
+    typename Geometry2,
+    overlay_type OverlayType,
+    bool FollowIsolatedPoints,
+    bool FollowContinueTurns,
+    typename TagOut = typename tag<LinestringOut>::type,
+    typename TagIn1 = typename tag<Geometry1>::type
+>
+struct follow
+    : not_implemented<LinestringOut, Geometry1>
+{};
+
+
+
+template
+<
+    typename LinestringOut,
+    typename Linestring,
+    typename Linear,
+    overlay_type OverlayType,
+    bool FollowIsolatedPoints,
+    bool FollowContinueTurns
+>
+struct follow
+    <
+        LinestringOut, Linestring, Linear,
+        OverlayType, FollowIsolatedPoints, FollowContinueTurns,
+        linestring_tag, linestring_tag
+    > : follow_linestring_linear_linestring
+        <
+            LinestringOut, Linestring, Linear,
+            OverlayType, FollowIsolatedPoints, FollowContinueTurns
+        >
+{};
+
+
+template
+<
+    typename LinestringOut,
+    typename MultiLinestring,
+    typename Linear,
+    overlay_type OverlayType,
+    bool FollowIsolatedPoints,
+    bool FollowContinueTurns
+>
+struct follow
+    <
+        LinestringOut, MultiLinestring, Linear,
+        OverlayType, FollowIsolatedPoints, FollowContinueTurns,
+        linestring_tag, multi_linestring_tag
+    > : follow_multilinestring_linear_linestring
+        <
+            LinestringOut, MultiLinestring, Linear,
+            OverlayType, FollowIsolatedPoints, FollowContinueTurns
+        >
+{};
+
+
+
+}} // namespace following::linear
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_FOLLOW_LINEAR_LINEAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_intersection_points.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_intersection_points.hpp
new file mode 100644
index 00000000000..94667d0ed00
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_intersection_points.hpp
@@ -0,0 +1,165 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_INTERSECTION_POINTS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_INTERSECTION_POINTS_HPP
+
+
+#include <cstddef>
+
+#include <boost/mpl/if.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/convert.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_turns.hpp>
+
+#include <boost/geometry/geometries/segment.hpp>
+
+#include <boost/geometry/policies/robustness/robust_point_type.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace get_intersection_points
+{
+
+
+template
+<
+    typename Point1,
+    typename Point2,
+    typename TurnInfo
+>
+struct get_turn_without_info
+{
+    template <typename Strategy, typename RobustPolicy, typename OutputIterator>
+    static inline OutputIterator apply(
+                Point1 const& pi, Point1 const& pj, Point1 const& /*pk*/,
+                Point2 const& qi, Point2 const& qj, Point2 const& /*qk*/,
+                bool /*is_p_first*/, bool /*is_p_last*/,
+                bool /*is_q_first*/, bool /*is_q_last*/,
+                TurnInfo const& ,
+                Strategy const& strategy,
+                RobustPolicy const& robust_policy,
+                OutputIterator out)
+    {
+        typedef typename TurnInfo::point_type turn_point_type;
+
+        typedef policies::relate::segments_intersection_points
+            <
+                segment_intersection_points
+                    <
+                        turn_point_type,
+                        typename geometry::segment_ratio_type
+                            <
+                                turn_point_type, RobustPolicy
+                            >::type
+                    >
+            > policy_type;
+
+        typedef model::referring_segment<Point1 const> segment_type1;
+        typedef model::referring_segment<Point2 const> segment_type2;
+        segment_type1 p1(pi, pj);
+        segment_type2 q1(qi, qj);
+
+        typedef typename geometry::robust_point_type
+            <
+                Point1, RobustPolicy
+            >::type robust_point_type;
+
+        robust_point_type pi_rob, pj_rob, qi_rob, qj_rob;
+        geometry::recalculate(pi_rob, pi, robust_policy);
+        geometry::recalculate(pj_rob, pj, robust_policy);
+        geometry::recalculate(qi_rob, qi, robust_policy);
+        geometry::recalculate(qj_rob, qj, robust_policy);
+        typename policy_type::return_type result
+            = strategy.apply(p1, q1, policy_type(), robust_policy,
+                             pi_rob, pj_rob, qi_rob, qj_rob);
+
+        for (std::size_t i = 0; i < result.count; i++)
+        {
+            TurnInfo tp;
+            geometry::convert(result.intersections[i], tp.point);
+            *out++ = tp;
+        }
+
+        return out;
+    }
+};
+
+}} // namespace detail::get_intersection_points
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename RobustPolicy,
+    typename Turns,
+    typename Strategy
+>
+inline void get_intersection_points(Geometry1 const& geometry1,
+            Geometry2 const& geometry2,
+            RobustPolicy const& robust_policy,
+            Turns& turns,
+            Strategy const& strategy)
+{
+    concepts::check_concepts_and_equal_dimensions<Geometry1 const, Geometry2 const>();
+
+    typedef detail::get_intersection_points::get_turn_without_info
+                        <
+                            typename point_type<Geometry1>::type,
+                            typename point_type<Geometry2>::type,
+                            typename boost::range_value<Turns>::type
+                        > TurnPolicy;
+
+    detail::get_turns::no_interrupt_policy interrupt_policy;
+
+    boost::mpl::if_c
+        <
+            reverse_dispatch<Geometry1, Geometry2>::type::value,
+            dispatch::get_turns_reversed
+            <
+                typename tag<Geometry1>::type,
+                typename tag<Geometry2>::type,
+                Geometry1, Geometry2,
+                false, false,
+                TurnPolicy
+            >,
+            dispatch::get_turns
+            <
+                typename tag<Geometry1>::type,
+                typename tag<Geometry2>::type,
+                Geometry1, Geometry2,
+                false, false,
+                TurnPolicy
+            >
+        >::type::apply(
+            0, geometry1,
+            1, geometry2,
+            strategy,
+            robust_policy,
+            turns, interrupt_policy);
+}
+
+
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_INTERSECTION_POINTS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_relative_order.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_relative_order.hpp
new file mode 100644
index 00000000000..2eec6af6650
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_relative_order.hpp
@@ -0,0 +1,103 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_RELATIVE_ORDER_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_RELATIVE_ORDER_HPP
+
+
+#include <boost/geometry/strategies/intersection_strategies.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+/*!
+    \brief Get relative order
+    \details Can indicate which of two segments R and S,
+        both crossing a common segment P, comes first.
+        If the two segments cross P very close (e.g. in a spike),
+        the distance between the intersection points can be zero,
+        but we still need to know which comes first.
+        Therefore, it is useful that using sides we are able to discover this.
+ */
+struct get_relative_order
+{
+    template <typename Point, typename SideStrategy>
+    static inline int value_via_product(Point const& ti, Point const& tj,
+                                        Point const& ui, Point const& uj, int factor,
+                                        SideStrategy const& strategy)
+    {
+        int const side_ti_u = strategy.apply(ti, tj, ui);
+        int const side_tj_u = strategy.apply(ti, tj, uj);
+
+#ifdef BOOST_GEOMETRY_DEBUG_RELATIVE_ORDER
+        std::cout << (factor == 1  ? " r//s " :  " s//r ")
+            << side_ti_u << " / " << side_tj_u;
+#endif
+
+        return side_ti_u * side_tj_u >= 0
+            ? factor * (side_ti_u != 0 ? side_ti_u : side_tj_u)
+            : 0;
+    }
+
+
+    template <typename Point1, typename SideStrategy>
+    static inline int apply(
+                Point1 const& pi, Point1 const& pj,
+                Point1 const& ri, Point1 const& rj,
+                Point1 const& si, Point1 const& sj,
+                SideStrategy const& strategy)
+    {
+        int const side_ri_p = strategy.apply(pi, pj, ri);
+        int const side_si_p = strategy.apply(pi, pj, si);
+
+#ifdef BOOST_GEOMETRY_DEBUG_RELATIVE_ORDER
+        int const side_rj_p = strategy::apply(pi, pj, rj);
+        int const side_sj_p = strategy::apply(pi, pj, sj);
+        std::cout << "r//p: " << side_ri_p << " / " << side_rj_p;
+        std::cout << " s//p: " << side_si_p << " / " << side_sj_p;
+#endif
+
+        int value = value_via_product(si, sj, ri, rj, 1, strategy);
+        if (value == 0)
+        {
+            value = value_via_product(ri, rj, si, sj, -1, strategy);
+        }
+
+        int const order = side_ri_p * side_ri_p * side_si_p * value;
+
+#ifdef BOOST_GEOMETRY_DEBUG_RELATIVE_ORDER
+        std::cout
+            << " o: " << order
+            << std::endl << std::endl;
+#endif
+
+        return order;
+    }
+};
+
+
+}} // namespace detail::overlay
+#endif //DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_RELATIVE_ORDER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_ring.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_ring.hpp
new file mode 100644
index 00000000000..460c30def3a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_ring.hpp
@@ -0,0 +1,123 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_RING_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_RING_HPP
+
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/algorithms/detail/ring_identifier.hpp>
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/util/range.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+template<typename Tag>
+struct get_ring
+{};
+
+// A range of rings (multi-ring but that does not exist)
+// gets the "void" tag and is dispatched here.
+template<>
+struct get_ring<void>
+{
+    template<typename Range>
+    static inline typename boost::range_value<Range>::type const&
+                apply(ring_identifier const& id, Range const& container)
+    {
+        return range::at(container, id.multi_index);
+    }
+};
+
+
+
+
+template<>
+struct get_ring<ring_tag>
+{
+    template<typename Ring>
+    static inline Ring const& apply(ring_identifier const& , Ring const& ring)
+    {
+        return ring;
+    }
+};
+
+
+template<>
+struct get_ring<box_tag>
+{
+    template<typename Box>
+    static inline Box const& apply(ring_identifier const& ,
+                    Box const& box)
+    {
+        return box;
+    }
+};
+
+
+template<>
+struct get_ring<polygon_tag>
+{
+    template<typename Polygon>
+    static inline typename ring_return_type<Polygon const>::type const apply(
+                ring_identifier const& id,
+                Polygon const& polygon)
+    {
+        BOOST_GEOMETRY_ASSERT
+            (
+                id.ring_index >= -1
+                && id.ring_index < int(boost::size(interior_rings(polygon)))
+            );
+        return id.ring_index < 0
+            ? exterior_ring(polygon)
+            : range::at(interior_rings(polygon), id.ring_index);
+    }
+};
+
+
+template<>
+struct get_ring<multi_polygon_tag>
+{
+    template<typename MultiPolygon>
+    static inline typename ring_type<MultiPolygon>::type const& apply(
+                ring_identifier const& id,
+                MultiPolygon const& multi_polygon)
+    {
+        BOOST_GEOMETRY_ASSERT
+            (
+                id.multi_index >= 0
+                && id.multi_index < int(boost::size(multi_polygon))
+            );
+        return get_ring<polygon_tag>::apply(id,
+                    range::at(multi_polygon, id.multi_index));
+    }
+};
+
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_RING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turn_info.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turn_info.hpp
new file mode 100644
index 00000000000..895952c8fc8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turn_info.hpp
@@ -0,0 +1,1143 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2015, 2017.
+// Modifications copyright (c) 2015-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TURN_INFO_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TURN_INFO_HPP
+
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/assert.hpp>
+
+#include <boost/geometry/algorithms/convert.hpp>
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+#include <boost/geometry/algorithms/detail/recalculate.hpp>
+
+#include <boost/geometry/geometries/segment.hpp>
+
+#include <boost/geometry/policies/robustness/robust_point_type.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_turn_info_helpers.hpp>
+
+// Silence warning C4127: conditional expression is constant
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4127)
+#endif
+
+
+namespace boost { namespace geometry
+{
+
+#if ! defined(BOOST_GEOMETRY_OVERLAY_NO_THROW)
+class turn_info_exception : public geometry::exception
+{
+    std::string message;
+public:
+
+    // NOTE: "char" will be replaced by enum in future version
+    inline turn_info_exception(char const method)
+    {
+        message = "Boost.Geometry Turn exception: ";
+        message += method;
+    }
+
+    virtual ~turn_info_exception() throw()
+    {}
+
+    virtual char const* what() const throw()
+    {
+        return message.c_str();
+    }
+};
+#endif
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+struct base_turn_handler
+{
+    // Returns true if both sides are opposite
+    static inline bool opposite(int side1, int side2)
+    {
+        // We cannot state side1 == -side2, because 0 == -0
+        // So either side1*side2==-1 or side1==-side2 && side1 != 0
+        return side1 * side2 == -1;
+    }
+
+    // Same side of a segment (not being 0)
+    static inline bool same(int side1, int side2)
+    {
+        return side1 * side2 == 1;
+    }
+
+    // Both continue
+    template <typename TurnInfo>
+    static inline void both(TurnInfo& ti, operation_type const op)
+    {
+        ti.operations[0].operation = op;
+        ti.operations[1].operation = op;
+    }
+
+    // If condition, first union/second intersection, else vice versa
+    template <typename TurnInfo>
+    static inline void ui_else_iu(bool condition, TurnInfo& ti)
+    {
+        ti.operations[0].operation = condition
+                    ? operation_union : operation_intersection;
+        ti.operations[1].operation = condition
+                    ? operation_intersection : operation_union;
+    }
+
+    // If condition, both union, else both intersection
+    template <typename TurnInfo>
+    static inline void uu_else_ii(bool condition, TurnInfo& ti)
+    {
+        both(ti, condition ? operation_union : operation_intersection);
+    }
+
+    template <typename TurnInfo, typename IntersectionInfo>
+    static inline void assign_point(TurnInfo& ti,
+                method_type method,
+                IntersectionInfo const& info, unsigned int index)
+    {
+        ti.method = method;
+
+        BOOST_GEOMETRY_ASSERT(index < info.count);
+
+        geometry::convert(info.intersections[index], ti.point);
+        ti.operations[0].fraction = info.fractions[index].robust_ra;
+        ti.operations[1].fraction = info.fractions[index].robust_rb;
+    }
+
+    template <typename IntersectionInfo>
+    static inline unsigned int non_opposite_to_index(IntersectionInfo const& info)
+    {
+        return info.fractions[0].robust_rb < info.fractions[1].robust_rb
+            ? 1 : 0;
+    }
+
+};
+
+
+template
+<
+    typename TurnInfo
+>
+struct touch_interior : public base_turn_handler
+{
+    // Index: 0, P is the interior, Q is touching and vice versa
+    template
+    <
+        unsigned int Index,
+        typename Point1,
+        typename Point2,
+        typename IntersectionInfo,
+        typename DirInfo,
+        typename SidePolicy
+    >
+    static inline void apply(
+                Point1 const& , Point1 const& , Point1 const& ,
+                Point2 const& , Point2 const& , Point2 const& ,
+                TurnInfo& ti,
+                IntersectionInfo const& intersection_info,
+                DirInfo const& dir_info,
+                SidePolicy const& side)
+    {
+        assign_point(ti, method_touch_interior, intersection_info, 0);
+
+        // Both segments of q touch segment p somewhere in its interior
+        // 1) We know: if q comes from LEFT or RIGHT
+        // (i.e. dir_info.sides.get<Index,0>() == 1 or -1)
+        // 2) Important is: if q_k goes to LEFT, RIGHT, COLLINEAR
+        //    and, if LEFT/COLL, if it is lying LEFT or RIGHT w.r.t. q_i
+
+        BOOST_STATIC_ASSERT(Index <= 1);
+        static unsigned int const index_p = Index;
+        static unsigned int const index_q = 1 - Index;
+
+        int const side_qi_p = dir_info.sides.template get<index_q, 0>();
+        int const side_qk_p = side.qk_wrt_p1();
+
+        if (side_qi_p == -side_qk_p)
+        {
+            // Q crosses P from left->right or from right->left (test "ML1")
+            // Union: folow P (left->right) or Q (right->left)
+            // Intersection: other turn
+            unsigned int index = side_qk_p == -1 ? index_p : index_q;
+            ti.operations[index].operation = operation_union;
+            ti.operations[1 - index].operation = operation_intersection;
+            return;
+        }
+
+        int const side_qk_q = side.qk_wrt_q1();
+
+        if (side_qi_p == -1 && side_qk_p == -1 && side_qk_q == 1)
+        {
+            // Q turns left on the right side of P (test "MR3")
+            // Both directions for "intersection"
+            both(ti, operation_intersection);
+            ti.touch_only = true;
+        }
+        else if (side_qi_p == 1 && side_qk_p == 1 && side_qk_q == -1)
+        {
+            // Q turns right on the left side of P (test "ML3")
+            // Union: take both operation
+            // Intersection: skip
+            both(ti, operation_union);
+            ti.touch_only = true;
+        }
+        else if (side_qi_p == side_qk_p && side_qi_p == side_qk_q)
+        {
+            // Q turns left on the left side of P (test "ML2")
+            // or Q turns right on the right side of P (test "MR2")
+            // Union: take left turn (Q if Q turns left, P if Q turns right)
+            // Intersection: other turn
+            unsigned int index = side_qk_q == 1 ? index_q : index_p;
+            ti.operations[index].operation = operation_union;
+            ti.operations[1 - index].operation = operation_intersection;
+            ti.touch_only = true;
+        }
+        else if (side_qk_p == 0)
+        {
+            // Q intersects on interior of P and continues collinearly
+            if (side_qk_q == side_qi_p)
+            {
+                // Collinearly in the same direction
+                // (Q comes from left of P and turns left,
+                //  OR Q comes from right of P and turns right)
+                // Omit intersection point.
+                // Union: just continue
+                // Intersection: just continue
+                both(ti, operation_continue);
+            }
+            else
+            {
+                // Opposite direction, which is never travelled.
+                // If Q turns left, P continues for intersection
+                // If Q turns right, P continues for union
+                ti.operations[index_p].operation = side_qk_q == 1
+                    ? operation_intersection
+                    : operation_union;
+                ti.operations[index_q].operation = operation_blocked;
+            }
+        }
+        else
+        {
+            // Should not occur!
+            ti.method = method_error;
+        }
+    }
+};
+
+
+template
+<
+    typename TurnInfo
+>
+struct touch : public base_turn_handler
+{
+    static inline bool between(int side1, int side2, int turn)
+    {
+        return side1 == side2 && ! opposite(side1, turn);
+    }
+
+    /*static inline void block_second(bool block, TurnInfo& ti)
+    {
+        if (block)
+        {
+            ti.operations[1].operation = operation_blocked;
+        }
+    }*/
+
+
+    template
+    <
+        typename Point1,
+        typename Point2,
+        typename IntersectionInfo,
+        typename DirInfo,
+        typename SidePolicy
+    >
+    static inline void apply(
+                Point1 const& , Point1 const& , Point1 const& ,
+                Point2 const& , Point2 const& , Point2 const& ,
+                TurnInfo& ti,
+                IntersectionInfo const& intersection_info,
+                DirInfo const& dir_info,
+                SidePolicy const& side)
+    {
+        assign_point(ti, method_touch, intersection_info, 0);
+
+        int const side_qi_p1 = dir_info.sides.template get<1, 0>();
+        int const side_qk_p1 = side.qk_wrt_p1();
+
+
+        // If Qi and Qk are both at same side of Pi-Pj,
+        // or collinear (so: not opposite sides)
+        if (! opposite(side_qi_p1, side_qk_p1))
+        {
+            int const side_pk_q2 = side.pk_wrt_q2();
+            int const side_pk_p  = side.pk_wrt_p1();
+            int const side_qk_q  = side.qk_wrt_q1();
+
+            bool const q_turns_left = side_qk_q == 1;
+            bool const block_q = side_qk_p1 == 0
+                        && ! same(side_qi_p1, side_qk_q)
+                        ;
+
+            // If Pk at same side as Qi/Qk
+            // (the "or" is for collinear case)
+            // or Q is fully collinear && P turns not to left
+            if (side_pk_p == side_qi_p1
+                || side_pk_p == side_qk_p1
+                || (side_qi_p1 == 0 && side_qk_p1 == 0 && side_pk_p != -1)
+                )
+            {
+                // Collinear -> lines join, continue
+                // (#BRL2)
+                if (side_pk_q2 == 0 && ! block_q)
+                {
+                    both(ti, operation_continue);
+                    return;
+                }
+
+                int const side_pk_q1 = side.pk_wrt_q1();
+
+
+                // Collinear opposite case -> block P
+                // (#BRL4, #BLR8)
+                if (side_pk_q1 == 0)
+                {
+                    ti.operations[0].operation = operation_blocked;
+                    // Q turns right -> union (both independent),
+                    // Q turns left -> intersection
+                    ti.operations[1].operation = block_q ? operation_blocked
+                        : q_turns_left ? operation_intersection
+                        : operation_union;
+                    return;
+                }
+
+                // Pk between Qi and Qk
+                // (#BRL3, #BRL7)
+                if (between(side_pk_q1, side_pk_q2, side_qk_q))
+                {
+                    ui_else_iu(q_turns_left, ti);
+                    if (block_q)
+                    {
+                        ti.operations[1].operation = operation_blocked;
+                    }
+                    //block_second(block_q, ti);
+                    return;
+                }
+
+                // Pk between Qk and P, so left of Qk (if Q turns right) and vv
+                // (#BRL1)
+                if (side_pk_q2 == -side_qk_q)
+                {
+                    ui_else_iu(! q_turns_left, ti);
+                    ti.touch_only = true;
+                    return;
+                }
+
+                //
+                // (#BRL5, #BRL9)
+                if (side_pk_q1 == -side_qk_q)
+                {
+                    uu_else_ii(! q_turns_left, ti);
+                    if (block_q)
+                    {
+                        ti.operations[1].operation = operation_blocked;
+                    }
+                    else
+                    {
+                        ti.touch_only = true;
+                    }
+                    //block_second(block_q, ti);
+                    return;
+                }
+            }
+            else
+            {
+                // Pk at other side than Qi/Pk
+                ti.operations[0].operation = q_turns_left
+                            ? operation_intersection
+                            : operation_union;
+                ti.operations[1].operation = block_q
+                            ? operation_blocked
+                            : side_qi_p1 == 1 || side_qk_p1 == 1
+                            ? operation_union
+                            : operation_intersection;
+                if (! block_q)
+                {
+                    ti.touch_only = true;
+                }
+
+                return;
+            }
+        }
+        else
+        {
+            // From left to right or from right to left
+            int const side_pk_p = side.pk_wrt_p1();
+            bool const right_to_left = side_qk_p1 == 1;
+
+            // If p turns into direction of qi (1,2)
+            if (side_pk_p == side_qi_p1)
+            {
+                int const side_pk_q1 = side.pk_wrt_q1();
+
+                // Collinear opposite case -> block P
+                if (side_pk_q1 == 0)
+                {
+                    ti.operations[0].operation = operation_blocked;
+                    ti.operations[1].operation = right_to_left
+                                ? operation_union : operation_intersection;
+                    return;
+                }
+
+                if (side_pk_q1 == side_qk_p1)
+                {
+                    uu_else_ii(right_to_left, ti);
+                    ti.touch_only = true;
+                    return;
+                }
+            }
+
+            // If p turns into direction of qk (4,5)
+            if (side_pk_p == side_qk_p1)
+            {
+                int const side_pk_q2 = side.pk_wrt_q2();
+
+                // Collinear case -> lines join, continue
+                if (side_pk_q2 == 0)
+                {
+                    both(ti, operation_continue);
+                    return;
+                }
+                if (side_pk_q2 == side_qk_p1)
+                {
+                    ui_else_iu(right_to_left, ti);
+                    ti.touch_only = true;
+                    return;
+                }
+            }
+            // otherwise (3)
+            ui_else_iu(! right_to_left, ti);
+            return;
+        }
+
+#ifdef BOOST_GEOMETRY_DEBUG_GET_TURNS
+        // Normally a robustness issue.
+        // TODO: more research if still occuring
+        std::cout << "Not yet handled" << std::endl
+            << "pi " << get<0>(pi) << " , " << get<1>(pi)
+            << " pj " << get<0>(pj) << " , " << get<1>(pj)
+            << " pk " << get<0>(pk) << " , " << get<1>(pk)
+            << std::endl
+            << "qi " << get<0>(qi) << " , " << get<1>(qi)
+            << " qj " << get<0>(qj) << " , " << get<1>(qj)
+            << " qk " << get<0>(qk) << " , " << get<1>(qk)
+            << std::endl;
+#endif
+
+    }
+};
+
+
+template
+<
+    typename TurnInfo
+>
+struct equal : public base_turn_handler
+{
+    template
+    <
+        typename Point1,
+        typename Point2,
+        typename IntersectionInfo,
+        typename DirInfo,
+        typename SidePolicy
+    >
+    static inline void apply(
+                Point1 const& , Point1 const& , Point1 const& ,
+                Point2 const& , Point2 const& , Point2 const& ,
+                TurnInfo& ti,
+                IntersectionInfo const& info,
+                DirInfo const&  ,
+                SidePolicy const& side)
+    {
+        // Copy the intersection point in TO direction
+        assign_point(ti, method_equal, info, non_opposite_to_index(info));
+
+        int const side_pk_q2 = side.pk_wrt_q2();
+        int const side_pk_p = side.pk_wrt_p1();
+        int const side_qk_p = side.qk_wrt_p1();
+
+
+        // If pk is collinear with qj-qk, they continue collinearly.
+        // This can be on either side of p1 (== q1), or collinear
+        // The second condition checks if they do not continue
+        // oppositely
+        if (side_pk_q2 == 0 && side_pk_p == side_qk_p)
+        {
+            both(ti, operation_continue);
+
+            return;
+        }
+
+
+        // If they turn to same side (not opposite sides)
+        if (! opposite(side_pk_p, side_qk_p))
+        {
+            // If pk is left of q2 or collinear: p: union, q: intersection
+            ui_else_iu(side_pk_q2 != -1, ti);
+        }
+        else
+        {
+            // They turn opposite sides. If p turns left (or collinear),
+            // p: union, q: intersection
+            ui_else_iu(side_pk_p != -1, ti);
+        }
+    }
+};
+
+
+template
+<
+    typename TurnInfo,
+    typename AssignPolicy
+>
+struct equal_opposite : public base_turn_handler
+{
+    template
+    <
+        typename Point1,
+        typename Point2,
+        typename OutputIterator,
+        typename IntersectionInfo
+    >
+    static inline void apply(Point1 const& pi, Point2 const& qi,
+                /* by value: */ TurnInfo tp,
+                OutputIterator& out,
+                IntersectionInfo const& intersection_info)
+    {
+        // For equal-opposite segments, normally don't do anything.
+        if (AssignPolicy::include_opposite)
+        {
+            tp.method = method_equal;
+            for (unsigned int i = 0; i < 2; i++)
+            {
+                tp.operations[i].operation = operation_opposite;
+            }
+            for (unsigned int i = 0; i < intersection_info.i_info().count; i++)
+            {
+                assign_point(tp, method_none, intersection_info.i_info(), i);
+                AssignPolicy::apply(tp, pi, qi, intersection_info);
+                *out++ = tp;
+            }
+        }
+    }
+};
+
+template
+<
+    typename TurnInfo
+>
+struct collinear : public base_turn_handler
+{
+    /*
+        arrival P   pk//p1  qk//q1   product*  case    result
+         1           1                1        CLL1    ui
+        -1                   1       -1        CLL2    iu
+         1           1                1        CLR1    ui
+        -1                  -1        1        CLR2    ui
+
+         1          -1               -1        CRL1    iu
+        -1                   1       -1        CRL2    iu
+         1          -1               -1        CRR1    iu
+        -1                  -1        1        CRR2    ui
+
+         1           0                0        CC1     cc
+        -1                   0        0        CC2     cc
+
+         *product = arrival * (pk//p1 or qk//q1)
+
+         Stated otherwise:
+         - if P arrives: look at turn P
+         - if Q arrives: look at turn Q
+         - if P arrives and P turns left: union for P
+         - if P arrives and P turns right: intersection for P
+         - if Q arrives and Q turns left: union for Q (=intersection for P)
+         - if Q arrives and Q turns right: intersection for Q (=union for P)
+
+         ROBUSTNESS: p and q are collinear, so you would expect
+         that side qk//p1 == pk//q1. But that is not always the case
+         in near-epsilon ranges. Then decision logic is different.
+         If p arrives, q is further, so the angle qk//p1 is (normally)
+         more precise than pk//p1
+
+    */
+    template
+    <
+        typename Point1,
+        typename Point2,
+        typename IntersectionInfo,
+        typename DirInfo,
+        typename SidePolicy
+    >
+    static inline void apply(
+                Point1 const& , Point1 const& pj, Point1 const& pk,
+                Point2 const& , Point2 const& qj, Point2 const& qk,
+                TurnInfo& ti,
+                IntersectionInfo const& info,
+                DirInfo const& dir_info,
+                SidePolicy const& side)
+    {
+        // Copy the intersection point in TO direction
+        assign_point(ti, method_collinear, info, non_opposite_to_index(info));
+
+        int const arrival = dir_info.arrival[0];
+        // Should not be 0, this is checked before
+        BOOST_GEOMETRY_ASSERT(arrival != 0);
+
+        int const side_p = side.pk_wrt_p1();
+        int const side_q = side.qk_wrt_q1();
+
+        // If p arrives, use p, else use q
+        int const side_p_or_q = arrival == 1
+            ? side_p
+            : side_q
+            ;
+
+        // See comments above,
+        // resulting in a strange sort of mathematic rule here:
+        // The arrival-info multiplied by the relevant side
+        // delivers a consistent result.
+
+        int const product = arrival * side_p_or_q;
+
+        if(product == 0)
+        {
+            both(ti, operation_continue);
+        }
+        else
+        {
+            ui_else_iu(product == 1, ti);
+        }
+
+        // Calculate remaining distance. If it continues collinearly it is
+        // measured until the end of the next segment
+        ti.operations[0].remaining_distance
+                = side_p == 0
+                ? distance_measure(ti.point, pk)
+                : distance_measure(ti.point, pj);
+        ti.operations[1].remaining_distance
+                = side_q == 0
+                ? distance_measure(ti.point, qk)
+                : distance_measure(ti.point, qj);
+    }
+
+    template <typename Point1, typename Point2>
+    static inline typename geometry::coordinate_type<Point1>::type
+            distance_measure(Point1 const& a, Point2 const& b)
+    {
+        // TODO: use comparable distance for point-point instead - but that
+        // causes currently cycling include problems
+        typedef typename geometry::coordinate_type<Point1>::type ctype;
+        ctype const dx = get<0>(a) - get<0>(b);
+        ctype const dy = get<1>(a) - get<1>(b);
+        return dx * dx + dy * dy;
+    }
+};
+
+template
+<
+    typename TurnInfo,
+    typename AssignPolicy
+>
+struct collinear_opposite : public base_turn_handler
+{
+private :
+    /*
+        arrival P  arrival Q  pk//p1   qk//q1  case  result2  result
+        --------------------------------------------------------------
+         1          1          1       -1      CLO1    ix      xu
+         1          1          1        0      CLO2    ix      (xx)
+         1          1          1        1      CLO3    ix      xi
+
+         1          1          0       -1      CCO1    (xx)    xu
+         1          1          0        0      CCO2    (xx)    (xx)
+         1          1          0        1      CCO3    (xx)    xi
+
+         1          1         -1       -1      CRO1    ux      xu
+         1          1         -1        0      CRO2    ux      (xx)
+         1          1         -1        1      CRO3    ux      xi
+
+        -1          1                  -1      CXO1    xu
+        -1          1                   0      CXO2    (xx)
+        -1          1                   1      CXO3    xi
+
+         1         -1          1               CXO1    ix
+         1         -1          0               CXO2    (xx)
+         1         -1         -1               CXO3    ux
+    */
+
+    template
+    <
+        unsigned int Index,
+        typename Point1,
+        typename Point2,
+        typename IntersectionInfo
+    >
+    static inline bool set_tp(Point1 const& , Point1 const& , Point1 const& , int side_rk_r,
+                bool const handle_robustness,
+                Point2 const& , Point2 const& , int side_rk_s,
+                TurnInfo& tp, IntersectionInfo const& intersection_info)
+    {
+        BOOST_STATIC_ASSERT(Index <= 1);
+
+        boost::ignore_unused(handle_robustness, side_rk_s);
+
+        operation_type blocked = operation_blocked;
+        switch(side_rk_r)
+        {
+
+            case 1 :
+                // Turning left on opposite collinear: intersection
+                tp.operations[Index].operation = operation_intersection;
+                break;
+            case -1 :
+                // Turning right on opposite collinear: union
+                tp.operations[Index].operation = operation_union;
+                break;
+            case 0 :
+                // No turn on opposite collinear: block, do not traverse
+                // But this "xx" is usually ignored, it is useless to include
+                // two operations blocked, so the whole point does not need
+                // to be generated.
+                // So return false to indicate nothing is to be done.
+                if (AssignPolicy::include_opposite)
+                {
+                    tp.operations[Index].operation = operation_opposite;
+                    blocked = operation_opposite;
+                }
+                else
+                {
+                    return false;
+                }
+                break;
+        }
+
+        // The other direction is always blocked when collinear opposite
+        tp.operations[1 - Index].operation = blocked;
+
+        // If P arrives within Q, set info on P (which is done above, index=0),
+        // this turn-info belongs to the second intersection point, index=1
+        // (see e.g. figure CLO1)
+        assign_point(tp, method_collinear, intersection_info, 1 - Index);
+        return true;
+    }
+
+public:
+    static inline void empty_transformer(TurnInfo &) {}
+
+    template
+    <
+        typename Point1,
+        typename Point2,
+        typename OutputIterator,
+        typename IntersectionInfo,
+        typename SidePolicy
+    >
+    static inline void apply(
+                Point1 const& pi, Point1 const& pj, Point1 const& pk,
+                Point2 const& qi, Point2 const& qj, Point2 const& qk,
+
+                // Opposite collinear can deliver 2 intersection points,
+                TurnInfo const& tp_model,
+                OutputIterator& out,
+
+                IntersectionInfo const& intersection_info,
+                SidePolicy const& side)
+    {
+        apply(pi, pj, pk, qi, qj, qk, tp_model, out, intersection_info, side, empty_transformer);
+    }
+
+public:
+    template
+    <
+        typename Point1,
+        typename Point2,
+        typename OutputIterator,
+        typename IntersectionInfo,
+        typename SidePolicy,
+        typename TurnTransformer
+    >
+    static inline void apply(
+                Point1 const& pi, Point1 const& pj, Point1 const& pk,
+                Point2 const& qi, Point2 const& qj, Point2 const& qk,
+
+                // Opposite collinear can deliver 2 intersection points,
+                TurnInfo const& tp_model,
+                OutputIterator& out,
+
+                IntersectionInfo const& info,
+                SidePolicy const& side,
+                TurnTransformer turn_transformer,
+                bool const is_pk_valid = true, bool const is_qk_valid = true)
+    {
+        TurnInfo tp = tp_model;
+
+        int const p_arrival = info.d_info().arrival[0];
+        int const q_arrival = info.d_info().arrival[1];
+
+        // If P arrives within Q, there is a turn dependent on P
+        if ( p_arrival == 1
+          && is_pk_valid
+          && set_tp<0>(pi, pj, pk, side.pk_wrt_p1(), true, qi, qj, side.pk_wrt_q1(), tp, info.i_info()) )
+        {
+            turn_transformer(tp);
+
+            AssignPolicy::apply(tp, pi, qi, info);
+            *out++ = tp;
+        }
+
+        // If Q arrives within P, there is a turn dependent on Q
+        if ( q_arrival == 1
+          && is_qk_valid
+          && set_tp<1>(qi, qj, qk, side.qk_wrt_q1(), false, pi, pj, side.qk_wrt_p1(), tp, info.i_info()) )
+        {
+            turn_transformer(tp);
+
+            AssignPolicy::apply(tp, pi, qi, info);
+            *out++ = tp;
+        }
+
+        if (AssignPolicy::include_opposite)
+        {
+            // Handle cases not yet handled above
+            if ((q_arrival == -1 && p_arrival == 0)
+                || (p_arrival == -1 && q_arrival == 0))
+            {
+                for (unsigned int i = 0; i < 2; i++)
+                {
+                    tp.operations[i].operation = operation_opposite;
+                }
+                for (unsigned int i = 0; i < info.i_info().count; i++)
+                {
+                    assign_point(tp, method_collinear, info.i_info(), i);
+                    AssignPolicy::apply(tp, pi, qi, info);
+                    *out++ = tp;
+                }
+            }
+        }
+
+    }
+};
+
+
+template
+<
+    typename TurnInfo
+>
+struct crosses : public base_turn_handler
+{
+    template
+    <
+        typename Point1,
+        typename Point2,
+        typename IntersectionInfo,
+        typename DirInfo
+    >
+    static inline void apply(
+                Point1 const& , Point1 const& , Point1 const& ,
+                Point2 const& , Point2 const& , Point2 const& ,
+                TurnInfo& ti,
+                IntersectionInfo const& intersection_info,
+                DirInfo const& dir_info)
+    {
+        assign_point(ti, method_crosses, intersection_info, 0);
+
+        // In all casees:
+        // If Q crosses P from left to right
+        // Union: take P
+        // Intersection: take Q
+        // Otherwise: vice versa
+        int const side_qi_p1 = dir_info.sides.template get<1, 0>();
+        unsigned int const index = side_qi_p1 == 1 ? 0 : 1;
+        ti.operations[index].operation = operation_union;
+        ti.operations[1 - index].operation = operation_intersection;
+    }
+};
+
+struct only_convert : public base_turn_handler
+{
+    template<typename TurnInfo, typename IntersectionInfo>
+    static inline void apply(TurnInfo& ti, IntersectionInfo const& intersection_info)
+    {
+        assign_point(ti, method_none, intersection_info, 0); // was collinear
+        ti.operations[0].operation = operation_continue;
+        ti.operations[1].operation = operation_continue;
+    }
+};
+
+/*!
+\brief Policy doing nothing
+\details get_turn_info can have an optional policy to get/assign some
+    extra information. By default it does not, and this class
+    is that default.
+ */
+struct assign_null_policy
+{
+    static bool const include_no_turn = false;
+    static bool const include_degenerate = false;
+    static bool const include_opposite = false;
+
+    template
+    <
+        typename Info,
+        typename Point1,
+        typename Point2,
+        typename IntersectionInfo
+    >
+    static inline void apply(Info& , Point1 const& , Point2 const&, IntersectionInfo const&)
+    {}
+
+};
+
+
+/*!
+    \brief Turn information: intersection point, method, and turn information
+    \details Information necessary for traversal phase (a phase
+        of the overlay process). The information is gathered during the
+        get_turns (segment intersection) phase.
+    \tparam Point1 point type of first segment
+    \tparam Point2 point type of second segment
+    \tparam TurnInfo type of class getting intersection and turn info
+    \tparam AssignPolicy policy to assign extra info,
+        e.g. to calculate distance from segment's first points
+        to intersection points.
+        It also defines if a certain class of points
+        (degenerate, non-turns) should be included.
+ */
+template<typename AssignPolicy>
+struct get_turn_info
+{
+    // Intersect pi-pj with qi-qj
+    // The points pk and qk are used do determine more information
+    // about the turn (turn left/right)
+    template
+    <
+        typename Point1,
+        typename Point2,
+        typename TurnInfo,
+        typename IntersectionStrategy,
+        typename RobustPolicy,
+        typename OutputIterator
+    >
+    static inline OutputIterator apply(
+                Point1 const& pi, Point1 const& pj, Point1 const& pk,
+                Point2 const& qi, Point2 const& qj, Point2 const& qk,
+                bool /*is_p_first*/, bool /*is_p_last*/,
+                bool /*is_q_first*/, bool /*is_q_last*/,
+                TurnInfo const& tp_model,
+                IntersectionStrategy const& intersection_strategy,
+                RobustPolicy const& robust_policy,
+                OutputIterator out)
+    {
+        typedef intersection_info
+            <
+                Point1, Point2,
+                typename TurnInfo::point_type,
+                IntersectionStrategy,
+                RobustPolicy
+            > inters_info;
+
+        inters_info inters(pi, pj, pk, qi, qj, qk, intersection_strategy, robust_policy);
+
+        char const method = inters.d_info().how;
+
+        // Copy, to copy possibly extended fields
+        TurnInfo tp = tp_model;
+
+        // Select method and apply
+        switch(method)
+        {
+            case 'a' : // collinear, "at"
+            case 'f' : // collinear, "from"
+            case 's' : // starts from the middle
+                if (AssignPolicy::include_no_turn
+                    && inters.i_info().count > 0)
+                {
+                    only_convert::apply(tp, inters.i_info());
+                    AssignPolicy::apply(tp, pi, qi, inters);
+                    *out++ = tp;
+                }
+                break;
+
+            case 'd' : // disjoint: never do anything
+                break;
+
+            case 'm' :
+            {
+                typedef touch_interior
+                    <
+                        TurnInfo
+                    > policy;
+
+                // If Q (1) arrives (1)
+                if ( inters.d_info().arrival[1] == 1 )
+                {
+                    policy::template apply<0>(pi, pj, pk, qi, qj, qk,
+                                tp, inters.i_info(), inters.d_info(),
+                                inters.sides());
+                }
+                else
+                {
+                    // Swap p/q
+                    side_calculator
+                        <
+                            typename inters_info::cs_tag,
+                            typename inters_info::robust_point2_type,
+                            typename inters_info::robust_point1_type,
+                            typename inters_info::side_strategy_type
+                        > swapped_side_calc(inters.rqi(), inters.rqj(), inters.rqk(),
+                                            inters.rpi(), inters.rpj(), inters.rpk(),
+                                            inters.get_side_strategy());
+
+                    policy::template apply<1>(qi, qj, qk, pi, pj, pk,
+                                tp, inters.i_info(), inters.d_info(),
+                                swapped_side_calc);
+                }
+                AssignPolicy::apply(tp, pi, qi, inters);
+                *out++ = tp;
+            }
+            break;
+            case 'i' :
+            {
+                crosses<TurnInfo>::apply(pi, pj, pk, qi, qj, qk,
+                    tp, inters.i_info(), inters.d_info());
+                AssignPolicy::apply(tp, pi, qi, inters);
+                *out++ = tp;
+            }
+            break;
+            case 't' :
+            {
+                // Both touch (both arrive there)
+                touch<TurnInfo>::apply(pi, pj, pk, qi, qj, qk,
+                    tp, inters.i_info(), inters.d_info(), inters.sides());
+                AssignPolicy::apply(tp, pi, qi, inters);
+                *out++ = tp;
+            }
+            break;
+            case 'e':
+            {
+                if ( ! inters.d_info().opposite )
+                {
+                    // Both equal
+                    // or collinear-and-ending at intersection point
+                    equal<TurnInfo>::apply(pi, pj, pk, qi, qj, qk,
+                        tp, inters.i_info(), inters.d_info(), inters.sides());
+                    AssignPolicy::apply(tp, pi, qi, inters);
+                    *out++ = tp;
+                }
+                else
+                {
+                    equal_opposite
+                        <
+                            TurnInfo,
+                            AssignPolicy
+                        >::apply(pi, qi,
+                            tp, out, inters);
+                }
+            }
+            break;
+            case 'c' :
+            {
+                // Collinear
+                if ( ! inters.d_info().opposite )
+                {
+
+                    if ( inters.d_info().arrival[0] == 0 )
+                    {
+                        // Collinear, but similar thus handled as equal
+                        equal<TurnInfo>::apply(pi, pj, pk, qi, qj, qk,
+                                tp, inters.i_info(), inters.d_info(), inters.sides());
+
+                        // override assigned method
+                        tp.method = method_collinear;
+                    }
+                    else
+                    {
+                        collinear<TurnInfo>::apply(pi, pj, pk, qi, qj, qk,
+                                tp, inters.i_info(), inters.d_info(), inters.sides());
+                    }
+
+                    AssignPolicy::apply(tp, pi, qi, inters);
+                    *out++ = tp;
+                }
+                else
+                {
+                    collinear_opposite
+                        <
+                            TurnInfo,
+                            AssignPolicy
+                        >::apply(pi, pj, pk, qi, qj, qk,
+                            tp, out, inters, inters.sides());
+                }
+            }
+            break;
+            case '0' :
+            {
+                // degenerate points
+                if (AssignPolicy::include_degenerate)
+                {
+                    only_convert::apply(tp, inters.i_info());
+                    AssignPolicy::apply(tp, pi, qi, inters);
+                    *out++ = tp;
+                }
+            }
+            break;
+            default :
+            {
+#if defined(BOOST_GEOMETRY_DEBUG_ROBUSTNESS)
+                std::cout << "TURN: Unknown method: " << method << std::endl;
+#endif
+#if ! defined(BOOST_GEOMETRY_OVERLAY_NO_THROW)
+                BOOST_THROW_EXCEPTION(turn_info_exception(method));
+#endif
+            }
+            break;
+        }
+
+        return out;
+    }
+};
+
+
+}} // namespace detail::overlay
+#endif //DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TURN_INFO_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turn_info_for_endpoint.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turn_info_for_endpoint.hpp
new file mode 100644
index 00000000000..48716634c54
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turn_info_for_endpoint.hpp
@@ -0,0 +1,667 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2013, 2014, 2017.
+// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TURN_INFO_FOR_ENDPOINT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TURN_INFO_FOR_ENDPOINT_HPP
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_turn_info.hpp>
+#include <boost/geometry/policies/robustness/no_rescale_policy.hpp>
+
+namespace boost { namespace geometry {
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay {
+
+// SEGMENT_INTERSECTION RESULT
+
+//                   C  H0  H1  A0  A1   O              IP1 IP2
+
+// D0 and D1 == 0
+
+// |-------->        2   0   0   0   0   F              i/i x/x
+// |-------->
+//
+// |-------->        2   0   0   0   0   T              i/x x/i
+// <--------|
+//
+// |----->           1   0   0   0   0   T              x/x
+//       <-----|
+//
+
+// |--------->       2   0   0   0   1   T              i/x x/i
+//      <----|
+//
+// |--------->       2   0   0   0   0   F              i/i x/x
+//      |---->
+//
+// |--------->       2   0   0  -1   1   F              i/i u/x
+// |---->
+//
+// |--------->       2   0   0  -1   0   T              i/x u/i
+// <----|
+
+// |------->         2   0   0   1  -1   F   and        i/i x/u
+//     |------->     2   0   0  -1   1   F   symetric   i/i u/x
+// |------->
+//
+//     |------->     2   0   0  -1  -1   T              i/u u/i
+// <-------|
+//
+// |------->         2   0   0   1   1   T              i/x x/i
+//     <-------|
+//
+// |-------->        2   0   0  -1   1   F              i/i u/x
+//   |---->
+//
+// |-------->        2   0   0  -1   1   T              i/x u/i
+//   <----|
+
+//       |----->     1  -1  -1  -1  -1   T              u/u
+// <-----|
+//
+//       |----->     1  -1   0  -1   0   F   and        u/x
+// |----->           1   0  -1   0  -1   F   symetric   x/u
+//       |----->
+
+// D0 or D1 != 0
+
+//          ^
+//          |
+//          +        1  -1   1  -1   1   F   and        u/x  (P is vertical)
+// |-------->        1   1  -1   1  -1   F   symetric   x/u  (P is horizontal)
+// ^
+// |
+// +
+//
+//          +
+//          |
+//          v
+// |-------->        1   1   1   1   1   F              x/x  (P is vertical)
+//
+// ^
+// |
+// +
+// |-------->        1  -1  -1  -1  -1   F              u/u  (P is vertical)
+//
+//      ^
+//      |
+//      +
+// |-------->        1   0  -1   0  -1   F              u/u  (P is vertical)
+//
+//      +
+//      |
+//      v
+// |-------->        1   0   1   0   1   F              u/x  (P is vertical)
+//
+
+class linear_intersections
+{
+public:
+    template <typename Point1, typename Point2, typename IntersectionResult>
+    linear_intersections(Point1 const& pi,
+                         Point2 const& qi,
+                         IntersectionResult const& result,
+                         bool is_p_last, bool is_q_last)
+    {
+        int arrival_a = result.template get<1>().arrival[0];
+        int arrival_b = result.template get<1>().arrival[1];
+        bool same_dirs = result.template get<1>().dir_a == 0
+                      && result.template get<1>().dir_b == 0;
+
+        if ( same_dirs )
+        {
+            if ( result.template get<0>().count == 2 )
+            {
+                if ( ! result.template get<1>().opposite )
+                {
+                    ips[0].p_operation = operation_intersection;
+                    ips[0].q_operation = operation_intersection;
+                    ips[1].p_operation = union_or_blocked_same_dirs(arrival_a, is_p_last);
+                    ips[1].q_operation = union_or_blocked_same_dirs(arrival_b, is_q_last);
+
+                    ips[0].is_pi
+                        = equals::equals_point_point(
+                            pi, result.template get<0>().intersections[0]);
+                    ips[0].is_qi
+                        = equals::equals_point_point(
+                            qi, result.template get<0>().intersections[0]);
+                    ips[1].is_pj = arrival_a != -1;
+                    ips[1].is_qj = arrival_b != -1;
+                }
+                else
+                {
+                    ips[0].p_operation = operation_intersection;
+                    ips[0].q_operation = union_or_blocked_same_dirs(arrival_b, is_q_last);
+                    ips[1].p_operation = union_or_blocked_same_dirs(arrival_a, is_p_last);
+                    ips[1].q_operation = operation_intersection;
+
+                    ips[0].is_pi = arrival_b != 1;
+                    ips[0].is_qj = arrival_b != -1;
+                    ips[1].is_pj = arrival_a != -1;
+                    ips[1].is_qi = arrival_a != 1;
+                }
+            }
+            else
+            {
+                BOOST_GEOMETRY_ASSERT(result.template get<0>().count == 1);
+                ips[0].p_operation = union_or_blocked_same_dirs(arrival_a, is_p_last);
+                ips[0].q_operation = union_or_blocked_same_dirs(arrival_b, is_q_last);
+
+                ips[0].is_pi = arrival_a == -1;
+                ips[0].is_qi = arrival_b == -1;
+                ips[0].is_pj = arrival_a == 0;
+                ips[0].is_qj = arrival_b == 0;
+            }
+        }
+        else
+        {
+            ips[0].p_operation = union_or_blocked_different_dirs(arrival_a, is_p_last);
+            ips[0].q_operation = union_or_blocked_different_dirs(arrival_b, is_q_last);
+
+            ips[0].is_pi = arrival_a == -1;
+            ips[0].is_qi = arrival_b == -1;
+            ips[0].is_pj = arrival_a == 1;
+            ips[0].is_qj = arrival_b == 1;
+        }
+    }
+
+    struct ip_info
+    {
+        inline ip_info()
+            : p_operation(operation_none), q_operation(operation_none)
+            , is_pi(false), is_pj(false), is_qi(false), is_qj(false)
+        {}
+
+        operation_type p_operation, q_operation;
+        bool is_pi, is_pj, is_qi, is_qj;
+    };
+
+    template <std::size_t I>
+    ip_info const& get() const
+    {
+        BOOST_STATIC_ASSERT(I < 2);
+        return ips[I];
+    }
+    
+private:
+
+    // only if collinear (same_dirs)
+    static inline operation_type union_or_blocked_same_dirs(int arrival, bool is_last)
+    {
+        if ( arrival == 1 )
+            return operation_blocked;
+        else if ( arrival == -1 )
+            return operation_union;
+        else
+            return is_last ? operation_blocked : operation_union;
+            //return operation_blocked;
+    }
+
+    // only if not collinear (!same_dirs)
+    static inline operation_type union_or_blocked_different_dirs(int arrival, bool is_last)
+    {
+        if ( arrival == 1 )
+            //return operation_blocked;
+            return is_last ? operation_blocked : operation_union;
+        else
+            return operation_union;
+    }
+
+    ip_info ips[2];
+};
+
+template <typename AssignPolicy, bool EnableFirst, bool EnableLast>
+struct get_turn_info_for_endpoint
+{
+    BOOST_STATIC_ASSERT(EnableFirst || EnableLast);
+
+    template<typename Point1,
+             typename Point2,
+             typename TurnInfo,
+             typename IntersectionInfo,
+             typename OutputIterator
+    >
+    static inline bool apply(Point1 const& pi, Point1 const& pj, Point1 const& pk,
+                             Point2 const& qi, Point2 const& qj, Point2 const& qk,
+                             bool is_p_first, bool is_p_last,
+                             bool is_q_first, bool is_q_last,
+                             TurnInfo const& tp_model,
+                             IntersectionInfo const& inters,
+                             method_type /*method*/,
+                             OutputIterator out)
+    {
+        std::size_t ip_count = inters.i_info().count;
+        // no intersection points
+        if ( ip_count == 0 )
+            return false;
+
+        if ( !is_p_first && !is_p_last && !is_q_first && !is_q_last )
+            return false;
+
+        linear_intersections intersections(pi, qi, inters.result(), is_p_last, is_q_last);
+
+        bool append0_last
+            = analyse_segment_and_assign_ip(pi, pj, pk, qi, qj, qk,
+                                            is_p_first, is_p_last, is_q_first, is_q_last,
+                                            intersections.template get<0>(),
+                                            tp_model, inters, 0, out);
+
+        // NOTE: opposite && ip_count == 1 may be true!
+        bool opposite = inters.d_info().opposite;
+
+        // don't ignore only for collinear opposite
+        bool result_ignore_ip0 = append0_last && ( ip_count == 1 || !opposite );
+
+        if ( intersections.template get<1>().p_operation == operation_none )
+            return result_ignore_ip0;
+        
+        bool append1_last
+            = analyse_segment_and_assign_ip(pi, pj, pk, qi, qj, qk,
+                                            is_p_first, is_p_last, is_q_first, is_q_last,
+                                            intersections.template get<1>(),
+                                            tp_model, inters, 1, out);
+
+        // don't ignore only for collinear opposite
+        bool result_ignore_ip1 = append1_last && !opposite /*&& ip_count == 2*/;
+
+        return result_ignore_ip0 || result_ignore_ip1;
+    }
+
+    template <typename Point1,
+              typename Point2,
+              typename TurnInfo,
+              typename IntersectionInfo,
+              typename OutputIterator>
+    static inline
+    bool analyse_segment_and_assign_ip(Point1 const& pi, Point1 const& pj, Point1 const& pk,
+                                       Point2 const& qi, Point2 const& qj, Point2 const& qk,
+                                       bool is_p_first, bool is_p_last,
+                                       bool is_q_first, bool is_q_last,
+                                       linear_intersections::ip_info const& ip_info,
+                                       TurnInfo const& tp_model,
+                                       IntersectionInfo const& inters,
+                                       unsigned int ip_index,
+                                       OutputIterator out)
+    {
+#ifdef BOOST_GEOMETRY_DEBUG_GET_TURNS_LINEAR_LINEAR
+        // may this give false positives for INTs?
+        typename IntersectionResult::point_type const&
+            inters_pt = result.template get<0>().intersections[ip_index];
+        BOOST_GEOMETRY_ASSERT(ip_info.is_pi == equals::equals_point_point(pi, inters_pt));
+        BOOST_GEOMETRY_ASSERT(ip_info.is_qi == equals::equals_point_point(qi, inters_pt));
+        BOOST_GEOMETRY_ASSERT(ip_info.is_pj == equals::equals_point_point(pj, inters_pt));
+        BOOST_GEOMETRY_ASSERT(ip_info.is_qj == equals::equals_point_point(qj, inters_pt));
+#endif
+
+        // TODO - calculate first/last only if needed
+        bool is_p_first_ip = is_p_first && ip_info.is_pi;
+        bool is_p_last_ip = is_p_last && ip_info.is_pj;
+        bool is_q_first_ip = is_q_first && ip_info.is_qi;
+        bool is_q_last_ip = is_q_last && ip_info.is_qj;
+        bool append_first = EnableFirst && (is_p_first_ip || is_q_first_ip);
+        bool append_last = EnableLast && (is_p_last_ip || is_q_last_ip);
+
+        operation_type p_operation = ip_info.p_operation;
+        operation_type q_operation = ip_info.q_operation;
+
+        if ( append_first || append_last )
+        {
+            bool handled = handle_internal<0>(pi, pj, pk, qi, qj, qk,
+                                              inters.rpi(), inters.rpj(), inters.rpk(),
+                                              inters.rqi(), inters.rqj(), inters.rqk(),
+                                              is_p_first_ip, is_p_last_ip,
+                                              is_q_first_ip, is_q_last_ip,
+                                              ip_info.is_qi, ip_info.is_qj,
+                                              tp_model, inters, ip_index,
+                                              p_operation, q_operation);
+            if ( !handled )
+            {
+                handle_internal<1>(qi, qj, qk, pi, pj, pk,
+                                   inters.rqi(), inters.rqj(), inters.rqk(),
+                                   inters.rpi(), inters.rpj(), inters.rpk(),
+                                   is_q_first_ip, is_q_last_ip,
+                                   is_p_first_ip, is_p_last_ip,
+                                   ip_info.is_pi, ip_info.is_pj,
+                                   tp_model, inters, ip_index,
+                                   q_operation, p_operation);
+            }
+
+            if ( p_operation != operation_none )
+            {
+                method_type method = endpoint_ip_method(ip_info.is_pi, ip_info.is_pj,
+                                                        ip_info.is_qi, ip_info.is_qj);
+                turn_position p_pos = ip_position(is_p_first_ip, is_p_last_ip);
+                turn_position q_pos = ip_position(is_q_first_ip, is_q_last_ip);
+
+                // handle spikes
+
+                // P is spike and should be handled
+                if ( !is_p_last
+                  && ip_info.is_pj // this check is redundant (also in is_spike_p) but faster
+                  && inters.i_info().count == 2
+                  && inters.is_spike_p() )
+                {
+                    assign(pi, qi, inters.result(), ip_index, method, operation_blocked, q_operation,
+                           p_pos, q_pos, is_p_first_ip, is_q_first_ip, true, false, tp_model, out);
+                    assign(pi, qi, inters.result(), ip_index, method, operation_intersection, q_operation,
+                           p_pos, q_pos, is_p_first_ip, is_q_first_ip, true, false, tp_model, out);
+                }
+                // Q is spike and should be handled
+                else if ( !is_q_last
+                       && ip_info.is_qj // this check is redundant (also in is_spike_q) but faster
+                       && inters.i_info().count == 2
+                       && inters.is_spike_q() )
+                {
+                    assign(pi, qi, inters.result(), ip_index, method, p_operation, operation_blocked,
+                           p_pos, q_pos, is_p_first_ip, is_q_first_ip, false, true, tp_model, out);
+                    assign(pi, qi, inters.result(), ip_index, method, p_operation, operation_intersection,
+                           p_pos, q_pos, is_p_first_ip, is_q_first_ip, false, true, tp_model, out);
+                }
+                // no spikes
+                else
+                {
+                    assign(pi, qi, inters.result(), ip_index, method, p_operation, q_operation,
+                           p_pos, q_pos, is_p_first_ip, is_q_first_ip, false, false, tp_model, out);
+                }
+            }
+        }
+
+        return append_last;
+    }
+
+    // TODO: IT'S ALSO PROBABLE THAT ALL THIS FUNCTION COULD BE INTEGRATED WITH handle_segment
+    //       however now it's lazily calculated and then it would be always calculated
+
+    template<std::size_t G1Index,
+             typename Point1,
+             typename Point2,
+             typename RobustPoint1,
+             typename RobustPoint2,
+             typename TurnInfo,
+             typename IntersectionInfo
+    >
+    static inline bool handle_internal(Point1 const& /*i1*/, Point1 const& /*j1*/, Point1 const& /*k1*/,
+                                       Point2 const& i2, Point2 const& j2, Point2 const& /*k2*/,
+                                       RobustPoint1 const& ri1, RobustPoint1 const& rj1, RobustPoint1 const& /*rk1*/,
+                                       RobustPoint2 const& ri2, RobustPoint2 const& rj2, RobustPoint2 const& rk2,
+                                       bool first1, bool last1, bool first2, bool last2,
+                                       bool ip_i2, bool ip_j2, TurnInfo const& tp_model,
+                                       IntersectionInfo const& inters, unsigned int ip_index,
+                                       operation_type & op1, operation_type & op2)
+    {
+        typedef typename cs_tag<typename TurnInfo::point_type>::type cs_tag;
+
+        boost::ignore_unused_variable_warning(i2);
+        boost::ignore_unused_variable_warning(j2);
+        boost::ignore_unused_variable_warning(ip_index);
+        boost::ignore_unused_variable_warning(tp_model);
+
+        if ( !first2 && !last2 )
+        {
+            if ( first1 )
+            {
+#ifdef BOOST_GEOMETRY_DEBUG_GET_TURNS_LINEAR_LINEAR
+                // may this give false positives for INTs?
+                typename IntersectionResult::point_type const&
+                    inters_pt = inters.i_info().intersections[ip_index];
+                BOOST_GEOMETRY_ASSERT(ip_i2 == equals::equals_point_point(i2, inters_pt));
+                BOOST_GEOMETRY_ASSERT(ip_j2 == equals::equals_point_point(j2, inters_pt));
+#endif
+                if ( ip_i2 )
+                {
+                    // don't output this IP - for the first point of other geometry segment
+                    op1 = operation_none;
+                    op2 = operation_none;
+                    return true;
+                }
+                else if ( ip_j2 )
+                {
+                    side_calculator<cs_tag,
+                                    RobustPoint1, RobustPoint2,
+                                    typename IntersectionInfo::side_strategy_type,
+                                    RobustPoint2>
+                        side_calc(ri2, ri1, rj1, ri2, rj2, rk2, inters.get_side_strategy());
+
+                    std::pair<operation_type, operation_type>
+                        operations = operations_of_equal(side_calc);
+
+// TODO: must the above be calculated?
+// wouldn't it be enough to check if segments are collinear?
+
+                    if ( operations_both(operations, operation_continue) )
+                    {
+                        if ( op1 != operation_union 
+                          || op2 != operation_union
+                          || ! ( G1Index == 0 ? inters.is_spike_q() : inters.is_spike_p() ) )
+                        {
+                            // THIS IS WRT THE ORIGINAL SEGMENTS! NOT THE ONES ABOVE!
+                            bool opposite = inters.d_info().opposite;
+
+                            op1 = operation_intersection;
+                            op2 = opposite ? operation_union : operation_intersection;
+                        }
+                    }
+                    else
+                    {
+                        BOOST_GEOMETRY_ASSERT(operations_combination(operations, operation_intersection, operation_union));
+                        //op1 = operation_union;
+                        //op2 = operation_union;
+                    }
+
+                    return true;
+                }
+                // else do nothing - shouldn't be handled this way
+            }
+            else if ( last1 )
+            {
+#ifdef BOOST_GEOMETRY_DEBUG_GET_TURNS_LINEAR_LINEAR
+                // may this give false positives for INTs?
+                typename IntersectionResult::point_type const&
+                    inters_pt = inters.i_info().intersections[ip_index];
+                BOOST_GEOMETRY_ASSERT(ip_i2 == equals::equals_point_point(i2, inters_pt));
+                BOOST_GEOMETRY_ASSERT(ip_j2 == equals::equals_point_point(j2, inters_pt));
+#endif
+                if ( ip_i2 )
+                {
+                    // don't output this IP - for the first point of other geometry segment
+                    op1 = operation_none;
+                    op2 = operation_none;
+                    return true;
+                }
+                else if ( ip_j2 )
+                {
+                    side_calculator<cs_tag, RobustPoint1, RobustPoint2,
+                                    typename IntersectionInfo::side_strategy_type,
+                                    RobustPoint2>
+                        side_calc(ri2, rj1, ri1, ri2, rj2, rk2, inters.get_side_strategy());
+                    
+                    std::pair<operation_type, operation_type>
+                        operations = operations_of_equal(side_calc);
+
+// TODO: must the above be calculated?
+// wouldn't it be enough to check if segments are collinear?
+
+                    if ( operations_both(operations, operation_continue) )
+                    {
+                        if ( op1 != operation_blocked
+                          || op2 != operation_union
+                          || ! ( G1Index == 0 ? inters.is_spike_q() : inters.is_spike_p() ) )
+                        {
+                            // THIS IS WRT THE ORIGINAL SEGMENTS! NOT THE ONES ABOVE!
+                            bool second_going_out = inters.i_info().count > 1;
+
+                            op1 = operation_blocked;
+                            op2 = second_going_out ? operation_union : operation_intersection;
+                        }
+                    }
+                    else
+                    {
+                        BOOST_GEOMETRY_ASSERT(operations_combination(operations, operation_intersection, operation_union));
+                        //op1 = operation_blocked;
+                        //op2 = operation_union;
+                    }
+
+                    return true;
+                }
+                // else do nothing - shouldn't be handled this way
+            }
+            // else do nothing - shouldn't be handled this way
+        }
+
+        return false;
+    }
+
+    static inline method_type endpoint_ip_method(bool ip_pi, bool ip_pj, bool ip_qi, bool ip_qj)
+    {
+        if ( (ip_pi || ip_pj) && (ip_qi || ip_qj) )
+            return method_touch;
+        else
+            return method_touch_interior;
+    }
+
+    static inline turn_position ip_position(bool is_ip_first_i, bool is_ip_last_j)
+    {
+        return is_ip_first_i ? position_front :
+               ( is_ip_last_j ? position_back : position_middle );
+    }
+
+    template <typename Point1,
+              typename Point2,
+              typename IntersectionResult,
+              typename TurnInfo,
+              typename OutputIterator>
+    static inline void assign(Point1 const& pi, Point2 const& qi,
+                              IntersectionResult const& result,
+                              unsigned int ip_index,
+                              method_type method,
+                              operation_type op0, operation_type op1,
+                              turn_position pos0, turn_position pos1,
+                              bool is_p_first_ip, bool is_q_first_ip,
+                              bool is_p_spike, bool is_q_spike,
+                              TurnInfo const& tp_model,
+                              OutputIterator out)
+    {
+        TurnInfo tp = tp_model;
+        
+        //geometry::convert(ip, tp.point);
+        //tp.method = method;
+        base_turn_handler::assign_point(tp, method, result.template get<0>(), ip_index);
+
+        tp.operations[0].operation = op0;
+        tp.operations[1].operation = op1;
+        tp.operations[0].position = pos0;
+        tp.operations[1].position = pos1;
+
+        if ( result.template get<0>().count > 1 )
+        {
+            // NOTE: is_collinear is NOT set for the first endpoint
+            // for which there is no preceding segment
+
+            //BOOST_GEOMETRY_ASSERT( result.template get<1>().dir_a == 0 && result.template get<1>().dir_b == 0 );
+            if ( ! is_p_first_ip )
+            {
+                tp.operations[0].is_collinear = op0 != operation_intersection
+                                             || is_p_spike;
+            }
+
+            if ( ! is_q_first_ip )
+            {
+                tp.operations[1].is_collinear = op1 != operation_intersection
+                                             || is_q_spike;
+            }
+        }
+        else //if ( result.template get<0>().count == 1 )
+        {
+            if ( op0 == operation_blocked && op1 == operation_intersection )
+            {
+                tp.operations[0].is_collinear = true;
+            }
+            else if ( op0 == operation_intersection && op1 == operation_blocked )
+            {
+                tp.operations[1].is_collinear = true;
+            }
+        }
+
+        // TODO: this should get an intersection_info, which is unavailable here
+        // Because the assign_null policy accepts any structure, we pass the result instead for now
+        AssignPolicy::apply(tp, pi, qi, result);
+        *out++ = tp;
+    }
+
+    template <typename SidePolicy>
+    static inline std::pair<operation_type, operation_type> operations_of_equal(SidePolicy const& side)
+    {
+        int const side_pk_q2 = side.pk_wrt_q2();
+        int const side_pk_p = side.pk_wrt_p1();
+        int const side_qk_p = side.qk_wrt_p1();
+
+        // If pk is collinear with qj-qk, they continue collinearly.
+        // This can be on either side of p1 (== q1), or collinear
+        // The second condition checks if they do not continue
+        // oppositely
+        if ( side_pk_q2 == 0 && side_pk_p == side_qk_p )
+        {
+            return std::make_pair(operation_continue, operation_continue);
+        }
+
+        // If they turn to same side (not opposite sides)
+        if ( ! base_turn_handler::opposite(side_pk_p, side_qk_p) )
+        {
+            // If pk is left of q2 or collinear: p: union, q: intersection
+            if ( side_pk_q2 != -1 )
+            {
+                return std::make_pair(operation_union, operation_intersection);
+            }
+            else
+            {
+               return std::make_pair(operation_intersection, operation_union);
+            }
+        }
+        else
+        {
+            // They turn opposite sides. If p turns left (or collinear),
+           // p: union, q: intersection
+            if ( side_pk_p != -1 )
+            {
+                return std::make_pair(operation_union, operation_intersection);
+            }
+           else
+            {
+                return std::make_pair(operation_intersection, operation_union);
+            }
+        }
+   }
+
+    static inline bool operations_both(
+                            std::pair<operation_type, operation_type> const& operations,
+                            operation_type const op)
+    {
+        return operations.first == op && operations.second == op;
+    }
+
+    static inline bool operations_combination(
+                            std::pair<operation_type, operation_type> const& operations,
+                            operation_type const op1, operation_type const op2)
+    {
+        return ( operations.first == op1 && operations.second == op2 )
+            || ( operations.first == op2 && operations.second == op1 );
+    }
+};
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TURN_INFO_FOR_ENDPOINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turn_info_helpers.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turn_info_helpers.hpp
new file mode 100644
index 00000000000..f8247cd2407
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turn_info_helpers.hpp
@@ -0,0 +1,388 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2013, 2014, 2015, 2017.
+// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TURN_INFO_HELPERS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TURN_INFO_HELPERS_HPP
+
+#include <boost/geometry/policies/robustness/no_rescale_policy.hpp>
+
+namespace boost { namespace geometry {
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay {
+
+enum turn_position { position_middle, position_front, position_back };
+
+template <typename Point, typename SegmentRatio>
+struct turn_operation_linear
+    : public turn_operation<Point, SegmentRatio>
+{
+    turn_operation_linear()
+        : position(position_middle)
+        , is_collinear(false)
+    {}
+
+    turn_position position;
+    bool is_collinear; // valid only for Linear geometry
+};
+
+template <typename TurnPointCSTag, typename PointP, typename PointQ,
+          typename SideStrategy,
+          typename Pi = PointP, typename Pj = PointP, typename Pk = PointP,
+          typename Qi = PointQ, typename Qj = PointQ, typename Qk = PointQ
+>
+struct side_calculator
+{
+    inline side_calculator(Pi const& pi, Pj const& pj, Pk const& pk,
+                           Qi const& qi, Qj const& qj, Qk const& qk,
+                           SideStrategy const& side_strategy)
+        : m_pi(pi), m_pj(pj), m_pk(pk)
+        , m_qi(qi), m_qj(qj), m_qk(qk)
+        , m_side_strategy(side_strategy)
+    {}
+
+    inline int pk_wrt_p1() const { return m_side_strategy.apply(m_pi, m_pj, m_pk); }
+    inline int pk_wrt_q1() const { return m_side_strategy.apply(m_qi, m_qj, m_pk); }
+    inline int qk_wrt_p1() const { return m_side_strategy.apply(m_pi, m_pj, m_qk); }
+    inline int qk_wrt_q1() const { return m_side_strategy.apply(m_qi, m_qj, m_qk); }
+
+    inline int pk_wrt_q2() const { return m_side_strategy.apply(m_qj, m_qk, m_pk); }
+    inline int qk_wrt_p2() const { return m_side_strategy.apply(m_pj, m_pk, m_qk); }
+
+    Pi const& m_pi;
+    Pj const& m_pj;
+    Pk const& m_pk;
+    Qi const& m_qi;
+    Qj const& m_qj;
+    Qk const& m_qk;
+
+    SideStrategy m_side_strategy;
+};
+
+template <typename Point1, typename Point2, typename RobustPolicy>
+struct robust_points
+{
+    typedef typename geometry::robust_point_type
+        <
+            Point1, RobustPolicy
+        >::type robust_point1_type;
+
+    // TODO: define robust_point2_type using Point2?
+    typedef robust_point1_type robust_point2_type;
+
+    inline robust_points(Point1 const& pi, Point1 const& pj, Point1 const& pk,
+                         Point2 const& qi, Point2 const& qj, Point2 const& qk,
+                         RobustPolicy const& robust_policy)
+    {
+        geometry::recalculate(m_rpi, pi, robust_policy);
+        geometry::recalculate(m_rpj, pj, robust_policy);
+        geometry::recalculate(m_rpk, pk, robust_policy);
+        geometry::recalculate(m_rqi, qi, robust_policy);
+        geometry::recalculate(m_rqj, qj, robust_policy);
+        geometry::recalculate(m_rqk, qk, robust_policy);
+    }
+
+    robust_point1_type m_rpi, m_rpj, m_rpk;
+    robust_point2_type m_rqi, m_rqj, m_rqk;
+};
+
+template <typename Point1, typename Point2, typename TurnPoint, typename IntersectionStrategy, typename RobustPolicy>
+class intersection_info_base
+    : private robust_points<Point1, Point2, RobustPolicy>
+{
+    typedef robust_points<Point1, Point2, RobustPolicy> base;
+
+public:
+    typedef Point1 point1_type;
+    typedef Point2 point2_type;
+
+    typedef typename base::robust_point1_type robust_point1_type;
+    typedef typename base::robust_point2_type robust_point2_type;
+
+    typedef typename cs_tag<TurnPoint>::type cs_tag;
+
+    typedef typename IntersectionStrategy::side_strategy_type side_strategy_type;
+    typedef side_calculator<cs_tag, robust_point1_type, robust_point2_type, side_strategy_type> side_calculator_type;
+    
+    intersection_info_base(Point1 const& pi, Point1 const& pj, Point1 const& pk,
+                           Point2 const& qi, Point2 const& qj, Point2 const& qk,
+                           IntersectionStrategy const& intersection_strategy,
+                           RobustPolicy const& robust_policy)
+        : base(pi, pj, pk, qi, qj, qk, robust_policy)
+        , m_side_calc(base::m_rpi, base::m_rpj, base::m_rpk,
+                      base::m_rqi, base::m_rqj, base::m_rqk,
+                      intersection_strategy.get_side_strategy())
+        , m_pi(pi), m_pj(pj), m_pk(pk)
+        , m_qi(qi), m_qj(qj), m_qk(qk)
+    {}
+
+    inline Point1 const& pi() const { return m_pi; }
+    inline Point1 const& pj() const { return m_pj; }
+    inline Point1 const& pk() const { return m_pk; }
+
+    inline Point2 const& qi() const { return m_qi; }
+    inline Point2 const& qj() const { return m_qj; }
+    inline Point2 const& qk() const { return m_qk; }
+
+    inline robust_point1_type const& rpi() const { return base::m_rpi; }
+    inline robust_point1_type const& rpj() const { return base::m_rpj; }
+    inline robust_point1_type const& rpk() const { return base::m_rpk; }
+
+    inline robust_point2_type const& rqi() const { return base::m_rqi; }
+    inline robust_point2_type const& rqj() const { return base::m_rqj; }
+    inline robust_point2_type const& rqk() const { return base::m_rqk; }
+
+    inline side_calculator_type const& sides() const { return m_side_calc; }
+    
+private:
+    side_calculator_type m_side_calc;
+
+    point1_type const& m_pi;
+    point1_type const& m_pj;
+    point1_type const& m_pk;
+    point2_type const& m_qi;
+    point2_type const& m_qj;
+    point2_type const& m_qk;
+};
+
+template <typename Point1, typename Point2, typename TurnPoint, typename IntersectionStrategy>
+class intersection_info_base<Point1, Point2, TurnPoint, IntersectionStrategy, detail::no_rescale_policy>
+{
+public:
+    typedef Point1 point1_type;
+    typedef Point2 point2_type;
+
+    typedef Point1 robust_point1_type;
+    typedef Point2 robust_point2_type;
+
+    typedef typename cs_tag<TurnPoint>::type cs_tag;
+
+    typedef typename IntersectionStrategy::side_strategy_type side_strategy_type;
+    typedef side_calculator<cs_tag, Point1, Point2, side_strategy_type> side_calculator_type;
+    
+    intersection_info_base(Point1 const& pi, Point1 const& pj, Point1 const& pk,
+                           Point2 const& qi, Point2 const& qj, Point2 const& qk,
+                           IntersectionStrategy const& intersection_strategy,
+                           no_rescale_policy const& /*robust_policy*/)
+        : m_side_calc(pi, pj, pk, qi, qj, qk,
+                      intersection_strategy.get_side_strategy())
+    {}
+
+    inline Point1 const& pi() const { return m_side_calc.m_pi; }
+    inline Point1 const& pj() const { return m_side_calc.m_pj; }
+    inline Point1 const& pk() const { return m_side_calc.m_pk; }
+
+    inline Point2 const& qi() const { return m_side_calc.m_qi; }
+    inline Point2 const& qj() const { return m_side_calc.m_qj; }
+    inline Point2 const& qk() const { return m_side_calc.m_qk; }
+
+    inline Point1 const& rpi() const { return pi(); }
+    inline Point1 const& rpj() const { return pj(); }
+    inline Point1 const& rpk() const { return pk(); }
+
+    inline Point2 const& rqi() const { return qi(); }
+    inline Point2 const& rqj() const { return qj(); }
+    inline Point2 const& rqk() const { return qk(); }
+
+    inline side_calculator_type const& sides() const { return m_side_calc; }
+    
+private:
+    side_calculator_type m_side_calc;
+};
+
+
+template
+<
+    typename Point1,
+    typename Point2,
+    typename TurnPoint,
+    typename IntersectionStrategy,
+    typename RobustPolicy
+>
+class intersection_info
+    : public intersection_info_base<Point1, Point2, TurnPoint, IntersectionStrategy, RobustPolicy>
+{
+    typedef intersection_info_base<Point1, Point2, TurnPoint, IntersectionStrategy, RobustPolicy> base;
+
+public:
+    typedef segment_intersection_points
+    <
+        TurnPoint,
+        typename geometry::segment_ratio_type
+            <
+                TurnPoint, RobustPolicy
+            >::type
+    > intersection_point_type;
+
+    // NOTE: formerly defined in intersection_strategies
+    typedef policies::relate::segments_tupled
+        <
+            policies::relate::segments_intersection_points
+                <
+                    intersection_point_type
+                >,
+            policies::relate::segments_direction
+        > intersection_policy_type;
+
+    typedef IntersectionStrategy intersection_strategy_type;
+    typedef typename IntersectionStrategy::side_strategy_type side_strategy_type;
+
+    typedef model::referring_segment<Point1 const> segment_type1;
+    typedef model::referring_segment<Point2 const> segment_type2;
+    typedef typename base::side_calculator_type side_calculator_type;
+    
+    typedef typename intersection_policy_type::return_type result_type;
+    typedef typename boost::tuples::element<0, result_type>::type i_info_type; // intersection_info
+    typedef typename boost::tuples::element<1, result_type>::type d_info_type; // dir_info
+
+    intersection_info(Point1 const& pi, Point1 const& pj, Point1 const& pk,
+                      Point2 const& qi, Point2 const& qj, Point2 const& qk,
+                      IntersectionStrategy const& intersection_strategy,
+                      RobustPolicy const& robust_policy)
+        : base(pi, pj, pk, qi, qj, qk, intersection_strategy, robust_policy)
+        , m_result(intersection_strategy.apply(
+                        segment_type1(pi, pj),
+                        segment_type2(qi, qj),
+                        intersection_policy_type(),
+                        robust_policy,
+                        base::rpi(), base::rpj(),
+                        base::rqi(), base::rqj()))
+        , m_intersection_strategy(intersection_strategy)
+        , m_robust_policy(robust_policy)
+    {}
+
+    inline result_type const& result() const { return m_result; }
+    inline i_info_type const& i_info() const { return m_result.template get<0>(); }
+    inline d_info_type const& d_info() const { return m_result.template get<1>(); }
+
+    inline intersection_strategy_type const& get_intersection_strategy() const
+    {
+        return m_intersection_strategy;
+    }
+
+    inline side_strategy_type get_side_strategy() const
+    {
+        return m_intersection_strategy.get_side_strategy();
+    }
+
+    // TODO: it's more like is_spike_ip_p
+    inline bool is_spike_p() const
+    {
+        if (base::sides().pk_wrt_p1() == 0)
+        {
+            if (! is_ip_j<0>())
+            {
+                return false;
+            }
+
+            int const qk_p1 = base::sides().qk_wrt_p1();
+            int const qk_p2 = base::sides().qk_wrt_p2();
+                
+            if (qk_p1 == -qk_p2)
+            {
+                if (qk_p1 == 0)
+                {
+                    return is_spike_of_collinear(base::pi(), base::pj(),
+                                                 base::pk());
+                }
+                        
+                return true;
+            }
+        }
+        
+        return false;
+    }
+
+    // TODO: it's more like is_spike_ip_q
+    inline bool is_spike_q() const
+    {
+        if (base::sides().qk_wrt_q1() == 0)
+        {
+            if (! is_ip_j<1>())
+            {
+                return false;
+            }
+
+            int const pk_q1 = base::sides().pk_wrt_q1();
+            int const pk_q2 = base::sides().pk_wrt_q2();
+                
+            if (pk_q1 == -pk_q2)
+            {
+                if (pk_q1 == 0)
+                {
+                    return is_spike_of_collinear(base::qi(), base::qj(),
+                                                 base::qk());
+                }
+                        
+                return true;
+            }
+        }
+        
+        return false;
+    }
+
+private:
+    template <typename Point>
+    inline bool is_spike_of_collinear(Point const& i, Point const& j,
+                                      Point const& k) const
+    {
+        typedef model::referring_segment<Point const> seg;
+
+        // no need to calcualte direction info
+        typedef policies::relate::segments_intersection_points
+                <
+                    intersection_point_type
+                > policy_type;
+
+        typename policy_type::return_type const result
+            = m_intersection_strategy.apply(seg(i, j), seg(j, k),
+                                            policy_type(),
+                                            m_robust_policy);
+        
+        return result.count == 2;
+    }
+
+    template <std::size_t OpId>
+    bool is_ip_j() const
+    {
+        int arrival = d_info().arrival[OpId];
+        bool same_dirs = d_info().dir_a == 0 && d_info().dir_b == 0;
+
+        if (same_dirs)
+        {
+            if (i_info().count == 2)
+            {
+                return arrival != -1;
+            }
+            else
+            {
+                return arrival == 0;
+            }
+        }
+        else
+        {
+            return arrival == 1;
+        }
+    }
+
+    result_type m_result;
+    IntersectionStrategy const& m_intersection_strategy;
+    RobustPolicy const& m_robust_policy;
+};
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TURN_INFO_HELPERS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turn_info_la.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turn_info_la.hpp
new file mode 100644
index 00000000000..46c1305cd79
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turn_info_la.hpp
@@ -0,0 +1,893 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013, 2014, 2015, 2017.
+// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TURN_INFO_LA_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TURN_INFO_LA_HPP
+
+#include <boost/throw_exception.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/get_turn_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_turn_info_for_endpoint.hpp>
+
+// TEMP, for spikes detector
+//#include <boost/geometry/algorithms/detail/overlay/get_turn_info_ll.hpp>
+
+namespace boost { namespace geometry {
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay {
+
+template<typename AssignPolicy>
+struct get_turn_info_linear_areal
+{
+    // Currently only Linear spikes are handled
+    // Areal spikes are ignored
+    static const bool handle_spikes = true;
+
+    template
+    <
+        typename Point1,
+        typename Point2,
+        typename TurnInfo,
+        typename IntersectionStrategy,
+        typename RobustPolicy,
+        typename OutputIterator
+    >
+    static inline OutputIterator apply(
+                Point1 const& pi, Point1 const& pj, Point1 const& pk,
+                Point2 const& qi, Point2 const& qj, Point2 const& qk,
+                bool is_p_first, bool is_p_last,
+                bool is_q_first, bool is_q_last,
+                TurnInfo const& tp_model,
+                IntersectionStrategy const& intersection_strategy,
+                RobustPolicy const& robust_policy,
+                OutputIterator out)
+    {
+        typedef intersection_info
+            <
+                Point1, Point2,
+                typename TurnInfo::point_type,
+                IntersectionStrategy,
+                RobustPolicy
+            > inters_info;
+
+        inters_info inters(pi, pj, pk, qi, qj, qk, intersection_strategy, robust_policy);
+
+        char const method = inters.d_info().how;
+
+        // Copy, to copy possibly extended fields
+        TurnInfo tp = tp_model;
+
+        // Select method and apply
+        switch(method)
+        {
+            case 'a' : // collinear, "at"
+            case 'f' : // collinear, "from"
+            case 's' : // starts from the middle
+                get_turn_info_for_endpoint<true, true>(
+                    pi, pj, pk, qi, qj, qk,
+                    is_p_first, is_p_last, is_q_first, is_q_last,
+                    tp_model, inters, method_none, out);
+                break;
+
+            case 'd' : // disjoint: never do anything
+                break;
+
+            case 'm' :
+            {
+                if ( get_turn_info_for_endpoint<false, true>(
+                        pi, pj, pk, qi, qj, qk,
+                        is_p_first, is_p_last, is_q_first, is_q_last,
+                        tp_model, inters, method_touch_interior, out) )
+                {
+                    // do nothing
+                }
+                else
+                {
+                    typedef touch_interior
+                        <
+                            TurnInfo
+                        > policy;
+
+                    // If Q (1) arrives (1)
+                    if ( inters.d_info().arrival[1] == 1 )
+                    {
+                        policy::template apply<0>(pi, pj, pk, qi, qj, qk,
+                                    tp, inters.i_info(), inters.d_info(),
+                                    inters.sides());
+                    }
+                    else
+                    {
+                        // Swap p/q
+                        side_calculator
+                            <
+                                typename inters_info::cs_tag,
+                                typename inters_info::robust_point2_type,
+                                typename inters_info::robust_point1_type,
+                                typename inters_info::side_strategy_type
+                            > swapped_side_calc(inters.rqi(), inters.rqj(), inters.rqk(),
+                                                inters.rpi(), inters.rpj(), inters.rpk(),
+                                                inters.get_side_strategy());
+                        policy::template apply<1>(qi, qj, qk, pi, pj, pk,
+                                    tp, inters.i_info(), inters.d_info(),
+                                    swapped_side_calc);
+                    }
+
+                    if ( tp.operations[1].operation == operation_blocked )
+                    {
+                        tp.operations[0].is_collinear = true;
+                    }
+
+                    replace_method_and_operations_tm(tp.method,
+                                                     tp.operations[0].operation,
+                                                     tp.operations[1].operation);
+                    
+                    // this function assumes that 'u' must be set for a spike
+                    calculate_spike_operation(tp.operations[0].operation,
+                                              inters, is_p_last);
+                    
+                    AssignPolicy::apply(tp, pi, qi, inters);
+
+                    *out++ = tp;
+                }
+            }
+            break;
+            case 'i' :
+            {
+                crosses<TurnInfo>::apply(pi, pj, pk, qi, qj, qk,
+                                         tp, inters.i_info(), inters.d_info());
+
+                replace_operations_i(tp.operations[0].operation, tp.operations[1].operation);
+
+                AssignPolicy::apply(tp, pi, qi, inters);
+                *out++ = tp;
+            }
+            break;
+            case 't' :
+            {
+                // Both touch (both arrive there)
+                if ( get_turn_info_for_endpoint<false, true>(
+                        pi, pj, pk, qi, qj, qk,
+                        is_p_first, is_p_last, is_q_first, is_q_last,
+                        tp_model, inters, method_touch, out) )
+                {
+                    // do nothing
+                }
+                else 
+                {
+                    touch<TurnInfo>::apply(pi, pj, pk, qi, qj, qk,
+                            tp, inters.i_info(), inters.d_info(), inters.sides());
+
+                    if ( tp.operations[1].operation == operation_blocked )
+                    {
+                        tp.operations[0].is_collinear = true;
+                    }
+
+                    // workarounds for touch<> not taking spikes into account starts here
+                    // those was discovered empirically
+                    // touch<> is not symmetrical!
+                    // P spikes and Q spikes may produce various operations!
+                    // Only P spikes are valid for L/A
+                    // TODO: this is not optimal solution - think about rewriting touch<>
+
+                    if ( tp.operations[0].operation == operation_blocked )
+                    {
+                        // a spike on P on the same line with Q1
+                        if ( inters.is_spike_p() )
+                        {
+                            if ( inters.sides().qk_wrt_p1() == 0 )
+                            {
+                                tp.operations[0].is_collinear = true;
+                            }
+                            else
+                            {
+                                tp.operations[0].operation = operation_union;                                
+                            }
+                        }
+                    }
+                    else if ( tp.operations[0].operation == operation_continue
+                           && tp.operations[1].operation == operation_continue )
+                    {
+                        // P spike on the same line with Q2 (opposite)
+                        if ( inters.sides().pk_wrt_q1() == -inters.sides().qk_wrt_q1()
+                          && inters.is_spike_p() )
+                        {
+                            tp.operations[0].operation = operation_union;
+                            tp.operations[1].operation = operation_union;
+                        }
+                    }
+                    else if ( tp.operations[0].operation == operation_none
+                           && tp.operations[1].operation == operation_none )
+                    {
+                        // spike not handled by touch<>
+                        if ( inters.is_spike_p() )
+                        {
+                            tp.operations[0].operation = operation_intersection;
+                            tp.operations[1].operation = operation_union;
+
+                            if ( inters.sides().pk_wrt_q2() == 0 )
+                            {
+                                tp.operations[0].operation = operation_continue; // will be converted to i
+                                tp.operations[0].is_collinear = true;
+                            }
+                        }
+                    }
+
+                    // workarounds for touch<> not taking spikes into account ends here
+
+                    replace_method_and_operations_tm(tp.method,
+                                                     tp.operations[0].operation,
+                                                     tp.operations[1].operation);
+
+                    bool ignore_spike
+                        = calculate_spike_operation(tp.operations[0].operation,
+                                                    inters, is_p_last);
+
+// TODO: move this into the append_xxx and call for each turn?
+                    AssignPolicy::apply(tp, pi, qi, inters);
+
+                    if ( ! BOOST_GEOMETRY_CONDITION(handle_spikes)
+                      || ignore_spike
+                      || ! append_opposite_spikes<append_touches>( // for 'i' or 'c' i???
+                                tp, inters, is_p_last, is_q_last, out) )
+                    {
+                        *out++ = tp;
+                    }
+                }
+            }
+            break;
+            case 'e':
+            {
+                if ( get_turn_info_for_endpoint<true, true>(
+                        pi, pj, pk, qi, qj, qk,
+                        is_p_first, is_p_last, is_q_first, is_q_last,
+                        tp_model, inters, method_equal, out) )
+                {
+                    // do nothing
+                }
+                else
+                {
+                    tp.operations[0].is_collinear = true;
+
+                    if ( ! inters.d_info().opposite )
+                    {
+                        // Both equal
+                        // or collinear-and-ending at intersection point
+                        equal<TurnInfo>::apply(pi, pj, pk, qi, qj, qk,
+                            tp, inters.i_info(), inters.d_info(), inters.sides());
+
+                        turn_transformer_ec<false> transformer(method_touch);
+                        transformer(tp);
+                    
+// TODO: move this into the append_xxx and call for each turn?
+                        AssignPolicy::apply(tp, pi, qi, inters);
+                        
+                        // conditionally handle spikes
+                        if ( ! BOOST_GEOMETRY_CONDITION(handle_spikes)
+                          || ! append_collinear_spikes(tp, inters, is_p_last, is_q_last,
+                                                       method_touch, append_equal, out) )
+                        {
+                            *out++ = tp; // no spikes
+                        }
+                    }
+                    else
+                    {
+                        equal_opposite
+                            <
+                                TurnInfo,
+                                AssignPolicy
+                            >::apply(pi, qi,
+                                     tp, out, inters);
+                    }
+                }
+            }
+            break;
+            case 'c' :
+            {
+                // Collinear
+                if ( get_turn_info_for_endpoint<true, true>(
+                        pi, pj, pk, qi, qj, qk,
+                        is_p_first, is_p_last, is_q_first, is_q_last,
+                        tp_model, inters, method_collinear, out) )
+                {
+                    // do nothing
+                }
+                else
+                {
+                    tp.operations[0].is_collinear = true;
+
+                    if ( ! inters.d_info().opposite )
+                    {
+                        method_type method_replace = method_touch_interior;
+                        append_version_c version = append_collinear;
+
+                        if ( inters.d_info().arrival[0] == 0 )
+                        {
+                            // Collinear, but similar thus handled as equal
+                            equal<TurnInfo>::apply(pi, pj, pk, qi, qj, qk,
+                                    tp, inters.i_info(), inters.d_info(), inters.sides());
+
+                            method_replace = method_touch;
+                            version = append_equal;
+                        }
+                        else
+                        {
+                            collinear<TurnInfo>::apply(pi, pj, pk, qi, qj, qk,
+                                    tp, inters.i_info(), inters.d_info(), inters.sides());
+
+                            //method_replace = method_touch_interior;
+                            //version = append_collinear;
+                        }
+
+                        turn_transformer_ec<false> transformer(method_replace);
+                        transformer(tp);
+
+// TODO: move this into the append_xxx and call for each turn?
+                        AssignPolicy::apply(tp, pi, qi, inters);
+                        
+                        // conditionally handle spikes
+                        if ( ! BOOST_GEOMETRY_CONDITION(handle_spikes)
+                          || ! append_collinear_spikes(tp, inters, is_p_last, is_q_last,
+                                                       method_replace, version, out) )
+                        {
+                            // no spikes
+                            *out++ = tp;
+                        }
+                    }
+                    else
+                    {
+                        // Is this always 'm' ?
+                        turn_transformer_ec<false> transformer(method_touch_interior);
+
+                        // conditionally handle spikes
+                        if ( BOOST_GEOMETRY_CONDITION(handle_spikes) )
+                        {
+                            append_opposite_spikes<append_collinear_opposite>(
+                                    tp, inters, is_p_last, is_q_last, out);
+                        }
+
+                        // TODO: ignore for spikes?
+                        //       E.g. pass is_p_valid = !is_p_last && !is_pj_spike,
+                        //       the same with is_q_valid
+
+                        collinear_opposite
+                            <
+                                TurnInfo,
+                                AssignPolicy
+                            >::apply(pi, pj, pk, qi, qj, qk,
+                                tp, out, inters,
+                                inters.sides(), transformer,
+                                !is_p_last, true); // qk is always valid
+                    }
+                }
+            }
+            break;
+            case '0' :
+            {
+                // degenerate points
+                if ( BOOST_GEOMETRY_CONDITION(AssignPolicy::include_degenerate) )
+                {
+                    only_convert::apply(tp, inters.i_info());
+
+                    if ( is_p_first
+                      && equals::equals_point_point(pi, tp.point) )
+                    {
+                        tp.operations[0].position = position_front;
+                    }
+                    else if ( is_p_last
+                           && equals::equals_point_point(pj, tp.point) )
+                    {
+                        tp.operations[0].position = position_back;
+                    }
+                    // tp.operations[1].position = position_middle;
+
+                    AssignPolicy::apply(tp, pi, qi, inters);
+                    *out++ = tp;
+                }
+            }
+            break;
+            default :
+            {
+#if defined(BOOST_GEOMETRY_DEBUG_ROBUSTNESS)
+                std::cout << "TURN: Unknown method: " << method << std::endl;
+#endif
+#if ! defined(BOOST_GEOMETRY_OVERLAY_NO_THROW)
+                BOOST_THROW_EXCEPTION(turn_info_exception(method));
+#endif
+            }
+            break;
+        }
+
+        return out;
+    }
+
+    template <typename Operation,
+              typename IntersectionInfo>
+    static inline bool calculate_spike_operation(Operation & op,
+                                                 IntersectionInfo const& inters,
+                                                 bool is_p_last)
+    {
+        bool is_p_spike = ( op == operation_union || op == operation_intersection )
+                       && ! is_p_last
+                       && inters.is_spike_p();
+
+        if ( is_p_spike )
+        {
+            int const pk_q1 = inters.sides().pk_wrt_q1();
+            
+            bool going_in = pk_q1 < 0; // Pk on the right
+            bool going_out = pk_q1 > 0; // Pk on the left
+
+            int const qk_q1 = inters.sides().qk_wrt_q1();
+
+            // special cases
+            if ( qk_q1 < 0 ) // Q turning R
+            { 
+                // spike on the edge point
+                // if it's already known that the spike is going out this musn't be checked
+                if ( ! going_out
+                  && equals::equals_point_point(inters.rpj(), inters.rqj()) )
+                {
+                    int const pk_q2 = inters.sides().pk_wrt_q2();
+                    going_in = pk_q1 < 0 && pk_q2 < 0; // Pk on the right of both
+                    going_out = pk_q1 > 0 || pk_q2 > 0; // Pk on the left of one of them
+                }
+            }
+            else if ( qk_q1 > 0 ) // Q turning L
+            {
+                // spike on the edge point
+                // if it's already known that the spike is going in this musn't be checked
+                if ( ! going_in
+                  && equals::equals_point_point(inters.rpj(), inters.rqj()) )
+                {
+                    int const pk_q2 = inters.sides().pk_wrt_q2();
+                    going_in = pk_q1 < 0 || pk_q2 < 0; // Pk on the right of one of them
+                    going_out = pk_q1 > 0 && pk_q2 > 0; // Pk on the left of both
+                }
+            }
+
+            if ( going_in )
+            {
+                op = operation_intersection;
+                return true;
+            }
+            else if ( going_out )
+            {
+                op = operation_union;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    enum append_version_c { append_equal, append_collinear };
+
+    template <typename TurnInfo,
+              typename IntersectionInfo,
+              typename OutIt>
+    static inline bool append_collinear_spikes(TurnInfo & tp,
+                                               IntersectionInfo const& inters,
+                                               bool is_p_last, bool /*is_q_last*/,
+                                               method_type method, append_version_c version,
+                                               OutIt out)
+    {
+        // method == touch || touch_interior
+        // both position == middle
+
+        bool is_p_spike = ( version == append_equal ?
+                            ( tp.operations[0].operation == operation_union
+                           || tp.operations[0].operation == operation_intersection ) :
+                            tp.operations[0].operation == operation_continue )
+                       && ! is_p_last
+                       && inters.is_spike_p();
+
+        // TODO: throw an exception for spike in Areal?
+        /*bool is_q_spike = tp.operations[1].operation == operation_continue
+                       && inters.is_spike_q();
+
+        // both are collinear spikes on the same IP, we can just follow both
+        if ( is_p_spike && is_q_spike )
+        {
+            return false;
+        }
+        // spike on Linear - it's turning back on the boundary of Areal
+        else*/
+        if ( is_p_spike )
+        {
+            tp.method = method;
+            tp.operations[0].operation = operation_blocked;
+            tp.operations[1].operation = operation_union;
+            *out++ = tp;
+            tp.operations[0].operation = operation_continue; // boundary
+            //tp.operations[1].operation = operation_union;
+            *out++ = tp;
+
+            return true;
+        }
+        // spike on Areal - Linear is going outside
+        /*else if ( is_q_spike )
+        {
+            tp.method = method;
+            tp.operations[0].operation = operation_union;
+            tp.operations[1].operation = operation_continue;
+            *out++ = tp;
+            *out++ = tp;
+
+            return true;
+        }*/
+
+        return false;
+    }
+
+    enum append_version_o { append_touches, append_collinear_opposite };
+
+    template <append_version_o Version,
+              typename TurnInfo,
+              typename IntersectionInfo,
+              typename OutIt>
+    static inline bool append_opposite_spikes(TurnInfo & tp,
+                                              IntersectionInfo const& inters,
+                                              bool is_p_last, bool /*is_q_last*/,
+                                              OutIt out)
+    {
+        static const bool is_version_touches = (Version == append_touches);
+
+        bool is_p_spike = ( is_version_touches ?
+                            ( tp.operations[0].operation == operation_continue
+                           || tp.operations[0].operation == operation_intersection ) : // i ???
+                            true )
+                       && ! is_p_last
+                       && inters.is_spike_p();
+        
+        // TODO: throw an exception for spike in Areal?
+        /*bool is_q_spike = ( ( Version == append_touches
+                           && tp.operations[1].operation == operation_continue )
+                         || ( Version == append_collinear_opposite
+                           && tp.operations[1].operation == operation_none ) )
+                       && inters.is_spike_q();
+
+        if ( is_p_spike && is_q_spike )
+        {
+            // u/u or nothing?
+            return false;
+        }
+        else*/
+        if ( is_p_spike )
+        {
+            if ( BOOST_GEOMETRY_CONDITION(is_version_touches)
+              || inters.d_info().arrival[0] == 1 )
+            {
+                if ( BOOST_GEOMETRY_CONDITION(is_version_touches) )
+                {
+                    tp.operations[0].is_collinear = true;
+                    //tp.operations[1].is_collinear = false;
+                    tp.method = method_touch;
+                }
+                else
+                {
+                    tp.operations[0].is_collinear = true;
+                    //tp.operations[1].is_collinear = false;
+
+                    BOOST_GEOMETRY_ASSERT(inters.i_info().count > 1);
+                    base_turn_handler::assign_point(tp, method_touch_interior, inters.i_info(), 1);
+
+                    AssignPolicy::apply(tp, inters.pi(), inters.qi(), inters);
+                }
+
+                tp.operations[0].operation = operation_blocked;
+                tp.operations[1].operation = operation_continue; // boundary
+                *out++ = tp;
+                tp.operations[0].operation = operation_continue; // boundary
+                //tp.operations[1].operation = operation_continue; // boundary
+                *out++ = tp;
+
+                return true;
+            }
+        }
+        /*else if ( is_q_spike )
+        {
+            tp.operations[0].is_collinear = true;
+            tp.method = is_version_touches ? method_touch : method_touch_interior;
+            tp.operations[0].operation = operation_continue;
+            tp.operations[1].operation = operation_continue; // boundary
+            *out++ = tp;
+            *out++ = tp;
+
+            return true;
+        }*/
+
+        return false;
+    }
+
+    static inline void replace_method_and_operations_tm(method_type & method,
+                                                        operation_type & op0,
+                                                        operation_type & op1)
+    {
+        if ( op0 == operation_blocked && op1 == operation_blocked )
+        {
+            // NOTE: probably only if methods are WRT IPs, not segments!
+            method = (method == method_touch ? method_equal : method_collinear);
+        }
+
+        // Assuming G1 is always Linear
+        if ( op0 == operation_blocked )
+        {
+            op0 = operation_continue;
+        }
+
+        if ( op1 == operation_blocked )
+        {
+            op1 = operation_continue;
+        }
+        else if ( op1 == operation_intersection )
+        {
+            op1 = operation_union;
+        }
+
+        // spikes in 'm'
+        if ( method == method_error )
+        {
+            method = method_touch_interior;
+            op0 = operation_union;
+            op1 = operation_union;
+        }
+    }
+
+    template <bool IsFront>
+    class turn_transformer_ec
+    {
+    public:
+        explicit turn_transformer_ec(method_type method_t_or_m)
+            : m_method(method_t_or_m)
+        {}
+
+        template <typename Turn>
+        void operator()(Turn & turn) const
+        {
+            operation_type & op0 = turn.operations[0].operation;
+            operation_type & op1 = turn.operations[1].operation;
+
+            // NOTE: probably only if methods are WRT IPs, not segments!
+            if ( BOOST_GEOMETRY_CONDITION(IsFront)
+              || op0 == operation_intersection || op0 == operation_union
+              || op1 == operation_intersection || op1 == operation_union )
+            {
+                turn.method = m_method;
+            }
+
+            turn.operations[0].is_collinear = op0 != operation_blocked;
+
+            // Assuming G1 is always Linear
+            if ( op0 == operation_blocked )
+            {
+                op0 = operation_continue;
+            }
+
+            if ( op1 == operation_blocked )
+            {
+                op1 = operation_continue;
+            }
+            else if ( op1 == operation_intersection )
+            {
+                op1 = operation_union;
+            }
+        }
+
+    private:
+        method_type m_method;
+    };
+
+    static inline void replace_operations_i(operation_type & /*op0*/, operation_type & op1)
+    {
+        // assuming Linear is always the first one
+        op1 = operation_union;
+    }
+
+    // NOTE: Spikes may NOT be handled for Linear endpoints because it's not
+    //       possible to define a spike on an endpoint. Areal geometries must
+    //       NOT have spikes at all. One thing that could be done is to throw
+    //       an exception when spike is detected in Areal geometry.
+    
+    template <bool EnableFirst,
+              bool EnableLast,
+              typename Point1,
+              typename Point2,
+              typename TurnInfo,
+              typename IntersectionInfo,
+              typename OutputIterator>
+    static inline bool get_turn_info_for_endpoint(
+                            Point1 const& pi, Point1 const& /*pj*/, Point1 const& /*pk*/,
+                            Point2 const& qi, Point2 const& /*qj*/, Point2 const& /*qk*/,
+                            bool is_p_first, bool is_p_last,
+                            bool /*is_q_first*/, bool is_q_last,
+                            TurnInfo const& tp_model,
+                            IntersectionInfo const& inters,
+                            method_type /*method*/,
+                            OutputIterator out)
+    {
+        namespace ov = overlay;
+        typedef ov::get_turn_info_for_endpoint<AssignPolicy, EnableFirst, EnableLast> get_info_e;
+
+        const std::size_t ip_count = inters.i_info().count;
+        // no intersection points
+        if ( ip_count == 0 )
+            return false;
+
+        if ( !is_p_first && !is_p_last )
+            return false;
+
+// TODO: is_q_last could probably be replaced by false and removed from parameters
+
+        linear_intersections intersections(pi, qi, inters.result(), is_p_last, is_q_last);
+        linear_intersections::ip_info const& ip0 = intersections.template get<0>();
+        linear_intersections::ip_info const& ip1 = intersections.template get<1>();
+
+        const bool opposite = inters.d_info().opposite;
+
+        // ANALYSE AND ASSIGN FIRST
+
+        // IP on the first point of Linear Geometry
+        bool was_first_point_handled = false;
+        if ( BOOST_GEOMETRY_CONDITION(EnableFirst)
+          && is_p_first && ip0.is_pi && !ip0.is_qi ) // !q0i prevents duplication
+        {
+            TurnInfo tp = tp_model;
+            tp.operations[0].position = position_front;
+            tp.operations[1].position = position_middle;
+
+            if ( opposite ) // opposite -> collinear
+            {
+                tp.operations[0].operation = operation_continue;
+                tp.operations[1].operation = operation_union;
+                tp.method = ip0.is_qj ? method_touch : method_touch_interior;
+            }
+            else
+            {
+                typedef typename IntersectionInfo::robust_point1_type rp1_type;
+                typedef typename IntersectionInfo::robust_point2_type rp2_type;
+
+                method_type replaced_method = method_touch_interior;
+
+                if ( ip0.is_qj )
+                {
+                    side_calculator
+                        <
+                            typename IntersectionInfo::cs_tag,
+                            rp1_type, rp2_type,
+                            typename IntersectionInfo::side_strategy_type,
+                            rp2_type
+                        > side_calc(inters.rqi(), inters.rpi(), inters.rpj(),
+                                    inters.rqi(), inters.rqj(), inters.rqk(),
+                                    inters.get_side_strategy());
+
+                    std::pair<operation_type, operation_type>
+                        operations = get_info_e::operations_of_equal(side_calc);
+
+                    tp.operations[0].operation = operations.first;
+                    tp.operations[1].operation = operations.second;
+
+                    replaced_method = method_touch;
+                }
+                else
+                {
+                    side_calculator
+                        <
+                            typename IntersectionInfo::cs_tag,
+                            rp1_type, rp2_type,
+                            typename IntersectionInfo::side_strategy_type,
+                            rp2_type, rp1_type, rp1_type,
+                            rp2_type, rp1_type, rp2_type
+                        > side_calc(inters.rqi(), inters.rpi(), inters.rpj(),
+                                    inters.rqi(), inters.rpi(), inters.rqj(),
+                                    inters.get_side_strategy());
+
+                    std::pair<operation_type, operation_type>
+                        operations = get_info_e::operations_of_equal(side_calc);
+
+                    tp.operations[0].operation = operations.first;
+                    tp.operations[1].operation = operations.second;
+                }
+
+                turn_transformer_ec<true> transformer(replaced_method);
+                transformer(tp);
+            }
+
+            // equals<> or collinear<> will assign the second point,
+            // we'd like to assign the first one
+            base_turn_handler::assign_point(tp, tp.method, inters.i_info(), 0);
+
+            // NOTE: is_collinear is not set for the first endpoint of L
+            // for which there is no preceding segment
+            // here is_p_first_ip == true
+            tp.operations[0].is_collinear = false;
+
+            AssignPolicy::apply(tp, pi, qi, inters);
+            *out++ = tp;
+
+            was_first_point_handled = true;
+        }
+
+        // ANALYSE AND ASSIGN LAST
+
+        // IP on the last point of Linear Geometry
+        if ( BOOST_GEOMETRY_CONDITION(EnableLast)
+          && is_p_last
+          && ( ip_count > 1 ? (ip1.is_pj && !ip1.is_qi) : (ip0.is_pj && !ip0.is_qi) ) ) // prevents duplication
+        {
+            TurnInfo tp = tp_model;
+            
+            if ( inters.i_info().count > 1 )
+            {
+                //BOOST_GEOMETRY_ASSERT( result.template get<1>().dir_a == 0 && result.template get<1>().dir_b == 0 );
+                tp.operations[0].is_collinear = true;
+                tp.operations[1].operation = opposite ? operation_continue : operation_union;
+            }
+            else //if ( result.template get<0>().count == 1 )
+            {
+                side_calculator
+                    <
+                        typename IntersectionInfo::cs_tag,
+                        typename IntersectionInfo::robust_point1_type,
+                        typename IntersectionInfo::robust_point2_type,
+                        typename IntersectionInfo::side_strategy_type,
+                        typename IntersectionInfo::robust_point2_type
+                    > side_calc(inters.rqi(), inters.rpj(), inters.rpi(),
+                                inters.rqi(), inters.rqj(), inters.rqk(),
+                                inters.get_side_strategy());
+
+                std::pair<operation_type, operation_type>
+                    operations = get_info_e::operations_of_equal(side_calc);
+
+                tp.operations[0].operation = operations.first;
+                tp.operations[1].operation = operations.second;
+
+                turn_transformer_ec<false> transformer(method_none);
+                transformer(tp);
+
+                tp.operations[0].is_collinear = tp.both(operation_continue);
+            }
+
+            tp.method = ( ip_count > 1 ? ip1.is_qj : ip0.is_qj ) ? method_touch : method_touch_interior;
+            tp.operations[0].operation = operation_blocked;
+            tp.operations[0].position = position_back;
+            tp.operations[1].position = position_middle;
+            
+            // equals<> or collinear<> will assign the second point,
+            // we'd like to assign the first one
+            unsigned int ip_index = ip_count > 1 ? 1 : 0;
+            base_turn_handler::assign_point(tp, tp.method, inters.i_info(), ip_index);
+
+            AssignPolicy::apply(tp, pi, qi, inters);
+            *out++ = tp;
+
+            // don't ignore the first IP if the segment is opposite
+            return !( opposite && ip_count > 1 ) || was_first_point_handled;
+        }
+
+        // don't ignore anything for now
+        return false;
+    }
+};
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TURN_INFO_LA_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turn_info_ll.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turn_info_ll.hpp
new file mode 100644
index 00000000000..58fd4bb5c78
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turn_info_ll.hpp
@@ -0,0 +1,759 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013, 2014, 2015, 2017.
+// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TURN_INFO_LL_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TURN_INFO_LL_HPP
+
+#include <boost/throw_exception.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/get_turn_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_turn_info_for_endpoint.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+
+namespace boost { namespace geometry {
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay {
+
+template<typename AssignPolicy>
+struct get_turn_info_linear_linear
+{
+    static const bool handle_spikes = true;
+
+    template
+    <
+        typename Point1,
+        typename Point2,
+        typename TurnInfo,
+        typename IntersectionStrategy,
+        typename RobustPolicy,
+        typename OutputIterator
+    >
+    static inline OutputIterator apply(
+                Point1 const& pi, Point1 const& pj, Point1 const& pk,
+                Point2 const& qi, Point2 const& qj, Point2 const& qk,
+                bool is_p_first, bool is_p_last,
+                bool is_q_first, bool is_q_last,
+                TurnInfo const& tp_model,
+                IntersectionStrategy const& strategy,
+                RobustPolicy const& robust_policy,
+                OutputIterator out)
+    {
+        typedef intersection_info
+            <
+                Point1, Point2,
+                typename TurnInfo::point_type,
+                IntersectionStrategy,
+                RobustPolicy
+            > inters_info;
+
+        inters_info inters(pi, pj, pk, qi, qj, qk, strategy, robust_policy);
+
+        char const method = inters.d_info().how;
+
+        // Copy, to copy possibly extended fields
+        TurnInfo tp = tp_model;
+
+        // Select method and apply
+        switch(method)
+        {
+            case 'a' : // collinear, "at"
+            case 'f' : // collinear, "from"
+            case 's' : // starts from the middle
+                get_turn_info_for_endpoint<AssignPolicy, true, true>
+                    ::apply(pi, pj, pk, qi, qj, qk,
+                            is_p_first, is_p_last, is_q_first, is_q_last,
+                            tp_model, inters, method_none, out);
+                break;
+
+            case 'd' : // disjoint: never do anything
+                break;
+
+            case 'm' :
+            {
+                if ( get_turn_info_for_endpoint<AssignPolicy, false, true>
+                        ::apply(pi, pj, pk, qi, qj, qk,
+                                is_p_first, is_p_last, is_q_first, is_q_last,
+                                tp_model, inters, method_touch_interior, out) )
+                {
+                    // do nothing
+                }
+                else
+                {
+                    typedef touch_interior
+                        <
+                            TurnInfo
+                        > policy;
+
+                    // If Q (1) arrives (1)
+                    if ( inters.d_info().arrival[1] == 1)
+                    {
+                        policy::template apply<0>(pi, pj, pk, qi, qj, qk,
+                                                  tp, inters.i_info(), inters.d_info(),
+                                                  inters.sides());
+                    }
+                    else
+                    {
+                        // Swap p/q
+                        side_calculator
+                            <
+                                typename inters_info::cs_tag,
+                                typename inters_info::robust_point2_type,
+                                typename inters_info::robust_point1_type,
+                                typename inters_info::side_strategy_type
+                            > swapped_side_calc(inters.rqi(), inters.rqj(), inters.rqk(),
+                                                inters.rpi(), inters.rpj(), inters.rpk(),
+                                                inters.get_side_strategy());
+
+                        policy::template apply<1>(qi, qj, qk, pi, pj, pk,
+                                                  tp, inters.i_info(), inters.d_info(),
+                                                  swapped_side_calc);
+                    }
+                    
+                    if ( tp.operations[0].operation == operation_blocked )
+                    {
+                        tp.operations[1].is_collinear = true;
+                    }
+                    if ( tp.operations[1].operation == operation_blocked )
+                    {
+                        tp.operations[0].is_collinear = true;
+                    }
+
+                    replace_method_and_operations_tm(tp.method,
+                                                     tp.operations[0].operation,
+                                                     tp.operations[1].operation);
+                    
+                    AssignPolicy::apply(tp, pi, qi, inters);
+                    *out++ = tp;
+                }
+            }
+            break;
+            case 'i' :
+            {
+                crosses<TurnInfo>::apply(pi, pj, pk, qi, qj, qk,
+                                         tp, inters.i_info(), inters.d_info());
+
+                replace_operations_i(tp.operations[0].operation, tp.operations[1].operation);
+
+                AssignPolicy::apply(tp, pi, qi, inters);
+                *out++ = tp;
+            }
+            break;
+            case 't' :
+            {
+                // Both touch (both arrive there)
+                if ( get_turn_info_for_endpoint<AssignPolicy, false, true>
+                        ::apply(pi, pj, pk, qi, qj, qk,
+                                is_p_first, is_p_last, is_q_first, is_q_last,
+                                tp_model, inters, method_touch, out) )
+                {
+                    // do nothing
+                }
+                else 
+                {
+                    touch<TurnInfo>::apply(pi, pj, pk, qi, qj, qk,
+                                           tp, inters.i_info(), inters.d_info(), inters.sides());
+
+                    // workarounds for touch<> not taking spikes into account starts here
+                    // those was discovered empirically
+                    // touch<> is not symmetrical!
+                    // P spikes and Q spikes may produce various operations!
+                    // TODO: this is not optimal solution - think about rewriting touch<>
+
+                    if ( tp.operations[0].operation == operation_blocked
+                      && tp.operations[1].operation == operation_blocked )
+                    {
+                        // two touching spikes on the same line
+                        if ( inters.is_spike_p() && inters.is_spike_q() )
+                        {
+                            tp.operations[0].operation = operation_union;
+                            tp.operations[1].operation = operation_union; 
+                        }
+                        else
+                        {
+                            tp.operations[0].is_collinear = true;
+                            tp.operations[1].is_collinear = true;
+                        }
+                    }
+                    else if ( tp.operations[0].operation == operation_blocked )
+                    {
+                        // a spike on P on the same line with Q1
+                        if ( inters.is_spike_p() )
+                        {
+                            if ( inters.sides().qk_wrt_p1() == 0 )
+                            {
+                                tp.operations[0].is_collinear = true;
+                            }
+                            else
+                            {
+                                tp.operations[0].operation = operation_union;                                
+                            }
+                        }
+                        else
+                        {
+                            tp.operations[1].is_collinear = true;
+                        }
+                    }
+                    else if ( tp.operations[1].operation == operation_blocked )
+                    {
+                        // a spike on Q on the same line with P1
+                        if ( inters.is_spike_q() )
+                        {
+                            if ( inters.sides().pk_wrt_q1() == 0 )
+                            {
+                                tp.operations[1].is_collinear = true;
+                            }
+                            else
+                            {
+                                tp.operations[1].operation = operation_union;                                
+                            }
+                        }
+                        else
+                        {
+                            tp.operations[0].is_collinear = true;
+                        }
+                    }
+                    else if ( tp.operations[0].operation == operation_continue
+                           && tp.operations[1].operation == operation_continue )
+                    {
+                        // P spike on the same line with Q2 (opposite)
+                        if ( inters.sides().pk_wrt_q1() == -inters.sides().qk_wrt_q1()
+                          && inters.is_spike_p() )
+                        {
+                            tp.operations[0].operation = operation_union;
+                            tp.operations[1].operation = operation_union; 
+                        }
+                    }
+                    else if ( tp.operations[0].operation == operation_none
+                           && tp.operations[1].operation == operation_none )
+                    {
+                        // spike not handled by touch<>
+                        bool const is_p = inters.is_spike_p();
+                        bool const is_q = inters.is_spike_q();
+
+                        if ( is_p || is_q )
+                        {
+                            tp.operations[0].operation = operation_union;
+                            tp.operations[1].operation = operation_union;
+
+                            if ( inters.sides().pk_wrt_q2() == 0 )
+                            {
+                                tp.operations[0].operation = operation_continue; // will be converted to i
+                                if ( is_p )
+                                {
+                                    tp.operations[0].is_collinear = true;
+                                }
+                            }
+
+                            if ( inters.sides().qk_wrt_p2() == 0 )
+                            {
+                                tp.operations[1].operation = operation_continue; // will be converted to i
+                                if ( is_q )
+                                {
+                                    tp.operations[1].is_collinear = true;
+                                }
+                            }
+                        }
+                    }
+
+                    // workarounds for touch<> not taking spikes into account ends here
+
+                    replace_method_and_operations_tm(tp.method,
+                                                     tp.operations[0].operation,
+                                                     tp.operations[1].operation);
+
+// TODO: move this into the append_xxx and call for each turn?
+                    AssignPolicy::apply(tp, pi, qi, inters);
+
+                    if ( ! BOOST_GEOMETRY_CONDITION(handle_spikes)
+                      || ! append_opposite_spikes<append_touches>(tp, inters,
+                                                                  is_p_last, is_q_last,
+                                                                  out) )
+                    {
+                        *out++ = tp;
+                    }
+                }
+            }
+            break;
+            case 'e':
+            {
+                if ( get_turn_info_for_endpoint<AssignPolicy, true, true>
+                        ::apply(pi, pj, pk, qi, qj, qk,
+                                is_p_first, is_p_last, is_q_first, is_q_last,
+                                tp_model, inters, method_equal, out) )
+                {
+                    // do nothing
+                }
+                else
+                {
+                    tp.operations[0].is_collinear = true;
+                    tp.operations[1].is_collinear = true;
+
+                    if ( ! inters.d_info().opposite )
+                    {
+                        // Both equal
+                        // or collinear-and-ending at intersection point
+                        equal<TurnInfo>::apply(pi, pj, pk, qi, qj, qk,
+                            tp, inters.i_info(), inters.d_info(), inters.sides());
+
+                        operation_type spike_op
+                            = ( tp.operations[0].operation != operation_continue
+                             || tp.operations[1].operation != operation_continue ) ?
+                                operation_union :
+                                operation_continue;
+
+                        // transform turn
+                        turn_transformer_ec transformer(method_touch);
+                        transformer(tp);
+
+// TODO: move this into the append_xxx and call for each turn?
+                        AssignPolicy::apply(tp, pi, qi, inters);
+
+                        // conditionally handle spikes
+                        if ( ! BOOST_GEOMETRY_CONDITION(handle_spikes)
+                          || ! append_collinear_spikes(tp, inters,
+                                                       is_p_last, is_q_last,
+                                                       method_touch, spike_op,
+                                                       out) )
+                        {
+                            *out++ = tp; // no spikes
+                        }
+                    }
+                    else
+                    {
+                        // TODO: ignore for spikes or generate something else than opposite?
+
+                        equal_opposite
+                            <
+                                TurnInfo,
+                                AssignPolicy
+                            >::apply(pi, qi, tp, out, inters);
+                    }
+                }
+            }
+            break;
+            case 'c' :
+            {
+                // Collinear
+                if ( get_turn_info_for_endpoint<AssignPolicy, true, true>
+                        ::apply(pi, pj, pk, qi, qj, qk,
+                                is_p_first, is_p_last, is_q_first, is_q_last,
+                                tp_model, inters, method_collinear, out) )
+                {
+                    // do nothing
+                }
+                else
+                {
+                    // NOTE: this is for spikes since those are set in the turn_transformer_ec
+                    tp.operations[0].is_collinear = true;
+                    tp.operations[1].is_collinear = true;
+
+                    if ( ! inters.d_info().opposite )
+                    {
+                        method_type method_replace = method_touch_interior;
+                        operation_type spike_op = operation_continue;
+
+                        if ( inters.d_info().arrival[0] == 0 )
+                        {
+                            // Collinear, but similar thus handled as equal
+                            equal<TurnInfo>::apply(pi, pj, pk, qi, qj, qk,
+                                    tp, inters.i_info(), inters.d_info(), inters.sides());
+
+                            method_replace = method_touch;
+                            if ( tp.operations[0].operation != operation_continue
+                              || tp.operations[1].operation != operation_continue )
+                            {
+                                spike_op = operation_union;
+                            }
+                        }
+                        else
+                        {
+                            collinear<TurnInfo>::apply(pi, pj, pk, qi, qj, qk,
+                                    tp, inters.i_info(), inters.d_info(), inters.sides());
+
+                            //method_replace = method_touch_interior;
+                            //spike_op = operation_continue;
+                        }
+
+                        // transform turn
+                        turn_transformer_ec transformer(method_replace);
+                        transformer(tp);
+                        
+// TODO: move this into the append_xxx and call for each turn?
+                        AssignPolicy::apply(tp, pi, qi, inters);
+
+                        // conditionally handle spikes
+                        if ( ! BOOST_GEOMETRY_CONDITION(handle_spikes)
+                          || ! append_collinear_spikes(tp, inters,
+                                                       is_p_last, is_q_last,
+                                                       method_replace, spike_op,
+                                                       out) )
+                        {
+                            // no spikes
+                            *out++ = tp;
+                        }
+                    }
+                    else
+                    {
+                        // If this always 'm' ?
+                        turn_transformer_ec transformer(method_touch_interior);
+
+                        // conditionally handle spikes
+                        if ( BOOST_GEOMETRY_CONDITION(handle_spikes) )
+                        {
+                            append_opposite_spikes<append_collinear_opposite>(tp, inters,
+                                                                              is_p_last, is_q_last,
+                                                                              out);
+                        }
+
+                        // TODO: ignore for spikes?
+                        //       E.g. pass is_p_valid = !is_p_last && !is_pj_spike,
+                        //       the same with is_q_valid
+
+                        collinear_opposite
+                            <
+                                TurnInfo,
+                                AssignPolicy
+                            >::apply(pi, pj, pk, qi, qj, qk,
+                                tp, out, inters, inters.sides(),
+                                transformer, !is_p_last, !is_q_last);
+                    }
+                }
+            }
+            break;
+            case '0' :
+            {
+                // degenerate points
+                if ( BOOST_GEOMETRY_CONDITION(AssignPolicy::include_degenerate) )
+                {
+                    only_convert::apply(tp, inters.i_info());
+
+                    // if any, only one of those should be true
+                    if ( is_p_first
+                      && equals::equals_point_point(pi, tp.point) )
+                    {
+                        tp.operations[0].position = position_front;
+                    }
+                    else if ( is_p_last
+                           && equals::equals_point_point(pj, tp.point) )
+                    {
+                        tp.operations[0].position = position_back;
+                    }
+                    else if ( is_q_first
+                           && equals::equals_point_point(qi, tp.point) )
+                    {
+                        tp.operations[1].position = position_front;
+                    }
+                    else if ( is_q_last
+                           && equals::equals_point_point(qj, tp.point) )
+                    {
+                        tp.operations[1].position = position_back;
+                    }
+
+                    AssignPolicy::apply(tp, pi, qi, inters);
+                    *out++ = tp;
+                }
+            }
+            break;
+            default :
+            {
+#if defined(BOOST_GEOMETRY_DEBUG_ROBUSTNESS)
+                std::cout << "TURN: Unknown method: " << method << std::endl;
+#endif
+#if ! defined(BOOST_GEOMETRY_OVERLAY_NO_THROW)
+                BOOST_THROW_EXCEPTION(turn_info_exception(method));
+#endif
+            }
+            break;
+        }
+
+        return out;
+    }
+
+    template <typename TurnInfo,
+              typename IntersectionInfo,
+              typename OutIt>
+    static inline bool append_collinear_spikes(TurnInfo & tp,
+                                               IntersectionInfo const& inters_info,
+                                               bool is_p_last, bool is_q_last,
+                                               method_type method, operation_type spike_op,
+                                               OutIt out)
+    {
+        // method == touch || touch_interior
+        // both position == middle
+
+        bool is_p_spike = tp.operations[0].operation == spike_op
+                       && ! is_p_last
+                       && inters_info.is_spike_p();
+        bool is_q_spike = tp.operations[1].operation == spike_op
+                       && ! is_q_last
+                       && inters_info.is_spike_q();
+
+        if ( is_p_spike && is_q_spike )
+        {
+            if ( tp.method == method_equal
+              && tp.operations[0].operation == operation_continue
+              && tp.operations[1].operation == operation_continue )
+            {
+                // treat both non-opposite collinear spikes as no-spikes
+                return false;
+            }
+
+            tp.method = method;
+            tp.operations[0].operation = operation_blocked;
+            tp.operations[1].operation = operation_blocked;
+            *out++ = tp;
+            tp.operations[0].operation = operation_intersection;
+            tp.operations[1].operation = operation_intersection;
+            *out++ = tp;
+
+            return true;
+        }
+        else if ( is_p_spike )
+        {
+            tp.method = method;
+            tp.operations[0].operation = operation_blocked;
+            tp.operations[1].operation = operation_union;
+            *out++ = tp;
+            tp.operations[0].operation = operation_intersection;
+            //tp.operations[1].operation = operation_union;
+            *out++ = tp;
+
+            return true;
+        }
+        else if ( is_q_spike )
+        {
+            tp.method = method;
+            tp.operations[0].operation = operation_union;
+            tp.operations[1].operation = operation_blocked;
+            *out++ = tp;
+            //tp.operations[0].operation = operation_union;
+            tp.operations[1].operation = operation_intersection;
+            *out++ = tp;
+
+            return true;
+        }
+        
+        return false;
+    }
+
+    enum append_version { append_touches, append_collinear_opposite };
+
+    template <append_version Version,
+              typename TurnInfo,
+              typename IntersectionInfo,
+              typename OutIt>
+    static inline bool append_opposite_spikes(TurnInfo & tp,
+                                              IntersectionInfo const& inters,
+                                              bool is_p_last, bool is_q_last,
+                                              OutIt out)
+    {
+        static const bool is_version_touches = (Version == append_touches);
+
+        bool is_p_spike = ( is_version_touches ?
+                            ( tp.operations[0].operation == operation_continue
+                           || tp.operations[0].operation == operation_intersection ) :
+                            true )
+                       && ! is_p_last
+                       && inters.is_spike_p();
+        bool is_q_spike = ( is_version_touches ?
+                            ( tp.operations[1].operation == operation_continue
+                           || tp.operations[1].operation == operation_intersection ) :
+                            true )
+                       && ! is_q_last
+                       && inters.is_spike_q();
+
+        bool res = false;
+
+        if ( is_p_spike
+          && ( BOOST_GEOMETRY_CONDITION(is_version_touches)
+            || inters.d_info().arrival[0] == 1 ) )
+        {
+            if ( BOOST_GEOMETRY_CONDITION(is_version_touches) )
+            {
+                tp.operations[0].is_collinear = true;
+                tp.operations[1].is_collinear = false;
+                tp.method = method_touch;
+            }
+            else // Version == append_collinear_opposite
+            {
+                tp.operations[0].is_collinear = true;
+                tp.operations[1].is_collinear = false;
+                
+                BOOST_GEOMETRY_ASSERT(inters.i_info().count > 1);
+                
+                base_turn_handler::assign_point(tp, method_touch_interior,
+                                                inters.i_info(), 1);
+
+                AssignPolicy::apply(tp, inters.pi(), inters.qi(), inters);
+            }
+
+            tp.operations[0].operation = operation_blocked;
+            tp.operations[1].operation = operation_intersection;
+            *out++ = tp;
+            tp.operations[0].operation = operation_intersection;
+            //tp.operations[1].operation = operation_intersection;
+            *out++ = tp;
+
+            res = true;
+        }
+
+        if ( is_q_spike
+          && ( BOOST_GEOMETRY_CONDITION(is_version_touches)
+            || inters.d_info().arrival[1] == 1 ) )
+        {
+            if ( BOOST_GEOMETRY_CONDITION(is_version_touches) )
+            {
+                tp.operations[0].is_collinear = false;
+                tp.operations[1].is_collinear = true;
+                tp.method = method_touch;
+            }
+            else // Version == append_collinear_opposite
+            {
+                tp.operations[0].is_collinear = false;
+                tp.operations[1].is_collinear = true;
+                
+                BOOST_GEOMETRY_ASSERT(inters.i_info().count > 0);
+
+                base_turn_handler::assign_point(tp, method_touch_interior, inters.i_info(), 0);
+
+                AssignPolicy::apply(tp, inters.pi(), inters.qi(), inters);
+            }
+
+            tp.operations[0].operation = operation_intersection;
+            tp.operations[1].operation = operation_blocked;
+            *out++ = tp;
+            //tp.operations[0].operation = operation_intersection;
+            tp.operations[1].operation = operation_intersection;
+            *out++ = tp;
+
+            res = true;
+        }
+        
+        return res;
+    }
+
+    static inline void replace_method_and_operations_tm(method_type & method,
+                                                        operation_type & op0,
+                                                        operation_type & op1)
+    {
+        if ( op0 == operation_blocked && op1 == operation_blocked )
+        {
+            // NOTE: probably only if methods are WRT IPs, not segments!
+            method = (method == method_touch ? method_equal : method_collinear);
+            op0 = operation_continue;
+            op1 = operation_continue;
+        }
+        else
+        {
+            if ( op0 == operation_continue || op0 == operation_blocked )
+            {
+                op0 = operation_intersection;
+            }
+            else if ( op0 == operation_intersection )
+            {
+                op0 = operation_union;
+            }
+
+            if ( op1 == operation_continue || op1 == operation_blocked )
+            {
+                op1 = operation_intersection;
+            }
+            else if ( op1 == operation_intersection )
+            {
+                op1 = operation_union;
+            }
+
+            // spikes in 'm'
+            if ( method == method_error )
+            {
+                method = method_touch_interior;
+                op0 = operation_union;
+                op1 = operation_union;
+            }
+        }
+    }
+
+    class turn_transformer_ec
+    {
+    public:
+        explicit turn_transformer_ec(method_type method_t_or_m)
+            : m_method(method_t_or_m)
+        {}
+
+        template <typename Turn>
+        void operator()(Turn & turn) const
+        {
+            operation_type & op0 = turn.operations[0].operation;
+            operation_type & op1 = turn.operations[1].operation;
+
+            BOOST_GEOMETRY_ASSERT(op0 != operation_blocked || op1 != operation_blocked );
+
+            if ( op0 == operation_blocked )
+            {
+                op0 = operation_intersection;
+            }
+            else if ( op0 == operation_intersection )
+            {
+                op0 = operation_union;
+            }
+
+            if ( op1 == operation_blocked )
+            {
+                op1 = operation_intersection;
+            }
+            else if ( op1 == operation_intersection )
+            {
+                op1 = operation_union;
+            }
+
+            if ( op0 == operation_intersection || op0 == operation_union
+              || op1 == operation_intersection || op1 == operation_union )
+            {
+                turn.method = m_method;
+            }
+
+// TODO: is this correct?
+//       it's equivalent to comparing to operation_blocked at the beginning of the function
+            turn.operations[0].is_collinear = op0 != operation_intersection;
+            turn.operations[1].is_collinear = op1 != operation_intersection;
+        }
+
+    private:
+        method_type m_method;
+    };
+
+    static inline void replace_operations_i(operation_type & op0, operation_type & op1)
+    {
+        if ( op0 == operation_intersection )
+        {
+            op0 = operation_union;
+        }
+
+        if ( op1 == operation_intersection )
+        {
+            op1 = operation_union;
+        }
+    }
+};
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TURN_INFO_LL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turns.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turns.hpp
new file mode 100644
index 00000000000..f88dfe84229
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/get_turns.hpp
@@ -0,0 +1,1050 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2014-2017 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014, 2016, 2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TURNS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TURNS_HPP
+
+
+#include <cstddef>
+#include <map>
+
+#include <boost/array.hpp>
+#include <boost/concept_check.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/vector_c.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/reverse_dispatch.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/views/closeable_view.hpp>
+#include <boost/geometry/views/reversible_view.hpp>
+#include <boost/geometry/views/detail/range_type.hpp>
+
+#include <boost/geometry/geometries/box.hpp>
+#include <boost/geometry/geometries/segment.hpp>
+
+#include <boost/geometry/iterators/ever_circling_iterator.hpp>
+
+#include <boost/geometry/strategies/intersection_strategies.hpp>
+#include <boost/geometry/strategies/intersection_result.hpp>
+
+#include <boost/geometry/algorithms/detail/disjoint/box_box.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/point_point.hpp>
+
+#include <boost/geometry/algorithms/detail/interior_iterator.hpp>
+#include <boost/geometry/algorithms/detail/partition.hpp>
+#include <boost/geometry/algorithms/detail/recalculate.hpp>
+#include <boost/geometry/algorithms/detail/sections/section_box_policies.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/get_turn_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_turn_info_ll.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_turn_info_la.hpp>
+#include <boost/geometry/algorithms/detail/overlay/segment_identifier.hpp>
+
+#include <boost/geometry/algorithms/detail/sections/range_by_section.hpp>
+#include <boost/geometry/algorithms/detail/sections/sectionalize.hpp>
+#include <boost/geometry/algorithms/detail/sections/section_functions.hpp>
+
+#ifdef BOOST_GEOMETRY_DEBUG_INTERSECTION
+#  include <sstream>
+#  include <boost/geometry/io/dsv/write.hpp>
+#endif
+
+
+namespace boost { namespace geometry
+{
+
+// Silence warning C4127: conditional expression is constant
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4127)
+#endif
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace get_turns
+{
+
+
+struct no_interrupt_policy
+{
+    static bool const enabled = false;
+
+    // variable required by self_get_turn_points::get_turns
+    static bool const has_intersections = false;
+
+    template <typename Range>
+    static inline bool apply(Range const&)
+    {
+        return false;
+    }
+};
+
+
+template
+<
+    typename Geometry1, typename Geometry2,
+    bool Reverse1, bool Reverse2,
+    typename Section1, typename Section2,
+    typename TurnPolicy
+>
+class get_turns_in_sections
+{
+    typedef typename closeable_view
+        <
+            typename range_type<Geometry1>::type const,
+            closure<Geometry1>::value
+        >::type cview_type1;
+    typedef typename closeable_view
+        <
+            typename range_type<Geometry2>::type const,
+            closure<Geometry2>::value
+        >::type cview_type2;
+
+    typedef typename reversible_view
+        <
+            cview_type1 const,
+            Reverse1 ? iterate_reverse : iterate_forward
+        >::type view_type1;
+    typedef typename reversible_view
+        <
+            cview_type2 const,
+            Reverse2 ? iterate_reverse : iterate_forward
+        >::type view_type2;
+
+    typedef typename boost::range_iterator
+        <
+            view_type1 const
+        >::type range1_iterator;
+
+    typedef typename boost::range_iterator
+        <
+            view_type2 const
+        >::type range2_iterator;
+
+
+    template <typename Geometry, typename Section>
+    static inline bool neighbouring(Section const& section,
+            signed_size_type index1, signed_size_type index2)
+    {
+        // About n-2:
+        //   (square: range_count=5, indices 0,1,2,3
+        //    -> 0-3 are adjacent, don't check on intersections)
+        // Also tested for open polygons, and/or duplicates
+        // About first condition: will be optimized by compiler (static)
+        // It checks if it is areal (box,ring,(multi)polygon
+        signed_size_type const n = static_cast<signed_size_type>(section.range_count);
+
+        boost::ignore_unused_variable_warning(n);
+        boost::ignore_unused_variable_warning(index1);
+        boost::ignore_unused_variable_warning(index2);
+
+        return boost::is_same
+                    <
+                        typename tag_cast
+                            <
+                                typename geometry::tag<Geometry>::type,
+                                areal_tag
+                            >::type,
+                        areal_tag
+                    >::value
+               && index1 == 0
+               && index2 >= n - 2
+                ;
+    }
+
+
+public :
+    // Returns true if terminated, false if interrupted
+    template <typename IntersectionStrategy, typename RobustPolicy, typename Turns, typename InterruptPolicy>
+    static inline bool apply(
+            int source_id1, Geometry1 const& geometry1, Section1 const& sec1,
+            int source_id2, Geometry2 const& geometry2, Section2 const& sec2,
+            bool skip_larger,
+            IntersectionStrategy const& intersection_strategy,
+            RobustPolicy const& robust_policy,
+            Turns& turns,
+            InterruptPolicy& interrupt_policy)
+    {
+        boost::ignore_unused_variable_warning(interrupt_policy);
+
+        if ((sec1.duplicate && (sec1.count + 1) < sec1.range_count)
+           || (sec2.duplicate && (sec2.count + 1) < sec2.range_count))
+        {
+            // Skip sections containig only duplicates.
+            // They are still important (can indicate non-disjointness)
+            // but they will be found processing adjacent sections.
+            // Do NOT skip if they are the ONLY section
+            return true;
+        }
+
+        cview_type1 cview1(range_by_section(geometry1, sec1));
+        cview_type2 cview2(range_by_section(geometry2, sec2));
+        view_type1 view1(cview1);
+        view_type2 view2(cview2);
+
+        range1_iterator begin_range_1 = boost::begin(view1);
+        range1_iterator end_range_1 = boost::end(view1);
+
+        range2_iterator begin_range_2 = boost::begin(view2);
+        range2_iterator end_range_2 = boost::end(view2);
+
+        int const dir1 = sec1.directions[0];
+        int const dir2 = sec2.directions[0];
+        signed_size_type index1 = sec1.begin_index;
+        signed_size_type ndi1 = sec1.non_duplicate_index;
+
+        bool const same_source =
+            source_id1 == source_id2
+                    && sec1.ring_id.multi_index == sec2.ring_id.multi_index
+                    && sec1.ring_id.ring_index == sec2.ring_id.ring_index;
+
+        range1_iterator prev1, it1, end1;
+
+        get_start_point_iterator(sec1, view1, prev1, it1, end1,
+                    index1, ndi1, dir1, sec2.bounding_box, robust_policy);
+
+        // We need a circular iterator because it might run through the closing point.
+        // One circle is actually enough but this one is just convenient.
+        ever_circling_iterator<range1_iterator> next1(begin_range_1, end_range_1, it1, true);
+        next1++;
+
+        // Walk through section and stop if we exceed the other box
+        // section 2:    [--------------]
+        // section 1: |----|---|---|---|---|
+        for (prev1 = it1++, next1++;
+            it1 != end1 && ! detail::section::exceeding<0>(dir1, *prev1, sec1.bounding_box, sec2.bounding_box, robust_policy);
+            ++prev1, ++it1, ++index1, ++next1, ++ndi1)
+        {
+            ever_circling_iterator<range1_iterator> nd_next1(
+                    begin_range_1, end_range_1, next1, true);
+            advance_to_non_duplicate_next(nd_next1, it1, sec1, robust_policy);
+
+            signed_size_type index2 = sec2.begin_index;
+            signed_size_type ndi2 = sec2.non_duplicate_index;
+
+            range2_iterator prev2, it2, end2;
+
+            get_start_point_iterator(sec2, view2, prev2, it2, end2,
+                        index2, ndi2, dir2, sec1.bounding_box, robust_policy);
+            ever_circling_iterator<range2_iterator> next2(begin_range_2, end_range_2, it2, true);
+            next2++;
+
+            for (prev2 = it2++, next2++;
+                it2 != end2 && ! detail::section::exceeding<0>(dir2, *prev2, sec2.bounding_box, sec1.bounding_box, robust_policy);
+                ++prev2, ++it2, ++index2, ++next2, ++ndi2)
+            {
+                bool skip = same_source;
+                if (skip)
+                {
+                    // If sources are the same (possibly self-intersecting):
+                    // skip if it is a neighbouring segment.
+                    // (including first-last segment
+                    //  and two segments with one or more degenerate/duplicate
+                    //  (zero-length) segments in between)
+
+                    // Also skip if index1 < index2 to avoid getting all
+                    // intersections twice (only do this on same source!)
+
+                    skip = (skip_larger && index1 >= index2)
+                        || ndi2 == ndi1 + 1
+                        || neighbouring<Geometry1>(sec1, index1, index2)
+                        ;
+                }
+
+                if (! skip)
+                {
+                    // Move to the "non duplicate next"
+                    ever_circling_iterator<range2_iterator> nd_next2(
+                            begin_range_2, end_range_2, next2, true);
+                    advance_to_non_duplicate_next(nd_next2, it2, sec2, robust_policy);
+
+                    typedef typename boost::range_value<Turns>::type turn_info;
+
+                    turn_info ti;
+                    ti.operations[0].seg_id
+                        = segment_identifier(source_id1, sec1.ring_id.multi_index,
+                                             sec1.ring_id.ring_index, index1);
+                    ti.operations[1].seg_id
+                        = segment_identifier(source_id2, sec2.ring_id.multi_index,
+                                             sec2.ring_id.ring_index, index2);
+
+                    std::size_t const size_before = boost::size(turns);
+
+                    bool const is_1_first = sec1.is_non_duplicate_first && index1 == sec1.begin_index;
+                    bool const is_1_last = sec1.is_non_duplicate_last && index1+1 >= sec1.end_index;
+                    bool const is_2_first = sec2.is_non_duplicate_first && index2 == sec2.begin_index;
+                    bool const is_2_last = sec2.is_non_duplicate_last && index2+1 >= sec2.end_index;
+
+                    TurnPolicy::apply(*prev1, *it1, *nd_next1, *prev2, *it2, *nd_next2,
+                                      is_1_first, is_1_last, is_2_first, is_2_last,
+                                      ti, intersection_strategy, robust_policy,
+                                      std::back_inserter(turns));
+
+                    if (InterruptPolicy::enabled)
+                    {
+                        if (interrupt_policy.apply(
+                                std::make_pair(range::pos(turns, size_before),
+                                               boost::end(turns))))
+                        {
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+
+private :
+    typedef typename geometry::point_type<Geometry1>::type point1_type;
+    typedef typename geometry::point_type<Geometry2>::type point2_type;
+    typedef typename model::referring_segment<point1_type const> segment1_type;
+    typedef typename model::referring_segment<point2_type const> segment2_type;
+
+    template <typename Iterator, typename RangeIterator, typename Section, typename RobustPolicy>
+    static inline void advance_to_non_duplicate_next(Iterator& next,
+            RangeIterator const& it, Section const& section, RobustPolicy const& robust_policy)
+    {
+        typedef typename robust_point_type<point1_type, RobustPolicy>::type robust_point_type;
+        robust_point_type robust_point_from_it;
+        robust_point_type robust_point_from_next;
+        geometry::recalculate(robust_point_from_it, *it, robust_policy);
+        geometry::recalculate(robust_point_from_next, *next, robust_policy);
+
+        // To see where the next segments bend to, in case of touch/intersections
+        // on end points, we need (in case of degenerate/duplicate points) an extra
+        // iterator which moves to the REAL next point, so non duplicate.
+        // This needs an extra comparison (disjoint).
+        // (Note that within sections, non duplicate points are already asserted,
+        //   by the sectionalize process).
+
+        // So advance to the "non duplicate next"
+        // (the check is defensive, to avoid endless loops)
+        std::size_t check = 0;
+        while(! detail::disjoint::disjoint_point_point
+                (
+                    robust_point_from_it, robust_point_from_next
+                )
+            && check++ < section.range_count)
+        {
+            next++;
+            geometry::recalculate(robust_point_from_next, *next, robust_policy);
+        }
+    }
+
+    // It is NOT possible to have section-iterators here
+    // because of the logistics of "index" (the section-iterator automatically
+    // skips to the begin-point, we loose the index or have to recalculate it)
+    // So we mimic it here
+    template <typename Range, typename Section, typename Box, typename RobustPolicy>
+    static inline void get_start_point_iterator(Section const& section,
+            Range const& range,
+            typename boost::range_iterator<Range const>::type& it,
+            typename boost::range_iterator<Range const>::type& prev,
+            typename boost::range_iterator<Range const>::type& end,
+            signed_size_type& index, signed_size_type& ndi,
+            int dir, Box const& other_bounding_box, RobustPolicy const& robust_policy)
+    {
+        it = boost::begin(range) + section.begin_index;
+        end = boost::begin(range) + section.end_index + 1;
+
+        // Mimic section-iterator:
+        // Skip to point such that section interects other box
+        prev = it++;
+        for(; it != end && detail::section::preceding<0>(dir, *it, section.bounding_box, other_bounding_box, robust_policy);
+            prev = it++, index++, ndi++)
+        {}
+        // Go back one step because we want to start completely preceding
+        it = prev;
+    }
+};
+
+template
+<
+    typename Geometry1, typename Geometry2,
+    bool Reverse1, bool Reverse2,
+    typename TurnPolicy,
+    typename IntersectionStrategy,
+    typename RobustPolicy,
+    typename Turns,
+    typename InterruptPolicy
+>
+struct section_visitor
+{
+    int m_source_id1;
+    Geometry1 const& m_geometry1;
+    int m_source_id2;
+    Geometry2 const& m_geometry2;
+    IntersectionStrategy const& m_intersection_strategy;
+    RobustPolicy const& m_rescale_policy;
+    Turns& m_turns;
+    InterruptPolicy& m_interrupt_policy;
+
+    section_visitor(int id1, Geometry1 const& g1,
+                    int id2, Geometry2 const& g2,
+                    IntersectionStrategy const& intersection_strategy,
+                    RobustPolicy const& robust_policy,
+                    Turns& turns,
+                    InterruptPolicy& ip)
+        : m_source_id1(id1), m_geometry1(g1)
+        , m_source_id2(id2), m_geometry2(g2)
+        , m_intersection_strategy(intersection_strategy)
+        , m_rescale_policy(robust_policy)
+        , m_turns(turns)
+        , m_interrupt_policy(ip)
+    {}
+
+    template <typename Section>
+    inline bool apply(Section const& sec1, Section const& sec2)
+    {
+        if (! detail::disjoint::disjoint_box_box(sec1.bounding_box, sec2.bounding_box))
+        {
+            // false if interrupted
+            return get_turns_in_sections
+                    <
+                        Geometry1,
+                        Geometry2,
+                        Reverse1, Reverse2,
+                        Section, Section,
+                        TurnPolicy
+                    >::apply(m_source_id1, m_geometry1, sec1,
+                             m_source_id2, m_geometry2, sec2,
+                             false,
+                             m_intersection_strategy,
+                             m_rescale_policy,
+                             m_turns, m_interrupt_policy);
+        }
+        return true;
+    }
+
+};
+
+template
+<
+    typename Geometry1, typename Geometry2,
+    bool Reverse1, bool Reverse2,
+    typename TurnPolicy
+>
+class get_turns_generic
+{
+
+public:
+    template <typename IntersectionStrategy, typename RobustPolicy, typename Turns, typename InterruptPolicy>
+    static inline void apply(
+            int source_id1, Geometry1 const& geometry1,
+            int source_id2, Geometry2 const& geometry2,
+            IntersectionStrategy const& intersection_strategy,
+            RobustPolicy const& robust_policy,
+            Turns& turns,
+            InterruptPolicy& interrupt_policy)
+    {
+        // First create monotonic sections...
+        typedef typename boost::range_value<Turns>::type ip_type;
+        typedef typename ip_type::point_type point_type;
+
+        typedef model::box
+            <
+                typename geometry::robust_point_type
+                <
+                    point_type, RobustPolicy
+                >::type
+            > box_type;
+        typedef geometry::sections<box_type, 2> sections_type;
+
+        sections_type sec1, sec2;
+        typedef boost::mpl::vector_c<std::size_t, 0, 1> dimensions;
+
+        typename IntersectionStrategy::envelope_strategy_type const
+            envelope_strategy = intersection_strategy.get_envelope_strategy();
+
+        geometry::sectionalize<Reverse1, dimensions>(geometry1, robust_policy,
+                sec1, envelope_strategy, 0);
+        geometry::sectionalize<Reverse2, dimensions>(geometry2, robust_policy,
+                sec2, envelope_strategy, 1);
+
+        // ... and then partition them, intersecting overlapping sections in visitor method
+        section_visitor
+            <
+                Geometry1, Geometry2,
+                Reverse1, Reverse2,
+                TurnPolicy,
+                IntersectionStrategy, RobustPolicy,
+                Turns, InterruptPolicy
+            > visitor(source_id1, geometry1, source_id2, geometry2,
+                      intersection_strategy, robust_policy,
+                      turns, interrupt_policy);
+
+        geometry::partition
+            <
+                box_type
+            >::apply(sec1, sec2, visitor,
+                     detail::section::get_section_box(),
+                     detail::section::overlaps_section_box());
+    }
+};
+
+
+// Get turns for a range with a box, following Cohen-Sutherland (cs) approach
+template
+<
+    typename Range, typename Box,
+    bool ReverseRange, bool ReverseBox,
+    typename TurnPolicy
+>
+struct get_turns_cs
+{
+    typedef typename geometry::point_type<Range>::type point_type;
+    typedef typename geometry::point_type<Box>::type box_point_type;
+
+    typedef typename closeable_view
+        <
+            Range const,
+            closure<Range>::value
+        >::type cview_type;
+
+    typedef typename reversible_view
+        <
+            cview_type const,
+            ReverseRange ? iterate_reverse : iterate_forward
+        >::type view_type;
+
+    typedef typename boost::range_iterator
+        <
+            view_type const
+        >::type iterator_type;
+
+
+    template <typename IntersectionStrategy, typename RobustPolicy, typename Turns, typename InterruptPolicy>
+    static inline void apply(
+                int source_id1, Range const& range,
+                int source_id2, Box const& box,
+                IntersectionStrategy const& intersection_strategy,
+                RobustPolicy const& robust_policy,
+                Turns& turns,
+                InterruptPolicy& interrupt_policy,
+                signed_size_type multi_index = -1,
+                signed_size_type ring_index = -1)
+    {
+        if ( boost::size(range) <= 1)
+        {
+            return;
+        }
+
+        boost::array<box_point_type,4> bp;
+        assign_box_corners_oriented<ReverseBox>(box, bp);
+
+        cview_type cview(range);
+        view_type view(cview);
+
+        typedef typename boost::range_size<view_type>::type size_type;
+        size_type segments_count1 = boost::size(view) - 1;
+
+        iterator_type it = boost::begin(view);
+
+        ever_circling_iterator<iterator_type> next(
+                boost::begin(view), boost::end(view), it, true);
+        next++;
+        next++;
+
+        //bool first = true;
+
+        //char previous_side[2] = {0, 0};
+
+        signed_size_type index = 0;
+
+        for (iterator_type prev = it++;
+            it != boost::end(view);
+            prev = it++, next++, index++)
+        {
+            segment_identifier seg_id(source_id1,
+                        multi_index, ring_index, index);
+
+            /*if (first)
+            {
+                previous_side[0] = get_side<0>(box, *prev);
+                previous_side[1] = get_side<1>(box, *prev);
+            }
+
+            char current_side[2];
+            current_side[0] = get_side<0>(box, *it);
+            current_side[1] = get_side<1>(box, *it);
+
+            // There can NOT be intersections if
+            // 1) EITHER the two points are lying on one side of the box (! 0 && the same)
+            // 2) OR same in Y-direction
+            // 3) OR all points are inside the box (0)
+            if (! (
+                (current_side[0] != 0 && current_side[0] == previous_side[0])
+                || (current_side[1] != 0 && current_side[1] == previous_side[1])
+                || (current_side[0] == 0
+                        && current_side[1] == 0
+                        && previous_side[0] == 0
+                        && previous_side[1] == 0)
+                  )
+                )*/
+            if (true)
+            {
+                get_turns_with_box(seg_id, source_id2,
+                        *prev, *it, *next,
+                        bp[0], bp[1], bp[2], bp[3],
+                        // NOTE: some dummy values could be passed below since this would be called only for Polygons and Boxes
+                        index == 0,
+                        size_type(index) == segments_count1,
+                        intersection_strategy,
+                        robust_policy,
+                        turns,
+                        interrupt_policy);
+                // Future performance enhancement:
+                // return if told by the interrupt policy
+            }
+        }
+    }
+
+private:
+    template<std::size_t Index, typename Point>
+    static inline int get_side(Box const& box, Point const& point)
+    {
+        // Inside -> 0
+        // Outside -> -1 (left/below) or 1 (right/above)
+        // On border -> -2 (left/lower) or 2 (right/upper)
+        // The only purpose of the value is to not be the same,
+        // and to denote if it is inside (0)
+
+        typename coordinate_type<Point>::type const& c = get<Index>(point);
+        typename coordinate_type<Box>::type const& left = get<min_corner, Index>(box);
+        typename coordinate_type<Box>::type const& right = get<max_corner, Index>(box);
+
+        if (geometry::math::equals(c, left)) return -2;
+        else if (geometry::math::equals(c, right)) return 2;
+        else if (c < left) return -1;
+        else if (c > right) return 1;
+        else return 0;
+    }
+
+    template <typename IntersectionStrategy, typename RobustPolicy, typename Turns, typename InterruptPolicy>
+    static inline void get_turns_with_box(segment_identifier const& seg_id, int source_id2,
+            // Points from a range:
+            point_type const& rp0,
+            point_type const& rp1,
+            point_type const& rp2,
+            // Points from the box
+            box_point_type const& bp0,
+            box_point_type const& bp1,
+            box_point_type const& bp2,
+            box_point_type const& bp3,
+            bool const is_range_first,
+            bool const is_range_last,
+            IntersectionStrategy const& intersection_strategy,
+            RobustPolicy const& robust_policy,
+            // Output
+            Turns& turns,
+            InterruptPolicy& interrupt_policy)
+    {
+        boost::ignore_unused_variable_warning(interrupt_policy);
+
+        // Depending on code some relations can be left out
+
+        typedef typename boost::range_value<Turns>::type turn_info;
+
+        turn_info ti;
+        ti.operations[0].seg_id = seg_id;
+
+        ti.operations[1].seg_id = segment_identifier(source_id2, -1, -1, 0);
+        TurnPolicy::apply(rp0, rp1, rp2, bp0, bp1, bp2,
+                          is_range_first, is_range_last,
+                          true, false,
+                          ti, intersection_strategy, robust_policy,
+                          std::back_inserter(turns));
+
+        ti.operations[1].seg_id = segment_identifier(source_id2, -1, -1, 1);
+        TurnPolicy::apply(rp0, rp1, rp2, bp1, bp2, bp3,
+                          is_range_first, is_range_last,
+                          false, false,
+                          ti, intersection_strategy, robust_policy,
+                          std::back_inserter(turns));
+
+        ti.operations[1].seg_id = segment_identifier(source_id2, -1, -1, 2);
+        TurnPolicy::apply(rp0, rp1, rp2, bp2, bp3, bp0,
+                          is_range_first, is_range_last,
+                          false, false,
+                          ti, intersection_strategy, robust_policy,
+                          std::back_inserter(turns));
+
+        ti.operations[1].seg_id = segment_identifier(source_id2, -1, -1, 3);
+        TurnPolicy::apply(rp0, rp1, rp2, bp3, bp0, bp1,
+                          is_range_first, is_range_last,
+                          false, true,
+                          ti, intersection_strategy, robust_policy,
+                          std::back_inserter(turns));
+
+        if (InterruptPolicy::enabled)
+        {
+            interrupt_policy.apply(turns);
+        }
+
+    }
+
+};
+
+
+template
+<
+    typename Polygon, typename Box,
+    bool Reverse, bool ReverseBox,
+    typename TurnPolicy
+>
+struct get_turns_polygon_cs
+{
+    template <typename IntersectionStrategy, typename RobustPolicy, typename Turns, typename InterruptPolicy>
+    static inline void apply(
+            int source_id1, Polygon const& polygon,
+            int source_id2, Box const& box,
+            IntersectionStrategy const& intersection_strategy,
+            RobustPolicy const& robust_policy,
+            Turns& turns,
+            InterruptPolicy& interrupt_policy,
+            signed_size_type multi_index = -1)
+    {
+        typedef typename geometry::ring_type<Polygon>::type ring_type;
+
+        typedef detail::get_turns::get_turns_cs
+            <
+                ring_type, Box,
+                Reverse, ReverseBox,
+                TurnPolicy
+            > intersector_type;
+
+        intersector_type::apply(
+                source_id1, geometry::exterior_ring(polygon),
+                source_id2, box,
+                intersection_strategy,
+                robust_policy,
+                turns,
+                interrupt_policy,
+                multi_index, -1);
+
+        signed_size_type i = 0;
+
+        typename interior_return_type<Polygon const>::type
+            rings = interior_rings(polygon);
+        for (typename detail::interior_iterator<Polygon const>::type
+                it = boost::begin(rings); it != boost::end(rings); ++it, ++i)
+        {
+            intersector_type::apply(
+                    source_id1, *it,
+                    source_id2, box,
+                    intersection_strategy,
+                    robust_policy,
+                    turns, interrupt_policy,
+                    multi_index, i);
+        }
+
+    }
+};
+
+
+template
+<
+    typename Multi, typename Box,
+    bool Reverse, bool ReverseBox,
+    typename TurnPolicy
+>
+struct get_turns_multi_polygon_cs
+{
+    template <typename IntersectionStrategy, typename RobustPolicy, typename Turns, typename InterruptPolicy>
+    static inline void apply(
+            int source_id1, Multi const& multi,
+            int source_id2, Box const& box,
+            IntersectionStrategy const& intersection_strategy,
+            RobustPolicy const& robust_policy,
+            Turns& turns,
+            InterruptPolicy& interrupt_policy)
+    {
+        typedef typename boost::range_iterator
+            <
+                Multi const
+            >::type iterator_type;
+
+        signed_size_type i = 0;
+        for (iterator_type it = boost::begin(multi);
+             it != boost::end(multi);
+             ++it, ++i)
+        {
+            // Call its single version
+            get_turns_polygon_cs
+                <
+                    typename boost::range_value<Multi>::type, Box,
+                    Reverse, ReverseBox,
+                    TurnPolicy
+                >::apply(source_id1, *it, source_id2, box,
+                         intersection_strategy, robust_policy,
+                         turns, interrupt_policy, i);
+        }
+    }
+};
+
+
+// GET_TURN_INFO_TYPE
+
+template <typename Geometry>
+struct topological_tag_base
+{
+    typedef typename tag_cast<typename tag<Geometry>::type, pointlike_tag, linear_tag, areal_tag>::type type;
+};
+
+template <typename Geometry1, typename Geometry2, typename AssignPolicy,
+          typename Tag1 = typename tag<Geometry1>::type, typename Tag2 = typename tag<Geometry2>::type,
+          typename TagBase1 = typename topological_tag_base<Geometry1>::type, typename TagBase2 = typename topological_tag_base<Geometry2>::type>
+struct get_turn_info_type
+    : overlay::get_turn_info<AssignPolicy>
+{};
+
+template <typename Geometry1, typename Geometry2, typename AssignPolicy, typename Tag1, typename Tag2>
+struct get_turn_info_type<Geometry1, Geometry2, AssignPolicy, Tag1, Tag2, linear_tag, linear_tag>
+    : overlay::get_turn_info_linear_linear<AssignPolicy>
+{};
+
+template <typename Geometry1, typename Geometry2, typename AssignPolicy, typename Tag1, typename Tag2>
+struct get_turn_info_type<Geometry1, Geometry2, AssignPolicy, Tag1, Tag2, linear_tag, areal_tag>
+    : overlay::get_turn_info_linear_areal<AssignPolicy>
+{};
+
+template <typename Geometry1, typename Geometry2, typename SegmentRatio,
+          typename Tag1 = typename tag<Geometry1>::type, typename Tag2 = typename tag<Geometry2>::type,
+          typename TagBase1 = typename topological_tag_base<Geometry1>::type, typename TagBase2 = typename topological_tag_base<Geometry2>::type>
+struct turn_operation_type
+{
+    typedef overlay::turn_operation<typename point_type<Geometry1>::type, SegmentRatio> type;
+};
+
+template <typename Geometry1, typename Geometry2, typename SegmentRatio, typename Tag1, typename Tag2>
+struct turn_operation_type<Geometry1, Geometry2, SegmentRatio, Tag1, Tag2, linear_tag, linear_tag>
+{
+    typedef overlay::turn_operation_linear<typename point_type<Geometry1>::type, SegmentRatio> type;
+};
+
+template <typename Geometry1, typename Geometry2, typename SegmentRatio, typename Tag1, typename Tag2>
+struct turn_operation_type<Geometry1, Geometry2, SegmentRatio, Tag1, Tag2, linear_tag, areal_tag>
+{
+    typedef overlay::turn_operation_linear<typename point_type<Geometry1>::type, SegmentRatio> type;
+};
+
+}} // namespace detail::get_turns
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+// Because this is "detail" method, and most implementations will use "generic",
+// we take the freedom to derive it from "generic".
+template
+<
+    typename GeometryTag1, typename GeometryTag2,
+    typename Geometry1, typename Geometry2,
+    bool Reverse1, bool Reverse2,
+    typename TurnPolicy
+>
+struct get_turns
+    : detail::get_turns::get_turns_generic
+        <
+            Geometry1, Geometry2,
+            Reverse1, Reverse2,
+            TurnPolicy
+        >
+{};
+
+
+template
+<
+    typename Polygon, typename Box,
+    bool ReversePolygon, bool ReverseBox,
+    typename TurnPolicy
+>
+struct get_turns
+    <
+        polygon_tag, box_tag,
+        Polygon, Box,
+        ReversePolygon, ReverseBox,
+        TurnPolicy
+    > : detail::get_turns::get_turns_polygon_cs
+            <
+                Polygon, Box,
+                ReversePolygon, ReverseBox,
+                TurnPolicy
+            >
+{};
+
+
+template
+<
+    typename Ring, typename Box,
+    bool ReverseRing, bool ReverseBox,
+    typename TurnPolicy
+>
+struct get_turns
+    <
+        ring_tag, box_tag,
+        Ring, Box,
+        ReverseRing, ReverseBox,
+        TurnPolicy
+    > : detail::get_turns::get_turns_cs
+            <
+                Ring, Box, ReverseRing, ReverseBox,
+                TurnPolicy
+            >
+
+{};
+
+
+template
+<
+    typename MultiPolygon,
+    typename Box,
+    bool ReverseMultiPolygon, bool ReverseBox,
+    typename TurnPolicy
+>
+struct get_turns
+    <
+        multi_polygon_tag, box_tag,
+        MultiPolygon, Box,
+        ReverseMultiPolygon, ReverseBox,
+        TurnPolicy
+    >
+    : detail::get_turns::get_turns_multi_polygon_cs
+        <
+            MultiPolygon, Box,
+            ReverseMultiPolygon, ReverseBox,
+            TurnPolicy
+        >
+{};
+
+
+template
+<
+    typename GeometryTag1, typename GeometryTag2,
+    typename Geometry1, typename Geometry2,
+    bool Reverse1, bool Reverse2,
+    typename TurnPolicy
+>
+struct get_turns_reversed
+{
+    template <typename IntersectionStrategy, typename RobustPolicy, typename Turns, typename InterruptPolicy>
+    static inline void apply(int source_id1, Geometry1 const& g1,
+                             int source_id2, Geometry2 const& g2,
+                             IntersectionStrategy const& intersection_strategy,
+                             RobustPolicy const& robust_policy,
+                             Turns& turns,
+                             InterruptPolicy& interrupt_policy)
+    {
+        get_turns
+            <
+                GeometryTag2, GeometryTag1,
+                Geometry2, Geometry1,
+                Reverse2, Reverse1,
+                TurnPolicy
+            >::apply(source_id2, g2, source_id1, g1,
+                     intersection_strategy, robust_policy,
+                     turns, interrupt_policy);
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+
+/*!
+\brief \brief_calc2{turn points}
+\ingroup overlay
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Turns type of turn-container (e.g. vector of "intersection/turn point"'s)
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param intersection_strategy segments intersection strategy
+\param robust_policy policy to handle robustness issues
+\param turns container which will contain turn points
+\param interrupt_policy policy determining if process is stopped
+    when intersection is found
+ */
+template
+<
+    bool Reverse1, bool Reverse2,
+    typename AssignPolicy,
+    typename Geometry1,
+    typename Geometry2,
+    typename IntersectionStrategy,
+    typename RobustPolicy,
+    typename Turns,
+    typename InterruptPolicy
+>
+inline void get_turns(Geometry1 const& geometry1,
+                      Geometry2 const& geometry2,
+                      IntersectionStrategy const& intersection_strategy,
+                      RobustPolicy const& robust_policy,
+                      Turns& turns,
+                      InterruptPolicy& interrupt_policy)
+{
+    concepts::check_concepts_and_equal_dimensions<Geometry1 const, Geometry2 const>();
+
+    typedef detail::overlay::get_turn_info<AssignPolicy> TurnPolicy;
+    //typedef detail::get_turns::get_turn_info_type<Geometry1, Geometry2, AssignPolicy> TurnPolicy;
+
+    boost::mpl::if_c
+        <
+            reverse_dispatch<Geometry1, Geometry2>::type::value,
+            dispatch::get_turns_reversed
+            <
+                typename tag<Geometry1>::type,
+                typename tag<Geometry2>::type,
+                Geometry1, Geometry2,
+                Reverse1, Reverse2,
+                TurnPolicy
+            >,
+            dispatch::get_turns
+            <
+                typename tag<Geometry1>::type,
+                typename tag<Geometry2>::type,
+                Geometry1, Geometry2,
+                Reverse1, Reverse2,
+                TurnPolicy
+            >
+        >::type::apply(0, geometry1,
+                       1, geometry2,
+                       intersection_strategy,
+                       robust_policy,
+                       turns, interrupt_policy);
+}
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_GET_TURNS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/handle_colocations.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/handle_colocations.hpp
new file mode 100644
index 00000000000..f3311b34e9b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/handle_colocations.hpp
@@ -0,0 +1,802 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_HANDLE_COLOCATIONS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_HANDLE_COLOCATIONS_HPP
+
+#include <cstddef>
+#include <algorithm>
+#include <map>
+#include <vector>
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/range.hpp>
+#include <boost/geometry/core/point_order.hpp>
+#include <boost/geometry/algorithms/detail/overlay/cluster_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/do_reverse.hpp>
+#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
+#include <boost/geometry/algorithms/detail/overlay/sort_by_side.hpp>
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+#include <boost/geometry/algorithms/detail/ring_identifier.hpp>
+#include <boost/geometry/algorithms/detail/overlay/segment_identifier.hpp>
+
+#if defined(BOOST_GEOMETRY_DEBUG_HANDLE_COLOCATIONS)
+#  include <iostream>
+#  include <boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp>
+#  include <boost/geometry/io/wkt/wkt.hpp>
+#  define BOOST_GEOMETRY_DEBUG_IDENTIFIER
+#endif
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+template <typename SegmentRatio>
+struct segment_fraction
+{
+    segment_identifier seg_id;
+    SegmentRatio fraction;
+
+    segment_fraction(segment_identifier const& id, SegmentRatio const& fr)
+        : seg_id(id)
+        , fraction(fr)
+    {}
+
+    segment_fraction()
+    {}
+
+    bool operator<(segment_fraction<SegmentRatio> const& other) const
+    {
+        return seg_id == other.seg_id
+                ? fraction < other.fraction
+                : seg_id < other.seg_id;
+    }
+
+};
+
+struct turn_operation_index
+{
+    turn_operation_index(signed_size_type ti = -1,
+                         signed_size_type oi = -1)
+        : turn_index(ti)
+        , op_index(oi)
+    {}
+
+    signed_size_type turn_index;
+    signed_size_type op_index; // only 0,1
+};
+
+
+template <typename Turns>
+struct less_by_fraction_and_type
+{
+    inline less_by_fraction_and_type(Turns const& turns)
+        : m_turns(turns)
+    {
+    }
+
+    inline bool operator()(turn_operation_index const& left,
+                           turn_operation_index const& right) const
+    {
+        typedef typename boost::range_value<Turns>::type turn_type;
+        typedef typename turn_type::turn_operation_type turn_operation_type;
+
+        turn_type const& left_turn = m_turns[left.turn_index];
+        turn_type const& right_turn = m_turns[right.turn_index];
+        turn_operation_type const& left_op
+                = left_turn.operations[left.op_index];
+
+        turn_operation_type const& right_op
+                = right_turn.operations[right.op_index];
+
+        if (! (left_op.fraction == right_op.fraction))
+        {
+            return left_op.fraction < right_op.fraction;
+        }
+
+        // Order xx first - used to discard any following colocated turn
+        bool const left_both_xx = left_turn.both(operation_blocked);
+        bool const right_both_xx = right_turn.both(operation_blocked);
+        if (left_both_xx && ! right_both_xx)
+        {
+            return true;
+        }
+        if (! left_both_xx && right_both_xx)
+        {
+            return false;
+        }
+
+        bool const left_both_uu = left_turn.both(operation_union);
+        bool const right_both_uu = right_turn.both(operation_union);
+        if (left_both_uu && ! right_both_uu)
+        {
+            return true;
+        }
+        if (! left_both_uu && right_both_uu)
+        {
+            return false;
+        }
+
+        turn_operation_type const& left_other_op
+                = left_turn.operations[1 - left.op_index];
+
+        turn_operation_type const& right_other_op
+                = right_turn.operations[1 - right.op_index];
+
+        // Fraction is the same, now sort on ring id, first outer ring,
+        // then interior rings
+        return left_other_op.seg_id < right_other_op.seg_id;
+    }
+
+private:
+    Turns const& m_turns;
+};
+
+template <typename Operation, typename ClusterPerSegment>
+inline signed_size_type get_cluster_id(Operation const& op, ClusterPerSegment const& cluster_per_segment)
+{
+    typedef typename ClusterPerSegment::key_type segment_fraction_type;
+
+    segment_fraction_type seg_frac(op.seg_id, op.fraction);
+    typename ClusterPerSegment::const_iterator it
+            = cluster_per_segment.find(seg_frac);
+
+    if (it == cluster_per_segment.end())
+    {
+        return -1;
+    }
+    return it->second;
+}
+
+template <typename Operation, typename ClusterPerSegment>
+inline void add_cluster_id(Operation const& op,
+    ClusterPerSegment& cluster_per_segment, signed_size_type id)
+{
+    typedef typename ClusterPerSegment::key_type segment_fraction_type;
+
+    segment_fraction_type seg_frac(op.seg_id, op.fraction);
+
+    cluster_per_segment[seg_frac] = id;
+}
+
+template <typename Turn, typename ClusterPerSegment>
+inline signed_size_type add_turn_to_cluster(Turn const& turn,
+        ClusterPerSegment& cluster_per_segment, signed_size_type& cluster_id)
+{
+    signed_size_type cid0 = get_cluster_id(turn.operations[0], cluster_per_segment);
+    signed_size_type cid1 = get_cluster_id(turn.operations[1], cluster_per_segment);
+
+    if (cid0 == -1 && cid1 == -1)
+    {
+        ++cluster_id;
+        add_cluster_id(turn.operations[0], cluster_per_segment, cluster_id);
+        add_cluster_id(turn.operations[1], cluster_per_segment, cluster_id);
+        return cluster_id;
+    }
+    else if (cid0 == -1 && cid1 != -1)
+    {
+        add_cluster_id(turn.operations[0], cluster_per_segment, cid1);
+        return cid1;
+    }
+    else if (cid0 != -1 && cid1 == -1)
+    {
+        add_cluster_id(turn.operations[1], cluster_per_segment, cid0);
+        return cid0;
+    }
+    else if (cid0 == cid1)
+    {
+        // Both already added to same cluster, no action
+        return cid0;
+    }
+
+    // Both operations.seg_id/fraction were already part of any cluster, and
+    // these clusters are not the same. Merge of two clusters is necessary
+#if defined(BOOST_GEOMETRY_DEBUG_HANDLE_COLOCATIONS)
+    std::cout << " TODO: merge " << cid0 << " and " << cid1 << std::endl;
+#endif
+    return cid0;
+}
+
+template
+<
+    typename Turns,
+    typename ClusterPerSegment,
+    typename Operations,
+    typename Geometry1,
+    typename Geometry2
+>
+inline void handle_colocation_cluster(Turns& turns,
+        signed_size_type& cluster_id,
+        ClusterPerSegment& cluster_per_segment,
+        Operations const& operations,
+        Geometry1 const& /*geometry1*/, Geometry2 const& /*geometry2*/)
+{
+    typedef typename boost::range_value<Turns>::type turn_type;
+    typedef typename turn_type::turn_operation_type turn_operation_type;
+
+    std::vector<turn_operation_index>::const_iterator vit = operations.begin();
+
+    turn_operation_index ref_toi = *vit;
+    signed_size_type ref_id = -1;
+
+    for (++vit; vit != operations.end(); ++vit)
+    {
+        turn_type& ref_turn = turns[ref_toi.turn_index];
+        turn_operation_type const& ref_op
+                = ref_turn.operations[ref_toi.op_index];
+
+        turn_operation_index const& toi = *vit;
+        turn_type& turn = turns[toi.turn_index];
+        turn_operation_type const& op = turn.operations[toi.op_index];
+
+        BOOST_ASSERT(ref_op.seg_id == op.seg_id);
+
+        if (ref_op.fraction == op.fraction)
+        {
+            turn_operation_type const& other_op = turn.operations[1 - toi.op_index];
+
+            if (ref_id == -1)
+            {
+                ref_id = add_turn_to_cluster(ref_turn, cluster_per_segment, cluster_id);
+            }
+            BOOST_ASSERT(ref_id != -1);
+
+            // ref_turn (both operations) are already added to cluster,
+            // so also "op" is already added to cluster,
+            // We only need to add other_op
+            signed_size_type id = get_cluster_id(other_op, cluster_per_segment);
+            if (id != -1 && id != ref_id)
+            {
+            }
+            else if (id == -1)
+            {
+                // Add to same cluster
+                add_cluster_id(other_op, cluster_per_segment, ref_id);
+                id = ref_id;
+            }
+        }
+        else
+        {
+            // Not on same fraction on this segment
+            // assign for next
+            ref_toi = toi;
+            ref_id = -1;
+        }
+    }
+}
+
+template
+<
+    typename Turns,
+    typename Clusters,
+    typename ClusterPerSegment
+>
+inline void assign_cluster_to_turns(Turns& turns,
+        Clusters& clusters,
+        ClusterPerSegment const& cluster_per_segment)
+{
+    typedef typename boost::range_value<Turns>::type turn_type;
+    typedef typename turn_type::turn_operation_type turn_operation_type;
+    typedef typename ClusterPerSegment::key_type segment_fraction_type;
+
+    signed_size_type turn_index = 0;
+    for (typename boost::range_iterator<Turns>::type it = turns.begin();
+         it != turns.end(); ++it, ++turn_index)
+    {
+        turn_type& turn = *it;
+
+        if (turn.discarded)
+        {
+            // They were processed (to create proper map) but will not be added
+            // This might leave a cluster with only 1 turn, which will be fixed
+            // afterwards
+            continue;
+        }
+
+        for (int i = 0; i < 2; i++)
+        {
+            turn_operation_type const& op = turn.operations[i];
+            segment_fraction_type seg_frac(op.seg_id, op.fraction);
+            typename ClusterPerSegment::const_iterator it = cluster_per_segment.find(seg_frac);
+            if (it != cluster_per_segment.end())
+            {
+#if defined(BOOST_GEOMETRY_DEBUG_HANDLE_COLOCATIONS)
+                if (turn.cluster_id != -1
+                        && turn.cluster_id != it->second)
+                {
+                    std::cout << " CONFLICT " << std::endl;
+                }
+#endif
+                turn.cluster_id = it->second;
+                clusters[turn.cluster_id].turn_indices.insert(turn_index);
+            }
+        }
+    }
+}
+
+template <typename Turns, typename Clusters>
+inline void remove_clusters(Turns& turns, Clusters& clusters)
+{
+    typename Clusters::iterator it = clusters.begin();
+    while (it != clusters.end())
+    {
+        // Hold iterator and increase. We can erase cit, this keeps the
+        // iterator valid (cf The standard associative-container erase idiom)
+        typename Clusters::iterator current_it = it;
+        ++it;
+
+        std::set<signed_size_type> const& turn_indices
+                = current_it->second.turn_indices;
+        if (turn_indices.size() == 1)
+        {
+            signed_size_type const turn_index = *turn_indices.begin();
+            turns[turn_index].cluster_id = -1;
+            clusters.erase(current_it);
+        }
+    }
+}
+
+template <typename Turns, typename Clusters>
+inline void cleanup_clusters(Turns& turns, Clusters& clusters)
+{
+    // Removes discarded turns from clusters
+    for (typename Clusters::iterator mit = clusters.begin();
+         mit != clusters.end(); ++mit)
+    {
+        cluster_info& cinfo = mit->second;
+        std::set<signed_size_type>& ids = cinfo.turn_indices;
+        for (std::set<signed_size_type>::iterator sit = ids.begin();
+             sit != ids.end(); /* no increment */)
+        {
+            std::set<signed_size_type>::iterator current_it = sit;
+            ++sit;
+
+            signed_size_type const turn_index = *current_it;
+            if (turns[turn_index].discarded)
+            {
+                ids.erase(current_it);
+            }
+        }
+    }
+
+    remove_clusters(turns, clusters);
+}
+
+template <typename Turn, typename IdSet>
+inline void discard_ie_turn(Turn& turn, IdSet& ids, signed_size_type id)
+{
+    turn.discarded = true;
+    // Set cluster id to -1, but don't clear colocated flags
+    turn.cluster_id = -1;
+    // To remove it later from clusters
+    ids.insert(id);
+}
+
+template <bool Reverse>
+inline bool is_interior(segment_identifier const& seg_id)
+{
+    return Reverse ? seg_id.ring_index == -1 : seg_id.ring_index >= 0;
+}
+
+template <bool Reverse0, bool Reverse1>
+inline bool is_ie_turn(segment_identifier const& ext_seg_0,
+                       segment_identifier const& ext_seg_1,
+                       segment_identifier const& int_seg_0,
+                       segment_identifier const& other_seg_1)
+{
+    if (ext_seg_0.source_index == ext_seg_1.source_index)
+    {
+        // External turn is a self-turn, dont discard internal turn for this
+        return false;
+    }
+
+
+    // Compares two segment identifiers from two turns (external / one internal)
+
+    // From first turn [0], both are from same polygon (multi_index),
+    // one is exterior (-1), the other is interior (>= 0),
+    // and the second turn [1] handles the same ring
+
+    // For difference, where the rings are processed in reversal, all interior
+    // rings become exterior and vice versa. But also the multi property changes:
+    // rings originally from the same multi should now be considered as from
+    // different multi polygons.
+    // But this is not always the case, and at this point hard to figure out
+    // (not yet implemented, TODO)
+
+    bool const same_multi0 = ! Reverse0
+                             && ext_seg_0.multi_index == int_seg_0.multi_index;
+
+    bool const same_multi1 = ! Reverse1
+                             && ext_seg_1.multi_index == other_seg_1.multi_index;
+
+    boost::ignore_unused(same_multi1);
+
+    return same_multi0
+            && same_multi1
+            && ! is_interior<Reverse0>(ext_seg_0)
+            && is_interior<Reverse0>(int_seg_0)
+            && ext_seg_1.ring_index == other_seg_1.ring_index;
+
+    // The other way round is tested in another call
+}
+
+template
+<
+    bool Reverse0, bool Reverse1, // Reverse interpretation interior/exterior
+    overlay_type OverlayType,
+    typename Turns,
+    typename Clusters
+>
+inline void discard_interior_exterior_turns(Turns& turns, Clusters& clusters)
+{
+    typedef std::set<signed_size_type>::const_iterator set_iterator;
+    typedef typename boost::range_value<Turns>::type turn_type;
+
+    std::set<signed_size_type> ids_to_remove;
+
+    for (typename Clusters::iterator cit = clusters.begin();
+         cit != clusters.end(); ++cit)
+    {
+        cluster_info& cinfo = cit->second;
+        std::set<signed_size_type>& ids = cinfo.turn_indices;
+
+        ids_to_remove.clear();
+
+        for (set_iterator it = ids.begin(); it != ids.end(); ++it)
+        {
+            turn_type& turn = turns[*it];
+            segment_identifier const& seg_0 = turn.operations[0].seg_id;
+            segment_identifier const& seg_1 = turn.operations[1].seg_id;
+
+            if (! (turn.both(operation_union)
+                   || turn.combination(operation_union, operation_blocked)))
+            {
+                // Not a uu/ux, so cannot be colocated with a iu turn
+                continue;
+            }
+
+            for (set_iterator int_it = ids.begin(); int_it != ids.end(); ++int_it)
+            {
+                if (*it == *int_it)
+                {
+                    continue;
+                }
+
+                // Turn with, possibly, an interior ring involved
+                turn_type& int_turn = turns[*int_it];
+                segment_identifier const& int_seg_0 = int_turn.operations[0].seg_id;
+                segment_identifier const& int_seg_1 = int_turn.operations[1].seg_id;
+
+                if (is_ie_turn<Reverse0, Reverse1>(seg_0, seg_1, int_seg_0, int_seg_1))
+                {
+                    discard_ie_turn(int_turn, ids_to_remove, *int_it);
+                }
+                if (is_ie_turn<Reverse1, Reverse0>(seg_1, seg_0, int_seg_1, int_seg_0))
+                {
+                    discard_ie_turn(int_turn, ids_to_remove, *int_it);
+                }
+            }
+        }
+
+        // Erase from the ids (which cannot be done above)
+        for (set_iterator sit = ids_to_remove.begin();
+             sit != ids_to_remove.end(); ++sit)
+        {
+            ids.erase(*sit);
+        }
+    }
+}
+
+template
+<
+    typename Turns,
+    typename Clusters
+>
+inline void set_colocation(Turns& turns, Clusters const& clusters)
+{
+    typedef std::set<signed_size_type>::const_iterator set_iterator;
+    typedef typename boost::range_value<Turns>::type turn_type;
+
+    for (typename Clusters::const_iterator cit = clusters.begin();
+         cit != clusters.end(); ++cit)
+    {
+        cluster_info const& cinfo = cit->second;
+        std::set<signed_size_type> const& ids = cinfo.turn_indices;
+
+        bool has_ii = false;
+        bool has_uu = false;
+        for (set_iterator it = ids.begin(); it != ids.end(); ++it)
+        {
+            turn_type const& turn = turns[*it];
+            if (turn.both(operation_intersection))
+            {
+                has_ii = true;
+            }
+            if (turn.both(operation_union) || turn.combination(operation_union, operation_blocked))
+            {
+                has_uu = true;
+            }
+        }
+        if (has_ii || has_uu)
+        {
+            for (set_iterator it = ids.begin(); it != ids.end(); ++it)
+            {
+                turn_type& turn = turns[*it];
+                if (has_ii)
+                {
+                    turn.colocated_ii = true;
+                }
+                if (has_uu)
+                {
+                    turn.colocated_uu = true;
+                }
+            }
+        }
+    }
+}
+
+// Checks colocated turns and flags combinations of uu/other, possibly a
+// combination of a ring touching another geometry's interior ring which is
+// tangential to the exterior ring
+
+// This function can be extended to replace handle_tangencies: at each
+// colocation incoming and outgoing vectors should be inspected
+
+template
+<
+    bool Reverse1, bool Reverse2,
+    overlay_type OverlayType,
+    typename Turns,
+    typename Clusters,
+    typename Geometry1,
+    typename Geometry2
+>
+inline bool handle_colocations(Turns& turns, Clusters& clusters,
+        Geometry1 const& geometry1, Geometry2 const& geometry2)
+{
+    typedef std::map
+        <
+            segment_identifier,
+            std::vector<turn_operation_index>
+        > map_type;
+
+    // Create and fill map on segment-identifier Map is sorted on seg_id,
+    // meaning it is sorted on ring_identifier too. This means that exterior
+    // rings are handled first. If there is a colocation on the exterior ring,
+    // that information can be used for the interior ring too
+    map_type map;
+
+    int index = 0;
+    for (typename boost::range_iterator<Turns>::type
+            it = boost::begin(turns);
+         it != boost::end(turns);
+         ++it, ++index)
+    {
+        map[it->operations[0].seg_id].push_back(turn_operation_index(index, 0));
+        map[it->operations[1].seg_id].push_back(turn_operation_index(index, 1));
+    }
+
+    // Check if there are multiple turns on one or more segments,
+    // if not then nothing is to be done
+    bool colocations = 0;
+    for (typename map_type::const_iterator it = map.begin();
+         it != map.end();
+         ++it)
+    {
+        if (it->second.size() > 1u)
+        {
+            colocations = true;
+            break;
+        }
+    }
+
+    if (! colocations)
+    {
+        return false;
+    }
+
+    // Sort all vectors, per same segment
+    less_by_fraction_and_type<Turns> less(turns);
+    for (typename map_type::iterator it = map.begin();
+         it != map.end(); ++it)
+    {
+        std::sort(it->second.begin(), it->second.end(), less);
+    }
+
+    typedef typename boost::range_value<Turns>::type turn_type;
+    typedef typename turn_type::segment_ratio_type segment_ratio_type;
+
+    typedef std::map
+        <
+            segment_fraction<segment_ratio_type>,
+            signed_size_type
+        > cluster_per_segment_type;
+
+    cluster_per_segment_type cluster_per_segment;
+    signed_size_type cluster_id = 0;
+
+    for (typename map_type::const_iterator it = map.begin();
+         it != map.end(); ++it)
+    {
+        if (it->second.size() > 1u)
+        {
+            handle_colocation_cluster(turns, cluster_id, cluster_per_segment,
+                it->second, geometry1, geometry2);
+        }
+    }
+
+    assign_cluster_to_turns(turns, clusters, cluster_per_segment);
+    set_colocation(turns, clusters);
+    discard_interior_exterior_turns
+        <
+            do_reverse<geometry::point_order<Geometry1>::value>::value != Reverse1,
+            do_reverse<geometry::point_order<Geometry2>::value>::value != Reverse2,
+            OverlayType
+        >(turns, clusters);
+
+#if defined(BOOST_GEOMETRY_DEBUG_HANDLE_COLOCATIONS)
+    std::cout << "*** Colocations " << map.size() << std::endl;
+    for (typename map_type::const_iterator it = map.begin();
+         it != map.end(); ++it)
+    {
+        std::cout << it->first << std::endl;
+        for (std::vector<turn_operation_index>::const_iterator vit
+             = it->second.begin(); vit != it->second.end(); ++vit)
+        {
+            turn_operation_index const& toi = *vit;
+            std::cout << geometry::wkt(turns[toi.turn_index].point)
+                << std::boolalpha
+                << " discarded=" << turns[toi.turn_index].discarded
+                << " colocated(uu)=" << turns[toi.turn_index].colocated_uu
+                << " colocated(ii)=" << turns[toi.turn_index].colocated_ii
+                << " " << operation_char(turns[toi.turn_index].operations[0].operation)
+                << " "  << turns[toi.turn_index].operations[0].seg_id
+                << " "  << turns[toi.turn_index].operations[0].fraction
+                << " // " << operation_char(turns[toi.turn_index].operations[1].operation)
+                << " "  << turns[toi.turn_index].operations[1].seg_id
+                << " "  << turns[toi.turn_index].operations[1].fraction
+                << std::endl;
+        }
+    }
+#endif // DEBUG
+
+    return true;
+}
+
+
+struct is_turn_index
+{
+    is_turn_index(signed_size_type index)
+        : m_index(index)
+    {}
+
+    template <typename Indexed>
+    inline bool operator()(Indexed const& indexed) const
+    {
+        // Indexed is a indexed_turn_operation<Operation>
+        return indexed.turn_index == m_index;
+    }
+
+    std::size_t m_index;
+};
+
+
+template
+<
+    bool Reverse1, bool Reverse2,
+    overlay_type OverlayType,
+    typename Turns,
+    typename Clusters,
+    typename Geometry1,
+    typename Geometry2,
+    typename SideStrategy
+>
+inline void gather_cluster_properties(Clusters& clusters, Turns& turns,
+        operation_type for_operation,
+        Geometry1 const& geometry1, Geometry2 const& geometry2,
+        SideStrategy const& strategy)
+{
+    typedef typename boost::range_value<Turns>::type turn_type;
+    typedef typename turn_type::point_type point_type;
+    typedef typename turn_type::turn_operation_type turn_operation_type;
+
+    // Define sorter, sorting counter-clockwise such that polygons are on the
+    // right side
+    typedef sort_by_side::side_sorter
+        <
+            Reverse1, Reverse2, OverlayType, point_type, SideStrategy, std::less<int>
+        > sbs_type;
+
+    for (typename Clusters::iterator mit = clusters.begin();
+         mit != clusters.end(); ++mit)
+    {
+        cluster_info& cinfo = mit->second;
+        std::set<signed_size_type> const& ids = cinfo.turn_indices;
+        if (ids.empty())
+        {
+            continue;
+        }
+
+        sbs_type sbs(strategy);
+        point_type turn_point; // should be all the same for all turns in cluster
+
+        bool first = true;
+        for (std::set<signed_size_type>::const_iterator sit = ids.begin();
+             sit != ids.end(); ++sit)
+        {
+            signed_size_type turn_index = *sit;
+            turn_type const& turn = turns[turn_index];
+            if (first)
+            {
+                turn_point = turn.point;
+            }
+            for (int i = 0; i < 2; i++)
+            {
+                turn_operation_type const& op = turn.operations[i];
+                sbs.add(op, turn_index, i, geometry1, geometry2, first);
+                first = false;
+            }
+        }
+        sbs.apply(turn_point);
+
+        sbs.find_open();
+        sbs.assign_zones(for_operation);
+
+        cinfo.open_count = sbs.open_count(for_operation);
+
+        // Unset the startable flag for all 'closed' zones
+        for (std::size_t i = 0; i < sbs.m_ranked_points.size(); i++)
+        {
+            const typename sbs_type::rp& ranked = sbs.m_ranked_points[i];
+            turn_type& turn = turns[ranked.turn_index];
+            turn_operation_type& op = turn.operations[ranked.operation_index];
+
+            if (for_operation == operation_union && cinfo.open_count == 0)
+            {
+                op.enriched.startable = false;
+            }
+
+            if (ranked.direction != sort_by_side::dir_to)
+            {
+                continue;
+            }
+
+            op.enriched.count_left = ranked.count_left;
+            op.enriched.count_right = ranked.count_right;
+            op.enriched.rank = ranked.rank;
+            op.enriched.zone = ranked.zone;
+
+            if ((for_operation == operation_union
+                    && ranked.count_left != 0)
+             || (for_operation == operation_intersection
+                    && ranked.count_right != 2))
+            {
+                op.enriched.startable = false;
+            }
+        }
+
+    }
+}
+
+
+}} // namespace detail::overlay
+#endif //DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_HANDLE_COLOCATIONS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/handle_self_turns.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/handle_self_turns.hpp
new file mode 100644
index 00000000000..39c55db7593
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/handle_self_turns.hpp
@@ -0,0 +1,143 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2017 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_HANDLE_SELF_TURNS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_HANDLE_SELF_TURNS_HPP
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/is_self_turn.hpp>
+#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
+#include <boost/geometry/algorithms/within.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+struct discard_turns
+{
+    template <typename Turns, typename Geometry0, typename Geometry1>
+    static inline
+    void apply(Turns& , Geometry0 const& , Geometry1 const& )
+    {}
+};
+
+template <overlay_type OverlayType, operation_type OperationType>
+struct discard_closed_turns : discard_turns {};
+
+// It is only implemented for operation_union, not in buffer
+template <>
+struct discard_closed_turns<overlay_union, operation_union>
+{
+
+    template <typename Turns, typename Geometry0, typename Geometry1>
+    static inline
+    void apply(Turns& turns,
+            Geometry0 const& geometry0, Geometry1 const& geometry1)
+    {
+        typedef typename boost::range_value<Turns>::type turn_type;
+
+        for (typename boost::range_iterator<Turns>::type
+                it = boost::begin(turns);
+             it != boost::end(turns);
+             ++it)
+        {
+            turn_type& turn = *it;
+
+            if (turn.cluster_id >= 0
+                    || turn.discarded
+                    || ! is_self_turn<overlay_union>(turn))
+            {
+                continue;
+            }
+
+            bool const within =
+                    turn.operations[0].seg_id.source_index == 0
+                    ? geometry::within(turn.point, geometry1)
+                    : geometry::within(turn.point, geometry0);
+
+            if (within)
+            {
+                // It is in the interior of the other geometry
+                turn.discarded = true;
+            }
+        }
+    }
+};
+
+struct discard_self_intersection_turns
+{
+    template <typename Turns, typename Geometry0, typename Geometry1>
+    static inline
+    void apply(Turns& turns,
+            Geometry0 const& geometry0, Geometry1 const& geometry1)
+    {
+        typedef typename boost::range_value<Turns>::type turn_type;
+
+        for (typename boost::range_iterator<Turns>::type
+                it = boost::begin(turns);
+             it != boost::end(turns);
+             ++it)
+        {
+            turn_type& turn = *it;
+
+            if (turn.cluster_id >= 0
+                    || turn.discarded
+                    || ! is_self_turn<overlay_intersection>(turn))
+            {
+                continue;
+            }
+
+            segment_identifier const& id0 = turn.operations[0].seg_id;
+            segment_identifier const& id1 = turn.operations[1].seg_id;
+            if (id0.multi_index != id1.multi_index
+                    || (id0.ring_index == -1 && id1.ring_index == -1)
+                    || (id0.ring_index >= 0 && id1.ring_index >= 0))
+            {
+                // Not an ii ring (int/ext) on same ring
+                continue;
+            }
+
+            // It is a non co-located ii self-turn
+            // Check if it is within the other geometry
+            // If not, it can be ignored
+
+            bool const within =
+                    turn.operations[0].seg_id.source_index == 0
+                    ? geometry::within(turn.point, geometry1)
+                    : geometry::within(turn.point, geometry0);
+
+            if (! within)
+            {
+                // It is not within another geometry, discard the turn
+                turn.discarded = true;
+            }
+        }
+    }
+};
+
+template <overlay_type OverlayType, operation_type OperationType>
+struct discard_open_turns : discard_turns {};
+
+// Handler it for intersection
+template <>
+struct discard_open_turns<overlay_intersection, operation_intersection>
+        : discard_self_intersection_turns {};
+
+// For difference, it should be done in a different way (TODO)
+
+}} // namespace detail::overlay
+#endif //DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_HANDLE_SELF_TURNS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/inconsistent_turns_exception.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/inconsistent_turns_exception.hpp
new file mode 100644
index 00000000000..1486f94fbd2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/inconsistent_turns_exception.hpp
@@ -0,0 +1,38 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2015, Oracle and/or its affiliates.
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_INCONSISTENT_TURNS_EXCEPTION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_INCONSISTENT_TURNS_EXCEPTION_HPP
+
+#if ! defined(BOOST_GEOMETRY_OVERLAY_NO_THROW)
+#include <boost/geometry/core/exception.hpp>
+
+namespace boost { namespace geometry
+{
+
+class inconsistent_turns_exception : public geometry::exception
+{
+public:
+
+    inline inconsistent_turns_exception() {}
+
+    virtual ~inconsistent_turns_exception() throw()
+    {}
+
+    virtual char const* what() const throw()
+    {
+        return "Boost.Geometry Inconsistent Turns exception";
+    }
+};
+
+}} // boost::geometry
+
+#endif // BOOST_GEOMETRY_OVERLAY_NO_THROW
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_INCONSISTENT_TURNS_EXCEPTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/intersection_box_box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/intersection_box_box.hpp
new file mode 100644
index 00000000000..c62b7d2834a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/intersection_box_box.hpp
@@ -0,0 +1,96 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_INTERSECTION_BOX_BOX_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_INTERSECTION_BOX_BOX_HPP
+
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace intersection
+{
+
+template <std::size_t Dimension, std::size_t DimensionCount>
+struct intersection_box_box
+{
+    template
+    <
+        typename Box1, typename Box2,
+        typename RobustPolicy,
+        typename BoxOut,
+        typename Strategy
+    >
+    static inline bool apply(Box1 const& box1,
+            Box2 const& box2,
+            RobustPolicy const& robust_policy,
+            BoxOut& box_out,
+            Strategy const& strategy)
+    {
+        typedef typename coordinate_type<BoxOut>::type ct;
+
+        ct max1 = get<max_corner, Dimension>(box1);
+        ct min2 = get<min_corner, Dimension>(box2);
+
+        if (max1 < min2)
+        {
+            return false;
+        }
+
+        ct max2 = get<max_corner, Dimension>(box2);
+        ct min1 = get<min_corner, Dimension>(box1);
+
+        if (max2 < min1)
+        {
+            return false;
+        }
+
+        // Set dimensions of output coordinate
+        set<min_corner, Dimension>(box_out, min1 < min2 ? min2 : min1);
+        set<max_corner, Dimension>(box_out, max1 > max2 ? max2 : max1);
+        
+        return intersection_box_box<Dimension + 1, DimensionCount>
+               ::apply(box1, box2, robust_policy, box_out, strategy);
+    }
+};
+
+template <std::size_t DimensionCount>
+struct intersection_box_box<DimensionCount, DimensionCount>
+{
+    template
+    <
+        typename Box1, typename Box2,
+        typename RobustPolicy,
+        typename BoxOut,
+        typename Strategy
+    >
+    static inline bool apply(Box1 const&, Box2 const&,
+            RobustPolicy const&, BoxOut&, Strategy const&)
+    {
+        return true;
+    }
+};
+
+
+}} // namespace detail::intersection
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_INTERSECTION_BOX_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/intersection_insert.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/intersection_insert.hpp
new file mode 100644
index 00000000000..7106e7b480f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/intersection_insert.hpp
@@ -0,0 +1,1087 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014, 2015, 2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_INTERSECTION_INSERT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_INTERSECTION_INSERT_HPP
+
+
+#include <cstddef>
+
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/range/metafunctions.hpp>
+
+
+#include <boost/geometry/core/is_areal.hpp>
+#include <boost/geometry/core/point_order.hpp>
+#include <boost/geometry/core/reverse_dispatch.hpp>
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/algorithms/convert.hpp>
+#include <boost/geometry/algorithms/detail/point_on_border.hpp>
+#include <boost/geometry/algorithms/detail/overlay/clip_linestring.hpp>
+#include <boost/geometry/algorithms/detail/overlay/follow.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_intersection_points.hpp>
+#include <boost/geometry/algorithms/detail/overlay/overlay.hpp>
+#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
+#include <boost/geometry/algorithms/detail/overlay/range_in_geometry.hpp>
+
+#include <boost/geometry/policies/robustness/robust_point_type.hpp>
+#include <boost/geometry/policies/robustness/segment_ratio_type.hpp>
+#include <boost/geometry/policies/robustness/get_rescale_policy.hpp>
+
+#include <boost/geometry/views/segment_view.hpp>
+#include <boost/geometry/views/detail/boundary_view.hpp>
+
+#include <boost/geometry/algorithms/detail/check_iterator_range.hpp>
+#include <boost/geometry/algorithms/detail/overlay/linear_linear.hpp>
+#include <boost/geometry/algorithms/detail/overlay/pointlike_pointlike.hpp>
+#include <boost/geometry/algorithms/detail/overlay/pointlike_linear.hpp>
+
+#if defined(BOOST_GEOMETRY_DEBUG_FOLLOW)
+#include <boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp>
+#include <boost/geometry/io/wkt/wkt.hpp>
+#endif
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace intersection
+{
+
+template <typename PointOut>
+struct intersection_segment_segment_point
+{
+    template
+    <
+        typename Segment1, typename Segment2,
+        typename RobustPolicy,
+        typename OutputIterator, typename Strategy
+    >
+    static inline OutputIterator apply(Segment1 const& segment1,
+            Segment2 const& segment2,
+            RobustPolicy const& robust_policy,
+            OutputIterator out,
+            Strategy const& strategy)
+    {
+        typedef typename point_type<PointOut>::type point_type;
+
+        typedef typename geometry::robust_point_type
+            <
+                typename geometry::point_type<Segment1>::type,
+                RobustPolicy
+            >::type robust_point_type;
+
+        // TODO: rescale segment -> robust points
+        robust_point_type pi_rob, pj_rob, qi_rob, qj_rob;
+        {
+            // Workaround:
+            point_type pi, pj, qi, qj;
+            assign_point_from_index<0>(segment1, pi);
+            assign_point_from_index<1>(segment1, pj);
+            assign_point_from_index<0>(segment2, qi);
+            assign_point_from_index<1>(segment2, qj);
+            geometry::recalculate(pi_rob, pi, robust_policy);
+            geometry::recalculate(pj_rob, pj, robust_policy);
+            geometry::recalculate(qi_rob, qi, robust_policy);
+            geometry::recalculate(qj_rob, qj, robust_policy);
+        }
+
+        // Get the intersection point (or two points)
+        typedef segment_intersection_points
+                <
+                    point_type,
+                    typename segment_ratio_type
+                    <
+                        point_type, RobustPolicy
+                    >::type
+                > intersection_return_type;
+
+        typedef policies::relate::segments_intersection_points
+            <
+                intersection_return_type
+            > policy_type;
+
+        intersection_return_type
+            is = strategy.apply(segment1, segment2,
+                                policy_type(), robust_policy,
+                                pi_rob, pj_rob, qi_rob, qj_rob);
+
+        for (std::size_t i = 0; i < is.count; i++)
+        {
+            PointOut p;
+            geometry::convert(is.intersections[i], p);
+            *out++ = p;
+        }
+        return out;
+    }
+};
+
+template <typename PointOut>
+struct intersection_linestring_linestring_point
+{
+    template
+    <
+        typename Linestring1, typename Linestring2,
+        typename RobustPolicy,
+        typename OutputIterator,
+        typename Strategy
+    >
+    static inline OutputIterator apply(Linestring1 const& linestring1,
+            Linestring2 const& linestring2,
+            RobustPolicy const& robust_policy,
+            OutputIterator out,
+            Strategy const& strategy)
+    {
+        typedef typename point_type<PointOut>::type point_type;
+
+        typedef detail::overlay::turn_info
+            <
+                point_type,
+                typename segment_ratio_type<point_type, RobustPolicy>::type
+            > turn_info;
+        std::deque<turn_info> turns;
+
+        geometry::get_intersection_points(linestring1, linestring2,
+                                          robust_policy, turns, strategy);
+
+        for (typename boost::range_iterator<std::deque<turn_info> const>::type
+            it = boost::begin(turns); it != boost::end(turns); ++it)
+        {
+            PointOut p;
+            geometry::convert(it->point, p);
+            *out++ = p;
+        }
+        return out;
+    }
+};
+
+/*!
+\brief Version of linestring with an areal feature (polygon or multipolygon)
+*/
+template
+<
+    bool ReverseAreal,
+    typename LineStringOut,
+    overlay_type OverlayType
+>
+struct intersection_of_linestring_with_areal
+{
+#if defined(BOOST_GEOMETRY_DEBUG_FOLLOW)
+    template <typename Turn, typename Operation>
+    static inline void debug_follow(Turn const& turn, Operation op,
+                                    int index)
+    {
+        std::cout << index
+                  << " at " << op.seg_id
+                  << " meth: " << method_char(turn.method)
+                  << " op: " << operation_char(op.operation)
+                  << " vis: " << visited_char(op.visited)
+                  << " of:  " << operation_char(turn.operations[0].operation)
+                  << operation_char(turn.operations[1].operation)
+                  << " " << geometry::wkt(turn.point)
+                  << std::endl;
+    }
+
+    template <typename Turn>
+    static inline void debug_turn(Turn const& t, bool non_crossing)
+    {
+        std::cout << "checking turn @"
+                  << geometry::wkt(t.point)
+                  << "; " << method_char(t.method)
+                  << ":" << operation_char(t.operations[0].operation)
+                  << "/" << operation_char(t.operations[1].operation)
+                  << "; non-crossing? "
+                  << std::boolalpha << non_crossing << std::noboolalpha
+                  << std::endl;
+    }
+#endif
+
+    class is_crossing_turn
+    {
+        // return true is the operation is intersection or blocked
+        template <std::size_t Index, typename Turn>
+        static inline bool has_op_i_or_b(Turn const& t)
+        {
+            return
+                t.operations[Index].operation == overlay::operation_intersection
+                ||
+                t.operations[Index].operation == overlay::operation_blocked;
+        }
+
+        template <typename Turn>
+        static inline bool has_method_crosses(Turn const& t)
+        {
+            return t.method == overlay::method_crosses;
+        }
+
+        template <typename Turn>
+        static inline bool is_cc(Turn const& t)
+        {
+            return
+                (t.method == overlay::method_touch_interior
+                 ||
+                 t.method == overlay::method_equal
+                 ||
+                 t.method == overlay::method_collinear)
+                &&
+                t.operations[0].operation == t.operations[1].operation
+                &&
+                t.operations[0].operation == overlay::operation_continue
+                ;
+        }
+
+        template <typename Turn>
+        static inline bool has_i_or_b_ops(Turn const& t)
+        {
+            return
+                (t.method == overlay::method_touch
+                 ||
+                 t.method == overlay::method_touch_interior
+                 ||
+                 t.method == overlay::method_collinear)
+                &&
+                t.operations[1].operation != t.operations[0].operation
+                &&
+                (has_op_i_or_b<0>(t) || has_op_i_or_b<1>(t));
+        }
+
+    public:
+        template <typename Turn>
+        static inline bool apply(Turn const& t)
+        {
+            bool const is_crossing
+                = has_method_crosses(t) || is_cc(t) || has_i_or_b_ops(t);
+#if defined(BOOST_GEOMETRY_DEBUG_FOLLOW)
+            debug_turn(t, ! is_crossing);
+#endif
+            return is_crossing;
+        }
+    };
+
+    struct is_non_crossing_turn
+    {
+        template <typename Turn>
+        static inline bool apply(Turn const& t)
+        {
+            return ! is_crossing_turn::apply(t);
+        }
+    };
+
+    template <typename Turns>
+    static inline bool no_crossing_turns_or_empty(Turns const& turns)
+    {
+        return detail::check_iterator_range
+            <
+                is_non_crossing_turn,
+                true // allow an empty turns range
+            >::apply(boost::begin(turns), boost::end(turns));
+    }
+
+    template <typename Turns>
+    static inline int inside_or_outside_turn(Turns const& turns)
+    {
+        using namespace overlay;
+        for (typename Turns::const_iterator it = turns.begin();
+                it != turns.end(); ++it)
+        {
+            operation_type op0 = it->operations[0].operation;
+            operation_type op1 = it->operations[1].operation;
+            if (op0 == operation_intersection && op1 == operation_intersection)
+            {
+                return 1; // inside
+            }
+            else if (op0 == operation_union && op1 == operation_union)
+            {
+                return -1; // outside
+            }
+        }
+        return 0;
+    }
+
+    template
+    <
+        typename LineString, typename Areal,
+        typename RobustPolicy,
+        typename OutputIterator, typename Strategy
+    >
+    static inline OutputIterator apply(LineString const& linestring, Areal const& areal,
+            RobustPolicy const& robust_policy,
+            OutputIterator out,
+            Strategy const& strategy)
+    {
+        if (boost::size(linestring) == 0)
+        {
+            return out;
+        }
+
+        typedef detail::overlay::follow
+                <
+                    LineStringOut,
+                    LineString,
+                    Areal,
+                    OverlayType,
+                    false // do not remove spikes for linear geometries
+                > follower;
+
+        typedef typename point_type<LineStringOut>::type point_type;
+        typedef detail::overlay::traversal_turn_info
+        <
+            point_type,
+            typename geometry::segment_ratio_type<point_type, RobustPolicy>::type
+        > turn_info;
+        std::deque<turn_info> turns;
+
+        detail::get_turns::no_interrupt_policy policy;
+        geometry::get_turns
+            <
+                false,
+                (OverlayType == overlay_intersection ? ReverseAreal : !ReverseAreal),
+                detail::overlay::assign_null_policy
+            >(linestring, areal, strategy, robust_policy, turns, policy);
+
+        if (no_crossing_turns_or_empty(turns))
+        {
+            // No intersection points, it is either
+            // inside (interior + borders)
+            // or outside (exterior + borders)
+
+            // analyse the turns
+            int inside_value = inside_or_outside_turn(turns);            
+            if (inside_value == 0)
+            {
+                // if needed analyse points of a linestring
+                // NOTE: range_in_geometry checks points of a linestring
+                // until a point inside/outside areal is found
+                inside_value = overlay::range_in_geometry(linestring, areal, strategy);
+            }
+            // add point to the output if conditions are met
+            if (inside_value != 0 && follower::included(inside_value))
+            {
+                LineStringOut copy;
+                geometry::convert(linestring, copy);
+                *out++ = copy;
+            }
+            return out;
+        }
+
+#if defined(BOOST_GEOMETRY_DEBUG_FOLLOW)
+        int index = 0;
+        for(typename std::deque<turn_info>::const_iterator
+            it = turns.begin(); it != turns.end(); ++it)
+        {
+            debug_follow(*it, it->operations[0], index++);
+        }
+#endif
+
+        return follower::apply
+                (
+                    linestring, areal,
+                    geometry::detail::overlay::operation_intersection,
+                    turns, robust_policy, out, strategy
+                );
+    }
+};
+
+
+}} // namespace detail::intersection
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    // real types
+    typename Geometry1,
+    typename Geometry2,
+    typename GeometryOut,
+    overlay_type OverlayType,
+    // orientation
+    bool Reverse1 = detail::overlay::do_reverse<geometry::point_order<Geometry1>::value>::value,
+    bool Reverse2 = detail::overlay::do_reverse<geometry::point_order<Geometry2>::value>::value,
+    bool ReverseOut = detail::overlay::do_reverse<geometry::point_order<GeometryOut>::value>::value,
+    // tag dispatching:
+    typename TagIn1 = typename geometry::tag<Geometry1>::type,
+    typename TagIn2 = typename geometry::tag<Geometry2>::type,
+    typename TagOut = typename geometry::tag<GeometryOut>::type,
+    // metafunction finetuning helpers:
+    bool Areal1 = geometry::is_areal<Geometry1>::value,
+    bool Areal2 = geometry::is_areal<Geometry2>::value,
+    bool ArealOut = geometry::is_areal<GeometryOut>::value
+>
+struct intersection_insert
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_OR_NOT_YET_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPES_OR_ORIENTATIONS
+            , (types<Geometry1, Geometry2, GeometryOut>)
+        );
+};
+
+
+template
+<
+    typename Geometry1, typename Geometry2,
+    typename GeometryOut,
+    overlay_type OverlayType,
+    bool Reverse1, bool Reverse2, bool ReverseOut,
+    typename TagIn1, typename TagIn2, typename TagOut
+>
+struct intersection_insert
+    <
+        Geometry1, Geometry2,
+        GeometryOut,
+        OverlayType,
+        Reverse1, Reverse2, ReverseOut,
+        TagIn1, TagIn2, TagOut,
+        true, true, true
+    > : detail::overlay::overlay
+        <Geometry1, Geometry2, Reverse1, Reverse2, ReverseOut, GeometryOut, OverlayType>
+{};
+
+
+// Any areal type with box:
+template
+<
+    typename Geometry, typename Box,
+    typename GeometryOut,
+    overlay_type OverlayType,
+    bool Reverse1, bool Reverse2, bool ReverseOut,
+    typename TagIn, typename TagOut
+>
+struct intersection_insert
+    <
+        Geometry, Box,
+        GeometryOut,
+        OverlayType,
+        Reverse1, Reverse2, ReverseOut,
+        TagIn, box_tag, TagOut,
+        true, true, true
+    > : detail::overlay::overlay
+        <Geometry, Box, Reverse1, Reverse2, ReverseOut, GeometryOut, OverlayType>
+{};
+
+
+template
+<
+    typename Segment1, typename Segment2,
+    typename GeometryOut,
+    overlay_type OverlayType,
+    bool Reverse1, bool Reverse2, bool ReverseOut
+>
+struct intersection_insert
+    <
+        Segment1, Segment2,
+        GeometryOut,
+        OverlayType,
+        Reverse1, Reverse2, ReverseOut,
+        segment_tag, segment_tag, point_tag,
+        false, false, false
+    > : detail::intersection::intersection_segment_segment_point<GeometryOut>
+{};
+
+
+template
+<
+    typename Linestring1, typename Linestring2,
+    typename GeometryOut,
+    overlay_type OverlayType,
+    bool Reverse1, bool Reverse2, bool ReverseOut
+>
+struct intersection_insert
+    <
+        Linestring1, Linestring2,
+        GeometryOut,
+        OverlayType,
+        Reverse1, Reverse2, ReverseOut,
+        linestring_tag, linestring_tag, point_tag,
+        false, false, false
+    > : detail::intersection::intersection_linestring_linestring_point<GeometryOut>
+{};
+
+
+template
+<
+    typename Linestring, typename Box,
+    typename GeometryOut,
+    bool Reverse1, bool Reverse2, bool ReverseOut
+>
+struct intersection_insert
+    <
+        Linestring, Box,
+        GeometryOut,
+        overlay_intersection,
+        Reverse1, Reverse2, ReverseOut,
+        linestring_tag, box_tag, linestring_tag,
+        false, true, false
+    >
+{
+    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(Linestring const& linestring,
+            Box const& box,
+            RobustPolicy const& robust_policy,
+            OutputIterator out, Strategy const& )
+    {
+        typedef typename point_type<GeometryOut>::type point_type;
+        strategy::intersection::liang_barsky<Box, point_type> lb_strategy;
+        return detail::intersection::clip_range_with_box
+            <GeometryOut>(box, linestring, robust_policy, out, lb_strategy);
+    }
+};
+
+
+template
+<
+    typename Linestring, typename Polygon,
+    typename GeometryOut,
+    overlay_type OverlayType,
+    bool ReverseLinestring, bool ReversePolygon, bool ReverseOut
+>
+struct intersection_insert
+    <
+        Linestring, Polygon,
+        GeometryOut,
+        OverlayType,
+        ReverseLinestring, ReversePolygon, ReverseOut,
+        linestring_tag, polygon_tag, linestring_tag,
+        false, true, false
+    > : detail::intersection::intersection_of_linestring_with_areal
+            <
+                ReversePolygon,
+                GeometryOut,
+                OverlayType
+            >
+{};
+
+
+template
+<
+    typename Linestring, typename Ring,
+    typename GeometryOut,
+    overlay_type OverlayType,
+    bool ReverseLinestring, bool ReverseRing, bool ReverseOut
+>
+struct intersection_insert
+    <
+        Linestring, Ring,
+        GeometryOut,
+        OverlayType,
+        ReverseLinestring, ReverseRing, ReverseOut,
+        linestring_tag, ring_tag, linestring_tag,
+        false, true, false
+    > : detail::intersection::intersection_of_linestring_with_areal
+            <
+                ReverseRing,
+                GeometryOut,
+                OverlayType
+            >
+{};
+
+template
+<
+    typename Segment, typename Box,
+    typename GeometryOut,
+    overlay_type OverlayType,
+    bool Reverse1, bool Reverse2, bool ReverseOut
+>
+struct intersection_insert
+    <
+        Segment, Box,
+        GeometryOut,
+        OverlayType,
+        Reverse1, Reverse2, ReverseOut,
+        segment_tag, box_tag, linestring_tag,
+        false, true, false
+    >
+{
+    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(Segment const& segment,
+            Box const& box,
+            RobustPolicy const& robust_policy,
+            OutputIterator out, Strategy const& )
+    {
+        geometry::segment_view<Segment> range(segment);
+
+        typedef typename point_type<GeometryOut>::type point_type;
+        strategy::intersection::liang_barsky<Box, point_type> lb_strategy;
+        return detail::intersection::clip_range_with_box
+            <GeometryOut>(box, range, robust_policy, out, lb_strategy);
+    }
+};
+
+template
+<
+    typename Geometry1, typename Geometry2,
+    typename PointOut,
+    overlay_type OverlayType,
+    bool Reverse1, bool Reverse2, bool ReverseOut,
+    typename Tag1, typename Tag2,
+    bool Areal1, bool Areal2
+>
+struct intersection_insert
+    <
+        Geometry1, Geometry2,
+        PointOut,
+        OverlayType,
+        Reverse1, Reverse2, ReverseOut,
+        Tag1, Tag2, point_tag,
+        Areal1, Areal2, false
+    >
+{
+    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(Geometry1 const& geometry1,
+            Geometry2 const& geometry2,
+            RobustPolicy const& robust_policy,
+            OutputIterator out, Strategy const& strategy)
+    {
+
+        typedef detail::overlay::turn_info
+            <
+                PointOut,
+                typename segment_ratio_type<PointOut, RobustPolicy>::type
+            > turn_info;
+        std::vector<turn_info> turns;
+
+        detail::get_turns::no_interrupt_policy policy;
+        geometry::get_turns
+            <
+                false, false, detail::overlay::assign_null_policy
+            >(geometry1, geometry2, strategy, robust_policy, turns, policy);
+        for (typename std::vector<turn_info>::const_iterator it
+            = turns.begin(); it != turns.end(); ++it)
+        {
+            *out++ = it->point;
+        }
+
+        return out;
+    }
+};
+
+
+template
+<
+    typename Geometry1, typename Geometry2, typename GeometryOut,
+    overlay_type OverlayType,
+    bool Reverse1, bool Reverse2, bool ReverseOut
+>
+struct intersection_insert_reversed
+{
+    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(Geometry1 const& g1,
+                Geometry2 const& g2,
+                RobustPolicy const& robust_policy,
+                OutputIterator out,
+                Strategy const& strategy)
+    {
+        return intersection_insert
+            <
+                Geometry2, Geometry1, GeometryOut,
+                OverlayType,
+                Reverse2, Reverse1, ReverseOut
+            >::apply(g2, g1, robust_policy, out, strategy);
+    }
+};
+
+
+// dispatch for intersection(areal, areal, linear)
+template
+<
+    typename Geometry1, typename Geometry2,
+    typename LinestringOut,
+    bool Reverse1, bool Reverse2, bool ReverseOut,
+    typename Tag1, typename Tag2
+>
+struct intersection_insert
+    <
+        Geometry1, Geometry2,
+        LinestringOut,
+        overlay_intersection,
+        Reverse1, Reverse2, ReverseOut,
+        Tag1, Tag2, linestring_tag,
+        true, true, false
+    >
+{
+    template
+    <
+        typename RobustPolicy, typename OutputIterator, typename Strategy
+    >
+    static inline OutputIterator apply(Geometry1 const& geometry1,
+                                       Geometry2 const& geometry2,
+                                       RobustPolicy const& robust_policy,
+                                       OutputIterator oit,
+                                       Strategy const& strategy)
+    {
+        detail::boundary_view<Geometry1 const> view1(geometry1);
+        detail::boundary_view<Geometry2 const> view2(geometry2);
+
+        return detail::overlay::linear_linear_linestring
+            <
+                detail::boundary_view<Geometry1 const>,
+                detail::boundary_view<Geometry2 const>,
+                LinestringOut,
+                overlay_intersection
+            >::apply(view1, view2, robust_policy, oit, strategy);
+    }
+};
+
+// dispatch for non-areal geometries
+template
+<
+    typename Geometry1, typename Geometry2, typename GeometryOut,
+    overlay_type OverlayType,
+    bool Reverse1, bool Reverse2, bool ReverseOut,
+    typename TagIn1, typename TagIn2
+>
+struct intersection_insert
+    <
+        Geometry1, Geometry2, GeometryOut,
+        OverlayType,
+        Reverse1, Reverse2, ReverseOut,
+        TagIn1, TagIn2, linestring_tag,
+        false, false, false
+    > : intersection_insert
+        <
+           Geometry1, Geometry2, GeometryOut,
+           OverlayType,
+           Reverse1, Reverse2, ReverseOut,
+           typename tag_cast<TagIn1, pointlike_tag, linear_tag>::type,
+           typename tag_cast<TagIn2, pointlike_tag, linear_tag>::type,
+           linestring_tag,
+           false, false, false
+        >
+{};
+
+
+// dispatch for difference/intersection of linear geometries
+template
+<
+    typename Linear1, typename Linear2, typename LineStringOut,
+    overlay_type OverlayType,
+    bool Reverse1, bool Reverse2, bool ReverseOut
+>
+struct intersection_insert
+    <
+        Linear1, Linear2, LineStringOut, OverlayType,
+        Reverse1, Reverse2, ReverseOut,
+        linear_tag, linear_tag, linestring_tag,
+        false, false, false
+    > : detail::overlay::linear_linear_linestring
+        <
+            Linear1, Linear2, LineStringOut, OverlayType
+        >
+{};
+
+
+// dispatch for difference/intersection of point-like geometries
+
+template
+<
+    typename Point1, typename Point2, typename PointOut,
+    overlay_type OverlayType,
+    bool Reverse1, bool Reverse2, bool ReverseOut
+>
+struct intersection_insert
+    <
+        Point1, Point2, PointOut, OverlayType,
+        Reverse1, Reverse2, ReverseOut,
+        point_tag, point_tag, point_tag,
+        false, false, false
+    > : detail::overlay::point_point_point
+        <
+            Point1, Point2, PointOut, OverlayType
+        >
+{};
+
+
+template
+<
+    typename MultiPoint, typename Point, typename PointOut,
+    overlay_type OverlayType,
+    bool Reverse1, bool Reverse2, bool ReverseOut
+>
+struct intersection_insert
+    <
+        MultiPoint, Point, PointOut, OverlayType,
+        Reverse1, Reverse2, ReverseOut,
+        multi_point_tag, point_tag, point_tag,
+        false, false, false
+    > : detail::overlay::multipoint_point_point
+        <
+            MultiPoint, Point, PointOut, OverlayType
+        >
+{};
+
+
+template
+<
+    typename Point, typename MultiPoint, typename PointOut,
+    overlay_type OverlayType,
+    bool Reverse1, bool Reverse2, bool ReverseOut
+>
+struct intersection_insert
+    <
+        Point, MultiPoint, PointOut, OverlayType,
+        Reverse1, Reverse2, ReverseOut,
+        point_tag, multi_point_tag, point_tag,
+        false, false, false
+    > : detail::overlay::point_multipoint_point
+        <
+            Point, MultiPoint, PointOut, OverlayType
+        >
+{};
+
+
+template
+<
+    typename MultiPoint1, typename MultiPoint2, typename PointOut,
+    overlay_type OverlayType,
+    bool Reverse1, bool Reverse2, bool ReverseOut
+>
+struct intersection_insert
+    <
+        MultiPoint1, MultiPoint2, PointOut, OverlayType,
+        Reverse1, Reverse2, ReverseOut,
+        multi_point_tag, multi_point_tag, point_tag,
+        false, false, false
+    > : detail::overlay::multipoint_multipoint_point
+        <
+            MultiPoint1, MultiPoint2, PointOut, OverlayType
+        >
+{};
+
+
+// dispatch for difference/intersection of pointlike-linear geometries
+template
+<
+    typename Point, typename Linear, typename PointOut,
+    overlay_type OverlayType,
+    bool Reverse1, bool Reverse2, bool ReverseOut,
+    typename Tag
+>
+struct intersection_insert
+    <
+        Point, Linear, PointOut, OverlayType,
+        Reverse1, Reverse2, ReverseOut,
+        point_tag, Tag, point_tag,
+        false, false, false
+    > : detail_dispatch::overlay::pointlike_linear_point
+        <
+            Point, Linear, PointOut, OverlayType,
+            point_tag, typename tag_cast<Tag, segment_tag, linear_tag>::type
+        >
+{};
+
+
+template
+<
+    typename MultiPoint, typename Linear, typename PointOut,
+    overlay_type OverlayType,
+    bool Reverse1, bool Reverse2, bool ReverseOut,
+    typename Tag
+>
+struct intersection_insert
+    <
+        MultiPoint, Linear, PointOut, OverlayType,
+        Reverse1, Reverse2, ReverseOut,
+        multi_point_tag, Tag, point_tag,
+        false, false, false
+    > : detail_dispatch::overlay::pointlike_linear_point
+        <
+            MultiPoint, Linear, PointOut, OverlayType,
+            multi_point_tag,
+            typename tag_cast<Tag, segment_tag, linear_tag>::type
+        >
+{};
+
+
+template
+<
+    typename Linestring, typename MultiPoint, typename PointOut,
+    bool Reverse1, bool Reverse2, bool ReverseOut
+>
+struct intersection_insert
+    <
+        Linestring, MultiPoint, PointOut, overlay_intersection,
+        Reverse1, Reverse2, ReverseOut,
+        linestring_tag, multi_point_tag, point_tag,
+        false, false, false
+    >
+{
+    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(Linestring const& linestring,
+                                       MultiPoint const& multipoint,
+                                       RobustPolicy const& robust_policy,
+                                       OutputIterator out,
+                                       Strategy const& strategy)
+    {
+        return detail_dispatch::overlay::pointlike_linear_point
+            <
+                MultiPoint, Linestring, PointOut, overlay_intersection,
+                multi_point_tag, linear_tag
+            >::apply(multipoint, linestring, robust_policy, out, strategy);
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace intersection
+{
+
+
+template
+<
+    typename GeometryOut,
+    bool ReverseSecond,
+    overlay_type OverlayType,
+    typename Geometry1, typename Geometry2,
+    typename RobustPolicy,
+    typename OutputIterator,
+    typename Strategy
+>
+inline OutputIterator insert(Geometry1 const& geometry1,
+            Geometry2 const& geometry2,
+            RobustPolicy robust_policy,
+            OutputIterator out,
+            Strategy const& strategy)
+{
+    return boost::mpl::if_c
+    <
+        geometry::reverse_dispatch<Geometry1, Geometry2>::type::value,
+        geometry::dispatch::intersection_insert_reversed
+        <
+            Geometry1, Geometry2,
+            GeometryOut,
+            OverlayType,
+            overlay::do_reverse<geometry::point_order<Geometry1>::value>::value,
+            overlay::do_reverse<geometry::point_order<Geometry2>::value, ReverseSecond>::value,
+            overlay::do_reverse<geometry::point_order<GeometryOut>::value>::value
+        >,
+        geometry::dispatch::intersection_insert
+        <
+            Geometry1, Geometry2,
+            GeometryOut,
+            OverlayType,
+            geometry::detail::overlay::do_reverse<geometry::point_order<Geometry1>::value>::value,
+            geometry::detail::overlay::do_reverse<geometry::point_order<Geometry2>::value, ReverseSecond>::value
+        >
+    >::type::apply(geometry1, geometry2, robust_policy, out, strategy);
+}
+
+
+/*!
+\brief \brief_calc2{intersection} \brief_strategy
+\ingroup intersection
+\details \details_calc2{intersection_insert, spatial set theoretic intersection}
+    \brief_strategy. \details_insert{intersection}
+\tparam GeometryOut \tparam_geometry{\p_l_or_c}
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam OutputIterator \tparam_out{\p_l_or_c}
+\tparam Strategy \tparam_strategy_overlay
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param out \param_out{intersection}
+\param strategy \param_strategy{intersection}
+\return \return_out
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/intersection.qbk]}
+*/
+template
+<
+    typename GeometryOut,
+    typename Geometry1,
+    typename Geometry2,
+    typename OutputIterator,
+    typename Strategy
+>
+inline OutputIterator intersection_insert(Geometry1 const& geometry1,
+            Geometry2 const& geometry2,
+            OutputIterator out,
+            Strategy const& strategy)
+{
+    concepts::check<Geometry1 const>();
+    concepts::check<Geometry2 const>();
+
+    typedef typename geometry::rescale_policy_type
+        <
+            typename geometry::point_type<Geometry1>::type // TODO from both
+        >::type rescale_policy_type;
+
+    rescale_policy_type robust_policy
+            = geometry::get_rescale_policy<rescale_policy_type>(geometry1, geometry2);
+
+    return detail::intersection::insert
+        <
+            GeometryOut, false, overlay_intersection
+        >(geometry1, geometry2, robust_policy, out, strategy);
+}
+
+
+/*!
+\brief \brief_calc2{intersection}
+\ingroup intersection
+\details \details_calc2{intersection_insert, spatial set theoretic intersection}.
+    \details_insert{intersection}
+\tparam GeometryOut \tparam_geometry{\p_l_or_c}
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam OutputIterator \tparam_out{\p_l_or_c}
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param out \param_out{intersection}
+\return \return_out
+
+\qbk{[include reference/algorithms/intersection.qbk]}
+*/
+template
+<
+    typename GeometryOut,
+    typename Geometry1,
+    typename Geometry2,
+    typename OutputIterator
+>
+inline OutputIterator intersection_insert(Geometry1 const& geometry1,
+            Geometry2 const& geometry2,
+            OutputIterator out)
+{
+    concepts::check<Geometry1 const>();
+    concepts::check<Geometry2 const>();
+
+    typedef typename strategy::intersection::services::default_strategy
+        <
+            typename cs_tag<GeometryOut>::type
+        >::type strategy_type;
+    
+    return intersection_insert<GeometryOut>(geometry1, geometry2, out,
+                                            strategy_type());
+}
+
+}} // namespace detail::intersection
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_INTERSECTION_INSERT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/is_self_turn.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/is_self_turn.hpp
new file mode 100644
index 00000000000..9cb7a0fca98
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/is_self_turn.hpp
@@ -0,0 +1,68 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2017-2017 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_IS_SELF_TURN_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_IS_SELF_TURN_HPP
+
+#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+template <overlay_type OverlayType>
+struct is_self_turn_check
+{
+    template <typename Turn>
+    static inline bool apply(Turn const& turn)
+    {
+        return turn.operations[0].seg_id.source_index
+                == turn.operations[1].seg_id.source_index;
+    }
+};
+
+template <>
+struct is_self_turn_check<overlay_buffer>
+{
+    template <typename Turn>
+    static inline bool apply(Turn const& turn)
+    {
+        return false;
+    }
+};
+
+template <>
+struct is_self_turn_check<overlay_dissolve>
+{
+    template <typename Turn>
+    static inline bool apply(Turn const& turn)
+    {
+        return false;
+    }
+};
+
+
+template <overlay_type OverlayType, typename Turn>
+bool is_self_turn(Turn const& turn)
+{
+    return is_self_turn_check<OverlayType>::apply(turn);
+}
+
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_IS_SELF_TURN_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/less_by_segment_ratio.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/less_by_segment_ratio.hpp
new file mode 100644
index 00000000000..dd30635ee27
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/less_by_segment_ratio.hpp
@@ -0,0 +1,207 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SORT_ON_SEGMENT_RATIO_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SORT_ON_SEGMENT_RATIO_HPP
+
+#include <cstddef>
+#include <algorithm>
+#include <map>
+#include <set>
+#include <vector>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/copy_segment_point.hpp>
+#include <boost/geometry/algorithms/detail/overlay/sort_by_side.hpp>
+#include <boost/geometry/strategies/side.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+// Wraps "turn_operation" from turn_info.hpp,
+// giving it extra information, necessary for sorting
+template <typename TurnOperation>
+struct indexed_turn_operation
+{
+    typedef TurnOperation type;
+
+    std::size_t turn_index;
+    std::size_t operation_index;
+    bool skip;
+    // use pointers to avoid copies, const& is not possible because of usage in vector
+    segment_identifier const* other_seg_id; // segment id of other segment of intersection of two segments
+    TurnOperation const* subject;
+
+    inline indexed_turn_operation(std::size_t ti, std::size_t oi,
+                TurnOperation const& sub,
+                segment_identifier const& oid)
+        : turn_index(ti)
+        , operation_index(oi)
+        , skip(false)
+        , other_seg_id(&oid)
+        , subject(boost::addressof(sub))
+    {}
+
+};
+
+template
+<
+    typename Turns,
+    typename Indexed,
+    typename Geometry1, typename Geometry2,
+    typename RobustPolicy,
+    typename SideStrategy,
+    bool Reverse1, bool Reverse2
+>
+struct less_by_segment_ratio
+{
+    inline less_by_segment_ratio(Turns const& turns
+            , operation_type for_operation
+            , Geometry1 const& geometry1
+            , Geometry2 const& geometry2
+            , RobustPolicy const& robust_policy
+            , SideStrategy const& strategy)
+        : m_turns(turns)
+        , m_for_operation(for_operation)
+        , m_geometry1(geometry1)
+        , m_geometry2(geometry2)
+        , m_robust_policy(robust_policy)
+        , m_strategy(strategy)
+    {
+    }
+
+private :
+
+    Turns const& m_turns;
+    operation_type m_for_operation;
+    Geometry1 const& m_geometry1;
+    Geometry2 const& m_geometry2;
+    RobustPolicy const& m_robust_policy;
+    SideStrategy const& m_strategy;
+
+    typedef typename geometry::point_type<Geometry1>::type point_type;
+
+    inline bool default_order(Indexed const& left, Indexed const& right) const
+    {
+        // We've nothing to sort on. Take the indexes
+        return left.turn_index < right.turn_index;
+    }
+
+    inline bool consider_relative_order(Indexed const& left,
+                    Indexed const& right) const
+    {
+        point_type pi, pj, ri, rj, si, sj;
+
+        geometry::copy_segment_points<Reverse1, Reverse2>(m_geometry1, m_geometry2,
+            left.subject->seg_id,
+            pi, pj);
+        geometry::copy_segment_points<Reverse1, Reverse2>(m_geometry1, m_geometry2,
+            *left.other_seg_id,
+            ri, rj);
+        geometry::copy_segment_points<Reverse1, Reverse2>(m_geometry1, m_geometry2,
+            *right.other_seg_id,
+            si, sj);
+
+        int const side_rj_p = m_strategy.apply(pi, pj, rj);
+        int const side_sj_p = m_strategy.apply(pi, pj, sj);
+
+        // Put the one turning left (1; right == -1) as last
+        if (side_rj_p != side_sj_p)
+        {
+            return side_rj_p < side_sj_p;
+        }
+
+        int const side_sj_r = m_strategy.apply(ri, rj, sj);
+        int const side_rj_s = m_strategy.apply(si, sj, rj);
+
+        // If they both turn left: the most left as last
+        // If they both turn right: this is not relevant, but take also here most left
+        if (side_rj_s != side_sj_r)
+        {
+            return side_rj_s < side_sj_r;
+        }
+
+        return default_order(left, right);
+    }
+
+
+public :
+
+    // Note that left/right do NOT correspond to m_geometry1/m_geometry2
+    // but to the "indexed_turn_operation"
+    inline bool operator()(Indexed const& left, Indexed const& right) const
+    {
+        if (! (left.subject->seg_id == right.subject->seg_id))
+        {
+            return left.subject->seg_id < right.subject->seg_id;
+        }
+
+        // Both left and right are located on the SAME segment.
+
+        if (! (left.subject->fraction == right.subject->fraction))
+        {
+            return left.subject->fraction < right.subject->fraction;
+        }
+
+
+        typedef typename boost::range_value<Turns>::type turn_type;
+        turn_type const& left_turn = m_turns[left.turn_index];
+        turn_type const& right_turn = m_turns[right.turn_index];
+
+        // First check "real" intersection (crosses)
+        // -> distance zero due to precision, solve it by sorting
+        if (left_turn.method == method_crosses
+            && right_turn.method == method_crosses)
+        {
+            return consider_relative_order(left, right);
+        }
+
+        bool const left_both_xx = left_turn.both(operation_blocked);
+        bool const right_both_xx = right_turn.both(operation_blocked);
+        if (left_both_xx && ! right_both_xx)
+        {
+            return true;
+        }
+        if (! left_both_xx && right_both_xx)
+        {
+            return false;
+        }
+
+        bool const left_both_uu = left_turn.both(operation_union);
+        bool const right_both_uu = right_turn.both(operation_union);
+        if (left_both_uu && ! right_both_uu)
+        {
+            return true;
+        }
+        if (! left_both_uu && right_both_uu)
+        {
+            return false;
+        }
+
+        return default_order(left, right);
+    }
+};
+
+
+}} // namespace detail::overlay
+#endif //DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SORT_ON_SEGMENT_RATIO_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/linear_linear.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/linear_linear.hpp
new file mode 100644
index 00000000000..21d079d95c9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/linear_linear.hpp
@@ -0,0 +1,344 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_LINEAR_LINEAR_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_LINEAR_LINEAR_HPP
+
+#include <algorithm>
+#include <vector>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/detail/relate/turns.hpp>
+
+#include <boost/geometry/algorithms/detail/turns/compare_turns.hpp>
+#include <boost/geometry/algorithms/detail/turns/filter_continue_turns.hpp>
+#include <boost/geometry/algorithms/detail/turns/remove_duplicate_turns.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
+#include <boost/geometry/algorithms/detail/overlay/follow_linear_linear.hpp>
+
+#include <boost/geometry/algorithms/convert.hpp>
+
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+template
+<
+    typename LineStringOut,
+    overlay_type OverlayType,
+    typename Geometry,
+    typename GeometryTag
+>
+struct linear_linear_no_intersections;
+
+
+template <typename LineStringOut, typename LineString>
+struct linear_linear_no_intersections
+    <
+        LineStringOut, overlay_difference, LineString, linestring_tag
+    >
+{
+    template <typename OutputIterator>
+    static inline OutputIterator apply(LineString const& linestring,
+                                       OutputIterator oit)
+    {
+        LineStringOut ls_out;
+        geometry::convert(linestring, ls_out);
+        *oit++ = ls_out;
+        return oit;
+    }
+};
+
+
+template <typename LineStringOut, typename MultiLineString>
+struct linear_linear_no_intersections
+    <
+        LineStringOut,
+        overlay_difference,
+        MultiLineString,
+        multi_linestring_tag
+    >
+{
+    template <typename OutputIterator>
+    static inline OutputIterator apply(MultiLineString const& multilinestring,
+                                       OutputIterator oit)
+    {
+        for (typename boost::range_iterator<MultiLineString const>::type
+                 it = boost::begin(multilinestring);
+             it != boost::end(multilinestring); ++it)
+        {
+            LineStringOut ls_out;
+            geometry::convert(*it, ls_out);
+            *oit++ = ls_out;
+        }
+        return oit;
+    }
+};
+
+
+template <typename LineStringOut, typename Geometry, typename GeometryTag>
+struct linear_linear_no_intersections
+    <
+        LineStringOut, overlay_intersection, Geometry, GeometryTag
+    >
+{
+    template <typename OutputIterator>
+    static inline OutputIterator apply(Geometry const&,
+                                       OutputIterator oit)
+    {
+        return oit;
+    }
+};
+
+
+
+
+
+
+
+template
+<
+    typename Linear1,
+    typename Linear2,
+    typename LinestringOut,
+    overlay_type OverlayType,
+    bool EnableFilterContinueTurns = false,
+    bool EnableRemoveDuplicateTurns = false,
+    bool EnableDegenerateTurns = true,
+#ifdef BOOST_GEOMETRY_INTERSECTION_DO_NOT_INCLUDE_ISOLATED_POINTS
+    bool EnableFollowIsolatedPoints = false
+#else
+    bool EnableFollowIsolatedPoints = true
+#endif
+>
+class linear_linear_linestring
+{
+protected:
+    struct assign_policy
+    {
+        static bool const include_no_turn = false;
+        static bool const include_degenerate = EnableDegenerateTurns;
+        static bool const include_opposite = false;
+
+        template
+        <
+            typename Info,
+            typename Point1,
+            typename Point2,
+            typename IntersectionInfo
+        >
+        static inline void apply(Info& , Point1 const& , Point2 const& ,
+                                 IntersectionInfo const& )
+        {
+        }
+    };
+
+
+    template
+    <
+        typename Turns,
+        typename LinearGeometry1,
+        typename LinearGeometry2,
+        typename IntersectionStrategy,
+        typename RobustPolicy
+    >
+    static inline void compute_turns(Turns& turns,
+                                     LinearGeometry1 const& linear1,
+                                     LinearGeometry2 const& linear2,
+                                     IntersectionStrategy const& strategy,
+                                     RobustPolicy const& robust_policy)
+    {
+        turns.clear();
+
+        detail::get_turns::no_interrupt_policy interrupt_policy;
+
+        geometry::detail::relate::turns::get_turns
+            <
+                LinearGeometry1,
+                LinearGeometry2,
+                detail::get_turns::get_turn_info_type
+                <
+                    LinearGeometry1,
+                    LinearGeometry2,
+                    assign_policy
+                >,
+                RobustPolicy
+            >::apply(turns, linear1, linear2, interrupt_policy, strategy, robust_policy);
+    }
+
+
+    template
+    <
+        overlay_type OverlayTypeForFollow,
+        bool FollowIsolatedPoints,
+        typename Turns,
+        typename LinearGeometry1,
+        typename LinearGeometry2,
+        typename OutputIterator,
+        typename IntersectionStrategy
+    >
+    static inline OutputIterator
+    sort_and_follow_turns(Turns& turns,
+                          LinearGeometry1 const& linear1,
+                          LinearGeometry2 const& linear2,
+                          OutputIterator oit,
+                          IntersectionStrategy const& strategy)
+    {
+        // remove turns that have no added value
+        turns::filter_continue_turns
+            <
+                Turns,
+                EnableFilterContinueTurns && OverlayType != overlay_intersection
+            >::apply(turns);
+
+        // sort by seg_id, distance, and operation
+        std::sort(boost::begin(turns), boost::end(turns),
+                  detail::turns::less_seg_fraction_other_op<>());
+
+        // remove duplicate turns
+        turns::remove_duplicate_turns
+            <
+                Turns, EnableRemoveDuplicateTurns
+            >::apply(turns);
+
+        return detail::overlay::following::linear::follow
+            <
+                LinestringOut,
+                LinearGeometry1,
+                LinearGeometry2,
+                OverlayTypeForFollow,
+                FollowIsolatedPoints,
+                !EnableFilterContinueTurns || OverlayType == overlay_intersection
+            >::apply(linear1, linear2, boost::begin(turns), boost::end(turns),
+                     oit, strategy.get_side_strategy());
+    }
+
+public:
+    template
+    <
+        typename RobustPolicy, typename OutputIterator, typename Strategy
+    >
+    static inline OutputIterator apply(Linear1 const& linear1,
+                                       Linear2 const& linear2,
+                                       RobustPolicy const& robust_policy,
+                                       OutputIterator oit,
+                                       Strategy const& strategy)
+    {
+        typedef typename detail::relate::turns::get_turns
+            <
+                Linear1,
+                Linear2,
+                detail::get_turns::get_turn_info_type
+                <
+                    Linear1,
+                    Linear2,
+                    assign_policy
+                >,
+                RobustPolicy
+            >::turn_info turn_info;
+
+        typedef std::vector<turn_info> turns_container;
+
+        turns_container turns;
+        compute_turns(turns, linear1, linear2, strategy, robust_policy);
+
+        if ( turns.empty() )
+        {
+            // the two linear geometries are disjoint
+            return linear_linear_no_intersections
+                <
+                    LinestringOut,
+                    OverlayType,
+                    Linear1,
+                    typename tag<Linear1>::type
+                >::apply(linear1, oit);
+        }
+
+        return sort_and_follow_turns
+            <
+                OverlayType,
+                EnableFollowIsolatedPoints
+                && OverlayType == overlay_intersection
+            >(turns, linear1, linear2, oit, strategy);
+    }
+};
+
+
+
+
+template
+<
+    typename Linear1,
+    typename Linear2,
+    typename LinestringOut,
+    bool EnableFilterContinueTurns,
+    bool EnableRemoveDuplicateTurns,
+    bool EnableDegenerateTurns,
+    bool EnableFollowIsolatedPoints
+>
+struct linear_linear_linestring
+    <
+        Linear1, Linear2, LinestringOut, overlay_union,
+        EnableFilterContinueTurns, EnableRemoveDuplicateTurns,
+        EnableDegenerateTurns, EnableFollowIsolatedPoints
+    >
+{
+    template
+    <
+        typename RobustPolicy, typename OutputIterator, typename Strategy
+    >
+    static inline OutputIterator apply(Linear1 const& linear1,
+                                       Linear2 const& linear2,
+                                       RobustPolicy const& robust_policy,
+                                       OutputIterator oit,
+                                       Strategy const& strategy)
+    {
+        oit = linear_linear_no_intersections
+            <
+                LinestringOut,
+                overlay_difference,
+                Linear1,
+                typename tag<Linear1>::type
+            >::apply(linear1, oit);
+
+        return linear_linear_linestring
+            <
+                Linear2, Linear1, LinestringOut, overlay_difference,
+                EnableFilterContinueTurns, EnableRemoveDuplicateTurns,
+                EnableDegenerateTurns, EnableFollowIsolatedPoints
+            >::apply(linear2, linear1, robust_policy, oit, strategy);
+    }
+};
+
+
+
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_LINEAR_LINEAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/overlay.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/overlay.hpp
new file mode 100644
index 00000000000..10829abd4f0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/overlay.hpp
@@ -0,0 +1,407 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2013-2015 Adam Wulkiewicz, Lodz, Poland
+
+// This file was modified by Oracle on 2015, 2017.
+// Modifications copyright (c) 2015-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_OVERLAY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_OVERLAY_HPP
+
+
+#include <deque>
+#include <map>
+
+#include <boost/range.hpp>
+#include <boost/mpl/assert.hpp>
+
+
+#include <boost/geometry/algorithms/detail/overlay/cluster_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/enrich_intersection_points.hpp>
+#include <boost/geometry/algorithms/detail/overlay/enrichment_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_turns.hpp>
+#include <boost/geometry/algorithms/detail/overlay/is_self_turn.hpp>
+#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
+#include <boost/geometry/algorithms/detail/overlay/traverse.hpp>
+#include <boost/geometry/algorithms/detail/overlay/traversal_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/self_turn_points.hpp>
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+
+#include <boost/geometry/algorithms/detail/recalculate.hpp>
+
+#include <boost/geometry/algorithms/is_empty.hpp>
+#include <boost/geometry/algorithms/reverse.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/add_rings.hpp>
+#include <boost/geometry/algorithms/detail/overlay/assign_parents.hpp>
+#include <boost/geometry/algorithms/detail/overlay/ring_properties.hpp>
+#include <boost/geometry/algorithms/detail/overlay/select_rings.hpp>
+#include <boost/geometry/algorithms/detail/overlay/do_reverse.hpp>
+
+#include <boost/geometry/policies/robustness/segment_ratio_type.hpp>
+
+
+#ifdef BOOST_GEOMETRY_DEBUG_ASSEMBLE
+#  include <boost/geometry/io/dsv/write.hpp>
+#endif
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+//! Default visitor for overlay, doing nothing
+struct overlay_null_visitor
+{
+    void print(char const* ) {}
+
+    template <typename Turns>
+    void print(char const* , Turns const& , int) {}
+
+    template <typename Turns>
+    void print(char const* , Turns const& , int , int ) {}
+
+    template <typename Turns>
+    void visit_turns(int , Turns const& ) {}
+
+    template <typename Clusters, typename Turns>
+    void visit_clusters(Clusters const& , Turns const& ) {}
+
+    template <typename Turns, typename Turn, typename Operation>
+    void visit_traverse(Turns const& , Turn const& , Operation const& , char const*)
+    {}
+
+    template <typename Turns, typename Turn, typename Operation>
+    void visit_traverse_reject(Turns const& , Turn const& , Operation const& , traverse_error_type )
+    {}
+};
+
+template
+<
+    overlay_type OverlayType,
+    typename TurnInfoMap,
+    typename Turns,
+    typename Clusters
+>
+inline void get_ring_turn_info(TurnInfoMap& turn_info_map, Turns const& turns, Clusters const& clusters)
+{
+    typedef typename boost::range_value<Turns>::type turn_type;
+    typedef typename turn_type::container_type container_type;
+
+    static const operation_type target_operation
+            = operation_from_overlay<OverlayType>::value;
+    static const operation_type opposite_operation
+            = target_operation == operation_union ? operation_intersection : operation_union;
+
+    signed_size_type turn_index = 0;
+    for (typename boost::range_iterator<Turns const>::type
+            it = boost::begin(turns);
+         it != boost::end(turns);
+         ++it, turn_index++)
+    {
+        typename boost::range_value<Turns>::type const& turn = *it;
+
+        bool const colocated_target = target_operation == operation_union
+                ? turn.colocated_uu : turn.colocated_ii;
+        bool const colocated_opp = target_operation == operation_union
+                ? turn.colocated_ii : turn.colocated_uu;
+        bool const both_opposite = turn.both(opposite_operation);
+
+        bool const traversed
+                = turn.operations[0].visited.finalized()
+                || turn.operations[0].visited.rejected()
+                || turn.operations[1].visited.finalized()
+                || turn.operations[1].visited.rejected()
+                || turn.both(operation_blocked)
+                || turn.combination(opposite_operation, operation_blocked);
+
+        bool is_closed = false;
+        if (turn.cluster_id >= 0 && target_operation == operation_union)
+        {
+            typename Clusters::const_iterator mit = clusters.find(turn.cluster_id);
+            BOOST_ASSERT(mit != clusters.end());
+
+            cluster_info const& cinfo = mit->second;
+            is_closed = cinfo.open_count == 0;
+        }
+
+        for (typename boost::range_iterator<container_type const>::type
+                op_it = boost::begin(turn.operations);
+            op_it != boost::end(turn.operations);
+            ++op_it)
+        {
+            ring_identifier const ring_id
+                (
+                    op_it->seg_id.source_index,
+                    op_it->seg_id.multi_index,
+                    op_it->seg_id.ring_index
+                );
+
+            if (traversed || is_closed || ! op_it->enriched.startable)
+            {
+                turn_info_map[ring_id].has_traversed_turn = true;
+            }
+            else if (both_opposite && colocated_target)
+            {
+                // For union: ii, colocated with a uu
+                // For example, two interior rings touch where two exterior rings also touch.
+                // The interior rings are not yet traversed, and should be taken from the input
+
+                // For intersection: uu, colocated with an ii
+                // unless it is two interior inner rings colocated with a uu
+
+                // So don't set has_traversed_turn here
+            }
+            else if (both_opposite && ! is_self_turn<OverlayType>(turn))
+            {
+                // For union, mark any ring with a ii turn as traversed
+                // For intersection, any uu - but not if it is a self-turn
+                turn_info_map[ring_id].has_traversed_turn = true;
+            }
+            else if (colocated_opp && ! colocated_target)
+            {
+                // For union, a turn colocated with ii and NOT with uu/ux
+                // For intersection v.v.
+                turn_info_map[ring_id].has_traversed_turn = true;
+            }
+        }
+    }
+}
+
+
+template
+<
+    typename GeometryOut, overlay_type OverlayType, bool ReverseOut,
+    typename Geometry1, typename Geometry2,
+    typename OutputIterator, typename Strategy
+>
+inline OutputIterator return_if_one_input_is_empty(Geometry1 const& geometry1,
+            Geometry2 const& geometry2,
+            OutputIterator out, Strategy const& strategy)
+{
+    typedef std::deque
+        <
+            typename geometry::ring_type<GeometryOut>::type
+        > ring_container_type;
+
+    typedef typename geometry::point_type<Geometry1>::type point_type1;
+
+    typedef ring_properties
+        <
+            point_type1,
+            typename Strategy::template area_strategy
+                <
+                    point_type1
+                >::type::return_type
+        > properties;
+
+// Silence warning C4127: conditional expression is constant
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4127)
+#endif
+
+    // Union: return either of them
+    // Intersection: return nothing
+    // Difference: return first of them
+    if (OverlayType == overlay_intersection
+        || (OverlayType == overlay_difference && geometry::is_empty(geometry1)))
+    {
+        return out;
+    }
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+
+    std::map<ring_identifier, ring_turn_info> empty;
+    std::map<ring_identifier, properties> all_of_one_of_them;
+
+    select_rings<OverlayType>(geometry1, geometry2, empty, all_of_one_of_them, strategy);
+    ring_container_type rings;
+    assign_parents(geometry1, geometry2, rings, all_of_one_of_them, strategy);
+    return add_rings<GeometryOut>(all_of_one_of_them, geometry1, geometry2, rings, out);
+}
+
+
+template
+<
+    typename Geometry1, typename Geometry2,
+    bool Reverse1, bool Reverse2, bool ReverseOut,
+    typename GeometryOut,
+    overlay_type OverlayType
+>
+struct overlay
+{
+    template <typename RobustPolicy, typename OutputIterator, typename Strategy, typename Visitor>
+    static inline OutputIterator apply(
+                Geometry1 const& geometry1, Geometry2 const& geometry2,
+                RobustPolicy const& robust_policy,
+                OutputIterator out,
+                Strategy const& strategy,
+                Visitor& visitor)
+    {
+        bool const is_empty1 = geometry::is_empty(geometry1);
+        bool const is_empty2 = geometry::is_empty(geometry2);
+
+        if (is_empty1 && is_empty2)
+        {
+            return out;
+        }
+
+        if (is_empty1 || is_empty2)
+        {
+            return return_if_one_input_is_empty
+                <
+                    GeometryOut, OverlayType, ReverseOut
+                >(geometry1, geometry2, out, strategy);
+        }
+
+        typedef typename geometry::point_type<GeometryOut>::type point_type;
+        typedef detail::overlay::traversal_turn_info
+        <
+            point_type,
+            typename geometry::segment_ratio_type<point_type, RobustPolicy>::type
+        > turn_info;
+        typedef std::deque<turn_info> turn_container_type;
+
+        typedef std::deque
+            <
+                typename geometry::ring_type<GeometryOut>::type
+            > ring_container_type;
+
+        // Define the clusters, mapping cluster_id -> turns
+        typedef std::map
+            <
+                signed_size_type,
+                cluster_info
+            > cluster_type;
+
+        turn_container_type turns;
+
+#ifdef BOOST_GEOMETRY_DEBUG_ASSEMBLE
+std::cout << "get turns" << std::endl;
+#endif
+        detail::get_turns::no_interrupt_policy policy;
+        geometry::get_turns
+            <
+                Reverse1, Reverse2,
+                detail::overlay::assign_null_policy
+            >(geometry1, geometry2, strategy, robust_policy, turns, policy);
+
+        visitor.visit_turns(1, turns);
+
+#ifdef BOOST_GEOMETRY_INCLUDE_SELF_TURNS
+        {
+            self_get_turn_points::self_turns<Reverse1, assign_null_policy>(geometry1,
+                strategy, robust_policy, turns, policy, 0);
+            self_get_turn_points::self_turns<Reverse2, assign_null_policy>(geometry2,
+                strategy, robust_policy, turns, policy, 1);
+        }
+#endif
+
+
+#ifdef BOOST_GEOMETRY_DEBUG_ASSEMBLE
+std::cout << "enrich" << std::endl;
+#endif
+        typename Strategy::side_strategy_type side_strategy = strategy.get_side_strategy();
+        cluster_type clusters;
+
+        geometry::enrich_intersection_points<Reverse1, Reverse2, OverlayType>(turns,
+                clusters, geometry1, geometry2,
+                    robust_policy,
+                    side_strategy);
+
+        visitor.visit_turns(2, turns);
+
+        visitor.visit_clusters(clusters, turns);
+
+#ifdef BOOST_GEOMETRY_DEBUG_ASSEMBLE
+std::cout << "traverse" << std::endl;
+#endif
+        // Traverse through intersection/turn points and create rings of them.
+        // Note that these rings are always in clockwise order, even in CCW polygons,
+        // and are marked as "to be reversed" below
+        ring_container_type rings;
+        traverse<Reverse1, Reverse2, Geometry1, Geometry2, OverlayType>::apply
+                (
+                    geometry1, geometry2,
+                    strategy,
+                    robust_policy,
+                    turns, rings,
+                    clusters,
+                    visitor
+                );
+
+        std::map<ring_identifier, ring_turn_info> turn_info_per_ring;
+        get_ring_turn_info<OverlayType>(turn_info_per_ring, turns, clusters);
+
+        typedef typename Strategy::template area_strategy<point_type>::type area_strategy_type;
+
+        typedef ring_properties
+            <
+                point_type,
+                typename area_strategy_type::return_type
+            > properties;
+
+        // Select all rings which are NOT touched by any intersection point
+        std::map<ring_identifier, properties> selected_ring_properties;
+        select_rings<OverlayType>(geometry1, geometry2, turn_info_per_ring,
+                selected_ring_properties, strategy);
+
+        // Add rings created during traversal
+        {
+            area_strategy_type const area_strategy = strategy.template get_area_strategy<point_type>();
+
+            ring_identifier id(2, 0, -1);
+            for (typename boost::range_iterator<ring_container_type>::type
+                    it = boost::begin(rings);
+                 it != boost::end(rings);
+                 ++it)
+            {
+                selected_ring_properties[id] = properties(*it, area_strategy);
+                selected_ring_properties[id].reversed = ReverseOut;
+                id.multi_index++;
+            }
+        }
+
+        assign_parents(geometry1, geometry2, rings, selected_ring_properties, strategy);
+
+        return add_rings<GeometryOut>(selected_ring_properties, geometry1, geometry2, rings, out);
+    }
+
+    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(
+                Geometry1 const& geometry1, Geometry2 const& geometry2,
+                RobustPolicy const& robust_policy,
+                OutputIterator out,
+                Strategy const& strategy)
+    {
+        overlay_null_visitor visitor;
+        return apply(geometry1, geometry2, robust_policy, out, strategy, visitor);
+    }
+};
+
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_OVERLAY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/overlay_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/overlay_type.hpp
new file mode 100644
index 00000000000..0f608409733
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/overlay_type.hpp
@@ -0,0 +1,67 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_OVERLAY_TYPE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_OVERLAY_TYPE_HPP
+
+
+
+namespace boost { namespace geometry
+{
+
+// TODO: move to detail
+enum overlay_type
+{
+    overlay_union,
+    overlay_intersection,
+    overlay_difference,
+    overlay_buffer,
+    overlay_dissolve
+};
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+enum operation_type
+{
+    operation_none,
+    operation_union,
+    operation_intersection,
+    operation_blocked,
+    operation_continue,
+    operation_opposite
+};
+
+
+template <overlay_type OverlayType>
+struct operation_from_overlay
+{
+    static const operation_type value = operation_union;
+};
+
+template <>
+struct operation_from_overlay<overlay_intersection>
+{
+    static const operation_type value = operation_intersection;
+};
+
+template <>
+struct operation_from_overlay<overlay_difference>
+{
+    static const operation_type value = operation_intersection;
+};
+
+}} // namespace detail::overlay
+#endif //DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_OVERLAY_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/pointlike_linear.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/pointlike_linear.hpp
new file mode 100644
index 00000000000..0a7c3bc4699
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/pointlike_linear.hpp
@@ -0,0 +1,394 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
+
+// Copyright (c) 2015-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_POINTLIKE_LINEAR_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_POINTLIKE_LINEAR_HPP
+
+#include <iterator>
+#include <vector>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/box.hpp>
+
+#include <boost/geometry/iterators/segment_iterator.hpp>
+
+#include <boost/geometry/algorithms/disjoint.hpp>
+#include <boost/geometry/algorithms/envelope.hpp>
+#include <boost/geometry/algorithms/expand.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/algorithms/detail/not.hpp>
+#include <boost/geometry/algorithms/detail/partition.hpp>
+#include <boost/geometry/algorithms/detail/relate/less.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/point_geometry.hpp>
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
+#include <boost/geometry/algorithms/detail/overlay/pointlike_pointlike.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+// action struct for pointlike-linear difference/intersection
+// it works the same as its pointlike-pointlike counterpart, hence the
+// derivation
+template <typename PointOut, overlay_type OverlayType>
+struct action_selector_pl_l
+    : action_selector_pl_pl<PointOut, OverlayType>
+{};
+
+// difference/intersection of point-linear
+template
+<
+    typename Point,
+    typename Linear,
+    typename PointOut,
+    overlay_type OverlayType,
+    typename Policy
+>
+struct point_linear_point
+{
+    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(Point const& point,
+                                       Linear const& linear,
+                                       RobustPolicy const&,
+                                       OutputIterator oit,
+                                       Strategy const& strategy)
+    {
+        action_selector_pl_l
+            <
+                PointOut, OverlayType
+            >::apply(point, Policy::apply(point, linear, strategy), oit);
+        return oit;
+    }
+};
+
+// difference/intersection of multipoint-segment
+template
+<
+    typename MultiPoint,
+    typename Segment,
+    typename PointOut,
+    overlay_type OverlayType,
+    typename Policy
+>
+struct multipoint_segment_point
+{
+    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(MultiPoint const& multipoint,
+                                       Segment const& segment,
+                                       RobustPolicy const&,
+                                       OutputIterator oit,
+                                       Strategy const& strategy)
+    {
+        for (typename boost::range_iterator<MultiPoint const>::type
+                 it = boost::begin(multipoint);
+             it != boost::end(multipoint);
+             ++it)
+        {
+            action_selector_pl_l
+                <
+                    PointOut, OverlayType
+                >::apply(*it, Policy::apply(*it, segment, strategy), oit);
+        }
+
+        return oit;
+    }
+};
+
+
+// difference/intersection of multipoint-linear
+template
+<
+    typename MultiPoint,
+    typename Linear,
+    typename PointOut,
+    overlay_type OverlayType,
+    typename Policy
+>
+class multipoint_linear_point
+{
+private:
+    // structs for partition -- start
+    struct expand_box_point
+    {
+        template <typename Box, typename Point>
+        static inline void apply(Box& total, Point const& point)
+        {
+            geometry::expand(total, point);
+        }
+    };
+
+    template <typename EnvelopeStrategy>
+    struct expand_box_segment
+    {
+        explicit expand_box_segment(EnvelopeStrategy const& strategy)
+            : m_strategy(strategy)
+        {}
+
+        template <typename Box, typename Segment>
+        inline void apply(Box& total, Segment const& segment) const
+        {
+            geometry::expand(total,
+                             geometry::return_envelope<Box>(segment, m_strategy));
+        }
+
+        EnvelopeStrategy const& m_strategy;
+    };
+
+    struct overlaps_box_point
+    {
+        template <typename Box, typename Point>
+        static inline bool apply(Box const& box, Point const& point)
+        {
+            return ! geometry::disjoint(point, box);
+        }
+    };
+
+    template <typename DisjointStrategy>
+    struct overlaps_box_segment
+    {
+        explicit overlaps_box_segment(DisjointStrategy const& strategy)
+            : m_strategy(strategy)
+        {}
+
+        template <typename Box, typename Segment>
+        inline bool apply(Box const& box, Segment const& segment) const
+        {
+            return ! geometry::disjoint(segment, box, m_strategy);
+        }
+
+        DisjointStrategy const& m_strategy;
+    };
+
+    template <typename OutputIterator, typename Strategy>
+    class item_visitor_type
+    {
+    public:
+        item_visitor_type(OutputIterator& oit, Strategy const& strategy)
+            : m_oit(oit)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Item1, typename Item2>
+        inline bool apply(Item1 const& item1, Item2 const& item2)
+        {
+            action_selector_pl_l
+                <
+                    PointOut, overlay_intersection
+                >::apply(item1, Policy::apply(item1, item2, m_strategy), m_oit);
+
+            return true;
+        }
+
+    private:
+        OutputIterator& m_oit;
+        Strategy const& m_strategy;
+    };
+    // structs for partition -- end
+
+    class segment_range
+    {
+    public:
+        typedef geometry::segment_iterator<Linear const> const_iterator;
+        typedef const_iterator iterator;
+
+        segment_range(Linear const& linear)
+            : m_linear(linear)
+        {}
+
+        const_iterator begin() const
+        {
+            return geometry::segments_begin(m_linear);
+        }
+
+        const_iterator end() const
+        {
+            return geometry::segments_end(m_linear);
+        }
+
+    private:
+        Linear const& m_linear;
+    };
+
+    template <typename OutputIterator, typename Strategy>
+    static inline OutputIterator get_common_points(MultiPoint const& multipoint,
+                                                   Linear const& linear,
+                                                   OutputIterator oit,
+                                                   Strategy const& strategy)
+    {
+        item_visitor_type<OutputIterator, Strategy> item_visitor(oit, strategy);
+
+        typedef typename Strategy::envelope_strategy_type envelope_strategy_type;
+        typedef typename Strategy::disjoint_strategy_type disjoint_strategy_type;
+
+        // TODO: disjoint Segment/Box may be called in partition multiple times
+        // possibly for non-cartesian segments which could be slow. We should consider
+        // passing a range of bounding boxes of segments after calculating them once.
+        // Alternatively instead of a range of segments a range of Segment/Envelope pairs
+        // should be passed, where envelope would be lazily calculated when needed the first time
+        geometry::partition
+            <
+                geometry::model::box
+                    <
+                        typename boost::range_value<MultiPoint>::type
+                    >
+            >::apply(multipoint, segment_range(linear), item_visitor,
+                     expand_box_point(),
+                     overlaps_box_point(),
+                     expand_box_segment<envelope_strategy_type>(strategy.get_envelope_strategy()),
+                     overlaps_box_segment<disjoint_strategy_type>(strategy.get_disjoint_strategy()));
+
+        return oit;
+    }
+
+public:
+    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(MultiPoint const& multipoint,
+                                       Linear const& linear,
+                                       RobustPolicy const& robust_policy,
+                                       OutputIterator oit,
+                                       Strategy const& strategy)
+    {
+        typedef std::vector
+            <
+                typename boost::range_value<MultiPoint>::type
+            > point_vector_type;
+
+        point_vector_type common_points;
+
+        // compute the common points
+        get_common_points(multipoint, linear,
+                          std::back_inserter(common_points),
+                          strategy);
+
+        return multipoint_multipoint_point
+            <
+                MultiPoint, point_vector_type, PointOut, OverlayType
+            >::apply(multipoint, common_points, robust_policy, oit, strategy);
+    }
+};
+
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace detail_dispatch { namespace overlay
+{
+
+// dispatch struct for pointlike-linear difference/intersection computation
+template
+<
+    typename PointLike,
+    typename Linear,
+    typename PointOut,
+    overlay_type OverlayType,
+    typename Tag1,
+    typename Tag2
+>
+struct pointlike_linear_point
+    : not_implemented<PointLike, Linear, PointOut>
+{};
+
+
+template
+<
+    typename Point,
+    typename Linear,
+    typename PointOut,
+    overlay_type OverlayType
+>
+struct pointlike_linear_point
+    <
+        Point, Linear, PointOut, OverlayType, point_tag, linear_tag
+    > : detail::overlay::point_linear_point
+        <
+            Point, Linear, PointOut, OverlayType,
+            detail::not_<detail::disjoint::reverse_covered_by>
+        >
+{};
+
+
+template
+<
+    typename Point,
+    typename Segment,
+    typename PointOut,
+    overlay_type OverlayType
+>
+struct pointlike_linear_point
+    <
+        Point, Segment, PointOut, OverlayType, point_tag, segment_tag
+    > : detail::overlay::point_linear_point
+        <
+            Point, Segment, PointOut, OverlayType,
+            detail::not_<detail::disjoint::reverse_covered_by>
+        >
+{};
+
+
+template
+<
+    typename MultiPoint,
+    typename Linear,
+    typename PointOut,
+    overlay_type OverlayType
+>
+struct pointlike_linear_point
+    <
+        MultiPoint, Linear, PointOut, OverlayType, multi_point_tag, linear_tag
+    > : detail::overlay::multipoint_linear_point
+        <
+            MultiPoint, Linear, PointOut, OverlayType,
+            detail::not_<detail::disjoint::reverse_covered_by>
+        >
+{};
+
+
+template
+<
+    typename MultiPoint,
+    typename Segment,
+    typename PointOut,
+    overlay_type OverlayType
+>
+struct pointlike_linear_point
+    <
+        MultiPoint, Segment, PointOut, OverlayType, multi_point_tag, segment_tag
+    > : detail::overlay::multipoint_segment_point
+        <
+            MultiPoint, Segment, PointOut, OverlayType,
+            detail::not_<detail::disjoint::reverse_covered_by>
+        >
+{};
+
+
+}} // namespace detail_dispatch::overlay
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_POINTLIKE_LINEAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/pointlike_pointlike.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/pointlike_pointlike.hpp
new file mode 100644
index 00000000000..438a3778761
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/pointlike_pointlike.hpp
@@ -0,0 +1,435 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2015, Oracle and/or its affiliates.
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_POINTLIKE_POINTLIKE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_POINTLIKE_POINTLIKE_HPP
+
+#include <algorithm>
+#include <vector>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/convert.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/algorithms/detail/relate/less.hpp>
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+// struct for copying points of the pointlike geometries to output
+template
+<
+    typename PointOut,
+    typename GeometryIn,
+    typename TagIn = typename tag<GeometryIn>::type
+>
+struct copy_points
+    : not_implemented<PointOut, GeometryIn>
+{};
+
+template <typename PointOut, typename PointIn>
+struct copy_points<PointOut, PointIn, point_tag>
+{
+    template <typename OutputIterator>
+    static inline void apply(PointIn const& point_in,
+                             OutputIterator& oit)
+    {
+        PointOut point_out;
+        geometry::convert(point_in, point_out);
+        *oit++ = point_out;
+    }
+};
+
+
+template <typename PointOut, typename MultiPointIn>
+struct copy_points<PointOut, MultiPointIn, multi_point_tag>
+{
+    template <typename OutputIterator>
+    static inline void apply(MultiPointIn const& multi_point_in,
+                             OutputIterator& oit)
+    {
+        for (typename boost::range_iterator<MultiPointIn const>::type
+                 it = boost::begin(multi_point_in);
+             it != boost::end(multi_point_in); ++it)
+        {
+            PointOut point_out;
+            geometry::convert(*it, point_out);
+            *oit++ = point_out;
+        }
+    }
+};
+
+
+
+// action struct for difference/intersection
+template <typename PointOut, overlay_type OverlayType>
+struct action_selector_pl_pl
+{};
+
+template <typename PointOut>
+struct action_selector_pl_pl<PointOut, overlay_intersection>
+{
+    template
+    <
+        typename Point,
+        typename OutputIterator
+    >
+    static inline void apply(Point const& point,
+                             bool is_common,
+                             OutputIterator& oit)
+    {
+        if ( is_common )
+        {
+            copy_points<PointOut, Point>::apply(point, oit);
+        }
+    }
+};
+
+
+
+template <typename PointOut>
+struct action_selector_pl_pl<PointOut, overlay_difference>
+{
+    template
+    <
+        typename Point,
+        typename OutputIterator
+    >
+    static inline void apply(Point const& point,
+                             bool is_common,
+                             OutputIterator& oit)
+    {
+        if ( !is_common )
+        {
+            copy_points<PointOut, Point>::apply(point, oit);
+        }
+    }
+};
+
+
+//===========================================================================
+
+// difference/intersection of point-point
+template
+<
+    typename Point1,
+    typename Point2,
+    typename PointOut,
+    overlay_type OverlayType
+>
+struct point_point_point
+{
+    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(Point1 const& point1,
+                                       Point2 const& point2,
+                                       RobustPolicy const& ,
+                                       OutputIterator oit,
+                                       Strategy const&)
+    {
+        action_selector_pl_pl
+            <
+                PointOut, OverlayType
+            >::apply(point1,
+                     detail::equals::equals_point_point(point1, point2),
+                     oit);
+
+        return oit;
+    }
+};
+
+
+
+// difference of multipoint-point
+//
+// the apply method in the following struct is called only for
+// difference; for intersection the reversal will
+// always call the point-multipoint version
+template
+<
+    typename MultiPoint,
+    typename Point,
+    typename PointOut,
+    overlay_type OverlayType
+>
+struct multipoint_point_point
+{
+    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(MultiPoint const& multipoint,
+                                       Point const& point,
+                                       RobustPolicy const& ,
+                                       OutputIterator oit,
+                                       Strategy const&)
+    {
+        BOOST_GEOMETRY_ASSERT( OverlayType == overlay_difference );
+
+        for (typename boost::range_iterator<MultiPoint const>::type
+                 it = boost::begin(multipoint);
+             it != boost::end(multipoint); ++it)
+        {
+            action_selector_pl_pl
+                <
+                    PointOut, OverlayType
+                >::apply(*it,
+                         detail::equals::equals_point_point(*it, point),
+                         oit);
+        }
+
+        return oit;
+    }
+};
+
+
+// difference/intersection of point-multipoint
+template
+<
+    typename Point,
+    typename MultiPoint,
+    typename PointOut,
+    overlay_type OverlayType
+>
+struct point_multipoint_point
+{
+    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(Point const& point,
+                                       MultiPoint const& multipoint,
+                                       RobustPolicy const& ,
+                                       OutputIterator oit,
+                                       Strategy const&)
+    {
+        typedef action_selector_pl_pl<PointOut, OverlayType> action;
+
+        for (typename boost::range_iterator<MultiPoint const>::type
+                 it = boost::begin(multipoint);
+             it != boost::end(multipoint); ++it)
+        {
+            if ( detail::equals::equals_point_point(*it, point) )
+            {
+                action::apply(point, true, oit);
+                return oit;
+            }
+        }
+
+        action::apply(point, false, oit);
+        return oit;
+    }
+};
+
+
+
+// difference/intersection of multipoint-multipoint
+template
+<
+    typename MultiPoint1,
+    typename MultiPoint2,
+    typename PointOut,
+    overlay_type OverlayType
+>
+struct multipoint_multipoint_point
+{
+    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(MultiPoint1 const& multipoint1,
+                                       MultiPoint2 const& multipoint2,
+                                       RobustPolicy const& robust_policy,
+                                       OutputIterator oit,
+                                       Strategy const& strategy)
+    {
+        if ( OverlayType != overlay_difference
+             && boost::size(multipoint1) > boost::size(multipoint2) )
+        {
+            return multipoint_multipoint_point
+                <
+                    MultiPoint2, MultiPoint1, PointOut, OverlayType
+                >::apply(multipoint2, multipoint1, robust_policy, oit, strategy);
+        }
+
+        std::vector<typename boost::range_value<MultiPoint2>::type>
+            points2(boost::begin(multipoint2), boost::end(multipoint2));
+
+        std::sort(points2.begin(), points2.end(), detail::relate::less());
+
+        for (typename boost::range_iterator<MultiPoint1 const>::type
+                 it1 = boost::begin(multipoint1);
+             it1 != boost::end(multipoint1); ++it1)
+        {
+            bool found = std::binary_search(points2.begin(), points2.end(),
+                                            *it1, detail::relate::less());
+
+            action_selector_pl_pl
+                <
+                    PointOut, OverlayType
+                >::apply(*it1, found, oit);
+        }
+        return oit;
+    }
+};
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+
+//===========================================================================
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace detail_dispatch { namespace overlay
+{
+
+// dispatch struct for pointlike-pointlike difference/intersection
+// computation
+template
+<
+    typename PointLike1,
+    typename PointLike2,
+    typename PointOut,
+    overlay_type OverlayType,
+    typename Tag1,
+    typename Tag2
+>
+struct pointlike_pointlike_point
+    : not_implemented<PointLike1, PointLike2, PointOut>
+{};
+
+
+template
+<
+    typename Point1,
+    typename Point2,
+    typename PointOut,
+    overlay_type OverlayType
+>
+struct pointlike_pointlike_point
+    <
+        Point1, Point2, PointOut, OverlayType,
+        point_tag, point_tag
+    > : detail::overlay::point_point_point
+        <
+            Point1, Point2, PointOut, OverlayType
+        >
+{};
+
+
+template
+<
+    typename Point,
+    typename MultiPoint,
+    typename PointOut,
+    overlay_type OverlayType
+>
+struct pointlike_pointlike_point
+    <
+        Point, MultiPoint, PointOut, OverlayType,
+        point_tag, multi_point_tag
+    > : detail::overlay::point_multipoint_point
+        <
+            Point, MultiPoint, PointOut, OverlayType
+        >
+{};
+
+
+template
+<
+    typename MultiPoint,
+    typename Point,
+    typename PointOut,
+    overlay_type OverlayType
+>
+struct pointlike_pointlike_point
+    <
+        MultiPoint, Point, PointOut, OverlayType,
+        multi_point_tag, point_tag
+    > : detail::overlay::multipoint_point_point
+        <
+            MultiPoint, Point, PointOut, OverlayType
+        >
+{};
+
+
+template
+<
+    typename MultiPoint1,
+    typename MultiPoint2,
+    typename PointOut,
+    overlay_type OverlayType
+>
+struct pointlike_pointlike_point
+    <
+        MultiPoint1, MultiPoint2, PointOut, OverlayType,
+        multi_point_tag, multi_point_tag
+    > : detail::overlay::multipoint_multipoint_point
+        <
+            MultiPoint1, MultiPoint2, PointOut, OverlayType
+        >
+{};
+
+
+}} // namespace detail_dispatch::overlay
+#endif // DOXYGEN_NO_DISPATCH
+
+
+//===========================================================================
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+// generic pointlike-pointlike union implementation
+template
+<
+    typename PointLike1,
+    typename PointLike2,
+    typename PointOut
+>
+struct union_pointlike_pointlike_point
+{
+    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(PointLike1 const& pointlike1,
+                                       PointLike2 const& pointlike2,
+                                       RobustPolicy const& robust_policy,
+                                       OutputIterator oit,
+                                       Strategy const& strategy)
+    {
+        copy_points<PointOut, PointLike1>::apply(pointlike1, oit);
+
+        return detail_dispatch::overlay::pointlike_pointlike_point
+            <
+                PointLike2, PointLike1, PointOut, overlay_difference,
+                typename tag<PointLike2>::type,
+                typename tag<PointLike1>::type
+            >::apply(pointlike2, pointlike1, robust_policy, oit, strategy);
+    }
+
+};
+
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_POINTLIKE_POINTLIKE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/range_in_geometry.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/range_in_geometry.hpp
new file mode 100644
index 00000000000..d4a47abecf9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/range_in_geometry.hpp
@@ -0,0 +1,178 @@
+// Boost.Geometry
+
+// Copyright (c) 2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_RANGE_IN_GEOMETRY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_RANGE_IN_GEOMETRY_HPP
+
+
+#include <boost/geometry/algorithms/covered_by.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/iterators/point_iterator.hpp>
+
+#include <boost/range.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+template
+<
+    typename Geometry,
+    typename Tag = typename geometry::tag<Geometry>::type
+>
+struct points_range
+{
+    typedef geometry::point_iterator<Geometry const> iterator_type;
+
+    explicit points_range(Geometry const& geometry)
+        : m_geometry(geometry)
+    {}
+
+    iterator_type begin() const
+    {
+        return geometry::points_begin(m_geometry);
+    }
+
+    iterator_type end() const
+    {
+        return geometry::points_end(m_geometry);
+    }
+
+    Geometry const& m_geometry;
+};
+// Specialized because point_iterator doesn't support boxes
+template <typename Box>
+struct points_range<Box, box_tag>
+{
+    typedef typename geometry::point_type<Box>::type point_type;
+    typedef const point_type * iterator_type;
+
+    explicit points_range(Box const& box)
+    {
+        detail::assign_box_corners(box,
+            m_corners[0], m_corners[1], m_corners[2], m_corners[3]);
+    }
+
+    iterator_type begin() const
+    {
+        return m_corners;
+    }
+
+    iterator_type end() const
+    {
+        return m_corners + 4;
+    }
+
+    point_type m_corners[4];
+};
+
+template
+<
+    typename Geometry,
+    typename Tag = typename geometry::tag<Geometry>::type
+>
+struct point_in_geometry_helper
+{
+    template <typename Point, typename Strategy>
+    static inline int apply(Point const& point, Geometry const& geometry,
+                            Strategy const& strategy)
+    {
+        return detail::within::point_in_geometry(point, geometry, strategy);
+    }
+};
+// Specialized because point_in_geometry doesn't support Boxes
+template <typename Box>
+struct point_in_geometry_helper<Box, box_tag>
+{
+    template <typename Point, typename Strategy>
+    static inline int apply(Point const& point, Box const& box,
+                            Strategy const&)
+    {
+        return geometry::covered_by(point, box) ? 1 : -1;
+    }
+};
+
+// This function returns
+// when it finds a point of geometry1 inside or outside geometry2
+template <typename Geometry1, typename Geometry2, typename Strategy>
+static inline int range_in_geometry(Geometry1 const& geometry1,
+                                    Geometry2 const& geometry2,
+                                    Strategy const& strategy,
+                                    bool skip_first = false)
+{
+    int result = 0;
+    points_range<Geometry1> points(geometry1);
+    typedef typename points_range<Geometry1>::iterator_type iterator_type;
+    iterator_type const end = points.end();
+    iterator_type it = points.begin();
+    if (it == end)
+    {
+        return result;
+    }
+    else if (skip_first)
+    {
+        ++it;
+    }
+
+    typename Strategy::template point_in_geometry_strategy
+        <
+            Geometry1, Geometry2
+        >::type const in_strategy
+        = strategy.template get_point_in_geometry_strategy<Geometry1, Geometry2>();
+
+    for ( ; it != end; ++it)
+    {
+        result = point_in_geometry_helper<Geometry2>::apply(*it, geometry2, in_strategy);
+        if (result != 0)
+        {
+            return result;
+        }
+    }
+    // all points contained entirely by the boundary
+    return result;
+}
+
+// This function returns if first_point1 is inside or outside geometry2 or
+// when it finds a point of geometry1 inside or outside geometry2
+template <typename Point1, typename Geometry1, typename Geometry2, typename Strategy>
+inline int range_in_geometry(Point1 const& first_point1,
+                             Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+{
+    // check a point on border of geometry1 first
+    int result = point_in_geometry_helper<Geometry2>::apply(first_point1, geometry2,
+                    strategy.template get_point_in_geometry_strategy<Point1, Geometry2>());
+    if (result == 0)
+    {
+        // if a point is on boundary of geometry2
+        // check points of geometry1 until point inside/outside is found
+        // NOTE: skip first point because it should be already tested above
+        result = range_in_geometry(geometry1, geometry2, strategy, true);
+    }    
+    return result;
+}
+
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_RANGE_IN_GEOMETRY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/ring_properties.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/ring_properties.hpp
new file mode 100644
index 00000000000..7dbc5d5fabe
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/ring_properties.hpp
@@ -0,0 +1,82 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_RING_PROPERTIES_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_RING_PROPERTIES_HPP
+
+
+#include <boost/geometry/algorithms/area.hpp>
+#include <boost/geometry/algorithms/within.hpp>
+#include <boost/geometry/algorithms/detail/point_on_border.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+template <typename Point, typename AreaType>
+struct ring_properties
+{
+    typedef Point point_type;
+    typedef AreaType area_type;
+
+    bool valid;
+
+    // Filled by "select_rings"
+    Point point;
+    area_type area;
+
+    // Filled by "update_ring_selection"
+    bool reversed;
+
+    // Filled/used by "assign_rings"
+    bool discarded;
+    ring_identifier parent;
+    area_type parent_area;
+    std::vector<ring_identifier> children;
+
+    inline ring_properties()
+        : valid(false)
+        , area(area_type())
+        , reversed(false)
+        , discarded(false)
+        , parent_area(-1)
+    {}
+
+    template <typename RingOrBox, typename AreaStrategy>
+    inline ring_properties(RingOrBox const& ring_or_box, AreaStrategy const& strategy)
+        : reversed(false)
+        , discarded(false)
+        , parent_area(-1)
+    {
+        this->area = geometry::area(ring_or_box, strategy);
+        valid = geometry::point_on_border(this->point, ring_or_box);
+    }
+
+    inline area_type get_area() const
+    {
+        return reversed ? -area : area;
+    }
+};
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_RING_PROPERTIES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/segment_identifier.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/segment_identifier.hpp
new file mode 100644
index 00000000000..5447c8813e4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/segment_identifier.hpp
@@ -0,0 +1,99 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SEGMENT_IDENTIFIER_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SEGMENT_IDENTIFIER_HPP
+
+
+#if defined(BOOST_GEOMETRY_DEBUG_OVERLAY)
+#  define BOOST_GEOMETRY_DEBUG_SEGMENT_IDENTIFIER
+#endif
+
+#if defined(BOOST_GEOMETRY_DEBUG_SEGMENT_IDENTIFIER)
+#include <iostream>
+#endif
+
+
+#include <boost/geometry/algorithms/detail/signed_size_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+
+// Internal struct to uniquely identify a segment
+// on a linestring,ring
+// or polygon (needs ring_index)
+// or multi-geometry (needs multi_index)
+struct segment_identifier
+{
+    inline segment_identifier()
+        : source_index(-1)
+        , multi_index(-1)
+        , ring_index(-1)
+        , segment_index(-1)
+        , piece_index(-1)
+    {}
+
+    inline segment_identifier(signed_size_type src,
+                              signed_size_type mul,
+                              signed_size_type rin,
+                              signed_size_type seg)
+        : source_index(src)
+        , multi_index(mul)
+        , ring_index(rin)
+        , segment_index(seg)
+        , piece_index(-1)
+    {}
+
+    inline bool operator<(segment_identifier const& other) const
+    {
+        return source_index != other.source_index ? source_index < other.source_index
+            : multi_index !=other.multi_index ? multi_index < other.multi_index
+            : ring_index != other.ring_index ? ring_index < other.ring_index
+            : segment_index < other.segment_index
+            ;
+    }
+
+    inline bool operator==(segment_identifier const& other) const
+    {
+        return source_index == other.source_index
+            && segment_index == other.segment_index
+            && ring_index == other.ring_index
+            && multi_index == other.multi_index
+            ;
+    }
+
+#if defined(BOOST_GEOMETRY_DEBUG_SEGMENT_IDENTIFIER)
+    friend std::ostream& operator<<(std::ostream &os, segment_identifier const& seg_id)
+    {
+        os
+            << "s:" << seg_id.source_index
+            << ", v:" << seg_id.segment_index // v:vertex because s is used for source
+            ;
+        if (seg_id.ring_index >= 0) os << ", r:" << seg_id.ring_index;
+        if (seg_id.multi_index >= 0) os << ", m:" << seg_id.multi_index;
+        return os;
+    }
+#endif
+
+    signed_size_type source_index;
+    signed_size_type multi_index;
+    signed_size_type ring_index;
+    signed_size_type segment_index;
+
+    // For buffer - todo: move this to buffer-only
+    signed_size_type piece_index;
+};
+
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SEGMENT_IDENTIFIER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/select_rings.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/select_rings.hpp
new file mode 100644
index 00000000000..67a4f4bb752
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/select_rings.hpp
@@ -0,0 +1,371 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SELECT_RINGS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SELECT_RINGS_HPP
+
+
+#include <map>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/area.hpp>
+#include <boost/geometry/algorithms/covered_by.hpp>
+#include <boost/geometry/algorithms/detail/interior_iterator.hpp>
+#include <boost/geometry/algorithms/detail/ring_identifier.hpp>
+#include <boost/geometry/algorithms/detail/overlay/range_in_geometry.hpp>
+#include <boost/geometry/algorithms/detail/overlay/ring_properties.hpp>
+#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+struct ring_turn_info
+{
+    bool has_traversed_turn;
+    bool within_other;
+
+    ring_turn_info()
+        : has_traversed_turn(false)
+        , within_other(false)
+    {}
+};
+
+namespace dispatch
+{
+
+    template <typename Tag, typename Geometry>
+    struct select_rings
+    {};
+
+    template <typename Box>
+    struct select_rings<box_tag, Box>
+    {
+        template <typename Geometry, typename RingPropertyMap, typename AreaStrategy>
+        static inline void apply(Box const& box, Geometry const& ,
+                ring_identifier const& id, RingPropertyMap& ring_properties,
+                AreaStrategy const& strategy)
+        {
+            ring_properties[id] = typename RingPropertyMap::mapped_type(box, strategy);
+        }
+
+        template <typename RingPropertyMap, typename AreaStrategy>
+        static inline void apply(Box const& box,
+                ring_identifier const& id, RingPropertyMap& ring_properties,
+                AreaStrategy const& strategy)
+        {
+            ring_properties[id] = typename RingPropertyMap::mapped_type(box, strategy);
+        }
+    };
+
+    template <typename Ring>
+    struct select_rings<ring_tag, Ring>
+    {
+        template <typename Geometry, typename RingPropertyMap, typename AreaStrategy>
+        static inline void apply(Ring const& ring, Geometry const& ,
+                    ring_identifier const& id, RingPropertyMap& ring_properties,
+                    AreaStrategy const& strategy)
+        {
+            if (boost::size(ring) > 0)
+            {
+                ring_properties[id] = typename RingPropertyMap::mapped_type(ring, strategy);
+            }
+        }
+
+        template <typename RingPropertyMap, typename AreaStrategy>
+        static inline void apply(Ring const& ring,
+                    ring_identifier const& id, RingPropertyMap& ring_properties,
+                    AreaStrategy const& strategy)
+        {
+            if (boost::size(ring) > 0)
+            {
+                ring_properties[id] = typename RingPropertyMap::mapped_type(ring, strategy);
+            }
+        }
+    };
+
+
+    template <typename Polygon>
+    struct select_rings<polygon_tag, Polygon>
+    {
+        template <typename Geometry, typename RingPropertyMap, typename AreaStrategy>
+        static inline void apply(Polygon const& polygon, Geometry const& geometry,
+                    ring_identifier id, RingPropertyMap& ring_properties,
+                    AreaStrategy const& strategy)
+        {
+            typedef typename geometry::ring_type<Polygon>::type ring_type;
+            typedef select_rings<ring_tag, ring_type> per_ring;
+
+            per_ring::apply(exterior_ring(polygon), geometry, id, ring_properties, strategy);
+
+            typename interior_return_type<Polygon const>::type
+                rings = interior_rings(polygon);
+            for (typename detail::interior_iterator<Polygon const>::type
+                    it = boost::begin(rings); it != boost::end(rings); ++it)
+            {
+                id.ring_index++;
+                per_ring::apply(*it, geometry, id, ring_properties, strategy);
+            }
+        }
+
+        template <typename RingPropertyMap, typename AreaStrategy>
+        static inline void apply(Polygon const& polygon,
+                ring_identifier id, RingPropertyMap& ring_properties,
+                AreaStrategy const& strategy)
+        {
+            typedef typename geometry::ring_type<Polygon>::type ring_type;
+            typedef select_rings<ring_tag, ring_type> per_ring;
+
+            per_ring::apply(exterior_ring(polygon), id, ring_properties, strategy);
+
+            typename interior_return_type<Polygon const>::type
+                rings = interior_rings(polygon);
+            for (typename detail::interior_iterator<Polygon const>::type
+                    it = boost::begin(rings); it != boost::end(rings); ++it)
+            {
+                id.ring_index++;
+                per_ring::apply(*it, id, ring_properties, strategy);
+            }
+        }
+    };
+
+    template <typename Multi>
+    struct select_rings<multi_polygon_tag, Multi>
+    {
+        template <typename Geometry, typename RingPropertyMap, typename AreaStrategy>
+        static inline void apply(Multi const& multi, Geometry const& geometry,
+                    ring_identifier id, RingPropertyMap& ring_properties,
+                    AreaStrategy const& strategy)
+        {
+            typedef typename boost::range_iterator
+                <
+                    Multi const
+                >::type iterator_type;
+
+            typedef select_rings<polygon_tag, typename boost::range_value<Multi>::type> per_polygon;
+
+            id.multi_index = 0;
+            for (iterator_type it = boost::begin(multi); it != boost::end(multi); ++it)
+            {
+                id.ring_index = -1;
+                per_polygon::apply(*it, geometry, id, ring_properties, strategy);
+                id.multi_index++;
+            }
+        }
+    };
+
+} // namespace dispatch
+
+
+template<overlay_type OverlayType>
+struct decide
+{
+    // Default implementation (union, inflate, deflate, dissolve)
+    static bool include(ring_identifier const& , ring_turn_info const& info)
+    {
+        return ! info.within_other;
+    }
+
+    static bool reversed(ring_identifier const& , ring_turn_info const& )
+    {
+        return false;
+    }
+
+};
+
+template<>
+struct decide<overlay_difference>
+{
+    static bool include(ring_identifier const& id, ring_turn_info const& info)
+    {
+        // Difference: A - B
+
+        // If this is A (source_index=0), then the ring is inside B
+        // If this is B (source_index=1), then the ring is NOT inside A
+
+        // If this is A and the ring is within the other geometry,
+        // then we should NOT include it.
+        // If this is B then we SHOULD include it.
+
+        return id.source_index == 0
+            ? ! info.within_other
+            : info.within_other;
+    }
+
+    static bool reversed(ring_identifier const& id, ring_turn_info const& info)
+    {
+        // Difference: A - B
+        // If this is B, and the ring is included, it should be reversed afterwards
+
+        return id.source_index == 1 && include(id, info);
+    }
+};
+
+template<>
+struct decide<overlay_intersection>
+{
+    static bool include(ring_identifier const& , ring_turn_info const& info)
+    {
+        return info.within_other;
+    }
+
+    static bool reversed(ring_identifier const& , ring_turn_info const& )
+    {
+        return false;
+    }
+};
+
+template
+<
+    overlay_type OverlayType,
+    typename Geometry1,
+    typename Geometry2,
+    typename TurnInfoMap,
+    typename RingPropertyMap,
+    typename Strategy
+>
+inline void update_ring_selection(Geometry1 const& geometry1,
+            Geometry2 const& geometry2,
+            TurnInfoMap const& turn_info_map,
+            RingPropertyMap const& all_ring_properties,
+            RingPropertyMap& selected_ring_properties,
+            Strategy const& strategy)
+{
+    selected_ring_properties.clear();
+
+    for (typename RingPropertyMap::const_iterator it = boost::begin(all_ring_properties);
+        it != boost::end(all_ring_properties);
+        ++it)
+    {
+        ring_identifier const& id = it->first;
+
+        ring_turn_info info;
+
+        typename TurnInfoMap::const_iterator tcit = turn_info_map.find(id);
+        if (tcit != turn_info_map.end())
+        {
+            info = tcit->second; // Copy by value
+        }
+
+        if (info.has_traversed_turn)
+        {
+            // This turn is traversed (or blocked),
+            // don't include the original ring
+            continue;
+        }
+
+        // Check if the ring is within the other geometry, by taking
+        // a point lying on the ring
+        switch(id.source_index)
+        {
+            // within
+            case 0 :
+                info.within_other = range_in_geometry(it->second.point,
+                                                      geometry1, geometry2,
+                                                      strategy) > 0;
+                break;
+            case 1 :
+                info.within_other = range_in_geometry(it->second.point,
+                                                      geometry2, geometry1,
+                                                      strategy) > 0;
+                break;
+        }
+
+        if (decide<OverlayType>::include(id, info))
+        {
+            typename RingPropertyMap::mapped_type properties = it->second; // Copy by value
+            properties.reversed = decide<OverlayType>::reversed(id, info);
+            selected_ring_properties[id] = properties;
+        }
+    }
+}
+
+
+/*!
+\brief The function select_rings select rings based on the overlay-type (union,intersection)
+*/
+template
+<
+    overlay_type OverlayType,
+    typename Geometry1,
+    typename Geometry2,
+    typename RingTurnInfoMap,
+    typename RingPropertyMap,
+    typename Strategy
+>
+inline void select_rings(Geometry1 const& geometry1, Geometry2 const& geometry2,
+            RingTurnInfoMap const& turn_info_per_ring,
+            RingPropertyMap& selected_ring_properties,
+            Strategy const& strategy)
+{
+    typedef typename geometry::tag<Geometry1>::type tag1;
+    typedef typename geometry::tag<Geometry2>::type tag2;
+    typedef typename geometry::point_type<Geometry1>::type point1_type;
+    typedef typename geometry::point_type<Geometry2>::type point2_type;
+
+    RingPropertyMap all_ring_properties;
+    dispatch::select_rings<tag1, Geometry1>::apply(geometry1, geometry2,
+                ring_identifier(0, -1, -1), all_ring_properties,
+                strategy.template get_area_strategy<point1_type>());
+    dispatch::select_rings<tag2, Geometry2>::apply(geometry2, geometry1,
+                ring_identifier(1, -1, -1), all_ring_properties,
+                strategy.template get_area_strategy<point2_type>());
+
+    update_ring_selection<OverlayType>(geometry1, geometry2, turn_info_per_ring,
+                all_ring_properties, selected_ring_properties,
+                strategy);
+}
+
+template
+<
+    overlay_type OverlayType,
+    typename Geometry,
+    typename RingTurnInfoMap,
+    typename RingPropertyMap,
+    typename Strategy
+>
+inline void select_rings(Geometry const& geometry,
+            RingTurnInfoMap const& turn_info_per_ring,
+            RingPropertyMap& selected_ring_properties,
+            Strategy const& strategy)
+{
+    typedef typename geometry::tag<Geometry>::type tag;
+    typedef typename geometry::point_type<Geometry>::type point_type;
+
+    RingPropertyMap all_ring_properties;
+    dispatch::select_rings<tag, Geometry>::apply(geometry,
+                ring_identifier(0, -1, -1), all_ring_properties,
+                strategy.template get_area_strategy<point_type>());
+
+    update_ring_selection<OverlayType>(geometry, geometry, turn_info_per_ring,
+                all_ring_properties, selected_ring_properties,
+                strategy);
+}
+
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SELECT_RINGS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/self_turn_points.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/self_turn_points.hpp
new file mode 100644
index 00000000000..5e9d8efa8e9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/self_turn_points.hpp
@@ -0,0 +1,354 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SELF_TURN_POINTS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SELF_TURN_POINTS_HPP
+
+
+#include <cstddef>
+
+#include <boost/mpl/vector_c.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/point_order.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/algorithms/detail/disjoint/box_box.hpp>
+#include <boost/geometry/algorithms/detail/partition.hpp>
+#include <boost/geometry/algorithms/detail/overlay/do_reverse.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_turns.hpp>
+#include <boost/geometry/algorithms/detail/sections/section_box_policies.hpp>
+
+#include <boost/geometry/geometries/box.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace self_get_turn_points
+{
+
+struct no_interrupt_policy
+{
+    static bool const enabled = false;
+    static bool const has_intersections = false;
+
+
+    template <typename Range>
+    static inline bool apply(Range const&)
+    {
+        return false;
+    }
+};
+
+
+template
+<
+    bool Reverse,
+    typename Geometry,
+    typename Turns,
+    typename TurnPolicy,
+    typename IntersectionStrategy,
+    typename RobustPolicy,
+    typename InterruptPolicy
+>
+struct self_section_visitor
+{
+    Geometry const& m_geometry;
+    IntersectionStrategy const& m_intersection_strategy;
+    RobustPolicy const& m_rescale_policy;
+    Turns& m_turns;
+    InterruptPolicy& m_interrupt_policy;
+    std::size_t m_source_index;
+
+    inline self_section_visitor(Geometry const& g,
+                                IntersectionStrategy const& is,
+                                RobustPolicy const& rp,
+                                Turns& turns,
+                                InterruptPolicy& ip,
+                                std::size_t source_index)
+        : m_geometry(g)
+        , m_intersection_strategy(is)
+        , m_rescale_policy(rp)
+        , m_turns(turns)
+        , m_interrupt_policy(ip)
+        , m_source_index(source_index)
+    {}
+
+    template <typename Section>
+    inline bool apply(Section const& sec1, Section const& sec2)
+    {
+        if (! detail::disjoint::disjoint_box_box(sec1.bounding_box, sec2.bounding_box)
+                && ! sec1.duplicate
+                && ! sec2.duplicate)
+        {
+            // false if interrupted
+            return detail::get_turns::get_turns_in_sections
+                    <
+                        Geometry, Geometry,
+                        Reverse, Reverse,
+                        Section, Section,
+                        TurnPolicy
+                    >::apply(m_source_index, m_geometry, sec1,
+                             m_source_index, m_geometry, sec2,
+                             false,
+                             m_intersection_strategy,
+                             m_rescale_policy,
+                             m_turns, m_interrupt_policy);
+        }
+
+        return true;
+    }
+
+};
+
+
+
+template <bool Reverse, typename TurnPolicy>
+struct get_turns
+{
+    template <typename Geometry, typename IntersectionStrategy, typename RobustPolicy, typename Turns, typename InterruptPolicy>
+    static inline bool apply(
+            Geometry const& geometry,
+            IntersectionStrategy const& intersection_strategy,
+            RobustPolicy const& robust_policy,
+            Turns& turns,
+            InterruptPolicy& interrupt_policy,
+            std::size_t source_index)
+    {
+        typedef model::box
+            <
+                typename geometry::robust_point_type
+                <
+                    typename geometry::point_type<Geometry>::type,
+                    RobustPolicy
+                >::type
+            > box_type;
+
+        typedef geometry::sections<box_type, 1> sections_type;
+
+        typedef boost::mpl::vector_c<std::size_t, 0> dimensions;
+
+        sections_type sec;
+        geometry::sectionalize<Reverse, dimensions>(geometry, robust_policy, sec,
+                                                  intersection_strategy.get_envelope_strategy());
+
+        self_section_visitor
+            <
+                Reverse, Geometry,
+                Turns, TurnPolicy, IntersectionStrategy, RobustPolicy, InterruptPolicy
+            > visitor(geometry, intersection_strategy, robust_policy, turns, interrupt_policy, source_index);
+
+        // false if interrupted
+        geometry::partition
+            <
+                box_type
+            >::apply(sec, visitor,
+                     detail::section::get_section_box(),
+                     detail::section::overlaps_section_box());
+
+        return ! interrupt_policy.has_intersections;
+    }
+};
+
+
+}} // namespace detail::self_get_turn_points
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    bool Reverse,
+    typename GeometryTag,
+    typename Geometry,
+    typename TurnPolicy
+>
+struct self_get_turn_points
+{
+};
+
+
+template
+<
+    bool Reverse,
+    typename Ring,
+    typename TurnPolicy
+>
+struct self_get_turn_points
+    <
+        Reverse, ring_tag, Ring,
+        TurnPolicy
+    >
+    : detail::self_get_turn_points::get_turns<Reverse, TurnPolicy>
+{};
+
+
+template
+<
+    bool Reverse,
+    typename Box,
+    typename TurnPolicy
+>
+struct self_get_turn_points
+    <
+        Reverse, box_tag, Box,
+        TurnPolicy
+    >
+{
+    template <typename Strategy, typename RobustPolicy, typename Turns, typename InterruptPolicy>
+    static inline bool apply(
+            Box const& ,
+            Strategy const& ,
+            RobustPolicy const& ,
+            Turns& ,
+            InterruptPolicy& ,
+            std::size_t)
+    {
+        return true;
+    }
+};
+
+
+template
+<
+    bool Reverse,
+    typename Polygon,
+    typename TurnPolicy
+>
+struct self_get_turn_points
+    <
+        Reverse, polygon_tag, Polygon,
+        TurnPolicy
+    >
+    : detail::self_get_turn_points::get_turns<Reverse, TurnPolicy>
+{};
+
+
+template
+<
+    bool Reverse,
+    typename MultiPolygon,
+    typename TurnPolicy
+>
+struct self_get_turn_points
+    <
+        Reverse, multi_polygon_tag, MultiPolygon,
+        TurnPolicy
+    >
+    : detail::self_get_turn_points::get_turns<Reverse, TurnPolicy>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace self_get_turn_points
+{
+
+// Version where Reverse can be specified manually. TODO: 
+// can most probably be merged with self_get_turn_points::get_turn
+template
+<
+    bool Reverse,
+    typename AssignPolicy,
+    typename Geometry,
+    typename IntersectionStrategy,
+    typename RobustPolicy,
+    typename Turns,
+    typename InterruptPolicy
+>
+inline void self_turns(Geometry const& geometry,
+                       IntersectionStrategy const& strategy,
+                       RobustPolicy const& robust_policy,
+                       Turns& turns,
+                       InterruptPolicy& interrupt_policy,
+                       std::size_t source_index = 0)
+{
+    concepts::check<Geometry const>();
+
+    typedef detail::overlay::get_turn_info<detail::overlay::assign_null_policy> turn_policy;
+
+    dispatch::self_get_turn_points
+            <
+                Reverse,
+                typename tag<Geometry>::type,
+                Geometry,
+                turn_policy
+            >::apply(geometry, strategy, robust_policy, turns, interrupt_policy, source_index);
+}
+
+}} // namespace detail::self_get_turn_points
+#endif // DOXYGEN_NO_DETAIL
+
+/*!
+    \brief Calculate self intersections of a geometry
+    \ingroup overlay
+    \tparam Geometry geometry type
+    \tparam Turns type of intersection container
+                (e.g. vector of "intersection/turn point"'s)
+    \param geometry geometry
+    \param strategy strategy to be used
+    \param robust_policy policy to handle robustness issues
+    \param turns container which will contain intersection points
+    \param interrupt_policy policy determining if process is stopped
+        when intersection is found
+ */
+template
+<
+    typename AssignPolicy,
+    typename Geometry,
+    typename IntersectionStrategy,
+    typename RobustPolicy,
+    typename Turns,
+    typename InterruptPolicy
+>
+inline void self_turns(Geometry const& geometry,
+                       IntersectionStrategy const& strategy,
+                       RobustPolicy const& robust_policy,
+                       Turns& turns,
+                       InterruptPolicy& interrupt_policy,
+                       std::size_t source_index = 0)
+{
+    concepts::check<Geometry const>();
+
+    static bool const reverse =  detail::overlay::do_reverse
+        <
+            geometry::point_order<Geometry>::value
+        >::value;
+
+    detail::self_get_turn_points::self_turns
+            <
+                reverse,
+                AssignPolicy
+            >(geometry, strategy, robust_policy, turns, interrupt_policy, source_index);
+}
+
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SELF_TURN_POINTS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/sort_by_side.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/sort_by_side.hpp
new file mode 100644
index 00000000000..5ad2e41b126
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/sort_by_side.hpp
@@ -0,0 +1,637 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SORT_BY_SIDE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SORT_BY_SIDE_HPP
+
+#include <algorithm>
+#include <map>
+#include <vector>
+
+#include <boost/geometry/algorithms/num_points.hpp>
+#include <boost/geometry/algorithms/detail/overlay/copy_segment_point.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_ring.hpp>
+#include <boost/geometry/algorithms/detail/direction_code.hpp>
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay { namespace sort_by_side
+{
+
+enum direction_type { dir_unknown = -1, dir_from = 0, dir_to = 1 };
+
+// Point-wrapper, adding some properties
+template <typename Point>
+struct ranked_point
+{
+    ranked_point()
+        : rank(0)
+        , turn_index(-1)
+        , operation_index(-1)
+        , direction(dir_unknown)
+        , count_left(0)
+        , count_right(0)
+        , operation(operation_none)
+    {}
+
+    template <typename Op>
+    ranked_point(const Point& p, signed_size_type ti, int oi,
+                 direction_type d, Op op)
+        : point(p)
+        , rank(0)
+        , zone(-1)
+        , turn_index(ti)
+        , operation_index(oi)
+        , direction(d)
+        , count_left(0)
+        , count_right(0)
+        , operation(op.operation)
+        , seg_id(op.seg_id)
+    {}
+
+    Point point;
+    std::size_t rank;
+    signed_size_type zone; // index of closed zone, in uu turn there would be 2 zones
+    signed_size_type turn_index;
+    int operation_index; // 0,1
+    direction_type direction;
+    std::size_t count_left;
+    std::size_t count_right;
+    operation_type operation;
+    segment_identifier seg_id;
+};
+
+struct less_by_turn_index
+{
+    template <typename T>
+    inline bool operator()(const T& first, const T& second) const
+    {
+        return first.turn_index == second.turn_index
+            ? first.index < second.index
+            : first.turn_index < second.turn_index
+            ;
+    }
+};
+
+struct less_by_index
+{
+    template <typename T>
+    inline bool operator()(const T& first, const T& second) const
+    {
+        // First order by from/to
+        if (first.direction != second.direction)
+        {
+            return first.direction < second.direction;
+        }
+        // All the same, order by turn index (we might consider length too)
+        return first.turn_index < second.turn_index;
+    }
+};
+
+struct less_false
+{
+    template <typename T>
+    inline bool operator()(const T&, const T& ) const
+    {
+        return false;
+    }
+};
+
+template <typename Point, typename SideStrategy, typename LessOnSame, typename Compare>
+struct less_by_side
+{
+    less_by_side(const Point& p1, const Point& p2, SideStrategy const& strategy)
+        : m_p1(p1)
+        , m_p2(p2)
+        , m_strategy(strategy)
+    {}
+
+    template <typename T>
+    inline bool operator()(const T& first, const T& second) const
+    {
+        LessOnSame on_same;
+        Compare compare;
+
+        int const side_first = m_strategy.apply(m_p1, m_p2, first.point);
+        int const side_second = m_strategy.apply(m_p1, m_p2, second.point);
+
+        if (side_first == 0 && side_second == 0)
+        {
+            // Both collinear. They might point into different directions: <------*------>
+            // If so, order the one going backwards as the very first.
+
+            int const first_code = direction_code(m_p1, m_p2, first.point);
+            int const second_code = direction_code(m_p1, m_p2, second.point);
+
+            // Order by code, backwards first, then forward.
+            return first_code != second_code
+                ? first_code < second_code
+                : on_same(first, second)
+                ;
+        }
+        else if (side_first == 0
+                && direction_code(m_p1, m_p2, first.point) == -1)
+        {
+            // First collinear and going backwards.
+            // Order as the very first, so return always true
+            return true;
+        }
+        else if (side_second == 0
+            && direction_code(m_p1, m_p2, second.point) == -1)
+        {
+            // Second is collinear and going backwards
+            // Order as very last, so return always false
+            return false;
+        }
+
+        // They are not both collinear
+
+        if (side_first != side_second)
+        {
+            return compare(side_first, side_second);
+        }
+
+        // They are both left, both right, and/or both collinear (with each other and/or with p1,p2)
+        // Check mutual side
+        int const side_second_wrt_first = m_strategy.apply(m_p2, first.point, second.point);
+
+        if (side_second_wrt_first == 0)
+        {
+            return on_same(first, second);
+        }
+
+        int const side_first_wrt_second = -side_second_wrt_first;
+
+        // Both are on same side, and not collinear
+        // Union: return true if second is right w.r.t. first, so -1,
+        // so other is 1. union has greater as compare functor
+        // Intersection: v.v.
+        return compare(side_first_wrt_second, side_second_wrt_first);
+    }
+
+private :
+    Point m_p1, m_p2;
+    SideStrategy const& m_strategy;
+};
+
+// Sorts vectors in counter clockwise order (by default)
+template
+<
+    bool Reverse1,
+    bool Reverse2,
+    overlay_type OverlayType,
+    typename Point,
+    typename SideStrategy,
+    typename Compare
+>
+struct side_sorter
+{
+    typedef ranked_point<Point> rp;
+
+private :
+    struct include_union
+    {
+        inline bool operator()(rp const& ranked_point) const
+        {
+            // New candidate if there are no polygons on left side,
+            // but there are on right side
+            return ranked_point.count_left == 0
+                && ranked_point.count_right > 0;
+        }
+    };
+
+    struct include_intersection
+    {
+        inline bool operator()(rp const& ranked_point) const
+        {
+            // New candidate if there are two polygons on right side,
+            // and less on the left side
+            return ranked_point.count_left < 2
+                && ranked_point.count_right >= 2;
+        }
+    };
+
+public :
+    side_sorter(SideStrategy const& strategy)
+        : m_origin_count(0)
+        , m_origin_segment_distance(0)
+        , m_strategy(strategy)
+    {}
+
+    template <typename Operation, typename Geometry1, typename Geometry2>
+    Point add(Operation const& op, signed_size_type turn_index, signed_size_type op_index,
+            Geometry1 const& geometry1,
+            Geometry2 const& geometry2,
+            bool is_origin)
+    {
+        Point point1, point2, point3;
+        geometry::copy_segment_points<Reverse1, Reverse2>(geometry1, geometry2,
+                op.seg_id, point1, point2, point3);
+        Point const& point_to = op.fraction.is_one() ? point3 : point2;
+
+        m_ranked_points.push_back(rp(point1, turn_index, op_index, dir_from, op));
+        m_ranked_points.push_back(rp(point_to, turn_index, op_index, dir_to, op));
+        if (is_origin)
+        {
+            m_origin = point1;
+            m_origin_count++;
+        }
+        return point1;
+    }
+
+    template <typename Operation, typename Geometry1, typename Geometry2>
+    void add(Operation const& op, signed_size_type turn_index, signed_size_type op_index,
+            segment_identifier const& departure_seg_id,
+            Geometry1 const& geometry1,
+            Geometry2 const& geometry2,
+            bool check_origin)
+    {
+        Point const point1 = add(op, turn_index, op_index, geometry1, geometry2, false);
+
+        if (check_origin)
+        {
+            bool const is_origin
+                    = op.seg_id.source_index == departure_seg_id.source_index
+                    && op.seg_id.ring_index == departure_seg_id.ring_index
+                    && op.seg_id.multi_index == departure_seg_id.multi_index;
+
+            if (is_origin)
+            {
+                int const segment_distance = calculate_segment_distance(op, departure_seg_id, geometry1, geometry2);
+                if (m_origin_count == 0 ||
+                        segment_distance < m_origin_segment_distance)
+                {
+                    m_origin = point1;
+                    m_origin_segment_distance = segment_distance;
+                }
+                m_origin_count++;
+            }
+        }
+    }
+
+    template <typename Operation, typename Geometry1, typename Geometry2>
+    static int calculate_segment_distance(Operation const& op,
+            segment_identifier const& departure_seg_id,
+            Geometry1 const& geometry1,
+            Geometry2 const& geometry2)
+    {
+        if (op.seg_id.segment_index >= departure_seg_id.segment_index)
+        {
+            return op.seg_id.segment_index - departure_seg_id.segment_index;
+        }
+        // Take wrap into account
+        // Suppose ring_count=10 (10 points, 9 segments), dep.seg_id=7, op.seg_id=2, then distance=10-9+2
+        // Generic function (is this used somewhere else too?)
+        ring_identifier const rid(op.seg_id.source_index, op.seg_id.multi_index, op.seg_id.ring_index);
+        int const segment_count
+                    (op.seg_id.source_index == 0
+                    ? geometry::num_points(detail::overlay::get_ring<typename geometry::tag<Geometry1>::type>::apply(rid, geometry1))
+                    : geometry::num_points(detail::overlay::get_ring<typename geometry::tag<Geometry2>::type>::apply(rid, geometry2)));
+        return ((segment_count - 1) - departure_seg_id.segment_index) + op.seg_id.segment_index;
+    }
+
+    void apply(Point const& turn_point)
+    {
+        // We need three compare functors:
+        // 1) to order clockwise (union) or counter clockwise (intersection)
+        // 2) to order by side, resulting in unique ranks for all points
+        // 3) to order by side, resulting in non-unique ranks
+        //    to give colinear points
+
+        // Sort by side and assign rank
+        less_by_side<Point, SideStrategy, less_by_index, Compare> less_unique(m_origin, turn_point, m_strategy);
+        less_by_side<Point, SideStrategy, less_false, Compare> less_non_unique(m_origin, turn_point, m_strategy);
+
+        std::sort(m_ranked_points.begin(), m_ranked_points.end(), less_unique);
+
+        std::size_t colinear_rank = 0;
+        for (std::size_t i = 0; i < m_ranked_points.size(); i++)
+        {
+            if (i > 0
+                && less_non_unique(m_ranked_points[i - 1], m_ranked_points[i]))
+            {
+                // It is not collinear
+                colinear_rank++;
+            }
+
+            m_ranked_points[i].rank = colinear_rank;
+        }
+    }
+
+    template <signed_size_type segment_identifier::*Member, typename Map>
+    void find_open_generic(Map& handled, bool check)
+    {
+        for (std::size_t i = 0; i < m_ranked_points.size(); i++)
+        {
+            const rp& ranked = m_ranked_points[i];
+            if (ranked.direction != dir_from)
+            {
+                continue;
+            }
+
+            signed_size_type const& index = ranked.seg_id.*Member;
+            if (check && (index < 0 || index > 1))
+            {
+                // Should not occur
+                continue;
+            }
+            if (! handled[index])
+            {
+                find_polygons_for_source<Member>(index, i);
+                handled[index] = true;
+            }
+        }
+    }
+
+    void find_open()
+    {
+        if (OverlayType == overlay_buffer)
+        {
+            // For buffers, use piece index
+            std::map<signed_size_type, bool> handled;
+            find_open_generic
+                <
+                    &segment_identifier::piece_index
+                >(handled, false);
+        }
+        else
+        {
+            // For other operations, by source (there should only source 0,1)
+            bool handled[2] = {false, false};
+            find_open_generic
+                <
+                    &segment_identifier::source_index
+                >(handled, true);
+        }
+    }
+
+    void reverse()
+    {
+        if (m_ranked_points.empty())
+        {
+            return;
+        }
+
+        std::size_t const last = 1 + m_ranked_points.back().rank;
+
+        // Move iterator after rank==0
+        bool has_first = false;
+        typename container_type::iterator it = m_ranked_points.begin() + 1;
+        for (; it != m_ranked_points.end() && it->rank == 0; ++it)
+        {
+            has_first = true;
+        }
+
+        if (has_first)
+        {
+            // Reverse first part (having rank == 0), if any,
+            // but skip the very first row
+            std::reverse(m_ranked_points.begin() + 1, it);
+            for (typename container_type::iterator fit = m_ranked_points.begin();
+                 fit != it; ++fit)
+            {
+                BOOST_ASSERT(fit->rank == 0);
+            }
+        }
+
+        // Reverse the rest (main rank > 0)
+        std::reverse(it, m_ranked_points.end());
+        for (; it != m_ranked_points.end(); ++it)
+        {
+            BOOST_ASSERT(it->rank > 0);
+            it->rank = last - it->rank;
+        }
+    }
+
+    bool has_origin() const
+    {
+        return m_origin_count > 0;
+    }
+
+//private :
+
+    typedef std::vector<rp> container_type;
+    container_type m_ranked_points;
+    Point m_origin;
+    std::size_t m_origin_count;
+    int m_origin_segment_distance;
+    SideStrategy m_strategy;
+
+private :
+
+    //! Check how many open spaces there are
+    template <typename Include>
+    inline std::size_t open_count(Include const& include_functor) const
+    {
+        std::size_t result = 0;
+        std::size_t last_rank = 0;
+        for (std::size_t i = 0; i < m_ranked_points.size(); i++)
+        {
+            rp const& ranked_point = m_ranked_points[i];
+
+            if (ranked_point.rank > last_rank
+                && ranked_point.direction == sort_by_side::dir_to
+                && include_functor(ranked_point))
+            {
+                result++;
+                last_rank = ranked_point.rank;
+            }
+        }
+        return result;
+    }
+
+    std::size_t move(std::size_t index) const
+    {
+        std::size_t const result = index + 1;
+        return result >= m_ranked_points.size() ? 0 : result;
+    }
+
+    //! member is pointer to member (source_index or multi_index)
+    template <signed_size_type segment_identifier::*Member>
+    std::size_t move(signed_size_type member_index, std::size_t index) const
+    {
+        std::size_t result = move(index);
+        while (m_ranked_points[result].seg_id.*Member != member_index)
+        {
+            result = move(result);
+        }
+        return result;
+    }
+
+    void assign_ranks(std::size_t min_rank, std::size_t max_rank, int side_index)
+    {
+        for (std::size_t i = 0; i < m_ranked_points.size(); i++)
+        {
+            rp& ranked = m_ranked_points[i];
+            // Suppose there are 8 ranks, if min=4,max=6: assign 4,5,6
+            // if min=5,max=2: assign from 5,6,7,1,2
+            bool const in_range
+                = max_rank >= min_rank
+                ? ranked.rank >= min_rank && ranked.rank <= max_rank
+                : ranked.rank >= min_rank || ranked.rank <= max_rank
+                ;
+
+            if (in_range)
+            {
+                if (side_index == 1)
+                {
+                    ranked.count_left++;
+                }
+                else if (side_index == 2)
+                {
+                    ranked.count_right++;
+                }
+            }
+        }
+    }
+
+    template <signed_size_type segment_identifier::*Member>
+    void find_polygons_for_source(signed_size_type the_index,
+                std::size_t start_index)
+    {
+        bool in_polygon = true; // Because start_index is "from", arrives at the turn
+        rp const& start_rp = m_ranked_points[start_index];
+        std::size_t last_from_rank = start_rp.rank;
+        std::size_t previous_rank = start_rp.rank;
+
+        for (std::size_t index = move<Member>(the_index, start_index);
+             ;
+             index = move<Member>(the_index, index))
+        {
+            rp& ranked = m_ranked_points[index];
+
+            if (ranked.rank != previous_rank && ! in_polygon)
+            {
+                assign_ranks(last_from_rank, previous_rank - 1, 1);
+                assign_ranks(last_from_rank + 1, previous_rank, 2);
+            }
+
+            if (index == start_index)
+            {
+                return;
+            }
+
+            if (ranked.direction == dir_from)
+            {
+                last_from_rank = ranked.rank;
+                in_polygon = true;
+            }
+            else if (ranked.direction == dir_to)
+            {
+                in_polygon = false;
+            }
+
+            previous_rank = ranked.rank;
+        }
+    }
+
+    //! Find closed zones and assign it
+    template <typename Include>
+    std::size_t assign_zones(Include const& include_functor)
+    {
+        // Find a starting point (the first rank after an outgoing rank
+        // with no polygons on the left side)
+        std::size_t start_rank = m_ranked_points.size() + 1;
+        std::size_t start_index = 0;
+        std::size_t max_rank = 0;
+        for (std::size_t i = 0; i < m_ranked_points.size(); i++)
+        {
+            rp const& ranked_point = m_ranked_points[i];
+            if (ranked_point.rank > max_rank)
+            {
+                max_rank = ranked_point.rank;
+            }
+            if (ranked_point.direction == sort_by_side::dir_to
+                && include_functor(ranked_point))
+            {
+                start_rank = ranked_point.rank + 1;
+            }
+            if (ranked_point.rank == start_rank && start_index == 0)
+            {
+                start_index = i;
+            }
+        }
+
+        // Assign the zones
+        std::size_t const undefined_rank = max_rank + 1;
+        std::size_t zone_id = 0;
+        std::size_t last_rank = 0;
+        std::size_t rank_at_next_zone = undefined_rank;
+        std::size_t index = start_index;
+        for (std::size_t i = 0; i < m_ranked_points.size(); i++)
+        {
+            rp& ranked_point = m_ranked_points[index];
+
+            // Implement cyclic behavior
+            index++;
+            if (index == m_ranked_points.size())
+            {
+                index = 0;
+            }
+
+            if (ranked_point.rank != last_rank)
+            {
+                if (ranked_point.rank == rank_at_next_zone)
+                {
+                    zone_id++;
+                    rank_at_next_zone = undefined_rank;
+                }
+
+                if (ranked_point.direction == sort_by_side::dir_to
+                    && include_functor(ranked_point))
+                {
+                    rank_at_next_zone = ranked_point.rank + 1;
+                    if (rank_at_next_zone > max_rank)
+                    {
+                        rank_at_next_zone = 0;
+                    }
+                }
+
+                last_rank = ranked_point.rank;
+            }
+
+            ranked_point.zone = zone_id;
+        }
+        return zone_id;
+    }
+
+public :
+    inline std::size_t open_count(operation_type for_operation) const
+    {
+        return for_operation == operation_union
+            ? open_count(include_union())
+            : open_count(include_intersection())
+            ;
+    }
+
+    inline std::size_t assign_zones(operation_type for_operation)
+    {
+        return for_operation == operation_union
+            ? assign_zones(include_union())
+            : assign_zones(include_intersection())
+            ;
+    }
+
+};
+
+
+}}} // namespace detail::overlay::sort_by_side
+#endif //DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_SORT_BY_SIDE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/stream_info.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/stream_info.hpp
new file mode 100644
index 00000000000..51fd1b3dca6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/stream_info.hpp
@@ -0,0 +1,74 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_STREAM_INFO_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_STREAM_INFO_HPP
+
+
+#include <string>
+
+#include <boost/array.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+    static inline std::string dir(int d)
+    {
+        return d == 0 ? "-" : (d == 1 ? "L" : d == -1 ? "R" : "#");
+    }
+    static inline std::string how_str(int h)
+    {
+        return h == 0 ? "-" : (h == 1 ? "A" : "D");
+    }
+
+    template <typename P>
+    std::ostream& operator<<(std::ostream &os, turn_info<P> const& info)
+    {
+        os  << "\t"
+            << " src " << info.seg_id.source_index
+            << " seg " << info.seg_id.segment_index
+            << " (// " << info.other_id.source_index
+                << "." << info.other_id.segment_index << ")"
+            << " how " << info.how
+                << "[" << how_str(info.arrival)
+                << " " << dir(info.direction)
+                << (info.opposite ? " o" : "")
+                << "]"
+            << " sd "
+                << dir(info.sides.get<0,0>())
+                << dir(info.sides.get<0,1>())
+                << dir(info.sides.get<1,0>())
+                << dir(info.sides.get<1,1>())
+            << " nxt seg " << info.travels_to_vertex_index
+            << " , ip " << info.travels_to_ip_index
+            << " , or " << info.next_ip_index
+            << " frac " << info.fraction
+            << info.visit_state;
+        if (info.flagged)
+        {
+            os << " FLAGGED";
+        }
+        return os;
+    }
+
+
+
+}} // namespace detail::overlay
+#endif //DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_STREAM_INFO_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traversal.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traversal.hpp
new file mode 100644
index 00000000000..69d62b788b7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traversal.hpp
@@ -0,0 +1,847 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_HPP
+
+#include <cstddef>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/aggregate_operations.hpp>
+#include <boost/geometry/algorithms/detail/overlay/is_self_turn.hpp>
+#include <boost/geometry/algorithms/detail/overlay/sort_by_side.hpp>
+#include <boost/geometry/algorithms/detail/overlay/traversal_intersection_patterns.hpp>
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/assert.hpp>
+
+#if defined(BOOST_GEOMETRY_DEBUG_INTERSECTION) \
+    || defined(BOOST_GEOMETRY_OVERLAY_REPORT_WKT) \
+    || defined(BOOST_GEOMETRY_DEBUG_TRAVERSE)
+#  include <string>
+#  include <boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp>
+#  include <boost/geometry/io/wkt/wkt.hpp>
+#endif
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+template <typename Turn, typename Operation>
+#ifdef BOOST_GEOMETRY_DEBUG_TRAVERSE
+inline void debug_traverse(Turn const& turn, Operation op,
+                std::string const& header, bool condition = true)
+{
+    if (! condition)
+    {
+        return;
+    }
+    std::cout << " " << header
+        << " at " << op.seg_id
+        << " meth: " << method_char(turn.method)
+        << " op: " << operation_char(op.operation)
+        << " vis: " << visited_char(op.visited)
+        << " of:  " << operation_char(turn.operations[0].operation)
+        << operation_char(turn.operations[1].operation)
+        << " " << geometry::wkt(turn.point)
+        << std::endl;
+
+    if (boost::contains(header, "Finished"))
+    {
+        std::cout << std::endl;
+    }
+}
+#else
+inline void debug_traverse(Turn const& , Operation, const char*, bool = true)
+{
+}
+#endif
+
+
+//! Metafunction to define side_order (clockwise, ccw) by operation_type
+template <operation_type OpType>
+struct side_compare {};
+
+template <>
+struct side_compare<operation_union>
+{
+    typedef std::greater<int> type;
+};
+
+template <>
+struct side_compare<operation_intersection>
+{
+    typedef std::less<int> type;
+};
+
+
+template
+<
+    bool Reverse1,
+    bool Reverse2,
+    overlay_type OverlayType,
+    typename Geometry1,
+    typename Geometry2,
+    typename Turns,
+    typename Clusters,
+    typename RobustPolicy,
+    typename SideStrategy,
+    typename Visitor
+>
+struct traversal
+{
+    static const operation_type target_operation = operation_from_overlay<OverlayType>::value;
+
+    typedef typename side_compare<target_operation>::type side_compare_type;
+    typedef typename boost::range_value<Turns>::type turn_type;
+    typedef typename turn_type::turn_operation_type turn_operation_type;
+
+    typedef typename geometry::point_type<Geometry1>::type point_type;
+    typedef sort_by_side::side_sorter
+        <
+            Reverse1, Reverse2, OverlayType,
+            point_type, SideStrategy, side_compare_type
+        > sbs_type;
+
+    inline traversal(Geometry1 const& geometry1, Geometry2 const& geometry2,
+            Turns& turns, Clusters const& clusters,
+            RobustPolicy const& robust_policy, SideStrategy const& strategy,
+            Visitor& visitor)
+        : m_geometry1(geometry1)
+        , m_geometry2(geometry2)
+        , m_turns(turns)
+        , m_clusters(clusters)
+        , m_robust_policy(robust_policy)
+        , m_strategy(strategy)
+        , m_visitor(visitor)
+    {
+    }
+
+    inline void finalize_visit_info()
+    {
+        for (typename boost::range_iterator<Turns>::type
+            it = boost::begin(m_turns);
+            it != boost::end(m_turns);
+            ++it)
+        {
+            turn_type& turn = *it;
+            for (int i = 0; i < 2; i++)
+            {
+                turn_operation_type& op = turn.operations[i];
+                op.visited.finalize();
+            }
+        }
+    }
+
+    //! Sets visited for ALL turns traveling to the same turn
+    inline void set_visited_in_cluster(signed_size_type cluster_id,
+                                       signed_size_type rank)
+    {
+        typename Clusters::const_iterator mit = m_clusters.find(cluster_id);
+        BOOST_ASSERT(mit != m_clusters.end());
+
+        cluster_info const& cinfo = mit->second;
+        std::set<signed_size_type> const& ids = cinfo.turn_indices;
+
+        for (typename std::set<signed_size_type>::const_iterator it = ids.begin();
+             it != ids.end(); ++it)
+        {
+            signed_size_type const turn_index = *it;
+            turn_type& turn = m_turns[turn_index];
+
+            for (int i = 0; i < 2; i++)
+            {
+                turn_operation_type& op = turn.operations[i];
+                if (op.visited.none()
+                    && op.enriched.rank == rank)
+                {
+                    op.visited.set_visited();
+                }
+            }
+        }
+    }
+    inline void set_visited(turn_type& turn, turn_operation_type& op)
+    {
+        if (op.operation == detail::overlay::operation_continue)
+        {
+            // On "continue", all go in same direction so set "visited" for ALL
+            for (int i = 0; i < 2; i++)
+            {
+                turn_operation_type& turn_op = turn.operations[i];
+                if (turn_op.visited.none())
+                {
+                    turn_op.visited.set_visited();
+                }
+            }
+        }
+        else
+        {
+            op.visited.set_visited();
+        }
+        if (turn.cluster_id >= 0)
+        {
+            set_visited_in_cluster(turn.cluster_id, op.enriched.rank);
+        }
+    }
+
+    inline bool is_visited(turn_type const& , turn_operation_type const& op,
+                         signed_size_type , int) const
+    {
+        return op.visited.visited();
+    }
+
+    inline bool select_source(signed_size_type turn_index,
+                              segment_identifier const& candidate_seg_id,
+                              segment_identifier const& previous_seg_id) const
+    {
+        // For uu/ii, only switch sources if indicated
+        turn_type const& turn = m_turns[turn_index];
+
+        if (OverlayType == overlay_buffer)
+        {
+            // Buffer does not use source_index (always 0)
+            return turn.switch_source
+                    ? candidate_seg_id.multi_index != previous_seg_id.multi_index
+                    : candidate_seg_id.multi_index == previous_seg_id.multi_index;
+        }
+
+        if (is_self_turn<OverlayType>(turn))
+        {
+            // Also, if it is a self-turn, stay on same ring (multi/ring)
+            return turn.switch_source
+                    ? candidate_seg_id.multi_index != previous_seg_id.multi_index
+                    : candidate_seg_id.multi_index == previous_seg_id.multi_index;
+        }
+
+#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSAL_SWITCH_DETECTOR)
+        if (turn.switch_source)
+        {
+            std::cout << "Switch source at " << turn_index << std::endl;
+        }
+        else
+        {
+            std::cout << "DON'T SWITCH SOURCES at " << turn_index << std::endl;
+        }
+#endif
+        return turn.switch_source
+                ? candidate_seg_id.source_index != previous_seg_id.source_index
+                : candidate_seg_id.source_index == previous_seg_id.source_index;
+    }
+
+    inline bool traverse_possible(signed_size_type turn_index) const
+    {
+        if (turn_index == -1)
+        {
+            return false;
+        }
+
+        turn_type const& turn = m_turns[turn_index];
+
+        // It is not a dead end if there is an operation to continue, or of
+        // there is a cluster (assuming for now we can get out of the cluster)
+        return turn.cluster_id >= 0
+            || turn.has(target_operation)
+            || turn.has(operation_continue);
+    }
+
+    inline
+    bool select_cc_operation(turn_type const& turn,
+                signed_size_type start_turn_index,
+                int& selected_op_index) const
+    {
+        // For "cc", take either one, but if there is a starting one,
+        //           take that one. If next is dead end, skip that one.
+        // If both are valid candidates, take the one with minimal remaining
+        // distance (important for #mysql_23023665 in buffer).
+
+        // Initialize with 0, automatically assigned on first result
+        typename turn_operation_type::comparable_distance_type
+                min_remaining_distance = 0;
+
+        bool result = false;
+
+        for (int i = 0; i < 2; i++)
+        {
+            turn_operation_type const& op = turn.operations[i];
+
+            signed_size_type const next_turn_index = op.enriched.get_next_turn_index();
+
+            if (! traverse_possible(next_turn_index))
+            {
+                continue;
+            }
+
+            if (! result
+                || next_turn_index == start_turn_index
+                || op.remaining_distance < min_remaining_distance)
+            {
+                debug_traverse(turn, op, "First candidate cc", ! result);
+                debug_traverse(turn, op, "Candidate cc override (start)",
+                    result && next_turn_index == start_turn_index);
+                debug_traverse(turn, op, "Candidate cc override (remaining)",
+                    result && op.remaining_distance < min_remaining_distance);
+
+                selected_op_index = i;
+                min_remaining_distance = op.remaining_distance;
+                result = true;
+            }
+        }
+
+        return result;
+    }
+
+    inline
+    bool select_noncc_operation(turn_type const& turn,
+                signed_size_type turn_index,
+                segment_identifier const& previous_seg_id,
+                int& selected_op_index) const
+    {
+        bool result = false;
+
+        for (int i = 0; i < 2; i++)
+        {
+            turn_operation_type const& op = turn.operations[i];
+
+            if (op.operation == target_operation
+                && ! op.visited.finished()
+                && (! result || select_source(turn_index, op.seg_id, previous_seg_id)))
+            {
+                selected_op_index = i;
+                debug_traverse(turn, op, "Candidate");
+                result = true;
+            }
+        }
+
+        return result;
+    }
+
+    inline
+    bool select_operation(const turn_type& turn,
+                signed_size_type turn_index,
+                signed_size_type start_turn_index,
+                segment_identifier const& previous_seg_id,
+                int& selected_op_index) const
+    {
+        bool result = false;
+        selected_op_index = -1;
+        if (turn.both(operation_continue))
+        {
+            result = select_cc_operation(turn, start_turn_index,
+                                         selected_op_index);
+        }
+        else
+        {
+            result = select_noncc_operation(turn, turn_index,
+                                            previous_seg_id, selected_op_index);
+        }
+        if (result)
+        {
+           debug_traverse(turn, turn.operations[selected_op_index], "Accepted");
+        }
+
+        return result;
+    }
+
+    inline int starting_operation_index(const turn_type& turn) const
+    {
+        for (int i = 0; i < 2; i++)
+        {
+            if (turn.operations[i].visited.started())
+            {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    inline bool both_finished(const turn_type& turn) const
+    {
+        for (int i = 0; i < 2; i++)
+        {
+            if (! turn.operations[i].visited.finished())
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    inline bool select_from_cluster_union(signed_size_type& turn_index,
+        int& op_index, sbs_type& sbs) const
+    {
+        std::vector<sort_by_side::rank_with_rings> aggregation;
+        sort_by_side::aggregate_operations(sbs, aggregation, m_turns, operation_union);
+
+
+        sort_by_side::rank_with_rings const& incoming = aggregation.front();
+
+        // Take the first one outgoing for the incoming region
+        std::size_t selected_rank = 0;
+        for (std::size_t i = 1; i < aggregation.size(); i++)
+        {
+            sort_by_side::rank_with_rings const& rwr = aggregation[i];
+            if (rwr.all_to()
+                    && rwr.region_id() == incoming.region_id())
+            {
+                selected_rank = rwr.rank;
+                break;
+            }
+        }
+
+        for (std::size_t i = 1; i < sbs.m_ranked_points.size(); i++)
+        {
+            typename sbs_type::rp const& ranked_point = sbs.m_ranked_points[i];
+            if (ranked_point.rank == selected_rank
+                    && ranked_point.direction == sort_by_side::dir_to)
+            {
+                turn_index = ranked_point.turn_index;
+                op_index = ranked_point.operation_index;
+
+                turn_type const& turn = m_turns[turn_index];
+                turn_operation_type const& op = turn.operations[op_index];
+
+                if (op.enriched.count_left == 0
+                    && op.enriched.count_right > 0
+                    && ! op.visited.finalized())
+                {
+                    // In some cases interior rings might be generated with polygons
+                    // on both sides
+
+                    // TODO: this should be finetuned such that checking
+                    // finalized is not necessary
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+
+    inline bool all_operations_of_type(sort_by_side::rank_with_rings const& rwr,
+                                       operation_type op_type,
+                                       sort_by_side::direction_type dir) const
+    {
+        typedef std::set<sort_by_side::ring_with_direction>::const_iterator sit_type;
+        for (sit_type it = rwr.rings.begin(); it != rwr.rings.end(); ++it)
+        {
+            sort_by_side::ring_with_direction const& rwd = *it;
+            if (rwd.direction != dir)
+            {
+                return false;
+            }
+            turn_type const& turn = m_turns[rwd.turn_index];
+            if (! turn.both(op_type))
+            {
+                return false;
+            }
+
+            // Check if this is not yet taken
+            turn_operation_type const& op = turn.operations[rwd.operation_index];
+            if (op.visited.finalized())
+            {
+                return false;
+            }
+
+        }
+        return true;
+    }
+
+    inline bool analyze_cluster_intersection(signed_size_type& turn_index,
+                int& op_index, sbs_type const& sbs) const
+    {
+        std::vector<sort_by_side::rank_with_rings> aggregation;
+        sort_by_side::aggregate_operations(sbs, aggregation, m_turns, operation_intersection);
+
+        std::size_t selected_rank = 0;
+
+
+        // Detect specific pattern(s)
+        bool const detected
+            = intersection_pattern_common_interior1(selected_rank, aggregation)
+            || intersection_pattern_common_interior2(selected_rank, aggregation)
+            || intersection_pattern_common_interior3(selected_rank, aggregation)
+            || intersection_pattern_common_interior4(selected_rank, aggregation)
+                ;
+
+        if (! detected)
+        {
+            int incoming_region_id = 0;
+            std::set<int> outgoing_region_ids;
+
+            for (std::size_t i = 0; i < aggregation.size(); i++)
+            {
+                sort_by_side::rank_with_rings const& rwr = aggregation[i];
+
+                if (rwr.all_to()
+                        && rwr.traversable(m_turns)
+                        && selected_rank == 0)
+                {
+                    // Take the first (= right) where segments leave,
+                    // having the polygon on the right side
+                    selected_rank = rwr.rank;
+                }
+
+                if (rwr.all_from()
+                        && selected_rank > 0
+                        && outgoing_region_ids.empty())
+                {
+                    // Incoming
+                    break;
+                }
+
+                if (incoming_region_id == 0)
+                {
+                    sort_by_side::ring_with_direction const& rwd = *rwr.rings.begin();
+                    turn_type const& turn = m_turns[rwd.turn_index];
+                    incoming_region_id = turn.operations[rwd.operation_index].enriched.region_id;
+                }
+                else
+                {
+                    if (rwr.rings.size() == 1)
+                    {
+                        sort_by_side::ring_with_direction const& rwd = *rwr.rings.begin();
+                        turn_type const& turn = m_turns[rwd.turn_index];
+                        if (rwd.direction == sort_by_side::dir_to
+                                && turn.both(operation_intersection))
+                        {
+
+                            turn_operation_type const& op = turn.operations[rwd.operation_index];
+                            if (op.enriched.region_id != incoming_region_id
+                                    && op.enriched.isolated)
+                            {
+                                outgoing_region_ids.insert(op.enriched.region_id);
+                            }
+                        }
+                        else if (! outgoing_region_ids.empty())
+                        {
+                            for (int i = 0; i < 2; i++)
+                            {
+                                int const region_id = turn.operations[i].enriched.region_id;
+                                if (outgoing_region_ids.count(region_id) == 1)
+                                {
+                                    selected_rank = 0;
+                                    outgoing_region_ids.erase(region_id);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if (selected_rank > 0)
+        {
+            std::size_t selected_index = sbs.m_ranked_points.size();
+            for (std::size_t i = 0; i < sbs.m_ranked_points.size(); i++)
+            {
+                typename sbs_type::rp const& ranked_point = sbs.m_ranked_points[i];
+
+                if (ranked_point.rank == selected_rank)
+                {
+                    turn_type const& ranked_turn = m_turns[ranked_point.turn_index];
+                    turn_operation_type const& ranked_op = ranked_turn.operations[ranked_point.operation_index];
+
+                    if (ranked_op.visited.finalized())
+                    {
+                        // This direction is already traveled before, the same
+                        // cannot be traveled again
+                        continue;
+                    }
+
+                    // Take the last turn from this rank
+                    selected_index = i;
+                }
+            }
+
+            if (selected_index < sbs.m_ranked_points.size())
+            {
+                typename sbs_type::rp const& ranked_point = sbs.m_ranked_points[selected_index];
+                turn_index = ranked_point.turn_index;
+                op_index = ranked_point.operation_index;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    inline bool select_turn_from_cluster(signed_size_type& turn_index,
+            int& op_index,
+            signed_size_type start_turn_index,
+            segment_identifier const& previous_seg_id) const
+    {
+        bool const is_union = target_operation == operation_union;
+
+        turn_type const& turn = m_turns[turn_index];
+        BOOST_ASSERT(turn.cluster_id >= 0);
+
+        typename Clusters::const_iterator mit = m_clusters.find(turn.cluster_id);
+        BOOST_ASSERT(mit != m_clusters.end());
+
+        cluster_info const& cinfo = mit->second;
+        std::set<signed_size_type> const& ids = cinfo.turn_indices;
+
+        sbs_type sbs(m_strategy);
+
+        for (typename std::set<signed_size_type>::const_iterator sit = ids.begin();
+             sit != ids.end(); ++sit)
+        {
+            signed_size_type cluster_turn_index = *sit;
+            turn_type const& cluster_turn = m_turns[cluster_turn_index];
+            bool const departure_turn = cluster_turn_index == turn_index;
+            if (cluster_turn.discarded)
+            {
+                // Defensive check, discarded turns should not be in cluster
+                continue;
+            }
+
+            for (int i = 0; i < 2; i++)
+            {
+                sbs.add(cluster_turn.operations[i],
+                        cluster_turn_index, i, previous_seg_id,
+                        m_geometry1, m_geometry2,
+                        departure_turn);
+            }
+        }
+
+        if (! sbs.has_origin())
+        {
+            return false;
+        }
+        sbs.apply(turn.point);
+
+        bool result = false;
+
+        if (is_union)
+        {
+            result = select_from_cluster_union(turn_index, op_index, sbs);
+        }
+        else
+        {
+            result = analyze_cluster_intersection(turn_index, op_index, sbs);
+        }
+        return result;
+    }
+
+    inline bool analyze_ii_intersection(signed_size_type& turn_index, int& op_index,
+                    turn_type const& current_turn,
+                    segment_identifier const& previous_seg_id)
+    {
+        sbs_type sbs(m_strategy);
+
+        // Add this turn to the sort-by-side sorter
+        for (int i = 0; i < 2; i++)
+        {
+            sbs.add(current_turn.operations[i],
+                    turn_index, i, previous_seg_id,
+                    m_geometry1, m_geometry2,
+                    true);
+        }
+
+        if (! sbs.has_origin())
+        {
+            return false;
+        }
+
+        sbs.apply(current_turn.point);
+
+        bool result = analyze_cluster_intersection(turn_index, op_index, sbs);
+
+        return result;
+    }
+
+    inline void change_index_for_self_turn(signed_size_type& to_vertex_index,
+                turn_type const& start_turn,
+                turn_operation_type const& start_op,
+                int start_op_index) const
+    {
+        if (OverlayType != overlay_buffer)
+        {
+            return;
+        }
+
+        // It travels to itself, can happen. If this is a buffer, it can
+        // sometimes travel to itself in the following configuration:
+        //
+        // +---->--+
+        // |       |
+        // |   +---*----+ *: one turn, with segment index 2/7
+        // |   |   |    |
+        // |   +---C    | C: closing point (start/end)
+        // |            |
+        // +------------+
+        //
+        // If it starts on segment 2 and travels to itself on segment 2, that
+        // should be corrected to 7 because that is the shortest path
+        //
+        // Also a uu turn (touching with another buffered ring) might have this
+        // apparent configuration, but there it should
+        // always travel the whole ring
+
+        turn_operation_type const& other_op
+                = start_turn.operations[1 - start_op_index];
+
+        bool const correct
+                = ! start_turn.both(operation_union)
+                  && start_op.seg_id.segment_index == to_vertex_index;
+
+#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSE)
+        std::cout << " WARNING: self-buffer "
+                  << " correct=" << correct
+                  << " turn=" << operation_char(start_turn.operations[0].operation)
+                  << operation_char(start_turn.operations[1].operation)
+                  << " start=" << start_op.seg_id.segment_index
+                  << " from=" << to_vertex_index
+                  << " to=" << other_op.enriched.travels_to_vertex_index
+                  << std::endl;
+#endif
+
+        if (correct)
+        {
+            to_vertex_index = other_op.enriched.travels_to_vertex_index;
+        }
+    }
+
+    bool select_turn_from_enriched(signed_size_type& turn_index,
+            segment_identifier& previous_seg_id,
+            signed_size_type& to_vertex_index,
+            signed_size_type start_turn_index,
+            int start_op_index,
+            turn_type const& previous_turn,
+            turn_operation_type const& previous_op,
+            bool is_start) const
+    {
+        to_vertex_index = -1;
+
+        if (previous_op.enriched.next_ip_index < 0)
+        {
+            // There is no next IP on this segment
+            if (previous_op.enriched.travels_to_vertex_index < 0
+                || previous_op.enriched.travels_to_ip_index < 0)
+            {
+                return false;
+            }
+
+            to_vertex_index = previous_op.enriched.travels_to_vertex_index;
+
+            if (is_start &&
+                    previous_op.enriched.travels_to_ip_index == start_turn_index)
+            {
+                change_index_for_self_turn(to_vertex_index, previous_turn,
+                    previous_op, start_op_index);
+            }
+
+            turn_index = previous_op.enriched.travels_to_ip_index;
+            previous_seg_id = previous_op.seg_id;
+        }
+        else
+        {
+            // Take the next IP on this segment
+            turn_index = previous_op.enriched.next_ip_index;
+            previous_seg_id = previous_op.seg_id;
+        }
+        return true;
+    }
+
+    bool select_turn(signed_size_type start_turn_index, int start_op_index,
+                     signed_size_type& turn_index,
+                     int& op_index,
+                     int previous_op_index,
+                     signed_size_type previous_turn_index,
+                     segment_identifier const& previous_seg_id,
+                     bool is_start)
+    {
+        turn_type const& current_turn = m_turns[turn_index];
+
+        if (target_operation == operation_intersection)
+        {
+            bool const back_at_start_cluster
+                    = current_turn.cluster_id >= 0
+                    && m_turns[start_turn_index].cluster_id == current_turn.cluster_id;
+
+            if (turn_index == start_turn_index || back_at_start_cluster)
+            {
+                // Intersection can always be finished if returning
+                turn_index = start_turn_index;
+                op_index = start_op_index;
+                return true;
+            }
+
+            if (current_turn.cluster_id < 0
+                && current_turn.both(operation_intersection))
+            {
+                if (analyze_ii_intersection(turn_index, op_index,
+                            current_turn, previous_seg_id))
+                {
+                    return true;
+                }
+            }
+        }
+
+        if (current_turn.cluster_id >= 0)
+        {
+            if (! select_turn_from_cluster(turn_index, op_index,
+                    start_turn_index, previous_seg_id))
+            {
+                return false;
+            }
+
+            if (is_start && turn_index == previous_turn_index)
+            {
+                op_index = previous_op_index;
+            }
+        }
+        else
+        {
+            op_index = starting_operation_index(current_turn);
+            if (op_index == -1)
+            {
+                if (both_finished(current_turn))
+                {
+                    return false;
+                }
+
+                if (! select_operation(current_turn, turn_index,
+                                start_turn_index,
+                                previous_seg_id,
+                                op_index))
+                {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+private :
+    Geometry1 const& m_geometry1;
+    Geometry2 const& m_geometry2;
+    Turns& m_turns;
+    Clusters const& m_clusters;
+    RobustPolicy const& m_robust_policy;
+    SideStrategy m_strategy;
+    Visitor& m_visitor;
+};
+
+
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traversal_info.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traversal_info.hpp
new file mode 100644
index 00000000000..8cabfb0d8db
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traversal_info.hpp
@@ -0,0 +1,53 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_INFO_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_INFO_HPP
+
+
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/enrichment_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/visit_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/segment_identifier.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+template <typename Point, typename SegmentRatio>
+struct traversal_turn_operation : public turn_operation<Point, SegmentRatio>
+{
+    enrichment_info<Point> enriched;
+    visit_info visited;
+};
+
+template <typename Point, typename SegmentRatio>
+struct traversal_turn_info
+    : public turn_info
+                <
+                    Point,
+                    SegmentRatio,
+                    traversal_turn_operation<Point, SegmentRatio>
+                >
+{};
+
+
+
+}} // namespace detail::overlay
+#endif //DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_INFO_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traversal_intersection_patterns.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traversal_intersection_patterns.hpp
new file mode 100644
index 00000000000..12279d762fb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traversal_intersection_patterns.hpp
@@ -0,0 +1,306 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2017 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_INTERSECTION_PATTERNS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_INTERSECTION_PATTERNS_HPP
+
+#include <cstddef>
+#include <vector>
+
+#include <boost/geometry/algorithms/detail/overlay/aggregate_operations.hpp>
+#include <boost/geometry/algorithms/detail/overlay/sort_by_side.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+inline bool check_pairs(std::vector<sort_by_side::rank_with_rings> const& aggregation,
+                        signed_size_type incoming_region_id,
+                        std::size_t first, std::size_t last)
+{
+    // Check if pairs 1,2 (and possibly 3,4 and 5,6 etc) satisfy
+
+    for (std::size_t i = first; i <= last; i += 2)
+    {
+        sort_by_side::rank_with_rings const& curr = aggregation[i];
+        sort_by_side::rank_with_rings const& next = aggregation[i + 1];
+        int const curr_id = curr.region_id();
+        int const next_id = next.region_id();
+
+        bool const possible =
+                curr.rings.size() == 2
+                && curr.is_isolated()
+                && curr.has_unique_region_id()
+                && next.rings.size() == 2
+                && next.is_isolated()
+                && next.has_unique_region_id()
+                && curr_id == next_id
+                && curr_id != incoming_region_id;
+
+        if (! possible)
+        {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+inline bool intersection_pattern_common_interior1(std::size_t& selected_rank,
+           std::vector<sort_by_side::rank_with_rings> const& aggregation)
+{
+    // Pattern: coming from exterior ring, encountering an isolated
+    // parallel interior ring, which should be skipped, and the first
+    // left (normally intersection takes first right) should be taken.
+    // Solves cases #case_133_multi
+    // and #case_recursive_boxes_49
+
+    std::size_t const n = aggregation.size();
+    if (n < 4)
+    {
+        return false;
+    }
+
+    sort_by_side::rank_with_rings const& incoming = aggregation.front();
+    sort_by_side::rank_with_rings const& outgoing = aggregation.back();
+
+    bool const incoming_ok =
+        incoming.all_from()
+        && incoming.rings.size() == 1
+        && incoming.has_only(operation_intersection);
+
+    if (! incoming_ok)
+    {
+        return false;
+    }
+
+    bool const outgoing_ok =
+        outgoing.all_to()
+        && outgoing.rings.size() == 1
+        && outgoing.has_only(operation_intersection)
+        && outgoing.region_id() == incoming.region_id();
+
+    if (! outgoing_ok)
+    {
+        return false;
+    }
+
+    if (check_pairs(aggregation, incoming.region_id(), 1, n - 2))
+    {
+        selected_rank = n - 1;
+        return true;
+    }
+    return false;
+}
+
+inline bool intersection_pattern_common_interior2(std::size_t& selected_rank,
+           std::vector<sort_by_side::rank_with_rings> const& aggregation)
+{
+    // Pattern: coming from two exterior rings, encountering two isolated
+    // equal interior rings
+
+    // See (for example, for ii) #case_recursive_boxes_53:
+
+    // INCOMING:
+    // Rank 0  {11[0] (s:0, m:0) i F rgn: 1 ISO}             {13[1] (s:1, m:0) i F rgn: 1 ISO}
+
+    // PAIR:
+    // Rank 1  {13[0] (s:0, r:1, m:0) i T rgn: 3 ISO ->16}   {11[1] (s:1, r:5, m:0) i T rgn: 3 ISO ->16}
+    // Rank 2  {13[0] (s:0, r:1, m:0) i F rgn: 3 ISO}        {11[1] (s:1, r:5, m:0) i F rgn: 3 ISO}
+
+    // LEAVING (in the same direction, take last one)
+    // Rank 3  {11[0] (s:0, m:0) i T rgn: 1 ISO ->10}        {13[1] (s:1, m:0) i T rgn: 1 ISO ->10}
+
+
+    std::size_t const n = aggregation.size();
+    if (n < 4)
+    {
+        return false;
+    }
+
+    sort_by_side::rank_with_rings const& incoming = aggregation.front();
+    sort_by_side::rank_with_rings const& outgoing = aggregation.back();
+
+    bool const incoming_ok =
+        incoming.all_from()
+        && incoming.rings.size() == 2
+        && incoming.has_unique_region_id();
+
+    if (! incoming_ok)
+    {
+        return false;
+    }
+
+    bool const outgoing_ok =
+        outgoing.all_to()
+        && outgoing.rings.size() == 2
+        && outgoing.has_unique_region_id()
+        && outgoing.region_id() == incoming.region_id();
+
+    if (! outgoing_ok)
+    {
+        return false;
+    }
+
+    bool const operation_ok =
+            (incoming.has_only(operation_continue) && outgoing.has_only(operation_continue))
+             || (incoming.has_only(operation_intersection) && outgoing.has_only(operation_intersection));
+
+    if (! operation_ok)
+    {
+        return false;
+    }
+
+    // Check if pairs 1,2 (and possibly 3,4 and 5,6 etc) satisfy
+    if (check_pairs(aggregation, incoming.region_id(), 1, n - 2))
+    {
+        selected_rank = n - 1;
+        return true;
+    }
+    return false;
+}
+
+inline bool intersection_pattern_common_interior3(std::size_t& selected_rank,
+           std::vector<sort_by_side::rank_with_rings> const& aggregation)
+{
+    // Pattern: approaches colocated turn (exterior+interior) from two
+    // different directions, and both leaves in the same direction
+
+    // See #case_136_multi:
+    // INCOMING:
+    //Rank 0  {10[0] (s:0, m:0) c F rgn: 1 ISO}
+
+    // PAIR:
+    //Rank 1  {14[0] (s:0, r:0, m:0) i T rgn: 2 ISO ->16} {11[1] (s:1, r:1, m:0) i T rgn: 2 ISO ->16}
+    //Rank 2  {14[0] (s:0, r:0, m:0) i F rgn: 2 ISO}      {11[1] (s:1, r:1, m:0) i F rgn: 2 ISO}
+
+    // LEAVING (select this one):
+    //Rank 3  {10[0] (s:0, m:0) c T rgn: 1 ISO ->12}      {10[1] (s:1, m:0) c T rgn: 1 ISO ->12}
+
+    // ADDITIONALLY: (other polygon coming in)
+    //Rank 4  {10[1] (s:1, m:0) c F rgn: 1 ISO}
+
+    std::size_t const n = aggregation.size();
+    if (n < 4)
+    {
+        return false;
+    }
+
+    sort_by_side::rank_with_rings const& incoming = aggregation.front();
+    sort_by_side::rank_with_rings const& outgoing = aggregation[n - 2];
+    sort_by_side::rank_with_rings const& last = aggregation.back();
+
+    bool const incoming_ok =
+        incoming.all_from()
+        && incoming.rings.size() == 1
+        && incoming.has_only(operation_continue);
+
+    if (! incoming_ok)
+    {
+        return false;
+    }
+
+    bool const outgoing_ok =
+        outgoing.all_to()
+        && outgoing.rings.size() == 2
+        && outgoing.has_only(operation_continue)
+        && outgoing.has_unique_region_id()
+        && outgoing.region_id() == incoming.region_id()
+        && last.all_from()
+        && last.rings.size() == 1
+        && last.region_id() == incoming.region_id()
+        && last.all_from();
+
+    if (! outgoing_ok)
+    {
+        return false;
+    }
+
+    // Check if pairs 1,2 (and possibly 3,4 and 5,6 etc) satisfy
+    if (check_pairs(aggregation, incoming.region_id(), 1, n - 3))
+    {
+        selected_rank = n - 2;
+        return true;
+    }
+    return false;
+}
+
+
+inline bool intersection_pattern_common_interior4(std::size_t& selected_rank,
+           std::vector<sort_by_side::rank_with_rings> const& aggregation)
+{
+    // Pattern: approaches colocated turn (exterior+interior) from same
+    // direction, but leaves in two different directions
+
+    // See #case_137_multi:
+
+    // INCOMING:
+    //Rank 0  {11[0] (s:0, m:0) i F rgn: 1 ISO}            {10[1] (s:1, m:0) i F rgn: 1 ISO}
+
+    // PAIR:
+    //Rank 1  {13[0] (s:0, r:0, m:0) i T rgn: 2 ISO ->15}  {11[1] (s:1, r:1, m:0) i T rgn: 2 ISO ->15}
+    //Rank 2  {13[0] (s:0, r:0, m:0) i F rgn: 2 ISO}       {11[1] (s:1, r:1, m:0) i F rgn: 2 ISO}
+
+    // LEAVING (in two different directions, take last one)
+    //Rank 3  {10[1] (s:1, m:0) i T rgn: 1 ISO ->0}
+    //Rank 4  {11[0] (s:0, m:0) i T rgn: 1 ISO ->12}
+
+    std::size_t const n = aggregation.size();
+    if (n < 4)
+    {
+        return false;
+    }
+
+    sort_by_side::rank_with_rings const& incoming = aggregation.front();
+    sort_by_side::rank_with_rings const& extra = aggregation[n - 2];
+    sort_by_side::rank_with_rings const& outgoing = aggregation.back();
+
+    bool const incoming_ok =
+        incoming.all_from()
+        && incoming.rings.size() == 2
+        && incoming.has_unique_region_id()
+        && incoming.has_only(operation_intersection);
+
+    if (! incoming_ok)
+    {
+        return false;
+    }
+
+    bool const outgoing_ok =
+        outgoing.all_to()
+        && outgoing.rings.size() == 1
+        && outgoing.has_only(operation_intersection)
+        && outgoing.region_id() == incoming.region_id()
+        && extra.all_to()
+        && extra.rings.size() == 1
+        && extra.has_only(operation_intersection)
+        && extra.region_id() == incoming.region_id();
+
+    if (! outgoing_ok)
+    {
+        return false;
+    }
+
+    // Check if pairs 1,2 (and possibly 3,4 and 5,6 etc) satisfy
+    if (check_pairs(aggregation, incoming.region_id(), 1, n - 3))
+    {
+        selected_rank = n - 1;
+        return true;
+    }
+    return false;
+}
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_INTERSECTION_PATTERNS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traversal_ring_creator.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traversal_ring_creator.hpp
new file mode 100644
index 00000000000..af643a822b2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traversal_ring_creator.hpp
@@ -0,0 +1,361 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017, Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_RING_CREATOR_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_RING_CREATOR_HPP
+
+#include <cstddef>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/copy_segments.hpp>
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/traversal.hpp>
+#include <boost/geometry/algorithms/num_points.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/closure.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+template
+<
+    bool Reverse1,
+    bool Reverse2,
+    overlay_type OverlayType,
+    typename Geometry1,
+    typename Geometry2,
+    typename Turns,
+    typename Clusters,
+    typename IntersectionStrategy,
+    typename RobustPolicy,
+    typename Visitor,
+    typename Backtrack
+>
+struct traversal_ring_creator
+{
+    typedef traversal
+            <
+                Reverse1, Reverse2, OverlayType,
+                Geometry1, Geometry2, Turns, Clusters,
+                RobustPolicy, typename IntersectionStrategy::side_strategy_type,
+                Visitor
+            > traversal_type;
+
+    typedef typename boost::range_value<Turns>::type turn_type;
+    typedef typename turn_type::turn_operation_type turn_operation_type;
+
+    static const operation_type target_operation
+        = operation_from_overlay<OverlayType>::value;
+
+    inline traversal_ring_creator(Geometry1 const& geometry1, Geometry2 const& geometry2,
+            Turns& turns, Clusters const& clusters,
+            IntersectionStrategy const& intersection_strategy,
+            RobustPolicy const& robust_policy, Visitor& visitor)
+        : m_trav(geometry1, geometry2, turns, clusters,
+                 robust_policy, intersection_strategy.get_side_strategy(),
+                 visitor)
+        , m_geometry1(geometry1)
+        , m_geometry2(geometry2)
+        , m_turns(turns)
+        , m_clusters(clusters)
+        , m_intersection_strategy(intersection_strategy)
+        , m_robust_policy(robust_policy)
+        , m_visitor(visitor)
+    {
+    }
+
+    template <typename Ring>
+    inline traverse_error_type travel_to_next_turn(signed_size_type start_turn_index,
+                int start_op_index,
+                signed_size_type& turn_index,
+                int& op_index,
+                Ring& current_ring,
+                bool is_start)
+    {
+        int const previous_op_index = op_index;
+        signed_size_type const previous_turn_index = turn_index;
+        turn_type& previous_turn = m_turns[turn_index];
+        turn_operation_type& previous_op = previous_turn.operations[op_index];
+        segment_identifier previous_seg_id;
+
+        signed_size_type to_vertex_index = -1;
+        if (! m_trav.select_turn_from_enriched(turn_index, previous_seg_id,
+                          to_vertex_index, start_turn_index, start_op_index,
+                          previous_turn, previous_op, is_start))
+        {
+            return is_start
+                    ? traverse_error_no_next_ip_at_start
+                    : traverse_error_no_next_ip;
+        }
+        if (to_vertex_index >= 0)
+        {
+            if (previous_op.seg_id.source_index == 0)
+            {
+                geometry::copy_segments<Reverse1>(m_geometry1,
+                        previous_op.seg_id, to_vertex_index,
+                        m_intersection_strategy.get_side_strategy(),
+                        m_robust_policy, current_ring);
+            }
+            else
+            {
+                geometry::copy_segments<Reverse2>(m_geometry2,
+                        previous_op.seg_id, to_vertex_index,
+                        m_intersection_strategy.get_side_strategy(),
+                        m_robust_policy, current_ring);
+            }
+        }
+
+        if (m_turns[turn_index].discarded)
+        {
+            return is_start
+                ? traverse_error_dead_end_at_start
+                : traverse_error_dead_end;
+        }
+
+        if (is_start)
+        {
+            // Register the start
+            previous_op.visited.set_started();
+            m_visitor.visit_traverse(m_turns, previous_turn, previous_op, "Start");
+        }
+
+        if (! m_trav.select_turn(start_turn_index, start_op_index,
+                turn_index, op_index,
+                previous_op_index, previous_turn_index, previous_seg_id,
+                is_start))
+        {
+            return is_start
+                ? traverse_error_no_next_ip_at_start
+                : traverse_error_no_next_ip;
+        }
+
+        {
+            // Check operation (TODO: this might be redundant or should be catched before)
+            const turn_type& current_turn = m_turns[turn_index];
+            const turn_operation_type& op = current_turn.operations[op_index];
+            if (op.visited.finalized()
+                || m_trav.is_visited(current_turn, op, turn_index, op_index))
+            {
+                return traverse_error_visit_again;
+            }
+        }
+
+        // Update registration and append point
+        turn_type& current_turn = m_turns[turn_index];
+        turn_operation_type& op = current_turn.operations[op_index];
+        detail::overlay::append_no_dups_or_spikes(current_ring, current_turn.point,
+            m_intersection_strategy.get_side_strategy(),
+            m_robust_policy);
+
+        // Register the visit
+        m_trav.set_visited(current_turn, op);
+        m_visitor.visit_traverse(m_turns, current_turn, op, "Visit");
+
+        return traverse_error_none;
+    }
+
+    template <typename Ring>
+    inline traverse_error_type traverse(Ring& ring,
+            signed_size_type start_turn_index, int start_op_index)
+    {
+        turn_type const& start_turn = m_turns[start_turn_index];
+        turn_operation_type& start_op = m_turns[start_turn_index].operations[start_op_index];
+
+        detail::overlay::append_no_dups_or_spikes(ring, start_turn.point,
+            m_intersection_strategy.get_side_strategy(),
+            m_robust_policy);
+
+        signed_size_type current_turn_index = start_turn_index;
+        int current_op_index = start_op_index;
+
+        traverse_error_type error = travel_to_next_turn(start_turn_index,
+                    start_op_index,
+                    current_turn_index, current_op_index,
+                    ring, true);
+
+        if (error != traverse_error_none)
+        {
+            // This is not necessarily a problem, it happens for clustered turns
+            // which are "build in" or otherwise point inwards
+            return error;
+        }
+
+        if (current_turn_index == start_turn_index)
+        {
+            start_op.visited.set_finished();
+            m_visitor.visit_traverse(m_turns, m_turns[current_turn_index], start_op, "Early finish");
+            return traverse_error_none;
+        }
+
+        if (start_turn.cluster_id >= 0)
+        {
+            turn_type const& turn = m_turns[current_turn_index];
+            if (turn.cluster_id == start_turn.cluster_id)
+            {
+                turn_operation_type& op = m_turns[start_turn_index].operations[current_op_index];
+                op.visited.set_finished();
+                m_visitor.visit_traverse(m_turns, m_turns[current_turn_index], start_op, "Early finish (cluster)");
+                return traverse_error_none;
+            }
+        }
+
+        std::size_t const max_iterations = 2 + 2 * m_turns.size();
+        for (std::size_t i = 0; i <= max_iterations; i++)
+        {
+            // We assume clockwise polygons only, non self-intersecting, closed.
+            // However, the input might be different, and checking validity
+            // is up to the library user.
+
+            // Therefore we make here some sanity checks. If the input
+            // violates the assumptions, the output polygon will not be correct
+            // but the routine will stop and output the current polygon, and
+            // will continue with the next one.
+
+            // Below three reasons to stop.
+            error = travel_to_next_turn(start_turn_index, start_op_index,
+                    current_turn_index, current_op_index,
+                    ring, false);
+
+            if (error != traverse_error_none)
+            {
+                return error;
+            }
+
+            if (current_turn_index == start_turn_index
+                    && current_op_index == start_op_index)
+            {
+                start_op.visited.set_finished();
+                m_visitor.visit_traverse(m_turns, start_turn, start_op, "Finish");
+                return traverse_error_none;
+            }
+        }
+
+        return traverse_error_endless_loop;
+    }
+
+    template <typename Rings>
+    void traverse_with_operation(turn_type const& start_turn,
+            std::size_t turn_index, int op_index,
+            Rings& rings, std::size_t& finalized_ring_size,
+            typename Backtrack::state_type& state)
+    {
+        typedef typename boost::range_value<Rings>::type ring_type;
+
+        turn_operation_type const& start_op = start_turn.operations[op_index];
+
+        if (! start_op.visited.none()
+            || ! start_op.enriched.startable
+            || start_op.visited.rejected()
+            || ! (start_op.operation == target_operation
+                || start_op.operation == detail::overlay::operation_continue))
+        {
+            return;
+        }
+
+        ring_type ring;
+        traverse_error_type traverse_error = traverse(ring, turn_index, op_index);
+
+        if (traverse_error == traverse_error_none)
+        {
+            std::size_t const min_num_points
+                    = core_detail::closure::minimum_ring_size
+                            <
+                                geometry::closure<ring_type>::value
+                            >::value;
+
+            if (geometry::num_points(ring) >= min_num_points)
+            {
+                clean_closing_dups_and_spikes(ring,
+                                              m_intersection_strategy.get_side_strategy(),
+                                              m_robust_policy);
+                rings.push_back(ring);
+
+                m_trav.finalize_visit_info();
+                finalized_ring_size++;
+            }
+        }
+        else
+        {
+            Backtrack::apply(
+                finalized_ring_size,
+                rings, ring, m_turns, start_turn,
+                m_turns[turn_index].operations[op_index],
+                traverse_error,
+                m_geometry1, m_geometry2,
+                m_intersection_strategy, m_robust_policy,
+                state, m_visitor);
+        }
+    }
+
+    template <typename Rings>
+    void iterate(Rings& rings, std::size_t& finalized_ring_size,
+                 typename Backtrack::state_type& state)
+    {
+        for (std::size_t turn_index = 0; turn_index < m_turns.size(); ++turn_index)
+        {
+            turn_type const& turn = m_turns[turn_index];
+
+            if (turn.discarded || turn.blocked())
+            {
+                // Skip discarded and blocked turns
+                continue;
+            }
+
+            if (turn.both(operation_continue))
+            {
+                // Traverse only one turn, the one with the SMALLEST remaining distance
+                // to avoid skipping a turn in between, which can happen in rare cases
+                // (e.g. #130)
+                turn_operation_type const& op0 = turn.operations[0];
+                turn_operation_type const& op1 = turn.operations[1];
+                int const op_index
+                        = op0.remaining_distance <= op1.remaining_distance ? 0 : 1;
+
+                traverse_with_operation(turn, turn_index, op_index,
+                        rings, finalized_ring_size, state);
+            }
+            else
+            {
+                for (int op_index = 0; op_index < 2; op_index++)
+                {
+                    traverse_with_operation(turn, turn_index, op_index,
+                            rings, finalized_ring_size, state);
+                }
+            }
+        }
+    }
+
+private:
+    traversal_type m_trav;
+
+    Geometry1 const& m_geometry1;
+    Geometry2 const& m_geometry2;
+    Turns& m_turns;
+    Clusters const& m_clusters;
+    IntersectionStrategy const& m_intersection_strategy;
+    RobustPolicy const& m_robust_policy;
+    Visitor& m_visitor;
+};
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_RING_CREATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traversal_switch_detector.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traversal_switch_detector.hpp
new file mode 100644
index 00000000000..0b4f393ef48
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traversal_switch_detector.hpp
@@ -0,0 +1,575 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015-2016 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_SWITCH_DETECTOR_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_SWITCH_DETECTOR_HPP
+
+#include <cstddef>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/detail/ring_identifier.hpp>
+#include <boost/geometry/algorithms/detail/overlay/copy_segments.hpp>
+#include <boost/geometry/algorithms/detail/overlay/cluster_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/is_self_turn.hpp>
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/assert.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+// Generic function (is this used somewhere else too?)
+inline ring_identifier ring_id_by_seg_id(segment_identifier const& seg_id)
+{
+    return ring_identifier(seg_id.source_index, seg_id.multi_index, seg_id.ring_index);
+}
+
+template
+<
+    bool Reverse1,
+    bool Reverse2,
+    overlay_type OverlayType,
+    typename Geometry1,
+    typename Geometry2,
+    typename Turns,
+    typename Clusters,
+    typename RobustPolicy,
+    typename Visitor
+>
+struct traversal_switch_detector
+{
+    enum isolation_type { isolation_unknown = -1, isolation_no = 0, isolation_yes = 1 };
+
+    typedef typename boost::range_value<Turns>::type turn_type;
+    typedef typename turn_type::turn_operation_type turn_operation_type;
+
+    // Per ring, first turns are collected (in turn_indices), and later
+    // a region_id is assigned
+    struct merged_ring_properties
+    {
+        signed_size_type region_id;
+        std::set<signed_size_type> turn_indices;
+
+        merged_ring_properties()
+            : region_id(-1)
+        {}
+    };
+
+    struct connection_properties
+    {
+        std::size_t count;
+        std::set<signed_size_type> cluster_indices;
+        connection_properties()
+            : count(0)
+        {}
+    };
+
+    typedef std::map<signed_size_type, connection_properties> connection_map;
+
+    // Per region, a set of properties is maintained, including its connections
+    // to other regions
+    struct region_properties
+    {
+        signed_size_type region_id;
+        isolation_type isolated;
+
+        // Maps from connected region_id to their properties
+        connection_map connected_region_counts;
+
+        region_properties()
+            : region_id(-1)
+            , isolated(isolation_unknown)
+        {}
+    };
+
+    // Keeps turn indices per ring
+    typedef std::map<ring_identifier, merged_ring_properties > merge_map;
+    typedef std::map<signed_size_type, region_properties> region_connection_map;
+
+    typedef std::set<signed_size_type>::const_iterator set_iterator;
+
+    inline traversal_switch_detector(Geometry1 const& geometry1, Geometry2 const& geometry2,
+            Turns& turns, Clusters& clusters,
+            RobustPolicy const& robust_policy, Visitor& visitor)
+        : m_geometry1(geometry1)
+        , m_geometry2(geometry2)
+        , m_turns(turns)
+        , m_clusters(clusters)
+        , m_robust_policy(robust_policy)
+        , m_visitor(visitor)
+    {
+    }
+
+    isolation_type get_isolation(region_properties const& properties,
+                                 signed_size_type parent_region_id,
+                                 const std::set<signed_size_type>& visited)
+    {
+        if (properties.isolated != isolation_unknown)
+        {
+            return properties.isolated;
+        }
+
+        bool all_colocated = true;
+        int unique_cluster_id = -1;
+        for (typename connection_map::const_iterator it = properties.connected_region_counts.begin();
+             all_colocated && it != properties.connected_region_counts.end(); ++it)
+        {
+            connection_properties const& cprop = it->second;
+            if (cprop.cluster_indices.size() != 1)
+            {
+                // Either no cluster (non colocated point), or more clusters
+                all_colocated = false;
+            }
+            int const cluster_id = *cprop.cluster_indices.begin();
+            if (cluster_id == -1)
+            {
+                all_colocated = false;
+            }
+            else if (unique_cluster_id == -1)
+            {
+                unique_cluster_id = cluster_id;
+            }
+            else if (unique_cluster_id != cluster_id)
+            {
+                all_colocated = false;
+            }
+        }
+        if (all_colocated)
+        {
+            return isolation_yes;
+        }
+
+
+        // It is isolated if there is only one connection, or if there are more connections but all
+        // of them are isolated themselves, or if there are more connections
+        // but they are all colocated
+        std::size_t non_isolation_count = 0;
+        bool child_not_isolated = false;
+        for (typename connection_map::const_iterator it = properties.connected_region_counts.begin();
+             it != properties.connected_region_counts.end(); ++it)
+        {
+            signed_size_type const region_id = it->first;
+            connection_properties const& cprop = it->second;
+
+            if (region_id == parent_region_id)
+            {
+                // Normal situation, skip its direct parent
+                continue;
+            }
+            if (visited.count(region_id) > 0)
+            {
+                // Find one of its ancestors again, this is a ring. Not isolated.
+                return isolation_no;
+            }
+            if (cprop.count > 1)
+            {
+                return isolation_no;
+            }
+
+            typename region_connection_map::iterator mit = m_connected_regions.find(region_id);
+            if (mit == m_connected_regions.end())
+            {
+                // Should not occur
+                continue;
+            }
+
+            std::set<signed_size_type> vis = visited;
+            vis.insert(parent_region_id);
+
+            region_properties& prop = mit->second;
+            if (prop.isolated == isolation_unknown)
+            {
+                isolation_type const iso = get_isolation(prop, properties.region_id, vis);
+                prop.isolated = iso;
+                if (iso == isolation_no)
+                {
+                    child_not_isolated = true;
+                }
+            }
+            if (prop.isolated == isolation_no)
+            {
+                non_isolation_count++;
+            }
+        }
+
+        return child_not_isolated || non_isolation_count > 1 ? isolation_no : isolation_yes;
+    }
+
+    void get_isolated_regions()
+    {
+        for (typename region_connection_map::iterator it = m_connected_regions.begin();
+             it != m_connected_regions.end(); ++it)
+        {
+            region_properties& properties = it->second;
+            if (properties.isolated == isolation_unknown)
+            {
+                std::set<signed_size_type> visited;
+                properties.isolated = get_isolation(properties, properties.region_id, visited);
+            }
+        }
+    }
+
+    void assign_isolation()
+    {
+        for (std::size_t turn_index = 0; turn_index < m_turns.size(); ++turn_index)
+        {
+            turn_type& turn = m_turns[turn_index];
+
+            for (int op_index = 0; op_index < 2; op_index++)
+            {
+                turn_operation_type& op = turn.operations[op_index];
+                typename region_connection_map::const_iterator mit = m_connected_regions.find(op.enriched.region_id);
+                if (mit != m_connected_regions.end())
+                {
+                    region_properties const& prop = mit->second;
+                    op.enriched.isolated = prop.isolated == isolation_yes;
+                }
+            }
+        }
+    }
+
+    void assign_regions()
+    {
+        for (typename merge_map::const_iterator it
+             = m_turns_per_ring.begin(); it != m_turns_per_ring.end(); ++it)
+        {
+            ring_identifier const& ring_id = it->first;
+            merged_ring_properties const& properties = it->second;
+
+            for (set_iterator sit = properties.turn_indices.begin();
+                 sit != properties.turn_indices.end(); ++sit)
+            {
+                turn_type& turn = m_turns[*sit];
+
+                for (int i = 0; i < 2; i++)
+                {
+                    turn_operation_type& op = turn.operations[i];
+                    if (ring_id_by_seg_id(op.seg_id) == ring_id)
+                    {
+                        op.enriched.region_id = properties.region_id;
+                    }
+                }
+                signed_size_type const& id0 = turn.operations[0].enriched.region_id;
+                signed_size_type const& id1 = turn.operations[1].enriched.region_id;
+                if (id0 != id1 && id0 != -1 && id1 != -1)
+                {
+                    // Force insertion
+                    m_connected_regions[id0].region_id = id0;
+                    m_connected_regions[id1].region_id = id1;
+
+                    connection_properties& prop0 = m_connected_regions[id0].connected_region_counts[id1];
+                    connection_properties& prop1 = m_connected_regions[id1].connected_region_counts[id0];
+
+                    if (turn.cluster_id < 0)
+                    {
+                        // Turn is not colocated, add reference to connection
+                        prop0.count++;
+                        prop1.count++;
+                    }
+                    else
+                    {
+                        // Turn is colocated, only add region reference if it was not yet registered
+                        if (prop0.cluster_indices.count(turn.cluster_id) == 0)
+                        {
+                            prop0.count++;
+                        }
+                        if (prop1.cluster_indices.count(turn.cluster_id) == 0)
+                        {
+                            prop1.count++;
+                        }
+                    }
+                    // Insert cluster-id (also -1 is inserted - reinsertion of
+                    // same cluster id is OK)
+                    prop0.cluster_indices.insert(turn.cluster_id);
+                    prop1.cluster_indices.insert(turn.cluster_id);
+                }
+            }
+        }
+    }
+
+    inline bool connects_same_region(turn_type const& turn) const
+    {
+        if (turn.discarded)
+        {
+            // Discarded turns don't connect same region (otherwise discarded colocated uu turn
+            // could make a connection)
+            return false;
+        }
+
+        if (turn.cluster_id == -1)
+        {
+            // If it is a uu/ii-turn (non clustered), it is never same region
+            return ! (turn.both(operation_union) || turn.both(operation_intersection));
+        }
+
+        if (operation_from_overlay<OverlayType>::value == operation_union)
+        {
+            // It is a cluster, check zones
+            // (assigned by sort_by_side/handle colocations) of both operations
+            return turn.operations[0].enriched.zone
+                    == turn.operations[1].enriched.zone;
+        }
+
+        // If a cluster contains an ii/cc it is not same region (for intersection)
+        typename Clusters::const_iterator it = m_clusters.find(turn.cluster_id);
+        if (it == m_clusters.end())
+        {
+            // Should not occur
+            return true;
+        }
+
+        cluster_info const& cinfo = it->second;
+        for (set_iterator sit = cinfo.turn_indices.begin();
+             sit != cinfo.turn_indices.end(); ++sit)
+        {
+            turn_type const& cluster_turn = m_turns[*sit];
+            if (cluster_turn.both(operation_union)
+                   || cluster_turn.both(operation_intersection))
+            {
+                return false;
+            }
+        }
+
+        // It is the same region
+        return false;
+    }
+
+
+    inline int get_region_id(turn_operation_type const& op) const
+    {
+        return op.enriched.region_id;
+    }
+
+
+    void create_region(signed_size_type& new_region_id, ring_identifier const& ring_id,
+                merged_ring_properties& properties, int region_id = -1)
+    {
+        if (properties.region_id > 0)
+        {
+            // Already handled
+            return;
+        }
+
+        // Assign new id if this is a new region
+        if (region_id == -1)
+        {
+            region_id = new_region_id++;
+        }
+
+        // Assign this ring to specified region
+        properties.region_id = region_id;
+
+#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSAL_SWITCH_DETECTOR)
+        std::cout << " ADD " << ring_id << "  TO REGION " << region_id << std::endl;
+#endif
+
+        // Find connecting rings, recursively
+        for (set_iterator sit = properties.turn_indices.begin();
+             sit != properties.turn_indices.end(); ++sit)
+        {
+            signed_size_type const turn_index = *sit;
+            turn_type const& turn = m_turns[turn_index];
+            if (! connects_same_region(turn))
+            {
+                // This is a non clustered uu/ii-turn, or a cluster connecting different 'zones'
+                continue;
+            }
+
+            // Union: This turn connects two rings (interior connected), create the region
+            // Intersection: This turn connects two rings, set same regions for these two rings
+            for (int op_index = 0; op_index < 2; op_index++)
+            {
+                turn_operation_type const& op = turn.operations[op_index];
+                ring_identifier connected_ring_id = ring_id_by_seg_id(op.seg_id);
+                if (connected_ring_id != ring_id)
+                {
+                    propagate_region(new_region_id, connected_ring_id, region_id);
+                }
+            }
+        }
+    }
+
+    void propagate_region(signed_size_type& new_region_id,
+            ring_identifier const& ring_id, int region_id)
+    {
+        typename merge_map::iterator it = m_turns_per_ring.find(ring_id);
+        if (it != m_turns_per_ring.end())
+        {
+            create_region(new_region_id, ring_id, it->second, region_id);
+        }
+    }
+
+
+    void iterate()
+    {
+#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSAL_SWITCH_DETECTOR)
+        std::cout << "SWITCH BEGIN ITERATION" << std::endl;
+#endif
+
+        // Collect turns per ring
+        m_turns_per_ring.clear();
+        m_connected_regions.clear();
+
+        for (std::size_t turn_index = 0; turn_index < m_turns.size(); ++turn_index)
+        {
+            turn_type const& turn = m_turns[turn_index];
+
+            if (turn.discarded
+                    && operation_from_overlay<OverlayType>::value == operation_intersection)
+            {
+                // Discarded turn (union currently still needs it to determine regions)
+                continue;
+            }
+
+            for (int op_index = 0; op_index < 2; op_index++)
+            {
+                turn_operation_type const& op = turn.operations[op_index];
+                m_turns_per_ring[ring_id_by_seg_id(op.seg_id)].turn_indices.insert(turn_index);
+            }
+        }
+
+        // All rings having turns are in the map. Now iterate them
+        {
+            signed_size_type new_region_id = 1;
+            for (typename merge_map::iterator it
+                 = m_turns_per_ring.begin(); it != m_turns_per_ring.end(); ++it)
+            {
+                create_region(new_region_id, it->first, it->second);
+            }
+
+            assign_regions();
+            get_isolated_regions();
+            assign_isolation();
+        }
+
+        // Now that all regions are filled, assign switch_source property
+        // Iterate through all clusters
+        for (typename Clusters::iterator it = m_clusters.begin(); it != m_clusters.end(); ++it)
+        {
+            cluster_info& cinfo = it->second;
+            if (cinfo.open_count <= 1)
+            {
+                // Not a touching cluster
+                continue;
+            }
+
+            // A touching cluster, gather regions
+            std::set<int> regions;
+
+            std::set<signed_size_type> const& ids = cinfo.turn_indices;
+
+#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSAL_SWITCH_DETECTOR)
+                std::cout << "SWITCH EXAMINE CLUSTER " << it->first << std::endl;
+#endif
+
+            for (set_iterator sit = ids.begin(); sit != ids.end(); ++sit)
+            {
+                signed_size_type turn_index = *sit;
+                turn_type const& turn = m_turns[turn_index];
+                if (turn.colocated_ii && ! turn.colocated_uu)
+                {
+                    continue;
+                }
+                for (int oi = 0; oi < 2; oi++)
+                {
+                    int const region = get_region_id(turn.operations[oi]);
+                    regions.insert(region);
+                }
+            }
+            // Switch source if this cluster connects the same region
+            cinfo.switch_source = regions.size() <= 1;
+        }
+
+        // Iterate through all uu/ii turns (non-clustered)
+        for (std::size_t turn_index = 0; turn_index < m_turns.size(); ++turn_index)
+        {
+            turn_type& turn = m_turns[turn_index];
+
+            if (turn.discarded
+                    || turn.blocked()
+                    || turn.cluster_id >= 0
+                    || ! (turn.both(operation_union) || turn.both(operation_intersection)))
+            {
+                // Skip discarded, blocked, non-uu/ii and clustered turns
+                continue;
+            }
+
+            if (OverlayType == overlay_buffer)
+            {
+                // For deflate, the region approach does not work because many
+                // pieces are outside the real polygons
+                // TODO: implement this in another way for buffer
+                // (because now buffer might output invalid geometries)
+                continue;
+            }
+
+            int const region0 = get_region_id(turn.operations[0]);
+            int const region1 = get_region_id(turn.operations[1]);
+
+            // Switch sources for same region
+            turn.switch_source = region0 == region1;
+        }
+
+
+#if defined(BOOST_GEOMETRY_DEBUG_TRAVERSAL_SWITCH_DETECTOR)
+        std::cout << "SWITCH END ITERATION" << std::endl;
+
+        for (std::size_t turn_index = 0; turn_index < m_turns.size(); ++turn_index)
+        {
+            turn_type const& turn = m_turns[turn_index];
+
+            if ((turn.both(operation_union) || turn.both(operation_intersection))
+                 && turn.cluster_id < 0)
+            {
+                std::cout << "UU/II SWITCH RESULT "
+                             << turn_index << " -> "
+                          << turn.switch_source << std::endl;
+            }
+        }
+
+        for (typename Clusters::const_iterator it = m_clusters.begin(); it != m_clusters.end(); ++it)
+        {
+            cluster_info const& cinfo = it->second;
+            if (cinfo.open_count > 1)
+            {
+                std::cout << "CL SWITCH RESULT " << it->first
+                             << " -> " << cinfo.switch_source << std::endl;
+            }
+            else
+            {
+                std::cout << "CL SWITCH RESULT " << it->first
+                          << " is not registered as open" << std::endl;
+            }
+        }
+#endif
+
+    }
+
+private:
+
+    Geometry1 const& m_geometry1;
+    Geometry2 const& m_geometry2;
+    Turns& m_turns;
+    Clusters& m_clusters;
+    merge_map m_turns_per_ring;
+    region_connection_map m_connected_regions;
+    RobustPolicy const& m_robust_policy;
+    Visitor& m_visitor;
+};
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSAL_SWITCH_DETECTOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traverse.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traverse.hpp
new file mode 100644
index 00000000000..058f6c94584
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/traverse.hpp
@@ -0,0 +1,112 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSE_HPP
+
+#include <cstddef>
+
+#include <boost/geometry/algorithms/detail/overlay/backtrack_check_si.hpp>
+#include <boost/geometry/algorithms/detail/overlay/traversal_ring_creator.hpp>
+#include <boost/geometry/algorithms/detail/overlay/traversal_switch_detector.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+/*!
+    \brief Traverses through intersection points / geometries
+    \ingroup overlay
+ */
+template
+<
+    bool Reverse1, bool Reverse2,
+    typename Geometry1,
+    typename Geometry2,
+    overlay_type OverlayType,
+    typename Backtrack = backtrack_check_self_intersections<Geometry1, Geometry2>
+>
+class traverse
+{
+
+    template <typename Turns>
+    static void reset_visits(Turns& turns)
+    {
+        for (typename boost::range_iterator<Turns>::type
+            it = boost::begin(turns);
+            it != boost::end(turns);
+            ++it)
+        {
+            for (int i = 0; i < 2; i++)
+            {
+                it->operations[i].visited.reset();
+            }
+        }
+    }
+
+
+public :
+    template
+    <
+        typename IntersectionStrategy,
+        typename RobustPolicy,
+        typename Turns,
+        typename Rings,
+        typename Visitor,
+        typename Clusters
+    >
+    static inline void apply(Geometry1 const& geometry1,
+                Geometry2 const& geometry2,
+                IntersectionStrategy const& intersection_strategy,
+                RobustPolicy const& robust_policy,
+                Turns& turns, Rings& rings,
+                Clusters& clusters,
+                Visitor& visitor)
+    {
+        traversal_switch_detector
+            <
+                Reverse1, Reverse2, OverlayType,
+                Geometry1, Geometry2,
+                Turns, Clusters,
+                RobustPolicy, Visitor
+            > switch_detector(geometry1, geometry2, turns, clusters,
+                   robust_policy, visitor);
+
+        switch_detector.iterate();
+        reset_visits(turns);
+
+        traversal_ring_creator
+            <
+                Reverse1, Reverse2, OverlayType,
+                Geometry1, Geometry2,
+                Turns, Clusters,
+                IntersectionStrategy,
+                RobustPolicy, Visitor,
+                Backtrack
+            > trav(geometry1, geometry2, turns, clusters,
+                   intersection_strategy, robust_policy, visitor);
+
+        std::size_t finalized_ring_size = boost::size(rings);
+
+        typename Backtrack::state_type state;
+
+        trav.iterate(rings, finalized_ring_size, state);
+    }
+};
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TRAVERSE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/turn_info.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/turn_info.hpp
new file mode 100644
index 00000000000..3a4c2e94a1a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/turn_info.hpp
@@ -0,0 +1,160 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TURN_INFO_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TURN_INFO_HPP
+
+
+#include <boost/array.hpp>
+
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/algorithms/detail/signed_size_type.hpp>
+#include <boost/geometry/algorithms/detail/overlay/segment_identifier.hpp>
+#include <boost/geometry/algorithms/detail/overlay/overlay_type.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+enum method_type
+{
+    method_none,
+    method_disjoint,
+    method_crosses,
+    method_touch,
+    method_touch_interior,
+    method_collinear,
+    method_equal,
+    method_error
+};
+
+
+/*!
+    \brief Turn operation: operation
+    \details Information necessary for traversal phase (a phase
+        of the overlay process). The information is gathered during the
+        get_turns (segment intersection) phase.
+        The class is to be included in the turn_info class, either direct
+        or a derived or similar class with more (e.g. enrichment) information.
+ */
+template <typename Point, typename SegmentRatio>
+struct turn_operation
+{
+    typedef SegmentRatio segment_ratio_type;
+
+    operation_type operation;
+    segment_identifier seg_id;
+    SegmentRatio fraction;
+
+    typedef typename coordinate_type<Point>::type comparable_distance_type;
+    comparable_distance_type remaining_distance;
+
+    inline turn_operation()
+        : operation(operation_none)
+        , remaining_distance(0)
+    {}
+};
+
+
+/*!
+    \brief Turn information: intersection point, method, and turn information
+    \details Information necessary for traversal phase (a phase
+        of the overlay process). The information is gathered during the
+        get_turns (segment intersection) phase.
+    \tparam Point point type of intersection point
+    \tparam Operation gives classes opportunity to add additional info
+    \tparam Container gives classes opportunity to define how operations are stored
+ */
+template
+<
+    typename Point,
+    typename SegmentRatio,
+    typename Operation = turn_operation<Point, SegmentRatio>,
+    typename Container = boost::array<Operation, 2>
+>
+struct turn_info
+{
+    typedef Point point_type;
+    typedef SegmentRatio segment_ratio_type;
+    typedef Operation turn_operation_type;
+    typedef Container container_type;
+
+    Point point;
+    method_type method;
+    bool touch_only; // True in case of method touch(interior) and lines do not cross
+    signed_size_type cluster_id; // For multiple turns on same location, >= 0. Else -1
+    bool discarded;
+
+    // TODO: move this to enriched
+    bool colocated_ii; // Colocated with a ii turn (TODO: or a ix turn)
+    bool colocated_uu; // Colocated with a uu turn or a ux turn
+    bool switch_source; // For u/u turns which can either switch or not
+
+    Container operations;
+
+    inline turn_info()
+        : method(method_none)
+        , touch_only(false)
+        , cluster_id(-1)
+        , discarded(false)
+        , colocated_ii(false)
+        , colocated_uu(false)
+        , switch_source(false)
+    {}
+
+    inline bool both(operation_type type) const
+    {
+        return has12(type, type);
+    }
+
+    inline bool has(operation_type type) const
+    {
+        return this->operations[0].operation == type
+            || this->operations[1].operation == type;
+    }
+
+    inline bool combination(operation_type type1, operation_type type2) const
+    {
+        return has12(type1, type2) || has12(type2, type1);
+    }
+
+    inline bool blocked() const
+    {
+        return both(operation_blocked);
+    }
+    inline bool opposite() const
+    {
+        return both(operation_opposite);
+    }
+    inline bool any_blocked() const
+    {
+        return has(operation_blocked);
+    }
+
+private :
+    inline bool has12(operation_type type1, operation_type type2) const
+    {
+        return this->operations[0].operation == type1
+            && this->operations[1].operation == type2
+            ;
+    }
+
+};
+
+
+}} // namespace detail::overlay
+#endif //DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_TURN_INFO_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/visit_info.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/visit_info.hpp
new file mode 100644
index 00000000000..e401fbbb497
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/overlay/visit_info.hpp
@@ -0,0 +1,98 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_VISIT_INFO_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_VISIT_INFO_HPP
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+class visit_info
+{
+private :
+    static const int NONE = 0;
+    static const int STARTED = 1;
+    static const int VISITED = 2;
+    static const int FINISHED = 3;
+    static const int REJECTED = 4;
+
+    int m_visit_code;
+    bool m_rejected;
+    bool m_final;
+
+public:
+    inline visit_info()
+        : m_visit_code(0)
+        , m_rejected(false)
+        , m_final(false)
+    {}
+
+    inline void set_visited() { m_visit_code = VISITED; }
+    inline void set_started() { m_visit_code = STARTED; }
+    inline void set_finished() { m_visit_code = FINISHED; }
+    inline void set_rejected()
+    {
+        m_visit_code = REJECTED;
+        m_rejected = true;
+    }
+
+    inline bool none() const { return m_visit_code == NONE; }
+    inline bool visited() const { return m_visit_code == VISITED; }
+    inline bool started() const { return m_visit_code == STARTED; }
+    inline bool finished() const { return m_visit_code == FINISHED; }
+    inline bool rejected() const { return m_rejected; }
+    inline bool finalized() const { return m_final; }
+
+    inline void clear()
+    {
+        if (! m_rejected && ! m_final)
+        {
+            m_visit_code = NONE;
+        }
+    }
+
+    inline void reset()
+    {
+        *this = visit_info();
+    }
+
+    inline void finalize()
+    {
+        if (visited() || started() || finished() )
+        {
+            m_final = true;
+        }
+    }
+
+#ifdef BOOST_GEOMETRY_DEBUG_INTERSECTION
+    friend std::ostream& operator<<(std::ostream &os, visit_info const& v)
+    {
+        if (v.m_visit_code != 0)
+        {
+            os << " VIS: " << int(v.m_visit_code);
+        }
+        return os;
+    }
+#endif
+
+};
+
+
+}} // namespace detail::overlay
+#endif //DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_OVERLAY_VISIT_INFO_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/partition.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/partition.hpp
new file mode 100644
index 00000000000..db134d548db
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/partition.hpp
@@ -0,0 +1,848 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2011-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2015, 2017.
+// Modifications copyright (c) 2015-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_PARTITION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_PARTITION_HPP
+
+#include <cstddef>
+#include <vector>
+#include <boost/range.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/algorithms/assign.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace detail { namespace partition
+{
+
+template <int Dimension, typename Box>
+inline void divide_box(Box const& box, Box& lower_box, Box& upper_box)
+{
+    typedef typename coordinate_type<Box>::type ctype;
+
+    // Divide input box into two parts, e.g. left/right
+    ctype two = 2;
+    ctype mid = (geometry::get<min_corner, Dimension>(box)
+            + geometry::get<max_corner, Dimension>(box)) / two;
+
+    lower_box = box;
+    upper_box = box;
+    geometry::set<max_corner, Dimension>(lower_box, mid);
+    geometry::set<min_corner, Dimension>(upper_box, mid);
+}
+
+// Divide forward_range into three subsets: lower, upper and oversized
+// (not-fitting)
+// (lower == left or bottom, upper == right or top)
+template <typename Box, typename IteratorVector, typename OverlapsPolicy>
+inline void divide_into_subsets(Box const& lower_box,
+                                Box const& upper_box,
+                                IteratorVector const& input,
+                                IteratorVector& lower,
+                                IteratorVector& upper,
+                                IteratorVector& exceeding,
+                                OverlapsPolicy const& overlaps_policy)
+{
+    typedef typename boost::range_iterator
+        <
+            IteratorVector const
+        >::type it_type;
+
+    for(it_type it = boost::begin(input); it != boost::end(input); ++it)
+    {
+        bool const lower_overlapping = overlaps_policy.apply(lower_box, **it);
+        bool const upper_overlapping = overlaps_policy.apply(upper_box, **it);
+
+        if (lower_overlapping && upper_overlapping)
+        {
+            exceeding.push_back(*it);
+        }
+        else if (lower_overlapping)
+        {
+            lower.push_back(*it);
+        }
+        else if (upper_overlapping)
+        {
+            upper.push_back(*it);
+        }
+        else
+        {
+            // Is nowhere. That is (since 1.58) possible, it might be
+            // skipped by the OverlapsPolicy to enhance performance
+        }
+    }
+}
+
+template
+<
+    typename Box,
+    typename IteratorVector,
+    typename ExpandPolicy
+>
+inline void expand_with_elements(Box& total, IteratorVector const& input,
+                                 ExpandPolicy const& expand_policy)
+{
+    typedef typename boost::range_iterator<IteratorVector const>::type it_type;
+    for(it_type it = boost::begin(input); it != boost::end(input); ++it)
+    {
+        expand_policy.apply(total, **it);
+    }
+}
+
+
+// Match forward_range with itself
+template <typename IteratorVector, typename VisitPolicy>
+inline bool handle_one(IteratorVector const& input, VisitPolicy& visitor)
+{
+    if (boost::empty(input))
+    {
+        return true;
+    }
+
+    typedef typename boost::range_iterator<IteratorVector const>::type it_type;
+
+    // Quadratic behaviour at lowest level (lowest quad, or all exceeding)
+    for (it_type it1 = boost::begin(input); it1 != boost::end(input); ++it1)
+    {
+        it_type it2 = it1;
+        for (++it2; it2 != boost::end(input); ++it2)
+        {
+            if (! visitor.apply(**it1, **it2))
+            {
+                return false; // interrupt
+            }
+        }
+    }
+
+    return true;
+}
+
+// Match forward range 1 with forward range 2
+template
+<
+    typename IteratorVector1,
+    typename IteratorVector2,
+    typename VisitPolicy
+>
+inline bool handle_two(IteratorVector1 const& input1,
+                       IteratorVector2 const& input2,
+                       VisitPolicy& visitor)
+{
+    typedef typename boost::range_iterator
+        <
+            IteratorVector1 const
+        >::type iterator_type1;
+
+    typedef typename boost::range_iterator
+        <
+            IteratorVector2 const
+        >::type iterator_type2;
+
+    if (boost::empty(input1) || boost::empty(input2))
+    {
+        return true;
+    }
+
+    for(iterator_type1 it1 = boost::begin(input1);
+        it1 != boost::end(input1);
+        ++it1)
+    {
+        for(iterator_type2 it2 = boost::begin(input2);
+            it2 != boost::end(input2);
+            ++it2)
+        {
+            if (! visitor.apply(**it1, **it2))
+            {
+                return false; // interrupt
+            }
+        }
+    }
+
+    return true;
+}
+
+template <typename IteratorVector>
+inline bool recurse_ok(IteratorVector const& input,
+                       std::size_t min_elements, std::size_t level)
+{
+    return boost::size(input) >= min_elements
+        && level < 100;
+}
+
+template <typename IteratorVector1, typename IteratorVector2>
+inline bool recurse_ok(IteratorVector1 const& input1,
+                       IteratorVector2 const& input2,
+                       std::size_t min_elements, std::size_t level)
+{
+    return boost::size(input1) >= min_elements
+        && recurse_ok(input2, min_elements, level);
+}
+
+template
+<
+    typename IteratorVector1,
+    typename IteratorVector2,
+    typename IteratorVector3
+>
+inline bool recurse_ok(IteratorVector1 const& input1,
+                       IteratorVector2 const& input2,
+                       IteratorVector3 const& input3,
+                       std::size_t min_elements, std::size_t level)
+{
+    return boost::size(input1) >= min_elements
+        && recurse_ok(input2, input3, min_elements, level);
+}
+
+
+template <int Dimension, typename Box>
+class partition_two_ranges;
+
+
+template <int Dimension, typename Box>
+class partition_one_range
+{
+    template <typename IteratorVector, typename ExpandPolicy>
+    static inline Box get_new_box(IteratorVector const& input,
+                                  ExpandPolicy const& expand_policy)
+    {
+        Box box;
+        geometry::assign_inverse(box);
+        expand_with_elements(box, input, expand_policy);
+        return box;
+    }
+
+    template
+    <
+        typename IteratorVector,
+        typename VisitPolicy,
+        typename ExpandPolicy,
+        typename OverlapsPolicy,
+        typename VisitBoxPolicy
+    >
+    static inline bool next_level(Box const& box,
+                                  IteratorVector const& input,
+                                  std::size_t level, std::size_t min_elements,
+                                  VisitPolicy& visitor,
+                                  ExpandPolicy const& expand_policy,
+                                  OverlapsPolicy const& overlaps_policy,
+                                  VisitBoxPolicy& box_policy)
+    {
+        if (recurse_ok(input, min_elements, level))
+        {
+            return partition_one_range
+                <
+                    1 - Dimension,
+                    Box
+                >::apply(box, input, level + 1, min_elements,
+                         visitor, expand_policy, overlaps_policy, box_policy);
+        }
+        else
+        {
+            return handle_one(input, visitor);
+        }
+    }
+
+    // Function to switch to two forward ranges if there are
+    // geometries exceeding the separation line
+    template
+    <
+        typename IteratorVector,
+        typename VisitPolicy,
+        typename ExpandPolicy,
+        typename OverlapsPolicy,
+        typename VisitBoxPolicy
+    >
+    static inline bool next_level2(Box const& box,
+                                   IteratorVector const& input1,
+                                   IteratorVector const& input2,
+                                   std::size_t level, std::size_t min_elements,
+                                   VisitPolicy& visitor,
+                                   ExpandPolicy const& expand_policy,
+                                   OverlapsPolicy const& overlaps_policy,
+                                   VisitBoxPolicy& box_policy)
+    {
+        if (recurse_ok(input1, input2, min_elements, level))
+        {
+            return partition_two_ranges
+                <
+                    1 - Dimension, Box
+                >::apply(box, input1, input2, level + 1, min_elements,
+                         visitor, expand_policy, overlaps_policy,
+                         expand_policy, overlaps_policy, box_policy);
+        }
+        else
+        {
+            return handle_two(input1, input2, visitor);
+        }
+    }
+
+public :
+    template
+    <
+        typename IteratorVector,
+        typename VisitPolicy,
+        typename ExpandPolicy,
+        typename OverlapsPolicy,
+        typename VisitBoxPolicy
+    >
+    static inline bool apply(Box const& box,
+                             IteratorVector const& input,
+                             std::size_t level,
+                             std::size_t min_elements,
+                             VisitPolicy& visitor,
+                             ExpandPolicy const& expand_policy,
+                             OverlapsPolicy const& overlaps_policy,
+                             VisitBoxPolicy& box_policy)
+    {
+        box_policy.apply(box, level);
+
+        Box lower_box, upper_box;
+        divide_box<Dimension>(box, lower_box, upper_box);
+
+        IteratorVector lower, upper, exceeding;
+        divide_into_subsets(lower_box, upper_box,
+                            input, lower, upper, exceeding,
+                            overlaps_policy);
+
+        if (! boost::empty(exceeding))
+        {
+            // Get the box of exceeding-only
+            Box exceeding_box = get_new_box(exceeding, expand_policy);
+
+                   // Recursively do exceeding elements only, in next dimension they
+                   // will probably be less exceeding within the new box
+            if (! (next_level(exceeding_box, exceeding, level, min_elements,
+                              visitor, expand_policy, overlaps_policy, box_policy)
+                   // Switch to two forward ranges, combine exceeding with
+                   // lower resp upper, but not lower/lower, upper/upper
+                && next_level2(exceeding_box, exceeding, lower, level, min_elements,
+                               visitor, expand_policy, overlaps_policy, box_policy)
+                && next_level2(exceeding_box, exceeding, upper, level, min_elements,
+                               visitor, expand_policy, overlaps_policy, box_policy)) )
+            {
+                return false; // interrupt
+            }
+        }
+
+        // Recursively call operation both parts
+        return next_level(lower_box, lower, level, min_elements,
+                          visitor, expand_policy, overlaps_policy, box_policy)
+            && next_level(upper_box, upper, level, min_elements,
+                          visitor, expand_policy, overlaps_policy, box_policy);
+    }
+};
+
+template
+<
+    int Dimension,
+    typename Box
+>
+class partition_two_ranges
+{
+    template
+    <
+        typename IteratorVector1,
+        typename IteratorVector2,
+        typename VisitPolicy,
+        typename ExpandPolicy1,
+        typename OverlapsPolicy1,
+        typename ExpandPolicy2,
+        typename OverlapsPolicy2,
+        typename VisitBoxPolicy
+    >
+    static inline bool next_level(Box const& box,
+                                  IteratorVector1 const& input1,
+                                  IteratorVector2 const& input2,
+                                  std::size_t level, std::size_t min_elements,
+                                  VisitPolicy& visitor,
+                                  ExpandPolicy1 const& expand_policy1,
+                                  OverlapsPolicy1 const& overlaps_policy1,
+                                  ExpandPolicy2 const& expand_policy2,
+                                  OverlapsPolicy2 const& overlaps_policy2,
+                                  VisitBoxPolicy& box_policy)
+    {
+        return partition_two_ranges
+            <
+                1 - Dimension, Box
+            >::apply(box, input1, input2, level + 1, min_elements,
+                     visitor, expand_policy1, overlaps_policy1,
+                     expand_policy2, overlaps_policy2, box_policy);
+    }
+
+    template <typename IteratorVector, typename ExpandPolicy>
+    static inline Box get_new_box(IteratorVector const& input,
+                                  ExpandPolicy const& expand_policy)
+    {
+        Box box;
+        geometry::assign_inverse(box);
+        expand_with_elements(box, input, expand_policy);
+        return box;
+    }
+
+    template
+    <
+        typename IteratorVector1, typename IteratorVector2,
+        typename ExpandPolicy1, typename ExpandPolicy2
+    >
+    static inline Box get_new_box(IteratorVector1 const& input1,
+                                  IteratorVector2 const& input2,
+                                  ExpandPolicy1 const& expand_policy1,
+                                  ExpandPolicy2 const& expand_policy2)
+    {
+        Box box = get_new_box(input1, expand_policy1);
+        expand_with_elements(box, input2, expand_policy2);
+        return box;
+    }
+
+public :
+    template
+    <
+        typename IteratorVector1,
+        typename IteratorVector2,
+        typename VisitPolicy,
+        typename ExpandPolicy1,
+        typename OverlapsPolicy1,
+        typename ExpandPolicy2,
+        typename OverlapsPolicy2,
+        typename VisitBoxPolicy
+    >
+    static inline bool apply(Box const& box,
+                             IteratorVector1 const& input1,
+                             IteratorVector2 const& input2,
+                             std::size_t level,
+                             std::size_t min_elements,
+                             VisitPolicy& visitor,
+                             ExpandPolicy1 const& expand_policy1,
+                             OverlapsPolicy1 const& overlaps_policy1,
+                             ExpandPolicy2 const& expand_policy2,
+                             OverlapsPolicy2 const& overlaps_policy2,
+                             VisitBoxPolicy& box_policy)
+    {
+        box_policy.apply(box, level);
+
+        Box lower_box, upper_box;
+        divide_box<Dimension>(box, lower_box, upper_box);
+
+        IteratorVector1 lower1, upper1, exceeding1;
+        IteratorVector2 lower2, upper2, exceeding2;
+        divide_into_subsets(lower_box, upper_box,
+                            input1, lower1, upper1, exceeding1,
+                            overlaps_policy1);
+        divide_into_subsets(lower_box, upper_box,
+                            input2, lower2, upper2, exceeding2,
+                            overlaps_policy2);
+
+        if (! boost::empty(exceeding1))
+        {
+            // All exceeding from 1 with 2:
+
+            if (recurse_ok(exceeding1, exceeding2, min_elements, level))
+            {
+                Box exceeding_box = get_new_box(exceeding1, exceeding2,
+                                                expand_policy1, expand_policy2);
+                if (! next_level(exceeding_box, exceeding1, exceeding2, level,
+                                 min_elements, visitor, expand_policy1, overlaps_policy1,
+                                 expand_policy2, overlaps_policy2, box_policy))
+                {
+                    return false; // interrupt
+                }
+            }
+            else
+            {
+                if (! handle_two(exceeding1, exceeding2, visitor))
+                {
+                    return false; // interrupt
+                }
+            }
+
+            // All exceeding from 1 with lower and upper of 2:
+
+            // (Check sizes of all three forward ranges to avoid recurse into
+            // the same combinations again and again)
+            if (recurse_ok(lower2, upper2, exceeding1, min_elements, level))
+            {
+                Box exceeding_box = get_new_box(exceeding1, expand_policy1);
+                if (! (next_level(exceeding_box, exceeding1, lower2, level,
+                                  min_elements, visitor, expand_policy1, overlaps_policy1,
+                                  expand_policy2, overlaps_policy2, box_policy)
+                    && next_level(exceeding_box, exceeding1, upper2, level,
+                                  min_elements, visitor, expand_policy1, overlaps_policy1,
+                                  expand_policy2, overlaps_policy2, box_policy)) )
+                {
+                    return false; // interrupt
+                }
+            }
+            else
+            {
+                if (! (handle_two(exceeding1, lower2, visitor)
+                    && handle_two(exceeding1, upper2, visitor)) )
+                {
+                    return false; // interrupt
+                }
+            }
+        }
+
+        if (! boost::empty(exceeding2))
+        {
+            // All exceeding from 2 with lower and upper of 1:
+            if (recurse_ok(lower1, upper1, exceeding2, min_elements, level))
+            {
+                Box exceeding_box = get_new_box(exceeding2, expand_policy2);
+                if (! (next_level(exceeding_box, lower1, exceeding2, level,
+                                  min_elements, visitor, expand_policy1, overlaps_policy1,
+                                  expand_policy2, overlaps_policy2, box_policy)
+                    && next_level(exceeding_box, upper1, exceeding2, level,
+                                  min_elements, visitor, expand_policy1, overlaps_policy1,
+                                  expand_policy2, overlaps_policy2, box_policy)) )
+                {
+                    return false; // interrupt
+                }
+            }
+            else
+            {
+                if (! (handle_two(lower1, exceeding2, visitor)
+                    && handle_two(upper1, exceeding2, visitor)) )
+                {
+                    return false; // interrupt
+                }
+            }
+        }
+
+        if (recurse_ok(lower1, lower2, min_elements, level))
+        {
+            if (! next_level(lower_box, lower1, lower2, level,
+                             min_elements, visitor, expand_policy1, overlaps_policy1,
+                             expand_policy2, overlaps_policy2, box_policy) )
+            {
+                return false; // interrupt
+            }
+        }
+        else
+        {
+            if (! handle_two(lower1, lower2, visitor))
+            {
+                return false; // interrupt
+            }
+        }
+
+        if (recurse_ok(upper1, upper2, min_elements, level))
+        {
+            if (! next_level(upper_box, upper1, upper2, level,
+                             min_elements, visitor, expand_policy1, overlaps_policy1,
+                             expand_policy2, overlaps_policy2, box_policy) )
+            {
+                return false; // interrupt
+            }
+        }
+        else
+        {
+            if (! handle_two(upper1, upper2, visitor))
+            {
+                return false; // interrupt
+            }
+        }
+
+        return true;
+    }
+};
+
+struct visit_no_policy
+{
+    template <typename Box>
+    static inline void apply(Box const&, std::size_t )
+    {}
+};
+
+struct include_all_policy
+{
+    template <typename Item>
+    static inline bool apply(Item const&)
+    {
+        return true;
+    }
+};
+
+
+}} // namespace detail::partition
+
+template
+<
+    typename Box,
+    typename IncludePolicy1 = detail::partition::include_all_policy,
+    typename IncludePolicy2 = detail::partition::include_all_policy
+>
+class partition
+{
+    static const std::size_t default_min_elements = 16;
+
+    template
+    <
+        typename IncludePolicy,
+        typename ForwardRange,
+        typename IteratorVector,
+        typename ExpandPolicy
+    >
+    static inline void expand_to_range(ForwardRange const& forward_range,
+                                       Box& total,
+                                       IteratorVector& iterator_vector,
+                                       ExpandPolicy const& expand_policy)
+    {
+        for(typename boost::range_iterator<ForwardRange const>::type
+                it = boost::begin(forward_range);
+            it != boost::end(forward_range);
+            ++it)
+        {
+            if (IncludePolicy::apply(*it))
+            {
+                expand_policy.apply(total, *it);
+                iterator_vector.push_back(it);
+            }
+        }
+    }
+
+public:
+    template
+    <
+        typename ForwardRange,
+        typename VisitPolicy,
+        typename ExpandPolicy,
+        typename OverlapsPolicy
+    >
+    static inline bool apply(ForwardRange const& forward_range,
+                             VisitPolicy& visitor,
+                             ExpandPolicy const& expand_policy,
+                             OverlapsPolicy const& overlaps_policy)
+    {
+        return apply(forward_range, visitor, expand_policy, overlaps_policy,
+                     default_min_elements, detail::partition::visit_no_policy());
+    }
+
+    template
+    <
+        typename ForwardRange,
+        typename VisitPolicy,
+        typename ExpandPolicy,
+        typename OverlapsPolicy
+    >
+    static inline bool apply(ForwardRange const& forward_range,
+                             VisitPolicy& visitor,
+                             ExpandPolicy const& expand_policy,
+                             OverlapsPolicy const& overlaps_policy,
+                             std::size_t min_elements)
+    {
+        return apply(forward_range, visitor, expand_policy, overlaps_policy,
+                     min_elements, detail::partition::visit_no_policy());
+    }
+
+    template
+    <
+        typename ForwardRange,
+        typename VisitPolicy,
+        typename ExpandPolicy,
+        typename OverlapsPolicy,
+        typename VisitBoxPolicy
+    >
+    static inline bool apply(ForwardRange const& forward_range,
+                             VisitPolicy& visitor,
+                             ExpandPolicy const& expand_policy,
+                             OverlapsPolicy const& overlaps_policy,
+                             std::size_t min_elements,
+                             VisitBoxPolicy box_visitor)
+    {
+        typedef typename boost::range_iterator
+            <
+                ForwardRange const
+            >::type iterator_type;
+
+        if (std::size_t(boost::size(forward_range)) > min_elements)
+        {
+            std::vector<iterator_type> iterator_vector;
+            Box total;
+            assign_inverse(total);
+            expand_to_range<IncludePolicy1>(forward_range, total,
+                                            iterator_vector, expand_policy);
+
+            return detail::partition::partition_one_range
+                <
+                    0, Box
+                >::apply(total, iterator_vector, 0, min_elements,
+                         visitor, expand_policy, overlaps_policy, box_visitor);
+        }
+        else
+        {
+            for(iterator_type it1 = boost::begin(forward_range);
+                it1 != boost::end(forward_range);
+                ++it1)
+            {
+                iterator_type it2 = it1;
+                for(++it2; it2 != boost::end(forward_range); ++it2)
+                {
+                    if (! visitor.apply(*it1, *it2))
+                    {
+                        return false; // interrupt
+                    }
+                }
+            }
+        }
+
+        return true;
+    }
+
+    template
+    <
+        typename ForwardRange1,
+        typename ForwardRange2,
+        typename VisitPolicy,
+        typename ExpandPolicy1,
+        typename OverlapsPolicy1
+    >
+    static inline bool apply(ForwardRange1 const& forward_range1,
+                             ForwardRange2 const& forward_range2,
+                             VisitPolicy& visitor,
+                             ExpandPolicy1 const& expand_policy1,
+                             OverlapsPolicy1 const& overlaps_policy1)
+    {
+        return apply(forward_range1, forward_range2, visitor,
+                     expand_policy1, overlaps_policy1, expand_policy1, overlaps_policy1,
+                     default_min_elements, detail::partition::visit_no_policy());
+    }
+
+    template
+    <
+        typename ForwardRange1,
+        typename ForwardRange2,
+        typename VisitPolicy,
+        typename ExpandPolicy1,
+        typename OverlapsPolicy1,
+        typename ExpandPolicy2,
+        typename OverlapsPolicy2
+    >
+    static inline bool apply(ForwardRange1 const& forward_range1,
+                             ForwardRange2 const& forward_range2,
+                             VisitPolicy& visitor,
+                             ExpandPolicy1 const& expand_policy1,
+                             OverlapsPolicy1 const& overlaps_policy1,
+                             ExpandPolicy2 const& expand_policy2,
+                             OverlapsPolicy2 const& overlaps_policy2)
+    {
+        return apply(forward_range1, forward_range2, visitor,
+                     expand_policy1, overlaps_policy1, expand_policy2, overlaps_policy2,
+                     default_min_elements, detail::partition::visit_no_policy());
+    }
+
+    template
+    <
+        typename ForwardRange1,
+        typename ForwardRange2,
+        typename VisitPolicy,
+        typename ExpandPolicy1,
+        typename OverlapsPolicy1,
+        typename ExpandPolicy2,
+        typename OverlapsPolicy2
+    >
+    static inline bool apply(ForwardRange1 const& forward_range1,
+                             ForwardRange2 const& forward_range2,
+                             VisitPolicy& visitor,
+                             ExpandPolicy1 const& expand_policy1,
+                             OverlapsPolicy1 const& overlaps_policy1,
+                             ExpandPolicy2 const& expand_policy2,
+                             OverlapsPolicy2 const& overlaps_policy2,
+                             std::size_t min_elements)
+    {
+        return apply(forward_range1, forward_range2, visitor,
+                     expand_policy1, overlaps_policy1, expand_policy2, overlaps_policy1,
+                     min_elements, detail::partition::visit_no_policy());
+    }
+
+    template
+    <
+        typename ForwardRange1,
+        typename ForwardRange2,
+        typename VisitPolicy,
+        typename ExpandPolicy1,
+        typename OverlapsPolicy1,
+        typename ExpandPolicy2,
+        typename OverlapsPolicy2,
+        typename VisitBoxPolicy
+    >
+    static inline bool apply(ForwardRange1 const& forward_range1,
+                             ForwardRange2 const& forward_range2,
+                             VisitPolicy& visitor,
+                             ExpandPolicy1 const& expand_policy1,
+                             OverlapsPolicy1 const& overlaps_policy1,
+                             ExpandPolicy2 const& expand_policy2,
+                             OverlapsPolicy2 const& overlaps_policy2,
+                             std::size_t min_elements,
+                             VisitBoxPolicy box_visitor)
+    {
+        typedef typename boost::range_iterator
+            <
+                ForwardRange1 const
+            >::type iterator_type1;
+
+        typedef typename boost::range_iterator
+            <
+                ForwardRange2 const
+            >::type iterator_type2;
+
+        if (std::size_t(boost::size(forward_range1)) > min_elements
+            && std::size_t(boost::size(forward_range2)) > min_elements)
+        {
+            std::vector<iterator_type1> iterator_vector1;
+            std::vector<iterator_type2> iterator_vector2;
+            Box total;
+            assign_inverse(total);
+            expand_to_range<IncludePolicy1>(forward_range1, total,
+                                            iterator_vector1, expand_policy1);
+            expand_to_range<IncludePolicy2>(forward_range2, total,
+                                            iterator_vector2, expand_policy2);
+
+            return detail::partition::partition_two_ranges
+                <
+                    0, Box
+                >::apply(total, iterator_vector1, iterator_vector2,
+                         0, min_elements, visitor, expand_policy1,
+                         overlaps_policy1, expand_policy2, overlaps_policy2,
+                         box_visitor);
+        }
+        else
+        {
+            for(iterator_type1 it1 = boost::begin(forward_range1);
+                it1 != boost::end(forward_range1);
+                ++it1)
+            {
+                for(iterator_type2 it2 = boost::begin(forward_range2);
+                    it2 != boost::end(forward_range2);
+                    ++it2)
+                {
+                    if (! visitor.apply(*it1, *it2))
+                    {
+                        return false; // interrupt
+                    }
+                }
+            }
+        }
+
+        return true;
+    }
+};
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_PARTITION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/point_is_spike_or_equal.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/point_is_spike_or_equal.hpp
new file mode 100644
index 00000000000..b8ea5e30e65
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/point_is_spike_or_equal.hpp
@@ -0,0 +1,147 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2015 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2015, 2017.
+// Modifications copyright (c) 2015-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_POINT_IS_EQUAL_OR_SPIKE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_POINT_IS_EQUAL_OR_SPIKE_HPP
+
+#include <boost/geometry/algorithms/detail/direction_code.hpp>
+#include <boost/geometry/algorithms/detail/recalculate.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/policies/robustness/robust_point_type.hpp>
+#include <boost/geometry/strategies/side.hpp>
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/math.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <typename Point1, typename Point2, typename Point3>
+inline bool collinear_point_is_spike_or_equal(Point1 const& last_point,
+                                                Point2 const& segment_a,
+                                                Point3 const& segment_b)
+{
+    // Check if segment is equal
+    int const sgn_x1 = sign_of_difference<0>(last_point, segment_b);
+    int const sgn_y1 = sign_of_difference<1>(last_point, segment_b);
+    if (sgn_x1 == 0 && sgn_y1 == 0)
+    {
+        return true;
+    }
+
+    // Check if segment moves forward
+    int const sgn_x2 = sign_of_difference<0>(segment_b, segment_a);
+    int const sgn_y2 = sign_of_difference<1>(segment_b, segment_a);
+
+    return sgn_x1 != sgn_x2 || sgn_y1 != sgn_y2;
+}
+
+// Checks if a point ("last_point") causes a spike w.r.t.
+// the specified two other points (segment_a, segment_b)
+//
+//  x-------x------x
+//  a       lp     b
+//
+// Above, lp generates a spike w.r.t. segment(a,b)
+// So specify last point first, then (a,b)
+// The segment's orientation does matter: if lp is to the right of b
+// no spike is reported
+template
+<
+    typename Point1, typename Point2, typename Point3,
+    typename SideStrategy
+>
+static inline bool point_is_spike_or_equal(Point1 const& last_point, // prev | back
+                                           Point2 const& segment_a,  // next | back - 2
+                                           Point3 const& segment_b,  // curr | back - 1 | spike's vertex
+                                           SideStrategy const& strategy)
+{
+    int const side = strategy.apply(segment_a, segment_b, last_point);
+    if (side == 0)
+    {
+        // Last point is collinear w.r.t previous segment.
+#ifdef BOOST_GEOMETRY_ENABLE_POINT_IS_SPIKE_OR_EQUAL_TEST
+        bool r1 = collinear_point_is_spike_or_equal(last_point, segment_a, segment_b);
+        bool r2 = direction_code(segment_a, segment_b, last_point) < 1;
+        if (r1 != r2)
+            std::cout << "spike detection failure with: " << r1 << " " << r2 << std::endl;
+        return r2;
+#else
+        return direction_code(segment_a, segment_b, last_point) < 1;
+#endif
+    }
+    return false;
+}
+
+template
+<
+    typename Point1,
+    typename Point2,
+    typename Point3,
+    typename SideStrategy,
+    typename RobustPolicy
+>
+static inline bool point_is_spike_or_equal(Point1 const& last_point,
+            Point2 const& segment_a,
+            Point3 const& segment_b,
+            SideStrategy const& strategy,
+            RobustPolicy const& robust_policy)
+{
+    if (point_is_spike_or_equal(last_point, segment_a, segment_b, strategy))
+    {
+        return true;
+    }
+
+    if (BOOST_GEOMETRY_CONDITION(! RobustPolicy::enabled))
+    {
+        return false;
+    }
+
+    // Try using specified robust policy
+    typedef typename geometry::robust_point_type
+    <
+        Point1,
+        RobustPolicy
+    >::type robust_point_type;
+
+    robust_point_type last_point_rob, segment_a_rob, segment_b_rob;
+    geometry::recalculate(last_point_rob, last_point, robust_policy);
+    geometry::recalculate(segment_a_rob, segment_a, robust_policy);
+    geometry::recalculate(segment_b_rob, segment_b, robust_policy);
+
+    return point_is_spike_or_equal
+        (
+            last_point_rob,
+            segment_a_rob,
+            segment_b_rob,
+            strategy
+        );
+}
+
+
+} // namespace detail
+#endif
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_POINT_IS_EQUAL_OR_SPIKE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/point_on_border.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/point_on_border.hpp
new file mode 100644
index 00000000000..831081aa695
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/point_on_border.hpp
@@ -0,0 +1,319 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.Dimension. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_POINT_ON_BORDER_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_POINT_ON_BORDER_HPP
+
+
+#include <cstddef>
+
+#include <boost/range.hpp>
+#include <boost/static_assert.hpp>
+
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/algorithms/detail/convert_point_to_point.hpp>
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace point_on_border
+{
+
+
+struct get_point
+{
+    template <typename Point>
+    static inline bool apply(Point& destination, Point const& source)
+    {
+        destination = source;
+        return true;
+    }
+};
+
+template<typename Point, std::size_t Dimension, std::size_t DimensionCount>
+struct midpoint_helper
+{
+    template <typename InputPoint>
+    static inline bool apply(Point& p, InputPoint const& p1, InputPoint const& p2)
+    {
+        typename coordinate_type<Point>::type const two = 2;
+        set<Dimension>(p,
+                    (get<Dimension>(p1) + get<Dimension>(p2)) / two);
+        return midpoint_helper<Point, Dimension + 1, DimensionCount>::apply(p, p1, p2);
+    }
+};
+
+
+template <typename Point, std::size_t DimensionCount>
+struct midpoint_helper<Point, DimensionCount, DimensionCount>
+{
+    template <typename InputPoint>
+    static inline bool apply(Point& , InputPoint const& , InputPoint const& )
+    {
+        return true;
+    }
+};
+
+
+template <bool Midpoint>
+struct point_on_range
+{
+    // Version with iterator
+    template<typename Point, typename Iterator>
+    static inline bool apply(Point& point, Iterator begin, Iterator end)
+    {
+        Iterator it = begin;
+        if (it == end)
+        {
+            return false;
+        }
+
+        if (! Midpoint)
+        {
+            geometry::detail::conversion::convert_point_to_point(*it, point);
+            return true;
+        }
+
+        Iterator prev = it++;
+
+        // Go to next non-duplicate point
+        while (it != end
+            && detail::equals::equals_point_point(*it, *prev))
+        {
+            prev = it++;
+        }
+        if (it != end)
+        {
+            return midpoint_helper
+                <
+                    Point,
+                    0, dimension<Point>::value
+                >::apply(point, *prev, *it);
+        }
+        return false;
+    }
+
+    // Version with range
+    template<typename Point, typename Range>
+    static inline bool apply(Point& point, Range const& range)
+    {
+        typedef typename geometry::cs_tag<Point>::type cs_tag;
+        BOOST_STATIC_ASSERT((! Midpoint || boost::is_same<cs_tag, cartesian_tag>::value));
+
+        return apply(point, boost::begin(range), boost::end(range));
+    }
+};
+
+
+template <bool Midpoint>
+struct point_on_polygon
+{
+    template<typename Point, typename Polygon>
+    static inline bool apply(Point& point, Polygon const& polygon)
+    {
+        return point_on_range
+            <
+                Midpoint
+            >::apply(point, exterior_ring(polygon));
+    }
+};
+
+
+template <bool Midpoint>
+struct point_on_box
+{
+    template<typename Point, typename Box>
+    static inline bool apply(Point& point, Box const& box)
+    {
+        if (BOOST_GEOMETRY_CONDITION(Midpoint))
+        {
+            Point p1, p2;
+            detail::assign::assign_box_2d_corner<min_corner, min_corner>(box, p1);
+            detail::assign::assign_box_2d_corner<max_corner, min_corner>(box, p2);
+            midpoint_helper
+                <
+                    Point,
+                    0, dimension<Point>::value
+                >::apply(point, p1, p2);
+        }
+        else
+        {
+            detail::assign::assign_box_2d_corner<min_corner, min_corner>(box, point);
+        }
+
+        return true;
+    }
+};
+
+
+template <typename Policy>
+struct point_on_multi
+{
+    template<typename Point, typename MultiGeometry>
+    static inline bool apply(Point& point, MultiGeometry const& multi)
+    {
+        // Take a point on the first multi-geometry
+        // (i.e. the first that is not empty)
+        for (typename boost::range_iterator
+                <
+                    MultiGeometry const
+                >::type it = boost::begin(multi);
+            it != boost::end(multi);
+            ++it)
+        {
+            if (Policy::apply(point, *it))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+};
+
+
+}} // namespace detail::point_on_border
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template
+<
+    typename GeometryTag,
+    bool Midpoint
+
+>
+struct point_on_border
+{};
+
+
+template <bool Midpoint>
+struct point_on_border<point_tag, Midpoint>
+    : detail::point_on_border::get_point
+{};
+
+
+template <bool Midpoint>
+struct point_on_border<linestring_tag, Midpoint>
+    : detail::point_on_border::point_on_range<Midpoint>
+{};
+
+
+template <bool Midpoint>
+struct point_on_border<ring_tag, Midpoint>
+    : detail::point_on_border::point_on_range<Midpoint>
+{};
+
+
+template <bool Midpoint>
+struct point_on_border<polygon_tag, Midpoint>
+    : detail::point_on_border::point_on_polygon<Midpoint>
+{};
+
+
+template <bool Midpoint>
+struct point_on_border<box_tag, Midpoint>
+    : detail::point_on_border::point_on_box<Midpoint>
+{};
+
+
+template <bool Midpoint>
+struct point_on_border<multi_polygon_tag, Midpoint>
+    : detail::point_on_border::point_on_multi
+        <
+            detail::point_on_border::point_on_polygon<Midpoint>
+        >
+{};
+
+
+template <bool Midpoint>
+struct point_on_border<multi_linestring_tag, Midpoint>
+    : detail::point_on_border::point_on_multi
+        <
+            detail::point_on_border::point_on_range<Midpoint>
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+/*!
+\brief Take point on a border
+\ingroup overlay
+\tparam Geometry geometry type. This also defines the type of the output point
+\param point to assign
+\param geometry geometry to take point from
+\return TRUE if successful, else false.
+    It is only false if polygon/line have no points
+\note for a polygon, it is always a point on the exterior ring
+ */
+template <typename Point, typename Geometry>
+inline bool point_on_border(Point& point, Geometry const& geometry)
+{
+    concepts::check<Point>();
+    concepts::check<Geometry const>();
+
+    return dispatch::point_on_border
+            <
+                typename tag<Geometry>::type,
+                false
+            >::apply(point, geometry);
+}
+
+
+/*!
+\tparam Midpoint boolean flag, true if the point should not be a vertex, but some point
+    in between of two vertices
+\note for Midpoint, it is not taken from two consecutive duplicate vertices,
+    (unless there are no other).
+ */
+/*
+template <bool Midpoint, typename Point, typename Geometry>
+inline bool point_on_border(Point& point, Geometry const& geometry)
+{
+    concepts::check<Point>();
+    concepts::check<Geometry const>();
+
+    return dispatch::point_on_border
+            <
+                typename tag<Geometry>::type,
+                Midpoint
+            >::apply(point, geometry);
+}
+*/
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_POINT_ON_BORDER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/recalculate.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/recalculate.hpp
new file mode 100644
index 00000000000..b75dd135e0d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/recalculate.hpp
@@ -0,0 +1,234 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2013 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2013 Bruno Lalande, Paris, France.
+// Copyright (c) 2013 Mateusz Loskot, London, UK.
+// Copyright (c) 2013 Adam Wulkiewicz, Lodz, Poland.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RECALCULATE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RECALCULATE_HPP
+
+
+#include <cstddef>
+
+#include <boost/concept/requires.hpp>
+#include <boost/concept_check.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/numeric/conversion/bounds.hpp>
+#include <boost/numeric/conversion/cast.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/size.hpp>
+
+#include <boost/geometry/arithmetic/arithmetic.hpp>
+#include <boost/geometry/algorithms/append.hpp>
+#include <boost/geometry/algorithms/clear.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace recalculate
+{
+
+template <std::size_t Dimension>
+struct recalculate_point
+{
+    template <typename Point1, typename Point2, typename Strategy>
+    static inline void apply(Point1& point1, Point2 const& point2, Strategy const& strategy)
+    {
+        std::size_t const dim = Dimension - 1;
+        geometry::set<dim>(point1, strategy.template apply<dim>(geometry::get<dim>(point2)));
+        recalculate_point<dim>::apply(point1, point2, strategy);
+    }
+};
+
+template <>
+struct recalculate_point<0>
+{
+    template <typename Point1, typename Point2, typename Strategy>
+    static inline void apply(Point1&, Point2 const&, Strategy const&)
+    {
+    }
+};
+
+
+template <std::size_t Dimension>
+struct recalculate_indexed
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline void apply(Geometry1& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        // Do it for both indices in one dimension
+        static std::size_t const dim = Dimension - 1;
+        geometry::set<0, dim>(geometry1, strategy.template apply<dim>(geometry::get<0, dim>(geometry2)));
+        geometry::set<1, dim>(geometry1, strategy.template apply<dim>(geometry::get<1, dim>(geometry2)));
+        recalculate_indexed<dim>::apply(geometry1, geometry2, strategy);
+    }
+};
+
+template <>
+struct recalculate_indexed<0>
+{
+
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline void apply(Geometry1& , Geometry2 const& , Strategy const& )
+    {
+    }
+};
+
+struct range_to_range
+{
+    template
+    <
+        typename Range1,
+        typename Range2,
+        typename Strategy
+    >
+    static inline void apply(Range1& destination, Range2 const& source,
+            Strategy const& strategy)
+    {
+        typedef typename geometry::point_type<Range2>::type point_type;
+        typedef recalculate_point<geometry::dimension<point_type>::value> per_point;
+        geometry::clear(destination);
+
+        for (typename boost::range_iterator<Range2 const>::type it
+                = boost::begin(source);
+            it != boost::end(source);
+            ++it)
+        {
+            point_type p;
+            per_point::apply(p, *it, strategy);
+            geometry::append(destination, p);
+        }
+    }
+};
+
+struct polygon_to_polygon
+{
+private:
+    template
+    <
+        typename IteratorIn,
+        typename IteratorOut,
+        typename Strategy
+    >
+    static inline void iterate(IteratorIn begin, IteratorIn end,
+                    IteratorOut it_out,
+                    Strategy const& strategy)
+    {
+        for (IteratorIn it_in = begin; it_in != end;  ++it_in, ++it_out)
+        {
+            range_to_range::apply(*it_out, *it_in, strategy);
+        }
+    }
+
+    template
+    <
+        typename InteriorRingsOut,
+        typename InteriorRingsIn,
+        typename Strategy
+    >
+    static inline void apply_interior_rings(
+                    InteriorRingsOut& interior_rings_out,
+                    InteriorRingsIn const& interior_rings_in,
+                    Strategy const& strategy)
+    {
+        traits::resize<InteriorRingsOut>::apply(interior_rings_out,
+            boost::size(interior_rings_in));
+
+        iterate(
+            boost::begin(interior_rings_in), boost::end(interior_rings_in),
+            boost::begin(interior_rings_out),
+            strategy);
+    }
+
+public:
+    template
+    <
+        typename Polygon1,
+        typename Polygon2,
+        typename Strategy
+    >
+    static inline void apply(Polygon1& destination, Polygon2 const& source,
+            Strategy const& strategy)
+    {
+        range_to_range::apply(geometry::exterior_ring(destination),
+            geometry::exterior_ring(source), strategy);
+
+        apply_interior_rings(geometry::interior_rings(destination),
+            geometry::interior_rings(source), strategy);
+    }
+};
+
+}} // namespace detail::recalculate
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename Tag1 = typename geometry::tag<Geometry1>::type,
+    typename Tag2 = typename geometry::tag<Geometry2>::type
+>
+struct recalculate : not_implemented<Tag1, Tag2>
+{};
+
+template <typename Point1, typename Point2>
+struct recalculate<Point1, Point2, point_tag, point_tag>
+    : detail::recalculate::recalculate_point<geometry::dimension<Point1>::value>
+{};
+
+template <typename Box1, typename Box2>
+struct recalculate<Box1, Box2, box_tag, box_tag>
+    : detail::recalculate::recalculate_indexed<geometry::dimension<Box1>::value>
+{};
+
+template <typename Segment1, typename Segment2>
+struct recalculate<Segment1, Segment2, segment_tag, segment_tag>
+    : detail::recalculate::recalculate_indexed<geometry::dimension<Segment1>::value>
+{};
+
+template <typename Polygon1, typename Polygon2>
+struct recalculate<Polygon1, Polygon2, polygon_tag, polygon_tag>
+    : detail::recalculate::polygon_to_polygon
+{};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+
+template <typename Geometry1, typename Geometry2, typename Strategy>
+inline void recalculate(Geometry1& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+{
+    concepts::check<Geometry1>();
+    concepts::check<Geometry2 const>();
+
+    // static assert dimensions (/types) are the same
+
+    dispatch::recalculate<Geometry1, Geometry2>::apply(geometry1, geometry2, strategy);
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RECALCULATE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/areal_areal.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/areal_areal.hpp
new file mode 100644
index 00000000000..800fbb2e96f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/areal_areal.hpp
@@ -0,0 +1,878 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2013, 2014, 2015, 2017.
+// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_AREAL_AREAL_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_AREAL_AREAL_HPP
+
+#include <boost/geometry/core/topological_dimension.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/algorithms/num_interior_rings.hpp>
+#include <boost/geometry/algorithms/detail/point_on_border.hpp>
+#include <boost/geometry/algorithms/detail/sub_range.hpp>
+#include <boost/geometry/algorithms/detail/single_geometry.hpp>
+
+#include <boost/geometry/algorithms/detail/relate/point_geometry.hpp>
+#include <boost/geometry/algorithms/detail/relate/turns.hpp>
+#include <boost/geometry/algorithms/detail/relate/boundary_checker.hpp>
+#include <boost/geometry/algorithms/detail/relate/follow_helpers.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace relate {
+    
+// WARNING!
+// TODO: In the worst case calling this Pred in a loop for MultiPolygon/MultiPolygon may take O(NM)
+// Use the rtree in this case!
+
+// may be used to set EI and EB for an Areal geometry for which no turns were generated
+template
+<
+    typename OtherAreal,
+    typename Result,
+    typename PointInArealStrategy,
+    bool TransposeResult
+>
+class no_turns_aa_pred
+{
+public:
+    no_turns_aa_pred(OtherAreal const& other_areal,
+                     Result & res,
+                     PointInArealStrategy const& point_in_areal_strategy)
+        : m_result(res)
+        , m_point_in_areal_strategy(point_in_areal_strategy)
+        , m_other_areal(other_areal)
+        , m_flags(0)
+    {
+        // check which relations must be analysed
+
+        if ( ! may_update<interior, interior, '2', TransposeResult>(m_result)
+          && ! may_update<boundary, interior, '1', TransposeResult>(m_result)
+          && ! may_update<exterior, interior, '2', TransposeResult>(m_result) )
+        {
+            m_flags |= 1;
+        }
+
+        if ( ! may_update<interior, exterior, '2', TransposeResult>(m_result)
+          && ! may_update<boundary, exterior, '1', TransposeResult>(m_result) )
+        {
+            m_flags |= 2;
+        }
+    }
+
+    template <typename Areal>
+    bool operator()(Areal const& areal)
+    {
+        using detail::within::point_in_geometry;
+
+        // if those flags are set nothing will change
+        if ( m_flags == 3 )
+        {
+            return false;
+        }
+
+        typedef typename geometry::point_type<Areal>::type point_type;
+        point_type pt;
+        bool const ok = boost::geometry::point_on_border(pt, areal);
+
+        // TODO: for now ignore, later throw an exception?
+        if ( !ok )
+        {
+            return true;
+        }
+
+        // check if the areal is inside the other_areal
+        // TODO: This is O(N)
+        // Run in a loop O(NM) - optimize!
+        int const pig = point_in_geometry(pt,
+                                          m_other_areal,
+                                          m_point_in_areal_strategy);
+        //BOOST_GEOMETRY_ASSERT( pig != 0 );
+        
+        // inside
+        if ( pig > 0 )
+        {
+            update<interior, interior, '2', TransposeResult>(m_result);
+            update<boundary, interior, '1', TransposeResult>(m_result);
+            update<exterior, interior, '2', TransposeResult>(m_result);
+            m_flags |= 1;
+
+            // TODO: OPTIMIZE!
+            // Only the interior rings of other ONE single geometry must be checked
+            // NOT all geometries
+
+            // Check if any interior ring is outside
+            ring_identifier ring_id(0, -1, 0);
+            std::size_t const irings_count = geometry::num_interior_rings(areal);
+            for ( ; static_cast<std::size_t>(ring_id.ring_index) < irings_count ;
+                    ++ring_id.ring_index )
+            {
+                typename detail::sub_range_return_type<Areal const>::type
+                    range_ref = detail::sub_range(areal, ring_id);
+
+                if ( boost::empty(range_ref) )
+                {
+                    // TODO: throw exception?
+                    continue; // ignore
+                }
+
+                // TODO: O(N)
+                // Optimize!
+                int const hpig = point_in_geometry(range::front(range_ref),
+                                                   m_other_areal,
+                                                   m_point_in_areal_strategy);
+
+                // hole outside
+                if ( hpig < 0 )
+                {
+                    update<interior, exterior, '2', TransposeResult>(m_result);
+                    update<boundary, exterior, '1', TransposeResult>(m_result);
+                    m_flags |= 2;
+                    break;
+                }
+            }
+        }
+        // outside
+        else
+        {
+            update<interior, exterior, '2', TransposeResult>(m_result);
+            update<boundary, exterior, '1', TransposeResult>(m_result);
+            m_flags |= 2;
+
+            // Check if any interior ring is inside
+            ring_identifier ring_id(0, -1, 0);
+            std::size_t const irings_count = geometry::num_interior_rings(areal);
+            for ( ; static_cast<std::size_t>(ring_id.ring_index) < irings_count ;
+                    ++ring_id.ring_index )
+            {
+                typename detail::sub_range_return_type<Areal const>::type
+                    range_ref = detail::sub_range(areal, ring_id);
+
+                if ( boost::empty(range_ref) )
+                {
+                    // TODO: throw exception?
+                    continue; // ignore
+                }
+
+                // TODO: O(N)
+                // Optimize!
+                int const hpig = point_in_geometry(range::front(range_ref),
+                                                   m_other_areal,
+                                                   m_point_in_areal_strategy);
+
+                // hole inside
+                if ( hpig > 0 )
+                {
+                    update<interior, interior, '2', TransposeResult>(m_result);
+                    update<boundary, interior, '1', TransposeResult>(m_result);
+                    update<exterior, interior, '2', TransposeResult>(m_result);
+                    m_flags |= 1;
+                    break;
+                }
+            }
+        }
+                    
+        return m_flags != 3 && !m_result.interrupt;
+    }
+
+private:
+    Result & m_result;
+    PointInArealStrategy const& m_point_in_areal_strategy;
+    OtherAreal const& m_other_areal;
+    int m_flags;
+};
+
+// The implementation of an algorithm calculating relate() for A/A
+template <typename Geometry1, typename Geometry2>
+struct areal_areal
+{
+    // check Linear / Areal
+    BOOST_STATIC_ASSERT(topological_dimension<Geometry1>::value == 2
+                     && topological_dimension<Geometry2>::value == 2);
+
+    static const bool interruption_enabled = true;
+
+    typedef typename geometry::point_type<Geometry1>::type point1_type;
+    typedef typename geometry::point_type<Geometry2>::type point2_type;
+    
+    template <typename Result, typename IntersectionStrategy>
+    static inline void apply(Geometry1 const& geometry1, Geometry2 const& geometry2,
+                             Result & result,
+                             IntersectionStrategy const& intersection_strategy)
+    {
+// TODO: If Areal geometry may have infinite size, change the following line:
+
+        // The result should be FFFFFFFFF
+        relate::set<exterior, exterior, result_dimension<Geometry2>::value>(result);// FFFFFFFFd, d in [1,9] or T
+
+        if ( BOOST_GEOMETRY_CONDITION(result.interrupt) )
+            return;
+
+        // get and analyse turns
+        typedef typename turns::get_turns<Geometry1, Geometry2>::turn_info turn_type;
+        std::vector<turn_type> turns;
+
+        interrupt_policy_areal_areal<Result> interrupt_policy(geometry1, geometry2, result);
+
+        turns::get_turns<Geometry1, Geometry2>::apply(turns, geometry1, geometry2, interrupt_policy, intersection_strategy);
+        if ( BOOST_GEOMETRY_CONDITION(result.interrupt) )
+            return;
+
+        typedef typename IntersectionStrategy::template point_in_geometry_strategy
+            <
+                Geometry1, Geometry2
+            >::type point_in_areal_strategy12_type;
+        point_in_areal_strategy12_type point_in_areal_strategy12
+            = intersection_strategy.template get_point_in_geometry_strategy<Geometry1, Geometry2>();
+        typedef typename IntersectionStrategy::template point_in_geometry_strategy
+            <
+                Geometry2, Geometry1
+            >::type point_in_areal_strategy21_type;
+        point_in_areal_strategy21_type point_in_areal_strategy21
+            = intersection_strategy.template get_point_in_geometry_strategy<Geometry2, Geometry1>();
+
+        no_turns_aa_pred<Geometry2, Result, point_in_areal_strategy12_type, false>
+            pred1(geometry2, result, point_in_areal_strategy12);
+        for_each_disjoint_geometry_if<0, Geometry1>::apply(turns.begin(), turns.end(), geometry1, pred1);
+        if ( BOOST_GEOMETRY_CONDITION(result.interrupt) )
+            return;
+
+        no_turns_aa_pred<Geometry1, Result, point_in_areal_strategy21_type, true>
+            pred2(geometry1, result, point_in_areal_strategy21);
+        for_each_disjoint_geometry_if<1, Geometry2>::apply(turns.begin(), turns.end(), geometry2, pred2);
+        if ( BOOST_GEOMETRY_CONDITION(result.interrupt) )
+            return;
+        
+        if ( turns.empty() )
+            return;
+
+        if ( may_update<interior, interior, '2'>(result)
+          || may_update<interior, exterior, '2'>(result)
+          || may_update<boundary, interior, '1'>(result)
+          || may_update<boundary, exterior, '1'>(result)
+          || may_update<exterior, interior, '2'>(result) )
+        {
+            // sort turns
+            typedef turns::less<0, turns::less_op_areal_areal<0> > less;
+            std::sort(turns.begin(), turns.end(), less());
+
+            /*if ( may_update<interior, exterior, '2'>(result)
+              || may_update<boundary, exterior, '1'>(result)
+              || may_update<boundary, interior, '1'>(result)
+              || may_update<exterior, interior, '2'>(result) )*/
+            {
+                // analyse sorted turns
+                turns_analyser<turn_type, 0> analyser;
+                analyse_each_turn(result, analyser, turns.begin(), turns.end());
+
+                if ( BOOST_GEOMETRY_CONDITION(result.interrupt) )
+                    return;
+            }
+
+            if ( may_update<interior, interior, '2'>(result)
+              || may_update<interior, exterior, '2'>(result)
+              || may_update<boundary, interior, '1'>(result)
+              || may_update<boundary, exterior, '1'>(result)
+              || may_update<exterior, interior, '2'>(result) )
+            {
+                // analyse rings for which turns were not generated
+                // or only i/i or u/u was generated
+                uncertain_rings_analyser<0, Result, Geometry1, Geometry2, point_in_areal_strategy12_type>
+                    rings_analyser(result, geometry1, geometry2, point_in_areal_strategy12);
+                analyse_uncertain_rings<0>::apply(rings_analyser, turns.begin(), turns.end());
+
+                if ( BOOST_GEOMETRY_CONDITION(result.interrupt) )
+                    return;
+            }
+        }
+
+        if ( may_update<interior, interior, '2', true>(result)
+          || may_update<interior, exterior, '2', true>(result)
+          || may_update<boundary, interior, '1', true>(result)
+          || may_update<boundary, exterior, '1', true>(result)
+          || may_update<exterior, interior, '2', true>(result) )
+        {
+            // sort turns
+            typedef turns::less<1, turns::less_op_areal_areal<1> > less;
+            std::sort(turns.begin(), turns.end(), less());
+
+            /*if ( may_update<interior, exterior, '2', true>(result)
+              || may_update<boundary, exterior, '1', true>(result)
+              || may_update<boundary, interior, '1', true>(result)
+              || may_update<exterior, interior, '2', true>(result) )*/
+            {
+                // analyse sorted turns
+                turns_analyser<turn_type, 1> analyser;
+                analyse_each_turn(result, analyser, turns.begin(), turns.end());
+
+                if ( BOOST_GEOMETRY_CONDITION(result.interrupt) )
+                    return;
+            }
+
+            if ( may_update<interior, interior, '2', true>(result)
+              || may_update<interior, exterior, '2', true>(result)
+              || may_update<boundary, interior, '1', true>(result)
+              || may_update<boundary, exterior, '1', true>(result)
+              || may_update<exterior, interior, '2', true>(result) )
+            {
+                // analyse rings for which turns were not generated
+                // or only i/i or u/u was generated
+                uncertain_rings_analyser<1, Result, Geometry2, Geometry1, point_in_areal_strategy21_type>
+                    rings_analyser(result, geometry2, geometry1, point_in_areal_strategy21);
+                analyse_uncertain_rings<1>::apply(rings_analyser, turns.begin(), turns.end());
+
+                //if ( result.interrupt )
+                //    return;
+            }
+        }
+    }
+
+    // interrupt policy which may be passed to get_turns to interrupt the analysis
+    // based on the info in the passed result/mask
+    template <typename Result>
+    class interrupt_policy_areal_areal
+    {
+    public:
+        static bool const enabled = true;
+
+        interrupt_policy_areal_areal(Geometry1 const& geometry1,
+                                     Geometry2 const& geometry2,
+                                     Result & result)
+            : m_result(result)
+            , m_geometry1(geometry1)
+            , m_geometry2(geometry2)
+        {}
+
+        template <typename Range>
+        inline bool apply(Range const& turns)
+        {
+            typedef typename boost::range_iterator<Range const>::type iterator;
+            
+            for (iterator it = boost::begin(turns) ; it != boost::end(turns) ; ++it)
+            {
+                per_turn<0>(*it);
+                per_turn<1>(*it);
+            }
+
+            return m_result.interrupt;
+        }
+
+    private:
+        template <std::size_t OpId, typename Turn>
+        inline void per_turn(Turn const& turn)
+        {
+            //static const std::size_t other_op_id = (OpId + 1) % 2;
+            static const bool transpose_result = OpId != 0;
+
+            overlay::operation_type const op = turn.operations[OpId].operation;
+
+            if ( op == overlay::operation_union )
+            {
+                // ignore u/u
+                /*if ( turn.operations[other_op_id].operation != overlay::operation_union )
+                {
+                    update<interior, exterior, '2', transpose_result>(m_result);
+                    update<boundary, exterior, '1', transpose_result>(m_result);
+                }*/
+
+                update<boundary, boundary, '0', transpose_result>(m_result);
+            }
+            else if ( op == overlay::operation_intersection )
+            {
+                // ignore i/i
+                /*if ( turn.operations[other_op_id].operation != overlay::operation_intersection )
+                {
+                    // not correct e.g. for G1 touching G2 in a point where a hole is touching the exterior ring
+                    // in this case 2 turns i/... and u/u will be generated for this IP
+                    //update<interior, interior, '2', transpose_result>(m_result);
+
+                    //update<boundary, interior, '1', transpose_result>(m_result);
+                }*/
+
+                update<boundary, boundary, '0', transpose_result>(m_result);
+            }
+            else if ( op == overlay::operation_continue )
+            {
+                update<boundary, boundary, '1', transpose_result>(m_result);
+                update<interior, interior, '2', transpose_result>(m_result);
+            }
+            else if ( op == overlay::operation_blocked )
+            {
+                update<boundary, boundary, '1', transpose_result>(m_result);
+                update<interior, exterior, '2', transpose_result>(m_result);
+            }
+        }
+
+        Result & m_result;
+        Geometry1 const& m_geometry1;
+        Geometry2 const& m_geometry2;
+    };
+
+    // This analyser should be used like Input or SinglePass Iterator
+    // IMPORTANT! It should be called also for the end iterator - last
+    template <typename TurnInfo, std::size_t OpId>
+    class turns_analyser
+    {
+        typedef typename TurnInfo::point_type turn_point_type;
+
+        static const std::size_t op_id = OpId;
+        static const std::size_t other_op_id = (OpId + 1) % 2;
+        static const bool transpose_result = OpId != 0;
+
+    public:
+        turns_analyser()
+            : m_previous_turn_ptr(0)
+            , m_previous_operation(overlay::operation_none)
+            , m_enter_detected(false)
+            , m_exit_detected(false)
+        {}
+
+        template <typename Result,
+                  typename TurnIt>
+        void apply(Result & result, TurnIt it)
+        {
+            //BOOST_GEOMETRY_ASSERT( it != last );
+
+            overlay::operation_type const op = it->operations[op_id].operation;
+
+            if ( op != overlay::operation_union
+              && op != overlay::operation_intersection
+              && op != overlay::operation_blocked
+              && op != overlay::operation_continue )
+            {
+                return;
+            }
+
+            segment_identifier const& seg_id = it->operations[op_id].seg_id;
+            //segment_identifier const& other_id = it->operations[other_op_id].seg_id;
+
+            const bool first_in_range = m_seg_watcher.update(seg_id);
+
+            if ( m_previous_turn_ptr )
+            {
+                if ( m_exit_detected /*m_previous_operation == overlay::operation_union*/ )
+                {
+                    // real exit point - may be multiple
+                    if ( first_in_range
+                      || ! turn_on_the_same_ip<op_id>(*m_previous_turn_ptr, *it) )
+                    {
+                        update_exit(result);
+                        m_exit_detected = false;
+                    }
+                    // fake exit point, reset state
+                    else if ( op != overlay::operation_union )
+                    {
+                        m_exit_detected = false;
+                    }
+                }                
+                /*else*/
+                if ( m_enter_detected /*m_previous_operation == overlay::operation_intersection*/ )
+                {
+                    // real entry point
+                    if ( first_in_range
+                      || ! turn_on_the_same_ip<op_id>(*m_previous_turn_ptr, *it) )
+                    {
+                        update_enter(result);
+                        m_enter_detected = false;
+                    }
+                    // fake entry point, reset state
+                    else if ( op != overlay::operation_intersection )
+                    {
+                        m_enter_detected = false;
+                    }
+                }
+            }
+
+            if ( op == overlay::operation_union )
+            {
+                // already set in interrupt policy
+                //update<boundary, boundary, '0', transpose_result>(m_result);
+
+                // ignore u/u
+                //if ( it->operations[other_op_id].operation != overlay::operation_union )
+                {
+                    m_exit_detected = true;
+                }
+            }
+            else if ( op == overlay::operation_intersection )
+            {
+                // ignore i/i
+                if ( it->operations[other_op_id].operation != overlay::operation_intersection )
+                {
+                    // this was set in the interrupt policy but it was wrong
+                    // also here it's wrong since it may be a fake entry point
+                    //update<interior, interior, '2', transpose_result>(result);
+
+                    // already set in interrupt policy
+                    //update<boundary, boundary, '0', transpose_result>(result);
+                    m_enter_detected = true;
+                }
+            }
+            else if ( op == overlay::operation_blocked )
+            {
+                // already set in interrupt policy
+            }
+            else // if ( op == overlay::operation_continue )
+            {
+                // already set in interrupt policy
+            }
+
+            // store ref to previously analysed (valid) turn
+            m_previous_turn_ptr = boost::addressof(*it);
+            // and previously analysed (valid) operation
+            m_previous_operation = op;
+        }
+
+        // it == last
+        template <typename Result>
+        void apply(Result & result)
+        {
+            //BOOST_GEOMETRY_ASSERT( first != last );
+
+            if ( m_exit_detected /*m_previous_operation == overlay::operation_union*/ )
+            {
+                update_exit(result);
+                m_exit_detected = false;
+            }
+
+            if ( m_enter_detected /*m_previous_operation == overlay::operation_intersection*/ )
+            {
+                update_enter(result);
+                m_enter_detected = false;
+            }
+        }
+
+        template <typename Result>
+        static inline void update_exit(Result & result)
+        {
+            update<interior, exterior, '2', transpose_result>(result);
+            update<boundary, exterior, '1', transpose_result>(result);
+        }
+
+        template <typename Result>
+        static inline void update_enter(Result & result)
+        {
+            update<interior, interior, '2', transpose_result>(result);
+            update<boundary, interior, '1', transpose_result>(result);
+            update<exterior, interior, '2', transpose_result>(result);
+        }
+
+    private:
+        segment_watcher<same_ring> m_seg_watcher;
+        TurnInfo * m_previous_turn_ptr;
+        overlay::operation_type m_previous_operation;
+        bool m_enter_detected;
+        bool m_exit_detected;
+    };
+
+    // call analyser.apply() for each turn in range
+    // IMPORTANT! The analyser is also called for the end iterator - last
+    template <typename Result,
+              typename Analyser,
+              typename TurnIt>
+    static inline void analyse_each_turn(Result & res,
+                                         Analyser & analyser,
+                                         TurnIt first, TurnIt last)
+    {
+        if ( first == last )
+            return;
+
+        for ( TurnIt it = first ; it != last ; ++it )
+        {
+            analyser.apply(res, it);
+
+            if ( BOOST_GEOMETRY_CONDITION(res.interrupt) )
+                return;
+        }
+
+        analyser.apply(res);
+    }
+
+    template
+    <
+        std::size_t OpId,
+        typename Result,
+        typename Geometry,
+        typename OtherGeometry,
+        typename PointInArealStrategy
+    >
+    class uncertain_rings_analyser
+    {
+        static const bool transpose_result = OpId != 0;
+        static const int other_id = (OpId + 1) % 2;
+
+    public:
+        inline uncertain_rings_analyser(Result & result,
+                                        Geometry const& geom,
+                                        OtherGeometry const& other_geom,
+                                        PointInArealStrategy const& point_in_areal_strategy)
+            : geometry(geom)
+            , other_geometry(other_geom)
+            , interrupt(result.interrupt) // just in case, could be false as well
+            , m_result(result)
+            , m_point_in_areal_strategy(point_in_areal_strategy)
+            , m_flags(0)
+        {
+            // check which relations must be analysed
+            // NOTE: 1 and 4 could probably be connected
+
+            if ( ! may_update<interior, interior, '2', transpose_result>(m_result) )
+            {
+                m_flags |= 1;
+            }
+
+            if ( ! may_update<interior, exterior, '2', transpose_result>(m_result)
+              && ! may_update<boundary, exterior, '1', transpose_result>(m_result) )
+            {
+                m_flags |= 2;
+            }
+
+            if ( ! may_update<boundary, interior, '1', transpose_result>(m_result)
+              && ! may_update<exterior, interior, '2', transpose_result>(m_result) )
+            {
+                m_flags |= 4;
+            }
+        }
+
+        inline void no_turns(segment_identifier const& seg_id)
+        {
+            // if those flags are set nothing will change
+            if ( m_flags == 7 )
+            {
+                return;
+            }
+
+            typename detail::sub_range_return_type<Geometry const>::type
+                range_ref = detail::sub_range(geometry, seg_id);
+
+            if ( boost::empty(range_ref) )
+            {
+                // TODO: throw an exception?
+                return; // ignore
+            }
+                
+            // TODO: possible optimization
+            // if the range is an interior ring we may use other IPs generated for this single geometry
+            // to know which other single geometries should be checked
+
+            // TODO: optimize! e.g. use spatial index
+            // O(N) - running it in a loop gives O(NM)
+            using detail::within::point_in_geometry;
+            int const pig = point_in_geometry(range::front(range_ref),
+                                              other_geometry,
+                                              m_point_in_areal_strategy);
+
+            //BOOST_GEOMETRY_ASSERT(pig != 0);
+            if ( pig > 0 )
+            {
+                update<interior, interior, '2', transpose_result>(m_result);
+                m_flags |= 1;
+
+                update<boundary, interior, '1', transpose_result>(m_result);
+                update<exterior, interior, '2', transpose_result>(m_result);
+                m_flags |= 4;
+            }
+            else
+            {
+                update<boundary, exterior, '1', transpose_result>(m_result);
+                update<interior, exterior, '2', transpose_result>(m_result);
+                m_flags |= 2;
+            }
+
+// TODO: break if all things are set
+// also some of them could be checked outside, before the analysis
+// In this case we shouldn't relay just on dummy flags
+// Flags should be initialized with proper values
+// or the result should be checked directly
+// THIS IS ALSO TRUE FOR OTHER ANALYSERS! in L/L and L/A
+
+            interrupt = m_flags == 7 || m_result.interrupt;
+        }
+
+        template <typename TurnIt>
+        inline void turns(TurnIt first, TurnIt last)
+        {
+            // if those flags are set nothing will change
+            if ( (m_flags & 6) == 6 )
+            {
+                return;
+            }
+
+            bool found_ii = false;
+            bool found_uu = false;
+
+            for ( TurnIt it = first ; it != last ; ++it )
+            {
+                if ( it->operations[0].operation == overlay::operation_intersection 
+                  && it->operations[1].operation == overlay::operation_intersection )
+                {
+                    found_ii = true;
+                }
+                else if ( it->operations[0].operation == overlay::operation_union 
+                       && it->operations[1].operation == overlay::operation_union )
+                {
+                    found_uu = true;
+                }
+                else // ignore
+                {
+                    return; // don't interrupt
+                }
+            }
+
+            // only i/i was generated for this ring
+            if ( found_ii )
+            {
+                update<interior, interior, '2', transpose_result>(m_result);
+                m_flags |= 1;
+
+                //update<boundary, boundary, '0', transpose_result>(m_result);                
+
+                update<boundary, interior, '1', transpose_result>(m_result);
+                update<exterior, interior, '2', transpose_result>(m_result);
+                m_flags |= 4;
+            }
+
+            // only u/u was generated for this ring
+            if ( found_uu )
+            {
+                update<boundary, exterior, '1', transpose_result>(m_result);
+                update<interior, exterior, '2', transpose_result>(m_result);
+                m_flags |= 2;
+            }
+
+            interrupt = m_flags == 7 || m_result.interrupt; // interrupt if the result won't be changed in the future
+        }
+
+        Geometry const& geometry;
+        OtherGeometry const& other_geometry;
+        bool interrupt;
+
+    private:
+        Result & m_result;
+        PointInArealStrategy const& m_point_in_areal_strategy;
+        int m_flags;
+    };
+
+    template <std::size_t OpId>
+    class analyse_uncertain_rings
+    {
+    public:
+        template <typename Analyser, typename TurnIt>
+        static inline void apply(Analyser & analyser, TurnIt first, TurnIt last)
+        {
+            if ( first == last )
+                return;
+
+            for_preceding_rings(analyser, *first);
+            //analyser.per_turn(*first);
+
+            TurnIt prev = first;
+            for ( ++first ; first != last ; ++first, ++prev )
+            {
+                // same multi
+                if ( prev->operations[OpId].seg_id.multi_index
+                  == first->operations[OpId].seg_id.multi_index )
+                {
+                    // same ring
+                    if ( prev->operations[OpId].seg_id.ring_index
+                      == first->operations[OpId].seg_id.ring_index )
+                    {
+                        //analyser.per_turn(*first);
+                    }
+                    // same multi, next ring
+                    else
+                    {
+                        //analyser.end_ring(*prev);
+                        analyser.turns(prev, first);
+
+                        //if ( prev->operations[OpId].seg_id.ring_index + 1
+                        //   < first->operations[OpId].seg_id.ring_index)
+                        {
+                            for_no_turns_rings(analyser,
+                                               *first,
+                                               prev->operations[OpId].seg_id.ring_index + 1,
+                                               first->operations[OpId].seg_id.ring_index);
+                        }
+
+                        //analyser.per_turn(*first);
+                    }
+                }
+                // next multi
+                else
+                {
+                    //analyser.end_ring(*prev);
+                    analyser.turns(prev, first);
+                    for_following_rings(analyser, *prev);
+                    for_preceding_rings(analyser, *first);
+                    //analyser.per_turn(*first);
+                }
+
+                if ( analyser.interrupt )
+                {
+                    return;
+                }
+            }
+
+            //analyser.end_ring(*prev);
+            analyser.turns(prev, first); // first == last
+            for_following_rings(analyser, *prev);
+        }
+
+    private:
+        template <typename Analyser, typename Turn>
+        static inline void for_preceding_rings(Analyser & analyser, Turn const& turn)
+        {
+            segment_identifier const& seg_id = turn.operations[OpId].seg_id;
+
+            for_no_turns_rings(analyser, turn, -1, seg_id.ring_index);
+        }
+
+        template <typename Analyser, typename Turn>
+        static inline void for_following_rings(Analyser & analyser, Turn const& turn)
+        {
+            segment_identifier const& seg_id = turn.operations[OpId].seg_id;
+
+            signed_size_type
+                count = boost::numeric_cast<signed_size_type>(
+                            geometry::num_interior_rings(
+                                detail::single_geometry(analyser.geometry, seg_id)));
+            
+            for_no_turns_rings(analyser, turn, seg_id.ring_index + 1, count);
+        }
+
+        template <typename Analyser, typename Turn>
+        static inline void for_no_turns_rings(Analyser & analyser,
+                                              Turn const& turn,
+                                              signed_size_type first,
+                                              signed_size_type last)
+        {
+            segment_identifier seg_id = turn.operations[OpId].seg_id;
+
+            for ( seg_id.ring_index = first ; seg_id.ring_index < last ; ++seg_id.ring_index )
+            {
+                analyser.no_turns(seg_id);
+            }
+        }
+    };
+};
+
+}} // namespace detail::relate
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_AREAL_AREAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/boundary_checker.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/boundary_checker.hpp
new file mode 100644
index 00000000000..1a9a5a8fd73
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/boundary_checker.hpp
@@ -0,0 +1,160 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014 Oracle and/or its affiliates.
+
+// 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)
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_BOUNDARY_CHECKER_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_BOUNDARY_CHECKER_HPP
+
+#include <boost/geometry/util/range.hpp>
+#include <boost/geometry/algorithms/num_points.hpp>
+#include <boost/geometry/algorithms/detail/sub_range.hpp>
+
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+
+#include <boost/geometry/util/has_nan_coordinate.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace relate {
+
+enum boundary_query { boundary_front, boundary_back, boundary_any };
+
+template <typename Geometry,
+          typename Tag = typename geometry::tag<Geometry>::type>
+class boundary_checker {};
+
+template <typename Geometry>
+class boundary_checker<Geometry, linestring_tag>
+{
+    typedef typename point_type<Geometry>::type point_type;
+
+public:
+    boundary_checker(Geometry const& g)
+        : has_boundary( boost::size(g) >= 2
+                     && !detail::equals::equals_point_point(range::front(g), range::back(g)) )
+        , geometry(g)
+    {}
+
+    template <boundary_query BoundaryQuery>
+    bool is_endpoint_boundary(point_type const& pt) const
+    {
+        boost::ignore_unused_variable_warning(pt);
+#ifdef BOOST_GEOMETRY_DEBUG_RELATE_BOUNDARY_CHECKER
+        // may give false positives for INT
+        BOOST_GEOMETRY_ASSERT( (BoundaryQuery == boundary_front || BoundaryQuery == boundary_any)
+                   && detail::equals::equals_point_point(pt, range::front(geometry))
+                   || (BoundaryQuery == boundary_back || BoundaryQuery == boundary_any)
+                   && detail::equals::equals_point_point(pt, range::back(geometry)) );
+#endif
+        return has_boundary;
+    }
+
+private:
+    bool has_boundary;
+    Geometry const& geometry;
+};
+
+template <typename Geometry>
+class boundary_checker<Geometry, multi_linestring_tag>
+{
+    typedef typename point_type<Geometry>::type point_type;
+
+public:
+    boundary_checker(Geometry const& g)
+        : is_filled(false), geometry(g)
+    {}
+
+    // First call O(NlogN)
+    // Each next call O(logN)
+    template <boundary_query BoundaryQuery>
+    bool is_endpoint_boundary(point_type const& pt) const
+    {
+        typedef typename boost::range_size<Geometry>::type size_type;
+        size_type multi_count = boost::size(geometry);
+
+        if ( multi_count < 1 )
+            return false;
+
+        if ( ! is_filled )
+        {
+            //boundary_points.clear();
+            boundary_points.reserve(multi_count * 2);
+
+            typedef typename boost::range_iterator<Geometry const>::type multi_iterator;
+            for ( multi_iterator it = boost::begin(geometry) ;
+                  it != boost::end(geometry) ; ++ it )
+            {
+                typename boost::range_reference<Geometry const>::type
+                    ls = *it;
+
+                // empty or point - no boundary
+                if (boost::size(ls) < 2)
+                {
+                    continue;
+                }
+
+                typedef typename boost::range_reference
+                    <
+                        typename boost::range_value<Geometry const>::type const
+                    >::type point_reference;
+
+                point_reference front_pt = range::front(ls);
+                point_reference back_pt = range::back(ls);
+
+                // linear ring or point - no boundary
+                if (! equals::equals_point_point(front_pt, back_pt))
+                {
+                    // do not add points containing NaN coordinates
+                    // because they cannot be reasonably compared, e.g. with MSVC
+                    // an assertion failure is reported in std::equal_range()
+                    if (! geometry::has_nan_coordinate(front_pt))
+                    {
+                        boundary_points.push_back(front_pt);
+                    }
+                    if (! geometry::has_nan_coordinate(back_pt))
+                    {
+                        boundary_points.push_back(back_pt);
+                    }
+                }
+            }
+
+            std::sort(boundary_points.begin(),
+                      boundary_points.end(),
+                      geometry::less<point_type>());
+
+            is_filled = true;
+        }
+
+        std::size_t equal_points_count
+            = boost::size(
+                std::equal_range(boundary_points.begin(),
+                                 boundary_points.end(),
+                                 pt,
+                                 geometry::less<point_type>())
+            );
+
+        return equal_points_count % 2 != 0;// && equal_points_count > 0; // the number is odd and > 0
+    }
+
+private:
+    mutable bool is_filled;
+    // TODO: store references/pointers instead of points?
+    mutable std::vector<point_type> boundary_points;
+
+    Geometry const& geometry;
+};
+
+}} // namespace detail::relate
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_BOUNDARY_CHECKER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/de9im.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/de9im.hpp
new file mode 100644
index 00000000000..713a3fc8f01
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/de9im.hpp
@@ -0,0 +1,439 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2013, 2014, 2015.
+// Modifications copyright (c) 2013-2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_DE9IM_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_DE9IM_HPP
+
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/push_back.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/mpl/vector_c.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/tuple/tuple.hpp>
+
+#include <boost/geometry/algorithms/detail/relate/result.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+#include <boost/geometry/core/topological_dimension.hpp>
+#include <boost/geometry/core/tag.hpp>
+
+// TEMP - move this header to geometry/detail
+#include <boost/geometry/index/detail/tuples.hpp>
+
+namespace boost { namespace geometry
+{
+    
+namespace de9im
+{
+
+/*!
+\brief DE-9IM model intersection matrix.
+\ingroup de9im
+\details This matrix can be used to express spatial relations as defined in
+         Dimensionally Extended 9-Intersection Model.
+
+\qbk{[heading See also]}
+\qbk{* [link geometry.reference.algorithms.relation relation]}
+ */
+class matrix
+    : public detail::relate::matrix<3, 3>
+{
+#ifdef DOXYGEN_INVOKED
+public:
+    /*!
+    \brief Initializes all of the matrix elements to F
+     */
+    matrix();
+    /*!
+    \brief Subscript operator
+    \param index The index of the element
+    \return The element
+     */
+    char operator[](std::size_t index) const;
+    /*!
+    \brief Returns the iterator to the first element
+    \return const RandomAccessIterator
+     */
+    const_iterator begin() const;
+    /*!
+    \brief Returns the iterator past the last element
+    \return const RandomAccessIterator
+     */
+    const_iterator end() const;
+    /*!
+    \brief Returns the number of elements
+    \return 9
+     */
+    static std::size_t size();
+    /*!
+    \brief Returns raw pointer to elements
+    \return const pointer to array of elements
+     */
+    inline const char * data() const;
+    /*!
+    \brief Returns std::string containing elements
+    \return string containing elements
+     */
+    inline std::string str() const;
+#endif
+};
+
+/*!
+\brief DE-9IM model intersection mask.
+\ingroup de9im
+\details This mask can be used to check spatial relations as defined in
+         Dimensionally Extended 9-Intersection Model.
+
+\qbk{[heading See also]}
+\qbk{* [link geometry.reference.algorithms.relate relate]}
+ */
+class mask
+    : public detail::relate::mask<3, 3>
+{
+    typedef detail::relate::mask<3, 3> base_type;
+
+public:
+    /*!
+    \brief The constructor.
+    \param code The mask pattern.
+    */
+    inline explicit mask(const char* code)
+        : base_type(code)
+    {}
+    
+    /*!
+    \brief The constructor.
+    \param code The mask pattern.
+    */
+    inline explicit mask(std::string const& code)
+        : base_type(code.c_str(), code.size())
+    {}
+};
+
+// static_mask
+
+/*!
+\brief DE-9IM model intersection mask (static version).
+\ingroup de9im
+\details This mask can be used to check spatial relations as defined in
+         Dimensionally Extended 9-Intersection Model.
+\tparam II Interior/Interior intersection mask element
+\tparam IB Interior/Boundary intersection mask element
+\tparam IE Interior/Exterior intersection mask element
+\tparam BI Boundary/Interior intersection mask element
+\tparam BB Boundary/Boundary intersection mask element
+\tparam BE Boundary/Exterior intersection mask element
+\tparam EI Exterior/Interior intersection mask element
+\tparam EB Exterior/Boundary intersection mask element
+\tparam EE Exterior/Exterior intersection mask element
+
+\qbk{[heading See also]}
+\qbk{* [link geometry.reference.algorithms.relate relate]}
+ */
+template
+<
+    char II = '*', char IB = '*', char IE = '*',
+    char BI = '*', char BB = '*', char BE = '*',
+    char EI = '*', char EB = '*', char EE = '*'
+>
+class static_mask
+    : public detail::relate::static_mask
+        <
+            boost::mpl::vector_c
+                <
+                    char, II, IB, IE, BI, BB, BE, EI, EB, EE
+                >,
+            3, 3
+        >
+{};
+
+} // namespace de9im
+
+namespace detail { namespace de9im
+{
+
+// a small helper util for ORing static masks
+
+template
+<
+    typename Seq,
+    typename T,
+    bool IsSeq = boost::mpl::is_sequence<Seq>::value
+>
+struct push_back
+{
+    typedef typename boost::mpl::push_back
+        <
+            Seq,
+            T
+        >::type type;
+};
+
+template <typename Seq, typename T>
+struct push_back<Seq, T, false>
+{};
+
+}} // namespace detail::de9im
+
+namespace de9im
+{
+
+inline
+boost::tuples::cons
+    <
+        mask,
+        boost::tuples::cons<mask, boost::tuples::null_type>
+    >
+operator||(mask const& m1, mask const& m2)
+{
+    namespace bt = boost::tuples;
+
+    return bt::cons<mask, bt::cons<mask, bt::null_type> >
+        ( m1, bt::cons<mask, bt::null_type>(m2, bt::null_type()) );
+}
+
+template <typename Tail>
+inline
+typename index::detail::tuples::push_back
+    <
+        boost::tuples::cons<mask, Tail>,
+        mask
+    >::type
+operator||(boost::tuples::cons<mask, Tail> const& t, mask const& m)
+{
+    namespace bt = boost::tuples;
+
+    return index::detail::tuples::push_back
+            <
+                bt::cons<mask, Tail>,
+                mask
+            >::apply(t, m);
+}
+
+template
+<
+    char II1, char IB1, char IE1,
+    char BI1, char BB1, char BE1,
+    char EI1, char EB1, char EE1,
+    char II2, char IB2, char IE2,
+    char BI2, char BB2, char BE2,
+    char EI2, char EB2, char EE2
+>
+inline
+boost::mpl::vector<
+    static_mask<II1, IB1, IE1, BI1, BB1, BE1, EI1, EB1, EE1>,
+    static_mask<II2, IB2, IE2, BI2, BB2, BE2, EI2, EB2, EE2>
+>
+operator||(static_mask<II1, IB1, IE1, BI1, BB1, BE1, EI1, EB1, EE1> const& ,
+           static_mask<II2, IB2, IE2, BI2, BB2, BE2, EI2, EB2, EE2> const& )
+{
+    return boost::mpl::vector
+            <
+                static_mask<II1, IB1, IE1, BI1, BB1, BE1, EI1, EB1, EE1>,
+                static_mask<II2, IB2, IE2, BI2, BB2, BE2, EI2, EB2, EE2>
+            >();
+}
+
+template
+<
+    typename Seq,
+    char II, char IB, char IE,
+    char BI, char BB, char BE,
+    char EI, char EB, char EE
+>
+inline
+typename detail::de9im::push_back
+    <
+        Seq,
+        static_mask<II, IB, IE, BI, BB, BE, EI, EB, EE>
+    >::type
+operator||(Seq const& ,
+           static_mask<II, IB, IE, BI, BB, BE, EI, EB, EE> const& )
+{
+    return typename detail::de9im::push_back
+            <
+                Seq,
+                static_mask<II, IB, IE, BI, BB, BE, EI, EB, EE>
+            >::type();
+}
+
+} // namespace de9im
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace de9im
+{
+
+// PREDEFINED MASKS
+
+// TODO:
+// 1. specialize for simplified masks if available
+// e.g. for TOUCHES use 1 mask for A/A
+// 2. Think about dimensions > 2 e.g. should TOUCHES be true
+// if the interior of the Areal overlaps the boundary of the Volumetric
+// like it's true for Linear/Areal
+
+// EQUALS
+template <typename Geometry1, typename Geometry2>
+struct static_mask_equals_type
+{
+    typedef geometry::de9im::static_mask<'T', '*', 'F', '*', '*', 'F', 'F', 'F', '*'> type; // wikipedia
+    //typedef geometry::de9im::static_mask<'T', 'F', 'F', 'F', 'T', 'F', 'F', 'F', 'T'> type; // OGC
+};
+
+// DISJOINT
+template <typename Geometry1, typename Geometry2>
+struct static_mask_disjoint_type
+{
+    typedef geometry::de9im::static_mask<'F', 'F', '*', 'F', 'F', '*', '*', '*', '*'> type;
+};
+
+// TOUCHES - NOT P/P
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    std::size_t Dim1 = geometry::topological_dimension<Geometry1>::value,
+    std::size_t Dim2 = geometry::topological_dimension<Geometry2>::value
+>
+struct static_mask_touches_impl
+{
+    typedef boost::mpl::vector
+        <
+            geometry::de9im::static_mask<'F', 'T', '*', '*', '*', '*', '*', '*', '*'>,
+            geometry::de9im::static_mask<'F', '*', '*', 'T', '*', '*', '*', '*', '*'>,
+            geometry::de9im::static_mask<'F', '*', '*', '*', 'T', '*', '*', '*', '*'>
+        > type;
+};
+// According to OGC, doesn't apply to P/P
+// Using the above mask the result would be always false
+template <typename Geometry1, typename Geometry2>
+struct static_mask_touches_impl<Geometry1, Geometry2, 0, 0>
+    : not_implemented<typename geometry::tag<Geometry1>::type,
+                      typename geometry::tag<Geometry2>::type>
+{};
+
+template <typename Geometry1, typename Geometry2>
+struct static_mask_touches_type
+    : static_mask_touches_impl<Geometry1, Geometry2>
+{};
+
+// WITHIN
+template <typename Geometry1, typename Geometry2>
+struct static_mask_within_type
+{
+    typedef geometry::de9im::static_mask<'T', '*', 'F', '*', '*', 'F', '*', '*', '*'> type;
+};
+
+// COVERED_BY (non OGC)
+template <typename Geometry1, typename Geometry2>
+struct static_mask_covered_by_type
+{
+    typedef boost::mpl::vector
+        <
+            geometry::de9im::static_mask<'T', '*', 'F', '*', '*', 'F', '*', '*', '*'>,
+            geometry::de9im::static_mask<'*', 'T', 'F', '*', '*', 'F', '*', '*', '*'>,
+            geometry::de9im::static_mask<'*', '*', 'F', 'T', '*', 'F', '*', '*', '*'>,
+            geometry::de9im::static_mask<'*', '*', 'F', '*', 'T', 'F', '*', '*', '*'>
+        > type;
+};
+
+// CROSSES
+// dim(G1) < dim(G2) - P/L P/A L/A
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    std::size_t Dim1 = geometry::topological_dimension<Geometry1>::value,
+    std::size_t Dim2 = geometry::topological_dimension<Geometry2>::value,
+    bool D1LessD2 = (Dim1 < Dim2)
+>
+struct static_mask_crosses_impl
+{
+    typedef geometry::de9im::static_mask<'T', '*', 'T', '*', '*', '*', '*', '*', '*'> type;
+};
+// TODO: I'm not sure if this one below should be available!
+// dim(G1) > dim(G2) - L/P A/P A/L
+template
+<
+    typename Geometry1, typename Geometry2, std::size_t Dim1, std::size_t Dim2
+>
+struct static_mask_crosses_impl<Geometry1, Geometry2, Dim1, Dim2, false>
+{
+    typedef geometry::de9im::static_mask<'T', '*', '*', '*', '*', '*', 'T', '*', '*'> type;
+};
+// dim(G1) == dim(G2) - P/P A/A
+template
+<
+    typename Geometry1, typename Geometry2, std::size_t Dim
+>
+struct static_mask_crosses_impl<Geometry1, Geometry2, Dim, Dim, false>
+    : not_implemented
+        <
+            typename geometry::tag<Geometry1>::type,
+            typename geometry::tag<Geometry2>::type
+        >
+{};
+// dim(G1) == 1 && dim(G2) == 1 - L/L
+template <typename Geometry1, typename Geometry2>
+struct static_mask_crosses_impl<Geometry1, Geometry2, 1, 1, false>
+{
+    typedef geometry::de9im::static_mask<'0', '*', '*', '*', '*', '*', '*', '*', '*'> type;
+};
+
+template <typename Geometry1, typename Geometry2>
+struct static_mask_crosses_type
+    : static_mask_crosses_impl<Geometry1, Geometry2>
+{};
+
+// OVERLAPS
+
+// dim(G1) != dim(G2) - NOT P/P, L/L, A/A
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    std::size_t Dim1 = geometry::topological_dimension<Geometry1>::value,
+    std::size_t Dim2 = geometry::topological_dimension<Geometry2>::value
+>
+struct static_mask_overlaps_impl
+    : not_implemented
+        <
+            typename geometry::tag<Geometry1>::type,
+            typename geometry::tag<Geometry2>::type
+        >
+{};
+// dim(G1) == D && dim(G2) == D - P/P A/A
+template <typename Geometry1, typename Geometry2, std::size_t Dim>
+struct static_mask_overlaps_impl<Geometry1, Geometry2, Dim, Dim>
+{
+    typedef geometry::de9im::static_mask<'T', '*', 'T', '*', '*', '*', 'T', '*', '*'> type;
+};
+// dim(G1) == 1 && dim(G2) == 1 - L/L
+template <typename Geometry1, typename Geometry2>
+struct static_mask_overlaps_impl<Geometry1, Geometry2, 1, 1>
+{
+    typedef geometry::de9im::static_mask<'1', '*', 'T', '*', '*', '*', 'T', '*', '*'> type;
+};
+
+template <typename Geometry1, typename Geometry2>
+struct static_mask_overlaps_type
+    : static_mask_overlaps_impl<Geometry1, Geometry2>
+{};
+
+}} // namespace detail::de9im
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_DE9IM_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/follow_helpers.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/follow_helpers.hpp
new file mode 100644
index 00000000000..20122471e5e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/follow_helpers.hpp
@@ -0,0 +1,404 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2013, 2014.
+// Modifications copyright (c) 2013-2014 Oracle and/or its affiliates.
+
+// 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)
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_FOLLOW_HELPERS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_FOLLOW_HELPERS_HPP
+
+#include <boost/geometry/core/assert.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/range.hpp>
+//#include <boost/geometry/algorithms/detail/sub_range.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace relate {
+
+// NOTE: This iterates through single geometries for which turns were not generated.
+//       It doesn't mean that the geometry is disjoint, only that no turns were detected.
+
+template <std::size_t OpId,
+          typename Geometry,
+          typename Tag = typename geometry::tag<Geometry>::type,
+          bool IsMulti = boost::is_base_of<multi_tag, Tag>::value
+>
+struct for_each_disjoint_geometry_if
+    : public not_implemented<Tag>
+{};
+
+template <std::size_t OpId, typename Geometry, typename Tag>
+struct for_each_disjoint_geometry_if<OpId, Geometry, Tag, false>
+{
+    template <typename TurnIt, typename Pred>
+    static inline bool apply(TurnIt first, TurnIt last,
+                             Geometry const& geometry,
+                             Pred & pred)
+    {
+        if ( first != last )
+            return false;
+        pred(geometry);
+        return true;
+    }
+};
+
+template <std::size_t OpId, typename Geometry, typename Tag>
+struct for_each_disjoint_geometry_if<OpId, Geometry, Tag, true>
+{
+    template <typename TurnIt, typename Pred>
+    static inline bool apply(TurnIt first, TurnIt last,
+                             Geometry const& geometry,
+                             Pred & pred)
+    {
+        if ( first != last )
+            return for_turns(first, last, geometry, pred);
+        else
+            return for_empty(geometry, pred);
+    }
+
+    template <typename Pred>
+    static inline bool for_empty(Geometry const& geometry,
+                                 Pred & pred)
+    {
+        typedef typename boost::range_iterator<Geometry const>::type iterator;
+
+        // O(N)
+        // check predicate for each contained geometry without generated turn
+        for ( iterator it = boost::begin(geometry) ;
+              it != boost::end(geometry) ; ++it )
+        {
+            bool cont = pred(*it);
+            if ( !cont )
+                break;
+        }
+        
+        return !boost::empty(geometry);
+    }
+
+    template <typename TurnIt, typename Pred>
+    static inline bool for_turns(TurnIt first, TurnIt last,
+                                 Geometry const& geometry,
+                                 Pred & pred)
+    {
+        BOOST_GEOMETRY_ASSERT(first != last);
+
+        const std::size_t count = boost::size(geometry);
+        boost::ignore_unused_variable_warning(count);
+
+        // O(I)
+        // gather info about turns generated for contained geometries
+        std::vector<bool> detected_intersections(count, false);
+        for ( TurnIt it = first ; it != last ; ++it )
+        {
+            signed_size_type multi_index = it->operations[OpId].seg_id.multi_index;
+            BOOST_GEOMETRY_ASSERT(multi_index >= 0);
+            std::size_t const index = static_cast<std::size_t>(multi_index);
+            BOOST_GEOMETRY_ASSERT(index < count);
+            detected_intersections[index] = true;
+        }
+
+        bool found = false;
+
+        // O(N)
+        // check predicate for each contained geometry without generated turn
+        for ( std::vector<bool>::iterator it = detected_intersections.begin() ;
+              it != detected_intersections.end() ; ++it )
+        {
+            // if there were no intersections for this multi_index
+            if ( *it == false )
+            {
+                found = true;
+                std::size_t const index = std::size_t(std::distance(detected_intersections.begin(), it));
+                bool cont = pred(range::at(geometry, index));
+                if ( !cont )
+                    break;
+            }
+        }
+        
+        return found;
+    }
+};
+
+// WARNING! This class stores pointers!
+// Passing a reference to local variable will result in undefined behavior!
+template <typename Point>
+class point_info
+{
+public:
+    point_info() : sid_ptr(NULL), pt_ptr(NULL) {}
+    point_info(Point const& pt, segment_identifier const& sid)
+        : sid_ptr(boost::addressof(sid))
+        , pt_ptr(boost::addressof(pt))
+    {}
+    segment_identifier const& seg_id() const
+    {
+        BOOST_GEOMETRY_ASSERT(sid_ptr);
+        return *sid_ptr;
+    }
+    Point const& point() const
+    {
+        BOOST_GEOMETRY_ASSERT(pt_ptr);
+        return *pt_ptr;
+    }
+
+    //friend bool operator==(point_identifier const& l, point_identifier const& r)
+    //{
+    //    return l.seg_id() == r.seg_id()
+    //        && detail::equals::equals_point_point(l.point(), r.point());
+    //}
+
+private:
+    const segment_identifier * sid_ptr;
+    const Point * pt_ptr;
+};
+
+// WARNING! This class stores pointers!
+// Passing a reference to local variable will result in undefined behavior!
+class same_single
+{
+public:
+    same_single(segment_identifier const& sid)
+        : sid_ptr(boost::addressof(sid))
+    {}
+
+    bool operator()(segment_identifier const& sid) const
+    {
+        return sid.multi_index == sid_ptr->multi_index;                
+    }
+
+    template <typename Point>
+    bool operator()(point_info<Point> const& pid) const
+    {
+        return operator()(pid.seg_id());
+    }
+
+private:
+    const segment_identifier * sid_ptr;
+};
+
+class same_ring
+{
+public:
+    same_ring(segment_identifier const& sid)
+        : sid_ptr(boost::addressof(sid))
+    {}
+
+    bool operator()(segment_identifier const& sid) const
+    {
+        return sid.multi_index == sid_ptr->multi_index
+            && sid.ring_index == sid_ptr->ring_index;
+    }
+
+private:
+    const segment_identifier * sid_ptr;
+};
+
+// WARNING! This class stores pointers!
+// Passing a reference to local variable will result in undefined behavior!
+template <typename SameRange = same_single>
+class segment_watcher
+{
+public:
+    segment_watcher()
+        : m_seg_id_ptr(NULL)
+    {}
+
+    bool update(segment_identifier const& seg_id)
+    {
+        bool result = m_seg_id_ptr == 0 || !SameRange(*m_seg_id_ptr)(seg_id);
+        m_seg_id_ptr = boost::addressof(seg_id);
+        return result;
+    }
+
+private:
+    const segment_identifier * m_seg_id_ptr;
+};
+
+// WARNING! This class stores pointers!
+// Passing a reference to local variable will result in undefined behavior!
+template <typename TurnInfo, std::size_t OpId>
+class exit_watcher
+{
+    static const std::size_t op_id = OpId;
+    static const std::size_t other_op_id = (OpId + 1) % 2;
+
+    typedef typename TurnInfo::point_type point_type;
+    typedef detail::relate::point_info<point_type> point_info;
+
+public:
+    exit_watcher()
+        : m_exit_operation(overlay::operation_none)
+        , m_exit_turn_ptr(NULL)
+    {}
+
+    void enter(TurnInfo const& turn)
+    {
+        m_other_entry_points.push_back(
+            point_info(turn.point, turn.operations[other_op_id].seg_id) );
+    }
+
+    // TODO: exit_per_geometry parameter looks not very safe
+    //       wrong value may be easily passed
+
+    void exit(TurnInfo const& turn, bool exit_per_geometry = true)
+    {
+        //segment_identifier const& seg_id = turn.operations[op_id].seg_id;
+        segment_identifier const& other_id = turn.operations[other_op_id].seg_id;
+        overlay::operation_type exit_op = turn.operations[op_id].operation;
+
+        typedef typename std::vector<point_info>::iterator point_iterator;
+        // search for the entry point in the same range of other geometry
+        point_iterator entry_it = std::find_if(m_other_entry_points.begin(),
+                                               m_other_entry_points.end(),
+                                               same_single(other_id));
+
+        // this end point has corresponding entry point
+        if ( entry_it != m_other_entry_points.end() )
+        {
+            // erase the corresponding entry point
+            m_other_entry_points.erase(entry_it);
+
+            if ( exit_per_geometry || m_other_entry_points.empty() )
+            {
+                // here we know that we possibly left LS
+                // we must still check if we didn't get back on the same point
+                m_exit_operation = exit_op;
+                m_exit_turn_ptr = boost::addressof(turn);
+            }
+        }
+    }
+
+    bool is_outside() const
+    {
+        // if we didn't entered anything in the past, we're outside
+        return m_other_entry_points.empty();
+    }
+
+    bool is_outside(TurnInfo const& turn) const
+    {
+        return m_other_entry_points.empty()
+            || std::find_if(m_other_entry_points.begin(),
+                            m_other_entry_points.end(),
+                            same_single(
+                                turn.operations[other_op_id].seg_id))
+                    == m_other_entry_points.end();
+    }
+
+    overlay::operation_type get_exit_operation() const
+    {
+        return m_exit_operation;
+    }
+
+    point_type const& get_exit_point() const
+    {
+        BOOST_GEOMETRY_ASSERT(m_exit_operation != overlay::operation_none);
+        BOOST_GEOMETRY_ASSERT(m_exit_turn_ptr);
+        return m_exit_turn_ptr->point;
+    }
+
+    TurnInfo const& get_exit_turn() const
+    {
+        BOOST_GEOMETRY_ASSERT(m_exit_operation != overlay::operation_none);
+        BOOST_GEOMETRY_ASSERT(m_exit_turn_ptr);
+        return *m_exit_turn_ptr;
+    }
+
+    void reset_detected_exit()
+    {
+        m_exit_operation = overlay::operation_none;
+    }
+
+    void reset()
+    {
+        m_exit_operation = overlay::operation_none;
+        m_other_entry_points.clear();
+    }
+
+private:
+    overlay::operation_type m_exit_operation;
+    const TurnInfo * m_exit_turn_ptr;
+    std::vector<point_info> m_other_entry_points; // TODO: use map here or sorted vector?
+};
+
+template <std::size_t OpId, typename Turn>
+inline bool turn_on_the_same_ip(Turn const& prev_turn, Turn const& curr_turn)
+{
+    segment_identifier const& prev_seg_id = prev_turn.operations[OpId].seg_id;
+    segment_identifier const& curr_seg_id = curr_turn.operations[OpId].seg_id;
+
+    if ( prev_seg_id.multi_index != curr_seg_id.multi_index
+      || prev_seg_id.ring_index != curr_seg_id.ring_index )
+    {
+        return false;
+    }
+
+    // TODO: will this work if between segments there will be some number of degenerated ones?
+
+    if ( prev_seg_id.segment_index != curr_seg_id.segment_index
+      && ( ! curr_turn.operations[OpId].fraction.is_zero()
+        || prev_seg_id.segment_index + 1 != curr_seg_id.segment_index ) )
+    {
+        return false;
+    }
+
+    return detail::equals::equals_point_point(prev_turn.point, curr_turn.point);
+}
+
+template <boundary_query BoundaryQuery,
+          typename Point,
+          typename BoundaryChecker>
+static inline bool is_endpoint_on_boundary(Point const& pt,
+                                           BoundaryChecker & boundary_checker)
+{
+    return boundary_checker.template is_endpoint_boundary<BoundaryQuery>(pt);
+}
+
+template <boundary_query BoundaryQuery,
+          typename IntersectionPoint,
+          typename OperationInfo,
+          typename BoundaryChecker>
+static inline bool is_ip_on_boundary(IntersectionPoint const& ip,
+                                     OperationInfo const& operation_info,
+                                     BoundaryChecker & boundary_checker,
+                                     segment_identifier const& seg_id)
+{
+    boost::ignore_unused_variable_warning(seg_id);
+
+    bool res = false;
+
+    // IP on the last point of the linestring
+    if ( BOOST_GEOMETRY_CONDITION(BoundaryQuery == boundary_back || BoundaryQuery == boundary_any)
+      && operation_info.position == overlay::position_back )
+    {
+        // check if this point is a boundary
+        res = boundary_checker.template is_endpoint_boundary<boundary_back>(ip);
+    }
+    // IP on the last point of the linestring
+    else if ( BOOST_GEOMETRY_CONDITION(BoundaryQuery == boundary_front || BoundaryQuery == boundary_any)
+           && operation_info.position == overlay::position_front )
+    {
+        // check if this point is a boundary
+        res = boundary_checker.template is_endpoint_boundary<boundary_front>(ip);
+    }
+            
+    return res;
+}
+
+
+}} // namespace detail::relate
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_FOLLOW_HELPERS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/implementation.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/implementation.hpp
new file mode 100644
index 00000000000..8f7942d46ea
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/implementation.hpp
@@ -0,0 +1,124 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2013, 2014, 2015, 2017.
+// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_IMPLEMENTATION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_IMPLEMENTATION_HPP
+
+
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/detail/relate/interface.hpp>
+
+#include <boost/geometry/algorithms/detail/relate/point_point.hpp>
+#include <boost/geometry/algorithms/detail/relate/point_geometry.hpp>
+#include <boost/geometry/algorithms/detail/relate/linear_linear.hpp>
+#include <boost/geometry/algorithms/detail/relate/linear_areal.hpp>
+#include <boost/geometry/algorithms/detail/relate/multi_point_geometry.hpp>
+#include <boost/geometry/algorithms/detail/relate/areal_areal.hpp>
+
+#include <boost/geometry/strategies/intersection.hpp>
+#include <boost/geometry/strategies/within.hpp>
+
+
+namespace boost { namespace geometry {
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch {
+
+template <typename Point1, typename Point2>
+struct relate<Point1, Point2, point_tag, point_tag, 0, 0, false>
+    : detail::relate::point_point<Point1, Point2>
+{};
+
+template <typename Point, typename MultiPoint>
+struct relate<Point, MultiPoint, point_tag, multi_point_tag, 0, 0, false>
+    : detail::relate::point_multipoint<Point, MultiPoint>
+{};
+
+template <typename MultiPoint, typename Point>
+struct relate<MultiPoint, Point, multi_point_tag, point_tag, 0, 0, false>
+    : detail::relate::multipoint_point<MultiPoint, Point>
+{};
+
+template <typename MultiPoint1, typename MultiPoint2>
+struct relate<MultiPoint1, MultiPoint2, multi_point_tag, multi_point_tag, 0, 0, false>
+    : detail::relate::multipoint_multipoint<MultiPoint1, MultiPoint2>
+{};
+
+// TODO - for now commented out because before implementing it we must consider:
+// 1. how the Box degenerated to a Point should be treated
+// 2. what should be the definition of a Box degenerated to a Point
+// 3. what fields should the matrix/mask contain for dimension > 2 and dimension > 9
+//
+//template <typename Point, typename Box, int TopDim2>
+//struct relate<Point, Box, point_tag, box_tag, 0, TopDim2, false>
+//    : detail::relate::point_box<Point, Box>
+//{};
+//
+//template <typename Box, typename Point, int TopDim1>
+//struct relate<Box, Point, box_tag, point_tag, TopDim1, 0, false>
+//    : detail::relate::box_point<Box, Point>
+//{};
+
+
+template <typename Point, typename Geometry, typename Tag2, int TopDim2>
+struct relate<Point, Geometry, point_tag, Tag2, 0, TopDim2, true>
+    : detail::relate::point_geometry<Point, Geometry>
+{};
+
+template <typename Geometry, typename Point, typename Tag1, int TopDim1>
+struct relate<Geometry, Point, Tag1, point_tag, TopDim1, 0, true>
+    : detail::relate::geometry_point<Geometry, Point>
+{};
+
+template <typename MultiPoint, typename Geometry, typename Tag2, int TopDim2>
+struct relate<MultiPoint, Geometry, multi_point_tag, Tag2, 0, TopDim2, false>
+    : detail::relate::multi_point_geometry<MultiPoint, Geometry>
+{};
+
+template <typename Geometry, typename MultiPoint, typename Tag1, int TopDim1>
+struct relate<Geometry, MultiPoint, Tag1, multi_point_tag, TopDim1, 0, false>
+    : detail::relate::geometry_multi_point<Geometry, MultiPoint>
+{};
+
+
+template <typename Linear1, typename Linear2, typename Tag1, typename Tag2>
+struct relate<Linear1, Linear2, Tag1, Tag2, 1, 1, true>
+    : detail::relate::linear_linear<Linear1, Linear2>
+{};
+
+
+template <typename Linear, typename Areal, typename Tag1, typename Tag2>
+struct relate<Linear, Areal, Tag1, Tag2, 1, 2, true>
+    : detail::relate::linear_areal<Linear, Areal>
+{};
+
+template <typename Areal, typename Linear, typename Tag1, typename Tag2>
+struct relate<Areal, Linear, Tag1, Tag2, 2, 1, true>
+    : detail::relate::areal_linear<Areal, Linear>
+{};
+
+
+template <typename Areal1, typename Areal2, typename Tag1, typename Tag2>
+struct relate<Areal1, Areal2, Tag1, Tag2, 2, 2, true>
+    : detail::relate::areal_areal<Areal1, Areal2>
+{};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_IMPLEMENTATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/interface.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/interface.hpp
new file mode 100644
index 00000000000..3575fe2bc47
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/interface.hpp
@@ -0,0 +1,421 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2013, 2014, 2015, 2017.
+// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_INTERFACE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_INTERFACE_HPP
+
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/core/topological_dimension.hpp>
+
+#include <boost/geometry/algorithms/detail/relate/de9im.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/strategies/relate.hpp>
+
+
+namespace boost { namespace geometry {
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace relate {
+
+// Those are used only to allow dispatch::relate to produce compile-time error
+
+template <typename Geometry,
+          typename Tag = typename geometry::tag<Geometry>::type>
+struct is_supported_by_generic
+{
+    static const bool value
+        = boost::is_same<Tag, linestring_tag>::value
+       || boost::is_same<Tag, multi_linestring_tag>::value
+       || boost::is_same<Tag, ring_tag>::value
+       || boost::is_same<Tag, polygon_tag>::value
+       || boost::is_same<Tag, multi_polygon_tag>::value;
+};
+
+template <typename Geometry1,
+          typename Geometry2,
+          typename Tag1 = typename geometry::tag<Geometry1>::type,
+          typename Tag2 = typename geometry::tag<Geometry2>::type>
+struct is_generic
+{
+    static const bool value = is_supported_by_generic<Geometry1>::value
+                           && is_supported_by_generic<Geometry2>::value;
+};
+
+
+template <typename Point, typename Geometry, typename Tag>
+struct is_generic<Point, Geometry, point_tag, Tag>
+{
+    static const bool value = is_supported_by_generic<Geometry>::value;
+};
+
+template <typename Geometry, typename Point, typename Tag>
+struct is_generic<Geometry, Point, Tag, point_tag>
+{
+    static const bool value = is_supported_by_generic<Geometry>::value;
+};
+
+template <typename Point1, typename Point2>
+struct is_generic<Point1, Point2, point_tag, point_tag>
+{
+    static const bool value = false;
+};
+
+
+}} // namespace detail::relate
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch {
+
+
+template <typename Geometry1,
+          typename Geometry2,
+          typename Tag1 = typename geometry::tag<Geometry1>::type,
+          typename Tag2 = typename geometry::tag<Geometry2>::type,
+          int TopDim1 = geometry::topological_dimension<Geometry1>::value,
+          int TopDim2 = geometry::topological_dimension<Geometry2>::value,
+          bool IsGeneric = detail::relate::is_generic<Geometry1, Geometry2>::value
+>
+struct relate : not_implemented<Tag1, Tag2>
+{};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace relate {
+
+template <typename Geometry1, typename Geometry2>
+struct interruption_enabled
+{
+    static const bool value =
+        dispatch::relate<Geometry1, Geometry2>::interruption_enabled;
+};
+
+template <typename Geometry1,
+          typename Geometry2,
+          typename Result,
+          bool IsSequence = boost::mpl::is_sequence<Result>::value>
+struct result_handler_type
+    : not_implemented<Result>
+{};
+
+template <typename Geometry1, typename Geometry2>
+struct result_handler_type<Geometry1, Geometry2, geometry::de9im::mask, false>
+{
+    typedef mask_handler
+        <
+            geometry::de9im::mask,
+            interruption_enabled
+                <
+                    Geometry1,
+                    Geometry2
+                >::value
+        > type;
+};
+
+template <typename Geometry1, typename Geometry2, typename Head, typename Tail>
+struct result_handler_type<Geometry1, Geometry2, boost::tuples::cons<Head, Tail>, false>
+{
+    typedef mask_handler
+        <
+            boost::tuples::cons<Head, Tail>,
+            interruption_enabled
+                <
+                    Geometry1,
+                    Geometry2
+                >::value
+        > type;
+};
+
+template <typename Geometry1, typename Geometry2,
+          char II, char IB, char IE,
+          char BI, char BB, char BE,
+          char EI, char EB, char EE>
+struct result_handler_type
+    <
+        Geometry1,
+        Geometry2,
+        geometry::de9im::static_mask<II, IB, IE, BI, BB, BE, EI, EB, EE>,
+        false
+    >
+{
+    typedef static_mask_handler
+        <
+            geometry::de9im::static_mask<II, IB, IE, BI, BB, BE, EI, EB, EE>,
+            interruption_enabled
+                <
+                    Geometry1,
+                    Geometry2
+                >::value
+        > type;
+};
+
+template <typename Geometry1, typename Geometry2, typename StaticSequence>
+struct result_handler_type<Geometry1, Geometry2, StaticSequence, true>
+{
+    typedef static_mask_handler
+        <
+            StaticSequence,
+            interruption_enabled
+                <
+                    Geometry1,
+                    Geometry2
+                >::value
+        > type;
+};
+
+
+}} // namespace detail::relate
+#endif // DOXYGEN_NO_DETAIL
+
+namespace resolve_strategy {
+
+struct relate
+{
+    template <typename Geometry1, typename Geometry2, typename ResultHandler, typename Strategy>
+    static inline void apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             ResultHandler & handler,
+                             Strategy const& strategy)
+    {
+        dispatch::relate
+            <
+                Geometry1,
+                Geometry2
+            >::apply(geometry1, geometry2, handler, strategy);
+    }
+
+    template <typename Geometry1, typename Geometry2, typename ResultHandler>
+    static inline void apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             ResultHandler & handler,
+                             default_strategy)
+    {
+        typedef typename strategy::relate::services::default_strategy
+            <
+                Geometry1,
+                Geometry2
+            >::type strategy_type;
+        
+        dispatch::relate
+            <
+                Geometry1,
+                Geometry2
+            >::apply(geometry1, geometry2, handler, strategy_type());
+    }
+};
+
+} // resolve_strategy
+
+namespace resolve_variant {
+
+template <typename Geometry1, typename Geometry2>
+struct relate
+{
+    template <typename Mask, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Mask const& mask,
+                             Strategy const& strategy)
+    {
+        concepts::check<Geometry1 const>();
+        concepts::check<Geometry2 const>();
+        assert_dimension_equal<Geometry1, Geometry2>();
+
+        typename detail::relate::result_handler_type
+            <
+                Geometry1,
+                Geometry2,
+                Mask
+            >::type handler(mask);
+
+        resolve_strategy::relate::apply(geometry1, geometry2, handler, strategy);
+
+        return handler.result();
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
+struct relate<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
+{
+    template <typename Mask, typename Strategy>
+    struct visitor : boost::static_visitor<bool>
+    {
+        Geometry2 const& m_geometry2;
+        Mask const& m_mask;
+        Strategy const& m_strategy;
+
+        visitor(Geometry2 const& geometry2, Mask const& mask, Strategy const& strategy)
+            : m_geometry2(geometry2), m_mask(mask), m_strategy(strategy) {}
+
+        template <typename Geometry1>
+        bool operator()(Geometry1 const& geometry1) const
+        {
+            return relate<Geometry1, Geometry2>
+                   ::apply(geometry1, m_geometry2, m_mask, m_strategy);
+        }
+    };
+
+    template <typename Mask, typename Strategy>
+    static inline bool
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
+          Geometry2 const& geometry2,
+          Mask const& mask,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Mask, Strategy>(geometry2, mask, strategy), geometry1);
+    }
+};
+
+template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct relate<Geometry1, boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Mask, typename Strategy>
+    struct visitor : boost::static_visitor<bool>
+    {
+        Geometry1 const& m_geometry1;
+        Mask const& m_mask;
+        Strategy const& m_strategy;
+
+        visitor(Geometry1 const& geometry1, Mask const& mask, Strategy const& strategy)
+            : m_geometry1(geometry1), m_mask(mask), m_strategy(strategy) {}
+
+        template <typename Geometry2>
+        bool operator()(Geometry2 const& geometry2) const
+        {
+            return relate<Geometry1, Geometry2>
+                   ::apply(m_geometry1, geometry2, m_mask, m_strategy);
+        }
+    };
+
+    template <typename Mask, typename Strategy>
+    static inline bool
+    apply(Geometry1 const& geometry1,
+          boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2,
+          Mask const& mask,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Mask, Strategy>(geometry1, mask, strategy), geometry2);
+    }
+};
+
+template <
+    BOOST_VARIANT_ENUM_PARAMS(typename T1),
+    BOOST_VARIANT_ENUM_PARAMS(typename T2)
+>
+struct relate<
+    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)>,
+    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)>
+>
+{
+    template <typename Mask, typename Strategy>
+    struct visitor : boost::static_visitor<bool>
+    {
+        Mask const& m_mask;
+        Strategy const& m_strategy;
+
+        visitor(Mask const& mask, Strategy const& strategy)
+            : m_mask(mask), m_strategy(strategy) {}
+
+        template <typename Geometry1, typename Geometry2>
+        bool operator()(Geometry1 const& geometry1,
+                        Geometry2 const& geometry2) const
+        {
+            return relate<Geometry1, Geometry2>
+                   ::apply(geometry1, geometry2, m_mask, m_strategy);
+        }
+    };
+
+    template <typename Mask, typename Strategy>
+    static inline bool
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)> const& geometry1,
+          boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2,
+          Mask const& mask,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Mask, Strategy>(mask, strategy), geometry1, geometry2);
+    }
+};
+
+} // namespace resolve_variant
+
+/*!
+\brief Checks relation between a pair of geometries defined by a mask.
+\ingroup relate
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Mask An intersection model Mask type.
+\tparam Strategy \tparam_strategy{Relate}
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param mask An intersection model mask object.
+\param strategy \param_strategy{relate}
+\return true if the relation is compatible with the mask, false otherwise.
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/relate.qbk]}
+ */
+template <typename Geometry1, typename Geometry2, typename Mask, typename Strategy>
+inline bool relate(Geometry1 const& geometry1,
+                   Geometry2 const& geometry2,
+                   Mask const& mask,
+                   Strategy const& strategy)
+{
+    return resolve_variant::relate
+            <
+                Geometry1,
+                Geometry2
+            >::apply(geometry1, geometry2, mask, strategy);
+}
+
+/*!
+\brief Checks relation between a pair of geometries defined by a mask.
+\ingroup relate
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Mask An intersection model Mask type.
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param mask An intersection model mask object.
+\return true if the relation is compatible with the mask, false otherwise.
+
+\qbk{[include reference/algorithms/relate.qbk]}
+ */
+template <typename Geometry1, typename Geometry2, typename Mask>
+inline bool relate(Geometry1 const& geometry1,
+                   Geometry2 const& geometry2,
+                   Mask const& mask)
+{
+    return resolve_variant::relate
+            <
+                Geometry1,
+                Geometry2
+            >::apply(geometry1, geometry2, mask, default_strategy());
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_INTERFACE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/less.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/less.hpp
new file mode 100644
index 00000000000..462fcc35f13
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/less.hpp
@@ -0,0 +1,83 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// 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)
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_LESS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_LESS_HPP
+
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/util/math.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace detail_dispatch { namespace relate {
+
+// TODO: Integrate it with geometry::less?
+
+template <typename Point1,
+          typename Point2,
+          std::size_t I = 0,
+          std::size_t D = geometry::dimension<Point1>::value>
+struct less
+{
+    static inline bool apply(Point1 const& left, Point2 const& right)
+    {
+        typename geometry::coordinate_type<Point1>::type
+            cleft = geometry::get<I>(left);
+        typename geometry::coordinate_type<Point2>::type
+            cright = geometry::get<I>(right);
+
+        if ( geometry::math::equals(cleft, cright) )
+        {
+            return less<Point1, Point2, I + 1, D>::apply(left, right);
+        }
+        else
+        {
+            return cleft < cright;
+        }
+    }
+};
+
+template <typename Point1, typename Point2, std::size_t D>
+struct less<Point1, Point2, D, D>
+{
+    static inline bool apply(Point1 const&, Point2 const&)
+    {
+        return false;
+    }
+};
+
+}} // namespace detail_dispatch::relate
+
+#endif
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace relate {
+
+struct less
+{
+    template <typename Point1, typename Point2>
+    inline bool operator()(Point1 const& point1, Point2 const& point2) const
+    {
+        return detail_dispatch::relate::less<Point1, Point2>::apply(point1, point2);
+    }
+};
+
+}} // namespace detail::relate
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_LESS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/linear_areal.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/linear_areal.hpp
new file mode 100644
index 00000000000..f1b4fdf81a0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/linear_areal.hpp
@@ -0,0 +1,1466 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2013, 2014, 2015, 2017.
+// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_LINEAR_AREAL_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_LINEAR_AREAL_HPP
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/range/size.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/topological_dimension.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/algorithms/num_interior_rings.hpp>
+#include <boost/geometry/algorithms/detail/point_on_border.hpp>
+#include <boost/geometry/algorithms/detail/sub_range.hpp>
+#include <boost/geometry/algorithms/detail/single_geometry.hpp>
+
+#include <boost/geometry/algorithms/detail/relate/point_geometry.hpp>
+#include <boost/geometry/algorithms/detail/relate/turns.hpp>
+#include <boost/geometry/algorithms/detail/relate/boundary_checker.hpp>
+#include <boost/geometry/algorithms/detail/relate/follow_helpers.hpp>
+
+#include <boost/geometry/views/detail/normalized_view.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace relate {
+
+// WARNING!
+// TODO: In the worst case calling this Pred in a loop for MultiLinestring/MultiPolygon may take O(NM)
+// Use the rtree in this case!
+
+// may be used to set IE and BE for a Linear geometry for which no turns were generated
+template
+<
+    typename Geometry2,
+    typename Result,
+    typename PointInArealStrategy,
+    typename BoundaryChecker,
+    bool TransposeResult
+>
+class no_turns_la_linestring_pred
+{
+public:
+    no_turns_la_linestring_pred(Geometry2 const& geometry2,
+                                Result & res,
+                                PointInArealStrategy const& point_in_areal_strategy,
+                                BoundaryChecker const& boundary_checker)
+        : m_geometry2(geometry2)
+        , m_result(res)
+        , m_point_in_areal_strategy(point_in_areal_strategy)
+        , m_boundary_checker(boundary_checker)
+        , m_interrupt_flags(0)
+    {
+        if ( ! may_update<interior, interior, '1', TransposeResult>(m_result) )
+        {
+            m_interrupt_flags |= 1;
+        }
+
+        if ( ! may_update<interior, exterior, '1', TransposeResult>(m_result) )
+        {
+            m_interrupt_flags |= 2;
+        }
+
+        if ( ! may_update<boundary, interior, '0', TransposeResult>(m_result) )
+        {
+            m_interrupt_flags |= 4;
+        }
+
+        if ( ! may_update<boundary, exterior, '0', TransposeResult>(m_result) )
+        {
+            m_interrupt_flags |= 8;
+        }
+    }
+
+    template <typename Linestring>
+    bool operator()(Linestring const& linestring)
+    {
+        std::size_t const count = boost::size(linestring);
+        
+        // invalid input
+        if ( count < 2 )
+        {
+            // ignore
+            // TODO: throw an exception?
+            return true;
+        }
+
+        // if those flags are set nothing will change
+        if ( m_interrupt_flags == 0xF )
+        {
+            return false;
+        }
+
+        int const pig = detail::within::point_in_geometry(range::front(linestring),
+                                                          m_geometry2,
+                                                          m_point_in_areal_strategy);
+        //BOOST_GEOMETRY_ASSERT_MSG(pig != 0, "There should be no IPs");
+
+        if ( pig > 0 )
+        {
+            update<interior, interior, '1', TransposeResult>(m_result);
+            m_interrupt_flags |= 1;
+        }
+        else
+        {
+            update<interior, exterior, '1', TransposeResult>(m_result);
+            m_interrupt_flags |= 2;
+        }
+
+        // check if there is a boundary
+        if ( ( m_interrupt_flags & 0xC ) != 0xC // if wasn't already set
+          && ( m_boundary_checker.template
+                is_endpoint_boundary<boundary_front>(range::front(linestring))
+            || m_boundary_checker.template
+                is_endpoint_boundary<boundary_back>(range::back(linestring)) ) )
+        {
+            if ( pig > 0 )
+            {
+                update<boundary, interior, '0', TransposeResult>(m_result);
+                m_interrupt_flags |= 4;
+            }
+            else
+            {
+                update<boundary, exterior, '0', TransposeResult>(m_result);
+                m_interrupt_flags |= 8;
+            }
+        }
+
+        return m_interrupt_flags != 0xF
+            && ! m_result.interrupt;
+    }
+
+private:
+    Geometry2 const& m_geometry2;
+    Result & m_result;
+    PointInArealStrategy const& m_point_in_areal_strategy;
+    BoundaryChecker const& m_boundary_checker;
+    unsigned m_interrupt_flags;
+};
+
+// may be used to set EI and EB for an Areal geometry for which no turns were generated
+template <typename Result, bool TransposeResult>
+class no_turns_la_areal_pred
+{
+public:
+    no_turns_la_areal_pred(Result & res)
+        : m_result(res)
+        , interrupt(! may_update<interior, exterior, '2', TransposeResult>(m_result)
+                 && ! may_update<boundary, exterior, '1', TransposeResult>(m_result) )
+    {}
+
+    template <typename Areal>
+    bool operator()(Areal const& areal)
+    {
+        if ( interrupt )
+        {
+            return false;
+        }
+
+        // TODO:
+        // handle empty/invalid geometries in a different way than below?
+
+        typedef typename geometry::point_type<Areal>::type point_type;
+        point_type dummy;
+        bool const ok = boost::geometry::point_on_border(dummy, areal);
+
+        // TODO: for now ignore, later throw an exception?
+        if ( !ok )
+        {
+            return true;
+        }
+
+        update<interior, exterior, '2', TransposeResult>(m_result);
+        update<boundary, exterior, '1', TransposeResult>(m_result);
+                    
+        return false;
+    }
+
+private:
+    Result & m_result;
+    bool const interrupt;
+};
+
+// The implementation of an algorithm calculating relate() for L/A
+template <typename Geometry1, typename Geometry2, bool TransposeResult = false>
+struct linear_areal
+{
+    // check Linear / Areal
+    BOOST_STATIC_ASSERT(topological_dimension<Geometry1>::value == 1
+                     && topological_dimension<Geometry2>::value == 2);
+
+    static const bool interruption_enabled = true;
+
+    typedef typename geometry::point_type<Geometry1>::type point1_type;
+    typedef typename geometry::point_type<Geometry2>::type point2_type;
+
+    template <typename Geometry>
+        struct is_multi
+            : boost::is_base_of
+                <
+                    multi_tag,
+                    typename tag<Geometry>::type
+                >
+        {};
+
+    template <typename Geom1, typename Geom2>
+    struct multi_turn_info
+        : turns::get_turns<Geom1, Geom2>::turn_info
+    {
+        multi_turn_info() : priority(0) {}
+        int priority; // single-geometry sorting priority
+    };
+
+    template <typename Geom1, typename Geom2>
+    struct turn_info_type
+        : boost::mpl::if_c
+            <
+                is_multi<Geometry2>::value,
+                multi_turn_info<Geom1, Geom2>,
+                typename turns::get_turns<Geom1, Geom2>::turn_info
+            >
+    {};
+    
+    template <typename Result, typename IntersectionStrategy>
+    static inline void apply(Geometry1 const& geometry1, Geometry2 const& geometry2,
+                             Result & result,
+                             IntersectionStrategy const& intersection_strategy)
+    {
+// TODO: If Areal geometry may have infinite size, change the following line:
+
+        // The result should be FFFFFFFFF
+        relate::set<exterior, exterior, result_dimension<Geometry2>::value, TransposeResult>(result);// FFFFFFFFd, d in [1,9] or T
+
+        if ( BOOST_GEOMETRY_CONDITION( result.interrupt ) )
+            return;
+
+        // get and analyse turns
+        typedef typename turn_info_type<Geometry1, Geometry2>::type turn_type;
+        std::vector<turn_type> turns;
+
+        interrupt_policy_linear_areal<Geometry2, Result> interrupt_policy(geometry2, result);
+
+        turns::get_turns<Geometry1, Geometry2>::apply(turns, geometry1, geometry2, interrupt_policy, intersection_strategy);
+        if ( BOOST_GEOMETRY_CONDITION( result.interrupt ) )
+            return;
+
+        boundary_checker<Geometry1> boundary_checker1(geometry1);
+        no_turns_la_linestring_pred
+            <
+                Geometry2,
+                Result,
+                typename IntersectionStrategy::template point_in_geometry_strategy<Geometry1, Geometry2>::type,
+                boundary_checker<Geometry1>,
+                TransposeResult
+            > pred1(geometry2,
+                    result,
+                    intersection_strategy.template get_point_in_geometry_strategy<Geometry1, Geometry2>(),
+                    boundary_checker1);
+        for_each_disjoint_geometry_if<0, Geometry1>::apply(turns.begin(), turns.end(), geometry1, pred1);
+        if ( BOOST_GEOMETRY_CONDITION( result.interrupt ) )
+            return;
+
+        no_turns_la_areal_pred<Result, !TransposeResult> pred2(result);
+        for_each_disjoint_geometry_if<1, Geometry2>::apply(turns.begin(), turns.end(), geometry2, pred2);
+        if ( BOOST_GEOMETRY_CONDITION( result.interrupt ) )
+            return;
+        
+        if ( turns.empty() )
+            return;
+
+        // This is set here because in the case if empty Areal geometry were passed
+        // those shouldn't be set
+        relate::set<exterior, interior, '2', TransposeResult>(result);// FFFFFF2Fd
+        if ( BOOST_GEOMETRY_CONDITION( result.interrupt ) )
+            return;
+
+        {
+            sort_dispatch(turns.begin(), turns.end(), is_multi<Geometry2>());
+
+            turns_analyser<turn_type> analyser;
+            analyse_each_turn(result, analyser,
+                              turns.begin(), turns.end(),
+                              geometry1, geometry2,
+                              boundary_checker1,
+                              intersection_strategy.get_side_strategy());
+
+            if ( BOOST_GEOMETRY_CONDITION( result.interrupt ) )
+                return;
+        }
+
+        // If 'c' (insersection_boundary) was not found we know that any Ls isn't equal to one of the Rings
+        if ( !interrupt_policy.is_boundary_found )
+        {
+            relate::set<exterior, boundary, '1', TransposeResult>(result);
+        }
+        // Don't calculate it if it's required
+        else if ( may_update<exterior, boundary, '1', TransposeResult>(result) )
+        {
+// TODO: REVISE THIS CODE AND PROBABLY REWRITE SOME PARTS TO BE MORE HUMAN-READABLE
+//       IN GENERAL IT ANALYSES THE RINGS OF AREAL GEOMETRY AND DETECTS THE ONES THAT
+//       MAY OVERLAP THE INTERIOR OF LINEAR GEOMETRY (NO IPs OR NON-FAKE 'u' OPERATION)
+// NOTE: For one case std::sort may be called again to sort data by operations for data already sorted by ring index
+//       In the worst case scenario the complexity will be O( NlogN + R*(N/R)log(N/R) )
+//       So always should remain O(NlogN) -> for R==1 <-> 1(N/1)log(N/1), for R==N <-> N(N/N)log(N/N)
+//       Some benchmarking should probably be done to check if only one std::sort should be used
+
+            // sort by multi_index and rind_index
+            std::sort(turns.begin(), turns.end(), less_ring());
+
+            typedef typename std::vector<turn_type>::iterator turn_iterator;
+
+            turn_iterator it = turns.begin();
+            segment_identifier * prev_seg_id_ptr = NULL;
+            // for each ring
+            for ( ; it != turns.end() ; )
+            {
+                // it's the next single geometry
+                if ( prev_seg_id_ptr == NULL
+                  || prev_seg_id_ptr->multi_index != it->operations[1].seg_id.multi_index )
+                {
+                    // if the first ring has no IPs
+                    if ( it->operations[1].seg_id.ring_index > -1 )
+                    {
+                        // we can be sure that the exterior overlaps the boundary
+                        relate::set<exterior, boundary, '1', TransposeResult>(result);                    
+                        break;
+                    }
+                    // if there was some previous ring
+                    if ( prev_seg_id_ptr != NULL )
+                    {
+                        signed_size_type const next_ring_index = prev_seg_id_ptr->ring_index + 1;
+                        BOOST_GEOMETRY_ASSERT(next_ring_index >= 0);
+                        
+                        // if one of the last rings of previous single geometry was ommited
+                        if ( static_cast<std::size_t>(next_ring_index)
+                                < geometry::num_interior_rings(
+                                    single_geometry(geometry2, *prev_seg_id_ptr)) )
+                        {
+                            // we can be sure that the exterior overlaps the boundary
+                            relate::set<exterior, boundary, '1', TransposeResult>(result);
+                            break;
+                        }
+                    }
+                }
+                // if it's the same single geometry
+                else /*if ( previous_multi_index == it->operations[1].seg_id.multi_index )*/
+                {
+                    // and we jumped over one of the rings
+                    if ( prev_seg_id_ptr != NULL // just in case
+                      && prev_seg_id_ptr->ring_index + 1 < it->operations[1].seg_id.ring_index )
+                    {
+                        // we can be sure that the exterior overlaps the boundary
+                        relate::set<exterior, boundary, '1', TransposeResult>(result);                    
+                        break;
+                    }
+                }
+
+                prev_seg_id_ptr = boost::addressof(it->operations[1].seg_id);
+
+                // find the next ring first iterator and check if the analysis should be performed
+                has_boundary_intersection has_boundary_inters;
+                turn_iterator next = find_next_ring(it, turns.end(), has_boundary_inters);
+
+                // if there is no 1d overlap with the boundary
+                if ( !has_boundary_inters.result )
+                {
+                    // we can be sure that the exterior overlaps the boundary
+                    relate::set<exterior, boundary, '1', TransposeResult>(result);                    
+                    break;
+                }
+                // else there is 1d overlap with the boundary so we must analyse the boundary
+                else
+                {
+                    // u, c
+                    typedef turns::less<1, turns::less_op_areal_linear<1> > less;
+                    std::sort(it, next, less());
+
+                    // analyse
+                    areal_boundary_analyser<turn_type> analyser;
+                    for ( turn_iterator rit = it ; rit != next ; ++rit )
+                    {
+                        // if the analyser requests, break the search
+                        if ( !analyser.apply(it, rit, next) )
+                            break;
+                    }
+
+                    // if the boundary of Areal goes out of the Linear
+                    if ( analyser.is_union_detected )
+                    {
+                        // we can be sure that the boundary of Areal overlaps the exterior of Linear
+                        relate::set<exterior, boundary, '1', TransposeResult>(result);
+                        break;
+                    }
+                }
+
+                it = next;
+            }
+
+            // if there was some previous ring
+            if ( prev_seg_id_ptr != NULL )
+            {
+                signed_size_type const next_ring_index = prev_seg_id_ptr->ring_index + 1;
+                BOOST_GEOMETRY_ASSERT(next_ring_index >= 0);
+
+                // if one of the last rings of previous single geometry was ommited
+                if ( static_cast<std::size_t>(next_ring_index)
+                        < geometry::num_interior_rings(
+                            single_geometry(geometry2, *prev_seg_id_ptr)) )
+                {
+                    // we can be sure that the exterior overlaps the boundary
+                    relate::set<exterior, boundary, '1', TransposeResult>(result);
+                }
+            }
+        }
+    }
+
+    template <typename It, typename Pred, typename Comp>
+    static void for_each_equal_range(It first, It last, Pred pred, Comp comp)
+    {
+        if ( first == last )
+            return;
+
+        It first_equal = first;
+        It prev = first;
+        for ( ++first ; ; ++first, ++prev )
+        {
+            if ( first == last || !comp(*prev, *first) )
+            {
+                pred(first_equal, first);
+                first_equal = first;
+            }
+            
+            if ( first == last )
+                break;
+        }
+    }
+
+    struct same_ip
+    {
+        template <typename Turn>
+        bool operator()(Turn const& left, Turn const& right) const
+        {
+            return left.operations[0].seg_id == right.operations[0].seg_id
+                && left.operations[0].fraction == right.operations[0].fraction;
+        }
+    };
+
+    struct same_ip_and_multi_index
+    {
+        template <typename Turn>
+        bool operator()(Turn const& left, Turn const& right) const
+        {
+            return same_ip()(left, right)
+                && left.operations[1].seg_id.multi_index == right.operations[1].seg_id.multi_index;
+        }
+    };
+
+    template <typename OpToPriority>
+    struct set_turns_group_priority
+    {
+        template <typename TurnIt>
+        void operator()(TurnIt first, TurnIt last) const
+        {
+            BOOST_GEOMETRY_ASSERT(first != last);
+            static OpToPriority op_to_priority;
+            // find the operation with the least priority
+            int least_priority = op_to_priority(first->operations[0]);
+            for ( TurnIt it = first + 1 ; it != last ; ++it )
+            {
+                int priority = op_to_priority(it->operations[0]);
+                if ( priority < least_priority )
+                    least_priority = priority;
+            }
+            // set the least priority for all turns of the group
+            for ( TurnIt it = first ; it != last ; ++it )
+            {
+                it->priority = least_priority;
+            }
+        }
+    };
+
+    template <typename SingleLess>
+    struct sort_turns_group
+    {
+        struct less
+        {
+            template <typename Turn>
+            bool operator()(Turn const& left, Turn const& right) const
+            {
+                return left.operations[1].seg_id.multi_index == right.operations[1].seg_id.multi_index ?
+                    SingleLess()(left, right) :
+                    left.priority < right.priority;
+            }
+        };
+
+        template <typename TurnIt>
+        void operator()(TurnIt first, TurnIt last) const
+        {
+            std::sort(first, last, less());
+        }
+    };
+
+    template <typename TurnIt>
+    static void sort_dispatch(TurnIt first, TurnIt last, boost::true_type const& /*is_multi*/)
+    {
+        // sort turns by Linear seg_id, then by fraction, then by other multi_index
+        typedef turns::less<0, turns::less_other_multi_index<0> > less;
+        std::sort(first, last, less());
+
+        // For the same IP and multi_index - the same other's single geometry
+        // set priorities as the least operation found for the whole single geometry
+        // so e.g. single geometries containing 'u' will always be before those only containing 'i'
+        typedef turns::op_to_int<0,2,3,1,4,0> op_to_int_xuic;
+        for_each_equal_range(first, last,
+                             set_turns_group_priority<op_to_int_xuic>(), // least operation in xuic order
+                             same_ip_and_multi_index()); // other's multi_index
+
+        // When priorities for single geometries are set now sort turns for the same IP
+        // if multi_index is the same sort them according to the single-less
+        // else use priority of the whole single-geometry set earlier
+        typedef turns::less<0, turns::less_op_linear_areal_single<0> > single_less;
+        for_each_equal_range(first, last,
+                             sort_turns_group<single_less>(),
+                             same_ip());
+    }
+
+    template <typename TurnIt>
+    static void sort_dispatch(TurnIt first, TurnIt last, boost::false_type const& /*is_multi*/)
+    {
+        // sort turns by Linear seg_id, then by fraction, then
+        // for same ring id: x, u, i, c
+        // for different ring id: c, i, u, x
+        typedef turns::less<0, turns::less_op_linear_areal_single<0> > less;
+        std::sort(first, last, less());
+    }
+    
+
+    // interrupt policy which may be passed to get_turns to interrupt the analysis
+    // based on the info in the passed result/mask
+    template <typename Areal, typename Result>
+    class interrupt_policy_linear_areal
+    {
+    public:
+        static bool const enabled = true;
+
+        interrupt_policy_linear_areal(Areal const& areal, Result & result)
+            : m_result(result), m_areal(areal)
+            , is_boundary_found(false)
+        {}
+
+// TODO: since we update result for some operations here, we may not do it in the analyser!
+
+        template <typename Range>
+        inline bool apply(Range const& turns)
+        {
+            typedef typename boost::range_iterator<Range const>::type iterator;
+            
+            for (iterator it = boost::begin(turns) ; it != boost::end(turns) ; ++it)
+            {
+                if ( it->operations[0].operation == overlay::operation_intersection )
+                {
+                    bool const no_interior_rings
+                        = geometry::num_interior_rings(
+                                single_geometry(m_areal, it->operations[1].seg_id)) == 0;
+
+                    // WARNING! THIS IS TRUE ONLY IF THE POLYGON IS SIMPLE!
+                    // OR WITHOUT INTERIOR RINGS (AND OF COURSE VALID)
+                    if ( no_interior_rings )
+                        update<interior, interior, '1', TransposeResult>(m_result);
+                }
+                else if ( it->operations[0].operation == overlay::operation_continue )
+                {
+                    update<interior, boundary, '1', TransposeResult>(m_result);
+                    is_boundary_found = true;
+                }
+                else if ( ( it->operations[0].operation == overlay::operation_union
+                         || it->operations[0].operation == overlay::operation_blocked )
+                       && it->operations[0].position == overlay::position_middle )
+                {
+// TODO: here we could also check the boundaries and set BB at this point
+                    update<interior, boundary, '0', TransposeResult>(m_result);
+                }
+            }
+
+            return m_result.interrupt;
+        }
+
+    private:
+        Result & m_result;
+        Areal const& m_areal;
+
+    public:
+        bool is_boundary_found;
+    };
+
+    // This analyser should be used like Input or SinglePass Iterator
+    // IMPORTANT! It should be called also for the end iterator - last
+    template <typename TurnInfo>
+    class turns_analyser
+    {
+        typedef typename TurnInfo::point_type turn_point_type;
+
+        static const std::size_t op_id = 0;
+        static const std::size_t other_op_id = 1;
+
+    public:
+        turns_analyser()
+            : m_previous_turn_ptr(NULL)
+            , m_previous_operation(overlay::operation_none)
+            , m_boundary_counter(0)
+            , m_interior_detected(false)
+            , m_first_interior_other_id_ptr(NULL)
+            , m_first_from_unknown(false)
+            , m_first_from_unknown_boundary_detected(false)
+        {}
+
+        template <typename Result,
+                  typename TurnIt,
+                  typename Geometry,
+                  typename OtherGeometry,
+                  typename BoundaryChecker,
+                  typename SideStrategy>
+        void apply(Result & res, TurnIt it,
+                   Geometry const& geometry,
+                   OtherGeometry const& other_geometry,
+                   BoundaryChecker const& boundary_checker,
+                   SideStrategy const& side_strategy)
+        {
+            overlay::operation_type op = it->operations[op_id].operation;
+
+            if ( op != overlay::operation_union
+              && op != overlay::operation_intersection
+              && op != overlay::operation_blocked
+              && op != overlay::operation_continue ) // operation_boundary / operation_boundary_intersection
+            {
+                return;
+            }
+
+            segment_identifier const& seg_id = it->operations[op_id].seg_id;
+            segment_identifier const& other_id = it->operations[other_op_id].seg_id;
+
+            const bool first_in_range = m_seg_watcher.update(seg_id);
+
+            // TODO: should apply() for the post-last ip be called if first_in_range ?
+            // this would unify how last points in ranges are handled
+            // possibly replacing parts of the code below
+            // e.g. for is_multi and m_interior_detected
+
+            // handle possible exit
+            bool fake_enter_detected = false;
+            if ( m_exit_watcher.get_exit_operation() == overlay::operation_union )
+            {
+                // real exit point - may be multiple
+                // we know that we entered and now we exit
+                if ( ! turn_on_the_same_ip<op_id>(m_exit_watcher.get_exit_turn(), *it) )
+                {
+                    m_exit_watcher.reset_detected_exit();
+                    
+                    update<interior, exterior, '1', TransposeResult>(res);
+
+                    // next single geometry
+                    if ( first_in_range && m_previous_turn_ptr )
+                    {
+                        // NOTE: similar code is in the post-last-ip-apply()
+                        segment_identifier const& prev_seg_id = m_previous_turn_ptr->operations[op_id].seg_id;
+
+                        bool const prev_back_b = is_endpoint_on_boundary<boundary_back>(
+                                                    range::back(sub_range(geometry, prev_seg_id)),
+                                                    boundary_checker);
+
+                        // if there is a boundary on the last point
+                        if ( prev_back_b )
+                        {
+                            update<boundary, exterior, '0', TransposeResult>(res);
+                        }
+                    }
+                }
+                // fake exit point, reset state
+                else if ( op == overlay::operation_intersection
+                        || op == overlay::operation_continue ) // operation_boundary
+                {
+                    m_exit_watcher.reset_detected_exit();
+                    fake_enter_detected = true;
+                }
+            }
+            else if ( m_exit_watcher.get_exit_operation() == overlay::operation_blocked )
+            {
+                // ignore multiple BLOCKs for this same single geometry1
+                if ( op == overlay::operation_blocked
+                  && seg_id.multi_index == m_previous_turn_ptr->operations[op_id].seg_id.multi_index )
+                {
+                    return;
+                }
+
+                if ( ( op == overlay::operation_intersection
+                    || op == overlay::operation_continue )
+                  && turn_on_the_same_ip<op_id>(m_exit_watcher.get_exit_turn(), *it) )
+                {
+                    fake_enter_detected = true;
+                }
+
+                m_exit_watcher.reset_detected_exit();
+            }
+
+            if ( BOOST_GEOMETRY_CONDITION( is_multi<OtherGeometry>::value )
+              && m_first_from_unknown )
+            {
+                // For MultiPolygon many x/u operations may be generated as a first IP
+                // if for all turns x/u was generated and any of the Polygons doesn't contain the LineString
+                // then we know that the LineString is outside
+                // Similar with the u/u turns, if it was the first one it doesn't mean that the
+                // Linestring came from the exterior
+                if ( ( m_previous_operation == overlay::operation_blocked
+                    && ( op != overlay::operation_blocked // operation different than block
+                        || seg_id.multi_index != m_previous_turn_ptr->operations[op_id].seg_id.multi_index ) ) // or the next single-geometry
+                  || ( m_previous_operation == overlay::operation_union
+                    && ! turn_on_the_same_ip<op_id>(*m_previous_turn_ptr, *it) )
+                   )
+                {
+                    update<interior, exterior, '1', TransposeResult>(res);
+                    if ( m_first_from_unknown_boundary_detected )
+                    {
+                        update<boundary, exterior, '0', TransposeResult>(res);
+                    }
+
+                    m_first_from_unknown = false;
+                    m_first_from_unknown_boundary_detected = false;
+                }
+            }
+
+// NOTE: THE WHOLE m_interior_detected HANDLING IS HERE BECAUSE WE CAN'T EFFICIENTLY SORT TURNS (CORRECTLY)
+// BECAUSE THE SAME IP MAY BE REPRESENTED BY TWO SEGMENTS WITH DIFFERENT DISTANCES
+// IT WOULD REQUIRE THE CALCULATION OF MAX DISTANCE
+// TODO: WE COULD GET RID OF THE TEST IF THE DISTANCES WERE NORMALIZED
+
+// UPDATE: THEY SHOULD BE NORMALIZED NOW
+
+// TODO: THIS IS POTENTIALLY ERROREOUS!
+// THIS ALGORITHM DEPENDS ON SOME SPECIFIC SEQUENCE OF OPERATIONS
+// IT WOULD GIVE WRONG RESULTS E.G.
+// IN THE CASE OF SELF-TOUCHING POINT WHEN 'i' WOULD BE BEFORE 'u' 
+
+            // handle the interior overlap
+            if ( m_interior_detected )
+            {
+                BOOST_GEOMETRY_ASSERT_MSG(m_previous_turn_ptr, "non-NULL ptr expected");
+
+                // real interior overlap
+                if ( ! turn_on_the_same_ip<op_id>(*m_previous_turn_ptr, *it) )
+                {
+                    update<interior, interior, '1', TransposeResult>(res);
+                    m_interior_detected = false;
+
+                    // new range detected - reset previous state and check the boundary
+                    if ( first_in_range )
+                    {
+                        segment_identifier const& prev_seg_id = m_previous_turn_ptr->operations[op_id].seg_id;
+
+                        bool const prev_back_b = is_endpoint_on_boundary<boundary_back>(
+                                                    range::back(sub_range(geometry, prev_seg_id)),
+                                                    boundary_checker);
+
+                        // if there is a boundary on the last point
+                        if ( prev_back_b )
+                        {
+                            update<boundary, interior, '0', TransposeResult>(res);
+                        }
+
+                        // The exit_watcher is reset below
+                        // m_exit_watcher.reset();
+                    }
+                }
+                // fake interior overlap
+                else if ( op == overlay::operation_continue )
+                {
+                    m_interior_detected = false;
+                }
+                else if ( op == overlay::operation_union )
+                {
+// TODO: this probably is not a good way of handling the interiors/enters
+//       the solution similar to exit_watcher would be more robust
+//       all enters should be kept and handled.
+//       maybe integrate it with the exit_watcher -> enter_exit_watcher
+                    if ( m_first_interior_other_id_ptr
+                      && m_first_interior_other_id_ptr->multi_index == other_id.multi_index )
+                    {
+                        m_interior_detected = false;
+                    }
+                }
+            }
+
+            // NOTE: If post-last-ip apply() was called this wouldn't be needed
+            if ( first_in_range )
+            {
+                m_exit_watcher.reset();
+                m_boundary_counter = 0;
+                m_first_from_unknown = false;
+                m_first_from_unknown_boundary_detected = false;
+            }
+
+            // i/u, c/u
+            if ( op == overlay::operation_intersection
+              || op == overlay::operation_continue ) // operation_boundary/operation_boundary_intersection
+            {
+                bool const first_point = first_in_range || m_first_from_unknown;
+                bool no_enters_detected = m_exit_watcher.is_outside();
+                m_exit_watcher.enter(*it);
+
+                if ( op == overlay::operation_intersection )
+                {
+                    if ( m_boundary_counter > 0 && it->operations[op_id].is_collinear )
+                        --m_boundary_counter;
+
+                    if ( m_boundary_counter == 0 )
+                    {
+                        // interiors overlaps
+                        //update<interior, interior, '1', TransposeResult>(res);
+
+// TODO: think about the implementation of the more robust version
+//       this way only the first enter will be handled
+                        if ( !m_interior_detected )
+                        {
+                            // don't update now
+                            // we might enter a boundary of some other ring on the same IP
+                            m_interior_detected = true;
+                            m_first_interior_other_id_ptr = boost::addressof(other_id);
+                        }
+                    }
+                }
+                else // operation_boundary
+                {
+                    // don't add to the count for all met boundaries
+                    // only if this is the "new" boundary
+                    if ( first_point || !it->operations[op_id].is_collinear )
+                        ++m_boundary_counter;
+
+                    update<interior, boundary, '1', TransposeResult>(res);
+                }
+
+                bool const this_b
+                    = is_ip_on_boundary<boundary_front>(it->point,
+                                                        it->operations[op_id],
+                                                        boundary_checker,
+                                                        seg_id);
+                // going inside on boundary point
+                if ( this_b )
+                {
+                    update<boundary, boundary, '0', TransposeResult>(res);
+                }
+                // going inside on non-boundary point
+                else
+                {
+                    update<interior, boundary, '0', TransposeResult>(res);
+
+                    // if we didn't enter in the past, we were outside
+                    if ( no_enters_detected
+                      && ! fake_enter_detected
+                      && it->operations[op_id].position != overlay::position_front )
+                    {
+// TODO: calculate_from_inside() is only needed if the current Linestring is not closed
+                        bool const from_inside = first_point
+                                              && calculate_from_inside(geometry,
+                                                                       other_geometry,
+                                                                       *it,
+                                                                       side_strategy);
+
+                        if ( from_inside )
+                            update<interior, interior, '1', TransposeResult>(res);
+                        else
+                            update<interior, exterior, '1', TransposeResult>(res);
+
+                        // if it's the first IP then the first point is outside
+                        if ( first_point )
+                        {
+                            bool const front_b = is_endpoint_on_boundary<boundary_front>(
+                                                    range::front(sub_range(geometry, seg_id)),
+                                                    boundary_checker);
+
+                            // if there is a boundary on the first point
+                            if ( front_b )
+                            {
+                                if ( from_inside )
+                                    update<boundary, interior, '0', TransposeResult>(res);
+                                else
+                                    update<boundary, exterior, '0', TransposeResult>(res);
+                            }
+                        }
+                    }
+                }
+
+                if ( BOOST_GEOMETRY_CONDITION( is_multi<OtherGeometry>::value ) )
+                {
+                    m_first_from_unknown = false;
+                    m_first_from_unknown_boundary_detected = false;
+                }
+            }
+            // u/u, x/u
+            else if ( op == overlay::operation_union || op == overlay::operation_blocked )
+            {
+                bool const op_blocked = op == overlay::operation_blocked;
+                bool const no_enters_detected = m_exit_watcher.is_outside()
+// TODO: is this condition ok?
+// TODO: move it into the exit_watcher?
+                    && m_exit_watcher.get_exit_operation() == overlay::operation_none;
+                    
+                if ( op == overlay::operation_union )
+                {
+                    if ( m_boundary_counter > 0 && it->operations[op_id].is_collinear )
+                        --m_boundary_counter;
+                }
+                else // overlay::operation_blocked
+                {
+                    m_boundary_counter = 0;
+                }
+
+                // we're inside, possibly going out right now
+                if ( ! no_enters_detected )
+                {
+                    if ( op_blocked
+                      && it->operations[op_id].position == overlay::position_back ) // ignore spikes!
+                    {
+                        // check if this is indeed the boundary point
+                        // NOTE: is_ip_on_boundary<>() should be called here but the result will be the same
+                        if ( is_endpoint_on_boundary<boundary_back>(it->point, boundary_checker) )
+                        {
+                            update<boundary, boundary, '0', TransposeResult>(res);
+                        }
+                    }
+                    // union, inside, but no exit -> collinear on self-intersection point
+                    // not needed since we're already inside the boundary
+                    /*else if ( !exit_detected )
+                    {
+                        update<interior, boundary, '0', TransposeResult>(res);
+                    }*/
+                }
+                // we're outside or inside and this is the first turn
+                else
+                {
+                    bool const this_b = is_ip_on_boundary<boundary_any>(it->point,
+                                                                        it->operations[op_id],
+                                                                        boundary_checker,
+                                                                        seg_id);
+                    // if current IP is on boundary of the geometry
+                    if ( this_b )
+                    {
+                        update<boundary, boundary, '0', TransposeResult>(res);
+                    }
+                    // if current IP is not on boundary of the geometry
+                    else
+                    {
+                        update<interior, boundary, '0', TransposeResult>(res);
+                    }
+
+                    // TODO: very similar code is used in the handling of intersection
+                    if ( it->operations[op_id].position != overlay::position_front )
+                    {
+// TODO: calculate_from_inside() is only needed if the current Linestring is not closed
+                        // NOTE: this is not enough for MultiPolygon and operation_blocked
+                        // For LS/MultiPolygon multiple x/u turns may be generated
+                        // the first checked Polygon may be the one which LS is outside for.
+                        bool const first_point = first_in_range || m_first_from_unknown;
+                        bool const first_from_inside = first_point
+                                                    && calculate_from_inside(geometry,
+                                                                             other_geometry,
+                                                                             *it,
+                                                                             side_strategy);
+                        if ( first_from_inside )
+                        {
+                            update<interior, interior, '1', TransposeResult>(res);
+
+                            // notify the exit_watcher that we started inside
+                            m_exit_watcher.enter(*it);
+                            // and reset unknown flags since we know that we started inside
+                            m_first_from_unknown = false;
+                            m_first_from_unknown_boundary_detected = false;
+                        }
+                        else
+                        {
+                            if ( BOOST_GEOMETRY_CONDITION( is_multi<OtherGeometry>::value )
+                              /*&& ( op == overlay::operation_blocked
+                                || op == overlay::operation_union )*/ ) // if we're here it's u or x
+                            {
+                                m_first_from_unknown = true;
+                            }
+                            else
+                            {
+                                update<interior, exterior, '1', TransposeResult>(res);
+                            }
+                        }
+
+                        // first IP on the last segment point - this means that the first point is outside or inside
+                        if ( first_point && ( !this_b || op_blocked ) )
+                        {
+                            bool const front_b = is_endpoint_on_boundary<boundary_front>(
+                                                    range::front(sub_range(geometry, seg_id)),
+                                                    boundary_checker);
+
+                            // if there is a boundary on the first point
+                            if ( front_b )
+                            {
+                                if ( first_from_inside )
+                                {
+                                    update<boundary, interior, '0', TransposeResult>(res);
+                                }
+                                else
+                                {
+                                    if ( BOOST_GEOMETRY_CONDITION( is_multi<OtherGeometry>::value )
+                                      /*&& ( op == overlay::operation_blocked
+                                        || op == overlay::operation_union )*/ ) // if we're here it's u or x
+                                    {
+                                        BOOST_GEOMETRY_ASSERT(m_first_from_unknown);
+                                        m_first_from_unknown_boundary_detected = true;
+                                    }
+                                    else
+                                    {
+                                        update<boundary, exterior, '0', TransposeResult>(res);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // if we're going along a boundary, we exit only if the linestring was collinear
+                if ( m_boundary_counter == 0
+                  || it->operations[op_id].is_collinear )
+                {
+                    // notify the exit watcher about the possible exit
+                    m_exit_watcher.exit(*it);
+                }
+            }
+
+            // store ref to previously analysed (valid) turn
+            m_previous_turn_ptr = boost::addressof(*it);
+            // and previously analysed (valid) operation
+            m_previous_operation = op;
+        }
+
+        // it == last
+        template <typename Result,
+                  typename TurnIt,
+                  typename Geometry,
+                  typename OtherGeometry,
+                  typename BoundaryChecker>
+        void apply(Result & res,
+                   TurnIt first, TurnIt last,
+                   Geometry const& geometry,
+                   OtherGeometry const& /*other_geometry*/,
+                   BoundaryChecker const& boundary_checker)
+        {
+            boost::ignore_unused(first, last);
+            //BOOST_GEOMETRY_ASSERT( first != last );
+
+            // For MultiPolygon many x/u operations may be generated as a first IP
+            // if for all turns x/u was generated and any of the Polygons doesn't contain the LineString
+            // then we know that the LineString is outside
+            if ( BOOST_GEOMETRY_CONDITION( is_multi<OtherGeometry>::value )
+              && m_first_from_unknown )
+            {
+                update<interior, exterior, '1', TransposeResult>(res);
+                if ( m_first_from_unknown_boundary_detected )
+                {
+                    update<boundary, exterior, '0', TransposeResult>(res);
+                }
+
+                // done below
+                //m_first_from_unknown = false;
+                //m_first_from_unknown_boundary_detected = false;
+            }
+
+            // here, the possible exit is the real one
+            // we know that we entered and now we exit
+            if ( /*m_exit_watcher.get_exit_operation() == overlay::operation_union // THIS CHECK IS REDUNDANT
+                ||*/ m_previous_operation == overlay::operation_union
+                && !m_interior_detected )
+            {
+                // for sure
+                update<interior, exterior, '1', TransposeResult>(res);
+
+                BOOST_GEOMETRY_ASSERT(first != last);
+                BOOST_GEOMETRY_ASSERT(m_previous_turn_ptr);
+
+                segment_identifier const& prev_seg_id = m_previous_turn_ptr->operations[op_id].seg_id;
+
+                bool const prev_back_b = is_endpoint_on_boundary<boundary_back>(
+                                            range::back(sub_range(geometry, prev_seg_id)),
+                                            boundary_checker);
+
+                // if there is a boundary on the last point
+                if ( prev_back_b )
+                {
+                    update<boundary, exterior, '0', TransposeResult>(res);
+                }
+            }
+            // we might enter some Areal and didn't go out,
+            else if ( m_previous_operation == overlay::operation_intersection
+                   || m_interior_detected )
+            {
+                // just in case
+                update<interior, interior, '1', TransposeResult>(res);
+                m_interior_detected = false;
+
+                BOOST_GEOMETRY_ASSERT(first != last);
+                BOOST_GEOMETRY_ASSERT(m_previous_turn_ptr);
+
+                segment_identifier const& prev_seg_id = m_previous_turn_ptr->operations[op_id].seg_id;
+
+                bool const prev_back_b = is_endpoint_on_boundary<boundary_back>(
+                                            range::back(sub_range(geometry, prev_seg_id)),
+                                            boundary_checker);
+
+                // if there is a boundary on the last point
+                if ( prev_back_b )
+                {
+                    update<boundary, interior, '0', TransposeResult>(res);
+                }
+            }
+
+            // This condition may be false if the Linestring is lying on the Polygon's collinear spike
+            // if Polygon's spikes are not handled in get_turns() or relate() (they currently aren't)
+            //BOOST_GEOMETRY_ASSERT_MSG(m_previous_operation != overlay::operation_continue,
+            //                    "Unexpected operation! Probably the error in get_turns(L,A) or relate(L,A)");
+            // Currently one c/c turn is generated for the exit
+            //   when a Linestring is going out on a collinear spike
+            // When a Linestring is going in on a collinear spike
+            //   the turn is not generated for the entry
+            // So assume it's the former
+            if ( m_previous_operation == overlay::operation_continue )
+            {
+                update<interior, exterior, '1', TransposeResult>(res);
+
+                segment_identifier const& prev_seg_id = m_previous_turn_ptr->operations[op_id].seg_id;
+
+                bool const prev_back_b = is_endpoint_on_boundary<boundary_back>(
+                                            range::back(sub_range(geometry, prev_seg_id)),
+                                            boundary_checker);
+
+                // if there is a boundary on the last point
+                if ( prev_back_b )
+                {
+                    update<boundary, exterior, '0', TransposeResult>(res);
+                }
+            }
+
+            // Reset exit watcher before the analysis of the next Linestring
+            m_exit_watcher.reset();
+            m_boundary_counter = 0;
+            m_first_from_unknown = false;
+            m_first_from_unknown_boundary_detected = false;
+        }
+
+        // check if the passed turn's segment of Linear geometry arrived
+        // from the inside or the outside of the Areal geometry
+        template <typename Turn, typename SideStrategy>
+        static inline bool calculate_from_inside(Geometry1 const& geometry1,
+                                                 Geometry2 const& geometry2,
+                                                 Turn const& turn,
+                                                 SideStrategy const& side_strategy)
+        {
+            typedef typename cs_tag<typename Turn::point_type>::type cs_tag;
+
+            if ( turn.operations[op_id].position == overlay::position_front )
+                return false;
+
+            typename sub_range_return_type<Geometry1 const>::type
+                range1 = sub_range(geometry1, turn.operations[op_id].seg_id);
+            
+            typedef detail::normalized_view<Geometry2 const> const range2_type;
+            typedef typename boost::range_iterator<range2_type>::type range2_iterator;
+            range2_type range2(sub_range(geometry2, turn.operations[other_op_id].seg_id));
+            
+            BOOST_GEOMETRY_ASSERT(boost::size(range1));
+            std::size_t const s2 = boost::size(range2);
+            BOOST_GEOMETRY_ASSERT(s2 > 2);
+            std::size_t const seg_count2 = s2 - 1;
+
+            std::size_t const p_seg_ij = static_cast<std::size_t>(turn.operations[op_id].seg_id.segment_index);
+            std::size_t const q_seg_ij = static_cast<std::size_t>(turn.operations[other_op_id].seg_id.segment_index);
+
+            BOOST_GEOMETRY_ASSERT(p_seg_ij + 1 < boost::size(range1));
+            BOOST_GEOMETRY_ASSERT(q_seg_ij + 1 < s2);
+
+            point1_type const& pi = range::at(range1, p_seg_ij);
+            point2_type const& qi = range::at(range2, q_seg_ij);
+            point2_type const& qj = range::at(range2, q_seg_ij + 1);
+            point1_type qi_conv;
+            geometry::convert(qi, qi_conv);
+            bool const is_ip_qj = equals::equals_point_point(turn.point, qj);
+// TODO: test this!
+//            BOOST_GEOMETRY_ASSERT(!equals::equals_point_point(turn.point, pi));
+//            BOOST_GEOMETRY_ASSERT(!equals::equals_point_point(turn.point, qi));
+            point1_type new_pj;
+            geometry::convert(turn.point, new_pj);
+
+            if ( is_ip_qj )
+            {
+                std::size_t const q_seg_jk = (q_seg_ij + 1) % seg_count2;
+// TODO: the following function should return immediately, however the worst case complexity is O(N)
+// It would be good to replace it with some O(1) mechanism
+                range2_iterator qk_it = find_next_non_duplicated(boost::begin(range2),
+                                                                 range::pos(range2, q_seg_jk),
+                                                                 boost::end(range2));
+
+                // Will this sequence of points be always correct?
+                overlay::side_calculator<cs_tag, point1_type, point2_type, SideStrategy>
+                    side_calc(qi_conv, new_pj, pi, qi, qj, *qk_it, side_strategy);
+
+                return calculate_from_inside_sides(side_calc);
+            }
+            else
+            {
+                point2_type new_qj;
+                geometry::convert(turn.point, new_qj);
+
+                overlay::side_calculator<cs_tag, point1_type, point2_type, SideStrategy>
+                    side_calc(qi_conv, new_pj, pi, qi, new_qj, qj, side_strategy);
+
+                return calculate_from_inside_sides(side_calc);
+            }
+        }
+
+        template <typename It>
+        static inline It find_next_non_duplicated(It first, It current, It last)
+        {
+            BOOST_GEOMETRY_ASSERT( current != last );
+
+            It it = current;
+
+            for ( ++it ; it != last ; ++it )
+            {
+                if ( !equals::equals_point_point(*current, *it) )
+                    return it;
+            }
+
+            // if not found start from the beginning
+            for ( it = first ; it != current ; ++it )
+            {
+                if ( !equals::equals_point_point(*current, *it) )
+                    return it;
+            }
+
+            return current;
+        }
+
+        // calculate inside or outside based on side_calc
+        // this is simplified version of a check from equal<>
+        template <typename SideCalc>
+        static inline bool calculate_from_inside_sides(SideCalc const& side_calc)
+        {
+            int const side_pk_p = side_calc.pk_wrt_p1();
+            int const side_qk_p = side_calc.qk_wrt_p1();
+            // If they turn to same side (not opposite sides)
+            if (! overlay::base_turn_handler::opposite(side_pk_p, side_qk_p))
+            {
+                int const side_pk_q2 = side_calc.pk_wrt_q2();
+                return side_pk_q2 == -1;
+            }
+            else
+            {
+                return side_pk_p == -1;
+            }
+        }
+
+    private:
+        exit_watcher<TurnInfo, op_id> m_exit_watcher;
+        segment_watcher<same_single> m_seg_watcher;
+        TurnInfo * m_previous_turn_ptr;
+        overlay::operation_type m_previous_operation;
+        unsigned m_boundary_counter;
+        bool m_interior_detected;
+        const segment_identifier * m_first_interior_other_id_ptr;
+        bool m_first_from_unknown;
+        bool m_first_from_unknown_boundary_detected;
+    };
+
+    // call analyser.apply() for each turn in range
+    // IMPORTANT! The analyser is also called for the end iterator - last
+    template <typename Result,
+              typename TurnIt,
+              typename Analyser,
+              typename Geometry,
+              typename OtherGeometry,
+              typename BoundaryChecker,
+              typename SideStrategy>
+    static inline void analyse_each_turn(Result & res,
+                                         Analyser & analyser,
+                                         TurnIt first, TurnIt last,
+                                         Geometry const& geometry,
+                                         OtherGeometry const& other_geometry,
+                                         BoundaryChecker const& boundary_checker,
+                                         SideStrategy const& side_strategy)
+    {
+        if ( first == last )
+            return;
+
+        for ( TurnIt it = first ; it != last ; ++it )
+        {
+            analyser.apply(res, it,
+                           geometry, other_geometry,
+                           boundary_checker,
+                           side_strategy);
+
+            if ( BOOST_GEOMETRY_CONDITION( res.interrupt ) )
+                return;
+        }
+
+        analyser.apply(res, first, last,
+                       geometry, other_geometry,
+                       boundary_checker);
+    }
+
+    // less comparator comparing multi_index then ring_index
+    // may be used to sort turns by ring
+    struct less_ring
+    {
+        template <typename Turn>
+        inline bool operator()(Turn const& left, Turn const& right) const
+        {
+            return left.operations[1].seg_id.multi_index < right.operations[1].seg_id.multi_index
+                || ( left.operations[1].seg_id.multi_index == right.operations[1].seg_id.multi_index
+                  && left.operations[1].seg_id.ring_index < right.operations[1].seg_id.ring_index );
+        }
+    };
+
+    // policy/functor checking if a turn's operation is operation_continue
+    struct has_boundary_intersection
+    {
+        has_boundary_intersection()
+            : result(false) {}
+
+        template <typename Turn>
+        inline void operator()(Turn const& turn)
+        {
+            if ( turn.operations[1].operation == overlay::operation_continue )
+                result = true;
+        }
+
+        bool result;
+    };
+
+    // iterate through the range and search for the different multi_index or ring_index
+    // also call fun for each turn in the current range
+    template <typename It, typename Fun>
+    static inline It find_next_ring(It first, It last, Fun & fun)
+    {
+        if ( first == last )
+            return last;
+
+        signed_size_type const multi_index = first->operations[1].seg_id.multi_index;
+        signed_size_type const ring_index = first->operations[1].seg_id.ring_index;
+
+        fun(*first);
+        ++first;
+
+        for ( ; first != last ; ++first )
+        {
+            if ( multi_index != first->operations[1].seg_id.multi_index
+              || ring_index != first->operations[1].seg_id.ring_index )
+            {
+                return first;
+            }
+
+            fun(*first);
+        }
+
+        return last;
+    }
+
+    // analyser which called for turns sorted by seg/distance/operation
+    // checks if the boundary of Areal geometry really got out
+    // into the exterior of Linear geometry
+    template <typename TurnInfo>
+    class areal_boundary_analyser
+    {
+    public:
+        areal_boundary_analyser()
+            : is_union_detected(false)
+            , m_previous_turn_ptr(NULL)
+        {}
+
+        template <typename TurnIt>
+        bool apply(TurnIt /*first*/, TurnIt it, TurnIt last)
+        {
+            overlay::operation_type op = it->operations[1].operation;
+
+            if ( it != last )
+            {
+                if ( op != overlay::operation_union
+                  && op != overlay::operation_continue )
+                {
+                    return true;
+                }
+
+                if ( is_union_detected )
+                {
+                    BOOST_GEOMETRY_ASSERT(m_previous_turn_ptr != NULL);
+                    if ( !detail::equals::equals_point_point(it->point, m_previous_turn_ptr->point) )
+                    {
+                        // break
+                        return false;
+                    }
+                    else if ( op == overlay::operation_continue ) // operation_boundary
+                    {
+                        is_union_detected = false;
+                    }
+                }
+
+                if ( op == overlay::operation_union )
+                {
+                    is_union_detected = true;
+                    m_previous_turn_ptr = boost::addressof(*it);
+                }
+
+                return true;
+            }
+            else
+            {
+                return false;
+            }            
+        }
+
+        bool is_union_detected;
+
+    private:
+        const TurnInfo * m_previous_turn_ptr;
+    };
+};
+
+template <typename Geometry1, typename Geometry2>
+struct areal_linear
+{
+    typedef linear_areal<Geometry2, Geometry1, true> linear_areal_type;
+
+    static const bool interruption_enabled = linear_areal_type::interruption_enabled;
+
+    template <typename Result, typename IntersectionStrategy>
+    static inline void apply(Geometry1 const& geometry1, Geometry2 const& geometry2,
+                             Result & result,
+                             IntersectionStrategy const& intersection_strategy)
+    {
+        linear_areal_type::apply(geometry2, geometry1, result, intersection_strategy);
+    }
+};
+
+}} // namespace detail::relate
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_LINEAR_AREAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/linear_linear.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/linear_linear.hpp
new file mode 100644
index 00000000000..520f2bd775f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/linear_linear.hpp
@@ -0,0 +1,793 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2013, 2014, 2015, 2017.
+// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_LINEAR_LINEAR_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_LINEAR_LINEAR_HPP
+
+#include <algorithm>
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/range/size.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/algorithms/detail/sub_range.hpp>
+#include <boost/geometry/algorithms/detail/single_geometry.hpp>
+
+#include <boost/geometry/algorithms/detail/relate/point_geometry.hpp>
+#include <boost/geometry/algorithms/detail/relate/result.hpp>
+#include <boost/geometry/algorithms/detail/relate/turns.hpp>
+#include <boost/geometry/algorithms/detail/relate/boundary_checker.hpp>
+#include <boost/geometry/algorithms/detail/relate/follow_helpers.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace relate {
+
+template <typename Result, typename BoundaryChecker, bool TransposeResult>
+class disjoint_linestring_pred
+{
+public:
+    disjoint_linestring_pred(Result & res,
+                             BoundaryChecker const& boundary_checker)
+        : m_result(res)
+        , m_boundary_checker(boundary_checker)
+        , m_flags(0)
+    {
+        if ( ! may_update<interior, exterior, '1', TransposeResult>(m_result) )
+        {
+            m_flags |= 1;
+        }
+        if ( ! may_update<boundary, exterior, '0', TransposeResult>(m_result) )
+        {
+            m_flags |= 2;
+        }
+    }
+
+    template <typename Linestring>
+    bool operator()(Linestring const& linestring)
+    {
+        if ( m_flags == 3 )
+        {
+            return false;
+        }
+
+        std::size_t const count = boost::size(linestring);
+        
+        // invalid input
+        if ( count < 2 )
+        {
+            // ignore
+            // TODO: throw an exception?
+            return true;
+        }
+
+        // point-like linestring
+        if ( count == 2
+          && equals::equals_point_point(range::front(linestring),
+                                        range::back(linestring)) )
+        {
+            update<interior, exterior, '0', TransposeResult>(m_result);
+        }
+        else
+        {
+            update<interior, exterior, '1', TransposeResult>(m_result);
+            m_flags |= 1;
+
+            // check if there is a boundary
+            if ( m_flags < 2
+              && ( m_boundary_checker.template
+                    is_endpoint_boundary<boundary_front>(range::front(linestring))
+                || m_boundary_checker.template
+                    is_endpoint_boundary<boundary_back>(range::back(linestring)) ) )
+            {
+                update<boundary, exterior, '0', TransposeResult>(m_result);
+                m_flags |= 2;
+            }
+        }
+
+        return m_flags != 3
+            && ! m_result.interrupt;
+    }
+
+private:
+    Result & m_result;
+    BoundaryChecker const& m_boundary_checker;
+    unsigned m_flags;
+};
+
+template <typename Geometry1, typename Geometry2>
+struct linear_linear
+{
+    static const bool interruption_enabled = true;
+
+    typedef typename geometry::point_type<Geometry1>::type point1_type;
+    typedef typename geometry::point_type<Geometry2>::type point2_type;
+
+    template <typename Result, typename IntersectionStrategy>
+    static inline void apply(Geometry1 const& geometry1, Geometry2 const& geometry2,
+                             Result & result,
+                             IntersectionStrategy const& intersection_strategy)
+    {
+        // The result should be FFFFFFFFF
+        relate::set<exterior, exterior, result_dimension<Geometry1>::value>(result);// FFFFFFFFd, d in [1,9] or T
+        if ( BOOST_GEOMETRY_CONDITION( result.interrupt ) )
+            return;
+
+        // get and analyse turns
+        typedef typename turns::get_turns<Geometry1, Geometry2>::turn_info turn_type;
+        std::vector<turn_type> turns;
+
+        interrupt_policy_linear_linear<Result> interrupt_policy(result);
+
+        turns::get_turns
+            <
+                Geometry1,
+                Geometry2,
+                detail::get_turns::get_turn_info_type<Geometry1, Geometry2, turns::assign_policy<true> >
+            >::apply(turns, geometry1, geometry2, interrupt_policy, intersection_strategy);
+
+        if ( BOOST_GEOMETRY_CONDITION( result.interrupt ) )
+            return;
+
+        boundary_checker<Geometry1> boundary_checker1(geometry1);
+        disjoint_linestring_pred<Result, boundary_checker<Geometry1>, false> pred1(result, boundary_checker1);
+        for_each_disjoint_geometry_if<0, Geometry1>::apply(turns.begin(), turns.end(), geometry1, pred1);
+        if ( BOOST_GEOMETRY_CONDITION( result.interrupt ) )
+            return;
+
+        boundary_checker<Geometry2> boundary_checker2(geometry2);
+        disjoint_linestring_pred<Result, boundary_checker<Geometry2>, true> pred2(result, boundary_checker2);
+        for_each_disjoint_geometry_if<1, Geometry2>::apply(turns.begin(), turns.end(), geometry2, pred2);
+        if ( BOOST_GEOMETRY_CONDITION( result.interrupt ) )
+            return;
+        
+        if ( turns.empty() )
+            return;
+
+        // TODO: turns must be sorted and followed only if it's possible to go out and in on the same point
+        // for linear geometries union operation must be detected which I guess would be quite often
+
+        if ( may_update<interior, interior, '1'>(result)
+          || may_update<interior, boundary, '0'>(result)
+          || may_update<interior, exterior, '1'>(result)
+          || may_update<boundary, interior, '0'>(result)
+          || may_update<boundary, boundary, '0'>(result)
+          || may_update<boundary, exterior, '0'>(result) )
+        {
+            typedef turns::less<0, turns::less_op_linear_linear<0> > less;
+            std::sort(turns.begin(), turns.end(), less());
+
+            turns_analyser<turn_type, 0> analyser;
+            analyse_each_turn(result, analyser,
+                              turns.begin(), turns.end(),
+                              geometry1, geometry2,
+                              boundary_checker1, boundary_checker2);
+        }
+
+        if ( BOOST_GEOMETRY_CONDITION( result.interrupt ) )
+            return;
+        
+        if ( may_update<interior, interior, '1', true>(result)
+          || may_update<interior, boundary, '0', true>(result)
+          || may_update<interior, exterior, '1', true>(result)
+          || may_update<boundary, interior, '0', true>(result)
+          || may_update<boundary, boundary, '0', true>(result)
+          || may_update<boundary, exterior, '0', true>(result) )
+        {
+            typedef turns::less<1, turns::less_op_linear_linear<1> > less;
+            std::sort(turns.begin(), turns.end(), less());
+
+            turns_analyser<turn_type, 1> analyser;
+            analyse_each_turn(result, analyser,
+                              turns.begin(), turns.end(),
+                              geometry2, geometry1,
+                              boundary_checker2, boundary_checker1);
+        }
+    }
+
+    template <typename Result>
+    class interrupt_policy_linear_linear
+    {
+    public:
+        static bool const enabled = true;
+
+        explicit interrupt_policy_linear_linear(Result & result)
+            : m_result(result)
+        {}
+
+// TODO: since we update result for some operations here, we may not do it in the analyser!
+
+        template <typename Range>
+        inline bool apply(Range const& turns)
+        {
+            typedef typename boost::range_iterator<Range const>::type iterator;
+            
+            for (iterator it = boost::begin(turns) ; it != boost::end(turns) ; ++it)
+            {
+                if ( it->operations[0].operation == overlay::operation_intersection
+                  || it->operations[1].operation == overlay::operation_intersection )
+                {
+                    update<interior, interior, '1'>(m_result);
+                }
+                else if ( ( it->operations[0].operation == overlay::operation_union
+                         || it->operations[0].operation == overlay::operation_blocked
+                         || it->operations[1].operation == overlay::operation_union
+                         || it->operations[1].operation == overlay::operation_blocked )
+                       && it->operations[0].position == overlay::position_middle
+                       && it->operations[1].position == overlay::position_middle )
+                {
+// TODO: here we could also check the boundaries and set IB,BI,BB at this point
+                    update<interior, interior, '0'>(m_result);
+                }
+            }
+
+            return m_result.interrupt;
+        }
+
+    private:
+        Result & m_result;
+    };
+
+    // This analyser should be used like Input or SinglePass Iterator
+    template <typename TurnInfo, std::size_t OpId>
+    class turns_analyser
+    {
+        typedef typename TurnInfo::point_type turn_point_type;
+
+        static const std::size_t op_id = OpId;
+        static const std::size_t other_op_id = (OpId + 1) % 2;
+        static const bool transpose_result = OpId != 0;
+
+    public:
+        turns_analyser()
+            : m_previous_turn_ptr(NULL)
+            , m_previous_operation(overlay::operation_none)
+            , m_degenerated_turn_ptr(NULL)
+            , m_collinear_spike_exit(false)
+        {}
+
+        template <typename Result,
+                  typename TurnIt,
+                  typename Geometry,
+                  typename OtherGeometry,
+                  typename BoundaryChecker,
+                  typename OtherBoundaryChecker>
+        void apply(Result & res, TurnIt it,
+                   Geometry const& geometry,
+                   OtherGeometry const& other_geometry,
+                   BoundaryChecker const& boundary_checker,
+                   OtherBoundaryChecker const& other_boundary_checker)
+        {
+            overlay::operation_type const op = it->operations[op_id].operation;
+
+            segment_identifier const& seg_id = it->operations[op_id].seg_id;
+            segment_identifier const& other_id = it->operations[other_op_id].seg_id;
+
+            bool const first_in_range = m_seg_watcher.update(seg_id);
+
+            if ( op != overlay::operation_union
+              && op != overlay::operation_intersection
+              && op != overlay::operation_blocked )
+            {
+                // degenerated turn
+                if ( op == overlay::operation_continue
+                  && it->method == overlay::method_none
+                  && m_exit_watcher.is_outside(*it) 
+                  /*&& ( m_exit_watcher.get_exit_operation() == overlay::operation_none 
+                    || ! turn_on_the_same_ip<op_id>(m_exit_watcher.get_exit_turn(), *it) )*/ )
+                {
+                    // TODO: rewrite the above condition
+
+                    // WARNING! For spikes the above condition may be TRUE
+                    // When degenerated turns are be marked in a different way than c,c/c
+                    // different condition will be checked
+
+                    handle_degenerated(res, *it,
+                                       geometry, other_geometry,
+                                       boundary_checker, other_boundary_checker,
+                                       first_in_range);
+
+                    // TODO: not elegant solution! should be rewritten.
+                    if ( it->operations[op_id].position == overlay::position_back )
+                    {
+                        m_previous_operation = overlay::operation_blocked;
+                        m_exit_watcher.reset_detected_exit();
+                    }
+                }
+
+                return;
+            }
+
+            // reset
+            m_degenerated_turn_ptr = NULL;
+
+            // handle possible exit
+            bool fake_enter_detected = false;
+            if ( m_exit_watcher.get_exit_operation() == overlay::operation_union )
+            {
+                // real exit point - may be multiple
+                // we know that we entered and now we exit
+                if ( ! turn_on_the_same_ip<op_id>(m_exit_watcher.get_exit_turn(), *it) )
+                {
+                    m_exit_watcher.reset_detected_exit();
+                    
+                    // not the last IP
+                    update<interior, exterior, '1', transpose_result>(res);
+                }
+                // fake exit point, reset state
+                else if ( op == overlay::operation_intersection )
+                {
+                    m_exit_watcher.reset_detected_exit();
+                    fake_enter_detected = true;
+                }
+            }
+            else if ( m_exit_watcher.get_exit_operation() == overlay::operation_blocked )
+            {
+                // ignore multiple BLOCKs
+                if ( op == overlay::operation_blocked )
+                    return;
+
+                if ( op == overlay::operation_intersection
+                  && turn_on_the_same_ip<op_id>(m_exit_watcher.get_exit_turn(), *it) )
+                {
+                    fake_enter_detected = true;
+                }
+
+                m_exit_watcher.reset_detected_exit();
+            }
+
+            // i/i, i/x, i/u
+            if ( op == overlay::operation_intersection )
+            {
+                bool const was_outside = m_exit_watcher.is_outside();
+                m_exit_watcher.enter(*it);
+
+                // interiors overlaps
+                update<interior, interior, '1', transpose_result>(res);
+
+                bool const this_b = it->operations[op_id].position == overlay::position_front // ignore spikes!
+                                 && is_ip_on_boundary<boundary_front>(it->point,
+                                                                      it->operations[op_id],
+                                                                      boundary_checker,
+                                                                      seg_id);
+
+                // going inside on boundary point
+                // may be front only
+                if ( this_b )
+                {
+                    // may be front and back
+                    bool const other_b = is_ip_on_boundary<boundary_any>(it->point,
+                                                                         it->operations[other_op_id],
+                                                                         other_boundary_checker,
+                                                                         other_id);
+
+                    // it's also the boundary of the other geometry
+                    if ( other_b )
+                    {
+                        update<boundary, boundary, '0', transpose_result>(res);
+                    }
+                    else
+                    {
+                        update<boundary, interior, '0', transpose_result>(res);
+                    }
+                }
+                // going inside on non-boundary point
+                else
+                {
+                    // if we didn't enter in the past, we were outside
+                    if ( was_outside
+                      && ! fake_enter_detected
+                      && it->operations[op_id].position != overlay::position_front
+                      && ! m_collinear_spike_exit )
+                    {
+                        update<interior, exterior, '1', transpose_result>(res);
+
+                        // if it's the first IP then the first point is outside
+                        if ( first_in_range )
+                        {
+                            bool const front_b = is_endpoint_on_boundary<boundary_front>(
+                                                    range::front(sub_range(geometry, seg_id)),
+                                                    boundary_checker);
+
+                            // if there is a boundary on the first point
+                            if ( front_b )
+                            {
+                                update<boundary, exterior, '0', transpose_result>(res);
+                            }
+                        }
+                    }
+                }
+
+                m_collinear_spike_exit = false;
+            }
+            // u/i, u/u, u/x, x/i, x/u, x/x
+            else if ( op == overlay::operation_union || op == overlay::operation_blocked )
+            {
+                // TODO: is exit watcher still needed?
+                // couldn't is_collinear and some going inside counter be used instead?
+
+                bool const is_collinear = it->operations[op_id].is_collinear;
+                bool const was_outside = m_exit_watcher.is_outside()
+                                      && m_exit_watcher.get_exit_operation() == overlay::operation_none;
+// TODO: move the above condition into the exit_watcher?
+
+                // to exit we must be currently inside and the current segment must be collinear
+                if ( !was_outside && is_collinear )
+                {
+                    m_exit_watcher.exit(*it, false);
+                    // if the position is not set to back it must be a spike
+                    if ( it->operations[op_id].position != overlay::position_back )
+                    {
+                        m_collinear_spike_exit = true;
+                    }
+                }
+
+                bool const op_blocked = op == overlay::operation_blocked;
+
+                // we're inside and going out from inside
+                // possibly going out right now
+                if ( ! was_outside && is_collinear )
+                {
+                    if ( op_blocked
+                      && it->operations[op_id].position == overlay::position_back ) // ignore spikes!
+                    {
+                        // check if this is indeed the boundary point
+                        // NOTE: is_ip_on_boundary<>() should be called here but the result will be the same
+                        if ( is_endpoint_on_boundary<boundary_back>(it->point, boundary_checker) )
+                        {
+                            // may be front and back
+                            bool const other_b = is_ip_on_boundary<boundary_any>(it->point,
+                                                                                 it->operations[other_op_id],
+                                                                                 other_boundary_checker,
+                                                                                 other_id);
+                            // it's also the boundary of the other geometry
+                            if ( other_b )
+                            {
+                                update<boundary, boundary, '0', transpose_result>(res);
+                            }
+                            else
+                            {
+                                update<boundary, interior, '0', transpose_result>(res);
+                            }
+                        }
+                    }
+                }
+                // we're outside or intersects some segment from the outside
+                else
+                {
+                    // if we are truly outside
+                    if ( was_outside
+                      && it->operations[op_id].position != overlay::position_front
+                      && ! m_collinear_spike_exit
+                      /*&& !is_collinear*/ )
+                    {
+                        update<interior, exterior, '1', transpose_result>(res);
+                    }
+
+                    // boundaries don't overlap - just an optimization
+                    if ( it->method == overlay::method_crosses )
+                    {
+                        // the L1 is going from one side of the L2 to the other through the point
+                        update<interior, interior, '0', transpose_result>(res);
+
+                        // it's the first point in range
+                        if ( first_in_range )
+                        {
+                            bool const front_b = is_endpoint_on_boundary<boundary_front>(
+                                                    range::front(sub_range(geometry, seg_id)),
+                                                    boundary_checker);
+
+                            // if there is a boundary on the first point
+                            if ( front_b )
+                            {
+                                update<boundary, exterior, '0', transpose_result>(res);
+                            }
+                        }
+                    }
+                    // method other than crosses, check more conditions
+                    else
+                    {
+                        bool const this_b = is_ip_on_boundary<boundary_any>(it->point,
+                                                                            it->operations[op_id],
+                                                                            boundary_checker,
+                                                                            seg_id);
+
+                        bool const other_b = is_ip_on_boundary<boundary_any>(it->point,
+                                                                             it->operations[other_op_id],
+                                                                             other_boundary_checker,
+                                                                             other_id);
+                        
+                        // if current IP is on boundary of the geometry
+                        if ( this_b )
+                        {
+                            // it's also the boundary of the other geometry
+                            if ( other_b )
+                            {
+                                update<boundary, boundary, '0', transpose_result>(res);
+                            }
+                            else
+                            {
+                                update<boundary, interior, '0', transpose_result>(res);
+                            }
+                        }
+                        // if current IP is not on boundary of the geometry
+                        else
+                        {
+                            // it's also the boundary of the other geometry
+                            if ( other_b )
+                            {
+                                update<interior, boundary, '0', transpose_result>(res);
+                            }
+                            else
+                            {
+                                update<interior, interior, '0', transpose_result>(res);
+                            }
+                        }
+
+                        // first IP on the last segment point - this means that the first point is outside
+                        if ( first_in_range
+                          && ( !this_b || op_blocked )
+                          && was_outside
+                          && it->operations[op_id].position != overlay::position_front
+                          && ! m_collinear_spike_exit
+                          /*&& !is_collinear*/ )
+                        {
+                            bool const front_b = is_endpoint_on_boundary<boundary_front>(
+                                                    range::front(sub_range(geometry, seg_id)),
+                                                    boundary_checker);
+
+                            // if there is a boundary on the first point
+                            if ( front_b )
+                            {
+                                update<boundary, exterior, '0', transpose_result>(res);
+                            }
+                        }
+                            
+                    }
+                }
+            }
+
+            // store ref to previously analysed (valid) turn
+            m_previous_turn_ptr = boost::addressof(*it);
+            // and previously analysed (valid) operation
+            m_previous_operation = op;
+        }
+
+        // Called for last
+        template <typename Result,
+                  typename TurnIt,
+                  typename Geometry,
+                  typename OtherGeometry,
+                  typename BoundaryChecker,
+                  typename OtherBoundaryChecker>
+        void apply(Result & res,
+                   TurnIt first, TurnIt last,
+                   Geometry const& geometry,
+                   OtherGeometry const& /*other_geometry*/,
+                   BoundaryChecker const& boundary_checker,
+                   OtherBoundaryChecker const& /*other_boundary_checker*/)
+        {
+            boost::ignore_unused(first, last);
+            //BOOST_GEOMETRY_ASSERT( first != last );
+
+            // here, the possible exit is the real one
+            // we know that we entered and now we exit
+            if ( /*m_exit_watcher.get_exit_operation() == overlay::operation_union // THIS CHECK IS REDUNDANT
+                ||*/ m_previous_operation == overlay::operation_union
+                || m_degenerated_turn_ptr )
+            {
+                update<interior, exterior, '1', transpose_result>(res);
+
+                BOOST_GEOMETRY_ASSERT(first != last);
+
+                const TurnInfo * turn_ptr = NULL;
+                if ( m_degenerated_turn_ptr )
+                    turn_ptr = m_degenerated_turn_ptr;
+                else if ( m_previous_turn_ptr )
+                    turn_ptr = m_previous_turn_ptr;
+                
+                if ( turn_ptr )
+                {
+                    segment_identifier const& prev_seg_id = turn_ptr->operations[op_id].seg_id;
+
+                    //BOOST_GEOMETRY_ASSERT(!boost::empty(sub_range(geometry, prev_seg_id)));
+                    bool const prev_back_b = is_endpoint_on_boundary<boundary_back>(
+                                                range::back(sub_range(geometry, prev_seg_id)),
+                                                boundary_checker);
+
+                    // if there is a boundary on the last point
+                    if ( prev_back_b )
+                    {
+                        update<boundary, exterior, '0', transpose_result>(res);
+                    }
+                }
+            }
+
+            // Just in case,
+            // reset exit watcher before the analysis of the next Linestring
+            // note that if there are some enters stored there may be some error above
+            m_exit_watcher.reset();
+
+            m_previous_turn_ptr = NULL;
+            m_previous_operation = overlay::operation_none;
+            m_degenerated_turn_ptr = NULL;
+
+            // actually if this is set to true here there is some error
+            // in get_turns_ll or relate_ll, an assert could be checked here
+            m_collinear_spike_exit = false;
+        }
+
+        template <typename Result,
+                  typename Turn,
+                  typename Geometry,
+                  typename OtherGeometry,
+                  typename BoundaryChecker,
+                  typename OtherBoundaryChecker>
+        void handle_degenerated(Result & res,
+                                Turn const& turn,
+                                Geometry const& geometry,
+                                OtherGeometry const& other_geometry,
+                                BoundaryChecker const& boundary_checker,
+                                OtherBoundaryChecker const& /*other_boundary_checker*/,
+                                bool first_in_range)
+        {
+            typename detail::single_geometry_return_type<Geometry const>::type
+                ls1_ref = detail::single_geometry(geometry, turn.operations[op_id].seg_id);
+            typename detail::single_geometry_return_type<OtherGeometry const>::type
+                ls2_ref = detail::single_geometry(other_geometry, turn.operations[other_op_id].seg_id);
+
+            // only one of those should be true:
+
+            if ( turn.operations[op_id].position == overlay::position_front )
+            {
+                // valid, point-sized
+                if ( boost::size(ls2_ref) == 2 )
+                {
+                    bool const front_b = is_endpoint_on_boundary<boundary_front>(turn.point, boundary_checker);
+
+                    if ( front_b )
+                    {
+                        update<boundary, interior, '0', transpose_result>(res);
+                    }
+                    else
+                    {
+                        update<interior, interior, '0', transpose_result>(res);
+                    }
+
+                    // operation 'c' should be last for the same IP so we know that the next point won't be the same
+                    update<interior, exterior, '1', transpose_result>(res);
+
+                    m_degenerated_turn_ptr = boost::addressof(turn);
+                }
+            }
+            else if ( turn.operations[op_id].position == overlay::position_back )
+            {
+                // valid, point-sized
+                if ( boost::size(ls2_ref) == 2 )
+                {
+                    update<interior, exterior, '1', transpose_result>(res);
+
+                    bool const back_b = is_endpoint_on_boundary<boundary_back>(turn.point, boundary_checker);
+
+                    if ( back_b )
+                    {
+                        update<boundary, interior, '0', transpose_result>(res);
+                    }
+                    else
+                    {
+                        update<interior, interior, '0', transpose_result>(res);
+                    }
+
+                    if ( first_in_range )
+                    {
+                        //BOOST_GEOMETRY_ASSERT(!boost::empty(ls1_ref));
+                        bool const front_b = is_endpoint_on_boundary<boundary_front>(
+                                                range::front(ls1_ref), boundary_checker);
+                        if ( front_b )
+                        {
+                            update<boundary, exterior, '0', transpose_result>(res);
+                        }
+                    }
+                }
+            }
+            else if ( turn.operations[op_id].position == overlay::position_middle
+                   && turn.operations[other_op_id].position == overlay::position_middle )
+            {
+                update<interior, interior, '0', transpose_result>(res);
+
+                // here we don't know which one is degenerated
+
+                bool const is_point1 = boost::size(ls1_ref) == 2
+                                    && equals::equals_point_point(range::front(ls1_ref), range::back(ls1_ref));
+                bool const is_point2 = boost::size(ls2_ref) == 2
+                                    && equals::equals_point_point(range::front(ls2_ref), range::back(ls2_ref));
+
+                // if the second one is degenerated
+                if ( !is_point1 && is_point2 )
+                {
+                    update<interior, exterior, '1', transpose_result>(res);
+
+                    if ( first_in_range )
+                    {
+                        //BOOST_GEOMETRY_ASSERT(!boost::empty(ls1_ref));
+                        bool const front_b = is_endpoint_on_boundary<boundary_front>(
+                                                range::front(ls1_ref), boundary_checker);
+                        if ( front_b )
+                        {
+                            update<boundary, exterior, '0', transpose_result>(res);
+                        }
+                    }
+
+                    m_degenerated_turn_ptr = boost::addressof(turn);
+                }
+            }
+
+            // NOTE: other.position == front and other.position == back
+            //       will be handled later, for the other geometry
+        }
+
+    private:
+        exit_watcher<TurnInfo, OpId> m_exit_watcher;
+        segment_watcher<same_single> m_seg_watcher;
+        const TurnInfo * m_previous_turn_ptr;
+        overlay::operation_type m_previous_operation;
+        const TurnInfo * m_degenerated_turn_ptr;
+        bool m_collinear_spike_exit;
+    };
+
+    template <typename Result,
+              typename TurnIt,
+              typename Analyser,
+              typename Geometry,
+              typename OtherGeometry,
+              typename BoundaryChecker,
+              typename OtherBoundaryChecker>
+    static inline void analyse_each_turn(Result & res,
+                                         Analyser & analyser,
+                                         TurnIt first, TurnIt last,
+                                         Geometry const& geometry,
+                                         OtherGeometry const& other_geometry,
+                                         BoundaryChecker const& boundary_checker,
+                                         OtherBoundaryChecker const& other_boundary_checker)
+    {
+        if ( first == last )
+            return;
+
+        for ( TurnIt it = first ; it != last ; ++it )
+        {
+            analyser.apply(res, it,
+                           geometry, other_geometry,
+                           boundary_checker, other_boundary_checker);
+
+            if ( BOOST_GEOMETRY_CONDITION( res.interrupt ) )
+                return;
+        }
+
+        analyser.apply(res, first, last,
+                       geometry, other_geometry,
+                       boundary_checker, other_boundary_checker);
+    }
+};
+
+}} // namespace detail::relate
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_LINEAR_LINEAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/multi_point_geometry.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/multi_point_geometry.hpp
new file mode 100644
index 00000000000..47c6963b876
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/multi_point_geometry.hpp
@@ -0,0 +1,568 @@
+// Boost.Geometry
+
+// Copyright (c) 2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_MULTI_POINT_GEOMETRY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_MULTI_POINT_GEOMETRY_HPP
+
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/detail/disjoint/box_box.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/point_box.hpp>
+#include <boost/geometry/algorithms/detail/expand_by_epsilon.hpp>
+#include <boost/geometry/algorithms/detail/relate/result.hpp>
+#include <boost/geometry/algorithms/detail/relate/topology_check.hpp>
+#include <boost/geometry/algorithms/detail/within/point_in_geometry.hpp>
+#include <boost/geometry/algorithms/envelope.hpp>
+
+#include <boost/geometry/core/is_areal.hpp>
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/geometries/box.hpp>
+
+#include <boost/geometry/index/rtree.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace relate
+{
+
+template
+<
+    typename Geometry,
+    typename Tag = typename tag<Geometry>::type
+>
+struct multi_point_geometry_eb
+{
+    template <typename MultiPoint>
+    static inline bool apply(MultiPoint const& ,
+                             detail::relate::topology_check<Geometry> const& )
+    {
+        return true;
+    }
+};
+
+template <typename Geometry>
+struct multi_point_geometry_eb<Geometry, linestring_tag>
+{
+    template <typename Points>
+    struct boundary_visitor
+    {
+        boundary_visitor(Points const& points)
+            : m_points(points)
+            , m_boundary_found(false)
+        {}
+
+        template <typename Point>
+        struct find_pred
+        {
+            find_pred(Point const& point)
+                : m_point(point)
+            {}
+
+            template <typename Pt>
+            bool operator()(Pt const& pt) const
+            {
+                return detail::equals::equals_point_point(pt, m_point);
+            }
+
+            Point const& m_point;
+        };
+
+        template <typename Point>
+        bool apply(Point const& boundary_point)
+        {
+            if (std::find_if(m_points.begin(), m_points.end(), find_pred<Point>(boundary_point)) == m_points.end())
+            {
+                m_boundary_found = true;
+                return false;
+            }
+            return true;
+        }
+
+        bool result() const { return m_boundary_found; }
+
+    private:
+        Points const& m_points;
+        bool m_boundary_found;
+    };
+
+    template <typename MultiPoint>
+    static inline bool apply(MultiPoint const& multi_point,
+                             detail::relate::topology_check<Geometry> const& tc)
+    {
+        boundary_visitor<MultiPoint> visitor(multi_point);
+        tc.for_each_boundary_point(visitor);
+        return visitor.result();
+    }
+};
+
+template <typename Geometry>
+struct multi_point_geometry_eb<Geometry, multi_linestring_tag>
+{
+    template <typename Points>
+    struct boundary_visitor
+    {
+        boundary_visitor(Points const& points)
+            : m_points(points)
+            , m_boundary_found(false)
+        {}
+
+        template <typename Point>
+        bool apply(Point const& boundary_point)
+        {
+            if (! std::binary_search(m_points.begin(), m_points.end(), boundary_point, relate::less()))
+            {
+                m_boundary_found = true;
+                return false;
+            }
+            return true;
+        }
+
+        bool result() const { return m_boundary_found; }
+
+    private:
+        Points const& m_points;
+        bool m_boundary_found;
+    };
+
+    template <typename MultiPoint>
+    static inline bool apply(MultiPoint const& multi_point,
+                             detail::relate::topology_check<Geometry> const& tc)
+    {
+        typedef typename boost::range_value<MultiPoint>::type point_type;
+        typedef std::vector<point_type> points_type;
+        points_type points(boost::begin(multi_point), boost::end(multi_point));
+        std::sort(points.begin(), points.end(), relate::less());
+
+        boundary_visitor<points_type> visitor(points);
+        tc.for_each_boundary_point(visitor);
+        return visitor.result();
+    }
+};
+
+// SingleGeometry - Linear or Areal
+template <typename MultiPoint, typename SingleGeometry, bool Transpose = false>
+struct multi_point_single_geometry
+{
+    static const bool interruption_enabled = true;
+
+    template <typename Result, typename Strategy>
+    static inline void apply(MultiPoint const& multi_point,
+                             SingleGeometry const& single_geometry,
+                             Result & result,
+                             Strategy const& strategy)
+    {
+        typedef typename point_type<SingleGeometry>::type point2_type;
+        typedef model::box<point2_type> box2_type;
+        
+        box2_type box2;
+        geometry::envelope(single_geometry, box2, strategy.get_envelope_strategy());
+        geometry::detail::expand_by_epsilon(box2);
+
+        typedef typename boost::range_const_iterator<MultiPoint>::type iterator;
+        for ( iterator it = boost::begin(multi_point) ; it != boost::end(multi_point) ; ++it )
+        {
+            if (! (relate::may_update<interior, interior, '0', Transpose>(result)
+                || relate::may_update<interior, boundary, '0', Transpose>(result)
+                || relate::may_update<interior, exterior, '0', Transpose>(result) ) )
+            {
+                break;
+            }
+
+            // The default strategy is enough for Point/Box
+            if (detail::disjoint::disjoint_point_box(*it, box2))
+            {
+                relate::set<interior, exterior, '0', Transpose>(result);
+            }
+            else
+            {
+                int in_val = detail::within::point_in_geometry(*it, single_geometry, strategy);
+
+                if (in_val > 0) // within
+                {
+                    relate::set<interior, interior, '0', Transpose>(result);
+                }
+                else if (in_val == 0)
+                {
+                    relate::set<interior, boundary, '0', Transpose>(result);
+                }
+                else // in_val < 0 - not within
+                {
+                    relate::set<interior, exterior, '0', Transpose>(result);
+                }
+            }
+
+            if ( BOOST_GEOMETRY_CONDITION(result.interrupt) )
+            {
+                return;
+            }
+        }
+
+        typedef detail::relate::topology_check<SingleGeometry> tc_t;
+        if ( relate::may_update<exterior, interior, tc_t::interior, Transpose>(result)
+          || relate::may_update<exterior, boundary, tc_t::boundary, Transpose>(result) )
+        {
+            tc_t tc(single_geometry);
+
+            if ( relate::may_update<exterior, interior, tc_t::interior, Transpose>(result)
+              && tc.has_interior() )
+            {
+                // TODO: this is not true if a linestring is degenerated to a point
+                // then the interior has topological dimension = 0, not 1
+                relate::set<exterior, interior, tc_t::interior, Transpose>(result);
+            }
+
+            if ( relate::may_update<exterior, boundary, tc_t::boundary, Transpose>(result)
+              && tc.has_boundary() )
+            {
+                if (multi_point_geometry_eb<SingleGeometry>::apply(multi_point, tc))
+                    relate::set<exterior, boundary, tc_t::boundary, Transpose>(result);
+            }
+        }
+
+        relate::set<exterior, exterior, result_dimension<MultiPoint>::value, Transpose>(result);
+    }
+};
+
+
+// MultiGeometry - Linear or Areal
+// part of the algorithm calculating II and IB when no IE has to be calculated
+// using partition()
+template <typename MultiPoint, typename MultiGeometry, bool Transpose>
+class multi_point_multi_geometry_ii_ib
+{
+    struct expand_box_point
+    {
+        template <typename Box, typename Point>
+        static inline void apply(Box& total, Point const& point)
+        {
+            geometry::expand(total, point);
+        }
+    };
+
+    struct expand_box_box_pair
+    {
+        template <typename Box, typename BoxPair>
+        static inline void apply(Box& total, BoxPair const& box_pair)
+        {
+            geometry::expand(total, box_pair.first);
+        }
+    };
+
+    struct overlaps_box_point
+    {
+        template <typename Box, typename Point>
+        static inline bool apply(Box const& box, Point const& point)
+        {
+            // The default strategy is enough for Point/Box
+            return ! detail::disjoint::disjoint_point_box(point, box);
+        }
+    };
+
+    struct overlaps_box_box_pair
+    {
+        template <typename Box, typename BoxPair>
+        static inline bool apply(Box const& box, BoxPair const& box_pair)
+        {
+            // The default strategy is enough for Box/Box
+            return ! detail::disjoint::disjoint_box_box(box_pair.first, box);
+        }
+    };
+
+    template <typename Result, typename PtSegStrategy>
+    class item_visitor_type
+    {
+    public:
+        item_visitor_type(MultiGeometry const& multi_geometry,
+                          detail::relate::topology_check<MultiGeometry> const& tc,
+                          Result & result,
+                          PtSegStrategy const& strategy)
+            : m_multi_geometry(multi_geometry)
+            , m_tc(tc)
+            , m_result(result)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Point, typename BoxPair>
+        inline bool apply(Point const& point, BoxPair const& box_pair)
+        {
+            // The default strategy is enough for Point/Box
+            if (! detail::disjoint::disjoint_point_box(point, box_pair.first))
+            {
+                typename boost::range_value<MultiGeometry>::type const&
+                    single = range::at(m_multi_geometry, box_pair.second);
+
+                int in_val = detail::within::point_in_geometry(point, single, m_strategy);
+
+                if (in_val > 0) // within
+                {
+                    relate::set<interior, interior, '0', Transpose>(m_result);
+                }
+                else if (in_val == 0)
+                {
+                    if (m_tc.check_boundary_point(point))
+                        relate::set<interior, boundary, '0', Transpose>(m_result);
+                    else
+                        relate::set<interior, interior, '0', Transpose>(m_result);
+                }
+            }
+
+            if ( BOOST_GEOMETRY_CONDITION(m_result.interrupt) )
+            {
+                return false;
+            }
+
+            if (! (relate::may_update<interior, interior, '0', Transpose>(m_result)
+                || relate::may_update<interior, boundary, '0', Transpose>(m_result) ) )
+            {
+                return false;
+            }
+
+            return true;
+        }
+
+
+    private:
+        MultiGeometry const& m_multi_geometry;
+        detail::relate::topology_check<MultiGeometry> const& m_tc;
+        Result & m_result;
+        PtSegStrategy const& m_strategy;
+    };
+
+public:
+    typedef typename point_type<MultiPoint>::type point1_type;
+    typedef typename point_type<MultiGeometry>::type point2_type;
+    typedef model::box<point1_type> box1_type;
+    typedef model::box<point2_type> box2_type;
+    typedef std::pair<box2_type, std::size_t> box_pair_type;
+
+    template <typename Result, typename Strategy>
+    static inline void apply(MultiPoint const& multi_point,
+                             MultiGeometry const& multi_geometry,
+                             std::vector<box_pair_type> const& boxes,
+                             detail::relate::topology_check<MultiGeometry> const& tc,
+                             Result & result,
+                             Strategy const& strategy)
+    {
+        item_visitor_type<Result, Strategy> visitor(multi_geometry, tc, result, strategy);
+
+        geometry::partition
+            <
+                box1_type
+            >::apply(multi_point, boxes, visitor,
+                     expand_box_point(),
+                     overlaps_box_point(),
+                     expand_box_box_pair(),
+                     overlaps_box_box_pair());
+    }
+
+};
+
+// MultiGeometry - Linear or Areal
+// part of the algorithm calculating II, IB and IE
+// using rtree
+template <typename MultiPoint, typename MultiGeometry, bool Transpose>
+struct multi_point_multi_geometry_ii_ib_ie
+{
+    typedef typename point_type<MultiPoint>::type point1_type;
+    typedef typename point_type<MultiGeometry>::type point2_type;
+    typedef model::box<point1_type> box1_type;
+    typedef model::box<point2_type> box2_type;
+    typedef std::pair<box2_type, std::size_t> box_pair_type;
+    typedef std::vector<box_pair_type> boxes_type;
+    typedef typename boxes_type::const_iterator boxes_iterator;
+
+    template <typename Result, typename Strategy>
+    static inline void apply(MultiPoint const& multi_point,
+                             MultiGeometry const& multi_geometry,
+                             std::vector<box_pair_type> const& boxes,
+                             detail::relate::topology_check<MultiGeometry> const& tc,
+                             Result & result,
+                             Strategy const& strategy)
+    {
+        index::rtree<box_pair_type, index::rstar<4> > rt(boxes.begin(), boxes.end());
+
+        typedef typename boost::range_const_iterator<MultiPoint>::type iterator;
+        for ( iterator it = boost::begin(multi_point) ; it != boost::end(multi_point) ; ++it )
+        {
+            if (! (relate::may_update<interior, interior, '0', Transpose>(result)
+                || relate::may_update<interior, boundary, '0', Transpose>(result)
+                || relate::may_update<interior, exterior, '0', Transpose>(result) ) )
+            {
+                return;
+            }
+
+            typename boost::range_value<MultiPoint>::type const& point = *it;
+
+            boxes_type boxes_found;
+            rt.query(index::intersects(point), std::back_inserter(boxes_found));
+
+            bool found_ii_or_ib = false;
+            for (boxes_iterator bi = boxes_found.begin() ; bi != boxes_found.end() ; ++bi)
+            {
+                typename boost::range_value<MultiGeometry>::type const&
+                    single = range::at(multi_geometry, bi->second);
+
+                int in_val = detail::within::point_in_geometry(point, single, strategy);
+
+                if (in_val > 0) // within
+                {
+                    relate::set<interior, interior, '0', Transpose>(result);
+                    found_ii_or_ib = true;
+                }
+                else if (in_val == 0) // on boundary of single
+                {
+                    if (tc.check_boundary_point(point))
+                        relate::set<interior, boundary, '0', Transpose>(result);
+                    else
+                        relate::set<interior, interior, '0', Transpose>(result);
+                    found_ii_or_ib = true;
+                }
+            }
+
+            // neither interior nor boundary found -> exterior
+            if (found_ii_or_ib == false)
+            {
+                relate::set<interior, exterior, '0', Transpose>(result);
+            }
+
+            if ( BOOST_GEOMETRY_CONDITION(result.interrupt) )
+            {
+                return;
+            }
+        }
+    }
+};
+
+// MultiGeometry - Linear or Areal
+template <typename MultiPoint, typename MultiGeometry, bool Transpose = false>
+struct multi_point_multi_geometry
+{
+    static const bool interruption_enabled = true;
+
+    template <typename Result, typename Strategy>
+    static inline void apply(MultiPoint const& multi_point,
+                             MultiGeometry const& multi_geometry,
+                             Result & result,
+                             Strategy const& strategy)
+    {
+        typedef typename point_type<MultiGeometry>::type point2_type;
+        typedef model::box<point2_type> box2_type;
+        typedef std::pair<box2_type, std::size_t> box_pair_type;
+
+        typename Strategy::envelope_strategy_type const
+            envelope_strategy = strategy.get_envelope_strategy();
+        
+        std::size_t count2 = boost::size(multi_geometry);
+        std::vector<box_pair_type> boxes(count2);
+        for (std::size_t i = 0 ; i < count2 ; ++i)
+        {
+            geometry::envelope(range::at(multi_geometry, i), boxes[i].first, envelope_strategy);
+            geometry::detail::expand_by_epsilon(boxes[i].first);
+            boxes[i].second = i;
+        }
+
+        typedef detail::relate::topology_check<MultiGeometry> tc_t;
+        tc_t tc(multi_geometry);
+
+        if ( relate::may_update<interior, interior, '0', Transpose>(result)
+          || relate::may_update<interior, boundary, '0', Transpose>(result)
+          || relate::may_update<interior, exterior, '0', Transpose>(result) )
+        {
+            // If there is no need to calculate IE, use partition
+            if (! relate::may_update<interior, exterior, '0', Transpose>(result) )
+            {
+                multi_point_multi_geometry_ii_ib<MultiPoint, MultiGeometry, Transpose>
+                    ::apply(multi_point, multi_geometry, boxes, tc, result, strategy);
+            }
+            else // otherwise use rtree
+            {
+                multi_point_multi_geometry_ii_ib_ie<MultiPoint, MultiGeometry, Transpose>
+                    ::apply(multi_point, multi_geometry, boxes, tc, result, strategy);
+            }
+        }
+
+        if ( BOOST_GEOMETRY_CONDITION(result.interrupt) )
+        {
+            return;
+        }
+
+        if ( relate::may_update<exterior, interior, tc_t::interior, Transpose>(result)
+          || relate::may_update<exterior, boundary, tc_t::boundary, Transpose>(result) )
+        {
+            if ( relate::may_update<exterior, interior, tc_t::interior, Transpose>(result)
+              && tc.has_interior() )
+            {
+                // TODO: this is not true if a linestring is degenerated to a point
+                // then the interior has topological dimension = 0, not 1
+                relate::set<exterior, interior, tc_t::interior, Transpose>(result);
+            }
+
+            if ( relate::may_update<exterior, boundary, tc_t::boundary, Transpose>(result)
+              && tc.has_boundary() )
+            {
+                if (multi_point_geometry_eb<MultiGeometry>::apply(multi_point, tc))
+                    relate::set<exterior, boundary, tc_t::boundary, Transpose>(result);
+            }
+        }
+
+        relate::set<exterior, exterior, result_dimension<MultiPoint>::value, Transpose>(result);
+    }
+
+};
+
+
+template
+<
+    typename MultiPoint, typename Geometry,
+    bool Transpose = false,
+    bool isMulti = boost::is_same
+                    <
+                        typename tag_cast
+                            <
+                                typename tag<Geometry>::type, multi_tag
+                            >::type,
+                            multi_tag
+                    >::value
+>
+struct multi_point_geometry
+    : multi_point_single_geometry<MultiPoint, Geometry, Transpose>
+{};
+
+template <typename MultiPoint, typename Geometry, bool Transpose>
+struct multi_point_geometry<MultiPoint, Geometry, Transpose, true>
+    : multi_point_multi_geometry<MultiPoint, Geometry, Transpose>
+{};
+
+
+// transposed result of multi_point_geometry
+template <typename Geometry, typename MultiPoint>
+struct geometry_multi_point
+{
+    static const bool interruption_enabled = true;
+
+    template <typename Result, typename Strategy>
+    static inline void apply(Geometry const& geometry, MultiPoint const& multi_point,
+                             Result & result, Strategy const& strategy)
+    {
+        multi_point_geometry<MultiPoint, Geometry, true>::apply(multi_point, geometry, result, strategy);
+    }
+};
+
+}} // namespace detail::relate
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_MULTI_POINT_GEOMETRY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/point_geometry.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/point_geometry.hpp
new file mode 100644
index 00000000000..e78a404b217
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/point_geometry.hpp
@@ -0,0 +1,206 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2013, 2014, 2015, 2017.
+// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_POINT_GEOMETRY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_POINT_GEOMETRY_HPP
+
+#include <boost/geometry/algorithms/detail/within/point_in_geometry.hpp>
+//#include <boost/geometry/algorithms/within.hpp>
+//#include <boost/geometry/algorithms/covered_by.hpp>
+
+#include <boost/geometry/algorithms/detail/relate/result.hpp>
+#include <boost/geometry/algorithms/detail/relate/topology_check.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace relate {
+
+// non-point geometry
+template <typename Point, typename Geometry, bool Transpose = false>
+struct point_geometry
+{
+    // TODO: interrupt only if the topology check is complex
+
+    static const bool interruption_enabled = true;
+
+    template <typename Result, typename Strategy>
+    static inline void apply(Point const& point, Geometry const& geometry, Result & result, Strategy const& strategy)
+    {
+        int pig = detail::within::point_in_geometry(point, geometry, strategy);
+
+        if ( pig > 0 ) // within
+        {
+            relate::set<interior, interior, '0', Transpose>(result);
+        }
+        else if ( pig == 0 )
+        {
+            relate::set<interior, boundary, '0', Transpose>(result);
+        }
+        else // pig < 0 - not within
+        {
+            relate::set<interior, exterior, '0', Transpose>(result);
+        }
+
+        relate::set<exterior, exterior, result_dimension<Point>::value, Transpose>(result);
+
+        if ( BOOST_GEOMETRY_CONDITION(result.interrupt) )
+            return;
+
+        typedef detail::relate::topology_check<Geometry> tc_t;
+        if ( relate::may_update<exterior, interior, tc_t::interior, Transpose>(result)
+          || relate::may_update<exterior, boundary, tc_t::boundary, Transpose>(result) )
+        {
+            // the point is on the boundary
+            if ( pig == 0 )
+            {
+                // NOTE: even for MLs, if there is at least one boundary point,
+                // somewhere there must be another one
+                relate::set<exterior, interior, tc_t::interior, Transpose>(result);
+                relate::set<exterior, boundary, tc_t::boundary, Transpose>(result);
+            }
+            else
+            {
+                // check if there is a boundary in Geometry
+                tc_t tc(geometry);
+                if ( tc.has_interior() )
+                    relate::set<exterior, interior, tc_t::interior, Transpose>(result);
+                if ( tc.has_boundary() )
+                    relate::set<exterior, boundary, tc_t::boundary, Transpose>(result);
+            }
+        }
+    }
+};
+
+// transposed result of point_geometry
+template <typename Geometry, typename Point>
+struct geometry_point
+{
+    // TODO: interrupt only if the topology check is complex
+
+    static const bool interruption_enabled = true;
+
+    template <typename Result, typename Strategy>
+    static inline void apply(Geometry const& geometry, Point const& point, Result & result, Strategy const& strategy)
+    {
+        point_geometry<Point, Geometry, true>::apply(point, geometry, result, strategy);
+    }
+};
+
+// TODO: rewrite the folowing:
+
+//// NOTE: Those tests should be consistent with within(Point, Box) and covered_by(Point, Box)
+//// There is no EPS used in those functions, values are compared using < or <=
+//// so comparing MIN and MAX in the same way should be fine
+//
+//template <typename Box, std::size_t I = 0, std::size_t D = geometry::dimension<Box>::value>
+//struct box_has_interior
+//{
+//    static inline bool apply(Box const& box)
+//    {
+//        return geometry::get<min_corner, I>(box) < geometry::get<max_corner, I>(box)
+//            && box_has_interior<Box, I + 1, D>::apply(box);
+//    }
+//};
+//
+//template <typename Box, std::size_t D>
+//struct box_has_interior<Box, D, D>
+//{
+//    static inline bool apply(Box const&) { return true; }
+//};
+//
+//// NOTE: especially important here (see the NOTE above).
+//
+//template <typename Box, std::size_t I = 0, std::size_t D = geometry::dimension<Box>::value>
+//struct box_has_equal_min_max
+//{
+//    static inline bool apply(Box const& box)
+//    {
+//        return geometry::get<min_corner, I>(box) == geometry::get<max_corner, I>(box)
+//            && box_has_equal_min_max<Box, I + 1, D>::apply(box);
+//    }
+//};
+//
+//template <typename Box, std::size_t D>
+//struct box_has_equal_min_max<Box, D, D>
+//{
+//    static inline bool apply(Box const&) { return true; }
+//};
+//
+//template <typename Point, typename Box>
+//struct point_box
+//{
+//    static inline result apply(Point const& point, Box const& box)
+//    {
+//        result res;
+//
+//        if ( geometry::within(point, box) ) // this also means that the box has interior
+//        {
+//            return result("0FFFFFTTT");
+//        }
+//        else if ( geometry::covered_by(point, box) ) // point is on the boundary
+//        {
+//            //if ( box_has_interior<Box>::apply(box) )
+//            //{
+//            //    return result("F0FFFFTTT");
+//            //}
+//            //else if ( box_has_equal_min_max<Box>::apply(box) ) // no boundary outside point
+//            //{
+//            //    return result("F0FFFFFFT");
+//            //}
+//            //else // no interior outside point
+//            //{
+//            //    return result("F0FFFFFTT");
+//            //}
+//            return result("F0FFFF**T");
+//        }
+//        else 
+//        {
+//            /*if ( box_has_interior<Box>::apply(box) )
+//            {
+//                return result("FF0FFFTTT");
+//            }
+//            else
+//            {
+//                return result("FF0FFFFTT");
+//            }*/
+//            return result("FF0FFF*TT");
+//        }
+//
+//        return res;
+//    }
+//};
+//
+//template <typename Box, typename Point>
+//struct box_point
+//{
+//    static inline result apply(Box const& box, Point const& point)
+//    {
+//        if ( geometry::within(point, box) )
+//            return result("0FTFFTFFT");
+//        else if ( geometry::covered_by(point, box) )
+//            return result("FF*0F*FFT");
+//        else 
+//            return result("FF*FFT0FT");
+//    }
+//};
+
+}} // namespace detail::relate
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_POINT_GEOMETRY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/point_point.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/point_point.hpp
new file mode 100644
index 00000000000..68d8be031ec
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/point_point.hpp
@@ -0,0 +1,265 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2013, 2014, 2017.
+// Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_POINT_POINT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_POINT_POINT_HPP
+
+#include <algorithm>
+#include <vector>
+
+#include <boost/range/empty.hpp>
+
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+#include <boost/geometry/algorithms/detail/within/point_in_geometry.hpp>
+#include <boost/geometry/algorithms/detail/relate/less.hpp>
+#include <boost/geometry/algorithms/detail/relate/result.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace relate {
+
+template <typename Point1, typename Point2>
+struct point_point
+{
+    static const bool interruption_enabled = false;
+
+    template <typename Result, typename Strategy>
+    static inline void apply(Point1 const& point1, Point2 const& point2,
+                             Result & result,
+                             Strategy const& /*strategy*/)
+    {
+        bool equal = detail::equals::equals_point_point(point1, point2);
+        if ( equal )
+        {
+            relate::set<interior, interior, '0'>(result);
+        }
+        else
+        {
+            relate::set<interior, exterior, '0'>(result);
+            relate::set<exterior, interior, '0'>(result);
+        }
+
+        relate::set<exterior, exterior, result_dimension<Point1>::value>(result);
+    }
+};
+
+template <typename Point, typename MultiPoint>
+std::pair<bool, bool> point_multipoint_check(Point const& point, MultiPoint const& multi_point)
+{
+    bool found_inside = false;
+    bool found_outside = false;
+
+    // point_in_geometry could be used here but why iterate over MultiPoint twice?
+    // we must search for a point in the exterior because all points in MultiPoint can be equal
+
+    typedef typename boost::range_iterator<MultiPoint const>::type iterator;
+    iterator it = boost::begin(multi_point);
+    iterator last = boost::end(multi_point);
+    for ( ; it != last ; ++it )
+    {
+        bool ii = detail::equals::equals_point_point(point, *it);
+
+        if ( ii )
+            found_inside = true;
+        else
+            found_outside = true;
+
+        if ( found_inside && found_outside )
+            break;
+    }
+
+    return std::make_pair(found_inside, found_outside);
+}
+
+template <typename Point, typename MultiPoint, bool Transpose = false>
+struct point_multipoint
+{
+    static const bool interruption_enabled = false;
+
+    template <typename Result, typename Strategy>
+    static inline void apply(Point const& point, MultiPoint const& multi_point,
+                             Result & result,
+                             Strategy const& /*strategy*/)
+    {
+        if ( boost::empty(multi_point) )
+        {
+            // TODO: throw on empty input?
+            relate::set<interior, exterior, '0', Transpose>(result);
+            return;
+        }
+
+        std::pair<bool, bool> rel = point_multipoint_check(point, multi_point);
+
+        if ( rel.first ) // some point of MP is equal to P
+        {
+            relate::set<interior, interior, '0', Transpose>(result);
+
+            if ( rel.second ) // a point of MP was found outside P
+            {
+                relate::set<exterior, interior, '0', Transpose>(result);
+            }
+        }
+        else
+        {
+            relate::set<interior, exterior, '0', Transpose>(result);
+            relate::set<exterior, interior, '0', Transpose>(result);
+        }
+
+        relate::set<exterior, exterior, result_dimension<Point>::value, Transpose>(result);
+    }
+};
+
+template <typename MultiPoint, typename Point>
+struct multipoint_point
+{
+    static const bool interruption_enabled = false;
+
+    template <typename Result, typename Strategy>
+    static inline void apply(MultiPoint const& multi_point, Point const& point,
+                             Result & result,
+                             Strategy const& strategy)
+    {
+        point_multipoint<Point, MultiPoint, true>::apply(point, multi_point, result, strategy);
+    }
+};
+
+template <typename MultiPoint1, typename MultiPoint2>
+struct multipoint_multipoint
+{
+    static const bool interruption_enabled = true;
+
+    template <typename Result, typename Strategy>
+    static inline void apply(MultiPoint1 const& multi_point1, MultiPoint2 const& multi_point2,
+                             Result & result,
+                             Strategy const& /*strategy*/)
+    {
+        {
+            // TODO: throw on empty input?
+            bool empty1 = boost::empty(multi_point1);
+            bool empty2 = boost::empty(multi_point2);
+            if ( empty1 && empty2 )
+            {
+                return;
+            }
+            else if ( empty1 )
+            {
+                relate::set<exterior, interior, '0'>(result);
+                return;
+            }
+            else if ( empty2 )
+            {
+                relate::set<interior, exterior, '0'>(result);
+                return;
+            }
+        }
+
+        // The geometry containing smaller number of points will be analysed first
+        if ( boost::size(multi_point1) < boost::size(multi_point2) )
+        {
+            search_both<false>(multi_point1, multi_point2, result);
+        }
+        else
+        {
+            search_both<true>(multi_point2, multi_point1, result);
+        }
+
+        relate::set<exterior, exterior, result_dimension<MultiPoint1>::value>(result);
+    }
+
+    template <bool Transpose, typename MPt1, typename MPt2, typename Result>
+    static inline void search_both(MPt1 const& first_sorted_mpt, MPt2 const& first_iterated_mpt,
+                                   Result & result)
+    {
+        if ( relate::may_update<interior, interior, '0'>(result)
+          || relate::may_update<interior, exterior, '0'>(result)
+          || relate::may_update<exterior, interior, '0'>(result) )
+        {
+            // NlogN + MlogN
+            bool is_disjoint = search<Transpose>(first_sorted_mpt, first_iterated_mpt, result);
+
+            if ( BOOST_GEOMETRY_CONDITION(is_disjoint || result.interrupt) )
+                return;
+        }
+
+        if ( relate::may_update<interior, interior, '0'>(result)
+          || relate::may_update<interior, exterior, '0'>(result)
+          || relate::may_update<exterior, interior, '0'>(result) )
+        {
+            // MlogM + NlogM
+            search<! Transpose>(first_iterated_mpt, first_sorted_mpt, result);
+        }
+    }
+
+    template <bool Transpose,
+              typename SortedMultiPoint,
+              typename IteratedMultiPoint,
+              typename Result>
+    static inline bool search(SortedMultiPoint const& sorted_mpt,
+                              IteratedMultiPoint const& iterated_mpt,
+                              Result & result)
+    {
+        // sort points from the 1 MPt
+        typedef typename geometry::point_type<SortedMultiPoint>::type point_type;
+        std::vector<point_type> points(boost::begin(sorted_mpt), boost::end(sorted_mpt));
+        std::sort(points.begin(), points.end(), less());
+
+        bool found_inside = false;
+        bool found_outside = false;
+
+        // for each point in the second MPt
+        typedef typename boost::range_iterator<IteratedMultiPoint const>::type iterator;
+        for ( iterator it = boost::begin(iterated_mpt) ;
+              it != boost::end(iterated_mpt) ; ++it )
+        {
+            bool ii =
+                std::binary_search(points.begin(), points.end(), *it, less());
+            if ( ii )
+                found_inside = true;
+            else
+                found_outside = true;
+
+            if ( found_inside && found_outside )
+                break;
+        }
+
+        if ( found_inside ) // some point of MP2 is equal to some of MP1
+        {
+// TODO: if I/I is set for one MPt, this won't be changed when the other one in analysed
+//       so if e.g. only I/I must be analysed we musn't check the other MPt
+
+            relate::set<interior, interior, '0', Transpose>(result);
+
+            if ( found_outside ) // some point of MP2 was found outside of MP1
+            {
+                relate::set<exterior, interior, '0', Transpose>(result);
+            }
+        }
+        else
+        {
+            relate::set<interior, exterior, '0', Transpose>(result);
+            relate::set<exterior, interior, '0', Transpose>(result);
+        }
+
+        // if no point is intersecting the other MPt then we musn't analyse the reversed case
+        return ! found_inside;
+    }
+};
+
+}} // namespace detail::relate
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_POINT_POINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/relate_impl.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/relate_impl.hpp
new file mode 100644
index 00000000000..2ec2361c03b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/relate_impl.hpp
@@ -0,0 +1,81 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2013, 2014, 2015.
+// Modifications copyright (c) 2013-2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_RELATE_IMPL_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_RELATE_IMPL_HPP
+
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+
+#include <boost/geometry/algorithms/detail/relate/interface.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+#include <boost/geometry/core/tag.hpp>
+
+namespace boost { namespace geometry {
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace relate {
+
+struct implemented_tag {};
+
+template <template <typename, typename> class StaticMaskTrait,
+          typename Geometry1,
+          typename Geometry2>
+struct relate_impl
+    : boost::mpl::if_
+        <
+            boost::mpl::or_
+                <
+                    boost::is_base_of
+                        <
+                            nyi::not_implemented_tag,
+                            StaticMaskTrait<Geometry1, Geometry2>
+                        >,
+                    boost::is_base_of
+                        <
+                            nyi::not_implemented_tag,
+                            dispatch::relate<Geometry1, Geometry2>
+                        >
+                >,
+            not_implemented
+                <
+                    typename geometry::tag<Geometry1>::type,
+                    typename geometry::tag<Geometry2>::type
+                >,
+            implemented_tag
+        >::type
+{
+    template <typename Strategy>
+    static inline bool apply(Geometry1 const& g1, Geometry2 const& g2, Strategy const& strategy)
+    {
+        typename detail::relate::result_handler_type
+            <
+                Geometry1,
+                Geometry2,
+                typename StaticMaskTrait<Geometry1, Geometry2>::type
+            >::type handler;
+
+        dispatch::relate<Geometry1, Geometry2>::apply(g1, g2, handler, strategy);
+
+        return handler.result();
+    }
+};
+
+}} // namespace detail::relate
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_RELATE_IMPL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/result.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/result.hpp
new file mode 100644
index 00000000000..07287dc6259
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/result.hpp
@@ -0,0 +1,1296 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013-2016.
+// Modifications copyright (c) 2013-2016 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_RESULT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_RESULT_HPP
+
+#include <cstddef>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/begin.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/end.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/exception.hpp>
+#include <boost/geometry/util/condition.hpp>
+
+namespace boost { namespace geometry {
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace relate {
+
+enum field { interior = 0, boundary = 1, exterior = 2 };
+
+// TODO: IF THE RESULT IS UPDATED WITH THE MAX POSSIBLE VALUE FOR SOME PAIR OF GEOEMTRIES
+// THE VALUE ALREADY STORED MUSN'T BE CHECKED
+// update() calls chould be replaced with set() in those cases
+// but for safety reasons (STATIC_ASSERT) we should check if parameter D is valid and set() doesn't do that
+// so some additional function could be added, e.g. set_dim()
+
+// --------------- MATRIX ----------------
+
+// matrix
+
+template <std::size_t Height, std::size_t Width = Height>
+class matrix
+{
+public:
+    typedef char value_type;
+    typedef std::size_t size_type;
+    typedef const char * const_iterator;
+    typedef const_iterator iterator;
+
+    static const std::size_t static_width = Width;
+    static const std::size_t static_height = Height;
+    static const std::size_t static_size = Width * Height;
+    
+    inline matrix()
+    {
+        ::memset(m_array, 'F', static_size);
+    }
+
+    template <field F1, field F2>
+    inline char get() const
+    {
+        BOOST_STATIC_ASSERT(F1 < Height && F2 < Width);
+        static const std::size_t index = F1 * Width + F2;
+        BOOST_STATIC_ASSERT(index < static_size);
+        return m_array[index];
+    }
+
+    template <field F1, field F2, char V>
+    inline void set()
+    {
+        BOOST_STATIC_ASSERT(F1 < Height && F2 < Width);
+        static const std::size_t index = F1 * Width + F2;
+        BOOST_STATIC_ASSERT(index < static_size);
+        m_array[index] = V;
+    }
+
+    inline char operator[](std::size_t index) const
+    {
+        BOOST_GEOMETRY_ASSERT(index < static_size);
+        return m_array[index];
+    }
+
+    inline const_iterator begin() const
+    {
+        return m_array;
+    }
+
+    inline const_iterator end() const
+    {
+        return m_array + static_size;
+    }
+
+    inline static std::size_t size()
+    {
+        return static_size;
+    }
+    
+    inline const char * data() const
+    {
+        return m_array;
+    }
+
+    inline std::string str() const
+    {
+        return std::string(m_array, static_size);
+    }
+
+private:
+    char m_array[static_size];
+};
+
+// matrix_handler
+
+template <typename Matrix>
+class matrix_handler
+{
+public:
+    typedef Matrix result_type;
+
+    static const bool interrupt = false;
+
+    matrix_handler()
+    {}
+
+    result_type const& result() const
+    {
+        return m_matrix;
+    }
+
+    result_type const& matrix() const
+    {
+        return m_matrix;
+    }
+
+    result_type & matrix()
+    {
+        return m_matrix;
+    }
+
+    template <field F1, field F2, char D>
+    inline bool may_update() const
+    {
+        BOOST_STATIC_ASSERT('0' <= D && D <= '9');
+
+        char const c = m_matrix.template get<F1, F2>();
+        return D > c || c > '9';
+    }
+
+    template <field F1, field F2, char V>
+    inline void set()
+    {
+        static const bool in_bounds = F1 < Matrix::static_height
+                                   && F2 < Matrix::static_width;
+        typedef boost::integral_constant<bool, in_bounds> in_bounds_t;
+        set_dispatch<F1, F2, V>(in_bounds_t());
+    }
+
+    template <field F1, field F2, char D>
+    inline void update()
+    {
+        static const bool in_bounds = F1 < Matrix::static_height
+                                   && F2 < Matrix::static_width;
+        typedef boost::integral_constant<bool, in_bounds> in_bounds_t;
+        update_dispatch<F1, F2, D>(in_bounds_t());
+    }
+
+private:
+    template <field F1, field F2, char V>
+    inline void set_dispatch(integral_constant<bool, true>)
+    {
+        static const std::size_t index = F1 * Matrix::static_width + F2;
+        BOOST_STATIC_ASSERT(index < Matrix::static_size);
+        BOOST_STATIC_ASSERT(('0' <= V && V <= '9') || V == 'T' || V == 'F');
+        m_matrix.template set<F1, F2, V>();
+    }
+    template <field F1, field F2, char V>
+    inline void set_dispatch(integral_constant<bool, false>)
+    {}
+
+    template <field F1, field F2, char D>
+    inline void update_dispatch(integral_constant<bool, true>)
+    {
+        static const std::size_t index = F1 * Matrix::static_width + F2;
+        BOOST_STATIC_ASSERT(index < Matrix::static_size);
+        BOOST_STATIC_ASSERT('0' <= D && D <= '9');
+        char const c = m_matrix.template get<F1, F2>();
+        if ( D > c || c > '9')
+            m_matrix.template set<F1, F2, D>();
+    }
+    template <field F1, field F2, char D>
+    inline void update_dispatch(integral_constant<bool, false>)
+    {}
+
+    Matrix m_matrix;
+};
+
+// --------------- RUN-TIME MASK ----------------
+
+// run-time mask
+
+template <std::size_t Height, std::size_t Width = Height>
+class mask
+{
+public:
+    static const std::size_t static_width = Width;
+    static const std::size_t static_height = Height;
+    static const std::size_t static_size = Width * Height;
+
+    inline mask(const char * s)
+    {
+        char * it = m_array;
+        char * const last = m_array + static_size;
+        for ( ; it != last && *s != '\0' ; ++it, ++s )
+        {
+            char c = *s;
+            check_char(c);
+            *it = c;
+        }
+        if ( it != last )
+        {
+            ::memset(it, '*', last - it);
+        }
+    }
+
+    inline mask(const char * s, std::size_t count)
+    {
+        if ( count > static_size )
+        {
+            count = static_size;
+        }
+        if ( count > 0 )
+        {
+            std::for_each(s, s + count, check_char);
+            ::memcpy(m_array, s, count);
+        }
+        if ( count < static_size )
+        {
+            ::memset(m_array + count, '*', static_size - count);
+        }
+    }
+
+    template <field F1, field F2>
+    inline char get() const
+    {
+        BOOST_STATIC_ASSERT(F1 < Height && F2 < Width);
+        static const std::size_t index = F1 * Width + F2;
+        BOOST_STATIC_ASSERT(index < static_size);
+        return m_array[index];
+    }
+
+private:
+    static inline void check_char(char c)
+    {
+        bool const is_valid = c == '*' || c == 'T' || c == 'F'
+                         || ( c >= '0' && c <= '9' );
+        if ( !is_valid )
+        {
+            BOOST_THROW_EXCEPTION(geometry::invalid_input_exception());
+        }
+    }
+
+    char m_array[static_size];
+};
+
+// interrupt()
+
+template <typename Mask, bool InterruptEnabled>
+struct interrupt_dispatch
+{
+    template <field F1, field F2, char V>
+    static inline bool apply(Mask const&)
+    {
+        return false;
+    }
+};
+
+template <typename Mask>
+struct interrupt_dispatch<Mask, true>
+{
+    template <field F1, field F2, char V>
+    static inline bool apply(Mask const& mask)
+    {
+        char m = mask.template get<F1, F2>();
+        return check_element<V>(m);
+    }
+
+    template <char V>
+    static inline bool check_element(char m)
+    {
+        if ( BOOST_GEOMETRY_CONDITION(V >= '0' && V <= '9') )
+        {
+            return m == 'F' || ( m < V && m >= '0' && m <= '9' );
+        }
+        else if ( BOOST_GEOMETRY_CONDITION(V == 'T') )
+        {
+            return m == 'F';
+        }
+        return false;
+    }
+};
+
+template <typename Masks, int I = 0, int N = boost::tuples::length<Masks>::value>
+struct interrupt_dispatch_tuple
+{
+    template <field F1, field F2, char V>
+    static inline bool apply(Masks const& masks)
+    {
+        typedef typename boost::tuples::element<I, Masks>::type mask_type;
+        mask_type const& mask = boost::get<I>(masks);
+        return interrupt_dispatch<mask_type, true>::template apply<F1, F2, V>(mask)
+            && interrupt_dispatch_tuple<Masks, I+1>::template apply<F1, F2, V>(masks);
+    }
+};
+
+template <typename Masks, int N>
+struct interrupt_dispatch_tuple<Masks, N, N>
+{
+    template <field F1, field F2, char V>
+    static inline bool apply(Masks const& )
+    {
+        return true;
+    }
+};
+
+//template <typename T0, typename T1, typename T2, typename T3, typename T4,
+//          typename T5, typename T6, typename T7, typename T8, typename T9>
+//struct interrupt_dispatch<boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>, true>
+//{
+//    typedef boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> mask_type;
+
+//    template <field F1, field F2, char V>
+//    static inline bool apply(mask_type const& mask)
+//    {
+//        return interrupt_dispatch_tuple<mask_type>::template apply<F1, F2, V>(mask);
+//    }
+//};
+
+template <typename Head, typename Tail>
+struct interrupt_dispatch<boost::tuples::cons<Head, Tail>, true>
+{
+    typedef boost::tuples::cons<Head, Tail> mask_type;
+
+    template <field F1, field F2, char V>
+    static inline bool apply(mask_type const& mask)
+    {
+        return interrupt_dispatch_tuple<mask_type>::template apply<F1, F2, V>(mask);
+    }
+};
+
+template <field F1, field F2, char V, bool InterruptEnabled, typename Mask>
+inline bool interrupt(Mask const& mask)
+{
+    return interrupt_dispatch<Mask, InterruptEnabled>
+                ::template apply<F1, F2, V>(mask);
+}
+
+// may_update()
+
+template <typename Mask>
+struct may_update_dispatch
+{
+    template <field F1, field F2, char D, typename Matrix>
+    static inline bool apply(Mask const& mask, Matrix const& matrix)
+    {
+        BOOST_STATIC_ASSERT('0' <= D && D <= '9');
+
+        char const m = mask.template get<F1, F2>();
+        
+        if ( m == 'F' )
+        {
+            return true;
+        }
+        else if ( m == 'T' )
+        {
+            char const c = matrix.template get<F1, F2>();
+            return c == 'F'; // if it's T or between 0 and 9, the result will be the same
+        }
+        else if ( m >= '0' && m <= '9' )
+        {
+            char const c = matrix.template get<F1, F2>();
+            return D > c || c > '9';
+        }
+
+        return false;
+    }
+};
+
+template <typename Masks, int I = 0, int N = boost::tuples::length<Masks>::value>
+struct may_update_dispatch_tuple
+{
+    template <field F1, field F2, char D, typename Matrix>
+    static inline bool apply(Masks const& masks, Matrix const& matrix)
+    {
+        typedef typename boost::tuples::element<I, Masks>::type mask_type;
+        mask_type const& mask = boost::get<I>(masks);
+        return may_update_dispatch<mask_type>::template apply<F1, F2, D>(mask, matrix)
+            || may_update_dispatch_tuple<Masks, I+1>::template apply<F1, F2, D>(masks, matrix);
+    }
+};
+
+template <typename Masks, int N>
+struct may_update_dispatch_tuple<Masks, N, N>
+{
+    template <field F1, field F2, char D, typename Matrix>
+    static inline bool apply(Masks const& , Matrix const& )
+    {
+        return false;
+    }
+};
+
+//template <typename T0, typename T1, typename T2, typename T3, typename T4,
+//          typename T5, typename T6, typename T7, typename T8, typename T9>
+//struct may_update_dispatch< boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >
+//{
+//    typedef boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> mask_type;
+
+//    template <field F1, field F2, char D, typename Matrix>
+//    static inline bool apply(mask_type const& mask, Matrix const& matrix)
+//    {
+//        return may_update_dispatch_tuple<mask_type>::template apply<F1, F2, D>(mask, matrix);
+//    }
+//};
+
+template <typename Head, typename Tail>
+struct may_update_dispatch< boost::tuples::cons<Head, Tail> >
+{
+    typedef boost::tuples::cons<Head, Tail> mask_type;
+
+    template <field F1, field F2, char D, typename Matrix>
+    static inline bool apply(mask_type const& mask, Matrix const& matrix)
+    {
+        return may_update_dispatch_tuple<mask_type>::template apply<F1, F2, D>(mask, matrix);
+    }
+};
+
+template <field F1, field F2, char D, typename Mask, typename Matrix>
+inline bool may_update(Mask const& mask, Matrix const& matrix)
+{
+    return may_update_dispatch<Mask>
+                ::template apply<F1, F2, D>(mask, matrix);
+}
+
+// check_matrix()
+
+template <typename Mask>
+struct check_dispatch
+{
+    template <typename Matrix>
+    static inline bool apply(Mask const& mask, Matrix const& matrix)
+    {
+        return per_one<interior, interior>(mask, matrix)
+            && per_one<interior, boundary>(mask, matrix)
+            && per_one<interior, exterior>(mask, matrix)
+            && per_one<boundary, interior>(mask, matrix)
+            && per_one<boundary, boundary>(mask, matrix)
+            && per_one<boundary, exterior>(mask, matrix)
+            && per_one<exterior, interior>(mask, matrix)
+            && per_one<exterior, boundary>(mask, matrix)
+            && per_one<exterior, exterior>(mask, matrix);
+    }
+
+    template <field F1, field F2, typename Matrix>
+    static inline bool per_one(Mask const& mask, Matrix const& matrix)
+    {
+        const char mask_el = mask.template get<F1, F2>();
+        const char el = matrix.template get<F1, F2>();
+
+        if ( mask_el == 'F' )
+        {
+            return el == 'F';
+        }
+        else if ( mask_el == 'T' )
+        {
+            return el == 'T' || ( el >= '0' && el <= '9' );
+        }
+        else if ( mask_el >= '0' && mask_el <= '9' )
+        {
+            return el == mask_el;
+        }
+
+        return true;
+    }
+};
+
+template <typename Masks, int I = 0, int N = boost::tuples::length<Masks>::value>
+struct check_dispatch_tuple
+{
+    template <typename Matrix>
+    static inline bool apply(Masks const& masks, Matrix const& matrix)
+    {
+        typedef typename boost::tuples::element<I, Masks>::type mask_type;
+        mask_type const& mask = boost::get<I>(masks);
+        return check_dispatch<mask_type>::apply(mask, matrix)
+            || check_dispatch_tuple<Masks, I+1>::apply(masks, matrix);
+    }
+};
+
+template <typename Masks, int N>
+struct check_dispatch_tuple<Masks, N, N>
+{
+    template <typename Matrix>
+    static inline bool apply(Masks const&, Matrix const&)
+    {
+        return false;
+    }
+};
+
+//template <typename T0, typename T1, typename T2, typename T3, typename T4,
+//          typename T5, typename T6, typename T7, typename T8, typename T9>
+//struct check_dispatch< boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >
+//{
+//    typedef boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> mask_type;
+
+//    template <typename Matrix>
+//    static inline bool apply(mask_type const& mask, Matrix const& matrix)
+//    {
+//        return check_dispatch_tuple<mask_type>::apply(mask, matrix);
+//    }
+//};
+
+template <typename Head, typename Tail>
+struct check_dispatch< boost::tuples::cons<Head, Tail> >
+{
+    typedef boost::tuples::cons<Head, Tail> mask_type;
+
+    template <typename Matrix>
+    static inline bool apply(mask_type const& mask, Matrix const& matrix)
+    {
+        return check_dispatch_tuple<mask_type>::apply(mask, matrix);
+    }
+};
+
+template <typename Mask, typename Matrix>
+inline bool check_matrix(Mask const& mask, Matrix const& matrix)
+{
+    return check_dispatch<Mask>::apply(mask, matrix);
+}
+
+// matrix_width
+
+template <typename MatrixOrMask>
+struct matrix_width
+{
+    static const std::size_t value = MatrixOrMask::static_width;
+};
+
+template <typename Tuple,
+          int I = 0,
+          int N = boost::tuples::length<Tuple>::value>
+struct matrix_width_tuple
+{
+    static const std::size_t
+        current = matrix_width<typename boost::tuples::element<I, Tuple>::type>::value;
+    static const std::size_t
+        next = matrix_width_tuple<Tuple, I+1>::value;
+
+    static const std::size_t
+        value = current > next ? current : next;
+};
+
+template <typename Tuple, int N>
+struct matrix_width_tuple<Tuple, N, N>
+{
+    static const std::size_t value = 0;
+};
+
+template <typename Head, typename Tail>
+struct matrix_width< boost::tuples::cons<Head, Tail> >
+{
+    static const std::size_t
+        value = matrix_width_tuple< boost::tuples::cons<Head, Tail> >::value;
+};
+
+// mask_handler
+
+template <typename Mask, bool Interrupt>
+class mask_handler
+    : private matrix_handler
+        <
+            relate::matrix<matrix_width<Mask>::value>
+        >
+{
+    typedef matrix_handler
+        <
+            relate::matrix<matrix_width<Mask>::value>
+        > base_t;
+
+public:
+    typedef bool result_type;
+
+    bool interrupt;
+
+    inline explicit mask_handler(Mask const& m)
+        : interrupt(false)
+        , m_mask(m)
+    {}
+
+    result_type result() const
+    {
+        return !interrupt
+            && check_matrix(m_mask, base_t::matrix());
+    }
+
+    template <field F1, field F2, char D>
+    inline bool may_update() const
+    {
+        return detail::relate::may_update<F1, F2, D>(
+                    m_mask, base_t::matrix()
+               );
+    }
+
+    template <field F1, field F2, char V>
+    inline void set()
+    {
+        if ( relate::interrupt<F1, F2, V, Interrupt>(m_mask) )
+        {
+            interrupt = true;
+        }
+        else
+        {
+            base_t::template set<F1, F2, V>();
+        }
+    }
+
+    template <field F1, field F2, char V>
+    inline void update()
+    {
+        if ( relate::interrupt<F1, F2, V, Interrupt>(m_mask) )
+        {
+            interrupt = true;
+        }
+        else
+        {
+            base_t::template update<F1, F2, V>();
+        }
+    }
+
+private:
+    Mask const& m_mask;
+};
+
+// --------------- COMPILE-TIME MASK ----------------
+
+// static_check_characters
+template
+<
+    typename Seq,
+    typename First = typename boost::mpl::begin<Seq>::type,
+    typename Last = typename boost::mpl::end<Seq>::type
+>
+struct static_check_characters
+    : static_check_characters
+        <
+            Seq,
+            typename boost::mpl::next<First>::type
+        >
+{
+    typedef typename boost::mpl::deref<First>::type type;
+    static const char value = type::value;
+    static const bool is_valid = (value >= '0' && value <= '9')
+                               || value == 'T' || value == 'F' || value == '*';
+    BOOST_MPL_ASSERT_MSG((is_valid),
+                         INVALID_STATIC_MASK_CHARACTER,
+                         (type));
+};
+
+template <typename Seq, typename Last>
+struct static_check_characters<Seq, Last, Last>
+{};
+
+// static_mask
+
+template
+<
+    typename Seq,
+    std::size_t Height,
+    std::size_t Width = Height
+>
+struct static_mask
+{
+    static const std::size_t static_width = Width;
+    static const std::size_t static_height = Height;
+    static const std::size_t static_size = Width * Height;
+
+    BOOST_STATIC_ASSERT(
+        std::size_t(boost::mpl::size<Seq>::type::value) == static_size);
+    
+    template <detail::relate::field F1, detail::relate::field F2>
+    struct static_get
+    {
+        BOOST_STATIC_ASSERT(std::size_t(F1) < static_height);
+        BOOST_STATIC_ASSERT(std::size_t(F2) < static_width);
+
+        static const char value
+            = boost::mpl::at_c<Seq, F1 * static_width + F2>::type::value;
+    };
+
+private:
+    // check static_mask characters
+    enum { mask_check = sizeof(static_check_characters<Seq>) };
+};
+
+// static_should_handle_element
+
+template <typename StaticMask, field F1, field F2, bool IsSequence>
+struct static_should_handle_element_dispatch
+{
+    static const char mask_el = StaticMask::template static_get<F1, F2>::value;
+    static const bool value = mask_el == 'F'
+                           || mask_el == 'T'
+                           || ( mask_el >= '0' && mask_el <= '9' );
+};
+
+template <typename First, typename Last, field F1, field F2>
+struct static_should_handle_element_sequence
+{
+    typedef typename boost::mpl::deref<First>::type StaticMask;
+
+    static const bool value
+        = static_should_handle_element_dispatch
+            <
+                StaticMask,
+                F1, F2,
+                boost::mpl::is_sequence<StaticMask>::value
+            >::value
+       || static_should_handle_element_sequence
+            <
+                typename boost::mpl::next<First>::type,
+                Last,
+                F1, F2
+            >::value;
+};
+
+template <typename Last, field F1, field F2>
+struct static_should_handle_element_sequence<Last, Last, F1, F2>
+{
+    static const bool value = false;
+};
+
+template <typename StaticMask, field F1, field F2>
+struct static_should_handle_element_dispatch<StaticMask, F1, F2, true>
+{
+    static const bool value
+        = static_should_handle_element_sequence
+            <
+                typename boost::mpl::begin<StaticMask>::type,
+                typename boost::mpl::end<StaticMask>::type,
+                F1, F2
+            >::value;
+};
+
+template <typename StaticMask, field F1, field F2>
+struct static_should_handle_element
+{
+    static const bool value
+        = static_should_handle_element_dispatch
+            <
+                StaticMask,
+                F1, F2,
+                boost::mpl::is_sequence<StaticMask>::value
+            >::value;
+};
+
+// static_interrupt
+
+template <typename StaticMask, char V, field F1, field F2, bool InterruptEnabled, bool IsSequence>
+struct static_interrupt_dispatch
+{
+    static const bool value = false;
+};
+
+template <typename StaticMask, char V, field F1, field F2, bool IsSequence>
+struct static_interrupt_dispatch<StaticMask, V, F1, F2, true, IsSequence>
+{
+    static const char mask_el = StaticMask::template static_get<F1, F2>::value;
+
+    static const bool value
+        = ( V >= '0' && V <= '9' ) ? 
+          ( mask_el == 'F' || ( mask_el < V && mask_el >= '0' && mask_el <= '9' ) ) :
+          ( ( V == 'T' ) ? mask_el == 'F' : false );
+};
+
+template <typename First, typename Last, char V, field F1, field F2>
+struct static_interrupt_sequence
+{
+    typedef typename boost::mpl::deref<First>::type StaticMask;
+
+    static const bool value
+        = static_interrupt_dispatch
+            <
+                StaticMask,
+                V, F1, F2,
+                true,
+                boost::mpl::is_sequence<StaticMask>::value
+            >::value
+       && static_interrupt_sequence
+            <
+                typename boost::mpl::next<First>::type,
+                Last,
+                V, F1, F2
+            >::value;
+};
+
+template <typename Last, char V, field F1, field F2>
+struct static_interrupt_sequence<Last, Last, V, F1, F2>
+{
+    static const bool value = true;
+};
+
+template <typename StaticMask, char V, field F1, field F2>
+struct static_interrupt_dispatch<StaticMask, V, F1, F2, true, true>
+{
+    static const bool value
+        = static_interrupt_sequence
+            <
+                typename boost::mpl::begin<StaticMask>::type,
+                typename boost::mpl::end<StaticMask>::type,
+                V, F1, F2
+            >::value;
+};
+
+template <typename StaticMask, char V, field F1, field F2, bool EnableInterrupt>
+struct static_interrupt
+{
+    static const bool value
+        = static_interrupt_dispatch
+            <
+                StaticMask,
+                V, F1, F2,
+                EnableInterrupt,
+                boost::mpl::is_sequence<StaticMask>::value
+            >::value;
+};
+
+// static_may_update
+
+template <typename StaticMask, char D, field F1, field F2, bool IsSequence>
+struct static_may_update_dispatch
+{
+    static const char mask_el = StaticMask::template static_get<F1, F2>::value;
+    static const int version
+                        = mask_el == 'F' ? 0
+                        : mask_el == 'T' ? 1
+                        : mask_el >= '0' && mask_el <= '9' ? 2
+                        : 3;
+
+    template <typename Matrix>
+    static inline bool apply(Matrix const& matrix)
+    {
+        return apply_dispatch(matrix, integral_constant<int, version>());
+    }
+
+    // mask_el == 'F'
+    template <typename Matrix>
+    static inline bool apply_dispatch(Matrix const& , integral_constant<int, 0>)
+    {
+        return true;
+    }
+    // mask_el == 'T'
+    template <typename Matrix>
+    static inline bool apply_dispatch(Matrix const& matrix, integral_constant<int, 1>)
+    {
+        char const c = matrix.template get<F1, F2>();
+        return c == 'F'; // if it's T or between 0 and 9, the result will be the same
+    }
+    // mask_el >= '0' && mask_el <= '9'
+    template <typename Matrix>
+    static inline bool apply_dispatch(Matrix const& matrix, integral_constant<int, 2>)
+    {
+        char const c = matrix.template get<F1, F2>();
+        return D > c || c > '9';
+    }
+    // else
+    template <typename Matrix>
+    static inline bool apply_dispatch(Matrix const&, integral_constant<int, 3>)
+    {
+        return false;
+    }
+};
+
+template <typename First, typename Last, char D, field F1, field F2>
+struct static_may_update_sequence
+{
+    typedef typename boost::mpl::deref<First>::type StaticMask;
+
+    template <typename Matrix>
+    static inline bool apply(Matrix const& matrix)
+    {
+        return static_may_update_dispatch
+                <
+                    StaticMask,
+                    D, F1, F2,
+                    boost::mpl::is_sequence<StaticMask>::value
+                >::apply(matrix)
+            || static_may_update_sequence
+                <
+                    typename boost::mpl::next<First>::type,
+                    Last,
+                    D, F1, F2
+                >::apply(matrix);
+    }
+};
+
+template <typename Last, char D, field F1, field F2>
+struct static_may_update_sequence<Last, Last, D, F1, F2>
+{
+    template <typename Matrix>
+    static inline bool apply(Matrix const& /*matrix*/)
+    {
+        return false;
+    }
+};
+
+template <typename StaticMask, char D, field F1, field F2>
+struct static_may_update_dispatch<StaticMask, D, F1, F2, true>
+{
+    template <typename Matrix>
+    static inline bool apply(Matrix const& matrix)
+    {
+        return static_may_update_sequence
+                <
+                    typename boost::mpl::begin<StaticMask>::type,
+                    typename boost::mpl::end<StaticMask>::type,
+                    D, F1, F2
+                >::apply(matrix);
+    }
+};
+
+template <typename StaticMask, char D, field F1, field F2>
+struct static_may_update
+{
+    template <typename Matrix>
+    static inline bool apply(Matrix const& matrix)
+    {
+        return static_may_update_dispatch
+                <
+                    StaticMask,
+                    D, F1, F2,
+                    boost::mpl::is_sequence<StaticMask>::value
+                >::apply(matrix);
+    }
+};
+
+// static_check_matrix
+
+template <typename StaticMask, bool IsSequence>
+struct static_check_dispatch
+{
+    template <typename Matrix>
+    static inline bool apply(Matrix const& matrix)
+    {
+        return per_one<interior, interior>::apply(matrix)
+            && per_one<interior, boundary>::apply(matrix)
+            && per_one<interior, exterior>::apply(matrix)
+            && per_one<boundary, interior>::apply(matrix)
+            && per_one<boundary, boundary>::apply(matrix)
+            && per_one<boundary, exterior>::apply(matrix)
+            && per_one<exterior, interior>::apply(matrix)
+            && per_one<exterior, boundary>::apply(matrix)
+            && per_one<exterior, exterior>::apply(matrix);
+    }
+    
+    template <field F1, field F2>
+    struct per_one
+    {
+        static const char mask_el = StaticMask::template static_get<F1, F2>::value;
+        static const int version
+                            = mask_el == 'F' ? 0
+                            : mask_el == 'T' ? 1
+                            : mask_el >= '0' && mask_el <= '9' ? 2
+                            : 3;
+
+        template <typename Matrix>
+        static inline bool apply(Matrix const& matrix)
+        {
+            const char el = matrix.template get<F1, F2>();
+            return apply_dispatch(el, integral_constant<int, version>());
+        }
+
+        // mask_el == 'F'
+        static inline bool apply_dispatch(char el, integral_constant<int, 0>)
+        {
+            return el == 'F';
+        }
+        // mask_el == 'T'
+        static inline bool apply_dispatch(char el, integral_constant<int, 1>)
+        {
+            return el == 'T' || ( el >= '0' && el <= '9' );
+        }
+        // mask_el >= '0' && mask_el <= '9'
+        static inline bool apply_dispatch(char el, integral_constant<int, 2>)
+        {
+            return el == mask_el;
+        }
+        // else
+        static inline bool apply_dispatch(char /*el*/, integral_constant<int, 3>)
+        {
+            return true;
+        }
+    };
+};
+
+template <typename First, typename Last>
+struct static_check_sequence
+{
+    typedef typename boost::mpl::deref<First>::type StaticMask;
+
+    template <typename Matrix>
+    static inline bool apply(Matrix const& matrix)
+    {
+        return static_check_dispatch
+                <
+                    StaticMask,
+                    boost::mpl::is_sequence<StaticMask>::value
+                >::apply(matrix)
+            || static_check_sequence
+                <
+                    typename boost::mpl::next<First>::type,
+                    Last
+                >::apply(matrix);
+    }
+};
+
+template <typename Last>
+struct static_check_sequence<Last, Last>
+{
+    template <typename Matrix>
+    static inline bool apply(Matrix const& /*matrix*/)
+    {
+        return false;
+    }
+};
+
+template <typename StaticMask>
+struct static_check_dispatch<StaticMask, true>
+{
+    template <typename Matrix>
+    static inline bool apply(Matrix const& matrix)
+    {
+        return static_check_sequence
+                <
+                    typename boost::mpl::begin<StaticMask>::type,
+                    typename boost::mpl::end<StaticMask>::type
+                >::apply(matrix);
+    }
+};
+
+template <typename StaticMask>
+struct static_check_matrix
+{
+    template <typename Matrix>
+    static inline bool apply(Matrix const& matrix)
+    {
+        return static_check_dispatch
+                <
+                    StaticMask,
+                    boost::mpl::is_sequence<StaticMask>::value
+                >::apply(matrix);
+    }
+};
+
+// static_mask_handler
+
+template <typename StaticMask, bool Interrupt>
+class static_mask_handler
+    : private matrix_handler< matrix<3> >
+{
+    typedef matrix_handler< relate::matrix<3> > base_type;
+
+public:
+    typedef bool result_type;
+
+    bool interrupt;
+
+    inline static_mask_handler()
+        : interrupt(false)
+    {}
+
+    inline explicit static_mask_handler(StaticMask const& /*dummy*/)
+        : interrupt(false)
+    {}
+
+    result_type result() const
+    {
+        return (!Interrupt || !interrupt)
+            && static_check_matrix<StaticMask>::apply(base_type::matrix());
+    }
+
+    template <field F1, field F2, char D>
+    inline bool may_update() const
+    {
+        return static_may_update<StaticMask, D, F1, F2>::
+                    apply(base_type::matrix());
+    }
+
+    template <field F1, field F2>
+    static inline bool expects()
+    {
+        return static_should_handle_element<StaticMask, F1, F2>::value;
+    }
+
+    template <field F1, field F2, char V>
+    inline void set()
+    {
+        static const bool interrupt_c = static_interrupt<StaticMask, V, F1, F2, Interrupt>::value;
+        static const bool should_handle = static_should_handle_element<StaticMask, F1, F2>::value;
+        static const int version = interrupt_c ? 0
+                                 : should_handle ? 1
+                                 : 2;
+
+        set_dispatch<F1, F2, V>(integral_constant<int, version>());
+    }
+
+    template <field F1, field F2, char V>
+    inline void update()
+    {
+        static const bool interrupt_c = static_interrupt<StaticMask, V, F1, F2, Interrupt>::value;
+        static const bool should_handle = static_should_handle_element<StaticMask, F1, F2>::value;
+        static const int version = interrupt_c ? 0
+                                 : should_handle ? 1
+                                 : 2;
+
+        update_dispatch<F1, F2, V>(integral_constant<int, version>());
+    }
+
+private:
+    // Interrupt && interrupt
+    template <field F1, field F2, char V>
+    inline void set_dispatch(integral_constant<int, 0>)
+    {
+        interrupt = true;
+    }
+    // else should_handle
+    template <field F1, field F2, char V>
+    inline void set_dispatch(integral_constant<int, 1>)
+    {
+        base_type::template set<F1, F2, V>();
+    }
+    // else
+    template <field F1, field F2, char V>
+    inline void set_dispatch(integral_constant<int, 2>)
+    {}
+
+    // Interrupt && interrupt
+    template <field F1, field F2, char V>
+    inline void update_dispatch(integral_constant<int, 0>)
+    {
+        interrupt = true;
+    }
+    // else should_handle
+    template <field F1, field F2, char V>
+    inline void update_dispatch(integral_constant<int, 1>)
+    {
+        base_type::template update<F1, F2, V>();
+    }
+    // else
+    template <field F1, field F2, char V>
+    inline void update_dispatch(integral_constant<int, 2>)
+    {}
+};
+
+// --------------- UTIL FUNCTIONS ----------------
+
+// set
+
+template <field F1, field F2, char V, typename Result>
+inline void set(Result & res)
+{
+    res.template set<F1, F2, V>();
+}
+
+template <field F1, field F2, char V, bool Transpose>
+struct set_dispatch
+{
+    template <typename Result>
+    static inline void apply(Result & res)
+    {
+        res.template set<F1, F2, V>();
+    }
+};
+
+template <field F1, field F2, char V>
+struct set_dispatch<F1, F2, V, true>
+{
+    template <typename Result>
+    static inline void apply(Result & res)
+    {
+        res.template set<F2, F1, V>();
+    }
+};
+
+template <field F1, field F2, char V, bool Transpose, typename Result>
+inline void set(Result & res)
+{
+    set_dispatch<F1, F2, V, Transpose>::apply(res);
+}
+
+// update
+
+template <field F1, field F2, char D, typename Result>
+inline void update(Result & res)
+{
+    res.template update<F1, F2, D>();
+}
+
+template <field F1, field F2, char D, bool Transpose>
+struct update_result_dispatch
+{
+    template <typename Result>
+    static inline void apply(Result & res)
+    {
+        update<F1, F2, D>(res);
+    }
+};
+
+template <field F1, field F2, char D>
+struct update_result_dispatch<F1, F2, D, true>
+{
+    template <typename Result>
+    static inline void apply(Result & res)
+    {
+        update<F2, F1, D>(res);
+    }
+};
+
+template <field F1, field F2, char D, bool Transpose, typename Result>
+inline void update(Result & res)
+{
+    update_result_dispatch<F1, F2, D, Transpose>::apply(res);
+}
+
+// may_update
+
+template <field F1, field F2, char D, typename Result>
+inline bool may_update(Result const& res)
+{
+    return res.template may_update<F1, F2, D>();
+}
+
+template <field F1, field F2, char D, bool Transpose>
+struct may_update_result_dispatch
+{
+    template <typename Result>
+    static inline bool apply(Result const& res)
+    {
+        return may_update<F1, F2, D>(res);
+    }
+};
+
+template <field F1, field F2, char D>
+struct may_update_result_dispatch<F1, F2, D, true>
+{
+    template <typename Result>
+    static inline bool apply(Result const& res)
+    {
+        return may_update<F2, F1, D>(res);
+    }
+};
+
+template <field F1, field F2, char D, bool Transpose, typename Result>
+inline bool may_update(Result const& res)
+{
+    return may_update_result_dispatch<F1, F2, D, Transpose>::apply(res);
+}
+
+// result_dimension
+
+template <typename Geometry>
+struct result_dimension
+{
+    BOOST_STATIC_ASSERT(geometry::dimension<Geometry>::value >= 0);
+    static const char value
+        = ( geometry::dimension<Geometry>::value <= 9 ) ?
+            ( '0' + geometry::dimension<Geometry>::value ) :
+              'T';
+};
+
+}} // namespace detail::relate
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_RESULT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/topology_check.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/topology_check.hpp
new file mode 100644
index 00000000000..654999d8fbd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/topology_check.hpp
@@ -0,0 +1,343 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_TOPOLOGY_CHECK_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_TOPOLOGY_CHECK_HPP
+
+
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+#include <boost/geometry/algorithms/detail/relate/less.hpp>
+
+#include <boost/geometry/util/has_nan_coordinate.hpp>
+#include <boost/geometry/util/range.hpp>
+
+
+namespace boost { namespace geometry {
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace relate {
+
+// TODO: change the name for e.g. something with the word "exterior"
+
+template <typename Geometry,
+          typename Tag = typename geometry::tag<Geometry>::type>
+struct topology_check
+    : not_implemented<Tag>
+{};
+
+//template <typename Point>
+//struct topology_check<Point, point_tag>
+//{
+//    static const char interior = '0';
+//    static const char boundary = 'F';
+//
+//    static const bool has_interior = true;
+//    static const bool has_boundary = false;
+//
+//    topology_check(Point const&) {}
+//    template <typename IgnoreBoundaryPoint>
+//    topology_check(Point const&, IgnoreBoundaryPoint const&) {}
+//};
+
+template <typename Linestring>
+struct topology_check<Linestring, linestring_tag>
+{
+    static const char interior = '1';
+    static const char boundary = '0';
+
+    topology_check(Linestring const& ls)
+        : m_ls(ls)
+        , m_is_initialized(false)
+    {}
+
+    bool has_interior() const
+    {
+        init();
+        return m_has_interior;
+    }
+
+    bool has_boundary() const
+    {
+        init();
+        return m_has_boundary;
+    }
+
+    /*template <typename Point>
+    bool check_boundary_point(Point const& point) const
+    {
+        init();
+        return m_has_boundary
+            && ( equals::equals_point_point(point, range::front(m_ls))
+              || equals::equals_point_point(point, range::back(m_ls)) );
+    }*/
+
+    template <typename Visitor>
+    void for_each_boundary_point(Visitor & visitor) const
+    {
+        init();
+        if (m_has_boundary)
+        {
+            if (visitor.apply(range::front(m_ls)))
+                visitor.apply(range::back(m_ls));
+        }
+    }
+
+private:
+    void init() const
+    {
+        if (m_is_initialized)
+            return;
+
+        std::size_t count = boost::size(m_ls);
+        m_has_interior = count > 0;
+        // NOTE: Linestring with all points equal is treated as 1d linear ring
+        m_has_boundary = count > 1
+                && ! detail::equals::equals_point_point(range::front(m_ls), range::back(m_ls));
+
+        m_is_initialized = true;
+    }
+
+    Linestring const& m_ls;
+    mutable bool m_is_initialized;
+
+    mutable bool m_has_interior;
+    mutable bool m_has_boundary;
+};
+
+template <typename MultiLinestring>
+struct topology_check<MultiLinestring, multi_linestring_tag>
+{
+    static const char interior = '1';
+    static const char boundary = '0';
+
+    topology_check(MultiLinestring const& mls)
+        : m_mls(mls)
+        , m_is_initialized(false)
+    {}
+
+    bool has_interior() const
+    {
+        init();
+        return m_has_interior;
+    }
+
+    bool has_boundary() const
+    {
+        init();
+        return m_has_boundary;
+    }
+
+    template <typename Point>
+    bool check_boundary_point(Point const& point) const
+    {
+        init();
+
+        if (! m_has_boundary)
+            return false;
+
+        std::size_t count = count_equal(m_endpoints.begin(), m_endpoints.end(), point);
+
+        return count % 2 != 0; // odd count -> boundary
+    }
+
+    template <typename Visitor>
+    void for_each_boundary_point(Visitor & visitor) const
+    {
+        init();
+        if (m_has_boundary)
+        {
+            for_each_boundary_point(m_endpoints.begin(), m_endpoints.end(), visitor);
+        }
+    }
+
+private:
+    void init() const
+    {
+        if (m_is_initialized)
+            return;
+
+        m_endpoints.reserve(boost::size(m_mls) * 2);
+
+        m_has_interior = false;
+
+        typedef typename boost::range_iterator<MultiLinestring const>::type ls_iterator;
+        for ( ls_iterator it = boost::begin(m_mls) ; it != boost::end(m_mls) ; ++it )
+        {
+            typename boost::range_reference<MultiLinestring const>::type
+                ls = *it;
+
+            std::size_t count = boost::size(ls);
+
+            if (count > 0)
+            {
+                m_has_interior = true;
+            }
+
+            if (count > 1)
+            {
+                typedef typename boost::range_reference
+                    <
+                        typename boost::range_value<MultiLinestring const>::type const
+                    >::type point_reference;
+                
+                point_reference front_pt = range::front(ls);
+                point_reference back_pt = range::back(ls);
+
+                // don't store boundaries of linear rings, this doesn't change anything
+                if (! equals::equals_point_point(front_pt, back_pt))
+                {
+                    // do not add points containing NaN coordinates
+                    // because they cannot be reasonably compared, e.g. with MSVC
+                    // an assertion failure is reported in std::equal_range()
+                    // NOTE: currently ignoring_counter calling std::equal_range()
+                    //   is not used anywhere in the code, still it's safer this way
+                    if (! geometry::has_nan_coordinate(front_pt))
+                    {
+                        m_endpoints.push_back(front_pt);
+                    }
+                    if (! geometry::has_nan_coordinate(back_pt))
+                    {
+                        m_endpoints.push_back(back_pt);
+                    }
+                }
+            }
+        }
+
+        m_has_boundary = false;
+
+        if (! m_endpoints.empty() )
+        {
+            std::sort(m_endpoints.begin(), m_endpoints.end(), relate::less());
+            m_has_boundary = find_odd_count(m_endpoints.begin(), m_endpoints.end());
+        }
+
+        m_is_initialized = true;
+    }
+
+    template <typename It, typename Point>
+    static inline std::size_t count_equal(It first, It last, Point const& point)
+    {
+        std::pair<It, It> rng = std::equal_range(first, last, point, relate::less());
+        return (std::size_t)std::distance(rng.first, rng.second);
+    }
+
+    template <typename It>
+    static inline bool find_odd_count(It first, It last)
+    {
+        interrupting_visitor visitor;
+        for_each_boundary_point(first, last, visitor);
+        return visitor.found;
+    }
+
+    struct interrupting_visitor
+    {
+        bool found;
+        interrupting_visitor() : found(false) {}
+        template <typename Point>
+        bool apply(Point const&)
+        {
+            found = true;
+            return false;
+        }
+    };
+
+    template <typename It, typename Visitor>
+    static void for_each_boundary_point(It first, It last, Visitor& visitor)
+    {
+        if ( first == last )
+            return;
+
+        std::size_t count = 1;
+        It prev = first;
+        ++first;
+        for ( ; first != last ; ++first, ++prev )
+        {
+            // the end of the equal points subrange
+            if ( ! equals::equals_point_point(*first, *prev) )
+            {
+                // odd count -> boundary
+                if ( count % 2 != 0 )
+                {
+                    if (! visitor.apply(*prev))
+                    {
+                        return;
+                    }
+                }
+
+                count = 1;
+            }
+            else
+            {
+                ++count;
+            }
+        }
+
+        // odd count -> boundary
+        if ( count % 2 != 0 )
+        {
+            visitor.apply(*prev);
+        }
+    }
+
+private:
+    MultiLinestring const& m_mls;
+    mutable bool m_is_initialized;
+
+    mutable bool m_has_interior;
+    mutable bool m_has_boundary;
+
+    typedef typename geometry::point_type<MultiLinestring>::type point_type;
+    mutable std::vector<point_type> m_endpoints;
+};
+
+template <typename Ring>
+struct topology_check<Ring, ring_tag>
+{
+    static const char interior = '2';
+    static const char boundary = '1';
+
+    topology_check(Ring const&) {}
+
+    static bool has_interior() { return true; }
+    static bool has_boundary() { return true; }
+};
+
+template <typename Polygon>
+struct topology_check<Polygon, polygon_tag>
+{
+    static const char interior = '2';
+    static const char boundary = '1';
+    
+    topology_check(Polygon const&) {}
+
+    static bool has_interior() { return true; }
+    static bool has_boundary() { return true; }
+};
+
+template <typename MultiPolygon>
+struct topology_check<MultiPolygon, multi_polygon_tag>
+{
+    static const char interior = '2';
+    static const char boundary = '1';
+    
+    topology_check(MultiPolygon const&) {}
+
+    static bool has_interior() { return true; }
+    static bool has_boundary() { return true; }
+    template <typename Point>
+    static bool check_boundary_point(Point const& ) { return true; }
+};
+
+}} // namespace detail::relate
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_TOPOLOGY_CHECK_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/turns.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/turns.hpp
new file mode 100644
index 00000000000..6fa05eaf212
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relate/turns.hpp
@@ -0,0 +1,307 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2013, 2014, 2015, 2017.
+// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_TURNS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_TURNS_HPP
+
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/algorithms/detail/overlay/do_reverse.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_turns.hpp>
+#include <boost/geometry/algorithms/detail/overlay/get_turn_info.hpp>
+
+#include <boost/geometry/policies/robustness/get_rescale_policy.hpp>
+#include <boost/geometry/policies/robustness/no_rescale_policy.hpp>
+
+#include <boost/type_traits/is_base_of.hpp>
+
+
+namespace boost { namespace geometry {
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace relate { namespace turns {
+
+template <bool IncludeDegenerate = false>
+struct assign_policy
+    : overlay::assign_null_policy
+{
+    static bool const include_degenerate = IncludeDegenerate;
+};
+
+// GET_TURNS
+
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename GetTurnPolicy = detail::get_turns::get_turn_info_type
+        <
+            Geometry1, Geometry2, assign_policy<>
+        >,
+    typename RobustPolicy = detail::no_rescale_policy
+>
+struct get_turns
+{
+    typedef typename geometry::point_type<Geometry1>::type point1_type;
+
+    typedef overlay::turn_info
+            <
+                point1_type,
+                typename segment_ratio_type<point1_type, RobustPolicy>::type,
+                typename detail::get_turns::turn_operation_type
+                    <
+                        Geometry1, Geometry2,
+                        typename segment_ratio_type
+                            <
+                                point1_type, RobustPolicy
+                            >::type
+                    >::type
+            > turn_info;
+
+    template <typename Turns>
+    static inline void apply(Turns & turns,
+                             Geometry1 const& geometry1,
+                             Geometry2 const& geometry2)
+    {
+        detail::get_turns::no_interrupt_policy interrupt_policy;
+
+        typename strategy::intersection::services::default_strategy
+            <
+                typename cs_tag<Geometry1>::type
+            >::type intersection_strategy;
+
+        apply(turns, geometry1, geometry2, interrupt_policy, intersection_strategy);
+    }
+
+    template <typename Turns, typename InterruptPolicy, typename IntersectionStrategy>
+    static inline void apply(Turns & turns,
+                             Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             InterruptPolicy & interrupt_policy,
+                             IntersectionStrategy const& intersection_strategy)
+    {
+        RobustPolicy robust_policy = geometry::get_rescale_policy
+            <
+                RobustPolicy
+            >(geometry1, geometry2);
+
+        apply(turns, geometry1, geometry2, interrupt_policy, intersection_strategy, robust_policy);
+    }
+
+    template <typename Turns, typename InterruptPolicy, typename IntersectionStrategy>
+    static inline void apply(Turns & turns,
+                             Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             InterruptPolicy & interrupt_policy,
+                             IntersectionStrategy const& intersection_strategy,
+                             RobustPolicy const& robust_policy)
+    {
+        static const bool reverse1 = detail::overlay::do_reverse
+            <
+                geometry::point_order<Geometry1>::value
+            >::value;
+
+        static const bool reverse2 = detail::overlay::do_reverse
+            <
+                geometry::point_order<Geometry2>::value
+            >::value;
+
+        dispatch::get_turns
+            <
+                typename geometry::tag<Geometry1>::type,
+                typename geometry::tag<Geometry2>::type,
+                Geometry1,
+                Geometry2,
+                reverse1,
+                reverse2,
+                GetTurnPolicy
+            >::apply(0, geometry1, 1, geometry2,
+                     intersection_strategy, robust_policy,
+                     turns, interrupt_policy);
+    }
+};
+
+// TURNS SORTING AND SEARCHING
+
+template <int N = 0, int U = 1, int I = 2, int B = 3, int C = 4, int O = 0>
+struct op_to_int
+{
+    template <typename Operation>
+    inline int operator()(Operation const& op) const
+    {
+        switch(op.operation)
+        {
+        case detail::overlay::operation_none : return N;
+        case detail::overlay::operation_union : return U;
+        case detail::overlay::operation_intersection : return I;
+        case detail::overlay::operation_blocked : return B;
+        case detail::overlay::operation_continue : return C;
+        case detail::overlay::operation_opposite : return O;
+        }
+        return -1;
+    }
+};
+
+template <std::size_t OpId, typename OpToInt>
+struct less_op_xxx_linear
+{
+    template <typename Turn>
+    inline bool operator()(Turn const& left, Turn const& right) const
+    {
+        static OpToInt op_to_int;
+        return op_to_int(left.operations[OpId]) < op_to_int(right.operations[OpId]);
+    }
+};
+
+template <std::size_t OpId>
+struct less_op_linear_linear
+    : less_op_xxx_linear< OpId, op_to_int<0,2,3,1,4,0> >
+{};
+
+template <std::size_t OpId>
+struct less_op_linear_areal_single
+{
+    template <typename Turn>
+    inline bool operator()(Turn const& left, Turn const& right) const
+    {
+        static const std::size_t other_op_id = (OpId + 1) % 2;
+        static turns::op_to_int<0,2,3,1,4,0> op_to_int_xuic;
+        static turns::op_to_int<0,3,2,1,4,0> op_to_int_xiuc;
+
+        segment_identifier const& left_other_seg_id = left.operations[other_op_id].seg_id;
+        segment_identifier const& right_other_seg_id = right.operations[other_op_id].seg_id;
+
+        typedef typename Turn::turn_operation_type operation_type;
+        operation_type const& left_operation = left.operations[OpId];
+        operation_type const& right_operation = right.operations[OpId];
+
+        if ( left_other_seg_id.ring_index == right_other_seg_id.ring_index )
+        {
+            return op_to_int_xuic(left_operation)
+                 < op_to_int_xuic(right_operation);
+        }
+        else
+        {
+            return op_to_int_xiuc(left_operation)
+                 < op_to_int_xiuc(right_operation);
+        }
+    }
+};
+
+template <std::size_t OpId>
+struct less_op_areal_linear
+    : less_op_xxx_linear< OpId, op_to_int<0,1,0,0,2,0> >
+{};
+
+template <std::size_t OpId>
+struct less_op_areal_areal
+{
+    template <typename Turn>
+    inline bool operator()(Turn const& left, Turn const& right) const
+    {
+        static const std::size_t other_op_id = (OpId + 1) % 2;
+        static op_to_int<0, 1, 2, 3, 4, 0> op_to_int_uixc;
+        static op_to_int<0, 2, 1, 3, 4, 0> op_to_int_iuxc;
+
+        segment_identifier const& left_other_seg_id = left.operations[other_op_id].seg_id;
+        segment_identifier const& right_other_seg_id = right.operations[other_op_id].seg_id;
+
+        typedef typename Turn::turn_operation_type operation_type;
+        operation_type const& left_operation = left.operations[OpId];
+        operation_type const& right_operation = right.operations[OpId];
+
+        if ( left_other_seg_id.multi_index == right_other_seg_id.multi_index )
+        {
+            if ( left_other_seg_id.ring_index == right_other_seg_id.ring_index )
+            {
+                return op_to_int_uixc(left_operation) < op_to_int_uixc(right_operation);
+            }
+            else
+            {
+                if ( left_other_seg_id.ring_index == -1 )
+                {
+                    if ( left_operation.operation == overlay::operation_union )
+                        return false;
+                    else if ( left_operation.operation == overlay::operation_intersection )
+                        return true;
+                }
+                else if ( right_other_seg_id.ring_index == -1 )
+                {
+                    if ( right_operation.operation == overlay::operation_union )
+                        return true;
+                    else if ( right_operation.operation == overlay::operation_intersection )
+                        return false;
+                }
+                
+                return op_to_int_iuxc(left_operation) < op_to_int_iuxc(right_operation);
+            }
+        }
+        else
+        {
+            return op_to_int_uixc(left_operation) < op_to_int_uixc(right_operation);
+        }
+    }
+};
+
+template <std::size_t OpId>
+struct less_other_multi_index
+{
+    static const std::size_t other_op_id = (OpId + 1) % 2;
+
+    template <typename Turn>
+    inline bool operator()(Turn const& left, Turn const& right) const
+    {
+        return left.operations[other_op_id].seg_id.multi_index
+             < right.operations[other_op_id].seg_id.multi_index;
+    }
+};
+
+// sort turns by G1 - source_index == 0 by:
+// seg_id -> distance -> operation
+template <std::size_t OpId = 0,
+          typename LessOp = less_op_xxx_linear< OpId, op_to_int<> > >
+struct less
+{
+    BOOST_STATIC_ASSERT(OpId < 2);
+
+    template <typename Turn>
+    static inline bool use_fraction(Turn const& left, Turn const& right)
+    {
+        static LessOp less_op;
+
+        return
+            geometry::math::equals(left.operations[OpId].fraction,
+                                   right.operations[OpId].fraction)
+            ?
+            less_op(left, right)
+            :
+            (left.operations[OpId].fraction < right.operations[OpId].fraction)
+            ;
+    }
+
+    template <typename Turn>
+    inline bool operator()(Turn const& left, Turn const& right) const
+    {
+        segment_identifier const& sl = left.operations[OpId].seg_id;
+        segment_identifier const& sr = right.operations[OpId].seg_id;
+
+        return sl < sr || ( sl == sr && use_fraction(left, right) );
+    }
+};
+
+}}} // namespace detail::relate::turns
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_TURNS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relation/implementation.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relation/implementation.hpp
new file mode 100644
index 00000000000..b9a238d6c8c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relation/implementation.hpp
@@ -0,0 +1,18 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATION_IMPLEMENTATION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATION_IMPLEMENTATION_HPP
+
+
+#include <boost/geometry/algorithms/detail/relate/implementation.hpp>
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATION_IMPLEMENTATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relation/interface.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relation/interface.hpp
new file mode 100644
index 00000000000..83d27ed72ff
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/relation/interface.hpp
@@ -0,0 +1,219 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2013, 2014, 2015, 2017.
+// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATION_INTERFACE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATION_INTERFACE_HPP
+
+
+#include <boost/geometry/algorithms/detail/relate/interface.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace relate
+{
+
+template <typename Geometry1, typename Geometry2>
+struct result_handler_type<Geometry1, Geometry2, geometry::de9im::matrix, false>
+{
+    typedef matrix_handler<geometry::de9im::matrix> type;
+};
+
+
+}} // namespace detail::relate
+#endif // DOXYGEN_NO_DETAIL
+
+namespace resolve_variant
+{
+
+template <typename Geometry1, typename Geometry2>
+struct relation
+{
+    template <typename Matrix, typename Strategy>
+    static inline Matrix apply(Geometry1 const& geometry1,
+                               Geometry2 const& geometry2,
+                               Strategy const& strategy)
+    {
+        concepts::check<Geometry1 const>();
+        concepts::check<Geometry2 const>();
+        assert_dimension_equal<Geometry1, Geometry2>();
+
+        typename detail::relate::result_handler_type
+            <
+                Geometry1,
+                Geometry2,
+                Matrix
+            >::type handler;
+
+        resolve_strategy::relate::apply(geometry1, geometry2, handler, strategy);
+
+        return handler.result();
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
+struct relation<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
+{
+    template <typename Matrix, typename Strategy>
+    struct visitor : boost::static_visitor<Matrix>
+    {
+        Geometry2 const& m_geometry2;
+        Strategy const& m_strategy;
+
+        visitor(Geometry2 const& geometry2, Strategy const& strategy)
+            : m_geometry2(geometry2), m_strategy(strategy) {}
+
+        template <typename Geometry1>
+        Matrix operator()(Geometry1 const& geometry1) const
+        {
+            return relation<Geometry1, Geometry2>
+                   ::template apply<Matrix>(geometry1, m_geometry2, m_strategy);
+        }
+    };
+
+    template <typename Matrix, typename Strategy>
+    static inline Matrix
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
+          Geometry2 const& geometry2,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Matrix, Strategy>(geometry2, strategy), geometry1);
+    }
+};
+
+template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct relation<Geometry1, boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Matrix, typename Strategy>
+    struct visitor : boost::static_visitor<Matrix>
+    {
+        Geometry1 const& m_geometry1;
+        Strategy const& m_strategy;
+
+        visitor(Geometry1 const& geometry1, Strategy const& strategy)
+            : m_geometry1(geometry1), m_strategy(strategy) {}
+
+        template <typename Geometry2>
+        Matrix operator()(Geometry2 const& geometry2) const
+        {
+            return relation<Geometry1, Geometry2>
+                   ::template apply<Matrix>(m_geometry1, geometry2, m_strategy);
+        }
+    };
+
+    template <typename Matrix, typename Strategy>
+    static inline Matrix
+    apply(Geometry1 const& geometry1,
+          boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Matrix, Strategy>(geometry1, strategy), geometry2);
+    }
+};
+
+template
+<
+    BOOST_VARIANT_ENUM_PARAMS(typename T1),
+    BOOST_VARIANT_ENUM_PARAMS(typename T2)
+>
+struct relation
+    <
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)>,
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)>
+    >
+{
+    template <typename Matrix, typename Strategy>
+    struct visitor : boost::static_visitor<Matrix>
+    {
+        Strategy const& m_strategy;
+
+        visitor(Strategy const& strategy)
+            : m_strategy(strategy) {}
+
+        template <typename Geometry1, typename Geometry2>
+        Matrix operator()(Geometry1 const& geometry1,
+                          Geometry2 const& geometry2) const
+        {
+            return relation<Geometry1, Geometry2>
+                   ::template apply<Matrix>(geometry1, geometry2, m_strategy);
+        }
+    };
+
+    template <typename Matrix, typename Strategy>
+    static inline Matrix
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)> const& geometry1,
+          boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Matrix, Strategy>(strategy), geometry1, geometry2);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief Calculates the relation between a pair of geometries as defined in DE-9IM.
+\ingroup relation
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Strategy \tparam_strategy{Relation}
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param strategy \param_strategy{relation}
+\return The DE-9IM matrix expressing the relation between geometries.
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/relation.qbk]}
+ */
+template <typename Geometry1, typename Geometry2, typename Strategy>
+inline de9im::matrix relation(Geometry1 const& geometry1,
+                              Geometry2 const& geometry2,
+                              Strategy const& strategy)
+{
+    return resolve_variant::relation
+        <
+            Geometry1,
+            Geometry2
+        >::template apply<de9im::matrix>(geometry1, geometry2, strategy);
+}
+
+
+/*!
+\brief Calculates the relation between a pair of geometries as defined in DE-9IM.
+\ingroup relation
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\return The DE-9IM matrix expressing the relation between geometries.
+
+\qbk{[include reference/algorithms/relation.qbk]}
+ */
+template <typename Geometry1, typename Geometry2>
+inline de9im::matrix relation(Geometry1 const& geometry1,
+                              Geometry2 const& geometry2)
+{
+    return resolve_variant::relation
+        <
+            Geometry1,
+            Geometry2
+        >::template apply<de9im::matrix>(geometry1, geometry2, default_strategy());
+}
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RELATE_INTERFACE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/ring_identifier.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/ring_identifier.hpp
new file mode 100644
index 00000000000..4a7e717cf78
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/ring_identifier.hpp
@@ -0,0 +1,85 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_RING_IDENTIFIER_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_RING_IDENTIFIER_HPP
+
+
+#if defined(BOOST_GEOMETRY_DEBUG_IDENTIFIER)
+#include <iostream>
+#endif
+
+
+#include <boost/geometry/algorithms/detail/signed_size_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+// Ring Identifier. It is currently: source,multi,ring
+struct ring_identifier
+{
+
+    inline ring_identifier()
+        : source_index(-1)
+        , multi_index(-1)
+        , ring_index(-1)
+    {}
+
+    inline ring_identifier(signed_size_type src,
+                           signed_size_type mul,
+                           signed_size_type rin)
+        : source_index(src)
+        , multi_index(mul)
+        , ring_index(rin)
+    {}
+
+    inline bool operator<(ring_identifier const& other) const
+    {
+        return source_index != other.source_index ? source_index < other.source_index
+            : multi_index !=other.multi_index ? multi_index < other.multi_index
+            : ring_index < other.ring_index
+            ;
+    }
+
+    inline bool operator==(ring_identifier const& other) const
+    {
+        return source_index == other.source_index
+            && ring_index == other.ring_index
+            && multi_index == other.multi_index
+            ;
+    }
+
+    inline bool operator!=(ring_identifier const& other) const
+    {
+        return ! operator==(other);
+    }
+
+#if defined(BOOST_GEOMETRY_DEBUG_IDENTIFIER)
+    friend std::ostream& operator<<(std::ostream &os, ring_identifier const& ring_id)
+    {
+        os << "(s:" << ring_id.source_index;
+        if (ring_id.ring_index >= 0) os << ", r:" << ring_id.ring_index;
+        if (ring_id.multi_index >= 0) os << ", m:" << ring_id.multi_index;
+        os << ")";
+        return os;
+    }
+#endif
+
+
+    signed_size_type source_index;
+    signed_size_type multi_index;
+    signed_size_type ring_index;
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_RING_IDENTIFIER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sections/range_by_section.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sections/range_by_section.hpp
new file mode 100644
index 00000000000..611ad172d27
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sections/range_by_section.hpp
@@ -0,0 +1,193 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2013, 2014.
+// Modifications copyright (c) 2013, 2014, Oracle and/or its affiliates.
+
+// 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)
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_SECTIONS_RANGE_BY_SECTION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_SECTIONS_RANGE_BY_SECTION_HPP
+
+#include <boost/mpl/assert.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/util/range.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace section
+{
+
+
+template <typename Range, typename Section>
+struct full_section_range
+{
+    static inline Range const& apply(Range const& range, Section const& )
+    {
+        return range;
+    }
+};
+
+
+template <typename Polygon, typename Section>
+struct full_section_polygon
+{
+    static inline typename ring_return_type<Polygon const>::type apply(Polygon const& polygon, Section const& section)
+    {
+        return section.ring_id.ring_index < 0
+            ? geometry::exterior_ring(polygon)
+            : range::at(geometry::interior_rings(polygon),
+                        static_cast<std::size_t>(section.ring_id.ring_index));
+    }
+};
+
+
+template
+<
+    typename MultiGeometry,
+    typename Section,
+    typename Policy
+>
+struct full_section_multi
+{
+    static inline typename ring_return_type<MultiGeometry const>::type apply(
+                MultiGeometry const& multi, Section const& section)
+    {
+        typedef typename boost::range_size<MultiGeometry>::type size_type;
+
+        BOOST_GEOMETRY_ASSERT
+            (
+                section.ring_id.multi_index >= 0
+                && size_type(section.ring_id.multi_index) < boost::size(multi)
+            );
+
+        return Policy::apply(range::at(multi, size_type(section.ring_id.multi_index)), section);
+    }
+};
+
+
+}} // namespace detail::section
+#endif
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template
+<
+    typename Tag,
+    typename Geometry,
+    typename Section
+>
+struct range_by_section
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_OR_NOT_YET_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
+            , (types<Geometry>)
+        );
+};
+
+
+template <typename LineString, typename Section>
+struct range_by_section<linestring_tag, LineString, Section>
+    : detail::section::full_section_range<LineString, Section>
+{};
+
+
+template <typename Ring, typename Section>
+struct range_by_section<ring_tag, Ring, Section>
+    : detail::section::full_section_range<Ring, Section>
+{};
+
+
+template <typename Polygon, typename Section>
+struct range_by_section<polygon_tag, Polygon, Section>
+    : detail::section::full_section_polygon<Polygon, Section>
+{};
+
+
+template <typename MultiPolygon, typename Section>
+struct range_by_section<multi_polygon_tag, MultiPolygon, Section>
+    : detail::section::full_section_multi
+        <
+            MultiPolygon,
+            Section,
+            detail::section::full_section_polygon
+                <
+                    typename boost::range_value<MultiPolygon>::type,
+                    Section
+                >
+       >
+{};
+
+template <typename MultiLinestring, typename Section>
+struct range_by_section<multi_linestring_tag, MultiLinestring, Section>
+    : detail::section::full_section_multi
+        <
+            MultiLinestring,
+            Section,
+            detail::section::full_section_range
+                <
+                    typename boost::range_value<MultiLinestring>::type,
+                    Section
+                >
+       >
+{};
+
+
+} // namespace dispatch
+#endif
+
+
+/*!
+    \brief Get full ring (exterior, one of interiors, one from multi)
+        indicated by the specified section
+    \ingroup sectionalize
+    \tparam Geometry type
+    \tparam Section type of section to get from
+    \param geometry geometry to take section of
+    \param section structure with section
+ */
+template <typename Geometry, typename Section>
+inline typename ring_return_type<Geometry const>::type
+            range_by_section(Geometry const& geometry, Section const& section)
+{
+    concepts::check<Geometry const>();
+
+    return dispatch::range_by_section
+        <
+            typename tag<Geometry>::type,
+            Geometry,
+            Section
+        >::apply(geometry, section);
+}
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_SECTIONS_RANGE_BY_SECTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sections/section_box_policies.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sections/section_box_policies.hpp
new file mode 100644
index 00000000000..cf06700306c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sections/section_box_policies.hpp
@@ -0,0 +1,49 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_SECTIONS_SECTION_BOX_POLICIES_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_SECTIONS_SECTION_BOX_POLICIES_HPP
+
+
+#include <boost/geometry/algorithms/detail/disjoint/box_box.hpp>
+#include <boost/geometry/algorithms/expand.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace section
+{
+
+struct get_section_box
+{
+    template <typename Box, typename Section>
+    static inline void apply(Box& total, Section const& section)
+    {
+        geometry::expand(total, section.bounding_box);
+    }
+};
+
+struct overlaps_section_box
+{
+    template <typename Box, typename Section>
+    static inline bool apply(Box const& box, Section const& section)
+    {
+        return ! detail::disjoint::disjoint_box_box(box, section.bounding_box);
+    }
+};
+
+
+}} // namespace detail::section
+#endif
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_SECTIONS_SECTION_BOX_POLICIES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sections/section_functions.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sections/section_functions.hpp
new file mode 100644
index 00000000000..67df3060c46
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sections/section_functions.hpp
@@ -0,0 +1,139 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2015, 2017.
+// Modifications copyright (c) 2015-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_SECTIONS_FUNCTIONS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_SECTIONS_FUNCTIONS_HPP
+
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/algorithms/detail/recalculate.hpp>
+#include <boost/geometry/policies/robustness/robust_point_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace section
+{
+
+template
+<
+    std::size_t Dimension,
+    typename Geometry,
+    typename CastedCSTag = typename tag_cast
+                            <
+                                typename cs_tag<Geometry>::type,
+                                spherical_tag
+                            >::type
+>
+struct preceding_check
+{
+    template <typename Point, typename Box>
+    static inline bool apply(int dir, Point const& point, Box const& /*point_box*/, Box const& other_box)
+    {
+        return (dir == 1  && get<Dimension>(point) < get<min_corner, Dimension>(other_box))
+            || (dir == -1 && get<Dimension>(point) > get<max_corner, Dimension>(other_box));
+    }
+};
+
+template <typename Geometry>
+struct preceding_check<0, Geometry, spherical_tag>
+{
+    template <typename Point, typename Box>
+    static inline bool apply(int dir, Point const& point, Box const& point_box, Box const& other_box)
+    {
+        typedef typename select_coordinate_type
+            <
+                Point, Box
+            >::type calc_t;
+        typedef typename coordinate_system<Point>::type::units units_t;
+
+        calc_t const c0 = 0;
+
+        if (dir == 1)
+        {
+            calc_t const diff_min = math::longitude_distance_signed
+                                        <
+                                            units_t, calc_t
+                                        >(get<min_corner, 0>(other_box), get<0>(point));
+
+            calc_t const diff_min_min = math::longitude_distance_signed
+                                        <
+                                            units_t, calc_t
+                                        >(get<min_corner, 0>(other_box), get<min_corner, 0>(point_box));
+
+            return diff_min < c0 && diff_min_min <= c0 && diff_min_min <= diff_min;
+        }
+        else if (dir == -1)
+        {
+            calc_t const diff_max = math::longitude_distance_signed
+                                        <
+                                            units_t, calc_t
+                                        >(get<max_corner, 0>(other_box), get<0>(point));
+
+            calc_t const diff_max_max = math::longitude_distance_signed
+                                        <
+                                            units_t, calc_t
+                                        >(get<max_corner, 0>(other_box), get<max_corner, 0>(point_box));
+
+            return diff_max > c0 && diff_max_max >= c0 && diff_max <= diff_max_max;
+        }
+
+        return false;
+    }
+};
+
+
+template
+<
+    std::size_t Dimension,
+    typename Point,
+    typename RobustBox,
+    typename RobustPolicy
+>
+static inline bool preceding(int dir,
+                             Point const& point,
+                             RobustBox const& point_robust_box,
+                             RobustBox const& other_robust_box,
+                             RobustPolicy const& robust_policy)
+{
+    typename geometry::robust_point_type<Point, RobustPolicy>::type robust_point;
+    geometry::recalculate(robust_point, point, robust_policy);
+    return preceding_check<Dimension, Point>::apply(dir, robust_point, point_robust_box, other_robust_box);
+}
+
+template
+<
+    std::size_t Dimension,
+    typename Point,
+    typename RobustBox,
+    typename RobustPolicy
+>
+static inline bool exceeding(int dir,
+                             Point const& point,
+                             RobustBox const& point_robust_box,
+                             RobustBox const& other_robust_box,
+                             RobustPolicy const& robust_policy)
+{
+    return preceding<Dimension>(-dir, point, point_robust_box, other_robust_box, robust_policy);
+}
+
+
+}} // namespace detail::section
+#endif
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_SECTIONS_FUNCTIONS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sections/sectionalize.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sections/sectionalize.hpp
new file mode 100644
index 00000000000..f1d8e7d2315
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sections/sectionalize.hpp
@@ -0,0 +1,999 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013, 2014, 2015, 2017.
+// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_SECTIONS_SECTIONALIZE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_SECTIONS_SECTIONALIZE_HPP
+
+#include <cstddef>
+#include <vector>
+
+#include <boost/concept/requires.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/vector_c.hpp>
+#include <boost/range.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_fundamental.hpp>
+
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/algorithms/envelope.hpp>
+#include <boost/geometry/algorithms/expand.hpp>
+
+#include <boost/geometry/algorithms/detail/interior_iterator.hpp>
+#include <boost/geometry/algorithms/detail/recalculate.hpp>
+#include <boost/geometry/algorithms/detail/ring_identifier.hpp>
+#include <boost/geometry/algorithms/detail/signed_size_type.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/point_order.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/policies/robustness/no_rescale_policy.hpp>
+#include <boost/geometry/policies/robustness/robust_point_type.hpp>
+#include <boost/geometry/views/closeable_view.hpp>
+#include <boost/geometry/views/reversible_view.hpp>
+#include <boost/geometry/geometries/segment.hpp>
+
+#include <boost/geometry/algorithms/detail/expand_by_epsilon.hpp>
+#include <boost/geometry/strategies/envelope.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+/*!
+    \brief Structure containing section information
+    \details Section information consists of a bounding box, direction
+        information (if it is increasing or decreasing, per dimension),
+        index information (begin-end, ring, multi) and the number of
+        segments in this section
+
+    \tparam Box box-type
+    \tparam DimensionCount number of dimensions for this section
+    \ingroup sectionalize
+ */
+template
+<
+    typename Box,
+    std::size_t DimensionCount
+>
+struct section
+{
+    typedef Box box_type;
+    static std::size_t const dimension_count = DimensionCount;
+
+    int directions[DimensionCount];
+    ring_identifier ring_id;
+    Box bounding_box;
+
+    // NOTE: size_type could be passed as template parameter
+    // NOTE: these probably also could be of type std::size_t
+    signed_size_type begin_index;
+    signed_size_type end_index;
+    std::size_t count;
+    std::size_t range_count;
+    bool duplicate;
+    signed_size_type non_duplicate_index;
+
+    bool is_non_duplicate_first;
+    bool is_non_duplicate_last;
+
+    inline section()
+        : begin_index(-1)
+        , end_index(-1)
+        , count(0)
+        , range_count(0)
+        , duplicate(false)
+        , non_duplicate_index(-1)
+        , is_non_duplicate_first(false)
+        , is_non_duplicate_last(false)
+    {
+        assign_inverse(bounding_box);
+        for (std::size_t i = 0; i < DimensionCount; i++)
+        {
+            directions[i] = 0;
+        }
+    }
+};
+
+
+/*!
+    \brief Structure containing a collection of sections
+    \note Derived from a vector, proves to be faster than of deque
+    \note vector might be templated in the future
+    \ingroup sectionalize
+ */
+template <typename Box, std::size_t DimensionCount>
+struct sections : std::vector<section<Box, DimensionCount> >
+{
+    typedef Box box_type;
+    static std::size_t const value = DimensionCount;
+};
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace sectionalize
+{
+
+// NOTE: This utility will NOT work for latitudes, dimension 1 in spherical
+// and geographic coordinate system because in these coordinate systems
+// e.g. a segment on northern hemisphere may go towards greater latitude
+// and then towards lesser latitude.
+template
+<
+    typename Point,
+    typename DimensionVector,
+    std::size_t Index,
+    std::size_t Count,
+    typename CastedCSTag = typename tag_cast
+                            <
+                                typename cs_tag<Point>::type,
+                                spherical_tag
+                            >::type
+>
+struct get_direction_loop
+{
+    typedef typename boost::mpl::at_c<DimensionVector, Index>::type dimension;
+
+    template <typename Segment>
+    static inline void apply(Segment const& seg,
+                int directions[Count])
+    {
+        typedef typename coordinate_type<Segment>::type coordinate_type;
+
+        coordinate_type const diff =
+            geometry::get<1, dimension::value>(seg)
+          - geometry::get<0, dimension::value>(seg);
+
+        coordinate_type zero = coordinate_type();
+        directions[Index] = diff > zero ? 1 : diff < zero ? -1 : 0;
+
+        get_direction_loop
+        <
+            Point,
+            DimensionVector,
+            Index + 1,
+            Count,
+            CastedCSTag
+        >::apply(seg, directions);
+    }
+};
+
+template
+<
+    typename Point,
+    typename DimensionVector,
+    std::size_t Count
+>
+struct get_direction_loop<Point, DimensionVector, 0, Count, spherical_tag>
+{
+    typedef typename boost::mpl::at_c<DimensionVector, 0>::type dimension;
+
+    template <typename Segment>
+    static inline void apply(Segment const& seg,
+                int directions[Count])
+    {
+        typedef typename coordinate_type<Segment>::type coordinate_type;
+        typedef typename coordinate_system<Point>::type::units units_t;
+
+        coordinate_type const diff = math::longitude_distance_signed
+                                        <
+                                            units_t, coordinate_type
+                                        >(geometry::get<0, 0>(seg),
+                                          geometry::get<1, 0>(seg));
+
+        coordinate_type zero = coordinate_type();
+        directions[0] = diff > zero ? 1 : diff < zero ? -1 : 0;
+
+        get_direction_loop
+        <
+            Point,
+            DimensionVector,
+            1,
+            Count,
+            spherical_tag
+        >::apply(seg, directions);
+    }
+};
+
+template
+<
+    typename Point,
+    typename DimensionVector,
+    std::size_t Count,
+    typename CastedCSTag
+>
+struct get_direction_loop<Point, DimensionVector, Count, Count, CastedCSTag>
+{
+    template <typename Segment>
+    static inline void apply(Segment const&, int [Count])
+    {}
+};
+
+
+//! Copy one static array to another
+template <typename T, std::size_t Index, std::size_t Count>
+struct copy_loop
+{
+    static inline void apply(T const source[Count], T target[Count])
+    {
+        target[Index] = source[Index];
+        copy_loop<T, Index + 1, Count>::apply(source, target);
+    }
+};
+
+template <typename T, std::size_t Count>
+struct copy_loop<T, Count, Count>
+{
+    static inline void apply(T const [Count], T [Count])
+    {}
+};
+
+//! Compare two static arrays
+template <typename T, std::size_t Index, std::size_t Count>
+struct compare_loop
+{
+    static inline bool apply(T const array1[Count], T const array2[Count])
+    {
+        return array1[Index] != array2[Index]
+            ? false
+            : compare_loop
+                <
+                    T, Index + 1, Count
+                >::apply(array1, array2);
+    }
+};
+
+template <typename T, std::size_t Count>
+struct compare_loop<T, Count, Count>
+{
+    static inline bool apply(T const [Count], T const [Count])
+    {
+
+        return true;
+    }
+};
+
+
+template <std::size_t Dimension, std::size_t DimensionCount>
+struct check_duplicate_loop
+{
+    template <typename Segment>
+    static inline bool apply(Segment const& seg)
+    {
+        if (! geometry::math::equals
+                (
+                    geometry::get<0, Dimension>(seg),
+                    geometry::get<1, Dimension>(seg)
+                )
+            )
+        {
+            return false;
+        }
+
+        return check_duplicate_loop
+        <
+                Dimension + 1, DimensionCount
+        >::apply(seg);
+    }
+};
+
+template <std::size_t DimensionCount>
+struct check_duplicate_loop<DimensionCount, DimensionCount>
+{
+    template <typename Segment>
+    static inline bool apply(Segment const&)
+    {
+        return true;
+    }
+};
+
+//! Assign a value to a static array
+template <typename T, std::size_t Index, std::size_t Count>
+struct assign_loop
+{
+    static inline void apply(T dims[Count], T const value)
+    {
+        dims[Index] = value;
+        assign_loop<T, Index + 1, Count>::apply(dims, value);
+    }
+};
+
+template <typename T, std::size_t Count>
+struct assign_loop<T, Count, Count>
+{
+    static inline void apply(T [Count], T const)
+    {
+    }
+};
+
+template <typename CSTag>
+struct box_first_in_section
+{
+    template <typename Box, typename Point, typename Strategy>
+    static inline void apply(Box & box, Point const& prev, Point const& curr,
+                             Strategy const& strategy)
+    {
+        geometry::model::referring_segment<Point const> seg(prev, curr);
+        geometry::envelope(seg, box, strategy);
+    }
+};
+
+template <>
+struct box_first_in_section<cartesian_tag>
+{
+    template <typename Box, typename Point, typename Strategy>
+    static inline void apply(Box & box, Point const& prev, Point const& curr,
+                             Strategy const& )
+    {
+        geometry::envelope(prev, box);
+        geometry::expand(box, curr);
+    }
+};
+
+template <typename CSTag>
+struct box_next_in_section
+{
+    template <typename Box, typename Point, typename Strategy>
+    static inline void apply(Box & box, Point const& prev, Point const& curr,
+                             Strategy const& strategy)
+    {
+        geometry::model::referring_segment<Point const> seg(prev, curr);
+        geometry::expand(box, seg, strategy);
+    }
+};
+
+template <>
+struct box_next_in_section<cartesian_tag>
+{
+    template <typename Box, typename Point, typename Strategy>
+    static inline void apply(Box & box, Point const& , Point const& curr,
+                             Strategy const& )
+    {
+        geometry::expand(box, curr);
+    }
+};
+
+/// @brief Helper class to create sections of a part of a range, on the fly
+template
+<
+    typename Point,
+    typename DimensionVector
+>
+struct sectionalize_part
+{
+    static const std::size_t dimension_count
+        = boost::mpl::size<DimensionVector>::value;
+
+    template
+    <
+        typename Iterator,
+        typename RobustPolicy,
+        typename Sections
+    >
+    static inline void apply(Sections& sections,
+                             Iterator begin, Iterator end,
+                             RobustPolicy const& robust_policy,
+                             ring_identifier ring_id,
+                             std::size_t max_count)
+    {
+        typedef typename strategy::envelope::services::default_strategy
+            <
+                typename cs_tag<typename Sections::box_type>::type
+            >::type envelope_strategy_type;
+
+        apply(sections, begin, end,
+              robust_policy, envelope_strategy_type(),
+              ring_id, max_count);
+    }
+
+    template
+    <
+        typename Iterator,
+        typename RobustPolicy,
+        typename Sections,
+        typename EnvelopeStrategy
+    >
+    static inline void apply(Sections& sections,
+                             Iterator begin, Iterator end,
+                             RobustPolicy const& robust_policy,
+                             EnvelopeStrategy const& strategy,
+                             ring_identifier ring_id,
+                             std::size_t max_count)
+    {
+        boost::ignore_unused_variable_warning(robust_policy);
+
+        typedef typename boost::range_value<Sections>::type section_type;
+        BOOST_STATIC_ASSERT
+            (
+                (static_cast<std::size_t>(section_type::dimension_count)
+                 == static_cast<std::size_t>(boost::mpl::size<DimensionVector>::value))
+            );
+
+        typedef typename geometry::robust_point_type
+        <
+            Point,
+            RobustPolicy
+        >::type robust_point_type;
+
+        std::size_t const count = std::distance(begin, end);
+        if (count == 0)
+        {
+            return;
+        }
+
+        signed_size_type index = 0;
+        signed_size_type ndi = 0; // non duplicate index
+        section_type section;
+
+        bool mark_first_non_duplicated = true;
+        std::size_t last_non_duplicate_index = sections.size();
+
+        Iterator it = begin;
+        robust_point_type previous_robust_point;
+        geometry::recalculate(previous_robust_point, *it, robust_policy);
+        
+        for(Iterator previous = it++;
+            it != end;
+            ++previous, ++it, index++)
+        {
+            robust_point_type current_robust_point;
+            geometry::recalculate(current_robust_point, *it, robust_policy);
+            model::referring_segment<robust_point_type> robust_segment(
+                    previous_robust_point, current_robust_point);
+
+            int direction_classes[dimension_count] = {0};
+            get_direction_loop
+            <
+                Point, DimensionVector, 0, dimension_count
+            >::apply(robust_segment, direction_classes);
+
+            // if "dir" == 0 for all point-dimensions, it is duplicate.
+            // Those sections might be omitted, if wished, lateron
+            bool duplicate = false;
+
+            if (direction_classes[0] == 0)
+            {
+                // Recheck because ALL dimensions should be checked,
+                // not only first one.
+                // (dimension_count might be < dimension<P>::value)
+                if (check_duplicate_loop
+                    <
+                        0, geometry::dimension<Point>::type::value
+                    >::apply(robust_segment)
+                    )
+                {
+                    duplicate = true;
+
+                    // Change direction-info to force new section
+                    // Note that wo consecutive duplicate segments will generate
+                    // only one duplicate-section.
+                    // Actual value is not important as long as it is not -1,0,1
+                    assign_loop
+                    <
+                        int, 0, dimension_count
+                    >::apply(direction_classes, -99);
+                }
+            }
+
+            if (section.count > 0
+                && (! compare_loop
+                        <
+                            int, 0, dimension_count
+                        >::apply(direction_classes, section.directions)
+                    || section.count > max_count)
+                )
+            {
+                if (! section.duplicate)
+                {
+                    last_non_duplicate_index = sections.size();
+                }
+
+                sections.push_back(section);
+                section = section_type();
+            }
+
+            if (section.count == 0)
+            {
+                section.begin_index = index;
+                section.ring_id = ring_id;
+                section.duplicate = duplicate;
+                section.non_duplicate_index = ndi;
+                section.range_count = count;
+
+                if (mark_first_non_duplicated && ! duplicate)
+                {
+                    section.is_non_duplicate_first = true;
+                    mark_first_non_duplicated = false;
+                }
+
+                copy_loop
+                    <
+                        int, 0, dimension_count
+                    >::apply(direction_classes, section.directions);
+
+                // In cartesian this is envelope of previous point expanded with current point
+                // in non-cartesian this is envelope of a segment
+                box_first_in_section<typename cs_tag<robust_point_type>::type>
+                    ::apply(section.bounding_box, previous_robust_point, current_robust_point, strategy);
+            }
+            else
+            {
+                // In cartesian this is expand with current point
+                // in non-cartesian this is expand with a segment
+                box_next_in_section<typename cs_tag<robust_point_type>::type>
+                    ::apply(section.bounding_box, previous_robust_point, current_robust_point, strategy);
+            }
+
+            section.end_index = index + 1;
+            section.count++;
+            if (! duplicate)
+            {
+                ndi++;
+            }
+            previous_robust_point = current_robust_point;
+        }
+
+        // Add last section if applicable
+        if (section.count > 0)
+        {
+            if (! section.duplicate)
+            {
+                last_non_duplicate_index = sections.size();
+            }
+
+            sections.push_back(section);
+        }
+
+        if (last_non_duplicate_index < sections.size()
+            && ! sections[last_non_duplicate_index].duplicate)
+        {
+            sections[last_non_duplicate_index].is_non_duplicate_last = true;
+        }
+    }
+};
+
+
+template
+<
+    closure_selector Closure,
+    bool Reverse,
+    typename Point,
+    typename DimensionVector
+>
+struct sectionalize_range
+{
+    template
+    <
+        typename Range,
+        typename RobustPolicy,
+        typename Sections,
+        typename EnvelopeStrategy
+    >
+    static inline void apply(Range const& range,
+                             RobustPolicy const& robust_policy,
+                             Sections& sections,
+                             EnvelopeStrategy const& strategy,
+                             ring_identifier ring_id,
+                             std::size_t max_count)
+    {
+        typedef typename closeable_view<Range const, Closure>::type cview_type;
+        typedef typename reversible_view
+        <
+            cview_type const,
+            Reverse ? iterate_reverse : iterate_forward
+        >::type view_type;
+
+        cview_type cview(range);
+        view_type view(cview);
+
+        std::size_t const n = boost::size(view);
+        if (n == 0)
+        {
+            // Zero points, no section
+            return;
+        }
+
+        if (n == 1)
+        {
+            // Line with one point ==> no sections
+            return;
+        }
+
+        sectionalize_part<Point, DimensionVector>::apply(sections,
+            boost::begin(view), boost::end(view),
+            robust_policy, strategy, ring_id, max_count);
+    }
+};
+
+template
+<
+    bool Reverse,
+    typename DimensionVector
+>
+struct sectionalize_polygon
+{
+    template
+    <
+        typename Polygon,
+        typename RobustPolicy,
+        typename Sections,
+        typename EnvelopeStrategy
+    >
+    static inline void apply(Polygon const& poly,
+                RobustPolicy const& robust_policy,
+                Sections& sections,
+                EnvelopeStrategy const& strategy,
+                ring_identifier ring_id,
+                std::size_t max_count)
+    {
+        typedef typename point_type<Polygon>::type point_type;
+        typedef sectionalize_range
+        <
+                closure<Polygon>::value, Reverse,
+                point_type, DimensionVector
+        > per_range;
+
+        ring_id.ring_index = -1;
+        per_range::apply(exterior_ring(poly), robust_policy, sections, strategy, ring_id, max_count);
+
+        ring_id.ring_index++;
+        typename interior_return_type<Polygon const>::type
+            rings = interior_rings(poly);
+        for (typename detail::interior_iterator<Polygon const>::type
+                it = boost::begin(rings); it != boost::end(rings); ++it, ++ring_id.ring_index)
+        {
+            per_range::apply(*it, robust_policy, sections, strategy, ring_id, max_count);
+        }
+    }
+};
+
+template <typename DimensionVector>
+struct sectionalize_box
+{
+    template
+    <
+        typename Box,
+        typename RobustPolicy,
+        typename Sections,
+        typename EnvelopeStrategy
+    >
+    static inline void apply(Box const& box,
+                RobustPolicy const& robust_policy,
+                Sections& sections,
+                EnvelopeStrategy const& ,
+                ring_identifier const& ring_id, std::size_t max_count)
+    {
+        typedef typename point_type<Box>::type point_type;
+
+        assert_dimension<Box, 2>();
+
+        // Add all four sides of the 2D-box as separate section.
+        // Easiest is to convert it to a polygon.
+        // However, we don't have the polygon type
+        // (or polygon would be a helper-type).
+        // Therefore we mimic a linestring/std::vector of 5 points
+
+        // TODO: might be replaced by assign_box_corners_oriented
+        // or just "convert"
+        point_type ll, lr, ul, ur;
+        geometry::detail::assign_box_corners(box, ll, lr, ul, ur);
+
+        std::vector<point_type> points;
+        points.push_back(ll);
+        points.push_back(ul);
+        points.push_back(ur);
+        points.push_back(lr);
+        points.push_back(ll);
+
+        // NOTE: Use cartesian envelope strategy in all coordinate systems
+        //       because edges of a box are not geodesic segments
+        sectionalize_range
+        <
+                closed, false,
+            point_type,
+            DimensionVector
+        >::apply(points, robust_policy, sections,
+                 strategy::envelope::cartesian_segment<>(),
+                 ring_id, max_count);
+    }
+};
+
+template <typename DimensionVector, typename Policy>
+struct sectionalize_multi
+{
+    template
+    <
+        typename MultiGeometry,
+        typename RobustPolicy,
+        typename Sections,
+        typename EnvelopeStrategy
+    >
+    static inline void apply(MultiGeometry const& multi,
+                RobustPolicy const& robust_policy,
+                Sections& sections,
+                EnvelopeStrategy const& strategy,
+                ring_identifier ring_id,
+                std::size_t max_count)
+    {
+        ring_id.multi_index = 0;
+        for (typename boost::range_iterator<MultiGeometry const>::type
+                    it = boost::begin(multi);
+            it != boost::end(multi);
+            ++it, ++ring_id.multi_index)
+        {
+            Policy::apply(*it, robust_policy, sections, strategy, ring_id, max_count);
+        }
+    }
+};
+
+template <typename Sections>
+inline void enlarge_sections(Sections& sections)
+{
+    // Robustness issue. Increase sections a tiny bit such that all points are really within (and not on border)
+    // Reason: turns might, rarely, be missed otherwise (case: "buffer_mp1")
+    // Drawback: not really, range is now completely inside the section. Section is a tiny bit too large,
+    // which might cause (a small number) of more comparisons
+    
+    // NOTE: above is old comment to the not used code expanding the Boxes by relaxed_epsilon(10)
+    
+    // Enlarge sections by scaled epsilon, this should be consistent with math::equals().
+    // Points and Segments are equal-compared WRT machine epsilon, but Boxes aren't
+    // Enlarging Boxes ensures that they correspond to the bound objects,
+    // Segments in this case, since Sections are collections of Segments.
+    for (typename boost::range_iterator<Sections>::type it = boost::begin(sections);
+        it != boost::end(sections);
+        ++it)
+    {
+        detail::expand_by_epsilon(it->bounding_box);
+    }
+}
+
+
+}} // namespace detail::sectionalize
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Tag,
+    typename Geometry,
+    bool Reverse,
+    typename DimensionVector
+>
+struct sectionalize
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_OR_NOT_YET_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
+            , (types<Geometry>)
+        );
+};
+
+template
+<
+    typename Box,
+    bool Reverse,
+    typename DimensionVector
+>
+struct sectionalize<box_tag, Box, Reverse, DimensionVector>
+    : detail::sectionalize::sectionalize_box<DimensionVector>
+{};
+
+template
+<
+    typename LineString,
+    typename DimensionVector
+>
+struct sectionalize
+    <
+        linestring_tag,
+        LineString,
+        false,
+        DimensionVector
+    >
+    : detail::sectionalize::sectionalize_range
+        <
+            closed, false,
+            typename point_type<LineString>::type,
+            DimensionVector
+        >
+{};
+
+template
+<
+    typename Ring,
+    bool Reverse,
+    typename DimensionVector
+>
+struct sectionalize<ring_tag, Ring, Reverse, DimensionVector>
+    : detail::sectionalize::sectionalize_range
+        <
+            geometry::closure<Ring>::value, Reverse,
+            typename point_type<Ring>::type,
+            DimensionVector
+        >
+{};
+
+template
+<
+    typename Polygon,
+    bool Reverse,
+    typename DimensionVector
+>
+struct sectionalize<polygon_tag, Polygon, Reverse, DimensionVector>
+    : detail::sectionalize::sectionalize_polygon
+        <
+            Reverse, DimensionVector
+        >
+{};
+
+template
+<
+    typename MultiPolygon,
+    bool Reverse,
+    typename DimensionVector
+>
+struct sectionalize<multi_polygon_tag, MultiPolygon, Reverse, DimensionVector>
+    : detail::sectionalize::sectionalize_multi
+        <
+            DimensionVector,
+            detail::sectionalize::sectionalize_polygon
+                <
+                    Reverse,
+                    DimensionVector
+                >
+        >
+
+{};
+
+template
+<
+    typename MultiLinestring,
+    bool Reverse,
+    typename DimensionVector
+>
+struct sectionalize<multi_linestring_tag, MultiLinestring, Reverse, DimensionVector>
+    : detail::sectionalize::sectionalize_multi
+        <
+            DimensionVector,
+            detail::sectionalize::sectionalize_range
+                <
+                    closed, false,
+                    typename point_type<MultiLinestring>::type,
+                    DimensionVector
+                >
+        >
+
+{};
+
+} // namespace dispatch
+#endif
+
+
+/*!
+    \brief Split a geometry into monotonic sections
+    \ingroup sectionalize
+    \tparam Geometry type of geometry to check
+    \tparam Sections type of sections to create
+    \param geometry geometry to create sections from
+    \param robust_policy policy to handle robustness issues
+    \param sections structure with sections
+    \param source_index index to assign to the ring_identifiers
+    \param max_count maximal number of points per section
+        (defaults to 10, this seems to give the fastest results)
+
+ */
+template
+<
+    bool Reverse,
+    typename DimensionVector,
+    typename Geometry,
+    typename Sections,
+    typename RobustPolicy,
+    typename EnvelopeStrategy
+>
+inline void sectionalize(Geometry const& geometry,
+                RobustPolicy const& robust_policy,
+                Sections& sections,
+                EnvelopeStrategy const& strategy,
+                int source_index = 0,
+                std::size_t max_count = 10)
+{
+    BOOST_STATIC_ASSERT((! boost::is_fundamental<EnvelopeStrategy>::value));
+
+    concepts::check<Geometry const>();
+
+    typedef typename boost::range_value<Sections>::type section_type;
+
+    // Compiletime check for point type of section boxes
+    // and point type related to robust policy
+    typedef typename geometry::coordinate_type
+    <
+        typename section_type::box_type
+    >::type ctype1;
+    typedef typename geometry::coordinate_type
+    <
+        typename geometry::robust_point_type
+        <
+            typename geometry::point_type<Geometry>::type,
+            RobustPolicy
+        >::type
+    >::type ctype2;
+
+    BOOST_MPL_ASSERT((boost::is_same<ctype1, ctype2>));
+
+
+    sections.clear();
+
+    ring_identifier ring_id;
+    ring_id.source_index = source_index;
+
+    dispatch::sectionalize
+        <
+            typename tag<Geometry>::type,
+            Geometry,
+            Reverse,
+            DimensionVector
+        >::apply(geometry, robust_policy, sections, strategy, ring_id, max_count);
+
+    detail::sectionalize::enlarge_sections(sections);
+}
+
+
+template
+<
+    bool Reverse,
+    typename DimensionVector,
+    typename Geometry,
+    typename Sections,
+    typename RobustPolicy
+>
+inline void sectionalize(Geometry const& geometry,
+                         RobustPolicy const& robust_policy,
+                         Sections& sections,
+                         int source_index = 0,
+                         std::size_t max_count = 10)
+{
+    typedef typename strategy::envelope::services::default_strategy
+        <
+            typename cs_tag<Geometry>::type
+        >::type envelope_strategy_type;
+
+    boost::geometry::sectionalize
+        <
+            Reverse, DimensionVector
+        >(geometry, robust_policy, sections,
+          envelope_strategy_type(),
+          source_index, max_count);
+}
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_SECTIONS_SECTIONALIZE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/signed_size_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/signed_size_type.hpp
new file mode 100644
index 00000000000..db7344ec80b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/signed_size_type.hpp
@@ -0,0 +1,28 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_SIGNED_SIZE_TYPE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_SIGNED_SIZE_TYPE_HPP
+
+
+#include <cstddef>
+#include <boost/type_traits/make_signed.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+typedef boost::make_signed<std::size_t>::type signed_size_type;
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_SIGNED_SIZE_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/single_geometry.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/single_geometry.hpp
new file mode 100644
index 00000000000..31e4401099a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/single_geometry.hpp
@@ -0,0 +1,94 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2013, 2014.
+// Modifications copyright (c) 2013-2014, Oracle and/or its affiliates.
+
+// 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)
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_SINGLE_GEOMETRY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_SINGLE_GEOMETRY_HPP
+
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/util/range.hpp>
+
+namespace boost { namespace geometry {
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace detail_dispatch {
+
+// Returns single geometry by Id
+// for single geometries returns the geometry itself
+template <typename Geometry,
+          bool IsMulti = boost::is_base_of
+                            <
+                                multi_tag,
+                                typename geometry::tag<Geometry>::type
+                            >::value
+>
+struct single_geometry
+{
+    typedef Geometry & return_type;
+
+    template <typename Id>
+    static inline return_type apply(Geometry & g, Id const& ) { return g; }
+};
+
+// for multi geometries returns one of the stored single geometries
+template <typename Geometry>
+struct single_geometry<Geometry, true>
+{
+    typedef typename boost::range_reference<Geometry>::type return_type;
+
+    template <typename Id>
+    static inline return_type apply(Geometry & g, Id const& id)
+    {
+        BOOST_GEOMETRY_ASSERT(id.multi_index >= 0);
+        typedef typename boost::range_size<Geometry>::type size_type;
+        return range::at(g, static_cast<size_type>(id.multi_index));
+    }
+};
+
+} // namespace detail_dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail {
+
+template <typename Geometry>
+struct single_geometry_return_type
+{
+    typedef typename detail_dispatch::single_geometry<Geometry>::return_type type;
+};
+
+template <typename Geometry, typename Id>
+inline
+typename single_geometry_return_type<Geometry>::type
+single_geometry(Geometry & geometry, Id const& id)
+{
+    return detail_dispatch::single_geometry<Geometry>::apply(geometry, id);
+}
+
+template <typename Geometry, typename Id>
+inline
+typename single_geometry_return_type<Geometry const>::type
+single_geometry(Geometry const& geometry, Id const& id)
+{
+    return detail_dispatch::single_geometry<Geometry const>::apply(geometry, id);
+}
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_SINGLE_GEOMETRY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sub_range.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sub_range.hpp
new file mode 100644
index 00000000000..29edc94e6cc
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sub_range.hpp
@@ -0,0 +1,129 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2013, 2014.
+// Modifications copyright (c) 2013-2014, Oracle and/or its affiliates.
+
+// 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)
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_SUB_RANGE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_SUB_RANGE_HPP
+
+#include <boost/mpl/if.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/util/range.hpp>
+
+namespace boost { namespace geometry {
+
+#ifndef DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace detail_dispatch {
+
+template <typename Geometry,
+          typename Tag = typename geometry::tag<Geometry>::type,
+          bool IsMulti = boost::is_base_of<multi_tag, Tag>::value>
+struct sub_range : not_implemented<Tag>
+{};
+
+template <typename Geometry, typename Tag>
+struct sub_range<Geometry, Tag, false>
+{
+    typedef Geometry & return_type;
+
+    template <typename Id> static inline
+    return_type apply(Geometry & geometry, Id const&)
+    {
+        return geometry;
+    }
+};
+
+template <typename Geometry>
+struct sub_range<Geometry, polygon_tag, false>
+{
+    typedef typename geometry::ring_return_type<Geometry>::type return_type;
+
+    template <typename Id> static inline
+    return_type apply(Geometry & geometry, Id const& id)
+    {
+        if ( id.ring_index < 0 )
+        {
+            return geometry::exterior_ring(geometry);
+        }
+        else
+        {
+            typedef typename boost::range_size
+                <
+                    typename geometry::interior_type<Geometry>::type
+                >::type size_type;
+            size_type const ri = static_cast<size_type>(id.ring_index);
+            return range::at(geometry::interior_rings(geometry), ri);
+        }
+    }
+};
+
+template <typename Geometry, typename Tag>
+struct sub_range<Geometry, Tag, true>
+{
+    typedef typename boost::range_value<Geometry>::type value_type;
+    typedef typename boost::mpl::if_c
+        <
+            boost::is_const<Geometry>::value,
+            typename boost::add_const<value_type>::type,
+            value_type
+        >::type sub_type;
+
+    typedef detail_dispatch::sub_range<sub_type> sub_sub_range;
+
+    // TODO: shouldn't it be return_type?
+    typedef typename sub_sub_range::return_type return_type;
+
+    template <typename Id> static inline
+    return_type apply(Geometry & geometry, Id const& id)
+    {
+        BOOST_GEOMETRY_ASSERT(0 <= id.multi_index);
+        typedef typename boost::range_size<Geometry>::type size_type;
+        size_type const mi = static_cast<size_type>(id.multi_index);
+        return sub_sub_range::apply(range::at(geometry, mi), id);
+    }
+};
+
+} // namespace detail_dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+namespace detail {
+
+template <typename Geometry>
+struct sub_range_return_type
+{
+    typedef typename detail_dispatch::sub_range<Geometry>::return_type type;
+};
+
+// This function also works for geometry::segment_identifier
+
+template <typename Geometry, typename Id> inline
+typename sub_range_return_type<Geometry>::type
+sub_range(Geometry & geometry, Id const& id)
+{
+    return detail_dispatch::sub_range<Geometry>::apply(geometry, id);
+}
+
+template <typename Geometry, typename Id> inline
+typename sub_range_return_type<Geometry const>::type
+sub_range(Geometry const& geometry, Id const& id)
+{
+    return detail_dispatch::sub_range<Geometry const>::apply(geometry, id);
+}
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_SUB_RANGE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sweep.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sweep.hpp
new file mode 100644
index 00000000000..3dc78261f2d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/sweep.hpp
@@ -0,0 +1,87 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_SWEEP_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_SWEEP_HPP
+
+#include <boost/core/ignore_unused.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace sweep
+{
+
+struct no_interrupt_policy
+{
+    static bool const enabled = false;
+
+    template <typename Event>
+    static inline bool apply(Event const&)
+    {
+        return false;
+    }
+};
+
+}} // namespace detail::sweep
+#endif // DOXYGEN_NO_DETAIL
+
+
+template
+<
+    typename Range,
+    typename PriorityQueue,
+    typename InitializationVisitor,
+    typename EventVisitor,
+    typename InterruptPolicy
+>
+inline void sweep(Range const& range, PriorityQueue& queue,
+                  InitializationVisitor& initialization_visitor,
+                  EventVisitor& event_visitor,
+                  InterruptPolicy const& interrupt_policy)
+{
+    typedef typename PriorityQueue::value_type event_type;
+
+    initialization_visitor.apply(range, queue, event_visitor);
+    while (! queue.empty())
+    {
+        event_type event = queue.top();
+        queue.pop();
+        event_visitor.apply(event, queue);
+        if (interrupt_policy.enabled && interrupt_policy.apply(event))
+        {
+            break;
+        }
+    }
+
+    boost::ignore_unused(interrupt_policy);
+}
+
+
+template
+<
+    typename Range,
+    typename PriorityQueue,
+    typename InitializationVisitor,
+    typename EventVisitor
+>
+inline void sweep(Range const& range, PriorityQueue& queue,
+                  InitializationVisitor& initialization_visitor,
+                  EventVisitor& event_visitor)
+{
+    sweep(range, queue, initialization_visitor, event_visitor,
+          detail::sweep::no_interrupt_policy());
+}
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_SWEEP_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/throw_on_empty_input.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/throw_on_empty_input.hpp
new file mode 100644
index 00000000000..3d45a46d160
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/throw_on_empty_input.hpp
@@ -0,0 +1,69 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_THROW_ON_EMPTY_INPUT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_THROW_ON_EMPTY_INPUT_HPP
+
+
+#include <boost/geometry/core/exception.hpp>
+#include <boost/geometry/algorithms/is_empty.hpp>
+
+#include <boost/throw_exception.hpp>
+
+
+// BSG 2012-02-06: we use this currently only for distance.
+// For other scalar results area,length,perimeter it is commented on purpose.
+// Reason is that for distance there is no other choice. distance of two
+// empty geometries (or one empty) should NOT return any value.
+// But for area it is no problem to be 0.
+// Suppose: area(intersection(a,b)). We (probably) don't want a throw there...
+
+// So decided that at least for Boost 1.49 this is commented for
+// scalar results, except distance.
+
+#if defined(BOOST_GEOMETRY_EMPTY_INPUT_NO_THROW)
+#include <boost/core/ignore_unused.hpp>
+#endif
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <typename Geometry>
+inline void throw_on_empty_input(Geometry const& geometry)
+{
+#if ! defined(BOOST_GEOMETRY_EMPTY_INPUT_NO_THROW)
+    if (geometry::is_empty(geometry))
+    {
+        BOOST_THROW_EXCEPTION(empty_input_exception());
+    }
+#else
+    boost::ignore_unused(geometry);
+#endif
+}
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_THROW_ON_EMPTY_INPUT_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/touches/implementation.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/touches/implementation.hpp
new file mode 100644
index 00000000000..94f1fba581e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/touches/implementation.hpp
@@ -0,0 +1,459 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2015 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013, 2014, 2015, 2017.
+// Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_TOUCHES_IMPLEMENTATION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_TOUCHES_IMPLEMENTATION_HPP
+
+
+#include <boost/geometry/algorithms/detail/for_each_range.hpp>
+#include <boost/geometry/algorithms/detail/overlay/overlay.hpp>
+#include <boost/geometry/algorithms/detail/overlay/self_turn_points.hpp>
+#include <boost/geometry/algorithms/detail/sub_range.hpp>
+#include <boost/geometry/algorithms/detail/relate/relate_impl.hpp>
+#include <boost/geometry/algorithms/detail/touches/interface.hpp>
+#include <boost/geometry/algorithms/disjoint.hpp>
+#include <boost/geometry/algorithms/intersects.hpp>
+#include <boost/geometry/algorithms/num_geometries.hpp>
+#include <boost/geometry/algorithms/relate.hpp>
+
+#include <boost/geometry/policies/robustness/no_rescale_policy.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace touches
+{
+
+// Box/Box
+
+template
+<
+    std::size_t Dimension,
+    std::size_t DimensionCount
+>
+struct box_box_loop
+{
+    template <typename Box1, typename Box2>
+    static inline bool apply(Box1 const& b1, Box2 const& b2, bool & touch)
+    {
+        typedef typename coordinate_type<Box1>::type coordinate_type1;
+        typedef typename coordinate_type<Box2>::type coordinate_type2;
+
+        coordinate_type1 const& min1 = get<min_corner, Dimension>(b1);
+        coordinate_type1 const& max1 = get<max_corner, Dimension>(b1);
+        coordinate_type2 const& min2 = get<min_corner, Dimension>(b2);
+        coordinate_type2 const& max2 = get<max_corner, Dimension>(b2);
+
+        // TODO assert or exception?
+        //BOOST_GEOMETRY_ASSERT(min1 <= max1 && min2 <= max2);
+
+        if (max1 < min2 || max2 < min1)
+        {
+            return false;
+        }
+
+        if (max1 == min2 || max2 == min1)
+        {
+            touch = true;
+        }
+        
+        return box_box_loop
+                <
+                    Dimension + 1,
+                    DimensionCount
+                >::apply(b1, b2, touch);
+    }
+};
+
+template
+<
+    std::size_t DimensionCount
+>
+struct box_box_loop<DimensionCount, DimensionCount>
+{
+    template <typename Box1, typename Box2>
+    static inline bool apply(Box1 const& , Box2 const&, bool &)
+    {
+        return true;
+    }
+};
+
+struct box_box
+{
+    template <typename Box1, typename Box2, typename Strategy>
+    static inline bool apply(Box1 const& b1, Box2 const& b2, Strategy const& /*strategy*/)
+    {
+        BOOST_STATIC_ASSERT((boost::is_same
+                                <
+                                    typename geometry::coordinate_system<Box1>::type,
+                                    typename geometry::coordinate_system<Box2>::type
+                                >::value
+                           ));
+        assert_dimension_equal<Box1, Box2>();
+
+        bool touches = false;
+        bool ok = box_box_loop
+                    <
+                        0,
+                        dimension<Box1>::type::value
+                    >::apply(b1, b2, touches);
+
+        return ok && touches;
+    }
+};
+
+// Areal/Areal
+
+struct areal_interrupt_policy
+{
+    static bool const enabled = true;
+    bool found_touch;
+    bool found_not_touch;
+
+    // dummy variable required by self_get_turn_points::get_turns
+    static bool const has_intersections = false;
+
+    inline bool result()
+    {
+        return found_touch && !found_not_touch;
+    }
+
+    inline areal_interrupt_policy()
+        : found_touch(false), found_not_touch(false)
+    {}
+
+    template <typename Range>
+    inline bool apply(Range const& range)
+    {
+        // if already rejected (temp workaround?)
+        if ( found_not_touch )
+            return true;
+
+        typedef typename boost::range_iterator<Range const>::type iterator;
+        for ( iterator it = boost::begin(range) ; it != boost::end(range) ; ++it )
+        {
+            if ( it->has(overlay::operation_intersection) )
+            {
+                found_not_touch = true;
+                return true;
+            }
+
+            switch(it->method)
+            {
+                case overlay::method_crosses:
+                    found_not_touch = true;
+                    return true;
+                case overlay::method_equal:
+                    // Segment spatially equal means: at the right side
+                    // the polygon internally overlaps. So return false.
+                    found_not_touch = true;
+                    return true;
+                case overlay::method_touch:
+                case overlay::method_touch_interior:
+                case overlay::method_collinear:
+                    if ( ok_for_touch(*it) )
+                    {
+                        found_touch = true;
+                    }
+                    else
+                    {
+                        found_not_touch = true;
+                        return true;
+                    }
+                    break;
+                case overlay::method_none :
+                case overlay::method_disjoint :
+                case overlay::method_error :
+                    break;
+            }
+        }
+
+        return false;
+    }
+
+    template <typename Turn>
+    inline bool ok_for_touch(Turn const& turn)
+    {
+        return turn.both(overlay::operation_union)
+            || turn.both(overlay::operation_blocked)
+            || turn.combination(overlay::operation_union, overlay::operation_blocked)
+            ;
+    }
+};
+
+template<typename Geometry, typename PointInRingStrategy>
+struct check_each_ring_for_within
+{
+    bool has_within;
+    Geometry const& m_geometry;
+    PointInRingStrategy const& m_strategy;
+
+    inline check_each_ring_for_within(Geometry const& g, PointInRingStrategy const& strategy)
+        : has_within(false)
+        , m_geometry(g)
+        , m_strategy(strategy)
+    {}
+
+    template <typename Range>
+    inline void apply(Range const& range)
+    {
+        typename geometry::point_type<Range>::type p;
+        geometry::point_on_border(p, range);
+        if ( !has_within && geometry::within(p, m_geometry, m_strategy) )
+        {
+            has_within = true;
+        }
+    }
+};
+
+template <typename FirstGeometry, typename SecondGeometry, typename IntersectionStrategy>
+inline bool rings_containing(FirstGeometry const& geometry1,
+                             SecondGeometry const& geometry2,
+                             IntersectionStrategy const& strategy)
+{
+    // NOTE: This strategy could be defined inside IntersectionStrategy
+    typedef typename IntersectionStrategy::template point_in_geometry_strategy
+        <
+            FirstGeometry, SecondGeometry
+        >::type point_in_ring_strategy_type;
+
+    point_in_ring_strategy_type point_in_ring_strategy
+        = strategy.template get_point_in_geometry_strategy<FirstGeometry, SecondGeometry>();
+
+    check_each_ring_for_within
+        <
+            FirstGeometry, point_in_ring_strategy_type
+        > checker(geometry1, point_in_ring_strategy);
+    geometry::detail::for_each_range(geometry2, checker);
+    return checker.has_within;
+}
+
+template <typename Geometry1, typename Geometry2>
+struct areal_areal
+{
+    template <typename IntersectionStrategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             IntersectionStrategy const& strategy)
+    {
+        typedef detail::no_rescale_policy rescale_policy_type;
+        typedef typename geometry::point_type<Geometry1>::type point_type;
+        typedef detail::overlay::turn_info
+            <
+                point_type,
+                typename segment_ratio_type<point_type, rescale_policy_type>::type
+            > turn_info;
+
+        std::deque<turn_info> turns;
+        detail::touches::areal_interrupt_policy policy;
+        rescale_policy_type robust_policy;
+        boost::geometry::get_turns
+                <
+                    detail::overlay::do_reverse<geometry::point_order<Geometry1>::value>::value,
+                    detail::overlay::do_reverse<geometry::point_order<Geometry2>::value>::value,
+                    detail::overlay::assign_null_policy
+                >(geometry1, geometry2, strategy, robust_policy, turns, policy);
+
+        return policy.result()
+            && ! geometry::detail::touches::rings_containing(geometry1, geometry2, strategy)
+            && ! geometry::detail::touches::rings_containing(geometry2, geometry1, strategy);
+    }
+};
+
+// P/*
+
+struct use_point_in_geometry
+{
+    template <typename Point, typename Geometry, typename Strategy>
+    static inline bool apply(Point const& point, Geometry const& geometry, Strategy const& strategy)
+    {
+        return detail::within::point_in_geometry(point, geometry, strategy) == 0;
+    }
+};
+
+
+}}
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch {
+
+// P/P
+
+template <typename Geometry1, typename Geometry2, typename Tag2>
+struct touches<Geometry1, Geometry2, point_tag, Tag2, pointlike_tag, pointlike_tag, false>
+{
+    template <typename Strategy>
+    static inline bool apply(Geometry1 const& , Geometry2 const& , Strategy const&)
+    {
+        return false;
+    }
+};
+
+template <typename Geometry1, typename Geometry2, typename Tag2>
+struct touches<Geometry1, Geometry2, multi_point_tag, Tag2, pointlike_tag, pointlike_tag, false>
+{
+    template <typename Strategy>
+    static inline bool apply(Geometry1 const&, Geometry2 const&, Strategy const&)
+    {
+        return false;
+    }
+};
+
+// P/*
+
+template <typename Point, typename Geometry, typename Tag2, typename CastedTag2>
+struct touches<Point, Geometry, point_tag, Tag2, pointlike_tag, CastedTag2, false>
+    : detail::touches::use_point_in_geometry
+{};
+
+template <typename MultiPoint, typename MultiGeometry, typename Tag2, typename CastedTag2>
+struct touches<MultiPoint, MultiGeometry, multi_point_tag, Tag2, pointlike_tag, CastedTag2, false>
+    : detail::relate::relate_impl
+        <
+            detail::de9im::static_mask_touches_type,
+            MultiPoint,
+            MultiGeometry
+        >
+{};
+
+template <typename Geometry, typename MultiPoint, typename Tag1, typename CastedTag1>
+struct touches<Geometry, MultiPoint, Tag1, multi_point_tag, CastedTag1, pointlike_tag, false>
+    : detail::relate::relate_impl
+        <
+            detail::de9im::static_mask_touches_type,
+            Geometry,
+            MultiPoint
+        >
+{};
+
+// Box/Box
+
+template <typename Box1, typename Box2, typename CastedTag1, typename CastedTag2>
+struct touches<Box1, Box2, box_tag, box_tag, CastedTag1, CastedTag2, false>
+    : detail::touches::box_box
+{};
+
+template <typename Box1, typename Box2>
+struct touches<Box1, Box2, box_tag, box_tag, areal_tag, areal_tag, false>
+    : detail::touches::box_box
+{};
+
+// L/L
+
+template <typename Linear1, typename Linear2, typename Tag1, typename Tag2>
+struct touches<Linear1, Linear2, Tag1, Tag2, linear_tag, linear_tag, false>
+    : detail::relate::relate_impl
+    <
+        detail::de9im::static_mask_touches_type,
+        Linear1,
+        Linear2
+    >
+{};
+
+// L/A
+
+template <typename Linear, typename Areal, typename Tag1, typename Tag2>
+struct touches<Linear, Areal, Tag1, Tag2, linear_tag, areal_tag, false>
+    : detail::relate::relate_impl
+    <
+        detail::de9im::static_mask_touches_type,
+        Linear,
+        Areal
+    >
+{};
+
+// A/L
+template <typename Linear, typename Areal, typename Tag1, typename Tag2>
+struct touches<Areal, Linear, Tag1, Tag2, areal_tag, linear_tag, false>
+    : detail::relate::relate_impl
+    <
+        detail::de9im::static_mask_touches_type,
+        Areal,
+        Linear
+    >
+{};
+
+// A/A
+
+template <typename Areal1, typename Areal2, typename Tag1, typename Tag2>
+struct touches<Areal1, Areal2, Tag1, Tag2, areal_tag, areal_tag, false>
+    : detail::relate::relate_impl
+        <
+            detail::de9im::static_mask_touches_type,
+            Areal1,
+            Areal2
+        >
+{};
+
+template <typename Areal1, typename Areal2>
+struct touches<Areal1, Areal2, ring_tag, ring_tag, areal_tag, areal_tag, false>
+    : detail::touches::areal_areal<Areal1, Areal2>
+{};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_variant {
+
+template <typename Geometry>
+struct self_touches
+{
+    static bool apply(Geometry const& geometry)
+    {
+        concepts::check<Geometry const>();
+
+        typedef typename strategy::relate::services::default_strategy
+            <
+                Geometry, Geometry
+            >::type strategy_type;
+        typedef detail::no_rescale_policy rescale_policy_type;
+        typedef typename geometry::point_type<Geometry>::type point_type;
+        typedef detail::overlay::turn_info
+            <
+                point_type,
+                typename segment_ratio_type<point_type, rescale_policy_type>::type
+            > turn_info;
+
+        typedef detail::overlay::get_turn_info
+        <
+            detail::overlay::assign_null_policy
+        > policy_type;
+
+        std::deque<turn_info> turns;
+        detail::touches::areal_interrupt_policy policy;
+        strategy_type strategy;
+        rescale_policy_type robust_policy;
+        detail::self_get_turn_points::get_turns
+        <
+            false, policy_type
+        >::apply(geometry, strategy, robust_policy, turns, policy, 0);
+
+        return policy.result();
+    }
+};
+
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_TOUCHES_IMPLEMENTATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/touches/interface.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/touches/interface.hpp
new file mode 100644
index 00000000000..d2e0cc8c4e9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/touches/interface.hpp
@@ -0,0 +1,321 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2015 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013, 2014, 2015, 2017.
+// Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_TOUCHES_INTERFACE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_TOUCHES_INTERFACE_HPP
+
+
+#include <deque>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/core/reverse_dispatch.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/strategies/relate.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch {
+
+// TODO: Since CastedTags are used is Reverse needed?
+
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename Tag1 = typename tag<Geometry1>::type,
+    typename Tag2 = typename tag<Geometry2>::type,
+    typename CastedTag1 = typename tag_cast<Tag1, pointlike_tag, linear_tag, areal_tag>::type,
+    typename CastedTag2 = typename tag_cast<Tag2, pointlike_tag, linear_tag, areal_tag>::type,
+    bool Reverse = reverse_dispatch<Geometry1, Geometry2>::type::value
+>
+struct touches
+    : not_implemented<Tag1, Tag2>
+{};
+
+// If reversal is needed, perform it
+template
+<
+    typename Geometry1, typename Geometry2,
+    typename Tag1, typename Tag2,
+    typename CastedTag1, typename CastedTag2
+>
+struct touches<Geometry1, Geometry2, Tag1, Tag2, CastedTag1, CastedTag2, true>
+    : touches<Geometry2, Geometry1, Tag2, Tag1, CastedTag2, CastedTag1, false>
+{
+    template <typename Strategy>
+    static inline bool apply(Geometry1 const& g1, Geometry2 const& g2, Strategy const& strategy)
+    {
+        return touches<Geometry2, Geometry1>::apply(g2, g1, strategy);
+    }
+};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_strategy
+{
+
+struct touches
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        return dispatch::touches
+            <
+                Geometry1, Geometry2
+            >::apply(geometry1, geometry2, strategy);
+    }
+
+    template <typename Geometry1, typename Geometry2>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             default_strategy)
+    {
+        typedef typename strategy::relate::services::default_strategy
+            <
+                Geometry1,
+                Geometry2
+            >::type strategy_type;
+
+        return dispatch::touches
+            <
+                Geometry1, Geometry2
+            >::apply(geometry1, geometry2, strategy_type());
+    }
+};
+
+} // namespace resolve_strategy
+
+
+namespace resolve_variant {
+
+template <typename Geometry1, typename Geometry2>
+struct touches
+{
+    template <typename Strategy>
+    static bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        concepts::check<Geometry1 const>();
+        concepts::check<Geometry2 const>();
+
+        return resolve_strategy::touches::apply(geometry1, geometry2, strategy);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
+struct touches<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
+{
+    template <typename Strategy>
+    struct visitor: boost::static_visitor<bool>
+    {
+        Geometry2 const& m_geometry2;
+        Strategy const& m_strategy;
+
+        visitor(Geometry2 const& geometry2, Strategy const& strategy)
+            : m_geometry2(geometry2)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Geometry1>
+        bool operator()(Geometry1 const& geometry1) const
+        {
+            return touches<Geometry1, Geometry2>::apply(geometry1, m_geometry2, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline bool apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(geometry2, strategy), geometry1);
+    }
+};
+
+template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct touches<Geometry1, boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Strategy>
+    struct visitor: boost::static_visitor<bool>
+    {
+        Geometry1 const& m_geometry1;
+        Strategy const& m_strategy;
+
+        visitor(Geometry1 const& geometry1, Strategy const& strategy)
+            : m_geometry1(geometry1)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Geometry2>
+        bool operator()(Geometry2 const& geometry2) const
+        {
+            return touches<Geometry1, Geometry2>::apply(m_geometry1, geometry2, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2,
+                             Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(geometry1, strategy), geometry2);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T1),
+          BOOST_VARIANT_ENUM_PARAMS(typename T2)>
+struct touches<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)>,
+               boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)> >
+{
+    template <typename Strategy>
+    struct visitor: boost::static_visitor<bool>
+    {
+        Strategy const& m_strategy;
+
+        visitor(Strategy const& strategy)
+            : m_strategy(strategy)
+        {}
+
+        template <typename Geometry1, typename Geometry2>
+        bool operator()(Geometry1 const& geometry1,
+                        Geometry2 const& geometry2) const
+        {
+            return touches<Geometry1, Geometry2>::apply(geometry1, geometry2, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline bool apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)> const& geometry1,
+                             boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2,
+                             Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(strategy), geometry1, geometry2);
+    }
+};
+
+template <typename Geometry>
+struct self_touches;
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct self_touches<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    struct visitor: boost::static_visitor<bool>
+    {
+        template <typename Geometry>
+        bool operator()(Geometry const& geometry) const
+        {
+            return self_touches<Geometry>::apply(geometry);
+        }
+    };
+
+    static inline bool
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry)
+    {
+        return boost::apply_visitor(visitor(), geometry);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief \brief_check{has at least one touching point (self-tangency)}
+\note This function can be called for one geometry (self-tangency) and
+    also for two geometries (touch)
+\ingroup touches
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\return \return_check{is self-touching}
+
+\qbk{distinguish,one geometry}
+\qbk{[def __one_parameter__]}
+\qbk{[include reference/algorithms/touches.qbk]}
+*/
+template <typename Geometry>
+inline bool touches(Geometry const& geometry)
+{
+    return resolve_variant::self_touches<Geometry>::apply(geometry);
+}
+
+
+/*!
+\brief \brief_check2{have at least one touching point (tangent - non overlapping)}
+\ingroup touches
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\return \return_check2{touch each other}
+
+\qbk{distinguish,two geometries}
+\qbk{[include reference/algorithms/touches.qbk]}
+ */
+template <typename Geometry1, typename Geometry2>
+inline bool touches(Geometry1 const& geometry1, Geometry2 const& geometry2)
+{
+    return resolve_variant::touches
+        <
+            Geometry1, Geometry2
+        >::apply(geometry1, geometry2, default_strategy());
+}
+
+/*!
+\brief \brief_check2{have at least one touching point (tangent - non overlapping)}
+\ingroup touches
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Strategy \tparam_strategy{Touches}
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param strategy \param_strategy{touches}
+\return \return_check2{touch each other}
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/touches.qbk]}
+ */
+template <typename Geometry1, typename Geometry2, typename Strategy>
+inline bool touches(Geometry1 const& geometry1,
+                    Geometry2 const& geometry2,
+                    Strategy const& strategy)
+{
+    return resolve_variant::touches
+        <
+            Geometry1, Geometry2
+        >::apply(geometry1, geometry2, strategy);
+}
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_TOUCHES_INTERFACE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/turns/compare_turns.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/turns/compare_turns.hpp
new file mode 100644
index 00000000000..ec383bf1039
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/turns/compare_turns.hpp
@@ -0,0 +1,117 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2015, Oracle and/or its affiliates.
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_TURNS_COMPARE_TURNS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_TURNS_COMPARE_TURNS_HPP
+
+#include <cstddef>
+#include <functional>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace detail { namespace turns
+{
+
+// TURNS SORTING AND SEARCHING
+
+// sort turns by G1 - source_index == 0 by:
+// seg_id -> fraction -> other_id -> operation
+template
+<
+    typename IdLess = std::less<signed_size_type>,
+    int N = 0, int U = 1, int I = 2, int B = 3, int C = 4, int O = 0,
+    std::size_t OpId = 0
+>
+struct less_seg_fraction_other_op
+{
+    BOOST_STATIC_ASSERT(OpId < 2);
+    static const std::size_t other_op_id = (OpId + 1) % 2;
+
+    template <typename Op>
+    static inline int order_op(Op const& op)
+    {
+        switch (op.operation)
+        {
+        case detail::overlay::operation_none : return N;
+        case detail::overlay::operation_union : return U;
+        case detail::overlay::operation_intersection : return I;
+        case detail::overlay::operation_blocked : return B;
+        case detail::overlay::operation_continue : return C;
+        case detail::overlay::operation_opposite : return O;
+        }
+        return -1;
+    }
+
+    template <typename Op>
+    static inline bool use_operation(Op const& left, Op const& right)
+    {
+        return order_op(left) < order_op(right);
+    }
+
+    template <typename Turn>
+    static inline bool use_other_id(Turn const& left, Turn const& right)
+    {
+        segment_identifier const& left_other_seg_id = left.operations[other_op_id].seg_id;
+        segment_identifier const& right_other_seg_id = right.operations[other_op_id].seg_id;
+
+        if ( left_other_seg_id.multi_index != right_other_seg_id.multi_index )
+        {
+            return left_other_seg_id.multi_index < right_other_seg_id.multi_index;
+        }
+        if ( left_other_seg_id.ring_index != right_other_seg_id.ring_index )
+        {
+            return left_other_seg_id.ring_index != right_other_seg_id.ring_index;
+        }
+        if ( left_other_seg_id.segment_index != right_other_seg_id.segment_index )
+        {
+            return IdLess()(left_other_seg_id.segment_index,
+                            right_other_seg_id.segment_index);
+        }
+        return use_operation(left.operations[OpId], right.operations[OpId]);
+    }
+
+    template <typename Turn>
+    static inline bool use_fraction(Turn const& left, Turn const& right)
+    {
+        return
+            geometry::math::equals(left.operations[OpId].fraction,
+                                   right.operations[OpId].fraction)
+            ?
+            use_other_id(left, right)
+            :
+            (left.operations[OpId].fraction < right.operations[OpId].fraction)
+            ;
+    }
+
+    template <typename Turn>
+    inline bool operator()(Turn const& left, Turn const& right) const
+    {
+        segment_identifier const& sl = left.operations[OpId].seg_id;
+        segment_identifier const& sr = right.operations[OpId].seg_id;
+
+        return sl < sr || ( sl == sr && use_fraction(left, right) );
+    }
+};
+
+
+
+
+
+}} // namespace detail::turns
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_TURNS_COMPARE_TURNS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/turns/debug_turn.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/turns/debug_turn.hpp
new file mode 100644
index 00000000000..5c4f03277af
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/turns/debug_turn.hpp
@@ -0,0 +1,65 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_TURNS_DEBUG_TURN_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_TURNS_DEBUG_TURN_HPP
+
+#ifdef BOOST_GEOMETRY_DEBUG_TURNS
+#include <iostream>
+#include <string>
+
+#include <boost/algorithm/string/predicate.hpp>
+
+#include <boost/geometry/io/wkt/write.hpp>
+#include <boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp>
+#endif // BOOST_GEOMETRY_DEBUG_TURNS
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace turns
+{
+
+
+#ifdef BOOST_GEOMETRY_DEBUG_TURNS
+template <typename Turn, typename Operation>
+inline void debug_turn(Turn const& turn, Operation op,
+                       std::string const& header)
+{
+    std::cout << header
+        << " at " << op.seg_id
+        << " meth: " << method_char(turn.method)
+        << " op: " << operation_char(op.operation)
+        << " of: " << operation_char(turn.operations[0].operation)
+        << operation_char(turn.operations[1].operation)
+        << " " << geometry::wkt(turn.point)
+        << std::endl;
+
+    if (boost::contains(header, "Finished"))
+    {
+        std::cout << std::endl;
+    }
+}
+#else
+template <typename Turn, typename Operation>
+inline void debug_turn(Turn const& , Operation, const char*)
+{
+}
+#endif // BOOST_GEOMETRY_DEBUG_TURNS
+
+
+}} // namespace detail::turns
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost:geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_TURNS_DEBUG_TURN_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/turns/filter_continue_turns.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/turns/filter_continue_turns.hpp
new file mode 100644
index 00000000000..17fbd65ddc9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/turns/filter_continue_turns.hpp
@@ -0,0 +1,78 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_TURNS_FILTER_CONTINUE_TURNS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_TURNS_FILTER_CONTINUE_TURNS_HPP
+
+#include <algorithm>
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace detail { namespace turns
+{
+
+
+template <typename Turns, bool Enable>
+struct filter_continue_turns
+{
+    static inline void apply(Turns&) {}
+};
+
+
+template <typename Turns>
+class filter_continue_turns<Turns, true>
+{
+private:
+    class IsContinueTurn
+    {
+    private:
+        template <typename Operation>
+        inline bool is_continue_or_opposite(Operation const& operation) const
+        {
+            return operation == detail::overlay::operation_continue
+                || operation == detail::overlay::operation_opposite;
+        }
+
+    public:
+        template <typename Turn>
+        bool operator()(Turn const& turn) const
+        {
+            if ( turn.method != detail::overlay::method_collinear
+                 && turn.method != detail::overlay::method_equal )
+            {
+                return false;
+            }
+
+            return is_continue_or_opposite(turn.operations[0].operation)
+                && is_continue_or_opposite(turn.operations[1].operation);
+        }
+    };
+
+
+public:
+    static inline void apply(Turns& turns)
+    {
+        turns.erase( std::remove_if(turns.begin(), turns.end(),
+                                    IsContinueTurn()),
+                     turns.end()
+                     );
+    }
+};
+
+
+}} // namespace detail::turns
+
+}} // namespect boost::geometry
+
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_TURNS_FILTER_CONTINUE_TURNS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/turns/print_turns.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/turns/print_turns.hpp
new file mode 100644
index 00000000000..1e9b9df4096
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/turns/print_turns.hpp
@@ -0,0 +1,105 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_TURNS_PRINT_TURNS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_TURNS_PRINT_TURNS_HPP
+
+#include <algorithm>
+#include <iostream>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/traversal_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/turn_info.hpp>
+#include <boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp>
+#include <boost/geometry/io/wkt/write.hpp>
+#include <boost/geometry/io/dsv/write.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace detail { namespace turns
+{
+
+struct turn_printer
+{
+    turn_printer(std::ostream & os)
+        : index(0)
+        , out(os)
+    {}
+
+    template <typename Turn>
+    void operator()(Turn const& turn)
+    {
+        out << index
+            << ": " << geometry::method_char(turn.method);
+
+        if ( turn.discarded )
+            out << " (discarded)\n";
+        else if ( turn.blocked() )
+            out << " (blocked)\n";
+        else
+            out << '\n';
+
+        double fraction[2];
+
+        fraction[0] = turn.operations[0].fraction.numerator()
+            / turn.operations[0].fraction.denominator();
+
+        out << geometry::operation_char(turn.operations[0].operation)
+            <<": seg: " << turn.operations[0].seg_id.source_index
+            << ", m: " << turn.operations[0].seg_id.multi_index
+            << ", r: " << turn.operations[0].seg_id.ring_index
+            << ", s: " << turn.operations[0].seg_id.segment_index;
+        out << ", fr: " << fraction[0];
+        out << ", col?: " << turn.operations[0].is_collinear;
+        out << ' ' << geometry::dsv(turn.point) << ' ';
+
+        out << '\n';
+
+        fraction[1] = turn.operations[1].fraction.numerator()
+            / turn.operations[1].fraction.denominator();
+
+        out << geometry::operation_char(turn.operations[1].operation)
+            << ": seg: " << turn.operations[1].seg_id.source_index
+            << ", m: " << turn.operations[1].seg_id.multi_index
+            << ", r: " << turn.operations[1].seg_id.ring_index
+            << ", s: " << turn.operations[1].seg_id.segment_index;
+        out << ", fr: " << fraction[1];
+        out << ", col?: " << turn.operations[1].is_collinear;
+        out << ' ' << geometry::dsv(turn.point) << ' ';
+
+        ++index;
+        out << std::endl;
+    }
+
+    int index;
+    std::ostream & out;
+};
+
+template <typename Geometry1, typename Geometry2, typename Turns>
+static inline void print_turns(Geometry1 const& g1,
+                               Geometry2 const& g2,
+                               Turns const& turns)
+{
+    std::cout << geometry::wkt(g1) << std::endl;
+    std::cout << geometry::wkt(g2) << std::endl;
+
+    std::for_each(boost::begin(turns), boost::end(turns), turn_printer(std::cout));
+}
+
+
+
+
+}} // namespace detail::turns
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_TURNS_PRINT_TURNS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/turns/remove_duplicate_turns.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/turns/remove_duplicate_turns.hpp
new file mode 100644
index 00000000000..ccb19efb73c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/turns/remove_duplicate_turns.hpp
@@ -0,0 +1,62 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_TURNS_REMOVE_DUPLICATE_TURNS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_TURNS_REMOVE_DUPLICATE_TURNS_HPP
+
+#include <algorithm>
+#include <boost/geometry/algorithms/equals.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace detail { namespace turns
+{
+
+template <typename Turns, bool Enable>
+struct remove_duplicate_turns
+{
+    static inline void apply(Turns&) {}
+};
+
+
+
+template <typename Turns>
+class remove_duplicate_turns<Turns, true>
+{
+private:
+    struct TurnEqualsTo
+    {
+        template <typename Turn>
+        bool operator()(Turn const& t1, Turn const& t2) const
+        {
+            return geometry::equals(t1.point, t2.point)
+                && t1.operations[0].seg_id == t2.operations[0].seg_id
+                && t1.operations[1].seg_id == t2.operations[1].seg_id;
+        }
+    };
+
+public:
+    static inline void apply(Turns& turns)
+    {
+        turns.erase( std::unique(turns.begin(), turns.end(),
+                                 TurnEqualsTo()),
+                     turns.end()
+                     );
+    }
+};
+
+
+
+}} // namespace detail::turns
+
+}} // namespect boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_TURNS_REMOVE_DUPLICATE_TURNS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/within/implementation.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/within/implementation.hpp
new file mode 100644
index 00000000000..8f1eba62e64
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/within/implementation.hpp
@@ -0,0 +1,306 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2013, 2014, 2017.
+// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_IMPLEMENTATION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_IMPLEMENTATION_HPP
+
+
+#include <cstddef>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/detail/within/interface.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/point_order.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/order_as_direction.hpp>
+#include <boost/geometry/views/closeable_view.hpp>
+#include <boost/geometry/views/reversible_view.hpp>
+
+#include <boost/geometry/algorithms/detail/within/multi_point.hpp>
+#include <boost/geometry/algorithms/detail/within/point_in_geometry.hpp>
+#include <boost/geometry/algorithms/relate.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/get_turns.hpp>
+#include <boost/geometry/algorithms/detail/overlay/do_reverse.hpp>
+#include <deque>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace within {
+
+struct use_point_in_geometry
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        return detail::within::point_in_geometry(geometry1, geometry2, strategy) == 1;
+    }
+};
+
+struct use_relate
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        typedef typename detail::de9im::static_mask_within_type
+            <
+                Geometry1, Geometry2
+            >::type within_mask;
+        return geometry::relate(geometry1, geometry2, within_mask(), strategy);
+    }
+};
+
+}} // namespace detail::within
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Point, typename Box>
+struct within<Point, Box, point_tag, box_tag>
+{
+    template <typename Strategy>
+    static inline bool apply(Point const& point, Box const& box, Strategy const& strategy)
+    {
+        boost::ignore_unused_variable_warning(strategy);
+        return strategy.apply(point, box);
+    }
+};
+
+template <typename Box1, typename Box2>
+struct within<Box1, Box2, box_tag, box_tag>
+{
+    template <typename Strategy>
+    static inline bool apply(Box1 const& box1, Box2 const& box2, Strategy const& strategy)
+    {
+        assert_dimension_equal<Box1, Box2>();
+        boost::ignore_unused_variable_warning(strategy);
+        return strategy.apply(box1, box2);
+    }
+};
+
+// P/P
+
+template <typename Point1, typename Point2>
+struct within<Point1, Point2, point_tag, point_tag>
+    : public detail::within::use_point_in_geometry
+{};
+
+template <typename Point, typename MultiPoint>
+struct within<Point, MultiPoint, point_tag, multi_point_tag>
+    : public detail::within::use_point_in_geometry
+{};
+
+template <typename MultiPoint, typename Point>
+struct within<MultiPoint, Point, multi_point_tag, point_tag>
+    : public detail::within::multi_point_point
+{};
+
+template <typename MultiPoint1, typename MultiPoint2>
+struct within<MultiPoint1, MultiPoint2, multi_point_tag, multi_point_tag>
+    : public detail::within::multi_point_multi_point
+{};
+
+// P/L
+
+template <typename Point, typename Segment>
+struct within<Point, Segment, point_tag, segment_tag>
+    : public detail::within::use_point_in_geometry
+{};
+
+template <typename Point, typename Linestring>
+struct within<Point, Linestring, point_tag, linestring_tag>
+    : public detail::within::use_point_in_geometry
+{};
+
+template <typename Point, typename MultiLinestring>
+struct within<Point, MultiLinestring, point_tag, multi_linestring_tag>
+    : public detail::within::use_point_in_geometry
+{};
+
+template <typename MultiPoint, typename Segment>
+struct within<MultiPoint, Segment, multi_point_tag, segment_tag>
+    : public detail::within::multi_point_single_geometry<true>
+{};
+
+template <typename MultiPoint, typename Linestring>
+struct within<MultiPoint, Linestring, multi_point_tag, linestring_tag>
+    : public detail::within::multi_point_single_geometry<true>
+{};
+
+template <typename MultiPoint, typename MultiLinestring>
+struct within<MultiPoint, MultiLinestring, multi_point_tag, multi_linestring_tag>
+    : public detail::within::multi_point_multi_geometry<true>
+{};
+
+// P/A
+
+template <typename Point, typename Ring>
+struct within<Point, Ring, point_tag, ring_tag>
+    : public detail::within::use_point_in_geometry
+{};
+
+template <typename Point, typename Polygon>
+struct within<Point, Polygon, point_tag, polygon_tag>
+    : public detail::within::use_point_in_geometry
+{};
+
+template <typename Point, typename MultiPolygon>
+struct within<Point, MultiPolygon, point_tag, multi_polygon_tag>
+    : public detail::within::use_point_in_geometry
+{};
+
+template <typename MultiPoint, typename Ring>
+struct within<MultiPoint, Ring, multi_point_tag, ring_tag>
+    : public detail::within::multi_point_single_geometry<true>
+{};
+
+template <typename MultiPoint, typename Polygon>
+struct within<MultiPoint, Polygon, multi_point_tag, polygon_tag>
+    : public detail::within::multi_point_single_geometry<true>
+{};
+
+template <typename MultiPoint, typename MultiPolygon>
+struct within<MultiPoint, MultiPolygon, multi_point_tag, multi_polygon_tag>
+    : public detail::within::multi_point_multi_geometry<true>
+{};
+
+// L/L
+
+template <typename Linestring1, typename Linestring2>
+struct within<Linestring1, Linestring2, linestring_tag, linestring_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename Linestring, typename MultiLinestring>
+struct within<Linestring, MultiLinestring, linestring_tag, multi_linestring_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename MultiLinestring, typename Linestring>
+struct within<MultiLinestring, Linestring, multi_linestring_tag, linestring_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename MultiLinestring1, typename MultiLinestring2>
+struct within<MultiLinestring1, MultiLinestring2, multi_linestring_tag, multi_linestring_tag>
+    : public detail::within::use_relate
+{};
+
+// L/A
+
+template <typename Linestring, typename Ring>
+struct within<Linestring, Ring, linestring_tag, ring_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename MultiLinestring, typename Ring>
+struct within<MultiLinestring, Ring, multi_linestring_tag, ring_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename Linestring, typename Polygon>
+struct within<Linestring, Polygon, linestring_tag, polygon_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename MultiLinestring, typename Polygon>
+struct within<MultiLinestring, Polygon, multi_linestring_tag, polygon_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename Linestring, typename MultiPolygon>
+struct within<Linestring, MultiPolygon, linestring_tag, multi_polygon_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename MultiLinestring, typename MultiPolygon>
+struct within<MultiLinestring, MultiPolygon, multi_linestring_tag, multi_polygon_tag>
+    : public detail::within::use_relate
+{};
+
+// A/A
+
+template <typename Ring1, typename Ring2>
+struct within<Ring1, Ring2, ring_tag, ring_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename Ring, typename Polygon>
+struct within<Ring, Polygon, ring_tag, polygon_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename Polygon, typename Ring>
+struct within<Polygon, Ring, polygon_tag, ring_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename Polygon1, typename Polygon2>
+struct within<Polygon1, Polygon2, polygon_tag, polygon_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename Ring, typename MultiPolygon>
+struct within<Ring, MultiPolygon, ring_tag, multi_polygon_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename MultiPolygon, typename Ring>
+struct within<MultiPolygon, Ring, multi_polygon_tag, ring_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename Polygon, typename MultiPolygon>
+struct within<Polygon, MultiPolygon, polygon_tag, multi_polygon_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename MultiPolygon, typename Polygon>
+struct within<MultiPolygon, Polygon, multi_polygon_tag, polygon_tag>
+    : public detail::within::use_relate
+{};
+
+template <typename MultiPolygon1, typename MultiPolygon2>
+struct within<MultiPolygon1, MultiPolygon2, multi_polygon_tag, multi_polygon_tag>
+    : public detail::within::use_relate
+{};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+#include <boost/geometry/index/rtree.hpp>
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_IMPLEMENTATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/within/interface.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/within/interface.hpp
new file mode 100644
index 00000000000..23263604c27
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/within/interface.hpp
@@ -0,0 +1,304 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2013, 2014, 2017.
+// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_INTERFACE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_INTERFACE_HPP
+
+
+#include <boost/concept_check.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/strategies/concepts/within_concept.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/strategies/within.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename Tag1 = typename tag<Geometry1>::type,
+    typename Tag2 = typename tag<Geometry2>::type
+>
+struct within
+    : not_implemented<Tag1, Tag2>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_strategy
+{
+
+struct within
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        concepts::within::check
+            <
+                typename tag<Geometry1>::type,
+                typename tag<Geometry2>::type,
+                typename tag_cast<typename tag<Geometry2>::type, areal_tag>::type,
+                Strategy
+            >();
+
+        return dispatch::within<Geometry1, Geometry2>::apply(geometry1, geometry2, strategy);
+    }
+
+    template <typename Geometry1, typename Geometry2>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             default_strategy)
+    {
+        typedef typename strategy::within::services::default_strategy
+            <
+                Geometry1,
+                Geometry2
+            >::type strategy_type;
+
+        return apply(geometry1, geometry2, strategy_type());
+    }
+};
+
+} // namespace resolve_strategy
+
+
+namespace resolve_variant
+{
+
+template <typename Geometry1, typename Geometry2>
+struct within
+{
+    template <typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Strategy const& strategy)
+    {
+        concepts::check<Geometry1 const>();
+        concepts::check<Geometry2 const>();
+        assert_dimension_equal<Geometry1, Geometry2>();
+
+        return resolve_strategy::within::apply(geometry1,
+                                               geometry2,
+                                               strategy);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
+struct within<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
+{
+    template <typename Strategy>
+    struct visitor: boost::static_visitor<bool>
+    {
+        Geometry2 const& m_geometry2;
+        Strategy const& m_strategy;
+
+        visitor(Geometry2 const& geometry2, Strategy const& strategy)
+            : m_geometry2(geometry2)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Geometry1>
+        bool operator()(Geometry1 const& geometry1) const
+        {
+            return within<Geometry1, Geometry2>::apply(geometry1,
+                                                       m_geometry2,
+                                                       m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline bool
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
+          Geometry2 const& geometry2,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(geometry2, strategy),
+                                    geometry1);
+    }
+};
+
+template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct within<Geometry1, boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Strategy>
+    struct visitor: boost::static_visitor<bool>
+    {
+        Geometry1 const& m_geometry1;
+        Strategy const& m_strategy;
+
+        visitor(Geometry1 const& geometry1, Strategy const& strategy)
+            : m_geometry1(geometry1)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Geometry2>
+        bool operator()(Geometry2 const& geometry2) const
+        {
+            return within<Geometry1, Geometry2>::apply(m_geometry1,
+                                                       geometry2,
+                                                       m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline bool
+    apply(Geometry1 const& geometry1,
+          boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(geometry1, strategy),
+                                    geometry2
+        );
+    }
+};
+
+template <
+    BOOST_VARIANT_ENUM_PARAMS(typename T1),
+    BOOST_VARIANT_ENUM_PARAMS(typename T2)
+>
+struct within<
+    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)>,
+    boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)>
+>
+{
+    template <typename Strategy>
+    struct visitor: boost::static_visitor<bool>
+    {
+        Strategy const& m_strategy;
+
+        visitor(Strategy const& strategy): m_strategy(strategy) {}
+
+        template <typename Geometry1, typename Geometry2>
+        bool operator()(Geometry1 const& geometry1,
+                        Geometry2 const& geometry2) const
+        {
+            return within<Geometry1, Geometry2>::apply(geometry1,
+                                                       geometry2,
+                                                       m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline bool
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T1)> const& geometry1,
+          boost::variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(strategy),
+                                    geometry1,
+                                    geometry2);
+    }
+};
+
+}
+
+
+/*!
+\brief \brief_check12{is completely inside}
+\ingroup within
+\details \details_check12{within, is completely inside}.
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry which might be within the second geometry
+\param geometry2 \param_geometry which might contain the first geometry
+\return true if geometry1 is completely contained within geometry2,
+    else false
+\note The default strategy is used for within detection
+
+
+\qbk{[include reference/algorithms/within.qbk]}
+
+\qbk{
+[heading Example]
+[within]
+[within_output]
+}
+ */
+template<typename Geometry1, typename Geometry2>
+inline bool within(Geometry1 const& geometry1, Geometry2 const& geometry2)
+{
+    return resolve_variant::within
+        <
+            Geometry1,
+            Geometry2
+        >::apply(geometry1, geometry2, default_strategy());
+}
+
+/*!
+\brief \brief_check12{is completely inside} \brief_strategy
+\ingroup within
+\details \details_check12{within, is completely inside}, \brief_strategy. \details_strategy_reasons
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry which might be within the second geometry
+\param geometry2 \param_geometry which might contain the first geometry
+\param strategy strategy to be used
+\return true if geometry1 is completely contained within geometry2,
+    else false
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/within.qbk]}
+\qbk{
+[heading Available Strategies]
+\* [link geometry.reference.strategies.strategy_within_winding Winding (coordinate system agnostic)]
+\* [link geometry.reference.strategies.strategy_within_franklin Franklin (cartesian)]
+\* [link geometry.reference.strategies.strategy_within_crossings_multiply Crossings Multiply (cartesian)]
+
+[heading Example]
+[within_strategy]
+[within_strategy_output]
+
+}
+*/
+template<typename Geometry1, typename Geometry2, typename Strategy>
+inline bool within(Geometry1 const& geometry1,
+                   Geometry2 const& geometry2,
+                   Strategy const& strategy)
+{
+    return resolve_variant::within
+        <
+            Geometry1,
+            Geometry2
+        >::apply(geometry1, geometry2, strategy);
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_INTERFACE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/within/multi_point.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/within/multi_point.hpp
new file mode 100644
index 00000000000..7e85f333832
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/within/multi_point.hpp
@@ -0,0 +1,268 @@
+// Boost.Geometry
+
+// Copyright (c) 2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_MULTI_POINT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_MULTI_POINT_HPP
+
+
+#include <algorithm>
+#include <vector>
+
+#include <boost/range.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/geometry/algorithms/detail/disjoint/box_box.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/point_box.hpp>
+#include <boost/geometry/algorithms/detail/expand_by_epsilon.hpp>
+#include <boost/geometry/algorithms/detail/relate/less.hpp>
+#include <boost/geometry/algorithms/detail/within/point_in_geometry.hpp>
+#include <boost/geometry/algorithms/envelope.hpp>
+#include <boost/geometry/algorithms/detail/partition.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/box.hpp>
+
+#include <boost/geometry/index/rtree.hpp>
+
+#include <boost/geometry/strategies/covered_by.hpp>
+#include <boost/geometry/strategies/disjoint.hpp>
+
+
+namespace boost { namespace geometry {
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace within {
+
+struct multi_point_point
+{
+    template <typename MultiPoint, typename Point, typename Strategy>
+    static inline bool apply(MultiPoint const& multi_point,
+                             Point const& point,
+                             Strategy const& strategy)
+    {
+        typedef typename boost::range_const_iterator<MultiPoint>::type iterator;
+        for ( iterator it = boost::begin(multi_point) ; it != boost::end(multi_point) ; ++it )
+        {
+            if (! strategy.apply(*it, point))
+            {
+                return false;
+            }
+        }
+
+        // all points of MultiPoint inside Point
+        return true;
+    }
+};
+
+// NOTE: currently the strategy is ignored, math::equals() is used inside relate::less
+struct multi_point_multi_point
+{
+    template <typename MultiPoint1, typename MultiPoint2, typename Strategy>
+    static inline bool apply(MultiPoint1 const& multi_point1,
+                             MultiPoint2 const& multi_point2,
+                             Strategy const& /*strategy*/)
+    {
+        typedef typename boost::range_value<MultiPoint2>::type point2_type;
+
+        relate::less const less = relate::less();
+
+        std::vector<point2_type> points2(boost::begin(multi_point2), boost::end(multi_point2));
+        std::sort(points2.begin(), points2.end(), less);
+
+        bool result = false;
+
+        typedef typename boost::range_const_iterator<MultiPoint1>::type iterator;
+        for ( iterator it = boost::begin(multi_point1) ; it != boost::end(multi_point1) ; ++it )
+        {
+            if (! std::binary_search(points2.begin(), points2.end(), *it, less))
+            {
+                return false;
+            }
+            else
+            {
+                result = true;
+            }
+        }
+
+        return result;
+    }
+};
+
+
+// TODO: the complexity could be lesser
+//   the second geometry could be "prepared"/sorted
+// For Linear geometries partition could be used
+// For Areal geometries point_in_geometry() would have to call the winding
+//   strategy differently, currently it linearly calls the strategy for each
+//   segment. So the segments would have to be sorted in a way consistent with
+//   the strategy and then the strategy called only for the segments in range.
+template <bool Within>
+struct multi_point_single_geometry
+{
+    template <typename MultiPoint, typename LinearOrAreal, typename Strategy>
+    static inline bool apply(MultiPoint const& multi_point,
+                             LinearOrAreal const& linear_or_areal,
+                             Strategy const& strategy)
+    {
+        typedef typename boost::range_value<MultiPoint>::type point1_type;
+        typedef typename point_type<LinearOrAreal>::type point2_type;
+        typedef model::box<point2_type> box2_type;
+
+        // Create envelope of geometry
+        box2_type box;
+        geometry::envelope(linear_or_areal, box, strategy.get_envelope_strategy());
+        geometry::detail::expand_by_epsilon(box);
+
+        typedef typename strategy::covered_by::services::default_strategy
+            <
+                point1_type, box2_type
+            >::type point_in_box_type;
+
+        // Test each Point with envelope and then geometry if needed
+        // If in the exterior, break
+        bool result = false;
+
+        typedef typename boost::range_const_iterator<MultiPoint>::type iterator;
+        for ( iterator it = boost::begin(multi_point) ; it != boost::end(multi_point) ; ++it )
+        {
+            int in_val = 0;
+
+            // exterior of box and of geometry
+            if (! point_in_box_type::apply(*it, box)
+                || (in_val = point_in_geometry(*it, linear_or_areal, strategy)) < 0)
+            {
+                result = false;
+                break;
+            }
+
+            // interior : interior/boundary
+            if (Within ? in_val > 0 : in_val >= 0)
+            {
+                result = true;
+            }
+        }
+
+        return result;
+    }
+};
+
+
+// TODO: same here, probably the complexity could be lesser
+template <bool Within>
+struct multi_point_multi_geometry
+{
+    template <typename MultiPoint, typename LinearOrAreal, typename Strategy>
+    static inline bool apply(MultiPoint const& multi_point,
+                             LinearOrAreal const& linear_or_areal,
+                             Strategy const& strategy)
+    {
+        typedef typename point_type<LinearOrAreal>::type point2_type;
+        typedef model::box<point2_type> box2_type;
+        static const bool is_linear = is_same
+            <
+                typename tag_cast
+                    <
+                        typename tag<LinearOrAreal>::type,
+                        linear_tag
+                    >::type,
+                linear_tag
+            >::value;
+
+        typename Strategy::envelope_strategy_type const
+            envelope_strategy = strategy.get_envelope_strategy();
+
+        // TODO: box pairs could be constructed on the fly, inside the rtree
+
+        // Prepare range of envelopes and ids
+        std::size_t count2 = boost::size(linear_or_areal);
+        typedef std::pair<box2_type, std::size_t> box_pair_type;
+        typedef std::vector<box_pair_type> box_pair_vector;
+        box_pair_vector boxes(count2);
+        for (std::size_t i = 0 ; i < count2 ; ++i)
+        {
+            geometry::envelope(linear_or_areal, boxes[i].first, envelope_strategy);
+            geometry::detail::expand_by_epsilon(boxes[i].first);
+            boxes[i].second = i;
+        }
+
+        // Create R-tree
+        index::rtree<box_pair_type, index::rstar<4> > rtree(boxes.begin(), boxes.end());
+
+        // For each point find overlapping envelopes and test corresponding single geometries
+        // If a point is in the exterior break
+        bool result = false;
+
+        typedef typename boost::range_const_iterator<MultiPoint>::type iterator;
+        for ( iterator it = boost::begin(multi_point) ; it != boost::end(multi_point) ; ++it )
+        {
+            // TODO: investigate the possibility of using satisfies
+            // TODO: investigate the possibility of using iterative queries (optimization below)
+            box_pair_vector inters_boxes;
+            rtree.query(index::intersects(*it), std::back_inserter(inters_boxes));
+
+            bool found_interior = false;
+            bool found_boundary = false;
+            int boundaries = 0;
+
+            typedef typename box_pair_vector::const_iterator iterator;
+            for ( iterator box_it = inters_boxes.begin() ; box_it != inters_boxes.end() ; ++box_it )
+            {
+                int in_val = point_in_geometry(*it, range::at(linear_or_areal, box_it->second), strategy);
+
+                if (in_val > 0)
+                    found_interior = true;
+                else if (in_val == 0)
+                    ++boundaries;
+
+                // If the result was set previously (interior or
+                // interior/boundary found) the only thing that needs to be
+                // done for other points is to make sure they're not
+                // overlapping the exterior no need to analyse boundaries.
+                if (result && in_val >= 0)
+                {
+                    break;
+                }
+            }
+
+            if ( boundaries > 0)
+            {
+                if (is_linear && boundaries % 2 == 0)
+                    found_interior = true;
+                else
+                    found_boundary = true;
+            }
+
+            // exterior
+            if (! found_interior && ! found_boundary)
+            {
+                result = false;
+                break;
+            }
+
+            // interior : interior/boundary
+            if (Within ? found_interior : (found_interior || found_boundary))
+            {
+                result = true;
+            }
+        }
+
+        return result;
+    }
+};
+
+}} // namespace detail::within
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_MULTI_POINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/within/point_in_geometry.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/within/point_in_geometry.hpp
new file mode 100644
index 00000000000..a24f4d21e26
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/within/point_in_geometry.hpp
@@ -0,0 +1,391 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013, 2014, 2015, 2017.
+// Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_POINT_IN_GEOMETRY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_POINT_IN_GEOMETRY_HPP
+
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/range.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+#include <boost/geometry/algorithms/detail/interior_iterator.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/strategies/concepts/within_concept.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/strategies/relate.hpp>
+
+#include <boost/geometry/util/range.hpp>
+#include <boost/geometry/views/detail/normalized_view.hpp>
+
+namespace boost { namespace geometry {
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace within {
+
+
+// TODO: is this needed?
+inline int check_result_type(int result)
+{
+    return result;
+}
+
+template <typename T>
+inline T check_result_type(T result)
+{
+    BOOST_GEOMETRY_ASSERT(false);
+    return result;
+}
+
+template <typename Point, typename Range, typename Strategy> inline
+int point_in_range(Point const& point, Range const& range, Strategy const& strategy)
+{
+    boost::ignore_unused(strategy);
+
+    typedef typename boost::range_iterator<Range const>::type iterator_type;
+    typename Strategy::state_type state;
+    iterator_type it = boost::begin(range);
+    iterator_type end = boost::end(range);
+
+    for ( iterator_type previous = it++ ; it != end ; ++previous, ++it )
+    {
+        if ( ! strategy.apply(point, *previous, *it, state) )
+        {
+            break;
+        }
+    }
+
+    return check_result_type(strategy.result(state));
+}
+
+template <typename Geometry, typename Point, typename Range>
+inline int point_in_range(Point const& point, Range const& range)
+{
+    typedef typename strategy::point_in_geometry::services::default_strategy
+        <
+            Point, Geometry
+        >::type strategy_type;
+
+    return point_in_range(point, range, strategy_type());
+}
+
+}} // namespace detail::within
+
+namespace detail_dispatch { namespace within {
+
+// checks the relation between a point P and geometry G
+// returns 1 if P is in the interior of G
+// returns 0 if P is on the boundry of G
+// returns -1 if P is in the exterior of G
+
+template <typename Geometry,
+          typename Tag = typename geometry::tag<Geometry>::type>
+struct point_in_geometry
+    : not_implemented<Tag>
+{};
+
+template <typename Point2>
+struct point_in_geometry<Point2, point_tag>
+{
+    template <typename Point1, typename Strategy> static inline
+    int apply(Point1 const& point1, Point2 const& point2, Strategy const& strategy)
+    {
+        boost::ignore_unused(strategy);
+        return strategy.apply(point1, point2) ? 1 : -1;
+    }
+};
+
+template <typename Segment>
+struct point_in_geometry<Segment, segment_tag>
+{
+    template <typename Point, typename Strategy> static inline
+    int apply(Point const& point, Segment const& segment, Strategy const& strategy)
+    {
+        boost::ignore_unused(strategy);
+
+        typedef typename geometry::point_type<Segment>::type point_type;
+        point_type p0, p1;
+// TODO: don't copy points
+        detail::assign_point_from_index<0>(segment, p0);
+        detail::assign_point_from_index<1>(segment, p1);
+
+        typename Strategy::state_type state;
+        strategy.apply(point, p0, p1, state);
+        int r = detail::within::check_result_type(strategy.result(state));
+
+        if ( r != 0 )
+            return -1; // exterior
+
+        // if the point is equal to the one of the terminal points
+        if ( detail::equals::equals_point_point(point, p0)
+          || detail::equals::equals_point_point(point, p1) )
+            return 0; // boundary
+        else
+            return 1; // interior
+    }
+};
+
+
+template <typename Linestring>
+struct point_in_geometry<Linestring, linestring_tag>
+{
+    template <typename Point, typename Strategy> static inline
+    int apply(Point const& point, Linestring const& linestring, Strategy const& strategy)
+    {
+        std::size_t count = boost::size(linestring);
+        if ( count > 1 )
+        {
+            if ( detail::within::point_in_range(point, linestring, strategy) != 0 )
+                return -1; // exterior
+
+            // if the linestring doesn't have a boundary
+            if (detail::equals::equals_point_point(range::front(linestring), range::back(linestring)))
+                return 1; // interior
+            // else if the point is equal to the one of the terminal points
+            else if (detail::equals::equals_point_point(point, range::front(linestring))
+                || detail::equals::equals_point_point(point, range::back(linestring)))
+                return 0; // boundary
+            else
+                return 1; // interior
+        }
+// TODO: for now degenerated linestrings are ignored
+//       throw an exception here?
+        /*else if ( count == 1 )
+        {
+            if ( detail::equals::equals_point_point(point, range::front(linestring)) )
+                return 1;
+        }*/
+
+        return -1; // exterior
+    }
+};
+
+template <typename Ring>
+struct point_in_geometry<Ring, ring_tag>
+{
+    template <typename Point, typename Strategy> static inline
+    int apply(Point const& point, Ring const& ring, Strategy const& strategy)
+    {
+        if ( boost::size(ring) < core_detail::closure::minimum_ring_size
+                                    <
+                                        geometry::closure<Ring>::value
+                                    >::value )
+        {
+            return -1;
+        }
+
+        detail::normalized_view<Ring const> view(ring);
+        return detail::within::point_in_range(point, view, strategy);
+    }
+};
+
+// Polygon: in exterior ring, and if so, not within interior ring(s)
+template <typename Polygon>
+struct point_in_geometry<Polygon, polygon_tag>
+{
+    template <typename Point, typename Strategy>
+    static inline int apply(Point const& point, Polygon const& polygon,
+                            Strategy const& strategy)
+    {
+        int const code = point_in_geometry
+            <
+                typename ring_type<Polygon>::type
+            >::apply(point, exterior_ring(polygon), strategy);
+
+        if (code == 1)
+        {
+            typename interior_return_type<Polygon const>::type
+                rings = interior_rings(polygon);
+            
+            for (typename detail::interior_iterator<Polygon const>::type
+                 it = boost::begin(rings);
+                 it != boost::end(rings);
+                 ++it)
+            {
+                int const interior_code = point_in_geometry
+                    <
+                        typename ring_type<Polygon>::type
+                    >::apply(point, *it, strategy);
+
+                if (interior_code != -1)
+                {
+                    // If 0, return 0 (touch)
+                    // If 1 (inside hole) return -1 (outside polygon)
+                    // If -1 (outside hole) check other holes if any
+                    return -interior_code;
+                }
+            }
+        }
+        return code;
+    }
+};
+
+template <typename Geometry>
+struct point_in_geometry<Geometry, multi_point_tag>
+{
+    template <typename Point, typename Strategy> static inline
+    int apply(Point const& point, Geometry const& geometry, Strategy const& strategy)
+    {
+        typedef typename boost::range_value<Geometry>::type point_type;
+        typedef typename boost::range_const_iterator<Geometry>::type iterator;
+        for ( iterator it = boost::begin(geometry) ; it != boost::end(geometry) ; ++it )
+        {
+            int pip = point_in_geometry<point_type>::apply(point, *it, strategy);
+
+            //BOOST_GEOMETRY_ASSERT(pip != 0);
+            if ( pip > 0 ) // inside
+                return 1;
+        }
+
+        return -1; // outside
+    }
+};
+
+template <typename Geometry>
+struct point_in_geometry<Geometry, multi_linestring_tag>
+{
+    template <typename Point, typename Strategy> static inline
+    int apply(Point const& point, Geometry const& geometry, Strategy const& strategy)
+    {
+        int pip = -1; // outside
+
+        typedef typename boost::range_value<Geometry>::type linestring_type;
+        typedef typename boost::range_value<linestring_type>::type point_type;
+        typedef typename boost::range_iterator<Geometry const>::type iterator;
+        iterator it = boost::begin(geometry);
+        for ( ; it != boost::end(geometry) ; ++it )
+        {
+            pip = point_in_geometry<linestring_type>::apply(point, *it, strategy);
+
+            // inside or on the boundary
+            if ( pip >= 0 )
+            {
+                ++it;
+                break;
+            }
+        }
+
+        // outside
+        if ( pip < 0 )
+            return -1;
+
+        // TODO: the following isn't needed for covered_by()
+
+        unsigned boundaries = pip == 0 ? 1 : 0;
+
+        for ( ; it != boost::end(geometry) ; ++it )
+        {
+            if ( boost::size(*it) < 2 )
+                continue;
+
+            point_type const& front = range::front(*it);
+            point_type const& back = range::back(*it);
+
+            // is closed_ring - no boundary
+            if ( detail::equals::equals_point_point(front, back) )
+                continue;
+
+            // is point on boundary
+            if ( detail::equals::equals_point_point(point, front)
+              || detail::equals::equals_point_point(point, back) )
+            {
+                ++boundaries;
+            }
+        }
+
+        // if the number of boundaries is odd, the point is on the boundary
+        return boundaries % 2 ? 0 : 1;
+    }
+};
+
+template <typename Geometry>
+struct point_in_geometry<Geometry, multi_polygon_tag>
+{
+    template <typename Point, typename Strategy> static inline
+    int apply(Point const& point, Geometry const& geometry, Strategy const& strategy)
+    {
+        // For invalid multipolygons
+        //int res = -1; // outside
+
+        typedef typename boost::range_value<Geometry>::type polygon_type;
+        typedef typename boost::range_const_iterator<Geometry>::type iterator;
+        for ( iterator it = boost::begin(geometry) ; it != boost::end(geometry) ; ++it )
+        {
+            int pip = point_in_geometry<polygon_type>::apply(point, *it, strategy);
+
+            // inside or on the boundary
+            if ( pip >= 0 )
+                return pip;
+
+            // For invalid multi-polygons
+            //if ( 1 == pip ) // inside polygon
+            //    return 1;
+            //else if ( res < pip ) // point must be inside at least one polygon
+            //    res = pip;
+        }
+
+        return -1; // for valid multipolygons
+        //return res; // for invalid multipolygons
+    }
+};
+
+}} // namespace detail_dispatch::within
+
+namespace detail { namespace within {
+
+// 1 - in the interior
+// 0 - in the boundry
+// -1 - in the exterior
+template <typename Point, typename Geometry, typename Strategy>
+inline int point_in_geometry(Point const& point, Geometry const& geometry, Strategy const& strategy)
+{
+    concepts::within::check
+        <
+            typename tag<Point>::type,
+            typename tag<Geometry>::type,
+            typename tag_cast<typename tag<Geometry>::type, areal_tag>::type,
+            Strategy
+        >();
+
+    return detail_dispatch::within::point_in_geometry<Geometry>::apply(point, geometry, strategy);
+}
+
+template <typename Point, typename Geometry>
+inline int point_in_geometry(Point const& point, Geometry const& geometry)
+{
+    typedef typename strategy::point_in_geometry::services::default_strategy
+        <
+            Point, Geometry
+        >::type strategy_type;
+
+    return point_in_geometry(point, geometry, strategy_type());
+}
+
+}} // namespace detail::within
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_POINT_IN_GEOMETRY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/within/within_no_turns.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/within/within_no_turns.hpp
new file mode 100644
index 00000000000..8da05e58fd8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/detail/within/within_no_turns.hpp
@@ -0,0 +1,221 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2013.
+// Modifications copyright (c) 2013, Oracle and/or its affiliates.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_WITHIN_NO_TURNS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_WITHIN_NO_TURNS_HPP
+
+#include <boost/geometry/algorithms/detail/point_on_border.hpp>
+#include <boost/geometry/algorithms/detail/within/point_in_geometry.hpp>
+
+namespace boost { namespace geometry {
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail_dispatch { namespace within {
+
+// returns true if G1 is within G2
+// this function should be called only if there are no intersection points
+// otherwise it may return invalid result
+// e.g. when non-first point of G1 is outside G2 or when some rings of G1 are the same as rings of G2
+
+template <typename Geometry1,
+          typename Geometry2,
+          typename Tag1 = typename geometry::tag<Geometry1>::type,
+          typename Tag2 = typename geometry::tag<Geometry2>::type>
+struct within_no_turns
+{
+    template <typename Strategy> static inline
+    bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        typedef typename geometry::point_type<Geometry1>::type point1_type;
+        point1_type p;
+        if ( !geometry::point_on_border(p, geometry1) )
+            return false;
+
+        return detail::within::point_in_geometry(p, geometry2, strategy) >= 0;
+    }
+};
+
+template <typename Geometry1, typename Geometry2>
+struct within_no_turns<Geometry1, Geometry2, ring_tag, polygon_tag>
+{
+    template <typename Strategy> static inline
+    bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        typedef typename geometry::point_type<Geometry1>::type point1_type;
+        typedef typename geometry::point_type<Geometry2>::type point2_type;
+        point1_type p;
+        if ( !geometry::point_on_border(p, geometry1) )
+            return false;
+        // check if one of ring points is outside the polygon
+        if ( detail::within::point_in_geometry(p, geometry2, strategy) < 0 )
+            return false;
+        // Now check if holes of G2 aren't inside G1
+        typedef typename boost::range_const_iterator
+            <
+                typename geometry::interior_type<Geometry2>::type
+            >::type iterator;
+        for ( iterator it = boost::begin(geometry::interior_rings(geometry2)) ;
+              it != boost::end(geometry::interior_rings(geometry2)) ;
+              ++it )
+        {
+            point2_type p;
+            if ( !geometry::point_on_border(p, *it) )
+                return false;
+            if ( detail::within::point_in_geometry(p, geometry1, strategy) > 0 )
+                return false;
+        }
+        return true;
+    }
+};
+
+template <typename Geometry1, typename Geometry2>
+struct within_no_turns<Geometry1, Geometry2, polygon_tag, polygon_tag>
+{
+    template <typename Strategy> static inline
+    bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        typedef typename geometry::point_type<Geometry1>::type point1_type;
+        typedef typename geometry::point_type<Geometry2>::type point2_type;
+        point1_type p;
+        if ( !geometry::point_on_border(p, geometry1) )
+            return false;
+        // check if one of ring points is outside the polygon
+        if ( detail::within::point_in_geometry(p, geometry2, strategy) < 0 )
+            return false;
+        // Now check if holes of G2 aren't inside G1
+        typedef typename boost::range_const_iterator
+            <
+                typename geometry::interior_type<Geometry2>::type
+            >::type iterator2;
+        for ( iterator2 it = boost::begin(geometry::interior_rings(geometry2)) ;
+              it != boost::end(geometry::interior_rings(geometry2)) ;
+              ++it )
+        {
+            point2_type p2;
+            if ( !geometry::point_on_border(p2, *it) )
+                return false;
+            // if the hole of G2 is inside G1
+            if ( detail::within::point_in_geometry(p2, geometry1, strategy) > 0 )
+            {
+                // if it's also inside one of the G1 holes, it's ok
+                bool ok = false;
+                typedef typename boost::range_const_iterator
+                    <
+                        typename geometry::interior_type<Geometry1>::type
+                    >::type iterator1;
+                for ( iterator1 it1 = boost::begin(geometry::interior_rings(geometry1)) ;
+                      it1 != boost::end(geometry::interior_rings(geometry1)) ;
+                      ++it1 )
+                {
+                    if ( detail::within::point_in_geometry(p2, *it1, strategy) < 0 )
+                    {
+                        ok = true;
+                        break;
+                    }
+                }
+                if ( !ok )
+                    return false;
+            }
+        }
+        return true;
+    }
+};
+
+template <typename Geometry1,
+          typename Geometry2,
+          typename Tag1 = typename geometry::tag<Geometry1>::type,
+          typename Tag2 = typename geometry::tag<Geometry2>::type,
+          bool IsMulti1 = boost::is_base_of<geometry::multi_tag, Tag1>::value,
+          bool IsMulti2 = boost::is_base_of<geometry::multi_tag, Tag2>::value>
+struct within_no_turns_multi
+{
+    template <typename Strategy> static inline
+    bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        return within_no_turns<Geometry1, Geometry2>::apply(geometry1, geometry2, strategy);
+    }
+};
+
+template <typename Geometry1, typename Geometry2, typename Tag1, typename Tag2>
+struct within_no_turns_multi<Geometry1, Geometry2, Tag1, Tag2, true, false>
+{
+    template <typename Strategy> static inline
+    bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        // All values of G1 must be inside G2
+        typedef typename boost::range_value<Geometry1>::type subgeometry1;
+        typedef typename boost::range_const_iterator<Geometry1>::type iterator;
+        for ( iterator it = boost::begin(geometry1) ; it != boost::end(geometry1) ; ++it )
+        {
+            if ( !within_no_turns<subgeometry1, Geometry2>::apply(*it, geometry2, strategy) )
+                return false;
+        }
+        return true;
+    }
+};
+
+template <typename Geometry1, typename Geometry2, typename Tag1, typename Tag2>
+struct within_no_turns_multi<Geometry1, Geometry2, Tag1, Tag2, false, true>
+{
+    template <typename Strategy> static inline
+    bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        // G1 must be within at least one value of G2
+        typedef typename boost::range_value<Geometry2>::type subgeometry2;
+        typedef typename boost::range_const_iterator<Geometry2>::type iterator;
+        for ( iterator it = boost::begin(geometry2) ; it != boost::end(geometry2) ; ++it )
+        {
+            if ( within_no_turns<Geometry1, subgeometry2>::apply(geometry1, *it, strategy) )
+                return true;
+        }
+        return false;
+    }
+};
+
+template <typename Geometry1, typename Geometry2, typename Tag1, typename Tag2>
+struct within_no_turns_multi<Geometry1, Geometry2, Tag1, Tag2, true, true>
+{
+    template <typename Strategy> static inline
+    bool apply(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+    {
+        // each value of G1 must be inside at least one value of G2
+        typedef typename boost::range_value<Geometry1>::type subgeometry1;
+        typedef typename boost::range_const_iterator<Geometry1>::type iterator;
+        for ( iterator it = boost::begin(geometry1) ; it != boost::end(geometry1) ; ++it )
+        {
+            if ( !within_no_turns_multi<subgeometry1, Geometry2>::apply(*it, geometry2, strategy) )
+                return false;
+        }
+        return true;
+    }
+};
+
+}} // namespace detail_dispatch::within
+
+namespace detail { namespace within {
+
+template <typename Geometry1, typename Geometry2, typename Strategy>
+inline bool within_no_turns(Geometry1 const& geometry1, Geometry2 const& geometry2, Strategy const& strategy)
+{
+    return detail_dispatch::within::within_no_turns_multi<Geometry1, Geometry2>::apply(geometry1, geometry2, strategy);
+}
+
+}} // namespace detail::within
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DETAIL_WITHIN_WITHIN_NO_TURNS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/difference.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/difference.hpp
new file mode 100644
index 00000000000..c11ceca2434
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/difference.hpp
@@ -0,0 +1,406 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DIFFERENCE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DIFFERENCE_HPP
+
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/intersection_insert.hpp>
+#include <boost/geometry/policies/robustness/get_rescale_policy.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/util/range.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace difference
+{
+
+/*!
+\brief_calc2{difference} \brief_strategy
+\ingroup difference
+\details \details_calc2{difference_insert, spatial set theoretic difference}
+    \brief_strategy. \details_inserter{difference}
+\tparam GeometryOut output geometry type, must be specified
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam OutputIterator output iterator
+\tparam Strategy \tparam_strategy_overlay
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param out \param_out{difference}
+\param strategy \param_strategy{difference}
+\return \return_out
+
+\qbk{distinguish,with strategy}
+*/
+template
+<
+    typename GeometryOut,
+    typename Geometry1,
+    typename Geometry2,
+    typename RobustPolicy,
+    typename OutputIterator,
+    typename Strategy
+>
+inline OutputIterator difference_insert(Geometry1 const& geometry1,
+                                        Geometry2 const& geometry2,
+                                        RobustPolicy const& robust_policy,
+                                        OutputIterator out,
+                                        Strategy const& strategy)
+{
+    concepts::check<Geometry1 const>();
+    concepts::check<Geometry2 const>();
+    concepts::check<GeometryOut>();
+
+    return geometry::dispatch::intersection_insert
+        <
+            Geometry1, Geometry2,
+            GeometryOut,
+            overlay_difference,
+            geometry::detail::overlay::do_reverse<geometry::point_order<Geometry1>::value>::value,
+            geometry::detail::overlay::do_reverse<geometry::point_order<Geometry2>::value, true>::value
+        >::apply(geometry1, geometry2, robust_policy, out, strategy);
+}
+
+/*!
+\brief_calc2{difference}
+\ingroup difference
+\details \details_calc2{difference_insert, spatial set theoretic difference}.
+    \details_insert{difference}
+\tparam GeometryOut output geometry type, must be specified
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam OutputIterator output iterator
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param out \param_out{difference}
+\return \return_out
+
+\qbk{[include reference/algorithms/difference_insert.qbk]}
+*/
+template
+<
+    typename GeometryOut,
+    typename Geometry1,
+    typename Geometry2,
+    typename RobustPolicy,
+    typename OutputIterator
+>
+inline OutputIterator difference_insert(Geometry1 const& geometry1,
+                                        Geometry2 const& geometry2,
+                                        RobustPolicy const& robust_policy,
+                                        OutputIterator out)
+{
+    typedef typename strategy::relate::services::default_strategy
+        <
+            Geometry1,
+            Geometry2
+        >::type strategy_type;
+
+    return difference_insert<GeometryOut>(geometry1, geometry2,
+                                          robust_policy, out, strategy_type());
+}
+
+
+}} // namespace detail::difference
+#endif // DOXYGEN_NO_DETAIL
+
+
+namespace resolve_strategy {
+
+struct difference
+{
+    template
+    <
+        typename Geometry1,
+        typename Geometry2,
+        typename RobustPolicy,
+        typename Collection,
+        typename Strategy
+    >
+    static inline void apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             RobustPolicy const& robust_policy,
+                             Collection & output_collection,
+                             Strategy const& strategy)
+    {
+        typedef typename boost::range_value<Collection>::type geometry_out;
+
+        detail::difference::difference_insert<geometry_out>(
+            geometry1, geometry2, robust_policy,
+            range::back_inserter(output_collection),
+            strategy);
+    }
+
+    template
+    <
+        typename Geometry1,
+        typename Geometry2,
+        typename RobustPolicy,
+        typename Collection
+    >
+    static inline void apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             RobustPolicy const& robust_policy,
+                             Collection & output_collection,
+                             default_strategy)
+    {
+        typedef typename boost::range_value<Collection>::type geometry_out;
+        
+        detail::difference::difference_insert<geometry_out>(
+            geometry1, geometry2, robust_policy,
+            range::back_inserter(output_collection));
+    }
+};
+
+} // resolve_strategy
+
+
+namespace resolve_variant
+{
+    
+template <typename Geometry1, typename Geometry2>
+struct difference
+{
+    template <typename Collection, typename Strategy>
+    static inline void apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Collection& output_collection,
+                             Strategy const& strategy)
+    {
+        typedef typename geometry::rescale_overlay_policy_type
+            <
+                Geometry1,
+                Geometry2
+            >::type rescale_policy_type;
+
+        rescale_policy_type robust_policy
+                = geometry::get_rescale_policy<rescale_policy_type>(geometry1,
+                                                                    geometry2);
+        
+        resolve_strategy::difference::apply(geometry1, geometry2,
+                                            robust_policy,
+                                            output_collection,
+                                            strategy);
+    }
+};
+
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
+struct difference<variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
+{
+    template <typename Collection, typename Strategy>
+    struct visitor: static_visitor<>
+    {
+        Geometry2 const& m_geometry2;
+        Collection& m_output_collection;
+        Strategy const& m_strategy;
+        
+        visitor(Geometry2 const& geometry2,
+                Collection& output_collection,
+                Strategy const& strategy)
+            : m_geometry2(geometry2)
+            , m_output_collection(output_collection)
+            , m_strategy(strategy)
+        {}
+        
+        template <typename Geometry1>
+        void operator()(Geometry1 const& geometry1) const
+        {
+            difference
+                <
+                    Geometry1,
+                    Geometry2
+                >::apply(geometry1, m_geometry2, m_output_collection, m_strategy);
+        }
+    };
+    
+    template <typename Collection, typename Strategy>
+    static inline void
+    apply(variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
+          Geometry2 const& geometry2,
+          Collection& output_collection,
+          Strategy const& strategy)
+    {
+        boost::apply_visitor(visitor<Collection, Strategy>(geometry2,
+                                                           output_collection,
+                                                           strategy),
+                             geometry1);
+    }
+};
+
+
+template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct difference<Geometry1, variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Collection, typename Strategy>
+    struct visitor: static_visitor<>
+    {
+        Geometry1 const& m_geometry1;
+        Collection& m_output_collection;
+        Strategy const& m_strategy;
+        
+        visitor(Geometry1 const& geometry1,
+                Collection& output_collection,
+                Strategy const& strategy)
+            : m_geometry1(geometry1)
+            , m_output_collection(output_collection)
+            , m_strategy(strategy)
+        {}
+        
+        template <typename Geometry2>
+        void operator()(Geometry2 const& geometry2) const
+        {
+            difference
+                <
+                    Geometry1,
+                    Geometry2
+                >::apply(m_geometry1, geometry2, m_output_collection, m_strategy);
+        }
+    };
+    
+    template <typename Collection, typename Strategy>
+    static inline void
+    apply(Geometry1 const& geometry1,
+          variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2,
+          Collection& output_collection,
+          Strategy const& strategy)
+    {
+        boost::apply_visitor(visitor<Collection, Strategy>(geometry1,
+                                                           output_collection,
+                                                           strategy),
+                             geometry2);
+    }
+};
+
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T1), BOOST_VARIANT_ENUM_PARAMS(typename T2)>
+struct difference<variant<BOOST_VARIANT_ENUM_PARAMS(T1)>, variant<BOOST_VARIANT_ENUM_PARAMS(T2)> >
+{
+    template <typename Collection, typename Strategy>
+    struct visitor: static_visitor<>
+    {
+        Collection& m_output_collection;
+        Strategy const& m_strategy;
+        
+        visitor(Collection& output_collection, Strategy const& strategy)
+            : m_output_collection(output_collection)
+            , m_strategy(strategy)
+        {}
+        
+        template <typename Geometry1, typename Geometry2>
+        void operator()(Geometry1 const& geometry1,
+                        Geometry2 const& geometry2) const
+        {
+            difference
+                <
+                    Geometry1,
+                    Geometry2
+                >::apply(geometry1, geometry2, m_output_collection, m_strategy);
+        }
+    };
+    
+    template <typename Collection, typename Strategy>
+    static inline void
+    apply(variant<BOOST_VARIANT_ENUM_PARAMS(T1)> const& geometry1,
+          variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2,
+          Collection& output_collection,
+          Strategy const& strategy)
+    {
+        boost::apply_visitor(visitor<Collection, Strategy>(output_collection,
+                                                           strategy),
+                             geometry1, geometry2);
+    }
+};
+    
+} // namespace resolve_variant
+
+
+/*!
+\brief_calc2{difference}
+\ingroup difference
+\details \details_calc2{difference, spatial set theoretic difference}.
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Collection \tparam_output_collection
+\tparam Strategy \tparam_strategy{Difference}
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param output_collection the output collection
+\param strategy \param_strategy{difference}
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/difference.qbk]}
+*/
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename Collection,
+    typename Strategy
+>
+inline void difference(Geometry1 const& geometry1,
+                       Geometry2 const& geometry2,
+                       Collection& output_collection,
+                       Strategy const& strategy)
+{
+    resolve_variant::difference
+        <
+            Geometry1,
+            Geometry2
+        >::apply(geometry1, geometry2, output_collection, strategy);
+}
+
+
+/*!
+\brief_calc2{difference}
+\ingroup difference
+\details \details_calc2{difference, spatial set theoretic difference}.
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Collection \tparam_output_collection
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param output_collection the output collection
+
+\qbk{[include reference/algorithms/difference.qbk]}
+*/
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename Collection
+>
+inline void difference(Geometry1 const& geometry1,
+                       Geometry2 const& geometry2,
+                       Collection& output_collection)
+{
+    resolve_variant::difference
+        <
+            Geometry1,
+            Geometry2
+        >::apply(geometry1, geometry2, output_collection, default_strategy());
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DIFFERENCE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/disjoint.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/disjoint.hpp
new file mode 100644
index 00000000000..f997487c717
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/disjoint.hpp
@@ -0,0 +1,27 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013-2014.
+// Modifications copyright (c) 2013-2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DISJOINT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DISJOINT_HPP
+
+#include <boost/geometry/algorithms/detail/disjoint/interface.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/implementation.hpp>
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DISJOINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/disjoint.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/disjoint.hpp
new file mode 100644
index 00000000000..78015f1a550
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/disjoint.hpp
@@ -0,0 +1,93 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013-2017.
+// Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DISPATCH_DISJOINT_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DISPATCH_DISJOINT_HPP
+
+#include <cstddef>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/core/reverse_dispatch.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template
+<
+    typename Geometry1, typename Geometry2,
+    std::size_t DimensionCount = dimension<Geometry1>::type::value,
+    typename Tag1 = typename tag_cast
+        <
+            typename tag<Geometry1>::type,
+            segment_tag, box_tag, linear_tag, areal_tag
+        >::type,
+    typename Tag2 = typename tag_cast
+        <
+            typename tag<Geometry2>::type,
+            segment_tag, box_tag, linear_tag, areal_tag
+        >::type,
+    bool Reverse = reverse_dispatch<Geometry1, Geometry2>::type::value
+>
+struct disjoint
+    : not_implemented<Geometry1, Geometry2>
+{};
+
+
+// If reversal is needed, perform it
+template
+<
+    typename Geometry1, typename Geometry2,
+    std::size_t DimensionCount,
+    typename Tag1, typename Tag2
+>
+struct disjoint<Geometry1, Geometry2, DimensionCount, Tag1, Tag2, true>
+{
+    template <typename Strategy>
+    static inline bool apply(Geometry1 const& g1, Geometry2 const& g2, Strategy const& strategy)
+    {
+        return disjoint
+            <
+                Geometry2, Geometry1,
+                DimensionCount,
+                Tag2, Tag1
+            >::apply(g2, g1, strategy);
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DISPATCH_DISJOINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/distance.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/distance.hpp
new file mode 100644
index 00000000000..cae3ebd0c99
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/distance.hpp
@@ -0,0 +1,82 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DISPATCH_DISTANCE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DISPATCH_DISTANCE_HPP
+
+
+#include <boost/geometry/core/reverse_dispatch.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template
+<
+    typename Geometry1, typename Geometry2,
+    typename Strategy = typename detail::distance::default_strategy
+        <
+            Geometry1, Geometry2
+        >::type,
+    typename Tag1 = typename tag_cast
+        <
+            typename tag<Geometry1>::type,
+            segment_tag,
+            box_tag,
+            linear_tag,
+            areal_tag
+        >::type,
+    typename Tag2 = typename tag_cast
+        <
+            typename tag<Geometry2>::type,
+            segment_tag,
+            box_tag,
+            linear_tag,
+            areal_tag
+        >::type,
+    typename StrategyTag = typename strategy::distance::services::tag
+        <
+            Strategy
+        >::type,
+    bool Reverse = reverse_dispatch<Geometry1, Geometry2>::type::value
+>
+struct distance: not_implemented<Tag1, Tag2>
+{};
+
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DISPATCH_DISTANCE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/envelope.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/envelope.hpp
new file mode 100644
index 00000000000..bb8a99f5a83
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/envelope.hpp
@@ -0,0 +1,49 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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_GEOMETRY_ALGORITHMS_DISPATCH_ENVELOPE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DISPATCH_ENVELOPE_HPP
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/tag.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Geometry,
+    typename Tag = typename tag<Geometry>::type,
+    typename CS_Tag = typename cs_tag<Geometry>::type
+>
+struct envelope : not_implemented<Tag>
+{};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DISPATCH_ENVELOPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/expand.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/expand.hpp
new file mode 100644
index 00000000000..2c23d6a1ce7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/expand.hpp
@@ -0,0 +1,58 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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_GEOMETRY_ALGORITHMS_DISPATCH_EXPAND_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DISPATCH_EXPAND_HPP
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/tag.hpp>
+
+#include <boost/geometry/strategies/compare.hpp>
+#include <boost/geometry/policies/compare.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename GeometryOut, typename Geometry,
+    typename StrategyLess = strategy::compare::default_strategy,
+    typename StrategyGreater = strategy::compare::default_strategy,
+    typename TagOut = typename tag<GeometryOut>::type,
+    typename Tag = typename tag<Geometry>::type,
+    typename CSTagOut = typename cs_tag<GeometryOut>::type,
+    typename CSTag = typename cs_tag<Geometry>::type
+>
+struct expand : not_implemented<TagOut, Tag>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DISPATCH_EXPAND_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/is_simple.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/is_simple.hpp
new file mode 100644
index 00000000000..2ac92256b37
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/is_simple.hpp
@@ -0,0 +1,38 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DISPATCH_IS_SIMPLE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DISPATCH_IS_SIMPLE_HPP
+
+#include <boost/geometry/core/tag.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct is_simple
+    : not_implemented<Geometry>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DISPATCH_IS_SIMPLE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/is_valid.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/is_valid.hpp
new file mode 100644
index 00000000000..5d8108655c0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/dispatch/is_valid.hpp
@@ -0,0 +1,44 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DISPATCH_IS_VALID_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DISPATCH_IS_VALID_HPP
+
+#include <boost/geometry/core/tag.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template
+<
+    typename Geometry,
+    typename Tag = typename tag<Geometry>::type,
+    // for multi-geometries: determines if empty multi-geometries are allowed
+    bool AllowEmptyMultiGeometries = true
+>
+struct is_valid
+    : not_implemented<Geometry>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DISPATCH_IS_VALID_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/distance.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/distance.hpp
new file mode 100644
index 00000000000..dcfe597cd01
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/distance.hpp
@@ -0,0 +1,26 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_DISTANCE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_DISTANCE_HPP
+
+#include <boost/geometry/algorithms/detail/distance/interface.hpp>
+#include <boost/geometry/algorithms/detail/distance/implementation.hpp>
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_DISTANCE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/envelope.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/envelope.hpp
new file mode 100644
index 00000000000..00981224b21
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/envelope.hpp
@@ -0,0 +1,25 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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_GEOMETRY_ALGORITHMS_ENVELOPE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_ENVELOPE_HPP
+
+#include <boost/geometry/algorithms/detail/envelope/interface.hpp>
+#include <boost/geometry/algorithms/detail/envelope/implementation.hpp>
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_ENVELOPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/equals.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/equals.hpp
new file mode 100644
index 00000000000..77b8977d223
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/equals.hpp
@@ -0,0 +1,30 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014, 2015, 2016, 2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_EQUALS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_EQUALS_HPP
+
+
+#include <boost/geometry/algorithms/detail/equals/interface.hpp>
+#include <boost/geometry/algorithms/detail/equals/implementation.hpp>
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_EQUALS_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/expand.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/expand.hpp
new file mode 100644
index 00000000000..f41df53801d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/expand.hpp
@@ -0,0 +1,26 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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_GEOMETRY_ALGORITHMS_EXPAND_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_EXPAND_HPP
+
+#include <boost/geometry/algorithms/detail/expand/interface.hpp>
+#include <boost/geometry/algorithms/detail/expand/implementation.hpp>
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_EXPAND_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/for_each.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/for_each.hpp
new file mode 100644
index 00000000000..741dc359fe6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/for_each.hpp
@@ -0,0 +1,373 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_FOR_EACH_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_FOR_EACH_HPP
+
+
+#include <algorithm>
+
+#include <boost/range.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/geometry/algorithms/detail/interior_iterator.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/geometries/segment.hpp>
+
+#include <boost/geometry/util/add_const_if_c.hpp>
+#include <boost/geometry/util/range.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace for_each
+{
+
+
+struct fe_point_per_point
+{
+    template <typename Point, typename Functor>
+    static inline void apply(Point& point, Functor& f)
+    {
+        f(point);
+    }
+};
+
+
+struct fe_point_per_segment
+{
+    template <typename Point, typename Functor>
+    static inline void apply(Point& , Functor& /*f*/)
+    {
+        // TODO: if non-const, we should extract the points from the segment
+        // and call the functor on those two points
+    }
+};
+
+
+struct fe_range_per_point
+{
+    template <typename Range, typename Functor>
+    static inline void apply(Range& range, Functor& f)
+    {
+        // The previous implementation called the std library:
+        // return (std::for_each(boost::begin(range), boost::end(range), f));
+        // But that is not accepted for capturing lambda's.
+        // It needs to do it like that to return the state of Functor f (f is passed by value in std::for_each).
+
+        // So we now loop manually.
+
+        for (typename boost::range_iterator<Range>::type
+                it = boost::begin(range); it != boost::end(range); ++it)
+        {
+            f(*it);
+        }
+    }
+};
+
+
+template <closure_selector Closure>
+struct fe_range_per_segment_with_closure
+{
+    template <typename Range, typename Functor>
+    static inline void apply(Range& range, Functor& f)
+    {
+        typedef typename add_const_if_c
+            <
+                is_const<Range>::value,
+                typename point_type<Range>::type
+            >::type point_type;
+
+        typedef typename boost::range_iterator<Range>::type iterator_type;
+
+        iterator_type it = boost::begin(range);
+        iterator_type previous = it++;
+        while(it != boost::end(range))
+        {
+            model::referring_segment<point_type> s(*previous, *it);
+            f(s);
+            previous = it++;
+        }
+    }
+};
+
+
+template <>
+struct fe_range_per_segment_with_closure<open>
+{
+    template <typename Range, typename Functor>
+    static inline void apply(Range& range, Functor& f)
+    {    
+        fe_range_per_segment_with_closure<closed>::apply(range, f);
+
+        model::referring_segment
+            <
+                typename add_const_if_c
+                    <
+                        is_const<Range>::value,
+                        typename point_type<Range>::type
+                    >::type
+            > s(range::back(range), range::front(range));
+
+        f(s);
+    }
+};
+
+
+struct fe_range_per_segment
+{
+    template <typename Range, typename Functor>
+    static inline void apply(Range& range, Functor& f)
+    {
+        fe_range_per_segment_with_closure
+            <
+                closure<Range>::value
+            >::apply(range, f);
+    }
+};
+
+
+struct fe_polygon_per_point
+{
+    template <typename Polygon, typename Functor>
+    static inline void apply(Polygon& poly, Functor& f)
+    {
+        fe_range_per_point::apply(exterior_ring(poly), f);
+
+        typename interior_return_type<Polygon>::type
+            rings = interior_rings(poly);
+
+        for (typename detail::interior_iterator<Polygon>::type
+                it = boost::begin(rings); it != boost::end(rings); ++it)
+        {
+            fe_range_per_point::apply(*it, f);
+        }
+    }
+
+};
+
+struct fe_polygon_per_segment
+{
+    template <typename Polygon, typename Functor>
+    static inline void apply(Polygon& poly, Functor& f)
+    {
+        fe_range_per_segment::apply(exterior_ring(poly), f);
+
+        typename interior_return_type<Polygon>::type
+            rings = interior_rings(poly);
+
+        for (typename detail::interior_iterator<Polygon>::type
+                it = boost::begin(rings); it != boost::end(rings); ++it)
+        {
+            fe_range_per_segment::apply(*it, f);
+        }
+    }
+
+};
+
+// Implementation of multi, for both point and segment,
+// just calling the single version.
+template <typename Policy>
+struct for_each_multi
+{
+    template <typename MultiGeometry, typename Functor>
+    static inline void apply(MultiGeometry& multi, Functor& f)
+    {
+        for (typename boost::range_iterator<MultiGeometry>::type
+                it = boost::begin(multi); it != boost::end(multi); ++it)
+        {
+            Policy::apply(*it, f);
+        }
+    }
+};
+
+}} // namespace detail::for_each
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Geometry,
+    typename Tag = typename tag_cast<typename tag<Geometry>::type, multi_tag>::type
+>
+struct for_each_point: not_implemented<Tag>
+{};
+
+
+template <typename Point>
+struct for_each_point<Point, point_tag>
+    : detail::for_each::fe_point_per_point
+{};
+
+
+template <typename Linestring>
+struct for_each_point<Linestring, linestring_tag>
+    : detail::for_each::fe_range_per_point
+{};
+
+
+template <typename Ring>
+struct for_each_point<Ring, ring_tag>
+    : detail::for_each::fe_range_per_point
+{};
+
+
+template <typename Polygon>
+struct for_each_point<Polygon, polygon_tag>
+    : detail::for_each::fe_polygon_per_point
+{};
+
+
+template
+<
+    typename Geometry,
+    typename Tag = typename tag_cast<typename tag<Geometry>::type, multi_tag>::type
+>
+struct for_each_segment: not_implemented<Tag>
+{};
+
+template <typename Point>
+struct for_each_segment<Point, point_tag>
+    : detail::for_each::fe_point_per_segment
+{};
+
+
+template <typename Linestring>
+struct for_each_segment<Linestring, linestring_tag>
+    : detail::for_each::fe_range_per_segment
+{};
+
+
+template <typename Ring>
+struct for_each_segment<Ring, ring_tag>
+    : detail::for_each::fe_range_per_segment
+{};
+
+
+template <typename Polygon>
+struct for_each_segment<Polygon, polygon_tag>
+    : detail::for_each::fe_polygon_per_segment
+{};
+
+
+template <typename MultiGeometry>
+struct for_each_point<MultiGeometry, multi_tag>
+    : detail::for_each::for_each_multi
+        <
+            // Specify the dispatch of the single-version as policy
+            for_each_point
+                <
+                    typename add_const_if_c
+                        <
+                            is_const<MultiGeometry>::value,
+                            typename boost::range_value<MultiGeometry>::type
+                        >::type
+                >
+        >
+{};
+
+
+template <typename MultiGeometry>
+struct for_each_segment<MultiGeometry, multi_tag>
+    : detail::for_each::for_each_multi
+        <
+            // Specify the dispatch of the single-version as policy
+            for_each_segment
+                <
+                    typename add_const_if_c
+                        <
+                            is_const<MultiGeometry>::value,
+                            typename boost::range_value<MultiGeometry>::type
+                        >::type
+                >
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+/*!
+\brief \brf_for_each{point}
+\details \det_for_each{point}
+\ingroup for_each
+\param geometry \param_geometry
+\param f \par_for_each_f{point}
+\tparam Geometry \tparam_geometry
+\tparam Functor \tparam_functor
+
+\qbk{[include reference/algorithms/for_each_point.qbk]}
+\qbk{[heading Example]}
+\qbk{[for_each_point] [for_each_point_output]}
+\qbk{[for_each_point_const] [for_each_point_const_output]}
+*/
+template<typename Geometry, typename Functor>
+inline Functor for_each_point(Geometry& geometry, Functor f)
+{
+    concepts::check<Geometry>();
+
+    dispatch::for_each_point<Geometry>::apply(geometry, f);
+    return f;
+}
+
+
+/*!
+\brief \brf_for_each{segment}
+\details \det_for_each{segment}
+\ingroup for_each
+\param geometry \param_geometry
+\param f \par_for_each_f{segment}
+\tparam Geometry \tparam_geometry
+\tparam Functor \tparam_functor
+
+\qbk{[include reference/algorithms/for_each_segment.qbk]}
+\qbk{[heading Example]}
+\qbk{[for_each_segment_const] [for_each_segment_const_output]}
+*/
+template<typename Geometry, typename Functor>
+inline Functor for_each_segment(Geometry& geometry, Functor f)
+{
+    concepts::check<Geometry>();
+
+    dispatch::for_each_segment<Geometry>::apply(geometry, f);
+    return f;
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_FOR_EACH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/intersection.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/intersection.hpp
new file mode 100644
index 00000000000..0169f12db1d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/intersection.hpp
@@ -0,0 +1,22 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_INTERSECTION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_INTERSECTION_HPP
+
+
+#include <boost/geometry/algorithms/detail/intersection/interface.hpp>
+#include <boost/geometry/algorithms/detail/intersection/implementation.hpp>
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_INTERSECTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/intersects.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/intersects.hpp
new file mode 100644
index 00000000000..503ee1a10ae
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/intersects.hpp
@@ -0,0 +1,28 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2013-2017.
+// Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_INTERSECTS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_INTERSECTS_HPP
+
+
+#include <boost/geometry/algorithms/detail/intersects/interface.hpp>
+#include <boost/geometry/algorithms/detail/intersects/implementation.hpp>
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_INTERSECTS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/is_convex.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/is_convex.hpp
new file mode 100644
index 00000000000..4a9251b2706
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/is_convex.hpp
@@ -0,0 +1,224 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_IS_CONVEX_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_IS_CONVEX_HPP
+
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/iterators/ever_circling_iterator.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/strategies/side.hpp>
+#include <boost/geometry/views/detail/normalized_view.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace is_convex
+{
+
+struct ring_is_convex
+{
+    template <typename Ring, typename SideStrategy>
+    static inline bool apply(Ring const& ring, SideStrategy const& strategy)
+    {
+        std::size_t n = boost::size(ring);
+        if (boost::size(ring) < core_detail::closure::minimum_ring_size
+                                    <
+                                        geometry::closure<Ring>::value
+                                    >::value)
+        {
+            // (Too) small rings are considered as non-concave, is convex
+            return true;
+        }
+
+        // Walk in clockwise direction, consider ring as closed
+        // (though closure is not important in this algorithm - any dupped
+        //  point is skipped)
+        typedef detail::normalized_view<Ring const> view_type;
+        view_type view(ring);
+
+        typedef geometry::ever_circling_range_iterator<view_type const> it_type;
+        it_type previous(view);
+        it_type current(view);
+        current++;
+
+        std::size_t index = 1;
+        while (equals::equals_point_point(*current, *previous) && index < n)
+        {
+            current++;
+            index++;
+        }
+
+        if (index == n)
+        {
+            // All points are apparently equal
+            return true;
+        }
+
+        it_type next = current;
+        next++;
+        while (equals::equals_point_point(*current, *next))
+        {
+            next++;
+        }
+
+        // We have now three different points on the ring
+        // Walk through all points, use a counter because of the ever-circling
+        // iterator
+        for (std::size_t i = 0; i < n; i++)
+        {
+            int const side = strategy.apply(*previous, *current, *next);
+            if (side == 1)
+            {
+                // Next is on the left side of clockwise ring:
+                // the piece is not convex
+                return false;
+            }
+
+            previous = current;
+            current = next;
+
+            // Advance next to next different point
+            // (because there are non-equal points, this loop is not infinite)
+            next++;
+            while (equals::equals_point_point(*current, *next))
+            {
+                next++;
+            }
+        }
+        return true;
+    }
+};
+
+
+}} // namespace detail::is_convex
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Geometry,
+    typename Tag = typename tag<Geometry>::type
+>
+struct is_convex : not_implemented<Tag>
+{};
+
+template <typename Box>
+struct is_convex<Box, box_tag>
+{
+    template <typename Strategy>
+    static inline bool apply(Box const& , Strategy const& )
+    {
+        // Any box is convex (TODO: consider spherical boxes)
+        return true;
+    }
+};
+
+template <typename Box>
+struct is_convex<Box, ring_tag> : detail::is_convex::ring_is_convex
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+namespace resolve_variant {
+
+template <typename Geometry>
+struct is_convex
+{
+    template <typename Strategy>
+    static bool apply(Geometry const& geometry, Strategy const& strategy)
+    {
+        concepts::check<Geometry>();
+        return dispatch::is_convex<Geometry>::apply(geometry, strategy);
+    }
+
+    static bool apply(Geometry const& geometry, geometry::default_strategy const&)
+    {
+        typedef typename strategy::side::services::default_strategy
+            <
+                typename cs_tag<Geometry>::type
+            >::type side_strategy;
+
+        return apply(geometry, side_strategy());
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct is_convex<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Strategy>
+    struct visitor: boost::static_visitor<bool>
+    {
+        Strategy const& m_strategy;
+
+        visitor(Strategy const& strategy) : m_strategy(strategy) {}
+
+        template <typename Geometry>
+        bool operator()(Geometry const& geometry) const
+        {
+            return is_convex<Geometry>::apply(geometry, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline bool apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry,
+                             Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(strategy), geometry);
+    }
+};
+
+} // namespace resolve_variant
+
+// TODO: documentation / qbk
+template<typename Geometry>
+inline bool is_convex(Geometry const& geometry)
+{
+    return resolve_variant::is_convex
+            <
+                Geometry
+            >::apply(geometry, geometry::default_strategy());
+}
+
+// TODO: documentation / qbk
+template<typename Geometry, typename Strategy>
+inline bool is_convex(Geometry const& geometry, Strategy const& strategy)
+{
+    return resolve_variant::is_convex<Geometry>::apply(geometry, strategy);
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_IS_CONVEX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/is_empty.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/is_empty.hpp
new file mode 100644
index 00000000000..8dab69c8799
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/is_empty.hpp
@@ -0,0 +1,207 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_IS_EMPTY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_IS_EMPTY_HPP
+
+#include <boost/range.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/algorithms/detail/check_iterator_range.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace is_empty
+{
+
+struct always_not_empty
+{
+    template <typename Geometry>
+    static inline bool apply(Geometry const&)
+    {
+        return false;
+    }
+};
+
+struct range_is_empty
+{
+    template <typename Range>
+    static inline bool apply(Range const& range)
+    {
+        return boost::empty(range);
+    }
+};
+
+class polygon_is_empty
+{
+    template <typename InteriorRings>
+    static inline bool check_interior_rings(InteriorRings const& interior_rings)
+    {
+        return check_iterator_range
+            <
+                range_is_empty, true // allow empty range
+            >::apply(boost::begin(interior_rings), boost::end(interior_rings));
+    }
+
+public:
+    template <typename Polygon>
+    static inline bool apply(Polygon const& polygon)
+    {
+        return boost::empty(exterior_ring(polygon))
+            && check_interior_rings(interior_rings(polygon));
+    }
+};
+
+template <typename Policy = range_is_empty>
+struct multi_is_empty
+{
+    template <typename MultiGeometry>
+    static inline bool apply(MultiGeometry const& multigeometry)
+    {
+        return check_iterator_range
+            <
+                Policy, true // allow empty range
+            >::apply(boost::begin(multigeometry), boost::end(multigeometry));
+    }
+    
+};
+
+}} // namespace detail::is_empty
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Geometry, typename Tag =  typename tag<Geometry>::type>
+struct is_empty : not_implemented<Tag>
+{};
+
+template <typename Geometry>
+struct is_empty<Geometry, point_tag>
+    : detail::is_empty::always_not_empty
+{};
+
+template <typename Geometry>
+struct is_empty<Geometry, box_tag>
+    : detail::is_empty::always_not_empty
+{};
+
+template <typename Geometry>
+struct is_empty<Geometry, segment_tag>
+    : detail::is_empty::always_not_empty
+{};
+
+template <typename Geometry>
+struct is_empty<Geometry, linestring_tag>
+    : detail::is_empty::range_is_empty
+{};
+
+template <typename Geometry>
+struct is_empty<Geometry, ring_tag>
+    : detail::is_empty::range_is_empty
+{};
+
+template <typename Geometry>
+struct is_empty<Geometry, polygon_tag>
+    : detail::is_empty::polygon_is_empty
+{};
+
+template <typename Geometry>
+struct is_empty<Geometry, multi_point_tag>
+    : detail::is_empty::range_is_empty
+{};
+
+template <typename Geometry>
+struct is_empty<Geometry, multi_linestring_tag>
+    : detail::is_empty::multi_is_empty<>
+{};
+
+template <typename Geometry>
+struct is_empty<Geometry, multi_polygon_tag>
+    : detail::is_empty::multi_is_empty<detail::is_empty::polygon_is_empty>
+{};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_variant
+{
+
+template <typename Geometry>
+struct is_empty
+{
+    static inline bool apply(Geometry const& geometry)
+    {
+        concepts::check<Geometry const>();
+
+        return dispatch::is_empty<Geometry>::apply(geometry);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct is_empty<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    struct visitor : boost::static_visitor<bool>
+    {
+        template <typename Geometry>
+        inline bool operator()(Geometry const& geometry) const
+        {
+            return is_empty<Geometry>::apply(geometry);
+        }
+    };
+
+    static bool
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry)
+    {
+        return boost::apply_visitor(visitor(), geometry);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief \brief_check{is the empty set}
+\ingroup is_empty
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\return \return_check{is the empty set}
+
+\qbk{[include reference/algorithms/is_empty.qbk]}
+*/
+template <typename Geometry>
+inline bool is_empty(Geometry const& geometry)
+{
+    return resolve_variant::is_empty<Geometry>::apply(geometry);
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_IS_EMPTY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/is_simple.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/is_simple.hpp
new file mode 100644
index 00000000000..f48c957dfc9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/is_simple.hpp
@@ -0,0 +1,16 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_IS_SIMPLE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_IS_SIMPLE_HPP
+
+#include <boost/geometry/algorithms/detail/is_simple/interface.hpp>
+#include <boost/geometry/algorithms/detail/is_simple/implementation.hpp>
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_IS_SIMPLE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/is_valid.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/is_valid.hpp
new file mode 100644
index 00000000000..24dc5f77371
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/is_valid.hpp
@@ -0,0 +1,16 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_IS_VALID_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_IS_VALID_HPP
+
+#include <boost/geometry/algorithms/detail/is_valid/interface.hpp>
+#include <boost/geometry/algorithms/detail/is_valid/implementation.hpp>
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_IS_VALID_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/length.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/length.hpp
new file mode 100644
index 00000000000..39a567a26b1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/length.hpp
@@ -0,0 +1,296 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014, 2015.
+// Modifications copyright (c) 2014-2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_LENGTH_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_LENGTH_HPP
+
+#include <iterator>
+
+#include <boost/concept_check.hpp>
+#include <boost/core/ignore_unused.hpp>
+#include <boost/mpl/fold.hpp>
+#include <boost/mpl/greater.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/insert.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/set.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/transform.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/algorithms/detail/calculate_null.hpp>
+#include <boost/geometry/algorithms/detail/multi_sum.hpp>
+// #include <boost/geometry/algorithms/detail/throw_on_empty_input.hpp>
+#include <boost/geometry/views/closeable_view.hpp>
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/default_length_result.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace length
+{
+
+
+template<typename Segment>
+struct segment_length
+{
+    template <typename Strategy>
+    static inline typename default_length_result<Segment>::type apply(
+            Segment const& segment, Strategy const& strategy)
+    {
+        boost::ignore_unused(strategy);
+        typedef typename point_type<Segment>::type point_type;
+        point_type p1, p2;
+        geometry::detail::assign_point_from_index<0>(segment, p1);
+        geometry::detail::assign_point_from_index<1>(segment, p2);
+        return strategy.apply(p1, p2);
+    }
+};
+
+/*!
+\brief Internal, calculates length of a linestring using iterator pairs and
+    specified strategy
+\note for_each could be used here, now that point_type is changed by boost
+    range iterator
+*/
+template<typename Range, closure_selector Closure>
+struct range_length
+{
+    typedef typename default_length_result<Range>::type return_type;
+
+    template <typename Strategy>
+    static inline return_type apply(
+            Range const& range, Strategy const& strategy)
+    {
+        boost::ignore_unused(strategy);
+        typedef typename closeable_view<Range const, Closure>::type view_type;
+        typedef typename boost::range_iterator
+            <
+                view_type const
+            >::type iterator_type;
+
+        return_type sum = return_type();
+        view_type view(range);
+        iterator_type it = boost::begin(view), end = boost::end(view);
+        if(it != end)
+        {
+            for(iterator_type previous = it++;
+                    it != end;
+                    ++previous, ++it)
+            {
+                // Add point-point distance using the return type belonging
+                // to strategy
+                sum += strategy.apply(*previous, *it);
+            }
+        }
+
+        return sum;
+    }
+};
+
+
+}} // namespace detail::length
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct length : detail::calculate_null
+{
+    typedef typename default_length_result<Geometry>::type return_type;
+
+    template <typename Strategy>
+    static inline return_type apply(Geometry const& geometry, Strategy const& strategy)
+    {
+        return calculate_null::apply<return_type>(geometry, strategy);
+    }
+};
+
+
+template <typename Geometry>
+struct length<Geometry, linestring_tag>
+    : detail::length::range_length<Geometry, closed>
+{};
+
+
+// RING: length is currently 0; it might be argued that it is the "perimeter"
+
+
+template <typename Geometry>
+struct length<Geometry, segment_tag>
+    : detail::length::segment_length<Geometry>
+{};
+
+
+template <typename MultiLinestring>
+struct length<MultiLinestring, multi_linestring_tag> : detail::multi_sum
+{
+    template <typename Strategy>
+    static inline typename default_length_result<MultiLinestring>::type
+    apply(MultiLinestring const& multi, Strategy const& strategy)
+    {
+        return multi_sum::apply
+               <
+                   typename default_length_result<MultiLinestring>::type,
+                   detail::length::range_length
+                   <
+                       typename boost::range_value<MultiLinestring>::type,
+                       closed // no need to close it explicitly
+                   >
+               >(multi, strategy);
+
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_variant {
+
+template <typename Geometry>
+struct length
+{
+    template <typename Strategy>
+    static inline typename default_length_result<Geometry>::type
+    apply(Geometry const& geometry, Strategy const& strategy)
+    {
+        return dispatch::length<Geometry>::apply(geometry, strategy);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct length<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    typedef typename default_length_result
+        <
+            boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>
+        >::type result_type;
+
+    template <typename Strategy>
+    struct visitor
+        : static_visitor<result_type>
+    {
+        Strategy const& m_strategy;
+
+        visitor(Strategy const& strategy)
+            : m_strategy(strategy)
+        {}
+
+        template <typename Geometry>
+        inline typename default_length_result<Geometry>::type
+        operator()(Geometry const& geometry) const
+        {
+            return length<Geometry>::apply(geometry, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline result_type apply(
+        variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry,
+        Strategy const& strategy
+    )
+    {
+        return boost::apply_visitor(visitor<Strategy>(strategy), geometry);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief \brief_calc{length}
+\ingroup length
+\details \details_calc{length, length (the sum of distances between consecutive points)}. \details_default_strategy
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\return \return_calc{length}
+
+\qbk{[include reference/algorithms/length.qbk]}
+\qbk{[length] [length_output]}
+ */
+template<typename Geometry>
+inline typename default_length_result<Geometry>::type
+length(Geometry const& geometry)
+{
+    concepts::check<Geometry const>();
+
+    // detail::throw_on_empty_input(geometry);
+
+    // TODO put this into a resolve_strategy stage
+    typedef typename strategy::distance::services::default_strategy
+        <
+            point_tag, point_tag, typename point_type<Geometry>::type
+        >::type strategy_type;
+
+    return resolve_variant::length<Geometry>::apply(geometry, strategy_type());
+}
+
+
+/*!
+\brief \brief_calc{length} \brief_strategy
+\ingroup length
+\details \details_calc{length, length (the sum of distances between consecutive points)} \brief_strategy. \details_strategy_reasons
+\tparam Geometry \tparam_geometry
+\tparam Strategy \tparam_strategy{distance}
+\param geometry \param_geometry
+\param strategy \param_strategy{distance}
+\return \return_calc{length}
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/length.qbk]}
+\qbk{[length_with_strategy] [length_with_strategy_output]}
+ */
+template<typename Geometry, typename Strategy>
+inline typename default_length_result<Geometry>::type
+length(Geometry const& geometry, Strategy const& strategy)
+{
+    concepts::check<Geometry const>();
+
+    // detail::throw_on_empty_input(geometry);
+
+    return resolve_variant::length<Geometry>::apply(geometry, strategy);
+}
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_LENGTH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/make.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/make.hpp
new file mode 100644
index 00000000000..899d5489b73
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/make.hpp
@@ -0,0 +1,200 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_MAKE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_MAKE_HPP
+
+#include <boost/geometry/algorithms/assign.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace make
+{
+
+/*!
+\brief Construct a geometry
+\ingroup make
+\tparam Geometry \tparam_geometry
+\tparam Range \tparam_range_point
+\param range \param_range_point
+\return The constructed geometry, here: a linestring or a ring
+
+\qbk{distinguish, with a range}
+\qbk{
+[heading Example]
+[make_with_range] [make_with_range_output]
+
+[heading See also]
+\* [link geometry.reference.algorithms.assign.assign_points assign]
+}
+ */
+template <typename Geometry, typename Range>
+inline Geometry make_points(Range const& range)
+{
+    concepts::check<Geometry>();
+
+    Geometry geometry;
+    geometry::append(geometry, range);
+    return geometry;
+}
+
+}} // namespace detail::make
+#endif // DOXYGEN_NO_DETAIL
+
+/*!
+\brief Construct a geometry
+\ingroup make
+\details
+\note It does not work with array-point types, like int[2]
+\tparam Geometry \tparam_geometry
+\tparam Type \tparam_numeric to specify the coordinates
+\param c1 \param_x
+\param c2 \param_y
+\return The constructed geometry, here: a 2D point
+
+\qbk{distinguish, 2 coordinate values}
+\qbk{
+[heading Example]
+[make_2d_point] [make_2d_point_output]
+
+[heading See also]
+\* [link geometry.reference.algorithms.assign.assign_values_3_2_coordinate_values assign]
+}
+*/
+template <typename Geometry, typename Type>
+inline Geometry make(Type const& c1, Type const& c2)
+{
+    concepts::check<Geometry>();
+
+    Geometry geometry;
+    dispatch::assign
+        <
+            typename tag<Geometry>::type,
+            Geometry,
+            geometry::dimension<Geometry>::type::value
+        >::apply(geometry, c1, c2);
+    return geometry;
+}
+
+/*!
+\brief Construct a geometry
+\ingroup make
+\tparam Geometry \tparam_geometry
+\tparam Type \tparam_numeric to specify the coordinates
+\param c1 \param_x
+\param c2 \param_y
+\param c3 \param_z
+\return The constructed geometry, here: a 3D point
+
+\qbk{distinguish, 3 coordinate values}
+\qbk{
+[heading Example]
+[make_3d_point] [make_3d_point_output]
+
+[heading See also]
+\* [link geometry.reference.algorithms.assign.assign_values_4_3_coordinate_values assign]
+}
+ */
+template <typename Geometry, typename Type>
+inline Geometry make(Type const& c1, Type const& c2, Type const& c3)
+{
+    concepts::check<Geometry>();
+
+    Geometry geometry;
+    dispatch::assign
+        <
+            typename tag<Geometry>::type,
+            Geometry,
+            geometry::dimension<Geometry>::type::value
+        >::apply(geometry, c1, c2, c3);
+    return geometry;
+}
+
+template <typename Geometry, typename Type>
+inline Geometry make(Type const& c1, Type const& c2, Type const& c3, Type const& c4)
+{
+    concepts::check<Geometry>();
+
+    Geometry geometry;
+    dispatch::assign
+        <
+            typename tag<Geometry>::type,
+            Geometry,
+            geometry::dimension<Geometry>::type::value
+        >::apply(geometry, c1, c2, c3, c4);
+    return geometry;
+}
+
+
+
+
+
+/*!
+\brief Construct a box with inverse infinite coordinates
+\ingroup make
+\details The make_inverse function initializes a 2D or 3D box with large coordinates, the
+    min corner is very large, the max corner is very small. This is useful e.g. in combination
+    with the expand function, to determine the bounding box of a series of geometries.
+\tparam Geometry \tparam_geometry
+\return The constructed geometry, here: a box
+
+\qbk{
+[heading Example]
+[make_inverse] [make_inverse_output]
+
+[heading See also]
+\* [link geometry.reference.algorithms.assign.assign_inverse assign_inverse]
+}
+ */
+template <typename Geometry>
+inline Geometry make_inverse()
+{
+    concepts::check<Geometry>();
+
+    Geometry geometry;
+    dispatch::assign_inverse
+        <
+            typename tag<Geometry>::type,
+            Geometry
+        >::apply(geometry);
+    return geometry;
+}
+
+/*!
+\brief Construct a geometry with its coordinates initialized to zero
+\ingroup make
+\details The make_zero function initializes a 2D or 3D point or box with coordinates of zero
+\tparam Geometry \tparam_geometry
+\return The constructed and zero-initialized geometry
+ */
+template <typename Geometry>
+inline Geometry make_zero()
+{
+    concepts::check<Geometry>();
+
+    Geometry geometry;
+    dispatch::assign_zero
+        <
+            typename tag<Geometry>::type,
+            Geometry
+        >::apply(geometry);
+    return geometry;
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_MAKE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/not_implemented.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/not_implemented.hpp
new file mode 100644
index 00000000000..9c416074ed0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/not_implemented.hpp
@@ -0,0 +1,131 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_NOT_IMPLEMENTED_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_NOT_IMPLEMENTED_HPP
+
+
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace info
+{
+    struct UNRECOGNIZED_GEOMETRY_TYPE {};
+    struct POINT {};
+    struct LINESTRING {};
+    struct POLYGON {};
+    struct RING {};
+    struct BOX {};
+    struct SEGMENT {};
+    struct MULTI_POINT {};
+    struct MULTI_LINESTRING {};
+    struct MULTI_POLYGON {};
+    struct GEOMETRY_COLLECTION {};
+    template <size_t D> struct DIMENSION {};
+}
+
+
+namespace nyi
+{
+
+
+struct not_implemented_tag {};
+
+template
+<
+    typename Term1,
+    typename Term2,
+    typename Term3
+>
+struct not_implemented_error
+{
+
+#ifndef BOOST_GEOMETRY_IMPLEMENTATION_STATUS_BUILD
+# define BOOST_GEOMETRY_IMPLEMENTATION_STATUS_BUILD false
+#endif
+
+    BOOST_MPL_ASSERT_MSG
+        (
+            BOOST_GEOMETRY_IMPLEMENTATION_STATUS_BUILD,
+            THIS_OPERATION_IS_NOT_OR_NOT_YET_IMPLEMENTED,
+            (
+                types<Term1, Term2, Term3>
+            )
+        );
+};
+
+template <typename Tag>
+struct tag_to_term
+{
+    typedef Tag type;
+};
+
+template <> struct tag_to_term<geometry_not_recognized_tag> { typedef info::UNRECOGNIZED_GEOMETRY_TYPE type; };
+template <> struct tag_to_term<point_tag>                   { typedef info::POINT type; };
+template <> struct tag_to_term<linestring_tag>              { typedef info::LINESTRING type; };
+template <> struct tag_to_term<polygon_tag>                 { typedef info::POLYGON type; };
+template <> struct tag_to_term<ring_tag>                    { typedef info::RING type; };
+template <> struct tag_to_term<box_tag>                     { typedef info::BOX type; };
+template <> struct tag_to_term<segment_tag>                 { typedef info::SEGMENT type; };
+template <> struct tag_to_term<multi_point_tag>             { typedef info::MULTI_POINT type; };
+template <> struct tag_to_term<multi_linestring_tag>        { typedef info::MULTI_LINESTRING type; };
+template <> struct tag_to_term<multi_polygon_tag>           { typedef info::MULTI_POLYGON type; };
+template <> struct tag_to_term<geometry_collection_tag>     { typedef info::GEOMETRY_COLLECTION type; };
+template <int D> struct tag_to_term<boost::mpl::int_<D> >   { typedef info::DIMENSION<D> type; };
+
+
+}
+
+
+template
+<
+    typename Term1 = void,
+    typename Term2 = void,
+    typename Term3 = void
+>
+struct not_implemented
+    : nyi::not_implemented_tag,
+      nyi::not_implemented_error
+      <
+          typename boost::mpl::identity
+              <
+                  typename nyi::tag_to_term<Term1>::type
+              >::type,
+          typename boost::mpl::identity
+              <
+                  typename nyi::tag_to_term<Term2>::type
+              >::type,
+          typename boost::mpl::identity
+              <
+                  typename nyi::tag_to_term<Term3>::type
+              >::type
+      >
+{};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_NOT_IMPLEMENTED_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/num_geometries.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/num_geometries.hpp
new file mode 100644
index 00000000000..e122241fea4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/num_geometries.hpp
@@ -0,0 +1,141 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_NUM_GEOMETRIES_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_NUM_GEOMETRIES_HPP
+
+#include <cstddef>
+
+#include <boost/range.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/algorithms/detail/counting.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template
+<
+    typename Geometry,
+    typename Tag = typename tag_cast
+                            <
+                                typename tag<Geometry>::type,
+                                single_tag,
+                                multi_tag
+                            >::type
+>
+struct num_geometries: not_implemented<Tag>
+{};
+
+
+template <typename Geometry>
+struct num_geometries<Geometry, single_tag>
+    : detail::counting::other_count<1>
+{};
+
+
+template <typename MultiGeometry>
+struct num_geometries<MultiGeometry, multi_tag>
+{
+    static inline std::size_t apply(MultiGeometry const& multi_geometry)
+    {
+        return boost::size(multi_geometry);
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_variant
+{
+
+template <typename Geometry>
+struct num_geometries
+{
+    static inline std::size_t apply(Geometry const& geometry)
+    {
+        concepts::check<Geometry const>();
+
+        return dispatch::num_geometries<Geometry>::apply(geometry);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct num_geometries<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    struct visitor: boost::static_visitor<std::size_t>
+    {
+        template <typename Geometry>
+        inline std::size_t operator()(Geometry const& geometry) const
+        {
+            return num_geometries<Geometry>::apply(geometry);
+        }
+    };
+
+    static inline std::size_t
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry)
+    {
+        return boost::apply_visitor(visitor(), geometry);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief \brief_calc{number of geometries}
+\ingroup num_geometries
+\details \details_calc{num_geometries, number of geometries}.
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\return \return_calc{number of geometries}
+
+\qbk{[include reference/algorithms/num_geometries.qbk]}
+*/
+template <typename Geometry>
+inline std::size_t num_geometries(Geometry const& geometry)
+{
+    return resolve_variant::num_geometries<Geometry>::apply(geometry);
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_NUM_GEOMETRIES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/num_interior_rings.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/num_interior_rings.hpp
new file mode 100644
index 00000000000..b7531a3dd00
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/num_interior_rings.hpp
@@ -0,0 +1,142 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_NUM_INTERIOR_RINGS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_NUM_INTERIOR_RINGS_HPP
+
+#include <cstddef>
+
+#include <boost/range.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/core/interior_rings.hpp>
+
+#include <boost/geometry/algorithms/detail/counting.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct num_interior_rings
+    : detail::counting::other_count<0>
+{};
+
+
+
+template <typename Polygon>
+struct num_interior_rings<Polygon, polygon_tag>
+{
+    static inline std::size_t apply(Polygon const& polygon)
+    {
+        return boost::size(geometry::interior_rings(polygon));
+    }
+
+};
+
+
+template <typename MultiPolygon>
+struct num_interior_rings<MultiPolygon, multi_polygon_tag>
+    : detail::counting::multi_count
+        <
+            num_interior_rings
+                <
+                    typename boost::range_value<MultiPolygon const>::type
+                >
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_variant
+{
+
+template <typename Geometry>
+struct num_interior_rings
+{
+    static inline std::size_t apply(Geometry const& geometry)
+    {
+        concepts::check<Geometry const>();
+
+        return dispatch::num_interior_rings<Geometry>::apply(geometry);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct num_interior_rings<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    struct visitor: boost::static_visitor<std::size_t>
+    {
+        template <typename Geometry>
+        inline std::size_t operator()(Geometry const& geometry) const
+        {
+            return num_interior_rings<Geometry>::apply(geometry);
+        }
+    };
+
+    static inline std::size_t
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry)
+    {
+        return boost::apply_visitor(visitor(), geometry);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief \brief_calc{number of interior rings}
+\ingroup num_interior_rings
+\details \details_calc{num_interior_rings, number of interior rings}.
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\return \return_calc{number of interior rings}
+
+\qbk{[include reference/algorithms/num_interior_rings.qbk]}
+
+\note Defined by OGC as "numInteriorRing". To be consistent with "numPoints"
+    letter "s" is appended
+*/
+template <typename Geometry>
+inline std::size_t num_interior_rings(Geometry const& geometry)
+{
+    return resolve_variant::num_interior_rings<Geometry>::apply(geometry);
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_NUM_INTERIOR_RINGS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/num_points.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/num_points.hpp
new file mode 100644
index 00000000000..9ef77f271d6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/num_points.hpp
@@ -0,0 +1,211 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_NUM_POINTS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_NUM_POINTS_HPP
+
+#include <cstddef>
+
+#include <boost/mpl/size_t.hpp>
+
+#include <boost/range.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/algorithms/detail/counting.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+// Silence warning C4127: conditional expression is constant
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4127)
+#endif
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace num_points
+{
+
+
+template <bool AddForOpen>
+struct range_count
+{
+    template <typename Range>
+    static inline std::size_t apply(Range const& range)
+    {
+        std::size_t n = boost::size(range);
+        if (AddForOpen
+            && n > 0
+            && geometry::closure<Range>::value == open
+            )
+        {
+            return n + 1;
+        }
+        return n;
+    }
+};
+
+}} // namespace detail::num_points
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Geometry,
+    bool AddForOpen,
+    typename Tag = typename tag_cast
+        <
+            typename tag<Geometry>::type, multi_tag
+        >::type
+>
+struct num_points: not_implemented<Tag>
+{};
+
+template <typename Geometry, bool AddForOpen>
+struct num_points<Geometry, AddForOpen, point_tag>
+    : detail::counting::other_count<1>
+{};
+
+template <typename Geometry, bool AddForOpen>
+struct num_points<Geometry, AddForOpen, box_tag>
+    : detail::counting::other_count<(1 << geometry::dimension<Geometry>::value)>
+{};
+
+template <typename Geometry, bool AddForOpen>
+struct num_points<Geometry, AddForOpen, segment_tag>
+    : detail::counting::other_count<2>
+{};
+
+template <typename Geometry, bool AddForOpen>
+struct num_points<Geometry, AddForOpen, linestring_tag>
+    : detail::num_points::range_count<AddForOpen>
+{};
+
+template <typename Geometry, bool AddForOpen>
+struct num_points<Geometry, AddForOpen, ring_tag>
+    : detail::num_points::range_count<AddForOpen>
+{};
+
+template <typename Geometry, bool AddForOpen>
+struct num_points<Geometry, AddForOpen, polygon_tag>
+    : detail::counting::polygon_count
+        <
+            detail::num_points::range_count<AddForOpen>
+        >
+{};
+
+template <typename Geometry, bool AddForOpen>
+struct num_points<Geometry, AddForOpen, multi_tag>
+    : detail::counting::multi_count
+        <
+            num_points<typename boost::range_value<Geometry>::type, AddForOpen>
+        >
+{};
+
+} // namespace dispatch
+#endif
+
+
+namespace resolve_variant
+{
+
+template <typename Geometry>
+struct num_points
+{
+    static inline std::size_t apply(Geometry const& geometry,
+                                    bool add_for_open)
+    {
+        concepts::check<Geometry const>();
+
+        return add_for_open
+            ? dispatch::num_points<Geometry, true>::apply(geometry)
+            : dispatch::num_points<Geometry, false>::apply(geometry);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct num_points<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    struct visitor: boost::static_visitor<std::size_t>
+    {
+        bool m_add_for_open;
+
+        visitor(bool add_for_open): m_add_for_open(add_for_open) {}
+
+        template <typename Geometry>
+        inline std::size_t operator()(Geometry const& geometry) const
+        {
+            return num_points<Geometry>::apply(geometry, m_add_for_open);
+        }
+    };
+
+    static inline std::size_t
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry,
+          bool add_for_open)
+    {
+        return boost::apply_visitor(visitor(add_for_open), geometry);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief \brief_calc{number of points}
+\ingroup num_points
+\details \details_calc{num_points, number of points}.
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\param add_for_open add one for open geometries (i.e. polygon types which are not closed)
+\return \return_calc{number of points}
+
+\qbk{[include reference/algorithms/num_points.qbk]}
+*/
+template <typename Geometry>
+inline std::size_t num_points(Geometry const& geometry, bool add_for_open = false)
+{
+    return resolve_variant::num_points<Geometry>::apply(geometry, add_for_open);
+}
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_NUM_POINTS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/num_segments.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/num_segments.hpp
new file mode 100644
index 00000000000..86eb63fad54
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/num_segments.hpp
@@ -0,0 +1,204 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_NUM_SEGMENTS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_NUM_SEGMENTS_HPP
+
+#include <cstddef>
+
+#include <boost/mpl/size_t.hpp>
+#include <boost/mpl/times.hpp>
+
+#include <boost/range.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/algorithms/detail/counting.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace num_segments
+{
+
+
+struct range_count
+{
+    template <typename Range>
+    static inline std::size_t apply(Range const& range)
+    {
+        std::size_t n = boost::size(range);
+        if ( n <= 1 )
+        {
+            return 0;
+        }
+
+        return
+            geometry::closure<Range>::value == open
+            ?
+            n
+            :
+            static_cast<std::size_t>(n - 1);
+    }
+};
+
+}} // namespace detail::num_segments
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct num_segments
+    : not_implemented<Tag>
+{};
+
+template <typename Geometry>
+struct num_segments<Geometry, point_tag>
+    : detail::counting::other_count<0>
+{};
+
+// the number of segments (1-dimensional faces) of the hypercube is
+// given by the formula: d * 2^(d-1), where d is the dimension of the
+// hypercube; see also:
+//            http://en.wikipedia.org/wiki/Hypercube
+template <typename Geometry>
+struct num_segments<Geometry, box_tag>
+    : detail::counting::other_count
+        <
+            geometry::dimension<Geometry>::value
+            * (1 << (geometry::dimension<Geometry>::value - 1))
+        >
+{};
+
+template <typename Geometry>
+struct num_segments<Geometry, segment_tag>
+    : detail::counting::other_count<1>
+{};
+
+template <typename Geometry>
+struct num_segments<Geometry, linestring_tag>
+    : detail::num_segments::range_count
+{};
+
+template <typename Geometry>
+struct num_segments<Geometry, ring_tag>
+    : detail::num_segments::range_count
+{};
+
+template <typename Geometry>
+struct num_segments<Geometry, polygon_tag>
+    : detail::counting::polygon_count<detail::num_segments::range_count>
+{};
+
+template <typename Geometry>
+struct num_segments<Geometry, multi_point_tag>
+    : detail::counting::other_count<0>
+{};
+
+template <typename Geometry>
+struct num_segments<Geometry, multi_linestring_tag>
+    : detail::counting::multi_count
+        <
+            num_segments< typename boost::range_value<Geometry>::type>
+        >
+{};
+
+template <typename Geometry>
+struct num_segments<Geometry, multi_polygon_tag>
+    : detail::counting::multi_count
+        <
+            num_segments< typename boost::range_value<Geometry>::type>
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+
+namespace resolve_variant
+{
+
+
+template <typename Geometry>
+struct num_segments
+{
+    static inline std::size_t apply(Geometry const& geometry)
+    {
+        concepts::check<Geometry const>();
+
+        return dispatch::num_segments<Geometry>::apply(geometry);
+    }
+};
+
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct num_segments<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    struct visitor: boost::static_visitor<std::size_t>
+    {
+        template <typename Geometry>
+        inline std::size_t operator()(Geometry const& geometry) const
+        {
+            return num_segments<Geometry>::apply(geometry);
+        }
+    };
+
+    static inline std::size_t
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry)
+    {
+        return boost::apply_visitor(visitor(), geometry);
+    }
+};
+
+
+} // namespace resolve_variant
+
+
+
+/*!
+\brief \brief_calc{number of segments}
+\ingroup num_segments
+\details \details_calc{num_segments, number of segments}.
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\return \return_calc{number of segments}
+
+\qbk{[include reference/algorithms/num_segments.qbk]}
+*/
+template <typename Geometry>
+inline std::size_t num_segments(Geometry const& geometry)
+{
+    return resolve_variant::num_segments<Geometry>::apply(geometry);
+}
+
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_NUM_SEGMENTS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/overlaps.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/overlaps.hpp
new file mode 100644
index 00000000000..869a85ca983
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/overlaps.hpp
@@ -0,0 +1,27 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014, 2015, 2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_OVERLAPS_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_OVERLAPS_HPP
+
+
+#include <boost/geometry/algorithms/detail/overlaps/interface.hpp>
+#include <boost/geometry/algorithms/detail/overlaps/implementation.hpp>
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_OVERLAPS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/perimeter.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/perimeter.hpp
new file mode 100644
index 00000000000..47b0649727c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/perimeter.hpp
@@ -0,0 +1,229 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_PERIMETER_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_PERIMETER_HPP
+
+#include <boost/range/metafunctions.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/length.hpp>
+#include <boost/geometry/algorithms/detail/calculate_null.hpp>
+#include <boost/geometry/algorithms/detail/calculate_sum.hpp>
+#include <boost/geometry/algorithms/detail/multi_sum.hpp>
+// #include <boost/geometry/algorithms/detail/throw_on_empty_input.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/strategies/default_length_result.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+// Default perimeter is 0.0, specializations implement calculated values
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct perimeter : detail::calculate_null
+{
+    typedef typename default_length_result<Geometry>::type return_type;
+
+    template <typename Strategy>
+    static inline return_type apply(Geometry const& geometry, Strategy const& strategy)
+    {
+        return calculate_null::apply<return_type>(geometry, strategy);
+    }
+};
+
+template <typename Geometry>
+struct perimeter<Geometry, ring_tag>
+    : detail::length::range_length
+        <
+            Geometry,
+            closure<Geometry>::value
+        >
+{};
+
+template <typename Polygon>
+struct perimeter<Polygon, polygon_tag> : detail::calculate_polygon_sum
+{
+    typedef typename default_length_result<Polygon>::type return_type;
+    typedef detail::length::range_length
+                <
+                    typename ring_type<Polygon>::type,
+                    closure<Polygon>::value
+                > policy;
+
+    template <typename Strategy>
+    static inline return_type apply(Polygon const& polygon, Strategy const& strategy)
+    {
+        return calculate_polygon_sum::apply<return_type, policy>(polygon, strategy);
+    }
+};
+
+template <typename MultiPolygon>
+struct perimeter<MultiPolygon, multi_polygon_tag> : detail::multi_sum
+{
+    typedef typename default_length_result<MultiPolygon>::type return_type;
+
+    template <typename Strategy>
+    static inline return_type apply(MultiPolygon const& multi, Strategy const& strategy)
+    {
+        return multi_sum::apply
+               <
+                   return_type,
+                   perimeter<typename boost::range_value<MultiPolygon>::type>
+               >(multi, strategy);
+    }
+};
+
+
+// box,n-sphere: to be implemented
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_strategy {
+
+struct perimeter
+{
+    template <typename Geometry, typename Strategy>
+    static inline typename default_length_result<Geometry>::type
+    apply(Geometry const& geometry, Strategy const& strategy)
+    {
+        return dispatch::perimeter<Geometry>::apply(geometry, strategy);
+    }
+
+    template <typename Geometry>
+    static inline typename default_length_result<Geometry>::type
+    apply(Geometry const& geometry, default_strategy)
+    {
+        typedef typename strategy::distance::services::default_strategy
+            <
+                point_tag, point_tag, typename point_type<Geometry>::type
+            >::type strategy_type;
+
+        return dispatch::perimeter<Geometry>::apply(geometry, strategy_type());
+    }
+};
+
+} // namespace resolve_strategy
+
+
+namespace resolve_variant {
+
+template <typename Geometry>
+struct perimeter
+{
+    template <typename Strategy>
+    static inline typename default_length_result<Geometry>::type
+    apply(Geometry const& geometry, Strategy const& strategy)
+    {
+        concepts::check<Geometry const>();
+        return resolve_strategy::perimeter::apply(geometry, strategy);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct perimeter<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    typedef typename default_length_result
+        <
+            boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>
+        >::type result_type;
+
+    template <typename Strategy>
+    struct visitor: boost::static_visitor<result_type>
+    {
+        Strategy const& m_strategy;
+
+        visitor(Strategy const& strategy): m_strategy(strategy) {}
+
+        template <typename Geometry>
+        typename default_length_result<Geometry>::type
+        operator()(Geometry const& geometry) const
+        {
+            return perimeter<Geometry>::apply(geometry, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline result_type
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry,
+          Strategy const& strategy)
+    {
+        return boost::apply_visitor(visitor<Strategy>(strategy), geometry);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief \brief_calc{perimeter}
+\ingroup perimeter
+\details The function perimeter returns the perimeter of a geometry,
+    using the default distance-calculation-strategy
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\return \return_calc{perimeter}
+
+\qbk{[include reference/algorithms/perimeter.qbk]}
+ */
+template<typename Geometry>
+inline typename default_length_result<Geometry>::type perimeter(
+        Geometry const& geometry)
+{
+    // detail::throw_on_empty_input(geometry);
+    return resolve_variant::perimeter<Geometry>::apply(geometry, default_strategy());
+}
+
+/*!
+\brief \brief_calc{perimeter} \brief_strategy
+\ingroup perimeter
+\details The function perimeter returns the perimeter of a geometry,
+    using specified strategy
+\tparam Geometry \tparam_geometry
+\tparam Strategy \tparam_strategy{distance}
+\param geometry \param_geometry
+\param strategy strategy to be used for distance calculations.
+\return \return_calc{perimeter}
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/perimeter.qbk]}
+ */
+template<typename Geometry, typename Strategy>
+inline typename default_length_result<Geometry>::type perimeter(
+        Geometry const& geometry, Strategy const& strategy)
+{
+    // detail::throw_on_empty_input(geometry);
+    return resolve_variant::perimeter<Geometry>::apply(geometry, strategy);
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_PERIMETER_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/point_on_surface.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/point_on_surface.hpp
new file mode 100644
index 00000000000..3f4d0f4afe8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/point_on_surface.hpp
@@ -0,0 +1,365 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2013 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2013 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2013 Mateusz Loskot, London, UK.
+// Copyright (c) 2013 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014, 2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_POINT_ON_SURFACE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_POINT_ON_SURFACE_HPP
+
+
+#include <cstddef>
+
+#include <numeric>
+
+#include <boost/concept_check.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/algorithms/detail/extreme_points.hpp>
+
+#include <boost/geometry/strategies/cartesian/centroid_bashein_detmer.hpp>
+#include <boost/geometry/strategies/side.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace point_on_surface
+{
+
+template <typename CoordinateType, int Dimension>
+struct specific_coordinate_first
+{
+    CoordinateType const m_value_to_be_first;
+
+    inline specific_coordinate_first(CoordinateType value_to_be_skipped)
+        : m_value_to_be_first(value_to_be_skipped)
+    {}
+
+    template <typename Point>
+    inline bool operator()(Point const& lhs, Point const& rhs)
+    {
+        CoordinateType const lh = geometry::get<Dimension>(lhs);
+        CoordinateType const rh = geometry::get<Dimension>(rhs);
+
+        // If both lhs and rhs equal m_value_to_be_first,
+        // we should handle conform if lh < rh = FALSE
+        // The first condition meets that, keep it first
+        if (geometry::math::equals(rh, m_value_to_be_first))
+        {
+            // Handle conform lh < -INF, which is always false
+            return false;
+        }
+
+        if (geometry::math::equals(lh, m_value_to_be_first))
+        {
+            // Handle conform -INF < rh, which is always true
+            return true;
+        }
+
+        return lh < rh;
+    }
+};
+
+template <int Dimension, typename Collection, typename Value, typename Predicate>
+inline bool max_value(Collection const& collection, Value& the_max, Predicate const& predicate)
+{
+    bool first = true;
+    for (typename Collection::const_iterator it = collection.begin(); it != collection.end(); ++it)
+    {
+        if (! it->empty())
+        {
+            Value the_value = geometry::get<Dimension>(*std::max_element(it->begin(), it->end(), predicate));
+            if (first || the_value > the_max)
+            {
+                the_max = the_value;
+                first = false;
+            }
+        }
+    }
+    return ! first;
+}
+
+
+template <int Dimension, typename Value>
+struct select_below
+{
+    Value m_value;
+    inline select_below(Value const& v)
+        : m_value(v)
+    {}
+
+    template <typename Intruder>
+    inline bool operator()(Intruder const& intruder) const
+    {
+        if (intruder.empty())
+        {
+            return true;
+        }
+        Value max = geometry::get<Dimension>(*std::max_element(intruder.begin(), intruder.end(), detail::extreme_points::compare<Dimension>()));
+        return geometry::math::equals(max, m_value) || max < m_value;
+    }
+};
+
+template <int Dimension, typename Value>
+struct adapt_base
+{
+    Value m_value;
+    inline adapt_base(Value const& v)
+        : m_value(v)
+    {}
+
+    template <typename Intruder>
+    inline void operator()(Intruder& intruder) const
+    {
+        if (intruder.size() >= 3)
+        {
+            detail::extreme_points::move_along_vector<Dimension>(intruder, m_value);
+        }
+    }
+};
+
+template <int Dimension, typename Value>
+struct min_of_intruder
+{
+    template <typename Intruder>
+    inline bool operator()(Intruder const& lhs, Intruder const& rhs) const
+    {
+        Value lhs_min = geometry::get<Dimension>(*std::min_element(lhs.begin(), lhs.end(), detail::extreme_points::compare<Dimension>()));
+        Value rhs_min = geometry::get<Dimension>(*std::min_element(rhs.begin(), rhs.end(), detail::extreme_points::compare<Dimension>()));
+        return lhs_min < rhs_min;
+    }
+};
+
+
+template <typename Point, typename P>
+inline void calculate_average(Point& point, std::vector<P> const& points)
+{
+    typedef typename geometry::coordinate_type<Point>::type coordinate_type;
+    typedef typename std::vector<P>::const_iterator iterator_type;
+    typedef typename std::vector<P>::size_type size_type;
+
+    coordinate_type x = 0;
+    coordinate_type y = 0;
+
+    iterator_type end = points.end();
+    for ( iterator_type it = points.begin() ; it != end ; ++it)
+    {
+        x += geometry::get<0>(*it);
+        y += geometry::get<1>(*it);
+    }
+
+    size_type const count = points.size();
+    geometry::set<0>(point, x / count);
+    geometry::set<1>(point, y / count);
+}
+
+
+template <int Dimension, typename Extremes, typename Intruders, typename CoordinateType>
+inline void replace_extremes_for_self_tangencies(Extremes& extremes, Intruders& intruders, CoordinateType const& max_intruder)
+{
+    // This function handles self-tangencies.
+    // Self-tangencies use, as usual, the major part of code...
+
+    //        ___ e
+    //       /|\ \                                                            .
+    //      / | \ \                                                           .
+    //     /  |  \ \                                                          .
+    //    /   |   \ \                                                         .
+    //   / /\ |    \ \                                                        .
+    //     i2    i1
+
+    // The picture above shows the extreme (outside, "e") and two intruders ("i1","i2")
+    // Assume that "i1" is self-tangent with the extreme, in one point at the top
+    // Now the "penultimate" value is searched, this is is the top of i2
+    // Then everything including and below (this is "i2" here) is removed
+    // Then the base of "i1" and of "e" is adapted to this penultimate value
+    // It then looks like:
+
+    //      b ___ e
+    //       /|\ \                                                            .
+    //      / | \ \                                                           .
+    //     /  |  \ \                                                          .
+    //    /   |   \ \                                                         .
+    //   a    c i1
+
+    // Then intruders (here "i1" but there may be more) are sorted from left to right
+    // Finally points "a","b" and "c" (in this order) are selected as a new triangle.
+    // This triangle will have a centroid which is inside (assumed that intruders left segment
+    // is not equal to extremes left segment, but that polygon would be invalid)
+
+    // Find highest non-self tangent intrusion, if any
+    CoordinateType penultimate_value;
+    specific_coordinate_first<CoordinateType, Dimension> pu_compare(max_intruder);
+    if (max_value<Dimension>(intruders, penultimate_value, pu_compare))
+    {
+        // Throw away all intrusions <= this value, and of the kept one set this as base.
+        select_below<Dimension, CoordinateType> predicate(penultimate_value);
+        intruders.erase
+            (
+                std::remove_if(boost::begin(intruders), boost::end(intruders), predicate),
+                boost::end(intruders)
+            );
+        adapt_base<Dimension, CoordinateType> fe_predicate(penultimate_value);
+        // Sort from left to right (or bottom to top if Dimension=0)
+        std::for_each(boost::begin(intruders), boost::end(intruders), fe_predicate);
+
+        // Also adapt base of extremes
+        detail::extreme_points::move_along_vector<Dimension>(extremes, penultimate_value);
+    }
+    // Then sort in 1-Dim. Take first to calc centroid.
+    std::sort(boost::begin(intruders), boost::end(intruders), min_of_intruder<1 - Dimension, CoordinateType>());
+
+    Extremes triangle;
+    triangle.reserve(3);
+
+    // Make a triangle of first two points of extremes (the ramp, from left to right), and last point of first intruder (which goes from right to left)
+    std::copy(extremes.begin(), extremes.begin() + 2, std::back_inserter(triangle));
+    triangle.push_back(intruders.front().back());
+
+    // (alternatively we could use the last two points of extremes, and first point of last intruder...):
+    //// ALTERNATIVE: std::copy(extremes.rbegin(), extremes.rbegin() + 2, std::back_inserter(triangle));
+    //// ALTERNATIVE: triangle.push_back(intruders.back().front());
+
+    // Now replace extremes with this smaller subset, a triangle, such that centroid calculation will result in a point inside
+    extremes = triangle;
+}
+
+template <int Dimension, typename Geometry, typename Point, typename SideStrategy>
+inline bool calculate_point_on_surface(Geometry const& geometry, Point& point,
+                                       SideStrategy const& strategy)
+{
+    typedef typename geometry::point_type<Geometry>::type point_type;
+    typedef typename geometry::coordinate_type<Geometry>::type coordinate_type;
+    std::vector<point_type> extremes;
+
+    typedef std::vector<std::vector<point_type> > intruders_type;
+    intruders_type intruders;
+    geometry::extreme_points<Dimension>(geometry, extremes, intruders, strategy);
+
+    if (extremes.size() < 3)
+    {
+        return false;
+    }
+
+    // If there are intruders, find the max.
+    if (! intruders.empty())
+    {
+        coordinate_type max_intruder;
+        detail::extreme_points::compare<Dimension> compare;
+        if (max_value<Dimension>(intruders, max_intruder, compare))
+        {
+            coordinate_type max_extreme = geometry::get<Dimension>(*std::max_element(extremes.begin(), extremes.end(), detail::extreme_points::compare<Dimension>()));
+            if (max_extreme > max_intruder)
+            {
+                detail::extreme_points::move_along_vector<Dimension>(extremes, max_intruder);
+            }
+            else
+            {
+                replace_extremes_for_self_tangencies<Dimension>(extremes, intruders, max_intruder);
+            }
+        }
+    }
+
+    // Now calculate the average/centroid of the (possibly adapted) extremes
+    calculate_average(point, extremes);
+
+    return true;
+}
+
+}} // namespace detail::point_on_surface
+#endif // DOXYGEN_NO_DETAIL
+
+
+/*!
+\brief Assigns a Point guaranteed to lie on the surface of the Geometry
+\tparam Geometry geometry type. This also defines the type of the output point
+\param geometry Geometry to take point from
+\param point Point to assign
+\param strategy side strategy
+ */
+template <typename Geometry, typename Point, typename SideStrategy>
+inline void point_on_surface(Geometry const& geometry, Point & point,
+                             SideStrategy const& strategy)
+{
+    concepts::check<Point>();
+    concepts::check<Geometry const>();
+
+    // First try in Y-direction (which should always succeed for valid polygons)
+    if (! detail::point_on_surface::calculate_point_on_surface<1>(geometry, point, strategy))
+    {
+        // For invalid polygons, we might try X-direction
+        detail::point_on_surface::calculate_point_on_surface<0>(geometry, point, strategy);
+    }
+}
+
+/*!
+\brief Assigns a Point guaranteed to lie on the surface of the Geometry
+\tparam Geometry geometry type. This also defines the type of the output point
+\param geometry Geometry to take point from
+\param point Point to assign
+ */
+template <typename Geometry, typename Point>
+inline void point_on_surface(Geometry const& geometry, Point & point)
+{
+    typedef typename strategy::side::services::default_strategy
+        <
+            typename cs_tag<Geometry>::type
+        >::type strategy_type;
+
+    point_on_surface(geometry, point, strategy_type());
+}
+
+
+/*!
+\brief Returns point guaranteed to lie on the surface of the Geometry
+\tparam Geometry geometry type. This also defines the type of the output point
+\param geometry Geometry to take point from
+\param strategy side strategy
+\return The Point guaranteed to lie on the surface of the Geometry
+ */
+template<typename Geometry, typename SideStrategy>
+inline typename geometry::point_type<Geometry>::type
+return_point_on_surface(Geometry const& geometry, SideStrategy const& strategy)
+{
+    typename geometry::point_type<Geometry>::type result;
+    geometry::point_on_surface(geometry, result, strategy);
+    return result;
+}
+
+/*!
+\brief Returns point guaranteed to lie on the surface of the Geometry
+\tparam Geometry geometry type. This also defines the type of the output point
+\param geometry Geometry to take point from
+\return The Point guaranteed to lie on the surface of the Geometry
+ */
+template<typename Geometry>
+inline typename geometry::point_type<Geometry>::type
+return_point_on_surface(Geometry const& geometry)
+{
+    typename geometry::point_type<Geometry>::type result;
+    geometry::point_on_surface(geometry, result);
+    return result;
+}
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_POINT_ON_SURFACE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/relate.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/relate.hpp
new file mode 100644
index 00000000000..34733ec5962
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/relate.hpp
@@ -0,0 +1,17 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_RELATE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_RELATE_HPP
+
+#include <boost/geometry/algorithms/detail/relate/interface.hpp>
+#include <boost/geometry/algorithms/detail/relate/implementation.hpp>
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_RELATE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/relation.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/relation.hpp
new file mode 100644
index 00000000000..c3cf2f99f82
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/relation.hpp
@@ -0,0 +1,17 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_RELATION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_RELATION_HPP
+
+#include <boost/geometry/algorithms/detail/relation/interface.hpp>
+#include <boost/geometry/algorithms/detail/relation/implementation.hpp>
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_RELATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/remove_spikes.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/remove_spikes.hpp
new file mode 100644
index 00000000000..196b20c6a44
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/remove_spikes.hpp
@@ -0,0 +1,323 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2013 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2013 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2013 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_REMOVE_SPIKES_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_REMOVE_SPIKES_HPP
+
+#include <deque>
+
+#include <boost/range.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/point_order.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/algorithms/detail/point_is_spike_or_equal.hpp>
+#include <boost/geometry/algorithms/detail/interior_iterator.hpp>
+#include <boost/geometry/algorithms/clear.hpp>
+
+#include <boost/geometry/strategies/default_strategy.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+
+
+/*
+Remove spikes from a ring/polygon.
+Ring (having 8 vertices, including closing vertex)
++------+
+|      |
+|      +--+
+|      |  ^this "spike" is removed, can be located outside/inside the ring
++------+
+(the actualy determination if it is removed is done by a strategy)
+
+*/
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace remove_spikes
+{
+
+
+struct range_remove_spikes
+{
+    template <typename Range, typename SideStrategy>
+    static inline void apply(Range& range, SideStrategy const& strategy)
+    {
+        typedef typename point_type<Range>::type point_type;
+
+        std::size_t n = boost::size(range);
+        std::size_t const min_num_points = core_detail::closure::minimum_ring_size
+            <
+                geometry::closure<Range>::value
+            >::value - 1; // subtract one: a polygon with only one spike should result into one point
+        if (n < min_num_points)
+        {
+            return;
+        }
+
+        std::deque<point_type> cleaned;
+        for (typename boost::range_iterator<Range const>::type it = boost::begin(range);
+            it != boost::end(range); ++it)
+        {
+            // Add point
+            cleaned.push_back(*it);
+
+            while(cleaned.size() >= 3
+               && detail::point_is_spike_or_equal(cleaned.back(),
+                                                  *(cleaned.end() - 3),
+                                                  *(cleaned.end() - 2),
+                                                  strategy))
+            {
+                // Remove pen-ultimate point causing the spike (or which was equal)
+                cleaned.erase(cleaned.end() - 2);
+            }
+        }
+
+        // For a closed-polygon, remove closing point, this makes checking first point(s) easier and consistent
+        if ( BOOST_GEOMETRY_CONDITION(geometry::closure<Range>::value == geometry::closed) )
+        {
+            cleaned.pop_back();
+        }
+
+        bool found = false;
+        do
+        {
+            found = false;
+            // Check for spike in first point
+            int const penultimate = 2;
+            while(cleaned.size() >= 3
+               && detail::point_is_spike_or_equal(cleaned.front(),
+                                                  *(cleaned.end() - penultimate),
+                                                  cleaned.back(),
+                                                  strategy))
+            {
+                cleaned.pop_back();
+                found = true;
+            }
+            // Check for spike in second point
+            while(cleaned.size() >= 3
+               && detail::point_is_spike_or_equal(*(cleaned.begin() + 1),
+                                                  cleaned.back(),
+                                                  cleaned.front(),
+                                                  strategy))
+            {
+                cleaned.pop_front();
+                found = true;
+            }
+        }
+        while (found);
+
+        if (cleaned.size() == 2)
+        {
+            // Ticket #9871: open polygon with only two points.
+            // the second point forms, by definition, a spike
+            cleaned.pop_back();
+        }
+
+        // Close if necessary
+        if ( BOOST_GEOMETRY_CONDITION(geometry::closure<Range>::value == geometry::closed) )
+        {
+            cleaned.push_back(cleaned.front());
+        }
+
+        // Copy output
+        geometry::clear(range);
+        std::copy(cleaned.begin(), cleaned.end(), range::back_inserter(range));
+    }
+};
+
+
+struct polygon_remove_spikes
+{
+    template <typename Polygon, typename SideStrategy>
+    static inline void apply(Polygon& polygon, SideStrategy const& strategy)
+    {
+        typedef range_remove_spikes per_range;
+        per_range::apply(exterior_ring(polygon), strategy);
+
+        typename interior_return_type<Polygon>::type
+            rings = interior_rings(polygon);
+
+        for (typename detail::interior_iterator<Polygon>::type
+                it = boost::begin(rings); it != boost::end(rings); ++it)
+        {
+            per_range::apply(*it, strategy);
+        }
+    }
+};
+
+
+template <typename SingleVersion>
+struct multi_remove_spikes
+{
+    template <typename MultiGeometry, typename SideStrategy>
+    static inline void apply(MultiGeometry& multi, SideStrategy const& strategy)
+    {
+        for (typename boost::range_iterator<MultiGeometry>::type
+                it = boost::begin(multi);
+            it != boost::end(multi);
+            ++it)
+        {
+            SingleVersion::apply(*it, strategy);
+        }
+    }
+};
+
+
+}} // namespace detail::remove_spikes
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template
+<
+    typename Geometry,
+    typename Tag = typename tag<Geometry>::type
+>
+struct remove_spikes
+{
+    template <typename SideStrategy>
+    static inline void apply(Geometry&, SideStrategy const&)
+    {}
+};
+
+
+template <typename Ring>
+struct remove_spikes<Ring, ring_tag>
+    : detail::remove_spikes::range_remove_spikes
+{};
+
+
+
+template <typename Polygon>
+struct remove_spikes<Polygon, polygon_tag>
+    : detail::remove_spikes::polygon_remove_spikes
+{};
+
+
+template <typename MultiPolygon>
+struct remove_spikes<MultiPolygon, multi_polygon_tag>
+    : detail::remove_spikes::multi_remove_spikes
+        <
+            detail::remove_spikes::polygon_remove_spikes
+        >
+{};
+
+
+} // namespace dispatch
+#endif
+
+
+namespace resolve_variant {
+
+template <typename Geometry>
+struct remove_spikes
+{
+    template <typename Strategy>
+    static void apply(Geometry& geometry, Strategy const& strategy)
+    {
+        concepts::check<Geometry>();
+        dispatch::remove_spikes<Geometry>::apply(geometry, strategy);
+    }
+
+    static void apply(Geometry& geometry, geometry::default_strategy const&)
+    {
+        typedef typename strategy::side::services::default_strategy
+            <
+                typename cs_tag<Geometry>::type
+            >::type side_strategy;
+
+        apply(geometry, side_strategy());
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct remove_spikes<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Strategy>
+    struct visitor: boost::static_visitor<void>
+    {
+        Strategy const& m_strategy;
+
+        visitor(Strategy const& strategy) : m_strategy(strategy) {}
+
+        template <typename Geometry>
+        void operator()(Geometry& geometry) const
+        {
+            remove_spikes<Geometry>::apply(geometry, m_strategy);
+        }
+    };
+
+    template <typename Strategy>
+    static inline void apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>& geometry,
+                             Strategy const& strategy)
+    {
+        boost::apply_visitor(visitor<Strategy>(strategy), geometry);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+    \ingroup remove_spikes
+    \tparam Geometry geometry type
+    \param geometry the geometry to make remove_spikes
+*/
+template <typename Geometry>
+inline void remove_spikes(Geometry& geometry)
+{
+    resolve_variant::remove_spikes<Geometry>::apply(geometry, geometry::default_strategy());
+}
+
+/*!
+    \ingroup remove_spikes
+    \tparam Geometry geometry type
+    \tparam Strategy side strategy type
+    \param geometry the geometry to make remove_spikes
+    \param strategy the side strategy used by the algorithm
+*/
+template <typename Geometry, typename Strategy>
+inline void remove_spikes(Geometry& geometry, Strategy const& strategy)
+{
+    resolve_variant::remove_spikes<Geometry>::apply(geometry, strategy);
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_REMOVE_SPIKES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/reverse.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/reverse.hpp
new file mode 100644
index 00000000000..dc7d2de42c1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/reverse.hpp
@@ -0,0 +1,186 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_REVERSE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_REVERSE_HPP
+
+#include <algorithm>
+
+#include <boost/range.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/detail/interior_iterator.hpp>
+#include <boost/geometry/algorithms/detail/multi_modify.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace reverse
+{
+
+
+struct range_reverse
+{
+    template <typename Range>
+    static inline void apply(Range& range)
+    {
+        std::reverse(boost::begin(range), boost::end(range));
+    }
+};
+
+
+struct polygon_reverse: private range_reverse
+{
+    template <typename Polygon>
+    static inline void apply(Polygon& polygon)
+    {
+        range_reverse::apply(exterior_ring(polygon));
+
+        typename interior_return_type<Polygon>::type
+            rings = interior_rings(polygon);
+
+        for (typename detail::interior_iterator<Polygon>::type
+                it = boost::begin(rings); it != boost::end(rings); ++it)
+        {
+            range_reverse::apply(*it);
+        }
+    }
+};
+
+
+}} // namespace detail::reverse
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct reverse
+{
+    static inline void apply(Geometry&)
+    {}
+};
+
+
+template <typename Ring>
+struct reverse<Ring, ring_tag>
+    : detail::reverse::range_reverse
+{};
+
+
+template <typename LineString>
+struct reverse<LineString, linestring_tag>
+    : detail::reverse::range_reverse
+{};
+
+
+template <typename Polygon>
+struct reverse<Polygon, polygon_tag>
+    : detail::reverse::polygon_reverse
+{};
+
+
+template <typename Geometry>
+struct reverse<Geometry, multi_linestring_tag>
+    : detail::multi_modify
+        <
+            Geometry,
+            detail::reverse::range_reverse
+        >
+{};
+
+
+template <typename Geometry>
+struct reverse<Geometry, multi_polygon_tag>
+    : detail::multi_modify
+        <
+            Geometry,
+            detail::reverse::polygon_reverse
+        >
+{};
+
+
+
+} // namespace dispatch
+#endif
+
+
+namespace resolve_variant
+{
+
+template <typename Geometry>
+struct reverse
+{
+    static void apply(Geometry& geometry)
+    {
+        concepts::check<Geometry>();
+        dispatch::reverse<Geometry>::apply(geometry);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct reverse<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    struct visitor: boost::static_visitor<void>
+    {
+        template <typename Geometry>
+        void operator()(Geometry& geometry) const
+        {
+            reverse<Geometry>::apply(geometry);
+        }
+    };
+
+    static inline void apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>& geometry)
+    {
+        boost::apply_visitor(visitor(), geometry);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief Reverses the points within a geometry
+\details Generic function to reverse a geometry. It resembles the std::reverse
+   functionality, but it takes the geometry type into account. Only for a ring
+   or for a linestring it is the same as the std::reverse.
+\ingroup reverse
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry which will be reversed
+
+\qbk{[include reference/algorithms/reverse.qbk]}
+*/
+template <typename Geometry>
+inline void reverse(Geometry& geometry)
+{
+    resolve_variant::reverse<Geometry>::apply(geometry);
+}
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_REVERSE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/simplify.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/simplify.hpp
new file mode 100644
index 00000000000..cfeb5422204
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/simplify.hpp
@@ -0,0 +1,556 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_SIMPLIFY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_SIMPLIFY_HPP
+
+#include <cstddef>
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/range.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/mutable_range.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/strategies/agnostic/simplify_douglas_peucker.hpp>
+#include <boost/geometry/strategies/concepts/simplify_concept.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/strategies/distance.hpp>
+
+#include <boost/geometry/algorithms/clear.hpp>
+#include <boost/geometry/algorithms/convert.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/algorithms/detail/distance/default_strategies.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace simplify
+{
+
+struct simplify_range_insert
+{
+    template<typename Range, typename Strategy, typename OutputIterator, typename Distance>
+    static inline void apply(Range const& range, OutputIterator out,
+                             Distance const& max_distance, Strategy const& strategy)
+    {
+        boost::ignore_unused(strategy);
+
+        if (boost::size(range) <= 2 || max_distance < 0)
+        {
+            std::copy(boost::begin(range), boost::end(range), out);
+        }
+        else
+        {
+            strategy.apply(range, out, max_distance);
+        }
+    }
+};
+
+
+struct simplify_copy
+{
+    template <typename Range, typename Strategy, typename Distance>
+    static inline void apply(Range const& range, Range& out,
+                             Distance const& , Strategy const& )
+    {
+        std::copy
+            (
+                boost::begin(range), boost::end(range), geometry::range::back_inserter(out)
+            );
+    }
+};
+
+
+template<std::size_t Minimum>
+struct simplify_range
+{
+    template <typename Range, typename Strategy, typename Distance>
+    static inline void apply(Range const& range, Range& out,
+                    Distance const& max_distance, Strategy const& strategy)
+    {
+        // Call do_container for a linestring / ring
+
+        /* For a RING:
+            The first/last point (the closing point of the ring) should maybe
+            be excluded because it lies on a line with second/one but last.
+            Here it is never excluded.
+
+            Note also that, especially if max_distance is too large,
+            the output ring might be self intersecting while the input ring is
+            not, although chances are low in normal polygons
+
+            Finally the inputring might have 3 (open) or 4 (closed) points (=correct),
+                the output < 3 or 4(=wrong)
+        */
+
+        if (boost::size(range) <= int(Minimum) || max_distance < 0.0)
+        {
+            simplify_copy::apply(range, out, max_distance, strategy);
+        }
+        else
+        {
+            simplify_range_insert::apply
+                (
+                    range, geometry::range::back_inserter(out), max_distance, strategy
+                );
+        }
+    }
+};
+
+struct simplify_polygon
+{
+private:
+
+    template
+    <
+        std::size_t Minimum,
+        typename IteratorIn,
+        typename IteratorOut,
+        typename Distance,
+        typename Strategy
+    >
+    static inline void iterate(IteratorIn begin, IteratorIn end,
+                    IteratorOut it_out,
+                    Distance const& max_distance, Strategy const& strategy)
+    {
+        for (IteratorIn it_in = begin; it_in != end;  ++it_in, ++it_out)
+        {
+            simplify_range<Minimum>::apply(*it_in, *it_out, max_distance, strategy);
+        }
+    }
+
+    template
+    <
+        std::size_t Minimum,
+        typename InteriorRingsIn,
+        typename InteriorRingsOut,
+        typename Distance,
+        typename Strategy
+    >
+    static inline void apply_interior_rings(
+                    InteriorRingsIn const& interior_rings_in,
+                    InteriorRingsOut& interior_rings_out,
+                    Distance const& max_distance, Strategy const& strategy)
+    {
+        traits::resize<InteriorRingsOut>::apply(interior_rings_out,
+            boost::size(interior_rings_in));
+
+        iterate<Minimum>(
+            boost::begin(interior_rings_in), boost::end(interior_rings_in),
+            boost::begin(interior_rings_out),
+            max_distance, strategy);
+    }
+
+public:
+    template <typename Polygon, typename Strategy, typename Distance>
+    static inline void apply(Polygon const& poly_in, Polygon& poly_out,
+                    Distance const& max_distance, Strategy const& strategy)
+    {
+        std::size_t const minimum = core_detail::closure::minimum_ring_size
+            <
+                geometry::closure<Polygon>::value
+            >::value;
+
+        // Note that if there are inner rings, and distance is too large,
+        // they might intersect with the outer ring in the output,
+        // while it didn't in the input.
+        simplify_range<minimum>::apply(exterior_ring(poly_in),
+                                       exterior_ring(poly_out),
+                                       max_distance, strategy);
+
+        apply_interior_rings<minimum>(interior_rings(poly_in),
+                                      interior_rings(poly_out),
+                                      max_distance, strategy);
+    }
+};
+
+
+template<typename Policy>
+struct simplify_multi
+{
+    template <typename MultiGeometry, typename Strategy, typename Distance>
+    static inline void apply(MultiGeometry const& multi, MultiGeometry& out,
+                    Distance const& max_distance, Strategy const& strategy)
+    {
+        traits::resize<MultiGeometry>::apply(out, boost::size(multi));
+
+        typename boost::range_iterator<MultiGeometry>::type it_out
+                = boost::begin(out);
+        for (typename boost::range_iterator<MultiGeometry const>::type
+                it_in = boost::begin(multi);
+             it_in != boost::end(multi);
+             ++it_in, ++it_out)
+        {
+            Policy::apply(*it_in, *it_out, max_distance, strategy);
+        }
+    }
+};
+
+
+}} // namespace detail::simplify
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Geometry,
+    typename Tag = typename tag<Geometry>::type
+>
+struct simplify: not_implemented<Tag>
+{};
+
+template <typename Point>
+struct simplify<Point, point_tag>
+{
+    template <typename Distance, typename Strategy>
+    static inline void apply(Point const& point, Point& out,
+                    Distance const& , Strategy const& )
+    {
+        geometry::convert(point, out);
+    }
+};
+
+
+template <typename Linestring>
+struct simplify<Linestring, linestring_tag>
+    : detail::simplify::simplify_range<2>
+{};
+
+template <typename Ring>
+struct simplify<Ring, ring_tag>
+    : detail::simplify::simplify_range
+            <
+                core_detail::closure::minimum_ring_size
+                    <
+                        geometry::closure<Ring>::value
+                    >::value
+            >
+{};
+
+template <typename Polygon>
+struct simplify<Polygon, polygon_tag>
+    : detail::simplify::simplify_polygon
+{};
+
+
+template
+<
+    typename Geometry,
+    typename Tag = typename tag<Geometry>::type
+>
+struct simplify_insert: not_implemented<Tag>
+{};
+
+
+template <typename Linestring>
+struct simplify_insert<Linestring, linestring_tag>
+    : detail::simplify::simplify_range_insert
+{};
+
+template <typename Ring>
+struct simplify_insert<Ring, ring_tag>
+    : detail::simplify::simplify_range_insert
+{};
+
+template <typename MultiPoint>
+struct simplify<MultiPoint, multi_point_tag>
+    : detail::simplify::simplify_copy
+{};
+
+
+template <typename MultiLinestring>
+struct simplify<MultiLinestring, multi_linestring_tag>
+    : detail::simplify::simplify_multi<detail::simplify::simplify_range<2> >
+{};
+
+
+template <typename MultiPolygon>
+struct simplify<MultiPolygon, multi_polygon_tag>
+    : detail::simplify::simplify_multi<detail::simplify::simplify_polygon>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_strategy
+{
+
+struct simplify
+{
+    template <typename Geometry, typename Distance, typename Strategy>
+    static inline void apply(Geometry const& geometry,
+                             Geometry& out,
+                             Distance const& max_distance,
+                             Strategy const& strategy)
+    {
+        dispatch::simplify<Geometry>::apply(geometry, out, max_distance, strategy);
+    }
+
+    template <typename Geometry, typename Distance>
+    static inline void apply(Geometry const& geometry,
+                             Geometry& out,
+                             Distance const& max_distance,
+                             default_strategy)
+    {
+        typedef typename point_type<Geometry>::type point_type;
+
+        typedef typename strategy::distance::services::default_strategy
+        <
+            point_tag, segment_tag, point_type
+        >::type ds_strategy_type;
+
+        typedef strategy::simplify::douglas_peucker
+        <
+            point_type, ds_strategy_type
+        > strategy_type;
+
+        BOOST_CONCEPT_ASSERT(
+            (concepts::SimplifyStrategy<strategy_type, point_type>)
+        );
+
+        apply(geometry, out, max_distance, strategy_type());
+    }
+};
+
+struct simplify_insert
+{
+    template
+    <
+        typename Geometry,
+        typename OutputIterator,
+        typename Distance,
+        typename Strategy
+    >
+    static inline void apply(Geometry const& geometry,
+                             OutputIterator& out,
+                             Distance const& max_distance,
+                             Strategy const& strategy)
+    {
+        dispatch::simplify_insert<Geometry>::apply(geometry, out, max_distance, strategy);
+    }
+
+    template <typename Geometry, typename OutputIterator, typename Distance>
+    static inline void apply(Geometry const& geometry,
+                             OutputIterator& out,
+                             Distance const& max_distance,
+                             default_strategy)
+    {
+        typedef typename point_type<Geometry>::type point_type;
+
+        typedef typename strategy::distance::services::default_strategy
+        <
+            point_tag, segment_tag, point_type
+        >::type ds_strategy_type;
+
+        typedef strategy::simplify::douglas_peucker
+        <
+            point_type, ds_strategy_type
+        > strategy_type;
+
+        BOOST_CONCEPT_ASSERT(
+            (concepts::SimplifyStrategy<strategy_type, point_type>)
+        );
+
+        apply(geometry, out, max_distance, strategy_type());
+    }
+};
+
+} // namespace resolve_strategy
+
+
+namespace resolve_variant {
+
+template <typename Geometry>
+struct simplify
+{
+    template <typename Distance, typename Strategy>
+    static inline void apply(Geometry const& geometry,
+                             Geometry& out,
+                             Distance const& max_distance,
+                             Strategy const& strategy)
+    {
+        resolve_strategy::simplify::apply(geometry, out, max_distance, strategy);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct simplify<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Distance, typename Strategy>
+    struct visitor: boost::static_visitor<void>
+    {
+        Distance const& m_max_distance;
+        Strategy const& m_strategy;
+
+        visitor(Distance const& max_distance, Strategy const& strategy)
+            : m_max_distance(max_distance)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Geometry>
+        void operator()(Geometry const& geometry, Geometry& out) const
+        {
+            simplify<Geometry>::apply(geometry, out, m_max_distance, m_strategy);
+        }
+    };
+
+    template <typename Distance, typename Strategy>
+    static inline void
+    apply(boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry,
+          boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>& out,
+          Distance const& max_distance,
+          Strategy const& strategy)
+    {
+        boost::apply_visitor(
+            visitor<Distance, Strategy>(max_distance, strategy),
+            geometry,
+            out
+        );
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief Simplify a geometry using a specified strategy
+\ingroup simplify
+\tparam Geometry \tparam_geometry
+\tparam Distance A numerical distance measure
+\tparam Strategy A type fulfilling a SimplifyStrategy concept
+\param strategy A strategy to calculate simplification
+\param geometry input geometry, to be simplified
+\param out output geometry, simplified version of the input geometry
+\param max_distance distance (in units of input coordinates) of a vertex
+    to other segments to be removed
+\param strategy simplify strategy to be used for simplification, might
+    include point-distance strategy
+
+\image html svg_simplify_country.png "The image below presents the simplified country"
+\qbk{distinguish,with strategy}
+*/
+template<typename Geometry, typename Distance, typename Strategy>
+inline void simplify(Geometry const& geometry, Geometry& out,
+                     Distance const& max_distance, Strategy const& strategy)
+{
+    concepts::check<Geometry>();
+
+    geometry::clear(out);
+
+    resolve_variant::simplify<Geometry>::apply(geometry, out, max_distance, strategy);
+}
+
+
+
+
+/*!
+\brief Simplify a geometry
+\ingroup simplify
+\tparam Geometry \tparam_geometry
+\tparam Distance \tparam_numeric
+\note This version of simplify simplifies a geometry using the default
+    strategy (Douglas Peucker),
+\param geometry input geometry, to be simplified
+\param out output geometry, simplified version of the input geometry
+\param max_distance distance (in units of input coordinates) of a vertex
+    to other segments to be removed
+
+\qbk{[include reference/algorithms/simplify.qbk]}
+ */
+template<typename Geometry, typename Distance>
+inline void simplify(Geometry const& geometry, Geometry& out,
+                     Distance const& max_distance)
+{
+    concepts::check<Geometry>();
+
+    geometry::simplify(geometry, out, max_distance, default_strategy());
+}
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace simplify
+{
+
+
+/*!
+\brief Simplify a geometry, using an output iterator
+    and a specified strategy
+\ingroup simplify
+\tparam Geometry \tparam_geometry
+\param geometry input geometry, to be simplified
+\param out output iterator, outputs all simplified points
+\param max_distance distance (in units of input coordinates) of a vertex
+    to other segments to be removed
+\param strategy simplify strategy to be used for simplification,
+    might include point-distance strategy
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/simplify.qbk]}
+*/
+template<typename Geometry, typename OutputIterator, typename Distance, typename Strategy>
+inline void simplify_insert(Geometry const& geometry, OutputIterator out,
+                            Distance const& max_distance, Strategy const& strategy)
+{
+    concepts::check<Geometry const>();
+
+    resolve_strategy::simplify_insert::apply(geometry, out, max_distance, strategy);
+}
+
+/*!
+\brief Simplify a geometry, using an output iterator
+\ingroup simplify
+\tparam Geometry \tparam_geometry
+\param geometry input geometry, to be simplified
+\param out output iterator, outputs all simplified points
+\param max_distance distance (in units of input coordinates) of a vertex
+    to other segments to be removed
+
+\qbk{[include reference/algorithms/simplify_insert.qbk]}
+ */
+template<typename Geometry, typename OutputIterator, typename Distance>
+inline void simplify_insert(Geometry const& geometry, OutputIterator out,
+                            Distance const& max_distance)
+{
+    // Concept: output point type = point type of input geometry
+    concepts::check<Geometry const>();
+    concepts::check<typename point_type<Geometry>::type>();
+
+    simplify_insert(geometry, out, max_distance, default_strategy());
+}
+
+}} // namespace detail::simplify
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_SIMPLIFY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/sym_difference.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/sym_difference.hpp
new file mode 100644
index 00000000000..725230cd5bb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/sym_difference.hpp
@@ -0,0 +1,582 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2015, 2017.
+// Modifications copyright (c) 2015-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_SYM_DIFFERENCE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_SYM_DIFFERENCE_HPP
+
+
+#include <algorithm>
+#include <iterator>
+#include <vector>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/intersection.hpp>
+#include <boost/geometry/algorithms/union.hpp>
+#include <boost/geometry/geometries/multi_polygon.hpp>
+#include <boost/geometry/policies/robustness/get_rescale_policy.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/util/range.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace sym_difference
+{
+
+
+template <typename GeometryOut>
+struct compute_difference
+{
+    template
+    <
+        typename Geometry1,
+        typename Geometry2,
+        typename RobustPolicy,
+        typename OutputIterator,
+        typename Strategy
+    >
+    static inline OutputIterator apply(Geometry1 const& geometry1,
+                                       Geometry2 const& geometry2,
+                                       RobustPolicy const& robust_policy,
+                                       OutputIterator out,
+                                       Strategy const& strategy)
+    {
+        return geometry::dispatch::intersection_insert
+            <
+                Geometry1,
+                Geometry2,
+                GeometryOut,
+                overlay_difference,
+                geometry::detail::overlay::do_reverse
+                    <
+                        geometry::point_order<Geometry1>::value
+                    >::value,
+                geometry::detail::overlay::do_reverse
+                    <
+                        geometry::point_order<Geometry2>::value, true
+                    >::value
+            >::apply(geometry1, geometry2, robust_policy, out, strategy);
+    }
+};
+
+
+
+template <typename GeometryOut, typename Geometry1, typename Geometry2>
+struct sym_difference_generic
+{
+    template
+    <
+        typename RobustPolicy,
+        typename OutputIterator,
+        typename Strategy
+    >
+    static inline OutputIterator apply(Geometry1 const& geometry1,
+                                       Geometry2 const& geometry2,
+                                       RobustPolicy const& robust_policy,
+                                       OutputIterator out,
+                                       Strategy const& strategy)
+    {
+        out = compute_difference
+            <
+                GeometryOut
+            >::apply(geometry1, geometry2, robust_policy, out, strategy);
+
+        return compute_difference
+            <
+                GeometryOut
+            >::apply(geometry2, geometry1, robust_policy, out, strategy);
+    }
+};
+
+
+template <typename GeometryOut, typename Areal1, typename Areal2>
+struct sym_difference_areal_areal
+{
+    template
+    <
+        typename RobustPolicy,
+        typename OutputIterator,
+        typename Strategy
+    >
+    static inline OutputIterator apply(Areal1 const& areal1,
+                                       Areal2 const& areal2,
+                                       RobustPolicy const& robust_policy,
+                                       OutputIterator out,
+                                       Strategy const& strategy)
+    {
+        typedef geometry::model::multi_polygon
+            <
+                GeometryOut
+            > helper_geometry_type;
+
+        helper_geometry_type diff12, diff21;
+
+        std::back_insert_iterator<helper_geometry_type> oit12(diff12);
+        std::back_insert_iterator<helper_geometry_type> oit21(diff21);
+
+        compute_difference
+            <
+                GeometryOut
+            >::apply(areal1, areal2, robust_policy, oit12, strategy);
+
+        compute_difference
+            <
+                GeometryOut
+            >::apply(areal2, areal1, robust_policy, oit21, strategy);
+
+        return geometry::dispatch::union_insert
+            <
+                helper_geometry_type,
+                helper_geometry_type,
+                GeometryOut
+            >::apply(diff12, diff21, robust_policy, out, strategy);
+    }
+};
+
+
+}} // namespace detail::sym_difference
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename GeometryOut,
+    typename TagIn1 = typename geometry::tag_cast
+        <
+            typename tag<Geometry1>::type, areal_tag
+        >::type,
+    typename TagIn2 = typename geometry::tag_cast
+        <
+            typename tag<Geometry2>::type, areal_tag
+        >::type,
+    typename TagOut = typename geometry::tag<GeometryOut>::type
+>
+struct sym_difference_insert
+    : detail::sym_difference::sym_difference_generic
+        <
+            GeometryOut, Geometry1, Geometry2
+        >
+{};
+
+
+template
+<
+    typename Areal1,
+    typename Areal2,
+    typename GeometryOut,
+    typename TagOut
+>
+struct sym_difference_insert
+    <
+        Areal1, Areal2, GeometryOut,
+        areal_tag, areal_tag, TagOut
+    > : detail::sym_difference::sym_difference_areal_areal
+        <
+            GeometryOut, Areal1, Areal2
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace sym_difference
+{
+
+
+
+/*!
+\brief \brief_calc2{symmetric difference}  \brief_strategy
+\ingroup sym_difference
+\details \details_calc2{symmetric difference, spatial set theoretic symmetric difference (XOR)}
+    \brief_strategy. \details_insert{sym_difference}
+\tparam GeometryOut output geometry type, must be specified
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Strategy \tparam_strategy_overlay
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param out \param_out{difference}
+\param strategy \param_strategy{difference}
+\return \return_out
+
+\qbk{distinguish,with strategy}
+*/
+template
+<
+    typename GeometryOut,
+    typename Geometry1,
+    typename Geometry2,
+    typename RobustPolicy,
+    typename OutputIterator,
+    typename Strategy
+>
+inline OutputIterator sym_difference_insert(Geometry1 const& geometry1,
+            Geometry2 const& geometry2,
+            RobustPolicy const& robust_policy,
+            OutputIterator out,
+            Strategy const& strategy)
+{
+    concepts::check<Geometry1 const>();
+    concepts::check<Geometry2 const>();
+    concepts::check<GeometryOut>();
+
+    return dispatch::sym_difference_insert
+        <
+            Geometry1, Geometry2, GeometryOut
+        >::apply(geometry1, geometry2, robust_policy, out, strategy);
+}
+
+
+/*!
+\brief \brief_calc2{symmetric difference}
+\ingroup sym_difference
+\details \details_calc2{symmetric difference, spatial set theoretic symmetric difference (XOR)}
+    \details_insert{sym_difference}
+\tparam GeometryOut output geometry type, must be specified
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param out \param_out{difference}
+\return \return_out
+
+*/
+template
+<
+    typename GeometryOut,
+    typename Geometry1,
+    typename Geometry2,
+    typename RobustPolicy,
+    typename OutputIterator
+>
+inline OutputIterator sym_difference_insert(Geometry1 const& geometry1,
+            Geometry2 const& geometry2,
+            RobustPolicy const& robust_policy, OutputIterator out)
+{
+    concepts::check<Geometry1 const>();
+    concepts::check<Geometry2 const>();
+    concepts::check<GeometryOut>();
+
+    typedef typename strategy::intersection::services::default_strategy
+        <
+            typename cs_tag<GeometryOut>::type
+        >::type strategy_type;
+
+    return sym_difference_insert<GeometryOut>(geometry1, geometry2, robust_policy, out, strategy_type());
+}
+
+}} // namespace detail::sym_difference
+#endif // DOXYGEN_NO_DETAIL
+
+
+namespace resolve_strategy {
+
+struct sym_difference
+{
+    template
+    <
+        typename Geometry1,
+        typename Geometry2,
+        typename RobustPolicy,
+        typename Collection,
+        typename Strategy
+    >
+    static inline void apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             RobustPolicy const& robust_policy,
+                             Collection & output_collection,
+                             Strategy const& strategy)
+    {
+        typedef typename boost::range_value<Collection>::type geometry_out;
+
+        detail::sym_difference::sym_difference_insert<geometry_out>(
+            geometry1, geometry2, robust_policy,
+            range::back_inserter(output_collection),
+            strategy);
+    }
+
+    template
+    <
+        typename Geometry1,
+        typename Geometry2,
+        typename RobustPolicy,
+        typename Collection
+    >
+    static inline void apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             RobustPolicy const& robust_policy,
+                             Collection & output_collection,
+                             default_strategy)
+    {
+        typedef typename boost::range_value<Collection>::type geometry_out;
+        
+        detail::sym_difference::sym_difference_insert<geometry_out>(
+            geometry1, geometry2, robust_policy,
+            range::back_inserter(output_collection));
+    }
+};
+
+} // resolve_strategy
+
+
+namespace resolve_variant
+{
+    
+template <typename Geometry1, typename Geometry2>
+struct sym_difference
+{
+    template <typename Collection, typename Strategy>
+    static inline void apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Collection& output_collection,
+                             Strategy const& strategy)
+    {
+        typedef typename geometry::rescale_overlay_policy_type
+            <
+                Geometry1,
+                Geometry2
+            >::type rescale_policy_type;
+
+        rescale_policy_type robust_policy
+                = geometry::get_rescale_policy<rescale_policy_type>(geometry1,
+                                                                    geometry2);
+        
+        resolve_strategy::sym_difference::apply(geometry1, geometry2,
+                                                robust_policy,
+                                                output_collection,
+                                                strategy);
+    }
+};
+
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
+struct sym_difference<variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
+{
+    template <typename Collection, typename Strategy>
+    struct visitor: static_visitor<>
+    {
+        Geometry2 const& m_geometry2;
+        Collection& m_output_collection;
+        Strategy const& m_strategy;
+        
+        visitor(Geometry2 const& geometry2,
+                Collection& output_collection,
+                Strategy const& strategy)
+            : m_geometry2(geometry2)
+            , m_output_collection(output_collection)
+            , m_strategy(strategy)
+        {}
+        
+        template <typename Geometry1>
+        void operator()(Geometry1 const& geometry1) const
+        {
+            sym_difference
+                <
+                    Geometry1,
+                    Geometry2
+                >::apply(geometry1, m_geometry2, m_output_collection, m_strategy);
+        }
+    };
+    
+    template <typename Collection, typename Strategy>
+    static inline void
+    apply(variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
+          Geometry2 const& geometry2,
+          Collection& output_collection,
+          Strategy const& strategy)
+    {
+        boost::apply_visitor(visitor<Collection, Strategy>(geometry2,
+                                                           output_collection,
+                                                           strategy),
+                             geometry1);
+    }
+};
+
+
+template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct sym_difference<Geometry1, variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Collection, typename Strategy>
+    struct visitor: static_visitor<>
+    {
+        Geometry1 const& m_geometry1;
+        Collection& m_output_collection;
+        Strategy const& m_strategy;
+        
+        visitor(Geometry1 const& geometry1,
+                Collection& output_collection,
+                Strategy const& strategy)
+            : m_geometry1(geometry1)
+            , m_output_collection(output_collection)
+            , m_strategy(strategy)
+        {}
+        
+        template <typename Geometry2>
+        void operator()(Geometry2 const& geometry2) const
+        {
+            sym_difference
+                <
+                    Geometry1,
+                    Geometry2
+                >::apply(m_geometry1, geometry2, m_output_collection, m_strategy);
+        }
+    };
+    
+    template <typename Collection, typename Strategy>
+    static inline void
+    apply(Geometry1 const& geometry1,
+          variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2,
+          Collection& output_collection,
+          Strategy const& strategy)
+    {
+        boost::apply_visitor(visitor<Collection, Strategy>(geometry1,
+                                                           output_collection,
+                                                           strategy),
+                             geometry2);
+    }
+};
+
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T1), BOOST_VARIANT_ENUM_PARAMS(typename T2)>
+struct sym_difference<variant<BOOST_VARIANT_ENUM_PARAMS(T1)>, variant<BOOST_VARIANT_ENUM_PARAMS(T2)> >
+{
+    template <typename Collection, typename Strategy>
+    struct visitor: static_visitor<>
+    {
+        Collection& m_output_collection;
+        Strategy const& m_strategy;
+        
+        visitor(Collection& output_collection, Strategy const& strategy)
+            : m_output_collection(output_collection)
+            , m_strategy(strategy)
+        {}
+        
+        template <typename Geometry1, typename Geometry2>
+        void operator()(Geometry1 const& geometry1,
+                        Geometry2 const& geometry2) const
+        {
+            sym_difference
+                <
+                    Geometry1,
+                    Geometry2
+                >::apply(geometry1, geometry2, m_output_collection, m_strategy);
+        }
+    };
+    
+    template <typename Collection, typename Strategy>
+    static inline void
+    apply(variant<BOOST_VARIANT_ENUM_PARAMS(T1)> const& geometry1,
+          variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2,
+          Collection& output_collection,
+          Strategy const& strategy)
+    {
+        boost::apply_visitor(visitor<Collection, Strategy>(output_collection,
+                                                           strategy),
+                             geometry1, geometry2);
+    }
+};
+    
+} // namespace resolve_variant
+
+
+/*!
+\brief \brief_calc2{symmetric difference}
+\ingroup sym_difference
+\details \details_calc2{symmetric difference, spatial set theoretic symmetric difference (XOR)}.
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Collection output collection, either a multi-geometry,
+    or a std::vector<Geometry> / std::deque<Geometry> etc
+\tparam Strategy \tparam_strategy{Sym_difference}
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param output_collection the output collection
+\param strategy \param_strategy{sym_difference}
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/sym_difference.qbk]}
+*/
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename Collection,
+    typename Strategy
+>
+inline void sym_difference(Geometry1 const& geometry1,
+                           Geometry2 const& geometry2,
+                           Collection& output_collection,
+                           Strategy const& strategy)
+{
+    resolve_variant::sym_difference
+        <
+            Geometry1,
+            Geometry2
+        >::apply(geometry1, geometry2, output_collection, strategy);
+}
+
+
+/*!
+\brief \brief_calc2{symmetric difference}
+\ingroup sym_difference
+\details \details_calc2{symmetric difference, spatial set theoretic symmetric difference (XOR)}.
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Collection output collection, either a multi-geometry,
+    or a std::vector<Geometry> / std::deque<Geometry> etc
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param output_collection the output collection
+
+\qbk{[include reference/algorithms/sym_difference.qbk]}
+*/
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename Collection
+>
+inline void sym_difference(Geometry1 const& geometry1,
+                           Geometry2 const& geometry2,
+                           Collection& output_collection)
+{
+    resolve_variant::sym_difference
+        <
+            Geometry1,
+            Geometry2
+        >::apply(geometry1, geometry2, output_collection, default_strategy());    
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_SYM_DIFFERENCE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/touches.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/touches.hpp
new file mode 100644
index 00000000000..d358c3f20ee
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/touches.hpp
@@ -0,0 +1,28 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2015 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013, 2014, 2015, 2017.
+// Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_TOUCHES_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_TOUCHES_HPP
+
+
+#include <boost/geometry/algorithms/detail/touches/interface.hpp>
+#include <boost/geometry/algorithms/detail/touches/implementation.hpp>
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_TOUCHES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/transform.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/transform.hpp
new file mode 100644
index 00000000000..b514c1dacf6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/transform.hpp
@@ -0,0 +1,480 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_TRANSFORM_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_TRANSFORM_HPP
+
+#include <cmath>
+#include <iterator>
+
+#include <boost/range.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/algorithms/clear.hpp>
+#include <boost/geometry/algorithms/detail/interior_iterator.hpp>
+#include <boost/geometry/algorithms/num_interior_rings.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/mutable_range.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/strategies/transform.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace transform
+{
+
+struct transform_point
+{
+    template <typename Point1, typename Point2, typename Strategy>
+    static inline bool apply(Point1 const& p1, Point2& p2,
+                Strategy const& strategy)
+    {
+        return strategy.apply(p1, p2);
+    }
+};
+
+
+struct transform_box
+{
+    template <typename Box1, typename Box2, typename Strategy>
+    static inline bool apply(Box1 const& b1, Box2& b2,
+                Strategy const& strategy)
+    {
+        typedef typename point_type<Box1>::type point_type1;
+        typedef typename point_type<Box2>::type point_type2;
+
+        point_type1 lower_left, upper_right;
+        geometry::detail::assign::assign_box_2d_corner<min_corner, min_corner>(
+                    b1, lower_left);
+        geometry::detail::assign::assign_box_2d_corner<max_corner, max_corner>(
+                    b1, upper_right);
+
+        point_type2 p1, p2;
+        if (strategy.apply(lower_left, p1) && strategy.apply(upper_right, p2))
+        {
+            // Create a valid box and therefore swap if necessary
+            typedef typename coordinate_type<point_type2>::type coordinate_type;
+            coordinate_type x1 = geometry::get<0>(p1)
+                    , y1  = geometry::get<1>(p1)
+                    , x2  = geometry::get<0>(p2)
+                    , y2  = geometry::get<1>(p2);
+
+            if (x1 > x2) { std::swap(x1, x2); }
+            if (y1 > y2) { std::swap(y1, y2); }
+
+            geometry::set<min_corner, 0>(b2, x1);
+            geometry::set<min_corner, 1>(b2, y1);
+            geometry::set<max_corner, 0>(b2, x2);
+            geometry::set<max_corner, 1>(b2, y2);
+
+            return true;
+        }
+        return false;
+    }
+};
+
+struct transform_box_or_segment
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& source, Geometry2& target,
+                Strategy const& strategy)
+    {
+        typedef typename point_type<Geometry1>::type point_type1;
+        typedef typename point_type<Geometry2>::type point_type2;
+
+        point_type1 source_point[2];
+        geometry::detail::assign_point_from_index<0>(source, source_point[0]);
+        geometry::detail::assign_point_from_index<1>(source, source_point[1]);
+
+        point_type2 target_point[2];
+        if (strategy.apply(source_point[0], target_point[0])
+            && strategy.apply(source_point[1], target_point[1]))
+        {
+            geometry::detail::assign_point_to_index<0>(target_point[0], target);
+            geometry::detail::assign_point_to_index<1>(target_point[1], target);
+            return true;
+        }
+        return false;
+    }
+};
+
+
+template
+<
+    typename PointOut,
+    typename OutputIterator,
+    typename Range,
+    typename Strategy
+>
+inline bool transform_range_out(Range const& range,
+    OutputIterator out, Strategy const& strategy)
+{
+    PointOut point_out;
+    for(typename boost::range_iterator<Range const>::type
+        it = boost::begin(range);
+        it != boost::end(range);
+        ++it)
+    {
+        if (! transform_point::apply(*it, point_out, strategy))
+        {
+            return false;
+        }
+        *out++ = point_out;
+    }
+    return true;
+}
+
+
+struct transform_polygon
+{
+    template <typename Polygon1, typename Polygon2, typename Strategy>
+    static inline bool apply(Polygon1 const& poly1, Polygon2& poly2,
+                Strategy const& strategy)
+    {
+        typedef typename point_type<Polygon2>::type point2_type;
+
+        geometry::clear(poly2);
+
+        if (!transform_range_out<point2_type>(geometry::exterior_ring(poly1),
+                    range::back_inserter(geometry::exterior_ring(poly2)), strategy))
+        {
+            return false;
+        }
+
+        // Note: here a resizeable container is assumed.
+        traits::resize
+            <
+                typename boost::remove_reference
+                <
+                    typename traits::interior_mutable_type<Polygon2>::type
+                >::type
+            >::apply(geometry::interior_rings(poly2),
+                     geometry::num_interior_rings(poly1));
+
+        typename geometry::interior_return_type<Polygon1 const>::type
+            rings1 = geometry::interior_rings(poly1);
+        typename geometry::interior_return_type<Polygon2>::type
+            rings2 = geometry::interior_rings(poly2);
+
+        typename detail::interior_iterator<Polygon1 const>::type
+            it1 = boost::begin(rings1);
+        typename detail::interior_iterator<Polygon2>::type
+            it2 = boost::begin(rings2);
+        for ( ; it1 != boost::end(rings1); ++it1, ++it2)
+        {
+            if ( ! transform_range_out<point2_type>(*it1,
+                                                    range::back_inserter(*it2),
+                                                    strategy) )
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+};
+
+
+template <typename Point1, typename Point2>
+struct select_strategy
+{
+    typedef typename strategy::transform::services::default_strategy
+        <
+            typename cs_tag<Point1>::type,
+            typename cs_tag<Point2>::type,
+            typename coordinate_system<Point1>::type,
+            typename coordinate_system<Point2>::type,
+            dimension<Point1>::type::value,
+            dimension<Point2>::type::value,
+            typename point_type<Point1>::type,
+            typename point_type<Point2>::type
+        >::type type;
+};
+
+struct transform_range
+{
+    template <typename Range1, typename Range2, typename Strategy>
+    static inline bool apply(Range1 const& range1,
+            Range2& range2, Strategy const& strategy)
+    {
+        typedef typename point_type<Range2>::type point_type;
+
+        // Should NOT be done here!
+        // geometry::clear(range2);
+        return transform_range_out<point_type>(range1,
+                range::back_inserter(range2), strategy);
+    }
+};
+
+
+/*!
+    \brief Is able to transform any multi-geometry, calling the single-version as policy
+*/
+template <typename Policy>
+struct transform_multi
+{
+    template <typename Multi1, typename Multi2, typename S>
+    static inline bool apply(Multi1 const& multi1, Multi2& multi2, S const& strategy)
+    {
+        traits::resize<Multi2>::apply(multi2, boost::size(multi1));
+
+        typename boost::range_iterator<Multi1 const>::type it1
+                = boost::begin(multi1);
+        typename boost::range_iterator<Multi2>::type it2
+                = boost::begin(multi2);
+
+        for (; it1 != boost::end(multi1); ++it1, ++it2)
+        {
+            if (! Policy::apply(*it1, *it2, strategy))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+};
+
+
+}} // namespace detail::transform
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Geometry1, typename Geometry2,
+    typename Tag1 = typename tag_cast<typename tag<Geometry1>::type, multi_tag>::type,
+    typename Tag2 = typename tag_cast<typename tag<Geometry2>::type, multi_tag>::type
+>
+struct transform {};
+
+template <typename Point1, typename Point2>
+struct transform<Point1, Point2, point_tag, point_tag>
+    : detail::transform::transform_point
+{
+};
+
+
+template <typename Linestring1, typename Linestring2>
+struct transform
+    <
+        Linestring1, Linestring2,
+        linestring_tag, linestring_tag
+    >
+    : detail::transform::transform_range
+{
+};
+
+template <typename Range1, typename Range2>
+struct transform<Range1, Range2, ring_tag, ring_tag>
+    : detail::transform::transform_range
+{
+};
+
+template <typename Polygon1, typename Polygon2>
+struct transform<Polygon1, Polygon2, polygon_tag, polygon_tag>
+    : detail::transform::transform_polygon
+{
+};
+
+template <typename Box1, typename Box2>
+struct transform<Box1, Box2, box_tag, box_tag>
+    : detail::transform::transform_box
+{
+};
+
+template <typename Segment1, typename Segment2>
+struct transform<Segment1, Segment2, segment_tag, segment_tag>
+    : detail::transform::transform_box_or_segment
+{
+};
+
+template <typename Multi1, typename Multi2>
+struct transform
+    <
+        Multi1, Multi2,
+        multi_tag, multi_tag
+    >
+    : detail::transform::transform_multi
+        <
+            dispatch::transform
+                <
+                    typename boost::range_value<Multi1>::type,
+                    typename boost::range_value<Multi2>::type
+                >
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+namespace resolve_strategy {
+
+struct transform
+{
+    template <typename Geometry1, typename Geometry2, typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2& geometry2,
+                             Strategy const& strategy)
+    {
+        concepts::check<Geometry1 const>();
+        concepts::check<Geometry2>();
+
+        return dispatch::transform<Geometry1, Geometry2>::apply(
+            geometry1,
+            geometry2,
+            strategy
+        );
+    }
+
+    template <typename Geometry1, typename Geometry2>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2& geometry2,
+                             default_strategy)
+    {
+        return apply(
+            geometry1,
+            geometry2,
+            typename detail::transform::select_strategy<Geometry1, Geometry2>::type()
+        );
+    }
+};
+
+} // namespace resolve_strategy
+
+
+namespace resolve_variant {
+
+template <typename Geometry1, typename Geometry2>
+struct transform
+{
+    template <typename Strategy>
+    static inline bool apply(Geometry1 const& geometry1,
+                             Geometry2& geometry2,
+                             Strategy const& strategy)
+    {
+        return resolve_strategy::transform::apply(
+            geometry1,
+            geometry2,
+            strategy
+        );
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
+struct transform<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
+{
+    template <typename Strategy>
+    struct visitor: static_visitor<bool>
+    {
+        Geometry2& m_geometry2;
+        Strategy const& m_strategy;
+
+        visitor(Geometry2& geometry2, Strategy const& strategy)
+            : m_geometry2(geometry2)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Geometry1>
+        inline bool operator()(Geometry1 const& geometry1) const
+        {
+            return transform<Geometry1, Geometry2>::apply(
+                geometry1,
+                m_geometry2,
+                m_strategy
+            );
+        }
+    };
+
+    template <typename Strategy>
+    static inline bool apply(
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
+        Geometry2& geometry2,
+        Strategy const& strategy
+    )
+    {
+        return boost::apply_visitor(visitor<Strategy>(geometry2, strategy), geometry1);
+    }
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief Transforms from one geometry to another geometry  \brief_strategy
+\ingroup transform
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Strategy strategy
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param strategy The strategy to be used for transformation
+\return True if the transformation could be done
+
+\qbk{distinguish,with strategy}
+
+\qbk{[include reference/algorithms/transform_with_strategy.qbk]}
+ */
+template <typename Geometry1, typename Geometry2, typename Strategy>
+inline bool transform(Geometry1 const& geometry1, Geometry2& geometry2,
+            Strategy const& strategy)
+{
+    return resolve_variant::transform<Geometry1, Geometry2>
+                          ::apply(geometry1, geometry2, strategy);
+}
+
+
+/*!
+\brief Transforms from one geometry to another geometry using a strategy
+\ingroup transform
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\return True if the transformation could be done
+
+\qbk{[include reference/algorithms/transform.qbk]}
+ */
+template <typename Geometry1, typename Geometry2>
+inline bool transform(Geometry1 const& geometry1, Geometry2& geometry2)
+{
+    return geometry::transform(geometry1, geometry2, default_strategy());
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_TRANSFORM_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/union.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/union.hpp
new file mode 100644
index 00000000000..d3a2daf66ee
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/union.hpp
@@ -0,0 +1,537 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014, 2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_UNION_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_UNION_HPP
+
+
+#include <boost/range/metafunctions.hpp>
+
+#include <boost/geometry/core/is_areal.hpp>
+#include <boost/geometry/core/point_order.hpp>
+#include <boost/geometry/core/reverse_dispatch.hpp>
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+#include <boost/geometry/algorithms/detail/overlay/overlay.hpp>
+#include <boost/geometry/policies/robustness/get_rescale_policy.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/algorithms/detail/overlay/linear_linear.hpp>
+#include <boost/geometry/algorithms/detail/overlay/pointlike_pointlike.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Geometry1, typename Geometry2, typename GeometryOut,
+    typename TagIn1 = typename tag<Geometry1>::type,
+    typename TagIn2 = typename tag<Geometry2>::type,
+    typename TagOut = typename tag<GeometryOut>::type,
+    bool Areal1 = geometry::is_areal<Geometry1>::value,
+    bool Areal2 = geometry::is_areal<Geometry2>::value,
+    bool ArealOut = geometry::is_areal<GeometryOut>::value,
+    bool Reverse1 = detail::overlay::do_reverse<geometry::point_order<Geometry1>::value>::value,
+    bool Reverse2 = detail::overlay::do_reverse<geometry::point_order<Geometry2>::value>::value,
+    bool ReverseOut = detail::overlay::do_reverse<geometry::point_order<GeometryOut>::value>::value,
+    bool Reverse = geometry::reverse_dispatch<Geometry1, Geometry2>::type::value
+>
+struct union_insert: not_implemented<TagIn1, TagIn2, TagOut>
+{};
+
+
+// If reversal is needed, perform it first
+
+template
+<
+    typename Geometry1, typename Geometry2, typename GeometryOut,
+    typename TagIn1, typename TagIn2, typename TagOut,
+    bool Areal1, bool Areal2, bool ArealOut,
+    bool Reverse1, bool Reverse2, bool ReverseOut
+>
+struct union_insert
+    <
+        Geometry1, Geometry2, GeometryOut,
+        TagIn1, TagIn2, TagOut,
+        Areal1, Areal2, ArealOut,
+        Reverse1, Reverse2, ReverseOut,
+        true
+    >: union_insert<Geometry2, Geometry1, GeometryOut>
+{
+    template <typename RobustPolicy, typename OutputIterator, typename Strategy>
+    static inline OutputIterator apply(Geometry1 const& g1,
+            Geometry2 const& g2,
+            RobustPolicy const& robust_policy,
+            OutputIterator out,
+            Strategy const& strategy)
+    {
+        return union_insert
+            <
+                Geometry2, Geometry1, GeometryOut
+            >::apply(g2, g1, robust_policy, out, strategy);
+    }
+};
+
+
+template
+<
+    typename Geometry1, typename Geometry2, typename GeometryOut,
+    typename TagIn1, typename TagIn2, typename TagOut,
+    bool Reverse1, bool Reverse2, bool ReverseOut
+>
+struct union_insert
+    <
+        Geometry1, Geometry2, GeometryOut,
+        TagIn1, TagIn2, TagOut,
+        true, true, true,
+        Reverse1, Reverse2, ReverseOut,
+        false
+    > : detail::overlay::overlay
+        <Geometry1, Geometry2, Reverse1, Reverse2, ReverseOut, GeometryOut, overlay_union>
+{};
+
+
+// dispatch for union of non-areal geometries
+template
+<
+    typename Geometry1, typename Geometry2, typename GeometryOut,
+    typename TagIn1, typename TagIn2, typename TagOut,
+    bool Reverse1, bool Reverse2, bool ReverseOut
+>
+struct union_insert
+    <
+        Geometry1, Geometry2, GeometryOut,
+        TagIn1, TagIn2, TagOut,
+        false, false, false,
+        Reverse1, Reverse2, ReverseOut,
+        false
+    > : union_insert
+        <
+            Geometry1, Geometry2, GeometryOut,
+            typename tag_cast<TagIn1, pointlike_tag, linear_tag>::type,
+            typename tag_cast<TagIn2, pointlike_tag, linear_tag>::type,
+            TagOut,
+            false, false, false,
+            Reverse1, Reverse2, ReverseOut,
+            false
+        >
+{};
+
+
+// dispatch for union of linear geometries
+template
+<
+    typename Linear1, typename Linear2, typename LineStringOut,
+    bool Reverse1, bool Reverse2, bool ReverseOut
+>
+struct union_insert
+    <
+        Linear1, Linear2, LineStringOut,
+        linear_tag, linear_tag, linestring_tag,
+        false, false, false,
+        Reverse1, Reverse2, ReverseOut,
+        false
+    > : detail::overlay::linear_linear_linestring
+        <
+            Linear1, Linear2, LineStringOut, overlay_union
+        >
+{};
+
+
+// dispatch for point-like geometries
+template
+<
+    typename PointLike1, typename PointLike2, typename PointOut,
+    bool Reverse1, bool Reverse2, bool ReverseOut
+>
+struct union_insert
+    <
+        PointLike1, PointLike2, PointOut,
+        pointlike_tag, pointlike_tag, point_tag,
+        false, false, false,
+        Reverse1, Reverse2, ReverseOut,
+        false
+    > : detail::overlay::union_pointlike_pointlike_point
+        <
+            PointLike1, PointLike2, PointOut
+        >
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace union_
+{
+
+/*!
+\brief_calc2{union}
+\ingroup union
+\details \details_calc2{union_insert, spatial set theoretic union}.
+    \details_insert{union}
+\tparam GeometryOut output geometry type, must be specified
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam OutputIterator output iterator
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param out \param_out{union}
+\return \return_out
+*/
+template
+<
+    typename GeometryOut,
+    typename Geometry1,
+    typename Geometry2,
+    typename OutputIterator
+>
+inline OutputIterator union_insert(Geometry1 const& geometry1,
+            Geometry2 const& geometry2,
+            OutputIterator out)
+{
+    concepts::check<Geometry1 const>();
+    concepts::check<Geometry2 const>();
+    concepts::check<GeometryOut>();
+
+    typedef typename geometry::rescale_overlay_policy_type
+        <
+            Geometry1,
+            Geometry2
+        >::type rescale_policy_type;
+
+    typename strategy::intersection::services::default_strategy
+        <
+            typename cs_tag<GeometryOut>::type
+        >::type strategy;
+
+    rescale_policy_type robust_policy
+            = geometry::get_rescale_policy<rescale_policy_type>(geometry1, geometry2);
+
+    return dispatch::union_insert
+           <
+               Geometry1, Geometry2, GeometryOut
+           >::apply(geometry1, geometry2, robust_policy, out, strategy);
+}
+
+
+}} // namespace detail::union_
+#endif // DOXYGEN_NO_DETAIL
+
+
+namespace resolve_strategy {
+
+struct union_
+{
+    template
+    <
+        typename Geometry1,
+        typename Geometry2,
+        typename RobustPolicy,
+        typename Collection,
+        typename Strategy
+    >
+    static inline void apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             RobustPolicy const& robust_policy,
+                             Collection & output_collection,
+                             Strategy const& strategy)
+    {
+        typedef typename boost::range_value<Collection>::type geometry_out;
+
+        dispatch::union_insert
+           <
+               Geometry1, Geometry2, geometry_out
+           >::apply(geometry1, geometry2, robust_policy,
+                    range::back_inserter(output_collection),
+                    strategy);
+    }
+
+    template
+    <
+        typename Geometry1,
+        typename Geometry2,
+        typename RobustPolicy,
+        typename Collection
+    >
+    static inline void apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             RobustPolicy const& robust_policy,
+                             Collection & output_collection,
+                             default_strategy)
+    {
+        typedef typename boost::range_value<Collection>::type geometry_out;
+
+        typedef typename strategy::intersection::services::default_strategy
+            <
+                typename cs_tag<geometry_out>::type
+            >::type strategy_type;
+
+        dispatch::union_insert
+           <
+               Geometry1, Geometry2, geometry_out
+           >::apply(geometry1, geometry2, robust_policy,
+                    range::back_inserter(output_collection),
+                    strategy_type());
+    }
+};
+
+} // resolve_strategy
+
+
+namespace resolve_variant
+{
+    
+template <typename Geometry1, typename Geometry2>
+struct union_
+{
+    template <typename Collection, typename Strategy>
+    static inline void apply(Geometry1 const& geometry1,
+                             Geometry2 const& geometry2,
+                             Collection& output_collection,
+                             Strategy const& strategy)
+    {
+        concepts::check<Geometry1 const>();
+        concepts::check<Geometry2 const>();
+        concepts::check<typename boost::range_value<Collection>::type>();
+
+        typedef typename geometry::rescale_overlay_policy_type
+            <
+                Geometry1,
+                Geometry2
+            >::type rescale_policy_type;
+
+        rescale_policy_type robust_policy
+                = geometry::get_rescale_policy<rescale_policy_type>(geometry1,
+                                                                    geometry2);
+        
+        resolve_strategy::union_::apply(geometry1, geometry2,
+                                        robust_policy,
+                                        output_collection,
+                                        strategy);
+    }
+};
+
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Geometry2>
+struct union_<variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Geometry2>
+{
+    template <typename Collection, typename Strategy>
+    struct visitor: static_visitor<>
+    {
+        Geometry2 const& m_geometry2;
+        Collection& m_output_collection;
+        Strategy const& m_strategy;
+        
+        visitor(Geometry2 const& geometry2,
+                Collection& output_collection,
+                Strategy const& strategy)
+            : m_geometry2(geometry2)
+            , m_output_collection(output_collection)
+            , m_strategy(strategy)
+        {}
+        
+        template <typename Geometry1>
+        void operator()(Geometry1 const& geometry1) const
+        {
+            union_
+                <
+                    Geometry1,
+                    Geometry2
+                >::apply(geometry1, m_geometry2, m_output_collection, m_strategy);
+        }
+    };
+    
+    template <typename Collection, typename Strategy>
+    static inline void
+    apply(variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry1,
+          Geometry2 const& geometry2,
+          Collection& output_collection,
+          Strategy const& strategy)
+    {
+        boost::apply_visitor(visitor<Collection, Strategy>(geometry2,
+                                                           output_collection,
+                                                           strategy),
+                             geometry1);
+    }
+};
+
+
+template <typename Geometry1, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct union_<Geometry1, variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename Collection, typename Strategy>
+    struct visitor: static_visitor<>
+    {
+        Geometry1 const& m_geometry1;
+        Collection& m_output_collection;
+        Strategy const& m_strategy;
+        
+        visitor(Geometry1 const& geometry1,
+                Collection& output_collection,
+                Strategy const& strategy)
+            : m_geometry1(geometry1)
+            , m_output_collection(output_collection)
+            , m_strategy(strategy)
+        {}
+        
+        template <typename Geometry2>
+        void operator()(Geometry2 const& geometry2) const
+        {
+            union_
+                <
+                    Geometry1,
+                    Geometry2
+                >::apply(m_geometry1, geometry2, m_output_collection, m_strategy);
+        }
+    };
+    
+    template <typename Collection, typename Strategy>
+    static inline void
+    apply(Geometry1 const& geometry1,
+          variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry2,
+          Collection& output_collection,
+          Strategy const& strategy)
+    {
+        boost::apply_visitor(visitor<Collection, Strategy>(geometry1,
+                                                           output_collection,
+                                                           strategy),
+                             geometry2);
+    }
+};
+
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T1), BOOST_VARIANT_ENUM_PARAMS(typename T2)>
+struct union_<variant<BOOST_VARIANT_ENUM_PARAMS(T1)>, variant<BOOST_VARIANT_ENUM_PARAMS(T2)> >
+{
+    template <typename Collection, typename Strategy>
+    struct visitor: static_visitor<>
+    {
+        Collection& m_output_collection;
+        Strategy const& m_strategy;
+        
+        visitor(Collection& output_collection, Strategy const& strategy)
+            : m_output_collection(output_collection)
+            , m_strategy(strategy)
+        {}
+        
+        template <typename Geometry1, typename Geometry2>
+        void operator()(Geometry1 const& geometry1,
+                        Geometry2 const& geometry2) const
+        {
+            union_
+                <
+                    Geometry1,
+                    Geometry2
+                >::apply(geometry1, geometry2, m_output_collection, m_strategy);
+        }
+    };
+    
+    template <typename Collection, typename Strategy>
+    static inline void
+    apply(variant<BOOST_VARIANT_ENUM_PARAMS(T1)> const& geometry1,
+          variant<BOOST_VARIANT_ENUM_PARAMS(T2)> const& geometry2,
+          Collection& output_collection,
+          Strategy const& strategy)
+    {
+        boost::apply_visitor(visitor<Collection, Strategy>(output_collection,
+                                                           strategy),
+                             geometry1, geometry2);
+    }
+};
+    
+} // namespace resolve_variant
+
+
+/*!
+\brief Combines two geometries which each other
+\ingroup union
+\details \details_calc2{union, spatial set theoretic union}.
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Collection output collection, either a multi-geometry,
+    or a std::vector<Geometry> / std::deque<Geometry> etc
+\tparam Strategy \tparam_strategy{Union_}
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param output_collection the output collection
+\param strategy \param_strategy{union_}
+\note Called union_ because union is a reserved word.
+
+\qbk{distinguish,with strategy}
+\qbk{[include reference/algorithms/union.qbk]}
+*/
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename Collection,
+    typename Strategy
+>
+inline void union_(Geometry1 const& geometry1,
+                   Geometry2 const& geometry2,
+                   Collection& output_collection,
+                   Strategy const& strategy)
+{
+    resolve_variant::union_
+        <
+            Geometry1,
+            Geometry2
+        >::apply(geometry1, geometry2, output_collection, strategy);
+}
+
+
+/*!
+\brief Combines two geometries which each other
+\ingroup union
+\details \details_calc2{union, spatial set theoretic union}.
+\tparam Geometry1 \tparam_geometry
+\tparam Geometry2 \tparam_geometry
+\tparam Collection output collection, either a multi-geometry,
+    or a std::vector<Geometry> / std::deque<Geometry> etc
+\param geometry1 \param_geometry
+\param geometry2 \param_geometry
+\param output_collection the output collection
+\note Called union_ because union is a reserved word.
+
+\qbk{[include reference/algorithms/union.qbk]}
+*/
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename Collection
+>
+inline void union_(Geometry1 const& geometry1,
+                   Geometry2 const& geometry2,
+                   Collection& output_collection)
+{
+    resolve_variant::union_
+        <
+            Geometry1,
+            Geometry2
+        >::apply(geometry1, geometry2, output_collection, default_strategy());
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_UNION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/unique.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/unique.hpp
new file mode 100644
index 00000000000..f57f4505ba1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/unique.hpp
@@ -0,0 +1,184 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_UNIQUE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_UNIQUE_HPP
+
+#include <algorithm>
+
+#include <boost/range.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/geometry/algorithms/detail/interior_iterator.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/mutable_range.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/policies/compare.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace unique
+{
+
+
+struct range_unique
+{
+    template <typename Range, typename ComparePolicy>
+    static inline void apply(Range& range, ComparePolicy const& policy)
+    {
+        typename boost::range_iterator<Range>::type it
+            = std::unique
+                (
+                    boost::begin(range),
+                    boost::end(range),
+                    policy
+                );
+
+        traits::resize<Range>::apply(range, it - boost::begin(range));
+    }
+};
+
+
+struct polygon_unique
+{
+    template <typename Polygon, typename ComparePolicy>
+    static inline void apply(Polygon& polygon, ComparePolicy const& policy)
+    {
+        range_unique::apply(exterior_ring(polygon), policy);
+
+        typename interior_return_type<Polygon>::type
+            rings = interior_rings(polygon);
+
+        for (typename detail::interior_iterator<Polygon>::type
+                it = boost::begin(rings); it != boost::end(rings); ++it)
+        {
+            range_unique::apply(*it, policy);
+        }
+    }
+};
+
+
+template <typename Policy>
+struct multi_unique
+{
+    template <typename MultiGeometry, typename ComparePolicy>
+    static inline void apply(MultiGeometry& multi, ComparePolicy const& compare)
+    {
+        for (typename boost::range_iterator<MultiGeometry>::type
+                it = boost::begin(multi);
+            it != boost::end(multi);
+            ++it)
+        {
+            Policy::apply(*it, compare);
+        }
+    }
+};
+
+
+}} // namespace detail::unique
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template
+<
+    typename Geometry,
+    typename Tag = typename tag<Geometry>::type
+>
+struct unique
+{
+    template <typename ComparePolicy>
+    static inline void apply(Geometry&, ComparePolicy const& )
+    {}
+};
+
+
+template <typename Ring>
+struct unique<Ring, ring_tag>
+    : detail::unique::range_unique
+{};
+
+
+template <typename LineString>
+struct unique<LineString, linestring_tag>
+    : detail::unique::range_unique
+{};
+
+
+template <typename Polygon>
+struct unique<Polygon, polygon_tag>
+    : detail::unique::polygon_unique
+{};
+
+
+// For points, unique is not applicable and does nothing
+// (Note that it is not "spatially unique" but that it removes duplicate coordinates,
+//  like std::unique does). Spatially unique is "dissolve" which can (or will be)
+//  possible for multi-points as well, removing points at the same location.
+
+
+template <typename MultiLineString>
+struct unique<MultiLineString, multi_linestring_tag>
+    : detail::unique::multi_unique<detail::unique::range_unique>
+{};
+
+
+template <typename MultiPolygon>
+struct unique<MultiPolygon, multi_polygon_tag>
+    : detail::unique::multi_unique<detail::unique::polygon_unique>
+{};
+
+
+} // namespace dispatch
+#endif
+
+
+/*!
+\brief \brief_calc{minimal set}
+\ingroup unique
+\details \details_calc{unique,minimal set (where duplicate consecutive points are removed)}.
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry which will be made unique
+
+\qbk{[include reference/algorithms/unique.qbk]}
+*/
+template <typename Geometry>
+inline void unique(Geometry& geometry)
+{
+    concepts::check<Geometry>();
+
+    // Default strategy is the default point-comparison policy
+    typedef geometry::equal_to
+        <
+            typename geometry::point_type<Geometry>::type
+        > policy;
+
+
+    dispatch::unique<Geometry>::apply(geometry, policy());
+}
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_UNIQUE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/validity_failure_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/validity_failure_type.hpp
new file mode 100644
index 00000000000..3fbf8027b4d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/validity_failure_type.hpp
@@ -0,0 +1,90 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_VALIDITY_FAILURE_TYPE_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_VALIDITY_FAILURE_TYPE_HPP
+
+
+namespace boost { namespace geometry
+{
+
+
+/*!
+\brief Enumerates the possible validity failure types for a geometry
+\ingroup enum
+\details The enumeration validity_failure_type enumerates the possible
+    reasons for which a geometry may be found as invalid by the
+    is_valid algorithm.
+    Besides the values that indicate invalidity, there is an
+    additional value (no_failure) that indicates validity.
+
+\qbk{
+[heading See also]
+[link geometry.reference.algorithms.is_valid The is_valid
+algorithm taking a reference to validity_failure_type as second argument]
+}
+*/
+enum validity_failure_type
+{
+    /// The geometry is valid
+    ///
+    no_failure = 0,
+    /// The geometry has a very small number of points, e.g., less
+    /// than 2 for linestrings, less than 3 for open rings, a closed
+    /// multi-polygon that contains a polygon with less than 4 points, etc.
+    /// (applies to linestrings, rings, polygons, multi-linestrings
+    /// and multi-polygons)
+    failure_few_points = 10,
+    /// The topological dimension of the geometry is smaller than its
+    /// dimension, e.g., a linestring with 3 identical points, an open
+    /// polygon with an interior ring consisting of 3 collinear points, etc.
+    /// (applies to linear and areal geometries, including segments
+    /// and boxes)
+    failure_wrong_topological_dimension = 11,
+    /// The geometry contains spikes
+    /// (applies to linear and areal geometries)
+    failure_spikes = 12,
+    /// The geometry has (consecutive) duplicate points
+    /// (applies to areal geometries only)
+    failure_duplicate_points = 13,
+    /// The geometry is defined as closed, the starting/ending points
+    /// are not equal
+    /// (applies to areal geometries only)
+    failure_not_closed = 20, // for areal geometries
+    /// The geometry has invalid self-intersections.
+    /// (applies to areal geometries only)
+    failure_self_intersections = 21, // for areal geometries
+    /// The actual orientation of the geometry is different from the one defined
+    /// (applies to areal geometries only)
+    failure_wrong_orientation = 22, // for areal geometries
+    /// The geometry contains interior rings that lie outside the exterior ring
+    /// (applies to polygons and multi-polygons only)
+    failure_interior_rings_outside = 30, // for (multi-)polygons
+    /// The geometry has nested interior rings
+    /// (applies to polygons and multi-polygons only)
+    failure_nested_interior_rings = 31, // for (multi-)polygons
+    /// The interior of the geometry is disconnected
+    /// (applies to polygons and multi-polygons only)
+    failure_disconnected_interior = 32, // for (multi-)polygons
+    /// The multi-polygon contains polygons whose interiors are not disjoint
+    /// (applies to multi-polygons only)
+    failure_intersecting_interiors = 40, // for multi-polygons
+    /// The top-right corner of the box is lexicographically smaller
+    /// than its bottom-left corner
+    /// (applies to boxes only)
+    failure_wrong_corner_order = 50, // for boxes
+    /// The geometry has at least one point with an invalid coordinate
+    /// (for example, the coordinate is a NaN)
+    failure_invalid_coordinate = 60
+};
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_VALIDITY_FAILURE_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/within.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/within.hpp
new file mode 100644
index 00000000000..e657bbda24f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/algorithms/within.hpp
@@ -0,0 +1,27 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2013, 2014, 2017.
+// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_WITHIN_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_WITHIN_HPP
+
+
+#include <boost/geometry/algorithms/detail/within/interface.hpp>
+#include <boost/geometry/algorithms/detail/within/implementation.hpp>
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_WITHIN_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/arithmetic/arithmetic.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/arithmetic/arithmetic.hpp
new file mode 100644
index 00000000000..3ab66b27f53
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/arithmetic/arithmetic.hpp
@@ -0,0 +1,335 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ARITHMETIC_ARITHMETIC_HPP
+#define BOOST_GEOMETRY_ARITHMETIC_ARITHMETIC_HPP
+
+#include <functional>
+
+#include <boost/call_traits.hpp>
+#include <boost/concept/requires.hpp>
+
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+#include <boost/geometry/util/for_each_coordinate.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+
+template <typename Point>
+struct param
+{
+    typedef typename boost::call_traits
+        <
+            typename coordinate_type<Point>::type
+        >::param_type type;
+};
+
+
+template <typename Value, template <typename> class Function>
+struct value_operation
+{
+    Value m_value;
+
+    inline value_operation(Value const &value)
+        : m_value(value)
+    {}
+
+    template <typename PointDst, std::size_t Index>
+    inline void apply(PointDst& point_dst) const
+    {
+        set<Index>(point_dst,
+               Function
+                <
+                    typename geometry::select_most_precise
+                        <
+                            Value,
+                            typename geometry::coordinate_type<PointDst>::type
+                        >::type
+                >()(get<Index>(point_dst), m_value));
+    }
+};
+
+template <typename PointSrc, template <typename> class Function>
+struct point_operation
+{
+    PointSrc const& m_point_src;
+
+    inline point_operation(PointSrc const& point)
+        : m_point_src(point)
+    {}
+
+    template <typename PointDst, std::size_t Index>
+    inline void apply(PointDst& point_dst) const
+    {
+        set<Index>(point_dst,
+               Function
+                <
+                    typename geometry::select_most_precise
+                        <
+                            typename geometry::coordinate_type<PointSrc>::type,
+                            typename geometry::coordinate_type<PointDst>::type
+                        >::type
+                >()(get<Index>(point_dst), get<Index>(m_point_src)));
+    }
+};
+
+
+template <typename Value>
+struct value_assignment
+{
+    Value m_value;
+
+    inline value_assignment(Value const &value)
+        : m_value(value)
+    {}
+
+    template <typename PointDst, std::size_t Index>
+    inline void apply(PointDst& point_dst) const
+    {
+        set<Index>(point_dst, m_value);
+    }
+};
+
+template <typename PointSrc>
+struct point_assignment
+{
+    PointSrc const& m_point_src;
+
+    inline point_assignment(PointSrc const& point)
+        : m_point_src(point)
+    {}
+
+    template <typename PointDst, std::size_t Index>
+    inline void apply(PointDst& point_dst) const
+    {
+        set<Index>(point_dst, get<Index>(m_point_src));
+    }
+};
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+/*!
+    \brief Adds the same value to each coordinate of a point
+    \ingroup arithmetic
+    \details
+    \tparam Point \tparam_point
+    \param p point
+    \param value value to add
+ */
+template <typename Point>
+inline void add_value(Point& p, typename detail::param<Point>::type value)
+{
+    BOOST_CONCEPT_ASSERT( (concepts::Point<Point>) );
+
+    for_each_coordinate(p,
+                        detail::value_operation
+                            <
+                                typename coordinate_type<Point>::type,
+                                std::plus
+                            >(value));
+}
+
+/*!
+    \brief Adds a point to another
+    \ingroup arithmetic
+    \details The coordinates of the second point will be added to those of the first point.
+             The second point is not modified.
+    \tparam Point1 \tparam_point
+    \tparam Point2 \tparam_point
+    \param p1 first point
+    \param p2 second point
+ */
+template <typename Point1, typename Point2>
+inline void add_point(Point1& p1, Point2 const& p2)
+{
+    BOOST_CONCEPT_ASSERT( (concepts::Point<Point1>) );
+    BOOST_CONCEPT_ASSERT( (concepts::ConstPoint<Point2>) );
+
+    for_each_coordinate(p1, detail::point_operation<Point2, std::plus>(p2));
+}
+
+/*!
+    \brief Subtracts the same value to each coordinate of a point
+    \ingroup arithmetic
+    \details
+    \tparam Point \tparam_point
+    \param p point
+    \param value value to subtract
+ */
+template <typename Point>
+inline void subtract_value(Point& p, typename detail::param<Point>::type value)
+{
+    BOOST_CONCEPT_ASSERT( (concepts::Point<Point>) );
+
+    for_each_coordinate(p,
+                        detail::value_operation
+                            <
+                                typename coordinate_type<Point>::type,
+                                std::minus
+                            >(value));
+}
+
+/*!
+    \brief Subtracts a point to another
+    \ingroup arithmetic
+    \details The coordinates of the second point will be subtracted to those of the first point.
+             The second point is not modified.
+    \tparam Point1 \tparam_point
+    \tparam Point2 \tparam_point
+    \param p1 first point
+    \param p2 second point
+ */
+template <typename Point1, typename Point2>
+inline void subtract_point(Point1& p1, Point2 const& p2)
+{
+    BOOST_CONCEPT_ASSERT( (concepts::Point<Point1>) );
+    BOOST_CONCEPT_ASSERT( (concepts::ConstPoint<Point2>) );
+
+    for_each_coordinate(p1, detail::point_operation<Point2, std::minus>(p2));
+}
+
+/*!
+    \brief Multiplies each coordinate of a point by the same value
+    \ingroup arithmetic
+    \details
+    \tparam Point \tparam_point
+    \param p point
+    \param value value to multiply by
+ */
+template <typename Point>
+inline void multiply_value(Point& p, typename detail::param<Point>::type value)
+{
+    BOOST_CONCEPT_ASSERT( (concepts::Point<Point>) );
+
+    for_each_coordinate(p,
+                        detail::value_operation
+                            <
+                                typename coordinate_type<Point>::type,
+                                std::multiplies
+                            >(value));
+}
+
+/*!
+    \brief Multiplies a point by another
+    \ingroup arithmetic
+    \details The coordinates of the first point will be multiplied by those of the second point.
+             The second point is not modified.
+    \tparam Point1 \tparam_point
+    \tparam Point2 \tparam_point
+    \param p1 first point
+    \param p2 second point
+    \note This is *not* a dot, cross or wedge product. It is a mere field-by-field multiplication.
+ */
+template <typename Point1, typename Point2>
+inline void multiply_point(Point1& p1, Point2 const& p2)
+{
+    BOOST_CONCEPT_ASSERT( (concepts::Point<Point1>) );
+    BOOST_CONCEPT_ASSERT( (concepts::ConstPoint<Point2>) );
+
+    for_each_coordinate(p1, detail::point_operation<Point2, std::multiplies>(p2));
+}
+
+/*!
+    \brief Divides each coordinate of the same point by a value
+    \ingroup arithmetic
+    \details
+    \tparam Point \tparam_point
+    \param p point
+    \param value value to divide by
+ */
+template <typename Point>
+inline void divide_value(Point& p, typename detail::param<Point>::type value)
+{
+    BOOST_CONCEPT_ASSERT( (concepts::Point<Point>) );
+
+    for_each_coordinate(p,
+                        detail::value_operation
+                            <
+                                typename coordinate_type<Point>::type,
+                                std::divides
+                            >(value));
+}
+
+/*!
+    \brief Divides a point by another
+    \ingroup arithmetic
+    \details The coordinates of the first point will be divided by those of the second point.
+             The second point is not modified.
+    \tparam Point1 \tparam_point
+    \tparam Point2 \tparam_point
+    \param p1 first point
+    \param p2 second point
+ */
+template <typename Point1, typename Point2>
+inline void divide_point(Point1& p1, Point2 const& p2)
+{
+    BOOST_CONCEPT_ASSERT( (concepts::Point<Point1>) );
+    BOOST_CONCEPT_ASSERT( (concepts::ConstPoint<Point2>) );
+
+    for_each_coordinate(p1, detail::point_operation<Point2, std::divides>(p2));
+}
+
+/*!
+    \brief Assign each coordinate of a point the same value
+    \ingroup arithmetic
+    \details
+    \tparam Point \tparam_point
+    \param p point
+    \param value value to assign
+ */
+template <typename Point>
+inline void assign_value(Point& p, typename detail::param<Point>::type value)
+{
+    BOOST_CONCEPT_ASSERT( (concepts::Point<Point>) );
+
+    for_each_coordinate(p,
+                        detail::value_assignment
+                            <
+                                typename coordinate_type<Point>::type
+                            >(value));
+}
+
+/*!
+    \brief Assign a point with another
+    \ingroup arithmetic
+    \details The coordinates of the first point will be assigned those of the second point.
+             The second point is not modified.
+    \tparam Point1 \tparam_point
+    \tparam Point2 \tparam_point
+    \param p1 first point
+    \param p2 second point
+ */
+template <typename Point1, typename Point2>
+inline void assign_point(Point1& p1, Point2 const& p2)
+{
+    BOOST_CONCEPT_ASSERT( (concepts::Point<Point1>) );
+    BOOST_CONCEPT_ASSERT( (concepts::ConstPoint<Point2>) );
+
+    for_each_coordinate(p1, detail::point_assignment<Point2>(p2));
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ARITHMETIC_ARITHMETIC_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/arithmetic/cross_product.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/arithmetic/cross_product.hpp
new file mode 100644
index 00000000000..485c2123b67
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/arithmetic/cross_product.hpp
@@ -0,0 +1,128 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2008-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+
+// This file was modified by Oracle on 2016.
+// Modifications copyright (c) 2016, Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ARITHMETIC_CROSS_PRODUCT_HPP
+#define BOOST_GEOMETRY_ARITHMETIC_CROSS_PRODUCT_HPP
+
+
+#include <cstddef>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/size_t.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <std::size_t Dimension>
+struct cross_product
+{
+    // We define cross product only for 2d (see Wolfram) and 3d.
+    // In Math, it is also well-defined for 7-dimension.
+    // Generalisation of cross product to n-dimension is defined as
+    // wedge product but it is not direct analogue to binary cross product.
+    BOOST_MPL_ASSERT_MSG((false),
+                         NOT_IMPLEMENTED_FOR_THIS_DIMENSION,
+                         (mpl::size_t<Dimension>));
+};
+
+template <>
+struct cross_product<2>
+{
+    template <typename P1, typename P2, typename ResultP>
+    static inline void apply(P1 const& p1, P2 const& p2, ResultP& result)
+    {
+        assert_dimension<P1, 2>();
+        assert_dimension<P2, 2>();
+        assert_dimension<ResultP, 2>();
+
+        // For 2-dimensions, analog of the cross product U(x,y) and V(x,y) is
+        // Ux * Vy - Uy * Vx
+        // which is returned as 0-component (or X) of 2d vector, 1-component is undefined.
+        set<0>(result, get<0>(p1) * get<1>(p2) - get<1>(p1) * get<0>(p2));
+    }
+};
+
+template <>
+struct cross_product<3>
+{
+    template <typename P1, typename P2, typename ResultP>
+    static inline void apply(P1 const& p1, P2 const& p2, ResultP& result)
+    {
+        assert_dimension<P1, 3>();
+        assert_dimension<P2, 3>();
+        assert_dimension<ResultP, 3>();
+
+        set<0>(result, get<1>(p1) * get<2>(p2) - get<2>(p1) * get<1>(p2));
+        set<1>(result, get<2>(p1) * get<0>(p2) - get<0>(p1) * get<2>(p2));
+        set<2>(result, get<0>(p1) * get<1>(p2) - get<1>(p1) * get<0>(p2));
+    }
+};
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+/*!
+\brief Computes the cross product of two vectors.
+\details All vectors should have the same dimension, 3 or 2.
+\ingroup arithmetic
+\param p1 first vector
+\param p2 second vector
+\return the cross product vector
+ */
+template <typename ResultP, typename P1, typename P2>
+inline ResultP cross_product(P1 const& p1, P2 const& p2)
+{
+    BOOST_CONCEPT_ASSERT( (concepts::Point<ResultP>) );
+    BOOST_CONCEPT_ASSERT( (concepts::ConstPoint<P1>) );
+    BOOST_CONCEPT_ASSERT( (concepts::ConstPoint<P2>) );
+
+    ResultP result;
+    detail::cross_product<dimension<ResultP>::value>::apply(p1, p2, result);
+    return result;
+}
+
+/*!
+\brief Computes the cross product of two vectors.
+\details All vectors should have the same dimension, 3 or 2.
+\ingroup arithmetic
+\param p1 first vector
+\param p2 second vector
+\return the cross product vector
+*/
+template <typename P>
+inline P cross_product(P const& p1, P const& p2)
+{
+    BOOST_CONCEPT_ASSERT((concepts::Point<P>));
+    BOOST_CONCEPT_ASSERT((concepts::ConstPoint<P>));
+
+    P result;
+    detail::cross_product<dimension<P>::value>::apply(p1, p2, result);
+    return result;
+}
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ARITHMETIC_CROSS_PRODUCT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/arithmetic/determinant.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/arithmetic/determinant.hpp
new file mode 100644
index 00000000000..59c596b1246
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/arithmetic/determinant.hpp
@@ -0,0 +1,78 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2008-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ARITHMETIC_DETERMINANT_HPP
+#define BOOST_GEOMETRY_ARITHMETIC_DETERMINANT_HPP
+
+
+#include <cstddef>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+#include <boost/geometry/util/select_coordinate_type.hpp>
+
+#include <boost/numeric/conversion/cast.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <typename ReturnType, typename U, typename V>
+class calculate_determinant
+{
+    template <typename T>
+    static inline ReturnType rt(T const& v)
+    {
+        return boost::numeric_cast<ReturnType>(v);
+    }
+
+public :
+
+    static inline ReturnType apply(U const& ux, U const& uy
+                                 , V const& vx, V const& vy)
+    {
+        return rt(ux) * rt(vy) - rt(uy) * rt(vx);
+    }
+};
+
+template <typename ReturnType, typename U, typename V>
+inline ReturnType determinant(U const& ux, U const& uy
+                            , V const& vx, V const& vy)
+{
+    return calculate_determinant
+        <
+            ReturnType, U, V
+        >::apply(ux, uy, vx, vy);
+}
+
+
+template <typename ReturnType, typename U, typename V>
+inline ReturnType determinant(U const& u, V const& v)
+{
+    BOOST_CONCEPT_ASSERT( (concepts::ConstPoint<U>) );
+    BOOST_CONCEPT_ASSERT( (concepts::ConstPoint<V>) );
+
+    return calculate_determinant
+        <
+            ReturnType,
+            typename geometry::coordinate_type<U>::type,
+            typename geometry::coordinate_type<V>::type
+        >::apply(get<0>(u), get<1>(u), get<0>(v), get<1>(v));
+}
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ARITHMETIC_DETERMINANT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/arithmetic/dot_product.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/arithmetic/dot_product.hpp
new file mode 100644
index 00000000000..747bd01ab05
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/arithmetic/dot_product.hpp
@@ -0,0 +1,84 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ARITHMETIC_DOT_PRODUCT_HPP
+#define BOOST_GEOMETRY_ARITHMETIC_DOT_PRODUCT_HPP
+
+
+#include <cstddef>
+
+#include <boost/concept/requires.hpp>
+
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+#include <boost/geometry/util/select_coordinate_type.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <typename P1, typename P2, std::size_t Dimension, std::size_t DimensionCount>
+struct dot_product_maker
+{
+    typedef typename select_coordinate_type<P1, P2>::type coordinate_type;
+
+    static inline coordinate_type apply(P1 const& p1, P2 const& p2)
+    {
+        return get<Dimension>(p1) * get<Dimension>(p2)
+            + dot_product_maker<P1, P2, Dimension+1, DimensionCount>::apply(p1, p2);
+    }
+};
+
+template <typename P1, typename P2, std::size_t DimensionCount>
+struct dot_product_maker<P1, P2, DimensionCount, DimensionCount>
+{
+    typedef typename select_coordinate_type<P1, P2>::type coordinate_type;
+
+    static inline coordinate_type apply(P1 const& p1, P2 const& p2)
+    {
+        return get<DimensionCount>(p1) * get<DimensionCount>(p2);
+    }
+};
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+/*!
+    \brief Computes the dot product (or scalar product) of 2 vectors (points).
+    \ingroup arithmetic
+    \tparam Point1 \tparam_point
+    \tparam Point2 \tparam_point
+    \param p1 first point
+    \param p2 second point
+    \return the dot product
+ */
+template <typename Point1, typename Point2>
+inline typename select_coordinate_type<Point1, Point2>::type dot_product(
+        Point1 const& p1, Point2 const& p2)
+{
+    BOOST_CONCEPT_ASSERT( (concepts::ConstPoint<Point1>) );
+    BOOST_CONCEPT_ASSERT( (concepts::ConstPoint<Point2>) );
+
+    return detail::dot_product_maker
+        <
+            Point1, Point2,
+            0, dimension<Point1>::type::value - 1
+        >::apply(p1, p2);
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ARITHMETIC_DOT_PRODUCT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/arithmetic/normalize.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/arithmetic/normalize.hpp
new file mode 100644
index 00000000000..7dfdbd2b039
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/arithmetic/normalize.hpp
@@ -0,0 +1,71 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2016, Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ARITHMETIC_NORMALIZE_HPP
+#define BOOST_GEOMETRY_ARITHMETIC_NORMALIZE_HPP
+
+
+#include <boost/geometry/core/coordinate_type.hpp>
+
+#include <boost/geometry/arithmetic/arithmetic.hpp>
+#include <boost/geometry/arithmetic/dot_product.hpp>
+#include <boost/geometry/util/math.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <typename Point>
+inline typename coordinate_type<Point>::type vec_length_sqr(Point const& pt)
+{
+    return dot_product(pt, pt);
+}
+
+template <typename Point>
+inline typename coordinate_type<Point>::type vec_length(Point const& pt)
+{
+    // NOTE: hypot() could be used instead of sqrt()
+    return math::sqrt(dot_product(pt, pt));
+}
+
+template <typename Point>
+inline bool vec_normalize(Point & pt, typename coordinate_type<Point>::type & len)
+{
+    typedef typename coordinate_type<Point>::type coord_t;
+
+    coord_t const c0 = 0;
+    len = vec_length(pt);
+    
+    if (math::equals(len, c0))
+    {
+        return false;
+    }
+
+    divide_value(pt, len);
+    return true;
+}
+
+template <typename Point>
+inline bool vec_normalize(Point & pt)
+{
+    typedef typename coordinate_type<Point>::type coord_t;
+    coord_t len;
+    return vec_normalize(pt, len);
+}
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ARITHMETIC_NORMALIZE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/formulas/andoyer_inverse.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/andoyer_inverse.hpp
new file mode 100644
index 00000000000..902fd7d8f65
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/andoyer_inverse.hpp
@@ -0,0 +1,260 @@
+// Boost.Geometry
+
+// Copyright (c) 2015-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_FORMULAS_ANDOYER_INVERSE_HPP
+#define BOOST_GEOMETRY_FORMULAS_ANDOYER_INVERSE_HPP
+
+
+#include <boost/math/constants/constants.hpp>
+
+#include <boost/geometry/core/radius.hpp>
+#include <boost/geometry/core/srs.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/formulas/differential_quantities.hpp>
+#include <boost/geometry/formulas/flattening.hpp>
+#include <boost/geometry/formulas/result_inverse.hpp>
+
+
+namespace boost { namespace geometry { namespace formula
+{
+
+/*!
+\brief The solution of the inverse problem of geodesics on latlong coordinates,
+       Forsyth-Andoyer-Lambert type approximation with first order terms.
+\author See
+    - Technical Report: PAUL D. THOMAS, MATHEMATICAL MODELS FOR NAVIGATION SYSTEMS, 1965
+      http://www.dtic.mil/docs/citations/AD0627893
+    - Technical Report: PAUL D. THOMAS, SPHEROIDAL GEODESICS, REFERENCE SYSTEMS, AND LOCAL GEOMETRY, 1970
+      http://www.dtic.mil/docs/citations/AD703541
+*/
+template <
+    typename CT,
+    bool EnableDistance,
+    bool EnableAzimuth,
+    bool EnableReverseAzimuth = false,
+    bool EnableReducedLength = false,
+    bool EnableGeodesicScale = false
+>
+class andoyer_inverse
+{
+    static const bool CalcQuantities = EnableReducedLength || EnableGeodesicScale;
+    static const bool CalcAzimuths = EnableAzimuth || EnableReverseAzimuth || CalcQuantities;
+    static const bool CalcFwdAzimuth = EnableAzimuth || CalcQuantities;
+    static const bool CalcRevAzimuth = EnableReverseAzimuth || CalcQuantities;
+
+public:
+    typedef result_inverse<CT> result_type;
+
+    template <typename T1, typename T2, typename Spheroid>
+    static inline result_type apply(T1 const& lon1,
+                                    T1 const& lat1,
+                                    T2 const& lon2,
+                                    T2 const& lat2,
+                                    Spheroid const& spheroid)
+    {
+        result_type result;
+
+        // coordinates in radians
+
+        if ( math::equals(lon1, lon2) && math::equals(lat1, lat2) )
+        {
+            return result;
+        }
+
+        CT const c0 = CT(0);
+        CT const c1 = CT(1);
+        CT const pi = math::pi<CT>();
+        CT const f = formula::flattening<CT>(spheroid);
+
+        CT const dlon = lon2 - lon1;
+        CT const sin_dlon = sin(dlon);
+        CT const cos_dlon = cos(dlon);
+        CT const sin_lat1 = sin(lat1);
+        CT const cos_lat1 = cos(lat1);
+        CT const sin_lat2 = sin(lat2);
+        CT const cos_lat2 = cos(lat2);
+
+        // H,G,T = infinity if cos_d = 1 or cos_d = -1
+        // lat1 == +-90 && lat2 == +-90
+        // lat1 == lat2 && lon1 == lon2
+        CT cos_d = sin_lat1*sin_lat2 + cos_lat1*cos_lat2*cos_dlon;
+        // on some platforms cos_d may be outside valid range
+        if (cos_d < -c1)
+            cos_d = -c1;
+        else if (cos_d > c1)
+            cos_d = c1;
+
+        CT const d = acos(cos_d); // [0, pi]
+        CT const sin_d = sin(d);  // [-1, 1]
+
+        if ( BOOST_GEOMETRY_CONDITION(EnableDistance) )
+        {
+            CT const K = math::sqr(sin_lat1-sin_lat2);
+            CT const L = math::sqr(sin_lat1+sin_lat2);
+            CT const three_sin_d = CT(3) * sin_d;
+
+            CT const one_minus_cos_d = c1 - cos_d;
+            CT const one_plus_cos_d = c1 + cos_d;
+            // cos_d = 1 or cos_d = -1 means that the points are antipodal
+
+            CT const H = math::equals(one_minus_cos_d, c0) ?
+                            c0 :
+                            (d + three_sin_d) / one_minus_cos_d;
+            CT const G = math::equals(one_plus_cos_d, c0) ?
+                            c0 :
+                            (d - three_sin_d) / one_plus_cos_d;
+
+            CT const dd = -(f/CT(4))*(H*K+G*L);
+
+            CT const a = get_radius<0>(spheroid);
+
+            result.distance = a * (d + dd);
+        }
+
+        if ( BOOST_GEOMETRY_CONDITION(CalcAzimuths) )
+        {
+            // sin_d = 0 <=> antipodal points
+            if (math::equals(sin_d, c0))
+            {
+                // T = inf
+                // dA = inf
+                // azimuth = -inf
+                result.azimuth = lat1 <= lat2 ? c0 : pi;
+            }
+            else
+            {
+                CT const c2 = CT(2);
+
+                CT A = c0;
+                CT U = c0;
+                if (math::equals(cos_lat2, c0))
+                {
+                    if (sin_lat2 < c0)
+                    {
+                        A = pi;
+                    }
+                }
+                else
+                {
+                    CT const tan_lat2 = sin_lat2/cos_lat2;
+                    CT const M = cos_lat1*tan_lat2-sin_lat1*cos_dlon;
+                    A = atan2(sin_dlon, M);
+                    CT const sin_2A = sin(c2*A);
+                    U = (f/ c2)*math::sqr(cos_lat1)*sin_2A;
+                }
+
+                CT B = c0;
+                CT V = c0;
+                if (math::equals(cos_lat1, c0))
+                {
+                    if (sin_lat1 < c0)
+                    {
+                        B = pi;
+                    }
+                }
+                else
+                {
+                    CT const tan_lat1 = sin_lat1/cos_lat1;
+                    CT const N = cos_lat2*tan_lat1-sin_lat2*cos_dlon;
+                    B = atan2(sin_dlon, N);
+                    CT const sin_2B = sin(c2*B);
+                    V = (f/ c2)*math::sqr(cos_lat2)*sin_2B;
+                }
+
+                CT const T = d / sin_d;
+
+                // even with sin_d == 0 checked above if the second point
+                // is somewhere in the antipodal area T may still be great
+                // therefore dA and dB may be great and the resulting azimuths
+                // may be some more or less arbitrary angles
+
+                if (BOOST_GEOMETRY_CONDITION(CalcFwdAzimuth))
+                {
+                    CT const dA = V*T - U;
+                    result.azimuth = A - dA;
+                    normalize_azimuth(result.azimuth, A, dA);
+                }
+
+                if (BOOST_GEOMETRY_CONDITION(CalcRevAzimuth))
+                {
+                    CT const dB = -U*T + V;
+                    result.reverse_azimuth = pi - B - dB;
+                    if (result.reverse_azimuth > pi)
+                    {
+                        result.reverse_azimuth -= 2 * pi;
+                    }
+                    normalize_azimuth(result.reverse_azimuth, B, dB);
+                }
+            }
+        }
+
+        if (BOOST_GEOMETRY_CONDITION(CalcQuantities))
+        {
+            typedef differential_quantities<CT, EnableReducedLength, EnableGeodesicScale, 1> quantities;
+            quantities::apply(dlon, sin_lat1, cos_lat1, sin_lat2, cos_lat2,
+                              result.azimuth, result.reverse_azimuth,
+                              get_radius<2>(spheroid), f,
+                              result.reduced_length, result.geodesic_scale);
+        }
+
+        return result;
+    }
+
+private:
+    static inline void normalize_azimuth(CT & azimuth, CT const& A, CT const& dA)
+    {
+        CT const c0 = 0;
+        
+        if (A >= c0) // A indicates Eastern hemisphere
+        {
+            if (dA >= c0) // A altered towards 0
+            {
+                if (azimuth < c0)
+                {
+                    azimuth = c0;
+                }
+            }
+            else // dA < 0, A altered towards pi
+            {
+                CT const pi = math::pi<CT>();
+                if (azimuth > pi)
+                {
+                    azimuth = pi;
+                }
+            }
+        }
+        else // A indicates Western hemisphere
+        {
+            if (dA <= c0) // A altered towards 0
+            {
+                if (azimuth > c0)
+                {
+                    azimuth = c0;
+                }
+            }
+            else // dA > 0, A altered towards -pi
+            {
+                CT const minus_pi = -math::pi<CT>();
+                if (azimuth < minus_pi)
+                {
+                    azimuth = minus_pi;
+                }
+            }
+        }
+    }
+};
+
+}}} // namespace boost::geometry::formula
+
+
+#endif // BOOST_GEOMETRY_FORMULAS_ANDOYER_INVERSE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/formulas/area_formulas.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/area_formulas.hpp
new file mode 100644
index 00000000000..6a0b525e250
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/area_formulas.hpp
@@ -0,0 +1,578 @@
+// Boost.Geometry
+
+// Copyright (c) 2015-2016 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_FORMULAS_AREA_FORMULAS_HPP
+#define BOOST_GEOMETRY_FORMULAS_AREA_FORMULAS_HPP
+
+#include <boost/geometry/formulas/flattening.hpp>
+#include <boost/math/special_functions/hypot.hpp>
+
+namespace boost { namespace geometry { namespace formula
+{
+
+/*!
+\brief Formulas for computing spherical and ellipsoidal polygon area.
+ The current class computes the area of the trapezoid defined by a segment
+ the two meridians passing by the endpoints and the equator.
+\author See
+- Danielsen JS, The area under the geodesic. Surv Rev 30(232):
+61–66, 1989
+- Charles F.F Karney, Algorithms for geodesics, 2011
+https://arxiv.org/pdf/1109.4448.pdf
+*/
+
+template <
+        typename CT,
+        std::size_t SeriesOrder = 2,
+        bool ExpandEpsN = true
+>
+class area_formulas
+{
+
+public:
+
+    //TODO: move the following to a more general space to be used by other
+    //      classes as well
+    /*
+        Evaluate the polynomial in x using Horner's method.
+    */
+    template <typename NT, typename IteratorType>
+    static inline NT horner_evaluate(NT x,
+                                     IteratorType begin,
+                                     IteratorType end)
+    {
+        NT result(0);
+        IteratorType it = end;
+        do
+        {
+            result = result * x + *--it;
+        }
+        while (it != begin);
+        return result;
+    }
+
+    /*
+        Clenshaw algorithm for summing trigonometric series
+        https://en.wikipedia.org/wiki/Clenshaw_algorithm
+    */
+    template <typename NT, typename IteratorType>
+    static inline NT clenshaw_sum(NT cosx,
+                                  IteratorType begin,
+                                  IteratorType end)
+    {
+        IteratorType it = end;
+        bool odd = true;
+        CT b_k, b_k1(0), b_k2(0);
+        do
+        {
+            CT c_k = odd ? *--it : NT(0);
+            b_k = c_k + NT(2) * cosx * b_k1 - b_k2;
+            b_k2 = b_k1;
+            b_k1 = b_k;
+            odd = !odd;
+        }
+        while (it != begin);
+
+        return *begin + b_k1 * cosx - b_k2;
+    }
+
+    template<typename T>
+    static inline void normalize(T& x, T& y)
+    {
+        T h = boost::math::hypot(x, y);
+        x /= h;
+        y /= h;
+    }
+
+    /*
+     Generate and evaluate the series expansion of the following integral
+
+        I4 = -integrate( (t(ep2) - t(k2*sin(sigma1)^2)) / (ep2 - k2*sin(sigma1)^2)
+           * sin(sigma1)/2, sigma1, pi/2, sigma )
+     where
+
+        t(x) = sqrt(1+1/x)*asinh(sqrt(x)) + x
+
+     valid for ep2 and k2 small.  We substitute k2 = 4 * eps / (1 - eps)^2
+     and ep2 = 4 * n / (1 - n)^2 and expand in eps and n.
+
+     The resulting sum of the series is of the form
+
+        sum(C4[l] * cos((2*l+1)*sigma), l, 0, maxpow-1) )
+
+     The above expansion is performed in Computer Algebra System Maxima.
+     The C++ code (that yields the function evaluate_coeffs_n below) is generated
+     by the following Maxima script and is based on script:
+     http://geographiclib.sourceforge.net/html/geod.mac
+
+        // Maxima script begin
+        taylordepth:5$
+        ataylor(expr,var,ord):=expand(ratdisrep(taylor(expr,var,0,ord)))$
+        jtaylor(expr,var1,var2,ord):=block([zz],expand(subst([zz=1],
+        ratdisrep(taylor(subst([var1=zz*var1,var2=zz*var2],expr),zz,0,ord)))))$
+
+        compute(maxpow):=block([int,t,intexp,area, x,ep2,k2],
+        maxpow:maxpow-1,
+        t : sqrt(1+1/x) * asinh(sqrt(x)) + x,
+        int:-(tf(ep2) - tf(k2*sin(sigma)^2)) / (ep2 - k2*sin(sigma)^2)
+        * sin(sigma)/2,
+        int:subst([tf(ep2)=subst([x=ep2],t),
+        tf(k2*sin(sigma)^2)=subst([x=k2*sin(sigma)^2],t)],
+        int),
+        int:subst([abs(sin(sigma))=sin(sigma)],int),
+        int:subst([k2=4*eps/(1-eps)^2,ep2=4*n/(1-n)^2],int),
+        intexp:jtaylor(int,n,eps,maxpow),
+        area:trigreduce(integrate(intexp,sigma)),
+        area:expand(area-subst(sigma=%pi/2,area)),
+        for i:0 thru maxpow do C4[i]:coeff(area,cos((2*i+1)*sigma)),
+        if expand(area-sum(C4[i]*cos((2*i+1)*sigma),i,0,maxpow)) # 0
+        then error("left over terms in I4"),
+        'done)$
+
+        printcode(maxpow):=
+        block([tab2:"    ",tab3:"      "],
+        print(" switch (SeriesOrder) {"),
+        for nn:1 thru maxpow do block([c],
+        print(concat(tab2,"case ",string(nn-1),":")),
+        c:0,
+        for m:0 thru nn-1 do block(
+          [q:jtaylor(subst([n=n],C4[m]),n,eps,nn-1),
+          linel:1200],
+          for j:m thru nn-1 do (
+            print(concat(tab3,"coeffs_n[",c,"] = ",
+                string(horner(coeff(q,eps,j))),";")),
+            c:c+1)
+        ),
+        print(concat(tab3,"break;"))),
+        print("    }"),
+        'done)$
+
+        maxpow:6$
+        compute(maxpow)$
+        printcode(maxpow)$
+        // Maxima script end
+
+     In the resulting code we should replace each number x by CT(x)
+     e.g. using the following scirpt:
+       sed -e 's/[0-9]\+/CT(&)/g; s/\[CT(/\[/g; s/)\]/\]/g;
+               s/case\sCT(/case /g; s/):/:/g'
+    */
+
+    static inline void evaluate_coeffs_n(CT n, CT coeffs_n[])
+    {
+
+        switch (SeriesOrder) {
+        case 0:
+            coeffs_n[0] = CT(2)/CT(3);
+            break;
+        case 1:
+            coeffs_n[0] = (CT(10)-CT(4)*n)/CT(15);
+            coeffs_n[1] = -CT(1)/CT(5);
+            coeffs_n[2] = CT(1)/CT(45);
+            break;
+        case 2:
+            coeffs_n[0] = (n*(CT(8)*n-CT(28))+CT(70))/CT(105);
+            coeffs_n[1] = (CT(16)*n-CT(7))/CT(35);
+            coeffs_n[2] = -CT(2)/CT(105);
+            coeffs_n[3] = (CT(7)-CT(16)*n)/CT(315);
+            coeffs_n[4] = -CT(2)/CT(105);
+            coeffs_n[5] = CT(4)/CT(525);
+            break;
+        case 3:
+            coeffs_n[0] = (n*(n*(CT(4)*n+CT(24))-CT(84))+CT(210))/CT(315);
+            coeffs_n[1] = ((CT(48)-CT(32)*n)*n-CT(21))/CT(105);
+            coeffs_n[2] = (-CT(32)*n-CT(6))/CT(315);
+            coeffs_n[3] = CT(11)/CT(315);
+            coeffs_n[4] = (n*(CT(32)*n-CT(48))+CT(21))/CT(945);
+            coeffs_n[5] = (CT(64)*n-CT(18))/CT(945);
+            coeffs_n[6] = -CT(1)/CT(105);
+            coeffs_n[7] = (CT(12)-CT(32)*n)/CT(1575);
+            coeffs_n[8] = -CT(8)/CT(1575);
+            coeffs_n[9] = CT(8)/CT(2205);
+            break;
+        case 4:
+            coeffs_n[0] = (n*(n*(n*(CT(16)*n+CT(44))+CT(264))-CT(924))+CT(2310))/CT(3465);
+            coeffs_n[1] = (n*(n*(CT(48)*n-CT(352))+CT(528))-CT(231))/CT(1155);
+            coeffs_n[2] = (n*(CT(1088)*n-CT(352))-CT(66))/CT(3465);
+            coeffs_n[3] = (CT(121)-CT(368)*n)/CT(3465);
+            coeffs_n[4] = CT(4)/CT(1155);
+            coeffs_n[5] = (n*((CT(352)-CT(48)*n)*n-CT(528))+CT(231))/CT(10395);
+            coeffs_n[6] = ((CT(704)-CT(896)*n)*n-CT(198))/CT(10395);
+            coeffs_n[7] = (CT(80)*n-CT(99))/CT(10395);
+            coeffs_n[8] = CT(4)/CT(1155);
+            coeffs_n[9] = (n*(CT(320)*n-CT(352))+CT(132))/CT(17325);
+            coeffs_n[10] = (CT(384)*n-CT(88))/CT(17325);
+            coeffs_n[11] = -CT(8)/CT(1925);
+            coeffs_n[12] = (CT(88)-CT(256)*n)/CT(24255);
+            coeffs_n[13] = -CT(16)/CT(8085);
+            coeffs_n[14] = CT(64)/CT(31185);
+            break;
+        case 5:
+            coeffs_n[0] = (n*(n*(n*(n*(CT(100)*n+CT(208))+CT(572))+CT(3432))-CT(12012))+CT(30030))
+                          /CT(45045);
+            coeffs_n[1] = (n*(n*(n*(CT(64)*n+CT(624))-CT(4576))+CT(6864))-CT(3003))/CT(15015);
+            coeffs_n[2] = (n*((CT(14144)-CT(10656)*n)*n-CT(4576))-CT(858))/CT(45045);
+            coeffs_n[3] = ((-CT(224)*n-CT(4784))*n+CT(1573))/CT(45045);
+            coeffs_n[4] = (CT(1088)*n+CT(156))/CT(45045);
+            coeffs_n[5] = CT(97)/CT(15015);
+            coeffs_n[6] = (n*(n*((-CT(64)*n-CT(624))*n+CT(4576))-CT(6864))+CT(3003))/CT(135135);
+            coeffs_n[7] = (n*(n*(CT(5952)*n-CT(11648))+CT(9152))-CT(2574))/CT(135135);
+            coeffs_n[8] = (n*(CT(5792)*n+CT(1040))-CT(1287))/CT(135135);
+            coeffs_n[9] = (CT(468)-CT(2944)*n)/CT(135135);
+            coeffs_n[10] = CT(1)/CT(9009);
+            coeffs_n[11] = (n*((CT(4160)-CT(1440)*n)*n-CT(4576))+CT(1716))/CT(225225);
+            coeffs_n[12] = ((CT(4992)-CT(8448)*n)*n-CT(1144))/CT(225225);
+            coeffs_n[13] = (CT(1856)*n-CT(936))/CT(225225);
+            coeffs_n[14] = CT(8)/CT(10725);
+            coeffs_n[15] = (n*(CT(3584)*n-CT(3328))+CT(1144))/CT(315315);
+            coeffs_n[16] = (CT(1024)*n-CT(208))/CT(105105);
+            coeffs_n[17] = -CT(136)/CT(63063);
+            coeffs_n[18] = (CT(832)-CT(2560)*n)/CT(405405);
+            coeffs_n[19] = -CT(128)/CT(135135);
+            coeffs_n[20] = CT(128)/CT(99099);
+            break;
+        }
+    }
+
+    /*
+       Expand in k2 and ep2.
+    */
+    static inline void evaluate_coeffs_ep(CT ep, CT coeffs_n[])
+    {
+        switch (SeriesOrder) {
+        case 0:
+            coeffs_n[0] = CT(2)/CT(3);
+            break;
+        case 1:
+            coeffs_n[0] = (CT(10)-ep)/CT(15);
+            coeffs_n[1] = -CT(1)/CT(20);
+            coeffs_n[2] = CT(1)/CT(180);
+            break;
+        case 2:
+            coeffs_n[0] = (ep*(CT(4)*ep-CT(7))+CT(70))/CT(105);
+            coeffs_n[1] = (CT(4)*ep-CT(7))/CT(140);
+            coeffs_n[2] = CT(1)/CT(42);
+            coeffs_n[3] = (CT(7)-CT(4)*ep)/CT(1260);
+            coeffs_n[4] = -CT(1)/CT(252);
+            coeffs_n[5] = CT(1)/CT(2100);
+            break;
+        case 3:
+            coeffs_n[0] = (ep*((CT(12)-CT(8)*ep)*ep-CT(21))+CT(210))/CT(315);
+            coeffs_n[1] = ((CT(12)-CT(8)*ep)*ep-CT(21))/CT(420);
+            coeffs_n[2] = (CT(3)-CT(2)*ep)/CT(126);
+            coeffs_n[3] = -CT(1)/CT(72);
+            coeffs_n[4] = (ep*(CT(8)*ep-CT(12))+CT(21))/CT(3780);
+            coeffs_n[5] = (CT(2)*ep-CT(3))/CT(756);
+            coeffs_n[6] = CT(1)/CT(360);
+            coeffs_n[7] = (CT(3)-CT(2)*ep)/CT(6300);
+            coeffs_n[8] = -CT(1)/CT(1800);
+            coeffs_n[9] = CT(1)/CT(17640);
+            break;
+        case 4:
+            coeffs_n[0] = (ep*(ep*(ep*(CT(64)*ep-CT(88))+CT(132))-CT(231))+CT(2310))/CT(3465);
+            coeffs_n[1] = (ep*(ep*(CT(64)*ep-CT(88))+CT(132))-CT(231))/CT(4620);
+            coeffs_n[2] = (ep*(CT(16)*ep-CT(22))+CT(33))/CT(1386);
+            coeffs_n[3] = (CT(8)*ep-CT(11))/CT(792);
+            coeffs_n[4] = CT(1)/CT(110);
+            coeffs_n[5] = (ep*((CT(88)-CT(64)*ep)*ep-CT(132))+CT(231))/CT(41580);
+            coeffs_n[6] = ((CT(22)-CT(16)*ep)*ep-CT(33))/CT(8316);
+            coeffs_n[7] = (CT(11)-CT(8)*ep)/CT(3960);
+            coeffs_n[8] = -CT(1)/CT(495);
+            coeffs_n[9] = (ep*(CT(16)*ep-CT(22))+CT(33))/CT(69300);
+            coeffs_n[10] = (CT(8)*ep-CT(11))/CT(19800);
+            coeffs_n[11] = CT(1)/CT(1925);
+            coeffs_n[12] = (CT(11)-CT(8)*ep)/CT(194040);
+            coeffs_n[13] = -CT(1)/CT(10780);
+            coeffs_n[14] = CT(1)/CT(124740);
+            break;
+        case 5:
+            coeffs_n[0] = (ep*(ep*(ep*((CT(832)-CT(640)*ep)*ep-CT(1144))+CT(1716))-CT(3003))+CT(30030))/CT(45045);
+            coeffs_n[1] = (ep*(ep*((CT(832)-CT(640)*ep)*ep-CT(1144))+CT(1716))-CT(3003))/CT(60060);
+            coeffs_n[2] = (ep*((CT(208)-CT(160)*ep)*ep-CT(286))+CT(429))/CT(18018);
+            coeffs_n[3] = ((CT(104)-CT(80)*ep)*ep-CT(143))/CT(10296);
+            coeffs_n[4] = (CT(13)-CT(10)*ep)/CT(1430);
+            coeffs_n[5] = -CT(1)/CT(156);
+            coeffs_n[6] = (ep*(ep*(ep*(CT(640)*ep-CT(832))+CT(1144))-CT(1716))+CT(3003))/CT(540540);
+            coeffs_n[7] = (ep*(ep*(CT(160)*ep-CT(208))+CT(286))-CT(429))/CT(108108);
+            coeffs_n[8] = (ep*(CT(80)*ep-CT(104))+CT(143))/CT(51480);
+            coeffs_n[9] = (CT(10)*ep-CT(13))/CT(6435);
+            coeffs_n[10] = CT(5)/CT(3276);
+            coeffs_n[11] = (ep*((CT(208)-CT(160)*ep)*ep-CT(286))+CT(429))/CT(900900);
+            coeffs_n[12] = ((CT(104)-CT(80)*ep)*ep-CT(143))/CT(257400);
+            coeffs_n[13] = (CT(13)-CT(10)*ep)/CT(25025);
+            coeffs_n[14] = -CT(1)/CT(2184);
+            coeffs_n[15] = (ep*(CT(80)*ep-CT(104))+CT(143))/CT(2522520);
+            coeffs_n[16] = (CT(10)*ep-CT(13))/CT(140140);
+            coeffs_n[17] = CT(5)/CT(45864);
+            coeffs_n[18] = (CT(13)-CT(10)*ep)/CT(1621620);
+            coeffs_n[19] = -CT(1)/CT(58968);
+            coeffs_n[20] = CT(1)/CT(792792);
+            break;
+        }
+    }
+
+    /*
+        Given the set of coefficients coeffs1[] evaluate on var2 and return
+        the set of coefficients coeffs2[]
+    */
+    static inline void evaluate_coeffs_var2(CT var2,
+                                            CT coeffs1[],
+                                            CT coeffs2[]){
+        std::size_t begin(0), end(0);
+        for(std::size_t i = 0; i <= SeriesOrder; i++){
+            end = begin + SeriesOrder + 1 - i;
+            coeffs2[i] = ((i==0) ? CT(1) : pow(var2,int(i)))
+                        * horner_evaluate(var2, coeffs1 + begin, coeffs1 + end);
+            begin = end;
+        }
+    }
+
+    /*
+        Compute the spherical excess of a geodesic (or shperical) segment
+    */
+    template <
+                bool LongSegment,
+                typename PointOfSegment
+             >
+    static inline CT spherical(PointOfSegment const& p1,
+                               PointOfSegment const& p2)
+    {
+        CT excess;
+
+        if(LongSegment) // not for segments parallel to equator
+        {
+            CT cbet1 = cos(geometry::get_as_radian<1>(p1));
+            CT sbet1 = sin(geometry::get_as_radian<1>(p1));
+            CT cbet2 = cos(geometry::get_as_radian<1>(p2));
+            CT sbet2 = sin(geometry::get_as_radian<1>(p2));
+
+            CT omg12 = geometry::get_as_radian<0>(p1)
+                     - geometry::get_as_radian<0>(p2);
+            CT comg12 = cos(omg12);
+            CT somg12 = sin(omg12);
+
+            CT alp1 = atan2(cbet1 * sbet2
+                            - sbet1 * cbet2 * comg12,
+                            cbet2 * somg12);
+
+            CT alp2 = atan2(cbet1 * sbet2 * comg12
+                            - sbet1 * cbet2,
+                            cbet1 * somg12);
+
+            excess = alp2 - alp1;
+
+        } else {
+
+            // Trapezoidal formula
+
+            CT tan_lat1 =
+                    tan(geometry::get_as_radian<1>(p1) / 2.0);
+            CT tan_lat2 =
+                    tan(geometry::get_as_radian<1>(p2) / 2.0);
+
+            excess = CT(2.0)
+                    * atan(((tan_lat1 + tan_lat2) / (CT(1) + tan_lat1 * tan_lat2))
+                           * tan((geometry::get_as_radian<0>(p2)
+                                - geometry::get_as_radian<0>(p1)) / 2));
+        }
+
+        return excess;
+    }
+
+    struct return_type_ellipsoidal
+    {
+        return_type_ellipsoidal()
+            :   spherical_term(0),
+                ellipsoidal_term(0)
+        {}
+
+        CT spherical_term;
+        CT ellipsoidal_term;
+    };
+
+    /*
+        Compute the ellipsoidal correction of a geodesic (or shperical) segment
+    */
+    template <
+                template <typename, bool, bool, bool, bool, bool> class Inverse,
+                //typename AzimuthStrategy,
+                typename PointOfSegment,
+                typename SpheroidConst
+             >
+    static inline return_type_ellipsoidal ellipsoidal(PointOfSegment const& p1,
+                                                      PointOfSegment const& p2,
+                                                      SpheroidConst spheroid_const)
+    {
+        return_type_ellipsoidal result;
+
+        // Azimuth Approximation
+
+        typedef Inverse<CT, false, true, true, false, false> inverse_type;
+        typedef typename inverse_type::result_type inverse_result;
+
+        inverse_result i_res = inverse_type::apply(get_as_radian<0>(p1),
+                                                   get_as_radian<1>(p1),
+                                                   get_as_radian<0>(p2),
+                                                   get_as_radian<1>(p2),
+                                                   spheroid_const.m_spheroid);
+
+        CT alp1 = i_res.azimuth;
+        CT alp2 = i_res.reverse_azimuth;
+
+        // Constants
+
+        CT const ep = spheroid_const.m_ep;
+        CT const f = formula::flattening<CT>(spheroid_const.m_spheroid);
+        CT const one_minus_f = CT(1) - f;
+        std::size_t const series_order_plus_one = SeriesOrder + 1;
+        std::size_t const series_order_plus_two = SeriesOrder + 2;
+
+        // Basic trigonometric computations
+
+        CT tan_bet1 = tan(get_as_radian<1>(p1)) * one_minus_f;
+        CT tan_bet2 = tan(get_as_radian<1>(p2)) * one_minus_f;
+        CT cos_bet1 = cos(atan(tan_bet1));
+        CT cos_bet2 = cos(atan(tan_bet2));
+        CT sin_bet1 = tan_bet1 * cos_bet1;
+        CT sin_bet2 = tan_bet2 * cos_bet2;
+        CT sin_alp1 = sin(alp1);
+        CT cos_alp1 = cos(alp1);
+        CT cos_alp2 = cos(alp2);
+        CT sin_alp0 = sin_alp1 * cos_bet1;
+
+        // Spherical term computation
+
+        CT sin_omg1 = sin_alp0 * sin_bet1;
+        CT cos_omg1 = cos_alp1 * cos_bet1;
+        CT sin_omg2 = sin_alp0 * sin_bet2;
+        CT cos_omg2 = cos_alp2 * cos_bet2;
+        CT cos_omg12 =  cos_omg1 * cos_omg2 + sin_omg1 * sin_omg2;
+        CT excess;
+
+        bool meridian = get<0>(p2) - get<0>(p1) == CT(0)
+              || get<1>(p1) == CT(90) || get<1>(p1) == -CT(90)
+              || get<1>(p2) == CT(90) || get<1>(p2) == -CT(90);
+
+        if (!meridian && cos_omg12 > -CT(0.7)
+                      && sin_bet2 - sin_bet1 < CT(1.75)) // short segment
+        {
+            CT sin_omg12 =  cos_omg1 * sin_omg2 - sin_omg1 * cos_omg2;
+            normalize(sin_omg12, cos_omg12);
+
+            CT cos_omg12p1 = CT(1) + cos_omg12;
+            CT cos_bet1p1 = CT(1) + cos_bet1;
+            CT cos_bet2p1 = CT(1) + cos_bet2;
+            excess = CT(2) * atan2(sin_omg12 * (sin_bet1 * cos_bet2p1 + sin_bet2 * cos_bet1p1),
+                                cos_omg12p1 * (sin_bet1 * sin_bet2 + cos_bet1p1 * cos_bet2p1));
+        }
+        else
+        {
+            /*
+                    CT sin_alp2 = sin(alp2);
+                    CT sin_alp12 = sin_alp2 * cos_alp1 - cos_alp2 * sin_alp1;
+                    CT cos_alp12 = cos_alp2 * cos_alp1 + sin_alp2 * sin_alp1;
+                    excess = atan2(sin_alp12, cos_alp12);
+            */
+                    excess = alp2 - alp1;
+        }
+
+        result.spherical_term = excess;
+
+        // Ellipsoidal term computation (uses integral approximation)
+
+        CT cos_alp0 = math::sqrt(CT(1) - math::sqr(sin_alp0));
+        CT cos_sig1 = cos_alp1 * cos_bet1;
+        CT cos_sig2 = cos_alp2 * cos_bet2;
+        CT sin_sig1 = sin_bet1;
+        CT sin_sig2 = sin_bet2;
+
+        normalize(sin_sig1, cos_sig1);
+        normalize(sin_sig2, cos_sig2);
+
+        CT coeffs[SeriesOrder + 1];
+        const std::size_t coeffs_var_size = (series_order_plus_two
+                                            * series_order_plus_one) / 2;
+        CT coeffs_var[coeffs_var_size];
+
+        if(ExpandEpsN){ // expand by eps and n
+
+            CT k2 = math::sqr(ep * cos_alp0);
+            CT sqrt_k2_plus_one = math::sqrt(CT(1) + k2);
+            CT eps = (sqrt_k2_plus_one - CT(1)) / (sqrt_k2_plus_one + CT(1));
+            CT n = f / (CT(2) - f);
+
+            // Generate and evaluate the polynomials on n
+            // to get the series coefficients (that depend on eps)
+            evaluate_coeffs_n(n, coeffs_var);
+
+            // Generate and evaluate the polynomials on eps (i.e. var2 = eps)
+            // to get the final series coefficients
+            evaluate_coeffs_var2(eps, coeffs_var, coeffs);
+
+        }else{ // expand by k2 and ep
+
+            CT k2 = math::sqr(ep * cos_alp0);
+            CT ep2 = math::sqr(ep);
+
+            // Generate and evaluate the polynomials on ep2
+            evaluate_coeffs_ep(ep2, coeffs_var);
+
+            // Generate and evaluate the polynomials on k2 (i.e. var2 = k2)
+            evaluate_coeffs_var2(k2, coeffs_var, coeffs);
+
+        }
+
+        // Evaluate the trigonometric sum
+        CT I12 = clenshaw_sum(cos_sig2, coeffs, coeffs + series_order_plus_one)
+               - clenshaw_sum(cos_sig1, coeffs, coeffs + series_order_plus_one);
+
+        // The part of the ellipsodal correction that depends on
+        // point coordinates
+        result.ellipsoidal_term = cos_alp0 * sin_alp0 * I12;
+
+        return result;
+    }
+
+    // Keep track whenever a segment crosses the prime meridian
+    // First normalize to [0,360)
+    template <typename PointOfSegment, typename StateType>
+    static inline int crosses_prime_meridian(PointOfSegment const& p1,
+                                             PointOfSegment const& p2,
+                                             StateType& state)
+    {
+        CT const pi
+            = geometry::math::pi<CT>();
+        CT const two_pi
+            = geometry::math::two_pi<CT>();
+
+        CT p1_lon = get_as_radian<0>(p1)
+                                - ( floor( get_as_radian<0>(p1) / two_pi )
+                                  * two_pi );
+        CT p2_lon = get_as_radian<0>(p2)
+                                - ( floor( get_as_radian<0>(p2) / two_pi )
+                                  * two_pi );
+
+        CT max_lon = (std::max)(p1_lon, p2_lon);
+        CT min_lon = (std::min)(p1_lon, p2_lon);
+
+        if(max_lon > pi && min_lon < pi && max_lon - min_lon > pi)
+        {
+            state.m_crosses_prime_meridian++;
+        }
+
+        return state.m_crosses_prime_meridian;
+    }
+
+};
+
+}}} // namespace boost::geometry::formula
+
+
+#endif // BOOST_GEOMETRY_FORMULAS_AREA_FORMULAS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/formulas/differential_quantities.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/differential_quantities.hpp
new file mode 100644
index 00000000000..ff2ec539db5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/differential_quantities.hpp
@@ -0,0 +1,303 @@
+// Boost.Geometry
+
+// Copyright (c) 2016-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_FORMULAS_INVERSE_DIFFERENTIAL_QUANTITIES_HPP
+#define BOOST_GEOMETRY_FORMULAS_INVERSE_DIFFERENTIAL_QUANTITIES_HPP
+
+
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/math.hpp>
+
+
+namespace boost { namespace geometry { namespace formula
+{
+
+/*!
+\brief The solution of a part of the inverse problem - differential quantities.
+\author See
+- Charles F.F Karney, Algorithms for geodesics, 2011
+https://arxiv.org/pdf/1109.4448.pdf
+*/
+template <
+    typename CT,
+    bool EnableReducedLength,
+    bool EnableGeodesicScale,
+    unsigned int Order = 2,
+    bool ApproxF = true
+>
+class differential_quantities
+{
+public:
+    static inline void apply(CT const& lon1, CT const& lat1,
+                             CT const& lon2, CT const& lat2,
+                             CT const& azimuth, CT const& reverse_azimuth,
+                             CT const& b, CT const& f,
+                             CT & reduced_length, CT & geodesic_scale)
+    {
+        CT const dlon = lon2 - lon1;
+        CT const sin_lat1 = sin(lat1);
+        CT const cos_lat1 = cos(lat1);
+        CT const sin_lat2 = sin(lat2);
+        CT const cos_lat2 = cos(lat2);
+
+        apply(dlon, sin_lat1, cos_lat1, sin_lat2, cos_lat2,
+              azimuth, reverse_azimuth,
+              b, f,
+              reduced_length, geodesic_scale);
+    }
+
+    static inline void apply(CT const& dlon,
+                             CT const& sin_lat1, CT const& cos_lat1,
+                             CT const& sin_lat2, CT const& cos_lat2,
+                             CT const& azimuth, CT const& reverse_azimuth,
+                             CT const& b, CT const& f,
+                             CT & reduced_length, CT & geodesic_scale)
+    {
+        CT const c0 = 0;
+        CT const c1 = 1;
+        CT const one_minus_f = c1 - f;
+
+        CT sin_bet1 = one_minus_f * sin_lat1;
+        CT sin_bet2 = one_minus_f * sin_lat2;
+            
+        // equator
+        if (math::equals(sin_bet1, c0) && math::equals(sin_bet2, c0))
+        {
+            CT const sig_12 = math::abs(dlon) / one_minus_f;
+            if (BOOST_GEOMETRY_CONDITION(EnableReducedLength))
+            {
+                CT m12 = sin(sig_12) * b;
+                reduced_length = m12;
+            }
+                
+            if (BOOST_GEOMETRY_CONDITION(EnableGeodesicScale))
+            {
+                CT M12 = cos(sig_12);
+                geodesic_scale = M12;
+            }
+        }
+        else
+        {
+            CT const c2 = 2;
+            CT const e2 = f * (c2 - f);
+            CT const ep2 = e2 / math::sqr(one_minus_f);
+
+            CT const sin_alp1 = sin(azimuth);
+            CT const cos_alp1 = cos(azimuth);
+            //CT const sin_alp2 = sin(reverse_azimuth);
+            CT const cos_alp2 = cos(reverse_azimuth);
+
+            CT cos_bet1 = cos_lat1;
+            CT cos_bet2 = cos_lat2;
+
+            normalize(sin_bet1, cos_bet1);
+            normalize(sin_bet2, cos_bet2);
+
+            CT sin_sig1 = sin_bet1;
+            CT cos_sig1 = cos_alp1 * cos_bet1;
+            CT sin_sig2 = sin_bet2;
+            CT cos_sig2 = cos_alp2 * cos_bet2;
+
+            normalize(sin_sig1, cos_sig1);
+            normalize(sin_sig2, cos_sig2);
+
+            CT const sin_alp0 = sin_alp1 * cos_bet1;
+            CT const cos_alp0_sqr = c1 - math::sqr(sin_alp0);
+
+            CT const J12 = BOOST_GEOMETRY_CONDITION(ApproxF) ?
+                           J12_f(sin_sig1, cos_sig1, sin_sig2, cos_sig2, cos_alp0_sqr, f) :
+                           J12_ep_sqr(sin_sig1, cos_sig1, sin_sig2, cos_sig2, cos_alp0_sqr, ep2) ;
+
+            CT const dn1 = math::sqrt(c1 + ep2 * math::sqr(sin_bet1));
+            CT const dn2 = math::sqrt(c1 + ep2 * math::sqr(sin_bet2));
+
+            if (BOOST_GEOMETRY_CONDITION(EnableReducedLength))
+            {
+                CT const m12_b = dn2 * (cos_sig1 * sin_sig2)
+                               - dn1 * (sin_sig1 * cos_sig2)
+                               - cos_sig1 * cos_sig2 * J12;
+                CT const m12 = m12_b * b;
+
+                reduced_length = m12;
+            }
+
+            if (BOOST_GEOMETRY_CONDITION(EnableGeodesicScale))
+            {
+                CT const cos_sig12 = cos_sig1 * cos_sig2 + sin_sig1 * sin_sig2;
+                CT const t = ep2 * (cos_bet1 - cos_bet2) * (cos_bet1 + cos_bet2) / (dn1 + dn2);
+                CT const M12 = cos_sig12 + (t * sin_sig2 - cos_sig2 * J12) * sin_sig1 / dn1;
+
+                geodesic_scale = M12;
+            }
+        }
+    }
+
+private:
+    /*! Approximation of J12, expanded into taylor series in f
+        Maxima script:
+        ep2: f * (2-f) / ((1-f)^2);
+        k2: ca02 * ep2;
+        assume(f < 1);
+        assume(sig > 0);
+        I1(sig):= integrate(sqrt(1 + k2 * sin(s)^2), s, 0, sig);
+        I2(sig):= integrate(1/sqrt(1 + k2 * sin(s)^2), s, 0, sig);
+        J(sig):= I1(sig) - I2(sig);
+        S: taylor(J(sig), f, 0, 3);
+        S1: factor( 2*integrate(sin(s)^2,s,0,sig)*ca02*f );
+        S2: factor( ((integrate(-6*ca02^2*sin(s)^4+6*ca02*sin(s)^2,s,0,sig)+integrate(-2*ca02^2*sin(s)^4+6*ca02*sin(s)^2,s,0,sig))*f^2)/4 );
+        S3: factor( ((integrate(30*ca02^3*sin(s)^6-54*ca02^2*sin(s)^4+24*ca02*sin(s)^2,s,0,sig)+integrate(6*ca02^3*sin(s)^6-18*ca02^2*sin(s)^4+24*ca02*sin(s)^2,s,0,sig))*f^3)/12 );
+    */
+    static inline CT J12_f(CT const& sin_sig1, CT const& cos_sig1,
+                           CT const& sin_sig2, CT const& cos_sig2,
+                           CT const& cos_alp0_sqr, CT const& f)
+    {
+        if (Order == 0)
+        {
+            return 0;
+        }
+
+        CT const c2 = 2;
+
+        CT const sig_12 = atan2(cos_sig1 * sin_sig2 - sin_sig1 * cos_sig2,
+                                cos_sig1 * cos_sig2 + sin_sig1 * sin_sig2);
+        CT const sin_2sig1 = c2 * cos_sig1 * sin_sig1; // sin(2sig1)
+        CT const sin_2sig2 = c2 * cos_sig2 * sin_sig2; // sin(2sig2)
+        CT const sin_2sig_12 = sin_2sig2 - sin_2sig1;
+        CT const L1 = sig_12 - sin_2sig_12 / c2;
+
+        if (Order == 1)
+        {
+            return cos_alp0_sqr * f * L1;
+        }
+        
+        CT const sin_4sig1 = c2 * sin_2sig1 * (math::sqr(cos_sig1) - math::sqr(sin_sig1)); // sin(4sig1)
+        CT const sin_4sig2 = c2 * sin_2sig2 * (math::sqr(cos_sig2) - math::sqr(sin_sig2)); // sin(4sig2)
+        CT const sin_4sig_12 = sin_4sig2 - sin_4sig1;
+        
+        CT const c8 = 8;
+        CT const c12 = 12;
+        CT const c16 = 16;
+        CT const c24 = 24;
+
+        CT const L2 = -( cos_alp0_sqr * sin_4sig_12
+                         + (-c8 * cos_alp0_sqr + c12) * sin_2sig_12
+                         + (c12 * cos_alp0_sqr - c24) * sig_12)
+                       / c16;
+
+        if (Order == 2)
+        {
+            return cos_alp0_sqr * f * (L1 + f * L2);
+        }
+
+        CT const c4 = 4;
+        CT const c9 = 9;
+        CT const c48 = 48;
+        CT const c60 = 60;
+        CT const c64 = 64;
+        CT const c96 = 96;
+        CT const c128 = 128;
+        CT const c144 = 144;
+
+        CT const cos_alp0_quad = math::sqr(cos_alp0_sqr);
+        CT const sin3_2sig1 = math::sqr(sin_2sig1) * sin_2sig1;
+        CT const sin3_2sig2 = math::sqr(sin_2sig2) * sin_2sig2;
+        CT const sin3_2sig_12 = sin3_2sig2 - sin3_2sig1;
+
+        CT const A = (c9 * cos_alp0_quad - c12 * cos_alp0_sqr) * sin_4sig_12;
+        CT const B = c4 * cos_alp0_quad * sin3_2sig_12;
+        CT const C = (-c48 * cos_alp0_quad + c96 * cos_alp0_sqr - c64) * sin_2sig_12;
+        CT const D = (c60 * cos_alp0_quad - c144 * cos_alp0_sqr + c128) * sig_12;
+
+        CT const L3 = (A + B + C + D) / c64;
+
+        // Order 3 and higher
+        return cos_alp0_sqr * f * (L1 + f * (L2 + f * L3));
+    }
+
+    /*! Approximation of J12, expanded into taylor series in e'^2
+        Maxima script:
+        k2: ca02 * ep2;
+        assume(sig > 0);
+        I1(sig):= integrate(sqrt(1 + k2 * sin(s)^2), s, 0, sig);
+        I2(sig):= integrate(1/sqrt(1 + k2 * sin(s)^2), s, 0, sig);
+        J(sig):= I1(sig) - I2(sig);
+        S: taylor(J(sig), ep2, 0, 3);
+        S1: factor( integrate(sin(s)^2,s,0,sig)*ca02*ep2 );
+        S2: factor( (integrate(sin(s)^4,s,0,sig)*ca02^2*ep2^2)/2 );
+        S3: factor( (3*integrate(sin(s)^6,s,0,sig)*ca02^3*ep2^3)/8 );
+    */
+    static inline CT J12_ep_sqr(CT const& sin_sig1, CT const& cos_sig1,
+                                CT const& sin_sig2, CT const& cos_sig2,
+                                CT const& cos_alp0_sqr, CT const& ep_sqr)
+    {
+        if (Order == 0)
+        {
+            return 0;
+        }
+
+        CT const c2 = 2;
+        CT const c4 = 4;
+
+        CT const c2a0ep2 = cos_alp0_sqr * ep_sqr;
+
+        CT const sig_12 = atan2(cos_sig1 * sin_sig2 - sin_sig1 * cos_sig2,
+                                cos_sig1 * cos_sig2 + sin_sig1 * sin_sig2); // sig2 - sig1
+        CT const sin_2sig1 = c2 * cos_sig1 * sin_sig1; // sin(2sig1)
+        CT const sin_2sig2 = c2 * cos_sig2 * sin_sig2; // sin(2sig2)
+        CT const sin_2sig_12 = sin_2sig2 - sin_2sig1;
+
+        CT const L1 = (c2 * sig_12 - sin_2sig_12) / c4;
+
+        if (Order == 1)
+        {
+            return c2a0ep2 * L1;
+        }
+
+        CT const c8 = 8;
+        CT const c64 = 64;
+        
+        CT const sin_4sig1 = c2 * sin_2sig1 * (math::sqr(cos_sig1) - math::sqr(sin_sig1)); // sin(4sig1)
+        CT const sin_4sig2 = c2 * sin_2sig2 * (math::sqr(cos_sig2) - math::sqr(sin_sig2)); // sin(4sig2)
+        CT const sin_4sig_12 = sin_4sig2 - sin_4sig1;
+        
+        CT const L2 = (sin_4sig_12 - c8 * sin_2sig_12 + 12 * sig_12) / c64;
+
+        if (Order == 2)
+        {
+            return c2a0ep2 * (L1 + c2a0ep2 * L2);
+        }
+
+        CT const sin3_2sig1 = math::sqr(sin_2sig1) * sin_2sig1;
+        CT const sin3_2sig2 = math::sqr(sin_2sig2) * sin_2sig2;
+        CT const sin3_2sig_12 = sin3_2sig2 - sin3_2sig1;
+
+        CT const c9 = 9;
+        CT const c48 = 48;
+        CT const c60 = 60;
+        CT const c512 = 512;
+
+        CT const L3 = (c9 * sin_4sig_12 + c4 * sin3_2sig_12 - c48 * sin_2sig_12 + c60 * sig_12) / c512;
+
+        // Order 3 and higher
+        return c2a0ep2 * (L1 + c2a0ep2 * (L2 + c2a0ep2 * L3));
+    }
+
+    static inline void normalize(CT & x, CT & y)
+    {
+        CT const len = math::sqrt(math::sqr(x) + math::sqr(y));
+        x /= len;
+        y /= len;
+    }
+};
+
+}}} // namespace boost::geometry::formula
+
+
+#endif // BOOST_GEOMETRY_FORMULAS_INVERSE_DIFFERENTIAL_QUANTITIES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/formulas/eccentricity_sqr.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/eccentricity_sqr.hpp
new file mode 100644
index 00000000000..01a9beacb94
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/eccentricity_sqr.hpp
@@ -0,0 +1,70 @@
+// Boost.Geometry
+
+// Copyright (c) 2016 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_FORMULAS_ECCENCRICITY_SQR_HPP
+#define BOOST_GEOMETRY_FORMULAS_ECCENCRICITY_SQR_HPP
+
+#include <boost/geometry/core/radius.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace formula_dispatch
+{
+
+template <typename ResultType, typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct eccentricity_sqr
+    : not_implemented<Tag>
+{};
+
+template <typename ResultType, typename Geometry>
+struct eccentricity_sqr<ResultType, Geometry, srs_sphere_tag>
+{
+    static inline ResultType apply(Geometry const& /*geometry*/)
+    {
+        return ResultType(0);
+    }
+};
+
+template <typename ResultType, typename Geometry>
+struct eccentricity_sqr<ResultType, Geometry, srs_spheroid_tag>
+{
+    static inline ResultType apply(Geometry const& geometry)
+    {
+        // 1 - (b / a)^2
+        return ResultType(1) - math::sqr(ResultType(get_radius<2>(geometry))
+                                       / ResultType(get_radius<0>(geometry)));
+    }
+};
+
+} // namespace formula_dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace formula
+{
+
+template <typename ResultType, typename Geometry>
+ResultType eccentricity_sqr(Geometry const& geometry)
+{
+    return formula_dispatch::eccentricity_sqr<ResultType, Geometry>::apply(geometry);
+}
+
+} // namespace formula
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_FORMULAS_ECCENCRICITY_SQR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/formulas/flattening.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/flattening.hpp
new file mode 100644
index 00000000000..f94ead65b05
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/flattening.hpp
@@ -0,0 +1,70 @@
+// Boost.Geometry
+
+// Copyright (c) 2014-2016 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_FORMULAS_FLATTENING_HPP
+#define BOOST_GEOMETRY_FORMULAS_FLATTENING_HPP
+
+#include <boost/geometry/core/radius.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace formula_dispatch
+{
+
+template <typename ResultType, typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct flattening
+    : not_implemented<Tag>
+{};
+
+template <typename ResultType, typename Geometry>
+struct flattening<ResultType, Geometry, srs_sphere_tag>
+{
+    static inline ResultType apply(Geometry const& /*geometry*/)
+    {
+        return ResultType(0);
+    }
+};
+
+template <typename ResultType, typename Geometry>
+struct flattening<ResultType, Geometry, srs_spheroid_tag>
+{
+    static inline ResultType apply(Geometry const& geometry)
+    {
+        // (a - b) / a
+        return ResultType(get_radius<0>(geometry) - get_radius<2>(geometry))
+                    / ResultType(get_radius<0>(geometry));
+    }
+};
+
+} // namespace formula_dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace formula
+{
+
+template <typename ResultType, typename Geometry>
+ResultType flattening(Geometry const& geometry)
+{
+    return formula_dispatch::flattening<ResultType, Geometry>::apply(geometry);
+}
+
+} // namespace formula
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_FORMULAS_FLATTENING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/formulas/geographic.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/geographic.hpp
new file mode 100644
index 00000000000..f6feb666334
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/geographic.hpp
@@ -0,0 +1,457 @@
+// Boost.Geometry
+
+// Copyright (c) 2016, Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_FORMULAS_GEOGRAPHIC_HPP
+#define BOOST_GEOMETRY_FORMULAS_GEOGRAPHIC_HPP
+
+#include <boost/geometry/core/coordinate_system.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/radian_access.hpp>
+
+#include <boost/geometry/arithmetic/arithmetic.hpp>
+#include <boost/geometry/arithmetic/cross_product.hpp>
+#include <boost/geometry/arithmetic/dot_product.hpp>
+#include <boost/geometry/arithmetic/normalize.hpp>
+
+#include <boost/geometry/formulas/eccentricity_sqr.hpp>
+#include <boost/geometry/formulas/flattening.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/normalize_spheroidal_coordinates.hpp>
+#include <boost/geometry/util/select_coordinate_type.hpp>
+
+namespace boost { namespace geometry {
+    
+namespace formula {
+
+template <typename Point3d, typename PointGeo, typename Spheroid>
+inline Point3d geo_to_cart3d(PointGeo const& point_geo, Spheroid const& spheroid)
+{
+    typedef typename coordinate_type<Point3d>::type calc_t;
+
+    calc_t const c1 = 1;
+    calc_t const e_sqr = eccentricity_sqr<calc_t>(spheroid);
+
+    calc_t const lon = get_as_radian<0>(point_geo);
+    calc_t const lat = get_as_radian<1>(point_geo);
+
+    Point3d res;
+
+    calc_t const sin_lat = sin(lat);
+
+    // "unit" spheroid, a = 1
+    calc_t const N = c1 / math::sqrt(c1 - e_sqr * math::sqr(sin_lat));
+    calc_t const N_cos_lat = N * cos(lat);
+
+    set<0>(res, N_cos_lat * cos(lon));
+    set<1>(res, N_cos_lat * sin(lon));
+    set<2>(res, N * (c1 - e_sqr) * sin_lat);
+
+    return res;
+}
+
+template <typename PointGeo, typename Spheroid, typename Point3d>
+inline void geo_to_cart3d(PointGeo const& point_geo, Point3d & result, Point3d & north, Point3d & east, Spheroid const& spheroid)
+{
+    typedef typename coordinate_type<Point3d>::type calc_t;
+
+    calc_t const c1 = 1;
+    calc_t const e_sqr = eccentricity_sqr<calc_t>(spheroid);
+
+    calc_t const lon = get_as_radian<0>(point_geo);
+    calc_t const lat = get_as_radian<1>(point_geo);
+
+    calc_t const sin_lon = sin(lon);
+    calc_t const cos_lon = cos(lon);
+    calc_t const sin_lat = sin(lat);
+    calc_t const cos_lat = cos(lat);
+
+    // "unit" spheroid, a = 1
+    calc_t const N = c1 / math::sqrt(c1 - e_sqr * math::sqr(sin_lat));
+    calc_t const N_cos_lat = N * cos_lat;
+
+    set<0>(result, N_cos_lat * cos_lon);
+    set<1>(result, N_cos_lat * sin_lon);
+    set<2>(result, N * (c1 - e_sqr) * sin_lat);
+
+    set<0>(east, -sin_lon);
+    set<1>(east, cos_lon);
+    set<2>(east, 0);
+
+    set<0>(north, -sin_lat * cos_lon);
+    set<1>(north, -sin_lat * sin_lon);
+    set<2>(north, cos_lat);
+}
+
+template <typename PointGeo, typename Point3d, typename Spheroid>
+inline PointGeo cart3d_to_geo(Point3d const& point_3d, Spheroid const& spheroid)
+{
+    typedef typename coordinate_type<PointGeo>::type coord_t;
+    typedef typename coordinate_type<Point3d>::type calc_t;
+
+    calc_t const c1 = 1;
+    //calc_t const c2 = 2;
+    calc_t const e_sqr = eccentricity_sqr<calc_t>(spheroid);
+
+    calc_t const x = get<0>(point_3d);
+    calc_t const y = get<1>(point_3d);
+    calc_t const z = get<2>(point_3d);
+    calc_t const xy_l = math::sqrt(math::sqr(x) + math::sqr(y));
+
+    calc_t const lonr = atan2(y, x);
+    
+    // NOTE: Alternative version
+    // http://www.iag-aig.org/attach/989c8e501d9c5b5e2736955baf2632f5/V60N2_5FT.pdf
+    // calc_t const lonr = c2 * atan2(y, x + xy_l);
+    
+    calc_t const latr = atan2(z, (c1 - e_sqr) * xy_l);
+
+    // NOTE: If h is equal to 0 then there is no need to improve value of latitude
+    //       because then N_i / (N_i + h_i) = 1
+    // http://www.navipedia.net/index.php/Ellipsoidal_and_Cartesian_Coordinates_Conversion
+
+    PointGeo res;
+
+    set_from_radian<0>(res, lonr);
+    set_from_radian<1>(res, latr);
+
+    coord_t lon = get<0>(res);
+    coord_t lat = get<1>(res);
+
+    math::normalize_spheroidal_coordinates
+        <
+            typename coordinate_system<PointGeo>::type::units,
+            coord_t
+        >(lon, lat);
+
+    set<0>(res, lon);
+    set<1>(res, lat);
+
+    return res;
+}
+
+template <typename Point3d, typename Spheroid>
+inline Point3d projected_to_xy(Point3d const& point_3d, Spheroid const& spheroid)
+{
+    typedef typename coordinate_type<Point3d>::type coord_t;    
+    
+    // len_xy = sqrt(x^2 + y^2)
+    // r = len_xy - |z / tan(lat)|
+    // assuming h = 0
+    // lat = atan2(z, (1 - e^2) * len_xy);
+    // |z / tan(lat)| = (1 - e^2) * len_xy
+    // r = e^2 * len_xy
+    // x_res = r * cos(lon) = e^2 * len_xy * x / len_xy = e^2 * x
+    // y_res = r * sin(lon) = e^2 * len_xy * y / len_xy = e^2 * y
+    
+    coord_t const c0 = 0;
+    coord_t const e_sqr = formula::eccentricity_sqr<coord_t>(spheroid);
+
+    Point3d res;
+
+    set<0>(res, e_sqr * get<0>(point_3d));
+    set<1>(res, e_sqr * get<1>(point_3d));
+    set<2>(res, c0);
+
+    return res;
+}
+
+template <typename Point3d, typename Spheroid>
+inline Point3d projected_to_surface(Point3d const& direction, Spheroid const& spheroid)
+{
+    typedef typename coordinate_type<Point3d>::type coord_t;
+
+    //coord_t const c0 = 0;
+    coord_t const c2 = 2;
+    coord_t const c4 = 4;
+
+    // calculate the point of intersection of a ray and spheroid's surface
+    // the origin is the origin of the coordinate system
+    //(x*x+y*y)/(a*a) + z*z/(b*b) = 1
+    // x = d.x * t
+    // y = d.y * t
+    // z = d.z * t        
+    coord_t const dx = get<0>(direction);
+    coord_t const dy = get<1>(direction);
+    coord_t const dz = get<2>(direction);
+
+    //coord_t const a_sqr = math::sqr(get_radius<0>(spheroid));
+    //coord_t const b_sqr = math::sqr(get_radius<2>(spheroid));
+    // "unit" spheroid, a = 1
+    coord_t const a_sqr = 1;
+    coord_t const b_sqr = math::sqr(get_radius<2>(spheroid) / get_radius<0>(spheroid));
+
+    coord_t const param_a = (dx*dx + dy*dy) / a_sqr + dz*dz / b_sqr;
+    coord_t const delta = c4 * param_a;
+    // delta >= 0
+    coord_t const t = math::sqrt(delta) / (c2 * param_a);
+
+    // result = direction * t
+    Point3d result = direction;
+    multiply_value(result, t);
+
+    return result;
+}
+
+template <typename Point3d, typename Spheroid>
+inline bool projected_to_surface(Point3d const& origin, Point3d const& direction, Point3d & result1, Point3d & result2, Spheroid const& spheroid)
+{
+    typedef typename coordinate_type<Point3d>::type coord_t;
+
+    coord_t const c0 = 0;
+    coord_t const c1 = 1;
+    coord_t const c2 = 2;
+    coord_t const c4 = 4;
+
+    // calculate the point of intersection of a ray and spheroid's surface
+    //(x*x+y*y)/(a*a) + z*z/(b*b) = 1
+    // x = o.x + d.x * t
+    // y = o.y + d.y * t
+    // z = o.z + d.z * t        
+    coord_t const ox = get<0>(origin);
+    coord_t const oy = get<1>(origin);
+    coord_t const oz = get<2>(origin);
+    coord_t const dx = get<0>(direction);
+    coord_t const dy = get<1>(direction);
+    coord_t const dz = get<2>(direction);
+
+    //coord_t const a_sqr = math::sqr(get_radius<0>(spheroid));
+    //coord_t const b_sqr = math::sqr(get_radius<2>(spheroid));
+    // "unit" spheroid, a = 1
+    coord_t const a_sqr = 1;
+    coord_t const b_sqr = math::sqr(get_radius<2>(spheroid) / get_radius<0>(spheroid));
+
+    coord_t const param_a = (dx*dx + dy*dy) / a_sqr + dz*dz / b_sqr;
+    coord_t const param_b = c2 * ((ox*dx + oy*dy) / a_sqr + oz*dz / b_sqr);
+    coord_t const param_c = (ox*ox + oy*oy) / a_sqr + oz*oz / b_sqr - c1;
+
+    coord_t const delta = math::sqr(param_b) - c4 * param_a*param_c;
+
+    // equals() ?
+    if (delta < c0 || param_a == 0)
+    {
+        return false;
+    }
+
+    // result = origin + direction * t
+
+    coord_t const sqrt_delta = math::sqrt(delta);
+    coord_t const two_a = c2 * param_a;
+
+    coord_t const t1 = (-param_b + sqrt_delta) / two_a;
+    result1 = direction;
+    multiply_value(result1, t1);
+    add_point(result1, origin);
+
+    coord_t const t2 = (-param_b - sqrt_delta) / two_a;
+    result2 = direction;
+    multiply_value(result2, t2);
+    add_point(result2, origin);
+
+    return true;
+}
+
+template <typename Point3d, typename Spheroid>
+inline bool great_elliptic_intersection(Point3d const& a1, Point3d const& a2,
+                                        Point3d const& b1, Point3d const& b2,
+                                        Point3d & result,
+                                        Spheroid const& spheroid)
+{
+    typedef typename coordinate_type<Point3d>::type coord_t;
+
+    coord_t c0 = 0;
+    coord_t c1 = 1;
+
+    Point3d n1 = cross_product(a1, a2);
+    Point3d n2 = cross_product(b1, b2);
+
+    // intersection direction
+    Point3d id = cross_product(n1, n2);
+    coord_t id_len_sqr = dot_product(id, id);
+
+    if (math::equals(id_len_sqr, c0))
+    {
+        return false;
+    }
+
+    // no need to normalize a1 and a2 because the intersection point on
+    // the opposite side of the globe is at the same distance from the origin
+    coord_t cos_a1i = dot_product(a1, id);
+    coord_t cos_a2i = dot_product(a2, id);
+    coord_t gri = math::detail::greatest(cos_a1i, cos_a2i);
+    Point3d neg_id = id;
+    multiply_value(neg_id, -c1);
+    coord_t cos_a1ni = dot_product(a1, neg_id);
+    coord_t cos_a2ni = dot_product(a2, neg_id);
+    coord_t grni = math::detail::greatest(cos_a1ni, cos_a2ni);
+
+    if (gri >= grni)
+    {
+        result = projected_to_surface(id, spheroid);
+    }
+    else
+    {
+        result = projected_to_surface(neg_id, spheroid);
+    }
+
+    return true;
+}
+
+template <typename Point3d1, typename Point3d2>
+static inline int elliptic_side_value(Point3d1 const& origin, Point3d1 const& norm, Point3d2 const& pt)
+{
+    typedef typename coordinate_type<Point3d1>::type calc_t;
+    calc_t c0 = 0;
+
+    // vector oposite to pt - origin
+    // only for the purpose of assigning origin
+    Point3d1 vec = origin;
+    subtract_point(vec, pt);
+
+    calc_t d = dot_product(norm, vec);
+
+    // since the vector is opposite the signs are opposite
+    return math::equals(d, c0) ? 0
+        : d < c0 ? 1
+        : -1; // d > 0
+}
+
+template <typename Point3d, typename Spheroid>
+inline bool planes_spheroid_intersection(Point3d const& o1, Point3d const& n1,
+                                         Point3d const& o2, Point3d const& n2,
+                                         Point3d & ip1, Point3d & ip2,
+                                         Spheroid const& spheroid)
+{
+    typedef typename coordinate_type<Point3d>::type coord_t;
+
+    coord_t c0 = 0;
+    coord_t c1 = 1;
+
+    // Below
+    // n . (p - o) = 0
+    // n . p - n . o = 0
+    // n . p + d = 0
+    // n . p = h
+
+    // intersection direction
+    Point3d id = cross_product(n1, n2);
+
+    if (math::equals(dot_product(id, id), c0))
+    {
+        return false;
+    }
+
+    coord_t dot_n1_n2 = dot_product(n1, n2);
+    coord_t dot_n1_n2_sqr = math::sqr(dot_n1_n2);
+
+    coord_t h1 = dot_product(n1, o1);
+    coord_t h2 = dot_product(n2, o2);
+
+    coord_t denom = c1 - dot_n1_n2_sqr;
+    coord_t C1 = (h1 - h2 * dot_n1_n2) / denom;
+    coord_t C2 = (h2 - h1 * dot_n1_n2) / denom;
+
+    // C1 * n1 + C2 * n2
+    Point3d C1_n1 = n1;
+    multiply_value(C1_n1, C1);
+    Point3d C2_n2 = n2;
+    multiply_value(C2_n2, C2);
+    Point3d io = C1_n1;
+    add_point(io, C2_n2);
+
+    if (! projected_to_surface(io, id, ip1, ip2, spheroid))
+    {
+        return false;
+    }
+
+    return true;
+}
+
+
+template <typename Point3d, typename Spheroid>
+inline void experimental_elliptic_plane(Point3d const& p1, Point3d const& p2,
+                                        Point3d & v1, Point3d & v2,
+                                        Point3d & origin, Point3d & normal,
+                                        Spheroid const& spheroid)
+{
+    typedef typename coordinate_type<Point3d>::type coord_t;
+
+    Point3d xy1 = projected_to_xy(p1, spheroid);
+    Point3d xy2 = projected_to_xy(p2, spheroid);
+
+    // origin = (xy1 + xy2) / 2
+    origin = xy1;
+    add_point(origin, xy2);
+    multiply_value(origin, coord_t(0.5));
+
+    // v1 = p1 - origin
+    v1 = p1;
+    subtract_point(v1, origin);
+    // v2 = p2 - origin
+    v2 = p2;
+    subtract_point(v2, origin);
+
+    normal = cross_product(v1, v2);
+}
+
+template <typename Point3d, typename Spheroid>
+inline void experimental_elliptic_plane(Point3d const& p1, Point3d const& p2,
+                                        Point3d & origin, Point3d & normal,
+                                        Spheroid const& spheroid)
+{
+    Point3d v1, v2;
+    experimental_elliptic_plane(p1, p2, v1, v2, origin, normal, spheroid);
+}
+
+template <typename Point3d, typename Spheroid>
+inline bool experimental_elliptic_intersection(Point3d const& a1, Point3d const& a2,
+                                               Point3d const& b1, Point3d const& b2,
+                                               Point3d & result,
+                                               Spheroid const& spheroid)
+{
+    typedef typename coordinate_type<Point3d>::type coord_t;
+
+    coord_t c0 = 0;
+    coord_t c1 = 1;
+
+    Point3d a1v, a2v, o1, n1;
+    experimental_elliptic_plane(a1, a2, a1v, a2v, o1, n1, spheroid);
+    Point3d b1v, b2v, o2, n2;
+    experimental_elliptic_plane(b1, b2, b1v, b2v, o2, n2, spheroid);
+
+    if (! detail::vec_normalize(n1) || ! detail::vec_normalize(n2))
+    {
+        return false;
+    }
+
+    Point3d ip1_s, ip2_s;
+    if (! planes_spheroid_intersection(o1, n1, o2, n2, ip1_s, ip2_s, spheroid))
+    {
+        return false;
+    }
+
+    // NOTE: simplified test, may not work in all cases
+    coord_t dot_a1i1 = dot_product(a1, ip1_s);
+    coord_t dot_a2i1 = dot_product(a2, ip1_s);
+    coord_t gri1 = math::detail::greatest(dot_a1i1, dot_a2i1);
+    coord_t dot_a1i2 = dot_product(a1, ip2_s);
+    coord_t dot_a2i2 = dot_product(a2, ip2_s);
+    coord_t gri2 = math::detail::greatest(dot_a1i2, dot_a2i2);
+
+    result = gri1 >= gri2 ? ip1_s : ip2_s;
+
+    return true;
+}
+
+} // namespace formula
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_FORMULAS_GEOGRAPHIC_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/formulas/gnomonic_intersection.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/gnomonic_intersection.hpp
new file mode 100644
index 00000000000..7e1b7bcdab1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/gnomonic_intersection.hpp
@@ -0,0 +1,148 @@
+// Boost.Geometry
+
+// Copyright (c) 2016 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_FORMULAS_GNOMONIC_INTERSECTION_HPP
+#define BOOST_GEOMETRY_FORMULAS_GNOMONIC_INTERSECTION_HPP
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/cs.hpp>
+
+#include <boost/geometry/arithmetic/cross_product.hpp>
+#include <boost/geometry/formulas/gnomonic_spheroid.hpp>
+#include <boost/geometry/geometries/point.hpp>
+#include <boost/geometry/util/math.hpp>
+
+
+namespace boost { namespace geometry { namespace formula
+{
+
+/*!
+\brief The intersection of two geodesics using spheroidal gnomonic projection
+       as proposed by Karney.
+\author See
+    - Charles F.F Karney, Algorithms for geodesics, 2011
+      https://arxiv.org/pdf/1109.4448.pdf
+    - GeographicLib forum thread: Intersection between two geodesic lines
+      https://sourceforge.net/p/geographiclib/discussion/1026621/thread/21aaff9f/
+*/
+template
+<
+    typename CT,
+    template <typename, bool, bool, bool, bool, bool> class Inverse,
+    template <typename, bool, bool, bool, bool> class Direct
+>
+class gnomonic_intersection
+{
+public:
+    template <typename T1, typename T2, typename Spheroid>
+    static inline bool apply(T1 const& lona1, T1 const& lata1,
+                             T1 const& lona2, T1 const& lata2,
+                             T2 const& lonb1, T2 const& latb1,
+                             T2 const& lonb2, T2 const& latb2,
+                             CT & lon, CT & lat,
+                             Spheroid const& spheroid)
+    {
+        CT const lon_a1 = lona1;
+        CT const lat_a1 = lata1;
+        CT const lon_a2 = lona2;
+        CT const lat_a2 = lata2;
+        CT const lon_b1 = lonb1;
+        CT const lat_b1 = latb1;
+        CT const lon_b2 = lonb2;
+        CT const lat_b2 = latb2;
+
+        return apply(lon_a1, lat_a1, lon_a2, lat_a2, lon_b1, lat_b1, lon_b2, lat_b2, lon, lat, spheroid);
+    }
+    
+    template <typename Spheroid>
+    static inline bool apply(CT const& lona1, CT const& lata1,
+                             CT const& lona2, CT const& lata2,
+                             CT const& lonb1, CT const& latb1,
+                             CT const& lonb2, CT const& latb2,
+                             CT & lon, CT & lat,
+                             Spheroid const& spheroid)
+    {
+        typedef gnomonic_spheroid<CT, Inverse, Direct> gnom_t;
+
+        lon = (lona1 + lona2 + lonb1 + lonb2) / 4;
+        lat = (lata1 + lata2 + latb1 + latb2) / 4;
+        // TODO: consider normalizing lon
+
+        for (int i = 0; i < 10; ++i)
+        {
+            CT xa1, ya1, xa2, ya2;
+            CT xb1, yb1, xb2, yb2;
+            CT x, y;
+            double lat1, lon1;
+
+            bool ok = gnom_t::forward(lon, lat, lona1, lata1, xa1, ya1, spheroid)
+                   && gnom_t::forward(lon, lat, lona2, lata2, xa2, ya2, spheroid)
+                   && gnom_t::forward(lon, lat, lonb1, latb1, xb1, yb1, spheroid)
+                   && gnom_t::forward(lon, lat, lonb2, latb2, xb2, yb2, spheroid)
+                   && intersect(xa1, ya1, xa2, ya2, xb1, yb1, xb2, yb2, x, y)
+                   && gnom_t::inverse(lon, lat, x, y, lon1, lat1, spheroid);
+
+            if (! ok)
+            {
+                return false;
+            }
+            
+            if (math::equals(lat1, lat) && math::equals(lon1, lon))
+            {
+                break;
+            }
+
+            lat = lat1;
+            lon = lon1;
+        }
+
+        // NOTE: true is also returned if the number of iterations is too great
+        //       which means that the accuracy of the result is low
+        return true;
+    }
+
+private:
+    static inline bool intersect(CT const& xa1, CT const& ya1, CT const& xa2, CT const& ya2,
+                                 CT const& xb1, CT const& yb1, CT const& xb2, CT const& yb2,
+                                 CT & x, CT & y)
+    {
+        typedef model::point<CT, 3, cs::cartesian> v3d_t;
+
+        CT const c0 = 0;
+        CT const c1 = 1;
+
+        v3d_t const va1(xa1, ya1, c1);
+        v3d_t const va2(xa2, ya2, c1);
+        v3d_t const vb1(xb1, yb1, c1);
+        v3d_t const vb2(xb2, yb2, c1);
+
+        v3d_t const la = cross_product(va1, va2);
+        v3d_t const lb = cross_product(vb1, vb2);
+        v3d_t const p = cross_product(la, lb);
+
+        CT const z = get<2>(p);
+
+        if (math::equals(z, c0))
+        {
+            // degenerated or collinear segments
+            return false;
+        }
+
+        x = get<0>(p) / z;
+        y = get<1>(p) / z;
+        
+        return true;
+    }
+};
+
+}}} // namespace boost::geometry::formula
+
+
+#endif // BOOST_GEOMETRY_FORMULAS_GNOMONIC_INTERSECTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/formulas/gnomonic_spheroid.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/gnomonic_spheroid.hpp
new file mode 100644
index 00000000000..4710c6c0631
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/gnomonic_spheroid.hpp
@@ -0,0 +1,125 @@
+// Boost.Geometry
+
+// Copyright (c) 2016 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_FORMULAS_GNOMONIC_SPHEROID_HPP
+#define BOOST_GEOMETRY_FORMULAS_GNOMONIC_SPHEROID_HPP
+
+
+#include <boost/geometry/core/radius.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/formulas/andoyer_inverse.hpp>
+#include <boost/geometry/formulas/flattening.hpp>
+#include <boost/geometry/formulas/thomas_inverse.hpp>
+#include <boost/geometry/formulas/vincenty_direct.hpp>
+#include <boost/geometry/formulas/vincenty_inverse.hpp>
+
+
+namespace boost { namespace geometry { namespace formula
+{
+
+/*!
+\brief Gnomonic projection on spheroid (ellipsoid of revolution).
+\author See
+- Charles F.F Karney, Algorithms for geodesics, 2011
+https://arxiv.org/pdf/1109.4448.pdf
+*/
+template <
+    typename CT,
+    template <typename, bool, bool, bool, bool ,bool> class Inverse,
+    template <typename, bool, bool, bool, bool> class Direct
+>
+class gnomonic_spheroid
+{
+    typedef Inverse<CT, false, true, true, true, true> inverse_type;
+    typedef typename inverse_type::result_type inverse_result;
+
+    typedef Direct<CT, false, false, true, true> direct_quantities_type;
+    typedef Direct<CT, true, false, false, false> direct_coordinates_type;
+    typedef typename direct_coordinates_type::result_type direct_result;
+
+public:
+    template <typename Spheroid>
+    static inline bool forward(CT const& lon0, CT const& lat0,
+                               CT const& lon, CT const& lat,
+                               CT & x, CT & y,
+                               Spheroid const& spheroid)
+    {
+        inverse_result i_res = inverse_type::apply(lon0, lat0, lon, lat, spheroid);
+        CT const& m = i_res.reduced_length;
+        CT const& M = i_res.geodesic_scale;
+
+        if (math::smaller_or_equals(M, CT(0)))
+        {
+            return false;
+        }
+
+        CT rho = m / M;
+        x = sin(i_res.azimuth) * rho;
+        y = cos(i_res.azimuth) * rho;
+        
+        return true;
+    }
+
+    template <typename Spheroid>
+    static inline bool inverse(CT const& lon0, CT const& lat0,
+                               CT const& x, CT const& y,
+                               CT & lon, CT & lat,
+                               Spheroid const& spheroid)
+    {
+        CT const a = get_radius<0>(spheroid);
+        CT const ds_threshold = a * std::numeric_limits<CT>::epsilon(); // TODO: 0 for non-fundamental type
+        
+        CT const azimuth = atan2(x, y);
+        CT const rho = math::sqrt(math::sqr(x) + math::sqr(y)); // use hypot?
+        CT distance = a * atan(rho / a);
+
+        bool found = false;
+        for (int i = 0 ; i < 10 ; ++i)
+        {
+            direct_result d_res = direct_quantities_type::apply(lon0, lat0, distance, azimuth, spheroid);
+            CT const& m = d_res.reduced_length;
+            CT const& M = d_res.geodesic_scale;
+
+            if (math::smaller_or_equals(M, CT(0)))
+            {
+                // found = false;
+                return found;
+            }
+            
+            CT const drho = m / M - rho; // rho = m / M
+            CT const ds = drho * math::sqr(M); // drho/ds = 1/M^2
+            distance -= ds;
+
+            // ds_threshold may be 0
+            if (math::abs(ds) <= ds_threshold)
+            {
+                found = true;
+                break;
+            }
+        }
+
+        if (found)
+        {
+            direct_result d_res = direct_coordinates_type::apply(lon0, lat0, distance, azimuth, spheroid);
+            lon = d_res.lon2;
+            lat = d_res.lat2;
+        }
+
+        return found;
+    }
+};
+
+}}} // namespace boost::geometry::formula
+
+
+#endif // BOOST_GEOMETRY_FORMULAS_GNOMONIC_SPHEROID_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/formulas/result_direct.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/result_direct.hpp
new file mode 100644
index 00000000000..8461d8ac9b6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/result_direct.hpp
@@ -0,0 +1,39 @@
+// Boost.Geometry
+
+// Copyright (c) 2016 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_FORMULAS_RESULT_DIRECT_HPP
+#define BOOST_GEOMETRY_FORMULAS_RESULT_DIRECT_HPP
+
+
+namespace boost { namespace geometry { namespace formula
+{
+
+template <typename T>
+struct result_direct
+{
+    result_direct()
+        : lon2(0)
+        , lat2(0)
+        , reverse_azimuth(0)
+        , reduced_length(0)
+        , geodesic_scale(1)
+    {}
+
+    T lon2;
+    T lat2;
+    T reverse_azimuth;
+    T reduced_length;
+    T geodesic_scale;
+};
+
+}}} // namespace boost::geometry::formula
+
+
+#endif // BOOST_GEOMETRY_FORMULAS_RESULT_DIRECT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/formulas/result_inverse.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/result_inverse.hpp
new file mode 100644
index 00000000000..b6faae6eaae
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/result_inverse.hpp
@@ -0,0 +1,39 @@
+// Boost.Geometry
+
+// Copyright (c) 2015-2016 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_FORMULAS_RESULT_INVERSE_HPP
+#define BOOST_GEOMETRY_FORMULAS_RESULT_INVERSE_HPP
+
+
+namespace boost { namespace geometry { namespace formula
+{
+
+template <typename T>
+struct result_inverse
+{
+    result_inverse()
+        : distance(0)
+        , azimuth(0)
+        , reverse_azimuth(0)
+        , reduced_length(0)
+        , geodesic_scale(1)
+    {}
+
+    T distance;
+    T azimuth;
+    T reverse_azimuth;
+    T reduced_length;
+    T geodesic_scale;
+};
+
+}}} // namespace boost::geometry::formula
+
+
+#endif // BOOST_GEOMETRY_FORMULAS_RESULT_INVERSE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/formulas/sjoberg_intersection.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/sjoberg_intersection.hpp
new file mode 100644
index 00000000000..92f9e8e78ea
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/sjoberg_intersection.hpp
@@ -0,0 +1,1219 @@
+// Boost.Geometry
+
+// Copyright (c) 2016 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_FORMULAS_SJOBERG_INTERSECTION_HPP
+#define BOOST_GEOMETRY_FORMULAS_SJOBERG_INTERSECTION_HPP
+
+
+#include <boost/math/constants/constants.hpp>
+
+#include <boost/geometry/core/radius.hpp>
+#include <boost/geometry/core/srs.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/formulas/flattening.hpp>
+#include <boost/geometry/formulas/spherical.hpp>
+
+
+namespace boost { namespace geometry { namespace formula
+{
+
+/*!
+\brief The intersection of two great circles as proposed by Sjoberg.
+\see See
+    - [Sjoberg02] Lars E. Sjoberg, Intersections on the sphere and ellipsoid, 2002
+      http://link.springer.com/article/10.1007/s00190-001-0230-9
+*/
+template <typename CT>
+struct sjoberg_intersection_spherical_02
+{
+    // TODO: if it will be used as standalone formula
+    //       support segments on equator and endpoints on poles
+
+    static inline bool apply(CT const& lon1, CT const& lat1, CT const& lon_a2, CT const& lat_a2,
+                             CT const& lon2, CT const& lat2, CT const& lon_b2, CT const& lat_b2,
+                             CT & lon, CT & lat)
+    {
+        CT tan_lat = 0;
+        bool res = apply_alt(lon1, lat1, lon_a2, lat_a2,
+                             lon2, lat2, lon_b2, lat_b2,
+                             lon, tan_lat);
+
+        if (res)
+        {
+            lat = atan(tan_lat);
+        }
+
+        return res;
+    }
+
+    static inline bool apply_alt(CT const& lon1, CT const& lat1, CT const& lon_a2, CT const& lat_a2,
+                                 CT const& lon2, CT const& lat2, CT const& lon_b2, CT const& lat_b2,
+                                 CT & lon, CT & tan_lat)
+    {
+        CT const cos_lon1 = cos(lon1);
+        CT const sin_lon1 = sin(lon1);
+        CT const cos_lon2 = cos(lon2);
+        CT const sin_lon2 = sin(lon2);
+        CT const sin_lat1 = sin(lat1);
+        CT const sin_lat2 = sin(lat2);
+        CT const cos_lat1 = cos(lat1);
+        CT const cos_lat2 = cos(lat2);
+
+        CT const tan_lat_a2 = tan(lat_a2);
+        CT const tan_lat_b2 = tan(lat_b2);
+        
+        return apply(lon1, lon_a2, lon2, lon_b2,
+                     sin_lon1, cos_lon1, sin_lat1, cos_lat1,
+                     sin_lon2, cos_lon2, sin_lat2, cos_lat2,
+                     tan_lat_a2, tan_lat_b2,
+                     lon, tan_lat);
+    }
+
+private:
+    static inline bool apply(CT const& lon1, CT const& lon_a2, CT const& lon2, CT const& lon_b2,
+                             CT const& sin_lon1, CT const& cos_lon1, CT const& sin_lat1, CT const& cos_lat1,
+                             CT const& sin_lon2, CT const& cos_lon2, CT const& sin_lat2, CT const& cos_lat2,
+                             CT const& tan_lat_a2, CT const& tan_lat_b2,
+                             CT & lon, CT & tan_lat)
+    {
+        // NOTE:
+        // cos_lat_ = 0 <=> segment on equator
+        // tan_alpha_ = 0 <=> segment vertical
+
+        CT const tan_lat1 = sin_lat1 / cos_lat1; //tan(lat1);
+        CT const tan_lat2 = sin_lat2 / cos_lat2; //tan(lat2);
+
+        CT const dlon1 = lon_a2 - lon1;
+        CT const sin_dlon1 = sin(dlon1);
+        CT const dlon2 = lon_b2 - lon2;
+        CT const sin_dlon2 = sin(dlon2);
+        
+        CT const c0 = 0;
+        bool const is_vertical1 = math::equals(sin_dlon1, c0);
+        bool const is_vertical2 = math::equals(sin_dlon2, c0);
+
+        CT tan_alpha1 = 0;
+        CT tan_alpha2 = 0;
+
+        if (is_vertical1 && is_vertical2)
+        {
+            // circles intersect at one of the poles or are collinear
+            return false;
+        }
+        else if (is_vertical1)
+        {
+            CT const cos_dlon2 = cos(dlon2);
+            CT const tan_alpha2_x = cos_lat2 * tan_lat_b2 - sin_lat2 * cos_dlon2;
+            tan_alpha2 = sin_dlon2 / tan_alpha2_x;
+
+            lon = lon1;
+        }
+        else if (is_vertical2)
+        {
+            CT const cos_dlon1 = cos(dlon1);
+            CT const tan_alpha1_x = cos_lat1 * tan_lat_a2 - sin_lat1 * cos_dlon1;
+            tan_alpha1 = sin_dlon1 / tan_alpha1_x;
+
+            lon = lon2;
+        }
+        else
+        {
+            CT const cos_dlon1 = cos(dlon1);
+            CT const cos_dlon2 = cos(dlon2);
+
+            CT const tan_alpha1_x = cos_lat1 * tan_lat_a2 - sin_lat1 * cos_dlon1;
+            CT const tan_alpha2_x = cos_lat2 * tan_lat_b2 - sin_lat2 * cos_dlon2;
+            tan_alpha1 = sin_dlon1 / tan_alpha1_x;
+            tan_alpha2 = sin_dlon2 / tan_alpha2_x;
+        
+            CT const T1 = tan_alpha1 * cos_lat1;
+            CT const T2 = tan_alpha2 * cos_lat2;
+            CT const T1T2 = T1*T2;
+            CT const tan_lon_y = T1 * sin_lon2 - T2 * sin_lon1 + T1T2 * (tan_lat1 * cos_lon1 - tan_lat2 * cos_lon2);
+            CT const tan_lon_x = T1 * cos_lon2 - T2 * cos_lon1 - T1T2 * (tan_lat1 * sin_lon1 - tan_lat2 * sin_lon2);
+
+            lon = atan2(tan_lon_y, tan_lon_x);
+        }
+
+        // choose closer result
+        CT const pi = math::pi<CT>();
+        CT const lon_2 = lon > c0 ? lon - pi : lon + pi;
+        CT const lon_dist1 = (std::max)((std::min)(math::longitude_difference<radian>(lon1, lon),
+                                                   math::longitude_difference<radian>(lon_a2, lon)),
+                                        (std::min)(math::longitude_difference<radian>(lon2, lon),
+                                                   math::longitude_difference<radian>(lon_b2, lon)));
+        CT const lon_dist2 = (std::max)((std::min)(math::longitude_difference<radian>(lon1, lon_2),
+                                                   math::longitude_difference<radian>(lon_a2, lon_2)),
+                                        (std::min)(math::longitude_difference<radian>(lon2, lon_2),
+                                                   math::longitude_difference<radian>(lon_b2, lon_2)));        
+        if (lon_dist2 < lon_dist1)
+        {
+            lon = lon_2;
+        }
+        
+        CT const sin_lon = sin(lon);
+        CT const cos_lon = cos(lon);
+
+        if (math::abs(tan_alpha1) >= math::abs(tan_alpha2)) // pick less vertical segment
+        {
+            CT const sin_dlon_1 = sin_lon * cos_lon1 - cos_lon * sin_lon1;
+            CT const cos_dlon_1 = cos_lon * cos_lon1 + sin_lon * sin_lon1;
+            CT const lat_y_1 = sin_dlon_1 + tan_alpha1 * sin_lat1 * cos_dlon_1;
+            CT const lat_x_1 = tan_alpha1 * cos_lat1;
+            tan_lat = lat_y_1 / lat_x_1;
+        }
+        else
+        {
+            CT const sin_dlon_2 = sin_lon * cos_lon2 - cos_lon * sin_lon2;
+            CT const cos_dlon_2 = cos_lon * cos_lon2 + sin_lon * sin_lon2;
+            CT const lat_y_2 = sin_dlon_2 + tan_alpha2 * sin_lat2 * cos_dlon_2;
+            CT const lat_x_2 = tan_alpha2 * cos_lat2;
+            tan_lat = lat_y_2 / lat_x_2;
+        }
+        
+        return true;
+    }
+};
+
+
+/*! Approximation of dLambda_j [Sjoberg07], expanded into taylor series in e^2
+    Maxima script:
+    dLI_j(c_j, sinB_j, sinB) := integrate(1 / (sqrt(1 - c_j ^ 2 - x ^ 2)*(1 + sqrt(1 - e2*(1 - x ^ 2)))), x, sinB_j, sinB);
+    dL_j(c_j, B_j, B) := -e2 * c_j * dLI_j(c_j, B_j, B);
+    S: taylor(dLI_j(c_j, sinB_j, sinB), e2, 0, 3);
+    assume(c_j < 1);
+    assume(c_j > 0);
+    L1: factor(integrate(sqrt(-x ^ 2 - c_j ^ 2 + 1) / (x ^ 2 + c_j ^ 2 - 1), x));
+    L2: factor(integrate(((x ^ 2 - 1)*sqrt(-x ^ 2 - c_j ^ 2 + 1)) / (x ^ 2 + c_j ^ 2 - 1), x));
+    L3: factor(integrate(((x ^ 4 - 2 * x ^ 2 + 1)*sqrt(-x ^ 2 - c_j ^ 2 + 1)) / (x ^ 2 + c_j ^ 2 - 1), x));
+    L4: factor(integrate(((x ^ 6 - 3 * x ^ 4 + 3 * x ^ 2 - 1)*sqrt(-x ^ 2 - c_j ^ 2 + 1)) / (x ^ 2 + c_j ^ 2 - 1), x));
+
+\see See
+    - [Sjoberg07] Lars E. Sjoberg, Geodetic intersection on the ellipsoid, 2007
+      http://link.springer.com/article/10.1007/s00190-007-0204-7
+*/
+template <unsigned int Order, typename CT>
+inline CT sjoberg_d_lambda_e_sqr(CT const& sin_betaj, CT const& sin_beta,
+                                 CT const& Cj, CT const& sqrt_1_Cj_sqr,
+                                 CT const& e_sqr)
+{
+    using math::detail::bounded;
+
+    if (Order == 0)
+    {
+        return 0;
+    }
+
+    CT const c1 = 1;
+    CT const c2 = 2;
+        
+    CT const asin_B = asin(bounded(sin_beta / sqrt_1_Cj_sqr, -c1, c1));
+    CT const asin_Bj = asin(sin_betaj / sqrt_1_Cj_sqr);
+    CT const L0 = (asin_B - asin_Bj) / c2;
+
+    if (Order == 1)
+    {
+        return -Cj * e_sqr * L0;
+    }
+
+    CT const c0 = 0;
+    CT const c16 = 16;
+
+    CT const X = sin_beta;
+    CT const Xj = sin_betaj;
+    CT const X_sqr = math::sqr(X);
+    CT const Xj_sqr = math::sqr(Xj);
+    CT const Cj_sqr = math::sqr(Cj);
+    CT const Cj_sqr_plus_one = Cj_sqr + c1;
+    CT const one_minus_Cj_sqr = c1 - Cj_sqr;
+    CT const sqrt_Y = math::sqrt(bounded(-X_sqr + one_minus_Cj_sqr, c0));
+    CT const sqrt_Yj = math::sqrt(-Xj_sqr + one_minus_Cj_sqr);
+    CT const L1 = (Cj_sqr_plus_one * (asin_B - asin_Bj) + X * sqrt_Y - Xj * sqrt_Yj) / c16;
+
+    if (Order == 2)
+    {
+        return -Cj * e_sqr * (L0 + e_sqr * L1);
+    }
+
+    CT const c3 = 3;
+    CT const c5 = 5;
+    CT const c128 = 128;
+
+    CT const E = Cj_sqr * (c3 * Cj_sqr + c2) + c3;
+    CT const F = X * (-c2 * X_sqr + c3 * Cj_sqr + c5);
+    CT const Fj = Xj * (-c2 * Xj_sqr + c3 * Cj_sqr + c5);
+    CT const L2 = (E * (asin_B - asin_Bj) + F * sqrt_Y - Fj * sqrt_Yj) / c128;
+
+    if (Order == 3)
+    {
+        return -Cj * e_sqr * (L0 + e_sqr * (L1 + e_sqr * L2));
+    }
+
+    CT const c8 = 8;
+    CT const c9 = 9;
+    CT const c10 = 10;
+    CT const c15 = 15;
+    CT const c24 = 24;
+    CT const c26 = 26;
+    CT const c33 = 33;
+    CT const c6144 = 6144;
+
+    CT const G = Cj_sqr * (Cj_sqr * (Cj_sqr * c15 + c9) + c9) + c15;
+    CT const H = -c10 * Cj_sqr - c26;
+    CT const I = Cj_sqr * (Cj_sqr * c15 + c24) + c33;
+    CT const J = X_sqr * (X * (c8 * X_sqr + H)) + X * I;
+    CT const Jj = Xj_sqr * (Xj * (c8 * Xj_sqr + H)) + Xj * I;
+    CT const L3 = (G * (asin_B - asin_Bj) + J * sqrt_Y - Jj * sqrt_Yj) / c6144;
+
+    // Order 4 and higher
+    return -Cj * e_sqr * (L0 + e_sqr * (L1 + e_sqr * (L2 + e_sqr * L3)));
+}
+
+/*!
+\brief The representation of geodesic as proposed by Sjoberg.
+\see See
+    - [Sjoberg07] Lars E. Sjoberg, Geodetic intersection on the ellipsoid, 2007
+      http://link.springer.com/article/10.1007/s00190-007-0204-7
+    - [Sjoberg12] Lars E. Sjoberg, Solutions to the ellipsoidal Clairaut constant
+      and the inverse geodetic problem by numerical integration, 2012
+      https://www.degruyter.com/view/j/jogs.2012.2.issue-3/v10156-011-0037-4/v10156-011-0037-4.xml
+*/
+template <typename CT, unsigned int Order>
+class sjoberg_geodesic
+{
+    sjoberg_geodesic() {}
+
+    static int sign_C(CT const& alphaj)
+    {
+        CT const c0 = 0;
+        CT const c2 = 2;
+        CT const pi = math::pi<CT>();
+        CT const pi_half = pi / c2;
+
+        return (pi_half < alphaj && alphaj < pi) || (-pi_half < alphaj && alphaj < c0) ? -1 : 1;
+    }
+
+public:
+    sjoberg_geodesic(CT const& lon, CT const& lat, CT const& alpha, CT const& f)
+        : lonj(lon)
+        , latj(lat)
+        , alphaj(alpha)
+    {
+        CT const c0 = 0;
+        CT const c1 = 1;
+        CT const c2 = 2;
+        //CT const pi = math::pi<CT>();
+        //CT const pi_half = pi / c2;
+
+        one_minus_f = c1 - f;
+        e_sqr = f * (c2 - f);
+
+        tan_latj = tan(lat);
+        tan_betaj = one_minus_f * tan_latj;
+        betaj = atan(tan_betaj);
+        sin_betaj = sin(betaj);
+
+        cos_betaj = cos(betaj);
+        sin_alphaj = sin(alphaj);
+        // Clairaut constant (lower-case in the paper)
+        Cj = sign_C(alphaj) * cos_betaj * sin_alphaj;
+        Cj_sqr = math::sqr(Cj);
+        sqrt_1_Cj_sqr = math::sqrt(c1 - Cj_sqr);
+
+        sign_lon_diff = alphaj >= 0 ? 1 : -1; // || alphaj == -pi ?
+        //sign_lon_diff = 1;
+
+        is_on_equator = math::equals(sqrt_1_Cj_sqr, c0);
+        is_Cj_zero = math::equals(Cj, c0);
+
+        t0j = c0;
+        asin_tj_t0j = c0;
+
+        if (! is_Cj_zero)
+        {
+            t0j = sqrt_1_Cj_sqr / Cj;
+        }
+
+        if (! is_on_equator)
+        {
+            //asin_tj_t0j = asin(tan_betaj / t0j);
+            asin_tj_t0j = asin(tan_betaj * Cj / sqrt_1_Cj_sqr);
+        }
+    }
+
+    struct vertex_data
+    {
+        //CT beta0j;
+        CT sin_beta0j;
+        CT dL0j;
+        CT lon0j;
+    };
+
+    vertex_data get_vertex_data() const
+    {
+        CT const c2 = 2;
+        CT const pi = math::pi<CT>();
+        CT const pi_half = pi / c2;
+
+        vertex_data res;
+
+        if (! is_Cj_zero)
+        {
+            //res.beta0j = atan(t0j);
+            //res.sin_beta0j = sin(res.beta0j);
+            res.sin_beta0j = math::sign(t0j) * sqrt_1_Cj_sqr;
+            res.dL0j = d_lambda(res.sin_beta0j);
+            res.lon0j = lonj + sign_lon_diff * (pi_half - asin_tj_t0j + res.dL0j);
+        }
+        else
+        {
+            //res.beta0j = pi_half;
+            //res.sin_beta0j = betaj >= 0 ? 1 : -1;
+            res.sin_beta0j = 1;
+            res.dL0j = 0;
+            res.lon0j = lonj;
+        }
+
+        return res;
+    }
+
+    bool is_sin_beta_ok(CT const& sin_beta) const
+    {
+        CT const c1 = 1;
+        return math::abs(sin_beta / sqrt_1_Cj_sqr) <= c1;
+    }
+
+    bool k_diff(CT const& sin_beta,
+                CT & delta_k) const
+    {
+        if (is_Cj_zero)
+        {
+            delta_k = 0;
+            return true;
+        }
+
+        // beta out of bounds and not close
+        if (! (is_sin_beta_ok(sin_beta)
+                || math::equals(math::abs(sin_beta), sqrt_1_Cj_sqr)) )
+        {
+            return false;
+        }
+        
+        // NOTE: beta may be slightly out of bounds here but d_lambda handles that
+        CT const dLj = d_lambda(sin_beta);
+        delta_k = sign_lon_diff * (/*asin_t_t0j*/ - asin_tj_t0j + dLj);
+
+        return true;
+    }
+
+    bool lon_diff(CT const& sin_beta, CT const& t,
+                  CT & delta_lon) const
+    {
+        using math::detail::bounded;
+        CT const c1 = 1;
+
+        if (is_Cj_zero)
+        {
+            delta_lon = 0;
+            return true;
+        }
+
+        CT delta_k = 0;
+        if (! k_diff(sin_beta, delta_k))
+        {
+            return false;
+        }
+
+        CT const t_t0j = t / t0j;
+        // NOTE: t may be slightly out of bounds here
+        CT const asin_t_t0j = asin(bounded(t_t0j, -c1, c1));
+        delta_lon = sign_lon_diff * asin_t_t0j + delta_k;
+
+        return true;
+    }
+
+    bool k_diffs(CT const& sin_beta, vertex_data const& vd,
+                 CT & delta_k_before, CT & delta_k_behind,
+                 bool check_sin_beta = true) const
+    {
+        CT const pi = math::pi<CT>();
+
+        if (is_Cj_zero)
+        {
+            delta_k_before = 0;
+            delta_k_behind = sign_lon_diff * pi;
+            return true;
+        }
+        
+        // beta out of bounds and not close
+        if (check_sin_beta
+            && ! (is_sin_beta_ok(sin_beta)
+                    || math::equals(math::abs(sin_beta), sqrt_1_Cj_sqr)) )
+        {
+            return false;
+        }
+        
+        // NOTE: beta may be slightly out of bounds here but d_lambda handles that
+        CT const dLj = d_lambda(sin_beta);
+        delta_k_before = sign_lon_diff * (/*asin_t_t0j*/ - asin_tj_t0j + dLj);
+
+        // This version require no additional dLj calculation
+        delta_k_behind = sign_lon_diff * (pi /*- asin_t_t0j*/ - asin_tj_t0j + vd.dL0j + (vd.dL0j - dLj));
+
+        // [Sjoberg12]
+        //CT const dL101 = d_lambda(sin_betaj, vd.sin_beta0j);
+        // WARNING: the following call might not work if beta was OoB because only the second argument is bounded
+        //CT const dL_01 = d_lambda(sin_beta, vd.sin_beta0j);
+        //delta_k_behind = sign_lon_diff * (pi /*- asin_t_t0j*/ - asin_tj_t0j + dL101 + dL_01);
+
+        return true;
+    }
+
+    bool lon_diffs(CT const& sin_beta, CT const& t, vertex_data const& vd,
+                   CT & delta_lon_before, CT & delta_lon_behind) const
+    {
+        using math::detail::bounded;
+        CT const c1 = 1;
+        CT const pi = math::pi<CT>();
+
+        if (is_Cj_zero)
+        {
+            delta_lon_before = 0;
+            delta_lon_behind = sign_lon_diff * pi;
+            return true;
+        }
+
+        CT delta_k_before = 0, delta_k_behind = 0;
+        if (! k_diffs(sin_beta, vd, delta_k_before, delta_k_behind))
+        {
+            return false;
+        }
+
+        CT const t_t0j = t / t0j;
+        // NOTE: t may be slightly out of bounds here
+        CT const asin_t_t0j = asin(bounded(t_t0j, -c1, c1));
+        CT const sign_asin_t_t0j = sign_lon_diff * asin_t_t0j;
+        delta_lon_before = sign_asin_t_t0j + delta_k_before;
+        delta_lon_behind = -sign_asin_t_t0j + delta_k_behind;
+
+        return true;
+    }
+
+    bool lon(CT const& sin_beta, CT const& t, vertex_data const& vd,
+             CT & lon_before, CT & lon_behind) const
+    {
+        using math::detail::bounded;
+        CT const c1 = 1;
+        CT const pi = math::pi<CT>();
+
+        if (is_Cj_zero)
+        {
+            lon_before = lonj;
+            lon_behind = lonj + sign_lon_diff * pi;
+            return true;
+        }
+
+        if (! (is_sin_beta_ok(sin_beta)
+                || math::equals(math::abs(sin_beta), sqrt_1_Cj_sqr)) )
+        {
+            return false;
+        }
+
+        CT const t_t0j = t / t0j;
+        CT const asin_t_t0j = asin(bounded(t_t0j, -c1, c1));
+        CT const dLj = d_lambda(sin_beta);
+        lon_before = lonj + sign_lon_diff * (asin_t_t0j - asin_tj_t0j + dLj);
+        lon_behind = vd.lon0j + (vd.lon0j - lon_before);
+
+        return true;
+    }
+
+
+    CT lon(CT const& delta_lon) const
+    {
+        return lonj + delta_lon;
+    }
+
+    CT lat(CT const& t) const
+    {
+        // t = tan(beta) = (1-f)tan(lat)
+        return atan(t / one_minus_f);
+    }
+
+    void vertex(CT & lon, CT & lat) const
+    {
+        lon = get_vertex_data().lon0j;
+        if (! is_Cj_zero)
+        {
+            lat = sjoberg_geodesic::lat(t0j);
+        }
+        else
+        {
+            CT const c2 = 2;
+            lat = math::pi<CT>() / c2;
+        }
+    }
+
+    CT lon_of_equator_intersection() const
+    {
+        CT const c0 = 0;
+        CT const dLj = d_lambda(c0);
+        CT const asin_tj_t0j = asin(Cj * tan_betaj / sqrt_1_Cj_sqr);
+        return lonj - asin_tj_t0j + dLj;
+    }
+
+    CT d_lambda(CT const& sin_beta) const
+    {
+        return sjoberg_d_lambda_e_sqr<Order>(sin_betaj, sin_beta, Cj, sqrt_1_Cj_sqr, e_sqr);
+    }
+
+    // [Sjoberg12]
+    /*CT d_lambda(CT const& sin_beta1, CT const& sin_beta2) const
+    {
+        return sjoberg_d_lambda_e_sqr<Order>(sin_beta1, sin_beta2, Cj, sqrt_1_Cj_sqr, e_sqr);
+    }*/
+
+    CT lonj;
+    CT latj;
+    CT alphaj;
+
+    CT one_minus_f;
+    CT e_sqr;
+
+    CT tan_latj;
+    CT tan_betaj;
+    CT betaj;
+    CT sin_betaj;
+    CT cos_betaj;
+    CT sin_alphaj;
+    CT Cj;
+    CT Cj_sqr;
+    CT sqrt_1_Cj_sqr;
+
+    int sign_lon_diff;
+
+    bool is_on_equator;
+    bool is_Cj_zero;
+
+    CT t0j;
+    CT asin_tj_t0j;
+};
+
+
+/*!
+\brief The intersection of two geodesics as proposed by Sjoberg.
+\see See
+    - [Sjoberg02] Lars E. Sjoberg, Intersections on the sphere and ellipsoid, 2002
+      http://link.springer.com/article/10.1007/s00190-001-0230-9
+    - [Sjoberg07] Lars E. Sjoberg, Geodetic intersection on the ellipsoid, 2007
+      http://link.springer.com/article/10.1007/s00190-007-0204-7
+    - [Sjoberg12] Lars E. Sjoberg, Solutions to the ellipsoidal Clairaut constant
+      and the inverse geodetic problem by numerical integration, 2012
+      https://www.degruyter.com/view/j/jogs.2012.2.issue-3/v10156-011-0037-4/v10156-011-0037-4.xml
+*/
+template
+<
+    typename CT,
+    template <typename, bool, bool, bool, bool, bool> class Inverse,
+    unsigned int Order = 4
+>
+class sjoberg_intersection
+{
+    typedef sjoberg_geodesic<CT, Order> geodesic_type;
+    typedef Inverse<CT, false, true, false, false, false> inverse_type;
+    typedef typename inverse_type::result_type inverse_result;
+
+    static bool const enable_02 = true;
+    static int const max_iterations_02 = 10;
+    static int const max_iterations_07 = 20;
+
+public:
+    template <typename T1, typename T2, typename Spheroid>
+    static inline bool apply(T1 const& lona1, T1 const& lata1,
+                             T1 const& lona2, T1 const& lata2,
+                             T2 const& lonb1, T2 const& latb1,
+                             T2 const& lonb2, T2 const& latb2,
+                             CT & lon, CT & lat,
+                             Spheroid const& spheroid)
+    {
+        CT const lon_a1 = lona1;
+        CT const lat_a1 = lata1;
+        CT const lon_a2 = lona2;
+        CT const lat_a2 = lata2;
+        CT const lon_b1 = lonb1;
+        CT const lat_b1 = latb1;
+        CT const lon_b2 = lonb2;
+        CT const lat_b2 = latb2;
+
+        inverse_result const res1 = inverse_type::apply(lon_a1, lat_a1, lon_a2, lat_a2, spheroid);
+        inverse_result const res2 = inverse_type::apply(lon_b1, lat_b1, lon_b2, lat_b2, spheroid);
+
+        return apply(lon_a1, lat_a1, lon_a2, lat_a2, res1.azimuth,
+                     lon_b1, lat_b1, lon_b2, lat_b2, res2.azimuth,
+                     lon, lat, spheroid);
+    }
+
+    // TODO: Currently may not work correctly if one of the endpoints is the pole
+    template <typename Spheroid>
+    static inline bool apply(CT const& lon_a1, CT const& lat_a1, CT const& lon_a2, CT const& lat_a2, CT const& alpha_a1,
+                             CT const& lon_b1, CT const& lat_b1, CT const& lon_b2, CT const& lat_b2, CT const& alpha_b1,
+                             CT & lon, CT & lat,
+                             Spheroid const& spheroid)
+    {
+        // coordinates in radians
+
+        CT const c0 = 0;
+        CT const c1 = 1;
+
+        CT const f = formula::flattening<CT>(spheroid);
+        CT const one_minus_f = c1 - f;
+
+        geodesic_type geod1(lon_a1, lat_a1, alpha_a1, f);
+        geodesic_type geod2(lon_b1, lat_b1, alpha_b1, f);
+
+        // Cj = 1 if on equator <=> sqrt_1_Cj_sqr = 0
+        // Cj = 0 if vertical <=> sqrt_1_Cj_sqr = 1
+
+        if (geod1.is_on_equator && geod2.is_on_equator)
+        {
+            return false;
+        }
+        else if (geod1.is_on_equator)
+        {
+            lon = geod2.lon_of_equator_intersection();
+            lat = c0;
+            return true;
+        }
+        else if (geod2.is_on_equator)
+        {
+            lon = geod1.lon_of_equator_intersection();
+            lat = c0;
+            return true;
+        }
+
+        // (lon1 - lon2) normalized to (-180, 180]
+        CT const lon1_minus_lon2 = math::longitude_distance_signed<radian>(geod2.lonj, geod1.lonj);
+
+        // vertical segments
+        if (geod1.is_Cj_zero && geod2.is_Cj_zero)
+        {
+            CT const pi = math::pi<CT>();
+
+            // the geodesics are parallel, the intersection point cannot be calculated
+            if ( math::equals(lon1_minus_lon2, c0)
+              || math::equals(lon1_minus_lon2 + (lon1_minus_lon2 < c0 ? pi : -pi), c0) )
+            {
+                return false;
+            }
+
+            lon = c0;
+
+            // the geodesics intersect at one of the poles
+            CT const pi_half = pi / CT(2);
+            CT const abs_lat_a1 = math::abs(lat_a1);
+            CT const abs_lat_a2 = math::abs(lat_a2);
+            if (math::equals(abs_lat_a1, abs_lat_a2))
+            {
+                lat = pi_half;
+            }
+            else
+            {
+                // pick the pole closest to one of the points of the first segment
+                CT const& closer_lat = abs_lat_a1 > abs_lat_a2 ? lat_a1 : lat_a2;
+                lat = closer_lat >= 0 ? pi_half : -pi_half;
+            }
+
+            return true;
+        }
+
+        CT lon_sph = 0;
+
+        // Starting tan(beta)
+        CT t = 0;
+
+        /*if (geod1.is_Cj_zero)
+        {
+            CT const k_base = lon1_minus_lon2 + geod2.sign_lon_diff * geod2.asin_tj_t0j;
+            t = sin(k_base) * geod2.t0j;
+            lon_sph = vertical_intersection_longitude(geod1.lonj, lon_b1, lon_b2);
+        }
+        else if (geod2.is_Cj_zero)
+        {
+            CT const k_base = lon1_minus_lon2 - geod1.sign_lon_diff * geod1.asin_tj_t0j;
+            t = sin(-k_base) * geod1.t0j;
+            lon_sph = vertical_intersection_longitude(geod2.lonj, lon_a1, lon_a2);
+        }
+        else*/
+        {
+            // TODO: Consider using betas instead of latitudes.
+            //       Some function calls might be saved this way.
+            CT tan_lat_sph = 0;
+            sjoberg_intersection_spherical_02<CT>::apply_alt(lon_a1, lat_a1, lon_a2, lat_a2,
+                                                             lon_b1, lat_b1, lon_b2, lat_b2,
+                                                             lon_sph, tan_lat_sph);
+            t = one_minus_f * tan_lat_sph; // tan(beta)
+        }
+
+        // TODO: no need to calculate atan here if reduced latitudes were used
+        //       instead of latitudes above, in sjoberg_intersection_spherical_02
+        CT const beta = atan(t);
+
+        if (enable_02 && newton_method(geod1, geod2, beta, t, lon1_minus_lon2, lon, lat))
+        {
+            return true;
+        }
+
+        return converge_07(geod1, geod2, beta, t, lon1_minus_lon2, lon_sph, lon, lat);
+    }
+
+private:
+    static inline bool newton_method(geodesic_type const& geod1, geodesic_type const& geod2, // in
+                                     CT beta, CT t, CT const& lon1_minus_lon2, // in
+                                     CT & lon, CT & lat) // out
+    {
+        CT const c0 = 0;
+        CT const c1 = 1;
+
+        CT const e_sqr = geod1.e_sqr;
+        
+        CT lon1_diff = 0;
+        CT lon2_diff = 0;
+
+        CT abs_dbeta_last = 0;
+
+        // [Sjoberg02] converges faster than solution in [Sjoberg07]
+        // Newton-Raphson method
+        for (int i = 0; i < max_iterations_02; ++i)
+        {
+            CT const sin_beta = sin(beta);
+            CT const cos_beta = cos(beta);
+            CT const cos_beta_sqr = math::sqr(cos_beta);
+            CT const G = c1 - e_sqr * cos_beta_sqr;
+
+            CT f1 = 0;
+            CT f2 = 0;
+
+            if (!geod1.is_Cj_zero)
+            {
+                bool is_beta_ok = geod1.lon_diff(sin_beta, t, lon1_diff);
+
+                if (is_beta_ok)
+                {
+                    CT const H = cos_beta_sqr - geod1.Cj_sqr;
+                    f1 = geod1.Cj / cos_beta * math::sqrt(G / H);
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            if (!geod2.is_Cj_zero)
+            {
+                bool is_beta_ok = geod2.lon_diff(sin_beta, t, lon2_diff);
+
+                if (is_beta_ok)
+                {
+                    CT const H = cos_beta_sqr - geod2.Cj_sqr;
+                    f2 = geod2.Cj / cos_beta * math::sqrt(G / H);
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            // NOTE: Things may go wrong if the IP is near the vertex
+            //   1. May converge into the wrong direction (from the other way around).
+            //      This happens when the starting point is on the other side than the vertex
+            //   2. During converging may "jump" into the other side of the vertex.
+            //      In this case sin_beta/sqrt_1_Cj_sqr and t/t0j is not in [-1, 1]
+            //   3. f1-f2 may be 0 which means that the intermediate point is on the vertex
+            //      In this case it's not possible to check if this is the correct result
+
+            CT const dbeta_denom = f1 - f2;
+            //CT const dbeta_denom = math::abs(f1) + math::abs(f2);
+
+            if (math::equals(dbeta_denom, c0))
+            {
+                return false;
+            }            
+
+            // The sign of dbeta is changed WRT [Sjoberg02]
+            CT const dbeta = (lon1_minus_lon2 + lon1_diff - lon2_diff) / dbeta_denom;
+
+            CT const abs_dbeta = math::abs(dbeta);
+            if (i > 0 && abs_dbeta > abs_dbeta_last)
+            {
+                // The algorithm is not converging
+                // The intersection may be on the other side of the vertex
+                return false;
+            }
+            abs_dbeta_last = abs_dbeta;
+
+            if (math::equals(dbeta, c0))
+            {
+                // Result found
+                break;
+            }
+
+            // Because the sign of dbeta is changed WRT [Sjoberg02] dbeta is subtracted here
+            beta = beta - dbeta;
+
+            t = tan(beta);
+        }
+
+        lat = geod1.lat(t);
+        // NOTE: if Cj is 0 then the result is lonj or lonj+180
+        lon = ! geod1.is_Cj_zero
+                ? geod1.lon(lon1_diff)
+                : geod2.lon(lon2_diff);
+
+        return true;
+    }
+
+    struct geodesics_type
+    {
+        geodesics_type(geodesic_type const& g1, geodesic_type const& g2)
+            : geod1(g1)
+            , geod2(g2)
+            , vertex1(geod1.get_vertex_data())
+            , vertex2(geod2.get_vertex_data())
+        {}
+
+        geodesic_type const& geod1;
+        geodesic_type const& geod2;
+        typename geodesic_type::vertex_data vertex1;
+        typename geodesic_type::vertex_data vertex2;
+    };
+
+    struct converge_07_result
+    {
+        converge_07_result()
+            : lon1(0), lon2(0), k1_diff(0), k2_diff(0), t1(0), t2(0)
+        {}
+
+        CT lon1, lon2;
+        CT k1_diff, k2_diff;
+        CT t1, t2;
+    };
+
+    static inline bool converge_07(geodesic_type const& geod1, geodesic_type const& geod2,
+                                   CT beta, CT t,
+                                   CT const& lon1_minus_lon2, CT const& lon_sph,
+                                   CT & lon, CT & lat)
+    {
+        //CT const c0 = 0;
+        //CT const c1 = 1;
+        //CT const c2 = 2;
+        //CT const pi = math::pi<CT>();
+
+        geodesics_type geodesics(geod1, geod2);
+        converge_07_result result;
+
+        // calculate first pair of longitudes
+        if (!converge_07_step_one(CT(sin(beta)), t, lon1_minus_lon2, geodesics, lon_sph, result, false))
+        {
+            return false;
+        }
+
+        int t_direction = 0;
+
+        CT lon_diff_prev = math::longitude_difference<radian>(result.lon1, result.lon2);
+
+        // [Sjoberg07]
+        for (int i = 2; i < max_iterations_07; ++i)
+        {
+            // pick t candidates from previous result based on dir
+            CT t_cand1 = result.t1;
+            CT t_cand2 = result.t2;
+            // if direction is 0 the closer one is the first
+            if (t_direction < 0)
+            {
+                t_cand1 = (std::min)(result.t1, result.t2);
+                t_cand2 = (std::max)(result.t1, result.t2);
+            }
+            else if (t_direction > 0)
+            {
+                t_cand1 = (std::max)(result.t1, result.t2);
+                t_cand2 = (std::min)(result.t1, result.t2);
+            }
+            else
+            {
+                t_direction = t_cand1 < t_cand2 ? -1 : 1;
+            }
+
+            CT t1 = t;
+            CT beta1 = beta;
+            // check if the further calculation is needed
+            if (converge_07_update(t1, beta1, t_cand1))
+            {
+                break;
+            }
+                    
+            bool try_t2 = false;
+            converge_07_result result_curr;
+            if (converge_07_step_one(CT(sin(beta1)), t1, lon1_minus_lon2, geodesics, lon_sph, result_curr))
+            {
+                CT const lon_diff1 = math::longitude_difference<radian>(result_curr.lon1, result_curr.lon2);
+                if (lon_diff_prev > lon_diff1)
+                {
+                    t = t1;
+                    beta = beta1;
+                    lon_diff_prev = lon_diff1;
+                    result = result_curr;
+                }
+                else if (t_cand1 != t_cand2)
+                {
+                    try_t2 = true;
+                }
+                else
+                {
+                    // the result is not fully correct but it won't be more accurate
+                    break;
+                }
+            }
+            // ! converge_07_step_one
+            else
+            {
+                if (t_cand1 != t_cand2)
+                {
+                    try_t2 = true;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+
+            
+            if (try_t2)
+            {
+                CT t2 = t;
+                CT beta2 = beta;
+                // check if the further calculation is needed
+                if (converge_07_update(t2, beta2, t_cand2))
+                {
+                    break;
+                }
+
+                if (! converge_07_step_one(CT(sin(beta2)), t2, lon1_minus_lon2, geodesics, lon_sph, result_curr))
+                {
+                    return false;
+                }
+
+                CT const lon_diff2 = math::longitude_difference<radian>(result_curr.lon1, result_curr.lon2);
+                if (lon_diff_prev > lon_diff2)
+                {
+                    t_direction *= -1;
+                    t = t2;
+                    beta = beta2;
+                    lon_diff_prev = lon_diff2;
+                    result = result_curr;
+                }
+                else
+                {
+                    // the result is not fully correct but it won't be more accurate
+                    break;
+                }
+            }
+        }
+
+        lat = geod1.lat(t);
+        lon = ! geod1.is_Cj_zero ? result.lon1 : result.lon2;
+        math::normalize_longitude<radian>(lon);
+
+        return true;
+    }
+
+    static inline bool converge_07_update(CT & t, CT & beta, CT const& t_new)
+    {
+        CT const c0 = 0;
+
+        CT const beta_new = atan(t_new);
+        CT const dbeta = beta_new - beta;
+        beta = beta_new;
+        t = t_new;
+
+        return math::equals(dbeta, c0);
+    }
+
+    static inline CT const& pick_t(CT const& t1, CT const& t2, int direction)
+    {
+        return direction < 0 ? (std::min)(t1, t2) : (std::max)(t1, t2);
+    }
+
+    static inline bool converge_07_step_one(CT const& sin_beta,
+                                            CT const& t,
+                                            CT const& lon1_minus_lon2,
+                                            geodesics_type const& geodesics,
+                                            CT const& lon_sph,
+                                            converge_07_result & result,
+                                            bool check_sin_beta = true)
+    {
+        bool ok = converge_07_one_geod(sin_beta, t, geodesics.geod1, geodesics.vertex1, lon_sph,
+                                       result.lon1, result.k1_diff, check_sin_beta)
+               && converge_07_one_geod(sin_beta, t, geodesics.geod2, geodesics.vertex2, lon_sph,
+                                       result.lon2, result.k2_diff, check_sin_beta);
+
+        if (!ok)
+        {
+            return false;
+        }
+
+        CT const k = lon1_minus_lon2 + result.k1_diff - result.k2_diff;
+
+        // get 2 possible ts one lesser and one greater than t
+        // t1 is the closer one
+        calc_ts(t, k, geodesics.geod1, geodesics.geod2, result.t1, result.t2);
+
+        return true;
+    }
+
+    static inline bool converge_07_one_geod(CT const& sin_beta, CT const& t,
+                                            geodesic_type const& geod,
+                                            typename geodesic_type::vertex_data const& vertex,
+                                            CT const& lon_sph,
+                                            CT & lon, CT & k_diff,
+                                            bool check_sin_beta)
+    {
+        using math::detail::bounded;
+        CT const c1 = 1;
+        
+        CT k_diff_before = 0;
+        CT k_diff_behind = 0;
+
+        bool is_beta_ok = geod.k_diffs(sin_beta, vertex, k_diff_before, k_diff_behind, check_sin_beta);
+
+        if (! is_beta_ok)
+        {
+            return false;
+        }
+
+        CT const asin_t_t0j = ! geod.is_Cj_zero ? asin(bounded(t / geod.t0j, -c1, c1)) : 0;
+        CT const sign_asin_t_t0j = geod.sign_lon_diff * asin_t_t0j;
+
+        CT const lon_before = geod.lonj + sign_asin_t_t0j + k_diff_before;
+        CT const lon_behind = geod.lonj - sign_asin_t_t0j + k_diff_behind;
+
+        CT const lon_dist_before = math::longitude_distance_signed<radian>(lon_before, lon_sph);
+        CT const lon_dist_behind = math::longitude_distance_signed<radian>(lon_behind, lon_sph);
+        if (math::abs(lon_dist_before) <= math::abs(lon_dist_behind))
+        {
+            k_diff = k_diff_before;
+            lon = lon_before;
+        }
+        else
+        {
+            k_diff = k_diff_behind;
+            lon = lon_behind;
+        }
+
+        return true;
+    }
+
+    static inline void calc_ts(CT const& t, CT const& k,
+                               geodesic_type const& geod1, geodesic_type const& geod2,
+                               CT & t1, CT& t2)
+    {
+        CT const c1 = 1;
+        CT const c2 = 2;
+
+        CT const K = sin(k);
+
+        BOOST_GEOMETRY_ASSERT(!geod1.is_Cj_zero || !geod2.is_Cj_zero);
+        if (geod1.is_Cj_zero)
+        {
+            t1 = K * geod2.t0j;
+            t2 = -t1;
+        }
+        else if (geod2.is_Cj_zero)
+        {
+            t1 = -K * geod1.t0j;
+            t2 = -t1;
+        }
+        else
+        {
+            CT const A = math::sqr(geod1.t0j) + math::sqr(geod2.t0j);
+            CT const B = c2 * geod1.t0j * geod2.t0j * math::sqrt(c1 - math::sqr(K));
+
+            CT const K_t01_t02 = K * geod1.t0j * geod2.t0j;
+            CT const D1 = math::sqrt(A + B);
+            CT const D2 = math::sqrt(A - B);
+            CT const t_new1 = K_t01_t02 / D1;
+            CT const t_new2 = K_t01_t02 / D2;
+            CT const t_new3 = -t_new1;
+            CT const t_new4 = -t_new2;
+
+            // Pick 2 nearest t_new, one greater and one lesser than current t
+            CT const abs_t_new1 = math::abs(t_new1);
+            CT const abs_t_new2 = math::abs(t_new2);
+            CT const abs_t_max = (std::max)(abs_t_new1, abs_t_new2);
+            t1 = -abs_t_max; // lesser
+            t2 = abs_t_max; // greater
+            if (t1 < t)
+            {
+                if (t_new1 < t && t_new1 > t1)
+                    t1 = t_new1;
+                if (t_new2 < t && t_new2 > t1)
+                    t1 = t_new2;
+                if (t_new3 < t && t_new3 > t1)
+                    t1 = t_new3;
+                if (t_new4 < t && t_new4 > t1)
+                    t1 = t_new4;
+            }
+            if (t2 > t)
+            {
+                if (t_new1 > t && t_new1 < t2)
+                    t2 = t_new1;
+                if (t_new2 > t && t_new2 < t2)
+                    t2 = t_new2;
+                if (t_new3 > t && t_new3 < t2)
+                    t2 = t_new3;
+                if (t_new4 > t && t_new4 < t2)
+                    t2 = t_new4;
+            }
+        }
+
+        // the first one is the closer one
+        if (math::abs(t - t2) < math::abs(t - t1))
+        {
+            std::swap(t2, t1);
+        }
+    }
+
+    static inline CT fj(CT const& cos_beta, CT const& cos2_beta, CT const& Cj, CT const& e_sqr)
+    {
+        CT const c1 = 1;
+        CT const Cj_sqr = math::sqr(Cj);
+        return Cj / cos_beta * math::sqrt((c1 - e_sqr * cos2_beta) / (cos2_beta - Cj_sqr));
+    }
+
+    /*static inline CT vertical_intersection_longitude(CT const& ip_lon, CT const& seg_lon1, CT const& seg_lon2)
+    {
+        CT const c0 = 0;
+        CT const lon_2 = ip_lon > c0 ? ip_lon - pi : ip_lon + pi;
+
+        return (std::min)(math::longitude_difference<radian>(ip_lon, seg_lon1),
+                          math::longitude_difference<radian>(ip_lon, seg_lon2))
+            <=
+               (std::min)(math::longitude_difference<radian>(lon_2, seg_lon1),
+                          math::longitude_difference<radian>(lon_2, seg_lon2))
+            ? ip_lon : lon_2;
+    }*/
+};
+
+}}} // namespace boost::geometry::formula
+
+
+#endif // BOOST_GEOMETRY_FORMULAS_SJOBERG_INTERSECTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/formulas/spherical.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/spherical.hpp
new file mode 100644
index 00000000000..ff24c51a880
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/spherical.hpp
@@ -0,0 +1,224 @@
+// Boost.Geometry
+
+// Copyright (c) 2016, Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_FORMULAS_SPHERICAL_HPP
+#define BOOST_GEOMETRY_FORMULAS_SPHERICAL_HPP
+
+#include <boost/geometry/core/coordinate_system.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/radian_access.hpp>
+
+//#include <boost/geometry/arithmetic/arithmetic.hpp>
+#include <boost/geometry/arithmetic/cross_product.hpp>
+#include <boost/geometry/arithmetic/dot_product.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/normalize_spheroidal_coordinates.hpp>
+#include <boost/geometry/util/select_coordinate_type.hpp>
+
+namespace boost { namespace geometry {
+    
+namespace formula {
+
+template <typename T>
+struct result_spherical
+{
+    result_spherical()
+        : azimuth(0)
+        , reverse_azimuth(0)
+    {}
+
+    T azimuth;
+    T reverse_azimuth;
+};
+
+template <typename T>
+static inline void sph_to_cart3d(T const& lon, T const& lat, T & x, T & y, T & z)
+{
+    T const cos_lat = cos(lat);
+    x = cos_lat * cos(lon);
+    y = cos_lat * sin(lon);
+    z = sin(lat);
+}
+
+template <typename Point3d, typename PointSph>
+static inline Point3d sph_to_cart3d(PointSph const& point_sph)
+{
+    typedef typename coordinate_type<Point3d>::type calc_t;
+
+    calc_t const lon = get_as_radian<0>(point_sph);
+    calc_t const lat = get_as_radian<1>(point_sph);
+    calc_t x, y, z;
+    sph_to_cart3d(lon, lat, x, y, z);
+
+    Point3d res;
+    set<0>(res, x);
+    set<1>(res, y);
+    set<2>(res, z);
+
+    return res;
+}
+
+template <typename T>
+static inline void cart3d_to_sph(T const& x, T const& y, T const& z, T & lon, T & lat)
+{
+    lon = atan2(y, x);
+    lat = asin(z);
+}
+
+template <typename PointSph, typename Point3d>
+static inline PointSph cart3d_to_sph(Point3d const& point_3d)
+{
+    typedef typename coordinate_type<PointSph>::type coord_t;
+    typedef typename coordinate_type<Point3d>::type calc_t;
+
+    calc_t const x = get<0>(point_3d);
+    calc_t const y = get<1>(point_3d);
+    calc_t const z = get<2>(point_3d);
+    calc_t lonr, latr;
+    cart3d_to_sph(x, y, z, lonr, latr);
+
+    PointSph res;
+    set_from_radian<0>(res, lonr);
+    set_from_radian<1>(res, latr);
+
+    coord_t lon = get<0>(res);
+    coord_t lat = get<1>(res);
+
+    math::normalize_spheroidal_coordinates
+        <
+            typename coordinate_system<PointSph>::type::units,
+            coord_t
+        >(lon, lat);
+
+    set<0>(res, lon);
+    set<1>(res, lat);
+
+    return res;
+}
+
+// -1 right
+// 1 left
+// 0 on
+template <typename Point3d1, typename Point3d2>
+static inline int sph_side_value(Point3d1 const& norm, Point3d2 const& pt)
+{
+    typedef typename select_coordinate_type<Point3d1, Point3d2>::type calc_t;
+    calc_t c0 = 0;
+    calc_t d = dot_product(norm, pt);
+    return math::equals(d, c0) ? 0
+        : d > c0 ? 1
+        : -1; // d < 0
+}
+
+template <typename CT, bool ReverseAzimuth, typename T1, typename T2>
+static inline result_spherical<CT> spherical_azimuth(T1 const& lon1,
+                                                     T1 const& lat1,
+                                                     T2 const& lon2,
+                                                     T2 const& lat2)
+{
+    typedef result_spherical<CT> result_type;
+    result_type result;
+
+    // http://williams.best.vwh.net/avform.htm#Crs
+    // https://en.wikipedia.org/wiki/Great-circle_navigation
+    CT dlon = lon2 - lon1;
+
+    // An optimization which should kick in often for Boxes
+    //if ( math::equals(dlon, ReturnType(0)) )
+    //if ( get<0>(p1) == get<0>(p2) )
+    //{
+    //    return - sin(get_as_radian<1>(p1)) * cos_p2lat);
+    //}
+
+    CT const cos_dlon = cos(dlon);
+    CT const sin_dlon = sin(dlon);
+    CT const cos_lat1 = cos(lat1);
+    CT const cos_lat2 = cos(lat2);
+    CT const sin_lat1 = sin(lat1);
+    CT const sin_lat2 = sin(lat2);
+
+    {
+        // "An alternative formula, not requiring the pre-computation of d"
+        // In the formula below dlon is used as "d"
+        CT const y = sin_dlon * cos_lat2;
+        CT const x = cos_lat1 * sin_lat2 - sin_lat1 * cos_lat2 * cos_dlon;
+        result.azimuth = atan2(y, x);
+    }
+
+    if (ReverseAzimuth)
+    {
+        CT const y = sin_dlon * cos_lat1;
+        CT const x = sin_lat2 * cos_lat1 * cos_dlon - cos_lat2 * sin_lat1;
+        result.reverse_azimuth = atan2(y, x);
+    }
+
+    return result;
+}
+
+template <typename ReturnType, typename T1, typename T2>
+inline ReturnType spherical_azimuth(T1 const& lon1, T1 const& lat1,
+                                    T2 const& lon2, T2 const& lat2)
+{
+    return spherical_azimuth<ReturnType, false>(lon1, lat1, lon2, lat2).azimuth;
+}
+
+template <typename T>
+inline T spherical_azimuth(T const& lon1, T const& lat1, T const& lon2, T const& lat2)
+{
+    return spherical_azimuth<T, false>(lon1, lat1, lon2, lat2).azimuth;
+}
+
+template <typename T>
+inline int azimuth_side_value(T const& azi_a1_p, T const& azi_a1_a2)
+{
+    T const pi = math::pi<T>();
+    T const two_pi = math::two_pi<T>();
+
+    // instead of the formula from XTD
+    //calc_t a_diff = asin(sin(azi_a1_p - azi_a1_a2));
+
+    T a_diff = azi_a1_p - azi_a1_a2;
+    // normalize, angle in [-pi, pi]
+    while (a_diff > pi)
+        a_diff -= two_pi;
+    while (a_diff < -pi)
+        a_diff += two_pi;
+
+    // NOTE: in general it shouldn't be required to support the pi/-pi case
+    // because in non-cartesian systems it makes sense to check the side
+    // only "between" the endpoints.
+    // However currently the winding strategy calls the side strategy
+    // for vertical segments to check if the point is "between the endpoints.
+    // This could be avoided since the side strategy is not required for that
+    // because meridian is the shortest path. So a difference of
+    // longitudes would be sufficient (of course normalized to [-pi, pi]).
+
+    // NOTE: with the above said, the pi/-pi check is temporary
+    // however in case if this was required
+    // the geodesics on ellipsoid aren't "symmetrical"
+    // therefore instead of comparing a_diff to pi and -pi
+    // one should probably use inverse azimuths and compare
+    // the difference to 0 as well
+
+    // positive azimuth is on the right side
+    return math::equals(a_diff, 0)
+        || math::equals(a_diff, pi)
+        || math::equals(a_diff, -pi) ? 0
+        : a_diff > 0 ? -1 // right
+        : 1; // left
+}
+
+} // namespace formula
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_FORMULAS_SPHERICAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/formulas/thomas_direct.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/thomas_direct.hpp
new file mode 100644
index 00000000000..f208167cf56
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/thomas_direct.hpp
@@ -0,0 +1,248 @@
+// Boost.Geometry
+
+// Copyright (c) 2016 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_FORMULAS_THOMAS_DIRECT_HPP
+#define BOOST_GEOMETRY_FORMULAS_THOMAS_DIRECT_HPP
+
+
+#include <boost/math/constants/constants.hpp>
+
+#include <boost/geometry/core/radius.hpp>
+#include <boost/geometry/core/srs.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/formulas/differential_quantities.hpp>
+#include <boost/geometry/formulas/flattening.hpp>
+#include <boost/geometry/formulas/result_direct.hpp>
+
+
+namespace boost { namespace geometry { namespace formula
+{
+
+
+/*!
+\brief The solution of the direct problem of geodesics on latlong coordinates,
+       Forsyth-Andoyer-Lambert type approximation with second order terms.
+\author See
+    - Technical Report: PAUL D. THOMAS, MATHEMATICAL MODELS FOR NAVIGATION SYSTEMS, 1965
+      http://www.dtic.mil/docs/citations/AD0627893
+    - Technical Report: PAUL D. THOMAS, SPHEROIDAL GEODESICS, REFERENCE SYSTEMS, AND LOCAL GEOMETRY, 1970
+      http://www.dtic.mil/docs/citations/AD0703541
+
+*/
+template <
+    typename CT,
+    bool EnableCoordinates = true,
+    bool EnableReverseAzimuth = false,
+    bool EnableReducedLength = false,
+    bool EnableGeodesicScale = false
+>
+class thomas_direct
+{
+    static const bool CalcQuantities = EnableReducedLength || EnableGeodesicScale;
+    static const bool CalcCoordinates = EnableCoordinates || CalcQuantities;
+    static const bool CalcRevAzimuth = EnableReverseAzimuth || CalcCoordinates || CalcQuantities;
+
+public:
+    typedef result_direct<CT> result_type;
+
+    template <typename T, typename Dist, typename Azi, typename Spheroid>
+    static inline result_type apply(T const& lo1,
+                                    T const& la1,
+                                    Dist const& distance,
+                                    Azi const& azimuth12,
+                                    Spheroid const& spheroid)
+    {
+        result_type result;
+
+        CT const lon1 = lo1;
+        CT const lat1 = la1;
+
+        if ( math::equals(distance, Dist(0)) || distance < Dist(0) )
+        {
+            result.lon2 = lon1;
+            result.lat2 = lat1;
+            return result;
+        }
+
+        CT const c0 = 0;
+        CT const c1 = 1;
+        CT const c2 = 2;
+        CT const c4 = 4;
+
+        CT const a = CT(get_radius<0>(spheroid));
+        CT const b = CT(get_radius<2>(spheroid));
+        CT const f = formula::flattening<CT>(spheroid);
+        CT const one_minus_f = c1 - f;
+
+        CT const pi = math::pi<CT>();
+        CT const pi_half = pi / c2;
+
+        // keep azimuth small - experiments show low accuracy
+        // if the azimuth is closer to (+-)180 deg.
+        CT azi12_alt = azimuth12;
+        CT lat1_alt = lat1;
+        bool alter_result = vflip_if_south(lat1, azimuth12, lat1_alt, azi12_alt);
+        
+        CT const theta1 = math::equals(lat1_alt, pi_half) ? lat1_alt :
+                          math::equals(lat1_alt, -pi_half) ? lat1_alt :
+                          atan(one_minus_f * tan(lat1_alt));
+        CT const sin_theta1 = sin(theta1);
+        CT const cos_theta1 = cos(theta1);
+
+        CT const sin_a12 = sin(azi12_alt);
+        CT const cos_a12 = cos(azi12_alt);
+
+        CT const M = cos_theta1 * sin_a12; // cos_theta0
+        CT const theta0 = acos(M);
+        CT const sin_theta0 = sin(theta0);
+
+        CT const N = cos_theta1 * cos_a12;
+        CT const C1 = f * M; // lower-case c1 in the technical report
+        CT const C2 = f * (c1 - math::sqr(M)) / c4; // lower-case c2 in the technical report
+        CT const D = (c1 - C2) * (c1 - C2 - C1 * M);
+        CT const P = C2 * (c1 + C1 * M / c2) / D;
+
+        // special case for equator:
+        // sin_theta0 = 0 <=> lat1 = 0 ^ |azimuth12| = pi/2
+        // NOTE: in this case it doesn't matter what's the value of cos_sigma1 because
+        //       theta1=0, theta0=0, M=1|-1, C2=0 so X=0 and Y=0 so d_sigma=d
+        //       cos_a12=0 so N=0, therefore
+        //       lat2=0, azi21=pi/2|-pi/2
+        //       d_eta = atan2(sin_d_sigma, cos_d_sigma)
+        //       H = C1 * d_sigma
+        CT const cos_sigma1 = math::equals(sin_theta0, c0)
+                                ? c1
+                                : normalized1_1(sin_theta1 / sin_theta0);
+        CT const sigma1 = acos(cos_sigma1);
+        CT const d = distance / (a * D);
+        CT const u = 2 * (sigma1 - d);
+        CT const cos_d = cos(d);
+        CT const sin_d = sin(d);
+        CT const cos_u = cos(u);
+        CT const sin_u = sin(u);
+
+        CT const W = c1 - c2 * P * cos_u;
+        CT const V = cos_u * cos_d - sin_u * sin_d;
+        CT const X = math::sqr(C2) * sin_d * cos_d * (2 * math::sqr(V) - c1);
+        CT const Y = c2 * P * V * W * sin_d;
+        CT const d_sigma = d + X - Y;
+        CT const sin_d_sigma = sin(d_sigma);
+        CT const cos_d_sigma = cos(d_sigma);
+
+        if (BOOST_GEOMETRY_CONDITION(CalcRevAzimuth))
+        {
+            result.reverse_azimuth = atan2(M, N * cos_d_sigma - sin_theta1 * sin_d_sigma);
+
+            if (alter_result)
+            {
+                vflip_rev_azi(result.reverse_azimuth, azimuth12);
+            }
+        }
+
+        if (BOOST_GEOMETRY_CONDITION(CalcCoordinates))
+        {
+            CT const S_sigma = c2 * sigma1 - d_sigma;
+            CT const cos_S_sigma = cos(S_sigma);
+            CT const d_eta = atan2(sin_d_sigma * sin_a12, cos_theta1 * cos_d_sigma - sin_theta1 * sin_d_sigma * cos_a12);
+            CT const H = C1 * (c1 - C2) * d_sigma - C1 * C2 * sin_d_sigma * cos_S_sigma;
+            CT const d_lambda = d_eta - H;
+            
+            result.lon2 = lon1 + d_lambda;
+
+            if (! math::equals(M, c0))
+            {
+                CT const sin_a21 = sin(result.reverse_azimuth);
+                CT const tan_theta2 = (sin_theta1 * cos_d_sigma + N * sin_d_sigma) * sin_a21 / M;
+                result.lat2 = atan(tan_theta2 / one_minus_f);
+            }
+            else
+            {
+                CT const sigma2 = S_sigma - sigma1;
+                //theta2 = asin(cos(sigma2)) <=> sin_theta0 = 1
+                CT const tan_theta2 = cos(sigma2) / sin(sigma2);
+                result.lat2 = atan(tan_theta2 / one_minus_f);
+            }
+
+            if (alter_result)
+            {
+                result.lat2 = -result.lat2;
+            }
+        }        
+
+        if (BOOST_GEOMETRY_CONDITION(CalcQuantities))
+        {
+            typedef differential_quantities<CT, EnableReducedLength, EnableGeodesicScale, 2> quantities;
+            quantities::apply(lon1, lat1, result.lon2, result.lat2,
+                              azimuth12, result.reverse_azimuth,
+                              b, f,
+                              result.reduced_length, result.geodesic_scale);
+        }
+
+        return result;
+    }
+
+private:
+    static inline bool vflip_if_south(CT const& lat1, CT const& azi12, CT & lat1_alt, CT & azi12_alt)
+    {
+        CT const c2 = 2;
+        CT const pi = math::pi<CT>();
+        CT const pi_half = pi / c2;
+
+        if (azi12 > pi_half)
+        {
+            azi12_alt = pi - azi12;
+            lat1_alt = -lat1;
+            return true;
+        }
+        else if (azi12 < -pi_half)
+        {
+            azi12_alt = -pi - azi12;
+            lat1_alt = -lat1;
+            return true;
+        }
+
+        return false;
+    }
+
+    static inline void vflip_rev_azi(CT & rev_azi, CT const& azimuth12)
+    {
+        CT const c0 = 0;
+        CT const pi = math::pi<CT>();
+
+        if (rev_azi == c0)
+        {
+            rev_azi = azimuth12 >= 0 ? pi : -pi;
+        }
+        else if (rev_azi > c0)
+        {
+            rev_azi = pi - rev_azi;
+        }
+        else
+        {
+            rev_azi = -pi - rev_azi;
+        }
+    }
+
+    static inline CT normalized1_1(CT const& value)
+    {
+        CT const c1 = 1;
+        return value > c1 ? c1 :
+               value < -c1 ? -c1 :
+               value;
+    }
+};
+
+}}} // namespace boost::geometry::formula
+
+
+#endif // BOOST_GEOMETRY_FORMULAS_THOMAS_DIRECT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/formulas/thomas_inverse.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/thomas_inverse.hpp
new file mode 100644
index 00000000000..0853a369803
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/thomas_inverse.hpp
@@ -0,0 +1,220 @@
+// Boost.Geometry
+
+// Copyright (c) 2015-2016 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_FORMULAS_THOMAS_INVERSE_HPP
+#define BOOST_GEOMETRY_FORMULAS_THOMAS_INVERSE_HPP
+
+
+#include <boost/math/constants/constants.hpp>
+
+#include <boost/geometry/core/radius.hpp>
+#include <boost/geometry/core/srs.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/formulas/differential_quantities.hpp>
+#include <boost/geometry/formulas/flattening.hpp>
+#include <boost/geometry/formulas/result_inverse.hpp>
+
+
+namespace boost { namespace geometry { namespace formula
+{
+
+/*!
+\brief The solution of the inverse problem of geodesics on latlong coordinates,
+       Forsyth-Andoyer-Lambert type approximation with second order terms.
+\author See
+    - Technical Report: PAUL D. THOMAS, MATHEMATICAL MODELS FOR NAVIGATION SYSTEMS, 1965
+      http://www.dtic.mil/docs/citations/AD0627893
+    - Technical Report: PAUL D. THOMAS, SPHEROIDAL GEODESICS, REFERENCE SYSTEMS, AND LOCAL GEOMETRY, 1970
+      http://www.dtic.mil/docs/citations/AD0703541
+*/
+template <
+    typename CT,
+    bool EnableDistance,
+    bool EnableAzimuth,
+    bool EnableReverseAzimuth = false,
+    bool EnableReducedLength = false,
+    bool EnableGeodesicScale = false
+>
+class thomas_inverse
+{
+    static const bool CalcQuantities = EnableReducedLength || EnableGeodesicScale;
+    static const bool CalcAzimuths = EnableAzimuth || EnableReverseAzimuth || CalcQuantities;
+    static const bool CalcFwdAzimuth = EnableAzimuth || CalcQuantities;
+    static const bool CalcRevAzimuth = EnableReverseAzimuth || CalcQuantities;
+
+public:
+    typedef result_inverse<CT> result_type;
+
+    template <typename T1, typename T2, typename Spheroid>
+    static inline result_type apply(T1 const& lon1,
+                                    T1 const& lat1,
+                                    T2 const& lon2,
+                                    T2 const& lat2,
+                                    Spheroid const& spheroid)
+    {
+        result_type result;
+
+        // coordinates in radians
+
+        if ( math::equals(lon1, lon2) && math::equals(lat1, lat2) )
+        {
+            return result;
+        }
+
+        CT const c0 = 0;
+        CT const c1 = 1;
+        CT const c2 = 2;
+        CT const c4 = 4;
+
+        CT const pi_half = math::pi<CT>() / c2;
+        CT const f = formula::flattening<CT>(spheroid);
+        CT const one_minus_f = c1 - f;
+
+//        CT const tan_theta1 = one_minus_f * tan(lat1);
+//        CT const tan_theta2 = one_minus_f * tan(lat2);
+//        CT const theta1 = atan(tan_theta1);
+//        CT const theta2 = atan(tan_theta2);
+
+        CT const theta1 = math::equals(lat1, pi_half) ? lat1 :
+                          math::equals(lat1, -pi_half) ? lat1 :
+                          atan(one_minus_f * tan(lat1));
+        CT const theta2 = math::equals(lat2, pi_half) ? lat2 :
+                          math::equals(lat2, -pi_half) ? lat2 :
+                          atan(one_minus_f * tan(lat2));
+
+        CT const theta_m = (theta1 + theta2) / c2;
+        CT const d_theta_m = (theta2 - theta1) / c2;
+        CT const d_lambda = lon2 - lon1;
+        CT const d_lambda_m = d_lambda / c2;
+
+        CT const sin_theta_m = sin(theta_m);
+        CT const cos_theta_m = cos(theta_m);
+        CT const sin_d_theta_m = sin(d_theta_m);
+        CT const cos_d_theta_m = cos(d_theta_m);
+        CT const sin2_theta_m = math::sqr(sin_theta_m);
+        CT const cos2_theta_m = math::sqr(cos_theta_m);
+        CT const sin2_d_theta_m = math::sqr(sin_d_theta_m);
+        CT const cos2_d_theta_m = math::sqr(cos_d_theta_m);
+        CT const sin_d_lambda_m = sin(d_lambda_m);
+        CT const sin2_d_lambda_m = math::sqr(sin_d_lambda_m);
+
+        CT const H = cos2_theta_m - sin2_d_theta_m;
+        CT const L = sin2_d_theta_m + H * sin2_d_lambda_m;
+        CT const cos_d = c1 - c2 * L;
+        CT const d = acos(cos_d);
+        CT const sin_d = sin(d);
+
+        CT const one_minus_L = c1 - L;
+
+        if ( math::equals(sin_d, c0)
+          || math::equals(L, c0)
+          || math::equals(one_minus_L, c0) )
+        {
+            return result;
+        }
+
+        CT const U = c2 * sin2_theta_m * cos2_d_theta_m / one_minus_L;
+        CT const V = c2 * sin2_d_theta_m * cos2_theta_m / L;
+        CT const X = U + V;
+        CT const Y = U - V;
+        CT const T = d / sin_d;
+        CT const D = c4 * math::sqr(T);
+        CT const E = c2 * cos_d;
+        CT const A = D * E;
+        CT const B = c2 * D;
+        CT const C = T - (A - E) / c2;
+
+        CT const f_sqr = math::sqr(f);
+        CT const f_sqr_per_64 = f_sqr / CT(64);
+    
+        if ( BOOST_GEOMETRY_CONDITION(EnableDistance) )
+        {
+            CT const n1 = X * (A + C*X);
+            CT const n2 = Y * (B + E*Y);
+            CT const n3 = D*X*Y;
+
+            CT const delta1d = f * (T*X-Y) / c4;
+            CT const delta2d = f_sqr_per_64 * (n1 - n2 + n3);
+
+            CT const a = get_radius<0>(spheroid);
+
+            //result.distance = a * sin_d * (T - delta1d);
+            result.distance = a * sin_d * (T - delta1d + delta2d);
+        }
+    
+        if ( BOOST_GEOMETRY_CONDITION(CalcAzimuths) )
+        {
+            // NOTE: if both cos_latX == 0 then below we'd have 0 * INF
+            // it's a situation when the endpoints are on the poles +-90 deg
+            // in this case the azimuth could either be 0 or +-pi
+            // but above always 0 is returned
+
+            CT const F = c2*Y-E*(c4-X);
+            CT const M = CT(32)*T-(CT(20)*T-A)*X-(B+c4)*Y;
+            CT const G = f*T/c2 + f_sqr_per_64 * M;
+            
+            // TODO:
+            // If d_lambda is close to 90 or -90 deg then tan(d_lambda) is big
+            // and F is small. The result is not accurate.
+            // In the edge case the result may be 2 orders of magnitude less
+            // accurate than Andoyer's.
+            CT const tan_d_lambda = tan(d_lambda);
+            CT const Q = -(F*G*tan_d_lambda) / c4;
+            CT const d_lambda_m_p = (d_lambda + Q) / c2;
+            CT const tan_d_lambda_m_p = tan(d_lambda_m_p);
+
+            CT const v = atan2(cos_d_theta_m, sin_theta_m * tan_d_lambda_m_p);
+            CT const u = atan2(-sin_d_theta_m, cos_theta_m * tan_d_lambda_m_p);
+
+            CT const pi = math::pi<CT>();
+
+            if (BOOST_GEOMETRY_CONDITION(EnableAzimuth))
+            {
+                CT alpha1 = v + u;
+                if (alpha1 > pi)
+                {
+                    alpha1 -= c2 * pi;
+                }
+
+                result.azimuth = alpha1;
+            }
+
+            if (BOOST_GEOMETRY_CONDITION(EnableReverseAzimuth))
+            {
+                CT alpha2 = pi - (v - u);
+                if (alpha2 > pi)
+                {
+                    alpha2 -= c2 * pi;
+                }
+
+                result.reverse_azimuth = alpha2;
+            }
+        }
+
+        if (BOOST_GEOMETRY_CONDITION(CalcQuantities))
+        {
+            typedef differential_quantities<CT, EnableReducedLength, EnableGeodesicScale, 2> quantities;
+            quantities::apply(lon1, lat1, lon2, lat2,
+                              result.azimuth, result.reverse_azimuth,
+                              get_radius<2>(spheroid), f,
+                              result.reduced_length, result.geodesic_scale);
+        }
+
+        return result;
+    }
+};
+
+}}} // namespace boost::geometry::formula
+
+
+#endif // BOOST_GEOMETRY_FORMULAS_THOMAS_INVERSE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/formulas/vertex_latitude.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/vertex_latitude.hpp
new file mode 100644
index 00000000000..755067b08d5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/vertex_latitude.hpp
@@ -0,0 +1,148 @@
+// Boost.Geometry
+
+// Copyright (c) 2016-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_FORMULAS_MAXIMUM_LATITUDE_HPP
+#define BOOST_GEOMETRY_FORMULAS_MAXIMUM_LATITUDE_HPP
+
+#include <boost/geometry/core/srs.hpp>
+#include <boost/geometry/formulas/flattening.hpp>
+#include <boost/geometry/formulas/spherical.hpp>
+#include <boost/mpl/assert.hpp>
+
+namespace boost { namespace geometry { namespace formula
+{
+
+/*!
+\brief Algorithm to compute the vertex latitude of a geodesic segment. Vertex is
+a point on the geodesic that maximizes (or minimizes) the latitude.
+\author See
+    [Wood96] Wood - Vertex Latitudes on Ellipsoid Geodesics, SIAM Rev., 38(4),
+             637–644, 1996
+*/
+
+template <typename CT>
+class vertex_latitude_on_sphere
+{
+
+public:
+    template<typename T1, typename T2>
+    static inline CT apply(T1 const& lat1,
+                           T2 const& alp1)
+    {
+        return std::acos( math::abs(cos(lat1) * sin(alp1)) );
+    }
+};
+
+template <typename CT>
+class vertex_latitude_on_spheroid
+{
+
+public:
+/*
+ * formula based on paper
+ *   [Wood96] Wood - Vertex Latitudes on Ellipsoid Geodesics, SIAM Rev., 38(4),
+ *            637–644, 1996
+    template <typename T1, typename T2, typename Spheroid>
+    static inline CT apply(T1 const& lat1,
+                           T2 const& alp1,
+                           Spheroid const& spheroid)
+    {
+        CT const f = formula::flattening<CT>(spheroid);
+
+        CT const e2 = f * (CT(2) - f);
+        CT const sin_alp1 = sin(alp1);
+        CT const sin2_lat1 = math::sqr(sin(lat1));
+        CT const cos2_lat1 = CT(1) - sin2_lat1;
+
+        CT const e2_sin2 = CT(1) - e2 * sin2_lat1;
+        CT const cos2_sin2 = cos2_lat1 * math::sqr(sin_alp1);
+        CT const vertex_lat = std::asin( math::sqrt((e2_sin2 - cos2_sin2)
+                                                    / (e2_sin2 - e2 * cos2_sin2)));
+        return vertex_lat;
+    }
+*/
+
+    // simpler formula based on Clairaut relation for spheroids
+    template <typename T1, typename T2, typename Spheroid>
+    static inline CT apply(T1 const& lat1,
+                           T2 const& alp1,
+                           Spheroid const& spheroid)
+    {
+        CT const f = formula::flattening<CT>(spheroid);
+
+        CT const one_minus_f = (CT(1) - f);
+
+        //get the reduced latitude
+        CT const bet1 = atan( one_minus_f * tan(lat1) );
+
+        //apply Clairaut relation
+        CT const betv =  vertex_latitude_on_sphere<CT>::apply(bet1, alp1);
+
+        //return the spheroid latitude
+        return atan( tan(betv) / one_minus_f );
+    }
+
+    /*
+    template <typename T>
+    inline static void sign_adjustment(CT lat1, CT lat2, CT vertex_lat, T& vrt_result)
+    {
+        // signbit returns a non-zero value (true) if the sign is negative;
+        // and zero (false) otherwise.
+        bool sign = std::signbit(std::abs(lat1) > std::abs(lat2) ? lat1 : lat2);
+
+        vrt_result.north = sign ? std::max(lat1, lat2) : vertex_lat;
+        vrt_result.south = sign ? vertex_lat * CT(-1) : std::min(lat1, lat2);
+    }
+
+    template <typename T>
+    inline static bool vertex_on_segment(CT alp1, CT alp2, CT lat1, CT lat2, T& vrt_result)
+    {
+        CT const half_pi = math::pi<CT>() / CT(2);
+
+        // if the segment does not contain the vertex of the geodesic
+        // then return the endpoint of max (min) latitude
+        if ((alp1 < half_pi && alp2 < half_pi)
+                || (alp1 > half_pi && alp2 > half_pi))
+        {
+            vrt_result.north = std::max(lat1, lat2);
+            vrt_result.south = std::min(lat1, lat2);
+            return false;
+        }
+        return true;
+    }
+    */
+};
+
+
+template <typename CT, typename CS_Tag>
+struct vertex_latitude
+{
+    BOOST_MPL_ASSERT_MSG
+         (
+             false, NOT_IMPLEMENTED_FOR_THIS_COORDINATE_SYSTEM, (types<CS_Tag>)
+         );
+
+};
+
+template <typename CT>
+struct vertex_latitude<CT, spherical_equatorial_tag>
+        : vertex_latitude_on_sphere<CT>
+{};
+
+template <typename CT>
+struct vertex_latitude<CT, geographic_tag>
+        : vertex_latitude_on_spheroid<CT>
+{};
+
+
+}}} // namespace boost::geometry::formula
+
+#endif // BOOST_GEOMETRY_FORMULAS_MAXIMUM_LATITUDE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/formulas/vertex_longitude.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/vertex_longitude.hpp
new file mode 100644
index 00000000000..00f2fd4e7ae
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/vertex_longitude.hpp
@@ -0,0 +1,339 @@
+// Boost.Geometry
+
+// Copyright (c) 2016-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_FORMULAS_MAXIMUM_LONGITUDE_HPP
+#define BOOST_GEOMETRY_FORMULAS_MAXIMUM_LONGITUDE_HPP
+
+#include <boost/geometry/formulas/spherical.hpp>
+#include <boost/geometry/formulas/flattening.hpp>
+#include <boost/geometry/core/srs.hpp>
+#include <boost/mpl/assert.hpp>
+
+#include <boost/math/special_functions/hypot.hpp>
+
+namespace boost { namespace geometry { namespace formula
+{
+
+/*!
+\brief Algorithm to compute the vertex longitude of a geodesic segment. Vertex is
+a point on the geodesic that maximizes (or minimizes) the latitude. The algorithm
+is given the vertex latitude.
+*/
+
+//Classes for spesific CS
+
+template <typename CT>
+class vertex_longitude_on_sphere
+{
+
+public:
+
+    template <typename T>
+    static inline CT apply(T const& lat1, //segment point 1
+                           T const& lat2, //segment point 2
+                           T const& lat3, //vertex latitude
+                           T const& sin_l12,
+                           T const& cos_l12) //lon1 -lon2
+    {
+        //https://en.wikipedia.org/wiki/Great-circle_navigation#Finding_way-points
+        CT const A = sin(lat1) * cos(lat2) * cos(lat3) * sin_l12;
+        CT const B = sin(lat1) * cos(lat2) * cos(lat3) * cos_l12
+                - cos(lat1) * sin(lat2) * cos(lat3);
+        CT lon = atan2(B, A);
+        return lon + math::pi<CT>();
+    }
+};
+
+template <typename CT>
+class vertex_longitude_on_spheroid
+{
+    template<typename T>
+    static inline void normalize(T& x, T& y)
+    {
+        T h = boost::math::hypot(x, y);
+        x /= h;
+        y /= h;
+    }
+
+public:
+
+    template <typename T, typename Spheroid>
+    static inline CT apply(T const& lat1, //segment point 1
+                           T const& lat2, //segment point 2
+                           T const& lat3, //vertex latitude
+                           T& alp1,
+                           Spheroid const& spheroid)
+    {
+        // We assume that segment points lay on different side w.r.t.
+        // the vertex
+
+        // Constants
+        CT const c0 = 0;
+        CT const c2 = 2;
+        CT const half_pi = math::pi<CT>() / c2;
+        if (math::equals(lat1, half_pi)
+                || math::equals(lat2, half_pi)
+                || math::equals(lat1, -half_pi)
+                || math::equals(lat2, -half_pi))
+        {
+            // one segment point is the pole
+            return c0;
+        }
+
+        // More constants
+        CT const f = flattening<CT>(spheroid);
+        CT const pi = math::pi<CT>();
+        CT const c1 = 1;
+        CT const cminus1 = -1;
+
+        // First, compute longitude on auxiliary sphere
+
+        CT const one_minus_f = c1 - f;
+        CT const bet1 = atan(one_minus_f * tan(lat1));
+        CT const bet2 = atan(one_minus_f * tan(lat2));
+        CT const bet3 = atan(one_minus_f * tan(lat3));
+
+        CT cos_bet1 = cos(bet1);
+        CT cos_bet2 = cos(bet2);
+        CT const sin_bet1 = sin(bet1);
+        CT const sin_bet2 = sin(bet2);
+        CT const sin_bet3 = sin(bet3);
+
+        CT omg12 = 0;
+
+        if (bet1 < c0)
+        {
+            cos_bet1 *= cminus1;
+            omg12 += pi;
+        }
+        if (bet2 < c0)
+        {
+            cos_bet2 *= cminus1;
+            omg12 += pi;
+        }
+
+        CT const sin_alp1 = sin(alp1);
+        CT const cos_alp1 = math::sqrt(c1 - math::sqr(sin_alp1));
+
+        CT const norm = math::sqrt(math::sqr(cos_alp1) + math::sqr(sin_alp1 * sin_bet1));
+        CT const sin_alp0 = sin(atan2(sin_alp1 * cos_bet1, norm));
+
+        BOOST_ASSERT(cos_bet2 != c0);
+        CT const sin_alp2 = sin_alp1 * cos_bet1 / cos_bet2;
+
+        CT const cos_alp0 = math::sqrt(c1 - math::sqr(sin_alp0));
+        CT const cos_alp2 = math::sqrt(c1 - math::sqr(sin_alp2));
+
+        CT const sig1 = atan2(sin_bet1, cos_alp1 * cos_bet1);
+        CT const sig2 = atan2(sin_bet2, -cos_alp2 * cos_bet2); //lat3 is a vertex
+
+        CT const cos_sig1 = cos(sig1);
+        CT const sin_sig1 = math::sqrt(c1 - math::sqr(cos_sig1));
+
+        CT const cos_sig2 = cos(sig2);
+        CT const sin_sig2 = math::sqrt(c1 - math::sqr(cos_sig2));
+
+        CT const omg1 = atan2(sin_alp0 * sin_sig1, cos_sig1);
+        CT const omg2 = atan2(sin_alp0 * sin_sig2, cos_sig2);
+
+        omg12 += omg1 - omg2;
+
+        CT const sin_omg12 = sin(omg12);
+        CT const cos_omg12 = cos(omg12);
+
+        CT omg13 = geometry::formula::vertex_longitude_on_sphere<CT>
+                ::apply(bet1, bet2, bet3, sin_omg12, cos_omg12);
+
+        if (lat1 * lat2 < c0)//different hemispheres
+        {
+            if ((lat2 - lat1) * lat3  > c0)// ascending segment
+            {
+                omg13 = pi - omg13;
+            }
+        }
+
+        // Second, compute the ellipsoidal longitude
+
+        CT const e2 = f * (c2 - f);
+        CT const ep = math::sqrt(e2 / (c1 - e2));
+        CT const k2 = math::sqr(ep * cos_alp0);
+        CT const sqrt_k2_plus_one = math::sqrt(c1 + k2);
+        CT const eps = (sqrt_k2_plus_one - c1) / (sqrt_k2_plus_one + c1);
+        CT const eps2 = eps * eps;
+        CT const n = f / (c2 - f);
+
+        // sig3 is the length from equator to the vertex
+        CT sig3;
+        if(sin_bet3 > c0)
+        {
+            sig3 = half_pi;
+        } else {
+            sig3 = -half_pi;
+        }
+        CT const cos_sig3 = 0;
+        CT const sin_sig3 = 1;
+
+        CT sig13 = sig3 - sig1;
+        if (sig13 > pi)
+        {
+            sig13 -= 2 * pi;
+        }
+
+        // Order 2 approximation
+        CT const c1over2 = 0.5;
+        CT const c1over4 = 0.25;
+        CT const c1over8 = 0.125;
+        CT const c1over16 = 0.0625;
+        CT const c4 = 4;
+        CT const c8 = 8;
+
+        CT const A3 = 1 - (c1over2 - c1over2 * n) * eps - c1over4 * eps2;
+        CT const C31 = (c1over4 - c1over4 * n) * eps + c1over8 * eps2;
+        CT const C32 = c1over16 * eps2;
+
+        CT const sin2_sig3 = c2 * cos_sig3 * sin_sig3;
+        CT const sin4_sig3 = sin_sig3 * (-c4 * cos_sig3
+                                         + c8 * cos_sig3 * cos_sig3 * cos_sig3);
+        CT const sin2_sig1 = c2 * cos_sig1 * sin_sig1;
+        CT const sin4_sig1 = sin_sig1 * (-c4 * cos_sig1
+                                         + c8 * cos_sig1 * cos_sig1 * cos_sig1);
+        CT const I3 = A3 * (sig13
+                            + C31 * (sin2_sig3 - sin2_sig1)
+                            + C32 * (sin4_sig3 - sin4_sig1));
+
+        int sign = c1;
+        if (bet3 < c0)
+        {
+            sign = cminus1;
+        }
+
+        CT const dlon_max = omg13 - sign * f * sin_alp0 * I3;
+
+        return dlon_max;
+    }
+};
+
+//CS_tag dispatching
+
+template <typename CT, typename CS_Tag>
+struct compute_vertex_lon
+{
+    BOOST_MPL_ASSERT_MSG
+    (
+        false, NOT_IMPLEMENTED_FOR_THIS_COORDINATE_SYSTEM, (types<CS_Tag>)
+    );
+
+};
+
+template <typename CT>
+struct compute_vertex_lon<CT, spherical_equatorial_tag>
+{
+    template <typename Strategy>
+    static inline CT apply(CT const& lat1,
+                           CT const& lat2,
+                           CT const& vertex_lat,
+                           CT const& sin_l12,
+                           CT const& cos_l12,
+                           CT,
+                           Strategy)
+    {
+        return vertex_longitude_on_sphere<CT>
+                ::apply(lat1,
+                        lat2,
+                        vertex_lat,
+                        sin_l12,
+                        cos_l12);
+    }
+};
+
+template <typename CT>
+struct compute_vertex_lon<CT, geographic_tag>
+{
+    template <typename Strategy>
+    static inline CT apply(CT const& lat1,
+                           CT const& lat2,
+                           CT const& vertex_lat,
+                           CT,
+                           CT,
+                           CT& alp1,
+                           Strategy const& azimuth_strategy)
+    {
+        return vertex_longitude_on_spheroid<CT>
+                ::apply(lat1,
+                        lat2,
+                        vertex_lat,
+                        alp1,
+                        azimuth_strategy.model());
+    }
+};
+
+// Vertex longitude interface
+// Assume that lon1 < lon2 and vertex_lat is the latitude of the vertex
+
+template <typename CT, typename CS_Tag>
+class vertex_longitude
+{
+public :
+    template <typename Strategy>
+    static inline CT apply(CT& lon1,
+                           CT& lat1,
+                           CT& lon2,
+                           CT& lat2,
+                           CT const& vertex_lat,
+                           CT& alp1,
+                           Strategy const& azimuth_strategy)
+    {
+        CT const c0 = 0;
+        CT pi = math::pi<CT>();
+
+        //Vertex is a segment's point
+        if (math::equals(vertex_lat, lat1))
+        {
+            return lon1;
+        }
+        if (math::equals(vertex_lat, lat2))
+        {
+            return lon2;
+        }
+
+        //Segment lay on meridian
+        if (math::equals(lon1, lon2))
+        {
+            return (std::max)(lat1, lat2);
+        }
+        BOOST_ASSERT(lon1 < lon2);
+
+        CT dlon = compute_vertex_lon<CT, CS_Tag>::apply(lat1, lat2,
+                                                        vertex_lat,
+                                                        sin(lon1 - lon2),
+                                                        cos(lon1 - lon2),
+                                                        alp1,
+                                                        azimuth_strategy);
+
+        CT vertex_lon = std::fmod(lon1 + dlon, 2 * pi);
+
+        if (vertex_lat < c0)
+        {
+            vertex_lon -= pi;
+        }
+
+        if (std::abs(lon1 - lon2) > pi)
+        {
+            vertex_lon -= pi;
+        }
+
+        return vertex_lon;
+    }
+};
+
+}}} // namespace boost::geometry::formula
+#endif // BOOST_GEOMETRY_FORMULAS_MAXIMUM_LONGITUDE_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/formulas/vincenty_direct.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/vincenty_direct.hpp
new file mode 100644
index 00000000000..1697e5fb635
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/vincenty_direct.hpp
@@ -0,0 +1,184 @@
+// Boost.Geometry
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014, 2016.
+// Modifications copyright (c) 2014-2016 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_FORMULAS_VINCENTY_DIRECT_HPP
+#define BOOST_GEOMETRY_FORMULAS_VINCENTY_DIRECT_HPP
+
+
+#include <boost/math/constants/constants.hpp>
+
+#include <boost/geometry/core/radius.hpp>
+#include <boost/geometry/core/srs.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/formulas/differential_quantities.hpp>
+#include <boost/geometry/formulas/flattening.hpp>
+#include <boost/geometry/formulas/result_direct.hpp>
+
+
+#ifndef BOOST_GEOMETRY_DETAIL_VINCENTY_MAX_STEPS
+#define BOOST_GEOMETRY_DETAIL_VINCENTY_MAX_STEPS 1000
+#endif
+
+
+namespace boost { namespace geometry { namespace formula
+{
+
+/*!
+\brief The solution of the direct problem of geodesics on latlong coordinates, after Vincenty, 1975
+\author See
+    - http://www.ngs.noaa.gov/PUBS_LIB/inverse.pdf
+    - http://www.icsm.gov.au/gda/gdav2.3.pdf
+\author Adapted from various implementations to get it close to the original document
+    - http://www.movable-type.co.uk/scripts/LatLongVincenty.html
+    - http://exogen.case.edu/projects/geopy/source/geopy.distance.html
+    - http://futureboy.homeip.net/fsp/colorize.fsp?fileName=navigation.frink
+
+*/
+template <
+    typename CT,
+    bool EnableCoordinates = true,
+    bool EnableReverseAzimuth = false,
+    bool EnableReducedLength = false,
+    bool EnableGeodesicScale = false
+>
+class vincenty_direct
+{
+    static const bool CalcQuantities = EnableReducedLength || EnableGeodesicScale;
+    static const bool CalcCoordinates = EnableCoordinates || CalcQuantities;
+    static const bool CalcRevAzimuth = EnableReverseAzimuth || CalcQuantities;
+
+public:
+    typedef result_direct<CT> result_type;
+
+    template <typename T, typename Dist, typename Azi, typename Spheroid>
+    static inline result_type apply(T const& lo1,
+                                    T const& la1,
+                                    Dist const& distance,
+                                    Azi const& azimuth12,
+                                    Spheroid const& spheroid)
+    {
+        result_type result;
+
+        CT const lon1 = lo1;
+        CT const lat1 = la1;
+
+        if ( math::equals(distance, Dist(0)) || distance < Dist(0) )
+        {
+            result.lon2 = lon1;
+            result.lat2 = lat1;
+            return result;
+        }
+
+        CT const radius_a = CT(get_radius<0>(spheroid));
+        CT const radius_b = CT(get_radius<2>(spheroid));
+        CT const flattening = formula::flattening<CT>(spheroid);
+
+        CT const sin_azimuth12 = sin(azimuth12);
+        CT const cos_azimuth12 = cos(azimuth12);
+
+        // U: reduced latitude, defined by tan U = (1-f) tan phi
+        CT const one_min_f = CT(1) - flattening;
+        CT const tan_U1 = one_min_f * tan(lat1);
+        CT const sigma1 = atan2(tan_U1, cos_azimuth12); // (1)
+
+        // may be calculated from tan using 1 sqrt()
+        CT const U1 = atan(tan_U1);
+        CT const sin_U1 = sin(U1);
+        CT const cos_U1 = cos(U1);
+
+        CT const sin_alpha = cos_U1 * sin_azimuth12; // (2)
+        CT const sin_alpha_sqr = math::sqr(sin_alpha);
+        CT const cos_alpha_sqr = CT(1) - sin_alpha_sqr;
+
+        CT const b_sqr = radius_b * radius_b;
+        CT const u_sqr = cos_alpha_sqr * (radius_a * radius_a - b_sqr) / b_sqr;
+        CT const A = CT(1) + (u_sqr/CT(16384)) * (CT(4096) + u_sqr*(CT(-768) + u_sqr*(CT(320) - u_sqr*CT(175)))); // (3)
+        CT const B = (u_sqr/CT(1024))*(CT(256) + u_sqr*(CT(-128) + u_sqr*(CT(74) - u_sqr*CT(47)))); // (4)
+
+        CT s_div_bA = distance / (radius_b * A);
+        CT sigma = s_div_bA; // (7)
+
+        CT previous_sigma;
+        CT sin_sigma;
+        CT cos_sigma;
+        CT cos_2sigma_m;
+        CT cos_2sigma_m_sqr;
+
+        int counter = 0; // robustness
+
+        do
+        {
+            previous_sigma = sigma;
+
+            CT const two_sigma_m = CT(2) * sigma1 + sigma; // (5)
+
+            sin_sigma = sin(sigma);
+            cos_sigma = cos(sigma);
+            CT const sin_sigma_sqr = math::sqr(sin_sigma);
+            cos_2sigma_m = cos(two_sigma_m);
+            cos_2sigma_m_sqr = math::sqr(cos_2sigma_m);
+
+            CT const delta_sigma = B * sin_sigma * (cos_2sigma_m
+                                        + (B/CT(4)) * ( cos_sigma * (CT(-1) + CT(2)*cos_2sigma_m_sqr)
+                                            - (B/CT(6) * cos_2sigma_m * (CT(-3)+CT(4)*sin_sigma_sqr) * (CT(-3)+CT(4)*cos_2sigma_m_sqr)) )); // (6)
+
+            sigma = s_div_bA + delta_sigma; // (7)
+
+            ++counter; // robustness
+
+        } while ( geometry::math::abs(previous_sigma - sigma) > CT(1e-12)
+               //&& geometry::math::abs(sigma) < pi
+               && counter < BOOST_GEOMETRY_DETAIL_VINCENTY_MAX_STEPS ); // robustness
+
+        if (BOOST_GEOMETRY_CONDITION(CalcCoordinates))
+        {
+            result.lat2
+                = atan2( sin_U1 * cos_sigma + cos_U1 * sin_sigma * cos_azimuth12,
+                         one_min_f * math::sqrt(sin_alpha_sqr + math::sqr(sin_U1 * sin_sigma - cos_U1 * cos_sigma * cos_azimuth12))); // (8)
+            
+            CT const lambda = atan2( sin_sigma * sin_azimuth12,
+                                     cos_U1 * cos_sigma - sin_U1 * sin_sigma * cos_azimuth12); // (9)
+            CT const C = (flattening/CT(16)) * cos_alpha_sqr * ( CT(4) + flattening * ( CT(4) - CT(3) * cos_alpha_sqr ) ); // (10)
+            CT const L = lambda - (CT(1) - C) * flattening * sin_alpha
+                            * ( sigma + C * sin_sigma * ( cos_2sigma_m + C * cos_sigma * ( CT(-1) + CT(2) * cos_2sigma_m_sqr ) ) ); // (11)
+
+            result.lon2 = lon1 + L;
+        }
+
+        if (BOOST_GEOMETRY_CONDITION(CalcRevAzimuth))
+        {
+            result.reverse_azimuth
+                = atan2(sin_alpha, -sin_U1 * sin_sigma + cos_U1 * cos_sigma * cos_azimuth12); // (12)
+        }
+
+        if (BOOST_GEOMETRY_CONDITION(CalcQuantities))
+        {
+            typedef differential_quantities<CT, EnableReducedLength, EnableGeodesicScale, 2> quantities;
+            quantities::apply(lon1, lat1, result.lon2, result.lat2,
+                              azimuth12, result.reverse_azimuth,
+                              radius_b, flattening,
+                              result.reduced_length, result.geodesic_scale);
+        }
+
+        return result;
+    }
+
+};
+
+}}} // namespace boost::geometry::formula
+
+
+#endif // BOOST_GEOMETRY_FORMULAS_VINCENTY_DIRECT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/formulas/vincenty_inverse.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/vincenty_inverse.hpp
new file mode 100644
index 00000000000..032e16e2915
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/formulas/vincenty_inverse.hpp
@@ -0,0 +1,224 @@
+// Boost.Geometry
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014, 2016, 2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_FORMULAS_VINCENTY_INVERSE_HPP
+#define BOOST_GEOMETRY_FORMULAS_VINCENTY_INVERSE_HPP
+
+
+#include <boost/math/constants/constants.hpp>
+
+#include <boost/geometry/core/radius.hpp>
+#include <boost/geometry/core/srs.hpp>
+
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/formulas/differential_quantities.hpp>
+#include <boost/geometry/formulas/flattening.hpp>
+#include <boost/geometry/formulas/result_inverse.hpp>
+
+
+#ifndef BOOST_GEOMETRY_DETAIL_VINCENTY_MAX_STEPS
+#define BOOST_GEOMETRY_DETAIL_VINCENTY_MAX_STEPS 1000
+#endif
+
+
+namespace boost { namespace geometry { namespace formula
+{
+
+/*!
+\brief The solution of the inverse problem of geodesics on latlong coordinates, after Vincenty, 1975
+\author See
+    - http://www.ngs.noaa.gov/PUBS_LIB/inverse.pdf
+    - http://www.icsm.gov.au/gda/gda-v_2.4.pdf
+\author Adapted from various implementations to get it close to the original document
+    - http://www.movable-type.co.uk/scripts/LatLongVincenty.html
+    - http://exogen.case.edu/projects/geopy/source/geopy.distance.html
+    - http://futureboy.homeip.net/fsp/colorize.fsp?fileName=navigation.frink
+
+*/
+template <
+    typename CT,
+    bool EnableDistance,
+    bool EnableAzimuth,
+    bool EnableReverseAzimuth = false,
+    bool EnableReducedLength = false,
+    bool EnableGeodesicScale = false
+>
+struct vincenty_inverse
+{
+    static const bool CalcQuantities = EnableReducedLength || EnableGeodesicScale;
+    static const bool CalcAzimuths = EnableAzimuth || EnableReverseAzimuth || CalcQuantities;
+    static const bool CalcFwdAzimuth = EnableAzimuth || CalcQuantities;
+    static const bool CalcRevAzimuth = EnableReverseAzimuth || CalcQuantities;
+
+public:
+    typedef result_inverse<CT> result_type;
+
+    template <typename T1, typename T2, typename Spheroid>
+    static inline result_type apply(T1 const& lon1,
+                                    T1 const& lat1,
+                                    T2 const& lon2,
+                                    T2 const& lat2,
+                                    Spheroid const& spheroid)
+    {
+        result_type result;
+
+        if (math::equals(lat1, lat2) && math::equals(lon1, lon2))
+        {
+            return result;
+        }
+
+        CT const c1 = 1;
+        CT const c2 = 2;
+        CT const c3 = 3;
+        CT const c4 = 4;
+        CT const c16 = 16;
+        CT const c_e_12 = CT(1e-12);
+
+        CT const pi = geometry::math::pi<CT>();
+        CT const two_pi = c2 * pi;
+
+        // lambda: difference in longitude on an auxiliary sphere
+        CT L = lon2 - lon1;
+        CT lambda = L;
+
+        if (L < -pi) L += two_pi;
+        if (L > pi) L -= two_pi;
+
+        CT const radius_a = CT(get_radius<0>(spheroid));
+        CT const radius_b = CT(get_radius<2>(spheroid));
+        CT const f = formula::flattening<CT>(spheroid);
+
+        // U: reduced latitude, defined by tan U = (1-f) tan phi
+        CT const one_min_f = c1 - f;
+        CT const tan_U1 = one_min_f * tan(lat1); // above (1)
+        CT const tan_U2 = one_min_f * tan(lat2); // above (1)
+
+        // calculate sin U and cos U using trigonometric identities
+        CT const temp_den_U1 = math::sqrt(c1 + math::sqr(tan_U1));
+        CT const temp_den_U2 = math::sqrt(c1 + math::sqr(tan_U2));
+        // cos = 1 / sqrt(1 + tan^2)
+        CT const cos_U1 = c1 / temp_den_U1;
+        CT const cos_U2 = c1 / temp_den_U2;
+        // sin = tan / sqrt(1 + tan^2)
+        // sin = tan * cos
+        CT const sin_U1 = tan_U1 * cos_U1;
+        CT const sin_U2 = tan_U2 * cos_U2;
+
+        // calculate sin U and cos U directly
+        //CT const U1 = atan(tan_U1);
+        //CT const U2 = atan(tan_U2);
+        //cos_U1 = cos(U1);
+        //cos_U2 = cos(U2);
+        //sin_U1 = tan_U1 * cos_U1; // sin(U1);
+        //sin_U2 = tan_U2 * cos_U2; // sin(U2);
+
+        CT previous_lambda;
+        CT sin_lambda;
+        CT cos_lambda;
+        CT sin_sigma;
+        CT sin_alpha;
+        CT cos2_alpha;
+        CT cos_2sigma_m;
+        CT cos2_2sigma_m;
+        CT sigma;
+
+        int counter = 0; // robustness
+
+        do
+        {
+            previous_lambda = lambda; // (13)
+            sin_lambda = sin(lambda);
+            cos_lambda = cos(lambda);
+            sin_sigma = math::sqrt(math::sqr(cos_U2 * sin_lambda) + math::sqr(cos_U1 * sin_U2 - sin_U1 * cos_U2 * cos_lambda)); // (14)
+            CT cos_sigma = sin_U1 * sin_U2 + cos_U1 * cos_U2 * cos_lambda; // (15)
+            sin_alpha = cos_U1 * cos_U2 * sin_lambda / sin_sigma; // (17)
+            cos2_alpha = c1 - math::sqr(sin_alpha);
+            cos_2sigma_m = math::equals(cos2_alpha, 0) ? 0 : cos_sigma - c2 * sin_U1 * sin_U2 / cos2_alpha; // (18)
+            cos2_2sigma_m = math::sqr(cos_2sigma_m);
+
+            CT C = f/c16 * cos2_alpha * (c4 + f * (c4 - c3 * cos2_alpha)); // (10)
+            sigma = atan2(sin_sigma, cos_sigma); // (16)
+            lambda = L + (c1 - C) * f * sin_alpha *
+                (sigma + C * sin_sigma * (cos_2sigma_m + C * cos_sigma * (-c1 + c2 * cos2_2sigma_m))); // (11)
+
+            ++counter; // robustness
+
+        } while ( geometry::math::abs(previous_lambda - lambda) > c_e_12
+               && geometry::math::abs(lambda) < pi
+               && counter < BOOST_GEOMETRY_DETAIL_VINCENTY_MAX_STEPS ); // robustness
+    
+        if ( BOOST_GEOMETRY_CONDITION(EnableDistance) )
+        {
+            // Oops getting hard here
+            // (again, problem is that ttmath cannot divide by doubles, which is OK)
+            CT const c1 = 1;
+            CT const c2 = 2;
+            CT const c3 = 3;
+            CT const c4 = 4;
+            CT const c6 = 6;
+            CT const c47 = 47;
+            CT const c74 = 74;
+            CT const c128 = 128;
+            CT const c256 = 256;
+            CT const c175 = 175;
+            CT const c320 = 320;
+            CT const c768 = 768;
+            CT const c1024 = 1024;
+            CT const c4096 = 4096;
+            CT const c16384 = 16384;
+
+            //CT sqr_u = cos2_alpha * (math::sqr(radius_a) - math::sqr(radius_b)) / math::sqr(radius_b); // above (1)
+            CT sqr_u = cos2_alpha * ( math::sqr(radius_a / radius_b) - c1 ); // above (1)
+
+            CT A = c1 + sqr_u/c16384 * (c4096 + sqr_u * (-c768 + sqr_u * (c320 - c175 * sqr_u))); // (3)
+            CT B = sqr_u/c1024 * (c256 + sqr_u * ( -c128 + sqr_u * (c74 - c47 * sqr_u))); // (4)
+            CT const cos_sigma = cos(sigma);
+            CT const sin2_sigma = math::sqr(sin_sigma);
+            CT delta_sigma = B * sin_sigma * (cos_2sigma_m + (B/c4) * (cos_sigma* (-c1 + c2 * cos2_2sigma_m)
+                - (B/c6) * cos_2sigma_m * (-c3 + c4 * sin2_sigma) * (-c3 + c4 * cos2_2sigma_m))); // (6)
+
+            result.distance = radius_b * A * (sigma - delta_sigma); // (19)
+        }
+    
+        if ( BOOST_GEOMETRY_CONDITION(CalcAzimuths) )
+        {
+            if (BOOST_GEOMETRY_CONDITION(CalcFwdAzimuth))
+            {
+                result.azimuth = atan2(cos_U2 * sin_lambda, cos_U1 * sin_U2 - sin_U1 * cos_U2 * cos_lambda); // (20)
+            }
+
+            if (BOOST_GEOMETRY_CONDITION(CalcRevAzimuth))
+            {
+                result.reverse_azimuth = atan2(cos_U1 * sin_lambda, -sin_U1 * cos_U2 + cos_U1 * sin_U2 * cos_lambda); // (21)
+            }
+        }
+
+        if (BOOST_GEOMETRY_CONDITION(CalcQuantities))
+        {
+            typedef differential_quantities<CT, EnableReducedLength, EnableGeodesicScale, 2> quantities;
+            quantities::apply(lon1, lat1, lon2, lat2,
+                              result.azimuth, result.reverse_azimuth,
+                              radius_b, f,
+                              result.reduced_length, result.geodesic_scale);
+        }
+
+        return result;
+    }
+};
+
+}}} // namespace boost::geometry::formula
+
+
+#endif // BOOST_GEOMETRY_FORMULAS_VINCENTY_INVERSE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_array.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_array.hpp
new file mode 100644
index 00000000000..275ccb5c2b7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_array.hpp
@@ -0,0 +1,120 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2010 Alfredo Correa
+// Copyright (c) 2010-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_ARRAY_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_ARRAY_HPP
+
+
+#ifdef BOOST_GEOMETRY_ADAPTED_BOOST_ARRAY_TAG_DEFINED
+#error Include either "boost_array_as_point" or \
+    "boost_array_as_linestring" or "boost_array_as_ring" \
+    or "boost_array_as_multi_point" to adapt a boost_array
+#endif
+
+#define BOOST_GEOMETRY_ADAPTED_BOOST_ARRAY_TAG_DEFINED
+
+
+#include <cstddef>
+
+#include <boost/type_traits/is_arithmetic.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/array.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+
+// Create class and specialization to indicate the tag
+// for normal cases and the case that the type of the c-array is arithmetic
+template <bool>
+struct boost_array_tag
+{
+    typedef geometry_not_recognized_tag type;
+};
+
+
+template <>
+struct boost_array_tag<true>
+{
+    typedef point_tag type;
+};
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+// Assign the point-tag, preventing arrays of points getting a point-tag
+template <typename CoordinateType, std::size_t DimensionCount>
+struct tag<boost::array<CoordinateType, DimensionCount> >
+    : detail::boost_array_tag<boost::is_arithmetic<CoordinateType>::value> {};
+
+
+template <typename CoordinateType, std::size_t DimensionCount>
+struct coordinate_type<boost::array<CoordinateType, DimensionCount> >
+{
+    typedef CoordinateType type;
+};
+
+
+template <typename CoordinateType, std::size_t DimensionCount>
+struct dimension<boost::array<CoordinateType, DimensionCount> >: boost::mpl::int_<DimensionCount> {};
+
+
+template <typename CoordinateType, std::size_t DimensionCount, std::size_t Dimension>
+struct access<boost::array<CoordinateType, DimensionCount>, Dimension>
+{
+    static inline CoordinateType get(boost::array<CoordinateType, DimensionCount> const& a)
+    {
+        return a[Dimension];
+    }
+
+    static inline void set(boost::array<CoordinateType, DimensionCount>& a,
+        CoordinateType const& value)
+    {
+        a[Dimension] = value;
+    }
+};
+
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+
+}} // namespace boost::geometry
+
+
+#define BOOST_GEOMETRY_REGISTER_BOOST_ARRAY_CS(CoordinateSystem) \
+    namespace boost { namespace geometry { namespace traits { \
+    template <class T, std::size_t N> \
+    struct coordinate_system<boost::array<T, N> > \
+    { \
+        typedef CoordinateSystem type; \
+    }; \
+    }}}
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_ARRAY_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_fusion.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_fusion.hpp
new file mode 100644
index 00000000000..2f3594e4e70
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_fusion.hpp
@@ -0,0 +1,178 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2011-2015 Akira Takahashi
+// Copyright (c) 2011-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_ADAPTED_FUSION_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_FUSION_HPP
+
+
+#include <cstddef>
+
+#include <boost/core/enable_if.hpp>
+
+#include <boost/fusion/include/is_sequence.hpp>
+#include <boost/fusion/include/size.hpp>
+#include <boost/fusion/include/tag_of.hpp>
+#include <boost/fusion/include/front.hpp>
+#include <boost/fusion/include/at.hpp>
+#include <boost/fusion/mpl.hpp>
+
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/count_if.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/placeholders.hpp>
+#include <boost/mpl/pop_front.hpp>
+#include <boost/mpl/size.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_system.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace fusion_adapt_detail
+{
+
+template <class Sequence>
+struct all_same :
+    boost::mpl::bool_<
+        boost::mpl::count_if<
+            Sequence,
+            boost::is_same<
+                typename boost::mpl::front<Sequence>::type,
+                boost::mpl::_
+            >
+        >::value == boost::mpl::size<Sequence>::value
+    >
+{};
+
+template <class Sequence>
+struct is_coordinate_size : boost::mpl::bool_<
+            boost::fusion::result_of::size<Sequence>::value == 2 ||
+            boost::fusion::result_of::size<Sequence>::value == 3> {};
+
+template<typename Sequence>
+struct is_fusion_sequence
+    : boost::mpl::and_<boost::fusion::traits::is_sequence<Sequence>,
+                fusion_adapt_detail::is_coordinate_size<Sequence>,
+                fusion_adapt_detail::all_same<Sequence> >
+{};
+
+
+} // namespace fusion_adapt_detail
+
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+// Boost Fusion Sequence, 2D or 3D
+template <typename Sequence>
+struct coordinate_type
+    <
+        Sequence,
+        typename boost::enable_if
+            <
+                fusion_adapt_detail::is_fusion_sequence<Sequence>
+            >::type
+    >
+{
+    typedef typename boost::mpl::front<Sequence>::type type;
+};
+
+
+template <typename Sequence>
+struct dimension
+    <
+        Sequence,
+        typename boost::enable_if
+            <
+                fusion_adapt_detail::is_fusion_sequence<Sequence>
+            >::type
+    > : boost::mpl::size<Sequence>
+{};
+
+
+template <typename Sequence, std::size_t Dimension>
+struct access
+    <
+        Sequence,
+        Dimension,
+        typename boost::enable_if
+            <
+                fusion_adapt_detail::is_fusion_sequence<Sequence>
+            >::type
+    >
+{
+    typedef typename coordinate_type<Sequence>::type ctype;
+
+    static inline ctype get(Sequence const& point)
+    {
+        return boost::fusion::at_c<Dimension>(point);
+    }
+
+    template <class CoordinateType>
+    static inline void set(Sequence& point, CoordinateType const& value)
+    {
+        boost::fusion::at_c<Dimension>(point) = value;
+    }
+};
+
+
+template <typename Sequence>
+struct tag
+    <
+        Sequence,
+        typename boost::enable_if
+            <
+                fusion_adapt_detail::is_fusion_sequence<Sequence>
+            >::type
+    >
+{
+    typedef point_tag type;
+};
+
+
+} // namespace traits
+
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+
+}} // namespace boost::geometry
+
+
+// Convenience registration macro to bind a Fusion sequence to a CS
+#define BOOST_GEOMETRY_REGISTER_BOOST_FUSION_CS(CoordinateSystem) \
+    namespace boost { namespace geometry { namespace traits { \
+    template <typename Sequence> \
+    struct coordinate_system \
+               < \
+                   Sequence, \
+                   typename boost::enable_if \
+                       < \
+                           fusion_adapt_detail::is_fusion_sequence<Sequence> \
+                       >::type \
+               > \
+    { typedef CoordinateSystem type; }; \
+    }}}
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_FUSION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon.hpp
new file mode 100644
index 00000000000..fed2362b6e1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon.hpp
@@ -0,0 +1,18 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2010-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_HPP
+
+#include <boost/geometry/geometries/adapted/boost_polygon/point.hpp>
+#include <boost/geometry/geometries/adapted/boost_polygon/box.hpp>
+#include <boost/geometry/geometries/adapted/boost_polygon/ring.hpp>
+#include <boost/geometry/geometries/adapted/boost_polygon/polygon.hpp>
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/box.hpp
new file mode 100644
index 00000000000..87c3b60650c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/box.hpp
@@ -0,0 +1,141 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2010-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_BOX_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_BOX_HPP
+
+// Adapts Geometries from Boost.Polygon for usage in Boost.Geometry
+// boost::polygon::rectangle_data -> boost::geometry::box
+
+
+#include <boost/polygon/polygon.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+
+template <typename CoordinateType>
+struct tag<boost::polygon::rectangle_data<CoordinateType> >
+{
+    typedef box_tag type;
+};
+
+
+template <typename CoordinateType>
+struct point_type<boost::polygon::rectangle_data<CoordinateType> >
+{
+    // Not sure what to do here. Boost.Polygon's rectangle does NOT define its
+    // point_type (but uses it...)
+    typedef boost::polygon::point_data<CoordinateType> type;
+};
+
+
+template <typename CoordinateType>
+struct indexed_access
+<
+    boost::polygon::rectangle_data<CoordinateType>,
+    min_corner, 0
+>
+{
+    typedef boost::polygon::rectangle_data<CoordinateType> box_type;
+
+    static inline CoordinateType get(box_type const& b)
+    {
+        return boost::polygon::xl(b);
+    }
+
+    static inline void set(box_type& b, CoordinateType const& value)
+    {
+        boost::polygon::xl(b, value);
+    }
+};
+
+
+template <typename CoordinateType>
+struct indexed_access
+<
+    boost::polygon::rectangle_data<CoordinateType>,
+    min_corner, 1
+>
+{
+    typedef boost::polygon::rectangle_data<CoordinateType> box_type;
+
+    static inline CoordinateType get(box_type const& b)
+    {
+        return boost::polygon::yl(b);
+    }
+
+    static inline void set(box_type& b, CoordinateType const& value)
+    {
+        boost::polygon::yl(b, value);
+    }
+};
+
+
+template <typename CoordinateType>
+struct indexed_access
+<
+    boost::polygon::rectangle_data<CoordinateType>,
+    max_corner, 0
+>
+{
+    typedef boost::polygon::rectangle_data<CoordinateType> box_type;
+
+    static inline CoordinateType get(box_type const& b)
+    {
+        return boost::polygon::xh(b);
+    }
+
+    static inline void set(box_type& b, CoordinateType const& value)
+    {
+        boost::polygon::xh(b, value);
+    }
+};
+
+
+template <typename CoordinateType>
+struct indexed_access
+<
+    boost::polygon::rectangle_data<CoordinateType>,
+    max_corner, 1
+>
+{
+    typedef boost::polygon::rectangle_data<CoordinateType> box_type;
+
+    static inline CoordinateType get(box_type const& b)
+    {
+        return boost::polygon::yh(b);
+    }
+
+    static inline void set(box_type& b, CoordinateType const& value)
+    {
+        boost::polygon::yh(b, value);
+    }
+};
+
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/hole_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/hole_iterator.hpp
new file mode 100644
index 00000000000..c9c1bc7b61d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/hole_iterator.hpp
@@ -0,0 +1,84 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2010-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_HOLE_ITERATOR_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_HOLE_ITERATOR_HPP
+
+// Adapts Geometries from Boost.Polygon for usage in Boost.Geometry
+// boost::polygon::polygon_with_holes_data -> boost::geometry::polygon
+//   hole_iterator  -> returning ring_proxy's instead of normal polygon_data
+
+#include <boost/polygon/polygon.hpp>
+
+#include <boost/iterator.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace adapt { namespace bp
+{
+
+
+template <typename Polygon, typename RingProxy>
+class hole_iterator
+    : public ::boost::iterator_facade
+        <
+            hole_iterator<Polygon, RingProxy>,
+            RingProxy, // value type
+            boost::forward_traversal_tag,
+            RingProxy // reference type
+        >
+{
+public :
+    typedef typename boost::polygon::polygon_with_holes_traits
+        <
+            Polygon
+        >::iterator_holes_type ith_type;
+
+    explicit inline hole_iterator(Polygon& polygon, ith_type const it)
+        : m_polygon(polygon)
+        , m_base(it)
+    {
+    }
+
+    typedef std::ptrdiff_t difference_type;
+
+private:
+    friend class boost::iterator_core_access;
+
+    inline RingProxy dereference() const
+    {
+        return RingProxy(m_polygon, this->m_base);
+    }
+
+    inline void increment() { ++m_base; }
+    inline void decrement() { --m_base; }
+    inline void advance(difference_type n)
+    {
+        for (int i = 0; i < n; i++)
+        {
+            ++m_base;
+        }
+    }
+
+    inline bool equal(hole_iterator<Polygon, RingProxy> const& other) const
+    {
+        return this->m_base == other.m_base;
+    }
+
+    Polygon& m_polygon;
+    ith_type m_base;
+};
+
+
+}}}}
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_HOLE_ITERATOR_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/holes_proxy.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/holes_proxy.hpp
new file mode 100644
index 00000000000..c2a6a44dba9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/holes_proxy.hpp
@@ -0,0 +1,204 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2010-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_HOLES_PROXY_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_HOLES_PROXY_HPP
+
+// Adapts Geometries from Boost.Polygon for usage in Boost.Geometry
+// boost::polygon::polygon_with_holes_data -> boost::geometry::polygon
+//   pair{begin_holes, begin_holes} -> interior_proxy
+
+#include <boost/polygon/polygon.hpp>
+
+#include <boost/geometry/geometries/adapted/boost_polygon/hole_iterator.hpp>
+#include <boost/geometry/geometries/adapted/boost_polygon/ring_proxy.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace adapt { namespace bp
+{
+
+
+// Polygon should implement the boost::polygon::polygon_with_holes_concept
+// Specify constness in the template parameter if necessary
+template<typename Polygon>
+struct holes_proxy
+{
+    typedef ring_proxy
+        <
+            typename boost::mpl::if_
+                <
+                    typename boost::is_const<Polygon>,
+                    Polygon const,
+                    Polygon
+                >::type
+        > proxy_type;
+    typedef hole_iterator<Polygon, proxy_type> iterator_type;
+
+    // The next line does not work probably because coordinate_type is part of the
+    // polygon_traits, but not of the polygon_with_holes_traits
+    // typedef typename boost::polygon::polygon_traits<Polygon>::coordinate_type coordinate_type;
+
+    // So we use:
+    typedef typename Polygon::coordinate_type coordinate_type;
+
+    inline holes_proxy(Polygon& p)
+        : polygon(p)
+    {}
+
+    inline void clear()
+    {
+        Polygon empty;
+        // Clear the holes
+        polygon.set_holes
+            (
+                boost::polygon::begin_holes(empty),
+                boost::polygon::end_holes(empty)
+            );
+    }
+
+    inline void resize(std::size_t new_size)
+    {
+        std::vector<boost::polygon::polygon_data<coordinate_type> > temporary_copy
+            (
+                boost::polygon::begin_holes(polygon),
+                boost::polygon::end_holes(polygon)
+            );
+        temporary_copy.resize(new_size);
+        polygon.set_holes(temporary_copy.begin(), temporary_copy.end());
+    }
+
+    template <typename Ring>
+    inline void push_back(Ring const& ring)
+    {
+        std::vector<boost::polygon::polygon_data<coordinate_type> > temporary_copy
+            (
+                boost::polygon::begin_holes(polygon),
+                boost::polygon::end_holes(polygon)
+            );
+        boost::polygon::polygon_data<coordinate_type> added;
+        boost::polygon::set_points(added, ring.begin(), ring.end());
+        temporary_copy.push_back(added);
+        polygon.set_holes(temporary_copy.begin(), temporary_copy.end());
+    }
+
+
+    Polygon& polygon;
+};
+
+
+// Support holes_proxy for Boost.Range ADP
+
+// Const versions
+template<typename Polygon>
+inline typename boost::geometry::adapt::bp::holes_proxy<Polygon const>::iterator_type
+            range_begin(boost::geometry::adapt::bp::holes_proxy<Polygon const> const& proxy)
+{
+    typename boost::geometry::adapt::bp::holes_proxy<Polygon const>::iterator_type
+            begin(proxy.polygon, boost::polygon::begin_holes(proxy.polygon));
+    return begin;
+}
+
+template<typename Polygon>
+inline typename boost::geometry::adapt::bp::holes_proxy<Polygon const>::iterator_type
+            range_end(boost::geometry::adapt::bp::holes_proxy<Polygon const> const& proxy)
+{
+    typename boost::geometry::adapt::bp::holes_proxy<Polygon const>::iterator_type
+            end(proxy.polygon, boost::polygon::end_holes(proxy.polygon));
+    return end;
+}
+
+// Mutable versions
+template<typename Polygon>
+inline typename boost::geometry::adapt::bp::holes_proxy<Polygon>::iterator_type
+            range_begin(boost::geometry::adapt::bp::holes_proxy<Polygon>& proxy)
+{
+    typename boost::geometry::adapt::bp::holes_proxy<Polygon>::iterator_type
+            begin(proxy.polygon, boost::polygon::begin_holes(proxy.polygon));
+    return begin;
+}
+
+template<typename Polygon>
+inline typename boost::geometry::adapt::bp::holes_proxy<Polygon>::iterator_type
+            range_end(boost::geometry::adapt::bp::holes_proxy<Polygon>& proxy)
+{
+    typename boost::geometry::adapt::bp::holes_proxy<Polygon>::iterator_type
+            end(proxy.polygon, boost::polygon::end_holes(proxy.polygon));
+    return end;
+}
+
+
+}}
+
+namespace traits
+{
+
+template <typename Polygon>
+struct rvalue_type<adapt::bp::holes_proxy<Polygon> >
+{
+    typedef adapt::bp::holes_proxy<Polygon> type;
+};
+
+
+template <typename Polygon>
+struct clear<adapt::bp::holes_proxy<Polygon> >
+{
+    static inline void apply(adapt::bp::holes_proxy<Polygon> proxy)
+    {
+        proxy.clear();
+    }
+};
+
+template <typename Polygon>
+struct resize<adapt::bp::holes_proxy<Polygon> >
+{
+    static inline void apply(adapt::bp::holes_proxy<Polygon> proxy, std::size_t new_size)
+    {
+        proxy.resize(new_size);
+    }
+};
+
+template <typename Polygon>
+struct push_back<adapt::bp::holes_proxy<Polygon> >
+{
+    template <typename Ring>
+    static inline void apply(adapt::bp::holes_proxy<Polygon> proxy, Ring const& ring)
+    {
+        proxy.push_back(ring);
+    }
+};
+
+
+
+} // namespace traits
+
+
+}}
+
+
+// Specialize holes_proxy for Boost.Range
+namespace boost
+{
+    template<typename Polygon>
+    struct range_mutable_iterator<geometry::adapt::bp::holes_proxy<Polygon> >
+    {
+        typedef typename geometry::adapt::bp::holes_proxy<Polygon>::iterator_type type;
+    };
+
+    template<typename Polygon>
+    struct range_const_iterator<geometry::adapt::bp::holes_proxy<Polygon> >
+    {
+        typedef typename geometry::adapt::bp::holes_proxy<Polygon const>::iterator_type type;
+    };
+
+} // namespace boost
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_HOLES_PROXY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/point.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/point.hpp
new file mode 100644
index 00000000000..2aabb5663c7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/point.hpp
@@ -0,0 +1,102 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2010-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_POINT_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_POINT_HPP
+
+// Adapts Geometries from Boost.Polygon for usage in Boost.Geometry
+// boost::polygon::point_data -> boost::geometry::point
+
+
+#include <boost/polygon/polygon.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+
+template <typename CoordinateType>
+struct tag<boost::polygon::point_data<CoordinateType> >
+{
+    typedef point_tag type;
+};
+
+
+template <typename CoordinateType>
+struct coordinate_type<boost::polygon::point_data<CoordinateType> >
+{
+    typedef CoordinateType type;
+};
+
+
+template <typename CoordinateType>
+struct coordinate_system<boost::polygon::point_data<CoordinateType> >
+{
+    typedef cs::cartesian type;
+};
+
+
+template <typename CoordinateType>
+struct dimension<boost::polygon::point_data<CoordinateType> >
+            : boost::mpl::int_<2>
+{};
+
+
+template <typename CoordinateType>
+struct access<boost::polygon::point_data<CoordinateType>, 0>
+{
+    typedef boost::polygon::point_data<CoordinateType> point_type;
+
+    static inline CoordinateType get(point_type const& p)
+    {
+        return p.x();
+    }
+
+    static inline void set(point_type& p, CoordinateType const& value)
+    {
+        p.x(value);
+    }
+};
+
+
+template <typename CoordinateType>
+struct access<boost::polygon::point_data<CoordinateType>, 1>
+{
+    typedef boost::polygon::point_data<CoordinateType> point_type;
+
+    static inline CoordinateType get(point_type const& p)
+    {
+        return p.y();
+    }
+
+    static inline void set(point_type& p, CoordinateType const& value)
+    {
+        p.y(value);
+    }
+};
+
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_POINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/polygon.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/polygon.hpp
new file mode 100644
index 00000000000..5703601e056
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/polygon.hpp
@@ -0,0 +1,111 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2010-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_POLYGON_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_POLYGON_HPP
+
+// Adapts Geometries from Boost.Polygon for usage in Boost.Geometry
+// boost::polygon::polygon_with_holes_data -> boost::geometry::polygon
+
+#include <boost/polygon/polygon.hpp>
+
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+
+#include <boost/geometry/geometries/adapted/boost_polygon/ring_proxy.hpp>
+#include <boost/geometry/geometries/adapted/boost_polygon/hole_iterator.hpp>
+#include <boost/geometry/geometries/adapted/boost_polygon/holes_proxy.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+template <typename CoordinateType>
+struct tag<boost::polygon::polygon_with_holes_data<CoordinateType> >
+{
+    typedef polygon_tag type;
+};
+
+template <typename CoordinateType>
+struct ring_const_type<boost::polygon::polygon_with_holes_data<CoordinateType> >
+{
+    typedef adapt::bp::ring_proxy<boost::polygon::polygon_with_holes_data<CoordinateType> const> type;
+};
+
+template <typename CoordinateType>
+struct ring_mutable_type<boost::polygon::polygon_with_holes_data<CoordinateType> >
+{
+    typedef adapt::bp::ring_proxy<boost::polygon::polygon_with_holes_data<CoordinateType> > type;
+};
+
+template <typename CoordinateType>
+struct interior_const_type<boost::polygon::polygon_with_holes_data<CoordinateType> >
+{
+    typedef adapt::bp::holes_proxy<boost::polygon::polygon_with_holes_data<CoordinateType> const> type;
+};
+
+template <typename CoordinateType>
+struct interior_mutable_type<boost::polygon::polygon_with_holes_data<CoordinateType> >
+{
+    typedef adapt::bp::holes_proxy<boost::polygon::polygon_with_holes_data<CoordinateType> > type;
+};
+
+
+template <typename CoordinateType>
+struct exterior_ring<boost::polygon::polygon_with_holes_data<CoordinateType> >
+{
+    typedef boost::polygon::polygon_with_holes_data<CoordinateType> polygon_type;
+    typedef adapt::bp::ring_proxy<polygon_type> proxy;
+    typedef adapt::bp::ring_proxy<polygon_type const> const_proxy;
+
+    static inline proxy get(polygon_type& p)
+    {
+        return proxy(p);
+    }
+
+    static inline const_proxy get(polygon_type const& p)
+    {
+        return const_proxy(p);
+    }
+};
+
+template <typename CoordinateType>
+struct interior_rings<boost::polygon::polygon_with_holes_data<CoordinateType> >
+{
+    typedef boost::polygon::polygon_with_holes_data<CoordinateType> polygon_type;
+    typedef adapt::bp::holes_proxy<polygon_type> proxy;
+    typedef adapt::bp::holes_proxy<polygon_type const> const_proxy;
+
+    static inline proxy get(polygon_type& p)
+    {
+        return proxy(p);
+    }
+
+    static inline const_proxy get(polygon_type const& p)
+    {
+        return const_proxy(p);
+    }
+};
+
+
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_POLYGON_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/ring.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/ring.hpp
new file mode 100644
index 00000000000..490fa45fe9a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/ring.hpp
@@ -0,0 +1,182 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2010-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_RING_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_RING_HPP
+
+// Adapts Geometries from Boost.Polygon for usage in Boost.Geometry
+// boost::polygon::polygon_data -> boost::geometry::ring
+
+#include <cstddef>
+#include <boost/polygon/polygon.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/mutable_range.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+namespace boost { namespace geometry
+{
+
+namespace traits
+{
+
+template <typename CoordinateType>
+struct tag<boost::polygon::polygon_data<CoordinateType> >
+{
+    typedef ring_tag type;
+};
+
+template <typename CoordinateType>
+struct clear<boost::polygon::polygon_data<CoordinateType> >
+{
+    static inline void apply(boost::polygon::polygon_data<CoordinateType>& data)
+    {
+        // There is no "clear" function but we can assign
+        // a newly (and therefore empty) constructed polygon
+        boost::polygon::assign(data, boost::polygon::polygon_data<CoordinateType>());
+    }
+};
+
+template <typename CoordinateType>
+struct push_back<boost::polygon::polygon_data<CoordinateType> >
+{
+    typedef boost::polygon::point_data<CoordinateType> point_type;
+
+    static inline void apply(boost::polygon::polygon_data<CoordinateType>& data,
+         point_type const& point)
+    {
+        // Boost.Polygon's polygons are not appendable. So create a temporary vector,
+        // add a record and set it to the original. Of course: this is not efficient.
+        // But there seems no other way (without using a wrapper)
+        std::vector<point_type> temporary_vector
+            (
+                boost::polygon::begin_points(data),
+                boost::polygon::end_points(data)
+            );
+        temporary_vector.push_back(point);
+        data.set(temporary_vector.begin(), temporary_vector.end());
+    }
+};
+
+template <typename CoordinateType>
+struct resize<boost::polygon::polygon_data<CoordinateType> >
+{
+    typedef boost::polygon::point_data<CoordinateType> point_type;
+
+    static inline void apply(boost::polygon::polygon_data<CoordinateType>& data,
+                             std::size_t new_size)
+    {
+        // Boost.Polygon's polygons are not resizable. So create a temporary vector,
+        // resize it and set it to the original. Of course: this is not efficient.
+        // But there seems no other way (without using a wrapper)
+        std::vector<point_type> temporary_vector
+            (
+                boost::polygon::begin_points(data),
+                boost::polygon::end_points(data)
+            );
+        temporary_vector.resize(new_size);
+        data.set(temporary_vector.begin(), temporary_vector.end());
+    }
+};
+
+
+} // namespace traits
+
+}} // namespace boost::geometry
+
+
+// Adapt Boost.Polygon's polygon_data to Boost.Range
+// This just translates to
+// polygon_data.begin() and polygon_data.end()
+namespace boost
+{
+    template<typename CoordinateType>
+    struct range_mutable_iterator<boost::polygon::polygon_data<CoordinateType> >
+    {
+        typedef typename boost::polygon::polygon_traits
+            <
+                boost::polygon::polygon_data<CoordinateType>
+            >::iterator_type type;
+    };
+
+    template<typename CoordinateType>
+    struct range_const_iterator<boost::polygon::polygon_data<CoordinateType> >
+    {
+        typedef typename boost::polygon::polygon_traits
+            <
+                boost::polygon::polygon_data<CoordinateType>
+            >::iterator_type type;
+    };
+
+    template<typename CoordinateType>
+    struct range_size<boost::polygon::polygon_data<CoordinateType> >
+    {
+        typedef std::size_t type;
+    };
+
+} // namespace boost
+
+
+// Support Boost.Polygon's polygon_data for Boost.Range ADP
+namespace boost { namespace polygon
+{
+
+template<typename CoordinateType>
+inline typename polygon_traits
+        <
+            polygon_data<CoordinateType>
+        >::iterator_type range_begin(polygon_data<CoordinateType>& polygon)
+{
+    return polygon.begin();
+}
+
+template<typename CoordinateType>
+inline typename polygon_traits
+        <
+            polygon_data<CoordinateType>
+        >::iterator_type range_begin(polygon_data<CoordinateType> const& polygon)
+{
+    return polygon.begin();
+}
+
+template<typename CoordinateType>
+inline typename polygon_traits
+        <
+            polygon_data<CoordinateType>
+        >::iterator_type range_end(polygon_data<CoordinateType>& polygon)
+{
+    return polygon.end();
+}
+
+template<typename CoordinateType>
+inline typename polygon_traits
+        <
+            polygon_data<CoordinateType>
+        >::iterator_type range_end(polygon_data<CoordinateType> const& polygon)
+{
+    return polygon.end();
+}
+
+template<typename CoordinateType>
+inline std::size_t range_calculate_size(polygon_data<CoordinateType> const& polygon)
+{
+    return polygon.size();
+}
+
+}}
+
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_RING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/ring_proxy.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/ring_proxy.hpp
new file mode 100644
index 00000000000..84f72aadcb8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_polygon/ring_proxy.hpp
@@ -0,0 +1,301 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2010-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_RING_PROXY_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_RING_PROXY_HPP
+
+// Adapts Geometries from Boost.Polygon for usage in Boost.Geometry
+// boost::polygon::polygon_with_holes_data -> boost::geometry::polygon
+//   pair{begin_points, end_points} -> ring_proxy
+
+#include <boost/polygon/polygon.hpp>
+#include <boost/range.hpp>
+
+
+
+namespace boost { namespace geometry
+{
+
+namespace adapt { namespace bp
+{
+
+namespace detail
+{
+
+template <bool Mutable>
+struct modify
+{};
+
+template <>
+struct modify<true>
+{
+    template <typename Ring, typename Point>
+    static inline void push_back(Ring& ring, Point const& point)
+    {
+        // Boost.Polygon's polygons are not appendable. So create a temporary vector,
+        // add a record and set it to the original. Of course: this is not efficient.
+        // But there seems no other way (without using a wrapper)
+        std::vector<Point> temporary_vector
+            (
+                boost::polygon::begin_points(ring),
+                boost::polygon::end_points(ring)
+            );
+        temporary_vector.push_back(point);
+        boost::polygon::set_points(ring, temporary_vector.begin(), temporary_vector.end());
+    }
+
+};
+
+template <>
+struct modify<false>
+{
+    template <typename Ring, typename Point>
+    static inline void push_back(Ring& /*ring*/, Point const& /*point*/)
+    {
+    }
+
+};
+
+
+}
+
+
+// Polygon should implement the boost::polygon::polygon_with_holes_concept
+// Specify constness in the template parameter if necessary
+template<typename Polygon>
+class ring_proxy
+{
+public :
+    typedef typename boost::polygon::polygon_traits
+        <
+            typename boost::remove_const<Polygon>::type
+        >::iterator_type iterator_type;
+
+    typedef typename boost::polygon::polygon_with_holes_traits
+        <
+            typename boost::remove_const<Polygon>::type
+        >::iterator_holes_type hole_iterator_type;
+
+    static const bool is_mutable = !boost::is_const<Polygon>::type::value;
+
+    inline ring_proxy(Polygon& p)
+        : m_polygon_pointer(&p)
+        , m_do_hole(false)
+    {}
+
+    // Constructor used from hole_iterator
+    inline ring_proxy(Polygon& p, hole_iterator_type hole_it)
+        : m_polygon_pointer(&p)
+        , m_do_hole(true)
+        , m_hole_it(hole_it)
+    {}
+
+    // Default constructor, for mutable polygons / appending (interior) rings
+    inline ring_proxy()
+        : m_polygon_pointer(&m_polygon_for_default_constructor)
+        , m_do_hole(false)
+    {}
+
+
+    iterator_type begin() const
+    {
+        return m_do_hole
+            ? boost::polygon::begin_points(*m_hole_it)
+            : boost::polygon::begin_points(*m_polygon_pointer)
+            ;
+    }
+
+    iterator_type begin()
+    {
+        return m_do_hole
+            ? boost::polygon::begin_points(*m_hole_it)
+            : boost::polygon::begin_points(*m_polygon_pointer)
+            ;
+    }
+
+    iterator_type end() const
+    {
+        return m_do_hole
+            ? boost::polygon::end_points(*m_hole_it)
+            : boost::polygon::end_points(*m_polygon_pointer)
+            ;
+    }
+
+    iterator_type end()
+    {
+        return m_do_hole
+            ? boost::polygon::end_points(*m_hole_it)
+            : boost::polygon::end_points(*m_polygon_pointer)
+            ;
+    }
+
+    // Mutable
+    void clear()
+    {
+        Polygon p;
+        if (m_do_hole)
+        {
+            // Does NOT work see comment above
+        }
+        else
+        {
+            boost::polygon::set_points(*m_polygon_pointer,
+                boost::polygon::begin_points(p),
+                boost::polygon::end_points(p));
+        }
+    }
+
+    void resize(std::size_t /*new_size*/)
+    {
+        if (m_do_hole)
+        {
+            // Does NOT work see comment above
+        }
+        else
+        {
+            // TODO: implement this by resizing the container
+        }
+    }
+
+
+
+    template <typename Point>
+    void push_back(Point const& point)
+    {
+        if (m_do_hole)
+        {
+            //detail::modify<is_mutable>::push_back(*m_hole_it, point);
+            //std::cout << "HOLE: " << typeid(*m_hole_it).name() << std::endl;
+            //std::cout << "HOLE: " << typeid(m_hole_it).name() << std::endl;
+            //std::cout << "HOLE: " << typeid(hole_iterator_type).name() << std::endl;
+
+            // Note, ths does NOT work because hole_iterator_type is defined
+            // as a const_iterator by Boost.Polygon
+
+        }
+        else
+        {
+            detail::modify<is_mutable>::push_back(*m_polygon_pointer, point);
+        }
+    }
+
+private :
+    Polygon* m_polygon_pointer;
+    bool m_do_hole;
+    hole_iterator_type m_hole_it;
+
+    Polygon m_polygon_for_default_constructor;
+};
+
+
+
+
+// Support geometry::adapt::bp::ring_proxy for Boost.Range ADP
+template<typename Polygon>
+inline typename boost::geometry::adapt::bp::ring_proxy<Polygon>::iterator_type
+            range_begin(boost::geometry::adapt::bp::ring_proxy<Polygon>& proxy)
+{
+    return proxy.begin();
+}
+
+template<typename Polygon>
+inline typename boost::geometry::adapt::bp::ring_proxy<Polygon const>::iterator_type
+            range_begin(boost::geometry::adapt::bp::ring_proxy<Polygon const> const& proxy)
+{
+    return proxy.begin();
+}
+
+template<typename Polygon>
+inline typename boost::geometry::adapt::bp::ring_proxy<Polygon>::iterator_type
+            range_end(boost::geometry::adapt::bp::ring_proxy<Polygon>& proxy)
+{
+    return proxy.end();
+}
+
+template<typename Polygon>
+inline typename boost::geometry::adapt::bp::ring_proxy<Polygon const>::iterator_type
+            range_end(boost::geometry::adapt::bp::ring_proxy<Polygon const> const& proxy)
+{
+    return proxy.end();
+}
+
+
+
+
+}} // namespace adapt::bp
+
+
+namespace traits
+{
+
+template <typename Polygon>
+struct tag<adapt::bp::ring_proxy<Polygon> >
+{
+    typedef ring_tag type;
+};
+
+
+template <typename Polygon>
+struct rvalue_type<adapt::bp::ring_proxy<Polygon> >
+{
+    typedef adapt::bp::ring_proxy<Polygon> type;
+};
+
+template <typename Polygon>
+struct clear<adapt::bp::ring_proxy<Polygon> >
+{
+    static inline void apply(adapt::bp::ring_proxy<Polygon> proxy)
+    {
+        proxy.clear();
+    }
+};
+
+
+template <typename Polygon>
+struct resize<adapt::bp::ring_proxy<Polygon> >
+{
+    static inline void apply(adapt::bp::ring_proxy<Polygon> proxy, std::size_t new_size)
+    {
+        proxy.resize(new_size);
+    }
+};
+
+template <typename Polygon>
+struct push_back<adapt::bp::ring_proxy<Polygon> >
+{
+    static inline void apply(adapt::bp::ring_proxy<Polygon> proxy,
+        typename boost::polygon::polygon_traits<Polygon>::point_type const& point)
+    {
+        proxy.push_back(point);
+    }
+};
+
+
+} // namespace traits
+
+}} // namespace boost::geometry
+
+// Specialize ring_proxy for Boost.Range
+namespace boost
+{
+    template<typename Polygon>
+    struct range_mutable_iterator<geometry::adapt::bp::ring_proxy<Polygon> >
+    {
+        typedef typename geometry::adapt::bp::ring_proxy<Polygon>::iterator_type type;
+    };
+
+    template<typename Polygon>
+    struct range_const_iterator<geometry::adapt::bp::ring_proxy<Polygon> >
+    {
+        typedef typename geometry::adapt::bp::ring_proxy<Polygon const>::iterator_type type;
+    };
+
+} // namespace boost
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_POLYGON_RING_PROXY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/adjacent_filtered.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/adjacent_filtered.hpp
new file mode 100644
index 00000000000..496dbeaec6c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/adjacent_filtered.hpp
@@ -0,0 +1,40 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2010-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_RANGE_ADJACENT_FILTERED_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_RANGE_ADJACENT_FILTERED_HPP
+
+
+#include <boost/range/adaptor/adjacent_filtered.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace traits
+{
+
+template<typename Filter, typename Geometry, bool DefaultPass>
+#if BOOST_VERSION > 104500
+struct tag<boost::adjacent_filtered_range<Filter, Geometry, DefaultPass> >
+#else
+struct tag<boost::range_detail::adjacent_filter_range<Filter, Geometry, DefaultPass> >
+#endif
+{
+    typedef typename geometry::tag<Geometry>::type type;
+};
+
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_RANGE_ADJACENT_FILTERED_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/filtered.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/filtered.hpp
new file mode 100644
index 00000000000..990d608460b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/filtered.hpp
@@ -0,0 +1,40 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2010-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_RANGE_FILTERED_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_RANGE_FILTERED_HPP
+
+
+#include <boost/range/adaptor/filtered.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace traits
+{
+
+template<typename Filter, typename Geometry>
+#if BOOST_VERSION > 104500
+struct tag<boost::filtered_range<Filter, Geometry> >
+#else
+struct tag<boost::range_detail::filter_range<Filter, Geometry> >
+#endif
+{
+    typedef typename geometry::tag<Geometry>::type type;
+};
+
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_RANGE_FILTERED_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/reversed.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/reversed.hpp
new file mode 100644
index 00000000000..3c8601fe195
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/reversed.hpp
@@ -0,0 +1,40 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2010-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_RANGE_REVERSED_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_RANGE_REVERSED_HPP
+
+
+#include <boost/range/adaptor/reversed.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace traits
+{
+
+template<typename Geometry>
+#if BOOST_VERSION > 104500
+struct tag<boost::reversed_range<Geometry> >
+#else
+struct tag<boost::range_detail::reverse_range<Geometry> >
+#endif
+{
+    typedef typename geometry::tag<Geometry>::type type;
+};
+
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_RANGE_REVERSED_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/sliced.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/sliced.hpp
new file mode 100644
index 00000000000..70189819cae
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/sliced.hpp
@@ -0,0 +1,36 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2010-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_RANGE_SLICED_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_RANGE_SLICED_HPP
+
+
+#include <boost/range/adaptor/sliced.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace traits
+{
+
+template<typename Geometry>
+struct tag<boost::adaptors::sliced_range<Geometry> >
+{
+    typedef typename geometry::tag<Geometry>::type type;
+};
+
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_RANGE_SLICED_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/strided.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/strided.hpp
new file mode 100644
index 00000000000..5c9cdd6a827
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/strided.hpp
@@ -0,0 +1,36 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2010-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_RANGE_STRIDED_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_RANGE_STRIDED_HPP
+
+
+#include <boost/range/adaptor/strided.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace traits
+{
+
+template<typename Geometry>
+struct tag<boost::strided_range<Geometry> >
+{
+    typedef typename geometry::tag<Geometry>::type type;
+};
+
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_RANGE_STRIDED_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/uniqued.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/uniqued.hpp
new file mode 100644
index 00000000000..beb51fe0b82
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_range/uniqued.hpp
@@ -0,0 +1,40 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2010-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_RANGE_UNIQUED_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_RANGE_UNIQUED_HPP
+
+
+#include <boost/range/adaptor/uniqued.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace traits
+{
+
+template<typename Geometry>
+#if BOOST_VERSION > 104500
+struct tag<boost::uniqued_range<Geometry> >
+#else
+struct tag<boost::range_detail::unique_range<Geometry> >
+#endif
+{
+    typedef typename geometry::tag<Geometry>::type type;
+};
+
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_RANGE_UNIQUED_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_tuple.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_tuple.hpp
new file mode 100644
index 00000000000..58065fe9af3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/boost_tuple.hpp
@@ -0,0 +1,109 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_TUPLE_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_BOOST_TUPLE_HPP
+
+
+#include <cstddef>
+
+#include <boost/tuple/tuple.hpp>
+
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7, typename T8, typename T9, typename T10>
+struct tag<boost::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >
+{
+    typedef point_tag type;
+};
+
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7, typename T8, typename T9, typename T10>
+struct coordinate_type<boost::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >
+{
+    typedef T1 type;
+};
+
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7, typename T8, typename T9, typename T10>
+struct dimension<boost::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> >
+    : boost::mpl::int_
+          <
+              boost::tuples::length
+                  <
+                      boost::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
+                  >::value
+          >
+{};
+
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5,
+          typename T6, typename T7, typename T8, typename T9, typename T10,
+          std::size_t Dimension>
+struct access
+    <
+        boost::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>,
+        Dimension
+    >
+{
+    static inline T1 get(
+        boost::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> const& point)
+    {
+        return point.template get<Dimension>();
+    }
+
+    static inline void set(
+        boost::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& point,
+        T1 const& value)
+    {
+        point.template get<Dimension>() = value;
+    }
+};
+
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+
+}} // namespace boost::geometry
+
+
+// Convenience registration macro to bind boost::tuple to a CS
+#define BOOST_GEOMETRY_REGISTER_BOOST_TUPLE_CS(CoordinateSystem) \
+    namespace boost { namespace geometry { namespace traits { \
+    template <typename T1, typename T2, typename T3, typename T4, typename T5, \
+              typename T6, typename T7, typename T8, typename T9, typename T10> \
+    struct coordinate_system<boost::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> > \
+    { \
+        typedef CoordinateSystem type; \
+    }; \
+    }}}
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_TUPLE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/c_array.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/c_array.hpp
new file mode 100644
index 00000000000..1b4523d9691
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/c_array.hpp
@@ -0,0 +1,111 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_ADAPTED_C_ARRAY_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_C_ARRAY_HPP
+
+#include <cstddef>
+
+#include <boost/type_traits/is_arithmetic.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+
+// Create class and specialization to indicate the tag
+// for normal cases and the case that the type of the c-array is arithmetic
+template <bool>
+struct c_array_tag
+{
+    typedef geometry_not_recognized_tag type;
+};
+
+
+template <>
+struct c_array_tag<true>
+{
+    typedef point_tag type;
+};
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+// Assign the point-tag, preventing arrays of points getting a point-tag
+template <typename CoordinateType, std::size_t DimensionCount>
+struct tag<CoordinateType[DimensionCount]>
+    : detail::c_array_tag<boost::is_arithmetic<CoordinateType>::value> {};
+
+
+template <typename CoordinateType, std::size_t DimensionCount>
+struct coordinate_type<CoordinateType[DimensionCount]>
+{
+    typedef CoordinateType type;
+};
+
+
+template <typename CoordinateType, std::size_t DimensionCount>
+struct dimension<CoordinateType[DimensionCount]>: boost::mpl::int_<DimensionCount> {};
+
+
+template <typename CoordinateType, std::size_t DimensionCount, std::size_t Dimension>
+struct access<CoordinateType[DimensionCount], Dimension>
+{
+    static inline CoordinateType get(CoordinateType const p[DimensionCount])
+    {
+        return p[Dimension];
+    }
+
+    static inline void set(CoordinateType p[DimensionCount],
+        CoordinateType const& value)
+    {
+        p[Dimension] = value;
+    }
+};
+
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+
+}} // namespace boost::geometry
+
+
+#define BOOST_GEOMETRY_REGISTER_C_ARRAY_CS(CoordinateSystem) \
+    namespace boost { namespace geometry { namespace traits { \
+    template <typename T, std::size_t N> \
+    struct coordinate_system<T[N]> \
+    { \
+        typedef CoordinateSystem type; \
+    }; \
+    }}}
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_C_ARRAY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/std_array.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/std_array.hpp
new file mode 100644
index 00000000000..4f5cbe0d328
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/std_array.hpp
@@ -0,0 +1,115 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2010 Alfredo Correa
+// Copyright (c) 2010-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2016 Norbert Wenzel
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_ADAPTED_STD_ARRAY_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_STD_ARRAY_HPP
+
+
+#define BOOST_GEOMETRY_ADAPTED_STD_ARRAY_TAG_DEFINED
+
+
+#include <cstddef>
+
+#include <boost/type_traits/is_arithmetic.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <array>
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+
+// Create class and specialization to indicate the tag
+// for normal cases and the case that the type of the std-array is arithmetic
+template <bool>
+struct std_array_tag
+{
+    typedef geometry_not_recognized_tag type;
+};
+
+
+template <>
+struct std_array_tag<true>
+{
+    typedef point_tag type;
+};
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+// Assign the point-tag, preventing arrays of points getting a point-tag
+template <typename CoordinateType, std::size_t DimensionCount>
+struct tag<std::array<CoordinateType, DimensionCount> >
+    : detail::std_array_tag<boost::is_arithmetic<CoordinateType>::value> {};
+
+
+template <typename CoordinateType, std::size_t DimensionCount>
+struct coordinate_type<std::array<CoordinateType, DimensionCount> >
+{
+    typedef CoordinateType type;
+};
+
+
+template <typename CoordinateType, std::size_t DimensionCount>
+struct dimension<std::array<CoordinateType, DimensionCount> >: boost::mpl::int_<DimensionCount> {};
+
+
+template <typename CoordinateType, std::size_t DimensionCount, std::size_t Dimension>
+struct access<std::array<CoordinateType, DimensionCount>, Dimension>
+{
+    static inline CoordinateType get(std::array<CoordinateType, DimensionCount> const& a)
+    {
+        return a[Dimension];
+    }
+
+    static inline void set(std::array<CoordinateType, DimensionCount>& a,
+        CoordinateType const& value)
+    {
+        a[Dimension] = value;
+    }
+};
+
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+
+}} // namespace boost::geometry
+
+
+#define BOOST_GEOMETRY_REGISTER_STD_ARRAY_CS(CoordinateSystem) \
+    namespace boost { namespace geometry { namespace traits { \
+    template <class T, std::size_t N> \
+    struct coordinate_system<std::array<T, N> > \
+    { \
+        typedef CoordinateSystem type; \
+    }; \
+    }}}
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_STD_ARRAY_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/std_pair_as_segment.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/std_pair_as_segment.hpp
new file mode 100644
index 00000000000..e9200e0fd04
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/adapted/std_pair_as_segment.hpp
@@ -0,0 +1,98 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_ADAPTED_STD_PAIR_AS_SEGMENT_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_ADAPTED_STD_PAIR_AS_SEGMENT_HPP
+
+// Only possible if the std::pair is not used for iterator/pair
+// (maybe it is possible to avoid that by detecting in the other file
+//  if an iterator was used in the pair)
+
+#ifdef BOOST_GEOMETRY_ADAPTED_STD_RANGE_TAG_DEFINED
+#error Include only one headerfile to register tag for adapted std:: containers or iterator pair
+#endif
+
+#define BOOST_GEOMETRY_ADAPTED_STD_RANGE_TAG_DEFINED
+
+
+#include <cstddef>
+
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+
+template <typename Point>
+struct tag<std::pair<Point, Point> >
+{
+    typedef segment_tag type;
+};
+
+template <typename Point>
+struct point_type<std::pair<Point, Point> >
+{
+    typedef Point type;
+};
+
+template <typename Point, std::size_t Dimension>
+struct indexed_access<std::pair<Point, Point>, 0, Dimension>
+{
+    typedef typename geometry::coordinate_type<Point>::type coordinate_type;
+
+    static inline coordinate_type get(std::pair<Point, Point> const& s)
+    {
+        return geometry::get<Dimension>(s.first);
+    }
+
+    static inline void set(std::pair<Point, Point>& s, coordinate_type const& value)
+    {
+        geometry::set<Dimension>(s.first, value);
+    }
+};
+
+
+template <typename Point, std::size_t Dimension>
+struct indexed_access<std::pair<Point, Point>, 1, Dimension>
+{
+    typedef typename geometry::coordinate_type<Point>::type coordinate_type;
+
+    static inline coordinate_type get(std::pair<Point, Point> const& s)
+    {
+        return geometry::get<Dimension>(s.second);
+    }
+
+    static inline void set(std::pair<Point, Point>& s, coordinate_type const& value)
+    {
+        geometry::set<Dimension>(s.second, value);
+    }
+};
+
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_ADAPTED_STD_PAIR_AS_SEGMENT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/box.hpp
new file mode 100644
index 00000000000..23fd098f651
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/box.hpp
@@ -0,0 +1,191 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_BOX_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_BOX_HPP
+
+#include <cstddef>
+
+#include <boost/concept/assert.hpp>
+#include <boost/config.hpp>
+
+#include <boost/geometry/algorithms/convert.hpp>
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+
+#if defined(BOOST_GEOMETRY_ENABLE_ACCESS_DEBUGGING)
+#include <boost/geometry/core/assert.hpp>
+#endif
+
+
+namespace boost { namespace geometry
+{
+
+namespace model
+{
+
+/*!
+\brief Class box: defines a box made of two describing points
+\ingroup geometries
+\details Box is always described by a min_corner() and a max_corner() point. If another
+    rectangle is used, use linear_ring or polygon.
+\note Boxes are for selections and for calculating the envelope of geometries. Not all algorithms
+are implemented for box. Boxes are also used in Spatial Indexes.
+\tparam Point point type. The box takes a point type as template parameter.
+The point type can be any point type.
+It can be 2D but can also be 3D or more dimensional.
+The box can also take a latlong point type as template parameter.
+
+\qbk{[include reference/geometries/box.qbk]}
+\qbk{before.synopsis, [heading Model of]}
+\qbk{before.synopsis, [link geometry.reference.concepts.concept_box Box Concept]}
+ */
+
+template<typename Point>
+class box
+{
+    BOOST_CONCEPT_ASSERT( (concepts::Point<Point>) );
+
+public:
+
+#if !defined(BOOST_GEOMETRY_ENABLE_ACCESS_DEBUGGING)
+#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
+    /// \constructor_default_no_init
+    box() = default;
+#else
+    /// \constructor_default_no_init
+    inline box()
+    {}
+#endif
+#else // defined(BOOST_GEOMETRY_ENABLE_ACCESS_DEBUGGING)
+    inline box()
+    {
+        m_created = 1;
+    }
+    ~box()
+    {
+        m_created = 0;
+    }
+#endif
+
+    /*!
+        \brief Constructor taking the minimum corner point and the maximum corner point
+    */
+    inline box(Point const& min_corner, Point const& max_corner)
+    {
+        geometry::convert(min_corner, m_min_corner);
+        geometry::convert(max_corner, m_max_corner);
+
+#if defined(BOOST_GEOMETRY_ENABLE_ACCESS_DEBUGGING)
+        m_created = 1;
+#endif
+    }
+
+    inline Point const& min_corner() const
+    {
+#if defined(BOOST_GEOMETRY_ENABLE_ACCESS_DEBUGGING)
+        BOOST_GEOMETRY_ASSERT(m_created == 1);
+#endif
+        return m_min_corner;
+    }
+    inline Point const& max_corner() const
+    {
+#if defined(BOOST_GEOMETRY_ENABLE_ACCESS_DEBUGGING)
+        BOOST_GEOMETRY_ASSERT(m_created == 1);
+#endif
+        return m_max_corner;
+    }
+
+    inline Point& min_corner()
+    {
+#if defined(BOOST_GEOMETRY_ENABLE_ACCESS_DEBUGGING)
+        BOOST_GEOMETRY_ASSERT(m_created == 1);
+#endif
+        return m_min_corner;
+    }
+    inline Point& max_corner()
+    {
+#if defined(BOOST_GEOMETRY_ENABLE_ACCESS_DEBUGGING)
+        BOOST_GEOMETRY_ASSERT(m_created == 1);
+#endif
+        return m_max_corner;
+    }
+
+private:
+
+    Point m_min_corner;
+    Point m_max_corner;
+
+#if defined(BOOST_GEOMETRY_ENABLE_ACCESS_DEBUGGING)
+    int m_created;
+#endif
+};
+
+
+} // namespace model
+
+
+// Traits specializations for box above
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+template <typename Point>
+struct tag<model::box<Point> >
+{
+    typedef box_tag type;
+};
+
+template <typename Point>
+struct point_type<model::box<Point> >
+{
+    typedef Point type;
+};
+
+template <typename Point, std::size_t Dimension>
+struct indexed_access<model::box<Point>, min_corner, Dimension>
+{
+    typedef typename geometry::coordinate_type<Point>::type coordinate_type;
+
+    static inline coordinate_type get(model::box<Point> const& b)
+    {
+        return geometry::get<Dimension>(b.min_corner());
+    }
+
+    static inline void set(model::box<Point>& b, coordinate_type const& value)
+    {
+        geometry::set<Dimension>(b.min_corner(), value);
+    }
+};
+
+template <typename Point, std::size_t Dimension>
+struct indexed_access<model::box<Point>, max_corner, Dimension>
+{
+    typedef typename geometry::coordinate_type<Point>::type coordinate_type;
+
+    static inline coordinate_type get(model::box<Point> const& b)
+    {
+        return geometry::get<Dimension>(b.max_corner());
+    }
+
+    static inline void set(model::box<Point>& b, coordinate_type const& value)
+    {
+        geometry::set<Dimension>(b.max_corner(), value);
+    }
+};
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/box_concept.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/box_concept.hpp
new file mode 100644
index 00000000000..816a90f63e5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/box_concept.hpp
@@ -0,0 +1,136 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_BOX_CONCEPT_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_BOX_CONCEPT_HPP
+
+
+#include <cstddef>
+
+#include <boost/concept_check.hpp>
+
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/point_type.hpp>
+
+
+namespace boost { namespace geometry { namespace concepts
+{
+
+
+/*!
+\brief Box concept
+\ingroup concepts
+\par Formal definition:
+The box concept is defined as following:
+- there must be a specialization of traits::tag defining box_tag as type
+- there must be a specialization of traits::point_type to define the
+  underlying point type (even if it does not consist of points, it should define
+  this type, to indicate the points it can work with)
+- there must be a specialization of traits::indexed_access, per index
+  (min_corner, max_corner) and per dimension, with two functions:
+  - get to get a coordinate value
+  - set to set a coordinate value (this one is not checked for ConstBox)
+*/
+template <typename Geometry>
+class Box
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+    typedef typename point_type<Geometry>::type point_type;
+
+
+    template
+    <
+        std::size_t Index,
+        std::size_t Dimension,
+        std::size_t DimensionCount
+    >
+    struct dimension_checker
+    {
+        static void apply()
+        {
+            Geometry* b = 0;
+            geometry::set<Index, Dimension>(*b, geometry::get<Index, Dimension>(*b));
+            dimension_checker<Index, Dimension + 1, DimensionCount>::apply();
+        }
+    };
+
+    template <std::size_t Index, std::size_t DimensionCount>
+    struct dimension_checker<Index, DimensionCount, DimensionCount>
+    {
+        static void apply() {}
+    };
+
+public :
+    BOOST_CONCEPT_USAGE(Box)
+    {
+        static const std::size_t n = dimension<Geometry>::type::value;
+        dimension_checker<min_corner, 0, n>::apply();
+        dimension_checker<max_corner, 0, n>::apply();
+    }
+#endif
+};
+
+
+/*!
+\brief Box concept (const version)
+\ingroup const_concepts
+\details The ConstBox concept apply the same as the Box concept,
+but does not apply write access.
+*/
+template <typename Geometry>
+class ConstBox
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+    typedef typename point_type<Geometry>::type point_type;
+    typedef typename coordinate_type<Geometry>::type coordinate_type;
+
+    template
+    <
+        std::size_t Index,
+        std::size_t Dimension,
+        std::size_t DimensionCount
+    >
+    struct dimension_checker
+    {
+        static void apply()
+        {
+            const Geometry* b = 0;
+            coordinate_type coord(geometry::get<Index, Dimension>(*b));
+            boost::ignore_unused_variable_warning(coord);
+            dimension_checker<Index, Dimension + 1, DimensionCount>::apply();
+        }
+    };
+
+    template <std::size_t Index, std::size_t DimensionCount>
+    struct dimension_checker<Index, DimensionCount, DimensionCount>
+    {
+        static void apply() {}
+    };
+
+public :
+    BOOST_CONCEPT_USAGE(ConstBox)
+    {
+        static const std::size_t n = dimension<Geometry>::type::value;
+        dimension_checker<min_corner, 0, n>::apply();
+        dimension_checker<max_corner, 0, n>::apply();
+    }
+#endif
+};
+
+}}} // namespace boost::geometry::concepts
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_BOX_CONCEPT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/check.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/check.hpp
new file mode 100644
index 00000000000..f609d5f1315
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/check.hpp
@@ -0,0 +1,243 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_CHECK_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_CHECK_HPP
+
+
+#include <boost/concept_check.hpp>
+#include <boost/concept/requires.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/box_concept.hpp>
+#include <boost/geometry/geometries/concepts/linestring_concept.hpp>
+#include <boost/geometry/geometries/concepts/multi_point_concept.hpp>
+#include <boost/geometry/geometries/concepts/multi_linestring_concept.hpp>
+#include <boost/geometry/geometries/concepts/multi_polygon_concept.hpp>
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+#include <boost/geometry/geometries/concepts/polygon_concept.hpp>
+#include <boost/geometry/geometries/concepts/ring_concept.hpp>
+#include <boost/geometry/geometries/concepts/segment_concept.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace concept_check
+{
+
+template <typename Concept>
+class check
+{
+    BOOST_CONCEPT_ASSERT((Concept ));
+};
+
+}} // namespace detail::concept_check
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    typename Geometry,
+    typename GeometryTag = typename geometry::tag<Geometry>::type,
+    bool IsConst = boost::is_const<Geometry>::type::value
+>
+struct check : not_implemented<GeometryTag>
+{};
+
+
+template <typename Geometry>
+struct check<Geometry, point_tag, true>
+    : detail::concept_check::check<concepts::ConstPoint<Geometry> >
+{};
+
+
+template <typename Geometry>
+struct check<Geometry, point_tag, false>
+    : detail::concept_check::check<concepts::Point<Geometry> >
+{};
+
+
+template <typename Geometry>
+struct check<Geometry, linestring_tag, true>
+    : detail::concept_check::check<concepts::ConstLinestring<Geometry> >
+{};
+
+
+template <typename Geometry>
+struct check<Geometry, linestring_tag, false>
+    : detail::concept_check::check<concepts::Linestring<Geometry> >
+{};
+
+
+template <typename Geometry>
+struct check<Geometry, ring_tag, true>
+    : detail::concept_check::check<concepts::ConstRing<Geometry> >
+{};
+
+
+template <typename Geometry>
+struct check<Geometry, ring_tag, false>
+    : detail::concept_check::check<concepts::Ring<Geometry> >
+{};
+
+template <typename Geometry>
+struct check<Geometry, polygon_tag, true>
+    : detail::concept_check::check<concepts::ConstPolygon<Geometry> >
+{};
+
+
+template <typename Geometry>
+struct check<Geometry, polygon_tag, false>
+    : detail::concept_check::check<concepts::Polygon<Geometry> >
+{};
+
+
+template <typename Geometry>
+struct check<Geometry, box_tag, true>
+    : detail::concept_check::check<concepts::ConstBox<Geometry> >
+{};
+
+
+template <typename Geometry>
+struct check<Geometry, box_tag, false>
+    : detail::concept_check::check<concepts::Box<Geometry> >
+{};
+
+
+template <typename Geometry>
+struct check<Geometry, segment_tag, true>
+    : detail::concept_check::check<concepts::ConstSegment<Geometry> >
+{};
+
+
+template <typename Geometry>
+struct check<Geometry, segment_tag, false>
+    : detail::concept_check::check<concepts::Segment<Geometry> >
+{};
+
+
+template <typename Geometry>
+struct check<Geometry, multi_point_tag, true>
+    : detail::concept_check::check<concepts::ConstMultiPoint<Geometry> >
+{};
+
+
+template <typename Geometry>
+struct check<Geometry, multi_point_tag, false>
+    : detail::concept_check::check<concepts::MultiPoint<Geometry> >
+{};
+
+
+template <typename Geometry>
+struct check<Geometry, multi_linestring_tag, true>
+    : detail::concept_check::check<concepts::ConstMultiLinestring<Geometry> >
+{};
+
+
+template <typename Geometry>
+struct check<Geometry, multi_linestring_tag, false>
+    : detail::concept_check::check<concepts::MultiLinestring<Geometry> >
+{};
+
+
+template <typename Geometry>
+struct check<Geometry, multi_polygon_tag, true>
+    : detail::concept_check::check<concepts::ConstMultiPolygon<Geometry> >
+{};
+
+
+template <typename Geometry>
+struct check<Geometry, multi_polygon_tag, false>
+    : detail::concept_check::check<concepts::MultiPolygon<Geometry> >
+{};
+
+
+} // namespace dispatch
+#endif
+
+
+
+
+namespace concepts
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+
+template <typename Geometry>
+struct checker : dispatch::check<Geometry>
+{};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct checker<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct checker<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const>
+{};
+
+
+}
+#endif // DOXYGEN_NO_DETAIL
+
+
+/*!
+    \brief Checks, in compile-time, the concept of any geometry
+    \ingroup concepts
+*/
+template <typename Geometry>
+inline void check()
+{
+    detail::checker<Geometry> c;
+    boost::ignore_unused_variable_warning(c);
+}
+
+
+/*!
+    \brief Checks, in compile-time, the concept of two geometries, and if they
+        have equal dimensions
+    \ingroup concepts
+*/
+template <typename Geometry1, typename Geometry2>
+inline void check_concepts_and_equal_dimensions()
+{
+    check<Geometry1>();
+    check<Geometry2>();
+    assert_dimension_equal<Geometry1, Geometry2>();
+}
+
+
+} // namespace concepts
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_CHECK_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/linestring_concept.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/linestring_concept.hpp
new file mode 100644
index 00000000000..6775239d050
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/linestring_concept.hpp
@@ -0,0 +1,125 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_LINESTRING_CONCEPT_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_LINESTRING_CONCEPT_HPP
+
+
+#include <boost/concept_check.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/mutable_range.hpp>
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+
+
+
+namespace boost { namespace geometry { namespace concepts
+{
+
+
+/*!
+\brief Linestring concept
+\ingroup concepts
+\par Formal definition:
+The linestring concept is defined as following:
+- there must be a specialization of traits::tag defining linestring_tag as type
+- it must behave like a Boost.Range
+- it must implement a std::back_insert_iterator
+    - either by implementing push_back
+    - or by specializing std::back_insert_iterator
+
+\note to fulfill the concepts, no traits class has to be specialized to
+define the point type.
+
+\par Example:
+
+A custom linestring, defining the necessary specializations to fulfill to the concept.
+
+Suppose that the following linestring is defined:
+\dontinclude doxygen_5.cpp
+\skip custom_linestring1
+\until };
+
+It can then be adapted to the concept as following:
+\dontinclude doxygen_5.cpp
+\skip adapt custom_linestring1
+\until }}
+
+\note
+- There is also the registration macro BOOST_GEOMETRY_REGISTER_LINESTRING
+- For registration of std::vector<P> (and deque, and list) it is enough to
+include the header-file geometries/adapted/std_as_linestring.hpp. That registers
+a vector as a linestring (so it cannot be registered as a linear ring then,
+in the same source code).
+
+
+*/
+
+template <typename Geometry>
+class Linestring
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+    typedef typename point_type<Geometry>::type point_type;
+
+    BOOST_CONCEPT_ASSERT( (concepts::Point<point_type>) );
+    BOOST_CONCEPT_ASSERT( (boost::RandomAccessRangeConcept<Geometry>) );
+
+public :
+
+    BOOST_CONCEPT_USAGE(Linestring)
+    {
+        Geometry* ls = 0;
+        traits::clear<Geometry>::apply(*ls);
+        traits::resize<Geometry>::apply(*ls, 0);
+        point_type* point = 0;
+        traits::push_back<Geometry>::apply(*ls, *point);
+    }
+#endif
+};
+
+
+/*!
+\brief Linestring concept (const version)
+\ingroup const_concepts
+\details The ConstLinestring concept check the same as the Linestring concept,
+but does not check write access.
+*/
+template <typename Geometry>
+class ConstLinestring
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+    typedef typename point_type<Geometry>::type point_type;
+
+    BOOST_CONCEPT_ASSERT( (concepts::ConstPoint<point_type>) );
+    //BOOST_CONCEPT_ASSERT( (boost::RandomAccessRangeConcept<Geometry>) );
+    // Relaxed the concept.
+    BOOST_CONCEPT_ASSERT( (boost::ForwardRangeConcept<Geometry>) );
+
+
+public :
+
+    BOOST_CONCEPT_USAGE(ConstLinestring)
+    {
+    }
+#endif
+};
+
+}}} // namespace boost::geometry::concepts
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_LINESTRING_CONCEPT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/multi_linestring_concept.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/multi_linestring_concept.hpp
new file mode 100644
index 00000000000..7931670903f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/multi_linestring_concept.hpp
@@ -0,0 +1,91 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_MULTI_LINESTRING_CONCEPT_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_MULTI_LINESTRING_CONCEPT_HPP
+
+
+#include <boost/concept_check.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/metafunctions.hpp>
+
+
+#include <boost/geometry/geometries/concepts/linestring_concept.hpp>
+
+
+namespace boost { namespace geometry { namespace concepts
+{
+
+
+/*!
+\brief multi-linestring concept
+\ingroup concepts
+\par Formal definition:
+The multi linestring concept is defined as following:
+- there must be a specialization of traits::tag defining multi_linestring_tag as
+  type
+- it must behave like a Boost.Range
+- its range value must fulfil the Linestring concept
+
+*/
+template <typename Geometry>
+class MultiLinestring
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+    typedef typename boost::range_value<Geometry>::type linestring_type;
+
+    BOOST_CONCEPT_ASSERT( (concepts::Linestring<linestring_type>) );
+    BOOST_CONCEPT_ASSERT( (boost::RandomAccessRangeConcept<Geometry>) );
+
+
+public :
+
+    BOOST_CONCEPT_USAGE(MultiLinestring)
+    {
+        Geometry* mls = 0;
+        traits::clear<Geometry>::apply(*mls);
+        traits::resize<Geometry>::apply(*mls, 0);
+        linestring_type* ls = 0;
+        traits::push_back<Geometry>::apply(*mls, *ls);
+    }
+#endif
+};
+
+
+/*!
+\brief concept for multi-linestring (const version)
+\ingroup const_concepts
+*/
+template <typename Geometry>
+class ConstMultiLinestring
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+    typedef typename boost::range_value<Geometry>::type linestring_type;
+
+    BOOST_CONCEPT_ASSERT( (concepts::ConstLinestring<linestring_type>) );
+    BOOST_CONCEPT_ASSERT( (boost::RandomAccessRangeConcept<Geometry>) );
+
+
+public :
+
+    BOOST_CONCEPT_USAGE(ConstMultiLinestring)
+    {
+    }
+#endif
+};
+
+}}} // namespace boost::geometry::concepts
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_MULTI_LINESTRING_CONCEPT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/multi_point_concept.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/multi_point_concept.hpp
new file mode 100644
index 00000000000..9e205f1635a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/multi_point_concept.hpp
@@ -0,0 +1,90 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_MULTI_POINT_CONCEPT_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_MULTI_POINT_CONCEPT_HPP
+
+
+#include <boost/concept_check.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/metafunctions.hpp>
+
+
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+
+
+namespace boost { namespace geometry { namespace concepts
+{
+
+
+/*!
+\brief MultiPoint concept
+\ingroup concepts
+\par Formal definition:
+The multi point concept is defined as following:
+- there must be a specialization of traits::tag defining multi_point_tag as type
+- it must behave like a Boost.Range
+- its range value must fulfil the Point concept
+
+*/
+template <typename Geometry>
+class MultiPoint
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+    typedef typename boost::range_value<Geometry>::type point_type;
+
+    BOOST_CONCEPT_ASSERT( (concepts::Point<point_type>) );
+    BOOST_CONCEPT_ASSERT( (boost::RandomAccessRangeConcept<Geometry>) );
+
+
+public :
+
+    BOOST_CONCEPT_USAGE(MultiPoint)
+    {
+        Geometry* mp = 0;
+        traits::clear<Geometry>::apply(*mp);
+        traits::resize<Geometry>::apply(*mp, 0);
+        point_type* point = 0;
+        traits::push_back<Geometry>::apply(*mp, *point);
+    }
+#endif
+};
+
+
+/*!
+\brief concept for multi-point (const version)
+\ingroup const_concepts
+*/
+template <typename Geometry>
+class ConstMultiPoint
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+    typedef typename boost::range_value<Geometry>::type point_type;
+
+    BOOST_CONCEPT_ASSERT( (concepts::ConstPoint<point_type>) );
+    BOOST_CONCEPT_ASSERT( (boost::RandomAccessRangeConcept<Geometry>) );
+
+
+public :
+
+    BOOST_CONCEPT_USAGE(ConstMultiPoint)
+    {
+    }
+#endif
+};
+
+}}} // namespace boost::geometry::concepts
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_MULTI_POINT_CONCEPT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/multi_polygon_concept.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/multi_polygon_concept.hpp
new file mode 100644
index 00000000000..63de6e5bfca
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/multi_polygon_concept.hpp
@@ -0,0 +1,91 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_MULTI_POLYGON_CONCEPT_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_MULTI_POLYGON_CONCEPT_HPP
+
+
+#include <boost/concept_check.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/metafunctions.hpp>
+
+#include <boost/geometry/geometries/concepts/polygon_concept.hpp>
+
+
+namespace boost { namespace geometry { namespace concepts
+{
+
+
+/*!
+\brief multi-polygon concept
+\ingroup concepts
+\par Formal definition:
+The multi polygon concept is defined as following:
+- there must be a specialization of traits::tag defining multi_polygon_tag
+  as type
+- it must behave like a Boost.Range
+- its range value must fulfil the Polygon concept
+
+*/
+template <typename Geometry>
+class MultiPolygon
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+    typedef typename boost::range_value<Geometry>::type polygon_type;
+
+    BOOST_CONCEPT_ASSERT( (concepts::Polygon<polygon_type>) );
+    BOOST_CONCEPT_ASSERT( (boost::RandomAccessRangeConcept<Geometry>) );
+
+
+public :
+
+    BOOST_CONCEPT_USAGE(MultiPolygon)
+    {
+        Geometry* mp = 0;
+        traits::clear<Geometry>::apply(*mp);
+        traits::resize<Geometry>::apply(*mp, 0);
+        polygon_type* poly = 0;
+        traits::push_back<Geometry>::apply(*mp, *poly);
+    }
+#endif
+};
+
+
+/*!
+\brief concept for multi-polygon (const version)
+\ingroup const_concepts
+*/
+template <typename Geometry>
+class ConstMultiPolygon
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+    typedef typename boost::range_value<Geometry>::type polygon_type;
+
+    BOOST_CONCEPT_ASSERT( (concepts::ConstPolygon<polygon_type>) );
+    BOOST_CONCEPT_ASSERT( (boost::RandomAccessRangeConcept<Geometry>) );
+
+
+public :
+
+    BOOST_CONCEPT_USAGE(ConstMultiPolygon)
+    {
+    }
+#endif
+};
+
+
+}}} // namespace boost::geometry::concepts
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_MULTI_POLYGON_CONCEPT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/point_concept.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/point_concept.hpp
new file mode 100644
index 00000000000..4001f4e06b7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/point_concept.hpp
@@ -0,0 +1,192 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+//
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_POINT_CONCEPT_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_POINT_CONCEPT_HPP
+
+#include <cstddef>
+
+#include <boost/concept_check.hpp>
+#include <boost/core/ignore_unused.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_system.hpp>
+
+
+
+namespace boost { namespace geometry { namespace concepts
+{
+
+/*!
+\brief Point concept.
+\ingroup concepts
+
+\par Formal definition:
+The point concept is defined as following:
+- there must be a specialization of traits::tag defining point_tag as type
+- there must be a specialization of traits::coordinate_type defining the type
+  of its coordinates
+- there must be a specialization of traits::coordinate_system defining its
+  coordinate system (cartesian, spherical, etc)
+- there must be a specialization of traits::dimension defining its number
+  of dimensions (2, 3, ...) (derive it conveniently
+  from boost::mpl::int_&lt;X&gt; for X-D)
+- there must be a specialization of traits::access, per dimension,
+  with two functions:
+  - \b get to get a coordinate value
+  - \b set to set a coordinate value (this one is not checked for ConstPoint)
+- for non-Cartesian coordinate systems, the coordinate system's units
+  must either be boost::geometry::degree or boost::geometry::radian
+
+
+\par Example:
+
+A legacy point, defining the necessary specializations to fulfil to the concept.
+
+Suppose that the following point is defined:
+\dontinclude doxygen_5.cpp
+\skip legacy_point1
+\until };
+
+It can then be adapted to the concept as following:
+\dontinclude doxygen_5.cpp
+\skip adapt legacy_point1
+\until }}
+
+Note that it is done like above to show the system. Users will normally use the registration macro.
+
+\par Example:
+
+A read-only legacy point, using a macro to fulfil to the ConstPoint concept.
+It cannot be modified by the library but can be used in all algorithms where
+points are not modified.
+
+The point looks like the following:
+
+\dontinclude doxygen_5.cpp
+\skip legacy_point2
+\until };
+
+It uses the macro as following:
+\dontinclude doxygen_5.cpp
+\skip adapt legacy_point2
+\until end adaptation
+
+*/
+
+template <typename Geometry>
+class Point
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+
+    typedef typename coordinate_type<Geometry>::type ctype;
+    typedef typename coordinate_system<Geometry>::type csystem;
+
+    // The following enum is used to fully instantiate the coordinate
+    // system class; this is needed in order to check the units passed
+    // to it for non-Cartesian coordinate systems.
+    enum { cs_check = sizeof(csystem) };
+
+    enum { ccount = dimension<Geometry>::value };
+
+    template <typename P, std::size_t Dimension, std::size_t DimensionCount>
+    struct dimension_checker
+    {
+        static void apply()
+        {
+            P* p = 0;
+            geometry::set<Dimension>(*p, geometry::get<Dimension>(*p));
+            dimension_checker<P, Dimension+1, DimensionCount>::apply();
+        }
+    };
+
+
+    template <typename P, std::size_t DimensionCount>
+    struct dimension_checker<P, DimensionCount, DimensionCount>
+    {
+        static void apply() {}
+    };
+
+public:
+
+    /// BCCL macro to apply the Point concept
+    BOOST_CONCEPT_USAGE(Point)
+    {
+        dimension_checker<Geometry, 0, ccount>::apply();
+    }
+#endif
+};
+
+
+/*!
+\brief point concept (const version).
+
+\ingroup const_concepts
+
+\details The ConstPoint concept apply the same as the Point concept,
+but does not apply write access.
+
+*/
+template <typename Geometry>
+class ConstPoint
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+
+    typedef typename coordinate_type<Geometry>::type ctype;
+    typedef typename coordinate_system<Geometry>::type csystem;
+
+    // The following enum is used to fully instantiate the coordinate
+    // system class; this is needed in order to check the units passed
+    // to it for non-Cartesian coordinate systems.
+    enum { cs_check = sizeof(csystem) };
+
+    enum { ccount = dimension<Geometry>::value };
+
+    template <typename P, std::size_t Dimension, std::size_t DimensionCount>
+    struct dimension_checker
+    {
+        static void apply()
+        {
+            const P* p = 0;
+            ctype coord(geometry::get<Dimension>(*p));
+            boost::ignore_unused(p, coord);
+            dimension_checker<P, Dimension+1, DimensionCount>::apply();
+        }
+    };
+
+
+    template <typename P, std::size_t DimensionCount>
+    struct dimension_checker<P, DimensionCount, DimensionCount>
+    {
+        static void apply() {}
+    };
+
+public:
+
+    /// BCCL macro to apply the ConstPoint concept
+    BOOST_CONCEPT_USAGE(ConstPoint)
+    {
+        dimension_checker<Geometry, 0, ccount>::apply();
+    }
+#endif
+};
+
+}}} // namespace boost::geometry::concepts
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_POINT_CONCEPT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/polygon_concept.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/polygon_concept.hpp
new file mode 100644
index 00000000000..58b780009b1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/polygon_concept.hpp
@@ -0,0 +1,135 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_POLYGON_CONCEPT_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_POLYGON_CONCEPT_HPP
+
+#include <boost/concept_check.hpp>
+#include <boost/range/concepts.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+#include <boost/geometry/geometries/concepts/ring_concept.hpp>
+
+
+namespace boost { namespace geometry { namespace concepts
+{
+
+/*!
+\brief Checks polygon concept
+\ingroup concepts
+*/
+template <typename PolygonType>
+class Polygon
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+    typedef typename boost::remove_const<PolygonType>::type polygon_type;
+
+    typedef typename traits::ring_const_type<polygon_type>::type ring_const_type;
+    typedef typename traits::ring_mutable_type<polygon_type>::type ring_mutable_type;
+    typedef typename traits::interior_const_type<polygon_type>::type interior_const_type;
+    typedef typename traits::interior_mutable_type<polygon_type>::type interior_mutable_type;
+
+    typedef typename point_type<PolygonType>::type point_type;
+    typedef typename ring_type<PolygonType>::type ring_type;
+
+    BOOST_CONCEPT_ASSERT( (concepts::Point<point_type>) );
+    BOOST_CONCEPT_ASSERT( (concepts::Ring<ring_type>) );
+
+    //BOOST_CONCEPT_ASSERT( (boost::RandomAccessRangeConcept<interior_type>) );
+
+    struct checker
+    {
+        static inline void apply()
+        {
+            polygon_type* poly = 0;
+            polygon_type const* cpoly = poly;
+
+            ring_mutable_type e = traits::exterior_ring<PolygonType>::get(*poly);
+            interior_mutable_type i = traits::interior_rings<PolygonType>::get(*poly);
+            ring_const_type ce = traits::exterior_ring<PolygonType>::get(*cpoly);
+            interior_const_type ci = traits::interior_rings<PolygonType>::get(*cpoly);
+
+            boost::ignore_unused_variable_warning(e);
+            boost::ignore_unused_variable_warning(i);
+            boost::ignore_unused_variable_warning(ce);
+            boost::ignore_unused_variable_warning(ci);
+            boost::ignore_unused_variable_warning(poly);
+            boost::ignore_unused_variable_warning(cpoly);
+        }
+    };
+
+public:
+
+    BOOST_CONCEPT_USAGE(Polygon)
+    {
+        checker::apply();
+    }
+#endif
+};
+
+
+/*!
+\brief Checks polygon concept (const version)
+\ingroup const_concepts
+*/
+template <typename PolygonType>
+class ConstPolygon
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+
+    typedef typename boost::remove_const<PolygonType>::type const_polygon_type;
+
+    typedef typename traits::ring_const_type<const_polygon_type>::type ring_const_type;
+    typedef typename traits::interior_const_type<const_polygon_type>::type interior_const_type;
+
+    typedef typename point_type<const_polygon_type>::type point_type;
+    typedef typename ring_type<const_polygon_type>::type ring_type;
+
+    BOOST_CONCEPT_ASSERT( (concepts::ConstPoint<point_type>) );
+    BOOST_CONCEPT_ASSERT( (concepts::ConstRing<ring_type>) );
+
+    ////BOOST_CONCEPT_ASSERT( (boost::RandomAccessRangeConcept<interior_type>) );
+
+    struct checker
+    {
+        static inline void apply()
+        {
+            const_polygon_type const* cpoly = 0;
+
+            ring_const_type ce = traits::exterior_ring<const_polygon_type>::get(*cpoly);
+            interior_const_type ci = traits::interior_rings<const_polygon_type>::get(*cpoly);
+
+            boost::ignore_unused_variable_warning(ce);
+            boost::ignore_unused_variable_warning(ci);
+            boost::ignore_unused_variable_warning(cpoly);
+        }
+    };
+
+public:
+
+    BOOST_CONCEPT_USAGE(ConstPolygon)
+    {
+        checker::apply();
+    }
+#endif
+};
+
+}}} // namespace boost::geometry::concepts
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_POLYGON_CONCEPT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/ring_concept.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/ring_concept.hpp
new file mode 100644
index 00000000000..d75d4284383
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/ring_concept.hpp
@@ -0,0 +1,99 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_RING_CONCEPT_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_RING_CONCEPT_HPP
+
+
+#include <boost/concept_check.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/mutable_range.hpp>
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+
+
+namespace boost { namespace geometry { namespace concepts
+{
+
+
+/*!
+\brief ring concept
+\ingroup concepts
+\par Formal definition:
+The ring concept is defined as following:
+- there must be a specialization of traits::tag defining ring_tag as type
+- it must behave like a Boost.Range
+- there can optionally be a specialization of traits::point_order defining the
+  order or orientation of its points, clockwise or counterclockwise.
+- it must implement a std::back_insert_iterator
+  (This is the same as the for the concept Linestring, and described there)
+
+\note to fulfill the concepts, no traits class has to be specialized to
+define the point type.
+*/
+template <typename Geometry>
+class Ring
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+    typedef typename point_type<Geometry>::type point_type;
+
+    BOOST_CONCEPT_ASSERT( (concepts::Point<point_type>) );
+    BOOST_CONCEPT_ASSERT( (boost::RandomAccessRangeConcept<Geometry>) );
+
+public :
+
+    BOOST_CONCEPT_USAGE(Ring)
+    {
+        Geometry* ring = 0;
+        traits::clear<Geometry>::apply(*ring);
+        traits::resize<Geometry>::apply(*ring, 0);
+        point_type* point = 0;
+        traits::push_back<Geometry>::apply(*ring, *point);
+    }
+#endif
+};
+
+
+/*!
+\brief (linear) ring concept (const version)
+\ingroup const_concepts
+\details The ConstLinearRing concept check the same as the Geometry concept,
+but does not check write access.
+*/
+template <typename Geometry>
+class ConstRing
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+    typedef typename point_type<Geometry>::type point_type;
+
+    BOOST_CONCEPT_ASSERT( (concepts::ConstPoint<point_type>) );
+    BOOST_CONCEPT_ASSERT( (boost::RandomAccessRangeConcept<Geometry>) );
+
+
+public :
+
+    BOOST_CONCEPT_USAGE(ConstRing)
+    {
+    }
+#endif
+};
+
+}}} // namespace boost::geometry::concepts
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_RING_CONCEPT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/segment_concept.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/segment_concept.hpp
new file mode 100644
index 00000000000..6a1c80486ff
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/concepts/segment_concept.hpp
@@ -0,0 +1,135 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_SEGMENT_CONCEPT_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_SEGMENT_CONCEPT_HPP
+
+
+#include <boost/concept_check.hpp>
+
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/point_type.hpp>
+
+
+namespace boost { namespace geometry { namespace concepts
+{
+
+
+/*!
+\brief Segment concept.
+\ingroup concepts
+\details Formal definition:
+The segment concept is defined as following:
+- there must be a specialization of traits::tag defining segment_tag as type
+- there must be a specialization of traits::point_type to define the
+  underlying point type (even if it does not consist of points, it should define
+  this type, to indicate the points it can work with)
+- there must be a specialization of traits::indexed_access, per index
+  and per dimension, with two functions:
+  - get to get a coordinate value
+  - set to set a coordinate value (this one is not checked for ConstSegment)
+
+\note The segment concept is similar to the box concept, defining another tag.
+However, the box concept assumes the index as min_corner, max_corner, while
+for the segment concept there is no assumption.
+*/
+template <typename Geometry>
+class Segment
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+    typedef typename point_type<Geometry>::type point_type;
+
+    BOOST_CONCEPT_ASSERT( (concepts::Point<point_type>) );
+
+
+    template <size_t Index, size_t Dimension, size_t DimensionCount>
+    struct dimension_checker
+    {
+        static void apply()
+        {
+            Geometry* s = 0;
+            geometry::set<Index, Dimension>(*s, geometry::get<Index, Dimension>(*s));
+            dimension_checker<Index, Dimension + 1, DimensionCount>::apply();
+        }
+    };
+
+    template <size_t Index, size_t DimensionCount>
+    struct dimension_checker<Index, DimensionCount, DimensionCount>
+    {
+        static void apply() {}
+    };
+
+public :
+
+    BOOST_CONCEPT_USAGE(Segment)
+    {
+        static const size_t n = dimension<point_type>::type::value;
+        dimension_checker<0, 0, n>::apply();
+        dimension_checker<1, 0, n>::apply();
+    }
+#endif
+};
+
+
+/*!
+\brief Segment concept (const version).
+\ingroup const_concepts
+\details The ConstSegment concept verifies the same as the Segment concept,
+but does not verify write access.
+*/
+template <typename Geometry>
+class ConstSegment
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+    typedef typename point_type<Geometry>::type point_type;
+    typedef typename coordinate_type<Geometry>::type coordinate_type;
+
+    BOOST_CONCEPT_ASSERT( (concepts::ConstPoint<point_type>) );
+
+
+    template <size_t Index, size_t Dimension, size_t DimensionCount>
+    struct dimension_checker
+    {
+        static void apply()
+        {
+            const Geometry* s = 0;
+            coordinate_type coord(geometry::get<Index, Dimension>(*s));
+            boost::ignore_unused_variable_warning(coord);
+            dimension_checker<Index, Dimension + 1, DimensionCount>::apply();
+        }
+    };
+
+    template <size_t Index, size_t DimensionCount>
+    struct dimension_checker<Index, DimensionCount, DimensionCount>
+    {
+        static void apply() {}
+    };
+
+public :
+
+    BOOST_CONCEPT_USAGE(ConstSegment)
+    {
+        static const size_t n = dimension<point_type>::type::value;
+        dimension_checker<0, 0, n>::apply();
+        dimension_checker<1, 0, n>::apply();
+    }
+#endif
+};
+
+
+}}} // namespace boost::geometry::concepts
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_CONCEPTS_SEGMENT_CONCEPT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/geometries.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/geometries.hpp
new file mode 100644
index 00000000000..de9e2b1fd95
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/geometries.hpp
@@ -0,0 +1,29 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_HPP
+
+#include <boost/geometry/geometries/point.hpp>
+#include <boost/geometry/geometries/linestring.hpp>
+#include <boost/geometry/geometries/polygon.hpp>
+
+#include <boost/geometry/geometries/multi_point.hpp>
+#include <boost/geometry/geometries/multi_linestring.hpp>
+#include <boost/geometry/geometries/multi_polygon.hpp>
+
+#include <boost/geometry/geometries/box.hpp>
+#include <boost/geometry/geometries/ring.hpp>
+#include <boost/geometry/geometries/segment.hpp>
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/helper_geometry.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/helper_geometry.hpp
new file mode 100644
index 00000000000..9cf14a91171
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/helper_geometry.hpp
@@ -0,0 +1,162 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_HELPER_GEOMETRY_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_HELPER_GEOMETRY_HPP
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/box.hpp>
+#include <boost/geometry/geometries/point.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace detail { namespace helper_geometries
+{
+
+template <typename Geometry, typename CS_Tag = typename cs_tag<Geometry>::type>
+struct default_units
+{
+    typedef typename coordinate_system<Geometry>::type::units type;
+};
+
+// The Cartesian coordinate system does not define the type units.
+// For that reason the generic implementation for default_units cannot be used
+// and specialization needs to be defined.
+// Moreover, it makes sense to define the units for the Cartesian
+// coordinate system to be radians, as this way a Cartesian point can
+// potentially be used in algorithms taking non-Cartesian strategies
+// and work as if it was as point in the non-Cartesian coordinate
+// system with radian units.
+template <typename Geometry>
+struct default_units<Geometry, cartesian_tag>
+{
+    typedef radian type;
+};
+
+
+template <typename Units, typename CS_Tag>
+struct cs_tag_to_coordinate_system
+{
+    typedef cs::cartesian type;
+};
+
+template <typename Units>
+struct cs_tag_to_coordinate_system<Units, spherical_equatorial_tag>
+{
+    typedef cs::spherical_equatorial<Units> type;
+};
+
+template <typename Units>
+struct cs_tag_to_coordinate_system<Units, spherical_tag>
+{
+    typedef cs::spherical<Units> type;
+};
+
+template <typename Units>
+struct cs_tag_to_coordinate_system<Units, geographic_tag>
+{
+    typedef cs::geographic<Units> type;
+};
+
+
+template
+<
+    typename Point,
+    typename NewCoordinateType,
+    typename NewUnits,
+    typename CS_Tag = typename cs_tag<Point>::type
+>
+struct helper_point
+{
+    typedef model::point
+        <
+            NewCoordinateType,
+            dimension<Point>::value,
+            typename cs_tag_to_coordinate_system<NewUnits, CS_Tag>::type
+        > type;
+};
+
+
+}} // detail::helper_geometries
+
+
+namespace detail_dispatch
+{
+
+
+template
+<
+    typename Geometry,
+    typename NewCoordinateType,
+    typename NewUnits,
+    typename Tag = typename tag<Geometry>::type>
+struct helper_geometry : not_implemented<Geometry>
+{};
+
+
+template <typename Point, typename NewCoordinateType, typename NewUnits>
+struct helper_geometry<Point, NewCoordinateType, NewUnits, point_tag>
+{
+    typedef typename detail::helper_geometries::helper_point
+        <
+            Point, NewCoordinateType, NewUnits
+        >::type type;
+};
+
+
+template <typename Box, typename NewCoordinateType, typename NewUnits>
+struct helper_geometry<Box, NewCoordinateType, NewUnits, box_tag>
+{
+    typedef model::box
+        <
+            typename helper_geometry
+                <
+                    typename point_type<Box>::type, NewCoordinateType, NewUnits
+                >::type
+        > type;
+};
+
+
+} // detail_dispatch
+
+
+// Meta-function that provides a new helper geometry of the same kind as
+// the input geometry and the same coordinate system type,
+// but with a possibly different coordinate type and coordinate system units
+template
+<
+    typename Geometry,
+    typename NewCoordinateType = typename coordinate_type<Geometry>::type,
+    typename NewUnits = typename detail::helper_geometries::default_units
+        <
+            Geometry
+        >::type
+>
+struct helper_geometry
+{
+    typedef typename detail_dispatch::helper_geometry
+        <
+            Geometry, NewCoordinateType, NewUnits
+        >::type type;
+};
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_HELPER_GEOMETRY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/linestring.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/linestring.hpp
new file mode 100644
index 00000000000..280c4be7a69
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/linestring.hpp
@@ -0,0 +1,123 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_LINESTRING_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_LINESTRING_HPP
+
+#include <memory>
+#include <vector>
+
+#include <boost/concept/assert.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#include <initializer_list>
+#endif
+
+namespace boost { namespace geometry
+{
+
+namespace model
+{
+
+/*!
+\brief A linestring (named so by OGC) is a collection (default a vector) of points.
+\ingroup geometries
+\tparam Point \tparam_point
+\tparam Container \tparam_container
+\tparam Allocator \tparam_allocator
+
+\qbk{[include reference/geometries/linestring.qbk]}
+\qbk{before.synopsis,
+[heading Model of]
+[link geometry.reference.concepts.concept_linestring Linestring Concept]
+}
+
+*/
+template
+<
+    typename Point,
+    template<typename,typename> class Container = std::vector,
+    template<typename> class Allocator = std::allocator
+>
+class linestring : public Container<Point, Allocator<Point> >
+{
+    BOOST_CONCEPT_ASSERT( (concepts::Point<Point>) );
+
+    typedef Container<Point, Allocator<Point> > base_type;
+
+public :
+    /// \constructor_default{linestring}
+    inline linestring()
+        : base_type()
+    {}
+
+    /// \constructor_begin_end{linestring}
+    template <typename Iterator>
+    inline linestring(Iterator begin, Iterator end)
+        : base_type(begin, end)
+    {}
+
+#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+
+    /// \constructor_initializer_list{linestring}
+    inline linestring(std::initializer_list<Point> l)
+        : base_type(l.begin(), l.end())
+    {}
+
+// Commented out for now in order to support Boost.Assign
+// Without this assignment operator first the object should be created
+//   from initializer list, then it should be moved.
+//// Without this workaround in MSVC the assignment operator is ambiguous
+//#ifndef BOOST_MSVC
+//    /// \assignment_initializer_list{linestring}
+//    inline linestring & operator=(std::initializer_list<Point> l)
+//    {
+//        base_type::assign(l.begin(), l.end());
+//        return *this;
+//    }
+//#endif
+
+#endif
+};
+
+} // namespace model
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+template
+<
+    typename Point,
+    template<typename,typename> class Container,
+    template<typename> class Allocator
+>
+struct tag<model::linestring<Point, Container, Allocator> >
+{
+    typedef linestring_tag type;
+};
+} // namespace traits
+
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_LINESTRING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/multi_linestring.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/multi_linestring.hpp
new file mode 100644
index 00000000000..67003522b0d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/multi_linestring.hpp
@@ -0,0 +1,119 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_MULTI_LINESTRING_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_MULTI_LINESTRING_HPP
+
+#include <memory>
+#include <vector>
+
+#include <boost/concept/requires.hpp>
+
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/geometries/concepts/linestring_concept.hpp>
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#include <initializer_list>
+#endif
+
+namespace boost { namespace geometry
+{
+
+
+namespace model
+{
+
+/*!
+\brief multi_line, a collection of linestring
+\details Multi-linestring can be used to group lines belonging to each other,
+        e.g. a highway (with interruptions)
+\ingroup geometries
+
+\qbk{[include reference/geometries/multi_linestring.qbk]}
+\qbk{before.synopsis,
+[heading Model of]
+[link geometry.reference.concepts.concept_multi_linestring MultiLineString Concept]
+}
+*/
+template
+<
+    typename LineString,
+    template<typename, typename> class Container = std::vector,
+    template<typename> class Allocator = std::allocator
+>
+class multi_linestring : public Container<LineString, Allocator<LineString> >
+{
+    BOOST_CONCEPT_ASSERT( (concepts::Linestring<LineString>) );
+
+#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+
+    // default constructor and base_type definitions are required only
+    // if the constructor taking std::initializer_list is defined
+
+    typedef Container<LineString, Allocator<LineString> > base_type;
+
+public:
+    /// \constructor_default{multi_linestring}
+    multi_linestring()
+        : base_type()
+    {}
+
+    /// \constructor_initializer_list{multi_linestring}
+    inline multi_linestring(std::initializer_list<LineString> l)
+        : base_type(l.begin(), l.end())
+    {}
+
+// Commented out for now in order to support Boost.Assign
+// Without this assignment operator first the object should be created
+//   from initializer list, then it shoudl be moved.
+//// Without this workaround in MSVC the assignment operator is ambiguous
+//#ifndef BOOST_MSVC
+//    /// \assignment_initializer_list{multi_linestring}
+//    inline multi_linestring & operator=(std::initializer_list<LineString> l)
+//    {
+//        base_type::assign(l.begin(), l.end());
+//        return *this;
+//    }
+//#endif
+
+#endif
+};
+
+
+} // namespace model
+
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+template
+<
+    typename LineString,
+    template<typename, typename> class Container,
+    template<typename> class Allocator
+>
+struct tag< model::multi_linestring<LineString, Container, Allocator> >
+{
+    typedef multi_linestring_tag type;
+};
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_MULTI_LINESTRING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/multi_point.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/multi_point.hpp
new file mode 100644
index 00000000000..9579f4f602b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/multi_point.hpp
@@ -0,0 +1,123 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_MULTI_POINT_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_MULTI_POINT_HPP
+
+#include <memory>
+#include <vector>
+
+#include <boost/concept/requires.hpp>
+
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#include <initializer_list>
+#endif
+
+namespace boost { namespace geometry
+{
+
+namespace model
+{
+
+
+/*!
+\brief multi_point, a collection of points
+\ingroup geometries
+\tparam Point \tparam_point
+\tparam Container \tparam_container
+\tparam Allocator \tparam_allocator
+\details Multipoint can be used to group points belonging to each other,
+        e.g. a constellation, or the result set of an intersection
+
+\qbk{[include reference/geometries/multi_point.qbk]}
+\qbk{before.synopsis,
+[heading Model of]
+[link geometry.reference.concepts.concept_multi_point MultiPoint Concept]
+}
+*/
+template
+<
+    typename Point,
+    template<typename, typename> class Container = std::vector,
+    template<typename> class Allocator = std::allocator
+>
+class multi_point : public Container<Point, Allocator<Point> >
+{
+    BOOST_CONCEPT_ASSERT( (concepts::Point<Point>) );
+
+    typedef Container<Point, Allocator<Point> > base_type;
+
+public :
+    /// \constructor_default{multi_point}
+    inline multi_point()
+        : base_type()
+    {}
+
+    /// \constructor_begin_end{multi_point}
+    template <typename Iterator>
+    inline multi_point(Iterator begin, Iterator end)
+        : base_type(begin, end)
+    {}
+
+#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+
+    /// \constructor_initializer_list{multi_point}
+    inline multi_point(std::initializer_list<Point> l)
+        : base_type(l.begin(), l.end())
+    {}
+
+// Commented out for now in order to support Boost.Assign
+// Without this assignment operator first the object should be created
+//   from initializer list, then it shoudl be moved.
+//// Without this workaround in MSVC the assignment operator is ambiguous
+//#ifndef BOOST_MSVC
+//    /// \assignment_initializer_list{multi_point}
+//    inline multi_point & operator=(std::initializer_list<Point> l)
+//    {
+//        base_type::assign(l.begin(), l.end());
+//        return *this;
+//    }
+//#endif
+
+#endif
+};
+
+} // namespace model
+
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+template
+<
+    typename Point,
+    template<typename, typename> class Container,
+    template<typename> class Allocator
+>
+struct tag< model::multi_point<Point, Container, Allocator> >
+{
+    typedef multi_point_tag type;
+};
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_MULTI_POINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/multi_polygon.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/multi_polygon.hpp
new file mode 100644
index 00000000000..94cd922719a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/multi_polygon.hpp
@@ -0,0 +1,117 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_MULTI_POLYGON_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_MULTI_POLYGON_HPP
+
+#include <memory>
+#include <vector>
+
+#include <boost/concept/requires.hpp>
+
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/geometries/concepts/polygon_concept.hpp>
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#include <initializer_list>
+#endif
+
+namespace boost { namespace geometry
+{
+
+namespace model
+{
+
+/*!
+\brief multi_polygon, a collection of polygons
+\details Multi-polygon can be used to group polygons belonging to each other,
+        e.g. Hawaii
+\ingroup geometries
+
+\qbk{[include reference/geometries/multi_polygon.qbk]}
+\qbk{before.synopsis,
+[heading Model of]
+[link geometry.reference.concepts.concept_multi_polygon MultiPolygon Concept]
+}
+*/
+template
+<
+    typename Polygon,
+    template<typename, typename> class Container = std::vector,
+    template<typename> class Allocator = std::allocator
+>
+class multi_polygon : public Container<Polygon, Allocator<Polygon> >
+{
+    BOOST_CONCEPT_ASSERT( (concepts::Polygon<Polygon>) );
+
+#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+
+    // default constructor and base_type definitions are required only
+    // if the constructor taking std::initializer_list is defined
+
+    typedef Container<Polygon, Allocator<Polygon> > base_type;
+
+public:
+    /// \constructor_default{multi_polygon}
+    multi_polygon()
+        : base_type()
+    {}
+
+    /// \constructor_initializer_list{multi_polygon}
+    inline multi_polygon(std::initializer_list<Polygon> l)
+        : base_type(l.begin(), l.end())
+    {}
+
+// Commented out for now in order to support Boost.Assign
+// Without this assignment operator first the object should be created
+//   from initializer list, then it shoudl be moved.
+//// Without this workaround in MSVC the assignment operator is ambiguous
+//#ifndef BOOST_MSVC
+//    /// \assignment_initializer_list{multi_polygon}
+//    inline multi_polygon & operator=(std::initializer_list<Polygon> l)
+//    {
+//        base_type::assign(l.begin(), l.end());
+//        return *this;
+//    }
+//#endif
+
+#endif
+};
+
+
+} // namespace model
+
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+template
+<
+    typename Polygon,
+    template<typename, typename> class Container,
+    template<typename> class Allocator
+>
+struct tag< model::multi_polygon<Polygon, Container, Allocator> >
+{
+    typedef multi_polygon_tag type;
+};
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_MULTI_POLYGON_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/point.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/point.hpp
new file mode 100644
index 00000000000..70bfeed447b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/point.hpp
@@ -0,0 +1,303 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_POINT_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_POINT_HPP
+
+#include <cstddef>
+
+#include <boost/config.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/int.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/coordinate_system.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+
+#if defined(BOOST_GEOMETRY_ENABLE_ACCESS_DEBUGGING)
+#include <algorithm>
+#include <boost/geometry/core/assert.hpp>
+#endif
+
+namespace boost { namespace geometry
+{
+
+// Silence warning C4127: conditional expression is constant
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4127)
+#endif
+
+
+namespace model
+{
+
+namespace detail
+{
+
+template <std::size_t DimensionCount, std::size_t Index>
+struct array_assign
+{
+    template <typename T>
+    static inline void apply(T values[], T const& value)
+    {
+        values[Index] = value;
+    }
+};
+
+// Specialization avoiding assigning element [2] for only 2 dimensions
+template <> struct array_assign<2, 2>
+{
+    template <typename T> static inline void apply(T [], T const& ) {}
+};
+
+// Specialization avoiding assigning elements for (rarely used) points in 1 dim
+template <> struct array_assign<1, 1>
+{
+    template <typename T> static inline void apply(T [], T const& ) {}
+};
+
+template <> struct array_assign<1, 2>
+{
+    template <typename T> static inline void apply(T [], T const& ) {}
+};
+
+}
+/*!
+\brief Basic point class, having coordinates defined in a neutral way
+\details Defines a neutral point class, fulfilling the Point Concept.
+    Library users can use this point class, or use their own point classes.
+    This point class is used in most of the samples and tests of Boost.Geometry
+    This point class is used occasionally within the library, where a temporary
+    point class is necessary.
+\ingroup geometries
+\tparam CoordinateType \tparam_numeric
+\tparam DimensionCount number of coordinates, usually 2 or 3
+\tparam CoordinateSystem coordinate system, for example cs::cartesian
+
+\qbk{[include reference/geometries/point.qbk]}
+\qbk{before.synopsis, [heading Model of]}
+\qbk{before.synopsis, [link geometry.reference.concepts.concept_point Point Concept]}
+
+
+*/
+template
+<
+    typename CoordinateType,
+    std::size_t DimensionCount,
+    typename CoordinateSystem
+>
+class point
+{
+    BOOST_MPL_ASSERT_MSG((DimensionCount >= 1),
+                         DIMENSION_GREATER_THAN_ZERO_EXPECTED,
+                         (boost::mpl::int_<DimensionCount>));
+
+    // The following enum is used to fully instantiate the
+    // CoordinateSystem class and check the correctness of the units
+    // passed for non-Cartesian coordinate systems.
+    enum { cs_check = sizeof(CoordinateSystem) };
+
+public:
+
+#if !defined(BOOST_GEOMETRY_ENABLE_ACCESS_DEBUGGING)
+#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS)
+    /// \constructor_default_no_init
+    point() = default;
+#else
+    /// \constructor_default_no_init
+    inline point()
+    {}
+#endif
+#else // defined(BOOST_GEOMETRY_ENABLE_ACCESS_DEBUGGING)
+    point()
+    {
+        m_created = 1;
+        std::fill_n(m_values_initialized, DimensionCount, 0);
+    }
+    ~point()
+    {
+        m_created = 0;
+        std::fill_n(m_values_initialized, DimensionCount, 0);
+    }
+#endif
+
+    /// @brief Constructor to set one value
+    explicit inline point(CoordinateType const& v0)
+    {
+        detail::array_assign<DimensionCount, 0>::apply(m_values, v0);
+        detail::array_assign<DimensionCount, 1>::apply(m_values, CoordinateType());
+        detail::array_assign<DimensionCount, 2>::apply(m_values, CoordinateType());
+
+#if defined(BOOST_GEOMETRY_ENABLE_ACCESS_DEBUGGING)
+        m_created = 1;
+        std::fill_n(m_values_initialized, (std::min)(std::size_t(3), DimensionCount), 1);
+#endif
+    }
+
+    /// @brief Constructor to set two values
+    inline point(CoordinateType const& v0, CoordinateType const& v1)
+    {
+        detail::array_assign<DimensionCount, 0>::apply(m_values, v0);
+        detail::array_assign<DimensionCount, 1>::apply(m_values, v1);
+        detail::array_assign<DimensionCount, 2>::apply(m_values, CoordinateType());
+
+#if defined(BOOST_GEOMETRY_ENABLE_ACCESS_DEBUGGING)
+        m_created = 1;
+        std::fill_n(m_values_initialized, (std::min)(std::size_t(3), DimensionCount), 1);
+#endif
+    }
+
+    /// @brief Constructor to set three values
+    inline point(CoordinateType const& v0, CoordinateType const& v1,
+            CoordinateType const& v2)
+    {
+        detail::array_assign<DimensionCount, 0>::apply(m_values, v0);
+        detail::array_assign<DimensionCount, 1>::apply(m_values, v1);
+        detail::array_assign<DimensionCount, 2>::apply(m_values, v2);
+
+#if defined(BOOST_GEOMETRY_ENABLE_ACCESS_DEBUGGING)
+        m_created = 1;
+        std::fill_n(m_values_initialized, (std::min)(std::size_t(3), DimensionCount), 1);
+#endif
+    }
+
+    /// @brief Get a coordinate
+    /// @tparam K coordinate to get
+    /// @return the coordinate
+    template <std::size_t K>
+    inline CoordinateType const& get() const
+    {
+#if defined(BOOST_GEOMETRY_ENABLE_ACCESS_DEBUGGING)
+        BOOST_GEOMETRY_ASSERT(m_created == 1);
+        BOOST_GEOMETRY_ASSERT(m_values_initialized[K] == 1);
+#endif
+        BOOST_STATIC_ASSERT(K < DimensionCount);
+        return m_values[K];
+    }
+
+    /// @brief Set a coordinate
+    /// @tparam K coordinate to set
+    /// @param value value to set
+    template <std::size_t K>
+    inline void set(CoordinateType const& value)
+    {
+#if defined(BOOST_GEOMETRY_ENABLE_ACCESS_DEBUGGING)
+        BOOST_GEOMETRY_ASSERT(m_created == 1);
+        m_values_initialized[K] = 1;
+#endif
+        BOOST_STATIC_ASSERT(K < DimensionCount);
+        m_values[K] = value;
+    }
+
+private:
+
+    CoordinateType m_values[DimensionCount];
+
+#if defined(BOOST_GEOMETRY_ENABLE_ACCESS_DEBUGGING)
+    int m_created;
+    int m_values_initialized[DimensionCount];
+#endif
+};
+
+
+} // namespace model
+
+// Adapt the point to the concept
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+template
+<
+    typename CoordinateType,
+    std::size_t DimensionCount,
+    typename CoordinateSystem
+>
+struct tag<model::point<CoordinateType, DimensionCount, CoordinateSystem> >
+{
+    typedef point_tag type;
+};
+
+template
+<
+    typename CoordinateType,
+    std::size_t DimensionCount,
+    typename CoordinateSystem
+>
+struct coordinate_type<model::point<CoordinateType, DimensionCount, CoordinateSystem> >
+{
+    typedef CoordinateType type;
+};
+
+template
+<
+    typename CoordinateType,
+    std::size_t DimensionCount,
+    typename CoordinateSystem
+>
+struct coordinate_system<model::point<CoordinateType, DimensionCount, CoordinateSystem> >
+{
+    typedef CoordinateSystem type;
+};
+
+template
+<
+    typename CoordinateType,
+    std::size_t DimensionCount,
+    typename CoordinateSystem
+>
+struct dimension<model::point<CoordinateType, DimensionCount, CoordinateSystem> >
+    : boost::mpl::int_<DimensionCount>
+{};
+
+template
+<
+    typename CoordinateType,
+    std::size_t DimensionCount,
+    typename CoordinateSystem,
+    std::size_t Dimension
+>
+struct access<model::point<CoordinateType, DimensionCount, CoordinateSystem>, Dimension>
+{
+    static inline CoordinateType get(
+        model::point<CoordinateType, DimensionCount, CoordinateSystem> const& p)
+    {
+        return p.template get<Dimension>();
+    }
+
+    static inline void set(
+        model::point<CoordinateType, DimensionCount, CoordinateSystem>& p,
+        CoordinateType const& value)
+    {
+        p.template set<Dimension>(value);
+    }
+};
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_POINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/point_xy.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/point_xy.hpp
new file mode 100644
index 00000000000..bbc35d5cecb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/point_xy.hpp
@@ -0,0 +1,134 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_POINT_XY_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_POINT_XY_HPP
+
+#include <cstddef>
+
+#include <boost/config.hpp>
+#include <boost/mpl/int.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/geometries/point.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace model { namespace d2
+{
+
+/*!
+\brief 2D point in Cartesian coordinate system
+\tparam CoordinateType numeric type, for example, double, float, int
+\tparam CoordinateSystem coordinate system, defaults to cs::cartesian
+
+\qbk{[include reference/geometries/point_xy.qbk]}
+\qbk{before.synopsis,
+[heading Model of]
+[link geometry.reference.concepts.concept_point Point Concept]
+}
+
+\qbk{[include reference/geometries/point_assign_warning.qbk]}
+
+*/
+template<typename CoordinateType, typename CoordinateSystem = cs::cartesian>
+class point_xy : public model::point<CoordinateType, 2, CoordinateSystem>
+{
+public:
+
+#ifndef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+    /// \constructor_default_no_init
+    point_xy() = default;
+#else
+    /// \constructor_default_no_init
+    inline point_xy()
+    {}
+#endif
+
+    /// Constructor with x/y values
+    inline point_xy(CoordinateType const& x, CoordinateType const& y)
+        : model::point<CoordinateType, 2, CoordinateSystem>(x, y)
+    {}
+
+    /// Get x-value
+    inline CoordinateType const& x() const
+    { return this->template get<0>(); }
+
+    /// Get y-value
+    inline CoordinateType const& y() const
+    { return this->template get<1>(); }
+
+    /// Set x-value
+    inline void x(CoordinateType const& v)
+    { this->template set<0>(v); }
+
+    /// Set y-value
+    inline void y(CoordinateType const& v)
+    { this->template set<1>(v); }
+};
+
+
+}} // namespace model::d2
+
+
+// Adapt the point_xy to the concept
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+template <typename CoordinateType, typename CoordinateSystem>
+struct tag<model::d2::point_xy<CoordinateType, CoordinateSystem> >
+{
+    typedef point_tag type;
+};
+
+template<typename CoordinateType, typename CoordinateSystem>
+struct coordinate_type<model::d2::point_xy<CoordinateType, CoordinateSystem> >
+{
+    typedef CoordinateType type;
+};
+
+template<typename CoordinateType, typename CoordinateSystem>
+struct coordinate_system<model::d2::point_xy<CoordinateType, CoordinateSystem> >
+{
+    typedef CoordinateSystem type;
+};
+
+template<typename CoordinateType, typename CoordinateSystem>
+struct dimension<model::d2::point_xy<CoordinateType, CoordinateSystem> >
+    : boost::mpl::int_<2>
+{};
+
+template<typename CoordinateType, typename CoordinateSystem, std::size_t Dimension>
+struct access<model::d2::point_xy<CoordinateType, CoordinateSystem>, Dimension >
+{
+    static inline CoordinateType get(
+        model::d2::point_xy<CoordinateType, CoordinateSystem> const& p)
+    {
+        return p.template get<Dimension>();
+    }
+
+    static inline void set(model::d2::point_xy<CoordinateType, CoordinateSystem>& p,
+        CoordinateType const& value)
+    {
+        p.template set<Dimension>(value);
+    }
+};
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_POINT_XY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/pointing_segment.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/pointing_segment.hpp
new file mode 100644
index 00000000000..f865a8a8c10
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/pointing_segment.hpp
@@ -0,0 +1,142 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_POINTING_SEGMENT_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_POINTING_SEGMENT_HPP
+
+#include <cstddef>
+
+#include <boost/concept/assert.hpp>
+#include <boost/core/addressof.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace model
+{
+
+// const or non-const segment type that is meant to be
+// * default constructible
+// * copy constructible
+// * assignable
+// referring_segment does not fit these requirements, hence the
+// pointing_segment class
+//
+// this class is used by the segment_iterator as its value type
+template <typename ConstOrNonConstPoint>
+class pointing_segment
+{
+    BOOST_CONCEPT_ASSERT( (
+        typename boost::mpl::if_
+            <
+                boost::is_const<ConstOrNonConstPoint>,
+                concepts::Point<ConstOrNonConstPoint>,
+                concepts::ConstPoint<ConstOrNonConstPoint>
+            >
+    ) );
+
+    typedef ConstOrNonConstPoint point_type;
+
+public:
+    point_type* first;
+    point_type* second;
+
+    inline pointing_segment()
+        : first(NULL)
+        , second(NULL)
+    {}
+
+    inline pointing_segment(point_type const& p1, point_type const& p2)
+        : first(boost::addressof(p1))
+        , second(boost::addressof(p2))
+    {}
+};
+
+
+} // namespace model
+
+
+// Traits specializations for segment above
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+template <typename Point>
+struct tag<model::pointing_segment<Point> >
+{
+    typedef segment_tag type;
+};
+
+template <typename Point>
+struct point_type<model::pointing_segment<Point> >
+{
+    typedef Point type;
+};
+
+template <typename Point, std::size_t Dimension>
+struct indexed_access<model::pointing_segment<Point>, 0, Dimension>
+{
+    typedef model::pointing_segment<Point> segment_type;
+    typedef typename geometry::coordinate_type
+        <
+            segment_type
+        >::type coordinate_type;
+
+    static inline coordinate_type get(segment_type const& s)
+    {
+        BOOST_GEOMETRY_ASSERT( s.first != NULL );
+        return geometry::get<Dimension>(*s.first);
+    }
+
+    static inline void set(segment_type& s, coordinate_type const& value)
+    {
+        BOOST_GEOMETRY_ASSERT( s.first != NULL );
+        geometry::set<Dimension>(*s.first, value);
+    }
+};
+
+
+template <typename Point, std::size_t Dimension>
+struct indexed_access<model::pointing_segment<Point>, 1, Dimension>
+{
+    typedef model::pointing_segment<Point> segment_type;
+    typedef typename geometry::coordinate_type
+        <
+            segment_type
+        >::type coordinate_type;
+
+    static inline coordinate_type get(segment_type const& s)
+    {
+        BOOST_GEOMETRY_ASSERT( s.second != NULL );
+        return geometry::get<Dimension>(*s.second);
+    }
+
+    static inline void set(segment_type& s, coordinate_type const& value)
+    {
+        BOOST_GEOMETRY_ASSERT( s.second != NULL );
+        geometry::set<Dimension>(*s.second, value);
+    }
+};
+
+
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_POINTING_SEGMENT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/polygon.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/polygon.hpp
new file mode 100644
index 00000000000..5d8a0f21f7e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/polygon.hpp
@@ -0,0 +1,367 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_POLYGON_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_POLYGON_HPP
+
+#include <memory>
+#include <vector>
+
+#include <boost/concept/assert.hpp>
+
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+#include <boost/geometry/geometries/ring.hpp>
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#include <initializer_list>
+#endif
+
+namespace boost { namespace geometry
+{
+
+namespace model
+{
+
+/*!
+\brief The polygon contains an outer ring and zero or more inner rings.
+\ingroup geometries
+\tparam Point point type
+\tparam ClockWise true for clockwise direction,
+            false for CounterClockWise direction
+\tparam Closed true for closed polygons (last point == first point),
+            false open points
+\tparam PointList container type for points,
+            for example std::vector, std::list, std::deque
+\tparam RingList container type for inner rings,
+            for example std::vector, std::list, std::deque
+\tparam PointAlloc container-allocator-type, for the points
+\tparam RingAlloc container-allocator-type, for the rings
+\note The container collecting the points in the rings can be different
+    from the container collecting the inner rings. They all default to vector.
+
+\qbk{[include reference/geometries/polygon.qbk]}
+\qbk{before.synopsis,
+[heading Model of]
+[link geometry.reference.concepts.concept_polygon Polygon Concept]
+}
+
+
+*/
+template
+<
+    typename Point,
+    bool ClockWise = true,
+    bool Closed = true,
+    template<typename, typename> class PointList = std::vector,
+    template<typename, typename> class RingList = std::vector,
+    template<typename> class PointAlloc = std::allocator,
+    template<typename> class RingAlloc = std::allocator
+>
+class polygon
+{
+    BOOST_CONCEPT_ASSERT( (concepts::Point<Point>) );
+
+public:
+
+    // Member types
+    typedef Point point_type;
+    typedef ring<Point, ClockWise, Closed, PointList, PointAlloc> ring_type;
+    typedef RingList<ring_type , RingAlloc<ring_type > > inner_container_type;
+
+    inline ring_type const& outer() const { return m_outer; }
+    inline inner_container_type const& inners() const { return m_inners; }
+
+    inline ring_type& outer() { return m_outer; }
+    inline inner_container_type & inners() { return m_inners; }
+
+#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+
+    // default constructor definition is required only
+    // if the constructor taking std::initializer_list is defined
+
+    /// \constructor_default{polygon}
+    inline polygon()
+        : m_outer()
+        , m_inners()
+    {}
+
+    /// \constructor_initializer_list{polygon}
+    inline polygon(std::initializer_list<ring_type> l)
+        : m_outer(l.size() > 0 ? *l.begin() : ring_type())
+        , m_inners(l.size() > 0 ? l.begin() + 1 : l.begin(), l.end())
+    {}
+
+// Commented out for now in order to support Boost.Assign
+// Without this assignment operator first the object should be created
+//   from initializer list, then it shoudl be moved.
+//// Without this workaround in MSVC the assignment operator is ambiguous
+//#ifndef BOOST_MSVC
+//    /// \assignment_initializer_list{polygon}
+//    inline polygon & operator=(std::initializer_list<ring_type> l)
+//    {
+//        if ( l.size() > 0 )
+//        {
+//            m_outer = *l.begin();
+//            m_inners.assign(l.begin() + 1, l.end());
+//        }
+//        else
+//        {
+//            m_outer.clear();
+//            m_inners.clear();
+//        }
+//        return *this;
+//    }
+//#endif
+
+#endif
+
+    /// Utility method, clears outer and inner rings
+    inline void clear()
+    {
+        m_outer.clear();
+        m_inners.clear();
+    }
+
+private:
+
+    ring_type m_outer;
+    inner_container_type m_inners;
+};
+
+
+} // namespace model
+
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+template
+<
+    typename Point,
+    bool ClockWise, bool Closed,
+    template<typename, typename> class PointList,
+    template<typename, typename> class RingList,
+    template<typename> class PointAlloc,
+    template<typename> class RingAlloc
+>
+struct tag
+<
+    model::polygon
+        <
+            Point, ClockWise, Closed,
+            PointList, RingList, PointAlloc, RingAlloc
+        >
+>
+{
+    typedef polygon_tag type;
+};
+
+template
+<
+    typename Point,
+    bool ClockWise, bool Closed,
+    template<typename, typename> class PointList,
+    template<typename, typename> class RingList,
+    template<typename> class PointAlloc,
+    template<typename> class RingAlloc
+>
+struct ring_const_type
+<
+    model::polygon
+        <
+            Point, ClockWise, Closed,
+            PointList, RingList, PointAlloc, RingAlloc
+        >
+>
+{
+    typedef typename model::polygon
+        <
+            Point, ClockWise, Closed,
+            PointList, RingList,
+            PointAlloc, RingAlloc
+        >::ring_type const& type;
+};
+
+
+template
+<
+    typename Point,
+    bool ClockWise, bool Closed,
+    template<typename, typename> class PointList,
+    template<typename, typename> class RingList,
+    template<typename> class PointAlloc,
+    template<typename> class RingAlloc
+>
+struct ring_mutable_type
+<
+    model::polygon
+        <
+            Point, ClockWise, Closed,
+            PointList, RingList, PointAlloc, RingAlloc
+        >
+>
+{
+    typedef typename model::polygon
+        <
+            Point, ClockWise, Closed,
+            PointList, RingList,
+            PointAlloc, RingAlloc
+        >::ring_type& type;
+};
+
+template
+<
+    typename Point,
+    bool ClockWise, bool Closed,
+    template<typename, typename> class PointList,
+    template<typename, typename> class RingList,
+    template<typename> class PointAlloc,
+    template<typename> class RingAlloc
+>
+struct interior_const_type
+<
+    model::polygon
+        <
+            Point, ClockWise, Closed,
+            PointList, RingList,
+            PointAlloc, RingAlloc
+        >
+>
+{
+    typedef typename model::polygon
+        <
+            Point, ClockWise, Closed,
+            PointList, RingList,
+            PointAlloc, RingAlloc
+        >::inner_container_type const& type;
+};
+
+
+template
+<
+    typename Point,
+    bool ClockWise, bool Closed,
+    template<typename, typename> class PointList,
+    template<typename, typename> class RingList,
+    template<typename> class PointAlloc,
+    template<typename> class RingAlloc
+>
+struct interior_mutable_type
+<
+    model::polygon
+        <
+            Point, ClockWise, Closed,
+            PointList, RingList,
+            PointAlloc, RingAlloc
+        >
+>
+{
+    typedef typename model::polygon
+        <
+            Point, ClockWise, Closed,
+            PointList, RingList,
+            PointAlloc, RingAlloc
+        >::inner_container_type& type;
+};
+
+
+template
+<
+    typename Point,
+    bool ClockWise, bool Closed,
+    template<typename, typename> class PointList,
+    template<typename, typename> class RingList,
+    template<typename> class PointAlloc,
+    template<typename> class RingAlloc
+>
+struct exterior_ring
+<
+    model::polygon
+        <
+            Point, ClockWise, Closed,
+            PointList, RingList, PointAlloc, RingAlloc
+        >
+>
+{
+    typedef model::polygon
+        <
+            Point, ClockWise, Closed,
+            PointList, RingList,
+            PointAlloc, RingAlloc
+        > polygon_type;
+
+    static inline typename polygon_type::ring_type& get(polygon_type& p)
+    {
+        return p.outer();
+    }
+
+    static inline typename polygon_type::ring_type const& get(
+                    polygon_type const& p)
+    {
+        return p.outer();
+    }
+};
+
+template
+<
+    typename Point,
+    bool ClockWise, bool Closed,
+    template<typename, typename> class PointList,
+    template<typename, typename> class RingList,
+    template<typename> class PointAlloc,
+    template<typename> class RingAlloc
+>
+struct interior_rings
+<
+    model::polygon
+        <
+            Point, ClockWise, Closed,
+            PointList, RingList,
+            PointAlloc, RingAlloc
+        >
+>
+{
+    typedef model::polygon
+        <
+            Point, ClockWise, Closed, PointList, RingList,
+            PointAlloc, RingAlloc
+        > polygon_type;
+
+    static inline typename polygon_type::inner_container_type& get(
+                    polygon_type& p)
+    {
+        return p.inners();
+    }
+
+    static inline typename polygon_type::inner_container_type const& get(
+                    polygon_type const& p)
+    {
+        return p.inners();
+    }
+};
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_POLYGON_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/box.hpp
new file mode 100644
index 00000000000..71a7077a662
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/box.hpp
@@ -0,0 +1,179 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_REGISTER_BOX_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_REGISTER_BOX_HPP
+
+
+#ifndef DOXYGEN_NO_SPECIALIZATIONS
+
+
+#define BOOST_GEOMETRY_DETAIL_SPECIALIZE_BOX_ACCESS(Box, Point, MinCorner, MaxCorner) \
+template <size_t D> \
+struct indexed_access<Box, min_corner, D> \
+{ \
+    typedef typename coordinate_type<Point>::type ct; \
+    static inline ct get(Box const& b) \
+    { return geometry::get<D>(b. MinCorner);  } \
+    static inline void set(Box& b, ct const& value) \
+    { geometry::set<D>(b. MinCorner, value);  } \
+}; \
+template <size_t D> \
+struct indexed_access<Box, max_corner, D> \
+{ \
+    typedef typename coordinate_type<Point>::type ct; \
+    static inline ct get(Box const& b) \
+    { return geometry::get<D>(b. MaxCorner);  } \
+    static inline void set(Box& b, ct const& value) \
+    { geometry::set<D>(b. MaxCorner, value);  } \
+};
+
+
+#define BOOST_GEOMETRY_DETAIL_SPECIALIZE_BOX_ACCESS_TEMPLATED(Box, MinCorner, MaxCorner) \
+template <typename P, size_t D> \
+struct indexed_access<Box<P>, min_corner, D> \
+{ \
+    typedef typename coordinate_type<P>::type ct; \
+    static inline ct get(Box<P> const& b) \
+    { return geometry::get<D>(b. MinCorner);  } \
+    static inline void set(Box<P>& b, ct const& value) \
+    { geometry::set<D>(b. MinCorner, value);  } \
+}; \
+template <typename P, size_t D> \
+struct indexed_access<Box<P>, max_corner, D> \
+{ \
+    typedef typename coordinate_type<P>::type ct; \
+    static inline ct get(Box<P> const& b) \
+    { return geometry::get<D>(b. MaxCorner);  } \
+    static inline void set(Box<P>& b, ct const& value) \
+    { geometry::set<D>(b. MaxCorner, value);  } \
+};
+
+
+#define BOOST_GEOMETRY_DETAIL_SPECIALIZE_BOX_ACCESS_4VALUES(Box, Point, Left, Bottom, Right, Top) \
+template <> struct indexed_access<Box, min_corner, 0> \
+{ \
+    typedef coordinate_type<Point>::type ct; \
+    static inline ct get(Box const& b) { return b. Left;  } \
+    static inline void set(Box& b, ct const& value) { b. Left = value; } \
+}; \
+template <> struct indexed_access<Box, min_corner, 1> \
+{ \
+    typedef coordinate_type<Point>::type ct; \
+    static inline ct get(Box const& b) { return b. Bottom;  } \
+    static inline void set(Box& b, ct const& value) { b. Bottom = value; } \
+}; \
+template <> struct indexed_access<Box, max_corner, 0> \
+{ \
+    typedef coordinate_type<Point>::type ct; \
+    static inline ct get(Box const& b) { return b. Right;  } \
+    static inline void set(Box& b, ct const& value) { b. Right = value; } \
+}; \
+template <> struct indexed_access<Box, max_corner, 1> \
+{ \
+    typedef coordinate_type<Point>::type ct; \
+    static inline ct get(Box const& b) { return b. Top; } \
+    static inline void set(Box& b, ct const& value) { b. Top = value; } \
+};
+
+
+
+
+#define BOOST_GEOMETRY_DETAIL_SPECIALIZE_BOX_TRAITS(Box, PointType) \
+    template<> struct tag<Box > { typedef box_tag type; }; \
+    template<> struct point_type<Box > { typedef PointType type; };
+
+#define BOOST_GEOMETRY_DETAIL_SPECIALIZE_BOX_TRAITS_TEMPLATED(Box) \
+    template<typename P> struct tag<Box<P> > { typedef box_tag type; }; \
+    template<typename P> struct point_type<Box<P> > { typedef P type; };
+
+#endif // DOXYGEN_NO_SPECIALIZATIONS
+
+
+
+/*!
+\brief \brief_macro{box}
+\ingroup register
+\details \details_macro{BOOST_GEOMETRY_REGISTER_BOX, box} The
+    box may contain template parameters, which must be specified then.
+\param Box \param_macro_type{Box}
+\param Point Point type on which box is based. Might be two or three-dimensional
+\param MinCorner minimum corner (should be public member or method)
+\param MaxCorner maximum corner (should be public member or method)
+
+\qbk{
+[heading Example]
+[register_box]
+[register_box_output]
+}
+*/
+#define BOOST_GEOMETRY_REGISTER_BOX(Box, Point, MinCorner, MaxCorner) \
+namespace boost { namespace geometry { namespace traits {  \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_BOX_TRAITS(Box, Point) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_BOX_ACCESS(Box, Point, MinCorner, MaxCorner) \
+}}}
+
+
+/*!
+\brief \brief_macro{box}
+\ingroup register
+\details \details_macro{BOOST_GEOMETRY_REGISTER_BOX_TEMPLATED, box}
+    \details_macro_templated{box, point}
+\param Box \param_macro_type{Box}
+\param MinCorner minimum corner (should be public member or method)
+\param MaxCorner maximum corner (should be public member or method)
+
+\qbk{
+[heading Example]
+[register_box_templated]
+[register_box_templated_output]
+}
+*/
+#define BOOST_GEOMETRY_REGISTER_BOX_TEMPLATED(Box, MinCorner, MaxCorner) \
+namespace boost { namespace geometry { namespace traits {  \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_BOX_TRAITS_TEMPLATED(Box) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_BOX_ACCESS_TEMPLATED(Box, MinCorner, MaxCorner) \
+}}}
+
+/*!
+\brief \brief_macro{box}
+\ingroup register
+\details \details_macro{BOOST_GEOMETRY_REGISTER_BOX_2D_4VALUES, box}
+\param Box \param_macro_type{Box}
+\param Point Point type reported as point_type by box. Must be two dimensional.
+    Note that these box tyeps do not contain points, but they must have a
+    related point_type
+\param Left Left side (must be public member or method)
+\param Bottom Bottom side (must be public member or method)
+\param Right Right side (must be public member or method)
+\param Top Top side (must be public member or method)
+
+\qbk{
+[heading Example]
+[register_box_2d_4values]
+[register_box_2d_4values_output]
+}
+*/
+#define BOOST_GEOMETRY_REGISTER_BOX_2D_4VALUES(Box, Point, Left, Bottom, Right, Top) \
+namespace boost { namespace geometry { namespace traits {  \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_BOX_TRAITS(Box, Point) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_BOX_ACCESS_4VALUES(Box, Point, Left, Bottom, Right, Top) \
+}}}
+
+
+
+// CONST versions are for boxes probably not that common. Postponed.
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_REGISTER_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/linestring.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/linestring.hpp
new file mode 100644
index 00000000000..cfc7dcaed25
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/linestring.hpp
@@ -0,0 +1,60 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_REGISTER_LINESTRING_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_REGISTER_LINESTRING_HPP
+
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+/*!
+\brief \brief_macro{linestring}
+\ingroup register
+\details \details_macro{BOOST_GEOMETRY_REGISTER_LINESTRING, linestring} The
+    linestring may contain template parameters, which must be specified then.
+\param Linestring \param_macro_type{linestring}
+
+\qbk{
+[heading Example]
+[register_linestring]
+[register_linestring_output]
+}
+*/
+#define BOOST_GEOMETRY_REGISTER_LINESTRING(Linestring) \
+namespace boost { namespace geometry { namespace traits {  \
+    template<> struct tag<Linestring> { typedef linestring_tag type; }; \
+}}}
+
+
+/*!
+\brief \brief_macro{templated linestring}
+\ingroup register
+\details \details_macro{BOOST_GEOMETRY_REGISTER_LINESTRING_TEMPLATED, templated linestring}
+    \details_macro_templated{linestring, point}
+\param Linestring \param_macro_type{linestring (without template parameters)}
+
+\qbk{
+[heading Example]
+[register_linestring_templated]
+[register_linestring_templated_output]
+}
+*/
+#define BOOST_GEOMETRY_REGISTER_LINESTRING_TEMPLATED(Linestring) \
+namespace boost { namespace geometry { namespace traits {  \
+    template<typename P> struct tag< Linestring<P> > { typedef linestring_tag type; }; \
+}}}
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_REGISTER_LINESTRING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/multi_linestring.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/multi_linestring.hpp
new file mode 100644
index 00000000000..ad11289d11a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/multi_linestring.hpp
@@ -0,0 +1,59 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_REGISTER_MULTI_LINESTRING_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_REGISTER_MULTI_LINESTRING_HPP
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+/*!
+\brief \brief_macro{multi_linestring}
+\ingroup register
+\details \details_macro{BOOST_GEOMETRY_REGISTER_MULTI_LINESTRING, multi_linestring} The
+    multi_linestring may contain template parameters, which must be specified then.
+\param MultiLineString \param_macro_type{multi_linestring}
+
+\qbk{
+[heading Example]
+[register_multi_linestring]
+[register_multi_linestring_output]
+}
+*/
+#define BOOST_GEOMETRY_REGISTER_MULTI_LINESTRING(MultiLineString) \
+namespace boost { namespace geometry { namespace traits {  \
+    template<> struct tag<MultiLineString> { typedef multi_linestring_tag type; }; \
+}}}
+
+
+/*!
+\brief \brief_macro{templated multi_linestring}
+\ingroup register
+\details \details_macro{BOOST_GEOMETRY_REGISTER_MULTI_LINESTRING_TEMPLATED, templated multi_linestring}
+    \details_macro_templated{multi_linestring, linestring}
+\param MultiLineString \param_macro_type{multi_linestring (without template parameters)}
+
+\qbk{
+[heading Example]
+[register_multi_linestring_templated]
+[register_multi_linestring_templated_output]
+}
+*/
+#define BOOST_GEOMETRY_REGISTER_MULTI_LINESTRING_TEMPLATED(MultiLineString) \
+namespace boost { namespace geometry { namespace traits {  \
+    template<typename LineString> struct tag< MultiLineString<LineString> > { typedef multi_linestring_tag type; }; \
+}}}
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_REGISTER_MULTI_LINESTRING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/multi_point.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/multi_point.hpp
new file mode 100644
index 00000000000..4e875ae0cd2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/multi_point.hpp
@@ -0,0 +1,59 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_REGISTER_MULTI_POINT_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_REGISTER_MULTI_POINT_HPP
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+/*!
+\brief \brief_macro{multi_point}
+\ingroup register
+\details \details_macro{BOOST_GEOMETRY_REGISTER_MULTI_POINT, multi_point} The
+    multi_point may contain template parameters, which must be specified then.
+\param MultiPoint \param_macro_type{multi_point}
+
+\qbk{
+[heading Example]
+[register_multi_point]
+[register_multi_point_output]
+}
+*/
+#define BOOST_GEOMETRY_REGISTER_MULTI_POINT(MultiPoint) \
+namespace boost { namespace geometry { namespace traits {  \
+    template<> struct tag<MultiPoint> { typedef multi_point_tag type; }; \
+}}}
+
+
+/*!
+\brief \brief_macro{templated multi_point}
+\ingroup register
+\details \details_macro{BOOST_GEOMETRY_REGISTER_MULTI_POINT_TEMPLATED, templated multi_point}
+    \details_macro_templated{multi_point, point}
+\param MultiPoint \param_macro_type{multi_point (without template parameters)}
+
+\qbk{
+[heading Example]
+[register_multi_point_templated]
+[register_multi_point_templated_output]
+}
+*/
+#define BOOST_GEOMETRY_REGISTER_MULTI_POINT_TEMPLATED(MultiPoint) \
+namespace boost { namespace geometry { namespace traits {  \
+    template<typename Point> struct tag< MultiPoint<Point> > { typedef multi_point_tag type; }; \
+}}}
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_REGISTER_MULTI_POINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/multi_polygon.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/multi_polygon.hpp
new file mode 100644
index 00000000000..1c3818b551e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/multi_polygon.hpp
@@ -0,0 +1,59 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_REGISTER_MULTI_POLYGON_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_REGISTER_MULTI_POLYGON_HPP
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+/*!
+\brief \brief_macro{multi_polygon}
+\ingroup register
+\details \details_macro{BOOST_GEOMETRY_REGISTER_MULTI_POLYGON, multi_polygon} The
+    multi_polygon may contain template parameters, which must be specified then.
+\param MultiPolygon \param_macro_type{multi_polygon}
+
+\qbk{
+[heading Example]
+[register_multi_polygon]
+[register_multi_polygon_output]
+}
+*/
+#define BOOST_GEOMETRY_REGISTER_MULTI_POLYGON(MultiPolygon) \
+namespace boost { namespace geometry { namespace traits {  \
+    template<> struct tag<MultiPolygon> { typedef multi_polygon_tag type; }; \
+}}}
+
+
+/*!
+\brief \brief_macro{templated multi_polygon}
+\ingroup register
+\details \details_macro{BOOST_GEOMETRY_REGISTER_MULTI_POLYGON_TEMPLATED, templated multi_polygon}
+    \details_macro_templated{multi_polygon, polygon}
+\param MultiPolygon \param_macro_type{multi_polygon (without template parameters)}
+
+\qbk{
+[heading Example]
+[register_multi_polygon_templated]
+[register_multi_polygon_templated_output]
+}
+*/
+#define BOOST_GEOMETRY_REGISTER_MULTI_POLYGON_TEMPLATED(MultiPolygon) \
+namespace boost { namespace geometry { namespace traits {  \
+    template<typename Polygon> struct tag< MultiPolygon<Polygon> > { typedef multi_polygon_tag type; }; \
+}}}
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_REGISTER_MULTI_POLYGON_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/point.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/point.hpp
new file mode 100644
index 00000000000..676582576f6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/point.hpp
@@ -0,0 +1,173 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_REGISTER_POINT_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_REGISTER_POINT_HPP
+
+
+#include <cstddef>
+
+#ifndef DOXYGEN_NO_SPECIALIZATIONS
+
+// Starting point, specialize basic traits necessary to register a point
+#define BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_TRAITS(Point, Dim, CoordinateType, CoordinateSystem) \
+    template<> struct tag<Point> { typedef point_tag type; }; \
+    template<> struct dimension<Point> : boost::mpl::int_<Dim> {}; \
+    template<> struct coordinate_type<Point> { typedef CoordinateType type; }; \
+    template<> struct coordinate_system<Point> { typedef CoordinateSystem type; };
+
+// Specialize access class per dimension
+#define BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_ACCESS(Point, Dim, CoordinateType, Get, Set) \
+    template<> struct access<Point, Dim> \
+    { \
+        static inline CoordinateType get(Point const& p) { return p. Get; } \
+        static inline void set(Point& p, CoordinateType const& value) { p. Set = value; } \
+    };
+
+// Const version
+#define BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_ACCESS_CONST(Point, Dim, CoordinateType, Get) \
+    template<> struct access<Point, Dim> \
+    { \
+        static inline CoordinateType get(Point const& p) { return p. Get; } \
+    };
+
+
+// Getter/setter version
+#define BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_ACCESS_GET_SET(Point, Dim, CoordinateType, Get, Set) \
+    template<> struct access<Point, Dim> \
+    { \
+        static inline CoordinateType get(Point const& p) \
+        { return  p. Get (); } \
+        static inline void set(Point& p, CoordinateType const& value) \
+        { p. Set ( value ); } \
+    };
+
+#endif // DOXYGEN_NO_SPECIALIZATIONS
+
+
+/*!
+\brief \brief_macro{2D point type}
+\ingroup register
+\details \details_macro{BOOST_GEOMETRY_REGISTER_POINT_2D, two-dimensional point type}
+\param Point \param_macro_type{Point}
+\param CoordinateType \param_macro_coortype{point}
+\param CoordinateSystem \param_macro_coorsystem
+\param Field0 \param_macro_member{\macro_x}
+\param Field1 \param_macro_member{\macro_y}
+
+\qbk{[include reference/geometries/register/point.qbk]}
+*/
+#define BOOST_GEOMETRY_REGISTER_POINT_2D(Point, CoordinateType, CoordinateSystem, Field0, Field1) \
+namespace boost { namespace geometry { namespace traits {  \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_TRAITS(Point, 2, CoordinateType, CoordinateSystem) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_ACCESS(Point, 0, CoordinateType, Field0, Field0) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_ACCESS(Point, 1, CoordinateType, Field1, Field1) \
+}}}
+
+/*!
+\brief \brief_macro{3D point type}
+\ingroup register
+\details \details_macro{BOOST_GEOMETRY_REGISTER_POINT_3D, three-dimensional point type}
+\param Point \param_macro_type{Point}
+\param CoordinateType \param_macro_coortype{point}
+\param CoordinateSystem \param_macro_coorsystem
+\param Field0 \param_macro_member{\macro_x}
+\param Field1 \param_macro_member{\macro_y}
+\param Field2 \param_macro_member{\macro_z}
+*/
+#define BOOST_GEOMETRY_REGISTER_POINT_3D(Point, CoordinateType, CoordinateSystem, Field0, Field1, Field2) \
+namespace boost { namespace geometry { namespace traits {  \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_TRAITS(Point, 3, CoordinateType, CoordinateSystem) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_ACCESS(Point, 0, CoordinateType, Field0, Field0) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_ACCESS(Point, 1, CoordinateType, Field1, Field1) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_ACCESS(Point, 2, CoordinateType, Field2, Field2) \
+}}}
+
+/*!
+\brief \brief_macro{2D point type} \brief_macro_const
+\ingroup register
+\details \details_macro{BOOST_GEOMETRY_REGISTER_POINT_2D_CONST, two-dimensional point type}. \details_macro_const
+\param Point \param_macro_type{Point}
+\param CoordinateType \param_macro_coortype{point}
+\param CoordinateSystem \param_macro_coorsystem
+\param Field0 \param_macro_member{\macro_x}
+\param Field1 \param_macro_member{\macro_y}
+*/
+#define BOOST_GEOMETRY_REGISTER_POINT_2D_CONST(Point, CoordinateType, CoordinateSystem, Field0, Field1) \
+namespace boost { namespace geometry { namespace traits {  \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_TRAITS(Point, 2, CoordinateType, CoordinateSystem) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_ACCESS_CONST(Point, 0, CoordinateType, Field0) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_ACCESS_CONST(Point, 1, CoordinateType, Field1) \
+}}}
+
+/*!
+\brief \brief_macro{3D point type} \brief_macro_const
+\ingroup register
+\details \details_macro{BOOST_GEOMETRY_REGISTER_POINT_3D_CONST, three-dimensional point type}. \details_macro_const
+\param Point \param_macro_type{Point}
+\param CoordinateType \param_macro_coortype{point}
+\param CoordinateSystem \param_macro_coorsystem
+\param Field0 \param_macro_member{\macro_x}
+\param Field1 \param_macro_member{\macro_y}
+\param Field2 \param_macro_member{\macro_z}
+*/
+#define BOOST_GEOMETRY_REGISTER_POINT_3D_CONST(Point, CoordinateType, CoordinateSystem, Field0, Field1, Field2) \
+namespace boost { namespace geometry { namespace traits {  \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_TRAITS(Point, 3, CoordinateType, CoordinateSystem) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_ACCESS_CONST(Point, 0, CoordinateType, Field0) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_ACCESS_CONST(Point, 1, CoordinateType, Field1) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_ACCESS_CONST(Point, 2, CoordinateType, Field2) \
+}}}
+
+/*!
+\brief \brief_macro{2D point type} \brief_macro_getset
+\ingroup register
+\details \details_macro{BOOST_GEOMETRY_REGISTER_POINT_2D_GET_SET, two-dimensional point type}. \details_macro_getset
+\param Point \param_macro_type{Point}
+\param CoordinateType \param_macro_coortype{point}
+\param CoordinateSystem \param_macro_coorsystem
+\param Get0 \param_macro_getset{get, \macro_x}
+\param Get1 \param_macro_getset{get, \macro_y}
+\param Set0 \param_macro_getset{set, \macro_x}
+\param Set1 \param_macro_getset{set, \macro_y}
+*/
+#define BOOST_GEOMETRY_REGISTER_POINT_2D_GET_SET(Point, CoordinateType, CoordinateSystem, Get0, Get1, Set0, Set1) \
+namespace boost { namespace geometry { namespace traits {  \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_TRAITS(Point, 2, CoordinateType, CoordinateSystem) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_ACCESS_GET_SET(Point, 0, CoordinateType, Get0, Set0) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_ACCESS_GET_SET(Point, 1, CoordinateType, Get1, Set1) \
+}}}
+
+/*!
+\brief \brief_macro{3D point type} \brief_macro_getset
+\ingroup register
+\details \details_macro{BOOST_GEOMETRY_REGISTER_POINT_3D_GET_SET, three-dimensional point type}. \details_macro_getset
+\param Point \param_macro_type{Point}
+\param CoordinateType \param_macro_coortype{point}
+\param CoordinateSystem \param_macro_coorsystem
+\param Get0 \param_macro_getset{get, \macro_x}
+\param Get1 \param_macro_getset{get, \macro_y}
+\param Get2 \param_macro_getset{get, \macro_z}
+\param Set0 \param_macro_getset{set, \macro_x}
+\param Set1 \param_macro_getset{set, \macro_y}
+\param Set2 \param_macro_getset{set, \macro_z}
+*/
+#define BOOST_GEOMETRY_REGISTER_POINT_3D_GET_SET(Point, CoordinateType, CoordinateSystem, Get0, Get1, Get2, Set0, Set1, Set2) \
+namespace boost { namespace geometry { namespace traits {  \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_TRAITS(Point, 3, CoordinateType, CoordinateSystem) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_ACCESS_GET_SET(Point, 0, CoordinateType, Get0, Set0) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_ACCESS_GET_SET(Point, 1, CoordinateType, Get1, Set1) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_POINT_ACCESS_GET_SET(Point, 2, CoordinateType, Get2, Set2) \
+}}}
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_REGISTER_POINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/ring.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/ring.hpp
new file mode 100644
index 00000000000..761e46fbc4b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/ring.hpp
@@ -0,0 +1,60 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_REGISTER_RING_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_REGISTER_RING_HPP
+
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+/*!
+\brief \brief_macro{ring}
+\ingroup register
+\details \details_macro{BOOST_GEOMETRY_REGISTER_RING, ring} The
+    ring may contain template parameters, which must be specified then.
+\param Ring \param_macro_type{ring}
+
+\qbk{
+[heading Example]
+[register_ring]
+[register_ring_output]
+}
+*/
+#define BOOST_GEOMETRY_REGISTER_RING(Ring) \
+namespace boost { namespace geometry { namespace traits {  \
+    template<> struct tag<Ring> { typedef ring_tag type; }; \
+}}}
+
+
+/*!
+\brief \brief_macro{templated ring}
+\ingroup register
+\details \details_macro{BOOST_GEOMETRY_REGISTER_RING_TEMPLATED, templated ring}
+    \details_macro_templated{ring, point}
+\param Ring \param_macro_type{ring (without template parameters)}
+
+\qbk{
+[heading Example]
+[register_ring_templated]
+[register_ring_templated_output]
+}
+*/
+#define BOOST_GEOMETRY_REGISTER_RING_TEMPLATED(Ring) \
+namespace boost { namespace geometry { namespace traits {  \
+    template<typename P> struct tag< Ring<P> > { typedef ring_tag type; }; \
+}}}
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_REGISTER_RING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/segment.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/segment.hpp
new file mode 100644
index 00000000000..6ea88c09183
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/register/segment.hpp
@@ -0,0 +1,129 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_REGISTER_SEGMENT_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_REGISTER_SEGMENT_HPP
+
+
+#ifndef DOXYGEN_NO_SPECIALIZATIONS
+
+
+#define BOOST_GEOMETRY_DETAIL_SPECIALIZE_SEGMENT_ACCESS(Segment, Point, Index0, Index1) \
+template <size_t D> \
+struct indexed_access<Segment, min_corner, D> \
+{ \
+    typedef typename coordinate_type<Point>::type ct; \
+    static inline ct get(Segment const& b) \
+    { return geometry::get<D>(b. Index0);  } \
+    static inline void set(Segment& b, ct const& value) \
+    { geometry::set<D>(b. Index0, value);  } \
+}; \
+template <size_t D> \
+struct indexed_access<Segment, max_corner, D> \
+{ \
+    typedef typename coordinate_type<Point>::type ct; \
+    static inline ct get(Segment const& b) \
+    { return geometry::get<D>(b. Index1);  } \
+    static inline void set(Segment& b, ct const& value) \
+    { geometry::set<D>(b. Index1, value);  } \
+};
+
+
+#define BOOST_GEOMETRY_DETAIL_SPECIALIZE_SEGMENT_ACCESS_TEMPLATIZED(Segment, Index0, Index1) \
+template <typename P, size_t D> \
+struct indexed_access<Segment<P>, min_corner, D> \
+{ \
+    typedef typename coordinate_type<P>::type ct; \
+    static inline ct get(Segment<P> const& b) \
+    { return geometry::get<D>(b. Index0);  } \
+    static inline void set(Segment<P>& b, ct const& value) \
+    { geometry::set<D>(b. Index0, value);  } \
+}; \
+template <typename P, size_t D> \
+struct indexed_access<Segment<P>, max_corner, D> \
+{ \
+    typedef typename coordinate_type<P>::type ct; \
+    static inline ct get(Segment<P> const& b) \
+    { return geometry::get<D>(b. Index1);  } \
+    static inline void set(Segment<P>& b, ct const& value) \
+    { geometry::set<D>(b. Index1, value);  } \
+};
+
+
+#define BOOST_GEOMETRY_DETAIL_SPECIALIZE_SEGMENT_ACCESS_4VALUES(Segment, Point, Left, Bottom, Right, Top) \
+template <> struct indexed_access<Segment, min_corner, 0> \
+{ \
+    typedef coordinate_type<Point>::type ct; \
+    static inline ct get(Segment const& b) { return b. Left;  } \
+    static inline void set(Segment& b, ct const& value) { b. Left = value; } \
+}; \
+template <> struct indexed_access<Segment, min_corner, 1> \
+{ \
+    typedef coordinate_type<Point>::type ct; \
+    static inline ct get(Segment const& b) { return b. Bottom;  } \
+    static inline void set(Segment& b, ct const& value) { b. Bottom = value; } \
+}; \
+template <> struct indexed_access<Segment, max_corner, 0> \
+{ \
+    typedef coordinate_type<Point>::type ct; \
+    static inline ct get(Segment const& b) { return b. Right;  } \
+    static inline void set(Segment& b, ct const& value) { b. Right = value; } \
+}; \
+template <> struct indexed_access<Segment, max_corner, 1> \
+{ \
+    typedef coordinate_type<Point>::type ct; \
+    static inline ct get(Segment const& b) { return b. Top; } \
+    static inline void set(Segment& b, ct const& value) { b. Top = value; } \
+};
+
+
+
+
+#define BOOST_GEOMETRY_DETAIL_SPECIALIZE_SEGMENT_TRAITS(Segment, PointType) \
+    template<> struct tag<Segment > { typedef segment_tag type; }; \
+    template<> struct point_type<Segment > { typedef PointType type; };
+
+#define BOOST_GEOMETRY_DETAIL_SPECIALIZE_SEGMENT_TRAITS_TEMPLATIZED(Segment) \
+    template<typename P> struct tag<Segment<P> > { typedef segment_tag type; }; \
+    template<typename P> struct point_type<Segment<P> > { typedef P type; };
+
+#endif // DOXYGEN_NO_SPECIALIZATIONS
+
+
+
+#define BOOST_GEOMETRY_REGISTER_SEGMENT(Segment, PointType, Index0, Index1) \
+namespace boost { namespace geometry { namespace traits {  \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_SEGMENT_TRAITS(Segment, PointType) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_SEGMENT_ACCESS(Segment, PointType, Index0, Index1) \
+}}}
+
+
+#define BOOST_GEOMETRY_REGISTER_SEGMENT_TEMPLATIZED(Segment, Index0, Index1) \
+namespace boost { namespace geometry { namespace traits {  \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_SEGMENT_TRAITS_TEMPLATIZED(Segment) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_SEGMENT_ACCESS_TEMPLATIZED(Segment, Index0, Index1) \
+}}}
+
+#define BOOST_GEOMETRY_REGISTER_SEGMENT_2D_4VALUES(Segment, PointType, Left, Bottom, Right, Top) \
+namespace boost { namespace geometry { namespace traits {  \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_SEGMENT_TRAITS(Segment, PointType) \
+    BOOST_GEOMETRY_DETAIL_SPECIALIZE_SEGMENT_ACCESS_4VALUES(Segment, PointType, Left, Bottom, Right, Top) \
+}}}
+
+
+
+// CONST versions are for segments probably not that common. Postponed.
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_REGISTER_SEGMENT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/ring.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/ring.hpp
new file mode 100644
index 00000000000..fda0be40b4d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/ring.hpp
@@ -0,0 +1,181 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_RING_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_RING_HPP
+
+#include <memory>
+#include <vector>
+
+#include <boost/concept/assert.hpp>
+
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/point_order.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+
+#include <boost/config.hpp>
+#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+#include <initializer_list>
+#endif
+
+namespace boost { namespace geometry
+{
+
+namespace model
+{
+/*!
+\brief A ring (aka linear ring) is a closed line which should not be selfintersecting
+\ingroup geometries
+\tparam Point point type
+\tparam ClockWise true for clockwise direction,
+            false for CounterClockWise direction
+\tparam Closed true for closed polygons (last point == first point),
+            false open points
+\tparam Container container type, for example std::vector, std::deque
+\tparam Allocator container-allocator-type
+
+\qbk{[include reference/geometries/ring.qbk]}
+\qbk{before.synopsis,
+[heading Model of]
+[link geometry.reference.concepts.concept_ring Ring Concept]
+}
+*/
+template
+<
+    typename Point,
+    bool ClockWise = true, bool Closed = true,
+    template<typename, typename> class Container = std::vector,
+    template<typename> class Allocator = std::allocator
+>
+class ring : public Container<Point, Allocator<Point> >
+{
+    BOOST_CONCEPT_ASSERT( (concepts::Point<Point>) );
+
+    typedef Container<Point, Allocator<Point> > base_type;
+
+public :
+    /// \constructor_default{ring}
+    inline ring()
+        : base_type()
+    {}
+
+    /// \constructor_begin_end{ring}
+    template <typename Iterator>
+    inline ring(Iterator begin, Iterator end)
+        : base_type(begin, end)
+    {}
+
+#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
+
+    /// \constructor_initializer_list{ring}
+    inline ring(std::initializer_list<Point> l)
+        : base_type(l.begin(), l.end())
+    {}
+
+// Commented out for now in order to support Boost.Assign
+// Without this assignment operator first the object should be created
+//   from initializer list, then it shoudl be moved.
+//// Without this workaround in MSVC the assignment operator is ambiguous
+//#ifndef BOOST_MSVC
+//    /// \assignment_initializer_list{ring}
+//    inline ring & operator=(std::initializer_list<Point> l)
+//    {
+//        base_type::assign(l.begin(), l.end());
+//        return *this;
+//    }
+//#endif
+
+#endif
+};
+
+} // namespace model
+
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+template
+<
+    typename Point,
+    bool ClockWise, bool Closed,
+    template<typename, typename> class Container,
+    template<typename> class Allocator
+>
+struct tag<model::ring<Point, ClockWise, Closed, Container, Allocator> >
+{
+    typedef ring_tag type;
+};
+
+
+template
+<
+    typename Point,
+    bool Closed,
+    template<typename, typename> class Container,
+    template<typename> class Allocator
+>
+struct point_order<model::ring<Point, false, Closed, Container, Allocator> >
+{
+    static const order_selector value = counterclockwise;
+};
+
+
+template
+<
+    typename Point,
+    bool Closed,
+    template<typename, typename> class Container,
+    template<typename> class Allocator
+>
+struct point_order<model::ring<Point, true, Closed, Container, Allocator> >
+{
+    static const order_selector value = clockwise;
+};
+
+template
+<
+    typename Point,
+    bool PointOrder,
+    template<typename, typename> class Container,
+    template<typename> class Allocator
+>
+struct closure<model::ring<Point, PointOrder, true, Container, Allocator> >
+{
+    static const closure_selector value = closed;
+};
+
+template
+<
+    typename Point,
+    bool PointOrder,
+    template<typename, typename> class Container,
+    template<typename> class Allocator
+>
+struct closure<model::ring<Point, PointOrder, false, Container, Allocator> >
+{
+    static const closure_selector value = open;
+};
+
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_RING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/segment.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/segment.hpp
new file mode 100644
index 00000000000..aeb275b8583
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/segment.hpp
@@ -0,0 +1,224 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_SEGMENT_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_SEGMENT_HPP
+
+#include <cstddef>
+
+#include <boost/concept/assert.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace model
+{
+
+/*!
+\brief Class segment: small class containing two points
+\ingroup geometries
+\details From Wikipedia: In geometry, a line segment is a part of a line that is bounded
+ by two distinct end points, and contains every point on the line between its end points.
+\note There is also a point-referring-segment, class referring_segment,
+   containing point references, where points are NOT copied
+
+\qbk{[include reference/geometries/segment.qbk]}
+\qbk{before.synopsis,
+[heading Model of]
+[link geometry.reference.concepts.concept_segment Segment Concept]
+}
+*/
+template<typename Point>
+class segment : public std::pair<Point, Point>
+{
+    BOOST_CONCEPT_ASSERT( (concepts::Point<Point>) );
+
+public :
+
+#ifndef BOOST_NO_CXX11_DEFAULTED_FUNCTIONS
+    /// \constructor_default_no_init
+    segment() = default;
+#else
+    /// \constructor_default_no_init
+    inline segment()
+    {}
+#endif
+
+    /*!
+        \brief Constructor taking the first and the second point
+    */
+    inline segment(Point const& p1, Point const& p2)
+    {
+        this->first = p1;
+        this->second = p2;
+    }
+};
+
+
+/*!
+\brief Class segment: small class containing two (templatized) point references
+\ingroup geometries
+\details From Wikipedia: In geometry, a line segment is a part of a line that is bounded
+ by two distinct end points, and contains every point on the line between its end points.
+\note The structure is like std::pair, and can often be used interchangeable.
+Difference is that it refers to points, does not have points.
+\note Like std::pair, points are public available.
+\note type is const or non const, so geometry::segment<P> or geometry::segment<P const>
+\note We cannot derive from std::pair<P&, P&> because of
+reference assignments.
+\tparam ConstOrNonConstPoint point type of the segment, maybe a point or a const point
+*/
+template<typename ConstOrNonConstPoint>
+class referring_segment
+{
+    BOOST_CONCEPT_ASSERT( (
+        typename boost::mpl::if_
+            <
+                boost::is_const<ConstOrNonConstPoint>,
+                concepts::Point<ConstOrNonConstPoint>,
+                concepts::ConstPoint<ConstOrNonConstPoint>
+            >
+    ) );
+
+    typedef ConstOrNonConstPoint point_type;
+
+public:
+
+    point_type& first;
+    point_type& second;
+
+    /*!
+        \brief Constructor taking the first and the second point
+    */
+    inline referring_segment(point_type& p1, point_type& p2)
+        : first(p1)
+        , second(p2)
+    {}
+};
+
+
+} // namespace model
+
+
+// Traits specializations for segment above
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+template <typename Point>
+struct tag<model::segment<Point> >
+{
+    typedef segment_tag type;
+};
+
+template <typename Point>
+struct point_type<model::segment<Point> >
+{
+    typedef Point type;
+};
+
+template <typename Point, std::size_t Dimension>
+struct indexed_access<model::segment<Point>, 0, Dimension>
+{
+    typedef model::segment<Point> segment_type;
+    typedef typename geometry::coordinate_type<segment_type>::type coordinate_type;
+
+    static inline coordinate_type get(segment_type const& s)
+    {
+        return geometry::get<Dimension>(s.first);
+    }
+
+    static inline void set(segment_type& s, coordinate_type const& value)
+    {
+        geometry::set<Dimension>(s.first, value);
+    }
+};
+
+
+template <typename Point, std::size_t Dimension>
+struct indexed_access<model::segment<Point>, 1, Dimension>
+{
+    typedef model::segment<Point> segment_type;
+    typedef typename geometry::coordinate_type<segment_type>::type coordinate_type;
+
+    static inline coordinate_type get(segment_type const& s)
+    {
+        return geometry::get<Dimension>(s.second);
+    }
+
+    static inline void set(segment_type& s, coordinate_type const& value)
+    {
+        geometry::set<Dimension>(s.second, value);
+    }
+};
+
+
+template <typename ConstOrNonConstPoint>
+struct tag<model::referring_segment<ConstOrNonConstPoint> >
+{
+    typedef segment_tag type;
+};
+
+template <typename ConstOrNonConstPoint>
+struct point_type<model::referring_segment<ConstOrNonConstPoint> >
+{
+    typedef ConstOrNonConstPoint type;
+};
+
+template <typename ConstOrNonConstPoint, std::size_t Dimension>
+struct indexed_access<model::referring_segment<ConstOrNonConstPoint>, 0, Dimension>
+{
+    typedef model::referring_segment<ConstOrNonConstPoint> segment_type;
+    typedef typename geometry::coordinate_type<segment_type>::type coordinate_type;
+
+    static inline coordinate_type get(segment_type const& s)
+    {
+        return geometry::get<Dimension>(s.first);
+    }
+
+    static inline void set(segment_type& s, coordinate_type const& value)
+    {
+        geometry::set<Dimension>(s.first, value);
+    }
+};
+
+
+template <typename ConstOrNonConstPoint, std::size_t Dimension>
+struct indexed_access<model::referring_segment<ConstOrNonConstPoint>, 1, Dimension>
+{
+    typedef model::referring_segment<ConstOrNonConstPoint> segment_type;
+    typedef typename geometry::coordinate_type<segment_type>::type coordinate_type;
+
+    static inline coordinate_type get(segment_type const& s)
+    {
+        return geometry::get<Dimension>(s.second);
+    }
+
+    static inline void set(segment_type& s, coordinate_type const& value)
+    {
+        geometry::set<Dimension>(s.second, value);
+    }
+};
+
+
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_SEGMENT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometries/variant.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/variant.hpp
new file mode 100644
index 00000000000..881eab9c8be
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometries/variant.hpp
@@ -0,0 +1,39 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRIES_VARIANT_GEOMETRY_HPP
+#define BOOST_GEOMETRY_GEOMETRIES_VARIANT_GEOMETRY_HPP
+
+
+#include <boost/variant/variant_fwd.hpp>
+#include <boost/mpl/front.hpp>
+
+
+namespace boost { namespace geometry {
+
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct point_type<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+    : point_type<
+        typename boost::mpl::front<
+            typename boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::types
+        >::type
+    >
+{};
+
+
+} // namespace geometry
+} // namespace boost
+
+
+#endif // BOOST_GEOMETRY_GEOMETRIES_VARIANT_GEOMETRY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/geometry.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/geometry.hpp
new file mode 100644
index 00000000000..aa807011045
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/geometry.hpp
@@ -0,0 +1,117 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014, 2015, 2016.
+// Modifications copyright (c) 2014-2016 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRY_HPP
+#define BOOST_GEOMETRY_GEOMETRY_HPP
+
+// Shortcut to include all header files
+
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_system.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/interior_type.hpp>
+#include <boost/geometry/core/point_order.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/srs.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+// Core algorithms
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/radian_access.hpp>
+#include <boost/geometry/core/radius.hpp>
+#include <boost/geometry/core/topological_dimension.hpp>
+
+#include <boost/geometry/arithmetic/arithmetic.hpp>
+#include <boost/geometry/arithmetic/dot_product.hpp>
+
+#include <boost/geometry/strategies/strategies.hpp>
+
+#include <boost/geometry/algorithms/append.hpp>
+#include <boost/geometry/algorithms/area.hpp>
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/algorithms/buffer.hpp>
+#include <boost/geometry/algorithms/centroid.hpp>
+#include <boost/geometry/algorithms/clear.hpp>
+#include <boost/geometry/algorithms/comparable_distance.hpp>
+#include <boost/geometry/algorithms/convert.hpp>
+#include <boost/geometry/algorithms/convex_hull.hpp>
+#include <boost/geometry/algorithms/correct.hpp>
+#include <boost/geometry/algorithms/covered_by.hpp>
+#include <boost/geometry/algorithms/crosses.hpp>
+#include <boost/geometry/algorithms/difference.hpp>
+#include <boost/geometry/algorithms/disjoint.hpp>
+#include <boost/geometry/algorithms/distance.hpp>
+#include <boost/geometry/algorithms/envelope.hpp>
+#include <boost/geometry/algorithms/equals.hpp>
+#include <boost/geometry/algorithms/expand.hpp>
+#include <boost/geometry/algorithms/for_each.hpp>
+#include <boost/geometry/algorithms/intersection.hpp>
+#include <boost/geometry/algorithms/intersects.hpp>
+#include <boost/geometry/algorithms/is_empty.hpp>
+#include <boost/geometry/algorithms/is_simple.hpp>
+#include <boost/geometry/algorithms/is_valid.hpp>
+#include <boost/geometry/algorithms/length.hpp>
+#include <boost/geometry/algorithms/make.hpp>
+#include <boost/geometry/algorithms/num_geometries.hpp>
+#include <boost/geometry/algorithms/num_interior_rings.hpp>
+#include <boost/geometry/algorithms/num_points.hpp>
+#include <boost/geometry/algorithms/num_segments.hpp>
+#include <boost/geometry/algorithms/overlaps.hpp>
+#include <boost/geometry/algorithms/perimeter.hpp>
+#include <boost/geometry/algorithms/relate.hpp>
+#include <boost/geometry/algorithms/relation.hpp>
+#include <boost/geometry/algorithms/remove_spikes.hpp>
+#include <boost/geometry/algorithms/reverse.hpp>
+#include <boost/geometry/algorithms/simplify.hpp>
+#include <boost/geometry/algorithms/sym_difference.hpp>
+#include <boost/geometry/algorithms/touches.hpp>
+#include <boost/geometry/algorithms/transform.hpp>
+#include <boost/geometry/algorithms/union.hpp>
+#include <boost/geometry/algorithms/unique.hpp>
+#include <boost/geometry/algorithms/within.hpp>
+
+// check includes all concepts
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/util/for_each_coordinate.hpp>
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/select_coordinate_type.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+
+#include <boost/geometry/views/box_view.hpp>
+#include <boost/geometry/views/closeable_view.hpp>
+#include <boost/geometry/views/identity_view.hpp>
+#include <boost/geometry/views/reversible_view.hpp>
+#include <boost/geometry/views/segment_view.hpp>
+
+#include <boost/geometry/io/io.hpp>
+#include <boost/geometry/io/dsv/write.hpp>
+#include <boost/geometry/io/svg/svg_mapper.hpp>
+#include <boost/geometry/io/svg/write.hpp>
+#include <boost/geometry/io/wkt/read.hpp>
+#include <boost/geometry/io/wkt/write.hpp>
+
+#endif // BOOST_GEOMETRY_GEOMETRY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/adaptors/query.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/adaptors/query.hpp
new file mode 100644
index 00000000000..472b3693b14
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/adaptors/query.hpp
@@ -0,0 +1,88 @@
+// Boost.Geometry Index
+//
+// Query range adaptor
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_ADAPTORS_QUERY_HPP
+#define BOOST_GEOMETRY_INDEX_ADAPTORS_QUERY_HPP
+
+/*!
+\defgroup adaptors Adaptors (boost::geometry::index::adaptors::)
+*/
+
+namespace boost { namespace geometry { namespace index {
+
+namespace adaptors {
+
+namespace detail {
+
+template <typename Index>
+class query_range
+{
+    BOOST_MPL_ASSERT_MSG(
+        (false),
+        NOT_IMPLEMENTED_FOR_THIS_INDEX,
+        (query_range));
+
+    typedef int* iterator;
+    typedef const int* const_iterator;
+
+    template <typename Predicates>
+    inline query_range(
+        Index const&,
+        Predicates const&)
+    {}
+
+    inline iterator begin() { return 0; }
+    inline iterator end() { return 0; }
+    inline const_iterator begin() const { return 0; }
+    inline const_iterator end() const { return 0; }
+};
+
+// TODO: awulkiew - consider removing reference from predicates
+
+template<typename Predicates>
+struct query
+{
+    inline explicit query(Predicates const& pred)
+        : predicates(pred)
+    {}
+
+    Predicates const& predicates;
+};
+
+template<typename Index, typename Predicates>
+index::adaptors::detail::query_range<Index>
+operator|(
+    Index const& si,
+    index::adaptors::detail::query<Predicates> const& f)
+{
+    return index::adaptors::detail::query_range<Index>(si, f.predicates);
+}
+
+} // namespace detail
+
+/*!
+\brief The query index adaptor generator.
+
+\ingroup adaptors
+
+\param pred   Predicates.
+*/
+template <typename Predicates>
+detail::query<Predicates>
+queried(Predicates const& pred)
+{
+    return detail::query<Predicates>(pred);
+}
+
+} // namespace adaptors
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_ADAPTORS_QUERY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/bounds.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/bounds.hpp
new file mode 100644
index 00000000000..a62fda070c6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/bounds.hpp
@@ -0,0 +1,90 @@
+// Boost.Geometry Index
+//
+// n-dimensional bounds
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_BOUNDS_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_BOUNDS_HPP
+
+#include <boost/geometry/index/detail/bounded_view.hpp>
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+namespace dispatch {
+
+template <typename Geometry,
+          typename Bounds,
+          typename TagGeometry = typename geometry::tag<Geometry>::type,
+          typename TagBounds = typename geometry::tag<Bounds>::type>
+struct bounds
+{
+    static inline void apply(Geometry const& g, Bounds & b)
+    {
+        geometry::convert(g, b);
+    }
+};
+
+template <typename Geometry, typename Bounds>
+struct bounds<Geometry, Bounds, segment_tag, box_tag>
+{
+    static inline void apply(Geometry const& g, Bounds & b)
+    {
+        index::detail::bounded_view<Geometry, Bounds> v(g);
+        geometry::convert(v, b);
+    }
+};
+
+} // namespace dispatch
+
+template <typename Geometry, typename Bounds>
+inline void bounds(Geometry const& g, Bounds & b)
+{
+    concepts::check_concepts_and_equal_dimensions<Geometry const, Bounds>();
+    dispatch::bounds<Geometry, Bounds>::apply(g, b);
+}
+
+namespace dispatch {
+
+template <typename Geometry,
+          typename TagGeometry = typename geometry::tag<Geometry>::type>
+struct return_ref_or_bounds
+{
+    typedef Geometry const& result_type;
+
+    static inline result_type apply(Geometry const& g)
+    {
+        return g;
+    }
+};
+
+template <typename Geometry>
+struct return_ref_or_bounds<Geometry, segment_tag>
+{
+    typedef typename point_type<Geometry>::type point_type;
+    typedef geometry::model::box<point_type> bounds_type;
+    typedef index::detail::bounded_view<Geometry, bounds_type> result_type;
+
+    static inline result_type apply(Geometry const& g)
+    {
+        return result_type(g);
+    }
+};
+
+} // namespace dispatch
+
+template <typename Geometry>
+inline
+typename dispatch::return_ref_or_bounds<Geometry>::result_type
+return_ref_or_bounds(Geometry const& g)
+{
+    return dispatch::return_ref_or_bounds<Geometry>::apply(g);
+}
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_BOUNDS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/comparable_distance_centroid.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/comparable_distance_centroid.hpp
new file mode 100644
index 00000000000..c4e44cae18c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/comparable_distance_centroid.hpp
@@ -0,0 +1,77 @@
+// Boost.Geometry Index
+//
+// squared distance between point and centroid of the box or point
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_COMPARABLE_DISTANCE_CENTROID_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_COMPARABLE_DISTANCE_CENTROID_HPP
+
+#include <boost/geometry/index/detail/algorithms/sum_for_indexable.hpp>
+#include <boost/geometry/index/detail/algorithms/diff_abs.hpp>
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+struct comparable_distance_centroid_tag {};
+
+template <
+    typename Point,
+    typename PointIndexable,
+    size_t N>
+struct sum_for_indexable<Point, PointIndexable, point_tag, comparable_distance_centroid_tag, N>
+{
+    typedef typename geometry::default_comparable_distance_result<Point, PointIndexable>::type result_type;
+
+    inline static result_type apply(Point const& pt, PointIndexable const& i)
+    {
+        return geometry::comparable_distance(pt, i);
+    }
+};
+
+template <
+    typename Point,
+    typename BoxIndexable,
+    size_t DimensionIndex>
+struct sum_for_indexable_dimension<Point, BoxIndexable, box_tag, comparable_distance_centroid_tag, DimensionIndex>
+{
+    typedef typename geometry::default_comparable_distance_result<Point, BoxIndexable>::type result_type;
+
+    inline static result_type apply(Point const& pt, BoxIndexable const& i)
+    {
+        typedef typename coordinate_type<Point>::type point_coord_t;
+        typedef typename coordinate_type<BoxIndexable>::type indexable_coord_t;
+
+        point_coord_t pt_c = geometry::get<DimensionIndex>(pt);
+        indexable_coord_t ind_c_min = geometry::get<geometry::min_corner, DimensionIndex>(i);
+        indexable_coord_t ind_c_max = geometry::get<geometry::max_corner, DimensionIndex>(i);
+        
+        indexable_coord_t ind_c_avg = ind_c_min + (ind_c_max - ind_c_min) / 2;
+        // TODO: awulkiew - is (ind_c_min + ind_c_max) / 2 safe?
+
+        result_type diff = detail::diff_abs(ind_c_avg, pt_c);
+
+        return diff * diff;
+    }
+};
+
+template <typename Point, typename Indexable>
+typename geometry::default_comparable_distance_result<Point, Indexable>::type
+comparable_distance_centroid(Point const& pt, Indexable const& i)
+{
+    return detail::sum_for_indexable<
+        Point,
+        Indexable,
+        typename tag<Indexable>::type,
+        detail::comparable_distance_centroid_tag,
+        dimension<Indexable>::value
+    >::apply(pt, i);
+}
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // #define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_COMPARABLE_DISTANCE_CENTROID_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/comparable_distance_far.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/comparable_distance_far.hpp
new file mode 100644
index 00000000000..214fbf6aaf3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/comparable_distance_far.hpp
@@ -0,0 +1,66 @@
+// Boost.Geometry Index
+//
+// squared distance between point and furthest point of the box or point
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_COMPARABLE_DISTANCE_FAR_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_COMPARABLE_DISTANCE_FAR_HPP
+
+#include <boost/geometry/index/detail/algorithms/diff_abs.hpp>
+#include <boost/geometry/index/detail/algorithms/sum_for_indexable.hpp>
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+// minmaxdist component
+
+struct comparable_distance_far_tag {};
+
+template <
+    typename Point,
+    typename BoxIndexable,
+    size_t DimensionIndex>
+struct sum_for_indexable_dimension<Point, BoxIndexable, box_tag, comparable_distance_far_tag, DimensionIndex>
+{
+    typedef typename geometry::default_comparable_distance_result<Point, BoxIndexable>::type result_type;
+
+    inline static result_type apply(Point const& pt, BoxIndexable const& i)
+    {
+        typedef typename coordinate_type<Point>::type point_coord_t;
+        typedef typename coordinate_type<BoxIndexable>::type indexable_coord_t;
+
+        point_coord_t pt_c = geometry::get<DimensionIndex>(pt);
+        indexable_coord_t ind_c_min = geometry::get<geometry::min_corner, DimensionIndex>(i);
+        indexable_coord_t ind_c_max = geometry::get<geometry::max_corner, DimensionIndex>(i);
+
+        result_type further_diff = 0;
+
+        if ( (ind_c_min + ind_c_max) / 2 <= pt_c )
+            further_diff = pt_c - ind_c_min;
+        else
+            further_diff = detail::diff_abs(pt_c, ind_c_max); // unsigned values protection
+
+        return further_diff * further_diff;
+    }
+};
+
+template <typename Point, typename Indexable>
+typename geometry::default_comparable_distance_result<Point, Indexable>::type
+comparable_distance_far(Point const& pt, Indexable const& i)
+{
+    return detail::sum_for_indexable<
+        Point,
+        Indexable,
+        typename tag<Indexable>::type,
+        detail::comparable_distance_far_tag,
+        dimension<Indexable>::value
+    >::apply(pt, i);
+}
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_COMPARABLE_DISTANCE_FAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/comparable_distance_near.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/comparable_distance_near.hpp
new file mode 100644
index 00000000000..15368a7d24b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/comparable_distance_near.hpp
@@ -0,0 +1,77 @@
+// Boost.Geometry Index
+//
+// squared distance between point and nearest point of the box or point
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_COMPARABLE_DISTANCE_NEAR_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_COMPARABLE_DISTANCE_NEAR_HPP
+
+#include <boost/geometry/index/detail/algorithms/sum_for_indexable.hpp>
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+struct comparable_distance_near_tag {};
+
+template <
+    typename Point,
+    typename PointIndexable,
+    size_t N>
+struct sum_for_indexable<Point, PointIndexable, point_tag, comparable_distance_near_tag, N>
+{
+    typedef typename geometry::default_comparable_distance_result<Point, PointIndexable>::type result_type;
+
+    inline static result_type apply(Point const& pt, PointIndexable const& i)
+    {
+        return geometry::comparable_distance(pt, i);
+    }
+};
+
+template <
+    typename Point,
+    typename BoxIndexable,
+    size_t DimensionIndex>
+struct sum_for_indexable_dimension<Point, BoxIndexable, box_tag, comparable_distance_near_tag, DimensionIndex>
+{
+    typedef typename geometry::default_comparable_distance_result<Point, BoxIndexable>::type result_type;
+
+    inline static result_type apply(Point const& pt, BoxIndexable const& i)
+    {
+        typedef typename coordinate_type<Point>::type point_coord_t;
+        typedef typename coordinate_type<BoxIndexable>::type indexable_coord_t;
+
+        point_coord_t pt_c = geometry::get<DimensionIndex>(pt);
+        indexable_coord_t ind_c_min = geometry::get<geometry::min_corner, DimensionIndex>(i);
+        indexable_coord_t ind_c_max = geometry::get<geometry::max_corner, DimensionIndex>(i);
+
+        result_type diff = 0;
+
+        if ( pt_c < ind_c_min )
+            diff = ind_c_min - pt_c;
+        else if ( ind_c_max < pt_c )
+            diff = pt_c - ind_c_max;
+
+        return diff * diff;
+    }
+};
+
+template <typename Point, typename Indexable>
+typename geometry::default_comparable_distance_result<Point, Indexable>::type
+comparable_distance_near(Point const& pt, Indexable const& i)
+{
+    return detail::sum_for_indexable<
+        Point,
+        Indexable,
+        typename tag<Indexable>::type,
+        detail::comparable_distance_near_tag,
+        dimension<Indexable>::value
+    >::apply(pt, i);
+}
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_COMPARABLE_DISTANCE_NEAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/content.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/content.hpp
new file mode 100644
index 00000000000..028113e0ef5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/content.hpp
@@ -0,0 +1,87 @@
+// Boost.Geometry Index
+//
+// n-dimensional content (hypervolume) - 2d area, 3d volume, ...
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_CONTENT_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_CONTENT_HPP
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+template <typename Indexable>
+struct default_content_result
+{
+    typedef typename select_most_precise<
+        typename coordinate_type<Indexable>::type,
+        long double
+    >::type type;
+};
+
+namespace dispatch {
+
+template <typename Box,
+          std::size_t CurrentDimension = dimension<Box>::value>
+struct content_box
+{
+    BOOST_STATIC_ASSERT(0 < CurrentDimension);
+
+    static inline typename detail::default_content_result<Box>::type apply(Box const& b)
+    {
+        return content_box<Box, CurrentDimension - 1>::apply(b) *
+            ( get<max_corner, CurrentDimension - 1>(b) - get<min_corner, CurrentDimension - 1>(b) );
+    }
+};
+
+template <typename Box>
+struct content_box<Box, 1>
+{
+    static inline typename detail::default_content_result<Box>::type apply(Box const& b)
+    {
+        return get<max_corner, 0>(b) - get<min_corner, 0>(b);
+    }
+};
+
+template <typename Indexable, typename Tag>
+struct content
+{
+    BOOST_MPL_ASSERT_MSG(false, NOT_IMPLEMENTED_FOR_THIS_INDEXABLE_AND_TAG, (Indexable, Tag));
+};
+
+template <typename Indexable>
+struct content<Indexable, point_tag>
+{
+    static typename detail::default_content_result<Indexable>::type apply(Indexable const&)
+    {
+        return 0;
+    }
+};
+
+template <typename Indexable>
+struct content<Indexable, box_tag>
+{
+    static typename default_content_result<Indexable>::type apply(Indexable const& b)
+    {
+        return dispatch::content_box<Indexable>::apply(b);
+    }
+};
+
+} // namespace dispatch
+
+template <typename Indexable>
+typename default_content_result<Indexable>::type content(Indexable const& b)
+{
+    return dispatch::content
+            <
+                Indexable,
+                typename tag<Indexable>::type
+            >::apply(b);
+}
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_CONTENT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/diff_abs.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/diff_abs.hpp
new file mode 100644
index 00000000000..ec63bd9a5d2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/diff_abs.hpp
@@ -0,0 +1,39 @@
+// Boost.Geometry Index
+//
+// Abs of difference
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_DIFF_ABS_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_DIFF_ABS_HPP
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+template <typename T>
+inline T diff_abs_dispatch(T const& v1, T const& v2, boost::mpl::bool_<true> const& /*is_integral*/)
+{
+    return v1 < v2 ? v2 - v1 : v1 - v2;
+}
+
+template <typename T>
+inline T diff_abs_dispatch(T const& v1, T const& v2, boost::mpl::bool_<false> const& /*is_integral*/)
+{
+    return ::fabs(v1 - v2);
+}
+
+template <typename T>
+inline T diff_abs(T const& v1, T const& v2)
+{
+    typedef boost::mpl::bool_<
+        boost::is_integral<T>::value
+    > is_integral;
+    return diff_abs_dispatch(v1, v2, is_integral());
+}
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_DIFF_ABS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/intersection_content.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/intersection_content.hpp
new file mode 100644
index 00000000000..437f90b46c3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/intersection_content.hpp
@@ -0,0 +1,46 @@
+// Boost.Geometry Index
+//
+// boxes union/intersection area/volume
+//
+// Copyright (c) 2011-2017 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_INTERSECTION_CONTENT_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_INTERSECTION_CONTENT_HPP
+
+#include <boost/geometry/algorithms/detail/disjoint/box_box.hpp>
+#include <boost/geometry/algorithms/detail/overlay/intersection_box_box.hpp>
+
+#include <boost/geometry/index/detail/algorithms/content.hpp>
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+/**
+ * \brief Compute the area of the intersection of b1 and b2
+ */
+template <typename Box>
+inline typename default_content_result<Box>::type intersection_content(Box const& box1, Box const& box2)
+{
+    bool const intersects = ! geometry::detail::disjoint::box_box<Box, Box>::apply(box1, box2);
+
+    if ( intersects )
+    {
+        Box box_intersection;
+        bool const ok = geometry::detail::intersection::intersection_box_box
+                            <
+                                0, geometry::dimension<Box>::value
+                            >::apply(box1, box2, 0, box_intersection, 0);
+        if ( ok )
+        {
+            return index::detail::content(box_intersection);
+        }
+    }
+    return 0;
+}
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_INTERSECTION_CONTENT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/is_valid.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/is_valid.hpp
new file mode 100644
index 00000000000..676eec2d2a8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/is_valid.hpp
@@ -0,0 +1,91 @@
+// Boost.Geometry Index
+//
+// n-dimensional Indexable validity check
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_IS_VALID_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_IS_VALID_HPP
+
+#include <cstddef>
+#include <boost/geometry/core/access.hpp>
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+namespace dispatch {
+
+template <typename Box,
+          std::size_t Dimension = geometry::dimension<Box>::value>
+struct is_valid_box
+{
+    static inline bool apply(Box const& b)
+    {
+        return is_valid_box<Box, Dimension - 1>::apply(b) &&
+            ( get<min_corner, Dimension - 1>(b) <= get<max_corner, Dimension - 1>(b) );
+    }
+};
+
+template <typename Box>
+struct is_valid_box<Box, 1>
+{
+    static inline bool apply(Box const& b)
+    {
+        return get<min_corner, 0>(b) <= get<max_corner, 0>(b);
+    }
+};
+
+template <typename Indexable,
+          typename Tag = typename geometry::tag<Indexable>::type>
+struct is_valid
+{
+    BOOST_MPL_ASSERT_MSG(
+        (false),
+        NOT_IMPLEMENTED_FOR_THIS_INDEXABLE,
+        (is_valid));
+};
+
+template <typename Indexable>
+struct is_valid<Indexable, point_tag>
+{
+    static inline bool apply(Indexable const&)
+    {
+        return true;
+    }
+};
+
+template <typename Indexable>
+struct is_valid<Indexable, box_tag>
+{
+    static inline bool apply(Indexable const& b)
+    {
+        return dispatch::is_valid_box<Indexable>::apply(b);
+    }
+};
+
+template <typename Indexable>
+struct is_valid<Indexable, segment_tag>
+{
+    static inline bool apply(Indexable const&)
+    {
+        return true;
+    }
+};
+
+} // namespace dispatch
+
+template <typename Indexable>
+inline bool is_valid(Indexable const& b)
+{
+    // CONSIDER: detection of NaNs
+    // e.g. by comparison of b with copy of b
+
+    return dispatch::is_valid<Indexable>::apply(b);
+}
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_DETAIL_INDEX_ALGORITHMS_IS_VALID_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/margin.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/margin.hpp
new file mode 100644
index 00000000000..d4876600acb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/margin.hpp
@@ -0,0 +1,169 @@
+// Boost.Geometry Index
+//
+// n-dimensional box's margin value (hypersurface), 2d perimeter, 3d surface, etc...
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_MARGIN_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_MARGIN_HPP
+
+// WARNING! comparable_margin() will work only if the same Geometries are compared
+// so it shouldn't be used in the case of Variants!
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+template <typename Box>
+struct default_margin_result
+{
+    typedef typename select_most_precise<
+        typename coordinate_type<Box>::type,
+        long double
+    >::type type;
+};
+
+//template <typename Box,
+//          std::size_t CurrentDimension,
+//          std::size_t EdgeDimension = dimension<Box>::value>
+//struct margin_for_each_edge
+//{
+//    BOOST_STATIC_ASSERT(0 < CurrentDimension);
+//    BOOST_STATIC_ASSERT(0 < EdgeDimension);
+//
+//    static inline typename default_margin_result<Box>::type apply(Box const& b)
+//    {
+//        return margin_for_each_edge<Box, CurrentDimension, EdgeDimension - 1>::apply(b) *
+//            ( geometry::get<max_corner, EdgeDimension - 1>(b) - geometry::get<min_corner, EdgeDimension - 1>(b) );
+//    }
+//};
+//
+//template <typename Box, std::size_t CurrentDimension>
+//struct margin_for_each_edge<Box, CurrentDimension, CurrentDimension>
+//{
+//    BOOST_STATIC_ASSERT(0 < CurrentDimension);
+//
+//    static inline typename default_margin_result<Box>::type apply(Box const& b)
+//    {
+//        return margin_for_each_edge<Box, CurrentDimension, CurrentDimension - 1>::apply(b);
+//    }
+//};
+//
+//template <typename Box, std::size_t CurrentDimension>
+//struct margin_for_each_edge<Box, CurrentDimension, 1>
+//{
+//    BOOST_STATIC_ASSERT(0 < CurrentDimension);
+//
+//    static inline typename default_margin_result<Box>::type apply(Box const& b)
+//    {
+//        return geometry::get<max_corner, 0>(b) - geometry::get<min_corner, 0>(b);
+//    }
+//};
+//
+//template <typename Box>
+//struct margin_for_each_edge<Box, 1, 1>
+//{
+//    static inline typename default_margin_result<Box>::type apply(Box const& /*b*/)
+//    {
+//        return 1;
+//    }
+//};
+//
+//template <typename Box,
+//          std::size_t CurrentDimension = dimension<Box>::value>
+//struct margin_for_each_dimension
+//{
+//    BOOST_STATIC_ASSERT(0 < CurrentDimension);
+//
+//    static inline typename default_margin_result<Box>::type apply(Box const& b)
+//    {
+//        return margin_for_each_dimension<Box, CurrentDimension - 1>::apply(b) +
+//            margin_for_each_edge<Box, CurrentDimension>::apply(b);
+//    }
+//};
+//
+//template <typename Box>
+//struct margin_for_each_dimension<Box, 1>
+//{
+//    static inline typename default_margin_result<Box>::type apply(Box const& b)
+//    {
+//        return margin_for_each_edge<Box, 1>::apply(b);
+//    }
+//};
+
+// TODO - test if this definition of margin is ok for Dimension > 2
+// Now it's sum of edges lengths
+// maybe margin_for_each_dimension should be used to get more or less hypersurface?
+
+template <typename Box,
+          std::size_t CurrentDimension = dimension<Box>::value>
+struct simple_margin_for_each_dimension
+{
+    BOOST_STATIC_ASSERT(0 < CurrentDimension);
+
+    static inline typename default_margin_result<Box>::type apply(Box const& b)
+    {
+        return simple_margin_for_each_dimension<Box, CurrentDimension - 1>::apply(b) +
+            geometry::get<max_corner, CurrentDimension - 1>(b) - geometry::get<min_corner, CurrentDimension - 1>(b);
+    }
+};
+
+template <typename Box>
+struct simple_margin_for_each_dimension<Box, 1>
+{
+    static inline typename default_margin_result<Box>::type apply(Box const& b)
+    {
+        return geometry::get<max_corner, 0>(b) - geometry::get<min_corner, 0>(b);
+    }
+};
+
+namespace dispatch {
+
+template <typename Geometry, typename Tag>
+struct comparable_margin
+{
+    BOOST_MPL_ASSERT_MSG(false, NOT_IMPLEMENTED_FOR_THIS_GEOMETRY, (Geometry, Tag));
+};
+
+template <typename Geometry>
+struct comparable_margin<Geometry, point_tag>
+{
+    typedef typename default_margin_result<Geometry>::type result_type;
+
+    static inline result_type apply(Geometry const& ) { return 0; }
+};
+
+template <typename Box>
+struct comparable_margin<Box, box_tag>
+{
+    typedef typename default_margin_result<Box>::type result_type;
+
+    static inline result_type apply(Box const& g)
+    {
+        //return detail::margin_for_each_dimension<Box>::apply(g);
+        return detail::simple_margin_for_each_dimension<Box>::apply(g);
+    }
+};
+
+} // namespace dispatch
+
+template <typename Geometry>
+typename default_margin_result<Geometry>::type comparable_margin(Geometry const& g)
+{
+    return dispatch::comparable_margin<
+        Geometry,
+        typename tag<Geometry>::type
+    >::apply(g);
+}
+
+//template <typename Box>
+//typename default_margin_result<Box>::type margin(Box const& b)
+//{
+//    return 2 * detail::margin_for_each_dimension<Box>::apply(b);
+//}
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_MARGIN_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/minmaxdist.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/minmaxdist.hpp
new file mode 100644
index 00000000000..ab6291504ff
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/minmaxdist.hpp
@@ -0,0 +1,119 @@
+// Boost.Geometry Index
+//
+// minmaxdist used in R-tree k nearest neighbors query
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_MINMAXDIST_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_MINMAXDIST_HPP
+
+#include <boost/geometry/algorithms/distance.hpp>
+#include <boost/geometry/algorithms/comparable_distance.hpp>
+
+#include <boost/geometry/index/detail/algorithms/diff_abs.hpp>
+#include <boost/geometry/index/detail/algorithms/sum_for_indexable.hpp>
+#include <boost/geometry/index/detail/algorithms/smallest_for_indexable.hpp>
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+struct minmaxdist_tag {};
+
+template <
+    typename Point,
+    typename BoxIndexable,
+    size_t DimensionIndex>
+struct smallest_for_indexable_dimension<Point, BoxIndexable, box_tag, minmaxdist_tag, DimensionIndex>
+{
+    typedef typename geometry::default_comparable_distance_result<Point, BoxIndexable>::type result_type;
+
+    inline static result_type apply(Point const& pt, BoxIndexable const& i, result_type const& maxd)
+    {
+        typedef typename coordinate_type<Point>::type point_coord_t;
+        typedef typename coordinate_type<BoxIndexable>::type indexable_coord_t;
+
+        point_coord_t pt_c = geometry::get<DimensionIndex>(pt);
+        indexable_coord_t ind_c_min = geometry::get<geometry::min_corner, DimensionIndex>(i);
+        indexable_coord_t ind_c_max = geometry::get<geometry::max_corner, DimensionIndex>(i);
+
+        indexable_coord_t ind_c_avg = ind_c_min + (ind_c_max - ind_c_min) / 2;
+        // TODO: awulkiew - is (ind_c_min + ind_c_max) / 2 safe?
+
+        // TODO: awulkiew - optimize! don't calculate 2x pt_c <= ind_c_avg
+        // take particular case pt_c == ind_c_avg into account
+
+        result_type closer_comp = 0;
+        if ( pt_c <= ind_c_avg )
+            closer_comp = detail::diff_abs(pt_c, ind_c_min); // unsigned values protection
+        else
+            closer_comp = ind_c_max - pt_c;
+        
+        result_type further_comp = 0;
+        if ( ind_c_avg <= pt_c )
+            further_comp = pt_c - ind_c_min;
+        else
+            further_comp = detail::diff_abs(pt_c, ind_c_max); // unsigned values protection
+
+        return (maxd + closer_comp * closer_comp) - further_comp * further_comp;
+    }
+};
+
+template <typename Point, typename Indexable, typename IndexableTag>
+struct minmaxdist_impl
+{
+    BOOST_MPL_ASSERT_MSG(
+        (false),
+        NOT_IMPLEMENTED_FOR_THIS_INDEXABLE_TAG_TYPE,
+        (minmaxdist_impl));
+};
+
+template <typename Point, typename Indexable>
+struct minmaxdist_impl<Point, Indexable, point_tag>
+{
+    typedef typename geometry::default_comparable_distance_result<Point, Indexable>::type result_type;
+
+    inline static result_type apply(Point const& pt, Indexable const& i)
+    {
+        return geometry::comparable_distance(pt, i);
+    }
+};
+
+template <typename Point, typename Indexable>
+struct minmaxdist_impl<Point, Indexable, box_tag>
+{
+    typedef typename geometry::default_comparable_distance_result<Point, Indexable>::type result_type;
+
+    inline static result_type apply(Point const& pt, Indexable const& i)
+    {
+        result_type maxd = geometry::comparable_distance(pt, i);
+
+        return smallest_for_indexable<
+            Point,
+            Indexable,
+            box_tag,
+            minmaxdist_tag,
+            dimension<Indexable>::value
+        >::apply(pt, i, maxd);
+    }
+};
+
+/**
+ * This is comparable distace.
+ */
+template <typename Point, typename Indexable>
+typename geometry::default_comparable_distance_result<Point, Indexable>::type
+minmaxdist(Point const& pt, Indexable const& i)
+{
+    return detail::minmaxdist_impl<
+        Point,
+        Indexable,
+        typename tag<Indexable>::type
+    >::apply(pt, i);
+}
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_MINMAXDIST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/nth_element.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/nth_element.hpp
new file mode 100644
index 00000000000..201180ae3a6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/nth_element.hpp
@@ -0,0 +1,62 @@
+// Boost.Geometry Index
+//
+// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_NTH_ELEMENT_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_NTH_ELEMENT_HPP
+
+#include <algorithm>
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+// See https://svn.boost.org/trac/boost/ticket/12861
+//     https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58800
+//     https://gcc.gnu.org/develop.html#timeline
+// 20120920 4.7.2 - no bug
+// 20130322 4.8.0 - no bug
+// 20130411 4.7.3 - no bug
+// 20130531 4.8.1 - no bug
+// 20131016 4.8.2 - bug
+// 20140422 4.9.0 - fixed
+// 20140522 4.8.3 - fixed
+// 20140612 4.7.4 - fixed
+// 20140716 4.9.1 - fixed
+#if defined(__GLIBCXX__) && (__GLIBCXX__ == 20131016)
+
+#warning "std::nth_element replaced with std::sort, libstdc++ bug workaround.";
+
+template <typename RandomIt>
+void nth_element(RandomIt first, RandomIt , RandomIt last)
+{
+    std::sort(first, last);
+}
+
+template <typename RandomIt, typename Compare>
+void nth_element(RandomIt first, RandomIt , RandomIt last, Compare comp)
+{
+    std::sort(first, last, comp);
+}
+
+#else
+
+template <typename RandomIt>
+void nth_element(RandomIt first, RandomIt nth, RandomIt last)
+{
+    std::nth_element(first, nth, last);
+}
+
+template <typename RandomIt, typename Compare>
+void nth_element(RandomIt first, RandomIt nth, RandomIt last, Compare comp)
+{
+    std::nth_element(first, nth, last, comp);
+}
+
+#endif
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_NTH_ELEMENT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/path_intersection.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/path_intersection.hpp
new file mode 100644
index 00000000000..3cfb556c304
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/path_intersection.hpp
@@ -0,0 +1,123 @@
+// Boost.Geometry Index
+//
+// n-dimensional box-linestring intersection
+//
+// Copyright (c) 2011-2017 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_PATH_INTERSECTION_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_PATH_INTERSECTION_HPP
+
+
+#include <boost/geometry/index/detail/algorithms/segment_intersection.hpp>
+
+#include <boost/geometry/strategies/default_length_result.hpp>
+
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+namespace dispatch {
+
+template <typename Indexable, typename Geometry, typename IndexableTag, typename GeometryTag>
+struct path_intersection
+{
+    BOOST_MPL_ASSERT_MSG((false), NOT_IMPLEMENTED_FOR_THIS_GEOMETRY_OR_INDEXABLE, (path_intersection));
+};
+
+// TODO: FP type must be used as a relative distance type!
+// and default_distance_result can be some user-defined int type
+// BUT! This code is experimental and probably won't be released at all
+// since more flexible user-defined-nearest predicate should be added instead
+
+template <typename Indexable, typename Segment>
+struct path_intersection<Indexable, Segment, box_tag, segment_tag>
+{
+    typedef typename default_distance_result<typename point_type<Segment>::type>::type comparable_distance_type;
+
+    static inline bool apply(Indexable const& b, Segment const& segment, comparable_distance_type & comparable_distance)
+    {
+        typedef typename point_type<Segment>::type point_type;
+        point_type p1, p2;
+        geometry::detail::assign_point_from_index<0>(segment, p1);
+        geometry::detail::assign_point_from_index<1>(segment, p2);
+        return index::detail::segment_intersection(b, p1, p2, comparable_distance);
+    }
+};
+
+template <typename Indexable, typename Linestring>
+struct path_intersection<Indexable, Linestring, box_tag, linestring_tag>
+{
+    typedef typename default_length_result<Linestring>::type comparable_distance_type;
+
+    static inline bool apply(Indexable const& b, Linestring const& path, comparable_distance_type & comparable_distance)
+    {
+        typedef typename ::boost::range_value<Linestring>::type point_type;
+        typedef typename ::boost::range_const_iterator<Linestring>::type const_iterator;        
+        typedef typename ::boost::range_size<Linestring>::type size_type;
+        
+        const size_type count = ::boost::size(path);
+
+        if ( count == 2 )
+        {
+            return index::detail::segment_intersection(b, *::boost::begin(path), *(::boost::begin(path)+1), comparable_distance);
+        }
+        else if ( 2 < count )
+        {
+            const_iterator it0 = ::boost::begin(path);
+            const_iterator it1 = ::boost::begin(path) + 1;
+            const_iterator last = ::boost::end(path);
+
+            comparable_distance = 0;
+
+            for ( ; it1 != last ; ++it0, ++it1 )
+            {
+                typename default_distance_result<point_type, point_type>::type
+                    dist = geometry::distance(*it0, *it1);
+
+                comparable_distance_type rel_dist;
+                if ( index::detail::segment_intersection(b, *it0, *it1, rel_dist) )
+                {
+                    comparable_distance += dist * rel_dist;
+                    return true;
+                }
+                else
+                    comparable_distance += dist;
+            }
+        }
+
+        return false;
+    }
+};
+
+} // namespace dispatch
+
+template <typename Indexable, typename SegmentOrLinestring>
+struct default_path_intersection_distance_type
+{
+    typedef typename dispatch::path_intersection<
+        Indexable, SegmentOrLinestring,
+        typename tag<Indexable>::type,
+        typename tag<SegmentOrLinestring>::type
+    >::comparable_distance_type type;
+};
+
+template <typename Indexable, typename SegmentOrLinestring> inline
+bool path_intersection(Indexable const& b,
+                       SegmentOrLinestring const& path,
+                       typename default_path_intersection_distance_type<Indexable, SegmentOrLinestring>::type & comparable_distance)
+{
+    // TODO check Indexable and Linestring concepts
+
+    return dispatch::path_intersection<
+            Indexable, SegmentOrLinestring,
+            typename tag<Indexable>::type,
+            typename tag<SegmentOrLinestring>::type
+        >::apply(b, path, comparable_distance);
+}
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_PATH_INTERSECTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/segment_intersection.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/segment_intersection.hpp
new file mode 100644
index 00000000000..ec7a88f4909
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/segment_intersection.hpp
@@ -0,0 +1,146 @@
+// Boost.Geometry Index
+//
+// n-dimensional box-segment intersection
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_SEGMENT_INTERSECTION_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_SEGMENT_INTERSECTION_HPP
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+//template <typename Indexable, typename Point>
+//struct default_relative_distance_type
+//{
+//    typedef typename select_most_precise<
+//        typename select_most_precise<
+//        typename coordinate_type<Indexable>::type,
+//        typename coordinate_type<Point>::type
+//        >::type,
+//        float // TODO - use bigger type, calculated from the size of coordinate types
+//    >::type type;
+//
+//
+//    BOOST_MPL_ASSERT_MSG((!::boost::is_unsigned<type>::value),
+//        THIS_TYPE_SHOULDNT_BE_UNSIGNED, (type));
+//};
+
+namespace dispatch {
+
+template <typename Box, typename Point, size_t I>
+struct box_segment_intersection_dim
+{
+    BOOST_STATIC_ASSERT(0 <= dimension<Box>::value);
+    BOOST_STATIC_ASSERT(0 <= dimension<Point>::value);
+    BOOST_STATIC_ASSERT(I < size_t(dimension<Box>::value));
+    BOOST_STATIC_ASSERT(I < size_t(dimension<Point>::value));
+    BOOST_STATIC_ASSERT(dimension<Point>::value == dimension<Box>::value);
+
+    // WARNING! - RelativeDistance must be IEEE float for this to work
+
+    template <typename RelativeDistance>
+    static inline bool apply(Box const& b, Point const& p0, Point const& p1,
+                             RelativeDistance & t_near, RelativeDistance & t_far)
+    {
+        RelativeDistance ray_d = geometry::get<I>(p1) - geometry::get<I>(p0);
+        RelativeDistance tn = ( geometry::get<min_corner, I>(b) - geometry::get<I>(p0) ) / ray_d;
+        RelativeDistance tf = ( geometry::get<max_corner, I>(b) - geometry::get<I>(p0) ) / ray_d;
+        if ( tf < tn )
+            ::std::swap(tn, tf);
+
+        if ( t_near < tn )
+            t_near = tn;
+        if ( tf < t_far )
+            t_far = tf;
+
+        return 0 <= t_far && t_near <= t_far;
+    }
+};
+
+template <typename Box, typename Point, size_t CurrentDimension>
+struct box_segment_intersection
+{
+    BOOST_STATIC_ASSERT(0 < CurrentDimension);
+
+    typedef box_segment_intersection_dim<Box, Point, CurrentDimension - 1> for_dim;
+
+    template <typename RelativeDistance>
+    static inline bool apply(Box const& b, Point const& p0, Point const& p1,
+                             RelativeDistance & t_near, RelativeDistance & t_far)
+    {
+        return box_segment_intersection<Box, Point, CurrentDimension - 1>::apply(b, p0, p1, t_near, t_far)
+            && for_dim::apply(b, p0, p1, t_near, t_far);
+    }
+};
+
+template <typename Box, typename Point>
+struct box_segment_intersection<Box, Point, 1>
+{
+    typedef box_segment_intersection_dim<Box, Point, 0> for_dim;
+
+    template <typename RelativeDistance>
+    static inline bool apply(Box const& b, Point const& p0, Point const& p1,
+                             RelativeDistance & t_near, RelativeDistance & t_far)
+    {
+        return for_dim::apply(b, p0, p1, t_near, t_far);
+    }
+};
+
+template <typename Indexable, typename Point, typename Tag>
+struct segment_intersection
+{
+    BOOST_MPL_ASSERT_MSG((false), NOT_IMPLEMENTED_FOR_THIS_GEOMETRY, (segment_intersection));
+};
+
+template <typename Indexable, typename Point>
+struct segment_intersection<Indexable, Point, point_tag>
+{
+    BOOST_MPL_ASSERT_MSG((false), SEGMENT_POINT_INTERSECTION_UNAVAILABLE, (segment_intersection));
+};
+
+template <typename Indexable, typename Point>
+struct segment_intersection<Indexable, Point, box_tag>
+{
+    typedef dispatch::box_segment_intersection<Indexable, Point, dimension<Indexable>::value> impl;
+
+    template <typename RelativeDistance>
+    static inline bool apply(Indexable const& b, Point const& p0, Point const& p1, RelativeDistance & relative_distance)
+    {
+
+// TODO: this ASSERT CHECK is wrong for user-defined CoordinateTypes!
+
+        static const bool check = !::boost::is_integral<RelativeDistance>::value;
+        BOOST_MPL_ASSERT_MSG(check, RELATIVE_DISTANCE_MUST_BE_FLOATING_POINT_TYPE, (RelativeDistance));
+
+        RelativeDistance t_near = -(::std::numeric_limits<RelativeDistance>::max)();
+        RelativeDistance t_far = (::std::numeric_limits<RelativeDistance>::max)();
+
+        return impl::apply(b, p0, p1, t_near, t_far) &&
+               (t_near <= 1) &&
+               ( relative_distance = 0 < t_near ? t_near : 0, true );
+    }
+};
+
+} // namespace dispatch
+
+template <typename Indexable, typename Point, typename RelativeDistance> inline
+bool segment_intersection(Indexable const& b,
+                          Point const& p0,
+                          Point const& p1,
+                          RelativeDistance & relative_distance)
+{
+    // TODO check Indexable and Point concepts
+
+    return dispatch::segment_intersection<
+            Indexable, Point,
+            typename tag<Indexable>::type
+        >::apply(b, p0, p1, relative_distance);
+}
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_SEGMENT_INTERSECTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/smallest_for_indexable.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/smallest_for_indexable.hpp
new file mode 100644
index 00000000000..3ca335d5a75
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/smallest_for_indexable.hpp
@@ -0,0 +1,80 @@
+// Boost.Geometry Index
+//
+// Get smallest value calculated for indexable's dimensions, used in R-tree k nearest neighbors query
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_SMALLEST_FOR_INDEXABLE_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_SMALLEST_FOR_INDEXABLE_HPP
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+template <
+    typename Geometry,
+    typename Indexable,
+    typename IndexableTag,
+    typename AlgoTag,
+    size_t DimensionIndex>
+struct smallest_for_indexable_dimension
+{
+    BOOST_MPL_ASSERT_MSG(
+        (false),
+        NOT_IMPLEMENTED_FOR_THIS_INDEXABLE_TAG_TYPE,
+        (smallest_for_indexable_dimension));
+};
+
+template <
+    typename Geometry,
+    typename Indexable,
+    typename IndexableTag,
+    typename AlgoTag,
+    size_t N>
+struct smallest_for_indexable
+{
+    typedef typename smallest_for_indexable_dimension<
+        Geometry, Indexable, IndexableTag, AlgoTag, N - 1
+    >::result_type result_type;
+
+    template <typename Data>
+    inline static result_type apply(Geometry const& g, Indexable const& i, Data const& data)
+    {
+        result_type r1 = smallest_for_indexable<
+            Geometry, Indexable, IndexableTag, AlgoTag, N - 1
+        >::apply(g, i, data);
+
+        result_type r2 = smallest_for_indexable_dimension<
+            Geometry, Indexable, IndexableTag, AlgoTag, N - 1
+        >::apply(g, i, data);
+
+        return r1 < r2 ? r1 : r2;
+    }
+};
+
+template <
+    typename Geometry,
+    typename Indexable,
+    typename IndexableTag,
+    typename AlgoTag>
+struct smallest_for_indexable<Geometry, Indexable, IndexableTag, AlgoTag, 1>
+{
+    typedef typename smallest_for_indexable_dimension<
+        Geometry, Indexable, IndexableTag, AlgoTag, 0
+    >::result_type result_type;
+
+    template <typename Data>
+    inline static result_type apply(Geometry const& g, Indexable const& i, Data const& data)
+    {
+        return
+            smallest_for_indexable_dimension<
+                Geometry, Indexable, IndexableTag, AlgoTag, 0
+            >::apply(g, i, data);
+    }
+};
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_SMALLEST_FOR_INDEXABLE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/sum_for_indexable.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/sum_for_indexable.hpp
new file mode 100644
index 00000000000..4aef36352ec
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/sum_for_indexable.hpp
@@ -0,0 +1,76 @@
+// Boost.Geometry Index
+//
+// Sum values calculated for indexable's dimensions, used e.g. in R-tree k nearest neighbors query
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_SUM_FOR_INDEXABLE_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_SUM_FOR_INDEXABLE_HPP
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+template <
+    typename Geometry,
+    typename Indexable,
+    typename IndexableTag,
+    typename AlgoTag,
+    size_t DimensionIndex>
+struct sum_for_indexable_dimension
+{
+    BOOST_MPL_ASSERT_MSG(
+        (false),
+        NOT_IMPLEMENTED_FOR_THIS_INDEXABLE_TAG_TYPE,
+        (sum_for_indexable_dimension));
+};
+
+template <
+    typename Geometry,
+    typename Indexable,
+    typename IndexableTag,
+    typename AlgoTag,
+    size_t N>
+struct sum_for_indexable
+{
+    typedef typename sum_for_indexable_dimension<
+        Geometry, Indexable, IndexableTag, AlgoTag, N - 1
+    >::result_type result_type;
+
+    inline static result_type apply(Geometry const& g, Indexable const& i)
+    {
+        return
+            sum_for_indexable<
+                Geometry, Indexable, IndexableTag, AlgoTag, N - 1
+            >::apply(g, i) +
+            sum_for_indexable_dimension<
+                Geometry, Indexable, IndexableTag, AlgoTag, N - 1
+            >::apply(g, i);
+    }
+};
+
+template <
+    typename Geometry,
+    typename Indexable,
+    typename IndexableTag,
+    typename AlgoTag>
+struct sum_for_indexable<Geometry, Indexable, IndexableTag, AlgoTag, 1>
+{
+    typedef typename sum_for_indexable_dimension<
+        Geometry, Indexable, IndexableTag, AlgoTag, 0
+    >::result_type result_type;
+
+    inline static result_type apply(Geometry const& g, Indexable const& i)
+    {
+        return
+            sum_for_indexable_dimension<
+                Geometry, Indexable, IndexableTag, AlgoTag, 0
+            >::apply(g, i);
+    }
+};
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_SUM_FOR_INDEXABLE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/union_content.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/union_content.hpp
new file mode 100644
index 00000000000..3acdc3d1988
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/algorithms/union_content.hpp
@@ -0,0 +1,33 @@
+// Boost.Geometry Index
+//
+// boxes union/sum area/volume
+//
+// Copyright (c) 2008 Federico J. Fernandez.
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_UNION_CONTENT_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_UNION_CONTENT_HPP
+
+#include <boost/geometry/algorithms/expand.hpp>
+#include <boost/geometry/index/detail/algorithms/content.hpp>
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+/**
+ * \brief Compute the area of the union of b1 and b2
+ */
+template <typename Box, typename Geometry>
+inline typename default_content_result<Box>::type union_content(Box const& b, Geometry const& g)
+{
+    Box expanded_box(b);
+    geometry::expand(expanded_box, g);
+    return detail::content(expanded_box);
+}
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_ALGORITHMS_UNION_CONTENT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/assert.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/assert.hpp
new file mode 100644
index 00000000000..08889df4782
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/assert.hpp
@@ -0,0 +1,19 @@
+// Boost.Geometry Index
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_ASSERT_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_ASSERT_HPP
+
+#include <boost/geometry/core/assert.hpp>
+
+#undef BOOST_GEOMETRY_INDEX_ASSERT
+
+#define BOOST_GEOMETRY_INDEX_ASSERT(CONDITION, TEXT_MSG) \
+    BOOST_GEOMETRY_ASSERT_MSG(CONDITION, TEXT_MSG)
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_ASSERT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/bounded_view.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/bounded_view.hpp
new file mode 100644
index 00000000000..e5f489d76b6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/bounded_view.hpp
@@ -0,0 +1,215 @@
+// Boost.Geometry Index
+//
+// This view makes possible to treat some simple primitives as its bounding geometry
+// e.g. box, nsphere, etc.
+//
+// Copyright (c) 2014-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_BOUNDED_VIEW_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_BOUNDED_VIEW_HPP
+
+#include <boost/geometry/algorithms/envelope.hpp>
+
+namespace boost { namespace geometry {
+
+namespace index { namespace detail {
+
+template <typename Geometry,
+          typename BoundingGeometry,
+          typename Tag = typename geometry::tag<Geometry>::type,
+          typename BoundingTag = typename geometry::tag<BoundingGeometry>::type,
+          typename CSystem = typename geometry::coordinate_system<Geometry>::type>
+struct bounded_view
+{
+    BOOST_MPL_ASSERT_MSG(
+        (false),
+        NOT_IMPLEMENTED_FOR_THOSE_GEOMETRIES,
+        (BoundingTag, Tag));
+};
+
+
+// Segment -> Box
+
+template <typename Segment, typename Box>
+struct bounded_view<Segment, Box, segment_tag, box_tag, cs::cartesian>
+{
+public:
+    typedef typename geometry::coordinate_type<Box>::type coordinate_type;
+
+    explicit bounded_view(Segment const& segment)
+        : m_segment(segment)
+    {}
+    
+    template <std::size_t Dimension>
+    inline coordinate_type get_min() const
+    {
+        return boost::numeric_cast<coordinate_type>(
+                (std::min)( geometry::get<0, Dimension>(m_segment),
+                            geometry::get<1, Dimension>(m_segment) ) );
+    }
+
+    template <std::size_t Dimension>
+    inline coordinate_type get_max() const
+    {
+        return boost::numeric_cast<coordinate_type>(
+                (std::max)( geometry::get<0, Dimension>(m_segment),
+                            geometry::get<1, Dimension>(m_segment) ) );
+    }
+
+private:
+    Segment const& m_segment;
+};
+
+template <typename Segment, typename Box, typename CSystem>
+struct bounded_view<Segment, Box, segment_tag, box_tag, CSystem>
+{
+public:
+    typedef typename geometry::coordinate_type<Box>::type coordinate_type;
+
+    explicit bounded_view(Segment const& segment)
+    {
+        geometry::envelope(segment, m_box);
+    }
+
+    template <std::size_t Dimension>
+    inline coordinate_type get_min() const
+    {
+        return geometry::get<min_corner, Dimension>(m_box);
+    }
+
+    template <std::size_t Dimension>
+    inline coordinate_type get_max() const
+    {
+        return geometry::get<max_corner, Dimension>(m_box);
+    }
+
+private:
+    Box m_box;
+};
+
+// Box -> Box
+
+template <typename BoxIn, typename Box, typename CSystem>
+struct bounded_view<BoxIn, Box, box_tag, box_tag, CSystem>
+{
+public:
+    typedef typename geometry::coordinate_type<Box>::type coordinate_type;
+
+    explicit bounded_view(BoxIn const& box)
+        : m_box(box)
+    {}
+
+    template <std::size_t Dimension>
+    inline coordinate_type get_min() const
+    {
+        return boost::numeric_cast<coordinate_type>(
+                geometry::get<min_corner, Dimension>(m_box) );
+    }
+
+    template <std::size_t Dimension>
+    inline coordinate_type get_max() const
+    {
+        return boost::numeric_cast<coordinate_type>(
+                geometry::get<max_corner, Dimension>(m_box) );
+    }
+
+private:
+    BoxIn const& m_box;
+};
+
+// Point -> Box
+
+template <typename Point, typename Box, typename CSystem>
+struct bounded_view<Point, Box, point_tag, box_tag, CSystem>
+{
+public:
+    typedef typename geometry::coordinate_type<Box>::type coordinate_type;
+
+    explicit bounded_view(Point const& point)
+        : m_point(point)
+    {}
+
+    template <std::size_t Dimension>
+    inline coordinate_type get_min() const
+    {
+        return boost::numeric_cast<coordinate_type>(
+                geometry::get<Dimension>(m_point) );
+    }
+
+    template <std::size_t Dimension>
+    inline coordinate_type get_max() const
+    {
+        return boost::numeric_cast<coordinate_type>(
+                geometry::get<Dimension>(m_point) );
+    }
+
+private:
+    Point const& m_point;
+};
+
+}} // namespace index::detail
+
+// XXX -> Box
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+template <typename Geometry, typename Box, typename Tag, typename CSystem>
+struct tag< index::detail::bounded_view<Geometry, Box, Tag, box_tag, CSystem> >
+{
+    typedef box_tag type;
+};
+
+template <typename Geometry, typename Box, typename Tag, typename CSystem>
+struct point_type< index::detail::bounded_view<Geometry, Box, Tag, box_tag, CSystem> >
+{
+    typedef typename point_type<Box>::type type;
+};
+
+template <typename Geometry, typename Box, typename Tag, typename CSystem, std::size_t Dimension>
+struct indexed_access<index::detail::bounded_view<Geometry, Box, Tag, box_tag, CSystem>,
+                      min_corner, Dimension>
+{
+    typedef index::detail::bounded_view<Geometry, Box, Tag, box_tag, CSystem> box_type;
+    typedef typename geometry::coordinate_type<Box>::type coordinate_type;
+
+    static inline coordinate_type get(box_type const& b)
+    {
+        return b.template get_min<Dimension>();
+    }
+
+    //static inline void set(box_type & b, coordinate_type const& value)
+    //{
+    //    BOOST_GEOMETRY_INDEX_ASSERT(false, "unable to modify a box through view");
+    //}
+};
+
+template <typename Geometry, typename Box, typename Tag, typename CSystem, std::size_t Dimension>
+struct indexed_access<index::detail::bounded_view<Geometry, Box, Tag, box_tag, CSystem>,
+                      max_corner, Dimension>
+{
+    typedef index::detail::bounded_view<Geometry, Box, Tag, box_tag, CSystem> box_type;
+    typedef typename geometry::coordinate_type<Box>::type coordinate_type;
+
+    static inline coordinate_type get(box_type const& b)
+    {
+        return b.template get_max<Dimension>();
+    }
+
+    //static inline void set(box_type & b, coordinate_type const& value)
+    //{
+    //    BOOST_GEOMETRY_INDEX_ASSERT(false, "unable to modify a box through view");
+    //}
+};
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_BOUNDED_VIEW_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/config_begin.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/config_begin.hpp
new file mode 100644
index 00000000000..21c346012b3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/config_begin.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry Index
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_MSVC
+
+    #pragma warning (push)
+    #pragma warning (disable : 4512) // assignment operator could not be generated
+    #pragma warning (disable : 4127) // conditional expression is constant
+
+    // temporary?
+    #pragma warning (disable : 4180) // qualifier applied to function type has no meaning
+
+#endif   //BOOST_MSVC
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/config_end.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/config_end.hpp
new file mode 100644
index 00000000000..d144c33698d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/config_end.hpp
@@ -0,0 +1,12 @@
+// Boost.Geometry Index
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// Use, modification and distribution is subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#if defined BOOST_MSVC
+    #pragma warning (pop)
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/distance_predicates.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/distance_predicates.hpp
new file mode 100644
index 00000000000..9a9371df95f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/distance_predicates.hpp
@@ -0,0 +1,161 @@
+// Boost.Geometry Index
+//
+// Spatial index distance predicates, calculators and checkers
+// used in nearest query - specialized for envelopes
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_DISTANCE_PREDICATES_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_DISTANCE_PREDICATES_HPP
+
+#include <boost/geometry/index/detail/algorithms/comparable_distance_near.hpp>
+#include <boost/geometry/index/detail/algorithms/comparable_distance_far.hpp>
+#include <boost/geometry/index/detail/algorithms/comparable_distance_centroid.hpp>
+#include <boost/geometry/index/detail/algorithms/path_intersection.hpp>
+
+#include <boost/geometry/index/detail/tags.hpp>
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+// ------------------------------------------------------------------ //
+// relations
+// ------------------------------------------------------------------ //
+
+template <typename T>
+struct to_nearest
+{
+    to_nearest(T const& v) : value(v) {}
+    T value;
+};
+
+template <typename T>
+struct to_centroid
+{
+    to_centroid(T const& v) : value(v) {}
+    T value;
+};
+
+template <typename T>
+struct to_furthest
+{
+    to_furthest(T const& v) : value(v) {}
+    T value;
+};
+
+// tags
+
+struct to_nearest_tag {};
+struct to_centroid_tag {};
+struct to_furthest_tag {};
+
+// ------------------------------------------------------------------ //
+// relation traits and access
+// ------------------------------------------------------------------ //
+
+template <typename T>
+struct relation
+{
+    typedef T value_type;
+    typedef to_nearest_tag tag;
+    static inline T const& value(T const& v) { return v; }
+    static inline T & value(T & v) { return v; }
+};
+
+template <typename T>
+struct relation< to_nearest<T> >
+{
+    typedef T value_type;
+    typedef to_nearest_tag tag;
+    static inline T const& value(to_nearest<T> const& r) { return r.value; }
+    static inline T & value(to_nearest<T> & r) { return r.value; }
+};
+
+template <typename T>
+struct relation< to_centroid<T> >
+{
+    typedef T value_type;
+    typedef to_centroid_tag tag;
+    static inline T const& value(to_centroid<T> const& r) { return r.value; }
+    static inline T & value(to_centroid<T> & r) { return r.value; }
+};
+
+template <typename T>
+struct relation< to_furthest<T> >
+{
+    typedef T value_type;
+    typedef to_furthest_tag tag;
+    static inline T const& value(to_furthest<T> const& r) { return r.value; }
+    static inline T & value(to_furthest<T> & r) { return r.value; }
+};
+
+// ------------------------------------------------------------------ //
+// calculate_distance
+// ------------------------------------------------------------------ //
+
+template <typename Predicate, typename Indexable, typename Tag>
+struct calculate_distance
+{
+    BOOST_MPL_ASSERT_MSG((false), INVALID_PREDICATE_OR_TAG, (calculate_distance));
+};
+
+// this handles nearest() with default Point parameter, to_nearest() and bounds
+template <typename PointRelation, typename Indexable, typename Tag>
+struct calculate_distance< predicates::nearest<PointRelation>, Indexable, Tag >
+{
+    typedef detail::relation<PointRelation> relation;
+    typedef typename relation::value_type point_type;
+    typedef typename geometry::default_comparable_distance_result<point_type, Indexable>::type result_type;
+
+    static inline bool apply(predicates::nearest<PointRelation> const& p, Indexable const& i, result_type & result)
+    {
+        result = geometry::comparable_distance(relation::value(p.point_or_relation), i);
+        return true;
+    }
+};
+
+template <typename Point, typename Indexable>
+struct calculate_distance< predicates::nearest< to_centroid<Point> >, Indexable, value_tag>
+{
+    typedef Point point_type;
+    typedef typename geometry::default_comparable_distance_result<point_type, Indexable>::type result_type;
+
+    static inline bool apply(predicates::nearest< to_centroid<Point> > const& p, Indexable const& i, result_type & result)
+    {
+        result = index::detail::comparable_distance_centroid(p.point_or_relation.value, i);
+        return true;
+    }
+};
+
+template <typename Point, typename Indexable>
+struct calculate_distance< predicates::nearest< to_furthest<Point> >, Indexable, value_tag>
+{
+    typedef Point point_type;
+    typedef typename geometry::default_comparable_distance_result<point_type, Indexable>::type result_type;
+
+    static inline bool apply(predicates::nearest< to_furthest<Point> > const& p, Indexable const& i, result_type & result)
+    {
+        result = index::detail::comparable_distance_far(p.point_or_relation.value, i);
+        return true;
+    }
+};
+
+template <typename SegmentOrLinestring, typename Indexable, typename Tag>
+struct calculate_distance< predicates::path<SegmentOrLinestring>, Indexable, Tag>
+{
+    typedef typename index::detail::default_path_intersection_distance_type<
+        Indexable, SegmentOrLinestring
+    >::type result_type;
+
+    static inline bool apply(predicates::path<SegmentOrLinestring> const& p, Indexable const& i, result_type & result)
+    {
+        return index::detail::path_intersection(i, p.geometry, result);
+    }
+};
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_RTREE_DISTANCE_PREDICATES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/exception.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/exception.hpp
new file mode 100644
index 00000000000..e2090533e7e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/exception.hpp
@@ -0,0 +1,87 @@
+// Boost.Geometry Index
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_EXCEPTION_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_EXCEPTION_HPP
+
+#include <boost/core/no_exceptions_support.hpp>
+
+#ifndef BOOST_NO_EXCEPTIONS
+#include <stdexcept>
+#include <boost/throw_exception.hpp>
+#else
+#include <cstdlib>
+#include <boost/geometry/index/detail/assert.hpp>
+#endif
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+#ifndef BOOST_NO_EXCEPTIONS
+
+inline void throw_runtime_error(const char * str)
+{
+    BOOST_THROW_EXCEPTION(std::runtime_error(str));
+}
+
+inline void throw_logic_error(const char * str)
+{
+    BOOST_THROW_EXCEPTION(std::logic_error(str));
+}
+
+inline void throw_invalid_argument(const char * str)
+{
+    BOOST_THROW_EXCEPTION(std::invalid_argument(str));
+}
+
+inline void throw_length_error(const char * str)
+{
+    BOOST_THROW_EXCEPTION(std::length_error(str));
+}
+
+inline void throw_out_of_range(const char * str)
+{
+    BOOST_THROW_EXCEPTION(std::out_of_range(str));
+}
+
+#else
+
+inline void throw_runtime_error(const char * str)
+{
+    BOOST_GEOMETRY_INDEX_ASSERT(!"runtime_error thrown", str);
+    std::abort();
+}
+
+inline void throw_logic_error(const char * str)
+{
+    BOOST_GEOMETRY_INDEX_ASSERT(!"logic_error thrown", str);
+    std::abort();
+}
+
+inline void throw_invalid_argument(const char * str)
+{
+    BOOST_GEOMETRY_INDEX_ASSERT(!"invalid_argument thrown", str);
+    std::abort();
+}
+
+inline void throw_length_error(const char * str)
+{
+    BOOST_GEOMETRY_INDEX_ASSERT(!"length_error thrown", str);
+    std::abort();
+}
+
+inline void throw_out_of_range(const char * str)
+{
+    BOOST_GEOMETRY_INDEX_ASSERT(!"out_of_range thrown", str);
+    std::abort();
+}
+
+#endif
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_EXCEPTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/is_bounding_geometry.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/is_bounding_geometry.hpp
new file mode 100644
index 00000000000..d14204af71c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/is_bounding_geometry.hpp
@@ -0,0 +1,35 @@
+// Boost.Geometry Index
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_IS_BOUNDING_GEOMETRY_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_IS_BOUNDING_GEOMETRY_HPP
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+template
+<
+    typename Geometry,
+    typename Tag = typename geometry::tag<Geometry>::type
+>
+struct is_bounding_geometry
+{
+    static const bool value = false;
+};
+
+template <typename Box>
+struct is_bounding_geometry<Box, box_tag>
+{
+    static const bool value = true;
+};
+
+}}}} // namespave boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_IS_BOUNDING_GEOMETRY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/is_indexable.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/is_indexable.hpp
new file mode 100644
index 00000000000..1e86463a379
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/is_indexable.hpp
@@ -0,0 +1,47 @@
+// Boost.Geometry Index
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_IS_INDEXABLE_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_IS_INDEXABLE_HPP
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+template
+<
+    typename Geometry,
+    typename Tag = typename geometry::tag<Geometry>::type
+>
+struct is_indexable
+{
+    static const bool value = false;
+};
+
+template <typename Point>
+struct is_indexable<Point, geometry::point_tag>
+{
+    static const bool value = true;
+};
+
+template <typename Box>
+struct is_indexable<Box, geometry::box_tag>
+{
+    static const bool value = true;
+};
+
+template <typename Segment>
+struct is_indexable<Segment, geometry::segment_tag>
+{
+    static const bool value = true;
+};
+
+}}}} // namespave boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_IS_INDEXABLE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/meta.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/meta.hpp
new file mode 100644
index 00000000000..bec1380b068
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/meta.hpp
@@ -0,0 +1,42 @@
+// Boost.Geometry Index
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#include <boost/range.hpp>
+#include <boost/mpl/aux_/has_type.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/and.hpp>
+//#include <boost/type_traits/is_convertible.hpp>
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_META_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_META_HPP
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+template <typename T>
+struct is_range
+    : ::boost::mpl::aux::has_type< ::boost::range_iterator<T> >
+{};
+
+//template <typename T, typename V, bool IsRange>
+//struct is_range_of_convertible_values_impl
+//    : ::boost::is_convertible<typename ::boost::range_value<T>::type, V>
+//{};
+//
+//template <typename T, typename V>
+//struct is_range_of_convertible_values_impl<T, V, false>
+//    : ::boost::mpl::bool_<false>
+//{};
+//
+//template <typename T, typename V>
+//struct is_range_of_convertible_values
+//    : is_range_of_convertible_values_impl<T, V, is_range<T>::value>
+//{};
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_META_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/predicates.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/predicates.hpp
new file mode 100644
index 00000000000..72c6c661b72
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/predicates.hpp
@@ -0,0 +1,831 @@
+// Boost.Geometry Index
+//
+// Spatial query predicates definition and checks.
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_PREDICATES_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_PREDICATES_HPP
+
+//#include <utility>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/tuple/tuple.hpp>
+
+#include <boost/geometry/index/detail/tags.hpp>
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+namespace predicates {
+
+// ------------------------------------------------------------------ //
+// predicates
+// ------------------------------------------------------------------ //
+
+template <typename Fun, bool IsFunction>
+struct satisfies_impl
+{
+    satisfies_impl() : fun(NULL) {}
+    satisfies_impl(Fun f) : fun(f) {}
+    Fun * fun;
+};
+
+template <typename Fun>
+struct satisfies_impl<Fun, false>
+{
+    satisfies_impl() {}
+    satisfies_impl(Fun const& f) : fun(f) {}
+    Fun fun;
+};
+
+template <typename Fun, bool Negated>
+struct satisfies
+    : satisfies_impl<Fun, ::boost::is_function<Fun>::value>
+{
+    typedef satisfies_impl<Fun, ::boost::is_function<Fun>::value> base;
+
+    satisfies() {}
+    satisfies(Fun const& f) : base(f) {}
+    satisfies(base const& b) : base(b) {}
+};
+
+// ------------------------------------------------------------------ //
+
+struct contains_tag {};
+struct covered_by_tag {};
+struct covers_tag {};
+struct disjoint_tag {};
+struct intersects_tag {};
+struct overlaps_tag {};
+struct touches_tag {};
+struct within_tag {};
+
+template <typename Geometry, typename Tag, bool Negated>
+struct spatial_predicate
+{
+    spatial_predicate() {}
+    spatial_predicate(Geometry const& g) : geometry(g) {}
+    Geometry geometry;
+};
+
+// ------------------------------------------------------------------ //
+
+// CONSIDER: separated nearest<> and path<> may be replaced by
+//           nearest_predicate<Geometry, Tag>
+//           where Tag = point_tag | path_tag
+// IMPROVEMENT: user-defined nearest predicate allowing to define
+//              all or only geometrical aspects of the search
+
+template <typename PointOrRelation>
+struct nearest
+{
+    nearest()
+//        : count(0)
+    {}
+    nearest(PointOrRelation const& por, unsigned k)
+        : point_or_relation(por)
+        , count(k)
+    {}
+    PointOrRelation point_or_relation;
+    unsigned count;
+};
+
+template <typename SegmentOrLinestring>
+struct path
+{
+    path()
+//        : count(0)
+    {}
+    path(SegmentOrLinestring const& g, unsigned k)
+        : geometry(g)
+        , count(k)
+    {}
+    SegmentOrLinestring geometry;
+    unsigned count;
+};
+
+} // namespace predicates
+
+// ------------------------------------------------------------------ //
+// predicate_check
+// ------------------------------------------------------------------ //
+
+template <typename Predicate, typename Tag>
+struct predicate_check
+{
+    BOOST_MPL_ASSERT_MSG(
+        (false),
+        NOT_IMPLEMENTED_FOR_THIS_PREDICATE_OR_TAG,
+        (predicate_check));
+};
+
+// ------------------------------------------------------------------ //
+
+template <typename Fun>
+struct predicate_check<predicates::satisfies<Fun, false>, value_tag>
+{
+    template <typename Value, typename Indexable>
+    static inline bool apply(predicates::satisfies<Fun, false> const& p, Value const& v, Indexable const&)
+    {
+        return p.fun(v);
+    }
+};
+
+template <typename Fun>
+struct predicate_check<predicates::satisfies<Fun, true>, value_tag>
+{
+    template <typename Value, typename Indexable>
+    static inline bool apply(predicates::satisfies<Fun, true> const& p, Value const& v, Indexable const&)
+    {
+        return !p.fun(v);
+    }
+};
+
+// ------------------------------------------------------------------ //
+
+template <typename Tag>
+struct spatial_predicate_call
+{
+    BOOST_MPL_ASSERT_MSG(false, NOT_IMPLEMENTED_FOR_THIS_TAG, (Tag));
+};
+
+template <>
+struct spatial_predicate_call<predicates::contains_tag>
+{
+    template <typename G1, typename G2>
+    static inline bool apply(G1 const& g1, G2 const& g2)
+    {
+        return geometry::within(g2, g1);
+    }
+};
+
+template <>
+struct spatial_predicate_call<predicates::covered_by_tag>
+{
+    template <typename G1, typename G2>
+    static inline bool apply(G1 const& g1, G2 const& g2)
+    {
+        return geometry::covered_by(g1, g2);
+    }
+};
+
+template <>
+struct spatial_predicate_call<predicates::covers_tag>
+{
+    template <typename G1, typename G2>
+    static inline bool apply(G1 const& g1, G2 const& g2)
+    {
+        return geometry::covered_by(g2, g1);
+    }
+};
+
+template <>
+struct spatial_predicate_call<predicates::disjoint_tag>
+{
+    template <typename G1, typename G2>
+    static inline bool apply(G1 const& g1, G2 const& g2)
+    {
+        return geometry::disjoint(g1, g2);
+    }
+};
+
+template <>
+struct spatial_predicate_call<predicates::intersects_tag>
+{
+    template <typename G1, typename G2>
+    static inline bool apply(G1 const& g1, G2 const& g2)
+    {
+        return geometry::intersects(g1, g2);
+    }
+};
+
+template <>
+struct spatial_predicate_call<predicates::overlaps_tag>
+{
+    template <typename G1, typename G2>
+    static inline bool apply(G1 const& g1, G2 const& g2)
+    {
+        return geometry::overlaps(g1, g2);
+    }
+};
+
+template <>
+struct spatial_predicate_call<predicates::touches_tag>
+{
+    template <typename G1, typename G2>
+    static inline bool apply(G1 const& g1, G2 const& g2)
+    {
+        return geometry::touches(g1, g2);
+    }
+};
+
+template <>
+struct spatial_predicate_call<predicates::within_tag>
+{
+    template <typename G1, typename G2>
+    static inline bool apply(G1 const& g1, G2 const& g2)
+    {
+        return geometry::within(g1, g2);
+    }
+};
+
+// ------------------------------------------------------------------ //
+
+// spatial predicate
+template <typename Geometry, typename Tag>
+struct predicate_check<predicates::spatial_predicate<Geometry, Tag, false>, value_tag>
+{
+    typedef predicates::spatial_predicate<Geometry, Tag, false> Pred;
+
+    template <typename Value, typename Indexable>
+    static inline bool apply(Pred const& p, Value const&, Indexable const& i)
+    {
+        return spatial_predicate_call<Tag>::apply(i, p.geometry);
+    }
+};
+
+// negated spatial predicate
+template <typename Geometry, typename Tag>
+struct predicate_check<predicates::spatial_predicate<Geometry, Tag, true>, value_tag>
+{
+    typedef predicates::spatial_predicate<Geometry, Tag, true> Pred;
+
+    template <typename Value, typename Indexable>
+    static inline bool apply(Pred const& p, Value const&, Indexable const& i)
+    {
+        return !spatial_predicate_call<Tag>::apply(i, p.geometry);
+    }
+};
+
+// ------------------------------------------------------------------ //
+
+template <typename DistancePredicates>
+struct predicate_check<predicates::nearest<DistancePredicates>, value_tag>
+{
+    template <typename Value, typename Box>
+    static inline bool apply(predicates::nearest<DistancePredicates> const&, Value const&, Box const&)
+    {
+        return true;
+    }
+};
+
+template <typename Linestring>
+struct predicate_check<predicates::path<Linestring>, value_tag>
+{
+    template <typename Value, typename Box>
+    static inline bool apply(predicates::path<Linestring> const&, Value const&, Box const&)
+    {
+        return true;
+    }
+};
+
+// ------------------------------------------------------------------ //
+// predicates_check for bounds
+// ------------------------------------------------------------------ //
+
+template <typename Fun, bool Negated>
+struct predicate_check<predicates::satisfies<Fun, Negated>, bounds_tag>
+{
+    template <typename Value, typename Box>
+    static bool apply(predicates::satisfies<Fun, Negated> const&, Value const&, Box const&)
+    {
+        return true;
+    }
+};
+
+// ------------------------------------------------------------------ //
+
+// NOT NEGATED
+// value_tag        bounds_tag
+// ---------------------------
+// contains(I,G)    covers(I,G)
+// covered_by(I,G)  intersects(I,G)
+// covers(I,G)      covers(I,G)
+// disjoint(I,G)    !covered_by(I,G)
+// intersects(I,G)  intersects(I,G)
+// overlaps(I,G)    intersects(I,G)  - possibly change to the version without border case, e.g. intersects_without_border(0,0x1,1, 1,1x2,2) should give false
+// touches(I,G)     intersects(I,G)
+// within(I,G)      intersects(I,G)  - possibly change to the version without border case, e.g. intersects_without_border(0,0x1,1, 1,1x2,2) should give false
+
+// spatial predicate - default
+template <typename Geometry, typename Tag>
+struct predicate_check<predicates::spatial_predicate<Geometry, Tag, false>, bounds_tag>
+{
+    typedef predicates::spatial_predicate<Geometry, Tag, false> Pred;
+
+    template <typename Value, typename Indexable>
+    static inline bool apply(Pred const& p, Value const&, Indexable const& i)
+    {
+        return spatial_predicate_call<predicates::intersects_tag>::apply(i, p.geometry);
+    }
+};
+
+// spatial predicate - contains
+template <typename Geometry>
+struct predicate_check<predicates::spatial_predicate<Geometry, predicates::contains_tag, false>, bounds_tag>
+{
+    typedef predicates::spatial_predicate<Geometry, predicates::contains_tag, false> Pred;
+
+    template <typename Value, typename Indexable>
+    static inline bool apply(Pred const& p, Value const&, Indexable const& i)
+    {
+        return spatial_predicate_call<predicates::covers_tag>::apply(i, p.geometry);
+    }
+};
+
+// spatial predicate - covers
+template <typename Geometry>
+struct predicate_check<predicates::spatial_predicate<Geometry, predicates::covers_tag, false>, bounds_tag>
+{
+    typedef predicates::spatial_predicate<Geometry, predicates::covers_tag, false> Pred;
+
+    template <typename Value, typename Indexable>
+    static inline bool apply(Pred const& p, Value const&, Indexable const& i)
+    {
+        return spatial_predicate_call<predicates::covers_tag>::apply(i, p.geometry);
+    }
+};
+
+// spatial predicate - disjoint
+template <typename Geometry>
+struct predicate_check<predicates::spatial_predicate<Geometry, predicates::disjoint_tag, false>, bounds_tag>
+{
+    typedef predicates::spatial_predicate<Geometry, predicates::disjoint_tag, false> Pred;
+
+    template <typename Value, typename Indexable>
+    static inline bool apply(Pred const& p, Value const&, Indexable const& i)
+    {
+        return !spatial_predicate_call<predicates::covered_by_tag>::apply(i, p.geometry);
+    }
+};
+
+// NEGATED
+// value_tag        bounds_tag
+// ---------------------------
+// !contains(I,G)   TRUE
+// !covered_by(I,G) !covered_by(I,G)
+// !covers(I,G)     TRUE
+// !disjoint(I,G)   !disjoint(I,G)
+// !intersects(I,G) !covered_by(I,G)
+// !overlaps(I,G)   TRUE
+// !touches(I,G)    !intersects(I,G)
+// !within(I,G)     !within(I,G)
+
+// negated spatial predicate - default
+template <typename Geometry, typename Tag>
+struct predicate_check<predicates::spatial_predicate<Geometry, Tag, true>, bounds_tag>
+{
+    typedef predicates::spatial_predicate<Geometry, Tag, true> Pred;
+
+    template <typename Value, typename Indexable>
+    static inline bool apply(Pred const& p, Value const&, Indexable const& i)
+    {
+        return !spatial_predicate_call<Tag>::apply(i, p.geometry);
+    }
+};
+
+// negated spatial predicate - contains
+template <typename Geometry>
+struct predicate_check<predicates::spatial_predicate<Geometry, predicates::contains_tag, true>, bounds_tag>
+{
+    typedef predicates::spatial_predicate<Geometry, predicates::contains_tag, true> Pred;
+
+    template <typename Value, typename Indexable>
+    static inline bool apply(Pred const& , Value const&, Indexable const& )
+    {
+        return true;
+    }
+};
+
+// negated spatial predicate - covers
+template <typename Geometry>
+struct predicate_check<predicates::spatial_predicate<Geometry, predicates::covers_tag, true>, bounds_tag>
+{
+    typedef predicates::spatial_predicate<Geometry, predicates::covers_tag, true> Pred;
+
+    template <typename Value, typename Indexable>
+    static inline bool apply(Pred const& , Value const&, Indexable const& )
+    {
+        return true;
+    }
+};
+
+// negated spatial predicate - intersects
+template <typename Geometry>
+struct predicate_check<predicates::spatial_predicate<Geometry, predicates::intersects_tag, true>, bounds_tag>
+{
+    typedef predicates::spatial_predicate<Geometry, predicates::intersects_tag, true> Pred;
+
+    template <typename Value, typename Indexable>
+    static inline bool apply(Pred const& p, Value const&, Indexable const& i)
+    {
+        return !spatial_predicate_call<predicates::covered_by_tag>::apply(i, p.geometry);
+    }
+};
+
+// negated spatial predicate - overlaps
+template <typename Geometry>
+struct predicate_check<predicates::spatial_predicate<Geometry, predicates::overlaps_tag, true>, bounds_tag>
+{
+    typedef predicates::spatial_predicate<Geometry, predicates::overlaps_tag, true> Pred;
+
+    template <typename Value, typename Indexable>
+    static inline bool apply(Pred const& , Value const&, Indexable const& )
+    {
+        return true;
+    }
+};
+
+// negated spatial predicate - touches
+template <typename Geometry>
+struct predicate_check<predicates::spatial_predicate<Geometry, predicates::touches_tag, true>, bounds_tag>
+{
+    typedef predicates::spatial_predicate<Geometry, predicates::touches_tag, true> Pred;
+
+    template <typename Value, typename Indexable>
+    static inline bool apply(Pred const& p, Value const&, Indexable const& i)
+    {
+        return !spatial_predicate_call<predicates::intersects_tag>::apply(i, p.geometry);
+    }
+};
+
+// ------------------------------------------------------------------ //
+
+template <typename DistancePredicates>
+struct predicate_check<predicates::nearest<DistancePredicates>, bounds_tag>
+{
+    template <typename Value, typename Box>
+    static inline bool apply(predicates::nearest<DistancePredicates> const&, Value const&, Box const&)
+    {
+        return true;
+    }
+};
+
+template <typename Linestring>
+struct predicate_check<predicates::path<Linestring>, bounds_tag>
+{
+    template <typename Value, typename Box>
+    static inline bool apply(predicates::path<Linestring> const&, Value const&, Box const&)
+    {
+        return true;
+    }
+};
+
+// ------------------------------------------------------------------ //
+// predicates_length
+// ------------------------------------------------------------------ //
+
+template <typename T>
+struct predicates_length
+{
+    static const unsigned value = 1;
+};
+
+//template <typename F, typename S>
+//struct predicates_length< std::pair<F, S> >
+//{
+//    static const unsigned value = 2;
+//};
+
+//template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+//struct predicates_length< boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >
+//{
+//    static const unsigned value = boost::tuples::length< boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >::value;
+//};
+
+template <typename Head, typename Tail>
+struct predicates_length< boost::tuples::cons<Head, Tail> >
+{
+    static const unsigned value = boost::tuples::length< boost::tuples::cons<Head, Tail> >::value;
+};
+
+// ------------------------------------------------------------------ //
+// predicates_element
+// ------------------------------------------------------------------ //
+
+template <unsigned I, typename T>
+struct predicates_element
+{
+    BOOST_MPL_ASSERT_MSG((I < 1), INVALID_INDEX, (predicates_element));
+    typedef T type;
+    static type const& get(T const& p) { return p; }
+};
+
+//template <unsigned I, typename F, typename S>
+//struct predicates_element< I, std::pair<F, S> >
+//{
+//    BOOST_MPL_ASSERT_MSG((I < 2), INVALID_INDEX, (predicates_element));
+//
+//    typedef F type;
+//    static type const& get(std::pair<F, S> const& p) { return p.first; }
+//};
+//
+//template <typename F, typename S>
+//struct predicates_element< 1, std::pair<F, S> >
+//{
+//    typedef S type;
+//    static type const& get(std::pair<F, S> const& p) { return p.second; }
+//};
+//
+//template <unsigned I, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+//struct predicates_element< I, boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >
+//{
+//    typedef boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> predicate_type;
+//
+//    typedef typename boost::tuples::element<I, predicate_type>::type type;
+//    static type const& get(predicate_type const& p) { return boost::get<I>(p); }
+//};
+
+template <unsigned I, typename Head, typename Tail>
+struct predicates_element< I, boost::tuples::cons<Head, Tail> >
+{
+    typedef boost::tuples::cons<Head, Tail> predicate_type;
+
+    typedef typename boost::tuples::element<I, predicate_type>::type type;
+    static type const& get(predicate_type const& p) { return boost::get<I>(p); }
+};
+
+// ------------------------------------------------------------------ //
+// predicates_check
+// ------------------------------------------------------------------ //
+
+//template <typename PairPredicates, typename Tag, unsigned First, unsigned Last>
+//struct predicates_check_pair {};
+//
+//template <typename PairPredicates, typename Tag, unsigned I>
+//struct predicates_check_pair<PairPredicates, Tag, I, I>
+//{
+//    template <typename Value, typename Indexable>
+//    static inline bool apply(PairPredicates const& , Value const& , Indexable const& )
+//    {
+//        return true;
+//    }
+//};
+//
+//template <typename PairPredicates, typename Tag>
+//struct predicates_check_pair<PairPredicates, Tag, 0, 1>
+//{
+//    template <typename Value, typename Indexable>
+//    static inline bool apply(PairPredicates const& p, Value const& v, Indexable const& i)
+//    {
+//        return predicate_check<typename PairPredicates::first_type, Tag>::apply(p.first, v, i);
+//    }
+//};
+//
+//template <typename PairPredicates, typename Tag>
+//struct predicates_check_pair<PairPredicates, Tag, 1, 2>
+//{
+//    template <typename Value, typename Indexable>
+//    static inline bool apply(PairPredicates const& p, Value const& v, Indexable const& i)
+//    {
+//        return predicate_check<typename PairPredicates::second_type, Tag>::apply(p.second, v, i);
+//    }
+//};
+//
+//template <typename PairPredicates, typename Tag>
+//struct predicates_check_pair<PairPredicates, Tag, 0, 2>
+//{
+//    template <typename Value, typename Indexable>
+//    static inline bool apply(PairPredicates const& p, Value const& v, Indexable const& i)
+//    {
+//        return predicate_check<typename PairPredicates::first_type, Tag>::apply(p.first, v, i)
+//            && predicate_check<typename PairPredicates::second_type, Tag>::apply(p.second, v, i);
+//    }
+//};
+
+template <typename TuplePredicates, typename Tag, unsigned First, unsigned Last>
+struct predicates_check_tuple
+{
+    template <typename Value, typename Indexable>
+    static inline bool apply(TuplePredicates const& p, Value const& v, Indexable const& i)
+    {
+        return
+        predicate_check<
+            typename boost::tuples::element<First, TuplePredicates>::type,
+            Tag
+        >::apply(boost::get<First>(p), v, i) &&
+        predicates_check_tuple<TuplePredicates, Tag, First+1, Last>::apply(p, v, i);
+    }
+};
+
+template <typename TuplePredicates, typename Tag, unsigned First>
+struct predicates_check_tuple<TuplePredicates, Tag, First, First>
+{
+    template <typename Value, typename Indexable>
+    static inline bool apply(TuplePredicates const& , Value const& , Indexable const& )
+    {
+        return true;
+    }
+};
+
+template <typename Predicate, typename Tag, unsigned First, unsigned Last>
+struct predicates_check_impl
+{
+    static const bool check = First < 1 && Last <= 1 && First <= Last;
+    BOOST_MPL_ASSERT_MSG((check), INVALID_INDEXES, (predicates_check_impl));
+
+    template <typename Value, typename Indexable>
+    static inline bool apply(Predicate const& p, Value const& v, Indexable const& i)
+    {
+        return predicate_check<Predicate, Tag>::apply(p, v, i);
+    }
+};
+
+//template <typename Predicate1, typename Predicate2, typename Tag, size_t First, size_t Last>
+//struct predicates_check_impl<std::pair<Predicate1, Predicate2>, Tag, First, Last>
+//{
+//    BOOST_MPL_ASSERT_MSG((First < 2 && Last <= 2 && First <= Last), INVALID_INDEXES, (predicates_check_impl));
+//
+//    template <typename Value, typename Indexable>
+//    static inline bool apply(std::pair<Predicate1, Predicate2> const& p, Value const& v, Indexable const& i)
+//    {
+//        return predicate_check<Predicate1, Tag>::apply(p.first, v, i)
+//            && predicate_check<Predicate2, Tag>::apply(p.second, v, i);
+//    }
+//};
+//
+//template <
+//    typename T0, typename T1, typename T2, typename T3, typename T4,
+//    typename T5, typename T6, typename T7, typename T8, typename T9,
+//    typename Tag, unsigned First, unsigned Last
+//>
+//struct predicates_check_impl<
+//    boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>,
+//    Tag, First, Last
+//>
+//{
+//    typedef boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> predicates_type;
+//
+//    static const unsigned pred_len = boost::tuples::length<predicates_type>::value;
+//    BOOST_MPL_ASSERT_MSG((First < pred_len && Last <= pred_len && First <= Last), INVALID_INDEXES, (predicates_check_impl));
+//
+//    template <typename Value, typename Indexable>
+//    static inline bool apply(predicates_type const& p, Value const& v, Indexable const& i)
+//    {
+//        return predicates_check_tuple<
+//            predicates_type,
+//            Tag, First, Last
+//        >::apply(p, v, i);
+//    }
+//};
+
+template <typename Head, typename Tail, typename Tag, unsigned First, unsigned Last>
+struct predicates_check_impl<
+    boost::tuples::cons<Head, Tail>,
+    Tag, First, Last
+>
+{
+    typedef boost::tuples::cons<Head, Tail> predicates_type;
+
+    static const unsigned pred_len = boost::tuples::length<predicates_type>::value;
+    static const bool check = First < pred_len && Last <= pred_len && First <= Last;
+    BOOST_MPL_ASSERT_MSG((check), INVALID_INDEXES, (predicates_check_impl));
+
+    template <typename Value, typename Indexable>
+    static inline bool apply(predicates_type const& p, Value const& v, Indexable const& i)
+    {
+        return predicates_check_tuple<
+            predicates_type,
+            Tag, First, Last
+        >::apply(p, v, i);
+    }
+};
+
+template <typename Tag, unsigned First, unsigned Last, typename Predicates, typename Value, typename Indexable>
+inline bool predicates_check(Predicates const& p, Value const& v, Indexable const& i)
+{
+    return detail::predicates_check_impl<Predicates, Tag, First, Last>
+        ::apply(p, v, i);
+}
+
+// ------------------------------------------------------------------ //
+// nearest predicate helpers
+// ------------------------------------------------------------------ //
+
+// predicates_is_nearest
+
+template <typename P>
+struct predicates_is_distance
+{
+    static const unsigned value = 0;
+};
+
+template <typename DistancePredicates>
+struct predicates_is_distance< predicates::nearest<DistancePredicates> >
+{
+    static const unsigned value = 1;
+};
+
+template <typename Linestring>
+struct predicates_is_distance< predicates::path<Linestring> >
+{
+    static const unsigned value = 1;
+};
+
+// predicates_count_nearest
+
+template <typename T>
+struct predicates_count_distance
+{
+    static const unsigned value = predicates_is_distance<T>::value;
+};
+
+//template <typename F, typename S>
+//struct predicates_count_distance< std::pair<F, S> >
+//{
+//    static const unsigned value = predicates_is_distance<F>::value
+//                                + predicates_is_distance<S>::value;
+//};
+
+template <typename Tuple, unsigned N>
+struct predicates_count_distance_tuple
+{
+    static const unsigned value =
+        predicates_is_distance<typename boost::tuples::element<N-1, Tuple>::type>::value
+        + predicates_count_distance_tuple<Tuple, N-1>::value;
+};
+
+template <typename Tuple>
+struct predicates_count_distance_tuple<Tuple, 1>
+{
+    static const unsigned value =
+        predicates_is_distance<typename boost::tuples::element<0, Tuple>::type>::value;
+};
+
+//template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+//struct predicates_count_distance< boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >
+//{
+//    static const unsigned value = predicates_count_distance_tuple<
+//        boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>,
+//        boost::tuples::length< boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >::value
+//    >::value;
+//};
+
+template <typename Head, typename Tail>
+struct predicates_count_distance< boost::tuples::cons<Head, Tail> >
+{
+    static const unsigned value = predicates_count_distance_tuple<
+        boost::tuples::cons<Head, Tail>,
+        boost::tuples::length< boost::tuples::cons<Head, Tail> >::value
+    >::value;
+};
+
+// predicates_find_nearest
+
+template <typename T>
+struct predicates_find_distance
+{
+    static const unsigned value = predicates_is_distance<T>::value ? 0 : 1;
+};
+
+//template <typename F, typename S>
+//struct predicates_find_distance< std::pair<F, S> >
+//{
+//    static const unsigned value = predicates_is_distance<F>::value ? 0 :
+//                                    (predicates_is_distance<S>::value ? 1 : 2);
+//};
+
+template <typename Tuple, unsigned N>
+struct predicates_find_distance_tuple
+{
+    static const bool is_found = predicates_find_distance_tuple<Tuple, N-1>::is_found
+                                || predicates_is_distance<typename boost::tuples::element<N-1, Tuple>::type>::value;
+
+    static const unsigned value = predicates_find_distance_tuple<Tuple, N-1>::is_found ?
+        predicates_find_distance_tuple<Tuple, N-1>::value :
+        (predicates_is_distance<typename boost::tuples::element<N-1, Tuple>::type>::value ?
+            N-1 : boost::tuples::length<Tuple>::value);
+};
+
+template <typename Tuple>
+struct predicates_find_distance_tuple<Tuple, 1>
+{
+    static const bool is_found = predicates_is_distance<typename boost::tuples::element<0, Tuple>::type>::value;
+    static const unsigned value = is_found ? 0 : boost::tuples::length<Tuple>::value;
+};
+
+//template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+//struct predicates_find_distance< boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >
+//{
+//    static const unsigned value = predicates_find_distance_tuple<
+//        boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>,
+//        boost::tuples::length< boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> >::value
+//    >::value;
+//};
+
+template <typename Head, typename Tail>
+struct predicates_find_distance< boost::tuples::cons<Head, Tail> >
+{
+    static const unsigned value = predicates_find_distance_tuple<
+        boost::tuples::cons<Head, Tail>,
+        boost::tuples::length< boost::tuples::cons<Head, Tail> >::value
+    >::value;
+};
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_PREDICATES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/adaptors.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/adaptors.hpp
new file mode 100644
index 00000000000..4e0eb9ba0a8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/adaptors.hpp
@@ -0,0 +1,54 @@
+// Boost.Geometry Index
+//
+// R-tree queries range adaptors
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_ADAPTORS_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_ADAPTORS_HPP
+
+#include <deque>
+#include <boost/static_assert.hpp>
+
+#include <boost/geometry/index/adaptors/query.hpp>
+
+namespace boost { namespace geometry { namespace index {
+
+template <typename Value, typename Options, typename IndexableGetter, typename EqualTo, typename Allocator>
+class rtree;
+
+namespace adaptors { namespace detail {
+
+template <typename Value, typename Options, typename IndexableGetter, typename EqualTo, typename Allocator>
+class query_range< index::rtree<Value, Options, IndexableGetter, EqualTo, Allocator> >
+{
+public:
+    typedef std::vector<Value> result_type;
+    typedef typename result_type::iterator iterator;
+    typedef typename result_type::const_iterator const_iterator;
+
+    template <typename Predicates> inline
+    query_range(index::rtree<Value, Options, IndexableGetter, EqualTo, Allocator> const& rtree,
+                Predicates const& pred)
+    {
+        rtree.query(pred, std::back_inserter(m_result));
+    }
+
+    inline iterator begin() { return m_result.begin(); }
+    inline iterator end() { return m_result.end(); }
+    inline const_iterator begin() const { return m_result.begin(); }
+    inline const_iterator end() const { return m_result.end(); }
+
+private:
+    result_type m_result;
+};
+
+}} // namespace adaptors::detail
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_ADAPTORS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/iterators.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/iterators.hpp
new file mode 100644
index 00000000000..a47dd7ea437
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/iterators.hpp
@@ -0,0 +1,122 @@
+// Boost.Geometry Index
+//
+// R-tree iterators
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_ITERATORS_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_ITERATORS_HPP
+
+namespace boost { namespace geometry { namespace index { namespace detail { namespace rtree { namespace iterators {
+
+template <typename Value, typename Allocators>
+struct end_iterator
+{
+    typedef std::forward_iterator_tag iterator_category;
+    typedef Value value_type;
+    typedef typename Allocators::const_reference reference;
+    typedef typename Allocators::difference_type difference_type;
+    typedef typename Allocators::const_pointer pointer;
+
+    reference operator*() const
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(false, "iterator not dereferencable");
+        pointer p(0);
+        return *p;
+    }
+
+    const value_type * operator->() const
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(false, "iterator not dereferencable");
+        const value_type * p = 0;
+        return p;
+    }
+
+    end_iterator & operator++()
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(false, "iterator not incrementable");
+        return *this;
+    }
+
+    end_iterator operator++(int)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(false, "iterator not incrementable");
+        return *this;
+    }
+
+    friend bool operator==(end_iterator const& /*l*/, end_iterator const& /*r*/)
+    {
+        return true;
+    }
+};
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+class iterator
+{
+    typedef visitors::iterator<Value, Options, Translator, Box, Allocators> visitor_type;
+    typedef typename visitor_type::node_pointer node_pointer;
+
+public:
+    typedef std::forward_iterator_tag iterator_category;
+    typedef Value value_type;
+    typedef typename Allocators::const_reference reference;
+    typedef typename Allocators::difference_type difference_type;
+    typedef typename Allocators::const_pointer pointer;
+
+    inline iterator()
+    {}
+
+    inline iterator(node_pointer root)
+    {
+        m_visitor.initialize(root);
+    }
+
+    reference operator*() const
+    {
+        return m_visitor.dereference();
+    }
+
+    const value_type * operator->() const
+    {
+        return boost::addressof(m_visitor.dereference());
+    }
+
+    iterator & operator++()
+    {
+        m_visitor.increment();
+        return *this;
+    }
+
+    iterator operator++(int)
+    {
+        iterator temp = *this;
+        this->operator++();
+        return temp;
+    }
+
+    friend bool operator==(iterator const& l, iterator const& r)
+    {
+        return l.m_visitor == r.m_visitor;
+    }
+
+    friend bool operator==(iterator const& l, end_iterator<Value, Allocators> const& /*r*/)
+    {
+        return l.m_visitor.is_end();
+    }
+
+    friend bool operator==(end_iterator<Value, Allocators> const& /*l*/, iterator const& r)
+    {
+        return r.m_visitor.is_end();
+    }
+    
+private:
+    visitor_type m_visitor;
+};
+
+}}}}}} // namespace boost::geometry::index::detail::rtree::iterators
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_ITERATORS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/kmeans/kmeans.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/kmeans/kmeans.hpp
new file mode 100644
index 00000000000..3f61482b27a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/kmeans/kmeans.hpp
@@ -0,0 +1,16 @@
+// Boost.Geometry Index
+//
+// R-tree kmeans algorithm implementation
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_KMEANS_KMEANS_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_KMEANS_KMEANS_HPP
+
+#include <boost/geometry/index/rtree/kmeans/split.hpp>
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_KMEANS_KMEANS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/kmeans/split.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/kmeans/split.hpp
new file mode 100644
index 00000000000..f19654972e8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/kmeans/split.hpp
@@ -0,0 +1,87 @@
+// Boost.Geometry Index
+//
+// R-tree kmeans split algorithm implementation
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_KMEANS_SPLIT_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_KMEANS_SPLIT_HPP
+
+#include <boost/geometry/index/rtree/node/node.hpp>
+#include <boost/geometry/index/rtree/visitors/insert.hpp>
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree {
+
+namespace kmeans {
+
+// some details
+
+} // namespace kmeans
+
+// split_kmeans_tag
+// OR
+// split_clusters_tag and redistribute_kmeans_tag - then redistribute will probably slightly different interface
+// or some other than "redistribute"
+
+// 1. for this algorithm one probably MUST USE NON-STATIC NODES with node_default_tag
+//    or the algorithm must be changed somehow - to not store additional nodes in the current node
+//    but return excessive element/elements container instead (possibly pushable_array<1> or std::vector)
+//    this would also cause building of smaller trees since +1 element in nodes wouldn't be needed in different redistributing algorithms
+// 2. it is probably possible to add e.g. 2 levels of tree in one insert
+
+// Edge case is that every node split generates M + 1 children, in parent containing M nodes
+// result is 2M + 1 nodes in parent on this level
+// On next level the same, next the same and so on.
+// We have Depth*M+1 nodes in the root
+// The tree may then gain some > 1 levels in one insert
+// split::apply() manages this but special attention is required
+
+// which algorithm should be used to choose current node in traversing while inserting?
+// some of the currently used ones or some using mean values as well?
+
+// TODO
+// 1. Zmienic troche algorytm zeby przekazywal nadmiarowe elementy do split
+//    i pobieral ze split nadmiarowe elementy rodzica
+//    W zaleznosci od algorytmu w rozny sposob - l/q/r* powinny zwracac np pushable_array<1>
+//    wtedy tez is_overerflow (z R* insert?) bedzie nieportrzebne
+//    Dla kmeans zapewne std::vector, jednak w wezlach nadal moglaby byc pushable_array
+// 2. Fajnie byloby tez uproscic te wszystkie parametry root,parent,index itd. Mozliwe ze okazalyby sie zbedne
+// 3. Sprawdzyc czasy wykonywania i zajetosc pamieci
+// 4. Pamietac o parametryzacji kontenera z nadmiarowymi elementami
+// PS. Z R* reinsertami moze byc masakra
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+class split<Value, Options, Translator, Box, Allocators, split_kmeans_tag>
+{
+protected:
+    typedef typename rtree::node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef typename Options::parameters_type parameters_type;
+
+public:
+    template <typename Node>
+    static inline void apply(node* & root_node,
+                             size_t & leafs_level,
+                             Node & n,
+                             internal_node *parent_node,
+                             size_t current_child_index,
+                             Translator const& tr,
+                             Allocators & allocators)
+    {
+
+    }
+};
+
+}} // namespace detail::rtree
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_KMEANS_SPLIT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/linear/linear.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/linear/linear.hpp
new file mode 100644
index 00000000000..1461692a1ee
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/linear/linear.hpp
@@ -0,0 +1,16 @@
+// Boost.Geometry Index
+//
+// R-tree linear algorithm implementation
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_LINEAR_LINEAR_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_LINEAR_LINEAR_HPP
+
+#include <boost/geometry/index/detail/rtree/linear/redistribute_elements.hpp>
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_LINEAR_LINEAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/linear/redistribute_elements.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/linear/redistribute_elements.hpp
new file mode 100644
index 00000000000..a10b046c0dc
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/linear/redistribute_elements.hpp
@@ -0,0 +1,446 @@
+// Boost.Geometry Index
+//
+// R-tree linear split algorithm implementation
+//
+// Copyright (c) 2008 Federico J. Fernandez.
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_LINEAR_REDISTRIBUTE_ELEMENTS_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_LINEAR_REDISTRIBUTE_ELEMENTS_HPP
+
+#include <boost/type_traits/is_unsigned.hpp>
+
+#include <boost/geometry/index/detail/algorithms/content.hpp>
+#include <boost/geometry/index/detail/bounded_view.hpp>
+
+#include <boost/geometry/index/detail/rtree/node/node.hpp>
+#include <boost/geometry/index/detail/rtree/visitors/insert.hpp>
+#include <boost/geometry/index/detail/rtree/visitors/is_leaf.hpp>
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree {
+
+namespace linear {
+
+template <typename R, typename T>
+inline R difference_dispatch(T const& from, T const& to, ::boost::mpl::bool_<false> const& /*is_unsigned*/)
+{
+    return to - from;
+}
+
+template <typename R, typename T>
+inline R difference_dispatch(T const& from, T const& to, ::boost::mpl::bool_<true> const& /*is_unsigned*/)
+{
+    return from <= to ? R(to - from) : -R(from - to);
+}
+
+template <typename R, typename T>
+inline R difference(T const& from, T const& to)
+{
+    BOOST_MPL_ASSERT_MSG(!boost::is_unsigned<R>::value, RESULT_CANT_BE_UNSIGNED, (R));
+
+    typedef ::boost::mpl::bool_<
+        boost::is_unsigned<T>::value
+    > is_unsigned;
+
+    return difference_dispatch<R>(from, to, is_unsigned());
+}
+
+// TODO: awulkiew
+// In general, all aerial Indexables in the tree with box-like nodes will be analyzed as boxes
+// because they must fit into larger box. Therefore the algorithm could be the same for Bounds type.
+// E.g. if Bounds type is sphere, Indexables probably should be analyzed as spheres.
+// 1. View could be provided to 'see' all Indexables as Bounds type.
+//    Not ok in the case of big types like Ring, however it's possible that Rings won't be supported,
+//    only simple types. Even then if we consider storing Box inside the Sphere we must calculate
+//    the bounding sphere 2x for each box because there are 2 loops. For each calculation this means
+//    4-2d or 8-3d expansions or -, / and sqrt().
+// 2. Additional container could be used and reused if the Indexable type is other than the Bounds type.
+
+// IMPORTANT!
+// Still probably the best way would be providing specialized algorithms for each Indexable-Bounds pair!
+// Probably on pick_seeds algorithm level - For Bounds=Sphere seeds would be choosen differently
+
+// TODO: awulkiew
+// there are loops inside find_greatest_normalized_separation::apply()
+// iteration is done for each DimensionIndex.
+// Separations and seeds for all DimensionIndex(es) could be calculated at once, stored, then the greatest would be choosen.
+
+// The following struct/method was adapted for the preliminary version of the R-tree. Then it was called:
+// void find_normalized_separations(std::vector<Box> const& boxes, T& separation, unsigned int& first, unsigned int& second) const
+
+template <typename Elements, typename Parameters, typename Translator, typename Tag, size_t DimensionIndex>
+struct find_greatest_normalized_separation
+{
+    typedef typename Elements::value_type element_type;
+    typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
+    typedef typename coordinate_type<indexable_type>::type coordinate_type;
+
+    typedef typename boost::mpl::if_c<
+        boost::is_integral<coordinate_type>::value,
+        double,
+        coordinate_type
+    >::type separation_type;
+
+    typedef typename geometry::point_type<indexable_type>::type point_type;
+    typedef geometry::model::box<point_type> bounds_type;
+    typedef index::detail::bounded_view<indexable_type, bounds_type> bounded_view_type;
+
+    static inline void apply(Elements const& elements,
+                             Parameters const& parameters,
+                             Translator const& translator,
+                             separation_type & separation,
+                             size_t & seed1,
+                             size_t & seed2)
+    {
+        const size_t elements_count = parameters.get_max_elements() + 1;
+        BOOST_GEOMETRY_INDEX_ASSERT(elements.size() == elements_count, "unexpected number of elements");
+        BOOST_GEOMETRY_INDEX_ASSERT(2 <= elements_count, "unexpected number of elements");
+
+        // find the lowest low, highest high
+        bounded_view_type bounded_indexable_0(rtree::element_indexable(elements[0], translator));
+        coordinate_type lowest_low = geometry::get<min_corner, DimensionIndex>(bounded_indexable_0);
+        coordinate_type highest_high = geometry::get<max_corner, DimensionIndex>(bounded_indexable_0);
+
+        // and the lowest high
+        coordinate_type lowest_high = highest_high;
+        size_t lowest_high_index = 0;
+        for ( size_t i = 1 ; i < elements_count ; ++i )
+        {
+            bounded_view_type bounded_indexable(rtree::element_indexable(elements[i], translator));
+            coordinate_type min_coord = geometry::get<min_corner, DimensionIndex>(bounded_indexable);
+            coordinate_type max_coord = geometry::get<max_corner, DimensionIndex>(bounded_indexable);
+
+            if ( max_coord < lowest_high )
+            {
+                lowest_high = max_coord;
+                lowest_high_index = i;
+            }
+
+            if ( min_coord < lowest_low )
+                lowest_low = min_coord;
+
+            if ( highest_high < max_coord )
+                highest_high = max_coord;
+        }
+
+        // find the highest low
+        size_t highest_low_index = lowest_high_index == 0 ? 1 : 0;
+        bounded_view_type bounded_indexable_hl(rtree::element_indexable(elements[highest_low_index], translator));
+        coordinate_type highest_low = geometry::get<min_corner, DimensionIndex>(bounded_indexable_hl);
+        for ( size_t i = highest_low_index ; i < elements_count ; ++i )
+        {
+            bounded_view_type bounded_indexable(rtree::element_indexable(elements[i], translator));
+            coordinate_type min_coord = geometry::get<min_corner, DimensionIndex>(bounded_indexable);
+            if ( highest_low < min_coord &&
+                 i != lowest_high_index )
+            {
+                highest_low = min_coord;
+                highest_low_index = i;
+            }
+        }
+
+        coordinate_type const width = highest_high - lowest_low;
+        
+        // highest_low - lowest_high
+        separation = difference<separation_type>(lowest_high, highest_low);
+        // BOOST_GEOMETRY_INDEX_ASSERT(0 <= width);
+        if ( std::numeric_limits<coordinate_type>::epsilon() < width )
+            separation /= width;
+
+        seed1 = highest_low_index;
+        seed2 = lowest_high_index;
+
+        ::boost::ignore_unused_variable_warning(parameters);
+    }
+};
+
+// Version for points doesn't calculate normalized separation since it would always be equal to 1
+// It returns two seeds most distant to each other, separation is equal to distance
+template <typename Elements, typename Parameters, typename Translator, size_t DimensionIndex>
+struct find_greatest_normalized_separation<Elements, Parameters, Translator, point_tag, DimensionIndex>
+{
+    typedef typename Elements::value_type element_type;
+    typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
+    typedef typename coordinate_type<indexable_type>::type coordinate_type;
+
+    typedef coordinate_type separation_type;
+
+    static inline void apply(Elements const& elements,
+                             Parameters const& parameters,
+                             Translator const& translator,
+                             separation_type & separation,
+                             size_t & seed1,
+                             size_t & seed2)
+    {
+        const size_t elements_count = parameters.get_max_elements() + 1;
+        BOOST_GEOMETRY_INDEX_ASSERT(elements.size() == elements_count, "unexpected number of elements");
+        BOOST_GEOMETRY_INDEX_ASSERT(2 <= elements_count, "unexpected number of elements");
+
+        // find the lowest low, highest high
+        coordinate_type lowest = geometry::get<DimensionIndex>(rtree::element_indexable(elements[0], translator));
+        coordinate_type highest = geometry::get<DimensionIndex>(rtree::element_indexable(elements[0], translator));
+        size_t lowest_index = 0;
+        size_t highest_index = 0;
+        for ( size_t i = 1 ; i < elements_count ; ++i )
+        {
+            coordinate_type coord = geometry::get<DimensionIndex>(rtree::element_indexable(elements[i], translator));
+
+            if ( coord < lowest )
+            {
+                lowest = coord;
+                lowest_index = i;
+            }
+
+            if ( highest < coord )
+            {
+                highest = coord;
+                highest_index = i;
+            }
+        }
+
+        separation = highest - lowest;
+        seed1 = lowest_index;
+        seed2 = highest_index;
+
+        if ( lowest_index == highest_index )
+            seed2 = (lowest_index + 1) % elements_count; // % is just in case since if this is true lowest_index is 0
+
+        ::boost::ignore_unused_variable_warning(parameters);
+    }
+};
+
+template <typename Elements, typename Parameters, typename Translator, size_t Dimension>
+struct pick_seeds_impl
+{
+    BOOST_STATIC_ASSERT(0 < Dimension);
+
+    typedef typename Elements::value_type element_type;
+    typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
+
+    typedef find_greatest_normalized_separation<
+        Elements, Parameters, Translator,
+        typename tag<indexable_type>::type, Dimension - 1
+    > find_norm_sep;
+
+    typedef typename find_norm_sep::separation_type separation_type;
+
+    static inline void apply(Elements const& elements,
+                             Parameters const& parameters,
+                             Translator const& tr,
+                             separation_type & separation,
+                             size_t & seed1,
+                             size_t & seed2)
+    {
+        pick_seeds_impl<Elements, Parameters, Translator, Dimension - 1>::apply(elements, parameters, tr, separation, seed1, seed2);
+
+        separation_type current_separation;
+        size_t s1, s2;
+        find_norm_sep::apply(elements, parameters, tr, current_separation, s1, s2);
+
+        // in the old implementation different operator was used: <= (y axis prefered)
+        if ( separation < current_separation )
+        {
+            separation = current_separation;
+            seed1 = s1;
+            seed2 = s2;
+        }
+    }
+};
+
+template <typename Elements, typename Parameters, typename Translator>
+struct pick_seeds_impl<Elements, Parameters, Translator, 1>
+{
+    typedef typename Elements::value_type element_type;
+    typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
+    typedef typename coordinate_type<indexable_type>::type coordinate_type;
+
+    typedef find_greatest_normalized_separation<
+        Elements, Parameters, Translator,
+        typename tag<indexable_type>::type, 0
+    > find_norm_sep;
+
+    typedef typename find_norm_sep::separation_type separation_type;
+
+    static inline void apply(Elements const& elements,
+                             Parameters const& parameters,
+                             Translator const& tr,
+                             separation_type & separation,
+                             size_t & seed1,
+                             size_t & seed2)
+    {
+        find_norm_sep::apply(elements, parameters, tr, separation, seed1, seed2);
+    }
+};
+
+// from void linear_pick_seeds(node_pointer const& n, unsigned int &seed1, unsigned int &seed2) const
+
+template <typename Elements, typename Parameters, typename Translator>
+inline void pick_seeds(Elements const& elements,
+                       Parameters const& parameters,
+                       Translator const& tr,
+                       size_t & seed1,
+                       size_t & seed2)
+{
+    typedef typename Elements::value_type element_type;
+    typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
+
+    typedef pick_seeds_impl
+        <
+            Elements, Parameters, Translator,
+            geometry::dimension<indexable_type>::value
+        > impl;
+    typedef typename impl::separation_type separation_type;
+
+    separation_type separation = 0;
+    impl::apply(elements, parameters, tr, separation, seed1, seed2);
+}
+
+} // namespace linear
+
+// from void split_node(node_pointer const& n, node_pointer& n1, node_pointer& n2) const
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+struct redistribute_elements<Value, Options, Translator, Box, Allocators, linear_tag>
+{
+    typedef typename Options::parameters_type parameters_type;
+
+    typedef typename rtree::node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    template <typename Node>
+    static inline void apply(Node & n,
+                             Node & second_node,
+                             Box & box1,
+                             Box & box2,
+                             parameters_type const& parameters,
+                             Translator const& translator,
+                             Allocators & allocators)
+    {
+        typedef typename rtree::elements_type<Node>::type elements_type;
+        typedef typename elements_type::value_type element_type;
+        typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
+        typedef typename index::detail::default_content_result<Box>::type content_type;
+
+        elements_type & elements1 = rtree::elements(n);
+        elements_type & elements2 = rtree::elements(second_node);
+        const size_t elements1_count = parameters.get_max_elements() + 1;
+
+        BOOST_GEOMETRY_INDEX_ASSERT(elements1.size() == elements1_count, "unexpected number of elements");
+
+        // copy original elements - use in-memory storage (std::allocator)
+        // TODO: move if noexcept
+        typedef typename rtree::container_from_elements_type<elements_type, element_type>::type
+            container_type;
+        container_type elements_copy(elements1.begin(), elements1.end());                                   // MAY THROW, STRONG (alloc, copy)
+
+        // calculate initial seeds
+        size_t seed1 = 0;
+        size_t seed2 = 0;
+        linear::pick_seeds(elements_copy, parameters, translator, seed1, seed2);
+
+        // prepare nodes' elements containers
+        elements1.clear();
+        BOOST_GEOMETRY_INDEX_ASSERT(elements2.empty(), "unexpected container state");
+
+        BOOST_TRY
+        {
+            // add seeds
+            elements1.push_back(elements_copy[seed1]);                                                      // MAY THROW, STRONG (copy)
+            elements2.push_back(elements_copy[seed2]);                                                      // MAY THROW, STRONG (alloc, copy)
+
+            // calculate boxes
+            detail::bounds(rtree::element_indexable(elements_copy[seed1], translator), box1);
+            detail::bounds(rtree::element_indexable(elements_copy[seed2], translator), box2);
+
+            // initialize areas
+            content_type content1 = index::detail::content(box1);
+            content_type content2 = index::detail::content(box2);
+
+            BOOST_GEOMETRY_INDEX_ASSERT(2 <= elements1_count, "unexpected elements number");
+            size_t remaining = elements1_count - 2;
+
+            // redistribute the rest of the elements
+            for ( size_t i = 0 ; i < elements1_count ; ++i )
+            {
+                if (i != seed1 && i != seed2)
+                {
+                    element_type const& elem = elements_copy[i];
+                    indexable_type const& indexable = rtree::element_indexable(elem, translator);
+
+                    // if there is small number of elements left and the number of elements in node is lesser than min_elems
+                    // just insert them to this node
+                    if ( elements1.size() + remaining <= parameters.get_min_elements() )
+                    {
+                        elements1.push_back(elem);                                                          // MAY THROW, STRONG (copy)
+                        geometry::expand(box1, indexable);
+                        content1 = index::detail::content(box1);
+                    }
+                    else if ( elements2.size() + remaining <= parameters.get_min_elements() )
+                    {
+                        elements2.push_back(elem);                                                          // MAY THROW, STRONG (alloc, copy)
+                        geometry::expand(box2, indexable);
+                        content2 = index::detail::content(box2);
+                    }
+                    // choose better node and insert element
+                    else
+                    {
+                        // calculate enlarged boxes and areas
+                        Box enlarged_box1(box1);
+                        Box enlarged_box2(box2);
+                        geometry::expand(enlarged_box1, indexable);
+                        geometry::expand(enlarged_box2, indexable);
+                        content_type enlarged_content1 = index::detail::content(enlarged_box1);
+                        content_type enlarged_content2 = index::detail::content(enlarged_box2);
+
+                        content_type content_increase1 = enlarged_content1 - content1;
+                        content_type content_increase2 = enlarged_content2 - content2;
+
+                        // choose group which box content have to be enlarged least or has smaller content or has fewer elements
+                        if ( content_increase1 < content_increase2 ||
+                                ( content_increase1 == content_increase2 &&
+                                    ( content1 < content2 ||
+                                        ( content1 == content2 && elements1.size() <= elements2.size() ) ) ) )
+                        {
+                            elements1.push_back(elem);                                                      // MAY THROW, STRONG (copy)
+                            box1 = enlarged_box1;
+                            content1 = enlarged_content1;
+                        }
+                        else
+                        {
+                            elements2.push_back(elem);                                                      // MAY THROW, STRONG (alloc, copy)
+                            box2 = enlarged_box2;
+                            content2 = enlarged_content2;
+                        }
+                    }
+                
+                    BOOST_GEOMETRY_INDEX_ASSERT(0 < remaining, "unexpected value");
+                    --remaining;
+                }
+            }
+        }
+        BOOST_CATCH(...)
+        {
+            elements1.clear();
+            elements2.clear();
+
+            rtree::destroy_elements<Value, Options, Translator, Box, Allocators>::apply(elements_copy, allocators);
+            //elements_copy.clear();
+
+            BOOST_RETHROW                                                                                     // RETHROW, BASIC
+        }
+        BOOST_CATCH_END
+    }
+};
+
+}} // namespace detail::rtree
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_LINEAR_REDISTRIBUTE_ELEMENTS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/concept.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/concept.hpp
new file mode 100644
index 00000000000..30fa44d2635
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/concept.hpp
@@ -0,0 +1,85 @@
+// Boost.Geometry Index
+//
+// R-tree node concept
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_CONCEPT_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_CONCEPT_HPP
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree {
+
+template <typename Value, typename Parameters, typename Box, typename Allocators, typename Tag>
+struct node
+{
+    BOOST_MPL_ASSERT_MSG(
+        (false),
+        NOT_IMPLEMENTED_FOR_THIS_TAG_TYPE,
+        (node));
+};
+
+template <typename Value, typename Parameters, typename Box, typename Allocators, typename Tag>
+struct internal_node
+{
+    BOOST_MPL_ASSERT_MSG(
+        (false),
+        NOT_IMPLEMENTED_FOR_THIS_TAG_TYPE,
+        (internal_node));
+};
+
+template <typename Value, typename Parameters, typename Box, typename Allocators, typename Tag>
+struct leaf
+{
+    BOOST_MPL_ASSERT_MSG(
+        (false),
+        NOT_IMPLEMENTED_FOR_THIS_TAG_TYPE,
+        (leaf));
+};
+
+template <typename Value, typename Parameters, typename Box, typename Allocators, typename Tag, bool IsVisitableConst>
+struct visitor
+{
+    BOOST_MPL_ASSERT_MSG(
+        (false),
+        NOT_IMPLEMENTED_FOR_THIS_TAG_TYPE,
+        (visitor));
+};
+
+template <typename Allocator, typename Value, typename Parameters, typename Box, typename Tag>
+class allocators
+{
+    BOOST_MPL_ASSERT_MSG(
+        (false),
+        NOT_IMPLEMENTED_FOR_THIS_TAG_TYPE,
+        (allocators));
+};
+
+template <typename Allocators, typename Node>
+struct create_node
+{
+    BOOST_MPL_ASSERT_MSG(
+        (false),
+        NOT_IMPLEMENTED_FOR_THIS_NODE_TYPE,
+        (create_node));
+};
+
+template <typename Allocators, typename Node>
+struct destroy_node
+{
+    BOOST_MPL_ASSERT_MSG(
+        (false),
+        NOT_IMPLEMENTED_FOR_THIS_NODE_TYPE,
+        (destroy_node));
+};
+
+}} // namespace detail::rtree
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_CONCEPT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/node.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/node.hpp
new file mode 100644
index 00000000000..2b270319f67
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/node.hpp
@@ -0,0 +1,212 @@
+// Boost.Geometry Index
+//
+// R-tree nodes
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_NODE_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_NODE_HPP
+
+#include <boost/container/vector.hpp>
+#include <boost/geometry/index/detail/varray.hpp>
+
+#include <boost/geometry/index/detail/rtree/node/concept.hpp>
+#include <boost/geometry/index/detail/rtree/node/pairs.hpp>
+#include <boost/geometry/index/detail/rtree/node/node_elements.hpp>
+#include <boost/geometry/index/detail/rtree/node/scoped_deallocator.hpp>
+
+//#include <boost/geometry/index/detail/rtree/node/weak_visitor.hpp>
+//#include <boost/geometry/index/detail/rtree/node/weak_dynamic.hpp>
+//#include <boost/geometry/index/detail/rtree/node/weak_static.hpp>
+
+#include <boost/geometry/index/detail/rtree/node/variant_visitor.hpp>
+#include <boost/geometry/index/detail/rtree/node/variant_dynamic.hpp>
+#include <boost/geometry/index/detail/rtree/node/variant_static.hpp>
+
+#include <boost/geometry/index/detail/rtree/node/subtree_destroyer.hpp>
+
+#include <boost/geometry/algorithms/expand.hpp>
+
+#include <boost/geometry/index/detail/rtree/visitors/is_leaf.hpp>
+
+#include <boost/geometry/index/detail/algorithms/bounds.hpp>
+#include <boost/geometry/index/detail/is_bounding_geometry.hpp>
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree {
+
+// elements box
+
+template <typename Box, typename FwdIter, typename Translator>
+inline Box elements_box(FwdIter first, FwdIter last, Translator const& tr)
+{
+    Box result;
+    
+    // Only here to suppress 'uninitialized local variable used' warning
+    // until the suggestion below is not implemented
+    geometry::assign_inverse(result);
+
+    //BOOST_GEOMETRY_INDEX_ASSERT(first != last, "non-empty range required");
+    // NOTE: this is not elegant temporary solution,
+    //       reference to box could be passed as parameter and bool returned
+    if ( first == last )
+        return result;
+
+    detail::bounds(element_indexable(*first, tr), result);
+    ++first;
+
+    for ( ; first != last ; ++first )
+        geometry::expand(result, element_indexable(*first, tr));
+
+    return result;
+}
+
+// Enlarge bounds of a leaf node WRT epsilon if needed.
+// It's because Points and Segments are compared WRT machine epsilon.
+// This ensures that leafs bounds correspond to the stored elements.
+// NOTE: this is done only if the Indexable is not a Box
+//       in the future don't do it also for NSphere
+template <typename Box, typename FwdIter, typename Translator>
+inline Box values_box(FwdIter first, FwdIter last, Translator const& tr)
+{
+    typedef typename std::iterator_traits<FwdIter>::value_type element_type;
+    BOOST_MPL_ASSERT_MSG((is_leaf_element<element_type>::value),
+                         SHOULD_BE_CALLED_ONLY_FOR_LEAF_ELEMENTS,
+                         (element_type));
+
+    Box result = elements_box<Box>(first, last, tr);
+
+#ifdef BOOST_GEOMETRY_INDEX_EXPERIMENTAL_ENLARGE_BY_EPSILON
+    if (BOOST_GEOMETRY_CONDITION((
+        ! is_bounding_geometry
+            <
+                typename indexable_type<Translator>::type
+            >::value)))
+    {
+        geometry::detail::expand_by_epsilon(result);
+    }
+#endif
+
+    return result;
+}
+
+// destroys subtree if the element is internal node's element
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+struct destroy_element
+{
+    typedef typename Options::parameters_type parameters_type;
+
+    typedef typename rtree::internal_node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef rtree::subtree_destroyer<Value, Options, Translator, Box, Allocators> subtree_destroyer;
+
+    inline static void apply(typename internal_node::elements_type::value_type & element, Allocators & allocators)
+    {
+         subtree_destroyer dummy(element.second, allocators);
+         element.second = 0;
+    }
+
+    inline static void apply(typename leaf::elements_type::value_type &, Allocators &) {}
+};
+
+// destroys stored subtrees if internal node's elements are passed
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+struct destroy_elements
+{
+    template <typename Range>
+    inline static void apply(Range & elements, Allocators & allocators)
+    {
+        apply(boost::begin(elements), boost::end(elements), allocators);
+    }
+
+    template <typename It>
+    inline static void apply(It first, It last, Allocators & allocators)
+    {
+        typedef boost::mpl::bool_<
+            boost::is_same<
+                Value, typename std::iterator_traits<It>::value_type
+            >::value
+        > is_range_of_values;
+
+        apply_dispatch(first, last, allocators, is_range_of_values());
+    }
+
+private:
+    template <typename It>
+    inline static void apply_dispatch(It first, It last, Allocators & allocators,
+                                      boost::mpl::bool_<false> const& /*is_range_of_values*/)
+    {
+        typedef rtree::subtree_destroyer<Value, Options, Translator, Box, Allocators> subtree_destroyer;
+
+        for ( ; first != last ; ++first )
+        {
+            subtree_destroyer dummy(first->second, allocators);
+            first->second = 0;
+        }
+    }
+
+    template <typename It>
+    inline static void apply_dispatch(It /*first*/, It /*last*/, Allocators & /*allocators*/,
+                                      boost::mpl::bool_<true> const& /*is_range_of_values*/)
+    {}
+};
+
+// clears node, deletes all subtrees stored in node
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+struct clear_node
+{
+    typedef typename Options::parameters_type parameters_type;
+
+    typedef typename rtree::node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    inline static void apply(node & node, Allocators & allocators)
+    {
+        rtree::visitors::is_leaf<Value, Options, Box, Allocators> ilv;
+        rtree::apply_visitor(ilv, node);
+        if ( ilv.result )
+        {
+            apply(rtree::get<leaf>(node), allocators);
+        }
+        else
+        {
+            apply(rtree::get<internal_node>(node), allocators);
+        }
+    }
+
+    inline static void apply(internal_node & internal_node, Allocators & allocators)
+    {
+        destroy_elements<Value, Options, Translator, Box, Allocators>::apply(rtree::elements(internal_node), allocators);
+        rtree::elements(internal_node).clear();
+    }
+
+    inline static void apply(leaf & leaf, Allocators &)
+    {
+        rtree::elements(leaf).clear();
+    }
+};
+
+template <typename Container, typename Iterator>
+void move_from_back(Container & container, Iterator it)
+{
+    BOOST_GEOMETRY_INDEX_ASSERT(!container.empty(), "cannot copy from empty container");
+    Iterator back_it = container.end();
+    --back_it;
+    if ( it != back_it )
+    {
+        *it = boost::move(*back_it);                                                             // MAY THROW (copy)
+    }
+}
+
+}} // namespace detail::rtree
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_NODE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/node_elements.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/node_elements.hpp
new file mode 100644
index 00000000000..0e5848987ea
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/node_elements.hpp
@@ -0,0 +1,110 @@
+// Boost.Geometry Index
+//
+// R-tree node elements access
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_NODE_ELEMENTS_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_NODE_ELEMENTS_HPP
+
+#include <boost/container/vector.hpp>
+#include <boost/geometry/algorithms/detail/expand_by_epsilon.hpp>
+#include <boost/geometry/index/detail/varray.hpp>
+#include <boost/geometry/index/detail/rtree/node/pairs.hpp>
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree {
+
+// element's indexable type
+
+template <typename Element, typename Translator>
+struct element_indexable_type
+{
+    typedef typename indexable_type<Translator>::type type;
+};
+
+template <typename First, typename Pointer, typename Translator>
+struct element_indexable_type<
+    rtree::ptr_pair<First, Pointer>,
+    Translator
+>
+{
+    typedef First type;
+};
+
+// is leaf element
+
+template <typename Element>
+struct is_leaf_element
+{
+    static const bool value = true;
+};
+
+template <typename First, typename Pointer>
+struct is_leaf_element< rtree::ptr_pair<First, Pointer> >
+{
+    static const bool value = false;
+};
+
+// element's indexable getter
+
+template <typename Element, typename Translator>
+typename result_type<Translator>::type
+element_indexable(Element const& el, Translator const& tr)
+{
+    return tr(el);
+}
+
+template <typename First, typename Pointer, typename Translator>
+First const&
+element_indexable(rtree::ptr_pair<First, Pointer> const& el, Translator const& /*tr*/)
+{
+    return el.first;
+}
+
+// nodes elements
+
+template <typename Node>
+struct elements_type
+{
+    typedef typename Node::elements_type type;
+};
+
+template <typename Node>
+inline typename elements_type<Node>::type &
+elements(Node & n)
+{
+    return n.elements;
+}
+
+template <typename Node>
+inline typename elements_type<Node>::type const&
+elements(Node const& n)
+{
+    return n.elements;
+}
+
+// elements derived type
+
+template <typename Elements, typename NewValue>
+struct container_from_elements_type
+{
+    typedef boost::container::vector<NewValue> type;
+};
+
+template <typename OldValue, size_t N, typename NewValue>
+struct container_from_elements_type<detail::varray<OldValue, N>, NewValue>
+{
+    typedef detail::varray<NewValue, N> type;
+};
+
+}} // namespace detail::rtree
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_NODE_ELEMENTS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/pairs.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/pairs.hpp
new file mode 100644
index 00000000000..dc088ec29b5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/pairs.hpp
@@ -0,0 +1,71 @@
+// Boost.Geometry Index
+//
+// Pairs intended to be used internally in nodes.
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_PAIRS_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_PAIRS_HPP
+
+#include <boost/move/move.hpp>
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree {
+
+template <typename First, typename Pointer>
+class ptr_pair
+{
+public:
+    typedef First first_type;
+    typedef Pointer second_type;
+    ptr_pair(First const& f, Pointer s) : first(f), second(s) {}
+    //ptr_pair(ptr_pair const& p) : first(p.first), second(p.second) {}
+    //ptr_pair & operator=(ptr_pair const& p) { first = p.first; second = p.second; return *this; }
+
+    first_type first;
+    second_type second;
+};
+
+template <typename First, typename Pointer> inline
+ptr_pair<First, Pointer>
+make_ptr_pair(First const& f, Pointer s)
+{
+    return ptr_pair<First, Pointer>(f, s);
+}
+
+// TODO: It this will be used, rename it to unique_ptr_pair and possibly use unique_ptr.
+
+template <typename First, typename Pointer>
+class exclusive_ptr_pair
+{
+    BOOST_MOVABLE_BUT_NOT_COPYABLE(exclusive_ptr_pair)
+public:
+    typedef First first_type;
+    typedef Pointer second_type;
+    exclusive_ptr_pair(First const& f, Pointer s) : first(f), second(s) {}
+
+    // INFO - members aren't really moved!
+    exclusive_ptr_pair(BOOST_RV_REF(exclusive_ptr_pair) p) : first(p.first), second(p.second) { p.second = 0; }
+    exclusive_ptr_pair & operator=(BOOST_RV_REF(exclusive_ptr_pair) p) { first = p.first; second = p.second; p.second = 0; return *this; }
+
+    first_type first;
+    second_type second;
+};
+
+template <typename First, typename Pointer> inline
+exclusive_ptr_pair<First, Pointer>
+make_exclusive_ptr_pair(First const& f, Pointer s)
+{
+    return exclusive_ptr_pair<First, Pointer>(f, s);
+}
+
+}} // namespace detail::rtree
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_PAIRS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/scoped_deallocator.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/scoped_deallocator.hpp
new file mode 100644
index 00000000000..2d08d89ef7b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/scoped_deallocator.hpp
@@ -0,0 +1,48 @@
+// Boost.Geometry Index
+//
+// R-tree scoped deallocator
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_SCOPED_DEALLOCATOR_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_SCOPED_DEALLOCATOR_HPP
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree {
+
+template <typename Alloc>
+class scoped_deallocator
+{
+    scoped_deallocator(scoped_deallocator const&);
+    scoped_deallocator & operator=(scoped_deallocator const&);
+public:
+    typedef typename Alloc::pointer pointer;
+    inline scoped_deallocator(pointer p, Alloc & a)
+        : m_ptr(p), m_alloc(a)
+    {}
+    inline ~scoped_deallocator()
+    {
+        if ( m_ptr )
+        {
+            boost::container::allocator_traits<Alloc>::deallocate(m_alloc, m_ptr, 1);
+        }
+    }
+    inline void release()
+    {
+        m_ptr = 0;
+    }
+private:
+    pointer m_ptr;
+    Alloc & m_alloc;
+};
+
+}} // namespace detail::rtree
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_SCOPED_DEALLOCATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/subtree_destroyer.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/subtree_destroyer.hpp
new file mode 100644
index 00000000000..3376068eedf
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/subtree_destroyer.hpp
@@ -0,0 +1,79 @@
+// Boost.Geometry Index
+//
+// R-tree subtree scoped destroyer
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_SUBTREE_DESTROYED_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_SUBTREE_DESTROYED_HPP
+
+#include <boost/geometry/index/detail/rtree/visitors/destroy.hpp>
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree {
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+class subtree_destroyer
+{
+    typedef typename rtree::node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename Allocators::node_pointer pointer;
+
+    subtree_destroyer(subtree_destroyer const&);
+    subtree_destroyer & operator=(subtree_destroyer const&);
+
+public:
+    subtree_destroyer(pointer ptr, Allocators & allocators)
+        : m_ptr(ptr)
+        , m_allocators(allocators)
+    {}
+
+    ~subtree_destroyer()
+    {
+        reset();
+    }
+
+    void reset(pointer ptr = 0)
+    {
+        if ( m_ptr && m_ptr != ptr )
+        {
+            detail::rtree::visitors::destroy<Value, Options, Translator, Box, Allocators> del_v(m_ptr, m_allocators);
+            detail::rtree::apply_visitor(del_v, *m_ptr);
+        }
+        m_ptr = ptr;
+    }
+
+    void release()
+    {
+        m_ptr = 0;
+    }
+
+    pointer get() const
+    {
+        return m_ptr;
+    }
+
+    node & operator*() const
+    {
+        return *m_ptr;
+    }
+
+    pointer operator->() const
+    {
+        return m_ptr;
+    }
+
+private:
+    pointer m_ptr;
+    Allocators & m_allocators;
+};
+
+}} // namespace detail::rtree
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_SUBTREE_DESTROYED_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/variant_dynamic.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/variant_dynamic.hpp
new file mode 100644
index 00000000000..e63cfd39ac4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/variant_dynamic.hpp
@@ -0,0 +1,278 @@
+// Boost.Geometry Index
+//
+// R-tree nodes based on Boost.Variant, storing dynamic-size containers
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_VARIANT_DYNAMIC_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_VARIANT_DYNAMIC_HPP
+
+#include <boost/core/pointer_traits.hpp>
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree {
+
+// nodes default types
+
+template <typename Value, typename Parameters, typename Box, typename Allocators, typename Tag>
+struct variant_internal_node
+{
+    typedef boost::container::vector
+        <
+            rtree::ptr_pair<Box, typename Allocators::node_pointer>,
+            typename Allocators::node_allocator_type::template rebind
+                <
+                    rtree::ptr_pair<Box, typename Allocators::node_pointer>
+                >::other
+        > elements_type;
+
+    template <typename Al>
+    inline variant_internal_node(Al const& al)
+        : elements(al)
+    {}
+
+    elements_type elements;
+};
+
+template <typename Value, typename Parameters, typename Box, typename Allocators, typename Tag>
+struct variant_leaf
+{
+    typedef boost::container::vector
+        <
+            Value,
+            typename Allocators::node_allocator_type::template rebind
+                <
+                    Value
+                >::other
+        > elements_type;
+
+     template <typename Al>
+    inline variant_leaf(Al const& al)
+        : elements(al)
+    {}
+
+    elements_type elements;
+};
+
+// nodes traits
+
+template <typename Value, typename Parameters, typename Box, typename Allocators>
+struct node<Value, Parameters, Box, Allocators, node_variant_dynamic_tag>
+{
+    typedef boost::variant<
+        variant_leaf<Value, Parameters, Box, Allocators, node_variant_dynamic_tag>,
+        variant_internal_node<Value, Parameters, Box, Allocators, node_variant_dynamic_tag>
+    > type;
+};
+
+template <typename Value, typename Parameters, typename Box, typename Allocators>
+struct internal_node<Value, Parameters, Box, Allocators, node_variant_dynamic_tag>
+{
+    typedef variant_internal_node<Value, Parameters, Box, Allocators, node_variant_dynamic_tag> type;
+};
+
+template <typename Value, typename Parameters, typename Box, typename Allocators>
+struct leaf<Value, Parameters, Box, Allocators, node_variant_dynamic_tag>
+{
+    typedef variant_leaf<Value, Parameters, Box, Allocators, node_variant_dynamic_tag> type;
+};
+
+// visitor traits
+
+template <typename Value, typename Parameters, typename Box, typename Allocators, bool IsVisitableConst>
+struct visitor<Value, Parameters, Box, Allocators, node_variant_dynamic_tag, IsVisitableConst>
+{
+    typedef static_visitor<> type;
+};
+
+// allocators
+
+template <typename Allocator, typename Value, typename Parameters, typename Box>
+class allocators<Allocator, Value, Parameters, Box, node_variant_dynamic_tag>
+    : public Allocator::template rebind<
+        typename node<
+            Value, Parameters, Box,
+            allocators<Allocator, Value, Parameters, Box, node_variant_dynamic_tag>,
+            node_variant_dynamic_tag
+        >::type
+    >::other
+{
+    typedef typename Allocator::template rebind<
+        Value
+    >::other value_allocator_type;
+
+public:
+    typedef Allocator allocator_type;
+
+    typedef Value value_type;
+    typedef typename value_allocator_type::reference reference;
+    typedef typename value_allocator_type::const_reference const_reference;
+    typedef typename value_allocator_type::size_type size_type;
+    typedef typename value_allocator_type::difference_type difference_type;
+    typedef typename value_allocator_type::pointer pointer;
+    typedef typename value_allocator_type::const_pointer const_pointer;
+
+    typedef typename Allocator::template rebind<
+        typename node<Value, Parameters, Box, allocators, node_variant_dynamic_tag>::type
+    >::other::pointer node_pointer;
+
+    typedef typename Allocator::template rebind<
+        typename node<Value, Parameters, Box, allocators, node_variant_dynamic_tag>::type
+    >::other node_allocator_type;
+
+    inline allocators()
+        : node_allocator_type()
+    {}
+
+    template <typename Alloc>
+    inline explicit allocators(Alloc const& alloc)
+        : node_allocator_type(alloc)
+    {}
+
+    inline allocators(BOOST_FWD_REF(allocators) a)
+        : node_allocator_type(boost::move(a.node_allocator()))
+    {}
+
+    inline allocators & operator=(BOOST_FWD_REF(allocators) a)
+    {
+        node_allocator() = boost::move(a.node_allocator());
+        return *this;
+    }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    inline allocators & operator=(allocators const& a)
+    {
+        node_allocator() = a.node_allocator();
+        return *this;
+    }
+#endif
+
+    void swap(allocators & a)
+    {
+        boost::swap(node_allocator(), a.node_allocator());
+    }
+
+    bool operator==(allocators const& a) const { return node_allocator() == a.node_allocator(); }
+    template <typename Alloc>
+    bool operator==(Alloc const& a) const { return node_allocator() == node_allocator_type(a); }
+
+    Allocator allocator() const { return Allocator(node_allocator()); }
+
+    node_allocator_type & node_allocator() { return *this; }
+    node_allocator_type const& node_allocator() const { return *this; }
+};
+
+// create_node_variant
+
+template <typename VariantPtr, typename Node>
+struct create_variant_node
+{
+    template <typename AllocNode>
+    static inline VariantPtr apply(AllocNode & alloc_node)
+    {
+        typedef boost::container::allocator_traits<AllocNode> Al;
+        typedef typename Al::pointer P;
+
+        P p = Al::allocate(alloc_node, 1);
+
+        if ( 0 == p )
+            throw_runtime_error("boost::geometry::index::rtree node creation failed");
+
+        scoped_deallocator<AllocNode> deallocator(p, alloc_node);
+
+        Al::construct(alloc_node, boost::pointer_traits<P>::to_address(p), Node(alloc_node)); // implicit cast to Variant
+
+        deallocator.release();
+        return p;
+    }
+};
+
+// destroy_node_variant
+
+template <typename Node>
+struct destroy_variant_node
+{
+    template <typename AllocNode, typename VariantPtr>
+    static inline void apply(AllocNode & alloc_node, VariantPtr n)
+    {
+        typedef boost::container::allocator_traits<AllocNode> Al;
+
+        Al::destroy(alloc_node, boost::addressof(*n));
+        Al::deallocate(alloc_node, n, 1);
+    }
+};
+
+// create_node
+
+template <typename Allocators, typename Value, typename Parameters, typename Box, typename Tag>
+struct create_node<
+    Allocators,
+    variant_internal_node<Value, Parameters, Box, Allocators, Tag>
+>
+{
+    static inline typename Allocators::node_pointer
+    apply(Allocators & allocators)
+    {
+        return create_variant_node<
+            typename Allocators::node_pointer,
+            variant_internal_node<Value, Parameters, Box, Allocators, Tag>
+        >::apply(allocators.node_allocator());
+    }
+};
+
+template <typename Allocators, typename Value, typename Parameters, typename Box, typename Tag>
+struct create_node<
+    Allocators,
+    variant_leaf<Value, Parameters, Box, Allocators, Tag>
+>
+{
+    static inline typename Allocators::node_pointer
+    apply(Allocators & allocators)
+    {
+        return create_variant_node<
+            typename Allocators::node_pointer,
+            variant_leaf<Value, Parameters, Box, Allocators, Tag>
+        >::apply(allocators.node_allocator());
+    }
+};
+
+// destroy_node
+
+template <typename Allocators, typename Value, typename Parameters, typename Box, typename Tag>
+struct destroy_node<
+    Allocators,
+    variant_internal_node<Value, Parameters, Box, Allocators, Tag>
+>
+{
+    static inline void apply(Allocators & allocators, typename Allocators::node_pointer n)
+    {
+        destroy_variant_node<
+            variant_internal_node<Value, Parameters, Box, Allocators, Tag>
+        >::apply(allocators.node_allocator(), n);
+    }
+};
+
+template <typename Allocators, typename Value, typename Parameters, typename Box, typename Tag>
+struct destroy_node<
+    Allocators,
+    variant_leaf<Value, Parameters, Box, Allocators, Tag>
+>
+{
+    static inline void apply(Allocators & allocators, typename Allocators::node_pointer n)
+    {
+        destroy_variant_node<
+            variant_leaf<Value, Parameters, Box, Allocators, Tag>
+        >::apply(allocators.node_allocator(), n);
+    }
+};
+
+}} // namespace detail::rtree
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_VARIANT_DYNAMIC_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/variant_static.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/variant_static.hpp
new file mode 100644
index 00000000000..174ceb7e7f7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/variant_static.hpp
@@ -0,0 +1,160 @@
+// Boost.Geometry Index
+//
+// R-tree nodes based on Boost.Variant, storing static-size containers
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_VARIANT_STATIC_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_VARIANT_STATIC_HPP
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree {
+
+// nodes default types
+
+template <typename Value, typename Parameters, typename Box, typename Allocators>
+struct variant_internal_node<Value, Parameters, Box, Allocators, node_variant_static_tag>
+{
+    typedef detail::varray<
+        rtree::ptr_pair<Box, typename Allocators::node_pointer>,
+        Parameters::max_elements + 1
+    > elements_type;
+
+    template <typename Alloc>
+    inline variant_internal_node(Alloc const&) {}
+
+    elements_type elements;
+};
+
+template <typename Value, typename Parameters, typename Box, typename Allocators>
+struct variant_leaf<Value, Parameters, Box, Allocators, node_variant_static_tag>
+{
+    typedef detail::varray<
+        Value,
+        Parameters::max_elements + 1
+    > elements_type;
+
+    template <typename Alloc>
+    inline variant_leaf(Alloc const&) {}
+
+    elements_type elements;
+};
+
+// nodes traits
+
+template <typename Value, typename Parameters, typename Box, typename Allocators>
+struct node<Value, Parameters, Box, Allocators, node_variant_static_tag>
+{
+    typedef boost::variant<
+        variant_leaf<Value, Parameters, Box, Allocators, node_variant_static_tag>,
+        variant_internal_node<Value, Parameters, Box, Allocators, node_variant_static_tag>
+    > type;
+};
+
+template <typename Value, typename Parameters, typename Box, typename Allocators>
+struct internal_node<Value, Parameters, Box, Allocators, node_variant_static_tag>
+{
+    typedef variant_internal_node<Value, Parameters, Box, Allocators, node_variant_static_tag> type;
+};
+
+template <typename Value, typename Parameters, typename Box, typename Allocators>
+struct leaf<Value, Parameters, Box, Allocators, node_variant_static_tag>
+{
+    typedef variant_leaf<Value, Parameters, Box, Allocators, node_variant_static_tag> type;
+};
+
+// visitor traits
+
+template <typename Value, typename Parameters, typename Box, typename Allocators, bool IsVisitableConst>
+struct visitor<Value, Parameters, Box, Allocators, node_variant_static_tag, IsVisitableConst>
+{
+    typedef static_visitor<> type;
+};
+
+// allocators
+
+template <typename Allocator, typename Value, typename Parameters, typename Box>
+class allocators<Allocator, Value, Parameters, Box, node_variant_static_tag>
+    : public Allocator::template rebind<
+        typename node<
+            Value, Parameters, Box,
+            allocators<Allocator, Value, Parameters, Box, node_variant_static_tag>,
+            node_variant_static_tag
+        >::type
+    >::other
+{
+    typedef typename Allocator::template rebind<
+        Value
+    >::other value_allocator_type;
+
+public:
+    typedef Allocator allocator_type;
+
+    typedef Value value_type;
+    typedef value_type & reference;
+    typedef const value_type & const_reference;
+    typedef typename value_allocator_type::size_type size_type;
+    typedef typename value_allocator_type::difference_type difference_type;
+    typedef typename value_allocator_type::pointer pointer;
+    typedef typename value_allocator_type::const_pointer const_pointer;
+
+    typedef typename Allocator::template rebind<
+        typename node<Value, Parameters, Box, allocators, node_variant_static_tag>::type
+    >::other::pointer node_pointer;
+
+    typedef typename Allocator::template rebind<
+        typename node<Value, Parameters, Box, allocators, node_variant_static_tag>::type
+    >::other node_allocator_type;
+
+    inline allocators()
+        : node_allocator_type()
+    {}
+
+    template <typename Alloc>
+    inline explicit allocators(Alloc const& alloc)
+        : node_allocator_type(alloc)
+    {}
+
+    inline allocators(BOOST_FWD_REF(allocators) a)
+        : node_allocator_type(boost::move(a.node_allocator()))
+    {}
+
+    inline allocators & operator=(BOOST_FWD_REF(allocators) a)
+    {
+        node_allocator() = boost::move(a.node_allocator());
+        return *this;
+    }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    inline allocators & operator=(allocators const& a)
+    {
+        node_allocator() = a.node_allocator();
+        return *this;
+    }
+#endif
+
+    void swap(allocators & a)
+    {
+        boost::swap(node_allocator(), a.node_allocator());
+    }
+
+    bool operator==(allocators const& a) const { return node_allocator() == a.node_allocator(); }
+    template <typename Alloc>
+    bool operator==(Alloc const& a) const { return node_allocator() == node_allocator_type(a); }
+
+    Allocator allocator() const { return Allocator(node_allocator()); }
+
+    node_allocator_type & node_allocator() { return *this; }
+    node_allocator_type const& node_allocator() const { return *this; }
+};
+
+}} // namespace detail::rtree
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_VARIANT_STATIC_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/variant_visitor.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/variant_visitor.hpp
new file mode 100644
index 00000000000..e272f9e1d96
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/variant_visitor.hpp
@@ -0,0 +1,68 @@
+// Boost.Geometry Index
+//
+// R-tree nodes static visitor related code
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_VARIANT_VISITOR_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_VARIANT_VISITOR_HPP
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/get.hpp>
+#include <boost/variant/variant.hpp>
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree {
+
+// nodes variants forward declarations
+
+template <typename Value, typename Parameters, typename Box, typename Allocators, typename Tag>
+struct variant_internal_node;
+
+template <typename Value, typename Parameters, typename Box, typename Allocators, typename Tag>
+struct variant_leaf;
+
+// nodes conversion
+
+template <typename V, typename Value, typename Parameters, typename Box, typename Allocators, typename Tag>
+inline V & get(
+    boost::variant<
+        variant_leaf<Value, Parameters, Box, Allocators, Tag>,
+        variant_internal_node<Value, Parameters, Box, Allocators, Tag>
+    > & v)
+{
+    return boost::get<V>(v);
+}
+
+// apply visitor
+
+template <typename Visitor, typename Value, typename Parameters, typename Box, typename Allocators, typename Tag>
+inline void apply_visitor(Visitor & v,
+                          boost::variant<
+                              variant_leaf<Value, Parameters, Box, Allocators, Tag>,
+                              variant_internal_node<Value, Parameters, Box, Allocators, Tag>
+                          > & n)
+{
+    boost::apply_visitor(v, n);
+}
+
+template <typename Visitor, typename Value, typename Parameters, typename Box, typename Allocators, typename Tag>
+inline void apply_visitor(Visitor & v,
+                          boost::variant<
+                              variant_leaf<Value, Parameters, Box, Allocators, Tag>,
+                              variant_internal_node<Value, Parameters, Box, Allocators, Tag>
+                          > const& n)
+{
+    boost::apply_visitor(v, n);
+}
+
+}} // namespace detail::rtree
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_VARIANT_VISITOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/weak_dynamic.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/weak_dynamic.hpp
new file mode 100644
index 00000000000..05fef59e525
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/weak_dynamic.hpp
@@ -0,0 +1,294 @@
+// Boost.Geometry Index
+//
+// R-tree nodes based on static conversion, storing dynamic-size containers
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_WEAK_DYNAMIC_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_WEAK_DYNAMIC_HPP
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree {
+
+template <typename Value, typename Parameters, typename Box, typename Allocators, typename Tag>
+struct weak_internal_node
+    : public weak_node<Value, Parameters, Box, Allocators, Tag>
+{
+    typedef boost::container::vector
+        <
+            rtree::ptr_pair<Box, typename Allocators::node_pointer>,
+            typename Allocators::internal_node_allocator_type::template rebind
+                <
+                    rtree::ptr_pair<Box, typename Allocators::node_pointer>
+                >::other
+        > elements_type;
+
+    template <typename Al>
+    inline weak_internal_node(Al const& al)
+        : elements(al)
+    {}
+
+    elements_type elements;
+};
+
+template <typename Value, typename Parameters, typename Box, typename Allocators, typename Tag>
+struct weak_leaf
+    : public weak_node<Value, Parameters, Box, Allocators, Tag>
+{
+    typedef boost::container::vector
+        <
+            Value,
+            typename Allocators::leaf_allocator_type::template rebind
+                <
+                    Value
+                >::other
+        > elements_type;
+
+    template <typename Al>
+    inline weak_leaf(Al const& al)
+        : elements(al)
+    {}
+
+    elements_type elements;
+};
+
+// nodes traits
+
+template <typename Value, typename Parameters, typename Box, typename Allocators>
+struct node<Value, Parameters, Box, Allocators, node_weak_dynamic_tag>
+{
+    typedef weak_node<Value, Parameters, Box, Allocators, node_weak_dynamic_tag> type;
+};
+
+template <typename Value, typename Parameters, typename Box, typename Allocators>
+struct internal_node<Value, Parameters, Box, Allocators, node_weak_dynamic_tag>
+{
+    typedef weak_internal_node<Value, Parameters, Box, Allocators, node_weak_dynamic_tag> type;
+};
+
+template <typename Value, typename Parameters, typename Box, typename Allocators>
+struct leaf<Value, Parameters, Box, Allocators, node_weak_dynamic_tag>
+{
+    typedef weak_leaf<Value, Parameters, Box, Allocators, node_weak_dynamic_tag> type;
+};
+
+// visitor traits
+
+template <typename Value, typename Parameters, typename Box, typename Allocators, bool IsVisitableConst>
+struct visitor<Value, Parameters, Box, Allocators, node_weak_dynamic_tag, IsVisitableConst>
+{
+    typedef weak_visitor<Value, Parameters, Box, Allocators, node_weak_dynamic_tag, IsVisitableConst> type;
+};
+
+// allocators
+
+template <typename Allocator, typename Value, typename Parameters, typename Box>
+class allocators<Allocator, Value, Parameters, Box, node_weak_dynamic_tag>
+    : public Allocator::template rebind<
+        typename internal_node<
+            Value, Parameters, Box,
+            allocators<Allocator, Value, Parameters, Box, node_weak_dynamic_tag>,
+            node_weak_dynamic_tag
+        >::type
+    >::other
+    , public Allocator::template rebind<
+        typename leaf<
+            Value, Parameters, Box,
+            allocators<Allocator, Value, Parameters, Box, node_weak_dynamic_tag>,
+            node_weak_dynamic_tag
+        >::type
+    >::other
+{
+    typedef typename Allocator::template rebind<
+        Value
+    >::other value_allocator_type;
+
+public:
+    typedef Allocator allocator_type;
+    
+    typedef Value value_type;
+    typedef typename value_allocator_type::reference reference;
+    typedef typename value_allocator_type::const_reference const_reference;
+    typedef typename value_allocator_type::size_type size_type;
+    typedef typename value_allocator_type::difference_type difference_type;
+    typedef typename value_allocator_type::pointer pointer;
+    typedef typename value_allocator_type::const_pointer const_pointer;
+
+    typedef typename Allocator::template rebind<
+        typename node<Value, Parameters, Box, allocators, node_weak_dynamic_tag>::type
+    >::other::pointer node_pointer;
+
+    typedef typename Allocator::template rebind<
+        typename internal_node<Value, Parameters, Box, allocators, node_weak_dynamic_tag>::type
+    >::other internal_node_allocator_type;
+
+    typedef typename Allocator::template rebind<
+        typename leaf<Value, Parameters, Box, allocators, node_weak_dynamic_tag>::type
+    >::other leaf_allocator_type;
+
+    inline allocators()
+        : internal_node_allocator_type()
+        , leaf_allocator_type()
+    {}
+
+    template <typename Alloc>
+    inline explicit allocators(Alloc const& alloc)
+        : internal_node_allocator_type(alloc)
+        , leaf_allocator_type(alloc)
+    {}
+
+    inline allocators(BOOST_FWD_REF(allocators) a)
+        : internal_node_allocator_type(boost::move(a.internal_node_allocator()))
+        , leaf_allocator_type(boost::move(a.leaf_allocator()))
+    {}
+
+    inline allocators & operator=(BOOST_FWD_REF(allocators) a)
+    {
+        internal_node_allocator() = ::boost::move(a.internal_node_allocator());
+        leaf_allocator() = ::boost::move(a.leaf_allocator());
+        return *this;
+    }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    inline allocators & operator=(allocators const& a)
+    {
+        internal_node_allocator() = a.internal_node_allocator();
+        leaf_allocator() = a.leaf_allocator();
+        return *this;
+    }
+#endif
+
+    void swap(allocators & a)
+    {
+        boost::swap(internal_node_allocator(), a.internal_node_allocator());
+        boost::swap(leaf_allocator(), a.leaf_allocator());
+    }
+
+    bool operator==(allocators const& a) const { return leaf_allocator() == a.leaf_allocator(); }
+    template <typename Alloc>
+    bool operator==(Alloc const& a) const { return leaf_allocator() == leaf_allocator_type(a); }
+
+    Allocator allocator() const { return Allocator(leaf_allocator()); }
+
+    internal_node_allocator_type & internal_node_allocator() { return *this; }
+    internal_node_allocator_type const& internal_node_allocator() const { return *this; }
+    leaf_allocator_type & leaf_allocator() { return *this; }
+    leaf_allocator_type const& leaf_allocator() const { return *this; }
+};
+
+// create_node_impl
+
+template <typename BaseNodePtr, typename Node>
+struct create_weak_node
+{
+    template <typename AllocNode>
+    static inline BaseNodePtr apply(AllocNode & alloc_node)
+    {
+        typedef boost::container::allocator_traits<AllocNode> Al;
+        typedef typename Al::pointer P;
+
+        P p = Al::allocate(alloc_node, 1);
+
+        if ( 0 == p )
+            throw_runtime_error("boost::geometry::index::rtree node creation failed");
+
+        scoped_deallocator<AllocNode> deallocator(p, alloc_node);
+
+        Al::construct(alloc_node, boost::pointer_traits<P>::to_address(p), alloc_node);
+
+        deallocator.release();
+        return p;
+    }
+};
+
+// destroy_node_impl
+
+template <typename Node>
+struct destroy_weak_node
+{
+    template <typename AllocNode, typename BaseNodePtr>
+    static inline void apply(AllocNode & alloc_node, BaseNodePtr n)
+    {
+        typedef boost::container::allocator_traits<AllocNode> Al;
+        typedef typename Al::pointer P;
+
+        P p(&static_cast<Node&>(rtree::get<Node>(*n)));
+        Al::destroy(alloc_node, boost::addressof(*p));
+        Al::deallocate(alloc_node, p, 1);
+    }
+};
+
+// create_node
+
+template <typename Allocators, typename Value, typename Parameters, typename Box, typename Tag>
+struct create_node<
+    Allocators,
+    weak_internal_node<Value, Parameters, Box, Allocators, Tag>
+>
+{
+    static inline typename Allocators::node_pointer
+    apply(Allocators & allocators)
+    {
+        return create_weak_node<
+            typename Allocators::node_pointer,
+            weak_internal_node<Value, Parameters, Box, Allocators, Tag>
+        >::apply(allocators.internal_node_allocator());
+    }
+};
+
+template <typename Allocators, typename Value, typename Parameters, typename Box, typename Tag>
+struct create_node<
+    Allocators,
+    weak_leaf<Value, Parameters, Box, Allocators, Tag>
+>
+{
+    static inline typename Allocators::node_pointer
+    apply(Allocators & allocators)
+    {
+        return create_weak_node<
+            typename Allocators::node_pointer,
+            weak_leaf<Value, Parameters, Box, Allocators, Tag>
+        >::apply(allocators.leaf_allocator());
+    }
+};
+
+// destroy_node
+
+template <typename Allocators, typename Value, typename Parameters, typename Box, typename Tag>
+struct destroy_node<
+    Allocators,
+    weak_internal_node<Value, Parameters, Box, Allocators, Tag>
+>
+{
+    static inline void apply(Allocators & allocators, typename Allocators::node_pointer n)
+    {
+        destroy_weak_node<
+            weak_internal_node<Value, Parameters, Box, Allocators, Tag>
+        >::apply(allocators.internal_node_allocator(), n);
+    }
+};
+
+template <typename Allocators, typename Value, typename Parameters, typename Box, typename Tag>
+struct destroy_node<
+    Allocators,
+    weak_leaf<Value, Parameters, Box, Allocators, Tag>
+>
+{
+    static inline void apply(Allocators & allocators, typename Allocators::node_pointer n)
+    {
+        destroy_weak_node<
+            weak_leaf<Value, Parameters, Box, Allocators, Tag>
+        >::apply(allocators.leaf_allocator(), n);
+    }
+};
+
+}} // namespace detail::rtree
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_WEAK_DYNAMIC_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/weak_static.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/weak_static.hpp
new file mode 100644
index 00000000000..632e35678a9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/weak_static.hpp
@@ -0,0 +1,174 @@
+// Boost.Geometry Index
+//
+// R-tree nodes based on static conversion, storing static-size containers
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_WEAK_STATIC_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_WEAK_STATIC_HPP
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree {
+
+template <typename Value, typename Parameters, typename Box, typename Allocators>
+struct weak_internal_node<Value, Parameters, Box, Allocators, node_weak_static_tag>
+    : public weak_node<Value, Parameters, Box, Allocators, node_weak_static_tag>
+{
+    typedef detail::varray<
+        rtree::ptr_pair<Box, typename Allocators::node_pointer>,
+        Parameters::max_elements + 1
+    > elements_type;
+
+    template <typename Alloc>
+    inline weak_internal_node(Alloc const&) {}
+
+    elements_type elements;
+};
+
+template <typename Value, typename Parameters, typename Box, typename Allocators>
+struct weak_leaf<Value, Parameters, Box, Allocators, node_weak_static_tag>
+    : public weak_node<Value, Parameters, Box, Allocators, node_weak_static_tag>
+{
+    typedef detail::varray<
+        Value,
+        Parameters::max_elements + 1
+    > elements_type;
+
+    template <typename Alloc>
+    inline weak_leaf(Alloc const&) {}
+
+    elements_type elements;
+};
+
+// nodes traits
+
+template <typename Value, typename Parameters, typename Box, typename Allocators>
+struct node<Value, Parameters, Box, Allocators, node_weak_static_tag>
+{
+    typedef weak_node<Value, Parameters, Box, Allocators, node_weak_static_tag> type;
+};
+
+template <typename Value, typename Parameters, typename Box, typename Allocators>
+struct internal_node<Value, Parameters, Box, Allocators, node_weak_static_tag>
+{
+    typedef weak_internal_node<Value, Parameters, Box, Allocators, node_weak_static_tag> type;
+};
+
+template <typename Value, typename Parameters, typename Box, typename Allocators>
+struct leaf<Value, Parameters, Box, Allocators, node_weak_static_tag>
+{
+    typedef weak_leaf<Value, Parameters, Box, Allocators, node_weak_static_tag> type;
+};
+
+template <typename Value, typename Parameters, typename Box, typename Allocators, bool IsVisitableConst>
+struct visitor<Value, Parameters, Box, Allocators, node_weak_static_tag, IsVisitableConst>
+{
+    typedef weak_visitor<Value, Parameters, Box, Allocators, node_weak_static_tag, IsVisitableConst> type;
+};
+
+// allocators
+
+template <typename Allocator, typename Value, typename Parameters, typename Box>
+class allocators<Allocator, Value, Parameters, Box, node_weak_static_tag>
+    : public Allocator::template rebind<
+        typename internal_node<
+            Value, Parameters, Box,
+            allocators<Allocator, Value, Parameters, Box, node_weak_static_tag>,
+            node_weak_static_tag
+        >::type
+    >::other
+    , public Allocator::template rebind<
+        typename leaf<
+            Value, Parameters, Box,
+            allocators<Allocator, Value, Parameters, Box, node_weak_static_tag>,
+            node_weak_static_tag
+        >::type
+    >::other
+{
+    typedef typename Allocator::template rebind<
+        Value
+    >::other value_allocator_type;
+
+public:
+    typedef Allocator allocator_type;
+
+    typedef Value value_type;
+    typedef value_type & reference;
+    typedef const value_type & const_reference;
+    typedef typename value_allocator_type::size_type size_type;
+    typedef typename value_allocator_type::difference_type difference_type;
+    typedef typename value_allocator_type::pointer pointer;
+    typedef typename value_allocator_type::const_pointer const_pointer;
+
+    typedef typename Allocator::template rebind<
+        typename node<Value, Parameters, Box, allocators, node_weak_static_tag>::type
+    >::other::pointer node_pointer;
+
+    typedef typename Allocator::template rebind<
+        typename internal_node<Value, Parameters, Box, allocators, node_weak_static_tag>::type
+    >::other internal_node_allocator_type;
+
+    typedef typename Allocator::template rebind<
+        typename leaf<Value, Parameters, Box, allocators, node_weak_static_tag>::type
+    >::other leaf_allocator_type;
+
+    inline allocators()
+        : internal_node_allocator_type()
+        , leaf_allocator_type()
+    {}
+
+    template <typename Alloc>
+    inline explicit allocators(Alloc const& alloc)
+        : internal_node_allocator_type(alloc)
+        , leaf_allocator_type(alloc)
+    {}
+
+    inline allocators(BOOST_FWD_REF(allocators) a)
+        : internal_node_allocator_type(boost::move(a.internal_node_allocator()))
+        , leaf_allocator_type(boost::move(a.leaf_allocator()))
+    {}
+
+    inline allocators & operator=(BOOST_FWD_REF(allocators) a)
+    {
+        internal_node_allocator() = ::boost::move(a.internal_node_allocator());
+        leaf_allocator() = ::boost::move(a.leaf_allocator());
+        return *this;
+    }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    inline allocators & operator=(allocators const& a)
+    {
+        internal_node_allocator() = a.internal_node_allocator();
+        leaf_allocator() = a.leaf_allocator();
+        return *this;
+    }
+#endif
+
+    void swap(allocators & a)
+    {
+        boost::swap(internal_node_allocator(), a.internal_node_allocator());
+        boost::swap(leaf_allocator(), a.leaf_allocator());
+    }
+
+    bool operator==(allocators const& a) const { return leaf_allocator() == a.leaf_allocator(); }
+    template <typename Alloc>
+    bool operator==(Alloc const& a) const { return leaf_allocator() == leaf_allocator_type(a); }
+
+    Allocator allocator() const { return Allocator(leaf_allocator()); }
+
+    internal_node_allocator_type & internal_node_allocator() { return *this; }
+    internal_node_allocator_type const& internal_node_allocator() const { return *this; }
+    leaf_allocator_type & leaf_allocator() { return *this; }
+    leaf_allocator_type const& leaf_allocator() const{ return *this; }
+};
+
+}} // namespace detail::rtree
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_WEAK_STATIC_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/weak_visitor.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/weak_visitor.hpp
new file mode 100644
index 00000000000..08d84778e63
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/node/weak_visitor.hpp
@@ -0,0 +1,67 @@
+// Boost.Geometry Index
+//
+// R-tree nodes weak visitor and nodes base type
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_WEAK_VISITOR_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_WEAK_VISITOR_HPP
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree {
+
+// empty visitor
+template <typename Value, typename Parameters, typename Box, typename Allocators, typename Tag, bool IsVisitableConst>
+struct weak_visitor {};
+
+// node
+
+template <typename Value, typename Parameters, typename Box, typename Allocators, typename Tag>
+struct weak_node {};
+
+// nodes variants forward declarations
+
+template <typename Value, typename Parameters, typename Box, typename Allocators, typename Tag>
+struct weak_internal_node;
+
+template <typename Value, typename Parameters, typename Box, typename Allocators, typename Tag>
+struct weak_leaf;
+
+// nodes conversion
+
+template <typename Derived, typename Value, typename Parameters, typename Box, typename Allocators, typename Tag>
+inline Derived & get(weak_node<Value, Parameters, Box, Allocators, Tag> & n)
+{
+    return static_cast<Derived&>(n);
+}
+
+// apply visitor
+
+template <typename Visitor, typename Value, typename Parameters, typename Box, typename Allocators, typename Tag>
+inline void apply_visitor(Visitor & v,
+                          weak_node<Value, Parameters, Box, Allocators, Tag> & n,
+                          bool is_internal_node)
+{
+    BOOST_GEOMETRY_INDEX_ASSERT(&n, "null ptr");
+    if ( is_internal_node )
+    {
+        typedef weak_internal_node<Value, Parameters, Box, Allocators, Tag> internal_node;
+        v(get<internal_node>(n));
+    }
+    else
+    {
+        typedef weak_leaf<Value, Parameters, Box, Allocators, Tag> leaf;
+        v(get<leaf>(n));
+    }
+}
+
+}} // namespace detail::rtree
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_NODE_DYNAMIC_VISITOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/options.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/options.hpp
new file mode 100644
index 00000000000..ff772834d71
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/options.hpp
@@ -0,0 +1,155 @@
+// Boost.Geometry Index
+//
+// R-tree options, algorithms, parameters
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_OPTIONS_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_OPTIONS_HPP
+
+#include <boost/geometry/index/parameters.hpp>
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree {
+
+// InsertTag
+struct insert_default_tag {};
+struct insert_reinsert_tag {};
+
+// ChooseNextNodeTag
+struct choose_by_content_diff_tag {};
+struct choose_by_overlap_diff_tag {};
+
+// SplitTag
+struct split_default_tag {};
+//struct split_kmeans_tag {};
+
+// RedistributeTag
+struct linear_tag {};
+struct quadratic_tag {};
+struct rstar_tag {};
+
+// NodeTag
+struct node_variant_dynamic_tag {};
+struct node_variant_static_tag {};
+//struct node_weak_dynamic_tag {};
+//struct node_weak_static_tag {};
+
+template <typename Parameters, typename InsertTag, typename ChooseNextNodeTag, typename SplitTag, typename RedistributeTag, typename NodeTag>
+struct options
+{
+    typedef Parameters parameters_type;
+    typedef InsertTag insert_tag;
+    typedef ChooseNextNodeTag choose_next_node_tag;
+    typedef SplitTag split_tag;
+    typedef RedistributeTag redistribute_tag;
+    typedef NodeTag node_tag;
+};
+
+template <typename Parameters>
+struct options_type
+{
+    // TODO: awulkiew - use static assert
+};
+
+template <size_t MaxElements, size_t MinElements>
+struct options_type< index::linear<MaxElements, MinElements> >
+{
+    typedef options<
+        index::linear<MaxElements, MinElements>,
+        insert_default_tag,
+        choose_by_content_diff_tag,
+        split_default_tag,
+        linear_tag,
+        node_variant_static_tag
+    > type;
+};
+
+template <size_t MaxElements, size_t MinElements>
+struct options_type< index::quadratic<MaxElements, MinElements> >
+{
+    typedef options<
+        index::quadratic<MaxElements, MinElements>,
+        insert_default_tag,
+        choose_by_content_diff_tag,
+        split_default_tag,
+        quadratic_tag,
+        node_variant_static_tag
+    > type;
+};
+
+template <size_t MaxElements, size_t MinElements, size_t OverlapCostThreshold, size_t ReinsertedElements>
+struct options_type< index::rstar<MaxElements, MinElements, OverlapCostThreshold, ReinsertedElements> >
+{
+    typedef options<
+        index::rstar<MaxElements, MinElements, OverlapCostThreshold, ReinsertedElements>,
+        insert_reinsert_tag,
+        choose_by_overlap_diff_tag,
+        split_default_tag,
+        rstar_tag,
+        node_variant_static_tag
+    > type;
+};
+
+//template <size_t MaxElements, size_t MinElements>
+//struct options_type< kmeans<MaxElements, MinElements> >
+//{
+//    typedef options<
+//        kmeans<MaxElements, MinElements>,
+//        insert_default_tag,
+//        choose_by_content_diff_tag, // change it?
+//        split_kmeans_tag,
+//        int, // dummy tag - not used for now
+//        node_variant_static_tag
+//    > type;
+//};
+
+template <>
+struct options_type< index::dynamic_linear >
+{
+    typedef options<
+        index::dynamic_linear,
+        insert_default_tag,
+        choose_by_content_diff_tag,
+        split_default_tag,
+        linear_tag,
+        node_variant_dynamic_tag
+    > type;
+};
+
+template <>
+struct options_type< index::dynamic_quadratic >
+{
+    typedef options<
+        index::dynamic_quadratic,
+        insert_default_tag,
+        choose_by_content_diff_tag,
+        split_default_tag,
+        quadratic_tag,
+        node_variant_dynamic_tag
+    > type;
+};
+
+template <>
+struct options_type< index::dynamic_rstar >
+{
+    typedef options<
+        index::dynamic_rstar,
+        insert_reinsert_tag,
+        choose_by_overlap_diff_tag,
+        split_default_tag,
+        rstar_tag,
+        node_variant_dynamic_tag
+    > type;
+};
+
+}} // namespace detail::rtree
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_OPTIONS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/pack_create.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/pack_create.hpp
new file mode 100644
index 00000000000..2d3903a7b49
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/pack_create.hpp
@@ -0,0 +1,465 @@
+// Boost.Geometry Index
+//
+// R-tree initial packing
+//
+// Copyright (c) 2011-2017 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_PACK_CREATE_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_PACK_CREATE_HPP
+
+#include <boost/geometry/algorithms/expand.hpp>
+#include <boost/geometry/index/detail/algorithms/bounds.hpp>
+#include <boost/geometry/index/detail/algorithms/nth_element.hpp>
+
+#include <boost/geometry/algorithms/detail/expand_by_epsilon.hpp>
+
+namespace boost { namespace geometry { namespace index { namespace detail { namespace rtree {
+
+namespace pack_utils {
+
+template <std::size_t Dimension>
+struct biggest_edge
+{
+    BOOST_STATIC_ASSERT(0 < Dimension);
+    template <typename Box>
+    static inline void apply(Box const& box, typename coordinate_type<Box>::type & length, std::size_t & dim_index)
+    {
+        biggest_edge<Dimension-1>::apply(box, length, dim_index);
+        typename coordinate_type<Box>::type curr
+            = geometry::get<max_corner, Dimension-1>(box) - geometry::get<min_corner, Dimension-1>(box);
+        if ( length < curr )
+        {
+            dim_index = Dimension - 1;
+            length = curr;
+        }
+    }
+};
+
+template <>
+struct biggest_edge<1>
+{
+    template <typename Box>
+    static inline void apply(Box const& box, typename coordinate_type<Box>::type & length, std::size_t & dim_index)
+    {
+        dim_index = 0;
+        length = geometry::get<max_corner, 0>(box) - geometry::get<min_corner, 0>(box);
+    }
+};
+
+template <std::size_t I>
+struct point_entries_comparer
+{
+    template <typename PointEntry>
+    bool operator()(PointEntry const& e1, PointEntry const& e2) const
+    {
+        return geometry::get<I>(e1.first) < geometry::get<I>(e2.first);
+    }
+};
+
+template <std::size_t I, std::size_t Dimension>
+struct nth_element_and_half_boxes
+{
+    template <typename EIt, typename Box>
+    static inline void apply(EIt first, EIt median, EIt last, Box const& box, Box & left, Box & right, std::size_t dim_index)
+    {
+        if ( I == dim_index )
+        {
+            index::detail::nth_element(first, median, last, point_entries_comparer<I>());
+
+            geometry::convert(box, left);
+            geometry::convert(box, right);
+            typename coordinate_type<Box>::type edge_len
+                = geometry::get<max_corner, I>(box) - geometry::get<min_corner, I>(box);
+            typename coordinate_type<Box>::type median
+                = geometry::get<min_corner, I>(box) + edge_len / 2;
+            geometry::set<max_corner, I>(left, median);
+            geometry::set<min_corner, I>(right, median);
+        }
+        else
+            nth_element_and_half_boxes<I+1, Dimension>::apply(first, median, last, box, left, right, dim_index);
+    }
+};
+
+template <std::size_t Dimension>
+struct nth_element_and_half_boxes<Dimension, Dimension>
+{
+    template <typename EIt, typename Box>
+    static inline void apply(EIt , EIt , EIt , Box const& , Box & , Box & , std::size_t ) {}
+};
+
+} // namespace pack_utils
+
+// STR leafs number are calculated as rcount/max
+// and the number of splitting planes for each dimension as (count/max)^(1/dimension)
+// <-> for dimension==2 -> sqrt(count/max)
+//
+// The main flaw of this algorithm is that the resulting tree will have bad structure for:
+// 1. non-uniformly distributed elements
+//      Statistic check could be performed, e.g. based on variance of lengths of elements edges for each dimension
+// 2. elements distributed mainly along one axis
+//      Calculate bounding box of all elements and then number of dividing planes for a dimension
+//      from the length of BB edge for this dimension (more or less assuming that elements are uniformly-distributed squares)
+//
+// Another thing is that the last node may have less elements than Max or even Min.
+// The number of splitting planes must be chosen more carefully than count/max
+//
+// This algorithm is something between STR and TGS
+// it is more similar to the top-down recursive kd-tree creation algorithm
+// using object median split and split axis of greatest BB edge
+// BB is only used as a hint (assuming objects are distributed uniformly)
+//
+// Implemented algorithm guarantees that the number of elements in nodes will be between Min and Max
+// and that nodes are packed as tightly as possible
+// e.g. for 177 values Max = 5 and Min = 2 it will construct the following tree:
+// ROOT                 177
+// L1          125               52
+// L2  25  25  25  25  25   25  17    10
+// L3  5x5 5x5 5x5 5x5 5x5  5x5 3x5+2 2x5
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+class pack
+{
+    typedef typename rtree::node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef typename Allocators::node_pointer node_pointer;
+    typedef rtree::subtree_destroyer<Value, Options, Translator, Box, Allocators> subtree_destroyer;
+    typedef typename Allocators::size_type size_type;
+
+    typedef typename geometry::point_type<Box>::type point_type;
+    typedef typename geometry::coordinate_type<point_type>::type coordinate_type;
+    typedef typename detail::default_content_result<Box>::type content_type;
+    typedef typename Options::parameters_type parameters_type;
+    static const std::size_t dimension = geometry::dimension<point_type>::value;
+
+    typedef typename rtree::container_from_elements_type<
+        typename rtree::elements_type<leaf>::type,
+        std::size_t
+    >::type values_counts_container;
+
+    typedef typename rtree::elements_type<internal_node>::type internal_elements;
+    typedef typename internal_elements::value_type internal_element;
+
+public:
+    // Arbitrary iterators
+    template <typename InIt> inline static
+    node_pointer apply(InIt first, InIt last, size_type & values_count, size_type & leafs_level,
+                       parameters_type const& parameters, Translator const& translator, Allocators & allocators)
+    {
+        typedef typename std::iterator_traits<InIt>::difference_type diff_type;
+            
+        diff_type diff = std::distance(first, last);
+        if ( diff <= 0 )
+            return node_pointer(0);
+
+        typedef std::pair<point_type, InIt> entry_type;
+        std::vector<entry_type> entries;
+
+        values_count = static_cast<size_type>(diff);
+        entries.reserve(values_count);
+        
+        expandable_box<Box> hint_box;
+        for ( ; first != last ; ++first )
+        {
+            // NOTE: support for iterators not returning true references adapted
+            // to Geometry concept and default translator returning true reference
+            // An alternative would be to dereference the iterator and translate
+            // in one expression each time the indexable was needed.
+            typename std::iterator_traits<InIt>::reference in_ref = *first;
+            typename Translator::result_type indexable = translator(in_ref);
+
+            // NOTE: added for consistency with insert()
+            // CONSIDER: alternative - ignore invalid indexable or throw an exception
+            BOOST_GEOMETRY_INDEX_ASSERT(detail::is_valid(indexable), "Indexable is invalid");
+
+            hint_box.expand(indexable);
+
+            point_type pt;
+            geometry::centroid(indexable, pt);
+            entries.push_back(std::make_pair(pt, first));
+        }
+
+        subtree_elements_counts subtree_counts = calculate_subtree_elements_counts(values_count, parameters, leafs_level);
+        internal_element el = per_level(entries.begin(), entries.end(), hint_box.get(), values_count, subtree_counts,
+                                        parameters, translator, allocators);
+
+        return el.second;
+    }
+
+private:
+    template <typename BoxType>
+    class expandable_box
+    {
+    public:
+        expandable_box()
+            : m_initialized(false)
+        {}
+
+        template <typename Indexable>
+        explicit expandable_box(Indexable const& indexable)
+            : m_initialized(true)
+        {
+            detail::bounds(indexable, m_box);
+        }
+
+        template <typename Indexable>
+        void expand(Indexable const& indexable)
+        {
+            if ( !m_initialized )
+            {
+                // it's guaranteed that the Box will be initialized
+                // only for Points, Boxes and Segments but that's ok
+                // since only those Geometries can be stored
+                detail::bounds(indexable, m_box);
+                m_initialized = true;
+            }
+            else
+            {
+                geometry::expand(m_box, indexable);
+            }
+        }
+
+        void expand_by_epsilon()
+        {
+            geometry::detail::expand_by_epsilon(m_box);
+        }
+
+        BoxType const& get() const
+        {
+            BOOST_GEOMETRY_INDEX_ASSERT(m_initialized, "uninitialized envelope accessed");
+            return m_box;
+        }
+
+    private:
+        bool m_initialized;
+        BoxType m_box;
+    };
+
+    struct subtree_elements_counts
+    {
+        subtree_elements_counts(std::size_t ma, std::size_t mi) : maxc(ma), minc(mi) {}
+        std::size_t maxc;
+        std::size_t minc;
+    };
+
+    template <typename EIt> inline static
+    internal_element per_level(EIt first, EIt last, Box const& hint_box, std::size_t values_count, subtree_elements_counts const& subtree_counts,
+                               parameters_type const& parameters, Translator const& translator, Allocators & allocators)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(0 < std::distance(first, last) && static_cast<std::size_t>(std::distance(first, last)) == values_count,
+                                    "unexpected parameters");
+
+        if ( subtree_counts.maxc <= 1 )
+        {
+            // ROOT or LEAF
+            BOOST_GEOMETRY_INDEX_ASSERT(values_count <= parameters.get_max_elements(),
+                                        "too big number of elements");
+            // if !root check m_parameters.get_min_elements() <= count
+
+            // create new leaf node
+            node_pointer n = rtree::create_node<Allocators, leaf>::apply(allocators);                       // MAY THROW (A)
+            subtree_destroyer auto_remover(n, allocators);
+            leaf & l = rtree::get<leaf>(*n);
+
+            // reserve space for values
+            rtree::elements(l).reserve(values_count);                                                       // MAY THROW (A)
+
+            // calculate values box and copy values
+            //   initialize the box explicitly to avoid GCC-4.4 uninitialized variable warnings with O2
+            expandable_box<Box> elements_box(translator(*(first->second)));
+            rtree::elements(l).push_back(*(first->second));                                                 // MAY THROW (A?,C)
+            for ( ++first ; first != last ; ++first )
+            {
+                // NOTE: push_back() must be called at the end in order to support move_iterator.
+                //       The iterator is dereferenced 2x (no temporary reference) to support
+                //       non-true reference types and move_iterator without boost::forward<>.
+                elements_box.expand(translator(*(first->second)));
+                rtree::elements(l).push_back(*(first->second));                                             // MAY THROW (A?,C)
+            }
+
+#ifdef BOOST_GEOMETRY_INDEX_EXPERIMENTAL_ENLARGE_BY_EPSILON
+            // Enlarge bounds of a leaf node.
+            // It's because Points and Segments are compared WRT machine epsilon
+            // This ensures that leafs bounds correspond to the stored elements
+            // NOTE: this is done only if the Indexable is a different kind of Geometry
+            //   than the bounds (only Box for now). Spatial predicates are checked
+            //   the same way for Geometry of the same kind.
+            if ( BOOST_GEOMETRY_CONDITION((
+                    ! index::detail::is_bounding_geometry
+                        <
+                            typename indexable_type<Translator>::type
+                        >::value )) )
+            {
+                elements_box.expand_by_epsilon();
+            }
+#endif
+
+            auto_remover.release();
+            return internal_element(elements_box.get(), n);
+        }
+
+        // calculate next max and min subtree counts
+        subtree_elements_counts next_subtree_counts = subtree_counts;
+        next_subtree_counts.maxc /= parameters.get_max_elements();
+        next_subtree_counts.minc /= parameters.get_max_elements();
+
+        // create new internal node
+        node_pointer n = rtree::create_node<Allocators, internal_node>::apply(allocators);                  // MAY THROW (A)
+        subtree_destroyer auto_remover(n, allocators);
+        internal_node & in = rtree::get<internal_node>(*n);
+
+        // reserve space for values
+        std::size_t nodes_count = calculate_nodes_count(values_count, subtree_counts);
+        rtree::elements(in).reserve(nodes_count);                                                           // MAY THROW (A)
+        // calculate values box and copy values
+        expandable_box<Box> elements_box;
+        
+        per_level_packets(first, last, hint_box, values_count, subtree_counts, next_subtree_counts,
+                          rtree::elements(in), elements_box,
+                          parameters, translator, allocators);
+
+        auto_remover.release();
+        return internal_element(elements_box.get(), n);
+    }
+
+    template <typename EIt, typename ExpandableBox> inline static
+    void per_level_packets(EIt first, EIt last, Box const& hint_box,
+                           std::size_t values_count,
+                           subtree_elements_counts const& subtree_counts,
+                           subtree_elements_counts const& next_subtree_counts,
+                           internal_elements & elements, ExpandableBox & elements_box,
+                           parameters_type const& parameters, Translator const& translator, Allocators & allocators)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(0 < std::distance(first, last) && static_cast<std::size_t>(std::distance(first, last)) == values_count,
+                                    "unexpected parameters");
+
+        BOOST_GEOMETRY_INDEX_ASSERT(subtree_counts.minc <= values_count,
+                                    "too small number of elements");
+
+        // only one packet
+        if ( values_count <= subtree_counts.maxc )
+        {
+            // the end, move to the next level
+            internal_element el = per_level(first, last, hint_box, values_count, next_subtree_counts,
+                                            parameters, translator, allocators);
+
+            // in case if push_back() do throw here
+            // and even if this is not probable (previously reserved memory, nonthrowing pairs copy)
+            // this case is also tested by exceptions test.
+            subtree_destroyer auto_remover(el.second, allocators);
+            // this container should have memory allocated, reserve() called outside
+            elements.push_back(el);                                                 // MAY THROW (A?,C) - however in normal conditions shouldn't
+            auto_remover.release();
+
+            elements_box.expand(el.first);
+            return;
+        }
+        
+        std::size_t median_count = calculate_median_count(values_count, subtree_counts);
+        EIt median = first + median_count;
+
+        coordinate_type greatest_length;
+        std::size_t greatest_dim_index = 0;
+        pack_utils::biggest_edge<dimension>::apply(hint_box, greatest_length, greatest_dim_index);
+        Box left, right;
+        pack_utils::nth_element_and_half_boxes<0, dimension>
+            ::apply(first, median, last, hint_box, left, right, greatest_dim_index);
+        
+        per_level_packets(first, median, left,
+                          median_count, subtree_counts, next_subtree_counts,
+                          elements, elements_box,
+                          parameters, translator, allocators);
+        per_level_packets(median, last, right,
+                          values_count - median_count, subtree_counts, next_subtree_counts,
+                          elements, elements_box,
+                          parameters, translator, allocators);
+    }
+
+    inline static
+    subtree_elements_counts calculate_subtree_elements_counts(std::size_t elements_count, parameters_type const& parameters, size_type & leafs_level)
+    {
+        boost::ignore_unused_variable_warning(parameters);
+
+        subtree_elements_counts res(1, 1);
+        leafs_level = 0;
+
+        std::size_t smax = parameters.get_max_elements();
+        for ( ; smax < elements_count ; smax *= parameters.get_max_elements(), ++leafs_level )
+            res.maxc = smax;
+
+        res.minc = parameters.get_min_elements() * (res.maxc / parameters.get_max_elements());
+
+        return res;
+    }
+
+    inline static
+    std::size_t calculate_nodes_count(std::size_t count,
+                                      subtree_elements_counts const& subtree_counts)
+    {
+        std::size_t n = count / subtree_counts.maxc;
+        std::size_t r = count % subtree_counts.maxc;
+
+        if ( 0 < r && r < subtree_counts.minc )
+        {
+            std::size_t count_minus_min = count - subtree_counts.minc;
+            n = count_minus_min / subtree_counts.maxc;
+            r = count_minus_min % subtree_counts.maxc;
+            ++n;
+        }
+
+        if ( 0 < r )
+            ++n;
+
+        return n;
+    }
+
+    inline static
+    std::size_t calculate_median_count(std::size_t count,
+                                       subtree_elements_counts const& subtree_counts)
+    {
+        // e.g. for max = 5, min = 2, count = 52, subtree_max = 25, subtree_min = 10
+
+        std::size_t n = count / subtree_counts.maxc; // e.g. 52 / 25 = 2
+        std::size_t r = count % subtree_counts.maxc; // e.g. 52 % 25 = 2
+        std::size_t median_count = (n / 2) * subtree_counts.maxc; // e.g. 2 / 2 * 25 = 25
+
+        if ( 0 != r ) // e.g. 0 != 2
+        {
+            if ( subtree_counts.minc <= r ) // e.g. 10 <= 2 == false
+            {
+                //BOOST_GEOMETRY_INDEX_ASSERT(0 < n, "unexpected value");
+                median_count = ((n+1)/2) * subtree_counts.maxc; // if calculated ((2+1)/2) * 25 which would be ok, but not in all cases
+            }
+            else // r < subtree_counts.second  // e.g. 2 < 10 == true
+            {
+                std::size_t count_minus_min = count - subtree_counts.minc; // e.g. 52 - 10 = 42
+                n = count_minus_min / subtree_counts.maxc; // e.g. 42 / 25 = 1
+                r = count_minus_min % subtree_counts.maxc; // e.g. 42 % 25 = 17
+                if ( r == 0 )                               // e.g. false
+                {
+                    // n can't be equal to 0 because then there wouldn't be any element in the other node
+                    //BOOST_GEOMETRY_INDEX_ASSERT(0 < n, "unexpected value");
+                    median_count = ((n+1)/2) * subtree_counts.maxc;     // if calculated ((1+1)/2) * 25 which would be ok, but not in all cases
+                }
+                else
+                {
+                    if ( n == 0 )                                        // e.g. false
+                        median_count = r;                                // if calculated -> 17 which is wrong!
+                    else
+                        median_count = ((n+2)/2) * subtree_counts.maxc; // e.g. ((1+2)/2) * 25 = 25
+                }
+            }
+        }
+
+        return median_count;
+    }
+};
+
+}}}}} // namespace boost::geometry::index::detail::rtree
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_PACK_CREATE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/quadratic/quadratic.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/quadratic/quadratic.hpp
new file mode 100644
index 00000000000..837ddbeecb6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/quadratic/quadratic.hpp
@@ -0,0 +1,16 @@
+// Boost.Geometry Index
+//
+// R-tree quadratic algorithm implementation
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_QUADRATIC_QUADRATIC_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_QUADRATIC_QUADRATIC_HPP
+
+#include <boost/geometry/index/detail/rtree/quadratic/redistribute_elements.hpp>
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_QUADRATIC_QUADRATIC_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/quadratic/redistribute_elements.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/quadratic/redistribute_elements.hpp
new file mode 100644
index 00000000000..928ffd47d96
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/quadratic/redistribute_elements.hpp
@@ -0,0 +1,295 @@
+// Boost.Geometry Index
+//
+// R-tree quadratic split algorithm implementation
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_QUADRATIC_REDISTRIBUTE_ELEMENTS_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_QUADRATIC_REDISTRIBUTE_ELEMENTS_HPP
+
+#include <algorithm>
+
+#include <boost/geometry/index/detail/algorithms/content.hpp>
+#include <boost/geometry/index/detail/algorithms/union_content.hpp>
+
+#include <boost/geometry/index/detail/bounded_view.hpp>
+
+#include <boost/geometry/index/detail/rtree/node/node.hpp>
+#include <boost/geometry/index/detail/rtree/visitors/insert.hpp>
+#include <boost/geometry/index/detail/rtree/visitors/is_leaf.hpp>
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree {
+
+namespace quadratic {
+
+template <typename Box, typename Elements, typename Parameters, typename Translator>
+inline void pick_seeds(Elements const& elements,
+                       Parameters const& parameters,
+                       Translator const& tr,
+                       size_t & seed1,
+                       size_t & seed2)
+{
+    typedef typename Elements::value_type element_type;
+    typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
+    typedef Box box_type;
+    typedef typename index::detail::default_content_result<box_type>::type content_type;
+    typedef index::detail::bounded_view<indexable_type, box_type> bounded_indexable_view;
+
+    const size_t elements_count = parameters.get_max_elements() + 1;
+    BOOST_GEOMETRY_INDEX_ASSERT(elements.size() == elements_count, "wrong number of elements");
+    BOOST_GEOMETRY_INDEX_ASSERT(2 <= elements_count, "unexpected number of elements");
+
+    content_type greatest_free_content = 0;
+    seed1 = 0;
+    seed2 = 1;
+
+    for ( size_t i = 0 ; i < elements_count - 1 ; ++i )
+    {
+        for ( size_t j = i + 1 ; j < elements_count ; ++j )
+        {
+            indexable_type const& ind1 = rtree::element_indexable(elements[i], tr);
+            indexable_type const& ind2 = rtree::element_indexable(elements[j], tr);
+
+            box_type enlarged_box;
+            detail::bounds(ind1, enlarged_box);
+            geometry::expand(enlarged_box, ind2);
+
+            bounded_indexable_view bounded_ind1(ind1);
+            bounded_indexable_view bounded_ind2(ind2);
+            content_type free_content = ( index::detail::content(enlarged_box)
+                                            - index::detail::content(bounded_ind1) )
+                                                - index::detail::content(bounded_ind2);
+                
+            if ( greatest_free_content < free_content )
+            {
+                greatest_free_content = free_content;
+                seed1 = i;
+                seed2 = j;
+            }
+        }
+    }
+
+    ::boost::ignore_unused_variable_warning(parameters);
+}
+
+} // namespace quadratic
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+struct redistribute_elements<Value, Options, Translator, Box, Allocators, quadratic_tag>
+{
+    typedef typename Options::parameters_type parameters_type;
+
+    typedef typename rtree::node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef typename index::detail::default_content_result<Box>::type content_type;
+
+    template <typename Node>
+    static inline void apply(Node & n,
+                             Node & second_node,
+                             Box & box1,
+                             Box & box2,
+                             parameters_type const& parameters,
+                             Translator const& translator,
+                             Allocators & allocators)
+    {
+        typedef typename rtree::elements_type<Node>::type elements_type;
+        typedef typename elements_type::value_type element_type;
+        typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
+
+        elements_type & elements1 = rtree::elements(n);
+        elements_type & elements2 = rtree::elements(second_node);
+        
+        BOOST_GEOMETRY_INDEX_ASSERT(elements1.size() == parameters.get_max_elements() + 1, "unexpected elements number");
+
+        // copy original elements - use in-memory storage (std::allocator)
+        // TODO: move if noexcept
+        typedef typename rtree::container_from_elements_type<elements_type, element_type>::type
+            container_type;
+        container_type elements_copy(elements1.begin(), elements1.end());                                   // MAY THROW, STRONG (alloc, copy)
+        container_type elements_backup(elements1.begin(), elements1.end());                                 // MAY THROW, STRONG (alloc, copy)
+        
+        // calculate initial seeds
+        size_t seed1 = 0;
+        size_t seed2 = 0;
+        quadratic::pick_seeds<Box>(elements_copy, parameters, translator, seed1, seed2);
+
+        // prepare nodes' elements containers
+        elements1.clear();
+        BOOST_GEOMETRY_INDEX_ASSERT(elements2.empty(), "second node's elements container should be empty");
+
+        BOOST_TRY
+        {
+            // add seeds
+            elements1.push_back(elements_copy[seed1]);                                                      // MAY THROW, STRONG (copy)
+            elements2.push_back(elements_copy[seed2]);                                                      // MAY THROW, STRONG (alloc, copy)
+
+            // calculate boxes
+            detail::bounds(rtree::element_indexable(elements_copy[seed1], translator), box1);
+            detail::bounds(rtree::element_indexable(elements_copy[seed2], translator), box2);
+
+            // remove seeds
+            if (seed1 < seed2)
+            {
+                rtree::move_from_back(elements_copy, elements_copy.begin() + seed2);                        // MAY THROW, STRONG (copy)
+                elements_copy.pop_back();
+                rtree::move_from_back(elements_copy, elements_copy.begin() + seed1);                        // MAY THROW, STRONG (copy)
+                elements_copy.pop_back();
+            }
+            else
+            {
+                rtree::move_from_back(elements_copy, elements_copy.begin() + seed1);                        // MAY THROW, STRONG (copy)
+                elements_copy.pop_back();
+                rtree::move_from_back(elements_copy, elements_copy.begin() + seed2);                        // MAY THROW, STRONG (copy)
+                elements_copy.pop_back();
+            }
+
+            // initialize areas
+            content_type content1 = index::detail::content(box1);
+            content_type content2 = index::detail::content(box2);
+
+            size_t remaining = elements_copy.size();
+
+            // redistribute the rest of the elements
+            while ( !elements_copy.empty() )
+            {
+                typename container_type::reverse_iterator el_it = elements_copy.rbegin();
+                bool insert_into_group1 = false;
+
+                size_t elements1_count = elements1.size();
+                size_t elements2_count = elements2.size();
+
+                // if there is small number of elements left and the number of elements in node is lesser than min_elems
+                // just insert them to this node
+                if ( elements1_count + remaining <= parameters.get_min_elements() )
+                {
+                    insert_into_group1 = true;
+                }
+                else if ( elements2_count + remaining <= parameters.get_min_elements() )
+                {
+                    insert_into_group1 = false;
+                }
+                // insert the best element
+                else
+                {
+                    // find element with minimum groups areas increses differences
+                    content_type content_increase1 = 0;
+                    content_type content_increase2 = 0;
+                    el_it = pick_next(elements_copy.rbegin(), elements_copy.rend(),
+                                      box1, box2, content1, content2, translator,
+                                      content_increase1, content_increase2);
+
+                    if ( content_increase1 < content_increase2 ||
+                         ( content_increase1 == content_increase2 && ( content1 < content2 ||
+                           ( content1 == content2 && elements1_count <= elements2_count ) )
+                         ) )
+                    {
+                        insert_into_group1 = true;
+                    }
+                    else
+                    {
+                        insert_into_group1 = false;
+                    }
+                }
+
+                // move element to the choosen group
+                element_type const& elem = *el_it;
+                indexable_type const& indexable = rtree::element_indexable(elem, translator);
+
+                if ( insert_into_group1 )
+                {
+                    elements1.push_back(elem);                                                              // MAY THROW, STRONG (copy)
+                    geometry::expand(box1, indexable);
+                    content1 = index::detail::content(box1);
+                }
+                else
+                {
+                    elements2.push_back(elem);                                                              // MAY THROW, STRONG (alloc, copy)
+                    geometry::expand(box2, indexable);
+                    content2 = index::detail::content(box2);
+                }
+
+                BOOST_GEOMETRY_INDEX_ASSERT(!elements_copy.empty(), "expected more elements");
+                typename container_type::iterator el_it_base = el_it.base();
+                rtree::move_from_back(elements_copy, --el_it_base);                                         // MAY THROW, STRONG (copy)
+                elements_copy.pop_back();
+
+                BOOST_GEOMETRY_INDEX_ASSERT(0 < remaining, "expected more remaining elements");
+                --remaining;
+            }
+        }
+        BOOST_CATCH(...)
+        {
+            //elements_copy.clear();
+            elements1.clear();
+            elements2.clear();
+
+            rtree::destroy_elements<Value, Options, Translator, Box, Allocators>::apply(elements_backup, allocators);
+            //elements_backup.clear();
+
+            BOOST_RETHROW                                                                                     // RETHROW, BASIC
+        }
+        BOOST_CATCH_END
+    }
+
+    // TODO: awulkiew - change following function to static member of the pick_next class?
+
+    template <typename It>
+    static inline It pick_next(It first, It last,
+                               Box const& box1, Box const& box2,
+                               content_type const& content1, content_type const& content2,
+                               Translator const& translator,
+                               content_type & out_content_increase1, content_type & out_content_increase2)
+    {
+        typedef typename boost::iterator_value<It>::type element_type;
+        typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
+
+        content_type greatest_content_incrase_diff = 0;
+        It out_it = first;
+        out_content_increase1 = 0;
+        out_content_increase2 = 0;
+        
+        // find element with greatest difference between increased group's boxes areas
+        for ( It el_it = first ; el_it != last ; ++el_it )
+        {
+            indexable_type const& indexable = rtree::element_indexable(*el_it, translator);
+
+            // calculate enlarged boxes and areas
+            Box enlarged_box1(box1);
+            Box enlarged_box2(box2);
+            geometry::expand(enlarged_box1, indexable);
+            geometry::expand(enlarged_box2, indexable);
+            content_type enlarged_content1 = index::detail::content(enlarged_box1);
+            content_type enlarged_content2 = index::detail::content(enlarged_box2);
+
+            content_type content_incrase1 = (enlarged_content1 - content1);
+            content_type content_incrase2 = (enlarged_content2 - content2);
+
+            content_type content_incrase_diff = content_incrase1 < content_incrase2 ?
+                content_incrase2 - content_incrase1 : content_incrase1 - content_incrase2;
+
+            if ( greatest_content_incrase_diff < content_incrase_diff )
+            {
+                greatest_content_incrase_diff = content_incrase_diff;
+                out_it = el_it;
+                out_content_increase1 = content_incrase1;
+                out_content_increase2 = content_incrase2;
+            }
+        }
+
+        return out_it;
+    }
+};
+
+}} // namespace detail::rtree
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_QUADRATIC_REDISTRIBUTE_ELEMENTS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/query_iterators.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/query_iterators.hpp
new file mode 100644
index 00000000000..83be106b8bd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/query_iterators.hpp
@@ -0,0 +1,387 @@
+// Boost.Geometry Index
+//
+// R-tree query iterators
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_QUERY_ITERATORS_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_QUERY_ITERATORS_HPP
+
+#include <boost/scoped_ptr.hpp>
+
+//#define BOOST_GEOMETRY_INDEX_DETAIL_QUERY_ITERATORS_USE_MOVE
+
+namespace boost { namespace geometry { namespace index { namespace detail { namespace rtree { namespace iterators {
+
+template <typename Value, typename Allocators>
+struct end_query_iterator
+{
+    typedef std::forward_iterator_tag iterator_category;
+    typedef Value value_type;
+    typedef typename Allocators::const_reference reference;
+    typedef typename Allocators::difference_type difference_type;
+    typedef typename Allocators::const_pointer pointer;
+
+    reference operator*() const
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(false, "iterator not dereferencable");
+        pointer p(0);
+        return *p;
+    }
+
+    const value_type * operator->() const
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(false, "iterator not dereferencable");
+        const value_type * p = 0;
+        return p;
+    }
+
+    end_query_iterator & operator++()
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(false, "iterator not incrementable");
+        return *this;
+    }
+
+    end_query_iterator operator++(int)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(false, "iterator not incrementable");
+        return *this;
+    }
+
+    friend bool operator==(end_query_iterator const& /*l*/, end_query_iterator const& /*r*/)
+    {
+        return true;
+    }
+};
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators, typename Predicates>
+class spatial_query_iterator
+{
+    typedef visitors::spatial_query_incremental<Value, Options, Translator, Box, Allocators, Predicates> visitor_type;
+    typedef typename visitor_type::node_pointer node_pointer;
+
+public:
+    typedef std::forward_iterator_tag iterator_category;
+    typedef Value value_type;
+    typedef typename Allocators::const_reference reference;
+    typedef typename Allocators::difference_type difference_type;
+    typedef typename Allocators::const_pointer pointer;
+
+    inline spatial_query_iterator()
+    {}
+
+    inline spatial_query_iterator(Translator const& t, Predicates const& p)
+        : m_visitor(t, p)
+    {}
+
+    inline spatial_query_iterator(node_pointer root, Translator const& t, Predicates const& p)
+        : m_visitor(t, p)
+    {
+        m_visitor.initialize(root);
+    }
+
+    reference operator*() const
+    {
+        return m_visitor.dereference();
+    }
+
+    const value_type * operator->() const
+    {
+        return boost::addressof(m_visitor.dereference());
+    }
+
+    spatial_query_iterator & operator++()
+    {
+        m_visitor.increment();
+        return *this;
+    }
+
+    spatial_query_iterator operator++(int)
+    {
+        spatial_query_iterator temp = *this;
+        this->operator++();
+        return temp;
+    }
+
+    friend bool operator==(spatial_query_iterator const& l, spatial_query_iterator const& r)
+    {
+        return l.m_visitor == r.m_visitor;
+    }
+
+    friend bool operator==(spatial_query_iterator const& l, end_query_iterator<Value, Allocators> const& /*r*/)
+    {
+        return l.m_visitor.is_end();
+    }
+
+    friend bool operator==(end_query_iterator<Value, Allocators> const& /*l*/, spatial_query_iterator const& r)
+    {
+        return r.m_visitor.is_end();
+    }
+    
+private:
+    visitor_type m_visitor;
+};
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators, typename Predicates, unsigned NearestPredicateIndex>
+class distance_query_iterator
+{
+    typedef visitors::distance_query_incremental<Value, Options, Translator, Box, Allocators, Predicates, NearestPredicateIndex> visitor_type;
+    typedef typename visitor_type::node_pointer node_pointer;
+
+public:
+    typedef std::forward_iterator_tag iterator_category;
+    typedef Value value_type;
+    typedef typename Allocators::const_reference reference;
+    typedef typename Allocators::difference_type difference_type;
+    typedef typename Allocators::const_pointer pointer;
+
+    inline distance_query_iterator()
+    {}
+
+    inline distance_query_iterator(Translator const& t, Predicates const& p)
+        : m_visitor(t, p)
+    {}
+
+    inline distance_query_iterator(node_pointer root, Translator const& t, Predicates const& p)
+        : m_visitor(t, p)
+    {
+        m_visitor.initialize(root);
+    }
+
+    reference operator*() const
+    {
+        return m_visitor.dereference();
+    }
+
+    const value_type * operator->() const
+    {
+        return boost::addressof(m_visitor.dereference());
+    }
+
+    distance_query_iterator & operator++()
+    {
+        m_visitor.increment();
+        return *this;
+    }
+
+    distance_query_iterator operator++(int)
+    {
+        distance_query_iterator temp = *this;
+        this->operator++();
+        return temp;
+    }
+
+    friend bool operator==(distance_query_iterator const& l, distance_query_iterator const& r)
+    {
+        return l.m_visitor == r.m_visitor;
+    }
+
+    friend bool operator==(distance_query_iterator const& l, end_query_iterator<Value, Allocators> const& /*r*/)
+    {
+        return l.m_visitor.is_end();
+    }
+
+    friend bool operator==(end_query_iterator<Value, Allocators> const& /*l*/, distance_query_iterator const& r)
+    {
+        return r.m_visitor.is_end();
+    }
+
+private:
+    visitor_type m_visitor;
+};
+
+
+template <typename L, typename R>
+inline bool operator!=(L const& l, R const& r)
+{
+    return !(l == r);
+}
+
+
+template <typename Value, typename Allocators>
+class query_iterator_base
+{
+public:
+    typedef std::forward_iterator_tag iterator_category;
+    typedef Value value_type;
+    typedef typename Allocators::const_reference reference;
+    typedef typename Allocators::difference_type difference_type;
+    typedef typename Allocators::const_pointer pointer;
+
+    virtual ~query_iterator_base() {}
+
+    virtual query_iterator_base * clone() const = 0;
+    
+    virtual bool is_end() const = 0;
+    virtual reference dereference() const = 0;
+    virtual void increment() = 0;
+    virtual bool equals(query_iterator_base const&) const = 0;
+};
+
+template <typename Value, typename Allocators, typename Iterator>
+class query_iterator_wrapper
+    : public query_iterator_base<Value, Allocators>
+{
+    typedef query_iterator_base<Value, Allocators> base_t;
+
+public:
+    typedef std::forward_iterator_tag iterator_category;
+    typedef Value value_type;
+    typedef typename Allocators::const_reference reference;
+    typedef typename Allocators::difference_type difference_type;
+    typedef typename Allocators::const_pointer pointer;
+
+    query_iterator_wrapper() : m_iterator() {}
+    explicit query_iterator_wrapper(Iterator const& it) : m_iterator(it) {}
+
+    virtual base_t * clone() const { return new query_iterator_wrapper(m_iterator); }
+
+    virtual bool is_end() const { return m_iterator == end_query_iterator<Value, Allocators>(); }
+    virtual reference dereference() const { return *m_iterator; }
+    virtual void increment() { ++m_iterator; }
+    virtual bool equals(base_t const& r) const
+    {
+        const query_iterator_wrapper * p = dynamic_cast<const query_iterator_wrapper *>(boost::addressof(r));
+        BOOST_GEOMETRY_INDEX_ASSERT(p, "iterators can't be compared");
+        return m_iterator == p->m_iterator;
+    }
+
+private:
+    Iterator m_iterator;
+};
+
+
+template <typename Value, typename Allocators>
+class query_iterator
+{
+    typedef query_iterator_base<Value, Allocators> iterator_base;
+    typedef boost::scoped_ptr<iterator_base> iterator_ptr;
+
+public:
+    typedef std::forward_iterator_tag iterator_category;
+    typedef Value value_type;
+    typedef typename Allocators::const_reference reference;
+    typedef typename Allocators::difference_type difference_type;
+    typedef typename Allocators::const_pointer pointer;
+
+    query_iterator()
+    {}
+
+    template <typename It>
+    query_iterator(It const& it)
+        : m_ptr(static_cast<iterator_base*>(
+                    new query_iterator_wrapper<Value, Allocators, It>(it) ))
+    {}
+
+    query_iterator(end_query_iterator<Value, Allocators> const& /*it*/)
+    {}
+
+    query_iterator(query_iterator const& o)
+        : m_ptr(o.m_ptr.get() ? o.m_ptr->clone() : 0)
+    {}
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_QUERY_ITERATORS_USE_MOVE
+    query_iterator & operator=(query_iterator const& o)
+    {
+        if ( this != boost::addressof(o) )
+        {
+            m_ptr.reset(o.m_ptr.get() ? o.m_ptr->clone() : 0);
+        }
+        return *this;
+    }
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    query_iterator(query_iterator && o)
+        : m_ptr(0)
+    {
+        m_ptr.swap(o.m_ptr);
+    }
+    query_iterator & operator=(query_iterator && o)
+    {
+        if ( this != boost::addressof(o) )
+        {
+            m_ptr.swap(o.m_ptr);
+            o.m_ptr.reset();
+        }
+        return *this;
+    }
+#endif
+#else // !BOOST_GEOMETRY_INDEX_DETAIL_QUERY_ITERATORS_USE_MOVE
+private:
+    BOOST_COPYABLE_AND_MOVABLE(query_iterator)
+public:
+    query_iterator & operator=(BOOST_COPY_ASSIGN_REF(query_iterator) o)
+    {
+        if ( this != boost::addressof(o) )
+        {
+            m_ptr.reset(o.m_ptr.get() ? o.m_ptr->clone() : 0);
+        }
+        return *this;
+    }
+    query_iterator(BOOST_RV_REF(query_iterator) o)
+        : m_ptr(0)
+    {
+        m_ptr.swap(o.m_ptr);
+    }
+    query_iterator & operator=(BOOST_RV_REF(query_iterator) o)
+    {
+        if ( this != boost::addressof(o) )
+        {
+            m_ptr.swap(o.m_ptr);
+            o.m_ptr.reset();
+        }
+        return *this;
+    }
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_QUERY_ITERATORS_USE_MOVE
+
+    reference operator*() const
+    {
+        return m_ptr->dereference();
+    }
+
+    const value_type * operator->() const
+    {
+        return boost::addressof(m_ptr->dereference());
+    }
+
+    query_iterator & operator++()
+    {
+        m_ptr->increment();
+        return *this;
+    }
+
+    query_iterator operator++(int)
+    {
+        query_iterator temp = *this;
+        this->operator++();
+        return temp;
+    }
+
+    friend bool operator==(query_iterator const& l, query_iterator const& r)
+    {
+        if ( l.m_ptr.get() )
+        {
+            if ( r.m_ptr.get() )
+                return l.m_ptr->equals(*r.m_ptr);
+            else
+                return l.m_ptr->is_end();
+        }
+        else
+        {
+            if ( r.m_ptr.get() )
+                return r.m_ptr->is_end();
+            else
+                return true;
+        }
+    }
+
+private:
+    iterator_ptr m_ptr;
+};
+
+}}}}}} // namespace boost::geometry::index::detail::rtree::iterators
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_QUERY_ITERATORS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/rstar/choose_next_node.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/rstar/choose_next_node.hpp
new file mode 100644
index 00000000000..89697b5947f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/rstar/choose_next_node.hpp
@@ -0,0 +1,234 @@
+// Boost.Geometry Index
+//
+// R-tree R*-tree next node choosing algorithm implementation
+//
+// Copyright (c) 2011-2017 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_RSTAR_CHOOSE_NEXT_NODE_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_RSTAR_CHOOSE_NEXT_NODE_HPP
+
+#include <algorithm>
+
+#include <boost/geometry/algorithms/expand.hpp>
+
+#include <boost/geometry/index/detail/algorithms/content.hpp>
+#include <boost/geometry/index/detail/algorithms/intersection_content.hpp>
+#include <boost/geometry/index/detail/algorithms/nth_element.hpp>
+#include <boost/geometry/index/detail/algorithms/union_content.hpp>
+
+#include <boost/geometry/index/detail/rtree/node/node.hpp>
+#include <boost/geometry/index/detail/rtree/visitors/is_leaf.hpp>
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree {
+
+template <typename Value, typename Options, typename Box, typename Allocators>
+class choose_next_node<Value, Options, Box, Allocators, choose_by_overlap_diff_tag>
+{
+    typedef typename rtree::node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef typename rtree::elements_type<internal_node>::type children_type;
+    typedef typename children_type::value_type child_type;
+
+    typedef typename Options::parameters_type parameters_type;
+
+    typedef typename index::detail::default_content_result<Box>::type content_type;
+
+public:
+    template <typename Indexable>
+    static inline size_t apply(internal_node & n,
+                               Indexable const& indexable,
+                               parameters_type const& parameters,
+                               size_t node_relative_level)
+    {
+        ::boost::ignore_unused_variable_warning(parameters);
+
+        children_type & children = rtree::elements(n);
+        
+        // children are leafs
+        if ( node_relative_level <= 1 )
+        {
+            return choose_by_minimum_overlap_cost(children, indexable, parameters.get_overlap_cost_threshold());
+        }
+        // children are internal nodes
+        else
+            return choose_by_minimum_content_cost(children, indexable);
+    }
+
+private:
+    template <typename Indexable>
+    static inline size_t choose_by_minimum_overlap_cost(children_type const& children,
+                                                        Indexable const& indexable,
+                                                        size_t overlap_cost_threshold)
+    {
+        const size_t children_count = children.size();
+
+        content_type min_content_diff = (std::numeric_limits<content_type>::max)();
+        content_type min_content = (std::numeric_limits<content_type>::max)();
+        size_t choosen_index = 0;
+
+        // create container of children sorted by content enlargement needed to include the new value
+        typedef boost::tuple<size_t, content_type, content_type> child_contents;
+
+        typename rtree::container_from_elements_type<children_type, child_contents>::type children_contents;
+        children_contents.resize(children_count);
+
+        for ( size_t i = 0 ; i < children_count ; ++i )
+        {
+            child_type const& ch_i = children[i];
+
+            // expanded child node's box
+            Box box_exp(ch_i.first);
+            geometry::expand(box_exp, indexable);
+
+            // areas difference
+            content_type content = index::detail::content(box_exp);
+            content_type content_diff = content - index::detail::content(ch_i.first);
+
+            children_contents[i] = boost::make_tuple(i, content_diff, content);
+
+            if ( content_diff < min_content_diff ||
+                 (content_diff == min_content_diff && content < min_content) )
+            {
+                min_content_diff = content_diff;
+                min_content = content;
+                choosen_index = i;
+            }
+        }
+
+        // is this assumption ok? if min_content_diff == 0 there is no overlap increase?
+
+        if ( min_content_diff < -std::numeric_limits<double>::epsilon() || std::numeric_limits<double>::epsilon() < min_content_diff )
+        {
+            size_t first_n_children_count = children_count;
+            if ( 0 < overlap_cost_threshold && overlap_cost_threshold < children.size() )
+            {
+                first_n_children_count = overlap_cost_threshold;
+                // rearrange by content_diff
+                // in order to calculate nearly minimum overlap cost
+                index::detail::nth_element(children_contents.begin(), children_contents.begin() + first_n_children_count, children_contents.end(), content_diff_less);
+            }
+
+            // calculate minimum or nearly minimum overlap cost
+            choosen_index = choose_by_minimum_overlap_cost_first_n(children, indexable, first_n_children_count, children_count, children_contents);
+        }
+
+        return choosen_index;
+    }
+
+    static inline bool content_diff_less(boost::tuple<size_t, content_type, content_type> const& p1, boost::tuple<size_t, content_type, content_type> const& p2)
+    {
+        return boost::get<1>(p1) < boost::get<1>(p2) ||
+               (boost::get<1>(p1) == boost::get<1>(p2) && boost::get<2>(p1) < boost::get<2>(p2));
+    }
+
+    template <typename Indexable, typename ChildrenContents>
+    static inline size_t choose_by_minimum_overlap_cost_first_n(children_type const& children,
+                                                                Indexable const& indexable,
+                                                                size_t const first_n_children_count,
+                                                                size_t const children_count,
+                                                                ChildrenContents const& children_contents)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(first_n_children_count <= children_count, "unexpected value");
+        BOOST_GEOMETRY_INDEX_ASSERT(children_contents.size() == children_count, "unexpected number of elements");
+
+        // choose index with smallest overlap change value, or content change or smallest content
+        size_t choosen_index = 0;
+        content_type smallest_overlap_diff = (std::numeric_limits<content_type>::max)();
+        content_type smallest_content_diff = (std::numeric_limits<content_type>::max)();
+        content_type smallest_content = (std::numeric_limits<content_type>::max)();
+
+        // for each child node
+        for (size_t i = 0 ; i < first_n_children_count ; ++i )
+        {
+            child_type const& ch_i = children[i];
+
+            Box box_exp(ch_i.first);
+            // calculate expanded box of child node ch_i
+            geometry::expand(box_exp, indexable);
+
+            content_type overlap_diff = 0;
+
+            // calculate overlap
+            for ( size_t j = 0 ; j < children_count ; ++j )
+            {
+                if ( i != j )
+                {
+                    child_type const& ch_j = children[j];
+
+                    content_type overlap_exp = index::detail::intersection_content(box_exp, ch_j.first);
+                    if ( overlap_exp < -std::numeric_limits<content_type>::epsilon() || std::numeric_limits<content_type>::epsilon() < overlap_exp )
+                    {
+                        overlap_diff += overlap_exp - index::detail::intersection_content(ch_i.first, ch_j.first);
+                    }
+                }
+            }
+
+            content_type content = boost::get<2>(children_contents[i]);
+            content_type content_diff = boost::get<1>(children_contents[i]);
+
+            // update result
+            if ( overlap_diff < smallest_overlap_diff ||
+                ( overlap_diff == smallest_overlap_diff && ( content_diff < smallest_content_diff ||
+                ( content_diff == smallest_content_diff && content < smallest_content ) )
+                ) )
+            {
+                smallest_overlap_diff = overlap_diff;
+                smallest_content_diff = content_diff;
+                smallest_content = content;
+                choosen_index = i;
+            }
+        }
+
+        return choosen_index;
+    }
+
+    template <typename Indexable>
+    static inline size_t choose_by_minimum_content_cost(children_type const& children, Indexable const& indexable)
+    {
+        size_t children_count = children.size();
+
+        // choose index with smallest content change or smallest content
+        size_t choosen_index = 0;
+        content_type smallest_content_diff = (std::numeric_limits<content_type>::max)();
+        content_type smallest_content = (std::numeric_limits<content_type>::max)();
+
+        // choose the child which requires smallest box expansion to store the indexable
+        for ( size_t i = 0 ; i < children_count ; ++i )
+        {
+            child_type const& ch_i = children[i];
+
+            // expanded child node's box
+            Box box_exp(ch_i.first);
+            geometry::expand(box_exp, indexable);
+
+            // areas difference
+            content_type content = index::detail::content(box_exp);
+            content_type content_diff = content - index::detail::content(ch_i.first);
+
+            // update the result
+            if ( content_diff < smallest_content_diff ||
+                ( content_diff == smallest_content_diff && content < smallest_content ) )
+            {
+                smallest_content_diff = content_diff;
+                smallest_content = content;
+                choosen_index = i;
+            }
+        }
+
+        return choosen_index;
+    }
+};
+
+}} // namespace detail::rtree
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_RSTAR_CHOOSE_NEXT_NODE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/rstar/insert.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/rstar/insert.hpp
new file mode 100644
index 00000000000..127290194f1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/rstar/insert.hpp
@@ -0,0 +1,591 @@
+// Boost.Geometry Index
+//
+// R-tree R*-tree insert algorithm implementation
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_RSTAR_INSERT_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_RSTAR_INSERT_HPP
+
+#include <boost/geometry/index/detail/algorithms/content.hpp>
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree { namespace visitors {
+
+namespace rstar {
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+class remove_elements_to_reinsert
+{
+public:
+    typedef typename rtree::node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef typename Options::parameters_type parameters_type;
+
+    //typedef typename Allocators::internal_node_pointer internal_node_pointer;
+    typedef internal_node * internal_node_pointer;
+
+    template <typename ResultElements, typename Node>
+    static inline void apply(ResultElements & result_elements,
+                             Node & n,
+                             internal_node_pointer parent,
+                             size_t current_child_index,
+                             parameters_type const& parameters,
+                             Translator const& translator,
+                             Allocators & allocators)
+    {
+        typedef typename rtree::elements_type<Node>::type elements_type;
+        typedef typename elements_type::value_type element_type;
+        typedef typename geometry::point_type<Box>::type point_type;
+        // TODO: awulkiew - change second point_type to the point type of the Indexable?
+        typedef typename
+            geometry::default_comparable_distance_result<point_type>::type
+                comparable_distance_type;
+
+        elements_type & elements = rtree::elements(n);
+
+        const size_t elements_count = parameters.get_max_elements() + 1;
+        const size_t reinserted_elements_count = (::std::min)(parameters.get_reinserted_elements(), elements_count - parameters.get_min_elements());
+
+        BOOST_GEOMETRY_INDEX_ASSERT(parent, "node shouldn't be the root node");
+        BOOST_GEOMETRY_INDEX_ASSERT(elements.size() == elements_count, "unexpected elements number");
+        BOOST_GEOMETRY_INDEX_ASSERT(0 < reinserted_elements_count, "wrong value of elements to reinsert");
+
+        // calculate current node's center
+        point_type node_center;
+        geometry::centroid(rtree::elements(*parent)[current_child_index].first, node_center);
+
+        // fill the container of centers' distances of children from current node's center
+        typedef typename index::detail::rtree::container_from_elements_type<
+            elements_type,
+            std::pair<comparable_distance_type, element_type>
+        >::type sorted_elements_type;
+
+        sorted_elements_type sorted_elements;
+        // If constructor is used instead of resize() MS implementation leaks here
+        sorted_elements.reserve(elements_count);                                                         // MAY THROW, STRONG (V, E: alloc, copy)
+        
+        for ( typename elements_type::const_iterator it = elements.begin() ;
+              it != elements.end() ; ++it )
+        {
+            point_type element_center;
+            geometry::centroid( rtree::element_indexable(*it, translator), element_center);
+            sorted_elements.push_back(std::make_pair(
+                geometry::comparable_distance(node_center, element_center),
+                *it));                                                                                  // MAY THROW (V, E: copy)
+        }
+
+        // sort elements by distances from center
+        std::partial_sort(
+            sorted_elements.begin(),
+            sorted_elements.begin() + reinserted_elements_count,
+            sorted_elements.end(),
+            distances_dsc<comparable_distance_type, element_type>);                                                // MAY THROW, BASIC (V, E: copy)
+
+        // copy elements which will be reinserted
+        result_elements.clear();
+        result_elements.reserve(reinserted_elements_count);                                             // MAY THROW, STRONG (V, E: alloc, copy)
+        for ( typename sorted_elements_type::const_iterator it = sorted_elements.begin() ;
+              it != sorted_elements.begin() + reinserted_elements_count ; ++it )
+        {
+            result_elements.push_back(it->second);                                                      // MAY THROW (V, E: copy)
+        }
+
+        BOOST_TRY
+        {
+            // copy remaining elements to the current node
+            elements.clear();
+            elements.reserve(elements_count - reinserted_elements_count);                                // SHOULDN'T THROW (new_size <= old size)
+            for ( typename sorted_elements_type::const_iterator it = sorted_elements.begin() + reinserted_elements_count;
+                  it != sorted_elements.end() ; ++it )
+            {
+                elements.push_back(it->second);                                                         // MAY THROW (V, E: copy)
+            }
+        }
+        BOOST_CATCH(...)
+        {
+            elements.clear();
+
+            for ( typename sorted_elements_type::iterator it = sorted_elements.begin() ;
+                  it != sorted_elements.end() ; ++it )
+            {
+                destroy_element<Value, Options, Translator, Box, Allocators>::apply(it->second, allocators);
+            }
+
+            BOOST_RETHROW                                                                                 // RETHROW
+        }
+        BOOST_CATCH_END
+
+        ::boost::ignore_unused_variable_warning(parameters);
+    }
+
+private:
+    template <typename Distance, typename El>
+    static inline bool distances_asc(
+        std::pair<Distance, El> const& d1,
+        std::pair<Distance, El> const& d2)
+    {
+        return d1.first < d2.first;
+    }
+    
+    template <typename Distance, typename El>
+    static inline bool distances_dsc(
+        std::pair<Distance, El> const& d1,
+        std::pair<Distance, El> const& d2)
+    {
+        return d1.first > d2.first;
+    }
+};
+
+template <size_t InsertIndex, typename Element, typename Value, typename Options, typename Box, typename Allocators>
+struct level_insert_elements_type
+{
+    typedef typename rtree::elements_type<
+        typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type
+    >::type type;
+};
+
+template <typename Value, typename Options, typename Box, typename Allocators>
+struct level_insert_elements_type<0, Value, Value, Options, Box, Allocators>
+{
+    typedef typename rtree::elements_type<
+        typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type
+    >::type type;
+};
+
+template <size_t InsertIndex, typename Element, typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+struct level_insert_base
+    : public detail::insert<Element, Value, Options, Translator, Box, Allocators>
+{
+    typedef detail::insert<Element, Value, Options, Translator, Box, Allocators> base;
+    typedef typename base::node node;
+    typedef typename base::internal_node internal_node;
+    typedef typename base::leaf leaf;
+
+    typedef typename level_insert_elements_type<InsertIndex, Element, Value, Options, Box, Allocators>::type elements_type;
+    typedef typename index::detail::rtree::container_from_elements_type<
+        elements_type,
+        typename elements_type::value_type
+    >::type result_elements_type;
+
+    typedef typename Options::parameters_type parameters_type;
+
+    typedef typename Allocators::node_pointer node_pointer;
+    typedef typename Allocators::size_type size_type;
+
+    inline level_insert_base(node_pointer & root,
+                             size_type & leafs_level,
+                             Element const& element,
+                             parameters_type const& parameters,
+                             Translator const& translator,
+                             Allocators & allocators,
+                             size_type relative_level)
+        : base(root, leafs_level, element, parameters, translator, allocators, relative_level)
+        , result_relative_level(0)
+    {}
+
+    template <typename Node>
+    inline void handle_possible_reinsert_or_split_of_root(Node &n)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(result_elements.empty(), "reinsert should be handled only once for level");
+
+        result_relative_level = base::m_leafs_level - base::m_traverse_data.current_level;
+
+        // overflow
+        if ( base::m_parameters.get_max_elements() < rtree::elements(n).size() )
+        {
+            // node isn't root node
+            if ( !base::m_traverse_data.current_is_root() )
+            {
+                // NOTE: exception-safety
+                // After an exception result_elements may contain garbage, don't use it
+                rstar::remove_elements_to_reinsert<Value, Options, Translator, Box, Allocators>::apply(
+                    result_elements, n,
+                    base::m_traverse_data.parent, base::m_traverse_data.current_child_index,
+                    base::m_parameters, base::m_translator, base::m_allocators);                            // MAY THROW, BASIC (V, E: alloc, copy)
+            }
+            // node is root node
+            else
+            {
+                BOOST_GEOMETRY_INDEX_ASSERT(&n == &rtree::get<Node>(*base::m_root_node), "node should be the root node");
+                base::split(n);                                                                             // MAY THROW (V, E: alloc, copy, N: alloc)
+            }
+        }
+    }
+
+    template <typename Node>
+    inline void handle_possible_split(Node &n) const
+    {
+        // overflow
+        if ( base::m_parameters.get_max_elements() < rtree::elements(n).size() )
+        {
+            base::split(n);                                                                                 // MAY THROW (V, E: alloc, copy, N: alloc)
+        }
+    }
+
+    template <typename Node>
+    inline void recalculate_aabb_if_necessary(Node const& n) const
+    {
+        if ( !result_elements.empty() && !base::m_traverse_data.current_is_root() )
+        {
+            // calulate node's new box
+            recalculate_aabb(n);
+        }
+    }
+
+    template <typename Node>
+    inline void recalculate_aabb(Node const& n) const
+    {
+        base::m_traverse_data.current_element().first =
+            elements_box<Box>(rtree::elements(n).begin(), rtree::elements(n).end(), base::m_translator);
+    }
+
+    inline void recalculate_aabb(leaf const& n) const
+    {
+        base::m_traverse_data.current_element().first =
+            values_box<Box>(rtree::elements(n).begin(), rtree::elements(n).end(), base::m_translator);
+    }
+
+    size_type result_relative_level;
+    result_elements_type result_elements;
+};
+
+template <size_t InsertIndex, typename Element, typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+struct level_insert
+    : public level_insert_base<InsertIndex, Element, Value, Options, Translator, Box, Allocators>
+{
+    typedef level_insert_base<InsertIndex, Element, Value, Options, Translator, Box, Allocators> base;
+    typedef typename base::node node;
+    typedef typename base::internal_node internal_node;
+    typedef typename base::leaf leaf;
+
+    typedef typename Options::parameters_type parameters_type;
+
+    typedef typename Allocators::node_pointer node_pointer;
+    typedef typename Allocators::size_type size_type;
+
+    inline level_insert(node_pointer & root,
+                        size_type & leafs_level,
+                        Element const& element,
+                        parameters_type const& parameters,
+                        Translator const& translator,
+                        Allocators & allocators,
+                        size_type relative_level)
+        : base(root, leafs_level, element, parameters, translator, allocators, relative_level)
+    {}
+
+    inline void operator()(internal_node & n)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(base::m_traverse_data.current_level < base::m_leafs_level, "unexpected level");
+
+        if ( base::m_traverse_data.current_level < base::m_level )
+        {
+            // next traversing step
+            base::traverse(*this, n);                                                                       // MAY THROW (E: alloc, copy, N: alloc)
+
+            // further insert
+            if ( 0 < InsertIndex )
+            {
+                BOOST_GEOMETRY_INDEX_ASSERT(0 < base::m_level, "illegal level value, level shouldn't be the root level for 0 < InsertIndex");
+
+                if ( base::m_traverse_data.current_level == base::m_level - 1 )
+                {
+                    base::handle_possible_reinsert_or_split_of_root(n);                                     // MAY THROW (E: alloc, copy, N: alloc)
+                }
+            }
+        }
+        else
+        {
+            BOOST_GEOMETRY_INDEX_ASSERT(base::m_level == base::m_traverse_data.current_level, "unexpected level");
+
+            BOOST_TRY
+            {
+                // push new child node
+                rtree::elements(n).push_back(base::m_element);                                              // MAY THROW, STRONG (E: alloc, copy)
+            }
+            BOOST_CATCH(...)
+            {
+                // NOTE: exception-safety
+                // if the insert fails above, the element won't be stored in the tree, so delete it
+
+                rtree::visitors::destroy<Value, Options, Translator, Box, Allocators> del_v(base::m_element.second, base::m_allocators);
+                rtree::apply_visitor(del_v, *base::m_element.second);
+
+                BOOST_RETHROW                                                                                 // RETHROW
+            }
+            BOOST_CATCH_END
+
+            // first insert
+            if ( 0 == InsertIndex )
+            {
+                base::handle_possible_reinsert_or_split_of_root(n);                                         // MAY THROW (E: alloc, copy, N: alloc)
+            }
+            // not the first insert
+            else
+            {
+                base::handle_possible_split(n);                                                             // MAY THROW (E: alloc, N: alloc)
+            }
+        }
+
+        base::recalculate_aabb_if_necessary(n);
+    }
+
+    inline void operator()(leaf &)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(false, "this visitor can't be used for a leaf");
+    }
+};
+
+template <size_t InsertIndex, typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+struct level_insert<InsertIndex, Value, Value, Options, Translator, Box, Allocators>
+    : public level_insert_base<InsertIndex, Value, Value, Options, Translator, Box, Allocators>
+{
+    typedef level_insert_base<InsertIndex, Value, Value, Options, Translator, Box, Allocators> base;
+    typedef typename base::node node;
+    typedef typename base::internal_node internal_node;
+    typedef typename base::leaf leaf;
+
+    typedef typename Options::parameters_type parameters_type;
+
+    typedef typename Allocators::node_pointer node_pointer;
+    typedef typename Allocators::size_type size_type;
+
+    inline level_insert(node_pointer & root,
+                        size_type & leafs_level,
+                        Value const& v,
+                        parameters_type const& parameters,
+                        Translator const& translator,
+                        Allocators & allocators,
+                        size_type relative_level)
+        : base(root, leafs_level, v, parameters, translator, allocators, relative_level)
+    {}
+
+    inline void operator()(internal_node & n)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(base::m_traverse_data.current_level < base::m_leafs_level, "unexpected level");
+        BOOST_GEOMETRY_INDEX_ASSERT(base::m_traverse_data.current_level < base::m_level, "unexpected level");
+
+        // next traversing step
+        base::traverse(*this, n);                                                                       // MAY THROW (V, E: alloc, copy, N: alloc)
+
+        BOOST_GEOMETRY_INDEX_ASSERT(0 < base::m_level, "illegal level value, level shouldn't be the root level for 0 < InsertIndex");
+        
+        if ( base::m_traverse_data.current_level == base::m_level - 1 )
+        {
+            base::handle_possible_reinsert_or_split_of_root(n);                                         // MAY THROW (E: alloc, copy, N: alloc)
+        }
+
+        base::recalculate_aabb_if_necessary(n);
+    }
+
+    inline void operator()(leaf & n)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(base::m_traverse_data.current_level == base::m_leafs_level,
+                                    "unexpected level");
+        BOOST_GEOMETRY_INDEX_ASSERT(base::m_level == base::m_traverse_data.current_level ||
+                                    base::m_level == (std::numeric_limits<size_t>::max)(),
+                                    "unexpected level");
+        
+        rtree::elements(n).push_back(base::m_element);                                                  // MAY THROW, STRONG (V: alloc, copy)
+
+        base::handle_possible_split(n);                                                                 // MAY THROW (V: alloc, copy, N: alloc)
+    }
+};
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+struct level_insert<0, Value, Value, Options, Translator, Box, Allocators>
+    : public level_insert_base<0, Value, Value, Options, Translator, Box, Allocators>
+{
+    typedef level_insert_base<0, Value, Value, Options, Translator, Box, Allocators> base;
+    typedef typename base::node node;
+    typedef typename base::internal_node internal_node;
+    typedef typename base::leaf leaf;
+
+    typedef typename Options::parameters_type parameters_type;
+
+    typedef typename Allocators::node_pointer node_pointer;
+    typedef typename Allocators::size_type size_type;
+
+    inline level_insert(node_pointer & root,
+                        size_type & leafs_level,
+                        Value const& v,
+                        parameters_type const& parameters,
+                        Translator const& translator,
+                        Allocators & allocators,
+                        size_type relative_level)
+        : base(root, leafs_level, v, parameters, translator, allocators, relative_level)
+    {}
+
+    inline void operator()(internal_node & n)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(base::m_traverse_data.current_level < base::m_leafs_level,
+                                    "unexpected level");
+        BOOST_GEOMETRY_INDEX_ASSERT(base::m_traverse_data.current_level < base::m_level,
+                                    "unexpected level");
+
+        // next traversing step
+        base::traverse(*this, n);                                                                       // MAY THROW (V: alloc, copy, N: alloc)
+
+        base::recalculate_aabb_if_necessary(n);
+    }
+
+    inline void operator()(leaf & n)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(base::m_traverse_data.current_level == base::m_leafs_level,
+                                    "unexpected level");
+        BOOST_GEOMETRY_INDEX_ASSERT(base::m_level == base::m_traverse_data.current_level ||
+                                    base::m_level == (std::numeric_limits<size_t>::max)(),
+                                    "unexpected level");
+
+        rtree::elements(n).push_back(base::m_element);                                                  // MAY THROW, STRONG (V: alloc, copy)
+
+        base::handle_possible_reinsert_or_split_of_root(n);                                             // MAY THROW (V: alloc, copy, N: alloc)
+        
+        base::recalculate_aabb_if_necessary(n);
+    }
+};
+
+} // namespace rstar
+
+// R*-tree insert visitor
+// After passing the Element to insert visitor the Element is managed by the tree
+// I.e. one should not delete the node passed to the insert visitor after exception is thrown
+// because this visitor may delete it
+template <typename Element, typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+class insert<Element, Value, Options, Translator, Box, Allocators, insert_reinsert_tag>
+    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, false>::type
+{
+    typedef typename Options::parameters_type parameters_type;
+
+    typedef typename rtree::node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef typename Allocators::node_pointer node_pointer;
+    typedef typename Allocators::size_type size_type;
+
+public:
+    inline insert(node_pointer & root,
+                  size_type & leafs_level,
+                  Element const& element,
+                  parameters_type const& parameters,
+                  Translator const& translator,
+                  Allocators & allocators,
+                  size_type relative_level = 0)
+        : m_root(root), m_leafs_level(leafs_level), m_element(element)
+        , m_parameters(parameters), m_translator(translator)
+        , m_relative_level(relative_level), m_allocators(allocators)
+    {}
+
+    inline void operator()(internal_node & n)
+    {
+        boost::ignore_unused(n);
+        BOOST_GEOMETRY_INDEX_ASSERT(&n == &rtree::get<internal_node>(*m_root), "current node should be the root");
+
+        // Distinguish between situation when reinserts are required and use adequate visitor, otherwise use default one
+        if ( m_parameters.get_reinserted_elements() > 0 )
+        {
+            rstar::level_insert<0, Element, Value, Options, Translator, Box, Allocators> lins_v(
+                m_root, m_leafs_level, m_element, m_parameters, m_translator, m_allocators, m_relative_level);
+
+            rtree::apply_visitor(lins_v, *m_root);                                                              // MAY THROW (V, E: alloc, copy, N: alloc)
+
+            if ( !lins_v.result_elements.empty() )
+            {
+                recursive_reinsert(lins_v.result_elements, lins_v.result_relative_level);                       // MAY THROW (V, E: alloc, copy, N: alloc)
+            }
+        }
+        else
+        {
+            visitors::insert<Element, Value, Options, Translator, Box, Allocators, insert_default_tag> ins_v(
+                m_root, m_leafs_level, m_element, m_parameters, m_translator, m_allocators, m_relative_level);
+
+            rtree::apply_visitor(ins_v, *m_root); 
+        }
+    }
+
+    inline void operator()(leaf & n)
+    {
+        boost::ignore_unused(n);
+        BOOST_GEOMETRY_INDEX_ASSERT(&n == &rtree::get<leaf>(*m_root), "current node should be the root");
+
+        // Distinguish between situation when reinserts are required and use adequate visitor, otherwise use default one
+        if ( m_parameters.get_reinserted_elements() > 0 )
+        {
+            rstar::level_insert<0, Element, Value, Options, Translator, Box, Allocators> lins_v(
+                m_root, m_leafs_level, m_element, m_parameters, m_translator, m_allocators, m_relative_level);
+
+            rtree::apply_visitor(lins_v, *m_root);                                                              // MAY THROW (V, E: alloc, copy, N: alloc)
+
+            // we're in the root, so root should be split and there should be no elements to reinsert
+            BOOST_GEOMETRY_INDEX_ASSERT(lins_v.result_elements.empty(), "unexpected state");
+        }
+        else
+        {
+            visitors::insert<Element, Value, Options, Translator, Box, Allocators, insert_default_tag> ins_v(
+                m_root, m_leafs_level, m_element, m_parameters, m_translator, m_allocators, m_relative_level);
+
+            rtree::apply_visitor(ins_v, *m_root); 
+        }
+    }
+
+private:
+    template <typename Elements>
+    inline void recursive_reinsert(Elements & elements, size_t relative_level)
+    {
+        typedef typename Elements::value_type element_type;
+
+        // reinsert children starting from the minimum distance
+        typename Elements::reverse_iterator it = elements.rbegin();
+        for ( ; it != elements.rend() ; ++it)
+        {
+            rstar::level_insert<1, element_type, Value, Options, Translator, Box, Allocators> lins_v(
+                m_root, m_leafs_level, *it, m_parameters, m_translator, m_allocators, relative_level);
+
+            BOOST_TRY
+            {
+                rtree::apply_visitor(lins_v, *m_root);                                                          // MAY THROW (V, E: alloc, copy, N: alloc)
+            }
+            BOOST_CATCH(...)
+            {
+                ++it;
+                for ( ; it != elements.rend() ; ++it)
+                    rtree::destroy_element<Value, Options, Translator, Box, Allocators>::apply(*it, m_allocators);
+                BOOST_RETHROW                                                                                     // RETHROW
+            }
+            BOOST_CATCH_END
+
+            BOOST_GEOMETRY_INDEX_ASSERT(relative_level + 1 == lins_v.result_relative_level, "unexpected level");
+
+            // non-root relative level
+            if ( lins_v.result_relative_level < m_leafs_level && !lins_v.result_elements.empty())
+            {
+                recursive_reinsert(lins_v.result_elements, lins_v.result_relative_level);                   // MAY THROW (V, E: alloc, copy, N: alloc)
+            }
+        }
+    }
+
+    node_pointer & m_root;
+    size_type & m_leafs_level;
+    Element const& m_element;
+
+    parameters_type const& m_parameters;
+    Translator const& m_translator;
+
+    size_type m_relative_level;
+
+    Allocators & m_allocators;
+};
+
+}}} // namespace detail::rtree::visitors
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_RSTAR_INSERT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/rstar/redistribute_elements.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/rstar/redistribute_elements.hpp
new file mode 100644
index 00000000000..187d37facd5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/rstar/redistribute_elements.hpp
@@ -0,0 +1,470 @@
+// Boost.Geometry Index
+//
+// R-tree R*-tree split algorithm implementation
+//
+// Copyright (c) 2011-2017 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_RSTAR_REDISTRIBUTE_ELEMENTS_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_RSTAR_REDISTRIBUTE_ELEMENTS_HPP
+
+#include <boost/geometry/index/detail/algorithms/intersection_content.hpp>
+#include <boost/geometry/index/detail/algorithms/margin.hpp>
+#include <boost/geometry/index/detail/algorithms/nth_element.hpp>
+#include <boost/geometry/index/detail/algorithms/union_content.hpp>
+
+#include <boost/geometry/index/detail/bounded_view.hpp>
+
+#include <boost/geometry/index/detail/rtree/node/node.hpp>
+#include <boost/geometry/index/detail/rtree/visitors/insert.hpp>
+#include <boost/geometry/index/detail/rtree/visitors/is_leaf.hpp>
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree {
+
+namespace rstar {
+
+template <typename Element, typename Translator, typename Tag, size_t Corner, size_t AxisIndex>
+class element_axis_corner_less
+{
+    typedef typename rtree::element_indexable_type<Element, Translator>::type indexable_type;
+    typedef typename geometry::point_type<indexable_type>::type point_type;
+    typedef geometry::model::box<point_type> bounds_type;
+    typedef index::detail::bounded_view<indexable_type, bounds_type> bounded_view_type;
+
+public:
+    element_axis_corner_less(Translator const& tr)
+        : m_tr(tr)
+    {}
+
+    bool operator()(Element const& e1, Element const& e2) const
+    {
+        bounded_view_type bounded_ind1(rtree::element_indexable(e1, m_tr));
+        bounded_view_type bounded_ind2(rtree::element_indexable(e2, m_tr));
+
+        return geometry::get<Corner, AxisIndex>(bounded_ind1)
+            < geometry::get<Corner, AxisIndex>(bounded_ind2);
+    }
+
+private:
+    Translator const& m_tr;
+};
+
+template <typename Element, typename Translator, size_t Corner, size_t AxisIndex>
+class element_axis_corner_less<Element, Translator, box_tag, Corner, AxisIndex>
+{
+public:
+    element_axis_corner_less(Translator const& tr)
+        : m_tr(tr)
+    {}
+
+    bool operator()(Element const& e1, Element const& e2) const
+    {
+        return geometry::get<Corner, AxisIndex>(rtree::element_indexable(e1, m_tr))
+            < geometry::get<Corner, AxisIndex>(rtree::element_indexable(e2, m_tr));
+    }
+
+private:
+    Translator const& m_tr;
+};
+
+template <typename Element, typename Translator, size_t Corner, size_t AxisIndex>
+class element_axis_corner_less<Element, Translator, point_tag, Corner, AxisIndex>
+{
+public:
+    element_axis_corner_less(Translator const& tr)
+        : m_tr(tr)
+    {}
+
+    bool operator()(Element const& e1, Element const& e2) const
+    {
+        return geometry::get<AxisIndex>(rtree::element_indexable(e1, m_tr))
+            < geometry::get<AxisIndex>(rtree::element_indexable(e2, m_tr));
+    }
+
+private:
+    Translator const& m_tr;
+};
+
+template <typename Box, size_t Corner, size_t AxisIndex>
+struct choose_split_axis_and_index_for_corner
+{
+    typedef typename index::detail::default_margin_result<Box>::type margin_type;
+    typedef typename index::detail::default_content_result<Box>::type content_type;
+
+    template <typename Elements, typename Parameters, typename Translator>
+    static inline void apply(Elements const& elements,
+                             size_t & choosen_index,
+                             margin_type & sum_of_margins,
+                             content_type & smallest_overlap,
+                             content_type & smallest_content,
+                             Parameters const& parameters,
+                             Translator const& translator)
+    {
+        typedef typename Elements::value_type element_type;
+        typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
+        typedef typename tag<indexable_type>::type indexable_tag;
+
+        BOOST_GEOMETRY_INDEX_ASSERT(elements.size() == parameters.get_max_elements() + 1, "wrong number of elements");
+
+        // copy elements
+        Elements elements_copy(elements);                                                                       // MAY THROW, STRONG (alloc, copy)
+        
+        size_t const index_first = parameters.get_min_elements();
+        size_t const index_last = parameters.get_max_elements() - parameters.get_min_elements() + 2;
+
+        // sort elements
+        element_axis_corner_less<element_type, Translator, indexable_tag, Corner, AxisIndex> elements_less(translator);
+        std::sort(elements_copy.begin(), elements_copy.end(), elements_less);                                   // MAY THROW, BASIC (copy)
+//        {
+//            typename Elements::iterator f = elements_copy.begin() + index_first;
+//            typename Elements::iterator l = elements_copy.begin() + index_last;
+//            // NOTE: for stdlibc++ shipped with gcc 4.8.2 std::nth_element is replaced with std::sort anyway
+//            index::detail::nth_element(elements_copy.begin(), f, elements_copy.end(), elements_less);                // MAY THROW, BASIC (copy)
+//            index::detail::nth_element(f, l, elements_copy.end(), elements_less);                                    // MAY THROW, BASIC (copy)
+//            std::sort(f, l, elements_less);                                                                   // MAY THROW, BASIC (copy)
+//        }
+
+        // init outputs
+        choosen_index = index_first;
+        sum_of_margins = 0;
+        smallest_overlap = (std::numeric_limits<content_type>::max)();
+        smallest_content = (std::numeric_limits<content_type>::max)();
+
+        // calculate sum of margins for all distributions
+        for ( size_t i = index_first ; i < index_last ; ++i )
+        {
+            // TODO - awulkiew: may be optimized - box of group 1 may be initialized with
+            // box of min_elems number of elements and expanded for each iteration by another element
+
+            Box box1 = rtree::elements_box<Box>(elements_copy.begin(), elements_copy.begin() + i, translator);
+            Box box2 = rtree::elements_box<Box>(elements_copy.begin() + i, elements_copy.end(), translator);
+            
+            sum_of_margins += index::detail::comparable_margin(box1) + index::detail::comparable_margin(box2);
+
+            content_type ovl = index::detail::intersection_content(box1, box2);
+            content_type con = index::detail::content(box1) + index::detail::content(box2);
+
+            // TODO - shouldn't here be < instead of <= ?
+            if ( ovl < smallest_overlap || (ovl == smallest_overlap && con <= smallest_content) )
+            {
+                choosen_index = i;
+                smallest_overlap = ovl;
+                smallest_content = con;
+            }
+        }
+
+        ::boost::ignore_unused_variable_warning(parameters);
+    }
+};
+
+//template <typename Box, size_t AxisIndex, typename ElementIndexableTag>
+//struct choose_split_axis_and_index_for_axis
+//{
+//    BOOST_MPL_ASSERT_MSG(false, NOT_IMPLEMENTED_FOR_THIS_TAG, (ElementIndexableTag));
+//};
+
+template <typename Box, size_t AxisIndex, typename ElementIndexableTag>
+struct choose_split_axis_and_index_for_axis
+{
+    typedef typename index::detail::default_margin_result<Box>::type margin_type;
+    typedef typename index::detail::default_content_result<Box>::type content_type;
+
+    template <typename Elements, typename Parameters, typename Translator>
+    static inline void apply(Elements const& elements,
+                             size_t & choosen_corner,
+                             size_t & choosen_index,
+                             margin_type & sum_of_margins,
+                             content_type & smallest_overlap,
+                             content_type & smallest_content,
+                             Parameters const& parameters,
+                             Translator const& translator)
+    {
+        size_t index1 = 0;
+        margin_type som1 = 0;
+        content_type ovl1 = (std::numeric_limits<content_type>::max)();
+        content_type con1 = (std::numeric_limits<content_type>::max)();
+
+        choose_split_axis_and_index_for_corner<Box, min_corner, AxisIndex>
+            ::apply(elements, index1,
+                    som1, ovl1, con1,
+                    parameters, translator);                                                                // MAY THROW, STRONG
+
+        size_t index2 = 0;
+        margin_type som2 = 0;
+        content_type ovl2 = (std::numeric_limits<content_type>::max)();
+        content_type con2 = (std::numeric_limits<content_type>::max)();
+
+        choose_split_axis_and_index_for_corner<Box, max_corner, AxisIndex>
+            ::apply(elements, index2,
+                    som2, ovl2, con2,
+                    parameters, translator);                                                                // MAY THROW, STRONG
+
+        sum_of_margins = som1 + som2;
+
+        if ( ovl1 < ovl2 || (ovl1 == ovl2 && con1 <= con2) )
+        {
+            choosen_corner = min_corner;
+            choosen_index = index1;
+            smallest_overlap = ovl1;
+            smallest_content = con1;
+        }
+        else
+        {
+            choosen_corner = max_corner;
+            choosen_index = index2;
+            smallest_overlap = ovl2;
+            smallest_content = con2;
+        }
+    }
+};
+
+template <typename Box, size_t AxisIndex>
+struct choose_split_axis_and_index_for_axis<Box, AxisIndex, point_tag>
+{
+    typedef typename index::detail::default_margin_result<Box>::type margin_type;
+    typedef typename index::detail::default_content_result<Box>::type content_type;
+
+    template <typename Elements, typename Parameters, typename Translator>
+    static inline void apply(Elements const& elements,
+                             size_t & choosen_corner,
+                             size_t & choosen_index,
+                             margin_type & sum_of_margins,
+                             content_type & smallest_overlap,
+                             content_type & smallest_content,
+                             Parameters const& parameters,
+                             Translator const& translator)
+    {
+        choose_split_axis_and_index_for_corner<Box, min_corner, AxisIndex>
+            ::apply(elements, choosen_index,
+                    sum_of_margins, smallest_overlap, smallest_content,
+                    parameters, translator);                                                                // MAY THROW, STRONG
+
+        choosen_corner = min_corner;
+    }
+};
+
+template <typename Box, size_t Dimension>
+struct choose_split_axis_and_index
+{
+    BOOST_STATIC_ASSERT(0 < Dimension);
+
+    typedef typename index::detail::default_margin_result<Box>::type margin_type;
+    typedef typename index::detail::default_content_result<Box>::type content_type;
+
+    template <typename Elements, typename Parameters, typename Translator>
+    static inline void apply(Elements const& elements,
+                             size_t & choosen_axis,
+                             size_t & choosen_corner,
+                             size_t & choosen_index,
+                             margin_type & smallest_sum_of_margins,
+                             content_type & smallest_overlap,
+                             content_type & smallest_content,
+                             Parameters const& parameters,
+                             Translator const& translator)
+    {
+        typedef typename rtree::element_indexable_type<typename Elements::value_type, Translator>::type element_indexable_type;
+
+        choose_split_axis_and_index<Box, Dimension - 1>
+            ::apply(elements, choosen_axis, choosen_corner, choosen_index,
+                    smallest_sum_of_margins, smallest_overlap, smallest_content,
+                    parameters, translator);                                                                // MAY THROW, STRONG
+
+        margin_type sum_of_margins = 0;
+
+        size_t corner = min_corner;
+        size_t index = 0;
+
+        content_type overlap_val = (std::numeric_limits<content_type>::max)();
+        content_type content_val = (std::numeric_limits<content_type>::max)();
+
+        choose_split_axis_and_index_for_axis<
+            Box,
+            Dimension - 1,
+            typename tag<element_indexable_type>::type
+        >::apply(elements, corner, index, sum_of_margins, overlap_val, content_val, parameters, translator); // MAY THROW, STRONG
+
+        if ( sum_of_margins < smallest_sum_of_margins )
+        {
+            choosen_axis = Dimension - 1;
+            choosen_corner = corner;
+            choosen_index = index;
+            smallest_sum_of_margins = sum_of_margins;
+            smallest_overlap = overlap_val;
+            smallest_content = content_val;
+        }
+    }
+};
+
+template <typename Box>
+struct choose_split_axis_and_index<Box, 1>
+{
+    typedef typename index::detail::default_margin_result<Box>::type margin_type;
+    typedef typename index::detail::default_content_result<Box>::type content_type;
+
+    template <typename Elements, typename Parameters, typename Translator>
+    static inline void apply(Elements const& elements,
+                             size_t & choosen_axis,
+                             size_t & choosen_corner,
+                             size_t & choosen_index,
+                             margin_type & smallest_sum_of_margins,
+                             content_type & smallest_overlap,
+                             content_type & smallest_content,
+                             Parameters const& parameters,
+                             Translator const& translator)
+    {
+        typedef typename rtree::element_indexable_type<typename Elements::value_type, Translator>::type element_indexable_type;
+
+        choosen_axis = 0;
+
+        choose_split_axis_and_index_for_axis<
+            Box,
+            0,
+            typename tag<element_indexable_type>::type
+        >::apply(elements, choosen_corner, choosen_index, smallest_sum_of_margins, smallest_overlap, smallest_content, parameters, translator); // MAY THROW
+    }
+};
+
+template <size_t Corner, size_t Dimension, size_t I = 0>
+struct nth_element
+{
+    BOOST_STATIC_ASSERT(0 < Dimension);
+    BOOST_STATIC_ASSERT(I < Dimension);
+
+    template <typename Elements, typename Translator>
+    static inline void apply(Elements & elements, const size_t axis, const size_t index, Translator const& tr)
+    {
+        //BOOST_GEOMETRY_INDEX_ASSERT(axis < Dimension, "unexpected axis value");
+
+        if ( axis != I )
+        {
+            nth_element<Corner, Dimension, I + 1>::apply(elements, axis, index, tr);                          // MAY THROW, BASIC (copy)
+        }
+        else
+        {
+            typedef typename Elements::value_type element_type;
+            typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
+            typedef typename tag<indexable_type>::type indexable_tag;
+
+            element_axis_corner_less<element_type, Translator, indexable_tag, Corner, I> less(tr);
+            index::detail::nth_element(elements.begin(), elements.begin() + index, elements.end(), less);            // MAY THROW, BASIC (copy)
+        }
+    }
+};
+
+template <size_t Corner, size_t Dimension>
+struct nth_element<Corner, Dimension, Dimension>
+{
+    template <typename Elements, typename Translator>
+    static inline void apply(Elements & /*elements*/, const size_t /*axis*/, const size_t /*index*/, Translator const& /*tr*/)
+    {}
+};
+
+} // namespace rstar
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+struct redistribute_elements<Value, Options, Translator, Box, Allocators, rstar_tag>
+{
+    typedef typename rtree::node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef typename Options::parameters_type parameters_type;
+
+    static const size_t dimension = geometry::dimension<Box>::value;
+
+    typedef typename index::detail::default_margin_result<Box>::type margin_type;
+    typedef typename index::detail::default_content_result<Box>::type content_type;
+
+    template <typename Node>
+    static inline void apply(
+        Node & n,
+        Node & second_node,
+        Box & box1,
+        Box & box2,
+        parameters_type const& parameters,
+        Translator const& translator,
+        Allocators & allocators)
+    {
+        typedef typename rtree::elements_type<Node>::type elements_type;
+        typedef typename elements_type::value_type element_type;
+        
+        elements_type & elements1 = rtree::elements(n);
+        elements_type & elements2 = rtree::elements(second_node);
+
+        // copy original elements - use in-memory storage (std::allocator)
+        // TODO: move if noexcept
+        typedef typename rtree::container_from_elements_type<elements_type, element_type>::type
+            container_type;
+        container_type elements_copy(elements1.begin(), elements1.end());                               // MAY THROW, STRONG
+        container_type elements_backup(elements1.begin(), elements1.end());                             // MAY THROW, STRONG
+
+        size_t split_axis = 0;
+        size_t split_corner = 0;
+        size_t split_index = parameters.get_min_elements();
+        margin_type smallest_sum_of_margins = (std::numeric_limits<margin_type>::max)();
+        content_type smallest_overlap = (std::numeric_limits<content_type>::max)();
+        content_type smallest_content = (std::numeric_limits<content_type>::max)();
+
+        // NOTE: this function internally copies passed elements
+        //       why not pass mutable elements and use the same container for all axes/corners
+        //       and again, the same below calling partial_sort/nth_element
+        //       It would be even possible to not re-sort/find nth_element if the axis/corner
+        //       was found for the last sorting - last combination of axis/corner
+        rstar::choose_split_axis_and_index<Box, dimension>
+            ::apply(elements_copy,
+                    split_axis, split_corner, split_index,
+                    smallest_sum_of_margins, smallest_overlap, smallest_content,
+                    parameters, translator);                                                            // MAY THROW, STRONG
+
+        // TODO: awulkiew - get rid of following static_casts?
+        BOOST_GEOMETRY_INDEX_ASSERT(split_axis < dimension, "unexpected value");
+        BOOST_GEOMETRY_INDEX_ASSERT(split_corner == static_cast<size_t>(min_corner) || split_corner == static_cast<size_t>(max_corner), "unexpected value");
+        BOOST_GEOMETRY_INDEX_ASSERT(parameters.get_min_elements() <= split_index && split_index <= parameters.get_max_elements() - parameters.get_min_elements() + 1, "unexpected value");
+
+        // TODO: consider using nth_element
+        if ( split_corner == static_cast<size_t>(min_corner) )
+        {
+            rstar::nth_element<min_corner, dimension>
+                ::apply(elements_copy, split_axis, split_index, translator);                            // MAY THROW, BASIC (copy)
+        }
+        else
+        {
+            rstar::nth_element<max_corner, dimension>
+                ::apply(elements_copy, split_axis, split_index, translator);                            // MAY THROW, BASIC (copy)
+        }
+
+        BOOST_TRY
+        {
+            // copy elements to nodes
+            elements1.assign(elements_copy.begin(), elements_copy.begin() + split_index);               // MAY THROW, BASIC
+            elements2.assign(elements_copy.begin() + split_index, elements_copy.end());                 // MAY THROW, BASIC
+
+            // calculate boxes
+            box1 = rtree::elements_box<Box>(elements1.begin(), elements1.end(), translator);
+            box2 = rtree::elements_box<Box>(elements2.begin(), elements2.end(), translator);
+        }
+        BOOST_CATCH(...)
+        {
+            //elements_copy.clear();
+            elements1.clear();
+            elements2.clear();
+
+            rtree::destroy_elements<Value, Options, Translator, Box, Allocators>::apply(elements_backup, allocators);
+            //elements_backup.clear();
+
+            BOOST_RETHROW                                                                                 // RETHROW, BASIC
+        }
+        BOOST_CATCH_END
+    }
+};
+
+}} // namespace detail::rtree
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_RSTAR_REDISTRIBUTE_ELEMENTS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/rstar/rstar.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/rstar/rstar.hpp
new file mode 100644
index 00000000000..ed3959c89d5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/rstar/rstar.hpp
@@ -0,0 +1,18 @@
+// Boost.Geometry Index
+//
+// R-tree R*-tree algorithm implementation
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_RSTAR_RSTAR_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_RSTAR_RSTAR_HPP
+
+#include <boost/geometry/index/detail/rtree/rstar/insert.hpp>
+#include <boost/geometry/index/detail/rtree/rstar/choose_next_node.hpp>
+#include <boost/geometry/index/detail/rtree/rstar/redistribute_elements.hpp>
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_RSTAR_RSTAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/are_boxes_ok.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/are_boxes_ok.hpp
new file mode 100644
index 00000000000..8e0560379b4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/are_boxes_ok.hpp
@@ -0,0 +1,128 @@
+// Boost.Geometry Index
+//
+// R-tree boxes validating visitor implementation
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_ARE_BOXES_OK_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_ARE_BOXES_OK_HPP
+
+#include <boost/geometry/algorithms/equals.hpp>
+#include <boost/geometry/index/detail/rtree/node/node.hpp>
+
+namespace boost { namespace geometry { namespace index { namespace detail { namespace rtree { namespace utilities {
+
+namespace visitors {
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+class are_boxes_ok
+    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
+{
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+public:
+    are_boxes_ok(Translator const& tr, bool exact_match)
+        : result(false), m_tr(tr), m_is_root(true), m_exact_match(exact_match)
+    {}
+
+    void operator()(internal_node const& n)
+    {
+        typedef typename rtree::elements_type<internal_node>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        if (elements.empty())
+        {
+            result = false;
+            return;
+        }
+
+        Box box_bckup = m_box;
+        bool is_root_bckup = m_is_root;
+
+        m_is_root = false;
+
+        for ( typename elements_type::const_iterator it = elements.begin();
+              it != elements.end() ; ++it)
+        {
+            m_box = it->first;
+
+            rtree::apply_visitor(*this, *it->second);
+
+            if ( result == false )
+                return;
+        }
+
+        m_box = box_bckup;
+        m_is_root = is_root_bckup;
+
+        Box box_exp = rtree::elements_box<Box>(elements.begin(), elements.end(), m_tr);
+        
+        if ( m_exact_match )
+            result = m_is_root || geometry::equals(box_exp, m_box);
+        else
+            result = m_is_root || geometry::covered_by(box_exp, m_box);
+    }
+
+    void operator()(leaf const& n)
+    {
+        typedef typename rtree::elements_type<leaf>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        // non-root node
+        if (!m_is_root)
+        {
+            if ( elements.empty() )
+            {
+                result = false;
+                return;
+            }
+        
+            Box box_exp = rtree::values_box<Box>(elements.begin(), elements.end(), m_tr);
+
+            if ( m_exact_match )
+                result = geometry::equals(box_exp, m_box);
+            else
+                result = geometry::covered_by(box_exp, m_box);
+        }
+        else
+            result = true;
+    }
+
+    bool result;
+
+private:
+    Translator const& m_tr;
+    Box m_box;
+    bool m_is_root;
+    bool m_exact_match;
+};
+
+} // namespace visitors
+
+template <typename Rtree> inline
+bool are_boxes_ok(Rtree const& tree, bool exact_match = true)
+{
+    typedef utilities::view<Rtree> RTV;
+    RTV rtv(tree);
+
+    visitors::are_boxes_ok<
+        typename RTV::value_type,
+        typename RTV::options_type,
+        typename RTV::translator_type,
+        typename RTV::box_type,
+        typename RTV::allocators_type
+    > v(rtv.translator(), exact_match);
+    
+    rtv.apply_visitor(v);
+
+    return v.result;
+}
+
+}}}}}} // namespace boost::geometry::index::detail::rtree::utilities
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_ARE_BOXES_OK_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/are_counts_ok.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/are_counts_ok.hpp
new file mode 100644
index 00000000000..10a1bec6ad2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/are_counts_ok.hpp
@@ -0,0 +1,110 @@
+// Boost.Geometry Index
+//
+// R-tree nodes elements numbers validating visitor implementation
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_ARE_COUNTS_OK_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_ARE_COUNTS_OK_HPP
+
+#include <boost/geometry/index/detail/rtree/node/node.hpp>
+
+namespace boost { namespace geometry { namespace index { namespace detail { namespace rtree { namespace utilities {
+
+namespace visitors {
+
+template <typename Value, typename Options, typename Box, typename Allocators>
+class are_counts_ok
+    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
+{
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+    typedef typename Options::parameters_type parameters_type;
+
+public:
+    inline are_counts_ok(parameters_type const& parameters)
+        : result(true), m_current_level(0), m_parameters(parameters)
+    {}
+
+    inline void operator()(internal_node const& n)
+    {
+        typedef typename rtree::elements_type<internal_node>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        // root internal node shouldn't contain 0 elements
+        if ( elements.empty()
+          || !check_count(elements) )
+        {
+            result = false;
+            return;
+        }
+
+        size_t current_level_backup = m_current_level;
+        ++m_current_level;
+
+        for ( typename elements_type::const_iterator it = elements.begin();
+              it != elements.end() && result == true ;
+              ++it)
+        {
+            rtree::apply_visitor(*this, *it->second);
+        }
+
+        m_current_level = current_level_backup;
+    }
+
+    inline void operator()(leaf const& n)
+    {
+        typedef typename rtree::elements_type<leaf>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        // empty leaf in non-root node
+        if ( ( m_current_level > 0 && elements.empty() )
+          || !check_count(elements) )
+        {
+            result = false;
+        }
+    }
+
+    bool result;
+
+private:
+    template <typename Elements>
+    bool check_count(Elements const& elements)
+    {
+        // root may contain count < min but should never contain count > max
+        return elements.size() <= m_parameters.get_max_elements()
+            && ( elements.size() >= m_parameters.get_min_elements()
+              || m_current_level == 0 );
+    }
+
+    size_t m_current_level;
+    parameters_type const& m_parameters;
+};
+
+} // namespace visitors
+
+template <typename Rtree> inline
+bool are_counts_ok(Rtree const& tree)
+{
+    typedef utilities::view<Rtree> RTV;
+    RTV rtv(tree);
+
+    visitors::are_counts_ok<
+        typename RTV::value_type,
+        typename RTV::options_type,
+        typename RTV::box_type,
+        typename RTV::allocators_type
+    > v(tree.parameters());
+    
+    rtv.apply_visitor(v);
+
+    return v.result;
+}
+
+}}}}}} // namespace boost::geometry::index::detail::rtree::utilities
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_ARE_COUNTS_OK_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/are_levels_ok.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/are_levels_ok.hpp
new file mode 100644
index 00000000000..4860dbcb9bb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/are_levels_ok.hpp
@@ -0,0 +1,109 @@
+// Boost.Geometry Index
+//
+// R-tree levels validating visitor implementation
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_ARE_LEVELS_OK_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_ARE_LEVELS_OK_HPP
+
+#include <boost/geometry/index/detail/rtree/node/node.hpp>
+
+namespace boost { namespace geometry { namespace index { namespace detail { namespace rtree { namespace utilities {
+
+namespace visitors {
+
+template <typename Value, typename Options, typename Box, typename Allocators>
+class are_levels_ok
+    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
+{
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+public:
+    inline are_levels_ok()
+        : result(true), m_leafs_level((std::numeric_limits<size_t>::max)()), m_current_level(0)
+    {}
+
+    inline void operator()(internal_node const& n)
+    {
+        typedef typename rtree::elements_type<internal_node>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        if (elements.empty())
+        {
+            result = false;
+            return;
+        }
+
+        size_t current_level_backup = m_current_level;
+        ++m_current_level;
+
+        for ( typename elements_type::const_iterator it = elements.begin();
+              it != elements.end() ; ++it)
+        {
+            rtree::apply_visitor(*this, *it->second);
+
+            if ( result == false )
+                return;
+        }
+
+        m_current_level = current_level_backup;
+    }
+
+    inline void operator()(leaf const& n)
+    {
+        typedef typename rtree::elements_type<leaf>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        // empty leaf in non-root node
+        if (0 < m_current_level && elements.empty())
+        {
+            result = false;
+            return;
+        }
+
+        if ( m_leafs_level == (std::numeric_limits<size_t>::max)() )
+        {
+            m_leafs_level = m_current_level;
+        }
+        else if ( m_leafs_level != m_current_level )
+        {
+            result = false;
+        }
+    }
+
+    bool result;
+
+private:
+    size_t m_leafs_level;
+    size_t m_current_level;
+};
+
+} // namespace visitors
+
+template <typename Rtree> inline
+bool are_levels_ok(Rtree const& tree)
+{
+    typedef utilities::view<Rtree> RTV;
+    RTV rtv(tree);
+
+    visitors::are_levels_ok<
+        typename RTV::value_type,
+        typename RTV::options_type,
+        typename RTV::box_type,
+        typename RTV::allocators_type
+    > v;
+    
+    rtv.apply_visitor(v);
+
+    return v.result;
+}
+
+}}}}}} // namespace boost::geometry::index::detail::rtree::utilities
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_ARE_LEVELS_OK_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/gl_draw.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/gl_draw.hpp
new file mode 100644
index 00000000000..84201b6afed
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/gl_draw.hpp
@@ -0,0 +1,243 @@
+// Boost.Geometry Index
+//
+// R-tree OpenGL drawing visitor implementation
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_GL_DRAW_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_GL_DRAW_HPP
+
+#include <boost/mpl/assert.hpp>
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+namespace utilities {
+
+namespace dispatch {
+
+template <typename Point, size_t Dimension>
+struct gl_draw_point
+{};
+
+template <typename Point>
+struct gl_draw_point<Point, 2>
+{
+    static inline void apply(Point const& p, typename coordinate_type<Point>::type z)
+    {
+        typename coordinate_type<Point>::type const& x = geometry::get<0>(p);
+        typename coordinate_type<Point>::type const& y = geometry::get<1>(p);
+        /*glBegin(GL_POINT);
+        glVertex3f(x, y, z);
+        glEnd();*/
+        glBegin(GL_QUADS);
+        glVertex3f(x+1, y, z);
+        glVertex3f(x, y+1, z);
+        glVertex3f(x-1, y, z);
+        glVertex3f(x, y-1, z);
+        glEnd();
+    }
+};
+
+template <typename Box, size_t Dimension>
+struct gl_draw_box
+{};
+
+template <typename Box>
+struct gl_draw_box<Box, 2>
+{
+    static inline void apply(Box const& b, typename coordinate_type<Box>::type z)
+    {
+        glBegin(GL_LINE_LOOP);
+        glVertex3f(geometry::get<min_corner, 0>(b), geometry::get<min_corner, 1>(b), z);
+        glVertex3f(geometry::get<max_corner, 0>(b), geometry::get<min_corner, 1>(b), z);
+        glVertex3f(geometry::get<max_corner, 0>(b), geometry::get<max_corner, 1>(b), z);
+        glVertex3f(geometry::get<min_corner, 0>(b), geometry::get<max_corner, 1>(b), z);
+        glEnd();
+    }
+};
+
+template <typename Segment, size_t Dimension>
+struct gl_draw_segment
+{};
+
+template <typename Segment>
+struct gl_draw_segment<Segment, 2>
+{
+    static inline void apply(Segment const& s, typename coordinate_type<Segment>::type z)
+    {
+        glBegin(GL_LINES);
+        glVertex3f(geometry::get<0, 0>(s), geometry::get<0, 1>(s), z);
+        glVertex3f(geometry::get<1, 0>(s), geometry::get<1, 1>(s), z);
+        glEnd();
+    }
+};
+
+template <typename Indexable, typename Tag>
+struct gl_draw_indexable
+{
+    BOOST_MPL_ASSERT_MSG((false), NOT_IMPLEMENTED_FOR_THIS_TAG, (Tag));
+};
+
+template <typename Box>
+struct gl_draw_indexable<Box, box_tag>
+    : gl_draw_box<Box, geometry::dimension<Box>::value>
+{};
+
+template <typename Point>
+struct gl_draw_indexable<Point, point_tag>
+    : gl_draw_point<Point, geometry::dimension<Point>::value>
+{};
+
+template <typename Segment>
+struct gl_draw_indexable<Segment, segment_tag>
+    : gl_draw_segment<Segment, geometry::dimension<Segment>::value>
+{};
+
+} // namespace dispatch
+
+template <typename Indexable> inline
+void gl_draw_indexable(Indexable const& i, typename coordinate_type<Indexable>::type z)
+{
+    dispatch::gl_draw_indexable<
+        Indexable,
+        typename tag<Indexable>::type
+    >::apply(i, z);
+}
+
+} // namespace utilities
+
+namespace rtree { namespace utilities {
+
+namespace visitors {
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+struct gl_draw : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
+{
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    inline gl_draw(Translator const& t,
+                   size_t level_first = 0,
+                   size_t level_last = (std::numeric_limits<size_t>::max)(),
+                   typename coordinate_type<Box>::type z_coord_level_multiplier = 1
+    )
+        : tr(t)
+        , level_f(level_first)
+        , level_l(level_last)
+        , z_mul(z_coord_level_multiplier)
+        , level(0)
+    {}
+
+    inline void operator()(internal_node const& n)
+    {
+        typedef typename rtree::elements_type<internal_node>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        if ( level_f <= level )
+        {
+            size_t level_rel = level - level_f;
+
+            if ( level_rel == 0 )
+                glColor3f(0.75f, 0.0f, 0.0f);
+            else if ( level_rel == 1 )
+                glColor3f(0.0f, 0.75f, 0.0f);
+            else if ( level_rel == 2 )
+                glColor3f(0.0f, 0.0f, 0.75f);
+            else if ( level_rel == 3 )
+                glColor3f(0.75f, 0.75f, 0.0f);
+            else if ( level_rel == 4 )
+                glColor3f(0.75f, 0.0f, 0.75f);
+            else if ( level_rel == 5 )
+                glColor3f(0.0f, 0.75f, 0.75f);
+            else
+                glColor3f(0.5f, 0.5f, 0.5f);
+
+            for (typename elements_type::const_iterator it = elements.begin();
+                it != elements.end(); ++it)
+            {
+                detail::utilities::gl_draw_indexable(it->first, level_rel * z_mul);
+            }
+        }
+        
+        size_t level_backup = level;
+        ++level;
+
+        if ( level < level_l )
+        {
+            for (typename elements_type::const_iterator it = elements.begin();
+                it != elements.end(); ++it)
+            {
+                rtree::apply_visitor(*this, *it->second);
+            }
+        }
+
+        level = level_backup;
+    }
+
+    inline void operator()(leaf const& n)
+    {
+        typedef typename rtree::elements_type<leaf>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        if ( level_f <= level )
+        {
+            size_t level_rel = level - level_f;
+
+            glColor3f(0.25f, 0.25f, 0.25f);
+
+            for (typename elements_type::const_iterator it = elements.begin();
+                it != elements.end(); ++it)
+            {
+                detail::utilities::gl_draw_indexable(tr(*it), level_rel * z_mul);
+            }
+        }
+    }
+
+    Translator const& tr;
+    size_t level_f;
+    size_t level_l;
+    typename coordinate_type<Box>::type z_mul;
+
+    size_t level;
+};
+
+} // namespace visitors
+
+template <typename Rtree> inline
+void gl_draw(Rtree const& tree,
+             size_t level_first = 0,
+             size_t level_last = (std::numeric_limits<size_t>::max)(),
+             typename coordinate_type<
+                    typename Rtree::bounds_type
+                >::type z_coord_level_multiplier = 1
+             )
+{
+    typedef utilities::view<Rtree> RTV;
+    RTV rtv(tree);
+
+    if ( !tree.empty() )
+    {
+        glColor3f(0.75f, 0.75f, 0.75f);
+        detail::utilities::gl_draw_indexable(tree.bounds(), 0);
+    }
+
+    visitors::gl_draw<
+        typename RTV::value_type,
+        typename RTV::options_type,
+        typename RTV::translator_type,
+        typename RTV::box_type,
+        typename RTV::allocators_type
+    > gl_draw_v(rtv.translator(), level_first, level_last, z_coord_level_multiplier);
+
+    rtv.apply_visitor(gl_draw_v);
+}
+
+}} // namespace rtree::utilities
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_GL_DRAW_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/print.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/print.hpp
new file mode 100644
index 00000000000..4c42659c643
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/print.hpp
@@ -0,0 +1,219 @@
+// Boost.Geometry Index
+//
+// R-tree ostreaming visitor implementation
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_PRINT_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_PRINT_HPP
+
+#include <iostream>
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+    
+namespace utilities {
+
+namespace dispatch {
+
+template <typename Point, size_t Dimension>
+struct print_point
+{
+    BOOST_STATIC_ASSERT(0 < Dimension);
+
+    static inline void apply(std::ostream & os, Point const& p)
+    {
+        print_point<Point, Dimension - 1>::apply(os, p);
+
+        os << ", " << geometry::get<Dimension - 1>(p);
+    }
+};
+
+template <typename Point>
+struct print_point<Point, 1>
+{
+    static inline void apply(std::ostream & os, Point const& p)
+    {
+        os << geometry::get<0>(p);
+    }
+};
+
+template <typename Box, size_t Corner, size_t Dimension>
+struct print_corner
+{
+    BOOST_STATIC_ASSERT(0 < Dimension);
+
+    static inline void apply(std::ostream & os, Box const& b)
+    {
+        print_corner<Box, Corner, Dimension - 1>::apply(os, b);
+
+        os << ", " << geometry::get<Corner, Dimension - 1>(b);
+    }
+};
+
+template <typename Box, size_t Corner>
+struct print_corner<Box, Corner, 1>
+{
+    static inline void apply(std::ostream & os, Box const& b)
+    {
+        os << geometry::get<Corner, 0>(b);
+    }
+};
+
+template <typename Indexable, typename Tag>
+struct print_indexable
+{
+    BOOST_MPL_ASSERT_MSG((false), NOT_IMPLEMENTED_FOR_THIS_TAG, (Tag));
+};
+
+template <typename Indexable>
+struct print_indexable<Indexable, box_tag>
+{
+    static const size_t dimension = geometry::dimension<Indexable>::value;
+
+    static inline void apply(std::ostream &os, Indexable const& i)
+    {
+        os << '(';
+        print_corner<Indexable, min_corner, dimension>::apply(os, i);
+        os << ")x(";
+        print_corner<Indexable, max_corner, dimension>::apply(os, i);
+        os << ')';
+    }
+};
+
+template <typename Indexable>
+struct print_indexable<Indexable, point_tag>
+{
+    static const size_t dimension = geometry::dimension<Indexable>::value;
+
+    static inline void apply(std::ostream &os, Indexable const& i)
+    {
+        os << '(';
+        print_point<Indexable, dimension>::apply(os, i);
+        os << ')';
+    }
+};
+
+template <typename Indexable>
+struct print_indexable<Indexable, segment_tag>
+{
+    static const size_t dimension = geometry::dimension<Indexable>::value;
+
+    static inline void apply(std::ostream &os, Indexable const& i)
+    {
+        os << '(';
+        print_corner<Indexable, 0, dimension>::apply(os, i);
+        os << ")-(";
+        print_corner<Indexable, 1, dimension>::apply(os, i);
+        os << ')';
+    }
+};
+
+} // namespace dispatch
+
+template <typename Indexable> inline
+void print_indexable(std::ostream & os, Indexable const& i)
+{
+    dispatch::print_indexable<
+        Indexable,
+        typename tag<Indexable>::type
+    >::apply(os, i);
+}
+
+} // namespace utilities
+
+namespace rtree { namespace utilities {
+
+namespace visitors {
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+struct print : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
+{
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    inline print(std::ostream & o, Translator const& t)
+        : os(o), tr(t), level(0)
+    {}
+
+    inline void operator()(internal_node const& n)
+    {
+        typedef typename rtree::elements_type<internal_node>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        spaces(level) << "INTERNAL NODE - L:" << level << " Ch:" << elements.size() << " @:" << &n << '\n';
+        
+        for (typename elements_type::const_iterator it = elements.begin();
+            it != elements.end(); ++it)
+        {
+            spaces(level);
+            detail::utilities::print_indexable(os, it->first);
+            os << " ->" << it->second << '\n';
+        }
+
+        size_t level_backup = level;
+        ++level;
+
+        for (typename elements_type::const_iterator it = elements.begin();
+            it != elements.end(); ++it)
+        {
+            rtree::apply_visitor(*this, *it->second);
+        }
+
+        level = level_backup;
+    }
+
+    inline void operator()(leaf const& n)
+    {
+        typedef typename rtree::elements_type<leaf>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        spaces(level) << "LEAF - L:" << level << " V:" << elements.size() << " @:" << &n << '\n';
+        for (typename elements_type::const_iterator it = elements.begin();
+            it != elements.end(); ++it)
+        {
+            spaces(level);
+            detail::utilities::print_indexable(os, tr(*it));
+            os << '\n';
+        }
+    }
+
+    inline std::ostream & spaces(size_t level)
+    {
+        for ( size_t i = 0 ; i < 2 * level ; ++i )
+            os << ' ';
+        return os;
+    }
+
+    std::ostream & os;
+    Translator const& tr;
+
+    size_t level;
+};
+
+} // namespace visitors
+
+template <typename Rtree> inline
+void print(std::ostream & os, Rtree const& tree)
+{
+    typedef utilities::view<Rtree> RTV;
+    RTV rtv(tree);
+
+    visitors::print<
+        typename RTV::value_type,
+        typename RTV::options_type,
+        typename RTV::translator_type,
+        typename RTV::box_type,
+        typename RTV::allocators_type
+    > print_v(os, rtv.translator());
+    rtv.apply_visitor(print_v);
+}
+
+}} // namespace rtree::utilities
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_PRINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/statistics.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/statistics.hpp
new file mode 100644
index 00000000000..bbaed8100e4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/statistics.hpp
@@ -0,0 +1,105 @@
+// Boost.Geometry Index
+//
+// R-tree visitor collecting basic statistics
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+// Copyright (c) 2013 Mateusz Loskot, London, UK.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_STATISTICS_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_STATISTICS_HPP
+
+#include <algorithm>
+#include <boost/tuple/tuple.hpp>
+
+namespace boost { namespace geometry { namespace index { namespace detail { namespace rtree { namespace utilities {
+
+namespace visitors {
+
+template <typename Value, typename Options, typename Box, typename Allocators>
+struct statistics : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
+{
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    inline statistics()
+        : level(0)
+        , levels(1) // count root
+        , nodes(0)
+        , leaves(0)
+        , values(0)
+        , values_min(0)
+        , values_max(0)
+    {}
+
+    inline void operator()(internal_node const& n)
+    {
+        typedef typename rtree::elements_type<internal_node>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+        
+        ++nodes; // count node
+
+        size_t const level_backup = level;
+        ++level;
+
+        levels += level++ > levels ? 1 : 0; // count level (root already counted)
+                
+        for (typename elements_type::const_iterator it = elements.begin();
+            it != elements.end(); ++it)
+        {
+            rtree::apply_visitor(*this, *it->second);
+        }
+        
+        level = level_backup;
+    }
+
+    inline void operator()(leaf const& n)
+    {   
+        typedef typename rtree::elements_type<leaf>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        ++leaves; // count leaves
+        
+        std::size_t const v = elements.size();
+        // count values spread per node and total
+        values_min = (std::min)(values_min == 0 ? v : values_min, v);
+        values_max = (std::max)(values_max, v);
+        values += v;
+    }
+    
+    std::size_t level;
+    std::size_t levels;
+    std::size_t nodes;
+    std::size_t leaves;
+    std::size_t values;
+    std::size_t values_min;
+    std::size_t values_max;
+};
+
+} // namespace visitors
+
+template <typename Rtree> inline
+boost::tuple<std::size_t, std::size_t, std::size_t, std::size_t, std::size_t, std::size_t>
+statistics(Rtree const& tree)
+{
+    typedef utilities::view<Rtree> RTV;
+    RTV rtv(tree);
+
+    visitors::statistics<
+        typename RTV::value_type,
+        typename RTV::options_type,
+        typename RTV::box_type,
+        typename RTV::allocators_type
+    > stats_v;
+
+    rtv.apply_visitor(stats_v);
+    
+    return boost::make_tuple(stats_v.levels, stats_v.nodes, stats_v.leaves, stats_v.values, stats_v.values_min, stats_v.values_max);
+}
+
+}}}}}} // namespace boost::geometry::index::detail::rtree::utilities
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_STATISTICS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/view.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/view.hpp
new file mode 100644
index 00000000000..6dbbd07bfe0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/utilities/view.hpp
@@ -0,0 +1,61 @@
+// Boost.Geometry Index
+//
+// Rtree utilities view
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_VIEW_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_VIEW_HPP
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree { namespace utilities {
+
+template <typename Rtree>
+class view
+{
+public:
+    typedef typename Rtree::size_type size_type;
+
+    typedef typename Rtree::translator_type translator_type;
+    typedef typename Rtree::value_type value_type;
+    typedef typename Rtree::options_type options_type;
+    typedef typename Rtree::box_type box_type;
+    typedef typename Rtree::allocators_type allocators_type;    
+
+    view(Rtree const& rt) : m_rtree(rt) {}
+
+    template <typename Visitor>
+    void apply_visitor(Visitor & vis) const
+    {
+        m_rtree.apply_visitor(vis);
+    }
+
+    // This will most certainly be removed in the future
+    translator_type translator() const
+    {
+        return m_rtree.translator();
+    }
+
+    // This will probably be removed in the future
+    size_type depth() const
+    {
+        return m_rtree.depth();
+    }
+
+private:
+    view(view const&);
+    view & operator=(view const&);
+
+    Rtree const& m_rtree;
+};
+
+}}} // namespace detail::rtree::utilities
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_UTILITIES_VIEW_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/children_box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/children_box.hpp
new file mode 100644
index 00000000000..6c1bafd3ded
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/children_box.hpp
@@ -0,0 +1,55 @@
+// Boost.Geometry Index
+//
+// R-tree node children box calculating visitor implementation
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_CHILDREN_BOX_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_CHILDREN_BOX_HPP
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree { namespace visitors {
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+class children_box
+    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
+{
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+public:
+    inline children_box(Box & result, Translator const& tr)
+        : m_result(result), m_tr(tr)
+    {}
+
+    inline void operator()(internal_node const& n)
+    {
+        typedef typename rtree::elements_type<internal_node>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        m_result = rtree::elements_box<Box>(elements.begin(), elements.end(), m_tr);
+    }
+
+    inline void operator()(leaf const& n)
+    {
+        typedef typename rtree::elements_type<leaf>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        m_result = rtree::values_box<Box>(elements.begin(), elements.end(), m_tr);
+    }
+
+private:
+    Box & m_result;
+    Translator const& m_tr;
+};
+
+}}} // namespace detail::rtree::visitors
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_CHILDREN_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/copy.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/copy.hpp
new file mode 100644
index 00000000000..86ffc99caf1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/copy.hpp
@@ -0,0 +1,92 @@
+// Boost.Geometry Index
+//
+// R-tree deep copying visitor implementation
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_COPY_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_COPY_HPP
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree { namespace visitors {
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+class copy
+    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, false>::type
+{
+public:
+    typedef typename rtree::node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef rtree::subtree_destroyer<Value, Options, Translator, Box, Allocators> subtree_destroyer;
+    typedef typename Allocators::node_pointer node_pointer;
+
+    explicit inline copy(Allocators & allocators)
+        : result(0)
+        , m_allocators(allocators)
+    {}
+
+    inline void operator()(internal_node & n)
+    {
+        node_pointer raw_new_node = rtree::create_node<Allocators, internal_node>::apply(m_allocators);      // MAY THROW, STRONG (N: alloc)
+        subtree_destroyer new_node(raw_new_node, m_allocators);
+
+        typedef typename rtree::elements_type<internal_node>::type elements_type;
+        elements_type & elements = rtree::elements(n);
+
+        elements_type & elements_dst = rtree::elements(rtree::get<internal_node>(*new_node));
+
+        for (typename elements_type::iterator it = elements.begin();
+            it != elements.end(); ++it)
+        {
+            rtree::apply_visitor(*this, *it->second);                                                   // MAY THROW (V, E: alloc, copy, N: alloc) 
+
+            // for exception safety
+            subtree_destroyer auto_result(result, m_allocators);
+
+            elements_dst.push_back( rtree::make_ptr_pair(it->first, result) );                          // MAY THROW, STRONG (E: alloc, copy)
+
+            auto_result.release();
+        }
+
+        result = new_node.get();
+        new_node.release();
+    }
+
+    inline void operator()(leaf & l)
+    {
+        node_pointer raw_new_node = rtree::create_node<Allocators, leaf>::apply(m_allocators);                // MAY THROW, STRONG (N: alloc)
+        subtree_destroyer new_node(raw_new_node, m_allocators);
+
+        typedef typename rtree::elements_type<leaf>::type elements_type;
+        elements_type & elements = rtree::elements(l);
+
+        elements_type & elements_dst = rtree::elements(rtree::get<leaf>(*new_node));
+
+        for (typename elements_type::iterator it = elements.begin();
+            it != elements.end(); ++it)
+        {
+            elements_dst.push_back(*it);                                                                // MAY THROW, STRONG (V: alloc, copy)
+        }
+
+        result = new_node.get();
+        new_node.release();
+    }
+
+    node_pointer result;
+
+private:
+    Allocators & m_allocators;
+};
+
+}}} // namespace detail::rtree::visitors
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_COPY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/count.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/count.hpp
new file mode 100644
index 00000000000..7efd5b70283
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/count.hpp
@@ -0,0 +1,107 @@
+// Boost.Geometry Index
+//
+// R-tree count visitor implementation
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_COUNT_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_COUNT_HPP
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree { namespace visitors {
+
+template <typename Indexable, typename Value>
+struct count_helper
+{
+    template <typename Translator>
+    static inline typename Translator::result_type indexable(Indexable const& i, Translator const&)
+    {
+        return i;
+    }
+    template <typename Translator>
+    static inline bool equals(Indexable const& i, Value const& v, Translator const& tr)
+    {
+        return geometry::equals(i, tr(v));
+    }
+};
+
+template <typename Value>
+struct count_helper<Value, Value>
+{
+    template <typename Translator>
+    static inline typename Translator::result_type indexable(Value const& v, Translator const& tr)
+    {
+        return tr(v);
+    }
+    template <typename Translator>
+    static inline bool equals(Value const& v1, Value const& v2, Translator const& tr)
+    {
+        return tr.equals(v1, v2);
+    }
+};
+
+template <typename ValueOrIndexable, typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+struct count
+    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
+{
+    typedef typename rtree::node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef count_helper<ValueOrIndexable, Value> count_help;
+
+    inline count(ValueOrIndexable const& vori, Translator const& t)
+        : value_or_indexable(vori), tr(t), found_count(0)
+    {}
+
+    inline void operator()(internal_node const& n)
+    {
+        typedef typename rtree::elements_type<internal_node>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        // traverse nodes meeting predicates
+        for (typename elements_type::const_iterator it = elements.begin();
+             it != elements.end(); ++it)
+        {
+            if ( geometry::covered_by(
+                    return_ref_or_bounds(
+                        count_help::indexable(value_or_indexable, tr)),
+                    it->first) )
+            {
+                rtree::apply_visitor(*this, *it->second);
+            }
+        }
+    }
+
+    inline void operator()(leaf const& n)
+    {
+        typedef typename rtree::elements_type<leaf>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        // get all values meeting predicates
+        for (typename elements_type::const_iterator it = elements.begin();
+             it != elements.end(); ++it)
+        {
+            // if value meets predicates
+            if ( count_help::equals(value_or_indexable, *it, tr) )
+            {
+                ++found_count;
+            }
+        }
+    }
+
+    ValueOrIndexable const& value_or_indexable;
+    Translator const& tr;
+    typename Allocators::size_type found_count;
+};
+
+}}} // namespace detail::rtree::visitors
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_COUNT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/destroy.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/destroy.hpp
new file mode 100644
index 00000000000..b4a800eac2f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/destroy.hpp
@@ -0,0 +1,71 @@
+// Boost.Geometry Index
+//
+// R-tree destroying visitor implementation
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_DELETE_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_DELETE_HPP
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree { namespace visitors {
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+class destroy
+    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, false>::type
+{
+public:
+    typedef typename rtree::node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef typename Allocators::node_pointer node_pointer;
+
+    inline destroy(node_pointer root_node, Allocators & allocators)
+        : m_current_node(root_node)
+        , m_allocators(allocators)
+    {}
+
+    inline void operator()(internal_node & n)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(&n == &rtree::get<internal_node>(*m_current_node), "invalid pointers");
+
+        node_pointer node_to_destroy = m_current_node;
+
+        typedef typename rtree::elements_type<internal_node>::type elements_type;
+        elements_type & elements = rtree::elements(n);
+
+        for (typename elements_type::iterator it = elements.begin();
+             it != elements.end(); ++it)
+        {
+            m_current_node = it->second;
+            rtree::apply_visitor(*this, *m_current_node);
+            it->second = 0;
+        }
+
+        rtree::destroy_node<Allocators, internal_node>::apply(m_allocators, node_to_destroy);
+    }
+
+    inline void operator()(leaf & l)
+    {
+        boost::ignore_unused(l);
+        BOOST_GEOMETRY_INDEX_ASSERT(&l == &rtree::get<leaf>(*m_current_node), "invalid pointers");
+
+        rtree::destroy_node<Allocators, leaf>::apply(m_allocators, m_current_node);
+    }
+
+private:
+    node_pointer m_current_node;
+    Allocators & m_allocators;
+};
+
+}}} // namespace detail::rtree::visitors
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_DELETE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/distance_query.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/distance_query.hpp
new file mode 100644
index 00000000000..b930714433f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/distance_query.hpp
@@ -0,0 +1,588 @@
+// Boost.Geometry Index
+//
+// R-tree distance (knn, path, etc. ) query visitor implementation
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_DISTANCE_QUERY_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_DISTANCE_QUERY_HPP
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree { namespace visitors {
+
+template <typename Value, typename Translator, typename DistanceType, typename OutIt>
+class distance_query_result
+{
+public:
+    typedef DistanceType distance_type;
+
+    inline explicit distance_query_result(size_t k, OutIt out_it)
+        : m_count(k), m_out_it(out_it)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(0 < m_count, "Number of neighbors should be greater than 0");
+
+        m_neighbors.reserve(m_count);
+    }
+
+    inline void store(Value const& val, distance_type const& curr_comp_dist)
+    {
+        if ( m_neighbors.size() < m_count )
+        {
+            m_neighbors.push_back(std::make_pair(curr_comp_dist, val));
+
+            if ( m_neighbors.size() == m_count )
+                std::make_heap(m_neighbors.begin(), m_neighbors.end(), neighbors_less);
+        }
+        else
+        {
+            if ( curr_comp_dist < m_neighbors.front().first )
+            {
+                std::pop_heap(m_neighbors.begin(), m_neighbors.end(), neighbors_less);
+                m_neighbors.back().first = curr_comp_dist;
+                m_neighbors.back().second = val;
+                std::push_heap(m_neighbors.begin(), m_neighbors.end(), neighbors_less);
+            }
+        }
+    }
+
+    inline bool has_enough_neighbors() const
+    {
+        return m_count <= m_neighbors.size();
+    }
+
+    inline distance_type greatest_comparable_distance() const
+    {
+        // greatest distance is in the first neighbor only
+        // if there is at least m_count values found
+        // this is just for safety reasons since is_comparable_distance_valid() is checked earlier
+        // TODO - may be replaced by ASSERT
+        return m_neighbors.size() < m_count
+            ? (std::numeric_limits<distance_type>::max)()
+            : m_neighbors.front().first;
+    }
+
+    inline size_t finish()
+    {
+        typedef typename std::vector< std::pair<distance_type, Value> >::const_iterator neighbors_iterator;
+        for ( neighbors_iterator it = m_neighbors.begin() ; it != m_neighbors.end() ; ++it, ++m_out_it )
+            *m_out_it = it->second;
+
+        return m_neighbors.size();
+    }
+
+private:
+    inline static bool neighbors_less(
+        std::pair<distance_type, Value> const& p1,
+        std::pair<distance_type, Value> const& p2)
+    {
+        return p1.first < p2.first;
+    }
+
+    size_t m_count;
+    OutIt m_out_it;
+
+    std::vector< std::pair<distance_type, Value> > m_neighbors;
+};
+
+template <
+    typename Value,
+    typename Options,
+    typename Translator,
+    typename Box,
+    typename Allocators,
+    typename Predicates,
+    unsigned DistancePredicateIndex,
+    typename OutIter
+>
+class distance_query
+    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
+{
+public:
+    typedef typename Options::parameters_type parameters_type;
+
+    typedef typename rtree::node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef index::detail::predicates_element<DistancePredicateIndex, Predicates> nearest_predicate_access;
+    typedef typename nearest_predicate_access::type nearest_predicate_type;
+    typedef typename indexable_type<Translator>::type indexable_type;
+
+    typedef index::detail::calculate_distance<nearest_predicate_type, indexable_type, value_tag> calculate_value_distance;
+    typedef index::detail::calculate_distance<nearest_predicate_type, Box, bounds_tag> calculate_node_distance;
+    typedef typename calculate_value_distance::result_type value_distance_type;
+    typedef typename calculate_node_distance::result_type node_distance_type;
+
+    static const unsigned predicates_len = index::detail::predicates_length<Predicates>::value;
+
+    inline distance_query(parameters_type const& parameters, Translator const& translator, Predicates const& pred, OutIter out_it)
+        : m_parameters(parameters), m_translator(translator)
+        , m_pred(pred)
+        , m_result(nearest_predicate_access::get(m_pred).count, out_it)
+    {}
+
+    inline void operator()(internal_node const& n)
+    {
+        typedef typename rtree::elements_type<internal_node>::type elements_type;
+
+        // array of active nodes
+        typedef typename index::detail::rtree::container_from_elements_type<
+            elements_type,
+            std::pair<node_distance_type, typename Allocators::node_pointer>
+        >::type active_branch_list_type;
+
+        active_branch_list_type active_branch_list;
+        active_branch_list.reserve(m_parameters.get_max_elements());
+        
+        elements_type const& elements = rtree::elements(n);
+
+        // fill array of nodes meeting predicates
+        for (typename elements_type::const_iterator it = elements.begin();
+            it != elements.end(); ++it)
+        {
+            // if current node meets predicates
+            // 0 - dummy value
+            if ( index::detail::predicates_check<index::detail::bounds_tag, 0, predicates_len>(m_pred, 0, it->first) )
+            {
+                // calculate node's distance(s) for distance predicate
+                node_distance_type node_distance;
+                // if distance isn't ok - move to the next node
+                if ( !calculate_node_distance::apply(predicate(), it->first, node_distance) )
+                {
+                    continue;
+                }
+
+                // if current node is further than found neighbors - don't analyze it
+                if ( m_result.has_enough_neighbors() &&
+                     is_node_prunable(m_result.greatest_comparable_distance(), node_distance) )
+                {
+                    continue;
+                }
+
+                // add current node's data into the list
+                active_branch_list.push_back( std::make_pair(node_distance, it->second) );
+            }
+        }
+
+        // if there aren't any nodes in ABL - return
+        if ( active_branch_list.empty() )
+            return;
+        
+        // sort array
+        std::sort(active_branch_list.begin(), active_branch_list.end(), abl_less);
+
+        // recursively visit nodes
+        for ( typename active_branch_list_type::const_iterator it = active_branch_list.begin();
+              it != active_branch_list.end() ; ++it )
+        {
+            // if current node is further than furthest neighbor, the rest of nodes also will be further
+            if ( m_result.has_enough_neighbors() &&
+                 is_node_prunable(m_result.greatest_comparable_distance(), it->first) )
+                break;
+
+            rtree::apply_visitor(*this, *(it->second));
+        }
+
+        // ALTERNATIVE VERSION - use heap instead of sorted container
+        // It seems to be faster for greater MaxElements and slower otherwise
+        // CONSIDER: using one global container/heap for active branches
+        //           instead of a sorted container per level
+        //           This would also change the way how branches are traversed!
+        //           The same may be applied to the iterative version which btw suffers
+        //           from the copying of the whole containers on resize of the ABLs container
+
+        //// make a heap
+        //std::make_heap(active_branch_list.begin(), active_branch_list.end(), abl_greater);
+
+        //// recursively visit nodes
+        //while ( !active_branch_list.empty() )
+        //{
+        //    //if current node is further than furthest neighbor, the rest of nodes also will be further
+        //    if ( m_result.has_enough_neighbors()
+        //      && is_node_prunable(m_result.greatest_comparable_distance(), active_branch_list.front().first) )
+        //    {
+        //        break;
+        //    }
+
+        //    rtree::apply_visitor(*this, *(active_branch_list.front().second));
+
+        //    std::pop_heap(active_branch_list.begin(), active_branch_list.end(), abl_greater);
+        //    active_branch_list.pop_back();
+        //}
+    }
+
+    inline void operator()(leaf const& n)
+    {
+        typedef typename rtree::elements_type<leaf>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+        
+        // search leaf for closest value meeting predicates
+        for (typename elements_type::const_iterator it = elements.begin();
+            it != elements.end(); ++it)
+        {
+            // if value meets predicates
+            if ( index::detail::predicates_check<index::detail::value_tag, 0, predicates_len>(m_pred, *it, m_translator(*it)) )
+            {
+                // calculate values distance for distance predicate
+                value_distance_type value_distance;
+                // if distance is ok
+                if ( calculate_value_distance::apply(predicate(), m_translator(*it), value_distance) )
+                {
+                    // store value
+                    m_result.store(*it, value_distance);
+                }
+            }
+        }
+    }
+
+    inline size_t finish()
+    {
+        return m_result.finish();
+    }
+
+private:
+    static inline bool abl_less(
+        std::pair<node_distance_type, typename Allocators::node_pointer> const& p1,
+        std::pair<node_distance_type, typename Allocators::node_pointer> const& p2)
+    {
+        return p1.first < p2.first;
+    }
+
+    //static inline bool abl_greater(
+    //    std::pair<node_distance_type, typename Allocators::node_pointer> const& p1,
+    //    std::pair<node_distance_type, typename Allocators::node_pointer> const& p2)
+    //{
+    //    return p1.first > p2.first;
+    //}
+
+    template <typename Distance>
+    static inline bool is_node_prunable(Distance const& greatest_dist, node_distance_type const& d)
+    {
+        return greatest_dist <= d;
+    }
+
+    nearest_predicate_type const& predicate() const
+    {
+        return nearest_predicate_access::get(m_pred);
+    }
+
+    parameters_type const& m_parameters;
+    Translator const& m_translator;
+
+    Predicates m_pred;
+    distance_query_result<Value, Translator, value_distance_type, OutIter> m_result;
+};
+
+template <
+    typename Value,
+    typename Options,
+    typename Translator,
+    typename Box,
+    typename Allocators,
+    typename Predicates,
+    unsigned DistancePredicateIndex
+>
+class distance_query_incremental
+    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
+{
+public:
+    typedef typename Options::parameters_type parameters_type;
+
+    typedef typename rtree::node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef index::detail::predicates_element<DistancePredicateIndex, Predicates> nearest_predicate_access;
+    typedef typename nearest_predicate_access::type nearest_predicate_type;
+    typedef typename indexable_type<Translator>::type indexable_type;
+    
+    typedef index::detail::calculate_distance<nearest_predicate_type, indexable_type, value_tag> calculate_value_distance;
+    typedef index::detail::calculate_distance<nearest_predicate_type, Box, bounds_tag> calculate_node_distance;
+    typedef typename calculate_value_distance::result_type value_distance_type;
+    typedef typename calculate_node_distance::result_type node_distance_type;
+
+    typedef typename Allocators::size_type size_type;
+    typedef typename Allocators::const_reference const_reference;
+    typedef typename Allocators::node_pointer node_pointer;
+
+    static const unsigned predicates_len = index::detail::predicates_length<Predicates>::value;
+
+    typedef typename rtree::elements_type<internal_node>::type internal_elements;
+    typedef typename internal_elements::const_iterator internal_iterator;
+    typedef typename rtree::elements_type<leaf>::type leaf_elements;
+
+    typedef std::pair<node_distance_type, node_pointer> branch_data;
+    typedef typename index::detail::rtree::container_from_elements_type<
+        internal_elements, branch_data
+    >::type active_branch_list_type;
+    struct internal_stack_element
+    {
+        internal_stack_element() : current_branch(0) {}
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+        // Required in c++03 for containers using Boost.Move
+        internal_stack_element & operator=(internal_stack_element const& o)
+        {
+            branches = o.branches;
+            current_branch = o.current_branch;
+            return *this;
+        }
+#endif
+        active_branch_list_type branches;
+        typename active_branch_list_type::size_type current_branch;
+    };
+    typedef std::vector<internal_stack_element> internal_stack_type;
+
+    inline distance_query_incremental()
+        : m_translator(NULL)
+//        , m_pred()
+        , current_neighbor((std::numeric_limits<size_type>::max)())
+//        , next_closest_node_distance((std::numeric_limits<node_distance_type>::max)())
+    {}
+
+    inline distance_query_incremental(Translator const& translator, Predicates const& pred)
+        : m_translator(::boost::addressof(translator))
+        , m_pred(pred)
+        , current_neighbor((std::numeric_limits<size_type>::max)())
+
+        , next_closest_node_distance((std::numeric_limits<node_distance_type>::max)())
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(0 < max_count(), "k must be greather than 0");
+    }
+
+    const_reference dereference() const
+    {
+        return *(neighbors[current_neighbor].second);
+    }
+
+    void initialize(node_pointer root)
+    {
+        rtree::apply_visitor(*this, *root);
+        increment();
+    }
+
+    void increment()
+    {
+        for (;;)
+        {
+            size_type new_neighbor = current_neighbor == (std::numeric_limits<size_type>::max)() ? 0 : current_neighbor + 1;
+
+            if ( internal_stack.empty() )
+            {
+                if ( new_neighbor < neighbors.size() )
+                    current_neighbor = new_neighbor;
+                else
+                {
+                    current_neighbor = (std::numeric_limits<size_type>::max)();
+                    // clear() is used to disable the condition above
+                    neighbors.clear();
+                }
+
+                return;
+            }
+            else
+            {
+                active_branch_list_type & branches = internal_stack.back().branches;
+                typename active_branch_list_type::size_type & current_branch = internal_stack.back().current_branch;
+
+                if ( branches.size() <= current_branch )
+                {
+                    internal_stack.pop_back();
+                    continue;
+                }
+
+                // if there are no nodes which can have closer values, set new value
+                if ( new_neighbor < neighbors.size() &&
+                     // here must be < because otherwise neighbours may be sorted in different order
+                     // if there is another value with equal distance
+                     neighbors[new_neighbor].first < next_closest_node_distance )
+                {
+                    current_neighbor = new_neighbor;
+                    return;
+                }
+
+                // if node is further than the furthest neighbour, following nodes also will be further
+                BOOST_GEOMETRY_INDEX_ASSERT(neighbors.size() <= max_count(), "unexpected neighbours count");
+                if ( max_count() <= neighbors.size() &&
+                     is_node_prunable(neighbors.back().first, branches[current_branch].first) )
+                {
+                    // stop traversing current level
+                    internal_stack.pop_back();
+                    continue;
+                }
+                else
+                {
+                    // new level - must increment current_branch before traversing of another level (mem reallocation)
+                    ++current_branch;
+                    rtree::apply_visitor(*this, *(branches[current_branch - 1].second));
+
+                    next_closest_node_distance = calc_closest_node_distance(internal_stack.begin(), internal_stack.end());
+                }
+            }
+        }
+    }
+
+    bool is_end() const
+    {
+        return (std::numeric_limits<size_type>::max)() == current_neighbor;
+    }
+
+    friend bool operator==(distance_query_incremental const& l, distance_query_incremental const& r)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(l.current_neighbor != r.current_neighbor ||
+                                    (std::numeric_limits<size_type>::max)() == l.current_neighbor ||
+                                    (std::numeric_limits<size_type>::max)() == r.current_neighbor ||
+                                    l.neighbors[l.current_neighbor].second == r.neighbors[r.current_neighbor].second,
+                                    "not corresponding iterators");
+        return l.current_neighbor == r.current_neighbor;
+    }
+
+    // Put node's elements into the list of active branches if those elements meets predicates
+    // and distance predicates(currently not used)
+    // and aren't further than found neighbours (if there is enough neighbours)
+    inline void operator()(internal_node const& n)
+    {
+        typedef typename rtree::elements_type<internal_node>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        // add new element
+        internal_stack.resize(internal_stack.size()+1);
+
+        // fill active branch list array of nodes meeting predicates
+        for ( typename elements_type::const_iterator it = elements.begin() ; it != elements.end() ; ++it )
+        {
+            // if current node meets predicates
+            // 0 - dummy value
+            if ( index::detail::predicates_check<index::detail::bounds_tag, 0, predicates_len>(m_pred, 0, it->first) )
+            {
+                // calculate node's distance(s) for distance predicate
+                node_distance_type node_distance;
+                // if distance isn't ok - move to the next node
+                if ( !calculate_node_distance::apply(predicate(), it->first, node_distance) )
+                {
+                    continue;
+                }
+
+                // if current node is further than found neighbors - don't analyze it
+                if ( max_count() <= neighbors.size() &&
+                     is_node_prunable(neighbors.back().first, node_distance) )
+                {
+                    continue;
+                }
+
+                // add current node's data into the list
+                internal_stack.back().branches.push_back( std::make_pair(node_distance, it->second) );
+            }
+        }
+
+        if ( internal_stack.back().branches.empty() )
+            internal_stack.pop_back();
+        else
+            // sort array
+            std::sort(internal_stack.back().branches.begin(), internal_stack.back().branches.end(), abl_less);
+    }
+
+    // Put values into the list of neighbours if those values meets predicates
+    // and distance predicates(currently not used)
+    // and aren't further than already found neighbours (if there is enough neighbours)
+    inline void operator()(leaf const& n)
+    {
+        typedef typename rtree::elements_type<leaf>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        // store distance to the furthest neighbour
+        bool not_enough_neighbors = neighbors.size() < max_count();
+        value_distance_type greatest_distance = !not_enough_neighbors ? neighbors.back().first : (std::numeric_limits<value_distance_type>::max)();
+        
+        // search leaf for closest value meeting predicates
+        for ( typename elements_type::const_iterator it = elements.begin() ; it != elements.end() ; ++it)
+        {
+            // if value meets predicates
+            if ( index::detail::predicates_check<index::detail::value_tag, 0, predicates_len>(m_pred, *it, (*m_translator)(*it)) )
+            {
+                // calculate values distance for distance predicate
+                value_distance_type value_distance;
+                // if distance is ok
+                if ( calculate_value_distance::apply(predicate(), (*m_translator)(*it), value_distance) )
+                {
+                    // if there is not enough values or current value is closer than furthest neighbour
+                    if ( not_enough_neighbors || value_distance < greatest_distance )
+                    {
+                        neighbors.push_back(std::make_pair(value_distance, boost::addressof(*it)));
+                    }
+                }
+            }
+        }
+
+        // sort array
+        std::sort(neighbors.begin(), neighbors.end(), neighbors_less);
+        // remove furthest values
+        if ( max_count() < neighbors.size() )
+            neighbors.resize(max_count());
+    }
+
+private:
+    static inline bool abl_less(std::pair<node_distance_type, typename Allocators::node_pointer> const& p1,
+                                std::pair<node_distance_type, typename Allocators::node_pointer> const& p2)
+    {
+        return p1.first < p2.first;
+    }
+
+    static inline bool neighbors_less(std::pair<value_distance_type, const Value *> const& p1,
+                                      std::pair<value_distance_type, const Value *> const& p2)
+    {
+        return p1.first < p2.first;
+    }
+
+    node_distance_type
+    calc_closest_node_distance(typename internal_stack_type::const_iterator first,
+                               typename internal_stack_type::const_iterator last)
+    {
+        node_distance_type result = (std::numeric_limits<node_distance_type>::max)();
+        for ( ; first != last ; ++first )
+        {
+            if ( first->branches.size() <= first->current_branch )
+                continue;
+
+            node_distance_type curr_dist = first->branches[first->current_branch].first;
+            if ( curr_dist < result )
+                result = curr_dist;
+        }
+        return result;
+    }
+
+    template <typename Distance>
+    static inline bool is_node_prunable(Distance const& greatest_dist, node_distance_type const& d)
+    {
+        return greatest_dist <= d;
+    }
+
+    inline unsigned max_count() const
+    {
+        return nearest_predicate_access::get(m_pred).count;
+    }
+
+    nearest_predicate_type const& predicate() const
+    {
+        return nearest_predicate_access::get(m_pred);
+    }
+
+    const Translator * m_translator;
+
+    Predicates m_pred;
+
+    internal_stack_type internal_stack;
+    std::vector< std::pair<value_distance_type, const Value *> > neighbors;
+    size_type current_neighbor;
+    node_distance_type next_closest_node_distance;
+};
+
+}}} // namespace detail::rtree::visitors
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_DISTANCE_QUERY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/insert.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/insert.hpp
new file mode 100644
index 00000000000..87d5bbbcca9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/insert.hpp
@@ -0,0 +1,573 @@
+// Boost.Geometry Index
+//
+// R-tree inserting visitor implementation
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_INSERT_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_INSERT_HPP
+
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/geometry/algorithms/detail/expand_by_epsilon.hpp>
+#include <boost/geometry/util/condition.hpp>
+
+#include <boost/geometry/index/detail/algorithms/content.hpp>
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree {
+
+// Default choose_next_node
+template <typename Value, typename Options, typename Box, typename Allocators, typename ChooseNextNodeTag>
+class choose_next_node;
+
+template <typename Value, typename Options, typename Box, typename Allocators>
+class choose_next_node<Value, Options, Box, Allocators, choose_by_content_diff_tag>
+{
+public:
+    typedef typename Options::parameters_type parameters_type;
+
+    typedef typename rtree::node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef typename rtree::elements_type<internal_node>::type children_type;
+
+    typedef typename index::detail::default_content_result<Box>::type content_type;
+
+    template <typename Indexable>
+    static inline size_t apply(internal_node & n,
+                               Indexable const& indexable,
+                               parameters_type const& /*parameters*/,
+                               size_t /*node_relative_level*/)
+    {
+        children_type & children = rtree::elements(n);
+
+        BOOST_GEOMETRY_INDEX_ASSERT(!children.empty(), "can't choose the next node if children are empty");
+
+        size_t children_count = children.size();
+
+        // choose index with smallest content change or smallest content
+        size_t choosen_index = 0;
+        content_type smallest_content_diff = (std::numeric_limits<content_type>::max)();
+        content_type smallest_content = (std::numeric_limits<content_type>::max)();
+
+        // caculate areas and areas of all nodes' boxes
+        for ( size_t i = 0 ; i < children_count ; ++i )
+        {
+            typedef typename children_type::value_type child_type;
+            child_type const& ch_i = children[i];
+
+            // expanded child node's box
+            Box box_exp(ch_i.first);
+            geometry::expand(box_exp, indexable);
+
+            // areas difference
+            content_type content = index::detail::content(box_exp);
+            content_type content_diff = content - index::detail::content(ch_i.first);
+
+            // update the result
+            if ( content_diff < smallest_content_diff ||
+                ( content_diff == smallest_content_diff && content < smallest_content ) )
+            {
+                smallest_content_diff = content_diff;
+                smallest_content = content;
+                choosen_index = i;
+            }
+        }
+
+        return choosen_index;
+    }
+};
+
+// ----------------------------------------------------------------------- //
+
+// Not implemented here
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators, typename RedistributeTag>
+struct redistribute_elements
+{
+    BOOST_MPL_ASSERT_MSG(
+        (false),
+        NOT_IMPLEMENTED_FOR_THIS_REDISTRIBUTE_TAG_TYPE,
+        (redistribute_elements));
+};
+
+// ----------------------------------------------------------------------- //
+
+// Split algorithm
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators, typename SplitTag>
+class split
+{
+    BOOST_MPL_ASSERT_MSG(
+        (false),
+        NOT_IMPLEMENTED_FOR_THIS_SPLIT_TAG_TYPE,
+        (split));
+};
+
+// Default split algorithm
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+class split<Value, Options, Translator, Box, Allocators, split_default_tag>
+{
+protected:
+    typedef typename Options::parameters_type parameters_type;
+
+    typedef typename rtree::node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef rtree::subtree_destroyer<Value, Options, Translator, Box, Allocators> subtree_destroyer;
+
+public:
+    typedef index::detail::varray<
+        typename rtree::elements_type<internal_node>::type::value_type,
+        1
+    > nodes_container_type;
+
+    template <typename Node>
+    static inline void apply(nodes_container_type & additional_nodes,
+                             Node & n,
+                             Box & n_box,
+                             parameters_type const& parameters,
+                             Translator const& translator,
+                             Allocators & allocators)
+    {
+        // TODO - consider creating nodes always with sufficient memory allocated
+
+        // create additional node, use auto destroyer for automatic destruction on exception
+        subtree_destroyer second_node(rtree::create_node<Allocators, Node>::apply(allocators), allocators);     // MAY THROW, STRONG (N: alloc)
+        // create reference to the newly created node
+        Node & n2 = rtree::get<Node>(*second_node);
+
+        // NOTE: thread-safety
+        // After throwing an exception by redistribute_elements the original node may be not changed or
+        // both nodes may be empty. In both cases the tree won't be valid r-tree.
+        // The alternative is to create 2 (or more) additional nodes here and store backup info
+        // in the original node, then, if exception was thrown, the node would always have more than max
+        // elements.
+        // The alternative is to use moving semantics in the implementations of redistribute_elements,
+        // it will be possible to throw from boost::move() in the case of e.g. static size nodes.
+
+        // redistribute elements
+        Box box2;
+        redistribute_elements<
+            Value,
+            Options,
+            Translator,
+            Box,
+            Allocators,
+            typename Options::redistribute_tag
+        >::apply(n, n2, n_box, box2, parameters, translator, allocators);                                   // MAY THROW (V, E: alloc, copy, copy)
+
+        // check numbers of elements
+        BOOST_GEOMETRY_INDEX_ASSERT(parameters.get_min_elements() <= rtree::elements(n).size() &&
+            rtree::elements(n).size() <= parameters.get_max_elements(),
+            "unexpected number of elements");
+        BOOST_GEOMETRY_INDEX_ASSERT(parameters.get_min_elements() <= rtree::elements(n2).size() &&
+            rtree::elements(n2).size() <= parameters.get_max_elements(),
+            "unexpected number of elements");
+
+        // return the list of newly created nodes (this algorithm returns one)
+        additional_nodes.push_back(rtree::make_ptr_pair(box2, second_node.get()));                           // MAY THROW, STRONG (alloc, copy)
+
+        // release the ptr
+        second_node.release();
+    }
+};
+
+// ----------------------------------------------------------------------- //
+
+namespace visitors { namespace detail {
+
+template <typename InternalNode, typename InternalNodePtr, typename SizeType>
+struct insert_traverse_data
+{
+    typedef typename rtree::elements_type<InternalNode>::type elements_type;
+    typedef typename elements_type::value_type element_type;
+    typedef typename elements_type::size_type elements_size_type;
+    typedef SizeType size_type;
+
+    insert_traverse_data()
+        : parent(0), current_child_index(0), current_level(0)
+    {}
+
+    void move_to_next_level(InternalNodePtr new_parent,
+                            elements_size_type new_child_index)
+    {
+        parent = new_parent;
+        current_child_index = new_child_index;
+        ++current_level;
+    }
+
+    bool current_is_root() const
+    {
+        return 0 == parent;
+    }
+
+    elements_type & parent_elements() const
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(parent, "null pointer");
+        return rtree::elements(*parent);
+    }
+
+    element_type & current_element() const
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(parent, "null pointer");
+        return rtree::elements(*parent)[current_child_index];
+    }
+
+    InternalNodePtr parent;
+    elements_size_type current_child_index;
+    size_type current_level;
+};
+
+// Default insert visitor
+template <typename Element, typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+class insert
+    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, false>::type
+{
+protected:
+    typedef typename Options::parameters_type parameters_type;
+
+    typedef typename rtree::node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef rtree::subtree_destroyer<Value, Options, Translator, Box, Allocators> subtree_destroyer;
+    typedef typename Allocators::node_pointer node_pointer;
+    typedef typename Allocators::size_type size_type;
+
+    //typedef typename Allocators::internal_node_pointer internal_node_pointer;
+    typedef internal_node * internal_node_pointer;
+
+    inline insert(node_pointer & root,
+                  size_type & leafs_level,
+                  Element const& element,
+                  parameters_type const& parameters,
+                  Translator const& translator,
+                  Allocators & allocators,
+                  size_type relative_level = 0
+    )
+        : m_element(element)
+        , m_parameters(parameters)
+        , m_translator(translator)
+        , m_relative_level(relative_level)
+        , m_level(leafs_level - relative_level)
+        , m_root_node(root)
+        , m_leafs_level(leafs_level)
+        , m_traverse_data()
+        , m_allocators(allocators)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(m_relative_level <= leafs_level, "unexpected level value");
+        BOOST_GEOMETRY_INDEX_ASSERT(m_level <= m_leafs_level, "unexpected level value");
+        BOOST_GEOMETRY_INDEX_ASSERT(0 != m_root_node, "there is no root node");
+        // TODO
+        // assert - check if Box is correct
+
+        // When a value is inserted, during the tree traversal bounds of nodes
+        // on a path from the root to a leaf must be expanded. So prepare
+        // a bounding object at the beginning to not do it later for each node.
+        // NOTE: This is actually only needed because conditionally the bounding
+        //       object may be expanded below. Otherwise the indexable could be
+        //       directly used instead
+        index::detail::bounds(rtree::element_indexable(m_element, m_translator), m_element_bounds);
+
+#ifdef BOOST_GEOMETRY_INDEX_EXPERIMENTAL_ENLARGE_BY_EPSILON
+        // Enlarge it in case if it's not bounding geometry type.
+        // It's because Points and Segments are compared WRT machine epsilon
+        // This ensures that leafs bounds correspond to the stored elements
+        if (BOOST_GEOMETRY_CONDITION((
+                boost::is_same<Element, Value>::value
+             && ! index::detail::is_bounding_geometry
+                    <
+                        typename indexable_type<Translator>::type
+                    >::value )) )
+        {
+            geometry::detail::expand_by_epsilon(m_element_bounds);
+        }
+#endif
+    }
+
+    template <typename Visitor>
+    inline void traverse(Visitor & visitor, internal_node & n)
+    {
+        // choose next node
+        size_t choosen_node_index = rtree::choose_next_node<Value, Options, Box, Allocators, typename Options::choose_next_node_tag>::
+            apply(n, rtree::element_indexable(m_element, m_translator), m_parameters, m_leafs_level - m_traverse_data.current_level);
+
+        // expand the node to contain value
+        geometry::expand(
+            rtree::elements(n)[choosen_node_index].first,
+            m_element_bounds
+            /*rtree::element_indexable(m_element, m_translator)*/);
+
+        // next traversing step
+        traverse_apply_visitor(visitor, n, choosen_node_index);                                                 // MAY THROW (V, E: alloc, copy, N:alloc)
+    }
+
+    // TODO: awulkiew - change post_traverse name to handle_overflow or overflow_treatment?
+
+    template <typename Node>
+    inline void post_traverse(Node &n)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(m_traverse_data.current_is_root() ||
+                                    &n == &rtree::get<Node>(*m_traverse_data.current_element().second),
+                                    "if node isn't the root current_child_index should be valid");
+
+        // handle overflow
+        if ( m_parameters.get_max_elements() < rtree::elements(n).size() )
+        {
+            // NOTE: If the exception is thrown current node may contain more than MAX elements or be empty.
+            // Furthermore it may be empty root - internal node.
+            split(n);                                                                                           // MAY THROW (V, E: alloc, copy, N:alloc)
+        }
+    }
+
+    template <typename Visitor>
+    inline void traverse_apply_visitor(Visitor & visitor, internal_node &n, size_t choosen_node_index)
+    {
+        // save previous traverse inputs and set new ones
+        insert_traverse_data<internal_node, internal_node_pointer, size_type>
+            backup_traverse_data = m_traverse_data;
+
+        // calculate new traverse inputs
+        m_traverse_data.move_to_next_level(&n, choosen_node_index);
+
+        // next traversing step
+        rtree::apply_visitor(visitor, *rtree::elements(n)[choosen_node_index].second);                          // MAY THROW (V, E: alloc, copy, N:alloc)
+
+        // restore previous traverse inputs
+        m_traverse_data = backup_traverse_data;
+    }
+
+    // TODO: consider - split result returned as OutIter is faster than reference to the container. Why?
+
+    template <typename Node>
+    inline void split(Node & n) const
+    {
+        typedef rtree::split<Value, Options, Translator, Box, Allocators, typename Options::split_tag> split_algo;
+
+        typename split_algo::nodes_container_type additional_nodes;
+        Box n_box;
+
+        split_algo::apply(additional_nodes, n, n_box, m_parameters, m_translator, m_allocators);                // MAY THROW (V, E: alloc, copy, N:alloc)
+
+        BOOST_GEOMETRY_INDEX_ASSERT(additional_nodes.size() == 1, "unexpected number of additional nodes");
+
+        // TODO add all additional nodes
+        // For kmeans algorithm:
+        // elements number may be greater than node max elements count
+        // split and reinsert must take node with some elements count
+        // and container of additional elements (std::pair<Box, node*>s or Values)
+        // and translator + allocators
+        // where node_elements_count + additional_elements > node_max_elements_count
+        // What with elements other than std::pair<Box, node*> ?
+        // Implement template <node_tag> struct node_element_type or something like that
+
+        // for exception safety
+        subtree_destroyer additional_node_ptr(additional_nodes[0].second, m_allocators);
+
+#ifdef BOOST_GEOMETRY_INDEX_EXPERIMENTAL_ENLARGE_BY_EPSILON
+        // Enlarge bounds of a leaf node.
+        // It's because Points and Segments are compared WRT machine epsilon
+        // This ensures that leafs' bounds correspond to the stored elements.
+        if (BOOST_GEOMETRY_CONDITION((
+                boost::is_same<Node, leaf>::value
+             && ! index::detail::is_bounding_geometry
+                    <
+                        typename indexable_type<Translator>::type
+                    >::value )))
+        {
+            geometry::detail::expand_by_epsilon(n_box);
+            geometry::detail::expand_by_epsilon(additional_nodes[0].first);
+        }
+#endif
+
+        // node is not the root - just add the new node
+        if ( !m_traverse_data.current_is_root() )
+        {
+            // update old node's box
+            m_traverse_data.current_element().first = n_box;
+            // add new node to parent's children
+            m_traverse_data.parent_elements().push_back(additional_nodes[0]);                                     // MAY THROW, STRONG (V, E: alloc, copy)
+        }
+        // node is the root - add level
+        else
+        {
+            BOOST_GEOMETRY_INDEX_ASSERT(&n == &rtree::get<Node>(*m_root_node), "node should be the root");
+
+            // create new root and add nodes
+            subtree_destroyer new_root(rtree::create_node<Allocators, internal_node>::apply(m_allocators), m_allocators); // MAY THROW, STRONG (N:alloc)
+
+            BOOST_TRY
+            {
+                rtree::elements(rtree::get<internal_node>(*new_root)).push_back(rtree::make_ptr_pair(n_box, m_root_node));  // MAY THROW, STRONG (E:alloc, copy)
+                rtree::elements(rtree::get<internal_node>(*new_root)).push_back(additional_nodes[0]);                 // MAY THROW, STRONG (E:alloc, copy)
+            }
+            BOOST_CATCH(...)
+            {
+                // clear new root to not delete in the ~subtree_destroyer() potentially stored old root node
+                rtree::elements(rtree::get<internal_node>(*new_root)).clear();
+                BOOST_RETHROW                                                                                           // RETHROW
+            }
+            BOOST_CATCH_END
+
+            m_root_node = new_root.get();
+            ++m_leafs_level;
+
+            new_root.release();
+        }
+
+        additional_node_ptr.release();
+    }
+
+    // TODO: awulkiew - implement dispatchable split::apply to enable additional nodes creation
+
+    Element const& m_element;
+    Box m_element_bounds;
+    parameters_type const& m_parameters;
+    Translator const& m_translator;
+    size_type const m_relative_level;
+    size_type const m_level;
+
+    node_pointer & m_root_node;
+    size_type & m_leafs_level;
+
+    // traversing input parameters
+    insert_traverse_data<internal_node, internal_node_pointer, size_type> m_traverse_data;
+
+    Allocators & m_allocators;
+};
+
+} // namespace detail
+
+// Insert visitor forward declaration
+template <typename Element, typename Value, typename Options, typename Translator, typename Box, typename Allocators, typename InsertTag>
+class insert;
+
+// Default insert visitor used for nodes elements
+// After passing the Element to insert visitor the Element is managed by the tree
+// I.e. one should not delete the node passed to the insert visitor after exception is thrown
+// because this visitor may delete it
+template <typename Element, typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+class insert<Element, Value, Options, Translator, Box, Allocators, insert_default_tag>
+    : public detail::insert<Element, Value, Options, Translator, Box, Allocators>
+{
+public:
+    typedef detail::insert<Element, Value, Options, Translator, Box, Allocators> base;
+    typedef typename base::node node;
+    typedef typename base::internal_node internal_node;
+    typedef typename base::leaf leaf;
+
+    typedef typename Options::parameters_type parameters_type;
+    typedef typename base::node_pointer node_pointer;
+    typedef typename base::size_type size_type;
+
+    inline insert(node_pointer & root,
+                  size_type & leafs_level,
+                  Element const& element,
+                  parameters_type const& parameters,
+                  Translator const& translator,
+                  Allocators & allocators,
+                  size_type relative_level = 0
+    )
+        : base(root, leafs_level, element, parameters, translator, allocators, relative_level)
+    {}
+
+    inline void operator()(internal_node & n)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(base::m_traverse_data.current_level < base::m_leafs_level, "unexpected level");
+
+        if ( base::m_traverse_data.current_level < base::m_level )
+        {
+            // next traversing step
+            base::traverse(*this, n);                                                                           // MAY THROW (E: alloc, copy, N: alloc)
+        }
+        else
+        {
+            BOOST_GEOMETRY_INDEX_ASSERT(base::m_level == base::m_traverse_data.current_level, "unexpected level");
+
+            BOOST_TRY
+            {
+                // push new child node
+                rtree::elements(n).push_back(base::m_element);                                                  // MAY THROW, STRONG (E: alloc, copy)
+            }
+            BOOST_CATCH(...)
+            {
+                // if the insert fails above, the element won't be stored in the tree
+
+                rtree::visitors::destroy<Value, Options, Translator, Box, Allocators> del_v(base::m_element.second, base::m_allocators);
+                rtree::apply_visitor(del_v, *base::m_element.second);
+
+                BOOST_RETHROW                                                                                     // RETHROW
+            }
+            BOOST_CATCH_END
+        }
+
+        base::post_traverse(n);                                                                                 // MAY THROW (E: alloc, copy, N: alloc)
+    }
+
+    inline void operator()(leaf &)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(false, "this visitor can't be used for a leaf");
+    }
+};
+
+// Default insert visitor specialized for Values elements
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+class insert<Value, Value, Options, Translator, Box, Allocators, insert_default_tag>
+    : public detail::insert<Value, Value, Options, Translator, Box, Allocators>
+{
+public:
+    typedef detail::insert<Value, Value, Options, Translator, Box, Allocators> base;
+    typedef typename base::node node;
+    typedef typename base::internal_node internal_node;
+    typedef typename base::leaf leaf;
+
+    typedef typename Options::parameters_type parameters_type;
+    typedef typename base::node_pointer node_pointer;
+    typedef typename base::size_type size_type;
+
+    inline insert(node_pointer & root,
+                  size_type & leafs_level,
+                  Value const& value,
+                  parameters_type const& parameters,
+                  Translator const& translator,
+                  Allocators & allocators,
+                  size_type relative_level = 0
+    )
+        : base(root, leafs_level, value, parameters, translator, allocators, relative_level)
+    {}
+
+    inline void operator()(internal_node & n)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(base::m_traverse_data.current_level < base::m_leafs_level, "unexpected level");
+        BOOST_GEOMETRY_INDEX_ASSERT(base::m_traverse_data.current_level < base::m_level, "unexpected level");
+
+        // next traversing step
+        base::traverse(*this, n);                                                                                   // MAY THROW (V, E: alloc, copy, N: alloc)
+
+        base::post_traverse(n);                                                                                     // MAY THROW (E: alloc, copy, N: alloc)
+    }
+
+    inline void operator()(leaf & n)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(base::m_traverse_data.current_level == base::m_leafs_level, "unexpected level");
+        BOOST_GEOMETRY_INDEX_ASSERT(base::m_level == base::m_traverse_data.current_level ||
+                                    base::m_level == (std::numeric_limits<size_t>::max)(), "unexpected level");
+        
+        rtree::elements(n).push_back(base::m_element);                                                              // MAY THROW, STRONG (V: alloc, copy)
+
+        base::post_traverse(n);                                                                                     // MAY THROW (V: alloc, copy, N: alloc)
+    }
+};
+
+}}} // namespace detail::rtree::visitors
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_INSERT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/is_leaf.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/is_leaf.hpp
new file mode 100644
index 00000000000..dd2159c71e6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/is_leaf.hpp
@@ -0,0 +1,45 @@
+// Boost.Geometry Index
+//
+// R-tree leaf node checking visitor implementation
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_IS_LEAF_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_IS_LEAF_HPP
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree { namespace visitors {
+
+template <typename Value, typename Options, typename Box, typename Allocators>
+struct is_leaf : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
+{
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    is_leaf()
+        : result(false)
+    {}
+
+    inline void operator()(internal_node const&)
+    {
+        // result = false;
+    }
+
+    inline void operator()(leaf const&)
+    {
+        result = true;
+    }
+
+    bool result;
+};
+
+}}} // namespace detail::rtree::visitors
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_IS_LEAF_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/iterator.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/iterator.hpp
new file mode 100644
index 00000000000..621231ae9a9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/iterator.hpp
@@ -0,0 +1,134 @@
+// Boost.Geometry Index
+//
+// R-tree iterator visitor implementation
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_ITERATOR_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_ITERATOR_HPP
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree { namespace visitors {
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+class iterator
+    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
+{
+public:
+    typedef typename rtree::node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef typename Allocators::size_type size_type;
+    typedef typename Allocators::const_reference const_reference;
+    typedef typename Allocators::node_pointer node_pointer;
+
+    typedef typename rtree::elements_type<internal_node>::type::const_iterator internal_iterator;
+    typedef typename rtree::elements_type<leaf>::type leaf_elements;
+    typedef typename rtree::elements_type<leaf>::type::const_iterator leaf_iterator;
+
+    inline iterator()
+        : m_values(NULL)
+        , m_current()
+    {}
+
+    inline void operator()(internal_node const& n)
+    {
+        typedef typename rtree::elements_type<internal_node>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        m_internal_stack.push_back(std::make_pair(elements.begin(), elements.end()));
+    }
+
+    inline void operator()(leaf const& n)
+    {
+        m_values = ::boost::addressof(rtree::elements(n));
+        m_current = rtree::elements(n).begin();
+    }
+
+    const_reference dereference() const
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(m_values, "not dereferencable");
+        return *m_current;
+    }
+
+    void initialize(node_pointer root)
+    {
+        rtree::apply_visitor(*this, *root);
+        search_value();
+    }
+
+    void increment()
+    {
+        ++m_current;
+        search_value();
+    }
+
+    void search_value()
+    {
+        for (;;)
+        {
+            // if leaf is choosen, move to the next value in leaf
+            if ( m_values )
+            {
+                // there are more values in the current leaf
+                if ( m_current != m_values->end() )
+                {
+                    return;
+                }
+                // no more values, clear current leaf
+                else
+                {
+                    m_values = 0;
+                }
+            }
+            // if leaf isn't choosen, move to the next leaf
+            else
+            {
+                // return if there is no more nodes to traverse
+                if ( m_internal_stack.empty() )
+                    return;
+
+                // no more children in current node, remove it from stack
+                if ( m_internal_stack.back().first == m_internal_stack.back().second )
+                {
+                    m_internal_stack.pop_back();
+                    continue;
+                }
+
+                internal_iterator it = m_internal_stack.back().first;
+                ++m_internal_stack.back().first;
+
+                // push the next node to the stack
+                rtree::apply_visitor(*this, *(it->second));
+            }
+        }
+    }
+
+    bool is_end() const
+    {
+        return 0 == m_values;
+    }
+
+    friend bool operator==(iterator const& l, iterator const& r)
+    {
+        return (l.m_values == r.m_values) && (0 == l.m_values || l.m_current == r.m_current );
+    }
+
+private:
+
+    std::vector< std::pair<internal_iterator, internal_iterator> > m_internal_stack;
+    const leaf_elements * m_values;
+    leaf_iterator m_current;
+};
+
+}}} // namespace detail::rtree::visitors
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_ITERATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/remove.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/remove.hpp
new file mode 100644
index 00000000000..7e6162a6163
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/remove.hpp
@@ -0,0 +1,344 @@
+// Boost.Geometry Index
+//
+// R-tree removing visitor implementation
+//
+// Copyright (c) 2011-2017 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_REMOVE_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_REMOVE_HPP
+
+#include <boost/geometry/index/detail/rtree/visitors/is_leaf.hpp>
+
+#include <boost/geometry/algorithms/detail/covered_by/interface.hpp>
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree { namespace visitors {
+
+// Default remove algorithm
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+class remove
+    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, false>::type
+{
+    typedef typename Options::parameters_type parameters_type;
+
+    typedef typename rtree::node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef rtree::subtree_destroyer<Value, Options, Translator, Box, Allocators> subtree_destroyer;
+    typedef typename Allocators::node_pointer node_pointer;
+    typedef typename Allocators::size_type size_type;
+
+    typedef typename rtree::elements_type<internal_node>::type::size_type internal_size_type;
+
+    //typedef typename Allocators::internal_node_pointer internal_node_pointer;
+    typedef internal_node * internal_node_pointer;
+
+public:
+    inline remove(node_pointer & root,
+                  size_type & leafs_level,
+                  Value const& value,
+                  parameters_type const& parameters,
+                  Translator const& translator,
+                  Allocators & allocators)
+        : m_value(value)
+        , m_parameters(parameters)
+        , m_translator(translator)
+        , m_allocators(allocators)
+        , m_root_node(root)
+        , m_leafs_level(leafs_level)
+        , m_is_value_removed(false)
+        , m_parent(0)
+        , m_current_child_index(0)
+        , m_current_level(0)
+        , m_is_underflow(false)
+    {
+        // TODO
+        // assert - check if Value/Box is correct
+    }
+
+    inline void operator()(internal_node & n)
+    {
+        typedef typename rtree::elements_type<internal_node>::type children_type;
+        children_type & children = rtree::elements(n);
+
+        // traverse children which boxes intersects value's box
+        internal_size_type child_node_index = 0;
+        for ( ; child_node_index < children.size() ; ++child_node_index )
+        {
+            if ( geometry::covered_by(
+                    return_ref_or_bounds(m_translator(m_value)),
+                    children[child_node_index].first) )
+            {
+                // next traversing step
+                traverse_apply_visitor(n, child_node_index);                                                            // MAY THROW
+
+                if ( m_is_value_removed )
+                    break;
+            }
+        }
+
+        // value was found and removed
+        if ( m_is_value_removed )
+        {
+            typedef typename rtree::elements_type<internal_node>::type elements_type;
+            typedef typename elements_type::iterator element_iterator;
+            elements_type & elements = rtree::elements(n);
+
+            // underflow occured - child node should be removed
+            if ( m_is_underflow )
+            {
+                element_iterator underfl_el_it = elements.begin() + child_node_index;
+                size_type relative_level = m_leafs_level - m_current_level;
+
+                // move node to the container - store node's relative level as well and return new underflow state
+                // NOTE: if the min elements number is 1, then after an underflow
+                //       here the child elements count is 0, so it's not required to store this node,
+                //       it could just be destroyed
+                m_is_underflow = store_underflowed_node(elements, underfl_el_it, relative_level);                       // MAY THROW (E: alloc, copy)
+            }
+
+            // n is not root - adjust aabb
+            if ( 0 != m_parent )
+            {
+                // underflow state should be ok here
+                // note that there may be less than min_elems elements in root
+                // so this condition should be checked only here
+                BOOST_GEOMETRY_INDEX_ASSERT((elements.size() < m_parameters.get_min_elements()) == m_is_underflow, "unexpected state");
+
+                rtree::elements(*m_parent)[m_current_child_index].first
+                    = rtree::elements_box<Box>(elements.begin(), elements.end(), m_translator);
+            }
+            // n is root node
+            else
+            {
+                BOOST_GEOMETRY_INDEX_ASSERT(&n == &rtree::get<internal_node>(*m_root_node), "node must be the root");
+
+                // reinsert elements from removed nodes (underflows)
+                reinsert_removed_nodes_elements();                                                                  // MAY THROW (V, E: alloc, copy, N: alloc)
+
+                // shorten the tree
+                // NOTE: if the min elements number is 1, then after underflow
+                //       here the number of elements may be equal to 0
+                //       this can occur only for the last removed element
+                if ( rtree::elements(n).size() <= 1 )
+                {
+                    node_pointer root_to_destroy = m_root_node;
+                    if ( rtree::elements(n).size() == 0 )
+                        m_root_node = 0;
+                    else
+                        m_root_node = rtree::elements(n)[0].second;
+                    --m_leafs_level;
+
+                    rtree::destroy_node<Allocators, internal_node>::apply(m_allocators, root_to_destroy);
+                }
+            }
+        }
+    }
+
+    inline void operator()(leaf & n)
+    {
+        typedef typename rtree::elements_type<leaf>::type elements_type;
+        elements_type & elements = rtree::elements(n);
+
+        // find value and remove it
+        for ( typename elements_type::iterator it = elements.begin() ; it != elements.end() ; ++it )
+        {
+            if ( m_translator.equals(*it, m_value) )
+            {
+                rtree::move_from_back(elements, it);                                                           // MAY THROW (V: copy)
+                elements.pop_back();
+                m_is_value_removed = true;
+                break;
+            }
+        }
+
+        // if value was removed
+        if ( m_is_value_removed )
+        {
+            BOOST_GEOMETRY_INDEX_ASSERT(0 < m_parameters.get_min_elements(), "min number of elements is too small");
+
+            // calc underflow
+            m_is_underflow = elements.size() < m_parameters.get_min_elements();
+
+            // n is not root - adjust aabb
+            if ( 0 != m_parent )
+            {
+                rtree::elements(*m_parent)[m_current_child_index].first
+                    = rtree::values_box<Box>(elements.begin(), elements.end(), m_translator);
+            }
+        }
+    }
+
+    bool is_value_removed() const
+    {
+        return m_is_value_removed;
+    }
+
+private:
+
+    typedef std::vector< std::pair<size_type, node_pointer> > UnderflowNodes;
+
+    void traverse_apply_visitor(internal_node &n, internal_size_type choosen_node_index)
+    {
+        // save previous traverse inputs and set new ones
+        internal_node_pointer parent_bckup = m_parent;
+        internal_size_type current_child_index_bckup = m_current_child_index;
+        size_type current_level_bckup = m_current_level;
+
+        m_parent = &n;
+        m_current_child_index = choosen_node_index;
+        ++m_current_level;
+
+        // next traversing step
+        rtree::apply_visitor(*this, *rtree::elements(n)[choosen_node_index].second);                    // MAY THROW (V, E: alloc, copy, N: alloc)
+
+        // restore previous traverse inputs
+        m_parent = parent_bckup;
+        m_current_child_index = current_child_index_bckup;
+        m_current_level = current_level_bckup;
+    }
+
+    bool store_underflowed_node(
+            typename rtree::elements_type<internal_node>::type & elements,
+            typename rtree::elements_type<internal_node>::type::iterator underfl_el_it,
+            size_type relative_level)
+    {
+        // move node to the container - store node's relative level as well
+        m_underflowed_nodes.push_back(std::make_pair(relative_level, underfl_el_it->second));           // MAY THROW (E: alloc, copy)
+
+        BOOST_TRY
+        {
+            // NOTE: those are elements of the internal node which means that copy/move shouldn't throw
+            // Though it's safer in case if the pointer type could throw in copy ctor.
+            // In the future this try-catch block could be removed.
+            rtree::move_from_back(elements, underfl_el_it);                                             // MAY THROW (E: copy)
+            elements.pop_back();
+        }
+        BOOST_CATCH(...)
+        {
+            m_underflowed_nodes.pop_back();
+            BOOST_RETHROW                                                                                 // RETHROW
+        }
+        BOOST_CATCH_END
+
+        // calc underflow
+        return elements.size() < m_parameters.get_min_elements();
+    }
+
+    static inline bool is_leaf(node const& n)
+    {
+        visitors::is_leaf<Value, Options, Box, Allocators> ilv;
+        rtree::apply_visitor(ilv, n);
+        return ilv.result;
+    }
+
+    void reinsert_removed_nodes_elements()
+    {
+        typename UnderflowNodes::reverse_iterator it = m_underflowed_nodes.rbegin();
+
+        BOOST_TRY
+        {
+            // reinsert elements from removed nodes
+            // begin with levels closer to the root
+            for ( ; it != m_underflowed_nodes.rend() ; ++it )
+            {
+                // it->first is an index of a level of a node, not children
+                // counted from the leafs level
+                bool const node_is_leaf = it->first == 1;
+                BOOST_GEOMETRY_INDEX_ASSERT(node_is_leaf == is_leaf(*it->second), "unexpected condition");
+                if ( node_is_leaf )
+                {
+                    reinsert_node_elements(rtree::get<leaf>(*it->second), it->first);                        // MAY THROW (V, E: alloc, copy, N: alloc)
+
+                    rtree::destroy_node<Allocators, leaf>::apply(m_allocators, it->second);
+                }
+                else
+                {
+                    reinsert_node_elements(rtree::get<internal_node>(*it->second), it->first);               // MAY THROW (V, E: alloc, copy, N: alloc)
+
+                    rtree::destroy_node<Allocators, internal_node>::apply(m_allocators, it->second);
+                }
+            }
+
+            //m_underflowed_nodes.clear();
+        }
+        BOOST_CATCH(...)
+        {
+            // destroy current and remaining nodes
+            for ( ; it != m_underflowed_nodes.rend() ; ++it )
+            {
+                subtree_destroyer dummy(it->second, m_allocators);
+            }
+
+            //m_underflowed_nodes.clear();
+
+            BOOST_RETHROW                                                                                      // RETHROW
+        }
+        BOOST_CATCH_END
+    }
+
+    template <typename Node>
+    void reinsert_node_elements(Node &n, size_type node_relative_level)
+    {
+        typedef typename rtree::elements_type<Node>::type elements_type;
+        elements_type & elements = rtree::elements(n);
+
+        typename elements_type::iterator it = elements.begin();
+        BOOST_TRY
+        {
+            for ( ; it != elements.end() ; ++it )
+            {
+                visitors::insert<
+                    typename elements_type::value_type,
+                    Value, Options, Translator, Box, Allocators,
+                    typename Options::insert_tag
+                > insert_v(
+                    m_root_node, m_leafs_level, *it,
+                    m_parameters, m_translator, m_allocators,
+                    node_relative_level - 1);
+
+                rtree::apply_visitor(insert_v, *m_root_node);                                               // MAY THROW (V, E: alloc, copy, N: alloc)
+            }
+        }
+        BOOST_CATCH(...)
+        {
+            ++it;
+            rtree::destroy_elements<Value, Options, Translator, Box, Allocators>
+                ::apply(it, elements.end(), m_allocators);
+            elements.clear();
+            BOOST_RETHROW                                                                                     // RETHROW
+        }
+        BOOST_CATCH_END
+    }
+
+    Value const& m_value;
+    parameters_type const& m_parameters;
+    Translator const& m_translator;
+    Allocators & m_allocators;
+
+    node_pointer & m_root_node;
+    size_type & m_leafs_level;
+
+    bool m_is_value_removed;
+    UnderflowNodes m_underflowed_nodes;
+
+    // traversing input parameters
+    internal_node_pointer m_parent;
+    internal_size_type m_current_child_index;
+    size_type m_current_level;
+
+    // traversing output parameters
+    bool m_is_underflow;
+};
+
+}}} // namespace detail::rtree::visitors
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_REMOVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/spatial_query.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/spatial_query.hpp
new file mode 100644
index 00000000000..b9cd0ae2c05
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/rtree/visitors/spatial_query.hpp
@@ -0,0 +1,214 @@
+// Boost.Geometry Index
+//
+// R-tree spatial query visitor implementation
+//
+// Copyright (c) 2011-2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_SPATIAL_QUERY_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_SPATIAL_QUERY_HPP
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { namespace rtree { namespace visitors {
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators, typename Predicates, typename OutIter>
+struct spatial_query
+    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
+{
+    typedef typename rtree::node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef typename Allocators::size_type size_type;
+
+    static const unsigned predicates_len = index::detail::predicates_length<Predicates>::value;
+
+    inline spatial_query(Translator const& t, Predicates const& p, OutIter out_it)
+        : tr(t), pred(p), out_iter(out_it), found_count(0)
+    {}
+
+    inline void operator()(internal_node const& n)
+    {
+        typedef typename rtree::elements_type<internal_node>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        // traverse nodes meeting predicates
+        for (typename elements_type::const_iterator it = elements.begin();
+            it != elements.end(); ++it)
+        {
+            // if node meets predicates
+            // 0 - dummy value
+            if ( index::detail::predicates_check<index::detail::bounds_tag, 0, predicates_len>(pred, 0, it->first) )
+                rtree::apply_visitor(*this, *it->second);
+        }
+    }
+
+    inline void operator()(leaf const& n)
+    {
+        typedef typename rtree::elements_type<leaf>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        // get all values meeting predicates
+        for (typename elements_type::const_iterator it = elements.begin();
+            it != elements.end(); ++it)
+        {
+            // if value meets predicates
+            if ( index::detail::predicates_check<index::detail::value_tag, 0, predicates_len>(pred, *it, tr(*it)) )
+            {
+                *out_iter = *it;
+                ++out_iter;
+
+                ++found_count;
+            }
+        }
+    }
+
+    Translator const& tr;
+
+    Predicates pred;
+
+    OutIter out_iter;
+    size_type found_count;
+};
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators, typename Predicates>
+class spatial_query_incremental
+    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
+{
+public:
+    typedef typename rtree::node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef typename Allocators::size_type size_type;
+    typedef typename Allocators::const_reference const_reference;
+    typedef typename Allocators::node_pointer node_pointer;
+
+    typedef typename rtree::elements_type<internal_node>::type::const_iterator internal_iterator;
+    typedef typename rtree::elements_type<leaf>::type leaf_elements;
+    typedef typename rtree::elements_type<leaf>::type::const_iterator leaf_iterator;
+
+    static const unsigned predicates_len = index::detail::predicates_length<Predicates>::value;
+
+    inline spatial_query_incremental()
+        : m_translator(NULL)
+//        , m_pred()
+        , m_values(NULL)
+        , m_current()
+    {}
+
+    inline spatial_query_incremental(Translator const& t, Predicates const& p)
+        : m_translator(::boost::addressof(t))
+        , m_pred(p)
+        , m_values(NULL)
+        , m_current()
+    {}
+
+    inline void operator()(internal_node const& n)
+    {
+        typedef typename rtree::elements_type<internal_node>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        m_internal_stack.push_back(std::make_pair(elements.begin(), elements.end()));
+    }
+
+    inline void operator()(leaf const& n)
+    {
+        m_values = ::boost::addressof(rtree::elements(n));
+        m_current = rtree::elements(n).begin();
+    }
+
+    const_reference dereference() const
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(m_values, "not dereferencable");
+        return *m_current;
+    }
+
+    void initialize(node_pointer root)
+    {
+        rtree::apply_visitor(*this, *root);
+        search_value();
+    }
+
+    void increment()
+    {
+        ++m_current;
+        search_value();
+    }
+
+    void search_value()
+    {
+        for (;;)
+        {
+            // if leaf is choosen, move to the next value in leaf
+            if ( m_values )
+            {
+                if ( m_current != m_values->end() )
+                {
+                    // return if next value is found
+                    Value const& v = *m_current;
+                    if ( index::detail::predicates_check<index::detail::value_tag, 0, predicates_len>(m_pred, v, (*m_translator)(v)) )
+                        return;
+
+                    ++m_current;
+                }
+                // no more values, clear current leaf
+                else
+                {
+                    m_values = 0;
+                }
+            }
+            // if leaf isn't choosen, move to the next leaf
+            else
+            {
+                // return if there is no more nodes to traverse
+                if ( m_internal_stack.empty() )
+                    return;
+
+                // no more children in current node, remove it from stack
+                if ( m_internal_stack.back().first == m_internal_stack.back().second )
+                {
+                    m_internal_stack.pop_back();
+                    continue;
+                }
+
+                internal_iterator it = m_internal_stack.back().first;
+                ++m_internal_stack.back().first;
+
+                // next node is found, push it to the stack
+                if ( index::detail::predicates_check<index::detail::bounds_tag, 0, predicates_len>(m_pred, 0, it->first) )
+                    rtree::apply_visitor(*this, *(it->second));
+            }
+        }
+    }
+
+    bool is_end() const
+    {
+        return 0 == m_values;
+    }
+
+    friend bool operator==(spatial_query_incremental const& l, spatial_query_incremental const& r)
+    {
+        return (l.m_values == r.m_values) && (0 == l.m_values || l.m_current == r.m_current );
+    }
+
+private:
+
+    const Translator * m_translator;
+
+    Predicates m_pred;
+
+    std::vector< std::pair<internal_iterator, internal_iterator> > m_internal_stack;
+    const leaf_elements * m_values;
+    leaf_iterator m_current;
+};
+
+}}} // namespace detail::rtree::visitors
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_VISITORS_SPATIAL_QUERY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/serialization.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/serialization.hpp
new file mode 100644
index 00000000000..550a37565be
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/serialization.hpp
@@ -0,0 +1,585 @@
+// Boost.Geometry Index
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_SERIALIZATION_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_SERIALIZATION_HPP
+
+//#include <boost/serialization/serialization.hpp>
+#include <boost/serialization/split_member.hpp>
+#include <boost/serialization/version.hpp>
+//#include <boost/serialization/nvp.hpp>
+
+// TODO
+// how about using the unsigned type capable of storing Max in compile-time versions?
+
+// TODO
+// - add wrappers for Point and Box and implement serialize for those wrappers instead of
+//   raw geometries
+//   PROBLEM: after implementing this, how Values would be set?
+// - store the name of the parameters to know how to load and detect errors
+// - in the header, once store info about the Indexable and Bounds types (geometry type, point CS, Dim, etc.)
+//   each geometry save without this info
+
+// TODO - move to index/detail/serialization.hpp
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+// TODO - use boost::move?
+template<typename T>
+class serialization_storage
+{
+public:
+    template <typename Archive>
+    serialization_storage(Archive & ar, unsigned int version)
+    {
+        boost::serialization::load_construct_data_adl(ar, this->address(), version);
+    }
+    ~serialization_storage()
+    {
+        this->address()->~T();
+    }
+    T * address()
+    {
+        return static_cast<T*>(m_storage.address());
+    }
+private:
+    boost::aligned_storage<sizeof(T), boost::alignment_of<T>::value> m_storage;
+};
+
+// TODO - save and load item_version? see: collections_load_imp and collections_save_imp
+// this should be done once for the whole container
+// versions of all used types should be stored
+
+template <typename T, typename Archive> inline
+T serialization_load(const char * name, Archive & ar)
+{
+    namespace bs = boost::serialization;    
+    serialization_storage<T> storage(ar, bs::version<T>::value);        // load_construct_data
+    ar >> boost::serialization::make_nvp(name, *storage.address());   // serialize
+    //ar >> *storage.address();                                           // serialize
+    return *storage.address();
+}
+
+template <typename T, typename Archive> inline
+void serialization_save(T const& t, const char * name, Archive & ar)
+{
+    namespace bs = boost::serialization;
+    bs::save_construct_data_adl(ar, boost::addressof(t), bs::version<T>::value);  // save_construct_data
+    ar << boost::serialization::make_nvp(name, t);                                // serialize
+    //ar << t;                                                                      // serialize
+}
+    
+}}}}
+
+// TODO - move to index/serialization/rtree.hpp
+namespace boost { namespace serialization {
+
+// boost::geometry::index::linear
+
+template<class Archive, size_t Max, size_t Min>
+void save_construct_data(Archive & ar, const boost::geometry::index::linear<Max, Min> * params, unsigned int )
+{
+    size_t max = params->get_max_elements(), min = params->get_min_elements();
+    ar << boost::serialization::make_nvp("max", max);
+    ar << boost::serialization::make_nvp("min", min);
+}
+template<class Archive, size_t Max, size_t Min>
+void load_construct_data(Archive & ar, boost::geometry::index::linear<Max, Min> * params, unsigned int )
+{
+    size_t max, min;
+    ar >> boost::serialization::make_nvp("max", max);
+    ar >> boost::serialization::make_nvp("min", min);
+    if ( max != params->get_max_elements() || min != params->get_min_elements() )
+        // TODO change exception type
+        BOOST_THROW_EXCEPTION(std::runtime_error("parameters not compatible"));
+    // the constructor musn't be called for this type
+    //::new(params)boost::geometry::index::linear<Max, Min>();
+}
+template<class Archive, size_t Max, size_t Min> void serialize(Archive &, boost::geometry::index::linear<Max, Min> &, unsigned int) {}
+
+// boost::geometry::index::quadratic
+
+template<class Archive, size_t Max, size_t Min>
+void save_construct_data(Archive & ar, const boost::geometry::index::quadratic<Max, Min> * params, unsigned int )
+{
+    size_t max = params->get_max_elements(), min = params->get_min_elements();
+    ar << boost::serialization::make_nvp("max", max);
+    ar << boost::serialization::make_nvp("min", min);
+}
+template<class Archive, size_t Max, size_t Min>
+void load_construct_data(Archive & ar, boost::geometry::index::quadratic<Max, Min> * params, unsigned int )
+{
+    size_t max, min;
+    ar >> boost::serialization::make_nvp("max", max);
+    ar >> boost::serialization::make_nvp("min", min);
+    if ( max != params->get_max_elements() || min != params->get_min_elements() )
+        // TODO change exception type
+        BOOST_THROW_EXCEPTION(std::runtime_error("parameters not compatible"));
+    // the constructor musn't be called for this type
+    //::new(params)boost::geometry::index::quadratic<Max, Min>();
+}
+template<class Archive, size_t Max, size_t Min> void serialize(Archive &, boost::geometry::index::quadratic<Max, Min> &, unsigned int) {}
+
+// boost::geometry::index::rstar
+
+template<class Archive, size_t Max, size_t Min, size_t RE, size_t OCT>
+void save_construct_data(Archive & ar, const boost::geometry::index::rstar<Max, Min, RE, OCT> * params, unsigned int )
+{
+    size_t max = params->get_max_elements()
+         , min = params->get_min_elements()
+         , re = params->get_reinserted_elements()
+         , oct = params->get_overlap_cost_threshold();
+    ar << boost::serialization::make_nvp("max", max);
+    ar << boost::serialization::make_nvp("min", min);
+    ar << boost::serialization::make_nvp("re", re);
+    ar << boost::serialization::make_nvp("oct", oct);
+}
+template<class Archive, size_t Max, size_t Min, size_t RE, size_t OCT>
+void load_construct_data(Archive & ar, boost::geometry::index::rstar<Max, Min, RE, OCT> * params, unsigned int )
+{
+    size_t max, min, re, oct;
+    ar >> boost::serialization::make_nvp("max", max);
+    ar >> boost::serialization::make_nvp("min", min);
+    ar >> boost::serialization::make_nvp("re", re);
+    ar >> boost::serialization::make_nvp("oct", oct);
+    if ( max != params->get_max_elements() || min != params->get_min_elements() ||
+         re != params->get_reinserted_elements() || oct != params->get_overlap_cost_threshold() )
+        // TODO change exception type
+        BOOST_THROW_EXCEPTION(std::runtime_error("parameters not compatible"));
+    // the constructor musn't be called for this type
+    //::new(params)boost::geometry::index::rstar<Max, Min, RE, OCT>();
+}
+template<class Archive, size_t Max, size_t Min, size_t RE, size_t OCT>
+void serialize(Archive &, boost::geometry::index::rstar<Max, Min, RE, OCT> &, unsigned int) {}
+
+// boost::geometry::index::dynamic_linear
+
+template<class Archive>
+inline void save_construct_data(Archive & ar, const boost::geometry::index::dynamic_linear * params, unsigned int )
+{
+    size_t max = params->get_max_elements(), min = params->get_min_elements();
+    ar << boost::serialization::make_nvp("max", max);
+    ar << boost::serialization::make_nvp("min", min);
+}
+template<class Archive>
+inline void load_construct_data(Archive & ar, boost::geometry::index::dynamic_linear * params, unsigned int )
+{
+    size_t max, min;
+    ar >> boost::serialization::make_nvp("max", max);
+    ar >> boost::serialization::make_nvp("min", min);
+    ::new(params)boost::geometry::index::dynamic_linear(max, min);
+}
+template<class Archive> void serialize(Archive &, boost::geometry::index::dynamic_linear &, unsigned int) {}
+
+// boost::geometry::index::dynamic_quadratic
+
+template<class Archive>
+inline void save_construct_data(Archive & ar, const boost::geometry::index::dynamic_quadratic * params, unsigned int )
+{
+    size_t max = params->get_max_elements(), min = params->get_min_elements();
+    ar << boost::serialization::make_nvp("max", max);
+    ar << boost::serialization::make_nvp("min", min);
+}
+template<class Archive>
+inline void load_construct_data(Archive & ar, boost::geometry::index::dynamic_quadratic * params, unsigned int )
+{
+    size_t max, min;
+    ar >> boost::serialization::make_nvp("max", max);
+    ar >> boost::serialization::make_nvp("min", min);
+    ::new(params)boost::geometry::index::dynamic_quadratic(max, min);
+}
+template<class Archive> void serialize(Archive &, boost::geometry::index::dynamic_quadratic &, unsigned int) {}
+
+// boost::geometry::index::dynamic_rstar
+
+template<class Archive>
+inline void save_construct_data(Archive & ar, const boost::geometry::index::dynamic_rstar * params, unsigned int )
+{
+    size_t max = params->get_max_elements()
+         , min = params->get_min_elements()
+         , re = params->get_reinserted_elements()
+         , oct = params->get_overlap_cost_threshold();
+    ar << boost::serialization::make_nvp("max", max);
+    ar << boost::serialization::make_nvp("min", min);
+    ar << boost::serialization::make_nvp("re", re);
+    ar << boost::serialization::make_nvp("oct", oct);
+}
+template<class Archive>
+inline void load_construct_data(Archive & ar, boost::geometry::index::dynamic_rstar * params, unsigned int )
+{
+    size_t max, min, re, oct;
+    ar >> boost::serialization::make_nvp("max", max);
+    ar >> boost::serialization::make_nvp("min", min);
+    ar >> boost::serialization::make_nvp("re", re);
+    ar >> boost::serialization::make_nvp("oct", oct);
+    ::new(params)boost::geometry::index::dynamic_rstar(max, min, re, oct);
+}
+template<class Archive> void serialize(Archive &, boost::geometry::index::dynamic_rstar &, unsigned int) {}
+
+}} // boost::serialization
+
+// TODO - move to index/detail/serialization.hpp or maybe geometry/serialization.hpp
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+template <typename P, size_t I = 0, size_t D = geometry::dimension<P>::value>
+struct serialize_point
+{
+    template <typename Archive>
+    static inline void save(Archive & ar, P const& p, unsigned int version)
+    {
+        typename coordinate_type<P>::type c = get<I>(p);
+        ar << boost::serialization::make_nvp("c", c);
+        serialize_point<P, I+1, D>::save(ar, p, version);
+    }
+
+    template <typename Archive>
+    static inline void load(Archive & ar, P & p, unsigned int version)
+    {
+        typename geometry::coordinate_type<P>::type c;
+        ar >> boost::serialization::make_nvp("c", c);
+        set<I>(p, c);
+        serialize_point<P, I+1, D>::load(ar, p, version);
+    }
+};
+
+template <typename P, size_t D>
+struct serialize_point<P, D, D>
+{
+    template <typename Archive> static inline void save(Archive &, P const&, unsigned int) {}
+    template <typename Archive> static inline void load(Archive &, P &, unsigned int) {}
+};
+
+}}}}
+
+// TODO - move to index/detail/serialization.hpp or maybe geometry/serialization.hpp
+namespace boost { namespace serialization {
+
+template<class Archive, typename T, size_t D, typename C>
+void save(Archive & ar, boost::geometry::model::point<T, D, C> const& p, unsigned int version)
+{
+    boost::geometry::index::detail::serialize_point< boost::geometry::model::point<T, D, C> >::save(ar, p, version);
+}
+template<class Archive, typename T, size_t D, typename C>
+void load(Archive & ar, boost::geometry::model::point<T, D, C> & p, unsigned int version)
+{
+    boost::geometry::index::detail::serialize_point< boost::geometry::model::point<T, D, C> >::load(ar, p, version);
+}
+template<class Archive, typename T, size_t D, typename C>
+inline void serialize(Archive & ar, boost::geometry::model::point<T, D, C> & o, const unsigned int version) { split_free(ar, o, version); }
+
+template<class Archive, typename P>
+inline void serialize(Archive & ar, boost::geometry::model::box<P> & b, const unsigned int)
+{
+    ar & boost::serialization::make_nvp("min", b.min_corner());
+    ar & boost::serialization::make_nvp("max", b.max_corner());
+}
+
+}} // boost::serialization
+
+// TODO - move to index/detail/rtree/visitors/save.hpp
+namespace boost { namespace geometry { namespace index { namespace detail { namespace rtree { namespace visitors {
+
+// TODO move saving and loading of the rtree outside the rtree, this will require adding some kind of members_view
+
+template <typename Archive, typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+class save
+    : public rtree::visitor<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag, true>::type
+{
+public:
+    typedef typename rtree::node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    save(Archive & archive, unsigned int version)
+        : m_archive(archive), m_version(version)
+    {}
+
+    inline void operator()(internal_node const& n)
+    {
+        typedef typename rtree::elements_type<internal_node>::type elements_type;
+        elements_type const& elements = rtree::elements(n);
+
+        // CONSIDER: change to elements_type::size_type or size_type
+        // or use fixed-size type like uint32 or even uint16?
+        size_t s = elements.size();
+        m_archive << boost::serialization::make_nvp("s", s);
+
+        for (typename elements_type::const_iterator it = elements.begin() ; it != elements.end() ; ++it)
+        {
+            serialization_save(it->first, "b", m_archive);
+
+            rtree::apply_visitor(*this, *it->second);
+        }
+    }
+
+    inline void operator()(leaf const& l)
+    {
+        typedef typename rtree::elements_type<leaf>::type elements_type;
+        //typedef typename elements_type::size_type elements_size;
+        elements_type const& elements = rtree::elements(l);
+
+        // CONSIDER: change to elements_type::size_type or size_type
+        // or use fixed-size type like uint32 or even uint16?
+        size_t s = elements.size();
+        m_archive << boost::serialization::make_nvp("s", s);
+
+        for (typename elements_type::const_iterator it = elements.begin() ; it != elements.end() ; ++it)
+        {
+            serialization_save(*it, "v", m_archive);
+        }
+    }
+
+private:
+    Archive & m_archive;
+    unsigned int m_version;
+};
+
+}}}}}} // boost::geometry::index::detail::rtree::visitors
+
+// TODO - move to index/detail/rtree/load.hpp
+namespace boost { namespace geometry { namespace index { namespace detail { namespace rtree {
+
+template <typename Value, typename Options, typename Translator, typename Box, typename Allocators>
+class load
+{
+    typedef typename rtree::node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type node;
+    typedef typename rtree::internal_node<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type internal_node;
+    typedef typename rtree::leaf<Value, typename Options::parameters_type, Box, Allocators, typename Options::node_tag>::type leaf;
+
+    typedef typename Options::parameters_type parameters_type;
+
+    typedef typename Allocators::node_pointer node_pointer;
+    typedef rtree::subtree_destroyer<Value, Options, Translator, Box, Allocators> subtree_destroyer;
+    typedef typename Allocators::size_type size_type;
+
+public:
+    template <typename Archive> inline static
+    node_pointer apply(Archive & ar, unsigned int version, size_type leafs_level, size_type & values_count, parameters_type const& parameters, Translator const& translator, Allocators & allocators)
+    {
+        values_count = 0;
+        return raw_apply(ar, version, leafs_level, values_count, parameters, translator, allocators);
+    }
+
+private:
+    template <typename Archive> inline static
+    node_pointer raw_apply(Archive & ar, unsigned int version, size_type leafs_level, size_type & values_count, parameters_type const& parameters, Translator const& translator, Allocators & allocators, size_type current_level = 0)
+    {
+        //BOOST_GEOMETRY_INDEX_ASSERT(current_level <= leafs_level, "invalid parameter");
+
+        typedef typename rtree::elements_type<internal_node>::type elements_type;
+        typedef typename elements_type::value_type element_type;
+        //typedef typename elements_type::size_type elements_size;
+
+        // CONSIDER: change to elements_type::size_type or size_type
+        // or use fixed-size type like uint32 or even uint16?
+        size_t elements_count;
+        ar >> boost::serialization::make_nvp("s", elements_count);
+
+        if ( elements_count < parameters.get_min_elements() || parameters.get_max_elements() < elements_count )
+            BOOST_THROW_EXCEPTION(std::runtime_error("rtree loading error"));
+
+        if ( current_level < leafs_level )
+        {
+            node_pointer n = rtree::create_node<Allocators, internal_node>::apply(allocators);              // MAY THROW (A)
+            subtree_destroyer auto_remover(n, allocators);    
+            internal_node & in = rtree::get<internal_node>(*n);
+
+            elements_type & elements = rtree::elements(in);
+
+            elements.reserve(elements_count);                                                               // MAY THROW (A)
+
+            for ( size_t i = 0 ; i < elements_count ; ++i )
+            {
+                typedef typename elements_type::value_type::first_type box_type;
+                box_type b = serialization_load<box_type>("b", ar);
+                node_pointer n = raw_apply(ar, version, leafs_level, values_count, parameters, translator, allocators, current_level+1); // recursive call
+                elements.push_back(element_type(b, n));
+            }
+
+            auto_remover.release();
+            return n;
+        }
+        else
+        {
+            BOOST_GEOMETRY_INDEX_ASSERT(current_level == leafs_level, "unexpected value");
+
+            node_pointer n = rtree::create_node<Allocators, leaf>::apply(allocators);                       // MAY THROW (A)
+            subtree_destroyer auto_remover(n, allocators);
+            leaf & l = rtree::get<leaf>(*n);
+
+            typedef typename rtree::elements_type<leaf>::type elements_type;
+            typedef typename elements_type::value_type element_type;
+            elements_type & elements = rtree::elements(l);
+
+            values_count += elements_count;
+
+            elements.reserve(elements_count);                                                               // MAY THROW (A)
+
+            for ( size_t i = 0 ; i < elements_count ; ++i )
+            {
+                element_type el = serialization_load<element_type>("v", ar);                                     // MAY THROW (C)
+                elements.push_back(el);                                                                     // MAY THROW (C)
+            }
+
+            auto_remover.release();
+            return n;
+        }
+    }
+};
+
+}}}}} // boost::geometry::index::detail::rtree
+
+// TODO - move to index/detail/rtree/private_view.hpp
+namespace boost { namespace geometry { namespace index { namespace detail { namespace rtree {
+
+template <typename Rtree>
+class const_private_view
+{
+public:
+    typedef typename Rtree::size_type size_type;
+
+    typedef typename Rtree::translator_type translator_type;
+    typedef typename Rtree::value_type value_type;
+    typedef typename Rtree::options_type options_type;
+    typedef typename Rtree::box_type box_type;
+    typedef typename Rtree::allocators_type allocators_type;    
+
+    const_private_view(Rtree const& rt) : m_rtree(rt) {}
+
+    typedef typename Rtree::members_holder members_holder;
+
+    members_holder const& members() const { return m_rtree.m_members; }
+
+private:
+    const_private_view(const_private_view const&);
+    const_private_view & operator=(const_private_view const&);
+
+    Rtree const& m_rtree;
+};
+
+template <typename Rtree>
+class private_view
+{
+public:
+    typedef typename Rtree::size_type size_type;
+
+    typedef typename Rtree::translator_type translator_type;
+    typedef typename Rtree::value_type value_type;
+    typedef typename Rtree::options_type options_type;
+    typedef typename Rtree::box_type box_type;
+    typedef typename Rtree::allocators_type allocators_type;    
+
+    private_view(Rtree & rt) : m_rtree(rt) {}
+
+    typedef typename Rtree::members_holder members_holder;
+
+    members_holder & members() { return m_rtree.m_members; }
+    members_holder const& members() const { return m_rtree.m_members; }
+
+private:
+    private_view(private_view const&);
+    private_view & operator=(private_view const&);
+
+    Rtree & m_rtree;
+};
+
+}}}}} // namespace boost::geometry::index::detail::rtree
+
+// TODO - move to index/serialization/rtree.hpp
+namespace boost { namespace serialization {
+
+template<class Archive, typename V, typename P, typename I, typename E, typename A>
+void save(Archive & ar, boost::geometry::index::rtree<V, P, I, E, A> const& rt, unsigned int version)
+{
+    namespace detail = boost::geometry::index::detail;
+
+    typedef boost::geometry::index::rtree<V, P, I, E, A> rtree;
+    typedef detail::rtree::const_private_view<rtree> view;
+    typedef typename view::translator_type translator_type;
+    typedef typename view::value_type value_type;
+    typedef typename view::options_type options_type;
+    typedef typename view::box_type box_type;
+    typedef typename view::allocators_type allocators_type;
+
+    view tree(rt);
+
+    detail::serialization_save(tree.members().parameters(), "parameters", ar);
+
+    ar << boost::serialization::make_nvp("values_count", tree.members().values_count);
+    ar << boost::serialization::make_nvp("leafs_level", tree.members().leafs_level);
+
+    if ( tree.members().values_count )
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(tree.members().root, "root shouldn't be null_ptr");
+
+        detail::rtree::visitors::save<Archive, value_type, options_type, translator_type, box_type, allocators_type> save_v(ar, version);
+        detail::rtree::apply_visitor(save_v, *tree.members().root);
+    }
+}
+
+template<class Archive, typename V, typename P, typename I, typename E, typename A>
+void load(Archive & ar, boost::geometry::index::rtree<V, P, I, E, A> & rt, unsigned int version)
+{
+    namespace detail = boost::geometry::index::detail;
+
+    typedef boost::geometry::index::rtree<V, P, I, E, A> rtree;
+    typedef detail::rtree::private_view<rtree> view;
+    typedef typename view::size_type size_type;
+    typedef typename view::translator_type translator_type;
+    typedef typename view::value_type value_type;
+    typedef typename view::options_type options_type;
+    typedef typename view::box_type box_type;
+    typedef typename view::allocators_type allocators_type;
+
+    typedef typename options_type::parameters_type parameters_type;
+    typedef typename allocators_type::node_pointer node_pointer;
+    typedef detail::rtree::subtree_destroyer<value_type, options_type, translator_type, box_type, allocators_type> subtree_destroyer;
+
+    view tree(rt);
+
+    parameters_type params = detail::serialization_load<parameters_type>("parameters", ar);
+
+    size_type values_count, leafs_level;
+    ar >> boost::serialization::make_nvp("values_count", values_count);
+    ar >> boost::serialization::make_nvp("leafs_level", leafs_level);
+
+    node_pointer n(0);
+    if ( 0 < values_count )
+    {
+        size_type loaded_values_count = 0;
+        n = detail::rtree::load<value_type, options_type, translator_type, box_type, allocators_type>
+            ::apply(ar, version, leafs_level, loaded_values_count, params, tree.members().translator(), tree.members().allocators());                                        // MAY THROW
+
+        subtree_destroyer remover(n, tree.members().allocators());
+        if ( loaded_values_count != values_count )
+            BOOST_THROW_EXCEPTION(std::runtime_error("unexpected number of values")); // TODO change exception type
+        remover.release();
+    }
+
+    tree.members().parameters() = params;
+    tree.members().values_count = values_count;
+    tree.members().leafs_level = leafs_level;
+
+    subtree_destroyer remover(tree.members().root, tree.members().allocators());
+    tree.members().root = n;
+}
+
+template<class Archive, typename V, typename P, typename I, typename E, typename A> inline
+void serialize(Archive & ar, boost::geometry::index::rtree<V, P, I, E, A> & rt, unsigned int version)
+{
+    split_free(ar, rt, version);
+}
+
+template<class Archive, typename V, typename P, typename I, typename E, typename A> inline
+void serialize(Archive & ar, boost::geometry::index::rtree<V, P, I, E, A> const& rt, unsigned int version)
+{
+    split_free(ar, rt, version);
+}
+
+}} // boost::serialization
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_SERIALIZATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/tags.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/tags.hpp
new file mode 100644
index 00000000000..e1a1716bed1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/tags.hpp
@@ -0,0 +1,25 @@
+// Boost.Geometry Index
+//
+// Tags used by the predicates checks implementation.
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_TAGS_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_TAGS_HPP
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail {
+
+struct value_tag {};
+struct bounds_tag {};
+
+} // namespace detail
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_RTREE_TAGS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/translator.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/translator.hpp
new file mode 100644
index 00000000000..f377c720aa9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/translator.hpp
@@ -0,0 +1,60 @@
+// Boost.Geometry Index
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_TRANSLATOR_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_TRANSLATOR_HPP
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail {
+
+template <typename IndexableGetter, typename EqualTo>
+struct translator
+    : public IndexableGetter
+    , public EqualTo
+{
+    typedef typename IndexableGetter::result_type result_type;
+
+    translator(IndexableGetter const& i, EqualTo const& e)
+        : IndexableGetter(i), EqualTo(e)
+    {}
+
+    template <typename Value>
+    result_type operator()(Value const& value) const
+    {
+        return IndexableGetter::operator()(value);
+    }
+
+    template <typename Value>
+    bool equals(Value const& v1, Value const& v2) const
+    {
+        return EqualTo::operator()(v1, v2);
+    }
+};
+
+template <typename IndexableGetter>
+struct result_type
+{
+    typedef typename IndexableGetter::result_type type;
+};
+
+template <typename IndexableGetter>
+struct indexable_type
+{
+    typedef typename boost::remove_const<
+        typename boost::remove_reference<
+            typename result_type<IndexableGetter>::type
+        >::type
+    >::type type;
+};
+
+} // namespace detail
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_TRANSLATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/tuples.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/tuples.hpp
new file mode 100644
index 00000000000..e7f6d22357b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/tuples.hpp
@@ -0,0 +1,204 @@
+// Boost.Geometry Index
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_TUPLES_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_TUPLES_HPP
+
+#include <boost/tuple/tuple.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+// TODO move this to index/tuples and separate algorithms
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+namespace tuples {
+
+// find_index
+
+namespace detail {
+
+template <typename Tuple, typename El, size_t N>
+struct find_index;
+
+template <typename Tuple, typename El, size_t N, typename CurrentEl>
+struct find_index_impl
+{
+    static const size_t value = find_index<Tuple, El, N - 1>::value;
+};
+
+template <typename Tuple, typename El, size_t N>
+struct find_index_impl<Tuple, El, N, El>
+{
+    static const size_t value = N - 1;
+};
+
+template <typename Tuple, typename El, typename CurrentEl>
+struct find_index_impl<Tuple, El, 1, CurrentEl>
+{
+    BOOST_MPL_ASSERT_MSG(
+        (false),
+        ELEMENT_NOT_FOUND,
+        (find_index_impl));
+};
+
+template <typename Tuple, typename El>
+struct find_index_impl<Tuple, El, 1, El>
+{
+    static const size_t value = 0;
+};
+
+template <typename Tuple, typename El, size_t N>
+struct find_index
+{
+    static const size_t value =
+        find_index_impl<
+            Tuple,
+            El,
+            N,
+            typename boost::tuples::element<N - 1, Tuple>::type
+        >::value;
+};
+
+} // namespace detail
+
+template <typename Tuple, typename El>
+struct find_index
+{
+    static const size_t value =
+        detail::find_index<
+            Tuple,
+            El,
+            boost::tuples::length<Tuple>::value
+        >::value;
+};
+
+// has
+
+namespace detail {
+
+template <typename Tuple, typename El, size_t N>
+struct has
+{
+    static const bool value
+        = boost::is_same<
+            typename boost::tuples::element<N - 1, Tuple>::type,
+            El
+        >::value
+        || has<Tuple, El, N - 1>::value;
+};
+
+template <typename Tuple, typename El>
+struct has<Tuple, El, 1>
+{
+    static const bool value
+        = boost::is_same<
+            typename boost::tuples::element<0, Tuple>::type,
+            El
+        >::value;
+};
+
+} // namespace detail
+
+template <typename Tuple, typename El>
+struct has
+{
+    static const bool value
+        = detail::has<
+            Tuple,
+            El,
+            boost::tuples::length<Tuple>::value
+        >::value;
+};
+
+// add
+
+template <typename Tuple, typename El>
+struct add
+{
+    BOOST_MPL_ASSERT_MSG(
+        (false),
+        NOT_IMPLEMENTED_FOR_THIS_TUPLE_TYPE,
+        (add));
+};
+
+template <typename T1, typename T>
+struct add<boost::tuple<T1>, T>
+{
+    typedef boost::tuple<T1, T> type;
+};
+
+template <typename T1, typename T2, typename T>
+struct add<boost::tuple<T1, T2>, T>
+{
+    typedef boost::tuple<T1, T2, T> type;
+};
+
+// add_if
+
+template <typename Tuple, typename El, bool Cond>
+struct add_if
+{
+    typedef Tuple type;
+};
+
+template <typename Tuple, typename El>
+struct add_if<Tuple, El, true>
+{
+    typedef typename add<Tuple, El>::type type;
+};
+
+// add_unique
+
+template <typename Tuple, typename El>
+struct add_unique
+{
+    typedef typename add_if<
+        Tuple,
+        El,
+        !has<Tuple, El>::value
+    >::type type;
+};
+
+template <typename Tuple,
+          typename T,
+          size_t I = 0,
+          size_t N = boost::tuples::length<Tuple>::value>
+struct push_back
+{
+    typedef
+    boost::tuples::cons<
+        typename boost::tuples::element<I, Tuple>::type,
+        typename push_back<Tuple, T, I+1, N>::type
+    > type;
+
+    static type apply(Tuple const& tup, T const& t)
+    {
+        return
+        type(
+            boost::get<I>(tup),
+            push_back<Tuple, T, I+1, N>::apply(tup, t)
+        );
+    }
+};
+
+template <typename Tuple, typename T, size_t N>
+struct push_back<Tuple, T, N, N>
+{
+    typedef boost::tuples::cons<T, boost::tuples::null_type> type;
+
+    static type apply(Tuple const&, T const& t)
+    {
+        return type(t, boost::tuples::null_type());
+    }
+};
+
+} // namespace tuples
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_RTREE_TAGS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/utilities.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/utilities.hpp
new file mode 100644
index 00000000000..26f07800169
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/utilities.hpp
@@ -0,0 +1,46 @@
+// Boost.Geometry Index
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#include <boost/swap.hpp>
+//#include <boost/type_traits/is_empty.hpp>
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_UTILITIES_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_UTILITIES_HPP
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+template<class T>
+static inline void assign_cond(T & l, T const& r, boost::mpl::bool_<true> const&)
+{
+    l = r;
+}
+
+template<class T>
+static inline void assign_cond(T &, T const&, boost::mpl::bool_<false> const&) {}
+
+template<class T>
+static inline void move_cond(T & l, T & r, boost::mpl::bool_<true> const&)
+{
+    l = ::boost::move(r);
+}
+
+template<class T>
+static inline void move_cond(T &, T &, boost::mpl::bool_<false> const&) {}
+
+template <typename T> inline
+void swap_cond(T & l, T & r, boost::mpl::bool_<true> const&)
+{
+    ::boost::swap(l, r);
+}
+
+template <typename T> inline
+void swap_cond(T &, T &, boost::mpl::bool_<false> const&) {}
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_UTILITIES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/varray.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/varray.hpp
new file mode 100644
index 00000000000..1b084aafdb5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/varray.hpp
@@ -0,0 +1,2199 @@
+// Boost.Container varray
+//
+// Copyright (c) 2012-2015 Adam Wulkiewicz, Lodz, Poland.
+// Copyright (c) 2011-2013 Andrew Hundt.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_VARRAY_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_VARRAY_HPP
+
+// TODO - REMOVE/CHANGE
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#include <boost/move/detail/fwd_macros.hpp>
+#endif
+
+#include <boost/config.hpp>
+#include <boost/swap.hpp>
+#include <boost/integer.hpp>
+
+#include <boost/mpl/assert.hpp>
+
+#include <boost/type_traits/is_unsigned.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/type_traits/aligned_storage.hpp>
+
+// TODO - use std::reverse_iterator and std::iterator_traits
+// instead Boost.Iterator to remove dependency?
+// or boost/detail/iterator.hpp ?
+#include <boost/iterator/reverse_iterator.hpp>
+#include <boost/iterator/iterator_concepts.hpp>
+
+#include <boost/geometry/index/detail/assert.hpp>
+#include <boost/geometry/index/detail/exception.hpp>
+
+#include <boost/geometry/index/detail/varray_detail.hpp>
+
+#include <boost/concept_check.hpp>
+
+/*!
+\defgroup varray_non_member varray non-member functions
+*/
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+    
+namespace varray_detail {
+
+template <typename Value, std::size_t Capacity>
+struct varray_traits
+{
+    typedef Value value_type;
+    typedef std::size_t size_type;
+    typedef std::ptrdiff_t difference_type;
+    typedef Value * pointer;
+    typedef const Value * const_pointer;
+    typedef Value & reference;
+    typedef const Value & const_reference;
+
+    typedef boost::false_type use_memop_in_swap_and_move;
+    typedef boost::false_type use_optimized_swap;
+    typedef boost::false_type disable_trivial_init;
+};
+
+template <typename Varray>
+struct checker
+{
+    typedef typename Varray::size_type size_type;
+    typedef typename Varray::const_iterator const_iterator;
+
+    static inline void check_capacity(Varray const& v, size_type s)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(s <= v.capacity(), "size too big");
+
+        ::boost::ignore_unused_variable_warning(v);
+        ::boost::ignore_unused_variable_warning(s);
+    }
+
+    static inline void throw_out_of_bounds(Varray const& v, size_type i)
+    {
+        if ( v.size() <= i )
+            throw_out_of_range("index out of bounds");
+
+        ::boost::ignore_unused_variable_warning(v);
+        ::boost::ignore_unused_variable_warning(i);
+    }
+
+    static inline void check_index(Varray const& v, size_type i)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(i < v.size(), "index out of bounds");
+
+        ::boost::ignore_unused_variable_warning(v);
+        ::boost::ignore_unused_variable_warning(i);
+    }
+
+    static inline void check_not_empty(Varray const& v)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(!v.empty(), "the container is empty");
+        
+        ::boost::ignore_unused_variable_warning(v);
+    }
+
+    static inline void check_iterator_end_neq(Varray const& v, const_iterator position)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(v.begin() <= position && position < v.end(), "iterator out of bounds");
+
+        ::boost::ignore_unused_variable_warning(v);
+        ::boost::ignore_unused_variable_warning(position);
+    }
+
+    static inline void check_iterator_end_eq(Varray const& v, const_iterator position)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(v.begin() <= position && position <= v.end(), "iterator out of bounds");
+
+        ::boost::ignore_unused_variable_warning(v);
+        ::boost::ignore_unused_variable_warning(position);
+    }
+};
+
+} // namespace varray_detail
+
+/*!
+\brief A variable-size array container with fixed capacity.
+
+varray is a sequence container like boost::container::vector with contiguous storage that can
+change in size, along with the static allocation, low overhead, and fixed capacity of boost::array.
+
+A varray is a sequence that supports random access to elements, constant time insertion and
+removal of elements at the end, and linear time insertion and removal of elements at the beginning or 
+in the middle. The number of elements in a varray may vary dynamically up to a fixed capacity
+because elements are stored within the object itself similarly to an array. However, objects are 
+initialized as they are inserted into varray unlike C arrays or std::array which must construct
+all elements on instantiation. The behavior of varray enables the use of statically allocated
+elements in cases with complex object lifetime requirements that would otherwise not be trivially 
+possible.
+
+\par Error Handling
+ Insertion beyond the capacity and out of bounds errors result in undefined behavior unless
+ otherwise specified. In this respect if size() == capacity(), then varray::push_back()
+ behaves like std::vector pop_front() if size() == empty(). The reason for this difference
+ is because unlike vectors, varray does not perform allocation.
+
+\par Advanced Usage
+ Error handling behavior can be modified to more closely match std::vector exception behavior
+ when exceeding bounds by providing an alternate Strategy and varray_traits instantiation.
+
+\tparam Value    The type of element that will be stored.
+\tparam Capacity The maximum number of elements varray can store, fixed at compile time.
+\tparam Strategy Defines the public typedefs and error handlers,
+        implements StaticVectorStrategy and has some similarities
+        to an Allocator.
+*/
+template <typename Value, std::size_t Capacity>
+class varray
+{
+    typedef varray_detail::varray_traits<Value, Capacity> vt;
+    typedef varray_detail::checker<varray> errh;
+
+    BOOST_MPL_ASSERT_MSG(
+        ( boost::is_unsigned<typename vt::size_type>::value &&
+          sizeof(typename boost::uint_value_t<Capacity>::least) <= sizeof(typename vt::size_type) ),
+        SIZE_TYPE_IS_TOO_SMALL_FOR_SPECIFIED_CAPACITY,
+        (varray)
+    );
+
+    typedef boost::aligned_storage<
+        sizeof(Value[Capacity]),
+        boost::alignment_of<Value[Capacity]>::value
+    > aligned_storage_type;
+
+    template <typename V, std::size_t C>
+    friend class varray;
+
+    BOOST_COPYABLE_AND_MOVABLE(varray)
+
+#ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
+public:
+    template <std::size_t C>
+    varray & operator=(varray<Value, C> & sv)
+    {
+        typedef varray<Value, C> other;
+        this->operator=(static_cast<const ::boost::rv<other> &>(const_cast<const other &>(sv)));
+        return *this;
+    }
+#endif
+
+public:
+    //! @brief The type of elements stored in the container.
+    typedef typename vt::value_type value_type;
+    //! @brief The unsigned integral type used by the container.
+    typedef typename vt::size_type size_type;
+    //! @brief The pointers difference type.
+    typedef typename vt::difference_type difference_type;
+    //! @brief The pointer type.
+    typedef typename vt::pointer pointer;
+    //! @brief The const pointer type.
+    typedef typename vt::const_pointer const_pointer;
+    //! @brief The value reference type.
+    typedef typename vt::reference reference;
+    //! @brief The value const reference type.
+    typedef typename vt::const_reference const_reference;
+
+    //! @brief The iterator type.
+    typedef pointer iterator;
+    //! @brief The const iterator type.
+    typedef const_pointer const_iterator;
+    //! @brief The reverse iterator type.
+    typedef boost::reverse_iterator<iterator> reverse_iterator;
+    //! @brief The const reverse iterator.
+    typedef boost::reverse_iterator<const_iterator> const_reverse_iterator;
+
+    //! @brief Constructs an empty varray.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    varray()
+        : m_size(0)
+    {}
+
+    //! @pre <tt>count <= capacity()</tt>
+    //!
+    //! @brief Constructs a varray containing count default constructed Values.
+    //!
+    //! @param count    The number of values which will be contained in the container.
+    //!
+    //! @par Throws
+    //!   If Value's default constructor throws.
+    //! @internal
+    //!   @li If a throwing error handler is specified, throws when the capacity is exceeded. (not by default).
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    explicit varray(size_type count)
+        : m_size(0)
+    {
+        this->resize(count);                                                        // may throw
+    }
+
+    //! @pre <tt>count <= capacity()</tt>
+    //!
+    //! @brief Constructs a varray containing count copies of value.
+    //!
+    //! @param count    The number of copies of a values that will be contained in the container.
+    //! @param value    The value which will be used to copy construct values.
+    //!
+    //! @par Throws
+    //!   If Value's copy constructor throws.
+    //! @internal
+    //!   @li If a throwing error handler is specified, throws when the capacity is exceeded. (not by default).
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    varray(size_type count, value_type const& value)
+        : m_size(0)
+    {
+        this->resize(count, value);                                                 // may throw
+    }
+
+    //! @pre
+    //!  @li <tt>distance(first, last) <= capacity()</tt>
+    //!  @li Iterator must meet the \c ForwardTraversalIterator concept.
+    //!
+    //! @brief Constructs a varray containing copy of a range <tt>[first, last)</tt>.
+    //!
+    //! @param first    The iterator to the first element in range.
+    //! @param last     The iterator to the one after the last element in range.
+    //!
+    //! @par Throws
+    //!   If Value's constructor taking a dereferenced Iterator throws.
+    //! @internal
+    //!   @li If a throwing error handler is specified, throws when the capacity is exceeded. (not by default).
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    template <typename Iterator>
+    varray(Iterator first, Iterator last)
+        : m_size(0)
+    {
+        BOOST_CONCEPT_ASSERT((boost_concepts::ForwardTraversal<Iterator>)); // Make sure you passed a ForwardIterator
+        
+        this->assign(first, last);                                                    // may throw
+    }
+
+    //! @brief Constructs a copy of other varray.
+    //!
+    //! @param other    The varray which content will be copied to this one.
+    //!
+    //! @par Throws
+    //!   If Value's copy constructor throws.
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    varray(varray const& other)
+        : m_size(other.size())
+    {
+        namespace sv = varray_detail;
+        sv::uninitialized_copy(other.begin(), other.end(), this->begin());          // may throw
+    }
+
+    //! @pre <tt>other.size() <= capacity()</tt>.
+    //!
+    //! @brief Constructs a copy of other varray.
+    //!
+    //! @param other    The varray which content will be copied to this one.
+    //!
+    //! @par Throws
+    //!   If Value's copy constructor throws.
+    //! @internal
+    //!   @li If a throwing error handler is specified, throws when the capacity is exceeded. (not by default).
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    template <std::size_t C>
+    varray(varray<value_type, C> const& other)
+        : m_size(other.size())
+    {
+        errh::check_capacity(*this, other.size());                                  // may throw
+        
+        namespace sv = varray_detail;
+        sv::uninitialized_copy(other.begin(), other.end(), this->begin());          // may throw
+    }
+
+    //! @brief Copy assigns Values stored in the other varray to this one.
+    //!
+    //! @param other    The varray which content will be copied to this one.
+    //!
+    //! @par Throws
+    //!   If Value's copy constructor or copy assignment throws.
+    //!
+    //! @par Complexity
+    //! Linear O(N).
+    varray & operator=(BOOST_COPY_ASSIGN_REF(varray) other)
+    {
+        this->assign(other.begin(), other.end());                                     // may throw
+
+        return *this;
+    }
+
+    //! @pre <tt>other.size() <= capacity()</tt>
+    //!
+    //! @brief Copy assigns Values stored in the other varray to this one.
+    //!
+    //! @param other    The varray which content will be copied to this one.
+    //!
+    //! @par Throws
+    //!   If Value's copy constructor or copy assignment throws.
+    //! @internal
+    //!   @li If a throwing error handler is specified, throws when the capacity is exceeded. (not by default).
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    template <std::size_t C>
+    varray & operator=(BOOST_COPY_ASSIGN_REF_2_TEMPL_ARGS(varray, value_type, C) other)
+    {
+        this->assign(other.begin(), other.end());                                     // may throw
+
+        return *this;
+    }
+
+    //! @brief Move constructor. Moves Values stored in the other varray to this one.
+    //!
+    //! @param other    The varray which content will be moved to this one.
+    //!
+    //! @par Throws
+    //!   @li If \c boost::has_nothrow_move<Value>::value is \c true and Value's move constructor throws.
+    //!   @li If \c boost::has_nothrow_move<Value>::value is \c false and Value's copy constructor throws.
+    //! @internal
+    //!   @li It throws only if \c use_memop_in_swap_and_move is \c false_type - default.
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    varray(BOOST_RV_REF(varray) other)
+    {
+        typedef typename
+        vt::use_memop_in_swap_and_move use_memop_in_swap_and_move;
+
+        this->move_ctor_dispatch(other, use_memop_in_swap_and_move());
+    }
+
+    //! @pre <tt>other.size() <= capacity()</tt>
+    //!
+    //! @brief Move constructor. Moves Values stored in the other varray to this one.
+    //!
+    //! @param other    The varray which content will be moved to this one.
+    //!
+    //! @par Throws
+    //!   @li If \c boost::has_nothrow_move<Value>::value is \c true and Value's move constructor throws.
+    //!   @li If \c boost::has_nothrow_move<Value>::value is \c false and Value's copy constructor throws.
+    //! @internal
+    //!   @li It throws only if \c use_memop_in_swap_and_move is false_type - default.
+    //! @endinternal
+    //! @internal
+    //!   @li If a throwing error handler is specified, throws when the capacity is exceeded. (not by default).
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    template <std::size_t C>
+    varray(BOOST_RV_REF_2_TEMPL_ARGS(varray, value_type, C) other)
+        : m_size(other.m_size)
+    {
+        errh::check_capacity(*this, other.size());                                  // may throw
+
+        typedef typename
+        vt::use_memop_in_swap_and_move use_memop_in_swap_and_move;
+
+        this->move_ctor_dispatch(other, use_memop_in_swap_and_move());
+    }
+
+    //! @brief Move assignment. Moves Values stored in the other varray to this one.
+    //!
+    //! @param other    The varray which content will be moved to this one.
+    //!
+    //! @par Throws
+    //!   @li If \c boost::has_nothrow_move<Value>::value is \c true and Value's move constructor or move assignment throws.
+    //!   @li If \c boost::has_nothrow_move<Value>::value is \c false and Value's copy constructor or copy assignment throws.
+    //! @internal
+    //!   @li It throws only if \c use_memop_in_swap_and_move is \c false_type - default.
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    varray & operator=(BOOST_RV_REF(varray) other)
+    {
+        if ( &other == this )
+            return *this;
+
+        typedef typename
+        vt::use_memop_in_swap_and_move use_memop_in_swap_and_move;
+
+        this->move_assign_dispatch(other, use_memop_in_swap_and_move());
+
+        return *this;
+    }
+
+    //! @pre <tt>other.size() <= capacity()</tt>
+    //!
+    //! @brief Move assignment. Moves Values stored in the other varray to this one.
+    //!
+    //! @param other    The varray which content will be moved to this one.
+    //!
+    //! @par Throws
+    //!   @li If \c boost::has_nothrow_move<Value>::value is \c true and Value's move constructor or move assignment throws.
+    //!   @li If \c boost::has_nothrow_move<Value>::value is \c false and Value's copy constructor or copy assignment throws.
+    //! @internal
+    //!   @li It throws only if \c use_memop_in_swap_and_move is \c false_type - default.
+    //! @endinternal
+    //! @internal
+    //!   @li If a throwing error handler is specified, throws when the capacity is exceeded. (not by default).
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    template <std::size_t C>
+    varray & operator=(BOOST_RV_REF_2_TEMPL_ARGS(varray, value_type, C) other)
+    {
+        errh::check_capacity(*this, other.size());                                  // may throw
+
+        typedef typename
+        vt::use_memop_in_swap_and_move use_memop_in_swap_and_move;
+
+        this->move_assign_dispatch(other, use_memop_in_swap_and_move());
+
+        return *this;
+    }
+
+    //! @brief Destructor. Destroys Values stored in this container.
+    //!
+    //! @par Throws
+    //!   Nothing
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    ~varray()
+    {
+        namespace sv = varray_detail;
+        sv::destroy(this->begin(), this->end());
+    }
+
+    //! @brief Swaps contents of the other varray and this one.
+    //!
+    //! @param other    The varray which content will be swapped with this one's content.
+    //!
+    //! @par Throws
+    //!   @li If \c boost::has_nothrow_move<Value>::value is \c true and Value's move constructor or move assignment throws,
+    //!   @li If \c boost::has_nothrow_move<Value>::value is \c false and Value's copy constructor or copy assignment throws,
+    //! @internal
+    //!   @li It throws only if \c use_memop_in_swap_and_move and \c use_optimized_swap are \c false_type - default.
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    void swap(varray & other)
+    {
+        typedef typename
+        vt::use_optimized_swap use_optimized_swap;
+
+        this->swap_dispatch(other, use_optimized_swap());
+    }
+
+    //! @pre <tt>other.size() <= capacity() && size() <= other.capacity()</tt>
+    //!
+    //! @brief Swaps contents of the other varray and this one.
+    //!
+    //! @param other    The varray which content will be swapped with this one's content.
+    //!
+    //! @par Throws
+    //!   @li If \c boost::has_nothrow_move<Value>::value is \c true and Value's move constructor or move assignment throws,
+    //!   @li If \c boost::has_nothrow_move<Value>::value is \c false and Value's copy constructor or copy assignment throws,
+    //! @internal
+    //!   @li It throws only if \c use_memop_in_swap_and_move and \c use_optimized_swap are \c false_type - default.
+    //! @endinternal
+    //! @internal
+    //!   @li If a throwing error handler is specified, throws when the capacity is exceeded. (not by default).
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    template <std::size_t C>
+    void swap(varray<value_type, C> & other)
+    {
+        errh::check_capacity(*this, other.size());
+        errh::check_capacity(other, this->size());
+
+        typedef typename
+        vt::use_optimized_swap use_optimized_swap;
+
+        this->swap_dispatch(other, use_optimized_swap()); 
+    }
+
+    //! @pre <tt>count <= capacity()</tt>
+    //!
+    //! @brief Inserts or erases elements at the end such that
+    //!   the size becomes count. New elements are default constructed.
+    //!
+    //! @param count    The number of elements which will be stored in the container.
+    //!
+    //! @par Throws
+    //!   If Value's default constructor throws.
+    //! @internal
+    //!   @li If a throwing error handler is specified, throws when the capacity is exceeded. (not by default).
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    void resize(size_type count)
+    {
+        namespace sv = varray_detail;
+        typedef typename vt::disable_trivial_init dti;
+
+        if ( count < m_size )
+        {
+            sv::destroy(this->begin() + count, this->end());
+        }
+        else
+        {
+            errh::check_capacity(*this, count);                                     // may throw
+
+            sv::uninitialized_fill(this->end(), this->begin() + count, dti()); // may throw
+        }
+        m_size = count; // update end
+    }
+
+    //! @pre <tt>count <= capacity()</tt>
+    //!
+    //! @brief Inserts or erases elements at the end such that
+    //!   the size becomes count. New elements are copy constructed from value.
+    //!
+    //! @param count    The number of elements which will be stored in the container.
+    //! @param value    The value used to copy construct the new element.
+    //!
+    //! @par Throws
+    //!   If Value's copy constructor throws.
+    //! @internal
+    //!   @li If a throwing error handler is specified, throws when the capacity is exceeded. (not by default).
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    void resize(size_type count, value_type const& value)
+    {
+        if ( count < m_size )
+        {
+            namespace sv = varray_detail;
+            sv::destroy(this->begin() + count, this->end());
+        }
+        else
+        {
+            errh::check_capacity(*this, count);                                     // may throw
+            
+            std::uninitialized_fill(this->end(), this->begin() + count, value);     // may throw
+        }
+        m_size = count; // update end
+    }
+
+    //! @pre <tt>count <= capacity()</tt>
+    //!
+    //! @brief This call has no effect because the Capacity of this container is constant.
+    //!
+    //! @param count    The number of elements which the container should be able to contain.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //! @internal
+    //!   @li If a throwing error handler is specified, throws when the capacity is exceeded. (not by default).
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    void reserve(size_type count)
+    {
+        errh::check_capacity(*this, count);                                         // may throw
+    }
+
+    //! @pre <tt>size() < capacity()</tt>
+    //!
+    //! @brief Adds a copy of value at the end.
+    //!
+    //! @param value    The value used to copy construct the new element.
+    //!
+    //! @par Throws
+    //!   If Value's copy constructor throws.
+    //! @internal
+    //!   @li If a throwing error handler is specified, throws when the capacity is exceeded. (not by default).
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    void push_back(value_type const& value)
+    {
+        typedef typename vt::disable_trivial_init dti;
+
+        errh::check_capacity(*this, m_size + 1);                                    // may throw
+        
+        namespace sv = varray_detail;
+        sv::construct(dti(), this->end(), value);                                          // may throw
+        ++m_size; // update end
+    }
+
+    //! @pre <tt>size() < capacity()</tt>
+    //!
+    //! @brief Moves value to the end.
+    //!
+    //! @param value    The value to move construct the new element.
+    //!
+    //! @par Throws
+    //!   If Value's move constructor throws.
+    //! @internal
+    //!   @li If a throwing error handler is specified, throws when the capacity is exceeded. (not by default).
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    void push_back(BOOST_RV_REF(value_type) value)
+    {
+        typedef typename vt::disable_trivial_init dti;
+
+        errh::check_capacity(*this, m_size + 1);                                    // may throw
+
+        namespace sv = varray_detail;
+        sv::construct(dti(), this->end(), ::boost::move(value));                           // may throw
+        ++m_size; // update end
+    }
+
+    //! @pre <tt>!empty()</tt>
+    //!
+    //! @brief Destroys last value and decreases the size.
+    //!
+    //! @par Throws
+    //!   Nothing by default.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    void pop_back()
+    {
+        errh::check_not_empty(*this);
+
+        namespace sv = varray_detail;
+        sv::destroy(this->end() - 1);
+        --m_size; // update end
+    }
+
+    //! @pre
+    //!  @li \c position must be a valid iterator of \c *this in range <tt>[begin(), end()]</tt>.
+    //!  @li <tt>size() < capacity()</tt>
+    //!
+    //! @brief Inserts a copy of element at position.
+    //!
+    //! @param position    The position at which the new value will be inserted.
+    //! @param value       The value used to copy construct the new element.
+    //!
+    //! @par Throws
+    //!   @li If Value's copy constructor or copy assignment throws
+    //!   @li If Value's move constructor or move assignment throws.
+    //! @internal
+    //!   @li If a throwing error handler is specified, throws when the capacity is exceeded. (not by default).
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Constant or linear.
+    iterator insert(iterator position, value_type const& value)
+    {
+        typedef typename vt::disable_trivial_init dti;
+        namespace sv = varray_detail;
+
+        errh::check_iterator_end_eq(*this, position);
+        errh::check_capacity(*this, m_size + 1);                                    // may throw
+
+        if ( position == this->end() )
+        {
+            sv::construct(dti(), position, value);                                  // may throw
+            ++m_size; // update end
+        }
+        else
+        {
+            // TODO - should move be used only if it's nonthrowing?
+            value_type & r = *(this->end() - 1);
+            sv::construct(dti(), this->end(), boost::move(r));                      // may throw
+            ++m_size; // update end
+            sv::move_backward(position, this->end() - 2, this->end() - 1);          // may throw
+            sv::assign(position, value);                                            // may throw
+        }
+
+        return position;
+    }
+
+    //! @pre
+    //!  @li \c position must be a valid iterator of \c *this in range <tt>[begin(), end()]</tt>.
+    //!  @li <tt>size() < capacity()</tt>
+    //!
+    //! @brief Inserts a move-constructed element at position.
+    //!
+    //! @param position    The position at which the new value will be inserted.
+    //! @param value       The value used to move construct the new element.
+    //!
+    //! @par Throws
+    //!   If Value's move constructor or move assignment throws.
+    //! @internal
+    //!   @li If a throwing error handler is specified, throws when the capacity is exceeded. (not by default).
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Constant or linear.
+    iterator insert(iterator position, BOOST_RV_REF(value_type) value)
+    {
+        typedef typename vt::disable_trivial_init dti;
+        namespace sv = varray_detail;
+
+        errh::check_iterator_end_eq(*this, position);
+        errh::check_capacity(*this, m_size + 1);                                    // may throw
+
+        if ( position == this->end() )
+        {
+            sv::construct(dti(), position, boost::move(value));                     // may throw
+            ++m_size; // update end
+        }
+        else
+        {
+            // TODO - should move be used only if it's nonthrowing?
+            value_type & r = *(this->end() - 1);
+            sv::construct(dti(), this->end(), boost::move(r));                      // may throw
+            ++m_size; // update end
+            sv::move_backward(position, this->end() - 2, this->end() - 1);          // may throw
+            sv::assign(position, boost::move(value));                               // may throw
+        }
+
+        return position;
+    }
+
+    //! @pre
+    //!  @li \c position must be a valid iterator of \c *this in range <tt>[begin(), end()]</tt>.
+    //!  @li <tt>size() + count <= capacity()</tt>
+    //!
+    //! @brief Inserts a count copies of value at position.
+    //!
+    //! @param position    The position at which new elements will be inserted.
+    //! @param count       The number of new elements which will be inserted.
+    //! @param value       The value used to copy construct new elements.
+    //!
+    //! @par Throws
+    //!   @li If Value's copy constructor or copy assignment throws.
+    //!   @li If Value's move constructor or move assignment throws.
+    //! @internal
+    //!   @li If a throwing error handler is specified, throws when the capacity is exceeded. (not by default).
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    iterator insert(iterator position, size_type count, value_type const& value)
+    {
+        errh::check_iterator_end_eq(*this, position);
+        errh::check_capacity(*this, m_size + count);                                // may throw
+
+        if ( position == this->end() )
+        {
+            std::uninitialized_fill(position, position + count, value);             // may throw
+            m_size += count; // update end
+        }
+        else
+        {
+            namespace sv = varray_detail;
+
+            difference_type to_move = std::distance(position, this->end());
+            
+            // TODO - should following lines check for exception and revert to the old size?
+
+            if ( count < static_cast<size_type>(to_move) )
+            {
+                sv::uninitialized_move(this->end() - count, this->end(), this->end());          // may throw
+                m_size += count; // update end
+                sv::move_backward(position, position + to_move - count, this->end() - count);   // may throw
+                std::fill_n(position, count, value);                                            // may throw
+            }
+            else
+            {
+                std::uninitialized_fill(this->end(), position + count, value);                  // may throw
+                m_size += count - to_move; // update end
+                sv::uninitialized_move(position, position + to_move, position + count);         // may throw
+                m_size += to_move; // update end
+                std::fill_n(position, to_move, value);                                          // may throw
+            }
+        }
+
+        return position;
+    }
+
+    //! @pre
+    //!  @li \c position must be a valid iterator of \c *this in range <tt>[begin(), end()]</tt>.
+    //!  @li <tt>distance(first, last) <= capacity()</tt>
+    //!  @li \c Iterator must meet the \c ForwardTraversalIterator concept.
+    //!
+    //! @brief Inserts a copy of a range <tt>[first, last)</tt> at position.
+    //!
+    //! @param position    The position at which new elements will be inserted.
+    //! @param first       The iterator to the first element of a range used to construct new elements.
+    //! @param last        The iterator to the one after the last element of a range used to construct new elements.
+    //!
+    //! @par Throws
+    //!   @li If Value's constructor and assignment taking a dereferenced \c Iterator.
+    //!   @li If Value's move constructor or move assignment throws.
+    //! @internal
+    //!   @li If a throwing error handler is specified, throws when the capacity is exceeded. (not by default).
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    template <typename Iterator>
+    iterator insert(iterator position, Iterator first, Iterator last)
+    {
+        BOOST_CONCEPT_ASSERT((boost_concepts::ForwardTraversal<Iterator>)); // Make sure you passed a ForwardIterator
+
+        typedef typename boost::iterator_traversal<Iterator>::type traversal;
+        this->insert_dispatch(position, first, last, traversal());
+
+        return position;
+    }
+
+    //! @pre \c position must be a valid iterator of \c *this in range <tt>[begin(), end())</tt>
+    //!
+    //! @brief Erases Value from position.
+    //!
+    //! @param position    The position of the element which will be erased from the container.
+    //!
+    //! @par Throws
+    //!   If Value's move assignment throws.
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    iterator erase(iterator position)
+    {
+        namespace sv = varray_detail;
+
+        errh::check_iterator_end_neq(*this, position);
+
+        //TODO - add empty check?
+        //errh::check_empty(*this);
+
+        sv::move(position + 1, this->end(), position);                              // may throw
+        sv::destroy(this->end() - 1);
+        --m_size;
+
+        return position;
+    }
+
+    //! @pre
+    //!  @li \c first and \c last must define a valid range
+    //!  @li iterators must be in range <tt>[begin(), end()]</tt>
+    //!
+    //! @brief Erases Values from a range <tt>[first, last)</tt>.
+    //!
+    //! @param first    The position of the first element of a range which will be erased from the container.
+    //! @param last     The position of the one after the last element of a range which will be erased from the container.
+    //!
+    //! @par Throws
+    //!   If Value's move assignment throws.
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    iterator erase(iterator first, iterator last)
+    {
+        namespace sv = varray_detail;
+
+        errh::check_iterator_end_eq(*this, first);
+        errh::check_iterator_end_eq(*this, last);
+        
+        difference_type n = std::distance(first, last);
+        
+        //TODO - add invalid range check?
+        //BOOST_GEOMETRY_INDEX_ASSERT(0 <= n, "invalid range");
+        //TODO - add this->size() check?
+        //BOOST_GEOMETRY_INDEX_ASSERT(n <= this->size(), "invalid range");
+
+        sv::move(last, this->end(), first);                                         // may throw
+        sv::destroy(this->end() - n, this->end());
+        m_size -= n;
+
+        return first;
+    }
+
+    //! @pre <tt>distance(first, last) <= capacity()</tt>
+    //!
+    //! @brief Assigns a range <tt>[first, last)</tt> of Values to this container.
+    //!
+    //! @param first       The iterator to the first element of a range used to construct new content of this container.
+    //! @param last        The iterator to the one after the last element of a range used to construct new content of this container.
+    //!
+    //! @par Throws
+    //!   If Value's copy constructor or copy assignment throws,
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    template <typename Iterator>
+    void assign(Iterator first, Iterator last)
+    {
+        BOOST_CONCEPT_ASSERT((boost_concepts::ForwardTraversal<Iterator>)); // Make sure you passed a ForwardIterator
+
+        typedef typename boost::iterator_traversal<Iterator>::type traversal;
+        this->assign_dispatch(first, last, traversal());                            // may throw
+    }
+
+    //! @pre <tt>count <= capacity()</tt>
+    //!
+    //! @brief Assigns a count copies of value to this container.
+    //!
+    //! @param count       The new number of elements which will be container in the container.
+    //! @param value       The value which will be used to copy construct the new content.
+    //!
+    //! @par Throws
+    //!   If Value's copy constructor or copy assignment throws.
+    //!
+    //! @par Complexity
+    //!   Linear O(N).
+    void assign(size_type count, value_type const& value)
+    {
+        if ( count < m_size )
+        {
+            namespace sv = varray_detail;
+
+            std::fill_n(this->begin(), count, value);                               // may throw
+            sv::destroy(this->begin() + count, this->end());
+        }
+        else
+        {
+            errh::check_capacity(*this, count);                                     // may throw
+
+            std::fill_n(this->begin(), m_size, value);                              // may throw
+            std::uninitialized_fill(this->end(), this->begin() + count, value);     // may throw
+        }
+        m_size = count; // update end
+    }
+
+#if !defined(BOOST_CONTAINER_VARRAY_DISABLE_EMPLACE)
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+    //! @pre <tt>size() < capacity()</tt>
+    //!
+    //! @brief Inserts a Value constructed with
+    //!   \c std::forward<Args>(args)... in the end of the container.
+    //!
+    //! @param args     The arguments of the constructor of the new element which will be created at the end of the container.
+    //!
+    //! @par Throws
+    //!   If in-place constructor throws or Value's move constructor throws.
+    //! @internal
+    //!   @li If a throwing error handler is specified, throws when the capacity is exceeded. (not by default).
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    template<class ...Args>
+    void emplace_back(BOOST_FWD_REF(Args) ...args)
+    {
+        typedef typename vt::disable_trivial_init dti;
+
+        errh::check_capacity(*this, m_size + 1);                                    // may throw
+
+        namespace sv = varray_detail;
+        sv::construct(dti(), this->end(), ::boost::forward<Args>(args)...);                // may throw
+        ++m_size; // update end
+    }
+
+    //! @pre
+    //!  @li \c position must be a valid iterator of \c *this in range <tt>[begin(), end()]</tt>
+    //!  @li <tt>size() < capacity()</tt>
+    //!
+    //! @brief Inserts a Value constructed with
+    //!   \c std::forward<Args>(args)... before position
+    //!
+    //! @param position The position at which new elements will be inserted.
+    //! @param args     The arguments of the constructor of the new element.
+    //!
+    //! @par Throws
+    //!   If in-place constructor throws or if Value's move constructor or move assignment throws.
+    //! @internal
+    //!   @li If a throwing error handler is specified, throws when the capacity is exceeded. (not by default).
+    //! @endinternal
+    //!
+    //! @par Complexity
+    //!   Constant or linear.
+    template<class ...Args>
+    iterator emplace(iterator position, BOOST_FWD_REF(Args) ...args)
+    {
+        typedef typename vt::disable_trivial_init dti;
+
+        namespace sv = varray_detail;
+
+        errh::check_iterator_end_eq(*this, position);
+        errh::check_capacity(*this, m_size + 1);                                    // may throw
+
+        if ( position == this->end() )
+        {
+            sv::construct(dti(), position, ::boost::forward<Args>(args)...);               // may throw
+            ++m_size; // update end
+        }
+        else
+        {
+            // TODO - should following lines check for exception and revert to the old size?
+
+            // TODO - should move be used only if it's nonthrowing?
+            value_type & r = *(this->end() - 1);
+            sv::construct(dti(), this->end(), boost::move(r));                             // may throw
+            ++m_size; // update end
+            sv::move_backward(position, this->end() - 2, this->end() - 1);          // may throw
+
+            aligned_storage<sizeof(value_type), alignment_of<value_type>::value> temp_storage;
+            value_type * val_p = static_cast<value_type *>(temp_storage.address());
+            sv::construct(dti(), val_p, ::boost::forward<Args>(args)...);                  // may throw
+            sv::scoped_destructor<value_type> d(val_p);
+            sv::assign(position, ::boost::move(*val_p));                            // may throw
+        }
+
+        return position;
+    }
+
+#else // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+
+    #define BOOST_GEOMETRY_INDEX_DETAIL_VARRAY_EMPLACE(N)                                        \
+    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N                                   \
+    void emplace_back(BOOST_MOVE_UREF##N)                                                        \
+    {                                                                                            \
+        typedef typename vt::disable_trivial_init dti;                                           \
+                                                                                                 \
+        errh::check_capacity(*this, m_size + 1);                                    /*may throw*/\
+                                                                                                 \
+        namespace sv = varray_detail;                                                            \
+        sv::construct(dti(), this->end() BOOST_MOVE_I##N BOOST_MOVE_FWD##N );       /*may throw*/\
+        ++m_size; /*update end*/                                                                 \
+    }                                                                                            \
+    \
+    BOOST_MOVE_TMPL_LT##N BOOST_MOVE_CLASS##N BOOST_MOVE_GT##N                                      \
+    iterator emplace(iterator position BOOST_MOVE_I##N BOOST_MOVE_UREF##N)                          \
+    {                                                                                               \
+        typedef typename vt::disable_trivial_init dti;                                              \
+        namespace sv = varray_detail;                                                               \
+                                                                                                    \
+        errh::check_iterator_end_eq(*this, position);                                               \
+        errh::check_capacity(*this, m_size + 1);                                       /*may throw*/\
+                                                                                                    \
+        if ( position == this->end() )                                                              \
+        {                                                                                           \
+            sv::construct(dti(), position BOOST_MOVE_I##N BOOST_MOVE_FWD##N );         /*may throw*/\
+            ++m_size; /*update end*/                                                                \
+        }                                                                                           \
+        else                                                                                        \
+        {                                                                                           \
+            /* TODO - should following lines check for exception and revert to the old size? */     \
+            /* TODO - should move be used only if it's nonthrowing? */                              \
+                                                                                                    \
+            value_type & r = *(this->end() - 1);                                                    \
+            sv::construct(dti(), this->end(), boost::move(r));                         /*may throw*/\
+            ++m_size; /*update end*/                                                                \
+            sv::move_backward(position, this->end() - 2, this->end() - 1);             /*may throw*/\
+                                                                                                    \
+            aligned_storage<sizeof(value_type), alignment_of<value_type>::value> temp_storage;      \
+            value_type * val_p = static_cast<value_type *>(temp_storage.address());                 \
+            sv::construct(dti(), val_p BOOST_MOVE_I##N BOOST_MOVE_FWD##N );            /*may throw*/\
+            sv::scoped_destructor<value_type> d(val_p);                                             \
+            sv::assign(position, ::boost::move(*val_p));                               /*may throw*/\
+        }                                                                                           \
+                                                                                                    \
+        return position;                                                                            \
+    }                                                                                               \
+    
+    BOOST_MOVE_ITERATE_0TO9(BOOST_GEOMETRY_INDEX_DETAIL_VARRAY_EMPLACE)
+    #undef BOOST_GEOMETRY_INDEX_DETAIL_VARRAY_EMPLACE
+
+#endif // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+#endif // !BOOST_CONTAINER_VARRAY_DISABLE_EMPLACE
+
+    //! @brief Removes all elements from the container.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    void clear()
+    {
+        namespace sv = varray_detail;
+        sv::destroy(this->begin(), this->end());
+        m_size = 0; // update end
+    }
+
+    //! @pre <tt>i < size()</tt>
+    //!
+    //! @brief Returns reference to the i-th element.
+    //!
+    //! @param i    The element's index.
+    //!
+    //! @return reference to the i-th element
+    //!   from the beginning of the container.
+    //!
+    //! @par Throws
+    //!   \c std::out_of_range exception by default.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    reference at(size_type i)
+    {
+        errh::throw_out_of_bounds(*this, i);                                   // may throw
+        return *(this->begin() + i);
+    }
+
+    //! @pre <tt>i < size()</tt>
+    //!
+    //! @brief Returns const reference to the i-th element.
+    //!
+    //! @param i    The element's index.
+    //!
+    //! @return const reference to the i-th element
+    //!   from the beginning of the container.
+    //!
+    //! @par Throws
+    //!   \c std::out_of_range exception by default.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    const_reference at(size_type i) const
+    {
+        errh::throw_out_of_bounds(*this, i);                                   // may throw
+        return *(this->begin() + i);
+    }
+
+    //! @pre <tt>i < size()</tt>
+    //!
+    //! @brief Returns reference to the i-th element.
+    //!
+    //! @param i    The element's index.
+    //!
+    //! @return reference to the i-th element
+    //!   from the beginning of the container.
+    //!
+    //! @par Throws
+    //!   Nothing by default.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    reference operator[](size_type i)
+    {
+        // TODO: Remove bounds check? std::vector and std::array operator[] don't check.
+        errh::check_index(*this, i);
+        return *(this->begin() + i);
+    }
+
+    //! @pre <tt>i < size()</tt>
+    //!
+    //! @brief Returns const reference to the i-th element.
+    //!
+    //! @param i    The element's index.
+    //!
+    //! @return const reference to the i-th element
+    //!   from the beginning of the container.
+    //!
+    //! @par Throws
+    //!   Nothing by default.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    const_reference operator[](size_type i) const
+    {
+        errh::check_index(*this, i);
+        return *(this->begin() + i);
+    }
+
+    //! @pre \c !empty()
+    //!
+    //! @brief Returns reference to the first element.
+    //!
+    //! @return reference to the first element
+    //!   from the beginning of the container.
+    //!
+    //! @par Throws
+    //!   Nothing by default.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    reference front()
+    {
+        errh::check_not_empty(*this);
+        return *(this->begin());
+    }
+
+    //! @pre \c !empty()
+    //!
+    //! @brief Returns const reference to the first element.
+    //!
+    //! @return const reference to the first element
+    //!   from the beginning of the container.
+    //!
+    //! @par Throws
+    //!   Nothing by default.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    const_reference front() const
+    {
+        errh::check_not_empty(*this);
+        return *(this->begin());
+    }
+
+    //! @pre \c !empty()
+    //!
+    //! @brief Returns reference to the last element.
+    //!
+    //! @return reference to the last element
+    //!   from the beginning of the container.
+    //!
+    //! @par Throws
+    //!   Nothing by default.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    reference back()
+    {
+        errh::check_not_empty(*this);
+        return *(this->end() - 1);
+    }
+
+    //! @pre \c !empty()
+    //!
+    //! @brief Returns const reference to the first element.
+    //!
+    //! @return const reference to the last element
+    //!   from the beginning of the container.
+    //!
+    //! @par Throws
+    //!   Nothing by default.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    const_reference back() const
+    {
+        errh::check_not_empty(*this);
+        return *(this->end() - 1);
+    }
+
+    //! @brief Pointer such that <tt>[data(), data() + size())</tt> is a valid range.
+    //!   For a non-empty vector <tt>data() == &front()</tt>.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    Value * data()
+    {
+        return boost::addressof(*(this->ptr()));
+    }
+
+    //! @brief Const pointer such that <tt>[data(), data() + size())</tt> is a valid range.
+    //!   For a non-empty vector <tt>data() == &front()</tt>.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    const Value * data() const
+    {
+        return boost::addressof(*(this->ptr()));
+    }
+
+    
+    //! @brief Returns iterator to the first element.
+    //!
+    //! @return iterator to the first element contained in the vector.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    iterator begin() { return this->ptr(); }
+
+    //! @brief Returns const iterator to the first element.
+    //!
+    //! @return const_iterator to the first element contained in the vector.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    const_iterator begin() const { return this->ptr(); }
+
+    //! @brief Returns const iterator to the first element.
+    //!
+    //! @return const_iterator to the first element contained in the vector.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    const_iterator cbegin() const { return this->ptr(); }
+
+    //! @brief Returns iterator to the one after the last element.
+    //!
+    //! @return iterator pointing to the one after the last element contained in the vector.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    iterator end() { return this->begin() + m_size; }
+
+    //! @brief Returns const iterator to the one after the last element.
+    //!
+    //! @return const_iterator pointing to the one after the last element contained in the vector.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    const_iterator end() const { return this->begin() + m_size; }
+
+    //! @brief Returns const iterator to the one after the last element.
+    //!
+    //! @return const_iterator pointing to the one after the last element contained in the vector.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    const_iterator cend() const { return this->cbegin() + m_size; }
+
+    //! @brief Returns reverse iterator to the first element of the reversed container.
+    //!
+    //! @return reverse_iterator pointing to the beginning
+    //! of the reversed varray.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    reverse_iterator rbegin() { return reverse_iterator(this->end()); }
+
+    //! @brief Returns const reverse iterator to the first element of the reversed container.
+    //!
+    //! @return const_reverse_iterator pointing to the beginning
+    //! of the reversed varray.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    const_reverse_iterator rbegin() const { return const_reverse_iterator(this->end()); }
+
+    //! @brief Returns const reverse iterator to the first element of the reversed container.
+    //!
+    //! @return const_reverse_iterator pointing to the beginning
+    //! of the reversed varray.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    const_reverse_iterator crbegin() const { return const_reverse_iterator(this->end()); }
+
+    //! @brief Returns reverse iterator to the one after the last element of the reversed container.
+    //!
+    //! @return reverse_iterator pointing to the one after the last element
+    //! of the reversed varray.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    reverse_iterator rend() { return reverse_iterator(this->begin()); }
+
+    //! @brief Returns const reverse iterator to the one after the last element of the reversed container.
+    //!
+    //! @return const_reverse_iterator pointing to the one after the last element
+    //! of the reversed varray.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    const_reverse_iterator rend() const { return const_reverse_iterator(this->begin()); }
+
+    //! @brief Returns const reverse iterator to the one after the last element of the reversed container.
+    //!
+    //! @return const_reverse_iterator pointing to the one after the last element
+    //! of the reversed varray.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    const_reverse_iterator crend() const { return const_reverse_iterator(this->begin()); }
+
+    //! @brief Returns container's capacity.
+    //!
+    //! @return container's capacity.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    static size_type capacity() { return Capacity; }
+
+    //! @brief Returns container's capacity.
+    //!
+    //! @return container's capacity.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    static size_type max_size() { return Capacity; }
+
+    //! @brief Returns the number of stored elements.
+    //!
+    //! @return Number of elements contained in the container.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    size_type size() const { return m_size; }
+
+    //! @brief Queries if the container contains elements.
+    //!
+    //! @return true if the number of elements contained in the
+    //!   container is equal to 0.
+    //!
+    //! @par Throws
+    //!   Nothing.
+    //!
+    //! @par Complexity
+    //!   Constant O(1).
+    bool empty() const { return 0 == m_size; }
+
+private:
+
+    // @par Throws
+    //   Nothing.
+    // @par Complexity
+    //   Linear O(N).
+    template <std::size_t C>
+    void move_ctor_dispatch(varray<value_type, C> & other, boost::true_type /*use_memop*/)
+    {
+        ::memcpy(this->data(), other.data(), sizeof(Value) * other.m_size);
+        m_size = other.m_size;
+    }
+
+    // @par Throws
+    //   @li If boost::has_nothrow_move<Value>::value is true and Value's move constructor throws
+    //   @li If boost::has_nothrow_move<Value>::value is false and Value's copy constructor throws.
+    // @par Complexity
+    //   Linear O(N).
+    template <std::size_t C>
+    void move_ctor_dispatch(varray<value_type, C> & other, boost::false_type /*use_memop*/)
+    {
+        namespace sv = varray_detail;
+        sv::uninitialized_move_if_noexcept(other.begin(), other.end(), this->begin());                  // may throw
+        m_size = other.m_size;
+    }
+
+    // @par Throws
+    //   Nothing.
+    // @par Complexity
+    //   Linear O(N).
+    template <std::size_t C>
+    void move_assign_dispatch(varray<value_type, C> & other, boost::true_type /*use_memop*/)
+    {
+        this->clear();
+
+        ::memcpy(this->data(), other.data(), sizeof(Value) * other.m_size);
+        std::swap(m_size, other.m_size);
+    }
+
+    // @par Throws
+    //   @li If boost::has_nothrow_move<Value>::value is true and Value's move constructor or move assignment throws
+    //   @li If boost::has_nothrow_move<Value>::value is false and Value's copy constructor or move assignment throws.
+    // @par Complexity
+    //   Linear O(N).
+    template <std::size_t C>
+    void move_assign_dispatch(varray<value_type, C> & other, boost::false_type /*use_memop*/)
+    {
+        namespace sv = varray_detail;
+        if ( m_size <= static_cast<size_type>(other.size()) )
+        {
+            sv::move_if_noexcept(other.begin(), other.begin() + m_size, this->begin());             // may throw
+            // TODO - perform uninitialized_copy first?
+            sv::uninitialized_move_if_noexcept(other.begin() + m_size, other.end(), this->end());   // may throw
+        }
+        else
+        {
+            sv::move_if_noexcept(other.begin(), other.end(), this->begin());                        // may throw
+            sv::destroy(this->begin() + other.size(), this->end());
+        }
+        m_size = other.size(); // update end
+    }
+
+    // @par Throws
+    //   Nothing.
+    // @par Complexity
+    //   Linear O(N).
+    template <std::size_t C>
+    void swap_dispatch(varray<value_type, C> & other, boost::true_type const& /*use_optimized_swap*/)
+    {
+        typedef typename
+        boost::mpl::if_c<
+            Capacity < C,
+            aligned_storage_type,
+            typename varray<value_type, C>::aligned_storage_type
+        >::type
+        storage_type;
+        
+        storage_type temp;
+        Value * temp_ptr = reinterpret_cast<Value*>(temp.address());
+
+        ::memcpy(temp_ptr, this->data(), sizeof(Value) * this->size());
+        ::memcpy(this->data(), other.data(), sizeof(Value) * other.size());
+        ::memcpy(other.data(), temp_ptr, sizeof(Value) * this->size());
+
+        std::swap(m_size, other.m_size);
+    }
+
+    // @par Throws
+    //   If Value's move constructor or move assignment throws
+    //   but only if use_memop_in_swap_and_move is false_type - default.
+    // @par Complexity
+    //   Linear O(N).
+    template <std::size_t C>
+    void swap_dispatch(varray<value_type, C> & other, boost::false_type const& /*use_optimized_swap*/)
+    {
+        namespace sv = varray_detail;
+
+        typedef typename
+        vt::use_memop_in_swap_and_move use_memop_in_swap_and_move;
+
+        if ( this->size() < other.size() )
+            swap_dispatch_impl(this->begin(), this->end(), other.begin(), other.end(), use_memop_in_swap_and_move()); // may throw
+        else
+            swap_dispatch_impl(other.begin(), other.end(), this->begin(), this->end(), use_memop_in_swap_and_move()); // may throw
+        std::swap(m_size, other.m_size);
+    }
+
+    // @par Throws
+    //   Nothing.
+    // @par Complexity
+    //   Linear O(N).
+    void swap_dispatch_impl(iterator first_sm, iterator last_sm, iterator first_la, iterator last_la, boost::true_type const& /*use_memop*/)
+    {
+        //BOOST_GEOMETRY_INDEX_ASSERT(std::distance(first_sm, last_sm) <= std::distance(first_la, last_la),
+        //                            "incompatible ranges");
+
+        namespace sv = varray_detail;
+        for (; first_sm != last_sm ; ++first_sm, ++first_la)
+        {
+            boost::aligned_storage<
+                sizeof(value_type),
+                boost::alignment_of<value_type>::value
+            > temp_storage;
+            value_type * temp_ptr = reinterpret_cast<value_type*>(temp_storage.address());
+
+            ::memcpy(temp_ptr, boost::addressof(*first_sm), sizeof(value_type));
+            ::memcpy(boost::addressof(*first_sm), boost::addressof(*first_la), sizeof(value_type));
+            ::memcpy(boost::addressof(*first_la), temp_ptr, sizeof(value_type));
+        }
+
+        ::memcpy(first_sm, first_la, sizeof(value_type) * std::distance(first_la, last_la));
+    }
+
+    // @par Throws
+    //   If Value's move constructor or move assignment throws.
+    // @par Complexity
+    //   Linear O(N).
+    void swap_dispatch_impl(iterator first_sm, iterator last_sm, iterator first_la, iterator last_la, boost::false_type const& /*use_memop*/)
+    {
+        //BOOST_GEOMETRY_INDEX_ASSERT(std::distance(first_sm, last_sm) <= std::distance(first_la, last_la),
+        //                            "incompatible ranges");
+
+        namespace sv = varray_detail;
+        for (; first_sm != last_sm ; ++first_sm, ++first_la)
+        {
+            //boost::swap(*first_sm, *first_la);                                    // may throw
+            value_type temp(boost::move(*first_sm));                                // may throw
+            *first_sm = boost::move(*first_la);                                     // may throw
+            *first_la = boost::move(temp);                                          // may throw
+        }
+        sv::uninitialized_move(first_la, last_la, first_sm);                        // may throw
+        sv::destroy(first_la, last_la);
+    }
+
+    // insert
+
+    // @par Throws
+    //   If Value's move constructor, move assignment throws
+    //   or if Value's copy constructor or copy assignment throws.
+    // @par Complexity
+    //   Linear O(N).
+    template <typename Iterator>
+    void insert_dispatch(iterator position, Iterator first, Iterator last, boost::random_access_traversal_tag const&)
+    {
+        BOOST_CONCEPT_ASSERT((boost_concepts::RandomAccessTraversal<Iterator>)); // Make sure you passed a RandomAccessIterator
+        
+        errh::check_iterator_end_eq(*this, position);
+        
+        typename boost::iterator_difference<Iterator>::type
+            count = std::distance(first, last);
+
+        errh::check_capacity(*this, m_size + count);                                             // may throw
+
+        if ( position == this->end() )
+        {
+            namespace sv = varray_detail;
+
+            sv::uninitialized_copy(first, last, position);                                      // may throw
+            m_size += count; // update end
+        }
+        else
+        {
+            this->insert_in_the_middle(position, first, last, count);                           // may throw
+        }
+    }
+
+    // @par Throws
+    //   If Value's move constructor, move assignment throws
+    //   or if Value's copy constructor or copy assignment throws.
+    // @par Complexity
+    //   Linear O(N).
+    template <typename Iterator, typename Traversal>
+    void insert_dispatch(iterator position, Iterator first, Iterator last, Traversal const& /*not_random_access*/)
+    {
+        errh::check_iterator_end_eq(*this, position);
+
+        if ( position == this->end() )
+        {
+            namespace sv = varray_detail;
+
+            std::ptrdiff_t d = std::distance(position, this->begin() + Capacity);
+            std::size_t count = sv::uninitialized_copy_s(first, last, position, d);                     // may throw
+            
+            errh::check_capacity(*this, count <= static_cast<std::size_t>(d) ? m_size + count : Capacity + 1);  // may throw
+
+            m_size += count;
+        }
+        else
+        {
+            typename boost::iterator_difference<Iterator>::type
+                count = std::distance(first, last);
+            
+            errh::check_capacity(*this, m_size + count);                                                // may throw
+
+            this->insert_in_the_middle(position, first, last, count);                                   // may throw
+        }
+    }
+
+    // @par Throws
+    //   If Value's move constructor, move assignment throws
+    //   or if Value's copy constructor or copy assignment throws.
+    // @par Complexity
+    //   Linear O(N).
+    template <typename Iterator>
+    void insert_in_the_middle(iterator position, Iterator first, Iterator last, difference_type count)
+    {
+        namespace sv = varray_detail;
+
+        difference_type to_move = std::distance(position, this->end());
+
+        // TODO - should following lines check for exception and revert to the old size?
+
+        if ( count < to_move )
+        {
+            sv::uninitialized_move(this->end() - count, this->end(), this->end());              // may throw
+            m_size += count; // update end
+            sv::move_backward(position, position + to_move - count, this->end() - count);       // may throw
+            sv::copy(first, last, position);                                                    // may throw
+        }
+        else
+        {
+            Iterator middle_iter = first;
+            std::advance(middle_iter, to_move);
+
+            sv::uninitialized_copy(middle_iter, last, this->end());                             // may throw
+            m_size += count - to_move; // update end
+            sv::uninitialized_move(position, position + to_move, position + count);             // may throw
+            m_size += to_move; // update end
+            sv::copy(first, middle_iter, position);                                             // may throw
+        }
+    }
+
+    // assign
+
+    // @par Throws
+    //   If Value's constructor or assignment taking dereferenced Iterator throws.
+    // @par Complexity
+    //   Linear O(N).
+    template <typename Iterator>
+    void assign_dispatch(Iterator first, Iterator last, boost::random_access_traversal_tag const& /*not_random_access*/)
+    {
+        namespace sv = varray_detail;
+
+        typename boost::iterator_difference<Iterator>::type
+            s = std::distance(first, last);
+
+        errh::check_capacity(*this, s);                                     // may throw
+
+        if ( m_size <= static_cast<size_type>(s) )
+        {
+            sv::copy(first, first + m_size, this->begin());                 // may throw
+            // TODO - perform uninitialized_copy first?
+            sv::uninitialized_copy(first + m_size, last, this->end());      // may throw
+        }
+        else
+        {
+            sv::copy(first, last, this->begin());                           // may throw
+            sv::destroy(this->begin() + s, this->end());
+        }
+        m_size = s; // update end
+    }
+
+    // @par Throws
+    //   If Value's constructor or assignment taking dereferenced Iterator throws.
+    // @par Complexity
+    //   Linear O(N).
+    template <typename Iterator, typename Traversal>
+    void assign_dispatch(Iterator first, Iterator last, Traversal const& /*not_random_access*/)
+    {
+        namespace sv = varray_detail;
+
+        size_type s = 0;
+        iterator it = this->begin();
+
+        for ( ; it != this->end() && first != last ; ++it, ++first, ++s )
+            *it = *first;                                                                                   // may throw
+
+        sv::destroy(it, this->end());
+
+        std::ptrdiff_t d = std::distance(it, this->begin() + Capacity);
+        std::size_t count = sv::uninitialized_copy_s(first, last, it, d);                                   // may throw
+        s += count;
+
+        errh::check_capacity(*this, count <= static_cast<std::size_t>(d) ? s : Capacity + 1);               // may throw
+
+        m_size = s; // update end
+    }
+
+    pointer ptr()
+    {
+        return pointer(static_cast<Value*>(m_storage.address()));
+    }
+
+    const_pointer ptr() const
+    {
+        return const_pointer(static_cast<const Value*>(m_storage.address()));
+    }
+
+    size_type m_size;
+    aligned_storage_type m_storage;
+};
+
+#if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+
+template<typename Value>
+class varray<Value, 0>
+{
+    typedef varray_detail::varray_traits<Value, 0> vt;
+    typedef varray_detail::checker<varray> errh;
+
+public:
+    typedef typename vt::value_type value_type;
+    typedef typename vt::size_type size_type;
+    typedef typename vt::difference_type difference_type;
+    typedef typename vt::pointer pointer;
+    typedef typename vt::const_pointer const_pointer;
+    typedef typename vt::reference reference;
+    typedef typename vt::const_reference const_reference;
+
+    typedef pointer iterator;
+    typedef const_pointer const_iterator;
+    typedef boost::reverse_iterator<iterator> reverse_iterator;
+    typedef boost::reverse_iterator<const_iterator> const_reverse_iterator;
+
+    // nothrow
+    varray() {}
+
+    // strong
+    explicit varray(size_type count)
+    {
+        errh::check_capacity(*this, count);                                         // may throw
+    }
+
+    // strong
+    varray(size_type count, value_type const&)
+    {
+        errh::check_capacity(*this, count);                                         // may throw
+    }
+
+    // strong
+    varray(varray const& /*other*/)
+    {
+        //errh::check_capacity(*this, count);
+    }
+
+    // strong
+    template <std::size_t C>
+    varray(varray<value_type, C> const& other)
+    {
+        errh::check_capacity(*this, other.size());                                  // may throw
+    }
+
+    // strong
+    template <typename Iterator>
+    varray(Iterator first, Iterator last)
+    {
+        errh::check_capacity(*this, std::distance(first, last));                    // may throw
+    }
+
+    // basic
+    varray & operator=(varray const& /*other*/)
+    {
+        //errh::check_capacity(*this, other.size());
+        return *this;
+    }
+
+    // basic
+    template <size_t C>
+    varray & operator=(varray<value_type, C> const& other)
+    {
+        errh::check_capacity(*this, other.size());                                  // may throw
+        return *this;
+    }
+
+    // nothrow
+    ~varray() {}
+
+    // strong
+    void resize(size_type count)
+    {
+        errh::check_capacity(*this, count);                                         // may throw
+    }
+
+    // strong
+    void resize(size_type count, value_type const&)
+    {
+        errh::check_capacity(*this, count);                                         // may throw
+    }
+
+    
+    // nothrow
+    void reserve(size_type count)
+    {
+        errh::check_capacity(*this, count);                                         // may throw
+    }
+
+    // strong
+    void push_back(value_type const&)
+    {
+        errh::check_capacity(*this, 1);                                             // may throw
+    }
+
+    // nothrow
+    void pop_back()
+    {
+        errh::check_not_empty(*this);
+    }
+
+    // basic
+    void insert(iterator position, value_type const&)
+    {
+        errh::check_iterator_end_eq(*this, position);
+        errh::check_capacity(*this, 1);                                             // may throw
+    }
+
+    // basic
+    void insert(iterator position, size_type count, value_type const&)
+    {
+        errh::check_iterator_end_eq(*this, position);
+        errh::check_capacity(*this, count);                                         // may throw
+    }
+
+    // basic
+    template <typename Iterator>
+    void insert(iterator, Iterator first, Iterator last)
+    {
+        // TODO - add MPL_ASSERT, check if Iterator is really an iterator
+        errh::check_capacity(*this, std::distance(first, last));                    // may throw
+    }
+
+    // basic
+    void erase(iterator position)
+    {
+        errh::check_iterator_end_neq(*this, position);
+    }
+
+    // basic
+    void erase(iterator first, iterator last)
+    {
+        errh::check_iterator_end_eq(*this, first);
+        errh::check_iterator_end_eq(*this, last);
+
+        //BOOST_GEOMETRY_INDEX_ASSERT(0 <= n, "invalid range");
+    }
+
+    // basic
+    template <typename Iterator>
+    void assign(Iterator first, Iterator last)
+    {
+        // TODO - add MPL_ASSERT, check if Iterator is really an iterator
+        errh::check_capacity(*this, std::distance(first, last));                    // may throw
+    }
+
+    // basic
+    void assign(size_type count, value_type const&)
+    {
+        errh::check_capacity(*this, count);                                     // may throw
+    }
+
+    // nothrow
+    void clear() {}
+
+    // strong
+    reference at(size_type i)
+    {
+        errh::throw_out_of_bounds(*this, i);                                   // may throw
+        return *(this->begin() + i);
+    }
+
+    // strong
+    const_reference at(size_type i) const
+    {
+        errh::throw_out_of_bounds(*this, i);                                   // may throw
+        return *(this->begin() + i);
+    }
+
+    // nothrow
+    reference operator[](size_type i)
+    {
+        errh::check_index(*this, i);
+        return *(this->begin() + i);
+    }
+
+    // nothrow
+    const_reference operator[](size_type i) const
+    {
+        errh::check_index(*this, i);
+        return *(this->begin() + i);
+    }
+
+    // nothrow
+    reference front()
+    {
+        errh::check_not_empty(*this);
+        return *(this->begin());
+    }
+
+    // nothrow
+    const_reference front() const
+    {
+        errh::check_not_empty(*this);
+        return *(this->begin());
+    }
+
+    // nothrow
+    reference back()
+    {
+        errh::check_not_empty(*this);
+        return *(this->end() - 1);
+    }
+
+    // nothrow
+    const_reference back() const
+    {
+        errh::check_not_empty(*this);
+        return *(this->end() - 1);
+    }
+
+    // nothrow
+    Value * data() { return boost::addressof(*(this->ptr())); }
+    const Value * data() const { return boost::addressof(*(this->ptr())); }
+
+    // nothrow
+    iterator begin() { return this->ptr(); }
+    const_iterator begin() const { return this->ptr(); }
+    const_iterator cbegin() const { return this->ptr(); }
+    iterator end() { return this->begin(); }
+    const_iterator end() const { return this->begin(); }
+    const_iterator cend() const { return this->cbegin(); }
+    // nothrow
+    reverse_iterator rbegin() { return reverse_iterator(this->end()); }
+    const_reverse_iterator rbegin() const { return reverse_iterator(this->end()); }
+    const_reverse_iterator crbegin() const { return reverse_iterator(this->end()); }
+    reverse_iterator rend() { return reverse_iterator(this->begin()); }
+    const_reverse_iterator rend() const { return reverse_iterator(this->begin()); }
+    const_reverse_iterator crend() const { return reverse_iterator(this->begin()); }
+
+    // nothrow
+    size_type capacity() const { return 0; }
+    size_type max_size() const { return 0; }
+    size_type size() const { return 0; }
+    bool empty() const { return true; }
+
+private:
+    pointer ptr()
+    {
+        return pointer(reinterpret_cast<Value*>(this));
+    }
+
+    const_pointer ptr() const
+    {
+        return const_pointer(reinterpret_cast<const Value*>(this));
+    }
+};
+
+#endif // !BOOST_CONTAINER_DOXYGEN_INVOKED
+
+//! @brief Checks if contents of two varrays are equal.
+//!
+//! @ingroup varray_non_member
+//!
+//! @param x    The first varray.
+//! @param y    The second varray.
+//!
+//! @return     \c true if containers have the same size and elements in both containers are equal.
+//!
+//! @par Complexity
+//!   Linear O(N).
+template<typename V, std::size_t C1, std::size_t C2>
+bool operator== (varray<V, C1> const& x, varray<V, C2> const& y)
+{
+    return x.size() == y.size() && std::equal(x.begin(), x.end(), y.begin());
+}
+
+//! @brief Checks if contents of two varrays are not equal.
+//!
+//! @ingroup varray_non_member
+//!
+//! @param x    The first varray.
+//! @param y    The second varray.
+//!
+//! @return     \c true if containers have different size or elements in both containers are not equal.
+//!
+//! @par Complexity
+//!   Linear O(N).
+template<typename V, std::size_t C1, std::size_t C2>
+bool operator!= (varray<V, C1> const& x, varray<V, C2> const& y)
+{
+    return !(x==y);
+}
+
+//! @brief Lexicographically compares varrays.
+//!
+//! @ingroup varray_non_member
+//!
+//! @param x    The first varray.
+//! @param y    The second varray.
+//!
+//! @return     \c true if x compares lexicographically less than y.
+//!
+//! @par Complexity
+//!   Linear O(N).
+template<typename V, std::size_t C1, std::size_t C2>
+bool operator< (varray<V, C1> const& x, varray<V, C2> const& y)
+{
+    return std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end());
+}
+
+//! @brief Lexicographically compares varrays.
+//!
+//! @ingroup varray_non_member
+//!
+//! @param x    The first varray.
+//! @param y    The second varray.
+//!
+//! @return     \c true if y compares lexicographically less than x.
+//!
+//! @par Complexity
+//!   Linear O(N).
+template<typename V, std::size_t C1, std::size_t C2>
+bool operator> (varray<V, C1> const& x, varray<V, C2> const& y)
+{
+    return y<x;
+}
+
+//! @brief Lexicographically compares varrays.
+//!
+//! @ingroup varray_non_member
+//!
+//! @param x    The first varray.
+//! @param y    The second varray.
+//!
+//! @return     \c true if y don't compare lexicographically less than x.
+//!
+//! @par Complexity
+//!   Linear O(N).
+template<typename V, std::size_t C1, std::size_t C2>
+bool operator<= (varray<V, C1> const& x, varray<V, C2> const& y)
+{
+    return !(y<x);
+}
+
+//! @brief Lexicographically compares varrays.
+//!
+//! @ingroup varray_non_member
+//!
+//! @param x    The first varray.
+//! @param y    The second varray.
+//!
+//! @return     \c true if x don't compare lexicographically less than y.
+//!
+//! @par Complexity
+//!   Linear O(N).
+template<typename V, std::size_t C1, std::size_t C2>
+bool operator>= (varray<V, C1> const& x, varray<V, C2> const& y)
+{
+    return !(x<y);
+}
+
+//! @brief Swaps contents of two varrays.
+//!
+//! This function calls varray::swap().
+//!
+//! @ingroup varray_non_member
+//!
+//! @param x    The first varray.
+//! @param y    The second varray.
+//!
+//! @par Complexity
+//!   Linear O(N).
+template<typename V, std::size_t C1, std::size_t C2>
+inline void swap(varray<V, C1> & x, varray<V, C2> & y)
+{
+    x.swap(y);
+}
+
+}}}} // namespace boost::geometry::index::detail
+
+// TODO - REMOVE/CHANGE
+#include <boost/container/detail/config_end.hpp>
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_VARRAY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/varray_detail.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/varray_detail.hpp
new file mode 100644
index 00000000000..31b77c40fed
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/detail/varray_detail.hpp
@@ -0,0 +1,760 @@
+// Boost.Geometry
+//
+// varray details
+//
+// Copyright (c) 2012-2015 Adam Wulkiewicz, Lodz, Poland.
+// Copyright (c) 2011-2013 Andrew Hundt.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_VARRAY_DETAIL_HPP
+#define BOOST_GEOMETRY_INDEX_DETAIL_VARRAY_DETAIL_HPP
+
+#include <cstddef>
+#include <cstring>
+#include <memory>
+#include <limits>
+
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/mpl/int.hpp>
+
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/has_trivial_assign.hpp>
+#include <boost/type_traits/has_trivial_copy.hpp>
+#include <boost/type_traits/has_trivial_constructor.hpp>
+#include <boost/type_traits/has_trivial_destructor.hpp>
+#include <boost/type_traits/has_trivial_move_constructor.hpp>
+#include <boost/type_traits/has_trivial_move_assign.hpp>
+//#include <boost/type_traits/has_nothrow_constructor.hpp>
+//#include <boost/type_traits/has_nothrow_copy.hpp>
+//#include <boost/type_traits/has_nothrow_assign.hpp>
+//#include <boost/type_traits/has_nothrow_destructor.hpp>
+
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/config.hpp>
+#include <boost/move/move.hpp>
+#include <boost/core/addressof.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#include <boost/move/detail/fwd_macros.hpp>
+#endif
+
+// TODO - move vectors iterators optimization to the other, optional file instead of checking defines?
+
+#if defined(BOOST_GEOMETRY_INDEX_DETAIL_VARRAY_ENABLE_VECTOR_OPTIMIZATION) && !defined(BOOST_NO_EXCEPTIONS)
+#include <vector>
+#include <boost/container/vector.hpp>
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_VARRAY_ENABLE_VECTOR_OPTIMIZATION && !BOOST_NO_EXCEPTIONS
+
+namespace boost { namespace geometry { namespace index { namespace detail { namespace varray_detail {
+
+template <typename I>
+struct are_elements_contiguous : boost::is_pointer<I>
+{};
+    
+// EXPERIMENTAL - not finished
+// Conditional setup - mark vector iterators defined in known implementations
+// as iterators pointing to contiguous ranges
+
+#if defined(BOOST_GEOMETRY_INDEX_DETAIL_VARRAY_ENABLE_VECTOR_OPTIMIZATION) && !defined(BOOST_NO_EXCEPTIONS)
+    
+template <typename Pointer>
+struct are_elements_contiguous<
+    boost::container::container_detail::vector_const_iterator<Pointer>
+> : boost::true_type
+{};
+
+template <typename Pointer>
+struct are_elements_contiguous<
+    boost::container::container_detail::vector_iterator<Pointer>
+> : boost::true_type
+{};
+
+#if defined(BOOST_DINKUMWARE_STDLIB)
+    
+template <typename T>
+struct are_elements_contiguous<
+    std::_Vector_const_iterator<T>
+> : boost::true_type
+{};
+
+template <typename T>
+struct are_elements_contiguous<
+    std::_Vector_iterator<T>
+> : boost::true_type
+{};
+
+#elif defined(BOOST_GNU_STDLIB)
+
+template <typename P, typename T, typename A>
+struct are_elements_contiguous<
+    __gnu_cxx::__normal_iterator<P, std::vector<T, A> >
+> : boost::true_type
+{};
+
+#elif defined(_LIBCPP_VERSION)
+
+// TODO - test it first
+//template <typename P>
+//struct are_elements_contiguous<
+//    __wrap_iter<P>
+//> : boost::true_type
+//{};
+
+#else // OTHER_STDLIB
+
+// TODO - add other iterators implementations
+    
+#endif // STDLIB
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_VARRAY_ENABLE_VECTOR_OPTIMIZATION && !BOOST_NO_EXCEPTIONS
+
+// True if iterator values are the same and both iterators points to the ranges of contiguous elements
+
+template <typename I, typename O>
+struct are_corresponding :
+    ::boost::mpl::and_<
+        ::boost::is_same<
+            ::boost::remove_const<
+                typename ::boost::iterator_value<I>::type
+            >,
+            ::boost::remove_const<
+                typename ::boost::iterator_value<O>::type
+            >
+        >,
+        are_elements_contiguous<I>,
+        are_elements_contiguous<O>
+    >
+{};
+
+template <typename I, typename V>
+struct is_corresponding_value :
+    ::boost::is_same<
+        ::boost::remove_const<
+            typename ::boost::iterator_value<I>::type
+        >,
+        ::boost::remove_const<V>
+    >
+{};
+
+// destroy(I, I)
+
+template <typename I>
+void destroy_dispatch(I /*first*/, I /*last*/,
+                      boost::true_type const& /*has_trivial_destructor*/)
+{}
+
+template <typename I>
+void destroy_dispatch(I first, I last,
+                      boost::false_type const& /*has_trivial_destructor*/)
+{
+    typedef typename boost::iterator_value<I>::type value_type;
+    for ( ; first != last ; ++first )
+        first->~value_type();
+}
+
+template <typename I>
+void destroy(I first, I last)
+{
+    typedef typename boost::iterator_value<I>::type value_type;
+    destroy_dispatch(first, last, has_trivial_destructor<value_type>());
+}
+
+// destroy(I)
+
+template <typename I>
+void destroy_dispatch(I /*pos*/,
+                      boost::true_type const& /*has_trivial_destructor*/)
+{}
+
+template <typename I>
+void destroy_dispatch(I pos,
+                      boost::false_type const& /*has_trivial_destructor*/)
+{
+    typedef typename boost::iterator_value<I>::type value_type;
+    pos->~value_type();
+}
+
+template <typename I>
+void destroy(I pos)
+{
+    typedef typename boost::iterator_value<I>::type value_type;
+    destroy_dispatch(pos, has_trivial_destructor<value_type>());
+}
+
+// copy(I, I, O)
+
+template <typename I, typename O>
+inline O copy_dispatch(I first, I last, O dst,
+                       boost::mpl::bool_<true> const& /*use_memmove*/)
+{
+    typedef typename boost::iterator_value<I>::type value_type;
+    typename boost::iterator_difference<I>::type d = std::distance(first, last);
+
+    ::memmove(boost::addressof(*dst), boost::addressof(*first), sizeof(value_type) * d);
+    return dst + d;
+}
+
+template <typename I, typename O>
+inline O copy_dispatch(I first, I last, O dst,
+                       boost::mpl::bool_<false> const& /*use_memmove*/)
+{
+    return std::copy(first, last, dst);                                         // may throw
+}
+
+template <typename I, typename O>
+inline O copy(I first, I last, O dst)
+{
+    typedef typename
+    ::boost::mpl::and_<
+        are_corresponding<I, O>,
+        ::boost::has_trivial_assign<
+            typename ::boost::iterator_value<O>::type
+        >
+    >::type
+    use_memmove;
+    
+    return copy_dispatch(first, last, dst, use_memmove());                       // may throw
+}
+
+// uninitialized_copy(I, I, O)
+
+template <typename I, typename O>
+inline
+O uninitialized_copy_dispatch(I first, I last, O dst,
+                              boost::mpl::bool_<true> const& /*use_memcpy*/)
+{
+    typedef typename boost::iterator_value<I>::type value_type;
+    typename boost::iterator_difference<I>::type d = std::distance(first, last);
+
+    ::memcpy(boost::addressof(*dst), boost::addressof(*first), sizeof(value_type) * d);
+    return dst + d;
+}
+
+template <typename I, typename F>
+inline
+F uninitialized_copy_dispatch(I first, I last, F dst,
+                              boost::mpl::bool_<false> const& /*use_memcpy*/)
+{
+    return std::uninitialized_copy(first, last, dst);                                       // may throw
+}
+
+template <typename I, typename F>
+inline
+F uninitialized_copy(I first, I last, F dst)
+{
+    typedef typename
+    ::boost::mpl::and_<
+        are_corresponding<I, F>,
+        ::boost::has_trivial_copy<
+            typename ::boost::iterator_value<F>::type
+        >
+    >::type
+    use_memcpy;
+
+    return uninitialized_copy_dispatch(first, last, dst, use_memcpy());          // may throw
+}
+
+// uninitialized_move(I, I, O)
+
+template <typename I, typename O>
+inline
+O uninitialized_move_dispatch(I first, I last, O dst,
+                              boost::mpl::bool_<true> const& /*use_memcpy*/)
+{
+    typedef typename boost::iterator_value<I>::type value_type;
+    typename boost::iterator_difference<I>::type d = std::distance(first, last);
+
+    ::memcpy(boost::addressof(*dst), boost::addressof(*first), sizeof(value_type) * d);
+    return dst + d;
+}
+
+template <typename I, typename O>
+inline
+O uninitialized_move_dispatch(I first, I last, O dst,
+                              boost::mpl::bool_<false> const& /*use_memcpy*/)
+{
+    //return boost::uninitialized_move(first, last, dst);                         // may throw
+
+    O o = dst;
+
+    BOOST_TRY
+    {
+        typedef typename std::iterator_traits<O>::value_type value_type;
+        for (; first != last; ++first, ++o )
+            new (boost::addressof(*o)) value_type(boost::move(*first));
+    }
+    BOOST_CATCH(...)
+    {
+        destroy(dst, o);
+        BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+
+    return dst;
+}
+
+template <typename I, typename O>
+inline
+O uninitialized_move(I first, I last, O dst)
+{
+    typedef typename
+    ::boost::mpl::and_<
+        are_corresponding<I, O>,
+        ::boost::has_trivial_copy<
+            typename ::boost::iterator_value<O>::type
+        >
+    >::type
+    use_memcpy;
+
+    return uninitialized_move_dispatch(first, last, dst, use_memcpy());         // may throw
+}
+
+// TODO - move uses memmove - implement 2nd version using memcpy?
+
+// move(I, I, O)
+
+template <typename I, typename O>
+inline
+O move_dispatch(I first, I last, O dst,
+                boost::mpl::bool_<true> const& /*use_memmove*/)
+{
+    typedef typename boost::iterator_value<I>::type value_type;
+    typename boost::iterator_difference<I>::type d = std::distance(first, last);
+
+    ::memmove(boost::addressof(*dst), boost::addressof(*first), sizeof(value_type) * d);
+    return dst + d;
+}
+
+template <typename I, typename O>
+inline
+O move_dispatch(I first, I last, O dst,
+                boost::mpl::bool_<false> const& /*use_memmove*/)
+{
+    return boost::move(first, last, dst);                                         // may throw
+}
+
+template <typename I, typename O>
+inline
+O move(I first, I last, O dst)
+{
+    typedef typename
+    ::boost::mpl::and_<
+        are_corresponding<I, O>,
+        ::boost::has_trivial_assign<
+            typename ::boost::iterator_value<O>::type
+        >
+    >::type
+    use_memmove;
+
+    return move_dispatch(first, last, dst, use_memmove());                      // may throw
+}
+
+// move_backward(BDI, BDI, BDO)
+
+template <typename BDI, typename BDO>
+inline
+BDO move_backward_dispatch(BDI first, BDI last, BDO dst,
+                           boost::mpl::bool_<true> const& /*use_memmove*/)
+{
+    typedef typename boost::iterator_value<BDI>::type value_type;
+    typename boost::iterator_difference<BDI>::type d = std::distance(first, last);
+
+    BDO foo(dst - d);
+    ::memmove(boost::addressof(*foo), boost::addressof(*first), sizeof(value_type) * d);
+    return foo;
+}
+
+template <typename BDI, typename BDO>
+inline
+BDO move_backward_dispatch(BDI first, BDI last, BDO dst,
+                           boost::mpl::bool_<false> const& /*use_memmove*/)
+{
+    return boost::move_backward(first, last, dst);                                // may throw
+}
+
+template <typename BDI, typename BDO>
+inline
+BDO move_backward(BDI first, BDI last, BDO dst)
+{
+    typedef typename
+    ::boost::mpl::and_<
+        are_corresponding<BDI, BDO>,
+        ::boost::has_trivial_assign<
+            typename ::boost::iterator_value<BDO>::type
+        >
+    >::type
+    use_memmove;
+
+    return move_backward_dispatch(first, last, dst, use_memmove());             // may throw
+}
+
+template <typename T>
+struct has_nothrow_move : public
+    ::boost::mpl::or_<
+        boost::mpl::bool_<
+            ::boost::has_nothrow_move<
+                typename ::boost::remove_const<T>::type
+            >::value
+        >,
+        boost::mpl::bool_<
+            ::boost::has_nothrow_move<T>::value
+        >
+    >
+{};
+
+// uninitialized_move_if_noexcept(I, I, O)
+
+template <typename I, typename O>
+inline
+O uninitialized_move_if_noexcept_dispatch(I first, I last, O dst, boost::mpl::bool_<true> const& /*use_move*/)
+{ return varray_detail::uninitialized_move(first, last, dst); }
+
+template <typename I, typename O>
+inline
+O uninitialized_move_if_noexcept_dispatch(I first, I last, O dst, boost::mpl::bool_<false> const& /*use_move*/)
+{ return varray_detail::uninitialized_copy(first, last, dst); }
+
+template <typename I, typename O>
+inline
+O uninitialized_move_if_noexcept(I first, I last, O dst)
+{
+    typedef typename has_nothrow_move<
+        typename ::boost::iterator_value<O>::type
+    >::type use_move;
+
+    return uninitialized_move_if_noexcept_dispatch(first, last, dst, use_move());         // may throw
+}
+
+// move_if_noexcept(I, I, O)
+
+template <typename I, typename O>
+inline
+O move_if_noexcept_dispatch(I first, I last, O dst, boost::mpl::bool_<true> const& /*use_move*/)
+{ return move(first, last, dst); }
+
+template <typename I, typename O>
+inline
+O move_if_noexcept_dispatch(I first, I last, O dst, boost::mpl::bool_<false> const& /*use_move*/)
+{ return copy(first, last, dst); }
+
+template <typename I, typename O>
+inline
+O move_if_noexcept(I first, I last, O dst)
+{
+    typedef typename has_nothrow_move<
+        typename ::boost::iterator_value<O>::type
+    >::type use_move;
+
+    return move_if_noexcept_dispatch(first, last, dst, use_move());         // may throw
+}
+
+// uninitialized_fill(I, I)
+
+template <typename I>
+inline
+void uninitialized_fill_dispatch(I /*first*/, I /*last*/,
+                                 boost::true_type const& /*has_trivial_constructor*/,
+                                 boost::true_type const& /*disable_trivial_init*/)
+{}
+
+template <typename I>
+inline
+void uninitialized_fill_dispatch(I first, I last,
+                                 boost::true_type const& /*has_trivial_constructor*/,
+                                 boost::false_type const& /*disable_trivial_init*/)
+{
+    typedef typename boost::iterator_value<I>::type value_type;
+    for ( ; first != last ; ++first )
+        new (boost::addressof(*first)) value_type();
+}
+
+template <typename I, typename DisableTrivialInit>
+inline
+void uninitialized_fill_dispatch(I first, I last,
+                                 boost::false_type const& /*has_trivial_constructor*/,
+                                 DisableTrivialInit const& /*not_used*/)
+{
+    typedef typename boost::iterator_value<I>::type value_type;
+    I it = first;
+
+    BOOST_TRY
+    {
+        for ( ; it != last ; ++it )
+            new (boost::addressof(*it)) value_type();                           // may throw
+    }
+    BOOST_CATCH(...)
+    {
+        destroy(first, it);
+        BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+}
+
+template <typename I, typename DisableTrivialInit>
+inline
+void uninitialized_fill(I first, I last, DisableTrivialInit const& disable_trivial_init)
+{
+    typedef typename boost::iterator_value<I>::type value_type;
+    uninitialized_fill_dispatch(first, last, boost::has_trivial_constructor<value_type>(), disable_trivial_init);     // may throw
+}
+
+// construct(I)
+
+template <typename I>
+inline
+void construct_dispatch(boost::mpl::bool_<true> const& /*dont_init*/, I /*pos*/)
+{}
+
+template <typename I>
+inline
+void construct_dispatch(boost::mpl::bool_<false> const& /*dont_init*/, I pos)
+{
+    typedef typename ::boost::iterator_value<I>::type value_type;
+    new (static_cast<void*>(::boost::addressof(*pos))) value_type();                      // may throw
+}
+
+template <typename DisableTrivialInit, typename I>
+inline
+void construct(DisableTrivialInit const&, I pos)
+{
+    typedef typename ::boost::iterator_value<I>::type value_type;
+    typedef typename ::boost::mpl::and_<
+        boost::has_trivial_constructor<value_type>,
+        DisableTrivialInit
+    >::type dont_init;
+
+    construct_dispatch(dont_init(), pos);                                                // may throw
+}
+
+// construct(I, V)
+
+template <typename I, typename V>
+inline
+void construct_copy_dispatch(I pos, V const& v,
+                             boost::mpl::bool_<true> const& /*use_memcpy*/)
+{
+    ::memcpy(boost::addressof(*pos), boost::addressof(v), sizeof(V));
+}
+
+template <typename I, typename P>
+inline
+void construct_copy_dispatch(I pos, P const& p,
+                             boost::mpl::bool_<false> const& /*use_memcpy*/)
+{
+    typedef typename boost::iterator_value<I>::type V;
+    new (static_cast<void*>(boost::addressof(*pos))) V(p);                      // may throw
+}
+
+template <typename DisableTrivialInit, typename I, typename P>
+inline
+void construct(DisableTrivialInit const&,
+               I pos, P const& p)
+{
+    typedef typename
+    ::boost::mpl::and_<
+        is_corresponding_value<I, P>,
+        ::boost::has_trivial_copy<P>
+    >::type
+    use_memcpy;
+
+    construct_copy_dispatch(pos, p, use_memcpy());                              // may throw
+}
+
+// Needed by push_back(V &&)
+
+template <typename I, typename V>
+inline
+void construct_move_dispatch(I pos, V const& v,
+                             boost::mpl::bool_<true> const& /*use_memcpy*/)
+{
+    ::memcpy(boost::addressof(*pos), boost::addressof(v), sizeof(V));
+}
+
+template <typename I, typename P>
+inline
+void construct_move_dispatch(I pos, BOOST_RV_REF(P) p,
+                             boost::mpl::bool_<false> const& /*use_memcpy*/)
+{
+    typedef typename boost::iterator_value<I>::type V;
+    new (static_cast<void*>(boost::addressof(*pos))) V(::boost::move(p));       // may throw
+}
+
+template <typename DisableTrivialInit, typename I, typename P>
+inline
+void construct(DisableTrivialInit const&, I pos, BOOST_RV_REF(P) p)
+{
+    typedef typename
+    ::boost::mpl::and_<
+        is_corresponding_value<I, P>,
+        ::boost::has_trivial_move_constructor<P>
+    >::type
+    use_memcpy;
+
+    construct_move_dispatch(pos, ::boost::move(p), use_memcpy());               // may throw
+}
+
+// Needed by emplace_back() and emplace()
+
+#if !defined(BOOST_CONTAINER_VARRAY_DISABLE_EMPLACE)
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+template <typename DisableTrivialInit, typename I, class ...Args>
+inline
+void construct(DisableTrivialInit const&,
+               I pos,
+               BOOST_FWD_REF(Args) ...args)
+{
+    typedef typename boost::iterator_value<I>::type V;
+    new (static_cast<void*>(boost::addressof(*pos))) V(::boost::forward<Args>(args)...);    // may throw
+}
+
+#else // !BOOST_NO_CXX11_VARIADIC_TEMPLATES
+
+// BOOST_NO_CXX11_RVALUE_REFERENCES -> P0 const& p0
+// !BOOST_NO_CXX11_RVALUE_REFERENCES -> P0 && p0
+// which means that version with one parameter may take V const& v
+
+#define BOOST_GEOMETRY_INDEX_DETAIL_VARRAY_DETAIL_CONSTRUCT(N)                                      \
+template <typename DisableTrivialInit, typename I, typename P BOOST_MOVE_I##N BOOST_MOVE_CLASS##N > \
+inline                                                                                              \
+void construct(DisableTrivialInit const&,                                                           \
+               I pos,                                                                               \
+               BOOST_FWD_REF(P) p                                                                   \
+               BOOST_MOVE_I##N BOOST_MOVE_UREF##N)                                                  \
+{                                                                                                   \
+    typedef typename boost::iterator_value<I>::type V;                                              \
+    new                                                                                             \
+    (static_cast<void*>(boost::addressof(*pos)))                                                    \
+    V(boost::forward<P>(p) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);                    /*may throw*/    \
+}                                                                                                   \
+
+BOOST_MOVE_ITERATE_1TO9(BOOST_GEOMETRY_INDEX_DETAIL_VARRAY_DETAIL_CONSTRUCT)
+#undef BOOST_GEOMETRY_INDEX_DETAIL_VARRAY_DETAIL_CONSTRUCT
+
+#endif // !BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#endif // !BOOST_CONTAINER_VARRAY_DISABLE_EMPLACE
+
+// assign(I, V)
+
+template <typename I, typename V>
+inline
+void assign_copy_dispatch(I pos, V const& v,
+                          boost::mpl::bool_<true> const& /*use_memcpy*/)
+{
+// TODO - use memmove here?
+    ::memcpy(boost::addressof(*pos), boost::addressof(v), sizeof(V));
+}
+
+template <typename I, typename V>
+inline
+void assign_copy_dispatch(I pos, V const& v,
+                          boost::mpl::bool_<false> const& /*use_memcpy*/)
+{
+    *pos = v;                                                                   // may throw
+}
+
+template <typename I, typename V>
+inline
+void assign(I pos, V const& v)
+{
+    typedef typename
+    ::boost::mpl::and_<
+        is_corresponding_value<I, V>,
+        ::boost::has_trivial_assign<V>
+    >::type
+    use_memcpy;
+
+    assign_copy_dispatch(pos, v, use_memcpy());                                   // may throw
+}
+
+template <typename I, typename V>
+inline
+void assign_move_dispatch(I pos, V const& v,
+                          boost::mpl::bool_<true> const& /*use_memcpy*/)
+{
+// TODO - use memmove here?
+    ::memcpy(boost::addressof(*pos), boost::addressof(v), sizeof(V));
+}
+
+template <typename I, typename V>
+inline
+void assign_move_dispatch(I pos, BOOST_RV_REF(V) v,
+                          boost::mpl::bool_<false> const& /*use_memcpy*/)
+{
+    *pos = boost::move(v);                                                        // may throw
+}
+
+template <typename I, typename V>
+inline
+void assign(I pos, BOOST_RV_REF(V) v)
+{
+    typedef typename
+    ::boost::mpl::and_<
+        is_corresponding_value<I, V>,
+        ::boost::has_trivial_move_assign<V>
+    >::type
+    use_memcpy;
+
+    assign_move_dispatch(pos, ::boost::move(v), use_memcpy());
+}
+
+// uninitialized_copy_s
+
+template <typename I, typename F>
+inline std::size_t uninitialized_copy_s(I first, I last, F dest, std::size_t max_count)
+{
+    std::size_t count = 0;
+    F it = dest;
+
+    BOOST_TRY
+    {
+        for ( ; first != last ; ++it, ++first, ++count )
+        {
+            if ( max_count <= count )
+                return (std::numeric_limits<std::size_t>::max)();
+
+            // dummy 0 as DisableTrivialInit
+            construct(0, it, *first);                                              // may throw
+        }
+    }
+    BOOST_CATCH(...)
+    {
+        destroy(dest, it);
+        BOOST_RETHROW;
+    }
+    BOOST_CATCH_END
+
+    return count;
+}
+
+// scoped_destructor
+
+template<class T>
+class scoped_destructor
+{
+public:
+    scoped_destructor(T * ptr) : m_ptr(ptr) {}
+
+    ~scoped_destructor()
+    {
+        if(m_ptr)
+            destroy(m_ptr);
+    }
+
+    void release() { m_ptr = 0; }
+
+private:
+    T * m_ptr;
+};
+
+}}}}} // namespace boost::geometry::index::detail::varray_detail
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_VARRAY_DETAIL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/distance_predicates.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/distance_predicates.hpp
new file mode 100644
index 00000000000..59b32af4753
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/distance_predicates.hpp
@@ -0,0 +1,204 @@
+// Boost.Geometry Index
+//
+// Spatial index distance predicates, calculators and checkers used in nearest neighbor query
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_DISTANCE_PREDICATES_HPP
+#define BOOST_GEOMETRY_INDEX_DISTANCE_PREDICATES_HPP
+
+#include <boost/geometry/index/detail/distance_predicates.hpp>
+
+/*!
+\defgroup nearest_relations Nearest relations (boost::geometry::index::)
+*/
+
+namespace boost { namespace geometry { namespace index {
+
+// relations generators
+
+#ifdef BOOST_GEOMETRY_INDEX_DETAIL_EXPERIMENTAL
+
+/*!
+\brief Generate to_nearest() relationship.
+
+Generate a nearest query Point and Value's Indexable relationship while calculating
+distances. This function may be used to define that knn query should calculate distances
+as smallest as possible between query Point and Indexable's points. In other words it
+should be the distance to the nearest Indexable's point. This function may be also used
+to define distances bounds which indicates that Indexable's nearest point should be
+closer or further than value v. This is default relation.
+
+\ingroup nearest_relations
+
+\tparam T   Type of wrapped object. This may be a Point for PointRelation or CoordinateType for
+            MinRelation or MaxRelation
+
+\param v    Point or distance value.
+*/
+template <typename T>
+detail::to_nearest<T> to_nearest(T const& v)
+{
+    return detail::to_nearest<T>(v);
+}
+
+/*!
+\brief Generate to_centroid() relationship.
+
+Generate a nearest query Point and Value's Indexable relationship while calculating
+distances. This function may be used to define that knn query should calculate distances
+between query Point and Indexable's centroid. This function may be also used
+to define distances bounds which indicates that Indexable's centroid should be
+closer or further than value v.
+
+\ingroup nearest_relations
+
+\tparam T   Type of wrapped object. This may be a Point for PointRelation or some CoordinateType for
+            MinRelation or MaxRelation
+
+\param v    Point or distance value.
+*/
+template <typename T>
+detail::to_centroid<T> to_centroid(T const& v)
+{
+    return detail::to_centroid<T>(v);
+}
+
+/*!
+\brief Generate to_furthest() relationship.
+
+Generate a nearest query Point and Value's Indexable relationship while calculating
+distances. This function may be used to define that knn query should calculate distances
+as biggest as possible between query Point and Indexable's points. In other words it
+should be the distance to the furthest Indexable's point. This function may be also used
+to define distances bounds which indicates that Indexable's furthest point should be
+closer or further than value v.
+
+\ingroup nearest_relations
+
+\tparam T   Type of wrapped object. This may be a Point for PointRelation or some CoordinateType for
+            MinRelation or MaxRelation
+
+\param v    Point or distance value.
+*/
+template <typename T>
+detail::to_furthest<T> to_furthest(T const& v)
+{
+    return detail::to_furthest<T>(v);
+}
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_EXPERIMENTAL
+
+// distance predicates generators
+
+/*!
+\brief Generate unbounded() distance predicate.
+
+Generate a distance predicate. This defines distances bounds which are used by knn query.
+This function indicates that there is no distance bounds and Values should be returned
+if distances between Point and Indexable are the smallest. Distance calculation is defined
+by PointRelation. This is default nearest predicate.
+
+\ingroup distance_predicates
+
+\tparam PointRelation   PointRelation type.
+
+\param pr               The point relation. This may be generated by \c index::to_nearest(),
+                        \c index::to_centroid() or \c index::to_furthest() with \c Point passed as a parameter.
+*/
+//template <typename PointRelation>
+//inline detail::unbounded<PointRelation>
+//unbounded(PointRelation const& pr)
+//{
+//    return detail::unbounded<PointRelation>(pr);
+//}
+
+/*!
+\brief Generate min_bounded() distance predicate.
+
+Generate a distance predicate. This defines distances bounds which are used by knn query.
+This function indicates that Values should be returned only if distances between Point and
+Indexable are greater or equal to some min_distance passed in MinRelation. Check for closest Value is
+defined by PointRelation. So it is possible e.g. to return Values with centroids closest to some
+Point but only if nearest points are further than some distance.
+
+\ingroup distance_predicates
+
+\tparam PointRelation   PointRelation type.
+\tparam MinRelation     MinRelation type.
+
+\param pr               The point relation. This may be generated by \c to_nearest(),
+                        \c to_centroid() or \c to_furthest() with \c Point passed as a parameter.
+\param minr             The minimum bound relation. This may be generated by \c to_nearest(),
+                        \c to_centroid() or \c to_furthest() with distance value passed as a parameter.
+*/
+//template <typename PointRelation, typename MinRelation>
+//inline detail::min_bounded<PointRelation, MinRelation>
+//min_bounded(PointRelation const& pr, MinRelation const& minr)
+//{
+//    return detail::min_bounded<PointRelation, MinRelation>(pr, minr);
+//}
+
+/*!
+\brief Generate max_bounded() distance predicate.
+
+Generate a distance predicate. This defines distances bounds which are used by knn query.
+This function indicates that Values should be returned only if distances between Point and
+Indexable are lesser or equal to some max_distance passed in MaxRelation. Check for closest Value is
+defined by PointRelation. So it is possible e.g. to return Values with centroids closest to some
+Point but only if nearest points are closer than some distance.
+
+\ingroup distance_predicates
+
+\tparam PointRelation   PointRelation type.
+\tparam MaxRelation     MaxRelation type.
+
+\param pr               The point relation. This may be generated by \c to_nearest(),
+                        \c to_centroid() or \c to_furthest() with \c Point passed as a parameter.
+\param maxr             The maximum bound relation. This may be generated by \c to_nearest(),
+                        \c to_centroid() or \c to_furthest() with distance value passed as a parameter.
+*/
+//template <typename PointRelation, typename MaxRelation>
+//inline detail::max_bounded<PointRelation, MaxRelation>
+//max_bounded(PointRelation const& pr, MaxRelation const& maxr)
+//{
+//    return detail::max_bounded<PointRelation, MaxRelation>(pr, maxr);
+//}
+
+/*!
+\brief Generate bounded() distance predicate.
+
+Generate a distance predicate. This defines distances bounds which are used by knn query.
+This function indicates that Values should be returned only if distances between Point and
+Indexable are greater or equal to some min_distance passed in MinRelation and lesser or equal to
+some max_distance passed in MaxRelation. Check for closest Value is defined by PointRelation.
+So it is possible e.g. to return Values with centroids closest to some Point but only if nearest
+points are further than some distance and closer than some other distance.
+
+\ingroup distance_predicates
+
+\tparam PointRelation   PointRelation type.
+\tparam MinRelation     MinRelation type.
+\tparam MaxRelation     MaxRelation type.
+
+\param pr               The point relation. This may be generated by \c to_nearest(),
+                        \c to_centroid() or \c to_furthest() with \c Point passed as a parameter.
+\param minr             The minimum bound relation. This may be generated by \c to_nearest(),
+                        \c to_centroid() or \c to_furthest() with distance value passed as a parameter.
+\param maxr             The maximum bound relation. This may be generated by \c to_nearest(),
+                        \c to_centroid() or \c to_furthest() with distance value passed as a parameter.
+*/
+//template <typename PointRelation, typename MinRelation, typename MaxRelation>
+//inline detail::bounded<PointRelation, MinRelation, MaxRelation>
+//bounded(PointRelation const& pr, MinRelation const& minr, MaxRelation const& maxr)
+//{
+//    return detail::bounded<PointRelation, MinRelation, MaxRelation>(pr, minr, maxr);
+//}
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_DISTANCE_PREDICATES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/equal_to.hpp
new file mode 100644
index 00000000000..2fb1ed216c2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/equal_to.hpp
@@ -0,0 +1,267 @@
+// Boost.Geometry Index
+//
+// Copyright (c) 2011-2016 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_EQUAL_TO_HPP
+#define BOOST_GEOMETRY_INDEX_EQUAL_TO_HPP
+
+#include <boost/geometry/algorithms/detail/equals/interface.hpp>
+#include <boost/geometry/index/indexable.hpp>
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+template <typename Geometry,
+          typename Tag = typename geometry::tag<Geometry>::type>
+struct equals
+{
+    inline static bool apply(Geometry const& g1, Geometry const& g2)
+    {
+        return geometry::equals(g1, g2);
+    }
+};
+
+template <typename Geometry, typename Tag>
+struct equals<Geometry *, Tag>
+{
+    inline static bool apply(const Geometry * g1, const Geometry * g2)
+    {
+        return g1 == g2;
+    }
+};
+
+template <typename T>
+struct equals<T, void>
+{
+    inline static bool apply(T const& v1, T const& v2)
+    {
+        return v1 == v2;
+    }
+};
+
+template <typename T>
+struct equals<T *, void>
+{
+    inline static bool apply(const T * v1, const T * v2)
+    {
+        return v1 == v2;
+    }
+};
+
+template <typename Tuple, size_t I, size_t N>
+struct tuple_equals
+{
+    inline static bool apply(Tuple const& t1, Tuple const& t2)
+    {
+        typedef typename boost::tuples::element<I, Tuple>::type T;
+
+        return equals<T>::apply(boost::get<I>(t1), boost::get<I>(t2))
+            && tuple_equals<Tuple, I+1, N>::apply(t1, t2);
+    }
+};
+
+template <typename Tuple, size_t I>
+struct tuple_equals<Tuple, I, I>
+{
+    inline static bool apply(Tuple const&, Tuple const&)
+    {
+        return true;
+    }
+};
+
+// TODO: Consider this: Since equal_to<> is using geometry::equals() it's possible that
+//       two compared Indexables are not exactly the same! They will be spatially equal
+//       but not strictly equal. Consider 2 Segments with reversed order of points.
+//       Therefore it's possible that during the Value removal different value will be
+//       removed than the one that was passed.
+
+/*!
+\brief The function object comparing Values.
+
+It compares Geometries using geometry::equals() function. Other types are compared using operator==.
+The default version handles Values which are Indexables.
+This template is also specialized for std::pair<T1, T2> and boost::tuple<...>.
+
+\tparam Value       The type of objects which are compared by this function object.
+\tparam IsIndexable If true, Values are compared using boost::geometry::equals() functions.
+*/
+template <typename Value,
+          bool IsIndexable = is_indexable<Value>::value>
+struct equal_to
+{
+    /*! \brief The type of result returned by function object. */
+    typedef bool result_type;
+    
+    /*!
+    \brief Compare values. If Value is a Geometry geometry::equals() function is used.
+    
+    \param l First value.
+    \param r Second value.
+    \return true if values are equal.
+    */
+    inline bool operator()(Value const& l, Value const& r) const
+    {
+        return detail::equals<Value>::apply(l ,r);
+    }
+};
+
+/*!
+\brief The function object comparing Values.
+
+This specialization compares values of type std::pair<T1, T2>.
+It compares pairs' first values, then second values.
+
+\tparam T1       The first type.
+\tparam T2       The second type.
+*/
+template <typename T1, typename T2>
+struct equal_to<std::pair<T1, T2>, false>
+{
+    /*! \brief The type of result returned by function object. */
+    typedef bool result_type;
+
+    /*!
+    \brief Compare values. If pair<> Value member is a Geometry geometry::equals() function is used.
+    
+    \param l First value.
+    \param r Second value.
+    \return true if values are equal.
+    */
+    inline bool operator()(std::pair<T1, T2> const& l, std::pair<T1, T2> const& r) const
+    {
+        return detail::equals<T1>::apply(l.first, r.first)
+            && detail::equals<T2>::apply(l.second, r.second);
+    }
+};
+
+/*!
+\brief The function object comparing Values.
+
+This specialization compares values of type boost::tuple<...>.
+It compares all members of the tuple from the first one to the last one.
+*/
+template <typename T0, typename T1, typename T2, typename T3, typename T4,
+          typename T5, typename T6, typename T7, typename T8, typename T9>
+struct equal_to<boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>, false>
+{
+    typedef boost::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> value_type;
+
+    /*! \brief The type of result returned by function object. */
+    typedef bool result_type;
+
+    /*!
+    \brief Compare values. If tuple<> Value member is a Geometry geometry::equals() function is used.
+    
+    \param l First value.
+    \param r Second value.
+    \return true if values are equal.
+    */
+    inline bool operator()(value_type const& l, value_type const& r) const
+    {
+        return detail::tuple_equals<
+            value_type, 0, boost::tuples::length<value_type>::value
+        >::apply(l ,r);
+    }
+};
+
+}}}} // namespace boost::geometry::index::detail
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+#include <tuple>
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+template <typename Tuple, size_t I, size_t N>
+struct std_tuple_equals
+{
+    inline static bool apply(Tuple const& t1, Tuple const& t2)
+    {
+        typedef typename std::tuple_element<I, Tuple>::type T;
+
+        return equals<T>::apply(std::get<I>(t1), std::get<I>(t2))
+            && std_tuple_equals<Tuple, I+1, N>::apply(t1, t2);
+    }
+};
+
+template <typename Tuple, size_t I>
+struct std_tuple_equals<Tuple, I, I>
+{
+    inline static bool apply(Tuple const&, Tuple const&)
+    {
+        return true;
+    }
+};
+
+/*!
+\brief The function object comparing Values.
+
+This specialization compares values of type std::tuple<Args...>.
+It's defined if the compiler supports tuples and variadic templates.
+It compares all members of the tuple from the first one to the last one.
+*/
+template <typename ...Args>
+struct equal_to<std::tuple<Args...>, false>
+{
+    typedef std::tuple<Args...> value_type;
+
+    /*! \brief The type of result returned by function object. */
+    typedef bool result_type;
+
+    /*!
+    \brief Compare values. If tuple<> Value member is a Geometry geometry::equals() function is used.
+    
+    \param l First value.
+    \param r Second value.
+    \return true if values are equal.
+    */
+    bool operator()(value_type const& l, value_type const& r) const
+    {
+        return detail::std_tuple_equals<
+            value_type, 0, std::tuple_size<value_type>::value
+        >::apply(l ,r);
+    }
+};
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // !defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+namespace boost { namespace geometry { namespace index {
+
+/*!
+\brief The function object comparing Values.
+
+The default version handles Values which are Indexables, std::pair<T1, T2>, boost::tuple<...>
+and std::tuple<...> if STD tuples and variadic templates are supported.
+All members are compared from left to right, Geometries using boost::geometry::equals() function,
+other types using operator==.
+
+\tparam Value       The type of objects which are compared by this function object.
+*/
+template <typename Value>
+struct equal_to
+    : detail::equal_to<Value>
+{
+    /*! \brief The type of result returned by function object. */
+    typedef typename detail::equal_to<Value>::result_type result_type;
+    
+    /*!
+    \brief Compare Values.
+    
+    \param l First value.
+    \param r Second value.
+    \return true if Values are equal.
+    */
+    inline bool operator()(Value const& l, Value const& r) const
+    {
+        return detail::equal_to<Value>::operator()(l ,r);
+    }
+};
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_EQUAL_TO_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/indexable.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/indexable.hpp
new file mode 100644
index 00000000000..831e17f6dd2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/indexable.hpp
@@ -0,0 +1,197 @@
+// Boost.Geometry Index
+//
+// Copyright (c) 2011-2017 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_INDEXABLE_HPP
+#define BOOST_GEOMETRY_INDEX_INDEXABLE_HPP
+
+#include <boost/mpl/assert.hpp>
+#include <boost/tuple/tuple.hpp>
+
+#include <boost/geometry/index/detail/is_indexable.hpp>
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+/*!
+\brief The function object extracting Indexable from Value.
+
+It translates Value object to Indexable object. The default version handles Values which are Indexables.
+This template is also specialized for std::pair<Indexable, T2>, boost::tuple<Indexable, ...>
+and std::tuple<Indexable, ...>.
+
+\tparam Value       The Value type which may be translated directly to the Indexable.
+\tparam IsIndexable If true, the const reference to Value is returned.
+*/
+template <typename Value, bool IsIndexable = is_indexable<Value>::value>
+struct indexable
+{
+    BOOST_MPL_ASSERT_MSG(
+        (detail::is_indexable<Value>::value),
+        NOT_VALID_INDEXABLE_TYPE,
+        (Value)
+    );
+
+    /*! \brief The type of result returned by function object. */
+    typedef Value const& result_type;
+
+    /*!
+    \brief Return indexable extracted from the value.
+    
+    \param v The value.
+    \return The indexable.
+    */
+    inline result_type operator()(Value const& v) const
+    {
+        return v;
+    }
+};
+
+/*!
+\brief The function object extracting Indexable from Value.
+
+This specialization translates from std::pair<Indexable, T2>.
+
+\tparam Indexable       The Indexable type.
+\tparam T2              The second type.
+*/
+template <typename Indexable, typename T2>
+struct indexable<std::pair<Indexable, T2>, false>
+{
+    BOOST_MPL_ASSERT_MSG(
+        (detail::is_indexable<Indexable>::value),
+        NOT_VALID_INDEXABLE_TYPE,
+        (Indexable)
+    );
+
+    /*! \brief The type of result returned by function object. */
+    typedef Indexable const& result_type;
+
+    /*!
+    \brief Return indexable extracted from the value.
+    
+    \param v The value.
+    \return The indexable.
+    */
+    inline result_type operator()(std::pair<Indexable, T2> const& v) const
+    {
+        return v.first;
+    }
+};
+
+/*!
+\brief The function object extracting Indexable from Value.
+
+This specialization translates from boost::tuple<Indexable, ...>.
+
+\tparam Indexable   The Indexable type.
+*/
+template <typename Indexable, typename T1, typename T2, typename T3, typename T4,
+          typename T5, typename T6, typename T7, typename T8, typename T9>
+struct indexable<boost::tuple<Indexable, T1, T2, T3, T4, T5, T6, T7, T8, T9>, false>
+{
+    typedef boost::tuple<Indexable, T1, T2, T3, T4, T5, T6, T7, T8, T9> value_type;
+
+    BOOST_MPL_ASSERT_MSG(
+        (detail::is_indexable<Indexable>::value),
+        NOT_VALID_INDEXABLE_TYPE,
+        (Indexable)
+        );
+
+    /*! \brief The type of result returned by function object. */
+    typedef Indexable const& result_type;
+
+    /*!
+    \brief Return indexable extracted from the value.
+    
+    \param v The value.
+    \return The indexable.
+    */
+    inline result_type operator()(value_type const& v) const
+    {
+        return boost::get<0>(v);
+    }
+};
+
+}}}} // namespace boost::geometry::index::detail
+
+#if !defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+#include <tuple>
+
+namespace boost { namespace geometry { namespace index { namespace detail {
+
+/*!
+\brief The function object extracting Indexable from Value.
+
+This specialization translates from std::tuple<Indexable, Args...>.
+It's defined if the compiler supports tuples and variadic templates.
+
+\tparam Indexable   The Indexable type.
+*/
+template <typename Indexable, typename ...Args>
+struct indexable<std::tuple<Indexable, Args...>, false>
+{
+    typedef std::tuple<Indexable, Args...> value_type;
+
+    BOOST_MPL_ASSERT_MSG(
+        (detail::is_indexable<Indexable>::value),
+        NOT_VALID_INDEXABLE_TYPE,
+        (Indexable)
+        );
+
+    /*! \brief The type of result returned by function object. */
+    typedef Indexable const& result_type;
+
+    /*!
+    \brief Return indexable extracted from the value.
+    
+    \param v The value.
+    \return The indexable.
+    */
+    result_type operator()(value_type const& v) const
+    {
+        return std::get<0>(v);
+    }
+};
+
+}}}} // namespace boost::geometry::index::detail
+
+#endif // !defined(BOOST_NO_CXX11_HDR_TUPLE) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+namespace boost { namespace geometry { namespace index {
+
+/*!
+\brief The function object extracting Indexable from Value.
+
+It translates Value object to Indexable object. By default, it can handle Values which are Indexables,
+std::pair<Indexable, T2>, boost::tuple<Indexable, ...> and std::tuple<Indexable, ...> if STD tuples
+and variadic templates are supported.
+
+\tparam Value       The Value type which may be translated directly to the Indexable.
+*/
+template <typename Value>
+struct indexable
+    : detail::indexable<Value>
+{
+    /*! \brief The type of result returned by function object. It should be const Indexable reference. */
+    typedef typename detail::indexable<Value>::result_type result_type;
+
+    /*!
+    \brief Return indexable extracted from the value.
+    
+    \param v The value.
+    \return The indexable.
+    */
+    inline result_type operator()(Value const& v) const
+    {
+        return detail::indexable<Value>::operator()(v);
+    }
+};
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_INDEXABLE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/inserter.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/inserter.hpp
new file mode 100644
index 00000000000..7c489bc3f12
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/inserter.hpp
@@ -0,0 +1,78 @@
+// Boost.Geometry Index
+//
+// Insert iterator
+//
+// Copyright (c) 2011-2013 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_INSERTER_HPP
+#define BOOST_GEOMETRY_INDEX_INSERTER_HPP
+
+#include <iterator>
+
+/*!
+\defgroup inserters Inserters (boost::geometry::index::)
+*/
+
+namespace boost { namespace geometry { namespace index {
+
+template <class Container>
+class insert_iterator :
+    public std::iterator<std::output_iterator_tag, void, void, void, void>
+{
+public:
+    typedef Container container_type;
+
+    inline explicit insert_iterator(Container & c)
+        : container(&c)
+    {}
+    
+    insert_iterator & operator=(typename Container::value_type const& value)
+    {
+        container->insert(value);
+        return *this;
+    }
+
+    insert_iterator & operator* ()
+    {
+        return *this;
+    }
+
+    insert_iterator & operator++ ()
+    {
+        return *this;
+    }
+
+    insert_iterator operator++(int)
+    {
+        return *this;
+    }
+
+private:
+    Container * container;
+};
+
+/*!
+\brief Insert iterator generator.
+
+Returns insert iterator capable to insert values to the container
+(spatial index) which has member function insert(value_type const&) defined.
+
+\ingroup inserters
+
+\param c    The reference to the container (spatial index) to which values will be inserted.
+
+\return     The insert iterator inserting values to the container.
+*/
+template <typename Container>
+insert_iterator<Container> inserter(Container & c)
+{
+    return insert_iterator<Container>(c);
+}
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_INSERTER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/parameters.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/parameters.hpp
new file mode 100644
index 00000000000..1a9469c1034
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/parameters.hpp
@@ -0,0 +1,258 @@
+// Boost.Geometry Index
+//
+// R-tree algorithms parameters
+//
+// Copyright (c) 2011-2017 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_PARAMETERS_HPP
+#define BOOST_GEOMETRY_INDEX_PARAMETERS_HPP
+
+
+#include <limits>
+
+#include <boost/mpl/assert.hpp>
+
+#include <boost/geometry/index/detail/exception.hpp>
+
+
+namespace boost { namespace geometry { namespace index {
+
+namespace detail { 
+
+template <size_t MaxElements>
+struct default_min_elements_s
+{
+    static const size_t raw_value = (MaxElements * 3) / 10;
+    static const size_t value = 1 <= raw_value ? raw_value : 1;
+};
+
+inline size_t default_min_elements_d()
+{
+    return (std::numeric_limits<size_t>::max)();
+}
+
+inline size_t default_min_elements_d_calc(size_t max_elements, size_t min_elements)
+{
+    if ( default_min_elements_d() == min_elements )
+    {
+        size_t raw_value = (max_elements * 3) / 10;
+        return 1 <= raw_value ? raw_value : 1;
+    }
+    
+    return min_elements;
+}
+
+template <size_t MaxElements>
+struct default_rstar_reinserted_elements_s
+{
+    static const size_t value = (MaxElements * 3) / 10;
+};
+
+inline size_t default_rstar_reinserted_elements_d()
+{
+    return (std::numeric_limits<size_t>::max)();
+}
+
+inline size_t default_rstar_reinserted_elements_d_calc(size_t max_elements, size_t reinserted_elements)
+{
+    if ( default_rstar_reinserted_elements_d() == reinserted_elements )
+    {
+        return (max_elements * 3) / 10;
+    }
+    
+    return reinserted_elements;
+}
+
+} // namespace detail
+
+/*!
+\brief Linear r-tree creation algorithm parameters.
+
+\tparam MaxElements     Maximum number of elements in nodes.
+\tparam MinElements     Minimum number of elements in nodes. Default: 0.3*Max.
+*/
+template <size_t MaxElements,
+          size_t MinElements = detail::default_min_elements_s<MaxElements>::value>
+struct linear
+{
+    BOOST_MPL_ASSERT_MSG((0 < MinElements && 2*MinElements <= MaxElements+1),
+                         INVALID_STATIC_MIN_MAX_PARAMETERS, (linear));
+
+    static const size_t max_elements = MaxElements;
+    static const size_t min_elements = MinElements;
+
+    static size_t get_max_elements() { return MaxElements; }
+    static size_t get_min_elements() { return MinElements; }
+};
+
+/*!
+\brief Quadratic r-tree creation algorithm parameters.
+
+\tparam MaxElements     Maximum number of elements in nodes.
+\tparam MinElements     Minimum number of elements in nodes. Default: 0.3*Max.
+*/
+template <size_t MaxElements,
+          size_t MinElements = detail::default_min_elements_s<MaxElements>::value>
+struct quadratic
+{
+    BOOST_MPL_ASSERT_MSG((0 < MinElements && 2*MinElements <= MaxElements+1),
+                         INVALID_STATIC_MIN_MAX_PARAMETERS, (quadratic));
+
+    static const size_t max_elements = MaxElements;
+    static const size_t min_elements = MinElements;
+
+    static size_t get_max_elements() { return MaxElements; }
+    static size_t get_min_elements() { return MinElements; }
+};
+
+/*!
+\brief R*-tree creation algorithm parameters.
+
+\tparam MaxElements             Maximum number of elements in nodes.
+\tparam MinElements             Minimum number of elements in nodes. Default: 0.3*Max.
+\tparam ReinsertedElements      The number of elements reinserted by forced reinsertions algorithm.
+                                If 0 forced reinsertions are disabled. Maximum value is Max+1-Min.
+                                Greater values are truncated. Default: 0.3*Max.
+\tparam OverlapCostThreshold    The number of most suitable leafs taken into account while choosing
+                                the leaf node to which currently inserted value will be added. If
+                                value is in range (0, MaxElements) - the algorithm calculates
+                                nearly minimum overlap cost, otherwise all leafs are analyzed
+                                and true minimum overlap cost is calculated. Default: 32.
+*/
+template <size_t MaxElements,
+          size_t MinElements = detail::default_min_elements_s<MaxElements>::value,
+          size_t ReinsertedElements = detail::default_rstar_reinserted_elements_s<MaxElements>::value,
+          size_t OverlapCostThreshold = 32>
+struct rstar
+{
+    BOOST_MPL_ASSERT_MSG((0 < MinElements && 2*MinElements <= MaxElements+1),
+                         INVALID_STATIC_MIN_MAX_PARAMETERS, (rstar));
+
+    static const size_t max_elements = MaxElements;
+    static const size_t min_elements = MinElements;
+    static const size_t reinserted_elements = ReinsertedElements;
+    static const size_t overlap_cost_threshold = OverlapCostThreshold;
+
+    static size_t get_max_elements() { return MaxElements; }
+    static size_t get_min_elements() { return MinElements; }
+    static size_t get_reinserted_elements() { return ReinsertedElements; }
+    static size_t get_overlap_cost_threshold() { return OverlapCostThreshold; }
+};
+
+//template <size_t MaxElements, size_t MinElements>
+//struct kmeans
+//{
+//    static const size_t max_elements = MaxElements;
+//    static const size_t min_elements = MinElements;
+//};
+
+/*!
+\brief Linear r-tree creation algorithm parameters - run-time version.
+*/
+class dynamic_linear
+{
+public:
+    /*!
+    \brief The constructor.
+
+    \param max_elements     Maximum number of elements in nodes.
+    \param min_elements     Minimum number of elements in nodes. Default: 0.3*Max.
+    */
+    explicit dynamic_linear(size_t max_elements,
+                            size_t min_elements = detail::default_min_elements_d())
+        : m_max_elements(max_elements)
+        , m_min_elements(detail::default_min_elements_d_calc(max_elements, min_elements))
+    {
+        if (!(0 < m_min_elements && 2*m_min_elements <= m_max_elements+1))
+            detail::throw_invalid_argument("invalid min or/and max parameters of dynamic_linear");
+    }
+
+    size_t get_max_elements() const { return m_max_elements; }
+    size_t get_min_elements() const { return m_min_elements; }
+
+private:
+    size_t m_max_elements;
+    size_t m_min_elements;
+};
+
+/*!
+\brief Quadratic r-tree creation algorithm parameters - run-time version.
+*/
+class dynamic_quadratic
+{
+public:
+    /*!
+    \brief The constructor.
+
+    \param max_elements     Maximum number of elements in nodes.
+    \param min_elements     Minimum number of elements in nodes. Default: 0.3*Max.
+    */
+    explicit dynamic_quadratic(size_t max_elements,
+                               size_t min_elements = detail::default_min_elements_d())
+        : m_max_elements(max_elements)
+        , m_min_elements(detail::default_min_elements_d_calc(max_elements, min_elements))
+    {
+        if (!(0 < m_min_elements && 2*m_min_elements <= m_max_elements+1))
+            detail::throw_invalid_argument("invalid min or/and max parameters of dynamic_quadratic");
+    }
+
+    size_t get_max_elements() const { return m_max_elements; }
+    size_t get_min_elements() const { return m_min_elements; }
+
+private:
+    size_t m_max_elements;
+    size_t m_min_elements;
+};
+
+/*!
+\brief R*-tree creation algorithm parameters - run-time version.
+*/
+class dynamic_rstar
+{
+public:
+    /*!
+    \brief The constructor.
+
+    \param max_elements             Maximum number of elements in nodes.
+    \param min_elements             Minimum number of elements in nodes. Default: 0.3*Max.
+    \param reinserted_elements      The number of elements reinserted by forced reinsertions algorithm.
+                                    If 0 forced reinsertions are disabled. Maximum value is Max-Min+1.
+                                    Greater values are truncated. Default: 0.3*Max.
+    \param overlap_cost_threshold   The number of most suitable leafs taken into account while choosing
+                                    the leaf node to which currently inserted value will be added. If
+                                    value is in range (0, MaxElements) - the algorithm calculates
+                                    nearly minimum overlap cost, otherwise all leafs are analyzed
+                                    and true minimum overlap cost is calculated. Default: 32.
+    */
+    explicit dynamic_rstar(size_t max_elements,
+                           size_t min_elements = detail::default_min_elements_d(),
+                           size_t reinserted_elements = detail::default_rstar_reinserted_elements_d(),
+                           size_t overlap_cost_threshold = 32)
+        : m_max_elements(max_elements)
+        , m_min_elements(detail::default_min_elements_d_calc(max_elements, min_elements))
+        , m_reinserted_elements(detail::default_rstar_reinserted_elements_d_calc(max_elements, reinserted_elements))
+        , m_overlap_cost_threshold(overlap_cost_threshold)
+    {
+        if (!(0 < m_min_elements && 2*m_min_elements <= m_max_elements+1))
+            detail::throw_invalid_argument("invalid min or/and max parameters of dynamic_rstar");
+    }
+
+    size_t get_max_elements() const { return m_max_elements; }
+    size_t get_min_elements() const { return m_min_elements; }
+    size_t get_reinserted_elements() const { return m_reinserted_elements; }
+    size_t get_overlap_cost_threshold() const { return m_overlap_cost_threshold; }
+
+private:
+    size_t m_max_elements;
+    size_t m_min_elements;
+    size_t m_reinserted_elements;
+    size_t m_overlap_cost_threshold;
+};
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_PARAMETERS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/predicates.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/predicates.hpp
new file mode 100644
index 00000000000..f4e22bdd559
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/predicates.hpp
@@ -0,0 +1,421 @@
+// Boost.Geometry Index
+//
+// Spatial query predicates
+//
+// Copyright (c) 2011-2015 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_PREDICATES_HPP
+#define BOOST_GEOMETRY_INDEX_PREDICATES_HPP
+
+#include <boost/geometry/index/detail/predicates.hpp>
+#include <boost/geometry/index/detail/tuples.hpp>
+
+/*!
+\defgroup predicates Predicates (boost::geometry::index::)
+*/
+
+namespace boost { namespace geometry { namespace index {
+
+/*!
+\brief Generate \c contains() predicate.
+
+Generate a predicate defining Value and Geometry relationship.
+Value will be returned by the query if <tt>bg::within(Geometry, Indexable)</tt>
+returns true.
+
+\par Example
+\verbatim
+bgi::query(spatial_index, bgi::contains(box), std::back_inserter(result));
+\endverbatim
+
+\ingroup predicates
+
+\tparam Geometry    The Geometry type.
+
+\param g            The Geometry object.
+*/
+template <typename Geometry> inline
+detail::predicates::spatial_predicate<Geometry, detail::predicates::contains_tag, false>
+contains(Geometry const& g)
+{
+    return detail::predicates::spatial_predicate
+                <
+                    Geometry,
+                    detail::predicates::contains_tag,
+                    false
+                >(g);
+}
+
+/*!
+\brief Generate \c covered_by() predicate.
+
+Generate a predicate defining Value and Geometry relationship.
+Value will be returned by the query if <tt>bg::covered_by(Indexable, Geometry)</tt>
+returns true.
+
+\par Example
+\verbatim
+bgi::query(spatial_index, bgi::covered_by(box), std::back_inserter(result));
+\endverbatim
+
+\ingroup predicates
+
+\tparam Geometry    The Geometry type.
+
+\param g            The Geometry object.
+*/
+template <typename Geometry> inline
+detail::predicates::spatial_predicate<Geometry, detail::predicates::covered_by_tag, false>
+covered_by(Geometry const& g)
+{
+    return detail::predicates::spatial_predicate
+                <
+                    Geometry,
+                    detail::predicates::covered_by_tag,
+                    false
+                >(g);
+}
+
+/*!
+\brief Generate \c covers() predicate.
+
+Generate a predicate defining Value and Geometry relationship.
+Value will be returned by the query if <tt>bg::covered_by(Geometry, Indexable)</tt>
+returns true.
+
+\par Example
+\verbatim
+bgi::query(spatial_index, bgi::covers(box), std::back_inserter(result));
+\endverbatim
+
+\ingroup predicates
+
+\tparam Geometry    The Geometry type.
+
+\param g            The Geometry object.
+*/
+template <typename Geometry> inline
+detail::predicates::spatial_predicate<Geometry, detail::predicates::covers_tag, false>
+covers(Geometry const& g)
+{
+    return detail::predicates::spatial_predicate
+                <
+                    Geometry,
+                    detail::predicates::covers_tag,
+                    false
+                >(g);
+}
+
+/*!
+\brief Generate \c disjoint() predicate.
+
+Generate a predicate defining Value and Geometry relationship.
+Value will be returned by the query if <tt>bg::disjoint(Indexable, Geometry)</tt>
+returns true.
+
+\par Example
+\verbatim
+bgi::query(spatial_index, bgi::disjoint(box), std::back_inserter(result));
+\endverbatim
+
+\ingroup predicates
+
+\tparam Geometry    The Geometry type.
+
+\param g            The Geometry object.
+*/
+template <typename Geometry> inline
+detail::predicates::spatial_predicate<Geometry, detail::predicates::disjoint_tag, false>
+disjoint(Geometry const& g)
+{
+    return detail::predicates::spatial_predicate
+                <
+                    Geometry,
+                    detail::predicates::disjoint_tag,
+                    false
+                >(g);
+}
+
+/*!
+\brief Generate \c intersects() predicate.
+
+Generate a predicate defining Value and Geometry relationship.
+Value will be returned by the query if <tt>bg::intersects(Indexable, Geometry)</tt>
+returns true.
+
+\par Example
+\verbatim
+bgi::query(spatial_index, bgi::intersects(box), std::back_inserter(result));
+bgi::query(spatial_index, bgi::intersects(ring), std::back_inserter(result));
+bgi::query(spatial_index, bgi::intersects(polygon), std::back_inserter(result));
+\endverbatim
+
+\ingroup predicates
+
+\tparam Geometry    The Geometry type.
+
+\param g            The Geometry object.
+*/
+template <typename Geometry> inline
+detail::predicates::spatial_predicate<Geometry, detail::predicates::intersects_tag, false>
+intersects(Geometry const& g)
+{
+    return detail::predicates::spatial_predicate
+                <
+                    Geometry,
+                    detail::predicates::intersects_tag,
+                    false
+                >(g);
+}
+
+/*!
+\brief Generate \c overlaps() predicate.
+
+Generate a predicate defining Value and Geometry relationship.
+Value will be returned by the query if <tt>bg::overlaps(Indexable, Geometry)</tt>
+returns true.
+
+\par Example
+\verbatim
+bgi::query(spatial_index, bgi::overlaps(box), std::back_inserter(result));
+\endverbatim
+
+\ingroup predicates
+
+\tparam Geometry    The Geometry type.
+
+\param g            The Geometry object.
+*/
+template <typename Geometry> inline
+detail::predicates::spatial_predicate<Geometry, detail::predicates::overlaps_tag, false>
+overlaps(Geometry const& g)
+{
+    return detail::predicates::spatial_predicate
+                <
+                    Geometry,
+                    detail::predicates::overlaps_tag,
+                    false
+                >(g);
+}
+
+#ifdef BOOST_GEOMETRY_INDEX_DETAIL_EXPERIMENTAL
+
+/*!
+\brief Generate \c touches() predicate.
+
+Generate a predicate defining Value and Geometry relationship.
+Value will be returned by the query if <tt>bg::touches(Indexable, Geometry)</tt>
+returns true.
+
+\ingroup predicates
+
+\tparam Geometry    The Geometry type.
+
+\param g            The Geometry object.
+*/
+template <typename Geometry> inline
+detail::predicates::spatial_predicate<Geometry, detail::predicates::touches_tag, false>
+touches(Geometry const& g)
+{
+    return detail::predicates::spatial_predicate
+                <
+                    Geometry,
+                    detail::predicates::touches_tag,
+                    false
+                >(g);
+}
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_EXPERIMENTAL
+
+/*!
+\brief Generate \c within() predicate.
+
+Generate a predicate defining Value and Geometry relationship.
+Value will be returned by the query if <tt>bg::within(Indexable, Geometry)</tt>
+returns true.
+
+\par Example
+\verbatim
+bgi::query(spatial_index, bgi::within(box), std::back_inserter(result));
+\endverbatim
+
+\ingroup predicates
+
+\tparam Geometry    The Geometry type.
+
+\param g            The Geometry object.
+*/
+template <typename Geometry> inline
+detail::predicates::spatial_predicate<Geometry, detail::predicates::within_tag, false>
+within(Geometry const& g)
+{
+    return detail::predicates::spatial_predicate
+                <
+                    Geometry,
+                    detail::predicates::within_tag,
+                    false
+                >(g);
+}
+
+/*!
+\brief Generate satisfies() predicate.
+
+A wrapper around user-defined UnaryPredicate checking if Value should be returned by spatial query.
+
+\par Example
+\verbatim
+bool is_red(Value const& v) { return v.is_red(); }
+
+struct is_red_o {
+template <typename Value> bool operator()(Value const& v) { return v.is_red(); }
+}
+
+// ...
+
+rt.query(index::intersects(box) && index::satisfies(is_red),
+std::back_inserter(result));
+
+rt.query(index::intersects(box) && index::satisfies(is_red_o()),
+std::back_inserter(result));
+
+#ifndef BOOST_NO_CXX11_LAMBDAS
+rt.query(index::intersects(box) && index::satisfies([](Value const& v) { return v.is_red(); }),
+std::back_inserter(result));
+#endif
+\endverbatim
+
+\ingroup predicates
+
+\tparam UnaryPredicate  A type of unary predicate function or function object.
+
+\param pred             The unary predicate function or function object.
+*/
+template <typename UnaryPredicate> inline
+detail::predicates::satisfies<UnaryPredicate, false>
+satisfies(UnaryPredicate const& pred)
+{
+    return detail::predicates::satisfies<UnaryPredicate, false>(pred);
+}
+
+/*!
+\brief Generate nearest() predicate.
+
+When nearest predicate is passed to the query, k-nearest neighbour search will be performed.
+\c nearest() predicate takes a \c Geometry from which distances to \c Values are calculated
+and the maximum number of \c Values that should be returned. Internally
+boost::geometry::comparable_distance() is used to perform the calculation.
+
+\par Example
+\verbatim
+bgi::query(spatial_index, bgi::nearest(pt, 5), std::back_inserter(result));
+bgi::query(spatial_index, bgi::nearest(pt, 5) && bgi::intersects(box), std::back_inserter(result));
+bgi::query(spatial_index, bgi::nearest(box, 5), std::back_inserter(result));
+\endverbatim
+
+\warning
+Only one \c nearest() predicate may be used in a query.
+
+\ingroup predicates
+
+\param geometry     The geometry from which distance is calculated.
+\param k            The maximum number of values to return.
+*/
+template <typename Geometry> inline
+detail::predicates::nearest<Geometry>
+nearest(Geometry const& geometry, unsigned k)
+{
+    return detail::predicates::nearest<Geometry>(geometry, k);
+}
+
+#ifdef BOOST_GEOMETRY_INDEX_DETAIL_EXPERIMENTAL
+
+/*!
+\brief Generate path() predicate.
+
+When path predicate is passed to the query, the returned values are k values along the path closest to
+its begin. \c path() predicate takes a \c Segment or a \c Linestring defining the path and the maximum
+number of \c Values that should be returned.
+
+\par Example
+\verbatim
+bgi::query(spatial_index, bgi::path(segment, 5), std::back_inserter(result));
+bgi::query(spatial_index, bgi::path(linestring, 5) && bgi::intersects(box), std::back_inserter(result));
+\endverbatim
+
+\warning
+Only one distance predicate (\c nearest() or \c path()) may be used in a query.
+
+\ingroup predicates
+
+\param linestring   The path along which distance is calculated.
+\param k            The maximum number of values to return.
+*/
+template <typename SegmentOrLinestring> inline
+detail::predicates::path<SegmentOrLinestring>
+path(SegmentOrLinestring const& linestring, unsigned k)
+{
+    return detail::predicates::path<SegmentOrLinestring>(linestring, k);
+}
+
+#endif // BOOST_GEOMETRY_INDEX_DETAIL_EXPERIMENTAL
+
+namespace detail { namespace predicates {
+
+// operator! generators
+
+template <typename Fun, bool Negated> inline
+satisfies<Fun, !Negated>
+operator!(satisfies<Fun, Negated> const& p)
+{
+    return satisfies<Fun, !Negated>(p);
+}
+
+template <typename Geometry, typename Tag, bool Negated> inline
+spatial_predicate<Geometry, Tag, !Negated>
+operator!(spatial_predicate<Geometry, Tag, Negated> const& p)
+{
+    return spatial_predicate<Geometry, Tag, !Negated>(p.geometry);
+}
+
+// operator&& generators
+
+template <typename Pred1, typename Pred2> inline
+boost::tuples::cons<
+    Pred1,
+    boost::tuples::cons<Pred2, boost::tuples::null_type>
+>
+operator&&(Pred1 const& p1, Pred2 const& p2)
+{
+    /*typedef typename boost::mpl::if_c<is_predicate<Pred1>::value, Pred1, Pred1 const&>::type stored1;
+    typedef typename boost::mpl::if_c<is_predicate<Pred2>::value, Pred2, Pred2 const&>::type stored2;*/
+    namespace bt = boost::tuples;
+
+    return
+    bt::cons< Pred1, bt::cons<Pred2, bt::null_type> >
+        ( p1, bt::cons<Pred2, bt::null_type>(p2, bt::null_type()) );
+}
+
+template <typename Head, typename Tail, typename Pred> inline
+typename tuples::push_back<
+    boost::tuples::cons<Head, Tail>, Pred
+>::type
+operator&&(boost::tuples::cons<Head, Tail> const& t, Pred const& p)
+{
+    //typedef typename boost::mpl::if_c<is_predicate<Pred>::value, Pred, Pred const&>::type stored;
+    namespace bt = boost::tuples;
+
+    return
+    tuples::push_back<
+        bt::cons<Head, Tail>, Pred
+    >::apply(t, p);
+}
+    
+}} // namespace detail::predicates
+
+}}} // namespace boost::geometry::index
+
+#endif // BOOST_GEOMETRY_INDEX_PREDICATES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/index/rtree.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/index/rtree.hpp
new file mode 100644
index 00000000000..439880ad5ad
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/index/rtree.hpp
@@ -0,0 +1,2226 @@
+// Boost.Geometry Index
+//
+// R-tree implementation
+//
+// Copyright (c) 2008 Federico J. Fernandez.
+// Copyright (c) 2011-2017 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_GEOMETRY_INDEX_RTREE_HPP
+#define BOOST_GEOMETRY_INDEX_RTREE_HPP
+
+// STD
+#include <algorithm>
+
+// Boost
+#include <boost/tuple/tuple.hpp>
+#include <boost/move/move.hpp>
+
+// Boost.Geometry
+#include <boost/geometry/algorithms/detail/comparable_distance/interface.hpp>
+#include <boost/geometry/algorithms/detail/covered_by/interface.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/interface.hpp>
+#include <boost/geometry/algorithms/detail/equals/interface.hpp>
+#include <boost/geometry/algorithms/detail/intersects/interface.hpp>
+#include <boost/geometry/algorithms/detail/overlaps/interface.hpp>
+#include <boost/geometry/algorithms/detail/touches/interface.hpp>
+#include <boost/geometry/algorithms/detail/within/interface.hpp>
+#include <boost/geometry/algorithms/centroid.hpp>
+
+#include <boost/geometry/geometries/point.hpp>
+#include <boost/geometry/geometries/box.hpp>
+
+// Boost.Geometry.Index
+#include <boost/geometry/index/detail/config_begin.hpp>
+
+#include <boost/geometry/index/detail/assert.hpp>
+#include <boost/geometry/index/detail/exception.hpp>
+
+#include <boost/geometry/index/detail/rtree/options.hpp>
+
+#include <boost/geometry/index/indexable.hpp>
+#include <boost/geometry/index/equal_to.hpp>
+
+#include <boost/geometry/index/detail/translator.hpp>
+
+#include <boost/geometry/index/predicates.hpp>
+#include <boost/geometry/index/distance_predicates.hpp>
+#include <boost/geometry/index/detail/rtree/adaptors.hpp>
+
+#include <boost/geometry/index/detail/meta.hpp>
+#include <boost/geometry/index/detail/utilities.hpp>
+#include <boost/geometry/index/detail/rtree/node/node.hpp>
+
+#include <boost/geometry/index/detail/algorithms/is_valid.hpp>
+
+#include <boost/geometry/index/detail/rtree/visitors/insert.hpp>
+#include <boost/geometry/index/detail/rtree/visitors/iterator.hpp>
+#include <boost/geometry/index/detail/rtree/visitors/remove.hpp>
+#include <boost/geometry/index/detail/rtree/visitors/copy.hpp>
+#include <boost/geometry/index/detail/rtree/visitors/destroy.hpp>
+#include <boost/geometry/index/detail/rtree/visitors/spatial_query.hpp>
+#include <boost/geometry/index/detail/rtree/visitors/distance_query.hpp>
+#include <boost/geometry/index/detail/rtree/visitors/count.hpp>
+#include <boost/geometry/index/detail/rtree/visitors/children_box.hpp>
+
+#include <boost/geometry/index/detail/rtree/linear/linear.hpp>
+#include <boost/geometry/index/detail/rtree/quadratic/quadratic.hpp>
+#include <boost/geometry/index/detail/rtree/rstar/rstar.hpp>
+//#include <boost/geometry/extensions/index/detail/rtree/kmeans/kmeans.hpp>
+
+#include <boost/geometry/index/detail/rtree/pack_create.hpp>
+
+#include <boost/geometry/index/inserter.hpp>
+
+#include <boost/geometry/index/detail/rtree/utilities/view.hpp>
+
+#include <boost/geometry/index/detail/rtree/iterators.hpp>
+#include <boost/geometry/index/detail/rtree/query_iterators.hpp>
+
+#ifdef BOOST_GEOMETRY_INDEX_DETAIL_EXPERIMENTAL
+// serialization
+#include <boost/geometry/index/detail/serialization.hpp>
+#endif
+
+// TODO change the name to bounding_tree
+
+/*!
+\defgroup rtree_functions R-tree free functions (boost::geometry::index::)
+*/
+
+namespace boost { namespace geometry { namespace index {
+
+/*!
+\brief The R-tree spatial index.
+
+This is self-balancing spatial index capable to store various types of Values
+and balancing algorithms.
+
+\par Parameters
+The user must pass a type defining the Parameters which will
+be used in rtree creation process. This type is used e.g. to specify balancing
+algorithm with specific parameters like min and max number of elements in node.
+
+\par
+Predefined algorithms with compile-time parameters are:
+\li <tt>boost::geometry::index::linear</tt>,
+ \li <tt>boost::geometry::index::quadratic</tt>,
+ \li <tt>boost::geometry::index::rstar</tt>.
+
+\par
+Predefined algorithms with run-time parameters are:
+ \li \c boost::geometry::index::dynamic_linear,
+ \li \c boost::geometry::index::dynamic_quadratic,
+ \li \c boost::geometry::index::dynamic_rstar.
+
+\par IndexableGetter
+The object of IndexableGetter type translates from Value to Indexable each time
+r-tree requires it. This means that this operation is done for each Value
+access. Therefore the IndexableGetter should return the Indexable by
+a reference type. The Indexable should not be calculated since it could harm
+the performance. The default IndexableGetter can translate all types adapted
+to Point, Box or Segment concepts (called Indexables). Furthermore, it can
+handle <tt>std::pair<Indexable, T></tt>, <tt>boost::tuple<Indexable, ...></tt>
+and <tt>std::tuple<Indexable, ...></tt> when possible. For example, for Value
+of type <tt>std::pair<Box, int></tt>, the default IndexableGetter translates
+from <tt>std::pair<Box, int> const&</tt> to <tt>Box const&</tt>.
+
+\par EqualTo
+The object of EqualTo type compares Values and returns <tt>true</tt> if they
+are equal. It's similar to <tt>std::equal_to<></tt>. The default EqualTo
+returns the result of <tt>boost::geometry::equals()</tt> for types adapted to
+some Geometry concept defined in Boost.Geometry and the result of
+<tt>operator==</tt> for other types. Components of Pairs and Tuples are
+compared left-to-right.
+
+\tparam Value           The type of objects stored in the container.
+\tparam Parameters      Compile-time parameters.
+\tparam IndexableGetter The function object extracting Indexable from Value.
+\tparam EqualTo         The function object comparing objects of type Value.
+\tparam Allocator       The allocator used to allocate/deallocate memory,
+                        construct/destroy nodes and Values.
+*/
+template
+<
+    typename Value,
+    typename Parameters,
+    typename IndexableGetter = index::indexable<Value>,
+    typename EqualTo = index::equal_to<Value>,
+    typename Allocator = std::allocator<Value>
+>
+class rtree
+{
+    BOOST_COPYABLE_AND_MOVABLE(rtree)
+
+public:
+    /*! \brief The type of Value stored in the container. */
+    typedef Value value_type;
+    /*! \brief R-tree parameters type. */
+    typedef Parameters parameters_type;
+    /*! \brief The function object extracting Indexable from Value. */
+    typedef IndexableGetter indexable_getter;
+    /*! \brief The function object comparing objects of type Value. */
+    typedef EqualTo value_equal;
+    /*! \brief The type of allocator used by the container. */
+    typedef Allocator allocator_type;
+
+    // TODO: SHOULD THIS TYPE BE REMOVED?
+    /*! \brief The Indexable type to which Value is translated. */
+    typedef typename index::detail::indexable_type<
+        detail::translator<IndexableGetter, EqualTo>
+    >::type indexable_type;
+
+    /*! \brief The Box type used by the R-tree. */
+    typedef geometry::model::box<
+                geometry::model::point<
+                    typename coordinate_type<indexable_type>::type,
+                    dimension<indexable_type>::value,
+                    typename coordinate_system<indexable_type>::type
+                >
+            >
+    bounds_type;
+
+private:
+
+    typedef detail::translator<IndexableGetter, EqualTo> translator_type;
+
+    typedef bounds_type box_type;
+    typedef typename detail::rtree::options_type<Parameters>::type options_type;
+    typedef typename options_type::node_tag node_tag;
+    typedef detail::rtree::allocators<allocator_type, value_type, typename options_type::parameters_type, box_type, node_tag> allocators_type;
+
+    typedef typename detail::rtree::node<value_type, typename options_type::parameters_type, box_type, allocators_type, node_tag>::type node;
+    typedef typename detail::rtree::internal_node<value_type, typename options_type::parameters_type, box_type, allocators_type, node_tag>::type internal_node;
+    typedef typename detail::rtree::leaf<value_type, typename options_type::parameters_type, box_type, allocators_type, node_tag>::type leaf;
+
+    typedef typename allocators_type::node_pointer node_pointer;
+    typedef ::boost::container::allocator_traits<Allocator> allocator_traits_type;
+    typedef detail::rtree::subtree_destroyer<value_type, options_type, translator_type, box_type, allocators_type> subtree_destroyer;
+
+    friend class detail::rtree::utilities::view<rtree>;
+#ifdef BOOST_GEOMETRY_INDEX_DETAIL_EXPERIMENTAL
+    friend class detail::rtree::private_view<rtree>;
+    friend class detail::rtree::const_private_view<rtree>;
+#endif
+
+public:
+
+    /*! \brief Type of reference to Value. */
+    typedef typename allocators_type::reference reference;
+    /*! \brief Type of reference to const Value. */
+    typedef typename allocators_type::const_reference const_reference;
+    /*! \brief Type of pointer to Value. */
+    typedef typename allocators_type::pointer pointer;
+    /*! \brief Type of pointer to const Value. */
+    typedef typename allocators_type::const_pointer const_pointer;
+    /*! \brief Type of difference type. */
+    typedef typename allocators_type::difference_type difference_type;
+    /*! \brief Unsigned integral type used by the container. */
+    typedef typename allocators_type::size_type size_type;
+
+    /*! \brief Type of const iterator, category ForwardIterator. */
+    typedef index::detail::rtree::iterators::iterator
+        <
+            value_type, options_type, translator_type, box_type, allocators_type
+        > const_iterator;
+
+    /*! \brief Type of const query iterator, category ForwardIterator. */
+    typedef index::detail::rtree::iterators::query_iterator
+        <
+            value_type, allocators_type
+        > const_query_iterator;
+
+public:
+
+    /*!
+    \brief The constructor.
+
+    \param parameters   The parameters object.
+    \param getter       The function object extracting Indexable from Value.
+    \param equal        The function object comparing Values.
+
+    \par Throws
+    If allocator default constructor throws.
+    */
+    inline explicit rtree(parameters_type const& parameters = parameters_type(),
+                          indexable_getter const& getter = indexable_getter(),
+                          value_equal const& equal = value_equal())
+        : m_members(getter, equal, parameters)
+    {}
+
+    /*!
+    \brief The constructor.
+
+    \param parameters   The parameters object.
+    \param getter       The function object extracting Indexable from Value.
+    \param equal        The function object comparing Values.
+    \param allocator    The allocator object.
+
+    \par Throws
+    If allocator copy constructor throws.
+    */
+    inline rtree(parameters_type const& parameters,
+                 indexable_getter const& getter,
+                 value_equal const& equal,
+                 allocator_type const& allocator)
+        : m_members(getter, equal, parameters, allocator)
+    {}
+
+    /*!
+    \brief The constructor.
+
+    The tree is created using packing algorithm.
+
+    \param first        The beginning of the range of Values.
+    \param last         The end of the range of Values.
+    \param parameters   The parameters object.
+    \param getter       The function object extracting Indexable from Value.
+    \param equal        The function object comparing Values.
+    \param allocator    The allocator object.
+
+    \par Throws
+    \li If allocator copy constructor throws.
+    \li If Value copy constructor or copy assignment throws.
+    \li If allocation throws or returns invalid value.
+    */
+    template<typename Iterator>
+    inline rtree(Iterator first, Iterator last,
+                 parameters_type const& parameters = parameters_type(),
+                 indexable_getter const& getter = indexable_getter(),
+                 value_equal const& equal = value_equal(),
+                 allocator_type const& allocator = allocator_type())
+        : m_members(getter, equal, parameters, allocator)
+    {
+        typedef detail::rtree::pack<value_type, options_type, translator_type, box_type, allocators_type> pack;
+        size_type vc = 0, ll = 0;
+        m_members.root = pack::apply(first, last, vc, ll,
+                                     m_members.parameters(), m_members.translator(), m_members.allocators());
+        m_members.values_count = vc;
+        m_members.leafs_level = ll;
+    }
+
+    /*!
+    \brief The constructor.
+
+    The tree is created using packing algorithm.
+
+    \param rng          The range of Values.
+    \param parameters   The parameters object.
+    \param getter       The function object extracting Indexable from Value.
+    \param equal        The function object comparing Values.
+    \param allocator    The allocator object.
+
+    \par Throws
+    \li If allocator copy constructor throws.
+    \li If Value copy constructor or copy assignment throws.
+    \li If allocation throws or returns invalid value.
+    */
+    template<typename Range>
+    inline explicit rtree(Range const& rng,
+                          parameters_type const& parameters = parameters_type(),
+                          indexable_getter const& getter = indexable_getter(),
+                          value_equal const& equal = value_equal(),
+                          allocator_type const& allocator = allocator_type())
+        : m_members(getter, equal, parameters, allocator)
+    {
+        typedef detail::rtree::pack<value_type, options_type, translator_type, box_type, allocators_type> pack;
+        size_type vc = 0, ll = 0;
+        m_members.root = pack::apply(::boost::begin(rng), ::boost::end(rng), vc, ll,
+                                     m_members.parameters(), m_members.translator(), m_members.allocators());
+        m_members.values_count = vc;
+        m_members.leafs_level = ll;
+    }
+
+    /*!
+    \brief The destructor.
+
+    \par Throws
+    Nothing.
+    */
+    inline ~rtree()
+    {
+        this->raw_destroy(*this);
+    }
+
+    /*!
+    \brief  The copy constructor.
+
+    It uses parameters, translator and allocator from the source tree.
+
+    \param src          The rtree which content will be copied.
+
+    \par Throws
+    \li If allocator copy constructor throws.
+    \li If Value copy constructor throws.
+    \li If allocation throws or returns invalid value.
+    */
+    inline rtree(rtree const& src)
+        : m_members(src.m_members.indexable_getter(),
+                    src.m_members.equal_to(),
+                    src.m_members.parameters(),
+                    allocator_traits_type::select_on_container_copy_construction(src.get_allocator()))
+    {
+        this->raw_copy(src, *this, false);
+    }
+
+    /*!
+    \brief The copy constructor.
+
+    It uses Parameters and translator from the source tree.
+
+    \param src          The rtree which content will be copied.
+    \param allocator    The allocator which will be used.
+
+    \par Throws
+    \li If allocator copy constructor throws.
+    \li If Value copy constructor throws.
+    \li If allocation throws or returns invalid value.
+    */
+    inline rtree(rtree const& src, allocator_type const& allocator)
+        : m_members(src.m_members.indexable_getter(),
+                    src.m_members.equal_to(),
+                    src.m_members.parameters(), allocator)
+    {
+        this->raw_copy(src, *this, false);
+    }
+
+    /*!
+    \brief The moving constructor.
+
+    It uses parameters, translator and allocator from the source tree.
+
+    \param src          The rtree which content will be moved.
+
+    \par Throws
+    Nothing.
+    */
+    inline rtree(BOOST_RV_REF(rtree) src)
+        : m_members(src.m_members.indexable_getter(),
+                    src.m_members.equal_to(),
+                    src.m_members.parameters(),
+                    boost::move(src.m_members.allocators()))
+    {
+        boost::swap(m_members.values_count, src.m_members.values_count);
+        boost::swap(m_members.leafs_level, src.m_members.leafs_level);
+        boost::swap(m_members.root, src.m_members.root);
+    }
+
+    /*!
+    \brief The moving constructor.
+
+    It uses parameters and translator from the source tree.
+
+    \param src          The rtree which content will be moved.
+    \param allocator    The allocator.
+
+    \par Throws
+    \li If allocator copy constructor throws.
+    \li If Value copy constructor throws (only if allocators aren't equal).
+    \li If allocation throws or returns invalid value (only if allocators aren't equal).
+    */
+    inline rtree(BOOST_RV_REF(rtree) src, allocator_type const& allocator)
+        : m_members(src.m_members.indexable_getter(),
+                    src.m_members.equal_to(),
+                    src.m_members.parameters(),
+                    allocator)
+    {
+        if ( src.m_members.allocators() == allocator )
+        {
+            boost::swap(m_members.values_count, src.m_members.values_count);
+            boost::swap(m_members.leafs_level, src.m_members.leafs_level);
+            boost::swap(m_members.root, src.m_members.root);
+        }
+        else
+        {
+            this->raw_copy(src, *this, false);
+        }
+    }
+
+    /*!
+    \brief The assignment operator.
+
+    It uses parameters and translator from the source tree.
+
+    \param src          The rtree which content will be copied.
+
+    \par Throws
+    \li If Value copy constructor throws.
+    \li If allocation throws.
+    \li If allocation throws or returns invalid value.
+    */
+    inline rtree & operator=(BOOST_COPY_ASSIGN_REF(rtree) src)
+    {
+        if ( &src != this )
+        {
+            allocators_type & this_allocs = m_members.allocators();
+            allocators_type const& src_allocs = src.m_members.allocators();
+
+            // NOTE: if propagate is true for std allocators on darwin 4.2.1, glibc++
+            // (allocators stored as base classes of members_holder)
+            // copying them changes values_count, in this case it doesn't cause errors since data must be copied
+            
+            typedef boost::mpl::bool_<
+                allocator_traits_type::propagate_on_container_copy_assignment::value
+            > propagate;
+            
+            if ( propagate::value && !(this_allocs == src_allocs) )
+                this->raw_destroy(*this);
+            detail::assign_cond(this_allocs, src_allocs, propagate());
+
+            // It uses m_allocators
+            this->raw_copy(src, *this, true);
+        }
+
+        return *this;
+    }
+
+    /*!
+    \brief The moving assignment.
+
+    It uses parameters and translator from the source tree.
+
+    \param src          The rtree which content will be moved.
+
+    \par Throws
+    Only if allocators aren't equal.
+    \li If Value copy constructor throws.
+    \li If allocation throws or returns invalid value.
+    */
+    inline rtree & operator=(BOOST_RV_REF(rtree) src)
+    {
+        if ( &src != this )
+        {
+            allocators_type & this_allocs = m_members.allocators();
+            allocators_type & src_allocs = src.m_members.allocators();
+            
+            if ( this_allocs == src_allocs )
+            {
+                this->raw_destroy(*this);
+
+                m_members.indexable_getter() = src.m_members.indexable_getter();
+                m_members.equal_to() = src.m_members.equal_to();
+                m_members.parameters() = src.m_members.parameters();
+
+                boost::swap(m_members.values_count, src.m_members.values_count);
+                boost::swap(m_members.leafs_level, src.m_members.leafs_level);
+                boost::swap(m_members.root, src.m_members.root);
+
+                // NOTE: if propagate is true for std allocators on darwin 4.2.1, glibc++
+                // (allocators stored as base classes of members_holder)
+                // moving them changes values_count
+                
+                typedef boost::mpl::bool_<
+                    allocator_traits_type::propagate_on_container_move_assignment::value
+                > propagate;
+                detail::move_cond(this_allocs, src_allocs, propagate());
+            }
+            else
+            {
+// TODO - shouldn't here propagate_on_container_copy_assignment be checked like in operator=(const&)?
+
+                // It uses m_allocators
+                this->raw_copy(src, *this, true);
+            }
+        }
+
+        return *this;
+    }
+
+    /*!
+    \brief Swaps contents of two rtrees.
+
+    Parameters, translator and allocators are swapped as well.
+
+    \param other    The rtree which content will be swapped with this rtree content.
+
+    \par Throws
+    If allocators swap throws.
+    */
+    void swap(rtree & other)
+    {
+        boost::swap(m_members.indexable_getter(), other.m_members.indexable_getter());
+        boost::swap(m_members.equal_to(), other.m_members.equal_to());
+        boost::swap(m_members.parameters(), other.m_members.parameters());
+        
+        // NOTE: if propagate is true for std allocators on darwin 4.2.1, glibc++
+        // (allocators stored as base classes of members_holder)
+        // swapping them changes values_count
+        
+        typedef boost::mpl::bool_<
+            allocator_traits_type::propagate_on_container_swap::value
+        > propagate;
+        detail::swap_cond(m_members.allocators(), other.m_members.allocators(), propagate());
+
+        boost::swap(m_members.values_count, other.m_members.values_count);
+        boost::swap(m_members.leafs_level, other.m_members.leafs_level);
+        boost::swap(m_members.root, other.m_members.root);
+    }
+
+    /*!
+    \brief Insert a value to the index.
+
+    \param value    The value which will be stored in the container.
+
+    \par Throws
+    \li If Value copy constructor or copy assignment throws.
+    \li If allocation throws or returns invalid value.
+
+    \warning
+    This operation only guarantees that there will be no memory leaks.
+    After an exception is thrown the R-tree may be left in an inconsistent state,
+    elements must not be inserted or removed. Other operations are allowed however
+    some of them may return invalid data.
+    */
+    inline void insert(value_type const& value)
+    {
+        if ( !m_members.root )
+            this->raw_create();
+
+        this->raw_insert(value);
+    }
+
+    /*!
+    \brief Insert a range of values to the index.
+
+    \param first    The beginning of the range of values.
+    \param last     The end of the range of values.
+
+    \par Throws
+    \li If Value copy constructor or copy assignment throws.
+    \li If allocation throws or returns invalid value.
+
+    \warning
+    This operation only guarantees that there will be no memory leaks.
+    After an exception is thrown the R-tree may be left in an inconsistent state,
+    elements must not be inserted or removed. Other operations are allowed however
+    some of them may return invalid data.
+    */
+    template <typename Iterator>
+    inline void insert(Iterator first, Iterator last)
+    {
+        if ( !m_members.root )
+            this->raw_create();
+
+        for ( ; first != last ; ++first )
+            this->raw_insert(*first);
+    }
+
+    /*!
+    \brief Insert a value created using convertible object or a range of values to the index.
+
+    \param conv_or_rng      An object of type convertible to value_type or a range of values.
+
+    \par Throws
+    \li If Value copy constructor or copy assignment throws.
+    \li If allocation throws or returns invalid value.
+
+    \warning
+    This operation only guarantees that there will be no memory leaks.
+    After an exception is thrown the R-tree may be left in an inconsistent state,
+    elements must not be inserted or removed. Other operations are allowed however
+    some of them may return invalid data.
+    */
+    template <typename ConvertibleOrRange>
+    inline void insert(ConvertibleOrRange const& conv_or_rng)
+    {
+        if ( !m_members.root )
+            this->raw_create();
+
+        typedef boost::mpl::bool_
+            <
+                boost::is_convertible<ConvertibleOrRange, value_type>::value
+            > is_conv_t;
+
+        this->insert_dispatch(conv_or_rng, is_conv_t());
+    }
+
+    /*!
+    \brief Remove a value from the container.
+
+    In contrast to the \c std::set or <tt>std::map erase()</tt> method
+    this method removes only one value from the container.
+
+    \param value    The value which will be removed from the container.
+
+    \return         1 if the value was removed, 0 otherwise.
+
+    \par Throws
+    \li If Value copy constructor or copy assignment throws.
+    \li If allocation throws or returns invalid value.
+
+    \warning
+    This operation only guarantees that there will be no memory leaks.
+    After an exception is thrown the R-tree may be left in an inconsistent state,
+    elements must not be inserted or removed. Other operations are allowed however
+    some of them may return invalid data.
+    */
+    inline size_type remove(value_type const& value)
+    {
+        if ( !m_members.root )
+            return 0;
+
+        return this->raw_remove(value);
+    }
+
+    /*!
+    \brief Remove a range of values from the container.
+
+    In contrast to the \c std::set or <tt>std::map erase()</tt> method
+    it doesn't take iterators pointing to values stored in this container. It removes values equal
+    to these passed as a range. Furthermore this method removes only one value for each one passed
+    in the range, not all equal values.
+
+    \param first    The beginning of the range of values.
+    \param last     The end of the range of values.
+
+    \return         The number of removed values.
+
+    \par Throws
+    \li If Value copy constructor or copy assignment throws.
+    \li If allocation throws or returns invalid value.
+
+    \warning
+    This operation only guarantees that there will be no memory leaks.
+    After an exception is thrown the R-tree may be left in an inconsistent state,
+    elements must not be inserted or removed. Other operations are allowed however
+    some of them may return invalid data.
+    */
+    template <typename Iterator>
+    inline size_type remove(Iterator first, Iterator last)
+    {
+        size_type result = 0;
+
+        if ( !m_members.root )
+            return result;
+
+        for ( ; first != last ; ++first )
+            result += this->raw_remove(*first);
+        return result;
+    }
+
+    /*!
+    \brief Remove value corresponding to an object convertible to it or a range of values from the container.
+
+    In contrast to the \c std::set or <tt>std::map erase()</tt> method
+    it removes values equal to these passed as a range. Furthermore, this method removes only
+    one value for each one passed in the range, not all equal values.
+
+    \param conv_or_rng      The object of type convertible to value_type or a range of values.
+
+    \return         The number of removed values.
+
+    \par Throws
+    \li If Value copy constructor or copy assignment throws.
+    \li If allocation throws or returns invalid value.
+
+    \warning
+    This operation only guarantees that there will be no memory leaks.
+    After an exception is thrown the R-tree may be left in an inconsistent state,
+    elements must not be inserted or removed. Other operations are allowed however
+    some of them may return invalid data.
+    */
+    template <typename ConvertibleOrRange>
+    inline size_type remove(ConvertibleOrRange const& conv_or_rng)
+    {
+        if ( !m_members.root )
+            return 0;
+
+        typedef boost::mpl::bool_
+            <
+                boost::is_convertible<ConvertibleOrRange, value_type>::value
+            > is_conv_t;
+
+        return this->remove_dispatch(conv_or_rng, is_conv_t());
+    }
+
+    /*!
+    \brief Finds values meeting passed predicates e.g. nearest to some Point and/or intersecting some Box.
+
+    This query function performs spatial and k-nearest neighbor searches. It allows to pass a set of predicates.
+    Values will be returned only if all predicates are met.
+
+    <b>Spatial predicates</b>
+    
+    Spatial predicates may be generated by one of the functions listed below:
+    \li \c boost::geometry::index::contains(),
+    \li \c boost::geometry::index::covered_by(),
+    \li \c boost::geometry::index::covers(),
+    \li \c boost::geometry::index::disjoint(),
+    \li \c boost::geometry::index::intersects(),
+    \li \c boost::geometry::index::overlaps(),
+    \li \c boost::geometry::index::within(),
+
+    It is possible to negate spatial predicates:
+    \li <tt>! boost::geometry::index::contains()</tt>,
+    \li <tt>! boost::geometry::index::covered_by()</tt>,
+    \li <tt>! boost::geometry::index::covers()</tt>,
+    \li <tt>! boost::geometry::index::disjoint()</tt>,
+    \li <tt>! boost::geometry::index::intersects()</tt>,
+    \li <tt>! boost::geometry::index::overlaps()</tt>,
+    \li <tt>! boost::geometry::index::within()</tt>
+
+    <b>Satisfies predicate</b>
+    
+    This is a special kind of predicate which allows to pass a user-defined function or function object which checks
+    if Value should be returned by the query. It's generated by:
+    \li \c boost::geometry::index::satisfies().
+
+    <b>Nearest predicate</b>
+
+    If the nearest predicate is passed a k-nearest neighbor search will be performed. This query will result
+    in returning k values to the output iterator. Only one nearest predicate may be passed to the query.
+    It may be generated by:
+    \li \c boost::geometry::index::nearest().
+        
+    <b>Connecting predicates</b>
+
+    Predicates may be passed together connected with \c operator&&().
+
+    \par Example
+    \verbatim
+    // return elements intersecting box
+    tree.query(bgi::intersects(box), std::back_inserter(result));
+    // return elements intersecting poly but not within box
+    tree.query(bgi::intersects(poly) && !bgi::within(box), std::back_inserter(result));
+    // return elements overlapping box and meeting my_fun unary predicate
+    tree.query(bgi::overlaps(box) && bgi::satisfies(my_fun), std::back_inserter(result));
+    // return 5 elements nearest to pt and elements are intersecting box
+    tree.query(bgi::nearest(pt, 5) && bgi::intersects(box), std::back_inserter(result));
+
+    // For each found value do_something (it is a type of function object)
+    tree.query(bgi::intersects(box),
+               boost::make_function_output_iterator(do_something()));
+
+    // For each value stored in the rtree do_something
+    // always_true is a type of function object always returning true
+    tree.query(bgi::satisfies(always_true()),
+               boost::make_function_output_iterator(do_something()));
+
+    // C++11 (lambda expression)
+    tree.query(bgi::intersects(box),
+               boost::make_function_output_iterator([](value_type const& val){
+                   // do something
+               }));
+
+    // C++14 (generic lambda expression)
+    tree.query(bgi::intersects(box),
+               boost::make_function_output_iterator([](auto const& val){
+                   // do something
+               }));
+    \endverbatim
+
+    \par Throws
+    If Value copy constructor or copy assignment throws.
+    If predicates copy throws.
+
+    \warning
+    Only one \c nearest() perdicate may be passed to the query. Passing more of them results in compile-time error.
+
+    \param predicates   Predicates.
+    \param out_it       The output iterator, e.g. generated by std::back_inserter().
+
+    \return             The number of values found.
+    */
+    template <typename Predicates, typename OutIter>
+    size_type query(Predicates const& predicates, OutIter out_it) const
+    {
+        if ( !m_members.root )
+            return 0;
+
+        static const unsigned distance_predicates_count = detail::predicates_count_distance<Predicates>::value;
+        static const bool is_distance_predicate = 0 < distance_predicates_count;
+        BOOST_MPL_ASSERT_MSG((distance_predicates_count <= 1), PASS_ONLY_ONE_DISTANCE_PREDICATE, (Predicates));
+
+        return query_dispatch(predicates, out_it, boost::mpl::bool_<is_distance_predicate>());
+    }
+
+    /*!
+    \brief Returns a query iterator pointing at the begin of the query range.
+
+    This method returns an iterator which may be used to perform iterative queries.
+    For the information about predicates which may be passed to this method see query().
+
+    \par Example
+    \verbatim    
+    for ( Rtree::const_query_iterator it = tree.qbegin(bgi::nearest(pt, 10000)) ;
+          it != tree.qend() ; ++it )
+    {
+        // do something with value
+        if ( has_enough_nearest_values() )
+            break;
+    }
+
+    // C++11 (auto)
+    for ( auto it = tree.qbegin(bgi::nearest(pt, 3)) ; it != tree.qend() ; ++it )
+    {
+        // do something with value
+    }
+
+    // C++14 (generic lambda expression)
+    std::for_each(tree.qbegin(bgi::nearest(pt, 3)), tree.qend(), [](auto const& val){
+        // do something with value
+    });
+    \endverbatim
+
+    \par Iterator category
+    ForwardIterator
+
+    \par Throws
+    If predicates copy throws.
+    If allocation throws.
+
+    \warning
+    The modification of the rtree may invalidate the iterators.
+
+    \param predicates   Predicates.
+    
+    \return             The iterator pointing at the begin of the query range.
+    */
+    template <typename Predicates>
+    const_query_iterator qbegin(Predicates const& predicates) const
+    {
+        return const_query_iterator(qbegin_(predicates));
+    }
+
+    /*!
+    \brief Returns a query iterator pointing at the end of the query range.
+
+    This method returns an iterator which may be used to check if the query has ended.
+
+    \par Example
+    \verbatim    
+    for ( Rtree::const_query_iterator it = tree.qbegin(bgi::nearest(pt, 10000)) ;
+          it != tree.qend() ; ++it )
+    {
+        // do something with value
+        if ( has_enough_nearest_values() )
+            break;
+    }
+
+    // C++11 (auto)
+    for ( auto it = tree.qbegin(bgi::nearest(pt, 3)) ; it != tree.qend() ; ++it )
+    {
+        // do something with value
+    }
+
+    // C++14 (generic lambda expression)
+    std::for_each(tree.qbegin(bgi::nearest(pt, 3)), tree.qend(), [](auto const& val){
+        // do something with value
+    });
+    \endverbatim
+
+    \par Iterator category
+    ForwardIterator
+
+    \par Throws
+    Nothing
+
+    \warning
+    The modification of the rtree may invalidate the iterators.
+    
+    \return             The iterator pointing at the end of the query range.
+    */
+    const_query_iterator qend() const
+    {
+        return const_query_iterator();
+    }
+
+#ifndef BOOST_GEOMETRY_INDEX_DETAIL_EXPERIMENTAL
+private:
+#endif
+    /*!
+    \brief Returns a query iterator pointing at the begin of the query range.
+
+    This method returns an iterator which may be used to perform iterative queries.
+    For the information about predicates which may be passed to this method see query().
+    
+    The type of the returned iterator depends on the type of passed Predicates but the iterator of this type
+    may be assigned to the variable of const_query_iterator type. If you'd like to use the type of the iterator
+    returned by this method you may get the type e.g. by using C++11 decltype or Boost.Typeof library.
+    This iterator may be compared with iterators returned by both versions of qend() method.
+
+    \par Example
+    \verbatim
+    // Store the result in the container using std::copy() - it requires both iterators of the same type
+    std::copy(tree.qbegin_(bgi::intersects(box)), tree.qend_(bgi::intersects(box)), std::back_inserter(result));
+
+    // Store the result in the container using std::copy() and type-erased iterators
+    Rtree::const_query_iterator first = tree.qbegin_(bgi::intersects(box));
+    Rtree::const_query_iterator last = tree.qend_();
+    std::copy(first, last, std::back_inserter(result));
+
+    // Boost.Typeof
+    typedef BOOST_TYPEOF(tree.qbegin(bgi::nearest(pt, 10000))) Iter;
+    for ( Iter it = tree.qbegin_(bgi::nearest(pt, 10000)) ; it != tree.qend_() ; ++it )
+    {
+        // do something with value
+        if ( has_enough_nearest_values() )
+            break;
+    }
+
+    // C++11 (auto)
+    for ( auto it = tree.qbegin_(bgi::nearest(pt, 10000)) ; it != tree.qend_() ; ++it )
+    {
+        // do something with value
+        if ( has_enough_nearest_values() )
+            break;
+    }
+    \endverbatim
+
+    \par Iterator category
+    ForwardIterator
+
+    \par Throws
+    If predicates copy throws.
+    If allocation throws.
+
+    \warning
+    The modification of the rtree may invalidate the iterators.
+
+    \param predicates   Predicates.
+    
+    \return             The iterator pointing at the begin of the query range.
+    */
+    template <typename Predicates>
+    typename boost::mpl::if_c<
+        detail::predicates_count_distance<Predicates>::value == 0,
+        detail::rtree::iterators::spatial_query_iterator<value_type, options_type, translator_type, box_type, allocators_type, Predicates>,
+        detail::rtree::iterators::distance_query_iterator<
+            value_type, options_type, translator_type, box_type, allocators_type, Predicates,
+            detail::predicates_find_distance<Predicates>::value
+        >
+    >::type
+    qbegin_(Predicates const& predicates) const
+    {
+        static const unsigned distance_predicates_count = detail::predicates_count_distance<Predicates>::value;
+        BOOST_MPL_ASSERT_MSG((distance_predicates_count <= 1), PASS_ONLY_ONE_DISTANCE_PREDICATE, (Predicates));
+
+        typedef typename boost::mpl::if_c<
+            detail::predicates_count_distance<Predicates>::value == 0,
+            detail::rtree::iterators::spatial_query_iterator<value_type, options_type, translator_type, box_type, allocators_type, Predicates>,
+            detail::rtree::iterators::distance_query_iterator<
+                value_type, options_type, translator_type, box_type, allocators_type, Predicates,
+                detail::predicates_find_distance<Predicates>::value
+            >
+        >::type iterator_type;
+
+        if ( !m_members.root )
+            return iterator_type(m_members.translator(), predicates);
+
+        return iterator_type(m_members.root, m_members.translator(), predicates);
+    }
+
+    /*!
+    \brief Returns the query iterator pointing at the end of the query range.
+
+    This method returns the iterator which may be used to perform iterative queries. For the information
+    about the predicates which may be passed to this method see query().
+    
+    The type of the returned iterator depends on the type of passed Predicates but the iterator of this type
+    may be assigned to the variable of const_query_iterator type. If you'd like to use the type of the iterator
+    returned by this method you may get the type e.g. by using C++11 decltype or Boost.Typeof library.
+
+    The type of the iterator returned by this method is the same as the one returned by qbegin() to which
+    the same predicates were passed.
+
+    \par Example
+    \verbatim
+    // Store the result in the container using std::copy() - it requires both iterators of the same type
+    std::copy(tree.qbegin_(bgi::intersects(box)), tree.qend_(bgi::intersects(box)), std::back_inserter(result));
+    \endverbatim
+
+    \par Iterator category
+    ForwardIterator
+
+    \par Throws
+    If predicates copy throws.
+
+    \warning
+    The modification of the rtree may invalidate the iterators.
+
+    \param predicates   Predicates.
+    
+    \return             The iterator pointing at the end of the query range.
+    */
+    template <typename Predicates>
+    typename boost::mpl::if_c<
+        detail::predicates_count_distance<Predicates>::value == 0,
+        detail::rtree::iterators::spatial_query_iterator<value_type, options_type, translator_type, box_type, allocators_type, Predicates>,
+        detail::rtree::iterators::distance_query_iterator<
+            value_type, options_type, translator_type, box_type, allocators_type, Predicates,
+            detail::predicates_find_distance<Predicates>::value
+        >
+    >::type
+    qend_(Predicates const& predicates) const
+    {
+        static const unsigned distance_predicates_count = detail::predicates_count_distance<Predicates>::value;
+        BOOST_MPL_ASSERT_MSG((distance_predicates_count <= 1), PASS_ONLY_ONE_DISTANCE_PREDICATE, (Predicates));
+
+        typedef typename boost::mpl::if_c<
+            detail::predicates_count_distance<Predicates>::value == 0,
+            detail::rtree::iterators::spatial_query_iterator<value_type, options_type, translator_type, box_type, allocators_type, Predicates>,
+            detail::rtree::iterators::distance_query_iterator<
+                value_type, options_type, translator_type, box_type, allocators_type, Predicates,
+                detail::predicates_find_distance<Predicates>::value
+            >
+        >::type iterator_type;
+
+        return iterator_type(m_members.translator(), predicates);
+    }
+
+    /*!
+    \brief Returns the query iterator pointing at the end of the query range.
+
+    This method returns the iterator which may be compared with the iterator returned by qbegin() in order to
+    check if the query has ended.
+    
+    The type of the returned iterator is different than the type returned by qbegin() but the iterator of this type
+    may be assigned to the variable of const_query_iterator type. If you'd like to use the type of the iterator returned by this
+    method, which most certainly will be faster than the type-erased iterator, you may get the type
+    e.g. by using C++11 decltype or Boost.Typeof library.
+
+    The type of the iterator returned by this method is dfferent than the type returned by qbegin().
+
+    \par Example
+    \verbatim
+    // Store the result in the container using std::copy() and type-erased iterators
+    Rtree::const_query_iterator first = tree.qbegin_(bgi::intersects(box));
+    Rtree::const_query_iterator last = tree.qend_();
+    std::copy(first, last, std::back_inserter(result));
+
+    // Boost.Typeof
+    typedef BOOST_TYPEOF(tree.qbegin(bgi::nearest(pt, 10000))) Iter;
+    for ( Iter it = tree.qbegin_(bgi::nearest(pt, 10000)) ; it != tree.qend_() ; ++it )
+    {
+        // do something with value
+        if ( has_enough_nearest_values() )
+            break;
+    }
+
+    // C++11 (auto)
+    for ( auto it = tree.qbegin_(bgi::nearest(pt, 10000)) ; it != tree.qend_() ; ++it )
+    {
+        // do something with value
+        if ( has_enough_nearest_values() )
+            break;
+    }
+    \endverbatim
+
+    \par Iterator category
+    ForwardIterator
+
+    \par Throws
+    Nothing
+
+    \warning
+    The modification of the rtree may invalidate the iterators.
+    
+    \return             The iterator pointing at the end of the query range.
+    */
+    detail::rtree::iterators::end_query_iterator<value_type, allocators_type>
+    qend_() const
+    {
+        return detail::rtree::iterators::end_query_iterator<value_type, allocators_type>();
+    }
+
+public:
+
+    /*!
+    \brief Returns the iterator pointing at the begin of the rtree values range.
+
+    This method returns the iterator which may be used to iterate over all values
+    stored in the rtree.
+
+    \par Example
+    \verbatim
+    // Copy all values into the vector
+    std::copy(tree.begin(), tree.end(), std::back_inserter(vec));
+
+    for ( Rtree::const_iterator it = tree.begin() ; it != tree.end() ; ++it )
+    {
+        // do something with value
+    }
+
+    // C++11 (auto)
+    for ( auto it = tree.begin() ; it != tree.end() ; ++it )
+    {
+        // do something with value
+    }
+
+    // C++14 (generic lambda expression)
+    std::for_each(tree.begin(), tree.end(), [](auto const& val){
+        // do something with value
+    })
+    \endverbatim
+
+    \par Iterator category
+    ForwardIterator
+
+    \par Throws
+    If allocation throws.
+
+    \warning
+    The modification of the rtree may invalidate the iterators.
+
+    \return             The iterator pointing at the begin of the range.
+    */
+    const_iterator begin() const
+    {
+        if ( !m_members.root )
+            return const_iterator();
+
+        return const_iterator(m_members.root);
+    }
+
+    /*!
+    \brief Returns the iterator pointing at the end of the rtree values range.
+
+    This method returns the iterator which may be compared with the iterator returned by begin()
+    in order to check if the iteration has ended.
+
+    \par Example
+    \verbatim
+    for ( Rtree::const_iterator it = tree.begin() ; it != tree.end() ; ++it )
+    {
+        // do something with value
+    }
+
+    // C++11 (lambda expression)
+    std::for_each(tree.begin(), tree.end(), [](value_type const& val){
+        // do something with value
+    })
+    \endverbatim
+
+    \par Iterator category
+    ForwardIterator
+
+    \par Throws
+    Nothing.
+
+    \warning
+    The modification of the rtree may invalidate the iterators.
+
+    \return             The iterator pointing at the end of the range.
+    */
+    const_iterator end() const
+    {
+        return const_iterator();
+    }
+
+    /*!
+    \brief Returns the number of stored values.
+
+    \return         The number of stored values.
+
+    \par Throws
+    Nothing.
+    */
+    inline size_type size() const
+    {
+        return m_members.values_count;
+    }
+
+    /*!
+    \brief Query if the container is empty.
+
+    \return         true if the container is empty.
+
+    \par Throws
+    Nothing.
+    */
+    inline bool empty() const
+    {
+        return 0 == m_members.values_count;
+    }
+
+    /*!
+    \brief Removes all values stored in the container.
+
+    \par Throws
+    Nothing.
+    */
+    inline void clear()
+    {
+        this->raw_destroy(*this);
+    }
+
+    /*!
+    \brief Returns the box able to contain all values stored in the container.
+
+    Returns the box able to contain all values stored in the container.
+    If the container is empty the result of \c geometry::assign_inverse() is returned.
+
+    \return     The box able to contain all values stored in the container or an invalid box if
+                there are no values in the container.
+
+    \par Throws
+    Nothing.
+    */
+    inline bounds_type bounds() const
+    {
+        bounds_type result;
+        // in order to suppress the uninitialized variable warnings
+        geometry::assign_inverse(result);
+
+        if ( m_members.root )
+        {
+            detail::rtree::visitors::children_box<value_type, options_type, translator_type, box_type, allocators_type>
+                box_v(result, m_members.translator());
+            detail::rtree::apply_visitor(box_v, *m_members.root);
+        }
+
+        return result;
+    }
+
+    /*!
+    \brief Count Values or Indexables stored in the container.
+    
+    For indexable_type it returns the number of values which indexables equals the parameter.
+    For value_type it returns the number of values which equals the parameter.
+
+    \param vori The value or indexable which will be counted.
+
+    \return     The number of values found.
+
+    \par Throws
+    Nothing.
+    */
+    template <typename ValueOrIndexable>
+    size_type count(ValueOrIndexable const& vori) const
+    {
+        if ( !m_members.root )
+            return 0;
+
+        // the input should be convertible to Value or Indexable type
+
+        enum { as_val = 0, as_ind, dont_know };
+        typedef boost::mpl::int_
+            <
+                boost::is_same<ValueOrIndexable, value_type>::value ?
+                    as_val :
+                    boost::is_same<ValueOrIndexable, indexable_type>::value ?
+                        as_ind :
+                        boost::is_convertible<ValueOrIndexable, indexable_type>::value ?
+                            as_ind :
+                            boost::is_convertible<ValueOrIndexable, value_type>::value ?
+                                as_val :
+                                dont_know
+            > variant;
+
+        BOOST_MPL_ASSERT_MSG((variant::value != dont_know),
+                             PASSED_OBJECT_NOT_CONVERTIBLE_TO_VALUE_NOR_INDEXABLE_TYPE,
+                             (ValueOrIndexable));
+
+        typedef typename boost::mpl::if_c
+            <
+                variant::value == as_val,
+                value_type,
+                indexable_type
+            >::type value_or_indexable;
+
+        // NOTE: If an object of convertible but not the same type is passed
+        // into the function, here a temporary will be created.
+        return this->template raw_count<value_or_indexable>(vori);
+    }
+
+    /*!
+    \brief Returns parameters.
+
+    \return     The parameters object.
+
+    \par Throws
+    Nothing.
+    */
+    inline parameters_type parameters() const
+    {
+        return m_members.parameters();
+    }
+
+    /*!
+    \brief Returns function retrieving Indexable from Value.
+
+    \return     The indexable_getter object.
+
+    \par Throws
+    Nothing.
+    */
+    indexable_getter indexable_get() const
+    {
+        return m_members.indexable_getter();
+    }
+
+    /*!
+    \brief Returns function comparing Values
+
+    \return     The value_equal function.
+
+    \par Throws
+    Nothing.
+    */
+    value_equal value_eq() const
+    {
+        return m_members.equal_to();
+    }
+
+    /*!
+    \brief Returns allocator used by the rtree.
+
+    \return     The allocator.
+
+    \par Throws
+    If allocator copy constructor throws.
+    */
+    allocator_type get_allocator() const
+    {
+        return m_members.allocators().allocator();
+    }
+
+private:
+
+    /*!
+    \brief Returns the translator object.
+
+    \return     The translator object.
+
+    \par Throws
+    Nothing.
+    */
+    inline translator_type translator() const
+    {
+        return m_members.translator();
+    }
+
+    /*!
+    \brief Apply a visitor to the nodes structure in order to perform some operator.
+
+    This function is not a part of the 'official' interface. However it makes
+    possible e.g. to pass a visitor drawing the tree structure.
+
+    \param visitor  The visitor object.
+
+    \par Throws
+    If Visitor::operator() throws.
+    */
+    template <typename Visitor>
+    inline void apply_visitor(Visitor & visitor) const
+    {
+        if ( m_members.root )
+            detail::rtree::apply_visitor(visitor, *m_members.root);
+    }
+
+    /*!
+    \brief Returns the depth of the R-tree.
+
+    This function is not a part of the 'official' interface.
+
+    \return     The depth of the R-tree.
+
+    \par Throws
+    Nothing.
+    */
+    inline size_type depth() const
+    {
+        return m_members.leafs_level;
+    }
+
+private:
+
+    /*!
+    \pre Root node must exist - m_root != 0.
+
+    \brief Insert a value to the index.
+
+    \param value    The value which will be stored in the container.
+
+    \par Exception-safety
+    basic
+    */
+    inline void raw_insert(value_type const& value)
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(m_members.root, "The root must exist");
+        // CONSIDER: alternative - ignore invalid indexable or throw an exception
+        BOOST_GEOMETRY_INDEX_ASSERT(detail::is_valid(m_members.translator()(value)), "Indexable is invalid");
+
+        detail::rtree::visitors::insert<
+            value_type,
+            value_type, options_type, translator_type, box_type, allocators_type,
+            typename options_type::insert_tag
+        > insert_v(m_members.root, m_members.leafs_level, value,
+                   m_members.parameters(), m_members.translator(), m_members.allocators());
+
+        detail::rtree::apply_visitor(insert_v, *m_members.root);
+
+// TODO
+// Think about this: If exception is thrown, may the root be removed?
+// Or it is just cleared?
+
+// TODO
+// If exception is thrown, m_values_count may be invalid
+        ++m_members.values_count;
+    }
+
+    /*!
+    \brief Remove the value from the container.
+
+    \param value    The value which will be removed from the container.
+
+    \par Exception-safety
+    basic
+    */
+    inline size_type raw_remove(value_type const& value)
+    {
+        // TODO: awulkiew - assert for correct value (indexable) ?
+        BOOST_GEOMETRY_INDEX_ASSERT(m_members.root, "The root must exist");
+
+        detail::rtree::visitors::remove<
+            value_type, options_type, translator_type, box_type, allocators_type
+        > remove_v(m_members.root, m_members.leafs_level, value,
+                   m_members.parameters(), m_members.translator(), m_members.allocators());
+
+        detail::rtree::apply_visitor(remove_v, *m_members.root);
+
+        // If exception is thrown, m_values_count may be invalid
+
+        if ( remove_v.is_value_removed() )
+        {
+            BOOST_GEOMETRY_INDEX_ASSERT(0 < m_members.values_count, "unexpected state");
+
+            --m_members.values_count;
+
+            return 1;
+        }
+
+        return 0;
+    }
+
+    /*!
+    \brief Create an empty R-tree i.e. new empty root node and clear other attributes.
+
+    \par Exception-safety
+    strong
+    */
+    inline void raw_create()
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(0 == m_members.root, "the tree is already created");
+
+        m_members.root = detail::rtree::create_node<allocators_type, leaf>::apply(m_members.allocators()); // MAY THROW (N: alloc)
+        m_members.values_count = 0;
+        m_members.leafs_level = 0;
+    }
+
+    /*!
+    \brief Destroy the R-tree i.e. all nodes and clear attributes.
+
+    \param t    The container which is going to be destroyed.
+
+    \par Exception-safety
+    nothrow
+    */
+    inline void raw_destroy(rtree & t)
+    {
+        if ( t.m_members.root )
+        {
+            detail::rtree::visitors::destroy<value_type, options_type, translator_type, box_type, allocators_type>
+                del_v(t.m_members.root, t.m_members.allocators());
+            detail::rtree::apply_visitor(del_v, *t.m_members.root);
+
+            t.m_members.root = 0;
+        }
+        t.m_members.values_count = 0;
+        t.m_members.leafs_level = 0;
+    }
+
+    /*!
+    \brief Copy the R-tree i.e. whole nodes structure, values and other attributes.
+    It uses destination's allocators to create the new structure.
+
+    \param src                  The source R-tree.
+    \param dst                  The destination R-tree.
+    \param copy_tr_and_params   If true, translator and parameters will also be copied.
+
+    \par Exception-safety
+    strong
+    */
+    inline void raw_copy(rtree const& src, rtree & dst, bool copy_tr_and_params) const
+    {
+        detail::rtree::visitors::copy<value_type, options_type, translator_type, box_type, allocators_type>
+            copy_v(dst.m_members.allocators());
+
+        if ( src.m_members.root )
+            detail::rtree::apply_visitor(copy_v, *src.m_members.root);                      // MAY THROW (V, E: alloc, copy, N: alloc)
+
+        if ( copy_tr_and_params )
+        {
+            dst.m_members.indexable_getter() = src.m_members.indexable_getter();
+            dst.m_members.equal_to() = src.m_members.equal_to();
+            dst.m_members.parameters() = src.m_members.parameters();
+        }
+
+        // TODO use subtree_destroyer
+        if ( dst.m_members.root )
+        {
+            detail::rtree::visitors::destroy<value_type, options_type, translator_type, box_type, allocators_type>
+                del_v(dst.m_members.root, dst.m_members.allocators());
+            detail::rtree::apply_visitor(del_v, *dst.m_members.root);
+            dst.m_members.root = 0;
+        }
+
+        dst.m_members.root = copy_v.result;
+        dst.m_members.values_count = src.m_members.values_count;
+        dst.m_members.leafs_level = src.m_members.leafs_level;
+    }
+
+    /*!
+    \brief Insert a value corresponding to convertible object into the index.
+
+    \param val_conv    The object convertible to value.
+
+    \par Exception-safety
+    basic
+    */
+    template <typename ValueConvertible>
+    inline void insert_dispatch(ValueConvertible const& val_conv,
+                                boost::mpl::bool_<true> const& /*is_convertible*/)
+    {
+        this->raw_insert(val_conv);
+    }
+
+    /*!
+    \brief Insert a range of values into the index.
+
+    \param rng    The range of values.
+
+    \par Exception-safety
+    basic
+    */
+    template <typename Range>
+    inline void insert_dispatch(Range const& rng,
+                                boost::mpl::bool_<false> const& /*is_convertible*/)
+    {
+        BOOST_MPL_ASSERT_MSG((detail::is_range<Range>::value),
+                             PASSED_OBJECT_IS_NOT_CONVERTIBLE_TO_VALUE_NOR_A_RANGE,
+                             (Range));
+
+        typedef typename boost::range_const_iterator<Range>::type It;
+        for ( It it = boost::const_begin(rng); it != boost::const_end(rng) ; ++it )
+            this->raw_insert(*it);
+    }
+
+    /*!
+    \brief Remove a value corresponding to convertible object from the index.
+
+    \param val_conv    The object convertible to value.
+
+    \par Exception-safety
+    basic
+    */
+    template <typename ValueConvertible>
+    inline size_type remove_dispatch(ValueConvertible const& val_conv,
+                                     boost::mpl::bool_<true> const& /*is_convertible*/)
+    {
+        return this->raw_remove(val_conv);
+    }
+
+    /*!
+    \brief Remove a range of values from the index.
+
+    \param rng    The range of values which will be removed from the container.
+
+    \par Exception-safety
+    basic
+    */
+    template <typename Range>
+    inline size_type remove_dispatch(Range const& rng,
+                                     boost::mpl::bool_<false> const& /*is_convertible*/)
+    {
+        BOOST_MPL_ASSERT_MSG((detail::is_range<Range>::value),
+                             PASSED_OBJECT_IS_NOT_CONVERTIBLE_TO_VALUE_NOR_A_RANGE,
+                             (Range));
+
+        size_type result = 0;
+        typedef typename boost::range_const_iterator<Range>::type It;
+        for ( It it = boost::const_begin(rng); it != boost::const_end(rng) ; ++it )
+            result += this->raw_remove(*it);
+        return result;
+    }
+
+    /*!
+    \brief Return values meeting predicates.
+
+    \par Exception-safety
+    strong
+    */
+    template <typename Predicates, typename OutIter>
+    size_type query_dispatch(Predicates const& predicates, OutIter out_it, boost::mpl::bool_<false> const& /*is_distance_predicate*/) const
+    {
+        detail::rtree::visitors::spatial_query<value_type, options_type, translator_type, box_type, allocators_type, Predicates, OutIter>
+            find_v(m_members.translator(), predicates, out_it);
+
+        detail::rtree::apply_visitor(find_v, *m_members.root);
+
+        return find_v.found_count;
+    }
+
+    /*!
+    \brief Perform nearest neighbour search.
+
+    \par Exception-safety
+    strong
+    */
+    template <typename Predicates, typename OutIter>
+    size_type query_dispatch(Predicates const& predicates, OutIter out_it, boost::mpl::bool_<true> const& /*is_distance_predicate*/) const
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(m_members.root, "The root must exist");
+
+        static const unsigned distance_predicate_index = detail::predicates_find_distance<Predicates>::value;
+        detail::rtree::visitors::distance_query<
+            value_type,
+            options_type,
+            translator_type,
+            box_type,
+            allocators_type,
+            Predicates,
+            distance_predicate_index,
+            OutIter
+        > distance_v(m_members.parameters(), m_members.translator(), predicates, out_it);
+
+        detail::rtree::apply_visitor(distance_v, *m_members.root);
+
+        return distance_v.finish();
+    }
+    
+    /*!
+    \brief Count elements corresponding to value or indexable.
+
+    \par Exception-safety
+    strong
+    */
+    template <typename ValueOrIndexable>
+    size_type raw_count(ValueOrIndexable const& vori) const
+    {
+        BOOST_GEOMETRY_INDEX_ASSERT(m_members.root, "The root must exist");
+
+        detail::rtree::visitors::count
+            <
+                ValueOrIndexable,
+                value_type,
+                options_type,
+                translator_type,
+                box_type,
+                allocators_type
+            > count_v(vori, m_members.translator());
+
+        detail::rtree::apply_visitor(count_v, *m_members.root);
+
+        return count_v.found_count;
+    }
+
+    struct members_holder
+        : public translator_type
+        , public Parameters
+        , public allocators_type
+    {
+    private:
+        members_holder(members_holder const&);
+        members_holder & operator=(members_holder const&);
+
+    public:
+        template <typename IndGet, typename ValEq, typename Alloc>
+        members_holder(IndGet const& ind_get,
+                       ValEq const& val_eq,
+                       Parameters const& parameters,
+                       BOOST_FWD_REF(Alloc) alloc)
+            : translator_type(ind_get, val_eq)
+            , Parameters(parameters)
+            , allocators_type(boost::forward<Alloc>(alloc))
+            , values_count(0)
+            , leafs_level(0)
+            , root(0)
+        {}
+
+        template <typename IndGet, typename ValEq>
+        members_holder(IndGet const& ind_get,
+                       ValEq const& val_eq,
+                       Parameters const& parameters)
+            : translator_type(ind_get, val_eq)
+            , Parameters(parameters)
+            , allocators_type()
+            , values_count(0)
+            , leafs_level(0)
+            , root(0)
+        {}
+
+        translator_type const& translator() const { return *this; }
+
+        IndexableGetter const& indexable_getter() const { return *this; }
+        IndexableGetter & indexable_getter() { return *this; }
+        EqualTo const& equal_to() const { return *this; }
+        EqualTo & equal_to() { return *this; }
+        Parameters const& parameters() const { return *this; }
+        Parameters & parameters() { return *this; }
+        allocators_type const& allocators() const { return *this; }
+        allocators_type & allocators() { return *this; }
+
+        size_type values_count;
+        size_type leafs_level;
+        node_pointer root;
+    };
+
+    members_holder m_members;
+};
+
+/*!
+\brief Insert a value to the index.
+
+It calls <tt>rtree::insert(value_type const&)</tt>.
+
+\ingroup rtree_functions
+
+\param tree The spatial index.
+\param v    The value which will be stored in the index.
+*/
+template <typename Value, typename Parameters, typename IndexableGetter, typename EqualTo, typename Allocator>
+inline void insert(rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator> & tree,
+                   Value const& v)
+{
+    tree.insert(v);
+}
+
+/*!
+\brief Insert a range of values to the index.
+
+It calls <tt>rtree::insert(Iterator, Iterator)</tt>.
+
+\ingroup rtree_functions
+
+\param tree     The spatial index.
+\param first    The beginning of the range of values.
+\param last     The end of the range of values.
+*/
+template<typename Value, typename Parameters, typename IndexableGetter, typename EqualTo, typename Allocator,
+         typename Iterator>
+inline void insert(rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator> & tree,
+                   Iterator first, Iterator last)
+{
+    tree.insert(first, last);
+}
+
+/*!
+\brief Insert a value created using convertible object or a range of values to the index.
+
+It calls <tt>rtree::insert(ConvertibleOrRange const&)</tt>.
+
+\ingroup rtree_functions
+
+\param tree             The spatial index.
+\param conv_or_rng      The object of type convertible to value_type or a range of values.
+*/
+template<typename Value, typename Parameters, typename IndexableGetter, typename EqualTo, typename Allocator,
+         typename ConvertibleOrRange>
+inline void insert(rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator> & tree,
+                   ConvertibleOrRange const& conv_or_rng)
+{
+    tree.insert(conv_or_rng);
+}
+
+/*!
+\brief Remove a value from the container.
+
+Remove a value from the container. In contrast to the \c std::set or <tt>std::map erase()</tt> method
+this function removes only one value from the container.
+
+It calls <tt>rtree::remove(value_type const&)</tt>.
+
+\ingroup rtree_functions
+
+\param tree The spatial index.
+\param v    The value which will be removed from the index.
+
+\return     1 if value was removed, 0 otherwise.
+*/
+template <typename Value, typename Parameters, typename IndexableGetter, typename EqualTo, typename Allocator>
+inline typename rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator>::size_type
+remove(rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator> & tree,
+       Value const& v)
+{
+    return tree.remove(v);
+}
+
+/*!
+\brief Remove a range of values from the container.
+
+Remove a range of values from the container. In contrast to the \c std::set or <tt>std::map erase()</tt> method
+it doesn't take iterators pointing to values stored in this container. It removes values equal
+to these passed as a range. Furthermore this function removes only one value for each one passed
+in the range, not all equal values.
+
+It calls <tt>rtree::remove(Iterator, Iterator)</tt>.
+
+\ingroup rtree_functions
+
+\param tree     The spatial index.
+\param first    The beginning of the range of values.
+\param last     The end of the range of values.
+
+\return         The number of removed values.
+*/
+template<typename Value, typename Parameters, typename IndexableGetter, typename EqualTo, typename Allocator,
+         typename Iterator>
+inline typename rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator>::size_type
+remove(rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator> & tree,
+       Iterator first, Iterator last)
+{
+    return tree.remove(first, last);
+}
+
+/*!
+\brief Remove a value corresponding to an object convertible to it or a range of values from the container.
+
+Remove a value corresponding to an object convertible to it or a range of values from the container.
+In contrast to the \c std::set or <tt>std::map erase()</tt> method
+it removes values equal to these passed as a range. Furthermore this method removes only
+one value for each one passed in the range, not all equal values.
+
+It calls <tt>rtree::remove(ConvertibleOrRange const&)</tt>.
+
+\ingroup rtree_functions
+
+\param tree                 The spatial index.
+\param conv_or_rng      The object of type convertible to value_type or the range of values.
+
+\return         The number of removed values.
+*/
+template<typename Value, typename Parameters, typename IndexableGetter, typename EqualTo, typename Allocator,
+         typename ConvertibleOrRange>
+inline typename rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator>::size_type
+remove(rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator> & tree,
+       ConvertibleOrRange const& conv_or_rng)
+{
+    return tree.remove(conv_or_rng);
+}
+
+/*!
+\brief Finds values meeting passed predicates e.g. nearest to some Point and/or intersecting some Box.
+
+This query function performs spatial and k-nearest neighbor searches. It allows to pass a set of predicates.
+Values will be returned only if all predicates are met.
+
+<b>Spatial predicates</b>
+    
+Spatial predicates may be generated by one of the functions listed below:
+\li \c boost::geometry::index::contains(),
+\li \c boost::geometry::index::covered_by(),
+\li \c boost::geometry::index::covers(),
+\li \c boost::geometry::index::disjoint(),
+\li \c boost::geometry::index::intersects(),
+\li \c boost::geometry::index::overlaps(),
+\li \c boost::geometry::index::within(),
+
+It is possible to negate spatial predicates:
+\li <tt>! boost::geometry::index::contains()</tt>,
+\li <tt>! boost::geometry::index::covered_by()</tt>,
+\li <tt>! boost::geometry::index::covers()</tt>,
+\li <tt>! boost::geometry::index::disjoint()</tt>,
+\li <tt>! boost::geometry::index::intersects()</tt>,
+\li <tt>! boost::geometry::index::overlaps()</tt>,
+\li <tt>! boost::geometry::index::within()</tt>
+
+<b>Satisfies predicate</b>
+
+This is a special kind of predicate which allows to pass a user-defined function or function object which checks
+if Value should be returned by the query. It's generated by:
+\li \c boost::geometry::index::satisfies().
+
+<b>Nearest predicate</b>
+
+If the nearest predicate is passed a k-nearest neighbor search will be performed. This query will result
+in returning k values to the output iterator. Only one nearest predicate may be passed to the query.
+It may be generated by:
+\li \c boost::geometry::index::nearest().
+        
+<b>Connecting predicates</b>
+
+Predicates may be passed together connected with \c operator&&().
+
+\par Example
+\verbatim
+// return elements intersecting box
+bgi::query(tree, bgi::intersects(box), std::back_inserter(result));
+// return elements intersecting poly but not within box
+bgi::query(tree, bgi::intersects(poly) && !bgi::within(box), std::back_inserter(result));
+// return elements overlapping box and meeting my_fun value predicate
+bgi::query(tree, bgi::overlaps(box) && bgi::satisfies(my_fun), std::back_inserter(result));
+// return 5 elements nearest to pt and elements are intersecting box
+bgi::query(tree, bgi::nearest(pt, 5) && bgi::intersects(box), std::back_inserter(result));
+
+// For each found value do_something (it is a type of function object)
+tree.query(bgi::intersects(box),
+           boost::make_function_output_iterator(do_something()));
+\endverbatim
+
+\par Throws
+If Value copy constructor or copy assignment throws.
+
+\warning
+Only one \c nearest() perdicate may be passed to the query. Passing more of them results in compile-time error.
+
+\ingroup rtree_functions
+
+\param tree         The rtree.
+\param predicates   Predicates.
+\param out_it       The output iterator, e.g. generated by std::back_inserter().
+
+\return             The number of values found.
+*/
+template <typename Value, typename Parameters, typename IndexableGetter, typename EqualTo, typename Allocator,
+          typename Predicates, typename OutIter> inline
+typename rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator>::size_type
+query(rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator> const& tree,
+      Predicates const& predicates,
+      OutIter out_it)
+{
+    return tree.query(predicates, out_it);
+}
+
+/*!
+\brief Returns the query iterator pointing at the begin of the query range.
+
+This method returns the iterator which may be used to perform iterative queries. For the information
+about the predicates which may be passed to this method see query().
+    
+\par Example
+\verbatim
+std::for_each(bgi::qbegin(tree, bgi::nearest(pt, 3)), bgi::qend(tree), do_something());
+\endverbatim
+
+\par Iterator category
+ForwardIterator
+
+\par Throws
+If predicates copy throws.
+If allocation throws.
+
+\warning
+The modification of the rtree may invalidate the iterators.
+
+\ingroup rtree_functions
+
+\param tree         The rtree.
+\param predicates   Predicates.
+    
+\return             The iterator pointing at the begin of the query range.
+*/
+template <typename Value, typename Parameters, typename IndexableGetter, typename EqualTo, typename Allocator,
+          typename Predicates> inline
+typename rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator>::const_query_iterator
+qbegin(rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator> const& tree,
+       Predicates const& predicates)
+{
+    return tree.qbegin(predicates);
+}
+
+/*!
+\brief Returns the query iterator pointing at the end of the query range.
+
+This method returns the iterator which may be used to check if the query has ended.
+    
+\par Example
+\verbatim
+std::for_each(bgi::qbegin(tree, bgi::nearest(pt, 3)), bgi::qend(tree), do_something());
+\endverbatim
+
+\par Iterator category
+ForwardIterator
+
+\par Throws
+Nothing
+
+\warning
+The modification of the rtree may invalidate the iterators.
+
+\ingroup rtree_functions
+    
+\return             The iterator pointing at the end of the query range.
+*/
+template <typename Value, typename Parameters, typename IndexableGetter, typename EqualTo, typename Allocator> inline
+typename rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator>::const_query_iterator
+qend(rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator> const& tree)
+{
+    return tree.qend();
+}
+
+/*!
+\brief Returns the iterator pointing at the begin of the rtree values range.
+
+This method returns the iterator which may be used to iterate over all values
+stored in the rtree.
+
+\par Example
+\verbatim
+std::for_each(bgi::begin(tree), bgi::end(tree), do_something());
+// the same as
+std::for_each(boost::begin(tree), boost::end(tree), do_something());
+\endverbatim
+
+\par Iterator category
+ForwardIterator
+
+\par Throws
+If allocation throws.
+
+\warning
+The modification of the rtree may invalidate the iterators.
+
+\ingroup rtree_functions
+
+\return             The iterator pointing at the begin of the range.
+*/
+template <typename Value, typename Parameters, typename IndexableGetter, typename EqualTo, typename Allocator> inline
+typename rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator>::const_iterator
+begin(rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator> const& tree)
+{
+    return tree.begin();
+}
+
+/*!
+\brief Returns the iterator pointing at the end of the rtree values range.
+
+This method returns the iterator which may be compared with the iterator returned by begin()
+in order to check if the iteration has ended.
+
+\par Example
+\verbatim
+std::for_each(bgi::begin(tree), bgi::end(tree), do_something());
+// the same as
+std::for_each(boost::begin(tree), boost::end(tree), do_something());
+\endverbatim
+
+\par Iterator category
+ForwardIterator
+
+\par Throws
+Nothing.
+
+\warning
+The modification of the rtree may invalidate the iterators.
+
+\ingroup rtree_functions
+
+\return             The iterator pointing at the end of the range.
+*/
+template <typename Value, typename Parameters, typename IndexableGetter, typename EqualTo, typename Allocator> inline
+typename rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator>::const_iterator
+end(rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator> const& tree)
+{
+    return tree.end();
+}
+
+/*!
+\brief Remove all values from the index.
+
+It calls \c rtree::clear().
+
+\ingroup rtree_functions
+
+\param tree     The spatial index.
+*/
+template <typename Value, typename Parameters, typename IndexableGetter, typename EqualTo, typename Allocator>
+inline void clear(rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator> & tree)
+{
+    return tree.clear();
+}
+
+/*!
+\brief Get the number of values stored in the index.
+
+It calls \c rtree::size().
+
+\ingroup rtree_functions
+
+\param tree     The spatial index.
+
+\return         The number of values stored in the index.
+*/
+template <typename Value, typename Parameters, typename IndexableGetter, typename EqualTo, typename Allocator>
+inline size_t size(rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator> const& tree)
+{
+    return tree.size();
+}
+
+/*!
+\brief Query if there are no values stored in the index.
+
+It calls \c rtree::empty().
+
+\ingroup rtree_functions
+
+\param tree     The spatial index.
+
+\return         true if there are no values in the index.
+*/
+template <typename Value, typename Parameters, typename IndexableGetter, typename EqualTo, typename Allocator>
+inline bool empty(rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator> const& tree)
+{
+    return tree.bounds();
+}
+
+/*!
+\brief Get the box containing all stored values or an invalid box if the index has no values.
+
+It calls \c rtree::envelope().
+
+\ingroup rtree_functions
+
+\param tree     The spatial index.
+
+\return         The box containing all stored values or an invalid box.
+*/
+template <typename Value, typename Parameters, typename IndexableGetter, typename EqualTo, typename Allocator>
+inline typename rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator>::bounds_type
+bounds(rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator> const& tree)
+{
+    return tree.bounds();
+}
+
+/*!
+\brief Exchanges the contents of the container with those of other.
+
+It calls \c rtree::swap().
+
+\ingroup rtree_functions
+
+\param l     The first rtree.
+\param r     The second rtree.
+*/
+template <typename Value, typename Parameters, typename IndexableGetter, typename EqualTo, typename Allocator>
+inline void swap(rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator> & l,
+                 rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator> & r)
+{
+    return l.swap(r);
+}
+
+}}} // namespace boost::geometry::index
+
+// Boost.Range adaptation
+namespace boost {
+
+template <typename Value, typename Parameters, typename IndexableGetter, typename EqualTo, typename Allocator>
+struct range_mutable_iterator
+    <
+        boost::geometry::index::rtree<Value, Parameters, IndexableGetter, EqualTo, Allocator>
+    >
+{
+    typedef typename boost::geometry::index::rtree
+        <
+            Value, Parameters, IndexableGetter, EqualTo, Allocator
+        >::const_iterator type;
+};
+
+} // namespace boost
+
+#include <boost/geometry/index/detail/config_end.hpp>
+
+#endif // BOOST_GEOMETRY_INDEX_RTREE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/io/dsv/write.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/io/dsv/write.hpp
new file mode 100644
index 00000000000..f74ae7f95d1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/io/dsv/write.hpp
@@ -0,0 +1,431 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_IO_DSV_WRITE_HPP
+#define BOOST_GEOMETRY_IO_DSV_WRITE_HPP
+
+#include <cstddef>
+#include <ostream>
+#include <string>
+
+#include <boost/concept_check.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/detail/interior_iterator.hpp>
+
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace dsv
+{
+
+struct dsv_settings
+{
+    std::string coordinate_separator;
+    std::string point_open;
+    std::string point_close;
+    std::string point_separator;
+    std::string list_open;
+    std::string list_close;
+    std::string list_separator;
+
+    dsv_settings(std::string const& sep
+            , std::string const& open
+            , std::string const& close
+            , std::string const& psep
+            , std::string const& lopen
+            , std::string const& lclose
+            , std::string const& lsep
+            )
+        : coordinate_separator(sep)
+        , point_open(open)
+        , point_close(close)
+        , point_separator(psep)
+        , list_open(lopen)
+        , list_close(lclose)
+        , list_separator(lsep)
+    {}
+};
+
+/*!
+\brief Stream coordinate of a point as \ref DSV
+*/
+template <typename Point, std::size_t Dimension, std::size_t Count>
+struct stream_coordinate
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+            Point const& point,
+            dsv_settings const& settings)
+    {
+        os << (Dimension > 0 ? settings.coordinate_separator : "")
+            << get<Dimension>(point);
+
+        stream_coordinate
+            <
+                Point, Dimension + 1, Count
+            >::apply(os, point, settings);
+    }
+};
+
+template <typename Point, std::size_t Count>
+struct stream_coordinate<Point, Count, Count>
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>&,
+            Point const&,
+            dsv_settings const& )
+    {
+    }
+};
+
+/*!
+\brief Stream indexed coordinate of a box/segment as \ref DSV
+*/
+template
+<
+    typename Geometry,
+    std::size_t Index,
+    std::size_t Dimension,
+    std::size_t Count
+>
+struct stream_indexed
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+            Geometry const& geometry,
+            dsv_settings const& settings)
+    {
+        os << (Dimension > 0 ? settings.coordinate_separator : "")
+            << get<Index, Dimension>(geometry);
+        stream_indexed
+            <
+                Geometry, Index, Dimension + 1, Count
+            >::apply(os, geometry, settings);
+    }
+};
+
+template <typename Geometry, std::size_t Index, std::size_t Count>
+struct stream_indexed<Geometry, Index, Count, Count>
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>&, Geometry const&,
+            dsv_settings const& )
+    {
+    }
+};
+
+/*!
+\brief Stream points as \ref DSV
+*/
+template <typename Point>
+struct dsv_point
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+            Point const& p,
+            dsv_settings const& settings)
+    {
+        os << settings.point_open;
+        stream_coordinate<Point, 0, dimension<Point>::type::value>::apply(os, p, settings);
+        os << settings.point_close;
+    }
+};
+
+/*!
+\brief Stream ranges as DSV
+\note policy is used to stream prefix/postfix, enabling derived classes to override this
+*/
+template <typename Range>
+struct dsv_range
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+            Range const& range,
+            dsv_settings const& settings)
+    {
+        typedef typename boost::range_iterator<Range const>::type iterator_type;
+
+        bool first = true;
+
+        os << settings.list_open;
+
+        for (iterator_type it = boost::begin(range);
+            it != boost::end(range);
+            ++it)
+        {
+            os << (first ? "" : settings.point_separator)
+                << settings.point_open;
+
+            stream_coordinate
+                <
+                    point_type, 0, dimension<point_type>::type::value
+                >::apply(os, *it, settings);
+            os << settings.point_close;
+
+            first = false;
+        }
+
+        os << settings.list_close;
+    }
+
+private:
+    typedef typename boost::range_value<Range>::type point_type;
+};
+
+/*!
+\brief Stream sequence of points as DSV-part, e.g. (1 2),(3 4)
+\note Used in polygon, all multi-geometries
+*/
+
+template <typename Polygon>
+struct dsv_poly
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+                Polygon const& poly,
+                dsv_settings const& settings)
+    {
+        typedef typename ring_type<Polygon>::type ring;
+
+        os << settings.list_open;
+
+        dsv_range<ring>::apply(os, exterior_ring(poly), settings);
+
+        typename interior_return_type<Polygon const>::type
+            rings = interior_rings(poly);
+        for (typename detail::interior_iterator<Polygon const>::type
+                it = boost::begin(rings); it != boost::end(rings); ++it)
+        {
+            os << settings.list_separator;
+            dsv_range<ring>::apply(os, *it, settings);
+        }
+        os << settings.list_close;
+    }
+};
+
+template <typename Geometry, std::size_t Index>
+struct dsv_per_index
+{
+    typedef typename point_type<Geometry>::type point_type;
+
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+            Geometry const& geometry,
+            dsv_settings const& settings)
+    {
+        os << settings.point_open;
+        stream_indexed
+            <
+                Geometry, Index, 0, dimension<Geometry>::type::value
+            >::apply(os, geometry, settings);
+        os << settings.point_close;
+    }
+};
+
+template <typename Geometry>
+struct dsv_indexed
+{
+    typedef typename point_type<Geometry>::type point_type;
+
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+            Geometry const& geometry,
+            dsv_settings const& settings)
+    {
+        os << settings.list_open;
+        dsv_per_index<Geometry, 0>::apply(os, geometry, settings);
+        os << settings.point_separator;
+        dsv_per_index<Geometry, 1>::apply(os, geometry, settings);
+        os << settings.list_close;
+    }
+};
+
+}} // namespace detail::dsv
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Tag, typename Geometry>
+struct dsv {};
+
+template <typename Point>
+struct dsv<point_tag, Point>
+    : detail::dsv::dsv_point<Point>
+{};
+
+template <typename Linestring>
+struct dsv<linestring_tag, Linestring>
+    : detail::dsv::dsv_range<Linestring>
+{};
+
+template <typename Box>
+struct dsv<box_tag, Box>
+    : detail::dsv::dsv_indexed<Box>
+{};
+
+template <typename Segment>
+struct dsv<segment_tag, Segment>
+    : detail::dsv::dsv_indexed<Segment>
+{};
+
+template <typename Ring>
+struct dsv<ring_tag, Ring>
+    : detail::dsv::dsv_range<Ring>
+{};
+
+template <typename Polygon>
+struct dsv<polygon_tag, Polygon>
+    : detail::dsv::dsv_poly<Polygon>
+{};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace dsv
+{
+
+// FIXME: This class is not copyable/assignable but it is used as such --mloskot
+template <typename Geometry>
+class dsv_manipulator
+{
+public:
+
+    inline dsv_manipulator(Geometry const& g,
+            dsv_settings const& settings)
+        : m_geometry(g)
+        , m_settings(settings)
+    {}
+
+    template <typename Char, typename Traits>
+    inline friend std::basic_ostream<Char, Traits>& operator<<(
+            std::basic_ostream<Char, Traits>& os,
+            dsv_manipulator const& m)
+    {
+        dispatch::dsv
+            <
+                typename tag_cast
+                    <
+                        typename tag<Geometry>::type,
+                        multi_tag
+                    >::type,
+                Geometry
+            >::apply(os, m.m_geometry, m.m_settings);
+        os.flush();
+        return os;
+    }
+
+private:
+    Geometry const& m_geometry;
+    dsv_settings m_settings;
+};
+
+
+template <typename MultiGeometry>
+struct dsv_multi
+{
+    typedef dispatch::dsv
+                <
+                    typename single_tag_of
+                        <
+                            typename tag<MultiGeometry>::type
+                        >::type,
+                    typename boost::range_value<MultiGeometry>::type
+                > dispatch_one;
+
+    typedef typename boost::range_iterator
+        <
+            MultiGeometry const
+        >::type iterator;
+
+
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+                MultiGeometry const& multi,
+                dsv_settings const& settings)
+    {
+        os << settings.list_open;
+
+        bool first = true;
+        for(iterator it = boost::begin(multi);
+            it != boost::end(multi);
+            ++it, first = false)
+        {
+            os << (first ? "" : settings.list_separator);
+            dispatch_one::apply(os, *it, settings);
+        }
+        os << settings.list_close;
+    }
+};
+
+}} // namespace detail::dsv
+#endif // DOXYGEN_NO_DETAIL
+
+// TODO: The alternative to this could be a forward declaration of dispatch::dsv<>
+//       or braking the code into the interface and implementation part
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Geometry>
+struct dsv<multi_tag, Geometry>
+    : detail::dsv::dsv_multi<Geometry>
+{};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+/*!
+\brief Main DSV-streaming function
+\details DSV stands for Delimiter Separated Values. Geometries can be streamed
+    as DSV. There are defaults for all separators.
+\note Useful for examples and testing purposes
+\note With this function GeoJSON objects can be created, using the right
+    delimiters
+\ingroup utility
+*/
+template <typename Geometry>
+inline detail::dsv::dsv_manipulator<Geometry> dsv(Geometry const& geometry
+    , std::string const& coordinate_separator = ", "
+    , std::string const& point_open = "("
+    , std::string const& point_close = ")"
+    , std::string const& point_separator = ", "
+    , std::string const& list_open = "("
+    , std::string const& list_close = ")"
+    , std::string const& list_separator = ", "
+    )
+{
+    concepts::check<Geometry const>();
+
+    return detail::dsv::dsv_manipulator<Geometry>(geometry,
+        detail::dsv::dsv_settings(coordinate_separator,
+            point_open, point_close, point_separator,
+            list_open, list_close, list_separator));
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_IO_DSV_WRITE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/io/io.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/io/io.hpp
new file mode 100644
index 00000000000..caafccf2bfc
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/io/io.hpp
@@ -0,0 +1,58 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_IO_HPP
+#define BOOST_GEOMETRY_IO_HPP
+
+#include <boost/geometry/io/wkt/read.hpp>
+#include <boost/geometry/io/wkt/write.hpp>
+
+namespace boost { namespace geometry
+{
+
+struct format_wkt {};
+struct format_wkb {}; // TODO
+struct format_dsv {}; // TODO
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+template <typename Tag, typename Geometry>
+struct read
+{
+};
+
+template <typename Geometry>
+struct read<format_wkt, Geometry>
+{
+    static inline void apply(Geometry& geometry, std::string const& wkt)
+    {
+        read_wkt<typename tag<Geometry>::type, Geometry>::apply(wkt, geometry);
+    }
+};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+template <typename Format, typename Geometry>
+inline void read(Geometry& geometry, std::string const& wkt)
+{
+    geometry::concepts::check<Geometry>();
+    dispatch::read<Format, Geometry>::apply(geometry, wkt);
+}
+
+// TODO: wriite
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_IO_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/io/svg/svg_mapper.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/io/svg/svg_mapper.hpp
new file mode 100644
index 00000000000..6302fd43ba8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/io/svg/svg_mapper.hpp
@@ -0,0 +1,450 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2009-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2015, 2016.
+// Modifications copyright (c) 2015-2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_IO_SVG_MAPPER_HPP
+#define BOOST_GEOMETRY_IO_SVG_MAPPER_HPP
+
+#include <cstdio>
+
+#include <vector>
+
+#include <boost/config.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/noncopyable.hpp>
+#include <boost/scoped_ptr.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+#include <boost/algorithm/string/split.hpp>
+#include <boost/algorithm/string/classification.hpp>
+
+
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+
+#include <boost/geometry/algorithms/envelope.hpp>
+#include <boost/geometry/algorithms/expand.hpp>
+#include <boost/geometry/algorithms/is_empty.hpp>
+#include <boost/geometry/algorithms/transform.hpp>
+#include <boost/geometry/strategies/transform/map_transformer.hpp>
+#include <boost/geometry/views/segment_view.hpp>
+
+#include <boost/geometry/io/svg/write.hpp>
+
+// Helper geometries (all points are transformed to svg-points)
+#include <boost/geometry/geometries/geometries.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename GeometryTag, typename Geometry, typename SvgPoint>
+struct svg_map
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_OR_NOT_YET_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
+            , (Geometry)
+        );
+};
+
+
+template <typename Point, typename SvgPoint>
+struct svg_map<point_tag, Point, SvgPoint>
+{
+    template <typename TransformStrategy>
+    static inline void apply(std::ostream& stream,
+                    std::string const& style, double size,
+                    Point const& point, TransformStrategy const& strategy)
+    {
+        SvgPoint ipoint;
+        geometry::transform(point, ipoint, strategy);
+        stream << geometry::svg(ipoint, style, size) << std::endl;
+    }
+};
+
+template <typename BoxSeg1, typename BoxSeg2, typename SvgPoint>
+struct svg_map_box_seg
+{
+    template <typename TransformStrategy>
+    static inline void apply(std::ostream& stream,
+                    std::string const& style, double size,
+                    BoxSeg1 const& box_seg, TransformStrategy const& strategy)
+    {
+        BoxSeg2 ibox_seg;
+
+        // Fix bug in gcc compiler warning for possible uninitialization
+#if defined(BOOST_GCC)
+        geometry::assign_zero(ibox_seg);
+#endif
+        geometry::transform(box_seg, ibox_seg, strategy);
+
+        stream << geometry::svg(ibox_seg, style, size) << std::endl;
+    }
+};
+
+template <typename Box, typename SvgPoint>
+struct svg_map<box_tag, Box, SvgPoint>
+    : svg_map_box_seg<Box, model::box<SvgPoint>, SvgPoint>
+{};
+
+template <typename Segment, typename SvgPoint>
+struct svg_map<segment_tag, Segment, SvgPoint>
+    : svg_map_box_seg<Segment, model::segment<SvgPoint>, SvgPoint>
+{};
+
+
+template <typename Range1, typename Range2, typename SvgPoint>
+struct svg_map_range
+{
+    template <typename TransformStrategy>
+    static inline void apply(std::ostream& stream,
+                std::string const& style, double size,
+                Range1 const& range, TransformStrategy const& strategy)
+    {
+        Range2 irange;
+        geometry::transform(range, irange, strategy);
+        stream << geometry::svg(irange, style, size) << std::endl;
+    }
+};
+
+template <typename Ring, typename SvgPoint>
+struct svg_map<ring_tag, Ring, SvgPoint>
+    : svg_map_range<Ring, model::ring<SvgPoint>, SvgPoint>
+{};
+
+
+template <typename Linestring, typename SvgPoint>
+struct svg_map<linestring_tag, Linestring, SvgPoint>
+    : svg_map_range<Linestring, model::linestring<SvgPoint>, SvgPoint>
+{};
+
+
+template <typename Polygon, typename SvgPoint>
+struct svg_map<polygon_tag, Polygon, SvgPoint>
+{
+    template <typename TransformStrategy>
+    static inline void apply(std::ostream& stream,
+                    std::string const& style, double size,
+                    Polygon const& polygon, TransformStrategy const& strategy)
+    {
+        model::polygon<SvgPoint> ipoly;
+        geometry::transform(polygon, ipoly, strategy);
+        stream << geometry::svg(ipoly, style, size) << std::endl;
+    }
+};
+
+
+template <typename Multi, typename SvgPoint>
+struct svg_map<multi_tag, Multi, SvgPoint>
+{
+    typedef typename single_tag_of
+      <
+          typename geometry::tag<Multi>::type
+      >::type stag;
+
+    template <typename TransformStrategy>
+    static inline void apply(std::ostream& stream,
+                    std::string const& style, double size,
+                    Multi const& multi, TransformStrategy const& strategy)
+    {
+        for (typename boost::range_iterator<Multi const>::type it
+            = boost::begin(multi);
+            it != boost::end(multi);
+            ++it)
+        {
+            svg_map
+                <
+                    stag,
+                    typename boost::range_value<Multi>::type,
+                    SvgPoint
+                >::apply(stream, style, size, *it, strategy);
+        }
+    }
+};
+
+
+template <typename SvgPoint, typename Geometry>
+struct devarianted_svg_map
+{
+    template <typename TransformStrategy>
+    static inline void apply(std::ostream& stream,
+                             std::string const& style,
+                             double size,
+                             Geometry const& geometry,
+                             TransformStrategy const& strategy)
+    {
+        svg_map
+            <
+                typename tag_cast
+                    <
+                        typename tag<Geometry>::type,
+                        multi_tag
+                    >::type,
+                typename boost::remove_const<Geometry>::type,
+                SvgPoint
+            >::apply(stream, style, size, geometry, strategy);
+    }
+};
+
+template <typename SvgPoint, BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct devarianted_svg_map<SvgPoint, variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename TransformStrategy>
+    struct visitor: static_visitor<void>
+    {
+        std::ostream& m_os;
+        std::string const& m_style;
+        double m_size;
+        TransformStrategy const& m_strategy;
+
+        visitor(std::ostream& os,
+                std::string const& style,
+                double size,
+                TransformStrategy const& strategy)
+            : m_os(os)
+            , m_style(style)
+            , m_size(size)
+            , m_strategy(strategy)
+        {}
+
+        template <typename Geometry>
+        inline void operator()(Geometry const& geometry) const
+        {
+            devarianted_svg_map<SvgPoint, Geometry>::apply(m_os, m_style, m_size, geometry, m_strategy);
+        }
+    };
+
+    template <typename TransformStrategy>
+    static inline void apply(std::ostream& stream,
+                             std::string const& style,
+                             double size,
+                             variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry,
+                             TransformStrategy const& strategy)
+    {
+        boost::apply_visitor(visitor<TransformStrategy>(stream, style, size, strategy), geometry);
+    }
+};
+
+
+} // namespace dispatch
+#endif
+
+
+template <typename SvgPoint, typename Geometry, typename TransformStrategy>
+inline void svg_map(std::ostream& stream,
+            std::string const& style, double size,
+            Geometry const& geometry, TransformStrategy const& strategy)
+{
+    dispatch::devarianted_svg_map<SvgPoint, Geometry>::apply(stream,
+            style, size, geometry, strategy);
+}
+
+
+/*!
+\brief Helper class to create SVG maps
+\tparam Point Point type, for input geometries.
+\tparam SameScale Boolean flag indicating if horizontal and vertical scale should
+    be the same. The default value is true
+\tparam SvgCoordinateType Coordinate type of SVG points. SVG is capable to
+    use floating point coordinates. Therefore the default value is double
+\ingroup svg
+
+\qbk{[include reference/io/svg.qbk]}
+*/
+template
+<
+    typename Point,
+    bool SameScale = true,
+    typename SvgCoordinateType = double
+>
+class svg_mapper : boost::noncopyable
+{
+    typedef model::point<SvgCoordinateType, 2, cs::cartesian> svg_point_type;
+
+    typedef typename geometry::select_most_precise
+        <
+            typename coordinate_type<Point>::type,
+            double
+        >::type calculation_type;
+
+    typedef strategy::transform::map_transformer
+        <
+            calculation_type,
+            geometry::dimension<Point>::type::value,
+            geometry::dimension<Point>::type::value,
+            true,
+            SameScale
+        > transformer_type;
+
+    model::box<Point> m_bounding_box;
+    boost::scoped_ptr<transformer_type> m_matrix;
+    std::ostream& m_stream;
+    SvgCoordinateType m_width, m_height;
+    std::string m_width_height; // for <svg> tag only, defaults to 2x 100%
+
+    void init_matrix()
+    {
+        if (! m_matrix)
+        {
+            m_matrix.reset(new transformer_type(m_bounding_box,
+                            m_width, m_height));
+
+
+            m_stream << "<?xml version=\"1.0\" standalone=\"no\"?>"
+                << std::endl
+                << "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\""
+                << std::endl
+                << "\"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">"
+                << std::endl
+                << "<svg " << m_width_height << " version=\"1.1\""
+                << std::endl
+                << "xmlns=\"http://www.w3.org/2000/svg\""
+                << std::endl
+                << "xmlns:xlink=\"http://www.w3.org/1999/xlink\""
+                << ">"
+                << std::endl;
+        }
+    }
+
+public :
+    
+    /*!
+    \brief Constructor, initializing the SVG map. Opens and initializes the SVG. 
+         Should be called explicitly.
+    \param stream Output stream, should be a stream already open
+    \param width Width of the SVG map (in SVG pixels)
+    \param height Height of the SVG map (in SVG pixels)
+    \param width_height Optional information to increase width and/or height
+    */
+    svg_mapper(std::ostream& stream
+        , SvgCoordinateType width
+        , SvgCoordinateType height
+        , std::string const& width_height = "width=\"100%\" height=\"100%\"")
+        : m_stream(stream)
+        , m_width(width)
+        , m_height(height)
+        , m_width_height(width_height)
+    {
+        assign_inverse(m_bounding_box);
+    }
+
+    /*!
+    \brief Destructor, called automatically. Closes the SVG by streaming <\/svg>
+    */
+    virtual ~svg_mapper()
+    {
+        m_stream << "</svg>" << std::endl;
+    }
+
+    /*!
+    \brief Adds a geometry to the transformation matrix. After doing this,
+        the specified geometry can be mapped fully into the SVG map
+    \tparam Geometry \tparam_geometry
+    \param geometry \param_geometry
+    */
+    template <typename Geometry>
+    void add(Geometry const& geometry)
+    {
+        if (! geometry::is_empty(geometry))
+        {
+            expand(m_bounding_box,
+                return_envelope
+                    <
+                        model::box<Point>
+                    >(geometry));
+        }
+    }
+
+    /*!
+    \brief Maps a geometry into the SVG map using the specified style
+    \tparam Geometry \tparam_geometry
+    \param geometry \param_geometry
+    \param style String containing verbatim SVG style information
+    \param size Optional size (used for SVG points) in SVG pixels. For linestrings,
+        specify linewidth in the SVG style information
+    */
+    template <typename Geometry>
+    void map(Geometry const& geometry, std::string const& style,
+                double size = -1.0)
+    {
+        init_matrix();
+        svg_map<svg_point_type>(m_stream, style, size, geometry, *m_matrix);
+    }
+
+    /*!
+    \brief Adds a text to the SVG map
+    \tparam TextPoint \tparam_point
+    \param point Location of the text (in map units)
+    \param s The text itself
+    \param style String containing verbatim SVG style information, of the text
+    \param offset_x Offset in SVG pixels, defaults to 0
+    \param offset_y Offset in SVG pixels, defaults to 0
+    \param lineheight Line height in SVG pixels, in case the text contains \n
+    */
+    template <typename TextPoint>
+    void text(TextPoint const& point, std::string const& s,
+                std::string const& style,
+                double offset_x = 0.0, double offset_y = 0.0,
+                double lineheight = 10.0)
+    {
+        init_matrix();
+        svg_point_type map_point;
+        transform(point, map_point, *m_matrix);
+        m_stream
+            << "<text style=\"" << style << "\""
+            << " x=\"" << get<0>(map_point) + offset_x << "\""
+            << " y=\"" << get<1>(map_point) + offset_y << "\""
+            << ">";
+        if (s.find("\n") == std::string::npos)
+        {
+             m_stream  << s;
+        }
+        else
+        {
+            // Multi-line modus
+
+            std::vector<std::string> splitted;
+            boost::split(splitted, s, boost::is_any_of("\n"));
+            for (std::vector<std::string>::const_iterator it
+                = splitted.begin();
+                it != splitted.end();
+                ++it, offset_y += lineheight)
+            {
+                 m_stream
+                    << "<tspan x=\"" << get<0>(map_point) + offset_x
+                    << "\""
+                    << " y=\"" << get<1>(map_point) + offset_y
+                    << "\""
+                    << ">" << *it << "</tspan>";
+            }
+        }
+        m_stream << "</text>" << std::endl;
+    }
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_IO_SVG_MAPPER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/io/svg/write.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/io/svg/write.hpp
new file mode 100644
index 00000000000..70858021fc0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/io/svg/write.hpp
@@ -0,0 +1,418 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2009-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2016.
+// Modifications copyright (c) 2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_IO_SVG_WRITE_HPP
+#define BOOST_GEOMETRY_IO_SVG_WRITE_HPP
+
+#include <ostream>
+#include <string>
+
+#include <boost/config.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/range.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/detail/interior_iterator.hpp>
+
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace svg
+{
+
+
+template <typename Point>
+struct svg_point
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+                Point const& p, std::string const& style, double size)
+    {
+        os << "<circle cx=\"" << geometry::get<0>(p)
+            << "\" cy=\"" << geometry::get<1>(p)
+            << "\" r=\"" << (size < 0 ? 5 : size)
+            << "\" style=\"" << style << "\"/>";
+    }
+};
+
+
+template <typename Box>
+struct svg_box
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+                Box const& box, std::string const& style, double)
+    {
+        // Prevent invisible boxes, making them >=1, using "max"
+        BOOST_USING_STD_MAX();
+
+        typedef typename coordinate_type<Box>::type ct;
+        ct x = geometry::get<geometry::min_corner, 0>(box);
+        ct y = geometry::get<geometry::min_corner, 1>(box);
+        ct width = max BOOST_PREVENT_MACRO_SUBSTITUTION (ct(1),
+                    geometry::get<geometry::max_corner, 0>(box) - x);
+        ct height = max BOOST_PREVENT_MACRO_SUBSTITUTION (ct(1),
+                    geometry::get<geometry::max_corner, 1>(box) - y);
+
+        os << "<rect x=\"" << x << "\" y=\"" << y
+           << "\" width=\"" << width << "\" height=\"" << height
+           << "\" style=\"" << style << "\"/>";
+    }
+};
+
+template <typename Segment>
+struct svg_segment
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+        Segment const& segment, std::string const& style, double)
+    {
+        typedef typename coordinate_type<Segment>::type ct;
+        ct x1 = geometry::get<0, 0>(segment);
+        ct y1 = geometry::get<0, 1>(segment);
+        ct x2 = geometry::get<1, 0>(segment);
+        ct y2 = geometry::get<1, 1>(segment);
+        
+        os << "<line x1=\"" << x1 << "\" y1=\"" << y1
+            << "\" x2=\"" << x2 << "\" y2=\"" << y2
+            << "\" style=\"" << style << "\"/>";
+    }
+};
+
+/*!
+\brief Stream ranges as SVG
+\note policy is used to select type (polyline/polygon)
+*/
+template <typename Range, typename Policy>
+struct svg_range
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+        Range const& range, std::string const& style, double)
+    {
+        typedef typename boost::range_iterator<Range const>::type iterator;
+
+        bool first = true;
+
+        os << "<" << Policy::prefix() << " points=\"";
+
+        for (iterator it = boost::begin(range);
+            it != boost::end(range);
+            ++it, first = false)
+        {
+            os << (first ? "" : " " )
+                << geometry::get<0>(*it)
+                << ","
+                << geometry::get<1>(*it);
+        }
+        os << "\" style=\"" << style << Policy::style() << "\"/>";
+    }
+};
+
+
+
+template <typename Polygon>
+struct svg_poly
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+        Polygon const& polygon, std::string const& style, double)
+    {
+        typedef typename geometry::ring_type<Polygon>::type ring_type;
+        typedef typename boost::range_iterator<ring_type const>::type iterator_type;
+
+        bool first = true;
+        os << "<g fill-rule=\"evenodd\"><path d=\"";
+
+        ring_type const& ring = geometry::exterior_ring(polygon);
+        for (iterator_type it = boost::begin(ring);
+            it != boost::end(ring);
+            ++it, first = false)
+        {
+            os << (first ? "M" : " L") << " "
+                << geometry::get<0>(*it)
+                << ","
+                << geometry::get<1>(*it);
+        }
+
+        // Inner rings:
+        {
+            typename interior_return_type<Polygon const>::type
+                rings = interior_rings(polygon);
+            for (typename detail::interior_iterator<Polygon const>::type
+                    rit = boost::begin(rings); rit != boost::end(rings); ++rit)
+            {
+                first = true;
+                for (typename detail::interior_ring_iterator<Polygon const>::type
+                        it = boost::begin(*rit); it != boost::end(*rit);
+                    ++it, first = false)
+                {
+                    os << (first ? "M" : " L") << " "
+                        << geometry::get<0>(*it)
+                        << ","
+                        << geometry::get<1>(*it);
+                }
+            }
+        }
+        os << " z \" style=\"" << style << "\"/></g>";
+
+    }
+};
+
+
+
+struct prefix_linestring
+{
+    static inline const char* prefix() { return "polyline"; }
+    static inline const char* style() { return ";fill:none"; }
+};
+
+
+struct prefix_ring
+{
+    static inline const char* prefix() { return "polygon"; }
+    static inline const char* style() { return ""; }
+};
+
+
+template <typename MultiGeometry, typename Policy>
+struct svg_multi
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+        MultiGeometry const& multi, std::string const& style, double size)
+    {
+        for (typename boost::range_iterator<MultiGeometry const>::type
+                    it = boost::begin(multi);
+            it != boost::end(multi);
+            ++it)
+        {
+            Policy::apply(os, *it, style, size);
+        }
+
+    }
+
+};
+
+
+}} // namespace detail::svg
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+/*!
+\brief Dispatching base struct for SVG streaming, specialized below per geometry type
+\details Specializations should implement a static method "stream" to stream a geometry
+The static method should have the signature:
+
+template <typename Char, typename Traits>
+static inline void apply(std::basic_ostream<Char, Traits>& os, G const& geometry)
+*/
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct svg
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_OR_NOT_YET_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
+            , (Geometry)
+        );
+};
+
+template <typename Point>
+struct svg<Point, point_tag> : detail::svg::svg_point<Point> {};
+
+template <typename Segment>
+struct svg<Segment, segment_tag> : detail::svg::svg_segment<Segment> {};
+
+template <typename Box>
+struct svg<Box, box_tag> : detail::svg::svg_box<Box> {};
+
+template <typename Linestring>
+struct svg<Linestring, linestring_tag>
+    : detail::svg::svg_range<Linestring, detail::svg::prefix_linestring> {};
+
+template <typename Ring>
+struct svg<Ring, ring_tag>
+    : detail::svg::svg_range<Ring, detail::svg::prefix_ring> {};
+
+template <typename Polygon>
+struct svg<Polygon, polygon_tag>
+    : detail::svg::svg_poly<Polygon> {};
+
+template <typename MultiPoint>
+struct svg<MultiPoint, multi_point_tag>
+    : detail::svg::svg_multi
+        <
+            MultiPoint,
+            detail::svg::svg_point
+                <
+                    typename boost::range_value<MultiPoint>::type
+                >
+
+        >
+{};
+
+template <typename MultiLinestring>
+struct svg<MultiLinestring, multi_linestring_tag>
+    : detail::svg::svg_multi
+        <
+            MultiLinestring,
+            detail::svg::svg_range
+                <
+                    typename boost::range_value<MultiLinestring>::type,
+                    detail::svg::prefix_linestring
+                >
+
+        >
+{};
+
+template <typename MultiPolygon>
+struct svg<MultiPolygon, multi_polygon_tag>
+    : detail::svg::svg_multi
+        <
+            MultiPolygon,
+            detail::svg::svg_poly
+                <
+                    typename boost::range_value<MultiPolygon>::type
+                >
+
+        >
+{};
+
+
+template <typename Geometry>
+struct devarianted_svg
+{
+    template <typename OutputStream>
+    static inline void apply(OutputStream& os,
+                             Geometry const& geometry,
+                             std::string const& style,
+                             double size)
+    {
+        svg<Geometry>::apply(os, geometry, style, size);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct devarianted_svg<variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename OutputStream>
+    struct visitor: static_visitor<void>
+    {
+        OutputStream& m_os;
+        std::string const& m_style;
+        double m_size;
+
+        visitor(OutputStream& os, std::string const& style, double size)
+            : m_os(os)
+            , m_style(style)
+            , m_size(size)
+        {}
+
+        template <typename Geometry>
+        inline void operator()(Geometry const& geometry) const
+        {
+            devarianted_svg<Geometry>::apply(m_os, geometry, m_style, m_size);
+        }
+    };
+
+    template <typename OutputStream>
+    static inline void apply(
+        OutputStream& os,
+        variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry,
+        std::string const& style,
+        double size
+    )
+    {
+        boost::apply_visitor(visitor<OutputStream>(os, style, size), geometry);
+    }
+};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+/*!
+\brief Generic geometry template manipulator class, takes corresponding output class from traits class
+\ingroup svg
+\details Stream manipulator, streams geometry classes as SVG (Scalable Vector Graphics)
+*/
+template <typename Geometry>
+class svg_manipulator
+{
+public:
+
+    inline svg_manipulator(Geometry const& g, std::string const& style, double size)
+        : m_geometry(g)
+        , m_style(style)
+        , m_size(size)
+    {}
+
+    template <typename Char, typename Traits>
+    inline friend std::basic_ostream<Char, Traits>& operator<<(
+                    std::basic_ostream<Char, Traits>& os, svg_manipulator const& m)
+    {
+        dispatch::devarianted_svg<Geometry>::apply(os,
+                                                   m.m_geometry,
+                                                   m.m_style,
+                                                   m.m_size);
+        os.flush();
+        return os;
+    }
+
+private:
+    Geometry const& m_geometry;
+    std::string const& m_style;
+    double m_size;
+};
+
+/*!
+\brief Manipulator to stream geometries as SVG
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\param style String containing verbatim SVG style information
+\param size Optional size (used for SVG points) in SVG pixels. For linestrings,
+    specify linewidth in the SVG style information
+\ingroup svg
+*/
+template <typename Geometry>
+inline svg_manipulator<Geometry> svg(Geometry const& geometry,
+            std::string const& style, double size = -1.0)
+{
+    concepts::check<Geometry const>();
+
+    return svg_manipulator<Geometry>(geometry, style, size);
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_IO_SVG_WRITE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/io/svg/write_svg.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/io/svg/write_svg.hpp
new file mode 100644
index 00000000000..371a80bc692
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/io/svg/write_svg.hpp
@@ -0,0 +1,28 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2009-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2016.
+// Modifications copyright (c) 2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_IO_SVG_WRITE_SVG_HPP
+#define BOOST_GEOMETRY_IO_SVG_WRITE_SVG_HPP
+
+
+// THIS FILE WAS LEFT HERE FOR BACKWARD COMPATIBILITY
+
+
+#include <boost/geometry/io/svg/write.hpp>
+
+
+#endif // BOOST_GEOMETRY_IO_SVG_WRITE_SVG_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/io/svg/write_svg_multi.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/io/svg/write_svg_multi.hpp
new file mode 100644
index 00000000000..d07a2c204e8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/io/svg/write_svg_multi.hpp
@@ -0,0 +1,27 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2009-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2016.
+// Modifications copyright (c) 2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_IO_SVG_WRITE_SVG_MULTI_HPP
+#define BOOST_GEOMETRY_IO_SVG_WRITE_SVG_MULTI_HPP
+
+
+// THIS FILE WAS LEFT HERE FOR BACKWARD COMPATIBILITY
+
+
+#include <boost/geometry/io/svg/write.hpp>
+
+
+#endif // BOOST_GEOMETRY_IO_SVG_WRITE_SVG_MULTI_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/detail/prefix.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/detail/prefix.hpp
new file mode 100644
index 00000000000..b566e02aa6a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/detail/prefix.hpp
@@ -0,0 +1,66 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_IO_WKT_DETAIL_PREFIX_HPP
+#define BOOST_GEOMETRY_IO_WKT_DETAIL_PREFIX_HPP
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace wkt
+{
+
+struct prefix_null
+{
+    static inline const char* apply() { return ""; }
+};
+
+struct prefix_point
+{
+    static inline const char* apply() { return "POINT"; }
+};
+
+struct prefix_polygon
+{
+    static inline const char* apply() { return "POLYGON"; }
+};
+
+struct prefix_linestring
+{
+    static inline const char* apply() { return "LINESTRING"; }
+};
+
+struct prefix_multipoint
+{
+    static inline const char* apply() { return "MULTIPOINT"; }
+};
+
+struct prefix_multilinestring
+{
+    static inline const char* apply() { return "MULTILINESTRING"; }
+};
+
+struct prefix_multipolygon
+{
+    static inline const char* apply() { return "MULTIPOLYGON"; }
+};
+
+}} // namespace wkt::impl
+#endif
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_IO_WKT_DETAIL_PREFIX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/detail/wkt_multi.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/detail/wkt_multi.hpp
new file mode 100644
index 00000000000..2b2d1946ad8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/detail/wkt_multi.hpp
@@ -0,0 +1,56 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_DOMAINS_GIS_IO_WKT_DETAIL_WKT_MULTI_HPP
+#define BOOST_GEOMETRY_DOMAINS_GIS_IO_WKT_DETAIL_WKT_MULTI_HPP
+
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/domains/gis/io/wkt/write.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace wkt
+{
+
+struct prefix_null
+{
+    static inline const char* apply() { return ""; }
+};
+
+struct prefix_multipoint
+{
+    static inline const char* apply() { return "MULTIPOINT"; }
+};
+
+struct prefix_multilinestring
+{
+    static inline const char* apply() { return "MULTILINESTRING"; }
+};
+
+struct prefix_multipolygon
+{
+    static inline const char* apply() { return "MULTIPOLYGON"; }
+};
+
+
+
+}} // namespace wkt::impl
+#endif
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_DOMAINS_GIS_IO_WKT_DETAIL_WKT_MULTI_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/read.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/read.hpp
new file mode 100644
index 00000000000..236690dc2ce
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/read.hpp
@@ -0,0 +1,905 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2017 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014, 2015.
+// Modifications copyright (c) 2014-2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_IO_WKT_READ_HPP
+#define BOOST_GEOMETRY_IO_WKT_READ_HPP
+
+#include <cstddef>
+#include <string>
+
+#include <boost/lexical_cast.hpp>
+#include <boost/tokenizer.hpp>
+
+#include <boost/algorithm/string.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/size.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/algorithms/append.hpp>
+#include <boost/geometry/algorithms/clear.hpp>
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/exception.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/geometry_id.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/mutable_range.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+#include <boost/geometry/util/coordinate_cast.hpp>
+
+#include <boost/geometry/io/wkt/detail/prefix.hpp>
+
+namespace boost { namespace geometry
+{
+
+/*!
+\brief Exception showing things wrong with WKT parsing
+\ingroup wkt
+*/
+struct read_wkt_exception : public geometry::exception
+{
+    template <typename Iterator>
+    read_wkt_exception(std::string const& msg,
+                       Iterator const& it,
+                       Iterator const& end,
+                       std::string const& wkt)
+        : message(msg)
+        , wkt(wkt)
+    {
+        if (it != end)
+        {
+            source = " at '";
+            source += it->c_str();
+            source += "'";
+        }
+        complete = message + source + " in '" + wkt.substr(0, 100) + "'";
+    }
+
+    read_wkt_exception(std::string const& msg, std::string const& wkt)
+        : message(msg)
+        , wkt(wkt)
+    {
+        complete = message + "' in (" + wkt.substr(0, 100) + ")";
+    }
+
+    virtual ~read_wkt_exception() throw() {}
+
+    virtual const char* what() const throw()
+    {
+        return complete.c_str();
+    }
+private :
+    std::string source;
+    std::string message;
+    std::string wkt;
+    std::string complete;
+};
+
+
+#ifndef DOXYGEN_NO_DETAIL
+// (wkt: Well Known Text, defined by OGC for all geometries and implemented by e.g. databases (MySQL, PostGIS))
+namespace detail { namespace wkt
+{
+
+typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
+
+template <typename Point,
+          std::size_t Dimension = 0,
+          std::size_t DimensionCount = geometry::dimension<Point>::value>
+struct parsing_assigner
+{
+    static inline void apply(tokenizer::iterator& it,
+                             tokenizer::iterator const& end,
+                             Point& point,
+                             std::string const& wkt)
+    {
+        typedef typename coordinate_type<Point>::type coordinate_type;
+
+        // Stop at end of tokens, or at "," ot ")"
+        bool finished = (it == end || *it == "," || *it == ")");
+
+        try
+        {
+            // Initialize missing coordinates to default constructor (zero)
+            // OR
+            // Use lexical_cast for conversion to double/int
+            // Note that it is much slower than atof. However, it is more standard
+            // and in parsing the change in performance falls probably away against
+            // the tokenizing
+            set<Dimension>(point, finished
+                    ? coordinate_type()
+                    : coordinate_cast<coordinate_type>::apply(*it));
+        }
+        catch(boost::bad_lexical_cast const& blc)
+        {
+            BOOST_THROW_EXCEPTION(read_wkt_exception(blc.what(), it, end, wkt));
+        }
+        catch(std::exception const& e)
+        {
+            BOOST_THROW_EXCEPTION(read_wkt_exception(e.what(), it, end, wkt));
+        }
+        catch(...)
+        {
+            BOOST_THROW_EXCEPTION(read_wkt_exception("", it, end, wkt));
+        }
+
+        parsing_assigner<Point, Dimension + 1, DimensionCount>::apply(
+                        (finished ? it : ++it), end, point, wkt);
+    }
+};
+
+template <typename Point, std::size_t DimensionCount>
+struct parsing_assigner<Point, DimensionCount, DimensionCount>
+{
+    static inline void apply(tokenizer::iterator&,
+                             tokenizer::iterator const&,
+                             Point&,
+                             std::string const&)
+    {
+    }
+};
+
+
+
+template <typename Iterator>
+inline void handle_open_parenthesis(Iterator& it,
+                                    Iterator const& end,
+                                    std::string const& wkt)
+{
+    if (it == end || *it != "(")
+    {
+        BOOST_THROW_EXCEPTION(read_wkt_exception("Expected '('", it, end, wkt));
+    }
+    ++it;
+}
+
+
+template <typename Iterator>
+inline void handle_close_parenthesis(Iterator& it,
+                                     Iterator const& end,
+                                     std::string const& wkt)
+{
+    if (it != end && *it == ")")
+    {
+        ++it;
+    }
+    else
+    {
+        BOOST_THROW_EXCEPTION(read_wkt_exception("Expected ')'", it, end, wkt));
+    }
+}
+
+template <typename Iterator>
+inline void check_end(Iterator& it,
+                      Iterator const& end,
+                      std::string const& wkt)
+{
+    if (it != end)
+    {
+        BOOST_THROW_EXCEPTION(read_wkt_exception("Too many tokens", it, end, wkt));
+    }
+}
+
+/*!
+\brief Internal, parses coordinate sequences, strings are formated like "(1 2,3 4,...)"
+\param it token-iterator, should be pre-positioned at "(", is post-positions after last ")"
+\param end end-token-iterator
+\param out Output itererator receiving coordinates
+*/
+template <typename Point>
+struct container_inserter
+{
+    // Version with output iterator
+    template <typename OutputIterator>
+    static inline void apply(tokenizer::iterator& it,
+                             tokenizer::iterator const& end,
+                             std::string const& wkt,
+                             OutputIterator out)
+    {
+        handle_open_parenthesis(it, end, wkt);
+
+        Point point;
+
+        // Parse points until closing parenthesis
+
+        while (it != end && *it != ")")
+        {
+            parsing_assigner<Point>::apply(it, end, point, wkt);
+            out = point;
+            ++out;
+            if (it != end && *it == ",")
+            {
+                ++it;
+            }
+        }
+
+        handle_close_parenthesis(it, end, wkt);
+    }
+};
+
+
+template <typename Geometry,
+          closure_selector Closure = closure<Geometry>::value>
+struct stateful_range_appender
+{
+    typedef typename geometry::point_type<Geometry>::type point_type;
+
+    // NOTE: Geometry is a reference
+    inline void append(Geometry geom, point_type const& point, bool)
+    {
+        geometry::append(geom, point);
+    }
+};
+
+template <typename Geometry>
+struct stateful_range_appender<Geometry, open>
+{
+    typedef typename geometry::point_type<Geometry>::type point_type;
+    typedef typename boost::range_size
+        <
+            typename util::bare_type<Geometry>::type
+        >::type size_type;
+
+    BOOST_STATIC_ASSERT(( boost::is_same
+                            <
+                                typename tag<Geometry>::type,
+                                ring_tag
+                            >::value ));
+
+    inline stateful_range_appender()
+        : pt_index(0)
+    {}
+
+    // NOTE: Geometry is a reference
+    inline void append(Geometry geom, point_type const& point, bool is_next_expected)
+    {
+        bool should_append = true;
+
+        if (pt_index == 0)
+        {
+            first_point = point;
+            //should_append = true;
+        }
+        else
+        {
+            // NOTE: if there is not enough Points, they're always appended
+            should_append
+                = is_next_expected
+                || pt_index < core_detail::closure::minimum_ring_size<open>::value
+                || !detail::equals::equals_point_point(point, first_point);
+        }
+        ++pt_index;
+
+        if (should_append)
+        {
+            geometry::append(geom, point);
+        }
+    }
+
+private:
+    size_type pt_index;
+    point_type first_point;
+};
+
+// Geometry is a value-type or reference-type
+template <typename Geometry>
+struct container_appender
+{
+    typedef typename geometry::point_type<Geometry>::type point_type;
+
+    static inline void apply(tokenizer::iterator& it,
+                             tokenizer::iterator const& end,
+                             std::string const& wkt,
+                             Geometry out)
+    {
+        handle_open_parenthesis(it, end, wkt);
+
+        stateful_range_appender<Geometry> appender;
+
+        // Parse points until closing parenthesis
+        while (it != end && *it != ")")
+        {
+            point_type point;
+
+            parsing_assigner<point_type>::apply(it, end, point, wkt);
+
+            bool const is_next_expected = it != end && *it == ",";
+
+            appender.append(out, point, is_next_expected);
+
+            if (is_next_expected)
+            {
+                ++it;
+            }
+        }
+
+        handle_close_parenthesis(it, end, wkt);
+    }
+};
+
+/*!
+\brief Internal, parses a point from a string like this "(x y)"
+\note used for parsing points and multi-points
+*/
+template <typename P>
+struct point_parser
+{
+    static inline void apply(tokenizer::iterator& it,
+                             tokenizer::iterator const& end,
+                             std::string const& wkt,
+                             P& point)
+    {
+        handle_open_parenthesis(it, end, wkt);
+        parsing_assigner<P>::apply(it, end, point, wkt);
+        handle_close_parenthesis(it, end, wkt);
+    }
+};
+
+
+template <typename Geometry>
+struct linestring_parser
+{
+    static inline void apply(tokenizer::iterator& it,
+                             tokenizer::iterator const& end,
+                             std::string const& wkt,
+                             Geometry& geometry)
+    {
+        container_appender<Geometry&>::apply(it, end, wkt, geometry);
+    }
+};
+
+
+template <typename Ring>
+struct ring_parser
+{
+    static inline void apply(tokenizer::iterator& it,
+                             tokenizer::iterator const& end,
+                             std::string const& wkt,
+                             Ring& ring)
+    {
+        // A ring should look like polygon((x y,x y,x y...))
+        // So handle the extra opening/closing parentheses
+        // and in between parse using the container-inserter
+        handle_open_parenthesis(it, end, wkt);
+        container_appender<Ring&>::apply(it, end, wkt, ring);
+        handle_close_parenthesis(it, end, wkt);
+    }
+};
+
+
+/*!
+\brief Internal, parses a polygon from a string like this "((x y,x y),(x y,x y))"
+\note used for parsing polygons and multi-polygons
+*/
+template <typename Polygon>
+struct polygon_parser
+{
+    typedef typename ring_return_type<Polygon>::type ring_return_type;
+    typedef container_appender<ring_return_type> appender;
+
+    static inline void apply(tokenizer::iterator& it,
+                             tokenizer::iterator const& end,
+                             std::string const& wkt,
+                             Polygon& poly)
+    {
+
+        handle_open_parenthesis(it, end, wkt);
+
+        int n = -1;
+
+        // Stop at ")"
+        while (it != end && *it != ")")
+        {
+            // Parse ring
+            if (++n == 0)
+            {
+                appender::apply(it, end, wkt, exterior_ring(poly));
+            }
+            else
+            {
+                typename ring_type<Polygon>::type ring;
+                appender::apply(it, end, wkt, ring);
+                traits::push_back
+                    <
+                        typename boost::remove_reference
+                        <
+                            typename traits::interior_mutable_type<Polygon>::type
+                        >::type
+                    >::apply(interior_rings(poly), ring);
+            }
+
+            if (it != end && *it == ",")
+            {
+                // Skip "," after ring is parsed
+                ++it;
+            }
+        }
+
+        handle_close_parenthesis(it, end, wkt);
+    }
+};
+
+
+inline bool one_of(tokenizer::iterator const& it,
+                   std::string const& value,
+                   bool& is_present)
+{
+    if (boost::iequals(*it, value))
+    {
+        is_present = true;
+        return true;
+    }
+    return false;
+}
+
+inline bool one_of(tokenizer::iterator const& it,
+                   std::string const& value,
+                   bool& present1,
+                   bool& present2)
+{
+    if (boost::iequals(*it, value))
+    {
+        present1 = true;
+        present2 = true;
+        return true;
+    }
+    return false;
+}
+
+
+inline void handle_empty_z_m(tokenizer::iterator& it,
+                             tokenizer::iterator const& end,
+                             bool& has_empty,
+                             bool& has_z,
+                             bool& has_m)
+{
+    has_empty = false;
+    has_z = false;
+    has_m = false;
+
+    // WKT can optionally have Z and M (measured) values as in
+    // POINT ZM (1 1 5 60), POINT M (1 1 80), POINT Z (1 1 5)
+    // GGL supports any of them as coordinate values, but is not aware
+    // of any Measured value.
+    while (it != end
+           && (one_of(it, "M", has_m)
+               || one_of(it, "Z", has_z)
+               || one_of(it, "EMPTY", has_empty)
+               || one_of(it, "MZ", has_m, has_z)
+               || one_of(it, "ZM", has_z, has_m)
+               )
+           )
+    {
+        ++it;
+    }
+}
+
+/*!
+\brief Internal, starts parsing
+\param tokens boost tokens, parsed with separator " " and keeping separator "()"
+\param geometry string to compare with first token
+*/
+template <typename Geometry>
+inline bool initialize(tokenizer const& tokens,
+                       std::string const& geometry_name,
+                       std::string const& wkt,
+                       tokenizer::iterator& it,
+                       tokenizer::iterator& end)
+{
+    it = tokens.begin();
+    end = tokens.end();
+    if (it != end && boost::iequals(*it++, geometry_name))
+    {
+        bool has_empty, has_z, has_m;
+
+        handle_empty_z_m(it, end, has_empty, has_z, has_m);
+
+// Silence warning C4127: conditional expression is constant
+#if defined(_MSC_VER)
+#pragma warning(push)  
+#pragma warning(disable : 4127)  
+#endif
+
+        if (has_z && dimension<Geometry>::type::value < 3)
+        {
+            BOOST_THROW_EXCEPTION(read_wkt_exception("Z only allowed for 3 or more dimensions", wkt));
+        }
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+        if (has_empty)
+        {
+            check_end(it, end, wkt);
+            return false;
+        }
+        // M is ignored at all.
+
+        return true;
+    }
+    BOOST_THROW_EXCEPTION(read_wkt_exception(std::string("Should start with '") + geometry_name + "'", wkt));
+}
+
+
+template <typename Geometry, template<typename> class Parser, typename PrefixPolicy>
+struct geometry_parser
+{
+    static inline void apply(std::string const& wkt, Geometry& geometry)
+    {
+        geometry::clear(geometry);
+
+        tokenizer tokens(wkt, boost::char_separator<char>(" ", ",()"));
+        tokenizer::iterator it, end;
+        if (initialize<Geometry>(tokens, PrefixPolicy::apply(), wkt, it, end))
+        {
+            Parser<Geometry>::apply(it, end, wkt, geometry);
+            check_end(it, end, wkt);
+        }
+    }
+};
+
+
+template <typename MultiGeometry, template<typename> class Parser, typename PrefixPolicy>
+struct multi_parser
+{
+    static inline void apply(std::string const& wkt, MultiGeometry& geometry)
+    {
+        traits::clear<MultiGeometry>::apply(geometry);
+
+        tokenizer tokens(wkt, boost::char_separator<char>(" ", ",()"));
+        tokenizer::iterator it, end;
+        if (initialize<MultiGeometry>(tokens, PrefixPolicy::apply(), wkt, it, end))
+        {
+            handle_open_parenthesis(it, end, wkt);
+
+            // Parse sub-geometries
+            while(it != end && *it != ")")
+            {
+                traits::resize<MultiGeometry>::apply(geometry, boost::size(geometry) + 1);
+                Parser
+                    <
+                        typename boost::range_value<MultiGeometry>::type
+                    >::apply(it, end, wkt, *(boost::end(geometry) - 1));
+                if (it != end && *it == ",")
+                {
+                    // Skip "," after multi-element is parsed
+                    ++it;
+                }
+            }
+
+            handle_close_parenthesis(it, end, wkt);
+        }
+
+        check_end(it, end, wkt);
+    }
+};
+
+template <typename P>
+struct noparenthesis_point_parser
+{
+    static inline void apply(tokenizer::iterator& it,
+                             tokenizer::iterator const& end,
+                             std::string const& wkt,
+                             P& point)
+    {
+        parsing_assigner<P>::apply(it, end, point, wkt);
+    }
+};
+
+template <typename MultiGeometry, typename PrefixPolicy>
+struct multi_point_parser
+{
+    static inline void apply(std::string const& wkt, MultiGeometry& geometry)
+    {
+        traits::clear<MultiGeometry>::apply(geometry);
+
+        tokenizer tokens(wkt, boost::char_separator<char>(" ", ",()"));
+        tokenizer::iterator it, end;
+
+        if (initialize<MultiGeometry>(tokens, PrefixPolicy::apply(), wkt, it, end))
+        {
+            handle_open_parenthesis(it, end, wkt);
+
+            // If first point definition starts with "(" then parse points as (x y)
+            // otherwise as "x y"
+            bool using_brackets = (it != end && *it == "(");
+
+            while(it != end && *it != ")")
+            {
+                traits::resize<MultiGeometry>::apply(geometry, boost::size(geometry) + 1);
+
+                if (using_brackets)
+                {
+                    point_parser
+                        <
+                            typename boost::range_value<MultiGeometry>::type
+                        >::apply(it, end, wkt, *(boost::end(geometry) - 1));
+                }
+                else
+                {
+                    noparenthesis_point_parser
+                        <
+                            typename boost::range_value<MultiGeometry>::type
+                        >::apply(it, end, wkt, *(boost::end(geometry) - 1));
+                }
+
+                if (it != end && *it == ",")
+                {
+                    // Skip "," after point is parsed
+                    ++it;
+                }
+            }
+
+            handle_close_parenthesis(it, end, wkt);
+        }
+
+        check_end(it, end, wkt);
+    }
+};
+
+
+/*!
+\brief Supports box parsing
+\note OGC does not define the box geometry, and WKT does not support boxes.
+    However, to be generic GGL supports reading and writing from and to boxes.
+    Boxes are outputted as a standard POLYGON. GGL can read boxes from
+    a standard POLYGON, from a POLYGON with 2 points of from a BOX
+\tparam Box the box
+*/
+template <typename Box>
+struct box_parser
+{
+    static inline void apply(std::string const& wkt, Box& box)
+    {
+        bool should_close = false;
+        tokenizer tokens(wkt, boost::char_separator<char>(" ", ",()"));
+        tokenizer::iterator it = tokens.begin();
+        tokenizer::iterator end = tokens.end();
+        if (it != end && boost::iequals(*it, "POLYGON"))
+        {
+            ++it;
+            bool has_empty, has_z, has_m;
+            handle_empty_z_m(it, end, has_empty, has_z, has_m);
+            if (has_empty)
+            {
+                assign_zero(box);
+                return;
+            }
+            handle_open_parenthesis(it, end, wkt);
+            should_close = true;
+        }
+        else if (it != end && boost::iequals(*it, "BOX"))
+        {
+            ++it;
+        }
+        else
+        {
+            BOOST_THROW_EXCEPTION(read_wkt_exception("Should start with 'POLYGON' or 'BOX'", wkt));
+        }
+
+        typedef typename point_type<Box>::type point_type;
+        std::vector<point_type> points;
+        container_inserter<point_type>::apply(it, end, wkt, std::back_inserter(points));
+
+        if (should_close)
+        {
+            handle_close_parenthesis(it, end, wkt);
+        }
+        check_end(it, end, wkt);
+
+        unsigned int index = 0;
+        std::size_t n = boost::size(points);
+        if (n == 2)
+        {
+            index = 1;
+        }
+        else if (n == 4 || n == 5)
+        {
+            // In case of 4 or 5 points, we do not check the other ones, just
+            // take the opposite corner which is always 2
+            index = 2;
+        }
+        else
+        {
+            BOOST_THROW_EXCEPTION(read_wkt_exception("Box should have 2,4 or 5 points", wkt));
+        }
+
+        geometry::detail::assign_point_to_index<min_corner>(points.front(), box);
+        geometry::detail::assign_point_to_index<max_corner>(points[index], box);
+    }
+};
+
+
+/*!
+\brief Supports segment parsing
+\note OGC does not define the segment, and WKT does not support segmentes.
+    However, it is useful to implement it, also for testing purposes
+\tparam Segment the segment
+*/
+template <typename Segment>
+struct segment_parser
+{
+    static inline void apply(std::string const& wkt, Segment& segment)
+    {
+        tokenizer tokens(wkt, boost::char_separator<char>(" ", ",()"));
+        tokenizer::iterator it = tokens.begin();
+        tokenizer::iterator end = tokens.end();
+        if (it != end &&
+            (boost::iequals(*it, "SEGMENT")
+            || boost::iequals(*it, "LINESTRING") ))
+        {
+            ++it;
+        }
+        else
+        {
+            BOOST_THROW_EXCEPTION(read_wkt_exception("Should start with 'LINESTRING' or 'SEGMENT'", wkt));
+        }
+
+        typedef typename point_type<Segment>::type point_type;
+        std::vector<point_type> points;
+        container_inserter<point_type>::apply(it, end, wkt, std::back_inserter(points));
+
+        check_end(it, end, wkt);
+
+        if (boost::size(points) == 2)
+        {
+            geometry::detail::assign_point_to_index<0>(points.front(), segment);
+            geometry::detail::assign_point_to_index<1>(points.back(), segment);
+        }
+        else
+        {
+            BOOST_THROW_EXCEPTION(read_wkt_exception("Segment should have 2 points", wkt));
+        }
+
+    }
+};
+
+
+}} // namespace detail::wkt
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Tag, typename Geometry>
+struct read_wkt {};
+
+
+template <typename Point>
+struct read_wkt<point_tag, Point>
+    : detail::wkt::geometry_parser
+        <
+            Point,
+            detail::wkt::point_parser,
+            detail::wkt::prefix_point
+        >
+{};
+
+
+template <typename L>
+struct read_wkt<linestring_tag, L>
+    : detail::wkt::geometry_parser
+        <
+            L,
+            detail::wkt::linestring_parser,
+            detail::wkt::prefix_linestring
+        >
+{};
+
+template <typename Ring>
+struct read_wkt<ring_tag, Ring>
+    : detail::wkt::geometry_parser
+        <
+            Ring,
+            detail::wkt::ring_parser,
+            detail::wkt::prefix_polygon
+        >
+{};
+
+template <typename Geometry>
+struct read_wkt<polygon_tag, Geometry>
+    : detail::wkt::geometry_parser
+        <
+            Geometry,
+            detail::wkt::polygon_parser,
+            detail::wkt::prefix_polygon
+        >
+{};
+
+
+template <typename MultiGeometry>
+struct read_wkt<multi_point_tag, MultiGeometry>
+    : detail::wkt::multi_point_parser
+            <
+                MultiGeometry,
+                detail::wkt::prefix_multipoint
+            >
+{};
+
+template <typename MultiGeometry>
+struct read_wkt<multi_linestring_tag, MultiGeometry>
+    : detail::wkt::multi_parser
+            <
+                MultiGeometry,
+                detail::wkt::linestring_parser,
+                detail::wkt::prefix_multilinestring
+            >
+{};
+
+template <typename MultiGeometry>
+struct read_wkt<multi_polygon_tag, MultiGeometry>
+    : detail::wkt::multi_parser
+            <
+                MultiGeometry,
+                detail::wkt::polygon_parser,
+                detail::wkt::prefix_multipolygon
+            >
+{};
+
+
+// Box (Non-OGC)
+template <typename Box>
+struct read_wkt<box_tag, Box>
+    : detail::wkt::box_parser<Box>
+{};
+
+// Segment (Non-OGC)
+template <typename Segment>
+struct read_wkt<segment_tag, Segment>
+    : detail::wkt::segment_parser<Segment>
+{};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+/*!
+\brief Parses OGC Well-Known Text (\ref WKT) into a geometry (any geometry)
+\ingroup wkt
+\tparam Geometry \tparam_geometry
+\param wkt string containing \ref WKT
+\param geometry \param_geometry output geometry
+\ingroup wkt
+\qbk{[include reference/io/read_wkt.qbk]}
+*/
+template <typename Geometry>
+inline void read_wkt(std::string const& wkt, Geometry& geometry)
+{
+    geometry::concepts::check<Geometry>();
+    dispatch::read_wkt<typename tag<Geometry>::type, Geometry>::apply(wkt, geometry);
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_IO_WKT_READ_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/stream.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/stream.hpp
new file mode 100644
index 00000000000..3849dda5946
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/stream.hpp
@@ -0,0 +1,38 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_IO_WKT_STREAM_HPP
+#define BOOST_GEOMETRY_IO_WKT_STREAM_HPP
+
+#include <boost/geometry/io/wkt/write.hpp>
+
+// This short file contains only one manipulator, streaming as WKT
+// Don't include this in any standard-included header file.
+
+// Don't use namespace boost::geometry, to enable the library to stream custom
+// geometries which are living outside the namespace boost::geometry
+
+// This is currently not documented on purpose: the Doxygen 2 QBK generator
+// should be updated w.r.t. << which in the end ruins the DocBook XML
+template<typename Char, typename Traits, typename Geometry>
+inline std::basic_ostream<Char, Traits>& operator<<
+    (
+        std::basic_ostream<Char, Traits> &os,
+        Geometry const& geom
+    )
+{
+    os << boost::geometry::wkt(geom);
+    return os;
+}
+
+#endif // BOOST_GEOMETRY_IO_WKT_STREAM_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/wkt.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/wkt.hpp
new file mode 100644
index 00000000000..28bd1e42aab
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/wkt.hpp
@@ -0,0 +1,25 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_IO_WKT_WKT_HPP
+#define BOOST_GEOMETRY_IO_WKT_WKT_HPP
+
+#include <boost/geometry/io/wkt/read.hpp>
+#include <boost/geometry/io/wkt/write.hpp>
+
+// BSG 2011-02-03
+// We don't include stream.hpp by default. That tries to stream anything not known
+// by default (such as ttmath) and reports errors.
+// Users can include stream.hpp themselves (if they want to)
+
+#endif // BOOST_GEOMETRY_IO_WKT_WKT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/write.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/write.hpp
new file mode 100644
index 00000000000..b98c894b384
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/io/wkt/write.hpp
@@ -0,0 +1,515 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_IO_WKT_WRITE_HPP
+#define BOOST_GEOMETRY_IO_WKT_WRITE_HPP
+
+#include <ostream>
+#include <string>
+
+#include <boost/array.hpp>
+#include <boost/range.hpp>
+
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/algorithms/detail/interior_iterator.hpp>
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/algorithms/convert.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/point_point.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+#include <boost/geometry/geometries/ring.hpp>
+
+#include <boost/geometry/io/wkt/detail/prefix.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+// Silence warning C4512: 'boost::geometry::wkt_manipulator<Geometry>' : assignment operator could not be generated
+#if defined(_MSC_VER)
+#pragma warning(push)  
+#pragma warning(disable : 4512)  
+#endif
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace wkt
+{
+
+template <typename P, int I, int Count>
+struct stream_coordinate
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os, P const& p)
+    {
+        os << (I > 0 ? " " : "") << get<I>(p);
+        stream_coordinate<P, I + 1, Count>::apply(os, p);
+    }
+};
+
+template <typename P, int Count>
+struct stream_coordinate<P, Count, Count>
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>&, P const&)
+    {}
+};
+
+struct prefix_linestring_par
+{
+    static inline const char* apply() { return "LINESTRING("; }
+};
+
+struct prefix_ring_par_par
+{
+    // Note, double parentheses are intentional, indicating WKT ring begin/end
+    static inline const char* apply() { return "POLYGON(("; }
+};
+
+struct opening_parenthesis
+{
+    static inline const char* apply() { return "("; }
+};
+
+struct closing_parenthesis
+{
+    static inline const char* apply() { return ")"; }
+};
+
+struct double_closing_parenthesis
+{
+    static inline const char* apply() { return "))"; }
+};
+
+/*!
+\brief Stream points as \ref WKT
+*/
+template <typename Point, typename Policy>
+struct wkt_point
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os, Point const& p)
+    {
+        os << Policy::apply() << "(";
+        stream_coordinate<Point, 0, dimension<Point>::type::value>::apply(os, p);
+        os << ")";
+    }
+};
+
+/*!
+\brief Stream ranges as WKT
+\note policy is used to stream prefix/postfix, enabling derived classes to override this
+*/
+template <typename Range, typename PrefixPolicy, typename SuffixPolicy>
+struct wkt_range
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+                Range const& range, bool force_closed)
+    {
+        typedef typename boost::range_iterator<Range const>::type iterator_type;
+
+        typedef stream_coordinate
+            <
+                point_type, 0, dimension<point_type>::type::value
+            > stream_type;
+
+        bool first = true;
+
+        os << PrefixPolicy::apply();
+
+        // TODO: check EMPTY here
+
+        iterator_type begin = boost::begin(range);
+        iterator_type end = boost::end(range);
+        for (iterator_type it = begin; it != end; ++it)
+        {
+            os << (first ? "" : ",");
+            stream_type::apply(os, *it);
+            first = false;
+        }
+
+        // optionally, close range to ring by repeating the first point
+        if (force_closed 
+            && boost::size(range) > 1
+            && detail::disjoint::disjoint_point_point(*begin, *(end - 1)))
+        {
+            os << ",";
+            stream_type::apply(os, *begin);
+        }
+
+        os << SuffixPolicy::apply();
+    }
+
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+                Range const& range)
+    {
+        apply(os, range, false);
+    }
+
+private:
+    typedef typename boost::range_value<Range>::type point_type;
+};
+
+/*!
+\brief Stream sequence of points as WKT-part, e.g. (1 2),(3 4)
+\note Used in polygon, all multi-geometries
+*/
+template <typename Range>
+struct wkt_sequence
+    : wkt_range
+        <
+            Range,
+            opening_parenthesis,
+            closing_parenthesis
+        >
+{};
+
+template <typename Polygon, typename PrefixPolicy>
+struct wkt_poly
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+                Polygon const& poly)
+    {
+        typedef typename ring_type<Polygon const>::type ring;
+        bool const force_closed = true;
+
+        os << PrefixPolicy::apply();
+        // TODO: check EMPTY here
+        os << "(";
+        wkt_sequence<ring>::apply(os, exterior_ring(poly), force_closed);
+
+        typename interior_return_type<Polygon const>::type
+            rings = interior_rings(poly);
+        for (typename detail::interior_iterator<Polygon const>::type
+                it = boost::begin(rings); it != boost::end(rings); ++it)
+        {
+            os << ",";
+            wkt_sequence<ring>::apply(os, *it, force_closed);
+        }
+        os << ")";
+    }
+};
+
+template <typename Multi, typename StreamPolicy, typename PrefixPolicy>
+struct wkt_multi
+{
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+                Multi const& geometry)
+    {
+        os << PrefixPolicy::apply();
+        // TODO: check EMPTY here
+        os << "(";
+
+        for (typename boost::range_iterator<Multi const>::type
+                    it = boost::begin(geometry);
+            it != boost::end(geometry);
+            ++it)
+        {
+            if (it != boost::begin(geometry))
+            {
+                os << ",";
+            }
+            StreamPolicy::apply(os, *it);
+        }
+
+        os << ")";
+    }
+};
+
+template <typename Box>
+struct wkt_box
+{
+    typedef typename point_type<Box>::type point_type;
+
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+                Box const& box)
+    {
+        // Convert to ring, then stream
+        typedef model::ring<point_type> ring_type;
+        ring_type ring;
+        geometry::convert(box, ring);
+        os << "POLYGON(";
+        wkt_sequence<ring_type>::apply(os, ring);
+        os << ")";
+    }
+
+    private:
+
+        inline wkt_box()
+        {
+            // Only streaming of boxes with two dimensions is support, otherwise it is a polyhedron!
+            //assert_dimension<B, 2>();
+        }
+};
+
+
+template <typename Segment>
+struct wkt_segment
+{
+    typedef typename point_type<Segment>::type point_type;
+
+    template <typename Char, typename Traits>
+    static inline void apply(std::basic_ostream<Char, Traits>& os,
+                Segment const& segment)
+    {
+        // Convert to two points, then stream
+        typedef boost::array<point_type, 2> sequence;
+
+        sequence points;
+        geometry::detail::assign_point_from_index<0>(segment, points[0]);
+        geometry::detail::assign_point_from_index<1>(segment, points[1]);
+
+        // In Boost.Geometry a segment is represented
+        // in WKT-format like (for 2D): LINESTRING(x y,x y)
+        os << "LINESTRING";
+        wkt_sequence<sequence>::apply(os, points);
+    }
+
+    private:
+
+        inline wkt_segment()
+        {}
+};
+
+}} // namespace detail::wkt
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct wkt: not_implemented<Tag>
+{};
+
+template <typename Point>
+struct wkt<Point, point_tag>
+    : detail::wkt::wkt_point
+        <
+            Point,
+            detail::wkt::prefix_point
+        >
+{};
+
+template <typename Linestring>
+struct wkt<Linestring, linestring_tag>
+    : detail::wkt::wkt_range
+        <
+            Linestring,
+            detail::wkt::prefix_linestring_par,
+            detail::wkt::closing_parenthesis
+        >
+{};
+
+/*!
+\brief Specialization to stream a box as WKT
+\details A "box" does not exist in WKT.
+It is therefore streamed as a polygon
+*/
+template <typename Box>
+struct wkt<Box, box_tag>
+    : detail::wkt::wkt_box<Box>
+{};
+
+template <typename Segment>
+struct wkt<Segment, segment_tag>
+    : detail::wkt::wkt_segment<Segment>
+{};
+
+/*!
+\brief Specialization to stream a ring as WKT
+\details A ring or "linear_ring" does not exist in WKT.
+A ring is equivalent to a polygon without inner rings
+It is therefore streamed as a polygon
+*/
+template <typename Ring>
+struct wkt<Ring, ring_tag>
+    : detail::wkt::wkt_range
+        <
+            Ring,
+            detail::wkt::prefix_ring_par_par,
+            detail::wkt::double_closing_parenthesis
+        >
+{};
+
+/*!
+\brief Specialization to stream polygon as WKT
+*/
+template <typename Polygon>
+struct wkt<Polygon, polygon_tag>
+    : detail::wkt::wkt_poly
+        <
+            Polygon,
+            detail::wkt::prefix_polygon
+        >
+{};
+
+template <typename Multi>
+struct wkt<Multi, multi_point_tag>
+    : detail::wkt::wkt_multi
+        <
+            Multi,
+            detail::wkt::wkt_point
+                <
+                    typename boost::range_value<Multi>::type,
+                    detail::wkt::prefix_null
+                >,
+            detail::wkt::prefix_multipoint
+        >
+{};
+
+template <typename Multi>
+struct wkt<Multi, multi_linestring_tag>
+    : detail::wkt::wkt_multi
+        <
+            Multi,
+            detail::wkt::wkt_sequence
+                <
+                    typename boost::range_value<Multi>::type
+                >,
+            detail::wkt::prefix_multilinestring
+        >
+{};
+
+template <typename Multi>
+struct wkt<Multi, multi_polygon_tag>
+    : detail::wkt::wkt_multi
+        <
+            Multi,
+            detail::wkt::wkt_poly
+                <
+                    typename boost::range_value<Multi>::type,
+                    detail::wkt::prefix_null
+                >,
+            detail::wkt::prefix_multipolygon
+        >
+{};
+
+
+template <typename Geometry>
+struct devarianted_wkt
+{
+    template <typename OutputStream>
+    static inline void apply(OutputStream& os, Geometry const& geometry)
+    {
+        wkt<Geometry>::apply(os, geometry);
+    }
+};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct devarianted_wkt<variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    template <typename OutputStream>
+    struct visitor: static_visitor<void>
+    {
+        OutputStream& m_os;
+
+        visitor(OutputStream& os)
+            : m_os(os)
+        {}
+
+        template <typename Geometry>
+        inline void operator()(Geometry const& geometry) const
+        {
+            devarianted_wkt<Geometry>::apply(m_os, geometry);
+        }
+    };
+
+    template <typename OutputStream>
+    static inline void apply(
+        OutputStream& os,
+        variant<BOOST_VARIANT_ENUM_PARAMS(T)> const& geometry
+    )
+    {
+        boost::apply_visitor(visitor<OutputStream>(os), geometry);
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+/*!
+\brief Generic geometry template manipulator class, takes corresponding output class from traits class
+\ingroup wkt
+\details Stream manipulator, streams geometry classes as \ref WKT streams
+\par Example:
+Small example showing how to use the wkt class
+\dontinclude doxygen_1.cpp
+\skip example_as_wkt_point
+\line {
+\until }
+*/
+template <typename Geometry>
+class wkt_manipulator
+{
+public:
+
+    inline wkt_manipulator(Geometry const& g)
+        : m_geometry(g)
+    {}
+
+    template <typename Char, typename Traits>
+    inline friend std::basic_ostream<Char, Traits>& operator<<(
+            std::basic_ostream<Char, Traits>& os,
+            wkt_manipulator const& m)
+    {
+        dispatch::devarianted_wkt<Geometry>::apply(os, m.m_geometry);
+        os.flush();
+        return os;
+    }
+
+private:
+    Geometry const& m_geometry;
+};
+
+/*!
+\brief Main WKT-streaming function
+\tparam Geometry \tparam_geometry
+\param geometry \param_geometry
+\ingroup wkt
+\qbk{[include reference/io/wkt.qbk]}
+*/
+template <typename Geometry>
+inline wkt_manipulator<Geometry> wkt(Geometry const& geometry)
+{
+    concepts::check<Geometry const>();
+
+    return wkt_manipulator<Geometry>(geometry);
+}
+
+#if defined(_MSC_VER)
+#pragma warning(pop)  
+#endif
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_IO_WKT_WRITE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/iterators/base.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/base.hpp
new file mode 100644
index 00000000000..1e824654e6b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/base.hpp
@@ -0,0 +1,70 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ITERATORS_BASE_HPP
+#define BOOST_GEOMETRY_ITERATORS_BASE_HPP
+
+#include <boost/iterator.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+#include <boost/mpl/if.hpp>
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace boost { namespace geometry { namespace detail { namespace iterators
+{
+
+template
+<
+    typename DerivedClass,
+    typename Iterator,
+    typename TraversalFlag = boost::bidirectional_traversal_tag
+>
+struct iterator_base
+    : public boost::iterator_adaptor
+    <
+        DerivedClass,
+        Iterator,
+        boost::use_default,
+        typename boost::mpl::if_
+        <
+            boost::is_convertible
+            <
+                typename boost::iterator_traversal<Iterator>::type,
+                boost::random_access_traversal_tag
+            >,
+            TraversalFlag,
+            boost::use_default
+        >::type
+    >
+{
+    // Define operator cast to Iterator to be able to write things like Iterator it = myit++
+    inline operator Iterator() const
+    {
+        return this->base();
+    }
+
+    /*inline bool operator==(Iterator const& other) const
+    {
+        return this->base() == other;
+    }
+    inline bool operator!=(Iterator const& other) const
+    {
+        return ! operator==(other);
+    }*/
+};
+
+}}}} // namespace boost::geometry::detail::iterators
+#endif
+
+
+#endif // BOOST_GEOMETRY_ITERATORS_BASE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/iterators/closing_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/closing_iterator.hpp
new file mode 100644
index 00000000000..e263f3aafbf
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/closing_iterator.hpp
@@ -0,0 +1,148 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ITERATORS_CLOSING_ITERATOR_HPP
+#define BOOST_GEOMETRY_ITERATORS_CLOSING_ITERATOR_HPP
+
+#include <boost/range.hpp>
+#include <boost/iterator.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+
+
+
+namespace boost { namespace geometry
+{
+
+/*!
+\brief Iterator which iterates through a range, but adds first element at end of the range
+\tparam Range range on which this class is based on
+\ingroup iterators
+\note It's const iterator treating the Range as one containing non-mutable elements.
+        For both "closing_iterator<Range> and "closing_iterator<Range const>
+        const reference is always returned when dereferenced.
+\note This class is normally used from "closeable_view" if Close==true
+*/
+template <typename Range>
+struct closing_iterator
+    : public boost::iterator_facade
+    <
+        closing_iterator<Range>,
+        typename boost::range_value<Range>::type const,
+        boost::random_access_traversal_tag
+    >
+{
+    typedef typename boost::range_difference<Range>::type difference_type;
+
+    /// Constructor including the range it is based on
+    explicit inline closing_iterator(Range& range)
+        : m_range(&range)
+        , m_iterator(boost::begin(range))
+        , m_end(boost::end(range))
+        , m_size(static_cast<difference_type>(boost::size(range)))
+        , m_index(0)
+    {}
+
+    /// Constructor to indicate the end of a range
+    explicit inline closing_iterator(Range& range, bool)
+        : m_range(&range)
+        , m_iterator(boost::end(range))
+        , m_end(boost::end(range))
+        , m_size(static_cast<difference_type>(boost::size(range)))
+        , m_index((m_size == 0) ? 0 : m_size + 1)
+    {}
+
+    /// Default constructor
+    explicit inline closing_iterator()
+        : m_range(NULL)
+        , m_size(0)
+        , m_index(0)
+    {}
+
+private:
+    friend class boost::iterator_core_access;
+
+    inline typename boost::range_value<Range>::type const& dereference() const
+    {
+        return *m_iterator;
+    }
+
+    inline difference_type distance_to(closing_iterator<Range> const& other) const
+    {
+        return other.m_index - this->m_index;
+    }
+
+    inline bool equal(closing_iterator<Range> const& other) const
+    {
+        return this->m_range == other.m_range
+            && this->m_index == other.m_index;
+    }
+
+    inline void increment()
+    {
+        if (++m_index < m_size)
+        {
+            ++m_iterator;
+        }
+        else
+        {
+            update_iterator();
+        }
+    }
+
+    inline void decrement()
+    {
+        if (m_index-- < m_size)
+        {
+            --m_iterator;
+        }
+        else
+        {
+            update_iterator();
+        }
+    }
+
+    inline void advance(difference_type n)
+    {
+        if (m_index < m_size && m_index + n < m_size)
+        {
+            m_index += n;
+            m_iterator += n;
+        }
+        else
+        {
+            m_index += n;
+            update_iterator();
+        }
+    }
+
+    inline void update_iterator()
+    {
+        this->m_iterator = m_index <= m_size
+            ? boost::begin(*m_range) + (m_index % m_size)
+            : boost::end(*m_range)
+            ;
+    }
+
+    Range* m_range;
+    typename boost::range_iterator<Range>::type m_iterator;
+    typename boost::range_iterator<Range>::type m_end;
+    difference_type m_size;
+    difference_type m_index;
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ITERATORS_CLOSING_ITERATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/iterators/concatenate_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/concatenate_iterator.hpp
new file mode 100644
index 00000000000..ea5728d0bcb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/concatenate_iterator.hpp
@@ -0,0 +1,153 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ITERATORS_CONCATENATE_ITERATOR_HPP
+#define BOOST_GEOMETRY_ITERATORS_CONCATENATE_ITERATOR_HPP
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/iterator.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+
+template
+<
+    typename Iterator1,
+    typename Iterator2,
+    typename Value,
+    typename Reference = Value&
+>
+class concatenate_iterator
+    : public boost::iterator_facade
+        <
+            concatenate_iterator<Iterator1, Iterator2, Value, Reference>,
+            Value,
+            boost::bidirectional_traversal_tag,
+            Reference
+        >
+{
+private:
+    Iterator1 m_it1, m_end1;
+    Iterator2 m_begin2, m_it2;
+
+public:
+    typedef Iterator1 first_iterator_type;
+    typedef Iterator2 second_iterator_type;
+
+    // default constructor
+    concatenate_iterator() {}
+
+    // for begin
+    concatenate_iterator(Iterator1 it1, Iterator1 end1,
+                         Iterator2 begin2, Iterator2 it2)
+        : m_it1(it1), m_end1(end1), m_begin2(begin2), m_it2(it2)
+    {}
+
+    // for end
+    concatenate_iterator(Iterator1 end1, Iterator2 begin2, Iterator2 end2)
+        : m_it1(end1), m_end1(end1), m_begin2(begin2), m_it2(end2)
+    {}
+
+    template
+    <
+        typename OtherIt1,
+        typename OtherIt2,
+        typename OtherValue,
+        typename OtherReference
+    >
+    concatenate_iterator(concatenate_iterator
+                         <
+                             OtherIt1,
+                             OtherIt2,
+                             OtherValue,
+                             OtherReference
+                         > const& other)
+        : m_it1(other.m_it1)
+        , m_end1(other.m_end1)
+        , m_begin2(other.m_begin2)
+        , m_it2(other.m_it2)
+    {
+        static const bool are_conv
+            = boost::is_convertible<OtherIt1, Iterator1>::value
+           && boost::is_convertible<OtherIt2, Iterator2>::value;
+
+        BOOST_MPL_ASSERT_MSG((are_conv),
+                             NOT_CONVERTIBLE,
+                             (types<OtherIt1, OtherIt2>));
+    }
+
+private:
+    friend class boost::iterator_core_access;
+
+    template <typename It1, typename It2, typename V, typename R>
+    friend class concatenate_iterator;
+
+    inline Reference dereference() const
+    {
+        if ( m_it1 == m_end1 )
+        {
+            return *m_it2;
+        }
+        return *m_it1;
+    }
+
+    template
+    <
+        typename OtherIt1,
+        typename OtherIt2,
+        typename OtherValue,
+        typename OtherReference
+    >
+    inline bool equal(concatenate_iterator
+                      <
+                          OtherIt1,
+                          OtherIt2,
+                          OtherValue,
+                          OtherReference
+                      > const& other) const
+    {
+        return m_it1 == other.m_it1 && m_it2 == other.m_it2;
+    }
+
+    inline void increment()
+    {
+        if ( m_it1 == m_end1 )
+        {
+            ++m_it2;
+        }
+        else
+        {
+            ++m_it1;
+        }
+    }
+
+    inline void decrement()
+    {
+        if ( m_it2 == m_begin2 )
+        {
+            --m_it1;
+        }
+        else
+        {
+            --m_it2;
+        }
+    }
+};
+
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ITERATORS_CONCATENATE_ITERATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/point_iterator/inner_range_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/point_iterator/inner_range_type.hpp
new file mode 100644
index 00000000000..b2239fb8ddc
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/point_iterator/inner_range_type.hpp
@@ -0,0 +1,66 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ITERATORS_DETAIL_POINT_ITERATOR_INNER_RANGE_TYPE_HPP
+#define BOOST_GEOMETRY_ITERATORS_DETAIL_POINT_ITERATOR_INNER_RANGE_TYPE_HPP
+
+#include <boost/range.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/mpl/if.hpp>
+
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace point_iterator
+{
+
+
+template
+<
+    typename Geometry, 
+    typename Tag = typename tag<Geometry>::type
+>
+struct inner_range_type
+{
+    typedef typename boost::mpl::if_c
+        <
+            !boost::is_const<Geometry>::type::value,
+            typename boost::range_value<Geometry>::type,
+            typename boost::range_value<Geometry>::type const
+        >::type type;
+};
+
+
+template <typename Polygon>
+struct inner_range_type<Polygon, polygon_tag>
+{
+    typedef typename boost::mpl::if_c
+        <
+            !boost::is_const<Polygon>::type::value,
+            typename geometry::ring_type<Polygon>::type,
+            typename geometry::ring_type<Polygon>::type const
+        >::type type;
+};
+
+
+}} // namespace detail::point_iterator
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ITERATORS_DETAIL_POINT_ITERATOR_INNER_RANGE_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/point_iterator/iterator_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/point_iterator/iterator_type.hpp
new file mode 100644
index 00000000000..a7805b127b5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/point_iterator/iterator_type.hpp
@@ -0,0 +1,136 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ITERATORS_DETAIL_POINT_ITERATOR_ITERATOR_TYPE_HPP
+#define BOOST_GEOMETRY_ITERATORS_DETAIL_POINT_ITERATOR_ITERATOR_TYPE_HPP
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/iterators/flatten_iterator.hpp>
+#include <boost/geometry/iterators/concatenate_iterator.hpp>
+
+#include <boost/geometry/iterators/detail/point_iterator/inner_range_type.hpp>
+#include <boost/geometry/iterators/detail/point_iterator/value_type.hpp>
+
+#include <boost/geometry/iterators/dispatch/point_iterator.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace point_iterator
+{
+
+
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct iterator_type
+    : not_implemented<Geometry>
+{};
+
+
+
+
+template <typename Linestring>
+struct iterator_type<Linestring, linestring_tag>
+{
+    typedef typename boost::range_iterator<Linestring>::type type;
+};
+
+
+template <typename Ring>
+struct iterator_type<Ring, ring_tag>
+{
+    typedef typename boost::range_iterator<Ring>::type type;
+};
+
+
+template <typename Polygon>
+class iterator_type<Polygon, polygon_tag>
+{
+private:
+    typedef typename inner_range_type<Polygon>::type inner_range;
+
+public:
+    typedef concatenate_iterator
+        <
+            typename boost::range_iterator<inner_range>::type,
+            flatten_iterator
+                <
+                    typename boost::range_iterator
+                        <
+                            typename geometry::interior_type<Polygon>::type
+                        >::type,
+                    typename iterator_type<inner_range>::type,
+                    typename value_type<Polygon>::type,
+                    dispatch::points_begin<inner_range>,
+                    dispatch::points_end<inner_range>
+                >,
+            typename value_type<Polygon>::type
+        > type;
+};
+
+
+template <typename MultiPoint>
+struct iterator_type<MultiPoint, multi_point_tag>
+{
+    typedef typename boost::range_iterator<MultiPoint>::type type;
+};
+
+
+template <typename MultiLinestring>
+class iterator_type<MultiLinestring, multi_linestring_tag>
+{
+private:
+    typedef typename inner_range_type<MultiLinestring>::type inner_range;
+
+public:
+    typedef flatten_iterator
+        <
+            typename boost::range_iterator<MultiLinestring>::type,
+            typename iterator_type<inner_range>::type,
+            typename value_type<MultiLinestring>::type,
+            dispatch::points_begin<inner_range>,
+            dispatch::points_end<inner_range>
+        > type;
+};
+
+
+template <typename MultiPolygon>
+class iterator_type<MultiPolygon, multi_polygon_tag>
+{
+private:
+    typedef typename inner_range_type<MultiPolygon>::type inner_range;
+
+public:
+    typedef flatten_iterator
+        <
+            typename boost::range_iterator<MultiPolygon>::type,
+            typename iterator_type<inner_range>::type,
+            typename value_type<MultiPolygon>::type,
+            dispatch::points_begin<inner_range>,
+            dispatch::points_end<inner_range>
+        > type;
+};
+
+
+}} // namespace detail::point_iterator
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ITERATORS_DETAIL_POINT_ITERATOR_ITERATOR_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/point_iterator/value_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/point_iterator/value_type.hpp
new file mode 100644
index 00000000000..7cdf3663916
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/point_iterator/value_type.hpp
@@ -0,0 +1,47 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ITERATORS_DETAIL_POINT_ITERATOR_VALUE_TYPE_HPP
+#define BOOST_GEOMETRY_ITERATORS_DETAIL_POINT_ITERATOR_VALUE_TYPE_HPP
+
+#include <boost/type_traits/is_const.hpp>
+#include <boost/mpl/if.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace point_iterator
+{
+
+
+template <typename Geometry>
+struct value_type
+{
+    typedef typename boost::mpl::if_c
+        <
+            !boost::is_const<Geometry>::type::value,
+            typename geometry::point_type<Geometry>::type,
+            typename geometry::point_type<Geometry>::type const
+        >::type type;
+};
+
+
+}} // namespace detail::point_iterator
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ITERATORS_DETAIL_POINT_ITERATOR_VALUE_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/segment_iterator/iterator_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/segment_iterator/iterator_type.hpp
new file mode 100644
index 00000000000..57a524e7e42
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/segment_iterator/iterator_type.hpp
@@ -0,0 +1,153 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ITERATORS_DETAIL_SEGMENT_ITERATOR_ITERATOR_TYPE_HPP
+#define BOOST_GEOMETRY_ITERATORS_DETAIL_SEGMENT_ITERATOR_ITERATOR_TYPE_HPP
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/interior_type.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+#include <boost/geometry/iterators/concatenate_iterator.hpp>
+#include <boost/geometry/iterators/flatten_iterator.hpp>
+#include <boost/geometry/iterators/detail/point_iterator/inner_range_type.hpp>
+
+#include <boost/geometry/iterators/detail/segment_iterator/range_segment_iterator.hpp>
+#include <boost/geometry/iterators/detail/segment_iterator/value_type.hpp>
+
+#include <boost/geometry/iterators/dispatch/segment_iterator.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace segment_iterator
+{
+
+
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct iterator_type
+    : not_implemented<Geometry>
+{};
+
+
+template <typename Linestring>
+struct iterator_type<Linestring, linestring_tag>
+{
+    typedef range_segment_iterator
+        <
+            Linestring, typename value_type<Linestring>::type
+        > type;
+};
+
+
+template <typename Ring>
+struct iterator_type<Ring, ring_tag>
+{
+    typedef range_segment_iterator
+        <
+            Ring, typename value_type<Ring>::type
+        > type;
+};
+
+
+template <typename Polygon>
+class iterator_type<Polygon, polygon_tag>
+{
+private:
+    typedef typename detail::point_iterator::inner_range_type
+        <
+            Polygon
+        >::type inner_range;
+
+public:
+    typedef concatenate_iterator
+        <
+            range_segment_iterator
+                <
+                    inner_range,
+                    typename value_type<Polygon>::type
+                >,
+            flatten_iterator
+                <
+                    typename boost::range_iterator
+                        <
+                            typename geometry::interior_type<Polygon>::type
+                        >::type,
+                    typename iterator_type<inner_range>::type,
+                    typename value_type<Polygon>::type,
+                    dispatch::segments_begin<inner_range>,
+                    dispatch::segments_end<inner_range>,
+                    typename value_type<Polygon>::type
+                >,
+            typename value_type<Polygon>::type,
+            typename value_type<Polygon>::type
+        > type;
+};
+
+
+template <typename MultiLinestring>
+class iterator_type<MultiLinestring, multi_linestring_tag>
+{
+private:
+    typedef typename detail::point_iterator::inner_range_type
+        <
+            MultiLinestring
+        >::type inner_range;
+
+public:
+    typedef flatten_iterator
+        <
+            typename boost::range_iterator<MultiLinestring>::type,
+            typename iterator_type<inner_range>::type,
+            typename value_type<MultiLinestring>::type,
+            dispatch::segments_begin<inner_range>,
+            dispatch::segments_end<inner_range>,
+            typename value_type<MultiLinestring>::type
+        > type;
+};
+
+
+template <typename MultiPolygon>
+class iterator_type<MultiPolygon, multi_polygon_tag>
+{
+private:
+    typedef typename detail::point_iterator::inner_range_type
+        <
+            MultiPolygon
+        >::type inner_range;
+public:
+    typedef flatten_iterator
+        <
+            typename boost::range_iterator<MultiPolygon>::type,
+            typename iterator_type<inner_range>::type,
+            typename value_type<MultiPolygon>::type,
+            dispatch::segments_begin<inner_range>,
+            dispatch::segments_end<inner_range>,
+            typename value_type<MultiPolygon>::type
+        > type;
+};
+
+
+
+}} // namespace detail::segment_iterator
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ITERATORS_DETAIL_SEGMENT_ITERATOR_ITERATOR_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/segment_iterator/range_segment_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/segment_iterator/range_segment_iterator.hpp
new file mode 100644
index 00000000000..e65b12b459f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/segment_iterator/range_segment_iterator.hpp
@@ -0,0 +1,215 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ITERATORS_DETAIL_SEGMENT_ITERATOR_RANGE_SEGMENT_ITERATOR_HPP
+#define BOOST_GEOMETRY_ITERATORS_DETAIL_SEGMENT_ITERATOR_RANGE_SEGMENT_ITERATOR_HPP
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/iterator.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/iterators/closing_iterator.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace segment_iterator
+{
+
+
+template <typename Range, closure_selector Closure = closure<Range>::value>
+struct range_iterator_type
+{
+    typedef typename boost::range_iterator<Range>::type type;
+};
+
+template <typename Range>
+struct range_iterator_type<Range, open>
+{
+    typedef closing_iterator<Range> type;
+};
+
+
+
+template <typename Range, closure_selector Closure = closure<Range>::value>
+struct range_iterator_begin
+{
+    static inline typename range_iterator_type<Range, Closure>::type
+    apply(Range& range)
+    {
+        return boost::begin(range);
+    }
+};
+
+template <typename Range>
+struct range_iterator_begin<Range, open>
+{
+    static inline typename range_iterator_type<Range, open>::type
+    apply(Range& range)
+    {
+        return closing_iterator<Range>(range);
+    }
+};
+
+
+
+template <typename Range, closure_selector Closure = closure<Range>::value>
+struct range_iterator_end
+{
+    static inline typename range_iterator_type<Range, Closure>::type
+    apply(Range& range)
+    {
+        return boost::end(range);
+    }
+};
+
+template <typename Range>
+struct range_iterator_end<Range, open>
+{
+    static inline typename range_iterator_type<Range, open>::type
+    apply(Range& range)
+    {
+        return closing_iterator<Range>(range, true);
+    }
+};
+
+
+
+
+
+
+template <typename Range, typename Value, typename Reference = Value>
+class range_segment_iterator
+    : public boost::iterator_facade
+        <
+            range_segment_iterator<Range, Value, Reference>,
+            Value,
+            boost::bidirectional_traversal_tag,
+            Reference
+        >
+{
+    static inline bool has_less_than_two_elements(Range const& r)
+    {
+        return boost::size(r) < ((closure<Range>::value == open) ? 1u : 2u);
+    }
+
+public:
+    typedef typename range_iterator_type<Range>::type iterator_type;
+
+    // default constructor
+    range_segment_iterator()
+        : m_it(), m_has_less_than_two_elements(false)
+    {}
+
+    // for begin
+    range_segment_iterator(Range& r)
+        : m_it(range_iterator_begin<Range>::apply(r))
+        , m_has_less_than_two_elements(has_less_than_two_elements(r))
+    {}
+
+    // for end
+    range_segment_iterator(Range& r, bool)
+        : m_it(range_iterator_end<Range>::apply(r))
+        , m_has_less_than_two_elements(has_less_than_two_elements(r))
+    {
+        if (! m_has_less_than_two_elements)
+        {
+            // the range consists of at least two items
+            --m_it;
+        }
+    }
+
+    template
+    <
+        typename OtherRange,
+        typename OtherValue,
+        typename OtherReference
+    >
+    range_segment_iterator(range_segment_iterator
+                           <
+                               OtherRange,
+                               OtherValue,
+                               OtherReference
+                           > const& other)
+        : m_it(other.m_it)
+    {
+        typedef typename range_segment_iterator
+            <
+                OtherRange, OtherValue, OtherReference
+            >::iterator_type other_iterator_type;
+
+        static const bool are_conv
+            = boost::is_convertible<other_iterator_type, iterator_type>::value;
+
+        BOOST_MPL_ASSERT_MSG((are_conv), NOT_CONVERTIBLE, (types<OtherRange>));
+    }
+
+private:
+    friend class boost::iterator_core_access;
+
+    template <typename Rng, typename V, typename R>
+    friend class range_segment_iterator;
+
+    inline Reference dereference() const
+    {
+        if (m_has_less_than_two_elements)
+        {
+            return Reference(*m_it, *m_it);
+        }
+
+        iterator_type next(m_it);
+        ++next;
+        return Reference(*m_it, *next);
+    }
+
+    template
+    <
+        typename OtherRange,
+        typename OtherValue,
+        typename OtherReference
+    >
+    inline bool equal(range_segment_iterator
+                      <
+                          OtherRange,
+                          OtherValue,
+                          OtherReference
+                      > const& other) const
+    {
+        return m_it == other.m_it;
+    }
+
+    inline void increment()
+    {
+        ++m_it;
+    }
+
+    inline void decrement()
+    {
+        --m_it;
+    }
+
+private:
+    iterator_type m_it;
+    bool m_has_less_than_two_elements;
+};
+
+
+}} // namespace detail::segment_iterator
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ITERATORS_DETAIL_SEGMENT_ITERATOR_RANGE_SEGMENT_ITERATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/segment_iterator/value_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/segment_iterator/value_type.hpp
new file mode 100644
index 00000000000..ff3267c8842
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/detail/segment_iterator/value_type.hpp
@@ -0,0 +1,71 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ITERATORS_DETAIL_SEGMENT_ITERATOR_VALUE_TYPE_HPP
+#define BOOST_GEOMETRY_ITERATORS_DETAIL_SEGMENT_ITERATOR_VALUE_TYPE_HPP
+
+#include <iterator>
+
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_reference.hpp>
+
+#include <boost/geometry/iterators/point_iterator.hpp>
+#include <boost/geometry/util/bare_type.hpp>
+#include <boost/geometry/geometries/segment.hpp>
+#include <boost/geometry/geometries/pointing_segment.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace segment_iterator
+{
+
+template <typename Geometry>
+struct value_type
+{
+    typedef typename std::iterator_traits
+        <
+            geometry::point_iterator<Geometry>
+        >::reference point_iterator_reference_type;
+
+    typedef typename detail::point_iterator::value_type
+        <
+            Geometry
+        >::type point_iterator_value_type;
+
+    // If the reference type of the point iterator is not really a
+    // reference, then dereferencing a point iterator would create
+    // a temporary object.
+    // In this case using a pointing_segment to represent the
+    // dereferenced value of the segment iterator cannot be used, as
+    // it would store pointers to temporary objects. Instead we use a
+    // segment, which does a full copy of the temporary objects
+    // returned by the point iterator.
+    typedef typename boost::mpl::if_
+        <
+            boost::is_reference<point_iterator_reference_type>,
+            geometry::model::pointing_segment<point_iterator_value_type>,
+            geometry::model::segment
+                <
+                    typename geometry::util::bare_type
+                        <
+                            point_iterator_value_type
+                        >::type
+                >
+        >::type type;
+};
+
+}} // namespace detail::segment_iterator
+#endif // DOXYGEN_NO_DETAIL
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ITERATORS_DETAIL_SEGMENT_ITERATOR_VALUE_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/iterators/dispatch/point_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/dispatch/point_iterator.hpp
new file mode 100644
index 00000000000..938dfd8ebc2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/dispatch/point_iterator.hpp
@@ -0,0 +1,47 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ITERATORS_DISPATCH_POINT_ITERATOR_HPP
+#define BOOST_GEOMETRY_ITERATORS_DISPATCH_POINT_ITERATOR_HPP
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// dispatch for points_begin
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct points_begin
+    : not_implemented<Geometry>
+{};
+
+
+
+// dispatch for points_end
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct points_end
+    : not_implemented<Geometry>
+{};
+
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ITERATORS_DISPATCH_POINT_ITERATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/iterators/dispatch/segment_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/dispatch/segment_iterator.hpp
new file mode 100644
index 00000000000..0c0a1b09a78
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/dispatch/segment_iterator.hpp
@@ -0,0 +1,47 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ITERATORS_DISPATCH_SEGMENT_ITERATOR_HPP
+#define BOOST_GEOMETRY_ITERATORS_DISPATCH_SEGMENT_ITERATOR_HPP
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// dispatch for segments_begin
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct segments_begin
+    : not_implemented<Geometry>
+{};
+
+
+
+// dispatch for segments_end
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct segments_end
+    : not_implemented<Geometry>
+{};
+
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ITERATORS_DISPATCH_SEGMENT_ITERATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/iterators/ever_circling_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/ever_circling_iterator.hpp
new file mode 100644
index 00000000000..cfb588b79f7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/ever_circling_iterator.hpp
@@ -0,0 +1,203 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ITERATORS_EVER_CIRCLING_ITERATOR_HPP
+#define BOOST_GEOMETRY_ITERATORS_EVER_CIRCLING_ITERATOR_HPP
+
+#include <boost/range.hpp>
+#include <boost/iterator.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+
+#include <boost/geometry/iterators/base.hpp>
+
+namespace boost { namespace geometry
+{
+
+/*!
+    \brief Iterator which ever circles through a range
+    \tparam Iterator iterator on which this class is based on
+    \ingroup iterators
+    \details If the iterator arrives at range.end() it restarts from the
+     beginning. So it has to be stopped in another way.
+    Don't call for(....; it++) because it will turn in an endless loop
+    \note Name inspired on David Bowie's
+    "Chant Of The Ever Circling Skeletal Family"
+*/
+template <typename Iterator>
+struct ever_circling_iterator :
+    public detail::iterators::iterator_base
+    <
+        ever_circling_iterator<Iterator>,
+        Iterator
+    >
+{
+    friend class boost::iterator_core_access;
+
+    explicit inline ever_circling_iterator(Iterator begin, Iterator end,
+            bool skip_first = false)
+      : m_begin(begin)
+      , m_end(end)
+      , m_skip_first(skip_first)
+    {
+        this->base_reference() = begin;
+    }
+
+    explicit inline ever_circling_iterator(Iterator begin, Iterator end, Iterator start,
+            bool skip_first = false)
+      : m_begin(begin)
+      , m_end(end)
+      , m_skip_first(skip_first)
+    {
+        this->base_reference() = start;
+    }
+
+    /// Navigate to a certain position, should be in [start .. end], if at end
+    /// it will circle again.
+    inline void moveto(Iterator it)
+    {
+        this->base_reference() = it;
+        check_end();
+    }
+
+private:
+
+    inline void increment(bool possibly_skip = true)
+    {
+        (this->base_reference())++;
+        check_end(possibly_skip);
+    }
+
+    inline void check_end(bool possibly_skip = true)
+    {
+        if (this->base() == this->m_end)
+        {
+            this->base_reference() = this->m_begin;
+            if (m_skip_first && possibly_skip)
+            {
+                increment(false);
+            }
+        }
+    }
+
+    Iterator m_begin;
+    Iterator m_end;
+    bool m_skip_first;
+};
+
+template <typename Range>
+struct ever_circling_range_iterator
+    : public boost::iterator_facade
+    <
+        ever_circling_range_iterator<Range>,
+        typename boost::range_value<Range>::type const,
+        boost::random_access_traversal_tag
+    >
+{
+    /// Constructor including the range it is based on
+    explicit inline ever_circling_range_iterator(Range& range)
+        : m_range(&range)
+        , m_iterator(boost::begin(range))
+        , m_size(boost::size(range))
+        , m_index(0)
+    {}
+
+    /// Default constructor
+    explicit inline ever_circling_range_iterator()
+        : m_range(NULL)
+        , m_size(0)
+        , m_index(0)
+    {}
+
+    typedef std::ptrdiff_t difference_type;
+
+private:
+    friend class boost::iterator_core_access;
+
+    inline typename boost::range_value<Range>::type const& dereference() const
+    {
+        return *m_iterator;
+    }
+
+    inline difference_type distance_to(ever_circling_range_iterator<Range> const& other) const
+    {
+        return other.m_index - this->m_index;
+    }
+
+    inline bool equal(ever_circling_range_iterator<Range> const& other) const
+    {
+        return this->m_range == other.m_range
+            && this->m_index == other.m_index;
+    }
+
+    inline void increment()
+    {
+        ++m_index;
+        if (m_index >= 0 && m_index < m_size)
+        {
+            ++m_iterator;
+        }
+        else
+        {
+            update_iterator();
+        }
+    }
+
+    inline void decrement()
+    {
+        --m_index;
+        if (m_index >= 0 && m_index < m_size)
+        {
+            --m_iterator;
+        }
+        else
+        {
+            update_iterator();
+        }
+    }
+
+    inline void advance(difference_type n)
+    {
+        if (m_index >= 0 && m_index < m_size
+            && m_index + n >= 0 && m_index + n < m_size)
+        {
+            m_index += n;
+            m_iterator += n;
+        }
+        else
+        {
+            m_index += n;
+            update_iterator();
+        }
+    }
+
+    inline void update_iterator()
+    {
+        while (m_index < 0)
+        {
+            m_index += m_size;
+        }
+        m_index = m_index % m_size;
+        this->m_iterator = boost::begin(*m_range) + m_index;
+    }
+
+    Range* m_range;
+    typename boost::range_iterator<Range>::type m_iterator;
+    difference_type m_size;
+    difference_type m_index;
+};
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ITERATORS_EVER_CIRCLING_ITERATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/iterators/flatten_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/flatten_iterator.hpp
new file mode 100644
index 00000000000..5ba70502209
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/flatten_iterator.hpp
@@ -0,0 +1,229 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ITERATORS_FLATTEN_ITERATOR_HPP
+#define BOOST_GEOMETRY_ITERATORS_FLATTEN_ITERATOR_HPP
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/iterator.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+
+template
+<
+    typename OuterIterator,
+    typename InnerIterator,
+    typename Value,
+    typename AccessInnerBegin,
+    typename AccessInnerEnd,
+    typename Reference = Value&
+>
+class flatten_iterator
+    : public boost::iterator_facade
+        <
+            flatten_iterator
+                <
+                    OuterIterator,
+                    InnerIterator,
+                    Value,
+                    AccessInnerBegin,
+                    AccessInnerEnd,
+                    Reference
+                >,
+            Value,
+            boost::bidirectional_traversal_tag,
+            Reference
+        >
+{
+private:
+    OuterIterator m_outer_it, m_outer_end;
+    InnerIterator m_inner_it;
+
+public:
+    typedef OuterIterator outer_iterator_type;
+    typedef InnerIterator inner_iterator_type;
+
+    // default constructor
+    flatten_iterator() {}
+
+    // for begin
+    flatten_iterator(OuterIterator outer_it, OuterIterator outer_end)
+        : m_outer_it(outer_it), m_outer_end(outer_end)
+    {
+        advance_through_empty();
+    }
+
+    // for end
+    flatten_iterator(OuterIterator outer_end)
+        : m_outer_it(outer_end), m_outer_end(outer_end)
+    {}
+
+    template
+    <
+        typename OtherOuterIterator, typename OtherInnerIterator,
+        typename OtherValue,
+        typename OtherAccessInnerBegin, typename OtherAccessInnerEnd,
+        typename OtherReference
+    >
+    flatten_iterator(flatten_iterator
+                     <
+                         OtherOuterIterator,
+                         OtherInnerIterator,
+                         OtherValue,
+                         OtherAccessInnerBegin,
+                         OtherAccessInnerEnd,
+                         OtherReference
+                     > const& other)
+        : m_outer_it(other.m_outer_it),
+          m_outer_end(other.m_outer_end),
+          m_inner_it(other.m_inner_it)
+    {
+        static const bool are_conv
+            = boost::is_convertible
+                <
+                    OtherOuterIterator, OuterIterator
+                >::value
+           && boost::is_convertible
+                <
+                    OtherInnerIterator, InnerIterator
+                >::value;
+
+        BOOST_MPL_ASSERT_MSG((are_conv),
+                             NOT_CONVERTIBLE,
+                             (types<OtherOuterIterator, OtherInnerIterator>));
+    }
+
+    flatten_iterator& operator=(flatten_iterator const& other)
+    {
+        m_outer_it = other.m_outer_it;
+        m_outer_end = other.m_outer_end;
+        // avoid assigning an iterator having singular value
+        if ( other.m_outer_it != other.m_outer_end )
+        {
+            m_inner_it = other.m_inner_it;
+        }
+        return *this;
+    }
+
+private:
+    friend class boost::iterator_core_access;
+
+    template
+    <
+        typename Outer,
+        typename Inner,
+        typename V,
+        typename InnerBegin,
+        typename InnerEnd,
+        typename R
+    >
+    friend class flatten_iterator;
+
+    static inline bool empty(OuterIterator outer_it)
+    {
+        return AccessInnerBegin::apply(*outer_it)
+            == AccessInnerEnd::apply(*outer_it);
+    }
+
+    inline void advance_through_empty()
+    {
+        while ( m_outer_it != m_outer_end && empty(m_outer_it) )
+        {
+            ++m_outer_it;
+        }
+
+        if ( m_outer_it != m_outer_end )
+        {
+            m_inner_it = AccessInnerBegin::apply(*m_outer_it);
+        }
+    }
+
+    inline Reference dereference() const
+    {
+        BOOST_GEOMETRY_ASSERT( m_outer_it != m_outer_end );
+        BOOST_GEOMETRY_ASSERT( m_inner_it != AccessInnerEnd::apply(*m_outer_it) );
+        return *m_inner_it;
+    }
+
+
+    template
+    <
+        typename OtherOuterIterator,
+        typename OtherInnerIterator,
+        typename OtherValue,
+        typename OtherAccessInnerBegin,
+        typename OtherAccessInnerEnd,
+        typename OtherReference
+    >
+    inline bool equal(flatten_iterator
+                      <
+                          OtherOuterIterator,
+                          OtherInnerIterator,
+                          OtherValue,
+                          OtherAccessInnerBegin,
+                          OtherAccessInnerEnd,
+                          OtherReference
+                      > const& other) const
+    {
+        if ( m_outer_it != other.m_outer_it )
+        {
+            return false;
+        }
+
+        if ( m_outer_it == m_outer_end )
+        {
+            return true;
+        }
+
+        return m_inner_it == other.m_inner_it;
+    }
+
+    inline void increment()
+    {
+        BOOST_GEOMETRY_ASSERT( m_outer_it != m_outer_end );
+        BOOST_GEOMETRY_ASSERT( m_inner_it != AccessInnerEnd::apply(*m_outer_it) );
+
+        ++m_inner_it;
+        if ( m_inner_it == AccessInnerEnd::apply(*m_outer_it) )
+        {
+            ++m_outer_it;
+            advance_through_empty();
+        }
+    }
+
+    inline void decrement()
+    {
+        if ( m_outer_it == m_outer_end
+             || m_inner_it == AccessInnerBegin::apply(*m_outer_it) )
+        {
+            do
+            {
+                --m_outer_it;
+            }
+            while ( empty(m_outer_it) );
+            m_inner_it = AccessInnerEnd::apply(*m_outer_it);
+        }        
+        --m_inner_it;
+    }
+};
+
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ITERATORS_FLATTEN_ITERATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/iterators/has_one_element.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/has_one_element.hpp
new file mode 100644
index 00000000000..2f9acefc1eb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/has_one_element.hpp
@@ -0,0 +1,29 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ITERATORS_HAS_ONE_ELEMENT_HPP
+#define BOOST_GEOMETRY_ITERATORS_HAS_ONE_ELEMENT_HPP
+
+
+namespace boost { namespace geometry
+{
+
+
+// free function to test if an iterator range has a single element
+template <typename Iterator>
+inline bool has_one_element(Iterator first, Iterator beyond)
+{
+    return first != beyond && ++first == beyond;
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ITERATORS_HAS_ONE_ELEMENT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/iterators/point_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/point_iterator.hpp
new file mode 100644
index 00000000000..5ee0e54917b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/point_iterator.hpp
@@ -0,0 +1,308 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ITERATORS_POINT_ITERATOR_HPP
+#define BOOST_GEOMETRY_ITERATORS_POINT_ITERATOR_HPP
+
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/iterators/dispatch/point_iterator.hpp>
+#include <boost/geometry/iterators/detail/point_iterator/iterator_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// specializations for points_begin
+
+
+template <typename Linestring>
+struct points_begin<Linestring, linestring_tag>
+{
+    static inline typename detail::point_iterator::iterator_type
+        <
+            Linestring
+        >::type
+    apply(Linestring& linestring)
+    {
+        return boost::begin(linestring);
+    }
+};
+
+
+template <typename Ring>
+struct points_begin<Ring, ring_tag>
+{
+    static inline typename detail::point_iterator::iterator_type<Ring>::type
+    apply(Ring& ring)
+    {
+        return boost::begin(ring);
+    }
+};
+
+
+template <typename Polygon>
+struct points_begin<Polygon, polygon_tag>
+{
+    typedef typename detail::point_iterator::iterator_type
+        <
+            Polygon
+        >::type return_type;
+
+    static inline return_type apply(Polygon& polygon)
+    {
+        typedef typename return_type::second_iterator_type flatten_iterator;
+
+        return return_type
+            (boost::begin(geometry::exterior_ring(polygon)),
+             boost::end(geometry::exterior_ring(polygon)),
+             flatten_iterator(boost::begin(geometry::interior_rings(polygon)),
+                              boost::end(geometry::interior_rings(polygon))
+                              ),
+             flatten_iterator(boost::begin(geometry::interior_rings(polygon)),
+                              boost::end(geometry::interior_rings(polygon))
+                              )
+             );
+    }
+};
+
+
+template <typename MultiPoint>
+struct points_begin<MultiPoint, multi_point_tag>
+{
+    static inline typename detail::point_iterator::iterator_type
+        <
+            MultiPoint
+        >::type
+    apply(MultiPoint& multipoint)
+    {
+        return boost::begin(multipoint);
+    }
+};
+
+
+template <typename MultiLinestring>
+struct points_begin<MultiLinestring, multi_linestring_tag>
+{
+    typedef typename detail::point_iterator::iterator_type
+        <
+            MultiLinestring
+        >::type return_type;
+
+    static inline return_type apply(MultiLinestring& multilinestring)
+    {
+        return return_type(boost::begin(multilinestring),
+                           boost::end(multilinestring));
+    }
+};
+
+
+template <typename MultiPolygon>
+struct points_begin<MultiPolygon, multi_polygon_tag>
+{
+    typedef typename detail::point_iterator::iterator_type
+        <
+            MultiPolygon
+        >::type return_type;
+
+    static inline return_type apply(MultiPolygon& multipolygon)
+    {
+        return return_type(boost::begin(multipolygon),
+                           boost::end(multipolygon));
+    }
+};
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// specializations for points_end
+
+
+template <typename Linestring>
+struct points_end<Linestring, linestring_tag>
+{
+    static inline typename detail::point_iterator::iterator_type
+        <
+            Linestring
+        >::type
+    apply(Linestring& linestring)
+    {
+        return boost::end(linestring);
+    }
+};
+
+
+template <typename Ring>
+struct points_end<Ring, ring_tag>
+{
+    static inline typename detail::point_iterator::iterator_type<Ring>::type
+    apply(Ring& ring)
+    {
+        return boost::end(ring);
+    }
+};
+
+
+template <typename Polygon>
+struct points_end<Polygon, polygon_tag>
+{
+    typedef typename detail::point_iterator::iterator_type
+        <
+            Polygon
+        >::type return_type;
+
+    static inline return_type apply(Polygon& polygon)
+    {
+        typedef typename return_type::second_iterator_type flatten_iterator;
+
+        return return_type
+            (boost::end(geometry::exterior_ring(polygon)),
+             flatten_iterator(boost::begin(geometry::interior_rings(polygon)),
+                              boost::end(geometry::interior_rings(polygon))
+                              ),
+             flatten_iterator( boost::end(geometry::interior_rings(polygon)) )
+             );
+    }
+};
+
+
+template <typename MultiPoint>
+struct points_end<MultiPoint, multi_point_tag>
+{
+    static inline typename detail::point_iterator::iterator_type
+        <
+            MultiPoint
+        >::type
+    apply(MultiPoint& multipoint)
+    {
+        return boost::end(multipoint);
+    }
+};
+
+
+template <typename MultiLinestring>
+struct points_end<MultiLinestring, multi_linestring_tag>
+{
+    typedef typename detail::point_iterator::iterator_type
+        <
+            MultiLinestring
+        >::type return_type;
+
+    static inline return_type apply(MultiLinestring& multilinestring)
+    {
+        return return_type(boost::end(multilinestring));
+    }
+};
+
+
+template <typename MultiPolygon>
+struct points_end<MultiPolygon, multi_polygon_tag>
+{
+    typedef typename detail::point_iterator::iterator_type
+        <
+            MultiPolygon
+        >::type return_type;
+
+    static inline return_type apply(MultiPolygon& multipolygon)
+    {
+        return return_type(boost::end(multipolygon));
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+// MK:: need to add doc here
+template <typename Geometry>
+class point_iterator
+    : public boost::iterator_adaptor
+        <
+            point_iterator<Geometry>,
+            typename detail::point_iterator::iterator_type<Geometry>::type
+        >
+{
+private:
+    template <typename OtherGeometry> friend class point_iterator;
+    template <typename G> friend inline point_iterator<G> points_begin(G&);
+    template <typename G> friend inline point_iterator<G> points_end(G&);
+
+    inline point_iterator(typename point_iterator::base_type const& base_it)
+        : point_iterator::iterator_adaptor_(base_it) {}
+
+public:
+    inline point_iterator() {}
+
+    template <typename OtherGeometry>
+    inline point_iterator(point_iterator<OtherGeometry> const& other)
+        : point_iterator::iterator_adaptor_(other.base())
+    {
+        static const bool is_conv
+            = boost::is_convertible<
+                typename detail::point_iterator::iterator_type
+                    <
+                        OtherGeometry
+                    >::type,
+                typename detail::point_iterator::iterator_type
+                    <
+                        Geometry
+                    >::type
+            >::value;
+
+        BOOST_MPL_ASSERT_MSG((is_conv),
+                             NOT_CONVERTIBLE,
+                             (point_iterator<OtherGeometry>));
+    }
+};
+
+
+// MK:: need to add doc here
+template <typename Geometry>
+inline point_iterator<Geometry>
+points_begin(Geometry& geometry)
+{
+    return dispatch::points_begin<Geometry>::apply(geometry);
+}
+
+
+// MK:: need to add doc here
+template <typename Geometry>
+inline point_iterator<Geometry>
+points_end(Geometry& geometry)
+{
+    return dispatch::points_end<Geometry>::apply(geometry);
+}
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ITERATORS_POINT_ITERATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/iterators/point_reverse_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/point_reverse_iterator.hpp
new file mode 100644
index 00000000000..b464c5f22ab
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/point_reverse_iterator.hpp
@@ -0,0 +1,89 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ITERATORS_POINT_REVERSE_ITERATOR_HPP
+#define BOOST_GEOMETRY_ITERATORS_POINT_REVERSE_ITERATOR_HPP
+
+#include <iterator>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+
+#include <boost/geometry/iterators/point_iterator.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+// MK:: need to add doc here
+template <typename Geometry>
+class point_reverse_iterator
+    : public std::reverse_iterator<point_iterator<Geometry> >
+{
+private:
+    typedef std::reverse_iterator<point_iterator<Geometry> > base_type;
+
+    template <typename OtherGeometry> friend class point_reverse_iterator;
+    template <typename G>
+    friend inline point_reverse_iterator<G> points_rbegin(G&);
+
+    template <typename G>
+    friend inline point_reverse_iterator<G> points_rend(G&);
+
+    inline point_reverse_iterator(base_type const& base_it)
+        : base_type(base_it) {}
+
+public:
+    inline point_reverse_iterator() {}
+
+    template <typename OtherGeometry>
+    inline
+    point_reverse_iterator(point_reverse_iterator<OtherGeometry> const& other)
+        : base_type(other.base())
+    {
+        static const bool is_conv = boost::is_convertible
+            <
+                std::reverse_iterator<point_iterator<Geometry> >,
+                std::reverse_iterator<point_iterator<OtherGeometry> >
+            >::value;
+
+        BOOST_MPL_ASSERT_MSG((is_conv),
+                             NOT_CONVERTIBLE,
+                             (point_reverse_iterator<OtherGeometry>));
+    }
+};
+
+
+// MK:: need to add doc here
+template <typename Geometry>
+inline point_reverse_iterator<Geometry>
+points_rbegin(Geometry& geometry)
+{
+    return std::reverse_iterator
+        <
+            point_iterator<Geometry>
+        >(points_end(geometry));
+}
+
+
+// MK:: need to add doc here
+template <typename Geometry>
+inline point_reverse_iterator<Geometry>
+points_rend(Geometry& geometry)
+{
+    return std::reverse_iterator
+        <
+            point_iterator<Geometry>
+        >(points_begin(geometry));
+}
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ITERATORS_POINT_REVERSE_ITERATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/iterators/segment_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/segment_iterator.hpp
new file mode 100644
index 00000000000..71aff39c43c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/iterators/segment_iterator.hpp
@@ -0,0 +1,353 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ITERATORS_SEGMENT_ITERATOR_HPP
+#define BOOST_GEOMETRY_ITERATORS_SEGMENT_ITERATOR_HPP
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/iterators/detail/point_iterator/inner_range_type.hpp>
+#include <boost/geometry/iterators/detail/segment_iterator/iterator_type.hpp>
+
+#include <boost/geometry/iterators/dispatch/segment_iterator.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// specializations for segments_begin
+
+
+template <typename Linestring>
+struct segments_begin<Linestring, linestring_tag>
+{
+    typedef typename detail::segment_iterator::iterator_type
+        <
+            Linestring
+        >::type return_type;
+
+    static inline return_type apply(Linestring& linestring)
+    {
+        return return_type(linestring);
+    }
+};
+
+
+template <typename Ring>
+struct segments_begin<Ring, ring_tag>
+{
+    typedef typename detail::segment_iterator::iterator_type
+        <
+            Ring
+        >::type return_type;
+
+    static inline return_type apply(Ring& ring)
+    {
+        return return_type(ring);
+    }
+};
+
+
+template <typename Polygon>
+struct segments_begin<Polygon, polygon_tag>
+{
+    typedef typename detail::point_iterator::inner_range_type
+        <
+            Polygon
+        >::type inner_range;
+
+    typedef typename detail::segment_iterator::iterator_type
+        <
+            Polygon
+        >::type return_type;
+
+    static inline return_type apply(Polygon& polygon)
+    {
+        typedef typename return_type::second_iterator_type flatten_iterator;
+
+        return return_type
+            (segments_begin
+                 <
+                     inner_range
+                 >::apply(geometry::exterior_ring(polygon)),
+             segments_end
+                 <
+                     inner_range
+                 >::apply(geometry::exterior_ring(polygon)),
+             flatten_iterator(boost::begin(geometry::interior_rings(polygon)),
+                              boost::end(geometry::interior_rings(polygon))
+                              ),
+             flatten_iterator(boost::begin(geometry::interior_rings(polygon)),
+                              boost::end(geometry::interior_rings(polygon))
+                              )
+             );
+    }
+};
+
+
+template <typename MultiLinestring>
+struct segments_begin<MultiLinestring, multi_linestring_tag>
+{
+    typedef typename detail::segment_iterator::iterator_type
+        <
+            MultiLinestring
+        >::type return_type;
+
+    static inline return_type apply(MultiLinestring& multilinestring)
+    {
+        return return_type(boost::begin(multilinestring),
+                           boost::end(multilinestring));
+    }
+};
+
+
+template <typename MultiPolygon>
+struct segments_begin<MultiPolygon, multi_polygon_tag>
+{
+    typedef typename detail::segment_iterator::iterator_type
+        <
+            MultiPolygon
+        >::type return_type;
+
+    static inline return_type apply(MultiPolygon& multipolygon)
+    {
+        return return_type(boost::begin(multipolygon),
+                           boost::end(multipolygon));
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+// specializations for segments_end
+
+
+template <typename Linestring>
+struct segments_end<Linestring, linestring_tag>
+{
+    typedef typename detail::segment_iterator::iterator_type
+        <
+            Linestring
+        >::type return_type;
+
+    static inline return_type apply(Linestring& linestring)
+    {
+        return return_type(linestring, true);
+    }
+};
+
+
+template <typename Ring>
+struct segments_end<Ring, ring_tag>
+{
+    typedef typename detail::segment_iterator::iterator_type
+        <
+            Ring
+        >::type return_type;
+
+    static inline return_type apply(Ring& ring)
+    {
+        return return_type(ring, true);
+    }
+};
+
+
+template <typename Polygon>
+struct segments_end<Polygon, polygon_tag>
+{
+    typedef typename detail::point_iterator::inner_range_type
+        <
+            Polygon
+        >::type inner_range;
+
+    typedef typename detail::segment_iterator::iterator_type
+        <
+            Polygon
+        >::type return_type;
+
+    static inline return_type apply(Polygon& polygon)
+    {
+        typedef typename return_type::second_iterator_type flatten_iterator;
+
+        return return_type
+            (segments_end
+                 <
+                     inner_range
+                 >::apply(geometry::exterior_ring(polygon)),
+             flatten_iterator(boost::begin(geometry::interior_rings(polygon)),
+                              boost::end(geometry::interior_rings(polygon))
+                              ),
+             flatten_iterator( boost::end(geometry::interior_rings(polygon)) )
+             );
+    }
+};
+
+
+template <typename MultiLinestring>
+struct segments_end<MultiLinestring, multi_linestring_tag>
+{
+    typedef typename detail::segment_iterator::iterator_type
+        <
+            MultiLinestring
+        >::type return_type;
+
+    static inline return_type apply(MultiLinestring& multilinestring)
+    {
+        return return_type(boost::end(multilinestring));
+    }
+};
+
+
+template <typename MultiPolygon>
+struct segments_end<MultiPolygon, multi_polygon_tag>
+{
+    typedef typename detail::segment_iterator::iterator_type
+        <
+            MultiPolygon
+        >::type return_type;
+
+    static inline return_type apply(MultiPolygon& multipolygon)
+    {
+        return return_type(boost::end(multipolygon));
+    }
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+// MK:: need to add doc here
+template <typename Geometry>
+class segment_iterator
+    : public detail::segment_iterator::iterator_type<Geometry>::type
+{
+private:
+    typedef typename detail::segment_iterator::iterator_type
+        <
+            Geometry
+        >::type base;
+
+    inline base const* base_ptr() const
+    {
+        return this;
+    }
+
+    template <typename OtherGeometry> friend class segment_iterator;
+
+    template <typename G>
+    friend inline segment_iterator<G const> segments_begin(G const&);
+
+    template <typename G>
+    friend inline segment_iterator<G const> segments_end(G const&);
+
+    inline segment_iterator(base const& base_it) : base(base_it) {}
+
+public:
+    // The following typedef is needed for this iterator to be
+    // bidirectional.
+    // Normally we would not have to define this. However, due to the
+    // fact that the value type of the iterator is not a reference,
+    // the iterator_facade framework (used to define the base class of
+    // this iterator) degrades automatically the iterator's category
+    // to input iterator. With the following typedef we recover the
+    // correct iterator category.
+    typedef std::bidirectional_iterator_tag iterator_category;
+
+    inline segment_iterator() {}
+
+    template <typename OtherGeometry>
+    inline segment_iterator(segment_iterator<OtherGeometry> const& other)
+        : base(*other.base_ptr())
+    {
+        static const bool is_conv
+            = boost::is_convertible<
+                typename detail::segment_iterator::iterator_type
+                    <
+                        OtherGeometry
+                    >::type,
+                typename detail::segment_iterator::iterator_type<Geometry>::type
+            >::value;
+
+        BOOST_MPL_ASSERT_MSG((is_conv),
+                             NOT_CONVERTIBLE,
+                             (segment_iterator<OtherGeometry>));
+    }
+
+    inline segment_iterator& operator++() // prefix
+    {
+        base::operator++();
+        return *this;
+    }
+
+    inline segment_iterator& operator--() // prefix
+    {
+        base::operator--();
+        return *this;
+    }
+
+    inline segment_iterator operator++(int) // postfix
+    {
+        segment_iterator copy(*this);
+        base::operator++();
+        return copy;
+    }
+
+    inline segment_iterator operator--(int) // postfix
+    {
+        segment_iterator copy(*this);
+        base::operator--();
+        return copy;
+    }
+};
+
+
+// MK:: need to add doc here
+template <typename Geometry>
+inline segment_iterator<Geometry const>
+segments_begin(Geometry const& geometry)
+{
+    return dispatch::segments_begin<Geometry const>::apply(geometry);
+}
+
+
+// MK:: need to add doc here
+template <typename Geometry>
+inline segment_iterator<Geometry const>
+segments_end(Geometry const& geometry)
+{
+    return dispatch::segments_end<Geometry const>::apply(geometry);
+}
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_ITERATORS_SEGMENT_ITERATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/append.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/append.hpp
new file mode 100644
index 00000000000..d1589aca849
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/append.hpp
@@ -0,0 +1,27 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_APPEND_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_APPEND_HPP
+
+
+#include <boost/geometry/algorithms/append.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_APPEND_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/area.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/area.hpp
new file mode 100644
index 00000000000..0e25ffc64ed
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/area.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_AREA_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_AREA_HPP
+
+
+#include <boost/geometry/algorithms/area.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_AREA_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/centroid.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/centroid.hpp
new file mode 100644
index 00000000000..1c9902f2bff
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/centroid.hpp
@@ -0,0 +1,22 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_CENTROID_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_CENTROID_HPP
+
+
+#include <boost/geometry/algorithms/centroid.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_CENTROID_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/clear.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/clear.hpp
new file mode 100644
index 00000000000..6d9e284d0a8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/clear.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_CLEAR_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_CLEAR_HPP
+
+
+#include <boost/geometry/algorithms/clear.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_CLEAR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/convert.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/convert.hpp
new file mode 100644
index 00000000000..0e7b2946d4e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/convert.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_CONVERT_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_CONVERT_HPP
+
+
+#include <boost/geometry/algorithms/convert.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_CONVERT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/correct.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/correct.hpp
new file mode 100644
index 00000000000..83d26ca60c9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/correct.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_CORRECT_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_CORRECT_HPP
+
+
+#include <boost/geometry/algorithms/correct.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_CORRECT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/covered_by.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/covered_by.hpp
new file mode 100644
index 00000000000..706bc78475e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/covered_by.hpp
@@ -0,0 +1,27 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2013 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013, 2014.
+// Modifications copyright (c) 2013, 2014 Oracle and/or its affiliates.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_COVERED_BY_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_COVERED_BY_HPP
+
+
+#include <boost/geometry/algorithms/covered_by.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_COVERED_BY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/extreme_points.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/extreme_points.hpp
new file mode 100644
index 00000000000..da2ac5e9fa1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/extreme_points.hpp
@@ -0,0 +1,19 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2013 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2013 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2013 Mateusz Loskot, London, UK.
+// Copyright (c) 2013 Adam Wulkiewicz, Lodz, Poland.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_EXTREME_POINTS_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_EXTREME_POINTS_HPP
+
+
+#include <boost/geometry/algorithms/detail/extreme_points.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_EXTREME_POINTS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/for_each_range.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/for_each_range.hpp
new file mode 100644
index 00000000000..2fe475ed583
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/for_each_range.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_FOR_EACH_RANGE_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_FOR_EACH_RANGE_HPP
+
+
+#include <boost/geometry/algorithms/detail/for_each_range.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_FOR_EACH_RANGE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/modify.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/modify.hpp
new file mode 100644
index 00000000000..ae52e002f02
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/modify.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_MODIFY_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_MODIFY_HPP
+
+
+#include <boost/geometry/algorithms/detail/multi_modify.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_MODIFY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/modify_with_predicate.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/modify_with_predicate.hpp
new file mode 100644
index 00000000000..1a82a671421
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/modify_with_predicate.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_MODIFY_WITH_PREDICATE_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_MODIFY_WITH_PREDICATE_HPP
+
+
+#include <boost/geometry/algorithms/detail/multi_modify_with_predicate.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_MODIFY_WITH_PREDICATE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/multi_sum.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/multi_sum.hpp
new file mode 100644
index 00000000000..b91970a1644
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/multi_sum.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_MULTI_SUM_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_MULTI_SUM_HPP
+
+
+#include <boost/geometry/algorithms/detail/multi_sum.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_MULTI_SUM_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/overlay/copy_segment_point.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/overlay/copy_segment_point.hpp
new file mode 100644
index 00000000000..5e23cf4bad4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/overlay/copy_segment_point.hpp
@@ -0,0 +1,19 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2013.
+// Modifications copyright (c) 2013, Oracle and/or its affiliates.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_OVERLAY_COPY_SEGMENT_POINT_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_OVERLAY_COPY_SEGMENT_POINT_HPP
+
+
+#include <boost/geometry/algorithms/detail/overlay/copy_segment_point.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_OVERLAY_COPY_SEGMENT_POINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/overlay/copy_segments.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/overlay/copy_segments.hpp
new file mode 100644
index 00000000000..54114bfae4b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/overlay/copy_segments.hpp
@@ -0,0 +1,16 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_OVERLAY_COPY_SEGMENTS_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_OVERLAY_COPY_SEGMENTS_HPP
+
+
+#include <boost/geometry/algorithms/detail/overlay/copy_segments.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_OVERLAY_COPY_SEGMENTS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/overlay/get_ring.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/overlay/get_ring.hpp
new file mode 100644
index 00000000000..65e00d064bb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/overlay/get_ring.hpp
@@ -0,0 +1,16 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_OVERLAY_GET_RING_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_OVERLAY_GET_RING_HPP
+
+
+#include <boost/geometry/algorithms/detail/overlay/get_ring.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_OVERLAY_GET_RING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/overlay/get_turns.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/overlay/get_turns.hpp
new file mode 100644
index 00000000000..a83fb773934
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/overlay/get_turns.hpp
@@ -0,0 +1,16 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_OVERLAY_GET_TURNS_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_OVERLAY_GET_TURNS_HPP
+
+
+#include <boost/geometry/algorithms/detail/overlay/get_turns.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_OVERLAY_GET_TURNS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/overlay/self_turn_points.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/overlay/self_turn_points.hpp
new file mode 100644
index 00000000000..39bfea2fb3f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/overlay/self_turn_points.hpp
@@ -0,0 +1,16 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_OVERLAY_SELF_TURN_POINTS_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_OVERLAY_SELF_TURN_POINTS_HPP
+
+
+#include <boost/geometry/algorithms/detail/overlay/self_turn_points.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_OVERLAY_SELF_TURN_POINTS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/point_on_border.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/point_on_border.hpp
new file mode 100644
index 00000000000..2ee789c5da8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/point_on_border.hpp
@@ -0,0 +1,24 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2013.
+// Modifications copyright (c) 2013, Oracle and/or its affiliates.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_POINT_ON_BORDER_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_POINT_ON_BORDER_HPP
+
+
+#include <boost/geometry/algorithms/detail/point_on_border.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_POINT_ON_BORDER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/sections/range_by_section.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/sections/range_by_section.hpp
new file mode 100644
index 00000000000..5604d9d74f9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/sections/range_by_section.hpp
@@ -0,0 +1,26 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2013.
+// Modifications copyright (c) 2013, Oracle and/or its affiliates.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_SECTIONS_RANGE_BY_SECTION_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_SECTIONS_RANGE_BY_SECTION_HPP
+
+
+#include <boost/geometry/algorithms/detail/sections/range_by_section.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_SECTIONS_RANGE_BY_SECTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/sections/sectionalize.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/sections/sectionalize.hpp
new file mode 100644
index 00000000000..ef98021237a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/detail/sections/sectionalize.hpp
@@ -0,0 +1,24 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2013.
+// Modifications copyright (c) 2013, Oracle and/or its affiliates.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_SECTIONS_SECTIONALIZE_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_SECTIONS_SECTIONALIZE_HPP
+
+
+#include <boost/geometry/algorithms/detail/sections/sectionalize.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_DETAIL_SECTIONS_SECTIONALIZE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/disjoint.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/disjoint.hpp
new file mode 100644
index 00000000000..55f0f01cd6c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/disjoint.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2012-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2012-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_DISJOINT_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_DISJOINT_HPP
+
+#include <boost/geometry/algorithms/disjoint.hpp>
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_DISJOINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/distance.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/distance.hpp
new file mode 100644
index 00000000000..4946b6f3e1e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/distance.hpp
@@ -0,0 +1,27 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_DISTANCE_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_DISTANCE_HPP
+
+// this file is intentionally empty (with the exception of the #include below)
+// it is used for backward compatinility and may be removed in the future
+
+#include <boost/geometry/algorithms/distance.hpp>
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_DISTANCE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/envelope.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/envelope.hpp
new file mode 100644
index 00000000000..457dfaf3bc7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/envelope.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_ENVELOPE_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_ENVELOPE_HPP
+
+
+#include <boost/geometry/algorithms/envelope.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_ENVELOPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/equals.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/equals.hpp
new file mode 100644
index 00000000000..0f045fff90b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/equals.hpp
@@ -0,0 +1,22 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_EQUALS_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_EQUALS_HPP
+
+
+#include <boost/geometry/algorithms/equals.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_EQUALS_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/for_each.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/for_each.hpp
new file mode 100644
index 00000000000..d8b3af1ff25
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/for_each.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_FOR_EACH_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_FOR_EACH_HPP
+
+
+#include <boost/geometry/algorithms/for_each.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_FOR_EACH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/intersection.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/intersection.hpp
new file mode 100644
index 00000000000..f434463253e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/intersection.hpp
@@ -0,0 +1,22 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_INTERSECTION_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_INTERSECTION_HPP
+
+
+#include <boost/geometry/algorithms/intersection.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_INTERSECTION_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/length.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/length.hpp
new file mode 100644
index 00000000000..168e6a732f9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/length.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_LENGTH_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_LENGTH_HPP
+
+
+#include <boost/geometry/algorithms/length.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_LENGTH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/num_geometries.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/num_geometries.hpp
new file mode 100644
index 00000000000..3a85f4e4bff
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/num_geometries.hpp
@@ -0,0 +1,22 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_NUM_GEOMETRIES_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_NUM_GEOMETRIES_HPP
+
+
+#include <boost/geometry/algorithms/num_geometries.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_NUM_GEOMETRIES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/num_interior_rings.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/num_interior_rings.hpp
new file mode 100644
index 00000000000..fbaa113aff5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/num_interior_rings.hpp
@@ -0,0 +1,26 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_NUM_INTERIOR_RINGS_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_NUM_INTERIOR_RINGS_HPP
+
+
+#include <boost/geometry/algorithms/num_interior_rings.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_NUM_INTERIOR_RINGS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/num_points.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/num_points.hpp
new file mode 100644
index 00000000000..a736f4254b2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/num_points.hpp
@@ -0,0 +1,27 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_NUM_POINTS_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_NUM_POINTS_HPP
+
+
+#include <boost/geometry/algorithms/num_points.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_NUM_POINTS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/perimeter.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/perimeter.hpp
new file mode 100644
index 00000000000..4820111f1f7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/perimeter.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_PERIMETER_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_PERIMETER_HPP
+
+
+#include <boost/geometry/algorithms/perimeter.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_PERIMETER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/remove_spikes.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/remove_spikes.hpp
new file mode 100644
index 00000000000..af224ec478c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/remove_spikes.hpp
@@ -0,0 +1,19 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2013 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2013 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2013 Mateusz Loskot, London, UK.
+// Copyright (c) 2013 Adam Wulkiewicz, Lodz, Poland.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_REMOVE_SPIKES_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_REMOVE_SPIKES_HPP
+
+
+#include <boost/geometry/algorithms/remove_spikes.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_REMOVE_SPIKES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/reverse.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/reverse.hpp
new file mode 100644
index 00000000000..a7872bdd2a0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/reverse.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_REVERSE_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_REVERSE_HPP
+
+
+#include <boost/geometry/algorithms/reverse.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_REVERSE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/simplify.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/simplify.hpp
new file mode 100644
index 00000000000..8648d366d1f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/simplify.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_SIMPLIFY_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_SIMPLIFY_HPP
+
+
+#include <boost/geometry/algorithms/simplify.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_SIMPLIFY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/transform.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/transform.hpp
new file mode 100644
index 00000000000..7aa691ec4a8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/transform.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_TRANSFORM_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_TRANSFORM_HPP
+
+
+#include <boost/geometry/algorithms/transform.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_TRANSFORM_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/unique.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/unique.hpp
new file mode 100644
index 00000000000..fa063a312dd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/unique.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_UNIQUE_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_UNIQUE_HPP
+
+
+#include <boost/geometry/algorithms/unique.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_UNIQUE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/within.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/within.hpp
new file mode 100644
index 00000000000..9fdc5dd39aa
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/algorithms/within.hpp
@@ -0,0 +1,25 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+// Copyright (c) 2013 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013, 2014.
+// Modifications copyright (c) 2013, 2014 Oracle and/or its affiliates.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+#ifndef BOOST_GEOMETRY_MULTI_ALGORITHMS_WITHIN_HPP
+#define BOOST_GEOMETRY_MULTI_ALGORITHMS_WITHIN_HPP
+
+#include <boost/geometry/algorithms/within.hpp>
+
+#endif // BOOST_GEOMETRY_MULTI_ALGORITHMS_WITHIN_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/concepts/check.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/concepts/check.hpp
new file mode 100644
index 00000000000..c741afd7948
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/concepts/check.hpp
@@ -0,0 +1,22 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_MULTI_GEOMETRIES_CONCEPTS_CHECK_HPP
+#define BOOST_GEOMETRY_MULTI_GEOMETRIES_CONCEPTS_CHECK_HPP
+
+
+#include <boost/geometry/geometries/concepts/check.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_GEOMETRIES_CONCEPTS_CHECK_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/concepts/multi_linestring_concept.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/concepts/multi_linestring_concept.hpp
new file mode 100644
index 00000000000..9a9438efccb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/concepts/multi_linestring_concept.hpp
@@ -0,0 +1,22 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_MULTI_GEOMETRIES_CONCEPTS_MULTI_LINESTRING_CONCEPT_HPP
+#define BOOST_GEOMETRY_MULTI_GEOMETRIES_CONCEPTS_MULTI_LINESTRING_CONCEPT_HPP
+
+
+#include <boost/geometry/geometries/concepts/multi_linestring_concept.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_GEOMETRIES_CONCEPTS_MULTI_LINESTRING_CONCEPT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/concepts/multi_point_concept.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/concepts/multi_point_concept.hpp
new file mode 100644
index 00000000000..14c1d25e57a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/concepts/multi_point_concept.hpp
@@ -0,0 +1,22 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_MULTI_GEOMETRIES_CONCEPTS_MULTI_POINT_CONCEPT_HPP
+#define BOOST_GEOMETRY_MULTI_GEOMETRIES_CONCEPTS_MULTI_POINT_CONCEPT_HPP
+
+
+#include <boost/geometry/geometries/concepts/multi_point_concept.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_GEOMETRIES_CONCEPTS_MULTI_POINT_CONCEPT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/concepts/multi_polygon_concept.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/concepts/multi_polygon_concept.hpp
new file mode 100644
index 00000000000..5e46fb75395
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/concepts/multi_polygon_concept.hpp
@@ -0,0 +1,22 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_MULTI_GEOMETRIES_CONCEPTS_MULTI_POLYGON_CONCEPT_HPP
+#define BOOST_GEOMETRY_MULTI_GEOMETRIES_CONCEPTS_MULTI_POLYGON_CONCEPT_HPP
+
+
+#include <boost/geometry/geometries/concepts/multi_polygon_concept.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_GEOMETRIES_CONCEPTS_MULTI_POLYGON_CONCEPT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/multi_geometries.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/multi_geometries.hpp
new file mode 100644
index 00000000000..53042091bdf
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/multi_geometries.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_GEOMETRIES_MULTI_GEOMETRIES_HPP
+#define BOOST_GEOMETRY_MULTI_GEOMETRIES_MULTI_GEOMETRIES_HPP
+
+#include <boost/geometry/geometries/multi_point.hpp>
+#include <boost/geometry/geometries/multi_linestring.hpp>
+#include <boost/geometry/geometries/multi_polygon.hpp>
+
+#endif // BOOST_GEOMETRY_MULTI_GEOMETRIES_MULTI_GEOMETRIES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/multi_linestring.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/multi_linestring.hpp
new file mode 100644
index 00000000000..696d907dccf
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/multi_linestring.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_GEOMETRIES_MULTI_LINESTRING_HPP
+#define BOOST_GEOMETRY_MULTI_GEOMETRIES_MULTI_LINESTRING_HPP
+
+
+#include <boost/geometry/geometries/multi_linestring.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_GEOMETRIES_MULTI_LINESTRING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/multi_point.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/multi_point.hpp
new file mode 100644
index 00000000000..750ad7802a6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/multi_point.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_GEOMETRIES_MULTI_POINT_HPP
+#define BOOST_GEOMETRY_MULTI_GEOMETRIES_MULTI_POINT_HPP
+
+
+#include <boost/geometry/geometries/multi_point.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_GEOMETRIES_MULTI_POINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/multi_polygon.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/multi_polygon.hpp
new file mode 100644
index 00000000000..06fefc7856b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/multi_polygon.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_GEOMETRIES_MULTI_POLYGON_HPP
+#define BOOST_GEOMETRY_MULTI_GEOMETRIES_MULTI_POLYGON_HPP
+
+
+#include <boost/geometry/geometries/multi_polygon.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_GEOMETRIES_MULTI_POLYGON_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/register/multi_linestring.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/register/multi_linestring.hpp
new file mode 100644
index 00000000000..2783a8455b6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/register/multi_linestring.hpp
@@ -0,0 +1,22 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_MULTI_GEOMETRIES_REGISTER_MULTI_LINESTRING_HPP
+#define BOOST_GEOMETRY_MULTI_GEOMETRIES_REGISTER_MULTI_LINESTRING_HPP
+
+
+#include <boost/geometry/geometries/register/multi_linestring.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_GEOMETRIES_REGISTER_MULTI_LINESTRING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/register/multi_point.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/register/multi_point.hpp
new file mode 100644
index 00000000000..6063492c2b4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/register/multi_point.hpp
@@ -0,0 +1,22 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_MULTI_GEOMETRIES_REGISTER_MULTI_POINT_HPP
+#define BOOST_GEOMETRY_MULTI_GEOMETRIES_REGISTER_MULTI_POINT_HPP
+
+
+#include <boost/geometry/geometries/register/multi_point.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_GEOMETRIES_REGISTER_MULTI_POINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/register/multi_polygon.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/register/multi_polygon.hpp
new file mode 100644
index 00000000000..6a3e47e3da5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/geometries/register/multi_polygon.hpp
@@ -0,0 +1,22 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_MULTI_GEOMETRIES_REGISTER_MULTI_POLYGON_HPP
+#define BOOST_GEOMETRY_MULTI_GEOMETRIES_REGISTER_MULTI_POLYGON_HPP
+
+
+#include <boost/geometry/geometries/register/multi_polygon.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_GEOMETRIES_REGISTER_MULTI_POLYGON_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/io/dsv/write.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/io/dsv/write.hpp
new file mode 100644
index 00000000000..092869f56c1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/io/dsv/write.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_IO_DSV_WRITE_HPP
+#define BOOST_GEOMETRY_MULTI_IO_DSV_WRITE_HPP
+
+
+#include <boost/geometry/io/dsv/write.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_IO_DSV_WRITE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/io/wkt/detail/prefix.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/io/wkt/detail/prefix.hpp
new file mode 100644
index 00000000000..34e2b241d09
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/io/wkt/detail/prefix.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_IO_WKT_DETAIL_PREFIX_HPP
+#define BOOST_GEOMETRY_MULTI_IO_WKT_DETAIL_PREFIX_HPP
+
+
+#include <boost/geometry/io/wkt/detail/prefix.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_IO_WKT_DETAIL_PREFIX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/io/wkt/read.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/io/wkt/read.hpp
new file mode 100644
index 00000000000..37e5f9e72e6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/io/wkt/read.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_IO_WKT_READ_MULTI_HPP
+#define BOOST_GEOMETRY_MULTI_IO_WKT_READ_MULTI_HPP
+
+
+#include <boost/geometry/io/wkt/read.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_IO_WKT_READ_MULTI_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/io/wkt/wkt.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/io/wkt/wkt.hpp
new file mode 100644
index 00000000000..a6159e1409a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/io/wkt/wkt.hpp
@@ -0,0 +1,20 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_IO_WKT_WKT_HPP
+#define BOOST_GEOMETRY_MULTI_IO_WKT_WKT_HPP
+
+#include <boost/geometry/io/wkt/read.hpp>
+#include <boost/geometry/io/wkt/write.hpp>
+
+#endif // BOOST_GEOMETRY_MULTI_IO_WKT_WKT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/io/wkt/write.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/io/wkt/write.hpp
new file mode 100644
index 00000000000..2c26d3d2e40
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/io/wkt/write.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_IO_WKT_WRITE_HPP
+#define BOOST_GEOMETRY_MULTI_IO_WKT_WRITE_HPP
+
+
+#include <boost/geometry/io/wkt/write.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_IO_WKT_WRITE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/multi.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/multi.hpp
new file mode 100644
index 00000000000..85d763ee6ef
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/multi.hpp
@@ -0,0 +1,24 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2013, 2015.
+// Modifications copyright (c) 2013-2015, Oracle and/or its affiliates.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_HPP
+#define BOOST_GEOMETRY_MULTI_HPP
+
+// keep this file for now, for backward compatibility
+// functionality-wise, make it equivalent to boost/geometry/geometry.hpp
+#include <boost/geometry/geometry.hpp>
+
+#endif // BOOST_GEOMETRY_MULTI_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/strategies/cartesian/centroid_average.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/strategies/cartesian/centroid_average.hpp
new file mode 100644
index 00000000000..ce614e2e76b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/strategies/cartesian/centroid_average.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_STRATEGIES_CARTESIAN_CENTROID_AVERAGE_HPP
+#define BOOST_GEOMETRY_MULTI_STRATEGIES_CARTESIAN_CENTROID_AVERAGE_HPP
+
+
+#include <boost/geometry/strategies/cartesian/centroid_average.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_STRATEGIES_CARTESIAN_CENTROID_AVERAGE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/views/detail/range_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/views/detail/range_type.hpp
new file mode 100644
index 00000000000..f8cb0e6e533
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/views/detail/range_type.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_VIEWS_DETAIL_RANGE_TYPE_HPP
+#define BOOST_GEOMETRY_MULTI_VIEWS_DETAIL_RANGE_TYPE_HPP
+
+
+#include <boost/geometry/views/detail/range_type.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_VIEWS_DETAIL_RANGE_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/policies/compare.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/policies/compare.hpp
new file mode 100644
index 00000000000..2e952d3e155
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/policies/compare.hpp
@@ -0,0 +1,242 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_POLICIES_COMPARE_HPP
+#define BOOST_GEOMETRY_POLICIES_COMPARE_HPP
+
+
+#include <cstddef>
+
+#include <boost/geometry/strategies/compare.hpp>
+#include <boost/geometry/util/math.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace compare
+{
+
+
+template
+<
+    int Direction,
+    typename Point,
+    typename Strategy,
+    std::size_t Dimension,
+    std::size_t DimensionCount
+>
+struct compare_loop
+{
+    typedef typename strategy::compare::detail::select_strategy
+        <
+            Strategy, Direction, Point, Dimension
+        >::type compare_type;
+
+    typedef typename geometry::coordinate_type<Point>::type coordinate_type;
+
+    static inline bool apply(Point const& left, Point const& right)
+    {
+        coordinate_type const& cleft = geometry::get<Dimension>(left);
+        coordinate_type const& cright = geometry::get<Dimension>(right);
+
+        if (geometry::math::equals(cleft, cright))
+        {
+            return compare_loop
+                <
+                    Direction, Point, Strategy,
+                    Dimension + 1, DimensionCount
+                >::apply(left, right);
+        }
+        else
+        {
+            compare_type compare;
+            return compare(cleft, cright);
+        }
+    }
+};
+
+template
+<
+    int Direction,
+    typename Point,
+    typename Strategy,
+    std::size_t DimensionCount
+>
+struct compare_loop<Direction, Point, Strategy, DimensionCount, DimensionCount>
+{
+    static inline bool apply(Point const&, Point const&)
+    {
+        // On coming here, points are equal. Return true if
+        // direction = 0 (equal), false if -1/1 (greater/less)
+        return Direction == 0;
+    }
+};
+
+
+template <int Direction, typename Point, typename Strategy>
+struct compare_in_all_dimensions
+{
+    inline bool operator()(Point const& left, Point const& right) const
+    {
+        return detail::compare::compare_loop
+            <
+                Direction, Point, Strategy,
+                0, geometry::dimension<Point>::type::value
+            >::apply(left, right);
+    }
+};
+
+
+template <typename Point, typename Strategy, std::size_t Dimension>
+class compare_in_one_dimension
+{
+    Strategy compare;
+
+public :
+    inline bool operator()(Point const& left, Point const& right) const
+    {
+        typedef typename geometry::coordinate_type<Point>::type coordinate_type;
+
+        coordinate_type const& cleft = get<Dimension>(left);
+        coordinate_type const& cright = get<Dimension>(right);
+        return compare(cleft, cright);
+    }
+};
+
+}} // namespace detail::compare
+
+#endif
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template
+<
+    int Direction,
+    typename Point,
+    typename Strategy,
+    int Dimension
+>
+struct compare_geometries
+    : detail::compare::compare_in_one_dimension
+        <
+            Point,
+            typename strategy::compare::detail::select_strategy
+                <
+                    Strategy, Direction, Point, Dimension
+                >::type,
+            Dimension
+        >
+{};
+
+
+// Specialization with -1: compare in all dimensions
+template <int Direction, typename Point, typename Strategy>
+struct compare_geometries<Direction, Point, Strategy, -1>
+    : detail::compare::compare_in_all_dimensions<Direction, Point, Strategy>
+{};
+
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+/*!
+\brief Less functor, to sort points in ascending order.
+\ingroup compare
+\details This functor compares points and orders them on x,
+    then on y, then on z coordinate.
+\tparam Geometry the geometry
+\tparam Dimension the dimension to sort on, defaults to -1,
+    indicating ALL dimensions. That's to say, first on x,
+    on equal x-es then on y, etc.
+    If a dimension is specified, only that dimension is considered
+\tparam Strategy underlying coordinate comparing functor,
+    defaults to the default comparison strategies
+    related to the point coordinate system. If specified, the specified
+    strategy is used. This can e.g. be std::less<double>.
+*/
+template
+<
+    typename Point,
+    int Dimension = -1,
+    typename Strategy = strategy::compare::default_strategy
+>
+struct less
+    : dispatch::compare_geometries
+        <
+            1, // indicates ascending
+            Point,
+            Strategy,
+            Dimension
+        >
+{
+    typedef Point first_argument_type;
+    typedef Point second_argument_type;
+    typedef bool result_type;
+};
+
+
+/*!
+\brief Greater functor
+\ingroup compare
+\details Can be used to sort points in reverse order
+\see Less functor
+*/
+template
+<
+    typename Point,
+    int Dimension = -1,
+    typename Strategy = strategy::compare::default_strategy
+>
+struct greater
+    : dispatch::compare_geometries
+        <
+            -1,  // indicates descending
+            Point,
+            Strategy,
+            Dimension
+        >
+{};
+
+
+/*!
+\brief Equal To functor, to compare if points are equal
+\ingroup compare
+\tparam Geometry the geometry
+\tparam Dimension the dimension to compare on, defaults to -1,
+    indicating ALL dimensions.
+    If a dimension is specified, only that dimension is considered
+\tparam Strategy underlying coordinate comparing functor
+*/
+template
+<
+    typename Point,
+    int Dimension = -1,
+    typename Strategy = strategy::compare::default_strategy
+>
+struct equal_to
+    : dispatch::compare_geometries
+        <
+            0,
+            Point,
+            Strategy,
+            Dimension
+        >
+{};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_POLICIES_COMPARE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/policies/disjoint_interrupt_policy.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/policies/disjoint_interrupt_policy.hpp
new file mode 100644
index 00000000000..2a6e54b0794
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/policies/disjoint_interrupt_policy.hpp
@@ -0,0 +1,67 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013-2014.
+// Modifications copyright (c) 2013-2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_POLICIES_DISJOINT_INTERRUPT_POLICY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_POLICIES_DISJOINT_INTERRUPT_POLICY_HPP
+
+#include <boost/range.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace disjoint
+{
+
+
+struct disjoint_interrupt_policy
+{
+    static bool const enabled = true;
+    bool has_intersections;
+
+    inline disjoint_interrupt_policy()
+        : has_intersections(false)
+    {}
+
+    template <typename Range>
+    inline bool apply(Range const& range)
+    {
+        // If there is any IP in the range, it is NOT disjoint
+        if (boost::size(range) > 0)
+        {
+            has_intersections = true;
+            return true;
+        }
+        return false;
+    }
+};
+
+
+
+}} // namespace detail::disjoint
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_POLICIES_DISJOINT_INTERRUPT_POLICY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/policies/is_valid/default_policy.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/policies/is_valid/default_policy.hpp
new file mode 100644
index 00000000000..c1bd347e11a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/policies/is_valid/default_policy.hpp
@@ -0,0 +1,59 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_POLICIES_IS_VALID_DEFAULT_POLICY_HPP
+#define BOOST_GEOMETRY_POLICIES_IS_VALID_DEFAULT_POLICY_HPP
+
+#include <boost/geometry/algorithms/validity_failure_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+template <bool AllowDuplicates = true, bool AllowSpikes = true>
+class is_valid_default_policy
+{
+protected:
+    static inline bool is_valid(validity_failure_type failure)
+    {
+        return failure == no_failure
+            || (AllowDuplicates && failure == failure_duplicate_points);
+    }
+
+    static inline bool is_valid(validity_failure_type failure, bool is_linear)
+    {
+        return is_valid(failure)
+            || (is_linear && AllowSpikes && failure == failure_spikes);
+    }
+
+public:
+    template <validity_failure_type Failure>
+    static inline bool apply()
+    {
+        return is_valid(Failure);
+    }
+
+    template <validity_failure_type Failure, typename Data>
+    static inline bool apply(Data const&)
+    {
+        return is_valid(Failure);
+    }
+
+    template <validity_failure_type Failure, typename Data1, typename Data2>
+    static inline bool apply(Data1 const& data1, Data2 const&)
+    {
+        return is_valid(Failure, data1);
+    }
+};
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_POLICIES_IS_VALID_DEFAULT_POLICY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/policies/is_valid/failing_reason_policy.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/policies/is_valid/failing_reason_policy.hpp
new file mode 100644
index 00000000000..bb28091d988
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/policies/is_valid/failing_reason_policy.hpp
@@ -0,0 +1,224 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_POLICIES_IS_VALID_FAILING_REASON_POLICY_HPP
+#define BOOST_GEOMETRY_POLICIES_IS_VALID_FAILING_REASON_POLICY_HPP
+
+#include <sstream>
+
+#include <boost/geometry/io/dsv/write.hpp>
+#include <boost/geometry/util/condition.hpp>
+#include <boost/geometry/util/range.hpp>
+#include <boost/geometry/algorithms/validity_failure_type.hpp>
+#include <boost/geometry/algorithms/detail/overlay/debug_turn_info.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+inline char const* validity_failure_type_message(validity_failure_type failure)
+{
+    switch (failure)
+    {
+    case no_failure:
+        return "Geometry is valid";
+    case failure_few_points:
+        return "Geometry has too few points";
+    case failure_wrong_topological_dimension:
+        return "Geometry has wrong topological dimension";
+    case failure_not_closed:
+        return "Geometry is defined as closed but is open";
+    case failure_spikes:
+        return "Geometry has spikes";
+    case failure_self_intersections:
+        return "Geometry has invalid self-intersections";
+    case failure_wrong_orientation:
+        return "Geometry has wrong orientation";
+    case failure_interior_rings_outside:
+        return "Geometry has interior rings defined outside the outer boundary";
+    case failure_nested_interior_rings:
+        return "Geometry has nested interior rings";
+    case failure_disconnected_interior:
+        return "Geometry has disconnected interior";
+    case failure_intersecting_interiors:
+        return "Multi-polygon has intersecting interiors";
+    case failure_duplicate_points:
+        return "Geometry has duplicate (consecutive) points";
+    case failure_wrong_corner_order:
+        return "Box has corners in wrong order";
+    case failure_invalid_coordinate:
+        return "Geometry has point(s) with invalid coordinate(s)";
+    default: // to avoid -Wreturn-type warning
+        return "";
+    }
+}
+
+
+template <bool AllowDuplicates = true, bool AllowSpikes = true>
+class failing_reason_policy
+{
+private:
+    static inline
+    validity_failure_type transform_failure_type(validity_failure_type failure)
+    {
+        if (BOOST_GEOMETRY_CONDITION(
+                AllowDuplicates && failure == failure_duplicate_points))
+        {
+            return no_failure;
+        }
+        return failure;
+    }
+
+    static inline
+    validity_failure_type transform_failure_type(validity_failure_type failure,
+                                                 bool is_linear)
+    {
+        if (BOOST_GEOMETRY_CONDITION(
+                is_linear && AllowSpikes && failure == failure_spikes))
+        {
+            return no_failure;
+        }
+        return transform_failure_type(failure);
+    }
+
+    inline void set_failure_message(validity_failure_type failure)
+    {
+        m_oss.str("");
+        m_oss.clear();
+        m_oss << validity_failure_type_message(failure);
+    }
+
+    template
+    <
+        validity_failure_type Failure,
+        typename Data1,
+        typename Data2 = Data1,
+        typename Dummy = void
+    >
+    struct process_data
+    {
+        static inline void apply(std::ostringstream&, Data1 const&)
+        {
+        }
+
+        static inline void apply(std::ostringstream&,
+                                 Data1 const&,
+                                 Data2 const&)
+        {
+        }
+    };
+
+    template <typename SpikePoint>
+    struct process_data<failure_spikes, bool, SpikePoint>
+    {
+        static inline void apply(std::ostringstream& oss,
+                                 bool is_linear,
+                                 SpikePoint const& spike_point)
+        {
+            if (BOOST_GEOMETRY_CONDITION(is_linear && AllowSpikes))
+            {
+                return;
+            }
+
+            oss << ". A spike point was found with apex at "
+                << geometry::dsv(spike_point);
+        }
+    };
+
+    template <typename Turns>
+    struct process_data<failure_self_intersections, Turns>
+    {
+        static inline
+        void apply_to_segment_identifier(std::ostringstream& oss,
+                                         segment_identifier seg_id)
+        {
+            oss << "{" << seg_id.source_index
+                << ", " << seg_id.multi_index
+                << ", " << seg_id.ring_index
+                << ", " << seg_id.segment_index
+                << "}";
+        }
+
+        static inline void apply(std::ostringstream& oss,
+                                 Turns const& turns)
+        {
+            typedef typename boost::range_value<Turns>::type turn_type;
+            turn_type const& turn = range::front(turns);
+            oss << ". A self-intersection point was found at "
+                << geometry::dsv(turn.point);
+
+            oss << "; method: " << method_char(turn.method)
+                << "; operations: "
+                << operation_char(turn.operations[0].operation)
+                << "/"
+                << operation_char(turn.operations[1].operation)
+                << "; segment IDs {source, multi, ring, segment}: ";
+            apply_to_segment_identifier(oss, turn.operations[0].seg_id);
+            oss << "/";
+            apply_to_segment_identifier(oss, turn.operations[1].seg_id);
+        }
+    };
+
+    template <typename Point>
+    struct process_data<failure_duplicate_points, Point>
+    {
+        static inline void apply(std::ostringstream& oss,
+                                 Point const& point)
+        {
+            if (BOOST_GEOMETRY_CONDITION(AllowDuplicates))
+            {
+                return;
+            }
+            oss << ". Duplicate points were found near point "
+                << geometry::dsv(point);
+        }
+    };
+
+public:
+    failing_reason_policy(std::ostringstream& oss)
+        : m_oss(oss)
+    {}
+
+    template <validity_failure_type Failure>
+    inline bool apply()
+    {
+        validity_failure_type const failure = transform_failure_type(Failure);
+        set_failure_message(failure);
+        return failure == no_failure;
+    }
+
+    template <validity_failure_type Failure, typename Data>
+    inline bool apply(Data const& data)
+    {
+        validity_failure_type const failure = transform_failure_type(Failure);
+        set_failure_message(failure);
+        process_data<Failure, Data>::apply(m_oss, data);
+        return failure == no_failure;
+    }
+
+    template <validity_failure_type Failure, typename Data1, typename Data2>
+    inline bool apply(Data1 const& data1, Data2 const& data2)
+    {
+        validity_failure_type const failure
+            = transform_failure_type(Failure, data1);
+        set_failure_message(failure);
+        process_data<Failure, Data1, Data2>::apply(m_oss, data1, data2);
+        return failure == no_failure;
+    }
+
+private:
+    std::ostringstream& m_oss;
+};
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_POLICIES_IS_VALID_FAILING_REASON_POLICY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/policies/is_valid/failure_type_policy.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/policies/is_valid/failure_type_policy.hpp
new file mode 100644
index 00000000000..9fb569e283f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/policies/is_valid/failure_type_policy.hpp
@@ -0,0 +1,83 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_POLICIES_IS_VALID_FAILURE_TYPE_POLICY_HPP
+#define BOOST_GEOMETRY_POLICIES_IS_VALID_FAILURE_TYPE_POLICY_HPP
+
+#include <boost/geometry/algorithms/validity_failure_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+// policy that simply keeps (and can return) the failure type
+template <bool AllowDuplicates = true, bool AllowSpikes = true>
+class failure_type_policy
+{
+private:
+    static inline
+    validity_failure_type transform_failure_type(validity_failure_type failure)
+    {
+        if (AllowDuplicates && failure == failure_duplicate_points)
+        {
+            return no_failure;
+        }
+        return failure;
+    }
+
+    static inline
+    validity_failure_type transform_failure_type(validity_failure_type failure,
+                                                 bool is_linear)
+    {
+        if (is_linear && AllowSpikes && failure == failure_spikes)
+        {
+            return no_failure;
+        }
+        return transform_failure_type(failure);
+    }
+
+public:
+    failure_type_policy()
+        : m_failure(no_failure)
+    {}
+
+    template <validity_failure_type Failure>
+    inline bool apply()
+    {
+        m_failure = transform_failure_type(Failure);
+        return m_failure == no_failure;
+    }
+
+    template <validity_failure_type Failure, typename Data>
+    inline bool apply(Data const&)
+    {
+        return apply<Failure>();
+    }
+
+    template <validity_failure_type Failure, typename Data1, typename Data2>
+    inline bool apply(Data1 const& data1, Data2 const&)
+    {
+        m_failure = transform_failure_type(Failure, data1);
+        return m_failure == no_failure;
+    }
+
+    validity_failure_type failure() const
+    {
+        return m_failure;
+    }
+
+private:
+    validity_failure_type m_failure;
+};
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_POLICIES_IS_VALID_FAILURE_TYPE_POLICY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/policies/predicate_based_interrupt_policy.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/policies/predicate_based_interrupt_policy.hpp
new file mode 100644
index 00000000000..0021b12dc62
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/policies/predicate_based_interrupt_policy.hpp
@@ -0,0 +1,101 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_ALGORITHMS_POLICIES_PREDICATE_BASED_INTERRUPT_POLICY_HPP
+#define BOOST_GEOMETRY_ALGORITHMS_POLICIES_PREDICATE_BASED_INTERRUPT_POLICY_HPP
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/algorithms/detail/check_iterator_range.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace overlay
+{
+
+
+template
+<
+    typename IsAcceptableTurnPredicate,
+    bool AllowEmptyTurnRange = true // by default, allow an empty turn range
+>
+struct stateless_predicate_based_interrupt_policy
+{
+    static bool const enabled = true;
+    bool has_intersections; // set to true if there is at least one
+                            // unacceptable turn
+
+    inline stateless_predicate_based_interrupt_policy()
+        : has_intersections(false)
+    {}
+
+    template <typename Range>
+    inline bool apply(Range const& range)
+    {
+        // if there is at least one unacceptable turn in the range, return false
+        has_intersections = !detail::check_iterator_range
+            <
+                IsAcceptableTurnPredicate,
+                AllowEmptyTurnRange
+            >::apply(boost::begin(range), boost::end(range));
+
+        return has_intersections;
+    }
+};
+
+
+
+
+template
+<
+    typename IsAcceptableTurnPredicate,
+    bool AllowEmptyTurnRange = true // by default, allow an empty turn range
+>
+struct predicate_based_interrupt_policy
+{
+    static bool const enabled = true;
+    bool has_intersections; // set to true if there is at least one
+                            // unacceptable turn
+    IsAcceptableTurnPredicate const& m_predicate;
+
+    inline
+    predicate_based_interrupt_policy(IsAcceptableTurnPredicate const& predicate)
+        : has_intersections(false)
+        , m_predicate(predicate)
+    {}
+
+    template <typename Range>
+    inline bool apply(Range const& range)
+    {
+        // if there is at least one unacceptable turn in the range, return false
+        has_intersections = !detail::check_iterator_range
+            <
+                IsAcceptableTurnPredicate,
+                AllowEmptyTurnRange
+            >::apply(boost::begin(range), boost::end(range), m_predicate);
+
+        return has_intersections;
+    }
+};
+
+
+
+
+}} // namespace detail::overlay
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_ALGORITHMS_POLICIES_PREDICATE_BASED_INTERRUPT_POLICY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/policies/relate/direction.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/policies/relate/direction.hpp
new file mode 100644
index 00000000000..2c903bd79f5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/policies/relate/direction.hpp
@@ -0,0 +1,391 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRY_POLICIES_RELATE_DIRECTION_HPP
+#define BOOST_GEOMETRY_GEOMETRY_POLICIES_RELATE_DIRECTION_HPP
+
+
+#include <cstddef>
+#include <string>
+
+#include <boost/concept_check.hpp>
+
+#include <boost/geometry/arithmetic/determinant.hpp>
+#include <boost/geometry/strategies/side_info.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/select_calculation_type.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace policies { namespace relate
+{
+
+struct direction_type
+{
+    // NOTE: "char" will be replaced by enum in future version
+
+    inline direction_type(side_info const& s, char h,
+                int ha, int hb,
+                int da = 0, int db = 0,
+                bool op = false)
+        : how(h)
+        , opposite(op)
+        , how_a(ha)
+        , how_b(hb)
+        , dir_a(da)
+        , dir_b(db)
+        , sides(s)
+    {
+        arrival[0] = ha;
+        arrival[1] = hb;
+    }
+
+    inline direction_type(char h, bool op, int ha = 0, int hb = 0)
+        : how(h)
+        , opposite(op)
+        , how_a(ha)
+        , how_b(hb)
+        , dir_a(0)
+        , dir_b(0)
+    {
+        arrival[0] = ha;
+        arrival[1] = hb;
+    }
+
+
+    // TODO: replace this
+    // NOTE: "char" will be replaced by enum in future version
+    // "How" is the intersection formed?
+    char how;
+
+    // Is it opposite (for collinear/equal cases)
+    bool opposite;
+
+    // Information on how A arrives at intersection, how B arrives at intersection
+    // 1: arrives at intersection
+    // -1: starts from intersection
+    int how_a;
+    int how_b;
+
+    // Direction: how is A positioned from B
+    // 1: points left, seen from IP
+    // -1: points right, seen from IP
+    // In case of intersection: B's TO direction
+    // In case that B's TO direction is at A: B's from direction
+    // In collinear cases: it is 0
+    int dir_a; // Direction of A-s TO from IP
+    int dir_b; // Direction of B-s TO from IP
+
+    // New information
+    side_info sides;
+    // THIS IS EQUAL TO arrival_a, arrival_b - they probably can go now we have robust fractions
+    int arrival[2]; // 1=arrival, -1=departure, 0=neutral; == how_a//how_b
+
+
+    // About arrival[0] (== arrival of a2 w.r.t. b) for COLLINEAR cases
+    // Arrival  1: a1--------->a2         (a arrives within b)
+    //                      b1----->b2
+
+    // Arrival  1: (a in b)
+    //
+
+
+    // Arrival -1:      a1--------->a2     (a does not arrive within b)
+    //             b1----->b2
+
+    // Arrival -1: (b in a)               a_1-------------a_2
+    //                                         b_1---b_2
+
+    // Arrival  0:                        a1------->a2  (a arrives at TO-border of b)
+    //                                        b1--->b2
+
+};
+
+struct segments_direction
+{
+    typedef direction_type return_type;
+
+    template
+    <
+        typename Segment1,
+        typename Segment2,
+        typename SegmentIntersectionInfo
+    >
+    static inline return_type segments_crosses(side_info const& sides,
+                    SegmentIntersectionInfo const& ,
+                    Segment1 const& , Segment2 const& )
+    {
+        bool const ra0 = sides.get<0,0>() == 0;
+        bool const ra1 = sides.get<0,1>() == 0;
+        bool const rb0 = sides.get<1,0>() == 0;
+        bool const rb1 = sides.get<1,1>() == 0;
+
+        return
+            // opposite and same starting point (FROM)
+            ra0 && rb0 ? calculate_side<1>(sides, 'f', -1, -1)
+
+            // opposite and point to each other (TO)
+            : ra1 && rb1 ? calculate_side<0>(sides, 't', 1, 1)
+
+            // not opposite, forming an angle, first a then b,
+            // directed either both left, or both right
+            // Check side of B2 from A. This is not calculated before
+            : ra1 && rb0 ? angle<1>(sides, 'a', 1, -1)
+
+            // not opposite, forming a angle, first b then a,
+            // directed either both left, or both right
+            : ra0 && rb1 ? angle<0>(sides, 'a', -1, 1)
+
+            // b starts from interior of a
+            : rb0 ? starts_from_middle(sides, 'B', 0, -1)
+
+            // a starts from interior of b (#39)
+            : ra0 ? starts_from_middle(sides, 'A', -1, 0)
+
+            // b ends at interior of a, calculate direction of A from IP
+            : rb1 ? b_ends_at_middle(sides)
+
+            // a ends at interior of b
+            : ra1 ? a_ends_at_middle(sides)
+
+            // normal intersection
+            : calculate_side<1>(sides, 'i', -1, -1)
+            ;
+    }
+
+    template <typename Ratio>
+    static inline int arrival_value(Ratio const& r_from, Ratio const& r_to)
+    {
+        //     a1--------->a2
+        // b1----->b2
+        // a departs: -1
+
+        // a1--------->a2
+        //         b1----->b2
+        // a arrives: 1
+
+        // a1--------->a2
+        //     b1----->b2
+        // both arrive there -> r-to = 1/1, or 0/1 (on_segment)
+
+        // First check the TO (for arrival), then FROM (for departure)
+        return r_to.in_segment() ? 1
+            : r_to.on_segment() ? 0
+            : r_from.on_segment() ? -1
+            : -1
+            ;
+    }
+
+    template <typename Ratio>
+    static inline void analyze(Ratio const& r,
+        int& in_segment_count,
+        int& on_end_count,
+        int& outside_segment_count)
+    {
+        if (r.on_end())
+        {
+            on_end_count++;
+        }
+        else if (r.in_segment())
+        {
+            in_segment_count++;
+        }
+        else
+        {
+            outside_segment_count++;
+        }
+    }
+
+    static inline int arrival_from_position_value(int /*v_from*/, int v_to)
+    {
+        return v_to == 2 ? 1
+             : v_to == 1 || v_to == 3 ? 0
+             //: v_from >= 1 && v_from <= 3 ? -1
+             : -1;
+
+        // NOTE: this should be an equivalent of the above for the other order
+        /* (v_from < 3 && v_to > 3) || (v_from > 3 && v_to < 3) ? 1
+         : v_from == 3 || v_to == 3 ? 0
+         : -1;*/
+    }
+
+    static inline void analyse_position_value(int pos_val,
+                                              int & in_segment_count,
+                                              int & on_end_count,
+                                              int & outside_segment_count)
+    {
+        if ( pos_val == 1 || pos_val == 3 )
+        {
+            on_end_count++;
+        }
+        else if ( pos_val == 2 )
+        {
+            in_segment_count++;
+        }
+        else
+        {
+            outside_segment_count++;
+        }
+    }
+
+    template <typename Segment1, typename Segment2, typename Ratio>
+    static inline return_type segments_collinear(
+        Segment1 const& , Segment2 const& , bool opposite,
+        int a1_wrt_b, int a2_wrt_b, int b1_wrt_a, int b2_wrt_a,
+        Ratio const& /*ra_from_wrt_b*/, Ratio const& /*ra_to_wrt_b*/,
+        Ratio const& /*rb_from_wrt_a*/, Ratio const& /*rb_to_wrt_a*/)
+    {
+        return_type r('c', opposite);
+
+        // IMPORTANT: the order of conditions is different as in intersection_points.hpp
+        // We assign A in 0 and B in 1
+        r.arrival[0] = arrival_from_position_value(a1_wrt_b, a2_wrt_b);
+        r.arrival[1] = arrival_from_position_value(b1_wrt_a, b2_wrt_a);
+
+        // Analyse them
+        int a_in_segment_count = 0;
+        int a_on_end_count = 0;
+        int a_outside_segment_count = 0;
+        int b_in_segment_count = 0;
+        int b_on_end_count = 0;
+        int b_outside_segment_count = 0;
+        analyse_position_value(a1_wrt_b,
+            a_in_segment_count, a_on_end_count, a_outside_segment_count);
+        analyse_position_value(a2_wrt_b,
+            a_in_segment_count, a_on_end_count, a_outside_segment_count);
+        analyse_position_value(b1_wrt_a,
+            b_in_segment_count, b_on_end_count, b_outside_segment_count);
+        analyse_position_value(b2_wrt_a,
+            b_in_segment_count, b_on_end_count, b_outside_segment_count);
+
+        if (a_on_end_count == 1
+            && b_on_end_count == 1
+            && a_outside_segment_count == 1
+            && b_outside_segment_count == 1)
+        {
+            // This is a collinear touch
+            // -------->             A (or B)
+            //         <----------   B (or A)
+            // We adapt the "how"
+            // TODO: how was to be refactored anyway,
+            if (! opposite)
+            {
+                r.how = 'a';
+            }
+            else
+            {
+                r.how = r.arrival[0] == 0 ? 't' : 'f';
+            }
+        }
+        else if (a_on_end_count == 2
+                 && b_on_end_count == 2)
+        {
+            r.how = 'e';
+        }
+
+        return r;
+    }
+
+    template <typename Segment>
+    static inline return_type degenerate(Segment const& , bool)
+    {
+        return return_type('0', false);
+    }
+
+    template <typename Segment, typename Ratio>
+    static inline return_type one_degenerate(Segment const& ,
+            Ratio const& ,
+            bool)
+    {
+        // To be decided
+        return return_type('0', false);
+    }
+
+    static inline return_type disjoint()
+    {
+        return return_type('d', false);
+    }
+
+    static inline return_type error(std::string const&)
+    {
+        // Return "E" to denote error
+        // This will throw an error in get_turn_info
+        // TODO: change to enum or similar
+        return return_type('E', false);
+    }
+
+private :
+
+    template <std::size_t I>
+    static inline return_type calculate_side(side_info const& sides,
+                char how, int how_a, int how_b)
+    {
+        int const dir = sides.get<1, I>() == 1 ? 1 : -1;
+        return return_type(sides, how, how_a, how_b, -dir, dir);
+    }
+
+    template <std::size_t I>
+    static inline return_type angle(side_info const& sides,
+                char how, int how_a, int how_b)
+    {
+        int const dir = sides.get<1, I>() == 1 ? 1 : -1;
+        return return_type(sides, how, how_a, how_b, dir, dir);
+    }
+
+
+    static inline return_type starts_from_middle(side_info const& sides,
+                char which,
+                int how_a, int how_b)
+    {
+        // Calculate ARROW of b segment w.r.t. s1
+        int dir = sides.get<1, 1>() == 1 ? 1 : -1;
+
+        // From other perspective, then reverse
+        bool const is_a = which == 'A';
+        if (is_a)
+        {
+            dir = -dir;
+        }
+
+        return return_type(sides, 's',
+            how_a,
+            how_b,
+            is_a ? dir : -dir,
+            ! is_a ? dir : -dir);
+    }
+
+
+
+    // To be harmonized
+    static inline return_type a_ends_at_middle(side_info const& sides)
+    {
+        // Ending at the middle, one ARRIVES, the other one is NEUTRAL
+        // (because it both "arrives"  and "departs" there)
+        int const dir = sides.get<1, 1>() == 1 ? 1 : -1;
+        return return_type(sides, 'm', 1, 0, dir, dir);
+    }
+
+
+    static inline return_type b_ends_at_middle(side_info const& sides)
+    {
+        int const dir = sides.get<0, 1>() == 1 ? 1 : -1;
+        return return_type(sides, 'm', 0, 1, dir, dir);
+    }
+
+};
+
+}} // namespace policies::relate
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRY_POLICIES_RELATE_DIRECTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/policies/relate/intersection_points.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/policies/relate/intersection_points.hpp
new file mode 100644
index 00000000000..2ca84ac028c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/policies/relate/intersection_points.hpp
@@ -0,0 +1,226 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2016.
+// Modifications copyright (c) 2016 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRY_POLICIES_RELATE_INTERSECTION_POINTS_HPP
+#define BOOST_GEOMETRY_GEOMETRY_POLICIES_RELATE_INTERSECTION_POINTS_HPP
+
+
+#include <algorithm>
+#include <string>
+
+#include <boost/geometry/algorithms/detail/assign_indexed_point.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/strategies/side_info.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace policies { namespace relate
+{
+
+
+/*!
+\brief Policy calculating the intersection points themselves
+ */
+template
+<
+    typename ReturnType
+>
+struct segments_intersection_points
+{
+    typedef ReturnType return_type;
+
+    template
+    <
+        typename Segment1,
+        typename Segment2,
+        typename SegmentIntersectionInfo
+    >
+    static inline return_type segments_crosses(side_info const&,
+                    SegmentIntersectionInfo const& sinfo,
+                    Segment1 const& s1, Segment2 const& s2)
+    {
+        return_type result;
+        result.count = 1;
+
+        bool use_a = true;
+
+        // Prefer one segment if one is on or near an endpoint
+        bool const a_near_end = sinfo.robust_ra.near_end();
+        bool const b_near_end = sinfo.robust_rb.near_end();
+        if (a_near_end && ! b_near_end)
+        {
+            use_a = true;
+        }
+        else if (b_near_end && ! a_near_end)
+        {
+            use_a = false;
+        }
+        else
+        {
+            // Prefer shorter segment
+            typedef typename SegmentIntersectionInfo::promoted_type ptype;
+            ptype const len_a = sinfo.comparable_length_a();
+            ptype const len_b = sinfo.comparable_length_b();
+            if (len_b < len_a)
+            {
+                use_a = false;
+            }
+            // else use_a is true but was already assigned like that
+        }
+
+        if (use_a)
+        {
+            sinfo.assign_a(result.intersections[0], s1, s2);
+        }
+        else
+        {
+            sinfo.assign_b(result.intersections[0], s1, s2);
+        }
+
+        result.fractions[0].assign(sinfo);
+
+        return result;
+    }
+
+    template <typename Segment1, typename Segment2, typename Ratio>
+    static inline return_type segments_collinear(
+        Segment1 const& a, Segment2 const& b, bool /*opposite*/,
+        int a1_wrt_b, int a2_wrt_b, int b1_wrt_a, int b2_wrt_a,
+        Ratio const& ra_from_wrt_b, Ratio const& ra_to_wrt_b,
+        Ratio const& rb_from_wrt_a, Ratio const& rb_to_wrt_a)
+    {
+        return_type result;
+        unsigned int index = 0, count_a = 0, count_b = 0;
+        Ratio on_a[2];
+
+        // The conditions "index < 2" are necessary for non-robust handling,
+        // if index would be 2 this indicate an (currently uncatched) error
+
+        // IMPORTANT: the order of conditions is different as in direction.hpp
+        if (a1_wrt_b >= 1 && a1_wrt_b <= 3 // ra_from_wrt_b.on_segment()
+            && index < 2)
+        {
+            //     a1--------->a2
+            // b1----->b2
+            //
+            // ra1 (relative to b) is between 0/1:
+            // -> First point of A is intersection point
+            detail::assign_point_from_index<0>(a, result.intersections[index]);
+            result.fractions[index].assign(Ratio::zero(), ra_from_wrt_b);
+            on_a[index] = Ratio::zero();
+            index++;
+            count_a++;
+        }
+        if (b1_wrt_a == 2 //rb_from_wrt_a.in_segment()
+            && index < 2)
+        {
+            // We take the first intersection point of B
+            // a1--------->a2
+            //         b1----->b2
+            // But only if it is not located on A
+            // a1--------->a2
+            // b1----->b2      rb_from_wrt_a == 0/1 -> a already taken
+
+            detail::assign_point_from_index<0>(b, result.intersections[index]);
+            result.fractions[index].assign(rb_from_wrt_a, Ratio::zero());
+            on_a[index] = rb_from_wrt_a;
+            index++;
+            count_b++;
+        }
+
+        if (a2_wrt_b >= 1 && a2_wrt_b <= 3 //ra_to_wrt_b.on_segment()
+            && index < 2)
+        {
+            // Similarly, second IP (here a2)
+            // a1--------->a2
+            //         b1----->b2
+            detail::assign_point_from_index<1>(a, result.intersections[index]);
+            result.fractions[index].assign(Ratio::one(), ra_to_wrt_b);
+            on_a[index] = Ratio::one();
+            index++;
+            count_a++;
+        }
+        if (b2_wrt_a == 2 // rb_to_wrt_a.in_segment()
+            && index < 2)
+        {
+            detail::assign_point_from_index<1>(b, result.intersections[index]);
+            result.fractions[index].assign(rb_to_wrt_a, Ratio::one());
+            on_a[index] = rb_to_wrt_a;
+            index++;
+            count_b++;
+        }
+
+        // TEMPORARY
+        // If both are from b, and b is reversed w.r.t. a, we swap IP's
+        // to align them w.r.t. a
+        // get_turn_info still relies on some order (in some collinear cases)
+        if (index == 2 && on_a[1] < on_a[0])
+        {
+            std::swap(result.fractions[0], result.fractions[1]);
+            std::swap(result.intersections[0], result.intersections[1]);
+        }
+
+        result.count = index;
+
+        return result;
+    }
+
+    static inline return_type disjoint()
+    {
+        return return_type();
+    }
+    static inline return_type error(std::string const&)
+    {
+        return return_type();
+    }
+
+    // Both degenerate
+    template <typename Segment>
+    static inline return_type degenerate(Segment const& segment, bool)
+    {
+        return_type result;
+        result.count = 1;
+        set<0>(result.intersections[0], get<0, 0>(segment));
+        set<1>(result.intersections[0], get<0, 1>(segment));
+        return result;
+    }
+
+    // One degenerate
+    template <typename Segment, typename Ratio>
+    static inline return_type one_degenerate(Segment const& degenerate_segment,
+            Ratio const& ratio, bool a_degenerate)
+    {
+        return_type result;
+        result.count = 1;
+        set<0>(result.intersections[0], get<0, 0>(degenerate_segment));
+        set<1>(result.intersections[0], get<0, 1>(degenerate_segment));
+        if (a_degenerate)
+        {
+            // IP lies on ratio w.r.t. segment b
+            result.fractions[0].assign(Ratio::zero(), ratio);
+        }
+        else
+        {
+            result.fractions[0].assign(ratio, Ratio::zero());
+        }
+        return result;
+    }
+};
+
+
+}} // namespace policies::relate
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRY_POLICIES_RELATE_INTERSECTION_POINTS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/policies/relate/intersection_ratios.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/policies/relate/intersection_ratios.hpp
new file mode 100644
index 00000000000..81ecba0b54c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/policies/relate/intersection_ratios.hpp
@@ -0,0 +1,127 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRY_POLICIES_RELATE_INTERSECTION_RATIOS_HPP
+#define BOOST_GEOMETRY_GEOMETRY_POLICIES_RELATE_INTERSECTION_RATIOS_HPP
+
+
+#include <algorithm>
+#include <string>
+
+#include <boost/concept_check.hpp>
+#include <boost/numeric/conversion/cast.hpp>
+
+#include <boost/geometry/algorithms/detail/assign_indexed_point.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/strategies/side_info.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace policies { namespace relate
+{
+
+
+/*!
+\brief Policy returning segment ratios
+\note Template argument FractionType should be a fraction_type<SegmentRatio>
+ */
+template
+<
+    typename FractionType
+>
+struct segments_intersection_ratios
+{
+    typedef FractionType return_type;
+
+    template
+    <
+        typename Segment1,
+        typename Segment2,
+        typename SegmentIntersectionInfo
+    >
+    static inline return_type segments_crosses(side_info const&,
+                    SegmentIntersectionInfo const& sinfo,
+                    Segment1 const& , Segment2 const& )
+    {
+        return_type result;
+        result.assign(sinfo);
+        return result;
+    }
+
+    template <typename Segment1, typename Segment2, typename Ratio>
+    static inline return_type segments_collinear(
+        Segment1 const& , Segment2 const& ,
+        Ratio const& ra_from_wrt_b, Ratio const& ra_to_wrt_b,
+        Ratio const& rb_from_wrt_a, Ratio const& rb_to_wrt_a)
+    {
+        // We have only one result, for (potentially) two IP's,
+        // so we take a first one
+        return_type result;
+
+        if (ra_from_wrt_b.on_segment())
+        {
+            result.assign(Ratio::zero(), ra_from_wrt_b);
+        }
+        else if (rb_from_wrt_a.in_segment())
+        {
+            result.assign(rb_from_wrt_a, Ratio::zero());
+        }
+        else if (ra_to_wrt_b.on_segment())
+        {
+            result.assign(Ratio::one(), ra_to_wrt_b);
+        }
+        else if (rb_to_wrt_a.in_segment())
+        {
+            result.assign(rb_to_wrt_a, Ratio::one());
+        }
+
+        return result;
+    }
+
+    static inline return_type disjoint()
+    {
+        return return_type();
+    }
+    static inline return_type error(std::string const&)
+    {
+        return return_type();
+    }
+
+    template <typename Segment>
+    static inline return_type degenerate(Segment const& segment, bool)
+    {
+        return return_type();
+    }
+
+    template <typename Segment, typename Ratio>
+    static inline return_type one_degenerate(Segment const& ,
+            Ratio const& ratio, bool a_degenerate)
+    {
+        return_type result;
+        if (a_degenerate)
+        {
+            // IP lies on ratio w.r.t. segment b
+            result.assign(Ratio::zero(), ratio);
+        }
+        else
+        {
+            result.assign(ratio, Ratio::zero());
+        }
+        return result;
+    }
+
+};
+
+
+}} // namespace policies::relate
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRY_POLICIES_RELATE_INTERSECTION_RATIOS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/policies/relate/tupled.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/policies/relate/tupled.hpp
new file mode 100644
index 00000000000..4b65432f20e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/policies/relate/tupled.hpp
@@ -0,0 +1,116 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_GEOMETRY_POLICIES_RELATE_TUPLED_HPP
+#define BOOST_GEOMETRY_GEOMETRY_POLICIES_RELATE_TUPLED_HPP
+
+
+#include <string>
+
+#include <boost/tuple/tuple.hpp>
+#include <boost/geometry/strategies/side_info.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace policies { namespace relate
+{
+
+
+// "tupled" to return intersection results together.
+// Now with two, with some meta-programming and derivations it can also be three (or more)
+template <typename Policy1, typename Policy2>
+struct segments_tupled
+{
+    typedef boost::tuple
+        <
+            typename Policy1::return_type,
+            typename Policy2::return_type
+        > return_type;
+
+    template <typename Segment1, typename Segment2, typename SegmentIntersectionInfo>
+    static inline return_type segments_crosses(side_info const& sides,
+                    SegmentIntersectionInfo const& sinfo,
+                    Segment1 const& s1, Segment2 const& s2)
+    {
+        return boost::make_tuple
+            (
+                Policy1::segments_crosses(sides, sinfo, s1, s2),
+                Policy2::segments_crosses(sides, sinfo, s1, s2)
+            );
+    }
+
+    template <typename Segment1, typename Segment2, typename Ratio>
+    static inline return_type segments_collinear(
+                    Segment1 const& segment1, Segment2 const& segment2,
+                    bool opposite,
+                    int pa1, int pa2, int pb1, int pb2,
+                    Ratio const& ra1, Ratio const& ra2,
+                    Ratio const& rb1, Ratio const& rb2)
+    {
+        return boost::make_tuple
+            (
+                Policy1::segments_collinear(segment1, segment2,
+                                            opposite,
+                                            pa1, pa2, pb1, pb2,
+                                            ra1, ra2, rb1, rb2),
+                Policy2::segments_collinear(segment1, segment2,
+                                            opposite,
+                                            pa1, pa2, pb1, pb2,
+                                            ra1, ra2, rb1, rb2)
+            );
+    }
+
+    template <typename Segment>
+    static inline return_type degenerate(Segment const& segment,
+                bool a_degenerate)
+    {
+        return boost::make_tuple
+            (
+                Policy1::degenerate(segment, a_degenerate),
+                Policy2::degenerate(segment, a_degenerate)
+            );
+    }
+
+    template <typename Segment, typename Ratio>
+    static inline return_type one_degenerate(Segment const& segment,
+            Ratio const& ratio,
+            bool a_degenerate)
+    {
+        return boost::make_tuple
+            (
+                Policy1::one_degenerate(segment, ratio, a_degenerate),
+                Policy2::one_degenerate(segment, ratio, a_degenerate)
+            );
+    }
+
+    static inline return_type disjoint()
+    {
+        return boost::make_tuple
+            (
+                Policy1::disjoint(),
+                Policy2::disjoint()
+            );
+    }
+
+    static inline return_type error(std::string const& msg)
+    {
+        return boost::make_tuple
+            (
+                Policy1::error(msg),
+                Policy2::error(msg)
+            );
+    }
+
+};
+
+}} // namespace policies::relate
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_GEOMETRY_POLICIES_RELATE_TUPLED_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/get_rescale_policy.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/get_rescale_policy.hpp
new file mode 100644
index 00000000000..daf32d3057b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/get_rescale_policy.hpp
@@ -0,0 +1,341 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2014-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2014-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_POLICIES_ROBUSTNESS_GET_RESCALE_POLICY_HPP
+#define BOOST_GEOMETRY_POLICIES_ROBUSTNESS_GET_RESCALE_POLICY_HPP
+
+
+#include <cstddef>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_floating_point.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+
+#include <boost/geometry/algorithms/envelope.hpp>
+#include <boost/geometry/algorithms/expand.hpp>
+#include <boost/geometry/algorithms/is_empty.hpp>
+#include <boost/geometry/algorithms/detail/recalculate.hpp>
+#include <boost/geometry/algorithms/detail/get_max_size.hpp>
+#include <boost/geometry/policies/robustness/robust_type.hpp>
+
+#include <boost/geometry/geometries/point.hpp>
+#include <boost/geometry/geometries/box.hpp>
+
+#include <boost/geometry/policies/robustness/no_rescale_policy.hpp>
+#include <boost/geometry/policies/robustness/rescale_policy.hpp>
+
+#include <boost/geometry/util/promote_floating_point.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace get_rescale_policy
+{
+
+template
+<
+    typename Box,
+    typename Point,
+    typename RobustPoint,
+    typename Factor
+>
+inline void scale_box_to_integer_range(Box const& box,
+                                       Point& min_point,
+                                       RobustPoint& min_robust_point,
+                                       Factor& factor)
+{
+    // Scale box to integer-range
+    typedef typename promote_floating_point
+        <
+            typename geometry::coordinate_type<Point>::type
+        >::type num_type;
+    num_type const diff = boost::numeric_cast<num_type>(detail::get_max_size(box));
+    num_type const range = 10000000.0; // Define a large range to get precise integer coordinates
+    num_type const half = 0.5;
+    if (math::equals(diff, num_type())
+        || diff >= range
+        || ! boost::math::isfinite(diff))
+    {
+        factor = 1;
+    }
+    else
+    {
+        factor = boost::numeric_cast<num_type>(
+            boost::numeric_cast<boost::long_long_type>(half + range / diff));
+        BOOST_GEOMETRY_ASSERT(factor >= 1);
+    }
+
+    // Assign input/output minimal points
+    detail::assign_point_from_index<0>(box, min_point);
+    num_type const two = 2;
+    boost::long_long_type const min_coordinate
+        = boost::numeric_cast<boost::long_long_type>(-range / two);
+    assign_values(min_robust_point, min_coordinate, min_coordinate);
+}
+
+template <typename Point, typename RobustPoint, typename Geometry, typename Factor>
+static inline void init_rescale_policy(Geometry const& geometry,
+        Point& min_point,
+        RobustPoint& min_robust_point,
+        Factor& factor)
+{
+    if (geometry::is_empty(geometry))
+    {
+        return;
+    }
+
+    // Get bounding boxes
+    model::box<Point> env = geometry::return_envelope<model::box<Point> >(geometry);
+
+    scale_box_to_integer_range(env, min_point, min_robust_point, factor);
+}
+
+template <typename Point, typename RobustPoint, typename Geometry1, typename Geometry2, typename Factor>
+static inline void init_rescale_policy(Geometry1 const& geometry1,
+        Geometry2 const& geometry2,
+        Point& min_point,
+        RobustPoint& min_robust_point,
+        Factor& factor)
+{
+    // Get bounding boxes (when at least one of the geometries is not empty)
+    bool const is_empty1 = geometry::is_empty(geometry1);
+    bool const is_empty2 = geometry::is_empty(geometry2);
+    if (is_empty1 && is_empty2)
+    {
+        return;
+    }
+
+    model::box<Point> env;
+    if (is_empty1)
+    {
+        geometry::envelope(geometry2, env);
+    }
+    else if (is_empty2)
+    {
+        geometry::envelope(geometry1, env);
+    }
+    else
+    {
+        // The following approach (envelope + expand) may not give the
+        // optimal MBR when then two geometries are in the spherical
+        // equatorial or geographic coordinate systems.
+        // TODO: implement envelope for two (or possibly more geometries)
+        geometry::envelope(geometry1, env);
+        model::box<Point> env2 = geometry::return_envelope
+            <
+                model::box<Point>
+            >(geometry2);
+        geometry::expand(env, env2);
+    }
+
+    scale_box_to_integer_range(env, min_point, min_robust_point, factor);
+}
+
+
+template
+<
+    typename Point,
+    bool IsFloatingPoint
+>
+struct rescale_policy_type
+{
+    typedef no_rescale_policy type;
+};
+
+// We rescale only all FP types
+template
+<
+    typename Point
+>
+struct rescale_policy_type<Point, true>
+{
+    typedef typename geometry::coordinate_type<Point>::type coordinate_type;
+    typedef model::point
+    <
+        typename detail::robust_type<coordinate_type>::type,
+        geometry::dimension<Point>::value,
+        typename geometry::coordinate_system<Point>::type
+    > robust_point_type;
+    typedef typename promote_floating_point<coordinate_type>::type factor_type;
+    typedef detail::robust_policy<Point, robust_point_type, factor_type> type;
+};
+
+template <typename Policy>
+struct get_rescale_policy
+{
+    template <typename Geometry>
+    static inline Policy apply(Geometry const& geometry)
+    {
+        typedef typename point_type<Geometry>::type point_type;
+        typedef typename geometry::coordinate_type<Geometry>::type coordinate_type;
+        typedef typename promote_floating_point<coordinate_type>::type factor_type;
+        typedef model::point
+        <
+            typename detail::robust_type<coordinate_type>::type,
+            geometry::dimension<point_type>::value,
+            typename geometry::coordinate_system<point_type>::type
+        > robust_point_type;
+
+        point_type min_point;
+        robust_point_type min_robust_point;
+        factor_type factor;
+        init_rescale_policy(geometry, min_point, min_robust_point, factor);
+
+        return Policy(min_point, min_robust_point, factor);
+    }
+
+    template <typename Geometry1, typename Geometry2>
+    static inline Policy apply(Geometry1 const& geometry1, Geometry2 const& geometry2)
+    {
+        typedef typename point_type<Geometry1>::type point_type;
+        typedef typename geometry::coordinate_type<Geometry1>::type coordinate_type;
+        typedef typename promote_floating_point<coordinate_type>::type factor_type;
+        typedef model::point
+        <
+            typename detail::robust_type<coordinate_type>::type,
+            geometry::dimension<point_type>::value,
+            typename geometry::coordinate_system<point_type>::type
+        > robust_point_type;
+
+        point_type min_point;
+        robust_point_type min_robust_point;
+        factor_type factor;
+        init_rescale_policy(geometry1, geometry2, min_point, min_robust_point, factor);
+
+        return Policy(min_point, min_robust_point, factor);
+    }
+};
+
+// Specialization for no-rescaling
+template <>
+struct get_rescale_policy<no_rescale_policy>
+{
+    template <typename Geometry>
+    static inline no_rescale_policy apply(Geometry const& )
+    {
+        return no_rescale_policy();
+    }
+
+    template <typename Geometry1, typename Geometry2>
+    static inline no_rescale_policy apply(Geometry1 const& , Geometry2 const& )
+    {
+        return no_rescale_policy();
+    }
+};
+
+
+}} // namespace detail::get_rescale_policy
+#endif // DOXYGEN_NO_DETAIL
+
+template<typename Point>
+struct rescale_policy_type
+    : public detail::get_rescale_policy::rescale_policy_type
+    <
+        Point,
+#if defined(BOOST_GEOMETRY_NO_ROBUSTNESS)
+        false
+#else
+        boost::is_floating_point
+            <
+                typename geometry::coordinate_type<Point>::type
+            >::type::value
+        &&
+        boost::is_same
+            <
+                typename geometry::coordinate_system<Point>::type,
+                geometry::cs::cartesian
+            >::value
+#endif
+    >
+{
+    static const bool is_point
+        = boost::is_same
+            <
+                typename geometry::tag<Point>::type,
+                geometry::point_tag
+            >::type::value;
+
+    BOOST_MPL_ASSERT_MSG((is_point),
+                         INVALID_INPUT_GEOMETRY,
+                         (typename geometry::tag<Point>::type));
+};
+
+
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename Tag1 = typename tag_cast
+    <
+        typename tag<Geometry1>::type,
+        box_tag,
+        pointlike_tag,
+        linear_tag,
+        areal_tag
+    >::type,
+    typename Tag2 = typename tag_cast
+    <
+        typename tag<Geometry2>::type,
+        box_tag,
+        pointlike_tag,
+        linear_tag,
+        areal_tag
+    >::type
+>
+struct rescale_overlay_policy_type
+    // Default: no rescaling
+    : public detail::get_rescale_policy::rescale_policy_type
+        <
+            typename geometry::point_type<Geometry1>::type,
+            false
+        >
+{};
+
+// Areal/areal: get rescale policy based on coordinate type
+template
+<
+    typename Geometry1,
+    typename Geometry2
+>
+struct rescale_overlay_policy_type<Geometry1, Geometry2, areal_tag, areal_tag>
+    : public rescale_policy_type
+        <
+            typename geometry::point_type<Geometry1>::type
+        >
+{};
+
+
+template <typename Policy, typename Geometry>
+inline Policy get_rescale_policy(Geometry const& geometry)
+{
+    return detail::get_rescale_policy::get_rescale_policy<Policy>::apply(geometry);
+}
+
+template <typename Policy, typename Geometry1, typename Geometry2>
+inline Policy get_rescale_policy(Geometry1 const& geometry1, Geometry2 const& geometry2)
+{
+    return detail::get_rescale_policy::get_rescale_policy<Policy>::apply(geometry1, geometry2);
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_POLICIES_ROBUSTNESS_GET_RESCALE_POLICY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/no_rescale_policy.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/no_rescale_policy.hpp
new file mode 100644
index 00000000000..a7899842c10
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/no_rescale_policy.hpp
@@ -0,0 +1,66 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2013 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2013 Bruno Lalande, Paris, France.
+// Copyright (c) 2013 Mateusz Loskot, London, UK.
+// Copyright (c) 2013 Adam Wulkiewicz, Lodz, Poland.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_POLICIES_ROBUSTNESS_NO_RESCALE_POLICY_HPP
+#define BOOST_GEOMETRY_POLICIES_ROBUSTNESS_NO_RESCALE_POLICY_HPP
+
+#include <stddef.h>
+
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/policies/robustness/robust_point_type.hpp>
+#include <boost/geometry/policies/robustness/segment_ratio.hpp>
+#include <boost/geometry/policies/robustness/segment_ratio_type.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+// Probably this will be moved out of namespace detail
+struct no_rescale_policy
+{
+    static bool const enabled = false;
+
+    // We don't rescale but return the reference of the input
+    template <std::size_t Dimension, typename Value>
+    inline Value const& apply(Value const& value) const
+    {
+        return value;
+    }
+};
+
+} // namespace detail
+#endif
+
+
+// Implement meta-functions for this policy
+template <typename Point>
+struct robust_point_type<Point, detail::no_rescale_policy>
+{
+    // The point itself
+    typedef Point type;
+};
+
+template <typename Point>
+struct segment_ratio_type<Point, detail::no_rescale_policy>
+{
+    // Define a segment_ratio defined on coordinate type, e.g.
+    // int/int or float/float
+    typedef typename geometry::coordinate_type<Point>::type coordinate_type;
+    typedef segment_ratio<coordinate_type> type;
+};
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_POLICIES_ROBUSTNESS_NO_RESCALE_POLICY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/rescale_policy.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/rescale_policy.hpp
new file mode 100644
index 00000000000..b92f6e1ec7a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/rescale_policy.hpp
@@ -0,0 +1,88 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2014-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2014-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Adam Wulkiewicz, Lodz, Poland.
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_POLICIES_ROBUSTNESS_RESCALE_POLICY_HPP
+#define BOOST_GEOMETRY_POLICIES_ROBUSTNESS_RESCALE_POLICY_HPP
+
+#include <cstddef>
+
+#include <boost/geometry/policies/robustness/segment_ratio.hpp>
+#include <boost/geometry/policies/robustness/segment_ratio_type.hpp>
+#include <boost/geometry/policies/robustness/robust_point_type.hpp>
+
+#include <boost/geometry/util/math.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <typename FpPoint, typename IntPoint, typename CalculationType>
+struct robust_policy
+{
+    static bool const enabled = true;
+
+    typedef typename geometry::coordinate_type<IntPoint>::type output_ct;
+
+    robust_policy(FpPoint const& fp_min, IntPoint const& int_min, CalculationType const& the_factor)
+        : m_fp_min(fp_min)
+        , m_int_min(int_min)
+        , m_multiplier(the_factor)
+    {
+    }
+
+    template <std::size_t Dimension, typename Value>
+    inline output_ct apply(Value const& value) const
+    {
+        // a + (v-b)*f
+        CalculationType const a = static_cast<CalculationType>(get<Dimension>(m_int_min));
+        CalculationType const b = static_cast<CalculationType>(get<Dimension>(m_fp_min));
+        CalculationType const result = a + (value - b) * m_multiplier;
+
+        return geometry::math::rounding_cast<output_ct>(result);
+    }
+
+    FpPoint m_fp_min;
+    IntPoint m_int_min;
+    CalculationType m_multiplier;
+};
+
+} // namespace detail
+#endif
+
+
+// Implement meta-functions for this policy
+
+// Define the IntPoint as a robust-point type
+template <typename Point, typename FpPoint, typename IntPoint, typename CalculationType>
+struct robust_point_type<Point, detail::robust_policy<FpPoint, IntPoint, CalculationType> >
+{
+    typedef IntPoint type;
+};
+
+// Meta function for rescaling, if rescaling is done segment_ratio is based on long long
+template <typename Point, typename FpPoint, typename IntPoint, typename CalculationType>
+struct segment_ratio_type<Point, detail::robust_policy<FpPoint, IntPoint, CalculationType> >
+{
+    typedef segment_ratio<boost::long_long_type> type;
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_POLICIES_ROBUSTNESS_RESCALE_POLICY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/robust_point_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/robust_point_type.hpp
new file mode 100644
index 00000000000..25639227f00
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/robust_point_type.hpp
@@ -0,0 +1,30 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2013 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2013 Bruno Lalande, Paris, France.
+// Copyright (c) 2013 Mateusz Loskot, London, UK.
+// Copyright (c) 2013 Adam Wulkiewicz, Lodz, Poland.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_POLICIES_ROBUSTNESS_ROBUST_POINT_TYPE_HPP
+#define BOOST_GEOMETRY_POLICIES_ROBUSTNESS_ROBUST_POINT_TYPE_HPP
+
+namespace boost { namespace geometry
+{
+
+// Meta-function to typedef a robust point type for a policy
+template <typename Point, typename Policy>
+struct robust_point_type
+{
+    // By default, the point itself is the robust type
+    typedef Point type;
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_POLICIES_ROBUSTNESS_ROBUST_POINT_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/robust_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/robust_type.hpp
new file mode 100644
index 00000000000..7342f905bf0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/robust_type.hpp
@@ -0,0 +1,67 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_POLICIES_ROBUSTNESS_ROBUST_TYPE_HPP
+#define BOOST_GEOMETRY_POLICIES_ROBUSTNESS_ROBUST_TYPE_HPP
+
+
+#include <boost/config.hpp>
+#include <boost/type_traits/is_floating_point.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+
+namespace detail_dispatch
+{
+
+template <typename CoordinateType, typename IsFloatingPoint>
+struct robust_type
+{
+};
+
+template <typename CoordinateType>
+struct robust_type<CoordinateType, boost::false_type>
+{
+    typedef CoordinateType type;
+};
+
+template <typename CoordinateType>
+struct robust_type<CoordinateType, boost::true_type>
+{
+    typedef boost::long_long_type type;
+};
+
+} // namespace detail_dispatch
+
+namespace detail
+{
+
+template <typename CoordinateType>
+struct robust_type
+{
+    typedef typename detail_dispatch::robust_type
+        <
+            CoordinateType,
+            typename boost::is_floating_point<CoordinateType>::type
+        >::type type;
+};
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_POLICIES_ROBUSTNESS_ROBUST_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/segment_ratio.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/segment_ratio.hpp
new file mode 100644
index 00000000000..9b313fdfaf2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/segment_ratio.hpp
@@ -0,0 +1,267 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2013 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2016.
+// Modifications copyright (c) 2016 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_POLICIES_ROBUSTNESS_SEGMENT_RATIO_HPP
+#define BOOST_GEOMETRY_POLICIES_ROBUSTNESS_SEGMENT_RATIO_HPP
+
+#include <boost/config.hpp>
+#include <boost/rational.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/promote_floating_point.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+namespace detail { namespace segment_ratio
+{
+
+template
+<
+    typename Type,
+    bool IsIntegral = boost::is_integral<Type>::type::value
+>
+struct less {};
+
+template <typename Type>
+struct less<Type, true>
+{
+    template <typename Ratio>
+    static inline bool apply(Ratio const& lhs, Ratio const& rhs)
+    {
+        return boost::rational<Type>(lhs.numerator(), lhs.denominator())
+             < boost::rational<Type>(rhs.numerator(), rhs.denominator());
+    }
+};
+
+template <typename Type>
+struct less<Type, false>
+{
+    template <typename Ratio>
+    static inline bool apply(Ratio const& lhs, Ratio const& rhs)
+    {
+        BOOST_GEOMETRY_ASSERT(lhs.denominator() != 0);
+        BOOST_GEOMETRY_ASSERT(rhs.denominator() != 0);
+        return lhs.numerator() * rhs.denominator()
+             < rhs.numerator() * lhs.denominator();
+    }
+};
+
+template
+<
+    typename Type,
+    bool IsIntegral = boost::is_integral<Type>::type::value
+>
+struct equal {};
+
+template <typename Type>
+struct equal<Type, true>
+{
+    template <typename Ratio>
+    static inline bool apply(Ratio const& lhs, Ratio const& rhs)
+    {
+        return boost::rational<Type>(lhs.numerator(), lhs.denominator())
+            == boost::rational<Type>(rhs.numerator(), rhs.denominator());
+    }
+};
+
+template <typename Type>
+struct equal<Type, false>
+{
+    template <typename Ratio>
+    static inline bool apply(Ratio const& lhs, Ratio const& rhs)
+    {
+        BOOST_GEOMETRY_ASSERT(lhs.denominator() != 0);
+        BOOST_GEOMETRY_ASSERT(rhs.denominator() != 0);
+        return geometry::math::equals
+            (
+                lhs.numerator() * rhs.denominator(),
+                rhs.numerator() * lhs.denominator()
+            );
+    }
+};
+
+}}
+
+//! Small class to keep a ratio (e.g. 1/4)
+//! Main purpose is intersections and checking on 0, 1, and smaller/larger
+//! The prototype used Boost.Rational. However, we also want to store FP ratios,
+//! (so numerator/denominator both in float)
+//! and Boost.Rational starts with GCD which we prefer to avoid if not necessary
+//! On a segment means: this ratio is between 0 and 1 (both inclusive)
+//!
+template <typename Type>
+class segment_ratio
+{
+public :
+    typedef Type numeric_type;
+
+    // Type-alias for the type itself
+    typedef segment_ratio<Type> thistype;
+
+    inline segment_ratio()
+        : m_numerator(0)
+        , m_denominator(1)
+        , m_approximation(0)
+    {}
+
+    inline segment_ratio(const Type& nominator, const Type& denominator)
+        : m_numerator(nominator)
+        , m_denominator(denominator)
+    {
+        initialize();
+    }
+
+    inline Type const& numerator() const { return m_numerator; }
+    inline Type const& denominator() const { return m_denominator; }
+
+    inline void assign(const Type& nominator, const Type& denominator)
+    {
+        m_numerator = nominator;
+        m_denominator = denominator;
+        initialize();
+    }
+
+    inline void initialize()
+    {
+        // Minimal normalization
+        // 1/-4 => -1/4, -1/-4 => 1/4
+        if (m_denominator < 0)
+        {
+            m_numerator = -m_numerator;
+            m_denominator = -m_denominator;
+        }
+
+        m_approximation =
+            m_denominator == 0 ? 0
+            : (
+                boost::numeric_cast<fp_type>(m_numerator) * scale()
+                / boost::numeric_cast<fp_type>(m_denominator)
+            );
+    }
+
+    inline bool is_zero() const { return math::equals(m_numerator, 0); }
+    inline bool is_one() const { return math::equals(m_numerator, m_denominator); }
+    inline bool on_segment() const
+    {
+        // e.g. 0/4 or 4/4 or 2/4
+        return m_numerator >= 0 && m_numerator <= m_denominator;
+    }
+    inline bool in_segment() const
+    {
+        // e.g. 1/4
+        return m_numerator > 0 && m_numerator < m_denominator;
+    }
+    inline bool on_end() const
+    {
+        // e.g. 0/4 or 4/4
+        return is_zero() || is_one();
+    }
+    inline bool left() const
+    {
+        // e.g. -1/4
+        return m_numerator < 0;
+    }
+    inline bool right() const
+    {
+        // e.g. 5/4
+        return m_numerator > m_denominator;
+    }
+
+    inline bool near_end() const
+    {
+        if (left() || right())
+        {
+            return false;
+        }
+
+        static fp_type const small_part_of_scale = scale() / 100;
+        return m_approximation < small_part_of_scale
+            || m_approximation > scale() - small_part_of_scale;
+    }
+
+    inline bool close_to(thistype const& other) const
+    {
+        return geometry::math::abs(m_approximation - other.m_approximation) < 50;
+    }
+
+    inline bool operator< (thistype const& other) const
+    {
+        return close_to(other)
+            ? detail::segment_ratio::less<Type>::apply(*this, other)
+            : m_approximation < other.m_approximation;
+    }
+
+    inline bool operator== (thistype const& other) const
+    {
+        return close_to(other)
+            && detail::segment_ratio::equal<Type>::apply(*this, other);
+    }
+
+    static inline thistype zero()
+    {
+        static thistype result(0, 1);
+        return result;
+    }
+
+    static inline thistype one()
+    {
+        static thistype result(1, 1);
+        return result;
+    }
+
+#if defined(BOOST_GEOMETRY_DEFINE_STREAM_OPERATOR_SEGMENT_RATIO)
+    friend std::ostream& operator<<(std::ostream &os, segment_ratio const& ratio)
+    {
+        os << ratio.m_numerator << "/" << ratio.m_denominator
+           << " (" << (static_cast<double>(ratio.m_numerator)
+                        / static_cast<double>(ratio.m_denominator))
+           << ")";
+        return os;
+    }
+#endif
+
+
+
+private :
+    // NOTE: if this typedef is used then fp_type is non-fundamental type
+    // if Type is non-fundamental type
+    //typedef typename promote_floating_point<Type>::type fp_type;
+
+    typedef typename boost::mpl::if_c
+        <
+            boost::is_float<Type>::value, Type, double
+        >::type fp_type;
+
+    Type m_numerator;
+    Type m_denominator;
+
+    // Contains ratio on scale 0..1000000 (for 0..1)
+    // This is an approximation for fast and rough comparisons
+    // Boost.Rational is used if the approximations are close.
+    // Reason: performance, Boost.Rational does a GCD by default and also the
+    // comparisons contain while-loops.
+    fp_type m_approximation;
+
+
+    static inline fp_type scale()
+    {
+        return 1000000.0;
+    }
+};
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_POLICIES_ROBUSTNESS_SEGMENT_RATIO_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/segment_ratio_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/segment_ratio_type.hpp
new file mode 100644
index 00000000000..19e935bbb93
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/policies/robustness/segment_ratio_type.hpp
@@ -0,0 +1,28 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2013 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2013 Bruno Lalande, Paris, France.
+// Copyright (c) 2013 Mateusz Loskot, London, UK.
+// Copyright (c) 2013 Adam Wulkiewicz, Lodz, Poland.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_POLICIES_ROBUSTNESS_SEGMENT_RATIO_TYPE_HPP
+#define BOOST_GEOMETRY_POLICIES_ROBUSTNESS_SEGMENT_RATIO_TYPE_HPP
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+namespace boost { namespace geometry
+{
+
+// Meta-function to access segment-ratio for a policy
+template <typename Point, typename Policy>
+struct segment_ratio_type {}; // : not_implemented<> {};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_POLICIES_ROBUSTNESS_SEGMENT_RATIO_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/buffer_distance_asymmetric.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/buffer_distance_asymmetric.hpp
new file mode 100644
index 00000000000..446d2f02cd1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/buffer_distance_asymmetric.hpp
@@ -0,0 +1,114 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012-2014 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_BUFFER_DISTANCE_ASYMMETRIC_HPP
+#define BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_BUFFER_DISTANCE_ASYMMETRIC_HPP
+
+#include <boost/core/ignore_unused.hpp>
+
+#include <boost/geometry/strategies/buffer.hpp>
+#include <boost/geometry/util/math.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace buffer
+{
+
+
+/*!
+\brief Let the buffer for linestrings be asymmetric
+\ingroup strategies
+\tparam NumericType \tparam_numeric
+\details This strategy can be used as DistanceStrategy for the buffer algorithm.
+    It can be applied for (multi)linestrings. It uses a (potentially) different
+    distances for left and for right. This means the (multi)linestrings are
+    interpreted having a direction.
+
+\qbk{
+[heading Example]
+[buffer_distance_asymmetric]
+[heading Output]
+[$img/strategies/buffer_distance_asymmetric.png]
+[heading See also]
+\* [link geometry.reference.algorithms.buffer.buffer_7_with_strategies buffer (with strategies)]
+\* [link geometry.reference.strategies.strategy_buffer_distance_symmetric distance_symmetric]
+}
+ */
+template<typename NumericType>
+class distance_asymmetric
+{
+public :
+    //! \brief Constructs the strategy, two distances must be specified
+    //! \param left The distance (or radius) of the buffer on the left side
+    //! \param right The distance on the right side
+    distance_asymmetric(NumericType const& left,
+                NumericType const& right)
+        : m_left(left)
+        , m_right(right)
+    {}
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+    //! Returns the distance-value for the specified side
+    template <typename Point>
+    inline NumericType apply(Point const& , Point const& ,
+                buffer_side_selector side)  const
+    {
+        NumericType result = side == buffer_side_left ? m_left : m_right;
+        return negative() ? math::abs(result) : result;
+    }
+
+    //! Used internally, returns -1 for deflate, 1 for inflate
+    inline int factor() const
+    {
+        return negative() ? -1 : 1;
+    }
+
+    //! Returns true if both distances are negative
+    inline bool negative() const
+    {
+        return m_left < 0 && m_right < 0;
+    }
+
+    //! Returns the max distance distance up to the buffer will reach
+    template <typename JoinStrategy, typename EndStrategy>
+    inline NumericType max_distance(JoinStrategy const& join_strategy,
+            EndStrategy const& end_strategy) const
+    {
+        boost::ignore_unused(join_strategy, end_strategy);
+
+        NumericType const left = geometry::math::abs(m_left);
+        NumericType const right = geometry::math::abs(m_right);
+        NumericType const dist = (std::max)(left, right);
+        return (std::max)(join_strategy.max_distance(dist),
+                          end_strategy.max_distance(dist));
+    }
+
+    //! Returns the distance at which the input is simplified before the buffer process
+    inline NumericType simplify_distance() const
+    {
+        NumericType const left = geometry::math::abs(m_left);
+        NumericType const right = geometry::math::abs(m_right);
+        return (std::min)(left, right) / 1000.0;
+    }
+
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+private :
+    NumericType m_left;
+    NumericType m_right;
+};
+
+
+}} // namespace strategy::buffer
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_BUFFER_DISTANCE_ASYMMETRIC_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/buffer_distance_symmetric.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/buffer_distance_symmetric.hpp
new file mode 100644
index 00000000000..73bd21ac730
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/buffer_distance_symmetric.hpp
@@ -0,0 +1,107 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012-2014 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_BUFFER_DISTANCE_SYMMETRIC_HPP
+#define BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_BUFFER_DISTANCE_SYMMETRIC_HPP
+
+
+#include <boost/core/ignore_unused.hpp>
+
+#include <boost/geometry/strategies/buffer.hpp>
+#include <boost/geometry/util/math.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace buffer
+{
+
+
+/*!
+\brief Let the buffer algorithm create buffers with same distances
+\ingroup strategies
+\tparam NumericType \tparam_numeric
+\details This strategy can be used as DistanceStrategy for the buffer algorithm.
+    It can be applied for all geometries. It uses one distance for left and
+    for right.
+    If the distance is negative and used with a (multi)polygon or ring, the
+    geometry will shrink (deflate) instead of expand (inflate).
+
+\qbk{
+[heading Example]
+[buffer_distance_symmetric]
+[heading Output]
+[$img/strategies/buffer_distance_symmetric.png]
+[heading See also]
+\* [link geometry.reference.algorithms.buffer.buffer_7_with_strategies buffer (with strategies)]
+\* [link geometry.reference.strategies.strategy_buffer_distance_asymmetric distance_asymmetric]
+}
+ */
+template<typename NumericType>
+class distance_symmetric
+{
+public :
+    //! \brief Constructs the strategy, a distance must be specified
+    //! \param distance The distance (or radius) of the buffer
+    explicit inline distance_symmetric(NumericType const& distance)
+        : m_distance(distance)
+    {}
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+    //! Returns the distance-value
+    template <typename Point>
+    inline NumericType apply(Point const& , Point const& ,
+                buffer_side_selector )  const
+    {
+        return negative() ? geometry::math::abs(m_distance) : m_distance;
+    }
+
+    //! Used internally, returns -1 for deflate, 1 for inflate
+    inline int factor() const
+    {
+        return negative() ? -1 : 1;
+    }
+
+    //! Returns true if distance is negative
+    inline bool negative() const
+    {
+        return m_distance < 0;
+    }
+
+    //! Returns the max distance distance up to the buffer will reach
+    template <typename JoinStrategy, typename EndStrategy>
+    inline NumericType max_distance(JoinStrategy const& join_strategy,
+            EndStrategy const& end_strategy) const
+    {
+        boost::ignore_unused(join_strategy, end_strategy);
+
+        NumericType const dist = geometry::math::abs(m_distance);
+        return (std::max)(join_strategy.max_distance(dist),
+                          end_strategy.max_distance(dist));
+    }
+
+
+    //! Returns the distance at which the input is simplified before the buffer process
+    inline NumericType simplify_distance() const
+    {
+        return geometry::math::abs(m_distance) / 1000.0;
+    }
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+private :
+    NumericType m_distance;
+};
+
+
+}} // namespace strategy::buffer
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_BUFFER_DISTANCE_SYMMETRIC_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/hull_graham_andrew.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/hull_graham_andrew.hpp
new file mode 100644
index 00000000000..0cd0cdc4dbd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/hull_graham_andrew.hpp
@@ -0,0 +1,390 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_CONVEX_GRAHAM_ANDREW_HPP
+#define BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_CONVEX_GRAHAM_ANDREW_HPP
+
+
+#include <cstddef>
+#include <algorithm>
+#include <vector>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/strategies/convex_hull.hpp>
+
+#include <boost/geometry/views/detail/range_type.hpp>
+
+#include <boost/geometry/policies/compare.hpp>
+
+#include <boost/geometry/algorithms/detail/for_each_range.hpp>
+#include <boost/geometry/views/reversible_view.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace convex_hull
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+
+template
+<
+    typename InputRange,
+    typename RangeIterator,
+    typename StrategyLess,
+    typename StrategyGreater
+>
+struct get_extremes
+{
+    typedef typename point_type<InputRange>::type point_type;
+
+    point_type left, right;
+
+    bool first;
+
+    StrategyLess less;
+    StrategyGreater greater;
+
+    inline get_extremes()
+        : first(true)
+    {}
+
+    inline void apply(InputRange const& range)
+    {
+        if (boost::size(range) == 0)
+        {
+            return;
+        }
+
+        // First iterate through this range
+        // (this two-stage approach avoids many point copies,
+        //  because iterators are kept in memory. Because iterators are
+        //  not persistent (in MSVC) this approach is not applicable
+        //  for more ranges together)
+
+        RangeIterator left_it = boost::begin(range);
+        RangeIterator right_it = boost::begin(range);
+
+        for (RangeIterator it = boost::begin(range) + 1;
+            it != boost::end(range);
+            ++it)
+        {
+            if (less(*it, *left_it))
+            {
+                left_it = it;
+            }
+
+            if (greater(*it, *right_it))
+            {
+                right_it = it;
+            }
+        }
+
+        // Then compare with earlier
+        if (first)
+        {
+            // First time, assign left/right
+            left = *left_it;
+            right = *right_it;
+            first = false;
+        }
+        else
+        {
+            // Next time, check if this range was left/right from
+            // the extremes already collected
+            if (less(*left_it, left))
+            {
+                left = *left_it;
+            }
+
+            if (greater(*right_it, right))
+            {
+                right = *right_it;
+            }
+        }
+    }
+};
+
+
+template
+<
+    typename InputRange,
+    typename RangeIterator,
+    typename Container,
+    typename SideStrategy
+>
+struct assign_range
+{
+    Container lower_points, upper_points;
+
+    typedef typename point_type<InputRange>::type point_type;
+
+    point_type const& most_left;
+    point_type const& most_right;
+
+    inline assign_range(point_type const& left, point_type const& right)
+        : most_left(left)
+        , most_right(right)
+    {}
+
+    inline void apply(InputRange const& range)
+    {
+        typedef SideStrategy side;
+
+        // Put points in one of the two output sequences
+        for (RangeIterator it = boost::begin(range);
+            it != boost::end(range);
+            ++it)
+        {
+            // check if it is lying most_left or most_right from the line
+
+            int dir = side::apply(most_left, most_right, *it);
+            switch(dir)
+            {
+                case 1 : // left side
+                    upper_points.push_back(*it);
+                    break;
+                case -1 : // right side
+                    lower_points.push_back(*it);
+                    break;
+
+                // 0: on line most_left-most_right,
+                //    or most_left, or most_right,
+                //    -> all never part of hull
+            }
+        }
+    }
+};
+
+template <typename Range>
+static inline void sort(Range& range)
+{
+    typedef typename boost::range_value<Range>::type point_type;
+    typedef geometry::less<point_type> comparator;
+
+    std::sort(boost::begin(range), boost::end(range), comparator());
+}
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+/*!
+\brief Graham scan strategy to calculate convex hull
+\ingroup strategies
+\note Completely reworked version inspired on the sources listed below
+\see http://www.ddj.com/architect/201806315
+\see http://marknelson.us/2007/08/22/convex
+ */
+template <typename InputGeometry, typename OutputPoint>
+class graham_andrew
+{
+public :
+    typedef OutputPoint point_type;
+    typedef InputGeometry geometry_type;
+
+private:
+
+    typedef typename cs_tag<point_type>::type cs_tag;
+
+    typedef typename std::vector<point_type> container_type;
+    typedef typename std::vector<point_type>::const_iterator iterator;
+    typedef typename std::vector<point_type>::const_reverse_iterator rev_iterator;
+
+
+    class partitions
+    {
+        friend class graham_andrew;
+
+        container_type m_lower_hull;
+        container_type m_upper_hull;
+        container_type m_copied_input;
+    };
+
+
+public:
+    typedef partitions state_type;
+
+
+    inline void apply(InputGeometry const& geometry, partitions& state) const
+    {
+        // First pass.
+        // Get min/max (in most cases left / right) points
+        // This makes use of the geometry::less/greater predicates
+
+        // For the left boundary it is important that multiple points
+        // are sorted from bottom to top. Therefore the less predicate
+        // does not take the x-only template parameter (this fixes ticket #6019.
+        // For the right boundary it is not necessary (though also not harmful),
+        // because points are sorted from bottom to top in a later stage.
+        // For symmetry and to get often more balanced lower/upper halves
+        // we keep it.
+
+        typedef typename geometry::detail::range_type<InputGeometry>::type range_type;
+
+        typedef typename boost::range_iterator
+            <
+                range_type const
+            >::type range_iterator;
+
+        detail::get_extremes
+            <
+                range_type,
+                range_iterator,
+                geometry::less<point_type>,
+                geometry::greater<point_type>
+            > extremes;
+        geometry::detail::for_each_range(geometry, extremes);
+
+        // Bounding left/right points
+        // Second pass, now that extremes are found, assign all points
+        // in either lower, either upper
+        detail::assign_range
+            <
+                range_type,
+                range_iterator,
+                container_type,
+                typename strategy::side::services::default_strategy<cs_tag>::type
+            > assigner(extremes.left, extremes.right);
+
+        geometry::detail::for_each_range(geometry, assigner);
+
+
+        // Sort both collections, first on x(, then on y)
+        detail::sort(assigner.lower_points);
+        detail::sort(assigner.upper_points);
+
+        //std::cout << boost::size(assigner.lower_points) << std::endl;
+        //std::cout << boost::size(assigner.upper_points) << std::endl;
+
+        // And decide which point should be in the final hull
+        build_half_hull<-1>(assigner.lower_points, state.m_lower_hull,
+                extremes.left, extremes.right);
+        build_half_hull<1>(assigner.upper_points, state.m_upper_hull,
+                extremes.left, extremes.right);
+    }
+
+
+    template <typename OutputIterator>
+    inline void result(partitions const& state,
+                       OutputIterator out,
+                       bool clockwise,
+                       bool closed) const
+    {
+        if (clockwise)
+        {
+            output_ranges(state.m_upper_hull, state.m_lower_hull, out, closed);
+        }
+        else
+        {
+            output_ranges(state.m_lower_hull, state.m_upper_hull, out, closed);
+        }
+    }
+
+
+private:
+
+    template <int Factor>
+    static inline void build_half_hull(container_type const& input,
+            container_type& output,
+            point_type const& left, point_type const& right)
+    {
+        output.push_back(left);
+        for(iterator it = input.begin(); it != input.end(); ++it)
+        {
+            add_to_hull<Factor>(*it, output);
+        }
+        add_to_hull<Factor>(right, output);
+    }
+
+
+    template <int Factor>
+    static inline void add_to_hull(point_type const& p, container_type& output)
+    {
+        typedef typename strategy::side::services::default_strategy<cs_tag>::type side;
+
+        output.push_back(p);
+        std::size_t output_size = output.size();
+        while (output_size >= 3)
+        {
+            rev_iterator rit = output.rbegin();
+            point_type const last = *rit++;
+            point_type const& last2 = *rit++;
+
+            if (Factor * side::apply(*rit, last, last2) <= 0)
+            {
+                // Remove last two points from stack, and add last again
+                // This is much faster then erasing the one but last.
+                output.pop_back();
+                output.pop_back();
+                output.push_back(last);
+                output_size--;
+            }
+            else
+            {
+                return;
+            }
+        }
+    }
+
+
+    template <typename OutputIterator>
+    static inline void output_ranges(container_type const& first, container_type const& second,
+                                     OutputIterator out, bool closed)
+    {
+        std::copy(boost::begin(first), boost::end(first), out);
+
+        BOOST_GEOMETRY_ASSERT(closed ? !boost::empty(second) : boost::size(second) > 1);
+        std::copy(++boost::rbegin(second), // skip the first Point
+                  closed ? boost::rend(second) : --boost::rend(second), // skip the last Point if open
+                  out);
+
+        typedef typename boost::range_size<container_type>::type size_type;
+        size_type const count = boost::size(first) + boost::size(second) - 1;
+        // count describes a closed case but comparison with min size of closed
+        // gives the result compatible also with open
+        // here core_detail::closure::minimum_ring_size<closed> could be used
+        if (count < 4)
+        {
+            // there should be only one missing
+            *out++ = *boost::begin(first);
+        }
+    }
+};
+
+}} // namespace strategy::convex_hull
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+template <typename InputGeometry, typename OutputPoint>
+struct strategy_convex_hull<InputGeometry, OutputPoint, cartesian_tag>
+{
+    typedef strategy::convex_hull::graham_andrew<InputGeometry, OutputPoint> type;
+};
+#endif
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_CONVEX_GRAHAM_ANDREW_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/point_in_box_by_side.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/point_in_box_by_side.hpp
new file mode 100644
index 00000000000..6740b519e21
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/point_in_box_by_side.hpp
@@ -0,0 +1,103 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_POINT_IN_BOX_BY_SIDE_HPP
+#define BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_POINT_IN_BOX_BY_SIDE_HPP
+
+#include <boost/array.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/strategies/covered_by.hpp>
+#include <boost/geometry/strategies/within.hpp>
+
+
+namespace boost { namespace geometry { namespace strategy
+{
+
+namespace within
+{
+
+struct decide_within
+{
+    static inline bool apply(int side, bool& result)
+    {
+        if (side != 1)
+        {
+            result = false;
+            return false;
+        }
+        return true; // continue
+    }
+};
+
+struct decide_covered_by
+{
+    static inline bool apply(int side, bool& result)
+    {
+        if (side != 1)
+        {
+            result = side >= 0;
+            return false;
+        }
+        return true; // continue
+    }
+};
+
+
+// WARNING
+// This strategy is not suitable for boxes in non-cartesian CSes having edges
+// longer than 180deg because e.g. the SSF formula picks the side of the closer
+// longitude, so for long edges the side is the opposite.
+template <typename Point, typename Box, typename Decide = decide_within>
+struct point_in_box_by_side
+{
+    typedef typename strategy::side::services::default_strategy
+    <
+        typename cs_tag<Box>::type
+    >::type side_strategy_type;
+
+    static inline bool apply(Point const& point, Box const& box)
+    {
+        // Create (counterclockwise) array of points, the fifth one closes it
+        // Every point should be on the LEFT side (=1), or ON the border (=0),
+        // So >= 1 or >= 0
+        boost::array<typename point_type<Box>::type, 5> bp;
+        geometry::detail::assign_box_corners_oriented<true>(box, bp);
+        bp[4] = bp[0];
+
+        bool result = true;
+        side_strategy_type strategy;
+        boost::ignore_unused_variable_warning(strategy);
+
+        for (int i = 1; i < 5; i++)
+        {
+            int const side = strategy.apply(point, bp[i - 1], bp[i]);
+            if (! Decide::apply(side, result))
+            {
+                return result;
+            }
+        }
+
+        return result;
+    }
+};
+
+
+} // namespace within
+
+
+}}} // namespace boost::geometry::strategy
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_AGNOSTIC_POINT_IN_BOX_BY_SIDE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/point_in_point.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/point_in_point.hpp
new file mode 100644
index 00000000000..1a9274149a1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/point_in_point.hpp
@@ -0,0 +1,85 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_STRATEGY_AGNOSTIC_POINT_IN_POINT_HPP
+#define BOOST_GEOMETRY_STRATEGY_AGNOSTIC_POINT_IN_POINT_HPP
+
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+
+#include <boost/geometry/strategies/covered_by.hpp>
+#include <boost/geometry/strategies/within.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace within
+{
+
+template
+<
+    typename Point1, typename Point2
+>
+struct point_in_point
+{
+    static inline bool apply(Point1 const& point1, Point2 const& point2)
+    {
+        return detail::equals::equals_point_point(point1, point2);
+    }
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+template <typename PointLike1, typename PointLike2, typename Tag1, typename Tag2, typename AnyCS1, typename AnyCS2>
+struct default_strategy<PointLike1, PointLike2, Tag1, Tag2, pointlike_tag, pointlike_tag, AnyCS1, AnyCS2>
+{
+    typedef strategy::within::point_in_point
+        <
+            typename point_type<PointLike1>::type,
+            typename point_type<PointLike2>::type
+        > type;
+};
+
+
+} // namespace services
+
+#endif
+
+
+}} // namespace strategy::within
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace strategy { namespace covered_by { namespace services
+{
+
+template <typename PointLike1, typename PointLike2, typename Tag1, typename Tag2, typename AnyCS1, typename AnyCS2>
+struct default_strategy<PointLike1, PointLike2, Tag1, Tag2, pointlike_tag, pointlike_tag, AnyCS1, AnyCS2>
+{
+    typedef strategy::within::point_in_point
+        <
+            typename point_type<PointLike1>::type,
+            typename point_type<PointLike2>::type
+        > type;
+};
+
+}}} // namespace strategy::covered_by::services
+#endif
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGY_AGNOSTIC_POINT_IN_POINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/point_in_poly_oriented_winding.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/point_in_poly_oriented_winding.hpp
new file mode 100644
index 00000000000..423948fff32
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/point_in_poly_oriented_winding.hpp
@@ -0,0 +1,208 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2011-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGY_AGNOSTIC_POINT_IN_POLY_ORIENTED_WINDING_HPP
+#define BOOST_GEOMETRY_STRATEGY_AGNOSTIC_POINT_IN_POLY_ORIENTED_WINDING_HPP
+
+
+#include <boost/geometry/core/point_order.hpp>
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/select_calculation_type.hpp>
+
+#include <boost/geometry/strategies/side.hpp>
+#include <boost/geometry/strategies/within.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace within
+{
+
+/*!
+\brief Within detection using winding rule, but checking if enclosing ring is
+    counter clockwise and, if so, reverses the result
+\ingroup strategies
+\tparam Point \tparam_point
+\tparam Reverse True if parameter should be reversed
+\tparam PointOfSegment \tparam_segment_point
+\tparam CalculationType \tparam_calculation
+\author Barend Gehrels
+\note The implementation is inspired by terralib http://www.terralib.org (LGPL)
+\note but totally revised afterwards, especially for cases on segments
+\note Only dependant on "side", -> agnostic, suitable for spherical/latlong
+
+\qbk{
+[heading See also]
+[link geometry.reference.algorithms.within.within_3_with_strategy within (with strategy)]
+}
+ */
+template
+<
+    bool Reverse,
+    typename Point,
+    typename PointOfSegment = Point,
+    typename CalculationType = void
+>
+class oriented_winding
+{
+    typedef typename select_calculation_type
+        <
+            Point,
+            PointOfSegment,
+            CalculationType
+        >::type calculation_type;
+
+
+    typedef typename strategy::side::services::default_strategy
+        <
+            typename cs_tag<Point>::type
+        >::type strategy_side_type;
+
+
+    /*! subclass to keep state */
+    class counter
+    {
+        int m_count;
+        bool m_touches;
+        calculation_type m_sum_area;
+
+        inline int code() const
+        {
+            return m_touches ? 0 : m_count == 0 ? -1 : 1;
+        }
+        inline int clockwise_oriented_code() const
+        {
+            return (m_sum_area > 0) ? code() : -code();
+        }
+        inline int oriented_code() const
+        {
+            return Reverse
+                ? -clockwise_oriented_code()
+                : clockwise_oriented_code();
+        }
+
+    public :
+        friend class oriented_winding;
+
+        inline counter()
+            : m_count(0)
+            , m_touches(false)
+            , m_sum_area(0)
+        {}
+
+        inline void add_to_area(calculation_type triangle)
+        {
+            m_sum_area += triangle;
+        }
+
+    };
+
+
+    template <size_t D>
+    static inline int check_touch(Point const& point,
+                PointOfSegment const& seg1, PointOfSegment const& seg2,
+                counter& state)
+    {
+        calculation_type const p = get<D>(point);
+        calculation_type const s1 = get<D>(seg1);
+        calculation_type const s2 = get<D>(seg2);
+        if ((s1 <= p && s2 >= p) || (s2 <= p && s1 >= p))
+        {
+            state.m_touches = true;
+        }
+        return 0;
+    }
+
+
+    template <size_t D>
+    static inline int check_segment(Point const& point,
+                PointOfSegment const& seg1, PointOfSegment const& seg2,
+                counter& state)
+    {
+        calculation_type const p = get<D>(point);
+        calculation_type const s1 = get<D>(seg1);
+        calculation_type const s2 = get<D>(seg2);
+
+
+        // Check if one of segment endpoints is at same level of point
+        bool eq1 = math::equals(s1, p);
+        bool eq2 = math::equals(s2, p);
+
+        if (eq1 && eq2)
+        {
+            // Both equal p -> segment is horizontal (or vertical for D=0)
+            // The only thing which has to be done is check if point is ON segment
+            return check_touch<1 - D>(point, seg1, seg2, state);
+        }
+
+        return
+              eq1 ? (s2 > p ?  1 : -1)  // Point on level s1, UP/DOWN depending on s2
+            : eq2 ? (s1 > p ? -1 :  1)  // idem
+            : s1 < p && s2 > p ?  2     // Point between s1 -> s2 --> UP
+            : s2 < p && s1 > p ? -2     // Point between s2 -> s1 --> DOWN
+            : 0;
+    }
+
+
+
+
+public :
+
+    // Typedefs and static methods to fulfill the concept
+    typedef Point point_type;
+    typedef PointOfSegment segment_point_type;
+    typedef counter state_type;
+
+    static inline bool apply(Point const& point,
+                PointOfSegment const& s1, PointOfSegment const& s2,
+                counter& state)
+    {
+        state.add_to_area(get<0>(s2) * get<1>(s1) - get<0>(s1) * get<1>(s2));
+
+        int count = check_segment<1>(point, s1, s2, state);
+        if (count != 0)
+        {
+            int side = strategy_side_type::apply(s1, s2, point);
+            if (side == 0)
+            {
+                // Point is lying on segment
+                state.m_touches = true;
+                state.m_count = 0;
+                return false;
+            }
+
+            // Side is NEG for right, POS for left.
+            // The count is -2 for down, 2 for up (or -1/1)
+            // Side positive thus means UP and LEFTSIDE or DOWN and RIGHTSIDE
+            // See accompagnying figure (TODO)
+            if (side * count > 0)
+            {
+                state.m_count += count;
+            }
+        }
+        return ! state.m_touches;
+    }
+
+    static inline int result(counter const& state)
+    {
+        return state.oriented_code();
+    }
+};
+
+
+}} // namespace strategy::within
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGY_AGNOSTIC_POINT_IN_POLY_ORIENTED_WINDING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/point_in_poly_winding.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/point_in_poly_winding.hpp
new file mode 100644
index 00000000000..0a797ac0f06
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/point_in_poly_winding.hpp
@@ -0,0 +1,575 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2013 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013, 2014, 2016, 2017.
+// Modifications copyright (c) 2013-2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGY_AGNOSTIC_POINT_IN_POLY_WINDING_HPP
+#define BOOST_GEOMETRY_STRATEGY_AGNOSTIC_POINT_IN_POLY_WINDING_HPP
+
+
+#include <boost/core/ignore_unused.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/select_calculation_type.hpp>
+
+#include <boost/geometry/strategies/side.hpp>
+#include <boost/geometry/strategies/covered_by.hpp>
+#include <boost/geometry/strategies/within.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace within
+{
+
+// 1 deg or pi/180 rad
+template <typename Point,
+          typename CalculationType = typename coordinate_type<Point>::type>
+struct winding_small_angle
+{
+    typedef typename coordinate_system<Point>::type cs_t;
+    typedef math::detail::constants_on_spheroid
+        <
+            CalculationType,
+            typename cs_t::units
+        > constants;
+
+    static inline CalculationType apply()
+    {
+        return constants::half_period() / CalculationType(180);
+    }
+};
+
+
+// Fix for https://svn.boost.org/trac/boost/ticket/9628
+// For floating point coordinates, the <D> coordinate of a point is compared
+// with the segment's points using some EPS. If the coordinates are "equal"
+// the sides are calculated. Therefore we can treat a segment as a long areal
+// geometry having some width. There is a small ~triangular area somewhere
+// between the segment's effective area and a segment's line used in sides
+// calculation where the segment is on the one side of the line but on the
+// other side of a segment (due to the width).
+// Below picture assuming D = 1, if D = 0 horiz<->vert, E<->N, RIGHT<->UP.
+// For the s1 of a segment going NE the real side is RIGHT but the point may
+// be detected as LEFT, like this:
+//                     RIGHT
+//                 ___----->
+//                  ^      O Pt  __ __
+//                 EPS     __ __
+//                  v__ __ BUT DETECTED AS LEFT OF THIS LINE
+//             _____7
+//       _____/
+// _____/
+// In the code below actually D = 0, so segments are nearly-vertical
+// Called when the point is on the same level as one of the segment's points
+// but the point is not aligned with a vertical segment
+template <typename CSTag>
+struct winding_side_equal
+{
+    typedef typename strategy::side::services::default_strategy
+        <
+            CSTag
+        >::type strategy_side_type;
+
+    template <typename Point, typename PointOfSegment>
+    static inline int apply(Point const& point,
+                            PointOfSegment const& se,
+                            int count)
+    {
+        typedef typename coordinate_type<PointOfSegment>::type scoord_t;
+        typedef typename coordinate_system<PointOfSegment>::type::units units_t;
+
+        if (math::equals(get<1>(point), get<1>(se)))
+            return 0;
+
+        // Create a horizontal segment intersecting the original segment's endpoint
+        // equal to the point, with the derived direction (E/W).
+        PointOfSegment ss1, ss2;
+        set<1>(ss1, get<1>(se));
+        set<0>(ss1, get<0>(se));
+        set<1>(ss2, get<1>(se));
+        scoord_t ss20 = get<0>(se);
+        if (count > 0)
+        {
+            ss20 += winding_small_angle<PointOfSegment>::apply();
+        }
+        else
+        {
+            ss20 -= winding_small_angle<PointOfSegment>::apply();
+        }
+        math::normalize_longitude<units_t>(ss20);
+        set<0>(ss2, ss20);
+
+        // Check the side using this vertical segment
+        return strategy_side_type::apply(ss1, ss2, point);
+    }
+};
+// The optimization for cartesian
+template <>
+struct winding_side_equal<cartesian_tag>
+{
+    template <typename Point, typename PointOfSegment>
+    static inline int apply(Point const& point,
+                            PointOfSegment const& se,
+                            int count)
+    {
+        // NOTE: for D=0 the signs would be reversed
+        return math::equals(get<1>(point), get<1>(se)) ?
+                0 :
+                get<1>(point) < get<1>(se) ?
+                    // assuming count is equal to 1 or -1
+                    -count : // ( count > 0 ? -1 : 1) :
+                    count;   // ( count > 0 ? 1 : -1) ;
+    }
+};
+
+
+template <typename Point,
+          typename CalculationType,
+          typename CSTag = typename cs_tag<Point>::type>
+struct winding_check_touch
+{
+    typedef CalculationType calc_t;
+    typedef typename coordinate_system<Point>::type::units units_t;
+    typedef math::detail::constants_on_spheroid<CalculationType, units_t> constants;
+
+    template <typename PointOfSegment, typename State>
+    static inline int apply(Point const& point,
+                            PointOfSegment const& seg1,
+                            PointOfSegment const& seg2,
+                            State& state,
+                            bool& eq1,
+                            bool& eq2)
+    {
+        calc_t const pi = constants::half_period();
+        calc_t const pi2 = pi / calc_t(2);
+
+        calc_t const px = get<0>(point);
+        calc_t const s1x = get<0>(seg1);
+        calc_t const s2x = get<0>(seg2);
+        calc_t const py = get<1>(point);
+        calc_t const s1y = get<1>(seg1);
+        calc_t const s2y = get<1>(seg2);
+
+        // NOTE: lat in {-90, 90} and arbitrary lon
+        //  it doesn't matter what lon it is if it's a pole
+        //  so e.g. if one of the segment endpoints is a pole
+        //  then only the other lon matters
+        
+        bool eq1_strict = math::equals(s1x, px);
+        bool eq2_strict = math::equals(s2x, px);
+
+        eq1 = eq1_strict // lon strictly equal to s1
+           || math::equals(s1y, pi2) || math::equals(s1y, -pi2); // s1 is pole
+        eq2 = eq2_strict // lon strictly equal to s2
+           || math::equals(s2y, pi2) || math::equals(s2y, -pi2); // s2 is pole
+        
+        // segment overlapping pole
+        calc_t s1x_anti = s1x + constants::half_period();
+        math::normalize_longitude<units_t, calc_t>(s1x_anti);
+        bool antipodal = math::equals(s2x, s1x_anti);
+        if (antipodal)
+        {
+            eq1 = eq2 = eq1 || eq2;
+
+            // segment overlapping pole and point is pole
+            if (math::equals(py, pi2) || math::equals(py, -pi2))
+            {
+                eq1 = eq2 = true;
+            }
+        }
+        
+        // Both equal p -> segment vertical
+        // The only thing which has to be done is check if point is ON segment
+        if (eq1 && eq2)
+        {
+            // segment endpoints on the same sides of the globe
+            if (! antipodal
+                // p's lat between segment endpoints' lats
+                ? (s1y <= py && s2y >= py) || (s2y <= py && s1y >= py)
+                // going through north or south pole?
+                : (pi - s1y - s2y <= pi
+                    ? (eq1_strict && s1y <= py) || (eq2_strict && s2y <= py) // north
+                        || math::equals(py, pi2) // point on north pole
+                    : (eq1_strict && s1y >= py) || (eq2_strict && s2y >= py)) // south
+                        || math::equals(py, -pi2) // point on south pole
+                )
+            {
+                state.m_touches = true;
+            }
+            return true;
+        }
+        return false;
+    }
+};
+// The optimization for cartesian
+template <typename Point, typename CalculationType>
+struct winding_check_touch<Point, CalculationType, cartesian_tag>
+{
+    typedef CalculationType calc_t;
+
+    template <typename PointOfSegment, typename State>
+    static inline bool apply(Point const& point,
+                             PointOfSegment const& seg1,
+                             PointOfSegment const& seg2,
+                             State& state,
+                             bool& eq1,
+                             bool& eq2)
+    {
+        calc_t const px = get<0>(point);
+        calc_t const s1x = get<0>(seg1);
+        calc_t const s2x = get<0>(seg2);
+
+        eq1 = math::equals(s1x, px);
+        eq2 = math::equals(s2x, px);
+
+        // Both equal p -> segment vertical
+        // The only thing which has to be done is check if point is ON segment
+        if (eq1 && eq2)
+        {
+            calc_t const py = get<1>(point);
+            calc_t const s1y = get<1>(seg1);
+            calc_t const s2y = get<1>(seg2);
+            if ((s1y <= py && s2y >= py) || (s2y <= py && s1y >= py))
+            {
+                state.m_touches = true;
+            }
+            return true;
+        }
+        return false;
+    }
+};
+
+
+// Called if point is not aligned with a vertical segment
+template <typename Point,
+          typename CalculationType,
+          typename CSTag = typename cs_tag<Point>::type>
+struct winding_calculate_count
+{
+    typedef CalculationType calc_t;
+    typedef typename coordinate_system<Point>::type::units units_t;
+
+    static inline bool greater(calc_t const& l, calc_t const& r)
+    {
+        calc_t diff = l - r;
+        math::normalize_longitude<units_t, calc_t>(diff);
+        return diff > calc_t(0);
+    }
+
+    static inline int apply(calc_t const& p,
+                            calc_t const& s1, calc_t const& s2,
+                            bool eq1, bool eq2)
+    {
+        // Probably could be optimized by avoiding normalization for some comparisons
+        // e.g. s1 > p could be calculated from p > s1
+
+        // If both segment endpoints were poles below checks wouldn't be enough
+        // but this means that either both are the same or that they are N/S poles
+        // and therefore the segment is not valid.
+        // If needed (eq1 && eq2 ? 0) could be returned
+
+        return
+              eq1 ? (greater(s2, p) ?  1 : -1)      // Point on level s1, E/W depending on s2
+            : eq2 ? (greater(s1, p) ? -1 :  1)      // idem
+            : greater(p, s1) && greater(s2, p) ?  2 // Point between s1 -> s2 --> E
+            : greater(p, s2) && greater(s1, p) ? -2 // Point between s2 -> s1 --> W
+            : 0;
+    }
+};
+// The optimization for cartesian
+template <typename Point, typename CalculationType>
+struct winding_calculate_count<Point, CalculationType, cartesian_tag>
+{
+    typedef CalculationType calc_t;
+    
+    static inline int apply(calc_t const& p,
+                            calc_t const& s1, calc_t const& s2,
+                            bool eq1, bool eq2)
+    {
+        return
+              eq1 ? (s2 > p ?  1 : -1)  // Point on level s1, E/W depending on s2
+            : eq2 ? (s1 > p ? -1 :  1)  // idem
+            : s1 < p && s2 > p ?  2     // Point between s1 -> s2 --> E
+            : s2 < p && s1 > p ? -2     // Point between s2 -> s1 --> W
+            : 0;
+    }
+};
+
+
+/*!
+\brief Within detection using winding rule
+\ingroup strategies
+\tparam Point \tparam_point
+\tparam PointOfSegment \tparam_segment_point
+\tparam SideStrategy Side strategy
+\tparam CalculationType \tparam_calculation
+\author Barend Gehrels
+\note The implementation is inspired by terralib http://www.terralib.org (LGPL)
+\note but totally revised afterwards, especially for cases on segments
+\note Only dependant on "side", -> agnostic, suitable for spherical/latlong
+
+\qbk{
+[heading See also]
+[link geometry.reference.algorithms.within.within_3_with_strategy within (with strategy)]
+}
+ */
+template
+<
+    typename Point,
+    typename PointOfSegment = Point,
+    typename SideStrategy = typename strategy::side::services::default_strategy
+                                <
+                                    typename cs_tag<Point>::type
+                                >::type,
+    typename CalculationType = void
+>
+class winding
+{
+    typedef typename select_calculation_type
+        <
+            Point,
+            PointOfSegment,
+            CalculationType
+        >::type calculation_type;
+    
+    /*! subclass to keep state */
+    class counter
+    {
+        int m_count;
+        bool m_touches;
+
+        inline int code() const
+        {
+            return m_touches ? 0 : m_count == 0 ? -1 : 1;
+        }
+
+    public :
+        friend class winding;
+
+        template <typename P, typename CT, typename CST>
+        friend struct winding_check_touch;
+
+        inline counter()
+            : m_count(0)
+            , m_touches(false)
+        {}
+
+    };
+
+    static inline int check_segment(Point const& point,
+                PointOfSegment const& seg1, PointOfSegment const& seg2,
+                counter& state, bool& eq1, bool& eq2)
+    {
+        if (winding_check_touch<Point, calculation_type>
+                ::apply(point, seg1, seg2, state, eq1, eq2))
+        {
+            return 0;
+        }
+
+        calculation_type const p = get<0>(point);
+        calculation_type const s1 = get<0>(seg1);
+        calculation_type const s2 = get<0>(seg2);
+        return winding_calculate_count<Point, calculation_type>
+                    ::apply(p, s1, s2, eq1, eq2);
+    }
+
+
+public:
+    typedef typename SideStrategy::envelope_strategy_type envelope_strategy_type;
+
+    inline envelope_strategy_type get_envelope_strategy() const
+    {
+        return m_side_strategy.get_envelope_strategy();
+    }
+
+    typedef typename SideStrategy::disjoint_strategy_type disjoint_strategy_type;
+
+    inline disjoint_strategy_type get_disjoint_strategy() const
+    {
+        return m_side_strategy.get_disjoint_strategy();
+    }
+
+    winding()
+    {}
+
+    explicit winding(SideStrategy const& side_strategy)
+        : m_side_strategy(side_strategy)
+    {}
+
+    // Typedefs and static methods to fulfill the concept
+    typedef Point point_type;
+    typedef PointOfSegment segment_point_type;
+    typedef counter state_type;
+
+    inline bool apply(Point const& point,
+                      PointOfSegment const& s1, PointOfSegment const& s2,
+                      counter& state) const
+    {
+        typedef typename cs_tag<Point>::type cs_t;
+
+        bool eq1 = false;
+        bool eq2 = false;
+        boost::ignore_unused(eq2);
+
+        int count = check_segment(point, s1, s2, state, eq1, eq2);
+        if (count != 0)
+        {
+            int side = 0;
+            if (count == 1 || count == -1)
+            {
+                side = winding_side_equal<cs_t>::apply(point, eq1 ? s1 : s2, count);
+            }
+            else // count == 2 || count == -2
+            {
+                // 1 left, -1 right
+                side = m_side_strategy.apply(s1, s2, point);
+            }
+            
+            if (side == 0)
+            {
+                // Point is lying on segment
+                state.m_touches = true;
+                state.m_count = 0;
+                return false;
+            }
+
+            // Side is NEG for right, POS for left.
+            // The count is -2 for down, 2 for up (or -1/1)
+            // Side positive thus means UP and LEFTSIDE or DOWN and RIGHTSIDE
+            // See accompagnying figure (TODO)
+            if (side * count > 0)
+            {
+                state.m_count += count;
+            }
+        }
+        return ! state.m_touches;
+    }
+
+    static inline int result(counter const& state)
+    {
+        return state.code();
+    }
+
+private:
+    SideStrategy m_side_strategy;
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+template <typename PointLike, typename Geometry, typename AnyTag1, typename AnyTag2>
+struct default_strategy<PointLike, Geometry, AnyTag1, AnyTag2, pointlike_tag, polygonal_tag, cartesian_tag, cartesian_tag>
+{
+    typedef winding
+        <
+            typename geometry::point_type<PointLike>::type,
+            typename geometry::point_type<Geometry>::type
+        > type;
+};
+
+template <typename PointLike, typename Geometry, typename AnyTag1, typename AnyTag2>
+struct default_strategy<PointLike, Geometry, AnyTag1, AnyTag2, pointlike_tag, polygonal_tag, spherical_tag, spherical_tag>
+{
+    typedef winding
+        <
+            typename geometry::point_type<PointLike>::type,
+            typename geometry::point_type<Geometry>::type
+        > type;
+};
+
+template <typename PointLike, typename Geometry, typename AnyTag1, typename AnyTag2>
+struct default_strategy<PointLike, Geometry, AnyTag1, AnyTag2, pointlike_tag, linear_tag, cartesian_tag, cartesian_tag>
+{
+    typedef winding
+        <
+            typename geometry::point_type<PointLike>::type,
+            typename geometry::point_type<Geometry>::type
+        > type;
+};
+
+template <typename PointLike, typename Geometry, typename AnyTag1, typename AnyTag2>
+struct default_strategy<PointLike, Geometry, AnyTag1, AnyTag2, pointlike_tag, linear_tag, spherical_tag, spherical_tag>
+{
+    typedef winding
+        <
+            typename geometry::point_type<PointLike>::type,
+            typename geometry::point_type<Geometry>::type
+        > type;
+};
+
+} // namespace services
+
+#endif
+
+
+}} // namespace strategy::within
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace strategy { namespace covered_by { namespace services
+{
+
+template <typename PointLike, typename Geometry, typename AnyTag1, typename AnyTag2>
+struct default_strategy<PointLike, Geometry, AnyTag1, AnyTag2, pointlike_tag, polygonal_tag, cartesian_tag, cartesian_tag>
+{
+    typedef within::winding
+        <
+            typename geometry::point_type<PointLike>::type,
+            typename geometry::point_type<Geometry>::type
+        > type;
+};
+
+template <typename PointLike, typename Geometry, typename AnyTag1, typename AnyTag2>
+struct default_strategy<PointLike, Geometry, AnyTag1, AnyTag2, pointlike_tag, polygonal_tag, spherical_tag, spherical_tag>
+{
+    typedef within::winding
+        <
+            typename geometry::point_type<PointLike>::type,
+            typename geometry::point_type<Geometry>::type
+        > type;
+};
+
+template <typename PointLike, typename Geometry, typename AnyTag1, typename AnyTag2>
+struct default_strategy<PointLike, Geometry, AnyTag1, AnyTag2, pointlike_tag, linear_tag, cartesian_tag, cartesian_tag>
+{
+    typedef within::winding
+        <
+            typename geometry::point_type<PointLike>::type,
+            typename geometry::point_type<Geometry>::type
+        > type;
+};
+
+template <typename PointLike, typename Geometry, typename AnyTag1, typename AnyTag2>
+struct default_strategy<PointLike, Geometry, AnyTag1, AnyTag2, pointlike_tag, linear_tag, spherical_tag, spherical_tag>
+{
+    typedef within::winding
+        <
+            typename geometry::point_type<PointLike>::type,
+            typename geometry::point_type<Geometry>::type
+        > type;
+};
+
+}}} // namespace strategy::covered_by::services
+#endif
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGY_AGNOSTIC_POINT_IN_POLY_WINDING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/simplify_douglas_peucker.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/simplify_douglas_peucker.hpp
new file mode 100644
index 00000000000..053723e4ccf
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/agnostic/simplify_douglas_peucker.hpp
@@ -0,0 +1,321 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 1995, 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 1995 Maarten Hilferink, Amsterdam, the Netherlands
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGY_AGNOSTIC_SIMPLIFY_DOUGLAS_PEUCKER_HPP
+#define BOOST_GEOMETRY_STRATEGY_AGNOSTIC_SIMPLIFY_DOUGLAS_PEUCKER_HPP
+
+
+#include <cstddef>
+#ifdef BOOST_GEOMETRY_DEBUG_DOUGLAS_PEUCKER
+#include <iostream>
+#endif
+#include <vector>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/strategies/distance.hpp>
+
+
+#ifdef BOOST_GEOMETRY_DEBUG_DOUGLAS_PEUCKER
+#include <boost/geometry/io/dsv/write.hpp>
+#endif
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace simplify
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+    /*!
+        \brief Small wrapper around a point, with an extra member "included"
+        \details
+            It has a const-reference to the original point (so no copy here)
+        \tparam the enclosed point type
+    */
+    template<typename Point>
+    struct douglas_peucker_point
+    {
+        Point const& p;
+        bool included;
+
+        inline douglas_peucker_point(Point const& ap)
+            : p(ap)
+            , included(false)
+        {}
+
+        // Necessary for proper compilation
+        inline douglas_peucker_point<Point> operator=(douglas_peucker_point<Point> const& )
+        {
+            return douglas_peucker_point<Point>(*this);
+        }
+    };
+
+    template
+    <
+        typename Point,
+        typename PointDistanceStrategy,
+        typename LessCompare
+            = std::less
+                <
+                    typename strategy::distance::services::return_type
+                        <
+                            PointDistanceStrategy,
+                            Point, Point
+                        >::type
+                >
+    >
+    class douglas_peucker
+        : LessCompare // for empty base optimization
+    {
+    public :
+
+        // See also ticket 5954 https://svn.boost.org/trac/boost/ticket/5954
+        // Comparable is currently not possible here because it has to be compared to the squared of max_distance, and more.
+        // For now we have to take the real distance.
+        typedef PointDistanceStrategy distance_strategy_type;
+        // typedef typename strategy::distance::services::comparable_type<PointDistanceStrategy>::type distance_strategy_type;
+
+        typedef typename strategy::distance::services::return_type
+                         <
+                             distance_strategy_type,
+                             Point, Point
+                         >::type distance_type;
+
+        douglas_peucker()
+        {}
+
+        douglas_peucker(LessCompare const& less_compare)
+            : LessCompare(less_compare)
+        {}
+
+    private :
+        typedef detail::douglas_peucker_point<Point> dp_point_type;
+        typedef typename std::vector<dp_point_type>::iterator iterator_type;
+
+
+        LessCompare const& less() const
+        {
+            return *this;
+        }
+
+        inline void consider(iterator_type begin,
+                             iterator_type end,
+                             distance_type const& max_dist,
+                             int& n,
+                             distance_strategy_type const& ps_distance_strategy) const
+        {
+            std::size_t size = end - begin;
+
+            // size must be at least 3
+            // because we want to consider a candidate point in between
+            if (size <= 2)
+            {
+#ifdef BOOST_GEOMETRY_DEBUG_DOUGLAS_PEUCKER
+                if (begin != end)
+                {
+                    std::cout << "ignore between " << dsv(begin->p)
+                        << " and " << dsv((end - 1)->p)
+                        << " size=" << size << std::endl;
+                }
+                std::cout << "return because size=" << size << std::endl;
+#endif
+                return;
+            }
+
+            iterator_type last = end - 1;
+
+#ifdef BOOST_GEOMETRY_DEBUG_DOUGLAS_PEUCKER
+            std::cout << "find between " << dsv(begin->p)
+                << " and " << dsv(last->p)
+                << " size=" << size << std::endl;
+#endif
+
+
+            // Find most far point, compare to the current segment
+            //geometry::segment<Point const> s(begin->p, last->p);
+            distance_type md(-1.0); // any value < 0
+            iterator_type candidate;
+            for(iterator_type it = begin + 1; it != last; ++it)
+            {
+                distance_type dist = ps_distance_strategy.apply(it->p, begin->p, last->p);
+
+#ifdef BOOST_GEOMETRY_DEBUG_DOUGLAS_PEUCKER
+                std::cout << "consider " << dsv(it->p)
+                    << " at " << double(dist)
+                    << ((dist > max_dist) ? " maybe" : " no")
+                    << std::endl;
+
+#endif
+                if ( less()(md, dist) )
+                {
+                    md = dist;
+                    candidate = it;
+                }
+            }
+
+            // If a point is found, set the include flag
+            // and handle segments in between recursively
+            if ( less()(max_dist, md) )
+            {
+#ifdef BOOST_GEOMETRY_DEBUG_DOUGLAS_PEUCKER
+                std::cout << "use " << dsv(candidate->p) << std::endl;
+#endif
+
+                candidate->included = true;
+                n++;
+
+                consider(begin, candidate + 1, max_dist, n, ps_distance_strategy);
+                consider(candidate, end, max_dist, n, ps_distance_strategy);
+            }
+        }
+
+
+    public :
+
+        template <typename Range, typename OutputIterator>
+        inline OutputIterator apply(Range const& range,
+                                    OutputIterator out,
+                                    distance_type max_distance) const
+        {
+#ifdef BOOST_GEOMETRY_DEBUG_DOUGLAS_PEUCKER
+                std::cout << "max distance: " << max_distance
+                          << std::endl << std::endl;
+#endif
+            distance_strategy_type strategy;
+
+            // Copy coordinates, a vector of references to all points
+            std::vector<dp_point_type> ref_candidates(boost::begin(range),
+                            boost::end(range));
+
+            // Include first and last point of line,
+            // they are always part of the line
+            int n = 2;
+            ref_candidates.front().included = true;
+            ref_candidates.back().included = true;
+
+            // Get points, recursively, including them if they are further away
+            // than the specified distance
+            consider(boost::begin(ref_candidates), boost::end(ref_candidates), max_distance, n, strategy);
+
+            // Copy included elements to the output
+            for(typename std::vector<dp_point_type>::const_iterator it
+                            = boost::begin(ref_candidates);
+                it != boost::end(ref_candidates);
+                ++it)
+            {
+                if (it->included)
+                {
+                    // copy-coordinates does not work because OutputIterator
+                    // does not model Point (??)
+                    //geometry::convert(it->p, *out);
+                    *out = it->p;
+                    out++;
+                }
+            }
+            return out;
+        }
+
+    };
+}
+#endif // DOXYGEN_NO_DETAIL
+
+
+/*!
+\brief Implements the simplify algorithm.
+\ingroup strategies
+\details The douglas_peucker strategy simplifies a linestring, ring or
+    vector of points using the well-known Douglas-Peucker algorithm.
+\tparam Point the point type
+\tparam PointDistanceStrategy point-segment distance strategy to be used
+\note This strategy uses itself a point-segment-distance strategy which
+    can be specified
+\author Barend and Maarten, 1995/1996
+\author Barend, revised for Generic Geometry Library, 2008
+*/
+
+/*
+For the algorithm, see for example:
+ - http://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm
+ - http://www2.dcs.hull.ac.uk/CISRG/projects/Royal-Inst/demos/dp.html
+*/
+template
+<
+    typename Point,
+    typename PointDistanceStrategy
+>
+class douglas_peucker
+{
+public :
+
+    typedef PointDistanceStrategy distance_strategy_type;
+
+    typedef typename detail::douglas_peucker
+        <
+            Point,
+            PointDistanceStrategy
+        >::distance_type distance_type;
+
+    template <typename Range, typename OutputIterator>
+    static inline OutputIterator apply(Range const& range,
+                                       OutputIterator out,
+                                       distance_type const& max_distance)
+    {
+        namespace services = strategy::distance::services;
+
+        typedef typename services::comparable_type
+            <
+                PointDistanceStrategy
+            >::type comparable_distance_strategy_type;
+
+        return detail::douglas_peucker
+            <
+                Point, comparable_distance_strategy_type
+            >().apply(range, out,
+                      services::result_from_distance
+                          <
+                              comparable_distance_strategy_type, Point, Point
+                          >::apply(comparable_distance_strategy_type(),
+                                   max_distance)
+                      );
+    }
+
+};
+
+}} // namespace strategy::simplify
+
+
+namespace traits {
+
+template <typename P>
+struct point_type<geometry::strategy::simplify::detail::douglas_peucker_point<P> >
+{
+    typedef P type;
+};
+
+} // namespace traits
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGY_AGNOSTIC_SIMPLIFY_DOUGLAS_PEUCKER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/area.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/area.hpp
new file mode 100644
index 00000000000..e192d9b28bb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/area.hpp
@@ -0,0 +1,50 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_AREA_HPP
+#define BOOST_GEOMETRY_STRATEGIES_AREA_HPP
+
+#include <boost/mpl/assert.hpp>
+
+#include <boost/geometry/strategies/tags.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace area { namespace services
+{
+
+/*!
+    \brief Traits class binding a default area strategy to a coordinate system
+    \ingroup area
+    \tparam Tag tag of coordinate system
+    \tparam PointOfSegment point-type
+*/
+template <typename Tag, typename PointOfSegment>
+struct default_strategy
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_POINT_TYPE
+            , (types<PointOfSegment>)
+        );
+};
+
+
+}}} // namespace strategy::area::services
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_AREA_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/azimuth.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/azimuth.hpp
new file mode 100644
index 00000000000..8044d3933bb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/azimuth.hpp
@@ -0,0 +1,44 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2016-2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fisikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_AZIMUTH_HPP
+#define BOOST_GEOMETRY_STRATEGIES_AZIMUTH_HPP
+
+#include <boost/mpl/assert.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace azimuth { namespace services
+{
+
+/*!
+\brief Traits class binding a default azimuth strategy to a coordinate system
+\ingroup util
+\tparam CSTag tag of coordinate system
+\tparam CalculationType \tparam_calculation
+*/
+template <typename CSTag, typename CalculationType = void>
+struct default_strategy
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_TYPE
+            , (types<CSTag>)
+        );
+};
+
+}}} // namespace strategy::azimuth::services
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_AZIMUTH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/buffer.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/buffer.hpp
new file mode 100644
index 00000000000..86bdcc37bf1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/buffer.hpp
@@ -0,0 +1,103 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012-2014 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_HPP
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace buffer
+{
+
+/*
+
+   A Buffer-join strategy gets 4 input points.
+   On the two consecutive segments s1 and s2 (joining at vertex v):
+
+   The lines from parallel at s1, s2 (at buffer-distance) end/start
+   in two points perpendicular to the segments: p1 and p2.
+   These parallel lines interesct in point ip
+
+             (s2)
+              |
+              |
+              ^
+              |
+        (p2)  |(v)
+        *     +----<--- (s1)
+
+        x(ip) *(p1)
+
+
+    So, in clockwise order:
+        v : vertex point
+        p1: perpendicular on left side of segment1<1> (perp1)
+        ip: intersection point
+        p2: perpendicular on left side of segment2<0> (perp2)
+*/
+
+
+
+/*!
+\brief Enumerates options for side of buffer (left/right w.r.t. directed
+    segment)
+\ingroup enum
+\details Around a linestring, a buffer can be defined left or right.
+    Around a polygon, assumed clockwise internally,
+    a buffer is either on the left side (inflates the polygon), or on the
+    right side (deflates the polygon)
+*/
+enum buffer_side_selector { buffer_side_left, buffer_side_right };
+
+/*!
+\brief Enumerates types of pieces (parts of buffer) around geometries
+\ingroup enum
+*/
+enum piece_type
+{
+    buffered_segment,
+    buffered_join,
+    buffered_round_end,
+    buffered_flat_end,
+    buffered_point,
+    buffered_concave,   // always on the inside
+    piece_type_unknown
+};
+
+
+/*!
+\brief Enumerates types of joins
+\ingroup enum
+*/
+enum join_selector
+{
+    join_convex,
+    join_concave,
+    join_continue, // collinear, next segment touches previous segment
+    join_spike     // collinear, with overlap, next segment goes back
+};
+
+/*!
+\brief Enumerates types of result codes from buffer strategies
+\ingroup enum
+*/
+enum result_code
+{
+    result_normal,
+    result_error_numerical,
+    result_no_output
+};
+
+
+}} // namespace strategy::buffer
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/area_surveyor.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/area_surveyor.hpp
new file mode 100644
index 00000000000..b3f19b1b1ed
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/area_surveyor.hpp
@@ -0,0 +1,152 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2016, 2017.
+// Modifications copyright (c) 2016-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_AREA_SURVEYOR_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_AREA_SURVEYOR_HPP
+
+
+#include <boost/mpl/if.hpp>
+
+//#include <boost/geometry/arithmetic/determinant.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/strategies/area.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace area
+{
+
+/*!
+\brief Area calculation for cartesian points
+\ingroup strategies
+\details Calculates area using the Surveyor's formula, a well-known
+    triangulation algorithm
+\tparam PointOfSegment \tparam_segment_point
+\tparam CalculationType \tparam_calculation
+
+\qbk{
+[heading See also]
+[link geometry.reference.algorithms.area.area_2_with_strategy area (with strategy)]
+}
+
+*/
+template
+<
+    typename PointOfSegment,
+    typename CalculationType = void
+>
+class surveyor
+{
+public :
+    // If user specified a calculation type, use that type,
+    //   whatever it is and whatever the point-type is.
+    // Else, use the pointtype, but at least double
+    typedef typename
+        boost::mpl::if_c
+        <
+            boost::is_void<CalculationType>::type::value,
+            typename select_most_precise
+            <
+                typename coordinate_type<PointOfSegment>::type,
+                double
+            >::type,
+            CalculationType
+        >::type return_type;
+
+
+private :
+
+    class summation
+    {
+        friend class surveyor;
+
+        return_type sum;
+    public :
+
+        inline summation() : sum(return_type())
+        {
+            // Strategy supports only 2D areas
+            assert_dimension<PointOfSegment, 2>();
+        }
+        inline return_type area() const
+        {
+            return_type result = sum;
+            return_type const two = 2;
+            result /= two;
+            return result;
+        }
+    };
+
+public :
+    typedef summation state_type;
+    typedef PointOfSegment segment_point_type;
+
+    static inline void apply(PointOfSegment const& p1,
+                PointOfSegment const& p2,
+                summation& state)
+    {
+        // Below formulas are equivalent, however the two lower ones
+        // suffer less from accuracy loss for great values of coordinates.
+        // See: https://svn.boost.org/trac/boost/ticket/11928
+
+        // SUM += x2 * y1 - x1 * y2;
+        // state.sum += detail::determinant<return_type>(p2, p1);
+
+        // SUM += (x2 - x1) * (y2 + y1)
+        //state.sum += (return_type(get<0>(p2)) - return_type(get<0>(p1)))
+        //           * (return_type(get<1>(p2)) + return_type(get<1>(p1)));
+
+        // SUM += (x1 + x2) * (y1 - y2)
+        state.sum += (return_type(get<0>(p1)) + return_type(get<0>(p2)))
+                   * (return_type(get<1>(p1)) - return_type(get<1>(p2)));
+    }
+
+    static inline return_type result(summation const& state)
+    {
+        return state.area();
+    }
+
+};
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+    template <typename Point>
+    struct default_strategy<cartesian_tag, Point>
+    {
+        typedef strategy::area::surveyor<Point> type;
+    };
+
+} // namespace services
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::area
+
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_AREA_SURVEYOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/azimuth.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/azimuth.hpp
new file mode 100644
index 00000000000..62f804e8f50
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/azimuth.hpp
@@ -0,0 +1,49 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2016-2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fisikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_AZIMUTH_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_AZIMUTH_HPP
+
+#include <boost/geometry/core/tags.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace azimuth
+{
+
+template
+<
+    typename CalculationType = void
+>
+class cartesian
+{};
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+template <typename CalculationType>
+struct default_strategy<cartesian_tag, CalculationType>
+{
+    typedef strategy::azimuth::cartesian<CalculationType> type;
+};
+
+}
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+}} // namespace strategy::azimuth
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_AZIMUTH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/box_in_box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/box_in_box.hpp
new file mode 100644
index 00000000000..4641aafcb18
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/box_in_box.hpp
@@ -0,0 +1,311 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2015 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2015, 2016, 2017.
+// Modifications copyright (c) 2016-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BOX_IN_BOX_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BOX_IN_BOX_HPP
+
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/strategies/covered_by.hpp>
+#include <boost/geometry/strategies/within.hpp>
+#include <boost/geometry/util/normalize_spheroidal_coordinates.hpp>
+
+
+namespace boost { namespace geometry { namespace strategy
+{
+
+
+namespace within
+{
+
+
+struct box_within_coord
+{
+    template <typename BoxContainedValue, typename BoxContainingValue>
+    static inline bool apply(BoxContainedValue const& bed_min,
+                             BoxContainedValue const& bed_max,
+                             BoxContainingValue const& bing_min,
+                             BoxContainingValue const& bing_max)
+    {
+        return bing_min <= bed_min && bed_max <= bing_max // contained in containing
+            && bed_min < bed_max;                         // interiors overlap
+    }
+};
+
+
+struct box_covered_by_coord
+{
+    template <typename BoxContainedValue, typename BoxContainingValue>
+    static inline bool apply(BoxContainedValue const& bed_min,
+                             BoxContainedValue const& bed_max,
+                             BoxContainingValue const& bing_min,
+                             BoxContainingValue const& bing_max)
+    {
+        return bed_min >= bing_min && bed_max <= bing_max;
+    }
+};
+
+
+template <typename Geometry, std::size_t Dimension, typename CSTag>
+struct box_within_range
+    : box_within_coord
+{};
+
+
+template <typename Geometry, std::size_t Dimension, typename CSTag>
+struct box_covered_by_range
+    : box_covered_by_coord
+{};
+
+
+struct box_within_longitude_diff
+{
+    template <typename CalcT>
+    static inline bool apply(CalcT const& diff_ed)
+    {
+        return diff_ed > CalcT(0);
+    }
+};
+
+struct box_covered_by_longitude_diff
+{
+    template <typename CalcT>
+    static inline bool apply(CalcT const&)
+    {
+        return true;
+    }
+};
+
+template <typename Geometry,
+          typename CoordCheck,
+          typename InteriorCheck>
+struct box_longitude_range
+{
+    template <typename BoxContainedValue, typename BoxContainingValue>
+    static inline bool apply(BoxContainedValue const& bed_min,
+                             BoxContainedValue const& bed_max,
+                             BoxContainingValue const& bing_min,
+                             BoxContainingValue const& bing_max)
+    {
+        typedef typename select_most_precise
+            <
+                BoxContainedValue,
+                BoxContainingValue
+            >::type calc_t;
+        typedef typename coordinate_system<Geometry>::type::units units_t;
+        typedef math::detail::constants_on_spheroid<calc_t, units_t> constants;
+
+        if (CoordCheck::apply(bed_min, bed_max, bing_min, bing_max))
+        {
+            return true;
+        }
+
+        // min <= max <=> diff >= 0
+        calc_t const diff_ed = bed_max - bed_min;
+        calc_t const diff_ing = bing_max - bing_min;
+        
+        // if containing covers the whole globe it contains all
+        if (diff_ing >= constants::period())
+        {
+            return true;
+        }
+
+        // if containing is smaller it cannot contain
+        // and check interior (within vs covered_by)
+        if (diff_ing < diff_ed || ! InteriorCheck::apply(diff_ed))
+        {
+            return false;
+        }
+
+        // calculate positive longitude translation with bing_min as origin
+        calc_t const diff_min = math::longitude_distance_unsigned<units_t>(bing_min, bed_min);
+
+        // max of contained translated into the containing origin must be lesser than max of containing
+        return bing_min + diff_min + diff_ed <= bing_max
+            /*|| bing_max - diff_min - diff_ed >= bing_min*/;
+    }
+};
+
+
+// spherical_equatorial_tag, spherical_polar_tag and geographic_cat are casted to spherical_tag
+template <typename Geometry>
+struct box_within_range<Geometry, 0, spherical_tag>
+    : box_longitude_range<Geometry, box_within_coord, box_within_longitude_diff>
+{};
+
+
+template <typename Geometry>
+struct box_covered_by_range<Geometry, 0, spherical_tag>
+    : box_longitude_range<Geometry, box_covered_by_coord, box_covered_by_longitude_diff>
+{};
+
+
+template
+<
+    template <typename, std::size_t, typename> class SubStrategy,
+    typename Box1,
+    typename Box2,
+    std::size_t Dimension,
+    std::size_t DimensionCount
+>
+struct relate_box_box_loop
+{
+    static inline bool apply(Box1 const& b_contained, Box2 const& b_containing)
+    {
+        assert_dimension_equal<Box1, Box2>();
+        typedef typename tag_cast<typename cs_tag<Box1>::type, spherical_tag>::type cs_tag_t;
+
+        if (! SubStrategy<Box1, Dimension, cs_tag_t>::apply(
+                    get<min_corner, Dimension>(b_contained),
+                    get<max_corner, Dimension>(b_contained),
+                    get<min_corner, Dimension>(b_containing),
+                    get<max_corner, Dimension>(b_containing)
+                )
+            )
+        {
+            return false;
+        }
+
+        return relate_box_box_loop
+            <
+                SubStrategy,
+                Box1, Box2,
+                Dimension + 1, DimensionCount
+            >::apply(b_contained, b_containing);
+    }
+};
+
+template
+<
+    template <typename, std::size_t, typename> class SubStrategy,
+    typename Box1,
+    typename Box2,
+    std::size_t DimensionCount
+>
+struct relate_box_box_loop<SubStrategy, Box1, Box2, DimensionCount, DimensionCount>
+{
+    static inline bool apply(Box1 const& , Box2 const& )
+    {
+        return true;
+    }
+};
+
+template
+<
+    typename Box1,
+    typename Box2,
+    template <typename, std::size_t, typename> class SubStrategy = box_within_range
+>
+struct box_in_box
+{
+    static inline bool apply(Box1 const& box1, Box2 const& box2)
+    {
+        return relate_box_box_loop
+            <
+                SubStrategy,
+                Box1, Box2, 0, dimension<Box1>::type::value
+            >::apply(box1, box2);
+    }
+};
+
+
+} // namespace within
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+namespace within { namespace services
+{
+
+template <typename BoxContained, typename BoxContaining>
+struct default_strategy
+    <
+        BoxContained, BoxContaining,
+        box_tag, box_tag,
+        areal_tag, areal_tag,
+        cartesian_tag, cartesian_tag
+    >
+{
+    typedef within::box_in_box<BoxContained, BoxContaining> type;
+};
+
+// spherical_equatorial_tag, spherical_polar_tag and geographic_cat are casted to spherical_tag
+template <typename BoxContained, typename BoxContaining>
+struct default_strategy
+    <
+        BoxContained, BoxContaining,
+        box_tag, box_tag,
+        areal_tag, areal_tag,
+        spherical_tag, spherical_tag
+    >
+{
+    typedef within::box_in_box<BoxContained, BoxContaining> type;
+};
+
+
+}} // namespace within::services
+
+namespace covered_by { namespace services
+{
+
+template <typename BoxContained, typename BoxContaining>
+struct default_strategy
+    <
+        BoxContained, BoxContaining,
+        box_tag, box_tag,
+        areal_tag, areal_tag,
+        cartesian_tag, cartesian_tag
+    >
+{
+    typedef within::box_in_box
+                <
+                    BoxContained, BoxContaining,
+                    within::box_covered_by_range
+                > type;
+};
+
+// spherical_equatorial_tag, spherical_polar_tag and geographic_cat are casted to spherical_tag
+template <typename BoxContained, typename BoxContaining>
+struct default_strategy
+    <
+        BoxContained, BoxContaining,
+        box_tag, box_tag,
+        areal_tag, areal_tag,
+        spherical_tag, spherical_tag
+    >
+{
+    typedef within::box_in_box
+                <
+                    BoxContained, BoxContaining,
+                    within::box_covered_by_range
+                > type;
+};
+
+
+}} // namespace covered_by::services
+
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}}} // namespace boost::geometry::strategy
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BOX_IN_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_end_flat.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_end_flat.hpp
new file mode 100644
index 00000000000..c01cf4df852
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_end_flat.hpp
@@ -0,0 +1,112 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012-2014 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_END_FLAT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_END_FLAT_HPP
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/strategies/tags.hpp>
+#include <boost/geometry/strategies/side.hpp>
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+
+#include <boost/geometry/strategies/buffer.hpp>
+
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace buffer
+{
+
+
+/*!
+\brief Let the buffer create flat ends
+\ingroup strategies
+\details This strategy can be used as EndStrategy for the buffer algorithm.
+    It creates a flat end for each linestring-end. It can be applied
+    for (multi)linestrings. Also it is applicable for spikes in (multi)polygons.
+    This strategy is only applicable for Cartesian coordinate systems.
+
+\qbk{
+[heading Example]
+[buffer_end_flat]
+[heading Output]
+[$img/strategies/buffer_end_flat.png]
+[heading See also]
+\* [link geometry.reference.algorithms.buffer.buffer_7_with_strategies buffer (with strategies)]
+\* [link geometry.reference.strategies.strategy_buffer_end_round end_round]
+}
+ */
+class end_flat
+{
+
+public :
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+    //! Fills output_range with a flat end
+    template <typename Point, typename RangeOut, typename DistanceStrategy>
+    inline void apply(Point const& penultimate_point,
+                Point const& perp_left_point,
+                Point const& ultimate_point,
+                Point const& perp_right_point,
+                buffer_side_selector side,
+                DistanceStrategy const& distance,
+                RangeOut& range_out) const
+    {
+        typedef typename coordinate_type<Point>::type coordinate_type;
+
+        typedef typename geometry::select_most_precise
+        <
+            coordinate_type,
+            double
+        >::type promoted_type;
+
+        promoted_type const dist_left = distance.apply(penultimate_point, ultimate_point, buffer_side_left);
+        promoted_type const dist_right = distance.apply(penultimate_point, ultimate_point, buffer_side_right);
+
+        bool reversed = (side == buffer_side_left && dist_right < 0 && -dist_right > dist_left)
+                    || (side == buffer_side_right && dist_left < 0 && -dist_left > dist_right)
+                    ;
+        if (reversed)
+        {
+            range_out.push_back(perp_right_point);
+            range_out.push_back(perp_left_point);
+        }
+        else
+        {
+            range_out.push_back(perp_left_point);
+            range_out.push_back(perp_right_point);
+        }
+        // Don't add the ultimate_point (endpoint of the linestring).
+        // The buffer might be generated completely at one side.
+        // In other cases it does no harm but is further useless
+    }
+
+    template <typename NumericType>
+    static inline NumericType max_distance(NumericType const& distance)
+    {
+        return distance;
+    }
+
+    //! Returns the piece_type (flat end)
+    static inline piece_type get_piece_type()
+    {
+        return buffered_flat_end;
+    }
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+};
+
+
+}} // namespace strategy::buffer
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_END_FLAT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_end_round.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_end_round.hpp
new file mode 100644
index 00000000000..3d7d5bb467d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_end_round.hpp
@@ -0,0 +1,178 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_END_ROUND_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_END_ROUND_HPP
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/strategies/tags.hpp>
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+
+#include <boost/geometry/strategies/buffer.hpp>
+
+
+#include <boost/geometry/io/wkt/wkt.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace buffer
+{
+
+
+/*!
+\brief Let the buffer create rounded ends
+\ingroup strategies
+\details This strategy can be used as EndStrategy for the buffer algorithm.
+    It creates a rounded end for each linestring-end. It can be applied
+    for (multi)linestrings. Also it is applicable for spikes in (multi)polygons.
+    This strategy is only applicable for Cartesian coordinate systems.
+
+\qbk{
+[heading Example]
+[buffer_end_round]
+[heading Output]
+[$img/strategies/buffer_end_round.png]
+[heading See also]
+\* [link geometry.reference.algorithms.buffer.buffer_7_with_strategies buffer (with strategies)]
+\* [link geometry.reference.strategies.strategy_buffer_end_flat end_flat]
+}
+ */
+class end_round
+{
+private :
+    std::size_t m_points_per_circle;
+
+    template
+    <
+        typename Point,
+        typename PromotedType,
+        typename DistanceType,
+        typename RangeOut
+    >
+    inline void generate_points(Point const& point,
+                PromotedType alpha, // by value
+                DistanceType const& buffer_distance,
+                RangeOut& range_out) const
+    {
+        PromotedType const two_pi = geometry::math::two_pi<PromotedType>();
+
+        std::size_t point_buffer_count = m_points_per_circle;
+
+        PromotedType const diff = two_pi / PromotedType(point_buffer_count);
+
+        // For half circle:
+        point_buffer_count /= 2;
+        point_buffer_count++;
+
+        for (std::size_t i = 0; i < point_buffer_count; i++, alpha -= diff)
+        {
+            typename boost::range_value<RangeOut>::type p;
+            set<0>(p, get<0>(point) + buffer_distance * cos(alpha));
+            set<1>(p, get<1>(point) + buffer_distance * sin(alpha));
+            range_out.push_back(p);
+        }
+    }
+
+    template <typename T, typename P1, typename P2>
+    static inline T calculate_angle(P1 const& from_point, P2 const& to_point)
+    {
+        typedef P1 vector_type;
+        vector_type v = from_point;
+        geometry::subtract_point(v, to_point);
+        return atan2(geometry::get<1>(v), geometry::get<0>(v));
+    }
+
+public :
+
+    //! \brief Constructs the strategy
+    //! \param points_per_circle points which would be used for a full circle
+    //! (if points_per_circle is smaller than 4, it is internally set to 4)
+    explicit inline end_round(std::size_t points_per_circle = 90)
+        : m_points_per_circle((points_per_circle < 4u) ? 4u : points_per_circle)
+    {}
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+
+    //! Fills output_range with a flat end
+    template <typename Point, typename RangeOut, typename DistanceStrategy>
+    inline void apply(Point const& penultimate_point,
+                Point const& perp_left_point,
+                Point const& ultimate_point,
+                Point const& perp_right_point,
+                buffer_side_selector side,
+                DistanceStrategy const& distance,
+                RangeOut& range_out) const
+    {
+        typedef typename coordinate_type<Point>::type coordinate_type;
+
+        typedef typename geometry::select_most_precise
+        <
+            coordinate_type,
+            double
+        >::type promoted_type;
+
+        promoted_type const alpha = calculate_angle<promoted_type>(perp_left_point, ultimate_point);
+
+        promoted_type const dist_left = distance.apply(penultimate_point, ultimate_point, buffer_side_left);
+        promoted_type const dist_right = distance.apply(penultimate_point, ultimate_point, buffer_side_right);
+        if (geometry::math::equals(dist_left, dist_right))
+        {
+            generate_points(ultimate_point, alpha, dist_left, range_out);
+        }
+        else
+        {
+            promoted_type const two = 2.0;
+            promoted_type dist_half_diff = (dist_left - dist_right) / two;
+
+            if (side == buffer_side_right)
+            {
+                dist_half_diff = -dist_half_diff;
+            }
+
+            Point shifted_point;
+            set<0>(shifted_point, get<0>(ultimate_point) + dist_half_diff * cos(alpha));
+            set<1>(shifted_point, get<1>(ultimate_point) + dist_half_diff * sin(alpha));
+            generate_points(shifted_point, alpha, (dist_left + dist_right) / two, range_out);
+        }
+
+        if (m_points_per_circle % 2 == 1)
+        {
+            // For a half circle, if the number of points is not even,
+            // we should insert the end point too, to generate a full cap
+            range_out.push_back(perp_right_point);
+        }
+    }
+
+    template <typename NumericType>
+    static inline NumericType max_distance(NumericType const& distance)
+    {
+        return distance;
+    }
+
+    //! Returns the piece_type (flat end)
+    static inline piece_type get_piece_type()
+    {
+        return buffered_round_end;
+    }
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+};
+
+
+}} // namespace strategy::buffer
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_END_ROUND_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_join_miter.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_join_miter.hpp
new file mode 100644
index 00000000000..5358156f6d2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_join_miter.hpp
@@ -0,0 +1,142 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012-2014 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_JOIN_MITER_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_JOIN_MITER_HPP
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/policies/compare.hpp>
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+
+#include <boost/geometry/strategies/buffer.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace buffer
+{
+
+/*!
+\brief Let the buffer create sharp corners
+\ingroup strategies
+\details This strategy can be used as JoinStrategy for the buffer algorithm.
+    It creates a sharp corners around each convex vertex. It can be applied
+    for (multi)linestrings and (multi)polygons.
+    If corners are sharp by themselves, the miters might become very long. Therefore
+    there is a limit (miter_limit), in terms of the used distance, which limits
+    their length. The miter is not changed to a bevel form (as done in some
+    other software), it is just adapted to the specified miter_limit but keeps
+    its miter form.
+    If the buffer distance is 5.0, and the miter limit is 2.0, generated points
+    will be located at a distance of at most 10.0 (2*5) units.
+    This strategy is only applicable for Cartesian coordinate systems.
+
+\qbk{
+[heading Example]
+[buffer_join_miter]
+[heading Output]
+[$img/strategies/buffer_join_miter.png]
+[heading See also]
+\* [link geometry.reference.algorithms.buffer.buffer_7_with_strategies buffer (with strategies)]
+\* [link geometry.reference.strategies.strategy_buffer_join_round join_round]
+}
+ */
+class join_miter
+{
+public:
+
+    //! \brief Constructs the strategy
+    //! \param miter_limit The miter limit, to avoid excessively long miters around sharp corners
+    explicit inline join_miter(double miter_limit = 5.0)
+        : m_miter_limit(valid_limit(miter_limit))
+    {}
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+    //! Fills output_range with a sharp shape around a vertex
+    template <typename Point, typename DistanceType, typename RangeOut>
+    inline bool apply(Point const& ip, Point const& vertex,
+                Point const& perp1, Point const& perp2,
+                DistanceType const& buffer_distance,
+                RangeOut& range_out) const
+    {
+        geometry::equal_to<Point> equals;
+        if (equals(ip, vertex))
+        {
+            return false;
+        }
+        if (equals(perp1, perp2))
+        {
+            return false;
+        }
+
+        typedef typename coordinate_type<Point>::type coordinate_type;
+        typedef typename geometry::select_most_precise
+        <
+            coordinate_type,
+            double
+        >::type promoted_type;
+
+        Point p = ip;
+
+        // Check the distance ip-vertex (= miter distance)
+        // (We calculate it manually (not using Pythagoras strategy) to reuse
+        //  dx and dy)
+        coordinate_type const dx = get<0>(p) - get<0>(vertex);
+        coordinate_type const dy = get<1>(p) - get<1>(vertex);
+
+        promoted_type const distance = geometry::math::sqrt(dx * dx + dy * dy);
+
+        promoted_type const max_distance
+            = m_miter_limit * geometry::math::abs(buffer_distance);
+
+        if (distance > max_distance)
+        {
+            BOOST_GEOMETRY_ASSERT(distance != 0.0);
+
+            promoted_type const proportion = max_distance / distance;
+            set<0>(p, get<0>(vertex) + dx * proportion);
+            set<1>(p, get<1>(vertex) + dy * proportion);
+        }
+
+        range_out.push_back(perp1);
+        range_out.push_back(p);
+        range_out.push_back(perp2);
+        return true;
+    }
+
+    template <typename NumericType>
+    inline NumericType max_distance(NumericType const& distance) const
+    {
+        return distance * m_miter_limit;
+    }
+
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+private :
+    double valid_limit(double miter_limit) const
+    {
+        if (miter_limit < 1.0)
+        {
+            // It should always exceed the buffer distance
+            miter_limit = 1.0;
+        }
+        return miter_limit;
+    }
+
+    double m_miter_limit;
+};
+
+}} // namespace strategy::buffer
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_JOIN_MITER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_join_round.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_join_round.hpp
new file mode 100644
index 00000000000..e1a433e1eeb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_join_round.hpp
@@ -0,0 +1,187 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_JOIN_ROUND_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_JOIN_ROUND_HPP
+
+#include <algorithm>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/policies/compare.hpp>
+#include <boost/geometry/strategies/buffer.hpp>
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+
+#ifdef BOOST_GEOMETRY_DEBUG_BUFFER_WARN
+#include <iostream>
+#include <boost/geometry/io/wkt/wkt.hpp>
+#endif
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace buffer
+{
+
+/*!
+\brief Let the buffer create rounded corners
+\ingroup strategies
+\details This strategy can be used as JoinStrategy for the buffer algorithm.
+    It creates a rounded corners around each convex vertex. It can be applied
+    for (multi)linestrings and (multi)polygons.
+    This strategy is only applicable for Cartesian coordinate systems.
+
+\qbk{
+[heading Example]
+[buffer_join_round]
+[heading Output]
+[$img/strategies/buffer_join_round.png]
+[heading See also]
+\* [link geometry.reference.algorithms.buffer.buffer_7_with_strategies buffer (with strategies)]
+\* [link geometry.reference.strategies.strategy_buffer_join_miter join_miter]
+}
+ */
+class join_round
+{
+public :
+
+    //! \brief Constructs the strategy
+    //! \param points_per_circle points which would be used for a full circle
+    explicit inline join_round(std::size_t points_per_circle = 90)
+        : m_points_per_circle(points_per_circle)
+    {}
+
+private :
+    template
+    <
+        typename PromotedType,
+        typename Point,
+        typename DistanceType,
+        typename RangeOut
+    >
+    inline void generate_points(Point const& vertex,
+                Point const& perp1, Point const& perp2,
+                DistanceType const& buffer_distance,
+                RangeOut& range_out) const
+    {
+        PromotedType const dx1 = get<0>(perp1) - get<0>(vertex);
+        PromotedType const dy1 = get<1>(perp1) - get<1>(vertex);
+        PromotedType const dx2 = get<0>(perp2) - get<0>(vertex);
+        PromotedType const dy2 = get<1>(perp2) - get<1>(vertex);
+
+        PromotedType const two_pi = geometry::math::two_pi<PromotedType>();
+
+        PromotedType const angle1 = atan2(dy1, dx1);
+        PromotedType angle2 = atan2(dy2, dx2);
+        while (angle2 > angle1)
+        {
+            angle2 -= two_pi;
+        }
+        PromotedType const angle_diff = angle1 - angle2;
+
+        // Divide the angle into an integer amount of steps to make it
+        // visually correct also for a low number of points / circle
+
+        // If a full circle is divided into 3 parts (e.g. angle is 125),
+        // the one point in between must still be generated
+        // The calculation below:
+        // - generates 1 point  in between for an angle of 125 based on 3 points
+        // - generates 0 points in between for an angle of 90  based on 4 points
+
+        std::size_t const n = (std::max)(static_cast<std::size_t>(
+            ceil(m_points_per_circle * angle_diff / two_pi)), std::size_t(1));
+
+        PromotedType const diff = angle_diff / static_cast<PromotedType>(n);
+        PromotedType a = angle1 - diff;
+
+        // Walk to n - 1 to avoid generating the last point
+        for (std::size_t i = 0; i < n - 1; i++, a -= diff)
+        {
+            Point p;
+            set<0>(p, get<0>(vertex) + buffer_distance * cos(a));
+            set<1>(p, get<1>(vertex) + buffer_distance * sin(a));
+            range_out.push_back(p);
+        }
+    }
+
+public :
+
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+    //! Fills output_range with a rounded shape around a vertex
+    template <typename Point, typename DistanceType, typename RangeOut>
+    inline bool apply(Point const& ip, Point const& vertex,
+                Point const& perp1, Point const& perp2,
+                DistanceType const& buffer_distance,
+                RangeOut& range_out) const
+    {
+        typedef typename coordinate_type<Point>::type coordinate_type;
+        typedef typename boost::range_value<RangeOut>::type output_point_type;
+
+        typedef typename geometry::select_most_precise
+            <
+                typename geometry::select_most_precise
+                    <
+                        coordinate_type,
+                        typename geometry::coordinate_type<output_point_type>::type
+                    >::type,
+                double
+            >::type promoted_type;
+
+        geometry::equal_to<Point> equals;
+        if (equals(perp1, perp2))
+        {
+#ifdef BOOST_GEOMETRY_DEBUG_BUFFER_WARN
+            std::cout << "Corner for equal points " << geometry::wkt(ip) << " " << geometry::wkt(perp1) << std::endl;
+#endif
+            return false;
+        }
+
+        // Generate 'vectors'
+        coordinate_type vix = (get<0>(ip) - get<0>(vertex));
+        coordinate_type viy = (get<1>(ip) - get<1>(vertex));
+
+        promoted_type length_i = geometry::math::sqrt(vix * vix + viy * viy);
+        DistanceType const bd = geometry::math::abs(buffer_distance);
+        promoted_type prop = bd / length_i;
+
+        Point bp;
+        set<0>(bp, get<0>(vertex) + vix * prop);
+        set<1>(bp, get<1>(vertex) + viy * prop);
+
+        range_out.push_back(perp1);
+        generate_points<promoted_type>(vertex, perp1, perp2, bd, range_out);
+        range_out.push_back(perp2);
+        return true;
+    }
+
+    template <typename NumericType>
+    static inline NumericType max_distance(NumericType const& distance)
+    {
+        return distance;
+    }
+
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+private :
+    std::size_t m_points_per_circle;
+};
+
+
+}} // namespace strategy::buffer
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_JOIN_ROUND_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_join_round_by_divide.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_join_round_by_divide.hpp
new file mode 100644
index 00000000000..ed3a010cd55
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_join_round_by_divide.hpp
@@ -0,0 +1,154 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012-2014 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_JOIN_ROUND_BY_DIVIDE_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_JOIN_ROUND_BY_DIVIDE_HPP
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/policies/compare.hpp>
+#include <boost/geometry/strategies/buffer.hpp>
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+
+#ifdef BOOST_GEOMETRY_DEBUG_BUFFER_WARN
+#include <boost/geometry/io/wkt/wkt.hpp>
+#endif
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace buffer
+{
+
+
+class join_round_by_divide
+{
+public :
+
+    inline join_round_by_divide(std::size_t max_level = 4)
+        : m_max_level(max_level)
+    {}
+
+    template
+    <
+        typename PromotedType,
+        typename Point,
+        typename DistanceType,
+        typename RangeOut
+    >
+    inline void mid_points(Point const& vertex,
+                Point const& p1, Point const& p2,
+                DistanceType const& buffer_distance,
+                RangeOut& range_out,
+                std::size_t level = 1) const
+    {
+        typedef typename coordinate_type<Point>::type coordinate_type;
+
+        // Generate 'vectors'
+        coordinate_type const vp1_x = get<0>(p1) - get<0>(vertex);
+        coordinate_type const vp1_y = get<1>(p1) - get<1>(vertex);
+
+        coordinate_type const vp2_x = (get<0>(p2) - get<0>(vertex));
+        coordinate_type const vp2_y = (get<1>(p2) - get<1>(vertex));
+
+        // Average them to generate vector in between
+        coordinate_type const two = 2;
+        coordinate_type const v_x = (vp1_x + vp2_x) / two;
+        coordinate_type const v_y = (vp1_y + vp2_y) / two;
+
+        PromotedType const length2 = geometry::math::sqrt(v_x * v_x + v_y * v_y);
+
+        PromotedType prop = buffer_distance / length2;
+
+        Point mid_point;
+        set<0>(mid_point, get<0>(vertex) + v_x * prop);
+        set<1>(mid_point, get<1>(vertex) + v_y * prop);
+
+        if (level < m_max_level)
+        {
+            mid_points<PromotedType>(vertex, p1, mid_point, buffer_distance, range_out, level + 1);
+        }
+        range_out.push_back(mid_point);
+        if (level < m_max_level)
+        {
+            mid_points<PromotedType>(vertex, mid_point, p2, buffer_distance, range_out, level + 1);
+        }
+    }
+
+    template <typename Point, typename DistanceType, typename RangeOut>
+    inline bool apply(Point const& ip, Point const& vertex,
+                Point const& perp1, Point const& perp2,
+                DistanceType const& buffer_distance,
+                RangeOut& range_out) const
+    {
+        typedef typename coordinate_type<Point>::type coordinate_type;
+
+        typedef typename geometry::select_most_precise
+            <
+                coordinate_type,
+                double
+            >::type promoted_type;
+
+        geometry::equal_to<Point> equals;
+
+        if (equals(perp1, perp2))
+        {
+#ifdef BOOST_GEOMETRY_DEBUG_BUFFER_WARN
+            std::cout << "Corner for equal points " << geometry::wkt(ip) << " " << geometry::wkt(perp1) << std::endl;
+#endif
+            return false;
+        }
+
+        // Generate 'vectors'
+        coordinate_type const vix = (get<0>(ip) - get<0>(vertex));
+        coordinate_type const viy = (get<1>(ip) - get<1>(vertex));
+
+        promoted_type const length_i = geometry::math::sqrt(vix * vix + viy * viy);
+
+        promoted_type const bd = geometry::math::abs(buffer_distance);
+        promoted_type prop = bd / length_i;
+
+        Point bp;
+        set<0>(bp, get<0>(vertex) + vix * prop);
+        set<1>(bp, get<1>(vertex) + viy * prop);
+
+        range_out.push_back(perp1);
+
+        if (m_max_level > 1)
+        {
+            mid_points<promoted_type>(vertex, perp1, bp, bd, range_out);
+            range_out.push_back(bp);
+            mid_points<promoted_type>(vertex, bp, perp2, bd, range_out);
+        }
+        else if (m_max_level == 1)
+        {
+            range_out.push_back(bp);
+        }
+
+        range_out.push_back(perp2);
+        return true;
+    }
+
+    template <typename NumericType>
+    static inline NumericType max_distance(NumericType const& distance)
+    {
+        return distance;
+    }
+
+private :
+    std::size_t m_max_level;
+};
+
+
+}} // namespace strategy::buffer
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_JOIN_ROUND_BY_DIVIDE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_point_circle.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_point_circle.hpp
new file mode 100644
index 00000000000..f2898571776
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_point_circle.hpp
@@ -0,0 +1,115 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_POINT_CIRCLE_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_POINT_CIRCLE_HPP
+
+#include <cstddef>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/strategies/buffer.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace buffer
+{
+
+/*!
+\brief Create a circular buffer around a point
+\ingroup strategies
+\details This strategy can be used as PointStrategy for the buffer algorithm.
+    It creates a circular buffer around a point. It can be applied
+    for points and multi_points, but also for a linestring (if it is degenerate,
+    so consisting of only one point) and for polygons (if it is degenerate).
+    This strategy is only applicable for Cartesian coordinate systems.
+
+\qbk{
+[heading Example]
+[buffer_point_circle]
+[heading Output]
+[$img/strategies/buffer_point_circle.png]
+[heading See also]
+\* [link geometry.reference.algorithms.buffer.buffer_7_with_strategies buffer (with strategies)]
+\* [link geometry.reference.strategies.strategy_buffer_point_square point_square]
+}
+ */
+class point_circle
+{
+public :
+    //! \brief Constructs the strategy
+    //! \param count number of points for the created circle (if count
+    //! is smaller than 3, count is internally set to 3)
+    explicit point_circle(std::size_t count = 90)
+        : m_count((count < 3u) ? 3u : count)
+    {}
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+    //! Fills output_range with a circle around point using distance_strategy
+    template
+    <
+        typename Point,
+        typename OutputRange,
+        typename DistanceStrategy
+    >
+    inline void apply(Point const& point,
+                DistanceStrategy const& distance_strategy,
+                OutputRange& output_range) const
+    {
+        typedef typename boost::range_value<OutputRange>::type output_point_type;
+
+        typedef typename geometry::select_most_precise
+            <
+                typename geometry::select_most_precise
+                    <
+                        typename geometry::coordinate_type<Point>::type,
+                        typename geometry::coordinate_type<output_point_type>::type
+                    >::type,
+                double
+            >::type promoted_type;
+
+        promoted_type const buffer_distance = distance_strategy.apply(point, point,
+                        strategy::buffer::buffer_side_left);
+
+        promoted_type const two_pi = geometry::math::two_pi<promoted_type>();
+
+        promoted_type const diff = two_pi / promoted_type(m_count);
+        promoted_type a = 0;
+
+        for (std::size_t i = 0; i < m_count; i++, a -= diff)
+        {
+            output_point_type p;
+            set<0>(p, get<0>(point) + buffer_distance * cos(a));
+            set<1>(p, get<1>(point) + buffer_distance * sin(a));
+            output_range.push_back(p);
+        }
+
+        // Close it:
+        output_range.push_back(output_range.front());
+    }
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+private :
+    std::size_t m_count;
+};
+
+
+}} // namespace strategy::buffer
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_POINT_CIRCLE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_point_square.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_point_square.hpp
new file mode 100644
index 00000000000..37a90c013fa
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_point_square.hpp
@@ -0,0 +1,109 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+// Copyright (c) 2012-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_POINT_SQUARE_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_POINT_SQUARE_HPP
+
+#include <cstddef>
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/util/math.hpp>
+
+#include <boost/geometry/strategies/buffer.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace buffer
+{
+
+/*!
+\brief Create a squared form buffer around a point
+\ingroup strategies
+\details This strategy can be used as PointStrategy for the buffer algorithm.
+    It creates a square from each point, where the point lies in the center.
+    It can be applied for points and multi_points, but also for a linestring (if it is degenerate,
+    so consisting of only one point) and for polygons (if it is degenerate).
+    This strategy is only applicable for Cartesian coordinate systems.
+
+\qbk{
+[heading Example]
+[buffer_point_square]
+[heading Output]
+[$img/strategies/buffer_point_square.png]
+[heading See also]
+\* [link geometry.reference.algorithms.buffer.buffer_7_with_strategies buffer (with strategies)]
+\* [link geometry.reference.strategies.strategy_buffer_point_circle point_circle]
+}
+ */
+class point_square
+{
+    template
+    <
+        typename Point,
+        typename DistanceType,
+        typename OutputRange
+    >
+    inline void add_point(Point const& point,
+                DistanceType const& distance,
+                DistanceType const& x,
+                DistanceType const& y,
+                OutputRange& output_range) const
+    {
+        typename boost::range_value<OutputRange>::type p;
+        set<0>(p, get<0>(point) + x * distance);
+        set<1>(p, get<1>(point) + y * distance);
+        output_range.push_back(p);
+    }
+
+    template
+    <
+        typename Point,
+        typename DistanceType,
+        typename OutputRange
+    >
+    inline void add_points(Point const& point,
+                DistanceType const& distance,
+                OutputRange& output_range) const
+    {
+        add_point(point, distance, -1.0, -1.0, output_range);
+        add_point(point, distance, -1.0, +1.0, output_range);
+        add_point(point, distance, +1.0, +1.0, output_range);
+        add_point(point, distance, +1.0, -1.0, output_range);
+
+        // Close it:
+        output_range.push_back(output_range.front());
+    }
+
+public :
+
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+    //! Fills output_range with a square around point using distance_strategy
+    template
+    <
+        typename Point,
+        typename DistanceStrategy,
+        typename OutputRange
+    >
+    inline void apply(Point const& point,
+                DistanceStrategy const& distance_strategy,
+                OutputRange& output_range) const
+    {
+        add_points(point, distance_strategy.apply(point, point,
+                        strategy::buffer::buffer_side_left), output_range);
+    }
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+
+};
+
+
+}} // namespace strategy::buffer
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_POINT_SQUARE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_side_straight.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_side_straight.hpp
new file mode 100644
index 00000000000..75247377fae
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/buffer_side_straight.hpp
@@ -0,0 +1,136 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+// Copyright (c) 2012-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_SIDE_STRAIGHT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_SIDE_STRAIGHT_HPP
+
+#include <cstddef>
+
+#include <boost/math/special_functions/fpclassify.hpp>
+
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+
+#include <boost/geometry/strategies/buffer.hpp>
+#include <boost/geometry/strategies/side.hpp>
+
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace buffer
+{
+
+
+
+/*!
+\brief Let the buffer use straight sides along segments (the default)
+\ingroup strategies
+\details This strategy can be used as SideStrategy for the buffer algorithm.
+    It is currently the only provided strategy for this purpose
+
+\qbk{
+[heading Example]
+See the examples for other buffer strategies\, for example
+[link geometry.reference.strategies.strategy_buffer_join_round join_round]
+[heading See also]
+\* [link geometry.reference.algorithms.buffer.buffer_7_with_strategies buffer (with strategies)]
+}
+ */
+class side_straight
+{
+public :
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+    template
+    <
+        typename Point,
+        typename OutputRange,
+        typename DistanceStrategy
+    >
+    static inline result_code apply(
+                Point const& input_p1, Point const& input_p2,
+                buffer_side_selector side,
+                DistanceStrategy const& distance,
+                OutputRange& output_range)
+    {
+        typedef typename coordinate_type<Point>::type coordinate_type;
+        typedef typename geometry::select_most_precise
+        <
+            coordinate_type,
+            double
+        >::type promoted_type;
+
+        // Generate a block along (left or right of) the segment
+
+        // Simulate a vector d (dx,dy)
+        coordinate_type const dx = get<0>(input_p2) - get<0>(input_p1);
+        coordinate_type const dy = get<1>(input_p2) - get<1>(input_p1);
+
+        // For normalization [0,1] (=dot product d.d, sqrt)
+        promoted_type const length = geometry::math::sqrt(dx * dx + dy * dy);
+
+        if (! boost::math::isfinite(length))
+        {
+            // In case of coordinates differences of e.g. 1e300, length
+            // will overflow and we should not generate output
+#ifdef BOOST_GEOMETRY_DEBUG_BUFFER_WARN
+            std::cout << "Error in length calculation for points "
+                << geometry::wkt(input_p1) << " " << geometry::wkt(input_p2)
+                << " length: " << length << std::endl;
+#endif
+            return result_error_numerical;
+        }
+
+        if (geometry::math::equals(length, 0))
+        {
+            // Coordinates are simplified and therefore most often not equal.
+            // But if simplify is skipped, or for lines with two
+            // equal points, length is 0 and we cannot generate output.
+            return result_no_output;
+        }
+
+        promoted_type const d = distance.apply(input_p1, input_p2, side);
+
+        // Generate the normalized perpendicular p, to the left (ccw)
+        promoted_type const px = -dy / length;
+        promoted_type const py = dx / length;
+
+        if (geometry::math::equals(px, 0)
+            && geometry::math::equals(py, 0))
+        {
+            // This basically should not occur - because of the checks above.
+            // There are no unit tests triggering this condition
+#ifdef BOOST_GEOMETRY_DEBUG_BUFFER_WARN
+            std::cout << "Error in perpendicular calculation for points "
+                << geometry::wkt(input_p1) << " " << geometry::wkt(input_p2)
+                << " length: " << length
+                << " distance: " << d
+                << std::endl;
+#endif
+            return result_no_output;
+        }
+
+        output_range.resize(2);
+
+        set<0>(output_range.front(), get<0>(input_p1) + px * d);
+        set<1>(output_range.front(), get<1>(input_p1) + py * d);
+        set<0>(output_range.back(), get<0>(input_p2) + px * d);
+        set<1>(output_range.back(), get<1>(input_p2) + py * d);
+
+        return result_normal;
+    }
+#endif // DOXYGEN_SHOULD_SKIP_THIS
+};
+
+
+}} // namespace strategy::buffer
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_BUFFER_SIDE_STRAIGHT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/centroid_average.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/centroid_average.hpp
new file mode 100644
index 00000000000..c12f6e2024f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/centroid_average.hpp
@@ -0,0 +1,126 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_CENTROID_AVERAGE_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_CENTROID_AVERAGE_HPP
+
+
+#include <cstddef>
+
+#include <boost/geometry/algorithms/assign.hpp>
+#include <boost/geometry/arithmetic/arithmetic.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/strategies/centroid.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace centroid
+{
+
+
+/*!
+\brief Centroid calculation taking average of points
+\ingroup strategies
+*/
+template
+<
+    typename PointCentroid,
+    typename Point = PointCentroid
+>
+class average
+{
+private :
+
+    /*! subclass to keep state */
+    class sum
+    {
+        friend class average;
+        std::size_t count;
+        PointCentroid centroid;
+
+    public :
+        inline sum()
+            : count(0)
+        {
+            assign_zero(centroid);
+        }
+    };
+
+public :
+    typedef sum state_type;
+    typedef PointCentroid centroid_point_type;
+    typedef Point point_type;
+
+    static inline void apply(Point const& p, sum& state)
+    {
+        add_point(state.centroid, p);
+        state.count++;
+    }
+
+    static inline bool result(sum const& state, PointCentroid& centroid)
+    {
+        centroid = state.centroid;
+        if ( state.count > 0 )
+        {
+            divide_value(centroid, state.count);
+            return true;
+        }
+        return false;
+    }
+
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+namespace services
+{
+
+template <typename Point, std::size_t DimensionCount, typename Geometry>
+struct default_strategy
+<
+    cartesian_tag,
+    pointlike_tag,
+    DimensionCount,
+    Point,
+    Geometry
+>
+{
+    typedef average
+        <
+            Point,
+            typename point_type<Geometry>::type
+        > type;
+};
+
+} // namespace services
+
+#endif
+
+
+}} // namespace strategy::centroid
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_CENTROID_AVERAGE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/centroid_bashein_detmer.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/centroid_bashein_detmer.hpp
new file mode 100644
index 00000000000..d081173a3e7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/centroid_bashein_detmer.hpp
@@ -0,0 +1,258 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_CENTROID_BASHEIN_DETMER_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_CENTROID_BASHEIN_DETMER_HPP
+
+
+#include <cstddef>
+
+#include <boost/math/special_functions/fpclassify.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/numeric/conversion/cast.hpp>
+#include <boost/type_traits/is_void.hpp>
+
+#include <boost/geometry/arithmetic/determinant.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/strategies/centroid.hpp>
+#include <boost/geometry/util/select_coordinate_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+// Note: when calling the namespace "centroid", it sometimes,
+// somehow, in gcc, gives compilation problems (confusion with function centroid).
+
+namespace strategy { namespace centroid
+{
+
+
+
+/*!
+\brief Centroid calculation using algorithm Bashein / Detmer
+\ingroup strategies
+\details Calculates centroid using triangulation method published by
+    Bashein / Detmer
+\tparam Point point type of centroid to calculate
+\tparam PointOfSegment point type of segments, defaults to Point
+\tparam CalculationType \tparam_calculation
+
+\author Adapted from  "Centroid of a Polygon" by
+    Gerard Bashein and Paul R. Detmer<em>,
+in "Graphics Gems IV", Academic Press, 1994</em>
+
+
+\qbk{
+[heading See also]
+[link geometry.reference.algorithms.centroid.centroid_3_with_strategy centroid (with strategy)]
+}
+*/
+
+/*
+\par Research notes
+The algorithm gives the same results as Oracle and PostGIS but
+    differs from MySQL
+(tried 5.0.21 / 5.0.45 / 5.0.51a / 5.1.23).
+
+Without holes:
+- this:       POINT(4.06923363095238 1.65055803571429)
+- geolib:     POINT(4.07254 1.66819)
+- MySQL:      POINT(3.6636363636364  1.6272727272727)'
+- PostGIS:    POINT(4.06923363095238 1.65055803571429)
+- Oracle:           4.06923363095238 1.65055803571429
+- SQL Server: POINT(4.06923362245959 1.65055804168294)
+
+Statements:
+- \b MySQL/PostGIS: select AsText(Centroid(GeomFromText(
+    'POLYGON((2 1.3,2.4 1.7,2.8 1.8,3.4 1.2,3.7 1.6,3.4 2,4.1 3,5.3 2.6
+        ,5.4 1.2,4.9 0.8,2.9 0.7,2 1.3))')))
+- \b Oracle: select sdo_geom.sdo_centroid(sdo_geometry(2003, null, null,
+        sdo_elem_info_array(1, 1003, 1), sdo_ordinate_array(
+            2,1.3,2.4,1.7,2.8,1.8,3.4,1.2,3.7,1.6,3.4,2,4.1,3,5.3,2.6
+            ,5.4,1.2,4.9,0.8,2.9,0.7,2,1.3))
+        , mdsys.sdo_dim_array(mdsys.sdo_dim_element('x',0,10,.00000005)
+        ,mdsys.sdo_dim_element('y',0,10,.00000005)))
+        from dual
+- \b SQL Server 2008: select geometry::STGeomFromText(
+    'POLYGON((2 1.3,2.4 1.7,2.8 1.8,3.4 1.2,3.7 1.6,3.4 2,4.1 3,5.3 2.6
+        ,5.4 1.2,4.9 0.8,2.9 0.7,2 1.3))',0)
+                .STCentroid()
+                .STAsText()
+
+With holes:
+- this:       POINT(4.04663 1.6349)
+- geolib:     POINT(4.04675 1.65735)
+- MySQL:      POINT(3.6090580503834 1.607573932092)
+- PostGIS:    POINT(4.0466265060241 1.63489959839357)
+- Oracle:           4.0466265060241 1.63489959839357
+- SQL Server: POINT(4.0466264962959677 1.6348996057331333)
+
+Statements:
+- \b MySQL/PostGIS: select AsText(Centroid(GeomFromText(
+    'POLYGON((2 1.3,2.4 1.7,2.8 1.8,3.4 1.2
+        ,3.7 1.6,3.4 2,4.1 3,5.3 2.6,5.4 1.2,4.9 0.8,2.9 0.7,2 1.3)
+        ,(4 2,4.2 1.4,4.8 1.9,4.4 2.2,4 2))')));
+- \b Oracle: select sdo_geom.sdo_centroid(sdo_geometry(2003, null, null
+        , sdo_elem_info_array(1, 1003, 1, 25, 2003, 1)
+        , sdo_ordinate_array(2,1.3,2.4,1.7,2.8,1.8,3.4,1.2,3.7,1.6,3.4,
+        2,4.1,3,5.3,2.6,5.4,1.2,4.9,0.8,2.9,0.7,2,1.3,4,2, 4.2,1.4,
+        4.8,1.9, 4.4,2.2, 4,2))
+        , mdsys.sdo_dim_array(mdsys.sdo_dim_element('x',0,10,.00000005)
+        ,mdsys.sdo_dim_element('y',0,10,.00000005)))
+        from dual
+ */
+template
+<
+    typename Point,
+    typename PointOfSegment = Point,
+    typename CalculationType = void
+>
+class bashein_detmer
+{
+private :
+    // If user specified a calculation type, use that type,
+    //   whatever it is and whatever the point-type(s) are.
+    // Else, use the most appropriate coordinate type
+    //    of the two points, but at least double
+    typedef typename
+        boost::mpl::if_c
+        <
+            boost::is_void<CalculationType>::type::value,
+            typename select_most_precise
+            <
+                typename select_coordinate_type
+                    <
+                        Point,
+                        PointOfSegment
+                    >::type,
+                double
+            >::type,
+            CalculationType
+        >::type calculation_type;
+
+    /*! subclass to keep state */
+    class sums
+    {
+        friend class bashein_detmer;
+        std::size_t count;
+        calculation_type sum_a2;
+        calculation_type sum_x;
+        calculation_type sum_y;
+
+    public :
+        inline sums()
+            : count(0)
+            , sum_a2(calculation_type())
+            , sum_x(calculation_type())
+            , sum_y(calculation_type())
+        {}
+    };
+
+public :
+    typedef sums state_type;
+
+    static inline void apply(PointOfSegment const& p1,
+            PointOfSegment const& p2, sums& state)
+    {
+        /* Algorithm:
+        For each segment:
+        begin
+            ai = x1 * y2 - x2 * y1;
+            sum_a2 += ai;
+            sum_x += ai * (x1 + x2);
+            sum_y += ai * (y1 + y2);
+        end
+        return POINT(sum_x / (3 * sum_a2), sum_y / (3 * sum_a2) )
+        */
+
+        // Get coordinates and promote them to calculation_type
+        calculation_type const x1 = boost::numeric_cast<calculation_type>(get<0>(p1));
+        calculation_type const y1 = boost::numeric_cast<calculation_type>(get<1>(p1));
+        calculation_type const x2 = boost::numeric_cast<calculation_type>(get<0>(p2));
+        calculation_type const y2 = boost::numeric_cast<calculation_type>(get<1>(p2));
+        calculation_type const ai = geometry::detail::determinant<calculation_type>(p1, p2);
+        state.count++;
+        state.sum_a2 += ai;
+        state.sum_x += ai * (x1 + x2);
+        state.sum_y += ai * (y1 + y2);
+    }
+
+    static inline bool result(sums const& state, Point& centroid)
+    {
+        calculation_type const zero = calculation_type();
+        if (state.count > 0 && ! math::equals(state.sum_a2, zero))
+        {
+            calculation_type const v3 = 3;
+            calculation_type const a3 = v3 * state.sum_a2;
+
+            typedef typename geometry::coordinate_type
+                <
+                    Point
+                >::type coordinate_type;
+
+            // Prevent NaN centroid coordinates
+            if (boost::math::isfinite(a3))
+            {
+                // NOTE: above calculation_type is checked, not the centroid coordinate_type
+                // which means that the centroid can still be filled with INF
+                // if e.g. calculation_type is double and centroid contains floats
+                set<0>(centroid,
+                    boost::numeric_cast<coordinate_type>(state.sum_x / a3));
+                set<1>(centroid,
+                    boost::numeric_cast<coordinate_type>(state.sum_y / a3));
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+};
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+// Register this strategy for rings and (multi)polygons, in two dimensions
+template <typename Point, typename Geometry>
+struct default_strategy<cartesian_tag, areal_tag, 2, Point, Geometry>
+{
+    typedef bashein_detmer
+        <
+            Point,
+            typename point_type<Geometry>::type
+        > type;
+};
+
+
+} // namespace services
+
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::centroid
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_CENTROID_BASHEIN_DETMER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/centroid_weighted_length.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/centroid_weighted_length.hpp
new file mode 100644
index 00000000000..0735e925b69
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/centroid_weighted_length.hpp
@@ -0,0 +1,174 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2009-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_CENTROID_WEIGHTED_LENGTH_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_CENTROID_WEIGHTED_LENGTH_HPP
+
+#include <boost/math/special_functions/fpclassify.hpp>
+#include <boost/numeric/conversion/cast.hpp>
+
+#include <boost/geometry/algorithms/detail/distance/interface.hpp>
+#include <boost/geometry/algorithms/detail/distance/point_to_geometry.hpp>
+#include <boost/geometry/arithmetic/arithmetic.hpp>
+#include <boost/geometry/util/for_each_coordinate.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+#include <boost/geometry/strategies/centroid.hpp>
+#include <boost/geometry/strategies/default_distance_result.hpp>
+
+// Helper geometry
+#include <boost/geometry/geometries/point.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace centroid
+{
+
+namespace detail
+{
+
+template <typename Type, std::size_t DimensionCount>
+struct weighted_length_sums
+{
+    typedef typename geometry::model::point
+        <
+            Type, DimensionCount,
+            cs::cartesian
+        > work_point;
+
+    Type length;
+    work_point average_sum;
+
+    inline weighted_length_sums()
+        : length(Type())
+    {
+        geometry::assign_zero(average_sum);
+    }
+};
+}
+
+template
+<
+    typename Point,
+    typename PointOfSegment = Point
+>
+class weighted_length
+{
+private :
+    typedef typename select_most_precise
+        <
+            typename default_distance_result<Point>::type,
+            typename default_distance_result<PointOfSegment>::type
+        >::type distance_type;
+
+public :
+    typedef detail::weighted_length_sums
+        <
+            distance_type,
+            geometry::dimension<Point>::type::value
+        > state_type;
+
+    static inline void apply(PointOfSegment const& p1,
+            PointOfSegment const& p2, state_type& state)
+    {
+        distance_type const d = geometry::distance(p1, p2);
+        state.length += d;
+
+        typename state_type::work_point weighted_median;
+        geometry::assign_zero(weighted_median);
+        geometry::add_point(weighted_median, p1);
+        geometry::add_point(weighted_median, p2);
+        geometry::multiply_value(weighted_median, d/2);
+        geometry::add_point(state.average_sum, weighted_median);
+    }
+
+    static inline bool result(state_type const& state, Point& centroid)
+    {
+        distance_type const zero = distance_type();
+        if (! geometry::math::equals(state.length, zero)
+            && boost::math::isfinite(state.length)) // Prevent NaN centroid coordinates
+        {
+            // NOTE: above distance_type is checked, not the centroid coordinate_type
+            // which means that the centroid can still be filled with INF
+            // if e.g. distance_type is double and centroid contains floats
+            geometry::for_each_coordinate(centroid, set_sum_div_length(state));
+            return true;
+        }
+
+        return false;
+    }
+
+    struct set_sum_div_length
+    {
+        state_type const& m_state;
+        set_sum_div_length(state_type const& state)
+            : m_state(state)
+        {}
+        template <typename Pt, std::size_t Dimension>
+        void apply(Pt & centroid) const
+        {
+            typedef typename geometry::coordinate_type<Pt>::type coordinate_type;
+            geometry::set<Dimension>(
+                centroid,
+                boost::numeric_cast<coordinate_type>(
+                    geometry::get<Dimension>(m_state.average_sum) / m_state.length
+                )
+            );
+        }
+    };
+};
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+
+// Register this strategy for linear geometries, in all dimensions
+
+template <std::size_t N, typename Point, typename Geometry>
+struct default_strategy
+<
+    cartesian_tag,
+    linear_tag,
+    N,
+    Point,
+    Geometry
+>
+{
+    typedef weighted_length
+        <
+            Point,
+            typename point_type<Geometry>::type
+        > type;
+};
+
+
+} // namespace services
+
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::centroid
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_CENTROID_WEIGHTED_LENGTH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/disjoint_segment_box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/disjoint_segment_box.hpp
new file mode 100644
index 00000000000..4da4bc4503b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/disjoint_segment_box.hpp
@@ -0,0 +1,319 @@
+// Boost.Geometry
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2013-2017.
+// Modifications copyright (c) 2013-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISJOINT_SEGMENT_BOX_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISJOINT_SEGMENT_BOX_HPP
+
+
+#include <cstddef>
+#include <utility>
+
+#include <boost/numeric/conversion/cast.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/calculation_type.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/algorithms/detail/assign_indexed_point.hpp>
+
+#include <boost/geometry/strategies/disjoint.hpp>
+
+
+namespace boost { namespace geometry { namespace strategy { namespace disjoint
+{
+
+namespace detail
+{
+
+template <std::size_t I>
+struct compute_tmin_tmax_per_dim
+{
+    template <typename SegmentPoint, typename Box, typename RelativeDistance>
+    static inline void apply(SegmentPoint const& p0,
+                             SegmentPoint const& p1,
+                             Box const& box,
+                             RelativeDistance& ti_min,
+                             RelativeDistance& ti_max,
+                             RelativeDistance& diff)
+    {
+        typedef typename coordinate_type<Box>::type box_coordinate_type;
+        typedef typename coordinate_type
+            <
+                SegmentPoint
+            >::type point_coordinate_type;
+
+        RelativeDistance c_p0 = boost::numeric_cast
+            <
+                point_coordinate_type
+            >( geometry::get<I>(p0) );
+
+        RelativeDistance c_p1 = boost::numeric_cast
+            <
+                point_coordinate_type
+            >( geometry::get<I>(p1) );
+
+        RelativeDistance c_b_min = boost::numeric_cast
+            <
+                box_coordinate_type
+            >( geometry::get<geometry::min_corner, I>(box) );
+
+        RelativeDistance c_b_max = boost::numeric_cast
+            <
+                box_coordinate_type
+            >( geometry::get<geometry::max_corner, I>(box) );
+
+        if ( geometry::get<I>(p1) >= geometry::get<I>(p0) )
+        {
+            diff = c_p1 - c_p0;
+            ti_min = c_b_min - c_p0;
+            ti_max = c_b_max - c_p0;
+        }
+        else
+        {
+            diff = c_p0 - c_p1;
+            ti_min = c_p0 - c_b_max;
+            ti_max = c_p0 - c_b_min;
+        }
+    }
+};
+
+
+template
+<
+    typename RelativeDistance,
+    typename SegmentPoint,
+    typename Box,
+    std::size_t I,
+    std::size_t Dimension
+>
+struct disjoint_segment_box_impl
+{
+    template <typename RelativeDistancePair>
+    static inline bool apply(SegmentPoint const& p0,
+                             SegmentPoint const& p1,
+                             Box const& box,
+                             RelativeDistancePair& t_min,
+                             RelativeDistancePair& t_max)
+    {
+        RelativeDistance ti_min, ti_max, diff;
+
+        compute_tmin_tmax_per_dim<I>::apply(p0, p1, box, ti_min, ti_max, diff);
+
+        if ( geometry::math::equals(diff, 0) )
+        {
+            if ( (geometry::math::equals(t_min.second, 0)
+                  && t_min.first > ti_max)
+                 ||
+                 (geometry::math::equals(t_max.second, 0)
+                  && t_max.first < ti_min)
+                 ||
+                 (math::sign(ti_min) * math::sign(ti_max) > 0) )
+            {
+                return true;
+            }
+        }
+
+        RelativeDistance t_min_x_diff = t_min.first * diff;
+        RelativeDistance t_max_x_diff = t_max.first * diff;
+
+        if ( t_min_x_diff > ti_max * t_min.second
+             || t_max_x_diff < ti_min * t_max.second )
+        {
+            return true;
+        }
+
+        if ( ti_min * t_min.second > t_min_x_diff )
+        {
+            t_min.first = ti_min;
+            t_min.second = diff;
+        }
+        if ( ti_max * t_max.second < t_max_x_diff )
+        {
+            t_max.first = ti_max;
+            t_max.second = diff;
+        }
+
+        if ( t_min.first > t_min.second || t_max.first < 0 )
+        {
+            return true;
+        }
+
+        return disjoint_segment_box_impl
+            <
+                RelativeDistance,
+                SegmentPoint,
+                Box, 
+                I + 1,
+                Dimension
+            >::apply(p0, p1, box, t_min, t_max);
+    }
+};
+
+
+template
+<
+    typename RelativeDistance,
+    typename SegmentPoint,
+    typename Box,
+    std::size_t Dimension
+>
+struct disjoint_segment_box_impl
+    <
+        RelativeDistance, SegmentPoint, Box, 0, Dimension
+    >
+{
+    static inline bool apply(SegmentPoint const& p0,
+                             SegmentPoint const& p1,
+                             Box const& box)
+    {
+        std::pair<RelativeDistance, RelativeDistance> t_min, t_max;
+        RelativeDistance diff;
+
+        compute_tmin_tmax_per_dim<0>::apply(p0, p1, box,
+                                            t_min.first, t_max.first, diff);
+
+        if ( geometry::math::equals(diff, 0) )
+        {
+            if ( geometry::math::equals(t_min.first, 0) ) { t_min.first = -1; }
+            if ( geometry::math::equals(t_max.first, 0) ) { t_max.first = 1; }
+
+            if (math::sign(t_min.first) * math::sign(t_max.first) > 0)
+            {
+                return true;
+            }
+        }
+
+        if ( t_min.first > diff || t_max.first < 0 )
+        {
+            return true;
+        }
+
+        t_min.second = t_max.second = diff;
+
+        return disjoint_segment_box_impl
+            <
+                RelativeDistance, SegmentPoint, Box, 1, Dimension
+            >::apply(p0, p1, box, t_min, t_max);
+    }
+};
+
+
+template
+<
+    typename RelativeDistance,
+    typename SegmentPoint,
+    typename Box,
+    std::size_t Dimension
+>
+struct disjoint_segment_box_impl
+    <
+        RelativeDistance, SegmentPoint, Box, Dimension, Dimension
+    >
+{
+    template <typename RelativeDistancePair>
+    static inline bool apply(SegmentPoint const&, SegmentPoint const&,
+                             Box const&,
+                             RelativeDistancePair&, RelativeDistancePair&)
+    {
+        return false;
+    }
+};
+
+} // namespace detail
+
+// NOTE: This may be temporary place for this or corresponding strategy
+// It seems to be more appropriate to implement the opposite of it
+// e.g. intersection::segment_box because in disjoint() algorithm
+// other strategies that are used are intersection and covered_by strategies.
+struct segment_box
+{
+    template <typename Segment, typename Box>
+    struct point_in_geometry_strategy
+        : services::default_strategy
+            <
+                typename point_type<Segment>::type,
+                Box
+            >
+    {};
+
+    template <typename Segment, typename Box>
+    static inline typename point_in_geometry_strategy<Segment, Box>::type
+        get_point_in_geometry_strategy()
+    {
+        typedef typename point_in_geometry_strategy<Segment, Box>::type strategy_type;
+
+        return strategy_type();
+    }
+
+    template <typename Segment, typename Box>
+    static inline bool apply(Segment const& segment, Box const& box)
+    {
+        assert_dimension_equal<Segment, Box>();
+
+        typedef typename util::calculation_type::geometric::binary
+            <
+                Segment, Box, void
+            >::type relative_distance_type;
+
+        typedef typename point_type<Segment>::type segment_point_type;
+        segment_point_type p0, p1;
+        geometry::detail::assign_point_from_index<0>(segment, p0);
+        geometry::detail::assign_point_from_index<1>(segment, p1);
+
+        return detail::disjoint_segment_box_impl
+            <
+                relative_distance_type, segment_point_type, Box,
+                0, dimension<Box>::value
+            >::apply(p0, p1, box);
+    }
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+namespace services
+{
+
+template <typename Linear, typename Box, typename LinearTag>
+struct default_strategy<Linear, Box, LinearTag, box_tag, 1, 2, cartesian_tag, cartesian_tag>
+{
+    typedef disjoint::segment_box type;
+};
+
+template <typename Box, typename Linear, typename LinearTag>
+struct default_strategy<Box, Linear, box_tag, LinearTag, 2, 1, cartesian_tag, cartesian_tag>
+{
+    typedef disjoint::segment_box type;
+};
+
+
+} // namespace services
+
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}}}} // namespace boost::geometry::strategy::disjoint
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISJOINT_SEGMENT_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/distance_projected_point.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/distance_projected_point.hpp
new file mode 100644
index 00000000000..b7127c834dd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/distance_projected_point.hpp
@@ -0,0 +1,278 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PROJECTED_POINT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PROJECTED_POINT_HPP
+
+
+#include <boost/concept_check.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_void.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/algorithms/convert.hpp>
+#include <boost/geometry/arithmetic/arithmetic.hpp>
+#include <boost/geometry/arithmetic/dot_product.hpp>
+
+#include <boost/geometry/strategies/tags.hpp>
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/default_distance_result.hpp>
+#include <boost/geometry/strategies/cartesian/distance_pythagoras.hpp>
+
+#include <boost/geometry/util/select_coordinate_type.hpp>
+
+// Helper geometry (projected point on line)
+#include <boost/geometry/geometries/point.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace distance
+{
+
+/*!
+\brief Strategy for distance point to segment
+\ingroup strategies
+\details Calculates distance using projected-point method, and (optionally) Pythagoras
+\author Adapted from: http://geometryalgorithms.com/Archive/algorithm_0102/algorithm_0102.htm
+\tparam CalculationType \tparam_calculation
+\tparam Strategy underlying point-point distance strategy
+\par Concepts for Strategy:
+- cartesian_distance operator(Point,Point)
+\note If the Strategy is a "comparable::pythagoras", this strategy
+    automatically is a comparable projected_point strategy (so without sqrt)
+
+\qbk{
+[heading See also]
+[link geometry.reference.algorithms.distance.distance_3_with_strategy distance (with strategy)]
+}
+
+*/
+template
+<
+    typename CalculationType = void,
+    typename Strategy = pythagoras<CalculationType>
+>
+class projected_point
+{
+public :
+    // The three typedefs below are necessary to calculate distances
+    // from segments defined in integer coordinates.
+
+    // Integer coordinates can still result in FP distances.
+    // There is a division, which must be represented in FP.
+    // So promote.
+    template <typename Point, typename PointOfSegment>
+    struct calculation_type
+        : promote_floating_point
+          <
+              typename strategy::distance::services::return_type
+                  <
+                      Strategy,
+                      Point,
+                      PointOfSegment
+                  >::type
+          >
+    {};
+
+public :
+
+    template <typename Point, typename PointOfSegment>
+    inline typename calculation_type<Point, PointOfSegment>::type
+    apply(Point const& p, PointOfSegment const& p1, PointOfSegment const& p2) const
+    {
+        assert_dimension_equal<Point, PointOfSegment>();
+
+        typedef typename calculation_type<Point, PointOfSegment>::type calculation_type;
+
+        // A projected point of points in Integer coordinates must be able to be
+        // represented in FP.
+        typedef model::point
+            <
+                calculation_type,
+                dimension<PointOfSegment>::value,
+                typename coordinate_system<PointOfSegment>::type
+            > fp_point_type;
+
+        // For convenience
+        typedef fp_point_type fp_vector_type;
+
+        /*
+            Algorithm [p: (px,py), p1: (x1,y1), p2: (x2,y2)]
+            VECTOR v(x2 - x1, y2 - y1)
+            VECTOR w(px - x1, py - y1)
+            c1 = w . v
+            c2 = v . v
+            b = c1 / c2
+            RETURN POINT(x1 + b * vx, y1 + b * vy)
+        */
+
+        // v is multiplied below with a (possibly) FP-value, so should be in FP
+        // For consistency we define w also in FP
+        fp_vector_type v, w, projected;
+
+        geometry::convert(p2, v);
+        geometry::convert(p, w);
+        geometry::convert(p1, projected);
+        subtract_point(v, projected);
+        subtract_point(w, projected);
+
+        Strategy strategy;
+        boost::ignore_unused_variable_warning(strategy);
+
+        calculation_type const zero = calculation_type();
+        calculation_type const c1 = dot_product(w, v);
+        if (c1 <= zero)
+        {
+            return strategy.apply(p, p1);
+        }
+        calculation_type const c2 = dot_product(v, v);
+        if (c2 <= c1)
+        {
+            return strategy.apply(p, p2);
+        }
+
+        // See above, c1 > 0 AND c2 > c1 so: c2 != 0
+        calculation_type const b = c1 / c2;
+
+        multiply_value(v, b);
+        add_point(projected, v);
+
+        return strategy.apply(p, projected);
+    }
+};
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+template <typename CalculationType, typename Strategy>
+struct tag<projected_point<CalculationType, Strategy> >
+{
+    typedef strategy_tag_distance_point_segment type;
+};
+
+
+template <typename CalculationType, typename Strategy, typename P, typename PS>
+struct return_type<projected_point<CalculationType, Strategy>, P, PS>
+    : projected_point<CalculationType, Strategy>::template calculation_type<P, PS>
+{};
+
+
+
+template <typename CalculationType, typename Strategy>
+struct comparable_type<projected_point<CalculationType, Strategy> >
+{
+    // Define a projected_point strategy with its underlying point-point-strategy
+    // being comparable
+    typedef projected_point
+        <
+            CalculationType,
+            typename comparable_type<Strategy>::type
+        > type;
+};
+
+
+template <typename CalculationType, typename Strategy>
+struct get_comparable<projected_point<CalculationType, Strategy> >
+{
+    typedef typename comparable_type
+        <
+            projected_point<CalculationType, Strategy>
+        >::type comparable_type;
+public :
+    static inline comparable_type apply(projected_point<CalculationType, Strategy> const& )
+    {
+        return comparable_type();
+    }
+};
+
+
+template <typename CalculationType, typename Strategy, typename P, typename PS>
+struct result_from_distance<projected_point<CalculationType, Strategy>, P, PS>
+{
+private :
+    typedef typename return_type<projected_point<CalculationType, Strategy>, P, PS>::type return_type;
+public :
+    template <typename T>
+    static inline return_type apply(projected_point<CalculationType, Strategy> const& , T const& value)
+    {
+        Strategy s;
+        return result_from_distance<Strategy, P, PS>::apply(s, value);
+    }
+};
+
+
+// Get default-strategy for point-segment distance calculation
+// while still have the possibility to specify point-point distance strategy (PPS)
+// It is used in algorithms/distance.hpp where users specify PPS for distance
+// of point-to-segment or point-to-linestring.
+// Convenient for geographic coordinate systems especially.
+template <typename Point, typename PointOfSegment, typename Strategy>
+struct default_strategy
+    <
+        point_tag, segment_tag, Point, PointOfSegment,
+        cartesian_tag, cartesian_tag, Strategy
+    >
+{
+    typedef strategy::distance::projected_point
+    <
+        void,
+        typename boost::mpl::if_
+            <
+                boost::is_void<Strategy>,
+                typename default_strategy
+                    <
+                        point_tag, point_tag, Point, PointOfSegment,
+                        cartesian_tag, cartesian_tag
+                    >::type,
+                Strategy
+            >::type
+    > type;
+};
+
+template <typename PointOfSegment, typename Point, typename Strategy>
+struct default_strategy
+    <
+        segment_tag, point_tag, PointOfSegment, Point,
+        cartesian_tag, cartesian_tag, Strategy
+    >
+{
+    typedef typename default_strategy
+        <
+            point_tag, segment_tag, Point, PointOfSegment,
+            cartesian_tag, cartesian_tag, Strategy
+        >::type type;
+};
+
+
+} // namespace services
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::distance
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PROJECTED_POINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/distance_projected_point_ax.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/distance_projected_point_ax.hpp
new file mode 100644
index 00000000000..7ff86c7cfae
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/distance_projected_point_ax.hpp
@@ -0,0 +1,314 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PROJECTED_POINT_AX_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PROJECTED_POINT_AX_HPP
+
+
+#include <algorithm>
+
+#include <boost/concept_check.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/algorithms/convert.hpp>
+#include <boost/geometry/arithmetic/arithmetic.hpp>
+#include <boost/geometry/arithmetic/dot_product.hpp>
+
+#include <boost/geometry/strategies/tags.hpp>
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/default_distance_result.hpp>
+#include <boost/geometry/strategies/cartesian/distance_pythagoras.hpp>
+#include <boost/geometry/strategies/cartesian/distance_projected_point.hpp>
+
+#include <boost/geometry/util/select_coordinate_type.hpp>
+
+// Helper geometry (projected point on line)
+#include <boost/geometry/geometries/point.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace distance
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <typename T>
+struct projected_point_ax_result
+{
+    typedef T value_type;
+
+    projected_point_ax_result(T const& c = T(0))
+        : atd(c), xtd(c)
+    {}
+
+    projected_point_ax_result(T const& a, T const& x)
+        : atd(a), xtd(x)
+    {}
+
+    friend inline bool operator<(projected_point_ax_result const& left,
+                                 projected_point_ax_result const& right)
+    {
+        return left.xtd < right.xtd || left.atd < right.atd;
+    }
+
+    T atd, xtd;
+};
+
+// This less-comparator may be used as a parameter of detail::douglas_peucker.
+// In this simplify strategy distances are compared in 2 places
+// 1. to choose the furthest candidate (md < dist)
+// 2. to check if the candidate is further than max_distance (max_distance < md)
+template <typename Distance>
+class projected_point_ax_less
+{
+public:
+    projected_point_ax_less(Distance const& max_distance)
+        : m_max_distance(max_distance)
+    {}
+
+    inline bool operator()(Distance const& left, Distance const& right) const
+    {
+        //return left.xtd < right.xtd && right.atd < m_max_distance.atd;
+
+        typedef typename Distance::value_type value_type;
+
+        value_type const lx = left.xtd > m_max_distance.xtd ? left.xtd - m_max_distance.xtd : 0;
+        value_type const rx = right.xtd > m_max_distance.xtd ? right.xtd - m_max_distance.xtd : 0;
+        value_type const la = left.atd > m_max_distance.atd ? left.atd - m_max_distance.atd : 0;
+        value_type const ra = right.atd > m_max_distance.atd ? right.atd - m_max_distance.atd : 0;
+
+        value_type const l = (std::max)(lx, la);
+        value_type const r = (std::max)(rx, ra);
+
+        return l < r;
+    }
+private:
+    Distance const& m_max_distance;
+};
+
+// This strategy returns 2-component Point/Segment distance.
+// The ATD (along track distance) is parallel to the Segment
+// and is a distance between Point projected into a line defined by a Segment and the nearest Segment's endpoint.
+// If the projected Point intersects the Segment the ATD is equal to 0.
+// The XTD (cross track distance) is perpendicular to the Segment
+// and is a distance between input Point and its projection.
+// If the Segment has length equal to 0, ATD and XTD has value equal
+// to the distance between the input Point and one of the Segment's endpoints.
+//
+//          p3         p4
+//          ^         7
+//          |        /
+// p1<-----e========e----->p2
+//
+// p1: atd=D,   xtd=0
+// p2: atd=D,   xtd=0
+// p3: atd=0,   xtd=D
+// p4: atd=D/2, xtd=D
+template
+<
+    typename CalculationType = void,
+    typename Strategy = pythagoras<CalculationType>
+>
+class projected_point_ax
+{
+public :
+    template <typename Point, typename PointOfSegment>
+    struct calculation_type
+        : public projected_point<CalculationType, Strategy>
+            ::template calculation_type<Point, PointOfSegment>
+    {};
+
+    template <typename Point, typename PointOfSegment>
+    struct result_type
+    {
+        typedef projected_point_ax_result
+                    <
+                        typename calculation_type<Point, PointOfSegment>::type
+                    > type;
+    };
+
+public :
+
+    template <typename Point, typename PointOfSegment>
+    inline typename result_type<Point, PointOfSegment>::type
+    apply(Point const& p, PointOfSegment const& p1, PointOfSegment const& p2) const
+    {
+        assert_dimension_equal<Point, PointOfSegment>();
+
+        typedef typename calculation_type<Point, PointOfSegment>::type calculation_type;
+
+        // A projected point of points in Integer coordinates must be able to be
+        // represented in FP.
+        typedef model::point
+            <
+                calculation_type,
+                dimension<PointOfSegment>::value,
+                typename coordinate_system<PointOfSegment>::type
+            > fp_point_type;
+
+        // For convenience
+        typedef fp_point_type fp_vector_type;
+
+        /*
+            Algorithm [p: (px,py), p1: (x1,y1), p2: (x2,y2)]
+            VECTOR v(x2 - x1, y2 - y1)
+            VECTOR w(px - x1, py - y1)
+            c1 = w . v
+            c2 = v . v
+            b = c1 / c2
+            RETURN POINT(x1 + b * vx, y1 + b * vy)
+        */
+
+        // v is multiplied below with a (possibly) FP-value, so should be in FP
+        // For consistency we define w also in FP
+        fp_vector_type v, w, projected;
+
+        geometry::convert(p2, v);
+        geometry::convert(p, w);
+        geometry::convert(p1, projected);
+        subtract_point(v, projected);
+        subtract_point(w, projected);
+
+        Strategy strategy;
+        boost::ignore_unused_variable_warning(strategy);
+
+        typename result_type<Point, PointOfSegment>::type result;
+
+        calculation_type const zero = calculation_type();
+        calculation_type const c2 = dot_product(v, v);
+        if ( math::equals(c2, zero) )
+        {
+            result.xtd = strategy.apply(p, projected);
+            // assume that the 0-length segment is perpendicular to the Pt->ProjPt vector
+            result.atd = 0;
+            return result;
+        }
+
+        calculation_type const c1 = dot_product(w, v);
+        calculation_type const b = c1 / c2;
+        multiply_value(v, b);
+        add_point(projected, v);
+
+        result.xtd = strategy.apply(p, projected);
+
+        if (c1 <= zero)
+        {
+            result.atd = strategy.apply(p1, projected);
+        }
+        else if (c2 <= c1)
+        {
+            result.atd = strategy.apply(p2, projected);
+        }
+        else
+        {
+            result.atd = 0;
+        }
+
+        return result;
+    }
+};
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+
+template <typename CalculationType, typename Strategy>
+struct tag<detail::projected_point_ax<CalculationType, Strategy> >
+{
+    typedef strategy_tag_distance_point_segment type;
+};
+
+
+template <typename CalculationType, typename Strategy, typename P, typename PS>
+struct return_type<detail::projected_point_ax<CalculationType, Strategy>, P, PS>
+{
+    typedef typename detail::projected_point_ax<CalculationType, Strategy>
+                        ::template result_type<P, PS>::type type;
+};
+
+
+template <typename CalculationType, typename Strategy>
+struct comparable_type<detail::projected_point_ax<CalculationType, Strategy> >
+{
+    // Define a projected_point strategy with its underlying point-point-strategy
+    // being comparable
+    typedef detail::projected_point_ax
+        <
+            CalculationType,
+            typename comparable_type<Strategy>::type
+        > type;
+};
+
+
+template <typename CalculationType, typename Strategy>
+struct get_comparable<detail::projected_point_ax<CalculationType, Strategy> >
+{
+    typedef typename comparable_type
+        <
+            detail::projected_point_ax<CalculationType, Strategy>
+        >::type comparable_type;
+public :
+    static inline comparable_type apply(detail::projected_point_ax<CalculationType, Strategy> const& )
+    {
+        return comparable_type();
+    }
+};
+
+
+template <typename CalculationType, typename Strategy, typename P, typename PS>
+struct result_from_distance<detail::projected_point_ax<CalculationType, Strategy>, P, PS>
+{
+private :
+    typedef typename return_type<detail::projected_point_ax<CalculationType, Strategy>, P, PS>::type return_type;
+public :
+    template <typename T>
+    static inline return_type apply(detail::projected_point_ax<CalculationType, Strategy> const& , T const& value)
+    {
+        Strategy s;
+        return_type ret;
+        ret.atd = result_from_distance<Strategy, P, PS>::apply(s, value.atd);
+        ret.xtd = result_from_distance<Strategy, P, PS>::apply(s, value.xtd);
+        return ret;
+    }
+};
+
+
+} // namespace services
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::distance
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PROJECTED_POINT_AX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/distance_pythagoras.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/distance_pythagoras.hpp
new file mode 100644
index 00000000000..8a8889dc991
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/distance_pythagoras.hpp
@@ -0,0 +1,288 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PYTHAGORAS_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PYTHAGORAS_HPP
+
+
+#include <boost/geometry/core/access.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/calculation_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace distance
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <size_t I, typename T>
+struct compute_pythagoras
+{
+    template <typename Point1, typename Point2>
+    static inline T apply(Point1 const& p1, Point2 const& p2)
+    {
+        T const c1 = boost::numeric_cast<T>(get<I-1>(p1));
+        T const c2 = boost::numeric_cast<T>(get<I-1>(p2));
+        T const d = c1 - c2;
+        return d * d + compute_pythagoras<I-1, T>::apply(p1, p2);
+    }
+};
+
+template <typename T>
+struct compute_pythagoras<0, T>
+{
+    template <typename Point1, typename Point2>
+    static inline T apply(Point1 const&, Point2 const&)
+    {
+        return boost::numeric_cast<T>(0);
+    }
+};
+
+}
+#endif // DOXYGEN_NO_DETAIL
+
+
+namespace comparable
+{
+
+/*!
+\brief Strategy to calculate comparable distance between two points
+\ingroup strategies
+\tparam Point1 \tparam_first_point
+\tparam Point2 \tparam_second_point
+\tparam CalculationType \tparam_calculation
+*/
+template <typename CalculationType = void>
+class pythagoras
+{
+public :
+
+    template <typename Point1, typename Point2>
+    struct calculation_type
+        : util::calculation_type::geometric::binary
+          <
+              Point1,
+              Point2,
+              CalculationType,
+              double,
+              double
+          >
+    {};
+
+    template <typename Point1, typename Point2>
+    static inline typename calculation_type<Point1, Point2>::type
+    apply(Point1 const& p1, Point2 const& p2)
+    {
+        BOOST_CONCEPT_ASSERT( (concepts::ConstPoint<Point1>) );
+        BOOST_CONCEPT_ASSERT( (concepts::ConstPoint<Point2>) );
+
+        // Calculate distance using Pythagoras
+        // (Leave comment above for Doxygen)
+
+        assert_dimension_equal<Point1, Point2>();
+
+        return detail::compute_pythagoras
+            <
+                dimension<Point1>::value,
+                typename calculation_type<Point1, Point2>::type
+            >::apply(p1, p2);
+    }
+};
+
+} // namespace comparable
+
+
+/*!
+\brief Strategy to calculate the distance between two points
+\ingroup strategies
+\tparam CalculationType \tparam_calculation
+
+\qbk{
+[heading Notes]
+[note Can be used for points with two\, three or more dimensions]
+[heading See also]
+[link geometry.reference.algorithms.distance.distance_3_with_strategy distance (with strategy)]
+}
+
+*/
+template
+<
+    typename CalculationType = void
+>
+class pythagoras
+{
+public :
+
+    template <typename P1, typename P2>
+    struct calculation_type
+        : util::calculation_type::geometric::binary
+          <
+              P1,
+              P2,
+              CalculationType,
+              double,
+              double // promote integer to double
+          >
+    {};
+
+    /*!
+    \brief applies the distance calculation using pythagoras
+    \return the calculated distance (including taking the square root)
+    \param p1 first point
+    \param p2 second point
+    */
+    template <typename P1, typename P2>
+    static inline typename calculation_type<P1, P2>::type
+    apply(P1 const& p1, P2 const& p2)
+    {
+        // The cast is necessary for MSVC which considers sqrt __int64 as an ambiguous call
+        return math::sqrt
+            (
+                 boost::numeric_cast<typename calculation_type<P1, P2>::type>
+                    (
+                        comparable::pythagoras<CalculationType>::apply(p1, p2)
+                    )
+            );
+    }
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+template <typename CalculationType>
+struct tag<pythagoras<CalculationType> >
+{
+    typedef strategy_tag_distance_point_point type;
+};
+
+
+template <typename CalculationType, typename P1, typename P2>
+struct return_type<distance::pythagoras<CalculationType>, P1, P2>
+    : pythagoras<CalculationType>::template calculation_type<P1, P2>
+{};
+
+
+template <typename CalculationType>
+struct comparable_type<pythagoras<CalculationType> >
+{
+    typedef comparable::pythagoras<CalculationType> type;
+};
+
+
+template <typename CalculationType>
+struct get_comparable<pythagoras<CalculationType> >
+{
+    typedef comparable::pythagoras<CalculationType> comparable_type;
+public :
+    static inline comparable_type apply(pythagoras<CalculationType> const& )
+    {
+        return comparable_type();
+    }
+};
+
+
+template <typename CalculationType, typename Point1, typename Point2>
+struct result_from_distance<pythagoras<CalculationType>, Point1, Point2>
+{
+private :
+    typedef typename return_type<pythagoras<CalculationType>, Point1, Point2>::type return_type;
+public :
+    template <typename T>
+    static inline return_type apply(pythagoras<CalculationType> const& , T const& value)
+    {
+        return return_type(value);
+    }
+};
+
+
+// Specializations for comparable::pythagoras
+template <typename CalculationType>
+struct tag<comparable::pythagoras<CalculationType> >
+{
+    typedef strategy_tag_distance_point_point type;
+};
+
+
+template <typename CalculationType, typename P1, typename P2>
+struct return_type<comparable::pythagoras<CalculationType>, P1, P2>
+    : comparable::pythagoras<CalculationType>::template calculation_type<P1, P2>
+{};
+
+
+
+
+template <typename CalculationType>
+struct comparable_type<comparable::pythagoras<CalculationType> >
+{
+    typedef comparable::pythagoras<CalculationType> type;
+};
+
+
+template <typename CalculationType>
+struct get_comparable<comparable::pythagoras<CalculationType> >
+{
+    typedef comparable::pythagoras<CalculationType> comparable_type;
+public :
+    static inline comparable_type apply(comparable::pythagoras<CalculationType> const& )
+    {
+        return comparable_type();
+    }
+};
+
+
+template <typename CalculationType, typename Point1, typename Point2>
+struct result_from_distance<comparable::pythagoras<CalculationType>, Point1, Point2>
+{
+private :
+    typedef typename return_type<comparable::pythagoras<CalculationType>, Point1, Point2>::type return_type;
+public :
+    template <typename T>
+    static inline return_type apply(comparable::pythagoras<CalculationType> const& , T const& value)
+    {
+        return_type const v = value;
+        return v * v;
+    }
+};
+
+
+template <typename Point1, typename Point2>
+struct default_strategy
+    <
+        point_tag, point_tag, Point1, Point2, cartesian_tag, cartesian_tag
+    >
+{
+    typedef pythagoras<> type;
+};
+
+
+} // namespace services
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::distance
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PYTHAGORAS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/distance_pythagoras_box_box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/distance_pythagoras_box_box.hpp
new file mode 100644
index 00000000000..4c1b6539be6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/distance_pythagoras_box_box.hpp
@@ -0,0 +1,338 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PYTHAGORAS_BOX_BOX_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PYTHAGORAS_BOX_BOX_HPP
+
+
+#include <boost/geometry/core/access.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/calculation_type.hpp>
+
+
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace distance
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <std::size_t I>
+struct compute_pythagoras_box_box
+{
+    template <typename Box1, typename Box2, typename T>
+    static inline void apply(Box1 const& box1, Box2 const& box2, T& result)
+    {
+        T const b1_min_coord =
+            boost::numeric_cast<T>(geometry::get<min_corner, I-1>(box1));
+        T const b1_max_coord =
+            boost::numeric_cast<T>(geometry::get<max_corner, I-1>(box1));
+
+        T const b2_min_coord =
+            boost::numeric_cast<T>(geometry::get<min_corner, I-1>(box2));
+        T const b2_max_coord =
+            boost::numeric_cast<T>(geometry::get<max_corner, I-1>(box2));
+
+        if ( b1_max_coord < b2_min_coord )
+        {
+            T diff = b2_min_coord - b1_max_coord;
+            result += diff * diff;
+        }
+        if ( b1_min_coord > b2_max_coord )
+        {
+            T diff = b1_min_coord - b2_max_coord;
+            result += diff * diff;
+        }
+
+        compute_pythagoras_box_box<I-1>::apply(box1, box2, result);
+    }
+};
+
+template <>
+struct compute_pythagoras_box_box<0>
+{
+    template <typename Box1, typename Box2, typename T>
+    static inline void apply(Box1 const&, Box2 const&, T&)
+    {
+    }
+};
+
+}
+#endif // DOXYGEN_NO_DETAIL
+
+
+namespace comparable
+{
+
+/*!
+\brief Strategy to calculate comparable distance between two boxes
+\ingroup strategies
+\tparam Box1 \tparam_first_box
+\tparam Box2 \tparam_second_box
+\tparam CalculationType \tparam_calculation
+*/
+template <typename CalculationType = void>
+class pythagoras_box_box
+{
+public :
+
+    template <typename Box1, typename Box2>
+    struct calculation_type
+    {
+        typedef typename util::calculation_type::geometric::binary
+            <
+                Box1,
+                Box2,
+                CalculationType
+            >::type type;
+    };
+
+    template <typename Box1, typename Box2>
+    static inline typename calculation_type<Box1, Box2>::type
+    apply(Box1 const& box1, Box2 const& box2)
+    {
+        BOOST_CONCEPT_ASSERT
+            ( (concepts::ConstPoint<typename point_type<Box1>::type>) );
+        BOOST_CONCEPT_ASSERT
+            ( (concepts::ConstPoint<typename point_type<Box2>::type>) );
+
+        // Calculate distance using Pythagoras
+        // (Leave comment above for Doxygen)
+
+        assert_dimension_equal<Box1, Box2>();
+
+        typename calculation_type<Box1, Box2>::type result(0);
+        
+        detail::compute_pythagoras_box_box
+            <
+                dimension<Box1>::value
+            >::apply(box1, box2, result);
+
+        return result;
+    }
+};
+
+} // namespace comparable
+
+
+/*!
+\brief Strategy to calculate the distance between two boxes
+\ingroup strategies
+\tparam CalculationType \tparam_calculation
+
+\qbk{
+[heading Notes]
+[note Can be used for boxes with two\, three or more dimensions]
+[heading See also]
+[link geometry.reference.algorithms.distance.distance_3_with_strategy distance (with strategy)]
+}
+
+*/
+template
+<
+    typename CalculationType = void
+>
+class pythagoras_box_box
+{
+public :
+
+    template <typename Box1, typename Box2>
+    struct calculation_type
+        : util::calculation_type::geometric::binary
+          <
+              Box1,
+              Box2,
+              CalculationType,
+              double,
+              double // promote integer to double
+          >
+    {};
+
+    /*!
+    \brief applies the distance calculation using pythagoras_box_box
+    \return the calculated distance (including taking the square root)
+    \param box1 first box
+    \param box2 second box
+    */
+    template <typename Box1, typename Box2>
+    static inline typename calculation_type<Box1, Box2>::type
+    apply(Box1 const& box1, Box2 const& box2)
+    {
+        // The cast is necessary for MSVC which considers sqrt __int64 as an ambiguous call
+        return math::sqrt
+            (
+                 boost::numeric_cast<typename calculation_type
+                     <
+                         Box1, Box2
+                     >::type>
+                    (
+                        comparable::pythagoras_box_box
+                            <
+                                CalculationType
+                            >::apply(box1, box2)
+                    )
+            );
+    }
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+template <typename CalculationType>
+struct tag<pythagoras_box_box<CalculationType> >
+{
+    typedef strategy_tag_distance_box_box type;
+};
+
+
+template <typename CalculationType, typename Box1, typename Box2>
+struct return_type<distance::pythagoras_box_box<CalculationType>, Box1, Box2>
+    : pythagoras_box_box<CalculationType>::template calculation_type<Box1, Box2>
+{};
+
+
+template <typename CalculationType>
+struct comparable_type<pythagoras_box_box<CalculationType> >
+{
+    typedef comparable::pythagoras_box_box<CalculationType> type;
+};
+
+
+template <typename CalculationType>
+struct get_comparable<pythagoras_box_box<CalculationType> >
+{
+    typedef comparable::pythagoras_box_box<CalculationType> comparable_type;
+public :
+    static inline comparable_type
+    apply(pythagoras_box_box<CalculationType> const& )
+    {
+        return comparable_type();
+    }
+};
+
+
+template <typename CalculationType, typename Box1, typename Box2>
+struct result_from_distance<pythagoras_box_box<CalculationType>, Box1, Box2>
+{
+private:
+    typedef typename return_type
+        <
+            pythagoras_box_box<CalculationType>, Box1, Box2
+        >::type return_type;
+public:
+    template <typename T>
+    static inline return_type
+    apply(pythagoras_box_box<CalculationType> const& , T const& value)
+    {
+        return return_type(value);
+    }
+};
+
+
+// Specializations for comparable::pythagoras_box_box
+template <typename CalculationType>
+struct tag<comparable::pythagoras_box_box<CalculationType> >
+{
+    typedef strategy_tag_distance_box_box type;
+};
+
+
+template <typename CalculationType, typename Box1, typename Box2>
+struct return_type<comparable::pythagoras_box_box<CalculationType>, Box1, Box2>
+    : comparable::pythagoras_box_box
+        <
+            CalculationType
+        >::template calculation_type<Box1, Box2>
+{};
+
+
+
+
+template <typename CalculationType>
+struct comparable_type<comparable::pythagoras_box_box<CalculationType> >
+{
+    typedef comparable::pythagoras_box_box<CalculationType> type;
+};
+
+
+template <typename CalculationType>
+struct get_comparable<comparable::pythagoras_box_box<CalculationType> >
+{
+    typedef comparable::pythagoras_box_box<CalculationType> comparable_type;
+public :
+    static inline comparable_type apply(comparable_type const& )
+    {
+        return comparable_type();
+    }
+};
+
+
+template <typename CalculationType, typename Box1, typename Box2>
+struct result_from_distance
+    <
+        comparable::pythagoras_box_box<CalculationType>, Box1, Box2
+    >
+{
+private :
+    typedef typename return_type
+        <
+            comparable::pythagoras_box_box<CalculationType>, Box1, Box2
+        >::type return_type;
+public :
+    template <typename T>
+    static inline return_type
+    apply(comparable::pythagoras_box_box<CalculationType> const&,
+          T const& value)
+    {
+        return_type const v = value;
+        return v * v;
+    }
+};
+
+
+template <typename BoxPoint1, typename BoxPoint2>
+struct default_strategy
+    <
+        box_tag, box_tag, BoxPoint1, BoxPoint2, cartesian_tag, cartesian_tag
+    >
+{
+    typedef pythagoras_box_box<> type;
+};
+
+
+} // namespace services
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::distance
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PYTHAGORAS_BOX_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/distance_pythagoras_point_box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/distance_pythagoras_point_box.hpp
new file mode 100644
index 00000000000..8423d16a63e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/distance_pythagoras_point_box.hpp
@@ -0,0 +1,349 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PYTHAGORAS_POINT_BOX_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PYTHAGORAS_POINT_BOX_HPP
+
+
+#include <boost/geometry/core/access.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/calculation_type.hpp>
+
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace distance
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <size_t I>
+struct compute_pythagoras_point_box
+{
+    template <typename Point, typename Box, typename T>
+    static inline void apply(Point const& point, Box const& box, T& result)
+    {
+        T const p_coord = boost::numeric_cast<T>(geometry::get<I-1>(point));
+        T const b_min_coord =
+            boost::numeric_cast<T>(geometry::get<min_corner, I-1>(box));
+        T const b_max_coord =
+            boost::numeric_cast<T>(geometry::get<max_corner, I-1>(box));
+
+        if ( p_coord < b_min_coord )
+        {
+            T diff = b_min_coord - p_coord;
+            result += diff * diff;
+        }
+        if ( p_coord > b_max_coord )
+        {
+            T diff = p_coord - b_max_coord;
+            result += diff * diff;
+        }
+
+        compute_pythagoras_point_box<I-1>::apply(point, box, result);
+    }
+};
+
+template <>
+struct compute_pythagoras_point_box<0>
+{
+    template <typename Point, typename Box, typename T>
+    static inline void apply(Point const&, Box const&, T&)
+    {
+    }
+};
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+namespace comparable
+{
+
+/*!
+    \brief Strategy to calculate comparable distance between a point
+    and a box
+    \ingroup strategies
+    \tparam Point \tparam_first_point
+    \tparam Box \tparam_second_box
+    \tparam CalculationType \tparam_calculation
+*/
+template <typename CalculationType = void>
+class pythagoras_point_box
+{
+public :
+
+    template <typename Point, typename Box>
+    struct calculation_type
+    {
+        typedef typename util::calculation_type::geometric::binary
+            <
+                Point, Box, CalculationType
+            >::type type;
+    };
+
+    template <typename Point, typename Box>
+    static inline typename calculation_type<Point, Box>::type
+    apply(Point const& point, Box const& box)
+    {
+        BOOST_CONCEPT_ASSERT( (concepts::ConstPoint<Point>) );
+        BOOST_CONCEPT_ASSERT
+            ( (concepts::ConstPoint<typename point_type<Box>::type>) );
+
+        // Calculate distance using Pythagoras
+        // (Leave comment above for Doxygen)
+
+        assert_dimension_equal<Point, Box>();
+
+        typename calculation_type<Point, Box>::type result(0);
+        
+        detail::compute_pythagoras_point_box
+            <
+                dimension<Point>::value
+            >::apply(point, box, result);
+
+        return result;
+    }
+};
+
+} // namespace comparable
+
+
+/*!
+\brief Strategy to calculate the distance between a point and a box
+\ingroup strategies
+\tparam CalculationType \tparam_calculation
+
+\qbk{
+[heading Notes]
+[note Can be used for points and boxes with two\, three or more dimensions]
+[heading See also]
+[link geometry.reference.algorithms.distance.distance_3_with_strategy distance (with strategy)]
+}
+
+*/
+template
+<
+    typename CalculationType = void
+>
+class pythagoras_point_box
+{
+public :
+
+    template <typename Point, typename Box>
+    struct calculation_type
+        : util::calculation_type::geometric::binary
+          <
+              Point,
+              Box,
+              CalculationType,
+              double,
+              double // promote integer to double
+          >
+    {};
+
+    /*!
+    \brief applies the distance calculation using pythagoras
+    \return the calculated distance (including taking the square root)
+    \param point point
+    \param box box
+    */
+    template <typename Point, typename Box>
+    static inline typename calculation_type<Point, Box>::type
+    apply(Point const& point, Box const& box)
+    {
+        // The cast is necessary for MSVC which considers sqrt __int64 as an ambiguous call
+        return math::sqrt
+            (
+                 boost::numeric_cast<typename calculation_type
+                     <
+                         Point, Box
+                     >::type>
+                    (
+                        comparable::pythagoras_point_box
+                            <
+                                CalculationType
+                            >::apply(point, box)
+                    )
+            );
+    }
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+template <typename CalculationType>
+struct tag<pythagoras_point_box<CalculationType> >
+{
+    typedef strategy_tag_distance_point_box type;
+};
+
+
+template <typename CalculationType, typename Point, typename Box>
+struct return_type<distance::pythagoras_point_box<CalculationType>, Point, Box>
+    : pythagoras_point_box
+        <
+            CalculationType
+        >::template calculation_type<Point, Box>
+{};
+
+
+template <typename CalculationType>
+struct comparable_type<pythagoras_point_box<CalculationType> >
+{
+    typedef comparable::pythagoras_point_box<CalculationType> type;
+};
+
+
+template <typename CalculationType>
+struct get_comparable<pythagoras_point_box<CalculationType> >
+{
+    typedef comparable::pythagoras_point_box<CalculationType> comparable_type;
+public :
+    static inline comparable_type
+    apply(pythagoras_point_box<CalculationType> const& )
+    {
+        return comparable_type();
+    }
+};
+
+
+template <typename CalculationType, typename Point, typename Box>
+struct result_from_distance<pythagoras_point_box<CalculationType>, Point, Box>
+{
+private :
+    typedef typename return_type
+        <
+            pythagoras_point_box<CalculationType>, Point, Box
+        >::type return_type;
+public :
+    template <typename T>
+    static inline return_type
+    apply(pythagoras_point_box<CalculationType> const& , T const& value)
+    {
+        return return_type(value);
+    }
+};
+
+
+// Specializations for comparable::pythagoras_point_box
+template <typename CalculationType>
+struct tag<comparable::pythagoras_point_box<CalculationType> >
+{
+    typedef strategy_tag_distance_point_box type;
+};
+
+
+template <typename CalculationType, typename Point, typename Box>
+struct return_type
+    <
+        comparable::pythagoras_point_box<CalculationType>, Point, Box
+    > : comparable::pythagoras_point_box
+        <
+            CalculationType
+        >::template calculation_type<Point, Box>
+{};
+
+
+
+
+template <typename CalculationType>
+struct comparable_type<comparable::pythagoras_point_box<CalculationType> >
+{
+    typedef comparable::pythagoras_point_box<CalculationType> type;
+};
+
+
+template <typename CalculationType>
+struct get_comparable<comparable::pythagoras_point_box<CalculationType> >
+{
+    typedef comparable::pythagoras_point_box<CalculationType> comparable_type;
+public :
+    static inline comparable_type apply(comparable_type const& )
+    {
+        return comparable_type();
+    }
+};
+
+
+template <typename CalculationType, typename Point, typename Box>
+struct result_from_distance
+    <
+        comparable::pythagoras_point_box<CalculationType>, Point, Box
+    >
+{
+private :
+    typedef typename return_type
+        <
+            comparable::pythagoras_point_box<CalculationType>, Point, Box
+        >::type return_type;
+public :
+    template <typename T>
+    static inline return_type
+    apply(comparable::pythagoras_point_box<CalculationType> const& ,
+          T const& value)
+    {
+        return_type const v = value;
+        return v * v;
+    }
+};
+
+
+template <typename Point, typename BoxPoint>
+struct default_strategy
+    <
+        point_tag, box_tag, Point, BoxPoint, cartesian_tag, cartesian_tag
+    >
+{
+    typedef pythagoras_point_box<> type;
+};
+
+template <typename BoxPoint, typename Point>
+struct default_strategy
+    <
+        box_tag, point_tag, BoxPoint, Point, cartesian_tag, cartesian_tag
+    >
+{
+    typedef typename default_strategy
+        <
+            point_tag, box_tag, Point, BoxPoint, cartesian_tag, cartesian_tag
+        >::type type;
+};
+
+
+} // namespace services
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::distance
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_DISTANCE_PYTHAGORAS_POINT_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/envelope_segment.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/envelope_segment.hpp
new file mode 100644
index 00000000000..a591996b848
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/envelope_segment.hpp
@@ -0,0 +1,72 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fisikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_ENVELOPE_SEGMENT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_ENVELOPE_SEGMENT_HPP
+
+
+#include <boost/geometry/algorithms/detail/envelope/segment.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/strategies/envelope.hpp>
+#include <boost/geometry/util/select_calculation_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace envelope
+{
+
+template
+<
+    typename CalculationType = void
+>
+class cartesian_segment
+{
+public :
+
+    template <typename Point1, typename Point2, typename Box>
+    inline void
+    apply(Point1 const& point1, Point2 const& point2, Box& box) const
+    {
+        geometry::detail::envelope::envelope_one_segment
+                <
+                    0,
+                    dimension<Point1>::value
+                >
+                ::apply(point1,
+                        point2,
+                        box,
+                        strategy::envelope::cartesian_segment<CalculationType>());
+    }
+
+};
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+template <typename CalculationType>
+struct default_strategy<cartesian_tag, CalculationType>
+{
+    typedef strategy::envelope::cartesian_segment<CalculationType> type;
+};
+
+}
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::envelope
+
+}} //namepsace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_ENVELOPE_SEGMENT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/intersection.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/intersection.hpp
new file mode 100644
index 00000000000..50e903885bd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/intersection.hpp
@@ -0,0 +1,713 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2013-2014 Adam Wulkiewicz, Lodz, Poland.
+
+// This file was modified by Oracle on 2014, 2016, 2017.
+// Modifications copyright (c) 2014-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_INTERSECTION_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_INTERSECTION_HPP
+
+#include <algorithm>
+
+#include <boost/geometry/core/exception.hpp>
+
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+#include <boost/geometry/geometries/concepts/segment_concept.hpp>
+
+#include <boost/geometry/arithmetic/determinant.hpp>
+#include <boost/geometry/algorithms/detail/assign_values.hpp>
+#include <boost/geometry/algorithms/detail/assign_indexed_point.hpp>
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+#include <boost/geometry/algorithms/detail/recalculate.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/promote_integral.hpp>
+#include <boost/geometry/util/select_calculation_type.hpp>
+
+#include <boost/geometry/strategies/agnostic/point_in_poly_winding.hpp>
+#include <boost/geometry/strategies/cartesian/area_surveyor.hpp>
+#include <boost/geometry/strategies/cartesian/distance_pythagoras.hpp>
+#include <boost/geometry/strategies/cartesian/envelope_segment.hpp>
+#include <boost/geometry/strategies/cartesian/side_by_triangle.hpp>
+#include <boost/geometry/strategies/covered_by.hpp>
+#include <boost/geometry/strategies/intersection.hpp>
+#include <boost/geometry/strategies/intersection_result.hpp>
+#include <boost/geometry/strategies/side.hpp>
+#include <boost/geometry/strategies/side_info.hpp>
+#include <boost/geometry/strategies/within.hpp>
+
+#include <boost/geometry/policies/robustness/robust_point_type.hpp>
+#include <boost/geometry/policies/robustness/segment_ratio_type.hpp>
+
+
+#if defined(BOOST_GEOMETRY_DEBUG_ROBUSTNESS)
+#  include <boost/geometry/io/wkt/write.hpp>
+#endif
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace intersection
+{
+
+
+/*!
+    \see http://mathworld.wolfram.com/Line-LineIntersection.html
+ */
+template
+<
+    typename CalculationType = void
+>
+struct cartesian_segments
+{
+    typedef side::side_by_triangle<CalculationType> side_strategy_type;
+
+    static inline side_strategy_type get_side_strategy()
+    {
+        return side_strategy_type();
+    }
+
+    template <typename Geometry1, typename Geometry2>
+    struct point_in_geometry_strategy
+    {
+        typedef strategy::within::winding
+            <
+                typename point_type<Geometry1>::type,
+                typename point_type<Geometry2>::type,
+                side_strategy_type,
+                CalculationType
+            > type;
+    };
+
+    template <typename Geometry1, typename Geometry2>
+    static inline typename point_in_geometry_strategy<Geometry1, Geometry2>::type
+        get_point_in_geometry_strategy()
+    {
+        typedef typename point_in_geometry_strategy
+            <
+                Geometry1, Geometry2
+            >::type strategy_type;
+        return strategy_type();
+    }
+
+    template <typename Geometry>
+    struct area_strategy
+    {
+        typedef area::surveyor
+            <
+                typename point_type<Geometry>::type,
+                CalculationType
+            > type;
+    };
+
+    template <typename Geometry>
+    static inline typename area_strategy<Geometry>::type get_area_strategy()
+    {
+        typedef typename area_strategy<Geometry>::type strategy_type;
+        return strategy_type();
+    }
+
+    template <typename Geometry>
+    struct distance_strategy
+    {
+        typedef distance::pythagoras
+            <
+                CalculationType
+            > type;
+    };
+
+    template <typename Geometry>
+    static inline typename distance_strategy<Geometry>::type get_distance_strategy()
+    {
+        typedef typename distance_strategy<Geometry>::type strategy_type;
+        return strategy_type();
+    }
+
+    typedef envelope::cartesian_segment<CalculationType>
+        envelope_strategy_type;
+
+    static inline envelope_strategy_type get_envelope_strategy()
+    {
+        return envelope_strategy_type();
+    }
+
+    template <typename CoordinateType, typename SegmentRatio>
+    struct segment_intersection_info
+    {
+        typedef typename select_most_precise
+            <
+                CoordinateType, double
+            >::type promoted_type;
+
+        promoted_type comparable_length_a() const
+        {
+            return dx_a * dx_a + dy_a * dy_a;
+        }
+
+        promoted_type comparable_length_b() const
+        {
+            return dx_b * dx_b + dy_b * dy_b;
+        }
+
+        template <typename Point, typename Segment1, typename Segment2>
+        void assign_a(Point& point, Segment1 const& a, Segment2 const& ) const
+        {
+            assign(point, a, dx_a, dy_a, robust_ra);
+        }
+        template <typename Point, typename Segment1, typename Segment2>
+        void assign_b(Point& point, Segment1 const& , Segment2 const& b) const
+        {
+            assign(point, b, dx_b, dy_b, robust_rb);
+        }
+
+        template <typename Point, typename Segment>
+        void assign(Point& point, Segment const& segment, CoordinateType const& dx, CoordinateType const& dy, SegmentRatio const& ratio) const
+        {
+            // Calculate the intersection point based on segment_ratio
+            // Up to now, division was postponed. Here we divide using numerator/
+            // denominator. In case of integer this results in an integer
+            // division.
+            BOOST_GEOMETRY_ASSERT(ratio.denominator() != 0);
+
+            typedef typename promote_integral<CoordinateType>::type promoted_type;
+
+            promoted_type const numerator
+                = boost::numeric_cast<promoted_type>(ratio.numerator());
+            promoted_type const denominator
+                = boost::numeric_cast<promoted_type>(ratio.denominator());
+            promoted_type const dx_promoted = boost::numeric_cast<promoted_type>(dx);
+            promoted_type const dy_promoted = boost::numeric_cast<promoted_type>(dy);
+
+            set<0>(point, get<0, 0>(segment) + boost::numeric_cast
+                <
+                    CoordinateType
+                >(numerator * dx_promoted / denominator));
+            set<1>(point, get<0, 1>(segment) + boost::numeric_cast
+                <
+                    CoordinateType
+                >(numerator * dy_promoted / denominator));
+        }
+
+        CoordinateType dx_a, dy_a;
+        CoordinateType dx_b, dy_b;
+        SegmentRatio robust_ra;
+        SegmentRatio robust_rb;
+    };
+
+    template <typename D, typename W, typename ResultType>
+    static inline void cramers_rule(D const& dx_a, D const& dy_a,
+        D const& dx_b, D const& dy_b, W const& wx, W const& wy,
+        // out:
+        ResultType& d, ResultType& da)
+    {
+        // Cramers rule
+        d = geometry::detail::determinant<ResultType>(dx_a, dy_a, dx_b, dy_b);
+        da = geometry::detail::determinant<ResultType>(dx_b, dy_b, wx, wy);
+        // Ratio is da/d , collinear if d == 0, intersecting if 0 <= r <= 1
+        // IntersectionPoint = (x1 + r * dx_a, y1 + r * dy_a)
+    }
+
+
+    // Relate segments a and b
+    template
+    <
+        typename Segment1,
+        typename Segment2,
+        typename Policy,
+        typename RobustPolicy
+    >
+    static inline typename Policy::return_type
+        apply(Segment1 const& a, Segment2 const& b,
+              Policy const& policy, RobustPolicy const& robust_policy)
+    {
+        // type them all as in Segment1 - TODO reconsider this, most precise?
+        typedef typename geometry::point_type<Segment1>::type point_type;
+
+        typedef typename geometry::robust_point_type
+            <
+                point_type, RobustPolicy
+            >::type robust_point_type;
+
+        point_type a0, a1, b0, b1;
+        robust_point_type a0_rob, a1_rob, b0_rob, b1_rob;
+
+        detail::assign_point_from_index<0>(a, a0);
+        detail::assign_point_from_index<1>(a, a1);
+        detail::assign_point_from_index<0>(b, b0);
+        detail::assign_point_from_index<1>(b, b1);
+
+        geometry::recalculate(a0_rob, a0, robust_policy);
+        geometry::recalculate(a1_rob, a1, robust_policy);
+        geometry::recalculate(b0_rob, b0, robust_policy);
+        geometry::recalculate(b1_rob, b1, robust_policy);
+
+        return apply(a, b, policy, robust_policy, a0_rob, a1_rob, b0_rob, b1_rob);
+    }
+
+    // The main entry-routine, calculating intersections of segments a / b
+    // NOTE: Robust* types may be the same as Segments' point types
+    template
+    <
+        typename Segment1,
+        typename Segment2,
+        typename Policy,
+        typename RobustPolicy,
+        typename RobustPoint1,
+        typename RobustPoint2
+    >
+    static inline typename Policy::return_type
+        apply(Segment1 const& a, Segment2 const& b,
+              Policy const&, RobustPolicy const& /*robust_policy*/,
+              RobustPoint1 const& robust_a1, RobustPoint1 const& robust_a2,
+              RobustPoint2 const& robust_b1, RobustPoint2 const& robust_b2)
+    {
+        BOOST_CONCEPT_ASSERT( (concepts::ConstSegment<Segment1>) );
+        BOOST_CONCEPT_ASSERT( (concepts::ConstSegment<Segment2>) );
+
+        using geometry::detail::equals::equals_point_point;
+        bool const a_is_point = equals_point_point(robust_a1, robust_a2);
+        bool const b_is_point = equals_point_point(robust_b1, robust_b2);
+
+        if(a_is_point && b_is_point)
+        {
+            return equals_point_point(robust_a1, robust_b2)
+                ? Policy::degenerate(a, true)
+                : Policy::disjoint()
+                ;
+        }
+
+        side_info sides;
+        sides.set<0>(side_strategy_type::apply(robust_b1, robust_b2, robust_a1),
+                     side_strategy_type::apply(robust_b1, robust_b2, robust_a2));
+
+        if (sides.same<0>())
+        {
+            // Both points are at same side of other segment, we can leave
+            return Policy::disjoint();
+        }
+
+        sides.set<1>(side_strategy_type::apply(robust_a1, robust_a2, robust_b1),
+                     side_strategy_type::apply(robust_a1, robust_a2, robust_b2));
+        
+        if (sides.same<1>())
+        {
+            // Both points are at same side of other segment, we can leave
+            return Policy::disjoint();
+        }
+
+        bool collinear = sides.collinear();
+
+        typedef typename select_most_precise
+            <
+                typename geometry::coordinate_type<RobustPoint1>::type,
+                typename geometry::coordinate_type<RobustPoint2>::type
+            >::type robust_coordinate_type;
+
+        typedef typename segment_ratio_type
+            <
+                typename geometry::point_type<Segment1>::type, // TODO: most precise point?
+                RobustPolicy
+            >::type ratio_type;
+
+        segment_intersection_info
+            <
+                typename select_calculation_type<Segment1, Segment2, CalculationType>::type,
+                ratio_type
+            > sinfo;
+
+        sinfo.dx_a = get<1, 0>(a) - get<0, 0>(a); // distance in x-dir
+        sinfo.dx_b = get<1, 0>(b) - get<0, 0>(b);
+        sinfo.dy_a = get<1, 1>(a) - get<0, 1>(a); // distance in y-dir
+        sinfo.dy_b = get<1, 1>(b) - get<0, 1>(b);
+
+        robust_coordinate_type const robust_dx_a = get<0>(robust_a2) - get<0>(robust_a1);
+        robust_coordinate_type const robust_dx_b = get<0>(robust_b2) - get<0>(robust_b1);
+        robust_coordinate_type const robust_dy_a = get<1>(robust_a2) - get<1>(robust_a1);
+        robust_coordinate_type const robust_dy_b = get<1>(robust_b2) - get<1>(robust_b1);
+
+        // r: ratio 0-1 where intersection divides A/B
+        // (only calculated for non-collinear segments)
+        if (! collinear)
+        {
+            robust_coordinate_type robust_da0, robust_da;
+            robust_coordinate_type robust_db0, robust_db;
+
+            cramers_rule(robust_dx_a, robust_dy_a, robust_dx_b, robust_dy_b,
+                get<0>(robust_a1) - get<0>(robust_b1),
+                get<1>(robust_a1) - get<1>(robust_b1),
+                robust_da0, robust_da);
+
+            cramers_rule(robust_dx_b, robust_dy_b, robust_dx_a, robust_dy_a,
+                get<0>(robust_b1) - get<0>(robust_a1),
+                get<1>(robust_b1) - get<1>(robust_a1),
+                robust_db0, robust_db);
+
+            math::detail::equals_factor_policy<robust_coordinate_type>
+                policy(robust_dx_a, robust_dy_a, robust_dx_b, robust_dy_b);
+            robust_coordinate_type const zero = 0;
+            if (math::detail::equals_by_policy(robust_da0, zero, policy)
+             || math::detail::equals_by_policy(robust_db0, zero, policy))
+            {
+                // If this is the case, no rescaling is done for FP precision.
+                // We set it to collinear, but it indicates a robustness issue.
+                sides.set<0>(0,0);
+                sides.set<1>(0,0);
+                collinear = true;
+            }
+            else
+            {
+                sinfo.robust_ra.assign(robust_da, robust_da0);
+                sinfo.robust_rb.assign(robust_db, robust_db0);
+            }
+        }
+
+        if (collinear)
+        {
+            std::pair<bool, bool> const collinear_use_first
+                    = is_x_more_significant(geometry::math::abs(robust_dx_a),
+                                            geometry::math::abs(robust_dy_a),
+                                            geometry::math::abs(robust_dx_b),
+                                            geometry::math::abs(robust_dy_b),
+                                            a_is_point, b_is_point);
+
+            if (collinear_use_first.second)
+            {
+                // Degenerate cases: segments of single point, lying on other segment, are not disjoint
+                // This situation is collinear too
+
+                if (collinear_use_first.first)
+                {
+                    return relate_collinear<0, Policy, ratio_type>(a, b,
+                            robust_a1, robust_a2, robust_b1, robust_b2,
+                            a_is_point, b_is_point);
+                }
+                else
+                {
+                    // Y direction contains larger segments (maybe dx is zero)
+                    return relate_collinear<1, Policy, ratio_type>(a, b,
+                            robust_a1, robust_a2, robust_b1, robust_b2,
+                            a_is_point, b_is_point);
+                }
+            }
+        }
+
+        return Policy::segments_crosses(sides, sinfo, a, b);
+    }
+
+private:
+    // first is true if x is more significant
+    // second is true if the more significant difference is not 0
+    template <typename RobustCoordinateType>
+    static inline std::pair<bool, bool>
+        is_x_more_significant(RobustCoordinateType const& abs_robust_dx_a,
+                              RobustCoordinateType const& abs_robust_dy_a,
+                              RobustCoordinateType const& abs_robust_dx_b,
+                              RobustCoordinateType const& abs_robust_dy_b,
+                              bool const a_is_point,
+                              bool const b_is_point)
+    {
+        //BOOST_GEOMETRY_ASSERT_MSG(!(a_is_point && b_is_point), "both segments shouldn't be degenerated");
+
+        // for degenerated segments the second is always true because this function
+        // shouldn't be called if both segments were degenerated
+
+        if (a_is_point)
+        {
+            return std::make_pair(abs_robust_dx_b >= abs_robust_dy_b, true);
+        }
+        else if (b_is_point)
+        {
+            return std::make_pair(abs_robust_dx_a >= abs_robust_dy_a, true);
+        }
+        else
+        {
+            RobustCoordinateType const min_dx = (std::min)(abs_robust_dx_a, abs_robust_dx_b);
+            RobustCoordinateType const min_dy = (std::min)(abs_robust_dy_a, abs_robust_dy_b);
+            return min_dx == min_dy ?
+                    std::make_pair(true, min_dx > RobustCoordinateType(0)) :
+                    std::make_pair(min_dx > min_dy, true);
+        }
+    }
+
+    template
+    <
+        std::size_t Dimension,
+        typename Policy,
+        typename RatioType,
+        typename Segment1,
+        typename Segment2,
+        typename RobustPoint1,
+        typename RobustPoint2
+    >
+    static inline typename Policy::return_type
+        relate_collinear(Segment1 const& a,
+                         Segment2 const& b,
+                         RobustPoint1 const& robust_a1, RobustPoint1 const& robust_a2,
+                         RobustPoint2 const& robust_b1, RobustPoint2 const& robust_b2,
+                         bool a_is_point, bool b_is_point)
+    {
+        if (a_is_point)
+        {
+            return relate_one_degenerate<Policy, RatioType>(a,
+                get<Dimension>(robust_a1),
+                get<Dimension>(robust_b1), get<Dimension>(robust_b2),
+                true);
+        }
+        if (b_is_point)
+        {
+            return relate_one_degenerate<Policy, RatioType>(b,
+                get<Dimension>(robust_b1),
+                get<Dimension>(robust_a1), get<Dimension>(robust_a2),
+                false);
+        }
+        return relate_collinear<Policy, RatioType>(a, b,
+                                get<Dimension>(robust_a1),
+                                get<Dimension>(robust_a2),
+                                get<Dimension>(robust_b1),
+                                get<Dimension>(robust_b2));
+    }
+
+    /// Relate segments known collinear
+    template
+    <
+        typename Policy,
+        typename RatioType,
+        typename Segment1,
+        typename Segment2,
+        typename RobustType1,
+        typename RobustType2
+    >
+    static inline typename Policy::return_type
+        relate_collinear(Segment1 const& a, Segment2 const& b,
+                         RobustType1 oa_1, RobustType1 oa_2,
+                         RobustType2 ob_1, RobustType2 ob_2)
+    {
+        // Calculate the ratios where a starts in b, b starts in a
+        //         a1--------->a2         (2..7)
+        //                b1----->b2      (5..8)
+        // length_a: 7-2=5
+        // length_b: 8-5=3
+        // b1 is located w.r.t. a at ratio: (5-2)/5=3/5 (on a)
+        // b2 is located w.r.t. a at ratio: (8-2)/5=6/5 (right of a)
+        // a1 is located w.r.t. b at ratio: (2-5)/3=-3/3 (left of b)
+        // a2 is located w.r.t. b at ratio: (7-5)/3=2/3 (on b)
+        // A arrives (a2 on b), B departs (b1 on a)
+
+        // If both are reversed:
+        //         a2<---------a1         (7..2)
+        //                b2<-----b1      (8..5)
+        // length_a: 2-7=-5
+        // length_b: 5-8=-3
+        // b1 is located w.r.t. a at ratio: (8-7)/-5=-1/5 (before a starts)
+        // b2 is located w.r.t. a at ratio: (5-7)/-5=2/5 (on a)
+        // a1 is located w.r.t. b at ratio: (7-8)/-3=1/3 (on b)
+        // a2 is located w.r.t. b at ratio: (2-8)/-3=6/3 (after b ends)
+
+        // If both one is reversed:
+        //         a1--------->a2         (2..7)
+        //                b2<-----b1      (8..5)
+        // length_a: 7-2=+5
+        // length_b: 5-8=-3
+        // b1 is located w.r.t. a at ratio: (8-2)/5=6/5 (after a ends)
+        // b2 is located w.r.t. a at ratio: (5-2)/5=3/5 (on a)
+        // a1 is located w.r.t. b at ratio: (2-8)/-3=6/3 (after b ends)
+        // a2 is located w.r.t. b at ratio: (7-8)/-3=1/3 (on b)
+        RobustType1 const length_a = oa_2 - oa_1; // no abs, see above
+        RobustType2 const length_b = ob_2 - ob_1;
+
+        RatioType ra_from(oa_1 - ob_1, length_b);
+        RatioType ra_to(oa_2 - ob_1, length_b);
+        RatioType rb_from(ob_1 - oa_1, length_a);
+        RatioType rb_to(ob_2 - oa_1, length_a);
+
+        // use absolute measure to detect endpoints intersection
+        // NOTE: it'd be possible to calculate bx_wrt_a using ax_wrt_b values
+        int const a1_wrt_b = position_value(oa_1, ob_1, ob_2);
+        int const a2_wrt_b = position_value(oa_2, ob_1, ob_2);
+        int const b1_wrt_a = position_value(ob_1, oa_1, oa_2);
+        int const b2_wrt_a = position_value(ob_2, oa_1, oa_2);
+        
+        // fix the ratios if necessary
+        // CONSIDER: fixing ratios also in other cases, if they're inconsistent
+        // e.g. if ratio == 1 or 0 (so IP at the endpoint)
+        // but position value indicates that the IP is in the middle of the segment
+        // because one of the segments is very long
+        // In such case the ratios could be moved into the middle direction
+        // by some small value (e.g. EPS+1ULP)
+        if (a1_wrt_b == 1)
+        {
+            ra_from.assign(0, 1);
+            rb_from.assign(0, 1);
+        }
+        else if (a1_wrt_b == 3)
+        {
+            ra_from.assign(1, 1);
+            rb_to.assign(0, 1);
+        } 
+
+        if (a2_wrt_b == 1)
+        {
+            ra_to.assign(0, 1);
+            rb_from.assign(1, 1);
+        }
+        else if (a2_wrt_b == 3)
+        {
+            ra_to.assign(1, 1);
+            rb_to.assign(1, 1);
+        }
+
+        if ((a1_wrt_b < 1 && a2_wrt_b < 1) || (a1_wrt_b > 3 && a2_wrt_b > 3))
+        //if ((ra_from.left() && ra_to.left()) || (ra_from.right() && ra_to.right()))
+        {
+            return Policy::disjoint();
+        }
+
+        bool const opposite = math::sign(length_a) != math::sign(length_b);
+
+        return Policy::segments_collinear(a, b, opposite,
+                                          a1_wrt_b, a2_wrt_b, b1_wrt_a, b2_wrt_a,
+                                          ra_from, ra_to, rb_from, rb_to);
+    }
+
+    /// Relate segments where one is degenerate
+    template
+    <
+        typename Policy,
+        typename RatioType,
+        typename DegenerateSegment,
+        typename RobustType1,
+        typename RobustType2
+    >
+    static inline typename Policy::return_type
+        relate_one_degenerate(DegenerateSegment const& degenerate_segment,
+                              RobustType1 d, RobustType2 s1, RobustType2 s2,
+                              bool a_degenerate)
+    {
+        // Calculate the ratios where ds starts in s
+        //         a1--------->a2         (2..6)
+        //              b1/b2      (4..4)
+        // Ratio: (4-2)/(6-2)
+        RatioType const ratio(d - s1, s2 - s1);
+
+        if (!ratio.on_segment())
+        {
+            return Policy::disjoint();
+        }
+
+        return Policy::one_degenerate(degenerate_segment, ratio, a_degenerate);
+    }
+
+    template <typename ProjCoord1, typename ProjCoord2>
+    static inline int position_value(ProjCoord1 const& ca1,
+                                     ProjCoord2 const& cb1,
+                                     ProjCoord2 const& cb2)
+    {
+        // S1x  0   1    2     3   4
+        // S2       |---------->
+        return math::equals(ca1, cb1) ? 1
+             : math::equals(ca1, cb2) ? 3
+             : cb1 < cb2 ?
+                ( ca1 < cb1 ? 0
+                : ca1 > cb2 ? 4
+                : 2 )
+              : ( ca1 > cb1 ? 0
+                : ca1 < cb2 ? 4
+                : 2 );
+    }
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+template <typename CalculationType>
+struct default_strategy<cartesian_tag, CalculationType>
+{
+    typedef cartesian_segments<CalculationType> type;
+};
+
+} // namespace services
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::intersection
+
+namespace strategy
+{
+
+namespace within { namespace services
+{
+
+template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
+struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, linear_tag, linear_tag, cartesian_tag, cartesian_tag>
+{
+    typedef strategy::intersection::cartesian_segments<> type;
+};
+
+template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
+struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, linear_tag, polygonal_tag, cartesian_tag, cartesian_tag>
+{
+    typedef strategy::intersection::cartesian_segments<> type;
+};
+
+template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
+struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, polygonal_tag, linear_tag, cartesian_tag, cartesian_tag>
+{
+    typedef strategy::intersection::cartesian_segments<> type;
+};
+
+template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
+struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, polygonal_tag, polygonal_tag, cartesian_tag, cartesian_tag>
+{
+    typedef strategy::intersection::cartesian_segments<> type;
+};
+
+}} // within::services
+
+namespace covered_by { namespace services
+{
+
+template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
+struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, linear_tag, linear_tag, cartesian_tag, cartesian_tag>
+{
+    typedef strategy::intersection::cartesian_segments<> type;
+};
+
+template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
+struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, linear_tag, polygonal_tag, cartesian_tag, cartesian_tag>
+{
+    typedef strategy::intersection::cartesian_segments<> type;
+};
+
+template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
+struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, polygonal_tag, linear_tag, cartesian_tag, cartesian_tag>
+{
+    typedef strategy::intersection::cartesian_segments<> type;
+};
+
+template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
+struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, polygonal_tag, polygonal_tag, cartesian_tag, cartesian_tag>
+{
+    typedef strategy::intersection::cartesian_segments<> type;
+};
+
+}} // within::services
+
+} // strategy
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_INTERSECTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/point_in_box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/point_in_box.hpp
new file mode 100644
index 00000000000..1c14125a6da
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/point_in_box.hpp
@@ -0,0 +1,295 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015-2017.
+// Modifications copyright (c) 2015-2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_POINT_IN_BOX_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_POINT_IN_BOX_HPP
+
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/strategies/covered_by.hpp>
+#include <boost/geometry/strategies/within.hpp>
+#include <boost/geometry/util/normalize_spheroidal_coordinates.hpp>
+
+
+namespace boost { namespace geometry { namespace strategy
+{
+
+namespace within
+{
+
+struct within_coord
+{
+    template <typename Value1, typename Value2>
+    static inline bool apply(Value1 const& value, Value2 const& min_value, Value2 const& max_value)
+    {
+        return value > min_value && value < max_value;
+    }
+};
+
+struct covered_by_coord
+{
+    template <typename Value1, typename Value2>
+    static inline bool apply(Value1 const& value, Value2 const& min_value, Value2 const& max_value)
+    {
+        return value >= min_value && value <= max_value;
+    }
+};
+
+template <typename Geometry, std::size_t Dimension, typename CSTag>
+struct within_range
+    : within_coord
+{};
+
+
+template <typename Geometry, std::size_t Dimension, typename CSTag>
+struct covered_by_range
+    : covered_by_coord
+{};
+
+
+// NOTE: the result would be the same if instead of structs defined below
+// the above xxx_range were used with the following arguments:
+// (min_value + diff_min, min_value, max_value)
+struct within_longitude_diff
+{
+    template <typename CalcT>
+    static inline bool apply(CalcT const& diff_min, CalcT const& min_value, CalcT const& max_value)
+    {
+        CalcT const c0 = 0;
+        return diff_min > c0
+            && (min_value + diff_min < max_value
+             /*|| max_value - diff_min > min_value*/);
+    }
+};
+
+struct covered_by_longitude_diff
+{
+    template <typename CalcT>
+    static inline bool apply(CalcT const& diff_min, CalcT const& min_value, CalcT const& max_value)
+    {
+        return min_value + diff_min <= max_value
+            /*|| max_value - diff_min >= min_value*/;
+    }
+};
+
+
+template <typename Geometry,
+          typename CoordCheck,
+          typename DiffCheck>
+struct longitude_range
+{
+    template <typename Value1, typename Value2>
+    static inline bool apply(Value1 const& value, Value2 const& min_value, Value2 const& max_value)
+    {
+        typedef typename select_most_precise
+            <
+                Value1, Value2
+            >::type calc_t;
+        typedef typename coordinate_system<Geometry>::type::units units_t;
+        typedef math::detail::constants_on_spheroid<calc_t, units_t> constants;
+
+        if (CoordCheck::apply(value, min_value, max_value))
+        {
+            return true;
+        }
+
+        // min <= max <=> diff >= 0
+        calc_t const diff_ing = max_value - min_value;
+
+        // if containing covers the whole globe it contains all
+        if (diff_ing >= constants::period())
+        {
+            return true;
+        }
+
+        // calculate positive longitude translation with min_value as origin
+        calc_t const diff_min = math::longitude_distance_unsigned<units_t, calc_t>(min_value, value);
+
+        return DiffCheck::template apply<calc_t>(diff_min, min_value, max_value);
+    }
+};
+
+
+// spherical_equatorial_tag, spherical_polar_tag and geographic_cat are casted to spherical_tag
+template <typename Geometry>
+struct within_range<Geometry, 0, spherical_tag>
+    : longitude_range<Geometry, within_coord, within_longitude_diff>
+{};
+
+
+template <typename Geometry>
+struct covered_by_range<Geometry, 0, spherical_tag>
+    : longitude_range<Geometry, covered_by_coord, covered_by_longitude_diff>
+{};
+
+
+template
+<
+    template <typename, std::size_t, typename> class SubStrategy,
+    typename Point,
+    typename Box,
+    std::size_t Dimension,
+    std::size_t DimensionCount
+>
+struct relate_point_box_loop
+{
+    static inline bool apply(Point const& point, Box const& box)
+    {
+        typedef typename tag_cast<typename cs_tag<Point>::type, spherical_tag>::type cs_tag_t;
+
+        if (! SubStrategy<Point, Dimension, cs_tag_t>::apply(get<Dimension>(point),
+                    get<min_corner, Dimension>(box),
+                    get<max_corner, Dimension>(box))
+            )
+        {
+            return false;
+        }
+
+        return relate_point_box_loop
+            <
+                SubStrategy,
+                Point, Box,
+                Dimension + 1, DimensionCount
+            >::apply(point, box);
+    }
+};
+
+
+template
+<
+    template <typename, std::size_t, typename> class SubStrategy,
+    typename Point,
+    typename Box,
+    std::size_t DimensionCount
+>
+struct relate_point_box_loop<SubStrategy, Point, Box, DimensionCount, DimensionCount>
+{
+    static inline bool apply(Point const& , Box const& )
+    {
+        return true;
+    }
+};
+
+
+template
+<
+    typename Point,
+    typename Box,
+    template <typename, std::size_t, typename> class SubStrategy = within_range
+>
+struct point_in_box
+{
+    static inline bool apply(Point const& point, Box const& box)
+    {
+        return relate_point_box_loop
+            <
+                SubStrategy,
+                Point, Box,
+                0, dimension<Point>::type::value
+            >::apply(point, box);
+    }
+};
+
+
+} // namespace within
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+namespace within { namespace services
+{
+
+template <typename Point, typename Box>
+struct default_strategy
+    <
+        Point, Box,
+        point_tag, box_tag,
+        pointlike_tag, areal_tag,
+        cartesian_tag, cartesian_tag
+    >
+{
+    typedef within::point_in_box<Point, Box> type;
+};
+
+// spherical_equatorial_tag, spherical_polar_tag and geographic_cat are casted to spherical_tag
+template <typename Point, typename Box>
+struct default_strategy
+    <
+        Point, Box,
+        point_tag, box_tag,
+        pointlike_tag, areal_tag,
+        spherical_tag, spherical_tag
+    >
+{
+    typedef within::point_in_box<Point, Box> type;
+};
+
+
+}} // namespace within::services
+
+
+namespace covered_by { namespace services
+{
+
+
+template <typename Point, typename Box>
+struct default_strategy
+    <
+        Point, Box,
+        point_tag, box_tag,
+        pointlike_tag, areal_tag,
+        cartesian_tag, cartesian_tag
+    >
+{
+    typedef within::point_in_box
+                <
+                    Point, Box,
+                    within::covered_by_range
+                > type;
+};
+
+// spherical_equatorial_tag, spherical_polar_tag and geographic_cat are casted to spherical_tag
+template <typename Point, typename Box>
+struct default_strategy
+    <
+        Point, Box,
+        point_tag, box_tag,
+        pointlike_tag, areal_tag,
+        spherical_tag, spherical_tag
+    >
+{
+    typedef within::point_in_box
+                <
+                    Point, Box,
+                    within::covered_by_range
+                > type;
+};
+
+
+}} // namespace covered_by::services
+
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}}} // namespace boost::geometry::strategy
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_POINT_IN_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/point_in_poly_crossings_multiply.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/point_in_poly_crossings_multiply.hpp
new file mode 100644
index 00000000000..94da5cc6775
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/point_in_poly_crossings_multiply.hpp
@@ -0,0 +1,124 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_POINT_IN_POLY_CROSSINGS_MULTIPLY_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_POINT_IN_POLY_CROSSINGS_MULTIPLY_HPP
+
+
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/util/select_calculation_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace within
+{
+
+/*!
+\brief Within detection using cross counting,
+\ingroup strategies
+\tparam Point \tparam_point
+\tparam PointOfSegment \tparam_segment_point
+\tparam CalculationType \tparam_calculation
+\see http://tog.acm.org/resources/GraphicsGems/gemsiv/ptpoly_haines/ptinpoly.c
+\note Does NOT work correctly for point ON border
+\qbk{
+[heading See also]
+[link geometry.reference.algorithms.within.within_3_with_strategy within (with strategy)]
+}
+ */
+
+template
+<
+    typename Point,
+    typename PointOfSegment = Point,
+    typename CalculationType = void
+>
+class crossings_multiply
+{
+    typedef typename select_calculation_type
+        <
+            Point,
+            PointOfSegment,
+            CalculationType
+        >::type calculation_type;
+
+    class flags
+    {
+        bool inside_flag;
+        bool first;
+        bool yflag0;
+
+    public :
+
+        friend class crossings_multiply;
+
+        inline flags()
+            : inside_flag(false)
+            , first(true)
+            , yflag0(false)
+        {}
+    };
+
+public :
+
+    typedef Point point_type;
+    typedef PointOfSegment segment_point_type;
+    typedef flags state_type;
+
+    static inline bool apply(Point const& point,
+            PointOfSegment const& seg1, PointOfSegment const& seg2,
+            flags& state)
+    {
+        calculation_type const tx = get<0>(point);
+        calculation_type const ty = get<1>(point);
+        calculation_type const x0 = get<0>(seg1);
+        calculation_type const y0 = get<1>(seg1);
+        calculation_type const x1 = get<0>(seg2);
+        calculation_type const y1 = get<1>(seg2);
+
+        if (state.first)
+        {
+            state.first = false;
+            state.yflag0 = y0 >= ty;
+        }
+
+
+        bool yflag1 = y1 >= ty;
+        if (state.yflag0 != yflag1)
+        {
+            if ( ((y1-ty) * (x0-x1) >= (x1-tx) * (y0-y1)) == yflag1 )
+            {
+                state.inside_flag = ! state.inside_flag;
+            }
+        }
+        state.yflag0 = yflag1;
+        return true;
+    }
+
+    static inline int result(flags const& state)
+    {
+        return state.inside_flag ? 1 : -1;
+    }
+};
+
+
+
+}} // namespace strategy::within
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_POINT_IN_POLY_CROSSINGS_MULTIPLY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/point_in_poly_franklin.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/point_in_poly_franklin.hpp
new file mode 100644
index 00000000000..a774d3c52dc
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/point_in_poly_franklin.hpp
@@ -0,0 +1,118 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_POINT_IN_POLY_FRANKLIN_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_POINT_IN_POLY_FRANKLIN_HPP
+
+
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/util/select_calculation_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace within
+{
+
+/*!
+\brief Within detection using cross counting
+\ingroup strategies
+\tparam Point \tparam_point
+\tparam PointOfSegment \tparam_segment_point
+\tparam CalculationType \tparam_calculation
+\author adapted from Randolph Franklin algorithm
+\author Barend and Maarten, 1995
+\author Revised for templatized library, Barend Gehrels, 2007
+\return true if point is in ring, works for closed rings in both directions
+\note Does NOT work correctly for point ON border
+
+\qbk{
+[heading See also]
+[link geometry.reference.algorithms.within.within_3_with_strategy within (with strategy)]
+}
+ */
+
+template
+<
+    typename Point,
+    typename PointOfSegment = Point,
+    typename CalculationType = void
+>
+class franklin
+{
+    typedef typename select_calculation_type
+        <
+            Point,
+            PointOfSegment,
+            CalculationType
+        >::type calculation_type;
+
+        /*! subclass to keep state */
+        class crossings
+        {
+            bool crosses;
+
+        public :
+
+            friend class franklin;
+            inline crossings()
+                : crosses(false)
+            {}
+        };
+
+public :
+
+    typedef Point point_type;
+    typedef PointOfSegment segment_point_type;
+    typedef crossings state_type;
+
+    static inline bool apply(Point const& point,
+            PointOfSegment const& seg1, PointOfSegment const& seg2,
+            crossings& state)
+    {
+        calculation_type const& px = get<0>(point);
+        calculation_type const& py = get<1>(point);
+        calculation_type const& x1 = get<0>(seg1);
+        calculation_type const& y1 = get<1>(seg1);
+        calculation_type const& x2 = get<0>(seg2);
+        calculation_type const& y2 = get<1>(seg2);
+
+        if (
+            ( (y2 <= py && py < y1) || (y1 <= py && py < y2) )
+            && (px < (x1 - x2) * (py - y2) / (y1 - y2) + x2)
+            )
+        {
+            state.crosses = ! state.crosses;
+        }
+        return true;
+    }
+
+    static inline int result(crossings const& state)
+    {
+        return state.crosses ? 1 : -1;
+    }
+};
+
+
+
+}} // namespace strategy::within
+
+
+
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_POINT_IN_POLY_FRANKLIN_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/side_by_triangle.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/side_by_triangle.hpp
new file mode 100644
index 00000000000..4d1d97520f5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/side_by_triangle.hpp
@@ -0,0 +1,280 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_SIDE_BY_TRIANGLE_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_SIDE_BY_TRIANGLE_HPP
+
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_void.hpp>
+
+#include <boost/geometry/arithmetic/determinant.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/util/select_coordinate_type.hpp>
+
+#include <boost/geometry/strategies/cartesian/disjoint_segment_box.hpp>
+#include <boost/geometry/strategies/cartesian/envelope_segment.hpp>
+#include <boost/geometry/strategies/side.hpp>
+
+#include <boost/geometry/algorithms/detail/relate/less.hpp>
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace side
+{
+
+/*!
+\brief Check at which side of a segment a point lies:
+    left of segment (> 0), right of segment (< 0), on segment (0)
+\ingroup strategies
+\tparam CalculationType \tparam_calculation
+ */
+template <typename CalculationType = void>
+class side_by_triangle
+{
+    template <typename Policy>
+    struct eps_policy
+    {
+        eps_policy() {}
+        template <typename Type>
+        eps_policy(Type const& a, Type const& b, Type const& c, Type const& d)
+            : policy(a, b, c, d)
+        {}
+        Policy policy;
+    };
+
+    struct eps_empty
+    {
+        eps_empty() {}
+        template <typename Type>
+        eps_empty(Type const&, Type const&, Type const&, Type const&) {}
+    };
+
+public :
+    typedef strategy::envelope::cartesian_segment<CalculationType> envelope_strategy_type;
+
+    static inline envelope_strategy_type get_envelope_strategy()
+    {
+        return envelope_strategy_type();
+    }
+
+    typedef strategy::disjoint::segment_box disjoint_strategy_type;
+
+    static inline disjoint_strategy_type get_disjoint_strategy()
+    {
+        return disjoint_strategy_type();
+    }
+
+    // Template member function, because it is not always trivial
+    // or convenient to explicitly mention the typenames in the
+    // strategy-struct itself.
+
+    // Types can be all three different. Therefore it is
+    // not implemented (anymore) as "segment"
+
+    template
+    <
+        typename CoordinateType,
+        typename PromotedType,
+        typename P1,
+        typename P2,
+        typename P,
+        typename EpsPolicy
+    >
+    static inline
+    PromotedType side_value(P1 const& p1, P2 const& p2, P const& p, EpsPolicy & eps_policy)
+    {
+        CoordinateType const x = get<0>(p);
+        CoordinateType const y = get<1>(p);
+
+        CoordinateType const sx1 = get<0>(p1);
+        CoordinateType const sy1 = get<1>(p1);
+        CoordinateType const sx2 = get<0>(p2);
+        CoordinateType const sy2 = get<1>(p2);
+
+        PromotedType const dx = sx2 - sx1;
+        PromotedType const dy = sy2 - sy1;
+        PromotedType const dpx = x - sx1;
+        PromotedType const dpy = y - sy1;
+
+        eps_policy = EpsPolicy(dx, dy, dpx, dpy);
+
+        return geometry::detail::determinant<PromotedType>
+                (
+                    dx, dy,
+                    dpx, dpy
+                );
+
+    }
+
+    template
+    <
+        typename CoordinateType,
+        typename PromotedType,
+        typename P1,
+        typename P2,
+        typename P
+    >
+    static inline
+    PromotedType side_value(P1 const& p1, P2 const& p2, P const& p)
+    {
+        eps_empty dummy;
+        return side_value<CoordinateType, PromotedType>(p1, p2, p, dummy);
+    }
+
+
+    template
+    <
+        typename CoordinateType,
+        typename PromotedType,
+        bool AreAllIntegralCoordinates
+    >
+    struct compute_side_value
+    {
+        template <typename P1, typename P2, typename P, typename EpsPolicy>
+        static inline PromotedType apply(P1 const& p1, P2 const& p2, P const& p, EpsPolicy & epsp)
+        {
+            return side_value<CoordinateType, PromotedType>(p1, p2, p, epsp);
+        }
+    };
+
+    template <typename CoordinateType, typename PromotedType>
+    struct compute_side_value<CoordinateType, PromotedType, false>
+    {
+        template <typename P1, typename P2, typename P, typename EpsPolicy>
+        static inline PromotedType apply(P1 const& p1, P2 const& p2, P const& p, EpsPolicy & epsp)
+        {
+            // For robustness purposes, first check if any two points are
+            // the same; in this case simply return that the points are
+            // collinear
+            if (geometry::detail::equals::equals_point_point(p1, p2)
+                || geometry::detail::equals::equals_point_point(p1, p)
+                || geometry::detail::equals::equals_point_point(p2, p))
+            {
+                return PromotedType(0);
+            }
+
+            // The side_by_triangle strategy computes the signed area of
+            // the point triplet (p1, p2, p); as such it is (in theory)
+            // invariant under cyclic permutations of its three arguments.
+            //
+            // In the context of numerical errors that arise in
+            // floating-point computations, and in order to make the strategy
+            // consistent with respect to cyclic permutations of its three
+            // arguments, we cyclically permute them so that the first
+            // argument is always the lexicographically smallest point.
+
+            geometry::detail::relate::less less;
+            if (less(p, p1))
+            {
+                if (less(p, p2))
+                {
+                    // p is the lexicographically smallest
+                    return side_value<CoordinateType, PromotedType>(p, p1, p2, epsp);
+                }
+                else
+                {
+                    // p2 is the lexicographically smallest
+                    return side_value<CoordinateType, PromotedType>(p2, p, p1, epsp);
+                }
+            }
+
+            if (less(p1, p2))
+            {
+                // p1 is the lexicographically smallest
+                return side_value<CoordinateType, PromotedType>(p1, p2, p, epsp);
+            }
+            else
+            {
+                // p2 is the lexicographically smallest
+                return side_value<CoordinateType, PromotedType>(p2, p, p1, epsp);
+            }
+        }
+    };
+
+
+    template <typename P1, typename P2, typename P>
+    static inline int apply(P1 const& p1, P2 const& p2, P const& p)
+    {
+        typedef typename coordinate_type<P1>::type coordinate_type1;
+        typedef typename coordinate_type<P2>::type coordinate_type2;
+        typedef typename coordinate_type<P>::type coordinate_type3;
+
+        typedef typename boost::mpl::if_c
+            <
+                boost::is_void<CalculationType>::type::value,
+                typename select_most_precise
+                    <
+                        typename select_most_precise
+                            <
+                                coordinate_type1, coordinate_type2
+                            >::type,
+                        coordinate_type3
+                    >::type,
+                CalculationType
+            >::type coordinate_type;
+
+        // Promote float->double, small int->int
+        typedef typename select_most_precise
+            <
+                coordinate_type,
+                double
+            >::type promoted_type;
+
+        bool const are_all_integral_coordinates =
+            boost::is_integral<coordinate_type1>::value
+            && boost::is_integral<coordinate_type2>::value
+            && boost::is_integral<coordinate_type3>::value;
+
+        eps_policy< math::detail::equals_factor_policy<promoted_type> > epsp;
+        promoted_type s = compute_side_value
+            <
+                coordinate_type, promoted_type, are_all_integral_coordinates
+            >::apply(p1, p2, p, epsp);
+
+        promoted_type const zero = promoted_type();
+        return math::detail::equals_by_policy(s, zero, epsp.policy) ? 0
+            : s > zero ? 1
+            : -1;
+    }
+
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+template <typename CalculationType>
+struct default_strategy<cartesian_tag, CalculationType>
+{
+    typedef side_by_triangle<CalculationType> type;
+};
+
+}
+#endif
+
+}} // namespace strategy::side
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_SIDE_BY_TRIANGLE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/side_of_intersection.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/side_of_intersection.hpp
new file mode 100644
index 00000000000..db57644ad55
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/cartesian/side_of_intersection.hpp
@@ -0,0 +1,349 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CARTESIAN_SIDE_OF_INTERSECTION_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CARTESIAN_SIDE_OF_INTERSECTION_HPP
+
+
+#include <limits>
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+
+#include <boost/geometry/arithmetic/determinant.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/algorithms/detail/assign_indexed_point.hpp>
+#include <boost/geometry/strategies/cartesian/side_by_triangle.hpp>
+#include <boost/geometry/util/math.hpp>
+
+#ifdef BOOST_GEOMETRY_SIDE_OF_INTERSECTION_DEBUG
+#include <boost/math/common_factor_ct.hpp>
+#include <boost/math/common_factor_rt.hpp>
+#include <boost/multiprecision/cpp_int.hpp>
+#endif
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace side
+{
+
+namespace detail
+{
+
+// A tool for multiplication of integers avoiding overflow
+// It's a temporary workaround until we can use Multiprecision
+// The algorithm is based on Karatsuba algorithm
+// see: http://en.wikipedia.org/wiki/Karatsuba_algorithm
+template <typename T>
+struct multiplicable_integral
+{
+    // Currently this tool can't be used with non-integral coordinate types.
+    // Also side_of_intersection strategy sign_of_product() and sign_of_compare()
+    // functions would have to be modified to properly support floating-point
+    // types (comparisons and multiplication).
+    BOOST_STATIC_ASSERT(boost::is_integral<T>::value);
+
+    static const std::size_t bits = CHAR_BIT * sizeof(T);
+    static const std::size_t half_bits = bits / 2;
+    typedef typename boost::make_unsigned<T>::type unsigned_type;
+    static const unsigned_type base = unsigned_type(1) << half_bits; // 2^half_bits
+
+    int m_sign;
+    unsigned_type m_ms;
+    unsigned_type m_ls;
+
+    multiplicable_integral(int sign, unsigned_type ms, unsigned_type ls)
+        : m_sign(sign), m_ms(ms), m_ls(ls)
+    {}
+
+    explicit multiplicable_integral(T const& val)
+    {
+        unsigned_type val_u = val > 0 ?
+                                unsigned_type(val)
+                              : val == (std::numeric_limits<T>::min)() ?
+                                  unsigned_type((std::numeric_limits<T>::max)()) + 1
+                                : unsigned_type(-val);
+        // MMLL -> S 00MM 00LL
+        m_sign = math::sign(val);
+        m_ms = val_u >> half_bits; // val_u / base
+        m_ls = val_u - m_ms * base;
+    }
+    
+    friend multiplicable_integral operator*(multiplicable_integral const& a,
+                                            multiplicable_integral const& b)
+    {
+        // (S 00MM 00LL) * (S 00MM 00LL) -> (S Z2MM 00LL)
+        unsigned_type z2 = a.m_ms * b.m_ms;
+        unsigned_type z0 = a.m_ls * b.m_ls;
+        unsigned_type z1 = (a.m_ms + a.m_ls) * (b.m_ms + b.m_ls) - z2 - z0;
+        // z0 may be >= base so it must be normalized to allow comparison
+        unsigned_type z0_ms = z0 >> half_bits; // z0 / base
+        return multiplicable_integral(a.m_sign * b.m_sign,
+                                      z2 * base + z1 + z0_ms,
+                                      z0 - base * z0_ms);
+    }
+
+    friend bool operator<(multiplicable_integral const& a,
+                          multiplicable_integral const& b)
+    {
+        if ( a.m_sign == b.m_sign )
+        {
+            bool u_less = a.m_ms < b.m_ms
+                      || (a.m_ms == b.m_ms && a.m_ls < b.m_ls);
+            return a.m_sign > 0 ? u_less : (! u_less);
+        }
+        else
+        {
+            return a.m_sign < b.m_sign;
+        }
+    }
+
+    friend bool operator>(multiplicable_integral const& a,
+                          multiplicable_integral const& b)
+    {
+        return b < a;
+    }
+
+    template <typename CmpVal>
+    void check_value(CmpVal const& cmp_val) const
+    {
+        unsigned_type b = base; // a workaround for MinGW - undefined reference base
+        CmpVal val = CmpVal(m_sign) * (CmpVal(m_ms) * CmpVal(b) + CmpVal(m_ls));
+        BOOST_GEOMETRY_ASSERT(cmp_val == val);
+    }
+};
+
+} // namespace detail
+
+// Calculates the side of the intersection-point (if any) of
+// of segment a//b w.r.t. segment c
+// This is calculated without (re)calculating the IP itself again and fully
+// based on integer mathematics; there are no divisions
+// It can be used for either integer (rescaled) points, and also for FP
+class side_of_intersection
+{
+private :
+    template <typename T, typename U>
+    static inline
+    int sign_of_product(T const& a, U const& b)
+    {
+        return a == 0 || b == 0 ? 0
+            : a > 0 && b > 0 ? 1
+            : a < 0 && b < 0 ? 1
+            : -1;
+    }
+
+    template <typename T>
+    static inline
+    int sign_of_compare(T const& a, T const& b, T const& c, T const& d)
+    {
+        // Both a*b and c*d are positive
+        // We have to judge if a*b > c*d
+
+        using side::detail::multiplicable_integral;
+        multiplicable_integral<T> ab = multiplicable_integral<T>(a)
+                                     * multiplicable_integral<T>(b);
+        multiplicable_integral<T> cd = multiplicable_integral<T>(c)
+                                     * multiplicable_integral<T>(d);
+        
+        int result = ab > cd ? 1
+                   : ab < cd ? -1
+                   : 0
+                   ;
+
+#ifdef BOOST_GEOMETRY_SIDE_OF_INTERSECTION_DEBUG
+        using namespace boost::multiprecision;
+        cpp_int const lab = cpp_int(a) * cpp_int(b);
+        cpp_int const lcd = cpp_int(c) * cpp_int(d);
+
+        ab.check_value(lab);
+        cd.check_value(lcd);
+
+        int result2 = lab > lcd ? 1
+                    : lab < lcd ? -1
+                    : 0
+                    ;
+        BOOST_GEOMETRY_ASSERT(result == result2);
+#endif
+
+        return result;
+    }
+
+    template <typename T>
+    static inline
+    int sign_of_addition_of_two_products(T const& a, T const& b, T const& c, T const& d)
+    {
+        // sign of a*b+c*d, 1 if positive, -1 if negative, else 0
+        int const ab = sign_of_product(a, b);
+        int const cd = sign_of_product(c, d);
+        if (ab == 0)
+        {
+            return cd;
+        }
+        if (cd == 0)
+        {
+            return ab;
+        }
+
+        if (ab == cd)
+        {
+            // Both positive or both negative
+            return ab;
+        }
+
+        // One is positive, one is negative, both are non zero
+        // If ab is positive, we have to judge if a*b > -c*d (then 1 because sum is positive)
+        // If ab is negative, we have to judge if c*d > -a*b (idem)
+        return ab == 1
+            ? sign_of_compare(a, b, -c, d)
+            : sign_of_compare(c, d, -a, b);
+    }
+
+
+public :
+
+    // Calculates the side of the intersection-point (if any) of
+    // of segment a//b w.r.t. segment c
+    // This is calculated without (re)calculating the IP itself again and fully
+    // based on integer mathematics
+    template <typename T, typename Segment, typename Point>
+    static inline T side_value(Segment const& a, Segment const& b,
+                Segment const& c, Point const& fallback_point)
+    {
+        // The first point of the three segments is reused several times
+        T const ax = get<0, 0>(a);
+        T const ay = get<0, 1>(a);
+        T const bx = get<0, 0>(b);
+        T const by = get<0, 1>(b);
+        T const cx = get<0, 0>(c);
+        T const cy = get<0, 1>(c);
+
+        T const dx_a = get<1, 0>(a) - ax;
+        T const dy_a = get<1, 1>(a) - ay;
+
+        T const dx_b = get<1, 0>(b) - bx;
+        T const dy_b = get<1, 1>(b) - by;
+
+        T const dx_c = get<1, 0>(c) - cx;
+        T const dy_c = get<1, 1>(c) - cy;
+
+        // Cramer's rule: d (see cart_intersect.hpp)
+        T const d = geometry::detail::determinant<T>
+                    (
+                        dx_a, dy_a,
+                        dx_b, dy_b
+                    );
+
+        T const zero = T();
+        if (d == zero)
+        {
+            // There is no IP of a//b, they are collinear or parallel
+            // Assuming they intersect (this method should be called for
+            // segments known to intersect), they are collinear and overlap.
+            // They have one or two intersection points - we don't know and
+            // have to rely on the fallback intersection point
+
+            Point c1, c2;
+            geometry::detail::assign_point_from_index<0>(c, c1);
+            geometry::detail::assign_point_from_index<1>(c, c2);
+            return side_by_triangle<>::apply(c1, c2, fallback_point);
+        }
+
+        // Cramer's rule: da (see cart_intersect.hpp)
+        T const da = geometry::detail::determinant<T>
+                    (
+                        dx_b,    dy_b,
+                        ax - bx, ay - by
+                    );
+
+        // IP is at (ax + (da/d) * dx_a, ay + (da/d) * dy_a)
+        // Side of IP is w.r.t. c is: determinant(dx_c, dy_c, ipx-cx, ipy-cy)
+        // We replace ipx by expression above and multiply each term by d
+
+#ifdef BOOST_GEOMETRY_SIDE_OF_INTERSECTION_DEBUG
+        T const result1 = geometry::detail::determinant<T>
+                    (
+                        dx_c * d,                   dy_c * d,
+                        d * (ax - cx) + dx_a * da,  d * (ay - cy) + dy_a * da
+                    );
+
+        // Note: result / (d * d)
+        // is identical to the side_value of side_by_triangle
+        // Therefore, the sign is always the same as that result, and the
+        // resulting side (left,right,collinear) is the same
+
+        // The first row we divide again by d because of determinant multiply rule
+        T const result2 = d * geometry::detail::determinant<T>
+                    (
+                        dx_c,                   dy_c,
+                        d * (ax - cx) + dx_a * da,  d * (ay - cy) + dy_a * da
+                    );
+        // Write out:
+        T const result3 = d * (dx_c * (d * (ay - cy) + dy_a * da)
+                             - dy_c * (d * (ax - cx) + dx_a * da));
+        // Write out in braces:
+        T const result4 = d * (dx_c * d * (ay - cy) + dx_c * dy_a * da
+                             - dy_c * d * (ax - cx) - dy_c * dx_a * da);
+        // Write in terms of d * XX + da * YY
+        T const result5 = d * (d * (dx_c * (ay - cy) - dy_c * (ax - cx))
+                             + da * (dx_c * dy_a - dy_c * dx_a));
+
+        boost::ignore_unused(result1, result2, result3, result4, result5);
+        //return result;
+#endif
+
+        // We consider the results separately
+        // (in the end we only have to return the side-value 1,0 or -1)
+
+        // To avoid multiplications we judge the product (easy, avoids *d)
+        // and the sign of p*q+r*s (more elaborate)
+        T const result = sign_of_product
+            (
+                d,
+                sign_of_addition_of_two_products
+                    (
+                        d, dx_c * (ay - cy) - dy_c * (ax - cx),
+                        da, dx_c * dy_a - dy_c * dx_a
+                    )
+                );
+        return result;
+
+
+    }
+
+    template <typename Segment, typename Point>
+    static inline int apply(Segment const& a, Segment const& b,
+            Segment const& c,
+            Point const& fallback_point)
+    {
+        typedef typename geometry::coordinate_type<Segment>::type coordinate_type;
+        coordinate_type const s = side_value<coordinate_type>(a, b, c, fallback_point);
+        coordinate_type const zero = coordinate_type();
+        return math::equals(s, zero) ? 0
+            : s > zero ? 1
+            : -1;
+    }
+
+};
+
+
+}} // namespace strategy::side
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CARTESIAN_SIDE_OF_INTERSECTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/centroid.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/centroid.hpp
new file mode 100644
index 00000000000..4963e6b40b7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/centroid.hpp
@@ -0,0 +1,72 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CENTROID_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CENTROID_HPP
+
+
+#include <cstddef>
+
+#include <boost/mpl/assert.hpp>
+
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/strategies/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace centroid
+{
+
+struct not_applicable_strategy
+{
+};
+
+
+namespace services
+{
+
+/*!
+    \brief Traits class binding a centroid calculation strategy to a coordinate system
+    \ingroup centroid
+    \tparam CsTag tag of coordinate system, for specialization
+    \tparam GeometryTag tag of geometry, for specialization
+    \tparam Dimension dimension of geometry, for specialization
+    \tparam Point point-type
+    \tparam Geometry
+*/
+template
+<
+    typename CsTag,
+    typename GeometryTag,
+    std::size_t Dimension,
+    typename Point,
+    typename Geometry
+>
+struct default_strategy
+{
+    typedef not_applicable_strategy type;
+};
+
+
+} // namespace services
+
+
+}} // namespace strategy::centroid
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CENTROID_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/comparable_distance_result.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/comparable_distance_result.hpp
new file mode 100644
index 00000000000..5ba9b1603d2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/comparable_distance_result.hpp
@@ -0,0 +1,196 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_COMPARABLE_DISTANCE_RESULT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_COMPARABLE_DISTANCE_RESULT_HPP
+
+#include <boost/mpl/always.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/vector.hpp>
+
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/strategies/distance.hpp>
+
+#include <boost/geometry/util/compress_variant.hpp>
+#include <boost/geometry/util/transform_variant.hpp>
+#include <boost/geometry/util/combine_if.hpp>
+
+#include <boost/geometry/algorithms/detail/distance/default_strategies.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace resolve_strategy
+{
+
+template <typename Geometry1, typename Geometry2, typename Strategy>
+struct comparable_distance_result
+    : strategy::distance::services::return_type
+        <
+            typename strategy::distance::services::comparable_type
+                <
+                    Strategy
+                >::type,
+            typename point_type<Geometry1>::type,
+            typename point_type<Geometry2>::type
+        >
+{};
+
+template <typename Geometry1, typename Geometry2>
+struct comparable_distance_result<Geometry1, Geometry2, default_strategy>
+    : comparable_distance_result
+        <
+            Geometry1,
+            Geometry2,
+            typename detail::distance::default_strategy
+                <
+                    Geometry1, Geometry2
+                >::type
+        >
+{};
+
+} // namespace resolve_strategy
+
+
+namespace resolve_variant
+{
+
+template <typename Geometry1, typename Geometry2, typename Strategy>
+struct comparable_distance_result
+    : resolve_strategy::comparable_distance_result
+        <
+            Geometry1,
+            Geometry2,
+            Strategy
+        >
+{};
+
+
+template
+<
+    typename Geometry1,
+    BOOST_VARIANT_ENUM_PARAMS(typename T),
+    typename Strategy
+>
+struct comparable_distance_result
+    <
+        Geometry1, boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Strategy
+    >
+{
+    // A set of all variant type combinations that are compatible and
+    // implemented
+    typedef typename util::combine_if<
+        typename boost::mpl::vector1<Geometry1>,
+        typename boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::types,
+        boost::mpl::always<boost::mpl::true_>
+    >::type possible_input_types;
+
+    // The (possibly variant) result type resulting from these combinations
+    typedef typename compress_variant<
+        typename transform_variant<
+            possible_input_types,
+            resolve_strategy::comparable_distance_result<
+                boost::mpl::first<boost::mpl::_>,
+                boost::mpl::second<boost::mpl::_>,
+                Strategy
+            >,
+            boost::mpl::back_inserter<boost::mpl::vector0<> >
+        >::type
+    >::type type;
+};
+
+
+// Distance arguments are commutative
+template
+<
+    BOOST_VARIANT_ENUM_PARAMS(typename T),
+    typename Geometry2,
+    typename Strategy
+>
+struct comparable_distance_result
+    <
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>,
+        Geometry2,
+        Strategy
+    > : public comparable_distance_result
+        <
+            Geometry2, boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Strategy
+        >
+{};
+
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Strategy>
+struct comparable_distance_result
+    <
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>,
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>,
+        Strategy
+    >
+{
+    // A set of all variant type combinations that are compatible and
+    // implemented
+    typedef typename util::combine_if
+        <
+            typename boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::types,
+            typename boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::types,
+            boost::mpl::always<boost::mpl::true_>
+        >::type possible_input_types;
+
+    // The (possibly variant) result type resulting from these combinations
+    typedef typename compress_variant<
+        typename transform_variant<
+            possible_input_types,
+            resolve_strategy::comparable_distance_result<
+                boost::mpl::first<boost::mpl::_>,
+                boost::mpl::second<boost::mpl::_>,
+                Strategy
+            >,
+            boost::mpl::back_inserter<boost::mpl::vector0<> >
+        >::type
+    >::type type;
+};
+
+} // namespace resolve_variant
+
+
+
+
+
+/*!
+\brief Meta-function defining return type of comparable_distance function
+\ingroup distance
+*/
+template
+<
+    typename Geometry1,
+    typename Geometry2 = Geometry1,
+    typename Strategy = void
+>
+struct comparable_distance_result
+    : resolve_variant::comparable_distance_result
+        <
+            Geometry1, Geometry2, Strategy
+        >
+{};
+
+template <typename Geometry1, typename Geometry2>
+struct comparable_distance_result<Geometry1, Geometry2, void>
+    : comparable_distance_result<Geometry1, Geometry2, default_strategy>
+{};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_COMPARABLE_DISTANCE_RESULT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/compare.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/compare.hpp
new file mode 100644
index 00000000000..29583192297
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/compare.hpp
@@ -0,0 +1,172 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_COMPARE_HPP
+#define BOOST_GEOMETRY_STRATEGIES_COMPARE_HPP
+
+#include <cstddef>
+#include <functional>
+
+#include <boost/mpl/if.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+
+#include <boost/geometry/strategies/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+/*!
+    \brief Traits class binding a comparing strategy to a coordinate system
+    \ingroup util
+    \tparam Tag tag of coordinate system of point-type
+    \tparam Direction direction to compare on: 1 for less (-> ascending order)
+        and -1 for greater (-> descending order)
+    \tparam Point point-type
+    \tparam CoordinateSystem coordinate sytem of point
+    \tparam Dimension: the dimension to compare on
+*/
+template
+<
+    typename Tag,
+    int Direction,
+    typename Point,
+    typename CoordinateSystem,
+    std::size_t Dimension
+>
+struct strategy_compare
+{
+    typedef strategy::not_implemented type;
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+// For compare we add defaults specializations,
+// because they defaultly redirect to std::less / greater / equal_to
+template
+<
+    typename Tag,
+    typename Point,
+    typename CoordinateSystem,
+    std::size_t Dimension
+>
+struct strategy_compare<Tag, 1, Point, CoordinateSystem, Dimension>
+{
+    typedef std::less<typename coordinate_type<Point>::type> type;
+};
+
+
+template
+<
+    typename Tag,
+    typename Point,
+    typename CoordinateSystem,
+    std::size_t Dimension
+>
+struct strategy_compare<Tag, -1, Point, CoordinateSystem, Dimension>
+{
+    typedef std::greater<typename coordinate_type<Point>::type> type;
+};
+
+
+template
+<
+    typename Tag,
+    typename Point,
+    typename CoordinateSystem,
+    std::size_t Dimension
+>
+struct strategy_compare<Tag, 0, Point, CoordinateSystem, Dimension>
+{
+    typedef std::equal_to<typename coordinate_type<Point>::type> type;
+};
+
+
+#endif
+
+
+namespace strategy { namespace compare
+{
+
+
+/*!
+    \brief Default strategy, indicates the default strategy for comparisons
+    \details The default strategy for comparisons defer in most cases
+        to std::less (for ascending) and std::greater (for descending).
+        However, if a spherical coordinate system is used, and comparison
+        is done on longitude, it will take another strategy handling circular
+*/
+struct default_strategy {};
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <typename Type>
+struct is_default : boost::false_type
+{};
+
+
+template <>
+struct is_default<default_strategy> : boost::true_type
+{};
+
+
+/*!
+    \brief Meta-function to select strategy
+    \details If "default_strategy" is specified, it will take the
+        traits-registered class for the specified coordinate system.
+        If another strategy is explicitly specified, it takes that one.
+*/
+template
+<
+    typename Strategy,
+    int Direction,
+    typename Point,
+    std::size_t Dimension
+>
+struct select_strategy
+{
+    typedef typename
+        boost::mpl::if_
+        <
+            is_default<Strategy>,
+            typename strategy_compare
+            <
+                typename cs_tag<Point>::type,
+                Direction,
+                Point,
+                typename coordinate_system<Point>::type,
+                Dimension
+            >::type,
+            Strategy
+        >::type type;
+};
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace strategy::compare
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_COMPARE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/area_concept.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/area_concept.hpp
new file mode 100644
index 00000000000..4eec6d1fc3d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/area_concept.hpp
@@ -0,0 +1,75 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CONCEPTS_AREA_CONCEPT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CONCEPTS_AREA_CONCEPT_HPP
+
+
+#include <boost/concept_check.hpp>
+
+
+namespace boost { namespace geometry { namespace concepts
+{
+
+
+/*!
+    \brief Checks strategy for area
+    \ingroup area
+*/
+template <typename Strategy>
+class AreaStrategy
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+
+    // 1) must define state_type,
+    typedef typename Strategy::state_type state_type;
+
+    // 2) must define return_type,
+    typedef typename Strategy::return_type return_type;
+
+    // 3) must define point_type, of polygon (segments)
+    typedef typename Strategy::segment_point_type spoint_type;
+
+    struct check_methods
+    {
+        static void apply()
+        {
+            Strategy const* str = 0;
+            state_type *st = 0;
+
+            // 4) must implement a method apply with the following signature
+            spoint_type const* sp = 0;
+            str->apply(*sp, *sp, *st);
+
+            // 5) must implement a static method result with the following signature
+            return_type r = str->result(*st);
+
+            boost::ignore_unused_variable_warning(r);
+            boost::ignore_unused_variable_warning(str);
+        }
+    };
+
+public :
+    BOOST_CONCEPT_USAGE(AreaStrategy)
+    {
+        check_methods::apply();
+    }
+
+#endif
+};
+
+
+}}} // namespace boost::geometry::concepts
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CONCEPTS_AREA_CONCEPT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/centroid_concept.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/centroid_concept.hpp
new file mode 100644
index 00000000000..0bbe94ba776
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/centroid_concept.hpp
@@ -0,0 +1,78 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CONCEPTS_CENTROID_CONCEPT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CONCEPTS_CENTROID_CONCEPT_HPP
+
+
+
+#include <boost/concept_check.hpp>
+
+
+namespace boost { namespace geometry { namespace concepts
+{
+
+
+/*!
+    \brief Checks strategy for centroid
+    \ingroup centroid
+*/
+template <typename Strategy>
+class CentroidStrategy
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+
+    // 1) must define state_type,
+    typedef typename Strategy::state_type state_type;
+
+    // 2) must define point_type,
+    typedef typename Strategy::point_type point_type;
+
+    // 3) must define point_type, of polygon (segments)
+    typedef typename Strategy::segment_point_type spoint_type;
+
+    struct check_methods
+    {
+        static void apply()
+        {
+            Strategy *str = 0;
+            state_type *st = 0;
+
+            // 4) must implement a static method apply,
+            // getting two segment-points
+            spoint_type const* sp = 0;
+            str->apply(*sp, *sp, *st);
+
+            // 5) must implement a static method result
+            //  getting the centroid
+            point_type *c = 0;
+            bool r = str->result(*st, *c);
+
+            boost::ignore_unused_variable_warning(str);
+            boost::ignore_unused_variable_warning(r);
+        }
+    };
+
+public :
+    BOOST_CONCEPT_USAGE(CentroidStrategy)
+    {
+        check_methods::apply();
+    }
+#endif
+};
+
+
+}}} // namespace boost::geometry::concepts
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CONCEPTS_CENTROID_CONCEPT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/convex_hull_concept.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/convex_hull_concept.hpp
new file mode 100644
index 00000000000..d4295ce47b8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/convex_hull_concept.hpp
@@ -0,0 +1,80 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CONCEPTS_CONVEX_HULL_CONCEPT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CONCEPTS_CONVEX_HULL_CONCEPT_HPP
+
+
+#include <vector>
+
+#include <boost/concept_check.hpp>
+
+
+namespace boost { namespace geometry { namespace concepts
+{
+
+
+/*!
+    \brief Checks strategy for convex_hull
+    \ingroup convex_hull
+*/
+template <typename Strategy>
+class ConvexHullStrategy
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+
+    // 1) must define state_type
+    typedef typename Strategy::state_type state_type;
+
+    // 2) must define point_type
+    typedef typename Strategy::point_type point_type;
+
+    // 3) must define geometry_type
+    typedef typename Strategy::geometry_type geometry_type;
+
+    struct check_methods
+    {
+        static void apply()
+        {
+            Strategy const* str = 0;
+
+            state_type* st = 0;
+            geometry_type* sp = 0;
+            std::vector<point_type> *v = 0;
+
+            // 4) must implement a method apply, iterating over a range
+            str->apply(*sp, *st);
+
+            // 5) must implement a method result, with an output iterator
+            str->result(*st, std::back_inserter(*v), true, true);
+        }
+    };
+
+public :
+    BOOST_CONCEPT_USAGE(ConvexHullStrategy)
+    {
+        check_methods::apply();
+    }
+#endif
+};
+
+
+}}} // namespace boost::geometry::concepts
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CONCEPTS_CONVEX_HULL_CONCEPT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/distance_concept.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/distance_concept.hpp
new file mode 100644
index 00000000000..0064d438d59
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/distance_concept.hpp
@@ -0,0 +1,212 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CONCEPTS_DISTANCE_CONCEPT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CONCEPTS_DISTANCE_CONCEPT_HPP
+
+#include <vector>
+#include <iterator>
+
+#include <boost/concept_check.hpp>
+#include <boost/core/ignore_unused.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/geometry/util/parameter_type_of.hpp>
+
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+#include <boost/geometry/geometries/segment.hpp>
+#include <boost/geometry/geometries/point.hpp>
+
+#include <boost/geometry/strategies/tags.hpp>
+
+
+namespace boost { namespace geometry { namespace concepts
+{
+
+
+/*!
+    \brief Checks strategy for point-point or point-box or box-box distance
+    \ingroup distance
+*/
+template <typename Strategy, typename Point1, typename Point2>
+struct PointDistanceStrategy
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+private :
+
+    struct checker
+    {
+        template <typename ApplyMethod>
+        static void apply(ApplyMethod)
+        {
+            // 1: inspect and define both arguments of apply
+            typedef typename parameter_type_of
+                <
+                    ApplyMethod, 0
+                >::type ptype1;
+
+            typedef typename parameter_type_of
+                <
+                    ApplyMethod, 1
+                >::type ptype2;
+
+            // 2) must define meta-function "return_type"
+            typedef typename strategy::distance::services::return_type
+                <
+                    Strategy, ptype1, ptype2
+                >::type rtype;
+
+            // 3) must define meta-function "comparable_type"
+            typedef typename strategy::distance::services::comparable_type
+                <
+                    Strategy
+                >::type ctype;
+
+            // 4) must define meta-function "tag"
+            typedef typename strategy::distance::services::tag
+                <
+                    Strategy
+                >::type tag;
+
+            static const bool is_correct_strategy_tag =
+                boost::is_same<tag, strategy_tag_distance_point_point>::value
+                || boost::is_same<tag, strategy_tag_distance_point_box>::value
+                || boost::is_same<tag, strategy_tag_distance_box_box>::value;
+
+            BOOST_MPL_ASSERT_MSG
+                ((is_correct_strategy_tag),
+                 INCORRECT_STRATEGY_TAG,
+                 (types<tag>));
+
+            // 5) must implement apply with arguments
+            Strategy* str = 0;
+            ptype1 *p1 = 0;
+            ptype2 *p2 = 0;
+            rtype r = str->apply(*p1, *p2);
+
+            // 6) must define (meta)struct "get_comparable" with apply
+            ctype c = strategy::distance::services::get_comparable
+                <
+                    Strategy
+                >::apply(*str);
+
+            // 7) must define (meta)struct "result_from_distance" with apply
+            r = strategy::distance::services::result_from_distance
+                <
+                    Strategy,
+                    ptype1, ptype2
+                >::apply(*str, 1.0);
+
+            boost::ignore_unused<tag>();
+            boost::ignore_unused(str, c, r);
+        }
+    };
+
+
+
+public :
+    BOOST_CONCEPT_USAGE(PointDistanceStrategy)
+    {
+        checker::apply(&Strategy::template apply<Point1, Point2>);
+    }
+#endif
+};
+
+
+/*!
+    \brief Checks strategy for point-segment distance
+    \ingroup strategy_concepts
+*/
+template <typename Strategy, typename Point, typename PointOfSegment>
+struct PointSegmentDistanceStrategy
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+private :
+
+    struct checker
+    {
+        template <typename ApplyMethod>
+        static void apply(ApplyMethod)
+        {
+            // 1) inspect and define both arguments of apply
+            typedef typename parameter_type_of
+                <
+                    ApplyMethod, 0
+                >::type ptype;
+
+            typedef typename parameter_type_of
+                <
+                    ApplyMethod, 1
+                >::type sptype;
+
+            namespace services = strategy::distance::services;
+            // 2) must define meta-function "tag"
+            typedef typename services::tag<Strategy>::type tag;
+
+            BOOST_MPL_ASSERT_MSG
+                ((boost::is_same
+                      <
+                          tag, strategy_tag_distance_point_segment
+                      >::value),
+                 INCORRECT_STRATEGY_TAG,
+                 (types<tag>));
+
+            // 3) must define meta-function "return_type"
+            typedef typename services::return_type
+                <
+                    Strategy, ptype, sptype
+                >::type rtype;
+
+            // 4) must define meta-function "comparable_type"
+            typedef typename services::comparable_type<Strategy>::type ctype;
+
+            // 5) must implement apply with arguments
+            Strategy *str = 0;
+            ptype *p = 0;
+            sptype *sp1 = 0;
+            sptype *sp2 = 0;
+
+            rtype r = str->apply(*p, *sp1, *sp2);
+
+            // 6) must define (meta-)struct "get_comparable" with apply
+            ctype cstrategy = services::get_comparable<Strategy>::apply(*str);
+
+            // 7) must define (meta-)struct "result_from_distance" with apply
+            r = services::result_from_distance
+                <
+                    Strategy, ptype, sptype
+                >::apply(*str, rtype(1.0));
+
+            boost::ignore_unused(str, r, cstrategy);
+        }
+    };
+
+public :
+    BOOST_CONCEPT_USAGE(PointSegmentDistanceStrategy)
+    {
+        checker::apply(&Strategy::template apply<Point, PointOfSegment>);
+    }
+#endif
+};
+
+
+}}} // namespace boost::geometry::concepts
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CONCEPTS_DISTANCE_CONCEPT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/segment_intersect_concept.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/segment_intersect_concept.hpp
new file mode 100644
index 00000000000..87d901eb939
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/segment_intersect_concept.hpp
@@ -0,0 +1,78 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CONCEPTS_SEGMENT_INTERSECT_CONCEPT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CONCEPTS_SEGMENT_INTERSECT_CONCEPT_HPP
+
+
+//NOT FINISHED!
+
+#include <boost/concept_check.hpp>
+
+
+namespace boost { namespace geometry { namespace concepts
+{
+
+
+/*!
+    \brief Checks strategy for segment intersection
+    \ingroup segment_intersection
+*/
+template <typename Strategy>
+class SegmentIntersectStrategy
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+
+    // 1) must define return_type
+    typedef typename Strategy::return_type return_type;
+
+    // 2) must define point_type (of segment points)
+    //typedef typename Strategy::point_type point_type;
+
+    // 3) must define segment_type 1 and 2 (of segment points)
+    typedef typename Strategy::segment_type1 segment_type1;
+    typedef typename Strategy::segment_type2 segment_type2;
+
+
+    struct check_methods
+    {
+        static void apply()
+        {
+            Strategy const* str;
+
+            return_type* rt;
+            //point_type const* p;
+            segment_type1 const* s1;
+            segment_type2 const* s2;
+
+            // 4) must implement a method apply
+            //    having two segments
+            *rt = str->apply(*s1, *s2);
+
+        }
+    };
+
+
+public :
+    BOOST_CONCEPT_USAGE(SegmentIntersectStrategy)
+    {
+        check_methods::apply();
+    }
+#endif
+};
+
+
+
+}}} // namespace boost::geometry::concepts
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CONCEPTS_SEGMENT_INTERSECT_CONCEPT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/simplify_concept.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/simplify_concept.hpp
new file mode 100644
index 00000000000..06600bafcba
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/simplify_concept.hpp
@@ -0,0 +1,96 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CONCEPTS_SIMPLIFY_CONCEPT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CONCEPTS_SIMPLIFY_CONCEPT_HPP
+
+#include <vector>
+#include <iterator>
+
+#include <boost/concept_check.hpp>
+#include <boost/core/ignore_unused.hpp>
+
+#include <boost/geometry/geometries/point.hpp>
+#include <boost/geometry/strategies/concepts/distance_concept.hpp>
+
+
+namespace boost { namespace geometry { namespace concepts
+{
+
+
+/*!
+    \brief Checks strategy for simplify
+    \ingroup simplify
+*/
+template <typename Strategy, typename Point>
+struct SimplifyStrategy
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+private :
+
+    // 1) must define distance_strategy_type,
+    //    defining point-segment distance strategy (to be checked)
+    typedef typename Strategy::distance_strategy_type ds_type;
+
+
+    struct checker
+    {
+        template <typename ApplyMethod>
+        static void apply(ApplyMethod)
+        {
+            namespace ft = boost::function_types;
+            typedef typename ft::parameter_types
+                <
+                    ApplyMethod
+                >::type parameter_types;
+
+            typedef typename boost::mpl::if_
+                <
+                    ft::is_member_function_pointer<ApplyMethod>,
+                    boost::mpl::int_<1>,
+                    boost::mpl::int_<0>
+                >::type base_index;
+
+            BOOST_CONCEPT_ASSERT
+                (
+                    (concepts::PointSegmentDistanceStrategy<ds_type, Point, Point>)
+                );
+
+            Strategy *str = 0;
+            std::vector<Point> const* v1 = 0;
+            std::vector<Point> * v2 = 0;
+
+            // 2) must implement method apply with arguments
+            //    - Range
+            //    - OutputIterator
+            //    - floating point value
+            str->apply(*v1, std::back_inserter(*v2), 1.0);
+
+            boost::ignore_unused<parameter_types, base_index>();
+            boost::ignore_unused(str);
+        }
+    };
+
+public :
+    BOOST_CONCEPT_USAGE(SimplifyStrategy)
+    {
+        checker::apply(&ds_type::template apply<Point, Point>);
+    }
+#endif
+};
+
+
+
+}}} // namespace boost::geometry::concepts
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CONCEPTS_SIMPLIFY_CONCEPT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/within_concept.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/within_concept.hpp
new file mode 100644
index 00000000000..ab712ccd5e1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/concepts/within_concept.hpp
@@ -0,0 +1,291 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CONCEPTS_WITHIN_CONCEPT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CONCEPTS_WITHIN_CONCEPT_HPP
+
+
+
+#include <boost/concept_check.hpp>
+#include <boost/function_types/result_type.hpp>
+
+#include <boost/geometry/util/parameter_type_of.hpp>
+
+
+namespace boost { namespace geometry { namespace concepts
+{
+
+
+/*!
+\brief Checks strategy for within (point-in-polygon)
+\ingroup within
+*/
+template <typename Strategy>
+class WithinStrategyPolygonal
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+
+    // 1) must define state_type
+    typedef typename Strategy::state_type state_type;
+
+    struct checker
+    {
+        template <typename ApplyMethod, typename ResultMethod>
+        static void apply(ApplyMethod const&, ResultMethod const& )
+        {
+            typedef typename parameter_type_of
+                <
+                    ApplyMethod, 0
+                >::type point_type;
+            typedef typename parameter_type_of
+                <
+                    ApplyMethod, 1
+                >::type segment_point_type;
+
+            // CHECK: apply-arguments should both fulfill point concept
+            BOOST_CONCEPT_ASSERT
+                (
+                    (concepts::ConstPoint<point_type>)
+                );
+
+            BOOST_CONCEPT_ASSERT
+                (
+                    (concepts::ConstPoint<segment_point_type>)
+                );
+
+            // CHECK: return types (result: int, apply: bool)
+            BOOST_MPL_ASSERT_MSG
+                (
+                    (boost::is_same
+                        <
+                            bool, typename boost::function_types::result_type<ApplyMethod>::type
+                        >::type::value),
+                    WRONG_RETURN_TYPE_OF_APPLY
+                    , (bool)
+                );
+            BOOST_MPL_ASSERT_MSG
+                (
+                    (boost::is_same
+                        <
+                            int, typename boost::function_types::result_type<ResultMethod>::type
+                        >::type::value),
+                    WRONG_RETURN_TYPE_OF_RESULT
+                    , (int)
+                );
+
+
+            // CHECK: calling method apply and result
+            Strategy const* str = 0;
+            state_type* st = 0;
+            point_type const* p = 0;
+            segment_point_type const* sp = 0;
+
+            bool b = str->apply(*p, *sp, *sp, *st);
+            int r = str->result(*st);
+
+            boost::ignore_unused_variable_warning(r);
+            boost::ignore_unused_variable_warning(b);
+            boost::ignore_unused_variable_warning(str);
+        }
+    };
+
+
+public :
+    BOOST_CONCEPT_USAGE(WithinStrategyPolygonal)
+    {
+        checker::apply(&Strategy::apply, &Strategy::result);
+    }
+#endif
+};
+
+template <typename Strategy>
+class WithinStrategyPointBox
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+
+    struct checker
+    {
+        template <typename ApplyMethod>
+        static void apply(ApplyMethod const&)
+        {
+            typedef typename parameter_type_of
+                <
+                    ApplyMethod, 0
+                >::type point_type;
+            typedef typename parameter_type_of
+                <
+                    ApplyMethod, 1
+                >::type box_type;
+
+            // CHECK: apply-arguments should fulfill point/box concept
+            BOOST_CONCEPT_ASSERT
+                (
+                    (concepts::ConstPoint<point_type>)
+                );
+
+            BOOST_CONCEPT_ASSERT
+                (
+                    (concepts::ConstBox<box_type>)
+                );
+
+            // CHECK: return types (apply: bool)
+            BOOST_MPL_ASSERT_MSG
+                (
+                    (boost::is_same
+                        <
+                            bool,
+                            typename boost::function_types::result_type<ApplyMethod>::type
+                        >::type::value),
+                    WRONG_RETURN_TYPE
+                    , (bool)
+                );
+
+
+            // CHECK: calling method apply
+            Strategy const* str = 0;
+            point_type const* p = 0;
+            box_type const* bx = 0;
+
+            bool b = str->apply(*p, *bx);
+
+            boost::ignore_unused_variable_warning(b);
+            boost::ignore_unused_variable_warning(str);
+        }
+    };
+
+
+public :
+    BOOST_CONCEPT_USAGE(WithinStrategyPointBox)
+    {
+        checker::apply(&Strategy::apply);
+    }
+#endif
+};
+
+template <typename Strategy>
+class WithinStrategyBoxBox
+{
+#ifndef DOXYGEN_NO_CONCEPT_MEMBERS
+
+    struct checker
+    {
+        template <typename ApplyMethod>
+        static void apply(ApplyMethod const&)
+        {
+            typedef typename parameter_type_of
+                <
+                    ApplyMethod, 0
+                >::type box_type1;
+            typedef typename parameter_type_of
+                <
+                    ApplyMethod, 1
+                >::type box_type2;
+
+            // CHECK: apply-arguments should both fulfill box concept
+            BOOST_CONCEPT_ASSERT
+                (
+                    (concepts::ConstBox<box_type1>)
+                );
+
+            BOOST_CONCEPT_ASSERT
+                (
+                    (concepts::ConstBox<box_type2>)
+                );
+
+            // CHECK: return types (apply: bool)
+            BOOST_MPL_ASSERT_MSG
+                (
+                    (boost::is_same
+                        <
+                            bool,
+                            typename boost::function_types::result_type<ApplyMethod>::type
+                        >::type::value),
+                    WRONG_RETURN_TYPE
+                    , (bool)
+                );
+
+
+            // CHECK: calling method apply
+            Strategy const* str = 0;
+            box_type1 const* b1 = 0;
+            box_type2 const* b2 = 0;
+
+            bool b = str->apply(*b1, *b2);
+
+            boost::ignore_unused_variable_warning(b);
+            boost::ignore_unused_variable_warning(str);
+        }
+    };
+
+
+public :
+    BOOST_CONCEPT_USAGE(WithinStrategyBoxBox)
+    {
+        checker::apply(&Strategy::apply);
+    }
+#endif
+};
+
+// So now: boost::geometry::concepts::within
+namespace within
+{
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+template <typename FirstTag, typename SecondTag, typename CastedTag, typename Strategy>
+struct check_within
+{};
+
+
+template <typename AnyTag, typename Strategy>
+struct check_within<point_tag, AnyTag, areal_tag, Strategy>
+{
+    BOOST_CONCEPT_ASSERT( (WithinStrategyPolygonal<Strategy>) );
+};
+
+
+template <typename Strategy>
+struct check_within<point_tag, box_tag, areal_tag, Strategy>
+{
+    BOOST_CONCEPT_ASSERT( (WithinStrategyPointBox<Strategy>) );
+};
+
+template <typename Strategy>
+struct check_within<box_tag, box_tag, areal_tag, Strategy>
+{
+    BOOST_CONCEPT_ASSERT( (WithinStrategyBoxBox<Strategy>) );
+};
+
+
+} // namespace dispatch
+#endif
+
+
+/*!
+\brief Checks, in compile-time, the concept of any within-strategy
+\ingroup concepts
+*/
+template <typename FirstTag, typename SecondTag, typename CastedTag, typename Strategy>
+inline void check()
+{
+    dispatch::check_within<FirstTag, SecondTag, CastedTag, Strategy> c;
+    boost::ignore_unused_variable_warning(c);
+}
+
+
+}}}} // namespace boost::geometry::concepts::within
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CONCEPTS_WITHIN_CONCEPT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/convex_hull.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/convex_hull.hpp
new file mode 100644
index 00000000000..f4edc5ba3f1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/convex_hull.hpp
@@ -0,0 +1,47 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_CONVEX_HULL_HPP
+#define BOOST_GEOMETRY_STRATEGIES_CONVEX_HULL_HPP
+
+#include <boost/geometry/strategies/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+
+
+/*!
+    \brief Traits class binding a convex hull calculation strategy to a coordinate system
+    \ingroup convex_hull
+    \tparam Tag tag of coordinate system
+    \tparam Geometry the geometry type (hull operates internally per hull over geometry)
+    \tparam Point point-type of output points
+*/
+template
+<
+    typename Geometry1,
+    typename Point,
+    typename CsTag = typename cs_tag<Point>::type
+>
+struct strategy_convex_hull
+{
+    typedef strategy::not_implemented type;
+};
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_CONVEX_HULL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/covered_by.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/covered_by.hpp
new file mode 100644
index 00000000000..363e34b68fb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/covered_by.hpp
@@ -0,0 +1,99 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_COVERED_BY_HPP
+#define BOOST_GEOMETRY_STRATEGIES_COVERED_BY_HPP
+
+#include <boost/mpl/assert.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace covered_by
+{
+
+
+namespace services
+{
+
+/*!
+\brief Traits class binding a covered_by determination strategy to a coordinate system
+\ingroup covered_by
+\tparam GeometryContained geometry-type of input (possibly) contained type
+\tparam GeometryContaining geometry-type of input (possibly) containing type
+\tparam TagContained casted tag of (possibly) contained type
+\tparam TagContaining casted tag of (possibly) containing type
+\tparam CsTagContained tag of coordinate system of (possibly) contained type
+\tparam CsTagContaining tag of coordinate system of (possibly) containing type
+*/
+template
+<
+    typename GeometryContained,
+    typename GeometryContaining,
+    typename TagContained = typename tag<GeometryContained>::type,
+    typename TagContaining = typename tag<GeometryContaining>::type,
+    typename CastedTagContained = typename tag_cast
+                                    <
+                                        typename tag<GeometryContained>::type,
+                                        pointlike_tag, linear_tag, polygonal_tag, areal_tag
+                                    >::type,
+    typename CastedTagContaining = typename tag_cast
+                                    <
+                                        typename tag<GeometryContaining>::type,
+                                        pointlike_tag, linear_tag, polygonal_tag, areal_tag
+                                    >::type,
+    typename CsTagContained = typename tag_cast
+                                <
+                                    typename cs_tag<typename point_type<GeometryContained>::type>::type,
+                                    spherical_tag
+                                >::type,
+    typename CsTagContaining = typename tag_cast
+                                <
+                                    typename cs_tag<typename point_type<GeometryContaining>::type>::type,
+                                    spherical_tag
+                                >::type
+>
+struct default_strategy
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THESE_TYPES
+            , (types<GeometryContained, GeometryContaining>)
+        );
+};
+
+
+} // namespace services
+
+
+}} // namespace strategy::covered_by
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_COVERED_BY_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/default_area_result.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/default_area_result.hpp
new file mode 100644
index 00000000000..8adfa5d6ea2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/default_area_result.hpp
@@ -0,0 +1,51 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_DEFAULT_AREA_RESULT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_DEFAULT_AREA_RESULT_HPP
+
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/strategies/area.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+/*!
+\brief Meta-function defining return type of area function, using the default strategy
+\ingroup area
+\note The strategy defines the return-type (so this situation is different
+    from length, where distance is sqr/sqrt, but length always squared)
+ */
+
+template <typename Geometry>
+struct default_area_result
+{
+    typedef typename point_type<Geometry>::type point_type;
+    typedef typename strategy::area::services::default_strategy
+        <
+            typename cs_tag<point_type>::type,
+            point_type
+        >::type strategy_type;
+
+    typedef typename strategy_type::return_type type;
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_DEFAULT_AREA_RESULT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/default_comparable_distance_result.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/default_comparable_distance_result.hpp
new file mode 100644
index 00000000000..3b4229f1067
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/default_comparable_distance_result.hpp
@@ -0,0 +1,43 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_DEFAULT_COMPARABLE_DISTANCE_RESULT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_DEFAULT_COMPARABLE_DISTANCE_RESULT_HPP
+
+#include <boost/geometry/strategies/comparable_distance_result.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+/*!
+\brief Meta-function defining return type of comparable_distance function
+\ingroup distance
+\note The strategy defines the return-type (so this situation is different
+    from length, where distance is sqr/sqrt, but length always squared)
+ */
+template <typename Geometry1, typename Geometry2 = Geometry1>
+struct default_comparable_distance_result
+    : comparable_distance_result<Geometry1, Geometry2, void>
+{};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_DEFAULT_COMPARABLE_DISTANCE_RESULT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/default_distance_result.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/default_distance_result.hpp
new file mode 100644
index 00000000000..e34a9477279
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/default_distance_result.hpp
@@ -0,0 +1,43 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_DEFAULT_DISTANCE_RESULT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_DEFAULT_DISTANCE_RESULT_HPP
+
+#include <boost/geometry/strategies/distance_result.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+/*!
+\brief Meta-function defining return type of distance function
+\ingroup distance
+\note The strategy defines the return-type (so this situation is different
+    from length, where distance is sqr/sqrt, but length always squared)
+ */
+template <typename Geometry1, typename Geometry2 = Geometry1>
+struct default_distance_result
+    : distance_result<Geometry1, Geometry2, void>
+{};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_DEFAULT_DISTANCE_RESULT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/default_length_result.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/default_length_result.hpp
new file mode 100644
index 00000000000..806e4284ce5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/default_length_result.hpp
@@ -0,0 +1,89 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_DEFAULT_LENGTH_RESULT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_DEFAULT_LENGTH_RESULT_HPP
+
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/core/coordinate_type.hpp>
+
+#include <boost/geometry/util/compress_variant.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+#include <boost/geometry/util/transform_variant.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace resolve_strategy
+{
+
+template <typename Geometry>
+struct default_length_result
+{
+    typedef typename select_most_precise
+        <
+            typename coordinate_type<Geometry>::type,
+            long double
+        >::type type;
+};
+
+} // namespace resolve_strategy
+
+
+namespace resolve_variant
+{
+
+template <typename Geometry>
+struct default_length_result
+    : resolve_strategy::default_length_result<Geometry>
+{};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T)>
+struct default_length_result<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> >
+{
+    typedef typename compress_variant<
+        typename transform_variant<
+            boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>,
+            resolve_strategy::default_length_result<boost::mpl::placeholders::_>
+        >::type
+    >::type type;
+};
+
+} // namespace resolve_variant
+
+
+/*!
+    \brief Meta-function defining return type of length function
+    \ingroup length
+    \note Length of a line of integer coordinates can be double.
+        So we take at least a double. If Big Number types are used,
+        we take that type.
+
+ */
+template <typename Geometry>
+struct default_length_result
+    : resolve_variant::default_length_result<Geometry>
+{};
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_DEFAULT_LENGTH_RESULT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/default_strategy.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/default_strategy.hpp
new file mode 100644
index 00000000000..6d05970b426
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/default_strategy.hpp
@@ -0,0 +1,34 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2013 Bruno Lalande, Paris, France.
+// Copyright (c) 2007-2013 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2013 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_DEFAULT_STRATEGY_HPP
+#define BOOST_GEOMETRY_STRATEGIES_DEFAULT_STRATEGY_HPP
+
+
+namespace boost { namespace geometry
+{
+
+// This is a strategy placeholder type, which is passed by the algorithm free
+// functions to the multi-stage resolving process. It's resolved into an actual
+// strategy type during the resolve_strategy stage, possibly depending on the
+// input geometry type(s). This typically happens after the resolve_variant
+// stage, as it needs to be based on concrete geometry types - as opposed to
+// variant geometry types.
+
+struct default_strategy {};
+
+}} // namespace boost::geometry
+
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_DEFAULT_STRATEGY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/disjoint.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/disjoint.hpp
new file mode 100644
index 00000000000..23d2cede498
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/disjoint.hpp
@@ -0,0 +1,93 @@
+// Boost.Geometry
+
+// Copyright (c) 2017, Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_DISJOINT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_DISJOINT_HPP
+
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/topological_dimension.hpp>
+
+#include <boost/geometry/strategies/covered_by.hpp>
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/strategies/relate.hpp>
+
+
+namespace boost { namespace geometry { namespace strategy { namespace disjoint
+{
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename Tag1 = typename geometry::tag<Geometry1>::type,
+    typename Tag2 = typename geometry::tag<Geometry2>::type,
+    int TopDim1 = geometry::topological_dimension<Geometry1>::value,
+    int TopDim2 = geometry::topological_dimension<Geometry2>::value,
+    typename CsTag1 = typename cs_tag<Geometry1>::type,
+    typename CsTag2 = typename cs_tag<Geometry2>::type
+>
+struct default_strategy
+    : relate::services::default_strategy
+        <
+            Geometry1, Geometry2
+        >
+{};
+
+template <typename Point, typename Box>
+struct default_strategy<Point, Box, point_tag, box_tag, 0, 2>
+    : strategy::covered_by::services::default_strategy<Point, Box>
+{};
+
+template <typename Box, typename Point>
+struct default_strategy<Box, Point, box_tag, point_tag, 2, 0>
+    : strategy::covered_by::services::default_strategy<Point, Box>
+{};
+
+template <typename MultiPoint, typename Box>
+struct default_strategy<MultiPoint, Box, multi_point_tag, box_tag, 0, 2>
+    : strategy::covered_by::services::default_strategy
+        <
+            typename point_type<MultiPoint>::type,
+            Box
+        >
+{};
+
+template <typename Box, typename MultiPoint>
+struct default_strategy<Box, MultiPoint, box_tag, multi_point_tag, 2, 0>
+    : strategy::covered_by::services::default_strategy
+        <
+            typename point_type<MultiPoint>::type,
+            Box
+        >
+{};
+
+template <typename Box1, typename Box2>
+struct default_strategy<Box1, Box2, box_tag, box_tag, 2, 2>
+{
+    // dummy strategy which will be ignored
+    typedef geometry::default_strategy type;
+};
+
+} // namespace services
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+}}}} // namespace boost::geometry::strategy::disjoint
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_DISJOINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/distance.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/distance.hpp
new file mode 100644
index 00000000000..98ccb8202bd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/distance.hpp
@@ -0,0 +1,110 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_DISTANCE_HPP
+#define BOOST_GEOMETRY_STRATEGIES_DISTANCE_HPP
+
+
+#include <boost/mpl/assert.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/strategies/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace distance { namespace services
+{
+
+
+template <typename Strategy> struct tag {};
+
+template <typename Strategy, typename P1, typename P2>
+struct return_type
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_STRATEGY, (types<Strategy, P1, P2>)
+        );
+};
+
+
+template <typename Strategy> struct comparable_type
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_STRATEGY, (types<Strategy>)
+        );
+};
+
+template <typename Strategy> struct get_comparable
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_STRATEGY, (types<Strategy>)
+        );
+};
+
+template <typename Strategy, typename P1, typename P2>
+struct result_from_distance {};
+
+
+
+
+// Default strategy
+
+
+/*!
+    \brief Traits class binding a default strategy for distance
+        to one (or possibly two) coordinate system(s)
+    \ingroup distance
+    \tparam GeometryTag1 tag (point/segment/box) for which this strategy is the default
+    \tparam GeometryTag2 tag (point/segment/box) for which this strategy is the default
+    \tparam Point1 first point-type
+    \tparam Point2 second point-type
+    \tparam CsTag1 tag of coordinate system of first point type
+    \tparam CsTag2 tag of coordinate system of second point type
+*/
+template
+<
+    typename GeometryTag1,
+    typename GeometryTag2,
+    typename Point1,
+    typename Point2 = Point1,
+    typename CsTag1 = typename cs_tag<Point1>::type,
+    typename CsTag2 = typename cs_tag<Point2>::type,
+    typename UnderlyingStrategy = void
+>
+struct default_strategy
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_POINT_TYPE_COMBINATION
+            , (types<Point1, Point2, CsTag1, CsTag2>)
+        );
+};
+
+
+}}} // namespace strategy::distance::services
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_DISTANCE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/distance_result.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/distance_result.hpp
new file mode 100644
index 00000000000..e4f326d3eee
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/distance_result.hpp
@@ -0,0 +1,213 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2013-2015 Adam Wulkiewicz, Lodz, Poland.
+// Copyright (c) 2014-2015 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2014, 2015.
+// Modifications copyright (c) 2014-2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_DISTANCE_RESULT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_DISTANCE_RESULT_HPP
+
+#include <boost/mpl/always.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/vector.hpp>
+
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/strategies/default_strategy.hpp>
+#include <boost/geometry/strategies/distance.hpp>
+
+#include <boost/geometry/util/compress_variant.hpp>
+#include <boost/geometry/util/transform_variant.hpp>
+#include <boost/geometry/util/combine_if.hpp>
+
+#include <boost/geometry/algorithms/detail/distance/default_strategies.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace resolve_strategy
+{
+
+template <typename Geometry1, typename Geometry2, typename Strategy>
+struct distance_result
+    : strategy::distance::services::return_type
+        <
+            Strategy,
+            typename point_type<Geometry1>::type,
+            typename point_type<Geometry2>::type
+        >
+{};
+
+template <typename Geometry1, typename Geometry2>
+struct distance_result<Geometry1, Geometry2, default_strategy>
+    : distance_result
+        <
+            Geometry1,
+            Geometry2,
+            typename detail::distance::default_strategy
+                <
+                    Geometry1, Geometry2
+                >::type
+        >
+{};
+
+} // namespace resolve_strategy
+
+
+namespace resolve_variant
+{
+
+template <typename Geometry1, typename Geometry2, typename Strategy>
+struct distance_result
+    : resolve_strategy::distance_result
+        <
+            Geometry1,
+            Geometry2,
+            Strategy
+        >
+{};
+
+
+template
+<
+    typename Geometry1,
+    BOOST_VARIANT_ENUM_PARAMS(typename T),
+    typename Strategy
+>
+struct distance_result
+    <
+        Geometry1, boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Strategy
+    >
+{
+    // A set of all variant type combinations that are compatible and
+    // implemented
+    typedef typename util::combine_if<
+        typename boost::mpl::vector1<Geometry1>,
+        typename boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::types,
+        // Here we want should remove most of the combinations that
+        // are not valid, mostly to limit the size of the resulting MPL set.
+        // But is_implementedn is not ready for prime time
+        //
+        // util::is_implemented2<boost::mpl::_1, boost::mpl::_2, dispatch::distance<boost::mpl::_1, boost::mpl::_2> >
+        boost::mpl::always<boost::mpl::true_>
+    >::type possible_input_types;
+
+    // The (possibly variant) result type resulting from these combinations
+    typedef typename compress_variant<
+        typename transform_variant<
+            possible_input_types,
+            resolve_strategy::distance_result<
+                boost::mpl::first<boost::mpl::_>,
+                boost::mpl::second<boost::mpl::_>,
+                Strategy
+            >,
+            boost::mpl::back_inserter<boost::mpl::vector0<> >
+        >::type
+    >::type type;
+};
+
+
+// Distance arguments are commutative
+template
+<
+    BOOST_VARIANT_ENUM_PARAMS(typename T),
+    typename Geometry2,
+    typename Strategy
+>
+struct distance_result
+    <
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>,
+        Geometry2,
+        Strategy
+    > : public distance_result
+        <
+            Geometry2, boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Strategy
+        >
+{};
+
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Strategy>
+struct distance_result
+    <
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>,
+        boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>,
+        Strategy
+    >
+{
+    // A set of all variant type combinations that are compatible and
+    // implemented
+    typedef typename util::combine_if
+        <
+            typename boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::types,
+            typename boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::types,
+            // Here we want to try to remove most of the combinations
+            // that are not valid, mostly to limit the size of the
+            // resulting MPL vector.
+            // But is_implemented is not ready for prime time
+            //
+            // util::is_implemented2<boost::mpl::_1, boost::mpl::_2, dispatch::distance<boost::mpl::_1, boost::mpl::_2> >
+            boost::mpl::always<boost::mpl::true_>
+        >::type possible_input_types;
+
+    // The (possibly variant) result type resulting from these combinations
+    typedef typename compress_variant<
+        typename transform_variant<
+            possible_input_types,
+            resolve_strategy::distance_result<
+                boost::mpl::first<boost::mpl::_>,
+                boost::mpl::second<boost::mpl::_>,
+                Strategy
+            >,
+            boost::mpl::back_inserter<boost::mpl::vector0<> >
+        >::type
+    >::type type;
+};
+
+} // namespace resolve_variant
+
+
+/*!
+\brief Meta-function defining return type of distance function
+\ingroup distance
+\note The strategy defines the return-type (so this situation is different
+    from length, where distance is sqr/sqrt, but length always squared)
+ */
+template
+<
+    typename Geometry1,
+    typename Geometry2 = Geometry1,
+    typename Strategy = void
+>
+struct distance_result
+    : resolve_variant::distance_result<Geometry1, Geometry2, Strategy>
+{};
+
+
+template <typename Geometry1, typename Geometry2>
+struct distance_result<Geometry1, Geometry2, void>
+    : distance_result<Geometry1, Geometry2, default_strategy>
+{};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_DISTANCE_RESULT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/envelope.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/envelope.hpp
new file mode 100644
index 00000000000..fde9c858a6a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/envelope.hpp
@@ -0,0 +1,45 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2016-2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fisikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_ENVELOPE_HPP
+#define BOOST_GEOMETRY_STRATEGIES_ENVELOPE_HPP
+
+#include <boost/mpl/assert.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace envelope { namespace services
+{
+
+/*!
+\brief Traits class binding a default envelope strategy to a coordinate system
+\ingroup util
+\tparam CSTag tag of coordinate system
+\tparam CalculationType \tparam_calculation
+*/
+template <typename CSTag, typename CalculationType = void>
+struct default_strategy
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_TYPE
+            , (types<CSTag>)
+        );
+};
+
+}}} // namespace strategy::envelope::services
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_ENVELOPE_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/area.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/area.hpp
new file mode 100644
index 00000000000..44dc2e69459
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/area.hpp
@@ -0,0 +1,231 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2016-2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fisikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_AREA_HPP
+#define BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_AREA_HPP
+
+
+#include <boost/geometry/core/srs.hpp>
+
+#include <boost/geometry/formulas/area_formulas.hpp>
+#include <boost/geometry/formulas/flattening.hpp>
+
+#include <boost/geometry/strategies/geographic/parameters.hpp>
+
+#include <boost/math/special_functions/atanh.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace area
+{
+
+/*!
+\brief Geographic area calculation
+\ingroup strategies
+\details Geographic area calculation by trapezoidal rule plus integral
+         approximation that gives the ellipsoidal correction
+\tparam PointOfSegment \tparam_segment_point
+\tparam FormulaPolicy Formula used to calculate azimuths
+\tparam SeriesOrder The order of approximation of the geodesic integral
+\tparam Spheroid The spheroid model
+\tparam CalculationType \tparam_calculation
+\author See
+- Danielsen JS, The area under the geodesic. Surv Rev 30(232): 61–66, 1989
+- Charles F.F Karney, Algorithms for geodesics, 2011 https://arxiv.org/pdf/1109.4448.pdf
+
+\qbk{
+[heading See also]
+[link geometry.reference.algorithms.area.area_2_with_strategy area (with strategy)]
+}
+*/
+template
+<
+    typename PointOfSegment,
+    typename FormulaPolicy = strategy::andoyer,
+    std::size_t SeriesOrder = strategy::default_order<FormulaPolicy>::value,
+    typename Spheroid = srs::spheroid<double>,
+    typename CalculationType = void
+>
+class geographic
+{
+    // Switch between two kinds of approximation(series in eps and n v.s.series in k ^ 2 and e'^2)
+    static const bool ExpandEpsN = true;
+    // LongSegment Enables special handling of long segments
+    static const bool LongSegment = false;
+
+    //Select default types in case they are not set
+
+    typedef typename boost::mpl::if_c
+    <
+        boost::is_void<CalculationType>::type::value,
+        typename select_most_precise
+            <
+                typename coordinate_type<PointOfSegment>::type,
+                double
+            >::type,
+        CalculationType
+    >::type CT;
+
+protected :
+    struct spheroid_constants
+    {
+        Spheroid m_spheroid;
+        CT const m_a2;  // squared equatorial radius
+        CT const m_e2;  // squared eccentricity
+        CT const m_ep2; // squared second eccentricity
+        CT const m_ep;  // second eccentricity
+        CT const m_c2;  // squared authalic radius
+
+        inline spheroid_constants(Spheroid const& spheroid)
+            : m_spheroid(spheroid)
+            , m_a2(math::sqr(get_radius<0>(spheroid)))
+            , m_e2(formula::flattening<CT>(spheroid)
+                 * (CT(2.0) - CT(formula::flattening<CT>(spheroid))))
+            , m_ep2(m_e2 / (CT(1.0) - m_e2))
+            , m_ep(math::sqrt(m_ep2))
+            , m_c2(authalic_radius(spheroid, m_a2, m_e2))
+        {}
+    };
+
+    static inline CT authalic_radius(Spheroid const& sph, CT const& a2, CT const& e2)
+    {
+        CT const c0 = 0;
+
+        if (math::equals(e2, c0))
+        {
+            return a2;
+        }
+
+        CT const sqrt_e2 = math::sqrt(e2);
+        CT const c2 = 2;
+
+        return (a2 / c2) +
+                  ((math::sqr(get_radius<2>(sph)) * boost::math::atanh(sqrt_e2))
+                   / (c2 * sqrt_e2));
+    }
+
+    struct area_sums
+    {
+        CT m_excess_sum;
+        CT m_correction_sum;
+
+        // Keep track if encircles some pole
+        std::size_t m_crosses_prime_meridian;
+
+        inline area_sums()
+            : m_excess_sum(0)
+            , m_correction_sum(0)
+            , m_crosses_prime_meridian(0)
+        {}
+        inline CT area(spheroid_constants spheroid_const) const
+        {
+            CT result;
+
+            CT sum = spheroid_const.m_c2 * m_excess_sum
+                   + spheroid_const.m_e2 * spheroid_const.m_a2 * m_correction_sum;
+
+            // If encircles some pole
+            if (m_crosses_prime_meridian % 2 == 1)
+            {
+                std::size_t times_crosses_prime_meridian
+                        = 1 + (m_crosses_prime_meridian / 2);
+
+                result = CT(2.0)
+                         * geometry::math::pi<CT>()
+                         * spheroid_const.m_c2
+                         * CT(times_crosses_prime_meridian)
+                         - geometry::math::abs(sum);
+
+                if (geometry::math::sign<CT>(sum) == 1)
+                {
+                    result = - result;
+                }
+
+            }
+            else
+            {
+                result = sum;
+            }
+
+            return result;
+        }
+    };
+
+public :
+    typedef CT return_type;
+    typedef PointOfSegment segment_point_type;
+    typedef area_sums state_type;
+
+    explicit inline geographic(Spheroid const& spheroid = Spheroid())
+        : m_spheroid_constants(spheroid)
+    {}
+
+    inline void apply(PointOfSegment const& p1,
+                      PointOfSegment const& p2,
+                      area_sums& state) const
+    {
+
+        if (! geometry::math::equals(get<0>(p1), get<0>(p2)))
+        {
+
+            typedef geometry::formula::area_formulas
+                <
+                    CT, SeriesOrder, ExpandEpsN
+                > area_formulas;
+
+            typename area_formulas::return_type_ellipsoidal result =
+                     area_formulas::template ellipsoidal<FormulaPolicy::template inverse>
+                                             (p1, p2, m_spheroid_constants);
+
+            state.m_excess_sum += result.spherical_term;
+            state.m_correction_sum += result.ellipsoidal_term;
+
+            // Keep track whenever a segment crosses the prime meridian
+            geometry::formula::area_formulas<CT>
+                    ::crosses_prime_meridian(p1, p2, state);
+        }
+    }
+
+    inline return_type result(area_sums const& state) const
+    {
+        return state.area(m_spheroid_constants);
+    }
+
+private:
+    spheroid_constants m_spheroid_constants;
+
+};
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+
+template <typename Point>
+struct default_strategy<geographic_tag, Point>
+{
+    typedef strategy::area::geographic<Point> type;
+};
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+}
+
+}} // namespace strategy::area
+
+
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_AREA_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/azimuth.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/azimuth.hpp
new file mode 100644
index 00000000000..79c49750fb3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/azimuth.hpp
@@ -0,0 +1,121 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2016-2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fisikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_AZIMUTH_HPP
+#define BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_AZIMUTH_HPP
+
+
+#include <boost/geometry/core/srs.hpp>
+
+#include <boost/geometry/strategies/azimuth.hpp>
+#include <boost/geometry/strategies/geographic/parameters.hpp>
+
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_void.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace azimuth
+{
+
+template
+<
+    typename FormulaPolicy = strategy::andoyer,
+    typename Spheroid = srs::spheroid<double>,
+    typename CalculationType = void
+>
+class geographic
+{
+public :
+
+    typedef Spheroid model_type;
+
+    inline geographic()
+        : m_spheroid()
+    {}
+
+    explicit inline geographic(Spheroid const& spheroid)
+        : m_spheroid(spheroid)
+    {}
+
+    inline model_type const& model() const
+    {
+        return m_spheroid;
+    }
+
+    template <typename T>
+    inline void apply(T const& lon1_rad, T const& lat1_rad,
+                      T const& lon2_rad, T const& lat2_rad,
+                      T& a1, T& a2) const
+    {
+        typedef typename boost::mpl::if_
+            <
+                boost::is_void<CalculationType>, T, CalculationType
+            >::type calc_t;            
+
+        typedef typename FormulaPolicy::template inverse<calc_t, false, true, true, false, false> inverse_type;
+        typedef typename inverse_type::result_type inverse_result;
+        inverse_result i_res = inverse_type::apply(calc_t(lon1_rad), calc_t(lat1_rad),
+                                                   calc_t(lon2_rad), calc_t(lat2_rad),
+                                                   m_spheroid);
+        a1 = i_res.azimuth;
+        a2 = i_res.reverse_azimuth;
+    }
+
+    template <typename T>
+    inline void apply(T const& lon1_rad, T const& lat1_rad,
+                      T const& lon2_rad, T const& lat2_rad,
+                      T& a1) const
+    {
+        typedef typename boost::mpl::if_
+                <
+                    boost::is_void<CalculationType>, T, CalculationType
+                >::type calc_t;
+
+        typedef typename FormulaPolicy::template inverse<calc_t, false, true, false, false, false> inverse_type;
+        typedef typename inverse_type::result_type inverse_result;
+        inverse_result i_res = inverse_type::apply(calc_t(lon1_rad), calc_t(lat1_rad),
+                                                   calc_t(lon2_rad), calc_t(lat2_rad),
+                                                   m_spheroid);
+        a1 = i_res.azimuth;
+    }
+
+private :
+    Spheroid m_spheroid;
+};
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+template <typename CalculationType>
+struct default_strategy<geographic_tag, CalculationType>
+{
+    typedef strategy::azimuth::geographic
+        <
+            strategy::andoyer,
+            srs::spheroid<double>,
+            CalculationType
+        > type;
+};
+
+}
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+}} // namespace strategy::azimuth
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_AZIMUTH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/disjoint_segment_box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/disjoint_segment_box.hpp
new file mode 100644
index 00000000000..afc9d667754
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/disjoint_segment_box.hpp
@@ -0,0 +1,130 @@
+// Boost.Geometry
+
+// Copyright (c) 2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_DISJOINT_SEGMENT_BOX_HPP
+#define BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_DISJOINT_SEGMENT_BOX_HPP
+
+
+#include <cstddef>
+#include <utility>
+
+#include <boost/numeric/conversion/cast.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/calculation_type.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/algorithms/detail/assign_indexed_point.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/segment_box.hpp>
+
+#include <boost/geometry/strategies/disjoint.hpp>
+#include <boost/geometry/strategies/geographic/azimuth.hpp>
+#include <boost/geometry/strategies/geographic/parameters.hpp>
+
+
+namespace boost { namespace geometry { namespace strategy { namespace disjoint
+{
+
+// NOTE: This may be temporary place for this or corresponding strategy
+// It seems to be more appropriate to implement the opposite of it
+// e.g. intersection::segment_box because in disjoint() algorithm
+// other strategies that are used are intersection and covered_by strategies.
+template
+<
+    typename FormulaPolicy = strategy::andoyer,
+    typename Spheroid = srs::spheroid<double>,
+    typename CalculationType = void
+>
+struct segment_box_geographic
+{
+public:
+    typedef Spheroid model_type;
+
+    inline segment_box_geographic()
+        : m_spheroid()
+    {}
+
+    explicit inline segment_box_geographic(Spheroid const& spheroid)
+        : m_spheroid(spheroid)
+    {}
+
+    template <typename Segment, typename Box>
+    struct point_in_geometry_strategy
+        : services::default_strategy
+            <
+                typename point_type<Segment>::type,
+                Box
+            >
+    {};
+
+    template <typename Segment, typename Box>
+    static inline typename point_in_geometry_strategy<Segment, Box>::type
+        get_point_in_geometry_strategy()
+    {
+        typedef typename point_in_geometry_strategy<Segment, Box>::type strategy_type;
+
+        return strategy_type();
+    }
+
+    template <typename Segment, typename Box>
+    inline bool apply(Segment const& segment, Box const& box) const
+    {
+        geometry::strategy::azimuth::geographic
+            <
+                FormulaPolicy,
+                Spheroid,
+                CalculationType
+            > azimuth_geographic(m_spheroid);
+
+        return geometry::detail::disjoint::disjoint_segment_box_sphere_or_spheroid
+                <geographic_tag>::apply(segment, box, azimuth_geographic);
+    }
+
+private:
+    Spheroid m_spheroid;
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+namespace services
+{
+
+template <typename Linear, typename Box, typename LinearTag>
+struct default_strategy<Linear, Box, LinearTag, box_tag, 1, 2,
+                        geographic_tag, geographic_tag>
+{
+    typedef segment_box_geographic<> type;
+};
+
+template <typename Box, typename Linear, typename LinearTag>
+struct default_strategy<Box, Linear, box_tag, LinearTag, 2, 1,
+                        geographic_tag, geographic_tag>
+{
+    typedef segment_box_geographic<> type;
+};
+
+
+} // namespace services
+
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}}}} // namespace boost::geometry::strategy::disjoint
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_DISJOINT_SEGMENT_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/distance.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/distance.hpp
new file mode 100644
index 00000000000..d3656f449c2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/distance.hpp
@@ -0,0 +1,195 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2016 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014-2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_DISTANCE_HPP
+#define BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_DISTANCE_HPP
+
+
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/radian_access.hpp>
+#include <boost/geometry/core/radius.hpp>
+#include <boost/geometry/core/srs.hpp>
+
+#include <boost/geometry/formulas/andoyer_inverse.hpp>
+#include <boost/geometry/formulas/flattening.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/geographic/parameters.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/promote_floating_point.hpp>
+#include <boost/geometry/util/select_calculation_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace distance
+{
+
+template
+<
+    typename FormulaPolicy = strategy::andoyer,
+    typename Spheroid = srs::spheroid<double>,
+    typename CalculationType = void
+>
+class geographic
+{
+public :
+    template <typename Point1, typename Point2>
+    struct calculation_type
+        : promote_floating_point
+          <
+              typename select_calculation_type
+                  <
+                      Point1,
+                      Point2,
+                      CalculationType
+                  >::type
+          >
+    {};
+
+    typedef Spheroid model_type;
+
+    inline geographic()
+        : m_spheroid()
+    {}
+
+    explicit inline geographic(Spheroid const& spheroid)
+        : m_spheroid(spheroid)
+    {}
+
+    template <typename Point1, typename Point2>
+    inline typename calculation_type<Point1, Point2>::type
+    apply(Point1 const& point1, Point2 const& point2) const
+    {
+        return FormulaPolicy::template inverse
+            <
+                typename calculation_type<Point1, Point2>::type,
+                true, false, false, false, false
+            >::apply(get_as_radian<0>(point1), get_as_radian<1>(point1),
+                     get_as_radian<0>(point2), get_as_radian<1>(point2),
+                     m_spheroid).distance;
+    }
+
+    inline Spheroid const& model() const
+    {
+        return m_spheroid;
+    }
+
+private :
+    Spheroid m_spheroid;
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+template
+<
+    typename FormulaPolicy,
+    typename Spheroid,
+    typename CalculationType
+>
+struct tag<geographic<FormulaPolicy, Spheroid, CalculationType> >
+{
+    typedef strategy_tag_distance_point_point type;
+};
+
+
+template
+<
+    typename FormulaPolicy,
+    typename Spheroid,
+    typename CalculationType,
+    typename P1,
+    typename P2
+>
+struct return_type<geographic<FormulaPolicy, Spheroid, CalculationType>, P1, P2>
+    : geographic<FormulaPolicy, Spheroid, CalculationType>::template calculation_type<P1, P2>
+{};
+
+
+template
+<
+    typename FormulaPolicy,
+    typename Spheroid,
+    typename CalculationType
+>
+struct comparable_type<geographic<FormulaPolicy, Spheroid, CalculationType> >
+{
+    typedef geographic<FormulaPolicy, Spheroid, CalculationType> type;
+};
+
+
+template
+<
+    typename FormulaPolicy,
+    typename Spheroid,
+    typename CalculationType
+>
+struct get_comparable<geographic<FormulaPolicy, Spheroid, CalculationType> >
+{
+    static inline geographic<FormulaPolicy, Spheroid, CalculationType>
+        apply(geographic<FormulaPolicy, Spheroid, CalculationType> const& input)
+    {
+        return input;
+    }
+};
+
+template
+<
+    typename FormulaPolicy,
+    typename Spheroid,
+    typename CalculationType,
+    typename P1,
+    typename P2
+>
+struct result_from_distance<geographic<FormulaPolicy, Spheroid, CalculationType>, P1, P2>
+{
+    template <typename T>
+    static inline typename return_type<geographic<FormulaPolicy, Spheroid, CalculationType>, P1, P2>::type
+        apply(geographic<FormulaPolicy, Spheroid, CalculationType> const& , T const& value)
+    {
+        return value;
+    }
+};
+
+
+template <typename Point1, typename Point2>
+struct default_strategy<point_tag, point_tag, Point1, Point2, geographic_tag, geographic_tag>
+{
+    typedef strategy::distance::geographic
+                <
+                    strategy::andoyer,
+                    srs::spheroid
+                        <
+                            typename select_coordinate_type<Point1, Point2>::type
+                        >
+                > type;
+};
+
+
+} // namespace services
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::distance
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_DISTANCE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/distance_andoyer.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/distance_andoyer.hpp
new file mode 100644
index 00000000000..d732951642b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/distance_andoyer.hpp
@@ -0,0 +1,128 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2016 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014, 2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_DISTANCE_DETAIL_HPP
+#define BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_DISTANCE_DETAIL_HPP
+
+
+#include <boost/geometry/strategies/geographic/distance.hpp>
+#include <boost/geometry/strategies/geographic/parameters.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace distance
+{
+
+
+/*!
+\brief Point-point distance approximation taking flattening into account
+\ingroup distance
+\tparam Spheroid The reference spheroid model
+\tparam CalculationType \tparam_calculation
+\author After Andoyer, 19xx, republished 1950, republished by Meeus, 1999
+\note Although not so well-known, the approximation is very good: in all cases the results
+are about the same as Vincenty. In my (Barend's) testcases the results didn't differ more than 6 m
+\see http://nacc.upc.es/tierra/node16.html
+\see http://sci.tech-archive.net/Archive/sci.geo.satellite-nav/2004-12/2724.html
+\see http://home.att.net/~srschmitt/great_circle_route.html (implementation)
+\see http://www.codeguru.com/Cpp/Cpp/algorithms/article.php/c5115 (implementation)
+\see http://futureboy.homeip.net/frinksamp/navigation.frink (implementation)
+\see http://www.voidware.com/earthdist.htm (implementation)
+\see http://www.dtic.mil/docs/citations/AD0627893
+\see http://www.dtic.mil/docs/citations/AD703541
+*/
+template
+<
+    typename Spheroid = srs::spheroid<double>,
+    typename CalculationType = void
+>
+class andoyer
+    : public strategy::distance::geographic
+        <
+            strategy::andoyer, Spheroid, CalculationType
+        >
+{
+    typedef strategy::distance::geographic
+        <
+            strategy::andoyer, Spheroid, CalculationType
+        > base_type;
+
+public :
+    inline andoyer()
+        : base_type()
+    {}
+
+    explicit inline andoyer(Spheroid const& spheroid)
+        : base_type(spheroid)
+    {}
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+template <typename Spheroid, typename CalculationType>
+struct tag<andoyer<Spheroid, CalculationType> >
+{
+    typedef strategy_tag_distance_point_point type;
+};
+
+
+template <typename Spheroid, typename CalculationType, typename P1, typename P2>
+struct return_type<andoyer<Spheroid, CalculationType>, P1, P2>
+    : andoyer<Spheroid, CalculationType>::template calculation_type<P1, P2>
+{};
+
+
+template <typename Spheroid, typename CalculationType>
+struct comparable_type<andoyer<Spheroid, CalculationType> >
+{
+    typedef andoyer<Spheroid, CalculationType> type;
+};
+
+
+template <typename Spheroid, typename CalculationType>
+struct get_comparable<andoyer<Spheroid, CalculationType> >
+{
+    static inline andoyer<Spheroid, CalculationType> apply(andoyer<Spheroid, CalculationType> const& input)
+    {
+        return input;
+    }
+};
+
+template <typename Spheroid, typename CalculationType, typename P1, typename P2>
+struct result_from_distance<andoyer<Spheroid, CalculationType>, P1, P2>
+{
+    template <typename T>
+    static inline typename return_type<andoyer<Spheroid, CalculationType>, P1, P2>::type
+        apply(andoyer<Spheroid, CalculationType> const& , T const& value)
+    {
+        return value;
+    }
+};
+
+
+} // namespace services
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::distance
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_DISTANCE_DETAIL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/distance_thomas.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/distance_thomas.hpp
new file mode 100644
index 00000000000..490920c7781
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/distance_thomas.hpp
@@ -0,0 +1,121 @@
+// Boost.Geometry
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2015-2017.
+// Modifications copyright (c) 2015-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_THOMAS_HPP
+#define BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_THOMAS_HPP
+
+
+#include <boost/geometry/strategies/geographic/distance.hpp>
+#include <boost/geometry/strategies/geographic/parameters.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace distance
+{
+
+/*!
+\brief The solution of the inverse problem of geodesics on latlong coordinates,
+       Forsyth-Andoyer-Lambert type approximation with second order terms.
+\ingroup distance
+\tparam Spheroid The reference spheroid model
+\tparam CalculationType \tparam_calculation
+\author See
+    - Technical Report: PAUL D. THOMAS, MATHEMATICAL MODELS FOR NAVIGATION SYSTEMS, 1965
+      http://www.dtic.mil/docs/citations/AD0627893
+    - Technical Report: PAUL D. THOMAS, SPHEROIDAL GEODESICS, REFERENCE SYSTEMS, AND LOCAL GEOMETRY, 1970
+      http://www.dtic.mil/docs/citations/AD703541
+*/
+template
+<
+    typename Spheroid = srs::spheroid<double>,
+    typename CalculationType = void
+>
+class thomas
+    : public strategy::distance::geographic
+        <
+            strategy::thomas, Spheroid, CalculationType
+        >
+{
+    typedef strategy::distance::geographic
+        <
+            strategy::thomas, Spheroid, CalculationType
+        > base_type;
+
+public :
+    inline thomas()
+        : base_type()
+    {}
+
+    explicit inline thomas(Spheroid const& spheroid)
+        : base_type(spheroid)
+    {}
+};
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+template <typename Spheroid, typename CalculationType>
+struct tag<thomas<Spheroid, CalculationType> >
+{
+    typedef strategy_tag_distance_point_point type;
+};
+
+
+template <typename Spheroid, typename CalculationType, typename P1, typename P2>
+struct return_type<thomas<Spheroid, CalculationType>, P1, P2>
+    : thomas<Spheroid, CalculationType>::template calculation_type<P1, P2>
+{};
+
+
+template <typename Spheroid, typename CalculationType>
+struct comparable_type<thomas<Spheroid, CalculationType> >
+{
+    typedef thomas<Spheroid, CalculationType> type;
+};
+
+
+template <typename Spheroid, typename CalculationType>
+struct get_comparable<thomas<Spheroid, CalculationType> >
+{
+    static inline thomas<Spheroid, CalculationType> apply(thomas<Spheroid, CalculationType> const& input)
+    {
+        return input;
+    }
+};
+
+template <typename Spheroid, typename CalculationType, typename P1, typename P2>
+struct result_from_distance<thomas<Spheroid, CalculationType>, P1, P2 >
+{
+    template <typename T>
+    static inline typename return_type<thomas<Spheroid, CalculationType>, P1, P2>::type
+        apply(thomas<Spheroid, CalculationType> const& , T const& value)
+    {
+        return value;
+    }
+};
+
+
+} // namespace services
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::distance
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_THOMAS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/distance_vincenty.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/distance_vincenty.hpp
new file mode 100644
index 00000000000..41146db9ff4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/distance_vincenty.hpp
@@ -0,0 +1,127 @@
+// Boost.Geometry
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014-2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_VINCENTY_HPP
+#define BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_VINCENTY_HPP
+
+
+#include <boost/geometry/strategies/geographic/distance.hpp>
+#include <boost/geometry/strategies/geographic/parameters.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace distance
+{
+
+/*!
+\brief Distance calculation formulae on latlong coordinates, after Vincenty, 1975
+\ingroup distance
+\tparam Spheroid The reference spheroid model
+\tparam CalculationType \tparam_calculation
+\author See
+    - http://www.ngs.noaa.gov/PUBS_LIB/inverse.pdf
+    - http://www.icsm.gov.au/gda/gdav2.3.pdf
+\author Adapted from various implementations to get it close to the original document
+    - http://www.movable-type.co.uk/scripts/LatLongVincenty.html
+    - http://exogen.case.edu/projects/geopy/source/geopy.distance.html
+    - http://futureboy.homeip.net/fsp/colorize.fsp?fileName=navigation.frink
+
+*/
+template
+<
+    typename Spheroid = srs::spheroid<double>,
+    typename CalculationType = void
+>
+class vincenty
+    : public strategy::distance::geographic
+        <
+            strategy::vincenty, Spheroid, CalculationType
+        >
+{
+    typedef strategy::distance::geographic
+        <
+            strategy::vincenty, Spheroid, CalculationType
+        > base_type;
+
+public:
+    inline vincenty()
+        : base_type()
+    {}
+
+    explicit inline vincenty(Spheroid const& spheroid)
+        : base_type(spheroid)
+    {}
+};
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+template <typename Spheroid, typename CalculationType>
+struct tag<vincenty<Spheroid, CalculationType> >
+{
+    typedef strategy_tag_distance_point_point type;
+};
+
+
+template <typename Spheroid, typename CalculationType, typename P1, typename P2>
+struct return_type<vincenty<Spheroid, CalculationType>, P1, P2>
+    : vincenty<Spheroid, CalculationType>::template calculation_type<P1, P2>
+{};
+
+
+template <typename Spheroid, typename CalculationType>
+struct comparable_type<vincenty<Spheroid, CalculationType> >
+{
+    typedef vincenty<Spheroid, CalculationType> type;
+};
+
+
+template <typename Spheroid, typename CalculationType>
+struct get_comparable<vincenty<Spheroid, CalculationType> >
+{
+    static inline vincenty<Spheroid, CalculationType> apply(vincenty<Spheroid, CalculationType> const& input)
+    {
+        return input;
+    }
+};
+
+template <typename Spheroid, typename CalculationType, typename P1, typename P2>
+struct result_from_distance<vincenty<Spheroid, CalculationType>, P1, P2 >
+{
+    template <typename T>
+    static inline typename return_type<vincenty<Spheroid, CalculationType>, P1, P2>::type
+        apply(vincenty<Spheroid, CalculationType> const& , T const& value)
+    {
+        return value;
+    }
+};
+
+
+} // namespace services
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+// We might add a vincenty-like strategy also for point-segment distance, but to calculate the projected point is not trivial
+
+
+
+}} // namespace strategy::distance
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_VINCENTY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/envelope_segment.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/envelope_segment.hpp
new file mode 100644
index 00000000000..3641b394286
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/envelope_segment.hpp
@@ -0,0 +1,104 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fisikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_ENVELOPE_SEGMENT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_ENVELOPE_SEGMENT_HPP
+
+
+#include <boost/geometry/algorithms/detail/envelope/segment.hpp>
+#include <boost/geometry/algorithms/detail/normalize.hpp>
+#include <boost/geometry/core/srs.hpp>
+#include <boost/geometry/strategies/envelope.hpp>
+#include <boost/geometry/strategies/geographic/azimuth.hpp>
+#include <boost/geometry/strategies/geographic/parameters.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace envelope
+{
+
+template
+<
+    typename FormulaPolicy = strategy::andoyer,
+    typename Spheroid = geometry::srs::spheroid<double>,
+    typename CalculationType = void
+>
+class geographic_segment
+{
+public:
+    typedef Spheroid model_type;
+
+    inline geographic_segment()
+        : m_spheroid()
+    {}
+
+    explicit inline geographic_segment(Spheroid const& spheroid)
+        : m_spheroid(spheroid)
+    {}
+
+    template <typename Point1, typename Point2, typename Box>
+    inline void apply(Point1 const& point1, Point2 const& point2, Box& box) const
+    {
+        Point1 p1_normalized = detail::return_normalized<Point1>(point1);
+        Point2 p2_normalized = detail::return_normalized<Point2>(point2);
+
+        geometry::strategy::azimuth::geographic
+            <
+                FormulaPolicy,
+                Spheroid,
+                CalculationType
+            > azimuth_geographic(m_spheroid);
+
+        typedef typename coordinate_system<Point1>::type::units units_type;
+
+        detail::envelope::envelope_segment_impl
+            <
+                geographic_tag
+            >::template apply<units_type>(geometry::get<0>(p1_normalized),
+                                          geometry::get<1>(p1_normalized),
+                                          geometry::get<0>(p2_normalized),
+                                          geometry::get<1>(p2_normalized),
+                                          box,
+                                          azimuth_geographic);
+
+    }
+
+private:
+    Spheroid m_spheroid;
+};
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+template <typename CalculationType>
+struct default_strategy<geographic_tag, CalculationType>
+{
+    typedef strategy::envelope::geographic_segment
+        <
+            strategy::andoyer,
+            srs::spheroid<double>,
+            CalculationType
+        > type;
+};
+
+}
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::envelope
+
+}} //namepsace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_ENVELOPE_SEGMENT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/intersection.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/intersection.hpp
new file mode 100644
index 00000000000..59a40f281d6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/intersection.hpp
@@ -0,0 +1,979 @@
+// Boost.Geometry
+
+// Copyright (c) 2016-2017, Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_INTERSECTION_HPP
+#define BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_INTERSECTION_HPP
+
+#include <algorithm>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/radian_access.hpp>
+#include <boost/geometry/core/srs.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/detail/assign_values.hpp>
+#include <boost/geometry/algorithms/detail/assign_indexed_point.hpp>
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+#include <boost/geometry/algorithms/detail/recalculate.hpp>
+
+#include <boost/geometry/formulas/andoyer_inverse.hpp>
+#include <boost/geometry/formulas/sjoberg_intersection.hpp>
+#include <boost/geometry/formulas/spherical.hpp>
+
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+#include <boost/geometry/geometries/concepts/segment_concept.hpp>
+
+#include <boost/geometry/policies/robustness/segment_ratio.hpp>
+
+#include <boost/geometry/strategies/geographic/area.hpp>
+#include <boost/geometry/strategies/geographic/distance.hpp>
+#include <boost/geometry/strategies/geographic/envelope_segment.hpp>
+#include <boost/geometry/strategies/geographic/parameters.hpp>
+#include <boost/geometry/strategies/geographic/side.hpp>
+#include <boost/geometry/strategies/intersection.hpp>
+#include <boost/geometry/strategies/intersection_result.hpp>
+#include <boost/geometry/strategies/side_info.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/select_calculation_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace intersection
+{
+
+// CONSIDER: Improvement of the robustness/accuracy/repeatability by
+// moving all segments to 0 longitude
+// picking latitudes closer to 0
+// etc.
+
+template
+<
+    typename FormulaPolicy = strategy::andoyer,
+    unsigned int Order = strategy::default_order<FormulaPolicy>::value,
+    typename Spheroid = srs::spheroid<double>,
+    typename CalculationType = void
+>
+struct geographic_segments
+{
+    typedef side::geographic
+        <
+            FormulaPolicy, Spheroid, CalculationType
+        > side_strategy_type;
+
+    inline side_strategy_type get_side_strategy() const
+    {
+        return side_strategy_type(m_spheroid);
+    }
+
+    template <typename Geometry1, typename Geometry2>
+    struct point_in_geometry_strategy
+    {
+        typedef strategy::within::winding
+            <
+                typename point_type<Geometry1>::type,
+                typename point_type<Geometry2>::type,
+                side_strategy_type,
+                CalculationType
+            > type;
+    };
+
+    template <typename Geometry1, typename Geometry2>
+    inline typename point_in_geometry_strategy<Geometry1, Geometry2>::type
+        get_point_in_geometry_strategy() const
+    {
+        typedef typename point_in_geometry_strategy
+            <
+                Geometry1, Geometry2
+            >::type strategy_type;
+        return strategy_type(get_side_strategy());
+    }
+
+    template <typename Geometry>
+    struct area_strategy
+    {
+        typedef area::geographic
+            <
+                typename point_type<Geometry>::type,
+                FormulaPolicy,
+                Order,
+                Spheroid,
+                CalculationType
+            > type;
+    };
+
+    template <typename Geometry>
+    inline typename area_strategy<Geometry>::type get_area_strategy() const
+    {
+        typedef typename area_strategy<Geometry>::type strategy_type;
+        return strategy_type(m_spheroid);
+    }
+
+    template <typename Geometry>
+    struct distance_strategy
+    {
+        typedef distance::geographic
+            <
+                FormulaPolicy,
+                Spheroid,
+                CalculationType
+            > type;
+    };
+
+    template <typename Geometry>
+    inline typename distance_strategy<Geometry>::type get_distance_strategy() const
+    {
+        typedef typename distance_strategy<Geometry>::type strategy_type;
+        return strategy_type(m_spheroid);
+    }
+
+    typedef envelope::geographic_segment<FormulaPolicy, Spheroid, CalculationType>
+        envelope_strategy_type;
+
+    inline envelope_strategy_type get_envelope_strategy() const
+    {
+        return envelope_strategy_type(m_spheroid);
+    }
+
+    enum intersection_point_flag { ipi_inters = 0, ipi_at_a1, ipi_at_a2, ipi_at_b1, ipi_at_b2 };
+
+    template <typename CoordinateType, typename SegmentRatio>
+    struct segment_intersection_info
+    {
+        typedef typename select_most_precise
+            <
+                CoordinateType, double
+            >::type promoted_type;
+
+        promoted_type comparable_length_a() const
+        {
+            return robust_ra.denominator();
+        }
+
+        promoted_type comparable_length_b() const
+        {
+            return robust_rb.denominator();
+        }
+
+        template <typename Point, typename Segment1, typename Segment2>
+        void assign_a(Point& point, Segment1 const& a, Segment2 const& b) const
+        {
+            assign(point, a, b);
+        }
+        template <typename Point, typename Segment1, typename Segment2>
+        void assign_b(Point& point, Segment1 const& a, Segment2 const& b) const
+        {
+            assign(point, a, b);
+        }
+
+        template <typename Point, typename Segment1, typename Segment2>
+        void assign(Point& point, Segment1 const& a, Segment2 const& b) const
+        {
+            if (ip_flag == ipi_inters)
+            {
+                // TODO: assign the rest of coordinates
+                set_from_radian<0>(point, lon);
+                set_from_radian<1>(point, lat);
+            }
+            else if (ip_flag == ipi_at_a1)
+            {
+                detail::assign_point_from_index<0>(a, point);
+            }
+            else if (ip_flag == ipi_at_a2)
+            {
+                detail::assign_point_from_index<1>(a, point);
+            }
+            else if (ip_flag == ipi_at_b1)
+            {
+                detail::assign_point_from_index<0>(b, point);
+            }
+            else // ip_flag == ipi_at_b2
+            {
+                detail::assign_point_from_index<1>(b, point);
+            }
+        }
+
+        CoordinateType lon;
+        CoordinateType lat;
+        SegmentRatio robust_ra;
+        SegmentRatio robust_rb;
+        intersection_point_flag ip_flag;
+    };
+
+    explicit geographic_segments(Spheroid const& spheroid = Spheroid())
+        : m_spheroid(spheroid)
+    {}
+
+    // Relate segments a and b
+    template
+    <
+        typename Segment1,
+        typename Segment2,
+        typename Policy,
+        typename RobustPolicy
+    >
+    inline typename Policy::return_type apply(Segment1 const& a, Segment2 const& b,
+                                              Policy const& policy,
+                                              RobustPolicy const& robust_policy) const
+    {
+        typedef typename point_type<Segment1>::type point1_t;
+        typedef typename point_type<Segment2>::type point2_t;
+        point1_t a1, a2;
+        point2_t b1, b2;
+
+        detail::assign_point_from_index<0>(a, a1);
+        detail::assign_point_from_index<1>(a, a2);
+        detail::assign_point_from_index<0>(b, b1);
+        detail::assign_point_from_index<1>(b, b2);
+
+        return apply(a, b, policy, robust_policy, a1, a2, b1, b2);
+    }
+
+    // Relate segments a and b
+    template
+    <
+        typename Segment1,
+        typename Segment2,
+        typename Policy,
+        typename RobustPolicy,
+        typename Point1,
+        typename Point2
+    >
+    inline typename Policy::return_type apply(Segment1 const& a, Segment2 const& b,
+                                              Policy const&, RobustPolicy const&,
+                                              Point1 a1, Point1 a2, Point2 b1, Point2 b2) const
+    {
+        bool is_a_reversed = get<1>(a1) > get<1>(a2);
+        bool is_b_reversed = get<1>(b1) > get<1>(b2);
+                           
+        if (is_a_reversed)
+        {
+            std::swap(a1, a2);
+        }
+
+        if (is_b_reversed)
+        {
+            std::swap(b1, b2);
+        }
+
+        return apply<Policy>(a, b, a1, a2, b1, b2, is_a_reversed, is_b_reversed);
+    }
+
+private:
+    // Relate segments a and b
+    template
+    <
+        typename Policy,
+        typename Segment1,
+        typename Segment2,
+        typename Point1,
+        typename Point2
+    >
+    inline typename Policy::return_type apply(Segment1 const& a, Segment2 const& b,
+                                              Point1 const& a1, Point1 const& a2,
+                                              Point2 const& b1, Point2 const& b2,
+                                              bool is_a_reversed, bool is_b_reversed) const
+    {
+        BOOST_CONCEPT_ASSERT( (concepts::ConstSegment<Segment1>) );
+        BOOST_CONCEPT_ASSERT( (concepts::ConstSegment<Segment2>) );
+
+        typedef typename select_calculation_type
+            <Segment1, Segment2, CalculationType>::type calc_t;
+
+        static const calc_t c0 = 0;
+
+        // normalized spheroid
+        srs::spheroid<calc_t> spheroid = normalized_spheroid<calc_t>(m_spheroid);
+
+        // TODO: check only 2 first coordinates here?
+        using geometry::detail::equals::equals_point_point;
+        bool a_is_point = equals_point_point(a1, a2);
+        bool b_is_point = equals_point_point(b1, b2);
+
+        if(a_is_point && b_is_point)
+        {
+            return equals_point_point(a1, b2)
+                ? Policy::degenerate(a, true)
+                : Policy::disjoint()
+                ;
+        }
+        
+        calc_t const a1_lon = get_as_radian<0>(a1);
+        calc_t const a1_lat = get_as_radian<1>(a1);
+        calc_t const a2_lon = get_as_radian<0>(a2);
+        calc_t const a2_lat = get_as_radian<1>(a2);
+        calc_t const b1_lon = get_as_radian<0>(b1);
+        calc_t const b1_lat = get_as_radian<1>(b1);
+        calc_t const b2_lon = get_as_radian<0>(b2);
+        calc_t const b2_lat = get_as_radian<1>(b2);
+
+        side_info sides;
+
+        // NOTE: potential optimization, don't calculate distance at this point
+        // this would require to reimplement inverse strategy to allow
+        // calculation of distance if needed, probably also storing intermediate
+        // results somehow inside an object.
+        typedef typename FormulaPolicy::template inverse<calc_t, true, true, false, false, false> inverse_dist_azi;
+        typedef typename inverse_dist_azi::result_type inverse_result;
+
+        // TODO: no need to call inverse formula if we know that the points are equal
+        // distance can be set to 0 in this case and azimuth may be not calculated
+        bool is_equal_a1_b1 = equals_point_point(a1, b1);
+        bool is_equal_a2_b1 = equals_point_point(a2, b1);
+        bool degen_neq_coords = false;
+
+        inverse_result res_b1_b2, res_b1_a1, res_b1_a2;
+        if (! b_is_point)
+        {
+            res_b1_b2 = inverse_dist_azi::apply(b1_lon, b1_lat, b2_lon, b2_lat, spheroid);
+            if (math::equals(res_b1_b2.distance, c0))
+            {
+                b_is_point = true;
+                degen_neq_coords = true;
+            }
+            else
+            {
+                res_b1_a1 = inverse_dist_azi::apply(b1_lon, b1_lat, a1_lon, a1_lat, spheroid);
+                if (math::equals(res_b1_a1.distance, c0))
+                {
+                    is_equal_a1_b1 = true;
+                }
+                res_b1_a2 = inverse_dist_azi::apply(b1_lon, b1_lat, a2_lon, a2_lat, spheroid);
+                if (math::equals(res_b1_a2.distance, c0))
+                {
+                    is_equal_a2_b1 = true;
+                }
+                sides.set<0>(is_equal_a1_b1 ? 0 : formula::azimuth_side_value(res_b1_a1.azimuth, res_b1_b2.azimuth),
+                             is_equal_a2_b1 ? 0 : formula::azimuth_side_value(res_b1_a2.azimuth, res_b1_b2.azimuth));
+                if (sides.same<0>())
+                {
+                    // Both points are at the same side of other segment, we can leave
+                    return Policy::disjoint();
+                }
+            }
+        }
+
+        bool is_equal_a1_b2 = equals_point_point(a1, b2);
+
+        inverse_result res_a1_a2, res_a1_b1, res_a1_b2;
+        if (! a_is_point)
+        {
+            res_a1_a2 = inverse_dist_azi::apply(a1_lon, a1_lat, a2_lon, a2_lat, spheroid);
+            if (math::equals(res_a1_a2.distance, c0))
+            {
+                a_is_point = true;
+                degen_neq_coords = true;
+            }
+            else
+            {
+                res_a1_b1 = inverse_dist_azi::apply(a1_lon, a1_lat, b1_lon, b1_lat, spheroid);
+                if (math::equals(res_a1_b1.distance, c0))
+                {
+                    is_equal_a1_b1 = true;
+                }
+                res_a1_b2 = inverse_dist_azi::apply(a1_lon, a1_lat, b2_lon, b2_lat, spheroid);
+                if (math::equals(res_a1_b2.distance, c0))
+                {
+                    is_equal_a1_b2 = true;
+                }
+                sides.set<1>(is_equal_a1_b1 ? 0 : formula::azimuth_side_value(res_a1_b1.azimuth, res_a1_a2.azimuth),
+                             is_equal_a1_b2 ? 0 : formula::azimuth_side_value(res_a1_b2.azimuth, res_a1_a2.azimuth));
+                if (sides.same<1>())
+                {
+                    // Both points are at the same side of other segment, we can leave
+                    return Policy::disjoint();
+                }
+            }
+        }
+
+        if(a_is_point && b_is_point)
+        {
+            return is_equal_a1_b2
+                ? Policy::degenerate(a, true)
+                : Policy::disjoint()
+                ;
+        }
+
+        // NOTE: at this point the segments may still be disjoint
+        // NOTE: at this point one of the segments may be degenerated
+
+        bool collinear = sides.collinear();       
+
+        if (! collinear)
+        {
+            // WARNING: the side strategy doesn't have the info about the other
+            // segment so it may return results inconsistent with this intersection
+            // strategy, as it checks both segments for consistency
+
+            if (sides.get<0, 0>() == 0 && sides.get<0, 1>() == 0)
+            {
+                collinear = true;
+                sides.set<1>(0, 0);
+            }
+            else if (sides.get<1, 0>() == 0 && sides.get<1, 1>() == 0)
+            {
+                collinear = true;
+                sides.set<0>(0, 0);
+            }
+        }
+
+        if (collinear)
+        {
+            if (a_is_point)
+            {
+                return collinear_one_degenerated<Policy, calc_t>(a, true, b1, b2, a1, a2, res_b1_b2, res_b1_a1, res_b1_a2, is_b_reversed, degen_neq_coords);
+            }
+            else if (b_is_point)
+            {
+                return collinear_one_degenerated<Policy, calc_t>(b, false, a1, a2, b1, b2, res_a1_a2, res_a1_b1, res_a1_b2, is_a_reversed, degen_neq_coords);
+            }
+            else
+            {
+                calc_t dist_a1_a2, dist_a1_b1, dist_a1_b2;
+                calc_t dist_b1_b2, dist_b1_a1, dist_b1_a2;
+                // use shorter segment
+                if (res_a1_a2.distance <= res_b1_b2.distance)
+                {
+                    calculate_collinear_data(a1, a2, b1, b2, res_a1_a2, res_a1_b1, res_a1_b2, dist_a1_a2, dist_a1_b1);
+                    calculate_collinear_data(a1, a2, b1, b2, res_a1_a2, res_a1_b2, res_a1_b1, dist_a1_a2, dist_a1_b2);
+                    dist_b1_b2 = dist_a1_b2 - dist_a1_b1;
+                    dist_b1_a1 = -dist_a1_b1;
+                    dist_b1_a2 = dist_a1_a2 - dist_a1_b1;
+                }
+                else
+                {
+                    calculate_collinear_data(b1, b2, a1, a2, res_b1_b2, res_b1_a1, res_b1_a2, dist_b1_b2, dist_b1_a1);
+                    calculate_collinear_data(b1, b2, a1, a2, res_b1_b2, res_b1_a2, res_b1_a1, dist_b1_b2, dist_b1_a2);
+                    dist_a1_a2 = dist_b1_a2 - dist_b1_a1;
+                    dist_a1_b1 = -dist_b1_a1;
+                    dist_a1_b2 = dist_b1_b2 - dist_b1_a1;
+                }
+
+                // NOTE: this is probably not needed
+                calc_t const c0 = 0;
+                int a1_on_b = position_value(c0, dist_a1_b1, dist_a1_b2);
+                int a2_on_b = position_value(dist_a1_a2, dist_a1_b1, dist_a1_b2);
+                int b1_on_a = position_value(c0, dist_b1_a1, dist_b1_a2);
+                int b2_on_a = position_value(dist_b1_b2, dist_b1_a1, dist_b1_a2);
+
+                if ((a1_on_b < 1 && a2_on_b < 1) || (a1_on_b > 3 && a2_on_b > 3))
+                {
+                    return Policy::disjoint();
+                }
+
+                if (a1_on_b == 1)
+                {
+                    dist_b1_a1 = 0;
+                    dist_a1_b1 = 0;
+                }
+                else if (a1_on_b == 3)
+                {
+                    dist_b1_a1 = dist_b1_b2;
+                    dist_a1_b2 = 0;
+                }
+
+                if (a2_on_b == 1)
+                {
+                    dist_b1_a2 = 0;
+                    dist_a1_b1 = dist_a1_a2;
+                }
+                else if (a2_on_b == 3)
+                {
+                    dist_b1_a2 = dist_b1_b2;
+                    dist_a1_b2 = dist_a1_a2;
+                }
+
+                bool opposite = ! same_direction(res_a1_a2.azimuth, res_b1_b2.azimuth);
+
+                // NOTE: If segment was reversed opposite, positions and segment ratios has to be altered
+                if (is_a_reversed)
+                {
+                    // opposite
+                    opposite = ! opposite;
+                    // positions
+                    std::swap(a1_on_b, a2_on_b);
+                    b1_on_a = 4 - b1_on_a;
+                    b2_on_a = 4 - b2_on_a;
+                    // distances for ratios
+                    std::swap(dist_b1_a1, dist_b1_a2);
+                    dist_a1_b1 = dist_a1_a2 - dist_a1_b1;
+                    dist_a1_b2 = dist_a1_a2 - dist_a1_b2;
+                }
+                if (is_b_reversed)
+                {
+                    // opposite
+                    opposite = ! opposite;
+                    // positions
+                    a1_on_b = 4 - a1_on_b;
+                    a2_on_b = 4 - a2_on_b;
+                    std::swap(b1_on_a, b2_on_a);
+                    // distances for ratios
+                    dist_b1_a1 = dist_b1_b2 - dist_b1_a1;
+                    dist_b1_a2 = dist_b1_b2 - dist_b1_a2;
+                    std::swap(dist_a1_b1, dist_a1_b2);
+                }
+
+                segment_ratio<calc_t> ra_from(dist_b1_a1, dist_b1_b2);
+                segment_ratio<calc_t> ra_to(dist_b1_a2, dist_b1_b2);
+                segment_ratio<calc_t> rb_from(dist_a1_b1, dist_a1_a2);
+                segment_ratio<calc_t> rb_to(dist_a1_b2, dist_a1_a2);
+
+                return Policy::segments_collinear(a, b, opposite,
+                    a1_on_b, a2_on_b, b1_on_a, b2_on_a,
+                    ra_from, ra_to, rb_from, rb_to);
+            }
+        }
+        else // crossing or touching
+        {
+            if (a_is_point || b_is_point)
+            {
+                return Policy::disjoint();
+            }
+
+            calc_t lon = 0, lat = 0;
+            intersection_point_flag ip_flag;
+            calc_t dist_a1_a2, dist_a1_i1, dist_b1_b2, dist_b1_i1;
+            if (calculate_ip_data(a1, a2, b1, b2,
+                                  a1_lon, a1_lat, a2_lon, a2_lat,
+                                  b1_lon, b1_lat, b2_lon, b2_lat,
+                                  res_a1_a2, res_a1_b1, res_a1_b2,
+                                  res_b1_b2, res_b1_a1, res_b1_a2,
+                                  sides, spheroid,
+                                  lon, lat,
+                                  dist_a1_a2, dist_a1_i1, dist_b1_b2, dist_b1_i1,
+                                  ip_flag))
+            {
+                // NOTE: If segment was reversed sides and segment ratios has to be altered
+                if (is_a_reversed)
+                {
+                    // sides
+                    sides_reverse_segment<0>(sides);
+                    // distance for ratio
+                    dist_a1_i1 = dist_a1_a2 - dist_a1_i1;
+                    // ip flag
+                    ip_flag_reverse_segment(ip_flag, ipi_at_a1, ipi_at_a2);
+                }
+                if (is_b_reversed)
+                {
+                    // sides
+                    sides_reverse_segment<1>(sides);
+                    // distance for ratio
+                    dist_b1_i1 = dist_b1_b2 - dist_b1_i1;
+                    // ip flag
+                    ip_flag_reverse_segment(ip_flag, ipi_at_b1, ipi_at_b2);
+                }
+
+                // intersects
+                segment_intersection_info
+                    <
+                        calc_t,
+                        segment_ratio<calc_t>
+                    > sinfo;
+
+                sinfo.lon = lon;
+                sinfo.lat = lat;
+                sinfo.robust_ra.assign(dist_a1_i1, dist_a1_a2);
+                sinfo.robust_rb.assign(dist_b1_i1, dist_b1_b2);
+                sinfo.ip_flag = ip_flag;
+
+                return Policy::segments_crosses(sides, sinfo, a, b);
+            }
+            else
+            {
+                return Policy::disjoint();
+            }
+        }
+    }
+
+    template <typename Policy, typename CalcT, typename Segment, typename Point1, typename Point2, typename ResultInverse>
+    static inline typename Policy::return_type
+        collinear_one_degenerated(Segment const& segment, bool degenerated_a,
+                                  Point1 const& a1, Point1 const& a2,
+                                  Point2 const& b1, Point2 const& b2,
+                                  ResultInverse const& res_a1_a2,
+                                  ResultInverse const& res_a1_b1,
+                                  ResultInverse const& res_a1_b2,
+                                  bool is_other_reversed,
+                                  bool degen_neq_coords)
+    {
+        CalcT dist_1_2, dist_1_o;
+        if (! calculate_collinear_data(a1, a2, b1, b2, res_a1_a2, res_a1_b1, res_a1_b2, dist_1_2, dist_1_o, degen_neq_coords))
+        {
+            return Policy::disjoint();
+        }
+
+        // NOTE: If segment was reversed segment ratio has to be altered
+        if (is_other_reversed)
+        {
+            // distance for ratio
+            dist_1_o = dist_1_2 - dist_1_o;
+        }
+        
+        return Policy::one_degenerate(segment, segment_ratio<CalcT>(dist_1_o, dist_1_2), degenerated_a);
+    }
+
+    // TODO: instead of checks below test bi against a1 and a2 here?
+    //       in order to make this independent from is_near()
+    template <typename Point1, typename Point2, typename ResultInverse, typename CalcT>
+    static inline bool calculate_collinear_data(Point1 const& a1, Point1 const& a2, // in
+                                                Point2 const& b1, Point2 const& b2, // in
+                                                ResultInverse const& res_a1_a2,     // in
+                                                ResultInverse const& res_a1_b1,     // in
+                                                ResultInverse const& res_a1_b2,     // in
+                                                CalcT& dist_a1_a2,                  // out
+                                                CalcT& dist_a1_bi,                  // out
+                                                bool degen_neq_coords = false)      // in
+    {
+        dist_a1_a2 = res_a1_a2.distance;
+
+        dist_a1_bi = res_a1_b1.distance;
+        if (! same_direction(res_a1_b1.azimuth, res_a1_a2.azimuth))
+        {
+            dist_a1_bi = -dist_a1_bi;
+        }
+
+        // if i1 is close to a1 and b1 or b2 is equal to a1
+        if (is_endpoint_equal(dist_a1_bi, a1, b1, b2))
+        {
+            dist_a1_bi = 0;
+            return true;
+        }
+        // or i1 is close to a2 and b1 or b2 is equal to a2
+        else if (is_endpoint_equal(dist_a1_a2 - dist_a1_bi, a2, b1, b2))
+        {
+            dist_a1_bi = dist_a1_a2;
+            return true;
+        }
+
+        // check the other endpoint of a very short segment near the pole
+        if (degen_neq_coords)
+        {
+            static CalcT const c0 = 0;
+            if (math::equals(res_a1_b2.distance, c0))
+            {
+                dist_a1_bi = 0;
+                return true;
+            }
+            else if (math::equals(dist_a1_a2 - res_a1_b2.distance, c0))
+            {
+                dist_a1_bi = dist_a1_a2;
+                return true;
+            }
+        }
+
+        // or i1 is on b
+        return segment_ratio<CalcT>(dist_a1_bi, dist_a1_a2).on_segment();
+    }
+
+    template <typename Point1, typename Point2, typename CalcT, typename ResultInverse, typename Spheroid_>
+    static inline bool calculate_ip_data(Point1 const& a1, Point1 const& a2,       // in
+                                         Point2 const& b1, Point2 const& b2,       // in
+                                         CalcT const& a1_lon, CalcT const& a1_lat, // in
+                                         CalcT const& a2_lon, CalcT const& a2_lat, // in
+                                         CalcT const& b1_lon, CalcT const& b1_lat, // in
+                                         CalcT const& b2_lon, CalcT const& b2_lat, // in
+                                         ResultInverse const& res_a1_a2,           // in
+                                         ResultInverse const& res_a1_b1,           // in
+                                         ResultInverse const& res_a1_b2,           // in
+                                         ResultInverse const& res_b1_b2,           // in
+                                         ResultInverse const& res_b1_a1,           // in
+                                         ResultInverse const& res_b1_a2,           // in
+                                         side_info const& sides,                   // in
+                                         Spheroid_ const& spheroid,                // in
+                                         CalcT & lon, CalcT & lat,             // out
+                                         CalcT& dist_a1_a2, CalcT& dist_a1_ip, // out
+                                         CalcT& dist_b1_b2, CalcT& dist_b1_ip, // out
+                                         intersection_point_flag& ip_flag)     // out
+    {
+        dist_a1_a2 = res_a1_a2.distance;
+        dist_b1_b2 = res_b1_b2.distance;
+
+        // assign the IP if some endpoints overlap
+        using geometry::detail::equals::equals_point_point;
+        if (equals_point_point(a1, b1))
+        {
+            lon = a1_lon;
+            lat = a1_lat;
+            dist_a1_ip = 0;
+            dist_b1_ip = 0;
+            ip_flag = ipi_at_a1;
+            return true;
+        }
+        else if (equals_point_point(a1, b2))
+        {
+            lon = a1_lon;
+            lat = a1_lat;
+            dist_a1_ip = 0;
+            dist_b1_ip = dist_b1_b2;
+            ip_flag = ipi_at_a1;
+            return true;
+        }
+        else if (equals_point_point(a2, b1))
+        {
+            lon = a2_lon;
+            lat = a2_lat;
+            dist_a1_ip = dist_a1_a2;
+            dist_b1_ip = 0;
+            ip_flag = ipi_at_a2;
+            return true;
+        }
+        else if (equals_point_point(a2, b2))
+        {
+            lon = a2_lon;
+            lat = a2_lat;
+            dist_a1_ip = dist_a1_a2;
+            dist_b1_ip = dist_b1_b2;
+            ip_flag = ipi_at_a2;
+            return true;
+        }
+
+        // at this point we know that the endpoints doesn't overlap
+        // check cases when an endpoint lies on the other geodesic
+        if (sides.template get<0, 0>() == 0) // a1 wrt b
+        {
+            if (res_b1_a1.distance <= res_b1_b2.distance
+                && same_direction(res_b1_a1.azimuth, res_b1_b2.azimuth))
+            {
+                lon = a1_lon;
+                lat = a1_lat;
+                dist_a1_ip = 0;
+                dist_b1_ip = res_b1_a1.distance;
+                ip_flag = ipi_at_a1;
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+        else if (sides.template get<0, 1>() == 0) // a2 wrt b
+        {
+            if (res_b1_a2.distance <= res_b1_b2.distance
+                && same_direction(res_b1_a2.azimuth, res_b1_b2.azimuth))
+            {
+                lon = a2_lon;
+                lat = a2_lat;
+                dist_a1_ip = res_a1_a2.distance;
+                dist_b1_ip = res_b1_a2.distance;
+                ip_flag = ipi_at_a2;
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+        else if (sides.template get<1, 0>() == 0) // b1 wrt a
+        {
+            if (res_a1_b1.distance <= res_a1_a2.distance
+                && same_direction(res_a1_b1.azimuth, res_a1_a2.azimuth))
+            {
+                lon = b1_lon;
+                lat = b1_lat;
+                dist_a1_ip = res_a1_b1.distance;
+                dist_b1_ip = 0;
+                ip_flag = ipi_at_b1;
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+        else if (sides.template get<1, 1>() == 0) // b2 wrt a
+        {
+            if (res_a1_b2.distance <= res_a1_a2.distance
+                && same_direction(res_a1_b2.azimuth, res_a1_a2.azimuth))
+            {
+                lon = b2_lon;
+                lat = b2_lat;
+                dist_a1_ip = res_a1_b2.distance;
+                dist_b1_ip = res_b1_b2.distance;
+                ip_flag = ipi_at_b2;
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
+        // At this point neither the endpoints overlaps
+        // nor any andpoint lies on the other geodesic
+        // So the endpoints should lie on the opposite sides of both geodesics
+
+        bool const ok = formula::sjoberg_intersection<CalcT, FormulaPolicy::template inverse, Order>
+                        ::apply(a1_lon, a1_lat, a2_lon, a2_lat, res_a1_a2.azimuth,
+                                b1_lon, b1_lat, b2_lon, b2_lat, res_b1_b2.azimuth,
+                                lon, lat, spheroid);
+
+        if (! ok)
+        {
+            return false;
+        }
+
+        typedef typename FormulaPolicy::template inverse<CalcT, true, true, false, false, false> inverse_dist_azi;
+        typedef typename inverse_dist_azi::result_type inverse_result;
+
+        inverse_result const res_a1_ip = inverse_dist_azi::apply(a1_lon, a1_lat, lon, lat, spheroid);
+        dist_a1_ip = res_a1_ip.distance;
+        if (! same_direction(res_a1_ip.azimuth, res_a1_a2.azimuth))
+        {
+            dist_a1_ip = -dist_a1_ip;
+        }
+
+        bool is_on_a = segment_ratio<CalcT>(dist_a1_ip, dist_a1_a2).on_segment();
+        // NOTE: not fully consistent with equals_point_point() since radians are always used.
+        bool is_on_a1 = math::equals(lon, a1_lon) && math::equals(lat, a1_lat);
+        bool is_on_a2 = math::equals(lon, a2_lon) && math::equals(lat, a2_lat);
+
+        if (! (is_on_a || is_on_a1 || is_on_a2))
+        {
+            return false;
+        }
+
+        inverse_result const res_b1_ip = inverse_dist_azi::apply(b1_lon, b1_lat, lon, lat, spheroid);
+        dist_b1_ip = res_b1_ip.distance;
+        if (! same_direction(res_b1_ip.azimuth, res_b1_b2.azimuth))
+        {
+            dist_b1_ip = -dist_b1_ip;
+        }
+
+        bool is_on_b = segment_ratio<CalcT>(dist_b1_ip, dist_b1_b2).on_segment();
+        // NOTE: not fully consistent with equals_point_point() since radians are always used.
+        bool is_on_b1 = math::equals(lon, b1_lon) && math::equals(lat, b1_lat);
+        bool is_on_b2 = math::equals(lon, b2_lon) && math::equals(lat, b2_lat);
+
+        if (! (is_on_b || is_on_b1 || is_on_b2))
+        {
+            return false;
+        }
+        
+        ip_flag = ipi_inters;
+
+        if (is_on_b1)
+        {
+            lon = b1_lon;
+            lat = b1_lat;
+            dist_b1_ip = 0;
+            ip_flag = ipi_at_b1;
+        }
+        else if (is_on_b2)
+        {
+            lon = b2_lon;
+            lat = b2_lat;
+            dist_b1_ip = res_b1_b2.distance;
+            ip_flag = ipi_at_b2;
+        }
+
+        if (is_on_a1)
+        {
+            lon = a1_lon;
+            lat = a1_lat;
+            dist_a1_ip = 0;
+            ip_flag = ipi_at_a1;
+        }
+        else if (is_on_a2)
+        {
+            lon = a2_lon;
+            lat = a2_lat;
+            dist_a1_ip = res_a1_a2.distance;
+            ip_flag = ipi_at_a2;
+        }        
+
+        return true;
+    }
+
+    template <typename CalcT, typename P1, typename P2>
+    static inline bool is_endpoint_equal(CalcT const& dist,
+                                         P1 const& ai, P2 const& b1, P2 const& b2)
+    {
+        static CalcT const c0 = 0;
+        using geometry::detail::equals::equals_point_point;
+        return is_near(dist) && (equals_point_point(ai, b1) || equals_point_point(ai, b2) || math::equals(dist, c0));
+    }
+
+    template <typename CalcT>
+    static inline bool is_near(CalcT const& dist)
+    {
+        // NOTE: This strongly depends on the Inverse method
+        CalcT const small_number = CalcT(boost::is_same<CalcT, float>::value ? 0.0001 : 0.00000001);
+        return math::abs(dist) <= small_number;
+    }
+
+    template <typename ProjCoord1, typename ProjCoord2>
+    static inline int position_value(ProjCoord1 const& ca1,
+                                     ProjCoord2 const& cb1,
+                                     ProjCoord2 const& cb2)
+    {
+        // S1x  0   1    2     3   4
+        // S2       |---------->
+        return math::equals(ca1, cb1) ? 1
+             : math::equals(ca1, cb2) ? 3
+             : cb1 < cb2 ?
+                ( ca1 < cb1 ? 0
+                : ca1 > cb2 ? 4
+                : 2 )
+              : ( ca1 > cb1 ? 0
+                : ca1 < cb2 ? 4
+                : 2 );
+    }
+
+    template <typename CalcT>
+    static inline bool same_direction(CalcT const& azimuth1, CalcT const& azimuth2)
+    {
+        // distance between two angles normalized to (-180, 180]
+        CalcT const angle_diff = math::longitude_distance_signed<radian>(azimuth1, azimuth2);
+        return math::abs(angle_diff) <= math::half_pi<CalcT>();
+    }
+
+    template <int Which>
+    static inline void sides_reverse_segment(side_info & sides)
+    {
+        // names assuming segment A is reversed (Which == 0)
+        int a1_wrt_b = sides.template get<Which, 0>();
+        int a2_wrt_b = sides.template get<Which, 1>();
+        std::swap(a1_wrt_b, a2_wrt_b);
+        sides.template set<Which>(a1_wrt_b, a2_wrt_b);
+        int b1_wrt_a = sides.template get<1 - Which, 0>();
+        int b2_wrt_a = sides.template get<1 - Which, 1>();
+        sides.template set<1 - Which>(-b1_wrt_a, -b2_wrt_a);
+    }
+
+    static inline void ip_flag_reverse_segment(intersection_point_flag & ip_flag,
+                                               intersection_point_flag const& ipi_at_p1,
+                                               intersection_point_flag const& ipi_at_p2)
+    {
+        ip_flag = ip_flag == ipi_at_p1 ? ipi_at_p2 :
+                  ip_flag == ipi_at_p2 ? ipi_at_p1 :
+                  ip_flag;
+    }
+
+    template <typename CalcT, typename SpheroidT>
+    static inline srs::spheroid<CalcT> normalized_spheroid(SpheroidT const& spheroid)
+    {
+        return srs::spheroid<CalcT>(CalcT(1),
+                                    CalcT(get_radius<2>(spheroid)) // b/a
+                                    / CalcT(get_radius<0>(spheroid)));
+    }
+
+private:
+    Spheroid m_spheroid;
+};
+
+
+}} // namespace strategy::intersection
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_INTERSECTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/intersection_elliptic.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/intersection_elliptic.hpp
new file mode 100644
index 00000000000..76e9940fe3b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/intersection_elliptic.hpp
@@ -0,0 +1,243 @@
+// Boost.Geometry
+
+// Copyright (c) 2016-2017, Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_INTERSECTION_ELLIPTIC_HPP
+#define BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_INTERSECTION_ELLIPTIC_HPP
+
+
+#include <boost/geometry/core/srs.hpp>
+
+#include <boost/geometry/formulas/geographic.hpp>
+
+#include <boost/geometry/strategies/spherical/intersection.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace intersection
+{
+
+template <typename Spheroid>
+struct great_elliptic_segments_calc_policy
+    : spherical_segments_calc_policy
+{
+    explicit great_elliptic_segments_calc_policy(Spheroid const& spheroid = Spheroid())
+        : m_spheroid(spheroid)
+    {}
+
+    template <typename Point, typename Point3d>
+    Point from_cart3d(Point3d const& point_3d) const
+    {
+        return formula::cart3d_to_geo<Point>(point_3d, m_spheroid);
+    }
+
+    template <typename Point3d, typename Point>
+    Point3d to_cart3d(Point const& point) const
+    {
+        return formula::geo_to_cart3d<Point3d>(point, m_spheroid);
+    }
+
+    // relate_xxx_calc_policy must live londer than plane because it contains
+    // Spheroid object and plane keeps the reference to that object.
+    template <typename Point3d>
+    struct plane
+    {
+        typedef typename coordinate_type<Point3d>::type coord_t;
+
+        // not normalized
+        plane(Point3d const& p1, Point3d const& p2)
+            : normal(cross_product(p1, p2))
+        {}
+
+        int side_value(Point3d const& pt) const
+        {
+            return formula::sph_side_value(normal, pt);
+        }
+
+        coord_t cos_angle_between(Point3d const& p1, Point3d const& p2) const
+        {
+            Point3d v1 = p1;
+            detail::vec_normalize(v1);
+            Point3d v2 = p2;
+            detail::vec_normalize(v2);
+
+            return dot_product(v1, v2);
+        }
+
+        coord_t cos_angle_between(Point3d const& p1, Point3d const& p2, bool & is_forward) const
+        {
+            coord_t const c0 = 0;
+
+            Point3d v1 = p1;
+            detail::vec_normalize(v1);
+            Point3d v2 = p2;
+            detail::vec_normalize(v2);
+
+            is_forward = dot_product(normal, cross_product(v1, v2)) >= c0;
+            return dot_product(v1, v2);
+        }
+
+        Point3d normal;
+    };
+
+    template <typename Point3d>
+    plane<Point3d> get_plane(Point3d const& p1, Point3d const& p2) const
+    {
+        return plane<Point3d>(p1, p2);
+    }
+
+    template <typename Point3d>
+    bool intersection_points(plane<Point3d> const& plane1,
+                             plane<Point3d> const& plane2,
+                             Point3d & ip1, Point3d & ip2) const
+    {
+        typedef typename coordinate_type<Point3d>::type coord_t;
+
+        Point3d id = cross_product(plane1.normal, plane2.normal);
+        // NOTE: the length should be greater than 0 at this point
+        // NOTE: no need to normalize in this case
+
+        ip1 = formula::projected_to_surface(id, m_spheroid);
+
+        ip2 = ip1;
+        multiply_value(ip2, coord_t(-1));
+
+        return true;
+    }
+
+private:
+    Spheroid m_spheroid;
+};
+
+template <typename Spheroid>
+struct experimental_elliptic_segments_calc_policy
+{
+    explicit experimental_elliptic_segments_calc_policy(Spheroid const& spheroid = Spheroid())
+        : m_spheroid(spheroid)
+    {}
+
+    template <typename Point, typename Point3d>
+    Point from_cart3d(Point3d const& point_3d) const
+    {
+        return formula::cart3d_to_geo<Point>(point_3d, m_spheroid);
+    }
+
+    template <typename Point3d, typename Point>
+    Point3d to_cart3d(Point const& point) const
+    {
+        return formula::geo_to_cart3d<Point3d>(point, m_spheroid);
+    }
+
+    // relate_xxx_calc_policy must live londer than plane because it contains
+    // Spheroid object and plane keeps the reference to that object.
+    template <typename Point3d>
+    struct plane
+    {
+        typedef typename coordinate_type<Point3d>::type coord_t;
+
+        // not normalized
+        plane(Point3d const& p1, Point3d const& p2, Spheroid const& spheroid)
+            : m_spheroid(spheroid)
+        {
+            formula::experimental_elliptic_plane(p1, p2, origin, normal, m_spheroid);
+        }
+
+        int side_value(Point3d const& pt) const
+        {
+            return formula::elliptic_side_value(origin, normal, pt);
+        }
+
+        coord_t cos_angle_between(Point3d const& p1, Point3d const& p2) const
+        {
+            Point3d const v1 = normalized_vec(p1);
+            Point3d const v2 = normalized_vec(p2);
+            return dot_product(v1, v2);
+        }
+
+        coord_t cos_angle_between(Point3d const& p1, Point3d const& p2, bool & is_forward) const
+        {
+            coord_t const c0 = 0;
+
+            Point3d const v1 = normalized_vec(p1);
+            Point3d const v2 = normalized_vec(p2);
+            
+            is_forward = dot_product(normal, cross_product(v1, v2)) >= c0;
+            return dot_product(v1, v2);
+        }
+
+        Point3d origin;
+        Point3d normal;
+
+    private:
+        Point3d normalized_vec(Point3d const& p) const
+        {
+            Point3d v = p;
+            subtract_point(v, origin);
+            detail::vec_normalize(v);
+            return v;
+        }
+
+        Spheroid const& m_spheroid;
+    };
+
+    template <typename Point3d>
+    plane<Point3d> get_plane(Point3d const& p1, Point3d const& p2) const
+    {
+        return plane<Point3d>(p1, p2, m_spheroid);
+    }
+
+    template <typename Point3d>
+    bool intersection_points(plane<Point3d> const& plane1,
+                             plane<Point3d> const& plane2,
+                             Point3d & ip1, Point3d & ip2) const
+    {
+        return formula::planes_spheroid_intersection(plane1.origin, plane1.normal,
+                                                     plane2.origin, plane2.normal,
+                                                     ip1, ip2, m_spheroid);
+    }
+
+private:
+    Spheroid m_spheroid;
+};
+
+
+template
+<
+    typename Spheroid = srs::spheroid<double>,
+    typename CalculationType = void
+>
+struct great_elliptic_segments
+    : ecef_segments
+        <
+            great_elliptic_segments_calc_policy<Spheroid>,
+            CalculationType
+        >
+{};
+
+template
+<
+    typename Spheroid = srs::spheroid<double>,
+    typename CalculationType = void
+>
+struct experimental_elliptic_segments
+    : ecef_segments
+        <
+            experimental_elliptic_segments_calc_policy<Spheroid>,
+            CalculationType
+        >
+{};
+
+
+}} // namespace strategy::intersection
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_INTERSECTION_ELLIPTIC_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/mapping_ssf.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/mapping_ssf.hpp
new file mode 100644
index 00000000000..20a05236162
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/mapping_ssf.hpp
@@ -0,0 +1,185 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2011-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014, 2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_MAPPING_SSF_HPP
+#define BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_MAPPING_SSF_HPP
+
+
+#include <boost/core/ignore_unused.hpp>
+
+#include <boost/geometry/core/radius.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/promote_floating_point.hpp>
+#include <boost/geometry/util/select_calculation_type.hpp>
+
+#include <boost/geometry/strategies/side.hpp>
+#include <boost/geometry/strategies/spherical/ssf.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace side
+{
+
+
+// An enumeration type defining types of mapping of geographical
+// latitude to spherical latitude.
+// See: http://en.wikipedia.org/wiki/Great_ellipse
+//      http://en.wikipedia.org/wiki/Latitude#Auxiliary_latitudes
+enum mapping_type { mapping_geodetic, mapping_reduced, mapping_geocentric };
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <typename Spheroid, mapping_type Mapping>
+struct mapper
+{
+    explicit inline mapper(Spheroid const& /*spheroid*/) {}
+
+    template <typename CalculationType>
+    static inline CalculationType const& apply(CalculationType const& lat)
+    {
+        return lat;
+    }
+};
+
+template <typename Spheroid>
+struct mapper<Spheroid, mapping_reduced>
+{
+    typedef typename promote_floating_point
+        <
+            typename radius_type<Spheroid>::type
+        >::type fraction_type;
+
+    explicit inline mapper(Spheroid const& spheroid)
+    {
+        fraction_type const a = geometry::get_radius<0>(spheroid);
+        fraction_type const b = geometry::get_radius<2>(spheroid);
+        b_div_a = b / a;
+    }
+
+    template <typename CalculationType>
+    inline CalculationType apply(CalculationType const& lat) const
+    {
+        return atan(static_cast<CalculationType>(b_div_a) * tan(lat));
+    }
+
+    fraction_type b_div_a;
+};
+
+template <typename Spheroid>
+struct mapper<Spheroid, mapping_geocentric>
+{
+    typedef typename promote_floating_point
+        <
+            typename radius_type<Spheroid>::type
+        >::type fraction_type;
+
+    explicit inline mapper(Spheroid const& spheroid)
+    {
+        fraction_type const a = geometry::get_radius<0>(spheroid);
+        fraction_type const b = geometry::get_radius<2>(spheroid);
+        sqr_b_div_a = b / a;
+        sqr_b_div_a *= sqr_b_div_a;
+    }
+
+    template <typename CalculationType>
+    inline CalculationType apply(CalculationType const& lat) const
+    {
+        return atan(static_cast<CalculationType>(sqr_b_div_a) * tan(lat));
+    }
+
+    fraction_type sqr_b_div_a;
+};
+
+}
+#endif // DOXYGEN_NO_DETAIL
+
+
+/*!
+\brief Check at which side of a geographical segment a point lies
+         left of segment (> 0), right of segment (< 0), on segment (0).
+         The check is performed by mapping the geographical coordinates
+         to spherical coordinates and using spherical_side_formula.
+\ingroup strategies
+\tparam Spheroid The reference spheroid model
+\tparam Mapping The type of mapping of geographical to spherical latitude
+\tparam CalculationType \tparam_calculation
+ */
+template <typename Spheroid,
+          mapping_type Mapping = mapping_geodetic,
+          typename CalculationType = void>
+class mapping_spherical_side_formula
+{
+
+public :
+    inline mapping_spherical_side_formula()
+        : m_mapper(Spheroid())
+    {}
+
+    explicit inline mapping_spherical_side_formula(Spheroid const& spheroid)
+        : m_mapper(spheroid)
+    {}
+
+    template <typename P1, typename P2, typename P>
+    inline int apply(P1 const& p1, P2 const& p2, P const& p) const
+    {
+        typedef typename promote_floating_point
+            <
+                typename select_calculation_type_alt
+                    <
+                        CalculationType,
+                        P1, P2, P
+                    >::type
+            >::type calculation_type;
+
+        calculation_type lon1 = get_as_radian<0>(p1);
+        calculation_type lat1 = m_mapper.template apply<calculation_type>(get_as_radian<1>(p1));
+        calculation_type lon2 = get_as_radian<0>(p2);
+        calculation_type lat2 = m_mapper.template apply<calculation_type>(get_as_radian<1>(p2));
+        calculation_type lon = get_as_radian<0>(p);
+        calculation_type lat = m_mapper.template apply<calculation_type>(get_as_radian<1>(p));
+
+        return detail::spherical_side_formula(lon1, lat1, lon2, lat2, lon, lat);
+    }
+
+private:
+    side::detail::mapper<Spheroid, Mapping> const m_mapper;
+};
+
+// The specialization for geodetic latitude which can be used directly
+template <typename Spheroid,
+          typename CalculationType>
+class mapping_spherical_side_formula<Spheroid, mapping_geodetic, CalculationType>
+{
+
+public :
+    inline mapping_spherical_side_formula() {}
+    explicit inline mapping_spherical_side_formula(Spheroid const& /*spheroid*/) {}
+
+    template <typename P1, typename P2, typename P>
+    static inline int apply(P1 const& p1, P2 const& p2, P const& p)
+    {
+        return spherical_side_formula<CalculationType>::apply(p1, p2, p);
+    }
+};
+
+}} // namespace strategy::side
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_MAPPING_SSF_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/parameters.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/parameters.hpp
new file mode 100644
index 00000000000..5638db50faf
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/parameters.hpp
@@ -0,0 +1,117 @@
+// Boost.Geometry
+
+// Copyright (c) 2017, Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_PARAMETERS_HPP
+#define BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_PARAMETERS_HPP
+
+
+#include <boost/geometry/formulas/andoyer_inverse.hpp>
+#include <boost/geometry/formulas/thomas_inverse.hpp>
+#include <boost/geometry/formulas/vincenty_inverse.hpp>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/integral_c.hpp>
+
+
+namespace boost { namespace geometry { namespace strategy
+{
+
+struct andoyer
+{
+    template
+    <
+        typename CT,
+        bool EnableDistance,
+        bool EnableAzimuth,
+        bool EnableReverseAzimuth = false,
+        bool EnableReducedLength = false,
+        bool EnableGeodesicScale = false
+    >
+    struct inverse
+        : formula::andoyer_inverse
+            <
+                CT, EnableDistance,
+                EnableAzimuth, EnableReverseAzimuth,
+                EnableReducedLength, EnableGeodesicScale
+            >
+    {};
+};
+
+struct thomas
+{
+    template
+    <
+        typename CT,
+        bool EnableDistance,
+        bool EnableAzimuth,
+        bool EnableReverseAzimuth = false,
+        bool EnableReducedLength = false,
+        bool EnableGeodesicScale = false
+    >
+    struct inverse
+        : formula::thomas_inverse
+            <
+                CT, EnableDistance,
+                EnableAzimuth, EnableReverseAzimuth,
+                EnableReducedLength, EnableGeodesicScale
+            >
+    {};
+};
+
+struct vincenty
+{
+    template
+    <
+        typename CT,
+        bool EnableDistance,
+        bool EnableAzimuth,
+        bool EnableReverseAzimuth = false,
+        bool EnableReducedLength = false,
+        bool EnableGeodesicScale = false
+    >
+    struct inverse
+        : formula::vincenty_inverse
+            <
+                CT, EnableDistance,
+                EnableAzimuth, EnableReverseAzimuth,
+                EnableReducedLength, EnableGeodesicScale
+            >
+    {};
+};
+
+
+template <typename FormulaPolicy>
+struct default_order
+{
+    BOOST_MPL_ASSERT_MSG
+    (
+        false, NOT_IMPLEMENTED_FOR_THIS_TYPE
+        , (types<FormulaPolicy>)
+    );
+};
+
+template<>
+struct default_order<andoyer>
+    : boost::mpl::integral_c<unsigned int, 1>
+{};
+
+template<>
+struct default_order<thomas>
+    : boost::mpl::integral_c<unsigned int, 2>
+{};
+
+template<>
+struct default_order<vincenty>
+    : boost::mpl::integral_c<unsigned int, 4>
+{};
+
+}}} // namespace boost::geometry::strategy
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_PARAMETERS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/side.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/side.hpp
new file mode 100644
index 00000000000..9276965a976
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/side.hpp
@@ -0,0 +1,139 @@
+// Boost.Geometry
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014-2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_SIDE_HPP
+#define BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_SIDE_HPP
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/radian_access.hpp>
+#include <boost/geometry/core/radius.hpp>
+#include <boost/geometry/core/srs.hpp>
+
+#include <boost/geometry/formulas/spherical.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/promote_floating_point.hpp>
+#include <boost/geometry/util/select_calculation_type.hpp>
+
+#include <boost/geometry/strategies/geographic/disjoint_segment_box.hpp>
+#include <boost/geometry/strategies/geographic/envelope_segment.hpp>
+#include <boost/geometry/strategies/geographic/parameters.hpp>
+#include <boost/geometry/strategies/side.hpp>
+//#include <boost/geometry/strategies/concepts/side_concept.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace side
+{
+
+
+/*!
+\brief Check at which side of a segment a point lies
+         left of segment (> 0), right of segment (< 0), on segment (0)
+\ingroup strategies
+\tparam FormulaPolicy Geodesic solution formula policy.
+\tparam Spheroid Reference model of coordinate system.
+\tparam CalculationType \tparam_calculation
+ */
+template
+<
+    typename FormulaPolicy = strategy::andoyer,
+    typename Spheroid = srs::spheroid<double>,
+    typename CalculationType = void
+>
+class geographic
+{
+public:
+    typedef strategy::envelope::geographic_segment
+        <
+            FormulaPolicy,
+            Spheroid,
+            CalculationType
+        > envelope_strategy_type;
+
+    inline envelope_strategy_type get_envelope_strategy() const
+    {
+        return envelope_strategy_type(m_model);
+    }
+
+    typedef strategy::disjoint::segment_box_geographic
+        <
+            FormulaPolicy,
+            Spheroid,
+            CalculationType
+        > disjoint_strategy_type;
+
+    inline disjoint_strategy_type get_disjoint_strategy() const
+    {
+        return disjoint_strategy_type(m_model);
+    }
+
+    geographic()
+    {}
+
+    explicit geographic(Spheroid const& model)
+        : m_model(model)
+    {}
+
+    template <typename P1, typename P2, typename P>
+    inline int apply(P1 const& p1, P2 const& p2, P const& p) const
+    {
+        typedef typename promote_floating_point
+            <
+                typename select_calculation_type_alt
+                    <
+                        CalculationType,
+                        P1, P2, P
+                    >::type
+            >::type calc_t;
+
+        typedef typename FormulaPolicy::template inverse
+                    <calc_t, false, true, false, false, false> inverse_formula;
+
+        calc_t a1p = azimuth<calc_t, inverse_formula>(p1, p, m_model);
+        calc_t a12 = azimuth<calc_t, inverse_formula>(p1, p2, m_model);
+
+        return formula::azimuth_side_value(a1p, a12);
+    }
+
+private:
+    template <typename ResultType,
+              typename InverseFormulaType,
+              typename Point1,
+              typename Point2,
+              typename ModelT>
+    static inline ResultType azimuth(Point1 const& point1, Point2 const& point2,
+                                     ModelT const& model)
+    {
+        return InverseFormulaType::apply(get_as_radian<0>(point1),
+                                         get_as_radian<1>(point1),
+                                         get_as_radian<0>(point2),
+                                         get_as_radian<1>(point2),
+                                         model).azimuth;
+    }
+
+    Spheroid m_model;
+};
+
+
+}} // namespace strategy::side
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_SIDE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/side_andoyer.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/side_andoyer.hpp
new file mode 100644
index 00000000000..204e45f6e26
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/side_andoyer.hpp
@@ -0,0 +1,60 @@
+// Boost.Geometry
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014-2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_SIDE_ANDOYER_HPP
+#define BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_SIDE_ANDOYER_HPP
+
+
+#include <boost/geometry/strategies/geographic/side.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace side
+{
+
+/*!
+\brief Check at which side of a segment a point lies
+         left of segment (> 0), right of segment (< 0), on segment (0)
+\ingroup strategies
+\tparam Spheroid Reference model of coordinate system.
+\tparam CalculationType \tparam_calculation
+ */
+template
+<
+    typename Spheroid = srs::spheroid<double>,
+    typename CalculationType = void
+>
+class andoyer
+    : public side::geographic<strategy::andoyer, Spheroid, CalculationType>
+{
+    typedef side::geographic<strategy::andoyer, Spheroid, CalculationType> base_t;
+
+public:
+    andoyer()
+    {}
+
+    explicit andoyer(Spheroid const& model)
+        : base_t(model)
+    {}
+};
+
+}} // namespace strategy::side
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_SIDE_ANDOYER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/side_thomas.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/side_thomas.hpp
new file mode 100644
index 00000000000..e6f8d77b585
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/side_thomas.hpp
@@ -0,0 +1,60 @@
+// Boost.Geometry
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014-2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_SIDE_THOMAS_HPP
+#define BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_SIDE_THOMAS_HPP
+
+
+#include <boost/geometry/strategies/geographic/side.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace side
+{
+
+/*!
+\brief Check at which side of a segment a point lies
+         left of segment (> 0), right of segment (< 0), on segment (0)
+\ingroup strategies
+\tparam Spheroid Reference model of coordinate system.
+\tparam CalculationType \tparam_calculation
+ */
+template
+<
+    typename Spheroid = srs::spheroid<double>,
+    typename CalculationType = void
+>
+class thomas
+    : public side::geographic<strategy::thomas, Spheroid, CalculationType>
+{
+    typedef side::geographic<strategy::thomas, Spheroid, CalculationType> base_t;
+
+public:
+    thomas()
+    {}
+
+    explicit thomas(Spheroid const& model)
+        : base_t(model)
+    {}
+};
+
+}} // namespace strategy::side
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_SIDE_THOMAS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/side_vincenty.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/side_vincenty.hpp
new file mode 100644
index 00000000000..b2f51b09011
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/geographic/side_vincenty.hpp
@@ -0,0 +1,60 @@
+// Boost.Geometry
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014-2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_SIDE_VINCENTY_HPP
+#define BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_SIDE_VINCENTY_HPP
+
+
+#include <boost/geometry/strategies/geographic/side.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace side
+{
+
+/*!
+\brief Check at which side of a segment a point lies
+         left of segment (> 0), right of segment (< 0), on segment (0)
+\ingroup strategies
+\tparam Spheroid Reference model of coordinate system.
+\tparam CalculationType \tparam_calculation
+ */
+template
+<
+    typename Spheroid = srs::spheroid<double>,
+    typename CalculationType = void
+>
+class vincenty
+    : public side::geographic<strategy::vincenty, Spheroid, CalculationType>
+{
+    typedef side::geographic<strategy::vincenty, Spheroid, CalculationType> base_t;
+
+public:
+    vincenty()
+    {}
+
+    explicit vincenty(Spheroid const& model)
+        : base_t(model)
+    {}
+};
+
+}} // namespace strategy::side
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_GEOGRAPHIC_SIDE_VINCENTY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/intersection.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/intersection.hpp
new file mode 100644
index 00000000000..e5662c9e460
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/intersection.hpp
@@ -0,0 +1,51 @@
+// Boost.Geometry
+
+// Copyright (c) 2016-2017, Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_SEGMENT_INTERSECTION_HPP
+#define BOOST_GEOMETRY_STRATEGIES_SEGMENT_INTERSECTION_HPP
+
+
+#include <boost/geometry/strategies/tags.hpp>
+
+
+#include <boost/mpl/assert.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace intersection
+{
+
+namespace services
+{
+
+/*!
+\brief Traits class binding a segments intersection strategy to a coordinate system
+\ingroup util
+\tparam CSTag tag of coordinate system of point-type
+\tparam CalculationType \tparam_calculation
+*/
+template <typename CSTag, typename CalculationType = void>
+struct default_strategy
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_TYPE
+            , (types<CSTag>)
+        );
+};
+
+} // namespace services
+
+}} // namespace strategy::intersection
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_SEGMENT_INTERSECTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/intersection_result.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/intersection_result.hpp
new file mode 100644
index 00000000000..db2a46e6a38
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/intersection_result.hpp
@@ -0,0 +1,78 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2015, 2016.
+// Modifications copyright (c) 2015-2016 Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_INTERSECTION_RESULT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_INTERSECTION_RESULT_HPP
+
+#if defined(HAVE_MATRIX_AS_STRING)
+#include <string>
+#endif
+
+#include <cstddef>
+
+
+
+namespace boost { namespace geometry
+{
+
+template <typename SegmentRatio>
+struct fraction_type
+{
+    SegmentRatio robust_ra; // TODO this can be renamed now to "ra"
+    SegmentRatio robust_rb;
+
+    bool initialized;
+    inline fraction_type()
+        : initialized(false)
+    {}
+
+    template <typename Info>
+    inline void assign(Info const& info)
+    {
+        initialized = true;
+        robust_ra = info.robust_ra;
+        robust_rb = info.robust_rb;
+    }
+
+    inline void assign(SegmentRatio const& a, SegmentRatio const& b)
+    {
+        initialized = true;
+        robust_ra = a;
+        robust_rb = b;
+    }
+
+};
+
+//
+/*!
+\brief return-type for segment-intersection
+\note Set in intersection_points.hpp, from segment_intersection_info
+*/
+template <typename Point, typename SegmentRatio>
+struct segment_intersection_points
+{
+    std::size_t count; // The number of intersection points
+
+    // TODO: combine intersections and fractions in one struct
+    Point intersections[2];
+    fraction_type<SegmentRatio> fractions[2];
+    typedef Point point_type;
+
+    segment_intersection_points()
+        : count(0)
+    {}
+};
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_INTERSECTION_RESULT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/intersection_strategies.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/intersection_strategies.hpp
new file mode 100644
index 00000000000..a173505804c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/intersection_strategies.hpp
@@ -0,0 +1,101 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2016, 2017.
+// Modifications copyright (c) 2016-2017, Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_INTERSECTION_HPP
+#define BOOST_GEOMETRY_STRATEGIES_INTERSECTION_HPP
+
+
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/geometries/segment.hpp>
+
+#include <boost/geometry/policies/relate/intersection_points.hpp>
+#include <boost/geometry/policies/relate/direction.hpp>
+#include <boost/geometry/policies/relate/tupled.hpp>
+
+#include <boost/geometry/strategies/intersection.hpp>
+#include <boost/geometry/strategies/intersection_result.hpp>
+#include <boost/geometry/strategies/side.hpp>
+
+#include <boost/geometry/strategies/cartesian/intersection.hpp>
+#include <boost/geometry/strategies/cartesian/side_by_triangle.hpp>
+#include <boost/geometry/strategies/spherical/intersection.hpp>
+#include <boost/geometry/strategies/spherical/ssf.hpp>
+
+#include <boost/geometry/policies/robustness/segment_ratio_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+/*!
+\brief "compound strategy", containing a segment-intersection-strategy
+       and a side-strategy
+ */
+template
+<
+    typename Tag,
+    typename Geometry1,
+    typename Geometry2,
+    typename IntersectionPoint,
+    typename RobustPolicy,
+    typename CalculationType = void
+>
+struct intersection_strategies
+{
+private :
+    // for development BOOST_STATIC_ASSERT((! boost::is_same<RobustPolicy, void>::type::value));
+
+    typedef typename geometry::point_type<Geometry1>::type point1_type;
+    typedef typename geometry::point_type<Geometry2>::type point2_type;
+    typedef typename model::referring_segment<point1_type const> segment1_type;
+    typedef typename model::referring_segment<point2_type const> segment2_type;
+
+    typedef segment_intersection_points
+    <
+        IntersectionPoint,
+        typename geometry::segment_ratio_type
+        <
+            IntersectionPoint, RobustPolicy
+        >::type
+    > ip_type;
+
+public:
+    typedef policies::relate::segments_tupled
+        <
+            policies::relate::segments_intersection_points
+                <
+                    ip_type
+                > ,
+            policies::relate::segments_direction
+        > intersection_policy_type;
+
+    typedef typename strategy::intersection::services::default_strategy
+            <
+                Tag,
+                CalculationType
+            >::type segment_intersection_strategy_type;
+
+    typedef typename strategy::side::services::default_strategy
+        <
+            Tag,
+            CalculationType
+        >::type side_strategy_type;
+
+    typedef RobustPolicy rescale_policy_type;
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_INTERSECTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/relate.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/relate.hpp
new file mode 100644
index 00000000000..ffeed789596
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/relate.hpp
@@ -0,0 +1,177 @@
+// Boost.Geometry
+
+// Copyright (c) 2017, Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_RELATE_HPP
+#define BOOST_GEOMETRY_STRATEGIES_RELATE_HPP
+
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/topological_dimension.hpp>
+
+#include <boost/geometry/strategies/covered_by.hpp>
+#include <boost/geometry/strategies/intersection.hpp>
+#include <boost/geometry/strategies/within.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy
+{
+    
+namespace point_in_geometry
+{
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+template
+<
+    typename Point,
+    typename Geometry,
+    typename Tag1 = typename tag<Point>::type,
+    typename Tag2 = typename tag<Geometry>::type
+>
+struct default_strategy
+    : strategy::within::services::default_strategy
+        <
+            Point,
+            Geometry
+        >
+{
+    typedef typename default_strategy::type within_strategy_type;
+
+    typedef typename strategy::covered_by::services::default_strategy
+        <
+            Point,
+            Geometry
+        >::type covered_by_strategy_type;
+
+    static const bool same_strategies = boost::is_same<within_strategy_type, covered_by_strategy_type>::value;
+    BOOST_MPL_ASSERT_MSG((same_strategies),
+                         DEFAULT_WITHIN_AND_COVERED_BY_STRATEGIES_NOT_COMPATIBLE,
+                         (within_strategy_type, covered_by_strategy_type));
+};
+
+template<typename Point, typename Geometry>
+struct default_strategy<Point, Geometry, point_tag, point_tag>
+    : strategy::within::services::default_strategy<Point, Geometry>
+{};
+
+template<typename Point, typename Geometry>
+struct default_strategy<Point, Geometry, point_tag, multi_point_tag>
+    : strategy::within::services::default_strategy<Point, Geometry>
+{};
+
+
+} // namespace services
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+} // namespace point_in_geometry
+
+namespace relate
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <typename Geometry>
+struct default_intersection_strategy
+    : strategy::intersection::services::default_strategy
+        <
+            typename cs_tag<Geometry>::type
+        >
+{};
+
+template <typename PointLike, typename Geometry>
+struct default_point_in_geometry_strategy
+    : point_in_geometry::services::default_strategy
+        <
+            typename point_type<PointLike>::type,
+            Geometry
+        >
+{};
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    int TopDim1 = geometry::topological_dimension<Geometry1>::value,
+    int TopDim2 = geometry::topological_dimension<Geometry2>::value
+>
+struct default_strategy
+{
+    BOOST_MPL_ASSERT_MSG
+    (
+        false, NOT_IMPLEMENTED_FOR_THESE_TYPES
+        , (types<Geometry1, Geometry2>)
+    );
+};
+
+template <typename PointLike1, typename PointLike2>
+struct default_strategy<PointLike1, PointLike2, 0, 0>
+    : detail::default_point_in_geometry_strategy<PointLike1, PointLike2>
+{};
+
+template <typename PointLike, typename Geometry, int TopDim2>
+struct default_strategy<PointLike, Geometry, 0, TopDim2>
+    : detail::default_point_in_geometry_strategy<PointLike, Geometry>
+{};
+
+template <typename Geometry, typename PointLike, int TopDim1>
+struct default_strategy<Geometry, PointLike, TopDim1, 0>
+    : detail::default_point_in_geometry_strategy<PointLike, Geometry>
+{};
+
+template <typename Geometry1, typename Geometry2>
+struct default_strategy<Geometry1, Geometry2, 1, 1>
+    : detail::default_intersection_strategy<Geometry1>
+{};
+
+template <typename Geometry1, typename Geometry2>
+struct default_strategy<Geometry1, Geometry2, 1, 2>
+    : detail::default_intersection_strategy<Geometry1>
+{};
+
+template <typename Geometry1, typename Geometry2>
+struct default_strategy<Geometry1, Geometry2, 2, 1>
+    : detail::default_intersection_strategy<Geometry1>
+{};
+
+template <typename Geometry1, typename Geometry2>
+struct default_strategy<Geometry1, Geometry2, 2, 2>
+    : detail::default_intersection_strategy<Geometry1>
+{};
+
+} // namespace services
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+} // namespace relate
+
+} // namespace strategy
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_RELATE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/side.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/side.hpp
new file mode 100644
index 00000000000..9aaa2bdddc1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/side.hpp
@@ -0,0 +1,55 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_SIDE_HPP
+#define BOOST_GEOMETRY_STRATEGIES_SIDE_HPP
+
+
+#include <boost/geometry/strategies/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace side
+{
+
+namespace services
+{
+
+/*!
+\brief Traits class binding a side determination strategy to a coordinate system
+\ingroup util
+\tparam CSTag tag of coordinate system of point-type
+\tparam CalculationType \tparam_calculation
+*/
+template <typename CSTag, typename CalculationType = void>
+struct default_strategy
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_TYPE
+            , (types<CSTag>)
+        );
+};
+
+
+} // namespace services
+
+
+}} // namespace strategy::side
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_SIDE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/side_info.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/side_info.hpp
new file mode 100644
index 00000000000..d113eaa8ff0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/side_info.hpp
@@ -0,0 +1,177 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_SIDE_INFO_HPP
+#define BOOST_GEOMETRY_STRATEGIES_SIDE_INFO_HPP
+
+#include <cmath>
+#include <utility>
+
+#if defined(BOOST_GEOMETRY_DEBUG_INTERSECTION) || defined(BOOST_GEOMETRY_DEBUG_ROBUSTNESS)
+#  include <iostream>
+#endif
+
+namespace boost { namespace geometry
+{
+
+// Silence warning C4127: conditional expression is constant
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4127)
+#endif
+
+/*!
+\brief Class side_info: small class wrapping for sides (-1,0,1)
+*/
+class side_info
+{
+public :
+    inline side_info(int side_a1 = 0, int side_a2 = 0,
+            int side_b1 = 0, int side_b2 = 0)
+    {
+        sides[0].first = side_a1;
+        sides[0].second = side_a2;
+        sides[1].first = side_b1;
+        sides[1].second = side_b2;
+    }
+
+    template <int Which>
+    inline void set(int first, int second)
+    {
+        sides[Which].first = first;
+        sides[Which].second = second;
+    }
+
+    template <int Which, int Index>
+    inline void correct_to_zero()
+    {
+        if (Index == 0)
+        {
+            sides[Which].first = 0;
+        }
+        else
+        {
+            sides[Which].second = 0;
+        }
+    }
+
+    template <int Which, int Index>
+    inline int get() const
+    {
+        return Index == 0 ? sides[Which].first : sides[Which].second;
+    }
+
+
+    // Returns true if both lying on the same side WRT the other
+    // (so either 1,1 or -1-1)
+    template <int Which>
+    inline bool same() const
+    {
+        return sides[Which].first * sides[Which].second == 1;
+    }
+
+    inline bool collinear() const
+    {
+        return sides[0].first == 0
+            && sides[0].second == 0
+            && sides[1].first == 0
+            && sides[1].second == 0;
+    }
+
+    inline bool crossing() const
+    {
+        return sides[0].first * sides[0].second == -1
+            && sides[1].first * sides[1].second == -1;
+    }
+
+    inline bool touching() const
+    {
+        return (sides[0].first * sides[1].first == -1
+            && sides[0].second == 0 && sides[1].second == 0)
+            || (sides[1].first * sides[0].first == -1
+            && sides[1].second == 0 && sides[0].second == 0);
+    }
+
+    template <int Which>
+    inline bool one_touching() const
+    {
+        // This is normally a situation which can't occur:
+        // If one is completely left or right, the other cannot touch
+        return one_zero<Which>()
+            && sides[1 - Which].first * sides[1 - Which].second == 1;
+    }
+
+    inline bool meeting() const
+    {
+        // Two of them (in each segment) zero, two not
+        return one_zero<0>() && one_zero<1>();
+    }
+
+    template <int Which>
+    inline bool zero() const
+    {
+        return sides[Which].first == 0 && sides[Which].second == 0;
+    }
+
+    template <int Which>
+    inline bool one_zero() const
+    {
+        return (sides[Which].first == 0 && sides[Which].second != 0)
+            || (sides[Which].first != 0 && sides[Which].second == 0);
+    }
+
+    inline bool one_of_all_zero() const
+    {
+        int const sum = std::abs(sides[0].first)
+                + std::abs(sides[0].second)
+                + std::abs(sides[1].first)
+                + std::abs(sides[1].second);
+        return sum == 3;
+    }
+
+
+    template <int Which>
+    inline int zero_index() const
+    {
+        return sides[Which].first == 0 ? 0 : 1;
+    }
+
+#if defined(BOOST_GEOMETRY_DEBUG_INTERSECTION) || defined(BOOST_GEOMETRY_DEBUG_ROBUSTNESS)
+    inline void debug() const
+    {
+        std::cout << sides[0].first << " "
+            << sides[0].second << " "
+            << sides[1].first << " "
+            << sides[1].second
+            << std::endl;
+    }
+#endif
+
+    inline void reverse()
+    {
+        std::swap(sides[0], sides[1]);
+    }
+
+//private :
+    std::pair<int, int> sides[2];
+
+};
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_SIDE_INFO_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/area.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/area.hpp
new file mode 100644
index 00000000000..206b7345488
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/area.hpp
@@ -0,0 +1,182 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2016-2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fisikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_SPHERICAL_AREA_HPP
+#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_AREA_HPP
+
+
+#include <boost/geometry/formulas/area_formulas.hpp>
+#include <boost/geometry/core/radius.hpp>
+#include <boost/geometry/core/srs.hpp>
+#include <boost/geometry/strategies/area.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace area
+{
+
+/*!
+\brief Spherical area calculation
+\ingroup strategies
+\details Calculates area on the surface of a sphere using the trapezoidal rule
+\tparam PointOfSegment \tparam_segment_point
+\tparam CalculationType \tparam_calculation
+
+\qbk{
+[heading See also]
+[link geometry.reference.algorithms.area.area_2_with_strategy area (with strategy)]
+}
+*/
+template
+<
+    typename PointOfSegment,
+    typename CalculationType = void
+>
+class spherical
+{
+    // Enables special handling of long segments
+    static const bool LongSegment = false;
+
+typedef typename boost::mpl::if_c
+    <
+        boost::is_void<CalculationType>::type::value,
+        typename select_most_precise
+            <
+                typename coordinate_type<PointOfSegment>::type,
+                double
+            >::type,
+        CalculationType
+    >::type CT;
+
+protected :
+    struct excess_sum
+    {
+        CT m_sum;
+
+        // Keep track if encircles some pole
+        size_t m_crosses_prime_meridian;
+
+        inline excess_sum()
+            : m_sum(0)
+            , m_crosses_prime_meridian(0)
+        {}
+        template <typename SphereType>
+        inline CT area(SphereType sphere) const
+        {
+            CT result;
+            CT radius = geometry::get_radius<0>(sphere);
+
+            // Encircles pole
+            if(m_crosses_prime_meridian % 2 == 1)
+            {
+                size_t times_crosses_prime_meridian
+                        = 1 + (m_crosses_prime_meridian / 2);
+
+                result = CT(2)
+                         * geometry::math::pi<CT>()
+                         * times_crosses_prime_meridian
+                         - geometry::math::abs(m_sum);
+
+                if(geometry::math::sign<CT>(m_sum) == 1)
+                {
+                    result = - result;
+                }
+
+            } else {
+                result =  m_sum;
+            }
+
+            result *= radius * radius;
+
+            return result;
+        }
+    };
+
+public :
+    typedef CT return_type;
+    typedef PointOfSegment segment_point_type;
+    typedef excess_sum state_type;
+    typedef geometry::srs::sphere<CT> sphere_type;
+
+    // For backward compatibility reasons the radius is set to 1
+    inline spherical()
+        : m_sphere(1.0)
+    {}
+
+    template <typename T>
+    explicit inline spherical(geometry::srs::sphere<T> const& sphere)
+        : m_sphere(geometry::get_radius<0>(sphere))
+    {}
+
+    explicit inline spherical(CT const& radius)
+        : m_sphere(radius)
+    {}
+
+    inline void apply(PointOfSegment const& p1,
+                      PointOfSegment const& p2,
+                      excess_sum& state) const
+    {
+        if (! geometry::math::equals(get<0>(p1), get<0>(p2)))
+        {
+
+            state.m_sum += geometry::formula::area_formulas
+                             <CT>::template spherical<LongSegment>(p1, p2);
+
+            // Keep track whenever a segment crosses the prime meridian
+            geometry::formula::area_formulas
+                         <CT>::crosses_prime_meridian(p1, p2, state);
+
+        }
+    }
+
+    inline return_type result(excess_sum const& state) const
+    {
+        return state.area(m_sphere);
+    }
+
+private :
+    /// srs Sphere
+    sphere_type m_sphere;
+};
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+
+template <typename Point>
+struct default_strategy<spherical_equatorial_tag, Point>
+{
+    typedef strategy::area::spherical<Point> type;
+};
+
+// Note: spherical polar coordinate system requires "get_as_radian_equatorial"
+template <typename Point>
+struct default_strategy<spherical_polar_tag, Point>
+{
+    typedef strategy::area::spherical<Point> type;
+};
+
+} // namespace services
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::area
+
+
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_AREA_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/azimuth.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/azimuth.hpp
new file mode 100644
index 00000000000..7a711c9814e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/azimuth.hpp
@@ -0,0 +1,105 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2016-2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fisikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_SPHERICAL_AZIMUTH_HPP
+#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_AZIMUTH_HPP
+
+
+#include <boost/geometry/strategies/azimuth.hpp>
+#include <boost/geometry/formulas/spherical.hpp>
+
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_void.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace azimuth
+{
+
+template
+<
+    typename CalculationType = void
+>
+class spherical
+{
+public :
+
+    inline spherical()
+    {}
+
+    template <typename T>
+    static inline void apply(T const& lon1_rad, T const& lat1_rad,
+                             T const& lon2_rad, T const& lat2_rad,
+                             T& a1, T& a2)
+    {
+        typedef typename boost::mpl::if_
+            <
+                boost::is_void<CalculationType>, T, CalculationType
+            >::type calc_t;
+
+        geometry::formula::result_spherical<calc_t>
+            result = geometry::formula::spherical_azimuth<calc_t, true>(
+                        calc_t(lon1_rad), calc_t(lat1_rad),
+                        calc_t(lon2_rad), calc_t(lat2_rad));
+
+        a1 = result.azimuth;
+        a2 = result.reverse_azimuth;
+    }
+
+    template <typename T>
+    inline void apply(T const& lon1_rad, T const& lat1_rad,
+                      T const& lon2_rad, T const& lat2_rad,
+                      T& a1) const
+    {
+         typedef typename boost::mpl::if_
+            <
+                boost::is_void<CalculationType>, T, CalculationType
+            >::type calc_t;
+
+        geometry::formula::result_spherical<calc_t>
+            result = geometry::formula::spherical_azimuth<calc_t, false>(
+                        calc_t(lon1_rad), calc_t(lat1_rad),
+                        calc_t(lon2_rad), calc_t(lat2_rad));
+
+        a1 = result.azimuth;
+    }
+
+};
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+template <typename CalculationType>
+struct default_strategy<spherical_equatorial_tag, CalculationType>
+{
+    typedef strategy::azimuth::spherical<CalculationType> type;
+};
+
+/*
+template <typename CalculationType>
+struct default_strategy<spherical_polar_tag, CalculationType>
+{
+    typedef strategy::azimuth::spherical<CalculationType> type;
+};
+*/
+}
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+}} // namespace strategy::azimuth
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_AZIMUTH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/compare_circular.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/compare_circular.hpp
new file mode 100644
index 00000000000..2f890dfd877
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/compare_circular.hpp
@@ -0,0 +1,152 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_SPHERICAL_COMPARE_SPHERICAL_HPP
+#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_COMPARE_SPHERICAL_HPP
+
+#include <boost/math/constants/constants.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/strategies/compare.hpp>
+#include <boost/geometry/util/math.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace compare
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <typename Units>
+struct shift
+{
+};
+
+template <>
+struct shift<degree>
+{
+    static inline double full() { return 360.0; }
+    static inline double half() { return 180.0; }
+};
+
+template <>
+struct shift<radian>
+{
+    static inline double full() { return 2.0 * boost::math::constants::pi<double>(); }
+    static inline double half() { return boost::math::constants::pi<double>(); }
+};
+
+} // namespace detail
+#endif
+
+/*!
+\brief Compare (in one direction) strategy for spherical coordinates
+\ingroup strategies
+\tparam Point point-type
+\tparam Dimension dimension
+*/
+template <typename CoordinateType, typename Units, typename Compare>
+struct circular_comparator
+{
+    static inline CoordinateType put_in_range(CoordinateType const& c,
+            double min_border, double max_border)
+    {
+        CoordinateType value = c;
+        while (value < min_border)
+        {
+            value += detail::shift<Units>::full();
+        }
+        while (value > max_border)
+        {
+            value -= detail::shift<Units>::full();
+        }
+        return value;
+    }
+
+    inline bool operator()(CoordinateType const& c1, CoordinateType const& c2)  const
+    {
+        Compare compare;
+
+        // Check situation that one of them is e.g. std::numeric_limits.
+        static const double full = detail::shift<Units>::full();
+        double mx = 10.0 * full;
+        if (c1 < -mx || c1 > mx || c2 < -mx || c2 > mx)
+        {
+            // do normal comparison, using circular is not useful
+            return compare(c1, c2);
+        }
+
+        static const double half = full / 2.0;
+        CoordinateType v1 = put_in_range(c1, -half, half);
+        CoordinateType v2 = put_in_range(c2, -half, half);
+
+        // Two coordinates on a circle are
+        // at max <= half a circle away from each other.
+        // So if it is more, shift origin.
+        CoordinateType diff = geometry::math::abs(v1 - v2);
+        if (diff > half)
+        {
+            v1 = put_in_range(v1, 0, full);
+            v2 = put_in_range(v2, 0, full);
+        }
+
+        return compare(v1, v2);
+    }
+};
+
+}} // namespace strategy::compare
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+// Specialize for the longitude (dim 0)
+template
+<
+    typename Point,
+    template<typename> class CoordinateSystem,
+    typename Units
+>
+struct strategy_compare<spherical_polar_tag, 1, Point, CoordinateSystem<Units>, 0>
+{
+    typedef typename coordinate_type<Point>::type coordinate_type;
+    typedef strategy::compare::circular_comparator
+        <
+            coordinate_type,
+            Units,
+            std::less<coordinate_type>
+        > type;
+};
+
+template
+<
+    typename Point,
+    template<typename> class CoordinateSystem,
+    typename Units
+>
+struct strategy_compare<spherical_polar_tag, -1, Point, CoordinateSystem<Units>, 0>
+{
+    typedef typename coordinate_type<Point>::type coordinate_type;
+    typedef strategy::compare::circular_comparator
+        <
+            coordinate_type,
+            Units,
+            std::greater<coordinate_type>
+        > type;
+};
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_COMPARE_SPHERICAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/disjoint_segment_box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/disjoint_segment_box.hpp
new file mode 100644
index 00000000000..bda62a77fc2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/disjoint_segment_box.hpp
@@ -0,0 +1,105 @@
+// Boost.Geometry
+
+// Copyright (c) 2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DISJOINT_SEGMENT_BOX_HPP
+#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DISJOINT_SEGMENT_BOX_HPP
+
+
+#include <cstddef>
+#include <utility>
+
+#include <boost/numeric/conversion/cast.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/calculation_type.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/point_type.hpp>
+
+#include <boost/geometry/algorithms/detail/assign_indexed_point.hpp>
+#include <boost/geometry/algorithms/detail/disjoint/segment_box.hpp>
+
+#include <boost/geometry/strategies/spherical/azimuth.hpp>
+#include <boost/geometry/strategies/disjoint.hpp>
+
+namespace boost { namespace geometry { namespace strategy { namespace disjoint
+{
+
+// NOTE: This may be temporary place for this or corresponding strategy
+// It seems to be more appropriate to implement the opposite of it
+// e.g. intersection::segment_box because in disjoint() algorithm
+// other strategies that are used are intersection and covered_by strategies.
+struct segment_box_spherical
+{
+    template <typename Segment, typename Box>
+    struct point_in_geometry_strategy
+        : services::default_strategy
+            <
+                typename point_type<Segment>::type,
+                Box
+            >
+    {};
+
+    template <typename Segment, typename Box>
+    static inline typename point_in_geometry_strategy<Segment, Box>::type
+        get_point_in_geometry_strategy()
+    {
+        typedef typename point_in_geometry_strategy<Segment, Box>::type strategy_type;
+
+        return strategy_type();
+    }
+
+    template <typename Segment, typename Box>
+    static inline bool apply(Segment const& segment, Box const& box)
+    {
+        typedef typename point_type<Segment>::type segment_point_type;
+        typedef typename coordinate_type<segment_point_type>::type CT;
+        geometry::strategy::azimuth::spherical<CT> azimuth_strategy;
+
+        return geometry::detail::disjoint::disjoint_segment_box_sphere_or_spheroid
+                <spherical_equatorial_tag>::apply(segment, box, azimuth_strategy);
+    }
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+namespace services
+{
+
+template <typename Linear, typename Box, typename LinearTag>
+struct default_strategy<Linear, Box, LinearTag, box_tag, 1, 2,
+                        spherical_equatorial_tag, spherical_equatorial_tag>
+{
+    typedef segment_box_spherical type;
+};
+
+template <typename Box, typename Linear, typename LinearTag>
+struct default_strategy<Box, Linear, box_tag, LinearTag, 2, 1,
+                        spherical_equatorial_tag, spherical_equatorial_tag>
+{
+    typedef segment_box_spherical type;
+};
+
+} // namespace services
+
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}}}} // namespace boost::geometry::strategy::disjoint
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DISJOINT_SEGMENT_BOX_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/distance_cross_track.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/distance_cross_track.hpp
new file mode 100644
index 00000000000..7daafa4a16f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/distance_cross_track.hpp
@@ -0,0 +1,773 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DISTANCE_CROSS_TRACK_HPP
+#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DISTANCE_CROSS_TRACK_HPP
+
+#include <algorithm>
+
+#include <boost/config.hpp>
+#include <boost/concept_check.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_void.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/radian_access.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/detail/course.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/concepts/distance_concept.hpp>
+#include <boost/geometry/strategies/spherical/distance_haversine.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/promote_floating_point.hpp>
+#include <boost/geometry/util/select_calculation_type.hpp>
+
+#ifdef BOOST_GEOMETRY_DEBUG_CROSS_TRACK
+#  include <boost/geometry/io/dsv/write.hpp>
+#endif
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace distance
+{
+
+
+namespace comparable
+{
+
+/*
+  Given a spherical segment AB and a point D, we are interested in
+  computing the distance of D from AB. This is usually known as the
+  cross track distance.
+
+  If the projection (along great circles) of the point D lies inside
+  the segment AB, then the distance (cross track error) XTD is given
+  by the formula (see http://williams.best.vwh.net/avform.htm#XTE):
+
+  XTD = asin( sin(dist_AD) * sin(crs_AD-crs_AB) )
+
+  where dist_AD is the great circle distance between the points A and
+  B, and crs_AD, crs_AB is the course (bearing) between the points A,
+  D and A, B, respectively.
+
+  If the point D does not project inside the arc AB, then the distance
+  of D from AB is the minimum of the two distances dist_AD and dist_BD.
+
+  Our reference implementation for this procedure is listed below
+  (this was the old Boost.Geometry implementation of the cross track distance),
+  where:
+  * The member variable m_strategy is the underlying haversine strategy.
+  * p stands for the point D.
+  * sp1 stands for the segment endpoint A.
+  * sp2 stands for the segment endpoint B.
+
+  ================= reference implementation -- start =================
+
+  return_type d1 = m_strategy.apply(sp1, p);
+  return_type d3 = m_strategy.apply(sp1, sp2);
+
+  if (geometry::math::equals(d3, 0.0))
+  {
+      // "Degenerate" segment, return either d1 or d2
+      return d1;
+  }
+
+  return_type d2 = m_strategy.apply(sp2, p);
+
+  return_type crs_AD = geometry::detail::course<return_type>(sp1, p);
+  return_type crs_AB = geometry::detail::course<return_type>(sp1, sp2);
+  return_type crs_BA = crs_AB - geometry::math::pi<return_type>();
+  return_type crs_BD = geometry::detail::course<return_type>(sp2, p);
+  return_type d_crs1 = crs_AD - crs_AB;
+  return_type d_crs2 = crs_BD - crs_BA;
+
+  // d1, d2, d3 are in principle not needed, only the sign matters
+  return_type projection1 = cos( d_crs1 ) * d1 / d3;
+  return_type projection2 = cos( d_crs2 ) * d2 / d3;
+
+  if (projection1 > 0.0 && projection2 > 0.0)
+  {
+      return_type XTD
+          = radius() * math::abs( asin( sin( d1 / radius() ) * sin( d_crs1 ) ));
+
+      // Return shortest distance, projected point on segment sp1-sp2
+      return return_type(XTD);
+  }
+  else
+  {
+      // Return shortest distance, project either on point sp1 or sp2
+      return return_type( (std::min)( d1 , d2 ) );
+  }
+
+  ================= reference implementation -- end =================
+
+
+  Motivation
+  ----------
+  In what follows we develop a comparable version of the cross track
+  distance strategy, that meets the following goals:
+  * It is more efficient than the original cross track strategy (less
+    operations and less calls to mathematical functions).
+  * Distances using the comparable cross track strategy can not only
+    be compared with other distances using the same strategy, but also with
+    distances computed with the comparable version of the haversine strategy.
+  * It can serve as the basis for the computation of the cross track distance,
+    as it is more efficient to compute its comparable version and
+    transform that to the actual cross track distance, rather than
+    follow/use the reference implementation listed above.
+
+  Major idea
+  ----------
+  The idea here is to use the comparable haversine strategy to compute
+  the distances d1, d2 and d3 in the above listing. Once we have done
+  that we need also to make sure that instead of returning XTD (as
+  computed above) that we return a distance CXTD that is compatible
+  with the comparable haversine distance. To achieve this CXTD must satisfy
+  the relation:
+      XTD = 2 * R * asin( sqrt(XTD) )
+  where R is the sphere's radius.
+
+  Below we perform the mathematical analysis that show how to compute CXTD.
+
+
+  Mathematical analysis
+  ---------------------
+  Below we use the following trigonometric identities:
+      sin(2 * x) = 2 * sin(x) * cos(x)
+      cos(asin(x)) = sqrt(1 - x^2)
+
+  Observation:
+  The distance d1 needed when the projection of the point D is within the
+  segment must be the true distance. However, comparable::haversine<>
+  returns a comparable distance instead of the one needed.
+  To remedy this, we implicitly compute what is needed. 
+  More precisely, we need to compute sin(true_d1):
+
+  sin(true_d1) = sin(2 * asin(sqrt(d1)))
+               = 2 * sin(asin(sqrt(d1)) * cos(asin(sqrt(d1)))
+               = 2 * sqrt(d1) * sqrt(1-(sqrt(d1))^2)
+               = 2 * sqrt(d1 - d1 * d1)
+  This relation is used below.
+
+  As we mentioned above the goal is to find CXTD (named "a" below for
+  brevity) such that ("b" below stands for "d1", and "c" for "d_crs1"):
+
+      2 * R * asin(sqrt(a)) == R * asin(2 * sqrt(b-b^2) * sin(c))
+
+  Analysis:
+      2 * R * asin(sqrt(a)) == R * asin(2 * sqrt(b-b^2) * sin(c))
+  <=> 2 * asin(sqrt(a)) == asin(sqrt(b-b^2) * sin(c))
+  <=> sin(2 * asin(sqrt(a))) == 2 * sqrt(b-b^2) * sin(c)
+  <=> 2 * sin(asin(sqrt(a))) * cos(asin(sqrt(a))) == 2 * sqrt(b-b^2) * sin(c)
+  <=> 2 * sqrt(a) * sqrt(1-a) == 2 * sqrt(b-b^2) * sin(c)
+  <=> sqrt(a) * sqrt(1-a) == sqrt(b-b^2) * sin(c)
+  <=> sqrt(a-a^2) == sqrt(b-b^2) * sin(c)
+  <=> a-a^2 == (b-b^2) * (sin(c))^2
+
+  Consider the quadratic equation: x^2-x+p^2 == 0,
+  where p = sqrt(b-b^2) * sin(c); its discriminant is:
+      d = 1 - 4 * p^2 = 1 - 4 * (b-b^2) * (sin(c))^2
+
+  The two solutions are:
+      a_1 = (1 - sqrt(d)) / 2
+      a_2 = (1 + sqrt(d)) / 2
+
+  Which one to choose?
+  "a" refers to the distance (on the unit sphere) of D from the
+  supporting great circle Circ(A,B) of the segment AB.
+  The two different values for "a" correspond to the lengths of the two
+  arcs delimited D and the points of intersection of Circ(A,B) and the
+  great circle perperdicular to Circ(A,B) passing through D.
+  Clearly, the value we want is the smallest among these two distances,
+  hence the root we must choose is the smallest root among the two.
+
+  So the answer is:
+      CXTD = ( 1 - sqrt(1 - 4 * (b-b^2) * (sin(c))^2) ) / 2
+
+  Therefore, in order to implement the comparable version of the cross
+  track strategy we need to:
+  (1) Use the comparable version of the haversine strategy instead of
+      the non-comparable one.
+  (2) Instead of return XTD when D projects inside the segment AB, we
+      need to return CXTD, given by the following formula:
+          CXTD = ( 1 - sqrt(1 - 4 * (d1-d1^2) * (sin(d_crs1))^2) ) / 2;
+
+
+  Complexity Analysis
+  -------------------
+  In the analysis that follows we refer to the actual implementation below.
+  In particular, instead of computing CXTD as above, we use the more
+  efficient (operation-wise) computation of CXTD shown here:
+
+      return_type sin_d_crs1 = sin(d_crs1);
+      return_type d1_x_sin = d1 * sin_d_crs1;
+      return_type d = d1_x_sin * (sin_d_crs1 - d1_x_sin);
+      return d / (0.5 + math::sqrt(0.25 - d));
+
+  Notice that instead of computing:
+      0.5 - 0.5 * sqrt(1 - 4 * d) = 0.5 - sqrt(0.25 - d)
+  we use the following formula instead:
+      d / (0.5 + sqrt(0.25 - d)).
+  This is done for numerical robustness. The expression 0.5 - sqrt(0.25 - x)
+  has large numerical errors for values of x close to 0 (if using doubles
+  the error start to become large even when d is as large as 0.001).
+  To remedy that, we re-write 0.5 - sqrt(0.25 - x) as:
+      0.5 - sqrt(0.25 - d)
+      = (0.5 - sqrt(0.25 - d) * (0.5 - sqrt(0.25 - d)) / (0.5 + sqrt(0.25 - d)).
+  The numerator is the difference of two squares:
+      (0.5 - sqrt(0.25 - d) * (0.5 - sqrt(0.25 - d))
+      = 0.5^2 - (sqrt(0.25 - d))^ = 0.25 - (0.25 - d) = d,
+  which gives the expression we use.
+
+  For the complexity analysis, we distinguish between two cases:
+  (A) The distance is realized between the point D and an
+      endpoint of the segment AB
+
+      Gains:
+      Since we are using comparable::haversine<> which is called
+      3 times, we gain:
+      -> 3 calls to sqrt
+      -> 3 calls to asin
+      -> 6 multiplications
+
+      Loses: None
+
+      So the net gain is:
+      -> 6 function calls (sqrt/asin)
+      -> 6 arithmetic operations
+
+      If we use comparable::cross_track<> to compute
+      cross_track<> we need to account for a call to sqrt, a call
+      to asin and 2 multiplications. In this case the net gain is:
+      -> 4 function calls (sqrt/asin)
+      -> 4 arithmetic operations
+
+
+  (B) The distance is realized between the point D and an
+      interior point of the segment AB
+
+      Gains:
+      Since we are using comparable::haversine<> which is called
+      3 times, we gain:
+      -> 3 calls to sqrt
+      -> 3 calls to asin
+      -> 6 multiplications
+      Also we gain the operations used to compute XTD:
+      -> 2 calls to sin
+      -> 1 call to asin
+      -> 1 call to abs
+      -> 2 multiplications
+      -> 1 division
+      So the total gains are:
+      -> 9 calls to sqrt/sin/asin
+      -> 1 call to abs
+      -> 8 multiplications
+      -> 1 division
+
+      Loses:
+      To compute a distance compatible with comparable::haversine<>
+      we need to perform a few more operations, namely:
+      -> 1 call to sin
+      -> 1 call to sqrt
+      -> 2 multiplications
+      -> 1 division
+      -> 1 addition
+      -> 2 subtractions
+
+      So roughly speaking the net gain is:
+      -> 8 fewer function calls and 3 fewer arithmetic operations
+
+      If we were to implement cross_track directly from the
+      comparable version (much like what haversine<> does using
+      comparable::haversine<>) we need additionally
+      -> 2 function calls (asin/sqrt)
+      -> 2 multiplications
+
+      So it pays off to re-implement cross_track<> to use
+      comparable::cross_track<>; in this case the net gain would be:
+      -> 6 function calls
+      -> 1 arithmetic operation
+
+   Summary/Conclusion
+   ------------------
+   Following the mathematical and complexity analysis above, the
+   comparable cross track strategy (as implemented below) satisfies
+   all the goal mentioned in the beginning:
+   * It is more efficient than its non-comparable counter-part.
+   * Comparable distances using this new strategy can also be compared
+     with comparable distances computed with the comparable haversine
+     strategy.
+   * It turns out to be more efficient to compute the actual cross
+     track distance XTD by first computing CXTD, and then computing
+     XTD by means of the formula:
+                XTD = 2 * R * asin( sqrt(CXTD) )
+*/
+
+template
+<
+    typename CalculationType = void,
+    typename Strategy = comparable::haversine<double, CalculationType>
+>
+class cross_track
+{
+public :
+    template <typename Point, typename PointOfSegment>
+    struct return_type
+        : promote_floating_point
+          <
+              typename select_calculation_type
+                  <
+                      Point,
+                      PointOfSegment,
+                      CalculationType
+                  >::type
+          >
+    {};
+
+    typedef typename Strategy::radius_type radius_type;
+
+    inline cross_track()
+    {}
+
+    explicit inline cross_track(typename Strategy::radius_type const& r)
+        : m_strategy(r)
+    {}
+
+    inline cross_track(Strategy const& s)
+        : m_strategy(s)
+    {}
+
+
+    // It might be useful in the future
+    // to overload constructor with strategy info.
+    // crosstrack(...) {}
+
+
+    template <typename Point, typename PointOfSegment>
+    inline typename return_type<Point, PointOfSegment>::type
+    apply(Point const& p, PointOfSegment const& sp1, PointOfSegment const& sp2) const
+    {
+
+#if !defined(BOOST_MSVC)
+        BOOST_CONCEPT_ASSERT
+            (
+                (concepts::PointDistanceStrategy<Strategy, Point, PointOfSegment>)
+            );
+#endif
+
+        typedef typename return_type<Point, PointOfSegment>::type return_type;
+
+#ifdef BOOST_GEOMETRY_DEBUG_CROSS_TRACK
+        std::cout << "Course " << dsv(sp1) << " to " << dsv(p) << " "
+                  << crs_AD * geometry::math::r2d<return_type>() << std::endl;
+        std::cout << "Course " << dsv(sp1) << " to " << dsv(sp2) << " "
+                  << crs_AB * geometry::math::r2d<return_type>() << std::endl;
+        std::cout << "Course " << dsv(sp2) << " to " << dsv(p) << " "
+                  << crs_BD * geometry::math::r2d << std::endl;
+        std::cout << "Projection AD-AB " << projection1 << " : "
+                  << d_crs1 * geometry::math::r2d<return_type>() << std::endl;
+        std::cout << "Projection BD-BA " << projection2 << " : "
+                  << d_crs2 * geometry::math::r2d<return_type>() << std::endl;
+#endif
+
+        // http://williams.best.vwh.net/avform.htm#XTE
+        return_type d1 = m_strategy.apply(sp1, p);
+        return_type d3 = m_strategy.apply(sp1, sp2);
+
+        if (geometry::math::equals(d3, 0.0))
+        {
+            // "Degenerate" segment, return either d1 or d2
+            return d1;
+        }
+
+        return_type d2 = m_strategy.apply(sp2, p);
+
+        return_type crs_AD = geometry::detail::course<return_type>(sp1, p);
+        return_type crs_AB = geometry::detail::course<return_type>(sp1, sp2);
+        return_type crs_BA = crs_AB - geometry::math::pi<return_type>();
+        return_type crs_BD = geometry::detail::course<return_type>(sp2, p);
+        return_type d_crs1 = crs_AD - crs_AB;
+        return_type d_crs2 = crs_BD - crs_BA;
+
+        // d1, d2, d3 are in principle not needed, only the sign matters
+        return_type projection1 = cos( d_crs1 ) * d1 / d3;
+        return_type projection2 = cos( d_crs2 ) * d2 / d3;
+
+        if (projection1 > 0.0 && projection2 > 0.0)
+        {
+#ifdef BOOST_GEOMETRY_DEBUG_CROSS_TRACK
+            return_type XTD = radius() * geometry::math::abs( asin( sin( d1 ) * sin( d_crs1 ) ));
+
+            std::cout << "Projection ON the segment" << std::endl;
+            std::cout << "XTD: " << XTD
+                      << " d1: " << (d1 * radius())
+                      << " d2: " << (d2 * radius())
+                      << std::endl;
+#endif
+            return_type const half(0.5);
+            return_type const quarter(0.25);
+
+            return_type sin_d_crs1 = sin(d_crs1);
+            /*
+              This is the straightforward obvious way to continue:
+              
+              return_type discriminant
+                  = 1.0 - 4.0 * (d1 - d1 * d1) * sin_d_crs1 * sin_d_crs1;
+              return 0.5 - 0.5 * math::sqrt(discriminant);
+            
+              Below we optimize the number of arithmetic operations
+              and account for numerical robustness:
+            */
+            return_type d1_x_sin = d1 * sin_d_crs1;
+            return_type d = d1_x_sin * (sin_d_crs1 - d1_x_sin);
+            return d / (half + math::sqrt(quarter - d));
+        }
+        else
+        {
+#ifdef BOOST_GEOMETRY_DEBUG_CROSS_TRACK
+            std::cout << "Projection OUTSIDE the segment" << std::endl;
+#endif
+
+            // Return shortest distance, project either on point sp1 or sp2
+            return return_type( (std::min)( d1 , d2 ) );
+        }
+    }
+
+    inline typename Strategy::radius_type radius() const
+    { return m_strategy.radius(); }
+
+private :
+    Strategy m_strategy;
+};
+
+} // namespace comparable
+
+
+/*!
+\brief Strategy functor for distance point to segment calculation
+\ingroup strategies
+\details Class which calculates the distance of a point to a segment, for points on a sphere or globe
+\see http://williams.best.vwh.net/avform.htm
+\tparam CalculationType \tparam_calculation
+\tparam Strategy underlying point-point distance strategy, defaults to haversine
+
+\qbk{
+[heading See also]
+[link geometry.reference.algorithms.distance.distance_3_with_strategy distance (with strategy)]
+}
+
+*/
+template
+<
+    typename CalculationType = void,
+    typename Strategy = haversine<double, CalculationType>
+>
+class cross_track
+{
+public :
+    template <typename Point, typename PointOfSegment>
+    struct return_type
+        : promote_floating_point
+          <
+              typename select_calculation_type
+                  <
+                      Point,
+                      PointOfSegment,
+                      CalculationType
+                  >::type
+          >
+    {};
+
+    typedef typename Strategy::radius_type radius_type;
+
+    inline cross_track()
+    {}
+
+    explicit inline cross_track(typename Strategy::radius_type const& r)
+        : m_strategy(r)
+    {}
+
+    inline cross_track(Strategy const& s)
+        : m_strategy(s)
+    {}
+
+
+    // It might be useful in the future
+    // to overload constructor with strategy info.
+    // crosstrack(...) {}
+
+
+    template <typename Point, typename PointOfSegment>
+    inline typename return_type<Point, PointOfSegment>::type
+    apply(Point const& p, PointOfSegment const& sp1, PointOfSegment const& sp2) const
+    {
+
+#if !defined(BOOST_MSVC)
+        BOOST_CONCEPT_ASSERT
+            (
+                (concepts::PointDistanceStrategy<Strategy, Point, PointOfSegment>)
+            );
+#endif
+        typedef typename return_type<Point, PointOfSegment>::type return_type;
+        typedef cross_track<CalculationType, Strategy> this_type;
+
+        typedef typename services::comparable_type
+            <
+                this_type
+            >::type comparable_type;
+
+        comparable_type cstrategy
+            = services::get_comparable<this_type>::apply(m_strategy);
+
+        return_type const a = cstrategy.apply(p, sp1, sp2);
+        return_type const c = return_type(2.0) * asin(math::sqrt(a));
+        return c * radius();
+    }
+
+    inline typename Strategy::radius_type radius() const
+    { return m_strategy.radius(); }
+
+private :
+
+    Strategy m_strategy;
+};
+
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+template <typename CalculationType, typename Strategy>
+struct tag<cross_track<CalculationType, Strategy> >
+{
+    typedef strategy_tag_distance_point_segment type;
+};
+
+
+template <typename CalculationType, typename Strategy, typename P, typename PS>
+struct return_type<cross_track<CalculationType, Strategy>, P, PS>
+    : cross_track<CalculationType, Strategy>::template return_type<P, PS>
+{};
+
+
+template <typename CalculationType, typename Strategy>
+struct comparable_type<cross_track<CalculationType, Strategy> >
+{
+    typedef comparable::cross_track
+        <
+            CalculationType, typename comparable_type<Strategy>::type
+        >  type;
+};
+
+
+template
+<
+    typename CalculationType,
+    typename Strategy
+>
+struct get_comparable<cross_track<CalculationType, Strategy> >
+{
+    typedef typename comparable_type
+        <
+            cross_track<CalculationType, Strategy>
+        >::type comparable_type;
+public :
+    static inline comparable_type
+    apply(cross_track<CalculationType, Strategy> const& strategy)
+    {
+        return comparable_type(strategy.radius());
+    }
+};
+
+
+template
+<
+    typename CalculationType,
+    typename Strategy,
+    typename P,
+    typename PS
+>
+struct result_from_distance<cross_track<CalculationType, Strategy>, P, PS>
+{
+private :
+    typedef typename cross_track
+        <
+            CalculationType, Strategy
+        >::template return_type<P, PS>::type return_type;
+public :
+    template <typename T>
+    static inline return_type
+    apply(cross_track<CalculationType, Strategy> const& , T const& distance)
+    {
+        return distance;
+    }
+};
+
+
+// Specializations for comparable::cross_track
+template <typename RadiusType, typename CalculationType>
+struct tag<comparable::cross_track<RadiusType, CalculationType> >
+{
+    typedef strategy_tag_distance_point_segment type;
+};
+
+
+template
+<
+    typename RadiusType,
+    typename CalculationType,
+    typename P,
+    typename PS
+>
+struct return_type<comparable::cross_track<RadiusType, CalculationType>, P, PS>
+    : comparable::cross_track
+        <
+            RadiusType, CalculationType
+        >::template return_type<P, PS>
+{};
+
+
+template <typename RadiusType, typename CalculationType>
+struct comparable_type<comparable::cross_track<RadiusType, CalculationType> >
+{
+    typedef comparable::cross_track<RadiusType, CalculationType> type;
+};
+
+
+template <typename RadiusType, typename CalculationType>
+struct get_comparable<comparable::cross_track<RadiusType, CalculationType> >
+{
+private :
+    typedef comparable::cross_track<RadiusType, CalculationType> this_type;
+public :
+    static inline this_type apply(this_type const& input)
+    {
+        return input;
+    }
+};
+
+
+template
+<
+    typename RadiusType,
+    typename CalculationType,
+    typename P,
+    typename PS
+>
+struct result_from_distance
+    <
+        comparable::cross_track<RadiusType, CalculationType>, P, PS
+    >
+{
+private :
+    typedef comparable::cross_track<RadiusType, CalculationType> strategy_type;
+    typedef typename return_type<strategy_type, P, PS>::type return_type;
+public :
+    template <typename T>
+    static inline return_type apply(strategy_type const& strategy,
+                                    T const& distance)
+    {
+        return_type const s
+            = sin( (distance / strategy.radius()) / return_type(2.0) );
+        return s * s;
+    }
+};
+
+
+
+/*
+
+TODO:  spherical polar coordinate system requires "get_as_radian_equatorial<>"
+
+template <typename Point, typename PointOfSegment, typename Strategy>
+struct default_strategy
+    <
+        segment_tag, Point, PointOfSegment,
+        spherical_polar_tag, spherical_polar_tag,
+        Strategy
+    >
+{
+    typedef cross_track
+        <
+            void,
+            typename boost::mpl::if_
+                <
+                    boost::is_void<Strategy>,
+                    typename default_strategy
+                        <
+                            point_tag, Point, PointOfSegment,
+                            spherical_polar_tag, spherical_polar_tag
+                        >::type,
+                    Strategy
+                >::type
+        > type;
+};
+*/
+
+template <typename Point, typename PointOfSegment, typename Strategy>
+struct default_strategy
+    <
+        point_tag, segment_tag, Point, PointOfSegment,
+        spherical_equatorial_tag, spherical_equatorial_tag,
+        Strategy
+    >
+{
+    typedef cross_track
+        <
+            void,
+            typename boost::mpl::if_
+                <
+                    boost::is_void<Strategy>,
+                    typename default_strategy
+                        <
+                            point_tag, point_tag, Point, PointOfSegment,
+                            spherical_equatorial_tag, spherical_equatorial_tag
+                        >::type,
+                    Strategy
+                >::type
+        > type;
+};
+
+
+template <typename PointOfSegment, typename Point, typename Strategy>
+struct default_strategy
+    <
+        segment_tag, point_tag, PointOfSegment, Point,
+        spherical_equatorial_tag, spherical_equatorial_tag,
+        Strategy
+    >
+{
+    typedef typename default_strategy
+        <
+            point_tag, segment_tag, Point, PointOfSegment,
+            spherical_equatorial_tag, spherical_equatorial_tag,
+            Strategy
+        >::type type;
+};
+
+
+} // namespace services
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+}} // namespace strategy::distance
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DISTANCE_CROSS_TRACK_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/distance_cross_track_point_box.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/distance_cross_track_point_box.hpp
new file mode 100644
index 00000000000..ee805c36d12
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/distance_cross_track_point_box.hpp
@@ -0,0 +1,364 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014, 2015.
+// Modifications copyright (c) 2014-2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DISTANCE_CROSS_TRACK_POINT_BOX_HPP
+#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DISTANCE_CROSS_TRACK_POINT_BOX_HPP
+
+#include <boost/config.hpp>
+#include <boost/concept_check.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_void.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/radian_access.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/concepts/distance_concept.hpp>
+#include <boost/geometry/strategies/spherical/distance_cross_track.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/algorithms/detail/assign_box_corners.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace distance
+{
+
+
+/*!
+\brief Strategy functor for distance point to box calculation
+\ingroup strategies
+\details Class which calculates the distance of a point to a box, for
+points and boxes on a sphere or globe
+\tparam CalculationType \tparam_calculation
+\tparam Strategy underlying point-segment distance strategy, defaults
+to cross track
+
+\qbk{
+[heading See also]
+[link geometry.reference.algorithms.distance.distance_3_with_strategy distance (with strategy)]
+}
+
+*/
+template
+<
+    typename CalculationType = void,
+    typename Strategy = cross_track<CalculationType>
+>
+class cross_track_point_box
+{
+public:
+    template <typename Point, typename Box>
+    struct return_type
+        : services::return_type<Strategy, Point, typename point_type<Box>::type>
+    {};
+
+    typedef typename Strategy::radius_type radius_type;
+
+    inline cross_track_point_box()
+    {}
+
+    explicit inline cross_track_point_box(typename Strategy::radius_type const& r)
+        : m_ps_strategy(r)
+    {}
+
+    inline cross_track_point_box(Strategy const& s)
+        : m_ps_strategy(s)
+    {}
+
+
+    // It might be useful in the future
+    // to overload constructor with strategy info.
+    // crosstrack(...) {}
+
+    template <typename Point, typename Box>
+    inline typename return_type<Point, Box>::type
+    apply(Point const& point, Box const& box) const
+    {
+#if !defined(BOOST_MSVC)
+        BOOST_CONCEPT_ASSERT
+            (
+                (concepts::PointSegmentDistanceStrategy
+                    <
+                        Strategy, Point, typename point_type<Box>::type
+                    >)
+            );
+#endif
+
+        // this method assumes that the coordinates of the point and
+        // the box are normalized
+
+        typedef typename return_type<Point, Box>::type return_type;
+        typedef typename point_type<Box>::type box_point_type;
+
+        // TODO: This strategy as well as other cross-track strategies
+        // and therefore e.g. spherical within(Point, Box) may not work
+        // properly for a Box degenerated to a Segment or Point
+
+        box_point_type bottom_left, bottom_right, top_left, top_right;
+        geometry::detail::assign_box_corners(box,
+                                             bottom_left, bottom_right,
+                                             top_left, top_right);
+
+        return_type const plon = geometry::get_as_radian<0>(point);
+        return_type const plat = geometry::get_as_radian<1>(point);
+
+        return_type const lon_min = geometry::get_as_radian<0>(bottom_left);
+        return_type const lat_min = geometry::get_as_radian<1>(bottom_left);
+        return_type const lon_max = geometry::get_as_radian<0>(top_right);
+        return_type const lat_max = geometry::get_as_radian<1>(top_right);
+
+        return_type const pi = math::pi<return_type>();
+        return_type const two_pi = math::two_pi<return_type>();
+
+        // First check if the point is within the band defined by the
+        // minimum and maximum longitude of the box; if yes, determine
+        // if the point is above, below or inside the box and compute
+        // the distance (easy in this case)
+        //
+        // Notice that the point may not be inside the longitude range
+        // of the box, but the shifted point may be inside the
+        // longitude range of the box; in this case the point is still
+        // considered as inside the longitude range band of the box
+        if ((plon >= lon_min && plon <= lon_max) || plon + two_pi <= lon_max)
+        {
+            if (plat > lat_max)
+            {
+                return services::result_from_distance
+                    <
+                        Strategy, Point, box_point_type
+                    >::apply(m_ps_strategy, radius() * (plat - lat_max));
+            }
+            else if (plat < lat_min)
+            {
+                return services::result_from_distance
+                    <
+                        Strategy, Point, box_point_type
+                    >::apply(m_ps_strategy, radius() * (lat_min - plat));
+            }
+            else
+            {
+                BOOST_GEOMETRY_ASSERT(plat >= lat_min && plat <= lat_max);
+                return return_type(0);
+            }
+        }
+
+        // Otherwise determine which among the two medirian segments of the
+        // box the point is closest to, and compute the distance of
+        // the point to this closest segment
+
+        // Below lon_midway is the longitude of the meridian that:
+        // (1) is midway between the meridians of the left and right
+        //     meridians of the box, and
+        // (2) does not intersect the box
+        return_type const two = 2.0;
+        bool use_left_segment;
+        if (lon_max > pi)
+        {
+            // the box crosses the antimeridian
+
+            // midway longitude = lon_min - (lon_min + (lon_max - 2 * pi)) / 2;
+            return_type const lon_midway = (lon_min - lon_max) / two + pi;
+            BOOST_GEOMETRY_ASSERT(lon_midway >= -pi && lon_midway <= pi);
+
+            use_left_segment = plon > lon_midway;
+        }
+        else
+        {
+            // the box does not cross the antimeridian
+
+            return_type const lon_sum = lon_min + lon_max;
+            if (math::equals(lon_sum, return_type(0)))
+            {
+                // special case: the box is symmetric with respect to
+                // the prime meridian; the midway meridian is the antimeridian
+
+                use_left_segment = plon < lon_min;
+            }
+            else
+            {
+                // midway long. = lon_min - (2 * pi - (lon_max - lon_min)) / 2;
+                return_type lon_midway = (lon_min + lon_max) / two - pi;
+
+                // normalize the midway longitude
+                if (lon_midway > pi)
+                {
+                    lon_midway -= two_pi;
+                }
+                else if (lon_midway < -pi)
+                {
+                    lon_midway += two_pi;
+                }
+                BOOST_GEOMETRY_ASSERT(lon_midway >= -pi && lon_midway <= pi);
+
+                // if lon_sum is positive the midway meridian is left
+                // of the box, or right of the box otherwise
+                use_left_segment = lon_sum > 0
+                    ? (plon < lon_min && plon >= lon_midway)
+                    : (plon <= lon_max || plon > lon_midway);
+            }
+        }
+
+        return use_left_segment
+            ? m_ps_strategy.apply(point, bottom_left, top_left)
+            : m_ps_strategy.apply(point, bottom_right, top_right);
+    }
+
+    inline typename Strategy::radius_type radius() const
+    {
+        return m_ps_strategy.radius();
+    }
+
+private:
+    Strategy m_ps_strategy;
+};
+
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+template <typename CalculationType, typename Strategy>
+struct tag<cross_track_point_box<CalculationType, Strategy> >
+{
+    typedef strategy_tag_distance_point_box type;
+};
+
+
+template <typename CalculationType, typename Strategy, typename P, typename Box>
+struct return_type<cross_track_point_box<CalculationType, Strategy>, P, Box>
+    : cross_track_point_box
+        <
+            CalculationType, Strategy
+        >::template return_type<P, Box>
+{};
+
+
+template <typename CalculationType, typename Strategy>
+struct comparable_type<cross_track_point_box<CalculationType, Strategy> >
+{
+    typedef cross_track_point_box
+        <
+            CalculationType, typename comparable_type<Strategy>::type
+        > type;
+};
+
+
+template <typename CalculationType, typename Strategy>
+struct get_comparable<cross_track_point_box<CalculationType, Strategy> >
+{
+    typedef cross_track_point_box<CalculationType, Strategy> this_strategy;
+    typedef typename comparable_type<this_strategy>::type comparable_type;
+
+public:
+    static inline comparable_type apply(this_strategy const& strategy)
+    {
+        return comparable_type(strategy.radius());
+    }
+};
+
+
+template <typename CalculationType, typename Strategy, typename P, typename Box>
+struct result_from_distance
+    <
+        cross_track_point_box<CalculationType, Strategy>, P, Box
+    >
+{
+private:
+    typedef cross_track_point_box<CalculationType, Strategy> this_strategy;
+
+    typedef typename this_strategy::template return_type
+        <
+            P, Box
+        >::type return_type;
+
+public:
+    template <typename T>
+    static inline return_type apply(this_strategy const& strategy,
+                                    T const& distance)
+    {
+        Strategy s(strategy.radius());
+
+        return result_from_distance
+            <
+                Strategy, P, typename point_type<Box>::type
+            >::apply(s, distance);
+    }
+};
+
+
+// define cross_track_point_box<default_point_segment_strategy> as
+// default point-box strategy for the spherical equatorial coordinate system
+template <typename Point, typename Box, typename Strategy>
+struct default_strategy
+    <
+        point_tag, box_tag, Point, Box,
+        spherical_equatorial_tag, spherical_equatorial_tag,
+        Strategy
+    >
+{
+    typedef cross_track_point_box
+        <
+            void,
+            typename boost::mpl::if_
+                <
+                    boost::is_void<Strategy>,
+                    typename default_strategy
+                        <
+                            point_tag, segment_tag,
+                            Point, typename point_type<Box>::type,
+                            spherical_equatorial_tag, spherical_equatorial_tag
+                        >::type,
+                    Strategy
+                >::type
+        > type;
+};
+
+
+template <typename Box, typename Point, typename Strategy>
+struct default_strategy
+    <
+        box_tag, point_tag, Box, Point,
+        spherical_equatorial_tag, spherical_equatorial_tag,
+        Strategy
+    >
+{
+    typedef typename default_strategy
+        <
+            point_tag, box_tag, Point, Box,
+            spherical_equatorial_tag, spherical_equatorial_tag,
+            Strategy
+        >::type type;
+};
+
+
+} // namespace services
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::distance
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DISTANCE_CROSS_TRACK_POINT_BOX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/distance_haversine.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/distance_haversine.hpp
new file mode 100644
index 00000000000..8b32056f3e9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/distance_haversine.hpp
@@ -0,0 +1,305 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DISTANCE_HAVERSINE_HPP
+#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DISTANCE_HAVERSINE_HPP
+
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/radian_access.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/select_calculation_type.hpp>
+#include <boost/geometry/util/promote_floating_point.hpp>
+
+#include <boost/geometry/strategies/distance.hpp>
+
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace distance
+{
+
+
+namespace comparable
+{
+
+// Comparable haversine.
+// To compare distances, we can avoid:
+// - multiplication with radius and 2.0
+// - applying sqrt
+// - applying asin (which is strictly (monotone) increasing)
+template
+<
+    typename RadiusType,
+    typename CalculationType = void
+>
+class haversine
+{
+public :
+    template <typename Point1, typename Point2>
+    struct calculation_type
+        : promote_floating_point
+          <
+              typename select_calculation_type
+                  <
+                      Point1,
+                      Point2,
+                      CalculationType
+                  >::type
+          >
+    {};
+
+    typedef RadiusType radius_type;
+
+    explicit inline haversine(RadiusType const& r = 1.0)
+        : m_radius(r)
+    {}
+
+    template <typename Point1, typename Point2>
+    static inline typename calculation_type<Point1, Point2>::type
+    apply(Point1 const& p1, Point2 const& p2)
+    {
+        return calculate<typename calculation_type<Point1, Point2>::type>(
+                   get_as_radian<0>(p1), get_as_radian<1>(p1),
+                   get_as_radian<0>(p2), get_as_radian<1>(p2)
+               );
+    }
+
+    inline RadiusType radius() const
+    {
+        return m_radius;
+    }
+
+
+private :
+    template <typename R, typename T1, typename T2>
+    static inline R calculate(T1 const& lon1, T1 const& lat1,
+                              T2 const& lon2, T2 const& lat2)
+    {
+        return math::hav(lat2 - lat1)
+                + cos(lat1) * cos(lat2) * math::hav(lon2 - lon1);
+    }
+
+    RadiusType m_radius;
+};
+
+
+
+} // namespace comparable
+
+/*!
+\brief Distance calculation for spherical coordinates
+on a perfect sphere using haversine
+\ingroup strategies
+\tparam RadiusType \tparam_radius
+\tparam CalculationType \tparam_calculation
+\author Adapted from: http://williams.best.vwh.net/avform.htm
+\see http://en.wikipedia.org/wiki/Great-circle_distance
+\note (from Wiki:) The great circle distance d between two
+points with coordinates {lat1,lon1} and {lat2,lon2} is given by:
+    d=acos(sin(lat1)*sin(lat2)+cos(lat1)*cos(lat2)*cos(lon1-lon2))
+A mathematically equivalent formula, which is less subject
+    to rounding error for short distances is:
+    d=2*asin(sqrt((sin((lat1-lat2) / 2))^2
+    + cos(lat1)*cos(lat2)*(sin((lon1-lon2) / 2))^2))
+
+
+\qbk{
+[heading See also]
+[link geometry.reference.algorithms.distance.distance_3_with_strategy distance (with strategy)]
+}
+
+*/
+template
+<
+    typename RadiusType,
+    typename CalculationType = void
+>
+class haversine
+{
+    typedef comparable::haversine<RadiusType, CalculationType> comparable_type;
+
+public :
+    template <typename Point1, typename Point2>
+    struct calculation_type
+        : services::return_type<comparable_type, Point1, Point2>
+    {};
+
+    typedef RadiusType radius_type;
+
+    /*!
+    \brief Constructor
+    \param radius radius of the sphere, defaults to 1.0 for the unit sphere
+    */
+    inline haversine(RadiusType const& radius = 1.0)
+        : m_radius(radius)
+    {}
+
+    /*!
+    \brief applies the distance calculation
+    \return the calculated distance (including multiplying with radius)
+    \param p1 first point
+    \param p2 second point
+    */
+    template <typename Point1, typename Point2>
+    inline typename calculation_type<Point1, Point2>::type
+    apply(Point1 const& p1, Point2 const& p2) const
+    {
+        typedef typename calculation_type<Point1, Point2>::type calculation_type;
+        calculation_type const a = comparable_type::apply(p1, p2);
+        calculation_type const c = calculation_type(2.0) * asin(math::sqrt(a));
+        return calculation_type(m_radius) * c;
+    }
+
+    /*!
+    \brief access to radius value
+    \return the radius
+    */
+    inline RadiusType radius() const
+    {
+        return m_radius;
+    }
+
+private :
+    RadiusType m_radius;
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+template <typename RadiusType, typename CalculationType>
+struct tag<haversine<RadiusType, CalculationType> >
+{
+    typedef strategy_tag_distance_point_point type;
+};
+
+
+template <typename RadiusType, typename CalculationType, typename P1, typename P2>
+struct return_type<haversine<RadiusType, CalculationType>, P1, P2>
+    : haversine<RadiusType, CalculationType>::template calculation_type<P1, P2>
+{};
+
+
+template <typename RadiusType, typename CalculationType>
+struct comparable_type<haversine<RadiusType, CalculationType> >
+{
+    typedef comparable::haversine<RadiusType, CalculationType> type;
+};
+
+
+template <typename RadiusType, typename CalculationType>
+struct get_comparable<haversine<RadiusType, CalculationType> >
+{
+private :
+    typedef haversine<RadiusType, CalculationType> this_type;
+    typedef comparable::haversine<RadiusType, CalculationType> comparable_type;
+public :
+    static inline comparable_type apply(this_type const& input)
+    {
+        return comparable_type(input.radius());
+    }
+};
+
+template <typename RadiusType, typename CalculationType, typename P1, typename P2>
+struct result_from_distance<haversine<RadiusType, CalculationType>, P1, P2>
+{
+private :
+    typedef haversine<RadiusType, CalculationType> this_type;
+    typedef typename return_type<this_type, P1, P2>::type return_type;
+public :
+    template <typename T>
+    static inline return_type apply(this_type const& , T const& value)
+    {
+        return return_type(value);
+    }
+};
+
+
+// Specializations for comparable::haversine
+template <typename RadiusType, typename CalculationType>
+struct tag<comparable::haversine<RadiusType, CalculationType> >
+{
+    typedef strategy_tag_distance_point_point type;
+};
+
+
+template <typename RadiusType, typename CalculationType, typename P1, typename P2>
+struct return_type<comparable::haversine<RadiusType, CalculationType>, P1, P2>
+    : comparable::haversine<RadiusType, CalculationType>::template calculation_type<P1, P2>
+{};
+
+
+template <typename RadiusType, typename CalculationType>
+struct comparable_type<comparable::haversine<RadiusType, CalculationType> >
+{
+    typedef comparable::haversine<RadiusType, CalculationType> type;
+};
+
+
+template <typename RadiusType, typename CalculationType>
+struct get_comparable<comparable::haversine<RadiusType, CalculationType> >
+{
+private :
+    typedef comparable::haversine<RadiusType, CalculationType> this_type;
+public :
+    static inline this_type apply(this_type const& input)
+    {
+        return input;
+    }
+};
+
+
+template <typename RadiusType, typename CalculationType, typename P1, typename P2>
+struct result_from_distance<comparable::haversine<RadiusType, CalculationType>, P1, P2>
+{
+private :
+    typedef comparable::haversine<RadiusType, CalculationType> strategy_type;
+    typedef typename return_type<strategy_type, P1, P2>::type return_type;
+public :
+    template <typename T>
+    static inline return_type apply(strategy_type const& strategy, T const& distance)
+    {
+        return_type const s = sin((distance / strategy.radius()) / return_type(2));
+        return s * s;
+    }
+};
+
+
+// Register it as the default for point-types
+// in a spherical equatorial coordinate system
+template <typename Point1, typename Point2>
+struct default_strategy
+    <
+        point_tag, point_tag, Point1, Point2,
+        spherical_equatorial_tag, spherical_equatorial_tag
+    >
+{
+    typedef strategy::distance::haversine<typename select_coordinate_type<Point1, Point2>::type> type;
+};
+
+// Note: spherical polar coordinate system requires "get_as_radian_equatorial"
+
+
+} // namespace services
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::distance
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_DISTANCE_HAVERSINE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/envelope_segment.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/envelope_segment.hpp
new file mode 100644
index 00000000000..98f085fe731
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/envelope_segment.hpp
@@ -0,0 +1,86 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2017 Oracle and/or its affiliates.
+// Contributed and/or modified by Vissarion Fisikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_SPHERICAL_ENVELOPE_SEGMENT_HPP
+#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_ENVELOPE_SEGMENT_HPP
+
+#include <boost/geometry/algorithms/detail/envelope/segment.hpp>
+#include <boost/geometry/algorithms/detail/normalize.hpp>
+#include <boost/geometry/strategies/envelope.hpp>
+#include <boost/geometry/strategies/spherical/azimuth.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace envelope
+{
+
+template
+<
+    typename CalculationType = void
+>
+class spherical_segment
+{
+public :
+
+    inline spherical_segment()
+    {}
+
+    template <typename Point1, typename Point2, typename Box>
+    inline void
+    apply(Point1 const& point1, Point2 const& point2, Box& box) const
+    {
+        Point1 p1_normalized = detail::return_normalized<Point1>(point1);
+        Point2 p2_normalized = detail::return_normalized<Point2>(point2);
+
+        geometry::strategy::azimuth::spherical<CalculationType> azimuth_spherical;
+
+        typedef typename coordinate_system<Point1>::type::units units_type;
+
+        geometry::detail::envelope::envelope_segment_impl<spherical_equatorial_tag>
+                ::template apply<units_type>(geometry::get<0>(p1_normalized),
+                                             geometry::get<1>(p1_normalized),
+                                             geometry::get<0>(p2_normalized),
+                                             geometry::get<1>(p2_normalized),
+                                             box,
+                                             azimuth_spherical);
+
+  }
+};
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+template <typename CalculationType>
+struct default_strategy<spherical_equatorial_tag, CalculationType>
+{
+    typedef strategy::envelope::spherical_segment<CalculationType> type;
+};
+
+
+template <typename CalculationType>
+struct default_strategy<spherical_polar_tag, CalculationType>
+{
+    typedef strategy::envelope::spherical_segment<CalculationType> type;
+};
+
+}
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::envelope
+
+}} //namepsace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_ENVELOPE_SEGMENT_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/intersection.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/intersection.hpp
new file mode 100644
index 00000000000..44b1cc62bfd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/intersection.hpp
@@ -0,0 +1,1067 @@
+// Boost.Geometry
+
+// Copyright (c) 2016-2017, Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_SPHERICAL_INTERSECTION_HPP
+#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_INTERSECTION_HPP
+
+#include <algorithm>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/radian_access.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/detail/assign_values.hpp>
+#include <boost/geometry/algorithms/detail/assign_indexed_point.hpp>
+#include <boost/geometry/algorithms/detail/equals/point_point.hpp>
+#include <boost/geometry/algorithms/detail/recalculate.hpp>
+
+#include <boost/geometry/arithmetic/arithmetic.hpp>
+#include <boost/geometry/arithmetic/cross_product.hpp>
+#include <boost/geometry/arithmetic/dot_product.hpp>
+#include <boost/geometry/arithmetic/normalize.hpp>
+#include <boost/geometry/formulas/spherical.hpp>
+
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+#include <boost/geometry/geometries/concepts/segment_concept.hpp>
+
+#include <boost/geometry/policies/robustness/segment_ratio.hpp>
+
+#include <boost/geometry/strategies/agnostic/point_in_poly_winding.hpp>
+#include <boost/geometry/strategies/covered_by.hpp>
+#include <boost/geometry/strategies/intersection.hpp>
+#include <boost/geometry/strategies/intersection_result.hpp>
+#include <boost/geometry/strategies/side.hpp>
+#include <boost/geometry/strategies/side_info.hpp>
+#include <boost/geometry/strategies/spherical/area.hpp>
+#include <boost/geometry/strategies/spherical/distance_haversine.hpp>
+#include <boost/geometry/strategies/spherical/envelope_segment.hpp>
+#include <boost/geometry/strategies/spherical/ssf.hpp>
+#include <boost/geometry/strategies/within.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/select_calculation_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace intersection
+{
+
+// NOTE:
+// The coordinates of crossing IP may be calculated with small precision in some cases.
+// For double, near the equator noticed error ~1e-9 so far greater than
+// machine epsilon which is ~1e-16. This error is ~0.04m.
+// E.g. consider two cases, one near the origin and the second one rotated by 90 deg around Z or SN axis.
+// After the conversion from spherical degrees to cartesian 3d the following coordinates
+// are calculated:
+// for sph (-1 -1,  1 1) deg cart3d ys are -0.017449748351250485 and  0.017449748351250485
+// for sph (89 -1, 91 1) deg cart3d xs are  0.017449748351250571 and -0.017449748351250450
+// During the conversion degrees must first be converted to radians and then radians
+// are passed into trigonometric functions. The error may have several causes:
+// 1. Radians cannot represent exactly the same angles as degrees.
+// 2. Different longitudes are passed into sin() for x, corresponding to cos() for y,
+//    and for different angle the error of the result may be different.
+// 3. These non-corresponding cartesian coordinates are used in calculation,
+//    e.g. multiplied several times in cross and dot products.
+// If it was a problem this strategy could e.g. "normalize" longitudes before the conversion using the source units
+// by rotating the globe around Z axis, so moving longitudes always the same way towards the origin,
+// assuming this could help which is not clear.
+// For now, intersection points near the endpoints are checked explicitly if needed (if the IP is near the endpoint)
+// to generate precise result for them. Only the crossing (i) case may suffer from lower precision.
+
+template
+<
+    typename CalcPolicy,
+    typename CalculationType = void
+>
+struct ecef_segments
+{
+    typedef side::spherical_side_formula<CalculationType> side_strategy_type;
+
+    static inline side_strategy_type get_side_strategy()
+    {
+        return side_strategy_type();
+    }
+
+    template <typename Geometry1, typename Geometry2>
+    struct point_in_geometry_strategy
+    {
+        typedef strategy::within::winding
+            <
+                typename point_type<Geometry1>::type,
+                typename point_type<Geometry2>::type,
+                side_strategy_type,
+                CalculationType
+            > type;
+    };
+
+    template <typename Geometry1, typename Geometry2>
+    static inline typename point_in_geometry_strategy<Geometry1, Geometry2>::type
+        get_point_in_geometry_strategy()
+    {
+        typedef typename point_in_geometry_strategy
+            <
+                Geometry1, Geometry2
+            >::type strategy_type;
+        return strategy_type();
+    }
+
+    template <typename Geometry>
+    struct area_strategy
+    {
+        typedef area::spherical
+            <
+                typename point_type<Geometry>::type,
+                CalculationType
+            > type;
+    };
+
+    template <typename Geometry>
+    static inline typename area_strategy<Geometry>::type get_area_strategy()
+    {
+        typedef typename area_strategy<Geometry>::type strategy_type;
+        return strategy_type();
+    }
+
+    template <typename Geometry>
+    struct distance_strategy
+    {
+        typedef distance::haversine
+            <
+                typename coordinate_type<Geometry>::type,
+                CalculationType
+            > type;
+    };
+
+    template <typename Geometry>
+    static inline typename distance_strategy<Geometry>::type get_distance_strategy()
+    {
+        typedef typename distance_strategy<Geometry>::type strategy_type;
+        return strategy_type();
+    }
+
+    typedef envelope::spherical_segment<CalculationType>
+        envelope_strategy_type;
+
+    static inline envelope_strategy_type get_envelope_strategy()
+    {
+        return envelope_strategy_type();
+    }
+
+    enum intersection_point_flag { ipi_inters = 0, ipi_at_a1, ipi_at_a2, ipi_at_b1, ipi_at_b2 };
+
+    // segment_intersection_info cannot outlive relate_ecef_segments
+    template <typename CoordinateType, typename SegmentRatio, typename Vector3d>
+    struct segment_intersection_info
+    {
+        typedef typename select_most_precise
+            <
+                CoordinateType, double
+            >::type promoted_type;
+
+        segment_intersection_info(CalcPolicy const& calc)
+            : calc_policy(calc)
+        {}
+
+        promoted_type comparable_length_a() const
+        {
+            return robust_ra.denominator();
+        }
+
+        promoted_type comparable_length_b() const
+        {
+            return robust_rb.denominator();
+        }
+
+        template <typename Point, typename Segment1, typename Segment2>
+        void assign_a(Point& point, Segment1 const& a, Segment2 const& b) const
+        {
+            assign(point, a, b);
+        }
+        template <typename Point, typename Segment1, typename Segment2>
+        void assign_b(Point& point, Segment1 const& a, Segment2 const& b) const
+        {
+            assign(point, a, b);
+        }
+
+        template <typename Point, typename Segment1, typename Segment2>
+        void assign(Point& point, Segment1 const& a, Segment2 const& b) const
+        {
+            if (ip_flag == ipi_inters)
+            {
+                // TODO: assign the rest of coordinates
+                point = calc_policy.template from_cart3d<Point>(intersection_point);
+            }
+            else if (ip_flag == ipi_at_a1)
+            {
+                detail::assign_point_from_index<0>(a, point);
+            }
+            else if (ip_flag == ipi_at_a2)
+            {
+                detail::assign_point_from_index<1>(a, point);
+            }
+            else if (ip_flag == ipi_at_b1)
+            {
+                detail::assign_point_from_index<0>(b, point);
+            }
+            else // ip_flag == ipi_at_b2
+            {
+                detail::assign_point_from_index<1>(b, point);
+            }
+        }
+
+        Vector3d intersection_point;
+        SegmentRatio robust_ra;
+        SegmentRatio robust_rb;
+        intersection_point_flag ip_flag;
+
+        CalcPolicy const& calc_policy;
+    };
+
+    // Relate segments a and b
+    template
+    <
+        typename Segment1,
+        typename Segment2,
+        typename Policy,
+        typename RobustPolicy
+    >
+    static inline typename Policy::return_type
+        apply(Segment1 const& a, Segment2 const& b,
+              Policy const& policy, RobustPolicy const& robust_policy)
+    {
+        typedef typename point_type<Segment1>::type point1_t;
+        typedef typename point_type<Segment2>::type point2_t;
+        point1_t a1, a2;
+        point2_t b1, b2;
+
+        // TODO: use indexed_point_view if possible?
+        detail::assign_point_from_index<0>(a, a1);
+        detail::assign_point_from_index<1>(a, a2);
+        detail::assign_point_from_index<0>(b, b1);
+        detail::assign_point_from_index<1>(b, b2);
+
+        return apply(a, b, policy, robust_policy, a1, a2, b1, b2);
+    }
+
+    // Relate segments a and b
+    template
+    <
+        typename Segment1,
+        typename Segment2,
+        typename Policy,
+        typename RobustPolicy,
+        typename Point1,
+        typename Point2
+    >
+    static inline typename Policy::return_type
+        apply(Segment1 const& a, Segment2 const& b,
+              Policy const&, RobustPolicy const&,
+              Point1 const& a1, Point1 const& a2, Point2 const& b1, Point2 const& b2)
+    {
+        // For now create it using default constructor. In the future it could
+        //  be stored in strategy. However then apply() wouldn't be static and
+        //  all relops and setops would have to take the strategy or model.
+        // Initialize explicitly to prevent compiler errors in case of PoD type
+        CalcPolicy const calc_policy = CalcPolicy();
+
+        BOOST_CONCEPT_ASSERT( (concepts::ConstSegment<Segment1>) );
+        BOOST_CONCEPT_ASSERT( (concepts::ConstSegment<Segment2>) );
+
+        // TODO: check only 2 first coordinates here?
+        using geometry::detail::equals::equals_point_point;
+        bool a_is_point = equals_point_point(a1, a2);
+        bool b_is_point = equals_point_point(b1, b2);
+
+        if(a_is_point && b_is_point)
+        {
+            return equals_point_point(a1, b2)
+                ? Policy::degenerate(a, true)
+                : Policy::disjoint()
+                ;
+        }
+
+        typedef typename select_calculation_type
+            <Segment1, Segment2, CalculationType>::type calc_t;
+
+        calc_t const c0 = 0;
+        calc_t const c1 = 1;
+
+        typedef model::point<calc_t, 3, cs::cartesian> vec3d_t;
+
+        vec3d_t const a1v = calc_policy.template to_cart3d<vec3d_t>(a1);
+        vec3d_t const a2v = calc_policy.template to_cart3d<vec3d_t>(a2);
+        vec3d_t const b1v = calc_policy.template to_cart3d<vec3d_t>(b1);
+        vec3d_t const b2v = calc_policy.template to_cart3d<vec3d_t>(b2);
+        
+        bool degen_neq_coords = false;
+        side_info sides;
+
+        typename CalcPolicy::template plane<vec3d_t>
+            plane2 = calc_policy.get_plane(b1v, b2v);
+
+        calc_t dist_b1_b2 = 0;
+        if (! b_is_point)
+        {
+            calculate_dist(b1v, b2v, plane2, dist_b1_b2);
+            if (math::equals(dist_b1_b2, c0))
+            {
+                degen_neq_coords = true;
+                b_is_point = true;
+                dist_b1_b2 = 0;
+            }
+            else
+            {
+                // not normalized normals, the same as in side strategy
+                sides.set<0>(plane2.side_value(a1v), plane2.side_value(a2v));
+                if (sides.same<0>())
+                {
+                    // Both points are at same side of other segment, we can leave
+                    return Policy::disjoint();
+                }
+            }
+        }
+
+        typename CalcPolicy::template plane<vec3d_t>
+            plane1 = calc_policy.get_plane(a1v, a2v);
+
+        calc_t dist_a1_a2 = 0;
+        if (! a_is_point)
+        {
+            calculate_dist(a1v, a2v, plane1, dist_a1_a2);
+            if (math::equals(dist_a1_a2, c0))
+            {
+                degen_neq_coords = true;
+                a_is_point = true;
+                dist_a1_a2 = 0;
+            }
+            else
+            {
+                // not normalized normals, the same as in side strategy
+                sides.set<1>(plane1.side_value(b1v), plane1.side_value(b2v));
+                if (sides.same<1>())
+                {
+                    // Both points are at same side of other segment, we can leave
+                    return Policy::disjoint();
+                }
+            }
+        }
+
+        // NOTE: at this point the segments may still be disjoint
+
+        calc_t len1 = 0;
+        // point or opposite sides of a sphere/spheroid, assume point
+        if (! a_is_point && ! detail::vec_normalize(plane1.normal, len1))
+        {
+            a_is_point = true;
+            if (sides.get<0, 0>() == 0 || sides.get<0, 1>() == 0)
+            {
+                sides.set<0>(0, 0);
+            }
+        }
+
+        calc_t len2 = 0;
+        if (! b_is_point && ! detail::vec_normalize(plane2.normal, len2))
+        {
+            b_is_point = true;
+            if (sides.get<1, 0>() == 0 || sides.get<1, 1>() == 0)
+            {
+                sides.set<1>(0, 0);
+            }
+        }
+
+        // check both degenerated once more
+        if (a_is_point && b_is_point)
+        {
+            return equals_point_point(a1, b2)
+                ? Policy::degenerate(a, true)
+                : Policy::disjoint()
+                ;
+        }
+
+        // NOTE: at this point the segments may still be disjoint
+        // NOTE: at this point one of the segments may be degenerated
+
+        bool collinear = sides.collinear();       
+
+        if (! collinear)
+        {
+            // NOTE: for some approximations it's possible that both points may lie
+            // on the same geodesic but still some of the sides may be != 0.
+            // This is e.g. true for long segments represented as elliptic arcs
+            // with origin different than the center of the coordinate system.
+            // So make the sides consistent
+
+            // WARNING: the side strategy doesn't have the info about the other
+            // segment so it may return results inconsistent with this intersection
+            // strategy, as it checks both segments for consistency
+
+            if (sides.get<0, 0>() == 0 && sides.get<0, 1>() == 0)
+            {
+                collinear = true;
+                sides.set<1>(0, 0);
+            }
+            else if (sides.get<1, 0>() == 0 && sides.get<1, 1>() == 0)
+            {
+                collinear = true;
+                sides.set<0>(0, 0);
+            }
+        }
+
+        calc_t dot_n1n2 = dot_product(plane1.normal, plane2.normal);
+
+        // NOTE: this is technically not needed since theoretically above sides
+        //       are calculated, but just in case check the normals.
+        //       Have in mind that SSF side strategy doesn't check this.
+        // collinear if normals are equal or opposite: cos(a) in {-1, 1}
+        if (! collinear && math::equals(math::abs(dot_n1n2), c1))
+        {
+            collinear = true;
+            sides.set<0>(0, 0);
+            sides.set<1>(0, 0);
+        }
+        
+        if (collinear)
+        {
+            if (a_is_point)
+            {
+                return collinear_one_degenerated<Policy, calc_t>(a, true, b1, b2, a1, a2, b1v, b2v,
+                                                                 plane2, a1v, a2v, dist_b1_b2, degen_neq_coords);
+            }
+            else if (b_is_point)
+            {
+                // b2 used to be consistent with (degenerated) checks above (is it needed?)
+                return collinear_one_degenerated<Policy, calc_t>(b, false, a1, a2, b1, b2, a1v, a2v,
+                                                                 plane1, b1v, b2v, dist_a1_a2, degen_neq_coords);
+            }
+            else
+            {
+                calc_t dist_a1_b1, dist_a1_b2;
+                calc_t dist_b1_a1, dist_b1_a2;
+                // use shorter segment
+                if (len1 <= len2)
+                {
+                    calculate_collinear_data(a1, a2, b1, b2, a1v, a2v, plane1, b1v, b2v, dist_a1_a2, dist_a1_b1);
+                    calculate_collinear_data(a1, a2, b1, b2, a1v, a2v, plane1, b2v, b1v, dist_a1_a2, dist_a1_b2);
+                    dist_b1_b2 = dist_a1_b2 - dist_a1_b1;
+                    dist_b1_a1 = -dist_a1_b1;
+                    dist_b1_a2 = dist_a1_a2 - dist_a1_b1;
+                }
+                else
+                {
+                    calculate_collinear_data(b1, b2, a1, a2, b1v, b2v, plane2, a1v, a2v, dist_b1_b2, dist_b1_a1);
+                    calculate_collinear_data(b1, b2, a1, a2, b1v, b2v, plane2, a2v, a1v, dist_b1_b2, dist_b1_a2);
+                    dist_a1_a2 = dist_b1_a2 - dist_b1_a1;
+                    dist_a1_b1 = -dist_b1_a1;
+                    dist_a1_b2 = dist_b1_b2 - dist_b1_a1;
+                }
+
+                segment_ratio<calc_t> ra_from(dist_b1_a1, dist_b1_b2);
+                segment_ratio<calc_t> ra_to(dist_b1_a2, dist_b1_b2);
+                segment_ratio<calc_t> rb_from(dist_a1_b1, dist_a1_a2);
+                segment_ratio<calc_t> rb_to(dist_a1_b2, dist_a1_a2);
+                
+                // NOTE: this is probably not needed
+                int const a1_wrt_b = position_value(c0, dist_a1_b1, dist_a1_b2);
+                int const a2_wrt_b = position_value(dist_a1_a2, dist_a1_b1, dist_a1_b2);
+                int const b1_wrt_a = position_value(c0, dist_b1_a1, dist_b1_a2);
+                int const b2_wrt_a = position_value(dist_b1_b2, dist_b1_a1, dist_b1_a2);
+
+                if (a1_wrt_b == 1)
+                {
+                    ra_from.assign(0, dist_b1_b2);
+                    rb_from.assign(0, dist_a1_a2);
+                }
+                else if (a1_wrt_b == 3)
+                {
+                    ra_from.assign(dist_b1_b2, dist_b1_b2);
+                    rb_to.assign(0, dist_a1_a2);
+                }
+
+                if (a2_wrt_b == 1)
+                {
+                    ra_to.assign(0, dist_b1_b2);
+                    rb_from.assign(dist_a1_a2, dist_a1_a2);
+                }
+                else if (a2_wrt_b == 3)
+                {
+                    ra_to.assign(dist_b1_b2, dist_b1_b2);
+                    rb_to.assign(dist_a1_a2, dist_a1_a2);
+                }
+
+                if ((a1_wrt_b < 1 && a2_wrt_b < 1) || (a1_wrt_b > 3 && a2_wrt_b > 3))
+                {
+                    return Policy::disjoint();
+                }
+
+                bool const opposite = dot_n1n2 < c0;
+
+                return Policy::segments_collinear(a, b, opposite,
+                    a1_wrt_b, a2_wrt_b, b1_wrt_a, b2_wrt_a,
+                    ra_from, ra_to, rb_from, rb_to);
+            }
+        }
+        else // crossing
+        {
+            if (a_is_point || b_is_point)
+            {
+                return Policy::disjoint();
+            }
+
+            vec3d_t i1;
+            intersection_point_flag ip_flag;
+            calc_t dist_a1_i1, dist_b1_i1;
+            if (calculate_ip_data(a1, a2, b1, b2, a1v, a2v, b1v, b2v,
+                                  plane1, plane2, calc_policy,
+                                  sides, dist_a1_a2, dist_b1_b2,
+                                  i1, dist_a1_i1, dist_b1_i1, ip_flag))
+            {
+                // intersects
+                segment_intersection_info
+                    <
+                        calc_t,
+                        segment_ratio<calc_t>,
+                        vec3d_t
+                    > sinfo(calc_policy);
+
+                sinfo.robust_ra.assign(dist_a1_i1, dist_a1_a2);
+                sinfo.robust_rb.assign(dist_b1_i1, dist_b1_b2);
+                sinfo.intersection_point = i1;
+                sinfo.ip_flag = ip_flag;
+
+                return Policy::segments_crosses(sides, sinfo, a, b);
+            }
+            else
+            {
+                return Policy::disjoint();
+            }
+        }
+    }
+
+private:
+    template <typename Policy, typename CalcT, typename Segment, typename Point1, typename Point2, typename Vec3d, typename Plane>
+    static inline typename Policy::return_type
+        collinear_one_degenerated(Segment const& segment, bool degenerated_a,
+                                  Point1 const& a1, Point1 const& a2,
+                                  Point2 const& b1, Point2 const& b2,
+                                  Vec3d const& a1v, Vec3d const& a2v,
+                                  Plane const& plane,
+                                  Vec3d const& b1v, Vec3d const& b2v,
+                                  CalcT const& dist_1_2,
+                                  bool degen_neq_coords)
+    {
+        CalcT dist_1_o;
+        return ! calculate_collinear_data(a1, a2, b1, b2, a1v, a2v, plane, b1v, b2v, dist_1_2, dist_1_o, degen_neq_coords)
+                ? Policy::disjoint()
+                : Policy::one_degenerate(segment, segment_ratio<CalcT>(dist_1_o, dist_1_2), degenerated_a);
+    }
+
+    template <typename Point1, typename Point2, typename Vec3d, typename Plane, typename CalcT>
+    static inline bool calculate_collinear_data(Point1 const& a1, Point1 const& a2, // in
+                                                Point2 const& b1, Point2 const& b2, // in
+                                                Vec3d const& a1v,                   // in
+                                                Vec3d const& a2v,                   // in
+                                                Plane const& plane1,                // in
+                                                Vec3d const& b1v,                   // in
+                                                Vec3d const& b2v,                   // in
+                                                CalcT const& dist_a1_a2,            // in
+                                                CalcT& dist_a1_i1,                  // out
+                                                bool degen_neq_coords = false)      // in
+    {
+        // calculate dist_a1_a2 and dist_a1_i1
+        calculate_dist(a1v, a2v, plane1, b1v, dist_a1_i1);
+
+        // if i1 is close to a1 and b1 or b2 is equal to a1
+        if (is_endpoint_equal(dist_a1_i1, a1, b1, b2))
+        {
+            dist_a1_i1 = 0;
+            return true;
+        }
+        // or i1 is close to a2 and b1 or b2 is equal to a2
+        else if (is_endpoint_equal(dist_a1_a2 - dist_a1_i1, a2, b1, b2))
+        {
+            dist_a1_i1 = dist_a1_a2;
+            return true;
+        }
+
+        // check the other endpoint of a very short segment near the pole
+        if (degen_neq_coords)
+        {
+            static CalcT const c0 = 0;
+
+            CalcT dist_a1_i2 = 0;
+            calculate_dist(a1v, a2v, plane1, b2v, dist_a1_i2);
+
+            if (math::equals(dist_a1_i2, c0))
+            {
+                dist_a1_i1 = 0;
+                return true;
+            }
+            else if (math::equals(dist_a1_a2 - dist_a1_i2, c0))
+            {
+                dist_a1_i1 = dist_a1_a2;
+                return true;
+            }
+        }
+
+        // or i1 is on b
+        return segment_ratio<CalcT>(dist_a1_i1, dist_a1_a2).on_segment();
+    }
+
+    template <typename Point1, typename Point2, typename Vec3d, typename Plane, typename CalcT>
+    static inline bool calculate_ip_data(Point1 const& a1, Point1 const& a2, // in
+                                         Point2 const& b1, Point2 const& b2, // in
+                                         Vec3d const& a1v, Vec3d const& a2v, // in
+                                         Vec3d const& b1v, Vec3d const& b2v, // in
+                                         Plane const& plane1,                // in
+                                         Plane const& plane2,                // in
+                                         CalcPolicy const& calc_policy,      // in
+                                         side_info const& sides,             // in
+                                         CalcT const& dist_a1_a2,            // in
+                                         CalcT const& dist_b1_b2,            // in
+                                         Vec3d & ip,                         // out
+                                         CalcT& dist_a1_ip,                  // out
+                                         CalcT& dist_b1_ip,                  // out
+                                         intersection_point_flag& ip_flag)   // out
+    {
+        Vec3d ip1, ip2;
+        calc_policy.intersection_points(plane1, plane2, ip1, ip2);
+        
+        calculate_dist(a1v, a2v, plane1, ip1, dist_a1_ip);
+        ip = ip1;
+
+        // choose the opposite side of the globe if the distance is shorter
+        {
+            CalcT const d = abs_distance(dist_a1_a2, dist_a1_ip);
+            if (d > CalcT(0))
+            {
+                // TODO: this should be ok not only for sphere
+                //       but requires more investigation
+                CalcT const dist_a1_i2 = dist_of_i2(dist_a1_ip);
+                CalcT const d2 = abs_distance(dist_a1_a2, dist_a1_i2);
+                if (d2 < d)
+                {
+                    dist_a1_ip = dist_a1_i2;
+                    ip = ip2;
+                }
+            }
+        }
+
+        bool is_on_a = false, is_near_a1 = false, is_near_a2 = false;
+        if (! is_potentially_crossing(dist_a1_a2, dist_a1_ip, is_on_a, is_near_a1, is_near_a2))
+        {
+            return false;
+        }
+
+        calculate_dist(b1v, b2v, plane2, ip, dist_b1_ip);
+
+        bool is_on_b = false, is_near_b1 = false, is_near_b2 = false;
+        if (! is_potentially_crossing(dist_b1_b2, dist_b1_ip, is_on_b, is_near_b1, is_near_b2))
+        {
+            return false;
+        }
+
+        // reassign the IP if some endpoints overlap
+        using geometry::detail::equals::equals_point_point;
+        if (is_near_a1)
+        {
+            if (is_near_b1 && equals_point_point(a1, b1))
+            {
+                dist_a1_ip = 0;
+                dist_b1_ip = 0;
+                //i1 = a1v;
+                ip_flag = ipi_at_a1;
+                return true;
+            }
+            
+            if (is_near_b2 && equals_point_point(a1, b2))
+            {
+                dist_a1_ip = 0;
+                dist_b1_ip = dist_b1_b2;
+                //i1 = a1v;
+                ip_flag = ipi_at_a1;
+                return true;
+            }
+        }
+
+        if (is_near_a2)
+        {
+            if (is_near_b1 && equals_point_point(a2, b1))
+            {
+                dist_a1_ip = dist_a1_a2;
+                dist_b1_ip = 0;
+                //i1 = a2v;
+                ip_flag = ipi_at_a2;
+                return true;
+            }
+
+            if (is_near_b2 && equals_point_point(a2, b2))
+            {
+                dist_a1_ip = dist_a1_a2;
+                dist_b1_ip = dist_b1_b2;
+                //i1 = a2v;
+                ip_flag = ipi_at_a2;
+                return true;
+            }
+        }
+
+        // at this point we know that the endpoints doesn't overlap
+        // reassign IP and distance if the IP is on a segment and one of
+        //   the endpoints of the other segment lies on the former segment
+        if (is_on_a)
+        {
+            if (is_near_b1 && sides.template get<1, 0>() == 0) // b1 wrt a
+            {
+                dist_b1_ip = 0;
+                //i1 = b1v;
+                ip_flag = ipi_at_b1;
+                return true;
+            }
+
+            if (is_near_b2 && sides.template get<1, 1>() == 0) // b2 wrt a
+            {
+                dist_b1_ip = dist_b1_b2;
+                //i1 = b2v;
+                ip_flag = ipi_at_b2;
+                return true;
+            }
+        }
+
+        if (is_on_b)
+        {
+            if (is_near_a1 && sides.template get<0, 0>() == 0) // a1 wrt b
+            {
+                dist_a1_ip = 0;
+                //i1 = a1v;
+                ip_flag = ipi_at_a1;
+                return true;
+            }
+
+            if (is_near_a2 && sides.template get<0, 1>() == 0) // a2 wrt b
+            {
+                dist_a1_ip = dist_a1_a2;
+                //i1 = a2v;
+                ip_flag = ipi_at_a2;
+                return true;
+            }
+        }
+
+        ip_flag = ipi_inters;
+
+        return is_on_a && is_on_b;
+    }
+
+    template <typename Vec3d, typename Plane, typename CalcT>
+    static inline void calculate_dist(Vec3d const& a1v,    // in
+                                      Vec3d const& a2v,    // in
+                                      Plane const& plane1, // in
+                                      CalcT& dist_a1_a2)   // out
+    {
+        static CalcT const c1 = 1;
+        CalcT const cos_a1_a2 = plane1.cos_angle_between(a1v, a2v);
+        dist_a1_a2 = -cos_a1_a2 + c1; // [1, -1] -> [0, 2] representing [0, pi]
+    }
+
+    template <typename Vec3d, typename Plane, typename CalcT>
+    static inline void calculate_dist(Vec3d const& a1v,     // in
+                                      Vec3d const& /*a2v*/, // in
+                                      Plane const& plane1,  // in
+                                      Vec3d const& i1,      // in
+                                      CalcT& dist_a1_i1)    // out
+    {
+        static CalcT const c1 = 1;
+        static CalcT const c2 = 2;
+        static CalcT const c4 = 4;
+
+        bool is_forward = true;
+        CalcT cos_a1_i1 = plane1.cos_angle_between(a1v, i1, is_forward);
+        dist_a1_i1 = -cos_a1_i1 + c1; // [0, 2] representing [0, pi]
+        if (! is_forward) // left or right of a1 on a
+        {
+            dist_a1_i1 = -dist_a1_i1; // [0, 2] -> [0, -2] representing [0, -pi]
+        }
+        if (dist_a1_i1 <= -c2) // <= -pi
+        {
+            dist_a1_i1 += c4; // += 2pi
+        }
+    }
+    /*
+    template <typename Vec3d, typename Plane, typename CalcT>
+    static inline void calculate_dists(Vec3d const& a1v,    // in
+                                       Vec3d const& a2v,    // in
+                                       Plane const& plane1, // in
+                                       Vec3d const& i1,     // in
+                                       CalcT& dist_a1_a2, // out
+                                       CalcT& dist_a1_i1) // out
+    {
+        calculate_dist(a1v, a2v, plane1, dist_a1_a2);
+        calculate_dist(a1v, a2v, plane1, i1, dist_a1_i1);
+    }
+    */
+    // the dist of the ip on the other side of the sphere
+    template <typename CalcT>
+    static inline CalcT dist_of_i2(CalcT const& dist_a1_i1)
+    {
+        CalcT const c2 = 2;
+        CalcT const c4 = 4;
+
+        CalcT dist_a1_i2 = dist_a1_i1 - c2; // dist_a1_i2 = dist_a1_i1 - pi;
+        if (dist_a1_i2 <= -c2)          // <= -pi
+        {
+            dist_a1_i2 += c4;           // += 2pi;
+        }
+        return dist_a1_i2;
+    }
+
+    template <typename CalcT>
+    static inline CalcT abs_distance(CalcT const& dist_a1_a2, CalcT const& dist_a1_i1)
+    {
+        if (dist_a1_i1 < CalcT(0))
+            return -dist_a1_i1;
+        else if (dist_a1_i1 > dist_a1_a2)
+            return dist_a1_i1 - dist_a1_a2;
+        else
+            return CalcT(0);
+    }
+
+    template <typename CalcT>
+    static inline bool is_potentially_crossing(CalcT const& dist_a1_a2, CalcT const& dist_a1_i1, // in
+                                               bool& is_on_a, bool& is_near_a1, bool& is_near_a2) // out
+    {
+        is_on_a = segment_ratio<CalcT>(dist_a1_i1, dist_a1_a2).on_segment();
+        is_near_a1 = is_near(dist_a1_i1);
+        is_near_a2 = is_near(dist_a1_a2 - dist_a1_i1);
+        return is_on_a || is_near_a1 || is_near_a2;
+    }
+
+    template <typename CalcT, typename P1, typename P2>
+    static inline bool is_endpoint_equal(CalcT const& dist,
+                                         P1 const& ai, P2 const& b1, P2 const& b2)
+    {
+        static CalcT const c0 = 0;
+        using geometry::detail::equals::equals_point_point;
+        return is_near(dist) && (equals_point_point(ai, b1) || equals_point_point(ai, b2) || math::equals(dist, c0));
+    }
+
+    template <typename CalcT>
+    static inline bool is_near(CalcT const& dist)
+    {
+        CalcT const small_number = CalcT(boost::is_same<CalcT, float>::value ? 0.0001 : 0.00000001);
+        return math::abs(dist) <= small_number;
+    }
+
+    template <typename ProjCoord1, typename ProjCoord2>
+    static inline int position_value(ProjCoord1 const& ca1,
+                                     ProjCoord2 const& cb1,
+                                     ProjCoord2 const& cb2)
+    {
+        // S1x  0   1    2     3   4
+        // S2       |---------->
+        return math::equals(ca1, cb1) ? 1
+             : math::equals(ca1, cb2) ? 3
+             : cb1 < cb2 ?
+                ( ca1 < cb1 ? 0
+                : ca1 > cb2 ? 4
+                : 2 )
+              : ( ca1 > cb1 ? 0
+                : ca1 < cb2 ? 4
+                : 2 );
+    }
+};
+
+struct spherical_segments_calc_policy
+{
+    template <typename Point, typename Point3d>
+    static Point from_cart3d(Point3d const& point_3d)
+    {
+        return formula::cart3d_to_sph<Point>(point_3d);
+    }
+
+    template <typename Point3d, typename Point>
+    static Point3d to_cart3d(Point const& point)
+    {
+        return formula::sph_to_cart3d<Point3d>(point);
+    }
+
+    template <typename Point3d>
+    struct plane
+    {
+        typedef typename coordinate_type<Point3d>::type coord_t;
+
+        // not normalized
+        plane(Point3d const& p1, Point3d const& p2)
+            : normal(cross_product(p1, p2))
+        {}
+
+        int side_value(Point3d const& pt) const
+        {
+            return formula::sph_side_value(normal, pt);
+        }
+
+        static coord_t cos_angle_between(Point3d const& p1, Point3d const& p2)
+        {
+            return dot_product(p1, p2);
+        }
+
+        coord_t cos_angle_between(Point3d const& p1, Point3d const& p2, bool & is_forward) const
+        {
+            coord_t const c0 = 0;
+            is_forward = dot_product(normal, cross_product(p1, p2)) >= c0;
+            return dot_product(p1, p2);
+        }
+
+        Point3d normal;
+    };
+
+    template <typename Point3d>
+    static plane<Point3d> get_plane(Point3d const& p1, Point3d const& p2)
+    {
+        return plane<Point3d>(p1, p2);
+    }
+
+    template <typename Point3d>
+    static bool intersection_points(plane<Point3d> const& plane1,
+                                    plane<Point3d> const& plane2,
+                                    Point3d & ip1, Point3d & ip2)
+    {
+        typedef typename coordinate_type<Point3d>::type coord_t;
+
+        ip1 = cross_product(plane1.normal, plane2.normal);
+        // NOTE: the length should be greater than 0 at this point
+        //       if the normals were not normalized and their dot product
+        //       not checked before this function is called the length
+        //       should be checked here (math::equals(len, c0))
+        coord_t const len = math::sqrt(dot_product(ip1, ip1));
+        divide_value(ip1, len); // normalize i1
+
+        ip2 = ip1;
+        multiply_value(ip2, coord_t(-1));
+
+        return true;
+    }
+};
+
+
+template
+<
+    typename CalculationType = void
+>
+struct spherical_segments
+    : ecef_segments
+        <
+            spherical_segments_calc_policy,
+            CalculationType
+        >
+{};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+/*template <typename CalculationType>
+struct default_strategy<spherical_polar_tag, CalculationType>
+{
+    typedef spherical_segments<CalculationType> type;
+};*/
+
+template <typename CalculationType>
+struct default_strategy<spherical_equatorial_tag, CalculationType>
+{
+    typedef spherical_segments<CalculationType> type;
+};
+
+template <typename CalculationType>
+struct default_strategy<geographic_tag, CalculationType>
+{
+    // NOTE: Spherical strategy returns the same result as the geographic one
+    // representing segments as great elliptic arcs. If the elliptic arcs are
+    // not great elliptic arcs (the origin not in the center of the coordinate
+    // system) then there may be problems with consistency of the side and
+    // intersection strategies.
+    typedef spherical_segments<CalculationType> type;
+};
+
+} // namespace services
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::intersection
+
+
+namespace strategy
+{
+
+namespace within { namespace services
+{
+
+template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
+struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, linear_tag, linear_tag, spherical_tag, spherical_tag>
+{
+    typedef strategy::intersection::spherical_segments<> type;
+};
+
+template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
+struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, linear_tag, polygonal_tag, spherical_tag, spherical_tag>
+{
+    typedef strategy::intersection::spherical_segments<> type;
+};
+
+template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
+struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, polygonal_tag, linear_tag, spherical_tag, spherical_tag>
+{
+    typedef strategy::intersection::spherical_segments<> type;
+};
+
+template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
+struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, polygonal_tag, polygonal_tag, spherical_tag, spherical_tag>
+{
+    typedef strategy::intersection::spherical_segments<> type;
+};
+
+}} // within::services
+
+namespace covered_by { namespace services
+{
+
+template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
+struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, linear_tag, linear_tag, spherical_tag, spherical_tag>
+{
+    typedef strategy::intersection::spherical_segments<> type;
+};
+
+template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
+struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, linear_tag, polygonal_tag, spherical_tag, spherical_tag>
+{
+    typedef strategy::intersection::spherical_segments<> type;
+};
+
+template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
+struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, polygonal_tag, linear_tag, spherical_tag, spherical_tag>
+{
+    typedef strategy::intersection::spherical_segments<> type;
+};
+
+template <typename Geometry1, typename Geometry2, typename AnyTag1, typename AnyTag2>
+struct default_strategy<Geometry1, Geometry2, AnyTag1, AnyTag2, polygonal_tag, polygonal_tag, spherical_tag, spherical_tag>
+{
+    typedef strategy::intersection::spherical_segments<> type;
+};
+
+}} // within::services
+
+} // strategy
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_INTERSECTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/side_by_cross_track.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/side_by_cross_track.hpp
new file mode 100644
index 00000000000..3f7be055578
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/side_by_cross_track.hpp
@@ -0,0 +1,76 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_SPHERICAL_SIDE_BY_CROSS_TRACK_HPP
+#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_SIDE_BY_CROSS_TRACK_HPP
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/radian_access.hpp>
+
+#include <boost/geometry/algorithms/detail/course.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/promote_floating_point.hpp>
+#include <boost/geometry/util/select_calculation_type.hpp>
+
+#include <boost/geometry/strategies/side.hpp>
+//#include <boost/geometry/strategies/concepts/side_concept.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace side
+{
+
+/*!
+\brief Check at which side of a Great Circle segment a point lies
+         left of segment (> 0), right of segment (< 0), on segment (0)
+\ingroup strategies
+\tparam CalculationType \tparam_calculation
+ */
+template <typename CalculationType = void>
+class side_by_cross_track
+{
+
+public :
+    template <typename P1, typename P2, typename P>
+    static inline int apply(P1 const& p1, P2 const& p2, P const& p)
+    {
+        typedef typename promote_floating_point
+            <
+                typename select_calculation_type_alt
+                    <
+                        CalculationType,
+                        P1, P2, P
+                    >::type
+            >::type calc_t;
+
+        calc_t d1 = 0.001; // m_strategy.apply(sp1, p);
+        calc_t crs_AD = geometry::detail::course<calc_t>(p1, p);
+        calc_t crs_AB = geometry::detail::course<calc_t>(p1, p2);
+        calc_t XTD = asin(sin(d1) * sin(crs_AD - crs_AB));
+
+        return math::equals(XTD, 0) ? 0 : XTD < 0 ? 1 : -1;
+    }
+};
+
+}} // namespace strategy::side
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_SIDE_BY_CROSS_TRACK_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/ssf.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/ssf.hpp
new file mode 100644
index 00000000000..03f5428ede3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/spherical/ssf.hpp
@@ -0,0 +1,157 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2011-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2016.
+// Modifications copyright (c) 2016, Oracle and/or its affiliates.
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_SPHERICAL_SSF_HPP
+#define BOOST_GEOMETRY_STRATEGIES_SPHERICAL_SSF_HPP
+
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/radian_access.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/promote_floating_point.hpp>
+#include <boost/geometry/util/select_calculation_type.hpp>
+
+#include <boost/geometry/strategies/side.hpp>
+#include <boost/geometry/strategies/spherical/disjoint_segment_box.hpp>
+#include <boost/geometry/strategies/spherical/envelope_segment.hpp>
+//#include <boost/geometry/strategies/concepts/side_concept.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace strategy { namespace side
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <typename T>
+int spherical_side_formula(T const& lambda1, T const& delta1,
+                           T const& lambda2, T const& delta2,
+                           T const& lambda, T const& delta)
+{
+    // Create temporary points (vectors) on unit a sphere
+    T const cos_delta1 = cos(delta1);
+    T const c1x = cos_delta1 * cos(lambda1);
+    T const c1y = cos_delta1 * sin(lambda1);
+    T const c1z = sin(delta1);
+
+    T const cos_delta2 = cos(delta2);
+    T const c2x = cos_delta2 * cos(lambda2);
+    T const c2y = cos_delta2 * sin(lambda2);
+    T const c2z = sin(delta2);
+
+    // (Third point is converted directly)
+    T const cos_delta = cos(delta);
+
+    // Apply the "Spherical Side Formula" as presented on my blog
+    T const dist
+        = (c1y * c2z - c1z * c2y) * cos_delta * cos(lambda)
+        + (c1z * c2x - c1x * c2z) * cos_delta * sin(lambda)
+        + (c1x * c2y - c1y * c2x) * sin(delta);
+
+    T zero = T();
+    return math::equals(dist, zero) ? 0
+        : dist > zero ? 1
+        : -1; // dist < zero
+}
+
+}
+#endif // DOXYGEN_NO_DETAIL
+
+/*!
+\brief Check at which side of a Great Circle segment a point lies
+         left of segment (> 0), right of segment (< 0), on segment (0)
+\ingroup strategies
+\tparam CalculationType \tparam_calculation
+ */
+template <typename CalculationType = void>
+class spherical_side_formula
+{
+
+public :
+    typedef strategy::envelope::spherical_segment<CalculationType> envelope_strategy_type;
+
+    static inline envelope_strategy_type get_envelope_strategy()
+    {
+        return envelope_strategy_type();
+    }
+
+    typedef strategy::disjoint::segment_box_spherical disjoint_strategy_type;
+
+    static inline disjoint_strategy_type get_disjoint_strategy()
+    {
+        return disjoint_strategy_type();
+    }
+
+    template <typename P1, typename P2, typename P>
+    static inline int apply(P1 const& p1, P2 const& p2, P const& p)
+    {
+        typedef typename promote_floating_point
+            <
+                typename select_calculation_type_alt
+                    <
+                        CalculationType,
+                        P1, P2, P
+                    >::type
+            >::type calculation_type;
+
+        calculation_type const lambda1 = get_as_radian<0>(p1);
+        calculation_type const delta1 = get_as_radian<1>(p1);
+        calculation_type const lambda2 = get_as_radian<0>(p2);
+        calculation_type const delta2 = get_as_radian<1>(p2);
+        calculation_type const lambda = get_as_radian<0>(p);
+        calculation_type const delta = get_as_radian<1>(p);
+
+        return detail::spherical_side_formula(lambda1, delta1,
+                                              lambda2, delta2,
+                                              lambda, delta);
+    }
+};
+
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+namespace services
+{
+
+/*template <typename CalculationType>
+struct default_strategy<spherical_polar_tag, CalculationType>
+{
+    typedef spherical_side_formula<CalculationType> type;
+};*/
+
+template <typename CalculationType>
+struct default_strategy<spherical_equatorial_tag, CalculationType>
+{
+    typedef spherical_side_formula<CalculationType> type;
+};
+
+template <typename CalculationType>
+struct default_strategy<geographic_tag, CalculationType>
+{
+    typedef spherical_side_formula<CalculationType> type;
+};
+
+}
+#endif
+
+}} // namespace strategy::side
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_SPHERICAL_SSF_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/strategies.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/strategies.hpp
new file mode 100644
index 00000000000..27a025c7c44
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/strategies.hpp
@@ -0,0 +1,111 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014-2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Vissarion Fysikopoulos, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_STRATEGIES_HPP
+#define BOOST_GEOMETRY_STRATEGIES_STRATEGIES_HPP
+
+
+#include <boost/geometry/strategies/tags.hpp>
+
+#include <boost/geometry/strategies/area.hpp>
+#include <boost/geometry/strategies/azimuth.hpp>
+#include <boost/geometry/strategies/buffer.hpp>
+#include <boost/geometry/strategies/centroid.hpp>
+#include <boost/geometry/strategies/compare.hpp>
+#include <boost/geometry/strategies/convex_hull.hpp>
+#include <boost/geometry/strategies/covered_by.hpp>
+#include <boost/geometry/strategies/disjoint.hpp>
+#include <boost/geometry/strategies/distance.hpp>
+#include <boost/geometry/strategies/envelope.hpp>
+#include <boost/geometry/strategies/intersection.hpp>
+#include <boost/geometry/strategies/intersection_strategies.hpp> // for backward compatibility
+#include <boost/geometry/strategies/relate.hpp>
+#include <boost/geometry/strategies/side.hpp>
+#include <boost/geometry/strategies/transform.hpp>
+#include <boost/geometry/strategies/within.hpp>
+
+#include <boost/geometry/strategies/cartesian/area_surveyor.hpp>
+#include <boost/geometry/strategies/cartesian/azimuth.hpp>
+#include <boost/geometry/strategies/cartesian/box_in_box.hpp>
+#include <boost/geometry/strategies/cartesian/buffer_end_flat.hpp>
+#include <boost/geometry/strategies/cartesian/buffer_end_round.hpp>
+#include <boost/geometry/strategies/cartesian/buffer_join_miter.hpp>
+#include <boost/geometry/strategies/cartesian/buffer_join_round.hpp>
+#include <boost/geometry/strategies/cartesian/buffer_join_round_by_divide.hpp>
+#include <boost/geometry/strategies/cartesian/buffer_point_circle.hpp>
+#include <boost/geometry/strategies/cartesian/buffer_point_square.hpp>
+#include <boost/geometry/strategies/cartesian/buffer_side_straight.hpp>
+#include <boost/geometry/strategies/cartesian/centroid_average.hpp>
+#include <boost/geometry/strategies/cartesian/centroid_bashein_detmer.hpp>
+#include <boost/geometry/strategies/cartesian/centroid_weighted_length.hpp>
+#include <boost/geometry/strategies/cartesian/disjoint_segment_box.hpp>
+#include <boost/geometry/strategies/cartesian/distance_pythagoras.hpp>
+#include <boost/geometry/strategies/cartesian/distance_pythagoras_point_box.hpp>
+#include <boost/geometry/strategies/cartesian/distance_pythagoras_box_box.hpp>
+#include <boost/geometry/strategies/cartesian/distance_projected_point.hpp>
+#include <boost/geometry/strategies/cartesian/distance_projected_point_ax.hpp>
+#include <boost/geometry/strategies/cartesian/envelope_segment.hpp>
+#include <boost/geometry/strategies/cartesian/intersection.hpp>
+#include <boost/geometry/strategies/cartesian/point_in_box.hpp>
+#include <boost/geometry/strategies/cartesian/point_in_poly_franklin.hpp>
+#include <boost/geometry/strategies/cartesian/point_in_poly_crossings_multiply.hpp>
+#include <boost/geometry/strategies/cartesian/side_by_triangle.hpp>
+
+#include <boost/geometry/strategies/spherical/area.hpp>
+#include <boost/geometry/strategies/spherical/azimuth.hpp>
+#include <boost/geometry/strategies/spherical/disjoint_segment_box.hpp>
+#include <boost/geometry/strategies/spherical/distance_haversine.hpp>
+#include <boost/geometry/strategies/spherical/distance_cross_track.hpp>
+#include <boost/geometry/strategies/spherical/distance_cross_track_point_box.hpp>
+#include <boost/geometry/strategies/spherical/compare_circular.hpp>
+#include <boost/geometry/strategies/spherical/envelope_segment.hpp>
+#include <boost/geometry/strategies/spherical/intersection.hpp>
+#include <boost/geometry/strategies/spherical/ssf.hpp>
+
+#include <boost/geometry/strategies/geographic/area.hpp>
+#include <boost/geometry/strategies/geographic/azimuth.hpp>
+#include <boost/geometry/strategies/geographic/disjoint_segment_box.hpp>
+#include <boost/geometry/strategies/geographic/distance.hpp>
+#include <boost/geometry/strategies/geographic/distance_andoyer.hpp>
+#include <boost/geometry/strategies/geographic/distance_thomas.hpp>
+#include <boost/geometry/strategies/geographic/distance_vincenty.hpp>
+#include <boost/geometry/strategies/geographic/envelope_segment.hpp>
+#include <boost/geometry/strategies/geographic/intersection.hpp>
+//#include <boost/geometry/strategies/geographic/intersection_elliptic.hpp>
+#include <boost/geometry/strategies/geographic/side.hpp>
+#include <boost/geometry/strategies/geographic/side_andoyer.hpp>
+#include <boost/geometry/strategies/geographic/side_thomas.hpp>
+#include <boost/geometry/strategies/geographic/side_vincenty.hpp>
+
+#include <boost/geometry/strategies/agnostic/buffer_distance_symmetric.hpp>
+#include <boost/geometry/strategies/agnostic/buffer_distance_asymmetric.hpp>
+#include <boost/geometry/strategies/agnostic/hull_graham_andrew.hpp>
+#include <boost/geometry/strategies/agnostic/point_in_box_by_side.hpp>
+#include <boost/geometry/strategies/agnostic/point_in_point.hpp>
+#include <boost/geometry/strategies/agnostic/point_in_poly_winding.hpp>
+#include <boost/geometry/strategies/agnostic/simplify_douglas_peucker.hpp>
+
+#include <boost/geometry/strategies/strategy_transform.hpp>
+
+#include <boost/geometry/strategies/transform/matrix_transformers.hpp>
+#include <boost/geometry/strategies/transform/map_transformer.hpp>
+#include <boost/geometry/strategies/transform/inverse_transformer.hpp>
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_STRATEGIES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/strategy_transform.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/strategy_transform.hpp
new file mode 100644
index 00000000000..99fcb720c69
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/strategy_transform.hpp
@@ -0,0 +1,527 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_STRATEGY_TRANSFORM_HPP
+#define BOOST_GEOMETRY_STRATEGIES_STRATEGY_TRANSFORM_HPP
+
+#include <cstddef>
+#include <cmath>
+#include <functional>
+
+#include <boost/numeric/conversion/cast.hpp>
+
+#include <boost/geometry/algorithms/convert.hpp>
+#include <boost/geometry/arithmetic/arithmetic.hpp>
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/radian_access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/strategies/transform.hpp>
+
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/promote_floating_point.hpp>
+#include <boost/geometry/util/select_coordinate_type.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace transform
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template
+<
+    typename Src, typename Dst,
+    std::size_t D, std::size_t N,
+    template <typename> class F
+>
+struct transform_coordinates
+{
+    template <typename T>
+    static inline void transform(Src const& source, Dst& dest, T value)
+    {
+        typedef typename select_coordinate_type<Src, Dst>::type coordinate_type;
+
+        F<coordinate_type> function;
+        set<D>(dest, boost::numeric_cast<coordinate_type>(function(get<D>(source), value)));
+        transform_coordinates<Src, Dst, D + 1, N, F>::transform(source, dest, value);
+    }
+};
+
+template
+<
+    typename Src, typename Dst,
+    std::size_t N,
+    template <typename> class F
+>
+struct transform_coordinates<Src, Dst, N, N, F>
+{
+    template <typename T>
+    static inline void transform(Src const& , Dst& , T )
+    {
+    }
+};
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+/*!
+    \brief Transformation strategy to copy one point to another using assignment operator
+    \ingroup transform
+    \tparam P point type
+ */
+template <typename P>
+struct copy_direct
+{
+    inline bool apply(P const& p1, P& p2) const
+    {
+        p2 = p1;
+        return true;
+    }
+};
+
+/*!
+    \brief Transformation strategy to do copy a point, copying per coordinate.
+    \ingroup transform
+    \tparam P1 first point type
+    \tparam P2 second point type
+ */
+template <typename P1, typename P2>
+struct copy_per_coordinate
+{
+    inline bool apply(P1 const& p1, P2& p2) const
+    {
+        // Defensive check, dimensions are equal, selected by specialization
+        assert_dimension_equal<P1, P2>();
+
+        geometry::convert(p1, p2);
+        return true;
+    }
+};
+
+
+/*!
+    \brief Transformation strategy to go from degree to radian and back
+    \ingroup transform
+    \tparam P1 first point type
+    \tparam P2 second point type
+    \tparam F additional functor to divide or multiply with d2r
+ */
+template <typename P1, typename P2, template <typename> class F>
+struct degree_radian_vv
+{
+    inline bool apply(P1 const& p1, P2& p2) const
+    {
+        // Spherical coordinates always have 2 coordinates measured in angles
+        // The optional third one is distance/height, provided in another strategy
+        // Polar coordinates having one angle, will be also in another strategy
+        assert_dimension<P1, 2>();
+        assert_dimension<P2, 2>();
+
+        typedef typename promote_floating_point
+            <
+                typename select_coordinate_type<P1, P2>::type
+            >::type calculation_type;
+
+        detail::transform_coordinates
+            <
+                P1, P2, 0, 2, F
+            >::transform(p1, p2, math::d2r<calculation_type>());
+        return true;
+    }
+};
+
+template <typename P1, typename P2, template <typename> class F>
+struct degree_radian_vv_3
+{
+    inline bool apply(P1 const& p1, P2& p2) const
+    {
+        assert_dimension<P1, 3>();
+        assert_dimension<P2, 3>();
+
+        typedef typename promote_floating_point
+            <
+                typename select_coordinate_type<P1, P2>::type
+            >::type calculation_type;
+
+        detail::transform_coordinates
+            <
+                P1, P2, 0, 2, F
+            >::transform(p1, p2, math::d2r<calculation_type>());
+
+        // Copy height or other third dimension
+        set<2>(p2, get<2>(p1));
+        return true;
+    }
+};
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+    /// Helper function for conversion, phi/theta are in radians
+    template <typename P, typename T, typename R>
+    inline void spherical_polar_to_cartesian(T phi, T theta, R r, P& p)
+    {
+        assert_dimension<P, 3>();
+
+        // http://en.wikipedia.org/wiki/List_of_canonical_coordinate_transformations#From_spherical_coordinates
+        // http://www.vias.org/comp_geometry/math_coord_convert_3d.htm
+        // https://moodle.polymtl.ca/file.php/1183/Autres_Documents/Derivation_for_Spherical_Co-ordinates.pdf
+        // http://en.citizendium.org/wiki/Spherical_polar_coordinates
+
+        // Phi = first, theta is second, r is third, see documentation on cs::spherical
+
+        // (calculations are splitted to implement ttmath)
+
+        T r_sin_theta = r;
+        T r_cos_theta = r;
+        r_sin_theta *= sin(theta);
+        r_cos_theta *= cos(theta);
+
+        set<0>(p, r_sin_theta * cos(phi));
+        set<1>(p, r_sin_theta * sin(phi));
+        set<2>(p, r_cos_theta);
+    }
+
+    /// Helper function for conversion, lambda/delta (lon lat) are in radians
+    template <typename P, typename T, typename R>
+    inline void spherical_equatorial_to_cartesian(T lambda, T delta, R r, P& p)
+    {
+        assert_dimension<P, 3>();
+
+        // http://mathworld.wolfram.com/GreatCircle.html
+        // http://www.spenvis.oma.be/help/background/coortran/coortran.html WRONG
+
+        T r_cos_delta = r;
+        T r_sin_delta = r;
+        r_cos_delta *= cos(delta);
+        r_sin_delta *= sin(delta);
+
+        set<0>(p, r_cos_delta * cos(lambda));
+        set<1>(p, r_cos_delta * sin(lambda));
+        set<2>(p, r_sin_delta);
+    }
+
+
+    /// Helper function for conversion
+    template <typename P, typename T>
+    inline bool cartesian_to_spherical2(T x, T y, T z, P& p)
+    {
+        assert_dimension<P, 2>();
+
+        // http://en.wikipedia.org/wiki/List_of_canonical_coordinate_transformations#From_Cartesian_coordinates
+
+#if defined(BOOST_GEOMETRY_TRANSFORM_CHECK_UNIT_SPHERE)
+        // TODO: MAYBE ONLY IF TO BE CHECKED?
+        T const r = /*sqrt not necessary, sqrt(1)=1*/ (x * x + y * y + z * z);
+
+        // Unit sphere, so r should be 1
+        if (geometry::math::abs(r - 1.0) > T(1e-6))
+        {
+            return false;
+        }
+        // end todo
+#endif
+
+        set_from_radian<0>(p, atan2(y, x));
+        set_from_radian<1>(p, acos(z));
+        return true;
+    }
+
+    template <typename P, typename T>
+    inline bool cartesian_to_spherical_equatorial2(T x, T y, T z, P& p)
+    {
+        assert_dimension<P, 2>();
+
+        set_from_radian<0>(p, atan2(y, x));
+        set_from_radian<1>(p, asin(z));
+        return true;
+    }
+
+
+    template <typename P, typename T>
+    inline bool cartesian_to_spherical3(T x, T y, T z, P& p)
+    {
+        assert_dimension<P, 3>();
+
+        // http://en.wikipedia.org/wiki/List_of_canonical_coordinate_transformations#From_Cartesian_coordinates
+        T const r = math::sqrt(x * x + y * y + z * z);
+        set<2>(p, r);
+        set_from_radian<0>(p, atan2(y, x));
+        if (r > 0.0)
+        {
+            set_from_radian<1>(p, acos(z / r));
+            return true;
+        }
+        return false;
+    }
+
+    template <typename P, typename T>
+    inline bool cartesian_to_spherical_equatorial3(T x, T y, T z, P& p)
+    {
+        assert_dimension<P, 3>();
+
+        // http://en.wikipedia.org/wiki/List_of_canonical_coordinate_transformations#From_Cartesian_coordinates
+        T const r = math::sqrt(x * x + y * y + z * z);
+        set<2>(p, r);
+        set_from_radian<0>(p, atan2(y, x));
+        if (r > 0.0)
+        {
+            set_from_radian<1>(p, asin(z / r));
+            return true;
+        }
+        return false;
+    }
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+/*!
+    \brief Transformation strategy for 2D spherical (phi,theta) to 3D cartesian (x,y,z)
+    \details on Unit sphere
+    \ingroup transform
+    \tparam P1 first point type
+    \tparam P2 second point type
+ */
+template <typename P1, typename P2>
+struct from_spherical_polar_2_to_cartesian_3
+{
+    inline bool apply(P1 const& p1, P2& p2) const
+    {
+        assert_dimension<P1, 2>();
+        detail::spherical_polar_to_cartesian(get_as_radian<0>(p1), get_as_radian<1>(p1), 1.0, p2);
+        return true;
+    }
+};
+
+template <typename P1, typename P2>
+struct from_spherical_equatorial_2_to_cartesian_3
+{
+    inline bool apply(P1 const& p1, P2& p2) const
+    {
+        assert_dimension<P1, 2>();
+        detail::spherical_equatorial_to_cartesian(get_as_radian<0>(p1), get_as_radian<1>(p1), 1.0, p2);
+        return true;
+    }
+};
+
+
+/*!
+    \brief Transformation strategy for 3D spherical (phi,theta,r) to 3D cartesian (x,y,z)
+    \ingroup transform
+    \tparam P1 first point type
+    \tparam P2 second point type
+ */
+template <typename P1, typename P2>
+struct from_spherical_polar_3_to_cartesian_3
+{
+    inline bool apply(P1 const& p1, P2& p2) const
+    {
+        assert_dimension<P1, 3>();
+        detail::spherical_polar_to_cartesian(
+                    get_as_radian<0>(p1), get_as_radian<1>(p1), get<2>(p1), p2);
+        return true;
+    }
+};
+
+template <typename P1, typename P2>
+struct from_spherical_equatorial_3_to_cartesian_3
+{
+    inline bool apply(P1 const& p1, P2& p2) const
+    {
+        assert_dimension<P1, 3>();
+        detail::spherical_equatorial_to_cartesian(
+                    get_as_radian<0>(p1), get_as_radian<1>(p1), get<2>(p1), p2);
+        return true;
+    }
+};
+
+
+/*!
+    \brief Transformation strategy for 3D cartesian (x,y,z) to 2D spherical (phi,theta)
+    \details on Unit sphere
+    \ingroup transform
+    \tparam P1 first point type
+    \tparam P2 second point type
+    \note If x,y,z point is not lying on unit sphere, transformation will return false
+ */
+template <typename P1, typename P2>
+struct from_cartesian_3_to_spherical_polar_2
+{
+    inline bool apply(P1 const& p1, P2& p2) const
+    {
+        assert_dimension<P1, 3>();
+        return detail::cartesian_to_spherical2(get<0>(p1), get<1>(p1), get<2>(p1), p2);
+    }
+};
+
+template <typename P1, typename P2>
+struct from_cartesian_3_to_spherical_equatorial_2
+{
+    inline bool apply(P1 const& p1, P2& p2) const
+    {
+        assert_dimension<P1, 3>();
+        return detail::cartesian_to_spherical_equatorial2(get<0>(p1), get<1>(p1), get<2>(p1), p2);
+    }
+};
+
+
+/*!
+    \brief Transformation strategy for 3D cartesian (x,y,z) to 3D spherical (phi,theta,r)
+    \ingroup transform
+    \tparam P1 first point type
+    \tparam P2 second point type
+ */
+template <typename P1, typename P2>
+struct from_cartesian_3_to_spherical_polar_3
+{
+    inline bool apply(P1 const& p1, P2& p2) const
+    {
+        assert_dimension<P1, 3>();
+        return detail::cartesian_to_spherical3(get<0>(p1), get<1>(p1), get<2>(p1), p2);
+    }
+};
+
+template <typename P1, typename P2>
+struct from_cartesian_3_to_spherical_equatorial_3
+{
+    inline bool apply(P1 const& p1, P2& p2) const
+    {
+        assert_dimension<P1, 3>();
+        return detail::cartesian_to_spherical_equatorial3(get<0>(p1), get<1>(p1), get<2>(p1), p2);
+    }
+};
+
+#ifndef DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+namespace services
+{
+
+/// Specialization for same coordinate system family, same system, same dimension, same point type, can be copied
+template <typename CoordSysTag, typename CoordSys, std::size_t D, typename P>
+struct default_strategy<CoordSysTag, CoordSysTag, CoordSys, CoordSys, D, D, P, P>
+{
+    typedef copy_direct<P> type;
+};
+
+/// Specialization for same coordinate system family and system, same dimension, different point type, copy per coordinate
+template <typename CoordSysTag, typename CoordSys, std::size_t D, typename P1, typename P2>
+struct default_strategy<CoordSysTag, CoordSysTag, CoordSys, CoordSys, D, D, P1, P2>
+{
+    typedef copy_per_coordinate<P1, P2> type;
+};
+
+/// Specialization to transform from degree to radian for any coordinate system / point type combination
+template <typename CoordSysTag, template<typename> class CoordSys, typename P1, typename P2>
+struct default_strategy<CoordSysTag, CoordSysTag, CoordSys<degree>, CoordSys<radian>, 2, 2, P1, P2>
+{
+    typedef degree_radian_vv<P1, P2, std::multiplies> type;
+};
+
+/// Specialization to transform from radian to degree for any coordinate system / point type combination
+template <typename CoordSysTag, template<typename> class CoordSys, typename P1, typename P2>
+struct default_strategy<CoordSysTag, CoordSysTag, CoordSys<radian>, CoordSys<degree>, 2, 2, P1, P2>
+{
+    typedef degree_radian_vv<P1, P2, std::divides> type;
+};
+
+
+/// Specialization degree->radian in 3D
+template <typename CoordSysTag, template<typename> class CoordSys, typename P1, typename P2>
+struct default_strategy<CoordSysTag, CoordSysTag, CoordSys<degree>, CoordSys<radian>, 3, 3, P1, P2>
+{
+    typedef degree_radian_vv_3<P1, P2, std::multiplies> type;
+};
+
+/// Specialization radian->degree in 3D
+template <typename CoordSysTag, template<typename> class CoordSys, typename P1, typename P2>
+struct default_strategy<CoordSysTag, CoordSysTag, CoordSys<radian>, CoordSys<degree>, 3, 3, P1, P2>
+{
+    typedef degree_radian_vv_3<P1, P2, std::divides> type;
+};
+
+/// Specialization to transform from unit sphere(phi,theta) to XYZ
+template <typename CoordSys1, typename CoordSys2, typename P1, typename P2>
+struct default_strategy<spherical_polar_tag, cartesian_tag, CoordSys1, CoordSys2, 2, 3, P1, P2>
+{
+    typedef from_spherical_polar_2_to_cartesian_3<P1, P2> type;
+};
+
+/// Specialization to transform from sphere(phi,theta,r) to XYZ
+template <typename CoordSys1, typename CoordSys2, typename P1, typename P2>
+struct default_strategy<spherical_polar_tag, cartesian_tag, CoordSys1, CoordSys2, 3, 3, P1, P2>
+{
+    typedef from_spherical_polar_3_to_cartesian_3<P1, P2> type;
+};
+
+template <typename CoordSys1, typename CoordSys2, typename P1, typename P2>
+struct default_strategy<spherical_equatorial_tag, cartesian_tag, CoordSys1, CoordSys2, 2, 3, P1, P2>
+{
+    typedef from_spherical_equatorial_2_to_cartesian_3<P1, P2> type;
+};
+
+template <typename CoordSys1, typename CoordSys2, typename P1, typename P2>
+struct default_strategy<spherical_equatorial_tag, cartesian_tag, CoordSys1, CoordSys2, 3, 3, P1, P2>
+{
+    typedef from_spherical_equatorial_3_to_cartesian_3<P1, P2> type;
+};
+
+/// Specialization to transform from XYZ to unit sphere(phi,theta)
+template <typename CoordSys1, typename CoordSys2, typename P1, typename P2>
+struct default_strategy<cartesian_tag, spherical_polar_tag, CoordSys1, CoordSys2, 3, 2, P1, P2>
+{
+    typedef from_cartesian_3_to_spherical_polar_2<P1, P2> type;
+};
+
+template <typename CoordSys1, typename CoordSys2, typename P1, typename P2>
+struct default_strategy<cartesian_tag, spherical_equatorial_tag, CoordSys1, CoordSys2, 3, 2, P1, P2>
+{
+    typedef from_cartesian_3_to_spherical_equatorial_2<P1, P2> type;
+};
+
+/// Specialization to transform from XYZ to sphere(phi,theta,r)
+template <typename CoordSys1, typename CoordSys2, typename P1, typename P2>
+struct default_strategy<cartesian_tag, spherical_polar_tag, CoordSys1, CoordSys2, 3, 3, P1, P2>
+{
+    typedef from_cartesian_3_to_spherical_polar_3<P1, P2> type;
+};
+template <typename CoordSys1, typename CoordSys2, typename P1, typename P2>
+struct default_strategy<cartesian_tag, spherical_equatorial_tag, CoordSys1, CoordSys2, 3, 3, P1, P2>
+{
+    typedef from_cartesian_3_to_spherical_equatorial_3<P1, P2> type;
+};
+
+
+} // namespace services
+
+
+#endif // DOXYGEN_NO_STRATEGY_SPECIALIZATIONS
+
+
+}} // namespace strategy::transform
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_STRATEGY_TRANSFORM_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/tags.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/tags.hpp
new file mode 100644
index 00000000000..7589c21071e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/tags.hpp
@@ -0,0 +1,43 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_TAGS_HPP
+#define BOOST_GEOMETRY_STRATEGIES_TAGS_HPP
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy
+{
+    /*!
+        \brief Indicate compiler/library user that strategy is not implemented.
+        \details Strategies are defined for point types or for point type
+        combinations. If there is no implementation for that specific point type, or point type
+        combination, the calculation cannot be done. To indicate this, this not_implemented
+        class is used as a typedef stub.
+
+    */
+    struct not_implemented {};
+}
+
+
+struct strategy_tag_distance_point_point {};
+struct strategy_tag_distance_point_segment {};
+struct strategy_tag_distance_point_box {};
+struct strategy_tag_distance_box_box {};
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_TAGS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/transform.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/transform.hpp
new file mode 100644
index 00000000000..3c806acac69
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/transform.hpp
@@ -0,0 +1,63 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_TRANSFORM_HPP
+#define BOOST_GEOMETRY_STRATEGIES_TRANSFORM_HPP
+
+#include <cstddef>
+
+#include <boost/mpl/assert.hpp>
+
+#include <boost/geometry/strategies/tags.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace transform { namespace services
+{
+
+/*!
+    \brief Traits class binding a transformation strategy to a coordinate system
+    \ingroup transform
+    \details Can be specialized
+    - per coordinate system family (tag)
+    - per coordinate system (or groups of them)
+    - per dimension
+    - per point type
+    \tparam CoordinateSystemTag 1,2 coordinate system tags
+    \tparam CoordinateSystem 1,2 coordinate system
+    \tparam D 1, 2 dimension
+    \tparam Point 1, 2 point type
+ */
+template
+<
+    typename CoordinateSystemTag1, typename CoordinateSystemTag2,
+    typename CoordinateSystem1, typename CoordinateSystem2,
+    std::size_t Dimension1, std::size_t Dimension2,
+    typename Point1, typename Point2
+>
+struct default_strategy
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_POINT_TYPES
+            , (types<Point1, Point2>)
+        );
+};
+
+}}} // namespace strategy::transform::services
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_TRANSFORM_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/transform/inverse_transformer.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/transform/inverse_transformer.hpp
new file mode 100644
index 00000000000..5213bce47ad
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/transform/inverse_transformer.hpp
@@ -0,0 +1,57 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_TRANSFORM_INVERSE_TRANSFORMER_HPP
+#define BOOST_GEOMETRY_STRATEGIES_TRANSFORM_INVERSE_TRANSFORMER_HPP
+
+#include <boost/qvm/mat.hpp>
+#include <boost/qvm/mat_operations.hpp>
+
+#include <boost/geometry/strategies/transform/matrix_transformers.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace transform
+{
+
+/*!
+\brief Transformation strategy to do an inverse transformation in a Cartesian coordinate system
+\ingroup strategies
+ */
+template
+<
+    typename CalculationType,
+    std::size_t Dimension1,
+    std::size_t Dimension2
+>
+class inverse_transformer
+    : public matrix_transformer<CalculationType, Dimension1, Dimension2>
+{
+public :
+    template <typename Transformer>
+    inline inverse_transformer(Transformer const& input)
+    {
+        this->m_matrix = boost::qvm::inverse(input.matrix());
+    }
+
+};
+
+
+}} // namespace strategy::transform
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_STRATEGIES_TRANSFORM_INVERSE_TRANSFORMER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/transform/map_transformer.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/transform/map_transformer.hpp
new file mode 100644
index 00000000000..01ea6168c56
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/transform/map_transformer.hpp
@@ -0,0 +1,172 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_TRANSFORM_MAP_TRANSFORMER_HPP
+#define BOOST_GEOMETRY_STRATEGIES_TRANSFORM_MAP_TRANSFORMER_HPP
+
+
+#include <cstddef>
+
+#include <boost/geometry/strategies/transform/matrix_transformers.hpp>
+
+namespace boost { namespace geometry
+{
+
+// Silence warning C4127: conditional expression is constant
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4127)
+#endif
+
+namespace strategy { namespace transform
+{
+
+/*!
+\brief Transformation strategy to map from one to another Cartesian coordinate system
+\ingroup strategies
+\tparam Mirror if true map is mirrored upside-down (in most cases pixels
+    are from top to bottom, while map is from bottom to top)
+ */
+template
+<
+    typename CalculationType,
+    std::size_t Dimension1,
+    std::size_t Dimension2,
+    bool Mirror = false,
+    bool SameScale = true
+>
+class map_transformer
+    : public matrix_transformer<CalculationType, Dimension1, Dimension2>
+{
+    typedef boost::qvm::mat<CalculationType, Dimension1 + 1, Dimension2 + 1> M;
+    typedef boost::qvm::mat<CalculationType, 3, 3> matrix33;
+
+public :
+    template <typename B, typename D>
+    explicit inline map_transformer(B const& box, D const& width, D const& height)
+    {
+        set_transformation(
+                get<min_corner, 0>(box), get<min_corner, 1>(box),
+                get<max_corner, 0>(box), get<max_corner, 1>(box),
+                width, height);
+    }
+
+    template <typename W, typename D>
+    explicit inline map_transformer(W const& wx1, W const& wy1, W const& wx2, W const& wy2,
+                        D const& width, D const& height)
+    {
+        set_transformation(wx1, wy1, wx2, wy2, width, height);
+    }
+
+
+private :
+    template <typename W, typename P, typename S>
+    inline void set_transformation_point(W const& wx, W const& wy,
+        P const& px, P const& py,
+        S const& scalex, S const& scaley)
+    {
+
+        // Translate to a coordinate system centered on world coordinates (-wx, -wy)
+        matrix33 t1;
+        qvm::A<0,0>(t1) = 1;   qvm::A<0,1>(t1) = 0;   qvm::A<0,2>(t1) = -wx;
+        qvm::A<1,0>(t1) = 0;   qvm::A<1,1>(t1) = 1;   qvm::A<1,2>(t1) = -wy;
+        qvm::A<2,0>(t1) = 0;   qvm::A<2,1>(t1) = 0;   qvm::A<2,2>(t1) = 1;
+
+        // Scale the map
+        matrix33 s;
+        qvm::A<0,0>(s) = scalex;   qvm::A<0,1>(s) = 0;      qvm::A<0,2>(s) = 0;
+        qvm::A<1,0>(s) = 0;        qvm::A<1,1>(s) = scaley; qvm::A<1,2>(s) = 0;
+        qvm::A<2,0>(s) = 0;        qvm::A<2,1>(s) = 0;      qvm::A<2,2>(s) = 1;
+
+        // Translate to a coordinate system centered on the specified pixels (+px, +py)
+        matrix33 t2;
+        qvm::A<0,0>(t2) = 1;   qvm::A<0,1>(t2) = 0;   qvm::A<0,2>(t2) = px;
+        qvm::A<1,0>(t2) = 0;   qvm::A<1,1>(t2) = 1;   qvm::A<1,2>(t2) = py;
+        qvm::A<2,0>(t2) = 0;   qvm::A<2,1>(t2) = 0;   qvm::A<2,2>(t2) = 1;
+
+        // Calculate combination matrix in two steps
+        this->m_matrix = s * t1;
+        this->m_matrix = t2 * this->m_matrix;
+    }
+
+
+    template <typename W, typename D>
+    void set_transformation(W const& wx1, W const& wy1, W const& wx2, W const& wy2,
+                    D const& width, D const& height)
+    {
+        D px1 = 0;
+        D py1 = 0;
+        D px2 = width;
+        D py2 = height;
+
+        // Get the same type, but at least a double
+        typedef typename select_most_precise<D, double>::type type;
+
+
+        // Calculate appropriate scale, take min because whole box must fit
+        // Scale is in PIXELS/MAPUNITS (meters)
+        W wdx = wx2 - wx1;
+        W wdy = wy2 - wy1;
+        type sx = (px2 - px1) / boost::numeric_cast<type>(wdx);
+        type sy = (py2 - py1) / boost::numeric_cast<type>(wdy);
+
+        if (SameScale)
+        {
+            type scale = (std::min)(sx, sy);
+            sx = scale;
+            sy = scale;
+        }
+
+        // Calculate centerpoints
+        W wtx = wx1 + wx2;
+        W wty = wy1 + wy2;
+        W two = 2;
+        W wmx = wtx / two;
+        W wmy = wty / two;
+        type pmx = (px1 + px2) / 2.0;
+        type pmy = (py1 + py2) / 2.0;
+
+        set_transformation_point(wmx, wmy, pmx, pmy, sx, sy);
+
+        if (Mirror)
+        {
+            // Mirror in y-direction
+            matrix33 m;
+            qvm::A<0,0>(m) = 1;   qvm::A<0,1>(m) = 0;   qvm::A<0,2>(m) = 0;
+            qvm::A<1,0>(m) = 0;   qvm::A<1,1>(m) = -1;  qvm::A<1,2>(m) = 0;
+            qvm::A<2,0>(m) = 0;   qvm::A<2,1>(m) = 0;   qvm::A<2,2>(m) = 1;
+
+            // Translate in y-direction such that it fits again
+            matrix33 y;
+            qvm::A<0,0>(y) = 1;   qvm::A<0,1>(y) = 0;   qvm::A<0,2>(y) = 0;
+            qvm::A<1,0>(y) = 0;   qvm::A<1,1>(y) = 1;   qvm::A<1,2>(y) = height;
+            qvm::A<2,0>(y) = 0;   qvm::A<2,1>(y) = 0;   qvm::A<2,2>(y) = 1;
+
+            // Calculate combination matrix in two steps
+            this->m_matrix = m * this->m_matrix;
+            this->m_matrix = y * this->m_matrix;
+        }
+    }
+};
+
+
+}} // namespace strategy::transform
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_TRANSFORM_MAP_TRANSFORMER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/transform/matrix_transformers.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/transform/matrix_transformers.hpp
new file mode 100644
index 00000000000..e0ac6496f3d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/transform/matrix_transformers.hpp
@@ -0,0 +1,399 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_TRANSFORM_MATRIX_TRANSFORMERS_HPP
+#define BOOST_GEOMETRY_STRATEGIES_TRANSFORM_MATRIX_TRANSFORMERS_HPP
+
+
+#include <cstddef>
+
+#include <boost/qvm/mat.hpp>
+#include <boost/qvm/mat_access.hpp>
+#include <boost/qvm/mat_operations.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/promote_floating_point.hpp>
+#include <boost/geometry/util/select_coordinate_type.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace transform
+{
+
+/*!
+\brief Affine transformation strategy in Cartesian system.
+\details The strategy serves as a generic definition of affine transformation matrix
+         and procedure of application it to given point.
+\see http://en.wikipedia.org/wiki/Affine_transformation
+     and http://www.devmaster.net/wiki/Transformation_matrices
+\ingroup strategies
+\tparam Dimension1 number of dimensions to transform from
+\tparam Dimension2 number of dimensions to transform to
+ */
+template
+<
+    typename CalculationType,
+    std::size_t Dimension1,
+    std::size_t Dimension2
+>
+class matrix_transformer
+{
+};
+
+
+template <typename CalculationType>
+class matrix_transformer<CalculationType, 2, 2>
+{
+protected :
+    typedef CalculationType ct;
+    typedef boost::qvm::mat<ct, 3, 3> matrix_type;
+    matrix_type m_matrix;
+
+public :
+
+    inline matrix_transformer(
+                ct const& m_0_0, ct const& m_0_1, ct const& m_0_2,
+                ct const& m_1_0, ct const& m_1_1, ct const& m_1_2,
+                ct const& m_2_0, ct const& m_2_1, ct const& m_2_2)
+    {
+        qvm::A<0,0>(m_matrix) = m_0_0;   qvm::A<0,1>(m_matrix) = m_0_1;   qvm::A<0,2>(m_matrix) = m_0_2;
+        qvm::A<1,0>(m_matrix) = m_1_0;   qvm::A<1,1>(m_matrix) = m_1_1;   qvm::A<1,2>(m_matrix) = m_1_2;
+        qvm::A<2,0>(m_matrix) = m_2_0;   qvm::A<2,1>(m_matrix) = m_2_1;   qvm::A<2,2>(m_matrix) = m_2_2;
+    }
+
+    inline matrix_transformer(matrix_type const& matrix)
+        : m_matrix(matrix)
+    {}
+
+
+    inline matrix_transformer() {}
+
+    template <typename P1, typename P2>
+    inline bool apply(P1 const& p1, P2& p2) const
+    {
+        assert_dimension_greater_equal<P1, 2>();
+        assert_dimension_greater_equal<P2, 2>();
+
+        ct const& c1 = get<0>(p1);
+        ct const& c2 = get<1>(p1);
+
+        ct p2x = c1 * qvm::A<0,0>(m_matrix) + c2 * qvm::A<0,1>(m_matrix) + qvm::A<0,2>(m_matrix);
+        ct p2y = c1 * qvm::A<1,0>(m_matrix) + c2 * qvm::A<1,1>(m_matrix) + qvm::A<1,2>(m_matrix);
+
+        typedef typename geometry::coordinate_type<P2>::type ct2;
+        set<0>(p2, boost::numeric_cast<ct2>(p2x));
+        set<1>(p2, boost::numeric_cast<ct2>(p2y));
+
+        return true;
+    }
+
+    matrix_type const& matrix() const { return m_matrix; }
+};
+
+
+// It IS possible to go from 3 to 2 coordinates
+template <typename CalculationType>
+class matrix_transformer<CalculationType, 3, 2> : public matrix_transformer<CalculationType, 2, 2>
+{
+    typedef CalculationType ct;
+
+public :
+    inline matrix_transformer(
+                ct const& m_0_0, ct const& m_0_1, ct const& m_0_2,
+                ct const& m_1_0, ct const& m_1_1, ct const& m_1_2,
+                ct const& m_2_0, ct const& m_2_1, ct const& m_2_2)
+        : matrix_transformer<CalculationType, 2, 2>(
+                    m_0_0, m_0_1, m_0_2,
+                    m_1_0, m_1_1, m_1_2,
+                    m_2_0, m_2_1, m_2_2)
+    {}
+
+    inline matrix_transformer()
+        : matrix_transformer<CalculationType, 2, 2>()
+    {}
+};
+
+
+template <typename CalculationType>
+class matrix_transformer<CalculationType, 3, 3>
+{
+protected :
+    typedef CalculationType ct;
+    typedef boost::qvm::mat<ct, 4, 4> matrix_type;
+    matrix_type m_matrix;
+
+public :
+    inline matrix_transformer(
+                ct const& m_0_0, ct const& m_0_1, ct const& m_0_2, ct const& m_0_3,
+                ct const& m_1_0, ct const& m_1_1, ct const& m_1_2, ct const& m_1_3,
+                ct const& m_2_0, ct const& m_2_1, ct const& m_2_2, ct const& m_2_3,
+                ct const& m_3_0, ct const& m_3_1, ct const& m_3_2, ct const& m_3_3
+                )
+    {
+        qvm::A<0,0>(m_matrix) = m_0_0; qvm::A<0,1>(m_matrix) = m_0_1; qvm::A<0,2>(m_matrix) = m_0_2; qvm::A<0,3>(m_matrix) = m_0_3;
+        qvm::A<1,0>(m_matrix) = m_1_0; qvm::A<1,1>(m_matrix) = m_1_1; qvm::A<1,2>(m_matrix) = m_1_2; qvm::A<1,3>(m_matrix) = m_1_3;
+        qvm::A<2,0>(m_matrix) = m_2_0; qvm::A<2,1>(m_matrix) = m_2_1; qvm::A<2,2>(m_matrix) = m_2_2; qvm::A<2,3>(m_matrix) = m_2_3;
+        qvm::A<3,0>(m_matrix) = m_3_0; qvm::A<3,1>(m_matrix) = m_3_1; qvm::A<3,2>(m_matrix) = m_3_2; qvm::A<3,3>(m_matrix) = m_3_3;
+    }
+
+    inline matrix_transformer() {}
+
+    template <typename P1, typename P2>
+    inline bool apply(P1 const& p1, P2& p2) const
+    {
+        ct const& c1 = get<0>(p1);
+        ct const& c2 = get<1>(p1);
+        ct const& c3 = get<2>(p1);
+
+        typedef typename geometry::coordinate_type<P2>::type ct2;
+
+        set<0>(p2, boost::numeric_cast<ct2>(
+            c1 * m_matrix(0,0) + c2 * m_matrix(0,1) + c3 * m_matrix(0,2) + m_matrix(0,3)));
+        set<1>(p2, boost::numeric_cast<ct2>(
+            c1 * m_matrix(1,0) + c2 * m_matrix(1,1) + c3 * m_matrix(1,2) + m_matrix(1,3)));
+        set<2>(p2, boost::numeric_cast<ct2>(
+            c1 * m_matrix(2,0) + c2 * m_matrix(2,1) + c3 * m_matrix(2,2) + m_matrix(2,3)));
+
+        return true;
+    }
+
+    matrix_type const& matrix() const { return m_matrix; }
+};
+
+
+/*!
+\brief Strategy of translate transformation in Cartesian system.
+\details Translate moves a geometry a fixed distance in 2 or 3 dimensions.
+\see http://en.wikipedia.org/wiki/Translation_%28geometry%29
+\ingroup strategies
+\tparam Dimension1 number of dimensions to transform from
+\tparam Dimension2 number of dimensions to transform to
+ */
+template
+<
+    typename CalculationType,
+    std::size_t Dimension1,
+    std::size_t Dimension2
+>
+class translate_transformer
+{
+};
+
+
+template<typename CalculationType>
+class translate_transformer<CalculationType, 2, 2> : public matrix_transformer<CalculationType, 2, 2>
+{
+public :
+    // To have translate transformers compatible for 2/3 dimensions, the
+    // constructor takes an optional third argument doing nothing.
+    inline translate_transformer(CalculationType const& translate_x,
+                CalculationType const& translate_y,
+                CalculationType const& = 0)
+        : matrix_transformer<CalculationType, 2, 2>(
+                1, 0, translate_x,
+                0, 1, translate_y,
+                0, 0, 1)
+    {}
+};
+
+
+template <typename CalculationType>
+class translate_transformer<CalculationType, 3, 3> : public matrix_transformer<CalculationType, 3, 3>
+{
+public :
+    inline translate_transformer(CalculationType const& translate_x,
+                CalculationType const& translate_y,
+                CalculationType const& translate_z)
+        : matrix_transformer<CalculationType, 3, 3>(
+                1, 0, 0, translate_x,
+                0, 1, 0, translate_y,
+                0, 0, 1, translate_z,
+                0, 0, 0, 1)
+    {}
+
+};
+
+
+/*!
+\brief Strategy of scale transformation in Cartesian system.
+\details Scale scales a geometry up or down in all its dimensions.
+\see http://en.wikipedia.org/wiki/Scaling_%28geometry%29
+\ingroup strategies
+\tparam Dimension1 number of dimensions to transform from
+\tparam Dimension2 number of dimensions to transform to
+*/
+template
+<
+    typename CalculationType,
+    std::size_t Dimension1,
+    std::size_t Dimension2
+>
+class scale_transformer
+{
+};
+
+
+template <typename CalculationType>
+class scale_transformer<CalculationType, 2, 2> : public matrix_transformer<CalculationType, 2, 2>
+{
+
+public :
+    inline scale_transformer(CalculationType const& scale_x,
+                CalculationType const& scale_y,
+                CalculationType const& = 0)
+        : matrix_transformer<CalculationType, 2, 2>(
+                scale_x, 0,       0,
+                0,       scale_y, 0,
+                0,       0,       1)
+    {}
+
+
+    inline scale_transformer(CalculationType const& scale)
+        : matrix_transformer<CalculationType, 2, 2>(
+                scale, 0,     0,
+                0,     scale, 0,
+                0,     0,     1)
+    {}
+};
+
+
+template <typename CalculationType>
+class scale_transformer<CalculationType, 3, 3> : public matrix_transformer<CalculationType, 3, 3>
+{
+public :
+    inline scale_transformer(CalculationType const& scale_x,
+                CalculationType const& scale_y,
+                CalculationType const& scale_z)
+        : matrix_transformer<CalculationType, 3, 3>(
+                scale_x, 0,       0,       0,
+                0,       scale_y, 0,       0,
+                0,       0,       scale_z, 0,
+                0,       0,       0,       1)
+    {}
+
+
+    inline scale_transformer(CalculationType const& scale)
+        : matrix_transformer<CalculationType, 3, 3>(
+                scale, 0,     0,     0,
+                0,     scale, 0,     0,
+                0,     0,     scale, 0,
+                0,     0,     0,     1)
+    {}
+};
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+
+template <typename DegreeOrRadian>
+struct as_radian
+{};
+
+
+template <>
+struct as_radian<radian>
+{
+    template <typename T>
+    static inline T get(T const& value)
+    {
+        return value;
+    }
+};
+
+template <>
+struct as_radian<degree>
+{
+    template <typename T>
+    static inline T get(T const& value)
+    {
+        typedef typename promote_floating_point<T>::type promoted_type;
+        return value * math::d2r<promoted_type>();
+    }
+
+};
+
+
+template
+<
+    typename CalculationType,
+    std::size_t Dimension1,
+    std::size_t Dimension2
+>
+class rad_rotate_transformer
+    : public matrix_transformer<CalculationType, Dimension1, Dimension2>
+{
+public :
+    inline rad_rotate_transformer(CalculationType const& angle)
+        : matrix_transformer<CalculationType, Dimension1, Dimension2>(
+                 cos(angle), sin(angle), 0,
+                -sin(angle), cos(angle), 0,
+                 0,          0,          1)
+    {}
+};
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+/*!
+\brief Strategy for rotate transformation in Cartesian coordinate system.
+\details Rotate rotates a geometry of specified angle about a fixed point (e.g. origin).
+\see http://en.wikipedia.org/wiki/Rotation_%28mathematics%29
+\ingroup strategies
+\tparam DegreeOrRadian degree/or/radian, type of rotation angle specification
+\note A single angle is needed to specify a rotation in 2D.
+      Not yet in 3D, the 3D version requires special things to allow
+      for rotation around X, Y, Z or arbitrary axis.
+\todo The 3D version will not compile.
+ */
+template
+<
+    typename DegreeOrRadian,
+    typename CalculationType,
+    std::size_t Dimension1,
+    std::size_t Dimension2
+>
+class rotate_transformer : public detail::rad_rotate_transformer<CalculationType, Dimension1, Dimension2>
+{
+
+public :
+    inline rotate_transformer(CalculationType const& angle)
+        : detail::rad_rotate_transformer
+            <
+                CalculationType, Dimension1, Dimension2
+            >(detail::as_radian<DegreeOrRadian>::get(angle))
+    {}
+};
+
+
+}} // namespace strategy::transform
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_TRANSFORM_MATRIX_TRANSFORMERS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/strategies/within.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/within.hpp
new file mode 100644
index 00000000000..28a3283db0d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/strategies/within.hpp
@@ -0,0 +1,98 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2017.
+// Modifications copyright (c) 2017, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_STRATEGIES_WITHIN_HPP
+#define BOOST_GEOMETRY_STRATEGIES_WITHIN_HPP
+
+#include <boost/mpl/assert.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/core/tag_cast.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace strategy { namespace within
+{
+
+
+namespace services
+{
+
+/*!
+\brief Traits class binding a within determination strategy to a coordinate system
+\ingroup within
+\tparam GeometryContained geometry-type of input (possibly) contained type
+\tparam GeometryContaining geometry-type of input (possibly) containing type
+\tparam TagContained casted tag of (possibly) contained type
+\tparam TagContaining casted tag of (possibly) containing type
+\tparam CsTagContained tag of coordinate system of (possibly) contained type
+\tparam CsTagContaining tag of coordinate system of (possibly) containing type
+*/
+template
+<
+    typename GeometryContained,
+    typename GeometryContaining,
+    typename TagContained = typename tag<GeometryContained>::type,
+    typename TagContaining = typename tag<GeometryContaining>::type,
+    typename CastedTagContained = typename tag_cast
+                                    <
+                                        typename tag<GeometryContained>::type,
+                                        pointlike_tag, linear_tag, polygonal_tag, areal_tag
+                                    >::type,
+    typename CastedTagContaining = typename tag_cast
+                                    <
+                                        typename tag<GeometryContaining>::type,
+                                        pointlike_tag, linear_tag, polygonal_tag, areal_tag
+                                    >::type,
+    typename CsTagContained = typename tag_cast
+                                <
+                                    typename cs_tag<typename point_type<GeometryContained>::type>::type,
+                                    spherical_tag
+                                >::type,
+    typename CsTagContaining = typename tag_cast
+                                <
+                                    typename cs_tag<typename point_type<GeometryContaining>::type>::type,
+                                    spherical_tag
+                                >::type
+>
+struct default_strategy
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THESE_TYPES
+            , (types<GeometryContained, GeometryContaining>)
+        );
+};
+
+
+} // namespace services
+
+
+}} // namespace strategy::within
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_STRATEGIES_WITHIN_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/add_const_if_c.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/add_const_if_c.hpp
new file mode 100644
index 00000000000..9e0c01299ce
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/add_const_if_c.hpp
@@ -0,0 +1,56 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_ADD_CONST_IF_C_HPP
+#define BOOST_GEOMETRY_UTIL_ADD_CONST_IF_C_HPP
+
+
+#include <boost/mpl/if.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+/*!
+    \brief Meta-function to define a const or non const type
+    \ingroup utility
+    \details If the boolean template parameter is true, the type parameter
+        will be defined as const, otherwise it will be defined as it was.
+        This meta-function is used to have one implementation for both
+        const and non const references
+    \note This traits class is completely independant from Boost.Geometry
+        and might be a separate addition to Boost
+    \note Used in a.o. for_each, interior_rings, exterior_ring
+    \par Example
+    \code
+        void foo(typename add_const_if_c<IsConst, Point>::type& point)
+    \endcode
+*/
+template <bool IsConst, typename Type>
+struct add_const_if_c
+{
+    typedef typename boost::mpl::if_c
+        <
+            IsConst,
+            Type const,
+            Type
+        >::type type;
+};
+
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_UTIL_ADD_CONST_IF_C_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/bare_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/bare_type.hpp
new file mode 100644
index 00000000000..26dd94a8ae9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/bare_type.hpp
@@ -0,0 +1,52 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_BARE_TYPE_HPP
+#define BOOST_GEOMETRY_UTIL_BARE_TYPE_HPP
+
+
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace util
+{
+
+template <typename T>
+struct bare_type
+{
+    typedef typename boost::remove_const
+        <
+            typename boost::remove_pointer
+                <
+                    typename boost::remove_reference
+                        <
+                            T
+                        >::type
+                >::type
+        >::type type;
+};
+
+
+} // namespace util
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_UTIL_BARE_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/calculation_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/calculation_type.hpp
new file mode 100644
index 00000000000..18eac4fbb7d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/calculation_type.hpp
@@ -0,0 +1,178 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2012 Mateusz Loskot, London, UK.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_CALCULATION_TYPE_HPP
+#define BOOST_GEOMETRY_UTIL_CALCULATION_TYPE_HPP
+
+#include <boost/config.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_floating_point.hpp>
+#include <boost/type_traits/is_fundamental.hpp>
+#include <boost/type_traits/is_void.hpp>
+
+#include <boost/geometry/util/select_coordinate_type.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace util
+{
+
+namespace detail
+{
+
+struct default_integral
+{
+#ifdef BOOST_HAS_LONG_LONG
+    typedef boost::long_long_type type;
+#else
+    typedef int type;
+#endif
+};
+
+/*!
+\details Selects the most appropriate:
+    - if calculation type is specified (not void), that one is used
+    - else if type is non-fundamental (user defined e.g. ttmath), that one
+    - else if type is floating point, the specified default FP is used
+    - else it is integral and the specified default integral is used
+ */
+template
+<
+    typename Type,
+    typename CalculationType,
+    typename DefaultFloatingPointCalculationType,
+    typename DefaultIntegralCalculationType
+>
+struct calculation_type
+{
+    BOOST_STATIC_ASSERT((
+        boost::is_fundamental
+            <
+                DefaultFloatingPointCalculationType
+            >::type::value
+        ));
+    BOOST_STATIC_ASSERT((
+        boost::is_fundamental
+            <
+                DefaultIntegralCalculationType
+            >::type::value
+        ));
+
+
+    typedef typename boost::mpl::if_
+        <
+            boost::is_void<CalculationType>,
+            typename boost::mpl::if_
+                <
+                    boost::is_floating_point<Type>,
+                    typename select_most_precise
+                        <
+                            DefaultFloatingPointCalculationType,
+                            Type
+                        >::type,
+                    typename select_most_precise
+                        <
+                            DefaultIntegralCalculationType,
+                            Type
+                        >::type
+                >::type,
+            CalculationType
+        >::type type;
+};
+
+} // namespace detail
+
+
+namespace calculation_type
+{
+
+namespace geometric
+{
+
+template
+<
+    typename Geometry,
+    typename CalculationType,
+    typename DefaultFloatingPointCalculationType = double,
+    typename DefaultIntegralCalculationType = detail::default_integral::type
+>
+struct unary
+{
+    typedef typename detail::calculation_type
+        <
+            typename geometry::coordinate_type<Geometry>::type,
+            CalculationType,
+            DefaultFloatingPointCalculationType,
+            DefaultIntegralCalculationType
+        >::type type;
+};
+
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename CalculationType,
+    typename DefaultFloatingPointCalculationType = double,
+    typename DefaultIntegralCalculationType = detail::default_integral::type
+>
+struct binary
+{
+    typedef typename detail::calculation_type
+        <
+            typename select_coordinate_type<Geometry1, Geometry2>::type,
+            CalculationType,
+            DefaultFloatingPointCalculationType,
+            DefaultIntegralCalculationType
+        >::type type;
+};
+
+
+/*!
+\brief calculation type (ternary, for three geometry types)
+ */
+template
+<
+    typename Geometry1,
+    typename Geometry2,
+    typename Geometry3,
+    typename CalculationType,
+    typename DefaultFloatingPointCalculationType = double,
+    typename DefaultIntegralCalculationType = detail::default_integral::type
+>
+struct ternary
+{
+    typedef typename detail::calculation_type
+        <
+            typename select_most_precise
+                <
+                    typename coordinate_type<Geometry1>::type,
+                    typename select_coordinate_type
+                        <
+                            Geometry2,
+                            Geometry3
+                        >::type
+                >::type,
+            CalculationType,
+            DefaultFloatingPointCalculationType,
+            DefaultIntegralCalculationType
+        >::type type;
+};
+
+}} // namespace calculation_type::geometric
+
+} // namespace util
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_UTIL_CALCULATION_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/closure_as_bool.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/closure_as_bool.hpp
new file mode 100644
index 00000000000..57fcd528008
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/closure_as_bool.hpp
@@ -0,0 +1,46 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_CLOSURE_AS_BOOL_HPP
+#define BOOST_GEOMETRY_UTIL_CLOSURE_AS_BOOL_HPP
+
+#include <boost/geometry/core/closure.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+template<closure_selector Closure>
+struct closure_as_bool
+{};
+
+
+template<>
+struct closure_as_bool<closed>
+{
+    static const bool value = true;
+};
+
+
+template<>
+struct closure_as_bool<open>
+{
+    static const bool value = false;
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_UTIL_CLOSURE_AS_BOOL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/combine_if.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/combine_if.hpp
new file mode 100644
index 00000000000..5d94c344613
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/combine_if.hpp
@@ -0,0 +1,92 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2014-2015 Samuel Debionne, Grenoble, France.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_COMBINE_IF_HPP
+#define BOOST_GEOMETRY_UTIL_COMBINE_IF_HPP
+
+#include <boost/mpl/fold.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/bind.hpp>
+#include <boost/mpl/set.hpp>
+#include <boost/mpl/insert.hpp>
+#include <boost/mpl/placeholders.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace util
+{
+
+
+/*!
+    \brief Meta-function to generate all the combination of pairs of types
+        from a given sequence Sequence except those that does not satisfy the
+        predicate Pred
+    \ingroup utility
+    \par Example
+    \code
+        typedef boost::mpl::vector<boost::mpl::int_<0>, boost::mpl::int_<1> > types;
+        typedef combine_if<types, types, always<true_> >::type combinations;
+        typedef boost::mpl::vector<
+            pair<boost::mpl::int_<1>, boost::mpl::int_<1> >,
+            pair<boost::mpl::int_<1>, boost::mpl::int_<0> >,
+            pair<boost::mpl::int_<0>, boost::mpl::int_<1> >,
+            pair<boost::mpl::int_<0>, boost::mpl::int_<0> >        
+        > result_types;
+        
+        BOOST_MPL_ASSERT(( boost::mpl::equal<combinations, result_types> ));
+    \endcode
+*/
+template <typename Sequence1, typename Sequence2, typename Pred>
+struct combine_if
+{
+    struct combine
+    {
+        template <typename Result, typename T>
+        struct apply
+        {
+            typedef typename boost::mpl::fold<Sequence2, Result,
+                boost::mpl::if_
+                <
+                    boost::mpl::bind
+                        <
+                            typename boost::mpl::lambda<Pred>::type,
+                            T,
+                            boost::mpl::_2
+                        >,
+                    boost::mpl::insert
+                        <
+                            boost::mpl::_1, boost::mpl::pair<T, boost::mpl::_2>
+                        >,
+                    boost::mpl::_1
+                >
+            >::type type;
+        };
+    };
+
+    typedef typename boost::mpl::fold
+        <
+            Sequence1, boost::mpl::set0<>, combine
+        >::type type;
+};
+
+
+} // namespace util
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_UTIL_COMBINE_IF_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/compress_variant.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/compress_variant.hpp
new file mode 100644
index 00000000000..363385965d4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/compress_variant.hpp
@@ -0,0 +1,106 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_COMPRESS_VARIANT_HPP
+#define BOOST_GEOMETRY_UTIL_COMPRESS_VARIANT_HPP
+
+
+#include <boost/mpl/equal_to.hpp>
+#include <boost/mpl/fold.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/insert.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/set.hpp>
+#include <boost/mpl/size.hpp>
+#include <boost/mpl/vector.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace detail
+{
+
+template <typename Variant>
+struct unique_types:
+    boost::mpl::fold<
+        typename boost::mpl::reverse_fold<
+            typename Variant::types,
+            boost::mpl::set<>,
+            boost::mpl::insert<
+                boost::mpl::placeholders::_1,
+                boost::mpl::placeholders::_2
+            >
+        >::type,
+        boost::mpl::vector<>,
+        boost::mpl::push_back
+            <
+                boost::mpl::placeholders::_1, boost::mpl::placeholders::_2
+            >
+    >
+{};
+
+template <typename Types>
+struct variant_or_single:
+    boost::mpl::if_<
+        boost::mpl::equal_to<
+            boost::mpl::size<Types>,
+            boost::mpl::int_<1>
+        >,
+        typename boost::mpl::front<Types>::type,
+        typename make_variant_over<Types>::type
+    >
+{};
+
+} // namespace detail
+
+
+/*!
+    \brief Meta-function that takes a boost::variant type and tries to minimize
+        it by doing the following:
+        - if there's any duplicate types, remove them
+        - if the result is a variant of one type, turn it into just that type
+    \ingroup utility
+    \par Example
+    \code
+        typedef variant<int, float, int, long> variant_type;
+        typedef compress_variant<variant_type>::type compressed;
+        typedef boost::mpl::vector<int, float, long> result_types;
+        BOOST_MPL_ASSERT(( boost::mpl::equal<compressed::types, result_types> ));
+
+        typedef variant<int, int, int> one_type_variant_type;
+        typedef compress_variant<one_type_variant_type>::type single_type;
+        BOOST_MPL_ASSERT(( boost::equals<single_type, int> ));
+    \endcode
+*/
+
+template <typename Variant>
+struct compress_variant:
+    detail::variant_or_single<
+        typename detail::unique_types<Variant>::type
+    >
+{};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_UTIL_COMPRESS_VARIANT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/condition.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/condition.hpp
new file mode 100644
index 00000000000..aea4ad3ad13
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/condition.hpp
@@ -0,0 +1,44 @@
+// Boost.Geometry
+
+// Copyright (c) 2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_CONDITION_HPP
+#define BOOST_GEOMETRY_UTIL_CONDITION_HPP
+
+
+#include <boost/config.hpp>
+
+
+// The macro defined in this file allows to suppress the MSVC
+// compiler warning C4127: conditional expression is constant
+
+#ifdef BOOST_MSVC
+
+// NOTE: The code commented out below contains an alternative implementation
+// of a macro using a free function. It was left here in case if in the future
+// version of MSVC for the code currently used in the macro implementation
+// the warning was generated.
+
+//#ifndef DOXYGEN_NO_DETAIL
+//namespace boost { namespace geometry { namespace detail {
+//BOOST_FORCEINLINE bool condition(bool const b) { return b; }
+//}}} // boost::geometry::detail
+//#endif // DOXYGEN_NO_DETAIL
+//#define BOOST_GEOMETRY_CONDITION(CONDITION) boost::geometry::detail::condition(CONDITION)
+
+#define BOOST_GEOMETRY_CONDITION(CONDITION) ((void)0, (CONDITION))
+
+#else
+
+#define BOOST_GEOMETRY_CONDITION(CONDITION) (CONDITION)
+
+#endif
+
+
+#endif // BOOST_GEOMETRY_UTIL_CONDITION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/coordinate_cast.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/coordinate_cast.hpp
new file mode 100644
index 00000000000..16a15cca5ba
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/coordinate_cast.hpp
@@ -0,0 +1,55 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_COORDINATE_CAST_HPP
+#define BOOST_GEOMETRY_UTIL_COORDINATE_CAST_HPP
+
+#include <cstdlib>
+#include <string>
+#include <boost/lexical_cast.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+/*!
+\brief cast coordinates from a string to a coordinate type
+\detail By default it uses lexical_cast. However, lexical_cast seems not to support
+    ttmath / partial specializations. Therefore this small utility is added.
+    See also "define_pi" where the same issue is solved
+*/
+template <typename CoordinateType>
+struct coordinate_cast
+{
+    static inline CoordinateType apply(std::string const& source)
+    {
+#if defined(BOOST_GEOMETRY_NO_LEXICAL_CAST)
+        return atof(source.c_str());
+#else
+        return boost::lexical_cast<CoordinateType>(source);
+#endif
+    }
+};
+
+
+} // namespace detail
+#endif
+
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_UTIL_COORDINATE_CAST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/for_each_coordinate.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/for_each_coordinate.hpp
new file mode 100644
index 00000000000..fb1e31856a9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/for_each_coordinate.hpp
@@ -0,0 +1,94 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_FOR_EACH_COORDINATE_HPP
+#define BOOST_GEOMETRY_UTIL_FOR_EACH_COORDINATE_HPP
+
+#include <boost/concept/requires.hpp>
+#include <boost/geometry/geometries/concepts/point_concept.hpp>
+#include <boost/geometry/util/add_const_if_c.hpp>
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <typename Point, int Dimension, int DimensionCount, bool IsConst>
+struct coordinates_scanner
+{
+    template <typename Op>
+    static inline Op apply(typename add_const_if_c
+        <
+            IsConst,
+            Point
+        >::type& point, Op operation)
+    {
+        operation.template apply<Point, Dimension>(point);
+        return coordinates_scanner
+            <
+                Point,
+                Dimension+1,
+                DimensionCount,
+                IsConst
+            >::apply(point, operation);
+    }
+};
+
+template <typename Point, int DimensionCount, bool IsConst>
+struct coordinates_scanner<Point, DimensionCount, DimensionCount, IsConst>
+{
+    template <typename Op>
+    static inline Op apply(typename add_const_if_c
+        <
+            IsConst,
+            Point
+        >::type& , Op operation)
+    {
+        return operation;
+    }
+};
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+template <typename Point, typename Op>
+inline void for_each_coordinate(Point& point, Op operation)
+{
+    BOOST_CONCEPT_ASSERT( (concepts::Point<Point>) );
+
+    typedef typename detail::coordinates_scanner
+        <
+            Point, 0, dimension<Point>::type::value, false
+        > scanner;
+
+    scanner::apply(point, operation);
+}
+
+template <typename Point, typename Op>
+inline Op for_each_coordinate(Point const& point, Op operation)
+{
+    BOOST_CONCEPT_ASSERT( (concepts::ConstPoint<Point>) );
+
+    typedef typename detail::coordinates_scanner
+        <
+            Point, 0, dimension<Point>::type::value, true
+        > scanner;
+
+    return scanner::apply(point, operation);
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_UTIL_FOR_EACH_COORDINATE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/has_infinite_coordinate.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/has_infinite_coordinate.hpp
new file mode 100644
index 00000000000..3f1d11a3b0f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/has_infinite_coordinate.hpp
@@ -0,0 +1,55 @@
+// Boost.Geometry
+
+// Copyright (c) 2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_HAS_INFINITE_COORDINATE_HPP
+#define BOOST_GEOMETRY_UTIL_HAS_INFINITE_COORDINATE_HPP
+
+#include <boost/type_traits/is_floating_point.hpp>
+
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/util/has_nan_coordinate.hpp>
+#include <boost/math/special_functions/fpclassify.hpp>
+
+namespace boost { namespace geometry
+{
+    
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+struct isinf
+{
+    template <typename T>
+    static inline bool apply(T const& t)
+    {
+        return boost::math::isinf(t);
+    }
+};
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+template <typename Point>
+bool has_infinite_coordinate(Point const& point)
+{
+    return detail::has_coordinate_with_property
+        <
+            Point,
+            detail::isinf,
+            boost::is_floating_point
+                <
+                    typename coordinate_type<Point>::type
+                >::value
+        >::apply(point);
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_UTIL_HAS_INFINITE_COORDINATE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/has_nan_coordinate.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/has_nan_coordinate.hpp
new file mode 100644
index 00000000000..93d7c7f0354
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/has_nan_coordinate.hpp
@@ -0,0 +1,99 @@
+// Boost.Geometry
+
+// Copyright (c) 2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_HAS_NAN_COORDINATE_HPP
+#define BOOST_GEOMETRY_UTIL_HAS_NAN_COORDINATE_HPP
+
+#include <cstddef>
+
+#include <boost/type_traits/is_floating_point.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+
+#include <boost/math/special_functions/fpclassify.hpp>
+
+
+namespace boost { namespace geometry
+{
+    
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+struct isnan
+{
+    template <typename T>
+    static inline bool apply(T const& t)
+    {
+        return boost::math::isnan(t);
+    }
+};
+
+template
+<
+    typename Point,
+    typename Predicate,
+    bool Enable,
+    std::size_t I = 0,
+    std::size_t N = geometry::dimension<Point>::value
+>
+struct has_coordinate_with_property
+{
+    static bool apply(Point const& point)
+    {
+        return Predicate::apply(geometry::get<I>(point))
+            || has_coordinate_with_property
+                <
+                    Point, Predicate, Enable, I+1, N
+                >::apply(point);
+    }
+};
+
+template <typename Point, typename Predicate, std::size_t I, std::size_t N>
+struct has_coordinate_with_property<Point, Predicate, false, I, N>
+{
+    static inline bool apply(Point const&)
+    {
+        return false;
+    }
+};
+
+template <typename Point, typename Predicate, std::size_t N>
+struct has_coordinate_with_property<Point, Predicate, true, N, N>
+{
+    static bool apply(Point const& )
+    {
+        return false;
+    }
+};
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+template <typename Point>
+bool has_nan_coordinate(Point const& point)
+{
+    return detail::has_coordinate_with_property
+        <
+            Point,
+            detail::isnan,
+            boost::is_floating_point
+                <
+                    typename coordinate_type<Point>::type
+                >::value
+        >::apply(point);
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_UTIL_HAS_NAN_COORDINATE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/has_non_finite_coordinate.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/has_non_finite_coordinate.hpp
new file mode 100644
index 00000000000..50075641ed6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/has_non_finite_coordinate.hpp
@@ -0,0 +1,55 @@
+// Boost.Geometry
+
+// Copyright (c) 2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_HAS_NON_FINITE_COORDINATE_HPP
+#define BOOST_GEOMETRY_UTIL_HAS_NON_FINITE_COORDINATE_HPP
+
+#include <boost/type_traits/is_floating_point.hpp>
+
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/util/has_nan_coordinate.hpp>
+#include <boost/math/special_functions/fpclassify.hpp>
+
+namespace boost { namespace geometry
+{
+    
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+struct is_not_finite
+{
+    template <typename T>
+    static inline bool apply(T const& t)
+    {
+        return ! boost::math::isfinite(t);
+    }
+};
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+template <typename Point>
+bool has_non_finite_coordinate(Point const& point)
+{
+    return detail::has_coordinate_with_property
+        <
+            Point,
+            detail::is_not_finite,
+            boost::is_floating_point
+                <
+                    typename coordinate_type<Point>::type
+                >::value
+        >::apply(point);
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_UTIL_HAS_NON_FINITE_COORDINATE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/math.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/math.hpp
new file mode 100644
index 00000000000..b1c3648c982
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/math.hpp
@@ -0,0 +1,779 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014, 2015.
+// Modifications copyright (c) 2014-2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_MATH_HPP
+#define BOOST_GEOMETRY_UTIL_MATH_HPP
+
+#include <cmath>
+#include <limits>
+
+#include <boost/core/ignore_unused.hpp>
+
+#include <boost/math/constants/constants.hpp>
+#include <boost/math/special_functions/fpclassify.hpp>
+//#include <boost/math/special_functions/round.hpp>
+#include <boost/numeric/conversion/cast.hpp>
+#include <boost/type_traits/is_fundamental.hpp>
+#include <boost/type_traits/is_integral.hpp>
+
+#include <boost/geometry/core/cs.hpp>
+
+#include <boost/geometry/util/select_most_precise.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace math
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <typename T>
+inline T const& greatest(T const& v1, T const& v2)
+{
+    return (std::max)(v1, v2);
+}
+
+template <typename T>
+inline T const& greatest(T const& v1, T const& v2, T const& v3)
+{
+    return (std::max)(greatest(v1, v2), v3);
+}
+
+template <typename T>
+inline T const& greatest(T const& v1, T const& v2, T const& v3, T const& v4)
+{
+    return (std::max)(greatest(v1, v2, v3), v4);
+}
+
+template <typename T>
+inline T const& greatest(T const& v1, T const& v2, T const& v3, T const& v4, T const& v5)
+{
+    return (std::max)(greatest(v1, v2, v3, v4), v5);
+}
+
+
+template <typename T>
+inline T bounded(T const& v, T const& lower, T const& upper)
+{
+    return (std::min)((std::max)(v, lower), upper);
+}
+
+template <typename T>
+inline T bounded(T const& v, T const& lower)
+{
+    return (std::max)(v, lower);
+}
+
+
+template <typename T,
+          bool IsFloatingPoint = boost::is_floating_point<T>::value>
+struct abs
+{
+    static inline T apply(T const& value)
+    {
+        T const zero = T();
+        return value < zero ? -value : value;
+    }
+};
+
+template <typename T>
+struct abs<T, true>
+{
+    static inline T apply(T const& value)
+    {
+        using ::fabs;
+        using std::fabs; // for long double
+
+        return fabs(value);
+    }
+};
+
+
+struct equals_default_policy
+{
+    template <typename T>
+    static inline T apply(T const& a, T const& b)
+    {
+        // See http://www.parashift.com/c++-faq-lite/newbie.html#faq-29.17
+        return greatest(abs<T>::apply(a), abs<T>::apply(b), T(1));
+    }
+};
+
+template <typename T,
+          bool IsFloatingPoint = boost::is_floating_point<T>::value>
+struct equals_factor_policy
+{
+    equals_factor_policy()
+        : factor(1) {}
+    explicit equals_factor_policy(T const& v)
+        : factor(greatest(abs<T>::apply(v), T(1)))
+    {}
+    equals_factor_policy(T const& v0, T const& v1, T const& v2, T const& v3)
+        : factor(greatest(abs<T>::apply(v0), abs<T>::apply(v1),
+                          abs<T>::apply(v2), abs<T>::apply(v3),
+                          T(1)))
+    {}
+
+    T const& apply(T const&, T const&) const
+    {
+        return factor;
+    }
+
+    T factor;
+};
+
+template <typename T>
+struct equals_factor_policy<T, false>
+{
+    equals_factor_policy() {}
+    explicit equals_factor_policy(T const&) {}
+    equals_factor_policy(T const& , T const& , T const& , T const& ) {}
+
+    static inline T apply(T const&, T const&)
+    {
+        return T(1);
+    }
+};
+
+template <typename Type,
+          bool IsFloatingPoint = boost::is_floating_point<Type>::value>
+struct equals
+{
+    template <typename Policy>
+    static inline bool apply(Type const& a, Type const& b, Policy const&)
+    {
+        return a == b;
+    }
+};
+
+template <typename Type>
+struct equals<Type, true>
+{
+    template <typename Policy>
+    static inline bool apply(Type const& a, Type const& b, Policy const& policy)
+    {
+        boost::ignore_unused(policy);
+
+        if (a == b)
+        {
+            return true;
+        }
+
+        if (boost::math::isfinite(a) && boost::math::isfinite(b))
+        {
+            // If a is INF and b is e.g. 0, the expression below returns true
+            // but the values are obviously not equal, hence the condition
+            return abs<Type>::apply(a - b)
+                <= std::numeric_limits<Type>::epsilon() * policy.apply(a, b);
+        }
+        else
+        {
+            return a == b;
+        }
+    }
+};
+
+template <typename T1, typename T2, typename Policy>
+inline bool equals_by_policy(T1 const& a, T2 const& b, Policy const& policy)
+{
+    return detail::equals
+        <
+            typename select_most_precise<T1, T2>::type
+        >::apply(a, b, policy);
+}
+
+template <typename Type,
+          bool IsFloatingPoint = boost::is_floating_point<Type>::value>
+struct smaller
+{
+    static inline bool apply(Type const& a, Type const& b)
+    {
+        return a < b;
+    }
+};
+
+template <typename Type>
+struct smaller<Type, true>
+{
+    static inline bool apply(Type const& a, Type const& b)
+    {
+        if (!(a < b)) // a >= b
+        {
+            return false;
+        }
+        
+        return ! equals<Type, true>::apply(b, a, equals_default_policy());
+    }
+};
+
+template <typename Type,
+          bool IsFloatingPoint = boost::is_floating_point<Type>::value>
+struct smaller_or_equals
+{
+    static inline bool apply(Type const& a, Type const& b)
+    {
+        return a <= b;
+    }
+};
+
+template <typename Type>
+struct smaller_or_equals<Type, true>
+{
+    static inline bool apply(Type const& a, Type const& b)
+    {
+        if (a <= b)
+        {
+            return true;
+        }
+
+        return equals<Type, true>::apply(a, b, equals_default_policy());
+    }
+};
+
+
+template <typename Type,
+          bool IsFloatingPoint = boost::is_floating_point<Type>::value>
+struct equals_with_epsilon
+    : public equals<Type, IsFloatingPoint>
+{};
+
+template
+<
+    typename T,
+    bool IsFundemantal = boost::is_fundamental<T>::value /* false */
+>
+struct square_root
+{
+    typedef T return_type;
+
+    static inline T apply(T const& value)
+    {
+        // for non-fundamental number types assume that sqrt is
+        // defined either:
+        // 1) at T's scope, or
+        // 2) at global scope, or
+        // 3) in namespace std
+        using ::sqrt;
+        using std::sqrt;
+
+        return sqrt(value);
+    }
+};
+
+template <typename FundamentalFP>
+struct square_root_for_fundamental_fp
+{
+    typedef FundamentalFP return_type;
+
+    static inline FundamentalFP apply(FundamentalFP const& value)
+    {
+#ifdef BOOST_GEOMETRY_SQRT_CHECK_FINITENESS
+        // This is a workaround for some 32-bit platforms.
+        // For some of those platforms it has been reported that
+        // std::sqrt(nan) and/or std::sqrt(-nan) returns a finite value.
+        // For those platforms we need to define the macro
+        // BOOST_GEOMETRY_SQRT_CHECK_FINITENESS so that the argument
+        // to std::sqrt is checked appropriately before passed to std::sqrt
+        if (boost::math::isfinite(value))
+        {
+            return std::sqrt(value);
+        }
+        else if (boost::math::isinf(value) && value < 0)
+        {
+            return -std::numeric_limits<FundamentalFP>::quiet_NaN();
+        }
+        return value;
+#else
+        // for fundamental floating point numbers use std::sqrt
+        return std::sqrt(value);
+#endif // BOOST_GEOMETRY_SQRT_CHECK_FINITENESS
+    }
+};
+
+template <>
+struct square_root<float, true>
+    : square_root_for_fundamental_fp<float>
+{
+};
+
+template <>
+struct square_root<double, true>
+    : square_root_for_fundamental_fp<double>
+{
+};
+
+template <>
+struct square_root<long double, true>
+    : square_root_for_fundamental_fp<long double>
+{
+};
+
+template <typename T>
+struct square_root<T, true>
+{
+    typedef double return_type;
+
+    static inline double apply(T const& value)
+    {
+        // for all other fundamental number types use also std::sqrt
+        //
+        // Note: in C++98 the only other possibility is double;
+        //       in C++11 there are also overloads for integral types;
+        //       this specialization works for those as well.
+        return square_root_for_fundamental_fp
+            <
+                double
+            >::apply(boost::numeric_cast<double>(value));
+    }
+};
+
+
+
+template
+<
+    typename T,
+    bool IsFundemantal = boost::is_fundamental<T>::value /* false */
+>
+struct modulo
+{
+    typedef T return_type;
+
+    static inline T apply(T const& value1, T const& value2)
+    {
+        // for non-fundamental number types assume that a free
+        // function mod() is defined either:
+        // 1) at T's scope, or
+        // 2) at global scope
+        return mod(value1, value2);
+    }
+};
+
+template
+<
+    typename Fundamental,
+    bool IsIntegral = boost::is_integral<Fundamental>::value
+>
+struct modulo_for_fundamental
+{
+    typedef Fundamental return_type;
+
+    static inline Fundamental apply(Fundamental const& value1,
+                                    Fundamental const& value2)
+    {
+        return value1 % value2;
+    }
+};
+
+// specialization for floating-point numbers
+template <typename Fundamental>
+struct modulo_for_fundamental<Fundamental, false>
+{
+    typedef Fundamental return_type;
+
+    static inline Fundamental apply(Fundamental const& value1,
+                                    Fundamental const& value2)
+    {
+        return std::fmod(value1, value2);
+    }
+};
+
+// specialization for fundamental number type
+template <typename Fundamental>
+struct modulo<Fundamental, true>
+    : modulo_for_fundamental<Fundamental>
+{};
+
+
+
+/*!
+\brief Short constructs to enable partial specialization for PI, 2*PI
+       and PI/2, currently not possible in Math.
+*/
+template <typename T>
+struct define_pi
+{
+    static inline T apply()
+    {
+        // Default calls Boost.Math
+        return boost::math::constants::pi<T>();
+    }
+};
+
+template <typename T>
+struct define_two_pi
+{
+    static inline T apply()
+    {
+        // Default calls Boost.Math
+        return boost::math::constants::two_pi<T>();
+    }
+};
+
+template <typename T>
+struct define_half_pi
+{
+    static inline T apply()
+    {
+        // Default calls Boost.Math
+        return boost::math::constants::half_pi<T>();
+    }
+};
+
+template <typename T>
+struct relaxed_epsilon
+{
+    static inline T apply(const T& factor)
+    {
+        return factor * std::numeric_limits<T>::epsilon();
+    }
+};
+
+// This must be consistent with math::equals.
+// By default math::equals() scales the error by epsilon using the greater of
+// compared values but here is only one value, though it should work the same way.
+// (a-a) <= max(a, a) * EPS       -> 0 <= a*EPS
+// (a+da-a) <= max(a+da, a) * EPS -> da <= (a+da)*EPS
+template <typename T, bool IsFloat = boost::is_floating_point<T>::value>
+struct scaled_epsilon
+{
+    static inline T apply(T const& val)
+    {
+        return (std::max)(abs<T>::apply(val), T(1))
+                    * std::numeric_limits<T>::epsilon();
+    }
+};
+
+template <typename T>
+struct scaled_epsilon<T, false>
+{
+    static inline T apply(T const&)
+    {
+        return T(0);
+    }
+};
+
+// ItoF ItoI FtoF
+template <typename Result, typename Source,
+          bool ResultIsInteger = std::numeric_limits<Result>::is_integer,
+          bool SourceIsInteger = std::numeric_limits<Source>::is_integer>
+struct rounding_cast
+{
+    static inline Result apply(Source const& v)
+    {
+        return boost::numeric_cast<Result>(v);
+    }
+};
+
+// TtoT
+template <typename Source, bool ResultIsInteger, bool SourceIsInteger>
+struct rounding_cast<Source, Source, ResultIsInteger, SourceIsInteger>
+{
+    static inline Source apply(Source const& v)
+    {
+        return v;
+    }
+};
+
+// FtoI
+template <typename Result, typename Source>
+struct rounding_cast<Result, Source, true, false>
+{
+    static inline Result apply(Source const& v)
+    {
+        return boost::numeric_cast<Result>(v < Source(0) ?
+                                            v - Source(0.5) :
+                                            v + Source(0.5));
+    }
+};
+
+} // namespace detail
+#endif
+
+
+template <typename T>
+inline T pi() { return detail::define_pi<T>::apply(); }
+
+template <typename T>
+inline T two_pi() { return detail::define_two_pi<T>::apply(); }
+
+template <typename T>
+inline T half_pi() { return detail::define_half_pi<T>::apply(); }
+
+template <typename T>
+inline T relaxed_epsilon(T const& factor)
+{
+    return detail::relaxed_epsilon<T>::apply(factor);
+}
+
+template <typename T>
+inline T scaled_epsilon(T const& value)
+{
+    return detail::scaled_epsilon<T>::apply(value);
+}
+
+
+// Maybe replace this by boost equals or so
+
+/*!
+    \brief returns true if both arguments are equal.
+    \ingroup utility
+    \param a first argument
+    \param b second argument
+    \return true if a == b
+    \note If both a and b are of an integral type, comparison is done by ==.
+    If one of the types is floating point, comparison is done by abs and
+    comparing with epsilon. If one of the types is non-fundamental, it might
+    be a high-precision number and comparison is done using the == operator
+    of that class.
+*/
+
+template <typename T1, typename T2>
+inline bool equals(T1 const& a, T2 const& b)
+{
+    return detail::equals
+        <
+            typename select_most_precise<T1, T2>::type
+        >::apply(a, b, detail::equals_default_policy());
+}
+
+template <typename T1, typename T2>
+inline bool equals_with_epsilon(T1 const& a, T2 const& b)
+{
+    return detail::equals_with_epsilon
+        <
+            typename select_most_precise<T1, T2>::type
+        >::apply(a, b, detail::equals_default_policy());
+}
+
+template <typename T1, typename T2>
+inline bool smaller(T1 const& a, T2 const& b)
+{
+    return detail::smaller
+        <
+            typename select_most_precise<T1, T2>::type
+        >::apply(a, b);
+}
+
+template <typename T1, typename T2>
+inline bool larger(T1 const& a, T2 const& b)
+{
+    return detail::smaller
+        <
+            typename select_most_precise<T1, T2>::type
+        >::apply(b, a);
+}
+
+template <typename T1, typename T2>
+inline bool smaller_or_equals(T1 const& a, T2 const& b)
+{
+    return detail::smaller_or_equals
+        <
+            typename select_most_precise<T1, T2>::type
+        >::apply(a, b);
+}
+
+template <typename T1, typename T2>
+inline bool larger_or_equals(T1 const& a, T2 const& b)
+{
+    return detail::smaller_or_equals
+        <
+            typename select_most_precise<T1, T2>::type
+        >::apply(b, a);
+}
+
+
+template <typename T>
+inline T d2r()
+{
+    static T const conversion_coefficient = geometry::math::pi<T>() / T(180.0);
+    return conversion_coefficient;
+}
+
+template <typename T>
+inline T r2d()
+{
+    static T const conversion_coefficient = T(180.0) / geometry::math::pi<T>();
+    return conversion_coefficient;
+}
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail {
+
+template <typename DegreeOrRadian>
+struct as_radian
+{
+    template <typename T>
+    static inline T apply(T const& value)
+    {
+        return value;
+    }
+};
+
+template <>
+struct as_radian<degree>
+{
+    template <typename T>
+    static inline T apply(T const& value)
+    {
+        return value * d2r<T>();
+    }
+};
+
+template <typename DegreeOrRadian>
+struct from_radian
+{
+    template <typename T>
+    static inline T apply(T const& value)
+    {
+        return value;
+    }
+};
+
+template <>
+struct from_radian<degree>
+{
+    template <typename T>
+    static inline T apply(T const& value)
+    {
+        return value * r2d<T>();
+    }
+};
+
+} // namespace detail
+#endif
+
+template <typename DegreeOrRadian, typename T>
+inline T as_radian(T const& value)
+{
+    return detail::as_radian<DegreeOrRadian>::apply(value);
+}
+
+template <typename DegreeOrRadian, typename T>
+inline T from_radian(T const& value)
+{
+    return detail::from_radian<DegreeOrRadian>::apply(value);
+}
+
+
+/*!
+    \brief Calculates the haversine of an angle
+    \ingroup utility
+    \note See http://en.wikipedia.org/wiki/Haversine_formula
+    haversin(alpha) = sin2(alpha/2)
+*/
+template <typename T>
+inline T hav(T const& theta)
+{
+    T const half = T(0.5);
+    T const sn = sin(half * theta);
+    return sn * sn;
+}
+
+/*!
+\brief Short utility to return the square
+\ingroup utility
+\param value Value to calculate the square from
+\return The squared value
+*/
+template <typename T>
+inline T sqr(T const& value)
+{
+    return value * value;
+}
+
+/*!
+\brief Short utility to return the square root
+\ingroup utility
+\param value Value to calculate the square root from
+\return The square root value
+*/
+template <typename T>
+inline typename detail::square_root<T>::return_type
+sqrt(T const& value)
+{
+    return detail::square_root
+        <
+            T, boost::is_fundamental<T>::value
+        >::apply(value);
+}
+
+/*!
+\brief Short utility to return the modulo of two values
+\ingroup utility
+\param value1 First value
+\param value2 Second value
+\return The result of the modulo operation on the (ordered) pair
+(value1, value2)
+*/
+template <typename T>
+inline typename detail::modulo<T>::return_type
+mod(T const& value1, T const& value2)
+{
+    return detail::modulo
+        <
+            T, boost::is_fundamental<T>::value
+        >::apply(value1, value2);
+}
+
+/*!
+\brief Short utility to workaround gcc/clang problem that abs is converting to integer
+       and that older versions of MSVC does not support abs of long long...
+\ingroup utility
+*/
+template<typename T>
+inline T abs(T const& value)
+{
+    return detail::abs<T>::apply(value);
+}
+
+/*!
+\brief Short utility to calculate the sign of a number: -1 (negative), 0 (zero), 1 (positive)
+\ingroup utility
+*/
+template <typename T>
+inline int sign(T const& value)
+{
+    T const zero = T();
+    return value > zero ? 1 : value < zero ? -1 : 0;
+}
+
+/*!
+\brief Short utility to cast a value possibly rounding it to the nearest
+       integral value.
+\ingroup utility
+\note If the source T is NOT an integral type and Result is an integral type
+      the value is rounded towards the closest integral value. Otherwise it's
+      casted without rounding.
+*/
+template <typename Result, typename T>
+inline Result rounding_cast(T const& v)
+{
+    return detail::rounding_cast<Result, T>::apply(v);
+}
+
+} // namespace math
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_UTIL_MATH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/normalize_spheroidal_box_coordinates.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/normalize_spheroidal_box_coordinates.hpp
new file mode 100644
index 00000000000..eb947bb0928
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/normalize_spheroidal_box_coordinates.hpp
@@ -0,0 +1,160 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_UTIL_NORMALIZE_SPHEROIDAL_BOX_COORDINATES_HPP
+#define BOOST_GEOMETRY_UTIL_NORMALIZE_SPHEROIDAL_BOX_COORDINATES_HPP
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/util/math.hpp>
+#include <boost/geometry/util/normalize_spheroidal_coordinates.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace math 
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+
+template <typename Units, typename CoordinateType>
+class normalize_spheroidal_box_coordinates
+{
+private:
+    typedef normalize_spheroidal_coordinates<Units, CoordinateType> normalize;
+    typedef constants_on_spheroid<CoordinateType, Units> constants;
+
+    static inline bool is_band(CoordinateType const& longitude1,
+                               CoordinateType const& longitude2)
+    {
+        return ! math::smaller(math::abs(longitude1 - longitude2),
+                               constants::period());
+    }
+
+public:
+    static inline void apply(CoordinateType& longitude1,
+                             CoordinateType& latitude1,
+                             CoordinateType& longitude2,
+                             CoordinateType& latitude2,
+                             bool band)
+    {
+        normalize::apply(longitude1, latitude1, false);
+        normalize::apply(longitude2, latitude2, false);
+
+        if (math::equals(latitude1, constants::min_latitude())
+            && math::equals(latitude2, constants::min_latitude()))
+        {
+            // box degenerates to the south pole
+            longitude1 = longitude2 = CoordinateType(0);
+        }
+        else if (math::equals(latitude1, constants::max_latitude())
+                 && math::equals(latitude2, constants::max_latitude()))
+        {
+            // box degenerates to the north pole
+            longitude1 = longitude2 = CoordinateType(0);
+        }
+        else if (band)
+        {
+            // the box is a band between two small circles (parallel
+            // to the equator) on the spheroid
+            longitude1 = constants::min_longitude();
+            longitude2 = constants::max_longitude();
+        }
+        else if (longitude1 > longitude2)
+        {
+            // the box crosses the antimeridian, so we need to adjust
+            // the longitudes
+            longitude2 += constants::period();
+        }
+
+#ifdef BOOST_GEOMETRY_NORMALIZE_LATITUDE
+        BOOST_GEOMETRY_ASSERT(! math::larger(latitude1, latitude2));
+        BOOST_GEOMETRY_ASSERT(! math::smaller(latitude1, constants::min_latitude()));
+        BOOST_GEOMETRY_ASSERT(! math::larger(latitude2, constants::max_latitude()));
+#endif
+
+        BOOST_GEOMETRY_ASSERT(! math::larger(longitude1, longitude2));
+        BOOST_GEOMETRY_ASSERT(! math::smaller(longitude1, constants::min_longitude()));
+        BOOST_GEOMETRY_ASSERT
+            (! math::larger(longitude2 - longitude1, constants::period()));
+    }
+
+    static inline void apply(CoordinateType& longitude1,
+                             CoordinateType& latitude1,
+                             CoordinateType& longitude2,
+                             CoordinateType& latitude2)
+    {
+        bool const band = is_band(longitude1, longitude2);
+
+        apply(longitude1, latitude1, longitude2, latitude2, band);
+    }
+};
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+/*!
+\brief Short utility to normalize the coordinates of a box on a spheroid
+\tparam Units The units of the coordindate system in the spheroid
+\tparam CoordinateType The type of the coordinates
+\param longitude1 Minimum longitude of the box
+\param latitude1 Minimum latitude of the box
+\param longitude2 Maximum longitude of the box
+\param latitude2 Maximum latitude of the box
+\ingroup utility
+*/
+template <typename Units, typename CoordinateType>
+inline void normalize_spheroidal_box_coordinates(CoordinateType& longitude1,
+                                                 CoordinateType& latitude1,
+                                                 CoordinateType& longitude2,
+                                                 CoordinateType& latitude2)
+{
+    detail::normalize_spheroidal_box_coordinates
+        <
+            Units, CoordinateType
+        >::apply(longitude1, latitude1, longitude2, latitude2);
+}
+
+/*!
+\brief Short utility to normalize the coordinates of a box on a spheroid
+\tparam Units The units of the coordindate system in the spheroid
+\tparam CoordinateType The type of the coordinates
+\param longitude1 Minimum longitude of the box
+\param latitude1 Minimum latitude of the box
+\param longitude2 Maximum longitude of the box
+\param latitude2 Maximum latitude of the box
+\param band Indicates whether the box should be treated as a band or
+       not and avoid the computation done in the other version of the function
+\ingroup utility
+*/
+template <typename Units, typename CoordinateType>
+inline void normalize_spheroidal_box_coordinates(CoordinateType& longitude1,
+                                                 CoordinateType& latitude1,
+                                                 CoordinateType& longitude2,
+                                                 CoordinateType& latitude2,
+                                                 bool band)
+{
+    detail::normalize_spheroidal_box_coordinates
+        <
+            Units, CoordinateType
+        >::apply(longitude1, latitude1, longitude2, latitude2, band);
+}
+
+
+} // namespace math
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_UTIL_NORMALIZE_SPHEROIDAL_BOX_COORDINATES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/normalize_spheroidal_coordinates.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/normalize_spheroidal_coordinates.hpp
new file mode 100644
index 00000000000..19d4d33d28d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/normalize_spheroidal_coordinates.hpp
@@ -0,0 +1,324 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015-2016, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_UTIL_NORMALIZE_SPHEROIDAL_COORDINATES_HPP
+#define BOOST_GEOMETRY_UTIL_NORMALIZE_SPHEROIDAL_COORDINATES_HPP
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/util/math.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace math 
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+
+template <typename CoordinateType, typename Units>
+struct constants_on_spheroid
+{
+    static inline CoordinateType period()
+    {
+        return math::two_pi<CoordinateType>();
+    }
+
+    static inline CoordinateType half_period()
+    {
+        return math::pi<CoordinateType>();
+    }
+
+    static inline CoordinateType min_longitude()
+    {
+        static CoordinateType const minus_pi = -math::pi<CoordinateType>();
+        return minus_pi;
+    }
+
+    static inline CoordinateType max_longitude()
+    {
+        return math::pi<CoordinateType>();
+    }
+
+    static inline CoordinateType min_latitude()
+    {
+        static CoordinateType const minus_half_pi
+            = -math::half_pi<CoordinateType>();
+        return minus_half_pi;
+    }
+
+    static inline CoordinateType max_latitude()
+    {
+        return math::half_pi<CoordinateType>();
+    }
+};
+
+template <typename CoordinateType>
+struct constants_on_spheroid<CoordinateType, degree>
+{
+    static inline CoordinateType period()
+    {
+        return CoordinateType(360.0);
+    }
+
+    static inline CoordinateType half_period()
+    {
+        return CoordinateType(180.0);
+    }
+
+    static inline CoordinateType min_longitude()
+    {
+        return CoordinateType(-180.0);
+    }
+
+    static inline CoordinateType max_longitude()
+    {
+        return CoordinateType(180.0);
+    }
+
+    static inline CoordinateType min_latitude()
+    {
+        return CoordinateType(-90.0);
+    }
+
+    static inline CoordinateType max_latitude()
+    {
+        return CoordinateType(90.0);
+    }
+};
+
+
+template <typename Units, typename CoordinateType>
+class normalize_spheroidal_coordinates
+{
+    typedef constants_on_spheroid<CoordinateType, Units> constants;
+
+protected:
+    static inline CoordinateType normalize_up(CoordinateType const& value)
+    {
+        return
+            math::mod(value + constants::half_period(), constants::period())
+            - constants::half_period();            
+    }
+
+    static inline CoordinateType normalize_down(CoordinateType const& value)
+    {
+        return
+            math::mod(value - constants::half_period(), constants::period())
+            + constants::half_period();            
+    }
+
+public:
+    static inline void apply(CoordinateType& longitude)
+    {
+        // normalize longitude
+        if (math::equals(math::abs(longitude), constants::half_period()))
+        {
+            longitude = constants::half_period();
+        }
+        else if (longitude > constants::half_period())
+        {
+            longitude = normalize_up(longitude);
+            if (math::equals(longitude, -constants::half_period()))
+            {
+                longitude = constants::half_period();
+            }
+        }
+        else if (longitude < -constants::half_period())
+        {
+            longitude = normalize_down(longitude);
+        }
+    }
+
+    static inline void apply(CoordinateType& longitude,
+                             CoordinateType& latitude,
+                             bool normalize_poles = true)
+    {
+#ifdef BOOST_GEOMETRY_NORMALIZE_LATITUDE
+        // normalize latitude
+        if (math::larger(latitude, constants::half_period()))
+        {
+            latitude = normalize_up(latitude);
+        }
+        else if (math::smaller(latitude, -constants::half_period()))
+        {
+            latitude = normalize_down(latitude);
+        }
+
+        // fix latitude range
+        if (latitude < constants::min_latitude())
+        {
+            latitude = -constants::half_period() - latitude;
+            longitude -= constants::half_period();
+        }
+        else if (latitude > constants::max_latitude())
+        {
+            latitude = constants::half_period() - latitude;
+            longitude -= constants::half_period();
+        }
+#endif // BOOST_GEOMETRY_NORMALIZE_LATITUDE
+
+        // normalize longitude
+        apply(longitude);
+
+        // finally normalize poles
+        if (normalize_poles)
+        {
+            if (math::equals(math::abs(latitude), constants::max_latitude()))
+            {
+                // for the north and south pole we set the longitude to 0
+                // (works for both radians and degrees)
+                longitude = CoordinateType(0);
+            }
+        }
+
+#ifdef BOOST_GEOMETRY_NORMALIZE_LATITUDE
+        BOOST_GEOMETRY_ASSERT(! math::larger(constants::min_latitude(), latitude));
+        BOOST_GEOMETRY_ASSERT(! math::larger(latitude, constants::max_latitude()));
+#endif // BOOST_GEOMETRY_NORMALIZE_LATITUDE
+
+        BOOST_GEOMETRY_ASSERT(math::smaller(constants::min_longitude(), longitude));
+        BOOST_GEOMETRY_ASSERT(! math::larger(longitude, constants::max_longitude()));
+    }
+};
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+/*!
+\brief Short utility to normalize the coordinates on a spheroid
+\tparam Units The units of the coordindate system in the spheroid
+\tparam CoordinateType The type of the coordinates
+\param longitude Longitude
+\param latitude Latitude
+\ingroup utility
+*/
+template <typename Units, typename CoordinateType>
+inline void normalize_spheroidal_coordinates(CoordinateType& longitude,
+                                             CoordinateType& latitude)
+{
+    detail::normalize_spheroidal_coordinates
+        <
+            Units, CoordinateType
+        >::apply(longitude, latitude);
+}
+
+
+/*!
+\brief Short utility to normalize the longitude on a spheroid.
+       Note that in general both coordinates should be normalized at once.
+       This utility is suitable e.g. for normalization of the difference of longitudes.
+\tparam Units The units of the coordindate system in the spheroid
+\tparam CoordinateType The type of the coordinates
+\param longitude Longitude
+\ingroup utility
+*/
+template <typename Units, typename CoordinateType>
+inline void normalize_longitude(CoordinateType& longitude)
+{
+    detail::normalize_spheroidal_coordinates
+        <
+            Units, CoordinateType
+        >::apply(longitude);
+}
+
+
+/*!
+\brief Short utility to calculate difference between two longitudes
+       normalized in range (-180, 180].
+\tparam Units The units of the coordindate system in the spheroid
+\tparam CoordinateType The type of the coordinates
+\param longitude1 Longitude 1
+\param longitude2 Longitude 2
+\ingroup utility
+*/
+template <typename Units, typename CoordinateType>
+inline CoordinateType longitude_distance_signed(CoordinateType const& longitude1,
+                                                CoordinateType const& longitude2)
+{
+    CoordinateType diff = longitude2 - longitude1;
+    math::normalize_longitude<Units, CoordinateType>(diff);
+    return diff;
+}
+
+
+/*!
+\brief Short utility to calculate difference between two longitudes
+       normalized in range [0, 360).
+\tparam Units The units of the coordindate system in the spheroid
+\tparam CoordinateType The type of the coordinates
+\param longitude1 Longitude 1
+\param longitude2 Longitude 2
+\ingroup utility
+*/
+template <typename Units, typename CoordinateType>
+inline CoordinateType longitude_distance_unsigned(CoordinateType const& longitude1,
+                                                  CoordinateType const& longitude2)
+{
+    typedef math::detail::constants_on_spheroid
+        <
+            CoordinateType, Units
+        > constants;
+
+    CoordinateType const c0 = 0;
+    CoordinateType diff = longitude_distance_signed<Units>(longitude1, longitude2);
+    if (diff < c0) // (-180, 180] -> [0, 360)
+    {
+        diff += constants::period();
+    }
+    return diff;
+}
+
+/*!
+\brief The abs difference between longitudes in range [0, 180].
+\tparam Units The units of the coordindate system in the spheroid
+\tparam CoordinateType The type of the coordinates
+\param longitude1 Longitude 1
+\param longitude2 Longitude 2
+\ingroup utility
+*/
+template <typename Units, typename CoordinateType>
+inline CoordinateType longitude_difference(CoordinateType const& longitude1,
+                                           CoordinateType const& longitude2)
+{
+    return math::abs(math::longitude_distance_signed<Units>(longitude1, longitude2));
+}
+
+template <typename Units, typename CoordinateType>
+inline CoordinateType longitude_interval_distance_signed(CoordinateType const& longitude_a1,
+                                                         CoordinateType const& longitude_a2,
+                                                         CoordinateType const& longitude_b)
+{
+    CoordinateType const c0 = 0;
+    CoordinateType dist_a12 = longitude_distance_signed<Units>(longitude_a1, longitude_a2);
+    CoordinateType dist_a1b = longitude_distance_signed<Units>(longitude_a1, longitude_b);
+    if (dist_a12 < c0)
+    {
+        dist_a12 = -dist_a12;
+        dist_a1b = -dist_a1b;
+    }
+    
+    return dist_a1b < c0 ? dist_a1b
+         : dist_a1b > dist_a12 ? dist_a1b - dist_a12
+         : c0;
+}
+
+} // namespace math
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_UTIL_NORMALIZE_SPHEROIDAL_COORDINATES_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/order_as_direction.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/order_as_direction.hpp
new file mode 100644
index 00000000000..6895ebf3f1f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/order_as_direction.hpp
@@ -0,0 +1,46 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_ORDER_AS_DIRECTION_HPP
+#define BOOST_GEOMETRY_UTIL_ORDER_AS_DIRECTION_HPP
+
+#include <boost/geometry/core/point_order.hpp>
+#include <boost/geometry/views/reversible_view.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+template<order_selector Order>
+struct order_as_direction
+{};
+
+
+template<>
+struct order_as_direction<clockwise>
+{
+    static const iterate_direction value = iterate_forward;
+};
+
+
+template<>
+struct order_as_direction<counterclockwise>
+{
+    static const iterate_direction value = iterate_reverse;
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_UTIL_ORDER_AS_DIRECTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/parameter_type_of.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/parameter_type_of.hpp
new file mode 100644
index 00000000000..731fb55a560
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/parameter_type_of.hpp
@@ -0,0 +1,75 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_PARAMETER_TYPE_OF_HPP
+#define BOOST_GEOMETRY_UTIL_PARAMETER_TYPE_OF_HPP
+
+
+#include <boost/function_types/function_arity.hpp>
+#include <boost/function_types/is_member_function_pointer.hpp>
+#include <boost/function_types/parameter_types.hpp>
+#include <boost/mpl/at.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/plus.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+/*!
+\brief Meta-function selecting a parameter type of a (member) function, by index
+\ingroup utility
+ */
+template <typename Method, std::size_t Index>
+struct parameter_type_of
+{
+    typedef typename boost::function_types::parameter_types
+        <
+            Method
+        >::type parameter_types;
+
+    typedef typename boost::mpl::if_
+        <
+            boost::function_types::is_member_function_pointer<Method>,
+            boost::mpl::int_<1>,
+            boost::mpl::int_<0>
+        >::type base_index_type;
+
+    typedef typename boost::mpl::if_c
+        <
+            Index == 0,
+            base_index_type,
+            typename boost::mpl::plus
+                <
+                    base_index_type,
+                    boost::mpl::int_<Index>
+                >::type
+        >::type indexed_type;
+
+    typedef typename boost::remove_reference
+        <
+            typename boost::mpl::at
+                <
+                    parameter_types,
+                    indexed_type
+                >::type
+        >::type type;
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_UTIL_PARAMETER_TYPE_OF_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/promote_floating_point.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/promote_floating_point.hpp
new file mode 100644
index 00000000000..b84069db1b6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/promote_floating_point.hpp
@@ -0,0 +1,50 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_PROMOTE_FLOATING_POINT_HPP
+#define BOOST_GEOMETRY_UTIL_PROMOTE_FLOATING_POINT_HPP
+
+
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_integral.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+/*!
+    \brief Meta-function converting, if necessary, to "a floating point" type
+    \details
+        - if input type is integer, type is double
+        - else type is input type
+    \ingroup utility
+ */
+
+template <typename T, typename PromoteIntegerTo = double>
+struct promote_floating_point
+{
+    typedef typename
+        boost::mpl::if_
+        <
+            boost::is_integral<T>,
+            PromoteIntegerTo,
+            T
+        >::type type;
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_UTIL_PROMOTE_FLOATING_POINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/promote_integral.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/promote_integral.hpp
new file mode 100644
index 00000000000..6b23403be35
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/promote_integral.hpp
@@ -0,0 +1,318 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_UTIL_PROMOTE_INTEGRAL_HPP
+#define BOOST_GEOMETRY_UTIL_PROMOTE_INTEGRAL_HPP
+
+// For now deactivate the use of multiprecision integers
+// TODO: activate it later
+#define BOOST_GEOMETRY_NO_MULTIPRECISION_INTEGER
+
+#include <climits>
+#include <cstddef>
+
+#include <boost/mpl/begin.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/end.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/list.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/mpl/size_t.hpp>
+
+#if !defined(BOOST_GEOMETRY_NO_MULTIPRECISION_INTEGER)
+#include <boost/multiprecision/cpp_int.hpp>
+#endif
+
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/is_fundamental.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_unsigned.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace promote_integral
+{
+
+// meta-function that returns the bit size of a type
+template
+<
+    typename T,
+    bool IsFundamental = boost::is_fundamental<T>::type::value
+>
+struct bit_size
+{};
+
+
+// for fundamental types, just return CHAR_BIT * sizeof(T)
+template <typename T>
+struct bit_size<T, true>
+    : boost::mpl::size_t<(CHAR_BIT * sizeof(T))>
+{};
+
+
+#if !defined(BOOST_GEOMETRY_NO_MULTIPRECISION_INTEGER)
+// partial specialization for cpp_int
+template
+<
+    unsigned MinSize,
+    unsigned MaxSize,
+    boost::multiprecision::cpp_integer_type SignType,
+    boost::multiprecision::cpp_int_check_type Checked,
+    typename Allocator,
+    boost::multiprecision::expression_template_option ExpressionTemplates
+>
+struct bit_size
+    <
+        boost::multiprecision::number
+            <
+                boost::multiprecision::cpp_int_backend
+                    <
+                        MinSize, MaxSize, SignType, Checked, Allocator
+                    >,
+                ExpressionTemplates
+            >,
+        false
+    > : boost::mpl::size_t<MaxSize>
+{};
+#endif // BOOST_GEOMETRY_NO_MULTIPRECISION_INTEGER
+
+
+template
+<
+    typename T,
+    typename Iterator,
+    typename EndIterator,
+    std::size_t MinSize
+>
+struct promote_to_larger
+{
+    typedef typename boost::mpl::deref<Iterator>::type current_type;
+
+    typedef typename boost::mpl::if_c
+        <
+            (bit_size<current_type>::type::value >= MinSize),
+            current_type,
+            typename promote_to_larger
+                <
+                    T,
+                    typename boost::mpl::next<Iterator>::type,
+                    EndIterator,
+                    MinSize
+                >::type
+        >::type type;
+};
+
+// The following specialization is required to finish the loop over
+// all list elements
+template <typename T, typename EndIterator, std::size_t MinSize>
+struct promote_to_larger<T, EndIterator, EndIterator, MinSize>
+{
+    // if promotion fails, keep the number T
+    // (and cross fingers that overflow will not occur)
+    typedef T type;
+};
+
+}} // namespace detail::promote_integral
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+/*!
+    \brief Meta-function to define an integral type with size
+    than is (roughly) twice the bit size of T
+    \ingroup utility
+    \details
+    This meta-function tries to promote the fundamental integral type T
+    to a another integral type with size (roughly) twice the bit size of T.
+
+    To do this, two times the bit size of T is tested against the bit sizes of:
+         short, int, long, boost::long_long_type, boost::int128_t
+    and the one that first matches is chosen.
+
+    For unsigned types the bit size of T is tested against the bit
+    sizes of the types above, if T is promoted to a signed type, or
+    the bit sizes of
+         unsigned short, unsigned int, unsigned long, std::size_t,
+         boost::ulong_long_type, boost::uint128_t
+    if T is promoted to an unsigned type.
+
+    By default an unsigned type is promoted to a signed type.
+    This behavior is controlled by the PromoteUnsignedToUnsigned
+    boolean template parameter, whose default value is "false".
+    To promote an unsigned type to an unsigned type set the value of
+    this template parameter to "true".
+
+    If the macro BOOST_GEOMETRY_NO_MULTIPRECISION_INTEGER is not
+    defined, boost's multiprecision integer cpp_int<> is used as a
+    last resort.
+
+    If BOOST_GEOMETRY_NO_MULTIPRECISION_INTEGER is defined and an
+    appropriate type cannot be detected, the input type is returned as is.
+
+    Finally, if the passed type is either a floating-point type or a
+    user-defined type it is returned as is.
+
+    \note boost::long_long_type and boost::ulong_long_type are
+    considered only if the macro BOOST_HAS_LONG_LONG is defined
+
+    \note boost::int128_type and boost::uint128_type are considered
+    only if the macros BOOST_HAS_INT128 and BOOST_GEOMETRY_ENABLE_INT128
+    are defined
+*/
+template
+<
+    typename T,
+    bool PromoteUnsignedToUnsigned = false,
+    bool UseCheckedInteger = false,
+    bool IsIntegral = boost::is_integral<T>::type::value
+>
+class promote_integral
+{
+private:
+    static bool const is_unsigned = boost::is_unsigned<T>::type::value;
+
+    typedef detail::promote_integral::bit_size<T> bit_size_type;
+
+#if !defined(BOOST_GEOMETRY_NO_MULTIPRECISION_INTEGER)
+    // Define the proper check policy for the multiprecision integer
+    typedef typename boost::mpl::if_c
+        <
+            UseCheckedInteger,
+            boost::integral_constant
+                <
+                    boost::multiprecision::cpp_int_check_type,
+                    boost::multiprecision::checked
+                >,
+            boost::integral_constant
+                <
+                    boost::multiprecision::cpp_int_check_type,
+                    boost::multiprecision::unchecked
+                >
+        >::type check_policy_type;
+
+    // Meta-function to get the multiprecision integer type for the
+    // given size and sign type (signed/unsigned)
+    template
+    <
+        unsigned int Size,
+        boost::multiprecision::cpp_integer_type SignType
+    >
+    struct multiprecision_integer_type
+    {
+        typedef boost::multiprecision::number
+            <
+                boost::multiprecision::cpp_int_backend
+                    <
+                        Size,
+                        Size,
+                        SignType,
+                        check_policy_type::value,
+                        void
+                    >
+            > type;
+    };
+#endif
+
+    // Define the minimum size (in bits) needed for the promoted type
+    // If T is the input type and P the promoted type, then the
+    // minimum number of bits for P are (below b stands for the number
+    // of bits of T):
+    // * if T is unsigned and P is unsigned: 2 * b
+    // * if T is signed and P is signed: 2 * b - 1
+    // * if T is unsigned and P is signed: 2 * b + 1
+    typedef typename boost::mpl::if_c
+        <
+            (PromoteUnsignedToUnsigned && is_unsigned),
+            boost::mpl::size_t<(2 * bit_size_type::value)>,
+            typename boost::mpl::if_c
+                <
+                    is_unsigned,
+                    boost::mpl::size_t<(2 * bit_size_type::value + 1)>,
+                    boost::mpl::size_t<(2 * bit_size_type::value - 1)>
+                >::type
+        >::type min_bit_size_type;
+
+    // Define the list of signed integral types we are going to use
+    // for promotion
+    typedef boost::mpl::list
+        <
+            short, int, long
+#if defined(BOOST_HAS_LONG_LONG)
+            , boost::long_long_type
+#endif
+#if defined(BOOST_HAS_INT128) && defined(BOOST_GEOMETRY_ENABLE_INT128)
+            , boost::int128_type
+#endif
+#if !defined(BOOST_GEOMETRY_NO_MULTIPRECISION_INTEGER)
+            , typename multiprecision_integer_type
+                <
+                    min_bit_size_type::value,
+                    boost::multiprecision::signed_magnitude
+                >::type
+#endif
+        > signed_integral_types;
+
+    // Define the list of unsigned integral types we are going to use
+    // for promotion
+    typedef boost::mpl::list
+        <
+            unsigned short, unsigned int, unsigned long, std::size_t
+#if defined(BOOST_HAS_LONG_LONG)
+            , boost::ulong_long_type
+#endif
+#if defined(BOOST_HAS_INT128) && defined(BOOST_GEOMETRY_ENABLE_INT128)
+            , boost::uint128_type
+#endif
+#if !defined(BOOST_GEOMETRY_NO_MULTIPRECISION_INTEGER)
+            , typename multiprecision_integer_type
+                <
+                    min_bit_size_type::value,
+                    boost::multiprecision::unsigned_magnitude
+                >::type
+#endif
+        > unsigned_integral_types;
+
+    // Define the list of integral types that will be used for
+    // promotion (depending in whether we was to promote unsigned to
+    // unsigned or not)
+    typedef typename boost::mpl::if_c
+        <
+            (is_unsigned && PromoteUnsignedToUnsigned),
+            unsigned_integral_types,
+            signed_integral_types
+        >::type integral_types;
+
+public:
+    typedef typename detail::promote_integral::promote_to_larger
+        <
+            T,
+            typename boost::mpl::begin<integral_types>::type,
+            typename boost::mpl::end<integral_types>::type,
+            min_bit_size_type::value
+        >::type type;
+};
+
+
+template <typename T, bool PromoteUnsignedToUnsigned, bool UseCheckedInteger>
+class promote_integral
+    <
+        T, PromoteUnsignedToUnsigned, UseCheckedInteger, false
+    >
+{
+public:
+    typedef T type;
+};
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_UTIL_PROMOTE_INTEGRAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/range.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/range.hpp
new file mode 100644
index 00000000000..b10a008059c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/range.hpp
@@ -0,0 +1,418 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+
+// This file was modified by Oracle on 2013, 2014, 2015, 2016.
+// Modifications copyright (c) 2013-2016 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_RANGE_HPP
+#define BOOST_GEOMETRY_UTIL_RANGE_HPP
+
+#include <algorithm>
+#include <iterator>
+
+#include <boost/concept_check.hpp>
+#include <boost/config.hpp>
+#include <boost/core/addressof.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/empty.hpp>
+#include <boost/range/difference_type.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/range/rbegin.hpp>
+#include <boost/range/reference.hpp>
+#include <boost/range/size.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/mutable_range.hpp>
+
+namespace boost { namespace geometry { namespace range {
+
+namespace detail {
+
+// NOTE: For SinglePassRanges pos could iterate over all elements until the i-th element was met.
+
+template <typename RandomAccessRange>
+struct pos
+{
+    typedef typename boost::range_iterator<RandomAccessRange>::type iterator;
+    typedef typename boost::range_size<RandomAccessRange>::type size_type;
+    typedef typename boost::range_difference<RandomAccessRange>::type difference_type;
+
+    static inline iterator apply(RandomAccessRange & rng, size_type i)
+    {
+        BOOST_RANGE_CONCEPT_ASSERT(( boost::RandomAccessRangeConcept<RandomAccessRange> ));
+        return boost::begin(rng) + static_cast<difference_type>(i);
+    }
+};
+
+} // namespace detail
+
+/*!
+\brief Short utility to conveniently return an iterator of a RandomAccessRange.
+\ingroup utility
+*/
+template <typename RandomAccessRange>
+inline typename boost::range_iterator<RandomAccessRange const>::type
+pos(RandomAccessRange const& rng,
+    typename boost::range_size<RandomAccessRange const>::type i)
+{
+    BOOST_GEOMETRY_ASSERT(i <= boost::size(rng));
+    return detail::pos<RandomAccessRange const>::apply(rng, i);
+}
+
+/*!
+\brief Short utility to conveniently return an iterator of a RandomAccessRange.
+\ingroup utility
+*/
+template <typename RandomAccessRange>
+inline typename boost::range_iterator<RandomAccessRange>::type
+pos(RandomAccessRange & rng,
+    typename boost::range_size<RandomAccessRange>::type i)
+{
+    BOOST_GEOMETRY_ASSERT(i <= boost::size(rng));
+    return detail::pos<RandomAccessRange>::apply(rng, i);
+}
+
+/*!
+\brief Short utility to conveniently return an element of a RandomAccessRange.
+\ingroup utility
+*/
+template <typename RandomAccessRange>
+inline typename boost::range_reference<RandomAccessRange const>::type
+at(RandomAccessRange const& rng,
+   typename boost::range_size<RandomAccessRange const>::type i)
+{
+    BOOST_GEOMETRY_ASSERT(i < boost::size(rng));
+    return * detail::pos<RandomAccessRange const>::apply(rng, i);
+}
+
+/*!
+\brief Short utility to conveniently return an element of a RandomAccessRange.
+\ingroup utility
+*/
+template <typename RandomAccessRange>
+inline typename boost::range_reference<RandomAccessRange>::type
+at(RandomAccessRange & rng,
+   typename boost::range_size<RandomAccessRange>::type i)
+{
+    BOOST_GEOMETRY_ASSERT(i < boost::size(rng));
+    return * detail::pos<RandomAccessRange>::apply(rng, i);
+}
+
+/*!
+\brief Short utility to conveniently return the front element of a Range.
+\ingroup utility
+*/
+template <typename Range>
+inline typename boost::range_reference<Range const>::type
+front(Range const& rng)
+{
+    BOOST_GEOMETRY_ASSERT(!boost::empty(rng));
+    return *boost::begin(rng);
+}
+
+/*!
+\brief Short utility to conveniently return the front element of a Range.
+\ingroup utility
+*/
+template <typename Range>
+inline typename boost::range_reference<Range>::type
+front(Range & rng)
+{
+    BOOST_GEOMETRY_ASSERT(!boost::empty(rng));
+    return *boost::begin(rng);
+}
+
+// NOTE: For SinglePassRanges back() could iterate over all elements until the last element is met.
+
+/*!
+\brief Short utility to conveniently return the back element of a BidirectionalRange.
+\ingroup utility
+*/
+template <typename BidirectionalRange>
+inline typename boost::range_reference<BidirectionalRange const>::type
+back(BidirectionalRange const& rng)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( boost::BidirectionalRangeConcept<BidirectionalRange const> ));
+    BOOST_GEOMETRY_ASSERT(!boost::empty(rng));
+    return *(boost::rbegin(rng));
+}
+
+/*!
+\brief Short utility to conveniently return the back element of a BidirectionalRange.
+\ingroup utility
+*/
+template <typename BidirectionalRange>
+inline typename boost::range_reference<BidirectionalRange>::type
+back(BidirectionalRange & rng)
+{
+    BOOST_RANGE_CONCEPT_ASSERT((boost::BidirectionalRangeConcept<BidirectionalRange>));
+    BOOST_GEOMETRY_ASSERT(!boost::empty(rng));
+    return *(boost::rbegin(rng));
+}
+
+
+/*!
+\brief Short utility to conveniently clear a mutable range.
+       It uses traits::clear<>.
+\ingroup utility
+*/
+template <typename Range>
+inline void clear(Range & rng)
+{
+    // NOTE: this trait is probably not needed since it could be implemented using resize()
+    geometry::traits::clear<Range>::apply(rng);
+}
+
+/*!
+\brief Short utility to conveniently insert a new element at the end of a mutable range.
+       It uses boost::geometry::traits::push_back<>.
+\ingroup utility
+*/
+template <typename Range>
+inline void push_back(Range & rng,
+                      typename boost::range_value<Range>::type const& value)
+{
+    geometry::traits::push_back<Range>::apply(rng, value);
+}
+
+/*!
+\brief Short utility to conveniently resize a mutable range.
+       It uses boost::geometry::traits::resize<>.
+\ingroup utility
+*/
+template <typename Range>
+inline void resize(Range & rng,
+                   typename boost::range_size<Range>::type new_size)
+{
+    geometry::traits::resize<Range>::apply(rng, new_size);
+}
+
+
+/*!
+\brief Short utility to conveniently remove an element from the back of a mutable range.
+       It uses resize().
+\ingroup utility
+*/
+template <typename Range>
+inline void pop_back(Range & rng)
+{
+    BOOST_GEOMETRY_ASSERT(!boost::empty(rng));
+    range::resize(rng, boost::size(rng) - 1);
+}
+
+namespace detail {
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+template <typename It,
+          typename OutIt,
+          bool UseMove = boost::is_convertible
+                            <
+                                typename std::iterator_traits<It>::value_type &&,
+                                typename std::iterator_traits<OutIt>::value_type
+                            >::value>
+struct copy_or_move_impl
+{
+    static inline OutIt apply(It first, It last, OutIt out)
+    {
+        return std::move(first, last, out);
+    }
+};
+
+template <typename It, typename OutIt>
+struct copy_or_move_impl<It, OutIt, false>
+{
+    static inline OutIt apply(It first, It last, OutIt out)
+    {
+        return std::copy(first, last, out);
+    }
+};
+
+template <typename It, typename OutIt>
+inline OutIt copy_or_move(It first, It last, OutIt out)
+{
+    return copy_or_move_impl<It, OutIt>::apply(first, last, out);
+}
+
+#else
+
+template <typename It, typename OutIt>
+inline OutIt copy_or_move(It first, It last, OutIt out)
+{
+    return std::copy(first, last, out);
+}
+
+#endif
+
+} // namespace detail
+
+/*!
+\brief Short utility to conveniently remove an element from a mutable range.
+       It uses std::copy() and resize(). Version taking mutable iterators.
+\ingroup utility
+*/
+template <typename Range>
+inline typename boost::range_iterator<Range>::type
+erase(Range & rng,
+      typename boost::range_iterator<Range>::type it)
+{
+    BOOST_GEOMETRY_ASSERT(!boost::empty(rng));
+    BOOST_GEOMETRY_ASSERT(it != boost::end(rng));
+
+    typename boost::range_difference<Range>::type const
+        d = std::distance(boost::begin(rng), it);
+
+    typename boost::range_iterator<Range>::type
+        next = it;
+    ++next;
+
+    detail::copy_or_move(next, boost::end(rng), it);
+    range::resize(rng, boost::size(rng) - 1);
+
+    // NOTE: In general this should be sufficient:
+    //    return it;
+    // But in MSVC using the returned iterator causes
+    // assertion failures when iterator debugging is enabled
+    // Furthermore the code below should work in the case if resize()
+    // invalidates iterators when the container is resized down.
+    return boost::begin(rng) + d;
+}
+
+/*!
+\brief Short utility to conveniently remove an element from a mutable range.
+       It uses std::copy() and resize(). Version taking non-mutable iterators.
+\ingroup utility
+*/
+template <typename Range>
+inline typename boost::range_iterator<Range>::type
+erase(Range & rng,
+      typename boost::range_iterator<Range const>::type cit)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( boost::RandomAccessRangeConcept<Range> ));
+
+    typename boost::range_iterator<Range>::type
+        it = boost::begin(rng)
+                + std::distance(boost::const_begin(rng), cit);
+
+    return erase(rng, it);
+}
+
+/*!
+\brief Short utility to conveniently remove a range of elements from a mutable range.
+       It uses std::copy() and resize(). Version taking mutable iterators.
+\ingroup utility
+*/
+template <typename Range>
+inline typename boost::range_iterator<Range>::type
+erase(Range & rng,
+      typename boost::range_iterator<Range>::type first,
+      typename boost::range_iterator<Range>::type last)
+{
+    typename boost::range_difference<Range>::type const
+        diff = std::distance(first, last);
+    BOOST_GEOMETRY_ASSERT(diff >= 0);
+
+    std::size_t const count = static_cast<std::size_t>(diff);
+    BOOST_GEOMETRY_ASSERT(count <= boost::size(rng));
+    
+    if ( count > 0 )
+    {
+        typename boost::range_difference<Range>::type const
+            d = std::distance(boost::begin(rng), first);
+
+        detail::copy_or_move(last, boost::end(rng), first);
+        range::resize(rng, boost::size(rng) - count);
+
+        // NOTE: In general this should be sufficient:
+        //    return first;
+        // But in MSVC using the returned iterator causes
+        // assertion failures when iterator debugging is enabled
+        // Furthermore the code below should work in the case if resize()
+        // invalidates iterators when the container is resized down.
+        return boost::begin(rng) + d;
+    }
+
+    return first;
+}
+
+/*!
+\brief Short utility to conveniently remove a range of elements from a mutable range.
+       It uses std::copy() and resize(). Version taking non-mutable iterators.
+\ingroup utility
+*/
+template <typename Range>
+inline typename boost::range_iterator<Range>::type
+erase(Range & rng,
+      typename boost::range_iterator<Range const>::type cfirst,
+      typename boost::range_iterator<Range const>::type clast)
+{
+    BOOST_RANGE_CONCEPT_ASSERT(( boost::RandomAccessRangeConcept<Range> ));
+
+    typename boost::range_iterator<Range>::type
+        first = boost::begin(rng)
+                    + std::distance(boost::const_begin(rng), cfirst);
+    typename boost::range_iterator<Range>::type
+        last = boost::begin(rng)
+                    + std::distance(boost::const_begin(rng), clast);
+
+    return erase(rng, first, last);
+}
+
+// back_inserter
+
+template <class Container>
+class back_insert_iterator
+    : public std::iterator<std::output_iterator_tag, void, void, void, void>
+{
+public:
+    typedef Container container_type;
+
+    explicit back_insert_iterator(Container & c)
+        : container(boost::addressof(c))
+    {}
+
+    back_insert_iterator & operator=(typename Container::value_type const& value)
+    {
+        range::push_back(*container, value);
+        return *this;
+    }
+
+    back_insert_iterator & operator* ()
+    {
+        return *this;
+    }
+
+    back_insert_iterator & operator++ ()
+    {
+        return *this;
+    }
+
+    back_insert_iterator operator++(int)
+    {
+        return *this;
+    }
+
+private:
+    Container * container;
+};
+
+template <typename Range>
+inline back_insert_iterator<Range> back_inserter(Range & rng)
+{
+    return back_insert_iterator<Range>(rng);
+}
+
+}}} // namespace boost::geometry::range
+
+#endif // BOOST_GEOMETRY_UTIL_RANGE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/rational.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/rational.hpp
new file mode 100644
index 00000000000..805c85eb46a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/rational.hpp
@@ -0,0 +1,179 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2011-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2011-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2011-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_RATIONAL_HPP
+#define BOOST_GEOMETRY_UTIL_RATIONAL_HPP
+
+#include <boost/rational.hpp>
+#include <boost/numeric/conversion/bounds.hpp>
+
+#include <boost/geometry/util/coordinate_cast.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+
+
+namespace boost{ namespace geometry
+{
+
+
+// Specialize for Boost.Geometry's coordinate cast
+// (from string to coordinate type)
+namespace detail
+{
+
+template <typename T>
+struct coordinate_cast<rational<T> >
+{
+    static inline void split_parts(std::string const& source, std::string::size_type p,
+        T& before, T& after, bool& negate, std::string::size_type& len)
+    {
+        std::string before_part = source.substr(0, p);
+        std::string const after_part = source.substr(p + 1);
+
+        negate = false;
+
+        if (before_part.size() > 0 && before_part[0] == '-')
+        {
+            negate = true;
+            before_part.erase(0, 1);
+        }
+        before = atol(before_part.c_str());
+        after = atol(after_part.c_str());
+        len = after_part.length();
+    }
+
+
+    static inline rational<T> apply(std::string const& source)
+    {
+        T before, after;
+        bool negate;
+        std::string::size_type len;
+
+        // Note: decimal comma is not (yet) supported, it does (and should) not
+        // occur in a WKT, where points are comma separated.
+        std::string::size_type p = source.find(".");
+        if (p == std::string::npos)
+        {
+            p = source.find("/");
+            if (p == std::string::npos)
+            {
+                return rational<T>(atol(source.c_str()));
+            }
+            split_parts(source, p, before, after, negate, len);
+
+            return negate
+                ? -rational<T>(before, after)
+                : rational<T>(before, after)
+                ;
+
+        }
+
+        split_parts(source, p, before, after, negate, len);
+
+        T den = 1;
+        for (std::string::size_type i = 0; i < len; i++)
+        {
+            den *= 10;
+        }
+
+        return negate
+            ? -rational<T>(before) - rational<T>(after, den)
+            : rational<T>(before) + rational<T>(after, den)
+            ;
+    }
+};
+
+} // namespace detail
+
+// Specialize for Boost.Geometry's select_most_precise
+template <typename T1, typename T2>
+struct select_most_precise<boost::rational<T1>, boost::rational<T2> >
+{
+    typedef typename boost::rational
+        <
+            typename select_most_precise<T1, T2>::type
+        > type;
+};
+
+template <typename T>
+struct select_most_precise<boost::rational<T>, double>
+{
+    typedef typename boost::rational<T> type;
+};
+
+
+}} // namespace boost::geometry
+
+
+// Specializes boost::rational to boost::numeric::bounds
+namespace boost { namespace numeric
+{
+
+template<class T>
+struct bounds<rational<T> >
+{
+    static inline rational<T> lowest()
+    {
+        return rational<T>(bounds<T>::lowest(), 1);
+    }
+    static inline rational<T> highest()
+    {
+        return rational<T>(bounds<T>::highest(), 1);
+    }
+};
+
+}} // namespace boost::numeric
+
+
+// Support for boost::numeric_cast to int and to double (necessary for SVG-mapper)
+namespace boost { namespace numeric
+{
+
+template
+<
+    typename T,
+    typename Traits,
+    typename OverflowHandler,
+    typename Float2IntRounder,
+    typename RawConverter,
+    typename UserRangeChecker
+>
+struct converter<int, rational<T>, Traits, OverflowHandler, Float2IntRounder, RawConverter, UserRangeChecker>
+{
+    static inline int convert(rational<T> const& arg)
+    {
+        return int(rational_cast<double>(arg));
+    }
+};
+
+template
+<
+    typename T,
+    typename Traits,
+    typename OverflowHandler,
+    typename Float2IntRounder,
+    typename RawConverter,
+    typename UserRangeChecker
+>
+struct converter<double, rational<T>, Traits, OverflowHandler, Float2IntRounder, RawConverter, UserRangeChecker>
+{
+    static inline double convert(rational<T> const& arg)
+    {
+        return rational_cast<double>(arg);
+    }
+};
+
+
+}}
+
+
+#endif // BOOST_GEOMETRY_UTIL_RATIONAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/readme.txt b/contrib/libboost/boost_1_65_0/boost/geometry/util/readme.txt
new file mode 100644
index 00000000000..7a1bf88bebd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/readme.txt
@@ -0,0 +1,17 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2011 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2011 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2011 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+This folder contains several headerfiles not fitting in one of the other folders,
+or meta-functions which would fit into boost as a separate trait or utility,
+such as add_const_if_c
+
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/select_calculation_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/select_calculation_type.hpp
new file mode 100644
index 00000000000..b6405831eb6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/select_calculation_type.hpp
@@ -0,0 +1,84 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_SELECT_CALCULATION_TYPE_HPP
+#define BOOST_GEOMETRY_UTIL_SELECT_CALCULATION_TYPE_HPP
+
+
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_void.hpp>
+
+#include <boost/geometry/util/select_coordinate_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+/*!
+    \brief Meta-function selecting the "calculation" type
+    \details Based on two input geometry types, and an input calculation type,
+        (which defaults to void in the calling function), this meta-function
+        selects the most appropriate:
+        - if calculation type is specified, that one is used,
+        - if it is void, the most precise of the two points is used
+    \ingroup utility
+ */
+template <typename Geometry1, typename Geometry2, typename CalculationType>
+struct select_calculation_type
+{
+    typedef typename
+        boost::mpl::if_
+        <
+            boost::is_void<CalculationType>,
+            typename select_coordinate_type
+                <
+                    Geometry1,
+                    Geometry2
+                >::type,
+            CalculationType
+        >::type type;
+};
+
+// alternative version supporting more than 2 Geometries
+
+template <typename CalculationType,
+          typename Geometry1,
+          typename Geometry2 = void,
+          typename Geometry3 = void>
+struct select_calculation_type_alt
+{
+    typedef typename
+        boost::mpl::if_
+        <
+            boost::is_void<CalculationType>,
+            typename select_coordinate_type
+                <
+                    Geometry1,
+                    Geometry2,
+                    Geometry3
+                >::type,
+            CalculationType
+        >::type type;
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_UTIL_SELECT_CALCULATION_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/select_coordinate_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/select_coordinate_type.hpp
new file mode 100644
index 00000000000..12a6b72a733
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/select_coordinate_type.hpp
@@ -0,0 +1,69 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_SELECT_COORDINATE_TYPE_HPP
+#define BOOST_GEOMETRY_UTIL_SELECT_COORDINATE_TYPE_HPP
+
+
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/util/select_most_precise.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+/*!
+    \brief Meta-function selecting the most precise coordinate type
+        of two geometries
+    \ingroup utility
+ */
+template <typename T1, typename T2 = void, typename T3 = void>
+struct select_coordinate_type
+{
+    typedef typename select_most_precise
+        <
+            typename coordinate_type<T1>::type,
+            typename coordinate_type<T2>::type,
+            typename coordinate_type<T3>::type
+        >::type type;
+};
+
+template <typename T1, typename T2>
+struct select_coordinate_type<T1, T2, void>
+{
+    typedef typename select_most_precise
+        <
+            typename coordinate_type<T1>::type,
+            typename coordinate_type<T2>::type
+        >::type type;
+};
+
+template <typename T1>
+struct select_coordinate_type<T1, void, void>
+{
+    typedef typename select_most_precise
+        <
+            typename coordinate_type<T1>::type
+        >::type type;
+};
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_UTIL_SELECT_COORDINATE_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/select_most_precise.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/select_most_precise.hpp
new file mode 100644
index 00000000000..3169f5fa17e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/select_most_precise.hpp
@@ -0,0 +1,182 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_SELECT_MOST_PRECISE_HPP
+#define BOOST_GEOMETRY_UTIL_SELECT_MOST_PRECISE_HPP
+
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_floating_point.hpp>
+#include <boost/type_traits/is_fundamental.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+
+namespace detail { namespace select_most_precise
+{
+
+
+// At least one of the types is non-fundamental. Take that one.
+// if both are non-fundamental, the type-to-be-selected
+// is unknown, it should be defined by explicit specialization.
+template <bool Fundamental1, bool Fundamental2, typename T1, typename T2>
+struct select_non_fundamental
+{
+    typedef T1 type;
+};
+
+template <typename T1, typename T2>
+struct select_non_fundamental<true, false, T1, T2>
+{
+    typedef T2 type;
+};
+
+template <typename T1, typename T2>
+struct select_non_fundamental<false, true, T1, T2>
+{
+    typedef T1 type;
+};
+
+
+// Selection of largest type (e.g. int of <short int,int>
+// It defaults takes the first one, if second is larger, take the second one
+template <bool SecondLarger, typename T1, typename T2>
+struct select_largest
+{
+    typedef T1 type;
+};
+
+template <typename T1, typename T2>
+struct select_largest<true, T1, T2>
+{
+    typedef T2 type;
+};
+
+
+
+// Selection of floating point and specializations:
+// both FP or both !FP does never occur...
+template <bool FP1, bool FP2, typename T1, typename T2>
+struct select_floating_point
+{
+    typedef char type;
+};
+
+
+// ... so if ONE but not both of these types is floating point, take that one
+template <typename T1, typename T2>
+struct select_floating_point<true, false, T1, T2>
+{
+    typedef T1 type;
+};
+
+
+template <typename T1, typename T2>
+struct select_floating_point<false, true, T1, T2>
+{
+    typedef T2 type;
+};
+
+
+}} // namespace detail::select_most_precise
+#endif // DOXYGEN_NO_DETAIL
+
+
+/*!
+    \brief Meta-function to select, of two types, the most accurate type for
+        calculations
+    \ingroup utility
+    \details select_most_precise classes, compares two types on compile time.
+    For example, if an addition must be done with a double and an integer, the
+        result must be a double.
+    If both types are integer, the result can be an integer.
+    \note It is different from the "promote" class, already in boost. That
+        class promotes e.g. a (one) float to a double. This class selects a
+        type from two types. It takes the most accurate, but does not promote
+        afterwards.
+    \note This traits class is completely independant from GGL and might be a
+        separate addition to Boost
+    \note If the input is a non-fundamental type, it might be a calculation
+        type such as a GMP-value or another high precision value. Therefore,
+        if one is non-fundamental, that one is chosen.
+    \note If both types are non-fundamental, the result is indeterminate and
+        currently the first one is chosen.
+*/
+template <typename T1, typename T2 = void, typename T3 = void>
+struct select_most_precise
+{
+    typedef typename select_most_precise
+        <
+            typename select_most_precise<T1, T2>::type,
+            T3
+        >::type type;
+};
+
+template <typename T1, typename T2>
+struct select_most_precise<T1, T2, void>
+{
+    static const bool second_larger = sizeof(T2) > sizeof(T1);
+    static const bool one_not_fundamental = !
+        (boost::is_fundamental<T1>::type::value
+          && boost::is_fundamental<T2>::type::value);
+
+    static const bool both_same =
+        boost::is_floating_point<T1>::type::value
+        == boost::is_floating_point<T2>::type::value;
+
+    typedef typename boost::mpl::if_c
+        <
+            one_not_fundamental,
+            typename detail::select_most_precise::select_non_fundamental
+            <
+                boost::is_fundamental<T1>::type::value,
+                boost::is_fundamental<T2>::type::value,
+                T1,
+                T2
+            >::type,
+            typename boost::mpl::if_c
+            <
+                both_same,
+                typename detail::select_most_precise::select_largest
+                <
+                    second_larger,
+                    T1,
+                    T2
+                >::type,
+                typename detail::select_most_precise::select_floating_point
+                <
+                    boost::is_floating_point<T1>::type::value,
+                    boost::is_floating_point<T2>::type::value,
+                    T1,
+                    T2
+                >::type
+            >::type
+        >::type type;
+};
+
+template <typename T1>
+struct select_most_precise<T1, void, void>
+{
+    typedef T1 type;
+};
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_UTIL_SELECT_MOST_PRECISE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/util/transform_variant.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/util/transform_variant.hpp
new file mode 100644
index 00000000000..f0836bcbf26
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/util/transform_variant.hpp
@@ -0,0 +1,84 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_UTIL_TRANSFORM_VARIANT_HPP
+#define BOOST_GEOMETRY_UTIL_TRANSFORM_VARIANT_HPP
+
+
+#include <boost/mpl/transform.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+/*!
+    \brief Meta-function that takes a Sequence type, an MPL lambda
+        expression and an optional Inserter and returns a variant type over
+        the same types as the initial variant type, each transformed using
+        the lambda expression.
+    \ingroup utility
+    \par Example
+    \code
+        typedef boost::mpl::vector<int, float, long> types;
+        typedef transform_variant<types, add_pointer<_> > transformed;
+        typedef variant<int*, float*, long*> result;
+        BOOST_MPL_ASSERT(( equal<result, transformed> ));
+    \endcode
+*/
+template <typename Sequence, typename Op, typename In = boost::mpl::na>
+struct transform_variant:
+    make_variant_over<
+        typename boost::mpl::transform<
+            Sequence,
+            Op,
+            In
+        >::type
+    >
+{};
+
+
+/*!
+    \brief Meta-function that takes a boost::variant type and an MPL lambda
+        expression and returns a variant type over the same types as the
+        initial variant type, each transformed using the lambda expression.
+    \ingroup utility
+    \par Example
+    \code
+        typedef variant<int, float, long> variant_type;
+        typedef transform_variant<variant_type, add_pointer<_> > transformed;
+        typedef variant<int*, float*, long*> result;
+        BOOST_MPL_ASSERT(( equal<result, transformed> ));
+    \endcode
+*/
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), typename Op>
+struct transform_variant<variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Op, boost::mpl::na> :
+    make_variant_over<
+        typename boost::mpl::transform<
+            typename variant<BOOST_VARIANT_ENUM_PARAMS(T)>::types,
+            Op
+        >::type
+    >
+{};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_UTIL_TRANSFORM_VARIANT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/views/box_view.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/views/box_view.hpp
new file mode 100644
index 00000000000..4ecb941ec9f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/views/box_view.hpp
@@ -0,0 +1,118 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_VIEWS_BOX_VIEW_HPP
+#define BOOST_GEOMETRY_VIEWS_BOX_VIEW_HPP
+
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/views/detail/points_view.hpp>
+#include <boost/geometry/algorithms/assign.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+/*!
+\brief Makes a box behave like a ring or a range
+\details Adapts a box to the Boost.Range concept, enabling the user to iterating
+    box corners. The box_view is registered as a Ring Concept
+\tparam Box \tparam_geometry{Box}
+\tparam Clockwise If true, walks in clockwise direction, otherwise
+    it walks in counterclockwise direction
+\ingroup views
+
+\qbk{before.synopsis,
+[heading Model of]
+[link geometry.reference.concepts.concept_ring Ring Concept]
+}
+
+\qbk{[include reference/views/box_view.qbk]}
+*/
+template <typename Box, bool Clockwise = true>
+struct box_view
+    : public detail::points_view
+        <
+            typename geometry::point_type<Box>::type,
+            5
+        >
+{
+    typedef typename geometry::point_type<Box>::type point_type;
+
+    /// Constructor accepting the box to adapt
+    explicit box_view(Box const& box)
+        : detail::points_view<point_type, 5>(copy_policy(box))
+    {}
+
+private :
+
+    class copy_policy
+    {
+    public :
+        inline copy_policy(Box const& box)
+            : m_box(box)
+        {}
+
+        inline void apply(point_type* points) const
+        {
+            // assign_box_corners_oriented requires a range
+            // an alternative for this workaround would be to pass a range here,
+            // e.g. use boost::array in points_view instead of c-array
+            std::pair<point_type*, point_type*> rng = std::make_pair(points, points + 5);
+            detail::assign_box_corners_oriented<!Clockwise>(m_box, rng);
+            points[4] = points[0];
+        }
+    private :
+        Box const& m_box;
+    };
+
+};
+
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+// All views on boxes are handled as rings
+namespace traits
+{
+
+template<typename Box, bool Clockwise>
+struct tag<box_view<Box, Clockwise> >
+{
+    typedef ring_tag type;
+};
+
+template<typename Box>
+struct point_order<box_view<Box, false> >
+{
+    static order_selector const value = counterclockwise;
+};
+
+
+template<typename Box>
+struct point_order<box_view<Box, true> >
+{
+    static order_selector const value = clockwise;
+};
+
+}
+
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_VIEWS_BOX_VIEW_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/views/closeable_view.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/views/closeable_view.hpp
new file mode 100644
index 00000000000..1f1eb2720bf
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/views/closeable_view.hpp
@@ -0,0 +1,109 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_VIEWS_CLOSEABLE_VIEW_HPP
+#define BOOST_GEOMETRY_VIEWS_CLOSEABLE_VIEW_HPP
+
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/iterators/closing_iterator.hpp>
+
+#include <boost/geometry/views/identity_view.hpp>
+
+namespace boost { namespace geometry
+{
+
+// Silence warning C4512: assignment operator could not be generated
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4512)
+#endif
+
+#ifndef DOXYGEN_NO_DETAIL
+
+namespace detail
+{
+
+template <typename Range>
+struct closing_view
+{
+    // Keep this explicit, important for nested views/ranges
+    explicit inline closing_view(Range& r)
+        : m_range(r)
+    {}
+
+    typedef closing_iterator<Range> iterator;
+    typedef closing_iterator<Range const> const_iterator;
+
+    inline const_iterator begin() const { return const_iterator(m_range); }
+    inline const_iterator end() const { return const_iterator(m_range, true); }
+
+    inline iterator begin() { return iterator(m_range); }
+    inline iterator end() { return iterator(m_range, true); }
+private :
+    Range& m_range;
+};
+
+}
+
+#endif // DOXYGEN_NO_DETAIL
+
+
+/*!
+\brief View on a range, either closing it or leaving it as it is
+\details The closeable_view is used internally by the library to handle all rings,
+    either closed or open, the same way. The default method is closed, all
+    algorithms process rings as if they are closed. Therefore, if they are opened,
+    a view is created which closes them.
+    The closeable_view might be used by library users, but its main purpose is
+    internally.
+\tparam Range Original range
+\tparam Close Specifies if it the range is closed, if so, nothing will happen.
+    If it is open, it will iterate the first point after the last point.
+\ingroup views
+*/
+template <typename Range, closure_selector Close>
+struct closeable_view {};
+
+
+#ifndef DOXYGEN_NO_SPECIALIZATIONS
+
+template <typename Range>
+struct closeable_view<Range, closed>
+{
+    typedef identity_view<Range> type;
+};
+
+
+template <typename Range>
+struct closeable_view<Range, open>
+{
+    typedef detail::closing_view<Range> type;
+};
+
+#endif // DOXYGEN_NO_SPECIALIZATIONS
+
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_VIEWS_CLOSEABLE_VIEW_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/boundary_view.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/boundary_view.hpp
new file mode 100644
index 00000000000..43bd5b202d6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/boundary_view.hpp
@@ -0,0 +1,16 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_VIEWS_DETAIL_BOUNDARY_VIEW_HPP
+#define BOOST_GEOMETRY_VIEWS_DETAIL_BOUNDARY_VIEW_HPP
+
+#include <boost/geometry/views/detail/boundary_view/interface.hpp>
+#include <boost/geometry/views/detail/boundary_view/implementation.hpp>
+
+#endif // BOOST_GEOMETRY_VIEWS_DETAIL_BOUNDARY_VIEW_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/boundary_view/implementation.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/boundary_view/implementation.hpp
new file mode 100644
index 00000000000..e6a09afd680
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/boundary_view/implementation.hpp
@@ -0,0 +1,466 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_VIEWS_DETAIL_BOUNDARY_VIEW_IMPLEMENTATION_HPP
+#define BOOST_GEOMETRY_VIEWS_DETAIL_BOUNDARY_VIEW_IMPLEMENTATION_HPP
+
+#include <cstddef>
+#include <algorithm>
+#include <iterator>
+#include <memory>
+#include <new>
+#include <utility>
+#include <vector>
+
+#include <boost/core/addressof.hpp>
+#include <boost/iterator.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/range.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/geometry/core/assert.hpp>
+#include <boost/geometry/core/closure.hpp>
+#include <boost/geometry/core/exterior_ring.hpp>
+#include <boost/geometry/core/interior_rings.hpp>
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/iterators/flatten_iterator.hpp>
+
+#include <boost/geometry/util/range.hpp>
+
+#include <boost/geometry/views/closeable_view.hpp>
+
+#include <boost/geometry/algorithms/num_interior_rings.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace boundary_views
+{
+
+
+template
+<
+    typename Polygon,
+    typename Value = typename ring_type<Polygon>::type,
+    typename Reference = typename ring_return_type<Polygon>::type,
+    typename Difference = typename boost::range_difference
+        <
+            typename boost::remove_reference
+                <
+                    typename interior_return_type<Polygon>::type
+                >::type
+        >::type
+>
+class polygon_rings_iterator
+    : public boost::iterator_facade
+        <
+            polygon_rings_iterator<Polygon, Value, Reference, Difference>,
+            Value,
+            boost::random_access_traversal_tag,
+            Reference,
+            Difference
+        >
+{
+    typedef typename boost::range_size
+        <
+            typename boost::remove_reference
+                <
+                    typename interior_return_type<Polygon>::type
+                >::type
+        >::type size_type;
+
+public:
+    // default constructor
+    polygon_rings_iterator()
+        : m_polygon(NULL)
+        , m_index(0)
+    {}
+
+    // for begin
+    polygon_rings_iterator(Polygon& polygon)
+        : m_polygon(boost::addressof(polygon))
+        , m_index(0)
+    {}
+
+    // for end
+    polygon_rings_iterator(Polygon& polygon, bool)
+        : m_polygon(boost::addressof(polygon))
+        , m_index(static_cast<size_type>(num_rings(polygon)))
+    {}
+
+    template
+    <
+        typename OtherPolygon,
+        typename OtherValue,
+        typename OtherReference,
+        typename OtherDifference
+    >
+    polygon_rings_iterator(polygon_rings_iterator
+                           <
+                               OtherPolygon,
+                               OtherValue,
+                               OtherReference,
+                               OtherDifference
+                           > const& other)
+        : m_polygon(other.m_polygon)
+        , m_index(other.m_index)
+    {
+        static const bool is_convertible
+            = boost::is_convertible<OtherPolygon, Polygon>::value;
+
+        BOOST_MPL_ASSERT_MSG((is_convertible),
+                             NOT_CONVERTIBLE,
+                             (types<OtherPolygon>));
+    }
+
+private:
+    friend class boost::iterator_core_access;
+
+    template
+    <
+        typename OtherPolygon,
+        typename OtherValue,
+        typename OtherReference,
+        typename OtherDifference
+    >
+    friend class polygon_rings_iterator;
+
+
+    static inline std::size_t num_rings(Polygon const& polygon)
+    {
+        return geometry::num_interior_rings(polygon) + 1;
+    }
+
+    inline Reference dereference() const
+    {
+        if (m_index == 0)
+        {
+            return exterior_ring(*m_polygon);
+        }
+        return range::at(interior_rings(*m_polygon), m_index - 1);
+    }
+
+    template
+    <
+        typename OtherPolygon,
+        typename OtherValue,
+        typename OtherReference,
+        typename OtherDifference
+    >
+    inline bool equal(polygon_rings_iterator
+                      <
+                          OtherPolygon,
+                          OtherValue,
+                          OtherReference,
+                          OtherDifference
+                      > const& other) const
+    {
+        BOOST_GEOMETRY_ASSERT(m_polygon == other.m_polygon);
+        return m_index == other.m_index;
+    }
+
+    inline void increment()
+    {
+        ++m_index;
+    }
+
+    inline void decrement()
+    {
+        --m_index;
+    }
+
+    template
+    <
+        typename OtherPolygon,
+        typename OtherValue,
+        typename OtherReference,
+        typename OtherDifference
+    >
+    inline Difference distance_to(polygon_rings_iterator
+                                  <
+                                      OtherPolygon,
+                                      OtherValue,
+                                      OtherReference,
+                                      OtherDifference
+                                  > const& other) const
+    {
+        return static_cast<Difference>(other.m_index)
+            - static_cast<Difference>(m_index);
+    }
+
+    inline void advance(Difference n)
+    {
+        m_index += n;
+    }
+
+private:
+    Polygon* m_polygon;
+    size_type m_index;
+};
+
+
+template <typename Ring>
+class ring_boundary : closeable_view<Ring, closure<Ring>::value>::type
+{
+private:
+    typedef typename closeable_view<Ring, closure<Ring>::value>::type base_type;
+
+public:
+    typedef typename base_type::iterator iterator;
+    typedef typename base_type::const_iterator const_iterator;
+    
+    typedef linestring_tag tag_type;
+
+    explicit ring_boundary(Ring& ring)
+        : base_type(ring) {}
+
+    iterator begin() { return base_type::begin(); }
+    iterator end() { return base_type::end(); }
+    const_iterator begin() const { return base_type::begin(); }
+    const_iterator end() const { return base_type::end(); }
+};
+
+
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct num_rings
+{};
+
+template <typename Polygon>
+struct num_rings<Polygon, polygon_tag>
+{
+    static inline std::size_t apply(Polygon const& polygon)
+    {
+        return geometry::num_interior_rings(polygon) + 1;
+    }
+};
+
+template <typename MultiPolygon>
+struct num_rings<MultiPolygon, multi_polygon_tag>
+{
+    static inline std::size_t apply(MultiPolygon const& multipolygon)
+    {
+        return geometry::num_interior_rings(multipolygon)
+            + static_cast<std::size_t>(boost::size(multipolygon));
+    }
+};
+
+
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct views_container_initializer
+{};
+
+template <typename Polygon>
+struct views_container_initializer<Polygon, polygon_tag>
+{
+    template <typename BoundaryView>
+    static inline void apply(Polygon const& polygon, BoundaryView* views)
+    {
+        typedef polygon_rings_iterator<Polygon> rings_iterator_type;
+
+        std::uninitialized_copy(rings_iterator_type(polygon),
+                                rings_iterator_type(polygon, true),
+                                views);
+    }
+};
+
+template <typename MultiPolygon>
+class views_container_initializer<MultiPolygon, multi_polygon_tag>
+{
+    typedef typename boost::mpl::if_
+        <
+            boost::is_const<MultiPolygon>,
+            typename boost::range_value<MultiPolygon>::type const,
+            typename boost::range_value<MultiPolygon>::type
+        >::type polygon_type;
+
+    typedef polygon_rings_iterator<polygon_type> inner_iterator_type;
+
+    struct polygon_rings_begin
+    {
+        static inline inner_iterator_type apply(polygon_type& polygon)
+        {
+            return inner_iterator_type(polygon);
+        }
+    };
+
+    struct polygon_rings_end
+    {
+        static inline inner_iterator_type apply(polygon_type& polygon)
+        {
+            return inner_iterator_type(polygon, true);
+        }
+    };
+
+    typedef flatten_iterator
+        <
+            typename boost::range_iterator<MultiPolygon>::type,
+            inner_iterator_type,
+            typename std::iterator_traits<inner_iterator_type>::value_type,
+            polygon_rings_begin,
+            polygon_rings_end,
+            typename std::iterator_traits<inner_iterator_type>::reference
+        > rings_iterator_type;
+
+public:
+    template <typename BoundaryView>
+    static inline void apply(MultiPolygon const& multipolygon,
+                             BoundaryView* views)
+    {
+        rings_iterator_type first(boost::begin(multipolygon),
+                                  boost::end(multipolygon));
+        rings_iterator_type last(boost::end(multipolygon));
+
+        std::uninitialized_copy(first, last, views);
+    }
+};
+
+
+template <typename Areal>
+class areal_boundary
+{
+    typedef boundary_view<typename ring_type<Areal>::type> boundary_view_type;
+    typedef views_container_initializer<Areal> exception_safe_initializer;
+
+    template <typename T>
+    struct automatic_deallocator
+    {
+        automatic_deallocator(T* ptr) : m_ptr(ptr) {}
+
+        ~automatic_deallocator()
+        {
+            operator delete(m_ptr);
+        }
+
+        inline void release() { m_ptr = NULL; }
+
+        T* m_ptr;
+    };
+
+    inline void initialize_views(Areal const& areal)
+    {
+        // initialize number of rings
+        std::size_t n_rings = num_rings<Areal>::apply(areal);
+
+        if (n_rings == 0)
+        {
+            return;
+        }
+
+        // allocate dynamic memory
+        boundary_view_type* views_ptr = static_cast
+            <
+                boundary_view_type*
+            >(operator new(sizeof(boundary_view_type) * n_rings));
+
+        // initialize; if exceptions are thrown by constructors
+        // they are handled automatically by automatic_deallocator
+        automatic_deallocator<boundary_view_type> deallocator(views_ptr);
+        exception_safe_initializer::apply(areal, views_ptr);
+        deallocator.release();
+
+        // now initialize member variables safely
+        m_views = views_ptr;
+        m_num_rings = n_rings;
+    }
+
+    // disallow copies and/or assignments
+    areal_boundary(areal_boundary const&);
+    areal_boundary& operator=(areal_boundary const&);
+
+public:
+    typedef boundary_view_type* iterator;
+    typedef boundary_view_type const* const_iterator;
+
+    typedef multi_linestring_tag tag_type;
+
+    explicit areal_boundary(Areal& areal)
+        : m_views(NULL)
+        , m_num_rings(0)
+    {
+        initialize_views(areal);
+    }
+
+    ~areal_boundary()
+    {
+        boundary_view_type* last = m_views + m_num_rings;
+        for (boundary_view_type* it = m_views; it != last; ++it)
+        {
+            it->~boundary_view_type();
+        }
+        operator delete(m_views);
+    }
+
+    inline iterator begin() { return m_views; }
+    inline iterator end() { return m_views + m_num_rings; }
+    inline const_iterator begin() const { return m_views; }
+    inline const_iterator end() const { return m_views + m_num_rings; }
+
+private:
+    boundary_view_type* m_views;
+    std::size_t m_num_rings;
+};
+
+
+}} // namespace detail::boundary_view
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace detail_dispatch
+{
+
+
+template <typename Ring>
+struct boundary_view<Ring, ring_tag>
+    : detail::boundary_views::ring_boundary<Ring>
+{
+    explicit boundary_view(Ring& ring)
+        : detail::boundary_views::ring_boundary<Ring>(ring)
+    {}
+};
+
+template <typename Polygon>
+struct boundary_view<Polygon, polygon_tag>
+    : detail::boundary_views::areal_boundary<Polygon>
+{
+    explicit boundary_view(Polygon& polygon)
+        : detail::boundary_views::areal_boundary<Polygon>(polygon)
+    {}
+};
+
+template <typename MultiPolygon>
+struct boundary_view<MultiPolygon, multi_polygon_tag>
+    : detail::boundary_views::areal_boundary<MultiPolygon>
+{
+    explicit boundary_view(MultiPolygon& multipolygon)
+        : detail::boundary_views::areal_boundary
+            <
+                MultiPolygon
+            >(multipolygon)
+    {}
+};
+
+
+} // namespace detail_dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_VIEWS_DETAIL_BOUNDARY_VIEW_IMPLEMENTATION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/boundary_view/interface.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/boundary_view/interface.hpp
new file mode 100644
index 00000000000..4d0b6d03030
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/boundary_view/interface.hpp
@@ -0,0 +1,70 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_VIEWS_DETAIL_BOUNDARY_VIEW_INTERFACE_HPP
+#define BOOST_GEOMETRY_VIEWS_DETAIL_BOUNDARY_VIEW_INTERFACE_HPP
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace detail_dispatch
+{
+
+template <typename Geometry, typename Tag = typename tag<Geometry>::type>
+struct boundary_view
+    : not_implemented<Tag>
+{};
+
+} // namespace detail_dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <typename Geometry>
+struct boundary_view
+    : detail_dispatch::boundary_view<Geometry>
+{
+    explicit boundary_view(Geometry& geometry)
+        : detail_dispatch::boundary_view<Geometry>(geometry)
+    {}
+};
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+template <typename Geometry>
+struct tag< geometry::detail::boundary_view<Geometry> >
+{
+    typedef typename detail_dispatch::boundary_view
+        <
+            Geometry
+        >::tag_type type;
+};
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_VIEWS_DETAIL_BOUNDARY_VIEW_INTERFACE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/indexed_point_view.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/indexed_point_view.hpp
new file mode 100644
index 00000000000..e5a89c9ae70
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/indexed_point_view.hpp
@@ -0,0 +1,123 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+// Copyright (c) 2014-2015 Adam Wulkiewicz, Lodz, Poland
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_VIEWS_DETAIL_INDEXED_POINT_VIEW_HPP
+#define BOOST_GEOMETRY_VIEWS_DETAIL_INDEXED_POINT_VIEW_HPP
+
+#include <cstddef>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/coordinate_system.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/util/math.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace detail
+{
+
+template <typename Geometry, std::size_t Index>
+class indexed_point_view
+{
+    indexed_point_view & operator=(indexed_point_view const&);
+
+public:
+    typedef typename geometry::point_type<Geometry>::type point_type;
+    typedef typename geometry::coordinate_type<Geometry>::type coordinate_type;
+
+    indexed_point_view(Geometry & geometry)
+        : m_geometry(geometry)
+    {}
+
+    template <std::size_t Dimension>
+    inline coordinate_type get() const
+    {
+        return geometry::get<Index, Dimension>(m_geometry);
+    }
+
+    template <std::size_t Dimension>
+    inline void set(coordinate_type const& value)
+    {
+        geometry::set<Index, Dimension>(m_geometry, value);
+    }
+
+private:
+    Geometry & m_geometry;
+};
+
+}
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+template <typename Geometry, std::size_t Index>
+struct tag< geometry::detail::indexed_point_view<Geometry, Index> >
+{
+    typedef point_tag type;
+};
+
+template <typename Geometry, std::size_t Index>
+struct coordinate_type< geometry::detail::indexed_point_view<Geometry, Index> >
+{
+    typedef typename geometry::coordinate_type<Geometry>::type type;
+};
+
+template <typename Geometry, std::size_t Index>
+struct coordinate_system
+    <
+        geometry::detail::indexed_point_view<Geometry, Index>
+    >
+{
+    typedef typename geometry::coordinate_system<Geometry>::type type;
+};
+
+template <typename Geometry, std::size_t Index>
+struct dimension< geometry::detail::indexed_point_view<Geometry, Index> >
+    : geometry::dimension<Geometry>
+{};
+
+template<typename Geometry, std::size_t Index, std::size_t Dimension>
+struct access
+    <
+       geometry::detail::indexed_point_view<Geometry, Index>, Dimension
+    >
+{
+    typedef typename geometry::coordinate_type<Geometry>::type coordinate_type;
+
+    static inline coordinate_type get(
+        geometry::detail::indexed_point_view<Geometry, Index> const& p)
+    {
+        return p.template get<Dimension>();
+    }
+
+    static inline void set(
+        geometry::detail::indexed_point_view<Geometry, Index> & p,
+        coordinate_type const& value)
+    {
+        p.template set<Dimension>(value);
+    }
+};
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_VIEWS_DETAIL_INDEXED_POINT_VIEW_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/normalized_view.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/normalized_view.hpp
new file mode 100644
index 00000000000..1e9cda9ce2f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/normalized_view.hpp
@@ -0,0 +1,117 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014 Oracle and/or its affiliates.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+#ifndef BOOST_GEOMETRY_VIEWS_DETAIL_NORMALIZED_VIEW_HPP
+#define BOOST_GEOMETRY_VIEWS_DETAIL_NORMALIZED_VIEW_HPP
+
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/geometry/views/detail/range_type.hpp>
+#include <boost/geometry/views/reversible_view.hpp>
+#include <boost/geometry/views/closeable_view.hpp>
+#include <boost/geometry/util/order_as_direction.hpp>
+
+namespace boost { namespace geometry {
+
+
+#ifndef DOXYGEN_NO_DETAIL
+
+namespace detail {
+
+template <typename Geometry>
+struct normalized_view
+{
+    static const bool is_const = boost::is_const<Geometry>::value;
+
+    //typedef typename ring_type<Geometry>::type ring_type;
+
+    typedef typename detail::range_type<Geometry>::type range_type;
+
+    typedef typename
+        boost::mpl::if_c
+            <
+                is_const,
+                range_type const,
+                range_type
+            >::type range;
+
+    typedef typename
+        reversible_view
+            <
+                range,
+                order_as_direction
+                    <
+                        geometry::point_order<Geometry>::value
+                    >::value
+            >::type reversible_type;
+
+    typedef typename
+        boost::mpl::if_c
+            <
+                is_const,
+                reversible_type const,
+                reversible_type
+            >::type reversible;
+
+    typedef typename
+        closeable_view
+            <
+                reversible,
+                geometry::closure<Geometry>::value
+            >::type closeable_type;
+
+    typedef typename
+        boost::mpl::if_c
+            <
+                is_const,
+                closeable_type const,
+                closeable_type
+            >::type closeable;
+    
+    explicit inline normalized_view(range & r)
+        : m_reversible(r)
+        , m_closeable(m_reversible)
+    {}
+
+    typedef typename boost::range_iterator<closeable>::type iterator;
+    typedef typename boost::range_const_iterator<closeable>::type const_iterator;
+
+    inline const_iterator begin() const { return boost::begin(m_closeable); }
+    inline const_iterator end() const { return boost::end(m_closeable); }
+
+    inline iterator begin() { return boost::begin(m_closeable); }
+    inline iterator end() { return boost::end(m_closeable); }
+
+private:
+    reversible_type m_reversible;
+    closeable_type m_closeable;
+};
+
+} // namespace detail
+
+#endif // DOXYGEN_NO_DETAIL
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_VIEWS_DETAIL_NORMALIZED_VIEW_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/points_view.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/points_view.hpp
new file mode 100644
index 00000000000..a06084216b5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/points_view.hpp
@@ -0,0 +1,142 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_VIEWS_DETAIL_POINTS_VIEW_HPP
+#define BOOST_GEOMETRY_VIEWS_DETAIL_POINTS_VIEW_HPP
+
+
+#include <boost/range.hpp>
+#include <boost/iterator.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+
+#include <boost/geometry/core/exception.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace detail
+{
+
+// Adapts pointer, on points, to a Boost.Range
+template <typename Point, int MaxSize>
+class points_view
+{
+    // Iterates over a series of points (indicated by pointer
+    // to have it lightweight). Probably there is already an
+    // equivalent of this within Boost. If so, TODO: use that one.
+    // This used to be "box_iterator" and "segment_iterator".
+    // ALTERNATIVE: use boost:array and its iterators
+    struct points_iterator
+        : public boost::iterator_facade
+            <
+                points_iterator,
+                Point const,
+                boost::random_access_traversal_tag
+            >
+    {
+        // Constructor: Begin iterator
+        inline points_iterator(Point const* p)
+            : m_points(p)
+            , m_index(0)
+        {}
+
+        // Constructor: End iterator
+        inline points_iterator(Point const* p, bool)
+            : m_points(p)
+            , m_index(MaxSize)
+        {}
+
+        // Constructor: default (for Range Concept checking).
+        inline points_iterator()
+            : m_points(NULL)
+            , m_index(MaxSize)
+        {}
+
+        typedef std::ptrdiff_t difference_type;
+
+    private:
+        friend class boost::iterator_core_access;
+
+        inline Point const& dereference() const
+        {
+            if (m_index >= 0 && m_index < MaxSize)
+            {
+                return m_points[m_index];
+            }
+
+            // If it index larger (or smaller) return first point
+            // (assuming initialized)
+            return m_points[0];
+        }
+
+        inline bool equal(points_iterator const& other) const
+        {
+            return other.m_index == this->m_index;
+        }
+
+        inline void increment()
+        {
+            m_index++;
+        }
+
+        inline void decrement()
+        {
+            m_index--;
+        }
+
+        inline difference_type distance_to(points_iterator const& other) const
+        {
+            return other.m_index - this->m_index;
+        }
+
+        inline void advance(difference_type n)
+        {
+            m_index += n;
+        }
+
+        Point const* m_points;
+        difference_type m_index;
+    };
+
+public :
+
+    typedef points_iterator const_iterator;
+    typedef points_iterator iterator; // must be defined
+
+    const_iterator begin() const { return const_iterator(m_points); }
+    const_iterator end() const { return const_iterator(m_points, true); }
+
+    // It may NOT be used non-const, so commented:
+    //iterator begin() { return m_begin; }
+    //iterator end() { return m_end; }
+
+protected :
+
+    template <typename CopyPolicy>
+    explicit points_view(CopyPolicy const& copy)
+    {
+       copy.apply(m_points);
+    }
+
+private :
+    // Copy points here - box might define them otherwise
+    Point m_points[MaxSize];
+};
+
+}
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_VIEWS_DETAIL_POINTS_VIEW_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/range_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/range_type.hpp
new file mode 100644
index 00000000000..fff634c3793
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/range_type.hpp
@@ -0,0 +1,134 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_VIEWS_DETAIL_RANGE_TYPE_HPP
+#define BOOST_GEOMETRY_VIEWS_DETAIL_RANGE_TYPE_HPP
+
+
+#include <boost/mpl/assert.hpp>
+#include <boost/range/value_type.hpp>
+
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/views/box_view.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace dispatch
+{
+
+
+template <typename Geometry,
+          typename Tag = typename tag<Geometry>::type>
+struct range_type
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_OR_NOT_YET_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
+            , (types<Geometry>)
+        );
+};
+
+
+template <typename Geometry>
+struct range_type<Geometry, ring_tag>
+{
+    typedef Geometry type;
+};
+
+
+template <typename Geometry>
+struct range_type<Geometry, linestring_tag>
+{
+    typedef Geometry type;
+};
+
+
+template <typename Geometry>
+struct range_type<Geometry, polygon_tag>
+{
+    typedef typename ring_type<Geometry>::type type;
+};
+
+
+template <typename Geometry>
+struct range_type<Geometry, box_tag>
+{
+    typedef box_view<Geometry> type;
+};
+
+
+// multi-point acts itself as a range
+template <typename Geometry>
+struct range_type<Geometry, multi_point_tag>
+{
+    typedef Geometry type;
+};
+
+
+template <typename Geometry>
+struct range_type<Geometry, multi_linestring_tag>
+{
+    typedef typename boost::range_value<Geometry>::type type;
+};
+
+
+template <typename Geometry>
+struct range_type<Geometry, multi_polygon_tag>
+{
+    // Call its single-version
+    typedef typename dispatch::range_type
+        <
+            typename boost::range_value<Geometry>::type
+        >::type type;
+};
+
+
+} // namespace dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+// Will probably be replaced by the more generic "view_as", therefore in detail
+namespace detail
+{
+
+
+/*!
+\brief Meta-function defining a type which is a boost-range.
+\details
+- For linestrings and rings, it defines the type itself.
+- For polygons it defines the ring type.
+- For multi-points, it defines the type itself
+- For multi-polygons and multi-linestrings, it defines the single-version
+    (so in the end the linestring and ring-type-of-multi-polygon)
+\ingroup iterators
+*/
+template <typename Geometry>
+struct range_type
+{
+    typedef typename dispatch::range_type
+        <
+            Geometry
+        >::type type;
+};
+
+}
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_VIEWS_DETAIL_RANGE_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/two_dimensional_view.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/two_dimensional_view.hpp
new file mode 100644
index 00000000000..fbd993cafc1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/views/detail/two_dimensional_view.hpp
@@ -0,0 +1,196 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Licensed under the Boost Software License version 1.0.
+// http://www.boost.org/users/license.html
+
+#ifndef BOOST_GEOMETRY_VIEWS_DETAIL_TWO_DIMENSIONAL_VIEW_HPP
+#define BOOST_GEOMETRY_VIEWS_DETAIL_TWO_DIMENSIONAL_VIEW_HPP
+
+#include <cstddef>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/int.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/coordinate_system.hpp>
+#include <boost/geometry/core/coordinate_dimension.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/algorithms/not_implemented.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template
+<
+    typename Geometry,
+    std::size_t Dimension1 = 0,
+    std::size_t Dimension2 = 1,
+    typename Tag = typename tag<Geometry>::type
+>
+struct two_dimensional_view
+    : not_implemented<Tag>
+{};
+
+
+// View that enables to choose two dimensions of a point and see it as
+// a two-dimensional point
+template <typename Point, std::size_t Dimension1, std::size_t Dimension2>
+struct two_dimensional_view<Point, Dimension1, Dimension2, point_tag>
+{
+    BOOST_MPL_ASSERT_MSG(
+        (Dimension1 < static_cast<std::size_t>(dimension<Point>::value)),
+        COORDINATE_DIMENSION1_IS_LARGER_THAN_POINT_DIMENSION,
+        (boost::mpl::int_<Dimension1>));
+
+    BOOST_MPL_ASSERT_MSG(
+        (Dimension2 < static_cast<std::size_t>(dimension<Point>::value)),
+        COORDINATE_DIMENSION2_IS_LARGER_THAN_POINT_DIMENSION,
+        (boost::mpl::int_<Dimension2>));
+
+    two_dimensional_view(Point& point)
+        : m_point(point)
+    {}
+
+    Point& m_point;
+};
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+
+template <typename Point, std::size_t Dimension1, std::size_t Dimension2>
+struct tag
+    <
+        geometry::detail::two_dimensional_view
+            <
+                Point, Dimension1, Dimension2, point_tag
+            >
+    >
+{
+    typedef point_tag type;
+};
+
+template <typename Point, std::size_t Dimension1, std::size_t Dimension2>
+struct coordinate_system
+    <
+        geometry::detail::two_dimensional_view
+            <
+                Point, Dimension1, Dimension2, point_tag
+            >
+    > : coordinate_system<typename geometry::point_type<Point>::type>
+{};
+
+template <typename Point, std::size_t Dimension1, std::size_t Dimension2>
+struct coordinate_type
+    <
+        geometry::detail::two_dimensional_view
+            <
+                Point, Dimension1, Dimension2, point_tag
+            >
+    > : coordinate_type<typename geometry::point_type<Point>::type>
+{};
+
+template <typename Point, std::size_t Dimension1, std::size_t Dimension2>
+struct dimension
+    <
+        geometry::detail::two_dimensional_view
+            <
+                Point, Dimension1, Dimension2, point_tag
+            >
+    > : boost::mpl::int_<2>
+{};
+
+template <typename Point, std::size_t Dimension1, std::size_t Dimension2>
+struct point_type
+    <
+        geometry::detail::two_dimensional_view
+            <
+                Point, Dimension1, Dimension2, point_tag
+            >
+    >
+{
+    typedef typename geometry::point_type<Point>::type type;
+};
+
+
+template <typename Point, std::size_t Dimension1, std::size_t Dimension2>
+struct access
+    <
+        geometry::detail::two_dimensional_view
+            <
+                Point, Dimension1, Dimension2, point_tag
+            >,
+        0
+    >
+{
+    typedef typename geometry::coordinate_type<Point>::type coordinate_type;
+    typedef geometry::detail::two_dimensional_view
+        <
+            Point, Dimension1, Dimension2, point_tag
+        > view_type;
+
+    static inline coordinate_type get(view_type const& view)
+    {
+        return geometry::get<Dimension1>(view.m_point);
+    }
+
+    static inline void set(view_type& view, coordinate_type const& value)
+    {
+        geometry::set<Dimension1>(view.m_point, value);
+    }
+};
+
+template <typename Point, std::size_t Dimension1, std::size_t Dimension2>
+struct access
+    <
+        geometry::detail::two_dimensional_view
+            <
+                Point, Dimension1, Dimension2, point_tag
+            >,
+        1
+    >
+{
+    typedef typename geometry::coordinate_type<Point>::type coordinate_type;
+    typedef geometry::detail::two_dimensional_view
+        <
+            Point, Dimension1, Dimension2, point_tag
+        > view_type;
+
+    static inline coordinate_type get(view_type const& view)
+    {
+        return geometry::get<Dimension2>(view.m_point);
+    }
+
+    static inline void set(view_type& view, coordinate_type const& value)
+    {
+        geometry::set<Dimension2>(view.m_point, value);
+    }
+};
+
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_VIEWS_DETAIL_TWO_DIMENSIONAL_VIEW_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/views/identity_view.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/views/identity_view.hpp
new file mode 100644
index 00000000000..8947ebf6fc0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/views/identity_view.hpp
@@ -0,0 +1,61 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_VIEWS_IDENTITY_VIEW_HPP
+#define BOOST_GEOMETRY_VIEWS_IDENTITY_VIEW_HPP
+
+
+#include <boost/range.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+// Silence warning C4512: assignment operator could not be generated
+#if defined(_MSC_VER)
+#pragma warning(push)
+#pragma warning(disable : 4512)
+#endif
+
+/*!
+\brief View on a range, not modifying anything
+\tparam Range original range
+\ingroup views
+*/
+template <typename Range>
+struct identity_view
+{
+    typedef typename boost::range_iterator<Range const>::type const_iterator;
+    typedef typename boost::range_iterator<Range>::type iterator;
+
+    explicit inline identity_view(Range& r)
+        : m_range(r)
+    {}
+
+    inline const_iterator begin() const { return boost::begin(m_range); }
+    inline const_iterator end() const { return boost::end(m_range); }
+
+    inline iterator begin() { return boost::begin(m_range); }
+    inline iterator end() { return boost::end(m_range); }
+private :
+    Range& m_range;
+};
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_VIEWS_IDENTITY_VIEW_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/views/reversible_view.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/views/reversible_view.hpp
new file mode 100644
index 00000000000..ad22136c813
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/views/reversible_view.hpp
@@ -0,0 +1,74 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_VIEWS_REVERSIBLE_VIEW_HPP
+#define BOOST_GEOMETRY_VIEWS_REVERSIBLE_VIEW_HPP
+
+
+#include <boost/version.hpp>
+#include <boost/range.hpp>
+#include <boost/range/adaptor/reversed.hpp>
+
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+#include <boost/geometry/views/identity_view.hpp>
+
+namespace boost { namespace geometry
+{
+
+/*!
+\brief Flag for iterating a reversible_view in forward or reverse direction
+\ingroup views
+*/
+enum iterate_direction { iterate_forward, iterate_reverse };
+
+/*!
+\brief View on a range, reversing direction if necessary
+\tparam Range original range
+\tparam Direction direction of iteration
+\ingroup views
+*/
+template <typename Range, iterate_direction Direction>
+struct reversible_view {};
+
+
+
+#ifndef DOXYGEN_NO_SPECIALIZATIONS
+
+template <typename Range>
+struct reversible_view<Range, iterate_forward>
+{
+    typedef identity_view<Range> type;
+};
+
+
+template <typename Range>
+struct reversible_view<Range, iterate_reverse>
+{
+#if BOOST_VERSION > 104500
+    typedef boost::reversed_range<Range> type;
+#else
+    // For older versions of Boost
+    typedef boost::range_detail::reverse_range<Range> type;
+#endif
+};
+
+#endif // DOXYGEN_NO_SPECIALIZATIONS
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_VIEWS_REVERSIBLE_VIEW_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/views/segment_view.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/views/segment_view.hpp
new file mode 100644
index 00000000000..ce676fc4bf2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/views/segment_view.hpp
@@ -0,0 +1,100 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_VIEWS_SEGMENT_VIEW_HPP
+#define BOOST_GEOMETRY_VIEWS_SEGMENT_VIEW_HPP
+
+
+#include <boost/range.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/views/detail/points_view.hpp>
+#include <boost/geometry/algorithms/assign.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+/*!
+\brief Makes a segment behave like a linestring or a range
+\details Adapts a segment to the Boost.Range concept, enabling the user to
+    iterate the two segment points. The segment_view is registered as a LineString Concept
+\tparam Segment \tparam_geometry{Segment}
+\ingroup views
+
+\qbk{before.synopsis,
+[heading Model of]
+[link geometry.reference.concepts.concept_linestring LineString Concept]
+}
+
+\qbk{[include reference/views/segment_view.qbk]}
+
+*/
+template <typename Segment>
+struct segment_view
+    : public detail::points_view
+        <
+            typename geometry::point_type<Segment>::type,
+            2
+        >
+{
+    typedef typename geometry::point_type<Segment>::type point_type;
+
+    /// Constructor accepting the segment to adapt
+    explicit segment_view(Segment const& segment)
+        : detail::points_view<point_type, 2>(copy_policy(segment))
+    {}
+
+private :
+
+    class copy_policy
+    {
+    public :
+        inline copy_policy(Segment const& segment)
+            : m_segment(segment)
+        {}
+
+        inline void apply(point_type* points) const
+        {
+            geometry::detail::assign_point_from_index<0>(m_segment, points[0]);
+            geometry::detail::assign_point_from_index<1>(m_segment, points[1]);
+        }
+    private :
+        Segment const& m_segment;
+    };
+
+};
+
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+// All segment ranges can be handled as linestrings
+namespace traits
+{
+
+template<typename Segment>
+struct tag<segment_view<Segment> >
+{
+    typedef linestring_tag type;
+};
+
+}
+
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_VIEWS_SEGMENT_VIEW_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/get_pointer.hpp b/contrib/libboost/boost_1_65_0/boost/get_pointer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/get_pointer.hpp
rename to contrib/libboost/boost_1_65_0/boost/get_pointer.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/integer.hpp b/contrib/libboost/boost_1_65_0/boost/integer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/integer.hpp
rename to contrib/libboost/boost_1_65_0/boost/integer.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/integer/common_factor.hpp b/contrib/libboost/boost_1_65_0/boost/integer/common_factor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/integer/common_factor.hpp
rename to contrib/libboost/boost_1_65_0/boost/integer/common_factor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/integer/common_factor_ct.hpp b/contrib/libboost/boost_1_65_0/boost/integer/common_factor_ct.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/integer/common_factor_ct.hpp
rename to contrib/libboost/boost_1_65_0/boost/integer/common_factor_ct.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/integer/common_factor_rt.hpp b/contrib/libboost/boost_1_65_0/boost/integer/common_factor_rt.hpp
new file mode 100644
index 00000000000..341b316501c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/integer/common_factor_rt.hpp
@@ -0,0 +1,578 @@
+//  (C) Copyright Jeremy William Murphy 2016.
+
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_INTEGER_COMMON_FACTOR_RT_HPP
+#define BOOST_INTEGER_COMMON_FACTOR_RT_HPP
+
+#include <boost/assert.hpp>
+#include <boost/core/enable_if.hpp>
+
+#include <boost/config.hpp>  // for BOOST_NESTED_TEMPLATE, etc.
+#include <boost/limits.hpp>  // for std::numeric_limits
+#include <climits>           // for CHAR_MIN
+#include <boost/detail/workaround.hpp>
+#include <iterator>
+#include <algorithm>
+#include <limits>
+#ifndef BOOST_NO_CXX11_HDR_TYPE_TRAITS
+#include <type_traits>
+#endif
+#ifdef BOOST_NO_CXX11_HDR_FUNCTIONAL
+#include <functional>
+#endif
+
+#if ((defined(BOOST_MSVC) && (BOOST_MSVC >= 1600)) || (defined(__clang__) && defined(__c2__)) || (defined(BOOST_INTEL) && defined(_MSC_VER))) && (defined(_M_IX86) || defined(_M_X64))
+#include <intrin.h>
+#endif
+
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4127 4244)  // Conditional expression is constant
+#endif
+
+#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) && !defined(BOOST_NO_CXX11_NOEXCEPT)
+#define BOOST_GCD_NOEXCEPT(T) noexcept(std::is_arithmetic<T>::value)
+#else
+#define BOOST_GCD_NOEXCEPT(T)
+#endif
+
+namespace boost {
+
+   template <class I>
+   class rational;
+
+   namespace integer {
+
+      namespace gcd_detail{
+
+         //
+         // some helper functions which really should be constexpr already, but sadly aren't:
+         //
+#ifndef BOOST_NO_CXX14_CONSTEXPR
+         template <class T>
+         inline constexpr T constexpr_min(T const& a, T const& b) BOOST_GCD_NOEXCEPT(T)
+         {
+            return a < b ? a : b;
+         }
+         template <class T>
+         inline constexpr auto constexpr_swap(T&a, T& b) BOOST_GCD_NOEXCEPT(T) -> decltype(a.swap(b))
+         {
+            return a.swap(b);
+         }
+         template <class T, class U>
+         inline constexpr void constexpr_swap(T&a, U& b...) BOOST_GCD_NOEXCEPT(T)
+         {
+            T t(static_cast<T&&>(a));
+            a = static_cast<T&&>(b);
+            b = static_cast<T&&>(t);
+         }
+#else
+         template <class T>
+         inline T constexpr_min(T const& a, T const& b) BOOST_GCD_NOEXCEPT(T)
+         {
+            return a < b ? a : b;
+         }
+         template <class T>
+         inline void constexpr_swap(T&a, T& b) BOOST_GCD_NOEXCEPT(T)
+         {
+            using std::swap;
+            swap(a, b);
+         }
+#endif
+
+      template <class T, bool a = 
+#ifndef BOOST_NO_CXX11_HDR_TYPE_TRAITS
+         std::is_unsigned<T>::value || 
+#endif
+         (std::numeric_limits<T>::is_specialized && !std::numeric_limits<T>::is_signed)>
+      struct gcd_traits_abs_defaults
+      {
+         inline static BOOST_CXX14_CONSTEXPR const T& abs(const T& val) BOOST_GCD_NOEXCEPT(T) { return val; }
+      };
+      template <class T>
+      struct gcd_traits_abs_defaults<T, false>
+      {
+         inline static T BOOST_CXX14_CONSTEXPR abs(const T& val) BOOST_GCD_NOEXCEPT(T)
+         {
+            // This sucks, but std::abs is not constexpr :(
+            return val < T(0) ? -val : val;
+         }
+      };
+
+      enum method_type
+      {
+         method_euclid = 0,
+         method_binary = 1,
+         method_mixed = 2
+      };
+
+      struct any_convert
+      {
+         template <class T>
+         any_convert(const T&);
+      };
+
+      struct unlikely_size
+      {
+         char buf[9973];
+      };
+
+      unlikely_size operator <<= (any_convert, any_convert);
+      unlikely_size operator >>= (any_convert, any_convert);
+
+      template <class T>
+      struct gcd_traits_defaults : public gcd_traits_abs_defaults<T>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(T& val) BOOST_GCD_NOEXCEPT(T)
+         {
+            unsigned r = 0;
+            while(0 == (val & 1u))
+            {
+#ifdef _MSC_VER  // VC++ can't handle operator >>= in constexpr code for some reason
+               val = val >> 1;
+#else
+               val >>= 1;
+#endif
+               ++r;
+            }
+            return r;
+         }
+         inline static BOOST_CXX14_CONSTEXPR bool less(const T& a, const T& b) BOOST_GCD_NOEXCEPT(T)
+         {
+            return a < b;
+         }
+
+         static T& get_value();
+
+#ifndef BOOST_NO_SFINAE
+         static const bool has_operator_left_shift_equal = sizeof(get_value() <<= 2) != sizeof(unlikely_size);
+         static const bool has_operator_right_shift_equal = sizeof(get_value() >>= 2) != sizeof(unlikely_size);
+#else
+         static const bool has_operator_left_shift_equal = true;
+         static const bool has_operator_right_shift_equal = true;
+#endif
+         static const method_type method = std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::is_integer && has_operator_left_shift_equal && has_operator_right_shift_equal ? method_mixed : method_euclid;
+      };
+      //
+      // Default gcd_traits just inherits from defaults:
+      //
+      template <class T>
+      struct gcd_traits : public gcd_traits_defaults<T> {};
+
+      //
+      // Some platforms have fast bitscan operations, that allow us to implement
+      // make_odd much more efficiently, unfortunately we can't use these if we want
+      // the functions to be constexpr as the compiler intrinsics aren't constexpr.
+      //
+#if defined(BOOST_NO_CXX14_CONSTEXPR) && ((defined(BOOST_MSVC) && (BOOST_MSVC >= 1600)) || (defined(__clang__) && defined(__c2__)) || (defined(BOOST_INTEL) && defined(_MSC_VER))) && (defined(_M_IX86) || defined(_M_X64))
+#pragma intrinsic(_BitScanForward,)
+      template <>
+      struct gcd_traits<unsigned long> : public gcd_traits_defaults<unsigned long>
+      {
+         BOOST_FORCEINLINE static unsigned find_lsb(unsigned long val) BOOST_NOEXCEPT
+         {
+            unsigned long result;
+            _BitScanForward(&result, val);
+            return result;
+         }
+         BOOST_FORCEINLINE static unsigned make_odd(unsigned long& val) BOOST_NOEXCEPT
+         {
+            unsigned result = find_lsb(val);
+            val >>= result;
+            return result;
+         }
+      };
+
+#ifdef _M_X64
+#pragma intrinsic(_BitScanForward64)
+      template <>
+      struct gcd_traits<unsigned __int64> : public gcd_traits_defaults<unsigned __int64>
+      {
+         BOOST_FORCEINLINE static unsigned find_lsb(unsigned __int64 mask) BOOST_NOEXCEPT
+         {
+            unsigned long result;
+            _BitScanForward64(&result, mask);
+            return result;
+         }
+         BOOST_FORCEINLINE static unsigned make_odd(unsigned __int64& val) BOOST_NOEXCEPT
+         {
+            unsigned result = find_lsb(val);
+            val >>= result;
+            return result;
+         }
+      };
+#endif
+      //
+      // Other integer type are trivial adaptations of the above,
+      // this works for signed types too, as by the time these functions
+      // are called, all values are > 0.
+      //
+      template <> struct gcd_traits<long> : public gcd_traits_defaults<long> 
+      { BOOST_FORCEINLINE static unsigned make_odd(long& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
+      template <> struct gcd_traits<unsigned int> : public gcd_traits_defaults<unsigned int> 
+      { BOOST_FORCEINLINE static unsigned make_odd(unsigned int& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
+      template <> struct gcd_traits<int> : public gcd_traits_defaults<int> 
+      { BOOST_FORCEINLINE static unsigned make_odd(int& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
+      template <> struct gcd_traits<unsigned short> : public gcd_traits_defaults<unsigned short> 
+      { BOOST_FORCEINLINE static unsigned make_odd(unsigned short& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
+      template <> struct gcd_traits<short> : public gcd_traits_defaults<short> 
+      { BOOST_FORCEINLINE static unsigned make_odd(short& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
+      template <> struct gcd_traits<unsigned char> : public gcd_traits_defaults<unsigned char> 
+      { BOOST_FORCEINLINE static unsigned make_odd(unsigned char& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
+      template <> struct gcd_traits<signed char> : public gcd_traits_defaults<signed char> 
+      { BOOST_FORCEINLINE static signed make_odd(signed char& val)BOOST_NOEXCEPT{ signed result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
+      template <> struct gcd_traits<char> : public gcd_traits_defaults<char> 
+      { BOOST_FORCEINLINE static unsigned make_odd(char& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+      template <> struct gcd_traits<wchar_t> : public gcd_traits_defaults<wchar_t> 
+      { BOOST_FORCEINLINE static unsigned make_odd(wchar_t& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
+#endif
+#ifdef _M_X64
+      template <> struct gcd_traits<__int64> : public gcd_traits_defaults<__int64> 
+      { BOOST_FORCEINLINE static unsigned make_odd(__int64& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned __int64>::find_lsb(val); val >>= result; return result; } };
+#endif
+
+#elif defined(BOOST_GCC) || defined(__clang__) || (defined(BOOST_INTEL) && defined(__GNUC__))
+
+      template <>
+      struct gcd_traits<unsigned> : public gcd_traits_defaults<unsigned>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned find_lsb(unsigned mask)BOOST_NOEXCEPT
+         {
+            return __builtin_ctz(mask);
+         }
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(unsigned& val)BOOST_NOEXCEPT
+         {
+            unsigned result = find_lsb(val);
+            val >>= result;
+            return result;
+         }
+      };
+      template <>
+      struct gcd_traits<unsigned long> : public gcd_traits_defaults<unsigned long>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned find_lsb(unsigned long mask)BOOST_NOEXCEPT
+         {
+            return __builtin_ctzl(mask);
+         }
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(unsigned long& val)BOOST_NOEXCEPT
+         {
+            unsigned result = find_lsb(val);
+            val >>= result;
+            return result;
+         }
+      };
+      template <>
+      struct gcd_traits<boost::ulong_long_type> : public gcd_traits_defaults<boost::ulong_long_type>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned find_lsb(boost::ulong_long_type mask)BOOST_NOEXCEPT
+         {
+            return __builtin_ctzll(mask);
+         }
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(boost::ulong_long_type& val)BOOST_NOEXCEPT
+         {
+            unsigned result = find_lsb(val);
+            val >>= result;
+            return result;
+         }
+      };
+      //
+      // Other integer type are trivial adaptations of the above,
+      // this works for signed types too, as by the time these functions
+      // are called, all values are > 0.
+      //
+      template <> struct gcd_traits<boost::long_long_type> : public gcd_traits_defaults<boost::long_long_type>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(boost::long_long_type& val)BOOST_NOEXCEPT { unsigned result = gcd_traits<boost::ulong_long_type>::find_lsb(val); val >>= result; return result; }
+      };
+      template <> struct gcd_traits<long> : public gcd_traits_defaults<long>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(long& val)BOOST_NOEXCEPT { unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; }
+      };
+      template <> struct gcd_traits<int> : public gcd_traits_defaults<int>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(int& val)BOOST_NOEXCEPT { unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; }
+      };
+      template <> struct gcd_traits<unsigned short> : public gcd_traits_defaults<unsigned short>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(unsigned short& val)BOOST_NOEXCEPT { unsigned result = gcd_traits<unsigned>::find_lsb(val); val >>= result; return result; }
+      };
+      template <> struct gcd_traits<short> : public gcd_traits_defaults<short>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(short& val)BOOST_NOEXCEPT { unsigned result = gcd_traits<unsigned>::find_lsb(val); val >>= result; return result; }
+      };
+      template <> struct gcd_traits<unsigned char> : public gcd_traits_defaults<unsigned char>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(unsigned char& val)BOOST_NOEXCEPT { unsigned result = gcd_traits<unsigned>::find_lsb(val); val >>= result; return result; }
+      };
+      template <> struct gcd_traits<signed char> : public gcd_traits_defaults<signed char>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR signed make_odd(signed char& val)BOOST_NOEXCEPT { signed result = gcd_traits<unsigned>::find_lsb(val); val >>= result; return result; }
+      };
+      template <> struct gcd_traits<char> : public gcd_traits_defaults<char>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(char& val)BOOST_NOEXCEPT { unsigned result = gcd_traits<unsigned>::find_lsb(val); val >>= result; return result; }
+      };
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T
+      template <> struct gcd_traits<wchar_t> : public gcd_traits_defaults<wchar_t>
+      {
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(wchar_t& val)BOOST_NOEXCEPT { unsigned result = gcd_traits<unsigned>::find_lsb(val); val >>= result; return result; }
+      };
+#endif
+#endif
+   //
+   // The Mixed Binary Euclid Algorithm
+   // Sidi Mohamed Sedjelmaci
+   // Electronic Notes in Discrete Mathematics 35 (2009) 169-176
+   //
+   template <class T>
+   BOOST_CXX14_CONSTEXPR T mixed_binary_gcd(T u, T v) BOOST_GCD_NOEXCEPT(T)
+   {
+      if(gcd_traits<T>::less(u, v))
+         constexpr_swap(u, v);
+
+      unsigned shifts = 0;
+
+      if(u == T(0))
+         return v;
+      if(v == T(0))
+         return u;
+
+      shifts = constexpr_min(gcd_traits<T>::make_odd(u), gcd_traits<T>::make_odd(v));
+
+      while(gcd_traits<T>::less(1, v))
+      {
+         u %= v;
+         v -= u;
+         if(u == T(0))
+            return v << shifts;
+         if(v == T(0))
+            return u << shifts;
+         gcd_traits<T>::make_odd(u);
+         gcd_traits<T>::make_odd(v);
+         if(gcd_traits<T>::less(u, v))
+            constexpr_swap(u, v);
+      }
+      return (v == 1 ? v : u) << shifts;
+   }
+
+    /** Stein gcd (aka 'binary gcd')
+     * 
+     * From Mathematics to Generic Programming, Alexander Stepanov, Daniel Rose
+     */
+    template <typename SteinDomain>
+    BOOST_CXX14_CONSTEXPR SteinDomain Stein_gcd(SteinDomain m, SteinDomain n) BOOST_GCD_NOEXCEPT(SteinDomain)
+    {
+        BOOST_ASSERT(m >= 0);
+        BOOST_ASSERT(n >= 0);
+        if (m == SteinDomain(0))
+            return n;
+        if (n == SteinDomain(0))
+            return m;
+        // m > 0 && n > 0
+        int d_m = gcd_traits<SteinDomain>::make_odd(m);
+        int d_n = gcd_traits<SteinDomain>::make_odd(n);
+        // odd(m) && odd(n)
+        while (m != n)
+        {
+            if (n > m)
+               constexpr_swap(n, m);
+            m -= n;
+            gcd_traits<SteinDomain>::make_odd(m);
+        }
+        // m == n
+        m <<= constexpr_min(d_m, d_n);
+        return m;
+    }
+
+    
+    /** Euclidean algorithm
+     * 
+     * From Mathematics to Generic Programming, Alexander Stepanov, Daniel Rose
+     * 
+     */
+    template <typename EuclideanDomain>
+    inline BOOST_CXX14_CONSTEXPR EuclideanDomain Euclid_gcd(EuclideanDomain a, EuclideanDomain b) BOOST_GCD_NOEXCEPT(EuclideanDomain)
+    {
+        while (b != EuclideanDomain(0))
+        {
+            a %= b;
+            constexpr_swap(a, b);
+        }
+        return a;
+    }
+
+
+    template <typename T>
+    inline BOOST_CXX14_CONSTEXPR BOOST_DEDUCED_TYPENAME enable_if_c<gcd_traits<T>::method == method_mixed, T>::type
+       optimal_gcd_select(T const &a, T const &b) BOOST_GCD_NOEXCEPT(T)
+    {
+       return gcd_detail::mixed_binary_gcd(a, b);
+    }
+
+    template <typename T>
+    inline BOOST_CXX14_CONSTEXPR BOOST_DEDUCED_TYPENAME enable_if_c<gcd_traits<T>::method == method_binary, T>::type
+       optimal_gcd_select(T const &a, T const &b) BOOST_GCD_NOEXCEPT(T)
+    {
+       return gcd_detail::Stein_gcd(a, b);
+    }
+
+    template <typename T>
+    inline BOOST_CXX14_CONSTEXPR BOOST_DEDUCED_TYPENAME enable_if_c<gcd_traits<T>::method == method_euclid, T>::type
+       optimal_gcd_select(T const &a, T const &b) BOOST_GCD_NOEXCEPT(T)
+    {
+       return gcd_detail::Euclid_gcd(a, b);
+    }
+
+    template <class T>
+    inline BOOST_CXX14_CONSTEXPR T lcm_imp(const T& a, const T& b) BOOST_GCD_NOEXCEPT(T)
+    {
+       T temp = boost::integer::gcd_detail::optimal_gcd_select(a, b);
+#if BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500)
+       return (temp != T(0)) ? T(a / temp * b) : T(0);
+#else
+       return temp != T(0) ? T(a / temp * b) : T(0);
+#endif
+    }
+
+} // namespace detail
+
+
+template <typename Integer>
+inline BOOST_CXX14_CONSTEXPR Integer gcd(Integer const &a, Integer const &b) BOOST_GCD_NOEXCEPT(Integer)
+{
+    if(a == (std::numeric_limits<Integer>::min)())
+       return a == static_cast<Integer>(0) ? gcd_detail::gcd_traits<Integer>::abs(b) : boost::integer::gcd(static_cast<Integer>(a % b), b);
+    else if (b == (std::numeric_limits<Integer>::min)())
+       return b == static_cast<Integer>(0) ? gcd_detail::gcd_traits<Integer>::abs(a) : boost::integer::gcd(a, static_cast<Integer>(b % a));
+    return gcd_detail::optimal_gcd_select(static_cast<Integer>(gcd_detail::gcd_traits<Integer>::abs(a)), static_cast<Integer>(gcd_detail::gcd_traits<Integer>::abs(b)));
+}
+
+template <typename Integer>
+inline BOOST_CXX14_CONSTEXPR Integer lcm(Integer const &a, Integer const &b) BOOST_GCD_NOEXCEPT(Integer)
+{
+   return gcd_detail::lcm_imp(static_cast<Integer>(gcd_detail::gcd_traits<Integer>::abs(a)), static_cast<Integer>(gcd_detail::gcd_traits<Integer>::abs(b)));
+}
+#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+//
+// This looks slightly odd, but the variadic forms must have 3 or more arguments, and the variadic argument pack may be empty.
+// This matters not at all for most compilers, but Oracle C++ selects the wrong overload in the 2-arg case unless we do this.
+//
+template <typename Integer, typename... Args>
+inline BOOST_CXX14_CONSTEXPR Integer gcd(Integer const &a, Integer const &b, const Integer& c, Args const&... args) BOOST_GCD_NOEXCEPT(Integer)
+{
+   Integer t = gcd(b, c, args...);
+   return t == 1 ? 1 : gcd(a, t);
+}
+
+template <typename Integer, typename... Args>
+inline BOOST_CXX14_CONSTEXPR Integer lcm(Integer const &a, Integer const &b, Integer const& c, Args const&... args) BOOST_GCD_NOEXCEPT(Integer)
+{
+   return lcm(a, lcm(b, c, args...));
+}
+#endif
+//
+// Special handling for rationals:
+//
+template <typename Integer>
+inline typename boost::enable_if_c<std::numeric_limits<Integer>::is_specialized, boost::rational<Integer> >::type gcd(boost::rational<Integer> const &a, boost::rational<Integer> const &b)
+{
+   return boost::rational<Integer>(static_cast<Integer>(gcd(a.numerator(), b.numerator())), static_cast<Integer>(lcm(a.denominator(), b.denominator())));
+}
+
+template <typename Integer>
+inline typename boost::enable_if_c<std::numeric_limits<Integer>::is_specialized, boost::rational<Integer> >::type lcm(boost::rational<Integer> const &a, boost::rational<Integer> const &b)
+{
+   return boost::rational<Integer>(static_cast<Integer>(lcm(a.numerator(), b.numerator())), static_cast<Integer>(gcd(a.denominator(), b.denominator())));
+}
+/**
+ * Knuth, The Art of Computer Programming: Volume 2, Third edition, 1998
+ * Chapter 4.5.2, Algorithm C: Greatest common divisor of n integers.
+ *
+ * Knuth counts down from n to zero but we naturally go from first to last.
+ * We also return the termination position because it might be useful to know.
+ * 
+ * Partly by quirk, partly by design, this algorithm is defined for n = 1, 
+ * because the gcd of {x} is x. It is not defined for n = 0.
+ * 
+ * @tparam  I   Input iterator.
+ * @return  The gcd of the range and the iterator position at termination.
+ */
+template <typename I>
+std::pair<typename std::iterator_traits<I>::value_type, I>
+gcd_range(I first, I last) BOOST_GCD_NOEXCEPT(I)
+{
+    BOOST_ASSERT(first != last);
+    typedef typename std::iterator_traits<I>::value_type T;
+    
+    T d = *first++;
+    while (d != T(1) && first != last)
+    {
+        d = gcd(d, *first);
+        first++;
+    }
+    return std::make_pair(d, first);
+}
+template <typename I>
+std::pair<typename std::iterator_traits<I>::value_type, I>
+lcm_range(I first, I last) BOOST_GCD_NOEXCEPT(I)
+{
+    BOOST_ASSERT(first != last);
+    typedef typename std::iterator_traits<I>::value_type T;
+    
+    T d = *first++;
+    while (d != T(1) && first != last)
+    {
+        d = lcm(d, *first);
+        first++;
+    }
+    return std::make_pair(d, first);
+}
+
+template < typename IntegerType >
+class gcd_evaluator
+#ifdef BOOST_NO_CXX11_HDR_FUNCTIONAL
+   : public std::binary_function<IntegerType, IntegerType, IntegerType>
+#endif
+{
+public:
+#ifndef BOOST_NO_CXX11_HDR_FUNCTIONAL
+   typedef IntegerType first_argument_type;
+   typedef IntegerType second_argument_type;
+   typedef IntegerType result_type;
+#endif
+   IntegerType operator()(IntegerType const &a, IntegerType const &b)const
+   {
+      return boost::integer::gcd(a, b);
+   }
+};
+
+template < typename IntegerType >
+class lcm_evaluator
+#ifdef BOOST_NO_CXX11_HDR_FUNCTIONAL
+   : public std::binary_function<IntegerType, IntegerType, IntegerType>
+#endif
+{
+public:
+#ifndef BOOST_NO_CXX11_HDR_FUNCTIONAL
+   typedef IntegerType first_argument_type;
+   typedef IntegerType second_argument_type;
+   typedef IntegerType result_type;
+#endif
+   IntegerType operator()(IntegerType const &a, IntegerType const &b)const
+   {
+      return boost::integer::lcm(a, b);
+   }
+};
+
+}  // namespace integer
+}  // namespace boost
+
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
+
+#endif  // BOOST_INTEGER_COMMON_FACTOR_RT_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/integer/integer_log2.hpp b/contrib/libboost/boost_1_65_0/boost/integer/integer_log2.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/integer/integer_log2.hpp
rename to contrib/libboost/boost_1_65_0/boost/integer/integer_log2.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/integer/integer_mask.hpp b/contrib/libboost/boost_1_65_0/boost/integer/integer_mask.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/integer/integer_mask.hpp
rename to contrib/libboost/boost_1_65_0/boost/integer/integer_mask.hpp
index 2acf7f7dff5..eee4679b84b 100644
--- a/contrib/libboost/boost_1_62_0/boost/integer/integer_mask.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/integer/integer_mask.hpp
@@ -57,19 +57,27 @@ struct high_bit_mask_t
 //  Makes masks for the lowest N bits
 //  (Specializations are needed when N fills up a type.)
 
+#ifdef BOOST_MSVC
+#pragma warning(push)
+#pragma warning(disable:4310)  // cast truncates constant value
+#endif
+
 template < std::size_t Bits >
 struct low_bits_mask_t
 {
     typedef typename uint_t<Bits>::least  least;
     typedef typename uint_t<Bits>::fast   fast;
 
-    BOOST_STATIC_CONSTANT( least, sig_bits = (~( ~(least( 0u )) << Bits )) );
+    BOOST_STATIC_CONSTANT( least, sig_bits = least(~(least(~(least( 0u ))) << Bits )) );
     BOOST_STATIC_CONSTANT( fast, sig_bits_fast = fast(sig_bits) );
 
     BOOST_STATIC_CONSTANT( std::size_t, bit_count = Bits );
 
 };  // boost::low_bits_mask_t
 
+#ifdef BOOST_MSVC
+#pragma warning(pop)
+#endif
 
 #define BOOST_LOW_BITS_MASK_SPECIALIZE( Type )                                  \
   template <  >  struct low_bits_mask_t< std::numeric_limits<Type>::digits >  { \
diff --git a/contrib/libboost/boost_1_62_0/boost/integer/static_log2.hpp b/contrib/libboost/boost_1_65_0/boost/integer/static_log2.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/integer/static_log2.hpp
rename to contrib/libboost/boost_1_65_0/boost/integer/static_log2.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/integer/static_min_max.hpp b/contrib/libboost/boost_1_65_0/boost/integer/static_min_max.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/integer/static_min_max.hpp
rename to contrib/libboost/boost_1_65_0/boost/integer/static_min_max.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/integer_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/integer_fwd.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/integer_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/integer_fwd.hpp
index 10577ae294d..18519dd696d 100644
--- a/contrib/libboost/boost_1_62_0/boost/integer_fwd.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/integer_fwd.hpp
@@ -159,6 +159,8 @@ template <static_min_max_unsigned_type Value1, static_min_max_unsigned_type Valu
     struct static_unsigned_max;
 
 
+namespace integer
+{
 //  From <boost/integer/common_factor_ct.hpp>
 
 #ifdef BOOST_NO_INTEGRAL_INT64_T
@@ -180,6 +182,7 @@ template < typename IntegerType >
 template < typename IntegerType >
     class lcm_evaluator;
 
+} // namespace integer
 
 }  // namespace boost
 
diff --git a/contrib/libboost/boost_1_62_0/boost/integer_traits.hpp b/contrib/libboost/boost_1_65_0/boost/integer_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/integer_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/integer_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/any_hook.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/any_hook.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/any_hook.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/any_hook.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/avl_set.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/avl_set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/avl_set.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/avl_set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/avl_set_hook.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/avl_set_hook.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/avl_set_hook.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/avl_set_hook.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/avltree.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/avltree.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/avltree.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/avltree.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/avltree_algorithms.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/avltree_algorithms.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/avltree_algorithms.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/avltree_algorithms.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/bs_set.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/bs_set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/bs_set.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/bs_set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/bs_set_hook.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/bs_set_hook.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/bs_set_hook.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/bs_set_hook.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/bstree.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/bstree.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/bstree.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/bstree.hpp
index f2cdb428b4b..ac67e864a0e 100644
--- a/contrib/libboost/boost_1_62_0/boost/intrusive/bstree.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/intrusive/bstree.hpp
@@ -255,7 +255,8 @@ struct get_key_of_value<void, T>
 template<class ValuePtr, class VoidOrKeyOfValue, class VoidOrKeyComp>
 struct bst_key_types
 {
-   typedef typename pointer_element<ValuePtr>::type   value_type;
+   typedef typename
+      boost::movelib::pointer_element<ValuePtr>::type value_type;
    typedef typename get_key_of_value
       < VoidOrKeyOfValue, value_type>::type           key_of_value;
    typedef typename key_of_value::type                key_type;
@@ -967,7 +968,7 @@ class bstree_impl
    void swap(bstree_impl& other)
    {
       //This can throw
-      ::boost::adl_move_swap(this->comp(), this->comp());
+      ::boost::adl_move_swap(this->comp(), other.comp());
       //These can't throw
       node_algorithms::swap_tree(this->header_ptr(), node_ptr(other.header_ptr()));
       this->sz_traits().swap(other.sz_traits());
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/bstree_algorithms.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/bstree_algorithms.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/bstree_algorithms.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/bstree_algorithms.hpp
index e8caee0c94b..e449ebac081 100644
--- a/contrib/libboost/boost_1_62_0/boost/intrusive/bstree_algorithms.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/intrusive/bstree_algorithms.hpp
@@ -37,6 +37,9 @@ namespace intrusive {
 template <class NodePtr>
 struct insert_commit_data_t
 {
+   BOOST_INTRUSIVE_FORCEINLINE insert_commit_data_t()
+      : link_left(false), node()
+   {}
    bool     link_left;
    NodePtr  node;
 };
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/circular_list_algorithms.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/circular_list_algorithms.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/circular_list_algorithms.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/circular_list_algorithms.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/circular_slist_algorithms.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/circular_slist_algorithms.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/circular_slist_algorithms.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/circular_slist_algorithms.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/derivation_value_traits.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/derivation_value_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/derivation_value_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/derivation_value_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/algo_type.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/algo_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/algo_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/algo_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/algorithm.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/algorithm.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/algorithm.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/algorithm.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/any_node_and_algorithms.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/any_node_and_algorithms.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/any_node_and_algorithms.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/any_node_and_algorithms.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/array_initializer.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/array_initializer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/array_initializer.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/array_initializer.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/assert.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/assert.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/assert.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/assert.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/avltree_node.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/avltree_node.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/avltree_node.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/avltree_node.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/bstree_algorithms_base.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/bstree_algorithms_base.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/bstree_algorithms_base.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/bstree_algorithms_base.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/common_slist_algorithms.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/common_slist_algorithms.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/common_slist_algorithms.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/common_slist_algorithms.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/config_begin.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/config_begin.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/config_begin.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/config_begin.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/config_end.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/config_end.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/config_end.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/config_end.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/default_header_holder.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/default_header_holder.hpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/default_header_holder.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/default_header_holder.hpp
index 288f8a0e41f..ba561b5f5bc 100644
--- a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/default_header_holder.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/default_header_holder.hpp
@@ -23,7 +23,7 @@
 
 #include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/pointer_traits.hpp>
-#include <boost/intrusive/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 
 namespace boost {
 namespace intrusive {
@@ -48,7 +48,7 @@ struct default_header_holder : public NodeTraits::node
 
    // (unsafe) downcast used to implement container-from-iterator
    BOOST_INTRUSIVE_FORCEINLINE static default_header_holder* get_holder(const node_ptr &p)
-   { return static_cast< default_header_holder* >(boost::intrusive::detail::to_raw_pointer(p)); }
+   { return static_cast< default_header_holder* >(boost::movelib::to_raw_pointer(p)); }
 };
 
 // type function producing the header node holder
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/ebo_functor_holder.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/ebo_functor_holder.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/ebo_functor_holder.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/ebo_functor_holder.hpp
index 31b2f813981..27415c11703 100644
--- a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/ebo_functor_holder.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/ebo_functor_holder.hpp
@@ -35,7 +35,7 @@ namespace detail {
 #define BOOST_INTRUSIVE_TT_DECL
 #endif
 
-#if defined(_MSC_EXTENSIONS) && !defined(__BORLAND__) && !defined(_WIN64) && !defined(_M_ARM) && !defined(UNDER_CE)
+#if defined(_MSC_EXTENSIONS) && !defined(__BORLAND__) && !defined(_WIN64) && !defined(_M_ARM) && !defined(_M_ARM64) && !defined(UNDER_CE)
 #define BOOST_INTRUSIVE_TT_TEST_MSC_FUNC_SIGS
 #endif
 
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/empty_node_checker.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/empty_node_checker.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/empty_node_checker.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/empty_node_checker.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/equal_to_value.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/equal_to_value.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/equal_to_value.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/equal_to_value.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/exception_disposer.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/exception_disposer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/exception_disposer.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/exception_disposer.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/function_detector.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/function_detector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/function_detector.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/function_detector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/generic_hook.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/generic_hook.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/generic_hook.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/generic_hook.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/get_value_traits.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/get_value_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/get_value_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/get_value_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/has_member_function_callable_with.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/has_member_function_callable_with.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/has_member_function_callable_with.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/has_member_function_callable_with.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/hashtable_node.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/hashtable_node.hpp
similarity index 88%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/hashtable_node.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/hashtable_node.hpp
index 0471ebe6840..d3b11d1b229 100644
--- a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/hashtable_node.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/hashtable_node.hpp
@@ -40,23 +40,22 @@ template <class Slist>
 struct bucket_impl : public Slist
 {
    typedef Slist slist_type;
-   bucket_impl()
+   BOOST_INTRUSIVE_FORCEINLINE bucket_impl()
    {}
 
-   bucket_impl(const bucket_impl &)
+   BOOST_INTRUSIVE_FORCEINLINE bucket_impl(const bucket_impl &)
    {}
 
-   ~bucket_impl()
+   BOOST_INTRUSIVE_FORCEINLINE ~bucket_impl()
    {
       //This bucket is still being used!
       BOOST_INTRUSIVE_INVARIANT_ASSERT(Slist::empty());
    }
 
-   bucket_impl &operator=(const bucket_impl&)
+   BOOST_INTRUSIVE_FORCEINLINE bucket_impl &operator=(const bucket_impl&)
    {
       //This bucket is still in use!
       BOOST_INTRUSIVE_INVARIANT_ASSERT(Slist::empty());
-      //Slist::clear();
       return *this;
    }
 };
@@ -77,25 +76,25 @@ struct bucket_traits_impl
    typedef typename Slist::size_type size_type;
    /// @endcond
 
-   bucket_traits_impl(bucket_ptr buckets, size_type len)
+   BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl(bucket_ptr buckets, size_type len)
       :  buckets_(buckets), buckets_len_(len)
    {}
 
-   bucket_traits_impl(const bucket_traits_impl &x)
+   BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl(const bucket_traits_impl &x)
       : buckets_(x.buckets_), buckets_len_(x.buckets_len_)
    {}
 
-   bucket_traits_impl(BOOST_RV_REF(bucket_traits_impl) x)
+   BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl(BOOST_RV_REF(bucket_traits_impl) x)
       : buckets_(x.buckets_), buckets_len_(x.buckets_len_)
    {  x.buckets_ = bucket_ptr();   x.buckets_len_ = 0;  }
 
-   bucket_traits_impl& operator=(BOOST_RV_REF(bucket_traits_impl) x)
+   BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl& operator=(BOOST_RV_REF(bucket_traits_impl) x)
    {
       buckets_ = x.buckets_; buckets_len_ = x.buckets_len_;
       x.buckets_ = bucket_ptr();   x.buckets_len_ = 0; return *this;
    }
 
-   bucket_traits_impl& operator=(BOOST_COPY_ASSIGN_REF(bucket_traits_impl) x)
+   BOOST_INTRUSIVE_FORCEINLINE bucket_traits_impl& operator=(BOOST_COPY_ASSIGN_REF(bucket_traits_impl) x)
    {
       buckets_ = x.buckets_;  buckets_len_ = x.buckets_len_; return *this;
    }
@@ -182,7 +181,7 @@ class hashtable_iterator
          < const BucketValueTraits >::type                     const_bucketvaltraits_ptr;
    typedef typename slist_impl::size_type                      size_type;
 
-   static node_ptr downcast_bucket(typename bucket_type::node_ptr p)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr downcast_bucket(typename bucket_type::node_ptr p)
    {
       return pointer_traits<node_ptr>::
          pointer_to(static_cast<typename node_traits::node&>(*p));
@@ -199,17 +198,17 @@ class hashtable_iterator
       , traitsptr_ (cont ? pointer_traits<const_bucketvaltraits_ptr>::pointer_to(*cont) : const_bucketvaltraits_ptr() )
    {}
 
-   hashtable_iterator(const hashtable_iterator<BucketValueTraits, false> &other)
+   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator(const hashtable_iterator<BucketValueTraits, false> &other)
       :  slist_it_(other.slist_it()), traitsptr_(other.get_bucket_value_traits())
    {}
 
    BOOST_INTRUSIVE_FORCEINLINE const siterator &slist_it() const
    { return slist_it_; }
 
-   hashtable_iterator<BucketValueTraits, false> unconst() const
+   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator<BucketValueTraits, false> unconst() const
    {  return hashtable_iterator<BucketValueTraits, false>(this->slist_it(), this->get_bucket_value_traits());   }
 
-   hashtable_iterator& operator++()
+   BOOST_INTRUSIVE_FORCEINLINE hashtable_iterator& operator++()
    {  this->increment();   return *this;   }
 
    hashtable_iterator operator++(int)
@@ -247,7 +246,7 @@ class hashtable_iterator
    void increment()
    {
       const bucket_traits &rbuck_traits = this->priv_bucket_traits();
-      bucket_type* const buckets = boost::intrusive::detail::to_raw_pointer(rbuck_traits.bucket_begin());
+      bucket_type* const buckets = boost::movelib::to_raw_pointer(rbuck_traits.bucket_begin());
       const size_type buckets_len = rbuck_traits.bucket_count();
 
       ++slist_it_;
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/hook_traits.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/hook_traits.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/hook_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/hook_traits.hpp
index 2a16061a543..7a6f206ca2b 100644
--- a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/hook_traits.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/hook_traits.hpp
@@ -26,7 +26,7 @@
 #include <boost/intrusive/detail/parent_from_member.hpp>
 #include <boost/intrusive/link_mode.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
-#include <boost/intrusive/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/intrusive/detail/node_holder.hpp>
 
 namespace boost {
@@ -128,14 +128,14 @@ struct mhtraits
    {
       return pointer_traits<pointer>::pointer_to
          (*detail::parent_from_member<T, Hook>
-            (static_cast<Hook*>(boost::intrusive::detail::to_raw_pointer(n)), P));
+            (static_cast<Hook*>(boost::movelib::to_raw_pointer(n)), P));
    }
 
    BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const const_node_ptr & n)
    {
       return pointer_traits<const_pointer>::pointer_to
          (*detail::parent_from_member<T, Hook>
-            (static_cast<const Hook*>(boost::intrusive::detail::to_raw_pointer(n)), P));
+            (static_cast<const Hook*>(boost::movelib::to_raw_pointer(n)), P));
    }
 };
 
@@ -161,10 +161,10 @@ struct fhtraits
    static const link_mode_type link_mode = hook_type::hooktags::link_mode;
 
    static node_ptr to_node_ptr(reference value)
-   {  return static_cast<node*>(boost::intrusive::detail::to_raw_pointer(Functor::to_hook_ptr(value)));  }
+   {  return static_cast<node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value)));  }
 
    static const_node_ptr to_node_ptr(const_reference value)
-   {  return static_cast<const node*>(boost::intrusive::detail::to_raw_pointer(Functor::to_hook_ptr(value)));  }
+   {  return static_cast<const node*>(boost::movelib::to_raw_pointer(Functor::to_hook_ptr(value)));  }
 
    static pointer to_value_ptr(const node_ptr & n)
    {  return Functor::to_value_ptr(to_hook_ptr(n));  }
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/iiterator.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/iiterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/iiterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/iiterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/is_stateful_value_traits.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/is_stateful_value_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/is_stateful_value_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/is_stateful_value_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/iterator.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/iterator.hpp
similarity index 55%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/iterator.hpp
index 2ae6abb7d03..c25be430a2c 100644
--- a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/iterator.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/iterator.hpp
@@ -27,6 +27,24 @@
 #include <boost/move/detail/iterator_traits.hpp>
 #include <boost/move/detail/meta_utils_core.hpp>
 
+namespace boost{
+namespace iterators{
+
+struct incrementable_traversal_tag;
+struct single_pass_traversal_tag;
+struct forward_traversal_tag;
+struct bidirectional_traversal_tag;
+struct random_access_traversal_tag;
+
+namespace detail{
+
+template <class Category, class Traversal>
+struct iterator_category_with_traversal;
+
+} //namespace boost{
+} //namespace iterators{
+} //namespace detail{
+
 namespace boost {
 namespace intrusive {
 
@@ -45,6 +63,28 @@ struct iterator
    typedef Reference    reference;
 };
 
+////////////////////////////////////////
+//    iterator_[dis|en]able_if_boost_iterator
+////////////////////////////////////////
+template<class I>
+struct is_boost_iterator
+{
+   static const bool value = false;
+};
+
+template<class Category, class Traversal>
+struct is_boost_iterator< boost::iterators::detail::iterator_category_with_traversal<Category, Traversal> >
+{
+   static const bool value = true;
+};
+
+template<class I, class R = void>
+struct iterator_enable_if_boost_iterator
+   : ::boost::move_detail::enable_if_c
+      < is_boost_iterator<typename boost::intrusive::iterator_traits<I>::iterator_category >::value
+      , R>
+{};
+
 ////////////////////////////////////////
 //    iterator_[dis|en]able_if_tag
 ////////////////////////////////////////
@@ -68,6 +108,23 @@ struct iterator_disable_if_tag
          , R>
 {};
 
+////////////////////////////////////////
+//    iterator_[dis|en]able_if_tag
+////////////////////////////////////////
+template<class I, class Tag, class Tag2, class R = void>
+struct iterator_enable_if_convertible_tag
+   : ::boost::move_detail::enable_if_c
+      < ::boost::move_detail::is_same_or_convertible
+         < typename boost::intrusive::iterator_traits<I>::iterator_category 
+         , Tag
+         >::value &&
+        !::boost::move_detail::is_same_or_convertible
+         < typename boost::intrusive::iterator_traits<I>::iterator_category 
+         , Tag2
+         >::value
+         , R>
+{};
+
 ////////////////////////////////////////
 //    iterator_[dis|en]able_if_tag_difference_type
 ////////////////////////////////////////
@@ -84,8 +141,9 @@ struct iterator_disable_if_tag_difference_type
 ////////////////////
 //    advance
 ////////////////////
+
 template<class InputIt, class Distance>
-typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::input_iterator_tag>::type
    iterator_advance(InputIt& it, Distance n)
 {
    while(n--)
@@ -101,7 +159,7 @@ typename iterator_enable_if_tag<InputIt, std::forward_iterator_tag>::type
 }
 
 template<class InputIt, class Distance>
-typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::bidirectional_iterator_tag>::type
    iterator_advance(InputIt& it, Distance n)
 {
    for (; 0 < n; --n)
@@ -117,6 +175,54 @@ BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_tag<InputIt, std::random
    it += n;
 }
 
+template<class InputIt, class Distance>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
+   <InputIt, const boost::iterators::incrementable_traversal_tag&, const boost::iterators::single_pass_traversal_tag&>::type
+   iterator_advance(InputIt& it, Distance n)
+{
+   while(n--)
+	   ++it;
+}
+
+template<class InputIt, class Distance>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
+   <InputIt, const boost::iterators::single_pass_traversal_tag &, const boost::iterators::forward_traversal_tag&>::type
+   iterator_advance(InputIt& it, Distance n)
+{
+   while(n--)
+	   ++it;
+}
+
+template<class InputIt, class Distance>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
+   <InputIt, const boost::iterators::forward_traversal_tag&, const boost::iterators::bidirectional_traversal_tag&>::type
+   iterator_advance(InputIt& it, Distance n)
+{
+   while(n--)
+	   ++it;
+}
+
+template<class InputIt, class Distance>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
+   <InputIt, const boost::iterators::bidirectional_traversal_tag&, const boost::iterators::random_access_traversal_tag&>::type
+   iterator_advance(InputIt& it, Distance n)
+{
+   for (; 0 < n; --n)
+	   ++it;
+   for (; n < 0; ++n)
+	   --it;
+}
+
+class fake{};
+
+template<class InputIt, class Distance>
+BOOST_INTRUSIVE_FORCEINLINE typename iterator_enable_if_convertible_tag
+   <InputIt, const boost::iterators::random_access_traversal_tag&, const fake&>::type
+   iterator_advance(InputIt& it, Distance n)
+{
+   it += n;
+}
+
 ////////////////////
 //    distance
 ////////////////////
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/key_nodeptr_comp.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/key_nodeptr_comp.hpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/key_nodeptr_comp.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/key_nodeptr_comp.hpp
index 9d64f09bcd7..bdc025e5ab3 100644
--- a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/key_nodeptr_comp.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/key_nodeptr_comp.hpp
@@ -59,6 +59,10 @@ struct key_nodeptr_comp
    //Use public inheritance to avoid MSVC bugs with closures
    :  public key_nodeptr_comp_types<KeyTypeKeyCompare, ValueTraits, KeyOfValue>::base_t
 {
+private:
+   struct sfinae_type;
+
+public:
    typedef key_nodeptr_comp_types<KeyTypeKeyCompare, ValueTraits, KeyOfValue> types_t;
    typedef typename types_t::value_traits          value_traits;
    typedef typename types_t::value_type            value_type;
@@ -83,32 +87,32 @@ struct key_nodeptr_comp
 
    //pred(pnode)
    template<class T1>
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()(const T1 &t1, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value >::type* =0) const
+   BOOST_INTRUSIVE_FORCEINLINE bool operator()(const T1 &t1, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value, sfinae_type* >::type = 0) const
    {  return base().get()(key_of_value()(*traits_->to_value_ptr(t1)));  }
 
    //operator() 2 arg
    //pred(pnode, pnode)
    template<class T1, class T2>
    BOOST_INTRUSIVE_FORCEINLINE bool operator()
-      (const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value && is_same_or_nodeptr_convertible<T2>::value >::type* =0) const
+      (const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value && is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
    {  return base()(*traits_->to_value_ptr(t1), *traits_->to_value_ptr(t2));  }
 
    //pred(pnode, key)
    template<class T1, class T2>
    BOOST_INTRUSIVE_FORCEINLINE bool operator()
-      (const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value && !is_same_or_nodeptr_convertible<T2>::value >::type* =0) const
+      (const T1 &t1, const T2 &t2, typename enable_if_c< is_same_or_nodeptr_convertible<T1>::value && !is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
    {  return base()(*traits_->to_value_ptr(t1), t2);  }
 
    //pred(key, pnode)
    template<class T1, class T2>
    BOOST_INTRUSIVE_FORCEINLINE bool operator()
-      (const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible<T1>::value && is_same_or_nodeptr_convertible<T2>::value >::type* =0) const
+      (const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible<T1>::value && is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
    {  return base()(t1, *traits_->to_value_ptr(t2));  }
 
    //pred(key, key)
    template<class T1, class T2>
    BOOST_INTRUSIVE_FORCEINLINE bool operator()
-      (const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible<T1>::value && !is_same_or_nodeptr_convertible<T2>::value >::type* =0) const
+      (const T1 &t1, const T2 &t2, typename enable_if_c< !is_same_or_nodeptr_convertible<T1>::value && !is_same_or_nodeptr_convertible<T2>::value, sfinae_type* >::type = 0) const
    {  return base()(t1, t2);  }
 
    const ValueTraits *const traits_;
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/list_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/list_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/list_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/list_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/list_node.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/list_node.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/list_node.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/list_node.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/math.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/math.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/math.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/math.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/minimal_less_equal_header.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/minimal_less_equal_header.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/minimal_less_equal_header.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/minimal_less_equal_header.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/minimal_pair_header.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/minimal_pair_header.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/minimal_pair_header.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/minimal_pair_header.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/mpl.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/mpl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/mpl.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/mpl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/node_cloner_disposer.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/node_cloner_disposer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/node_cloner_disposer.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/node_cloner_disposer.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/node_holder.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/node_holder.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/node_holder.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/node_holder.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/node_to_value.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/node_to_value.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/node_to_value.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/node_to_value.hpp
index 5af33473456..218e78e4e0e 100644
--- a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/node_to_value.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/node_to_value.hpp
@@ -59,7 +59,7 @@ struct constptr
    {}
 
    const void *get_ptr() const
-   {  return boost::intrusive::detail::to_raw_pointer(const_void_ptr_);  }
+   {  return boost::movelib::to_raw_pointer(const_void_ptr_);  }
 
    ConstVoidPtr const_void_ptr_;
 };
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/parent_from_member.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/parent_from_member.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/parent_from_member.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/parent_from_member.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/rbtree_node.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/rbtree_node.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/rbtree_node.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/rbtree_node.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/reverse_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/reverse_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/reverse_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/reverse_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/simple_disposers.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/simple_disposers.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/simple_disposers.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/simple_disposers.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/size_holder.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/size_holder.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/size_holder.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/size_holder.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/slist_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/slist_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/slist_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/slist_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/slist_node.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/slist_node.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/slist_node.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/slist_node.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/std_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/std_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/std_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/std_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/transform_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/transform_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/transform_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/transform_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/tree_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/tree_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/tree_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/tree_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/tree_node.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/tree_node.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/tree_node.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/tree_node.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/tree_value_compare.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/tree_value_compare.hpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/tree_value_compare.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/tree_value_compare.hpp
index c8f596fc961..f6dd01dc256 100644
--- a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/tree_value_compare.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/tree_value_compare.hpp
@@ -37,7 +37,8 @@ struct disable_if_smartref_to
       || detail::is_same
             <From, typename pointer_traits
                      < typename pointer_rebind
-                           <ValuePtr, const typename pointer_element<ValuePtr>::type>::type>
+                           < ValuePtr
+                           , const typename boost::movelib::pointer_element<ValuePtr>::type>::type>
                   ::reference>::value
       >
 {};
@@ -45,11 +46,13 @@ struct disable_if_smartref_to
 //This function object takes a KeyCompare function object
 //and compares values that contains keys using KeyOfValue
 template< class ValuePtr, class KeyCompare, class KeyOfValue
-        , bool = boost::intrusive::detail::is_same<typename pointer_element<ValuePtr>::type, typename KeyOfValue::type>::value >
+        , bool = boost::intrusive::detail::is_same
+   <typename boost::movelib::pointer_element<ValuePtr>::type, typename KeyOfValue::type>::value >
 struct tree_value_compare
    :  public boost::intrusive::detail::ebo_functor_holder<KeyCompare>
 {
-   typedef typename pointer_element<ValuePtr>::type   value_type;
+   typedef typename
+      boost::movelib::pointer_element<ValuePtr>::type value_type;
    typedef KeyCompare                                 key_compare;
    typedef KeyOfValue                                 key_of_value;
    typedef typename KeyOfValue::type                  key_type;
@@ -114,7 +117,8 @@ template<class ValuePtr, class KeyCompare, class KeyOfValue>
 struct tree_value_compare<ValuePtr, KeyCompare, KeyOfValue, true>
    :  public boost::intrusive::detail::ebo_functor_holder<KeyCompare>
 {
-   typedef typename pointer_element<ValuePtr>::type   value_type;
+   typedef typename
+      boost::movelib::pointer_element<ValuePtr>::type value_type;
    typedef KeyCompare                                 key_compare;
    typedef KeyOfValue                                 key_of_value;
    typedef typename KeyOfValue::type                  key_type;
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/uncast.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/uncast.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/uncast.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/uncast.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/workaround.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/workaround.hpp
similarity index 90%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/workaround.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/detail/workaround.hpp
index 7a9ac48e0b6..594ac0b2e54 100644
--- a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/workaround.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/intrusive/detail/workaround.hpp
@@ -43,6 +43,9 @@
 #elif defined(BOOST_MSVC) && defined(_DEBUG)
    //"__forceinline" and MSVC seems to have some bugs in debug mode
    #define BOOST_INTRUSIVE_FORCEINLINE inline
+#elif defined(__GNUC__) && ((__GNUC__ < 4) || (__GNUC__ == 4 && (__GNUC_MINOR__ < 5)))
+   //Older GCCs have problems with forceinline
+   #define BOOST_INTRUSIVE_FORCEINLINE inline
 #else
    #define BOOST_INTRUSIVE_FORCEINLINE BOOST_FORCEINLINE
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/hashtable.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/hashtable.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/hashtable.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/hashtable.hpp
index 313da829d3f..bae9d52485c 100644
--- a/contrib/libboost/boost_1_62_0/boost/intrusive/hashtable.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/intrusive/hashtable.hpp
@@ -117,6 +117,24 @@ struct prime_list_holder
 {
    static const std::size_t prime_list[];
    static const std::size_t prime_list_size;
+
+   static std::size_t suggested_upper_bucket_count(std::size_t n)
+   {
+      const std::size_t *primes     = &prime_list_holder<0>::prime_list[0];
+      const std::size_t *primes_end = primes + prime_list_holder<0>::prime_list_size;
+      std::size_t const* bound = std::lower_bound(primes, primes_end, n);
+      bound -= (bound == primes_end);
+      return *bound;
+   }
+
+   static std::size_t suggested_lower_bucket_count(std::size_t n)
+   {
+      const std::size_t *primes     = &prime_list_holder<0>::prime_list[0];
+      const std::size_t *primes_end = primes + prime_list_holder<0>::prime_list_size;
+      std::size_t const* bound = std::upper_bound(primes, primes_end, n);
+      bound -= (bound != primes);
+      return *bound;
+   }
 };
 
 #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
@@ -588,7 +606,6 @@ struct bucket_plus_vtraits
    typedef typename value_traits::node_traits            node_traits;
    typedef unordered_group_adapter<node_traits>          group_traits;
    typedef typename slist_impl::iterator                 siterator;
-   typedef typename slist_impl::size_type                size_type;
    typedef detail::bucket_impl<slist_impl>               bucket_type;
    typedef detail::group_functions<node_traits>          group_functions_t;
    typedef typename slist_impl::node_algorithms          node_algorithms;
@@ -655,7 +672,7 @@ struct bucket_plus_vtraits
    BOOST_INTRUSIVE_FORCEINLINE bucket_ptr priv_bucket_pointer() const
    {  return this->priv_bucket_traits().bucket_begin();  }
 
-   typename slist_impl::size_type priv_bucket_count() const
+   std::size_t priv_bucket_count() const
    {  return this->priv_bucket_traits().bucket_count();  }
 
    BOOST_INTRUSIVE_FORCEINLINE bucket_ptr priv_invalid_bucket() const
@@ -668,9 +685,9 @@ struct bucket_plus_vtraits
    {  return this->priv_bucket_traits().bucket_begin()->before_begin();  }
 
    template<class NodeDisposer>
-   static size_type priv_erase_from_single_bucket(bucket_type &b, siterator sbefore_first, siterator slast, NodeDisposer node_disposer, detail::true_)   //optimize multikey
+   static std::size_t priv_erase_from_single_bucket(bucket_type &b, siterator sbefore_first, siterator slast, NodeDisposer node_disposer, detail::true_)   //optimize multikey
    {
-      size_type n = 0;
+      std::size_t n = 0;
       siterator const sfirst(++siterator(sbefore_first));
       if(sfirst != slast){
          node_ptr const nf = detail::dcast_bucket_ptr<node>(sfirst.pointed_node());
@@ -708,9 +725,9 @@ struct bucket_plus_vtraits
    }
 
    template<class NodeDisposer>
-   static size_type priv_erase_from_single_bucket(bucket_type &b, siterator sbefore_first, siterator slast, NodeDisposer node_disposer, detail::false_)   //optimize multikey
+   static std::size_t priv_erase_from_single_bucket(bucket_type &b, siterator sbefore_first, siterator slast, NodeDisposer node_disposer, detail::false_)   //optimize multikey
    {
-      size_type n = 0;
+      std::size_t n = 0;
       siterator it(++siterator(sbefore_first));
       while(it != slast){
          node_disposer((it++).pointed_node());
@@ -757,17 +774,17 @@ struct bucket_plus_vtraits
    {  b.erase_after_and_dispose(b.previous(i), node_disposer);   }
 
    template<class NodeDisposer, bool OptimizeMultikey>
-   size_type priv_erase_node_range( siterator const &before_first_it,  size_type const first_bucket
-                        , siterator const &last_it,          size_type const last_bucket
+   std::size_t priv_erase_node_range( siterator const &before_first_it,  std::size_t const first_bucket
+                        , siterator const &last_it,          std::size_t const last_bucket
                         , NodeDisposer node_disposer, detail::bool_<OptimizeMultikey> optimize_multikey_tag)
    {
-      size_type num_erased(0);
+      std::size_t num_erased(0);
       siterator last_step_before_it;
       if(first_bucket != last_bucket){
          bucket_type *b = (&this->priv_bucket_pointer()[0]);
          num_erased += this->priv_erase_from_single_bucket
             (b[first_bucket], before_first_it, b[first_bucket].end(), node_disposer, optimize_multikey_tag);
-         for(size_type i = 0, n = (last_bucket - first_bucket - 1); i != n; ++i){
+         for(std::size_t i = 0, n = (last_bucket - first_bucket - 1); i != n; ++i){
             num_erased += this->priv_erase_whole_bucket(b[first_bucket+i+1], node_disposer);
          }
          last_step_before_it = b[last_bucket].before_begin();
@@ -797,9 +814,9 @@ struct bucket_plus_vtraits
    }
 
    template<class NodeDisposer>
-   size_type priv_erase_whole_bucket(bucket_type &b, NodeDisposer node_disposer)
+   std::size_t priv_erase_whole_bucket(bucket_type &b, NodeDisposer node_disposer)
    {
-      size_type num_erased = 0;
+      std::size_t num_erased = 0;
       siterator b_begin(b.before_begin());
       siterator nxt(b_begin);
       ++nxt;
@@ -841,7 +858,7 @@ struct bucket_plus_vtraits
       const bucket_type &b = static_cast<const bucket_type&>
          (bucket_type::slist_type::container_from_end_iterator(bucket_type::s_iterator_to(*bb)));
       //Now just calculate the index b has in the bucket array
-      return static_cast<size_type>(&b - &*f);
+      return static_cast<std::size_t>(&b - &*f);
    }
 
    std::size_t priv_get_bucket_num_no_hash_store(siterator it, detail::false_)   //NO optimize multikey
@@ -881,10 +898,10 @@ struct bucket_plus_vtraits
    BOOST_INTRUSIVE_FORCEINLINE const_reference priv_value_from_slist_node(slist_node_ptr n) const
    {  return *this->priv_value_traits().to_value_ptr(detail::dcast_bucket_ptr<node>(n)); }
 
-   void priv_clear_buckets(const bucket_ptr buckets_ptr, const size_type bucket_cnt)
+   void priv_clear_buckets(const bucket_ptr buckets_ptr, const std::size_t bucket_cnt)
    {
       bucket_ptr buckets_it = buckets_ptr;
-      for(size_type bucket_i = 0; bucket_i != bucket_cnt; ++buckets_it, ++bucket_i){
+      for(std::size_t bucket_i = 0; bucket_i != bucket_cnt; ++buckets_it, ++bucket_i){
          if(safemode_or_autounlink){
             buckets_it->clear_and_dispose(detail::init_disposer<node_algorithms>());
          }
@@ -909,24 +926,6 @@ struct bucket_plus_vtraits
    BOOST_INTRUSIVE_FORCEINLINE const_iterator cend() const
    {  return const_iterator(this->priv_invalid_local_it(), 0);  }
 
-   static size_type suggested_upper_bucket_count(size_type n)
-   {
-      const std::size_t *primes     = &prime_list_holder<0>::prime_list[0];
-      const std::size_t *primes_end = primes + prime_list_holder<0>::prime_list_size;
-      std::size_t const* bound = std::lower_bound(primes, primes_end, n);
-      bound -= (bound == primes_end);
-      return size_type(*bound);
-   }
-
-   static size_type suggested_lower_bucket_count(size_type n)
-   {
-      const std::size_t *primes     = &prime_list_holder<0>::prime_list[0];
-      const std::size_t *primes_end = primes + prime_list_holder<0>::prime_list_size;
-      size_type const* bound = std::upper_bound(primes, primes_end, n);
-      bound -= (bound != primes);
-      return size_type(*bound);
-   }
-
    //Public functions:
    struct data_type : public ValueTraits
    {
@@ -1072,7 +1071,6 @@ struct bucket_hash_equal_t
    typedef typename bucket_hash_type::hasher    hasher;
    typedef BucketTraits                         bucket_traits;
    typedef typename bucket_plus_vtraits_t::slist_impl       slist_impl;
-   typedef typename slist_impl::size_type                   size_type;
    typedef typename slist_impl::iterator                    siterator;
    typedef detail::bucket_impl<slist_impl>                  bucket_type;
    typedef typename detail::unordered_bucket_ptr_impl<value_traits>::type bucket_ptr;
@@ -1089,7 +1087,7 @@ struct bucket_hash_equal_t
    BOOST_INTRUSIVE_FORCEINLINE void priv_set_cache(const bucket_ptr &)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE size_type priv_get_cache_bucket_num()
+   BOOST_INTRUSIVE_FORCEINLINE std::size_t priv_get_cache_bucket_num()
    {  return 0u;  }
 
    BOOST_INTRUSIVE_FORCEINLINE void priv_initialize_cache()
@@ -1100,8 +1098,8 @@ struct bucket_hash_equal_t
 
    siterator priv_begin() const
    {
-      size_type n = 0;
-      size_type bucket_cnt = this->bucket_hash_type::priv_bucket_count();
+      std::size_t n = 0;
+      std::size_t bucket_cnt = this->bucket_hash_type::priv_bucket_count();
       for (n = 0; n < bucket_cnt; ++n){
          bucket_type &b = this->bucket_hash_type::priv_bucket_pointer()[n];
          if(!b.empty()){
@@ -1111,10 +1109,10 @@ struct bucket_hash_equal_t
       return this->bucket_hash_type::priv_invalid_local_it();
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE void priv_insertion_update_cache(size_type)
+   BOOST_INTRUSIVE_FORCEINLINE void priv_insertion_update_cache(std::size_t)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE void priv_erasure_update_cache_range(size_type, size_type)
+   BOOST_INTRUSIVE_FORCEINLINE void priv_erasure_update_cache_range(std::size_t, std::size_t)
    {}
 
    BOOST_INTRUSIVE_FORCEINLINE void priv_erasure_update_cache()
@@ -1145,7 +1143,6 @@ struct bucket_hash_equal_t<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, VoidOrK
    typedef bucket_hash_t<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, BucketTraits>   bucket_hash_type;
    typedef typename bucket_hash_type::hasher                         hasher;
    typedef BucketTraits                                              bucket_traits;
-   typedef typename bucket_plus_vtraits_t::slist_impl::size_type     size_type;
    typedef typename bucket_plus_vtraits_t::slist_impl::iterator      siterator;
 
    template<class BucketTraitsType>
@@ -1187,7 +1184,7 @@ struct bucket_hash_equal_t<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, VoidOrK
       }
    }
 
-   void priv_insertion_update_cache(size_type insertion_bucket)
+   void priv_insertion_update_cache(std::size_t insertion_bucket)
    {
       bucket_ptr p = this->bucket_hash_type::priv_bucket_pointer() + insertion_bucket;
       if(p < this->cached_begin_){
@@ -1201,7 +1198,7 @@ struct bucket_hash_equal_t<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, VoidOrK
    BOOST_INTRUSIVE_FORCEINLINE key_equal &priv_equal()
    {  return this->equal_holder_t::get();  }
 
-   void priv_erasure_update_cache_range(size_type first_bucket_num, size_type last_bucket_num)
+   void priv_erasure_update_cache_range(std::size_t first_bucket_num, std::size_t last_bucket_num)
    {
       //If the last bucket is the end, the cache must be updated
       //to the last position if all
@@ -1215,8 +1212,8 @@ struct bucket_hash_equal_t<ValueTraits, VoidOrKeyOfValue, VoidOrKeyHash, VoidOrK
    void priv_erasure_update_cache()
    {
       if(this->cached_begin_ != this->bucket_hash_type::priv_invalid_bucket()){
-         size_type current_n = this->priv_get_cache() - this->bucket_hash_type::priv_bucket_pointer();
-         for( const size_type num_buckets = this->bucket_hash_type::priv_bucket_count()
+         std::size_t current_n = this->priv_get_cache() - this->bucket_hash_type::priv_bucket_pointer();
+         for( const std::size_t num_buckets = this->bucket_hash_type::priv_bucket_count()
             ; current_n < num_buckets
             ; ++current_n, ++this->priv_get_cache()){
             if(!this->priv_get_cache()->empty()){
@@ -1307,7 +1304,7 @@ struct hashdata_internal
    typedef typename internal_type::key_equal                key_equal;
    typedef typename internal_type::hasher                   hasher;
    typedef bucket_plus_vtraits<ValueTraits,BucketTraits>    bucket_plus_vtraits_t;
-   typedef typename bucket_plus_vtraits_t::size_type        size_type;
+   typedef SizeType                                         size_type;
    typedef typename internal_type::size_traits              split_traits;
    typedef typename bucket_plus_vtraits_t::bucket_ptr       bucket_ptr;
    typedef typename bucket_plus_vtraits_t::const_value_traits_ptr   const_value_traits_ptr;
@@ -1459,7 +1456,11 @@ struct hashdata_internal
    }
 
    BOOST_INTRUSIVE_FORCEINLINE size_type bucket_count() const
-   {  return this->priv_bucket_count();   }
+   {
+      const std::size_t bc = this->priv_bucket_count();
+      BOOST_INTRUSIVE_INVARIANT_ASSERT(sizeof(size_type) >= sizeof(std::size_t) || bc <= size_type(-1));
+      return static_cast<size_type>(bc);
+   }
 
    BOOST_INTRUSIVE_FORCEINLINE size_type bucket_size(size_type n) const
    {  return this->priv_bucket_pointer()[n].size();   }
@@ -1473,6 +1474,20 @@ struct hashdata_internal
    BOOST_INTRUSIVE_FORCEINLINE const_local_iterator begin(size_type n) const
    {  return this->cbegin(n);  }
 
+   static BOOST_INTRUSIVE_FORCEINLINE size_type suggested_upper_bucket_count(size_type n)
+   {
+      std::size_t c = prime_list_holder<0>::suggested_upper_bucket_count
+         (sizeof(size_type) > sizeof(std::size_t) && n > std::size_t(-1) ? std::size_t(-1) : static_cast<std::size_t>(n));
+      return sizeof(size_type) < sizeof(std::size_t) && c > size_type(-1) ? size_type(-1) : static_cast<size_type>(c);
+   }
+
+   static BOOST_INTRUSIVE_FORCEINLINE size_type suggested_lower_bucket_count(size_type n)
+   {
+      std::size_t c = prime_list_holder<0>::suggested_lower_bucket_count
+         (sizeof(size_type) > sizeof(std::size_t) && n > std::size_t(-1) ? std::size_t(-1) : static_cast<std::size_t>(n));
+      return sizeof(size_type) < sizeof(std::size_t) && c > size_type(-1) ? size_type(-1) : static_cast<size_type>(c);
+   }
+
    const_local_iterator cbegin(size_type n) const
    {
       return const_local_iterator
@@ -1737,7 +1752,7 @@ class hashtable_impl
    {
       this->priv_initialize_buckets_and_cache();
       this->priv_size_traits().set_size(size_type(0));
-      size_type bucket_sz = this->priv_bucket_count();
+      size_type bucket_sz = this->bucket_count();
       BOOST_INTRUSIVE_INVARIANT_ASSERT(bucket_sz != 0);
       //Check power of two bucket array if the option is activated
       BOOST_INTRUSIVE_INVARIANT_ASSERT
@@ -1770,7 +1785,7 @@ class hashtable_impl
    {
       this->priv_initialize_buckets_and_cache();
       this->priv_size_traits().set_size(size_type(0));
-      size_type bucket_sz = this->priv_bucket_count();
+      size_type bucket_sz = this->bucket_count();
       BOOST_INTRUSIVE_INVARIANT_ASSERT(bucket_sz != 0);
       //Check power of two bucket array if the option is activated
       BOOST_INTRUSIVE_INVARIANT_ASSERT
@@ -1894,8 +1909,8 @@ class hashtable_impl
          return this->begin() == this->end();
       }
       else{
-         size_type bucket_cnt = this->priv_bucket_count();
-         const bucket_type *b = boost::intrusive::detail::to_raw_pointer(this->priv_bucket_pointer());
+         size_type bucket_cnt = this->bucket_count();
+         const bucket_type *b = boost::movelib::to_raw_pointer(this->priv_bucket_pointer());
          for (size_type n = 0; n < bucket_cnt; ++n, ++b){
             if(!b->empty()){
                return false;
@@ -1917,8 +1932,8 @@ class hashtable_impl
          return this->priv_size_traits().get_size();
       else{
          size_type len = 0;
-         size_type bucket_cnt = this->priv_bucket_count();
-         const bucket_type *b = boost::intrusive::detail::to_raw_pointer(this->priv_bucket_pointer());
+         size_type bucket_cnt = this->bucket_count();
+         const bucket_type *b = boost::movelib::to_raw_pointer(this->priv_bucket_pointer());
          for (size_type n = 0; n < bucket_cnt; ++n, ++b){
             len += b->size();
          }
@@ -2898,7 +2913,7 @@ class hashtable_impl
       //This function is only available for containers with incremental hashing
       BOOST_STATIC_ASSERT(( incremental && power_2_buckets ));
       const size_type split_idx  = this->priv_split_traits().get_size();
-      const size_type bucket_cnt = this->priv_bucket_count();
+      const size_type bucket_cnt = this->bucket_count();
       const bucket_ptr buck_ptr  = this->priv_bucket_pointer();
       bool ret = false;
 
@@ -2961,7 +2976,7 @@ class hashtable_impl
       //This function is only available for containers with incremental hashing
       BOOST_STATIC_ASSERT(( incremental && power_2_buckets ));
       size_type const new_bucket_traits_size = new_bucket_traits.bucket_count();
-      size_type const cur_bucket_traits      = this->priv_bucket_count();
+      size_type const cur_bucket_traits      = this->bucket_count();
       const size_type split_idx = this->split_count();
 
       //Test new bucket size is consistent with internal bucket size and split count
@@ -3071,7 +3086,7 @@ class hashtable_impl
       const bucket_ptr new_buckets      = new_bucket_traits.bucket_begin();
             size_type  new_bucket_count = new_bucket_traits.bucket_count();
       const bucket_ptr old_buckets      = this->priv_bucket_pointer();
-            size_type  old_bucket_count = this->priv_bucket_count();
+            size_type  old_bucket_count = this->bucket_count();
 
       //Check power of two bucket array if the option is activated
       BOOST_INTRUSIVE_INVARIANT_ASSERT
@@ -3400,7 +3415,7 @@ class hashtable_impl
          to_return.second == bp[n_bucket].end()){
          to_return.second = this->priv_invalid_local_it();
          ++n_bucket;
-         for( const size_type max_bucket = this->priv_bucket_count()
+         for( const size_type max_bucket = this->bucket_count()
             ; n_bucket != max_bucket
             ; ++n_bucket){
             bucket_type &b = bp[n_bucket];
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/intrusive_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/intrusive_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/intrusive_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/intrusive_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/linear_slist_algorithms.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/linear_slist_algorithms.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/linear_slist_algorithms.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/linear_slist_algorithms.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/link_mode.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/link_mode.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/link_mode.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/link_mode.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/list.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/list.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/list_hook.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/list_hook.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/list_hook.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/list_hook.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/member_value_traits.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/member_value_traits.hpp
similarity index 95%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/member_value_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/member_value_traits.hpp
index 01ccf4e38fa..0ab7ffb1122 100644
--- a/contrib/libboost/boost_1_62_0/boost/intrusive/member_value_traits.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/intrusive/member_value_traits.hpp
@@ -18,6 +18,7 @@
 
 #include <boost/intrusive/link_mode.hpp>
 #include <boost/intrusive/detail/parent_from_member.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp> 
 #include <boost/intrusive/pointer_traits.hpp>
 
 #if defined(BOOST_HAS_PRAGMA_ONCE)
@@ -65,13 +66,13 @@ struct member_value_traits
    BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(const node_ptr &n)
    {
       return pointer_traits<pointer>::pointer_to(*detail::parent_from_member<value_type, node>
-         (boost::intrusive::detail::to_raw_pointer(n), PtrToMember));
+         (boost::movelib::to_raw_pointer(n), PtrToMember));
    }
 
    BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const const_node_ptr &n)
    {
       return pointer_traits<const_pointer>::pointer_to(*detail::parent_from_member<value_type, node>
-         (boost::intrusive::detail::to_raw_pointer(n), PtrToMember));
+         (boost::movelib::to_raw_pointer(n), PtrToMember));
 
    }
 };
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/options.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/options.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/options.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/options.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/pack_options.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/pack_options.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/pack_options.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/pack_options.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/parent_from_member.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/parent_from_member.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/parent_from_member.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/parent_from_member.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/pointer_plus_bits.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/pointer_plus_bits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/pointer_plus_bits.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/pointer_plus_bits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/pointer_rebind.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/pointer_rebind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/pointer_rebind.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/pointer_rebind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/pointer_traits.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/pointer_traits.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/pointer_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/pointer_traits.hpp
index 5baf5e807ce..4216c7ee9ca 100644
--- a/contrib/libboost/boost_1_62_0/boost/intrusive/pointer_traits.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/intrusive/pointer_traits.hpp
@@ -20,7 +20,7 @@
 #include <boost/intrusive/detail/config_begin.hpp>
 #include <boost/intrusive/detail/workaround.hpp>
 #include <boost/intrusive/pointer_rebind.hpp>
-#include <boost/intrusive/detail/pointer_element.hpp>
+#include <boost/move/detail/pointer_element.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
 #include <cstddef>
 
@@ -97,7 +97,7 @@ struct pointer_traits
       //
       typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT
          ( boost::intrusive::detail::, Ptr, element_type
-         , boost::intrusive::detail::first_param<Ptr>)                        element_type;
+         , boost::movelib::detail::first_param<Ptr>)                          element_type;
       //
       typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
          (boost::intrusive::detail::, Ptr, difference_type, std::ptrdiff_t)   difference_type;
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/priority_compare.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/priority_compare.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/priority_compare.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/priority_compare.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/rbtree.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/rbtree.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/rbtree.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/rbtree.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/rbtree_algorithms.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/rbtree_algorithms.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/rbtree_algorithms.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/rbtree_algorithms.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/set.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/set.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/set_hook.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/set_hook.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/set_hook.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/set_hook.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/sg_set.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/sg_set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/sg_set.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/sg_set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/sgtree.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/sgtree.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/sgtree.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/sgtree.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/sgtree_algorithms.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/sgtree_algorithms.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/sgtree_algorithms.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/sgtree_algorithms.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/slist.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/slist.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/slist.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/slist.hpp
index 00206990f68..f34350d80fd 100644
--- a/contrib/libboost/boost_1_62_0/boost/intrusive/slist.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/intrusive/slist.hpp
@@ -1115,7 +1115,7 @@ class slist_impl
    //!
    //! <b>Throws</b>: Nothing.
    //!
-   //! <b>Complexity</b>: Lineal to the elements (l - before_f + 1).
+   //! <b>Complexity</b>: Linear to the elements (l - before_f + 1).
    //!
    //! <b>Note</b>: Invalidates the iterators to the erased element.
    template<class Disposer>
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/slist_hook.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/slist_hook.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/slist_hook.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/slist_hook.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/splay_set.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/splay_set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/splay_set.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/splay_set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/splaytree.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/splaytree.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/splaytree.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/splaytree.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/splaytree_algorithms.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/splaytree_algorithms.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/splaytree_algorithms.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/splaytree_algorithms.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/treap.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/treap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/treap.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/treap.hpp
index 8567072d547..c6f63ff2deb 100644
--- a/contrib/libboost/boost_1_62_0/boost/intrusive/treap.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/intrusive/treap.hpp
@@ -354,9 +354,9 @@ class treap_impl
    //! <b>Throws</b>: If the comparison functor's swap call throws.
    void swap(treap_impl& other)
    {
-      tree_type::swap(other);
       //This can throw
       ::boost::adl_move_swap(this->priv_pcomp(), other.priv_pcomp());
+      tree_type::swap(other);
    }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/treap_algorithms.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/treap_algorithms.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/treap_algorithms.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/treap_algorithms.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/treap_set.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/treap_set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/treap_set.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/treap_set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/trivial_value_traits.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/trivial_value_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/trivial_value_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/trivial_value_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/unordered_set.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/unordered_set.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/unordered_set.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/unordered_set.hpp
index 1968fa250e7..cf60dc4f7a5 100644
--- a/contrib/libboost/boost_1_62_0/boost/intrusive/unordered_set.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/intrusive/unordered_set.hpp
@@ -120,7 +120,7 @@ class unordered_set_impl
    public:
 
    //! @copydoc ::boost::intrusive::hashtable::hashtable(const bucket_traits &,const hasher &,const key_equal &,const value_traits &)
-   explicit unordered_set_impl( const bucket_traits &b_traits
+   BOOST_INTRUSIVE_FORCEINLINE explicit unordered_set_impl( const bucket_traits &b_traits
                               , const hasher & hash_func = hasher()
                               , const key_equal &equal_func = key_equal()
                               , const value_traits &v_traits = value_traits())
@@ -129,7 +129,7 @@ class unordered_set_impl
 
    //! @copydoc ::boost::intrusive::hashtable::hashtable(bool,Iterator,Iterator,const bucket_traits &,const hasher &,const key_equal &,const value_traits &)
    template<class Iterator>
-   unordered_set_impl( Iterator b
+   BOOST_INTRUSIVE_FORCEINLINE unordered_set_impl( Iterator b
                      , Iterator e
                      , const bucket_traits &b_traits
                      , const hasher & hash_func = hasher()
@@ -139,12 +139,12 @@ class unordered_set_impl
    {}
 
    //! @copydoc ::boost::intrusive::hashtable::hashtable(hashtable&&)
-   unordered_set_impl(BOOST_RV_REF(unordered_set_impl) x)
+   BOOST_INTRUSIVE_FORCEINLINE unordered_set_impl(BOOST_RV_REF(unordered_set_impl) x)
       :  table_type(BOOST_MOVE_BASE(table_type, x))
    {}
 
    //! @copydoc ::boost::intrusive::hashtable::operator=(hashtable&&)
-   unordered_set_impl& operator=(BOOST_RV_REF(unordered_set_impl) x)
+   BOOST_INTRUSIVE_FORCEINLINE unordered_set_impl& operator=(BOOST_RV_REF(unordered_set_impl) x)
    {  return static_cast<unordered_set_impl&>(table_type::operator=(BOOST_MOVE_BASE(table_type, x))); }
 
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
@@ -196,30 +196,30 @@ class unordered_set_impl
 
    //! @copydoc ::boost::intrusive::hashtable::clone_from(hashtable&&,Cloner,Disposer)
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(unordered_set_impl) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(unordered_set_impl) src, Cloner cloner, Disposer disposer)
    {  table_type::clone_from(BOOST_MOVE_BASE(table_type, src), cloner, disposer);  }
 
    //! @copydoc ::boost::intrusive::hashtable::insert_unique(reference)
-   std::pair<iterator, bool> insert(reference value)
+   BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator, bool> insert(reference value)
    {  return table_type::insert_unique(value);  }
 
    //! @copydoc ::boost::intrusive::hashtable::insert_unique(Iterator,Iterator)
    template<class Iterator>
-   void insert(Iterator b, Iterator e)
+   BOOST_INTRUSIVE_FORCEINLINE void insert(Iterator b, Iterator e)
    {  table_type::insert_unique(b, e);  }
 
    //! @copydoc ::boost::intrusive::hashtable::insert_unique_check(const key_type&,insert_commit_data&)
-   std::pair<iterator, bool> insert_check(const key_type &key, insert_commit_data &commit_data)
+   BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator, bool> insert_check(const key_type &key, insert_commit_data &commit_data)
    {  return table_type::insert_unique_check(key, commit_data); }
 
    //! @copydoc ::boost::intrusive::hashtable::insert_unique_check(const KeyType&,KeyHasher,KeyEqual,insert_commit_data&)
    template<class KeyType, class KeyHasher, class KeyEqual>
-   std::pair<iterator, bool> insert_check
+   BOOST_INTRUSIVE_FORCEINLINE std::pair<iterator, bool> insert_check
       (const KeyType &key, KeyHasher hasher, KeyEqual key_value_equal, insert_commit_data &commit_data)
    {  return table_type::insert_unique_check(key, hasher, key_value_equal, commit_data); }
 
    //! @copydoc ::boost::intrusive::hashtable::insert_unique_commit
-   iterator insert_commit(reference value, const insert_commit_data &commit_data)
+   BOOST_INTRUSIVE_FORCEINLINE iterator insert_commit(reference value, const insert_commit_data &commit_data)
    {  return table_type::insert_unique_commit(value, commit_data); }
 
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
@@ -506,8 +506,8 @@ class unordered_set
    {}
 
    template<class Iterator>
-   unordered_set  ( Iterator b
-                  , Iterator e
+   BOOST_INTRUSIVE_FORCEINLINE unordered_set
+                  ( Iterator b, Iterator e
                   , const bucket_traits &b_traits
                   , const hasher & hash_func = hasher()
                   , const key_equal &equal_func = key_equal()
@@ -515,19 +515,19 @@ class unordered_set
       :  Base(b, e, b_traits, hash_func, equal_func, v_traits)
    {}
 
-   unordered_set(BOOST_RV_REF(unordered_set) x)
+   BOOST_INTRUSIVE_FORCEINLINE unordered_set(BOOST_RV_REF(unordered_set) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   unordered_set& operator=(BOOST_RV_REF(unordered_set) x)
+   BOOST_INTRUSIVE_FORCEINLINE unordered_set& operator=(BOOST_RV_REF(unordered_set) x)
    {  return static_cast<unordered_set&>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const unordered_set &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const unordered_set &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(unordered_set) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(unordered_set) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 };
 
@@ -616,7 +616,7 @@ class unordered_multiset_impl
    public:
 
    //! @copydoc ::boost::intrusive::hashtable::hashtable(const bucket_traits &,const hasher &,const key_equal &,const value_traits &)
-   explicit unordered_multiset_impl ( const bucket_traits &b_traits
+   BOOST_INTRUSIVE_FORCEINLINE explicit unordered_multiset_impl ( const bucket_traits &b_traits
                                     , const hasher & hash_func = hasher()
                                     , const key_equal &equal_func = key_equal()
                                     , const value_traits &v_traits = value_traits())
@@ -625,7 +625,7 @@ class unordered_multiset_impl
 
    //! @copydoc ::boost::intrusive::hashtable::hashtable(bool,Iterator,Iterator,const bucket_traits &,const hasher &,const key_equal &,const value_traits &)
    template<class Iterator>
-   unordered_multiset_impl ( Iterator b
+   BOOST_INTRUSIVE_FORCEINLINE unordered_multiset_impl ( Iterator b
                            , Iterator e
                            , const bucket_traits &b_traits
                            , const hasher & hash_func = hasher()
@@ -636,13 +636,13 @@ class unordered_multiset_impl
 
    //! <b>Effects</b>: to-do
    //!
-   unordered_multiset_impl(BOOST_RV_REF(unordered_multiset_impl) x)
+   BOOST_INTRUSIVE_FORCEINLINE unordered_multiset_impl(BOOST_RV_REF(unordered_multiset_impl) x)
       :  table_type(BOOST_MOVE_BASE(table_type, x))
    {}
 
    //! <b>Effects</b>: to-do
    //!
-   unordered_multiset_impl& operator=(BOOST_RV_REF(unordered_multiset_impl) x)
+   BOOST_INTRUSIVE_FORCEINLINE unordered_multiset_impl& operator=(BOOST_RV_REF(unordered_multiset_impl) x)
    {  return static_cast<unordered_multiset_impl&>(table_type::operator=(BOOST_MOVE_BASE(table_type, x)));  }
 
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
@@ -695,16 +695,16 @@ class unordered_multiset_impl
 
    //! @copydoc ::boost::intrusive::hashtable::clone_from(hashtable&&,Cloner,Disposer)
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(unordered_multiset_impl) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(unordered_multiset_impl) src, Cloner cloner, Disposer disposer)
    {  table_type::clone_from(BOOST_MOVE_BASE(table_type, src), cloner, disposer);  }
 
    //! @copydoc ::boost::intrusive::hashtable::insert_equal(reference)
-   iterator insert(reference value)
+   BOOST_INTRUSIVE_FORCEINLINE iterator insert(reference value)
    {  return table_type::insert_equal(value);  }
 
    //! @copydoc ::boost::intrusive::hashtable::insert_equal(Iterator,Iterator)
    template<class Iterator>
-   void insert(Iterator b, Iterator e)
+   BOOST_INTRUSIVE_FORCEINLINE void insert(Iterator b, Iterator e)
    {  table_type::insert_equal(b, e);  }
 
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
@@ -954,7 +954,7 @@ class unordered_multiset
       :  Base(b_traits, hash_func, equal_func, v_traits)
    {}
 
-   template<class Iterator>
+   template<class Iterator> BOOST_INTRUSIVE_FORCEINLINE
    unordered_multiset( Iterator b
                      , Iterator e
                      , const bucket_traits &b_traits
@@ -964,19 +964,19 @@ class unordered_multiset
       :  Base(b, e, b_traits, hash_func, equal_func, v_traits)
    {}
 
-   unordered_multiset(BOOST_RV_REF(unordered_multiset) x)
+   BOOST_INTRUSIVE_FORCEINLINE unordered_multiset(BOOST_RV_REF(unordered_multiset) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   unordered_multiset& operator=(BOOST_RV_REF(unordered_multiset) x)
+   BOOST_INTRUSIVE_FORCEINLINE unordered_multiset& operator=(BOOST_RV_REF(unordered_multiset) x)
    {  return static_cast<unordered_multiset&>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const unordered_multiset &src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(const unordered_multiset &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(unordered_multiset) src, Cloner cloner, Disposer disposer)
+   BOOST_INTRUSIVE_FORCEINLINE void clone_from(BOOST_RV_REF(unordered_multiset) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 };
 
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/unordered_set_hook.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive/unordered_set_hook.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/unordered_set_hook.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive/unordered_set_hook.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/intrusive_ptr.hpp
similarity index 83%
rename from contrib/libboost/boost_1_62_0/boost/intrusive_ptr.hpp
rename to contrib/libboost/boost_1_65_0/boost/intrusive_ptr.hpp
index 63036dcd6ee..c43adbdc0dc 100644
--- a/contrib/libboost/boost_1_62_0/boost/intrusive_ptr.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/intrusive_ptr.hpp
@@ -10,7 +10,7 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 //
-//  See http://www.boost.org/libs/smart_ptr/intrusive_ptr.html for documentation.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 #include <boost/smart_ptr/intrusive_ptr.hpp>
diff --git a/contrib/libboost/boost_1_62_0/boost/io/detail/quoted_manip.hpp b/contrib/libboost/boost_1_65_0/boost/io/detail/quoted_manip.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/io/detail/quoted_manip.hpp
rename to contrib/libboost/boost_1_65_0/boost/io/detail/quoted_manip.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/io/ios_state.hpp b/contrib/libboost/boost_1_65_0/boost/io/ios_state.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/io/ios_state.hpp
rename to contrib/libboost/boost_1_65_0/boost/io/ios_state.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/io_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/io_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/io_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/io_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/is_placeholder.hpp b/contrib/libboost/boost_1_65_0/boost/is_placeholder.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/is_placeholder.hpp
rename to contrib/libboost/boost_1_65_0/boost/is_placeholder.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator.hpp b/contrib/libboost/boost_1_65_0/boost/iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/iterator/advance.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/advance.hpp
new file mode 100644
index 00000000000..6f81cdb6b19
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/iterator/advance.hpp
@@ -0,0 +1,84 @@
+// Copyright (C) 2017 Michel Morin.
+//
+// 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_ITERATOR_ADVANCE_HPP
+#define BOOST_ITERATOR_ADVANCE_HPP
+
+#include <boost/config.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+
+namespace boost {
+namespace iterators {
+
+    namespace detail {
+        template <typename InputIterator, typename Distance>
+        inline BOOST_CXX14_CONSTEXPR void
+        advance_impl(
+            InputIterator& it
+          , Distance n
+          , incrementable_traversal_tag
+        )
+        {
+            while (n > 0) {
+                ++it;
+                --n;
+            }
+        }
+
+        template <typename BidirectionalIterator, typename Distance>
+        inline BOOST_CXX14_CONSTEXPR void
+        advance_impl(
+            BidirectionalIterator& it
+          , Distance n
+          , bidirectional_traversal_tag
+        )
+        {
+            if (n >= 0) {
+                while (n > 0) {
+                    ++it;
+                    --n;
+                }
+            }
+            else {
+                while (n < 0) {
+                    --it;
+                    ++n;
+                }
+            }
+        }
+
+        template <typename RandomAccessIterator, typename Distance>
+        inline BOOST_CXX14_CONSTEXPR void
+        advance_impl(
+            RandomAccessIterator& it
+          , Distance n
+          , random_access_traversal_tag
+        )
+        {
+            it += n;
+        }
+    }
+
+    namespace advance_adl_barrier {
+        template <typename InputIterator, typename Distance>
+        inline BOOST_CXX14_CONSTEXPR void
+        advance(InputIterator& it, Distance n)
+        {
+            detail::advance_impl(
+                it, n, typename iterator_traversal<InputIterator>::type()
+            );
+        }
+    }
+
+    using namespace advance_adl_barrier;
+
+} // namespace iterators
+
+using iterators::advance;
+
+} // namespace boost
+
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/counting_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/counting_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/counting_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/counting_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/detail/any_conversion_eater.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/detail/any_conversion_eater.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/detail/any_conversion_eater.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/detail/any_conversion_eater.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/detail/config_def.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/detail/config_def.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/detail/config_def.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/detail/config_def.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/detail/config_undef.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/detail/config_undef.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/detail/config_undef.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/detail/config_undef.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/detail/enable_if.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/detail/enable_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/detail/enable_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/detail/enable_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/detail/facade_iterator_category.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/detail/facade_iterator_category.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/detail/facade_iterator_category.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/detail/facade_iterator_category.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/detail/minimum_category.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/detail/minimum_category.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/detail/minimum_category.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/detail/minimum_category.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/iterator/distance.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/distance.hpp
new file mode 100644
index 00000000000..8cf3f15c446
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/iterator/distance.hpp
@@ -0,0 +1,65 @@
+// Copyright (C) 2017 Michel Morin.
+//
+// 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_ITERATOR_DISTANCE_HPP
+#define BOOST_ITERATOR_DISTANCE_HPP
+
+#include <boost/config.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost {
+namespace iterators {
+
+    namespace detail {
+        template <typename SinglePassIterator>
+        inline BOOST_CXX14_CONSTEXPR typename iterator_difference<SinglePassIterator>::type
+        distance_impl(
+            SinglePassIterator first
+          , SinglePassIterator last
+          , single_pass_traversal_tag
+        )
+        {
+            typename iterator_difference<SinglePassIterator>::type n = 0;
+            while (first != last) {
+                ++first;
+                ++n;
+            }
+            return n;
+        }
+
+        template <typename RandomAccessIterator>
+        inline BOOST_CXX14_CONSTEXPR typename iterator_difference<RandomAccessIterator>::type
+        distance_impl(
+            RandomAccessIterator first
+          , RandomAccessIterator last
+          , random_access_traversal_tag
+        )
+        {
+            return last - first;
+        }
+    }
+
+    namespace distance_adl_barrier {
+        template <typename SinglePassIterator>
+        inline BOOST_CXX14_CONSTEXPR typename iterator_difference<SinglePassIterator>::type
+        distance(SinglePassIterator first, SinglePassIterator last)
+        {
+            return detail::distance_impl(
+                first, last, typename iterator_traversal<SinglePassIterator>::type()
+            );
+        }
+    }
+
+    using namespace distance_adl_barrier;
+
+} // namespace iterators
+
+using iterators::distance;
+
+} // namespace boost
+
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/filter_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/filter_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/filter_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/filter_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/function_input_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/function_input_iterator.hpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/boost/iterator/function_input_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/function_input_iterator.hpp
index 8a793df1b79..f3e9de92e4f 100644
--- a/contrib/libboost/boost_1_62_0/boost/iterator/function_input_iterator.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/iterator/function_input_iterator.hpp
@@ -9,6 +9,7 @@
 #ifndef BOOST_FUNCTION_INPUT_ITERATOR
 #define BOOST_FUNCTION_INPUT_ITERATOR
 
+#include <boost/config.hpp>
 #include <boost/assert.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/function_types/is_function_pointer.hpp>
@@ -17,6 +18,7 @@
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/none.hpp>
 #include <boost/optional/optional.hpp>
+#include <boost/utility/result_of.hpp>
 
 namespace boost {
 
@@ -28,9 +30,9 @@ namespace iterators {
         class function_input_iterator
             : public iterator_facade<
             function_input_iterator<Function, Input>,
-            typename Function::result_type,
+            BOOST_DEDUCED_TYPENAME result_of<Function ()>::type,
             single_pass_traversal_tag,
-            typename Function::result_type const &
+            BOOST_DEDUCED_TYPENAME result_of<Function ()>::type const &
             >
         {
         public:
@@ -46,7 +48,7 @@ namespace iterators {
                 ++state;
             }
 
-            typename Function::result_type const &
+            BOOST_DEDUCED_TYPENAME result_of<Function ()>::type const &
                 dereference() const {
                     return (value ? value : value = (*f)()).get();
             }
@@ -58,7 +60,7 @@ namespace iterators {
         private:
             Function * f;
             Input state;
-            mutable optional<typename Function::result_type> value;
+            mutable optional<BOOST_DEDUCED_TYPENAME result_of<Function ()>::type> value;
         };
 
         template <class Function, class Input>
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/indirect_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/indirect_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/indirect_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/indirect_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/interoperable.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/interoperable.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/interoperable.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/interoperable.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/is_lvalue_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/is_lvalue_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/is_lvalue_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/is_lvalue_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/is_readable_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/is_readable_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/is_readable_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/is_readable_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/iterator_adaptor.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/iterator_adaptor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/iterator_adaptor.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/iterator_adaptor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/iterator_archetypes.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/iterator_archetypes.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/iterator_archetypes.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/iterator_archetypes.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/iterator_categories.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/iterator_categories.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/iterator_categories.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/iterator_categories.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/iterator_concepts.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/iterator_concepts.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/iterator_concepts.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/iterator_concepts.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/iterator_facade.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/iterator_facade.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/iterator_facade.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/iterator_facade.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/iterator_traits.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/iterator_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/iterator_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/iterator_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/minimum_category.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/minimum_category.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/minimum_category.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/minimum_category.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/new_iterator_tests.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/new_iterator_tests.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/new_iterator_tests.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/new_iterator_tests.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/permutation_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/permutation_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/permutation_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/permutation_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/reverse_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/reverse_iterator.hpp
similarity index 90%
rename from contrib/libboost/boost_1_62_0/boost/iterator/reverse_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/reverse_iterator.hpp
index 3bef39e4b6d..7ed6b1b5ef0 100644
--- a/contrib/libboost/boost_1_62_0/boost/iterator/reverse_iterator.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/iterator/reverse_iterator.hpp
@@ -7,7 +7,6 @@
 #ifndef BOOST_REVERSE_ITERATOR_23022003THW_HPP
 #define BOOST_REVERSE_ITERATOR_23022003THW_HPP
 
-#include <boost/next_prior.hpp>
 #include <boost/iterator.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>
 
@@ -40,14 +39,19 @@ namespace iterators {
       {}
 
    private:
-      typename super_t::reference dereference() const { return *boost::prior(this->base()); }
+      typename super_t::reference dereference() const
+      {
+          Iterator it = this->base_reference();
+          --it;
+          return *it;
+      }
 
       void increment() { --this->base_reference(); }
       void decrement() { ++this->base_reference(); }
 
       void advance(typename super_t::difference_type n)
       {
-          this->base_reference() += -n;
+          this->base_reference() -= n;
       }
 
       template <class OtherIterator>
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/transform_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/transform_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator/transform_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/transform_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator/zip_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/iterator/zip_iterator.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/iterator/zip_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator/zip_iterator.hpp
index 83fa63b2a77..3675c0f8024 100644
--- a/contrib/libboost/boost_1_62_0/boost/iterator/zip_iterator.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/iterator/zip_iterator.hpp
@@ -84,7 +84,7 @@ namespace iterators {
       struct result<This(Iterator)>
       {
         typedef typename
-          remove_reference<typename remove_cv<Iterator>::type>::type
+          remove_cv<typename remove_reference<Iterator>::type>::type
         iterator;
 
         typedef typename iterator_reference<iterator>::type type;
diff --git a/contrib/libboost/boost_1_62_0/boost/iterator_adaptors.hpp b/contrib/libboost/boost_1_65_0/boost/iterator_adaptors.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/iterator_adaptors.hpp
rename to contrib/libboost/boost_1_65_0/boost/iterator_adaptors.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/lexical_cast.hpp b/contrib/libboost/boost_1_65_0/boost/lexical_cast.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/lexical_cast.hpp
rename to contrib/libboost/boost_1_65_0/boost/lexical_cast.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/lexical_cast/bad_lexical_cast.hpp b/contrib/libboost/boost_1_65_0/boost/lexical_cast/bad_lexical_cast.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/lexical_cast/bad_lexical_cast.hpp
rename to contrib/libboost/boost_1_65_0/boost/lexical_cast/bad_lexical_cast.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/lexical_cast/detail/converter_lexical.hpp b/contrib/libboost/boost_1_65_0/boost/lexical_cast/detail/converter_lexical.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/lexical_cast/detail/converter_lexical.hpp
rename to contrib/libboost/boost_1_65_0/boost/lexical_cast/detail/converter_lexical.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/lexical_cast/detail/converter_lexical_streams.hpp b/contrib/libboost/boost_1_65_0/boost/lexical_cast/detail/converter_lexical_streams.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/lexical_cast/detail/converter_lexical_streams.hpp
rename to contrib/libboost/boost_1_65_0/boost/lexical_cast/detail/converter_lexical_streams.hpp
index 981594995ae..7bee25e1ade 100644
--- a/contrib/libboost/boost_1_62_0/boost/lexical_cast/detail/converter_lexical_streams.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/lexical_cast/detail/converter_lexical_streams.hpp
@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2014.
+// Copyright Antony Polukhin, 2011-2016.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -13,7 +13,7 @@
 //        Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
 //        Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
 //        Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
-// when:  November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
+// when:  November 2000, March 2003, June 2005, June 2006, March 2011 - 2014, Nowember 2016
 
 #ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_STREAMS_HPP
 #define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_LEXICAL_STREAMS_HPP
@@ -107,23 +107,26 @@ namespace boost {
 
     namespace detail
     {
-        struct do_not_construct_out_stream_t{};
-        
+        struct do_not_construct_out_buffer_t{};
+        struct do_not_construct_out_stream_t{
+            do_not_construct_out_stream_t(do_not_construct_out_buffer_t*){}
+        };
+
         template <class CharT, class Traits>
         struct out_stream_helper_trait {
 #if defined(BOOST_NO_STRINGSTREAM)
-            typedef std::ostrstream                                 out_stream_t;
-            typedef void                                            buffer_t;
+            typedef std::ostream                                                    out_stream_t;
+            typedef basic_unlockedbuf<std::strstreambuf, char>                      stringbuffer_t;
 #elif defined(BOOST_NO_STD_LOCALE)
-            typedef std::ostringstream                              out_stream_t;
-            typedef basic_unlockedbuf<std::streambuf, char>         buffer_t;
+            typedef std::ostream                                                    out_stream_t;
+            typedef basic_unlockedbuf<std::stringbuf, char>                         stringbuffer_t;
+            typedef basic_unlockedbuf<std::streambuf, char>                         buffer_t;
 #else
-            typedef std::basic_ostringstream<CharT, Traits> 
-                out_stream_t;
-            typedef basic_unlockedbuf<std::basic_streambuf<CharT, Traits>, CharT>  
-                buffer_t;
+            typedef std::basic_ostream<CharT, Traits>                               out_stream_t;
+            typedef basic_unlockedbuf<std::basic_stringbuf<CharT, Traits>, CharT>   stringbuffer_t;
+            typedef basic_unlockedbuf<std::basic_streambuf<CharT, Traits>, CharT>   buffer_t;
 #endif
-        };   
+        };
     }
 
     namespace detail // optimized stream wrappers
@@ -134,19 +137,19 @@ namespace boost {
                 , std::size_t CharacterBufferSize
                 >
         class lexical_istream_limited_src: boost::noncopyable {
-            typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::buffer_t
-                buffer_t;
-
-            typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::out_stream_t
-                out_stream_t;
-    
             typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
                 RequiresStringbuffer,
-                out_stream_t,
+                BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::out_stream_t,
                 do_not_construct_out_stream_t
             >::type deduced_out_stream_t;
 
-            // A string representation of Source is written to `buffer`.
+            typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
+                RequiresStringbuffer,
+                BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::stringbuffer_t,
+                do_not_construct_out_buffer_t
+            >::type deduced_out_buffer_t;
+
+            deduced_out_buffer_t out_buffer;
             deduced_out_stream_t out_stream;
             CharT   buffer[CharacterBufferSize];
 
@@ -157,7 +160,9 @@ namespace boost {
 
         public:
             lexical_istream_limited_src() BOOST_NOEXCEPT
-              : start(buffer)
+              : out_buffer()
+              , out_stream(&out_buffer)
+              , start(buffer)
               , finish(buffer + CharacterBufferSize)
             {}
     
@@ -170,10 +175,6 @@ namespace boost {
             }
 
         private:
-            // Undefined:
-            lexical_istream_limited_src(lexical_istream_limited_src const&);
-            void operator=(lexical_istream_limited_src const&);
-
 /************************************ HELPER FUNCTIONS FOR OPERATORS << ( ... ) ********************************/
             bool shl_char(CharT ch) BOOST_NOEXCEPT {
                 Traits::assign(buffer[0], ch);
@@ -212,7 +213,7 @@ namespace boost {
                     "Use boost::locale instead" );
                 return shl_input_streamable(str);
             }
-            
+
             bool shl_char_array_limited(CharT const* str, std::size_t max_size) BOOST_NOEXCEPT {
                 start = str;
                 finish = std::find(start, start + max_size, Traits::to_char_type(0));
@@ -232,8 +233,8 @@ namespace boost {
                 try {
 #endif
                 bool const result = !(out_stream << input).fail();
-                const buffer_t* const p = static_cast<buffer_t*>(
-                    static_cast<std::basic_streambuf<CharT, Traits>*>(out_stream.rdbuf())
+                const deduced_out_buffer_t* const p = static_cast<deduced_out_buffer_t*>(
+                    out_stream.rdbuf()
                 );
                 start = p->pbase();
                 finish = p->pptr();
@@ -573,17 +574,15 @@ namespace boost {
                     "support such conversions. Try updating it."
                 );
 #endif
-                typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::buffer_t
-                    buffer_t;
 
 #if defined(BOOST_NO_STRINGSTREAM)
-                std::istrstream stream(start, finish - start);
+                std::istrstream stream(start, static_cast<std::istrstream::streamsize>(finish - start));
 #else
-
+                typedef BOOST_DEDUCED_TYPENAME out_stream_helper_trait<CharT, Traits>::buffer_t buffer_t;
                 buffer_t buf;
                 // Usually `istream` and `basic_istream` do not modify 
                 // content of buffer; `buffer_t` assures that this is true
-                buf.setbuf(const_cast<CharT*>(start), finish - start);
+                buf.setbuf(const_cast<CharT*>(start), static_cast<typename buffer_t::streamsize>(finish - start));
 #if defined(BOOST_NO_STD_LOCALE)
                 std::istream stream(&buf);
 #else
diff --git a/contrib/libboost/boost_1_62_0/boost/lexical_cast/detail/converter_numeric.hpp b/contrib/libboost/boost_1_65_0/boost/lexical_cast/detail/converter_numeric.hpp
similarity index 85%
rename from contrib/libboost/boost_1_62_0/boost/lexical_cast/detail/converter_numeric.hpp
rename to contrib/libboost/boost_1_65_0/boost/lexical_cast/detail/converter_numeric.hpp
index a6cc8e77b8d..f50e2ca0fb3 100644
--- a/contrib/libboost/boost_1_62_0/boost/lexical_cast/detail/converter_numeric.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/lexical_cast/detail/converter_numeric.hpp
@@ -1,6 +1,6 @@
 // Copyright Kevlin Henney, 2000-2005.
 // Copyright Alexander Nasonov, 2006-2010.
-// Copyright Antony Polukhin, 2011-2014.
+// Copyright Antony Polukhin, 2011-2016.
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
@@ -13,7 +13,7 @@
 //        Beman Dawes, Dave Abrahams, Daryle Walker, Peter Dimov,
 //        Alexander Nasonov, Antony Polukhin, Justin Viiret, Michael Hofmann,
 //        Cheng Yang, Matthew Bradbury, David W. Birdsall, Pavel Korzh and other Boosters
-// when:  November 2000, March 2003, June 2005, June 2006, March 2011 - 2014
+// when:  November 2000, March 2003, June 2005, June 2006, March 2011 - 2016
 
 #ifndef BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP
 #define BOOST_LEXICAL_CAST_DETAIL_CONVERTER_NUMERIC_HPP
@@ -154,35 +154,13 @@ struct dynamic_num_converter_impl
 {
     static inline bool try_convert(const Source &arg, Target& result) BOOST_NOEXCEPT {
         typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_c<
-        	boost::is_unsigned<Target>::value &&
-        	(boost::is_signed<Source>::value || boost::is_float<Source>::value) &&
-        	!(boost::is_same<Source, bool>::value) &&
-        	!(boost::is_same<Target, bool>::value),
+            boost::is_unsigned<Target>::value &&
+            (boost::is_signed<Source>::value || boost::is_float<Source>::value) &&
+            !(boost::is_same<Source, bool>::value) &&
+            !(boost::is_same<Target, bool>::value),
             lexical_cast_dynamic_num_ignoring_minus<Target, Source>,
             lexical_cast_dynamic_num_not_ignoring_minus<Target, Source>
         >::type caster_type;
-        
-#if 0
-
-        typedef BOOST_DEDUCED_TYPENAME boost::mpl::if_<
-            BOOST_DEDUCED_TYPENAME boost::mpl::and_<
-                boost::is_unsigned<Target>,
-                boost::mpl::or_<
-                    boost::is_signed<Source>,
-                    boost::is_float<Source>
-                >,
-                boost::mpl::not_<
-                    boost::is_same<Source, bool>
-                >,
-                boost::mpl::not_<
-                    boost::is_same<Target, bool>
-                >
-            >::type,
-            lexical_cast_dynamic_num_ignoring_minus<Target, Source>,
-            lexical_cast_dynamic_num_not_ignoring_minus<Target, Source>
-        >::type caster_type;
-        
-#endif
 
         return caster_type::try_convert(arg, result);
     }
diff --git a/contrib/libboost/boost_1_62_0/boost/lexical_cast/detail/inf_nan.hpp b/contrib/libboost/boost_1_65_0/boost/lexical_cast/detail/inf_nan.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/lexical_cast/detail/inf_nan.hpp
rename to contrib/libboost/boost_1_65_0/boost/lexical_cast/detail/inf_nan.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/lexical_cast/detail/is_character.hpp b/contrib/libboost/boost_1_65_0/boost/lexical_cast/detail/is_character.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/lexical_cast/detail/is_character.hpp
rename to contrib/libboost/boost_1_65_0/boost/lexical_cast/detail/is_character.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/lexical_cast/detail/lcast_char_constants.hpp b/contrib/libboost/boost_1_65_0/boost/lexical_cast/detail/lcast_char_constants.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/lexical_cast/detail/lcast_char_constants.hpp
rename to contrib/libboost/boost_1_65_0/boost/lexical_cast/detail/lcast_char_constants.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/lexical_cast/detail/lcast_unsigned_converters.hpp b/contrib/libboost/boost_1_65_0/boost/lexical_cast/detail/lcast_unsigned_converters.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/lexical_cast/detail/lcast_unsigned_converters.hpp
rename to contrib/libboost/boost_1_65_0/boost/lexical_cast/detail/lcast_unsigned_converters.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/lexical_cast/detail/widest_char.hpp b/contrib/libboost/boost_1_65_0/boost/lexical_cast/detail/widest_char.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/lexical_cast/detail/widest_char.hpp
rename to contrib/libboost/boost_1_65_0/boost/lexical_cast/detail/widest_char.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/lexical_cast/lexical_cast_old.hpp b/contrib/libboost/boost_1_65_0/boost/lexical_cast/lexical_cast_old.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/lexical_cast/lexical_cast_old.hpp
rename to contrib/libboost/boost_1_65_0/boost/lexical_cast/lexical_cast_old.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/lexical_cast/try_lexical_convert.hpp b/contrib/libboost/boost_1_65_0/boost/lexical_cast/try_lexical_convert.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/lexical_cast/try_lexical_convert.hpp
rename to contrib/libboost/boost_1_65_0/boost/lexical_cast/try_lexical_convert.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/limits.hpp b/contrib/libboost/boost_1_65_0/boost/limits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/limits.hpp
rename to contrib/libboost/boost_1_65_0/boost/limits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/make_shared.hpp b/contrib/libboost/boost_1_65_0/boost/make_shared.hpp
similarity index 82%
rename from contrib/libboost/boost_1_62_0/boost/make_shared.hpp
rename to contrib/libboost/boost_1_65_0/boost/make_shared.hpp
index c04938f9b35..588fbfde1b8 100644
--- a/contrib/libboost/boost_1_62_0/boost/make_shared.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/make_shared.hpp
@@ -9,8 +9,7 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 //
-//  See http://www.boost.org/libs/smart_ptr/make_shared.html
-//  for documentation.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
 #include <boost/smart_ptr/make_shared.hpp>
 
diff --git a/contrib/libboost/boost_1_62_0/boost/math/bindings/detail/big_digamma.hpp b/contrib/libboost/boost_1_65_0/boost/math/bindings/detail/big_digamma.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/bindings/detail/big_digamma.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/bindings/detail/big_digamma.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/bindings/detail/big_lanczos.hpp b/contrib/libboost/boost_1_65_0/boost/math/bindings/detail/big_lanczos.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/bindings/detail/big_lanczos.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/bindings/detail/big_lanczos.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/bindings/e_float.hpp b/contrib/libboost/boost_1_65_0/boost/math/bindings/e_float.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/bindings/e_float.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/bindings/e_float.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/bindings/mpfr.hpp b/contrib/libboost/boost_1_65_0/boost/math/bindings/mpfr.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/bindings/mpfr.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/bindings/mpfr.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/bindings/mpreal.hpp b/contrib/libboost/boost_1_65_0/boost/math/bindings/mpreal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/bindings/mpreal.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/bindings/mpreal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/bindings/rr.hpp b/contrib/libboost/boost_1_65_0/boost/math/bindings/rr.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/bindings/rr.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/bindings/rr.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/common_factor.hpp b/contrib/libboost/boost_1_65_0/boost/math/common_factor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/common_factor.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/common_factor.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/math/common_factor_ct.hpp b/contrib/libboost/boost_1_65_0/boost/math/common_factor_ct.hpp
new file mode 100644
index 00000000000..3ca0905945a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/math/common_factor_ct.hpp
@@ -0,0 +1,28 @@
+//  Boost common_factor_ct.hpp header file  ----------------------------------//
+
+//  (C) Copyright John Maddock 2017.
+//  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 updates, documentation, and revision history. 
+
+#ifndef BOOST_MATH_COMMON_FACTOR_CT_HPP
+#define BOOST_MATH_COMMON_FACTOR_CT_HPP
+
+#include <boost/integer/common_factor_ct.hpp>
+
+namespace boost
+{
+namespace math
+{
+
+   using boost::integer::static_gcd;
+   using boost::integer::static_lcm;
+   using boost::integer::static_gcd_type;
+
+}  // namespace math
+}  // namespace boost
+
+
+#endif  // BOOST_MATH_COMMON_FACTOR_CT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/math/common_factor_rt.hpp b/contrib/libboost/boost_1_65_0/boost/math/common_factor_rt.hpp
new file mode 100644
index 00000000000..42d9edfc04b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/math/common_factor_rt.hpp
@@ -0,0 +1,25 @@
+//  (C) Copyright John Maddock 2017.
+
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_MATH_COMMON_FACTOR_RT_HPP
+#define BOOST_MATH_COMMON_FACTOR_RT_HPP
+
+#include <boost/integer/common_factor_rt.hpp>
+
+namespace boost {
+   namespace math {
+
+      using boost::integer::gcd;
+      using boost::integer::lcm;
+      using boost::integer::gcd_range;
+      using boost::integer::lcm_range;
+      using boost::integer::gcd_evaluator;
+      using boost::integer::lcm_evaluator;
+
+   }
+}
+
+#endif  // BOOST_MATH_COMMON_FACTOR_RT_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/math/complex.hpp b/contrib/libboost/boost_1_65_0/boost/math/complex.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/complex.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/complex.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/complex/acos.hpp b/contrib/libboost/boost_1_65_0/boost/math/complex/acos.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/complex/acos.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/complex/acos.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/complex/acosh.hpp b/contrib/libboost/boost_1_65_0/boost/math/complex/acosh.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/complex/acosh.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/complex/acosh.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/complex/asin.hpp b/contrib/libboost/boost_1_65_0/boost/math/complex/asin.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/complex/asin.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/complex/asin.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/complex/asinh.hpp b/contrib/libboost/boost_1_65_0/boost/math/complex/asinh.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/complex/asinh.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/complex/asinh.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/complex/atan.hpp b/contrib/libboost/boost_1_65_0/boost/math/complex/atan.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/complex/atan.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/complex/atan.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/complex/atanh.hpp b/contrib/libboost/boost_1_65_0/boost/math/complex/atanh.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/complex/atanh.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/complex/atanh.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/complex/details.hpp b/contrib/libboost/boost_1_65_0/boost/math/complex/details.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/complex/details.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/complex/details.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/complex/fabs.hpp b/contrib/libboost/boost_1_65_0/boost/math/complex/fabs.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/complex/fabs.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/complex/fabs.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/concepts/distributions.hpp b/contrib/libboost/boost_1_65_0/boost/math/concepts/distributions.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/concepts/distributions.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/concepts/distributions.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/concepts/real_concept.hpp b/contrib/libboost/boost_1_65_0/boost/math/concepts/real_concept.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/concepts/real_concept.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/concepts/real_concept.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/concepts/real_type_concept.hpp b/contrib/libboost/boost_1_65_0/boost/math/concepts/real_type_concept.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/concepts/real_type_concept.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/concepts/real_type_concept.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/concepts/std_real_concept.hpp b/contrib/libboost/boost_1_65_0/boost/math/concepts/std_real_concept.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/math/concepts/std_real_concept.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/concepts/std_real_concept.hpp
index b297501d988..b8657bc6a3b 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/concepts/std_real_concept.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/concepts/std_real_concept.hpp
@@ -399,7 +399,3 @@ using concepts::llround;
 } // namespace boost
 
 #endif // BOOST_MATH_STD_REAL_CONCEPT_HPP
-
-
-
-
diff --git a/contrib/libboost/boost_1_62_0/boost/math/constants/calculate_constants.hpp b/contrib/libboost/boost_1_65_0/boost/math/constants/calculate_constants.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/constants/calculate_constants.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/constants/calculate_constants.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/constants/constants.hpp b/contrib/libboost/boost_1_65_0/boost/math/constants/constants.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/math/constants/constants.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/constants/constants.hpp
index b5db9cedf72..8c5c4105d4f 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/constants/constants.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/constants/constants.hpp
@@ -266,6 +266,7 @@ namespace boost{ namespace math
   BOOST_DEFINE_MATH_CONSTANT(third, 3.333333333333333333333333333333333333e-01, "3.33333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333e-01")
   BOOST_DEFINE_MATH_CONSTANT(twothirds, 6.666666666666666666666666666666666666e-01, "6.66666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666667e-01")
   BOOST_DEFINE_MATH_CONSTANT(two_thirds, 6.666666666666666666666666666666666666e-01, "6.66666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666667e-01")
+  BOOST_DEFINE_MATH_CONSTANT(sixth, 1.66666666666666666666666666666666666666666e-01, "1.66666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666667e-01")
   BOOST_DEFINE_MATH_CONSTANT(three_quarters, 7.500000000000000000000000000000000000e-01, "7.50000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-01")
   BOOST_DEFINE_MATH_CONSTANT(root_two, 1.414213562373095048801688724209698078e+00, "1.41421356237309504880168872420969807856967187537694807317667973799073247846210703885038753432764157273501384623e+00")
   BOOST_DEFINE_MATH_CONSTANT(root_three, 1.732050807568877293527446341505872366e+00, "1.73205080756887729352744634150587236694280525381038062805580697945193301690880003708114618675724857567562614142e+00")
@@ -343,5 +344,3 @@ namespace boost{ namespace math
 #include <boost/math/constants/calculate_constants.hpp>
 
 #endif // BOOST_MATH_CONSTANTS_CONSTANTS_INCLUDED
-
-
diff --git a/contrib/libboost/boost_1_62_0/boost/math/constants/info.hpp b/contrib/libboost/boost_1_65_0/boost/math/constants/info.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/constants/info.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/constants/info.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/cstdfloat/cstdfloat_cmath.hpp b/contrib/libboost/boost_1_65_0/boost/math/cstdfloat/cstdfloat_cmath.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/cstdfloat/cstdfloat_cmath.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/cstdfloat/cstdfloat_cmath.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/cstdfloat/cstdfloat_complex.hpp b/contrib/libboost/boost_1_65_0/boost/math/cstdfloat/cstdfloat_complex.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/cstdfloat/cstdfloat_complex.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/cstdfloat/cstdfloat_complex.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/cstdfloat/cstdfloat_complex_std.hpp b/contrib/libboost/boost_1_65_0/boost/math/cstdfloat/cstdfloat_complex_std.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/cstdfloat/cstdfloat_complex_std.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/cstdfloat/cstdfloat_complex_std.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/cstdfloat/cstdfloat_iostream.hpp b/contrib/libboost/boost_1_65_0/boost/math/cstdfloat/cstdfloat_iostream.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/cstdfloat/cstdfloat_iostream.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/cstdfloat/cstdfloat_iostream.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/cstdfloat/cstdfloat_limits.hpp b/contrib/libboost/boost_1_65_0/boost/math/cstdfloat/cstdfloat_limits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/cstdfloat/cstdfloat_limits.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/cstdfloat/cstdfloat_limits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/cstdfloat/cstdfloat_types.hpp b/contrib/libboost/boost_1_65_0/boost/math/cstdfloat/cstdfloat_types.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/cstdfloat/cstdfloat_types.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/cstdfloat/cstdfloat_types.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/arcsine.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/arcsine.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/arcsine.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/arcsine.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/bernoulli.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/bernoulli.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/bernoulli.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/bernoulli.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/beta.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/beta.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/beta.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/beta.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/binomial.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/binomial.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/binomial.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/binomial.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/cauchy.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/cauchy.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/cauchy.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/cauchy.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/chi_squared.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/chi_squared.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/chi_squared.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/chi_squared.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/complement.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/complement.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/complement.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/complement.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/detail/common_error_handling.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/detail/common_error_handling.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/detail/common_error_handling.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/detail/common_error_handling.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/detail/derived_accessors.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/detail/derived_accessors.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/detail/derived_accessors.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/detail/derived_accessors.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/detail/generic_mode.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/detail/generic_mode.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/detail/generic_mode.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/detail/generic_mode.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/detail/generic_quantile.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/detail/generic_quantile.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/detail/generic_quantile.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/detail/generic_quantile.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/detail/hypergeometric_cdf.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/detail/hypergeometric_cdf.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/detail/hypergeometric_cdf.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/detail/hypergeometric_cdf.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/detail/hypergeometric_pdf.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/detail/hypergeometric_pdf.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/detail/hypergeometric_pdf.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/detail/hypergeometric_pdf.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/detail/hypergeometric_quantile.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/detail/hypergeometric_quantile.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/detail/hypergeometric_quantile.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/detail/hypergeometric_quantile.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/detail/inv_discrete_quantile.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/detail/inv_discrete_quantile.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/detail/inv_discrete_quantile.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/detail/inv_discrete_quantile.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/exponential.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/exponential.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/exponential.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/exponential.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/extreme_value.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/extreme_value.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/extreme_value.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/extreme_value.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/find_location.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/find_location.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/find_location.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/find_location.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/find_scale.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/find_scale.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/find_scale.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/find_scale.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/fisher_f.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/fisher_f.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/fisher_f.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/fisher_f.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/fwd.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/gamma.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/gamma.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/gamma.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/gamma.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/geometric.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/geometric.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/geometric.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/geometric.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/hyperexponential.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/hyperexponential.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/hyperexponential.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/hyperexponential.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/hypergeometric.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/hypergeometric.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/hypergeometric.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/hypergeometric.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/inverse_chi_squared.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/inverse_chi_squared.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/inverse_chi_squared.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/inverse_chi_squared.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/inverse_gamma.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/inverse_gamma.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/inverse_gamma.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/inverse_gamma.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/inverse_gaussian.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/inverse_gaussian.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/inverse_gaussian.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/inverse_gaussian.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/laplace.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/laplace.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/laplace.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/laplace.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/logistic.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/logistic.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/logistic.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/logistic.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/lognormal.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/lognormal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/lognormal.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/lognormal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/negative_binomial.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/negative_binomial.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/negative_binomial.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/negative_binomial.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/non_central_beta.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/non_central_beta.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/non_central_beta.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/non_central_beta.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/non_central_chi_squared.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/non_central_chi_squared.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/non_central_chi_squared.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/non_central_chi_squared.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/non_central_f.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/non_central_f.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/non_central_f.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/non_central_f.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/non_central_t.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/non_central_t.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/non_central_t.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/non_central_t.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/normal.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/normal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/normal.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/normal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/pareto.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/pareto.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/pareto.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/pareto.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/poisson.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/poisson.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/poisson.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/poisson.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/rayleigh.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/rayleigh.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/rayleigh.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/rayleigh.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/skew_normal.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/skew_normal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/skew_normal.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/skew_normal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/students_t.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/students_t.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/students_t.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/students_t.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/triangular.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/triangular.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/triangular.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/triangular.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/uniform.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/uniform.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/uniform.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/uniform.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/distributions/weibull.hpp b/contrib/libboost/boost_1_65_0/boost/math/distributions/weibull.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/distributions/weibull.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/distributions/weibull.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/math/interpolators/barycentric_rational.hpp b/contrib/libboost/boost_1_65_0/boost/math/interpolators/barycentric_rational.hpp
new file mode 100644
index 00000000000..79bab9042d5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/math/interpolators/barycentric_rational.hpp
@@ -0,0 +1,70 @@
+/*
+ *  Copyright Nick Thompson, 2017
+ *  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)
+ *
+ *  Given N samples (t_i, y_i) which are irregularly spaced, this routine constructs an
+ *  interpolant s which is constructed in O(N) time, occupies O(N) space, and can be evaluated in O(N) time.
+ *  The interpolation is stable, unless one point is incredibly close to another, and the next point is incredibly far.
+ *  The measure of this stability is the "local mesh ratio", which can be queried from the routine.
+ *  Pictorially, the following t_i spacing is bad (has a high local mesh ratio)
+ *  ||             |      | |                           |
+ *  and this t_i spacing is good (has a low local mesh ratio)
+ *  |   |      |    |     |    |        |    |  |    |
+ *
+ *
+ *  If f is C^{d+2}, then the interpolant is O(h^(d+1)) accurate, where d is the interpolation order.
+ *  A disadvantage of this interpolant is that it does not reproduce rational functions; for example, 1/(1+x^2) is not interpolated exactly.
+ *
+ *  References:
+ *  Floater, Michael S., and Kai Hormann. "Barycentric rational interpolation with no poles and high rates of approximation." Numerische Mathematik 107.2 (2007): 315-331.
+ *  Press, William H., et al. "Numerical recipes third edition: the art of scientific computing." Cambridge University Press 32 (2007): 10013-2473.
+ */
+
+#ifndef BOOST_MATH_INTERPOLATORS_BARYCENTRIC_RATIONAL_HPP
+#define BOOST_MATH_INTERPOLATORS_BARYCENTRIC_RATIONAL_HPP
+
+#include <memory>
+#include <boost/math/interpolators/detail/barycentric_rational_detail.hpp>
+
+namespace boost{ namespace math{
+
+template<class Real>
+class barycentric_rational
+{
+public:
+    barycentric_rational(const Real* const x, const Real* const y, size_t n, size_t approximation_order = 3);
+
+    template <class InputIterator1, class InputIterator2>
+    barycentric_rational(InputIterator1 start_x, InputIterator1 end_x, InputIterator2 start_y, size_t approximation_order = 3, typename boost::disable_if_c<boost::is_integral<InputIterator2>::value>::type* = 0);
+
+    Real operator()(Real x) const;
+
+private:
+    std::shared_ptr<detail::barycentric_rational_imp<Real>> m_imp;
+};
+
+template <class Real>
+barycentric_rational<Real>::barycentric_rational(const Real* const x, const Real* const y, size_t n, size_t approximation_order):
+ m_imp(std::make_shared<detail::barycentric_rational_imp<Real>>(x, x + n, y, approximation_order))
+{
+    return;
+}
+
+template <class Real>
+template <class InputIterator1, class InputIterator2>
+barycentric_rational<Real>::barycentric_rational(InputIterator1 start_x, InputIterator1 end_x, InputIterator2 start_y, size_t approximation_order, typename boost::disable_if_c<boost::is_integral<InputIterator2>::value>::type*)
+ : m_imp(std::make_shared<detail::barycentric_rational_imp<Real>>(start_x, end_x, start_y, approximation_order))
+{
+}
+
+template<class Real>
+Real barycentric_rational<Real>::operator()(Real x) const
+{
+    return m_imp->operator()(x);
+}
+
+
+}}
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/math/interpolators/cubic_b_spline.hpp b/contrib/libboost/boost_1_65_0/boost/math/interpolators/cubic_b_spline.hpp
new file mode 100644
index 00000000000..73ac1d01373
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/math/interpolators/cubic_b_spline.hpp
@@ -0,0 +1,78 @@
+// Copyright Nick Thompson, 2017
+// 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 implements the compactly supported cubic b spline algorithm described in
+// Kress, Rainer. "Numerical analysis, volume 181 of Graduate Texts in Mathematics." (1998).
+// Splines of compact support are faster to evaluate and are better conditioned than classical cubic splines.
+
+// Let f be the function we are trying to interpolate, and s be the interpolating spline.
+// The routine constructs the interpolant in O(N) time, and evaluating s at a point takes constant time.
+// The order of accuracy depends on the regularity of the f, however, assuming f is
+// four-times continuously differentiable, the error is of O(h^4).
+// In addition, we can differentiate the spline and obtain a good interpolant for f'.
+// The main restriction of this method is that the samples of f must be evenly spaced.
+// Look for barycentric rational interpolation for non-evenly sampled data.
+// Properties:
+// - s(x_j) = f(x_j)
+// - All cubic polynomials interpolated exactly
+
+#ifndef BOOST_MATH_INTERPOLATORS_CUBIC_B_SPLINE_HPP
+#define BOOST_MATH_INTERPOLATORS_CUBIC_B_SPLINE_HPP
+
+#include <boost/math/interpolators/detail/cubic_b_spline_detail.hpp>
+
+namespace boost{ namespace math{
+
+template <class Real>
+class cubic_b_spline
+{
+public:
+    // If you don't know the value of the derivative at the endpoints, leave them as nans and the routine will estimate them.
+    // f[0] = f(a), f[length -1] = b, step_size = (b - a)/(length -1).
+    template <class BidiIterator>
+    cubic_b_spline(const BidiIterator f, BidiIterator end_p, Real left_endpoint, Real step_size,
+                   Real left_endpoint_derivative = std::numeric_limits<Real>::quiet_NaN(),
+                   Real right_endpoint_derivative = std::numeric_limits<Real>::quiet_NaN());
+    cubic_b_spline(const Real* const f, size_t length, Real left_endpoint, Real step_size,
+       Real left_endpoint_derivative = std::numeric_limits<Real>::quiet_NaN(),
+       Real right_endpoint_derivative = std::numeric_limits<Real>::quiet_NaN());
+
+    cubic_b_spline() = default;
+    Real operator()(Real x) const;
+
+    Real prime(Real x) const;
+
+private:
+    std::shared_ptr<detail::cubic_b_spline_imp<Real>> m_imp;
+};
+
+template<class Real>
+cubic_b_spline<Real>::cubic_b_spline(const Real* const f, size_t length, Real left_endpoint, Real step_size,
+                                     Real left_endpoint_derivative, Real right_endpoint_derivative) : m_imp(std::make_shared<detail::cubic_b_spline_imp<Real>>(f, f + length, left_endpoint, step_size, left_endpoint_derivative, right_endpoint_derivative))
+{
+}
+
+template <class Real>
+template <class BidiIterator>
+cubic_b_spline<Real>::cubic_b_spline(BidiIterator f, BidiIterator end_p, Real left_endpoint, Real step_size,
+   Real left_endpoint_derivative, Real right_endpoint_derivative) : m_imp(std::make_shared<detail::cubic_b_spline_imp<Real>>(f, end_p, left_endpoint, step_size, left_endpoint_derivative, right_endpoint_derivative))
+{
+}
+
+template<class Real>
+Real cubic_b_spline<Real>::operator()(Real x) const
+{
+    return m_imp->operator()(x);
+}
+
+template<class Real>
+Real cubic_b_spline<Real>::prime(Real x) const
+{
+    return m_imp->prime(x);
+}
+
+}}
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/math/interpolators/detail/barycentric_rational_detail.hpp b/contrib/libboost/boost_1_65_0/boost/math/interpolators/detail/barycentric_rational_detail.hpp
new file mode 100644
index 00000000000..b853901d890
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/math/interpolators/detail/barycentric_rational_detail.hpp
@@ -0,0 +1,151 @@
+/*
+ *  Copyright Nick Thompson, 2017
+ *  Use, modification and distribution are subject to the
+ *  Boost Software License, Version 1.0. (See accompanying file
+ *  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_MATH_INTERPOLATORS_BARYCENTRIC_RATIONAL_DETAIL_HPP
+#define BOOST_MATH_INTERPOLATORS_BARYCENTRIC_RATIONAL_DETAIL_HPP
+
+#include <vector>
+#include <boost/lexical_cast.hpp>
+#include <boost/math/special_functions/fpclassify.hpp>
+#include <boost/core/demangle.hpp>
+
+namespace boost{ namespace math{ namespace detail{
+
+template<class Real>
+class barycentric_rational_imp
+{
+public:
+    template <class InputIterator1, class InputIterator2>
+    barycentric_rational_imp(InputIterator1 start_x, InputIterator1 end_x, InputIterator2 start_y, size_t approximation_order = 3);
+
+    Real operator()(Real x) const;
+
+    // The barycentric weights are not really that interesting; except to the unit tests!
+    Real weight(size_t i) const { return m_w[i]; }
+
+private:
+    // Technically, we do not need to copy over y to m_y, or x to m_x.
+    // We could simply store a pointer. However, in doing so,
+    // we'd need to make sure the user managed the lifetime of m_y,
+    // and didn't alter its data. Since we are unlikely to run out of
+    // memory for a linearly scaling algorithm, it seems best just to make a copy.
+    std::vector<Real> m_y;
+    std::vector<Real> m_x;
+    std::vector<Real> m_w;
+};
+
+template <class Real>
+template <class InputIterator1, class InputIterator2>
+barycentric_rational_imp<Real>::barycentric_rational_imp(InputIterator1 start_x, InputIterator1 end_x, InputIterator2 start_y, size_t approximation_order)
+{
+    using std::abs;
+
+    std::ptrdiff_t n = std::distance(start_x, end_x);
+
+    if (approximation_order >= (std::size_t)n)
+    {
+        throw std::domain_error("Approximation order must be < data length.");
+    }
+
+    // Big sad memcpy to make sure the object is easy to use.
+    m_x.resize(n);
+    m_y.resize(n);
+    for(unsigned i = 0; start_x != end_x; ++start_x, ++start_y, ++i)
+    {
+        // But if we're going to do a memcpy, we can do some error checking which is inexpensive relative to the copy:
+        if(boost::math::isnan(*start_x))
+        {
+            std::string msg = std::string("x[") + boost::lexical_cast<std::string>(i) + "] is a NAN";
+            throw std::domain_error(msg);
+        }
+
+        if(boost::math::isnan(*start_y))
+        {
+           std::string msg = std::string("y[") + boost::lexical_cast<std::string>(i) + "] is a NAN";
+           throw std::domain_error(msg);
+        }
+
+        m_x[i] = *start_x;
+        m_y[i] = *start_y;
+    }
+
+    m_w.resize(n, 0);
+    for(int64_t k = 0; k < n; ++k)
+    {
+        int64_t i_min = (std::max)(k - (int64_t) approximation_order, (int64_t) 0);
+        int64_t i_max = k;
+        if (k >= n - (std::ptrdiff_t)approximation_order)
+        {
+            i_max = n - approximation_order - 1;
+        }
+
+        for(int64_t i = i_min; i <= i_max; ++i)
+        {
+            Real inv_product = 1;
+            int64_t j_max = (std::min)(static_cast<int64_t>(i + approximation_order), static_cast<int64_t>(n - 1));
+            for(int64_t j = i; j <= j_max; ++j)
+            {
+                if (j == k)
+                {
+                    continue;
+                }
+
+                Real diff = m_x[k] - m_x[j];
+                if (abs(diff) < std::numeric_limits<Real>::epsilon())
+                {
+                   std::string msg = std::string("Spacing between  x[")
+                      + boost::lexical_cast<std::string>(k) + std::string("] and x[")
+                      + boost::lexical_cast<std::string>(i) + std::string("] is ")
+                      + boost::lexical_cast<std::string>(diff) + std::string(", which is smaller than the epsilon of ")
+                      + boost::core::demangle(typeid(Real).name());
+                    throw std::logic_error(msg);
+                }
+                inv_product *= diff;
+            }
+            if (i % 2 == 0)
+            {
+                m_w[k] += 1/inv_product;
+            }
+            else
+            {
+                m_w[k] -= 1/inv_product;
+            }
+        }
+    }
+}
+
+template<class Real>
+Real barycentric_rational_imp<Real>::operator()(Real x) const
+{
+    Real numerator = 0;
+    Real denominator = 0;
+    for(size_t i = 0; i < m_x.size(); ++i)
+    {
+        // Presumably we should see if the accuracy is improved by using ULP distance of say, 5 here, instead of testing for floating point equality.
+        // However, it has been shown that if x approx x_i, but x != x_i, then inaccuracy in the numerator cancels the inaccuracy in the denominator,
+        // and the result is fairly accurate. See: http://epubs.siam.org/doi/pdf/10.1137/S0036144502417715
+        if (x == m_x[i])
+        {
+            return m_y[i];
+        }
+        Real t = m_w[i]/(x - m_x[i]);
+        numerator += t*m_y[i];
+        denominator += t;
+    }
+    return numerator/denominator;
+}
+
+/*
+ * A formula for computing the derivative of the barycentric representation is given in
+ * "Some New Aspects of Rational Interpolation", by Claus Schneider and Wilhelm Werner,
+ * Mathematics of Computation, v47, number 175, 1986.
+ * http://www.ams.org/journals/mcom/1986-47-175/S0025-5718-1986-0842136-8/S0025-5718-1986-0842136-8.pdf
+ * However, this requires a lot of machinery which is not built into the library at present.
+ * So we wait until there is a requirement to interpolate the derivative.
+ */
+}}}
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/math/interpolators/detail/cubic_b_spline_detail.hpp b/contrib/libboost/boost_1_65_0/boost/math/interpolators/detail/cubic_b_spline_detail.hpp
new file mode 100644
index 00000000000..f7b2d6cd29f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/math/interpolators/detail/cubic_b_spline_detail.hpp
@@ -0,0 +1,287 @@
+// Copyright Nick Thompson, 2017
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef CUBIC_B_SPLINE_DETAIL_HPP
+#define CUBIC_B_SPLINE_DETAIL_HPP
+
+#include <limits>
+#include <cmath>
+#include <vector>
+#include <memory>
+#include <boost/math/constants/constants.hpp>
+#include <boost/math/special_functions/fpclassify.hpp>
+
+namespace boost{ namespace math{ namespace detail{
+
+
+template <class Real>
+class cubic_b_spline_imp
+{
+public:
+    // If you don't know the value of the derivative at the endpoints, leave them as nans and the routine will estimate them.
+    // f[0] = f(a), f[length -1] = b, step_size = (b - a)/(length -1).
+    template <class BidiIterator>
+    cubic_b_spline_imp(BidiIterator f, BidiIterator end_p, Real left_endpoint, Real step_size,
+                       Real left_endpoint_derivative = std::numeric_limits<Real>::quiet_NaN(),
+                       Real right_endpoint_derivative = std::numeric_limits<Real>::quiet_NaN());
+
+    Real operator()(Real x) const;
+
+    Real prime(Real x) const;
+
+private:
+    std::vector<Real> m_beta;
+    Real m_h_inv;
+    Real m_a;
+    Real m_avg;
+};
+
+
+
+template <class Real>
+Real b3_spline(Real x)
+{
+    using std::abs;
+    Real absx = abs(x);
+    if (absx < 1)
+    {
+        Real y = 2 - absx;
+        Real z = 1 - absx;
+        return boost::math::constants::sixth<Real>()*(y*y*y - 4*z*z*z);
+    }
+    if (absx < 2)
+    {
+        Real y = 2 - absx;
+        return boost::math::constants::sixth<Real>()*y*y*y;
+    }
+    return (Real) 0;
+}
+
+template<class Real>
+Real b3_spline_prime(Real x)
+{
+    if (x < 0)
+    {
+        return -b3_spline_prime(-x);
+    }
+
+    if (x < 1)
+    {
+        return x*(3*boost::math::constants::half<Real>()*x - 2);
+    }
+    if (x < 2)
+    {
+        return -boost::math::constants::half<Real>()*(2 - x)*(2 - x);
+    }
+    return (Real) 0;
+}
+
+
+template <class Real>
+template <class BidiIterator>
+cubic_b_spline_imp<Real>::cubic_b_spline_imp(BidiIterator f, BidiIterator end_p, Real left_endpoint, Real step_size,
+                                             Real left_endpoint_derivative, Real right_endpoint_derivative) : m_a(left_endpoint), m_avg(0)
+{
+    using boost::math::constants::third;
+
+    std::size_t length = end_p - f;
+
+    if (length < 5)
+    {
+        if (boost::math::isnan(left_endpoint_derivative) || boost::math::isnan(right_endpoint_derivative))
+        {
+            throw std::logic_error("Interpolation using a cubic b spline with derivatives estimated at the endpoints requires at least 5 points.\n");
+        }
+        if (length < 3)
+        {
+            throw std::logic_error("Interpolation using a cubic b spline requires at least 3 points.\n");
+        }
+    }
+
+    if (boost::math::isnan(left_endpoint))
+    {
+        throw std::logic_error("Left endpoint is NAN; this is disallowed.\n");
+    }
+    if (left_endpoint + length*step_size >= (std::numeric_limits<Real>::max)())
+    {
+        throw std::logic_error("Right endpoint overflows the maximum representable number of the specified precision.\n");
+    }
+    if (step_size <= 0)
+    {
+        throw std::logic_error("The step size must be strictly > 0.\n");
+    }
+    // Storing the inverse of the stepsize does provide a measurable speedup.
+    // It's not huge, but nonetheless worthwhile.
+    m_h_inv = 1/step_size;
+
+    // Following Kress's notation, s'(a) = a1, s'(b) = b1
+    Real a1 = left_endpoint_derivative;
+    // See the finite-difference table on Wikipedia for reference on how
+    // to construct high-order estimates for one-sided derivatives:
+    // https://en.wikipedia.org/wiki/Finite_difference_coefficient#Forward_and_backward_finite_difference
+    // Here, we estimate then to O(h^4), as that is the maximum accuracy we could obtain from this method.
+    if (boost::math::isnan(a1))
+    {
+        // For simple functions (linear, quadratic, so on)
+        // almost all the error comes from derivative estimation.
+        // This does pairwise summation which gives us another digit of accuracy over naive summation.
+        Real t0 = 4*(f[1] + third<Real>()*f[3]);
+        Real t1 = -(25*third<Real>()*f[0] + f[4])/4  - 3*f[2];
+        a1 = m_h_inv*(t0 + t1);
+    }
+
+    Real b1 = right_endpoint_derivative;
+    if (boost::math::isnan(b1))
+    {
+        size_t n = length - 1;
+        Real t0 = 4*(f[n-3] + third<Real>()*f[n - 1]);
+        Real t1 = -(25*third<Real>()*f[n - 4] + f[n])/4  - 3*f[n - 2];
+
+        b1 = m_h_inv*(t0 + t1);
+    }
+
+    // s(x) = \sum \alpha_i B_{3}( (x- x_i - a)/h )
+    // Of course we must reindex from Kress's notation, since he uses negative indices which make C++ unhappy.
+    m_beta.resize(length + 2, std::numeric_limits<Real>::quiet_NaN());
+
+    // Since the splines have compact support, they decay to zero very fast outside the endpoints.
+    // This is often very annoying; we'd like to evaluate the interpolant a little bit outside the
+    // boundary [a,b] without massive error.
+    // A simple way to deal with this is just to subtract the DC component off the signal, so we need the average.
+    // This algorithm for computing the average is recommended in
+    // http://www.heikohoffmann.de/htmlthesis/node134.html
+    Real t = 1;
+    for (size_t i = 0; i < length; ++i)
+    {
+        if (boost::math::isnan(f[i]))
+        {
+            std::string err = "This function you are trying to interpolate is a nan at index " + std::to_string(i) + "\n";
+            throw std::logic_error(err);
+        }
+        m_avg += (f[i] - m_avg) / t;
+        t += 1;
+    }
+
+
+    // Now we must solve an almost-tridiagonal system, which requires O(N) operations.
+    // There are, in fact 5 diagonals, but they only differ from zero on the first and last row,
+    // so we can patch up the tridiagonal row reduction algorithm to deal with two special rows.
+    // See Kress, equations 8.41
+    // The the "tridiagonal" matrix is:
+    // 1  0 -1
+    // 1  4  1
+    //    1  4  1
+    //       1  4  1
+    //          ....
+    //          1  4  1
+    //          1  0 -1
+    // Numerical estimate indicate that as N->Infinity, cond(A) -> 6.9, so this matrix is good.
+    std::vector<Real> rhs(length + 2, std::numeric_limits<Real>::quiet_NaN());
+    std::vector<Real> super_diagonal(length + 2, std::numeric_limits<Real>::quiet_NaN());
+
+    rhs[0] = -2*step_size*a1;
+    rhs[rhs.size() - 1] = -2*step_size*b1;
+
+    super_diagonal[0] = 0;
+
+    for(size_t i = 1; i < rhs.size() - 1; ++i)
+    {
+        rhs[i] = 6*(f[i - 1] - m_avg);
+        super_diagonal[i] = 1;
+    }
+
+
+    // One step of row reduction on the first row to patch up the 5-diagonal problem:
+    // 1 0 -1 | r0
+    // 1 4 1  | r1
+    // mapsto:
+    // 1 0 -1 | r0
+    // 0 4 2  | r1 - r0
+    // mapsto
+    // 1 0 -1 | r0
+    // 0 1 1/2| (r1 - r0)/4
+    super_diagonal[1] = 0.5;
+    rhs[1] = (rhs[1] - rhs[0])/4;
+
+    // Now do a tridiagonal row reduction the standard way, until just before the last row:
+    for (size_t i = 2; i < rhs.size() - 1; ++i)
+    {
+        Real diagonal = 4 - super_diagonal[i - 1];
+        rhs[i] = (rhs[i] - rhs[i - 1])/diagonal;
+        super_diagonal[i] /= diagonal;
+    }
+
+    // Now the last row, which is in the form
+    // 1 sd[n-3] 0      | rhs[n-3]
+    // 0  1     sd[n-2] | rhs[n-2]
+    // 1  0     -1      | rhs[n-1]
+    Real final_subdiag = -super_diagonal[rhs.size() - 3];
+    rhs[rhs.size() - 1] = (rhs[rhs.size() - 1] - rhs[rhs.size() - 3])/final_subdiag;
+    Real final_diag = -1/final_subdiag;
+    // Now we're here:
+    // 1 sd[n-3] 0         | rhs[n-3]
+    // 0  1     sd[n-2]    | rhs[n-2]
+    // 0  1     final_diag | (rhs[n-1] - rhs[n-3])/diag
+
+    final_diag = final_diag - super_diagonal[rhs.size() - 2];
+    rhs[rhs.size() - 1] = rhs[rhs.size() - 1] - rhs[rhs.size() - 2];
+
+
+    // Back substitutions:
+    m_beta[rhs.size() - 1] = rhs[rhs.size() - 1]/final_diag;
+    for(size_t i = rhs.size() - 2; i > 0; --i)
+    {
+        m_beta[i] = rhs[i] - super_diagonal[i]*m_beta[i + 1];
+    }
+    m_beta[0] = m_beta[2] + rhs[0];
+}
+
+template<class Real>
+Real cubic_b_spline_imp<Real>::operator()(Real x) const
+{
+    // See Kress, 8.40: Since B3 has compact support, we don't have to sum over all terms,
+    // just the (at most 5) whose support overlaps the argument.
+    Real z = m_avg;
+    Real t = m_h_inv*(x - m_a) + 1;
+
+    using std::max;
+    using std::min;
+    using std::ceil;
+    using std::floor;
+
+    size_t k_min = (size_t) max(static_cast<long>(0), boost::math::ltrunc(ceil(t - 2)));
+    size_t k_max = (size_t) max(min(static_cast<long>(m_beta.size() - 1), boost::math::ltrunc(floor(t + 2))), (long) 0);
+    for (size_t k = k_min; k <= k_max; ++k)
+    {
+        z += m_beta[k]*b3_spline(t - k);
+    }
+
+    return z;
+}
+
+template<class Real>
+Real cubic_b_spline_imp<Real>::prime(Real x) const
+{
+    Real z = 0;
+    Real t = m_h_inv*(x - m_a) + 1;
+
+    using std::max;
+    using std::min;
+    using std::ceil;
+    using std::floor;
+
+    size_t k_min = (size_t) max(static_cast<long>(0), boost::math::ltrunc(ceil(t - 2)));
+    size_t k_max = (size_t) min(static_cast<long>(m_beta.size() - 1), boost::math::ltrunc(floor(t + 2)));
+
+    for (size_t k = k_min; k <= k_max; ++k)
+    {
+        z += m_beta[k]*b3_spline_prime(t - k);
+    }
+    return z*m_h_inv;
+}
+
+}}}
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/math/octonion.hpp b/contrib/libboost/boost_1_65_0/boost/math/octonion.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/octonion.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/octonion.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/policies/error_handling.hpp b/contrib/libboost/boost_1_65_0/boost/math/policies/error_handling.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/policies/error_handling.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/policies/error_handling.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/policies/policy.hpp b/contrib/libboost/boost_1_65_0/boost/math/policies/policy.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/policies/policy.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/policies/policy.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/math/quadrature/trapezoidal.hpp b/contrib/libboost/boost_1_65_0/boost/math/quadrature/trapezoidal.hpp
new file mode 100644
index 00000000000..af466a0916d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/math/quadrature/trapezoidal.hpp
@@ -0,0 +1,120 @@
+/*
+ * Copyright Nick Thompson, 2017
+ * 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)
+ *
+ * Use the adaptive trapezoidal rule to estimate the integral of periodic functions over a period,
+ * or to integrate a function whose derivative vanishes at the endpoints.
+ *
+ * If your function does not satisfy these conditions, and instead is simply continuous and bounded
+ * over the whole interval, then this routine will still converge, albeit slowly. However, there
+ * are much more efficient methods in this case, including Romberg, Simpson, and double exponential quadrature.
+ */
+
+#ifndef BOOST_MATH_QUADRATURE_TRAPEZOIDAL_HPP
+#define BOOST_MATH_QUADRATURE_TRAPEZOIDAL_HPP
+
+#include <cmath>
+#include <limits>
+#include <stdexcept>
+#include <boost/math/constants/constants.hpp>
+#include <boost/math/special_functions/fpclassify.hpp>
+#include <boost/math/policies/error_handling.hpp>
+
+namespace boost{ namespace math{ namespace quadrature {
+
+template<class F, class Real, class Policy>
+Real trapezoidal(F f, Real a, Real b, Real tol, std::size_t max_refinements, Real* error_estimate, Real* L1, const Policy& pol)
+{
+    static const char* function = "boost::math::quadrature::trapezoidal<%1%>(F, %1%, %1%, %1%)";
+    using std::abs;
+    using boost::math::constants::half;
+    if(a >= b)
+    {
+        return boost::math::policies::raise_domain_error(function, "a < b for integration over the region [a, b] is required, but got a = %1%.\n", a, pol);
+    }
+    if (!(boost::math::isfinite)(a))
+    {
+       return boost::math::policies::raise_domain_error(function, "Left endpoint of integration must be finite for adaptive trapezoidal integration but got a = %1%.\n", a, pol);
+    }
+    if (!(boost::math::isfinite)(b))
+    {
+       return boost::math::policies::raise_domain_error(function, "Right endpoint of integration must be finite for adaptive trapedzoidal integration but got b = %1%.\n", b, pol);
+    }
+
+    Real ya = f(a);
+    Real yb = f(b);
+    Real h = (b - a)*half<Real>();
+    Real I0 = (ya + yb)*h;
+    Real IL0 = (abs(ya) + abs(yb))*h;
+
+    Real yh = f(a + h);
+    Real I1 = half<Real>()*I0 + yh*h;
+    Real IL1 = half<Real>()*IL0 + abs(yh)*h;
+
+    // The recursion is:
+    // I_k = 1/2 I_{k-1} + 1/2^k \sum_{j=1; j odd, j < 2^k} f(a + j(b-a)/2^k)
+    std::size_t k = 2;
+    // We want to go through at least 4 levels so we have sampled the function at least 10 times.
+    // Otherwise, we could terminate prematurely and miss essential features.
+    // This is of course possible anyway, but 10 samples seems to be a reasonable compromise.
+    Real error = abs(I0 - I1);
+    while (k < 4 || (k < max_refinements && error > tol*IL1) )
+    {
+        I0 = I1;
+        IL0 = IL1;
+
+        I1 = half<Real>()*I0;
+        IL1 = half<Real>()*IL0;
+        std::size_t p = static_cast<std::size_t>(1u) << k;
+        h *= half<Real>();
+        Real sum = 0;
+        Real absum = 0;
+
+        for(std::size_t j = 1; j < p; j += 2)
+        {
+            Real y = f(a + j*h);
+            sum += y;
+            absum += abs(y);
+        }
+
+        I1 += sum*h;
+        IL1 += absum*h;
+        ++k;
+        error = abs(I0 - I1);
+    }
+
+    if (error_estimate)
+    {
+        *error_estimate = error;
+    }
+
+    if (L1)
+    {
+        *L1 = IL1;
+    }
+
+    return I1;
+}
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1800)
+// Template argument dedcution failure otherwise:
+template<class F, class Real>
+Real trapezoidal(F f, Real a, Real b, Real tol = 0, std::size_t max_refinements = 10, Real* error_estimate = 0, Real* L1 = 0)
+#elif !defined(BOOST_NO_CXX11_NULLPTR)
+template<class F, class Real>
+Real trapezoidal(F f, Real a, Real b, Real tol = boost::math::tools::root_epsilon<Real>(), std::size_t max_refinements = 10, Real* error_estimate = nullptr, Real* L1 = nullptr)
+#else
+template<class F, class Real>
+Real trapezoidal(F f, Real a, Real b, Real tol = boost::math::tools::root_epsilon<Real>(), std::size_t max_refinements = 10, Real* error_estimate = 0, Real* L1 = 0)
+#endif
+{
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1600)
+   if (tol == 0)
+      tol = boost::math::tools::root_epsilon<Real>();
+#endif
+   return trapezoidal(f, a, b, tol, max_refinements, error_estimate, L1, boost::math::policies::policy<>());
+}
+
+}}}
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/math/quaternion.hpp b/contrib/libboost/boost_1_65_0/boost/math/quaternion.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/quaternion.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/quaternion.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/acosh.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/acosh.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/acosh.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/acosh.hpp
index 0af5c94c145..3b7edbad3f8 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/special_functions/acosh.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/acosh.hpp
@@ -36,7 +36,7 @@ namespace boost
         {
             BOOST_MATH_STD_USING
             
-            if(x < 1)
+            if((x < 1) || (boost::math::isnan)(x))
             {
                return policies::raise_domain_error<T>(
                   "boost::math::acosh<%1%>(%1%)",
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/airy.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/airy.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/airy.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/airy.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/asinh.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/asinh.hpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/asinh.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/asinh.hpp
index a863e688545..e55a3562846 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/special_functions/asinh.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/asinh.hpp
@@ -36,6 +36,12 @@ namespace boost
         {
             BOOST_MATH_STD_USING
             
+            if((boost::math::isnan)(x))
+            {
+               return policies::raise_domain_error<T>(
+                  "boost::math::asinh<%1%>(%1%)",
+                  "asinh requires a finite argument, but got x = %1%.", x, pol);
+            }
             if        (x >= tools::forth_root_epsilon<T>())
             {
                if        (x > 1 / tools::root_epsilon<T>())
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/atanh.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/atanh.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/atanh.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/atanh.hpp
index 2c5e3f4b78a..871a465a8cd 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/special_functions/atanh.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/atanh.hpp
@@ -51,6 +51,12 @@ namespace boost
                   function,
                   "atanh requires x <= 1, but got x = %1%.", x, pol);
             }
+            else if((boost::math::isnan)(x))
+            {
+               return policies::raise_domain_error<T>(
+                  function,
+                  "atanh requires -1 <= x <= 1, but got x = %1%.", x, pol);
+            }
             else if(x < -1 + tools::epsilon<T>())
             {
                // -Infinity:
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/bernoulli.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/bernoulli.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/bernoulli.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/bernoulli.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/bessel.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/bessel.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/bessel.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/bessel.hpp
index 1b57e0a8734..69f931bd5a4 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/special_functions/bessel.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/bessel.hpp
@@ -206,7 +206,7 @@ T cyl_bessel_i_imp(T v, T x, const Policy& pol)
       }
       return sqrt(2 / (x * constants::pi<T>())) * sinh(x);
    }
-   if(policies::digits<T, Policy>() <= 64)
+   if(policies::digits<T, Policy>() <= 113)
    {
       if(v == 0)
       {
@@ -572,7 +572,7 @@ inline typename detail::bessel_traits<T1, T2, Policy>::result_type cyl_bessel_k(
 {
    BOOST_FPU_EXCEPTION_GUARD
    typedef typename detail::bessel_traits<T1, T2, Policy>::result_type result_type;
-   typedef typename detail::bessel_traits<T1, T2, Policy>::optimisation_tag tag_type;
+   typedef typename detail::bessel_traits<T1, T2, Policy>::optimisation_tag128 tag_type;
    typedef typename policies::evaluation<result_type, Policy>::type value_type;
    typedef typename policies::normalise<
       Policy, 
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/bessel_prime.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/bessel_prime.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/bessel_prime.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/bessel_prime.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/beta.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/beta.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/beta.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/beta.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/binomial.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/binomial.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/binomial.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/binomial.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/cbrt.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/cbrt.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/cbrt.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/cbrt.hpp
index 0fc6e0742af..c34ad39949a 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/special_functions/cbrt.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/cbrt.hpp
@@ -68,7 +68,8 @@ T cbrt_imp(T z, const Policy& pol)
       static_cast<T>(1.2599210498948731647672106072782),   // 2^1/3
       static_cast<T>(1.5874010519681994747517056392723),   // 2^2/3
    };
-
+   if((boost::math::isinf)(z) || (z == 0))
+      return z;
    if(!(boost::math::isfinite)(z))
    {
       return policies::raise_domain_error("boost::math::cbrt<%1%>(%1%)", "Argument to function must be finite but got %1%.", z, pol);
@@ -80,8 +81,6 @@ T cbrt_imp(T z, const Policy& pol)
       z = -z;
       sign = -sign;
    }
-   if(z == 0)
-      return 0;
 
    T guess = frexp(z, &i_exp);
    int original_i_exp = i_exp; // save for later
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/cos_pi.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/cos_pi.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/cos_pi.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/cos_pi.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/airy_ai_bi_zero.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/airy_ai_bi_zero.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/airy_ai_bi_zero.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/airy_ai_bi_zero.hpp
index dbb7388dda9..b5a71c78eb2 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/airy_ai_bi_zero.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/airy_ai_bi_zero.hpp
@@ -86,7 +86,7 @@
         class function_object_ai_and_ai_prime
         {
         public:
-          function_object_ai_and_ai_prime(const Policy pol) : my_pol(pol) { }
+          function_object_ai_and_ai_prime(const Policy& pol) : my_pol(pol) { }
 
           boost::math::tuple<T, T> operator()(const T& x) const
           {
@@ -137,7 +137,7 @@
         class function_object_bi_and_bi_prime
         {
         public:
-          function_object_bi_and_bi_prime(const Policy pol) : my_pol(pol) { }
+          function_object_bi_and_bi_prime(const Policy& pol) : my_pol(pol) { }
 
           boost::math::tuple<T, T> operator()(const T& x) const
           {
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bernoulli_details.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bernoulli_details.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bernoulli_details.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bernoulli_details.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_derivatives_linear.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_derivatives_linear.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_derivatives_linear.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_derivatives_linear.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_i0.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_i0.hpp
new file mode 100644
index 00000000000..77382294542
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_i0.hpp
@@ -0,0 +1,554 @@
+//  Copyright (c) 2006 Xiaogang Zhang
+//  Copyright (c) 2017 John Maddock
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_MATH_BESSEL_I0_HPP
+#define BOOST_MATH_BESSEL_I0_HPP
+
+#ifdef _MSC_VER
+#pragma once
+#endif
+
+#include <boost/math/tools/rational.hpp>
+#include <boost/math/tools/big_constant.hpp>
+#include <boost/assert.hpp>
+
+// Modified Bessel function of the first kind of order zero
+// we use the approximating forms derived in:
+// "Rational Approximations for the Modified Bessel Function of the First Kind � I0(x) for Computations with Double Precision"
+// by Pavel Holoborodko, 
+// see http://www.advanpix.com/2015/11/11/rational-approximations-for-the-modified-bessel-function-of-the-first-kind-i0-computations-double-precision
+// The actual coefficients used are our own, and extend Pavel's work to precision's other than double.
+
+namespace boost { namespace math { namespace detail{
+
+template <typename T>
+T bessel_i0(const T& x);
+
+template <class T, class tag>
+struct bessel_i0_initializer
+{
+   struct init
+   {
+      init()
+      {
+         do_init(tag());
+      }
+      static void do_init(const mpl::int_<64>&)
+      {
+         bessel_i0(T(1));
+         bessel_i0(T(8));
+         bessel_i0(T(12));
+         bessel_i0(T(40));
+         bessel_i0(T(101));
+      }
+      static void do_init(const mpl::int_<113>&)
+      {
+         bessel_i0(T(1));
+         bessel_i0(T(10));
+         bessel_i0(T(20));
+         bessel_i0(T(40));
+         bessel_i0(T(101));
+      }
+      template <class U>
+      static void do_init(const U&) {}
+      void force_instantiate()const {}
+   };
+   static const init initializer;
+   static void force_instantiate()
+   {
+      initializer.force_instantiate();
+   }
+};
+
+template <class T, class tag>
+const typename bessel_i0_initializer<T, tag>::init bessel_i0_initializer<T, tag>::initializer;
+
+template <typename T, int N>
+T bessel_i0_imp(const T&, const mpl::int_<N>&)
+{
+   BOOST_ASSERT(0);
+   return 0;
+}
+
+template <typename T>
+T bessel_i0_imp(const T& x, const mpl::int_<24>&)
+{
+   BOOST_MATH_STD_USING
+   if(x < 7.75)
+   {
+      // Max error in interpolated form: 3.929e-08
+      // Max Error found at float precision = Poly: 1.991226e-07
+      static const float P[] = {
+         1.00000003928615375e+00f,
+         2.49999576572179639e-01f,
+         2.77785268558399407e-02f,
+         1.73560257755821695e-03f,
+         6.96166518788906424e-05f,
+         1.89645733877137904e-06f,
+         4.29455004657565361e-08f,
+         3.90565476357034480e-10f,
+         1.48095934745267240e-11f
+      };
+      T a = x * x / 4;
+      return a * boost::math::tools::evaluate_polynomial(P, a) + 1;
+   }
+   else if(x < 50)
+   {
+      // Max error in interpolated form: 5.195e-08
+      // Max Error found at float precision = Poly: 8.502534e-08
+      static const float P[] = {
+         3.98942651588301770e-01f,
+         4.98327234176892844e-02f,
+         2.91866904423115499e-02f,
+         1.35614940793742178e-02f,
+         1.31409251787866793e-01f
+      };
+      return exp(x) * boost::math::tools::evaluate_polynomial(P, T(1 / x)) / sqrt(x);
+   }
+   else
+   {
+      // Max error in interpolated form: 1.782e-09
+      // Max Error found at float precision = Poly: 6.473568e-08
+      static const float P[] = {
+         3.98942391532752700e-01f,
+         4.98455950638200020e-02f,
+         2.94835666900682535e-02f
+      };
+      T ex = exp(x / 2);
+      T result = ex * boost::math::tools::evaluate_polynomial(P, T(1 / x)) / sqrt(x);
+      result *= ex;
+      return result;
+   }
+}
+
+template <typename T>
+T bessel_i0_imp(const T& x, const mpl::int_<53>&)
+{
+   BOOST_MATH_STD_USING
+   if(x < 7.75)
+   {
+      // Bessel I0 over[10 ^ -16, 7.75]
+      // Max error in interpolated form : 3.042e-18
+      // Max Error found at double precision = Poly : 5.106609e-16 Cheb : 5.239199e-16
+      static const double P[] = {
+         1.00000000000000000e+00,
+         2.49999999999999909e-01,
+         2.77777777777782257e-02,
+         1.73611111111023792e-03,
+         6.94444444453352521e-05,
+         1.92901234513219920e-06,
+         3.93675991102510739e-08,
+         6.15118672704439289e-10,
+         7.59407002058973446e-12,
+         7.59389793369836367e-14,
+         6.27767773636292611e-16,
+         4.34709704153272287e-18,
+         2.63417742690109154e-20,
+         1.13943037744822825e-22,
+         9.07926920085624812e-25
+      };
+      T a = x * x / 4;
+      return a * boost::math::tools::evaluate_polynomial(P, a) + 1;
+   }
+   else if(x < 500)
+   {
+      // Max error in interpolated form : 1.685e-16
+      // Max Error found at double precision = Poly : 2.575063e-16 Cheb : 2.247615e+00
+      static const double P[] = {
+         3.98942280401425088e-01,
+         4.98677850604961985e-02,
+         2.80506233928312623e-02,
+         2.92211225166047873e-02,
+         4.44207299493659561e-02,
+         1.30970574605856719e-01,
+         -3.35052280231727022e+00,
+         2.33025711583514727e+02,
+         -1.13366350697172355e+04,
+         4.24057674317867331e+05,
+         -1.23157028595698731e+07,
+         2.80231938155267516e+08,
+         -5.01883999713777929e+09,
+         7.08029243015109113e+10,
+         -7.84261082124811106e+11,
+         6.76825737854096565e+12,
+         -4.49034849696138065e+13,
+         2.24155239966958995e+14,
+         -8.13426467865659318e+14,
+         2.02391097391687777e+15,
+         -3.08675715295370878e+15,
+         2.17587543863819074e+15
+      };
+      return exp(x) * boost::math::tools::evaluate_polynomial(P, T(1 / x)) / sqrt(x);
+   }
+   else
+   {
+      // Max error in interpolated form : 2.437e-18
+      // Max Error found at double precision = Poly : 1.216719e-16
+      static const double P[] = {
+         3.98942280401432905e-01,
+         4.98677850491434560e-02,
+         2.80506308916506102e-02,
+         2.92179096853915176e-02,
+         4.53371208762579442e-02
+      };
+      T ex = exp(x / 2);
+      T result = ex * boost::math::tools::evaluate_polynomial(P, T(1 / x)) / sqrt(x);
+      result *= ex;
+      return result;
+   }
+}
+
+template <typename T>
+T bessel_i0_imp(const T& x, const mpl::int_<64>&)
+{
+   BOOST_MATH_STD_USING
+   if(x < 7.75)
+   {
+      // Bessel I0 over[10 ^ -16, 7.75]
+      // Max error in interpolated form : 3.899e-20
+      // Max Error found at float80 precision = Poly : 1.770840e-19
+      static const T P[] = {
+         BOOST_MATH_BIG_CONSTANT(T, 64, 9.99999999999999999961011629e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 2.50000000000000001321873912e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 2.77777777777777703400424216e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 1.73611111111112764793802701e-03),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 6.94444444444251461247253525e-05),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 1.92901234569262206386118739e-06),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 3.93675988851131457141005209e-08),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 6.15118734688297476454205352e-10),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 7.59405797058091016449222685e-12),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 7.59406599631719800679835140e-14),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 6.27598961062070013516660425e-16),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 4.35920318970387940278362992e-18),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 2.57372492687715452949437981e-20),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 1.33908663475949906992942204e-22),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 5.15976668870980234582896010e-25),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 3.46240478946376069211156548e-27)
+      };
+      T a = x * x / 4;
+      return a * boost::math::tools::evaluate_polynomial(P, a) + 1;
+   }
+   else if(x < 10)
+   {
+      // Maximum Deviation Found:                     6.906e-21
+      // Expected Error Term : -6.903e-21
+      // Maximum Relative Change in Control Points : 1.631e-04
+      // Max Error found at float80 precision = Poly : 7.811948e-21
+      static const T Y = 4.051098823547363281250e-01f;
+      static const T P[] = {
+         BOOST_MATH_BIG_CONSTANT(T, 64, -6.158081780620616479492e-03),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 4.883635969834048766148e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 7.892782002476195771920e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -1.478784996478070170327e+00),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 2.988611837308006851257e+01),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -4.140133766747436806179e+02),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 4.117316447921276453271e+03),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -2.942353667455141676001e+04),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 1.493482682461387081534e+05),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -5.228100538921466124653e+05),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 1.195279248600467989454e+06),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -1.601530760654337045917e+06),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 9.504921137873298402679e+05)
+      };
+      return exp(x) * (boost::math::tools::evaluate_polynomial(P, T(1 / x)) + Y) / sqrt(x);
+   }
+   else if(x < 15)
+   {
+      // Maximum Deviation Found:                     4.083e-21
+      // Expected Error Term : -4.025e-21
+      // Maximum Relative Change in Control Points : 1.304e-03
+      // Max Error found at float80 precision = Poly : 2.303527e-20
+      static const T Y = 4.033188819885253906250e-01f;
+      static const T P[] = {
+         BOOST_MATH_BIG_CONSTANT(T, 64, -4.376373876116109401062e-03),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 4.982899138682911273321e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 3.109477529533515397644e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -1.163760580110576407673e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 4.776501832837367371883e+00),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -1.101478069227776656318e+02),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 1.892071912448960299773e+03),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -2.417739279982328117483e+04),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 2.296963447724067390552e+05),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -1.598589306710589358747e+06),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 7.903662411851774878322e+06),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -2.622677059040339516093e+07),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 5.227776578828667629347e+07),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -4.727797957441040896878e+07)
+      };
+      return exp(x) * (boost::math::tools::evaluate_polynomial(P, T(1 / x)) + Y) / sqrt(x);
+   }
+   else if(x < 50)
+   {
+      // Max error in interpolated form: 1.035e-21
+      // Max Error found at float80 precision = Poly: 1.885872e-21
+      static const T Y = 4.011702537536621093750e-01f;
+      static const T P[] = {
+         BOOST_MATH_BIG_CONSTANT(T, 64, -2.227973351806078464328e-03),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 4.986778486088017419036e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 2.805066823812285310011e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 2.921443721160964964623e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 4.517504941996594744052e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 6.316922639868793684401e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 1.535891099168810015433e+00),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -4.706078229522448308087e+01),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 1.351015763079160914632e+03),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -2.948809013999277355098e+04),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 4.967598958582595361757e+05),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -6.346924657995383019558e+06),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 5.998794574259956613472e+07),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -4.016371355801690142095e+08),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 1.768791455631826490838e+09),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -4.441995678177349895640e+09),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 4.482292669974971387738e+09)
+      };
+      return exp(x) * (boost::math::tools::evaluate_polynomial(P, T(1 / x)) + Y) / sqrt(x);
+   }
+   else
+   {
+      // Bessel I0 over[50, INF]
+      // Max error in interpolated form : 5.587e-20
+      // Max Error found at float80 precision = Poly : 8.776852e-20
+      static const T P[] = {
+         BOOST_MATH_BIG_CONSTANT(T, 64, 3.98942280401432677955074061e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 4.98677850501789875615574058e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 2.80506290908675604202206833e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 2.92194052159035901631494784e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 4.47422430732256364094681137e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 9.05971614435738691235525172e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 2.29180522595459823234266708e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 6.15122547776140254569073131e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 7.48491812136365376477357324e+00),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -2.45569740166506688169730713e+02),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 9.66857566379480730407063170e+03),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -2.71924083955641197750323901e+05),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 5.74276685704579268845870586e+06),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -8.89753803265734681907148778e+07),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 9.82590905134996782086242180e+08),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -7.30623197145529889358596301e+09),
+         BOOST_MATH_BIG_CONSTANT(T, 64, 3.27310000726207055200805893e+10),
+         BOOST_MATH_BIG_CONSTANT(T, 64, -6.64365417189215599168817064e+10)
+      };
+      T ex = exp(x / 2);
+      T result = ex * boost::math::tools::evaluate_polynomial(P, T(1 / x)) / sqrt(x);
+      result *= ex;
+      return result;
+   }
+}
+
+template <typename T>
+T bessel_i0_imp(const T& x, const mpl::int_<113>&)
+{
+   BOOST_MATH_STD_USING
+   if(x < 7.75)
+   {
+      // Bessel I0 over[10 ^ -34, 7.75]
+      // Max error in interpolated form : 1.274e-34
+      // Max Error found at float128 precision = Poly : 3.096091e-34
+      static const T P[] = {
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.0000000000000000000000000000000001273856e+00),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.4999999999999999999999999999999107477496e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.7777777777777777777777777777881795230918e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.7361111111111111111111111106290091648808e-03),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.9444444444444444444444445629960334523101e-05),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.9290123456790123456790105563456483249753e-06),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.9367598891408415217940836339080514004844e-08),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.1511873267825648777900014857992724731476e-10),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 7.5940584281266233066162999610732449709209e-12),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 7.5940584281266232783124723601470051895304e-14),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.2760813455591936763439337059117957836078e-16),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 4.3583898233049738471136482147779094353096e-18),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.5789288895299965395422423848480340736308e-20),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.3157800456718804437960453545507623434606e-22),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 5.8479113149412360748032684260932041506493e-25),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.2843403488398038539283241944594140493394e-27),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 7.9042925594356556196790242908697582021825e-30),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.4395919891312152120710245152115597111101e-32),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.7580986145276689333214547502373003196707e-35),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.6886514018062348877723837017198859723889e-37),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.8540558465757554512570197585002702777999e-40),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 7.4684706070226893763741850944911705726436e-43),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.0210715309399646335858150349406935414314e-45)
+      };
+      T a = x * x / 4;
+      return a * boost::math::tools::evaluate_polynomial(P, a) + 1;
+   }
+   else if(x < 15)
+   {
+      // Bessel I0 over[7.75, 15]
+      // Max error in interpolated form : 7.534e-35
+      // Max Error found at float128 precision = Poly : 6.123912e-34
+      static const T P[] = {
+         BOOST_MATH_BIG_CONSTANT(T, 113, 9.9999999999999999992388573069504617493518e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.5000000000000000007304739268173096975340e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.7777777777777777744261405400543564492074e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.7361111111111111209006987259719750726867e-03),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.9444444444444442399703186871329381908321e-05),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.9290123456790126709286741580242189785431e-06),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.9367598891408374246503061422528266924389e-08),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.1511873267826068395343047827801353170966e-10),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 7.5940584281262673459688011737168286944521e-12),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 7.5940584281291583769928563167645746144508e-14),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.2760813455438840231126529638737436950274e-16),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 4.3583898233839583885132809584770578894948e-18),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.5789288891798658971960571838369339742994e-20),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.3157800470129311623308216856009970266088e-22),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 5.8479112701534604520063520412207286692581e-25),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.2843404822552330714586265081801727491890e-27),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 7.9042888166225242675881424439818162458179e-30),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.4396027771820721384198604723320045236973e-32),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.7577659910606076328136207973456511895030e-35),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.6896548123724136624716224328803899914646e-37),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.8285850162160539150210466453921758781984e-40),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 7.9419071894227736216423562425429524883562e-43),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.4720374049498608905571855665134539425038e-45),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.7763533278527958112907118930154738930378e-48),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.1213839473168678646697528580511702663617e-51),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.0648035313124146852372607519737686740964e-53),
+         -BOOST_MATH_BIG_CONSTANT(T, 113, 5.1255595184052024349371058585102280860878e-57),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.4652470895944157957727948355523715335882e-59)
+      };
+      T a = x * x / 4;
+      return a * boost::math::tools::evaluate_polynomial(P, a) + 1;
+   }
+   else if(x < 30)
+   {
+      // Max error in interpolated form : 1.808e-34
+      // Max Error found at float128 precision = Poly : 2.399403e-34
+      static const T P[] = {
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.9894228040870793650581242239624530714032e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 4.9867780576714783790784348982178607842250e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.8051948347934462928487999569249907599510e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.8971143420388958551176254291160976367263e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 7.8197359701715582763961322341827341098897e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -3.3430484862908317377522273217643346601271e+00),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.7884507603213662610604413960838990199224e+02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -1.8304926482356755790062999202373909300514e+04),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 9.8867173178574875515293357145875120137676e+05),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -4.4261178812193528551544261731796888257644e+07),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.6453010340778116475788083817762403540097e+09),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -5.0432401330113978669454035365747869477960e+10),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.2462165331309799059332310595587606836357e+12),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.3299800389951335932792950236410844978273e+13),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.5748218240248714177527965706790413406639e+14),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.8330014378766930869945511450377736037385e+15),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -1.8494610073827453236940544799030787866218e+17),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 5.7244661371420647691301043350229977856476e+18),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -1.2386378807889388140099109087465781254321e+20),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.1104000573102013529518477353943384110982e+21),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.9426541092239879262282594572224300191016e+22),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.4061439136301913488512592402635688101020e+23),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -3.2836554760521986358980180942859101564671e+24),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.6270285589905206294944214795661236766988e+25),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -1.7278631455211972017740134341610659484259e+26),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 9.1971734473772196124736986948034978906801e+26),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -3.8669270707172568763908838463689093500098e+27),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.2368879358870281916900125550129211146626e+28),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.8296235063297831758204519071113999839858e+28),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 4.1253861666023020670144616019148954773662e+28),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.8809536950051955163648980306847791014734e+28) };
+      return exp(x) * boost::math::tools::evaluate_polynomial(P, T(1 / x)) / sqrt(x);
+   }
+   else if(x < 100)
+   {
+      // Bessel I0 over[30, 100]
+      // Max error in interpolated form : 1.487e-34
+      // Max Error found at float128 precision = Poly : 1.929924e-34
+      static const T P[] = {
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.9894228040143267793996798658172135362278e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 4.9867785050179084714910130342157246539820e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.8050629090725751585266360464766768437048e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.9219405302833158254515212437025679637597e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 4.4742214371598631578107310396249912330627e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 9.0602983776478659136184969363625092585520e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.2839507231977478205885469900971893734770e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.8925739165733823730525449511456529001868e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.4238082222874015159424842335385854632223e+00),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 9.6759648427182491050716309699208988458050e+00),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 4.7292246491169360014875196108746167872215e+01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.1001411442786230340015781205680362993575e+01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 9.8277628835804873490331739499978938078848e+03),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -3.1208326312801432038715638596517882759639e+05),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 9.4813611580683862051838126076298945680803e+06),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.1278197693321821164135890132925119054391e+08),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.3190303792682886967459489059860595063574e+09),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.1580767338646580750893606158043485767644e+10),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -5.0256008808415702780816006134784995506549e+11),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.9044186472918017896554580836514681614475e+13),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -3.2521078890073151875661384381880225635135e+14),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.3620352486836976842181057590770636605454e+15),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.0375525734060401555856465179734887312420e+16),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 5.6392664899881014534361728644608549445131e+16)
+      };
+      return exp(x) * boost::math::tools::evaluate_polynomial(P, T(1 / x)) / sqrt(x);
+   }
+   else
+   {
+      // Bessel I0 over[100, INF]
+      // Max error in interpolated form : 5.459e-35
+      // Max Error found at float128 precision = Poly : 1.472240e-34
+      static const T P[] = {
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.9894228040143267793994605993438166526772e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 4.9867785050179084742493257495245185241487e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.8050629090725735167652437695397756897920e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.9219405302839307466358297347675795965363e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 4.4742214369972689474366968442268908028204e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 9.0602984099194778006610058410222616383078e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.2839502241666629677015839125593079416327e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.8926354981801627920292655818232972385750e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.4231921590621824187100989532173995000655e+00),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 9.7264260959693775207585700654645245723497e+00),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 4.3890136225398811195878046856373030127018e+01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.1999720924619285464910452647408431234369e+02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.2076909538525038580501368530598517194748e+03),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 7.5684635141332367730007149159063086133399e+03),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.5178192543258299267923025833141286569141e+04),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.2966297919851965784482163987240461837728e+05) };
+      T ex = exp(x / 2);
+      T result = ex * boost::math::tools::evaluate_polynomial(P, T(1 / x)) / sqrt(x);
+      result *= ex;
+      return result;
+   }
+}
+
+template <typename T>
+T bessel_i0_imp(const T& x, const mpl::int_<0>&)
+{
+   if(boost::math::tools::digits<T>() <= 24)
+      return bessel_i0_imp(x, mpl::int_<24>());
+   else if(boost::math::tools::digits<T>() <= 53)
+      return bessel_i0_imp(x, mpl::int_<53>());
+   else if(boost::math::tools::digits<T>() <= 64)
+      return bessel_i0_imp(x, mpl::int_<64>());
+   else if(boost::math::tools::digits<T>() <= 113)
+      return bessel_i0_imp(x, mpl::int_<113>());
+   BOOST_ASSERT(0);
+   return 0;
+}
+
+template <typename T>
+inline T bessel_i0(const T& x)
+{
+   typedef mpl::int_<
+      ((std::numeric_limits<T>::digits == 0) || (std::numeric_limits<T>::radix != 2)) ?
+      0 :
+      std::numeric_limits<T>::digits <= 24 ?
+      24 :
+      std::numeric_limits<T>::digits <= 53 ?
+      53 :
+      std::numeric_limits<T>::digits <= 64 ?
+      64 :
+      std::numeric_limits<T>::digits <= 113 ?
+      113 : -1
+   > tag_type;
+
+   bessel_i0_initializer<T, tag_type>::force_instantiate();
+   return bessel_i0_imp(x, tag_type());
+}
+
+}}} // namespaces
+
+#endif // BOOST_MATH_BESSEL_I0_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_i1.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_i1.hpp
new file mode 100644
index 00000000000..a6364a6cc9f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_i1.hpp
@@ -0,0 +1,577 @@
+// Modified Bessel function of the first kind of order zero
+// we use the approximating forms derived in:
+// "Rational Approximations for the Modified Bessel Function of the First Kind � I1(x) for Computations with Double Precision"
+// by Pavel Holoborodko, 
+// see http://www.advanpix.com/2015/11/12/rational-approximations-for-the-modified-bessel-function-of-the-first-kind-i1-for-computations-with-double-precision/
+// The actual coefficients used are our own, and extend Pavel's work to precision's other than double.
+
+#ifndef BOOST_MATH_BESSEL_I1_HPP
+#define BOOST_MATH_BESSEL_I1_HPP
+
+#ifdef _MSC_VER
+#pragma once
+#endif
+
+#include <boost/math/tools/rational.hpp>
+#include <boost/math/tools/big_constant.hpp>
+#include <boost/assert.hpp>
+
+// Modified Bessel function of the first kind of order one
+// minimax rational approximations on intervals, see
+// Blair and Edwards, Chalk River Report AECL-4928, 1974
+
+namespace boost { namespace math { namespace detail{
+
+template <typename T>
+T bessel_i1(const T& x);
+
+template <class T, class tag>
+struct bessel_i1_initializer
+{
+   struct init
+   {
+      init()
+      {
+         do_init(tag());
+      }
+      static void do_init(const mpl::int_<64>&)
+      {
+         bessel_i1(T(1));
+         bessel_i1(T(15));
+         bessel_i1(T(80));
+         bessel_i1(T(101));
+      }
+      static void do_init(const mpl::int_<113>&)
+      {
+         bessel_i1(T(1));
+         bessel_i1(T(10));
+         bessel_i1(T(14));
+         bessel_i1(T(19));
+         bessel_i1(T(34));
+         bessel_i1(T(99));
+         bessel_i1(T(101));
+      }
+      template <class U>
+      static void do_init(const U&) {}
+      void force_instantiate()const{}
+   };
+   static const init initializer;
+   static void force_instantiate()
+   {
+      initializer.force_instantiate();
+   }
+};
+
+template <class T, class tag>
+const typename bessel_i1_initializer<T, tag>::init bessel_i1_initializer<T, tag>::initializer;
+
+template <typename T, int N>
+T bessel_i1_imp(const T&, const mpl::int_<N>&)
+{
+   BOOST_ASSERT(0);
+   return 0;
+}
+
+template <typename T>
+T bessel_i1_imp(const T& x, const mpl::int_<24>&)
+{
+   BOOST_MATH_STD_USING
+      if(x < 7.75)
+      {
+         //Max error in interpolated form : 1.348e-08
+         // Max Error found at float precision = Poly : 1.469121e-07
+         static const float P[] = {
+            8.333333221e-02f,
+            6.944453712e-03f,
+            3.472097211e-04f,
+            1.158047174e-05f,
+            2.739745142e-07f,
+            5.135884609e-09f,
+            5.262251502e-11f,
+            1.331933703e-12f
+         };
+         T a = x * x / 4;
+         T Q[3] = { 1, 0.5f, boost::math::tools::evaluate_polynomial(P, a) };
+         return x * boost::math::tools::evaluate_polynomial(Q, a) / 2;
+      }
+      else
+      {
+         // Max error in interpolated form: 9.000e-08
+         // Max Error found at float precision = Poly: 1.044345e-07
+
+         static const float P[] = {
+            3.98942115977513013e-01f,
+            -1.49581264836620262e-01f,
+            -4.76475741878486795e-02f,
+            -2.65157315524784407e-02f,
+            -1.47148600683672014e-01f
+         };
+         T ex = exp(x / 2);
+         T result = ex * boost::math::tools::evaluate_polynomial(P, T(1 / x)) / sqrt(x);
+         result *= ex;
+         return result;
+      }
+}
+
+template <typename T>
+T bessel_i1_imp(const T& x, const mpl::int_<53>&)
+{
+   BOOST_MATH_STD_USING
+   if(x < 7.75)
+   {
+      // Bessel I0 over[10 ^ -16, 7.75]
+      // Max error in interpolated form: 5.639e-17
+      // Max Error found at double precision = Poly: 1.795559e-16
+
+      static const double P[] = {
+         8.333333333333333803e-02,
+         6.944444444444341983e-03,
+         3.472222222225921045e-04,
+         1.157407407354987232e-05,
+         2.755731926254790268e-07,
+         4.920949692800671435e-09,
+         6.834657311305621830e-11,
+         7.593969849687574339e-13,
+         6.904822652741917551e-15,
+         5.220157095351373194e-17,
+         3.410720494727771276e-19,
+         1.625212890947171108e-21,
+         1.332898928162290861e-23
+      };
+      T a = x * x / 4;
+      T Q[3] = { 1, 0.5f, boost::math::tools::evaluate_polynomial(P, a) };
+      return x * boost::math::tools::evaluate_polynomial(Q, a) / 2;
+   }
+   else if(x < 500)
+   {
+      // Max error in interpolated form: 1.796e-16
+      // Max Error found at double precision = Poly: 2.898731e-16
+
+      static const double P[] = {
+         3.989422804014406054e-01,
+         -1.496033551613111533e-01,
+         -4.675104253598537322e-02,
+         -4.090895951581637791e-02,
+         -5.719036414430205390e-02,
+         -1.528189554374492735e-01,
+         3.458284470977172076e+00,
+         -2.426181371595021021e+02,
+         1.178785865993440669e+04,
+         -4.404655582443487334e+05,
+         1.277677779341446497e+07,
+         -2.903390398236656519e+08,
+         5.192386898222206474e+09,
+         -7.313784438967834057e+10,
+         8.087824484994859552e+11,
+         -6.967602516005787001e+12,
+         4.614040809616582764e+13,
+         -2.298849639457172489e+14,
+         8.325554073334618015e+14,
+         -2.067285045778906105e+15,
+         3.146401654361325073e+15,
+         -2.213318202179221945e+15
+      };
+      return exp(x) * boost::math::tools::evaluate_polynomial(P, T(1 / x)) / sqrt(x);
+   }
+   else
+   {
+      // Max error in interpolated form: 1.320e-19
+      // Max Error found at double precision = Poly: 7.065357e-17
+      static const double P[] = {
+         3.989422804014314820e-01,
+         -1.496033551467584157e-01,
+         -4.675105322571775911e-02,
+         -4.090421597376992892e-02,
+         -5.843630344778927582e-02
+      };
+      T ex = exp(x / 2);
+      T result = ex * boost::math::tools::evaluate_polynomial(P, T(1 / x)) / sqrt(x);
+      result *= ex;
+      return result;
+   }
+}
+
+template <typename T>
+T bessel_i1_imp(const T& x, const mpl::int_<64>&)
+{
+   BOOST_MATH_STD_USING
+      if(x < 7.75)
+      {
+         // Bessel I0 over[10 ^ -16, 7.75]
+         // Max error in interpolated form: 8.086e-21
+         // Max Error found at float80 precision = Poly: 7.225090e-20
+         static const T P[] = {
+            BOOST_MATH_BIG_CONSTANT(T, 64, 8.33333333333333333340071817e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 6.94444444444444442462728070e-03),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 3.47222222222222318886683883e-04),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.15740740740738880709555060e-05),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.75573192240046222242685145e-07),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 4.92094986131253986838697503e-09),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 6.83465258979924922633502182e-11),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 7.59405830675154933645967137e-13),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 6.90369179710633344508897178e-15),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 5.23003610041709452814262671e-17),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 3.35291901027762552549170038e-19),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.83991379419781823063672109e-21),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 8.87732714140192556332037815e-24),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 3.32120654663773147206454247e-26),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.95294659305369207813486871e-28) 
+         };
+         T a = x * x / 4;
+         T Q[3] = { 1, 0.5f, boost::math::tools::evaluate_polynomial(P, a) };
+         return x * boost::math::tools::evaluate_polynomial(Q, a) / 2;
+      }
+      else if(x < 20)
+      {
+         // Max error in interpolated form: 4.258e-20
+         // Max Error found at float80 precision = Poly: 2.851105e-19
+         // Maximum Deviation Found : 3.887e-20
+         // Expected Error Term : 3.887e-20
+         // Maximum Relative Change in Control Points : 1.681e-04
+         static const T P[] = {
+            BOOST_MATH_BIG_CONSTANT(T, 64, 3.98942260530218897338680e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -1.49599542849073670179540e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -4.70492865454119188276875e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -3.12389893307392002405869e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.49696126385202602071197e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -3.84206507612717711565967e+01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.14748094784412558689584e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -7.70652726663596993005669e+04),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.01659736164815617174439e+06),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -4.04740659606466305607544e+07),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 6.38383394696382837263656e+08),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -8.00779638649147623107378e+09),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 8.02338237858684714480491e+10),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -6.41198553664947312995879e+11),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 4.05915186909564986897554e+12),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -2.00907636964168581116181e+13),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 7.60855263982359981275199e+13),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -2.12901817219239205393806e+14),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 4.14861794397709807823575e+14),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -5.02808138522587680348583e+14),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.85505477056514919387171e+14)
+         };
+         return exp(x) * boost::math::tools::evaluate_polynomial(P, T(1 / x)) / sqrt(x);
+      }
+      else if(x < 100)
+      {
+         // Bessel I0 over [15, 50]
+         // Maximum Deviation Found:                     2.444e-20
+         // Expected Error Term : 2.438e-20
+         // Maximum Relative Change in Control Points : 2.101e-03
+         // Max Error found at float80 precision = Poly : 6.029974e-20
+
+         static const T P[] = {
+            BOOST_MATH_BIG_CONSTANT(T, 64, 3.98942280401431675205845e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -1.49603355149968887210170e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -4.67510486284376330257260e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -4.09071458907089270559464e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -5.75278280327696940044714e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -1.10591299500956620739254e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -2.77061766699949309115618e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -5.42683771801837596371638e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -9.17021412070404158464316e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.04154379346763380543310e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -1.43462345357478348323006e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 9.98109660274422449523837e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -3.74438822767781410362757e+04)
+         };
+         return exp(x) * boost::math::tools::evaluate_polynomial(P, T(1 / x)) / sqrt(x);
+      }
+      else
+      {
+         // Bessel I0 over[100, INF]
+         // Max error in interpolated form: 2.456e-20
+         // Max Error found at float80 precision = Poly: 5.446356e-20
+         static const T P[] = {
+            BOOST_MATH_BIG_CONSTANT(T, 64, 3.98942280401432677958445e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -1.49603355150537411254359e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -4.67510484842456251368526e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -4.09071676503922479645155e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -5.75256179814881566010606e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -1.10754910257965227825040e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -2.67858639515616079840294e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -9.17266479586791298924367e-01)
+         };
+         T ex = exp(x / 2);
+         T result = ex * boost::math::tools::evaluate_polynomial(P, T(1 / x)) / sqrt(x);
+         result *= ex;
+         return result;
+      }
+}
+
+template <typename T>
+T bessel_i1_imp(const T& x, const mpl::int_<113>&)
+{
+   BOOST_MATH_STD_USING
+   if(x < 7.75)
+   {
+      // Bessel I0 over[10 ^ -34, 7.75]
+      // Max error in interpolated form: 1.835e-35
+      // Max Error found at float128 precision = Poly: 1.645036e-34
+
+      static const T P[] = {
+         BOOST_MATH_BIG_CONSTANT(T, 113, 8.3333333333333333333333333333333331804098e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.9444444444444444444444444444445418303082e-03),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.4722222222222222222222222222119082346591e-04),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.1574074074074074074074074078415867655987e-05),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.7557319223985890652557318255143448192453e-07),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 4.9209498614260519022423916850415000626427e-09),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.8346525853139609753354247043900442393686e-11),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 7.5940584281266233060080535940234144302217e-13),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.9036894801151120925605467963949641957095e-15),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 5.2300677879659941472662086395055636394839e-17),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.3526075563884539394691458717439115962233e-19),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.8420920639497841692288943167036233338434e-21),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 8.7718669711748690065381181691546032291365e-24),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.6549445715236427401845636880769861424730e-26),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.3437296196812697924703896979250126739676e-28),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 4.3912734588619073883015937023564978854893e-31),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.2839967682792395867255384448052781306897e-33),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.3790094235693528861015312806394354114982e-36),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 8.0423861671932104308662362292359563970482e-39),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.7493858979396446292135661268130281652945e-41),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.2786079392547776769387921361408303035537e-44),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 8.2335693685833531118863552173880047183822e-47)
+      };
+      T a = x * x / 4;
+      T Q[3] = { 1, 0.5f, boost::math::tools::evaluate_polynomial(P, a) };
+      return x * boost::math::tools::evaluate_polynomial(Q, a) / 2;
+   }
+   else if(x < 11)
+   {
+      // Max error in interpolated form: 8.574e-36
+      // Maximum Deviation Found : 4.689e-36
+      // Expected Error Term : 3.760e-36
+      // Maximum Relative Change in Control Points : 5.204e-03
+      // Max Error found at float128 precision = Poly : 2.882561e-34
+
+      static const T P[] = {
+         BOOST_MATH_BIG_CONSTANT(T, 113, 8.333333333333333326889717360850080939e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.944444444444444511272790848815114507e-03),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.472222222222221892451965054394153443e-04),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.157407407407408437378868534321538798e-05),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.755731922398566216824909767320161880e-07),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 4.920949861426434829568192525456800388e-09),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.834652585308926245465686943255486934e-11),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 7.594058428179852047689599244015979196e-13),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.903689479655006062822949671528763738e-15),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 5.230067791254403974475987777406992984e-17),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.352607536815161679702105115200693346e-19),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.842092161364672561828681848278567885e-21),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 8.771862912600611801856514076709932773e-24),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.654958704184380914803366733193713605e-26),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.343688672071130980471207297730607625e-28),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 4.392252844664709532905868749753463950e-31),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.282086786672692641959912811902298600e-33),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.408812012322547015191398229942864809e-36),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 7.681220437734066258673404589233009892e-39),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.072417451640733785626701738789290055e-41),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.352218520142636864158849446833681038e-44),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.407918492276267527897751358794783640e-46)
+      };
+      T a = x * x / 4;
+      T Q[3] = { 1, 0.5f, boost::math::tools::evaluate_polynomial(P, a) };
+      return x * boost::math::tools::evaluate_polynomial(Q, a) / 2;
+   }
+   else if(x < 15)
+   {
+      //Max error in interpolated form: 7.599e-36
+      // Maximum Deviation Found : 1.766e-35
+      // Expected Error Term : 1.021e-35
+      // Maximum Relative Change in Control Points : 6.228e-03
+      static const T P[] = {
+         BOOST_MATH_BIG_CONSTANT(T, 113, 8.333333333333255774414858563409941233e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.944444444444897867884955912228700291e-03),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.472222222220954970397343617150959467e-04),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.157407407409660682751155024932538578e-05),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.755731922369973706427272809014190998e-07),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 4.920949861702265600960449699129258153e-09),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.834652583208361401197752793379677147e-11),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 7.594058441128280500819776168239988143e-13),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.903689413939268702265479276217647209e-15),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 5.230068069012898202890718644753625569e-17),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.352606552027491657204243201021677257e-19),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.842095100698532984651921750204843362e-21),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 8.771789051329870174925649852681844169e-24),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.655114381199979536997025497438385062e-26),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.343415732516712339472538688374589373e-28),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 4.396177019032432392793591204647901390e-31),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.277563309255167951005939802771456315e-33),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.449201419305514579791370198046544736e-36),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 7.415430703400740634202379012388035255e-39),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.195458831864936225409005027914934499e-41),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 8.829726762743879793396637797534668039e-45),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.698302711685624490806751012380215488e-46),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.062520475425422618494185821587228317e-49),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.732372906742845717148185173723304360e-52)
+      };
+      T a = x * x / 4;
+      T Q[3] = { 1, 0.5f, boost::math::tools::evaluate_polynomial(P, a) };
+      return x * boost::math::tools::evaluate_polynomial(Q, a) / 2;
+   }
+   else if(x < 20)
+   {
+      // Max error in interpolated form: 8.864e-36
+      // Max Error found at float128 precision = Poly: 8.522841e-35
+      static const T P[] = {
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.989422793693152031514179994954750043e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -1.496029423752889591425633234009799670e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -4.682975926820553021482820043377990241e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -3.138871171577224532369979905856458929e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -8.765350219426341341990447005798111212e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 5.321389275507714530941178258122955540e+01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.727748393898888756515271847678850411e+03),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.123040820686242586086564998713862335e+05),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -3.784112378374753535335272752884808068e+06),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.054920416060932189433079126269416563e+08),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.450129415468060676827180524327749553e+09),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 4.758831882046487398739784498047935515e+10),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -7.736936520262204842199620784338052937e+11),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.051128683324042629513978256179115439e+13),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -1.188008285959794869092624343537262342e+14),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.108530004906954627420484180793165669e+15),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -8.441516828490144766650287123765318484e+15),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 5.158251664797753450664499268756393535e+16),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.467314522709016832128790443932896401e+17),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 8.896222045367960462945885220710294075e+17),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.273382139594876997203657902425653079e+18),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.669871448568623680543943144842394531e+18),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.813923031370708069940575240509912588e+18)
+      };
+      return exp(x) * boost::math::tools::evaluate_polynomial(P, T(1 / x)) / sqrt(x);
+   }
+   else if(x < 35)
+   {
+      // Max error in interpolated form: 6.028e-35
+      // Max Error found at float128 precision = Poly: 1.368313e-34
+
+      static const T P[] = {
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.989422804012941975429616956496046931e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -1.496033550576049830976679315420681402e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -4.675107835141866009896710750800622147e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -4.090104965125365961928716504473692957e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -5.842241652296980863361375208605487570e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -1.063604828033747303936724279018650633e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -9.113375972811586130949401996332817152e+00),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 6.334748570425075872639817839399823709e+02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -3.759150758768733692594821032784124765e+04),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.863672813448915255286274382558526321e+06),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -7.798248643371718775489178767529282534e+07),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.769963173932801026451013022000669267e+09),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -8.381780137198278741566746511015220011e+10),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.163891337116820832871382141011952931e+12),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -4.764325864671438675151635117936912390e+13),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 8.925668307403332887856809510525154955e+14),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -1.416692606589060039334938090985713641e+16),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.892398600219306424294729851605944429e+17),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.107232903741874160308537145391245060e+18),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.930223393531877588898224144054112045e+19),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -1.427759576167665663373350433236061007e+20),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 8.306019279465532835530812122374386654e+20),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -3.653753000392125229440044977239174472e+21),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.140760686989511568435076842569804906e+22),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.249149337812510200795436107962504749e+22),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.101619088427348382058085685849420866e+22)
+      };
+      return exp(x) * boost::math::tools::evaluate_polynomial(P, T(1 / x)) / sqrt(x);
+   }
+   else if(x < 100)
+   {
+      // Max error in interpolated form: 5.494e-35
+      // Max Error found at float128 precision = Poly: 1.214651e-34
+
+      static const T P[] = {
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.989422804014326779399307367861631577e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -1.496033551505372542086590873271571919e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -4.675104848454290286276466276677172664e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -4.090716742397105403027549796269213215e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -5.752570419098513588311026680089351230e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -1.107369803696534592906420980901195808e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.699214194000085622941721628134575121e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -7.953006169077813678478720427604462133e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.746618809476524091493444128605380593e+00),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -1.084446249943196826652788161656973391e+01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -5.020325182518980633783194648285500554e+01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -1.510195971266257573425196228564489134e+02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -5.241661863814900938075696173192225056e+03),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.323374362891993686413568398575539777e+05),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -4.112838452096066633754042734723911040e+06),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 9.369270194978310081563767560113534023e+07),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -1.704295412488936504389347368131134993e+09),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 2.320829576277038198439987439508754886e+10),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.258818139077875493434420764260185306e+11),
+         BOOST_MATH_BIG_CONSTANT(T, 113, 1.396791306321498426110315039064592443e+12),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -4.217617301585849875301440316301068439e+12)
+      };
+      return exp(x) * boost::math::tools::evaluate_polynomial(P, T(1 / x)) / sqrt(x);
+   }
+   else
+   {
+      // Bessel I0 over[100, INF]
+      // Max error in interpolated form: 6.081e-35
+      // Max Error found at float128 precision = Poly: 1.407151e-34
+      static const T P[] = {
+         BOOST_MATH_BIG_CONSTANT(T, 113, 3.9894228040143267793994605993438200208417e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -1.4960335515053725422747977247811372936584e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -4.6751048484542891946087411826356811991039e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -4.0907167423975030452875828826630006305665e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -5.7525704189964886494791082898669060345483e-02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -1.1073698056568248642163476807108190176386e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.6992139012879749064623499618582631684228e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -7.9530409594026597988098934027440110587905e-01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.7462844478733532517044536719240098183686e+00),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -1.0870711340681926669381449306654104739256e+01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -4.8510175413216969245241059608553222505228e+01),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -2.4094682286011573747064907919522894740063e+02),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -1.3128845936764406865199641778959502795443e+03),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -8.1655901321962541203257516341266838487359e+03),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -3.8019591025686295090160445920753823994556e+04),
+         BOOST_MATH_BIG_CONSTANT(T, 113, -6.7008089049178178697338128837158732831105e+05)
+      };
+      T ex = exp(x / 2);
+      T result = ex * boost::math::tools::evaluate_polynomial(P, T(1 / x)) / sqrt(x);
+      result *= ex;
+      return result;
+   }
+}
+
+template <typename T>
+T bessel_i1_imp(const T& x, const mpl::int_<0>&)
+{
+   if(boost::math::tools::digits<T>() <= 24)
+      return bessel_i1_imp(x, mpl::int_<24>());
+   else if(boost::math::tools::digits<T>() <= 53)
+      return bessel_i1_imp(x, mpl::int_<53>());
+   else if(boost::math::tools::digits<T>() <= 64)
+      return bessel_i1_imp(x, mpl::int_<64>());
+   else if(boost::math::tools::digits<T>() <= 113)
+      return bessel_i1_imp(x, mpl::int_<113>());
+   BOOST_ASSERT(0);
+   return 0;
+}
+
+template <typename T>
+inline T bessel_i1(const T& x)
+{
+   typedef mpl::int_<
+      ((std::numeric_limits<T>::digits == 0) || (std::numeric_limits<T>::radix != 2)) ?
+      0 :
+      std::numeric_limits<T>::digits <= 24 ?
+      24 :
+      std::numeric_limits<T>::digits <= 53 ?
+      53 :
+      std::numeric_limits<T>::digits <= 64 ?
+      64 :
+      std::numeric_limits<T>::digits <= 113 ?
+      113 : -1
+   > tag_type;
+
+   bessel_i1_initializer<T, tag_type>::force_instantiate();
+   return bessel_i1_imp(x, tag_type());
+}
+
+}}} // namespaces
+
+#endif // BOOST_MATH_BESSEL_I1_HPP
+
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_ik.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_ik.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_ik.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_ik.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_j0.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_j0.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_j0.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_j0.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_j1.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_j1.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_j1.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_j1.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_jn.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_jn.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_jn.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_jn.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_jy.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_jy.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_jy.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_jy.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_jy_asym.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_jy_asym.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_jy_asym.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_jy_asym.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_jy_derivatives_asym.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_jy_derivatives_asym.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_jy_derivatives_asym.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_jy_derivatives_asym.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_jy_derivatives_series.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_jy_derivatives_series.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_jy_derivatives_series.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_jy_derivatives_series.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_jy_series.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_jy_series.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_jy_series.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_jy_series.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_jy_zero.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_jy_zero.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_jy_zero.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_jy_zero.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_k0.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_k0.hpp
new file mode 100644
index 00000000000..74f4014bd9b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_k0.hpp
@@ -0,0 +1,509 @@
+//  Copyright (c) 2006 Xiaogang Zhang
+//  Copyright (c) 2017 John Maddock
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_MATH_BESSEL_K0_HPP
+#define BOOST_MATH_BESSEL_K0_HPP
+
+#ifdef _MSC_VER
+#pragma once
+#pragma warning(push)
+#pragma warning(disable:4702) // Unreachable code (release mode only warning)
+#endif
+
+#include <boost/math/tools/rational.hpp>
+#include <boost/math/tools/big_constant.hpp>
+#include <boost/math/policies/error_handling.hpp>
+#include <boost/assert.hpp>
+
+// Modified Bessel function of the second kind of order zero
+// minimax rational approximations on intervals, see
+// Russon and Blair, Chalk River Report AECL-3461, 1969,
+// as revised by Pavel Holoborodko in "Rational Approximations 
+// for the Modified Bessel Function of the Second Kind - K0(x) 
+// for Computations with Double Precision", see 
+// http://www.advanpix.com/2015/11/25/rational-approximations-for-the-modified-bessel-function-of-the-second-kind-k0-for-computations-with-double-precision/
+//
+// The actual coefficients used are our own derivation (by JM)
+// since we extend to both greater and lesser precision than the
+// references above.  We can also improve performance WRT to
+// Holoborodko without loss of precision.
+
+namespace boost { namespace math { namespace detail{
+
+template <typename T>
+T bessel_k0(const T& x);
+
+template <class T, class tag>
+struct bessel_k0_initializer
+{
+   struct init
+   {
+      init()
+      {
+         do_init(tag());
+      }
+      static void do_init(const mpl::int_<113>&)
+      {
+         bessel_k0(T(0.5));
+         bessel_k0(T(1.5));
+      }
+      static void do_init(const mpl::int_<64>&)
+      {
+         bessel_k0(T(0.5));
+         bessel_k0(T(1.5));
+      }
+      template <class U>
+      static void do_init(const U&){}
+      void force_instantiate()const{}
+   };
+   static const init initializer;
+   static void force_instantiate()
+   {
+      initializer.force_instantiate();
+   }
+};
+
+template <class T, class tag>
+const typename bessel_k0_initializer<T, tag>::init bessel_k0_initializer<T, tag>::initializer;
+
+
+template <typename T, int N>
+T bessel_k0_imp(const T& x, const mpl::int_<N>&)
+{
+   BOOST_ASSERT(0);
+   return 0;
+}
+
+template <typename T>
+T bessel_k0_imp(const T& x, const mpl::int_<24>&)
+{
+   BOOST_MATH_STD_USING
+   if(x <= 1)
+   {
+      // Maximum Deviation Found : 2.358e-09
+      // Expected Error Term : -2.358e-09
+      // Maximum Relative Change in Control Points : 9.552e-02
+      // Max Error found at float precision = Poly : 4.448220e-08
+      static const T Y = 1.137250900268554688f;
+      static const T P[] = 
+      {
+         -1.372508979104259711e-01f,
+         2.622545986273687617e-01f,
+         5.047103728247919836e-03f
+      };
+      static const T Q[] = 
+      {
+         1.000000000000000000e+00f,
+         -8.928694018000029415e-02f,
+         2.985980684180969241e-03f
+      };
+      T a = x * x / 4;
+      a = (tools::evaluate_rational(P, Q, a) + Y) * a + 1;
+
+      // Maximum Deviation Found:                     1.346e-09
+      // Expected Error Term : -1.343e-09
+      // Maximum Relative Change in Control Points : 2.405e-02
+      // Max Error found at float precision = Poly : 1.354814e-07
+      static const T P2[] = {
+         1.159315158e-01f,
+         2.789828686e-01f,
+         2.524902861e-02f,
+         8.457241514e-04f,
+         1.530051997e-05f
+      };
+      return tools::evaluate_polynomial(P2, T(x * x)) - log(x) * a;
+   }
+   else
+   {
+      // Maximum Deviation Found:                     1.587e-08
+      // Expected Error Term : 1.531e-08
+      // Maximum Relative Change in Control Points : 9.064e-02
+      // Max Error found at float precision = Poly : 5.065020e-08
+
+      static const T P[] =
+      {
+         2.533141220e-01,
+         5.221502603e-01,
+         6.380180669e-02,
+         -5.934976547e-02
+      };
+      static const T Q[] =
+      {
+         1.000000000e+00,
+         2.679722431e+00,
+         1.561635813e+00,
+         1.573660661e-01
+      };
+      if(x < tools::log_max_value<T>())
+         return ((tools::evaluate_rational(P, Q, T(1 / x)) + 1) * exp(-x) / sqrt(x));
+      else
+      {
+         T ex = exp(-x / 2);
+         return ((tools::evaluate_rational(P, Q, T(1 / x)) + 1) * ex / sqrt(x)) * ex;
+      }
+   }
+}
+
+template <typename T>
+T bessel_k0_imp(const T& x, const mpl::int_<53>&)
+{
+   BOOST_MATH_STD_USING
+   if(x <= 1)
+   {
+      // Maximum Deviation Found:                     6.077e-17
+      // Expected Error Term : -6.077e-17
+      // Maximum Relative Change in Control Points : 7.797e-02
+      // Max Error found at double precision = Poly : 1.003156e-16
+      static const T Y = 1.137250900268554688;
+      static const T P[] =
+      {
+         -1.372509002685546267e-01,
+         2.574916117833312855e-01,
+         1.395474602146869316e-02,
+         5.445476986653926759e-04,
+         7.125159422136622118e-06
+      };
+      static const T Q[] =
+      {
+         1.000000000000000000e+00,
+         -5.458333438017788530e-02,
+         1.291052816975251298e-03,
+         -1.367653946978586591e-05
+      };
+
+      T a = x * x / 4;
+      a = (tools::evaluate_polynomial(P, a) / tools::evaluate_polynomial(Q, a) + Y) * a + 1;
+
+      // Maximum Deviation Found:                     3.429e-18
+      // Expected Error Term : 3.392e-18
+      // Maximum Relative Change in Control Points : 2.041e-02
+      // Max Error found at double precision = Poly : 2.513112e-16
+      static const T P2[] =
+      {
+         1.159315156584124484e-01,
+         2.789828789146031732e-01,
+         2.524892993216121934e-02,
+         8.460350907213637784e-04,
+         1.491471924309617534e-05,
+         1.627106892422088488e-07,
+         1.208266102392756055e-09,
+         6.611686391749704310e-12
+      };
+
+      return tools::evaluate_polynomial(P2, T(x * x)) - log(x) * a;
+   }
+   else
+   {
+      // Maximum Deviation Found:                     4.316e-17
+      // Expected Error Term : 9.570e-18
+      // Maximum Relative Change in Control Points : 2.757e-01
+      // Max Error found at double precision = Poly : 1.001560e-16
+
+      static const T Y = 1;
+      static const T P[] =
+      {
+         2.533141373155002416e-01,
+         3.628342133984595192e+00,
+         1.868441889406606057e+01,
+         4.306243981063412784e+01,
+         4.424116209627428189e+01,
+         1.562095339356220468e+01,
+         -1.810138978229410898e+00,
+         -1.414237994269995877e+00,
+         -9.369168119754924625e-02
+      };
+      static const T Q[] =
+      {
+         1.000000000000000000e+00,
+         1.494194694879908328e+01,
+         8.265296455388554217e+01,
+         2.162779506621866970e+02,
+         2.845145155184222157e+02,
+         1.851714491916334995e+02,
+         5.486540717439723515e+01,
+         6.118075837628957015e+00,
+         1.586261269326235053e-01
+      };
+      if(x < tools::log_max_value<T>())
+         return ((tools::evaluate_rational(P, Q, T(1 / x)) + Y) * exp(-x) / sqrt(x));
+      else
+      {
+         T ex = exp(-x / 2);
+         return ((tools::evaluate_rational(P, Q, T(1 / x)) + Y) * ex / sqrt(x)) * ex;
+      }
+   }
+}
+
+template <typename T>
+T bessel_k0_imp(const T& x, const mpl::int_<64>&)
+{
+   BOOST_MATH_STD_USING
+      if(x <= 1)
+      {
+         // Maximum Deviation Found:                     2.180e-22
+         // Expected Error Term : 2.180e-22
+         // Maximum Relative Change in Control Points : 2.943e-01
+         // Max Error found at float80 precision = Poly : 3.923207e-20
+         static const T Y = 1.137250900268554687500e+00;
+         static const T P[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 64, -1.372509002685546875002e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.566481981037407600436e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.551881122448948854873e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 6.646112454323276529650e-04),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.213747930378196492543e-05),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 9.423709328020389560844e-08)
+         };
+         static const T Q[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.000000000000000000000e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -4.843828412587773008342e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.088484822515098936140e-03),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -1.374724008530702784829e-05),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 8.452665455952581680339e-08)
+         };
+
+
+         T a = x * x / 4;
+         a = (tools::evaluate_polynomial(P, a) / tools::evaluate_polynomial(Q, a) + Y) * a + 1;
+
+         // Maximum Deviation Found:                     2.440e-21
+         // Expected Error Term : -2.434e-21
+         // Maximum Relative Change in Control Points : 2.459e-02
+         // Max Error found at float80 precision = Poly : 1.482487e-19
+         static const T P2[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.159315156584124488110e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.764832791416047889734e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.926062887220923354112e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 3.660777862036966089410e-04),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.094942446930673386849e-06)
+         };
+         static const T Q2[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.000000000000000000000e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -2.156100313881251616320e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.315993873344905957033e-04),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -1.529444499350703363451e-06),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 5.524988589917857531177e-09)
+         };
+         return tools::evaluate_rational(P2, Q2, T(x * x)) - log(x) * a;
+      }
+      else
+      {
+         // Maximum Deviation Found:                     4.291e-20
+         // Expected Error Term : 2.236e-21
+         // Maximum Relative Change in Control Points : 3.021e-01
+         //Max Error found at float80 precision = Poly : 8.727378e-20
+         static const T Y = 1;
+         static const T P[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.533141373155002512056e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 5.417942070721928652715e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 4.477464607463971754433e+01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.838745728725943889876e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 4.009736314927811202517e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 4.557411293123609803452e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.360222564015361268955e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.385435333168505701022e+01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -1.750195760942181592050e+01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -4.059789241612946683713e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -1.612783121537333908889e-01)
+         };
+         static const T Q[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.000000000000000000000e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.200669254769325861404e+01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.900177593527144126549e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 8.361003989965786932682e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.041319870804843395893e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.828491555113790345068e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.190342229261529076624e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 9.003330795963812219852e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.773371397243777891569e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.368634935531158398439e+01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.543310879400359967327e-01)
+         };
+         if(x < tools::log_max_value<T>())
+            return ((tools::evaluate_rational(P, Q, T(1 / x)) + Y) * exp(-x) / sqrt(x));
+         else
+         {
+            T ex = exp(-x / 2);
+            return ((tools::evaluate_rational(P, Q, T(1 / x)) + Y) * ex / sqrt(x)) * ex;
+         }
+      }
+}
+
+template <typename T>
+T bessel_k0_imp(const T& x, const mpl::int_<113>&)
+{
+   BOOST_MATH_STD_USING
+      if(x <= 1)
+      {
+         // Maximum Deviation Found:                     5.682e-37
+         // Expected Error Term : 5.682e-37
+         // Maximum Relative Change in Control Points : 6.094e-04
+         // Max Error found at float128 precision = Poly : 5.338213e-35
+         static const T Y = 1.137250900268554687500000000000000000e+00f;
+         static const T P[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 113, -1.372509002685546875000000000000000006e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.556212905071072782462974351698081303e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.742459135264203478530904179889103929e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 8.077860530453688571555479526961318918e-04),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.868173911669241091399374307788635148e-05),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.496405768838992243478709145123306602e-07),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.752489221949580551692915881999762125e-09),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 5.243010555737173524710512824955368526e-12)
+         };
+         static const T Q[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.000000000000000000000000000000000000e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -4.095631064064621099785696980653193721e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 8.313880983725212151967078809725835532e-04),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -1.095229912293480063501285562382835142e-05),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.022828799511943141130509410251996277e-07),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -6.860874007419812445494782795829046836e-10),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 3.107297802344970725756092082686799037e-12),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -7.460529579244623559164763757787600944e-15)
+         };
+         T a = x * x / 4;
+         a = (tools::evaluate_rational(P, Q, a) + Y) * a + 1;
+
+         // Maximum Deviation Found:                     5.173e-38
+         // Expected Error Term : 5.105e-38
+         // Maximum Relative Change in Control Points : 9.734e-03
+         // Max Error found at float128 precision = Poly : 1.688806e-34
+         static const T P2[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.159315156584124488107200313757741370e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.789828789146031122026800078439435369e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.524892993216269451266750049024628432e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 8.460350907082229957222453839935101823e-04),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.491471929926042875260452849503857976e-05),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.627105610481598430816014719558896866e-07),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.208426165007797264194914898538250281e-09),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 6.508697838747354949164182457073784117e-12),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.659784680639805301101014383907273109e-14),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 8.531090131964391104248859415958109654e-17),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.205195117066478034260323124669936314e-19),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 4.692219280289030165761119775783115426e-22),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 8.362350161092532344171965861545860747e-25),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.277990623924628999539014980773738258e-27)
+         };
+
+         return tools::evaluate_polynomial(P2, T(x * x)) - log(x) * a;
+      }
+      else
+      {
+         // Maximum Deviation Found:                     1.462e-34
+         // Expected Error Term : 4.917e-40
+         // Maximum Relative Change in Control Points : 3.385e-01
+         // Max Error found at float128 precision = Poly : 1.567573e-34
+         static const T Y = 1;
+         static const T P[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.533141373155002512078826424055226265e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.001949740768235770078339977110749204e+01),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 6.991516715983883248363351472378349986e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.429587951594593159075690819360687720e+04),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.911933815201948768044660065771258450e+05),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.769943016204926614862175317962439875e+06),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.170866154649560750500954150401105606e+07),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 5.634687099724383996792011977705727661e+07),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.989524036456492581597607246664394014e+08),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 5.160394785715328062088529400178080360e+08),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 9.778173054417826368076483100902201433e+08),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.335667778588806892764139643950439733e+09),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.283635100080306980206494425043706838e+09),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 8.300616188213640626577036321085025855e+08),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 3.277591957076162984986406540894621482e+08),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 5.564360536834214058158565361486115932e+07),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -1.043505161612403359098596828115690596e+07),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -7.217035248223503605127967970903027314e+06),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -1.422938158797326748375799596769964430e+06),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -1.229125746200586805278634786674745210e+05),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -4.201632288615609937883545928660649813e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -3.690820607338480548346746717311811406e+01)
+         };
+         static const T Q[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.000000000000000000000000000000000000e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 7.964877874035741452203497983642653107e+01),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.808929943826193766839360018583294769e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 5.814524004679994110944366890912384139e+04),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 7.897794522506725610540209610337355118e+05),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 7.456339470955813675629523617440433672e+06),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 5.057818717813969772198911392875127212e+07),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.513821619536852436424913886081133209e+08),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 9.255938846873380596038513316919990776e+08),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.537077551699028079347581816919572141e+09),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 5.176769339768120752974843214652367321e+09),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 7.828722317390455845253191337207432060e+09),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 8.698864296569996402006511705803675890e+09),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 7.007803261356636409943826918468544629e+09),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 4.016564631288740308993071395104715469e+09),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.595893010619754750655947035567624730e+09),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 4.241241839120481076862742189989406856e+08),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 7.168778094393076220871007550235840858e+07),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 7.156200301360388147635052029404211109e+06),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 3.752130382550379886741949463587008794e+05),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 8.370574966987293592457152146806662562e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 4.871254714311063594080644835895740323e+01)
+         };
+         if(x < tools::log_max_value<T>())
+            return  ((tools::evaluate_rational(P, Q, T(1 / x)) + Y) * exp(-x) / sqrt(x));
+         else
+         {
+            T ex = exp(-x / 2);
+            return ((tools::evaluate_rational(P, Q, T(1 / x)) + Y) * ex / sqrt(x)) * ex;
+         }
+      }
+}
+
+template <typename T>
+T bessel_k0_imp(const T& x, const mpl::int_<0>&)
+{
+   if(boost::math::tools::digits<T>() <= 24)
+      return bessel_k0_imp(x, mpl::int_<24>());
+   else if(boost::math::tools::digits<T>() <= 53)
+      return bessel_k0_imp(x, mpl::int_<53>());
+   else if(boost::math::tools::digits<T>() <= 64)
+      return bessel_k0_imp(x, mpl::int_<64>());
+   else if(boost::math::tools::digits<T>() <= 113)
+      return bessel_k0_imp(x, mpl::int_<113>());
+   BOOST_ASSERT(0);
+   return 0;
+}
+
+template <typename T>
+inline T bessel_k0(const T& x)
+{
+   typedef mpl::int_<
+      ((std::numeric_limits<T>::digits == 0) || (std::numeric_limits<T>::radix != 2)) ?
+      0 :
+      std::numeric_limits<T>::digits <= 24 ?
+      24 :
+      std::numeric_limits<T>::digits <= 53 ?
+      53 :
+      std::numeric_limits<T>::digits <= 64 ?
+      64 :
+      std::numeric_limits<T>::digits <= 113 ?
+      113 : -1
+   > tag_type;
+
+   bessel_k0_initializer<T, tag_type>::force_instantiate();
+   return bessel_k0_imp(x, tag_type());
+}
+
+}}} // namespaces
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_MATH_BESSEL_K0_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_k1.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_k1.hpp
new file mode 100644
index 00000000000..2ab191fb498
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_k1.hpp
@@ -0,0 +1,551 @@
+//  Copyright (c) 2006 Xiaogang Zhang
+//  Copyright (c) 2017 John Maddock 
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_MATH_BESSEL_K1_HPP
+#define BOOST_MATH_BESSEL_K1_HPP
+
+#ifdef _MSC_VER
+#pragma once
+#pragma warning(push)
+#pragma warning(disable:4702) // Unreachable code (release mode only warning)
+#endif
+
+#include <boost/math/tools/rational.hpp>
+#include <boost/math/tools/big_constant.hpp>
+#include <boost/math/policies/error_handling.hpp>
+#include <boost/assert.hpp>
+
+// Modified Bessel function of the second kind of order zero
+// minimax rational approximations on intervals, see
+// Russon and Blair, Chalk River Report AECL-3461, 1969,
+// as revised by Pavel Holoborodko in "Rational Approximations 
+// for the Modified Bessel Function of the Second Kind - K0(x) 
+// for Computations with Double Precision", see 
+// http://www.advanpix.com/2016/01/05/rational-approximations-for-the-modified-bessel-function-of-the-second-kind-k1-for-computations-with-double-precision/
+//
+// The actual coefficients used are our own derivation (by JM)
+// since we extend to both greater and lesser precision than the
+// references above.  We can also improve performance WRT to
+// Holoborodko without loss of precision.
+
+namespace boost { namespace math { namespace detail{
+
+   template <typename T>
+   T bessel_k1(const T& x);
+
+   template <class T, class tag>
+   struct bessel_k1_initializer
+   {
+      struct init
+      {
+         init()
+         {
+            do_init(tag());
+         }
+         static void do_init(const mpl::int_<113>&)
+         {
+            bessel_k1(T(0.5));
+            bessel_k1(T(2));
+            bessel_k1(T(6));
+         }
+         static void do_init(const mpl::int_<64>&)
+         {
+            bessel_k1(T(0.5));
+            bessel_k1(T(6));
+         }
+         template <class U>
+         static void do_init(const U&) {}
+         void force_instantiate()const {}
+      };
+      static const init initializer;
+      static void force_instantiate()
+      {
+         initializer.force_instantiate();
+      }
+   };
+
+   template <class T, class tag>
+   const typename bessel_k1_initializer<T, tag>::init bessel_k1_initializer<T, tag>::initializer;
+
+
+   template <typename T, int N>
+   inline T bessel_k1_imp(const T& x, const mpl::int_<N>&)
+   {
+      BOOST_ASSERT(0);
+      return 0;
+   }
+
+   template <typename T>
+   T bessel_k1_imp(const T& x, const mpl::int_<24>&)
+   {
+      BOOST_MATH_STD_USING
+      if(x <= 1)
+      {
+         // Maximum Deviation Found:                     3.090e-12
+         // Expected Error Term : -3.053e-12
+         // Maximum Relative Change in Control Points : 4.927e-02
+         // Max Error found at float precision = Poly : 7.918347e-10
+         static const T Y = 8.695471287e-02f;
+         static const T P[] =
+         {
+            -3.621379531e-03f,
+            7.131781976e-03f,
+            -1.535278300e-05f
+         };
+         static const T Q[] =
+         {
+            1.000000000e+00f,
+            -5.173102701e-02f,
+            9.203530671e-04f
+         };
+
+         T a = x * x / 4;
+         a = ((tools::evaluate_rational(P, Q, a) + Y) * a * a + a / 2 + 1) * x / 2;
+
+         // Maximum Deviation Found:                     3.556e-08
+         // Expected Error Term : -3.541e-08
+         // Maximum Relative Change in Control Points : 8.203e-02
+         static const T P2[] =
+         {
+            -3.079657469e-01f,
+            -8.537108913e-02f,
+            -4.640275408e-03f,
+            -1.156442414e-04f
+         };
+
+         return tools::evaluate_polynomial(P2, T(x * x)) * x + 1 / x + log(x) * a;
+      }
+      else
+      {
+         // Maximum Deviation Found:                     3.369e-08
+         // Expected Error Term : -3.227e-08
+         // Maximum Relative Change in Control Points : 9.917e-02
+         // Max Error found at float precision = Poly : 6.084411e-08
+         static const T Y = 1.450342178f;
+         static const T P[] =
+         {
+            -1.970280088e-01f,
+            2.188747807e-02f,
+            7.270394756e-01f,
+            2.490678196e-01f
+         };
+         static const T Q[] =
+         {
+            1.000000000e+00f,
+            2.274292882e+00f,
+            9.904984851e-01f,
+            4.585534549e-02f
+         };
+         if(x < tools::log_max_value<T>())
+            return ((tools::evaluate_rational(P, Q, T(1 / x)) + Y) * exp(-x) / sqrt(x));
+         else
+         {
+            T ex = exp(-x / 2);
+            return ((tools::evaluate_rational(P, Q, T(1 / x)) + Y) * ex / sqrt(x)) * ex;
+         }
+      }
+   }
+
+   template <typename T>
+   T bessel_k1_imp(const T& x, const mpl::int_<53>&)
+   {
+      BOOST_MATH_STD_USING
+      if(x <= 1)
+      {
+         // Maximum Deviation Found:                     1.922e-17
+         // Expected Error Term : 1.921e-17
+         // Maximum Relative Change in Control Points : 5.287e-03
+         // Max Error found at double precision = Poly : 2.004747e-17
+         static const T Y = 8.69547128677368164e-02f;
+         static const T P[] =
+         {
+            -3.62137953440350228e-03,
+            7.11842087490330300e-03,
+            1.00302560256614306e-05,
+            1.77231085381040811e-06
+         };
+         static const T Q[] =
+         {
+            1.00000000000000000e+00,
+            -4.80414794429043831e-02,
+            9.85972641934416525e-04,
+            -8.91196859397070326e-06
+         };
+
+         T a = x * x / 4;
+         a = ((tools::evaluate_rational(P, Q, a) + Y) * a * a + a / 2 + 1) * x / 2;
+
+         // Maximum Deviation Found:                     4.053e-17
+         // Expected Error Term : -4.053e-17
+         // Maximum Relative Change in Control Points : 3.103e-04
+         // Max Error found at double precision = Poly : 1.246698e-16
+
+         static const T P2[] =
+         {
+            -3.07965757829206184e-01,
+            -7.80929703673074907e-02,
+            -2.70619343754051620e-03,
+            -2.49549522229072008e-05
+         };
+         static const T Q2[] = 
+         {
+            1.00000000000000000e+00,
+            -2.36316836412163098e-02,
+            2.64524577525962719e-04,
+            -1.49749618004162787e-06
+         };
+
+         return tools::evaluate_rational(P2, Q2, T(x * x)) * x + 1 / x + log(x) * a;
+      }
+      else
+      {
+         // Maximum Deviation Found:                     8.883e-17
+         // Expected Error Term : -1.641e-17
+         // Maximum Relative Change in Control Points : 2.786e-01
+         // Max Error found at double precision = Poly : 1.258798e-16
+
+         static const T Y = 1.45034217834472656f;
+         static const T P[] =
+         {
+            -1.97028041029226295e-01,
+            -2.32408961548087617e+00,
+            -7.98269784507699938e+00,
+            -2.39968410774221632e+00,
+            3.28314043780858713e+01,
+            5.67713761158496058e+01,
+            3.30907788466509823e+01,
+            6.62582288933739787e+00,
+            3.08851840645286691e-01
+         };
+         static const T Q[] =
+         {
+            1.00000000000000000e+00,
+            1.41811409298826118e+01,
+            7.35979466317556420e+01,
+            1.77821793937080859e+02,
+            2.11014501598705982e+02,
+            1.19425262951064454e+02,
+            2.88448064302447607e+01,
+            2.27912927104139732e+00,
+            2.50358186953478678e-02
+         };
+         if(x < tools::log_max_value<T>())
+            return ((tools::evaluate_rational(P, Q, T(1 / x)) + Y) * exp(-x) / sqrt(x));
+         else
+         {
+            T ex = exp(-x / 2);
+            return ((tools::evaluate_rational(P, Q, T(1 / x)) + Y) * ex / sqrt(x)) * ex;
+         }
+      }
+   }
+
+   template <typename T>
+   T bessel_k1_imp(const T& x, const mpl::int_<64>&)
+   {
+      BOOST_MATH_STD_USING
+      if(x <= 1)
+      {
+         // Maximum Deviation Found:                     5.549e-23
+         // Expected Error Term : -5.548e-23
+         // Maximum Relative Change in Control Points : 2.002e-03
+         // Max Error found at float80 precision = Poly : 9.352785e-22
+         static const T Y = 8.695471286773681640625e-02f;
+         static const T P[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 64, -3.621379534403483072861e-03),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 7.102135866103952705932e-03),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 4.167545240236717601167e-05),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.537484002571894870830e-06),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 6.603228256820000135990e-09)
+         };
+         static const T Q[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.000000000000000000000e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -4.354457194045068370363e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 8.709137201220209072820e-04),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -9.676151796359590545143e-06),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 5.162715192766245311659e-08)
+         };
+
+         T a = x * x / 4;
+         a = ((tools::evaluate_rational(P, Q, a) + Y) * a * a + a / 2 + 1) * x / 2;
+
+         // Maximum Deviation Found:                     1.995e-23
+         // Expected Error Term : 1.995e-23
+         // Maximum Relative Change in Control Points : 8.174e-04
+         // Max Error found at float80 precision = Poly : 4.137325e-20
+         static const T P2[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 64, -3.079657578292062244054e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -7.963049154965966503231e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -3.103277523735639924895e-03),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -4.023052834702215699504e-05),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -1.719459155018493821839e-07)
+         };
+         static const T Q2[] = 
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.000000000000000000000e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -1.863917670410152669768e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.699367098849735298090e-04),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -9.309358790546076298429e-07),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.708893480271612711933e-09)
+         };
+
+         return tools::evaluate_rational(P2, Q2, T(x * x)) * x + 1 / x + log(x) * a;
+      }
+      else
+      {
+         // Maximum Deviation Found:                     9.785e-20
+         // Expected Error Term : -3.302e-21
+         // Maximum Relative Change in Control Points : 3.432e-01
+         // Max Error found at float80 precision = Poly : 1.083755e-19
+         static const T Y = 1.450342178344726562500e+00f;
+         static const T P[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 64, -1.970280410292263112917e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -4.058564803062959169322e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -3.036658174194917777473e+01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -9.576825392332820142173e+01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, -6.706969489248020941949e+01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 3.264572499406168221382e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 8.584972047303151034100e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 8.422082733280017909550e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 3.738005441471368178383e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 7.016938390144121276609e+01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 4.319614662598089438939e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 3.710715864316521856193e-02)
+         };
+         static const T Q[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.000000000000000000000e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.298433045824439052398e+01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.082047745067709230037e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 9.662367854250262046592e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.504148628460454004686e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 3.712730364911389908905e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 3.108002081150068641112e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 1.400149940532448553143e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 3.083303048095846226299e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 2.748706060530351833346e+01),
+            BOOST_MATH_BIG_CONSTANT(T, 64, 6.321900849331506946977e-01),
+         };
+         if(x < tools::log_max_value<T>())
+            return ((tools::evaluate_polynomial(P, T(1 / x)) / tools::evaluate_polynomial(Q, T(1 / x)) + Y) * exp(-x) / sqrt(x));
+         else
+         {
+            T ex = exp(-x / 2);
+            return ((tools::evaluate_polynomial(P, T(1 / x)) / tools::evaluate_polynomial(Q, T(1 / x)) + Y) * ex / sqrt(x)) * ex;
+         }
+      }
+   }
+
+   template <typename T>
+   T bessel_k1_imp(const T& x, const mpl::int_<113>&)
+   {
+      BOOST_MATH_STD_USING
+      if(x <= 1)
+      {
+         // Maximum Deviation Found:                     7.120e-35
+         // Expected Error Term : -7.119e-35
+         // Maximum Relative Change in Control Points : 1.207e-03
+         // Max Error found at float128 precision = Poly : 7.143688e-35
+         static const T Y = 8.695471286773681640625000000000000000e-02f;
+         static const T P[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 113, -3.621379534403483072916666666666595475e-03),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 7.074117676930975433219826471336547627e-03),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 9.631337631362776369069668419033041661e-05),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 3.468935967870048731821071646104412775e-06),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.956705020559599861444492614737168261e-08),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.347140307321161346703214099534250263e-10),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 5.569608494081482873946791086435679661e-13)
+         };
+         static const T Q[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.000000000000000000000000000000000000e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -3.580768910152105375615558920428350204e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 6.197467671701485365363068445534557369e-04),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -6.707466533308630411966030561446666237e-06),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 4.846687802282250112624373388491123527e-08),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -2.248493131151981569517383040323900343e-10),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 5.319279786372775264555728921709381080e-13)
+         };
+
+         T a = x * x / 4;
+         a = ((tools::evaluate_rational(P, Q, a) + Y) * a * a + a / 2 + 1) * x / 2;
+
+         // Maximum Deviation Found:                     4.473e-37
+         // Expected Error Term : 4.473e-37
+         // Maximum Relative Change in Control Points : 8.550e-04
+         // Max Error found at float128 precision = Poly : 8.167701e-35
+         static const T P2[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 113, -3.079657578292062244053600156878870690e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -8.133183745732467770755578848987414875e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -3.548968792764174773125420229299431951e-03),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -5.886125468718182876076972186152445490e-05),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -4.506712111733707245745396404449639865e-07),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -1.632502325880313239698965376754406011e-09),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -2.311973065898784812266544485665624227e-12)
+         };
+         static const T Q2[] = 
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.000000000000000000000000000000000000e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -1.311471216733781016657962995723287450e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 8.571876054797365417068164018709472969e-05),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -3.630181215268238731442496851497901293e-07),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.070176111227805048604885986867484807e-09),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -2.129046580769872602793220056461084761e-12),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.294906469421390890762001971790074432e-15)
+         };
+
+         return tools::evaluate_rational(P2, Q2, T(x * x)) * x + 1 / x + log(x) * a;
+      }
+      else if(x < 4)
+      {
+         // Max error in interpolated form: 5.307e-37
+         // Max Error found at float128 precision = Poly: 7.087862e-35
+         static const T Y = 1.5023040771484375f;
+         static const T P[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 113, -2.489899398329369710528254347931380044e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -6.819080211203854781858815596508456873e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -7.599915699069767382647695624952723034e+01),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -4.450211910821295507926582231071300718e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -1.451374687870925175794150513723956533e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -2.405805746895098802803503988539098226e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -5.638808326778389656403861103277220518e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 5.513958744081268456191778822780865708e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.121301640926540743072258116122834804e+04),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.080094900175649541266613109971296190e+04),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 5.896531083639613332407534434915552429e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.856602122319645694042555107114028437e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 3.237121918853145421414003823957537419e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.842072954561323076230238664623893504e+01),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.039705646510167437971862966128055524e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.008418100718254816100425022904039530e-02)
+         };
+         static const T Q[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.000000000000000000000000000000000000e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.927456835239137986889227412815459529e+01),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 3.598985593265577043711382994516531273e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.449897377085510281395819892689690579e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.025555887684561913263090023158085327e+04),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.774140447181062463181892531100679195e+04),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 4.962055507843204417243602332246120418e+04),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 5.908269326976180183216954452196772931e+04),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 4.655160454422016855911700790722577942e+04),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.383586885019548163464418964577684608e+04),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 7.679920375586960324298491662159976419e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.478586421028842906987799049804565008e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.565384974896746094224942654383537090e+02),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 7.902617937084010911005732488607114511e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.429293010387921526110949911029094926e-01),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 3.880342607911083143560111853491047663e-04)
+         };
+         return ((tools::evaluate_polynomial(P, T(1 / x)) / tools::evaluate_polynomial(Q, T(1 / x)) + Y) * exp(-x) / sqrt(x));
+      }
+      else
+      {
+         // Maximum Deviation Found:                     4.359e-37
+         // Expected Error Term : -6.565e-40
+         // Maximum Relative Change in Control Points : 1.880e-01
+         // Max Error found at float128 precision = Poly : 2.943572e-35
+         static const T Y = 1.308816909790039062500000000000000000f;
+         static const T P[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 113, -5.550277247453881129211735759447737350e-02),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -3.485883080219574328217554864956175929e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -8.903760658131484239300875153154881958e+01),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -1.144813672213626237418235110712293337e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 113, -6.498400501156131446691826557494158173e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.573531831870363502604119835922166116e+04),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 5.417416550054632009958262596048841154e+05),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 4.271266450613557412825896604269130661e+06),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.898386013314389952534433455681107783e+07),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 5.353798784656436259250791761023512750e+07),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 9.839619195427352438957774052763490067e+07),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.169246368651532232388152442538005637e+08),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 8.696368884166831199967845883371116431e+07),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 3.810226630422736458064005843327500169e+07),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 8.854996610560406127438950635716757614e+06),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 8.981057433937398731355768088809437625e+05),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.519440069856232098711793483639792952e+04)
+         };
+         static const T Q[] =
+         {
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.000000000000000000000000000000000000e+00),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 7.127348248283623146544565916604103560e+01),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.205092684176906740104488180754982065e+03),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 3.911249195069050636298346469740075758e+04),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 4.426103406579046249654548481377792614e+05),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 3.365861555422488771286500241966208541e+06),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.765377714160383676864913709252529840e+07),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 6.453822726931857253365138260720815246e+07),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.643207885048369990391975749439783892e+08),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.882540678243694621895816336640877878e+08),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 3.410120808992380266174106812005338148e+08),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.628138016559335882019310900426773027e+08),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.250794693811010646965360198541047961e+08),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 3.378723408195485594610593014072950078e+07),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 4.488253856312453816451380319061865560e+06),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 2.202167197882689873967723350537104582e+05),
+            BOOST_MATH_BIG_CONSTANT(T, 113, 1.673233230356966539460728211412989843e+03)
+         };
+         if(x < tools::log_max_value<T>())
+            return ((tools::evaluate_polynomial(P, T(1 / x)) / tools::evaluate_polynomial(Q, T(1 / x)) + Y) * exp(-x) / sqrt(x));
+         else
+         {
+            T ex = exp(-x / 2);
+            return ((tools::evaluate_polynomial(P, T(1 / x)) / tools::evaluate_polynomial(Q, T(1 / x)) + Y) * ex / sqrt(x)) * ex;
+         }
+      }
+    }
+
+    template <typename T>
+    T bessel_k1_imp(const T& x, const mpl::int_<0>&)
+    {
+       if(boost::math::tools::digits<T>() <= 24)
+          return bessel_k1_imp(x, mpl::int_<24>());
+       else if(boost::math::tools::digits<T>() <= 53)
+          return bessel_k1_imp(x, mpl::int_<53>());
+       else if(boost::math::tools::digits<T>() <= 64)
+          return bessel_k1_imp(x, mpl::int_<64>());
+       else if(boost::math::tools::digits<T>() <= 113)
+          return bessel_k1_imp(x, mpl::int_<113>());
+       BOOST_ASSERT(0);
+       return 0;
+    }
+
+    template <typename T>
+   inline T bessel_k1(const T& x)
+   {
+      typedef mpl::int_<
+         ((std::numeric_limits<T>::digits == 0) || (std::numeric_limits<T>::radix != 2)) ?
+         0 :
+         std::numeric_limits<T>::digits <= 24 ?
+         24 :
+         std::numeric_limits<T>::digits <= 53 ?
+         53 :
+         std::numeric_limits<T>::digits <= 64 ?
+         64 :
+         std::numeric_limits<T>::digits <= 113 ?
+         113 : -1
+      > tag_type;
+
+      bessel_k1_initializer<T, tag_type>::force_instantiate();
+      return bessel_k1_imp(x, tag_type());
+   }
+
+}}} // namespaces
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+#endif // BOOST_MATH_BESSEL_K1_HPP
+
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_kn.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_kn.hpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_kn.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_kn.hpp
index e3a5023c63f..54c4a1cfa7a 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_kn.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_kn.hpp
@@ -45,16 +45,16 @@ T bessel_kn(int n, T x, const Policy& pol)
     }
     if (n == 0)
     {
-        value = bessel_k0(x, pol);
+        value = bessel_k0(x);
     }
     else if (n == 1)
     {
-        value = bessel_k1(x, pol);
+        value = bessel_k1(x);
     }
     else
     {
-       prev = bessel_k0(x, pol);
-       current = bessel_k1(x, pol);
+       prev = bessel_k0(x);
+       current = bessel_k1(x);
        int k = 1;
        BOOST_ASSERT(k < n);
        T scale = 1;
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_y0.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_y0.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_y0.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_y0.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_y1.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_y1.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_y1.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_y1.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_yn.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_yn.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/bessel_yn.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/bessel_yn.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/erf_inv.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/erf_inv.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/erf_inv.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/erf_inv.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/fp_traits.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/fp_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/fp_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/fp_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/gamma_inva.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/gamma_inva.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/gamma_inva.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/gamma_inva.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/ibeta_inv_ab.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/ibeta_inv_ab.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/ibeta_inv_ab.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/ibeta_inv_ab.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/ibeta_inverse.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/ibeta_inverse.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/ibeta_inverse.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/ibeta_inverse.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/iconv.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/iconv.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/iconv.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/iconv.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/igamma_inverse.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/igamma_inverse.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/igamma_inverse.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/igamma_inverse.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/igamma_large.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/igamma_large.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/igamma_large.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/igamma_large.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/lanczos_sse2.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/lanczos_sse2.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/lanczos_sse2.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/lanczos_sse2.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/lgamma_small.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/lgamma_small.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/lgamma_small.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/lgamma_small.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/polygamma.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/polygamma.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/polygamma.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/polygamma.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/round_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/round_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/round_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/round_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/t_distribution_inv.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/t_distribution_inv.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/t_distribution_inv.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/t_distribution_inv.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/unchecked_bernoulli.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/unchecked_bernoulli.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/unchecked_bernoulli.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/unchecked_bernoulli.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/unchecked_factorial.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/unchecked_factorial.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/detail/unchecked_factorial.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/detail/unchecked_factorial.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/digamma.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/digamma.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/digamma.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/digamma.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/ellint_1.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/ellint_1.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/ellint_1.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/ellint_1.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/ellint_2.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/ellint_2.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/ellint_2.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/ellint_2.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/ellint_3.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/ellint_3.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/ellint_3.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/ellint_3.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/ellint_d.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/ellint_d.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/ellint_d.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/ellint_d.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/ellint_rc.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/ellint_rc.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/ellint_rc.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/ellint_rc.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/ellint_rd.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/ellint_rd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/ellint_rd.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/ellint_rd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/ellint_rf.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/ellint_rf.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/ellint_rf.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/ellint_rf.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/ellint_rg.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/ellint_rg.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/ellint_rg.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/ellint_rg.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/ellint_rj.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/ellint_rj.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/ellint_rj.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/ellint_rj.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/erf.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/erf.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/erf.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/erf.hpp
index f7f75b0bc7a..8d3ee925f43 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/special_functions/erf.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/erf.hpp
@@ -155,12 +155,18 @@ T erf_imp(T z, bool invert, const Policy& pol, const Tag& t)
          result = tgamma_small_upper_part(T(0.5f), x, pol);
          result /= sqrt(boost::math::constants::pi<T>());
       }
+      else if(x > 1 / tools::epsilon<T>())
+      {
+         // http://functions.wolfram.com/06.27.06.0006.02
+         invert = !invert;
+         result = exp(-x) / (constants::root_pi<T>() * z);
+      }
       else
       {
          // Compute Q:
          invert = !invert;
          result = z * exp(-x);
-         result /= sqrt(boost::math::constants::pi<T>());
+         result /= boost::math::constants::root_pi<T>();
          result *= upper_gamma_fraction(T(0.5f), x, policies::get_epsilon<T, Policy>());
       }
    }
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/expint.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/expint.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/expint.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/expint.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/expm1.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/expm1.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/expm1.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/expm1.hpp
index 7423dc5c811..9cecc897560 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/special_functions/expm1.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/expm1.hpp
@@ -107,6 +107,10 @@ T expm1_imp(T x, const mpl::int_<0>&, const Policy& pol)
    BOOST_MATH_STD_USING
 
    T a = fabs(x);
+   if((boost::math::isnan)(a))
+   {
+      return policies::raise_domain_error<T>("boost::math::expm1<%1%>(%1%)", "expm1 requires a finite argument, but got %1%", a, pol);
+   }
    if(a > T(0.5f))
    {
       if(a >= tools::log_max_value<T>())
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/factorials.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/factorials.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/factorials.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/factorials.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/fpclassify.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/fpclassify.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/fpclassify.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/fpclassify.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/gamma.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/gamma.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/gamma.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/gamma.hpp
index a2b30f85512..1903b997cbf 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/special_functions/gamma.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/gamma.hpp
@@ -239,14 +239,14 @@ T lgamma_imp(T z, const Policy& pol, const Lanczos& l, int* sign = 0)
    }
    else if (z < tools::root_epsilon<T>())
    {
-     if (0 == z)
-	      return policies::raise_pole_error<T>(function, "Evaluation of lgamma at %1%.", z, pol);
+      if (0 == z)
+         return policies::raise_pole_error<T>(function, "Evaluation of lgamma at %1%.", z, pol);
       if (fabs(z) < 1 / tools::max_value<T>())
          result = -log(fabs(z));
       else
          result = log(fabs(1 / z - constants::euler<T>()));
       if (z < 0)
-		sresult = -1;
+         sresult = -1;
    }
    else if(z < 15)
    {
@@ -391,8 +391,8 @@ T gamma_imp(T z, const Policy& pol, const lanczos::undefined_lanczos&)
    // Check if the argument of tgamma is identically zero.
    const bool is_at_zero = (z == 0);
 
-   if(is_at_zero)
-      return policies::raise_domain_error<T>(function, "Evaluation of tgamma at zero %1%.", z, pol);
+   if((is_at_zero) || ((boost::math::isinf)(z) && (z < 0)))
+      return policies::raise_domain_error<T>(function, "Evaluation of tgamma at %1%.", z, pol);
 
    const bool b_neg = (z < 0);
 
@@ -538,6 +538,10 @@ T lgamma_imp(T z, const Policy& pol, const lanczos::undefined_lanczos&, int* sig
 
    if(is_at_zero)
       return policies::raise_domain_error<T>(function, "Evaluation of lgamma at zero %1%.", z, pol);
+   if((boost::math::isnan)(z))
+      return policies::raise_domain_error<T>(function, "Evaluation of lgamma at %1%.", z, pol);
+   if((boost::math::isinf)(z))
+      return policies::raise_overflow_error<T>(function, 0, pol);
 
    const bool b_neg = (z < 0);
 
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/hankel.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/hankel.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/hankel.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/hankel.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/hermite.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/hermite.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/hermite.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/hermite.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/heuman_lambda.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/heuman_lambda.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/heuman_lambda.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/heuman_lambda.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/hypot.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/hypot.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/hypot.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/hypot.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/jacobi_elliptic.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/jacobi_elliptic.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/jacobi_elliptic.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/jacobi_elliptic.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/jacobi_zeta.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/jacobi_zeta.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/jacobi_zeta.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/jacobi_zeta.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/laguerre.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/laguerre.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/laguerre.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/laguerre.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/lanczos.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/lanczos.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/lanczos.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/lanczos.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/legendre.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/legendre.hpp
similarity index 51%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/legendre.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/legendre.hpp
index 1a2ef5d6155..6028b377d30 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/special_functions/legendre.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/legendre.hpp
@@ -11,8 +11,11 @@
 #pragma once
 #endif
 
+#include <utility>
+#include <vector>
 #include <boost/math/special_functions/math_fwd.hpp>
 #include <boost/math/special_functions/factorials.hpp>
+#include <boost/math/tools/roots.hpp>
 #include <boost/math/tools/config.hpp>
 
 namespace boost{
@@ -68,6 +71,149 @@ T legendre_imp(unsigned l, T x, const Policy& pol, bool second = false)
    return p1;
 }
 
+template <class T, class Policy>
+T legendre_p_prime_imp(unsigned l, T x, const Policy& pol, T* Pn 
+#ifdef BOOST_NO_CXX11_NULLPTR
+   = 0
+#else
+   = nullptr
+#endif
+)
+{
+   static const char* function = "boost::math::legrendre_p_prime<%1%>(unsigned, %1%)";
+   // Error handling:
+   if ((x < -1) || (x > 1))
+      return policies::raise_domain_error<T>(
+         function,
+         "The Legendre Polynomial is defined for"
+         " -1 <= x <= 1, but got x = %1%.", x, pol);
+   
+   if (l == 0)
+    {
+        if (Pn)
+        {
+           *Pn = 1;
+        }
+        return 0;
+    }
+    T p0 = 1;
+    T p1 = x;
+    T p_prime;
+    bool odd = l & 1;
+    // If the order is odd, we sum all the even polynomials:
+    if (odd)
+    {
+        p_prime = p0;
+    }
+    else // Otherwise we sum the odd polynomials * (2n+1)
+    {
+        p_prime = 3*p1;
+    }
+
+    unsigned n = 1;
+    while(n < l - 1)
+    {
+       std::swap(p0, p1);
+       p1 = boost::math::legendre_next(n, x, p0, p1);
+       ++n;
+       if (odd)
+       {
+          p_prime += (2*n+1)*p1;
+          odd = false;
+       }
+       else
+       {
+           odd = true;
+       }
+    }
+    // This allows us to evaluate the derivative and the function for the same cost.
+    if (Pn)
+    {
+        std::swap(p0, p1);
+        *Pn = boost::math::legendre_next(n, x, p0, p1);
+    }
+    return p_prime;
+}
+
+template <class T, class Policy>
+struct legendre_p_zero_func
+{
+   int n;
+   const Policy& pol;
+
+   legendre_p_zero_func(int n_, const Policy& p) : n(n_), pol(p) {}
+
+   std::pair<T, T> operator()(T x) const
+   { 
+      T Pn;
+      T Pn_prime = detail::legendre_p_prime_imp(n, x, pol, &Pn);
+      return std::pair<T, T>(Pn, Pn_prime); 
+   };
+};
+
+template <class T, class Policy>
+std::vector<T> legendre_p_zeros_imp(int n, const Policy& pol)
+{
+    using std::cos;
+    using std::sin;
+    using std::ceil;
+    using std::sqrt;
+    using boost::math::constants::pi;
+    using boost::math::constants::half;
+    using boost::math::tools::newton_raphson_iterate;
+
+    BOOST_ASSERT(n >= 0);
+    std::vector<T> zeros;
+    if (n == 0)
+    {
+        // There are no zeros of P_0(x) = 1.
+        return zeros;
+    }
+    int k;
+    if (n & 1)
+    {
+        zeros.resize((n-1)/2 + 1, std::numeric_limits<T>::quiet_NaN());
+        zeros[0] = 0;
+        k = 1;
+    }
+    else
+    {
+        zeros.resize(n/2, std::numeric_limits<T>::quiet_NaN());
+        k = 0;
+    }
+    T half_n = ceil(n*half<T>());
+
+    while (k < (int)zeros.size())
+    {
+        // Bracket the root: Szego:
+        // Gabriel Szego, Inequalities for the Zeros of Legendre Polynomials and Related Functions, Transactions of the American Mathematical Society, Vol. 39, No. 1 (1936)
+        T theta_nk =  ((half_n - half<T>()*half<T>() - static_cast<T>(k))*pi<T>())/(static_cast<T>(n)+half<T>());
+        T lower_bound = cos( (half_n - static_cast<T>(k))*pi<T>()/static_cast<T>(n + 1));
+        T cos_nk = cos(theta_nk);
+        T upper_bound = cos_nk;
+        // First guess follows from:
+        //  F. G. Tricomi, Sugli zeri dei polinomi sferici ed ultrasferici, Ann. Mat. Pura Appl., 31 (1950), pp. 93–97;
+        T inv_n_sq = 1/static_cast<T>(n*n);
+        T sin_nk = sin(theta_nk);
+        T x_nk_guess = (1 - inv_n_sq/static_cast<T>(8) + inv_n_sq /static_cast<T>(8*n) - (inv_n_sq*inv_n_sq/384)*(39  - 28 / (sin_nk*sin_nk) ) )*cos_nk;
+
+        boost::uintmax_t number_of_iterations = policies::get_max_root_iterations<Policy>();
+
+        legendre_p_zero_func<T, Policy> f(n, pol);
+
+        const T x_nk = newton_raphson_iterate(f, x_nk_guess,
+                                              lower_bound, upper_bound,
+                                              policies::digits<T, Policy>(),
+                                              number_of_iterations);
+
+        BOOST_ASSERT(lower_bound < x_nk);
+        BOOST_ASSERT(upper_bound > x_nk);
+        zeros[k] = x_nk;
+        ++k;
+    }
+    return zeros;
+}
+
 } // namespace detail
 
 template <class T, class Policy>
@@ -82,13 +228,49 @@ inline typename boost::enable_if_c<policies::is_policy<Policy>::value, typename
    return policies::checked_narrowing_cast<result_type, Policy>(detail::legendre_imp(l, static_cast<value_type>(x), pol, false), function);
 }
 
+
+template <class T, class Policy>
+inline typename boost::enable_if_c<policies::is_policy<Policy>::value, typename tools::promote_args<T>::type>::type
+   legendre_p_prime(int l, T x, const Policy& pol)
+{
+   typedef typename tools::promote_args<T>::type result_type;
+   typedef typename policies::evaluation<result_type, Policy>::type value_type;
+   static const char* function = "boost::math::legendre_p_prime<%1%>(unsigned, %1%)";
+   if(l < 0)
+      return policies::checked_narrowing_cast<result_type, Policy>(detail::legendre_p_prime_imp(-l-1, static_cast<value_type>(x), pol), function);
+   return policies::checked_narrowing_cast<result_type, Policy>(detail::legendre_p_prime_imp(l, static_cast<value_type>(x), pol), function);
+}
+
 template <class T>
-inline typename tools::promote_args<T>::type 
+inline typename tools::promote_args<T>::type
    legendre_p(int l, T x)
 {
    return boost::math::legendre_p(l, x, policies::policy<>());
 }
 
+template <class T>
+inline typename tools::promote_args<T>::type
+   legendre_p_prime(int l, T x)
+{
+   return boost::math::legendre_p_prime(l, x, policies::policy<>());
+}
+
+template <class T, class Policy>
+inline std::vector<T> legendre_p_zeros(int l, const Policy& pol)
+{
+    if(l < 0)
+        return detail::legendre_p_zeros_imp<T>(-l-1, pol);
+
+    return detail::legendre_p_zeros_imp<T>(l, pol);
+}
+
+
+template <class T>
+inline std::vector<T> legendre_p_zeros(int l)
+{
+   return boost::math::legendre_p_zeros<T>(l, policies::policy<>());
+}
+
 template <class T, class Policy>
 inline typename boost::enable_if_c<policies::is_policy<Policy>::value, typename tools::promote_args<T>::type>::type
    legendre_q(unsigned l, T x, const Policy& pol)
@@ -99,7 +281,7 @@ inline typename boost::enable_if_c<policies::is_policy<Policy>::value, typename
 }
 
 template <class T>
-inline typename tools::promote_args<T>::type 
+inline typename tools::promote_args<T>::type
    legendre_q(unsigned l, T x)
 {
    return boost::math::legendre_q(l, x, policies::policy<>());
@@ -107,7 +289,7 @@ inline typename tools::promote_args<T>::type
 
 // Recurrence for associated polynomials:
 template <class T1, class T2, class T3>
-inline typename tools::promote_args<T1, T2, T3>::type 
+inline typename tools::promote_args<T1, T2, T3>::type
    legendre_next(unsigned l, unsigned m, T1 x, T2 Pl, T3 Plm1)
 {
    typedef typename tools::promote_args<T1, T2, T3>::type result_type;
@@ -189,6 +371,3 @@ inline typename tools::promote_args<T>::type
 } // namespace boost
 
 #endif // BOOST_MATH_SPECIAL_LEGENDRE_HPP
-
-
-
diff --git a/contrib/libboost/boost_1_65_0/boost/math/special_functions/legendre_stieltjes.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/legendre_stieltjes.hpp
new file mode 100644
index 00000000000..5d681988707
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/legendre_stieltjes.hpp
@@ -0,0 +1,235 @@
+// Copyright Nick Thompson 2017.
+// Use, modification and distribution are subject to the
+// Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt
+// or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_MATH_SPECIAL_LEGENDRE_STIELTJES_HPP
+#define BOOST_MATH_SPECIAL_LEGENDRE_STIELTJES_HPP
+
+/*
+ * Constructs the Legendre-Stieltjes polynomial of degree m.
+ * The Legendre-Stieltjes polynomials are used to create extensions for Gaussian quadratures,
+ * commonly called "Gauss-Konrod" quadratures.
+ *
+ * References:
+ * Patterson, TNL. "The optimum addition of points to quadrature formulae." Mathematics of Computation 22.104 (1968): 847-856.
+ */
+
+#include <iostream>
+#include <vector>
+#include <boost/math/tools/roots.hpp>
+#include <boost/math/special_functions/legendre.hpp>
+
+namespace boost{
+namespace math{
+
+template<class Real>
+class legendre_stieltjes
+{
+public:
+    legendre_stieltjes(size_t m)
+    {
+        if (m == 0)
+        {
+           throw std::domain_error("The Legendre-Stieltjes polynomial is defined for order m > 0.\n");
+        }
+        m_m = m;
+        std::ptrdiff_t n = m - 1;
+        std::ptrdiff_t q;
+        std::ptrdiff_t r;
+        bool odd = n & 1;
+        if (odd)
+        {
+           q = 1;
+           r = (n-1)/2 + 2;
+        }
+        else
+        {
+           q = 0;
+           r = n/2 + 1;
+        }
+        m_a.resize(r + 1);
+        // We'll keep the ones-based indexing at the cost of storing a superfluous element
+        // so that we can follow Patterson's notation exactly.
+        m_a[r] = static_cast<Real>(1);
+        // Make sure using the zero index is a bug:
+        m_a[0] = std::numeric_limits<Real>::quiet_NaN();
+
+        for (std::ptrdiff_t k = 1; k < r; ++k)
+        {
+            Real ratio = 1;
+            m_a[r - k] = 0;
+            for (std::ptrdiff_t i = r + 1 - k; i <= r; ++i)
+            {
+                // See Patterson, equation 12
+                std::ptrdiff_t num = (n - q + 2*(i + k - 1))*(n + q + 2*(k - i + 1))*(n-1-q+2*(i-k))*(2*(k+i-1) -1 -q -n);
+                std::ptrdiff_t den = (n - q + 2*(i - k))*(2*(k + i - 1) - q - n)*(n + 1 + q + 2*(k - i))*(n - 1 - q + 2*(i + k));
+                ratio *= static_cast<Real>(num)/static_cast<Real>(den);
+                m_a[r - k] -= ratio*m_a[i];
+            }
+        }
+    }
+
+
+    Real norm_sq() const
+    {
+        Real t = 0;
+        bool odd = m_m & 1;
+        for (size_t i = 1; i < m_a.size(); ++i)
+        {
+            if(odd)
+            {
+                t += 2*m_a[i]*m_a[i]/static_cast<Real>(4*i-1);
+            }
+            else
+            {
+                t += 2*m_a[i]*m_a[i]/static_cast<Real>(4*i-3);
+            }
+        }
+        return t;
+    }
+
+
+    Real operator()(Real x) const
+    {
+        // Trivial implementation:
+        // Em += m_a[i]*legendre_p(2*i - 1, x);  m odd
+        // Em += m_a[i]*legendre_p(2*i - 2, x);  m even
+        size_t r = m_a.size() - 1;
+        Real p0 = 1;
+        Real p1 = x;
+
+        Real Em;
+        bool odd = m_m & 1;
+        if (odd)
+        {
+            Em = m_a[1]*p1;
+        }
+        else
+        {
+            Em = m_a[1]*p0;
+        }
+
+        unsigned n = 1;
+        for (size_t i = 2; i <= r; ++i)
+        {
+            std::swap(p0, p1);
+            p1 = boost::math::legendre_next(n, x, p0, p1);
+            ++n;
+            if (!odd)
+            {
+               Em += m_a[i]*p1;
+            }
+            std::swap(p0, p1);
+            p1 = boost::math::legendre_next(n, x, p0, p1);
+            ++n;
+            if(odd)
+            {
+                Em += m_a[i]*p1;
+            }
+        }
+        return Em;
+    }
+
+
+    Real prime(Real x) const
+    {
+        Real Em_prime = 0;
+
+        for (size_t i = 1; i < m_a.size(); ++i)
+        {
+            if(m_m & 1)
+            {
+                Em_prime += m_a[i]*detail::legendre_p_prime_imp(2*i - 1, x, policies::policy<>());
+            }
+            else
+            {
+                Em_prime += m_a[i]*detail::legendre_p_prime_imp(2*i - 2, x, policies::policy<>());
+            }
+        }
+        return Em_prime;
+    }
+
+    std::vector<Real> zeros() const
+    {
+        using boost::math::constants::half;
+
+        std::vector<Real> stieltjes_zeros;
+        std::vector<Real> legendre_zeros = legendre_p_zeros<Real>(m_m - 1);
+        int k;
+        if (m_m & 1)
+        {
+            stieltjes_zeros.resize(legendre_zeros.size() + 1, std::numeric_limits<Real>::quiet_NaN());
+            stieltjes_zeros[0] = 0;
+            k = 1;
+        }
+        else
+        {
+            stieltjes_zeros.resize(legendre_zeros.size(), std::numeric_limits<Real>::quiet_NaN());
+            k = 0;
+        }
+
+        while (k < (int)stieltjes_zeros.size())
+        {
+            Real lower_bound;
+            Real upper_bound;
+            if (m_m & 1)
+            {
+                lower_bound = legendre_zeros[k - 1];
+                if (k == (int)legendre_zeros.size())
+                {
+                    upper_bound = 1;
+                }
+                else
+                {
+                    upper_bound = legendre_zeros[k];
+                }
+            }
+            else
+            {
+                lower_bound = legendre_zeros[k];
+                if (k == (int)legendre_zeros.size() - 1)
+                {
+                    upper_bound = 1;
+                }
+                else
+                {
+                    upper_bound = legendre_zeros[k+1];
+                }
+            }
+
+            // The root bracketing is not very tight; to keep weird stuff from happening
+            // in the Newton's method, let's tighten up the tolerance using a few bisections.
+            boost::math::tools::eps_tolerance<Real> tol(6);
+            auto g = [&](Real t) { return this->operator()(t); };
+            auto p = boost::math::tools::bisect(g, lower_bound, upper_bound, tol);
+
+            Real x_nk_guess = p.first + (p.second - p.first)*half<Real>();
+            boost::uintmax_t number_of_iterations = 500;
+
+            auto f = [&] (Real x) { Real Pn = this->operator()(x);
+                                    Real Pn_prime = this->prime(x);
+                                    return std::pair<Real, Real>(Pn, Pn_prime); };
+
+            const Real x_nk = boost::math::tools::newton_raphson_iterate(f, x_nk_guess,
+                                                  p.first, p.second,
+                                                  2*std::numeric_limits<Real>::digits10,
+                                                  number_of_iterations);
+
+            BOOST_ASSERT(p.first < x_nk);
+            BOOST_ASSERT(x_nk < p.second);
+            stieltjes_zeros[k] = x_nk;
+            ++k;
+        }
+        return stieltjes_zeros;
+    }
+
+private:
+    // Coefficients of Legendre expansion
+    std::vector<Real> m_a;
+    int m_m;
+};
+
+}}
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/log1p.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/log1p.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/log1p.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/log1p.hpp
index 50bdaeb3858..7fa1eb8de99 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/special_functions/log1p.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/log1p.hpp
@@ -80,7 +80,7 @@ T log1p_imp(T const & x, const Policy& pol, const mpl::int_<0>&)
 
    static const char* function = "boost::math::log1p<%1%>(%1%)";
 
-   if(x < -1)
+   if((x < -1) || (boost::math::isnan)(x))
       return policies::raise_domain_error<T>(
          function, "log1p(x) requires x > -1, but got x = %1%.", x, pol);
    if(x == -1)
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/math_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/math_fwd.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/math_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/math_fwd.hpp
index ca8e58144e8..9becef9f6dd 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/special_functions/math_fwd.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/math_fwd.hpp
@@ -23,6 +23,7 @@
 #pragma once
 #endif
 
+#include <vector>
 #include <boost/math/special_functions/detail/round_fwd.hpp>
 #include <boost/math/tools/promotion.hpp> // for argument promotion.
 #include <boost/math/policies/policy.hpp>
@@ -181,10 +182,24 @@ namespace boost
    template <class T>
    typename tools::promote_args<T>::type
          legendre_p(int l, T x);
+   template <class T>
+   typename tools::promote_args<T>::type
+          legendre_p_prime(int l, T x);
+
+
+   template <class T, class Policy>
+   inline std::vector<T> legendre_p_zeros(int l, const Policy& pol);
+
+   template <class T>
+   inline std::vector<T> legendre_p_zeros(int l);
+
 #if !BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
    template <class T, class Policy>
    typename boost::enable_if_c<policies::is_policy<Policy>::value, typename tools::promote_args<T>::type>::type
          legendre_p(int l, T x, const Policy& pol);
+   template <class T, class Policy>
+   inline typename boost::enable_if_c<policies::is_policy<Policy>::value, typename tools::promote_args<T>::type>::type
+      legendre_p_prime(int l, T x, const Policy& pol);
 #endif
    template <class T>
    typename tools::promote_args<T>::type
@@ -626,6 +641,17 @@ namespace boost
                bessel_maybe_int_tag
             >::type
          >::type optimisation_tag;
+         typedef typename mpl::if_<
+            mpl::or_<
+               mpl::less_equal<precision_type, mpl::int_<0> >,
+               mpl::greater<precision_type, mpl::int_<113> > >,
+            bessel_no_int_tag,
+            typename mpl::if_<
+               is_integral<T1>,
+               bessel_int_tag,
+               bessel_maybe_int_tag
+            >::type
+         >::type optimisation_tag128;
       };
    } // detail
 
@@ -1133,6 +1159,10 @@ namespace boost
    template <class T>\
    inline typename boost::math::tools::promote_args<T>::type \
    legendre_p(int l, T x){ return ::boost::math::legendre_p(l, x, Policy()); }\
+\
+   template <class T>\
+   inline typename boost::math::tools::promote_args<T>::type \
+   legendre_p_prime(int l, T x){ return ::boost::math::legendre_p(l, x, Policy()); }\
 \
    template <class T>\
    inline typename boost::math::tools::promote_args<T>::type \
@@ -1582,5 +1612,3 @@ template <class OutputIterator, class T>\
 
 
 #endif // BOOST_MATH_SPECIAL_MATH_FWD_HPP
-
-
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/modf.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/modf.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/modf.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/modf.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/next.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/next.hpp
similarity index 50%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/next.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/next.hpp
index 9602bc7697f..f23ddaffe3d 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/special_functions/next.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/next.hpp
@@ -27,8 +27,58 @@
 
 namespace boost{ namespace math{
 
+   namespace concepts {
+
+      struct real_concept;
+      struct std_real_concept;
+
+   }
+
 namespace detail{
 
+template <class T>
+struct has_hidden_guard_digits;
+template <>
+struct has_hidden_guard_digits<float> : public mpl::false_ {};
+template <>
+struct has_hidden_guard_digits<double> : public mpl::false_ {};
+template <>
+struct has_hidden_guard_digits<long double> : public mpl::false_ {};
+#ifdef BOOST_HAS_FLOAT128
+template <>
+struct has_hidden_guard_digits<__float128> : public mpl::false_ {};
+#endif
+template <>
+struct has_hidden_guard_digits<boost::math::concepts::real_concept> : public mpl::false_ {};
+template <>
+struct has_hidden_guard_digits<boost::math::concepts::std_real_concept> : public mpl::false_ {};
+
+template <class T, bool b>
+struct has_hidden_guard_digits_10 : public mpl::false_ {};
+template <class T>
+struct has_hidden_guard_digits_10<T, true> : public mpl::bool_<(std::numeric_limits<T>::digits10 != std::numeric_limits<T>::max_digits10)> {};
+
+template <class T>
+struct has_hidden_guard_digits 
+   : public has_hidden_guard_digits_10<T, 
+   std::numeric_limits<T>::is_specialized
+   && (std::numeric_limits<T>::radix == 10) >
+{};
+
+template <class T>
+inline const T& normalize_value(const T& val, const mpl::false_&) { return val; }
+template <class T>
+inline T normalize_value(const T& val, const mpl::true_&) 
+{
+   BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_specialized);
+   BOOST_STATIC_ASSERT(std::numeric_limits<T>::radix != 2);
+
+   boost::intmax_t shift = std::numeric_limits<T>::digits - ilogb(val) - 1;
+   T result = scalbn(val, shift);
+   result = round(result);
+   return scalbn(result, -shift); 
+}
+
 template <class T>
 inline T get_smallest_value(mpl::true_ const&)
 {
@@ -93,19 +143,33 @@ struct min_shift_initializer
 template <class T>
 const typename min_shift_initializer<T>::init min_shift_initializer<T>::initializer;
 
+template <class T>
+inline T calc_min_shifted(const mpl::true_&)
+{
+   BOOST_MATH_STD_USING
+   return ldexp(tools::min_value<T>(), tools::digits<T>() + 1);
+}
+template <class T>
+inline T calc_min_shifted(const mpl::false_&)
+{
+   BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_specialized);
+   BOOST_STATIC_ASSERT(std::numeric_limits<T>::radix != 2);
+
+   return scalbn(tools::min_value<T>(), std::numeric_limits<T>::digits + 1);
+}
+
 
 template <class T>
 inline T get_min_shift_value()
 {
-   BOOST_MATH_STD_USING
-   static const T val = ldexp(tools::min_value<T>(), tools::digits<T>() + 1);
+   static const T val = calc_min_shifted<T>(mpl::bool_<!std::numeric_limits<T>::is_specialized || std::numeric_limits<T>::radix == 2>());
    min_shift_initializer<T>::force_instantiate();
 
    return val;
 }
 
 template <class T, class Policy>
-T float_next_imp(const T& val, const Policy& pol)
+T float_next_imp(const T& val, const mpl::true_&, const Policy& pol)
 {
    BOOST_MATH_STD_USING
    int expon;
@@ -144,15 +208,63 @@ T float_next_imp(const T& val, const Policy& pol)
    if(diff == 0)
       diff = detail::get_smallest_value<T>();
    return val + diff;
-}
+} // float_next_imp
+//
+// Special version for some base other than 2:
+//
+template <class T, class Policy>
+T float_next_imp(const T& val, const mpl::false_&, const Policy& pol)
+{
+   BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_specialized);
+   BOOST_STATIC_ASSERT(std::numeric_limits<T>::radix != 2);
 
-}
+   BOOST_MATH_STD_USING
+   boost::intmax_t expon;
+   static const char* function = "float_next<%1%>(%1%)";
+
+   int fpclass = (boost::math::fpclassify)(val);
+
+   if((fpclass == (int)FP_NAN) || (fpclass == (int)FP_INFINITE))
+   {
+      if(val < 0)
+         return -tools::max_value<T>();
+      return policies::raise_domain_error<T>(
+         function,
+         "Argument must be finite, but got %1%", val, pol);
+   }
+
+   if(val >= tools::max_value<T>())
+      return policies::raise_overflow_error<T>(function, 0, pol);
+
+   if(val == 0)
+      return detail::get_smallest_value<T>();
+
+   if((fpclass != (int)FP_SUBNORMAL) && (fpclass != (int)FP_ZERO) && (fabs(val) < detail::get_min_shift_value<T>()) && (val != -tools::min_value<T>()))
+   {
+      //
+      // Special case: if the value of the least significant bit is a denorm, and the result
+      // would not be a denorm, then shift the input, increment, and shift back.
+      // This avoids issues with the Intel SSE2 registers when the FTZ or DAZ flags are set.
+      //
+      return scalbn(float_next(T(scalbn(val, 2 * std::numeric_limits<T>::digits)), pol), -2 * std::numeric_limits<T>::digits);
+   }
+
+   expon = 1 + ilogb(val);
+   if(-1 == scalbn(val, -expon) * std::numeric_limits<T>::radix)
+      --expon; // reduce exponent when val is a power of base, and negative.
+   T diff = scalbn(T(1), expon - std::numeric_limits<T>::digits);
+   if(diff == 0)
+      diff = detail::get_smallest_value<T>();
+   return val + diff;
+} // float_next_imp
+
+} // namespace detail
 
 template <class T, class Policy>
 inline typename tools::promote_args<T>::type float_next(const T& val, const Policy& pol)
 {
    typedef typename tools::promote_args<T>::type result_type;
-   return detail::float_next_imp(static_cast<result_type>(val), pol);
+   return detail::float_next_imp(detail::normalize_value(static_cast<result_type>(val), typename detail::has_hidden_guard_digits<result_type>::type()), mpl::bool_<!std::numeric_limits<result_type>::is_specialized || (std::numeric_limits<result_type>::radix == 2)>(), pol);
 }
 
 #if 0 //def BOOST_MSVC
@@ -187,7 +299,7 @@ inline typename tools::promote_args<T>::type float_next(const T& val)
 namespace detail{
 
 template <class T, class Policy>
-T float_prior_imp(const T& val, const Policy& pol)
+T float_prior_imp(const T& val, const mpl::true_&, const Policy& pol)
 {
    BOOST_MATH_STD_USING
    int expon;
@@ -221,21 +333,70 @@ T float_prior_imp(const T& val, const Policy& pol)
    }
 
    T remain = frexp(val, &expon);
-   if(remain == 0.5)
+   if(remain == 0.5f)
       --expon; // when val is a power of two we must reduce the exponent
    T diff = ldexp(T(1), expon - tools::digits<T>());
    if(diff == 0)
       diff = detail::get_smallest_value<T>();
    return val - diff;
-}
+} // float_prior_imp
+//
+// Special version for bases other than 2:
+//
+template <class T, class Policy>
+T float_prior_imp(const T& val, const mpl::false_&, const Policy& pol)
+{
+   BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_specialized);
+   BOOST_STATIC_ASSERT(std::numeric_limits<T>::radix != 2);
 
-}
+   BOOST_MATH_STD_USING
+   boost::intmax_t expon;
+   static const char* function = "float_prior<%1%>(%1%)";
+
+   int fpclass = (boost::math::fpclassify)(val);
+
+   if((fpclass == (int)FP_NAN) || (fpclass == (int)FP_INFINITE))
+   {
+      if(val > 0)
+         return tools::max_value<T>();
+      return policies::raise_domain_error<T>(
+         function,
+         "Argument must be finite, but got %1%", val, pol);
+   }
+
+   if(val <= -tools::max_value<T>())
+      return -policies::raise_overflow_error<T>(function, 0, pol);
+
+   if(val == 0)
+      return -detail::get_smallest_value<T>();
+
+   if((fpclass != (int)FP_SUBNORMAL) && (fpclass != (int)FP_ZERO) && (fabs(val) < detail::get_min_shift_value<T>()) && (val != tools::min_value<T>()))
+   {
+      //
+      // Special case: if the value of the least significant bit is a denorm, and the result
+      // would not be a denorm, then shift the input, increment, and shift back.
+      // This avoids issues with the Intel SSE2 registers when the FTZ or DAZ flags are set.
+      //
+      return scalbn(float_prior(T(scalbn(val, 2 * std::numeric_limits<T>::digits)), pol), -2 * std::numeric_limits<T>::digits);
+   }
+
+   expon = 1 + ilogb(val);
+   T remain = scalbn(val, -expon);
+   if(remain * std::numeric_limits<T>::radix == 1)
+      --expon; // when val is a power of two we must reduce the exponent
+   T diff = scalbn(T(1), expon - std::numeric_limits<T>::digits);
+   if(diff == 0)
+      diff = detail::get_smallest_value<T>();
+   return val - diff;
+} // float_prior_imp
+
+} // namespace detail
 
 template <class T, class Policy>
 inline typename tools::promote_args<T>::type float_prior(const T& val, const Policy& pol)
 {
    typedef typename tools::promote_args<T>::type result_type;
-   return detail::float_prior_imp(static_cast<result_type>(val), pol);
+   return detail::float_prior_imp(detail::normalize_value(static_cast<result_type>(val), typename detail::has_hidden_guard_digits<result_type>::type()), mpl::bool_<!std::numeric_limits<result_type>::is_specialized || (std::numeric_limits<result_type>::radix == 2)>(), pol);
 }
 
 #if 0 //def BOOST_MSVC
@@ -283,7 +444,7 @@ inline typename tools::promote_args<T, U>::type nextafter(const T& val, const U&
 namespace detail{
 
 template <class T, class Policy>
-T float_distance_imp(const T& a, const T& b, const Policy& pol)
+T float_distance_imp(const T& a, const T& b, const mpl::true_&, const Policy& pol)
 {
    BOOST_MATH_STD_USING
    //
@@ -304,7 +465,7 @@ T float_distance_imp(const T& a, const T& b, const Policy& pol)
    if(a > b)
       return -float_distance(b, a, pol);
    if(a == b)
-      return 0;
+      return T(0);
    if(a == 0)
       return 1 + fabs(float_distance(static_cast<T>((b < 0) ? T(-detail::get_smallest_value<T>()) : detail::get_smallest_value<T>()), b, pol));
    if(b == 0)
@@ -330,20 +491,24 @@ T float_distance_imp(const T& a, const T& b, const Policy& pol)
    //
    frexp(((boost::math::fpclassify)(a) == (int)FP_SUBNORMAL) ? tools::min_value<T>() : a, &expon);
    T upper = ldexp(T(1), expon);
-   T result = 0;
-   expon = tools::digits<T>() - expon;
+   T result = T(0);
    //
    // If b is greater than upper, then we *must* split the calculation
    // as the size of the ULP changes with each order of magnitude change:
    //
    if(b > upper)
    {
-      result = float_distance(upper, b);
+      int expon2;
+      frexp(b, &expon2);
+      T upper2 = ldexp(T(0.5), expon2);
+      result = float_distance(upper2, b);
+      result += (expon2 - expon - 1) * ldexp(T(1), tools::digits<T>() - 1);
    }
    //
    // Use compensated double-double addition to avoid rounding
    // errors in the subtraction:
    //
+   expon = tools::digits<T>() - expon;
    T mb, x, y, z;
    if(((boost::math::fpclassify)(a) == (int)FP_SUBNORMAL) || (b - a < tools::min_value<T>()))
    {
@@ -379,15 +544,122 @@ T float_distance_imp(const T& a, const T& b, const Policy& pol)
    //
    BOOST_ASSERT(result == floor(result));
    return result;
-}
+} // float_distance_imp
+//
+// Special versions for bases other than 2:
+//
+template <class T, class Policy>
+T float_distance_imp(const T& a, const T& b, const mpl::false_&, const Policy& pol)
+{
+   BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_specialized);
+   BOOST_STATIC_ASSERT(std::numeric_limits<T>::radix != 2);
 
-}
+   BOOST_MATH_STD_USING
+   //
+   // Error handling:
+   //
+   static const char* function = "float_distance<%1%>(%1%, %1%)";
+   if(!(boost::math::isfinite)(a))
+      return policies::raise_domain_error<T>(
+         function,
+         "Argument a must be finite, but got %1%", a, pol);
+   if(!(boost::math::isfinite)(b))
+      return policies::raise_domain_error<T>(
+         function,
+         "Argument b must be finite, but got %1%", b, pol);
+   //
+   // Special cases:
+   //
+   if(a > b)
+      return -float_distance(b, a, pol);
+   if(a == b)
+      return T(0);
+   if(a == 0)
+      return 1 + fabs(float_distance(static_cast<T>((b < 0) ? T(-detail::get_smallest_value<T>()) : detail::get_smallest_value<T>()), b, pol));
+   if(b == 0)
+      return 1 + fabs(float_distance(static_cast<T>((a < 0) ? T(-detail::get_smallest_value<T>()) : detail::get_smallest_value<T>()), a, pol));
+   if(boost::math::sign(a) != boost::math::sign(b))
+      return 2 + fabs(float_distance(static_cast<T>((b < 0) ? T(-detail::get_smallest_value<T>()) : detail::get_smallest_value<T>()), b, pol))
+         + fabs(float_distance(static_cast<T>((a < 0) ? T(-detail::get_smallest_value<T>()) : detail::get_smallest_value<T>()), a, pol));
+   //
+   // By the time we get here, both a and b must have the same sign, we want
+   // b > a and both postive for the following logic:
+   //
+   if(a < 0)
+      return float_distance(static_cast<T>(-b), static_cast<T>(-a), pol);
+
+   BOOST_ASSERT(a >= 0);
+   BOOST_ASSERT(b >= a);
+
+   boost::intmax_t expon;
+   //
+   // Note that if a is a denorm then the usual formula fails
+   // because we actually have fewer than tools::digits<T>()
+   // significant bits in the representation:
+   //
+   expon = 1 + ilogb(((boost::math::fpclassify)(a) == (int)FP_SUBNORMAL) ? tools::min_value<T>() : a);
+   T upper = scalbn(T(1), expon);
+   T result = T(0);
+   //
+   // If b is greater than upper, then we *must* split the calculation
+   // as the size of the ULP changes with each order of magnitude change:
+   //
+   if(b > upper)
+   {
+      boost::intmax_t expon2 = 1 + ilogb(b);
+      T upper2 = scalbn(T(1), expon2 - 1);
+      result = float_distance(upper2, b);
+      result += (expon2 - expon - 1) * scalbn(T(1), std::numeric_limits<T>::digits - 1);
+   }
+   //
+   // Use compensated double-double addition to avoid rounding
+   // errors in the subtraction:
+   //
+   expon = std::numeric_limits<T>::digits - expon;
+   T mb, x, y, z;
+   if(((boost::math::fpclassify)(a) == (int)FP_SUBNORMAL) || (b - a < tools::min_value<T>()))
+   {
+      //
+      // Special case - either one end of the range is a denormal, or else the difference is.
+      // The regular code will fail if we're using the SSE2 registers on Intel and either
+      // the FTZ or DAZ flags are set.
+      //
+      T a2 = scalbn(a, std::numeric_limits<T>::digits);
+      T b2 = scalbn(b, std::numeric_limits<T>::digits);
+      mb = -(std::min)(T(scalbn(upper, std::numeric_limits<T>::digits)), b2);
+      x = a2 + mb;
+      z = x - a2;
+      y = (a2 - (x - z)) + (mb - z);
+
+      expon -= std::numeric_limits<T>::digits;
+   }
+   else
+   {
+      mb = -(std::min)(upper, b);
+      x = a + mb;
+      z = x - a;
+      y = (a - (x - z)) + (mb - z);
+   }
+   if(x < 0)
+   {
+      x = -x;
+      y = -y;
+   }
+   result += scalbn(x, expon) + scalbn(y, expon);
+   //
+   // Result must be an integer:
+   //
+   BOOST_ASSERT(result == floor(result));
+   return result;
+} // float_distance_imp
+
+} // namespace detail
 
 template <class T, class U, class Policy>
 inline typename tools::promote_args<T, U>::type float_distance(const T& a, const U& b, const Policy& pol)
 {
    typedef typename tools::promote_args<T, U>::type result_type;
-   return detail::float_distance_imp(static_cast<result_type>(a), static_cast<result_type>(b), pol);
+   return detail::float_distance_imp(detail::normalize_value(static_cast<result_type>(a), typename detail::has_hidden_guard_digits<result_type>::type()), detail::normalize_value(static_cast<result_type>(b), typename detail::has_hidden_guard_digits<result_type>::type()), mpl::bool_<!std::numeric_limits<result_type>::is_specialized || (std::numeric_limits<result_type>::radix == 2)>(), pol);
 }
 
 template <class T, class U>
@@ -399,7 +671,7 @@ typename tools::promote_args<T, U>::type float_distance(const T& a, const U& b)
 namespace detail{
 
 template <class T, class Policy>
-T float_advance_imp(T val, int distance, const Policy& pol)
+T float_advance_imp(T val, int distance, const mpl::true_&, const Policy& pol)
 {
    BOOST_MATH_STD_USING
    //
@@ -477,15 +749,101 @@ T float_advance_imp(T val, int distance, const Policy& pol)
    if(diff == 0)
       diff = distance * detail::get_smallest_value<T>();
    return val += diff;
-}
+} // float_advance_imp
+//
+// Special version for bases other than 2:
+//
+template <class T, class Policy>
+T float_advance_imp(T val, int distance, const mpl::false_&, const Policy& pol)
+{
+   BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_specialized);
+   BOOST_STATIC_ASSERT(std::numeric_limits<T>::radix != 2);
 
-}
+   BOOST_MATH_STD_USING
+   //
+   // Error handling:
+   //
+   static const char* function = "float_advance<%1%>(%1%, int)";
+
+   int fpclass = (boost::math::fpclassify)(val);
+
+   if((fpclass == (int)FP_NAN) || (fpclass == (int)FP_INFINITE))
+      return policies::raise_domain_error<T>(
+         function,
+         "Argument val must be finite, but got %1%", val, pol);
+
+   if(val < 0)
+      return -float_advance(-val, -distance, pol);
+   if(distance == 0)
+      return val;
+   if(distance == 1)
+      return float_next(val, pol);
+   if(distance == -1)
+      return float_prior(val, pol);
+
+   if(fabs(val) < detail::get_min_shift_value<T>())
+   {
+      //
+      // Special case: if the value of the least significant bit is a denorm,
+      // implement in terms of float_next/float_prior.
+      // This avoids issues with the Intel SSE2 registers when the FTZ or DAZ flags are set.
+      //
+      if(distance > 0)
+      {
+         do{ val = float_next(val, pol); } while(--distance);
+      }
+      else
+      {
+         do{ val = float_prior(val, pol); } while(++distance);
+      }
+      return val;
+   }
+
+   boost::intmax_t expon = 1 + ilogb(val);
+   T limit = scalbn(T(1), distance < 0 ? expon - 1 : expon);
+   if(val <= tools::min_value<T>())
+   {
+      limit = sign(T(distance)) * tools::min_value<T>();
+   }
+   T limit_distance = float_distance(val, limit);
+   while(fabs(limit_distance) < abs(distance))
+   {
+      distance -= itrunc(limit_distance);
+      val = limit;
+      if(distance < 0)
+      {
+         limit /= std::numeric_limits<T>::radix;
+         expon--;
+      }
+      else
+      {
+         limit *= std::numeric_limits<T>::radix;
+         expon++;
+      }
+      limit_distance = float_distance(val, limit);
+      if(distance && (limit_distance == 0))
+      {
+         return policies::raise_evaluation_error<T>(function, "Internal logic failed while trying to increment floating point value %1%: most likely your FPU is in non-IEEE conforming mode.", val, pol);
+      }
+   }
+   /*expon = 1 + ilogb(val);
+   if((1 == scalbn(val, 1 + expon)) && (distance < 0))
+      --expon;*/
+   T diff = 0;
+   if(val != 0)
+      diff = distance * scalbn(T(1), expon - std::numeric_limits<T>::digits);
+   if(diff == 0)
+      diff = distance * detail::get_smallest_value<T>();
+   return val += diff;
+} // float_advance_imp
+
+} // namespace detail
 
 template <class T, class Policy>
 inline typename tools::promote_args<T>::type float_advance(T val, int distance, const Policy& pol)
 {
    typedef typename tools::promote_args<T>::type result_type;
-   return detail::float_advance_imp(static_cast<result_type>(val), distance, pol);
+   return detail::float_advance_imp(detail::normalize_value(static_cast<result_type>(val), typename detail::has_hidden_guard_digits<result_type>::type()), distance, mpl::bool_<!std::numeric_limits<result_type>::is_specialized || (std::numeric_limits<result_type>::radix == 2)>(), pol);
 }
 
 template <class T>
@@ -494,7 +852,7 @@ inline typename tools::promote_args<T>::type float_advance(const T& val, int dis
    return boost::math::float_advance(val, distance, policies::policy<>());
 }
 
-}} // namespaces
+}} // boost math namespaces
 
 #endif // BOOST_MATH_SPECIAL_NEXT_HPP
 
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/nonfinite_num_facets.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/nonfinite_num_facets.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/nonfinite_num_facets.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/nonfinite_num_facets.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/owens_t.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/owens_t.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/owens_t.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/owens_t.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/polygamma.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/polygamma.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/polygamma.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/polygamma.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/pow.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/pow.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/pow.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/pow.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/powm1.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/powm1.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/powm1.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/powm1.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/prime.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/prime.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/prime.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/prime.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/relative_difference.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/relative_difference.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/relative_difference.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/relative_difference.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/round.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/round.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/round.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/round.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/sign.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/sign.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/sign.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/sign.hpp
index 3324c90a879..5cb21bac54a 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/special_functions/sign.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/sign.hpp
@@ -27,7 +27,7 @@ namespace detail {
     template<class T> 
     inline int signbit_impl(T x, native_tag const&)
     {
-        return (std::signbit)(x);
+        return (std::signbit)(x) ? 1 : 0;
     }
 #endif
 
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/sin_pi.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/sin_pi.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/sin_pi.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/sin_pi.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/sinc.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/sinc.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/sinc.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/sinc.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/sinhc.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/sinhc.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/sinhc.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/sinhc.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/spherical_harmonic.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/spherical_harmonic.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/spherical_harmonic.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/spherical_harmonic.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/sqrt1pm1.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/sqrt1pm1.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/sqrt1pm1.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/sqrt1pm1.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/trigamma.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/trigamma.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/trigamma.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/trigamma.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/trunc.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/trunc.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/trunc.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/trunc.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/ulp.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/ulp.hpp
similarity index 57%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/ulp.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/ulp.hpp
index 3d78a1c7c2c..bb0332a7e08 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/special_functions/ulp.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/special_functions/ulp.hpp
@@ -18,7 +18,7 @@
 namespace boost{ namespace math{ namespace detail{
 
 template <class T, class Policy>
-T ulp_imp(const T& val, const Policy& pol)
+T ulp_imp(const T& val, const mpl::true_&, const Policy& pol)
 {
    BOOST_MATH_STD_USING
    int expon;
@@ -48,6 +48,40 @@ T ulp_imp(const T& val, const Policy& pol)
       diff = detail::get_smallest_value<T>();
    return diff;
 }
+// non-binary version:
+template <class T, class Policy>
+T ulp_imp(const T& val, const mpl::false_&, const Policy& pol)
+{
+   BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_specialized);
+   BOOST_STATIC_ASSERT(std::numeric_limits<T>::radix != 2);
+   BOOST_MATH_STD_USING
+   int expon;
+   static const char* function = "ulp<%1%>(%1%)";
+
+   int fpclass = (boost::math::fpclassify)(val);
+
+   if(fpclass == (int)FP_NAN)
+   {
+      return policies::raise_domain_error<T>(
+         function,
+         "Argument must be finite, but got %1%", val, pol);
+   }
+   else if((fpclass == (int)FP_INFINITE) || (fabs(val) >= tools::max_value<T>()))
+   {
+      return (val < 0 ? -1 : 1) * policies::raise_overflow_error<T>(function, 0, pol);
+   }
+   else if(fpclass == FP_ZERO)
+      return detail::get_smallest_value<T>();
+   //
+   // This code is almost the same as that for float_next, except for negative integers,
+   // where we preserve the relation ulp(x) == ulp(-x) as does Java:
+   //
+   expon = 1 + ilogb(fabs(val));
+   T diff = scalbn(T(1), expon - std::numeric_limits<T>::digits);
+   if(diff == 0)
+      diff = detail::get_smallest_value<T>();
+   return diff;
+}
 
 }
 
@@ -55,7 +89,7 @@ template <class T, class Policy>
 inline typename tools::promote_args<T>::type ulp(const T& val, const Policy& pol)
 {
    typedef typename tools::promote_args<T>::type result_type;
-   return detail::ulp_imp(static_cast<result_type>(val), pol);
+   return detail::ulp_imp(static_cast<result_type>(val), mpl::bool_<!std::numeric_limits<result_type>::is_specialized || (std::numeric_limits<result_type>::radix == 2)>(), pol);
 }
 
 template <class T>
diff --git a/contrib/libboost/boost_1_62_0/boost/math/special_functions/zeta.hpp b/contrib/libboost/boost_1_65_0/boost/math/special_functions/zeta.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/special_functions/zeta.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/special_functions/zeta.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/big_constant.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/big_constant.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/big_constant.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/big_constant.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/config.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/config.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/config.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/config.hpp
index 32375e6a6e5..8131facb985 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/tools/config.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/tools/config.hpp
@@ -31,7 +31,7 @@
 #if (defined(__CYGWIN__) || defined(__FreeBSD__) || defined(__NetBSD__) \
    || (defined(__hppa) && !defined(__OpenBSD__)) || (defined(__NO_LONG_DOUBLE_MATH) && (DBL_MANT_DIG != LDBL_MANT_DIG))) \
    && !defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS)
-#  define BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
+//#  define BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
 #endif
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
 //
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/convert_from_string.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/convert_from_string.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/convert_from_string.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/convert_from_string.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_10.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_10.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_10.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_10.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_11.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_11.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_11.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_11.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_12.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_12.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_12.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_12.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_13.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_13.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_13.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_13.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_14.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_14.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_14.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_14.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_15.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_15.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_15.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_15.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_16.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_16.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_16.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_16.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_17.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_17.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_17.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_17.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_18.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_18.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_18.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_18.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_19.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_19.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_19.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_19.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_2.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_2.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_2.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_2.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_20.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_20.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_20.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_20.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_3.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_3.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_3.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_3.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_4.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_4.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_4.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_4.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_5.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_5.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_5.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_5.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_6.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_6.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_6.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_6.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_7.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_7.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_7.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_7.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_8.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_8.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_8.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_8.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_9.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_9.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner1_9.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner1_9.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_10.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_10.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_10.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_10.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_11.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_11.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_11.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_11.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_12.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_12.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_12.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_12.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_13.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_13.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_13.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_13.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_14.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_14.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_14.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_14.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_15.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_15.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_15.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_15.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_16.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_16.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_16.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_16.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_17.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_17.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_17.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_17.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_18.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_18.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_18.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_18.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_19.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_19.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_19.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_19.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_2.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_2.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_2.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_2.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_20.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_20.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_20.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_20.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_3.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_3.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_3.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_3.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_4.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_4.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_4.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_4.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_5.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_5.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_5.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_5.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_6.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_6.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_6.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_6.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_7.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_7.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_7.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_7.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_8.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_8.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_8.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_8.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_9.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_9.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner2_9.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner2_9.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_10.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_10.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_10.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_10.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_11.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_11.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_11.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_11.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_12.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_12.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_12.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_12.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_13.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_13.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_13.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_13.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_14.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_14.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_14.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_14.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_15.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_15.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_15.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_15.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_16.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_16.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_16.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_16.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_17.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_17.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_17.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_17.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_18.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_18.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_18.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_18.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_19.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_19.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_19.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_19.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_2.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_2.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_2.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_2.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_20.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_20.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_20.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_20.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_3.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_3.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_3.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_3.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_4.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_4.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_4.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_4.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_5.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_5.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_5.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_5.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_6.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_6.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_6.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_6.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_7.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_7.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_7.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_7.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_8.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_8.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_8.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_8.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_9.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_9.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/polynomial_horner3_9.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/polynomial_horner3_9.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_10.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_10.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_10.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_10.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_11.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_11.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_11.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_11.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_12.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_12.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_12.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_12.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_13.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_13.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_13.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_13.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_14.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_14.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_14.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_14.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_15.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_15.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_15.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_15.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_16.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_16.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_16.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_16.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_17.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_17.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_17.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_17.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_18.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_18.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_18.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_18.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_19.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_19.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_19.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_19.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_2.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_2.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_2.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_2.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_20.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_20.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_20.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_20.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_3.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_3.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_3.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_3.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_4.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_4.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_4.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_4.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_5.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_5.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_5.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_5.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_6.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_6.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_6.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_6.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_7.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_7.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_7.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_7.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_8.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_8.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_8.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_8.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_9.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_9.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner1_9.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner1_9.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_10.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_10.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_10.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_10.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_11.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_11.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_11.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_11.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_12.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_12.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_12.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_12.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_13.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_13.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_13.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_13.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_14.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_14.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_14.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_14.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_15.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_15.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_15.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_15.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_16.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_16.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_16.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_16.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_17.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_17.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_17.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_17.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_18.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_18.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_18.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_18.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_19.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_19.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_19.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_19.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_2.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_2.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_2.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_2.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_20.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_20.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_20.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_20.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_3.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_3.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_3.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_3.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_4.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_4.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_4.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_4.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_5.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_5.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_5.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_5.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_6.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_6.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_6.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_6.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_7.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_7.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_7.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_7.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_8.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_8.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_8.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_8.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_9.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_9.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner2_9.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner2_9.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_10.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_10.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_10.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_10.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_11.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_11.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_11.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_11.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_12.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_12.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_12.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_12.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_13.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_13.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_13.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_13.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_14.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_14.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_14.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_14.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_15.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_15.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_15.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_15.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_16.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_16.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_16.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_16.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_17.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_17.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_17.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_17.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_18.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_18.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_18.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_18.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_19.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_19.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_19.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_19.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_2.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_2.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_2.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_2.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_20.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_20.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_20.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_20.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_3.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_3.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_3.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_3.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_4.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_4.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_4.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_4.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_5.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_5.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_5.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_5.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_6.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_6.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_6.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_6.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_7.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_7.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_7.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_7.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_8.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_8.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_8.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_8.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_9.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_9.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/detail/rational_horner3_9.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/detail/rational_horner3_9.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/fraction.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/fraction.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/fraction.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/fraction.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/minima.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/minima.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/minima.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/minima.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/polynomial.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/polynomial.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/polynomial.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/polynomial.hpp
index c81a05caa4d..56c4e6895ed 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/tools/polynomial.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/tools/polynomial.hpp
@@ -15,7 +15,6 @@
 
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
-#include <boost/config/suffix.hpp>
 #include <boost/function.hpp>
 #include <boost/lambda/lambda.hpp>
 #include <boost/math/tools/rational.hpp>
@@ -337,7 +336,7 @@ public:
    }
    T evaluate(T z)const
    {
-      return boost::math::tools::evaluate_polynomial(&m_data[0], z, m_data.size());;
+      return m_data.size() > 0 ? boost::math::tools::evaluate_polynomial(&m_data[0], z, m_data.size()) : 0;
    }
    std::vector<T> chebyshev()const
    {
@@ -713,6 +712,11 @@ inline std::basic_ostream<charT, traits>& operator << (std::basic_ostream<charT,
 } // namespace math
 } // namespace boost
 
+//
+// Polynomial specific overload of gcd algorithm:
+//
+#include <boost/math/tools/polynomial_gcd.hpp>
+
 #endif // BOOST_MATH_TOOLS_POLYNOMIAL_HPP
 
 
diff --git a/contrib/libboost/boost_1_65_0/boost/math/tools/polynomial_gcd.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/polynomial_gcd.hpp
new file mode 100644
index 00000000000..fdbafda6ca0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/math/tools/polynomial_gcd.hpp
@@ -0,0 +1,209 @@
+//  (C) Copyright Jeremy William Murphy 2016.
+
+//  Use, modification and distribution are subject to the
+//  Boost Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_MATH_TOOLS_POLYNOMIAL_GCD_HPP
+#define BOOST_MATH_TOOLS_POLYNOMIAL_GCD_HPP
+
+#ifdef _MSC_VER
+#pragma once
+#endif
+
+#include <boost/math/tools/polynomial.hpp>
+#include <boost/math/common_factor_rt.hpp>
+#include <boost/type_traits/is_pod.hpp>
+
+
+namespace boost{ 
+   
+   namespace integer {
+
+      namespace gcd_detail {
+
+         template <class T>
+         struct gcd_traits;
+
+         template <class T>
+         struct gcd_traits<boost::math::tools::polynomial<T> >
+         {
+            inline static const boost::math::tools::polynomial<T>& abs(const boost::math::tools::polynomial<T>& val) { return val; }
+
+            static const method_type method = method_euclid;
+         };
+
+      }
+}
+   
+   
+   
+namespace math{ namespace tools{
+    
+/* From Knuth, 4.6.1:
+* 
+* We may write any nonzero polynomial u(x) from R[x] where R is a UFD as
+*
+*      u(x) = cont(u) · pp(u(x))
+*
+* where cont(u), the content of u, is an element of S, and pp(u(x)), the primitive
+* part of u(x), is a primitive polynomial over S. 
+* When u(x) = 0, it is convenient to define cont(u) = pp(u(x)) = O.
+*/
+
+template <class T>
+T content(polynomial<T> const &x)
+{
+    return x ? gcd_range(x.data().begin(), x.data().end()).first : T(0);
+}
+
+// Knuth, 4.6.1
+template <class T>
+polynomial<T> primitive_part(polynomial<T> const &x, T const &cont)
+{
+    return x ? x / cont : polynomial<T>();
+}
+
+
+template <class T>
+polynomial<T> primitive_part(polynomial<T> const &x)
+{
+    return primitive_part(x, content(x));
+}
+
+
+// Trivial but useful convenience function referred to simply as l() in Knuth.
+template <class T>
+T leading_coefficient(polynomial<T> const &x)
+{
+    return x ? x.data().back() : T(0);
+}
+
+
+namespace detail
+{
+    /* Reduce u and v to their primitive parts and return the gcd of their 
+    * contents. Used in a couple of gcd algorithms.
+    */
+    template <class T>
+    T reduce_to_primitive(polynomial<T> &u, polynomial<T> &v)
+    {
+        using boost::math::gcd;
+        T const u_cont = content(u), v_cont = content(v);
+        u /= u_cont;
+        v /= v_cont;
+        return gcd(u_cont, v_cont);
+    }
+}
+
+
+/**
+* Knuth, The Art of Computer Programming: Volume 2, Third edition, 1998
+* Algorithm 4.6.1C: Greatest common divisor over a unique factorization domain.
+* 
+* The subresultant algorithm by George E. Collins [JACM 14 (1967), 128-142], 
+* later improved by W. S. Brown and J. F. Traub [JACM 18 (1971), 505-514].
+* 
+* Although step C3 keeps the coefficients to a "reasonable" size, they are
+* still potentially several binary orders of magnitude larger than the inputs.
+* Thus, this algorithm should only be used where T is a multi-precision type.
+* 
+* @tparam   T   Polynomial coefficient type.
+* @param    u   First polynomial.
+* @param    v   Second polynomial.
+* @return       Greatest common divisor of polynomials u and v.
+*/
+template <class T>
+typename enable_if_c< std::numeric_limits<T>::is_integer, polynomial<T> >::type
+subresultant_gcd(polynomial<T> u, polynomial<T> v)
+{
+    using std::swap;
+    BOOST_ASSERT(u || v);
+    
+    if (!u)
+        return v;
+    if (!v)
+        return u;
+    
+    typedef typename polynomial<T>::size_type N;
+    
+    if (u.degree() < v.degree())
+        swap(u, v);
+    
+    T const d = detail::reduce_to_primitive(u, v);
+    T g = 1, h = 1;
+    polynomial<T> r;
+    while (true)
+    {
+        BOOST_ASSERT(u.degree() >= v.degree());
+        // Pseudo-division.
+        r = u % v;
+        if (!r)
+            return d * primitive_part(v); // Attach the content.
+        if (r.degree() == 0)
+            return d * polynomial<T>(T(1)); // The content is the result.
+        N const delta = u.degree() - v.degree();
+        // Adjust remainder.
+        u = v;
+        v = r / (g * detail::integer_power(h, delta));
+        g = leading_coefficient(u);
+        T const tmp = detail::integer_power(g, delta);
+        if (delta <= N(1))
+            h = tmp * detail::integer_power(h, N(1) - delta);
+        else
+            h = tmp / detail::integer_power(h, delta - N(1));
+    }
+}
+ 
+ 
+/**
+ * @brief GCD for polynomials with unbounded multi-precision integral coefficients.
+ * 
+ * The multi-precision constraint is enforced via numeric_limits.
+ *
+ * Note that intermediate terms in the evaluation can grow arbitrarily large, hence the need for
+ * unbounded integers, otherwise numeric loverflow would break the algorithm.
+ * 
+ * @tparam  T   A multi-precision integral type.
+ */
+template <typename T>
+typename enable_if_c<std::numeric_limits<T>::is_integer && !std::numeric_limits<T>::is_bounded, polynomial<T> >::type
+gcd(polynomial<T> const &u, polynomial<T> const &v)
+{
+    return subresultant_gcd(u, v);
+}
+// GCD over bounded integers is not currently allowed:
+template <typename T>
+typename enable_if_c<std::numeric_limits<T>::is_integer && std::numeric_limits<T>::is_bounded, polynomial<T> >::type
+gcd(polynomial<T> const &u, polynomial<T> const &v)
+{
+   BOOST_STATIC_ASSERT_MSG(sizeof(v) == 0, "GCD on polynomials of bounded integers is disallowed due to the excessive growth in the size of intermediate terms.");
+   return subresultant_gcd(u, v);
+}
+// GCD over polynomials of floats can go via the Euclid algorithm:
+template <typename T>
+typename enable_if_c<!std::numeric_limits<T>::is_integer && (std::numeric_limits<T>::min_exponent != std::numeric_limits<T>::max_exponent) && !std::numeric_limits<T>::is_exact, polynomial<T> >::type
+gcd(polynomial<T> const &u, polynomial<T> const &v)
+{
+   return boost::integer::gcd_detail::Euclid_gcd(u, v);
+}
+
+}
+//
+// Using declaration so we overload the default implementation in this namespace:
+//
+using boost::math::tools::gcd;
+
+}
+
+namespace integer
+{
+   //
+   // Using declaration so we overload the default implementation in this namespace:
+   //
+   using boost::math::tools::gcd;
+}
+
+} // namespace boost::math::tools
+
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/precision.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/precision.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/precision.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/precision.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/promotion.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/promotion.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/promotion.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/promotion.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/rational.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/rational.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/rational.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/rational.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/real_cast.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/real_cast.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/real_cast.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/real_cast.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/roots.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/roots.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/roots.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/roots.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/series.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/series.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/series.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/series.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/stats.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/stats.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/stats.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/stats.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/toms748_solve.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/toms748_solve.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/toms748_solve.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/toms748_solve.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/traits.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/tuple.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/tuple.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/tuple.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/tuple.hpp
index 5723f813383..81de59fa3ab 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/tools/tuple.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/tools/tuple.hpp
@@ -6,6 +6,7 @@
 #ifndef BOOST_MATH_TUPLE_HPP_INCLUDED
 #  define BOOST_MATH_TUPLE_HPP_INCLUDED
 #  include <boost/config.hpp>
+#  include <boost/detail/workaround.hpp>
 
 #if !defined(BOOST_NO_CXX11_HDR_TUPLE) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500)
 
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/user.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/user.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/user.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/user.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tools/workaround.hpp b/contrib/libboost/boost_1_65_0/boost/math/tools/workaround.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tools/workaround.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tools/workaround.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tr1.hpp b/contrib/libboost/boost_1_65_0/boost/math/tr1.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/math/tr1.hpp
rename to contrib/libboost/boost_1_65_0/boost/math/tr1.hpp
index eae9216d042..bb5f8514632 100644
--- a/contrib/libboost/boost_1_62_0/boost/math/tr1.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/math/tr1.hpp
@@ -673,7 +673,7 @@ inline long double nexttoward BOOST_PREVENT_MACRO_SUBSTITUTION(long double x, lo
 { return boost::math::tr1::nexttowardl BOOST_PREVENT_MACRO_SUBSTITUTION(x, y); }
 template <class T1, class T2>
 inline typename tools::promote_args<T1, T2>::type nexttoward BOOST_PREVENT_MACRO_SUBSTITUTION(T1 x, T2 y)
-{ return boost::math::tr1::nexttoward BOOST_PREVENT_MACRO_SUBSTITUTION(static_cast<typename tools::promote_args<T1, T2>::type>(x), static_cast<long double>(y)); }
+{ return static_cast<typename tools::promote_args<T1, T2>::type>(boost::math::tr1::nexttoward BOOST_PREVENT_MACRO_SUBSTITUTION(static_cast<typename tools::promote_args<T1, T2>::type>(x), static_cast<long double>(y))); }
 #if 0
 double remainder BOOST_PREVENT_MACRO_SUBSTITUTION(double x, double y);
 float remainderf BOOST_PREVENT_MACRO_SUBSTITUTION(float x, float y);
diff --git a/contrib/libboost/boost_1_62_0/boost/math/tr1_c_macros.ipp b/contrib/libboost/boost_1_65_0/boost/math/tr1_c_macros.ipp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/math/tr1_c_macros.ipp
rename to contrib/libboost/boost_1_65_0/boost/math/tr1_c_macros.ipp
diff --git a/contrib/libboost/boost_1_62_0/boost/mem_fn.hpp b/contrib/libboost/boost_1_65_0/boost/mem_fn.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mem_fn.hpp
rename to contrib/libboost/boost_1_65_0/boost/mem_fn.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/move/adl_move_swap.hpp b/contrib/libboost/boost_1_65_0/boost/move/adl_move_swap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/move/adl_move_swap.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/adl_move_swap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/move/algo/adaptive_merge.hpp b/contrib/libboost/boost_1_65_0/boost/move/algo/adaptive_merge.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/move/algo/adaptive_merge.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/algo/adaptive_merge.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/move/algo/adaptive_sort.hpp b/contrib/libboost/boost_1_65_0/boost/move/algo/adaptive_sort.hpp
similarity index 85%
rename from contrib/libboost/boost_1_62_0/boost/move/algo/adaptive_sort.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/algo/adaptive_sort.hpp
index 6b5586e5870..c96ab2d78b8 100644
--- a/contrib/libboost/boost_1_62_0/boost/move/algo/adaptive_sort.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/move/algo/adaptive_sort.hpp
@@ -43,18 +43,25 @@ namespace movelib {
 //!   ceil(sqrt(std::distance(first, last)))*2.
 //!
 //! <b>Caution</b>: Experimental implementation, not production-ready.
-template<class RandIt, class Compare>
+template<class RandIt, class RandRawIt, class Compare>
 void adaptive_sort( RandIt first, RandIt last, Compare comp
-               , typename iterator_traits<RandIt>::value_type* uninitialized = 0
-               , std::size_t uninitialized_len = 0)
+               , RandRawIt uninitialized
+               , std::size_t uninitialized_len)
 {
    typedef typename iterator_traits<RandIt>::size_type  size_type;
    typedef typename iterator_traits<RandIt>::value_type value_type;
 
-   ::boost::movelib::detail_adaptive::adaptive_xbuf<value_type> xbuf(uninitialized, uninitialized_len);
+   ::boost::movelib::detail_adaptive::adaptive_xbuf<value_type, RandRawIt> xbuf(uninitialized, uninitialized_len);
    ::boost::movelib::detail_adaptive::adaptive_sort_impl(first, size_type(last - first), comp, xbuf);
 }
 
+template<class RandIt, class Compare>
+void adaptive_sort( RandIt first, RandIt last, Compare comp)
+{
+   typedef typename iterator_traits<RandIt>::value_type value_type;
+   adaptive_sort(first, last, comp, (value_type*)0, 0u);
+}
+
 }  //namespace movelib {
 }  //namespace boost {
 
diff --git a/contrib/libboost/boost_1_62_0/boost/move/algo/detail/adaptive_sort_merge.hpp b/contrib/libboost/boost_1_65_0/boost/move/algo/detail/adaptive_sort_merge.hpp
similarity index 60%
rename from contrib/libboost/boost_1_62_0/boost/move/algo/detail/adaptive_sort_merge.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/algo/detail/adaptive_sort_merge.hpp
index 3d97212a29c..60b5e7b06c5 100644
--- a/contrib/libboost/boost_1_62_0/boost/move/algo/detail/adaptive_sort_merge.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/move/algo/detail/adaptive_sort_merge.hpp
@@ -29,8 +29,7 @@
 //   phase can form up to sqrt(len)*4 segments if enough keys are found.
 // - The merge-sort phase can take advantage of external memory to
 //   save some additional combination steps.
-// - Optimized comparisons when selection-sorting blocks as A and B blocks
-//   are already sorted.
+// - Combination phase: Blocks are selection sorted and merged in parallel.
 // - The combination phase is performed alternating merge to left and merge
 //   to right phases minimizing swaps due to internal buffer repositioning.
 // - When merging blocks special optimizations are made to avoid moving some
@@ -38,8 +37,7 @@
 //
 // The adaptive_merge algorithm was developed by Ion Gaztanaga reusing some parts
 // from the sorting algorithm and implementing an additional block merge algorithm
-// without moving elements to left or right, which is used when external memory
-// is available.
+// without moving elements to left or right.
 //////////////////////////////////////////////////////////////////////////////
 #ifndef BOOST_MOVE_ADAPTIVE_SORT_MERGE_HPP
 #define BOOST_MOVE_ADAPTIVE_SORT_MERGE_HPP
@@ -63,6 +61,14 @@
    #define BOOST_MOVE_ADAPTIVE_SORT_PRINT(STR, L)
 #endif
 
+#ifdef BOOST_MOVE_ADAPTIVE_SORT_INVARIANTS
+   #define BOOST_MOVE_ADAPTIVE_SORT_INVARIANT  BOOST_ASSERT
+#else
+   #define BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(L)
+#endif
+
+
+
 namespace boost {
 namespace movelib {
 
@@ -90,20 +96,78 @@ const T &max_value(const T &a, const T &b)
    return a > b ? a : b;
 }
 
-template<class T>
+template<class ForwardIt, class Pred>
+bool is_sorted(ForwardIt const first, ForwardIt last, Pred pred)
+{
+   if (first != last) {
+      ForwardIt next = first, cur(first);
+      while (++next != last) {
+         if (pred(*next, *cur))
+            return false;
+         cur = next;
+      }
+   }
+   return true;
+}
+
+#if defined(BOOST_MOVE_ADAPTIVE_SORT_INVARIANTS)
+
+bool is_sorted(::order_perf_type *first, ::order_perf_type *last, ::order_type_less)
+{
+   if (first != last) {
+      const order_perf_type *next = first, *cur(first);
+      while (++next != last) {
+         if (!(cur->key < next->key || (cur->key == next->key && cur->val < next->val)))
+            return false;
+         cur = next;
+      }
+   }
+   return true;
+}
+
+#endif   //BOOST_MOVE_ADAPTIVE_SORT_INVARIANTS
+
+template<class ForwardIt, class Pred>
+bool is_sorted_and_unique(ForwardIt first, ForwardIt last, Pred pred)
+{
+   if (first != last) {
+      ForwardIt next = first;
+      while (++next != last) {
+         if (!pred(*first, *next))
+            return false;
+         first = next;
+      }
+   }
+   return true;
+}
+
+template<class ForwardIt, class Pred, class V>
+typename iterator_traits<ForwardIt>::size_type
+   count_if_with(ForwardIt first, ForwardIt last, Pred pred, const V &v)
+{
+   typedef typename iterator_traits<ForwardIt>::size_type size_type;
+   size_type count = 0;
+   while(first != last) {
+      count += static_cast<size_type>(0 != pred(*first, v));
+      ++first;
+   }
+   return count;
+}
+
+template<class T, class RandRawIt = T*>
 class adaptive_xbuf
 {
    adaptive_xbuf(const adaptive_xbuf &);
    adaptive_xbuf & operator=(const adaptive_xbuf &);
 
    public:
-   typedef T* iterator;
+   typedef RandRawIt iterator;
 
    adaptive_xbuf()
-      : m_ptr(0), m_size(0), m_capacity(0)
+      : m_ptr(), m_size(0), m_capacity(0)
    {}
 
-   adaptive_xbuf(T *raw_memory, std::size_t capacity)
+   adaptive_xbuf(RandRawIt raw_memory, std::size_t capacity)
       : m_ptr(raw_memory), m_size(0), m_capacity(capacity)
    {}
 
@@ -119,7 +183,7 @@ class adaptive_xbuf
          m_size = n;
       }
       else{
-         T *result = boost::move(first, first+m_size, m_ptr);
+         RandRawIt result = boost::move(first, first+m_size, m_ptr);
          boost::uninitialized_move(first+m_size, first+n, result);
          m_size = n;
       }
@@ -137,8 +201,8 @@ class adaptive_xbuf
    iterator add(RandIt it)
    {
       BOOST_ASSERT(m_size < m_capacity);
-      T * p_ret = m_ptr + m_size;
-      ::new(p_ret) T(::boost::move(*it));
+      RandRawIt p_ret = m_ptr + m_size;
+      ::new(&*p_ret) T(::boost::move(*it));
       ++m_size;
       return p_ret;
    }
@@ -185,14 +249,26 @@ class adaptive_xbuf
       }
    }
 
+   private:
+   template<class RIt>
+   static bool is_raw_ptr(RIt)
+   {
+      return false;
+   }
+
+   static bool is_raw_ptr(T*)
+   {
+      return true;
+   }
+
+   public:
    template<class U>
    bool supports_aligned_trailing(std::size_t size, std::size_t trail_count) const
    {
-      if(this->data()){
-         uintptr_t u_addr_sz = uintptr_t(this->data()+size);
-         uintptr_t u_addr_cp = uintptr_t(this->data()+this->capacity());
+      if(this->is_raw_ptr(this->data()) && m_capacity){
+         uintptr_t u_addr_sz = uintptr_t(&*(this->data()+size));
+         uintptr_t u_addr_cp = uintptr_t(&*(this->data()+this->capacity()));
          u_addr_sz = ((u_addr_sz + sizeof(U)-1)/sizeof(U))*sizeof(U);
-         
          return (u_addr_cp >= u_addr_sz) && ((u_addr_cp - u_addr_sz)/sizeof(U) >= trail_count);
       }
       return false;
@@ -207,7 +283,7 @@ class adaptive_xbuf
    template<class U>
    U *aligned_trailing(std::size_t pos) const
    {
-      uintptr_t u_addr = uintptr_t(this->data()+pos);
+      uintptr_t u_addr = uintptr_t(&*(this->data()+pos));
       u_addr = ((u_addr + sizeof(U)-1)/sizeof(U))*sizeof(U);
       return (U*)u_addr;
    }
@@ -238,7 +314,7 @@ class adaptive_xbuf
    }
 
    private:
-   T *m_ptr;
+   RandRawIt m_ptr;
    std::size_t m_size;
    std::size_t m_capacity;
 };
@@ -320,40 +396,15 @@ RandIt skip_until_merge
    return first1;
 }
 
-template<class InputIt1, class InputIt2, class OutputIt, class Compare, class Op>
-OutputIt op_partial_merge
-   (InputIt1 &r_first1, InputIt1 const last1, InputIt2 &r_first2, InputIt2 const last2, OutputIt d_first, Compare comp, Op op)
-{
-   InputIt1 first1(r_first1);
-   InputIt2 first2(r_first2);
-   if(first2 != last2 && last1 != first1)
-   while(1){
-      if(comp(*first2, *first1)) {
-         op(first2++, d_first++);
-         if(first2 == last2){
-            break;
-         }
-      }
-      else{
-         op(first1++, d_first++);
-         if(first1 == last1){
-            break;
-         }
-      }
-   }
-   r_first1 = first1;
-   r_first2 = first2;
-   return d_first;
-}
 
 template<class RandIt1, class RandIt2, class RandItB, class Compare, class Op>
-RandItB op_buffered_partial_merge_to_left_placed
+RandItB op_buffered_partial_merge_to_range1_and_buffer
    ( RandIt1 first1, RandIt1 const last1
    , RandIt2 &rfirst2, RandIt2 const last2
    , RandItB &rfirstb, Compare comp, Op op )
 {
    RandItB firstb = rfirstb;
-   RandItB lastb = firstb;
+   RandItB lastb  = firstb;
    RandIt2 first2 = rfirst2;
 
    //Move to buffer while merging
@@ -372,315 +423,38 @@ RandItB op_buffered_partial_merge_to_left_placed
          }
          op(three_way_t(), comp(*first2, *firstb) ? first2++ : firstb++, first1++, lastb++);
       }
+      rfirst2 = first2;
+      rfirstb = firstb;
    }
 
-   rfirst2 = first2;
-   rfirstb = firstb;
    return lastb;
 }
 
-///////////////////////////////////////////////////////////////////////////////
-//
-//                         PARTIAL MERGE BUF
-//
-///////////////////////////////////////////////////////////////////////////////
-
-template<class Buf, class RandIt, class Compare, class Op>
-RandIt op_partial_merge_with_buf_impl
-   ( RandIt first1, RandIt const last1, RandIt first2, RandIt last2
-   , Buf &buf, typename Buf::iterator &buf_first1_in_out, typename Buf::iterator &buf_last1_in_out
-   , Compare comp, Op op
-   )
+template<class RandItKeys, class RandIt>
+void swap_and_update_key
+   ( bool is_next_far_away
+   , RandItKeys const key_next
+   , RandItKeys const key_range2
+   , RandItKeys &key_mid
+   , RandIt const begin
+   , RandIt const end
+   , RandIt const with)
 {
-   typedef typename Buf::iterator buf_iterator;
-
-   BOOST_ASSERT(first1 != last1);
-   BOOST_ASSERT(first2 != last2);
-   buf_iterator buf_first1 = buf_first1_in_out;
-   buf_iterator buf_last1  = buf_last1_in_out;
-
-   if(buf_first1 == buf_last1){
-      //Skip any element that does not need to be moved
-      first1 = skip_until_merge(first1, last1, *last1, comp);
-      if(first1 == last1){
-         return first1;
+   if(is_next_far_away){
+      ::boost::adl_move_swap_ranges(begin, end, with);
+      ::boost::adl_move_swap(*key_next, *key_range2);
+      if(key_next == key_mid){
+         key_mid = key_range2;
       }
-      buf_first1 = buf.data();
-      buf_last1  = op_buffered_partial_merge_to_left_placed(first1, last1, first2, last2, buf_first1, comp, op);
-      BOOST_ASSERT(buf_last1 == (buf.data() + (last1-first1)));
-      first1 = last1;
-   }
-   else{
-      BOOST_ASSERT((last1-first1) == (buf_last1 - buf_first1));
-   }
-
-   //Now merge from buffer
-   first1 = op_partial_merge(buf_first1, buf_last1, first2, last2, first1, comp, op);
-   buf_first1_in_out = buf_first1;
-   buf_last1_in_out  = buf_last1;
-   return first1;
-}
-
-template<class RandIt, class Buf, class Compare, class Op>
-RandIt op_partial_merge_with_buf
-   ( RandIt first1, RandIt const last1, RandIt first2, RandIt last2
-   , Buf &buf
-   , typename Buf::iterator &buf_first1_in_out
-   , typename Buf::iterator &buf_last1_in_out
-   , Compare comp
-   , Op op
-   , bool is_stable)
-{
-   return is_stable
-      ? op_partial_merge_with_buf_impl
-         (first1, last1, first2, last2, buf, buf_first1_in_out, buf_last1_in_out, comp, op)
-      : op_partial_merge_with_buf_impl
-         (first1, last1, first2, last2, buf, buf_first1_in_out, buf_last1_in_out, antistable<Compare>(comp), op)
-      ;
-}
-
-// key_first - sequence of keys, in same order as blocks. key_comp(key, midkey) means stream A
-// first - first element to merge.
-// first[-l_block, 0) - buffer
-// l_block - length of regular blocks. Blocks are stable sorted by 1st elements and key-coded
-// l_irreg1 is the irregular block to be merged before n_bef_irreg2 blocks (can be 0)
-// n_bef_irreg2/n_aft_irreg2 are regular blocks
-// l_irreg2 is a irregular block, that is to be merged after n_bef_irreg2 blocks and before n_aft_irreg2 blocks
-// If l_irreg2==0 then n_aft_irreg2==0 (no irregular blocks).
-template<class RandItKeys, class KeyCompare, class RandIt, class Compare, class Op, class Buf>
-void op_merge_blocks_with_buf
-   ( RandItKeys key_first
-   , const typename iterator_traits<RandItKeys>::value_type &midkey
-   , KeyCompare key_comp
-   , RandIt const first
-   , typename iterator_traits<RandIt>::size_type const l_block
-   , typename iterator_traits<RandIt>::size_type const l_irreg1
-   , typename iterator_traits<RandIt>::size_type const n_bef_irreg2
-   , typename iterator_traits<RandIt>::size_type const n_aft_irreg2
-   , typename iterator_traits<RandIt>::size_type const l_irreg2
-   , Compare comp
-   , Op op
-   , Buf & xbuf)
-{
-   typedef typename Buf::iterator buf_iterator;
-   buf_iterator buffer = xbuf.data();
-   buf_iterator buffer_end = buffer;
-   RandIt first1 = first;
-   RandIt last1  = first1 + l_irreg1;
-   RandItKeys const key_end (key_first+n_bef_irreg2);
-
-   bool is_range1_A = true;   //first l_irreg1 elements are always from range A
-
-   for( ; key_first != key_end; ++key_first, last1 += l_block){
-      //If the trailing block is empty, we'll make it equal to the previous if empty
-      bool const is_range2_A = key_comp(*key_first, midkey);
-
-      if(is_range1_A == is_range2_A){
-         //If buffered, put those elements in place
-         RandIt res = op(forward_t(), buffer, buffer_end, first1);
-         BOOST_ASSERT(buffer == buffer_end || res == last1); (void)res;
-         buffer_end = buffer;
-         first1 = last1;
+      else if(key_mid == key_range2){
+         key_mid = key_next;
       }
-      else {
-         first1 = op_partial_merge_with_buf(first1, last1, last1, last1 + l_block, xbuf, buffer, buffer_end, comp, op, is_range1_A);
-         BOOST_ASSERT(buffer == buffer_end || (buffer_end-buffer) == (last1+l_block-first1));
-         is_range1_A ^= buffer == buffer_end;
-      }
-   }
-
-   //Now the trailing irregular block, first put buffered elements in place
-   RandIt res = op(forward_t(), buffer, buffer_end, first1);
-   BOOST_ASSERT(buffer == buffer_end || res == last1); (void)res;
-
-   BOOST_ASSERT(l_irreg2 || n_aft_irreg2);
-   if(l_irreg2){
-      bool const is_range2_A  = false; //last l_irreg2 elements always from range B
-      if(is_range1_A == is_range2_A){
-         first1 = last1;
-         last1 = last1+l_block*n_aft_irreg2;
-      }
-      else {
-         last1 += l_block*n_aft_irreg2;
-      }
-      xbuf.clear();
-      op_buffered_merge(first1, last1, last1+l_irreg2, comp, op, xbuf);
-   }
-}
-
-
-template<class RandItKeys, class KeyCompare, class RandIt, class Compare, class Buf>
-void merge_blocks_with_buf
-   ( RandItKeys key_first
-   , const typename iterator_traits<RandItKeys>::value_type &midkey
-   , KeyCompare key_comp
-   , RandIt const first
-   , typename iterator_traits<RandIt>::size_type const l_block
-   , typename iterator_traits<RandIt>::size_type const l_irreg1
-   , typename iterator_traits<RandIt>::size_type const n_bef_irreg2
-   , typename iterator_traits<RandIt>::size_type const n_aft_irreg2
-   , typename iterator_traits<RandIt>::size_type const l_irreg2
-   , Compare comp
-   , Buf & xbuf
-   , bool const xbuf_used)
-{
-   if(xbuf_used){
-      op_merge_blocks_with_buf
-         (key_first, midkey, key_comp, first, l_block, l_irreg1, n_bef_irreg2, n_aft_irreg2, l_irreg2, comp, move_op(), xbuf);
-   }
-   else{
-      op_merge_blocks_with_buf
-         (key_first, midkey, key_comp, first, l_block, l_irreg1, n_bef_irreg2, n_aft_irreg2, l_irreg2, comp, swap_op(), xbuf);
    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //
-//                         PARTIAL MERGE LEFT
-//
-///////////////////////////////////////////////////////////////////////////////
-
-template<class RandIt, class Compare, class Op>
-RandIt op_partial_merge_left_middle_buffer_impl
-   (RandIt first1, RandIt const last1, RandIt const first2
-   , const typename iterator_traits<RandIt>::value_type &next_key, Compare comp
-   , Op op)
-{
-   first1 = skip_until_merge(first1, last1, next_key, comp);
-
-   //Even if we copy backward, no overlapping occurs so use forward copy
-   //that can be faster specially with trivial types
-   RandIt const new_first1 = first2 - (last1 - first1);
-   BOOST_ASSERT(last1 <= new_first1);
-   op(forward_t(), first1, last1, new_first1);
-   return new_first1;
-}
-
-template<class RandIt, class Compare, class Op>
-RandIt op_partial_merge_left_middle_buffer
-   ( RandIt first1, RandIt const last1, RandIt const first2
-   , const typename iterator_traits<RandIt>::value_type &next_key, Compare comp, Op op, bool is_stable)
-{
-   return is_stable ? op_partial_merge_left_middle_buffer_impl(first1, last1, first2, next_key, comp, op)
-                    : op_partial_merge_left_middle_buffer_impl(first1, last1, first2, next_key, antistable<Compare>(comp), op);
-}
-
-// Partially merges two ordered ranges. Partially means that elements are merged
-// until one of two ranges is exhausted (M elements from ranges 1 y 2).
-// [buf_first, ...) -> buffer that can be overwritten
-// [first1, last1) merge [last1,last2) -> [buf_first, buf_first+M)
-// Note: distance(buf_first, first1) >= distance(last1, last2), so no overlapping occurs.
-template<class RandIt, class Compare, class Op>
-RandIt op_partial_merge_left_smart_impl
-   ( RandIt first1, RandIt last1, RandIt first2, RandIt const last2, Compare comp, Op op)
-{
-   RandIt dest;
-   if(last1 != first2){
-      BOOST_ASSERT(0 != (last1-first1));
-      BOOST_ASSERT((first2-last1)==(last2-first2));
-      //Skip any element that does not need to be moved
-      first1 = skip_until_merge(first1, last1, *first2, comp);
-      if(first1 == last1)
-         return first2;
-      RandIt buf_first1 = first2 - (last1-first1);
-      dest   = last1;
-      last1 = op_buffered_partial_merge_to_left_placed(first1, last1, first2, last2, buf_first1, comp, op);
-      first1 = buf_first1;
-      BOOST_ASSERT((first1-dest) == (last2-first2));
-   }
-   else{
-      dest = first1-(last2-first2);
-   }
-
-   op_partial_merge(first1, last1, first2, last2, dest, comp, op);
-   return first1 == last1 ? first2 : first1;
-}
-
-template<class RandIt, class Compare, class Op>
-RandIt op_partial_merge_left_smart
-   (RandIt first1, RandIt const last1, RandIt first2, RandIt const last2, Compare comp, Op op, bool is_stable)
-{
-   return is_stable ? op_partial_merge_left_smart_impl(first1, last1, first2, last2, comp, op)
-                    : op_partial_merge_left_smart_impl(first1, last1, first2, last2, antistable<Compare>(comp), op);
-}
-
-// first - first element to merge.
-// first[-l_block, 0) - buffer
-// l_block - length of regular blocks. Blocks are stable sorted by 1st elements and key-coded
-// key_first - sequence of keys, in same order as blocks. key<midkey means stream A
-// n_bef_irreg2/n_aft_irreg2 are regular blocks
-// l_irreg2 is a irregular block, that is to be merged after n_bef_irreg2 blocks and before n_aft_irreg2 blocks
-// If l_irreg2==0 then n_aft_irreg2==0 (no irregular blocks).
-template<class RandItKeys, class KeyCompare, class RandIt, class Compare, class Op>
-void op_merge_blocks_left
-   ( RandItKeys key_first
-   , const typename iterator_traits<RandItKeys>::value_type &midkey
-   , KeyCompare key_comp
-   , RandIt const first
-   , typename iterator_traits<RandIt>::size_type const l_block
-   , typename iterator_traits<RandIt>::size_type const l_irreg1
-   , typename iterator_traits<RandIt>::size_type const n_bef_irreg2
-   , typename iterator_traits<RandIt>::size_type const n_aft_irreg2
-   , typename iterator_traits<RandIt>::size_type const l_irreg2
-   , Compare comp, Op op)
-{
-   RandIt buffer = first - l_block;
-   RandIt first1 = first;
-   RandIt last1  = first1 + l_irreg1;
-   RandIt first2 = last1;
-   RandItKeys const key_end (key_first+n_bef_irreg2);
-   bool is_range1_A = true;
-   for( ; key_first != key_end; first2 += l_block, ++key_first){
-      //If the trailing block is empty, we'll make it equal to the previous if empty
-      bool const is_range2_A = key_comp(*key_first, midkey);
-
-      if(is_range1_A == is_range2_A){
-         if(last1 != buffer){  //equiv. to if(!is_buffer_middle)
-            buffer = op(forward_t(), first1, last1, buffer);
-         }
-         first1 = first2;
-         last1  = first2 + l_block;
-      }
-      else {
-         RandIt const last2  = first2 + l_block;
-         first1 = op_partial_merge_left_smart(first1, last1, first2, last2, comp, op, is_range1_A);
-
-         if(first1 < first2){  //is_buffer_middle for the next iteration
-            last1  = first2;
-            buffer = last1;
-         }
-         else{ //!is_buffer_middle for the next iteration
-            is_range1_A = is_range2_A;
-            buffer = first1 - l_block;
-            last1 = last2;
-         }
-      }
-   }
-
-   //Now the trailing irregular block
-   bool const is_range2_A      = false;   //Trailing l_irreg2 is always from Range B
-   bool const is_buffer_middle = last1 == buffer;
-
-   if(!l_irreg2 || is_range1_A == is_range2_A){ //trailing is always B type
-      //If range1 is buffered, write it to its final position
-      if(!is_buffer_middle){
-         buffer = op(forward_t(), first1, last1, buffer);
-      }
-      first1 = first2;
-   }
-   else {
-      if(is_buffer_middle){
-         first1 = op_partial_merge_left_middle_buffer(first1, last1, first2, first2[l_block*n_aft_irreg2], comp, op, is_range1_A);
-         buffer = first1 - l_block;
-      }
-   }
-   last1 = first2 + l_block*n_aft_irreg2;
-   op_merge_left(buffer, first1, last1, last1+l_irreg2, comp, op);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//
-//                         PARTIAL MERGE BUFFERLESS
+//                         MERGE BUFFERLESS
 //
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -696,7 +470,7 @@ RandIt partial_merge_bufferless_impl
    if(first1 != last1 && comp(*last1, last1[-1])){
       do{
          RandIt const old_last1 = last1;
-         last1  = lower_bound(last1, last2, *first1, comp);
+         last1  = boost::movelib::lower_bound(last1, last2, *first1, comp);
          first1 = rotate_gcd(first1, old_last1, last1);//old_last1 == last1 supported
          if(last1 == last2){
             return first1;
@@ -719,54 +493,111 @@ RandIt partial_merge_bufferless
                         : partial_merge_bufferless_impl(first1, last1, last2, pis_range1_A, antistable<Compare>(comp));
 }
 
+template<class SizeType>
+static SizeType needed_keys_count(SizeType n_block_a, SizeType n_block_b)
+{
+   return n_block_a + n_block_b;
+}
 
+template<class RandItKeys, class KeyCompare, class RandIt, class Compare>
+typename iterator_traits<RandIt>::size_type
+   find_next_block
+      ( RandItKeys key_first
+      , KeyCompare key_comp
+      , RandIt const first
+      , typename iterator_traits<RandIt>::size_type const l_block
+      , typename iterator_traits<RandIt>::size_type const ix_first_block
+      , typename iterator_traits<RandIt>::size_type const ix_last_block
+      , Compare comp)
+{
+   typedef typename iterator_traits<RandIt>::size_type      size_type;
+   typedef typename iterator_traits<RandIt>::value_type     value_type;
+   typedef typename iterator_traits<RandItKeys>::value_type key_type;
+   BOOST_ASSERT(ix_first_block <= ix_last_block);
+   size_type ix_min_block = 0u;
+   for (size_type szt_i = ix_first_block; szt_i < ix_last_block; ++szt_i) {
+      const value_type &min_val = first[ix_min_block*l_block];
+      const value_type &cur_val = first[szt_i*l_block];
+      const key_type   &min_key = key_first[ix_min_block];
+      const key_type   &cur_key = key_first[szt_i];
+
+      bool const less_than_minimum = comp(cur_val, min_val) ||
+         (!comp(min_val, cur_val) && key_comp(cur_key, min_key));
+
+      if (less_than_minimum) {
+         ix_min_block = szt_i;
+      }
+   }
+   return ix_min_block;
+}
 
-// l_block - length of regular blocks. First nblocks are stable sorted by 1st elements and key-coded
-// keys - sequence of keys, in same order as blocks. key<midkey means stream A
-// n_aft_irreg2 are regular blocks from stream A. l_irreg2 is length of last (irregular) block from stream B, that should go before n_aft_irreg2 blocks.
-// l_irreg2=0 requires n_aft_irreg2=0 (no irregular blocks). l_irreg2>0, n_aft_irreg2=0 is possible.
 template<class RandItKeys, class KeyCompare, class RandIt, class Compare>
 void merge_blocks_bufferless
    ( RandItKeys key_first
-   , const typename iterator_traits<RandItKeys>::value_type &midkey
    , KeyCompare key_comp
-   , RandIt first
+   , RandIt const first
    , typename iterator_traits<RandIt>::size_type const l_block
    , typename iterator_traits<RandIt>::size_type const l_irreg1
-   , typename iterator_traits<RandIt>::size_type const n_bef_irreg2
-   , typename iterator_traits<RandIt>::size_type const n_aft_irreg2
+   , typename iterator_traits<RandIt>::size_type const n_block_a
+   , typename iterator_traits<RandIt>::size_type const n_block_b
    , typename iterator_traits<RandIt>::size_type const l_irreg2
    , Compare comp)
 {
-   if(n_bef_irreg2 == 0){
-      RandIt const last_reg(first+l_irreg1+n_aft_irreg2*l_block);
-      merge_bufferless(first, last_reg, last_reg+l_irreg2, comp);
-   }
-   else{
-      RandIt first1 = first;
-      RandIt last1  = l_irreg1 ? first + l_irreg1: first + l_block;
-      RandItKeys const key_end (key_first+n_bef_irreg2);
-      bool is_range1_A = l_irreg1 ? true : key_comp(*key_first++, midkey);
+   typedef typename iterator_traits<RandIt>::size_type size_type;
+   size_type const key_count = needed_keys_count(n_block_a, n_block_b); (void)key_count;
+   //BOOST_ASSERT(n_block_a || n_block_b);
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted_and_unique(key_first, key_first + key_count, key_comp));
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_b || n_block_a == count_if_with(key_first, key_first + key_count, key_comp, key_first[n_block_a]));
 
-      for( ; key_first != key_end; ++key_first){
-         bool is_range2_A = key_comp(*key_first, midkey);
-         if(is_range1_A == is_range2_A){
-            first1 = last1;
-         }
-         else{
-            first1 = partial_merge_bufferless(first1, last1, last1 + l_block, &is_range1_A, comp);
-         }
-         last1 += l_block;
-      }
+   size_type n_bef_irreg2 = 0;
+   bool l_irreg_pos_count = true;
+   RandItKeys key_mid(key_first + n_block_a);
+   RandIt const first_irr2 = first + l_irreg1 + (n_block_a+n_block_b)*l_block;
+   RandIt const last_irr2  = first_irr2 + l_irreg2;
 
-      if(l_irreg2){
-         if(!is_range1_A){
-            first1 = last1;
+   {  //Selection sort blocks
+      size_type n_block_left = n_block_b + n_block_a;
+      RandItKeys key_range2(key_first);
+
+      size_type min_check = n_block_a == n_block_left ? 0u : n_block_a;
+      size_type max_check = min_value(min_check+1, n_block_left);
+      for (RandIt f = first+l_irreg1; n_block_left; --n_block_left, ++key_range2, f += l_block, min_check -= min_check != 0, max_check -= max_check != 0) {
+         size_type const next_key_idx = find_next_block(key_range2, key_comp, f, l_block, min_check, max_check, comp);
+         RandItKeys const key_next(key_range2 + next_key_idx);
+         max_check = min_value(max_value(max_check, next_key_idx+2), n_block_left);
+
+         RandIt const first_min = f + next_key_idx*l_block;
+
+         //Check if irregular b block should go here.
+         //If so, break to the special code handling the irregular block
+         if (l_irreg_pos_count && l_irreg2 && comp(*first_irr2, *first_min)){
+            l_irreg_pos_count = false;
          }
-         last1 += l_block*n_aft_irreg2;
-         merge_bufferless(first1, last1, last1+l_irreg2, comp);
+         n_bef_irreg2 += l_irreg_pos_count;
+
+         swap_and_update_key(next_key_idx != 0, key_next, key_range2, key_mid, f, f + l_block, first_min);
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(f, f+l_block, comp));
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first_min, first_min + l_block, comp));
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT((f == (first+l_irreg1)) || !comp(*f, *(f-l_block)));
       }
    }
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first+l_irreg1+n_bef_irreg2*l_block, first_irr2, comp));
+
+   RandIt first1 = first;
+   RandIt last1  = first+l_irreg1;
+   RandItKeys const key_end (key_first+n_bef_irreg2);
+   bool is_range1_A = true;
+
+   for( ; key_first != key_end; ++key_first){
+      bool is_range2_A = key_mid == (key_first+key_count) || key_comp(*key_first, *key_mid);
+      first1 = is_range1_A == is_range2_A
+         ? last1 : partial_merge_bufferless(first1, last1, last1 + l_block, &is_range1_A, comp);
+      last1 += l_block;
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first, first1, comp));
+   }
+
+   merge_bufferless(is_range1_A ? first1 : last1, first_irr2, last_irr2, comp);
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first, last_irr2, comp));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -785,13 +616,13 @@ void op_buffered_merge
       size_type const len1 = size_type(middle-first);
       size_type const len2 = size_type(last-middle);
       if(len1 <= len2){
-         first = upper_bound(first, middle, *middle, comp);
+         first = boost::movelib::upper_bound(first, middle, *middle, comp);
          xbuf.move_assign(first, size_type(middle-first));
          op_merge_with_right_placed
             (xbuf.data(), xbuf.end(), first, middle, last, comp, op);
       }
       else{
-         last = lower_bound(middle, last, middle[-1], comp);
+         last = boost::movelib::lower_bound(middle, last, middle[-1], comp);
          xbuf.move_assign(middle, size_type(last-middle));
          op_merge_with_left_placed
             (first, middle, last, xbuf.data(), xbuf.end(), comp, op);
@@ -799,11 +630,11 @@ void op_buffered_merge
    }
 }
 
-template<class RandIt, class Compare>
+template<class RandIt, class Compare, class XBuf>
 void buffered_merge
       ( RandIt first, RandIt const middle, RandIt last
       , Compare comp
-      , adaptive_xbuf<typename iterator_traits<RandIt>::value_type> &xbuf)
+      , XBuf &xbuf)
 {
    op_buffered_merge(first, middle, last, comp, move_op(), xbuf);
 }
@@ -814,15 +645,14 @@ void buffered_merge
 // in the begining of the range, and ordered according to comp
 // 
 // Returns the number of collected keys
-template<class RandIt, class Compare>
+template<class RandIt, class Compare, class XBuf>
 typename iterator_traits<RandIt>::size_type
    collect_unique
       ( RandIt const first, RandIt const last
       , typename iterator_traits<RandIt>::size_type const max_collected, Compare comp
-      , adaptive_xbuf<typename iterator_traits<RandIt>::value_type> & xbuf)
+      , XBuf & xbuf)
 {
    typedef typename iterator_traits<RandIt>::size_type size_type;
-   typedef typename iterator_traits<RandIt>::value_type value_type;
    size_type h = 0;
    if(max_collected){
       ++h;  // first key is always here
@@ -831,9 +661,9 @@ typename iterator_traits<RandIt>::size_type
       RandIt search_end = u;
 
       if(xbuf.capacity() >= max_collected){
-         value_type *const ph0 = xbuf.add(first);
+         typename XBuf::iterator const ph0 = xbuf.add(first);
          while(u != last && h < max_collected){
-            value_type * const r = lower_bound(ph0, xbuf.end(), *u, comp);
+            typename XBuf::iterator const r = boost::movelib::lower_bound(ph0, xbuf.end(), *u, comp);
             //If key not found add it to [h, h+h0)
             if(r == xbuf.end() || comp(*u, *r) ){
                RandIt const new_h0 = boost::move(search_end, u, h0);
@@ -850,7 +680,7 @@ typename iterator_traits<RandIt>::size_type
       }
       else{
          while(u != last && h < max_collected){
-            RandIt const r = lower_bound(h0, search_end, *u, comp);
+            RandIt const r = boost::movelib::lower_bound(h0, search_end, *u, comp);
             //If key not found add it to [h, h+h0)
             if(r == search_end || comp(*u, *r) ){
                RandIt const new_h0 = rotate_gcd(h0, search_end, u);
@@ -929,20 +759,6 @@ Unsigned ceil_sqrt_multiple(Unsigned const n, Unsigned *pbase = 0)
    return res;
 }
 
-template<class Unsigned>
-Unsigned ceil_sqrt_pow2(Unsigned const n)
-{
-   Unsigned r=1;
-   Unsigned exp = 0;
-   Unsigned pow = 1u;
-   while(pow != 0 && pow < n){
-      r*=2;
-      ++exp;
-      pow = r << exp;
-   }
-   return r;
-}
-
 struct less
 {
    template<class T>
@@ -1038,128 +854,6 @@ Unsigned lblock_for_combine
    }
 }
 
-
-//Although "cycle" sort is known to have the minimum number of writes to target
-//selection sort is more appropriate here as we want to minimize swaps.
-template<class RandItKeys, class KeyCompare, class RandIt, class Compare, class XBuf>
-void selection_sort_blocks
-   ( RandItKeys keys
-   , typename iterator_traits<RandIt>::size_type &midkey_idx //inout
-   , KeyCompare key_comp
-   , RandIt const first_block
-   , typename iterator_traits<RandIt>::size_type const l_block
-   , typename iterator_traits<RandIt>::size_type const n_blocks
-   , Compare comp
-   , bool use_first_element
-   , XBuf & xbuf
-)
-{
-   typedef typename iterator_traits<RandIt>::size_type size_type ;
-   size_type const back_midkey_idx = midkey_idx;
-   typedef typename iterator_traits<RandIt>::size_type   size_type;
-   typedef typename iterator_traits<RandIt>::value_type  value_type;
-
-   //Nothing to sort if 0 or 1 blocks or all belong to the first ordered half
-   if(n_blocks < 2 || back_midkey_idx >= n_blocks){
-      return;
-   }
-   //One-past the position of the first untouched element of the second half
-   size_type high_watermark = back_midkey_idx+1;
-   BOOST_ASSERT(high_watermark <= n_blocks);
-   const bool b_cache_on = xbuf.capacity() >= l_block;
-   //const bool b_cache_on = false;
-   const size_type cached_none = size_type(-1);
-   size_type cached_block = cached_none;
-
-   //Sort by first element if left merging, last element otherwise
-   size_type const reg_off = use_first_element ? 0u: l_block-1;
-
-   for(size_type block=0; block < n_blocks-1; ++block){
-      size_type min_block = block;
-      //Since we are searching for the minimum value in two sorted halves:
-      //Optimization 1: If block belongs to first half, don't waste time comparing elements of the first half.
-      //Optimization 2: It is enough to compare until the first untouched element of the second half.
-      //Optimization 3: If cache memory is available, instead of swapping blocks (3 writes per element),
-      // play with the cache to aproximate it to 2 writes per element.
-      high_watermark = size_type(max_value(block+2, high_watermark));
-      BOOST_ASSERT(high_watermark <= n_blocks);
-      for(size_type next_block = size_type(max_value(block+1, back_midkey_idx)); next_block < high_watermark; ++next_block){
-         const value_type &min_v = (b_cache_on && (cached_block == min_block)  ? xbuf.data()[reg_off] : first_block[min_block*l_block+reg_off]);
-         const value_type &v     = (b_cache_on && (cached_block == next_block) ? xbuf.data()[reg_off] : first_block[next_block*l_block+reg_off]);
-
-         if( comp(v, min_v) || (!comp(min_v, v) && key_comp(keys[next_block], keys[min_block])) ){
-            min_block = next_block;
-         }
-      }
-
-      if(min_block != block){
-         BOOST_ASSERT(block >= back_midkey_idx || min_block >= back_midkey_idx);
-         BOOST_ASSERT(min_block < high_watermark);
-         //Increase high watermark if not the maximum and min_block is just before the high watermark
-         high_watermark += size_type((min_block + 1) != n_blocks && (min_block + 1) == high_watermark);
-         BOOST_ASSERT(high_watermark <= n_blocks);
-         if(!b_cache_on){
-            boost::adl_move_swap_ranges(first_block+block*l_block, first_block+(block+1)*l_block, first_block+min_block*l_block);
-         }
-         else if(cached_block == cached_none){
-            //Cache the biggest block and put the minimum into its final position
-            xbuf.move_assign(first_block+block*l_block, l_block);
-            boost::move(first_block+min_block*l_block, first_block+(min_block+1)*l_block, first_block+block*l_block);
-            cached_block = min_block;
-         }
-         else if(cached_block == block){
-            //Since block is cached and is not the minimum, just put the minimum directly into its final position and update the cache index
-            boost::move(first_block+min_block*l_block, first_block+(min_block+1)*l_block, first_block+block*l_block);
-            cached_block = min_block;
-         }
-         else if(cached_block == min_block){
-            //Since the minimum is cached, move the block to the back position and flush the cache to its final position
-            boost::move(first_block+block*l_block, first_block+(block+1)*l_block, first_block+min_block*l_block);
-            boost::move(xbuf.data(), xbuf.end(), first_block+block*l_block);
-            cached_block = cached_none;
-         }
-         else{
-            //Cached block is not any of two blocks to be exchanged, a smarter operation must be performed
-            BOOST_ASSERT(cached_block != min_block);
-            BOOST_ASSERT(cached_block != block);
-            BOOST_ASSERT(cached_block > block);
-            BOOST_ASSERT(cached_block < high_watermark);
-            //Instead of moving block to the slot of the minimum (which is typical selection sort), before copying
-            //data from the minimum slot to its final position:
-            // -> move it to free slot pointed by cached index, and 
-            // -> move cached index into slot of the minimum.
-            //Since both cached_block and min_block belong to the still unordered range of blocks, the change
-            //does not break selection sort and saves one copy.
-            boost::move(first_block+block*l_block, first_block+(block+1)*l_block, first_block+cached_block*l_block);
-            boost::move(first_block+min_block*l_block, first_block+(min_block+1)*l_block, first_block+block*l_block);
-            //Note that this trick requires an additionl fix for keys and midkey index
-            boost::adl_move_swap(keys[cached_block], keys[min_block]);
-            if(midkey_idx == cached_block)
-               midkey_idx = min_block;
-            else if(midkey_idx == min_block)
-               midkey_idx = cached_block;
-            boost::adl_move_swap(cached_block, min_block);
-         }
-         //Once min_block and block are exchanged, fix the movement imitation key buffer and midkey index.
-         boost::adl_move_swap(keys[block], keys[min_block]);
-         if(midkey_idx == block)
-            midkey_idx = min_block;
-         else if(midkey_idx == min_block)
-            midkey_idx = block;
-      }
-      else if(b_cache_on && cached_block == block){
-         //The selected block was the minimum, but since it was cached, move it to its final position
-         boost::move(xbuf.data(), xbuf.end(), first_block+block*l_block);
-         cached_block = cached_none;
-      }
-   }  //main for loop
-
-   if(b_cache_on && cached_block != cached_none){
-      //The sort has ended with cached data, move it to its final position
-      boost::move(xbuf.data(), xbuf.end(), first_block+cached_block*l_block);
-   }
-}
-
 template<class RandIt, class Compare, class XBuf>
 void stable_sort( RandIt first, RandIt last, Compare comp, XBuf & xbuf)
 {
@@ -1195,128 +889,6 @@ void initialize_keys( RandIt first, RandIt last
    }
 }
 
-template<class RandItKeys, class KeyCompare, class RandIt, class Compare, class XBuf>
-void combine_params
-   ( RandItKeys const keys
-   , KeyCompare key_comp
-   , RandIt const first
-   , typename iterator_traits<RandIt>::size_type l_combined
-   , typename iterator_traits<RandIt>::size_type const l_prev_merged
-   , typename iterator_traits<RandIt>::size_type const l_block
-   , XBuf & xbuf
-   , Compare comp
-   //Output
-   , typename iterator_traits<RandIt>::size_type &midkey_idx
-   , typename iterator_traits<RandIt>::size_type &l_irreg1
-   , typename iterator_traits<RandIt>::size_type &n_bef_irreg2
-   , typename iterator_traits<RandIt>::size_type &n_aft_irreg2
-   , typename iterator_traits<RandIt>::size_type &l_irreg2
-   //Options
-   , bool is_merge_left_or_bufferless
-   , bool do_initialize_keys = true)
-{
-   typedef typename iterator_traits<RandIt>::size_type   size_type;
-   typedef typename iterator_traits<RandIt>::value_type  value_type;
-
-   //Initial parameters for selection sort blocks
-   l_irreg1 = l_prev_merged%l_block;
-   l_irreg2 = (l_combined-l_irreg1)%l_block;
-   BOOST_ASSERT(((l_combined-l_irreg1-l_irreg2)%l_block) == 0);
-   size_type const n_reg_block = (l_combined-l_irreg1-l_irreg2)/l_block;
-   midkey_idx = l_prev_merged/l_block;
-   BOOST_ASSERT(n_reg_block>=midkey_idx);
-
-   //Key initialization
-   if (do_initialize_keys) {
-      initialize_keys(keys, keys+n_reg_block+(midkey_idx==n_reg_block), key_comp, xbuf);
-   }
-   BOOST_MOVE_ADAPTIVE_SORT_PRINT("   A initkey: ", l_combined + l_block);
-
-   //Selection sort blocks
-   selection_sort_blocks(keys, midkey_idx, key_comp, first+l_irreg1, l_block, n_reg_block, comp, is_merge_left_or_bufferless, xbuf);
-   BOOST_MOVE_ADAPTIVE_SORT_PRINT("   A selsort: ", l_combined + l_block);
-
-   //Special case for the last elements
-   n_aft_irreg2  = 0;
-   if(l_irreg2 != 0){
-      size_type const reg_off   = is_merge_left_or_bufferless ? 0u: l_block-1;
-      size_type const irreg_off = is_merge_left_or_bufferless ? 0u: l_irreg2-1;
-      RandIt prev_block_first = first + l_combined - l_irreg2;
-      const value_type &incomplete_block_first = prev_block_first[irreg_off];
-      while(n_aft_irreg2 != n_reg_block && 
-            comp(incomplete_block_first, (prev_block_first-= l_block)[reg_off]) ){
-         ++n_aft_irreg2;
-      }
-   }
-   n_bef_irreg2 = n_reg_block-n_aft_irreg2;
-}
-
-// first - first element to merge.
-// first[-l_block, 0) - buffer (if use_buf == true)
-// l_block - length of regular blocks. First nblocks are stable sorted by 1st elements and key-coded
-// keys - sequence of keys, in same order as blocks. key<midkey means stream A
-// n_bef_irreg2/n_aft_irreg2 are regular blocks
-// l_irreg2 is a irregular block, that is to be combined after n_bef_irreg2 blocks and before n_aft_irreg2 blocks
-// If l_irreg2==0 then n_aft_irreg2==0 (no irregular blocks).
-template<class RandItKeys, class KeyCompare, class RandIt, class Compare>
-void merge_blocks_left
-   ( RandItKeys const key_first
-   , const typename iterator_traits<RandItKeys>::value_type &midkey
-   , KeyCompare key_comp
-   , RandIt const first
-   , typename iterator_traits<RandIt>::size_type const l_block
-   , typename iterator_traits<RandIt>::size_type const l_irreg1
-   , typename iterator_traits<RandIt>::size_type const n_bef_irreg2
-   , typename iterator_traits<RandIt>::size_type const n_aft_irreg2
-   , typename iterator_traits<RandIt>::size_type const l_irreg2
-   , Compare comp
-   , bool const xbuf_used)
-{
-   if(xbuf_used){
-      op_merge_blocks_left
-         (key_first, midkey, key_comp, first, l_block, l_irreg1, n_bef_irreg2, n_aft_irreg2, l_irreg2, comp, move_op());
-   }
-   else{
-      op_merge_blocks_left
-         (key_first, midkey, key_comp, first, l_block, l_irreg1, n_bef_irreg2, n_aft_irreg2, l_irreg2, comp, swap_op());
-   }
-}
-
-
-// first - first element to merge.
-// [first+l_block*(n_bef_irreg2+n_aft_irreg2)+l_irreg2, first+l_block*(n_bef_irreg2+n_aft_irreg2+1)+l_irreg2) - buffer
-// l_block - length of regular blocks. First nblocks are stable sorted by 1st elements and key-coded
-// keys - sequence of keys, in same order as blocks. key<midkey means stream A
-// n_bef_irreg2/n_aft_irreg2 are regular blocks
-// l_irreg2 is a irregular block, that is to be combined after n_bef_irreg2 blocks and before n_aft_irreg2 blocks
-// If l_irreg2==0 then n_aft_irreg2==0 (no irregular blocks).
-template<class RandItKeys, class KeyCompare, class RandIt, class Compare>
-void merge_blocks_right
-   ( RandItKeys const key_first
-   , const typename iterator_traits<RandItKeys>::value_type &midkey
-   , KeyCompare key_comp
-   , RandIt const first
-   , typename iterator_traits<RandIt>::size_type const l_block
-   , typename iterator_traits<RandIt>::size_type const n_bef_irreg2
-   , typename iterator_traits<RandIt>::size_type const n_aft_irreg2
-   , typename iterator_traits<RandIt>::size_type const l_irreg2
-   , Compare comp
-   , bool const xbuf_used)
-{
-   merge_blocks_left
-      ( make_reverse_iterator(key_first+n_aft_irreg2 + n_bef_irreg2)
-      , midkey
-      , negate<KeyCompare>(key_comp)
-      , make_reverse_iterator(first+(n_bef_irreg2+n_aft_irreg2)*l_block+l_irreg2)
-      , l_block
-      , l_irreg2
-      , n_aft_irreg2 + n_bef_irreg2
-      , 0
-      , 0
-      , inverse<Compare>(comp), xbuf_used);
-}
-
-
 template<class RandIt>
 void move_data_backward( RandIt cur_pos
               , typename iterator_traits<RandIt>::size_type const l_data
@@ -1368,108 +940,620 @@ Unsigned calculate_total_combined(Unsigned const len, Unsigned const l_prev_merg
    return l_total_combined;
 }
 
-// keys are on the left of first:
-//    If use_buf: [first - l_block - n_keys, first - l_block).
-//    Otherwise:  [first - n_keys, first).
-// Buffer (if use_buf) is also on the left of first [first - l_block, first).
-// Blocks of length l_prev_merged combined. We'll combine them in pairs
-// l_prev_merged and n_keys are powers of 2. (2*l_prev_merged/l_block) keys are guaranteed
-// Returns the number of combined elements (some trailing elements might be left uncombined)
-template<class RandItKeys, class KeyCompare, class RandIt, class Compare, class XBuf>
-void adaptive_sort_combine_blocks
+template<class RandItKeys, class KeyCompare, class SizeType, class XBuf>
+void combine_params
    ( RandItKeys const keys
    , KeyCompare key_comp
-   , RandIt const first
-   , typename iterator_traits<RandIt>::size_type const len
-   , typename iterator_traits<RandIt>::size_type const l_prev_merged
-   , typename iterator_traits<RandIt>::size_type const l_block
-   , bool const use_buf
-   , bool const xbuf_used
+   , SizeType l_combined
+   , SizeType const l_prev_merged
+   , SizeType const l_block
    , XBuf & xbuf
-   , Compare comp
-   , bool merge_left)
+   //Output
+   , SizeType &n_block_a
+   , SizeType &n_block_b
+   , SizeType &l_irreg1
+   , SizeType &l_irreg2
+   //Options
+   , bool do_initialize_keys = true)
 {
-   (void)xbuf;
-   typedef typename iterator_traits<RandIt>::size_type   size_type;
+   typedef SizeType   size_type;
 
-   size_type const l_reg_combined   = 2*l_prev_merged;
-   size_type l_irreg_combined = 0;
-   size_type const l_total_combined = calculate_total_combined(len, l_prev_merged, &l_irreg_combined);
-   size_type const n_reg_combined = len/l_reg_combined;
-   RandIt combined_first = first;
+   //Initial parameters for selection sort blocks
+   l_irreg1 = l_prev_merged%l_block;
+   l_irreg2 = (l_combined-l_irreg1)%l_block;
+   BOOST_ASSERT(((l_combined-l_irreg1-l_irreg2)%l_block) == 0);
+   size_type const n_reg_block = (l_combined-l_irreg1-l_irreg2)/l_block;
+   n_block_a = l_prev_merged/l_block;
+   n_block_b = n_reg_block - n_block_a;
+   BOOST_ASSERT(n_reg_block>=n_block_a);
 
-   (void)l_total_combined;
-   BOOST_ASSERT(l_total_combined <= len);
+   //Key initialization
+   if (do_initialize_keys) {
+      initialize_keys(keys, keys + needed_keys_count(n_block_a, n_block_b), key_comp, xbuf);
+   }
+}
 
-   size_type n_bef_irreg2, n_aft_irreg2, midkey_idx, l_irreg1, l_irreg2;
-   size_type const max_i = n_reg_combined + (l_irreg_combined != 0);
+template<class RandIt1, class RandIt2, class RandItB, class Compare, class Op>
+RandItB op_buffered_partial_merge_and_swap_to_range1_and_buffer
+   ( RandIt1 first1, RandIt1 const last1
+   , RandIt2 &rfirst2, RandIt2 const last2, RandIt2 &rfirst_min
+   , RandItB &rfirstb, Compare comp, Op op )
+{
+   RandItB firstb = rfirstb;
+   RandItB lastb  = firstb;
+   RandIt2 first2 = rfirst2;
 
-   if(merge_left || !use_buf) {
-      for( size_type combined_i = 0; combined_i != max_i; ++combined_i, combined_first += l_reg_combined) {
-         bool const is_last = combined_i==n_reg_combined;
-         size_type const l_cur_combined = is_last ? l_irreg_combined : l_reg_combined;
+   //Move to buffer while merging
+   //Three way moves need less moves when op is swap_op so use it
+   //when merging elements from range2 to the destination occupied by range1
+   if(first1 != last1 && first2 != last2){
+      RandIt2 first_min = rfirst_min;
+      op(four_way_t(), first2++, first_min++, first1++, lastb++);
 
-         range_xbuf<RandIt, move_op> rbuf( (use_buf && xbuf_used) ? (combined_first-l_block) : combined_first, combined_first);
-         combine_params( keys, key_comp, combined_first, l_cur_combined
-                       , l_prev_merged, l_block, rbuf, comp
-                       , midkey_idx, l_irreg1, n_bef_irreg2, n_aft_irreg2, l_irreg2, true);   //Outputs
-         //Now merge blocks
-         if(!use_buf){
-            merge_blocks_bufferless
-               (keys, keys[midkey_idx], key_comp, combined_first, l_block, 0u, n_bef_irreg2, n_aft_irreg2, l_irreg2, comp);
+      while(first1 != last1){
+         if(first2 == last2){
+            lastb = op(forward_t(), first1, last1, firstb);
+            break;
+         }
+         bool const min_less = comp(*first_min, *firstb);
+
+         if(min_less){
+            op( four_way_t(), first2++, first_min++, first1++, lastb++);
          }
          else{
-            merge_blocks_left
-               (keys, keys[midkey_idx], key_comp, combined_first, l_block, 0u, n_bef_irreg2, n_aft_irreg2, l_irreg2, comp, xbuf_used);
+            op(three_way_t(), firstb++, first1++, lastb++);
+         }
+      }
+      rfirst2 = first2;
+      rfirstb = firstb;
+      rfirst_min = first_min;
+   }
+
+   return lastb;
+}
+
+//////////////////////////////////
+//
+//          partial_merge
+//
+//////////////////////////////////
+template<class InputIt1, class InputIt2, class OutputIt, class Compare, class Op>
+OutputIt op_partial_merge_impl
+   (InputIt1 &r_first1, InputIt1 const last1, InputIt2 &r_first2, InputIt2 const last2, OutputIt d_first, Compare comp, Op op)
+{
+   InputIt1 first1(r_first1);
+   InputIt2 first2(r_first2);
+   if(first2 != last2 && last1 != first1)
+   while(1){
+      if(comp(*first2, *first1)) {
+         op(first2++, d_first++);
+         if(first2 == last2){
+            break;
+         }
+      }
+      else{
+         op(first1++, d_first++);
+         if(first1 == last1){
+            break;
          }
-         //BOOST_MOVE_ADAPTIVE_SORT_PRINT("   After merge_blocks_l: ", len + l_block);
       }
    }
+   r_first1 = first1;
+   r_first2 = first2;
+   return d_first;
+}
+
+template<class InputIt1, class InputIt2, class OutputIt, class Compare, class Op>
+OutputIt op_partial_merge
+   (InputIt1 &r_first1, InputIt1 const last1, InputIt2 &r_first2, InputIt2 const last2, OutputIt d_first, Compare comp, Op op, bool is_stable)
+{
+   return is_stable ? op_partial_merge_impl(r_first1, last1, r_first2, last2, d_first, comp, op)
+                    : op_partial_merge_impl(r_first1, last1, r_first2, last2, d_first, antistable<Compare>(comp), op);
+}
+
+//////////////////////////////////
+//
+//    partial_merge_and_swap
+//
+//////////////////////////////////
+template<class InputIt1, class InputIt2, class OutputIt, class Compare, class Op>
+OutputIt op_partial_merge_and_swap_impl
+   (InputIt1 &r_first1, InputIt1 const last1, InputIt2 &r_first2, InputIt2 const last2, InputIt2 &r_first_min, OutputIt d_first, Compare comp, Op op)
+{
+   InputIt1 first1(r_first1);
+   InputIt2 first2(r_first2);
+   
+   if(first2 != last2 && last1 != first1) {
+      InputIt2 first_min(r_first_min);
+      bool non_empty_ranges = true;
+      do{
+         if(comp(*first_min, *first1)) {
+            op(three_way_t(), first2++, first_min++, d_first++);
+            non_empty_ranges = first2 != last2;
+         }
+         else{
+            op(first1++, d_first++);
+            non_empty_ranges = first1 != last1;
+         }
+      } while(non_empty_ranges);
+      r_first_min = first_min;
+      r_first1 = first1;
+      r_first2 = first2;
+   }
+   return d_first;
+}
+
+template<class RandIt, class InputIt2, class OutputIt, class Compare, class Op>
+RandIt op_partial_merge_and_swap
+   (RandIt &r_first1, RandIt const last1, RandIt &r_first2, RandIt const last2, InputIt2 &r_first_min, OutputIt d_first, Compare comp, Op op, bool is_stable)
+{
+   return is_stable ? op_partial_merge_and_swap_impl(r_first1, last1, r_first2, last2, r_first_min, d_first, comp, op)
+                    : op_partial_merge_and_swap_impl(r_first1, last1, r_first2, last2, r_first_min, d_first, antistable<Compare>(comp), op);
+}
+
+template<class RandIt, class RandItBuf, class Compare, class Op>
+RandIt op_partial_merge_and_save_impl
+   ( RandIt first1, RandIt const last1, RandIt &rfirst2, RandIt last2, RandIt first_min
+   , RandItBuf &buf_first1_in_out, RandItBuf &buf_last1_in_out
+   , Compare comp, Op op
+   )
+{
+   RandItBuf buf_first1 = buf_first1_in_out;
+   RandItBuf buf_last1  = buf_last1_in_out;
+   RandIt first2(rfirst2);
+
+   bool const do_swap = first2 != first_min;
+   if(buf_first1 == buf_last1){
+      //Skip any element that does not need to be moved
+      RandIt new_first1 = skip_until_merge(first1, last1, *first_min, comp);
+      buf_first1 += (new_first1-first1);
+      first1 = new_first1;
+      buf_last1  = do_swap ? op_buffered_partial_merge_and_swap_to_range1_and_buffer(first1, last1, first2, last2, first_min, buf_first1, comp, op)
+                           : op_buffered_partial_merge_to_range1_and_buffer    (first1, last1, first2, last2, buf_first1, comp, op);
+      first1 = last1;
+   }
    else{
-      combined_first += l_reg_combined*(max_i-1);
-      for( size_type combined_i = max_i; combined_i--; combined_first -= l_reg_combined) {
-         bool const is_last = combined_i==n_reg_combined;
-         size_type const l_cur_combined = is_last ? l_irreg_combined : l_reg_combined;
-         RandIt const combined_last(combined_first+l_cur_combined);
-         range_xbuf<RandIt, move_op> rbuf(combined_last, xbuf_used ? (combined_last+l_block) : combined_last);
-         combine_params( keys, key_comp, combined_first, l_cur_combined
-                     , l_prev_merged, l_block, rbuf, comp
-                     , midkey_idx, l_irreg1, n_bef_irreg2, n_aft_irreg2, l_irreg2, false);  //Outputs
-         //BOOST_MOVE_ADAPTIVE_SORT_PRINT("   After combine_params: ", len + l_block);
-         merge_blocks_right
-            (keys, keys[midkey_idx], key_comp, combined_first, l_block, n_bef_irreg2, n_aft_irreg2, l_irreg2, comp, xbuf_used);
-         //BOOST_MOVE_ADAPTIVE_SORT_PRINT("   After merge_blocks_r: ", len + l_block);
+      BOOST_ASSERT((last1-first1) == (buf_last1 - buf_first1));
+   }
+
+   //Now merge from buffer
+   first1 = do_swap ? op_partial_merge_and_swap_impl(buf_first1, buf_last1, first2, last2, first_min, first1, comp, op)
+                    : op_partial_merge_impl    (buf_first1, buf_last1, first2, last2, first1, comp, op);
+   buf_first1_in_out = buf_first1;
+   buf_last1_in_out  = buf_last1;
+   rfirst2 = first2;
+   return first1;
+}
+
+template<class RandIt, class RandItBuf, class Compare, class Op>
+RandIt op_partial_merge_and_save
+   ( RandIt first1, RandIt const last1, RandIt &rfirst2, RandIt last2, RandIt first_min
+   , RandItBuf &buf_first1_in_out
+   , RandItBuf &buf_last1_in_out
+   , Compare comp
+   , Op op
+   , bool is_stable)
+{
+   return is_stable
+      ? op_partial_merge_and_save_impl
+         (first1, last1, rfirst2, last2, first_min, buf_first1_in_out, buf_last1_in_out, comp, op)
+      : op_partial_merge_and_save_impl
+         (first1, last1, rfirst2, last2, first_min, buf_first1_in_out, buf_last1_in_out, antistable<Compare>(comp), op)
+      ;
+}
+
+
+
+template<class RandItKeys, class KeyCompare, class RandIt, class RandIt2, class OutputIt, class Compare, class Op>
+OutputIt op_merge_blocks_with_irreg
+   ( RandItKeys key_first
+   , RandItKeys key_mid
+   , KeyCompare key_comp
+   , RandIt first_reg
+   , RandIt2 &first_irr
+   , RandIt2 const last_irr
+   , OutputIt dest
+   , typename iterator_traits<RandIt>::size_type const l_block
+   , typename iterator_traits<RandIt>::size_type n_block_left
+   , typename iterator_traits<RandIt>::size_type min_check
+   , typename iterator_traits<RandIt>::size_type max_check
+   , Compare comp, bool const is_stable, Op op)
+{
+   typedef typename iterator_traits<RandIt>::size_type size_type;
+
+   for(; n_block_left; --n_block_left, ++key_first, min_check -= min_check != 0, max_check -= max_check != 0){
+      size_type next_key_idx = find_next_block(key_first, key_comp, first_reg, l_block, min_check, max_check, comp);  
+      max_check = min_value(max_value(max_check, next_key_idx+2), n_block_left);
+      RandIt const last_reg  = first_reg + l_block;
+      RandIt first_min = first_reg + next_key_idx*l_block;
+      RandIt const last_min  = first_min + l_block; (void)last_min;
+
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first_reg, last_reg, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!next_key_idx || is_sorted(first_min, last_min, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT((!next_key_idx || !comp(*first_reg, *first_min )));
+
+      OutputIt orig_dest = dest; (void)orig_dest;
+      dest = next_key_idx ? op_partial_merge_and_swap(first_irr, last_irr, first_reg, last_reg, first_min, dest, comp, op, is_stable)
+                          : op_partial_merge    (first_irr, last_irr, first_reg, last_reg, dest, comp, op, is_stable);
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(orig_dest, dest, comp));
+
+      if(first_reg == dest){
+         dest = next_key_idx ? ::boost::adl_move_swap_ranges(first_min, last_min, first_reg)
+                             : last_reg;
       }
+      else{
+         dest = next_key_idx ? op(three_way_forward_t(), first_reg, last_reg, first_min, dest)
+                             : op(forward_t(), first_reg, last_reg, dest);
+      }
+
+      RandItKeys const key_next(key_first + next_key_idx);
+      swap_and_update_key(next_key_idx != 0, key_next, key_first, key_mid, last_reg, last_reg, first_min);
+
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(orig_dest, dest, comp));
+      first_reg = last_reg;
+   }
+   return dest;
+}
+
+template<class RandItKeys, class KeyCompare, class RandIt, class Compare, class Op>
+void op_merge_blocks_left
+   ( RandItKeys const key_first
+   , KeyCompare key_comp
+   , RandIt const first
+   , typename iterator_traits<RandIt>::size_type const l_block
+   , typename iterator_traits<RandIt>::size_type const l_irreg1
+   , typename iterator_traits<RandIt>::size_type const n_block_a
+   , typename iterator_traits<RandIt>::size_type const n_block_b
+   , typename iterator_traits<RandIt>::size_type const l_irreg2
+   , Compare comp, Op op)
+{
+   typedef typename iterator_traits<RandIt>::size_type size_type;
+   size_type const key_count = needed_keys_count(n_block_a, n_block_b); (void)key_count;
+//   BOOST_ASSERT(n_block_a || n_block_b);
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted_and_unique(key_first, key_first + key_count, key_comp));
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_b || n_block_a == count_if_with(key_first, key_first + key_count, key_comp, key_first[n_block_a]));
+
+   size_type n_block_b_left = n_block_b;
+   size_type n_block_a_left = n_block_a;
+   size_type n_block_left = n_block_b + n_block_a;
+   RandItKeys key_mid(key_first + n_block_a);
+
+   RandIt buffer = first - l_block;
+   RandIt first1 = first;
+   RandIt last1  = first1 + l_irreg1;
+   RandIt first2 = last1;
+   RandIt const irreg2 = first2 + n_block_left*l_block;
+   bool is_range1_A = true;
+
+   RandItKeys key_range2(key_first);
+
+   ////////////////////////////////////////////////////////////////////////////
+   //Process all regular blocks before the irregular B block
+   ////////////////////////////////////////////////////////////////////////////
+   size_type min_check = n_block_a == n_block_left ? 0u : n_block_a;
+   size_type max_check = min_value(min_check+1, n_block_left);
+   for (; n_block_left; --n_block_left, ++key_range2, min_check -= min_check != 0, max_check -= max_check != 0) {
+      size_type const next_key_idx = find_next_block(key_range2, key_comp, first2, l_block, min_check, max_check, comp);
+      max_check = min_value(max_value(max_check, next_key_idx+2), n_block_left);
+      RandIt const first_min = first2 + next_key_idx*l_block;
+      RandIt const last_min  = first_min + l_block; (void)last_min;
+      RandIt const last2  = first2 + l_block;
+
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first1, last1, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first2, last2, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_left || is_sorted(first_min, last_min, comp));
+
+      //Check if irregular b block should go here.
+      //If so, break to the special code handling the irregular block
+      if (!n_block_b_left &&
+            ( (l_irreg2 && comp(*irreg2, *first_min)) || (!l_irreg2 && is_range1_A)) ){
+         break;
+      }
+
+      RandItKeys const key_next(key_range2 + next_key_idx);
+      bool const is_range2_A = key_mid == (key_first+key_count) || key_comp(*key_next, *key_mid);
+
+      bool const is_buffer_middle = last1 == buffer;
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT( ( is_buffer_middle && size_type(first2-buffer) == l_block && buffer == last1) ||
+                                          (!is_buffer_middle && size_type(first1-buffer) == l_block && first2 == last1));
+
+      if(is_range1_A == is_range2_A){
+         BOOST_ASSERT((first1 == last1) || !comp(*first_min, last1[-1]));
+         if(!is_buffer_middle){
+            buffer = op(forward_t(), first1, last1, buffer);
+         }
+         swap_and_update_key(next_key_idx != 0, key_next, key_range2, key_mid, first2, last2, first_min);
+         first1 = first2;
+         last1  = last2;
+      }
+      else {
+         RandIt unmerged;
+         RandIt buf_beg;
+         RandIt buf_end;
+         if(is_buffer_middle){
+            buf_end = buf_beg = first2 - (last1-first1);
+            unmerged = op_partial_merge_and_save( first1, last1, first2, last2, first_min
+                                                , buf_beg, buf_end, comp, op, is_range1_A);
+         }  
+         else{
+            buf_beg = first1;
+            buf_end = last1;
+            unmerged = op_partial_merge_and_save
+               (buffer, buffer+(last1-first1), first2, last2, first_min, buf_beg, buf_end, comp, op, is_range1_A);
+         }
+         (void)unmerged;
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first-l_block, unmerged, comp));
+
+         swap_and_update_key( next_key_idx != 0, key_next, key_range2, key_mid, first2, last2
+                            , last_min - size_type(last2 - first2));
+
+         if(buf_beg != buf_end){  //range2 exhausted: is_buffer_middle for the next iteration
+            first1 = buf_beg;
+            last1  = buf_end;
+            BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(buf_end == (last2-l_block));
+            buffer = last1;
+         }
+         else{ //range1 exhausted: !is_buffer_middle for the next iteration
+            first1 = first2;
+            last1  = last2;
+            buffer = first2 - l_block;
+            is_range1_A = is_range2_A;
+         }
+      }
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT( (is_range2_A && n_block_a_left) || (!is_range2_A && n_block_b_left));
+      is_range2_A ? --n_block_a_left : --n_block_b_left;
+      first2 = last2;
+   }
+
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_b || n_block_a == count_if_with(key_first, key_range2 + n_block_left, key_comp, *key_mid));
+   BOOST_ASSERT(!n_block_b_left);
+
+   ////////////////////////////////////////////////////////////////////////////
+   //Process remaining range 1 left before the irregular B block
+   ////////////////////////////////////////////////////////////////////////////
+   bool const is_buffer_middle = last1 == buffer;
+   RandIt first_irr2 = irreg2;
+   RandIt const last_irr2  = first_irr2 + l_irreg2;
+   if(l_irreg2 && is_range1_A){
+      if(is_buffer_middle){
+         first1 = skip_until_merge(first1, last1, *first_irr2, comp);
+         //Even if we copy backward, no overlapping occurs so use forward copy
+         //that can be faster specially with trivial types
+         RandIt const new_first1 = first2 - (last1 - first1);
+         op(forward_t(), first1, last1, new_first1);
+         first1 = new_first1;
+         last1 = first2;
+         buffer = first1 - l_block;
+      }
+      buffer = op_partial_merge_impl(first1, last1, first_irr2, last_irr2, buffer, comp, op);
+      buffer = op(forward_t(), first1, last1, buffer);
+   }
+   else if(!is_buffer_middle){
+      buffer = op(forward_t(), first1, last1, buffer);
+   }
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first-l_block, buffer, comp));
+
+   ////////////////////////////////////////////////////////////////////////////
+   //Process irregular B block and remaining A blocks
+   ////////////////////////////////////////////////////////////////////////////
+   buffer = op_merge_blocks_with_irreg
+      ( key_range2, key_mid, key_comp, first2, first_irr2, last_irr2
+      , buffer, l_block, n_block_left, min_check, max_check, comp, false, op);
+   buffer = op(forward_t(), first_irr2, last_irr2, buffer);(void)buffer;
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first-l_block, buffer, comp));
+}
+
+// first - first element to merge.
+// first[-l_block, 0) - buffer (if use_buf == true)
+// l_block - length of regular blocks. First nblocks are stable sorted by 1st elements and key-coded
+// keys - sequence of keys, in same order as blocks. key<midkey means stream A
+// n_bef_irreg2/n_aft_irreg2 are regular blocks
+// l_irreg2 is a irregular block, that is to be combined after n_bef_irreg2 blocks and before n_aft_irreg2 blocks
+// If l_irreg2==0 then n_aft_irreg2==0 (no irregular blocks).
+template<class RandItKeys, class KeyCompare, class RandIt, class Compare>
+void merge_blocks_left
+   ( RandItKeys const key_first
+   , KeyCompare key_comp
+   , RandIt const first
+   , typename iterator_traits<RandIt>::size_type const l_block
+   , typename iterator_traits<RandIt>::size_type const l_irreg1
+   , typename iterator_traits<RandIt>::size_type const n_block_a
+   , typename iterator_traits<RandIt>::size_type const n_block_b
+   , typename iterator_traits<RandIt>::size_type const l_irreg2
+   , Compare comp
+   , bool const xbuf_used)
+{
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_b || n_block_a == count_if_with(key_first, key_first + needed_keys_count(n_block_a, n_block_b), key_comp, key_first[n_block_a]));
+   if(xbuf_used){
+      op_merge_blocks_left
+         (key_first, key_comp, first, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp, move_op());
+   }
+   else{
+      op_merge_blocks_left
+         (key_first, key_comp, first, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp, swap_op());
    }
 }
 
 
-template<class RandIt, class Compare>
-typename iterator_traits<RandIt>::size_type
-   buffered_merge_blocks
-      ( RandIt const first, RandIt const last
-      , typename iterator_traits<RandIt>::size_type const input_combined_size
-      , Compare comp
-      , adaptive_xbuf<typename iterator_traits<RandIt>::value_type> &xbuf)
+// first - first element to merge.
+// [first+l_block*(n_bef_irreg2+n_aft_irreg2)+l_irreg2, first+l_block*(n_bef_irreg2+n_aft_irreg2+1)+l_irreg2) - buffer
+// l_block - length of regular blocks. First nblocks are stable sorted by 1st elements and key-coded
+// keys - sequence of keys, in same order as blocks. key<midkey means stream A
+// n_bef_irreg2/n_aft_irreg2 are regular blocks
+// l_irreg2 is a irregular block, that is to be combined after n_bef_irreg2 blocks and before n_aft_irreg2 blocks
+// If l_irreg2==0 then n_aft_irreg2==0 (no irregular blocks).
+template<class RandItKeys, class KeyCompare, class RandIt, class Compare>
+void merge_blocks_right
+   ( RandItKeys const key_first
+   , KeyCompare key_comp
+   , RandIt const first
+   , typename iterator_traits<RandIt>::size_type const l_block
+   , typename iterator_traits<RandIt>::size_type const n_block_a
+   , typename iterator_traits<RandIt>::size_type const n_block_b
+   , typename iterator_traits<RandIt>::size_type const l_irreg2
+   , Compare comp
+   , bool const xbuf_used)
 {
-   typedef typename iterator_traits<RandIt>::size_type   size_type;
-   size_type combined_size = input_combined_size;
+   merge_blocks_left
+      ( make_reverse_iterator(key_first + needed_keys_count(n_block_a, n_block_b))
+      , inverse<KeyCompare>(key_comp)
+      , make_reverse_iterator(first + ((n_block_a+n_block_b)*l_block+l_irreg2))
+      , l_block
+      , l_irreg2
+      , n_block_b
+      , n_block_a
+      , 0
+      , inverse<Compare>(comp), xbuf_used);
+}
 
-   for( size_type const elements_in_blocks = size_type(last - first)
-      ; elements_in_blocks > combined_size && size_type(xbuf.capacity()) >= combined_size
-      ; combined_size *=2){
-      RandIt merge_point = first;
-      while(size_type(last - merge_point) > 2*combined_size) {
-         RandIt const second_half = merge_point+combined_size;
-         RandIt const next_merge_point = second_half+combined_size;
-         buffered_merge(merge_point, second_half, next_merge_point, comp, xbuf);
-         merge_point = next_merge_point;
+template<class RandItKeys, class KeyCompare, class RandIt, class Compare, class Op, class RandItBuf>
+void op_merge_blocks_with_buf
+   ( RandItKeys key_first
+   , KeyCompare key_comp
+   , RandIt const first
+   , typename iterator_traits<RandIt>::size_type const l_block
+   , typename iterator_traits<RandIt>::size_type const l_irreg1
+   , typename iterator_traits<RandIt>::size_type const n_block_a
+   , typename iterator_traits<RandIt>::size_type const n_block_b
+   , typename iterator_traits<RandIt>::size_type const l_irreg2
+   , Compare comp
+   , Op op
+   , RandItBuf const buf_first)
+{
+   typedef typename iterator_traits<RandIt>::size_type size_type;
+   size_type const key_count = needed_keys_count(n_block_a, n_block_b); (void)key_count;
+   //BOOST_ASSERT(n_block_a || n_block_b);
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted_and_unique(key_first, key_first + key_count, key_comp));
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_b || n_block_a == count_if_with(key_first, key_first + key_count, key_comp, key_first[n_block_a]));
+
+   size_type n_block_b_left = n_block_b;
+   size_type n_block_a_left = n_block_a;
+   size_type n_block_left = n_block_b + n_block_a;
+   RandItKeys key_mid(key_first + n_block_a);
+
+   RandItBuf buffer = buf_first;
+   RandItBuf buffer_end = buffer;
+   RandIt first1 = first;
+   RandIt last1  = first1 + l_irreg1;
+   RandIt first2 = last1;
+   RandIt const first_irr2 = first2 + n_block_left*l_block;
+   bool is_range1_A = true;
+
+   RandItKeys key_range2(key_first);
+
+   ////////////////////////////////////////////////////////////////////////////
+   //Process all regular blocks before the irregular B block
+   ////////////////////////////////////////////////////////////////////////////
+   size_type min_check = n_block_a == n_block_left ? 0u : n_block_a;
+   size_type max_check = min_value(min_check+1, n_block_left);
+   for (; n_block_left; --n_block_left, ++key_range2, min_check -= min_check != 0, max_check -= max_check != 0) {
+      size_type const next_key_idx = find_next_block(key_range2, key_comp, first2, l_block, min_check, max_check, comp);
+      max_check = min_value(max_value(max_check, next_key_idx+2), n_block_left);
+      RandIt       first_min = first2 + next_key_idx*l_block;
+      RandIt const last_min  = first_min + l_block; (void)last_min;
+      RandIt const last2  = first2 + l_block;
+
+      bool const buffer_empty = buffer == buffer_end; (void)buffer_empty;
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(buffer_empty ? is_sorted(first1, last1, comp) : is_sorted(buffer, buffer_end, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first2, last2, comp));
+      BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!n_block_left || is_sorted(first_min, last_min, comp));
+
+      //Check if irregular b block should go here.
+      //If so, break to the special code handling the irregular block
+      if (!n_block_b_left &&
+            ( (l_irreg2 && comp(*first_irr2, *first_min)) || (!l_irreg2 && is_range1_A)) ){
+         break;
       }
-      if(size_type(last-merge_point) > combined_size){
-         buffered_merge(merge_point, merge_point+combined_size, last, comp, xbuf);
+
+      RandItKeys const key_next(key_range2 + next_key_idx);
+      bool const is_range2_A = key_mid == (key_first+key_count) || key_comp(*key_next, *key_mid);
+
+      if(is_range1_A == is_range2_A){
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT((first1 == last1) || (buffer_empty ? !comp(*first_min, last1[-1]) : !comp(*first_min, buffer_end[-1])));
+         //If buffered, put those elements in place
+         RandIt res = op(forward_t(), buffer, buffer_end, first1);
+         buffer    = buffer_end = buf_first;
+         BOOST_ASSERT(buffer_empty || res == last1); (void)res;
+         swap_and_update_key(next_key_idx != 0, key_next, key_range2, key_mid, first2, last2, first_min);
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first2, last2, comp));
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first_min, last_min, comp));
+         first1 = first2;
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first, first1, comp));
       }
+      else {
+         RandIt const unmerged = op_partial_merge_and_save(first1, last1, first2, last2, first_min, buffer, buffer_end, comp, op, is_range1_A);
+         bool const is_range_1_empty = buffer == buffer_end;
+         BOOST_ASSERT(is_range_1_empty || (buffer_end-buffer) == (last1+l_block-unmerged));
+         if(is_range_1_empty){
+            buffer    = buffer_end = buf_first;
+            first_min = last_min - (last2 - first2);
+         }
+         else{
+            first_min = last_min;
+         }
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(!is_range_1_empty || (last_min-first_min) == (last2-unmerged));
+         swap_and_update_key(next_key_idx != 0, key_next, key_range2, key_mid, first2, last2, first_min);
+
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first_min, last_min, comp));
+         is_range1_A ^= is_range_1_empty;
+         first1 = unmerged;
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first, unmerged, comp));
+      }
+      BOOST_ASSERT( (is_range2_A && n_block_a_left) || (!is_range2_A && n_block_b_left));
+      is_range2_A ? --n_block_a_left : --n_block_b_left;
+      last1 += l_block;
+      first2 = last2;
+   }
+
+   RandIt res = op(forward_t(), buffer, buffer_end, first1); (void)res;
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first, res, comp));
+
+   ////////////////////////////////////////////////////////////////////////////
+   //Process irregular B block and remaining A blocks
+   ////////////////////////////////////////////////////////////////////////////
+   RandIt const last_irr2 = first_irr2 + l_irreg2;
+   op(forward_t(), first_irr2, first_irr2+l_irreg2, buf_first);
+   buffer = buf_first;
+   buffer_end = buffer+l_irreg2;
+
+   reverse_iterator<RandItBuf> rbuf_beg(buffer_end);
+   RandIt dest = op_merge_blocks_with_irreg
+      ( make_reverse_iterator(key_first + n_block_b + n_block_a), make_reverse_iterator(key_mid), inverse<KeyCompare>(key_comp)
+      , make_reverse_iterator(first_irr2), rbuf_beg
+      , make_reverse_iterator(buffer), make_reverse_iterator(last_irr2)
+      , l_block, n_block_left, 0, n_block_left
+      , inverse<Compare>(comp), true, op).base();
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(dest, last_irr2, comp));
+
+   buffer_end = rbuf_beg.base();
+   BOOST_ASSERT((dest-last1) == (buffer_end-buffer));
+   op_merge_with_left_placed(is_range1_A ? first1 : last1, last1, dest, buffer, buffer_end, comp, op);
+
+   BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(first, last_irr2, comp));
+}
+
+template<class RandItKeys, class KeyCompare, class RandIt, class Compare, class RandItBuf>
+void merge_blocks_with_buf
+   ( RandItKeys key_first
+   , KeyCompare key_comp
+   , RandIt const first
+   , typename iterator_traits<RandIt>::size_type const l_block
+   , typename iterator_traits<RandIt>::size_type const l_irreg1
+   , typename iterator_traits<RandIt>::size_type const n_block_a
+   , typename iterator_traits<RandIt>::size_type const n_block_b
+   , typename iterator_traits<RandIt>::size_type const l_irreg2
+   , Compare comp
+   , RandItBuf const buf_first
+   , bool const xbuf_used)
+{
+   if(xbuf_used){
+      op_merge_blocks_with_buf
+         (key_first, key_comp, first, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp, move_op(), buf_first);
+   }
+   else{
+      op_merge_blocks_with_buf
+         (key_first, key_comp, first, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp, swap_op(), buf_first);
    }
-   return combined_size;
 }
 
 template<class RandIt, class Compare, class Op>
@@ -1514,7 +1598,7 @@ typename iterator_traits<RandIt>::size_type
 
 template<class RandIt, class Compare, class Op>
 typename iterator_traits<RandIt>::size_type  
-   op_merge_left_step
+   op_merge_left_step_multiple
       ( RandIt first_block
       , typename iterator_traits<RandIt>::size_type const elements_in_blocks
       , typename iterator_traits<RandIt>::size_type l_merged
@@ -1529,14 +1613,17 @@ typename iterator_traits<RandIt>::size_type
       RandIt pos = first_block;
       while((elements_in_blocks - p0) > 2*l_merged) {
          op_merge_left(pos-l_merged, pos, pos+l_merged, pos+2*l_merged, comp, op);
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(pos-l_merged, pos+l_merged, comp));
          p0 += 2*l_merged;
          pos = first_block+p0;
       }
       if((elements_in_blocks-p0) > l_merged) {
          op_merge_left(pos-l_merged, pos, pos+l_merged, first_block+elements_in_blocks, comp, op);
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(pos-l_merged, pos-l_merged+(first_block+elements_in_blocks-pos), comp));
       }
       else {
          op(forward_t(), pos, first_block+elements_in_blocks, pos-l_merged);
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(pos-l_merged, first_block+elements_in_blocks-l_merged, comp));
       }
       first_block -= l_merged;
       l_left_space -= l_merged;
@@ -1545,7 +1632,7 @@ typename iterator_traits<RandIt>::size_type
 }
 
 template<class RandIt, class Compare, class Op>
-void op_merge_right_step
+void op_merge_right_step_once
       ( RandIt first_block
       , typename iterator_traits<RandIt>::size_type const elements_in_blocks
       , typename iterator_traits<RandIt>::size_type const l_build_buf
@@ -1590,14 +1677,14 @@ void op_merge_right_step
 //
 // As a last step, if auxiliary memory is available in-place merge is performed.
 // until all is merged or auxiliary memory is not large enough.
-template<class RandIt, class Compare>
+template<class RandIt, class Compare, class XBuf>
 typename iterator_traits<RandIt>::size_type  
    adaptive_sort_build_blocks
       ( RandIt const first
       , typename iterator_traits<RandIt>::size_type const len
       , typename iterator_traits<RandIt>::size_type const l_base
       , typename iterator_traits<RandIt>::size_type const l_build_buf
-      , adaptive_xbuf<typename iterator_traits<RandIt>::value_type> & xbuf
+      , XBuf & xbuf
       , Compare comp)
 {
    typedef typename iterator_traits<RandIt>::size_type  size_type;
@@ -1613,74 +1700,138 @@ typename iterator_traits<RandIt>::size_type
    //////////////////////////////////
    size_type l_merged = 0u;
 
-//   if(xbuf.capacity()>=2*l_build_buf){
-   if(!l_build_buf){
-      l_merged = insertion_sort_step(first_block, elements_in_blocks, l_base, comp);
-      //2*l_build_buf already merged, now try to merge further
-      //using classic in-place mergesort if enough auxiliary memory is available
-      return buffered_merge_blocks
-         (first_block, first_block + elements_in_blocks, l_merged, comp, xbuf);
+   BOOST_ASSERT(l_build_buf);
+   //If there is no enough buffer for the insertion sort step, just avoid the external buffer
+   size_type kbuf = min_value<size_type>(l_build_buf, size_type(xbuf.capacity()));
+   kbuf = kbuf < l_base ? 0 : kbuf;
+
+   if(kbuf){
+      //Backup internal buffer values in external buffer so they can be overwritten
+      xbuf.move_assign(first+l_build_buf-kbuf, kbuf);
+      l_merged = op_insertion_sort_step_left(first_block, elements_in_blocks, l_base, comp, move_op());
+
+      //Now combine them using the buffer. Elements from buffer can be
+      //overwritten since they've been saved to xbuf
+      l_merged = op_merge_left_step_multiple
+         ( first_block - l_merged, elements_in_blocks, l_merged, l_build_buf, kbuf - l_merged, comp, move_op());
+
+      //Restore internal buffer from external buffer unless kbuf was l_build_buf,
+      //in that case restoration will happen later
+      if(kbuf != l_build_buf){
+         boost::move(xbuf.data()+kbuf-l_merged, xbuf.data() + kbuf, first_block-l_merged+elements_in_blocks);
+      }
    }
    else{
-      //If there is no enough buffer for the insertion sort step, just avoid the external buffer
-      size_type kbuf = min_value<size_type>(l_build_buf, size_type(xbuf.capacity()));
-      kbuf = kbuf < l_base ? 0 : kbuf;
+      l_merged = insertion_sort_step(first_block, elements_in_blocks, l_base, comp);
+      rotate_gcd(first_block - l_merged, first_block, first_block+elements_in_blocks);
+   }
 
-      if(kbuf){
-         //Backup internal buffer values in external buffer so they can be overwritten
-         xbuf.move_assign(first+l_build_buf-kbuf, kbuf);
-         l_merged = op_insertion_sort_step_left(first_block, elements_in_blocks, l_base, comp, move_op());
+   //Now combine elements using the buffer. Elements from buffer can't be
+   //overwritten since xbuf was not big enough, so merge swapping elements.
+   l_merged = op_merge_left_step_multiple
+      (first_block - l_merged, elements_in_blocks, l_merged, l_build_buf, l_build_buf - l_merged, comp, swap_op());
 
-         //Now combine them using the buffer. Elements from buffer can be
-         //overwritten since they've been saved to xbuf
-         l_merged = op_merge_left_step
-            ( first_block - l_merged, elements_in_blocks, l_merged, l_build_buf, kbuf - l_merged, comp, move_op());
+   BOOST_ASSERT(l_merged == l_build_buf);
 
-         //Restore internal buffer from external buffer unless kbuf was l_build_buf,
-         //in that case restoration will happen later
-         if(kbuf != l_build_buf){
-            boost::move(xbuf.data()+kbuf-l_merged, xbuf.data() + kbuf, first_block-l_merged+elements_in_blocks);
+   //////////////////////////////////
+   // Start of merge to right step
+   //////////////////////////////////
+
+   //If kbuf is l_build_buf then we can merge right without swapping
+   //Saved data is still in xbuf
+   if(kbuf && kbuf == l_build_buf){
+      op_merge_right_step_once(first, elements_in_blocks, l_build_buf, comp, move_op());
+      //Restore internal buffer from external buffer if kbuf was l_build_buf.
+      //as this operation was previously delayed.
+      boost::move(xbuf.data(), xbuf.data() + kbuf, first);
+   }
+   else{
+      op_merge_right_step_once(first, elements_in_blocks, l_build_buf, comp, swap_op());
+   }
+   xbuf.clear();
+   //2*l_build_buf or total already merged
+   return min_value(elements_in_blocks, 2*l_build_buf);
+}
+
+template<class RandItKeys, class KeyCompare, class RandIt, class Compare, class XBuf>
+void adaptive_sort_combine_blocks
+   ( RandItKeys const keys
+   , KeyCompare key_comp
+   , RandIt const first
+   , typename iterator_traits<RandIt>::size_type const len
+   , typename iterator_traits<RandIt>::size_type const l_prev_merged
+   , typename iterator_traits<RandIt>::size_type const l_block
+   , bool const use_buf
+   , bool const xbuf_used
+   , XBuf & xbuf
+   , Compare comp
+   , bool merge_left)
+{
+   (void)xbuf;
+   typedef typename iterator_traits<RandIt>::size_type   size_type;
+
+   size_type const l_reg_combined   = 2*l_prev_merged;
+   size_type l_irreg_combined = 0;
+   size_type const l_total_combined = calculate_total_combined(len, l_prev_merged, &l_irreg_combined);
+   size_type const n_reg_combined = len/l_reg_combined;
+   RandIt combined_first = first;
+
+   (void)l_total_combined;
+   BOOST_ASSERT(l_total_combined <= len);
+
+   size_type const max_i = n_reg_combined + (l_irreg_combined != 0);
+
+   if(merge_left || !use_buf) {
+      for( size_type combined_i = 0; combined_i != max_i; ++combined_i, combined_first += l_reg_combined) {
+         //Now merge blocks
+         bool const is_last = combined_i==n_reg_combined;
+         size_type const l_cur_combined = is_last ? l_irreg_combined : l_reg_combined;
+
+         range_xbuf<RandIt, move_op> rbuf( (use_buf && xbuf_used) ? (combined_first-l_block) : combined_first, combined_first);
+         size_type n_block_a, n_block_b, l_irreg1, l_irreg2;
+         combine_params( keys, key_comp, l_cur_combined
+                        , l_prev_merged, l_block, rbuf
+                        , n_block_a, n_block_b, l_irreg1, l_irreg2);   //Outputs
+         BOOST_MOVE_ADAPTIVE_SORT_PRINT("   A combpar:            ", len + l_block);
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(combined_first, combined_first + n_block_a*l_block+l_irreg1, comp));
+            BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(combined_first + n_block_a*l_block+l_irreg1, combined_first + n_block_a*l_block+l_irreg1+n_block_b*l_block+l_irreg2, comp));
+         if(!use_buf){
+            merge_blocks_bufferless
+               (keys, key_comp, combined_first, l_block, 0u, n_block_a, n_block_b, l_irreg2, comp);
          }
+         else{
+            merge_blocks_left
+               (keys, key_comp, combined_first, l_block, 0u, n_block_a, n_block_b, l_irreg2, comp, xbuf_used);
+         }
+         BOOST_MOVE_ADAPTIVE_SORT_PRINT("   After merge_blocks_l: ", len + l_block);
       }
-      else{
-         l_merged = insertion_sort_step(first_block, elements_in_blocks, l_base, comp);
-         rotate_gcd(first_block - l_merged, first_block, first_block+elements_in_blocks);
+   }
+   else{
+      combined_first += l_reg_combined*(max_i-1);
+      for( size_type combined_i = max_i; combined_i--; combined_first -= l_reg_combined) {
+         bool const is_last = combined_i==n_reg_combined;
+         size_type const l_cur_combined = is_last ? l_irreg_combined : l_reg_combined;
+
+         RandIt const combined_last(combined_first+l_cur_combined);
+         range_xbuf<RandIt, move_op> rbuf(combined_last, xbuf_used ? (combined_last+l_block) : combined_last);
+         size_type n_block_a, n_block_b, l_irreg1, l_irreg2;
+         combine_params( keys, key_comp, l_cur_combined
+                        , l_prev_merged, l_block, rbuf
+                        , n_block_a, n_block_b, l_irreg1, l_irreg2);  //Outputs
+         BOOST_MOVE_ADAPTIVE_SORT_PRINT("   A combpar:            ", len + l_block);
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(combined_first, combined_first + n_block_a*l_block+l_irreg1, comp));
+         BOOST_MOVE_ADAPTIVE_SORT_INVARIANT(is_sorted(combined_first + n_block_a*l_block+l_irreg1, combined_first + n_block_a*l_block+l_irreg1+n_block_b*l_block+l_irreg2, comp));
+         merge_blocks_right
+            (keys, key_comp, combined_first, l_block, n_block_a, n_block_b, l_irreg2, comp, xbuf_used);
+         BOOST_MOVE_ADAPTIVE_SORT_PRINT("   After merge_blocks_r: ", len + l_block);
       }
-
-      //Now combine elements using the buffer. Elements from buffer can't be
-      //overwritten since xbuf was not big enough, so merge swapping elements.
-      l_merged = op_merge_left_step
-         (first_block - l_merged, elements_in_blocks, l_merged, l_build_buf, l_build_buf - l_merged, comp, swap_op());
-
-      BOOST_ASSERT(l_merged == l_build_buf);
-
-      //////////////////////////////////
-      // Start of merge to right step
-      //////////////////////////////////
-
-      //If kbuf is l_build_buf then we can merge right without swapping
-      //Saved data is still in xbuf
-      if(kbuf && kbuf == l_build_buf){
-         op_merge_right_step(first, elements_in_blocks, l_build_buf, comp, move_op());
-         //Restore internal buffer from external buffer if kbuf was l_build_buf.
-         //as this operation was previously delayed.
-         boost::move(xbuf.data(), xbuf.data() + kbuf, first);
-      }
-      else{
-         op_merge_right_step(first, elements_in_blocks, l_build_buf, comp, swap_op());
-      }
-      xbuf.clear();
-      //2*l_build_buf already merged, now try to merge further
-      //using classic in-place mergesort if enough auxiliary memory is available
-      return buffered_merge_blocks
-         (first_block, first_block + elements_in_blocks, l_build_buf*2, comp, xbuf);
    }
 }
 
 //Returns true if buffer is placed in 
 //[buffer+len-l_intbuf, buffer+len). Otherwise, buffer is
 //[buffer,buffer+l_intbuf)
-template<class RandIt, class Compare>
+template<class RandIt, class Compare, class XBuf>
 bool adaptive_sort_combine_all_blocks
    ( RandIt keys
    , typename iterator_traits<RandIt>::size_type &n_keys
@@ -1688,7 +1839,7 @@ bool adaptive_sort_combine_all_blocks
    , typename iterator_traits<RandIt>::size_type const l_buf_plus_data
    , typename iterator_traits<RandIt>::size_type l_merged
    , typename iterator_traits<RandIt>::size_type &l_intbuf
-   , adaptive_xbuf<typename iterator_traits<RandIt>::value_type> & xbuf
+   , XBuf & xbuf
    , Compare comp)
 {
    typedef typename iterator_traits<RandIt>::size_type  size_type;
@@ -1702,7 +1853,7 @@ bool adaptive_sort_combine_all_blocks
    }
 
    bool prev_merge_left = true;
-   size_type l_prev_total_combined = 0u, l_prev_block = 0;
+   size_type l_prev_total_combined = l_merged, l_prev_block = 0;
    bool prev_use_internal_buf = true;
 
    for( size_type n = 0; l_data > l_merged
@@ -1738,8 +1889,8 @@ bool adaptive_sort_combine_all_blocks
                move_data_forward(buf_end, l_diff, buf_beg, common_xbuf);
             }
          }
+         BOOST_MOVE_ADAPTIVE_SORT_PRINT("   After move_data     : ", l_data + l_intbuf);
       }
-      BOOST_MOVE_ADAPTIVE_SORT_PRINT("   After move_data     : ", l_data + l_intbuf);
 
       //Combine to form l_merged*2 segments
       if(n_keys){
@@ -1776,11 +1927,11 @@ bool adaptive_sort_combine_all_blocks
    return buffer_right;
 }
 
-template<class RandIt, class Compare>
+template<class RandIt, class Compare, class XBuf>
 void stable_merge
       ( RandIt first, RandIt const middle, RandIt last
       , Compare comp
-      , adaptive_xbuf<typename iterator_traits<RandIt>::value_type> &xbuf)
+      , XBuf &xbuf)
 {
    BOOST_ASSERT(xbuf.empty());
    typedef typename iterator_traits<RandIt>::size_type   size_type;
@@ -1797,13 +1948,13 @@ void stable_merge
 }
 
 
-template<class RandIt, class Compare>
+template<class RandIt, class Compare, class XBuf>
 void adaptive_sort_final_merge( bool buffer_right
                               , RandIt const first
                               , typename iterator_traits<RandIt>::size_type const l_intbuf
                               , typename iterator_traits<RandIt>::size_type const n_keys
                               , typename iterator_traits<RandIt>::size_type const len
-                              , adaptive_xbuf<typename iterator_traits<RandIt>::value_type> & xbuf
+                              , XBuf & xbuf
                               , Compare comp)
 {
    //BOOST_ASSERT(n_keys || xbuf.size() == l_intbuf);
@@ -1833,11 +1984,11 @@ void adaptive_sort_final_merge( bool buffer_right
    BOOST_MOVE_ADAPTIVE_SORT_PRINT("   After final_merge   : ", len);
 }
 
-template<class RandIt, class Compare, class Unsigned, class T>
+template<class RandIt, class Compare, class Unsigned, class XBuf>
 bool adaptive_sort_build_params
    (RandIt first, Unsigned const len, Compare comp
    , Unsigned &n_keys, Unsigned &l_intbuf, Unsigned &l_base, Unsigned &l_build_buf
-   , adaptive_xbuf<T> & xbuf
+   , XBuf & xbuf
    )
 {
    typedef Unsigned size_type;
@@ -1853,17 +2004,22 @@ bool adaptive_sort_build_params
    //segments of size l_build_buf*2, maximizing the classic merge phase.
    l_intbuf = size_type(ceil_sqrt_multiple(len, &l_base));
 
+   //The internal buffer can be expanded if there is enough external memory
+   while(xbuf.capacity() >= l_intbuf*2){
+      l_intbuf *= 2;
+   }
+
    //This is the minimum number of keys to implement the ideal algorithm
    //
    //l_intbuf is used as buffer plus the key count
-   size_type n_min_ideal_keys = l_intbuf-1u;
+   size_type n_min_ideal_keys = l_intbuf-1;
    while(n_min_ideal_keys >= (len-l_intbuf-n_min_ideal_keys)/l_intbuf){
       --n_min_ideal_keys;
    }
-   ++n_min_ideal_keys;
-   BOOST_ASSERT(n_min_ideal_keys < l_intbuf);
+   n_min_ideal_keys += 1;
+   BOOST_ASSERT(n_min_ideal_keys <= l_intbuf);
 
-   if(xbuf.template supports_aligned_trailing<size_type>(l_intbuf, n_min_ideal_keys)){
+   if(xbuf.template supports_aligned_trailing<size_type>(l_intbuf, (len-l_intbuf-1)/l_intbuf+1)){
       n_keys = 0u;
       l_build_buf = l_intbuf;
    }
@@ -1875,18 +2031,29 @@ bool adaptive_sort_build_params
       //If available memory is 2*sqrt(l), then only sqrt(l) unique keys are needed,
       //(to be used for keys in combine_all_blocks) as the whole l_build_buf
       //will be backuped in the buffer during build_blocks.
-      bool const non_unique_buf = xbuf.capacity() >= 2*l_intbuf;
-      size_type const to_collect = non_unique_buf ? l_intbuf : l_intbuf*2;
+      bool const non_unique_buf = xbuf.capacity() >= l_intbuf;
+      size_type const to_collect = non_unique_buf ? n_min_ideal_keys : l_intbuf*2;
       size_type collected = collect_unique(first, first+len, to_collect, comp, xbuf);
 
       //If available memory is 2*sqrt(l), then for "build_params" 
       //the situation is the same as if 2*l_intbuf were collected.
-      if(non_unique_buf && (collected >= n_min_ideal_keys))
-         collected += l_intbuf;
-
+      if(non_unique_buf && collected == n_min_ideal_keys){
+         l_build_buf = l_intbuf;
+         n_keys = n_min_ideal_keys;
+      }
+      else if(collected == 2*l_intbuf){
+         //l_intbuf*2 elements found. Use all of them in the build phase 
+         l_build_buf = l_intbuf*2;
+         n_keys = l_intbuf;
+      }
+      else if(collected == (n_min_ideal_keys+l_intbuf)){ 
+         l_build_buf = l_intbuf;
+         n_keys = n_min_ideal_keys;
+      }
       //If collected keys are not enough, try to fix n_keys and l_intbuf. If no fix
       //is possible (due to very low unique keys), then go to a slow sort based on rotations.
-      if(collected < (n_min_ideal_keys+l_intbuf)){
+      else{
+         BOOST_ASSERT(collected < (n_min_ideal_keys+l_intbuf));
          if(collected < 4){  //No combination possible with less that 4 keys
             return false;
          }
@@ -1902,25 +2069,13 @@ bool adaptive_sort_build_params
          l_intbuf = 0;
          l_build_buf = n_keys;
       }
-      else if((collected - l_intbuf) >= l_intbuf){
-         //l_intbuf*2 elements found. Use all of them in the build phase 
-         l_build_buf = l_intbuf*2;
-         n_keys = l_intbuf;
-      }
-      else{
-         l_build_buf = l_intbuf;
-         n_keys = n_min_ideal_keys;
-      }
       BOOST_ASSERT((n_keys+l_intbuf) >= l_build_buf);
    }
 
    return true;
 }
 
-
-#define BOOST_MOVE_ADAPTIVE_MERGE_WITH_BUF
-
-template<class RandIt, class Compare>
+template<class RandIt, class Compare, class XBuf>
 inline void adaptive_merge_combine_blocks( RandIt first
                                       , typename iterator_traits<RandIt>::size_type len1
                                       , typename iterator_traits<RandIt>::size_type len2
@@ -1930,44 +2085,46 @@ inline void adaptive_merge_combine_blocks( RandIt first
                                       , bool use_internal_buf
                                       , bool xbuf_used
                                       , Compare comp
-                                      , adaptive_xbuf<typename iterator_traits<RandIt>::value_type> & xbuf
+                                      , XBuf & xbuf
                                       )
 {
    typedef typename iterator_traits<RandIt>::size_type size_type;
    size_type const len = len1+len2;
    size_type const l_combine  = len-collected;
    size_type const l_combine1 = len1-collected;
-   size_type n_bef_irreg2, n_aft_irreg2, l_irreg1, l_irreg2, midkey_idx;
 
-   if(n_keys){
+    if(n_keys){
       RandIt const first_data = first+collected;
       RandIt const keys = first;
-      combine_params( keys, comp, first_data, l_combine
-                     , l_combine1, l_block, xbuf, comp
-                     , midkey_idx, l_irreg1, n_bef_irreg2, n_aft_irreg2, l_irreg2, true, false);   //Outputs
       BOOST_MOVE_ADAPTIVE_SORT_PRINT("   A combine: ", len);
       if(xbuf_used){
+         if(xbuf.size() < l_block){
+            xbuf.initialize_until(l_block, *first);
+         }
          BOOST_ASSERT(xbuf.size() >= l_block);
+         size_type n_block_a, n_block_b, l_irreg1, l_irreg2;
+         combine_params( keys, comp, l_combine
+                           , l_combine1, l_block, xbuf
+                           , n_block_a, n_block_b, l_irreg1, l_irreg2);   //Outputs
          merge_blocks_with_buf
-            (keys, keys[midkey_idx], comp, first_data, l_block, l_irreg1, n_bef_irreg2, n_aft_irreg2, l_irreg2, comp, xbuf, xbuf_used);
+            (keys, comp, first_data, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp, xbuf.data(), xbuf_used);
          BOOST_MOVE_ADAPTIVE_SORT_PRINT("   A mrg xbf: ", len);
       }
-      else if(use_internal_buf){
-         #ifdef BOOST_MOVE_ADAPTIVE_MERGE_WITH_BUF
-         range_xbuf<RandIt, swap_op> rbuf(first_data-l_block, first_data);
-         merge_blocks_with_buf
-            (keys, keys[midkey_idx], comp, first_data, l_block, l_irreg1, n_bef_irreg2, n_aft_irreg2, l_irreg2, comp, rbuf, xbuf_used);
-         BOOST_MOVE_ADAPTIVE_SORT_PRINT("   A mrg buf: ", len);
-         #else
-         merge_blocks_left
-            (keys, keys[midkey_idx], comp, first_data, l_block, l_irreg1, n_bef_irreg2, n_aft_irreg2, l_irreg2, comp, xbuf_used);
-         BOOST_MOVE_ADAPTIVE_SORT_PRINT("   A mrg lft: ", len);
-         #endif
-      }
       else{
-         merge_blocks_bufferless
-            (keys, keys[midkey_idx], comp, first_data, l_block, l_irreg1, n_bef_irreg2, n_aft_irreg2, l_irreg2, comp);
-         BOOST_MOVE_ADAPTIVE_SORT_PRINT("   A mrg xbf: ", len);
+         size_type n_block_a, n_block_b, l_irreg1, l_irreg2;
+         combine_params( keys, comp, l_combine
+                           , l_combine1, l_block, xbuf
+                           , n_block_a, n_block_b, l_irreg1, l_irreg2);   //Outputs
+         if(use_internal_buf){
+            merge_blocks_with_buf
+               (keys, comp, first_data, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp, first_data-l_block, xbuf_used);
+            BOOST_MOVE_ADAPTIVE_SORT_PRINT("   A mrg buf: ", len);
+         }
+         else{
+            merge_blocks_bufferless
+               (keys, comp, first_data, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp);
+            BOOST_MOVE_ADAPTIVE_SORT_PRINT("   A mrg nbf: ", len);
+         }
       }
    }
    else{
@@ -1976,20 +2133,20 @@ inline void adaptive_merge_combine_blocks( RandIt first
          xbuf.initialize_until(l_block, *first);
       }
       size_type *const uint_keys = xbuf.template aligned_trailing<size_type>(l_block);
-      combine_params( uint_keys, less(), first, l_combine
-                     , l_combine1, l_block, xbuf, comp
-                     , midkey_idx, l_irreg1, n_bef_irreg2, n_aft_irreg2, l_irreg2, true, true);   //Outputs
+      size_type n_block_a, n_block_b, l_irreg1, l_irreg2;
+      combine_params( uint_keys, less(), l_combine
+                     , l_combine1, l_block, xbuf
+                     , n_block_a, n_block_b, l_irreg1, l_irreg2, true);   //Outputs
       BOOST_MOVE_ADAPTIVE_SORT_PRINT("   A combine: ", len);
       BOOST_ASSERT(xbuf.size() >= l_block);
       merge_blocks_with_buf
-         (uint_keys, uint_keys[midkey_idx], less(), first, l_block, l_irreg1, n_bef_irreg2, n_aft_irreg2, l_irreg2, comp, xbuf, true);
+         (uint_keys, less(), first, l_block, l_irreg1, n_block_a, n_block_b, l_irreg2, comp, xbuf.data(), true);
       xbuf.clear();
       BOOST_MOVE_ADAPTIVE_SORT_PRINT("   A mrg buf: ", len);
    }
-
 }
 
-template<class RandIt, class Compare>
+template<class RandIt, class Compare, class XBuf>
 inline void adaptive_merge_final_merge( RandIt first
                                       , typename iterator_traits<RandIt>::size_type len1
                                       , typename iterator_traits<RandIt>::size_type len2
@@ -1999,7 +2156,7 @@ inline void adaptive_merge_final_merge( RandIt first
                                       , bool use_internal_buf
                                       , bool xbuf_used
                                       , Compare comp
-                                      , adaptive_xbuf<typename iterator_traits<RandIt>::value_type> & xbuf
+                                      , XBuf & xbuf
                                       )
 {
    typedef typename iterator_traits<RandIt>::size_type size_type;
@@ -2017,27 +2174,11 @@ inline void adaptive_merge_final_merge( RandIt first
          }
       }
       else{
-         #ifdef BOOST_MOVE_ADAPTIVE_MERGE_WITH_BUF
          xbuf.clear();
          stable_sort(first, first+collected, comp, xbuf);
          BOOST_MOVE_ADAPTIVE_SORT_PRINT("   A k/b srt: ", len);
          stable_merge(first, first+collected, first+len, comp, xbuf);
          BOOST_MOVE_ADAPTIVE_SORT_PRINT("   A k/b mrg: ", len);
-         #else
-         xbuf.clear();
-         stable_sort(first+len-l_block, first+len, comp, xbuf);
-         BOOST_MOVE_ADAPTIVE_SORT_PRINT("   A buf srt: ", len);
-         RandIt const pos1 = lower_bound(first+n_keys, first+len-l_block, first[len-1], comp);
-         RandIt const pos2 = rotate_gcd(pos1, first+len-l_block, first+len);
-         stable_merge(first+n_keys, pos1, pos2, antistable<Compare>(comp), xbuf);
-         BOOST_MOVE_ADAPTIVE_SORT_PRINT("   A buf mrg: ", len);
-         if(n_keys){
-            stable_sort(first, first+n_keys, comp, xbuf);
-            BOOST_MOVE_ADAPTIVE_SORT_PRINT("   A key srt: ", len);
-            stable_merge(first, first+n_keys, first+len, comp, xbuf);
-            BOOST_MOVE_ADAPTIVE_SORT_PRINT("   A key mrg: ", len);
-         }
-         #endif
       }
    }
    else{
@@ -2050,24 +2191,29 @@ inline void adaptive_merge_final_merge( RandIt first
 }
 
 template<class SizeType, class Xbuf>
-inline SizeType adaptive_merge_n_keys_intbuf(SizeType l_block, SizeType len, Xbuf & xbuf, SizeType &l_intbuf_inout)
+inline SizeType adaptive_merge_n_keys_intbuf(SizeType &rl_block, SizeType len1, SizeType len2, Xbuf & xbuf, SizeType &l_intbuf_inout)
 {
    typedef SizeType size_type;
+   size_type l_block = rl_block;
    size_type l_intbuf = xbuf.capacity() >= l_block ? 0u : l_block;
 
+   while(xbuf.capacity() >= l_block*2){
+      l_block *= 2;
+   }
+
    //This is the minimum number of keys to implement the ideal algorithm
-   //ceil(len/l_block) - 1 (as the first block is used as buffer)
-   size_type n_keys = len/l_block+1;
-   while(n_keys >= (len-l_intbuf-n_keys)/l_block){
+   size_type n_keys = len1/l_block+len2/l_block;
+   while(n_keys >= ((len1-l_intbuf-n_keys)/l_block + len2/l_block)){
       --n_keys;
    }
    ++n_keys;
-   //BOOST_ASSERT(n_keys < l_block);
+   BOOST_ASSERT(n_keys >= ((len1-l_intbuf-n_keys)/l_block + len2/l_block));
 
    if(xbuf.template supports_aligned_trailing<size_type>(l_block, n_keys)){
       n_keys = 0u;
    }
    l_intbuf_inout = l_intbuf;
+   rl_block = l_block;
    return n_keys;
 }
 
@@ -2106,7 +2252,7 @@ inline SizeType adaptive_merge_n_keys_intbuf(SizeType l_block, SizeType len, Xbu
 //           2*merged_block/csqrtlen keys are sorted to be used as markers
 //         * Groups are selection-sorted by first or last element (depending wheter they
 //           merged to left or right) and keys are reordered accordingly as an imitation-buffer.
-//         * Elements of each block pair is merged using the csqrtlen buffer taking into account
+//         * Elements of each block pair are merged using the csqrtlen buffer taking into account
 //           if they belong to the first half or second half (marked by the key).
 //
 // * In the final merge step leading elements (2*csqrtlen) are sorted and merged with
@@ -2135,12 +2281,12 @@ inline SizeType adaptive_merge_n_keys_intbuf(SizeType l_block, SizeType len, Xbu
 //
 // * If auxiliary memory is available, the "build_blocks" will be extended to build bigger blocks
 //   using classic merge.
-template<class RandIt, class Compare>
+template<class RandIt, class Compare, class XBuf>
 void adaptive_sort_impl
    ( RandIt first
    , typename iterator_traits<RandIt>::size_type const len
    , Compare comp
-   , adaptive_xbuf<typename iterator_traits<RandIt>::value_type> & xbuf
+   , XBuf & xbuf
    )
 {
    typedef typename iterator_traits<RandIt>::size_type  size_type;
@@ -2170,7 +2316,7 @@ void adaptive_sort_impl
       stable_sort(first, first+len, comp, xbuf);
       return;
    }
-
+   BOOST_ASSERT(l_build_buf);
    //Otherwise, continue the adaptive_sort
    BOOST_MOVE_ADAPTIVE_SORT_PRINT("\n   After collect_unique: ", len);
    size_type const n_key_plus_buf = l_intbuf+n_keys;
@@ -2203,13 +2349,14 @@ void adaptive_sort_impl
 //   Explanation of the "combine_blocks" step:
 //
 //         * Trailing [first+to_collect, first+len1) elements are divided in groups of cqrtlen elements.
-//           Remaining elements that can't form a group are grouped in the front of those elements.
+//           Remaining elements that can't form a group are grouped in front of those elements.
 //         * Trailing [first+len1, first+len1+len2) elements are divided in groups of cqrtlen elements.
 //           Remaining elements that can't form a group are grouped in the back of those elements.
-//         * Groups are selection-sorted by first or last element (depending wheter they
-//           merged to left or right) and keys are reordered accordingly as an imitation-buffer.
-//         * Elements of each block pair is merged using the csqrtlen buffer taking into account
-//           if they belong to the first half or second half (marked by the key).
+//         * In parallel the following two steps are performed:
+//             *  Groups are selection-sorted by first or last element (depending wheter they
+//                merged to left or right) and keys are reordered accordingly as an imitation-buffer.
+//             * Elements of each block pair are merged using the csqrtlen buffer taking into account
+//                if they belong to the first half or second half (marked by the key).
 //
 // * In the final merge step leading "to_collect" elements are merged with rotations
 //   with the rest of merged elements in the "combine_blocks" step.
@@ -2232,13 +2379,13 @@ void adaptive_sort_impl
 // * If auxiliary memory is more than csqrtlen+n_keys*sizeof(std::size_t),
 //   then no csqrtlen need to be extracted and "combine_blocks" will use integral
 //   keys to combine blocks.
-template<class RandIt, class Compare>
+template<class RandIt, class Compare, class XBuf>
 void adaptive_merge_impl
    ( RandIt first
    , typename iterator_traits<RandIt>::size_type const len1
    , typename iterator_traits<RandIt>::size_type const len2
    , Compare comp
-   , adaptive_xbuf<typename iterator_traits<RandIt>::value_type> & xbuf
+   , XBuf & xbuf
    )
 {
    typedef typename iterator_traits<RandIt>::size_type size_type;
@@ -2261,7 +2408,7 @@ void adaptive_merge_impl
       //Detail the number of keys and internal buffer. If xbuf has enough memory, no
       //internal buffer is needed so l_intbuf will remain 0.
       size_type l_intbuf = 0;
-      size_type n_keys = adaptive_merge_n_keys_intbuf(l_block, len, xbuf, l_intbuf);
+      size_type n_keys = adaptive_merge_n_keys_intbuf(l_block, len1, len2, xbuf, l_intbuf);
       size_type const to_collect = l_intbuf+n_keys;
       //Try to extract needed unique values from the first range
       size_type const collected  = collect_unique(first, first+len1, to_collect, comp, xbuf);
@@ -2291,6 +2438,7 @@ void adaptive_merge_impl
    }
 }
 
+
 }  //namespace detail_adaptive {
 }  //namespace movelib {
 }  //namespace boost {
diff --git a/contrib/libboost/boost_1_65_0/boost/move/algo/detail/basic_op.hpp b/contrib/libboost/boost_1_65_0/boost/move/algo/detail/basic_op.hpp
new file mode 100644
index 00000000000..ea5faf0e537
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/move/algo/detail/basic_op.hpp
@@ -0,0 +1,121 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2016.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_MOVE_ALGO_BASIC_OP
+#define BOOST_MOVE_ALGO_BASIC_OP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+#
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/move/utility_core.hpp>
+#include <boost/move/adl_move_swap.hpp>
+#include <boost/move/detail/iterator_traits.hpp>
+
+namespace boost {
+namespace movelib {
+
+struct forward_t{};
+struct backward_t{};
+struct three_way_t{};
+struct three_way_forward_t{};
+struct four_way_t{};
+
+struct move_op
+{
+   template <class SourceIt, class DestinationIt>
+   BOOST_MOVE_FORCEINLINE void operator()(SourceIt source, DestinationIt dest)
+   {  *dest = ::boost::move(*source);  }
+
+   template <class SourceIt, class DestinationIt>
+   BOOST_MOVE_FORCEINLINE DestinationIt operator()(forward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
+   {  return ::boost::move(first, last, dest_begin);  }
+
+   template <class SourceIt, class DestinationIt>
+   BOOST_MOVE_FORCEINLINE DestinationIt operator()(backward_t, SourceIt first, SourceIt last, DestinationIt dest_last)
+   {  return ::boost::move_backward(first, last, dest_last);  }
+
+   template <class SourceIt, class DestinationIt1, class DestinationIt2>
+   BOOST_MOVE_FORCEINLINE void operator()(three_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it)
+   {
+      *dest2it = boost::move(*dest1it);
+      *dest1it = boost::move(*srcit);
+   }
+
+   template <class SourceIt, class DestinationIt1, class DestinationIt2>
+   DestinationIt2 operator()(three_way_forward_t, SourceIt srcit, SourceIt srcitend, DestinationIt1 dest1it, DestinationIt2 dest2it)
+   {
+      //Destination2 range can overlap SourceIt range so avoid boost::move
+      while(srcit != srcitend){
+         this->operator()(three_way_t(), srcit++, dest1it++, dest2it++);
+      }
+      return dest2it;
+   }
+
+   template <class SourceIt, class DestinationIt1, class DestinationIt2, class DestinationIt3>
+   BOOST_MOVE_FORCEINLINE void operator()(four_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it, DestinationIt3 dest3it)
+   {
+      *dest3it = boost::move(*dest2it);
+      *dest2it = boost::move(*dest1it);
+      *dest1it = boost::move(*srcit);
+   }
+};
+
+struct swap_op
+{
+   template <class SourceIt, class DestinationIt>
+   BOOST_MOVE_FORCEINLINE void operator()(SourceIt source, DestinationIt dest)
+   {  boost::adl_move_swap(*dest, *source);  }
+
+   template <class SourceIt, class DestinationIt>
+   BOOST_MOVE_FORCEINLINE DestinationIt operator()(forward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
+   {  return boost::adl_move_swap_ranges(first, last, dest_begin);  }
+
+   template <class SourceIt, class DestinationIt>
+   BOOST_MOVE_FORCEINLINE DestinationIt operator()(backward_t, SourceIt first, SourceIt last, DestinationIt dest_begin)
+   {  return boost::adl_move_swap_ranges_backward(first, last, dest_begin);  }
+
+   template <class SourceIt, class DestinationIt1, class DestinationIt2>
+   BOOST_MOVE_FORCEINLINE void operator()(three_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it)
+   {
+      typename ::boost::movelib::iterator_traits<SourceIt>::value_type tmp(boost::move(*dest2it));
+      *dest2it = boost::move(*dest1it);
+      *dest1it = boost::move(*srcit);
+      *srcit = boost::move(tmp);
+   }
+
+   template <class SourceIt, class DestinationIt1, class DestinationIt2>
+   DestinationIt2 operator()(three_way_forward_t, SourceIt srcit, SourceIt srcitend, DestinationIt1 dest1it, DestinationIt2 dest2it)
+   {
+      while(srcit != srcitend){
+         this->operator()(three_way_t(), srcit++, dest1it++, dest2it++);
+      }
+      return dest2it;
+   }
+
+   template <class SourceIt, class DestinationIt1, class DestinationIt2, class DestinationIt3>
+   BOOST_MOVE_FORCEINLINE void operator()(four_way_t, SourceIt srcit, DestinationIt1 dest1it, DestinationIt2 dest2it, DestinationIt3 dest3it)
+   {
+      typename ::boost::movelib::iterator_traits<SourceIt>::value_type tmp(boost::move(*dest3it));
+      *dest3it = boost::move(*dest2it);
+      *dest2it = boost::move(*dest1it);
+      *dest1it = boost::move(*srcit);
+      *srcit = boost::move(tmp);
+   }
+};
+
+
+}} //namespace boost::movelib
+
+#endif   //BOOST_MOVE_ALGO_BASIC_OP
diff --git a/contrib/libboost/boost_1_62_0/boost/move/algo/detail/insertion_sort.hpp b/contrib/libboost/boost_1_65_0/boost/move/algo/detail/insertion_sort.hpp
similarity index 84%
rename from contrib/libboost/boost_1_62_0/boost/move/algo/detail/insertion_sort.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/algo/detail/insertion_sort.hpp
index 15df35d9d6f..3328f757483 100644
--- a/contrib/libboost/boost_1_62_0/boost/move/algo/detail/insertion_sort.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/move/algo/detail/insertion_sort.hpp
@@ -31,6 +31,7 @@
 #include <boost/move/detail/destruct_n.hpp>
 #include <boost/move/algo/detail/basic_op.hpp>
 #include <boost/move/detail/placement_new.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
 
 namespace boost {  namespace movelib{
 
@@ -91,30 +92,30 @@ void insertion_sort(BirdirectionalIterator first, BirdirectionalIterator last, C
    }
 }
 
-template <class Compare, class BirdirectionalIterator>
+template <class Compare, class BirdirectionalIterator, class BirdirectionalRawIterator>
 void insertion_sort_uninitialized_copy
    (BirdirectionalIterator first1, BirdirectionalIterator const last1
-   , typename iterator_traits<BirdirectionalIterator>::value_type* const first2
+   , BirdirectionalRawIterator const first2
    , Compare comp)
 {
    typedef typename iterator_traits<BirdirectionalIterator>::value_type value_type;
    if (first1 != last1){
-      value_type* last2 = first2;
-      ::new(last2, boost_move_new_t()) value_type(move(*first1));
-      destruct_n<value_type> d(first2);
+      BirdirectionalRawIterator last2 = first2;
+      ::new((iterator_to_raw_pointer)(last2), boost_move_new_t()) value_type(move(*first1));
+      destruct_n<value_type, BirdirectionalRawIterator> d(first2);
       d.incr();
       for (++last2; ++first1 != last1; ++last2){
-         value_type* j2 = last2;
-         value_type* k2 = j2;
+         BirdirectionalRawIterator j2 = last2;
+         BirdirectionalRawIterator k2 = j2;
          if (comp(*first1, *--k2)){
-            ::new(j2, boost_move_new_t()) value_type(move(*k2));
+            ::new((iterator_to_raw_pointer)(j2), boost_move_new_t()) value_type(move(*k2));
             d.incr();
             for (--j2; k2 != first2 && comp(*first1, *--k2); --j2)
                *j2 = move(*k2);
             *j2 = move(*first1);
          }
          else{
-            ::new(j2, boost_move_new_t()) value_type(move(*first1));
+            ::new((iterator_to_raw_pointer)(j2), boost_move_new_t()) value_type(move(*first1));
             d.incr();
          }
       }
diff --git a/contrib/libboost/boost_1_62_0/boost/move/algo/detail/merge.hpp b/contrib/libboost/boost_1_65_0/boost/move/algo/detail/merge.hpp
similarity index 88%
rename from contrib/libboost/boost_1_62_0/boost/move/algo/detail/merge.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/algo/detail/merge.hpp
index 11d5740a6ab..621dfa28af8 100644
--- a/contrib/libboost/boost_1_62_0/boost/move/algo/detail/merge.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/move/algo/detail/merge.hpp
@@ -16,6 +16,8 @@
 #include <boost/move/algo/detail/basic_op.hpp>
 #include <boost/move/detail/iterator_traits.hpp>
 #include <boost/move/detail/destruct_n.hpp>
+#include <boost/move/algo/predicate.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
 #include <boost/assert.hpp>
 
 namespace boost {
@@ -181,9 +183,6 @@ void op_merge_left( RandIt buf_first
                            //and all elements from the second half are less)
       op(forward_t(), first1, last1, buf_first);
    }
-   else{
-      buf_first = buf_first;
-   }
 }
 
 // [buf_first, first1) -> buffer
@@ -312,13 +311,13 @@ void merge_bufferless_ONlogN_recursive
       if (len1 > len2) {
          len11 = len1 / 2;
          first_cut +=  len11;
-         second_cut = lower_bound(middle, last, *first_cut, comp);
+         second_cut = boost::movelib::lower_bound(middle, last, *first_cut, comp);
          len22 = size_type(second_cut - middle);
       }
       else {
          len22 = len2 / 2;
          second_cut += len22;
-         first_cut = upper_bound(first, middle, *second_cut, comp);
+         first_cut = boost::movelib::upper_bound(first, middle, *second_cut, comp);
          len11 = size_type(first_cut - first);
       }
       BidirIt new_middle = rotate_gcd(first_cut, middle, second_cut);
@@ -359,7 +358,7 @@ void merge_bufferless_ON2(RandIt first, RandIt middle, RandIt last, Compare comp
    if((middle - first) < (last - middle)){
       while(first != middle){
          RandIt const old_last1 = middle;
-         middle = lower_bound(middle, last, *first, comp);
+         middle = boost::movelib::lower_bound(middle, last, *first, comp);
          first = rotate_gcd(first, old_last1, middle);
          if(middle == last){
             break;
@@ -371,7 +370,7 @@ void merge_bufferless_ON2(RandIt first, RandIt middle, RandIt last, Compare comp
    }
    else{
       while(middle != last){
-         RandIt p = upper_bound(first, middle, last[-1], comp);
+         RandIt p = boost::movelib::upper_bound(first, middle, last[-1], comp);
          last = rotate_gcd(p, middle, last);
          middle = p;
          if(middle == first){
@@ -396,65 +395,6 @@ void merge_bufferless(RandIt first, RandIt middle, RandIt last, Compare comp)
    #endif   //BOOST_ADAPTIVE_MERGE_NLOGN_MERGE
 }
 
-template<class Comp>
-struct antistable
-{
-   explicit antistable(Comp &comp)
-      : m_comp(comp)
-   {}
-
-   template<class U, class V>
-   bool operator()(const U &u, const V & v)
-   {  return !m_comp(v, u);  }
-
-   private:
-   antistable & operator=(const antistable &);
-   Comp &m_comp;
-};
-
-template <class Comp>
-class negate
-{
-   public:
-   negate()
-   {}
-
-   explicit negate(Comp comp)
-      : m_comp(comp)
-   {}
-
-   template <class T1, class T2>
-   bool operator()(const T1& l, const T2& r)
-   {
-      return !m_comp(l, r);
-   }
-
-   private:
-   Comp m_comp;
-};
-
-
-template <class Comp>
-class inverse
-{
-   public:
-   inverse()
-   {}
-
-   explicit inverse(Comp comp)
-      : m_comp(comp)
-   {}
-
-   template <class T1, class T2>
-   bool operator()(const T1& l, const T2& r)
-   {
-      return m_comp(r, l);
-   }
-
-   private:
-   Comp m_comp;
-};
-
 // [r_first, r_last) are already in the right part of the destination range.
 template <class Compare, class InputIterator, class InputOutIterator, class Op>
 void op_merge_with_right_placed
@@ -492,7 +432,7 @@ void swap_merge_with_right_placed
    op_merge_with_right_placed(first, last, dest_first, r_first, r_last, comp, swap_op());
 }
 
-// [r_first, r_last) are already in the right part of the destination range.
+// [first, last) are already in the right part of the destination range.
 template <class Compare, class Op, class BidirIterator, class BidirOutIterator>
 void op_merge_with_left_placed
    ( BidirOutIterator const first, BidirOutIterator last, BidirOutIterator dest_last
@@ -525,7 +465,7 @@ void op_merge_with_left_placed
 
 // @endcond
 
-// [r_first, r_last) are already in the right part of the destination range.
+// [irst, last) are already in the right part of the destination range.
 template <class Compare, class BidirIterator, class BidirOutIterator>
 void merge_with_left_placed
    ( BidirOutIterator const first, BidirOutIterator last, BidirOutIterator dest_last
@@ -557,7 +497,50 @@ void uninitialized_merge_with_right_placed
    typedef typename iterator_traits<InputOutIterator>::value_type value_type;
    InputOutIterator const original_r_first = r_first;
 
-   destruct_n<value_type> d(&*dest_first);
+   destruct_n<value_type, InputOutIterator> d(dest_first);
+
+   while ( first != last && dest_first != original_r_first ) {
+      if (r_first == r_last) {
+         for(; dest_first != original_r_first; ++dest_first, ++first){
+            ::new((iterator_to_raw_pointer)(dest_first)) value_type(::boost::move(*first));
+            d.incr();
+         }
+         d.release();
+         InputOutIterator end = ::boost::move(first, last, original_r_first);
+         BOOST_ASSERT(end == r_last);
+         (void)end;
+         return;
+      }
+      else if (comp(*r_first, *first)) {
+         ::new((iterator_to_raw_pointer)(dest_first)) value_type(::boost::move(*r_first));
+         d.incr();
+         ++r_first;
+      }
+      else {
+         ::new((iterator_to_raw_pointer)(dest_first)) value_type(::boost::move(*first));
+         d.incr();
+         ++first;
+      }
+      ++dest_first;
+   }
+   d.release();
+   merge_with_right_placed(first, last, original_r_first, r_first, r_last, comp);
+}
+
+/*
+// [r_first, r_last) are already in the right part of the destination range.
+// [dest_first, r_first) is uninitialized memory
+template <class Compare, class BidirOutIterator, class BidirIterator>
+void uninitialized_merge_with_left_placed
+   ( BidirOutIterator dest_first, BidirOutIterator r_first, BidirOutIterator r_last
+   , BidirIterator first, BidirIterator last
+   , Compare comp)
+{
+   BOOST_ASSERT((last - first) == (r_last - r_first));
+   typedef typename iterator_traits<BidirOutIterator>::value_type value_type;
+   BidirOutIterator const original_r_last = r_last;
+
+   destruct_n<value_type> d(&*dest_last);
 
    while ( first != last && dest_first != original_r_first ) {
       if (r_first == r_last) {
@@ -566,7 +549,7 @@ void uninitialized_merge_with_right_placed
             d.incr();
          }
          d.release();
-         InputOutIterator end = ::boost::move(first, last, original_r_first);
+         BidirOutIterator end = ::boost::move(first, last, original_r_first);
          BOOST_ASSERT(end == r_last);
          (void)end;
          return;
@@ -586,6 +569,7 @@ void uninitialized_merge_with_right_placed
    d.release();
    merge_with_right_placed(first, last, original_r_first, r_first, r_last, comp);
 }
+*/
 
 }  //namespace movelib {
 }  //namespace boost {
diff --git a/contrib/libboost/boost_1_62_0/boost/move/algo/detail/merge_sort.hpp b/contrib/libboost/boost_1_65_0/boost/move/algo/detail/merge_sort.hpp
similarity index 92%
rename from contrib/libboost/boost_1_62_0/boost/move/algo/detail/merge_sort.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/algo/detail/merge_sort.hpp
index 892639b05f6..62d185acb63 100644
--- a/contrib/libboost/boost_1_62_0/boost/move/algo/detail/merge_sort.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/move/algo/detail/merge_sort.hpp
@@ -79,9 +79,9 @@ void merge_sort_copy( RandIt first, RandIt last
    }
 }
 
-template<class RandIt, class Compare>
+template<class RandIt, class RandItRaw, class Compare>
 void merge_sort_uninitialized_copy( RandIt first, RandIt last
-                                 , typename iterator_traits<RandIt>::value_type* uninitialized
+                                 , RandItRaw uninitialized
                                  , Compare comp)
 {
    typedef typename iterator_traits<RandIt>::size_type  size_type;
@@ -94,7 +94,7 @@ void merge_sort_uninitialized_copy( RandIt first, RandIt last
    else{
       size_type const half = count/2;
       merge_sort_uninitialized_copy(first + half, last, uninitialized + half, comp);
-      destruct_n<value_type> d(uninitialized+half);
+      destruct_n<value_type, RandItRaw> d(uninitialized+half);
       d.incr(count-half);
       merge_sort_copy(first, first + half, first + half, comp);
       uninitialized_merge_with_right_placed
@@ -105,9 +105,9 @@ void merge_sort_uninitialized_copy( RandIt first, RandIt last
    }
 }
 
-template<class RandIt, class Compare>
+template<class RandIt, class RandItRaw, class Compare>
 void merge_sort( RandIt first, RandIt last, Compare comp
-               , typename iterator_traits<RandIt>::value_type* uninitialized)
+               , RandItRaw uninitialized)
 {
    typedef typename iterator_traits<RandIt>::size_type  size_type;
    typedef typename iterator_traits<RandIt>::value_type value_type;
@@ -123,7 +123,7 @@ void merge_sort( RandIt first, RandIt last, Compare comp
       RandIt const rest_it = first + rest;
 
       merge_sort_uninitialized_copy(half_it, last, uninitialized, comp);
-      destruct_n<value_type> d(uninitialized);
+      destruct_n<value_type, RandItRaw> d(uninitialized);
       d.incr(rest);
       merge_sort_copy(first, half_it, rest_it, comp);
       merge_with_right_placed
diff --git a/contrib/libboost/boost_1_62_0/boost/move/algo/move.hpp b/contrib/libboost/boost_1_65_0/boost/move/algo/move.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/move/algo/move.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/algo/move.hpp
index d35f04a3997..2390877a43b 100644
--- a/contrib/libboost/boost_1_62_0/boost/move/algo/move.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/move/algo/move.hpp
@@ -26,6 +26,7 @@
 
 #include <boost/move/utility_core.hpp>
 #include <boost/move/detail/iterator_traits.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
 #include <boost/detail/no_exceptions_support.hpp>
 
 namespace boost {
@@ -126,7 +127,7 @@ F uninitialized_move(I f, I l, F r
    }
    BOOST_CATCH(...){
       for (; back != r; ++back){
-         back->~input_value_type();
+         boost::movelib::iterator_to_raw_pointer(back)->~input_value_type();
       }
       BOOST_RETHROW;
    }
diff --git a/contrib/libboost/boost_1_65_0/boost/move/algo/predicate.hpp b/contrib/libboost/boost_1_65_0/boost/move/algo/predicate.hpp
new file mode 100644
index 00000000000..0287d663184
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/move/algo/predicate.hpp
@@ -0,0 +1,86 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2015-2016.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_MOVE_ALGO_PREDICATE_HPP
+#define BOOST_MOVE_ALGO_PREDICATE_HPP
+
+#include <boost/move/algo/move.hpp>
+#include <boost/move/adl_move_swap.hpp>
+#include <boost/move/algo/detail/basic_op.hpp>
+#include <boost/move/detail/iterator_traits.hpp>
+#include <boost/move/detail/destruct_n.hpp>
+#include <boost/assert.hpp>
+
+namespace boost {
+namespace movelib {
+
+template<class Comp>
+struct antistable
+{
+   explicit antistable(Comp &comp)
+      : m_comp(comp)
+   {}
+
+   template<class U, class V>
+   bool operator()(const U &u, const V & v)
+   {  return !m_comp(v, u);  }
+
+   private:
+   antistable & operator=(const antistable &);
+   Comp &m_comp;
+};
+
+template <class Comp>
+class negate
+{
+   public:
+   negate()
+   {}
+
+   explicit negate(Comp comp)
+      : m_comp(comp)
+   {}
+
+   template <class T1, class T2>
+   bool operator()(const T1& l, const T2& r)
+   {
+      return !m_comp(l, r);
+   }
+
+   private:
+   Comp m_comp;
+};
+
+
+template <class Comp>
+class inverse
+{
+   public:
+   inverse()
+   {}
+
+   explicit inverse(Comp comp)
+      : m_comp(comp)
+   {}
+
+   template <class T1, class T2>
+   bool operator()(const T1& l, const T2& r)
+   {
+      return m_comp(r, l);
+   }
+
+   private:
+   Comp m_comp;
+};
+
+}  //namespace movelib {
+}  //namespace boost {
+
+#endif   //#define BOOST_MOVE_ALGO_PREDICATE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/move/algo/unique.hpp b/contrib/libboost/boost_1_65_0/boost/move/algo/unique.hpp
new file mode 100644
index 00000000000..8022a654e26
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/move/algo/unique.hpp
@@ -0,0 +1,55 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2017-2017.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/move for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_MOVE_ALGO_UNIQUE_HPP
+#define BOOST_MOVE_ALGO_UNIQUE_HPP
+
+#include <boost/move/detail/config_begin.hpp>
+#include <boost/move/utility_core.hpp>
+
+namespace boost {
+namespace movelib {
+
+//! <b>Requires</b>: The comparison function shall be an equivalence relation. The type of *first shall satisfy
+//! the MoveAssignable requirements
+//!
+//! <b>Effects</b>: For a nonempty range, eliminates all but the first element from every consecutive group
+//!   of equivalent elements referred to by the iterator i in the range [first + 1, last) for which the
+//!   following conditions hold: pred(*(i - 1), *i) != false.
+//!
+//! <b>Returns</b>: The end of the resulting range.
+//!
+//! <b>Complexity</b>: For nonempty ranges, exactly (last - first) - 1 applications of the corresponding predicate.
+template<class ForwardIterator, class BinaryPredicate>
+ForwardIterator unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred)
+{
+    if (first != last) {
+      ForwardIterator next(first);
+      ++next;
+      for (; next != last; ++next, ++first) {
+         if (pred(*first, *next)) { //Find first equal element
+            while (++next != last)
+               if (!pred(*first, *next))
+                  *++first = ::boost::move(*next);
+            break;
+         }
+      }
+      ++first;
+   }
+   return first;
+}
+
+}  //namespace movelib {
+}  //namespace boost {
+
+#include <boost/move/detail/config_end.hpp>
+
+#endif   //#define BOOST_MOVE_ALGO_UNIQUE_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/move/algorithm.hpp b/contrib/libboost/boost_1_65_0/boost/move/algorithm.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/move/algorithm.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/algorithm.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/move/core.hpp b/contrib/libboost/boost_1_65_0/boost/move/core.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/move/core.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/core.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/move/default_delete.hpp b/contrib/libboost/boost_1_65_0/boost/move/default_delete.hpp
similarity index 96%
rename from contrib/libboost/boost_1_62_0/boost/move/default_delete.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/default_delete.hpp
index 1c26ed924b2..31ae67aa07c 100644
--- a/contrib/libboost/boost_1_62_0/boost/move/default_delete.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/move/default_delete.hpp
@@ -96,6 +96,22 @@ typedef int bool_conversion::* explicit_bool_arg;
    typedef int (bool_conversion::*nullptr_type)();
 #endif
 
+template<bool B>
+struct is_array_del
+{};
+
+template<class T>
+void call_delete(T *p, is_array_del<true>)
+{
+   delete [] p;
+}
+
+template<class T>
+void call_delete(T *p, is_array_del<false>)
+{
+   delete p;
+}
+
 }  //namespace move_upd {
 // @endcond
 
@@ -184,7 +200,7 @@ struct default_delete
       //and T has no virtual destructor, then you have a problem
       BOOST_STATIC_ASSERT(( !::boost::move_upmu::missing_virtual_destructor<default_delete, U>::value ));
       element_type * const p = static_cast<element_type*>(ptr);
-      bmupmu::is_array<T>::value ? delete [] p : delete p;
+      move_upd::call_delete(p, move_upd::is_array_del<bmupmu::is_array<T>::value>());
    }
 
    //! <b>Effects</b>: Same as <tt>(*this)(static_cast<element_type*>(nullptr))</tt>.
diff --git a/contrib/libboost/boost_1_62_0/boost/move/detail/config_begin.hpp b/contrib/libboost/boost_1_65_0/boost/move/detail/config_begin.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/move/detail/config_begin.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/detail/config_begin.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/move/detail/config_end.hpp b/contrib/libboost/boost_1_65_0/boost/move/detail/config_end.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/move/detail/config_end.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/detail/config_end.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/move/detail/destruct_n.hpp b/contrib/libboost/boost_1_65_0/boost/move/detail/destruct_n.hpp
similarity index 91%
rename from contrib/libboost/boost_1_62_0/boost/move/detail/destruct_n.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/detail/destruct_n.hpp
index 06f1f589ed5..9f60fc2773a 100644
--- a/contrib/libboost/boost_1_62_0/boost/move/detail/destruct_n.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/move/detail/destruct_n.hpp
@@ -27,11 +27,11 @@
 namespace boost {
 namespace movelib{
 
-template<class T>
+template<class T, class RandItUninit>
 class destruct_n
 {
    public:
-   explicit destruct_n(T *raw)
+   explicit destruct_n(RandItUninit raw)
       : m_ptr(raw), m_size()
    {}
 
@@ -48,7 +48,6 @@ class destruct_n
    void release()
    {
       m_size = 0u;
-      m_ptr = 0;
    }
 
    ~destruct_n()
@@ -58,7 +57,7 @@ class destruct_n
       }
    }
    private:
-   T *m_ptr;
+   RandItUninit m_ptr;
    std::size_t m_size;
 };
 
diff --git a/contrib/libboost/boost_1_62_0/boost/move/detail/fwd_macros.hpp b/contrib/libboost/boost_1_65_0/boost/move/detail/fwd_macros.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/move/detail/fwd_macros.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/detail/fwd_macros.hpp
index 71324367833..a5df5f1be78 100644
--- a/contrib/libboost/boost_1_62_0/boost/move/detail/fwd_macros.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/move/detail/fwd_macros.hpp
@@ -458,6 +458,31 @@ namespace move_detail {
 #define BOOST_MOVE_CLASSDFLTQ8 BOOST_MOVE_CLASSDFLTQ7, class Q7 = void
 #define BOOST_MOVE_CLASSDFLTQ9 BOOST_MOVE_CLASSDFLTQ8, class Q8 = void
 
+//BOOST_MOVE_LAST_TARGN
+#define BOOST_MOVE_LAST_TARG0 void
+#define BOOST_MOVE_LAST_TARG1 P0
+#define BOOST_MOVE_LAST_TARG2 P1
+#define BOOST_MOVE_LAST_TARG3 P2
+#define BOOST_MOVE_LAST_TARG4 P3
+#define BOOST_MOVE_LAST_TARG5 P4
+#define BOOST_MOVE_LAST_TARG6 P5
+#define BOOST_MOVE_LAST_TARG7 P6
+#define BOOST_MOVE_LAST_TARG8 P7
+#define BOOST_MOVE_LAST_TARG9 P8
+
+//BOOST_MOVE_LAST_TARGQN
+#define BOOST_MOVE_LAST_TARGQ0 void
+#define BOOST_MOVE_LAST_TARGQ1 Q0
+#define BOOST_MOVE_LAST_TARGQ2 Q1
+#define BOOST_MOVE_LAST_TARGQ3 Q2
+#define BOOST_MOVE_LAST_TARGQ4 Q3
+#define BOOST_MOVE_LAST_TARGQ5 Q4
+#define BOOST_MOVE_LAST_TARGQ6 Q5
+#define BOOST_MOVE_LAST_TARGQ7 Q6
+#define BOOST_MOVE_LAST_TARGQ8 Q7
+#define BOOST_MOVE_LAST_TARGQ9 Q8
+
+
 //BOOST_MOVE_TARGN
 #define BOOST_MOVE_TARG0
 #define BOOST_MOVE_TARG1                   P0
diff --git a/contrib/libboost/boost_1_62_0/boost/container/detail/iterator_to_raw_pointer.hpp b/contrib/libboost/boost_1_65_0/boost/move/detail/iterator_to_raw_pointer.hpp
similarity index 51%
rename from contrib/libboost/boost_1_62_0/boost/container/detail/iterator_to_raw_pointer.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/detail/iterator_to_raw_pointer.hpp
index 83736d8bb18..97ee3a65955 100644
--- a/contrib/libboost/boost_1_62_0/boost/container/detail/iterator_to_raw_pointer.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/move/detail/iterator_to_raw_pointer.hpp
@@ -7,8 +7,8 @@
 // See http://www.boost.org/libs/container for documentation.
 //
 //////////////////////////////////////////////////////////////////////////////
-#ifndef BOOST_CONTAINER_DETAIL_ITERATOR_TO_RAW_POINTER_HPP
-#define BOOST_CONTAINER_DETAIL_ITERATOR_TO_RAW_POINTER_HPP
+#ifndef BOOST_MOVE_DETAIL_ITERATOR_TO_RAW_POINTER_HPP
+#define BOOST_MOVE_DETAIL_ITERATOR_TO_RAW_POINTER_HPP
 
 #ifndef BOOST_CONFIG_HPP
 #  include <boost/config.hpp>
@@ -18,41 +18,42 @@
 #  pragma once
 #endif
 
-#include <boost/container/detail/iterator.hpp>
-#include <boost/container/detail/to_raw_pointer.hpp>
-#include <boost/intrusive/pointer_traits.hpp>
+#include <boost/move/detail/iterator_traits.hpp>
+#include <boost/move/detail/to_raw_pointer.hpp>
+#include <boost/move/detail/pointer_element.hpp>
 
 namespace boost {
-namespace container {
-namespace container_detail {
+namespace movelib {
+namespace detail {
 
 template <class T>
 inline T* iterator_to_pointer(T* i)
 {  return i; }
 
 template <class Iterator>
-inline typename boost::container::iterator_traits<Iterator>::pointer
+inline typename boost::movelib::iterator_traits<Iterator>::pointer
    iterator_to_pointer(const Iterator &i)
 {  return i.operator->();  }
 
 template <class Iterator>
 struct iterator_to_element_ptr
 {
-   typedef typename boost::container::iterator_traits<Iterator>::pointer      pointer;
-   typedef typename boost::intrusive::pointer_traits<pointer>::element_type   element_type;
+   typedef typename boost::movelib::iterator_traits<Iterator>::pointer  pointer;
+   typedef typename boost::movelib::pointer_element<pointer>::type      element_type;
    typedef element_type* type;
 };
 
+}  //namespace detail {
+
 template <class Iterator>
-inline typename iterator_to_element_ptr<Iterator>::type
+inline typename boost::movelib::detail::iterator_to_element_ptr<Iterator>::type
    iterator_to_raw_pointer(const Iterator &i)
 {
-   return ::boost::intrusive::detail::to_raw_pointer
-      (  ::boost::container::container_detail::iterator_to_pointer(i)   );
+   return ::boost::movelib::to_raw_pointer
+      (  ::boost::movelib::detail::iterator_to_pointer(i)   );
 }
 
-}  //namespace container_detail {
-}  //namespace container {
+}  //namespace movelib {
 }  //namespace boost {
 
-#endif   //#ifndef BOOST_CONTAINER_DETAIL_ITERATOR_TO_RAW_POINTER_HPP
+#endif   //#ifndef BOOST_MOVE_DETAIL_ITERATOR_TO_RAW_POINTER_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/move/detail/iterator_traits.hpp b/contrib/libboost/boost_1_65_0/boost/move/detail/iterator_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/move/detail/iterator_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/detail/iterator_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/move/detail/meta_utils.hpp b/contrib/libboost/boost_1_65_0/boost/move/detail/meta_utils.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/move/detail/meta_utils.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/detail/meta_utils.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/move/detail/meta_utils_core.hpp b/contrib/libboost/boost_1_65_0/boost/move/detail/meta_utils_core.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/move/detail/meta_utils_core.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/detail/meta_utils_core.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/move/detail/move_helpers.hpp b/contrib/libboost/boost_1_65_0/boost/move/detail/move_helpers.hpp
similarity index 79%
rename from contrib/libboost/boost_1_62_0/boost/move/detail/move_helpers.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/detail/move_helpers.hpp
index a2502bf7dc6..17138444d1d 100644
--- a/contrib/libboost/boost_1_62_0/boost/move/detail/move_helpers.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/move/detail/move_helpers.hpp
@@ -69,13 +69,13 @@
    {};
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
-      RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(static_cast<const TYPE&>(x)); }\
       \
-      RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(::boost::move(x));  }\
       \
-      RETURN_VALUE PUB_FUNCTION(TYPE &x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(TYPE &x)\
       {  return FWD_FUNCTION(const_cast<const TYPE &>(x)); }\
    //
    #if defined(BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN)
@@ -83,12 +83,12 @@
          BOOST_MOVE_CONVERSION_AWARE_CATCH_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
+         BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
             typename boost_move_conversion_aware_catch_1< ::boost::move_detail::nat, BOOST_MOVE_TEMPL_PARAM, TYPE>::type* = 0)\
          { return FWD_FUNCTION(u); }\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
+         BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u,\
             typename boost_move_conversion_aware_catch_2< ::boost::move_detail::nat, BOOST_MOVE_TEMPL_PARAM, TYPE>::type* = 0)\
          {\
             TYPE t((u));\
@@ -100,12 +100,12 @@
          BOOST_MOVE_CONVERSION_AWARE_CATCH_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         typename boost_move_conversion_aware_catch_1<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, TYPE>::type\
+         BOOST_MOVE_FORCEINLINE typename boost_move_conversion_aware_catch_1<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, TYPE>::type\
             PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
          { return FWD_FUNCTION(u); }\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         typename boost_move_conversion_aware_catch_2<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, TYPE>::type\
+         BOOST_MOVE_FORCEINLINE typename boost_move_conversion_aware_catch_2<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, TYPE>::type\
             PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
          {\
             TYPE t((u));\
@@ -116,14 +116,14 @@
 #elif (defined(_MSC_VER) && (_MSC_VER == 1600))
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
-      RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(static_cast<const TYPE&>(x)); }\
       \
-      RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(::boost::move(x));  }\
       \
       template<class BOOST_MOVE_TEMPL_PARAM>\
-      typename ::boost::move_detail::enable_if_c\
+      BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::enable_if_c\
                         < !::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM>::value\
                         , RETURN_VALUE >::type\
       PUB_FUNCTION(const BOOST_MOVE_TEMPL_PARAM &u)\
@@ -136,10 +136,10 @@
 #else    //BOOST_NO_CXX11_RVALUE_REFERENCES
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION)\
-      RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
-      {  return FWD_FUNCTION(static_cast<const TYPE&>(x)); }\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      {  return FWD_FUNCTION(x); }\
       \
-      RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(::boost::move(x));  }\
    //
 
@@ -174,13 +174,13 @@
    {};
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
-      RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
       \
-      RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(arg1, ::boost::move(x));  }\
       \
-      RETURN_VALUE PUB_FUNCTION(ARG1 arg1, TYPE &x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, TYPE &x)\
       {  return FWD_FUNCTION(arg1, const_cast<const TYPE &>(x)); }\
    //
    #if defined(BOOST_MOVE_HELPERS_RETURN_SFINAE_BROKEN)
@@ -188,12 +188,12 @@
          BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
+         BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
             typename boost_move_conversion_aware_catch_1arg_1<void, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type* = 0)\
          { return FWD_FUNCTION(arg1, u); }\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
+         BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u,\
             typename boost_move_conversion_aware_catch_1arg_2<void, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type* = 0)\
          {\
             TYPE t((u));\
@@ -205,12 +205,12 @@
          BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG_COMMON(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         typename boost_move_conversion_aware_catch_1arg_1<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type\
+         BOOST_MOVE_FORCEINLINE typename boost_move_conversion_aware_catch_1arg_1<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type\
             PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u)\
          { return FWD_FUNCTION(arg1, u); }\
          \
          template<class BOOST_MOVE_TEMPL_PARAM>\
-         typename boost_move_conversion_aware_catch_1arg_2<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type\
+         BOOST_MOVE_FORCEINLINE typename boost_move_conversion_aware_catch_1arg_2<RETURN_VALUE, BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO, TYPE>::type\
             PUB_FUNCTION(ARG1 arg1, const BOOST_MOVE_TEMPL_PARAM &u)\
          {\
             TYPE t((u));\
@@ -222,14 +222,14 @@
 #elif (defined(_MSC_VER) && (_MSC_VER == 1600))
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
-      RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
       \
-      RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(arg1, ::boost::move(x));  }\
       \
       template<class BOOST_MOVE_TEMPL_PARAM>\
-      typename ::boost::move_detail::disable_if_or\
+      BOOST_MOVE_FORCEINLINE typename ::boost::move_detail::disable_if_or\
                         < RETURN_VALUE \
                         , ::boost::move_detail::is_same<TYPE, BOOST_MOVE_TEMPL_PARAM> \
                         , ::boost::move_detail::is_same_or_convertible<BOOST_MOVE_TEMPL_PARAM, UNLESS_CONVERTIBLE_TO> \
@@ -244,10 +244,10 @@
 #else
 
    #define BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(PUB_FUNCTION, TYPE, RETURN_VALUE, FWD_FUNCTION, ARG1, UNLESS_CONVERTIBLE_TO)\
-      RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_CONST(TYPE) x)\
       {  return FWD_FUNCTION(arg1, static_cast<const TYPE&>(x)); }\
       \
-      RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
+      BOOST_MOVE_FORCEINLINE RETURN_VALUE PUB_FUNCTION(ARG1 arg1, BOOST_MOVE_CATCH_RVALUE(TYPE) x) \
       {  return FWD_FUNCTION(arg1, ::boost::move(x));  }\
    //
 
diff --git a/contrib/libboost/boost_1_62_0/boost/move/detail/placement_new.hpp b/contrib/libboost/boost_1_65_0/boost/move/detail/placement_new.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/move/detail/placement_new.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/detail/placement_new.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/pointer_element.hpp b/contrib/libboost/boost_1_65_0/boost/move/detail/pointer_element.hpp
similarity index 87%
rename from contrib/libboost/boost_1_62_0/boost/intrusive/detail/pointer_element.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/detail/pointer_element.hpp
index dd26e3cf0b4..ecdd6080ce0 100644
--- a/contrib/libboost/boost_1_62_0/boost/intrusive/detail/pointer_element.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/move/detail/pointer_element.hpp
@@ -1,15 +1,15 @@
 //////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gaztanaga 2014-2014. Distributed under the Boost
+// (C) Copyright Ion Gaztanaga 2014-2017. 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/intrusive for documentation.
+// See http://www.boost.org/libs/move for documentation.
 //
 //////////////////////////////////////////////////////////////////////////////
 
-#ifndef BOOST_INTRUSIVE_DETAIL_POINTER_ELEMENT_HPP
-#define BOOST_INTRUSIVE_DETAIL_POINTER_ELEMENT_HPP
+#ifndef BOOST_MOVE_DETAIL_POINTER_ELEMENT_HPP
+#define BOOST_MOVE_DETAIL_POINTER_ELEMENT_HPP
 
 #ifndef BOOST_CONFIG_HPP
 #  include <boost/config.hpp>
@@ -19,12 +19,12 @@
 #  pragma once
 #endif
 
-#ifndef BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP
-#include <boost/intrusive/detail/workaround.hpp>
-#endif   //BOOST_INTRUSIVE_DETAIL_WORKAROUND_HPP
+#ifndef BOOST_MOVE_DETAIL_WORKAROUND_HPP
+#include <boost/move/detail/workaround.hpp>
+#endif   //BOOST_MOVE_DETAIL_WORKAROUND_HPP
 
 namespace boost {
-namespace intrusive {
+namespace movelib {
 namespace detail{
 
 //////////////////////
@@ -147,7 +147,7 @@ struct pointer_element_impl
 template<class Ptr>
 struct pointer_element_impl<Ptr, false>
 {
-   typedef typename boost::intrusive::detail::first_param<Ptr>::type type;
+   typedef typename boost::movelib::detail::first_param<Ptr>::type type;
 };
 
 }  //namespace detail{
@@ -155,14 +155,14 @@ struct pointer_element_impl<Ptr, false>
 template <typename Ptr>
 struct pointer_element
 {
-   typedef typename ::boost::intrusive::detail::pointer_element_impl<Ptr>::type type;
+   typedef typename ::boost::movelib::detail::pointer_element_impl<Ptr>::type type;
 };
 
 template <typename T>
 struct pointer_element<T*>
 {  typedef T type; };
 
-}  //namespace container {
+}  //namespace movelib {
 }  //namespace boost {
 
-#endif // defined(BOOST_INTRUSIVE_DETAIL_POINTER_ELEMENT_HPP)
+#endif // defined(BOOST_MOVE_DETAIL_POINTER_ELEMENT_HPP)
diff --git a/contrib/libboost/boost_1_62_0/boost/move/detail/reverse_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/move/detail/reverse_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/move/detail/reverse_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/detail/reverse_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/move/detail/std_ns_begin.hpp b/contrib/libboost/boost_1_65_0/boost/move/detail/std_ns_begin.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/move/detail/std_ns_begin.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/detail/std_ns_begin.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/move/detail/std_ns_end.hpp b/contrib/libboost/boost_1_65_0/boost/move/detail/std_ns_end.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/move/detail/std_ns_end.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/detail/std_ns_end.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/move/detail/to_raw_pointer.hpp b/contrib/libboost/boost_1_65_0/boost/move/detail/to_raw_pointer.hpp
new file mode 100644
index 00000000000..7e89beb4db0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/move/detail/to_raw_pointer.hpp
@@ -0,0 +1,45 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga  2017-2017
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/move for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_MOVE_DETAIL_TO_RAW_POINTER_HPP
+#define BOOST_MOVE_DETAIL_TO_RAW_POINTER_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/move/detail/config_begin.hpp>
+#include <boost/move/detail/workaround.hpp>
+#include <boost/move/detail/pointer_element.hpp>
+
+namespace boost {
+namespace movelib {
+
+template <class T>
+BOOST_MOVE_FORCEINLINE T* to_raw_pointer(T* p)
+{  return p; }
+
+template <class Pointer>
+BOOST_MOVE_FORCEINLINE typename boost::movelib::pointer_element<Pointer>::type*
+to_raw_pointer(const Pointer &p)
+{  return ::boost::movelib::to_raw_pointer(p.operator->());  }
+
+} //namespace movelib
+} //namespace boost
+
+#include <boost/move/detail/config_end.hpp>
+
+#endif //BOOST_MOVE_DETAIL_TO_RAW_POINTER_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/move/detail/type_traits.hpp b/contrib/libboost/boost_1_65_0/boost/move/detail/type_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/move/detail/type_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/detail/type_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/move/detail/unique_ptr_meta_utils.hpp b/contrib/libboost/boost_1_65_0/boost/move/detail/unique_ptr_meta_utils.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/move/detail/unique_ptr_meta_utils.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/detail/unique_ptr_meta_utils.hpp
index 33720683def..e11124d8988 100644
--- a/contrib/libboost/boost_1_62_0/boost/move/detail/unique_ptr_meta_utils.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/move/detail/unique_ptr_meta_utils.hpp
@@ -397,7 +397,7 @@ struct pointer_type_imp
 template <class T, class D>
 struct pointer_type_imp<T, D, false>
 {
-    typedef typename remove_extent<T>::type* type;
+    typedef T* type;
 };
 
 template <class T, class D>
@@ -446,7 +446,7 @@ class is_convertible
 #define BOOST_MOVE_TT_DECL
 #endif
 
-#if defined(_MSC_EXTENSIONS) && !defined(__BORLAND__) && !defined(_WIN64) && !defined(_M_ARM) && !defined(UNDER_CE)
+#if defined(_MSC_EXTENSIONS) && !defined(__BORLAND__) && !defined(_WIN64) && !defined(_M_ARM) && !defined(_M_ARM64) && !defined(UNDER_CE)
 #define BOOST_MOVE_TT_TEST_MSC_FUNC_SIGS
 #endif
 
diff --git a/contrib/libboost/boost_1_62_0/boost/move/detail/workaround.hpp b/contrib/libboost/boost_1_65_0/boost/move/detail/workaround.hpp
similarity index 92%
rename from contrib/libboost/boost_1_62_0/boost/move/detail/workaround.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/detail/workaround.hpp
index befe141e96a..1d16f243321 100644
--- a/contrib/libboost/boost_1_62_0/boost/move/detail/workaround.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/move/detail/workaround.hpp
@@ -52,8 +52,6 @@
    #define BOOST_MOVE_MSVC_AUTO_MOVE_RETURN_BUG
 #endif
 
-#define BOOST_MOVE_DISABLE_FORCEINLINE
-
 #if defined(BOOST_MOVE_DISABLE_FORCEINLINE)
    #define BOOST_MOVE_FORCEINLINE inline
 #elif defined(BOOST_MOVE_FORCEINLINE_IS_BOOST_FORCELINE)
@@ -61,6 +59,9 @@
 #elif defined(BOOST_MSVC) && defined(_DEBUG)
    //"__forceinline" and MSVC seems to have some bugs in debug mode
    #define BOOST_MOVE_FORCEINLINE inline
+#elif defined(__GNUC__) && ((__GNUC__ < 4) || (__GNUC__ == 4 && (__GNUC_MINOR__ < 5)))
+   //Older GCCs have problems with forceinline
+   #define BOOST_MOVE_FORCEINLINE inline
 #else
    #define BOOST_MOVE_FORCEINLINE BOOST_FORCEINLINE
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/move/iterator.hpp b/contrib/libboost/boost_1_65_0/boost/move/iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/move/iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/move/make_unique.hpp b/contrib/libboost/boost_1_65_0/boost/move/make_unique.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/move/make_unique.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/make_unique.hpp
index bb59ab6ec09..ef106dbb55a 100644
--- a/contrib/libboost/boost_1_62_0/boost/move/make_unique.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/move/make_unique.hpp
@@ -75,7 +75,8 @@ struct nothrow_holder
 };
 
 template <int Dummy>
-std::nothrow_t *nothrow_holder<Dummy>::pnothrow;
+std::nothrow_t *nothrow_holder<Dummy>::pnothrow = 
+   reinterpret_cast<std::nothrow_t *>(0x1234);  //Avoid reference to null errors in sanitizers
 
 }  //namespace move_upmu {
 }  //namespace boost{
diff --git a/contrib/libboost/boost_1_62_0/boost/move/move.hpp b/contrib/libboost/boost_1_65_0/boost/move/move.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/move/move.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/move.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/move/traits.hpp b/contrib/libboost/boost_1_65_0/boost/move/traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/move/traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/move/unique_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/move/unique_ptr.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/move/unique_ptr.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/unique_ptr.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/move/utility.hpp b/contrib/libboost/boost_1_65_0/boost/move/utility.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/move/utility.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/utility.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/move/utility_core.hpp b/contrib/libboost/boost_1_65_0/boost/move/utility_core.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/move/utility_core.hpp
rename to contrib/libboost/boost_1_65_0/boost/move/utility_core.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/O1_size.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/O1_size.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/O1_size.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/O1_size.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/O1_size_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/O1_size_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/O1_size_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/O1_size_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/accumulate.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/accumulate.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/accumulate.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/accumulate.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/advance.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/advance.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/advance.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/advance.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/advance_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/advance_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/advance_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/advance_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/alias.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/alias.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/alias.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/alias.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/always.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/always.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/always.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/always.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/and.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/and.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/and.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/and.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/apply.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/apply.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/apply.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/apply.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/apply_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/apply_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/apply_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/apply_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/apply_wrap.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/apply_wrap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/apply_wrap.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/apply_wrap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/arg.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/arg.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/arg.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/arg.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/arg_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/arg_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/arg_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/arg_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/arithmetic.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/arithmetic.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/arithmetic.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/arithmetic.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/as_sequence.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/as_sequence.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/as_sequence.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/as_sequence.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/assert.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/assert.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/assert.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/assert.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/at.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/at.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/at.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/at.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/at_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/at_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/at_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/at_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/O1_size_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/O1_size_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/O1_size_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/O1_size_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/adl_barrier.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/adl_barrier.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/adl_barrier.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/adl_barrier.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/advance_backward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/advance_backward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/advance_backward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/advance_backward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/advance_forward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/advance_forward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/advance_forward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/advance_forward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/apply_1st.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/apply_1st.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/apply_1st.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/apply_1st.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/arg_typedef.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/arg_typedef.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/arg_typedef.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/arg_typedef.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/arithmetic_op.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/arithmetic_op.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/arithmetic_op.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/arithmetic_op.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/arity.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/arity.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/arity.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/arity.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/arity_spec.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/arity_spec.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/arity_spec.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/arity_spec.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/at_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/at_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/at_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/at_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/back_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/back_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/back_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/back_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/basic_bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/basic_bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/basic_bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/basic_bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/begin_end_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/begin_end_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/begin_end_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/begin_end_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/clear_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/clear_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/clear_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/clear_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/common_name_wknd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/common_name_wknd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/common_name_wknd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/common_name_wknd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/comparison_op.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/comparison_op.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/comparison_op.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/comparison_op.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/adl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/adl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/adl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/adl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/arrays.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/arrays.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/arrays.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/arrays.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/bcc.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/bcc.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/bcc.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/bcc.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/compiler.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/compiler.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/compiler.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/compiler.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/ctps.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/ctps.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/ctps.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/ctps.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/dependent_nttp.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/dependent_nttp.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/dependent_nttp.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/dependent_nttp.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/dmc_ambiguous_ctps.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/dtp.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/dtp.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/dtp.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/dtp.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/eti.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/eti.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/eti.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/eti.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/forwarding.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/forwarding.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/forwarding.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/forwarding.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/gcc.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/gcc.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/gcc.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/gcc.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/gpu.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/gpu.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/gpu.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/gpu.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/has_apply.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/has_apply.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/has_apply.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/has_apply.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/has_xxx.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/has_xxx.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/has_xxx.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/has_xxx.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/integral.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/integral.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/integral.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/integral.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/intel.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/intel.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/intel.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/intel.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/lambda.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/lambda.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/lambda.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/lambda.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/msvc.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/msvc.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/msvc.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/msvc.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/msvc_typename.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/msvc_typename.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/msvc_typename.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/msvc_typename.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/nttp.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/nttp.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/nttp.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/nttp.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/operators.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/operators.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/operators.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/operators.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/overload_resolution.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/overload_resolution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/overload_resolution.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/overload_resolution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/pp_counter.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/pp_counter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/pp_counter.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/pp_counter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/preprocessor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/preprocessor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/preprocessor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/preprocessor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/static_constant.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/static_constant.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/static_constant.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/static_constant.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/ttp.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/ttp.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/ttp.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/ttp.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/typeof.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/typeof.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/typeof.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/typeof.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/use_preprocessed.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/use_preprocessed.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/use_preprocessed.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/use_preprocessed.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/workaround.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/workaround.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/config/workaround.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/config/workaround.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/contains_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/contains_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/contains_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/contains_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/count_args.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/count_args.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/count_args.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/count_args.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/count_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/count_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/count_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/count_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/empty_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/empty_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/empty_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/empty_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/erase_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/erase_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/erase_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/erase_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/erase_key_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/erase_key_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/erase_key_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/erase_key_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/filter_iter.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/filter_iter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/filter_iter.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/filter_iter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/find_if_pred.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/find_if_pred.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/find_if_pred.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/find_if_pred.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/fold_impl_body.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/fold_impl_body.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/fold_impl_body.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/fold_impl_body.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/fold_op.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/fold_op.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/fold_op.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/fold_op.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/fold_pred.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/fold_pred.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/fold_pred.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/fold_pred.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/front_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/front_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/front_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/front_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/full_lambda.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/full_lambda.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/full_lambda.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/full_lambda.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/has_apply.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/has_apply.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/has_apply.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/has_apply.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/has_begin.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/has_begin.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/has_begin.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/has_begin.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/has_key_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/has_key_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/has_key_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/has_key_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/has_rebind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/has_rebind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/has_rebind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/has_rebind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/has_size.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/has_size.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/has_size.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/has_size.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/has_tag.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/has_tag.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/has_tag.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/has_tag.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/has_type.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/has_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/has_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/has_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/include_preprocessed.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/include_preprocessed.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/include_preprocessed.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/include_preprocessed.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/insert_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/insert_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/insert_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/insert_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/insert_range_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/insert_range_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/insert_range_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/insert_range_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/inserter_algorithm.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/inserter_algorithm.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/inserter_algorithm.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/inserter_algorithm.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/integral_wrapper.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/integral_wrapper.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/integral_wrapper.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/integral_wrapper.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/is_msvc_eti_arg.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/is_msvc_eti_arg.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/is_msvc_eti_arg.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/is_msvc_eti_arg.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/iter_apply.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/iter_apply.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/iter_apply.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/iter_apply.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/iter_fold_if_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/iter_fold_if_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/iter_fold_if_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/iter_fold_if_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/iter_push_front.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/iter_push_front.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/iter_push_front.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/iter_push_front.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/joint_iter.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/joint_iter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/joint_iter.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/joint_iter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/lambda_arity_param.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/lambda_arity_param.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/lambda_arity_param.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/lambda_arity_param.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/lambda_no_ctps.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/lambda_no_ctps.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/lambda_no_ctps.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/lambda_no_ctps.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/lambda_spec.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/lambda_spec.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/lambda_spec.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/lambda_spec.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/lambda_support.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/lambda_support.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/lambda_support.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/lambda_support.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/largest_int.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/largest_int.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/largest_int.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/largest_int.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/logical_op.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/logical_op.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/logical_op.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/logical_op.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/msvc_dtw.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/msvc_dtw.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/msvc_dtw.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/msvc_dtw.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/msvc_eti_base.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/msvc_eti_base.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/msvc_eti_base.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/msvc_eti_base.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/msvc_is_class.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/msvc_is_class.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/msvc_is_class.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/msvc_is_class.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/msvc_never_true.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/msvc_never_true.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/msvc_never_true.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/msvc_never_true.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/msvc_type.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/msvc_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/msvc_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/msvc_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/na.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/na.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/na.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/na.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/na_assert.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/na_assert.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/na_assert.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/na_assert.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/na_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/na_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/na_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/na_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/na_spec.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/na_spec.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/na_spec.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/na_spec.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/nested_type_wknd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/nested_type_wknd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/nested_type_wknd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/nested_type_wknd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/nttp_decl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/nttp_decl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/nttp_decl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/nttp_decl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/numeric_cast_utils.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/numeric_cast_utils.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/numeric_cast_utils.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/numeric_cast_utils.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/numeric_op.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/numeric_op.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/numeric_op.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/numeric_op.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/order_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/order_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/order_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/order_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/overload_names.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/overload_names.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/overload_names.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/overload_names.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/partition_op.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/partition_op.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/partition_op.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/partition_op.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/pop_back_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/pop_back_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/pop_back_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/pop_back_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/pop_front_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/pop_front_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/pop_front_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/pop_front_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/advance_backward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/advance_backward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/advance_backward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/advance_backward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/advance_forward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/advance_forward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/advance_forward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/advance_forward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/and.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/and.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/and.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/and.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/apply.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/apply.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/apply.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/apply.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/apply_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/apply_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/apply_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/apply_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/apply_wrap.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/apply_wrap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/apply_wrap.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/apply_wrap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/arg.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/arg.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/arg.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/arg.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/basic_bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/basic_bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/basic_bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/basic_bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/bind_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/bind_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/bind_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/bind_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/bitand.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/bitand.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/bitand.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/bitand.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/bitor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/bitor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/bitor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/bitor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/bitxor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/bitxor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/bitxor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/bitxor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/deque.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/deque.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/deque.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/deque.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/divides.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/divides.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/divides.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/divides.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/full_lambda.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/full_lambda.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/full_lambda.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/full_lambda.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/greater.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/greater.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/greater.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/greater.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/greater_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/greater_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/greater_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/greater_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/inherit.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/inherit.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/inherit.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/inherit.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/iter_fold_if_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/iter_fold_if_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/iter_fold_if_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/iter_fold_if_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/lambda_no_ctps.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/lambda_no_ctps.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/lambda_no_ctps.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/lambda_no_ctps.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/less.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/less.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/less.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/less.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/less_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/less_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/less_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/less_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/list.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/list.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/list_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/list_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/list_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/list_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/map.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/map.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/map.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/map.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/minus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/minus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/minus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/minus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/modulus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/modulus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/modulus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/modulus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/not_equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/not_equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/not_equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/not_equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/or.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/or.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/or.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/or.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/placeholders.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/placeholders.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/placeholders.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/placeholders.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/plus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/plus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/plus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/plus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/quote.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/quote.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/quote.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/quote.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/reverse_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/reverse_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/reverse_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/reverse_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/reverse_iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/reverse_iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/reverse_iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/reverse_iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/set.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/set.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/set_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/set_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/set_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/set_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/shift_left.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/shift_left.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/shift_left.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/shift_left.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/shift_right.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/shift_right.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/shift_right.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/shift_right.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/template_arity.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/template_arity.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/template_arity.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/template_arity.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/times.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/times.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/times.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/times.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/unpack_args.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/unpack_args.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/unpack_args.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/unpack_args.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/vector.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/vector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/vector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/vector_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/vector_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc/vector_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc/vector_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/advance_backward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/advance_backward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/advance_backward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/advance_backward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/advance_forward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/advance_forward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/advance_forward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/advance_forward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/and.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/and.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/and.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/and.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/apply.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/apply.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/apply.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/apply.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/apply_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/apply_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/apply_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/apply_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/apply_wrap.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/apply_wrap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/apply_wrap.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/apply_wrap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/arg.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/arg.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/arg.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/arg.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/basic_bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/basic_bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/basic_bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/basic_bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/bind_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/bind_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/bind_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/bind_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/bitand.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/bitand.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/bitand.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/bitand.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/bitor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/bitor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/bitor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/bitor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/bitxor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/bitxor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/bitxor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/bitxor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/deque.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/deque.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/deque.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/deque.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/divides.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/divides.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/divides.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/divides.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/full_lambda.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/full_lambda.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/full_lambda.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/full_lambda.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/greater.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/greater.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/greater.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/greater.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/greater_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/greater_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/greater_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/greater_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/inherit.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/inherit.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/inherit.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/inherit.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/iter_fold_if_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/iter_fold_if_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/iter_fold_if_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/iter_fold_if_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/lambda_no_ctps.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/lambda_no_ctps.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/lambda_no_ctps.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/lambda_no_ctps.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/less.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/less.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/less.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/less.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/less_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/less_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/less_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/less_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/list.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/list.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/list_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/list_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/list_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/list_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/map.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/map.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/map.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/map.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/minus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/minus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/minus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/minus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/modulus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/modulus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/modulus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/modulus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/not_equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/not_equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/not_equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/not_equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/or.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/or.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/or.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/or.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/placeholders.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/placeholders.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/placeholders.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/placeholders.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/plus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/plus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/plus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/plus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/quote.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/quote.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/quote.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/quote.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/reverse_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/reverse_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/reverse_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/reverse_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/reverse_iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/reverse_iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/reverse_iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/reverse_iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/set.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/set.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/set_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/set_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/set_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/set_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/shift_left.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/shift_left.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/shift_left.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/shift_left.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/shift_right.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/shift_right.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/shift_right.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/shift_right.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/template_arity.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/template_arity.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/template_arity.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/template_arity.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/times.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/times.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/times.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/times.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/unpack_args.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/unpack_args.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/unpack_args.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/unpack_args.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/vector.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/vector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/vector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/vector_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/vector_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc551/vector_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc551/vector_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/advance_backward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/advance_backward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/advance_backward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/advance_backward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/advance_forward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/advance_forward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/advance_forward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/advance_forward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/and.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/and.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/and.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/and.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/apply.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/apply.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/apply.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/apply.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/apply_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/apply_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/apply_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/apply_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/apply_wrap.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/apply_wrap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/apply_wrap.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/apply_wrap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/arg.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/arg.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/arg.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/arg.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/basic_bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/basic_bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/basic_bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/basic_bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/bind_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/bind_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/bind_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/bind_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/bitand.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/bitand.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/bitand.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/bitand.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/bitor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/bitor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/bitor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/bitor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/bitxor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/bitxor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/bitxor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/bitxor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/deque.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/deque.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/deque.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/deque.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/divides.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/divides.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/divides.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/divides.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/full_lambda.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/full_lambda.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/full_lambda.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/full_lambda.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/greater.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/greater.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/greater.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/greater.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/greater_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/greater_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/greater_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/greater_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/inherit.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/inherit.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/inherit.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/inherit.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/iter_fold_if_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/iter_fold_if_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/iter_fold_if_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/iter_fold_if_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/lambda_no_ctps.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/lambda_no_ctps.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/lambda_no_ctps.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/lambda_no_ctps.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/less.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/less.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/less.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/less.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/less_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/less_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/less_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/less_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/list.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/list.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/list_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/list_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/list_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/list_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/map.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/map.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/map.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/map.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/minus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/minus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/minus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/minus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/modulus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/modulus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/modulus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/modulus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/not_equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/not_equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/not_equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/not_equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/or.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/or.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/or.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/or.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/placeholders.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/placeholders.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/placeholders.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/placeholders.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/plus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/plus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/plus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/plus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/quote.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/quote.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/quote.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/quote.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/reverse_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/reverse_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/reverse_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/reverse_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/reverse_iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/reverse_iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/reverse_iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/reverse_iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/set.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/set.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/set_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/set_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/set_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/set_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/shift_left.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/shift_left.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/shift_left.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/shift_left.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/shift_right.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/shift_right.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/shift_right.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/shift_right.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/template_arity.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/template_arity.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/template_arity.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/template_arity.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/times.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/times.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/times.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/times.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/unpack_args.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/unpack_args.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/unpack_args.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/unpack_args.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/vector.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/vector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/vector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/vector_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/vector_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/bcc_pre590/vector_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/bcc_pre590/vector_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/advance_backward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/advance_backward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/advance_backward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/advance_backward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/advance_forward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/advance_forward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/advance_forward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/advance_forward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/and.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/and.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/and.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/and.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/apply.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/apply.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/apply.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/apply.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/apply_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/apply_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/apply_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/apply_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/apply_wrap.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/apply_wrap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/apply_wrap.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/apply_wrap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/arg.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/arg.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/arg.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/arg.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/basic_bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/basic_bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/basic_bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/basic_bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/bind_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/bind_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/bind_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/bind_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/bitand.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/bitand.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/bitand.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/bitand.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/bitor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/bitor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/bitor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/bitor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/bitxor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/bitxor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/bitxor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/bitxor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/deque.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/deque.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/deque.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/deque.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/divides.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/divides.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/divides.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/divides.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/full_lambda.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/full_lambda.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/full_lambda.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/full_lambda.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/greater.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/greater.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/greater.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/greater.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/greater_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/greater_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/greater_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/greater_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/inherit.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/inherit.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/inherit.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/inherit.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/iter_fold_if_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/iter_fold_if_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/iter_fold_if_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/iter_fold_if_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/lambda_no_ctps.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/lambda_no_ctps.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/lambda_no_ctps.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/lambda_no_ctps.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/less.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/less.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/less.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/less.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/less_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/less_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/less_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/less_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/list.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/list.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/list_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/list_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/list_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/list_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/map.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/map.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/map.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/map.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/minus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/minus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/minus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/minus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/modulus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/modulus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/modulus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/modulus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/not_equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/not_equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/not_equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/not_equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/or.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/or.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/or.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/or.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/placeholders.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/placeholders.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/placeholders.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/placeholders.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/plus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/plus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/plus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/plus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/quote.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/quote.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/quote.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/quote.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/reverse_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/reverse_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/reverse_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/reverse_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/reverse_iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/reverse_iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/reverse_iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/reverse_iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/set.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/set.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/set_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/set_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/set_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/set_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/shift_left.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/shift_left.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/shift_left.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/shift_left.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/shift_right.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/shift_right.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/shift_right.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/shift_right.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/template_arity.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/template_arity.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/template_arity.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/template_arity.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/times.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/times.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/times.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/times.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/unpack_args.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/unpack_args.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/unpack_args.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/unpack_args.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/vector.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/vector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/vector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/vector_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/vector_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/dmc/vector_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/dmc/vector_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/advance_backward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/advance_forward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/and.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/and.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/and.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/and.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/apply.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/apply.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/apply.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/apply.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/apply_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/apply_wrap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/arg.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/arg.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/arg.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/arg.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/basic_bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/basic_bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/basic_bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/basic_bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/bind_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/bitand.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/bitand.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/bitand.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/bitand.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/bitor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/bitor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/bitor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/bitor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/bitxor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/bitxor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/bitxor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/bitxor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/deque.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/deque.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/deque.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/deque.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/divides.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/divides.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/divides.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/divides.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/full_lambda.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/greater.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/greater.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/greater.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/greater.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/greater_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/inherit.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/inherit.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/inherit.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/inherit.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/iter_fold_if_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/lambda_no_ctps.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/lambda_no_ctps.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/lambda_no_ctps.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/lambda_no_ctps.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/less.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/less.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/less.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/less.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/less_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/less_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/less_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/less_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/list.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/list.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/list_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/list_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/list_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/list_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/map.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/map.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/map.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/map.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/minus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/minus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/minus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/minus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/modulus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/modulus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/modulus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/modulus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/not_equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/or.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/or.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/or.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/or.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/placeholders.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/plus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/plus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/plus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/plus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/quote.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/quote.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/quote.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/quote.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/reverse_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/reverse_iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/reverse_iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/reverse_iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/reverse_iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/set.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/set.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/set_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/set_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/set_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/set_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/shift_left.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/shift_left.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/shift_left.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/shift_left.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/shift_right.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/shift_right.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/shift_right.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/shift_right.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/template_arity.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/times.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/times.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/times.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/times.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/unpack_args.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/unpack_args.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/unpack_args.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/unpack_args.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/vector.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/vector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/vector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/vector_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/vector_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/gcc/vector_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/gcc/vector_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/advance_backward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/advance_backward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/advance_backward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/advance_backward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/advance_forward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/advance_forward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/advance_forward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/advance_forward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/and.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/and.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/and.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/and.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/apply.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/apply.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/apply.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/apply.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/apply_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/apply_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/apply_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/apply_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/apply_wrap.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/apply_wrap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/apply_wrap.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/apply_wrap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/arg.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/arg.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/arg.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/arg.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/basic_bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/basic_bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/basic_bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/basic_bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/bind_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/bind_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/bind_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/bind_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/bitand.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/bitand.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/bitand.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/bitand.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/bitor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/bitor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/bitor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/bitor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/bitxor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/bitxor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/bitxor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/bitxor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/deque.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/deque.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/deque.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/deque.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/divides.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/divides.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/divides.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/divides.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/full_lambda.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/full_lambda.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/full_lambda.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/full_lambda.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/greater.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/greater.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/greater.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/greater.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/greater_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/greater_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/greater_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/greater_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/inherit.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/inherit.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/inherit.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/inherit.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/iter_fold_if_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/iter_fold_if_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/iter_fold_if_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/iter_fold_if_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/lambda_no_ctps.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/lambda_no_ctps.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/lambda_no_ctps.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/lambda_no_ctps.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/less.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/less.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/less.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/less.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/less_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/less_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/less_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/less_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/list.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/list.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/list_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/list_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/list_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/list_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/map.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/map.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/map.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/map.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/minus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/minus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/minus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/minus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/modulus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/modulus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/modulus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/modulus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/not_equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/not_equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/not_equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/not_equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/or.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/or.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/or.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/or.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/placeholders.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/placeholders.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/placeholders.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/placeholders.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/plus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/plus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/plus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/plus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/quote.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/quote.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/quote.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/quote.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/reverse_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/reverse_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/reverse_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/reverse_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/reverse_iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/reverse_iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/reverse_iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/reverse_iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/set.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/set.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/set_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/set_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/set_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/set_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/shift_left.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/shift_left.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/shift_left.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/shift_left.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/shift_right.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/shift_right.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/shift_right.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/shift_right.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/template_arity.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/template_arity.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/template_arity.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/template_arity.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/times.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/times.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/times.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/times.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/unpack_args.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/unpack_args.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/unpack_args.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/unpack_args.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/vector.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/vector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/vector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/vector_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/vector_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc60/vector_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc60/vector_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/advance_backward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/advance_backward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/advance_backward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/advance_backward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/advance_forward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/advance_forward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/advance_forward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/advance_forward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/and.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/and.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/and.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/and.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/apply.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/apply.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/apply.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/apply.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/apply_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/apply_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/apply_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/apply_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/apply_wrap.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/apply_wrap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/apply_wrap.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/apply_wrap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/arg.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/arg.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/arg.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/arg.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/basic_bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/basic_bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/basic_bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/basic_bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/bind_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/bind_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/bind_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/bind_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/bitand.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/bitand.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/bitand.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/bitand.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/bitor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/bitor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/bitor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/bitor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/bitxor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/bitxor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/bitxor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/bitxor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/deque.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/deque.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/deque.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/deque.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/divides.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/divides.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/divides.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/divides.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/full_lambda.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/full_lambda.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/full_lambda.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/full_lambda.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/greater.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/greater.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/greater.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/greater.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/greater_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/greater_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/greater_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/greater_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/inherit.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/inherit.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/inherit.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/inherit.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/iter_fold_if_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/iter_fold_if_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/iter_fold_if_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/iter_fold_if_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/lambda_no_ctps.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/lambda_no_ctps.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/lambda_no_ctps.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/lambda_no_ctps.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/less.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/less.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/less.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/less.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/less_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/less_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/less_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/less_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/list.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/list.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/list_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/list_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/list_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/list_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/map.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/map.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/map.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/map.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/minus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/minus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/minus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/minus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/modulus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/modulus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/modulus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/modulus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/not_equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/not_equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/not_equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/not_equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/or.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/or.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/or.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/or.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/placeholders.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/placeholders.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/placeholders.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/placeholders.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/plus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/plus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/plus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/plus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/quote.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/quote.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/quote.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/quote.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/reverse_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/reverse_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/reverse_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/reverse_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/reverse_iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/reverse_iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/reverse_iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/reverse_iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/set.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/set.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/set_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/set_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/set_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/set_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/shift_left.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/shift_left.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/shift_left.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/shift_left.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/shift_right.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/shift_right.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/shift_right.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/shift_right.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/template_arity.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/template_arity.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/template_arity.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/template_arity.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/times.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/times.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/times.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/times.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/unpack_args.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/unpack_args.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/unpack_args.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/unpack_args.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/vector.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/vector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/vector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/vector_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/vector_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/msvc70/vector_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/msvc70/vector_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/advance_backward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/advance_backward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/advance_backward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/advance_backward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/advance_forward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/advance_forward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/advance_forward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/advance_forward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/and.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/and.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/and.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/and.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/apply.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/apply.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/apply.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/apply.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/apply_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/apply_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/apply_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/apply_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/apply_wrap.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/apply_wrap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/apply_wrap.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/apply_wrap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/arg.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/arg.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/arg.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/arg.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/basic_bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/basic_bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/basic_bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/basic_bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/bind_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/bind_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/bind_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/bind_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/bitand.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/bitand.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/bitand.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/bitand.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/bitor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/bitor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/bitor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/bitor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/bitxor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/bitxor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/bitxor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/bitxor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/deque.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/deque.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/deque.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/deque.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/divides.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/divides.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/divides.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/divides.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/full_lambda.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/full_lambda.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/full_lambda.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/full_lambda.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/greater.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/greater.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/greater.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/greater.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/greater_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/greater_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/greater_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/greater_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/inherit.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/inherit.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/inherit.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/inherit.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/iter_fold_if_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/iter_fold_if_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/iter_fold_if_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/iter_fold_if_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/lambda_no_ctps.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/lambda_no_ctps.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/lambda_no_ctps.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/lambda_no_ctps.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/less.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/less.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/less.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/less.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/less_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/less_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/less_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/less_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/list.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/list.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/list_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/list_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/list_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/list_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/map.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/map.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/map.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/map.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/minus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/minus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/minus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/minus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/modulus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/modulus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/modulus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/modulus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/not_equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/not_equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/not_equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/not_equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/or.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/or.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/or.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/or.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/placeholders.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/placeholders.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/placeholders.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/placeholders.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/plus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/plus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/plus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/plus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/quote.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/quote.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/quote.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/quote.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/reverse_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/reverse_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/reverse_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/reverse_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/reverse_iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/reverse_iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/reverse_iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/reverse_iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/set.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/set.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/set_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/set_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/set_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/set_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/shift_left.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/shift_left.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/shift_left.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/shift_left.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/shift_right.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/shift_right.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/shift_right.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/shift_right.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/template_arity.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/template_arity.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/template_arity.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/template_arity.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/times.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/times.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/times.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/times.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/unpack_args.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/unpack_args.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/unpack_args.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/unpack_args.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/vector.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/vector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/vector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/vector_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/vector_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/mwcw/vector_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/mwcw/vector_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/advance_backward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/advance_backward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/advance_backward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/advance_backward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/advance_forward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/advance_forward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/advance_forward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/advance_forward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/and.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/and.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/and.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/and.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/apply.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/apply.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/apply.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/apply.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/apply_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/apply_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/apply_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/apply_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/apply_wrap.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/apply_wrap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/apply_wrap.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/apply_wrap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/arg.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/arg.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/arg.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/arg.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/basic_bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/basic_bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/basic_bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/basic_bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/bind_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/bind_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/bind_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/bind_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/bitand.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/bitand.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/bitand.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/bitand.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/bitor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/bitor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/bitor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/bitor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/bitxor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/bitxor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/bitxor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/bitxor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/deque.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/deque.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/deque.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/deque.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/divides.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/divides.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/divides.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/divides.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/full_lambda.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/full_lambda.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/full_lambda.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/full_lambda.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/greater.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/greater.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/greater.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/greater.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/greater_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/greater_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/greater_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/greater_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/inherit.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/inherit.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/inherit.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/inherit.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/iter_fold_if_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/iter_fold_if_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/iter_fold_if_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/iter_fold_if_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/lambda_no_ctps.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/lambda_no_ctps.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/lambda_no_ctps.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/lambda_no_ctps.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/less.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/less.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/less.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/less.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/less_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/less_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/less_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/less_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/list.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/list.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/list_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/list_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/list_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/list_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/map.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/map.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/map.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/map.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/minus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/minus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/minus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/minus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/modulus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/modulus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/modulus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/modulus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/not_equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/not_equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/not_equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/not_equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/or.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/or.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/or.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/or.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/placeholders.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/placeholders.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/placeholders.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/placeholders.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/plus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/plus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/plus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/plus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/quote.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/quote.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/quote.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/quote.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/reverse_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/reverse_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/reverse_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/reverse_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/reverse_iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/reverse_iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/reverse_iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/reverse_iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/set.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/set.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/set_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/set_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/set_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/set_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/shift_left.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/shift_left.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/shift_left.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/shift_left.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/shift_right.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/shift_right.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/shift_right.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/shift_right.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/template_arity.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/template_arity.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/template_arity.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/template_arity.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/times.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/times.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/times.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/times.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/unpack_args.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/unpack_args.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/unpack_args.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/unpack_args.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/vector.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/vector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/vector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/vector_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/vector_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ctps/vector_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ctps/vector_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/advance_backward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/advance_backward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/advance_backward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/advance_backward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/advance_forward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/advance_forward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/advance_forward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/advance_forward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/and.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/and.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/and.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/and.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/apply.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/apply.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/apply.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/apply.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/apply_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/apply_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/apply_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/apply_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/apply_wrap.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/apply_wrap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/apply_wrap.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/apply_wrap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/arg.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/arg.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/arg.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/arg.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/basic_bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/basic_bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/basic_bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/basic_bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/bind_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/bind_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/bind_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/bind_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/bitand.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/bitand.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/bitand.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/bitand.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/bitor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/bitor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/bitor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/bitor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/bitxor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/bitxor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/bitxor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/bitxor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/deque.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/deque.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/deque.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/deque.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/divides.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/divides.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/divides.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/divides.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/full_lambda.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/full_lambda.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/full_lambda.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/full_lambda.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/greater.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/greater.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/greater.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/greater.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/greater_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/greater_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/greater_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/greater_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/inherit.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/inherit.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/inherit.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/inherit.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_if_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_if_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_if_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_if_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/lambda_no_ctps.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/lambda_no_ctps.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/lambda_no_ctps.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/lambda_no_ctps.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/less.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/less.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/less.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/less.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/less_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/less_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/less_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/less_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/list.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/list.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/list_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/list_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/list_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/list_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/map.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/map.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/map.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/map.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/minus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/minus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/minus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/minus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/modulus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/modulus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/modulus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/modulus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/not_equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/not_equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/not_equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/not_equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/or.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/or.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/or.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/or.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/placeholders.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/placeholders.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/placeholders.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/placeholders.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/plus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/plus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/plus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/plus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/quote.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/quote.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/quote.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/quote.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/reverse_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/reverse_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/reverse_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/reverse_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/reverse_iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/reverse_iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/reverse_iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/reverse_iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/set.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/set.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/set_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/set_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/set_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/set_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/shift_left.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/shift_left.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/shift_left.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/shift_left.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/shift_right.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/shift_right.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/shift_right.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/shift_right.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/template_arity.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/template_arity.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/template_arity.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/template_arity.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/times.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/times.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/times.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/times.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/unpack_args.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/unpack_args.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/unpack_args.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/unpack_args.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/vector.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/vector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/vector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/vector_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/vector_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/no_ttp/vector_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/no_ttp/vector_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/advance_backward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/advance_backward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/advance_backward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/advance_backward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/advance_forward.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/advance_forward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/advance_forward.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/advance_forward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/and.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/and.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/and.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/and.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/apply.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/apply.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/apply.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/apply.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/apply_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/apply_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/apply_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/apply_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/apply_wrap.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/apply_wrap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/apply_wrap.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/apply_wrap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/arg.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/arg.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/arg.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/arg.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/basic_bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/basic_bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/basic_bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/basic_bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/bind_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/bind_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/bind_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/bind_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/bitand.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/bitand.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/bitand.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/bitand.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/bitor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/bitor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/bitor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/bitor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/bitxor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/bitxor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/bitxor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/bitxor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/deque.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/deque.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/deque.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/deque.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/divides.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/divides.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/divides.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/divides.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/full_lambda.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/full_lambda.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/full_lambda.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/full_lambda.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/greater.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/greater.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/greater.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/greater.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/greater_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/greater_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/greater_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/greater_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/inherit.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/inherit.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/inherit.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/inherit.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/iter_fold_if_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/iter_fold_if_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/iter_fold_if_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/iter_fold_if_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/lambda_no_ctps.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/lambda_no_ctps.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/lambda_no_ctps.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/lambda_no_ctps.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/less.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/less.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/less.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/less.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/less_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/less_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/less_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/less_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/list.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/list.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/list_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/list_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/list_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/list_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/map.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/map.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/map.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/map.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/minus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/minus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/minus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/minus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/modulus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/modulus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/modulus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/modulus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/not_equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/not_equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/not_equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/not_equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/or.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/or.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/or.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/or.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/placeholders.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/placeholders.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/placeholders.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/placeholders.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/plus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/plus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/plus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/plus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/quote.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/quote.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/quote.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/quote.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/reverse_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/reverse_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/reverse_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/reverse_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/reverse_iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/reverse_iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/reverse_iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/reverse_iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/set.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/set.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/set_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/set_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/set_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/set_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/shift_left.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/shift_left.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/shift_left.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/shift_left.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/shift_right.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/shift_right.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/shift_right.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/shift_right.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/template_arity.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/template_arity.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/template_arity.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/template_arity.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/times.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/times.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/times.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/times.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/unpack_args.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/unpack_args.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/unpack_args.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/unpack_args.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/vector.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/vector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/vector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/vector_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/vector_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessed/plain/vector_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessed/plain/vector_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/add.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/add.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/add.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/add.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/def_params_tail.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/def_params_tail.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/def_params_tail.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/def_params_tail.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/default_params.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/default_params.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/default_params.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/default_params.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/enum.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/enum.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/enum.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/enum.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/ext_params.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/ext_params.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/ext_params.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/ext_params.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/filter_params.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/filter_params.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/filter_params.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/filter_params.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/is_seq.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/is_seq.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/is_seq.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/is_seq.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/params.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/params.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/params.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/params.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/partial_spec_params.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/partial_spec_params.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/partial_spec_params.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/partial_spec_params.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/range.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/range.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/range.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/range.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/repeat.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/repeat.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/repeat.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/repeat.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/sub.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/sub.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/sub.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/sub.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/token_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/token_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/token_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/token_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/tuple.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/tuple.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/preprocessor/tuple.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/preprocessor/tuple.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/ptr_to_ref.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/ptr_to_ref.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/ptr_to_ref.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/ptr_to_ref.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/push_back_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/push_back_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/push_back_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/push_back_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/push_front_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/push_front_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/push_front_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/push_front_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/range_c/O1_size.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/range_c/O1_size.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/range_c/O1_size.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/range_c/O1_size.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/range_c/back.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/range_c/back.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/range_c/back.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/range_c/back.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/range_c/empty.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/range_c/empty.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/range_c/empty.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/range_c/empty.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/range_c/front.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/range_c/front.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/range_c/front.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/range_c/front.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/range_c/iterator.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/range_c/iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/range_c/iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/range_c/iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/range_c/size.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/range_c/size.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/range_c/size.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/range_c/size.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/range_c/tag.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/range_c/tag.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/range_c/tag.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/range_c/tag.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/reverse_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/reverse_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/reverse_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/reverse_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/reverse_fold_impl_body.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/reverse_fold_impl_body.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/reverse_fold_impl_body.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/reverse_fold_impl_body.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/reverse_iter_fold_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/reverse_iter_fold_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/reverse_iter_fold_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/reverse_iter_fold_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/sequence_wrapper.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/sequence_wrapper.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/sequence_wrapper.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/sequence_wrapper.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/shift_op.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/shift_op.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/shift_op.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/shift_op.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/single_element_iter.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/single_element_iter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/single_element_iter.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/single_element_iter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/size_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/size_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/size_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/size_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/sort_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/sort_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/sort_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/sort_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/static_cast.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/static_cast.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/static_cast.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/static_cast.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/template_arity.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/template_arity.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/template_arity.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/template_arity.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/template_arity_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/template_arity_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/template_arity_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/template_arity_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/test.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/test.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/test.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/test.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/test/assert.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/test/assert.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/test/assert.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/test/assert.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/test/data.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/test/data.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/test/data.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/test/data.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/test/test_case.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/test/test_case.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/test/test_case.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/test/test_case.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/traits_lambda_spec.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/traits_lambda_spec.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/traits_lambda_spec.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/traits_lambda_spec.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/transform_iter.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/transform_iter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/transform_iter.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/transform_iter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/type_wrapper.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/type_wrapper.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/type_wrapper.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/type_wrapper.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/unwrap.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/unwrap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/unwrap.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/unwrap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/value_wknd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/value_wknd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/value_wknd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/value_wknd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/aux_/yes_no.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/aux_/yes_no.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/aux_/yes_no.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/aux_/yes_no.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/back.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/back.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/back.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/back.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/back_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/back_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/back_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/back_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/back_inserter.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/back_inserter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/back_inserter.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/back_inserter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/base.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/base.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/base.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/base.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/begin.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/begin.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/begin.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/begin.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/begin_end.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/begin_end.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/begin_end.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/begin_end.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/begin_end_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/begin_end_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/begin_end_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/begin_end_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/bind.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/bind_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/bind_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/bind_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/bind_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/bitand.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/bitand.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/bitand.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/bitand.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/bitor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/bitor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/bitor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/bitor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/bitwise.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/bitwise.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/bitwise.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/bitwise.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/bitxor.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/bitxor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/bitxor.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/bitxor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/bool.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/bool.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/bool.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/bool.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/bool_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/bool_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/bool_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/bool_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/char.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/char.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/char.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/char.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/char_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/char_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/char_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/char_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/clear.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/clear.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/clear.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/clear.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/clear_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/clear_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/clear_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/clear_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/comparison.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/comparison.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/comparison.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/comparison.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/contains.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/contains.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/contains.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/contains.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/contains_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/contains_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/contains_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/contains_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/copy.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/copy.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/copy.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/copy.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/copy_if.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/copy_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/copy_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/copy_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/count.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/count.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/count.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/count.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/count_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/count_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/count_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/count_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/count_if.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/count_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/count_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/count_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/deque.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/deque.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/deque.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/deque.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/deref.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/deref.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/deref.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/deref.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/distance.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/distance.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/distance.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/distance.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/distance_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/distance_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/distance_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/distance_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/divides.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/divides.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/divides.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/divides.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/empty.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/empty.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/empty.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/empty.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/empty_base.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/empty_base.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/empty_base.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/empty_base.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/empty_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/empty_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/empty_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/empty_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/empty_sequence.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/empty_sequence.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/empty_sequence.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/empty_sequence.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/end.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/end.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/end.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/end.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/erase.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/erase.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/erase.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/erase.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/erase_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/erase_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/erase_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/erase_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/erase_key.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/erase_key.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/erase_key.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/erase_key.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/erase_key_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/erase_key_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/erase_key_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/erase_key_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/eval_if.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/eval_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/eval_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/eval_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/filter_view.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/filter_view.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/filter_view.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/filter_view.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/find.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/find.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/find.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/find.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/find_if.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/find_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/find_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/find_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/fold.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/fold.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/fold.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/fold.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/for_each.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/for_each.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/for_each.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/for_each.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/front.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/front.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/front.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/front.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/front_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/front_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/front_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/front_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/front_inserter.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/front_inserter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/front_inserter.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/front_inserter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/greater.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/greater.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/greater.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/greater.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/greater_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/greater_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/greater_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/greater_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/has_key.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/has_key.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/has_key.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/has_key.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/has_key_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/has_key_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/has_key_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/has_key_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/has_xxx.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/has_xxx.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/has_xxx.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/has_xxx.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/identity.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/identity.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/identity.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/identity.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/if.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/if.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/index_if.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/index_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/index_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/index_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/index_of.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/index_of.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/index_of.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/index_of.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/inherit.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/inherit.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/inherit.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/inherit.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/inherit_linearly.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/inherit_linearly.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/inherit_linearly.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/inherit_linearly.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/insert.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/insert.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/insert.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/insert.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/insert_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/insert_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/insert_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/insert_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/insert_range.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/insert_range.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/insert_range.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/insert_range.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/insert_range_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/insert_range_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/insert_range_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/insert_range_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/inserter.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/inserter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/inserter.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/inserter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/int.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/int.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/int.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/int.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/int_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/int_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/int_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/int_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/integral_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/integral_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/integral_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/integral_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/integral_c_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/integral_c_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/integral_c_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/integral_c_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/integral_c_tag.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/integral_c_tag.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/integral_c_tag.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/integral_c_tag.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/is_placeholder.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/is_placeholder.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/is_placeholder.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/is_placeholder.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/is_sequence.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/is_sequence.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/is_sequence.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/is_sequence.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/iter_fold.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/iter_fold.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/iter_fold.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/iter_fold.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/iter_fold_if.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/iter_fold_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/iter_fold_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/iter_fold_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/iterator_category.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/iterator_category.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/iterator_category.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/iterator_category.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/iterator_range.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/iterator_range.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/iterator_range.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/iterator_range.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/iterator_tags.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/iterator_tags.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/iterator_tags.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/iterator_tags.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/joint_view.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/joint_view.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/joint_view.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/joint_view.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/key_type.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/key_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/key_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/key_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/key_type_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/key_type_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/key_type_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/key_type_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/lambda.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/lambda.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/lambda.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/lambda.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/lambda_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/lambda_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/lambda_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/lambda_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/less.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/less.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/less.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/less.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/less_equal.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/less_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/less_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/less_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/limits/arity.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/limits/arity.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/limits/arity.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/limits/arity.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/limits/list.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/limits/list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/limits/list.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/limits/list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/limits/map.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/limits/map.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/limits/map.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/limits/map.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/limits/set.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/limits/set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/limits/set.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/limits/set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/limits/string.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/limits/string.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/limits/string.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/limits/string.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/limits/unrolling.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/limits/unrolling.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/limits/unrolling.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/limits/unrolling.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/limits/vector.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/limits/vector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/limits/vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/limits/vector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/O1_size.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/O1_size.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/O1_size.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/O1_size.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/begin_end.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/begin_end.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/begin_end.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/begin_end.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/clear.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/clear.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/clear.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/clear.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/empty.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/empty.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/empty.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/empty.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/front.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/front.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/front.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/front.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/include_preprocessed.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/include_preprocessed.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/include_preprocessed.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/include_preprocessed.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/item.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/item.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/item.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/item.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/iterator.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/numbered.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/numbered.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/numbered.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/numbered.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/numbered_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/numbered_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/numbered_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/numbered_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/pop_front.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/pop_front.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/pop_front.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/pop_front.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/preprocessed/plain/list10.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/preprocessed/plain/list10.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/preprocessed/plain/list10.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/preprocessed/plain/list10.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/preprocessed/plain/list10_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/preprocessed/plain/list10_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/preprocessed/plain/list10_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/preprocessed/plain/list10_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/preprocessed/plain/list20.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/preprocessed/plain/list20.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/preprocessed/plain/list20.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/preprocessed/plain/list20.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/preprocessed/plain/list20_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/preprocessed/plain/list20_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/preprocessed/plain/list20_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/preprocessed/plain/list20_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/preprocessed/plain/list30.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/preprocessed/plain/list30.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/preprocessed/plain/list30.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/preprocessed/plain/list30.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/preprocessed/plain/list30_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/preprocessed/plain/list30_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/preprocessed/plain/list30_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/preprocessed/plain/list30_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/preprocessed/plain/list40.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/preprocessed/plain/list40.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/preprocessed/plain/list40.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/preprocessed/plain/list40.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/preprocessed/plain/list40_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/preprocessed/plain/list40_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/preprocessed/plain/list40_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/preprocessed/plain/list40_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/preprocessed/plain/list50.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/preprocessed/plain/list50.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/preprocessed/plain/list50.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/preprocessed/plain/list50.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/preprocessed/plain/list50_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/preprocessed/plain/list50_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/preprocessed/plain/list50_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/preprocessed/plain/list50_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/push_back.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/push_back.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/push_back.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/push_back.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/push_front.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/push_front.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/push_front.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/push_front.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/size.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/size.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/size.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/size.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/tag.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/tag.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/aux_/tag.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/aux_/tag.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/list0.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/list0.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/list0.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/list0.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/list0_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/list0_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/list0_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/list0_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/list10.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/list10.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/list10.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/list10.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/list10_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/list10_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/list10_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/list10_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/list20.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/list20.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/list20.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/list20.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/list20_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/list20_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/list20_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/list20_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/list30.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/list30.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/list30.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/list30.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/list30_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/list30_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/list30_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/list30_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/list40.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/list40.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/list40.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/list40.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/list40_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/list40_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/list40_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/list40_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/list50.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/list50.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/list50.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/list50.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list/list50_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list/list50_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list/list50_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list/list50_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/list_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/list_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/list_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/list_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/logical.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/logical.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/logical.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/logical.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/long.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/long.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/long.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/long.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/long_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/long_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/long_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/long_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/lower_bound.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/lower_bound.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/lower_bound.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/lower_bound.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/at_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/at_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/at_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/at_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/begin_end_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/begin_end_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/begin_end_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/begin_end_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/clear_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/clear_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/clear_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/clear_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/contains_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/contains_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/contains_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/contains_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/empty_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/empty_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/empty_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/empty_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/erase_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/erase_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/erase_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/erase_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/erase_key_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/erase_key_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/erase_key_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/erase_key_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/has_key_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/has_key_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/has_key_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/has_key_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/include_preprocessed.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/include_preprocessed.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/include_preprocessed.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/include_preprocessed.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/insert_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/insert_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/insert_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/insert_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/insert_range_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/insert_range_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/insert_range_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/insert_range_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/item.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/item.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/item.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/item.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/iterator.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/key_type_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/key_type_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/key_type_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/key_type_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/map0.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/map0.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/map0.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/map0.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/numbered.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/numbered.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/numbered.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/numbered.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/no_ctps/map10.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/no_ctps/map10.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/no_ctps/map10.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/no_ctps/map10.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/no_ctps/map20.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/no_ctps/map20.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/no_ctps/map20.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/no_ctps/map20.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/no_ctps/map30.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/no_ctps/map30.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/no_ctps/map30.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/no_ctps/map30.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/no_ctps/map40.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/no_ctps/map40.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/no_ctps/map40.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/no_ctps/map40.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/no_ctps/map50.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/no_ctps/map50.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/no_ctps/map50.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/no_ctps/map50.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/plain/map10.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/plain/map10.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/plain/map10.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/plain/map10.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/plain/map20.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/plain/map20.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/plain/map20.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/plain/map20.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/plain/map30.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/plain/map30.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/plain/map30.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/plain/map30.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/plain/map40.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/plain/map40.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/plain/map40.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/plain/map40.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/plain/map50.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/plain/map50.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/plain/map50.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/plain/map50.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/typeof_based/map10.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/typeof_based/map10.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/typeof_based/map10.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/typeof_based/map10.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/typeof_based/map20.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/typeof_based/map20.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/typeof_based/map20.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/typeof_based/map20.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/typeof_based/map30.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/typeof_based/map30.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/typeof_based/map30.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/typeof_based/map30.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/typeof_based/map40.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/typeof_based/map40.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/typeof_based/map40.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/typeof_based/map40.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/typeof_based/map50.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/typeof_based/map50.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/preprocessed/typeof_based/map50.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/preprocessed/typeof_based/map50.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/size_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/size_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/size_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/size_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/tag.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/tag.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/tag.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/tag.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/value_type_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/value_type_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/aux_/value_type_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/aux_/value_type_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/map0.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/map0.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/map0.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/map0.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/map10.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/map10.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/map10.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/map10.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/map20.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/map20.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/map20.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/map20.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/map30.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/map30.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/map30.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/map30.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/map40.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/map40.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/map40.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/map40.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/map/map50.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/map/map50.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/map/map50.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/map/map50.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/math/fixed_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/math/fixed_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/math/fixed_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/math/fixed_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/math/is_even.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/math/is_even.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/math/is_even.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/math/is_even.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/math/rational_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/math/rational_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/math/rational_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/math/rational_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/max.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/max.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/max.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/max.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/max_element.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/max_element.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/max_element.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/max_element.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/min.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/min.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/min.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/min.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/min_element.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/min_element.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/min_element.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/min_element.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/min_max.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/min_max.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/min_max.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/min_max.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/minus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/minus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/minus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/minus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/modulus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/modulus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/modulus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/modulus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/multiplies.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/multiplies.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/multiplies.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/multiplies.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/multiset/aux_/count_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/multiset/aux_/count_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/multiset/aux_/count_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/multiset/aux_/count_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/multiset/aux_/insert_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/multiset/aux_/insert_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/multiset/aux_/insert_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/multiset/aux_/insert_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/multiset/aux_/item.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/multiset/aux_/item.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/multiset/aux_/item.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/multiset/aux_/item.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/multiset/aux_/multiset0.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/multiset/aux_/multiset0.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/multiset/aux_/multiset0.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/multiset/aux_/multiset0.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/multiset/aux_/tag.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/multiset/aux_/tag.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/multiset/aux_/tag.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/multiset/aux_/tag.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/multiset/multiset0.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/multiset/multiset0.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/multiset/multiset0.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/multiset/multiset0.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/negate.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/negate.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/negate.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/negate.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/next.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/next.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/next.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/next.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/next_prior.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/next_prior.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/next_prior.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/next_prior.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/not.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/not.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/not.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/not.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/not_equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/not_equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/not_equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/not_equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/numeric_cast.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/numeric_cast.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/numeric_cast.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/numeric_cast.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/or.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/or.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/or.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/or.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/order.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/order.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/order.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/order.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/order_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/order_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/order_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/order_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/pair.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/pair.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/pair.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/pair.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/pair_view.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/pair_view.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/pair_view.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/pair_view.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/partition.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/partition.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/partition.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/partition.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/placeholders.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/placeholders.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/placeholders.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/placeholders.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/plus.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/plus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/plus.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/plus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/pop_back.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/pop_back.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/pop_back.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/pop_back.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/pop_back_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/pop_back_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/pop_back_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/pop_back_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/pop_front.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/pop_front.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/pop_front.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/pop_front.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/pop_front_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/pop_front_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/pop_front_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/pop_front_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/print.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/print.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/print.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/print.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/prior.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/prior.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/prior.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/prior.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/protect.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/protect.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/protect.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/protect.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/push_back.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/push_back.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/push_back.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/push_back.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/push_back_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/push_back_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/push_back_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/push_back_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/push_front.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/push_front.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/push_front.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/push_front.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/push_front_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/push_front_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/push_front_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/push_front_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/quote.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/quote.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/quote.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/quote.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/range_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/range_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/range_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/range_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/remove.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/remove.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/remove.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/remove.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/remove_if.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/remove_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/remove_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/remove_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/replace.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/replace.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/replace.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/replace.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/replace_if.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/replace_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/replace_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/replace_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/reverse.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/reverse.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/reverse.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/reverse.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/reverse_fold.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/reverse_fold.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/reverse_fold.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/reverse_fold.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/reverse_iter_fold.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/reverse_iter_fold.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/reverse_iter_fold.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/reverse_iter_fold.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/same_as.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/same_as.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/same_as.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/same_as.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/sequence_tag.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/sequence_tag.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/sequence_tag.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/sequence_tag.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/sequence_tag_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/sequence_tag_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/sequence_tag_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/sequence_tag_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/at_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/at_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/at_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/at_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/begin_end_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/begin_end_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/begin_end_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/begin_end_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/clear_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/clear_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/clear_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/clear_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/empty_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/empty_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/empty_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/empty_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/erase_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/erase_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/erase_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/erase_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/erase_key_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/erase_key_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/erase_key_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/erase_key_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/has_key_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/has_key_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/has_key_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/has_key_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/include_preprocessed.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/include_preprocessed.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/include_preprocessed.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/include_preprocessed.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/insert_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/insert_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/insert_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/insert_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/insert_range_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/insert_range_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/insert_range_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/insert_range_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/item.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/item.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/item.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/item.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/iterator.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/key_type_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/key_type_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/key_type_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/key_type_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/numbered.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/numbered.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/numbered.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/numbered.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/numbered_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/numbered_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/numbered_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/numbered_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/preprocessed/plain/set10.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/preprocessed/plain/set10.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/preprocessed/plain/set10.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/preprocessed/plain/set10.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/preprocessed/plain/set10_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/preprocessed/plain/set10_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/preprocessed/plain/set10_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/preprocessed/plain/set10_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/preprocessed/plain/set20.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/preprocessed/plain/set20.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/preprocessed/plain/set20.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/preprocessed/plain/set20.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/preprocessed/plain/set20_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/preprocessed/plain/set20_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/preprocessed/plain/set20_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/preprocessed/plain/set20_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/preprocessed/plain/set30.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/preprocessed/plain/set30.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/preprocessed/plain/set30.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/preprocessed/plain/set30.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/preprocessed/plain/set30_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/preprocessed/plain/set30_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/preprocessed/plain/set30_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/preprocessed/plain/set30_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/preprocessed/plain/set40.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/preprocessed/plain/set40.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/preprocessed/plain/set40.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/preprocessed/plain/set40.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/preprocessed/plain/set40_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/preprocessed/plain/set40_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/preprocessed/plain/set40_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/preprocessed/plain/set40_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/preprocessed/plain/set50.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/preprocessed/plain/set50.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/preprocessed/plain/set50.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/preprocessed/plain/set50.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/preprocessed/plain/set50_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/preprocessed/plain/set50_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/preprocessed/plain/set50_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/preprocessed/plain/set50_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/set0.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/set0.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/set0.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/set0.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/size_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/size_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/size_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/size_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/tag.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/tag.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/tag.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/tag.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/value_type_impl.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/value_type_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/aux_/value_type_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/aux_/value_type_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/set0.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/set0.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/set0.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/set0.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/set0_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/set0_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/set0_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/set0_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/set10.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/set10.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/set10.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/set10.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/set10_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/set10_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/set10_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/set10_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/set20.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/set20.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/set20.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/set20.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/set20_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/set20_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/set20_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/set20_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/set30.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/set30.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/set30.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/set30.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/set30_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/set30_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/set30_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/set30_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/set40.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/set40.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/set40.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/set40.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/set40_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/set40_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/set40_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/set40_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/set50.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/set50.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/set50.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/set50.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set/set50_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set/set50_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set/set50_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set/set50_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/set_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/set_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/set_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/set_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/shift_left.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/shift_left.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/shift_left.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/shift_left.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/shift_right.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/shift_right.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/shift_right.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/shift_right.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/single_view.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/single_view.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/single_view.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/single_view.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/size.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/size.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/size.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/size.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/size_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/size_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/size_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/size_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/size_t.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/size_t.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/size_t.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/size_t.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/size_t_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/size_t_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/size_t_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/size_t_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/sizeof.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/sizeof.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/sizeof.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/sizeof.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/sort.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/sort.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/sort.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/sort.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/stable_partition.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/stable_partition.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/stable_partition.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/stable_partition.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/string.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/string.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/string.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/string.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/switch.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/switch.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/switch.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/switch.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/tag.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/tag.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/tag.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/tag.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/times.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/times.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/times.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/times.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/transform.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/transform.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/transform.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/transform.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/transform_view.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/transform_view.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/transform_view.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/transform_view.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/unique.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/unique.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/unique.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/unique.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/unpack_args.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/unpack_args.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/unpack_args.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/unpack_args.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/upper_bound.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/upper_bound.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/upper_bound.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/upper_bound.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/value_type.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/value_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/value_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/value_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/value_type_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/value_type_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/value_type_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/value_type_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/O1_size.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/O1_size.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/O1_size.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/O1_size.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/at.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/at.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/at.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/at.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/back.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/back.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/back.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/back.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/begin_end.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/begin_end.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/begin_end.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/begin_end.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/clear.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/clear.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/clear.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/clear.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/empty.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/empty.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/empty.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/empty.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/front.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/front.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/front.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/front.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/include_preprocessed.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/include_preprocessed.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/include_preprocessed.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/include_preprocessed.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/item.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/item.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/item.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/item.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/iterator.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/numbered.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/numbered.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/numbered.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/numbered.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/numbered_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/numbered_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/numbered_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/numbered_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/pop_back.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/pop_back.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/pop_back.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/pop_back.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/pop_front.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/pop_front.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/pop_front.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/pop_front.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector10.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector10.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector10.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector10.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector10_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector10_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector10_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector10_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector20_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector30.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector30.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector30.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector30.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector30_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector30_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector30_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector30_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector40.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector40.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector40.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector40.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector40_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector40_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector40_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector40_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector50.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector50.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector50.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector50.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector50_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector50_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector50_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/no_ctps/vector50_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/plain/vector10.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/plain/vector10.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/plain/vector10.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/plain/vector10.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/plain/vector10_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/plain/vector10_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/plain/vector10_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/plain/vector10_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/plain/vector20.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/plain/vector20.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/plain/vector20.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/plain/vector20.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/plain/vector20_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/plain/vector20_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/plain/vector20_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/plain/vector20_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/plain/vector30.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/plain/vector30.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/plain/vector30.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/plain/vector30.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/plain/vector30_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/plain/vector30_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/plain/vector30_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/plain/vector30_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/plain/vector40.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/plain/vector40.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/plain/vector40.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/plain/vector40.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/plain/vector40_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/plain/vector40_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/plain/vector40_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/plain/vector40_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/plain/vector50.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/plain/vector50.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/plain/vector50.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/plain/vector50.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/plain/vector50_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/plain/vector50_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/plain/vector50_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/plain/vector50_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector10_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector20_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector30_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector40.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector40.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector40.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector40.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector40_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector40_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector40_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector40_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector50.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector50.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector50.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector50.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector50_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector50_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector50_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/preprocessed/typeof_based/vector50_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/push_back.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/push_back.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/push_back.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/push_back.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/push_front.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/push_front.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/push_front.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/push_front.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/size.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/size.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/size.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/size.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/tag.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/tag.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/tag.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/tag.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/vector0.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/vector0.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/aux_/vector0.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/aux_/vector0.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/vector0.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/vector0.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/vector0.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/vector0.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/vector0_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/vector0_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/vector0_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/vector0_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/vector10.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/vector10.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/vector10.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/vector10.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/vector10_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/vector10_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/vector10_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/vector10_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/vector20.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/vector20.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/vector20.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/vector20.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/vector20_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/vector20_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/vector20_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/vector20_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/vector30.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/vector30.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/vector30.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/vector30.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/vector30_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/vector30_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/vector30_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/vector30_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/vector40.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/vector40.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/vector40.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/vector40.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/vector40_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/vector40_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/vector40_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/vector40_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/vector50.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/vector50.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/vector50.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/vector50.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector/vector50_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector/vector50_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector/vector50_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector/vector50_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/vector_c.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/vector_c.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/vector_c.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/vector_c.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/void.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/void.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/void.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/void.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/void_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/void_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/void_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/void_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/mpl/zip_view.hpp b/contrib/libboost/boost_1_65_0/boost/mpl/zip_view.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/mpl/zip_view.hpp
rename to contrib/libboost/boost_1_65_0/boost/mpl/zip_view.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/next_prior.hpp b/contrib/libboost/boost_1_65_0/boost/next_prior.hpp
new file mode 100644
index 00000000000..bad46ed6548
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/next_prior.hpp
@@ -0,0 +1,180 @@
+//  Boost next_prior.hpp header file  ---------------------------------------//
+
+//  (C) Copyright Dave Abrahams and Daniel Walker 1999-2003.
+//  Copyright (c) Andrey Semashev 2017
+//
+//  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/utility for documentation.
+
+//  Revision History
+//  13 Dec 2003  Added next(x, n) and prior(x, n) (Daniel Walker)
+
+#ifndef BOOST_NEXT_PRIOR_HPP_INCLUDED
+#define BOOST_NEXT_PRIOR_HPP_INCLUDED
+
+#include <iterator>
+#include <boost/config.hpp>
+#include <boost/core/enable_if.hpp>
+#include <boost/type_traits/has_plus.hpp>
+#include <boost/type_traits/has_plus_assign.hpp>
+#include <boost/type_traits/has_minus.hpp>
+#include <boost/type_traits/has_minus_assign.hpp>
+#include <boost/iterator/advance.hpp>
+#include <boost/iterator/reverse_iterator.hpp>
+
+namespace boost {
+
+//  Helper functions for classes like bidirectional iterators not supporting
+//  operator+ and operator-
+//
+//  Usage:
+//    const std::list<T>::iterator p = get_some_iterator();
+//    const std::list<T>::iterator prev = boost::prior(p);
+//    const std::list<T>::iterator next = boost::next(prev, 2);
+
+//  Contributed by Dave Abrahams
+
+namespace next_prior_detail {
+
+// The trait attempts to detect if the T type is an iterator. Class-type iterators are assumed
+// to have the nested type iterator_category. Strictly speaking, this is not required to be the
+// case (e.g. a user can specialize iterator_traits for T without defining T::iterator_category).
+// Still, this is a good heuristic in practice, and we can't do anything better anyway.
+// Since C++17 we can test for iterator_traits<T>::iterator_category presence instead as it is
+// required to be only present for iterators.
+template< typename T, typename Void = void >
+struct is_iterator
+{
+    static BOOST_CONSTEXPR_OR_CONST bool value = false;
+};
+
+template< typename T >
+struct is_iterator< T, typename enable_if_has_type< typename T::iterator_category >::type >
+{
+    static BOOST_CONSTEXPR_OR_CONST bool value = true;
+};
+
+template< typename T >
+struct is_iterator< T*, void >
+{
+    static BOOST_CONSTEXPR_OR_CONST bool value = true;
+};
+
+
+template< typename T, typename Distance, bool HasPlus = has_plus< T, Distance >::value >
+struct next_plus_impl;
+
+template< typename T, typename Distance >
+struct next_plus_impl< T, Distance, true >
+{
+    static T call(T x, Distance n)
+    {
+        return x + n;
+    }
+};
+
+template< typename T, typename Distance, bool HasPlusAssign = has_plus_assign< T, Distance >::value >
+struct next_plus_assign_impl :
+    public next_plus_impl< T, Distance >
+{
+};
+
+template< typename T, typename Distance >
+struct next_plus_assign_impl< T, Distance, true >
+{
+    static T call(T x, Distance n)
+    {
+        x += n;
+        return x;
+    }
+};
+
+template< typename T, typename Distance, bool IsIterator = is_iterator< T >::value >
+struct next_advance_impl :
+    public next_plus_assign_impl< T, Distance >
+{
+};
+
+template< typename T, typename Distance >
+struct next_advance_impl< T, Distance, true >
+{
+    static T call(T x, Distance n)
+    {
+        boost::iterators::advance(x, n);
+        return x;
+    }
+};
+
+
+template< typename T, typename Distance, bool HasMinus = has_minus< T, Distance >::value >
+struct prior_minus_impl;
+
+template< typename T, typename Distance >
+struct prior_minus_impl< T, Distance, true >
+{
+    static T call(T x, Distance n)
+    {
+        return x - n;
+    }
+};
+
+template< typename T, typename Distance, bool HasMinusAssign = has_minus_assign< T, Distance >::value >
+struct prior_minus_assign_impl :
+    public prior_minus_impl< T, Distance >
+{
+};
+
+template< typename T, typename Distance >
+struct prior_minus_assign_impl< T, Distance, true >
+{
+    static T call(T x, Distance n)
+    {
+        x -= n;
+        return x;
+    }
+};
+
+template< typename T, typename Distance, bool IsIterator = is_iterator< T >::value >
+struct prior_advance_impl :
+    public prior_minus_assign_impl< T, Distance >
+{
+};
+
+template< typename T, typename Distance >
+struct prior_advance_impl< T, Distance, true >
+{
+    static T call(T x, Distance n)
+    {
+        // Avoid negating n to sidestep possible integer overflow
+        boost::iterators::reverse_iterator< T > rx(x);
+        boost::iterators::advance(rx, n);
+        return rx.base();
+    }
+};
+
+} // namespace next_prior_detail
+
+template <class T>
+inline T next(T x) { return ++x; }
+
+template <class T, class Distance>
+inline T next(T x, Distance n)
+{
+    return next_prior_detail::next_advance_impl< T, Distance >::call(x, n);
+}
+
+template <class T>
+inline T prior(T x) { return --x; }
+
+template <class T, class Distance>
+inline T prior(T x, Distance n)
+{
+    return next_prior_detail::prior_advance_impl< T, Distance >::call(x, n);
+}
+
+} // namespace boost
+
+#endif  // BOOST_NEXT_PRIOR_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/noncopyable.hpp b/contrib/libboost/boost_1_65_0/boost/noncopyable.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/noncopyable.hpp
rename to contrib/libboost/boost_1_65_0/boost/noncopyable.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/none.hpp b/contrib/libboost/boost_1_65_0/boost/none.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/none.hpp
rename to contrib/libboost/boost_1_65_0/boost/none.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/none_t.hpp b/contrib/libboost/boost_1_65_0/boost/none_t.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/none_t.hpp
rename to contrib/libboost/boost_1_65_0/boost/none_t.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/bounds.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/bounds.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/bounds.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/bounds.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/cast.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/cast.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/cast.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/cast.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/conversion_traits.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/conversion_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/conversion_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/conversion_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/converter.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/converter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/converter.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/converter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/converter_policies.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/converter_policies.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/converter_policies.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/converter_policies.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/bounds.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/bounds.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/bounds.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/bounds.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/conversion_traits.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/conversion_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/conversion_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/conversion_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/converter.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/converter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/converter.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/converter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/int_float_mixture.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/int_float_mixture.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/int_float_mixture.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/int_float_mixture.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/is_subranged.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/is_subranged.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/is_subranged.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/is_subranged.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/meta.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/meta.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/meta.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/meta.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/numeric_cast_traits.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/numeric_cast_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/numeric_cast_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/numeric_cast_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/old_numeric_cast.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/old_numeric_cast.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/old_numeric_cast.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/old_numeric_cast.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_common.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_common.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_common.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_common.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_long_long.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_long_long.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_long_long.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/preprocessed/numeric_cast_traits_long_long.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/sign_mixture.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/sign_mixture.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/sign_mixture.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/sign_mixture.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/udt_builtin_mixture.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/udt_builtin_mixture.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/detail/udt_builtin_mixture.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/detail/udt_builtin_mixture.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/int_float_mixture.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/int_float_mixture.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/int_float_mixture.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/int_float_mixture.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/int_float_mixture_enum.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/int_float_mixture_enum.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/int_float_mixture_enum.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/int_float_mixture_enum.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/is_subranged.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/is_subranged.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/is_subranged.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/is_subranged.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/numeric_cast_traits.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/numeric_cast_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/numeric_cast_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/numeric_cast_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/sign_mixture.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/sign_mixture.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/sign_mixture.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/sign_mixture.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/sign_mixture_enum.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/sign_mixture_enum.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/sign_mixture_enum.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/sign_mixture_enum.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/udt_builtin_mixture.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/udt_builtin_mixture.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/udt_builtin_mixture.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/udt_builtin_mixture.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/conversion/udt_builtin_mixture_enum.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/conversion/udt_builtin_mixture_enum.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/conversion/udt_builtin_mixture_enum.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/conversion/udt_builtin_mixture_enum.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval.hpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval.hpp
index e6f976df038..1f755430729 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval.hpp
@@ -1,7 +1,7 @@
 /* Boost interval.hpp header file
  *
  * Copyright 2000 Jens Maurer
- * Copyright 2002 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/arith.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/arith.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/arith.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/arith.hpp
index c0320c45ef9..0d598be7d01 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/arith.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/arith.hpp
@@ -1,7 +1,7 @@
 /* Boost interval/arith.hpp template implementation file
  *
  * Copyright 2000 Jens Maurer
- * Copyright 2002-2003 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002-2003 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/arith2.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/arith2.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/arith2.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/arith2.hpp
index 5501929e4be..b0aba7c04cc 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/arith2.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/arith2.hpp
@@ -4,7 +4,7 @@
  * functions: fmod, sqrt, square, pov, inverse and
  * a multi-interval division.
  *
- * Copyright 2002-2003 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002-2003 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/arith3.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/arith3.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/arith3.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/arith3.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/checking.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/checking.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/checking.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/checking.hpp
index 2db486a0bee..f40ba65a557 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/checking.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/checking.hpp
@@ -1,6 +1,6 @@
 /* Boost interval/checking.hpp template implementation file
  *
- * Copyright 2002 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/compare.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/compare.hpp
similarity index 89%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/compare.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/compare.hpp
index f21753e7110..0b4b751af12 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/compare.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/compare.hpp
@@ -1,6 +1,6 @@
 /* Boost interval/compare.hpp template implementation file
  *
- * Copyright 2002 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/compare/certain.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/compare/certain.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/compare/certain.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/compare/certain.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/compare/explicit.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/compare/explicit.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/compare/explicit.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/compare/explicit.hpp
index 8c68be8916b..f66dc641ed9 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/compare/explicit.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/compare/explicit.hpp
@@ -1,7 +1,7 @@
 /* Boost interval/compare/explicit.hpp template implementation file
  *
  * Copyright 2000 Jens Maurer
- * Copyright 2002 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/compare/lexicographic.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/compare/lexicographic.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/compare/lexicographic.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/compare/lexicographic.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/compare/possible.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/compare/possible.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/compare/possible.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/compare/possible.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/compare/set.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/compare/set.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/compare/set.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/compare/set.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/compare/tribool.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/compare/tribool.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/compare/tribool.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/compare/tribool.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/constants.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/constants.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/constants.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/constants.hpp
index a3a42efecee..6a228343ecb 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/constants.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/constants.hpp
@@ -1,6 +1,6 @@
 /* Boost interval/constants.hpp template implementation file
  *
- * Copyright 2002 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/alpha_rounding_control.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/alpha_rounding_control.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/alpha_rounding_control.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/alpha_rounding_control.hpp
index d9a6079e1be..25b6ff617f1 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/alpha_rounding_control.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/alpha_rounding_control.hpp
@@ -1,6 +1,6 @@
 /* Boost interval/detail/alpha_rounding_control.hpp file
  *
- * Copyright 2005 Felix H�fling, Guillaume Melquiond
+ * Copyright 2005 Felix Höfling, Guillaume Melquiond
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/bcc_rounding_control.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/bcc_rounding_control.hpp
similarity index 95%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/bcc_rounding_control.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/bcc_rounding_control.hpp
index e3aaf046c50..c55d0823b22 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/bcc_rounding_control.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/bcc_rounding_control.hpp
@@ -1,7 +1,7 @@
 /* Boost interval/detail/bcc_rounding_control.hpp file
  *
  * Copyright 2000 Jens Maurer
- * Copyright 2002 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/bugs.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/bugs.hpp
similarity index 95%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/bugs.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/bugs.hpp
index b9b421a230f..e15bd0cfb34 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/bugs.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/bugs.hpp
@@ -1,7 +1,7 @@
 /* Boost interval/detail/bugs.hpp file
  *
  * Copyright 2000 Jens Maurer
- * Copyright 2002 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/c99_rounding_control.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/c99_rounding_control.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/c99_rounding_control.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/c99_rounding_control.hpp
index 71d13e787af..2ba7847f7aa 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/c99_rounding_control.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/c99_rounding_control.hpp
@@ -1,7 +1,7 @@
 /* Boost interval/detail/c99_rounding_control.hpp file
  *
  * Copyright 2000 Jens Maurer
- * Copyright 2002 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/c99sub_rounding_control.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/c99sub_rounding_control.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/c99sub_rounding_control.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/c99sub_rounding_control.hpp
index 92c9b5c8a88..a8684df6a31 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/c99sub_rounding_control.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/c99sub_rounding_control.hpp
@@ -1,7 +1,7 @@
 /* Boost interval/detail/c99sub_rounding_control.hpp file
  *
  * Copyright 2000 Jens Maurer
- * Copyright 2002 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/division.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/division.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/division.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/division.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/ia64_rounding_control.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/ia64_rounding_control.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/ia64_rounding_control.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/ia64_rounding_control.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/interval_prototype.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/interval_prototype.hpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/interval_prototype.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/interval_prototype.hpp
index ac9029b70bd..47ba447b65e 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/interval_prototype.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/interval_prototype.hpp
@@ -1,6 +1,6 @@
 /* Boost interval/detail/interval_prototype.hpp file
  *
- * Copyright 2002 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/msvc_rounding_control.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/msvc_rounding_control.hpp
similarity index 95%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/msvc_rounding_control.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/msvc_rounding_control.hpp
index ccf1e8b4763..2ad3fc19ceb 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/msvc_rounding_control.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/msvc_rounding_control.hpp
@@ -1,7 +1,7 @@
 /* Boost interval/detail/msvc_rounding_control.hpp file
  *
  * Copyright 2000 Maarten Keijzer
- * Copyright 2002 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
@@ -91,7 +91,7 @@ struct x86_rounding
   {
     _control87(hard2msvc(mode),
       _MCW_EM | _MCW_RC
-#if !defined(_M_AMD64) && !defined(_M_ARM)
+#if !defined(_M_AMD64) && !defined(_M_ARM) && !defined(_M_ARM64)
       // x64 ignores _MCW_PC and _MCW_IC, and the Debug CRT library actually
       // asserts when these are passed to _control87.
       // MSDN says on '_control87' that changing precision (_MCW_PC) or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/ppc_rounding_control.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/ppc_rounding_control.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/ppc_rounding_control.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/ppc_rounding_control.hpp
index d2cf4c80f3f..87fe8ee665e 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/ppc_rounding_control.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/ppc_rounding_control.hpp
@@ -1,7 +1,7 @@
 /* Boost interval/detail/ppc_rounding_control.hpp file
  *
  * Copyright 2000 Jens Maurer
- * Copyright 2002 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  * Copyright 2005 Guillaume Melquiond
  *
  * Distributed under the Boost Software License, Version 1.0.
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/sparc_rounding_control.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/sparc_rounding_control.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/sparc_rounding_control.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/sparc_rounding_control.hpp
index 6ba5baf0383..2b08bec5cf5 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/sparc_rounding_control.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/sparc_rounding_control.hpp
@@ -1,7 +1,7 @@
 /* Boost interval/detail/sparc_rounding_control.hpp file
  *
  * Copyright 2000 Jens Maurer
- * Copyright 2002 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/test_input.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/test_input.hpp
similarity index 96%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/test_input.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/test_input.hpp
index 58695fec3cb..9f93bb04ef9 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/test_input.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/test_input.hpp
@@ -1,6 +1,6 @@
 /* Boost interval/detail/test_input.hpp file
  *
- * Copyright 2002 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/x86_rounding_control.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/x86_rounding_control.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/x86_rounding_control.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/x86_rounding_control.hpp
index c35f16d9143..3594d01691e 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/x86_rounding_control.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/x86_rounding_control.hpp
@@ -1,7 +1,7 @@
 /* Boost interval/detail/x86_rounding_control.hpp file
  *
  * Copyright 2000 Jens Maurer
- * Copyright 2002 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/x86gcc_rounding_control.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/x86gcc_rounding_control.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/x86gcc_rounding_control.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/x86gcc_rounding_control.hpp
index 079d681df96..da5513b5523 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/detail/x86gcc_rounding_control.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/detail/x86gcc_rounding_control.hpp
@@ -1,7 +1,7 @@
 /* Boost interval/detail/x86gcc_rounding_control.hpp file
  *
  * Copyright 2000 Jens Maurer
- * Copyright 2002 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/ext/integer.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/ext/integer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/ext/integer.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/ext/integer.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/ext/x86_fast_rounding_control.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/ext/x86_fast_rounding_control.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/ext/x86_fast_rounding_control.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/ext/x86_fast_rounding_control.hpp
index 7f89a4e5494..a505ead0924 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/ext/x86_fast_rounding_control.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/ext/x86_fast_rounding_control.hpp
@@ -7,7 +7,7 @@
  * overflow would happen without it. Indeed, only
  * values in range are correctly rounded.
  *
- * Copyright 2002 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/hw_rounding.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/hw_rounding.hpp
similarity index 92%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/hw_rounding.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/hw_rounding.hpp
index d0062567f82..574b2433a1c 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/hw_rounding.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/hw_rounding.hpp
@@ -1,6 +1,6 @@
 /* Boost interval/hw_rounding.hpp template implementation file
  *
- * Copyright 2002 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  * Copyright 2005 Guillaume Melquiond
  *
  * Distributed under the Boost Software License, Version 1.0.
@@ -21,6 +21,8 @@
 #  include <boost/numeric/interval/detail/c99_rounding_control.hpp>
 #elif defined(__i386__) || defined(_M_IX86) || defined(__BORLANDC__) || defined(_M_X64)
 #  include <boost/numeric/interval/detail/x86_rounding_control.hpp>
+#elif defined(__i386) && defined(__SUNPRO_CC)
+#  include <boost/numeric/interval/detail/x86_rounding_control.hpp>
 #elif defined(powerpc) || defined(__powerpc__) || defined(__ppc__)
 #  include <boost/numeric/interval/detail/ppc_rounding_control.hpp>
 #elif defined(sparc) || defined(__sparc__)
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/interval.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/interval.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/interval.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/interval.hpp
index 0b2d0eec6ea..e89af484fb4 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/interval.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/interval.hpp
@@ -1,6 +1,6 @@
 /* Boost interval/interval.hpp header file
  *
- * Copyright 2002-2003 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002-2003 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/io.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/io.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/io.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/io.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/limits.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/limits.hpp
similarity index 95%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/limits.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/limits.hpp
index 973681dbc56..36fd3a397bf 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/limits.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/limits.hpp
@@ -1,7 +1,7 @@
 /* Boost interval/limits.hpp template implementation file
  *
  * Copyright 2000 Jens Maurer
- * Copyright 2002-2003 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002-2003 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/policies.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/policies.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/policies.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/policies.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/rounded_arith.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/rounded_arith.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/rounded_arith.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/rounded_arith.hpp
index 2520274a6a7..4bb869122a4 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/rounded_arith.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/rounded_arith.hpp
@@ -1,6 +1,6 @@
 /* Boost interval/rounded_arith.hpp template implementation file
  *
- * Copyright 2002-2003 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002-2003 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/rounded_transc.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/rounded_transc.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/rounded_transc.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/rounded_transc.hpp
index ac4982e31ca..ef6e28b3f98 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/rounded_transc.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/rounded_transc.hpp
@@ -1,6 +1,6 @@
 /* Boost interval/rounded_transc.hpp template implementation file
  *
- * Copyright 2002-2003 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002-2003 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/rounding.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/rounding.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/rounding.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/rounding.hpp
index f69e2e4b538..bf5b3c2719d 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/rounding.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/rounding.hpp
@@ -1,6 +1,6 @@
 /* Boost interval/rounding.hpp template implementation file
  *
- * Copyright 2002-2003 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002-2003 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/transc.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/transc.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/transc.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/transc.hpp
index 8d7a7a1acdd..b9b7e60c4e7 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/transc.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/transc.hpp
@@ -1,7 +1,7 @@
 /* Boost interval/transc.hpp template implementation file
  *
  * Copyright 2000 Jens Maurer
- * Copyright 2002 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/interval/utility.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/interval/utility.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/numeric/interval/utility.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/interval/utility.hpp
index c89cdb1e932..97c6bad81c5 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/interval/utility.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/interval/utility.hpp
@@ -1,7 +1,7 @@
 /* Boost interval/utility.hpp template implementation file
  *
  * Copyright 2000 Jens Maurer
- * Copyright 2002-2003 Herv� Br�nnimann, Guillaume Melquiond, Sylvain Pion
+ * Copyright 2002-2003 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
  *
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or
@@ -248,7 +248,6 @@ bisect(const interval<T, Policies>& x)
 template<class T, class Policies> inline
 T norm(const interval<T, Policies>& x)
 {
-  typedef interval<T, Policies> I;
   if (interval_lib::detail::test_input(x)) {
     typedef typename Policies::checking checking;
     return checking::nan();
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/algebra_dispatcher.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/algebra_dispatcher.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/algebra_dispatcher.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/algebra_dispatcher.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/array_algebra.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/array_algebra.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/array_algebra.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/array_algebra.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/default_operations.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/default_operations.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/default_operations.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/default_operations.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/detail/extract_value_type.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/detail/extract_value_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/detail/extract_value_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/detail/extract_value_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/detail/for_each.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/detail/for_each.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/detail/for_each.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/detail/for_each.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/detail/macros.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/detail/macros.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/detail/macros.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/detail/macros.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/detail/norm_inf.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/detail/norm_inf.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/detail/norm_inf.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/detail/norm_inf.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/fusion_algebra.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/fusion_algebra.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/fusion_algebra.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/fusion_algebra.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/fusion_algebra_dispatcher.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/fusion_algebra_dispatcher.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/fusion_algebra_dispatcher.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/fusion_algebra_dispatcher.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/multi_array_algebra.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/multi_array_algebra.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/multi_array_algebra.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/multi_array_algebra.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/norm_result_type.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/norm_result_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/norm_result_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/norm_result_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/operations_dispatcher.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/operations_dispatcher.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/operations_dispatcher.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/operations_dispatcher.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/range_algebra.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/range_algebra.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/range_algebra.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/range_algebra.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/vector_space_algebra.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/vector_space_algebra.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/algebra/vector_space_algebra.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/algebra/vector_space_algebra.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/config.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/config.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/config.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/config.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/blaze/blaze_algebra_dispatcher.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/blaze/blaze_algebra_dispatcher.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/blaze/blaze_algebra_dispatcher.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/blaze/blaze_algebra_dispatcher.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/blaze/blaze_resize.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/blaze/blaze_resize.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/blaze/blaze_resize.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/blaze/blaze_resize.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/compute/compute.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/compute/compute.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/compute/compute.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/compute/compute.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/compute/compute_algebra.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/compute/compute_algebra.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/compute/compute_algebra.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/compute/compute_algebra.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/compute/compute_algebra_dispatcher.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/compute/compute_algebra_dispatcher.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/compute/compute_algebra_dispatcher.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/compute/compute_algebra_dispatcher.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/compute/compute_operations.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/compute/compute_operations.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/compute/compute_operations.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/compute/compute_operations.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/compute/compute_operations_dispatcher.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/compute/compute_operations_dispatcher.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/compute/compute_operations_dispatcher.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/compute/compute_operations_dispatcher.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/compute/compute_resize.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/compute/compute_resize.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/compute/compute_resize.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/compute/compute_resize.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/eigen/eigen.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/eigen/eigen.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/eigen/eigen.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/eigen/eigen.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/eigen/eigen_algebra.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/eigen/eigen_algebra.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/eigen/eigen_algebra.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/eigen/eigen_algebra.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/eigen/eigen_algebra_dispatcher.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/eigen/eigen_algebra_dispatcher.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/eigen/eigen_algebra_dispatcher.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/eigen/eigen_algebra_dispatcher.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/eigen/eigen_resize.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/eigen/eigen_resize.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/eigen/eigen_resize.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/eigen/eigen_resize.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/gsl/gsl_wrapper.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/gsl/gsl_wrapper.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/gsl/gsl_wrapper.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/gsl/gsl_wrapper.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/mkl/mkl_operations.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/mkl/mkl_operations.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/mkl/mkl_operations.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/mkl/mkl_operations.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/mpi/mpi.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/mpi/mpi.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/mpi/mpi.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/mpi/mpi.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/mpi/mpi_nested_algebra.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/mpi/mpi_nested_algebra.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/mpi/mpi_nested_algebra.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/mpi/mpi_nested_algebra.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/mpi/mpi_state.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/mpi/mpi_state.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/mpi/mpi_state.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/mpi/mpi_state.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/mpi/mpi_vector_state.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/mpi/mpi_vector_state.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/mpi/mpi_vector_state.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/mpi/mpi_vector_state.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/mtl4/implicit_euler_mtl4.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/mtl4/implicit_euler_mtl4.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/mtl4/implicit_euler_mtl4.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/mtl4/implicit_euler_mtl4.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/mtl4/mtl4.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/mtl4/mtl4.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/mtl4/mtl4.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/mtl4/mtl4.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/mtl4/mtl4_algebra_dispatcher.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/mtl4/mtl4_algebra_dispatcher.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/mtl4/mtl4_algebra_dispatcher.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/mtl4/mtl4_algebra_dispatcher.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/mtl4/mtl4_resize.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/mtl4/mtl4_resize.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/mtl4/mtl4_resize.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/mtl4/mtl4_resize.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/nt2/nt2_algebra_dispatcher.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/nt2/nt2_algebra_dispatcher.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/nt2/nt2_algebra_dispatcher.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/nt2/nt2_algebra_dispatcher.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/nt2/nt2_copy.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/nt2/nt2_copy.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/nt2/nt2_copy.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/nt2/nt2_copy.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/nt2/nt2_norm_inf.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/nt2/nt2_norm_inf.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/nt2/nt2_norm_inf.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/nt2/nt2_norm_inf.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/nt2/nt2_resize.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/nt2/nt2_resize.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/nt2/nt2_resize.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/nt2/nt2_resize.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/openmp/openmp.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/openmp/openmp.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/openmp/openmp.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/openmp/openmp.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/openmp/openmp_nested_algebra.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/openmp/openmp_nested_algebra.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/openmp/openmp_nested_algebra.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/openmp/openmp_nested_algebra.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/openmp/openmp_range_algebra.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/openmp/openmp_range_algebra.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/openmp/openmp_range_algebra.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/openmp/openmp_range_algebra.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/openmp/openmp_state.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/openmp/openmp_state.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/openmp/openmp_state.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/openmp/openmp_state.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/thrust/thrust.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/thrust/thrust.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/thrust/thrust.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/thrust/thrust.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/thrust/thrust_algebra.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/thrust/thrust_algebra.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/thrust/thrust_algebra.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/thrust/thrust_algebra.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/thrust/thrust_algebra_dispatcher.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/thrust/thrust_algebra_dispatcher.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/thrust/thrust_algebra_dispatcher.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/thrust/thrust_algebra_dispatcher.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/thrust/thrust_operations.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/thrust/thrust_operations.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/thrust/thrust_operations.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/thrust/thrust_operations.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/thrust/thrust_operations_dispatcher.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/thrust/thrust_operations_dispatcher.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/thrust/thrust_operations_dispatcher.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/thrust/thrust_operations_dispatcher.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/thrust/thrust_resize.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/thrust/thrust_resize.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/thrust/thrust_resize.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/thrust/thrust_resize.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/vexcl/vexcl.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/vexcl/vexcl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/vexcl/vexcl.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/vexcl/vexcl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/vexcl/vexcl_abs.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/vexcl/vexcl_abs.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/vexcl/vexcl_abs.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/vexcl/vexcl_abs.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/vexcl/vexcl_algebra_dispatcher.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/vexcl/vexcl_algebra_dispatcher.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/vexcl/vexcl_algebra_dispatcher.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/vexcl/vexcl_algebra_dispatcher.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/vexcl/vexcl_copy.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/vexcl/vexcl_copy.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/vexcl/vexcl_copy.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/vexcl/vexcl_copy.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/vexcl/vexcl_norm_inf.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/vexcl/vexcl_norm_inf.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/vexcl/vexcl_norm_inf.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/vexcl/vexcl_norm_inf.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/vexcl/vexcl_resize.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/vexcl/vexcl_resize.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/vexcl/vexcl_resize.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/vexcl/vexcl_resize.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/vexcl/vexcl_same_instance.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/vexcl/vexcl_same_instance.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/vexcl/vexcl_same_instance.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/vexcl/vexcl_same_instance.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/viennacl/viennacl_operations.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/viennacl/viennacl_operations.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/viennacl/viennacl_operations.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/viennacl/viennacl_operations.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/viennacl/viennacl_resize.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/viennacl/viennacl_resize.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/external/viennacl/viennacl_resize.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/external/viennacl/viennacl_resize.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/check_adapter.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/check_adapter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/check_adapter.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/check_adapter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/detail/functors.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/detail/functors.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/detail/functors.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/detail/functors.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/detail/integrate_adaptive.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/detail/integrate_const.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/detail/integrate_const.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/detail/integrate_const.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/detail/integrate_const.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/detail/integrate_n_steps.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/detail/integrate_n_steps.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/detail/integrate_n_steps.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/detail/integrate_n_steps.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/detail/integrate_times.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/detail/integrate_times.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/detail/integrate_times.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/detail/integrate_times.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/integrate.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/integrate.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/integrate.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/integrate.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/integrate_adaptive.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/integrate_adaptive.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/integrate_adaptive.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/integrate_adaptive.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/integrate_const.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/integrate_const.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/integrate_const.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/integrate_const.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/integrate_n_steps.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/integrate_n_steps.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/integrate_n_steps.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/integrate_n_steps.hpp
index 7f3a49bddc0..5cc8aa0e7b3 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/integrate_n_steps.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/integrate_n_steps.hpp
@@ -23,6 +23,7 @@
 #include <boost/numeric/odeint/stepper/stepper_categories.hpp>
 #include <boost/numeric/odeint/integrate/null_observer.hpp>
 #include <boost/numeric/odeint/integrate/detail/integrate_n_steps.hpp>
+#include <boost/numeric/odeint/integrate/check_adapter.hpp>
 
 namespace boost {
 namespace numeric {
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/integrate_times.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/integrate_times.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/integrate_times.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/integrate_times.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/max_step_checker.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/max_step_checker.hpp
similarity index 92%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/max_step_checker.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/max_step_checker.hpp
index 6808a57bdbf..654c95bc7d6 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/max_step_checker.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/max_step_checker.hpp
@@ -69,7 +69,7 @@ public:
         if( m_steps++ >= m_max_steps )
         {
             char error_msg[200];
-            sprintf(error_msg, "Max number of iterations exceeded (%d).", m_max_steps);
+            std::sprintf(error_msg, "Max number of iterations exceeded (%d).", m_max_steps);
             BOOST_THROW_EXCEPTION( no_progress_error(error_msg) );
         }
     }
@@ -101,7 +101,7 @@ public:
         if( m_steps++ >= m_max_steps )
         {
             char error_msg[200];
-            sprintf(error_msg, "Max number of iterations exceeded (%d). A new step size was not found.", m_max_steps);
+            std::sprintf(error_msg, "Max number of iterations exceeded (%d). A new step size was not found.", m_max_steps);
             BOOST_THROW_EXCEPTION( step_adjustment_error(error_msg) );
         }
     }
@@ -111,4 +111,4 @@ public:
 } // namespace numeric
 } // namespace boost
 
-#endif
\ No newline at end of file
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/null_observer.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/null_observer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/null_observer.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/null_observer.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/observer_collection.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/observer_collection.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/integrate/observer_collection.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/integrate/observer_collection.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/adaptive_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/adaptive_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/adaptive_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/adaptive_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/adaptive_time_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/adaptive_time_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/adaptive_time_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/adaptive_time_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/const_step_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/const_step_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/const_step_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/const_step_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/const_step_time_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/const_step_time_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/const_step_time_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/const_step_time_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/detail/ode_iterator_base.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/impl/adaptive_iterator_impl.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/impl/adaptive_iterator_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/impl/adaptive_iterator_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/impl/adaptive_iterator_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/impl/const_step_iterator_impl.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/impl/const_step_iterator_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/impl/const_step_iterator_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/impl/const_step_iterator_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/impl/n_step_iterator_impl.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/impl/n_step_iterator_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/impl/n_step_iterator_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/impl/n_step_iterator_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/impl/times_iterator_impl.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/impl/times_iterator_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/impl/times_iterator_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/impl/times_iterator_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/detail/functors.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/detail/functors.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/detail/functors.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/detail/functors.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/detail/integrate_adaptive.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/detail/integrate_adaptive.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/detail/integrate_adaptive.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/detail/integrate_adaptive.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/detail/integrate_const.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/detail/integrate_const.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/detail/integrate_const.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/detail/integrate_const.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/detail/integrate_n_steps.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/detail/integrate_n_steps.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/detail/integrate_n_steps.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/detail/integrate_n_steps.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/detail/integrate_times.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/detail/integrate_times.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/detail/integrate_times.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/detail/integrate_times.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/integrate.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/integrate.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/integrate.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/integrate.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/integrate_adaptive.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/integrate_adaptive.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/integrate_adaptive.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/integrate_adaptive.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/integrate_const.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/integrate_const.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/integrate_const.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/integrate_const.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/integrate_n_steps.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/integrate_n_steps.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/integrate_n_steps.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/integrate_n_steps.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/integrate_times.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/integrate_times.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/integrate_times.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/integrate_times.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/null_observer.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/null_observer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/null_observer.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/null_observer.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/observer_collection.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/observer_collection.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/integrate/observer_collection.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/integrate/observer_collection.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/n_step_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/n_step_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/n_step_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/n_step_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/n_step_time_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/n_step_time_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/n_step_time_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/n_step_time_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/times_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/times_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/times_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/times_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/times_time_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/times_time_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/iterator/times_time_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/iterator/times_time_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/adams_bashforth.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/adams_bashforth.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/adams_bashforth.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/adams_bashforth.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/adams_bashforth_moulton.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/adams_bashforth_moulton.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/adams_bashforth_moulton.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/adams_bashforth_moulton.hpp
index 2f7cc4c6fb1..f3edce1989d 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/adams_bashforth_moulton.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/adams_bashforth_moulton.hpp
@@ -150,6 +150,12 @@ public :
     }
 
 
+    void reset(void)
+    {
+        m_adams_bashforth.reset();
+    }
+
+
 
 private:
     
@@ -175,7 +181,7 @@ private:
         {
             m_resizer.adjust_size( in , detail::bind( &stepper_type::template resize_impl< StateInOut > , detail::ref( *this ) , detail::_1 ) );        
             m_adams_bashforth.do_step( system , in , t , m_x.m_v , dt );
-            m_adams_moulton.do_step( system , in , m_x.m_v , t , out , dt , m_adams_bashforth.step_storage() );
+            m_adams_moulton.do_step( system , in , m_x.m_v , t+dt , out , dt , m_adams_bashforth.step_storage() );
         }
         else
         {
@@ -293,6 +299,11 @@ private:
      * \param dt The step size.
      */
 
+    /**
+     * \fn adams_bashforth_moulton::reset( void )
+     * \brief Resets the internal buffers of the stepper.
+     */
+
 
 } // odeint
 } // numeric
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/adams_moulton.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/adams_moulton.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/adams_moulton.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/adams_moulton.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/base/algebra_stepper_base.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/base/explicit_error_stepper_base.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/base/explicit_error_stepper_fsal_base.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/base/explicit_error_stepper_fsal_base.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/base/explicit_error_stepper_fsal_base.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/base/explicit_error_stepper_fsal_base.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/base/explicit_stepper_base.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/base/symplectic_rkn_stepper_base.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/bulirsch_stoer.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/bulirsch_stoer.hpp
similarity index 96%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/bulirsch_stoer.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/bulirsch_stoer.hpp
index 4b908333bad..02c37492b99 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/bulirsch_stoer.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/bulirsch_stoer.hpp
@@ -98,6 +98,7 @@ public:
           m_interval_sequence( m_k_max+1 ) ,
           m_coeff( m_k_max+1 ) ,
           m_cost( m_k_max+1 ) ,
+          m_facmin_table( m_k_max+1 ) ,
           m_table( m_k_max ) ,
           STEPFAC1( 0.65 ) , STEPFAC2( 0.94 ) , STEPFAC3( 0.02 ) , STEPFAC4( 4.0 ) , KFAC1( 0.8 ) , KFAC2( 0.9 )
     {
@@ -112,21 +113,14 @@ public:
             else
                 m_cost[i] = m_cost[i-1] + m_interval_sequence[i];
             m_coeff[i].resize(i);
+            m_facmin_table[i] = pow BOOST_PREVENT_MACRO_SUBSTITUTION( STEPFAC3 , static_cast< value_type >(1) / static_cast< value_type >( 2*i+1 ) );
             for( size_t k = 0 ; k < i ; ++k  )
             {
                 const value_type r = static_cast< value_type >( m_interval_sequence[i] ) / static_cast< value_type >( m_interval_sequence[k] );
                 m_coeff[i][k] = 1.0 / ( r*r - static_cast< value_type >( 1.0 ) ); // coefficients for extrapolation
             }
-
-            // crude estimate of optimal order
-
-            m_current_k_opt = 4;
-            /* no calculation because log10 might not exist for value_type!
-            const value_type logfact( -log10( max BOOST_PREVENT_MACRO_SUBSTITUTION( eps_rel , static_cast< value_type >(1.0E-12) ) ) * 0.6 + 0.5 );
-            m_current_k_opt = max BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<value_type>( 1 ) , min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<value_type>( m_k_max-1 ) , logfact ));
-            */
         }
-
+        reset();
     }
 
 
@@ -282,7 +276,7 @@ public:
                         {
                             m_current_k_opt = min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<int>(m_k_max-1) , static_cast<int>(m_current_k_opt)+1 );
                             new_h = h_opt[k];
-                            new_h *= m_cost[m_current_k_opt]/m_cost[k];
+                            new_h *= static_cast<value_type>(m_cost[m_current_k_opt])/static_cast<value_type>(m_cost[k]);
                         } else
                             new_h = h_opt[m_current_k_opt];
                         break;
@@ -344,6 +338,12 @@ public:
     {
         m_first = true;
         m_last_step_rejected = false;
+        // crude estimate of optimal order
+        m_current_k_opt = 4;
+        /* no calculation because log10 might not exist for value_type!
+        const value_type logfact( -log10( max BOOST_PREVENT_MACRO_SUBSTITUTION( eps_rel , static_cast< value_type >(1.0E-12) ) ) * 0.6 + 0.5 );
+        m_current_k_opt = max BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<value_type>( 1 ) , min BOOST_PREVENT_MACRO_SUBSTITUTION( static_cast<value_type>( m_k_max-1 ) , logfact ));
+        */
     }
 
 
@@ -417,7 +417,7 @@ private:
         BOOST_USING_STD_MAX();
         using std::pow;
         value_type expo( 1.0/(2*k+1) );
-        value_type facmin = pow BOOST_PREVENT_MACRO_SUBSTITUTION( STEPFAC3 , expo );
+        value_type facmin = m_facmin_table[k];
         value_type fac;
         if (error == 0.0)
             fac=1.0/facmin;
@@ -506,6 +506,7 @@ private:
     int_vector m_interval_sequence; // stores the successive interval counts
     value_matrix m_coeff;
     int_vector m_cost; // costs for interval count
+    value_vector m_facmin_table; // for precomputed facmin to save pow calls
 
     state_table_type m_table; // sequence of states for extrapolation
 
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/bulirsch_stoer_dense_out.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/bulirsch_stoer_dense_out.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/bulirsch_stoer_dense_out.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/bulirsch_stoer_dense_out.hpp
index d876ca3d360..6a1eed15fb2 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/bulirsch_stoer_dense_out.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/bulirsch_stoer_dense_out.hpp
@@ -110,6 +110,7 @@ public:
           m_interval_sequence( m_k_max+1 ) ,
           m_coeff( m_k_max+1 ) ,
           m_cost( m_k_max+1 ) ,
+          m_facmin_table( m_k_max+1 ) ,
           m_table( m_k_max ) ,
           m_mp_states( m_k_max+1 ) ,
           m_derivs( m_k_max+1 ) ,
@@ -125,9 +126,13 @@ public:
             m_interval_sequence[i] = 2 + 4*i;  // 2 6 10 14 ...
             m_derivs[i].resize( m_interval_sequence[i] );
             if( i == 0 )
+            {
                 m_cost[i] = m_interval_sequence[i];
-            else
+            } else
+            {
                 m_cost[i] = m_cost[i-1] + m_interval_sequence[i];
+            }
+            m_facmin_table[i] = pow BOOST_PREVENT_MACRO_SUBSTITUTION( STEPFAC3 , static_cast< value_type >(1) / static_cast< value_type >( 2*i+1 ) );
             m_coeff[i].resize(i);
             for( size_t k = 0 ; k < i ; ++k  )
             {
@@ -429,7 +434,7 @@ private:
         using std::pow;
 
         value_type expo = static_cast<value_type>(1)/(m_interval_sequence[k-1]);
-        value_type facmin = pow BOOST_PREVENT_MACRO_SUBSTITUTION( STEPFAC3 , expo );
+        value_type facmin = m_facmin_table[k];
         value_type fac;
         if (error == 0.0)
             fac = static_cast<value_type>(1)/facmin;
@@ -692,6 +697,7 @@ private:
     int_vector m_interval_sequence; // stores the successive interval counts
     value_matrix m_coeff;
     int_vector m_cost; // costs for interval count
+    value_vector m_facmin_table; // for precomputed facmin to save pow calls
 
     state_vector_type m_table; // sequence of states for extrapolation
 
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/controlled_runge_kutta.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/controlled_runge_kutta.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/controlled_runge_kutta.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/controlled_runge_kutta.hpp
index 8ae627fe1cd..aac2b02dcac 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/controlled_runge_kutta.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/controlled_runge_kutta.hpp
@@ -143,7 +143,7 @@ public:
             error = max BOOST_PREVENT_MACRO_SUBSTITUTION (
                     static_cast<value_type>( pow( static_cast<value_type>(5.0) , -static_cast<value_type>(stepper_order) ) ) ,
                     error);
-            time_type dt_old = dt;
+            // time_type dt_old = dt;   unused variable warning 
             //error too small - increase dt and keep the evolution and limit scaling factor to 5.0
             dt *= static_cast<value_type>(9)/static_cast<value_type>(10) *
                   pow(error, static_cast<value_type>(-1) / stepper_order);
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/controlled_step_result.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/controlled_step_result.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/controlled_step_result.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/controlled_step_result.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/dense_output_runge_kutta.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/detail/adams_bashforth_call_algebra.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/detail/adams_bashforth_call_algebra.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/detail/adams_bashforth_call_algebra.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/detail/adams_bashforth_call_algebra.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/detail/adams_bashforth_coefficients.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/detail/adams_bashforth_coefficients.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/detail/adams_bashforth_coefficients.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/detail/adams_bashforth_coefficients.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/detail/adams_moulton_call_algebra.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/detail/adams_moulton_call_algebra.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/detail/adams_moulton_call_algebra.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/detail/adams_moulton_call_algebra.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/detail/adams_moulton_coefficients.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/detail/adams_moulton_coefficients.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/detail/adams_moulton_coefficients.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/detail/adams_moulton_coefficients.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/detail/generic_rk_algorithm.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/detail/generic_rk_algorithm.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/detail/generic_rk_algorithm.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/detail/generic_rk_algorithm.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/detail/generic_rk_call_algebra.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/detail/generic_rk_call_algebra.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/detail/generic_rk_call_algebra.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/detail/generic_rk_call_algebra.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/detail/generic_rk_operations.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/detail/generic_rk_operations.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/detail/generic_rk_operations.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/detail/generic_rk_operations.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/detail/rotating_buffer.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/detail/rotating_buffer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/detail/rotating_buffer.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/detail/rotating_buffer.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/euler.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/euler.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/euler.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/euler.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/explicit_error_generic_rk.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/explicit_generic_rk.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/explicit_generic_rk.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/explicit_generic_rk.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/explicit_generic_rk.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/extrapolation_stepper.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/extrapolation_stepper.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/extrapolation_stepper.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/extrapolation_stepper.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/generation.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/generation.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/generation.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/generation.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/generation/generation_controlled_runge_kutta.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/generation/generation_controlled_runge_kutta.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/generation/generation_controlled_runge_kutta.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/generation/generation_controlled_runge_kutta.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/generation/generation_dense_output_runge_kutta.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/generation/generation_dense_output_runge_kutta.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/generation/generation_dense_output_runge_kutta.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/generation/generation_dense_output_runge_kutta.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/generation/generation_rosenbrock4.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/generation/generation_rosenbrock4.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/generation/generation_rosenbrock4.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/generation/generation_rosenbrock4.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54_classic.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54_classic.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54_classic.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/generation/generation_runge_kutta_cash_karp54_classic.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/generation/generation_runge_kutta_dopri5.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/generation/generation_runge_kutta_dopri5.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/generation/generation_runge_kutta_dopri5.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/generation/generation_runge_kutta_dopri5.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/generation/generation_runge_kutta_fehlberg78.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/generation/generation_runge_kutta_fehlberg78.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/generation/generation_runge_kutta_fehlberg78.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/generation/generation_runge_kutta_fehlberg78.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/generation/make_controlled.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/generation/make_controlled.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/generation/make_controlled.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/generation/make_controlled.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/generation/make_dense_output.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/generation/make_dense_output.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/generation/make_dense_output.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/generation/make_dense_output.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/implicit_euler.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/implicit_euler.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/implicit_euler.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/implicit_euler.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/modified_midpoint.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/modified_midpoint.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/modified_midpoint.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/modified_midpoint.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/rosenbrock4.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/rosenbrock4.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/rosenbrock4.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/rosenbrock4.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/rosenbrock4_controller.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/rosenbrock4_controller.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/rosenbrock4_controller.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/rosenbrock4_controller.hpp
index 0e5edd32c0b..61d6e511917 100644
--- a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/rosenbrock4_controller.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/rosenbrock4_controller.hpp
@@ -163,6 +163,8 @@ public:
             if( m_max_dt != static_cast<time_type>(0) )
             {
                 dt = detail::min_abs(m_max_dt, dt_new);
+            } else {
+                dt = dt_new;
             }
             m_last_rejected = false;
             return success;
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/rosenbrock4_dense_output.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/rosenbrock4_dense_output.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/rosenbrock4_dense_output.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/rosenbrock4_dense_output.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/runge_kutta4.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/runge_kutta4.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/runge_kutta4.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/runge_kutta4.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/runge_kutta4_classic.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/runge_kutta4_classic.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/runge_kutta4_classic.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/runge_kutta4_classic.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/runge_kutta_cash_karp54.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/runge_kutta_cash_karp54.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/runge_kutta_cash_karp54.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/runge_kutta_cash_karp54.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/runge_kutta_cash_karp54_classic.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/runge_kutta_cash_karp54_classic.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/runge_kutta_cash_karp54_classic.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/runge_kutta_cash_karp54_classic.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/runge_kutta_dopri5.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/runge_kutta_fehlberg78.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/runge_kutta_fehlberg78.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/runge_kutta_fehlberg78.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/runge_kutta_fehlberg78.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/stepper_categories.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/stepper_categories.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/stepper_categories.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/stepper_categories.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/symplectic_euler.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/symplectic_euler.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/symplectic_euler.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/symplectic_euler.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_m4_mclachlan.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_m4_mclachlan.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_m4_mclachlan.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_m4_mclachlan.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_mclachlan.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_mclachlan.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_mclachlan.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/symplectic_rkn_sb3a_mclachlan.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/velocity_verlet.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/velocity_verlet.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/stepper/velocity_verlet.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/stepper/velocity_verlet.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/bind.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/bind.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/bind.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/bind.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/copy.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/copy.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/copy.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/copy.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/detail/is_range.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/detail/is_range.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/detail/is_range.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/detail/is_range.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/detail/less_with_sign.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/detail/less_with_sign.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/detail/less_with_sign.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/detail/less_with_sign.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/is_pair.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/is_pair.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/is_pair.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/is_pair.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/is_resizeable.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/is_resizeable.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/is_resizeable.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/is_resizeable.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/multi_array_adaption.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/multi_array_adaption.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/multi_array_adaption.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/multi_array_adaption.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/n_ary_helper.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/n_ary_helper.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/n_ary_helper.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/n_ary_helper.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/odeint_error.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/odeint_error.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/odeint_error.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/odeint_error.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/resize.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/resize.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/resize.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/resize.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/resizer.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/resizer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/resizer.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/resizer.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/same_instance.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/same_instance.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/same_instance.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/same_instance.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/same_size.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/same_size.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/same_size.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/same_size.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/split.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/split.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/split.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/split.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/split_adaptor.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/split_adaptor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/split_adaptor.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/split_adaptor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/state_wrapper.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/state_wrapper.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/state_wrapper.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/state_wrapper.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/stepper_traits.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/stepper_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/stepper_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/stepper_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/ublas_matrix_expression.patch b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/ublas_matrix_expression.patch
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/ublas_matrix_expression.patch
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/ublas_matrix_expression.patch
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/ublas_wrapper.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/ublas_wrapper.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/ublas_wrapper.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/ublas_wrapper.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/unit_helper.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/unit_helper.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/unit_helper.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/unit_helper.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/unwrap_reference.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/unwrap_reference.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/util/unwrap_reference.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/util/unwrap_reference.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/odeint/version.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/odeint/version.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/odeint/version.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/odeint/version.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/assignment.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/assignment.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/assignment.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/assignment.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/banded.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/banded.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/banded.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/banded.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/blas.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/blas.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/blas.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/blas.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/concepts.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/concepts.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/concepts.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/concepts.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/config.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/config.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/config.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/config.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/definitions.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/definitions.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/definitions.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/definitions.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/documentation.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/documentation.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/documentation.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/documentation.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/duff.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/duff.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/duff.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/duff.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/iterator.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/matrix_assign.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/matrix_assign.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/matrix_assign.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/matrix_assign.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/raw.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/raw.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/raw.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/raw.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/returntype_deduction.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/returntype_deduction.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/returntype_deduction.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/returntype_deduction.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/temporary.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/temporary.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/temporary.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/temporary.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/vector_assign.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/vector_assign.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/detail/vector_assign.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/detail/vector_assign.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/doxydoc.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/doxydoc.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/doxydoc.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/doxydoc.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/exception.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/exception.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/exception.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/exception.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/experimental/sparse_view.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/experimental/sparse_view.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/experimental/sparse_view.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/experimental/sparse_view.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/expression_types.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/expression_types.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/expression_types.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/expression_types.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/functional.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/functional.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/functional.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/functional.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/fwd.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/hermitian.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/hermitian.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/hermitian.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/hermitian.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/io.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/io.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/io.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/io.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/lu.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/lu.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/lu.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/lu.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/matrix.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/matrix.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/matrix.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/matrix.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/matrix_expression.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/matrix_expression.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/matrix_expression.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/matrix_expression.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/matrix_proxy.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/matrix_proxy.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/matrix_proxy.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/matrix_proxy.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/matrix_sparse.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/matrix_sparse.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/matrix_sparse.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/matrix_sparse.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/matrix_vector.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/matrix_vector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/matrix_vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/matrix_vector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/operation.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/operation.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/operation.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/operation.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/operation/begin.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/operation/begin.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/operation/begin.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/operation/begin.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/operation/c_array.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/operation/c_array.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/operation/c_array.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/operation/c_array.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/operation/end.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/operation/end.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/operation/end.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/operation/end.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/operation/num_columns.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/operation/num_columns.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/operation/num_columns.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/operation/num_columns.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/operation/num_rows.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/operation/num_rows.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/operation/num_rows.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/operation/num_rows.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/operation/size.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/operation/size.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/operation/size.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/operation/size.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/operation_blocked.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/operation_blocked.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/operation_blocked.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/operation_blocked.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/operation_sparse.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/operation_sparse.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/operation_sparse.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/operation_sparse.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/operations.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/operations.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/operations.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/operations.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/storage.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/storage.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/storage.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/storage.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/storage_sparse.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/storage_sparse.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/storage_sparse.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/storage_sparse.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/symmetric.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/symmetric.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/symmetric.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/symmetric.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/tags.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/tags.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/tags.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/tags.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/traits.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/traits/c_array.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/traits/c_array.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/traits/c_array.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/traits/c_array.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/traits/const_iterator_type.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/traits/const_iterator_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/traits/const_iterator_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/traits/const_iterator_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/traits/iterator_type.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/traits/iterator_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/traits/iterator_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/traits/iterator_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/triangular.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/triangular.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/triangular.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/triangular.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/vector.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/vector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/vector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/vector_expression.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/vector_expression.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/vector_expression.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/vector_expression.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/vector_of_vector.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/vector_of_vector.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/vector_of_vector.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/vector_of_vector.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/vector_proxy.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/vector_proxy.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/vector_proxy.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/vector_proxy.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/numeric/ublas/vector_sparse.hpp b/contrib/libboost/boost_1_65_0/boost/numeric/ublas/vector_sparse.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/numeric/ublas/vector_sparse.hpp
rename to contrib/libboost/boost_1_65_0/boost/numeric/ublas/vector_sparse.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/operators.hpp b/contrib/libboost/boost_1_65_0/boost/operators.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/operators.hpp
rename to contrib/libboost/boost_1_65_0/boost/operators.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/operators_v1.hpp b/contrib/libboost/boost_1_65_0/boost/operators_v1.hpp
new file mode 100644
index 00000000000..e1c53e87034
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/operators_v1.hpp
@@ -0,0 +1,951 @@
+//  Boost operators.hpp header file  ----------------------------------------//
+
+//  (C) Copyright David Abrahams, Jeremy Siek, Daryle Walker 1999-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/utility/operators.htm for documentation.
+
+//  Revision History
+//  22 Feb 16 Preserve old work-arounds. (Daniel Frey)
+//  16 Dec 10 Limit warning suppression for 4284 to older versions of VC++
+//            (Matthew Bradbury, fixes #4432)
+//  07 Aug 08 Added "euclidean" spelling. (Daniel Frey)
+//  03 Apr 08 Make sure "convertible to bool" is sufficient
+//            for T::operator<, etc. (Daniel Frey)
+//  24 May 07 Changed empty_base to depend on T, see
+//            http://svn.boost.org/trac/boost/ticket/979
+//  21 Oct 02 Modified implementation of operators to allow compilers with a
+//            correct named return value optimization (NRVO) to produce optimal
+//            code.  (Daniel Frey)
+//  02 Dec 01 Bug fixed in random_access_iteratable.  (Helmut Zeisel)
+//  28 Sep 01 Factored out iterator operator groups.  (Daryle Walker)
+//  27 Aug 01 'left' form for non commutative operators added;
+//            additional classes for groups of related operators added;
+//            workaround for empty base class optimization
+//            bug of GCC 3.0 (Helmut Zeisel)
+//  25 Jun 01 output_iterator_helper changes: removed default template 
+//            parameters, added support for self-proxying, additional 
+//            documentation and tests (Aleksey Gurtovoy)
+//  29 May 01 Added operator classes for << and >>.  Added input and output
+//            iterator helper classes.  Added classes to connect equality and
+//            relational operators.  Added classes for groups of related
+//            operators.  Reimplemented example operator and iterator helper
+//            classes in terms of the new groups.  (Daryle Walker, with help
+//            from Alexy Gurtovoy)
+//  11 Feb 01 Fixed bugs in the iterator helpers which prevented explicitly
+//            supplied arguments from actually being used (Dave Abrahams)
+//  04 Jul 00 Fixed NO_OPERATORS_IN_NAMESPACE bugs, major cleanup and
+//            refactoring of compiler workarounds, additional documentation
+//            (Alexy Gurtovoy and Mark Rodgers with some help and prompting from
+//            Dave Abrahams) 
+//  28 Jun 00 General cleanup and integration of bugfixes from Mark Rodgers and
+//            Jeremy Siek (Dave Abrahams)
+//  20 Jun 00 Changes to accommodate Borland C++Builder 4 and Borland C++ 5.5
+//            (Mark Rodgers)
+//  20 Jun 00 Minor fixes to the prior revision (Aleksey Gurtovoy)
+//  10 Jun 00 Support for the base class chaining technique was added
+//            (Aleksey Gurtovoy). See documentation and the comments below 
+//            for the details. 
+//  12 Dec 99 Initial version with iterator operators (Jeremy Siek)
+//  18 Nov 99 Change name "divideable" to "dividable", remove unnecessary
+//            specializations of dividable, subtractable, modable (Ed Brey) 
+//  17 Nov 99 Add comments (Beman Dawes)
+//            Remove unnecessary specialization of operators<> (Ed Brey)
+//  15 Nov 99 Fix less_than_comparable<T,U> second operand type for first two
+//            operators.(Beman Dawes)
+//  12 Nov 99 Add operators templates (Ed Brey)
+//  11 Nov 99 Add single template parameter version for compilers without
+//            partial specialization (Beman Dawes)
+//  10 Nov 99 Initial version
+
+// 10 Jun 00:
+// An additional optional template parameter was added to most of 
+// operator templates to support the base class chaining technique (see 
+// documentation for the details). Unfortunately, a straightforward
+// implementation of this change would have broken compatibility with the
+// previous version of the library by making it impossible to use the same
+// template name (e.g. 'addable') for both the 1- and 2-argument versions of
+// an operator template. This implementation solves the backward-compatibility
+// issue at the cost of some simplicity.
+//
+// One of the complications is an existence of special auxiliary class template
+// 'is_chained_base<>' (see 'detail' namespace below), which is used
+// to determine whether its template parameter is a library's operator template
+// or not. You have to specialize 'is_chained_base<>' for each new 
+// operator template you add to the library.
+//
+// However, most of the non-trivial implementation details are hidden behind 
+// several local macros defined below, and as soon as you understand them,
+// you understand the whole library implementation. 
+
+#ifndef BOOST_OPERATORS_V1_HPP
+#define BOOST_OPERATORS_V1_HPP
+
+#include <cstddef>
+#include <iterator>
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#if defined(__sgi) && !defined(__GNUC__)
+#   pragma set woff 1234
+#endif
+
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1600)
+#   pragma warning( disable : 4284 ) // complaint about return type of 
+#endif                               // operator-> not begin a UDT
+
+namespace boost {
+namespace detail {
+
+template <typename T> class empty_base {};
+
+} // namespace detail
+} // namespace boost
+
+// In this section we supply the xxxx1 and xxxx2 forms of the operator
+// templates, which are explicitly targeted at the 1-type-argument and
+// 2-type-argument operator forms, respectively. Some compilers get confused
+// when inline friend functions are overloaded in namespaces other than the
+// global namespace. When BOOST_NO_OPERATORS_IN_NAMESPACE is defined, all of
+// these templates must go in the global namespace.
+
+#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
+namespace boost
+{
+#endif
+
+//  Basic operator classes (contributed by Dave Abrahams) ------------------//
+
+//  Note that friend functions defined in a class are implicitly inline.
+//  See the C++ std, 11.4 [class.friend] paragraph 5
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct less_than_comparable2 : B
+{
+     friend bool operator<=(const T& x, const U& y) { return !static_cast<bool>(x > y); }
+     friend bool operator>=(const T& x, const U& y) { return !static_cast<bool>(x < y); }
+     friend bool operator>(const U& x, const T& y)  { return y < x; }
+     friend bool operator<(const U& x, const T& y)  { return y > x; }
+     friend bool operator<=(const U& x, const T& y) { return !static_cast<bool>(y < x); }
+     friend bool operator>=(const U& x, const T& y) { return !static_cast<bool>(y > x); }
+};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct less_than_comparable1 : B
+{
+     friend bool operator>(const T& x, const T& y)  { return y < x; }
+     friend bool operator<=(const T& x, const T& y) { return !static_cast<bool>(y < x); }
+     friend bool operator>=(const T& x, const T& y) { return !static_cast<bool>(x < y); }
+};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct equality_comparable2 : B
+{
+     friend bool operator==(const U& y, const T& x) { return x == y; }
+     friend bool operator!=(const U& y, const T& x) { return !static_cast<bool>(x == y); }
+     friend bool operator!=(const T& y, const U& x) { return !static_cast<bool>(y == x); }
+};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct equality_comparable1 : B
+{
+     friend bool operator!=(const T& x, const T& y) { return !static_cast<bool>(x == y); }
+};
+
+// A macro which produces "name_2left" from "name".
+#define BOOST_OPERATOR2_LEFT(name) name##2##_##left
+
+//  NRVO-friendly implementation (contributed by Daniel Frey) ---------------//
+
+#if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
+
+// This is the optimal implementation for ISO/ANSI C++,
+// but it requires the compiler to implement the NRVO.
+// If the compiler has no NRVO, this is the best symmetric
+// implementation available.
+
+#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP )                         \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >        \
+struct NAME##2 : B                                                            \
+{                                                                             \
+  friend T operator OP( const T& lhs, const U& rhs )                          \
+    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
+  friend T operator OP( const U& lhs, const T& rhs )                          \
+    { T nrv( rhs ); nrv OP##= lhs; return nrv; }                              \
+};                                                                            \
+                                                                              \
+template <class T, class B = ::boost::detail::empty_base<T> >                 \
+struct NAME##1 : B                                                            \
+{                                                                             \
+  friend T operator OP( const T& lhs, const T& rhs )                          \
+    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
+};
+
+#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )               \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
+struct NAME##2 : B                                                      \
+{                                                                       \
+  friend T operator OP( const T& lhs, const U& rhs )                    \
+    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                        \
+};                                                                      \
+                                                                        \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
+struct BOOST_OPERATOR2_LEFT(NAME) : B                                   \
+{                                                                       \
+  friend T operator OP( const U& lhs, const T& rhs )                    \
+    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                        \
+};                                                                      \
+                                                                        \
+template <class T, class B = ::boost::detail::empty_base<T> >           \
+struct NAME##1 : B                                                      \
+{                                                                       \
+  friend T operator OP( const T& lhs, const T& rhs )                    \
+    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                        \
+};
+
+#else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
+
+// For compilers without NRVO the following code is optimal, but not
+// symmetric!  Note that the implementation of
+// BOOST_OPERATOR2_LEFT(NAME) only looks cool, but doesn't provide
+// optimization opportunities to the compiler :)
+
+#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP )                   \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
+struct NAME##2 : B                                                      \
+{                                                                       \
+  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
+  friend T operator OP( const U& lhs, T rhs ) { return rhs OP##= lhs; } \
+};                                                                      \
+                                                                        \
+template <class T, class B = ::boost::detail::empty_base<T> >           \
+struct NAME##1 : B                                                      \
+{                                                                       \
+  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
+};
+
+#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )               \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
+struct NAME##2 : B                                                      \
+{                                                                       \
+  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
+};                                                                      \
+                                                                        \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >  \
+struct BOOST_OPERATOR2_LEFT(NAME) : B                                   \
+{                                                                       \
+  friend T operator OP( const U& lhs, const T& rhs )                    \
+    { return T( lhs ) OP##= rhs; }                                      \
+};                                                                      \
+                                                                        \
+template <class T, class B = ::boost::detail::empty_base<T> >           \
+struct NAME##1 : B                                                      \
+{                                                                       \
+  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
+};
+
+#endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
+
+BOOST_BINARY_OPERATOR_COMMUTATIVE( multipliable, * )
+BOOST_BINARY_OPERATOR_COMMUTATIVE( addable, + )
+BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( subtractable, - )
+BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( dividable, / )
+BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( modable, % )
+BOOST_BINARY_OPERATOR_COMMUTATIVE( xorable, ^ )
+BOOST_BINARY_OPERATOR_COMMUTATIVE( andable, & )
+BOOST_BINARY_OPERATOR_COMMUTATIVE( orable, | )
+
+#undef BOOST_BINARY_OPERATOR_COMMUTATIVE
+#undef BOOST_BINARY_OPERATOR_NON_COMMUTATIVE
+#undef BOOST_OPERATOR2_LEFT
+
+//  incrementable and decrementable contributed by Jeremy Siek
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct incrementable : B
+{
+  friend T operator++(T& x, int)
+  {
+    incrementable_type nrv(x);
+    ++x;
+    return nrv;
+  }
+private: // The use of this typedef works around a Borland bug
+  typedef T incrementable_type;
+};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct decrementable : B
+{
+  friend T operator--(T& x, int)
+  {
+    decrementable_type nrv(x);
+    --x;
+    return nrv;
+  }
+private: // The use of this typedef works around a Borland bug
+  typedef T decrementable_type;
+};
+
+//  Iterator operator classes (contributed by Jeremy Siek) ------------------//
+
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
+struct dereferenceable : B
+{
+  P operator->() const
+  { 
+    return &*static_cast<const T&>(*this); 
+  }
+};
+
+template <class T, class I, class R, class B = ::boost::detail::empty_base<T> >
+struct indexable : B
+{
+  R operator[](I n) const
+  {
+    return *(static_cast<const T&>(*this) + n);
+  }
+};
+
+//  More operator classes (contributed by Daryle Walker) --------------------//
+//  (NRVO-friendly implementation contributed by Daniel Frey) ---------------//
+
+#if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
+
+#define BOOST_BINARY_OPERATOR( NAME, OP )                                     \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >        \
+struct NAME##2 : B                                                            \
+{                                                                             \
+  friend T operator OP( const T& lhs, const U& rhs )                          \
+    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
+};                                                                            \
+                                                                              \
+template <class T, class B = ::boost::detail::empty_base<T> >                 \
+struct NAME##1 : B                                                            \
+{                                                                             \
+  friend T operator OP( const T& lhs, const T& rhs )                          \
+    { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
+};
+
+#else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
+
+#define BOOST_BINARY_OPERATOR( NAME, OP )                                     \
+template <class T, class U, class B = ::boost::detail::empty_base<T> >        \
+struct NAME##2 : B                                                            \
+{                                                                             \
+  friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; }       \
+};                                                                            \
+                                                                              \
+template <class T, class B = ::boost::detail::empty_base<T> >                 \
+struct NAME##1 : B                                                            \
+{                                                                             \
+  friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; }       \
+};
+
+#endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
+
+BOOST_BINARY_OPERATOR( left_shiftable, << )
+BOOST_BINARY_OPERATOR( right_shiftable, >> )
+
+#undef BOOST_BINARY_OPERATOR
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct equivalent2 : B
+{
+  friend bool operator==(const T& x, const U& y)
+  {
+    return !static_cast<bool>(x < y) && !static_cast<bool>(x > y);
+  }
+};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct equivalent1 : B
+{
+  friend bool operator==(const T&x, const T&y)
+  {
+    return !static_cast<bool>(x < y) && !static_cast<bool>(y < x);
+  }
+};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct partially_ordered2 : B
+{
+  friend bool operator<=(const T& x, const U& y)
+    { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
+  friend bool operator>=(const T& x, const U& y)
+    { return static_cast<bool>(x > y) || static_cast<bool>(x == y); }
+  friend bool operator>(const U& x, const T& y)
+    { return y < x; }
+  friend bool operator<(const U& x, const T& y)
+    { return y > x; }
+  friend bool operator<=(const U& x, const T& y)
+    { return static_cast<bool>(y > x) || static_cast<bool>(y == x); }
+  friend bool operator>=(const U& x, const T& y)
+    { return static_cast<bool>(y < x) || static_cast<bool>(y == x); }
+};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct partially_ordered1 : B
+{
+  friend bool operator>(const T& x, const T& y)
+    { return y < x; }
+  friend bool operator<=(const T& x, const T& y)
+    { return static_cast<bool>(x < y) || static_cast<bool>(x == y); }
+  friend bool operator>=(const T& x, const T& y)
+    { return static_cast<bool>(y < x) || static_cast<bool>(x == y); }
+};
+
+//  Combined operator classes (contributed by Daryle Walker) ----------------//
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct totally_ordered2
+    : less_than_comparable2<T, U
+    , equality_comparable2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct totally_ordered1
+    : less_than_comparable1<T
+    , equality_comparable1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct additive2
+    : addable2<T, U
+    , subtractable2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct additive1
+    : addable1<T
+    , subtractable1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct multiplicative2
+    : multipliable2<T, U
+    , dividable2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct multiplicative1
+    : multipliable1<T
+    , dividable1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct integer_multiplicative2
+    : multiplicative2<T, U
+    , modable2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct integer_multiplicative1
+    : multiplicative1<T
+    , modable1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct arithmetic2
+    : additive2<T, U
+    , multiplicative2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct arithmetic1
+    : additive1<T
+    , multiplicative1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct integer_arithmetic2
+    : additive2<T, U
+    , integer_multiplicative2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct integer_arithmetic1
+    : additive1<T
+    , integer_multiplicative1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct bitwise2
+    : xorable2<T, U
+    , andable2<T, U
+    , orable2<T, U, B
+      > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct bitwise1
+    : xorable1<T
+    , andable1<T
+    , orable1<T, B
+      > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct unit_steppable
+    : incrementable<T
+    , decrementable<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct shiftable2
+    : left_shiftable2<T, U
+    , right_shiftable2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct shiftable1
+    : left_shiftable1<T
+    , right_shiftable1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct ring_operators2
+    : additive2<T, U
+    , subtractable2_left<T, U
+    , multipliable2<T, U, B
+      > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct ring_operators1
+    : additive1<T
+    , multipliable1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct ordered_ring_operators2
+    : ring_operators2<T, U
+    , totally_ordered2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct ordered_ring_operators1
+    : ring_operators1<T
+    , totally_ordered1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct field_operators2
+    : ring_operators2<T, U
+    , dividable2<T, U
+    , dividable2_left<T, U, B
+      > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct field_operators1
+    : ring_operators1<T
+    , dividable1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct ordered_field_operators2
+    : field_operators2<T, U
+    , totally_ordered2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct ordered_field_operators1
+    : field_operators1<T
+    , totally_ordered1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct euclidian_ring_operators2
+    : ring_operators2<T, U
+    , dividable2<T, U
+    , dividable2_left<T, U
+    , modable2<T, U
+    , modable2_left<T, U, B
+      > > > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct euclidian_ring_operators1
+    : ring_operators1<T
+    , dividable1<T
+    , modable1<T, B
+      > > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct ordered_euclidian_ring_operators2
+    : totally_ordered2<T, U
+    , euclidian_ring_operators2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct ordered_euclidian_ring_operators1
+    : totally_ordered1<T
+    , euclidian_ring_operators1<T, B
+      > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct euclidean_ring_operators2
+    : ring_operators2<T, U
+    , dividable2<T, U
+    , dividable2_left<T, U
+    , modable2<T, U
+    , modable2_left<T, U, B
+      > > > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct euclidean_ring_operators1
+    : ring_operators1<T
+    , dividable1<T
+    , modable1<T, B
+      > > > {};
+
+template <class T, class U, class B = ::boost::detail::empty_base<T> >
+struct ordered_euclidean_ring_operators2
+    : totally_ordered2<T, U
+    , euclidean_ring_operators2<T, U, B
+      > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct ordered_euclidean_ring_operators1
+    : totally_ordered1<T
+    , euclidean_ring_operators1<T, B
+      > > {};
+
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
+struct input_iteratable
+    : equality_comparable1<T
+    , incrementable<T
+    , dereferenceable<T, P, B
+      > > > {};
+
+template <class T, class B = ::boost::detail::empty_base<T> >
+struct output_iteratable
+    : incrementable<T, B
+      > {};
+
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
+struct forward_iteratable
+    : input_iteratable<T, P, B
+      > {};
+
+template <class T, class P, class B = ::boost::detail::empty_base<T> >
+struct bidirectional_iteratable
+    : forward_iteratable<T, P
+    , decrementable<T, B
+      > > {};
+
+//  To avoid repeated derivation from equality_comparable,
+//  which is an indirect base class of bidirectional_iterable,
+//  random_access_iteratable must not be derived from totally_ordered1
+//  but from less_than_comparable1 only. (Helmut Zeisel, 02-Dec-2001)
+template <class T, class P, class D, class R, class B = ::boost::detail::empty_base<T> >
+struct random_access_iteratable
+    : bidirectional_iteratable<T, P
+    , less_than_comparable1<T
+    , additive2<T, D
+    , indexable<T, D, R, B
+      > > > > {};
+
+#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
+} // namespace boost
+#endif // BOOST_NO_OPERATORS_IN_NAMESPACE
+
+
+// BOOST_IMPORT_TEMPLATE1 .. BOOST_IMPORT_TEMPLATE4 -
+//
+// When BOOST_NO_OPERATORS_IN_NAMESPACE is defined we need a way to import an
+// operator template into the boost namespace. BOOST_IMPORT_TEMPLATE1 is used
+// for one-argument forms of operator templates; BOOST_IMPORT_TEMPLATE2 for
+// two-argument forms. Note that these macros expect to be invoked from within
+// boost.
+
+#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
+
+  // The template is already in boost so we have nothing to do.
+# define BOOST_IMPORT_TEMPLATE4(template_name)
+# define BOOST_IMPORT_TEMPLATE3(template_name)
+# define BOOST_IMPORT_TEMPLATE2(template_name)
+# define BOOST_IMPORT_TEMPLATE1(template_name)
+
+#else // BOOST_NO_OPERATORS_IN_NAMESPACE
+
+#  ifndef BOOST_NO_USING_TEMPLATE
+
+     // Bring the names in with a using-declaration
+     // to avoid stressing the compiler.
+#    define BOOST_IMPORT_TEMPLATE4(template_name) using ::template_name;
+#    define BOOST_IMPORT_TEMPLATE3(template_name) using ::template_name;
+#    define BOOST_IMPORT_TEMPLATE2(template_name) using ::template_name;
+#    define BOOST_IMPORT_TEMPLATE1(template_name) using ::template_name;
+
+#  else
+
+     // Otherwise, because a Borland C++ 5.5 bug prevents a using declaration
+     // from working, we are forced to use inheritance for that compiler.
+#    define BOOST_IMPORT_TEMPLATE4(template_name)                                             \
+     template <class T, class U, class V, class W, class B = ::boost::detail::empty_base<T> > \
+     struct template_name : ::template_name<T, U, V, W, B> {};
+
+#    define BOOST_IMPORT_TEMPLATE3(template_name)                                    \
+     template <class T, class U, class V, class B = ::boost::detail::empty_base<T> > \
+     struct template_name : ::template_name<T, U, V, B> {};
+
+#    define BOOST_IMPORT_TEMPLATE2(template_name)                           \
+     template <class T, class U, class B = ::boost::detail::empty_base<T> > \
+     struct template_name : ::template_name<T, U, B> {};
+
+#    define BOOST_IMPORT_TEMPLATE1(template_name)                  \
+     template <class T, class B = ::boost::detail::empty_base<T> > \
+     struct template_name : ::template_name<T, B> {};
+
+#  endif // BOOST_NO_USING_TEMPLATE
+
+#endif // BOOST_NO_OPERATORS_IN_NAMESPACE
+
+//
+// Here's where we put it all together, defining the xxxx forms of the templates
+// in namespace boost. We also define specializations of is_chained_base<> for
+// the xxxx, xxxx1, and xxxx2 templates, importing them into boost:: as
+// necessary.
+//
+
+// is_chained_base<> - a traits class used to distinguish whether an operator
+// template argument is being used for base class chaining, or is specifying a
+// 2nd argument type.
+
+namespace boost {
+// A type parameter is used instead of a plain bool because Borland's compiler
+// didn't cope well with the more obvious non-type template parameter.
+namespace detail {
+  struct true_t {};
+  struct false_t {};
+} // namespace detail
+
+// Unspecialized version assumes that most types are not being used for base
+// class chaining. We specialize for the operator templates defined in this
+// library.
+template<class T> struct is_chained_base {
+  typedef ::boost::detail::false_t value;
+};
+
+} // namespace boost
+
+// Import a 4-type-argument operator template into boost (if necessary) and
+// provide a specialization of 'is_chained_base<>' for it.
+# define BOOST_OPERATOR_TEMPLATE4(template_name4)                     \
+  BOOST_IMPORT_TEMPLATE4(template_name4)                              \
+  template<class T, class U, class V, class W, class B>               \
+  struct is_chained_base< ::boost::template_name4<T, U, V, W, B> > {  \
+    typedef ::boost::detail::true_t value;                            \
+  };
+
+// Import a 3-type-argument operator template into boost (if necessary) and
+// provide a specialization of 'is_chained_base<>' for it.
+# define BOOST_OPERATOR_TEMPLATE3(template_name3)                     \
+  BOOST_IMPORT_TEMPLATE3(template_name3)                              \
+  template<class T, class U, class V, class B>                        \
+  struct is_chained_base< ::boost::template_name3<T, U, V, B> > {     \
+    typedef ::boost::detail::true_t value;                            \
+  };
+
+// Import a 2-type-argument operator template into boost (if necessary) and
+// provide a specialization of 'is_chained_base<>' for it.
+# define BOOST_OPERATOR_TEMPLATE2(template_name2)                  \
+  BOOST_IMPORT_TEMPLATE2(template_name2)                           \
+  template<class T, class U, class B>                              \
+  struct is_chained_base< ::boost::template_name2<T, U, B> > {     \
+    typedef ::boost::detail::true_t value;                         \
+  };
+
+// Import a 1-type-argument operator template into boost (if necessary) and
+// provide a specialization of 'is_chained_base<>' for it.
+# define BOOST_OPERATOR_TEMPLATE1(template_name1)                  \
+  BOOST_IMPORT_TEMPLATE1(template_name1)                           \
+  template<class T, class B>                                       \
+  struct is_chained_base< ::boost::template_name1<T, B> > {        \
+    typedef ::boost::detail::true_t value;                         \
+  };
+
+// BOOST_OPERATOR_TEMPLATE(template_name) defines template_name<> such that it
+// can be used for specifying both 1-argument and 2-argument forms. Requires the
+// existence of two previously defined class templates named '<template_name>1'
+// and '<template_name>2' which must implement the corresponding 1- and 2-
+// argument forms.
+//
+// The template type parameter O == is_chained_base<U>::value is used to
+// distinguish whether the 2nd argument to <template_name> is being used for
+// base class chaining from another boost operator template or is describing a
+// 2nd operand type. O == true_t only when U is actually an another operator
+// template from the library. Partial specialization is used to select an
+// implementation in terms of either '<template_name>1' or '<template_name>2'.
+//
+
+# define BOOST_OPERATOR_TEMPLATE(template_name)                    \
+template <class T                                                  \
+         ,class U = T                                              \
+         ,class B = ::boost::detail::empty_base<T>                 \
+         ,class O = typename is_chained_base<U>::value             \
+         >                                                         \
+struct template_name : template_name##2<T, U, B> {};               \
+                                                                   \
+template<class T, class U, class B>                                \
+struct template_name<T, U, B, ::boost::detail::true_t>             \
+  : template_name##1<T, U> {};                                     \
+                                                                   \
+template <class T, class B>                                        \
+struct template_name<T, T, B, ::boost::detail::false_t>            \
+  : template_name##1<T, B> {};                                     \
+                                                                   \
+template<class T, class U, class B, class O>                       \
+struct is_chained_base< ::boost::template_name<T, U, B, O> > {     \
+  typedef ::boost::detail::true_t value;                           \
+};                                                                 \
+                                                                   \
+BOOST_OPERATOR_TEMPLATE2(template_name##2)                         \
+BOOST_OPERATOR_TEMPLATE1(template_name##1)
+
+
+
+namespace boost {
+    
+BOOST_OPERATOR_TEMPLATE(less_than_comparable)
+BOOST_OPERATOR_TEMPLATE(equality_comparable)
+BOOST_OPERATOR_TEMPLATE(multipliable)
+BOOST_OPERATOR_TEMPLATE(addable)
+BOOST_OPERATOR_TEMPLATE(subtractable)
+BOOST_OPERATOR_TEMPLATE2(subtractable2_left)
+BOOST_OPERATOR_TEMPLATE(dividable)
+BOOST_OPERATOR_TEMPLATE2(dividable2_left)
+BOOST_OPERATOR_TEMPLATE(modable)
+BOOST_OPERATOR_TEMPLATE2(modable2_left)
+BOOST_OPERATOR_TEMPLATE(xorable)
+BOOST_OPERATOR_TEMPLATE(andable)
+BOOST_OPERATOR_TEMPLATE(orable)
+
+BOOST_OPERATOR_TEMPLATE1(incrementable)
+BOOST_OPERATOR_TEMPLATE1(decrementable)
+
+BOOST_OPERATOR_TEMPLATE2(dereferenceable)
+BOOST_OPERATOR_TEMPLATE3(indexable)
+
+BOOST_OPERATOR_TEMPLATE(left_shiftable)
+BOOST_OPERATOR_TEMPLATE(right_shiftable)
+BOOST_OPERATOR_TEMPLATE(equivalent)
+BOOST_OPERATOR_TEMPLATE(partially_ordered)
+
+BOOST_OPERATOR_TEMPLATE(totally_ordered)
+BOOST_OPERATOR_TEMPLATE(additive)
+BOOST_OPERATOR_TEMPLATE(multiplicative)
+BOOST_OPERATOR_TEMPLATE(integer_multiplicative)
+BOOST_OPERATOR_TEMPLATE(arithmetic)
+BOOST_OPERATOR_TEMPLATE(integer_arithmetic)
+BOOST_OPERATOR_TEMPLATE(bitwise)
+BOOST_OPERATOR_TEMPLATE1(unit_steppable)
+BOOST_OPERATOR_TEMPLATE(shiftable)
+BOOST_OPERATOR_TEMPLATE(ring_operators)
+BOOST_OPERATOR_TEMPLATE(ordered_ring_operators)
+BOOST_OPERATOR_TEMPLATE(field_operators)
+BOOST_OPERATOR_TEMPLATE(ordered_field_operators)
+BOOST_OPERATOR_TEMPLATE(euclidian_ring_operators)
+BOOST_OPERATOR_TEMPLATE(ordered_euclidian_ring_operators)
+BOOST_OPERATOR_TEMPLATE(euclidean_ring_operators)
+BOOST_OPERATOR_TEMPLATE(ordered_euclidean_ring_operators)
+BOOST_OPERATOR_TEMPLATE2(input_iteratable)
+BOOST_OPERATOR_TEMPLATE1(output_iteratable)
+BOOST_OPERATOR_TEMPLATE2(forward_iteratable)
+BOOST_OPERATOR_TEMPLATE2(bidirectional_iteratable)
+BOOST_OPERATOR_TEMPLATE4(random_access_iteratable)
+
+#undef BOOST_OPERATOR_TEMPLATE
+#undef BOOST_OPERATOR_TEMPLATE4
+#undef BOOST_OPERATOR_TEMPLATE3
+#undef BOOST_OPERATOR_TEMPLATE2
+#undef BOOST_OPERATOR_TEMPLATE1
+#undef BOOST_IMPORT_TEMPLATE1
+#undef BOOST_IMPORT_TEMPLATE2
+#undef BOOST_IMPORT_TEMPLATE3
+#undef BOOST_IMPORT_TEMPLATE4
+
+// The following 'operators' classes can only be used portably if the derived class
+// declares ALL of the required member operators.
+template <class T, class U>
+struct operators2
+    : totally_ordered2<T,U
+    , integer_arithmetic2<T,U
+    , bitwise2<T,U
+      > > > {};
+
+template <class T, class U = T>
+struct operators : operators2<T, U> {};
+
+template <class T> struct operators<T, T>
+    : totally_ordered<T
+    , integer_arithmetic<T
+    , bitwise<T
+    , unit_steppable<T
+      > > > > {};
+
+//  Iterator helper classes (contributed by Jeremy Siek) -------------------//
+//  (Input and output iterator helpers contributed by Daryle Walker) -------//
+//  (Changed to use combined operator classes by Daryle Walker) ------------//
+template <class T,
+          class V,
+          class D = std::ptrdiff_t,
+          class P = V const *,
+          class R = V const &>
+struct input_iterator_helper
+  : input_iteratable<T, P
+  , std::iterator<std::input_iterator_tag, V, D, P, R
+    > > {};
+
+template<class T>
+struct output_iterator_helper
+  : output_iteratable<T
+  , std::iterator<std::output_iterator_tag, void, void, void, void
+  > >
+{
+  T& operator*()  { return static_cast<T&>(*this); }
+  T& operator++() { return static_cast<T&>(*this); }
+};
+
+template <class T,
+          class V,
+          class D = std::ptrdiff_t,
+          class P = V*,
+          class R = V&>
+struct forward_iterator_helper
+  : forward_iteratable<T, P
+  , std::iterator<std::forward_iterator_tag, V, D, P, R
+    > > {};
+
+template <class T,
+          class V,
+          class D = std::ptrdiff_t,
+          class P = V*,
+          class R = V&>
+struct bidirectional_iterator_helper
+  : bidirectional_iteratable<T, P
+  , std::iterator<std::bidirectional_iterator_tag, V, D, P, R
+    > > {};
+
+template <class T,
+          class V, 
+          class D = std::ptrdiff_t,
+          class P = V*,
+          class R = V&>
+struct random_access_iterator_helper
+  : random_access_iteratable<T, P, D, R
+  , std::iterator<std::random_access_iterator_tag, V, D, P, R
+    > >
+{
+  friend D requires_difference_operator(const T& x, const T& y) {
+    return x - y;
+  }
+}; // random_access_iterator_helper
+
+} // namespace boost
+
+#if defined(__sgi) && !defined(__GNUC__)
+#pragma reset woff 1234
+#endif
+
+#endif // BOOST_OPERATORS_V1_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/optional/bad_optional_access.hpp b/contrib/libboost/boost_1_65_0/boost/optional/bad_optional_access.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/optional/bad_optional_access.hpp
rename to contrib/libboost/boost_1_65_0/boost/optional/bad_optional_access.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/optional/detail/old_optional_implementation.hpp b/contrib/libboost/boost_1_65_0/boost/optional/detail/old_optional_implementation.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/optional/detail/old_optional_implementation.hpp
rename to contrib/libboost/boost_1_65_0/boost/optional/detail/old_optional_implementation.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/optional/detail/optional_aligned_storage.hpp b/contrib/libboost/boost_1_65_0/boost/optional/detail/optional_aligned_storage.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/optional/detail/optional_aligned_storage.hpp
rename to contrib/libboost/boost_1_65_0/boost/optional/detail/optional_aligned_storage.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/optional/detail/optional_config.hpp b/contrib/libboost/boost_1_65_0/boost/optional/detail/optional_config.hpp
similarity index 81%
rename from contrib/libboost/boost_1_62_0/boost/optional/detail/optional_config.hpp
rename to contrib/libboost/boost_1_65_0/boost/optional/detail/optional_config.hpp
index 648744edbea..e26d73c1b4b 100644
--- a/contrib/libboost/boost_1_62_0/boost/optional/detail/optional_config.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/optional/detail/optional_config.hpp
@@ -96,4 +96,21 @@
 
 #endif // defined(__GNUC__)
 
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500) && !defined(__SUNPRO_CC)
+  // this condition is a copy paste from is_constructible.hpp
+  // I also disable SUNPRO, as it seems not to support type_traits correctly
+#else
+# define BOOST_OPTIONAL_DETAIL_NO_IS_CONSTRUCTIBLE_TRAIT
+#endif
+
+#if defined __SUNPRO_CC
+# define BOOST_OPTIONAL_DETAIL_NO_SFINAE_FRIENDLY_CONSTRUCTORS
+#elif (defined _MSC_FULL_VER) && (_MSC_FULL_VER < 190023026)
+# define BOOST_OPTIONAL_DETAIL_NO_SFINAE_FRIENDLY_CONSTRUCTORS
+#elif defined BOOST_GCC && !defined BOOST_GCC_CXX11
+# define BOOST_OPTIONAL_DETAIL_NO_SFINAE_FRIENDLY_CONSTRUCTORS
+#elif defined BOOST_GCC_VERSION && BOOST_GCC_VERSION < 40800
+# define BOOST_OPTIONAL_DETAIL_NO_SFINAE_FRIENDLY_CONSTRUCTORS
+#endif
+
 #endif // header guard
diff --git a/contrib/libboost/boost_1_62_0/boost/optional/detail/optional_factory_support.hpp b/contrib/libboost/boost_1_65_0/boost/optional/detail/optional_factory_support.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/optional/detail/optional_factory_support.hpp
rename to contrib/libboost/boost_1_65_0/boost/optional/detail/optional_factory_support.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/optional/detail/optional_reference_spec.hpp b/contrib/libboost/boost_1_65_0/boost/optional/detail/optional_reference_spec.hpp
similarity index 68%
rename from contrib/libboost/boost_1_62_0/boost/optional/detail/optional_reference_spec.hpp
rename to contrib/libboost/boost_1_65_0/boost/optional/detail/optional_reference_spec.hpp
index ba3951af7b1..ce558755a2a 100644
--- a/contrib/libboost/boost_1_62_0/boost/optional/detail/optional_reference_spec.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/optional/detail/optional_reference_spec.hpp
@@ -44,6 +44,23 @@ BOOST_DEDUCED_TYPENAME boost::remove_reference<T>::type& forward_reference(T&& r
 
 #endif // BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 
+
+template <class T>
+struct is_const_integral
+{
+  static const bool value = boost::is_const<T>::value && boost::is_integral<T>::value;
+};
+
+template <class T>
+struct is_const_integral_bad_for_conversion
+{
+#if (!defined BOOST_OPTIONAL_CONFIG_ALLOW_BINDING_TO_RVALUES) && (defined BOOST_OPTIONAL_CONFIG_NO_PROPER_CONVERT_FROM_CONST_INT)
+  static const bool value = boost::is_const<T>::value && boost::is_integral<T>::value;
+#else
+  static const bool value = false;
+#endif
+};
+
 template <class From>
 void prevent_assignment_from_false_const_integral()
 {
@@ -51,12 +68,13 @@ void prevent_assignment_from_false_const_integral()
 #ifdef BOOST_OPTIONAL_CONFIG_NO_PROPER_ASSIGN_FROM_CONST_INT
     // MSVC compiler without rvalue refernces: we need to disable the asignment from
     // const integral lvalue reference, as it may be an invalid temporary
-    BOOST_STATIC_ASSERT_MSG(!(boost::is_const<From>::value && boost::is_integral<From>::value), 
+    BOOST_STATIC_ASSERT_MSG(!is_const_integral<From>::value, 
                             "binding const lvalue references to integral types is disabled in this compiler");
 #endif
 #endif   
 }
 
+
 template <class T>
 struct is_optional_
 {
@@ -75,6 +93,21 @@ struct is_no_optional
   static const bool value = !is_optional_<BOOST_DEDUCED_TYPENAME boost::decay<T>::type>::value;
 };
 
+
+template <class T, class U>
+  struct is_same_decayed
+  {
+    static const bool value = ::boost::is_same<T, BOOST_DEDUCED_TYPENAME ::boost::remove_reference<U>::type>::value
+                           || ::boost::is_same<T, const BOOST_DEDUCED_TYPENAME ::boost::remove_reference<U>::type>::value;
+  };
+
+template <class T, class U>
+struct no_unboxing_cond
+{
+  static const bool value = is_no_optional<U>::value && !is_same_decayed<T, U>::value;
+};
+
+
 } // namespace detail
 
 template <class T>
@@ -94,13 +127,21 @@ public:
     optional(none_t) BOOST_NOEXCEPT : ptr_() {}  
 
     template <class U>
-        explicit optional(const optional<U&>& rhs) BOOST_NOEXCEPT : ptr_(rhs.ptr_) {}
-    optional(const optional& rhs) BOOST_NOEXCEPT : ptr_(rhs.ptr_) {}
+        explicit optional(const optional<U&>& rhs) BOOST_NOEXCEPT : ptr_(rhs.get_ptr()) {}
+    optional(const optional& rhs) BOOST_NOEXCEPT : ptr_(rhs.get_ptr()) {}
     
-
-    optional& operator=(const optional& rhs) BOOST_NOEXCEPT { ptr_ = rhs.ptr_; return *this; }
+    // the following two implement a 'conditionally explicit' constructor: condition is a hack for buggy compilers with srewed conversion construction from const int
     template <class U>
-        optional& operator=(const optional<U&>& rhs) BOOST_NOEXCEPT { ptr_ = rhs.ptr_; return *this; }
+      explicit optional(U& rhs, BOOST_DEDUCED_TYPENAME boost::enable_if_c<detail::is_same_decayed<T, U>::value && detail::is_const_integral_bad_for_conversion<U>::value>::type* = 0) BOOST_NOEXCEPT
+      : ptr_(boost::addressof(rhs)) {}
+      
+    template <class U>
+      optional(U& rhs, BOOST_DEDUCED_TYPENAME boost::enable_if_c<detail::is_same_decayed<T, U>::value && !detail::is_const_integral_bad_for_conversion<U>::value>::type* = 0) BOOST_NOEXCEPT
+      : ptr_(boost::addressof(rhs)) {}
+
+    optional& operator=(const optional& rhs) BOOST_NOEXCEPT { ptr_ = rhs.get_ptr(); return *this; }
+    template <class U>
+        optional& operator=(const optional<U&>& rhs) BOOST_NOEXCEPT { ptr_ = rhs.get_ptr(); return *this; }
     optional& operator=(none_t) BOOST_NOEXCEPT { ptr_ = 0; return *this; }
     
     
@@ -121,8 +162,10 @@ public:
     
 #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES   
  
+    optional(T&& /* rhs */) BOOST_NOEXCEPT { detail::prevent_binding_rvalue<T&&>(); }
+    
     template <class R>
-        optional(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<R> >::type* = 0) BOOST_NOEXCEPT
+        optional(R&& r, BOOST_DEDUCED_TYPENAME boost::enable_if<detail::no_unboxing_cond<T, R> >::type* = 0) BOOST_NOEXCEPT
         : ptr_(boost::addressof(r)) { detail::prevent_binding_rvalue<R>(); }
         
     template <class R>
@@ -154,19 +197,26 @@ public:
       
 #else  // BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
 
+    
+    // the following two implement a 'conditionally explicit' constructor
     template <class U>
-        optional(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<U> >::type* = 0) BOOST_NOEXCEPT : ptr_(boost::addressof(v)) { }
+      explicit optional(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if_c<detail::no_unboxing_cond<T, U>::value && detail::is_const_integral_bad_for_conversion<U>::value >::type* = 0) BOOST_NOEXCEPT
+      : ptr_(boost::addressof(v)) { }
+      
+    template <class U>
+      optional(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if_c<detail::no_unboxing_cond<T, U>::value && !detail::is_const_integral_bad_for_conversion<U>::value >::type* = 0) BOOST_NOEXCEPT
+      : ptr_(boost::addressof(v)) { }
         
     template <class U>
-        optional(bool cond, U& v, BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<U> >::type* = 0) BOOST_NOEXCEPT : ptr_(cond ? boost::addressof(v) : 0) {}
+      optional(bool cond, U& v, BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<U> >::type* = 0) BOOST_NOEXCEPT : ptr_(cond ? boost::addressof(v) : 0) {}
 
     template <class U>
-        BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<U>, optional<T&>&>::type
-        operator=(U& v) BOOST_NOEXCEPT
-        {
-            detail::prevent_assignment_from_false_const_integral<U>();
-            ptr_ = boost::addressof(v); return *this;
-        }
+      BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<U>, optional<T&>&>::type
+      operator=(U& v) BOOST_NOEXCEPT
+      {
+        detail::prevent_assignment_from_false_const_integral<U>();
+        ptr_ = boost::addressof(v); return *this;
+      }
 
     template <class U>
         void emplace(U& v, BOOST_DEDUCED_TYPENAME boost::enable_if<detail::is_no_optional<U> >::type* = 0) BOOST_NOEXCEPT
diff --git a/contrib/libboost/boost_1_62_0/boost/optional/detail/optional_relops.hpp b/contrib/libboost/boost_1_65_0/boost/optional/detail/optional_relops.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/optional/detail/optional_relops.hpp
rename to contrib/libboost/boost_1_65_0/boost/optional/detail/optional_relops.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/optional/detail/optional_swap.hpp b/contrib/libboost/boost_1_65_0/boost/optional/detail/optional_swap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/optional/detail/optional_swap.hpp
rename to contrib/libboost/boost_1_65_0/boost/optional/detail/optional_swap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/optional/optional.hpp b/contrib/libboost/boost_1_65_0/boost/optional/optional.hpp
similarity index 83%
rename from contrib/libboost/boost_1_62_0/boost/optional/optional.hpp
rename to contrib/libboost/boost_1_65_0/boost/optional/optional.hpp
index ff1a16ca487..a465b9ed661 100644
--- a/contrib/libboost/boost_1_62_0/boost/optional/optional.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/optional/optional.hpp
@@ -1,5 +1,5 @@
 // Copyright (C) 2003, 2008 Fernando Luis Cacciola Carballal.
-// Copyright (C) 2014, 2015 Andrzej Krzemienski.
+// Copyright (C) 2014 - 2016 Andrzej Krzemienski.
 //
 // Use, modification, and distribution is subject to the Boost Software
 // License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -56,6 +56,31 @@
 #include <boost/optional/detail/old_optional_implementation.hpp>
 #else
 namespace boost {
+  
+namespace optional_ns {
+  
+// a tag for in-place initialization of contained value
+struct in_place_init_t
+{
+  struct init_tag{};
+  explicit in_place_init_t(init_tag){}
+};            
+const in_place_init_t in_place_init ((in_place_init_t::init_tag()));
+
+// a tag for conditional in-place initialization of contained value	
+struct in_place_init_if_t
+{
+  struct init_tag{};
+  explicit in_place_init_if_t(init_tag){}
+};
+const in_place_init_if_t in_place_init_if ((in_place_init_if_t::init_tag()));
+  
+} // namespace optional_ns
+
+using optional_ns::in_place_init_t;
+using optional_ns::in_place_init;
+using optional_ns::in_place_init_if_t;
+using optional_ns::in_place_init_if;
 
 namespace optional_detail {
 
@@ -338,51 +363,179 @@ class optional_base : public optional_tag
 #if (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES) && (!defined BOOST_NO_CXX11_VARIADIC_TEMPLATES)
     // Constructs in-place
     // upon exception *this is always uninitialized
+    template<class... Args>
+    void construct ( in_place_init_t, Args&&... args )
+    {
+      ::new (m_storage.address()) value_type( boost::forward<Args>(args)... ) ;
+      m_initialized = true ;
+    }
+
     template<class... Args>
     void emplace_assign ( Args&&... args )
-     {
-       destroy();
-       ::new (m_storage.address()) value_type( boost::forward<Args>(args)... );
-       m_initialized = true ;
-     }
+    {
+      destroy();
+      construct(in_place_init, boost::forward<Args>(args)...);
+    }
+     
+    template<class... Args>
+    explicit optional_base ( in_place_init_t, Args&&... args )
+      :
+      m_initialized(false)
+    {
+      construct(in_place_init, boost::forward<Args>(args)...);
+    }
+    
+    template<class... Args>
+    explicit optional_base ( in_place_init_if_t, bool cond, Args&&... args )
+      :
+      m_initialized(false)
+    {
+      if ( cond )
+        construct(in_place_init, boost::forward<Args>(args)...);
+    }
 #elif (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES)
     template<class Arg>
-    void emplace_assign ( Arg&& arg )
+    void construct ( in_place_init_t, Arg&& arg )
      {
-       destroy();
        ::new (m_storage.address()) value_type( boost::forward<Arg>(arg) );
        m_initialized = true ;
      }
      
-    void emplace_assign ()
+    void construct ( in_place_init_t )
      {
-       destroy();
        ::new (m_storage.address()) value_type();
        m_initialized = true ;
      }
-#else
+     
     template<class Arg>
-    void emplace_assign ( const Arg& arg )
+    void emplace_assign ( Arg&& arg )
      {
        destroy();
+       construct(in_place_init, boost::forward<Arg>(arg)) ;
+     }
+     
+    void emplace_assign ()
+     {
+       destroy();
+       construct(in_place_init) ;
+     }
+     
+    template<class Arg>
+    explicit optional_base ( in_place_init_t, Arg&& arg )
+      :
+      m_initialized(false)
+    {
+      construct(in_place_init, boost::forward<Arg>(arg));
+    }
+    
+    explicit optional_base ( in_place_init_t )
+      :
+      m_initialized(false)
+    {
+      construct(in_place_init);
+    }
+    
+    template<class Arg>
+    explicit optional_base ( in_place_init_if_t, bool cond, Arg&& arg )
+      :
+      m_initialized(false)
+    {
+      if ( cond )
+        construct(in_place_init, boost::forward<Arg>(arg));
+    }
+    
+    explicit optional_base ( in_place_init_if_t, bool cond )
+      :
+      m_initialized(false)
+    {
+      if ( cond )
+        construct(in_place_init);
+    }
+
+#else
+     
+    template<class Arg>
+    void construct ( in_place_init_t, const Arg& arg )
+     {
        ::new (m_storage.address()) value_type( arg );
        m_initialized = true ;
      }
      
+    template<class Arg>
+    void construct ( in_place_init_t, Arg& arg )
+     {
+       ::new (m_storage.address()) value_type( arg );
+       m_initialized = true ;
+     }
+     
+    void construct ( in_place_init_t )
+     {
+       ::new (m_storage.address()) value_type();
+       m_initialized = true ;
+     }
+
+    template<class Arg>
+    void emplace_assign ( const Arg& arg )
+    {
+      destroy();
+      construct(in_place_init, arg);
+    }
+     
     template<class Arg>
     void emplace_assign ( Arg& arg )
-     {
-       destroy();
-       ::new (m_storage.address()) value_type( arg );
-       m_initialized = true ;
-     }
+    {
+      destroy();
+      construct(in_place_init, arg);
+    }
      
     void emplace_assign ()
-     {
-       destroy();
-       ::new (m_storage.address()) value_type();
-       m_initialized = true ;
-     }
+    {
+      destroy();
+      construct(in_place_init);
+    }
+    
+    template<class Arg>
+    explicit optional_base ( in_place_init_t, const Arg& arg )
+      : m_initialized(false)
+    {
+      construct(in_place_init, arg);
+    }
+
+    template<class Arg>
+    explicit optional_base ( in_place_init_t, Arg& arg )
+      : m_initialized(false)
+    {
+      construct(in_place_init, arg);
+    }
+    
+    explicit optional_base ( in_place_init_t )
+      : m_initialized(false)
+    {
+      construct(in_place_init);
+    }
+    
+    template<class Arg>
+    explicit optional_base ( in_place_init_if_t, bool cond, const Arg& arg )
+      : m_initialized(false)
+    {
+      if ( cond )
+        construct(in_place_init, arg);
+    }
+    
+    template<class Arg>
+    explicit optional_base ( in_place_init_if_t, bool cond, Arg& arg )
+      : m_initialized(false)
+    {
+      if ( cond )
+        construct(in_place_init, arg);
+    } 
+    
+    explicit optional_base ( in_place_init_if_t, bool cond )
+      : m_initialized(false)
+    {
+      if ( cond )
+        construct(in_place_init);
+    }
 #endif
 
 #ifndef BOOST_OPTIONAL_NO_INPLACE_FACTORY_SUPPORT
@@ -574,30 +727,36 @@ class optional_base : public optional_tag
 template <typename U>
 struct is_optional_related
   : boost::conditional< boost::is_base_of<optional_detail::optional_tag, BOOST_DEDUCED_TYPENAME boost::decay<U>::type>::value
-                     || boost::is_same<BOOST_DEDUCED_TYPENAME boost::decay<U>::type, none_t>::value,
+                     || boost::is_same<BOOST_DEDUCED_TYPENAME boost::decay<U>::type, none_t>::value
+                     || boost::is_same<BOOST_DEDUCED_TYPENAME boost::decay<U>::type, in_place_init_t>::value
+                     || boost::is_same<BOOST_DEDUCED_TYPENAME boost::decay<U>::type, in_place_init_if_t>::value,
     boost::true_type, boost::false_type>::type
 {};
 
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_DECLTYPE) && !BOOST_WORKAROUND(BOOST_MSVC, < 1800) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500) && !defined(__SUNPRO_CC)
-  // this condition is a copy paste from is_constructible.hpp
-  // I also disable SUNPRO, as it seems not to support type_traits correctly
+#if !defined(BOOST_OPTIONAL_DETAIL_NO_IS_CONSTRUCTIBLE_TRAIT)
   
 template <typename T, typename U>
 struct is_convertible_to_T_or_factory
   : boost::conditional< boost::is_base_of<boost::in_place_factory_base, BOOST_DEDUCED_TYPENAME boost::decay<U>::type>::value
                      || boost::is_base_of<boost::typed_in_place_factory_base, BOOST_DEDUCED_TYPENAME boost::decay<U>::type>::value
-                     || boost::is_constructible<T, U&&>::value
+                     || (boost::is_constructible<T, U&&>::value && !boost::is_same<T, BOOST_DEDUCED_TYPENAME boost::decay<U>::type>::value)
                       , boost::true_type, boost::false_type>::type
 {};
 
+template <typename T, typename U>
+struct is_optional_constructible : boost::is_constructible<T, U>
+{};
+
 #else
 
-#define BOOST_OPTIONAL_DETAIL_NO_IS_CONSTRUCTIBLE_TRAIT
-
 template <typename, typename>
 struct is_convertible_to_T_or_factory : boost::true_type
 {};
 
+template <typename T, typename U>
+struct is_optional_constructible : boost::true_type
+{};
+
 #endif // is_convertible condition
 
 template <typename T, typename U>
@@ -657,7 +816,11 @@ class optional : public optional_detail::optional_base<T>
     // Requires a valid conversion from U to T.
     // Can throw if T::T(U const&) does
     template<class U>
-    explicit optional ( optional<U> const& rhs )
+    explicit optional ( optional<U> const& rhs
+#ifndef BOOST_OPTIONAL_DETAIL_NO_SFINAE_FRIENDLY_CONSTRUCTORS
+                        ,typename boost::enable_if< optional_detail::is_optional_constructible<T, U const&> >::type* = 0
+#endif
+                      )
       :
       base()
     {
@@ -670,7 +833,11 @@ class optional : public optional_detail::optional_base<T>
     // Requires a valid conversion from U to T.
     // Can throw if T::T(U&&) does
     template<class U>
-    explicit optional ( optional<U> && rhs )
+    explicit optional ( optional<U> && rhs
+#ifndef BOOST_OPTIONAL_DETAIL_NO_SFINAE_FRIENDLY_CONSTRUCTORS
+                        ,typename boost::enable_if< optional_detail::is_optional_constructible<T, U> >::type* = 0
+#endif
+                      )
       :
       base()
     {
@@ -789,6 +956,19 @@ class optional : public optional_detail::optional_base<T>
       }
 #endif
 
+#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+
+    // Assigns from a T (deep-moves/copies the rhs value)
+    template <typename T_>
+    BOOST_DEDUCED_TYPENAME boost::enable_if<boost::is_same<T, BOOST_DEDUCED_TYPENAME boost::decay<T_>::type>, optional&>::type
+    operator= ( T_&& val )
+      {
+        this->assign( boost::forward<T_>(val) ) ;
+        return *this ;
+      }
+      
+#else
+
     // Assigns from a T (deep-copies the rhs value)
     // Basic Guarantee: If T::( T const& ) throws, this is left UNINITIALIZED
     optional& operator= ( argument_type val )
@@ -796,7 +976,7 @@ class optional : public optional_detail::optional_base<T>
         this->assign( val ) ;
         return *this ;
       }
-
+      
 #ifndef BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES
     // Assigns from a T (deep-moves the rhs value)
     optional& operator= ( rval_reference_type val )
@@ -805,7 +985,9 @@ class optional : public optional_detail::optional_base<T>
         return *this ;
       }
 #endif
-
+      
+#endif // BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+      
     // Assigns from a "none"
     // Which destroys the current value, if any, leaving this UNINITIALIZED
     // No-throw (assuming T::~T() doesn't)
@@ -820,9 +1002,20 @@ class optional : public optional_detail::optional_base<T>
     // upon exception *this is always uninitialized
     template<class... Args>
     void emplace ( Args&&... args )
-     {
-       this->emplace_assign( boost::forward<Args>(args)... );
-     }
+    {
+      this->emplace_assign( boost::forward<Args>(args)... );
+    }
+     
+    template<class... Args>
+    explicit optional ( in_place_init_t, Args&&... args )
+    : base( in_place_init, boost::forward<Args>(args)... )
+    {}
+    
+    template<class... Args>
+    explicit optional ( in_place_init_if_t, bool cond, Args&&... args )
+    : base( in_place_init_if, cond, boost::forward<Args>(args)... )
+    {}
+    
 #elif (!defined BOOST_OPTIONAL_DETAIL_NO_RVALUE_REFERENCES)
     template<class Arg>
     void emplace ( Arg&& arg )
@@ -834,6 +1027,24 @@ class optional : public optional_detail::optional_base<T>
      {
        this->emplace_assign();
      }
+     
+    template<class Args>
+    explicit optional ( in_place_init_t, Args&& args )
+    : base( in_place_init, boost::forward<Args>(args) )
+    {}
+
+    explicit optional ( in_place_init_t )
+    : base( in_place_init )
+    {}
+    
+    template<class Args>
+    explicit optional ( in_place_init_if_t, bool cond, Args&& args )
+    : base( in_place_init_if, cond, boost::forward<Args>(args) )
+    {}
+    
+    explicit optional ( in_place_init_if_t, bool cond )
+    : base( in_place_init_if, cond )
+    {}
 #else
     template<class Arg>
     void emplace ( const Arg& arg )
@@ -851,6 +1062,34 @@ class optional : public optional_detail::optional_base<T>
      {
        this->emplace_assign();
      }
+     
+    template<class Arg>
+    explicit optional ( in_place_init_t, const Arg& arg )
+    : base( in_place_init, arg )
+    {}
+    
+    template<class Arg>
+    explicit optional ( in_place_init_t, Arg& arg )
+    : base( in_place_init, arg )
+    {}
+
+    explicit optional ( in_place_init_t )
+    : base( in_place_init )
+    {}
+    
+    template<class Arg>
+    explicit optional ( in_place_init_if_t, bool cond, const Arg& arg )
+    : base( in_place_init_if, cond, arg )
+    {}
+    
+    template<class Arg>
+    explicit optional ( in_place_init_if_t, bool cond, Arg& arg )
+    : base( in_place_init_if, cond, arg )
+    {} 
+    
+    explicit optional ( in_place_init_if_t, bool cond )
+    : base( in_place_init_if, cond )
+    {}
 #endif
 
     void swap( optional & arg )
diff --git a/contrib/libboost/boost_1_62_0/boost/optional/optional_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/optional/optional_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/optional/optional_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/optional/optional_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/optional/optional_io.hpp b/contrib/libboost/boost_1_65_0/boost/optional/optional_io.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/optional/optional_io.hpp
rename to contrib/libboost/boost_1_65_0/boost/optional/optional_io.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/bucket_sorter.hpp b/contrib/libboost/boost_1_65_0/boost/pending/bucket_sorter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pending/bucket_sorter.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/bucket_sorter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/container_traits.hpp b/contrib/libboost/boost_1_65_0/boost/pending/container_traits.hpp
similarity index 96%
rename from contrib/libboost/boost_1_62_0/boost/pending/container_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/container_traits.hpp
index a58b5245037..13800a30018 100644
--- a/contrib/libboost/boost_1_62_0/boost/pending/container_traits.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/pending/container_traits.hpp
@@ -23,14 +23,6 @@
 #include <boost/unordered_set.hpp>
 #include <boost/unordered_map.hpp>
 
-#if !defined BOOST_NO_SLIST
-#  ifdef BOOST_SLIST_HEADER
-#    include BOOST_SLIST_HEADER
-#  else
-#    include <slist>
-#  endif
-#endif
-
 #ifndef BOOST_NO_CXX11_HDR_UNORDERED_SET
 #include <unordered_set>
 #endif
@@ -149,27 +141,6 @@ namespace boost { namespace graph_detail {
     typedef stable_tag iterator_stability;
   };
 
-
-  // std::slist
-#ifndef BOOST_NO_SLIST
-  template <class T, class Alloc>
-  struct container_traits<BOOST_STD_EXTENSION_NAMESPACE::slist<T,Alloc> > {
-    typedef front_insertion_sequence_tag category;
-    typedef stable_tag iterator_stability;
-  };
-  template <class T, class Alloc>
-  front_insertion_sequence_tag container_category(
-  const BOOST_STD_EXTENSION_NAMESPACE::slist<T,Alloc>&
-  )
-    { return front_insertion_sequence_tag(); }
-
-  template <class T, class Alloc>
-  stable_tag iterator_stability(
-  const BOOST_STD_EXTENSION_NAMESPACE::slist<T,Alloc>&)
-    { return stable_tag(); }
-#endif
-
-
   // std::set
   struct set_tag :
     virtual public sorted_associative_container_tag,
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/detail/disjoint_sets.hpp b/contrib/libboost/boost_1_65_0/boost/pending/detail/disjoint_sets.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pending/detail/disjoint_sets.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/detail/disjoint_sets.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/detail/int_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/pending/detail/int_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pending/detail/int_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/detail/int_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/detail/property.hpp b/contrib/libboost/boost_1_65_0/boost/pending/detail/property.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pending/detail/property.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/detail/property.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/disjoint_sets.hpp b/contrib/libboost/boost_1_65_0/boost/pending/disjoint_sets.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pending/disjoint_sets.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/disjoint_sets.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/fenced_priority_queue.hpp b/contrib/libboost/boost_1_65_0/boost/pending/fenced_priority_queue.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pending/fenced_priority_queue.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/fenced_priority_queue.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/fibonacci_heap.hpp b/contrib/libboost/boost_1_65_0/boost/pending/fibonacci_heap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pending/fibonacci_heap.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/fibonacci_heap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/indirect_cmp.hpp b/contrib/libboost/boost_1_65_0/boost/pending/indirect_cmp.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pending/indirect_cmp.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/indirect_cmp.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/integer_log2.hpp b/contrib/libboost/boost_1_65_0/boost/pending/integer_log2.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pending/integer_log2.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/integer_log2.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/is_heap.hpp b/contrib/libboost/boost_1_65_0/boost/pending/is_heap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pending/is_heap.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/is_heap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/iterator_adaptors.hpp b/contrib/libboost/boost_1_65_0/boost/pending/iterator_adaptors.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pending/iterator_adaptors.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/iterator_adaptors.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/iterator_tests.hpp b/contrib/libboost/boost_1_65_0/boost/pending/iterator_tests.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pending/iterator_tests.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/iterator_tests.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/lowest_bit.hpp b/contrib/libboost/boost_1_65_0/boost/pending/lowest_bit.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pending/lowest_bit.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/lowest_bit.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/mutable_heap.hpp b/contrib/libboost/boost_1_65_0/boost/pending/mutable_heap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pending/mutable_heap.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/mutable_heap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/mutable_queue.hpp b/contrib/libboost/boost_1_65_0/boost/pending/mutable_queue.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pending/mutable_queue.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/mutable_queue.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/property.hpp b/contrib/libboost/boost_1_65_0/boost/pending/property.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pending/property.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/property.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/property_serialize.hpp b/contrib/libboost/boost_1_65_0/boost/pending/property_serialize.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pending/property_serialize.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/property_serialize.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/queue.hpp b/contrib/libboost/boost_1_65_0/boost/pending/queue.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pending/queue.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/queue.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/relaxed_heap.hpp b/contrib/libboost/boost_1_65_0/boost/pending/relaxed_heap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pending/relaxed_heap.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/relaxed_heap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pending/stringtok.hpp b/contrib/libboost/boost_1_65_0/boost/pending/stringtok.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pending/stringtok.hpp
rename to contrib/libboost/boost_1_65_0/boost/pending/stringtok.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/pointee.hpp b/contrib/libboost/boost_1_65_0/boost/pointee.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/pointee.hpp
rename to contrib/libboost/boost_1_65_0/boost/pointee.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/predef.h b/contrib/libboost/boost_1_65_0/boost/predef.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef.h
rename to contrib/libboost/boost_1_65_0/boost/predef.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/architecture.h b/contrib/libboost/boost_1_65_0/boost/predef/architecture.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/architecture.h
rename to contrib/libboost/boost_1_65_0/boost/predef/architecture.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/architecture/alpha.h b/contrib/libboost/boost_1_65_0/boost/predef/architecture/alpha.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/architecture/alpha.h
rename to contrib/libboost/boost_1_65_0/boost/predef/architecture/alpha.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/architecture/arm.h b/contrib/libboost/boost_1_65_0/boost/predef/architecture/arm.h
similarity index 89%
rename from contrib/libboost/boost_1_62_0/boost/predef/architecture/arm.h
rename to contrib/libboost/boost_1_65_0/boost/predef/architecture/arm.h
index b200c627772..76f9f947bd7 100644
--- a/contrib/libboost/boost_1_62_0/boost/predef/architecture/arm.h
+++ b/contrib/libboost/boost_1_65_0/boost/predef/architecture/arm.h
@@ -27,11 +27,13 @@ http://www.boost.org/LICENSE_1_0.txt)
     [[`__TARGET_ARCH_ARM`] [__predef_detection__]]
     [[`__TARGET_ARCH_THUMB`] [__predef_detection__]]
     [[`_M_ARM`] [__predef_detection__]]
+    [[`_M_ARM64`] [__predef_detection__]]
 
     [[`__arm64`] [8.0.0]]
     [[`__TARGET_ARCH_ARM`] [V.0.0]]
     [[`__TARGET_ARCH_THUMB`] [V.0.0]]
     [[`_M_ARM`] [V.0.0]]
+    [[`_M_ARM64`] [8.0.0]]
     ]
  */
 
@@ -39,7 +41,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 
 #if defined(__arm__) || defined(__arm64) || defined(__thumb__) || \
     defined(__TARGET_ARCH_ARM) || defined(__TARGET_ARCH_THUMB) || \
-    defined(_M_ARM)
+    defined(_M_ARM) || defined(_M_ARM64)
 #   undef BOOST_ARCH_ARM
 #   if !defined(BOOST_ARCH_ARM) && defined(__arm64)
 #       define BOOST_ARCH_ARM BOOST_VERSION_NUMBER(8,0,0)
@@ -50,6 +52,9 @@ http://www.boost.org/LICENSE_1_0.txt)
 #   if !defined(BOOST_ARCH_ARM) && defined(__TARGET_ARCH_THUMB)
 #       define BOOST_ARCH_ARM BOOST_VERSION_NUMBER(__TARGET_ARCH_THUMB,0,0)
 #   endif
+#   if !defined(BOOST_ARCH_ARM) && defined(_M_ARM64)
+#       define BOOST_ARCH_ARM BOOST_VERSION_NUMBER(8,0,0)
+#   endif
 #   if !defined(BOOST_ARCH_ARM) && defined(_M_ARM)
 #       define BOOST_ARCH_ARM BOOST_VERSION_NUMBER(_M_ARM,0,0)
 #   endif
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/architecture/blackfin.h b/contrib/libboost/boost_1_65_0/boost/predef/architecture/blackfin.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/architecture/blackfin.h
rename to contrib/libboost/boost_1_65_0/boost/predef/architecture/blackfin.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/architecture/convex.h b/contrib/libboost/boost_1_65_0/boost/predef/architecture/convex.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/architecture/convex.h
rename to contrib/libboost/boost_1_65_0/boost/predef/architecture/convex.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/architecture/ia64.h b/contrib/libboost/boost_1_65_0/boost/predef/architecture/ia64.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/architecture/ia64.h
rename to contrib/libboost/boost_1_65_0/boost/predef/architecture/ia64.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/architecture/m68k.h b/contrib/libboost/boost_1_65_0/boost/predef/architecture/m68k.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/architecture/m68k.h
rename to contrib/libboost/boost_1_65_0/boost/predef/architecture/m68k.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/architecture/mips.h b/contrib/libboost/boost_1_65_0/boost/predef/architecture/mips.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/architecture/mips.h
rename to contrib/libboost/boost_1_65_0/boost/predef/architecture/mips.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/architecture/parisc.h b/contrib/libboost/boost_1_65_0/boost/predef/architecture/parisc.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/architecture/parisc.h
rename to contrib/libboost/boost_1_65_0/boost/predef/architecture/parisc.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/architecture/ppc.h b/contrib/libboost/boost_1_65_0/boost/predef/architecture/ppc.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/architecture/ppc.h
rename to contrib/libboost/boost_1_65_0/boost/predef/architecture/ppc.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/architecture/pyramid.h b/contrib/libboost/boost_1_65_0/boost/predef/architecture/pyramid.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/architecture/pyramid.h
rename to contrib/libboost/boost_1_65_0/boost/predef/architecture/pyramid.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/architecture/rs6k.h b/contrib/libboost/boost_1_65_0/boost/predef/architecture/rs6k.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/architecture/rs6k.h
rename to contrib/libboost/boost_1_65_0/boost/predef/architecture/rs6k.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/architecture/sparc.h b/contrib/libboost/boost_1_65_0/boost/predef/architecture/sparc.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/architecture/sparc.h
rename to contrib/libboost/boost_1_65_0/boost/predef/architecture/sparc.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/architecture/superh.h b/contrib/libboost/boost_1_65_0/boost/predef/architecture/superh.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/architecture/superh.h
rename to contrib/libboost/boost_1_65_0/boost/predef/architecture/superh.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/architecture/sys370.h b/contrib/libboost/boost_1_65_0/boost/predef/architecture/sys370.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/architecture/sys370.h
rename to contrib/libboost/boost_1_65_0/boost/predef/architecture/sys370.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/architecture/sys390.h b/contrib/libboost/boost_1_65_0/boost/predef/architecture/sys390.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/architecture/sys390.h
rename to contrib/libboost/boost_1_65_0/boost/predef/architecture/sys390.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/architecture/x86.h b/contrib/libboost/boost_1_65_0/boost/predef/architecture/x86.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/architecture/x86.h
rename to contrib/libboost/boost_1_65_0/boost/predef/architecture/x86.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/architecture/x86/32.h b/contrib/libboost/boost_1_65_0/boost/predef/architecture/x86/32.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/architecture/x86/32.h
rename to contrib/libboost/boost_1_65_0/boost/predef/architecture/x86/32.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/architecture/x86/64.h b/contrib/libboost/boost_1_65_0/boost/predef/architecture/x86/64.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/architecture/x86/64.h
rename to contrib/libboost/boost_1_65_0/boost/predef/architecture/x86/64.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/architecture/z.h b/contrib/libboost/boost_1_65_0/boost/predef/architecture/z.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/architecture/z.h
rename to contrib/libboost/boost_1_65_0/boost/predef/architecture/z.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/borland.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/borland.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/borland.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/borland.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/clang.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/clang.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/clang.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/clang.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/comeau.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/comeau.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/comeau.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/comeau.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/compaq.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/compaq.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/compaq.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/compaq.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/diab.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/diab.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/diab.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/diab.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/digitalmars.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/digitalmars.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/digitalmars.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/digitalmars.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/dignus.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/dignus.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/dignus.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/dignus.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/edg.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/edg.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/edg.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/edg.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/ekopath.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/ekopath.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/ekopath.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/ekopath.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/gcc.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/gcc.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/gcc.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/gcc.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/gcc_xml.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/gcc_xml.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/gcc_xml.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/gcc_xml.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/greenhills.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/greenhills.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/greenhills.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/greenhills.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/hp_acc.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/hp_acc.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/hp_acc.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/hp_acc.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/iar.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/iar.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/iar.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/iar.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/ibm.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/ibm.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/ibm.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/ibm.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/intel.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/intel.h
similarity index 67%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/intel.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/intel.h
index 65bde6778ad..f8a17ef437e 100644
--- a/contrib/libboost/boost_1_62_0/boost/predef/compiler/intel.h
+++ b/contrib/libboost/boost_1_65_0/boost/predef/compiler/intel.h
@@ -1,5 +1,5 @@
 /*
-Copyright Rene Rivera 2008-2015
+Copyright Rene Rivera 2008-2017
 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)
@@ -25,7 +25,8 @@ Version number available as major, minor, and patch.
     [[`__ICC`] [__predef_detection__]]
     [[`__ECC`] [__predef_detection__]]
 
-    [[`__INTEL_COMPILER`] [V.R.P]]
+    [[`__INTEL_COMPILER`] [V.R]]
+    [[`__INTEL_COMPILER` and `__INTEL_COMPILER_UPDATE`] [V.R.P]]
     ]
  */
 
@@ -33,8 +34,21 @@ Version number available as major, minor, and patch.
 
 #if defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || \
     defined(__ECC)
+/*`
+[note Because of an Intel mistake in the release version numbering when
+`__INTEL_COMPILER` is `9999` it is detected as version 12.1.0.]
+ */
+#   if !defined(BOOST_COMP_INTEL_DETECTION) && defined(__INTEL_COMPILER) && (__INTEL_COMPILER == 9999)
+#       define BOOST_COMP_INTEL_DETECTION BOOST_VERSION_NUMBER(12,1,0)
+#   endif
+#   if !defined(BOOST_COMP_INTEL_DETECTION) && defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE)
+#       define BOOST_COMP_INTEL_DETECTION BOOST_VERSION_NUMBER( \
+            BOOST_VERSION_NUMBER_MAJOR(BOOST_PREDEF_MAKE_10_VVRR(__INTEL_COMPILER)), \
+            BOOST_VERSION_NUMBER_MINOR(BOOST_PREDEF_MAKE_10_VVRR(__INTEL_COMPILER)), \
+            __INTEL_COMPILER_UPDATE)
+#   endif
 #   if !defined(BOOST_COMP_INTEL_DETECTION) && defined(__INTEL_COMPILER)
-#       define BOOST_COMP_INTEL_DETECTION BOOST_PREDEF_MAKE_10_VRP(__INTEL_COMPILER)
+#       define BOOST_COMP_INTEL_DETECTION BOOST_PREDEF_MAKE_10_VVRR(__INTEL_COMPILER)
 #   endif
 #   if !defined(BOOST_COMP_INTEL_DETECTION)
 #       define BOOST_COMP_INTEL_DETECTION BOOST_VERSION_NUMBER_AVAILABLE
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/kai.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/kai.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/kai.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/kai.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/llvm.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/llvm.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/llvm.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/llvm.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/metaware.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/metaware.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/metaware.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/metaware.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/metrowerks.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/metrowerks.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/metrowerks.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/metrowerks.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/microtec.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/microtec.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/microtec.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/microtec.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/mpw.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/mpw.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/mpw.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/mpw.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/palm.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/palm.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/palm.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/palm.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/pgi.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/pgi.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/pgi.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/pgi.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/sgi_mipspro.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/sgi_mipspro.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/sgi_mipspro.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/sgi_mipspro.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/sunpro.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/sunpro.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/sunpro.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/sunpro.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/tendra.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/tendra.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/tendra.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/tendra.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/visualc.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/visualc.h
similarity index 80%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/visualc.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/visualc.h
index 9481d9d9fdc..f81e61ed522 100644
--- a/contrib/libboost/boost_1_62_0/boost/predef/compiler/visualc.h
+++ b/contrib/libboost/boost_1_65_0/boost/predef/compiler/visualc.h
@@ -29,6 +29,10 @@ Version number available as major, minor, and patch.
     [[`_MSC_FULL_VER`] [V.R.P]]
     [[`_MSC_VER`] [V.R.0]]
     ]
+
+[note Release of Visual Studio after 2015 will no longer be identified
+by Boost Predef as the marketing version number. Instead we use the
+compiler version number directly, i.e. the _MSC_VER number.]
  */
 
 #define BOOST_COMP_MSVC BOOST_VERSION_NUMBER_NOT_AVAILABLE
@@ -53,8 +57,18 @@ Version number available as major, minor, and patch.
     means that the compiler and VS product versions are no longer
     in sync. Hence we need to use different formulas for
     mapping from MSC version to VS product version.
+
+    VS2017 is a total nightmare when it comes to version numbers.
+    Hence to avoid arguments relating to that both present and
+    future.. Any version after VS2015 will use solely the compiler
+    version, i.e. cl.exe, as the version number here.
     */
-#   if (_MSC_VER >= 1900)
+#   if (_MSC_VER > 1900)
+#       define BOOST_COMP_MSVC_DETECTION BOOST_VERSION_NUMBER(\
+            _MSC_VER/100,\
+            _MSC_VER%100,\
+            BOOST_COMP_MSVC_BUILD)
+#   elif (_MSC_VER >= 1900)
 #       define BOOST_COMP_MSVC_DETECTION BOOST_VERSION_NUMBER(\
             _MSC_VER/100-5,\
             _MSC_VER%100,\
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/compiler/watcom.h b/contrib/libboost/boost_1_65_0/boost/predef/compiler/watcom.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/compiler/watcom.h
rename to contrib/libboost/boost_1_65_0/boost/predef/compiler/watcom.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/detail/_cassert.h b/contrib/libboost/boost_1_65_0/boost/predef/detail/_cassert.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/detail/_cassert.h
rename to contrib/libboost/boost_1_65_0/boost/predef/detail/_cassert.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/detail/_exception.h b/contrib/libboost/boost_1_65_0/boost/predef/detail/_exception.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/detail/_exception.h
rename to contrib/libboost/boost_1_65_0/boost/predef/detail/_exception.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/detail/comp_detected.h b/contrib/libboost/boost_1_65_0/boost/predef/detail/comp_detected.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/detail/comp_detected.h
rename to contrib/libboost/boost_1_65_0/boost/predef/detail/comp_detected.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/detail/endian_compat.h b/contrib/libboost/boost_1_65_0/boost/predef/detail/endian_compat.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/detail/endian_compat.h
rename to contrib/libboost/boost_1_65_0/boost/predef/detail/endian_compat.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/detail/os_detected.h b/contrib/libboost/boost_1_65_0/boost/predef/detail/os_detected.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/detail/os_detected.h
rename to contrib/libboost/boost_1_65_0/boost/predef/detail/os_detected.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/detail/platform_detected.h b/contrib/libboost/boost_1_65_0/boost/predef/detail/platform_detected.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/detail/platform_detected.h
rename to contrib/libboost/boost_1_65_0/boost/predef/detail/platform_detected.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/detail/test.h b/contrib/libboost/boost_1_65_0/boost/predef/detail/test.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/detail/test.h
rename to contrib/libboost/boost_1_65_0/boost/predef/detail/test.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/detail/test_def.h b/contrib/libboost/boost_1_65_0/boost/predef/detail/test_def.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/detail/test_def.h
rename to contrib/libboost/boost_1_65_0/boost/predef/detail/test_def.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/hardware.h b/contrib/libboost/boost_1_65_0/boost/predef/hardware.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/hardware.h
rename to contrib/libboost/boost_1_65_0/boost/predef/hardware.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/hardware/simd.h b/contrib/libboost/boost_1_65_0/boost/predef/hardware/simd.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/hardware/simd.h
rename to contrib/libboost/boost_1_65_0/boost/predef/hardware/simd.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/hardware/simd/arm.h b/contrib/libboost/boost_1_65_0/boost/predef/hardware/simd/arm.h
similarity index 90%
rename from contrib/libboost/boost_1_62_0/boost/predef/hardware/simd/arm.h
rename to contrib/libboost/boost_1_65_0/boost/predef/hardware/simd/arm.h
index d067c931968..3b3fc3fa366 100644
--- a/contrib/libboost/boost_1_62_0/boost/predef/hardware/simd/arm.h
+++ b/contrib/libboost/boost_1_65_0/boost/predef/hardware/simd/arm.h
@@ -24,6 +24,7 @@ http://www.boost.org/LICENSE_1_0.txt)
      [[`__ARM_NEON__`] [__predef_detection__]]
      [[`__aarch64__`] [__predef_detection__]]
      [[`_M_ARM`] [__predef_detection__]]
+     [[`_M_ARM64`] [__predef_detection__]]
      ]
 
  [table
@@ -32,6 +33,7 @@ http://www.boost.org/LICENSE_1_0.txt)
      [[`__ARM_NEON__`] [BOOST_HW_SIMD_ARM_NEON_VERSION]]
      [[`__aarch64__`] [BOOST_HW_SIMD_ARM_NEON_VERSION]]
      [[`_M_ARM`] [BOOST_HW_SIMD_ARM_NEON_VERSION]]
+     [[`_M_ARM64`] [BOOST_HW_SIMD_ARM_NEON_VERSION]]
      ]
 
  */
@@ -39,7 +41,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 #define BOOST_HW_SIMD_ARM BOOST_VERSION_NUMBER_NOT_AVAILABLE
 
 #undef BOOST_HW_SIMD_ARM
-#if !defined(BOOST_HW_SIMD_ARM) && (defined(__ARM_NEON__) || defined(__aarch64__) || defined (_M_ARM))
+#if !defined(BOOST_HW_SIMD_ARM) && (defined(__ARM_NEON__) || defined(__aarch64__) || defined (_M_ARM) || defined (_M_ARM64))
 #   define BOOST_HW_SIMD_ARM BOOST_HW_SIMD_ARM_NEON_VERSION
 #endif
 
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/hardware/simd/arm/versions.h b/contrib/libboost/boost_1_65_0/boost/predef/hardware/simd/arm/versions.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/hardware/simd/arm/versions.h
rename to contrib/libboost/boost_1_65_0/boost/predef/hardware/simd/arm/versions.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/hardware/simd/ppc.h b/contrib/libboost/boost_1_65_0/boost/predef/hardware/simd/ppc.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/hardware/simd/ppc.h
rename to contrib/libboost/boost_1_65_0/boost/predef/hardware/simd/ppc.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/hardware/simd/ppc/versions.h b/contrib/libboost/boost_1_65_0/boost/predef/hardware/simd/ppc/versions.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/hardware/simd/ppc/versions.h
rename to contrib/libboost/boost_1_65_0/boost/predef/hardware/simd/ppc/versions.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/hardware/simd/x86.h b/contrib/libboost/boost_1_65_0/boost/predef/hardware/simd/x86.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/hardware/simd/x86.h
rename to contrib/libboost/boost_1_65_0/boost/predef/hardware/simd/x86.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/hardware/simd/x86/versions.h b/contrib/libboost/boost_1_65_0/boost/predef/hardware/simd/x86/versions.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/hardware/simd/x86/versions.h
rename to contrib/libboost/boost_1_65_0/boost/predef/hardware/simd/x86/versions.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/hardware/simd/x86_amd.h b/contrib/libboost/boost_1_65_0/boost/predef/hardware/simd/x86_amd.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/hardware/simd/x86_amd.h
rename to contrib/libboost/boost_1_65_0/boost/predef/hardware/simd/x86_amd.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/hardware/simd/x86_amd/versions.h b/contrib/libboost/boost_1_65_0/boost/predef/hardware/simd/x86_amd/versions.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/hardware/simd/x86_amd/versions.h
rename to contrib/libboost/boost_1_65_0/boost/predef/hardware/simd/x86_amd/versions.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/language.h b/contrib/libboost/boost_1_65_0/boost/predef/language.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/language.h
rename to contrib/libboost/boost_1_65_0/boost/predef/language.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/language/objc.h b/contrib/libboost/boost_1_65_0/boost/predef/language/objc.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/language/objc.h
rename to contrib/libboost/boost_1_65_0/boost/predef/language/objc.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/language/stdc.h b/contrib/libboost/boost_1_65_0/boost/predef/language/stdc.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/language/stdc.h
rename to contrib/libboost/boost_1_65_0/boost/predef/language/stdc.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/language/stdcpp.h b/contrib/libboost/boost_1_65_0/boost/predef/language/stdcpp.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/language/stdcpp.h
rename to contrib/libboost/boost_1_65_0/boost/predef/language/stdcpp.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/library.h b/contrib/libboost/boost_1_65_0/boost/predef/library.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/library.h
rename to contrib/libboost/boost_1_65_0/boost/predef/library.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/library/c.h b/contrib/libboost/boost_1_65_0/boost/predef/library/c.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/library/c.h
rename to contrib/libboost/boost_1_65_0/boost/predef/library/c.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/library/c/_prefix.h b/contrib/libboost/boost_1_65_0/boost/predef/library/c/_prefix.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/library/c/_prefix.h
rename to contrib/libboost/boost_1_65_0/boost/predef/library/c/_prefix.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/library/c/gnu.h b/contrib/libboost/boost_1_65_0/boost/predef/library/c/gnu.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/library/c/gnu.h
rename to contrib/libboost/boost_1_65_0/boost/predef/library/c/gnu.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/library/c/uc.h b/contrib/libboost/boost_1_65_0/boost/predef/library/c/uc.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/library/c/uc.h
rename to contrib/libboost/boost_1_65_0/boost/predef/library/c/uc.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/library/c/vms.h b/contrib/libboost/boost_1_65_0/boost/predef/library/c/vms.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/library/c/vms.h
rename to contrib/libboost/boost_1_65_0/boost/predef/library/c/vms.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/library/c/zos.h b/contrib/libboost/boost_1_65_0/boost/predef/library/c/zos.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/library/c/zos.h
rename to contrib/libboost/boost_1_65_0/boost/predef/library/c/zos.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/library/std.h b/contrib/libboost/boost_1_65_0/boost/predef/library/std.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/library/std.h
rename to contrib/libboost/boost_1_65_0/boost/predef/library/std.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/library/std/_prefix.h b/contrib/libboost/boost_1_65_0/boost/predef/library/std/_prefix.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/library/std/_prefix.h
rename to contrib/libboost/boost_1_65_0/boost/predef/library/std/_prefix.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/library/std/cxx.h b/contrib/libboost/boost_1_65_0/boost/predef/library/std/cxx.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/library/std/cxx.h
rename to contrib/libboost/boost_1_65_0/boost/predef/library/std/cxx.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/library/std/dinkumware.h b/contrib/libboost/boost_1_65_0/boost/predef/library/std/dinkumware.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/library/std/dinkumware.h
rename to contrib/libboost/boost_1_65_0/boost/predef/library/std/dinkumware.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/library/std/libcomo.h b/contrib/libboost/boost_1_65_0/boost/predef/library/std/libcomo.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/library/std/libcomo.h
rename to contrib/libboost/boost_1_65_0/boost/predef/library/std/libcomo.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/library/std/modena.h b/contrib/libboost/boost_1_65_0/boost/predef/library/std/modena.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/library/std/modena.h
rename to contrib/libboost/boost_1_65_0/boost/predef/library/std/modena.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/library/std/msl.h b/contrib/libboost/boost_1_65_0/boost/predef/library/std/msl.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/library/std/msl.h
rename to contrib/libboost/boost_1_65_0/boost/predef/library/std/msl.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/library/std/roguewave.h b/contrib/libboost/boost_1_65_0/boost/predef/library/std/roguewave.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/library/std/roguewave.h
rename to contrib/libboost/boost_1_65_0/boost/predef/library/std/roguewave.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/library/std/sgi.h b/contrib/libboost/boost_1_65_0/boost/predef/library/std/sgi.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/library/std/sgi.h
rename to contrib/libboost/boost_1_65_0/boost/predef/library/std/sgi.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/library/std/stdcpp3.h b/contrib/libboost/boost_1_65_0/boost/predef/library/std/stdcpp3.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/library/std/stdcpp3.h
rename to contrib/libboost/boost_1_65_0/boost/predef/library/std/stdcpp3.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/library/std/stlport.h b/contrib/libboost/boost_1_65_0/boost/predef/library/std/stlport.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/library/std/stlport.h
rename to contrib/libboost/boost_1_65_0/boost/predef/library/std/stlport.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/library/std/vacpp.h b/contrib/libboost/boost_1_65_0/boost/predef/library/std/vacpp.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/library/std/vacpp.h
rename to contrib/libboost/boost_1_65_0/boost/predef/library/std/vacpp.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/make.h b/contrib/libboost/boost_1_65_0/boost/predef/make.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/make.h
rename to contrib/libboost/boost_1_65_0/boost/predef/make.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os.h b/contrib/libboost/boost_1_65_0/boost/predef/os.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/aix.h b/contrib/libboost/boost_1_65_0/boost/predef/os/aix.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/aix.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/aix.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/amigaos.h b/contrib/libboost/boost_1_65_0/boost/predef/os/amigaos.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/amigaos.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/amigaos.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/android.h b/contrib/libboost/boost_1_65_0/boost/predef/os/android.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/android.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/android.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/beos.h b/contrib/libboost/boost_1_65_0/boost/predef/os/beos.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/beos.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/beos.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/bsd.h b/contrib/libboost/boost_1_65_0/boost/predef/os/bsd.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/bsd.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/bsd.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/bsd/bsdi.h b/contrib/libboost/boost_1_65_0/boost/predef/os/bsd/bsdi.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/bsd/bsdi.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/bsd/bsdi.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/bsd/dragonfly.h b/contrib/libboost/boost_1_65_0/boost/predef/os/bsd/dragonfly.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/bsd/dragonfly.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/bsd/dragonfly.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/bsd/free.h b/contrib/libboost/boost_1_65_0/boost/predef/os/bsd/free.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/bsd/free.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/bsd/free.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/bsd/net.h b/contrib/libboost/boost_1_65_0/boost/predef/os/bsd/net.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/bsd/net.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/bsd/net.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/bsd/open.h b/contrib/libboost/boost_1_65_0/boost/predef/os/bsd/open.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/bsd/open.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/bsd/open.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/cygwin.h b/contrib/libboost/boost_1_65_0/boost/predef/os/cygwin.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/cygwin.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/cygwin.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/haiku.h b/contrib/libboost/boost_1_65_0/boost/predef/os/haiku.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/haiku.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/haiku.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/hpux.h b/contrib/libboost/boost_1_65_0/boost/predef/os/hpux.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/hpux.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/hpux.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/ios.h b/contrib/libboost/boost_1_65_0/boost/predef/os/ios.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/ios.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/ios.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/irix.h b/contrib/libboost/boost_1_65_0/boost/predef/os/irix.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/irix.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/irix.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/linux.h b/contrib/libboost/boost_1_65_0/boost/predef/os/linux.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/linux.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/linux.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/macos.h b/contrib/libboost/boost_1_65_0/boost/predef/os/macos.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/macos.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/macos.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/os400.h b/contrib/libboost/boost_1_65_0/boost/predef/os/os400.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/os400.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/os400.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/qnxnto.h b/contrib/libboost/boost_1_65_0/boost/predef/os/qnxnto.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/qnxnto.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/qnxnto.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/solaris.h b/contrib/libboost/boost_1_65_0/boost/predef/os/solaris.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/solaris.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/solaris.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/unix.h b/contrib/libboost/boost_1_65_0/boost/predef/os/unix.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/unix.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/unix.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/vms.h b/contrib/libboost/boost_1_65_0/boost/predef/os/vms.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/vms.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/vms.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/os/windows.h b/contrib/libboost/boost_1_65_0/boost/predef/os/windows.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/os/windows.h
rename to contrib/libboost/boost_1_65_0/boost/predef/os/windows.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/other.h b/contrib/libboost/boost_1_65_0/boost/predef/other.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/other.h
rename to contrib/libboost/boost_1_65_0/boost/predef/other.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/other/endian.h b/contrib/libboost/boost_1_65_0/boost/predef/other/endian.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/other/endian.h
rename to contrib/libboost/boost_1_65_0/boost/predef/other/endian.h
diff --git a/contrib/libboost/boost_1_65_0/boost/predef/other/workaround.h b/contrib/libboost/boost_1_65_0/boost/predef/other/workaround.h
new file mode 100644
index 00000000000..7167a18ac63
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/predef/other/workaround.h
@@ -0,0 +1,87 @@
+/*
+Copyright Rene Rivera 2017
+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_PREDEF_WORKAROUND_H
+#define BOOST_PREDEF_WORKAROUND_H
+
+/*`
+[heading `BOOST_PREDEF_WORKAROUND`]
+
+``
+BOOST_PREDEF_WORKAROUND(symbol,comp,major,minor,patch)
+``
+
+Usage:
+
+``
+#if BOOST_PREDEF_WORKAROUND(BOOST_COMP_CLANG,<,3,0,0)
+    // Workaround for old clang compilers..
+#endif
+``
+
+Defines a comparison against two version numbers that depends on the definion
+of `BOOST_STRICT_CONFIG`. When `BOOST_STRICT_CONFIG` is defined this will expand
+to a value convertible to `false`. Which has the effect of disabling all code
+conditionally guarded by `BOOST_PREDEF_WORKAROUND`. When `BOOST_STRICT_CONFIG`
+is undefine this expand to test the given `symbol` version value with the
+`comp` comparison against `BOOST_VERSION_NUMBER(major,minor,patch)`.
+*/
+#ifdef BOOST_STRICT_CONFIG
+#   define BOOST_PREDEF_WORKAROUND(symbol, comp, major, minor, patch) (0)
+#else
+#   include <boost/predef/version_number.h>
+#   define BOOST_PREDEF_WORKAROUND(symbol, comp, major, minor, patch) \
+        ( (symbol) != (0) ) && \
+        ( (symbol) comp (BOOST_VERSION_NUMBER( (major) , (minor) , (patch) )) )
+#endif
+
+/*`
+[heading `BOOST_PREDEF_TESTED_AT`]
+
+``
+BOOST_PREDEF_TESTED_AT(symbol,major,minor,patch)
+``
+
+Usage:
+
+``
+#if BOOST_PREDEF_TESTED_AT(BOOST_COMP_CLANG,3,5,0)
+    // Needed for clang, and last checked for 3.5.0.
+#endif
+``
+
+Defines a comparison against two version numbers that depends on the definion
+of `BOOST_STRICT_CONFIG` and `BOOST_DETECT_OUTDATED_WORKAROUNDS`.
+When `BOOST_STRICT_CONFIG` is defined this will expand to a value convertible
+to `false`. Which has the effect of disabling all code
+conditionally guarded by `BOOST_PREDEF_TESTED_AT`. When `BOOST_STRICT_CONFIG`
+is undefined this expand to either:
+
+* A value convertible to `true` when `BOOST_DETECT_OUTDATED_WORKAROUNDS` is not
+  defined.
+* A value convertible `true` when the expansion of
+  `BOOST_PREDEF_WORKAROUND(symbol, <=, major, minor, patch)` is `true` and
+  `BOOST_DETECT_OUTDATED_WORKAROUNDS` is defined.
+* A compile error when the expansion of
+  `BOOST_PREDEF_WORKAROUND(symbol, >, major, minor, patch)` is true and
+  `BOOST_DETECT_OUTDATED_WORKAROUNDS` is defined.
+*/
+#ifdef BOOST_STRICT_CONFIG
+#   define BOOST_PREDEF_TESTED_AT(symbol, major, minor, patch) (0)
+#else
+#   ifdef BOOST_DETECT_OUTDATED_WORKAROUNDS
+#       define BOOST_PREDEF_TESTED_AT(symbol, major, minor, patch) ( \
+            BOOST_PREDEF_WORKAROUND(symbol, <=, major, minor, patch) \
+            ? 1 \
+            : (1%0) )
+#   else
+#       define BOOST_PREDEF_TESTED_AT(symbol, major, minor, patch) \
+            ( (symbol) >= BOOST_VERSION_NUMBER_AVAILABLE )
+#   endif
+#endif
+
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/platform.h b/contrib/libboost/boost_1_65_0/boost/predef/platform.h
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/predef/platform.h
rename to contrib/libboost/boost_1_65_0/boost/predef/platform.h
index c0c8706e8a2..7da697e63dc 100644
--- a/contrib/libboost/boost_1_62_0/boost/predef/platform.h
+++ b/contrib/libboost/boost_1_65_0/boost/predef/platform.h
@@ -16,6 +16,7 @@ http://www.boost.org/LICENSE_1_0.txt)
 #include <boost/predef/platform/windows_store.h>
 #include <boost/predef/platform/windows_phone.h>
 #include <boost/predef/platform/windows_runtime.h>
+#include <boost/predef/platform/ios.h>
 /*#include <boost/predef/platform/.h>*/
 
 #endif
diff --git a/contrib/libboost/boost_1_65_0/boost/predef/platform/ios.h b/contrib/libboost/boost_1_65_0/boost/predef/platform/ios.h
new file mode 100644
index 00000000000..af1c364cf05
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/predef/platform/ios.h
@@ -0,0 +1,58 @@
+/*
+Copyright Ruslan Baratov 2017
+Copyright Rene Rivera 2017
+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_PREDEF_PLAT_IOS_H
+#define BOOST_PREDEF_PLAT_IOS_H
+
+#include <boost/predef/os/ios.h> // BOOST_OS_IOS
+#include <boost/predef/version_number.h> // BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+/*`
+[heading `BOOST_PLAT_IOS_DEVICE`]
+[heading `BOOST_PLAT_IOS_SIMULATOR`]
+
+[table
+    [[__predef_symbol__] [__predef_version__]]
+
+    [[`TARGET_IPHONE_SIMULATOR`] [__predef_detection__]]
+    ]
+ */
+
+#define BOOST_PLAT_IOS_DEVICE BOOST_VERSION_NUMBER_NOT_AVAILABLE
+#define BOOST_PLAT_IOS_SIMULATOR BOOST_VERSION_NUMBER_NOT_AVAILABLE
+
+// https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h
+#if BOOST_OS_IOS
+#    include <TargetConditionals.h>
+#    if TARGET_IPHONE_SIMULATOR == 1
+#        undef BOOST_PLAT_IOS_SIMULATOR
+#        define BOOST_PLAT_IOS_SIMULATOR BOOST_VERSION_NUMBER_AVAILABLE
+#    else
+#        undef BOOST_PLAT_IOS_DEVICE
+#        define BOOST_PLAT_IOS_DEVICE BOOST_VERSION_NUMBER_AVAILABLE
+#    endif
+#endif
+
+#if BOOST_PLAT_IOS_SIMULATOR
+#    define BOOST_PLAT_IOS_SIMULATOR_AVAILABLE
+#    include <boost/predef/detail/platform_detected.h>
+#endif
+
+#if BOOST_PLAT_IOS_DEVICE
+#    define BOOST_PLAT_IOS_DEVICE_AVAILABLE
+#    include <boost/predef/detail/platform_detected.h>
+#endif
+
+#define BOOST_PLAT_IOS_SIMULATOR_NAME "iOS Simulator"
+#define BOOST_PLAT_IOS_DEVICE_NAME "iOS Device"
+
+#endif // BOOST_PREDEF_PLAT_IOS_H
+
+#include <boost/predef/detail/test.h>
+BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_IOS_SIMULATOR,BOOST_PLAT_IOS_SIMULATOR_NAME)
+BOOST_PREDEF_DECLARE_TEST(BOOST_PLAT_IOS_DEVICE,BOOST_PLAT_IOS_DEVICE_NAME)
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/platform/mingw.h b/contrib/libboost/boost_1_65_0/boost/predef/platform/mingw.h
similarity index 96%
rename from contrib/libboost/boost_1_62_0/boost/predef/platform/mingw.h
rename to contrib/libboost/boost_1_65_0/boost/predef/platform/mingw.h
index 64c5837364a..5a1334b47cd 100644
--- a/contrib/libboost/boost_1_62_0/boost/predef/platform/mingw.h
+++ b/contrib/libboost/boost_1_65_0/boost/predef/platform/mingw.h
@@ -5,8 +5,8 @@ Distributed under the Boost Software License, Version 1.0.
 http://www.boost.org/LICENSE_1_0.txt)
 */
 
-#ifndef BOOST_PREDEF_COMPILER_MINGW_H
-#define BOOST_PREDEF_COMPILER_MINGW_H
+#ifndef BOOST_PREDEF_PLAT_MINGW_H
+#define BOOST_PREDEF_PLAT_MINGW_H
 
 #include <boost/predef/version_number.h>
 #include <boost/predef/make.h>
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/platform/windows_desktop.h b/contrib/libboost/boost_1_65_0/boost/predef/platform/windows_desktop.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/platform/windows_desktop.h
rename to contrib/libboost/boost_1_65_0/boost/predef/platform/windows_desktop.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/platform/windows_phone.h b/contrib/libboost/boost_1_65_0/boost/predef/platform/windows_phone.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/platform/windows_phone.h
rename to contrib/libboost/boost_1_65_0/boost/predef/platform/windows_phone.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/platform/windows_runtime.h b/contrib/libboost/boost_1_65_0/boost/predef/platform/windows_runtime.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/platform/windows_runtime.h
rename to contrib/libboost/boost_1_65_0/boost/predef/platform/windows_runtime.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/platform/windows_store.h b/contrib/libboost/boost_1_65_0/boost/predef/platform/windows_store.h
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/predef/platform/windows_store.h
rename to contrib/libboost/boost_1_65_0/boost/predef/platform/windows_store.h
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/version.h b/contrib/libboost/boost_1_65_0/boost/predef/version.h
similarity index 83%
rename from contrib/libboost/boost_1_62_0/boost/predef/version.h
rename to contrib/libboost/boost_1_65_0/boost/predef/version.h
index 8745c94976d..e03469f68d0 100644
--- a/contrib/libboost/boost_1_62_0/boost/predef/version.h
+++ b/contrib/libboost/boost_1_65_0/boost/predef/version.h
@@ -10,6 +10,6 @@ http://www.boost.org/LICENSE_1_0.txt)
 
 #include <boost/predef/version_number.h>
 
-#define BOOST_PREDEF_VERSION BOOST_VERSION_NUMBER(1,4,1)
+#define BOOST_PREDEF_VERSION BOOST_VERSION_NUMBER(1,6,0)
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/predef/version_number.h b/contrib/libboost/boost_1_65_0/boost/predef/version_number.h
similarity index 73%
rename from contrib/libboost/boost_1_62_0/boost/predef/version_number.h
rename to contrib/libboost/boost_1_65_0/boost/predef/version_number.h
index 3903a36b705..44942709c7f 100644
--- a/contrib/libboost/boost_1_62_0/boost/predef/version_number.h
+++ b/contrib/libboost/boost_1_65_0/boost/predef/version_number.h
@@ -1,5 +1,5 @@
 /*
-Copyright Rene Rivera 2005, 2008-2013
+Copyright Rene Rivera 2005-2016
 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)
@@ -50,4 +50,23 @@ Defines standard version numbers, with these properties:
 #define BOOST_VERSION_NUMBER_NOT_AVAILABLE \
     BOOST_VERSION_NUMBER_ZERO
 
+/*`
+``
+BOOST_VERSION_NUMBER_MAJOR(N), BOOST_VERSION_NUMBER_MINOR(N), BOOST_VERSION_NUMBER_PATCH(N)
+``
+
+The macros extract the major, minor, and patch portion from a well formed
+version number resulting in a preprocessor expression in the range of
+\[0,99\] or \[0,99999\] for the major and minor, or patch numbers
+respectively.
+*/
+#define BOOST_VERSION_NUMBER_MAJOR(N) \
+    ( ((N)/10000000)%100 )
+
+#define BOOST_VERSION_NUMBER_MINOR(N) \
+    ( ((N)/100000)%100 )
+
+#define BOOST_VERSION_NUMBER_PATCH(N) \
+    ( (N)%100000 )
+
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/arithmetic.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/arithmetic.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/arithmetic.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/arithmetic.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/arithmetic/add.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/arithmetic/add.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/arithmetic/add.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/arithmetic/add.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/arithmetic/dec.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/arithmetic/dec.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/arithmetic/dec.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/arithmetic/dec.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/arithmetic/detail/div_base.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/arithmetic/detail/div_base.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/arithmetic/detail/div_base.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/arithmetic/detail/div_base.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/arithmetic/div.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/arithmetic/div.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/arithmetic/div.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/arithmetic/div.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/arithmetic/inc.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/arithmetic/inc.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/arithmetic/inc.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/arithmetic/inc.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/arithmetic/mod.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/arithmetic/mod.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/arithmetic/mod.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/arithmetic/mod.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/arithmetic/mul.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/arithmetic/mul.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/arithmetic/mul.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/arithmetic/mul.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/arithmetic/sub.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/arithmetic/sub.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/arithmetic/sub.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/arithmetic/sub.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/array.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/array.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/array.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/array.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/array/data.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/array/data.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/array/data.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/array/data.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/array/detail/get_data.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/array/detail/get_data.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/array/detail/get_data.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/array/detail/get_data.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/array/elem.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/array/elem.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/array/elem.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/array/elem.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/array/enum.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/array/enum.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/array/enum.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/array/enum.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/array/insert.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/array/insert.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/array/insert.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/array/insert.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/array/pop_back.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/array/pop_back.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/array/pop_back.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/array/pop_back.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/array/pop_front.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/array/pop_front.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/array/pop_front.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/array/pop_front.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/array/push_back.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/array/push_back.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/array/push_back.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/array/push_back.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/array/push_front.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/array/push_front.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/array/push_front.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/array/push_front.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/array/remove.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/array/remove.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/array/remove.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/array/remove.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/array/replace.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/array/replace.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/array/replace.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/array/replace.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/array/reverse.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/array/reverse.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/array/reverse.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/array/reverse.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/array/size.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/array/size.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/array/size.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/array/size.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/array/to_list.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/array/to_list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/array/to_list.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/array/to_list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/array/to_seq.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/array/to_seq.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/array/to_seq.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/array/to_seq.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/array/to_tuple.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/array/to_tuple.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/array/to_tuple.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/array/to_tuple.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/assert_msg.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/assert_msg.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/assert_msg.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/assert_msg.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/cat.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/cat.hpp
similarity index 88%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/cat.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/cat.hpp
index 5e52850d48a..52a389270c2 100644
--- a/contrib/libboost/boost_1_62_0/boost/preprocessor/cat.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/preprocessor/cat.hpp
@@ -25,7 +25,7 @@
 #    define BOOST_PP_CAT_OO(par) BOOST_PP_CAT_I ## par
 # endif
 #
-# if ~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC()
+# if (~BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC()) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1700)
 #    define BOOST_PP_CAT_I(a, b) a ## b
 # else
 #    define BOOST_PP_CAT_I(a, b) BOOST_PP_CAT_II(~, a ## b)
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/comma.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/comma.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/comma.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/comma.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/comma_if.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/comma_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/comma_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/comma_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/comparison.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/comparison.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/comparison.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/comparison.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/comparison/equal.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/comparison/equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/comparison/equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/comparison/equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/comparison/greater.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/comparison/greater.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/comparison/greater.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/comparison/greater.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/comparison/greater_equal.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/comparison/greater_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/comparison/greater_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/comparison/greater_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/comparison/less.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/comparison/less.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/comparison/less.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/comparison/less.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/comparison/less_equal.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/comparison/less_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/comparison/less_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/comparison/less_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/comparison/not_equal.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/comparison/not_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/comparison/not_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/comparison/not_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/config/config.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/config/config.hpp
similarity index 80%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/config/config.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/config/config.hpp
index 8be0e475456..28dcdd46429 100644
--- a/contrib/libboost/boost_1_62_0/boost/preprocessor/config/config.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/preprocessor/config/config.hpp
@@ -25,18 +25,16 @@
 # define BOOST_PP_CONFIG_DMC() 0x0040
 #
 # ifndef BOOST_PP_CONFIG_FLAGS
-#    if defined(__GCCXML__)
-#        define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT())
-#    elif defined(__WAVE__)
-#        define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT())
-#    elif defined(__MWERKS__) && __MWERKS__ >= 0x3200
+#    if defined(__GCCXML__) || defined(__WAVE__) || defined(__MWERKS__) && __MWERKS__ >= 0x3200
 #        define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT())
 #    elif defined(__EDG__) || defined(__EDG_VERSION__)
-#        if defined(_MSC_VER) && (defined(__INTELLISENSE__) || __EDG_VERSION__ >= 308)
+#        if defined(_MSC_VER) && !defined(__clang__) && (defined(__INTELLISENSE__) || __EDG_VERSION__ >= 308)
 #            define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_MSVC())
 #        else
 #            define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_EDG() | BOOST_PP_CONFIG_STRICT())
 #        endif
+#    elif defined(_MSC_VER) && defined(__clang__)
+#        define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT())
 #    elif defined(__MWERKS__)
 #        define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_MWCC())
 #    elif defined(__DMC__)
@@ -45,7 +43,7 @@
 #        define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT())
 #    elif defined(__BORLANDC__) || defined(__IBMC__) || defined(__IBMCPP__) || defined(__SUNPRO_CC)
 #        define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_BCC())
-#    elif defined(_MSC_VER) && !defined(__clang__)
+#    elif defined(_MSC_VER)
 #        define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_MSVC())
 #    else
 #        define BOOST_PP_CONFIG_FLAGS() (BOOST_PP_CONFIG_STRICT())
@@ -75,8 +73,10 @@
 #    /* variadic support explicitly disabled for all untested compilers */
 #    if defined __GCCXML__ || defined __CUDACC__ || defined __PATHSCALE__ || defined __DMC__ || defined __CODEGEARC__ || defined __BORLANDC__ || defined __MWERKS__ || ( defined __SUNPRO_CC && __SUNPRO_CC < 0x5120 ) || defined __HP_aCC && !defined __EDG__ || defined __MRC__ || defined __SC__ || defined __IBMCPP__ || defined __PGI
 #        define BOOST_PP_VARIADICS 0
-#    /* VC++ (C/C++) */
-#    elif defined _MSC_VER && _MSC_VER >= 1400 && (!defined __EDG__ || defined(__INTELLISENSE__)) && !defined __clang__
+#    elif defined(_MSC_VER) && defined(__clang__)
+#        define BOOST_PP_VARIADICS 1
+#    /* VC++ (C/C++) and Intel C++ Compiler >= 17.0 with MSVC */
+#    elif defined _MSC_VER && _MSC_VER >= 1400 && (!defined __EDG__ || defined(__INTELLISENSE__) || defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1700)
 #        define BOOST_PP_VARIADICS 1
 #        undef BOOST_PP_VARIADICS_MSVC
 #        define BOOST_PP_VARIADICS_MSVC 1
@@ -92,7 +92,7 @@
 # elif !BOOST_PP_VARIADICS + 1 < 2
 #    undef BOOST_PP_VARIADICS
 #    define BOOST_PP_VARIADICS 1
-#    if defined _MSC_VER && _MSC_VER >= 1400 && (defined(__INTELLISENSE__) || !(defined __EDG__ || defined __GCCXML__ || defined __CUDACC__ || defined __PATHSCALE__ || defined __clang__ || defined __DMC__ || defined __CODEGEARC__ || defined __BORLANDC__ || defined __MWERKS__ || defined __SUNPRO_CC || defined __HP_aCC || defined __MRC__ || defined __SC__ || defined __IBMCPP__ || defined __PGI))
+#    if defined _MSC_VER && _MSC_VER >= 1400 && !defined(__clang__) && (defined(__INTELLISENSE__) || (defined(__INTEL_COMPILER) && __INTEL_COMPILER >= 1700) || !(defined __EDG__ || defined __GCCXML__ || defined __CUDACC__ || defined __PATHSCALE__ || defined __DMC__ || defined __CODEGEARC__ || defined __BORLANDC__ || defined __MWERKS__ || defined __SUNPRO_CC || defined __HP_aCC || defined __MRC__ || defined __SC__ || defined __IBMCPP__ || defined __PGI))
 #        undef BOOST_PP_VARIADICS_MSVC
 #        define BOOST_PP_VARIADICS_MSVC 1
 #    endif
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/config/limits.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/config/limits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/config/limits.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/config/limits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/control.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/control.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/control.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/control.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/control/deduce_d.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/control/deduce_d.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/control/deduce_d.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/control/deduce_d.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/control/detail/dmc/while.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/control/detail/dmc/while.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/control/detail/dmc/while.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/control/detail/dmc/while.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/control/detail/edg/while.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/control/detail/edg/while.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/control/detail/edg/while.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/control/detail/edg/while.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/control/detail/msvc/while.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/control/detail/msvc/while.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/control/detail/msvc/while.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/control/detail/msvc/while.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/control/detail/while.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/control/detail/while.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/control/detail/while.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/control/detail/while.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/control/expr_if.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/control/expr_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/control/expr_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/control/expr_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/control/expr_iif.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/control/expr_iif.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/control/expr_iif.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/control/expr_iif.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/control/if.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/control/if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/control/if.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/control/if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/control/iif.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/control/iif.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/control/iif.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/control/iif.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/control/while.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/control/while.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/control/while.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/control/while.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/debug.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/debug.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/debug.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/debug.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/debug/assert.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/debug/assert.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/debug/assert.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/debug/assert.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/debug/error.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/debug/error.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/debug/error.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/debug/error.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/debug/line.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/debug/line.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/debug/line.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/debug/line.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/dec.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/dec.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/dec.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/dec.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/detail/auto_rec.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/detail/auto_rec.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/detail/auto_rec.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/detail/auto_rec.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/detail/check.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/detail/check.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/detail/check.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/detail/check.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/detail/dmc/auto_rec.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/detail/dmc/auto_rec.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/detail/dmc/auto_rec.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/detail/dmc/auto_rec.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/detail/is_binary.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/detail/is_binary.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/detail/is_binary.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/detail/is_binary.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/detail/is_nullary.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/detail/is_nullary.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/detail/is_nullary.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/detail/is_nullary.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/detail/is_unary.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/detail/is_unary.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/detail/is_unary.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/detail/is_unary.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/detail/null.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/detail/null.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/detail/null.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/detail/null.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/detail/split.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/detail/split.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/detail/split.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/detail/split.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/empty.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/empty.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/empty.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/empty.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/enum.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/enum.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/enum.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/enum.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/enum_params.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/enum_params.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/enum_params.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/enum_params.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/enum_params_with_a_default.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/enum_params_with_a_default.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/enum_params_with_a_default.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/enum_params_with_a_default.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/enum_params_with_defaults.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/enum_params_with_defaults.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/enum_params_with_defaults.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/enum_params_with_defaults.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/enum_shifted.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/enum_shifted.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/enum_shifted.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/enum_shifted.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/enum_shifted_params.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/enum_shifted_params.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/enum_shifted_params.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/enum_shifted_params.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/expand.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/expand.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/expand.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/expand.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/expr_if.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/expr_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/expr_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/expr_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/facilities.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/facilities.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/facilities.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/facilities.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/apply.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/apply.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/apply.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/apply.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/detail/is_empty.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/detail/is_empty.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/detail/is_empty.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/detail/is_empty.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/empty.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/empty.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/empty.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/empty.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/expand.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/expand.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/expand.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/expand.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/identity.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/identity.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/identity.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/identity.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/intercept.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/intercept.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/intercept.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/intercept.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/is_1.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/is_1.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/is_1.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/is_1.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/is_empty.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/is_empty.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/is_empty.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/is_empty.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/is_empty_or_1.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/is_empty_or_1.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/is_empty_or_1.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/is_empty_or_1.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/is_empty_variadic.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/is_empty_variadic.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/is_empty_variadic.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/is_empty_variadic.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/overload.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/overload.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/facilities/overload.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/facilities/overload.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/for.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/for.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/for.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/for.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/identity.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/identity.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/identity.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/identity.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/if.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/if.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/inc.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/inc.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/inc.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/inc.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iterate.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iterate.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iterate.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iterate.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/bounds/lower1.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/bounds/lower1.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/bounds/lower1.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/bounds/lower1.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/bounds/lower2.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/bounds/lower2.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/bounds/lower2.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/bounds/lower2.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/bounds/lower3.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/bounds/lower3.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/bounds/lower3.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/bounds/lower3.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/bounds/lower4.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/bounds/lower4.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/bounds/lower4.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/bounds/lower4.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/bounds/lower5.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/bounds/lower5.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/bounds/lower5.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/bounds/lower5.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/bounds/upper1.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/bounds/upper1.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/bounds/upper1.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/bounds/upper1.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/bounds/upper2.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/bounds/upper2.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/bounds/upper2.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/bounds/upper2.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/bounds/upper3.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/bounds/upper3.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/bounds/upper3.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/bounds/upper3.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/bounds/upper4.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/bounds/upper4.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/bounds/upper4.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/bounds/upper4.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/bounds/upper5.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/bounds/upper5.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/bounds/upper5.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/bounds/upper5.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/finish.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/finish.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/finish.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/finish.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/iter/forward1.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/iter/forward1.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/iter/forward1.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/iter/forward1.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/iter/forward2.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/iter/forward2.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/iter/forward2.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/iter/forward2.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/iter/forward3.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/iter/forward3.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/iter/forward3.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/iter/forward3.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/iter/forward4.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/iter/forward4.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/iter/forward4.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/iter/forward4.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/iter/forward5.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/iter/forward5.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/iter/forward5.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/iter/forward5.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/iter/reverse1.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/iter/reverse1.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/iter/reverse1.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/iter/reverse1.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/iter/reverse2.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/iter/reverse2.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/iter/reverse2.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/iter/reverse2.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/iter/reverse3.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/iter/reverse3.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/iter/reverse3.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/iter/reverse3.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/iter/reverse4.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/iter/reverse4.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/iter/reverse4.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/iter/reverse4.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/iter/reverse5.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/iter/reverse5.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/iter/reverse5.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/iter/reverse5.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/local.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/local.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/local.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/local.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/rlocal.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/rlocal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/rlocal.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/rlocal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/self.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/self.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/self.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/self.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/start.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/start.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/detail/start.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/detail/start.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/iterate.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/iterate.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/iterate.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/iterate.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/local.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/local.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/local.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/local.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/self.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/self.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/iteration/self.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/iteration/self.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/library.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/library.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/library.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/library.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/limits.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/limits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/limits.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/limits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/adt.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/adt.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/adt.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/adt.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/append.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/append.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/append.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/append.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/at.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/at.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/at.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/at.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/cat.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/cat.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/cat.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/cat.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/detail/dmc/fold_left.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/detail/dmc/fold_left.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/detail/dmc/fold_left.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/detail/dmc/fold_left.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/detail/edg/fold_left.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/detail/edg/fold_left.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/detail/edg/fold_left.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/detail/edg/fold_left.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/detail/edg/fold_right.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/detail/edg/fold_right.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/detail/edg/fold_right.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/detail/edg/fold_right.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/detail/fold_left.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/detail/fold_left.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/detail/fold_left.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/detail/fold_left.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/detail/fold_right.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/detail/fold_right.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/detail/fold_right.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/detail/fold_right.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/enum.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/enum.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/enum.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/enum.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/filter.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/filter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/filter.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/filter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/first_n.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/first_n.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/first_n.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/first_n.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/fold_left.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/fold_left.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/fold_left.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/fold_left.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/fold_right.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/fold_right.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/fold_right.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/fold_right.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/for_each.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/for_each.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/for_each.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/for_each.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/for_each_i.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/for_each_i.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/for_each_i.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/for_each_i.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/for_each_product.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/for_each_product.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/for_each_product.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/for_each_product.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/rest_n.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/rest_n.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/rest_n.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/rest_n.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/reverse.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/reverse.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/reverse.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/reverse.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/size.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/size.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/size.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/size.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/to_array.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/to_array.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/to_array.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/to_array.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/to_seq.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/to_seq.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/to_seq.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/to_seq.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/to_tuple.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/to_tuple.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/to_tuple.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/to_tuple.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/list/transform.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/list/transform.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/list/transform.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/list/transform.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/logical.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/logical.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/logical.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/logical.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/logical/and.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/logical/and.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/logical/and.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/logical/and.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/logical/bitand.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/logical/bitand.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/logical/bitand.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/logical/bitand.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/logical/bitnor.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/logical/bitnor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/logical/bitnor.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/logical/bitnor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/logical/bitor.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/logical/bitor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/logical/bitor.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/logical/bitor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/logical/bitxor.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/logical/bitxor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/logical/bitxor.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/logical/bitxor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/logical/bool.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/logical/bool.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/logical/bool.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/logical/bool.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/logical/compl.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/logical/compl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/logical/compl.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/logical/compl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/logical/nor.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/logical/nor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/logical/nor.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/logical/nor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/logical/not.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/logical/not.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/logical/not.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/logical/not.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/logical/or.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/logical/or.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/logical/or.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/logical/or.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/logical/xor.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/logical/xor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/logical/xor.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/logical/xor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/max.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/max.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/max.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/max.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/min.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/min.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/min.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/min.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/punctuation.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/punctuation.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/punctuation.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/punctuation.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/punctuation/comma.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/punctuation/comma.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/punctuation/comma.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/punctuation/comma.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/punctuation/comma_if.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/punctuation/comma_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/punctuation/comma_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/punctuation/comma_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/punctuation/detail/is_begin_parens.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/punctuation/detail/is_begin_parens.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/punctuation/detail/is_begin_parens.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/punctuation/detail/is_begin_parens.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/punctuation/is_begin_parens.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/punctuation/is_begin_parens.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/punctuation/is_begin_parens.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/punctuation/is_begin_parens.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/punctuation/paren.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/punctuation/paren.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/punctuation/paren.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/punctuation/paren.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/punctuation/paren_if.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/punctuation/paren_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/punctuation/paren_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/punctuation/paren_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/punctuation/remove_parens.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/punctuation/remove_parens.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/punctuation/remove_parens.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/punctuation/remove_parens.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repeat.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repeat.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repeat.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repeat.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repeat_2nd.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repeat_2nd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repeat_2nd.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repeat_2nd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repeat_3rd.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repeat_3rd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repeat_3rd.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repeat_3rd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repeat_from_to.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repeat_from_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repeat_from_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repeat_from_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repeat_from_to_2nd.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repeat_from_to_2nd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repeat_from_to_2nd.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repeat_from_to_2nd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repeat_from_to_3rd.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repeat_from_to_3rd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repeat_from_to_3rd.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repeat_from_to_3rd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/deduce_r.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/deduce_r.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/deduce_r.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/deduce_r.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/deduce_z.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/deduce_z.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/deduce_z.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/deduce_z.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/detail/dmc/for.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/detail/dmc/for.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/detail/dmc/for.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/detail/dmc/for.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/detail/edg/for.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/detail/edg/for.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/detail/edg/for.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/detail/edg/for.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/detail/for.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/detail/for.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/detail/for.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/detail/for.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/detail/msvc/for.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/detail/msvc/for.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/detail/msvc/for.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/detail/msvc/for.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum_binary_params.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum_binary_params.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum_binary_params.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum_binary_params.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum_params.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum_params.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum_params.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum_params.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum_params_with_a_default.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum_params_with_a_default.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum_params_with_a_default.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum_params_with_a_default.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum_params_with_defaults.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum_params_with_defaults.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum_params_with_defaults.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum_params_with_defaults.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum_shifted.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum_shifted.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum_shifted.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum_shifted.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum_shifted_binary_params.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum_shifted_binary_params.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum_shifted_binary_params.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum_shifted_binary_params.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum_shifted_params.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum_shifted_params.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum_shifted_params.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum_shifted_params.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum_trailing.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum_trailing.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum_trailing.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum_trailing.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum_trailing_binary_params.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum_trailing_binary_params.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum_trailing_binary_params.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum_trailing_binary_params.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum_trailing_params.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum_trailing_params.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/enum_trailing_params.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/enum_trailing_params.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/for.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/for.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/for.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/for.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/repeat.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/repeat.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/repeat.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/repeat.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/repeat_from_to.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/repeat_from_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/repetition/repeat_from_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/repetition/repeat_from_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/selection.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/selection.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/selection.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/selection.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/selection/max.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/selection/max.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/selection/max.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/selection/max.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/selection/min.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/selection/min.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/selection/min.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/selection/min.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/cat.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/cat.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/cat.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/cat.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/detail/binary_transform.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/detail/binary_transform.hpp
similarity index 78%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/detail/binary_transform.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/detail/binary_transform.hpp
index 70897b09cfb..08b5f9de4dc 100644
--- a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/detail/binary_transform.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/detail/binary_transform.hpp
@@ -30,14 +30,13 @@
 # endif
 # if BOOST_PP_VARIADICS
 #    if BOOST_PP_VARIADICS_MSVC
-#		define BOOST_PP_SEQ_BINARY_TRANSFORM_GET_REM(...) \
-			BOOST_PP_VARIADIC_IS_SINGLE_RETURN(BOOST_PP_REM_CAT,BOOST_PP_REM,__VA_ARGS__) \
-		/**/
+#		define BOOST_PP_SEQ_BINARY_TRANSFORM_REM(data) data
+#       define BOOST_PP_SEQ_BINARY_TRANSFORM_A(...) (BOOST_PP_SEQ_BINARY_TRANSFORM_REM, __VA_ARGS__)() BOOST_PP_SEQ_BINARY_TRANSFORM_B
+#       define BOOST_PP_SEQ_BINARY_TRANSFORM_B(...) (BOOST_PP_SEQ_BINARY_TRANSFORM_REM, __VA_ARGS__)() BOOST_PP_SEQ_BINARY_TRANSFORM_A
 #	 else
-#		define BOOST_PP_SEQ_BINARY_TRANSFORM_GET_REM(...) BOOST_PP_REM
+#       define BOOST_PP_SEQ_BINARY_TRANSFORM_A(...) (BOOST_PP_REM, __VA_ARGS__)() BOOST_PP_SEQ_BINARY_TRANSFORM_B
+#       define BOOST_PP_SEQ_BINARY_TRANSFORM_B(...) (BOOST_PP_REM, __VA_ARGS__)() BOOST_PP_SEQ_BINARY_TRANSFORM_A
 #	 endif
-#    define BOOST_PP_SEQ_BINARY_TRANSFORM_A(...) (BOOST_PP_SEQ_BINARY_TRANSFORM_GET_REM(__VA_ARGS__), __VA_ARGS__)() BOOST_PP_SEQ_BINARY_TRANSFORM_B
-#    define BOOST_PP_SEQ_BINARY_TRANSFORM_B(...) (BOOST_PP_SEQ_BINARY_TRANSFORM_GET_REM(__VA_ARGS__), __VA_ARGS__)() BOOST_PP_SEQ_BINARY_TRANSFORM_A
 # else
 #    define BOOST_PP_SEQ_BINARY_TRANSFORM_A(e) (BOOST_PP_REM, e)() BOOST_PP_SEQ_BINARY_TRANSFORM_B
 #    define BOOST_PP_SEQ_BINARY_TRANSFORM_B(e) (BOOST_PP_REM, e)() BOOST_PP_SEQ_BINARY_TRANSFORM_A
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/detail/is_empty.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/detail/is_empty.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/detail/is_empty.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/detail/is_empty.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/detail/split.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/detail/split.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/detail/split.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/detail/split.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/detail/to_list_msvc.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/detail/to_list_msvc.hpp
new file mode 100644
index 00000000000..2599c0014ac
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/detail/to_list_msvc.hpp
@@ -0,0 +1,55 @@
+# /* **************************************************************************
+#  *                                                                          *
+#  *     (C) Copyright Edward Diener 2016.                                    *
+#  *     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_SEQ_DETAIL_TO_LIST_MSVC_HPP
+# define BOOST_PREPROCESSOR_SEQ_DETAIL_TO_LIST_MSVC_HPP
+#
+# include <boost/preprocessor/config/config.hpp>
+#
+# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC()
+#
+# include <boost/preprocessor/cat.hpp>
+# include <boost/preprocessor/arithmetic/dec.hpp>
+# include <boost/preprocessor/control/while.hpp>
+# include <boost/preprocessor/tuple/elem.hpp>
+#
+# define BOOST_PP_SEQ_DETAIL_TO_LIST_MSVC_STATE_RESULT(state) \
+    BOOST_PP_TUPLE_ELEM(2, 0, state) \
+/**/
+# define BOOST_PP_SEQ_DETAIL_TO_LIST_MSVC_STATE_SIZE(state) \
+    BOOST_PP_TUPLE_ELEM(2, 1, state) \
+/**/
+# define BOOST_PP_SEQ_DETAIL_TO_LIST_MSVC_PRED(d,state) \
+    BOOST_PP_SEQ_DETAIL_TO_LIST_MSVC_STATE_SIZE(state) \
+/**/
+# define BOOST_PP_SEQ_DETAIL_TO_LIST_MSVC_OP(d,state) \
+    ( \
+    BOOST_PP_CAT(BOOST_PP_SEQ_DETAIL_TO_LIST_MSVC_STATE_RESULT(state),), \
+    BOOST_PP_DEC(BOOST_PP_SEQ_DETAIL_TO_LIST_MSVC_STATE_SIZE(state)) \
+    ) \
+/**/
+#
+# /* BOOST_PP_SEQ_DETAIL_TO_LIST_MSVC */
+#
+# define BOOST_PP_SEQ_DETAIL_TO_LIST_MSVC(result,seqsize) \
+    BOOST_PP_SEQ_DETAIL_TO_LIST_MSVC_STATE_RESULT \
+        ( \
+        BOOST_PP_WHILE \
+            ( \
+            BOOST_PP_SEQ_DETAIL_TO_LIST_MSVC_PRED, \
+            BOOST_PP_SEQ_DETAIL_TO_LIST_MSVC_OP, \
+            (result,seqsize) \
+            ) \
+        ) \
+/**/
+# endif // BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC()
+#
+# endif // BOOST_PREPROCESSOR_SEQ_DETAIL_TO_LIST_MSVC_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/elem.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/elem.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/elem.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/elem.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/enum.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/enum.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/enum.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/enum.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/filter.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/filter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/filter.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/filter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/first_n.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/first_n.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/first_n.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/first_n.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/fold_left.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/fold_left.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/fold_left.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/fold_left.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/fold_right.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/fold_right.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/fold_right.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/fold_right.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/for_each.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/for_each.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/for_each.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/for_each.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/for_each_i.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/for_each_i.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/for_each_i.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/for_each_i.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/for_each_product.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/for_each_product.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/for_each_product.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/for_each_product.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/insert.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/insert.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/insert.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/insert.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/pop_back.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/pop_back.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/pop_back.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/pop_back.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/pop_front.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/pop_front.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/pop_front.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/pop_front.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/push_back.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/push_back.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/push_back.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/push_back.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/push_front.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/push_front.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/push_front.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/push_front.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/remove.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/remove.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/remove.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/remove.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/replace.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/replace.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/replace.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/replace.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/rest_n.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/rest_n.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/rest_n.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/rest_n.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/reverse.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/reverse.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/reverse.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/reverse.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/seq.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/seq.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/seq.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/seq.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/size.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/size.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/size.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/size.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/subseq.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/subseq.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/subseq.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/subseq.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/to_array.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/to_array.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/to_array.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/to_array.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/to_list.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/to_list.hpp
similarity index 80%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/to_list.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/to_list.hpp
index fa0421bcc8c..ed8948dbd40 100644
--- a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/to_list.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/to_list.hpp
@@ -19,7 +19,19 @@
 #
 # /* BOOST_PP_SEQ_TO_LIST */
 #
+# if BOOST_PP_CONFIG_FLAGS() & BOOST_PP_CONFIG_MSVC()
+# include <boost/preprocessor/seq/size.hpp>
+# include <boost/preprocessor/seq/detail/to_list_msvc.hpp>
+# define BOOST_PP_SEQ_TO_LIST(seq) \
+    BOOST_PP_SEQ_DETAIL_TO_LIST_MSVC \
+        ( \
+        BOOST_PP_SEQ_TO_LIST_I(BOOST_PP_SEQ_BINARY_TRANSFORM(seq)), \
+        BOOST_PP_SEQ_SIZE(seq) \
+        ) \
+/**/
+# else
 # define BOOST_PP_SEQ_TO_LIST(seq) BOOST_PP_SEQ_TO_LIST_I(BOOST_PP_SEQ_BINARY_TRANSFORM(seq))
+# endif
 # define BOOST_PP_SEQ_TO_LIST_I(bseq) BOOST_PP_SEQ_TO_LIST_A bseq BOOST_PP_NIL BOOST_PP_SEQ_TO_LIST_B bseq
 # define BOOST_PP_SEQ_TO_LIST_A(m, e) m(BOOST_PP_LPAREN() e BOOST_PP_COMMA() BOOST_PP_SEQ_TO_LIST_A_ID)
 # define BOOST_PP_SEQ_TO_LIST_A_ID() BOOST_PP_SEQ_TO_LIST_A
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/to_tuple.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/to_tuple.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/to_tuple.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/to_tuple.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/transform.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/transform.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/transform.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/transform.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/seq/variadic_seq_to_seq.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/seq/variadic_seq_to_seq.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/seq/variadic_seq_to_seq.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/seq/variadic_seq_to_seq.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/slot.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/slot.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/slot.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/slot.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/slot/counter.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/slot/counter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/slot/counter.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/slot/counter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/slot/detail/counter.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/slot/detail/counter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/slot/detail/counter.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/slot/detail/counter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/slot/detail/def.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/slot/detail/def.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/slot/detail/def.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/slot/detail/def.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/slot/detail/shared.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/slot/detail/shared.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/slot/detail/shared.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/slot/detail/shared.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/slot/detail/slot1.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/slot/detail/slot1.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/slot/detail/slot1.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/slot/detail/slot1.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/slot/detail/slot2.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/slot/detail/slot2.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/slot/detail/slot2.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/slot/detail/slot2.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/slot/detail/slot3.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/slot/detail/slot3.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/slot/detail/slot3.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/slot/detail/slot3.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/slot/detail/slot4.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/slot/detail/slot4.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/slot/detail/slot4.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/slot/detail/slot4.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/slot/detail/slot5.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/slot/detail/slot5.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/slot/detail/slot5.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/slot/detail/slot5.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/slot/slot.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/slot/slot.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/slot/slot.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/slot/slot.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/stringize.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/stringize.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/stringize.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/stringize.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/tuple.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/tuple.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/tuple.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/tuple.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/detail/is_single_return.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/detail/is_single_return.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/detail/is_single_return.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/detail/is_single_return.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/eat.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/eat.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/eat.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/eat.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/elem.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/elem.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/elem.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/elem.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/enum.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/enum.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/enum.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/enum.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/insert.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/insert.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/insert.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/insert.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/pop_back.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/pop_back.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/pop_back.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/pop_back.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/pop_front.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/pop_front.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/pop_front.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/pop_front.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/push_back.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/push_back.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/push_back.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/push_back.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/push_front.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/push_front.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/push_front.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/push_front.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/rem.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/rem.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/rem.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/rem.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/remove.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/remove.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/remove.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/remove.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/replace.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/replace.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/replace.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/replace.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/reverse.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/reverse.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/reverse.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/reverse.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/size.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/size.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/size.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/size.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/to_array.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/to_array.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/to_array.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/to_array.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/to_list.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/to_list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/to_list.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/to_list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/to_seq.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/to_seq.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/tuple/to_seq.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/tuple/to_seq.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/variadic.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/variadic.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/variadic.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/variadic.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/variadic/detail/is_single_return.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/variadic/detail/is_single_return.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/variadic/detail/is_single_return.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/variadic/detail/is_single_return.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/variadic/elem.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/variadic/elem.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/variadic/elem.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/variadic/elem.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/variadic/size.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/variadic/size.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/variadic/size.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/variadic/size.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/variadic/to_array.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/variadic/to_array.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/variadic/to_array.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/variadic/to_array.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/variadic/to_list.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/variadic/to_list.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/variadic/to_list.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/variadic/to_list.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/variadic/to_seq.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/variadic/to_seq.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/variadic/to_seq.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/variadic/to_seq.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/variadic/to_tuple.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/variadic/to_tuple.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/variadic/to_tuple.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/variadic/to_tuple.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/while.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/while.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/while.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/while.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/preprocessor/wstringize.hpp b/contrib/libboost/boost_1_65_0/boost/preprocessor/wstringize.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/preprocessor/wstringize.hpp
rename to contrib/libboost/boost_1_65_0/boost/preprocessor/wstringize.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/program_options.hpp b/contrib/libboost/boost_1_65_0/boost/program_options.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/program_options.hpp
rename to contrib/libboost/boost_1_65_0/boost/program_options.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/program_options/cmdline.hpp b/contrib/libboost/boost_1_65_0/boost/program_options/cmdline.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/program_options/cmdline.hpp
rename to contrib/libboost/boost_1_65_0/boost/program_options/cmdline.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/program_options/config.hpp b/contrib/libboost/boost_1_65_0/boost/program_options/config.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/program_options/config.hpp
rename to contrib/libboost/boost_1_65_0/boost/program_options/config.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/program_options/detail/cmdline.hpp b/contrib/libboost/boost_1_65_0/boost/program_options/detail/cmdline.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/program_options/detail/cmdline.hpp
rename to contrib/libboost/boost_1_65_0/boost/program_options/detail/cmdline.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/program_options/detail/config_file.hpp b/contrib/libboost/boost_1_65_0/boost/program_options/detail/config_file.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/program_options/detail/config_file.hpp
rename to contrib/libboost/boost_1_65_0/boost/program_options/detail/config_file.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/program_options/detail/convert.hpp b/contrib/libboost/boost_1_65_0/boost/program_options/detail/convert.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/program_options/detail/convert.hpp
rename to contrib/libboost/boost_1_65_0/boost/program_options/detail/convert.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/program_options/detail/parsers.hpp b/contrib/libboost/boost_1_65_0/boost/program_options/detail/parsers.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/program_options/detail/parsers.hpp
rename to contrib/libboost/boost_1_65_0/boost/program_options/detail/parsers.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/program_options/detail/utf8_codecvt_facet.hpp b/contrib/libboost/boost_1_65_0/boost/program_options/detail/utf8_codecvt_facet.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/program_options/detail/utf8_codecvt_facet.hpp
rename to contrib/libboost/boost_1_65_0/boost/program_options/detail/utf8_codecvt_facet.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/program_options/detail/value_semantic.hpp b/contrib/libboost/boost_1_65_0/boost/program_options/detail/value_semantic.hpp
similarity index 92%
rename from contrib/libboost/boost_1_62_0/boost/program_options/detail/value_semantic.hpp
rename to contrib/libboost/boost_1_65_0/boost/program_options/detail/value_semantic.hpp
index 978a38a86e2..9531339a34e 100644
--- a/contrib/libboost/boost_1_62_0/boost/program_options/detail/value_semantic.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/program_options/detail/value_semantic.hpp
@@ -8,6 +8,9 @@
 
 #include <boost/throw_exception.hpp>
 
+// forward declaration
+namespace boost { template<class T> class optional; }
+
 namespace boost { namespace program_options { 
 
     extern BOOST_PROGRAM_OPTIONS_DECL std::string arg;
@@ -152,6 +155,20 @@ namespace boost { namespace program_options {
         }
     }
 
+    /** Validates optional arguments. */
+    template<class T, class charT>
+    void validate(boost::any& v,
+                  const std::vector<std::basic_string<charT> >& s,
+                  boost::optional<T>*,
+                  int)
+    {
+        validators::check_first_occurrence(v);
+        validators::get_single_string(s);
+        boost::any a;
+        validate(a, s, (T*)0, 0);
+        v = boost::any(boost::optional<T>(boost::any_cast<T>(a)));
+    }
+
     template<class T, class charT>
     void 
     typed_value<T, charT>::
diff --git a/contrib/libboost/boost_1_62_0/boost/program_options/environment_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/program_options/environment_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/program_options/environment_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/program_options/environment_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/program_options/eof_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/program_options/eof_iterator.hpp
similarity index 96%
rename from contrib/libboost/boost_1_62_0/boost/program_options/eof_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/program_options/eof_iterator.hpp
index 4eeef0e9370..5e53df5b812 100644
--- a/contrib/libboost/boost_1_62_0/boost/program_options/eof_iterator.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/program_options/eof_iterator.hpp
@@ -68,7 +68,11 @@ namespace boost {
 
 
     private: // iterator core operations
-        friend class iterator_core_access;
+#ifdef __DCC__ 
+        friend class boost::iterator_core_access; 
+#else 
+        friend class iterator_core_access; 	 
+#endif
 
         void increment()
         {
diff --git a/contrib/libboost/boost_1_62_0/boost/program_options/errors.hpp b/contrib/libboost/boost_1_65_0/boost/program_options/errors.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/program_options/errors.hpp
rename to contrib/libboost/boost_1_65_0/boost/program_options/errors.hpp
index f31defbd369..ba83d88f40d 100644
--- a/contrib/libboost/boost_1_62_0/boost/program_options/errors.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/program_options/errors.hpp
@@ -26,7 +26,12 @@ namespace boost { namespace program_options {
     inline std::string strip_prefixes(const std::string& text)
     {
         // "--foo-bar" -> "foo-bar"
-        return text.substr(text.find_first_not_of("-/"));
+        std::string::size_type i = text.find_first_not_of("-/");
+        if (i == std::string::npos) {
+            return text;
+        } else {
+            return text.substr(i);
+        }
     }
 
     /** Base class for all errors in the library. */
@@ -169,7 +174,7 @@ namespace boost { namespace program_options {
         virtual void set_option_name(const std::string& option_name)
         {           set_substitute("option", option_name);}
 
-        std::string get_option_name() const throw()
+        std::string get_option_name() const
         {           return get_canonical_option_name();         }
 
         void set_original_token(const std::string& original_token)
diff --git a/contrib/libboost/boost_1_62_0/boost/program_options/option.hpp b/contrib/libboost/boost_1_65_0/boost/program_options/option.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/program_options/option.hpp
rename to contrib/libboost/boost_1_65_0/boost/program_options/option.hpp
index 1fa6a192344..427678fa786 100644
--- a/contrib/libboost/boost_1_62_0/boost/program_options/option.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/program_options/option.hpp
@@ -31,6 +31,7 @@ namespace boost { namespace program_options {
         basic_option(const std::string& xstring_key, 
                const std::vector< std::string> &xvalue)
         : string_key(xstring_key)
+        , position_key(-1)
         , value(xvalue)
         , unregistered(false)
         , case_insensitive(false)
diff --git a/contrib/libboost/boost_1_62_0/boost/program_options/options_description.hpp b/contrib/libboost/boost_1_65_0/boost/program_options/options_description.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/program_options/options_description.hpp
rename to contrib/libboost/boost_1_65_0/boost/program_options/options_description.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/program_options/parsers.hpp b/contrib/libboost/boost_1_65_0/boost/program_options/parsers.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/program_options/parsers.hpp
rename to contrib/libboost/boost_1_65_0/boost/program_options/parsers.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/program_options/positional_options.hpp b/contrib/libboost/boost_1_65_0/boost/program_options/positional_options.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/program_options/positional_options.hpp
rename to contrib/libboost/boost_1_65_0/boost/program_options/positional_options.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/program_options/value_semantic.hpp b/contrib/libboost/boost_1_65_0/boost/program_options/value_semantic.hpp
similarity index 96%
rename from contrib/libboost/boost_1_62_0/boost/program_options/value_semantic.hpp
rename to contrib/libboost/boost_1_65_0/boost/program_options/value_semantic.hpp
index be3f10801e1..ac9dbc663b5 100644
--- a/contrib/libboost/boost_1_62_0/boost/program_options/value_semantic.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/program_options/value_semantic.hpp
@@ -38,11 +38,6 @@ namespace boost { namespace program_options {
             should be present on the command line. */
         virtual unsigned max_tokens() const = 0;
 
-        /** Returns true if the option should only take adjacent token,
-            not one from further command-line arguments.
-        */
-        virtual bool adjacent_tokens_only() const = 0;
-
         /** Returns true if values from different sources should be composed.
             Otherwise, value from the first source is used and values from
             other sources are discarded.
@@ -53,7 +48,7 @@ namespace boost { namespace program_options {
 
         */
         virtual bool is_required() const = 0;
-
+        
         /** Parses a group of tokens that specify a value of option.
             Stores the result in 'value_store', using whatever representation
             is desired. May be be called several times if value of the same
@@ -139,7 +134,6 @@ namespace boost { namespace program_options {
 
         unsigned min_tokens() const;
         unsigned max_tokens() const;
-        bool adjacent_tokens_only() const { return false; }
 
         bool is_composing() const { return false; }
 
@@ -224,10 +218,7 @@ namespace boost { namespace program_options {
 
         /** Specifies an implicit value, which will be used
             if the option is given, but without an adjacent value.
-            Using this implies that an explicit value is optional, but if
-            given, must be strictly adjacent to the option, i.e.: '-ovalue'
-            or '--option=value'.  Giving '-o' or '--option' will cause the
-            implicit value to be applied.
+            Using this implies that an explicit value is optional,
         */
         typed_value* implicit_value(const T &v)
         {
@@ -331,8 +322,6 @@ namespace boost { namespace program_options {
             }
         }
 
-        bool adjacent_tokens_only() const { return !m_implicit_value.empty(); }
-
         bool is_required() const { return m_required; }
 
         /** Creates an instance of the 'validator' class and calls
diff --git a/contrib/libboost/boost_1_62_0/boost/program_options/variables_map.hpp b/contrib/libboost/boost_1_65_0/boost/program_options/variables_map.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/program_options/variables_map.hpp
rename to contrib/libboost/boost_1_65_0/boost/program_options/variables_map.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/program_options/version.hpp b/contrib/libboost/boost_1_65_0/boost/program_options/version.hpp
similarity index 81%
rename from contrib/libboost/boost_1_62_0/boost/program_options/version.hpp
rename to contrib/libboost/boost_1_65_0/boost/program_options/version.hpp
index 748094361bb..aa27568bb86 100644
--- a/contrib/libboost/boost_1_62_0/boost/program_options/version.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/program_options/version.hpp
@@ -15,5 +15,8 @@
 #endif
 #define BOOST_PROGRAM_OPTIONS_VERSION 2
 
+// Signal that implicit options will use values from next
+// token, if available.
+#define BOOST_PROGRAM_OPTIONS_IMPLICIT_VALUE_NEXT_TOKEN 1
 
 #endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/all.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/all.hpp
new file mode 100644
index 00000000000..73e8b81f27a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/all.hpp
@@ -0,0 +1,32 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_BE94EA1A31B211E0BBF943CFDFD72085
+#define UUID_BE94EA1A31B211E0BBF943CFDFD72085
+
+#include <boost/qvm/error.hpp>
+#include <boost/qvm/mat_operations.hpp>
+#include <boost/qvm/mat_access.hpp>
+#include <boost/qvm/mat_traits_defaults.hpp>
+#include <boost/qvm/mat_traits_array.hpp>
+#include <boost/qvm/map.hpp>
+#include <boost/qvm/mat.hpp>
+#include <boost/qvm/math.hpp>
+#include <boost/qvm/quat_operations.hpp>
+#include <boost/qvm/quat_access.hpp>
+#include <boost/qvm/quat_traits_defaults.hpp>
+#include <boost/qvm/quat_traits.hpp>
+#include <boost/qvm/quat.hpp>
+#include <boost/qvm/quat_vec_operations.hpp>
+#include <boost/qvm/swizzle.hpp>
+#include <boost/qvm/vec_operations.hpp>
+#include <boost/qvm/vec_access.hpp>
+#include <boost/qvm/vec_traits_defaults.hpp>
+#include <boost/qvm/vec_traits_array.hpp>
+#include <boost/qvm/vec.hpp>
+#include <boost/qvm/vec_mat_operations.hpp>
+#include <boost/qvm/to_string.hpp>
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/assert.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/assert.hpp
new file mode 100644
index 00000000000..ef7826fbebb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/assert.hpp
@@ -0,0 +1,9 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_ASSERT
+#include <boost/assert.hpp>
+#define BOOST_QVM_ASSERT BOOST_ASSERT
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/deduce_mat.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/deduce_mat.hpp
new file mode 100644
index 00000000000..e2fb7a2127b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/deduce_mat.hpp
@@ -0,0 +1,90 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_C5DC682E196211E0A4C1686BDFD72085
+#define UUID_C5DC682E196211E0A4C1686BDFD72085
+
+#include <boost/qvm/deduce_scalar.hpp>
+#include <boost/qvm/mat_traits.hpp>
+#include <boost/qvm/static_assert.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class T,int Rows,int Cols>
+        struct mat;
+
+        namespace
+        qvm_detail
+            {
+            template <class M,int R,int C,
+                int MR=mat_traits<M>::rows,
+                int MC=mat_traits<M>::cols>
+            struct
+            deduce_mat_default
+                {
+                BOOST_QVM_STATIC_ASSERT(is_mat<M>::value);
+                typedef mat<typename mat_traits<M>::scalar_type,R,C> type;
+                };
+
+            template <class M,int R,int C>
+            struct
+            deduce_mat_default<M,R,C,R,C>
+                {
+                BOOST_QVM_STATIC_ASSERT(is_mat<M>::value);
+                typedef M type;
+                };
+            }
+
+        template <class Type,int Rows=mat_traits<Type>::rows,int Cols=mat_traits<Type>::cols>
+        struct
+        deduce_mat
+            {
+            BOOST_QVM_STATIC_ASSERT(is_mat<Type>::value);
+            typedef typename qvm_detail::deduce_mat_default<Type,Rows,Cols>::type type;
+            };
+
+        namespace
+        qvm_detail
+            {
+            template <class A,class B,int R,int C,
+                bool VA=is_mat<A>::value,
+                bool VB=is_mat<B>::value,
+                int AR=mat_traits<A>::rows,
+                int AC=mat_traits<A>::cols,
+                int BR=mat_traits<B>::rows,
+                int BC=mat_traits<B>::cols>
+            struct
+            deduce_m2_default
+                {
+                typedef mat<
+                    typename deduce_scalar<
+                        typename scalar<A>::type,
+                        typename scalar<B>::type>::type,
+                    R,C> type;
+                };
+
+            template <class M,int R,int C>
+            struct
+            deduce_m2_default<M,M,R,C,true,true,R,C,R,C>
+                {
+                typedef M type;
+                };
+            }
+
+        template <class A,class B,int R,int C>
+        struct
+        deduce_mat2
+            {
+            BOOST_QVM_STATIC_ASSERT(is_mat<A>::value || is_mat<B>::value);
+            typedef typename qvm_detail::deduce_m2_default<A,B,R,C>::type type;
+            };
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/deduce_quat.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/deduce_quat.hpp
new file mode 100644
index 00000000000..6235f1f5175
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/deduce_quat.hpp
@@ -0,0 +1,63 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_435FA7E8196311E0A176DE6BDFD72085
+#define UUID_435FA7E8196311E0A176DE6BDFD72085
+
+#include <boost/qvm/deduce_scalar.hpp>
+#include <boost/qvm/quat_traits.hpp>
+#include <boost/qvm/static_assert.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class T>
+        struct quat;
+
+        template <class Q>
+        struct
+        deduce_quat
+            {
+            BOOST_QVM_STATIC_ASSERT(is_quat<Q>::value);
+            typedef Q type;
+            };
+
+        namespace
+        qvm_detail
+            {
+            template <class A,class B,
+                bool QA=is_quat<A>::value,
+                bool QB=is_quat<B>::value>
+            struct
+            deduce_quat2_default
+                {
+                typedef quat<
+                    typename deduce_scalar<
+                        typename scalar<A>::type,
+                        typename scalar<B>::type>::type> type;
+                };
+
+            template <class Q>
+            struct
+            deduce_quat2_default<Q,Q,true,true>
+                {
+                typedef Q type;
+                };
+            }
+
+        template <class A,class B>
+        struct
+        deduce_quat2
+            {
+            BOOST_QVM_STATIC_ASSERT(is_quat<A>::value || is_quat<B>::value);
+            typedef typename qvm_detail::deduce_quat2_default<A,B>::type type;
+            };
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/deduce_scalar.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/deduce_scalar.hpp
new file mode 100644
index 00000000000..010af340437
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/deduce_scalar.hpp
@@ -0,0 +1,131 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_F20566FC196311E0B99D606CDFD72085
+#define UUID_F20566FC196311E0B99D606CDFD72085
+
+#include <boost/qvm/scalar_traits.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        namespace
+        deduce_scalar_detail
+            {
+            template <class A,class B> struct deduce_scalar_impl { };
+
+            template <class T>
+            struct
+            deduce_scalar_impl<T,T>
+                {
+                typedef T type;
+                };
+
+            template <> struct deduce_scalar_impl<signed char,unsigned char> { typedef unsigned char type; };
+            template <> struct deduce_scalar_impl<signed char,unsigned short> { typedef unsigned short type; };
+            template <> struct deduce_scalar_impl<signed char,unsigned int> { typedef unsigned int type; };
+            template <> struct deduce_scalar_impl<signed char,unsigned long> { typedef unsigned long type; };
+            template <> struct deduce_scalar_impl<signed char,signed short> { typedef signed short type; };
+            template <> struct deduce_scalar_impl<signed char,signed int> { typedef signed int type; };
+            template <> struct deduce_scalar_impl<signed char,signed long> { typedef signed long type; };
+            template <> struct deduce_scalar_impl<signed char,float> { typedef float type; };
+            template <> struct deduce_scalar_impl<signed char,double> { typedef double type; };
+            template <> struct deduce_scalar_impl<unsigned char,unsigned short> { typedef unsigned short type; };
+            template <> struct deduce_scalar_impl<unsigned char,unsigned int> { typedef unsigned int type; };
+            template <> struct deduce_scalar_impl<unsigned char,unsigned long> { typedef unsigned long type; };
+            template <> struct deduce_scalar_impl<unsigned char,signed short> { typedef signed short type; };
+            template <> struct deduce_scalar_impl<unsigned char,signed int> { typedef signed int type; };
+            template <> struct deduce_scalar_impl<unsigned char,signed long> { typedef signed long type; };
+            template <> struct deduce_scalar_impl<unsigned char,float> { typedef float type; };
+            template <> struct deduce_scalar_impl<unsigned char,double> { typedef double type; };
+            template <> struct deduce_scalar_impl<signed short,unsigned short> { typedef unsigned short type; };
+            template <> struct deduce_scalar_impl<signed short,unsigned int> { typedef unsigned int type; };
+            template <> struct deduce_scalar_impl<signed short,unsigned long> { typedef unsigned long type; };
+            template <> struct deduce_scalar_impl<signed short,signed int> { typedef signed int type; };
+            template <> struct deduce_scalar_impl<signed short,signed long> { typedef signed long type; };
+            template <> struct deduce_scalar_impl<signed short,float> { typedef float type; };
+            template <> struct deduce_scalar_impl<signed short,double> { typedef double type; };
+            template <> struct deduce_scalar_impl<unsigned short,unsigned int> { typedef unsigned int type; };
+            template <> struct deduce_scalar_impl<unsigned short,unsigned long> { typedef unsigned long type; };
+            template <> struct deduce_scalar_impl<unsigned short,signed int> { typedef signed int type; };
+            template <> struct deduce_scalar_impl<unsigned short,signed long> { typedef signed long type; };
+            template <> struct deduce_scalar_impl<unsigned short,float> { typedef float type; };
+            template <> struct deduce_scalar_impl<unsigned short,double> { typedef double type; };
+            template <> struct deduce_scalar_impl<signed int,unsigned int> { typedef unsigned int type; };
+            template <> struct deduce_scalar_impl<signed int,unsigned long> { typedef unsigned long type; };
+            template <> struct deduce_scalar_impl<signed int,signed long> { typedef signed long type; };
+            template <> struct deduce_scalar_impl<signed int,float> { typedef float type; };
+            template <> struct deduce_scalar_impl<signed int,double> { typedef double type; };
+            template <> struct deduce_scalar_impl<unsigned int,unsigned long> { typedef unsigned long type; };
+            template <> struct deduce_scalar_impl<unsigned int,signed long> { typedef signed long type; };
+            template <> struct deduce_scalar_impl<unsigned int,float> { typedef float type; };
+            template <> struct deduce_scalar_impl<unsigned int,double> { typedef double type; };
+            template <> struct deduce_scalar_impl<signed long,unsigned long> { typedef unsigned long type; };
+            template <> struct deduce_scalar_impl<signed long,float> { typedef float type; };
+            template <> struct deduce_scalar_impl<signed long,double> { typedef double type; };
+            template <> struct deduce_scalar_impl<unsigned long,float> { typedef float type; };
+            template <> struct deduce_scalar_impl<unsigned long,double> { typedef double type; };
+            template <> struct deduce_scalar_impl<float,double> { typedef double type; };
+
+            template <> struct deduce_scalar_impl<unsigned char,signed char> { typedef unsigned char type; };
+            template <> struct deduce_scalar_impl<unsigned short,signed char> { typedef unsigned short type; };
+            template <> struct deduce_scalar_impl<unsigned int,signed char> { typedef unsigned int type; };
+            template <> struct deduce_scalar_impl<unsigned long,signed char> { typedef unsigned long type; };
+            template <> struct deduce_scalar_impl<signed short,signed char> { typedef signed short type; };
+            template <> struct deduce_scalar_impl<signed int,signed char> { typedef signed int type; };
+            template <> struct deduce_scalar_impl<signed long,signed char> { typedef signed long type; };
+            template <> struct deduce_scalar_impl<float,signed char> { typedef float type; };
+            template <> struct deduce_scalar_impl<double,signed char> { typedef double type; };
+            template <> struct deduce_scalar_impl<unsigned short,unsigned char> { typedef unsigned short type; };
+            template <> struct deduce_scalar_impl<unsigned int,unsigned char> { typedef unsigned int type; };
+            template <> struct deduce_scalar_impl<unsigned long,unsigned char> { typedef unsigned long type; };
+            template <> struct deduce_scalar_impl<signed short,unsigned char> { typedef signed short type; };
+            template <> struct deduce_scalar_impl<signed int,unsigned char> { typedef signed int type; };
+            template <> struct deduce_scalar_impl<signed long,unsigned char> { typedef signed long type; };
+            template <> struct deduce_scalar_impl<float,unsigned char> { typedef float type; };
+            template <> struct deduce_scalar_impl<double,unsigned char> { typedef double type; };
+            template <> struct deduce_scalar_impl<unsigned short,signed short> { typedef unsigned short type; };
+            template <> struct deduce_scalar_impl<unsigned int,signed short> { typedef unsigned int type; };
+            template <> struct deduce_scalar_impl<unsigned long,signed short> { typedef unsigned long type; };
+            template <> struct deduce_scalar_impl<signed int,signed short> { typedef signed int type; };
+            template <> struct deduce_scalar_impl<signed long,signed short> { typedef signed long type; };
+            template <> struct deduce_scalar_impl<float,signed short> { typedef float type; };
+            template <> struct deduce_scalar_impl<double,signed short> { typedef double type; };
+            template <> struct deduce_scalar_impl<unsigned int,unsigned short> { typedef unsigned int type; };
+            template <> struct deduce_scalar_impl<unsigned long,unsigned short> { typedef unsigned long type; };
+            template <> struct deduce_scalar_impl<signed int,unsigned short> { typedef signed int type; };
+            template <> struct deduce_scalar_impl<signed long,unsigned short> { typedef signed long type; };
+            template <> struct deduce_scalar_impl<float,unsigned short> { typedef float type; };
+            template <> struct deduce_scalar_impl<double,unsigned short> { typedef double type; };
+            template <> struct deduce_scalar_impl<unsigned int,signed int> { typedef unsigned int type; };
+            template <> struct deduce_scalar_impl<unsigned long,signed int> { typedef unsigned long type; };
+            template <> struct deduce_scalar_impl<signed long,signed int> { typedef signed long type; };
+            template <> struct deduce_scalar_impl<float,signed int> { typedef float type; };
+            template <> struct deduce_scalar_impl<double,signed int> { typedef double type; };
+            template <> struct deduce_scalar_impl<unsigned long,unsigned int> { typedef unsigned long type; };
+            template <> struct deduce_scalar_impl<signed long,unsigned int> { typedef signed long type; };
+            template <> struct deduce_scalar_impl<float,unsigned int> { typedef float type; };
+            template <> struct deduce_scalar_impl<double,unsigned int> { typedef double type; };
+            template <> struct deduce_scalar_impl<unsigned long,signed long> { typedef unsigned long type; };
+            template <> struct deduce_scalar_impl<float,signed long> { typedef float type; };
+            template <> struct deduce_scalar_impl<double,signed long> { typedef double type; };
+            template <> struct deduce_scalar_impl<float,unsigned long> { typedef float type; };
+            template <> struct deduce_scalar_impl<double,unsigned long> { typedef double type; };
+            template <> struct deduce_scalar_impl<double,float> { typedef double type; };
+            }
+
+        template <class A,class B>
+        struct
+        deduce_scalar
+            {
+            typedef typename deduce_scalar_detail::deduce_scalar_impl<A,B>::type type;
+            };
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/deduce_vec.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/deduce_vec.hpp
new file mode 100644
index 00000000000..e15cf0eec3d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/deduce_vec.hpp
@@ -0,0 +1,85 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_7E7AB138196311E0907B246CDFD72085
+#define UUID_7E7AB138196311E0907B246CDFD72085
+
+#include <boost/qvm/deduce_scalar.hpp>
+#include <boost/qvm/vec_traits.hpp>
+#include <boost/qvm/static_assert.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class T,int D>
+        struct vec;
+
+        namespace
+        qvm_detail
+            {
+            template <class V,int D,
+                int VD=vec_traits<V>::dim>
+            struct
+            deduce_vec_default
+                {
+                typedef vec<typename vec_traits<V>::scalar_type,D> type;
+                };
+
+            template <class V,int D>
+            struct
+            deduce_vec_default<V,D,D>
+                {
+                typedef V type;
+                };
+            }
+
+        template <class V,int Dim=vec_traits<V>::dim>
+        struct
+        deduce_vec
+            {
+            BOOST_QVM_STATIC_ASSERT(is_vec<V>::value);
+            typedef typename qvm_detail::deduce_vec_default<V,Dim>::type type;
+            };
+
+        namespace
+        qvm_detail
+            {
+            template <class A,class B,int D,
+                bool VA=is_vec<A>::value,
+                bool VB=is_vec<B>::value,
+                int AD=vec_traits<A>::dim,
+                int BD=vec_traits<B>::dim>
+            struct
+            deduce_v2_default
+                {
+                typedef vec<
+                    typename deduce_scalar<
+                        typename scalar<A>::type,
+                        typename scalar<B>::type>::type,
+                    D> type;
+                };
+
+            template <class V,int D>
+            struct
+            deduce_v2_default<V,V,D,true,true,D,D>
+                {
+                typedef V type;
+                };
+            }
+
+        template <class A,class B,int D>
+        struct
+        deduce_vec2
+            {
+            BOOST_QVM_STATIC_ASSERT(is_vec<A>::value || is_vec<B>::value);
+            typedef typename qvm_detail::deduce_v2_default<A,B,D>::type type;
+            };
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/detail/cofactor_impl.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/detail/cofactor_impl.hpp
new file mode 100644
index 00000000000..b4ccd5b2f71
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/detail/cofactor_impl.hpp
@@ -0,0 +1,64 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_995547FAAE0E11DE8CF511E755D89593
+#define UUID_995547FAAE0E11DE8CF511E755D89593
+
+#include <boost/qvm/detail/determinant_impl.hpp>
+#include <boost/qvm/mat_traits.hpp>
+#include <boost/qvm/static_assert.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        namespace
+        qvm_detail
+            {
+            template <class A>
+            BOOST_QVM_INLINE_OPERATIONS
+            typename deduce_mat<A>::type
+            cofactor_impl( A const & a )
+                {
+                BOOST_QVM_STATIC_ASSERT(mat_traits<A>::rows==mat_traits<A>::cols);
+                int const N=mat_traits<A>::rows;
+                typedef typename mat_traits<A>::scalar_type T;
+                T c[N-1][N-1];
+                typedef typename deduce_mat<A>::type R;
+                R b;
+                for( int j=0; j!=N; ++j )
+                    {
+                    for( int i=0; i!=N; ++i )
+                        {
+                        int i1=0;
+                        for( int ii=0; ii!=N; ++ii )
+                            {
+                            if( ii==i )
+                                continue;
+                            int j1=0;
+                            for( int jj=0; jj!=N; ++jj )
+                                {
+                                if( jj==j )
+                                    continue;
+                                c[i1][j1] = mat_traits<A>::read_element_idx(ii,jj,a);
+                                ++j1;
+                                }
+                            ++i1;
+                            }
+                        T det = determinant_impl(c);
+                        if( (i+j)&1 )
+                            det=-det;
+                        mat_traits<R>::write_element_idx(i,j,b) = det;
+                        }
+                    }
+                return b;
+                }
+            }
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/detail/determinant_impl.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/detail/determinant_impl.hpp
new file mode 100644
index 00000000000..6886c4ee838
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/detail/determinant_impl.hpp
@@ -0,0 +1,79 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_3DCF6B90AE0E11DE9A315BE555D89593
+#define UUID_3DCF6B90AE0E11DE9A315BE555D89593
+
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/mat_traits_array.hpp>
+#include <boost/qvm/static_assert.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        namespace
+        qvm_detail
+            {
+            template <int N>
+            struct
+            det_size
+                {
+                };
+
+            template <class M>
+            BOOST_QVM_INLINE_TRIVIAL
+            typename mat_traits<M>::scalar_type
+            determinant_impl_( M const & a, det_size<2> )
+                {
+                return
+                    mat_traits<M>::template read_element<0,0>(a) * mat_traits<M>::template read_element<1,1>(a) -
+                    mat_traits<M>::template read_element<1,0>(a) * mat_traits<M>::template read_element<0,1>(a);
+                }
+
+            template <class M,int N>
+            BOOST_QVM_INLINE_RECURSION
+            typename mat_traits<M>::scalar_type
+            determinant_impl_( M const & a, det_size<N> )
+                {
+                typedef typename mat_traits<M>::scalar_type T;
+                T m[N-1][N-1];
+                T det=T(0);
+                for( int j1=0; j1!=N; ++j1 )
+                    {
+                    for( int i=1; i!=N; ++i )
+                        {
+                        int j2 = 0;
+                        for( int j=0; j!=N; ++j )
+                            {
+                            if( j==j1 )
+                                continue;
+                            m[i-1][j2] = mat_traits<M>::read_element_idx(i,j,a);
+                            ++j2;
+                            }
+                        }
+                    T d=determinant_impl_(m,det_size<N-1>());
+                    if( j1&1 )
+                        d=-d;
+                    det += mat_traits<M>::read_element_idx(0,j1,a) * d;
+                    }
+                return det;
+                }
+
+            template <class M>
+            BOOST_QVM_INLINE_TRIVIAL
+            typename mat_traits<M>::scalar_type
+            determinant_impl( M const & a )
+                {
+                BOOST_QVM_STATIC_ASSERT(mat_traits<M>::rows==mat_traits<M>::cols);
+                return determinant_impl_(a,det_size<mat_traits<M>::rows>());
+                }
+            }
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/detail/mat_assign.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/detail/mat_assign.hpp
new file mode 100644
index 00000000000..89d50243eb6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/detail/mat_assign.hpp
@@ -0,0 +1,75 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_47136D2C385411E7BA27D3B681262D2E
+#define UUID_47136D2C385411E7BA27D3B681262D2E
+
+#include <boost/qvm/gen/mat_assign2.hpp>
+#include <boost/qvm/gen/mat_assign3.hpp>
+#include <boost/qvm/gen/mat_assign4.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        namespace
+        qvm_detail
+            {
+            template <int M,int N>
+            struct
+            assign_mm_defined
+                {
+                static bool const value=false;
+                };
+
+            template <int I,int N>
+            struct
+            copy_matrix_elements
+                {
+                template <class A,class B>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                void
+                f( A & a, B const & b )
+                    {
+                    mat_traits<A>::template write_element<I/mat_traits<A>::cols,I%mat_traits<A>::cols>(a) =
+                        mat_traits<B>::template read_element<I/mat_traits<B>::cols,I%mat_traits<B>::cols>(b);
+                    copy_matrix_elements<I+1,N>::f(a,b);
+                    }
+                };
+
+            template <int N>
+            struct
+            copy_matrix_elements<N,N>
+                {
+                template <class A,class B>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                void
+                f( A &, B const & )
+                    {
+                    }
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename boost::enable_if_c<
+            is_mat<A>::value && is_mat<B>::value &&
+            mat_traits<A>::rows==mat_traits<B>::rows &&
+            mat_traits<A>::cols==mat_traits<B>::cols &&
+            !qvm_detail::assign_mm_defined<mat_traits<A>::rows,mat_traits<A>::cols>::value,
+            A &>::type
+        assign( A & a, B const & b )
+            {
+            qvm_detail::copy_matrix_elements<0,mat_traits<A>::rows*mat_traits<A>::cols>::f(a,b);
+            return a;
+            }
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/detail/quat_assign.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/detail/quat_assign.hpp
new file mode 100644
index 00000000000..87b2cf1f62e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/detail/quat_assign.hpp
@@ -0,0 +1,35 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_86A42DA4385511E7822024B881262D2E
+#define UUID_86A42DA4385511E7822024B881262D2E
+
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/enable_if.hpp>
+#include <boost/qvm/quat_traits.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<A>::value && is_quat<B>::value,
+            A &>::type
+        assign( A & a, B const & b )
+            {
+            quat_traits<A>::template write_element<0>(a) = quat_traits<B>::template read_element<0>(b);
+            quat_traits<A>::template write_element<1>(a) = quat_traits<B>::template read_element<1>(b);
+            quat_traits<A>::template write_element<2>(a) = quat_traits<B>::template read_element<2>(b);
+            quat_traits<A>::template write_element<3>(a) = quat_traits<B>::template read_element<3>(b);
+            return a;
+            }
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/detail/remove_const.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/detail/remove_const.hpp
new file mode 100644
index 00000000000..82f1d1cef5f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/detail/remove_const.hpp
@@ -0,0 +1,35 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_4E340430AE4C11DEBA56149755D89593
+#define UUID_4E340430AE4C11DEBA56149755D89593
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        namespace
+        qvm_detail
+            {
+            template <class T>
+            struct
+            remove_const
+                {
+                typedef T type;
+                };
+
+            template <class T>
+            struct
+            remove_const<T const>
+                {
+                typedef T type;
+                };
+            }
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/detail/swizzle_traits.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/detail/swizzle_traits.hpp
new file mode 100644
index 00000000000..8ead2976f56
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/detail/swizzle_traits.hpp
@@ -0,0 +1,338 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_E831FAD6B38F11DE8CECBF0D56D89593
+#define UUID_E831FAD6B38F11DE8CECBF0D56D89593
+
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/deduce_vec.hpp>
+#include <boost/qvm/enable_if.hpp>
+#include <boost/qvm/assert.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        namespace
+        qvm_detail
+            {
+            BOOST_QVM_INLINE_CRITICAL
+            void const *
+            get_null()
+                {
+                static int const obj=0;
+                return &obj;
+                }
+
+            template <int A,class Next=void> struct swizzle_idx { static int const value=A; typedef Next next; };
+
+            template <class V,int Idx>
+            struct
+            const_value
+                {
+                static
+                BOOST_QVM_INLINE_TRIVIAL
+                typename vec_traits<V>::scalar_type
+                value()
+                    {
+                    BOOST_QVM_ASSERT(0);
+                    return typename vec_traits<V>::scalar_type();
+                    }
+                };
+
+            template <class V>
+            struct
+            const_value<V,-1>
+                {
+                static
+                BOOST_QVM_INLINE_TRIVIAL
+                typename vec_traits<V>::scalar_type
+                value()
+                    {
+                    return scalar_traits<typename vec_traits<V>::scalar_type>::value(0);
+                    }
+                };
+
+            template <class V>
+            struct
+            const_value<V,-2>
+                {
+                static
+                BOOST_QVM_INLINE_TRIVIAL
+                typename vec_traits<V>::scalar_type
+                value()
+                    {
+                    return scalar_traits<typename vec_traits<V>::scalar_type>::value(1);
+                    }
+                };
+
+            template <int Index,bool Neg=(Index<0)>
+            struct neg_zero;
+
+            template <int Index>
+            struct
+            neg_zero<Index,true>
+                {
+                static int const value=0;
+                };
+
+            template <int Index>
+            struct
+            neg_zero<Index,false>
+                {
+                static int const value=Index;
+                };
+
+            template <class SwizzleList,int Index,int C=0>
+            struct
+            swizzle
+                {
+                static int const value=swizzle<typename SwizzleList::next,Index,C+1>::value;
+                };
+
+            template <class SwizzleList,int Match>
+            struct
+            swizzle<SwizzleList,Match,Match>
+                {
+                static int const value=SwizzleList::value;
+                };
+
+            template <int Index,int C>
+            struct swizzle<void,Index,C>;
+
+            template <class SwizzleList,int C=0>
+            struct
+            swizzle_list_length
+                {
+                static int const value=swizzle_list_length<typename SwizzleList::next,C+1>::value;
+                };
+
+            template <int C>
+            struct
+            swizzle_list_length<void,C>
+                {
+                static int const value=C;
+                };
+
+            template <class SwizzleList,int D>
+            struct
+            validate_swizzle_list
+                {
+                static bool const value =
+                    ((SwizzleList::value)<D) && //don't touch extra (), MSVC parsing bug.
+                    validate_swizzle_list<typename SwizzleList::next,D>::value;
+                };
+
+            template <int D>
+            struct
+            validate_swizzle_list<void,D>
+                {
+                static bool const value=true;
+                };
+
+            template <class OriginalType,class SwizzleList>
+            class
+            sw_
+                {
+                sw_( sw_ const & );
+                sw_ & operator=( sw_ const & );
+                ~sw_();
+
+                BOOST_QVM_STATIC_ASSERT((validate_swizzle_list<SwizzleList,vec_traits<OriginalType>::dim>::value));
+
+                public:
+
+                template <class T>
+                BOOST_QVM_INLINE_TRIVIAL
+                sw_ &
+                operator=( T const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+
+            template <class SwizzleList>
+            class
+            sw01_
+                {
+                sw01_( sw01_ const & );
+                sw01_ & operator=( sw01_ const & );
+                ~sw01_();
+
+                public:
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+
+            template <class OriginalType,class SwizzleList>
+            class
+            sws_
+                {
+                sws_( sws_ const & );
+                sws_ & operator=( sws_ const & );
+                ~sws_();
+
+                BOOST_QVM_STATIC_ASSERT((validate_swizzle_list<SwizzleList,1>::value));
+
+                public:
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <class OriginalVector,class SwizzleList>
+        struct
+        vec_traits<qvm_detail::sw_<OriginalVector,SwizzleList> >
+            {
+            typedef qvm_detail::sw_<OriginalVector,SwizzleList> this_vector;
+            typedef typename vec_traits<OriginalVector>::scalar_type scalar_type;
+            static int const dim=qvm_detail::swizzle_list_length<SwizzleList>::value;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_vector const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<dim);
+                int const idx=qvm_detail::swizzle<SwizzleList,I>::value;
+                BOOST_QVM_STATIC_ASSERT(idx<vec_traits<OriginalVector>::dim);
+                return idx>=0?
+                    vec_traits<OriginalVector>::template read_element<qvm_detail::neg_zero<idx>::value>(reinterpret_cast<OriginalVector const &>(x)) :
+                    qvm_detail::const_value<this_vector,idx>::value();
+                }
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_vector & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<dim);
+                int const idx=qvm_detail::swizzle<SwizzleList,I>::value;
+                BOOST_QVM_STATIC_ASSERT(idx>=0);
+                BOOST_QVM_STATIC_ASSERT(idx<vec_traits<OriginalVector>::dim);
+                return vec_traits<OriginalVector>::template write_element<idx>(reinterpret_cast<OriginalVector &>(x));
+                }
+            };
+
+        template <class SwizzleList>
+        struct
+        vec_traits<qvm_detail::sw01_<SwizzleList> >
+            {
+            typedef qvm_detail::sw01_<SwizzleList> this_vector;
+            typedef int scalar_type;
+            static int const dim=qvm_detail::swizzle_list_length<SwizzleList>::value;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_vector const & )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<dim);
+                int const idx=qvm_detail::swizzle<SwizzleList,I>::value;
+                BOOST_QVM_STATIC_ASSERT(idx<0);
+                return qvm_detail::const_value<this_vector,idx>::value();
+                }
+            };
+
+        template <class OriginalScalar,class SwizzleList>
+        struct
+        vec_traits<qvm_detail::sws_<OriginalScalar,SwizzleList> >
+            {
+            typedef qvm_detail::sws_<OriginalScalar,SwizzleList> this_vector;
+            typedef OriginalScalar scalar_type;
+            static int const dim=qvm_detail::swizzle_list_length<SwizzleList>::value;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_vector const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<dim);
+                int const idx=qvm_detail::swizzle<SwizzleList,I>::value;
+                BOOST_QVM_STATIC_ASSERT(idx<1);
+                return idx==0?
+                    reinterpret_cast<OriginalScalar const &>(x) :
+                    qvm_detail::const_value<this_vector,idx>::value();
+                }
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_vector & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<dim);
+                int const idx=qvm_detail::swizzle<SwizzleList,I>::value;
+                BOOST_QVM_STATIC_ASSERT(idx==0);
+                return reinterpret_cast<OriginalScalar &>(x);
+                }
+            };
+
+        template <class OriginalVector,class SwizzleList,int D>
+        struct
+        deduce_vec<qvm_detail::sw_<OriginalVector,SwizzleList>,D>
+            {
+            typedef vec<typename vec_traits<OriginalVector>::scalar_type,D> type;
+            };
+
+        template <class OriginalVector,class SwizzleList,int D>
+        struct
+        deduce_vec2<qvm_detail::sw_<OriginalVector,SwizzleList>,qvm_detail::sw_<OriginalVector,SwizzleList>,D>
+            {
+            typedef vec<typename vec_traits<OriginalVector>::scalar_type,D> type;
+            };
+
+        template <class Scalar,class SwizzleList,int D>
+        struct
+        deduce_vec<qvm_detail::sws_<Scalar,SwizzleList>,D>
+            {
+            typedef vec<Scalar,D> type;
+            };
+
+        template <class Scalar,class SwizzleList,int D>
+        struct
+        deduce_vec2<qvm_detail::sws_<Scalar,SwizzleList>,qvm_detail::sws_<Scalar,SwizzleList>,D>
+            {
+            typedef vec<Scalar,D> type;
+            };
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/detail/transp_impl.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/detail/transp_impl.hpp
new file mode 100644
index 00000000000..8ead1da9fc5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/detail/transp_impl.hpp
@@ -0,0 +1,128 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_B3B8081A277711E09E007F2DDFD72085
+#define UUID_B3B8081A277711E09E007F2DDFD72085
+
+#include <boost/qvm/deduce_mat.hpp>
+#include <boost/qvm/static_assert.hpp>
+#include <boost/qvm/assert.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        namespace
+        qvm_detail
+            {
+            template <class OriginalMatrix>
+            class
+            transposed_
+                {
+                transposed_( transposed_ const & );
+                transposed_ & operator=( transposed_ const & );
+                ~transposed_();
+
+                public:
+
+                template <class T>
+                BOOST_QVM_INLINE_TRIVIAL
+                transposed_ &
+                operator=( T const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <class OriginalMatrix>
+        struct
+        mat_traits< qvm_detail::transposed_<OriginalMatrix> >
+            {
+            typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
+            typedef qvm_detail::transposed_<OriginalMatrix> this_matrix;
+            static int const rows=mat_traits<OriginalMatrix>::cols;
+            static int const cols=mat_traits<OriginalMatrix>::rows;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return mat_traits<OriginalMatrix>::template read_element<Col,Row>(reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_matrix & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return mat_traits<OriginalMatrix>::template write_element<Col,Row>(reinterpret_cast<OriginalMatrix &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return mat_traits<OriginalMatrix>::read_element_idx(col,row,reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int row, int col, this_matrix & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return mat_traits<OriginalMatrix>::write_element_idx(col,row,reinterpret_cast<OriginalMatrix &>(x));
+                }
+            };
+
+        template <class OriginalMatrix,int R,int C>
+        struct
+        deduce_mat<qvm_detail::transposed_<OriginalMatrix>,R,C>
+            {
+            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
+            };
+
+        template <class OriginalMatrix,int R,int C>
+        struct
+        deduce_mat2<qvm_detail::transposed_<OriginalMatrix>,qvm_detail::transposed_<OriginalMatrix>,R,C>
+            {
+            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
+            };
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/detail/vec_assign.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/detail/vec_assign.hpp
new file mode 100644
index 00000000000..c196c4f68d5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/detail/vec_assign.hpp
@@ -0,0 +1,71 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_185557CE385511E780ACD7B781262D2E
+#define UUID_185557CE385511E780ACD7B781262D2E
+
+#include <boost/qvm/gen/vec_assign2.hpp>
+#include <boost/qvm/gen/vec_assign3.hpp>
+#include <boost/qvm/gen/vec_assign4.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            assign_vv_defined
+                {
+                static bool const value=false;
+                };
+
+            template <int I,int N>
+            struct
+            copy_vector_elements
+                {
+                template <class A,class B>
+                static
+                void
+                f( A & a, B const & b )
+                    {
+                    vec_traits<A>::template write_element<I>(a)=vec_traits<B>::template read_element<I>(b);
+                    copy_vector_elements<I+1,N>::f(a,b);
+                    }
+                };
+
+            template <int N>
+            struct
+            copy_vector_elements<N,N>
+                {
+                template <class A,class B>
+                static
+                void
+                f( A &, B const & )
+                    {
+                    }
+                };
+            }
+
+        template <class A,class B>
+        inline
+        typename boost::enable_if_c<
+            is_vec<A>::value && is_vec<B>::value &&
+            vec_traits<A>::dim==vec_traits<B>::dim &&
+            !qvm_detail::assign_vv_defined<vec_traits<A>::dim>::value,
+            A &>::type
+        assign( A & a, B const & b )
+            {
+            qvm_detail::copy_vector_elements<0,vec_traits<A>::dim>::f(a,b);
+            return a;
+            }
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/enable_if.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/enable_if.hpp
new file mode 100644
index 00000000000..3ce0b4f9ea8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/enable_if.hpp
@@ -0,0 +1,24 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_A4FA0794391911DF85A6622B56D89593
+#define UUID_A4FA0794391911DF85A6622B56D89593
+
+#include <boost/utility/enable_if.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        using boost::enable_if;
+        using boost::enable_if_c;
+        using boost::lazy_enable_if;
+        using boost::lazy_enable_if_c;
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/error.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/error.hpp
new file mode 100644
index 00000000000..cf0ebe6afd9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/error.hpp
@@ -0,0 +1,40 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_92B1247AAE1111DE9655F2FC55D89593
+#define UUID_92B1247AAE1111DE9655F2FC55D89593
+
+#include "boost/exception/exception.hpp"
+#include "boost/exception/error_info.hpp"
+#include <exception>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        struct
+        error:
+            virtual boost::exception,
+            virtual std::exception
+            {
+            char const *
+            what() const throw()
+                {
+                return "Boost QVM error";
+                }
+
+            ~error() throw()
+                {
+                }
+            };
+
+        struct zero_determinant_error: virtual error { };
+        struct zero_magnitude_error: virtual error { };
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_assign2.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_assign2.hpp
new file mode 100644
index 00000000000..8a4285c9115
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_assign2.hpp
@@ -0,0 +1,125 @@
+//Copyright (c) 2008-2017 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_5DD4CBFC96F5453B13D89A1CDBAE32
+#define BOOST_QVM_5DD4CBFC96F5453B13D89A1CDBAE32
+
+//This file was generated by a program. Do not edit manually.
+
+#include <boost/qvm/enable_if.hpp>
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/mat_traits.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<B>::rows==2 &&
+            mat_traits<A>::cols==2 && mat_traits<B>::cols==2,
+            A &>::type
+        assign( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<0,1>(a)=mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<A>::template write_element<1,0>(a)=mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<A>::template write_element<1,1>(a)=mat_traits<B>::template read_element<1,1>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::assign;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct assign_mm_defined;
+
+            template <>
+            struct
+            assign_mm_defined<2,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<B>::rows==2 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            A &>::type
+        assign( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<1,0>(a)=mat_traits<B>::template read_element<1,0>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::assign;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct assign_mm_defined;
+
+            template <>
+            struct
+            assign_mm_defined<2,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==2 && mat_traits<B>::cols==2,
+            A &>::type
+        assign( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<0,1>(a)=mat_traits<B>::template read_element<0,1>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::assign;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct assign_mm_defined;
+
+            template <>
+            struct
+            assign_mm_defined<1,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_assign3.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_assign3.hpp
new file mode 100644
index 00000000000..b2e8f12f4c6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_assign3.hpp
@@ -0,0 +1,132 @@
+//Copyright (c) 2008-2017 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_209A50EE407836FD124932F69E7D49DC
+#define BOOST_QVM_209A50EE407836FD124932F69E7D49DC
+
+//This file was generated by a program. Do not edit manually.
+
+#include <boost/qvm/enable_if.hpp>
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/mat_traits.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<B>::rows==3 &&
+            mat_traits<A>::cols==3 && mat_traits<B>::cols==3,
+            A &>::type
+        assign( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<0,1>(a)=mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<A>::template write_element<0,2>(a)=mat_traits<B>::template read_element<0,2>(b);
+            mat_traits<A>::template write_element<1,0>(a)=mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<A>::template write_element<1,1>(a)=mat_traits<B>::template read_element<1,1>(b);
+            mat_traits<A>::template write_element<1,2>(a)=mat_traits<B>::template read_element<1,2>(b);
+            mat_traits<A>::template write_element<2,0>(a)=mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<A>::template write_element<2,1>(a)=mat_traits<B>::template read_element<2,1>(b);
+            mat_traits<A>::template write_element<2,2>(a)=mat_traits<B>::template read_element<2,2>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::assign;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct assign_mm_defined;
+
+            template <>
+            struct
+            assign_mm_defined<3,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<B>::rows==3 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            A &>::type
+        assign( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<1,0>(a)=mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<A>::template write_element<2,0>(a)=mat_traits<B>::template read_element<2,0>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::assign;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct assign_mm_defined;
+
+            template <>
+            struct
+            assign_mm_defined<3,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==3 && mat_traits<B>::cols==3,
+            A &>::type
+        assign( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<0,1>(a)=mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<A>::template write_element<0,2>(a)=mat_traits<B>::template read_element<0,2>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::assign;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct assign_mm_defined;
+
+            template <>
+            struct
+            assign_mm_defined<1,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_assign4.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_assign4.hpp
new file mode 100644
index 00000000000..69fa3e19284
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_assign4.hpp
@@ -0,0 +1,141 @@
+//Copyright (c) 2008-2017 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_AD4F14F2444066D06BC430B7323BA122
+#define BOOST_QVM_AD4F14F2444066D06BC430B7323BA122
+
+//This file was generated by a program. Do not edit manually.
+
+#include <boost/qvm/enable_if.hpp>
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/mat_traits.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<B>::rows==4 &&
+            mat_traits<A>::cols==4 && mat_traits<B>::cols==4,
+            A &>::type
+        assign( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<0,1>(a)=mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<A>::template write_element<0,2>(a)=mat_traits<B>::template read_element<0,2>(b);
+            mat_traits<A>::template write_element<0,3>(a)=mat_traits<B>::template read_element<0,3>(b);
+            mat_traits<A>::template write_element<1,0>(a)=mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<A>::template write_element<1,1>(a)=mat_traits<B>::template read_element<1,1>(b);
+            mat_traits<A>::template write_element<1,2>(a)=mat_traits<B>::template read_element<1,2>(b);
+            mat_traits<A>::template write_element<1,3>(a)=mat_traits<B>::template read_element<1,3>(b);
+            mat_traits<A>::template write_element<2,0>(a)=mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<A>::template write_element<2,1>(a)=mat_traits<B>::template read_element<2,1>(b);
+            mat_traits<A>::template write_element<2,2>(a)=mat_traits<B>::template read_element<2,2>(b);
+            mat_traits<A>::template write_element<2,3>(a)=mat_traits<B>::template read_element<2,3>(b);
+            mat_traits<A>::template write_element<3,0>(a)=mat_traits<B>::template read_element<3,0>(b);
+            mat_traits<A>::template write_element<3,1>(a)=mat_traits<B>::template read_element<3,1>(b);
+            mat_traits<A>::template write_element<3,2>(a)=mat_traits<B>::template read_element<3,2>(b);
+            mat_traits<A>::template write_element<3,3>(a)=mat_traits<B>::template read_element<3,3>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::assign;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct assign_mm_defined;
+
+            template <>
+            struct
+            assign_mm_defined<4,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<B>::rows==4 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            A &>::type
+        assign( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<1,0>(a)=mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<A>::template write_element<2,0>(a)=mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<A>::template write_element<3,0>(a)=mat_traits<B>::template read_element<3,0>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::assign;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct assign_mm_defined;
+
+            template <>
+            struct
+            assign_mm_defined<4,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==4 && mat_traits<B>::cols==4,
+            A &>::type
+        assign( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<0,1>(a)=mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<A>::template write_element<0,2>(a)=mat_traits<B>::template read_element<0,2>(b);
+            mat_traits<A>::template write_element<0,3>(a)=mat_traits<B>::template read_element<0,3>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::assign;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct assign_mm_defined;
+
+            template <>
+            struct
+            assign_mm_defined<1,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_operations2.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_operations2.hpp
new file mode 100644
index 00000000000..d20339bc7d0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_operations2.hpp
@@ -0,0 +1,1720 @@
+//Copyright (c) 2008-2017 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_2923BE84E16CD6AE529049F1F1BBE9EB
+#define BOOST_QVM_2923BE84E16CD6AE529049F1F1BBE9EB
+
+//This file was generated by a program. Do not edit manually.
+
+#include <boost/qvm/assert.hpp>
+#include <boost/qvm/deduce_mat.hpp>
+#include <boost/qvm/deduce_vec.hpp>
+#include <boost/qvm/error.hpp>
+#include <boost/qvm/gen/mat_assign2.hpp>
+#include <boost/qvm/throw_exception.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<B>::rows==2 &&
+            mat_traits<A>::cols==2 && mat_traits<B>::cols==2,
+            deduce_mat2<A,B,2,2> >::type
+        operator+( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,2,2>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==2);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==2);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)+mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)+mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)+mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<R>::template write_element<1,1>(r)=mat_traits<A>::template read_element<1,1>(a)+mat_traits<B>::template read_element<1,1>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct plus_mm_defined;
+
+            template <>
+            struct
+            plus_mm_defined<2,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<B>::rows==2 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            deduce_mat2<A,B,2,1> >::type
+        operator+( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,2,1>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==2);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==1);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)+mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)+mat_traits<B>::template read_element<1,0>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct plus_mm_defined;
+
+            template <>
+            struct
+            plus_mm_defined<2,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==2 && mat_traits<B>::cols==2,
+            deduce_mat2<A,B,1,2> >::type
+        operator+( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,1,2>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==1);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==2);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)+mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)+mat_traits<B>::template read_element<0,1>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct plus_mm_defined;
+
+            template <>
+            struct
+            plus_mm_defined<1,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<B>::rows==2 &&
+            mat_traits<A>::cols==2 && mat_traits<B>::cols==2,
+            deduce_mat2<A,B,2,2> >::type
+        operator-( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,2,2>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==2);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==2);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)-mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)-mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)-mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<R>::template write_element<1,1>(r)=mat_traits<A>::template read_element<1,1>(a)-mat_traits<B>::template read_element<1,1>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_mm_defined;
+
+            template <>
+            struct
+            minus_mm_defined<2,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<B>::rows==2 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            deduce_mat2<A,B,2,1> >::type
+        operator-( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,2,1>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==2);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==1);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)-mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)-mat_traits<B>::template read_element<1,0>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_mm_defined;
+
+            template <>
+            struct
+            minus_mm_defined<2,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==2 && mat_traits<B>::cols==2,
+            deduce_mat2<A,B,1,2> >::type
+        operator-( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,1,2>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==1);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==2);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)-mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)-mat_traits<B>::template read_element<0,1>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_mm_defined;
+
+            template <>
+            struct
+            minus_mm_defined<1,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<B>::rows==2 &&
+            mat_traits<A>::cols==2 && mat_traits<B>::cols==2,
+            A &>::type
+        operator+=( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)+=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<0,1>(a)+=mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<A>::template write_element<1,0>(a)+=mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<A>::template write_element<1,1>(a)+=mat_traits<B>::template read_element<1,1>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct plus_eq_mm_defined;
+
+            template <>
+            struct
+            plus_eq_mm_defined<2,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<B>::rows==2 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            A &>::type
+        operator+=( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)+=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<1,0>(a)+=mat_traits<B>::template read_element<1,0>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct plus_eq_mm_defined;
+
+            template <>
+            struct
+            plus_eq_mm_defined<2,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==2 && mat_traits<B>::cols==2,
+            A &>::type
+        operator+=( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)+=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<0,1>(a)+=mat_traits<B>::template read_element<0,1>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct plus_eq_mm_defined;
+
+            template <>
+            struct
+            plus_eq_mm_defined<1,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<B>::rows==2 &&
+            mat_traits<A>::cols==2 && mat_traits<B>::cols==2,
+            A &>::type
+        operator-=( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)-=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<0,1>(a)-=mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<A>::template write_element<1,0>(a)-=mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<A>::template write_element<1,1>(a)-=mat_traits<B>::template read_element<1,1>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_eq_mm_defined;
+
+            template <>
+            struct
+            minus_eq_mm_defined<2,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<B>::rows==2 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            A &>::type
+        operator-=( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)-=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<1,0>(a)-=mat_traits<B>::template read_element<1,0>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_eq_mm_defined;
+
+            template <>
+            struct
+            minus_eq_mm_defined<2,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==2 && mat_traits<B>::cols==2,
+            A &>::type
+        operator-=( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)-=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<0,1>(a)-=mat_traits<B>::template read_element<0,1>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_eq_mm_defined;
+
+            template <>
+            struct
+            minus_eq_mm_defined<1,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<A>::cols==2 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        operator*( A const & a, B b )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)*b;
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)*b;
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)*b;
+            mat_traits<R>::template write_element<1,1>(r)=mat_traits<A>::template read_element<1,1>(a)*b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_ms_defined;
+
+            template <>
+            struct
+            mul_ms_defined<2,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_scalar<A>::value && mat_traits<B>::rows==2 && mat_traits<B>::cols==2,
+            deduce_mat<B> >::type
+        operator*( A a, B const & b )
+            {
+            typedef typename deduce_mat<B>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a*mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=a*mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<R>::template write_element<1,0>(r)=a*mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<R>::template write_element<1,1>(r)=a*mat_traits<B>::template read_element<1,1>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_sm_defined;
+
+            template <>
+            struct
+            mul_sm_defined<2,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<A>::cols==1 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        operator*( A const & a, B b )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)*b;
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)*b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_ms_defined;
+
+            template <>
+            struct
+            mul_ms_defined<2,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_scalar<A>::value && mat_traits<B>::rows==2 && mat_traits<B>::cols==1,
+            deduce_mat<B> >::type
+        operator*( A a, B const & b )
+            {
+            typedef typename deduce_mat<B>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a*mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<1,0>(r)=a*mat_traits<B>::template read_element<1,0>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_sm_defined;
+
+            template <>
+            struct
+            mul_sm_defined<2,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<A>::cols==2 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        operator*( A const & a, B b )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)*b;
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)*b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_ms_defined;
+
+            template <>
+            struct
+            mul_ms_defined<1,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_scalar<A>::value && mat_traits<B>::rows==1 && mat_traits<B>::cols==2,
+            deduce_mat<B> >::type
+        operator*( A a, B const & b )
+            {
+            typedef typename deduce_mat<B>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a*mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=a*mat_traits<B>::template read_element<0,1>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_sm_defined;
+
+            template <>
+            struct
+            mul_sm_defined<1,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<A>::cols==2 && is_scalar<B>::value,
+            A &>::type
+        operator*=( A & a, B b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)*=b;
+            mat_traits<A>::template write_element<0,1>(a)*=b;
+            mat_traits<A>::template write_element<1,0>(a)*=b;
+            mat_traits<A>::template write_element<1,1>(a)*=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_eq_ms_defined;
+
+            template <>
+            struct
+            mul_eq_ms_defined<2,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<A>::cols==1 && is_scalar<B>::value,
+            A &>::type
+        operator*=( A & a, B b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)*=b;
+            mat_traits<A>::template write_element<1,0>(a)*=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_eq_ms_defined;
+
+            template <>
+            struct
+            mul_eq_ms_defined<2,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<A>::cols==2 && is_scalar<B>::value,
+            A &>::type
+        operator*=( A & a, B b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)*=b;
+            mat_traits<A>::template write_element<0,1>(a)*=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_eq_ms_defined;
+
+            template <>
+            struct
+            mul_eq_ms_defined<1,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<A>::cols==2 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        operator/( A const & a, B b )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)/b;
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)/b;
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)/b;
+            mat_traits<R>::template write_element<1,1>(r)=mat_traits<A>::template read_element<1,1>(a)/b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_ms_defined;
+
+            template <>
+            struct
+            div_ms_defined<2,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_scalar<A>::value && mat_traits<B>::rows==2 && mat_traits<B>::cols==2,
+            deduce_mat<B> >::type
+        operator/( A a, B const & b )
+            {
+            typedef typename deduce_mat<B>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a/mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=a/mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<R>::template write_element<1,0>(r)=a/mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<R>::template write_element<1,1>(r)=a/mat_traits<B>::template read_element<1,1>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_sm_defined;
+
+            template <>
+            struct
+            div_sm_defined<2,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<A>::cols==1 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        operator/( A const & a, B b )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)/b;
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)/b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_ms_defined;
+
+            template <>
+            struct
+            div_ms_defined<2,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_scalar<A>::value && mat_traits<B>::rows==2 && mat_traits<B>::cols==1,
+            deduce_mat<B> >::type
+        operator/( A a, B const & b )
+            {
+            typedef typename deduce_mat<B>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a/mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<1,0>(r)=a/mat_traits<B>::template read_element<1,0>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_sm_defined;
+
+            template <>
+            struct
+            div_sm_defined<2,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<A>::cols==2 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        operator/( A const & a, B b )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)/b;
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)/b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_ms_defined;
+
+            template <>
+            struct
+            div_ms_defined<1,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<A>::cols==2 && is_scalar<B>::value,
+            A &>::type
+        operator/=( A & a, B b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)/=b;
+            mat_traits<A>::template write_element<0,1>(a)/=b;
+            mat_traits<A>::template write_element<1,0>(a)/=b;
+            mat_traits<A>::template write_element<1,1>(a)/=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_eq_ms_defined;
+
+            template <>
+            struct
+            div_eq_ms_defined<2,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<A>::cols==1 && is_scalar<B>::value,
+            A &>::type
+        operator/=( A & a, B b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)/=b;
+            mat_traits<A>::template write_element<1,0>(a)/=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_eq_ms_defined;
+
+            template <>
+            struct
+            div_eq_ms_defined<2,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<A>::cols==2 && is_scalar<B>::value,
+            A &>::type
+        operator/=( A & a, B b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)/=b;
+            mat_traits<A>::template write_element<0,1>(a)/=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_eq_ms_defined;
+
+            template <>
+            struct
+            div_eq_ms_defined<1,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class R,class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<R>::rows==2 && mat_traits<A>::rows==2 &&
+            mat_traits<R>::cols==2 && mat_traits<A>::cols==2,
+            R>::type
+        convert_to( A const & a )
+            {
+            R r;
+            mat_traits<R>::template write_element<0,0>(r) = mat_traits<A>::template read_element<0,0>(a);
+            mat_traits<R>::template write_element<0,1>(r) = mat_traits<A>::template read_element<0,1>(a);
+            mat_traits<R>::template write_element<1,0>(r) = mat_traits<A>::template read_element<1,0>(a);
+            mat_traits<R>::template write_element<1,1>(r) = mat_traits<A>::template read_element<1,1>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::convert_to;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct convert_to_m_defined;
+
+            template <>
+            struct
+            convert_to_m_defined<2,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class R,class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<R>::rows==2 && mat_traits<A>::rows==2 &&
+            mat_traits<R>::cols==1 && mat_traits<A>::cols==1,
+            R>::type
+        convert_to( A const & a )
+            {
+            R r;
+            mat_traits<R>::template write_element<0,0>(r) = mat_traits<A>::template read_element<0,0>(a);
+            mat_traits<R>::template write_element<1,0>(r) = mat_traits<A>::template read_element<1,0>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::convert_to;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct convert_to_m_defined;
+
+            template <>
+            struct
+            convert_to_m_defined<2,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class R,class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<R>::rows==1 && mat_traits<A>::rows==1 &&
+            mat_traits<R>::cols==2 && mat_traits<A>::cols==2,
+            R>::type
+        convert_to( A const & a )
+            {
+            R r;
+            mat_traits<R>::template write_element<0,0>(r) = mat_traits<A>::template read_element<0,0>(a);
+            mat_traits<R>::template write_element<0,1>(r) = mat_traits<A>::template read_element<0,1>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::convert_to;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct convert_to_m_defined;
+
+            template <>
+            struct
+            convert_to_m_defined<1,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<B>::rows==2 &&
+            mat_traits<A>::cols==2 && mat_traits<B>::cols==2,
+            bool>::type
+        operator==( A const & a, B const & b )
+            {
+            return
+                mat_traits<A>::template read_element<0,0>(a)==mat_traits<B>::template read_element<0,0>(b) &&
+                mat_traits<A>::template read_element<0,1>(a)==mat_traits<B>::template read_element<0,1>(b) &&
+                mat_traits<A>::template read_element<1,0>(a)==mat_traits<B>::template read_element<1,0>(b) &&
+                mat_traits<A>::template read_element<1,1>(a)==mat_traits<B>::template read_element<1,1>(b);
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator==;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct eq_mm_defined;
+
+            template <>
+            struct
+            eq_mm_defined<2,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<B>::rows==2 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            bool>::type
+        operator==( A const & a, B const & b )
+            {
+            return
+                mat_traits<A>::template read_element<0,0>(a)==mat_traits<B>::template read_element<0,0>(b) &&
+                mat_traits<A>::template read_element<1,0>(a)==mat_traits<B>::template read_element<1,0>(b);
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator==;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct eq_mm_defined;
+
+            template <>
+            struct
+            eq_mm_defined<2,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==2 && mat_traits<B>::cols==2,
+            bool>::type
+        operator==( A const & a, B const & b )
+            {
+            return
+                mat_traits<A>::template read_element<0,0>(a)==mat_traits<B>::template read_element<0,0>(b) &&
+                mat_traits<A>::template read_element<0,1>(a)==mat_traits<B>::template read_element<0,1>(b);
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator==;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct eq_mm_defined;
+
+            template <>
+            struct
+            eq_mm_defined<1,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<B>::rows==2 &&
+            mat_traits<A>::cols==2 && mat_traits<B>::cols==2,
+            bool>::type
+        operator!=( A const & a, B const & b )
+            {
+            return
+                !(mat_traits<A>::template read_element<0,0>(a)==mat_traits<B>::template read_element<0,0>(b)) ||
+                !(mat_traits<A>::template read_element<0,1>(a)==mat_traits<B>::template read_element<0,1>(b)) ||
+                !(mat_traits<A>::template read_element<1,0>(a)==mat_traits<B>::template read_element<1,0>(b)) ||
+                !(mat_traits<A>::template read_element<1,1>(a)==mat_traits<B>::template read_element<1,1>(b));
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator!=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct neq_mm_defined;
+
+            template <>
+            struct
+            neq_mm_defined<2,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<B>::rows==2 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            bool>::type
+        operator!=( A const & a, B const & b )
+            {
+            return
+                !(mat_traits<A>::template read_element<0,0>(a)==mat_traits<B>::template read_element<0,0>(b)) ||
+                !(mat_traits<A>::template read_element<1,0>(a)==mat_traits<B>::template read_element<1,0>(b));
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator!=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct neq_mm_defined;
+
+            template <>
+            struct
+            neq_mm_defined<2,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==2 && mat_traits<B>::cols==2,
+            bool>::type
+        operator!=( A const & a, B const & b )
+            {
+            return
+                !(mat_traits<A>::template read_element<0,0>(a)==mat_traits<B>::template read_element<0,0>(b)) ||
+                !(mat_traits<A>::template read_element<0,1>(a)==mat_traits<B>::template read_element<0,1>(b));
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator!=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct neq_mm_defined;
+
+            template <>
+            struct
+            neq_mm_defined<1,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<A>::cols==2,
+            deduce_mat<A> >::type
+        operator-( A const & a )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=-mat_traits<A>::template read_element<0,0>(a);
+            mat_traits<R>::template write_element<0,1>(r)=-mat_traits<A>::template read_element<0,1>(a);
+            mat_traits<R>::template write_element<1,0>(r)=-mat_traits<A>::template read_element<1,0>(a);
+            mat_traits<R>::template write_element<1,1>(r)=-mat_traits<A>::template read_element<1,1>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_m_defined;
+
+            template <>
+            struct
+            minus_m_defined<2,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<A>::cols==1,
+            deduce_mat<A> >::type
+        operator-( A const & a )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=-mat_traits<A>::template read_element<0,0>(a);
+            mat_traits<R>::template write_element<1,0>(r)=-mat_traits<A>::template read_element<1,0>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_m_defined;
+
+            template <>
+            struct
+            minus_m_defined<2,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<A>::cols==2,
+            deduce_mat<A> >::type
+        operator-( A const & a )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=-mat_traits<A>::template read_element<0,0>(a);
+            mat_traits<R>::template write_element<0,1>(r)=-mat_traits<A>::template read_element<0,1>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_m_defined;
+
+            template <>
+            struct
+            minus_m_defined<1,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<A>::cols==2,
+            typename mat_traits<A>::scalar_type>::type
+        determinant( A const & a )
+            {
+            typedef typename mat_traits<A>::scalar_type T;
+            T const a00=mat_traits<A>::template read_element<0,0>(a);
+            T const a01=mat_traits<A>::template read_element<0,1>(a);
+            T const a10=mat_traits<A>::template read_element<1,0>(a);
+            T const a11=mat_traits<A>::template read_element<1,1>(a);
+            T det=(a00*a11-a01*a10);
+            return det;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::determinant;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct determinant_defined;
+
+            template <>
+            struct
+            determinant_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<A>::cols==2 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        inverse( A const & a, B det )
+            {
+            typedef typename mat_traits<A>::scalar_type T;
+            BOOST_QVM_ASSERT(det!=scalar_traits<B>::value(0));
+            T const a00=mat_traits<A>::template read_element<0,0>(a);
+            T const a01=mat_traits<A>::template read_element<0,1>(a);
+            T const a10=mat_traits<A>::template read_element<1,0>(a);
+            T const a11=mat_traits<A>::template read_element<1,1>(a);
+            T const f=scalar_traits<T>::value(1)/det;
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)= f*a11;
+            mat_traits<R>::template write_element<0,1>(r)=-f*a01;
+            mat_traits<R>::template write_element<1,0>(r)=-f*a10;
+            mat_traits<R>::template write_element<1,1>(r)= f*a00;
+            return r;
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<A>::cols==2,
+            deduce_mat<A> >::type
+        inverse( A const & a )
+            {
+            typedef typename mat_traits<A>::scalar_type T;
+            T det=determinant(a);
+            if( det==scalar_traits<T>::value(0) )
+                BOOST_QVM_THROW_EXCEPTION(zero_determinant_error());
+            return inverse(a,det);
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::inverse;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct inverse_m_defined;
+
+            template <>
+            struct
+            inverse_m_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<B>::rows==2 &&
+            mat_traits<A>::cols==2 && mat_traits<B>::cols==2,
+            deduce_mat2<A,B,2,2> >::type
+        operator*( A const & a, B const & b )
+            {
+            typedef typename mat_traits<A>::scalar_type Ta;
+            typedef typename mat_traits<B>::scalar_type Tb;
+            Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
+            Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
+            Ta const a10 = mat_traits<A>::template read_element<1,0>(a);
+            Ta const a11 = mat_traits<A>::template read_element<1,1>(a);
+            Tb const b00 = mat_traits<B>::template read_element<0,0>(b);
+            Tb const b01 = mat_traits<B>::template read_element<0,1>(b);
+            Tb const b10 = mat_traits<B>::template read_element<1,0>(b);
+            Tb const b11 = mat_traits<B>::template read_element<1,1>(b);
+            typedef typename deduce_mat2<A,B,2,2>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==2);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==2);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a00*b00+a01*b10;
+            mat_traits<R>::template write_element<0,1>(r)=a00*b01+a01*b11;
+            mat_traits<R>::template write_element<1,0>(r)=a10*b00+a11*b10;
+            mat_traits<R>::template write_element<1,1>(r)=a10*b01+a11*b11;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int CR,int C>
+            struct mul_mm_defined;
+
+            template <>
+            struct
+            mul_mm_defined<2,2,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<B>::rows==2 &&
+            mat_traits<A>::cols==2 && mat_traits<B>::cols==2,
+            A &>::type
+        operator*=( A & a, B const & b )
+            {
+            typedef typename mat_traits<A>::scalar_type Ta;
+            typedef typename mat_traits<B>::scalar_type Tb;
+            Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
+            Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
+            Ta const a10 = mat_traits<A>::template read_element<1,0>(a);
+            Ta const a11 = mat_traits<A>::template read_element<1,1>(a);
+            Tb const b00 = mat_traits<B>::template read_element<0,0>(b);
+            Tb const b01 = mat_traits<B>::template read_element<0,1>(b);
+            Tb const b10 = mat_traits<B>::template read_element<1,0>(b);
+            Tb const b11 = mat_traits<B>::template read_element<1,1>(b);
+            mat_traits<A>::template write_element<0,0>(a)=a00*b00+a01*b10;
+            mat_traits<A>::template write_element<0,1>(a)=a00*b01+a01*b11;
+            mat_traits<A>::template write_element<1,0>(a)=a10*b00+a11*b10;
+            mat_traits<A>::template write_element<1,1>(a)=a10*b01+a11*b11;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct mul_eq_mm_defined;
+
+            template <>
+            struct
+            mul_eq_mm_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<B>::rows==2 &&
+            mat_traits<A>::cols==2 && mat_traits<B>::cols==1,
+            deduce_mat2<A,B,2,1> >::type
+        operator*( A const & a, B const & b )
+            {
+            typedef typename mat_traits<A>::scalar_type Ta;
+            typedef typename mat_traits<B>::scalar_type Tb;
+            Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
+            Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
+            Ta const a10 = mat_traits<A>::template read_element<1,0>(a);
+            Ta const a11 = mat_traits<A>::template read_element<1,1>(a);
+            Tb const b00 = mat_traits<B>::template read_element<0,0>(b);
+            Tb const b10 = mat_traits<B>::template read_element<1,0>(b);
+            typedef typename deduce_mat2<A,B,2,1>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==2);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==1);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a00*b00+a01*b10;
+            mat_traits<R>::template write_element<1,0>(r)=a10*b00+a11*b10;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int CR,int C>
+            struct mul_mm_defined;
+
+            template <>
+            struct
+            mul_mm_defined<2,2,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==2 &&
+            mat_traits<A>::cols==2 && mat_traits<B>::cols==2,
+            deduce_mat2<A,B,1,2> >::type
+        operator*( A const & a, B const & b )
+            {
+            typedef typename mat_traits<A>::scalar_type Ta;
+            typedef typename mat_traits<B>::scalar_type Tb;
+            Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
+            Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
+            Tb const b00 = mat_traits<B>::template read_element<0,0>(b);
+            Tb const b01 = mat_traits<B>::template read_element<0,1>(b);
+            Tb const b10 = mat_traits<B>::template read_element<1,0>(b);
+            Tb const b11 = mat_traits<B>::template read_element<1,1>(b);
+            typedef typename deduce_mat2<A,B,1,2>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==1);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==2);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a00*b00+a01*b10;
+            mat_traits<R>::template write_element<0,1>(r)=a00*b01+a01*b11;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int CR,int C>
+            struct mul_mm_defined;
+
+            template <>
+            struct
+            mul_mm_defined<1,2,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_operations3.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_operations3.hpp
new file mode 100644
index 00000000000..31cf755dabd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_operations3.hpp
@@ -0,0 +1,1915 @@
+//Copyright (c) 2008-2017 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_B3A6DB3C87C3E99245ED1C6B747DE
+#define BOOST_QVM_B3A6DB3C87C3E99245ED1C6B747DE
+
+//This file was generated by a program. Do not edit manually.
+
+#include <boost/qvm/assert.hpp>
+#include <boost/qvm/deduce_mat.hpp>
+#include <boost/qvm/deduce_vec.hpp>
+#include <boost/qvm/error.hpp>
+#include <boost/qvm/gen/mat_assign3.hpp>
+#include <boost/qvm/quat_traits.hpp>
+#include <boost/qvm/scalar_traits.hpp>
+#include <boost/qvm/throw_exception.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<B>::rows==3 &&
+            mat_traits<A>::cols==3 && mat_traits<B>::cols==3,
+            deduce_mat2<A,B,3,3> >::type
+        operator+( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,3,3>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==3);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==3);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)+mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)+mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<R>::template write_element<0,2>(r)=mat_traits<A>::template read_element<0,2>(a)+mat_traits<B>::template read_element<0,2>(b);
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)+mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<R>::template write_element<1,1>(r)=mat_traits<A>::template read_element<1,1>(a)+mat_traits<B>::template read_element<1,1>(b);
+            mat_traits<R>::template write_element<1,2>(r)=mat_traits<A>::template read_element<1,2>(a)+mat_traits<B>::template read_element<1,2>(b);
+            mat_traits<R>::template write_element<2,0>(r)=mat_traits<A>::template read_element<2,0>(a)+mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<R>::template write_element<2,1>(r)=mat_traits<A>::template read_element<2,1>(a)+mat_traits<B>::template read_element<2,1>(b);
+            mat_traits<R>::template write_element<2,2>(r)=mat_traits<A>::template read_element<2,2>(a)+mat_traits<B>::template read_element<2,2>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct plus_mm_defined;
+
+            template <>
+            struct
+            plus_mm_defined<3,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<B>::rows==3 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            deduce_mat2<A,B,3,1> >::type
+        operator+( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,3,1>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==3);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==1);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)+mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)+mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<R>::template write_element<2,0>(r)=mat_traits<A>::template read_element<2,0>(a)+mat_traits<B>::template read_element<2,0>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct plus_mm_defined;
+
+            template <>
+            struct
+            plus_mm_defined<3,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==3 && mat_traits<B>::cols==3,
+            deduce_mat2<A,B,1,3> >::type
+        operator+( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,1,3>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==1);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==3);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)+mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)+mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<R>::template write_element<0,2>(r)=mat_traits<A>::template read_element<0,2>(a)+mat_traits<B>::template read_element<0,2>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct plus_mm_defined;
+
+            template <>
+            struct
+            plus_mm_defined<1,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<B>::rows==3 &&
+            mat_traits<A>::cols==3 && mat_traits<B>::cols==3,
+            deduce_mat2<A,B,3,3> >::type
+        operator-( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,3,3>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==3);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==3);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)-mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)-mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<R>::template write_element<0,2>(r)=mat_traits<A>::template read_element<0,2>(a)-mat_traits<B>::template read_element<0,2>(b);
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)-mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<R>::template write_element<1,1>(r)=mat_traits<A>::template read_element<1,1>(a)-mat_traits<B>::template read_element<1,1>(b);
+            mat_traits<R>::template write_element<1,2>(r)=mat_traits<A>::template read_element<1,2>(a)-mat_traits<B>::template read_element<1,2>(b);
+            mat_traits<R>::template write_element<2,0>(r)=mat_traits<A>::template read_element<2,0>(a)-mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<R>::template write_element<2,1>(r)=mat_traits<A>::template read_element<2,1>(a)-mat_traits<B>::template read_element<2,1>(b);
+            mat_traits<R>::template write_element<2,2>(r)=mat_traits<A>::template read_element<2,2>(a)-mat_traits<B>::template read_element<2,2>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_mm_defined;
+
+            template <>
+            struct
+            minus_mm_defined<3,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<B>::rows==3 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            deduce_mat2<A,B,3,1> >::type
+        operator-( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,3,1>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==3);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==1);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)-mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)-mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<R>::template write_element<2,0>(r)=mat_traits<A>::template read_element<2,0>(a)-mat_traits<B>::template read_element<2,0>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_mm_defined;
+
+            template <>
+            struct
+            minus_mm_defined<3,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==3 && mat_traits<B>::cols==3,
+            deduce_mat2<A,B,1,3> >::type
+        operator-( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,1,3>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==1);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==3);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)-mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)-mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<R>::template write_element<0,2>(r)=mat_traits<A>::template read_element<0,2>(a)-mat_traits<B>::template read_element<0,2>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_mm_defined;
+
+            template <>
+            struct
+            minus_mm_defined<1,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<B>::rows==3 &&
+            mat_traits<A>::cols==3 && mat_traits<B>::cols==3,
+            A &>::type
+        operator+=( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)+=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<0,1>(a)+=mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<A>::template write_element<0,2>(a)+=mat_traits<B>::template read_element<0,2>(b);
+            mat_traits<A>::template write_element<1,0>(a)+=mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<A>::template write_element<1,1>(a)+=mat_traits<B>::template read_element<1,1>(b);
+            mat_traits<A>::template write_element<1,2>(a)+=mat_traits<B>::template read_element<1,2>(b);
+            mat_traits<A>::template write_element<2,0>(a)+=mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<A>::template write_element<2,1>(a)+=mat_traits<B>::template read_element<2,1>(b);
+            mat_traits<A>::template write_element<2,2>(a)+=mat_traits<B>::template read_element<2,2>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct plus_eq_mm_defined;
+
+            template <>
+            struct
+            plus_eq_mm_defined<3,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<B>::rows==3 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            A &>::type
+        operator+=( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)+=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<1,0>(a)+=mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<A>::template write_element<2,0>(a)+=mat_traits<B>::template read_element<2,0>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct plus_eq_mm_defined;
+
+            template <>
+            struct
+            plus_eq_mm_defined<3,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==3 && mat_traits<B>::cols==3,
+            A &>::type
+        operator+=( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)+=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<0,1>(a)+=mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<A>::template write_element<0,2>(a)+=mat_traits<B>::template read_element<0,2>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct plus_eq_mm_defined;
+
+            template <>
+            struct
+            plus_eq_mm_defined<1,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<B>::rows==3 &&
+            mat_traits<A>::cols==3 && mat_traits<B>::cols==3,
+            A &>::type
+        operator-=( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)-=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<0,1>(a)-=mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<A>::template write_element<0,2>(a)-=mat_traits<B>::template read_element<0,2>(b);
+            mat_traits<A>::template write_element<1,0>(a)-=mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<A>::template write_element<1,1>(a)-=mat_traits<B>::template read_element<1,1>(b);
+            mat_traits<A>::template write_element<1,2>(a)-=mat_traits<B>::template read_element<1,2>(b);
+            mat_traits<A>::template write_element<2,0>(a)-=mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<A>::template write_element<2,1>(a)-=mat_traits<B>::template read_element<2,1>(b);
+            mat_traits<A>::template write_element<2,2>(a)-=mat_traits<B>::template read_element<2,2>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_eq_mm_defined;
+
+            template <>
+            struct
+            minus_eq_mm_defined<3,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<B>::rows==3 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            A &>::type
+        operator-=( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)-=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<1,0>(a)-=mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<A>::template write_element<2,0>(a)-=mat_traits<B>::template read_element<2,0>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_eq_mm_defined;
+
+            template <>
+            struct
+            minus_eq_mm_defined<3,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==3 && mat_traits<B>::cols==3,
+            A &>::type
+        operator-=( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)-=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<0,1>(a)-=mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<A>::template write_element<0,2>(a)-=mat_traits<B>::template read_element<0,2>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_eq_mm_defined;
+
+            template <>
+            struct
+            minus_eq_mm_defined<1,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<A>::cols==3 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        operator*( A const & a, B b )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)*b;
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)*b;
+            mat_traits<R>::template write_element<0,2>(r)=mat_traits<A>::template read_element<0,2>(a)*b;
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)*b;
+            mat_traits<R>::template write_element<1,1>(r)=mat_traits<A>::template read_element<1,1>(a)*b;
+            mat_traits<R>::template write_element<1,2>(r)=mat_traits<A>::template read_element<1,2>(a)*b;
+            mat_traits<R>::template write_element<2,0>(r)=mat_traits<A>::template read_element<2,0>(a)*b;
+            mat_traits<R>::template write_element<2,1>(r)=mat_traits<A>::template read_element<2,1>(a)*b;
+            mat_traits<R>::template write_element<2,2>(r)=mat_traits<A>::template read_element<2,2>(a)*b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_ms_defined;
+
+            template <>
+            struct
+            mul_ms_defined<3,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_scalar<A>::value && mat_traits<B>::rows==3 && mat_traits<B>::cols==3,
+            deduce_mat<B> >::type
+        operator*( A a, B const & b )
+            {
+            typedef typename deduce_mat<B>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a*mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=a*mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<R>::template write_element<0,2>(r)=a*mat_traits<B>::template read_element<0,2>(b);
+            mat_traits<R>::template write_element<1,0>(r)=a*mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<R>::template write_element<1,1>(r)=a*mat_traits<B>::template read_element<1,1>(b);
+            mat_traits<R>::template write_element<1,2>(r)=a*mat_traits<B>::template read_element<1,2>(b);
+            mat_traits<R>::template write_element<2,0>(r)=a*mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<R>::template write_element<2,1>(r)=a*mat_traits<B>::template read_element<2,1>(b);
+            mat_traits<R>::template write_element<2,2>(r)=a*mat_traits<B>::template read_element<2,2>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_sm_defined;
+
+            template <>
+            struct
+            mul_sm_defined<3,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<A>::cols==1 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        operator*( A const & a, B b )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)*b;
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)*b;
+            mat_traits<R>::template write_element<2,0>(r)=mat_traits<A>::template read_element<2,0>(a)*b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_ms_defined;
+
+            template <>
+            struct
+            mul_ms_defined<3,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_scalar<A>::value && mat_traits<B>::rows==3 && mat_traits<B>::cols==1,
+            deduce_mat<B> >::type
+        operator*( A a, B const & b )
+            {
+            typedef typename deduce_mat<B>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a*mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<1,0>(r)=a*mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<R>::template write_element<2,0>(r)=a*mat_traits<B>::template read_element<2,0>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_sm_defined;
+
+            template <>
+            struct
+            mul_sm_defined<3,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<A>::cols==3 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        operator*( A const & a, B b )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)*b;
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)*b;
+            mat_traits<R>::template write_element<0,2>(r)=mat_traits<A>::template read_element<0,2>(a)*b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_ms_defined;
+
+            template <>
+            struct
+            mul_ms_defined<1,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_scalar<A>::value && mat_traits<B>::rows==1 && mat_traits<B>::cols==3,
+            deduce_mat<B> >::type
+        operator*( A a, B const & b )
+            {
+            typedef typename deduce_mat<B>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a*mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=a*mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<R>::template write_element<0,2>(r)=a*mat_traits<B>::template read_element<0,2>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_sm_defined;
+
+            template <>
+            struct
+            mul_sm_defined<1,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<A>::cols==3 && is_scalar<B>::value,
+            A &>::type
+        operator*=( A & a, B b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)*=b;
+            mat_traits<A>::template write_element<0,1>(a)*=b;
+            mat_traits<A>::template write_element<0,2>(a)*=b;
+            mat_traits<A>::template write_element<1,0>(a)*=b;
+            mat_traits<A>::template write_element<1,1>(a)*=b;
+            mat_traits<A>::template write_element<1,2>(a)*=b;
+            mat_traits<A>::template write_element<2,0>(a)*=b;
+            mat_traits<A>::template write_element<2,1>(a)*=b;
+            mat_traits<A>::template write_element<2,2>(a)*=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_eq_ms_defined;
+
+            template <>
+            struct
+            mul_eq_ms_defined<3,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<A>::cols==1 && is_scalar<B>::value,
+            A &>::type
+        operator*=( A & a, B b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)*=b;
+            mat_traits<A>::template write_element<1,0>(a)*=b;
+            mat_traits<A>::template write_element<2,0>(a)*=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_eq_ms_defined;
+
+            template <>
+            struct
+            mul_eq_ms_defined<3,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<A>::cols==3 && is_scalar<B>::value,
+            A &>::type
+        operator*=( A & a, B b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)*=b;
+            mat_traits<A>::template write_element<0,1>(a)*=b;
+            mat_traits<A>::template write_element<0,2>(a)*=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_eq_ms_defined;
+
+            template <>
+            struct
+            mul_eq_ms_defined<1,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<A>::cols==3 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        operator/( A const & a, B b )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)/b;
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)/b;
+            mat_traits<R>::template write_element<0,2>(r)=mat_traits<A>::template read_element<0,2>(a)/b;
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)/b;
+            mat_traits<R>::template write_element<1,1>(r)=mat_traits<A>::template read_element<1,1>(a)/b;
+            mat_traits<R>::template write_element<1,2>(r)=mat_traits<A>::template read_element<1,2>(a)/b;
+            mat_traits<R>::template write_element<2,0>(r)=mat_traits<A>::template read_element<2,0>(a)/b;
+            mat_traits<R>::template write_element<2,1>(r)=mat_traits<A>::template read_element<2,1>(a)/b;
+            mat_traits<R>::template write_element<2,2>(r)=mat_traits<A>::template read_element<2,2>(a)/b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_ms_defined;
+
+            template <>
+            struct
+            div_ms_defined<3,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_scalar<A>::value && mat_traits<B>::rows==3 && mat_traits<B>::cols==3,
+            deduce_mat<B> >::type
+        operator/( A a, B const & b )
+            {
+            typedef typename deduce_mat<B>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a/mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=a/mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<R>::template write_element<0,2>(r)=a/mat_traits<B>::template read_element<0,2>(b);
+            mat_traits<R>::template write_element<1,0>(r)=a/mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<R>::template write_element<1,1>(r)=a/mat_traits<B>::template read_element<1,1>(b);
+            mat_traits<R>::template write_element<1,2>(r)=a/mat_traits<B>::template read_element<1,2>(b);
+            mat_traits<R>::template write_element<2,0>(r)=a/mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<R>::template write_element<2,1>(r)=a/mat_traits<B>::template read_element<2,1>(b);
+            mat_traits<R>::template write_element<2,2>(r)=a/mat_traits<B>::template read_element<2,2>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_sm_defined;
+
+            template <>
+            struct
+            div_sm_defined<3,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<A>::cols==1 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        operator/( A const & a, B b )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)/b;
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)/b;
+            mat_traits<R>::template write_element<2,0>(r)=mat_traits<A>::template read_element<2,0>(a)/b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_ms_defined;
+
+            template <>
+            struct
+            div_ms_defined<3,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_scalar<A>::value && mat_traits<B>::rows==3 && mat_traits<B>::cols==1,
+            deduce_mat<B> >::type
+        operator/( A a, B const & b )
+            {
+            typedef typename deduce_mat<B>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a/mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<1,0>(r)=a/mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<R>::template write_element<2,0>(r)=a/mat_traits<B>::template read_element<2,0>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_sm_defined;
+
+            template <>
+            struct
+            div_sm_defined<3,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<A>::cols==3 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        operator/( A const & a, B b )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)/b;
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)/b;
+            mat_traits<R>::template write_element<0,2>(r)=mat_traits<A>::template read_element<0,2>(a)/b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_ms_defined;
+
+            template <>
+            struct
+            div_ms_defined<1,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<A>::cols==3 && is_scalar<B>::value,
+            A &>::type
+        operator/=( A & a, B b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)/=b;
+            mat_traits<A>::template write_element<0,1>(a)/=b;
+            mat_traits<A>::template write_element<0,2>(a)/=b;
+            mat_traits<A>::template write_element<1,0>(a)/=b;
+            mat_traits<A>::template write_element<1,1>(a)/=b;
+            mat_traits<A>::template write_element<1,2>(a)/=b;
+            mat_traits<A>::template write_element<2,0>(a)/=b;
+            mat_traits<A>::template write_element<2,1>(a)/=b;
+            mat_traits<A>::template write_element<2,2>(a)/=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_eq_ms_defined;
+
+            template <>
+            struct
+            div_eq_ms_defined<3,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<A>::cols==1 && is_scalar<B>::value,
+            A &>::type
+        operator/=( A & a, B b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)/=b;
+            mat_traits<A>::template write_element<1,0>(a)/=b;
+            mat_traits<A>::template write_element<2,0>(a)/=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_eq_ms_defined;
+
+            template <>
+            struct
+            div_eq_ms_defined<3,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<A>::cols==3 && is_scalar<B>::value,
+            A &>::type
+        operator/=( A & a, B b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)/=b;
+            mat_traits<A>::template write_element<0,1>(a)/=b;
+            mat_traits<A>::template write_element<0,2>(a)/=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_eq_ms_defined;
+
+            template <>
+            struct
+            div_eq_ms_defined<1,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class R,class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<R>::rows==3 && mat_traits<A>::rows==3 &&
+            mat_traits<R>::cols==3 && mat_traits<A>::cols==3,
+            R>::type
+        convert_to( A const & a )
+            {
+            R r;
+            mat_traits<R>::template write_element<0,0>(r) = mat_traits<A>::template read_element<0,0>(a);
+            mat_traits<R>::template write_element<0,1>(r) = mat_traits<A>::template read_element<0,1>(a);
+            mat_traits<R>::template write_element<0,2>(r) = mat_traits<A>::template read_element<0,2>(a);
+            mat_traits<R>::template write_element<1,0>(r) = mat_traits<A>::template read_element<1,0>(a);
+            mat_traits<R>::template write_element<1,1>(r) = mat_traits<A>::template read_element<1,1>(a);
+            mat_traits<R>::template write_element<1,2>(r) = mat_traits<A>::template read_element<1,2>(a);
+            mat_traits<R>::template write_element<2,0>(r) = mat_traits<A>::template read_element<2,0>(a);
+            mat_traits<R>::template write_element<2,1>(r) = mat_traits<A>::template read_element<2,1>(a);
+            mat_traits<R>::template write_element<2,2>(r) = mat_traits<A>::template read_element<2,2>(a);
+            return r;
+            }
+
+        template <class R,class A>
+        BOOST_QVM_INLINE
+        typename enable_if_c<
+            is_mat<R>::value && is_quat<A>::value &&
+            mat_traits<R>::rows==3 && mat_traits<R>::cols==3,
+            R>::type
+        convert_to( A const & q )
+            {
+            typedef typename mat_traits<R>::scalar_type T;
+            T const a=quat_traits<A>::template read_element<0>(q);
+            T const b=quat_traits<A>::template read_element<1>(q);
+            T const c=quat_traits<A>::template read_element<2>(q);
+            T const d=quat_traits<A>::template read_element<3>(q);
+            T const bb = b*b;
+            T const cc = c*c;
+            T const dd = d*d;
+            T const bc = b*c;
+            T const bd = b*d;
+            T const cd = c*d;
+            T const ab = a*b;
+            T const ac = a*c;
+            T const ad = a*d;
+            T const one = scalar_traits<T>::value(1);
+            T const two = one+one;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r) = one - two*(cc+dd);
+            mat_traits<R>::template write_element<0,1>(r) = two*(bc-ad);
+            mat_traits<R>::template write_element<0,2>(r) = two*(bd+ac);
+            mat_traits<R>::template write_element<1,0>(r) = two*(bc+ad);
+            mat_traits<R>::template write_element<1,1>(r) = one - two*(bb+dd);
+            mat_traits<R>::template write_element<1,2>(r) = two*(cd-ab);
+            mat_traits<R>::template write_element<2,0>(r) = two*(bd-ac);
+            mat_traits<R>::template write_element<2,1>(r) = two*(cd+ab);
+            mat_traits<R>::template write_element<2,2>(r) = one - two*(bb+cc);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::convert_to;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct convert_to_m_defined;
+
+            template <>
+            struct
+            convert_to_m_defined<3,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class R,class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<R>::rows==3 && mat_traits<A>::rows==3 &&
+            mat_traits<R>::cols==1 && mat_traits<A>::cols==1,
+            R>::type
+        convert_to( A const & a )
+            {
+            R r;
+            mat_traits<R>::template write_element<0,0>(r) = mat_traits<A>::template read_element<0,0>(a);
+            mat_traits<R>::template write_element<1,0>(r) = mat_traits<A>::template read_element<1,0>(a);
+            mat_traits<R>::template write_element<2,0>(r) = mat_traits<A>::template read_element<2,0>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::convert_to;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct convert_to_m_defined;
+
+            template <>
+            struct
+            convert_to_m_defined<3,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class R,class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<R>::rows==1 && mat_traits<A>::rows==1 &&
+            mat_traits<R>::cols==3 && mat_traits<A>::cols==3,
+            R>::type
+        convert_to( A const & a )
+            {
+            R r;
+            mat_traits<R>::template write_element<0,0>(r) = mat_traits<A>::template read_element<0,0>(a);
+            mat_traits<R>::template write_element<0,1>(r) = mat_traits<A>::template read_element<0,1>(a);
+            mat_traits<R>::template write_element<0,2>(r) = mat_traits<A>::template read_element<0,2>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::convert_to;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct convert_to_m_defined;
+
+            template <>
+            struct
+            convert_to_m_defined<1,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<B>::rows==3 &&
+            mat_traits<A>::cols==3 && mat_traits<B>::cols==3,
+            bool>::type
+        operator==( A const & a, B const & b )
+            {
+            return
+                mat_traits<A>::template read_element<0,0>(a)==mat_traits<B>::template read_element<0,0>(b) &&
+                mat_traits<A>::template read_element<0,1>(a)==mat_traits<B>::template read_element<0,1>(b) &&
+                mat_traits<A>::template read_element<0,2>(a)==mat_traits<B>::template read_element<0,2>(b) &&
+                mat_traits<A>::template read_element<1,0>(a)==mat_traits<B>::template read_element<1,0>(b) &&
+                mat_traits<A>::template read_element<1,1>(a)==mat_traits<B>::template read_element<1,1>(b) &&
+                mat_traits<A>::template read_element<1,2>(a)==mat_traits<B>::template read_element<1,2>(b) &&
+                mat_traits<A>::template read_element<2,0>(a)==mat_traits<B>::template read_element<2,0>(b) &&
+                mat_traits<A>::template read_element<2,1>(a)==mat_traits<B>::template read_element<2,1>(b) &&
+                mat_traits<A>::template read_element<2,2>(a)==mat_traits<B>::template read_element<2,2>(b);
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator==;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct eq_mm_defined;
+
+            template <>
+            struct
+            eq_mm_defined<3,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<B>::rows==3 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            bool>::type
+        operator==( A const & a, B const & b )
+            {
+            return
+                mat_traits<A>::template read_element<0,0>(a)==mat_traits<B>::template read_element<0,0>(b) &&
+                mat_traits<A>::template read_element<1,0>(a)==mat_traits<B>::template read_element<1,0>(b) &&
+                mat_traits<A>::template read_element<2,0>(a)==mat_traits<B>::template read_element<2,0>(b);
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator==;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct eq_mm_defined;
+
+            template <>
+            struct
+            eq_mm_defined<3,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==3 && mat_traits<B>::cols==3,
+            bool>::type
+        operator==( A const & a, B const & b )
+            {
+            return
+                mat_traits<A>::template read_element<0,0>(a)==mat_traits<B>::template read_element<0,0>(b) &&
+                mat_traits<A>::template read_element<0,1>(a)==mat_traits<B>::template read_element<0,1>(b) &&
+                mat_traits<A>::template read_element<0,2>(a)==mat_traits<B>::template read_element<0,2>(b);
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator==;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct eq_mm_defined;
+
+            template <>
+            struct
+            eq_mm_defined<1,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<B>::rows==3 &&
+            mat_traits<A>::cols==3 && mat_traits<B>::cols==3,
+            bool>::type
+        operator!=( A const & a, B const & b )
+            {
+            return
+                !(mat_traits<A>::template read_element<0,0>(a)==mat_traits<B>::template read_element<0,0>(b)) ||
+                !(mat_traits<A>::template read_element<0,1>(a)==mat_traits<B>::template read_element<0,1>(b)) ||
+                !(mat_traits<A>::template read_element<0,2>(a)==mat_traits<B>::template read_element<0,2>(b)) ||
+                !(mat_traits<A>::template read_element<1,0>(a)==mat_traits<B>::template read_element<1,0>(b)) ||
+                !(mat_traits<A>::template read_element<1,1>(a)==mat_traits<B>::template read_element<1,1>(b)) ||
+                !(mat_traits<A>::template read_element<1,2>(a)==mat_traits<B>::template read_element<1,2>(b)) ||
+                !(mat_traits<A>::template read_element<2,0>(a)==mat_traits<B>::template read_element<2,0>(b)) ||
+                !(mat_traits<A>::template read_element<2,1>(a)==mat_traits<B>::template read_element<2,1>(b)) ||
+                !(mat_traits<A>::template read_element<2,2>(a)==mat_traits<B>::template read_element<2,2>(b));
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator!=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct neq_mm_defined;
+
+            template <>
+            struct
+            neq_mm_defined<3,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<B>::rows==3 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            bool>::type
+        operator!=( A const & a, B const & b )
+            {
+            return
+                !(mat_traits<A>::template read_element<0,0>(a)==mat_traits<B>::template read_element<0,0>(b)) ||
+                !(mat_traits<A>::template read_element<1,0>(a)==mat_traits<B>::template read_element<1,0>(b)) ||
+                !(mat_traits<A>::template read_element<2,0>(a)==mat_traits<B>::template read_element<2,0>(b));
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator!=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct neq_mm_defined;
+
+            template <>
+            struct
+            neq_mm_defined<3,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==3 && mat_traits<B>::cols==3,
+            bool>::type
+        operator!=( A const & a, B const & b )
+            {
+            return
+                !(mat_traits<A>::template read_element<0,0>(a)==mat_traits<B>::template read_element<0,0>(b)) ||
+                !(mat_traits<A>::template read_element<0,1>(a)==mat_traits<B>::template read_element<0,1>(b)) ||
+                !(mat_traits<A>::template read_element<0,2>(a)==mat_traits<B>::template read_element<0,2>(b));
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator!=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct neq_mm_defined;
+
+            template <>
+            struct
+            neq_mm_defined<1,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<A>::cols==3,
+            deduce_mat<A> >::type
+        operator-( A const & a )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=-mat_traits<A>::template read_element<0,0>(a);
+            mat_traits<R>::template write_element<0,1>(r)=-mat_traits<A>::template read_element<0,1>(a);
+            mat_traits<R>::template write_element<0,2>(r)=-mat_traits<A>::template read_element<0,2>(a);
+            mat_traits<R>::template write_element<1,0>(r)=-mat_traits<A>::template read_element<1,0>(a);
+            mat_traits<R>::template write_element<1,1>(r)=-mat_traits<A>::template read_element<1,1>(a);
+            mat_traits<R>::template write_element<1,2>(r)=-mat_traits<A>::template read_element<1,2>(a);
+            mat_traits<R>::template write_element<2,0>(r)=-mat_traits<A>::template read_element<2,0>(a);
+            mat_traits<R>::template write_element<2,1>(r)=-mat_traits<A>::template read_element<2,1>(a);
+            mat_traits<R>::template write_element<2,2>(r)=-mat_traits<A>::template read_element<2,2>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_m_defined;
+
+            template <>
+            struct
+            minus_m_defined<3,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<A>::cols==1,
+            deduce_mat<A> >::type
+        operator-( A const & a )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=-mat_traits<A>::template read_element<0,0>(a);
+            mat_traits<R>::template write_element<1,0>(r)=-mat_traits<A>::template read_element<1,0>(a);
+            mat_traits<R>::template write_element<2,0>(r)=-mat_traits<A>::template read_element<2,0>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_m_defined;
+
+            template <>
+            struct
+            minus_m_defined<3,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<A>::cols==3,
+            deduce_mat<A> >::type
+        operator-( A const & a )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=-mat_traits<A>::template read_element<0,0>(a);
+            mat_traits<R>::template write_element<0,1>(r)=-mat_traits<A>::template read_element<0,1>(a);
+            mat_traits<R>::template write_element<0,2>(r)=-mat_traits<A>::template read_element<0,2>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_m_defined;
+
+            template <>
+            struct
+            minus_m_defined<1,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<A>::cols==3,
+            typename mat_traits<A>::scalar_type>::type
+        determinant( A const & a )
+            {
+            typedef typename mat_traits<A>::scalar_type T;
+            T const a00=mat_traits<A>::template read_element<0,0>(a);
+            T const a01=mat_traits<A>::template read_element<0,1>(a);
+            T const a02=mat_traits<A>::template read_element<0,2>(a);
+            T const a10=mat_traits<A>::template read_element<1,0>(a);
+            T const a11=mat_traits<A>::template read_element<1,1>(a);
+            T const a12=mat_traits<A>::template read_element<1,2>(a);
+            T const a20=mat_traits<A>::template read_element<2,0>(a);
+            T const a21=mat_traits<A>::template read_element<2,1>(a);
+            T const a22=mat_traits<A>::template read_element<2,2>(a);
+            T det=(a00*(a11*a22-a12*a21)-a01*(a10*a22-a12*a20)+a02*(a10*a21-a11*a20));
+            return det;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::determinant;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct determinant_defined;
+
+            template <>
+            struct
+            determinant_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<A>::cols==3 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        inverse( A const & a, B det )
+            {
+            typedef typename mat_traits<A>::scalar_type T;
+            BOOST_QVM_ASSERT(det!=scalar_traits<B>::value(0));
+            T const a00=mat_traits<A>::template read_element<0,0>(a);
+            T const a01=mat_traits<A>::template read_element<0,1>(a);
+            T const a02=mat_traits<A>::template read_element<0,2>(a);
+            T const a10=mat_traits<A>::template read_element<1,0>(a);
+            T const a11=mat_traits<A>::template read_element<1,1>(a);
+            T const a12=mat_traits<A>::template read_element<1,2>(a);
+            T const a20=mat_traits<A>::template read_element<2,0>(a);
+            T const a21=mat_traits<A>::template read_element<2,1>(a);
+            T const a22=mat_traits<A>::template read_element<2,2>(a);
+            T const f=scalar_traits<T>::value(1)/det;
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)= f*(a11*a22-a12*a21);
+            mat_traits<R>::template write_element<0,1>(r)=-f*(a01*a22-a02*a21);
+            mat_traits<R>::template write_element<0,2>(r)= f*(a01*a12-a02*a11);
+            mat_traits<R>::template write_element<1,0>(r)=-f*(a10*a22-a12*a20);
+            mat_traits<R>::template write_element<1,1>(r)= f*(a00*a22-a02*a20);
+            mat_traits<R>::template write_element<1,2>(r)=-f*(a00*a12-a02*a10);
+            mat_traits<R>::template write_element<2,0>(r)= f*(a10*a21-a11*a20);
+            mat_traits<R>::template write_element<2,1>(r)=-f*(a00*a21-a01*a20);
+            mat_traits<R>::template write_element<2,2>(r)= f*(a00*a11-a01*a10);
+            return r;
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<A>::cols==3,
+            deduce_mat<A> >::type
+        inverse( A const & a )
+            {
+            typedef typename mat_traits<A>::scalar_type T;
+            T det=determinant(a);
+            if( det==scalar_traits<T>::value(0) )
+                BOOST_QVM_THROW_EXCEPTION(zero_determinant_error());
+            return inverse(a,det);
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::inverse;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct inverse_m_defined;
+
+            template <>
+            struct
+            inverse_m_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<B>::rows==3 &&
+            mat_traits<A>::cols==3 && mat_traits<B>::cols==3,
+            deduce_mat2<A,B,3,3> >::type
+        operator*( A const & a, B const & b )
+            {
+            typedef typename mat_traits<A>::scalar_type Ta;
+            typedef typename mat_traits<B>::scalar_type Tb;
+            Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
+            Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
+            Ta const a02 = mat_traits<A>::template read_element<0,2>(a);
+            Ta const a10 = mat_traits<A>::template read_element<1,0>(a);
+            Ta const a11 = mat_traits<A>::template read_element<1,1>(a);
+            Ta const a12 = mat_traits<A>::template read_element<1,2>(a);
+            Ta const a20 = mat_traits<A>::template read_element<2,0>(a);
+            Ta const a21 = mat_traits<A>::template read_element<2,1>(a);
+            Ta const a22 = mat_traits<A>::template read_element<2,2>(a);
+            Tb const b00 = mat_traits<B>::template read_element<0,0>(b);
+            Tb const b01 = mat_traits<B>::template read_element<0,1>(b);
+            Tb const b02 = mat_traits<B>::template read_element<0,2>(b);
+            Tb const b10 = mat_traits<B>::template read_element<1,0>(b);
+            Tb const b11 = mat_traits<B>::template read_element<1,1>(b);
+            Tb const b12 = mat_traits<B>::template read_element<1,2>(b);
+            Tb const b20 = mat_traits<B>::template read_element<2,0>(b);
+            Tb const b21 = mat_traits<B>::template read_element<2,1>(b);
+            Tb const b22 = mat_traits<B>::template read_element<2,2>(b);
+            typedef typename deduce_mat2<A,B,3,3>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==3);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==3);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a00*b00+a01*b10+a02*b20;
+            mat_traits<R>::template write_element<0,1>(r)=a00*b01+a01*b11+a02*b21;
+            mat_traits<R>::template write_element<0,2>(r)=a00*b02+a01*b12+a02*b22;
+            mat_traits<R>::template write_element<1,0>(r)=a10*b00+a11*b10+a12*b20;
+            mat_traits<R>::template write_element<1,1>(r)=a10*b01+a11*b11+a12*b21;
+            mat_traits<R>::template write_element<1,2>(r)=a10*b02+a11*b12+a12*b22;
+            mat_traits<R>::template write_element<2,0>(r)=a20*b00+a21*b10+a22*b20;
+            mat_traits<R>::template write_element<2,1>(r)=a20*b01+a21*b11+a22*b21;
+            mat_traits<R>::template write_element<2,2>(r)=a20*b02+a21*b12+a22*b22;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int CR,int C>
+            struct mul_mm_defined;
+
+            template <>
+            struct
+            mul_mm_defined<3,3,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<B>::rows==3 &&
+            mat_traits<A>::cols==3 && mat_traits<B>::cols==3,
+            A &>::type
+        operator*=( A & a, B const & b )
+            {
+            typedef typename mat_traits<A>::scalar_type Ta;
+            typedef typename mat_traits<B>::scalar_type Tb;
+            Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
+            Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
+            Ta const a02 = mat_traits<A>::template read_element<0,2>(a);
+            Ta const a10 = mat_traits<A>::template read_element<1,0>(a);
+            Ta const a11 = mat_traits<A>::template read_element<1,1>(a);
+            Ta const a12 = mat_traits<A>::template read_element<1,2>(a);
+            Ta const a20 = mat_traits<A>::template read_element<2,0>(a);
+            Ta const a21 = mat_traits<A>::template read_element<2,1>(a);
+            Ta const a22 = mat_traits<A>::template read_element<2,2>(a);
+            Tb const b00 = mat_traits<B>::template read_element<0,0>(b);
+            Tb const b01 = mat_traits<B>::template read_element<0,1>(b);
+            Tb const b02 = mat_traits<B>::template read_element<0,2>(b);
+            Tb const b10 = mat_traits<B>::template read_element<1,0>(b);
+            Tb const b11 = mat_traits<B>::template read_element<1,1>(b);
+            Tb const b12 = mat_traits<B>::template read_element<1,2>(b);
+            Tb const b20 = mat_traits<B>::template read_element<2,0>(b);
+            Tb const b21 = mat_traits<B>::template read_element<2,1>(b);
+            Tb const b22 = mat_traits<B>::template read_element<2,2>(b);
+            mat_traits<A>::template write_element<0,0>(a)=a00*b00+a01*b10+a02*b20;
+            mat_traits<A>::template write_element<0,1>(a)=a00*b01+a01*b11+a02*b21;
+            mat_traits<A>::template write_element<0,2>(a)=a00*b02+a01*b12+a02*b22;
+            mat_traits<A>::template write_element<1,0>(a)=a10*b00+a11*b10+a12*b20;
+            mat_traits<A>::template write_element<1,1>(a)=a10*b01+a11*b11+a12*b21;
+            mat_traits<A>::template write_element<1,2>(a)=a10*b02+a11*b12+a12*b22;
+            mat_traits<A>::template write_element<2,0>(a)=a20*b00+a21*b10+a22*b20;
+            mat_traits<A>::template write_element<2,1>(a)=a20*b01+a21*b11+a22*b21;
+            mat_traits<A>::template write_element<2,2>(a)=a20*b02+a21*b12+a22*b22;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct mul_eq_mm_defined;
+
+            template <>
+            struct
+            mul_eq_mm_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<B>::rows==3 &&
+            mat_traits<A>::cols==3 && mat_traits<B>::cols==1,
+            deduce_mat2<A,B,3,1> >::type
+        operator*( A const & a, B const & b )
+            {
+            typedef typename mat_traits<A>::scalar_type Ta;
+            typedef typename mat_traits<B>::scalar_type Tb;
+            Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
+            Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
+            Ta const a02 = mat_traits<A>::template read_element<0,2>(a);
+            Ta const a10 = mat_traits<A>::template read_element<1,0>(a);
+            Ta const a11 = mat_traits<A>::template read_element<1,1>(a);
+            Ta const a12 = mat_traits<A>::template read_element<1,2>(a);
+            Ta const a20 = mat_traits<A>::template read_element<2,0>(a);
+            Ta const a21 = mat_traits<A>::template read_element<2,1>(a);
+            Ta const a22 = mat_traits<A>::template read_element<2,2>(a);
+            Tb const b00 = mat_traits<B>::template read_element<0,0>(b);
+            Tb const b10 = mat_traits<B>::template read_element<1,0>(b);
+            Tb const b20 = mat_traits<B>::template read_element<2,0>(b);
+            typedef typename deduce_mat2<A,B,3,1>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==3);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==1);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a00*b00+a01*b10+a02*b20;
+            mat_traits<R>::template write_element<1,0>(r)=a10*b00+a11*b10+a12*b20;
+            mat_traits<R>::template write_element<2,0>(r)=a20*b00+a21*b10+a22*b20;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int CR,int C>
+            struct mul_mm_defined;
+
+            template <>
+            struct
+            mul_mm_defined<3,3,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==3 &&
+            mat_traits<A>::cols==3 && mat_traits<B>::cols==3,
+            deduce_mat2<A,B,1,3> >::type
+        operator*( A const & a, B const & b )
+            {
+            typedef typename mat_traits<A>::scalar_type Ta;
+            typedef typename mat_traits<B>::scalar_type Tb;
+            Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
+            Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
+            Ta const a02 = mat_traits<A>::template read_element<0,2>(a);
+            Tb const b00 = mat_traits<B>::template read_element<0,0>(b);
+            Tb const b01 = mat_traits<B>::template read_element<0,1>(b);
+            Tb const b02 = mat_traits<B>::template read_element<0,2>(b);
+            Tb const b10 = mat_traits<B>::template read_element<1,0>(b);
+            Tb const b11 = mat_traits<B>::template read_element<1,1>(b);
+            Tb const b12 = mat_traits<B>::template read_element<1,2>(b);
+            Tb const b20 = mat_traits<B>::template read_element<2,0>(b);
+            Tb const b21 = mat_traits<B>::template read_element<2,1>(b);
+            Tb const b22 = mat_traits<B>::template read_element<2,2>(b);
+            typedef typename deduce_mat2<A,B,1,3>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==1);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==3);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a00*b00+a01*b10+a02*b20;
+            mat_traits<R>::template write_element<0,1>(r)=a00*b01+a01*b11+a02*b21;
+            mat_traits<R>::template write_element<0,2>(r)=a00*b02+a01*b12+a02*b22;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int CR,int C>
+            struct mul_mm_defined;
+
+            template <>
+            struct
+            mul_mm_defined<1,3,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_operations4.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_operations4.hpp
new file mode 100644
index 00000000000..1c50131461a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/gen/mat_operations4.hpp
@@ -0,0 +1,2129 @@
+//Copyright (c) 2008-2017 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_B3124DC843BB8BA61F35A7D938251F
+#define BOOST_QVM_B3124DC843BB8BA61F35A7D938251F
+
+//This file was generated by a program. Do not edit manually.
+
+#include <boost/qvm/assert.hpp>
+#include <boost/qvm/deduce_mat.hpp>
+#include <boost/qvm/deduce_vec.hpp>
+#include <boost/qvm/error.hpp>
+#include <boost/qvm/gen/mat_assign4.hpp>
+#include <boost/qvm/quat_traits.hpp>
+#include <boost/qvm/scalar_traits.hpp>
+#include <boost/qvm/throw_exception.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<B>::rows==4 &&
+            mat_traits<A>::cols==4 && mat_traits<B>::cols==4,
+            deduce_mat2<A,B,4,4> >::type
+        operator+( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,4,4>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==4);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==4);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)+mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)+mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<R>::template write_element<0,2>(r)=mat_traits<A>::template read_element<0,2>(a)+mat_traits<B>::template read_element<0,2>(b);
+            mat_traits<R>::template write_element<0,3>(r)=mat_traits<A>::template read_element<0,3>(a)+mat_traits<B>::template read_element<0,3>(b);
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)+mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<R>::template write_element<1,1>(r)=mat_traits<A>::template read_element<1,1>(a)+mat_traits<B>::template read_element<1,1>(b);
+            mat_traits<R>::template write_element<1,2>(r)=mat_traits<A>::template read_element<1,2>(a)+mat_traits<B>::template read_element<1,2>(b);
+            mat_traits<R>::template write_element<1,3>(r)=mat_traits<A>::template read_element<1,3>(a)+mat_traits<B>::template read_element<1,3>(b);
+            mat_traits<R>::template write_element<2,0>(r)=mat_traits<A>::template read_element<2,0>(a)+mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<R>::template write_element<2,1>(r)=mat_traits<A>::template read_element<2,1>(a)+mat_traits<B>::template read_element<2,1>(b);
+            mat_traits<R>::template write_element<2,2>(r)=mat_traits<A>::template read_element<2,2>(a)+mat_traits<B>::template read_element<2,2>(b);
+            mat_traits<R>::template write_element<2,3>(r)=mat_traits<A>::template read_element<2,3>(a)+mat_traits<B>::template read_element<2,3>(b);
+            mat_traits<R>::template write_element<3,0>(r)=mat_traits<A>::template read_element<3,0>(a)+mat_traits<B>::template read_element<3,0>(b);
+            mat_traits<R>::template write_element<3,1>(r)=mat_traits<A>::template read_element<3,1>(a)+mat_traits<B>::template read_element<3,1>(b);
+            mat_traits<R>::template write_element<3,2>(r)=mat_traits<A>::template read_element<3,2>(a)+mat_traits<B>::template read_element<3,2>(b);
+            mat_traits<R>::template write_element<3,3>(r)=mat_traits<A>::template read_element<3,3>(a)+mat_traits<B>::template read_element<3,3>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct plus_mm_defined;
+
+            template <>
+            struct
+            plus_mm_defined<4,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<B>::rows==4 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            deduce_mat2<A,B,4,1> >::type
+        operator+( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,4,1>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==4);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==1);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)+mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)+mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<R>::template write_element<2,0>(r)=mat_traits<A>::template read_element<2,0>(a)+mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<R>::template write_element<3,0>(r)=mat_traits<A>::template read_element<3,0>(a)+mat_traits<B>::template read_element<3,0>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct plus_mm_defined;
+
+            template <>
+            struct
+            plus_mm_defined<4,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==4 && mat_traits<B>::cols==4,
+            deduce_mat2<A,B,1,4> >::type
+        operator+( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,1,4>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==1);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==4);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)+mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)+mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<R>::template write_element<0,2>(r)=mat_traits<A>::template read_element<0,2>(a)+mat_traits<B>::template read_element<0,2>(b);
+            mat_traits<R>::template write_element<0,3>(r)=mat_traits<A>::template read_element<0,3>(a)+mat_traits<B>::template read_element<0,3>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct plus_mm_defined;
+
+            template <>
+            struct
+            plus_mm_defined<1,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<B>::rows==4 &&
+            mat_traits<A>::cols==4 && mat_traits<B>::cols==4,
+            deduce_mat2<A,B,4,4> >::type
+        operator-( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,4,4>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==4);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==4);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)-mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)-mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<R>::template write_element<0,2>(r)=mat_traits<A>::template read_element<0,2>(a)-mat_traits<B>::template read_element<0,2>(b);
+            mat_traits<R>::template write_element<0,3>(r)=mat_traits<A>::template read_element<0,3>(a)-mat_traits<B>::template read_element<0,3>(b);
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)-mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<R>::template write_element<1,1>(r)=mat_traits<A>::template read_element<1,1>(a)-mat_traits<B>::template read_element<1,1>(b);
+            mat_traits<R>::template write_element<1,2>(r)=mat_traits<A>::template read_element<1,2>(a)-mat_traits<B>::template read_element<1,2>(b);
+            mat_traits<R>::template write_element<1,3>(r)=mat_traits<A>::template read_element<1,3>(a)-mat_traits<B>::template read_element<1,3>(b);
+            mat_traits<R>::template write_element<2,0>(r)=mat_traits<A>::template read_element<2,0>(a)-mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<R>::template write_element<2,1>(r)=mat_traits<A>::template read_element<2,1>(a)-mat_traits<B>::template read_element<2,1>(b);
+            mat_traits<R>::template write_element<2,2>(r)=mat_traits<A>::template read_element<2,2>(a)-mat_traits<B>::template read_element<2,2>(b);
+            mat_traits<R>::template write_element<2,3>(r)=mat_traits<A>::template read_element<2,3>(a)-mat_traits<B>::template read_element<2,3>(b);
+            mat_traits<R>::template write_element<3,0>(r)=mat_traits<A>::template read_element<3,0>(a)-mat_traits<B>::template read_element<3,0>(b);
+            mat_traits<R>::template write_element<3,1>(r)=mat_traits<A>::template read_element<3,1>(a)-mat_traits<B>::template read_element<3,1>(b);
+            mat_traits<R>::template write_element<3,2>(r)=mat_traits<A>::template read_element<3,2>(a)-mat_traits<B>::template read_element<3,2>(b);
+            mat_traits<R>::template write_element<3,3>(r)=mat_traits<A>::template read_element<3,3>(a)-mat_traits<B>::template read_element<3,3>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_mm_defined;
+
+            template <>
+            struct
+            minus_mm_defined<4,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<B>::rows==4 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            deduce_mat2<A,B,4,1> >::type
+        operator-( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,4,1>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==4);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==1);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)-mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)-mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<R>::template write_element<2,0>(r)=mat_traits<A>::template read_element<2,0>(a)-mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<R>::template write_element<3,0>(r)=mat_traits<A>::template read_element<3,0>(a)-mat_traits<B>::template read_element<3,0>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_mm_defined;
+
+            template <>
+            struct
+            minus_mm_defined<4,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==4 && mat_traits<B>::cols==4,
+            deduce_mat2<A,B,1,4> >::type
+        operator-( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,1,4>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==1);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==4);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)-mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)-mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<R>::template write_element<0,2>(r)=mat_traits<A>::template read_element<0,2>(a)-mat_traits<B>::template read_element<0,2>(b);
+            mat_traits<R>::template write_element<0,3>(r)=mat_traits<A>::template read_element<0,3>(a)-mat_traits<B>::template read_element<0,3>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_mm_defined;
+
+            template <>
+            struct
+            minus_mm_defined<1,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<B>::rows==4 &&
+            mat_traits<A>::cols==4 && mat_traits<B>::cols==4,
+            A &>::type
+        operator+=( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)+=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<0,1>(a)+=mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<A>::template write_element<0,2>(a)+=mat_traits<B>::template read_element<0,2>(b);
+            mat_traits<A>::template write_element<0,3>(a)+=mat_traits<B>::template read_element<0,3>(b);
+            mat_traits<A>::template write_element<1,0>(a)+=mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<A>::template write_element<1,1>(a)+=mat_traits<B>::template read_element<1,1>(b);
+            mat_traits<A>::template write_element<1,2>(a)+=mat_traits<B>::template read_element<1,2>(b);
+            mat_traits<A>::template write_element<1,3>(a)+=mat_traits<B>::template read_element<1,3>(b);
+            mat_traits<A>::template write_element<2,0>(a)+=mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<A>::template write_element<2,1>(a)+=mat_traits<B>::template read_element<2,1>(b);
+            mat_traits<A>::template write_element<2,2>(a)+=mat_traits<B>::template read_element<2,2>(b);
+            mat_traits<A>::template write_element<2,3>(a)+=mat_traits<B>::template read_element<2,3>(b);
+            mat_traits<A>::template write_element<3,0>(a)+=mat_traits<B>::template read_element<3,0>(b);
+            mat_traits<A>::template write_element<3,1>(a)+=mat_traits<B>::template read_element<3,1>(b);
+            mat_traits<A>::template write_element<3,2>(a)+=mat_traits<B>::template read_element<3,2>(b);
+            mat_traits<A>::template write_element<3,3>(a)+=mat_traits<B>::template read_element<3,3>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct plus_eq_mm_defined;
+
+            template <>
+            struct
+            plus_eq_mm_defined<4,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<B>::rows==4 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            A &>::type
+        operator+=( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)+=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<1,0>(a)+=mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<A>::template write_element<2,0>(a)+=mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<A>::template write_element<3,0>(a)+=mat_traits<B>::template read_element<3,0>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct plus_eq_mm_defined;
+
+            template <>
+            struct
+            plus_eq_mm_defined<4,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==4 && mat_traits<B>::cols==4,
+            A &>::type
+        operator+=( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)+=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<0,1>(a)+=mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<A>::template write_element<0,2>(a)+=mat_traits<B>::template read_element<0,2>(b);
+            mat_traits<A>::template write_element<0,3>(a)+=mat_traits<B>::template read_element<0,3>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct plus_eq_mm_defined;
+
+            template <>
+            struct
+            plus_eq_mm_defined<1,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<B>::rows==4 &&
+            mat_traits<A>::cols==4 && mat_traits<B>::cols==4,
+            A &>::type
+        operator-=( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)-=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<0,1>(a)-=mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<A>::template write_element<0,2>(a)-=mat_traits<B>::template read_element<0,2>(b);
+            mat_traits<A>::template write_element<0,3>(a)-=mat_traits<B>::template read_element<0,3>(b);
+            mat_traits<A>::template write_element<1,0>(a)-=mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<A>::template write_element<1,1>(a)-=mat_traits<B>::template read_element<1,1>(b);
+            mat_traits<A>::template write_element<1,2>(a)-=mat_traits<B>::template read_element<1,2>(b);
+            mat_traits<A>::template write_element<1,3>(a)-=mat_traits<B>::template read_element<1,3>(b);
+            mat_traits<A>::template write_element<2,0>(a)-=mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<A>::template write_element<2,1>(a)-=mat_traits<B>::template read_element<2,1>(b);
+            mat_traits<A>::template write_element<2,2>(a)-=mat_traits<B>::template read_element<2,2>(b);
+            mat_traits<A>::template write_element<2,3>(a)-=mat_traits<B>::template read_element<2,3>(b);
+            mat_traits<A>::template write_element<3,0>(a)-=mat_traits<B>::template read_element<3,0>(b);
+            mat_traits<A>::template write_element<3,1>(a)-=mat_traits<B>::template read_element<3,1>(b);
+            mat_traits<A>::template write_element<3,2>(a)-=mat_traits<B>::template read_element<3,2>(b);
+            mat_traits<A>::template write_element<3,3>(a)-=mat_traits<B>::template read_element<3,3>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_eq_mm_defined;
+
+            template <>
+            struct
+            minus_eq_mm_defined<4,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<B>::rows==4 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            A &>::type
+        operator-=( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)-=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<1,0>(a)-=mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<A>::template write_element<2,0>(a)-=mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<A>::template write_element<3,0>(a)-=mat_traits<B>::template read_element<3,0>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_eq_mm_defined;
+
+            template <>
+            struct
+            minus_eq_mm_defined<4,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==4 && mat_traits<B>::cols==4,
+            A &>::type
+        operator-=( A & a, B const & b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)-=mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<A>::template write_element<0,1>(a)-=mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<A>::template write_element<0,2>(a)-=mat_traits<B>::template read_element<0,2>(b);
+            mat_traits<A>::template write_element<0,3>(a)-=mat_traits<B>::template read_element<0,3>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_eq_mm_defined;
+
+            template <>
+            struct
+            minus_eq_mm_defined<1,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<A>::cols==4 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        operator*( A const & a, B b )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)*b;
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)*b;
+            mat_traits<R>::template write_element<0,2>(r)=mat_traits<A>::template read_element<0,2>(a)*b;
+            mat_traits<R>::template write_element<0,3>(r)=mat_traits<A>::template read_element<0,3>(a)*b;
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)*b;
+            mat_traits<R>::template write_element<1,1>(r)=mat_traits<A>::template read_element<1,1>(a)*b;
+            mat_traits<R>::template write_element<1,2>(r)=mat_traits<A>::template read_element<1,2>(a)*b;
+            mat_traits<R>::template write_element<1,3>(r)=mat_traits<A>::template read_element<1,3>(a)*b;
+            mat_traits<R>::template write_element<2,0>(r)=mat_traits<A>::template read_element<2,0>(a)*b;
+            mat_traits<R>::template write_element<2,1>(r)=mat_traits<A>::template read_element<2,1>(a)*b;
+            mat_traits<R>::template write_element<2,2>(r)=mat_traits<A>::template read_element<2,2>(a)*b;
+            mat_traits<R>::template write_element<2,3>(r)=mat_traits<A>::template read_element<2,3>(a)*b;
+            mat_traits<R>::template write_element<3,0>(r)=mat_traits<A>::template read_element<3,0>(a)*b;
+            mat_traits<R>::template write_element<3,1>(r)=mat_traits<A>::template read_element<3,1>(a)*b;
+            mat_traits<R>::template write_element<3,2>(r)=mat_traits<A>::template read_element<3,2>(a)*b;
+            mat_traits<R>::template write_element<3,3>(r)=mat_traits<A>::template read_element<3,3>(a)*b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_ms_defined;
+
+            template <>
+            struct
+            mul_ms_defined<4,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_scalar<A>::value && mat_traits<B>::rows==4 && mat_traits<B>::cols==4,
+            deduce_mat<B> >::type
+        operator*( A a, B const & b )
+            {
+            typedef typename deduce_mat<B>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a*mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=a*mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<R>::template write_element<0,2>(r)=a*mat_traits<B>::template read_element<0,2>(b);
+            mat_traits<R>::template write_element<0,3>(r)=a*mat_traits<B>::template read_element<0,3>(b);
+            mat_traits<R>::template write_element<1,0>(r)=a*mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<R>::template write_element<1,1>(r)=a*mat_traits<B>::template read_element<1,1>(b);
+            mat_traits<R>::template write_element<1,2>(r)=a*mat_traits<B>::template read_element<1,2>(b);
+            mat_traits<R>::template write_element<1,3>(r)=a*mat_traits<B>::template read_element<1,3>(b);
+            mat_traits<R>::template write_element<2,0>(r)=a*mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<R>::template write_element<2,1>(r)=a*mat_traits<B>::template read_element<2,1>(b);
+            mat_traits<R>::template write_element<2,2>(r)=a*mat_traits<B>::template read_element<2,2>(b);
+            mat_traits<R>::template write_element<2,3>(r)=a*mat_traits<B>::template read_element<2,3>(b);
+            mat_traits<R>::template write_element<3,0>(r)=a*mat_traits<B>::template read_element<3,0>(b);
+            mat_traits<R>::template write_element<3,1>(r)=a*mat_traits<B>::template read_element<3,1>(b);
+            mat_traits<R>::template write_element<3,2>(r)=a*mat_traits<B>::template read_element<3,2>(b);
+            mat_traits<R>::template write_element<3,3>(r)=a*mat_traits<B>::template read_element<3,3>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_sm_defined;
+
+            template <>
+            struct
+            mul_sm_defined<4,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<A>::cols==1 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        operator*( A const & a, B b )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)*b;
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)*b;
+            mat_traits<R>::template write_element<2,0>(r)=mat_traits<A>::template read_element<2,0>(a)*b;
+            mat_traits<R>::template write_element<3,0>(r)=mat_traits<A>::template read_element<3,0>(a)*b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_ms_defined;
+
+            template <>
+            struct
+            mul_ms_defined<4,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_scalar<A>::value && mat_traits<B>::rows==4 && mat_traits<B>::cols==1,
+            deduce_mat<B> >::type
+        operator*( A a, B const & b )
+            {
+            typedef typename deduce_mat<B>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a*mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<1,0>(r)=a*mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<R>::template write_element<2,0>(r)=a*mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<R>::template write_element<3,0>(r)=a*mat_traits<B>::template read_element<3,0>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_sm_defined;
+
+            template <>
+            struct
+            mul_sm_defined<4,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<A>::cols==4 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        operator*( A const & a, B b )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)*b;
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)*b;
+            mat_traits<R>::template write_element<0,2>(r)=mat_traits<A>::template read_element<0,2>(a)*b;
+            mat_traits<R>::template write_element<0,3>(r)=mat_traits<A>::template read_element<0,3>(a)*b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_ms_defined;
+
+            template <>
+            struct
+            mul_ms_defined<1,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_scalar<A>::value && mat_traits<B>::rows==1 && mat_traits<B>::cols==4,
+            deduce_mat<B> >::type
+        operator*( A a, B const & b )
+            {
+            typedef typename deduce_mat<B>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a*mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=a*mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<R>::template write_element<0,2>(r)=a*mat_traits<B>::template read_element<0,2>(b);
+            mat_traits<R>::template write_element<0,3>(r)=a*mat_traits<B>::template read_element<0,3>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_sm_defined;
+
+            template <>
+            struct
+            mul_sm_defined<1,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<A>::cols==4 && is_scalar<B>::value,
+            A &>::type
+        operator*=( A & a, B b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)*=b;
+            mat_traits<A>::template write_element<0,1>(a)*=b;
+            mat_traits<A>::template write_element<0,2>(a)*=b;
+            mat_traits<A>::template write_element<0,3>(a)*=b;
+            mat_traits<A>::template write_element<1,0>(a)*=b;
+            mat_traits<A>::template write_element<1,1>(a)*=b;
+            mat_traits<A>::template write_element<1,2>(a)*=b;
+            mat_traits<A>::template write_element<1,3>(a)*=b;
+            mat_traits<A>::template write_element<2,0>(a)*=b;
+            mat_traits<A>::template write_element<2,1>(a)*=b;
+            mat_traits<A>::template write_element<2,2>(a)*=b;
+            mat_traits<A>::template write_element<2,3>(a)*=b;
+            mat_traits<A>::template write_element<3,0>(a)*=b;
+            mat_traits<A>::template write_element<3,1>(a)*=b;
+            mat_traits<A>::template write_element<3,2>(a)*=b;
+            mat_traits<A>::template write_element<3,3>(a)*=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_eq_ms_defined;
+
+            template <>
+            struct
+            mul_eq_ms_defined<4,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<A>::cols==1 && is_scalar<B>::value,
+            A &>::type
+        operator*=( A & a, B b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)*=b;
+            mat_traits<A>::template write_element<1,0>(a)*=b;
+            mat_traits<A>::template write_element<2,0>(a)*=b;
+            mat_traits<A>::template write_element<3,0>(a)*=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_eq_ms_defined;
+
+            template <>
+            struct
+            mul_eq_ms_defined<4,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<A>::cols==4 && is_scalar<B>::value,
+            A &>::type
+        operator*=( A & a, B b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)*=b;
+            mat_traits<A>::template write_element<0,1>(a)*=b;
+            mat_traits<A>::template write_element<0,2>(a)*=b;
+            mat_traits<A>::template write_element<0,3>(a)*=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_eq_ms_defined;
+
+            template <>
+            struct
+            mul_eq_ms_defined<1,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<A>::cols==4 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        operator/( A const & a, B b )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)/b;
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)/b;
+            mat_traits<R>::template write_element<0,2>(r)=mat_traits<A>::template read_element<0,2>(a)/b;
+            mat_traits<R>::template write_element<0,3>(r)=mat_traits<A>::template read_element<0,3>(a)/b;
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)/b;
+            mat_traits<R>::template write_element<1,1>(r)=mat_traits<A>::template read_element<1,1>(a)/b;
+            mat_traits<R>::template write_element<1,2>(r)=mat_traits<A>::template read_element<1,2>(a)/b;
+            mat_traits<R>::template write_element<1,3>(r)=mat_traits<A>::template read_element<1,3>(a)/b;
+            mat_traits<R>::template write_element<2,0>(r)=mat_traits<A>::template read_element<2,0>(a)/b;
+            mat_traits<R>::template write_element<2,1>(r)=mat_traits<A>::template read_element<2,1>(a)/b;
+            mat_traits<R>::template write_element<2,2>(r)=mat_traits<A>::template read_element<2,2>(a)/b;
+            mat_traits<R>::template write_element<2,3>(r)=mat_traits<A>::template read_element<2,3>(a)/b;
+            mat_traits<R>::template write_element<3,0>(r)=mat_traits<A>::template read_element<3,0>(a)/b;
+            mat_traits<R>::template write_element<3,1>(r)=mat_traits<A>::template read_element<3,1>(a)/b;
+            mat_traits<R>::template write_element<3,2>(r)=mat_traits<A>::template read_element<3,2>(a)/b;
+            mat_traits<R>::template write_element<3,3>(r)=mat_traits<A>::template read_element<3,3>(a)/b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_ms_defined;
+
+            template <>
+            struct
+            div_ms_defined<4,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_scalar<A>::value && mat_traits<B>::rows==4 && mat_traits<B>::cols==4,
+            deduce_mat<B> >::type
+        operator/( A a, B const & b )
+            {
+            typedef typename deduce_mat<B>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a/mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<0,1>(r)=a/mat_traits<B>::template read_element<0,1>(b);
+            mat_traits<R>::template write_element<0,2>(r)=a/mat_traits<B>::template read_element<0,2>(b);
+            mat_traits<R>::template write_element<0,3>(r)=a/mat_traits<B>::template read_element<0,3>(b);
+            mat_traits<R>::template write_element<1,0>(r)=a/mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<R>::template write_element<1,1>(r)=a/mat_traits<B>::template read_element<1,1>(b);
+            mat_traits<R>::template write_element<1,2>(r)=a/mat_traits<B>::template read_element<1,2>(b);
+            mat_traits<R>::template write_element<1,3>(r)=a/mat_traits<B>::template read_element<1,3>(b);
+            mat_traits<R>::template write_element<2,0>(r)=a/mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<R>::template write_element<2,1>(r)=a/mat_traits<B>::template read_element<2,1>(b);
+            mat_traits<R>::template write_element<2,2>(r)=a/mat_traits<B>::template read_element<2,2>(b);
+            mat_traits<R>::template write_element<2,3>(r)=a/mat_traits<B>::template read_element<2,3>(b);
+            mat_traits<R>::template write_element<3,0>(r)=a/mat_traits<B>::template read_element<3,0>(b);
+            mat_traits<R>::template write_element<3,1>(r)=a/mat_traits<B>::template read_element<3,1>(b);
+            mat_traits<R>::template write_element<3,2>(r)=a/mat_traits<B>::template read_element<3,2>(b);
+            mat_traits<R>::template write_element<3,3>(r)=a/mat_traits<B>::template read_element<3,3>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_sm_defined;
+
+            template <>
+            struct
+            div_sm_defined<4,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<A>::cols==1 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        operator/( A const & a, B b )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)/b;
+            mat_traits<R>::template write_element<1,0>(r)=mat_traits<A>::template read_element<1,0>(a)/b;
+            mat_traits<R>::template write_element<2,0>(r)=mat_traits<A>::template read_element<2,0>(a)/b;
+            mat_traits<R>::template write_element<3,0>(r)=mat_traits<A>::template read_element<3,0>(a)/b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_ms_defined;
+
+            template <>
+            struct
+            div_ms_defined<4,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_scalar<A>::value && mat_traits<B>::rows==4 && mat_traits<B>::cols==1,
+            deduce_mat<B> >::type
+        operator/( A a, B const & b )
+            {
+            typedef typename deduce_mat<B>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a/mat_traits<B>::template read_element<0,0>(b);
+            mat_traits<R>::template write_element<1,0>(r)=a/mat_traits<B>::template read_element<1,0>(b);
+            mat_traits<R>::template write_element<2,0>(r)=a/mat_traits<B>::template read_element<2,0>(b);
+            mat_traits<R>::template write_element<3,0>(r)=a/mat_traits<B>::template read_element<3,0>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_sm_defined;
+
+            template <>
+            struct
+            div_sm_defined<4,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<A>::cols==4 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        operator/( A const & a, B b )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=mat_traits<A>::template read_element<0,0>(a)/b;
+            mat_traits<R>::template write_element<0,1>(r)=mat_traits<A>::template read_element<0,1>(a)/b;
+            mat_traits<R>::template write_element<0,2>(r)=mat_traits<A>::template read_element<0,2>(a)/b;
+            mat_traits<R>::template write_element<0,3>(r)=mat_traits<A>::template read_element<0,3>(a)/b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_ms_defined;
+
+            template <>
+            struct
+            div_ms_defined<1,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<A>::cols==4 && is_scalar<B>::value,
+            A &>::type
+        operator/=( A & a, B b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)/=b;
+            mat_traits<A>::template write_element<0,1>(a)/=b;
+            mat_traits<A>::template write_element<0,2>(a)/=b;
+            mat_traits<A>::template write_element<0,3>(a)/=b;
+            mat_traits<A>::template write_element<1,0>(a)/=b;
+            mat_traits<A>::template write_element<1,1>(a)/=b;
+            mat_traits<A>::template write_element<1,2>(a)/=b;
+            mat_traits<A>::template write_element<1,3>(a)/=b;
+            mat_traits<A>::template write_element<2,0>(a)/=b;
+            mat_traits<A>::template write_element<2,1>(a)/=b;
+            mat_traits<A>::template write_element<2,2>(a)/=b;
+            mat_traits<A>::template write_element<2,3>(a)/=b;
+            mat_traits<A>::template write_element<3,0>(a)/=b;
+            mat_traits<A>::template write_element<3,1>(a)/=b;
+            mat_traits<A>::template write_element<3,2>(a)/=b;
+            mat_traits<A>::template write_element<3,3>(a)/=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_eq_ms_defined;
+
+            template <>
+            struct
+            div_eq_ms_defined<4,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<A>::cols==1 && is_scalar<B>::value,
+            A &>::type
+        operator/=( A & a, B b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)/=b;
+            mat_traits<A>::template write_element<1,0>(a)/=b;
+            mat_traits<A>::template write_element<2,0>(a)/=b;
+            mat_traits<A>::template write_element<3,0>(a)/=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_eq_ms_defined;
+
+            template <>
+            struct
+            div_eq_ms_defined<4,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<A>::cols==4 && is_scalar<B>::value,
+            A &>::type
+        operator/=( A & a, B b )
+            {
+            mat_traits<A>::template write_element<0,0>(a)/=b;
+            mat_traits<A>::template write_element<0,1>(a)/=b;
+            mat_traits<A>::template write_element<0,2>(a)/=b;
+            mat_traits<A>::template write_element<0,3>(a)/=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct div_eq_ms_defined;
+
+            template <>
+            struct
+            div_eq_ms_defined<1,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class R,class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<R>::rows==4 && mat_traits<A>::rows==4 &&
+            mat_traits<R>::cols==4 && mat_traits<A>::cols==4,
+            R>::type
+        convert_to( A const & a )
+            {
+            R r;
+            mat_traits<R>::template write_element<0,0>(r) = mat_traits<A>::template read_element<0,0>(a);
+            mat_traits<R>::template write_element<0,1>(r) = mat_traits<A>::template read_element<0,1>(a);
+            mat_traits<R>::template write_element<0,2>(r) = mat_traits<A>::template read_element<0,2>(a);
+            mat_traits<R>::template write_element<0,3>(r) = mat_traits<A>::template read_element<0,3>(a);
+            mat_traits<R>::template write_element<1,0>(r) = mat_traits<A>::template read_element<1,0>(a);
+            mat_traits<R>::template write_element<1,1>(r) = mat_traits<A>::template read_element<1,1>(a);
+            mat_traits<R>::template write_element<1,2>(r) = mat_traits<A>::template read_element<1,2>(a);
+            mat_traits<R>::template write_element<1,3>(r) = mat_traits<A>::template read_element<1,3>(a);
+            mat_traits<R>::template write_element<2,0>(r) = mat_traits<A>::template read_element<2,0>(a);
+            mat_traits<R>::template write_element<2,1>(r) = mat_traits<A>::template read_element<2,1>(a);
+            mat_traits<R>::template write_element<2,2>(r) = mat_traits<A>::template read_element<2,2>(a);
+            mat_traits<R>::template write_element<2,3>(r) = mat_traits<A>::template read_element<2,3>(a);
+            mat_traits<R>::template write_element<3,0>(r) = mat_traits<A>::template read_element<3,0>(a);
+            mat_traits<R>::template write_element<3,1>(r) = mat_traits<A>::template read_element<3,1>(a);
+            mat_traits<R>::template write_element<3,2>(r) = mat_traits<A>::template read_element<3,2>(a);
+            mat_traits<R>::template write_element<3,3>(r) = mat_traits<A>::template read_element<3,3>(a);
+            return r;
+            }
+
+        template <class R,class A>
+        BOOST_QVM_INLINE
+        typename enable_if_c<
+            is_mat<R>::value && is_quat<A>::value &&
+            mat_traits<R>::rows==4 && mat_traits<R>::cols==4,
+            R>::type
+        convert_to( A const & q )
+            {
+            typedef typename mat_traits<R>::scalar_type T;
+            T const a=quat_traits<A>::template read_element<0>(q);
+            T const b=quat_traits<A>::template read_element<1>(q);
+            T const c=quat_traits<A>::template read_element<2>(q);
+            T const d=quat_traits<A>::template read_element<3>(q);
+            T const bb = b*b;
+            T const cc = c*c;
+            T const dd = d*d;
+            T const bc = b*c;
+            T const bd = b*d;
+            T const cd = c*d;
+            T const ab = a*b;
+            T const ac = a*c;
+            T const ad = a*d;
+            T const zero = scalar_traits<T>::value(0);
+            T const one = scalar_traits<T>::value(1);
+            T const two = one+one;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r) = one - two*(cc+dd);
+            mat_traits<R>::template write_element<0,1>(r) = two*(bc-ad);
+            mat_traits<R>::template write_element<0,2>(r) = two*(bd+ac);
+            mat_traits<R>::template write_element<0,3>(r) = zero;
+            mat_traits<R>::template write_element<1,0>(r) = two*(bc+ad);
+            mat_traits<R>::template write_element<1,1>(r) = one - two*(bb+dd);
+            mat_traits<R>::template write_element<1,2>(r) = two*(cd-ab);
+            mat_traits<R>::template write_element<1,3>(r) = zero;
+            mat_traits<R>::template write_element<2,0>(r) = two*(bd-ac);
+            mat_traits<R>::template write_element<2,1>(r) = two*(cd+ab);
+            mat_traits<R>::template write_element<2,2>(r) = one - two*(bb+cc);
+            mat_traits<R>::template write_element<2,3>(r) = zero;
+            mat_traits<R>::template write_element<3,0>(r) = zero;
+            mat_traits<R>::template write_element<3,1>(r) = zero;
+            mat_traits<R>::template write_element<3,2>(r) = zero;
+            mat_traits<R>::template write_element<3,3>(r) = one;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::convert_to;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct convert_to_m_defined;
+
+            template <>
+            struct
+            convert_to_m_defined<4,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class R,class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<R>::rows==4 && mat_traits<A>::rows==4 &&
+            mat_traits<R>::cols==1 && mat_traits<A>::cols==1,
+            R>::type
+        convert_to( A const & a )
+            {
+            R r;
+            mat_traits<R>::template write_element<0,0>(r) = mat_traits<A>::template read_element<0,0>(a);
+            mat_traits<R>::template write_element<1,0>(r) = mat_traits<A>::template read_element<1,0>(a);
+            mat_traits<R>::template write_element<2,0>(r) = mat_traits<A>::template read_element<2,0>(a);
+            mat_traits<R>::template write_element<3,0>(r) = mat_traits<A>::template read_element<3,0>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::convert_to;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct convert_to_m_defined;
+
+            template <>
+            struct
+            convert_to_m_defined<4,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class R,class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<R>::rows==1 && mat_traits<A>::rows==1 &&
+            mat_traits<R>::cols==4 && mat_traits<A>::cols==4,
+            R>::type
+        convert_to( A const & a )
+            {
+            R r;
+            mat_traits<R>::template write_element<0,0>(r) = mat_traits<A>::template read_element<0,0>(a);
+            mat_traits<R>::template write_element<0,1>(r) = mat_traits<A>::template read_element<0,1>(a);
+            mat_traits<R>::template write_element<0,2>(r) = mat_traits<A>::template read_element<0,2>(a);
+            mat_traits<R>::template write_element<0,3>(r) = mat_traits<A>::template read_element<0,3>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::convert_to;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct convert_to_m_defined;
+
+            template <>
+            struct
+            convert_to_m_defined<1,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<B>::rows==4 &&
+            mat_traits<A>::cols==4 && mat_traits<B>::cols==4,
+            bool>::type
+        operator==( A const & a, B const & b )
+            {
+            return
+                mat_traits<A>::template read_element<0,0>(a)==mat_traits<B>::template read_element<0,0>(b) &&
+                mat_traits<A>::template read_element<0,1>(a)==mat_traits<B>::template read_element<0,1>(b) &&
+                mat_traits<A>::template read_element<0,2>(a)==mat_traits<B>::template read_element<0,2>(b) &&
+                mat_traits<A>::template read_element<0,3>(a)==mat_traits<B>::template read_element<0,3>(b) &&
+                mat_traits<A>::template read_element<1,0>(a)==mat_traits<B>::template read_element<1,0>(b) &&
+                mat_traits<A>::template read_element<1,1>(a)==mat_traits<B>::template read_element<1,1>(b) &&
+                mat_traits<A>::template read_element<1,2>(a)==mat_traits<B>::template read_element<1,2>(b) &&
+                mat_traits<A>::template read_element<1,3>(a)==mat_traits<B>::template read_element<1,3>(b) &&
+                mat_traits<A>::template read_element<2,0>(a)==mat_traits<B>::template read_element<2,0>(b) &&
+                mat_traits<A>::template read_element<2,1>(a)==mat_traits<B>::template read_element<2,1>(b) &&
+                mat_traits<A>::template read_element<2,2>(a)==mat_traits<B>::template read_element<2,2>(b) &&
+                mat_traits<A>::template read_element<2,3>(a)==mat_traits<B>::template read_element<2,3>(b) &&
+                mat_traits<A>::template read_element<3,0>(a)==mat_traits<B>::template read_element<3,0>(b) &&
+                mat_traits<A>::template read_element<3,1>(a)==mat_traits<B>::template read_element<3,1>(b) &&
+                mat_traits<A>::template read_element<3,2>(a)==mat_traits<B>::template read_element<3,2>(b) &&
+                mat_traits<A>::template read_element<3,3>(a)==mat_traits<B>::template read_element<3,3>(b);
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator==;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct eq_mm_defined;
+
+            template <>
+            struct
+            eq_mm_defined<4,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<B>::rows==4 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            bool>::type
+        operator==( A const & a, B const & b )
+            {
+            return
+                mat_traits<A>::template read_element<0,0>(a)==mat_traits<B>::template read_element<0,0>(b) &&
+                mat_traits<A>::template read_element<1,0>(a)==mat_traits<B>::template read_element<1,0>(b) &&
+                mat_traits<A>::template read_element<2,0>(a)==mat_traits<B>::template read_element<2,0>(b) &&
+                mat_traits<A>::template read_element<3,0>(a)==mat_traits<B>::template read_element<3,0>(b);
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator==;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct eq_mm_defined;
+
+            template <>
+            struct
+            eq_mm_defined<4,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==4 && mat_traits<B>::cols==4,
+            bool>::type
+        operator==( A const & a, B const & b )
+            {
+            return
+                mat_traits<A>::template read_element<0,0>(a)==mat_traits<B>::template read_element<0,0>(b) &&
+                mat_traits<A>::template read_element<0,1>(a)==mat_traits<B>::template read_element<0,1>(b) &&
+                mat_traits<A>::template read_element<0,2>(a)==mat_traits<B>::template read_element<0,2>(b) &&
+                mat_traits<A>::template read_element<0,3>(a)==mat_traits<B>::template read_element<0,3>(b);
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator==;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct eq_mm_defined;
+
+            template <>
+            struct
+            eq_mm_defined<1,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<B>::rows==4 &&
+            mat_traits<A>::cols==4 && mat_traits<B>::cols==4,
+            bool>::type
+        operator!=( A const & a, B const & b )
+            {
+            return
+                !(mat_traits<A>::template read_element<0,0>(a)==mat_traits<B>::template read_element<0,0>(b)) ||
+                !(mat_traits<A>::template read_element<0,1>(a)==mat_traits<B>::template read_element<0,1>(b)) ||
+                !(mat_traits<A>::template read_element<0,2>(a)==mat_traits<B>::template read_element<0,2>(b)) ||
+                !(mat_traits<A>::template read_element<0,3>(a)==mat_traits<B>::template read_element<0,3>(b)) ||
+                !(mat_traits<A>::template read_element<1,0>(a)==mat_traits<B>::template read_element<1,0>(b)) ||
+                !(mat_traits<A>::template read_element<1,1>(a)==mat_traits<B>::template read_element<1,1>(b)) ||
+                !(mat_traits<A>::template read_element<1,2>(a)==mat_traits<B>::template read_element<1,2>(b)) ||
+                !(mat_traits<A>::template read_element<1,3>(a)==mat_traits<B>::template read_element<1,3>(b)) ||
+                !(mat_traits<A>::template read_element<2,0>(a)==mat_traits<B>::template read_element<2,0>(b)) ||
+                !(mat_traits<A>::template read_element<2,1>(a)==mat_traits<B>::template read_element<2,1>(b)) ||
+                !(mat_traits<A>::template read_element<2,2>(a)==mat_traits<B>::template read_element<2,2>(b)) ||
+                !(mat_traits<A>::template read_element<2,3>(a)==mat_traits<B>::template read_element<2,3>(b)) ||
+                !(mat_traits<A>::template read_element<3,0>(a)==mat_traits<B>::template read_element<3,0>(b)) ||
+                !(mat_traits<A>::template read_element<3,1>(a)==mat_traits<B>::template read_element<3,1>(b)) ||
+                !(mat_traits<A>::template read_element<3,2>(a)==mat_traits<B>::template read_element<3,2>(b)) ||
+                !(mat_traits<A>::template read_element<3,3>(a)==mat_traits<B>::template read_element<3,3>(b));
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator!=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct neq_mm_defined;
+
+            template <>
+            struct
+            neq_mm_defined<4,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<B>::rows==4 &&
+            mat_traits<A>::cols==1 && mat_traits<B>::cols==1,
+            bool>::type
+        operator!=( A const & a, B const & b )
+            {
+            return
+                !(mat_traits<A>::template read_element<0,0>(a)==mat_traits<B>::template read_element<0,0>(b)) ||
+                !(mat_traits<A>::template read_element<1,0>(a)==mat_traits<B>::template read_element<1,0>(b)) ||
+                !(mat_traits<A>::template read_element<2,0>(a)==mat_traits<B>::template read_element<2,0>(b)) ||
+                !(mat_traits<A>::template read_element<3,0>(a)==mat_traits<B>::template read_element<3,0>(b));
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator!=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct neq_mm_defined;
+
+            template <>
+            struct
+            neq_mm_defined<4,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==1 &&
+            mat_traits<A>::cols==4 && mat_traits<B>::cols==4,
+            bool>::type
+        operator!=( A const & a, B const & b )
+            {
+            return
+                !(mat_traits<A>::template read_element<0,0>(a)==mat_traits<B>::template read_element<0,0>(b)) ||
+                !(mat_traits<A>::template read_element<0,1>(a)==mat_traits<B>::template read_element<0,1>(b)) ||
+                !(mat_traits<A>::template read_element<0,2>(a)==mat_traits<B>::template read_element<0,2>(b)) ||
+                !(mat_traits<A>::template read_element<0,3>(a)==mat_traits<B>::template read_element<0,3>(b));
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator!=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct neq_mm_defined;
+
+            template <>
+            struct
+            neq_mm_defined<1,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<A>::cols==4,
+            deduce_mat<A> >::type
+        operator-( A const & a )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=-mat_traits<A>::template read_element<0,0>(a);
+            mat_traits<R>::template write_element<0,1>(r)=-mat_traits<A>::template read_element<0,1>(a);
+            mat_traits<R>::template write_element<0,2>(r)=-mat_traits<A>::template read_element<0,2>(a);
+            mat_traits<R>::template write_element<0,3>(r)=-mat_traits<A>::template read_element<0,3>(a);
+            mat_traits<R>::template write_element<1,0>(r)=-mat_traits<A>::template read_element<1,0>(a);
+            mat_traits<R>::template write_element<1,1>(r)=-mat_traits<A>::template read_element<1,1>(a);
+            mat_traits<R>::template write_element<1,2>(r)=-mat_traits<A>::template read_element<1,2>(a);
+            mat_traits<R>::template write_element<1,3>(r)=-mat_traits<A>::template read_element<1,3>(a);
+            mat_traits<R>::template write_element<2,0>(r)=-mat_traits<A>::template read_element<2,0>(a);
+            mat_traits<R>::template write_element<2,1>(r)=-mat_traits<A>::template read_element<2,1>(a);
+            mat_traits<R>::template write_element<2,2>(r)=-mat_traits<A>::template read_element<2,2>(a);
+            mat_traits<R>::template write_element<2,3>(r)=-mat_traits<A>::template read_element<2,3>(a);
+            mat_traits<R>::template write_element<3,0>(r)=-mat_traits<A>::template read_element<3,0>(a);
+            mat_traits<R>::template write_element<3,1>(r)=-mat_traits<A>::template read_element<3,1>(a);
+            mat_traits<R>::template write_element<3,2>(r)=-mat_traits<A>::template read_element<3,2>(a);
+            mat_traits<R>::template write_element<3,3>(r)=-mat_traits<A>::template read_element<3,3>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_m_defined;
+
+            template <>
+            struct
+            minus_m_defined<4,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<A>::cols==1,
+            deduce_mat<A> >::type
+        operator-( A const & a )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=-mat_traits<A>::template read_element<0,0>(a);
+            mat_traits<R>::template write_element<1,0>(r)=-mat_traits<A>::template read_element<1,0>(a);
+            mat_traits<R>::template write_element<2,0>(r)=-mat_traits<A>::template read_element<2,0>(a);
+            mat_traits<R>::template write_element<3,0>(r)=-mat_traits<A>::template read_element<3,0>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_m_defined;
+
+            template <>
+            struct
+            minus_m_defined<4,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<A>::cols==4,
+            deduce_mat<A> >::type
+        operator-( A const & a )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=-mat_traits<A>::template read_element<0,0>(a);
+            mat_traits<R>::template write_element<0,1>(r)=-mat_traits<A>::template read_element<0,1>(a);
+            mat_traits<R>::template write_element<0,2>(r)=-mat_traits<A>::template read_element<0,2>(a);
+            mat_traits<R>::template write_element<0,3>(r)=-mat_traits<A>::template read_element<0,3>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct minus_m_defined;
+
+            template <>
+            struct
+            minus_m_defined<1,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<A>::cols==4,
+            typename mat_traits<A>::scalar_type>::type
+        determinant( A const & a )
+            {
+            typedef typename mat_traits<A>::scalar_type T;
+            T const a00=mat_traits<A>::template read_element<0,0>(a);
+            T const a01=mat_traits<A>::template read_element<0,1>(a);
+            T const a02=mat_traits<A>::template read_element<0,2>(a);
+            T const a03=mat_traits<A>::template read_element<0,3>(a);
+            T const a10=mat_traits<A>::template read_element<1,0>(a);
+            T const a11=mat_traits<A>::template read_element<1,1>(a);
+            T const a12=mat_traits<A>::template read_element<1,2>(a);
+            T const a13=mat_traits<A>::template read_element<1,3>(a);
+            T const a20=mat_traits<A>::template read_element<2,0>(a);
+            T const a21=mat_traits<A>::template read_element<2,1>(a);
+            T const a22=mat_traits<A>::template read_element<2,2>(a);
+            T const a23=mat_traits<A>::template read_element<2,3>(a);
+            T const a30=mat_traits<A>::template read_element<3,0>(a);
+            T const a31=mat_traits<A>::template read_element<3,1>(a);
+            T const a32=mat_traits<A>::template read_element<3,2>(a);
+            T const a33=mat_traits<A>::template read_element<3,3>(a);
+            T det=(a00*(a11*(a22*a33-a23*a32)-a12*(a21*a33-a23*a31)+a13*(a21*a32-a22*a31))-a01*(a10*(a22*a33-a23*a32)-a12*(a20*a33-a23*a30)+a13*(a20*a32-a22*a30))+a02*(a10*(a21*a33-a23*a31)-a11*(a20*a33-a23*a30)+a13*(a20*a31-a21*a30))-a03*(a10*(a21*a32-a22*a31)-a11*(a20*a32-a22*a30)+a12*(a20*a31-a21*a30)));
+            return det;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::determinant;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct determinant_defined;
+
+            template <>
+            struct
+            determinant_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<A>::cols==4 && is_scalar<B>::value,
+            deduce_mat<A> >::type
+        inverse( A const & a, B det )
+            {
+            typedef typename mat_traits<A>::scalar_type T;
+            BOOST_QVM_ASSERT(det!=scalar_traits<B>::value(0));
+            T const a00=mat_traits<A>::template read_element<0,0>(a);
+            T const a01=mat_traits<A>::template read_element<0,1>(a);
+            T const a02=mat_traits<A>::template read_element<0,2>(a);
+            T const a03=mat_traits<A>::template read_element<0,3>(a);
+            T const a10=mat_traits<A>::template read_element<1,0>(a);
+            T const a11=mat_traits<A>::template read_element<1,1>(a);
+            T const a12=mat_traits<A>::template read_element<1,2>(a);
+            T const a13=mat_traits<A>::template read_element<1,3>(a);
+            T const a20=mat_traits<A>::template read_element<2,0>(a);
+            T const a21=mat_traits<A>::template read_element<2,1>(a);
+            T const a22=mat_traits<A>::template read_element<2,2>(a);
+            T const a23=mat_traits<A>::template read_element<2,3>(a);
+            T const a30=mat_traits<A>::template read_element<3,0>(a);
+            T const a31=mat_traits<A>::template read_element<3,1>(a);
+            T const a32=mat_traits<A>::template read_element<3,2>(a);
+            T const a33=mat_traits<A>::template read_element<3,3>(a);
+            T const f=scalar_traits<T>::value(1)/det;
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)= f*(a11*(a22*a33-a23*a32)-a12*(a21*a33-a23*a31)+a13*(a21*a32-a22*a31));
+            mat_traits<R>::template write_element<0,1>(r)=-f*(a01*(a22*a33-a23*a32)-a02*(a21*a33-a23*a31)+a03*(a21*a32-a22*a31));
+            mat_traits<R>::template write_element<0,2>(r)= f*(a01*(a12*a33-a13*a32)-a02*(a11*a33-a13*a31)+a03*(a11*a32-a12*a31));
+            mat_traits<R>::template write_element<0,3>(r)=-f*(a01*(a12*a23-a13*a22)-a02*(a11*a23-a13*a21)+a03*(a11*a22-a12*a21));
+            mat_traits<R>::template write_element<1,0>(r)=-f*(a10*(a22*a33-a23*a32)-a12*(a20*a33-a23*a30)+a13*(a20*a32-a22*a30));
+            mat_traits<R>::template write_element<1,1>(r)= f*(a00*(a22*a33-a23*a32)-a02*(a20*a33-a23*a30)+a03*(a20*a32-a22*a30));
+            mat_traits<R>::template write_element<1,2>(r)=-f*(a00*(a12*a33-a13*a32)-a02*(a10*a33-a13*a30)+a03*(a10*a32-a12*a30));
+            mat_traits<R>::template write_element<1,3>(r)= f*(a00*(a12*a23-a13*a22)-a02*(a10*a23-a13*a20)+a03*(a10*a22-a12*a20));
+            mat_traits<R>::template write_element<2,0>(r)= f*(a10*(a21*a33-a23*a31)-a11*(a20*a33-a23*a30)+a13*(a20*a31-a21*a30));
+            mat_traits<R>::template write_element<2,1>(r)=-f*(a00*(a21*a33-a23*a31)-a01*(a20*a33-a23*a30)+a03*(a20*a31-a21*a30));
+            mat_traits<R>::template write_element<2,2>(r)= f*(a00*(a11*a33-a13*a31)-a01*(a10*a33-a13*a30)+a03*(a10*a31-a11*a30));
+            mat_traits<R>::template write_element<2,3>(r)=-f*(a00*(a11*a23-a13*a21)-a01*(a10*a23-a13*a20)+a03*(a10*a21-a11*a20));
+            mat_traits<R>::template write_element<3,0>(r)=-f*(a10*(a21*a32-a22*a31)-a11*(a20*a32-a22*a30)+a12*(a20*a31-a21*a30));
+            mat_traits<R>::template write_element<3,1>(r)= f*(a00*(a21*a32-a22*a31)-a01*(a20*a32-a22*a30)+a02*(a20*a31-a21*a30));
+            mat_traits<R>::template write_element<3,2>(r)=-f*(a00*(a11*a32-a12*a31)-a01*(a10*a32-a12*a30)+a02*(a10*a31-a11*a30));
+            mat_traits<R>::template write_element<3,3>(r)= f*(a00*(a11*a22-a12*a21)-a01*(a10*a22-a12*a20)+a02*(a10*a21-a11*a20));
+            return r;
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<A>::cols==4,
+            deduce_mat<A> >::type
+        inverse( A const & a )
+            {
+            typedef typename mat_traits<A>::scalar_type T;
+            T det=determinant(a);
+            if( det==scalar_traits<T>::value(0) )
+                BOOST_QVM_THROW_EXCEPTION(zero_determinant_error());
+            return inverse(a,det);
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::inverse;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct inverse_m_defined;
+
+            template <>
+            struct
+            inverse_m_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<B>::rows==4 &&
+            mat_traits<A>::cols==4 && mat_traits<B>::cols==4,
+            deduce_mat2<A,B,4,4> >::type
+        operator*( A const & a, B const & b )
+            {
+            typedef typename mat_traits<A>::scalar_type Ta;
+            typedef typename mat_traits<B>::scalar_type Tb;
+            Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
+            Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
+            Ta const a02 = mat_traits<A>::template read_element<0,2>(a);
+            Ta const a03 = mat_traits<A>::template read_element<0,3>(a);
+            Ta const a10 = mat_traits<A>::template read_element<1,0>(a);
+            Ta const a11 = mat_traits<A>::template read_element<1,1>(a);
+            Ta const a12 = mat_traits<A>::template read_element<1,2>(a);
+            Ta const a13 = mat_traits<A>::template read_element<1,3>(a);
+            Ta const a20 = mat_traits<A>::template read_element<2,0>(a);
+            Ta const a21 = mat_traits<A>::template read_element<2,1>(a);
+            Ta const a22 = mat_traits<A>::template read_element<2,2>(a);
+            Ta const a23 = mat_traits<A>::template read_element<2,3>(a);
+            Ta const a30 = mat_traits<A>::template read_element<3,0>(a);
+            Ta const a31 = mat_traits<A>::template read_element<3,1>(a);
+            Ta const a32 = mat_traits<A>::template read_element<3,2>(a);
+            Ta const a33 = mat_traits<A>::template read_element<3,3>(a);
+            Tb const b00 = mat_traits<B>::template read_element<0,0>(b);
+            Tb const b01 = mat_traits<B>::template read_element<0,1>(b);
+            Tb const b02 = mat_traits<B>::template read_element<0,2>(b);
+            Tb const b03 = mat_traits<B>::template read_element<0,3>(b);
+            Tb const b10 = mat_traits<B>::template read_element<1,0>(b);
+            Tb const b11 = mat_traits<B>::template read_element<1,1>(b);
+            Tb const b12 = mat_traits<B>::template read_element<1,2>(b);
+            Tb const b13 = mat_traits<B>::template read_element<1,3>(b);
+            Tb const b20 = mat_traits<B>::template read_element<2,0>(b);
+            Tb const b21 = mat_traits<B>::template read_element<2,1>(b);
+            Tb const b22 = mat_traits<B>::template read_element<2,2>(b);
+            Tb const b23 = mat_traits<B>::template read_element<2,3>(b);
+            Tb const b30 = mat_traits<B>::template read_element<3,0>(b);
+            Tb const b31 = mat_traits<B>::template read_element<3,1>(b);
+            Tb const b32 = mat_traits<B>::template read_element<3,2>(b);
+            Tb const b33 = mat_traits<B>::template read_element<3,3>(b);
+            typedef typename deduce_mat2<A,B,4,4>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==4);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==4);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a00*b00+a01*b10+a02*b20+a03*b30;
+            mat_traits<R>::template write_element<0,1>(r)=a00*b01+a01*b11+a02*b21+a03*b31;
+            mat_traits<R>::template write_element<0,2>(r)=a00*b02+a01*b12+a02*b22+a03*b32;
+            mat_traits<R>::template write_element<0,3>(r)=a00*b03+a01*b13+a02*b23+a03*b33;
+            mat_traits<R>::template write_element<1,0>(r)=a10*b00+a11*b10+a12*b20+a13*b30;
+            mat_traits<R>::template write_element<1,1>(r)=a10*b01+a11*b11+a12*b21+a13*b31;
+            mat_traits<R>::template write_element<1,2>(r)=a10*b02+a11*b12+a12*b22+a13*b32;
+            mat_traits<R>::template write_element<1,3>(r)=a10*b03+a11*b13+a12*b23+a13*b33;
+            mat_traits<R>::template write_element<2,0>(r)=a20*b00+a21*b10+a22*b20+a23*b30;
+            mat_traits<R>::template write_element<2,1>(r)=a20*b01+a21*b11+a22*b21+a23*b31;
+            mat_traits<R>::template write_element<2,2>(r)=a20*b02+a21*b12+a22*b22+a23*b32;
+            mat_traits<R>::template write_element<2,3>(r)=a20*b03+a21*b13+a22*b23+a23*b33;
+            mat_traits<R>::template write_element<3,0>(r)=a30*b00+a31*b10+a32*b20+a33*b30;
+            mat_traits<R>::template write_element<3,1>(r)=a30*b01+a31*b11+a32*b21+a33*b31;
+            mat_traits<R>::template write_element<3,2>(r)=a30*b02+a31*b12+a32*b22+a33*b32;
+            mat_traits<R>::template write_element<3,3>(r)=a30*b03+a31*b13+a32*b23+a33*b33;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int CR,int C>
+            struct mul_mm_defined;
+
+            template <>
+            struct
+            mul_mm_defined<4,4,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<B>::rows==4 &&
+            mat_traits<A>::cols==4 && mat_traits<B>::cols==4,
+            A &>::type
+        operator*=( A & a, B const & b )
+            {
+            typedef typename mat_traits<A>::scalar_type Ta;
+            typedef typename mat_traits<B>::scalar_type Tb;
+            Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
+            Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
+            Ta const a02 = mat_traits<A>::template read_element<0,2>(a);
+            Ta const a03 = mat_traits<A>::template read_element<0,3>(a);
+            Ta const a10 = mat_traits<A>::template read_element<1,0>(a);
+            Ta const a11 = mat_traits<A>::template read_element<1,1>(a);
+            Ta const a12 = mat_traits<A>::template read_element<1,2>(a);
+            Ta const a13 = mat_traits<A>::template read_element<1,3>(a);
+            Ta const a20 = mat_traits<A>::template read_element<2,0>(a);
+            Ta const a21 = mat_traits<A>::template read_element<2,1>(a);
+            Ta const a22 = mat_traits<A>::template read_element<2,2>(a);
+            Ta const a23 = mat_traits<A>::template read_element<2,3>(a);
+            Ta const a30 = mat_traits<A>::template read_element<3,0>(a);
+            Ta const a31 = mat_traits<A>::template read_element<3,1>(a);
+            Ta const a32 = mat_traits<A>::template read_element<3,2>(a);
+            Ta const a33 = mat_traits<A>::template read_element<3,3>(a);
+            Tb const b00 = mat_traits<B>::template read_element<0,0>(b);
+            Tb const b01 = mat_traits<B>::template read_element<0,1>(b);
+            Tb const b02 = mat_traits<B>::template read_element<0,2>(b);
+            Tb const b03 = mat_traits<B>::template read_element<0,3>(b);
+            Tb const b10 = mat_traits<B>::template read_element<1,0>(b);
+            Tb const b11 = mat_traits<B>::template read_element<1,1>(b);
+            Tb const b12 = mat_traits<B>::template read_element<1,2>(b);
+            Tb const b13 = mat_traits<B>::template read_element<1,3>(b);
+            Tb const b20 = mat_traits<B>::template read_element<2,0>(b);
+            Tb const b21 = mat_traits<B>::template read_element<2,1>(b);
+            Tb const b22 = mat_traits<B>::template read_element<2,2>(b);
+            Tb const b23 = mat_traits<B>::template read_element<2,3>(b);
+            Tb const b30 = mat_traits<B>::template read_element<3,0>(b);
+            Tb const b31 = mat_traits<B>::template read_element<3,1>(b);
+            Tb const b32 = mat_traits<B>::template read_element<3,2>(b);
+            Tb const b33 = mat_traits<B>::template read_element<3,3>(b);
+            mat_traits<A>::template write_element<0,0>(a)=a00*b00+a01*b10+a02*b20+a03*b30;
+            mat_traits<A>::template write_element<0,1>(a)=a00*b01+a01*b11+a02*b21+a03*b31;
+            mat_traits<A>::template write_element<0,2>(a)=a00*b02+a01*b12+a02*b22+a03*b32;
+            mat_traits<A>::template write_element<0,3>(a)=a00*b03+a01*b13+a02*b23+a03*b33;
+            mat_traits<A>::template write_element<1,0>(a)=a10*b00+a11*b10+a12*b20+a13*b30;
+            mat_traits<A>::template write_element<1,1>(a)=a10*b01+a11*b11+a12*b21+a13*b31;
+            mat_traits<A>::template write_element<1,2>(a)=a10*b02+a11*b12+a12*b22+a13*b32;
+            mat_traits<A>::template write_element<1,3>(a)=a10*b03+a11*b13+a12*b23+a13*b33;
+            mat_traits<A>::template write_element<2,0>(a)=a20*b00+a21*b10+a22*b20+a23*b30;
+            mat_traits<A>::template write_element<2,1>(a)=a20*b01+a21*b11+a22*b21+a23*b31;
+            mat_traits<A>::template write_element<2,2>(a)=a20*b02+a21*b12+a22*b22+a23*b32;
+            mat_traits<A>::template write_element<2,3>(a)=a20*b03+a21*b13+a22*b23+a23*b33;
+            mat_traits<A>::template write_element<3,0>(a)=a30*b00+a31*b10+a32*b20+a33*b30;
+            mat_traits<A>::template write_element<3,1>(a)=a30*b01+a31*b11+a32*b21+a33*b31;
+            mat_traits<A>::template write_element<3,2>(a)=a30*b02+a31*b12+a32*b22+a33*b32;
+            mat_traits<A>::template write_element<3,3>(a)=a30*b03+a31*b13+a32*b23+a33*b33;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct mul_eq_mm_defined;
+
+            template <>
+            struct
+            mul_eq_mm_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<B>::rows==4 &&
+            mat_traits<A>::cols==4 && mat_traits<B>::cols==1,
+            deduce_mat2<A,B,4,1> >::type
+        operator*( A const & a, B const & b )
+            {
+            typedef typename mat_traits<A>::scalar_type Ta;
+            typedef typename mat_traits<B>::scalar_type Tb;
+            Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
+            Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
+            Ta const a02 = mat_traits<A>::template read_element<0,2>(a);
+            Ta const a03 = mat_traits<A>::template read_element<0,3>(a);
+            Ta const a10 = mat_traits<A>::template read_element<1,0>(a);
+            Ta const a11 = mat_traits<A>::template read_element<1,1>(a);
+            Ta const a12 = mat_traits<A>::template read_element<1,2>(a);
+            Ta const a13 = mat_traits<A>::template read_element<1,3>(a);
+            Ta const a20 = mat_traits<A>::template read_element<2,0>(a);
+            Ta const a21 = mat_traits<A>::template read_element<2,1>(a);
+            Ta const a22 = mat_traits<A>::template read_element<2,2>(a);
+            Ta const a23 = mat_traits<A>::template read_element<2,3>(a);
+            Ta const a30 = mat_traits<A>::template read_element<3,0>(a);
+            Ta const a31 = mat_traits<A>::template read_element<3,1>(a);
+            Ta const a32 = mat_traits<A>::template read_element<3,2>(a);
+            Ta const a33 = mat_traits<A>::template read_element<3,3>(a);
+            Tb const b00 = mat_traits<B>::template read_element<0,0>(b);
+            Tb const b10 = mat_traits<B>::template read_element<1,0>(b);
+            Tb const b20 = mat_traits<B>::template read_element<2,0>(b);
+            Tb const b30 = mat_traits<B>::template read_element<3,0>(b);
+            typedef typename deduce_mat2<A,B,4,1>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==4);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==1);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a00*b00+a01*b10+a02*b20+a03*b30;
+            mat_traits<R>::template write_element<1,0>(r)=a10*b00+a11*b10+a12*b20+a13*b30;
+            mat_traits<R>::template write_element<2,0>(r)=a20*b00+a21*b10+a22*b20+a23*b30;
+            mat_traits<R>::template write_element<3,0>(r)=a30*b00+a31*b10+a32*b20+a33*b30;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int CR,int C>
+            struct mul_mm_defined;
+
+            template <>
+            struct
+            mul_mm_defined<4,4,1>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==1 && mat_traits<B>::rows==4 &&
+            mat_traits<A>::cols==4 && mat_traits<B>::cols==4,
+            deduce_mat2<A,B,1,4> >::type
+        operator*( A const & a, B const & b )
+            {
+            typedef typename mat_traits<A>::scalar_type Ta;
+            typedef typename mat_traits<B>::scalar_type Tb;
+            Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
+            Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
+            Ta const a02 = mat_traits<A>::template read_element<0,2>(a);
+            Ta const a03 = mat_traits<A>::template read_element<0,3>(a);
+            Tb const b00 = mat_traits<B>::template read_element<0,0>(b);
+            Tb const b01 = mat_traits<B>::template read_element<0,1>(b);
+            Tb const b02 = mat_traits<B>::template read_element<0,2>(b);
+            Tb const b03 = mat_traits<B>::template read_element<0,3>(b);
+            Tb const b10 = mat_traits<B>::template read_element<1,0>(b);
+            Tb const b11 = mat_traits<B>::template read_element<1,1>(b);
+            Tb const b12 = mat_traits<B>::template read_element<1,2>(b);
+            Tb const b13 = mat_traits<B>::template read_element<1,3>(b);
+            Tb const b20 = mat_traits<B>::template read_element<2,0>(b);
+            Tb const b21 = mat_traits<B>::template read_element<2,1>(b);
+            Tb const b22 = mat_traits<B>::template read_element<2,2>(b);
+            Tb const b23 = mat_traits<B>::template read_element<2,3>(b);
+            Tb const b30 = mat_traits<B>::template read_element<3,0>(b);
+            Tb const b31 = mat_traits<B>::template read_element<3,1>(b);
+            Tb const b32 = mat_traits<B>::template read_element<3,2>(b);
+            Tb const b33 = mat_traits<B>::template read_element<3,3>(b);
+            typedef typename deduce_mat2<A,B,1,4>::type R;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::rows==1);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<R>::cols==4);
+            R r;
+            mat_traits<R>::template write_element<0,0>(r)=a00*b00+a01*b10+a02*b20+a03*b30;
+            mat_traits<R>::template write_element<0,1>(r)=a00*b01+a01*b11+a02*b21+a03*b31;
+            mat_traits<R>::template write_element<0,2>(r)=a00*b02+a01*b12+a02*b22+a03*b32;
+            mat_traits<R>::template write_element<0,3>(r)=a00*b03+a01*b13+a02*b23+a03*b33;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int CR,int C>
+            struct mul_mm_defined;
+
+            template <>
+            struct
+            mul_mm_defined<1,4,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/gen/swizzle2.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/gen/swizzle2.hpp
new file mode 100644
index 00000000000..a4f6ac27aa6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/gen/swizzle2.hpp
@@ -0,0 +1,714 @@
+//Copyright (c) 2008-2017 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_9673ED9162F6768D4F74A4AD0576876
+#define BOOST_QVM_9673ED9162F6768D4F74A4AD0576876
+
+//This file was generated by a program. Do not edit manually.
+
+#include <boost/qvm/detail/swizzle_traits.hpp>
+#include <boost/qvm/enable_if.hpp>
+#include <boost/qvm/inline.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > const &
+        _11()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > const *>(qvm_detail::get_null());
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > const &
+        _01()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > const *>(qvm_detail::get_null());
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > const &>::type
+        W1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > &>::type
+        W1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > const &>::type
+        Z1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > &>::type
+        Z1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > const &>::type
+        Y1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > &>::type
+        Y1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > const &>::type
+        X1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > const &>::type
+        X1( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > &>::type
+        X1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > &>::type
+        X1( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > &>(a);
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > const &
+        _10()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > const *>(qvm_detail::get_null());
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > const &
+        _00()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > const *>(qvm_detail::get_null());
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > const &>::type
+        W0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > &>::type
+        W0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > const &>::type
+        Z0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > &>::type
+        Z0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > const &>::type
+        Y0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > &>::type
+        Y0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > const &>::type
+        X0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > const &>::type
+        X0( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > &>::type
+        X0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > &>::type
+        X0( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > const &>::type
+        _1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > &>::type
+        _1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > const &>::type
+        _0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > &>::type
+        _0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > const &>::type
+        WW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > &>::type
+        WW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > const &>::type
+        ZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > &>::type
+        ZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > const &>::type
+        YW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > &>::type
+        YW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > const &>::type
+        XW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > &>::type
+        XW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > const &>::type
+        _1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > &>::type
+        _1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > const &>::type
+        _0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > &>::type
+        _0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > const &>::type
+        WZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > &>::type
+        WZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > const &>::type
+        ZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > &>::type
+        ZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > const &>::type
+        YZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > &>::type
+        YZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > const &>::type
+        XZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > &>::type
+        XZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > const &>::type
+        _1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > &>::type
+        _1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > const &>::type
+        _0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > &>::type
+        _0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > const &>::type
+        WY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > &>::type
+        WY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > const &>::type
+        ZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > &>::type
+        ZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > const &>::type
+        YY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > &>::type
+        YY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > const &>::type
+        XY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > &>::type
+        XY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > const &>::type
+        _1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > const &>::type
+        _1X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > &>::type
+        _1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > &>::type
+        _1X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > const &>::type
+        _0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > const &>::type
+        _0X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > &>::type
+        _0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > &>::type
+        _0X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > const &>::type
+        WX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > &>::type
+        WX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > const &>::type
+        ZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > &>::type
+        ZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > const &>::type
+        YX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > &>::type
+        YX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > const &>::type
+        XX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > const &>::type
+        XX( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > &>::type
+        XX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > &>::type
+        XX( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > &>(a);
+            }
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/gen/swizzle3.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/gen/swizzle3.hpp
new file mode 100644
index 00000000000..beacb2681eb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/gen/swizzle3.hpp
@@ -0,0 +1,4158 @@
+//Copyright (c) 2008-2017 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_FA16BB11ADAE248879FE52DB2543E53C
+#define BOOST_QVM_FA16BB11ADAE248879FE52DB2543E53C
+
+//This file was generated by a program. Do not edit manually.
+
+#include <boost/qvm/detail/swizzle_traits.hpp>
+#include <boost/qvm/enable_if.hpp>
+#include <boost/qvm/inline.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > const &
+        _111()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > const *>(qvm_detail::get_null());
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > const &
+        _011()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > const *>(qvm_detail::get_null());
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        W11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        W11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        Z11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        Z11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        Y11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        Y11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        X11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        X11( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        X11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        X11( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > const &
+        _101()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > const *>(qvm_detail::get_null());
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > const &
+        _001()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > const *>(qvm_detail::get_null());
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        W01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        W01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        Z01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        Z01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        Y01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        Y01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        X01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        X01( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        X01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        X01( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        _1W1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        _1W1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        _0W1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        _0W1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        WW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        WW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        ZW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        ZW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        YW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        YW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        XW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        XW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        _1Z1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        _1Z1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        _0Z1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        _0Z1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        WZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        WZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        ZZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        ZZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        YZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        YZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        XZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        XZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        _1Y1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        _1Y1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        _0Y1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        _0Y1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        WY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        WY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        ZY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        ZY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        YY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        YY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        XY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        XY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        _1X1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        _1X1( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        _1X1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        _1X1( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        _0X1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        _0X1( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        _0X1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        _0X1( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        WX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        WX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        ZX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        ZX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        YX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        YX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        XX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > const &>::type
+        XX1( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        XX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > &>::type
+        XX1( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > &>(a);
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > const &
+        _110()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > const *>(qvm_detail::get_null());
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > const &
+        _010()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > const *>(qvm_detail::get_null());
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        W10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        W10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        Z10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        Z10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        Y10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        Y10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        X10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        X10( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        X10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        X10( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > const &
+        _100()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > const *>(qvm_detail::get_null());
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > const &
+        _000()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > const *>(qvm_detail::get_null());
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        W00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        W00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        Z00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        Z00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        Y00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        Y00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        X00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        X00( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        X00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        X00( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        _1W0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        _1W0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        _0W0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        _0W0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        WW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        WW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        ZW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        ZW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        YW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        YW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        XW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        XW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        _1Z0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        _1Z0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        _0Z0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        _0Z0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        WZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        WZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        ZZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        ZZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        YZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        YZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        XZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        XZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        _1Y0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        _1Y0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        _0Y0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        _0Y0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        WY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        WY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        ZY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        ZY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        YY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        YY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        XY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        XY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        _1X0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        _1X0( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        _1X0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        _1X0( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        _0X0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        _0X0( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        _0X0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        _0X0( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        WX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        WX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        ZX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        ZX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        YX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        YX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        XX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > const &>::type
+        XX0( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        XX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > &>::type
+        XX0( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        _11W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > &>::type
+        _11W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        _01W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > &>::type
+        _01W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        W1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > &>::type
+        W1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        Z1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > &>::type
+        Z1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        Y1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > &>::type
+        Y1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        X1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > &>::type
+        X1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        _10W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > &>::type
+        _10W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        _00W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > &>::type
+        _00W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        W0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > &>::type
+        W0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        Z0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > &>::type
+        Z0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        Y0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > &>::type
+        Y0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        X0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > &>::type
+        X0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        _1WW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > &>::type
+        _1WW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        _0WW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > &>::type
+        _0WW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        WWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > &>::type
+        WWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        ZWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > &>::type
+        ZWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        YWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > &>::type
+        YWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        XWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > &>::type
+        XWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        _1ZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > &>::type
+        _1ZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        _0ZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > &>::type
+        _0ZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        WZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > &>::type
+        WZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        ZZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > &>::type
+        ZZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        YZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > &>::type
+        YZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        XZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > &>::type
+        XZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        _1YW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > &>::type
+        _1YW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        _0YW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > &>::type
+        _0YW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        WYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > &>::type
+        WYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        ZYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > &>::type
+        ZYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        YYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > &>::type
+        YYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        XYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > &>::type
+        XYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        _1XW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > &>::type
+        _1XW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        _0XW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > &>::type
+        _0XW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        WXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > &>::type
+        WXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        ZXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > &>::type
+        ZXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        YXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > &>::type
+        YXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > const &>::type
+        XXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > &>::type
+        XXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        _11Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > &>::type
+        _11Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        _01Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > &>::type
+        _01Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        W1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > &>::type
+        W1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        Z1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > &>::type
+        Z1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        Y1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > &>::type
+        Y1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        X1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > &>::type
+        X1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        _10Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > &>::type
+        _10Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        _00Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > &>::type
+        _00Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        W0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > &>::type
+        W0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        Z0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > &>::type
+        Z0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        Y0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > &>::type
+        Y0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        X0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > &>::type
+        X0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        _1WZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > &>::type
+        _1WZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        _0WZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > &>::type
+        _0WZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        WWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > &>::type
+        WWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        ZWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > &>::type
+        ZWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        YWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > &>::type
+        YWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        XWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > &>::type
+        XWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        _1ZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > &>::type
+        _1ZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        _0ZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > &>::type
+        _0ZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        WZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > &>::type
+        WZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        ZZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > &>::type
+        ZZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        YZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > &>::type
+        YZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        XZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > &>::type
+        XZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        _1YZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > &>::type
+        _1YZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        _0YZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > &>::type
+        _0YZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        WYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > &>::type
+        WYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        ZYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > &>::type
+        ZYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        YYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > &>::type
+        YYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        XYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > &>::type
+        XYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        _1XZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > &>::type
+        _1XZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        _0XZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > &>::type
+        _0XZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        WXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > &>::type
+        WXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        ZXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > &>::type
+        ZXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        YXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > &>::type
+        YXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > const &>::type
+        XXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > &>::type
+        XXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        _11Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > &>::type
+        _11Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        _01Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > &>::type
+        _01Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        W1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > &>::type
+        W1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        Z1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > &>::type
+        Z1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        Y1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > &>::type
+        Y1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        X1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > &>::type
+        X1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        _10Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > &>::type
+        _10Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        _00Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > &>::type
+        _00Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        W0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > &>::type
+        W0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        Z0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > &>::type
+        Z0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        Y0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > &>::type
+        Y0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        X0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > &>::type
+        X0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        _1WY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > &>::type
+        _1WY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        _0WY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > &>::type
+        _0WY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        WWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > &>::type
+        WWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        ZWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > &>::type
+        ZWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        YWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > &>::type
+        YWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        XWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > &>::type
+        XWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        _1ZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > &>::type
+        _1ZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        _0ZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > &>::type
+        _0ZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        WZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > &>::type
+        WZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        ZZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > &>::type
+        ZZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        YZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > &>::type
+        YZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        XZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > &>::type
+        XZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        _1YY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > &>::type
+        _1YY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        _0YY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > &>::type
+        _0YY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        WYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > &>::type
+        WYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        ZYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > &>::type
+        ZYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        YYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > &>::type
+        YYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        XYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > &>::type
+        XYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        _1XY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > &>::type
+        _1XY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        _0XY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > &>::type
+        _0XY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        WXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > &>::type
+        WXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        ZXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > &>::type
+        ZXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        YXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > &>::type
+        YXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > const &>::type
+        XXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > &>::type
+        XXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        _11X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        _11X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > &>::type
+        _11X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > &>::type
+        _11X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        _01X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        _01X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > &>::type
+        _01X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > &>::type
+        _01X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        W1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > &>::type
+        W1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        Z1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > &>::type
+        Z1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        Y1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > &>::type
+        Y1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        X1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        X1X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > &>::type
+        X1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > &>::type
+        X1X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        _10X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        _10X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > &>::type
+        _10X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > &>::type
+        _10X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        _00X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        _00X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > &>::type
+        _00X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > &>::type
+        _00X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        W0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > &>::type
+        W0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        Z0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > &>::type
+        Z0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        Y0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > &>::type
+        Y0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        X0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        X0X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > &>::type
+        X0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > &>::type
+        X0X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        _1WX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > &>::type
+        _1WX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        _0WX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > &>::type
+        _0WX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        WWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > &>::type
+        WWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        ZWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > &>::type
+        ZWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        YWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > &>::type
+        YWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        XWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > &>::type
+        XWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        _1ZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > &>::type
+        _1ZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        _0ZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > &>::type
+        _0ZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        WZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > &>::type
+        WZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        ZZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > &>::type
+        ZZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        YZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > &>::type
+        YZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        XZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > &>::type
+        XZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        _1YX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > &>::type
+        _1YX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        _0YX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > &>::type
+        _0YX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        WYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > &>::type
+        WYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        ZYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > &>::type
+        ZYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        YYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > &>::type
+        YYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        XYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > &>::type
+        XYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        _1XX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        _1XX( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > &>::type
+        _1XX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > &>::type
+        _1XX( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        _0XX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        _0XX( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > &>::type
+        _0XX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > &>::type
+        _0XX( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        WXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > &>::type
+        WXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        ZXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > &>::type
+        ZXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        YXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > &>::type
+        YXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        XXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > const &>::type
+        XXX( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > &>::type
+        XXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > &>::type
+        XXX( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > &>(a);
+            }
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/gen/swizzle4.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/gen/swizzle4.hpp
new file mode 100644
index 00000000000..c400a12a6f3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/gen/swizzle4.hpp
@@ -0,0 +1,24330 @@
+//Copyright (c) 2008-2017 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_F445D3D828CEBF5C560593D97278A59
+#define BOOST_QVM_F445D3D828CEBF5C560593D97278A59
+
+//This file was generated by a program. Do not edit manually.
+
+#include <boost/qvm/detail/swizzle_traits.hpp>
+#include <boost/qvm/enable_if.hpp>
+#include <boost/qvm/inline.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &
+        _1111()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const *>(qvm_detail::get_null());
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &
+        _0111()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const *>(qvm_detail::get_null());
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        W111( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        W111( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Z111( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Z111( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Y111( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Y111( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        X111( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        X111( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        X111( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        X111( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &
+        _1011()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const *>(qvm_detail::get_null());
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &
+        _0011()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const *>(qvm_detail::get_null());
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        W011( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        W011( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Z011( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Z011( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Y011( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Y011( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        X011( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        X011( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        X011( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        X011( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1W11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1W11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0W11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0W11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WW11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WW11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZW11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZW11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YW11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YW11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XW11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XW11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1Z11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1Z11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0Z11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0Z11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WZ11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WZ11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZZ11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZZ11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YZ11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YZ11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XZ11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XZ11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1Y11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1Y11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0Y11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0Y11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WY11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WY11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZY11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZY11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YY11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YY11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XY11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XY11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1X11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1X11( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1X11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1X11( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0X11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0X11( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0X11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0X11( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WX11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WX11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZX11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZX11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YX11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YX11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XX11( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XX11( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XX11( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XX11( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &
+        _1101()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const *>(qvm_detail::get_null());
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &
+        _0101()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const *>(qvm_detail::get_null());
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        W101( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        W101( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Z101( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Z101( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Y101( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Y101( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        X101( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        X101( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        X101( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        X101( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &
+        _1001()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const *>(qvm_detail::get_null());
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &
+        _0001()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const *>(qvm_detail::get_null());
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        W001( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        W001( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Z001( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Z001( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Y001( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Y001( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        X001( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        X001( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        X001( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        X001( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1W01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1W01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0W01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0W01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WW01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WW01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZW01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZW01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YW01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YW01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XW01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XW01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1Z01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1Z01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0Z01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0Z01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WZ01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WZ01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZZ01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZZ01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YZ01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YZ01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XZ01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XZ01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1Y01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1Y01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0Y01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0Y01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WY01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WY01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZY01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZY01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YY01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YY01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XY01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XY01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1X01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1X01( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1X01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1X01( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0X01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0X01( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0X01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0X01( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WX01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WX01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZX01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZX01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YX01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YX01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XX01( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XX01( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XX01( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XX01( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _11W1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _11W1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _01W1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _01W1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        W1W1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        W1W1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Z1W1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Z1W1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Y1W1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Y1W1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        X1W1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        X1W1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _10W1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _10W1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _00W1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _00W1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        W0W1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        W0W1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Z0W1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Z0W1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Y0W1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Y0W1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        X0W1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        X0W1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1WW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1WW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0WW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0WW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WWW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WWW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZWW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZWW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YWW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YWW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XWW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XWW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1ZW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1ZW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0ZW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0ZW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WZW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WZW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZZW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZZW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YZW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YZW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XZW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XZW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1YW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1YW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0YW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0YW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WYW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WYW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZYW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZYW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YYW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YYW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XYW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XYW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1XW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1XW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0XW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0XW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WXW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WXW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZXW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZXW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YXW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YXW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XXW1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XXW1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _11Z1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _11Z1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _01Z1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _01Z1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        W1Z1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        W1Z1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Z1Z1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Z1Z1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Y1Z1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Y1Z1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        X1Z1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        X1Z1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _10Z1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _10Z1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _00Z1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _00Z1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        W0Z1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        W0Z1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Z0Z1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Z0Z1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Y0Z1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Y0Z1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        X0Z1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        X0Z1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1WZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1WZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0WZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0WZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WWZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WWZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZWZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZWZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YWZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YWZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XWZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XWZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1ZZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1ZZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0ZZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0ZZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WZZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WZZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZZZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZZZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YZZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YZZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XZZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XZZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1YZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1YZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0YZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0YZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WYZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WYZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZYZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZYZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YYZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YYZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XYZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XYZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1XZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1XZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0XZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0XZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WXZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WXZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZXZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZXZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YXZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YXZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XXZ1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XXZ1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _11Y1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _11Y1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _01Y1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _01Y1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        W1Y1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        W1Y1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Z1Y1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Z1Y1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Y1Y1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Y1Y1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        X1Y1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        X1Y1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _10Y1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _10Y1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _00Y1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _00Y1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        W0Y1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        W0Y1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Z0Y1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Z0Y1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Y0Y1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Y0Y1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        X0Y1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        X0Y1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1WY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1WY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0WY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0WY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WWY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WWY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZWY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZWY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YWY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YWY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XWY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XWY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1ZY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1ZY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0ZY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0ZY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WZY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WZY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZZY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZZY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YZY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YZY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XZY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XZY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1YY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1YY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0YY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0YY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WYY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WYY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZYY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZYY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YYY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YYY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XYY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XYY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1XY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1XY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0XY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0XY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WXY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WXY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZXY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZXY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YXY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YXY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XXY1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XXY1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _11X1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _11X1( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _11X1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _11X1( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _01X1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _01X1( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _01X1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _01X1( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        W1X1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        W1X1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Z1X1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Z1X1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Y1X1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Y1X1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        X1X1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        X1X1( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        X1X1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        X1X1( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _10X1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _10X1( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _10X1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _10X1( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _00X1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _00X1( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _00X1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _00X1( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        W0X1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        W0X1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Z0X1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Z0X1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        Y0X1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        Y0X1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        X0X1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        X0X1( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        X0X1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        X0X1( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1WX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1WX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0WX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0WX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WWX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WWX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZWX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZWX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YWX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YWX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XWX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XWX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1ZX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1ZX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0ZX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0ZX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WZX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WZX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZZX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZZX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YZX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YZX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XZX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XZX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1YX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1YX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0YX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0YX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WYX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WYX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZYX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZYX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YYX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YYX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XYX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XYX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1XX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _1XX1( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1XX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _1XX1( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0XX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        _0XX1( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0XX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        _0XX1( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        WXX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        WXX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        ZXX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        ZXX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        YXX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        YXX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XXX1( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>::type
+        XXX1( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XXX1( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>::type
+        XXX1( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2 > > > > > &>(a);
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &
+        _1110()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const *>(qvm_detail::get_null());
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &
+        _0110()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const *>(qvm_detail::get_null());
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        W110( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        W110( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Z110( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Z110( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Y110( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Y110( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        X110( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        X110( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        X110( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        X110( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &
+        _1010()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const *>(qvm_detail::get_null());
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &
+        _0010()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const *>(qvm_detail::get_null());
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        W010( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        W010( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Z010( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Z010( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Y010( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Y010( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        X010( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        X010( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        X010( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        X010( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1W10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1W10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0W10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0W10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WW10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WW10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZW10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZW10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YW10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YW10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XW10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XW10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1Z10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1Z10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0Z10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0Z10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WZ10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WZ10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZZ10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZZ10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YZ10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YZ10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XZ10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XZ10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1Y10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1Y10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0Y10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0Y10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WY10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WY10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZY10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZY10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YY10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YY10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XY10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XY10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1X10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1X10( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1X10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1X10( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0X10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0X10( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0X10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0X10( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WX10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WX10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZX10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZX10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YX10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YX10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XX10( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XX10( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XX10( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XX10( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &
+        _1100()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const *>(qvm_detail::get_null());
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &
+        _0100()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const *>(qvm_detail::get_null());
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        W100( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        W100( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Z100( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Z100( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Y100( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Y100( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        X100( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        X100( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        X100( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        X100( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &
+        _1000()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const *>(qvm_detail::get_null());
+            }
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &
+        _0000()
+            {
+            return *reinterpret_cast<qvm_detail::sw01_<qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const *>(qvm_detail::get_null());
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        W000( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        W000( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Z000( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Z000( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Y000( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Y000( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        X000( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        X000( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        X000( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        X000( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1W00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1W00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0W00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0W00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WW00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WW00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZW00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZW00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YW00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YW00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XW00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XW00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1Z00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1Z00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0Z00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0Z00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WZ00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WZ00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZZ00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZZ00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YZ00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YZ00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XZ00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XZ00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1Y00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1Y00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0Y00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0Y00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WY00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WY00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZY00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZY00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YY00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YY00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XY00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XY00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1X00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1X00( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1X00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1X00( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0X00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0X00( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0X00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0X00( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WX00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WX00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZX00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZX00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YX00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YX00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XX00( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XX00( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XX00( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XX00( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _11W0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _11W0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _01W0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _01W0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        W1W0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        W1W0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Z1W0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Z1W0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Y1W0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Y1W0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        X1W0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        X1W0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _10W0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _10W0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _00W0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _00W0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        W0W0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        W0W0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Z0W0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Z0W0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Y0W0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Y0W0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        X0W0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        X0W0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1WW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1WW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0WW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0WW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WWW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WWW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZWW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZWW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YWW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YWW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XWW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XWW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1ZW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1ZW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0ZW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0ZW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WZW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WZW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZZW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZZW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YZW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YZW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XZW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XZW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1YW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1YW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0YW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0YW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WYW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WYW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZYW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZYW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YYW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YYW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XYW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XYW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1XW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1XW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0XW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0XW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WXW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WXW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZXW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZXW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YXW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YXW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XXW0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XXW0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _11Z0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _11Z0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _01Z0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _01Z0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        W1Z0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        W1Z0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Z1Z0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Z1Z0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Y1Z0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Y1Z0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        X1Z0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        X1Z0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _10Z0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _10Z0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _00Z0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _00Z0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        W0Z0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        W0Z0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Z0Z0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Z0Z0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Y0Z0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Y0Z0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        X0Z0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        X0Z0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1WZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1WZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0WZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0WZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WWZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WWZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZWZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZWZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YWZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YWZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XWZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XWZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1ZZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1ZZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0ZZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0ZZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WZZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WZZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZZZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZZZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YZZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YZZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XZZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XZZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1YZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1YZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0YZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0YZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WYZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WYZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZYZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZYZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YYZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YYZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XYZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XYZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1XZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1XZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0XZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0XZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WXZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WXZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZXZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZXZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YXZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YXZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XXZ0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XXZ0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _11Y0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _11Y0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _01Y0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _01Y0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        W1Y0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        W1Y0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Z1Y0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Z1Y0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Y1Y0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Y1Y0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        X1Y0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        X1Y0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _10Y0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _10Y0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _00Y0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _00Y0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        W0Y0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        W0Y0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Z0Y0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Z0Y0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Y0Y0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Y0Y0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        X0Y0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        X0Y0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1WY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1WY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0WY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0WY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WWY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WWY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZWY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZWY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YWY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YWY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XWY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XWY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1ZY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1ZY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0ZY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0ZY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WZY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WZY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZZY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZZY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YZY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YZY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XZY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XZY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1YY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1YY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0YY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0YY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WYY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WYY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZYY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZYY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YYY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YYY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XYY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XYY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1XY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1XY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0XY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0XY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WXY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WXY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZXY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZXY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YXY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YXY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XXY0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XXY0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _11X0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _11X0( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _11X0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _11X0( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _01X0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _01X0( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _01X0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _01X0( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        W1X0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        W1X0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Z1X0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Z1X0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Y1X0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Y1X0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        X1X0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        X1X0( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        X1X0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        X1X0( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _10X0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _10X0( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _10X0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _10X0( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _00X0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _00X0( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _00X0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _00X0( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        W0X0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        W0X0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Z0X0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Z0X0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        Y0X0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        Y0X0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        X0X0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        X0X0( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        X0X0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        X0X0( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1WX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1WX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0WX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0WX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WWX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WWX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZWX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZWX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YWX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YWX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XWX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XWX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1ZX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1ZX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0ZX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0ZX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WZX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WZX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZZX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZZX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YZX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YZX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XZX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XZX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1YX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1YX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0YX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0YX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WYX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WYX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZYX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZYX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YYX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YYX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XYX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XYX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1XX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _1XX0( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1XX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _1XX0( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0XX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        _0XX0( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0XX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        _0XX0( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        WXX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        WXX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        ZXX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        ZXX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        YXX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        YXX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XXX0( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>::type
+        XXX0( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XXX0( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>::type
+        XXX0( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _111W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _111W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _011W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _011W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        W11W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        W11W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Z11W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Z11W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Y11W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Y11W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        X11W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        X11W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _101W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _101W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _001W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _001W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        W01W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        W01W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Z01W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Z01W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Y01W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Y01W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        X01W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        X01W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1W1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1W1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0W1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0W1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WW1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WW1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZW1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZW1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YW1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YW1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XW1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XW1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1Z1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1Z1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0Z1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0Z1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WZ1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WZ1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZZ1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZZ1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YZ1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YZ1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XZ1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XZ1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1Y1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1Y1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0Y1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0Y1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WY1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WY1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZY1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZY1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YY1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YY1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XY1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XY1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1X1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1X1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0X1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0X1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WX1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WX1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZX1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZX1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YX1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YX1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XX1W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XX1W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _110W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _110W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _010W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _010W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        W10W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        W10W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Z10W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Z10W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Y10W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Y10W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        X10W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        X10W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _100W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _100W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _000W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _000W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        W00W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        W00W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Z00W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Z00W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Y00W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Y00W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        X00W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        X00W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1W0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1W0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0W0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0W0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WW0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WW0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZW0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZW0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YW0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YW0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XW0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XW0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1Z0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1Z0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0Z0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0Z0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WZ0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WZ0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZZ0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZZ0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YZ0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YZ0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XZ0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XZ0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1Y0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1Y0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0Y0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0Y0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WY0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WY0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZY0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZY0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YY0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YY0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XY0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XY0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1X0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1X0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0X0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0X0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WX0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WX0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZX0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZX0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YX0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YX0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XX0W( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XX0W( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _11WW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _11WW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _01WW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _01WW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        W1WW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        W1WW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Z1WW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Z1WW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Y1WW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Y1WW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        X1WW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        X1WW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _10WW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _10WW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _00WW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _00WW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        W0WW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        W0WW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Z0WW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Z0WW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Y0WW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Y0WW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        X0WW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        X0WW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1WWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1WWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0WWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0WWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WWWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WWWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZWWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZWWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YWWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YWWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XWWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XWWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1ZWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1ZWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0ZWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0ZWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WZWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WZWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZZWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZZWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YZWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YZWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XZWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XZWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1YWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1YWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0YWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0YWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WYWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WYWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZYWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZYWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YYWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YYWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XYWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XYWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1XWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1XWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0XWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0XWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WXWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WXWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZXWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZXWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YXWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YXWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XXWW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XXWW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _11ZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _11ZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _01ZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _01ZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        W1ZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        W1ZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Z1ZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Z1ZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Y1ZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Y1ZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        X1ZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        X1ZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _10ZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _10ZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _00ZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _00ZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        W0ZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        W0ZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Z0ZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Z0ZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Y0ZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Y0ZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        X0ZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        X0ZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1WZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1WZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0WZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0WZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WWZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WWZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZWZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZWZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YWZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YWZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XWZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XWZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1ZZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1ZZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0ZZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0ZZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WZZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WZZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZZZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZZZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YZZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YZZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XZZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XZZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1YZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1YZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0YZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0YZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WYZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WYZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZYZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZYZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YYZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YYZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XYZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XYZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1XZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1XZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0XZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0XZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WXZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WXZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZXZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZXZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YXZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YXZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XXZW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XXZW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _11YW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _11YW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _01YW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _01YW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        W1YW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        W1YW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Z1YW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Z1YW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Y1YW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Y1YW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        X1YW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        X1YW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _10YW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _10YW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _00YW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _00YW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        W0YW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        W0YW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Z0YW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Z0YW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Y0YW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Y0YW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        X0YW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        X0YW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1WYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1WYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0WYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0WYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WWYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WWYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZWYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZWYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YWYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YWYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XWYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XWYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1ZYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1ZYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0ZYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0ZYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WZYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WZYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZZYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZZYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YZYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YZYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XZYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XZYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1YYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1YYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0YYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0YYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WYYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WYYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZYYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZYYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YYYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YYYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XYYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XYYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1XYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1XYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0XYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0XYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WXYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WXYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZXYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZXYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YXYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YXYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XXYW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XXYW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _11XW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _11XW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _01XW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _01XW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        W1XW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        W1XW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Z1XW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Z1XW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Y1XW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Y1XW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        X1XW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        X1XW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _10XW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _10XW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _00XW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _00XW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        W0XW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        W0XW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Z0XW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Z0XW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        Y0XW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        Y0XW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        X0XW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        X0XW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1WXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1WXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0WXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0WXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WWXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WWXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZWXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZWXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YWXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YWXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XWXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XWXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1ZXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1ZXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0ZXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0ZXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WZXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WZXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZZXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZZXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YZXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YZXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XZXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XZXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1YXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1YXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0YXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0YXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WYXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WYXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZYXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZYXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YYXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YYXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XYXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XYXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _1XXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _1XXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        _0XXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        _0XXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        WXXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        WXXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        ZXXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        ZXXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        YXXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        YXXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>::type
+        XXXW( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>::type
+        XXXW( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _111Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _111Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _011Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _011Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        W11Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        W11Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Z11Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Z11Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Y11Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Y11Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        X11Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        X11Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _101Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _101Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _001Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _001Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        W01Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        W01Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Z01Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Z01Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Y01Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Y01Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        X01Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        X01Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1W1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1W1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0W1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0W1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WW1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WW1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZW1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZW1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YW1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YW1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XW1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XW1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1Z1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1Z1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0Z1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0Z1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WZ1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WZ1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZZ1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZZ1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YZ1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YZ1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XZ1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XZ1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1Y1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1Y1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0Y1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0Y1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WY1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WY1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZY1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZY1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YY1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YY1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XY1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XY1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1X1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1X1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0X1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0X1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WX1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WX1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZX1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZX1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YX1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YX1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XX1Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XX1Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _110Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _110Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _010Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _010Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        W10Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        W10Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Z10Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Z10Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Y10Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Y10Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        X10Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        X10Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _100Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _100Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _000Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _000Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        W00Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        W00Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Z00Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Z00Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Y00Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Y00Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        X00Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        X00Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1W0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1W0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0W0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0W0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WW0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WW0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZW0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZW0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YW0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YW0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XW0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XW0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1Z0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1Z0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0Z0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0Z0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WZ0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WZ0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZZ0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZZ0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YZ0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YZ0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XZ0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XZ0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1Y0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1Y0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0Y0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0Y0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WY0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WY0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZY0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZY0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YY0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YY0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XY0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XY0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1X0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1X0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0X0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0X0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WX0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WX0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZX0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZX0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YX0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YX0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XX0Z( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XX0Z( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _11WZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _11WZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _01WZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _01WZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        W1WZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        W1WZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Z1WZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Z1WZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Y1WZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Y1WZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        X1WZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        X1WZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _10WZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _10WZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _00WZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _00WZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        W0WZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        W0WZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Z0WZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Z0WZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Y0WZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Y0WZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        X0WZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        X0WZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1WWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1WWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0WWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0WWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WWWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WWWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZWWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZWWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YWWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YWWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XWWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XWWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1ZWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1ZWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0ZWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0ZWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WZWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WZWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZZWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZZWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YZWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YZWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XZWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XZWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1YWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1YWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0YWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0YWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WYWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WYWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZYWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZYWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YYWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YYWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XYWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XYWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1XWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1XWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0XWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0XWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WXWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WXWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZXWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZXWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YXWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YXWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XXWZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XXWZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _11ZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _11ZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _01ZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _01ZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        W1ZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        W1ZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Z1ZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Z1ZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Y1ZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Y1ZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        X1ZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        X1ZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _10ZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _10ZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _00ZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _00ZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        W0ZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        W0ZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Z0ZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Z0ZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Y0ZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Y0ZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        X0ZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        X0ZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1WZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1WZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0WZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0WZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WWZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WWZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZWZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZWZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YWZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YWZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XWZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XWZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1ZZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1ZZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0ZZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0ZZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WZZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WZZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZZZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZZZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YZZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YZZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XZZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XZZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1YZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1YZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0YZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0YZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WYZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WYZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZYZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZYZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YYZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YYZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XYZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XYZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1XZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1XZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0XZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0XZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WXZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WXZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZXZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZXZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YXZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YXZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XXZZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XXZZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _11YZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _11YZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _01YZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _01YZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        W1YZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        W1YZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Z1YZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Z1YZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Y1YZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Y1YZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        X1YZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        X1YZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _10YZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _10YZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _00YZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _00YZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        W0YZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        W0YZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Z0YZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Z0YZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Y0YZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Y0YZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        X0YZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        X0YZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1WYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1WYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0WYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0WYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WWYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WWYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZWYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZWYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YWYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YWYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XWYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XWYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1ZYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1ZYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0ZYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0ZYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WZYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WZYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZZYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZZYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YZYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YZYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XZYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XZYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1YYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1YYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0YYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0YYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WYYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WYYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZYYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZYYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YYYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YYYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XYYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XYYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1XYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1XYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0XYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0XYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WXYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WXYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZXYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZXYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YXYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YXYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XXYZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XXYZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _11XZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _11XZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _01XZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _01XZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        W1XZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        W1XZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Z1XZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Z1XZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Y1XZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Y1XZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        X1XZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        X1XZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _10XZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _10XZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _00XZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _00XZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        W0XZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        W0XZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Z0XZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Z0XZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        Y0XZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        Y0XZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        X0XZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        X0XZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1WXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1WXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0WXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0WXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WWXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WWXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZWXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZWXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YWXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YWXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XWXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XWXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1ZXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1ZXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0ZXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0ZXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WZXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WZXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZZXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZZXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YZXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YZXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XZXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XZXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1YXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1YXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0YXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0YXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WYXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WYXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZYXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZYXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YYXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YYXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XYXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XYXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _1XXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _1XXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        _0XXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        _0XXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        WXXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        WXXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        ZXXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        ZXXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        YXXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        YXXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>::type
+        XXXZ( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>::type
+        XXXZ( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _111Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _111Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _011Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _011Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        W11Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        W11Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Z11Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Z11Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Y11Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Y11Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        X11Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        X11Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _101Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _101Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _001Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _001Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        W01Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        W01Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Z01Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Z01Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Y01Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Y01Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        X01Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        X01Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1W1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1W1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0W1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0W1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WW1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WW1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZW1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZW1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YW1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YW1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XW1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XW1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1Z1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1Z1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0Z1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0Z1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WZ1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WZ1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZZ1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZZ1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YZ1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YZ1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XZ1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XZ1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1Y1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1Y1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0Y1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0Y1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WY1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WY1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZY1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZY1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YY1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YY1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XY1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XY1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1X1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1X1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0X1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0X1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WX1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WX1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZX1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZX1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YX1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YX1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XX1Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XX1Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _110Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _110Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _010Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _010Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        W10Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        W10Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Z10Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Z10Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Y10Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Y10Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        X10Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        X10Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _100Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _100Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _000Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _000Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        W00Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        W00Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Z00Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Z00Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Y00Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Y00Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        X00Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        X00Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1W0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1W0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0W0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0W0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WW0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WW0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZW0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZW0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YW0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YW0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XW0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XW0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1Z0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1Z0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0Z0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0Z0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WZ0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WZ0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZZ0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZZ0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YZ0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YZ0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XZ0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XZ0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1Y0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1Y0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0Y0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0Y0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WY0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WY0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZY0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZY0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YY0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YY0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XY0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XY0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1X0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1X0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0X0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0X0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WX0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WX0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZX0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZX0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YX0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YX0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XX0Y( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XX0Y( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _11WY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _11WY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _01WY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _01WY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        W1WY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        W1WY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Z1WY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Z1WY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Y1WY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Y1WY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        X1WY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        X1WY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _10WY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _10WY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _00WY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _00WY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        W0WY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        W0WY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Z0WY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Z0WY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Y0WY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Y0WY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        X0WY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        X0WY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1WWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1WWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0WWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0WWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WWWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WWWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZWWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZWWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YWWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YWWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XWWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XWWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1ZWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1ZWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0ZWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0ZWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WZWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WZWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZZWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZZWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YZWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YZWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XZWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XZWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1YWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1YWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0YWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0YWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WYWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WYWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZYWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZYWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YYWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YYWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XYWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XYWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1XWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1XWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0XWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0XWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WXWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WXWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZXWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZXWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YXWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YXWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XXWY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XXWY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _11ZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _11ZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _01ZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _01ZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        W1ZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        W1ZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Z1ZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Z1ZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Y1ZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Y1ZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        X1ZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        X1ZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _10ZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _10ZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _00ZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _00ZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        W0ZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        W0ZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Z0ZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Z0ZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Y0ZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Y0ZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        X0ZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        X0ZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1WZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1WZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0WZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0WZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WWZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WWZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZWZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZWZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YWZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YWZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XWZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XWZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1ZZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1ZZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0ZZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0ZZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WZZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WZZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZZZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZZZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YZZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YZZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XZZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XZZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1YZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1YZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0YZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0YZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WYZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WYZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZYZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZYZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YYZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YYZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XYZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XYZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1XZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1XZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0XZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0XZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WXZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WXZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZXZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZXZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YXZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YXZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XXZY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XXZY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _11YY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _11YY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _01YY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _01YY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        W1YY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        W1YY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Z1YY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Z1YY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Y1YY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Y1YY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        X1YY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        X1YY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _10YY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _10YY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _00YY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _00YY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        W0YY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        W0YY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Z0YY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Z0YY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Y0YY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Y0YY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        X0YY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        X0YY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1WYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1WYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0WYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0WYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WWYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WWYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZWYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZWYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YWYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YWYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XWYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XWYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1ZYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1ZYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0ZYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0ZYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WZYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WZYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZZYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZZYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YZYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YZYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XZYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XZYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1YYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1YYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0YYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0YYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WYYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WYYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZYYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZYYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YYYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YYYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XYYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XYYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1XYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1XYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0XYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0XYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WXYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WXYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZXYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZXYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YXYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YXYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XXYY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XXYY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _11XY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _11XY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _01XY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _01XY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        W1XY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        W1XY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Z1XY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Z1XY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Y1XY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Y1XY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        X1XY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        X1XY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _10XY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _10XY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _00XY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _00XY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        W0XY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        W0XY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Z0XY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Z0XY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        Y0XY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        Y0XY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        X0XY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        X0XY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1WXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1WXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0WXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0WXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WWXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WWXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZWXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZWXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YWXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YWXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XWXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XWXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1ZXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1ZXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0ZXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0ZXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WZXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WZXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZZXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZZXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YZXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YZXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XZXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XZXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1YXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1YXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0YXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0YXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WYXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WYXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZYXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZYXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YYXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YYXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XYXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XYXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _1XXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _1XXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        _0XXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        _0XXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        WXXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        WXXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        ZXXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        ZXXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        YXXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        YXXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>::type
+        XXXY( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>::type
+        XXXY( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _111X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _111X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _111X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _111X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _011X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _011X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _011X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _011X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        W11X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        W11X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Z11X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Z11X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Y11X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Y11X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        X11X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        X11X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        X11X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        X11X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _101X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _101X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _101X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _101X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _001X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _001X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _001X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _001X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        W01X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        W01X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Z01X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Z01X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Y01X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Y01X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        X01X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        X01X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        X01X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        X01X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1W1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1W1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0W1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0W1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WW1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WW1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZW1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZW1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YW1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YW1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XW1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XW1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1Z1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1Z1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0Z1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0Z1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WZ1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WZ1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZZ1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZZ1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YZ1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YZ1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XZ1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XZ1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1Y1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1Y1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0Y1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0Y1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WY1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WY1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZY1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZY1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YY1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YY1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XY1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XY1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1X1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1X1X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1X1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1X1X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0X1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0X1X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0X1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0X1X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WX1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WX1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZX1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZX1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YX1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YX1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XX1X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XX1X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XX1X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XX1X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _110X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _110X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _110X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _110X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _010X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _010X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _010X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _010X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        W10X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        W10X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Z10X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Z10X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Y10X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Y10X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        X10X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        X10X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        X10X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        X10X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _100X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _100X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _100X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _100X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _000X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _000X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _000X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _000X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        W00X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        W00X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Z00X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Z00X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Y00X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Y00X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        X00X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        X00X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        X00X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        X00X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1W0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1W0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0W0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0W0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WW0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WW0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZW0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZW0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YW0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YW0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XW0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XW0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1Z0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1Z0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0Z0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0Z0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WZ0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WZ0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZZ0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZZ0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YZ0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YZ0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XZ0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XZ0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1Y0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1Y0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0Y0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0Y0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WY0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WY0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZY0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZY0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YY0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YY0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XY0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XY0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1X0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1X0X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1X0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1X0X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0X0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0X0X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0X0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0X0X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WX0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WX0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZX0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZX0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YX0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YX0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XX0X( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XX0X( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XX0X( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XX0X( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _11WX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _11WX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _01WX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _01WX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        W1WX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        W1WX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Z1WX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Z1WX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Y1WX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Y1WX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        X1WX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        X1WX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _10WX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _10WX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _00WX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _00WX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        W0WX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        W0WX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Z0WX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Z0WX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Y0WX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Y0WX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        X0WX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        X0WX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1WWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1WWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0WWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0WWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WWWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WWWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZWWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZWWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YWWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YWWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XWWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XWWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1ZWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1ZWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0ZWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0ZWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WZWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WZWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZZWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZZWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YZWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YZWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XZWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XZWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1YWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1YWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0YWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0YWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WYWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WYWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZYWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZYWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YYWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YYWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XYWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XYWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1XWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1XWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0XWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0XWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WXWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WXWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZXWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZXWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YXWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YXWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XXWX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XXWX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _11ZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _11ZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _01ZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _01ZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        W1ZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        W1ZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Z1ZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Z1ZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Y1ZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Y1ZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        X1ZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        X1ZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _10ZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _10ZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _00ZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _00ZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        W0ZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        W0ZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Z0ZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Z0ZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Y0ZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Y0ZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        X0ZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        X0ZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1WZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1WZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0WZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0WZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WWZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WWZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZWZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZWZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YWZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YWZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XWZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XWZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1ZZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1ZZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0ZZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0ZZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WZZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WZZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZZZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZZZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YZZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YZZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XZZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XZZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1YZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1YZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0YZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0YZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WYZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WYZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZYZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZYZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YYZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YYZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XYZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XYZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1XZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1XZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0XZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0XZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WXZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WXZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZXZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZXZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YXZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YXZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XXZX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XXZX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _11YX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _11YX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _01YX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _01YX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        W1YX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        W1YX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Z1YX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Z1YX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Y1YX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Y1YX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        X1YX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        X1YX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _10YX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _10YX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _00YX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _00YX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        W0YX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        W0YX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Z0YX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Z0YX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Y0YX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Y0YX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        X0YX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        X0YX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1WYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1WYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0WYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0WYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WWYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WWYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZWYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZWYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YWYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YWYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XWYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XWYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1ZYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1ZYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0ZYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0ZYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WZYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WZYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZZYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZZYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YZYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YZYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XZYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XZYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1YYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1YYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0YYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0YYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WYYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WYYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZYYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZYYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YYYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YYYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XYYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XYYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1XYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1XYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0XYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0XYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WXYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WXYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZXYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZXYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YXYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YXYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XXYX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XXYX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _11XX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _11XX( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _11XX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _11XX( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _01XX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _01XX( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _01XX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _01XX( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        W1XX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        W1XX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Z1XX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Z1XX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Y1XX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Y1XX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        X1XX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        X1XX( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        X1XX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        X1XX( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _10XX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _10XX( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _10XX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _10XX( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _00XX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _00XX( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _00XX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _00XX( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        W0XX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        W0XX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Z0XX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Z0XX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        Y0XX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        Y0XX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        X0XX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        X0XX( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        X0XX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        X0XX( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1WXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1WXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0WXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0WXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WWXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WWXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZWXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZWXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YWXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YWXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XWXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XWXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1ZXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1ZXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0ZXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0ZXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WZXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WZXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZZXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZZXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YZXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YZXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XZXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XZXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1YXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1YXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0YXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0YXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WYXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WYXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZYXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZYXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YYXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YYXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XYXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XYXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1XXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _1XXX( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1XXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _1XXX( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0XXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        _0XXX( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0XXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        _0XXX( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<-1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        WXXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=4,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        WXXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<3,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        ZXXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=3,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        ZXXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<2,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        YXXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=2,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        YXXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<1,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XXXX( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>::type
+        XXXX( S const & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > const &>(a);
+            }
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value && vec_traits<V>::dim>=1,
+            qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XXXX( V & a )
+            {
+            return reinterpret_cast<qvm_detail::sw_<V,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        template <class S>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_scalar<S>::value,
+            qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>::type
+        XXXX( S & a )
+            {
+            return reinterpret_cast<qvm_detail::sws_<S,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0,qvm_detail::swizzle_idx<0 > > > > > &>(a);
+            }
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_assign2.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_assign2.hpp
new file mode 100644
index 00000000000..2265602b7a2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_assign2.hpp
@@ -0,0 +1,56 @@
+//Copyright (c) 2008-2017 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_61CDD11E9D9C167272E61DF0844F4A77
+#define BOOST_QVM_61CDD11E9D9C167272E61DF0844F4A77
+
+//This file was generated by a program. Do not edit manually.
+
+#include <boost/qvm/enable_if.hpp>
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/vec_traits.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==2 && vec_traits<B>::dim==2,
+            A &>::type
+        assign( A & a, B const & b )
+            {
+            vec_traits<A>::template write_element<0>(a)=vec_traits<B>::template read_element<0>(b);
+            vec_traits<A>::template write_element<1>(a)=vec_traits<B>::template read_element<1>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::assign;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct assign_vv_defined;
+
+            template <>
+            struct
+            assign_vv_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_assign3.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_assign3.hpp
new file mode 100644
index 00000000000..17da3ad9af1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_assign3.hpp
@@ -0,0 +1,57 @@
+//Copyright (c) 2008-2017 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_2D7E8392C53CBC9121E33749ECF4D5
+#define BOOST_QVM_2D7E8392C53CBC9121E33749ECF4D5
+
+//This file was generated by a program. Do not edit manually.
+
+#include <boost/qvm/enable_if.hpp>
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/vec_traits.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
+            A &>::type
+        assign( A & a, B const & b )
+            {
+            vec_traits<A>::template write_element<0>(a)=vec_traits<B>::template read_element<0>(b);
+            vec_traits<A>::template write_element<1>(a)=vec_traits<B>::template read_element<1>(b);
+            vec_traits<A>::template write_element<2>(a)=vec_traits<B>::template read_element<2>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::assign;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct assign_vv_defined;
+
+            template <>
+            struct
+            assign_vv_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_assign4.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_assign4.hpp
new file mode 100644
index 00000000000..7fa7a566ef9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_assign4.hpp
@@ -0,0 +1,58 @@
+//Copyright (c) 2008-2017 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_D49FD4A4597E35CF3222F4CCCFD3902D
+#define BOOST_QVM_D49FD4A4597E35CF3222F4CCCFD3902D
+
+//This file was generated by a program. Do not edit manually.
+
+#include <boost/qvm/enable_if.hpp>
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/vec_traits.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==4 && vec_traits<B>::dim==4,
+            A &>::type
+        assign( A & a, B const & b )
+            {
+            vec_traits<A>::template write_element<0>(a)=vec_traits<B>::template read_element<0>(b);
+            vec_traits<A>::template write_element<1>(a)=vec_traits<B>::template read_element<1>(b);
+            vec_traits<A>::template write_element<2>(a)=vec_traits<B>::template read_element<2>(b);
+            vec_traits<A>::template write_element<3>(a)=vec_traits<B>::template read_element<3>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::assign;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct assign_vv_defined;
+
+            template <>
+            struct
+            assign_vv_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_mat_operations2.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_mat_operations2.hpp
new file mode 100644
index 00000000000..8b52bd25e40
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_mat_operations2.hpp
@@ -0,0 +1,114 @@
+//Copyright (c) 2008-2017 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_48D38F75E6D91D2AE5C0F72B78818744
+#define BOOST_QVM_48D38F75E6D91D2AE5C0F72B78818744
+
+//This file was generated by a program. Do not edit manually.
+
+#include <boost/qvm/deduce_vec.hpp>
+#include <boost/qvm/enable_if.hpp>
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/mat_traits.hpp>
+#include <boost/qvm/vec_traits.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==2 && mat_traits<A>::cols==2 &&
+            vec_traits<B>::dim==2,
+            deduce_vec2<A,B,2> >::type
+        operator*( A const & a, B const & b )
+            {
+            typedef typename mat_traits<A>::scalar_type Ta;
+            typedef typename vec_traits<B>::scalar_type Tb;
+            Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
+            Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
+            Ta const a10 = mat_traits<A>::template read_element<1,0>(a);
+            Ta const a11 = mat_traits<A>::template read_element<1,1>(a);
+            Tb const b0 = vec_traits<B>::template read_element<0>(b);
+            Tb const b1 = vec_traits<B>::template read_element<1>(b);
+            typedef typename deduce_vec2<A,B,2>::type R;
+            BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==2);
+            R r;
+            vec_traits<R>::template write_element<0>(r)=a00*b0+a01*b1;
+            vec_traits<R>::template write_element<1>(r)=a10*b0+a11*b1;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_mv_defined;
+
+            template <>
+            struct
+            mul_mv_defined<2,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<B>::rows==2 && mat_traits<B>::cols==2 &&
+            vec_traits<A>::dim==2,
+            deduce_vec2<A,B,2> >::type
+        operator*( A const & a, B const & b )
+            {
+            typedef typename vec_traits<A>::scalar_type Ta;
+            typedef typename mat_traits<B>::scalar_type Tb;
+            Ta const a0 = vec_traits<A>::template read_element<0>(a);
+            Ta const a1 = vec_traits<A>::template read_element<1>(a);
+            Tb const b00 = mat_traits<B>::template read_element<0,0>(b);
+            Tb const b01 = mat_traits<B>::template read_element<0,1>(b);
+            Tb const b10 = mat_traits<B>::template read_element<1,0>(b);
+            Tb const b11 = mat_traits<B>::template read_element<1,1>(b);
+            typedef typename deduce_vec2<A,B,2>::type R;
+            BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==2);
+            R r;
+            vec_traits<R>::template write_element<0>(r)=a0*b00+a1*b10;
+            vec_traits<R>::template write_element<1>(r)=a0*b01+a1*b11;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_vm_defined;
+
+            template <>
+            struct
+            mul_vm_defined<2,2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_mat_operations3.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_mat_operations3.hpp
new file mode 100644
index 00000000000..9e0da9045e3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_mat_operations3.hpp
@@ -0,0 +1,128 @@
+//Copyright (c) 2008-2017 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_E5F500D4618DBE7B51573B33821F
+#define BOOST_QVM_E5F500D4618DBE7B51573B33821F
+
+//This file was generated by a program. Do not edit manually.
+
+#include <boost/qvm/deduce_vec.hpp>
+#include <boost/qvm/enable_if.hpp>
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/mat_traits.hpp>
+#include <boost/qvm/vec_traits.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==3 && mat_traits<A>::cols==3 &&
+            vec_traits<B>::dim==3,
+            deduce_vec2<A,B,3> >::type
+        operator*( A const & a, B const & b )
+            {
+            typedef typename mat_traits<A>::scalar_type Ta;
+            typedef typename vec_traits<B>::scalar_type Tb;
+            Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
+            Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
+            Ta const a02 = mat_traits<A>::template read_element<0,2>(a);
+            Ta const a10 = mat_traits<A>::template read_element<1,0>(a);
+            Ta const a11 = mat_traits<A>::template read_element<1,1>(a);
+            Ta const a12 = mat_traits<A>::template read_element<1,2>(a);
+            Ta const a20 = mat_traits<A>::template read_element<2,0>(a);
+            Ta const a21 = mat_traits<A>::template read_element<2,1>(a);
+            Ta const a22 = mat_traits<A>::template read_element<2,2>(a);
+            Tb const b0 = vec_traits<B>::template read_element<0>(b);
+            Tb const b1 = vec_traits<B>::template read_element<1>(b);
+            Tb const b2 = vec_traits<B>::template read_element<2>(b);
+            typedef typename deduce_vec2<A,B,3>::type R;
+            BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==3);
+            R r;
+            vec_traits<R>::template write_element<0>(r)=a00*b0+a01*b1+a02*b2;
+            vec_traits<R>::template write_element<1>(r)=a10*b0+a11*b1+a12*b2;
+            vec_traits<R>::template write_element<2>(r)=a20*b0+a21*b1+a22*b2;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_mv_defined;
+
+            template <>
+            struct
+            mul_mv_defined<3,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<B>::rows==3 && mat_traits<B>::cols==3 &&
+            vec_traits<A>::dim==3,
+            deduce_vec2<A,B,3> >::type
+        operator*( A const & a, B const & b )
+            {
+            typedef typename vec_traits<A>::scalar_type Ta;
+            typedef typename mat_traits<B>::scalar_type Tb;
+            Ta const a0 = vec_traits<A>::template read_element<0>(a);
+            Ta const a1 = vec_traits<A>::template read_element<1>(a);
+            Ta const a2 = vec_traits<A>::template read_element<2>(a);
+            Tb const b00 = mat_traits<B>::template read_element<0,0>(b);
+            Tb const b01 = mat_traits<B>::template read_element<0,1>(b);
+            Tb const b02 = mat_traits<B>::template read_element<0,2>(b);
+            Tb const b10 = mat_traits<B>::template read_element<1,0>(b);
+            Tb const b11 = mat_traits<B>::template read_element<1,1>(b);
+            Tb const b12 = mat_traits<B>::template read_element<1,2>(b);
+            Tb const b20 = mat_traits<B>::template read_element<2,0>(b);
+            Tb const b21 = mat_traits<B>::template read_element<2,1>(b);
+            Tb const b22 = mat_traits<B>::template read_element<2,2>(b);
+            typedef typename deduce_vec2<A,B,3>::type R;
+            BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==3);
+            R r;
+            vec_traits<R>::template write_element<0>(r)=a0*b00+a1*b10+a2*b20;
+            vec_traits<R>::template write_element<1>(r)=a0*b01+a1*b11+a2*b21;
+            vec_traits<R>::template write_element<2>(r)=a0*b02+a1*b12+a2*b22;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_vm_defined;
+
+            template <>
+            struct
+            mul_vm_defined<3,3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_mat_operations4.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_mat_operations4.hpp
new file mode 100644
index 00000000000..ab7db98e31c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_mat_operations4.hpp
@@ -0,0 +1,146 @@
+//Copyright (c) 2008-2017 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_187092DA6454CEB1853E6915F8466A4
+#define BOOST_QVM_187092DA6454CEB1853E6915F8466A4
+
+//This file was generated by a program. Do not edit manually.
+
+#include <boost/qvm/deduce_vec.hpp>
+#include <boost/qvm/enable_if.hpp>
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/mat_traits.hpp>
+#include <boost/qvm/vec_traits.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<A>::cols==4 &&
+            vec_traits<B>::dim==4,
+            deduce_vec2<A,B,4> >::type
+        operator*( A const & a, B const & b )
+            {
+            typedef typename mat_traits<A>::scalar_type Ta;
+            typedef typename vec_traits<B>::scalar_type Tb;
+            Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
+            Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
+            Ta const a02 = mat_traits<A>::template read_element<0,2>(a);
+            Ta const a03 = mat_traits<A>::template read_element<0,3>(a);
+            Ta const a10 = mat_traits<A>::template read_element<1,0>(a);
+            Ta const a11 = mat_traits<A>::template read_element<1,1>(a);
+            Ta const a12 = mat_traits<A>::template read_element<1,2>(a);
+            Ta const a13 = mat_traits<A>::template read_element<1,3>(a);
+            Ta const a20 = mat_traits<A>::template read_element<2,0>(a);
+            Ta const a21 = mat_traits<A>::template read_element<2,1>(a);
+            Ta const a22 = mat_traits<A>::template read_element<2,2>(a);
+            Ta const a23 = mat_traits<A>::template read_element<2,3>(a);
+            Ta const a30 = mat_traits<A>::template read_element<3,0>(a);
+            Ta const a31 = mat_traits<A>::template read_element<3,1>(a);
+            Ta const a32 = mat_traits<A>::template read_element<3,2>(a);
+            Ta const a33 = mat_traits<A>::template read_element<3,3>(a);
+            Tb const b0 = vec_traits<B>::template read_element<0>(b);
+            Tb const b1 = vec_traits<B>::template read_element<1>(b);
+            Tb const b2 = vec_traits<B>::template read_element<2>(b);
+            Tb const b3 = vec_traits<B>::template read_element<3>(b);
+            typedef typename deduce_vec2<A,B,4>::type R;
+            BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==4);
+            R r;
+            vec_traits<R>::template write_element<0>(r)=a00*b0+a01*b1+a02*b2+a03*b3;
+            vec_traits<R>::template write_element<1>(r)=a10*b0+a11*b1+a12*b2+a13*b3;
+            vec_traits<R>::template write_element<2>(r)=a20*b0+a21*b1+a22*b2+a23*b3;
+            vec_traits<R>::template write_element<3>(r)=a30*b0+a31*b1+a32*b2+a33*b3;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_mv_defined;
+
+            template <>
+            struct
+            mul_mv_defined<4,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<B>::rows==4 && mat_traits<B>::cols==4 &&
+            vec_traits<A>::dim==4,
+            deduce_vec2<A,B,4> >::type
+        operator*( A const & a, B const & b )
+            {
+            typedef typename vec_traits<A>::scalar_type Ta;
+            typedef typename mat_traits<B>::scalar_type Tb;
+            Ta const a0 = vec_traits<A>::template read_element<0>(a);
+            Ta const a1 = vec_traits<A>::template read_element<1>(a);
+            Ta const a2 = vec_traits<A>::template read_element<2>(a);
+            Ta const a3 = vec_traits<A>::template read_element<3>(a);
+            Tb const b00 = mat_traits<B>::template read_element<0,0>(b);
+            Tb const b01 = mat_traits<B>::template read_element<0,1>(b);
+            Tb const b02 = mat_traits<B>::template read_element<0,2>(b);
+            Tb const b03 = mat_traits<B>::template read_element<0,3>(b);
+            Tb const b10 = mat_traits<B>::template read_element<1,0>(b);
+            Tb const b11 = mat_traits<B>::template read_element<1,1>(b);
+            Tb const b12 = mat_traits<B>::template read_element<1,2>(b);
+            Tb const b13 = mat_traits<B>::template read_element<1,3>(b);
+            Tb const b20 = mat_traits<B>::template read_element<2,0>(b);
+            Tb const b21 = mat_traits<B>::template read_element<2,1>(b);
+            Tb const b22 = mat_traits<B>::template read_element<2,2>(b);
+            Tb const b23 = mat_traits<B>::template read_element<2,3>(b);
+            Tb const b30 = mat_traits<B>::template read_element<3,0>(b);
+            Tb const b31 = mat_traits<B>::template read_element<3,1>(b);
+            Tb const b32 = mat_traits<B>::template read_element<3,2>(b);
+            Tb const b33 = mat_traits<B>::template read_element<3,3>(b);
+            typedef typename deduce_vec2<A,B,4>::type R;
+            BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==4);
+            R r;
+            vec_traits<R>::template write_element<0>(r)=a0*b00+a1*b10+a2*b20+a3*b30;
+            vec_traits<R>::template write_element<1>(r)=a0*b01+a1*b11+a2*b21+a3*b31;
+            vec_traits<R>::template write_element<2>(r)=a0*b02+a1*b12+a2*b22+a3*b32;
+            vec_traits<R>::template write_element<3>(r)=a0*b03+a1*b13+a2*b23+a3*b33;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct mul_vm_defined;
+
+            template <>
+            struct
+            mul_vm_defined<4,4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_operations2.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_operations2.hpp
new file mode 100644
index 00000000000..08faeddb383
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_operations2.hpp
@@ -0,0 +1,632 @@
+//Copyright (c) 2008-2017 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_F622919DE18B1FDAB0CA992B9729D49
+#define BOOST_QVM_F622919DE18B1FDAB0CA992B9729D49
+
+//This file was generated by a program. Do not edit manually.
+
+#include <boost/qvm/deduce_scalar.hpp>
+#include <boost/qvm/deduce_vec.hpp>
+#include <boost/qvm/error.hpp>
+#include <boost/qvm/gen/vec_assign2.hpp>
+#include <boost/qvm/math.hpp>
+#include <boost/qvm/static_assert.hpp>
+#include <boost/qvm/throw_exception.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==2 && vec_traits<B>::dim==2,
+            deduce_vec2<A,B,2> >::type
+        operator+( A const & a, B const & b )
+            {
+            typedef typename deduce_vec2<A,B,2>::type R;
+            BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==2);
+            R r;
+            vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)+vec_traits<B>::template read_element<0>(b);
+            vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)+vec_traits<B>::template read_element<1>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct plus_vv_defined;
+
+            template <>
+            struct
+            plus_vv_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==2 && vec_traits<B>::dim==2,
+            deduce_vec2<A,B,2> >::type
+        operator-( A const & a, B const & b )
+            {
+            typedef typename deduce_vec2<A,B,2>::type R;
+            BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==2);
+            R r;
+            vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)-vec_traits<B>::template read_element<0>(b);
+            vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)-vec_traits<B>::template read_element<1>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct minus_vv_defined;
+
+            template <>
+            struct
+            minus_vv_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==2 && vec_traits<B>::dim==2,
+            A &>::type
+        operator+=( A & a, B const & b )
+            {
+            vec_traits<A>::template write_element<0>(a)+=vec_traits<B>::template read_element<0>(b);
+            vec_traits<A>::template write_element<1>(a)+=vec_traits<B>::template read_element<1>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct plus_eq_vv_defined;
+
+            template <>
+            struct
+            plus_eq_vv_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==2 && vec_traits<B>::dim==2,
+            A &>::type
+        operator-=( A & a, B const & b )
+            {
+            vec_traits<A>::template write_element<0>(a)-=vec_traits<B>::template read_element<0>(b);
+            vec_traits<A>::template write_element<1>(a)-=vec_traits<B>::template read_element<1>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct minus_eq_vv_defined;
+
+            template <>
+            struct
+            minus_eq_vv_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==2 && is_scalar<B>::value,
+            deduce_vec<A> >::type
+        operator*( A const & a, B b )
+            {
+            typedef typename deduce_vec<A>::type R;
+            R r;
+            vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)*b;
+            vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)*b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct mul_vs_defined;
+
+            template <>
+            struct
+            mul_vs_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_scalar<A>::value && vec_traits<B>::dim==2,
+            deduce_vec<B> >::type
+        operator*( A a, B const & b )
+            {
+            typedef typename deduce_vec<B>::type R;
+            R r;
+            vec_traits<R>::template write_element<0>(r)=a*vec_traits<B>::template read_element<0>(b);
+            vec_traits<R>::template write_element<1>(r)=a*vec_traits<B>::template read_element<1>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct mul_sv_defined;
+
+            template <>
+            struct
+            mul_sv_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class  B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==2 && is_scalar<B>::value,
+            A &>::type
+        operator*=( A & a, B b )
+            {
+            vec_traits<A>::template write_element<0>(a)*=b;
+            vec_traits<A>::template write_element<1>(a)*=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct mul_eq_vs_defined;
+
+            template <>
+            struct
+            mul_eq_vs_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==2 && is_scalar<B>::value,
+            deduce_vec<A> >::type
+        operator/( A const & a, B b )
+            {
+            typedef typename deduce_vec<A>::type R;
+            R r;
+            vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)/b;
+            vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)/b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct div_vs_defined;
+
+            template <>
+            struct
+            div_vs_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class  B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==2 && is_scalar<B>::value,
+            A &>::type
+        operator/=( A & a, B b )
+            {
+            vec_traits<A>::template write_element<0>(a)/=b;
+            vec_traits<A>::template write_element<1>(a)/=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct div_eq_vs_defined;
+
+            template <>
+            struct
+            div_eq_vs_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class R,class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_vec<A>::value &&
+            vec_traits<R>::dim==2 && vec_traits<A>::dim==2,
+            R>::type
+        convert_to( A const & a )
+            {
+            R r;
+            vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a);
+            vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::convert_to;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct convert_to_v_defined;
+
+            template <>
+            struct
+            convert_to_v_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==2 && vec_traits<B>::dim==2,
+        bool>::type
+        operator==( A const & a, B const & b )
+            {
+            return
+                vec_traits<A>::template read_element<0>(a)==vec_traits<B>::template read_element<0>(b) &&
+                vec_traits<A>::template read_element<1>(a)==vec_traits<B>::template read_element<1>(b);
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator==;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct eq_vv_defined;
+
+            template <>
+            struct
+            eq_vv_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==2 && vec_traits<B>::dim==2,
+        bool>::type
+        operator!=( A const & a, B const & b )
+            {
+            return
+                !(vec_traits<A>::template read_element<0>(a)==vec_traits<B>::template read_element<0>(b)) ||
+                !(vec_traits<A>::template read_element<1>(a)==vec_traits<B>::template read_element<1>(b));
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator!=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct neq_vv_defined;
+
+            template <>
+            struct
+            neq_vv_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==2,
+            deduce_vec<A> >::type
+        operator-( A const & a )
+            {
+            typedef typename deduce_vec<A>::type R;
+            R r;
+            vec_traits<R>::template write_element<0>(r)=-vec_traits<A>::template read_element<0>(a);
+            vec_traits<R>::template write_element<1>(r)=-vec_traits<A>::template read_element<1>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct minus_v_defined;
+
+            template <>
+            struct
+            minus_v_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_vec<A>::value && vec_traits<A>::dim==2,
+            typename vec_traits<A>::scalar_type>::type
+        mag( A const & a )
+            {
+            typedef typename vec_traits<A>::scalar_type T;
+            T const a0=vec_traits<A>::template read_element<0>(a);
+            T const a1=vec_traits<A>::template read_element<1>(a);
+            T const m2=a0*a0+a1*a1;
+            T const mag=sqrt<T>(m2);
+            return mag;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::mag;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct mag_v_defined;
+
+            template <>
+            struct
+            mag_v_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_vec<A>::value && vec_traits<A>::dim==2,
+            typename vec_traits<A>::scalar_type>::type
+        mag_sqr( A const & a )
+            {
+            typedef typename vec_traits<A>::scalar_type T;
+            T const a0=vec_traits<A>::template read_element<0>(a);
+            T const a1=vec_traits<A>::template read_element<1>(a);
+            T const m2=a0*a0+a1*a1;
+            return m2;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::mag_sqr;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct mag_sqr_v_defined;
+
+            template <>
+            struct
+            mag_sqr_v_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==2,
+            deduce_vec<A> >::type
+        normalized( A const & a )
+            {
+            typedef typename vec_traits<A>::scalar_type T;
+            T const a0=vec_traits<A>::template read_element<0>(a);
+            T const a1=vec_traits<A>::template read_element<1>(a);
+            T const m2=a0*a0+a1*a1;
+            if( m2==scalar_traits<typename vec_traits<A>::scalar_type>::value(0) )
+                BOOST_QVM_THROW_EXCEPTION(zero_magnitude_error());
+            T const rm=scalar_traits<T>::value(1)/sqrt<T>(m2);
+            typedef typename deduce_vec<A>::type R;
+            R r;
+            vec_traits<R>::template write_element<0>(r)=a0*rm;
+            vec_traits<R>::template write_element<1>(r)=a1*rm;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::normalized;
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==2,
+            void>::type
+        normalize( A & a )
+            {
+            typedef typename vec_traits<A>::scalar_type T;
+            T const a0=vec_traits<A>::template read_element<0>(a);
+            T const a1=vec_traits<A>::template read_element<1>(a);
+            T const m2=a0*a0+a1*a1;
+            if( m2==scalar_traits<typename vec_traits<A>::scalar_type>::value(0) )
+                BOOST_QVM_THROW_EXCEPTION(zero_magnitude_error());
+            T const rm=scalar_traits<T>::value(1)/sqrt<T>(m2);
+            vec_traits<A>::template write_element<0>(a)*=rm;
+            vec_traits<A>::template write_element<1>(a)*=rm;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::normalize;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct normalize_v_defined;
+
+            template <>
+            struct
+            normalize_v_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==2 && vec_traits<B>::dim==2,
+            deduce_scalar<typename vec_traits<A>::scalar_type,typename vec_traits<B>::scalar_type> >::type
+        dot( A const & a, B const & b )
+            {
+            typedef typename vec_traits<A>::scalar_type Ta;
+            typedef typename vec_traits<B>::scalar_type Tb;
+            typedef typename deduce_scalar<Ta,Tb>::type Tr;
+            Ta const a0=vec_traits<A>::template read_element<0>(a);
+            Ta const a1=vec_traits<A>::template read_element<1>(a);
+            Tb const b0=vec_traits<B>::template read_element<0>(b);
+            Tb const b1=vec_traits<B>::template read_element<1>(b);
+            Tr const dot=a0*b0+a1*b1;
+            return dot;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::dot;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct dot_vv_defined;
+
+            template <>
+            struct
+            dot_vv_defined<2>
+                {
+                static bool const value=true;
+                };
+            }
+
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_operations3.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_operations3.hpp
new file mode 100644
index 00000000000..c985721d65a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_operations3.hpp
@@ -0,0 +1,653 @@
+//Copyright (c) 2008-2017 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_2C807EC599D5E980B2EAC9CC53BF67D6
+#define BOOST_QVM_2C807EC599D5E980B2EAC9CC53BF67D6
+
+//This file was generated by a program. Do not edit manually.
+
+#include <boost/qvm/deduce_scalar.hpp>
+#include <boost/qvm/deduce_vec.hpp>
+#include <boost/qvm/error.hpp>
+#include <boost/qvm/gen/vec_assign3.hpp>
+#include <boost/qvm/math.hpp>
+#include <boost/qvm/static_assert.hpp>
+#include <boost/qvm/throw_exception.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
+            deduce_vec2<A,B,3> >::type
+        operator+( A const & a, B const & b )
+            {
+            typedef typename deduce_vec2<A,B,3>::type R;
+            BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==3);
+            R r;
+            vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)+vec_traits<B>::template read_element<0>(b);
+            vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)+vec_traits<B>::template read_element<1>(b);
+            vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a)+vec_traits<B>::template read_element<2>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct plus_vv_defined;
+
+            template <>
+            struct
+            plus_vv_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
+            deduce_vec2<A,B,3> >::type
+        operator-( A const & a, B const & b )
+            {
+            typedef typename deduce_vec2<A,B,3>::type R;
+            BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==3);
+            R r;
+            vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)-vec_traits<B>::template read_element<0>(b);
+            vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)-vec_traits<B>::template read_element<1>(b);
+            vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a)-vec_traits<B>::template read_element<2>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct minus_vv_defined;
+
+            template <>
+            struct
+            minus_vv_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
+            A &>::type
+        operator+=( A & a, B const & b )
+            {
+            vec_traits<A>::template write_element<0>(a)+=vec_traits<B>::template read_element<0>(b);
+            vec_traits<A>::template write_element<1>(a)+=vec_traits<B>::template read_element<1>(b);
+            vec_traits<A>::template write_element<2>(a)+=vec_traits<B>::template read_element<2>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct plus_eq_vv_defined;
+
+            template <>
+            struct
+            plus_eq_vv_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
+            A &>::type
+        operator-=( A & a, B const & b )
+            {
+            vec_traits<A>::template write_element<0>(a)-=vec_traits<B>::template read_element<0>(b);
+            vec_traits<A>::template write_element<1>(a)-=vec_traits<B>::template read_element<1>(b);
+            vec_traits<A>::template write_element<2>(a)-=vec_traits<B>::template read_element<2>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct minus_eq_vv_defined;
+
+            template <>
+            struct
+            minus_eq_vv_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==3 && is_scalar<B>::value,
+            deduce_vec<A> >::type
+        operator*( A const & a, B b )
+            {
+            typedef typename deduce_vec<A>::type R;
+            R r;
+            vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)*b;
+            vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)*b;
+            vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a)*b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct mul_vs_defined;
+
+            template <>
+            struct
+            mul_vs_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_scalar<A>::value && vec_traits<B>::dim==3,
+            deduce_vec<B> >::type
+        operator*( A a, B const & b )
+            {
+            typedef typename deduce_vec<B>::type R;
+            R r;
+            vec_traits<R>::template write_element<0>(r)=a*vec_traits<B>::template read_element<0>(b);
+            vec_traits<R>::template write_element<1>(r)=a*vec_traits<B>::template read_element<1>(b);
+            vec_traits<R>::template write_element<2>(r)=a*vec_traits<B>::template read_element<2>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct mul_sv_defined;
+
+            template <>
+            struct
+            mul_sv_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class  B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==3 && is_scalar<B>::value,
+            A &>::type
+        operator*=( A & a, B b )
+            {
+            vec_traits<A>::template write_element<0>(a)*=b;
+            vec_traits<A>::template write_element<1>(a)*=b;
+            vec_traits<A>::template write_element<2>(a)*=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct mul_eq_vs_defined;
+
+            template <>
+            struct
+            mul_eq_vs_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==3 && is_scalar<B>::value,
+            deduce_vec<A> >::type
+        operator/( A const & a, B b )
+            {
+            typedef typename deduce_vec<A>::type R;
+            R r;
+            vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)/b;
+            vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)/b;
+            vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a)/b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct div_vs_defined;
+
+            template <>
+            struct
+            div_vs_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class  B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==3 && is_scalar<B>::value,
+            A &>::type
+        operator/=( A & a, B b )
+            {
+            vec_traits<A>::template write_element<0>(a)/=b;
+            vec_traits<A>::template write_element<1>(a)/=b;
+            vec_traits<A>::template write_element<2>(a)/=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct div_eq_vs_defined;
+
+            template <>
+            struct
+            div_eq_vs_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class R,class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_vec<A>::value &&
+            vec_traits<R>::dim==3 && vec_traits<A>::dim==3,
+            R>::type
+        convert_to( A const & a )
+            {
+            R r;
+            vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a);
+            vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a);
+            vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::convert_to;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct convert_to_v_defined;
+
+            template <>
+            struct
+            convert_to_v_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
+        bool>::type
+        operator==( A const & a, B const & b )
+            {
+            return
+                vec_traits<A>::template read_element<0>(a)==vec_traits<B>::template read_element<0>(b) &&
+                vec_traits<A>::template read_element<1>(a)==vec_traits<B>::template read_element<1>(b) &&
+                vec_traits<A>::template read_element<2>(a)==vec_traits<B>::template read_element<2>(b);
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator==;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct eq_vv_defined;
+
+            template <>
+            struct
+            eq_vv_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
+        bool>::type
+        operator!=( A const & a, B const & b )
+            {
+            return
+                !(vec_traits<A>::template read_element<0>(a)==vec_traits<B>::template read_element<0>(b)) ||
+                !(vec_traits<A>::template read_element<1>(a)==vec_traits<B>::template read_element<1>(b)) ||
+                !(vec_traits<A>::template read_element<2>(a)==vec_traits<B>::template read_element<2>(b));
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator!=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct neq_vv_defined;
+
+            template <>
+            struct
+            neq_vv_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==3,
+            deduce_vec<A> >::type
+        operator-( A const & a )
+            {
+            typedef typename deduce_vec<A>::type R;
+            R r;
+            vec_traits<R>::template write_element<0>(r)=-vec_traits<A>::template read_element<0>(a);
+            vec_traits<R>::template write_element<1>(r)=-vec_traits<A>::template read_element<1>(a);
+            vec_traits<R>::template write_element<2>(r)=-vec_traits<A>::template read_element<2>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct minus_v_defined;
+
+            template <>
+            struct
+            minus_v_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_vec<A>::value && vec_traits<A>::dim==3,
+            typename vec_traits<A>::scalar_type>::type
+        mag( A const & a )
+            {
+            typedef typename vec_traits<A>::scalar_type T;
+            T const a0=vec_traits<A>::template read_element<0>(a);
+            T const a1=vec_traits<A>::template read_element<1>(a);
+            T const a2=vec_traits<A>::template read_element<2>(a);
+            T const m2=a0*a0+a1*a1+a2*a2;
+            T const mag=sqrt<T>(m2);
+            return mag;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::mag;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct mag_v_defined;
+
+            template <>
+            struct
+            mag_v_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_vec<A>::value && vec_traits<A>::dim==3,
+            typename vec_traits<A>::scalar_type>::type
+        mag_sqr( A const & a )
+            {
+            typedef typename vec_traits<A>::scalar_type T;
+            T const a0=vec_traits<A>::template read_element<0>(a);
+            T const a1=vec_traits<A>::template read_element<1>(a);
+            T const a2=vec_traits<A>::template read_element<2>(a);
+            T const m2=a0*a0+a1*a1+a2*a2;
+            return m2;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::mag_sqr;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct mag_sqr_v_defined;
+
+            template <>
+            struct
+            mag_sqr_v_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==3,
+            deduce_vec<A> >::type
+        normalized( A const & a )
+            {
+            typedef typename vec_traits<A>::scalar_type T;
+            T const a0=vec_traits<A>::template read_element<0>(a);
+            T const a1=vec_traits<A>::template read_element<1>(a);
+            T const a2=vec_traits<A>::template read_element<2>(a);
+            T const m2=a0*a0+a1*a1+a2*a2;
+            if( m2==scalar_traits<typename vec_traits<A>::scalar_type>::value(0) )
+                BOOST_QVM_THROW_EXCEPTION(zero_magnitude_error());
+            T const rm=scalar_traits<T>::value(1)/sqrt<T>(m2);
+            typedef typename deduce_vec<A>::type R;
+            R r;
+            vec_traits<R>::template write_element<0>(r)=a0*rm;
+            vec_traits<R>::template write_element<1>(r)=a1*rm;
+            vec_traits<R>::template write_element<2>(r)=a2*rm;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::normalized;
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==3,
+            void>::type
+        normalize( A & a )
+            {
+            typedef typename vec_traits<A>::scalar_type T;
+            T const a0=vec_traits<A>::template read_element<0>(a);
+            T const a1=vec_traits<A>::template read_element<1>(a);
+            T const a2=vec_traits<A>::template read_element<2>(a);
+            T const m2=a0*a0+a1*a1+a2*a2;
+            if( m2==scalar_traits<typename vec_traits<A>::scalar_type>::value(0) )
+                BOOST_QVM_THROW_EXCEPTION(zero_magnitude_error());
+            T const rm=scalar_traits<T>::value(1)/sqrt<T>(m2);
+            vec_traits<A>::template write_element<0>(a)*=rm;
+            vec_traits<A>::template write_element<1>(a)*=rm;
+            vec_traits<A>::template write_element<2>(a)*=rm;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::normalize;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct normalize_v_defined;
+
+            template <>
+            struct
+            normalize_v_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
+            deduce_scalar<typename vec_traits<A>::scalar_type,typename vec_traits<B>::scalar_type> >::type
+        dot( A const & a, B const & b )
+            {
+            typedef typename vec_traits<A>::scalar_type Ta;
+            typedef typename vec_traits<B>::scalar_type Tb;
+            typedef typename deduce_scalar<Ta,Tb>::type Tr;
+            Ta const a0=vec_traits<A>::template read_element<0>(a);
+            Ta const a1=vec_traits<A>::template read_element<1>(a);
+            Ta const a2=vec_traits<A>::template read_element<2>(a);
+            Tb const b0=vec_traits<B>::template read_element<0>(b);
+            Tb const b1=vec_traits<B>::template read_element<1>(b);
+            Tb const b2=vec_traits<B>::template read_element<2>(b);
+            Tr const dot=a0*b0+a1*b1+a2*b2;
+            return dot;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::dot;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct dot_vv_defined;
+
+            template <>
+            struct
+            dot_vv_defined<3>
+                {
+                static bool const value=true;
+                };
+            }
+
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_operations4.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_operations4.hpp
new file mode 100644
index 00000000000..e3edfa27c3f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/gen/vec_operations4.hpp
@@ -0,0 +1,674 @@
+//Copyright (c) 2008-2017 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_BF14D67E2DDC8E6683EF574961FF698F
+#define BOOST_QVM_BF14D67E2DDC8E6683EF574961FF698F
+
+//This file was generated by a program. Do not edit manually.
+
+#include <boost/qvm/deduce_scalar.hpp>
+#include <boost/qvm/deduce_vec.hpp>
+#include <boost/qvm/error.hpp>
+#include <boost/qvm/gen/vec_assign4.hpp>
+#include <boost/qvm/math.hpp>
+#include <boost/qvm/static_assert.hpp>
+#include <boost/qvm/throw_exception.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==4 && vec_traits<B>::dim==4,
+            deduce_vec2<A,B,4> >::type
+        operator+( A const & a, B const & b )
+            {
+            typedef typename deduce_vec2<A,B,4>::type R;
+            BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==4);
+            R r;
+            vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)+vec_traits<B>::template read_element<0>(b);
+            vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)+vec_traits<B>::template read_element<1>(b);
+            vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a)+vec_traits<B>::template read_element<2>(b);
+            vec_traits<R>::template write_element<3>(r)=vec_traits<A>::template read_element<3>(a)+vec_traits<B>::template read_element<3>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct plus_vv_defined;
+
+            template <>
+            struct
+            plus_vv_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==4 && vec_traits<B>::dim==4,
+            deduce_vec2<A,B,4> >::type
+        operator-( A const & a, B const & b )
+            {
+            typedef typename deduce_vec2<A,B,4>::type R;
+            BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==4);
+            R r;
+            vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)-vec_traits<B>::template read_element<0>(b);
+            vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)-vec_traits<B>::template read_element<1>(b);
+            vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a)-vec_traits<B>::template read_element<2>(b);
+            vec_traits<R>::template write_element<3>(r)=vec_traits<A>::template read_element<3>(a)-vec_traits<B>::template read_element<3>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct minus_vv_defined;
+
+            template <>
+            struct
+            minus_vv_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==4 && vec_traits<B>::dim==4,
+            A &>::type
+        operator+=( A & a, B const & b )
+            {
+            vec_traits<A>::template write_element<0>(a)+=vec_traits<B>::template read_element<0>(b);
+            vec_traits<A>::template write_element<1>(a)+=vec_traits<B>::template read_element<1>(b);
+            vec_traits<A>::template write_element<2>(a)+=vec_traits<B>::template read_element<2>(b);
+            vec_traits<A>::template write_element<3>(a)+=vec_traits<B>::template read_element<3>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator+=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct plus_eq_vv_defined;
+
+            template <>
+            struct
+            plus_eq_vv_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==4 && vec_traits<B>::dim==4,
+            A &>::type
+        operator-=( A & a, B const & b )
+            {
+            vec_traits<A>::template write_element<0>(a)-=vec_traits<B>::template read_element<0>(b);
+            vec_traits<A>::template write_element<1>(a)-=vec_traits<B>::template read_element<1>(b);
+            vec_traits<A>::template write_element<2>(a)-=vec_traits<B>::template read_element<2>(b);
+            vec_traits<A>::template write_element<3>(a)-=vec_traits<B>::template read_element<3>(b);
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct minus_eq_vv_defined;
+
+            template <>
+            struct
+            minus_eq_vv_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==4 && is_scalar<B>::value,
+            deduce_vec<A> >::type
+        operator*( A const & a, B b )
+            {
+            typedef typename deduce_vec<A>::type R;
+            R r;
+            vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)*b;
+            vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)*b;
+            vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a)*b;
+            vec_traits<R>::template write_element<3>(r)=vec_traits<A>::template read_element<3>(a)*b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct mul_vs_defined;
+
+            template <>
+            struct
+            mul_vs_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_scalar<A>::value && vec_traits<B>::dim==4,
+            deduce_vec<B> >::type
+        operator*( A a, B const & b )
+            {
+            typedef typename deduce_vec<B>::type R;
+            R r;
+            vec_traits<R>::template write_element<0>(r)=a*vec_traits<B>::template read_element<0>(b);
+            vec_traits<R>::template write_element<1>(r)=a*vec_traits<B>::template read_element<1>(b);
+            vec_traits<R>::template write_element<2>(r)=a*vec_traits<B>::template read_element<2>(b);
+            vec_traits<R>::template write_element<3>(r)=a*vec_traits<B>::template read_element<3>(b);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct mul_sv_defined;
+
+            template <>
+            struct
+            mul_sv_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class  B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==4 && is_scalar<B>::value,
+            A &>::type
+        operator*=( A & a, B b )
+            {
+            vec_traits<A>::template write_element<0>(a)*=b;
+            vec_traits<A>::template write_element<1>(a)*=b;
+            vec_traits<A>::template write_element<2>(a)*=b;
+            vec_traits<A>::template write_element<3>(a)*=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct mul_eq_vs_defined;
+
+            template <>
+            struct
+            mul_eq_vs_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==4 && is_scalar<B>::value,
+            deduce_vec<A> >::type
+        operator/( A const & a, B b )
+            {
+            typedef typename deduce_vec<A>::type R;
+            R r;
+            vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a)/b;
+            vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a)/b;
+            vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a)/b;
+            vec_traits<R>::template write_element<3>(r)=vec_traits<A>::template read_element<3>(a)/b;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct div_vs_defined;
+
+            template <>
+            struct
+            div_vs_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class  B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==4 && is_scalar<B>::value,
+            A &>::type
+        operator/=( A & a, B b )
+            {
+            vec_traits<A>::template write_element<0>(a)/=b;
+            vec_traits<A>::template write_element<1>(a)/=b;
+            vec_traits<A>::template write_element<2>(a)/=b;
+            vec_traits<A>::template write_element<3>(a)/=b;
+            return a;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator/=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct div_eq_vs_defined;
+
+            template <>
+            struct
+            div_eq_vs_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class R,class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_vec<A>::value &&
+            vec_traits<R>::dim==4 && vec_traits<A>::dim==4,
+            R>::type
+        convert_to( A const & a )
+            {
+            R r;
+            vec_traits<R>::template write_element<0>(r)=vec_traits<A>::template read_element<0>(a);
+            vec_traits<R>::template write_element<1>(r)=vec_traits<A>::template read_element<1>(a);
+            vec_traits<R>::template write_element<2>(r)=vec_traits<A>::template read_element<2>(a);
+            vec_traits<R>::template write_element<3>(r)=vec_traits<A>::template read_element<3>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::convert_to;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct convert_to_v_defined;
+
+            template <>
+            struct
+            convert_to_v_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==4 && vec_traits<B>::dim==4,
+        bool>::type
+        operator==( A const & a, B const & b )
+            {
+            return
+                vec_traits<A>::template read_element<0>(a)==vec_traits<B>::template read_element<0>(b) &&
+                vec_traits<A>::template read_element<1>(a)==vec_traits<B>::template read_element<1>(b) &&
+                vec_traits<A>::template read_element<2>(a)==vec_traits<B>::template read_element<2>(b) &&
+                vec_traits<A>::template read_element<3>(a)==vec_traits<B>::template read_element<3>(b);
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator==;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct eq_vv_defined;
+
+            template <>
+            struct
+            eq_vv_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==4 && vec_traits<B>::dim==4,
+        bool>::type
+        operator!=( A const & a, B const & b )
+            {
+            return
+                !(vec_traits<A>::template read_element<0>(a)==vec_traits<B>::template read_element<0>(b)) ||
+                !(vec_traits<A>::template read_element<1>(a)==vec_traits<B>::template read_element<1>(b)) ||
+                !(vec_traits<A>::template read_element<2>(a)==vec_traits<B>::template read_element<2>(b)) ||
+                !(vec_traits<A>::template read_element<3>(a)==vec_traits<B>::template read_element<3>(b));
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator!=;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct neq_vv_defined;
+
+            template <>
+            struct
+            neq_vv_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==4,
+            deduce_vec<A> >::type
+        operator-( A const & a )
+            {
+            typedef typename deduce_vec<A>::type R;
+            R r;
+            vec_traits<R>::template write_element<0>(r)=-vec_traits<A>::template read_element<0>(a);
+            vec_traits<R>::template write_element<1>(r)=-vec_traits<A>::template read_element<1>(a);
+            vec_traits<R>::template write_element<2>(r)=-vec_traits<A>::template read_element<2>(a);
+            vec_traits<R>::template write_element<3>(r)=-vec_traits<A>::template read_element<3>(a);
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator-;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct minus_v_defined;
+
+            template <>
+            struct
+            minus_v_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_vec<A>::value && vec_traits<A>::dim==4,
+            typename vec_traits<A>::scalar_type>::type
+        mag( A const & a )
+            {
+            typedef typename vec_traits<A>::scalar_type T;
+            T const a0=vec_traits<A>::template read_element<0>(a);
+            T const a1=vec_traits<A>::template read_element<1>(a);
+            T const a2=vec_traits<A>::template read_element<2>(a);
+            T const a3=vec_traits<A>::template read_element<3>(a);
+            T const m2=a0*a0+a1*a1+a2*a2+a3*a3;
+            T const mag=sqrt<T>(m2);
+            return mag;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::mag;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct mag_v_defined;
+
+            template <>
+            struct
+            mag_v_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_vec<A>::value && vec_traits<A>::dim==4,
+            typename vec_traits<A>::scalar_type>::type
+        mag_sqr( A const & a )
+            {
+            typedef typename vec_traits<A>::scalar_type T;
+            T const a0=vec_traits<A>::template read_element<0>(a);
+            T const a1=vec_traits<A>::template read_element<1>(a);
+            T const a2=vec_traits<A>::template read_element<2>(a);
+            T const a3=vec_traits<A>::template read_element<3>(a);
+            T const m2=a0*a0+a1*a1+a2*a2+a3*a3;
+            return m2;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::mag_sqr;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct mag_sqr_v_defined;
+
+            template <>
+            struct
+            mag_sqr_v_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==4,
+            deduce_vec<A> >::type
+        normalized( A const & a )
+            {
+            typedef typename vec_traits<A>::scalar_type T;
+            T const a0=vec_traits<A>::template read_element<0>(a);
+            T const a1=vec_traits<A>::template read_element<1>(a);
+            T const a2=vec_traits<A>::template read_element<2>(a);
+            T const a3=vec_traits<A>::template read_element<3>(a);
+            T const m2=a0*a0+a1*a1+a2*a2+a3*a3;
+            if( m2==scalar_traits<typename vec_traits<A>::scalar_type>::value(0) )
+                BOOST_QVM_THROW_EXCEPTION(zero_magnitude_error());
+            T const rm=scalar_traits<T>::value(1)/sqrt<T>(m2);
+            typedef typename deduce_vec<A>::type R;
+            R r;
+            vec_traits<R>::template write_element<0>(r)=a0*rm;
+            vec_traits<R>::template write_element<1>(r)=a1*rm;
+            vec_traits<R>::template write_element<2>(r)=a2*rm;
+            vec_traits<R>::template write_element<3>(r)=a3*rm;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::normalized;
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            vec_traits<A>::dim==4,
+            void>::type
+        normalize( A & a )
+            {
+            typedef typename vec_traits<A>::scalar_type T;
+            T const a0=vec_traits<A>::template read_element<0>(a);
+            T const a1=vec_traits<A>::template read_element<1>(a);
+            T const a2=vec_traits<A>::template read_element<2>(a);
+            T const a3=vec_traits<A>::template read_element<3>(a);
+            T const m2=a0*a0+a1*a1+a2*a2+a3*a3;
+            if( m2==scalar_traits<typename vec_traits<A>::scalar_type>::value(0) )
+                BOOST_QVM_THROW_EXCEPTION(zero_magnitude_error());
+            T const rm=scalar_traits<T>::value(1)/sqrt<T>(m2);
+            vec_traits<A>::template write_element<0>(a)*=rm;
+            vec_traits<A>::template write_element<1>(a)*=rm;
+            vec_traits<A>::template write_element<2>(a)*=rm;
+            vec_traits<A>::template write_element<3>(a)*=rm;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::normalize;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct normalize_v_defined;
+
+            template <>
+            struct
+            normalize_v_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            vec_traits<A>::dim==4 && vec_traits<B>::dim==4,
+            deduce_scalar<typename vec_traits<A>::scalar_type,typename vec_traits<B>::scalar_type> >::type
+        dot( A const & a, B const & b )
+            {
+            typedef typename vec_traits<A>::scalar_type Ta;
+            typedef typename vec_traits<B>::scalar_type Tb;
+            typedef typename deduce_scalar<Ta,Tb>::type Tr;
+            Ta const a0=vec_traits<A>::template read_element<0>(a);
+            Ta const a1=vec_traits<A>::template read_element<1>(a);
+            Ta const a2=vec_traits<A>::template read_element<2>(a);
+            Ta const a3=vec_traits<A>::template read_element<3>(a);
+            Tb const b0=vec_traits<B>::template read_element<0>(b);
+            Tb const b1=vec_traits<B>::template read_element<1>(b);
+            Tb const b2=vec_traits<B>::template read_element<2>(b);
+            Tb const b3=vec_traits<B>::template read_element<3>(b);
+            Tr const dot=a0*b0+a1*b1+a2*b2+a3*b3;
+            return dot;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::dot;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct dot_vv_defined;
+
+            template <>
+            struct
+            dot_vv_defined<4>
+                {
+                static bool const value=true;
+                };
+            }
+
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/inline.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/inline.hpp
new file mode 100644
index 00000000000..419fad223e7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/inline.hpp
@@ -0,0 +1,34 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_FORCEINLINE
+#   if defined(_MSC_VER)
+#       define BOOST_QVM_FORCEINLINE __forceinline
+#   elif defined(__GNUC__) && __GNUC__>3
+#       define BOOST_QVM_FORCEINLINE inline __attribute__ ((always_inline))
+#   else
+#       define BOOST_QVM_FORCEINLINE inline
+#   endif
+#endif
+
+#ifndef BOOST_QVM_INLINE
+#define BOOST_QVM_INLINE inline
+#endif
+
+#ifndef BOOST_QVM_INLINE_TRIVIAL
+#define BOOST_QVM_INLINE_TRIVIAL BOOST_QVM_FORCEINLINE
+#endif
+
+#ifndef BOOST_QVM_INLINE_CRITICAL
+#define BOOST_QVM_INLINE_CRITICAL BOOST_QVM_FORCEINLINE
+#endif
+
+#ifndef BOOST_QVM_INLINE_OPERATIONS
+#define BOOST_QVM_INLINE_OPERATIONS BOOST_QVM_INLINE
+#endif
+
+#ifndef BOOST_QVM_INLINE_RECURSION
+#define BOOST_QVM_INLINE_RECURSION BOOST_QVM_INLINE_OPERATIONS
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/map.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/map.hpp
new file mode 100644
index 00000000000..9b53211a90d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/map.hpp
@@ -0,0 +1,13 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_74318C76B4ED11E58A3AE198BB8E7F8B
+#define UUID_74318C76B4ED11E58A3AE198BB8E7F8B
+
+#include <boost/qvm/map_vec_mat.hpp>
+#include <boost/qvm/map_mat_vec.hpp>
+#include <boost/qvm/map_mat_mat.hpp>
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/map_mat_mat.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/map_mat_mat.hpp
new file mode 100644
index 00000000000..8f691722ea8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/map_mat_mat.hpp
@@ -0,0 +1,895 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_20D98340A3EB11DEB2180CD156D89593
+#define UUID_20D98340A3EB11DEB2180CD156D89593
+
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/deduce_mat.hpp>
+#include <boost/qvm/assert.hpp>
+#include <boost/qvm/enable_if.hpp>
+#include <boost/qvm/detail/transp_impl.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int Row,class OriginalMatrix>
+            class
+            del_row_
+                {
+                del_row_( del_row_ const & );
+                del_row_ & operator=( del_row_ const & );
+                ~del_row_();
+
+                public:
+
+                template <class T>
+                BOOST_QVM_INLINE_TRIVIAL
+                del_row_ &
+                operator=( T const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <int I,class OriginalMatrix>
+        struct
+        mat_traits< qvm_detail::del_row_<I,OriginalMatrix> >
+            {
+            typedef qvm_detail::del_row_<I,OriginalMatrix> this_matrix;
+            typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
+            static int const rows=mat_traits<OriginalMatrix>::rows-1;
+            static int const cols=mat_traits<OriginalMatrix>::cols;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return mat_traits<OriginalMatrix>::template read_element<Row+(Row>=I),Col>(reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_matrix & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return mat_traits<OriginalMatrix>::template write_element<Row+(Row>=I),Col>(reinterpret_cast<OriginalMatrix &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return mat_traits<OriginalMatrix>::read_element_idx(row+(row>=I),col,reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int row, int col, this_matrix & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return mat_traits<OriginalMatrix>::write_element_idx(row+(row>=I),col,reinterpret_cast<OriginalMatrix &>(x));
+                }
+            };
+
+        template <int J,class OriginalMatrix,int R,int C>
+        struct
+        deduce_mat<qvm_detail::del_row_<J,OriginalMatrix>,R,C>
+            {
+            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
+            };
+
+        template <int J,class OriginalMatrix,int R,int C>
+        struct
+        deduce_mat2<qvm_detail::del_row_<J,OriginalMatrix>,qvm_detail::del_row_<J,OriginalMatrix>,R,C>
+            {
+            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
+            };
+
+        template <int Row,class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value,
+            qvm_detail::del_row_<Row,A> const &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        del_row( A const & a )
+            {
+            return reinterpret_cast<typename qvm_detail::del_row_<Row,A> const &>(a);
+            }
+
+        template <int Row,class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value,
+            qvm_detail::del_row_<Row,A> &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        del_row( A & a )
+            {
+            return reinterpret_cast<typename qvm_detail::del_row_<Row,A> &>(a);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int Col,class OriginalMatrix>
+            class
+            del_col_
+                {
+                del_col_( del_col_ const & );
+                del_col_ & operator=( del_col_ const & );
+                ~del_col_();
+
+                public:
+
+                template <class T>
+                BOOST_QVM_INLINE_TRIVIAL
+                del_col_ &
+                operator=( T const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <int J,class OriginalMatrix>
+        struct
+        mat_traits< qvm_detail::del_col_<J,OriginalMatrix> >
+            {
+            typedef qvm_detail::del_col_<J,OriginalMatrix> this_matrix;
+            typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
+            static int const rows=mat_traits<OriginalMatrix>::rows;
+            static int const cols=mat_traits<OriginalMatrix>::cols-1;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return mat_traits<OriginalMatrix>::template read_element<Row,Col+(Col>=J)>(reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_matrix & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return mat_traits<OriginalMatrix>::template write_element<Row,Col+(Col>=J)>(reinterpret_cast<OriginalMatrix &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return mat_traits<OriginalMatrix>::read_element_idx(row,col+(col>=J),reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int row, int col, this_matrix & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return mat_traits<OriginalMatrix>::write_element_idx(row,col+(col>=J),reinterpret_cast<OriginalMatrix &>(x));
+                }
+            };
+
+        template <int J,class OriginalMatrix,int R,int C>
+        struct
+        deduce_mat<qvm_detail::del_col_<J,OriginalMatrix>,R,C>
+            {
+            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
+            };
+
+        template <int J,class OriginalMatrix,int R,int C>
+        struct
+        deduce_mat2<qvm_detail::del_col_<J,OriginalMatrix>,qvm_detail::del_col_<J,OriginalMatrix>,R,C>
+            {
+            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
+            };
+
+        template <int Col,class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value,
+            qvm_detail::del_col_<Col,A> const &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        del_col( A const & a )
+            {
+            return reinterpret_cast<typename qvm_detail::del_col_<Col,A> const &>(a);
+            }
+
+        template <int Col,class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value,
+            qvm_detail::del_col_<Col,A> &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        del_col( A & a )
+            {
+            return reinterpret_cast<typename qvm_detail::del_col_<Col,A> &>(a);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int Row,int Col,class OriginalMatrix>
+            class
+            del_row_col_
+                {
+                del_row_col_( del_row_col_ const & );
+                ~del_row_col_();
+
+                public:
+
+                BOOST_QVM_INLINE_TRIVIAL
+                del_row_col_ &
+                operator=( del_row_col_ const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class T>
+                BOOST_QVM_INLINE_TRIVIAL
+                del_row_col_ &
+                operator=( T const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <int I,int J,class OriginalMatrix>
+        struct
+        mat_traits< qvm_detail::del_row_col_<I,J,OriginalMatrix> >
+            {
+            typedef qvm_detail::del_row_col_<I,J,OriginalMatrix> this_matrix;
+            typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
+            static int const rows=mat_traits<OriginalMatrix>::rows-1;
+            static int const cols=mat_traits<OriginalMatrix>::cols-1;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return mat_traits<OriginalMatrix>::template read_element<Row+(Row>=I),Col+(Col>=J)>(reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_matrix & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return mat_traits<OriginalMatrix>::template write_element<Row+(Row>=I),Col+(Col>=J)>(reinterpret_cast<OriginalMatrix &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return mat_traits<OriginalMatrix>::read_element_idx(row+(row>=I),col+(col>=J),reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int row, int col, this_matrix & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return mat_traits<OriginalMatrix>::write_element_idx(row+(row>=I),col+(col>=J),reinterpret_cast<OriginalMatrix &>(x));
+                }
+            };
+
+        template <int I,int J,class OriginalMatrix,int R,int C>
+        struct
+        deduce_mat<qvm_detail::del_row_col_<I,J,OriginalMatrix>,R,C>
+            {
+            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
+            };
+
+        template <int I,int J,class OriginalMatrix,int R,int C>
+        struct
+        deduce_mat2<qvm_detail::del_row_col_<I,J,OriginalMatrix>,qvm_detail::del_row_col_<I,J,OriginalMatrix>,R,C>
+            {
+            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
+            };
+
+        template <int Row,int Col,class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value,
+            qvm_detail::del_row_col_<Row,Col,A> const &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        del_row_col( A const & a )
+            {
+            return reinterpret_cast<typename qvm_detail::del_row_col_<Row,Col,A> const &>(a);
+            }
+
+        template <int Row,int Col,class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value,
+            qvm_detail::del_row_col_<Row,Col,A> &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        del_row_col( A & a )
+            {
+            return reinterpret_cast<typename qvm_detail::del_row_col_<Row,Col,A> &>(a);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int Row,class OriginalMatrix>
+            class
+            neg_row_
+                {
+                neg_row_( neg_row_ const & );
+                neg_row_ & operator=( neg_row_ const & );
+                ~neg_row_();
+
+                public:
+
+                template <class T>
+                BOOST_QVM_INLINE_TRIVIAL
+                neg_row_ &
+                operator=( T const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <int I,class OriginalMatrix>
+        struct
+        mat_traits< qvm_detail::neg_row_<I,OriginalMatrix> >
+            {
+            typedef qvm_detail::neg_row_<I,OriginalMatrix> this_matrix;
+            typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
+            static int const rows=mat_traits<OriginalMatrix>::rows;
+            static int const cols=mat_traits<OriginalMatrix>::cols;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return Row==I ?
+                    -mat_traits<OriginalMatrix>::template read_element<Row,Col>(reinterpret_cast<OriginalMatrix const &>(x)) :
+                    mat_traits<OriginalMatrix>::template read_element<Row,Col>(reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return row==I?
+                    -mat_traits<OriginalMatrix>::read_element_idx(row,col,reinterpret_cast<OriginalMatrix const &>(x)) :
+                    mat_traits<OriginalMatrix>::read_element_idx(row,col,reinterpret_cast<OriginalMatrix const &>(x));
+                }
+            };
+
+        template <int J,class OriginalMatrix,int R,int C>
+        struct
+        deduce_mat<qvm_detail::neg_row_<J,OriginalMatrix>,R,C>
+            {
+            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
+            };
+
+        template <int J,class OriginalMatrix,int R,int C>
+        struct
+        deduce_mat2<qvm_detail::neg_row_<J,OriginalMatrix>,qvm_detail::neg_row_<J,OriginalMatrix>,R,C>
+            {
+            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
+            };
+
+        template <int Row,class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value,
+            qvm_detail::neg_row_<Row,A> const &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        neg_row( A const & a )
+            {
+            return reinterpret_cast<typename qvm_detail::neg_row_<Row,A> const &>(a);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int Col,class OriginalMatrix>
+            class
+            neg_col_
+                {
+                neg_col_( neg_col_ const & );
+                neg_col_ & operator=( neg_col_ const & );
+                ~neg_col_();
+
+                public:
+
+                template <class T>
+                BOOST_QVM_INLINE_TRIVIAL
+                neg_col_ &
+                operator=( T const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <int J,class OriginalMatrix>
+        struct
+        mat_traits< qvm_detail::neg_col_<J,OriginalMatrix> >
+            {
+            typedef qvm_detail::neg_col_<J,OriginalMatrix> this_matrix;
+            typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
+            static int const rows=mat_traits<OriginalMatrix>::rows;
+            static int const cols=mat_traits<OriginalMatrix>::cols;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return Col==J?
+                    -mat_traits<OriginalMatrix>::template read_element<Row,Col>(reinterpret_cast<OriginalMatrix const &>(x)) :
+                    mat_traits<OriginalMatrix>::template read_element<Row,Col>(reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return col==J?
+                    -mat_traits<OriginalMatrix>::read_element_idx(row,col,reinterpret_cast<OriginalMatrix const &>(x)) :
+                    mat_traits<OriginalMatrix>::read_element_idx(row,col,reinterpret_cast<OriginalMatrix const &>(x));
+                }
+            };
+
+        template <int J,class OriginalMatrix,int R,int C>
+        struct
+        deduce_mat<qvm_detail::neg_col_<J,OriginalMatrix>,R,C>
+            {
+            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
+            };
+
+        template <int J,class OriginalMatrix,int R,int C>
+        struct
+        deduce_mat2<qvm_detail::neg_col_<J,OriginalMatrix>,qvm_detail::neg_col_<J,OriginalMatrix>,R,C>
+            {
+            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
+            };
+
+        template <int Col,class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value,
+            qvm_detail::neg_col_<Col,A> const &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        neg_col( A const & a )
+            {
+            return reinterpret_cast<typename qvm_detail::neg_col_<Col,A> const &>(a);
+            }
+
+        ////////////////////////////////////////////////
+
+        template <class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value,
+            qvm_detail::transposed_<A> const &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        transposed( A const & a )
+            {
+            return reinterpret_cast<typename qvm_detail::transposed_<A> const &>(a);
+            }
+
+        template <class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value,
+            qvm_detail::transposed_<A> &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        transposed( A & a )
+            {
+            return reinterpret_cast<typename qvm_detail::transposed_<A> &>(a);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int Row1,int Row2,class OriginalMatrix>
+            class
+            swap_rows_
+                {
+                swap_rows_( swap_rows_ const & );
+                swap_rows_ & operator=( swap_rows_ const & );
+                ~swap_rows_();
+
+                public:
+
+                template <class T>
+                BOOST_QVM_INLINE_TRIVIAL
+                swap_rows_ &
+                operator=( T const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <int R1,int R2,class OriginalMatrix>
+        struct
+        mat_traits< qvm_detail::swap_rows_<R1,R2,OriginalMatrix> >
+            {
+            typedef qvm_detail::swap_rows_<R1,R2,OriginalMatrix> this_matrix;
+            typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
+            static int const rows=mat_traits<OriginalMatrix>::rows;
+            static int const cols=mat_traits<OriginalMatrix>::cols;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return mat_traits<OriginalMatrix>::template read_element<(Row==R1 && R1!=R2)*R2+(Row==R2 && R1!=R2)*R1+((Row!=R1 && Row!=R2) || R1==R2)*Row,Col>(reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_matrix & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return mat_traits<OriginalMatrix>::template write_element<(Row==R1 && R1!=R2)*R2+(Row==R2 && R1!=R2)*R1+((Row!=R1 && Row!=R2) || R1==R2)*Row,Col>(reinterpret_cast<OriginalMatrix &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return mat_traits<OriginalMatrix>::read_element_idx(row==R1?R2:row==R2?R1:row,col,reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int row, int col, this_matrix & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return mat_traits<OriginalMatrix>::write_element_idx(row==R1?R2:row==R2?R1:row,col,reinterpret_cast<OriginalMatrix &>(x));
+                }
+            };
+
+        template <int R1,int R2,class OriginalMatrix,int R,int C>
+        struct
+        deduce_mat<qvm_detail::swap_rows_<R1,R2,OriginalMatrix>,R,C>
+            {
+            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
+            };
+
+        template <int R1,int R2,class OriginalMatrix,int R,int C>
+        struct
+        deduce_mat2<qvm_detail::swap_rows_<R1,R2,OriginalMatrix>,qvm_detail::swap_rows_<R1,R2,OriginalMatrix>,R,C>
+            {
+            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
+            };
+
+        template <int R1,int R2,class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value,
+            qvm_detail::swap_rows_<R1,R2,A> const &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        swap_rows( A const & a )
+            {
+            return reinterpret_cast<typename qvm_detail::swap_rows_<R1,R2,A> const &>(a);
+            }
+
+        template <int R1,int R2,class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value,
+            qvm_detail::swap_rows_<R1,R2,A> &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        swap_rows( A & a )
+            {
+            return reinterpret_cast<typename qvm_detail::swap_rows_<R1,R2,A> &>(a);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int Row1,int Row2,class OriginalMatrix>
+            class
+            swap_cols_
+                {
+                swap_cols_( swap_cols_ const & );
+                swap_cols_ & operator=( swap_cols_ const & );
+                ~swap_cols_();
+
+                public:
+
+                template <class T>
+                BOOST_QVM_INLINE_TRIVIAL
+                swap_cols_ &
+                operator=( T const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <int C1,int C2,class OriginalMatrix>
+        struct
+        mat_traits< qvm_detail::swap_cols_<C1,C2,OriginalMatrix> >
+            {
+            typedef qvm_detail::swap_cols_<C1,C2,OriginalMatrix> this_matrix;
+            typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
+            static int const rows=mat_traits<OriginalMatrix>::rows;
+            static int const cols=mat_traits<OriginalMatrix>::cols;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return mat_traits<OriginalMatrix>::template read_element<Row,(Col==C1 && C1!=C2)*C2+(Col==C2 && C1!=C2)*C1+((Col!=C1 && Col!=C2) || C1==C2)*Col>(reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_matrix & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return mat_traits<OriginalMatrix>::template write_element<Row,(Col==C1 && C1!=C2)*C2+(Col==C2 && C1!=C2)*C1+((Col!=C1 && Col!=C2) || C1==C2)*Col>(reinterpret_cast<OriginalMatrix &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return mat_traits<OriginalMatrix>::read_element_idx(row,col==C1?C2:col==C2?C1:col,reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int row, int col, this_matrix & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return mat_traits<OriginalMatrix>::write_element_idx(row,col==C1?C2:col==C2?C1:col,reinterpret_cast<OriginalMatrix &>(x));
+                }
+            };
+
+        template <int C1,int C2,class OriginalMatrix,int R,int C>
+        struct
+        deduce_mat<qvm_detail::swap_cols_<C1,C2,OriginalMatrix>,R,C>
+            {
+            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
+            };
+
+        template <int C1,int C2,class OriginalMatrix,int R,int C>
+        struct
+        deduce_mat2<qvm_detail::swap_cols_<C1,C2,OriginalMatrix>,qvm_detail::swap_cols_<C1,C2,OriginalMatrix>,R,C>
+            {
+            typedef mat<typename mat_traits<OriginalMatrix>::scalar_type,R,C> type;
+            };
+
+        template <int C1,int C2,class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value,
+            qvm_detail::swap_cols_<C1,C2,A> const &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        swap_cols( A const & a )
+            {
+            return reinterpret_cast<typename qvm_detail::swap_cols_<C1,C2,A> const &>(a);
+            }
+
+        template <int C1,int C2,class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value,
+            qvm_detail::swap_cols_<C1,C2,A> &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        swap_cols( A & a )
+            {
+            return reinterpret_cast<typename qvm_detail::swap_cols_<C1,C2,A> &>(a);
+            }
+
+        ////////////////////////////////////////////////
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/map_mat_vec.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/map_mat_vec.hpp
new file mode 100644
index 00000000000..81a2527d218
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/map_mat_vec.hpp
@@ -0,0 +1,537 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_5265FC7CA1C011DE9EBDFFA956D89593
+#define UUID_5265FC7CA1C011DE9EBDFFA956D89593
+
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/mat_traits.hpp>
+#include <boost/qvm/deduce_vec.hpp>
+#include <boost/qvm/assert.hpp>
+#include <boost/qvm/enable_if.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int Col,class OriginalMatrix>
+            class
+            col_
+                {
+                col_( col_ const & );
+                col_ & operator=( col_ const & );
+                ~col_();
+
+                public:
+
+                template <class T>
+                BOOST_QVM_INLINE_TRIVIAL
+                col_ &
+                operator=( T const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <int Col,class OriginalMatrix>
+        struct
+        vec_traits< qvm_detail::col_<Col,OriginalMatrix> >
+            {
+            typedef qvm_detail::col_<Col,OriginalMatrix> this_vector;
+            typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
+            static int const dim=mat_traits<OriginalMatrix>::rows;
+            BOOST_QVM_STATIC_ASSERT(Col>=0);
+            BOOST_QVM_STATIC_ASSERT(Col<mat_traits<OriginalMatrix>::cols);
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_vector const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<dim);
+                return mat_traits<OriginalMatrix>::template read_element<I,Col>(reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_vector & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<dim);
+                return mat_traits<OriginalMatrix>::template write_element<I,Col>(reinterpret_cast<OriginalMatrix &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int i, this_vector const & x )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<dim);
+                return mat_traits<OriginalMatrix>::read_element_idx(i,Col,reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int i, this_vector & x )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<dim);
+                return mat_traits<OriginalMatrix>::write_element_idx(i,Col,reinterpret_cast<OriginalMatrix &>(x));
+                }
+            };
+
+        template <int Col,class OriginalMatrix,int D>
+        struct
+        deduce_vec<qvm_detail::col_<Col,OriginalMatrix>,D>
+            {
+            typedef vec<typename mat_traits<OriginalMatrix>::scalar_type,D> type;
+            };
+
+        template <int Col,class OriginalMatrix,int D>
+        struct
+        deduce_vec2<qvm_detail::col_<Col,OriginalMatrix>,qvm_detail::col_<Col,OriginalMatrix>,D>
+            {
+            typedef vec<typename mat_traits<OriginalMatrix>::scalar_type,D> type;
+            };
+
+        template <int Col,class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value,
+            qvm_detail::col_<Col,A> const &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        col( A const & a )
+            {
+            return reinterpret_cast<typename qvm_detail::col_<Col,A> const &>(a);
+            }
+
+        template <int Col,class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value,
+            qvm_detail::col_<Col,A> &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        col( A & a )
+            {
+            return reinterpret_cast<typename qvm_detail::col_<Col,A> &>(a);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int Row,class OriginalMatrix>
+            class
+            row_
+                {
+                row_( row_ const & );
+                row_ & operator=( row_ const & );
+                ~row_();
+
+                public:
+
+                template <class T>
+                BOOST_QVM_INLINE_TRIVIAL
+                row_ &
+                operator=( T const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <int Row,class OriginalMatrix>
+        struct
+        vec_traits< qvm_detail::row_<Row,OriginalMatrix> >
+            {
+            typedef qvm_detail::row_<Row,OriginalMatrix> this_vector;
+            typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
+            static int const dim=mat_traits<OriginalMatrix>::cols;
+            BOOST_QVM_STATIC_ASSERT(Row>=0);
+            BOOST_QVM_STATIC_ASSERT(Row<mat_traits<OriginalMatrix>::rows);
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_vector const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<dim);
+                return mat_traits<OriginalMatrix>::template read_element<Row,I>(reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_vector & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<dim);
+                return mat_traits<OriginalMatrix>::template write_element<Row,I>(reinterpret_cast<OriginalMatrix &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int i, this_vector const & x )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<dim);
+                return mat_traits<OriginalMatrix>::read_element_idx(Row,i,reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int i, this_vector & x )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<dim);
+                return mat_traits<OriginalMatrix>::write_element_idx(Row,i,reinterpret_cast<OriginalMatrix &>(x));
+                }
+            };
+
+        template <int Row,class OriginalMatrix,int D>
+        struct
+        deduce_vec<qvm_detail::row_<Row,OriginalMatrix>,D>
+            {
+            typedef vec<typename mat_traits<OriginalMatrix>::scalar_type,D> type;
+            };
+
+        template <int Row,class OriginalMatrix,int D>
+        struct
+        deduce_vec2<qvm_detail::row_<Row,OriginalMatrix>,qvm_detail::row_<Row,OriginalMatrix>,D>
+            {
+            typedef vec<typename mat_traits<OriginalMatrix>::scalar_type,D> type;
+            };
+
+        template <int Row,class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value,
+            qvm_detail::row_<Row,A> const &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        row( A const & a )
+            {
+            return reinterpret_cast<typename qvm_detail::row_<Row,A> const &>(a);
+            }
+
+        template <int Row,class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value,
+            qvm_detail::row_<Row,A> &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        row( A & a )
+            {
+            return reinterpret_cast<typename qvm_detail::row_<Row,A> &>(a);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class OriginalMatrix>
+            class
+            diag_
+                {
+                diag_( diag_ const & );
+                diag_ & operator=( diag_ const & );
+                ~diag_();
+
+                public:
+
+                template <class T>
+                BOOST_QVM_INLINE_TRIVIAL
+                diag_ &
+                operator=( T const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+
+            template <int X,int Y,bool Which>
+            struct diag_bool_dispatch;
+
+            template <int X,int Y>
+            struct
+            diag_bool_dispatch<X,Y,true>
+                {
+                static int const value=X;
+                };
+
+            template <int X,int Y>
+            struct
+            diag_bool_dispatch<X,Y,false>
+                {
+                static int const value=Y;
+                };
+            }
+
+        template <class OriginalMatrix>
+        struct
+        vec_traits< qvm_detail::diag_<OriginalMatrix> >
+            {
+            typedef qvm_detail::diag_<OriginalMatrix> this_vector;
+            typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
+            static int const dim=qvm_detail::diag_bool_dispatch<
+                    mat_traits<OriginalMatrix>::rows,
+                    mat_traits<OriginalMatrix>::cols,
+                    mat_traits<OriginalMatrix>::rows<=mat_traits<OriginalMatrix>::cols>::value;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_vector const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<dim);
+                return mat_traits<OriginalMatrix>::template read_element<I,I>(reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_vector & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<dim);
+                return mat_traits<OriginalMatrix>::template write_element<I,I>(reinterpret_cast<OriginalMatrix &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int i, this_vector const & x )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<dim);
+                return mat_traits<OriginalMatrix>::read_element_idx(i,i,reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int i, this_vector & x )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<dim);
+                return mat_traits<OriginalMatrix>::write_element_idx(i,i,reinterpret_cast<OriginalMatrix &>(x));
+                }
+            };
+
+        template <class OriginalMatrix,int D>
+        struct
+        deduce_vec<qvm_detail::diag_<OriginalMatrix>,D>
+            {
+            typedef vec<typename mat_traits<OriginalMatrix>::scalar_type,D> type;
+            };
+
+        template <class OriginalMatrix,int D>
+        struct
+        deduce_vec2<qvm_detail::diag_<OriginalMatrix>,qvm_detail::diag_<OriginalMatrix>,D>
+            {
+            typedef vec<typename mat_traits<OriginalMatrix>::scalar_type,D> type;
+            };
+
+        template <class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value,
+            qvm_detail::diag_<A> const &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        diag( A const & a )
+            {
+            return reinterpret_cast<typename qvm_detail::diag_<A> const &>(a);
+            }
+
+        template <class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value,
+            qvm_detail::diag_<A> &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        diag( A & a )
+            {
+            return reinterpret_cast<typename qvm_detail::diag_<A> &>(a);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class OriginalMatrix>
+            class
+            translation_
+                {
+                translation_( translation_ const & );
+                ~translation_();
+
+                public:
+
+                translation_ &
+                operator=( translation_ const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class T>
+                BOOST_QVM_INLINE_TRIVIAL
+                translation_ &
+                operator=( T const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <class OriginalMatrix>
+        struct
+        vec_traits< qvm_detail::translation_<OriginalMatrix> >
+            {
+            typedef qvm_detail::translation_<OriginalMatrix> this_vector;
+            typedef typename mat_traits<OriginalMatrix>::scalar_type scalar_type;
+            static int const dim=mat_traits<OriginalMatrix>::rows-1;
+            BOOST_QVM_STATIC_ASSERT(mat_traits<OriginalMatrix>::rows==mat_traits<OriginalMatrix>::cols);
+            BOOST_QVM_STATIC_ASSERT(mat_traits<OriginalMatrix>::rows>=3);
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_vector const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<dim);
+                return mat_traits<OriginalMatrix>::template read_element<I,dim>(reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_vector & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<dim);
+                return mat_traits<OriginalMatrix>::template write_element<I,dim>(reinterpret_cast<OriginalMatrix &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int i, this_vector const & x )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<dim);
+                return mat_traits<OriginalMatrix>::read_element_idx(i,dim,reinterpret_cast<OriginalMatrix const &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int i, this_vector & x )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<dim);
+                return mat_traits<OriginalMatrix>::write_element_idx(i,dim,reinterpret_cast<OriginalMatrix &>(x));
+                }
+            };
+
+        template <class OriginalMatrix,int D>
+        struct
+        deduce_vec<qvm_detail::translation_<OriginalMatrix>,D>
+            {
+            typedef vec<typename mat_traits<OriginalMatrix>::scalar_type,D> type;
+            };
+
+        template <class OriginalMatrix,int D>
+        struct
+        deduce_vec2<qvm_detail::translation_<OriginalMatrix>,qvm_detail::translation_<OriginalMatrix>,D>
+            {
+            typedef vec<typename mat_traits<OriginalMatrix>::scalar_type,D> type;
+            };
+
+        template <class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value && mat_traits<A>::rows==mat_traits<A>::cols && mat_traits<A>::rows>=3,
+            qvm_detail::translation_<A> const &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        translation( A const & a )
+            {
+            return reinterpret_cast<typename qvm_detail::translation_<A> const &>(a);
+            }
+
+        template <class A>
+        typename boost::enable_if_c<
+            is_mat<A>::value && mat_traits<A>::rows==mat_traits<A>::cols && mat_traits<A>::rows>=3,
+            qvm_detail::translation_<A> &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        translation( A & a )
+            {
+            return reinterpret_cast<typename qvm_detail::translation_<A> &>(a);
+            }
+
+        ////////////////////////////////////////////////
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/map_vec_mat.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/map_vec_mat.hpp
new file mode 100644
index 00000000000..b7412f2963c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/map_vec_mat.hpp
@@ -0,0 +1,591 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_3EDF999CA1C011DEBA5C8DA956D89593
+#define UUID_3EDF999CA1C011DEBA5C8DA956D89593
+
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/deduce_mat.hpp>
+#include <boost/qvm/vec_traits.hpp>
+#include <boost/qvm/assert.hpp>
+#include <boost/qvm/enable_if.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class OriginalVector>
+            class
+            col_mat_
+                {
+                col_mat_( col_mat_ const & );
+                col_mat_ & operator=( col_mat_ const & );
+                ~col_mat_();
+
+                public:
+
+                template <class T>
+                BOOST_QVM_INLINE_TRIVIAL
+                col_mat_ &
+                operator=( T const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <class OriginalVector>
+        struct
+        mat_traits< qvm_detail::col_mat_<OriginalVector> >
+            {
+            typedef qvm_detail::col_mat_<OriginalVector> this_matrix;
+            typedef typename vec_traits<OriginalVector>::scalar_type scalar_type;
+            static int const rows=vec_traits<OriginalVector>::dim;
+            static int const cols=1;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Col==0);
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                return vec_traits<OriginalVector>::template read_element<Row>(reinterpret_cast<OriginalVector const &>(x));
+                }
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_matrix & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Col==0);
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                return vec_traits<OriginalVector>::template write_element<Row>(reinterpret_cast<OriginalVector &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(col==0);
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                return vec_traits<OriginalVector>::read_element_idx(row,reinterpret_cast<OriginalVector const &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int row, int col, this_matrix & x )
+                {
+                BOOST_QVM_ASSERT(col==0);
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                return vec_traits<OriginalVector>::write_element_idx(row,reinterpret_cast<OriginalVector &>(x));
+                }
+            };
+
+        template <class OriginalVector,int R,int C>
+        struct
+        deduce_mat<qvm_detail::col_mat_<OriginalVector>,R,C>
+            {
+            typedef mat<typename vec_traits<OriginalVector>::scalar_type,R,C> type;
+            };
+
+        template <class OriginalVector,int R,int C>
+        struct
+        deduce_mat2<qvm_detail::col_mat_<OriginalVector>,qvm_detail::col_mat_<OriginalVector>,R,C>
+            {
+            typedef mat<typename vec_traits<OriginalVector>::scalar_type,R,C> type;
+            };
+
+        template <class A>
+        typename boost::enable_if_c<
+            is_vec<A>::value,
+            qvm_detail::col_mat_<A> const &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        col_mat( A const & a )
+            {
+            return reinterpret_cast<typename qvm_detail::col_mat_<A> const &>(a);
+            }
+
+        template <class A>
+        typename boost::enable_if_c<
+            is_vec<A>::value,
+            qvm_detail::col_mat_<A> &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        col_mat( A & a )
+            {
+            return reinterpret_cast<typename qvm_detail::col_mat_<A> &>(a);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class OriginalVector>
+            class
+            row_mat_
+                {
+                row_mat_( row_mat_ const & );
+                row_mat_ & operator=( row_mat_ const & );
+                ~row_mat_();
+
+                public:
+
+                template <class T>
+                BOOST_QVM_INLINE_TRIVIAL
+                row_mat_ &
+                operator=( T const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <class OriginalVector>
+        struct
+        mat_traits< qvm_detail::row_mat_<OriginalVector> >
+            {
+            typedef qvm_detail::row_mat_<OriginalVector> this_matrix;
+            typedef typename vec_traits<OriginalVector>::scalar_type scalar_type;
+            static int const rows=1;
+            static int const cols=vec_traits<OriginalVector>::dim;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row==0);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return vec_traits<OriginalVector>::template read_element<Col>(reinterpret_cast<OriginalVector const &>(x));
+                }
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_matrix & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row==0);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return vec_traits<OriginalVector>::template write_element<Col>(reinterpret_cast<OriginalVector &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row==0);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return vec_traits<OriginalVector>::read_element_idx(col,reinterpret_cast<OriginalVector const &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int row, int col, this_matrix & x )
+                {
+                BOOST_QVM_ASSERT(row==0);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return vec_traits<OriginalVector>::write_element_idx(col,reinterpret_cast<OriginalVector &>(x));
+                }
+            };
+
+        template <class OriginalVector,int R,int C>
+        struct
+        deduce_mat<qvm_detail::row_mat_<OriginalVector>,R,C>
+            {
+            typedef mat<typename vec_traits<OriginalVector>::scalar_type,R,C> type;
+            };
+
+        template <class OriginalVector,int R,int C>
+        struct
+        deduce_mat2<qvm_detail::row_mat_<OriginalVector>,qvm_detail::row_mat_<OriginalVector>,R,C>
+            {
+            typedef mat<typename vec_traits<OriginalVector>::scalar_type,R,C> type;
+            };
+
+        template <class A>
+        typename boost::enable_if_c<
+            is_vec<A>::value,
+            qvm_detail::row_mat_<A> const &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        row_mat( A const & a )
+            {
+            return reinterpret_cast<typename qvm_detail::row_mat_<A> const &>(a);
+            }
+
+        template <class A>
+        typename boost::enable_if_c<
+            is_vec<A>::value,
+            qvm_detail::row_mat_<A> &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        row_mat( A & a )
+            {
+            return reinterpret_cast<typename qvm_detail::row_mat_<A> &>(a);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class OriginalVector>
+            class
+            translation_mat_
+                {
+                translation_mat_( translation_mat_ const & );
+                translation_mat_ & operator=( translation_mat_ const & );
+                ~translation_mat_();
+
+                public:
+
+                template <class T>
+                BOOST_QVM_INLINE_TRIVIAL
+                translation_mat_ &
+                operator=( T const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+
+            template <class M,int Row,int Col,bool TransCol=(Col==mat_traits<M>::cols-1)>
+            struct read_translation_matat;
+
+            template <class OriginalVector,int Row,int Col,bool TransCol>
+            struct
+            read_translation_matat<translation_mat_<OriginalVector>,Row,Col,TransCol>
+                {
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                typename mat_traits< translation_mat_<OriginalVector> >::scalar_type
+                f( translation_mat_<OriginalVector> const & )
+                    {
+                    return scalar_traits<typename mat_traits< translation_mat_<OriginalVector> >::scalar_type>::value(0);
+                    }
+                };
+
+            template <class OriginalVector,int D>
+            struct
+            read_translation_matat<translation_mat_<OriginalVector>,D,D,false>
+                {
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                typename mat_traits< translation_mat_<OriginalVector> >::scalar_type
+                f( translation_mat_<OriginalVector> const & )
+                    {
+                    return scalar_traits<typename mat_traits< translation_mat_<OriginalVector> >::scalar_type>::value(1);
+                    }
+                };
+
+            template <class OriginalVector,int D>
+            struct
+            read_translation_matat<translation_mat_<OriginalVector>,D,D,true>
+                {
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                typename mat_traits< translation_mat_<OriginalVector> >::scalar_type
+                f( translation_mat_<OriginalVector> const & )
+                    {
+                    return scalar_traits<typename mat_traits< translation_mat_<OriginalVector> >::scalar_type>::value(1);
+                    }
+                };
+
+            template <class OriginalVector,int Row,int Col>
+            struct
+            read_translation_matat<translation_mat_<OriginalVector>,Row,Col,true>
+                {
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                typename mat_traits< translation_mat_<OriginalVector> >::scalar_type
+                f( translation_mat_<OriginalVector> const & x )
+                    {
+                    return vec_traits<OriginalVector>::template read_element<Row>(reinterpret_cast<OriginalVector const &>(x));
+                    }
+                };
+            }
+
+        template <class OriginalVector>
+        struct
+        mat_traits< qvm_detail::translation_mat_<OriginalVector> >
+            {
+            typedef qvm_detail::translation_mat_<OriginalVector> this_matrix;
+            typedef typename vec_traits<OriginalVector>::scalar_type scalar_type;
+            static int const rows=vec_traits<OriginalVector>::dim+1;
+            static int const cols=vec_traits<OriginalVector>::dim+1;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return qvm_detail::read_translation_matat<qvm_detail::translation_mat_<OriginalVector>,Row,Col>::f(x);
+                }
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_matrix & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col==cols-1);
+                BOOST_QVM_STATIC_ASSERT(Col!=Row);
+                return vec_traits<OriginalVector>::template write_element<Row>(reinterpret_cast<OriginalVector &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return
+                    row==col?
+                        scalar_traits<scalar_type>::value(1):
+                        (col==cols-1?
+                            vec_traits<OriginalVector>::read_element_idx(row,reinterpret_cast<OriginalVector const &>(x)):
+                            scalar_traits<scalar_type>::value(0));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col==cols-1);
+                BOOST_QVM_ASSERT(col!=row);
+                return vec_traits<OriginalVector>::write_element_idx(row,reinterpret_cast<OriginalVector &>(x));
+                }
+            };
+
+        template <class OriginalVector,int R,int C>
+        struct
+        deduce_mat<qvm_detail::translation_mat_<OriginalVector>,R,C>
+            {
+            typedef mat<typename vec_traits<OriginalVector>::scalar_type,R,C> type;
+            };
+
+        template <class OriginalVector,int R,int C>
+        struct
+        deduce_mat2<qvm_detail::translation_mat_<OriginalVector>,qvm_detail::translation_mat_<OriginalVector>,R,C>
+            {
+            typedef mat<typename vec_traits<OriginalVector>::scalar_type,R,C> type;
+            };
+
+        template <class A>
+        typename boost::enable_if_c<
+            is_vec<A>::value,
+            qvm_detail::translation_mat_<A> const &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        translation_mat( A const & a )
+            {
+            return reinterpret_cast<typename qvm_detail::translation_mat_<A> const &>(a);
+            }
+
+        template <class A>
+        typename boost::enable_if_c<
+            is_vec<A>::value,
+            qvm_detail::translation_mat_<A> &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        translation_mat( A & a )
+            {
+            return reinterpret_cast<typename qvm_detail::translation_mat_<A> &>(a);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class OriginalVector>
+            class
+            diag_mat_
+                {
+                diag_mat_( diag_mat_ const & );
+                diag_mat_ & operator=( diag_mat_ const & );
+                ~diag_mat_();
+
+                public:
+
+                template <class T>
+                BOOST_QVM_INLINE_TRIVIAL
+                diag_mat_ &
+                operator=( T const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <class OriginalVector>
+        struct
+        mat_traits< qvm_detail::diag_mat_<OriginalVector> >
+            {
+            typedef qvm_detail::diag_mat_<OriginalVector> this_matrix;
+            typedef typename vec_traits<OriginalVector>::scalar_type scalar_type;
+            static int const rows=vec_traits<OriginalVector>::dim;
+            static int const cols=vec_traits<OriginalVector>::dim;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return Row==Col?vec_traits<OriginalVector>::template read_element<Row>(reinterpret_cast<OriginalVector const &>(x)):scalar_traits<scalar_type>::value(0);
+                }
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_matrix & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Row==Col);
+                return vec_traits<OriginalVector>::template write_element<Row>(reinterpret_cast<OriginalVector &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return row==col?vec_traits<OriginalVector>::read_element_idx(row,reinterpret_cast<OriginalVector const &>(x)):scalar_traits<scalar_type>::value(0);
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int row, int col, this_matrix & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(row==col);
+                return vec_traits<OriginalVector>::write_element_idx(row,reinterpret_cast<OriginalVector &>(x));
+                }
+            };
+
+        template <class OriginalVector,int R,int C>
+        struct
+        deduce_mat<qvm_detail::diag_mat_<OriginalVector>,R,C>
+            {
+            typedef mat<typename vec_traits<OriginalVector>::scalar_type,R,C> type;
+            };
+
+        template <class OriginalVector,int R,int C>
+        struct
+        deduce_mat2<qvm_detail::diag_mat_<OriginalVector>,qvm_detail::diag_mat_<OriginalVector>,R,C>
+            {
+            typedef mat<typename vec_traits<OriginalVector>::scalar_type,R,C> type;
+            };
+
+        template <class A>
+        typename boost::enable_if_c<
+            is_vec<A>::value,
+            qvm_detail::diag_mat_<A> const &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        diag_mat( A const & a )
+            {
+            return reinterpret_cast<typename qvm_detail::diag_mat_<A> const &>(a);
+            }
+
+        template <class A>
+        typename boost::enable_if_c<
+            is_vec<A>::value,
+            qvm_detail::diag_mat_<A> &>::type
+        BOOST_QVM_INLINE_TRIVIAL
+        diag_mat( A & a )
+            {
+            return reinterpret_cast<typename qvm_detail::diag_mat_<A> &>(a);
+            }
+
+        ////////////////////////////////////////////////
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/mat.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/mat.hpp
new file mode 100644
index 00000000000..a3d44a96991
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/mat.hpp
@@ -0,0 +1,98 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_67E67D68A32F11DEA56FD18556D89593
+#define UUID_67E67D68A32F11DEA56FD18556D89593
+
+#include <boost/qvm/detail/mat_assign.hpp>
+#include <boost/qvm/assert.hpp>
+#include <boost/qvm/static_assert.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class T,int Rows,int Cols>
+        struct
+        mat
+            {
+            T a[Rows][Cols];
+            template <class R>
+            operator R() const
+                {
+                R r;
+                assign(r,*this);
+                return r;
+                }
+            };
+
+        template <class M>
+        struct mat_traits;
+
+        template <class T,int Rows,int Cols>
+        struct
+        mat_traits< mat<T,Rows,Cols> >
+            {
+            typedef mat<T,Rows,Cols> this_matrix;
+            typedef T scalar_type;
+            static int const rows=Rows;
+            static int const cols=Cols;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<Rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<Cols);
+                return x.a[Row][Col];
+                }
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_matrix & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<Rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<Cols);
+                return x.a[Row][Col];
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<Rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<Cols);
+                return x.a[row][col];
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int row, int col, this_matrix & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<Rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<Cols);
+                return x.a[row][col];
+                }
+            };
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/mat_access.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/mat_access.hpp
new file mode 100644
index 00000000000..a50ff66db25
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/mat_access.hpp
@@ -0,0 +1,258 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_47B1D1217B411E08424FA0ADFD72085
+#define UUID_47B1D1217B411E08424FA0ADFD72085
+
+#include <boost/qvm/mat_traits.hpp>
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/static_assert.hpp>
+#include <boost/qvm/enable_if.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        ////////////////////////////////////////////////
+
+        template <int R,int C,class M>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_mat<M>::value,
+            typename mat_traits<M>::scalar_type>::type
+        A( M const & a )
+            {
+            BOOST_STATIC_ASSERT(R>=0);
+            BOOST_STATIC_ASSERT(R<mat_traits<M>::rows);
+            BOOST_STATIC_ASSERT(C>=0);
+            BOOST_STATIC_ASSERT(C<mat_traits<M>::cols);
+            return mat_traits<M>::template read_element<R,C>(a);
+            }
+
+        template <int R,int C,class M>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_mat<M>::value,
+            typename mat_traits<M>::scalar_type &>::type
+        A( M & a )
+            {
+            BOOST_STATIC_ASSERT(R>=0);
+            BOOST_STATIC_ASSERT(R<mat_traits<M>::rows);
+            BOOST_STATIC_ASSERT(C>=0);
+            BOOST_STATIC_ASSERT(C<mat_traits<M>::cols);
+            return mat_traits<M>::template write_element<R,C>(a);
+            }
+
+        ////////////////////////////////////////////////
+
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A00( M const & a ) { BOOST_STATIC_ASSERT(0<mat_traits<M>::rows && 0<mat_traits<M>::cols); return mat_traits<M>::template read_element<0,0>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A01( M const & a ) { BOOST_STATIC_ASSERT(0<mat_traits<M>::rows && 1<mat_traits<M>::cols); return mat_traits<M>::template read_element<0,1>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A02( M const & a ) { BOOST_STATIC_ASSERT(0<mat_traits<M>::rows && 2<mat_traits<M>::cols); return mat_traits<M>::template read_element<0,2>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A03( M const & a ) { BOOST_STATIC_ASSERT(0<mat_traits<M>::rows && 3<mat_traits<M>::cols); return mat_traits<M>::template read_element<0,3>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A04( M const & a ) { BOOST_STATIC_ASSERT(0<mat_traits<M>::rows && 4<mat_traits<M>::cols); return mat_traits<M>::template read_element<0,4>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A05( M const & a ) { BOOST_STATIC_ASSERT(0<mat_traits<M>::rows && 5<mat_traits<M>::cols); return mat_traits<M>::template read_element<0,5>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A06( M const & a ) { BOOST_STATIC_ASSERT(0<mat_traits<M>::rows && 6<mat_traits<M>::cols); return mat_traits<M>::template read_element<0,6>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A07( M const & a ) { BOOST_STATIC_ASSERT(0<mat_traits<M>::rows && 7<mat_traits<M>::cols); return mat_traits<M>::template read_element<0,7>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A08( M const & a ) { BOOST_STATIC_ASSERT(0<mat_traits<M>::rows && 8<mat_traits<M>::cols); return mat_traits<M>::template read_element<0,8>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A09( M const & a ) { BOOST_STATIC_ASSERT(0<mat_traits<M>::rows && 9<mat_traits<M>::cols); return mat_traits<M>::template read_element<0,9>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A10( M const & a ) { BOOST_STATIC_ASSERT(1<mat_traits<M>::rows && 0<mat_traits<M>::cols); return mat_traits<M>::template read_element<1,0>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A11( M const & a ) { BOOST_STATIC_ASSERT(1<mat_traits<M>::rows && 1<mat_traits<M>::cols); return mat_traits<M>::template read_element<1,1>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A12( M const & a ) { BOOST_STATIC_ASSERT(1<mat_traits<M>::rows && 2<mat_traits<M>::cols); return mat_traits<M>::template read_element<1,2>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A13( M const & a ) { BOOST_STATIC_ASSERT(1<mat_traits<M>::rows && 3<mat_traits<M>::cols); return mat_traits<M>::template read_element<1,3>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A14( M const & a ) { BOOST_STATIC_ASSERT(1<mat_traits<M>::rows && 4<mat_traits<M>::cols); return mat_traits<M>::template read_element<1,4>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A15( M const & a ) { BOOST_STATIC_ASSERT(1<mat_traits<M>::rows && 5<mat_traits<M>::cols); return mat_traits<M>::template read_element<1,5>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A16( M const & a ) { BOOST_STATIC_ASSERT(1<mat_traits<M>::rows && 6<mat_traits<M>::cols); return mat_traits<M>::template read_element<1,6>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A17( M const & a ) { BOOST_STATIC_ASSERT(1<mat_traits<M>::rows && 7<mat_traits<M>::cols); return mat_traits<M>::template read_element<1,7>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A18( M const & a ) { BOOST_STATIC_ASSERT(1<mat_traits<M>::rows && 8<mat_traits<M>::cols); return mat_traits<M>::template read_element<1,8>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A19( M const & a ) { BOOST_STATIC_ASSERT(1<mat_traits<M>::rows && 9<mat_traits<M>::cols); return mat_traits<M>::template read_element<1,9>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A20( M const & a ) { BOOST_STATIC_ASSERT(2<mat_traits<M>::rows && 0<mat_traits<M>::cols); return mat_traits<M>::template read_element<2,0>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A21( M const & a ) { BOOST_STATIC_ASSERT(2<mat_traits<M>::rows && 1<mat_traits<M>::cols); return mat_traits<M>::template read_element<2,1>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A22( M const & a ) { BOOST_STATIC_ASSERT(2<mat_traits<M>::rows && 2<mat_traits<M>::cols); return mat_traits<M>::template read_element<2,2>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A23( M const & a ) { BOOST_STATIC_ASSERT(2<mat_traits<M>::rows && 3<mat_traits<M>::cols); return mat_traits<M>::template read_element<2,3>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A24( M const & a ) { BOOST_STATIC_ASSERT(2<mat_traits<M>::rows && 4<mat_traits<M>::cols); return mat_traits<M>::template read_element<2,4>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A25( M const & a ) { BOOST_STATIC_ASSERT(2<mat_traits<M>::rows && 5<mat_traits<M>::cols); return mat_traits<M>::template read_element<2,5>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A26( M const & a ) { BOOST_STATIC_ASSERT(2<mat_traits<M>::rows && 6<mat_traits<M>::cols); return mat_traits<M>::template read_element<2,6>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A27( M const & a ) { BOOST_STATIC_ASSERT(2<mat_traits<M>::rows && 7<mat_traits<M>::cols); return mat_traits<M>::template read_element<2,7>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A28( M const & a ) { BOOST_STATIC_ASSERT(2<mat_traits<M>::rows && 8<mat_traits<M>::cols); return mat_traits<M>::template read_element<2,8>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A29( M const & a ) { BOOST_STATIC_ASSERT(2<mat_traits<M>::rows && 9<mat_traits<M>::cols); return mat_traits<M>::template read_element<2,9>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A30( M const & a ) { BOOST_STATIC_ASSERT(3<mat_traits<M>::rows && 0<mat_traits<M>::cols); return mat_traits<M>::template read_element<3,0>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A31( M const & a ) { BOOST_STATIC_ASSERT(3<mat_traits<M>::rows && 1<mat_traits<M>::cols); return mat_traits<M>::template read_element<3,1>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A32( M const & a ) { BOOST_STATIC_ASSERT(3<mat_traits<M>::rows && 2<mat_traits<M>::cols); return mat_traits<M>::template read_element<3,2>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A33( M const & a ) { BOOST_STATIC_ASSERT(3<mat_traits<M>::rows && 3<mat_traits<M>::cols); return mat_traits<M>::template read_element<3,3>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A34( M const & a ) { BOOST_STATIC_ASSERT(3<mat_traits<M>::rows && 4<mat_traits<M>::cols); return mat_traits<M>::template read_element<3,4>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A35( M const & a ) { BOOST_STATIC_ASSERT(3<mat_traits<M>::rows && 5<mat_traits<M>::cols); return mat_traits<M>::template read_element<3,5>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A36( M const & a ) { BOOST_STATIC_ASSERT(3<mat_traits<M>::rows && 6<mat_traits<M>::cols); return mat_traits<M>::template read_element<3,6>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A37( M const & a ) { BOOST_STATIC_ASSERT(3<mat_traits<M>::rows && 7<mat_traits<M>::cols); return mat_traits<M>::template read_element<3,7>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A38( M const & a ) { BOOST_STATIC_ASSERT(3<mat_traits<M>::rows && 8<mat_traits<M>::cols); return mat_traits<M>::template read_element<3,8>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A39( M const & a ) { BOOST_STATIC_ASSERT(3<mat_traits<M>::rows && 9<mat_traits<M>::cols); return mat_traits<M>::template read_element<3,9>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A40( M const & a ) { BOOST_STATIC_ASSERT(4<mat_traits<M>::rows && 0<mat_traits<M>::cols); return mat_traits<M>::template read_element<4,0>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A41( M const & a ) { BOOST_STATIC_ASSERT(4<mat_traits<M>::rows && 1<mat_traits<M>::cols); return mat_traits<M>::template read_element<4,1>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A42( M const & a ) { BOOST_STATIC_ASSERT(4<mat_traits<M>::rows && 2<mat_traits<M>::cols); return mat_traits<M>::template read_element<4,2>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A43( M const & a ) { BOOST_STATIC_ASSERT(4<mat_traits<M>::rows && 3<mat_traits<M>::cols); return mat_traits<M>::template read_element<4,3>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A44( M const & a ) { BOOST_STATIC_ASSERT(4<mat_traits<M>::rows && 4<mat_traits<M>::cols); return mat_traits<M>::template read_element<4,4>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A45( M const & a ) { BOOST_STATIC_ASSERT(4<mat_traits<M>::rows && 5<mat_traits<M>::cols); return mat_traits<M>::template read_element<4,5>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A46( M const & a ) { BOOST_STATIC_ASSERT(4<mat_traits<M>::rows && 6<mat_traits<M>::cols); return mat_traits<M>::template read_element<4,6>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A47( M const & a ) { BOOST_STATIC_ASSERT(4<mat_traits<M>::rows && 7<mat_traits<M>::cols); return mat_traits<M>::template read_element<4,7>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A48( M const & a ) { BOOST_STATIC_ASSERT(4<mat_traits<M>::rows && 8<mat_traits<M>::cols); return mat_traits<M>::template read_element<4,8>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A49( M const & a ) { BOOST_STATIC_ASSERT(4<mat_traits<M>::rows && 9<mat_traits<M>::cols); return mat_traits<M>::template read_element<4,9>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A50( M const & a ) { BOOST_STATIC_ASSERT(5<mat_traits<M>::rows && 0<mat_traits<M>::cols); return mat_traits<M>::template read_element<5,0>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A51( M const & a ) { BOOST_STATIC_ASSERT(5<mat_traits<M>::rows && 1<mat_traits<M>::cols); return mat_traits<M>::template read_element<5,1>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A52( M const & a ) { BOOST_STATIC_ASSERT(5<mat_traits<M>::rows && 2<mat_traits<M>::cols); return mat_traits<M>::template read_element<5,2>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A53( M const & a ) { BOOST_STATIC_ASSERT(5<mat_traits<M>::rows && 3<mat_traits<M>::cols); return mat_traits<M>::template read_element<5,3>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A54( M const & a ) { BOOST_STATIC_ASSERT(5<mat_traits<M>::rows && 4<mat_traits<M>::cols); return mat_traits<M>::template read_element<5,4>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A55( M const & a ) { BOOST_STATIC_ASSERT(5<mat_traits<M>::rows && 5<mat_traits<M>::cols); return mat_traits<M>::template read_element<5,5>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A56( M const & a ) { BOOST_STATIC_ASSERT(5<mat_traits<M>::rows && 6<mat_traits<M>::cols); return mat_traits<M>::template read_element<5,6>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A57( M const & a ) { BOOST_STATIC_ASSERT(5<mat_traits<M>::rows && 7<mat_traits<M>::cols); return mat_traits<M>::template read_element<5,7>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A58( M const & a ) { BOOST_STATIC_ASSERT(5<mat_traits<M>::rows && 8<mat_traits<M>::cols); return mat_traits<M>::template read_element<5,8>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A59( M const & a ) { BOOST_STATIC_ASSERT(5<mat_traits<M>::rows && 9<mat_traits<M>::cols); return mat_traits<M>::template read_element<5,9>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A60( M const & a ) { BOOST_STATIC_ASSERT(6<mat_traits<M>::rows && 0<mat_traits<M>::cols); return mat_traits<M>::template read_element<6,0>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A61( M const & a ) { BOOST_STATIC_ASSERT(6<mat_traits<M>::rows && 1<mat_traits<M>::cols); return mat_traits<M>::template read_element<6,1>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A62( M const & a ) { BOOST_STATIC_ASSERT(6<mat_traits<M>::rows && 2<mat_traits<M>::cols); return mat_traits<M>::template read_element<6,2>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A63( M const & a ) { BOOST_STATIC_ASSERT(6<mat_traits<M>::rows && 3<mat_traits<M>::cols); return mat_traits<M>::template read_element<6,3>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A64( M const & a ) { BOOST_STATIC_ASSERT(6<mat_traits<M>::rows && 4<mat_traits<M>::cols); return mat_traits<M>::template read_element<6,4>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A65( M const & a ) { BOOST_STATIC_ASSERT(6<mat_traits<M>::rows && 5<mat_traits<M>::cols); return mat_traits<M>::template read_element<6,5>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A66( M const & a ) { BOOST_STATIC_ASSERT(6<mat_traits<M>::rows && 6<mat_traits<M>::cols); return mat_traits<M>::template read_element<6,6>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A67( M const & a ) { BOOST_STATIC_ASSERT(6<mat_traits<M>::rows && 7<mat_traits<M>::cols); return mat_traits<M>::template read_element<6,7>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A68( M const & a ) { BOOST_STATIC_ASSERT(6<mat_traits<M>::rows && 8<mat_traits<M>::cols); return mat_traits<M>::template read_element<6,8>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A69( M const & a ) { BOOST_STATIC_ASSERT(6<mat_traits<M>::rows && 9<mat_traits<M>::cols); return mat_traits<M>::template read_element<6,9>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A70( M const & a ) { BOOST_STATIC_ASSERT(7<mat_traits<M>::rows && 0<mat_traits<M>::cols); return mat_traits<M>::template read_element<7,0>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A71( M const & a ) { BOOST_STATIC_ASSERT(7<mat_traits<M>::rows && 1<mat_traits<M>::cols); return mat_traits<M>::template read_element<7,1>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A72( M const & a ) { BOOST_STATIC_ASSERT(7<mat_traits<M>::rows && 2<mat_traits<M>::cols); return mat_traits<M>::template read_element<7,2>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A73( M const & a ) { BOOST_STATIC_ASSERT(7<mat_traits<M>::rows && 3<mat_traits<M>::cols); return mat_traits<M>::template read_element<7,3>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A74( M const & a ) { BOOST_STATIC_ASSERT(7<mat_traits<M>::rows && 4<mat_traits<M>::cols); return mat_traits<M>::template read_element<7,4>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A75( M const & a ) { BOOST_STATIC_ASSERT(7<mat_traits<M>::rows && 5<mat_traits<M>::cols); return mat_traits<M>::template read_element<7,5>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A76( M const & a ) { BOOST_STATIC_ASSERT(7<mat_traits<M>::rows && 6<mat_traits<M>::cols); return mat_traits<M>::template read_element<7,6>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A77( M const & a ) { BOOST_STATIC_ASSERT(7<mat_traits<M>::rows && 7<mat_traits<M>::cols); return mat_traits<M>::template read_element<7,7>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A78( M const & a ) { BOOST_STATIC_ASSERT(7<mat_traits<M>::rows && 8<mat_traits<M>::cols); return mat_traits<M>::template read_element<7,8>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A79( M const & a ) { BOOST_STATIC_ASSERT(7<mat_traits<M>::rows && 9<mat_traits<M>::cols); return mat_traits<M>::template read_element<7,9>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A80( M const & a ) { BOOST_STATIC_ASSERT(8<mat_traits<M>::rows && 0<mat_traits<M>::cols); return mat_traits<M>::template read_element<8,0>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A81( M const & a ) { BOOST_STATIC_ASSERT(8<mat_traits<M>::rows && 1<mat_traits<M>::cols); return mat_traits<M>::template read_element<8,1>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A82( M const & a ) { BOOST_STATIC_ASSERT(8<mat_traits<M>::rows && 2<mat_traits<M>::cols); return mat_traits<M>::template read_element<8,2>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A83( M const & a ) { BOOST_STATIC_ASSERT(8<mat_traits<M>::rows && 3<mat_traits<M>::cols); return mat_traits<M>::template read_element<8,3>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A84( M const & a ) { BOOST_STATIC_ASSERT(8<mat_traits<M>::rows && 4<mat_traits<M>::cols); return mat_traits<M>::template read_element<8,4>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A85( M const & a ) { BOOST_STATIC_ASSERT(8<mat_traits<M>::rows && 5<mat_traits<M>::cols); return mat_traits<M>::template read_element<8,5>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A86( M const & a ) { BOOST_STATIC_ASSERT(8<mat_traits<M>::rows && 6<mat_traits<M>::cols); return mat_traits<M>::template read_element<8,6>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A87( M const & a ) { BOOST_STATIC_ASSERT(8<mat_traits<M>::rows && 7<mat_traits<M>::cols); return mat_traits<M>::template read_element<8,7>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A88( M const & a ) { BOOST_STATIC_ASSERT(8<mat_traits<M>::rows && 8<mat_traits<M>::cols); return mat_traits<M>::template read_element<8,8>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A89( M const & a ) { BOOST_STATIC_ASSERT(8<mat_traits<M>::rows && 9<mat_traits<M>::cols); return mat_traits<M>::template read_element<8,9>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A90( M const & a ) { BOOST_STATIC_ASSERT(9<mat_traits<M>::rows && 0<mat_traits<M>::cols); return mat_traits<M>::template read_element<9,0>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A91( M const & a ) { BOOST_STATIC_ASSERT(9<mat_traits<M>::rows && 1<mat_traits<M>::cols); return mat_traits<M>::template read_element<9,1>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A92( M const & a ) { BOOST_STATIC_ASSERT(9<mat_traits<M>::rows && 2<mat_traits<M>::cols); return mat_traits<M>::template read_element<9,2>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A93( M const & a ) { BOOST_STATIC_ASSERT(9<mat_traits<M>::rows && 3<mat_traits<M>::cols); return mat_traits<M>::template read_element<9,3>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A94( M const & a ) { BOOST_STATIC_ASSERT(9<mat_traits<M>::rows && 4<mat_traits<M>::cols); return mat_traits<M>::template read_element<9,4>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A95( M const & a ) { BOOST_STATIC_ASSERT(9<mat_traits<M>::rows && 5<mat_traits<M>::cols); return mat_traits<M>::template read_element<9,5>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A96( M const & a ) { BOOST_STATIC_ASSERT(9<mat_traits<M>::rows && 6<mat_traits<M>::cols); return mat_traits<M>::template read_element<9,6>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A97( M const & a ) { BOOST_STATIC_ASSERT(9<mat_traits<M>::rows && 7<mat_traits<M>::cols); return mat_traits<M>::template read_element<9,7>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A98( M const & a ) { BOOST_STATIC_ASSERT(9<mat_traits<M>::rows && 8<mat_traits<M>::cols); return mat_traits<M>::template read_element<9,8>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type>::type A99( M const & a ) { BOOST_STATIC_ASSERT(9<mat_traits<M>::rows && 9<mat_traits<M>::cols); return mat_traits<M>::template read_element<9,9>(a); }
+
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A00( M & a ) { BOOST_STATIC_ASSERT(0<mat_traits<M>::rows && 0<mat_traits<M>::cols); return mat_traits<M>::template write_element<0,0>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A01( M & a ) { BOOST_STATIC_ASSERT(0<mat_traits<M>::rows && 1<mat_traits<M>::cols); return mat_traits<M>::template write_element<0,1>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A02( M & a ) { BOOST_STATIC_ASSERT(0<mat_traits<M>::rows && 2<mat_traits<M>::cols); return mat_traits<M>::template write_element<0,2>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A03( M & a ) { BOOST_STATIC_ASSERT(0<mat_traits<M>::rows && 3<mat_traits<M>::cols); return mat_traits<M>::template write_element<0,3>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A04( M & a ) { BOOST_STATIC_ASSERT(0<mat_traits<M>::rows && 4<mat_traits<M>::cols); return mat_traits<M>::template write_element<0,4>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A05( M & a ) { BOOST_STATIC_ASSERT(0<mat_traits<M>::rows && 5<mat_traits<M>::cols); return mat_traits<M>::template write_element<0,5>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A06( M & a ) { BOOST_STATIC_ASSERT(0<mat_traits<M>::rows && 6<mat_traits<M>::cols); return mat_traits<M>::template write_element<0,6>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A07( M & a ) { BOOST_STATIC_ASSERT(0<mat_traits<M>::rows && 7<mat_traits<M>::cols); return mat_traits<M>::template write_element<0,7>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A08( M & a ) { BOOST_STATIC_ASSERT(0<mat_traits<M>::rows && 8<mat_traits<M>::cols); return mat_traits<M>::template write_element<0,8>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A09( M & a ) { BOOST_STATIC_ASSERT(0<mat_traits<M>::rows && 9<mat_traits<M>::cols); return mat_traits<M>::template write_element<0,9>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A10( M & a ) { BOOST_STATIC_ASSERT(1<mat_traits<M>::rows && 0<mat_traits<M>::cols); return mat_traits<M>::template write_element<1,0>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A11( M & a ) { BOOST_STATIC_ASSERT(1<mat_traits<M>::rows && 1<mat_traits<M>::cols); return mat_traits<M>::template write_element<1,1>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A12( M & a ) { BOOST_STATIC_ASSERT(1<mat_traits<M>::rows && 2<mat_traits<M>::cols); return mat_traits<M>::template write_element<1,2>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A13( M & a ) { BOOST_STATIC_ASSERT(1<mat_traits<M>::rows && 3<mat_traits<M>::cols); return mat_traits<M>::template write_element<1,3>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A14( M & a ) { BOOST_STATIC_ASSERT(1<mat_traits<M>::rows && 4<mat_traits<M>::cols); return mat_traits<M>::template write_element<1,4>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A15( M & a ) { BOOST_STATIC_ASSERT(1<mat_traits<M>::rows && 5<mat_traits<M>::cols); return mat_traits<M>::template write_element<1,5>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A16( M & a ) { BOOST_STATIC_ASSERT(1<mat_traits<M>::rows && 6<mat_traits<M>::cols); return mat_traits<M>::template write_element<1,6>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A17( M & a ) { BOOST_STATIC_ASSERT(1<mat_traits<M>::rows && 7<mat_traits<M>::cols); return mat_traits<M>::template write_element<1,7>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A18( M & a ) { BOOST_STATIC_ASSERT(1<mat_traits<M>::rows && 8<mat_traits<M>::cols); return mat_traits<M>::template write_element<1,8>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A19( M & a ) { BOOST_STATIC_ASSERT(1<mat_traits<M>::rows && 9<mat_traits<M>::cols); return mat_traits<M>::template write_element<1,9>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A20( M & a ) { BOOST_STATIC_ASSERT(2<mat_traits<M>::rows && 0<mat_traits<M>::cols); return mat_traits<M>::template write_element<2,0>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A21( M & a ) { BOOST_STATIC_ASSERT(2<mat_traits<M>::rows && 1<mat_traits<M>::cols); return mat_traits<M>::template write_element<2,1>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A22( M & a ) { BOOST_STATIC_ASSERT(2<mat_traits<M>::rows && 2<mat_traits<M>::cols); return mat_traits<M>::template write_element<2,2>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A23( M & a ) { BOOST_STATIC_ASSERT(2<mat_traits<M>::rows && 3<mat_traits<M>::cols); return mat_traits<M>::template write_element<2,3>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A24( M & a ) { BOOST_STATIC_ASSERT(2<mat_traits<M>::rows && 4<mat_traits<M>::cols); return mat_traits<M>::template write_element<2,4>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A25( M & a ) { BOOST_STATIC_ASSERT(2<mat_traits<M>::rows && 5<mat_traits<M>::cols); return mat_traits<M>::template write_element<2,5>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A26( M & a ) { BOOST_STATIC_ASSERT(2<mat_traits<M>::rows && 6<mat_traits<M>::cols); return mat_traits<M>::template write_element<2,6>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A27( M & a ) { BOOST_STATIC_ASSERT(2<mat_traits<M>::rows && 7<mat_traits<M>::cols); return mat_traits<M>::template write_element<2,7>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A28( M & a ) { BOOST_STATIC_ASSERT(2<mat_traits<M>::rows && 8<mat_traits<M>::cols); return mat_traits<M>::template write_element<2,8>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A29( M & a ) { BOOST_STATIC_ASSERT(2<mat_traits<M>::rows && 9<mat_traits<M>::cols); return mat_traits<M>::template write_element<2,9>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A30( M & a ) { BOOST_STATIC_ASSERT(3<mat_traits<M>::rows && 0<mat_traits<M>::cols); return mat_traits<M>::template write_element<3,0>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A31( M & a ) { BOOST_STATIC_ASSERT(3<mat_traits<M>::rows && 1<mat_traits<M>::cols); return mat_traits<M>::template write_element<3,1>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A32( M & a ) { BOOST_STATIC_ASSERT(3<mat_traits<M>::rows && 2<mat_traits<M>::cols); return mat_traits<M>::template write_element<3,2>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A33( M & a ) { BOOST_STATIC_ASSERT(3<mat_traits<M>::rows && 3<mat_traits<M>::cols); return mat_traits<M>::template write_element<3,3>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A34( M & a ) { BOOST_STATIC_ASSERT(3<mat_traits<M>::rows && 4<mat_traits<M>::cols); return mat_traits<M>::template write_element<3,4>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A35( M & a ) { BOOST_STATIC_ASSERT(3<mat_traits<M>::rows && 5<mat_traits<M>::cols); return mat_traits<M>::template write_element<3,5>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A36( M & a ) { BOOST_STATIC_ASSERT(3<mat_traits<M>::rows && 6<mat_traits<M>::cols); return mat_traits<M>::template write_element<3,6>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A37( M & a ) { BOOST_STATIC_ASSERT(3<mat_traits<M>::rows && 7<mat_traits<M>::cols); return mat_traits<M>::template write_element<3,7>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A38( M & a ) { BOOST_STATIC_ASSERT(3<mat_traits<M>::rows && 8<mat_traits<M>::cols); return mat_traits<M>::template write_element<3,8>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A39( M & a ) { BOOST_STATIC_ASSERT(3<mat_traits<M>::rows && 9<mat_traits<M>::cols); return mat_traits<M>::template write_element<3,9>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A40( M & a ) { BOOST_STATIC_ASSERT(4<mat_traits<M>::rows && 0<mat_traits<M>::cols); return mat_traits<M>::template write_element<4,0>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A41( M & a ) { BOOST_STATIC_ASSERT(4<mat_traits<M>::rows && 1<mat_traits<M>::cols); return mat_traits<M>::template write_element<4,1>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A42( M & a ) { BOOST_STATIC_ASSERT(4<mat_traits<M>::rows && 2<mat_traits<M>::cols); return mat_traits<M>::template write_element<4,2>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A43( M & a ) { BOOST_STATIC_ASSERT(4<mat_traits<M>::rows && 3<mat_traits<M>::cols); return mat_traits<M>::template write_element<4,3>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A44( M & a ) { BOOST_STATIC_ASSERT(4<mat_traits<M>::rows && 4<mat_traits<M>::cols); return mat_traits<M>::template write_element<4,4>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A45( M & a ) { BOOST_STATIC_ASSERT(4<mat_traits<M>::rows && 5<mat_traits<M>::cols); return mat_traits<M>::template write_element<4,5>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A46( M & a ) { BOOST_STATIC_ASSERT(4<mat_traits<M>::rows && 6<mat_traits<M>::cols); return mat_traits<M>::template write_element<4,6>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A47( M & a ) { BOOST_STATIC_ASSERT(4<mat_traits<M>::rows && 7<mat_traits<M>::cols); return mat_traits<M>::template write_element<4,7>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A48( M & a ) { BOOST_STATIC_ASSERT(4<mat_traits<M>::rows && 8<mat_traits<M>::cols); return mat_traits<M>::template write_element<4,8>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A49( M & a ) { BOOST_STATIC_ASSERT(4<mat_traits<M>::rows && 9<mat_traits<M>::cols); return mat_traits<M>::template write_element<4,9>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A50( M & a ) { BOOST_STATIC_ASSERT(5<mat_traits<M>::rows && 0<mat_traits<M>::cols); return mat_traits<M>::template write_element<5,0>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A51( M & a ) { BOOST_STATIC_ASSERT(5<mat_traits<M>::rows && 1<mat_traits<M>::cols); return mat_traits<M>::template write_element<5,1>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A52( M & a ) { BOOST_STATIC_ASSERT(5<mat_traits<M>::rows && 2<mat_traits<M>::cols); return mat_traits<M>::template write_element<5,2>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A53( M & a ) { BOOST_STATIC_ASSERT(5<mat_traits<M>::rows && 3<mat_traits<M>::cols); return mat_traits<M>::template write_element<5,3>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A54( M & a ) { BOOST_STATIC_ASSERT(5<mat_traits<M>::rows && 4<mat_traits<M>::cols); return mat_traits<M>::template write_element<5,4>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A55( M & a ) { BOOST_STATIC_ASSERT(5<mat_traits<M>::rows && 5<mat_traits<M>::cols); return mat_traits<M>::template write_element<5,5>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A56( M & a ) { BOOST_STATIC_ASSERT(5<mat_traits<M>::rows && 6<mat_traits<M>::cols); return mat_traits<M>::template write_element<5,6>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A57( M & a ) { BOOST_STATIC_ASSERT(5<mat_traits<M>::rows && 7<mat_traits<M>::cols); return mat_traits<M>::template write_element<5,7>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A58( M & a ) { BOOST_STATIC_ASSERT(5<mat_traits<M>::rows && 8<mat_traits<M>::cols); return mat_traits<M>::template write_element<5,8>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A59( M & a ) { BOOST_STATIC_ASSERT(5<mat_traits<M>::rows && 9<mat_traits<M>::cols); return mat_traits<M>::template write_element<5,9>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A60( M & a ) { BOOST_STATIC_ASSERT(6<mat_traits<M>::rows && 0<mat_traits<M>::cols); return mat_traits<M>::template write_element<6,0>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A61( M & a ) { BOOST_STATIC_ASSERT(6<mat_traits<M>::rows && 1<mat_traits<M>::cols); return mat_traits<M>::template write_element<6,1>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A62( M & a ) { BOOST_STATIC_ASSERT(6<mat_traits<M>::rows && 2<mat_traits<M>::cols); return mat_traits<M>::template write_element<6,2>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A63( M & a ) { BOOST_STATIC_ASSERT(6<mat_traits<M>::rows && 3<mat_traits<M>::cols); return mat_traits<M>::template write_element<6,3>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A64( M & a ) { BOOST_STATIC_ASSERT(6<mat_traits<M>::rows && 4<mat_traits<M>::cols); return mat_traits<M>::template write_element<6,4>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A65( M & a ) { BOOST_STATIC_ASSERT(6<mat_traits<M>::rows && 5<mat_traits<M>::cols); return mat_traits<M>::template write_element<6,5>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A66( M & a ) { BOOST_STATIC_ASSERT(6<mat_traits<M>::rows && 6<mat_traits<M>::cols); return mat_traits<M>::template write_element<6,6>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A67( M & a ) { BOOST_STATIC_ASSERT(6<mat_traits<M>::rows && 7<mat_traits<M>::cols); return mat_traits<M>::template write_element<6,7>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A68( M & a ) { BOOST_STATIC_ASSERT(6<mat_traits<M>::rows && 8<mat_traits<M>::cols); return mat_traits<M>::template write_element<6,8>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A69( M & a ) { BOOST_STATIC_ASSERT(6<mat_traits<M>::rows && 9<mat_traits<M>::cols); return mat_traits<M>::template write_element<6,9>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A70( M & a ) { BOOST_STATIC_ASSERT(7<mat_traits<M>::rows && 0<mat_traits<M>::cols); return mat_traits<M>::template write_element<7,0>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A71( M & a ) { BOOST_STATIC_ASSERT(7<mat_traits<M>::rows && 1<mat_traits<M>::cols); return mat_traits<M>::template write_element<7,1>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A72( M & a ) { BOOST_STATIC_ASSERT(7<mat_traits<M>::rows && 2<mat_traits<M>::cols); return mat_traits<M>::template write_element<7,2>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A73( M & a ) { BOOST_STATIC_ASSERT(7<mat_traits<M>::rows && 3<mat_traits<M>::cols); return mat_traits<M>::template write_element<7,3>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A74( M & a ) { BOOST_STATIC_ASSERT(7<mat_traits<M>::rows && 4<mat_traits<M>::cols); return mat_traits<M>::template write_element<7,4>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A75( M & a ) { BOOST_STATIC_ASSERT(7<mat_traits<M>::rows && 5<mat_traits<M>::cols); return mat_traits<M>::template write_element<7,5>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A76( M & a ) { BOOST_STATIC_ASSERT(7<mat_traits<M>::rows && 6<mat_traits<M>::cols); return mat_traits<M>::template write_element<7,6>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A77( M & a ) { BOOST_STATIC_ASSERT(7<mat_traits<M>::rows && 7<mat_traits<M>::cols); return mat_traits<M>::template write_element<7,7>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A78( M & a ) { BOOST_STATIC_ASSERT(7<mat_traits<M>::rows && 8<mat_traits<M>::cols); return mat_traits<M>::template write_element<7,8>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A79( M & a ) { BOOST_STATIC_ASSERT(7<mat_traits<M>::rows && 9<mat_traits<M>::cols); return mat_traits<M>::template write_element<7,9>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A80( M & a ) { BOOST_STATIC_ASSERT(8<mat_traits<M>::rows && 0<mat_traits<M>::cols); return mat_traits<M>::template write_element<8,0>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A81( M & a ) { BOOST_STATIC_ASSERT(8<mat_traits<M>::rows && 1<mat_traits<M>::cols); return mat_traits<M>::template write_element<8,1>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A82( M & a ) { BOOST_STATIC_ASSERT(8<mat_traits<M>::rows && 2<mat_traits<M>::cols); return mat_traits<M>::template write_element<8,2>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A83( M & a ) { BOOST_STATIC_ASSERT(8<mat_traits<M>::rows && 3<mat_traits<M>::cols); return mat_traits<M>::template write_element<8,3>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A84( M & a ) { BOOST_STATIC_ASSERT(8<mat_traits<M>::rows && 4<mat_traits<M>::cols); return mat_traits<M>::template write_element<8,4>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A85( M & a ) { BOOST_STATIC_ASSERT(8<mat_traits<M>::rows && 5<mat_traits<M>::cols); return mat_traits<M>::template write_element<8,5>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A86( M & a ) { BOOST_STATIC_ASSERT(8<mat_traits<M>::rows && 6<mat_traits<M>::cols); return mat_traits<M>::template write_element<8,6>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A87( M & a ) { BOOST_STATIC_ASSERT(8<mat_traits<M>::rows && 7<mat_traits<M>::cols); return mat_traits<M>::template write_element<8,7>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A88( M & a ) { BOOST_STATIC_ASSERT(8<mat_traits<M>::rows && 8<mat_traits<M>::cols); return mat_traits<M>::template write_element<8,8>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A89( M & a ) { BOOST_STATIC_ASSERT(8<mat_traits<M>::rows && 9<mat_traits<M>::cols); return mat_traits<M>::template write_element<8,9>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A90( M & a ) { BOOST_STATIC_ASSERT(9<mat_traits<M>::rows && 0<mat_traits<M>::cols); return mat_traits<M>::template write_element<9,0>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A91( M & a ) { BOOST_STATIC_ASSERT(9<mat_traits<M>::rows && 1<mat_traits<M>::cols); return mat_traits<M>::template write_element<9,1>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A92( M & a ) { BOOST_STATIC_ASSERT(9<mat_traits<M>::rows && 2<mat_traits<M>::cols); return mat_traits<M>::template write_element<9,2>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A93( M & a ) { BOOST_STATIC_ASSERT(9<mat_traits<M>::rows && 3<mat_traits<M>::cols); return mat_traits<M>::template write_element<9,3>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A94( M & a ) { BOOST_STATIC_ASSERT(9<mat_traits<M>::rows && 4<mat_traits<M>::cols); return mat_traits<M>::template write_element<9,4>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A95( M & a ) { BOOST_STATIC_ASSERT(9<mat_traits<M>::rows && 5<mat_traits<M>::cols); return mat_traits<M>::template write_element<9,5>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A96( M & a ) { BOOST_STATIC_ASSERT(9<mat_traits<M>::rows && 6<mat_traits<M>::cols); return mat_traits<M>::template write_element<9,6>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A97( M & a ) { BOOST_STATIC_ASSERT(9<mat_traits<M>::rows && 7<mat_traits<M>::cols); return mat_traits<M>::template write_element<9,7>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A98( M & a ) { BOOST_STATIC_ASSERT(9<mat_traits<M>::rows && 8<mat_traits<M>::cols); return mat_traits<M>::template write_element<9,8>(a); }
+        template <class M> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_mat<M>::value,typename mat_traits<M>::scalar_type &>::type A99( M & a ) { BOOST_STATIC_ASSERT(9<mat_traits<M>::rows && 9<mat_traits<M>::cols); return mat_traits<M>::template write_element<9,9>(a); }
+
+        ////////////////////////////////////////////////
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/mat_operations.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/mat_operations.hpp
new file mode 100644
index 00000000000..ccd36129226
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/mat_operations.hpp
@@ -0,0 +1,1936 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_4F915D9ED30A11DF962186E3DFD72085
+#define UUID_4F915D9ED30A11DF962186E3DFD72085
+
+#include <boost/qvm/detail/mat_assign.hpp>
+#include <boost/qvm/mat_operations2.hpp>
+#include <boost/qvm/mat_operations3.hpp>
+#include <boost/qvm/mat_operations4.hpp>
+#include <boost/qvm/math.hpp>
+#include <boost/qvm/detail/determinant_impl.hpp>
+#include <boost/qvm/detail/cofactor_impl.hpp>
+#include <boost/qvm/detail/transp_impl.hpp>
+#include <boost/qvm/scalar_traits.hpp>
+#include <string>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        namespace
+        qvm_detail
+            {
+            BOOST_QVM_INLINE_CRITICAL
+            void const *
+            get_valid_ptr_mat_operations()
+                {
+                static int const obj=0;
+                return &obj;
+                }
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_to_string_detail
+            {
+            template <class T>
+            std::string to_string( T const & x );
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int C>
+            struct
+            to_string_m_defined
+                {
+                static bool const value=false;
+                };
+
+            template <int I,int SizeMinusOne>
+            struct
+            to_string_matrix_elements
+                {
+                template <class A>
+                static
+                std::string
+                f( A const & a )
+                    {
+                    using namespace qvm_to_string_detail;
+                    return
+                        ( (I%mat_traits<A>::cols)==0 ? '(' : ',' ) +
+                        to_string(mat_traits<A>::template read_element<I/mat_traits<A>::cols,I%mat_traits<A>::cols>(a)) +
+                        ( (I%mat_traits<A>::cols)==mat_traits<A>::cols-1 ? ")" : "" ) +
+                        to_string_matrix_elements<I+1,SizeMinusOne>::f(a);
+                    }
+                };
+
+            template <int SizeMinusOne>
+            struct
+            to_string_matrix_elements<SizeMinusOne,SizeMinusOne>
+                {
+                template <class A>
+                static
+                std::string
+                f( A const & a )
+                    {
+                    using namespace qvm_to_string_detail;
+                    return
+                        ( (SizeMinusOne%mat_traits<A>::cols)==0 ? '(' : ',' ) +
+                        to_string(mat_traits<A>::template read_element<SizeMinusOne/mat_traits<A>::cols,SizeMinusOne%mat_traits<A>::cols>(a)) +
+                        ')';
+                    }
+                };
+            }
+
+        template <class A>
+        inline
+        typename boost::enable_if_c<
+            is_mat<A>::value  &&
+            !qvm_detail::to_string_m_defined<mat_traits<A>::rows,mat_traits<A>::cols>::value,
+            std::string>::type
+        to_string( A const & a )
+            {
+            return "("+qvm_detail::to_string_matrix_elements<0,mat_traits<A>::rows*mat_traits<A>::cols-1>::f(a)+')';
+            }
+
+        ////////////////////////////////////////////////
+
+        template <class A,class B,class Cmp>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_mat<A>::value && is_mat<B>::value &&
+            mat_traits<A>::rows==mat_traits<B>::rows &&
+            mat_traits<A>::cols==mat_traits<B>::cols,
+            bool>::type
+        cmp( A const & a, B const & b, Cmp f )
+            {
+            typedef typename deduce_scalar<
+                typename mat_traits<A>::scalar_type,
+                typename mat_traits<B>::scalar_type>::type T;
+            int const rows=mat_traits<A>::rows;
+            int const cols=mat_traits<A>::cols;
+            T m1[rows][cols]; assign(m1,a);
+            T m2[rows][cols]; assign(m2,b);
+            for( int i=0; i!=rows; ++i )
+                for( int j=0; j!=cols; ++j )
+                    if( !f(m1[i][j],m2[i][j]) )
+                        return false;
+            return true;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int M,int N>
+            struct
+            convert_to_m_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class R,class A>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_mat<R>::value && is_mat<A>::value &&
+            mat_traits<R>::rows==mat_traits<A>::rows &&
+            mat_traits<R>::cols==mat_traits<A>::cols &&
+            !qvm_detail::convert_to_m_defined<mat_traits<A>::rows,mat_traits<A>::cols>::value,
+            R>::type
+        convert_to( A const & a )
+            {
+            R r; assign(r,a);
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            determinant_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_mat<A>::value &&
+            mat_traits<A>::rows==mat_traits<A>::cols &&
+            !qvm_detail::determinant_defined<mat_traits<A>::rows>::value,
+            typename mat_traits<A>::scalar_type>::type
+        determinant( A const & a )
+            {
+            return qvm_detail::determinant_impl(a);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class T,int Dim>
+            class
+            identity_mat_
+                {
+                identity_mat_( identity_mat_ const & );
+                identity_mat_ & operator=( identity_mat_ const & );
+                ~identity_mat_();
+
+                public:
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <class T,int Dim>
+        struct
+        mat_traits< qvm_detail::identity_mat_<T,Dim> >
+            {
+            typedef qvm_detail::identity_mat_<T,Dim> this_matrix;
+            typedef T scalar_type;
+            static int const rows=Dim;
+            static int const cols=Dim;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<Dim);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<Dim);
+                return scalar_traits<scalar_type>::value(Row==Col);
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<Dim);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<Dim);
+                return scalar_traits<scalar_type>::value(row==col);
+                }
+            };
+
+        template <class T,int Dim>
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::identity_mat_<T,Dim> const &
+        identity_mat()
+            {
+            return *(qvm_detail::identity_mat_<T,Dim> const *)qvm_detail::get_valid_ptr_mat_operations();
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_mat<A>::value &&
+            mat_traits<A>::rows==mat_traits<A>::cols,
+            void>::type
+        set_identity( A & a )
+            {
+            assign(a,identity_mat<typename mat_traits<A>::scalar_type,mat_traits<A>::rows>());
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class T>
+            struct
+            projection_
+                {
+                T const _00;
+                T const _11;
+                T const _22;
+                T const _23;
+                T const _32;
+
+                BOOST_QVM_INLINE_TRIVIAL
+                projection_( T _00, T _11, T _22, T _23, T _32 ):
+                    _00(_00),
+                    _11(_11),
+                    _22(_22),
+                    _23(_23),
+                    _32(_32)
+                    {
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+
+            template <int Row,int Col>
+            struct
+            projection_get
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( projection_<T> const & )
+                    {
+                    return scalar_traits<T>::value(0);
+                    }
+                };
+
+            template <> struct projection_get<0,0> { template <class T> static BOOST_QVM_INLINE_CRITICAL T get( projection_<T> const & m ) { return m._00; } };
+            template <> struct projection_get<1,1> { template <class T> static BOOST_QVM_INLINE_CRITICAL T get( projection_<T> const & m ) { return m._11; } };
+            template <> struct projection_get<2,2> { template <class T> static BOOST_QVM_INLINE_CRITICAL T get( projection_<T> const & m ) { return m._22; } };
+            template <> struct projection_get<2,3> { template <class T> static BOOST_QVM_INLINE_CRITICAL T get( projection_<T> const & m ) { return m._23; } };
+            template <> struct projection_get<3,2> { template <class T> static BOOST_QVM_INLINE_CRITICAL T get( projection_<T> const & m ) { return m._32; } };
+            }
+
+        template <class T>
+        struct
+        mat_traits< qvm_detail::projection_<T> >
+            {
+            typedef qvm_detail::projection_<T> this_matrix;
+            typedef T scalar_type;
+            static int const rows=4;
+            static int const cols=4;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return qvm_detail::projection_get<Row,Col>::get(x);
+                }
+            };
+
+        template <class T>
+        qvm_detail::projection_<T>
+        BOOST_QVM_INLINE_OPERATIONS
+        perspective_lh( T fov_y, T aspect_ratio, T z_near, T z_far )
+            {
+            T const one = scalar_traits<T>::value(1);
+            T const ys = one/tan<T>(fov_y/scalar_traits<T>::value(2));
+            T const xs = ys/aspect_ratio;
+            T const zd = z_far-z_near;
+            T const z1 = z_far/zd;
+            T const z2 = -z_near*z1;
+            return qvm_detail::projection_<T>(xs,ys,z1,z2,one);
+            }
+
+        template <class T>
+        qvm_detail::projection_<T>
+        BOOST_QVM_INLINE_OPERATIONS
+        perspective_rh( T fov_y, T aspect_ratio, T z_near, T z_far )
+            {
+            T const one = scalar_traits<T>::value(1);
+            T const ys = one/tan<T>(fov_y/scalar_traits<T>::value(2));
+            T const xs = ys/aspect_ratio;
+            T const zd = z_near-z_far;
+            T const z1 = z_far/zd;
+            T const z2 = z_near*z1;
+            return qvm_detail::projection_<T>(xs,ys,z1,z2,-one);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class OriginalType,class Scalar>
+            class
+            matrix_scalar_cast_
+                {
+                matrix_scalar_cast_( matrix_scalar_cast_ const & );
+                matrix_scalar_cast_ & operator=( matrix_scalar_cast_ const & );
+                ~matrix_scalar_cast_();
+
+                public:
+
+                template <class T>
+                BOOST_QVM_INLINE_TRIVIAL
+                matrix_scalar_cast_ &
+                operator=( T const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+
+            template <bool> struct scalar_cast_matrix_filter { };
+            template <> struct scalar_cast_matrix_filter<true> { typedef int type; };
+            }
+
+        template <class OriginalType,class Scalar>
+        struct
+        mat_traits< qvm_detail::matrix_scalar_cast_<OriginalType,Scalar> >
+            {
+            typedef Scalar scalar_type;
+            typedef qvm_detail::matrix_scalar_cast_<OriginalType,Scalar> this_matrix;
+            static int const rows=mat_traits<OriginalType>::rows;
+            static int const cols=mat_traits<OriginalType>::cols;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return scalar_type(mat_traits<OriginalType>::template read_element<Row,Col>(reinterpret_cast<OriginalType const &>(x)));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return scalar_type(mat_traits<OriginalType>::read_element_idx(col,row,reinterpret_cast<OriginalType const &>(x)));
+                }
+            };
+
+        template <class OriginalType,class Scalar,int R,int C>
+        struct
+        deduce_mat<qvm_detail::matrix_scalar_cast_<OriginalType,Scalar>,R,C>
+            {
+            typedef mat<Scalar,R,C> type;
+            };
+
+        template <class Scalar,class T>
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::matrix_scalar_cast_<T,Scalar> const &
+        scalar_cast( T const & x, typename qvm_detail::scalar_cast_matrix_filter<is_mat<T>::value>::type=0 )
+            {
+            return reinterpret_cast<qvm_detail::matrix_scalar_cast_<T,Scalar> const &>(x);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int M,int N>
+            struct
+            div_eq_ms_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_mat<A>::value && is_scalar<B>::value &&
+            !qvm_detail::div_eq_ms_defined<mat_traits<A>::rows,mat_traits<A>::cols>::value,
+            A &>::type
+        operator/=( A & a, B b )
+            {
+            for( int i=0; i!=mat_traits<A>::rows; ++i )
+                for( int j=0; j!=mat_traits<A>::cols; ++j )
+                    mat_traits<A>::write_element_idx(i,j,a)/=b;
+            return a;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int M,int N>
+            struct
+            div_ms_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_mat<A>::value && is_scalar<B>::value &&
+            !qvm_detail::div_ms_defined<mat_traits<A>::rows,mat_traits<A>::cols>::value,
+            deduce_mat<A> >::type
+        operator/( A const & a, B b )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            for( int i=0; i!=mat_traits<A>::rows; ++i )
+                for( int j=0; j!=mat_traits<A>::cols; ++j )
+                    mat_traits<R>::write_element_idx(i,j,r)=mat_traits<A>::read_element_idx(i,j,a)/b;
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int M,int N>
+            struct
+            eq_mm_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_mat<A>::value && is_mat<B>::value &&
+            mat_traits<A>::rows==mat_traits<B>::rows &&
+            mat_traits<A>::cols==mat_traits<B>::cols &&
+            !qvm_detail::eq_mm_defined<mat_traits<A>::rows,mat_traits<A>::cols>::value,
+            bool>::type
+        operator==( A const & a, B const & b )
+            {
+            for( int i=0; i!=mat_traits<A>::rows; ++i )
+                for( int j=0; j!=mat_traits<A>::cols; ++j )
+                    if( mat_traits<A>::read_element_idx(i,j,a)!=mat_traits<B>::read_element_idx(i,j,b) )
+                        return false;
+            return true;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int M,int N>
+            struct
+            minus_eq_mm_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_mat<A>::value && is_mat<B>::value &&
+            mat_traits<A>::rows==mat_traits<B>::rows &&
+            mat_traits<A>::cols==mat_traits<B>::cols &&
+            !qvm_detail::minus_eq_mm_defined<mat_traits<A>::rows,mat_traits<A>::cols>::value,
+            A &>::type
+        operator-=( A & a, B const & b )
+            {
+            for( int i=0; i!=mat_traits<A>::rows; ++i )
+                for( int j=0; j!=mat_traits<A>::cols; ++j )
+                    mat_traits<A>::write_element_idx(i,j,a)-=mat_traits<B>::read_element_idx(i,j,b);
+            return a;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int M,int N>
+            struct
+            minus_m_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_mat<A>::value &&
+            !qvm_detail::minus_m_defined<mat_traits<A>::rows,mat_traits<A>::cols>::value,
+            deduce_mat<A> >::type
+        operator-( A const & a )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            for( int i=0; i!=mat_traits<A>::rows; ++i )
+                for( int j=0; j!=mat_traits<A>::cols; ++j )
+                    mat_traits<R>::write_element_idx(i,j,r)=-mat_traits<A>::read_element_idx(i,j,a);
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int M,int N>
+            struct
+            minus_mm_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_mat<A>::value && is_mat<B>::value &&
+            mat_traits<A>::rows==mat_traits<B>::rows &&
+            mat_traits<A>::cols==mat_traits<B>::cols &&
+            !qvm_detail::minus_mm_defined<mat_traits<A>::rows,mat_traits<A>::cols>::value,
+            deduce_mat2<A,B,mat_traits<A>::rows,mat_traits<A>::cols> >::type
+        operator-( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,mat_traits<A>::rows,mat_traits<A>::cols>::type R;
+            R r;
+            for( int i=0; i!=mat_traits<A>::rows; ++i )
+                for( int j=0; j!=mat_traits<A>::cols; ++j )
+                    mat_traits<R>::write_element_idx(i,j,r)=mat_traits<A>::read_element_idx(i,j,a)-mat_traits<B>::read_element_idx(i,j,b);
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            mul_eq_mm_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_mat<A>::value &&
+            is_mat<B>::value &&
+            mat_traits<A>::rows==mat_traits<A>::cols &&
+            mat_traits<A>::rows==mat_traits<B>::rows &&
+            mat_traits<A>::cols==mat_traits<B>::cols &&
+            !qvm_detail::mul_eq_mm_defined<mat_traits<A>::rows>::value,
+            A &>::type
+        operator*=( A & r, B const & b )
+            {
+            typedef typename mat_traits<A>::scalar_type Ta;
+            Ta a[mat_traits<A>::rows][mat_traits<A>::cols];
+            for( int i=0; i<mat_traits<A>::rows; ++i )
+                for( int j=0; j<mat_traits<B>::cols; ++j )
+                    a[i][j]=mat_traits<A>::read_element_idx(i,j,r);
+            for( int i=0; i<mat_traits<A>::rows; ++i )
+                for( int j=0; j<mat_traits<B>::cols; ++j )
+                    {
+                    Ta x(scalar_traits<Ta>::value(0));
+                    for( int k=0; k<mat_traits<A>::cols; ++k )
+                        x += a[i][k]*mat_traits<B>::read_element_idx(k,j,b);
+                    mat_traits<A>::write_element_idx(i,j,r) = x;
+                    }
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int M,int N>
+            struct
+            mul_eq_ms_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_mat<A>::value && is_scalar<B>::value &&
+            !qvm_detail::mul_eq_ms_defined<mat_traits<A>::rows,mat_traits<A>::cols>::value,
+            A &>::type
+        operator*=( A & a, B b )
+            {
+            for( int i=0; i!=mat_traits<A>::rows; ++i )
+                for( int j=0; j!=mat_traits<A>::cols; ++j )
+                    mat_traits<A>::write_element_idx(i,j,a)*=b;
+            return a;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int R,int CR,int C>
+            struct
+            mul_mm_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_mat<A>::value && is_mat<B>::value &&
+            mat_traits<A>::cols==mat_traits<B>::rows &&
+            !qvm_detail::mul_mm_defined<mat_traits<A>::rows,mat_traits<A>::cols,mat_traits<B>::cols>::value,
+            deduce_mat2<A,B,mat_traits<A>::rows,mat_traits<B>::cols> >::type
+        operator*( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,mat_traits<A>::rows,mat_traits<B>::cols>::type R;
+            R r;
+            for( int i=0; i<mat_traits<A>::rows; ++i )
+                for( int j=0; j<mat_traits<B>::cols; ++j )
+                    {
+                    typedef typename mat_traits<A>::scalar_type Ta;
+                    Ta x(scalar_traits<Ta>::value(0));
+                    for( int k=0; k<mat_traits<A>::cols; ++k )
+                        x += mat_traits<A>::read_element_idx(i,k,a)*mat_traits<B>::read_element_idx(k,j,b);
+                    mat_traits<R>::write_element_idx(i,j,r) = x;
+                    }
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int M,int N>
+            struct
+            mul_ms_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_mat<A>::value && is_scalar<B>::value &&
+            !qvm_detail::mul_ms_defined<mat_traits<A>::rows,mat_traits<A>::cols>::value,
+            deduce_mat<A> >::type
+        operator*( A const & a, B b )
+            {
+            typedef typename deduce_mat<A>::type R;
+            R r;
+            for( int i=0; i!=mat_traits<A>::rows; ++i )
+                for( int j=0; j!=mat_traits<A>::cols; ++j )
+                    mat_traits<R>::write_element_idx(i,j,r)=mat_traits<A>::read_element_idx(i,j,a)*b;
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int M,int N>
+            struct
+            mul_sm_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_scalar<A>::value && is_mat<B>::value &&
+            !qvm_detail::mul_sm_defined<mat_traits<B>::rows,mat_traits<B>::cols>::value,
+            deduce_mat<B> >::type
+        operator*( A a, B const & b )
+            {
+            typedef typename deduce_mat<B>::type R;
+            R r;
+            for( int i=0; i!=mat_traits<B>::rows; ++i )
+                for( int j=0; j!=mat_traits<B>::cols; ++j )
+                    mat_traits<R>::write_element_idx(i,j,r)=a*mat_traits<B>::read_element_idx(i,j,b);
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int M,int N>
+            struct
+            neq_mm_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_mat<A>::value && is_mat<B>::value &&
+            mat_traits<A>::rows==mat_traits<B>::rows &&
+            mat_traits<A>::cols==mat_traits<B>::cols &&
+            !qvm_detail::neq_mm_defined<mat_traits<A>::rows,mat_traits<A>::cols>::value,
+            bool>::type
+        operator!=( A const & a, B const & b )
+            {
+            for( int i=0; i!=mat_traits<A>::rows; ++i )
+                for( int j=0; j!=mat_traits<A>::cols; ++j )
+                    if( mat_traits<A>::read_element_idx(i,j,a)!=mat_traits<B>::read_element_idx(i,j,b) )
+                        return true;
+            return false;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int M,int N>
+            struct
+            plus_eq_mm_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_mat<A>::value && is_mat<B>::value &&
+            mat_traits<A>::rows==mat_traits<B>::rows &&
+            mat_traits<A>::cols==mat_traits<B>::cols &&
+            !qvm_detail::plus_eq_mm_defined<mat_traits<A>::rows,mat_traits<A>::cols>::value,
+            A &>::type
+        operator+=( A & a, B const & b )
+            {
+            for( int i=0; i!=mat_traits<A>::rows; ++i )
+                for( int j=0; j!=mat_traits<A>::cols; ++j )
+                    mat_traits<A>::write_element_idx(i,j,a)+=mat_traits<B>::read_element_idx(i,j,b);
+            return a;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int M,int N>
+            struct
+            plus_mm_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_mat<A>::value && is_mat<B>::value &&
+            mat_traits<A>::rows==mat_traits<B>::rows &&
+            mat_traits<A>::cols==mat_traits<B>::cols &&
+            !qvm_detail::plus_mm_defined<mat_traits<A>::rows,mat_traits<A>::cols>::value,
+            deduce_mat2<A,B,mat_traits<A>::rows,mat_traits<A>::cols> >::type
+        operator+( A const & a, B const & b )
+            {
+            typedef typename deduce_mat2<A,B,mat_traits<A>::rows,mat_traits<A>::cols>::type R;
+            R r;
+            for( int i=0; i!=mat_traits<A>::rows; ++i )
+                for( int j=0; j!=mat_traits<A>::cols; ++j )
+                    mat_traits<R>::write_element_idx(i,j,r)=mat_traits<A>::read_element_idx(i,j,a)+mat_traits<B>::read_element_idx(i,j,b);
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class T>
+            class
+            mref_
+                {
+                mref_( mref_ const & );
+                mref_ & operator=( mref_ const & );
+                ~mref_();
+
+                public:
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                mref_ &
+                operator=( R const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <class M>
+        struct
+        mat_traits< qvm_detail::mref_<M> >
+            {
+            typedef typename mat_traits<M>::scalar_type scalar_type;
+            typedef qvm_detail::mref_<M> this_matrix;
+            static int const rows=mat_traits<M>::rows;
+            static int const cols=mat_traits<M>::cols;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return mat_traits<M>::template read_element<Row,Col>(reinterpret_cast<M const &>(x));
+                }
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_matrix & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<cols);
+                return mat_traits<M>::template write_element<Row,Col>(reinterpret_cast<M &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return mat_traits<M>::read_element_idx(row,col,reinterpret_cast<M const &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int row, int col, this_matrix & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return mat_traits<M>::write_element_idx(row,col,reinterpret_cast<M &>(x));
+                }
+            };
+
+        template <class M,int R,int C>
+        struct
+        deduce_mat<qvm_detail::mref_<M>,R,C>
+            {
+            typedef mat<typename mat_traits<M>::scalar_type,R,C> type;
+            };
+
+        template <class M>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_mat<M>::value,
+            qvm_detail::mref_<M> const &>::type
+        mref( M const & a )
+            {
+            return reinterpret_cast<qvm_detail::mref_<M> const &>(a);
+            }
+
+        template <class M>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_mat<M>::value,
+            qvm_detail::mref_<M> &>::type
+        mref( M & a )
+            {
+            return reinterpret_cast<qvm_detail::mref_<M> &>(a);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class T,int Rows,int Cols>
+            class
+            zero_mat_
+                {
+                zero_mat_( zero_mat_ const & );
+                zero_mat_ & operator=( zero_mat_ const & );
+                ~zero_mat_();
+
+                public:
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <class T,int Rows,int Cols>
+        struct
+        mat_traits< qvm_detail::zero_mat_<T,Rows,Cols> >
+            {
+            typedef qvm_detail::zero_mat_<T,Rows,Cols> this_matrix;
+            typedef T scalar_type;
+            static int const rows=Rows;
+            static int const cols=Cols;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<Rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<Cols);
+                return scalar_traits<scalar_type>::value(0);
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<cols);
+                return scalar_traits<scalar_type>::value(0);
+                }
+            };
+
+        template <class T,int Rows,int Cols,int R,int C>
+        struct
+        deduce_mat<qvm_detail::zero_mat_<T,Rows,Cols>,R,C>
+            {
+            typedef mat<T,R,C> type;
+            };
+
+        template <class T,int Rows,int Cols>
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::zero_mat_<T,Rows,Cols> const &
+        zero_mat()
+            {
+            return *(qvm_detail::zero_mat_<T,Rows,Cols> const *)qvm_detail::get_valid_ptr_mat_operations();
+            }
+
+        template <class T,int Dim>
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::zero_mat_<T,Dim,Dim> const &
+        zero_mat()
+            {
+            return *(qvm_detail::zero_mat_<T,Dim,Dim> const *)qvm_detail::get_valid_ptr_mat_operations();
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_mat<A>::value,
+            void>::type
+        set_zero( A & a )
+            {
+            assign(a,zero_mat<typename mat_traits<A>::scalar_type,mat_traits<A>::rows,mat_traits<A>::cols>());
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D,class V>
+            struct
+            rot_mat_
+                {
+                typedef typename vec_traits<V>::scalar_type scalar_type;
+                scalar_type a[3][3];
+
+                template <class Angle>
+                BOOST_QVM_INLINE
+                rot_mat_( V const & axis, Angle angle )
+                    {
+                    scalar_type const x=vec_traits<V>::template read_element<0>(axis);
+                    scalar_type const y=vec_traits<V>::template read_element<1>(axis);
+                    scalar_type const z=vec_traits<V>::template read_element<2>(axis);
+                    scalar_type const m2=x*x+y*y+z*z;
+                    if( m2==scalar_traits<scalar_type>::value(0) )
+                        BOOST_QVM_THROW_EXCEPTION(zero_magnitude_error());
+                    scalar_type const s = sin<Angle>(angle);
+                    scalar_type const c = cos<Angle>(angle);
+                    scalar_type const x2 = x*x;
+                    scalar_type const y2 = y*y;
+                    scalar_type const z2 = z*z;
+                    scalar_type const xy = x*y;
+                    scalar_type const xz = x*z;
+                    scalar_type const yz = y*z;
+                    scalar_type const xs = x*s;
+                    scalar_type const ys = y*s;
+                    scalar_type const zs = z*s;
+                    scalar_type const one = scalar_traits<scalar_type>::value(1);
+                    scalar_type const c1 = one-c;
+                    a[0][0] = x2+(one-x2)*c;
+                    a[0][1] = xy*c1-zs;
+                    a[0][2] = xz*(one-c)+ys;
+                    a[1][0] = xy*c1+zs;
+                    a[1][1] = y2+(one-y2)*c;
+                    a[1][2] = yz*c1-xs;
+                    a[2][0] = xz*c1-ys;
+                    a[2][1] = yz*c1+xs;
+                    a[2][2] = z2+(one-z2)*c;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+
+            template <int Row,int Col>
+            struct
+            rot_m_get
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const (&)[3][3] )
+                    {
+                    return scalar_traits<T>::value(Row==Col);
+                    }
+                };
+
+            template <> struct rot_m_get<0,0> { template <class T> static BOOST_QVM_INLINE_CRITICAL T get( T const (&a)[3][3] ) { return a[0][0]; } };
+            template <> struct rot_m_get<0,1> { template <class T> static BOOST_QVM_INLINE_CRITICAL T get( T const (&a)[3][3] ) { return a[0][1]; } };
+            template <> struct rot_m_get<0,2> { template <class T> static BOOST_QVM_INLINE_CRITICAL T get( T const (&a)[3][3] ) { return a[0][2]; } };
+            template <> struct rot_m_get<1,0> { template <class T> static BOOST_QVM_INLINE_CRITICAL T get( T const (&a)[3][3] ) { return a[1][0]; } };
+            template <> struct rot_m_get<1,1> { template <class T> static BOOST_QVM_INLINE_CRITICAL T get( T const (&a)[3][3] ) { return a[1][1]; } };
+            template <> struct rot_m_get<1,2> { template <class T> static BOOST_QVM_INLINE_CRITICAL T get( T const (&a)[3][3] ) { return a[1][2]; } };
+            template <> struct rot_m_get<2,0> { template <class T> static BOOST_QVM_INLINE_CRITICAL T get( T const (&a)[3][3] ) { return a[2][0]; } };
+            template <> struct rot_m_get<2,1> { template <class T> static BOOST_QVM_INLINE_CRITICAL T get( T const (&a)[3][3] ) { return a[2][1]; } };
+            template <> struct rot_m_get<2,2> { template <class T> static BOOST_QVM_INLINE_CRITICAL T get( T const (&a)[3][3] ) { return a[2][2]; } };
+            }
+
+        template <class M>
+        struct mat_traits;
+
+        template <int D,class V>
+        struct
+        mat_traits< qvm_detail::rot_mat_<D,V> >
+            {
+            typedef qvm_detail::rot_mat_<D,V> this_matrix;
+            typedef typename this_matrix::scalar_type scalar_type;
+            static int const rows=D;
+            static int const cols=D;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<D);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<D);
+                return qvm_detail::rot_m_get<Row,Col>::get(x.a);
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<D);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<D);
+                return row<3 && col<3?
+                    x.a[row][col] :
+                    scalar_traits<scalar_type>::value(row==col);
+                }
+            };
+
+        template <int Dim,class A,class Angle>
+        BOOST_QVM_INLINE
+        typename enable_if_c<
+            is_vec<A>::value && vec_traits<A>::dim==3,
+            qvm_detail::rot_mat_<Dim,A> >::type
+        rot_mat( A const & axis, Angle angle )
+            {
+            return qvm_detail::rot_mat_<Dim,A>(axis,angle);
+            }
+
+        template <class A,class B,class Angle>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_mat<A>::value &&
+            mat_traits<A>::rows==mat_traits<A>::cols &&
+            mat_traits<A>::rows>=3 &&
+            is_vec<B>::value && vec_traits<B>::dim==3,
+            void>::type
+        set_rot( A & a, B const & axis, Angle angle )
+            {
+            assign(a,rot_mat<mat_traits<A>::rows>(axis,angle));
+            }
+
+        template <class A,class B,class Angle>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_mat<A>::value &&
+            mat_traits<A>::rows==mat_traits<A>::cols &&
+            mat_traits<A>::rows>=3 &&
+            is_vec<B>::value && vec_traits<B>::dim==3,
+            void>::type
+        rotate( A & a, B const & axis, Angle angle )
+            {
+            a *= rot_mat<mat_traits<A>::rows>(axis,angle);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int Dim,class Angle>
+            struct
+            rotx_mat_
+                {
+                BOOST_QVM_INLINE_TRIVIAL
+                rotx_mat_()
+                    {
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+
+                private:
+
+                rotx_mat_( rotx_mat_ const & );
+                rotx_mat_ & operator=( rotx_mat_ const & );
+                ~rotx_mat_();
+                };
+
+            template <int Row,int Col>
+            struct
+            rotx_m_get
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & )
+                    {
+                    return scalar_traits<T>::value(Row==Col);
+                    }
+                };
+
+            template <>
+            struct
+            rotx_m_get<1,1>
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & angle )
+                    {
+                    return cos<T>(angle);
+                    }
+                };
+
+            template <>
+            struct
+            rotx_m_get<1,2>
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & angle )
+                    {
+                    return -sin<T>(angle);
+                    }
+                };
+
+            template <>
+            struct
+            rotx_m_get<2,1>
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & angle )
+                    {
+                    return sin<T>(angle);
+                    }
+                };
+
+            template <>
+            struct
+            rotx_m_get<2,2>
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & angle )
+                    {
+                    return cos<T>(angle);
+                    }
+                };
+            }
+
+        template <int Dim,class Angle>
+        struct
+        mat_traits< qvm_detail::rotx_mat_<Dim,Angle> >
+            {
+            typedef qvm_detail::rotx_mat_<Dim,Angle> this_matrix;
+            typedef Angle scalar_type;
+            static int const rows=Dim;
+            static int const cols=Dim;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<Dim);
+                BOOST_QVM_STATIC_ASSERT(Col<Dim);
+                return qvm_detail::rotx_m_get<Row,Col>::get(reinterpret_cast<Angle const &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(row<Dim);
+                BOOST_QVM_ASSERT(col<Dim);
+                Angle const & a=reinterpret_cast<Angle const &>(x);
+                if( row==1 )
+                    {
+                    if( col==1 )
+                        return cos<scalar_type>(a);
+                    if( col==2 )
+                        return -sin<scalar_type>(a);
+                    }
+                if( row==2 )
+                    {
+                    if( col==1 )
+                        return sin<scalar_type>(a);
+                    if( col==2 )
+                        return cos<scalar_type>(a);
+                    }
+                return scalar_traits<scalar_type>::value(row==col);
+                }
+            };
+
+        template <int Dim,class Angle>
+        struct
+        deduce_mat<qvm_detail::rotx_mat_<Dim,Angle>,Dim,Dim>
+            {
+            typedef mat<Angle,Dim,Dim> type;
+            };
+
+        template <int Dim,class Angle>
+        struct
+        deduce_mat2<qvm_detail::rotx_mat_<Dim,Angle>,qvm_detail::rotx_mat_<Dim,Angle>,Dim,Dim>
+            {
+            typedef mat<Angle,Dim,Dim> type;
+            };
+
+        template <int Dim,class Angle>
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::rotx_mat_<Dim,Angle> const &
+        rotx_mat( Angle const & angle )
+            {
+            BOOST_QVM_STATIC_ASSERT(Dim>=3);
+            return reinterpret_cast<qvm_detail::rotx_mat_<Dim,Angle> const &>(angle);
+            }
+
+        template <class A,class Angle>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_mat<A>::value &&
+            mat_traits<A>::rows>=3 &&
+            mat_traits<A>::rows==mat_traits<A>::cols,
+            void>::type
+        set_rotx( A & a, Angle angle )
+            {
+            assign(a,rotx_mat<mat_traits<A>::rows>(angle));
+            }
+
+        template <class A,class Angle>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_mat<A>::value &&
+            mat_traits<A>::rows>=3 &&
+            mat_traits<A>::rows==mat_traits<A>::cols,
+            void>::type
+        rotate_x( A & a, Angle angle )
+            {
+            a *= rotx_mat<mat_traits<A>::rows>(angle);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int Dim,class Angle>
+            struct
+            roty_mat_
+                {
+                BOOST_QVM_INLINE_TRIVIAL
+                roty_mat_()
+                    {
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+
+                private:
+
+                roty_mat_( roty_mat_ const & );
+                roty_mat_ & operator=( roty_mat_ const & );
+                ~roty_mat_();
+                };
+
+            template <int Row,int Col>
+            struct
+            roty_m_get
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & )
+                    {
+                    return scalar_traits<T>::value(Row==Col);
+                    }
+                };
+
+            template <>
+            struct
+            roty_m_get<0,0>
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & angle )
+                    {
+                    return cos<T>(angle);
+                    }
+                };
+
+            template <>
+            struct
+            roty_m_get<0,2>
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & angle )
+                    {
+                    return sin<T>(angle);
+                    }
+                };
+
+            template <>
+            struct
+            roty_m_get<2,0>
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & angle )
+                    {
+                    return -sin<T>(angle);
+                    }
+                };
+
+            template <>
+            struct
+            roty_m_get<2,2>
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & angle )
+                    {
+                    return cos<T>(angle);
+                    }
+                };
+            }
+
+        template <int Dim,class Angle>
+        struct
+        mat_traits< qvm_detail::roty_mat_<Dim,Angle> >
+            {
+            typedef qvm_detail::roty_mat_<Dim,Angle> this_matrix;
+            typedef Angle scalar_type;
+            static int const rows=Dim;
+            static int const cols=Dim;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<Dim);
+                BOOST_QVM_STATIC_ASSERT(Col<Dim);
+                return qvm_detail::roty_m_get<Row,Col>::get(reinterpret_cast<Angle const &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(row<Dim);
+                BOOST_QVM_ASSERT(col<Dim);
+                Angle const & a=reinterpret_cast<Angle const &>(x);
+                if( row==0 )
+                    {
+                    if( col==0 )
+                        return cos<scalar_type>(a);
+                    if( col==2 )
+                        return sin<scalar_type>(a);
+                    }
+                if( row==2 )
+                    {
+                    if( col==0 )
+                        return -sin<scalar_type>(a);
+                    if( col==2 )
+                        return cos<scalar_type>(a);
+                    }
+                return scalar_traits<scalar_type>::value(row==col);
+                }
+            };
+
+        template <int Dim,class Angle>
+        struct
+        deduce_mat<qvm_detail::roty_mat_<Dim,Angle>,Dim,Dim>
+            {
+            typedef mat<Angle,Dim,Dim> type;
+            };
+
+        template <int Dim,class Angle>
+        struct
+        deduce_mat2<qvm_detail::roty_mat_<Dim,Angle>,qvm_detail::roty_mat_<Dim,Angle>,Dim,Dim>
+            {
+            typedef mat<Angle,Dim,Dim> type;
+            };
+
+        template <int Dim,class Angle>
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::roty_mat_<Dim,Angle> const &
+        roty_mat( Angle const & angle )
+            {
+            BOOST_QVM_STATIC_ASSERT(Dim>=3);
+            return reinterpret_cast<qvm_detail::roty_mat_<Dim,Angle> const &>(angle);
+            }
+
+        template <class A,class Angle>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_mat<A>::value &&
+            mat_traits<A>::rows>=2 &&
+            mat_traits<A>::rows==mat_traits<A>::cols,
+            void>::type
+        set_roty( A & a, Angle angle )
+            {
+            assign(a,roty_mat<mat_traits<A>::rows>(angle));
+            }
+
+        template <class A,class Angle>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_mat<A>::value &&
+            mat_traits<A>::rows>=3 &&
+            mat_traits<A>::rows==mat_traits<A>::cols,
+            void>::type
+        rotate_y( A & a, Angle angle )
+            {
+            a *= roty_mat<mat_traits<A>::rows>(angle);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int Dim,class Angle>
+            struct
+            rotz_mat_
+                {
+                BOOST_QVM_INLINE_TRIVIAL
+                rotz_mat_()
+                    {
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+
+                private:
+
+                rotz_mat_( rotz_mat_ const & );
+                rotz_mat_ & operator=( rotz_mat_ const & );
+                ~rotz_mat_();
+                };
+
+            template <int Row,int Col>
+            struct
+            rotz_m_get
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & )
+                    {
+                    return scalar_traits<T>::value(Row==Col);
+                    }
+                };
+
+            template <>
+            struct
+            rotz_m_get<0,0>
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & angle )
+                    {
+                    return cos<T>(angle);
+                    }
+                };
+
+            template <>
+            struct
+            rotz_m_get<0,1>
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & angle )
+                    {
+                    return -sin<T>(angle);
+                    }
+                };
+
+            template <>
+            struct
+            rotz_m_get<1,0>
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & angle )
+                    {
+                    return sin<T>(angle);
+                    }
+                };
+
+            template <>
+            struct
+            rotz_m_get<1,1>
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & angle )
+                    {
+                    return cos<T>(angle);
+                    }
+                };
+            }
+
+        template <int Dim,class Angle>
+        struct
+        mat_traits< qvm_detail::rotz_mat_<Dim,Angle> >
+            {
+            typedef qvm_detail::rotz_mat_<Dim,Angle> this_matrix;
+            typedef Angle scalar_type;
+            static int const rows=Dim;
+            static int const cols=Dim;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<Dim);
+                BOOST_QVM_STATIC_ASSERT(Col<Dim);
+                return qvm_detail::rotz_m_get<Row,Col>::get(reinterpret_cast<Angle const &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(row<Dim);
+                BOOST_QVM_ASSERT(col<Dim);
+                Angle const & a=reinterpret_cast<Angle const &>(x);
+                if( row==0 )
+                    {
+                    if( col==0 )
+                        return cos<scalar_type>(a);
+                    if( col==1 )
+                        return -sin<scalar_type>(a);
+                    }
+                if( row==1 )
+                    {
+                    if( col==0 )
+                        return sin<scalar_type>(a);
+                    if( col==1 )
+                        return cos<scalar_type>(a);
+                    }
+                return scalar_traits<scalar_type>::value(row==col);
+                }
+            };
+
+        template <int Dim,class Angle>
+        struct
+        deduce_mat<qvm_detail::rotz_mat_<Dim,Angle>,Dim,Dim>
+            {
+            typedef mat<Angle,Dim,Dim> type;
+            };
+
+        template <int Dim,class Angle,int R,int C>
+        struct
+        deduce_mat2<qvm_detail::rotz_mat_<Dim,Angle>,qvm_detail::rotz_mat_<Dim,Angle>,R,C>
+            {
+            typedef mat<Angle,R,C> type;
+            };
+
+        template <int Dim,class Angle>
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::rotz_mat_<Dim,Angle> const &
+        rotz_mat( Angle const & angle )
+            {
+            BOOST_QVM_STATIC_ASSERT(Dim>=2);
+            return reinterpret_cast<qvm_detail::rotz_mat_<Dim,Angle> const &>(angle);
+            }
+
+        template <class A,class Angle>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_mat<A>::value &&
+            mat_traits<A>::rows>=2 &&
+            mat_traits<A>::rows==mat_traits<A>::cols,
+            void>::type
+        set_rotz( A & a, Angle angle )
+            {
+            assign(a,rotz_mat<mat_traits<A>::rows>(angle));
+            }
+
+        template <class A,class Angle>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_mat<A>::value &&
+            mat_traits<A>::rows>=2 &&
+            mat_traits<A>::rows==mat_traits<A>::cols,
+            void>::type
+        rotate_z( A & a, Angle angle )
+            {
+            a *= rotz_mat<mat_traits<A>::rows>(angle);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            inverse_m_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename lazy_enable_if_c<
+            is_mat<A>::value && is_scalar<B>::value &&
+            mat_traits<A>::rows==mat_traits<A>::cols &&
+            !qvm_detail::inverse_m_defined<mat_traits<A>::rows>::value,
+            deduce_mat<A> >::type
+        inverse( A const & a, B det )
+            {
+            typedef typename mat_traits<A>::scalar_type T;
+            BOOST_QVM_ASSERT(det!=scalar_traits<T>::value(0));
+            T f=scalar_traits<T>::value(1)/det;
+            typedef typename deduce_mat<A>::type cofactor_return_type;
+            cofactor_return_type c=qvm_detail::cofactor_impl(a);
+            return reinterpret_cast<qvm_detail::transposed_<cofactor_return_type> const &>(c) * f;
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename lazy_enable_if_c<
+            is_mat<A>::value &&
+            mat_traits<A>::rows==mat_traits<A>::cols &&
+            !qvm_detail::inverse_m_defined<mat_traits<A>::rows>::value,
+            deduce_mat<A> >::type
+        inverse( A const & a )
+            {
+            typedef typename mat_traits<A>::scalar_type T;
+            T det=determinant(a);
+            if( det==scalar_traits<T>::value(0) )
+                BOOST_QVM_THROW_EXCEPTION(zero_determinant_error());
+            return inverse(a,det);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::to_string;
+            using ::boost::qvm::assign;
+            using ::boost::qvm::determinant;
+            using ::boost::qvm::cmp;
+            using ::boost::qvm::convert_to;
+            using ::boost::qvm::set_identity;
+            using ::boost::qvm::set_zero;
+            using ::boost::qvm::scalar_cast;
+            using ::boost::qvm::operator/=;
+            using ::boost::qvm::operator/;
+            using ::boost::qvm::operator==;
+            using ::boost::qvm::operator-=;
+            using ::boost::qvm::operator-;
+            using ::boost::qvm::operator*=;
+            using ::boost::qvm::operator*;
+            using ::boost::qvm::operator!=;
+            using ::boost::qvm::operator+=;
+            using ::boost::qvm::operator+;
+            using ::boost::qvm::mref;
+            using ::boost::qvm::rot_mat;
+            using ::boost::qvm::set_rot;
+            using ::boost::qvm::rotate;
+            using ::boost::qvm::set_rotx;
+            using ::boost::qvm::rotate_x;
+            using ::boost::qvm::set_roty;
+            using ::boost::qvm::rotate_y;
+            using ::boost::qvm::set_rotz;
+            using ::boost::qvm::rotate_z;
+            using ::boost::qvm::inverse;
+            }
+
+        ////////////////////////////////////////////////
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/mat_operations2.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/mat_operations2.hpp
new file mode 100644
index 00000000000..b3907801736
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/mat_operations2.hpp
@@ -0,0 +1,6 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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)
+
+#include <boost/qvm/gen/mat_operations2.hpp>
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/mat_operations3.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/mat_operations3.hpp
new file mode 100644
index 00000000000..4c76d0753ca
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/mat_operations3.hpp
@@ -0,0 +1,6 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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)
+
+#include <boost/qvm/gen/mat_operations3.hpp>
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/mat_operations4.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/mat_operations4.hpp
new file mode 100644
index 00000000000..ab0835adf76
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/mat_operations4.hpp
@@ -0,0 +1,6 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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)
+
+#include <boost/qvm/gen/mat_operations4.hpp>
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/mat_traits.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/mat_traits.hpp
new file mode 100644
index 00000000000..9937443979b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/mat_traits.hpp
@@ -0,0 +1,33 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_8C06FE26A3E711DEA02C88BA55D89593
+#define UUID_8C06FE26A3E711DEA02C88BA55D89593
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class M>
+        struct
+        mat_traits
+            {
+            static int const rows=0;
+            static int const cols=0;
+            typedef void scalar_type;
+            };
+
+        template <class T>
+        struct
+        is_mat
+            {
+            static bool const value=mat_traits<T>::rows>0 && mat_traits<T>::cols>0;
+            };
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/mat_traits_array.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/mat_traits_array.hpp
new file mode 100644
index 00000000000..160ead7d61c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/mat_traits_array.hpp
@@ -0,0 +1,118 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_FA3ED0DCA17911DEA6BBA09955D89593
+#define UUID_FA3ED0DCA17911DEA6BBA09955D89593
+
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/deduce_mat.hpp>
+#include <boost/qvm/detail/remove_const.hpp>
+#include <boost/qvm/assert.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class T,int R,int CR,int C>
+        struct
+        mat_traits<T[R][CR][C]>
+            {
+            static int const rows=0;
+            static int const cols=0;
+            typedef void scalar_type;
+            };
+
+        template <class T,int Rows,int Cols>
+        struct
+        mat_traits<T[Rows][Cols]>
+            {
+            typedef T this_matrix[Rows][Cols];
+            typedef typename qvm_detail::remove_const<T>::type scalar_type;
+            static int const rows=Rows;
+            static int const cols=Cols;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_matrix const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<Rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<Cols);
+                return x[Row][Col];
+                }
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_matrix & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(Row>=0);
+                BOOST_QVM_STATIC_ASSERT(Row<Rows);
+                BOOST_QVM_STATIC_ASSERT(Col>=0);
+                BOOST_QVM_STATIC_ASSERT(Col<Cols);
+                return x[Row][Col];
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int row, int col, this_matrix const & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<Rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<Cols);
+                return x[row][col];
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int row, int col, this_matrix & x )
+                {
+                BOOST_QVM_ASSERT(row>=0);
+                BOOST_QVM_ASSERT(row<Rows);
+                BOOST_QVM_ASSERT(col>=0);
+                BOOST_QVM_ASSERT(col<Cols);
+                return x[row][col];
+                }
+            };
+
+        template <class T,int Rows,int Cols,int R,int C>
+        struct
+        deduce_mat<T[Rows][Cols],R,C>
+            {
+            typedef mat<T,R,C> type;
+            };
+
+        template <class T,int Rows,int Cols,int R,int C>
+        struct
+        deduce_mat<T const[Rows][Cols],R,C>
+            {
+            typedef mat<T,R,C> type;
+            };
+
+        template <class T1,class T2,int Rows,int Cols,int R,int C>
+        struct
+        deduce_mat2<T1[Rows][Cols],T2[Rows][Cols],R,C>
+            {
+            typedef mat<typename deduce_scalar<T1,T2>::type,R,C> type;
+            };
+
+        template <int Rows,int Cols,class T>
+        T (&ptr_mref( T * ptr ))[Rows][Cols]
+            {
+            return *reinterpret_cast<T (*)[Rows][Cols]>(ptr);
+            }
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/mat_traits_defaults.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/mat_traits_defaults.hpp
new file mode 100644
index 00000000000..898e79064a7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/mat_traits_defaults.hpp
@@ -0,0 +1,95 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_FB4D5BEAC71B11E68D0EEF1707624D53
+#define UUID_FB4D5BEAC71B11E68D0EEF1707624D53
+
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/assert.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class>
+        struct mat_traits;
+
+        namespace
+        qvm_detail
+            {
+            template <int I,int N>
+            struct
+            matrix_w
+                {
+                template <class A>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                typename mat_traits<A>::scalar_type &
+                write_element_idx( int r, int c, A & a )
+                    {
+                    return (I/mat_traits<A>::cols)==r && (I%mat_traits<A>::cols)==c?
+                        mat_traits<A>::template write_element<I/mat_traits<A>::cols,I%mat_traits<A>::cols>(a) :
+                        matrix_w<I+1,N>::write_element_idx(r,c,a);
+                    }
+                };
+
+            template <int N>
+            struct
+            matrix_w<N,N>
+                {
+                template <class A>
+                static
+                BOOST_QVM_INLINE_TRIVIAL
+                typename mat_traits<A>::scalar_type &
+                write_element_idx( int, int, A & a )
+                    {
+                    BOOST_QVM_ASSERT(0);
+                    return mat_traits<A>::template write_element<0,0>(a);
+                    }
+                };
+            }
+
+        template <class MatType,class ScalarType,int Rows,int Cols>
+        struct
+        mat_traits_defaults
+            {
+            typedef MatType mat_type;
+            typedef ScalarType scalar_type;
+            static int const rows=Rows;
+            static int const cols=Cols;
+
+            template <int Row,int Col>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( mat_type const & x )
+                {
+                return mat_traits<mat_type>::template write_element<Row,Col>(const_cast<mat_type &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int r, int c, mat_type const & x )
+                {
+                return mat_traits<mat_type>::write_element_idx(r,c,const_cast<mat_type &>(x));
+                }
+
+            protected:
+
+            static
+            BOOST_QVM_INLINE_TRIVIAL
+            scalar_type &
+            write_element_idx( int r, int c, mat_type & m )
+                {
+                return qvm_detail::matrix_w<0,mat_traits<mat_type>::rows*mat_traits<mat_type>::cols>::write_element_idx(r,c,m);
+                }
+            };
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/math.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/math.hpp
new file mode 100644
index 00000000000..26ab3f4c86a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/math.hpp
@@ -0,0 +1,87 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_5FD6A664ACC811DEAAFF8A8055D89593
+#define UUID_5FD6A664ACC811DEAAFF8A8055D89593
+
+#include <math.h>
+#include <boost/qvm/inline.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class T> T acos( T );
+        template <class T> T asin( T );
+        template <class T> T atan( T );
+        template <class T> T atan2( T, T );
+        template <class T> T cos( T );
+        template <class T> T sin( T );
+        template <class T> T tan( T );
+        template <class T> T cosh( T );
+        template <class T> T sinh( T );
+        template <class T> T tanh( T );
+        template <class T> T exp( T );
+        template <class T> T log( T );
+        template <class T> T log10( T );
+        template <class T> T mod( T , T );
+        template <class T> T pow( T, T );
+        template <class T> T sqrt( T );
+        template <class T> T ceil( T );
+        template <class T> T abs( T );
+        template <class T> T floor( T );
+        template <class T> T mod( T, T );
+        template <class T> T ldexp( T, int );
+        template <class T> T sign( T );
+
+        template <> BOOST_QVM_INLINE_TRIVIAL float acos<float>( float x ) { return ::acosf(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL float asin<float>( float x ) { return ::asinf(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL float atan<float>( float x ) { return ::atanf(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL float atan2<float>( float x, float y ) { return ::atan2f(x,y); }
+        template <> BOOST_QVM_INLINE_TRIVIAL float cos<float>( float x ) { return ::cosf(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL float sin<float>( float x ) { return ::sinf(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL float tan<float>( float x ) { return ::tanf(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL float cosh<float>( float x ) { return ::coshf(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL float sinh<float>( float x ) { return ::sinhf(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL float tanh<float>( float x ) { return ::tanhf(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL float exp<float>( float x ) { return ::expf(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL float log<float>( float x ) { return ::logf(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL float log10<float>( float x ) { return ::log10f(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL float mod<float>( float x, float y ) { return ::fmodf(x,y); }
+        template <> BOOST_QVM_INLINE_TRIVIAL float pow<float>( float x, float y ) { return ::powf(x,y); }
+        template <> BOOST_QVM_INLINE_TRIVIAL float sqrt<float>( float x ) { return ::sqrtf(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL float ceil<float>( float x ) { return ::ceilf(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL float abs<float>( float x ) { return ::fabsf(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL float floor<float>( float x ) { return ::floorf(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL float ldexp<float>( float x, int y ) { return ::ldexpf(x,y); }
+        template <> BOOST_QVM_INLINE_TRIVIAL float sign<float>( float x ) { return x<0 ? -1.f : +1.f; }
+                    
+        template <> BOOST_QVM_INLINE_TRIVIAL double acos<double>( double x ) { return ::acos(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL double asin<double>( double x ) { return ::asin(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL double atan<double>( double x ) { return ::atan(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL double atan2<double>( double x, double y ) { return ::atan2(x,y); }
+        template <> BOOST_QVM_INLINE_TRIVIAL double cos<double>( double x ) { return ::cos(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL double sin<double>( double x ) { return ::sin(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL double tan<double>( double x ) { return ::tan(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL double cosh<double>( double x ) { return ::cosh(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL double sinh<double>( double x ) { return ::sinh(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL double tanh<double>( double x ) { return ::tanh(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL double exp<double>( double x ) { return ::exp(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL double log<double>( double x ) { return ::log(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL double log10<double>( double x ) { return ::log10(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL double mod<double>( double x, double y ) { return ::fmod(x,y); }
+        template <> BOOST_QVM_INLINE_TRIVIAL double pow<double>( double x, double y ) { return ::pow(x,y); }
+        template <> BOOST_QVM_INLINE_TRIVIAL double sqrt<double>( double x ) { return ::sqrt(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL double ceil<double>( double x ) { return ::ceil(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL double abs<double>( double x ) { return ::fabs(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL double floor<double>( double x ) { return ::floor(x); }
+        template <> BOOST_QVM_INLINE_TRIVIAL double ldexp<double>( double x, int y ) { return ::ldexp(x,y); }
+        template <> BOOST_QVM_INLINE_TRIVIAL double sign<double>( double x ) { return x<0 ? -1.0 : +1.0; }
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/operations.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/operations.hpp
new file mode 100644
index 00000000000..a82ddf8e848
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/operations.hpp
@@ -0,0 +1,15 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_0B9D9FB6B95D11DEA8E0305E55D89593
+#define UUID_0B9D9FB6B95D11DEA8E0305E55D89593
+
+#include <boost/qvm/quat_operations.hpp>
+#include <boost/qvm/vec_operations.hpp>
+#include <boost/qvm/mat_operations.hpp>
+#include <boost/qvm/quat_vec_operations.hpp>
+#include <boost/qvm/vec_mat_operations.hpp>
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/quat.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/quat.hpp
new file mode 100644
index 00000000000..cd078ee0914
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/quat.hpp
@@ -0,0 +1,68 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_49C5A1042AEF11DF9603880056D89593
+#define UUID_49C5A1042AEF11DF9603880056D89593
+
+#include <boost/qvm/detail/quat_assign.hpp>
+#include <boost/qvm/assert.hpp>
+#include <boost/qvm/static_assert.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class T>
+        struct
+        quat
+            {
+            T a[4];
+            template <class R>
+            operator R() const
+                {
+                R r;
+                assign(r,*this);
+                return r;
+                }
+            };
+
+        template <class Q>
+        struct quat_traits;
+
+        template <class T>
+        struct
+        quat_traits< quat<T> >
+            {
+            typedef quat<T> this_quaternion;
+            typedef T scalar_type;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_quaternion const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<4);
+                return x.a[I];
+                }
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_quaternion & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<4);
+                return x.a[I];
+                }
+            };
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/quat_access.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/quat_access.hpp
new file mode 100644
index 00000000000..fe69b29cb1d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/quat_access.hpp
@@ -0,0 +1,128 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_8AC84A2217C411E0A7AF3A1BDFD72085
+#define UUID_8AC84A2217C411E0A7AF3A1BDFD72085
+
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/quat_traits.hpp>
+#include <boost/qvm/deduce_vec.hpp>
+#include <boost/qvm/static_assert.hpp>
+#include <boost/qvm/enable_if.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class Q>
+            struct
+            quat_v_
+                {
+                template <class R>
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+
+                private:
+
+                quat_v_( quat_v_ const & );
+                quat_v_ const & operator=( quat_v_ const & );
+                ~quat_v_();
+                };
+            }
+
+        template <class V>
+        struct vec_traits;
+
+        template <class Q>
+        struct
+        vec_traits< qvm_detail::quat_v_<Q> >
+            {
+            typedef qvm_detail::quat_v_<Q> this_vector;
+            typedef typename quat_traits<Q>::scalar_type scalar_type;
+            static int const dim=3;
+
+            template <int I>
+            BOOST_QVM_INLINE_CRITICAL
+            static
+            scalar_type
+            read_element( this_vector const & q )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<dim);
+                return quat_traits<Q>::template read_element<I+1>( reinterpret_cast<Q const &>(q) );
+                }
+
+            template <int I>
+            BOOST_QVM_INLINE_CRITICAL
+            static
+            scalar_type &
+            write_element( this_vector & q )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<dim);
+                return quat_traits<Q>::template write_element<I+1>( reinterpret_cast<Q &>(q) );
+                }
+            };
+
+        template <class Q,int D>
+        struct
+        deduce_vec<qvm_detail::quat_v_<Q>,D>
+            {
+            typedef vec<typename quat_traits<Q>::scalar_type,D> type;
+            };
+
+        template <class Q,int D>
+        struct
+        deduce_vec2<qvm_detail::quat_v_<Q>,qvm_detail::quat_v_<Q>,D>
+            {
+            typedef vec<typename quat_traits<Q>::scalar_type,D> type;
+            };
+
+        template <class Q>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_quat<Q>::value,
+            qvm_detail::quat_v_<Q> const &>::type
+        V( Q const & a )
+            {
+            return reinterpret_cast<qvm_detail::quat_v_<Q> const &>(a);
+            }
+
+        template <class Q>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_quat<Q>::value,
+            qvm_detail::quat_v_<Q> &>::type
+        V( Q & a )
+            {
+            return reinterpret_cast<qvm_detail::quat_v_<Q> &>(a);
+            }
+
+        template <class Q> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_quat<Q>::value,typename quat_traits<Q>::scalar_type>::type S( Q const & a ) { return quat_traits<Q>::template read_element<0>(a); }
+        template <class Q> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_quat<Q>::value,typename quat_traits<Q>::scalar_type>::type X( Q const & a ) { return quat_traits<Q>::template read_element<1>(a); }
+        template <class Q> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_quat<Q>::value,typename quat_traits<Q>::scalar_type>::type Y( Q const & a ) { return quat_traits<Q>::template read_element<2>(a); }
+        template <class Q> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_quat<Q>::value,typename quat_traits<Q>::scalar_type>::type Z( Q const & a ) { return quat_traits<Q>::template read_element<3>(a); }
+
+        template <class Q> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_quat<Q>::value,typename quat_traits<Q>::scalar_type &>::type S( Q & a ) { return quat_traits<Q>::template write_element<0>(a); }
+        template <class Q> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_quat<Q>::value,typename quat_traits<Q>::scalar_type &>::type X( Q & a ) { return quat_traits<Q>::template write_element<1>(a); }
+        template <class Q> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_quat<Q>::value,typename quat_traits<Q>::scalar_type &>::type Y( Q & a ) { return quat_traits<Q>::template write_element<2>(a); }
+        template <class Q> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_quat<Q>::value,typename quat_traits<Q>::scalar_type &>::type Z( Q & a ) { return quat_traits<Q>::template write_element<3>(a); }
+
+        ////////////////////////////////////////////////
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/quat_operations.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/quat_operations.hpp
new file mode 100644
index 00000000000..aad0331fc67
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/quat_operations.hpp
@@ -0,0 +1,1493 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_E6519754D19211DFB8405F74DFD72085
+#define UUID_E6519754D19211DFB8405F74DFD72085
+
+#include <boost/qvm/detail/quat_assign.hpp>
+#include <boost/qvm/deduce_quat.hpp>
+#include <boost/qvm/mat_traits.hpp>
+#include <boost/qvm/scalar_traits.hpp>
+#include <boost/qvm/math.hpp>
+#include <boost/qvm/assert.hpp>
+#include <boost/qvm/error.hpp>
+#include <boost/qvm/throw_exception.hpp>
+#include <string>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        namespace
+        qvm_detail
+            {
+            BOOST_QVM_INLINE_CRITICAL
+            void const *
+            get_valid_ptr_quat_operations()
+                {
+                static int const obj=0;
+                return &obj;
+                }
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        msvc_parse_bug_workaround
+            {
+            template <class A,class B>
+            struct
+            quats
+                {
+                static bool const value=is_quat<A>::value && is_quat<B>::value;
+                };
+            }
+
+        namespace
+        qvm_to_string_detail
+            {
+            template <class T>
+            std::string to_string( T const & x );
+            }
+
+        template <class A>
+        inline
+        typename boost::enable_if_c<
+            is_quat<A>::value,
+            std::string>::type
+        to_string( A const & a )
+            {
+            using namespace qvm_to_string_detail;
+            return '('+
+                to_string(quat_traits<A>::template read_element<0>(a))+','+
+                to_string(quat_traits<A>::template read_element<1>(a))+','+
+                to_string(quat_traits<A>::template read_element<2>(a))+','+
+                to_string(quat_traits<A>::template read_element<3>(a))+')';
+            }
+
+        ////////////////////////////////////////////////
+
+        template <class A,class B,class Cmp>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<A>::value && is_quat<B>::value,
+            bool>::type
+        cmp( A const & a, B const & b, Cmp f )
+            {
+            typedef typename deduce_scalar<
+                typename quat_traits<A>::scalar_type,
+                typename quat_traits<B>::scalar_type>::type T;
+            T q1[4] =
+                {
+                quat_traits<A>::template read_element<0>(a),
+                quat_traits<A>::template read_element<1>(a),
+                quat_traits<A>::template read_element<2>(a),
+                quat_traits<A>::template read_element<3>(a)
+                };
+            T q2[4] =
+                {
+                quat_traits<B>::template read_element<0>(b),
+                quat_traits<B>::template read_element<1>(b),
+                quat_traits<B>::template read_element<2>(b),
+                quat_traits<B>::template read_element<3>(b)
+                };
+            int i;
+            for( i=0; i!=4; ++i )
+                if( !f(q1[i],q2[i]) )
+                    break;
+            if( i==4 )
+                return true;
+            for( i=0; i!=4; ++i )
+                if( !f(q1[i],-q2[i]) )
+                    return false;
+            return true;
+            }
+
+        ////////////////////////////////////////////////
+
+        template <class R,class A>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_quat<R>::value && is_quat<A>::value,
+            R>::type
+        convert_to( A const & a )
+            {
+            R r;
+            quat_traits<R>::template write_element<0>(r) = quat_traits<A>::template read_element<0>(a);
+            quat_traits<R>::template write_element<1>(r) = quat_traits<A>::template read_element<1>(a);
+            quat_traits<R>::template write_element<2>(r) = quat_traits<A>::template read_element<2>(a);
+            quat_traits<R>::template write_element<3>(r) = quat_traits<A>::template read_element<3>(a);
+            return r;
+            }
+
+        template <class R,class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<R>::value && is_mat<A>::value &&
+            mat_traits<A>::rows==3 && mat_traits<A>::cols==3,
+            R>::type
+        convert_to( A const & a )
+            {
+            typedef typename mat_traits<A>::scalar_type T;
+            T const mat[3][3] =
+                {
+                    { mat_traits<A>::template read_element<0,0>(a), mat_traits<A>::template read_element<0,1>(a), mat_traits<A>::template read_element<0,2>(a) },
+                    { mat_traits<A>::template read_element<1,0>(a), mat_traits<A>::template read_element<1,1>(a), mat_traits<A>::template read_element<1,2>(a) },
+                    { mat_traits<A>::template read_element<2,0>(a), mat_traits<A>::template read_element<2,1>(a), mat_traits<A>::template read_element<2,2>(a) }
+                };
+            R r;
+            if( mat[0][0]+mat[1][1]+mat[2][2] > scalar_traits<T>::value(0) )
+                {
+                T t = mat[0][0] + mat[1][1] + mat[2][2] + scalar_traits<T>::value(1);
+                T s = (scalar_traits<T>::value(1)/sqrt<T>(t))/2;
+                quat_traits<R>::template write_element<0>(r)=s*t;
+                quat_traits<R>::template write_element<1>(r)=(mat[2][1]-mat[1][2])*s;
+                quat_traits<R>::template write_element<2>(r)=(mat[0][2]-mat[2][0])*s;
+                quat_traits<R>::template write_element<3>(r)=(mat[1][0]-mat[0][1])*s;
+                }
+            else if( mat[0][0]>mat[1][1] && mat[0][0]>mat[2][2] )
+                {
+                T t = mat[0][0] - mat[1][1] - mat[2][2] + scalar_traits<T>::value(1);
+                T s = (scalar_traits<T>::value(1)/sqrt<T>(t))/2;
+                quat_traits<R>::template write_element<0>(r)=(mat[2][1]-mat[1][2])*s;
+                quat_traits<R>::template write_element<1>(r)=s*t;
+                quat_traits<R>::template write_element<2>(r)=(mat[1][0]+mat[0][1])*s;
+                quat_traits<R>::template write_element<3>(r)=(mat[0][2]+mat[2][0])*s;
+                }
+            else if( mat[1][1]>mat[2][2] )
+                {
+                T t = - mat[0][0] + mat[1][1] - mat[2][2] + scalar_traits<T>::value(1);
+                T s = (scalar_traits<T>::value(1)/sqrt<T>(t))/2;
+                quat_traits<R>::template write_element<0>(r)=(mat[0][2]-mat[2][0])*s;
+                quat_traits<R>::template write_element<1>(r)=(mat[1][0]+mat[0][1])*s;
+                quat_traits<R>::template write_element<2>(r)=s*t;
+                quat_traits<R>::template write_element<3>(r)=(mat[2][1]+mat[1][2])*s;
+                }
+            else
+                {
+                T t = - mat[0][0] - mat[1][1] + mat[2][2] + scalar_traits<T>::value(1);
+                T s = (scalar_traits<T>::value(1)/sqrt<T>(t))/2;
+                quat_traits<R>::template write_element<0>(r)=(mat[1][0]-mat[0][1])*s;
+                quat_traits<R>::template write_element<1>(r)=(mat[0][2]+mat[2][0])*s;
+                quat_traits<R>::template write_element<2>(r)=(mat[2][1]+mat[1][2])*s;
+                quat_traits<R>::template write_element<3>(r)=s*t;
+                }
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_quat<A>::value,
+            deduce_quat<A> >::type
+        conjugate( A const & a )
+            {
+            typedef typename deduce_quat<A>::type R;
+            R r;
+            quat_traits<R>::template write_element<0>(r)=quat_traits<A>::template read_element<0>(a);
+            quat_traits<R>::template write_element<1>(r)=-quat_traits<A>::template read_element<1>(a);
+            quat_traits<R>::template write_element<2>(r)=-quat_traits<A>::template read_element<2>(a);
+            quat_traits<R>::template write_element<3>(r)=-quat_traits<A>::template read_element<3>(a);
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class T>
+            class
+            identity_quat_
+                {
+                identity_quat_( identity_quat_ const & );
+                identity_quat_ & operator=( identity_quat_ const & );
+                ~identity_quat_();
+
+                public:
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <class T>
+        struct
+        quat_traits< qvm_detail::identity_quat_<T> >
+            {
+            typedef qvm_detail::identity_quat_<T> this_quaternion;
+            typedef T scalar_type;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_quaternion const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<4);
+                return scalar_traits<T>::value(I==0);
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int i, this_quaternion const & x )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<4);
+                return scalar_traits<T>::value(i==0);
+                }
+            };
+
+        template <class T>
+        struct
+        deduce_quat< qvm_detail::identity_quat_<T> >
+            {
+            typedef quat<T> type;
+            };
+
+        template <class T>
+        struct
+        deduce_quat2< qvm_detail::identity_quat_<T>, qvm_detail::identity_quat_<T> >
+            {
+            typedef quat<T> type;
+            };
+
+        template <class T>
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::identity_quat_<T> const &
+        identity_quat()
+            {
+            return *(qvm_detail::identity_quat_<T> const *)qvm_detail::get_valid_ptr_quat_operations();
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<A>::value,
+            void>::type
+        set_identity( A & a )
+            {
+            typedef typename quat_traits<A>::scalar_type T;
+            T const zero=scalar_traits<T>::value(0);
+            T const one=scalar_traits<T>::value(1);
+            quat_traits<A>::template write_element<0>(a) = one;
+            quat_traits<A>::template write_element<1>(a) = zero;
+            quat_traits<A>::template write_element<2>(a) = zero;
+            quat_traits<A>::template write_element<3>(a) = zero;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class OriginalType,class Scalar>
+            class
+            quaternion_scalar_cast_
+                {
+                quaternion_scalar_cast_( quaternion_scalar_cast_ const & );
+                quaternion_scalar_cast_ & operator=( quaternion_scalar_cast_ const & );
+                ~quaternion_scalar_cast_();
+
+                public:
+
+                template <class T>
+                BOOST_QVM_INLINE_TRIVIAL
+                quaternion_scalar_cast_ &
+                operator=( T const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+
+            template <bool> struct scalar_cast_quaternion_filter { };
+            template <> struct scalar_cast_quaternion_filter<true> { typedef int type; };
+            }
+
+        template <class OriginalType,class Scalar>
+        struct
+        quat_traits< qvm_detail::quaternion_scalar_cast_<OriginalType,Scalar> >
+            {
+            typedef Scalar scalar_type;
+            typedef qvm_detail::quaternion_scalar_cast_<OriginalType,Scalar> this_quaternion;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_quaternion const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<4);
+                return scalar_type(quat_traits<OriginalType>::template read_element<I>(reinterpret_cast<OriginalType const &>(x)));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int i, this_quaternion const & x )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<4);
+                return scalar_type(quat_traits<OriginalType>::read_element_idx(i,reinterpret_cast<OriginalType const &>(x)));
+                }
+            };
+
+        template <class Scalar,class T>
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::quaternion_scalar_cast_<T,Scalar> const &
+        scalar_cast( T const & x, typename qvm_detail::scalar_cast_quaternion_filter<is_quat<T>::value>::type=0 )
+            {
+            return reinterpret_cast<qvm_detail::quaternion_scalar_cast_<T,Scalar> const &>(x);
+            }
+
+        ////////////////////////////////////////////////
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<A>::value && is_scalar<B>::value,
+            A &>::type
+        operator/=( A & a, B b )
+            {
+            quat_traits<A>::template write_element<0>(a)/=b;
+            quat_traits<A>::template write_element<1>(a)/=b;
+            quat_traits<A>::template write_element<2>(a)/=b;
+            quat_traits<A>::template write_element<3>(a)/=b;
+            return a;
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_quat<A>::value && is_scalar<B>::value,
+            deduce_quat<A> >::type
+        operator/( A const & a, B b )
+            {
+            typedef typename deduce_quat<A>::type R;
+            R r;
+            quat_traits<R>::template write_element<0>(r) = quat_traits<A>::template read_element<0>(a)/b;
+            quat_traits<R>::template write_element<1>(r) = quat_traits<A>::template read_element<1>(a)/b;
+            quat_traits<R>::template write_element<2>(r) = quat_traits<A>::template read_element<2>(a)/b;
+            quat_traits<R>::template write_element<3>(r) = quat_traits<A>::template read_element<3>(a)/b;
+            return r;
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_quat<A>::value && is_quat<B>::value,
+            deduce_scalar<typename quat_traits<A>::scalar_type,typename quat_traits<B>::scalar_type> >::type
+        dot( A const & a, B const & b )
+            {
+            typedef typename quat_traits<A>::scalar_type Ta;
+            typedef typename quat_traits<B>::scalar_type Tb;
+            typedef typename deduce_scalar<Ta,Tb>::type Tr;
+            Ta const a0=quat_traits<A>::template read_element<0>(a);
+            Ta const a1=quat_traits<A>::template read_element<1>(a);
+            Ta const a2=quat_traits<A>::template read_element<2>(a);
+            Ta const a3=quat_traits<A>::template read_element<3>(a);
+            Tb const b0=quat_traits<B>::template read_element<0>(b);
+            Tb const b1=quat_traits<B>::template read_element<1>(b);
+            Tb const b2=quat_traits<B>::template read_element<2>(b);
+            Tb const b3=quat_traits<B>::template read_element<3>(b);
+            Tr const dp=a0*b0+a1*b1+a2*b2+a3*b3;
+            return dp;
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<A>::value && is_quat<B>::value,
+            bool>::type
+        operator==( A const & a, B const & b )
+            {
+            return
+                quat_traits<A>::template read_element<0>(a)==quat_traits<B>::template read_element<0>(b) &&
+                quat_traits<A>::template read_element<1>(a)==quat_traits<B>::template read_element<1>(b) &&
+                quat_traits<A>::template read_element<2>(a)==quat_traits<B>::template read_element<2>(b) &&
+                quat_traits<A>::template read_element<3>(a)==quat_traits<B>::template read_element<3>(b);
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_quat<A>::value,
+            deduce_quat<A> >::type
+        inverse( A const & a )
+            {
+            typedef typename deduce_quat<A>::type R;
+            typedef typename quat_traits<A>::scalar_type TA;
+            TA aa = quat_traits<A>::template read_element<0>(a);
+            TA ab = quat_traits<A>::template read_element<1>(a);
+            TA ac = quat_traits<A>::template read_element<2>(a);
+            TA ad = quat_traits<A>::template read_element<3>(a);
+            TA m2 = ab*ab + ac*ac + ad*ad + aa*aa;
+            if( m2==scalar_traits<TA>::value(0) )
+                BOOST_QVM_THROW_EXCEPTION(zero_magnitude_error());
+            TA rm=scalar_traits<TA>::value(1)/m2;
+            R r;
+            quat_traits<R>::template write_element<0>(r) = aa*rm;
+            quat_traits<R>::template write_element<1>(r) = -ab*rm;
+            quat_traits<R>::template write_element<2>(r) = -ac*rm;
+            quat_traits<R>::template write_element<3>(r) = -ad*rm;
+            return r;
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<A>::value,
+            typename quat_traits<A>::scalar_type>::type
+        mag_sqr( A const & a )
+            {
+            typedef typename quat_traits<A>::scalar_type T;
+            T x=quat_traits<A>::template read_element<0>(a);
+            T y=quat_traits<A>::template read_element<1>(a);
+            T z=quat_traits<A>::template read_element<2>(a);
+            T w=quat_traits<A>::template read_element<3>(a);
+            return x*x+y*y+z*z+w*w;
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<A>::value,
+            typename quat_traits<A>::scalar_type>::type
+        mag( A const & a )
+            {
+            typedef typename quat_traits<A>::scalar_type T;
+            T x=quat_traits<A>::template read_element<0>(a);
+            T y=quat_traits<A>::template read_element<1>(a);
+            T z=quat_traits<A>::template read_element<2>(a);
+            T w=quat_traits<A>::template read_element<3>(a);
+            return sqrt<T>(x*x+y*y+z*z+w*w);
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if<
+            msvc_parse_bug_workaround::quats<A,B>,
+            A &>::type
+        operator-=( A & a, B const & b )
+            {
+            quat_traits<A>::template write_element<0>(a)-=quat_traits<B>::template read_element<0>(b);
+            quat_traits<A>::template write_element<1>(a)-=quat_traits<B>::template read_element<1>(b);
+            quat_traits<A>::template write_element<2>(a)-=quat_traits<B>::template read_element<2>(b);
+            quat_traits<A>::template write_element<3>(a)-=quat_traits<B>::template read_element<3>(b);
+            return a;
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_quat<A>::value && is_quat<B>::value,
+            deduce_quat2<A,B> >::type
+        operator-( A const & a, B const & b )
+            {
+            typedef typename deduce_quat2<A,B>::type R;
+            R r;
+            quat_traits<R>::template write_element<0>(r)=quat_traits<A>::template read_element<0>(a)-quat_traits<B>::template read_element<0>(b);
+            quat_traits<R>::template write_element<1>(r)=quat_traits<A>::template read_element<1>(a)-quat_traits<B>::template read_element<1>(b);
+            quat_traits<R>::template write_element<2>(r)=quat_traits<A>::template read_element<2>(a)-quat_traits<B>::template read_element<2>(b);
+            quat_traits<R>::template write_element<3>(r)=quat_traits<A>::template read_element<3>(a)-quat_traits<B>::template read_element<3>(b);
+            return r;
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_quat<A>::value,
+            deduce_quat<A> >::type
+        operator-( A const & a )
+            {
+            typedef typename deduce_quat<A>::type R;
+            R r;
+            quat_traits<R>::template write_element<0>(r)=-quat_traits<A>::template read_element<0>(a);
+            quat_traits<R>::template write_element<1>(r)=-quat_traits<A>::template read_element<1>(a);
+            quat_traits<R>::template write_element<2>(r)=-quat_traits<A>::template read_element<2>(a);
+            quat_traits<R>::template write_element<3>(r)=-quat_traits<A>::template read_element<3>(a);
+            return r;
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if<
+            msvc_parse_bug_workaround::quats<A,B>,
+            A &>::type
+        operator*=( A & a, B const & b )
+            {
+            typedef typename quat_traits<A>::scalar_type TA;
+            typedef typename quat_traits<B>::scalar_type TB;
+            TA const aa=quat_traits<A>::template read_element<0>(a);
+            TA const ab=quat_traits<A>::template read_element<1>(a);
+            TA const ac=quat_traits<A>::template read_element<2>(a);
+            TA const ad=quat_traits<A>::template read_element<3>(a);
+            TB const ba=quat_traits<B>::template read_element<0>(b);
+            TB const bb=quat_traits<B>::template read_element<1>(b);
+            TB const bc=quat_traits<B>::template read_element<2>(b);
+            TB const bd=quat_traits<B>::template read_element<3>(b);
+            quat_traits<A>::template write_element<0>(a) = aa*ba - ab*bb - ac*bc - ad*bd;
+            quat_traits<A>::template write_element<1>(a) = aa*bb + ab*ba + ac*bd - ad*bc;
+            quat_traits<A>::template write_element<2>(a) = aa*bc + ac*ba + ad*bb - ab*bd;
+            quat_traits<A>::template write_element<3>(a) = aa*bd + ad*ba + ab*bc - ac*bb;
+            return a;
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<A>::value && is_scalar<B>::value,
+            A &>::type
+        operator*=( A & a, B b )
+            {
+            quat_traits<A>::template write_element<0>(a)*=b;
+            quat_traits<A>::template write_element<1>(a)*=b;
+            quat_traits<A>::template write_element<2>(a)*=b;
+            quat_traits<A>::template write_element<3>(a)*=b;
+            return a;
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_quat<A>::value && is_quat<B>::value,
+            deduce_quat2<A,B> >::type
+        operator*( A const & a, B const & b )
+            {
+            typedef typename deduce_quat2<A,B>::type R;
+            typedef typename quat_traits<A>::scalar_type TA;
+            typedef typename quat_traits<B>::scalar_type TB;
+            TA const aa=quat_traits<A>::template read_element<0>(a);
+            TA const ab=quat_traits<A>::template read_element<1>(a);
+            TA const ac=quat_traits<A>::template read_element<2>(a);
+            TA const ad=quat_traits<A>::template read_element<3>(a);
+            TB const ba=quat_traits<B>::template read_element<0>(b);
+            TB const bb=quat_traits<B>::template read_element<1>(b);
+            TB const bc=quat_traits<B>::template read_element<2>(b);
+            TB const bd=quat_traits<B>::template read_element<3>(b);
+            R r;
+            quat_traits<R>::template write_element<0>(r) = aa*ba - ab*bb - ac*bc - ad*bd;
+            quat_traits<R>::template write_element<1>(r) = aa*bb + ab*ba + ac*bd - ad*bc;
+            quat_traits<R>::template write_element<2>(r) = aa*bc + ac*ba + ad*bb - ab*bd;
+            quat_traits<R>::template write_element<3>(r) = aa*bd + ad*ba + ab*bc - ac*bb;
+            return r;
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_quat<A>::value && is_scalar<B>::value,
+            deduce_quat<A> >::type
+        operator*( A const & a, B b )
+            {
+            typedef typename deduce_quat<A>::type R;
+            R r;
+            quat_traits<R>::template write_element<0>(r)=quat_traits<A>::template read_element<0>(a)*b;
+            quat_traits<R>::template write_element<1>(r)=quat_traits<A>::template read_element<1>(a)*b;
+            quat_traits<R>::template write_element<2>(r)=quat_traits<A>::template read_element<2>(a)*b;
+            quat_traits<R>::template write_element<3>(r)=quat_traits<A>::template read_element<3>(a)*b;
+            return r;
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<A>::value && is_quat<B>::value,
+            bool>::type
+        operator!=( A const & a, B const & b )
+            {
+            return
+                quat_traits<A>::template read_element<0>(a)!=quat_traits<B>::template read_element<0>(b) ||
+                quat_traits<A>::template read_element<1>(a)!=quat_traits<B>::template read_element<1>(b) ||
+                quat_traits<A>::template read_element<2>(a)!=quat_traits<B>::template read_element<2>(b) ||
+                quat_traits<A>::template read_element<3>(a)!=quat_traits<B>::template read_element<3>(b);
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_quat<A>::value,
+            deduce_quat<A> >::type
+        normalized( A const & a )
+            {
+            typedef typename quat_traits<A>::scalar_type T;
+            T const a0=quat_traits<A>::template read_element<0>(a);
+            T const a1=quat_traits<A>::template read_element<1>(a);
+            T const a2=quat_traits<A>::template read_element<2>(a);
+            T const a3=quat_traits<A>::template read_element<3>(a);
+            T const m2=a0*a0+a1*a1+a2*a2+a3*a3;
+            if( m2==scalar_traits<typename quat_traits<A>::scalar_type>::value(0) )
+                BOOST_QVM_THROW_EXCEPTION(zero_magnitude_error());
+            T const rm=scalar_traits<T>::value(1)/sqrt<T>(m2);
+            typedef typename deduce_quat<A>::type R;
+            R r;
+            quat_traits<R>::template write_element<0>(r)=a0*rm;
+            quat_traits<R>::template write_element<1>(r)=a1*rm;
+            quat_traits<R>::template write_element<2>(r)=a2*rm;
+            quat_traits<R>::template write_element<3>(r)=a3*rm;
+            return r;
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<A>::value,
+            void>::type
+        normalize( A & a )
+            {
+            typedef typename quat_traits<A>::scalar_type T;
+            T const a0=quat_traits<A>::template read_element<0>(a);
+            T const a1=quat_traits<A>::template read_element<1>(a);
+            T const a2=quat_traits<A>::template read_element<2>(a);
+            T const a3=quat_traits<A>::template read_element<3>(a);
+            T const m2=a0*a0+a1*a1+a2*a2+a3*a3;
+            if( m2==scalar_traits<typename quat_traits<A>::scalar_type>::value(0) )
+                BOOST_QVM_THROW_EXCEPTION(zero_magnitude_error());
+            T const rm=scalar_traits<T>::value(1)/sqrt<T>(m2);
+            quat_traits<A>::template write_element<0>(a)*=rm;
+            quat_traits<A>::template write_element<1>(a)*=rm;
+            quat_traits<A>::template write_element<2>(a)*=rm;
+            quat_traits<A>::template write_element<3>(a)*=rm;
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if<
+            msvc_parse_bug_workaround::quats<A,B>,
+            A &>::type
+        operator+=( A & a, B const & b )
+            {
+            quat_traits<A>::template write_element<0>(a)+=quat_traits<B>::template read_element<0>(b);
+            quat_traits<A>::template write_element<1>(a)+=quat_traits<B>::template read_element<1>(b);
+            quat_traits<A>::template write_element<2>(a)+=quat_traits<B>::template read_element<2>(b);
+            quat_traits<A>::template write_element<3>(a)+=quat_traits<B>::template read_element<3>(b);
+            return a;
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_quat<A>::value && is_quat<B>::value,
+            deduce_quat2<A,B> >::type
+        operator+( A const & a, B const & b )
+            {
+            typedef typename deduce_quat2<A,B>::type R;
+            R r;
+            quat_traits<R>::template write_element<0>(r)=quat_traits<A>::template read_element<0>(a)+quat_traits<B>::template read_element<0>(b);
+            quat_traits<R>::template write_element<1>(r)=quat_traits<A>::template read_element<1>(a)+quat_traits<B>::template read_element<1>(b);
+            quat_traits<R>::template write_element<2>(r)=quat_traits<A>::template read_element<2>(a)+quat_traits<B>::template read_element<2>(b);
+            quat_traits<R>::template write_element<3>(r)=quat_traits<A>::template read_element<3>(a)+quat_traits<B>::template read_element<3>(b);
+            return r;
+            }
+
+        template <class A,class B,class C>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_quat<A>::value && is_quat<B>::value && is_scalar<C>::value,
+            deduce_quat2<A,B> >::type
+        slerp( A const & a, B const & b, C t )
+            {
+            typedef typename deduce_quat2<A,B>::type R;
+            typedef typename quat_traits<R>::scalar_type TR;
+            TR const one = scalar_traits<TR>::value(1);
+            TR dp = dot(a,b);
+            TR sc=one;
+            if( dp < one )
+                {
+                TR const theta = acosf(dp);
+                TR const invsintheta = one/sin<TR>(theta);
+                TR const scale = sin<TR>(theta*(one-t)) * invsintheta;
+                TR const invscale = sin<TR>(theta*t) * invsintheta * sc;
+                return a*scale + b*invscale;
+                }
+            else
+                return normalized(a+(b-a)*t);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class T>
+            class
+            qref_
+                {
+                qref_( qref_ const & );
+                qref_ & operator=( qref_ const & );
+                ~qref_();
+
+                public:
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                qref_ &
+                operator=( R const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <class Q>
+        struct quat_traits;
+
+        template <class Q>
+        struct
+        quat_traits< qvm_detail::qref_<Q> >
+            {
+            typedef typename quat_traits<Q>::scalar_type scalar_type;
+            typedef qvm_detail::qref_<Q> this_quaternion;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_quaternion const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<4);
+                return quat_traits<Q>::template read_element<I>(reinterpret_cast<Q const &>(x));
+                }
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_quaternion & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<4);
+                return quat_traits<Q>::template write_element<I>(reinterpret_cast<Q &>(x));
+                }
+            };
+
+        template <class Q>
+        struct
+        deduce_quat< qvm_detail::qref_<Q> >
+            {
+            typedef quat<typename quat_traits<Q>::scalar_type> type;
+            };
+
+        template <class Q>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_quat<Q>::value,
+            qvm_detail::qref_<Q> const &>::type
+        qref( Q const & a )
+            {
+            return reinterpret_cast<qvm_detail::qref_<Q> const &>(a);
+            }
+
+        template <class Q>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_quat<Q>::value,
+            qvm_detail::qref_<Q> &>::type
+        qref( Q & a )
+            {
+            return reinterpret_cast<qvm_detail::qref_<Q> &>(a);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class T>
+            class
+            zero_q_
+                {
+                zero_q_( zero_q_ const & );
+                zero_q_ & operator=( zero_q_ const & );
+                ~zero_q_();
+
+                public:
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <class T>
+        struct
+        quat_traits< qvm_detail::zero_q_<T> >
+            {
+            typedef qvm_detail::zero_q_<T> this_quaternion;
+            typedef T scalar_type;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_quaternion const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<4);
+                return scalar_traits<scalar_type>::value(0);
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int i, this_quaternion const & x )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<4);
+                return scalar_traits<scalar_type>::value(0);
+                }
+            };
+
+        template <class T>
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::zero_q_<T> const &
+        zero_quat()
+            {
+            return *(qvm_detail::zero_q_<T> const *)qvm_detail::get_valid_ptr_quat_operations();
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<A>::value,
+            void>::type
+        set_zero( A & a )
+            {
+            typedef typename quat_traits<A>::scalar_type T;
+            T const zero=scalar_traits<T>::value(0);
+            quat_traits<A>::template write_element<0>(a) = zero;
+            quat_traits<A>::template write_element<1>(a) = zero;
+            quat_traits<A>::template write_element<2>(a) = zero;
+            quat_traits<A>::template write_element<3>(a) = zero;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class V>
+            struct
+            rot_quat_
+                {
+                typedef typename vec_traits<V>::scalar_type scalar_type;
+                scalar_type a[4];
+
+                template <class Angle>
+                BOOST_QVM_INLINE
+                rot_quat_( V const & axis, Angle angle )
+                    {
+                    scalar_type const x=vec_traits<V>::template read_element<0>(axis);
+                    scalar_type const y=vec_traits<V>::template read_element<1>(axis);
+                    scalar_type const z=vec_traits<V>::template read_element<2>(axis);
+                    scalar_type const m2=x*x+y*y+z*z;
+                    if( m2==scalar_traits<scalar_type>::value(0) )
+                        BOOST_QVM_THROW_EXCEPTION(zero_magnitude_error());
+                    scalar_type const rm=scalar_traits<scalar_type>::value(1)/sqrt<scalar_type>(m2);
+                    angle/=2;
+                    scalar_type const s=sin<Angle>(angle);
+                    a[0] = cos<Angle>(angle);
+                    a[1] = rm*x*s;
+                    a[2] = rm*y*s;
+                    a[3] = rm*z*s;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <class V>
+        struct
+        quat_traits< qvm_detail::rot_quat_<V> >
+            {
+            typedef qvm_detail::rot_quat_<V> this_quaternion;
+            typedef typename this_quaternion::scalar_type scalar_type;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_quaternion const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<4);
+                return x.a[I];
+                }
+            };
+
+        template <class V>
+        struct
+        deduce_quat< qvm_detail::rot_quat_<V> >
+            {
+            typedef quat<typename vec_traits<V>::scalar_type> type;
+            };
+
+        template <class A,class Angle>
+        BOOST_QVM_INLINE
+        typename enable_if_c<
+            is_vec<A>::value && vec_traits<A>::dim==3,
+            qvm_detail::rot_quat_<A> >::type
+        rot_quat( A const & axis, Angle angle )
+            {
+            return qvm_detail::rot_quat_<A>(axis,angle);
+            }
+
+        template <class A,class B,class Angle>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<A>::value &&
+            is_vec<B>::value && vec_traits<B>::dim==3,
+            void>::type
+        set_rot( A & a, B const & axis, Angle angle )
+            {
+            assign(a,rot_quat(axis,angle));
+            }
+
+        template <class A,class B,class Angle>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<A>::value &&
+            is_vec<B>::value && vec_traits<B>::dim==3,
+            void>::type
+        rotate( A & a, B const & axis, Angle angle )
+            {
+            a *= rot_quat(axis,angle);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class T>
+            struct
+            rotx_quat_
+                {
+                BOOST_QVM_INLINE_TRIVIAL
+                rotx_quat_()
+                    {
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+
+                private:
+
+                rotx_quat_( rotx_quat_ const & );
+                rotx_quat_ & operator=( rotx_quat_ const & );
+                ~rotx_quat_();
+                };
+
+            template <int I>
+            struct
+            rotx_q_get
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & )
+                    {
+                    return scalar_traits<T>::value(0);
+                    }
+                };
+
+            template <>
+            struct
+            rotx_q_get<1>
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & angle )
+                    {
+                    return sin<T>(angle/2);
+                    }
+                };
+
+            template <>
+            struct
+            rotx_q_get<0>
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & angle )
+                    {
+                    return cos<T>(angle/2);
+                    }
+                };
+            }
+
+        template <class Angle>
+        struct
+        quat_traits< qvm_detail::rotx_quat_<Angle> >
+            {
+            typedef qvm_detail::rotx_quat_<Angle> this_quaternion;
+            typedef Angle scalar_type;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_quaternion const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<4);
+                return qvm_detail::rotx_q_get<I>::get(reinterpret_cast<Angle const &>(x));
+                }
+            };
+
+        template <class Angle>
+        struct
+        deduce_quat< qvm_detail::rotx_quat_<Angle> >
+            {
+            typedef quat<Angle> type;
+            };
+
+        template <class Angle>
+        struct
+        deduce_quat2< qvm_detail::rotx_quat_<Angle>, qvm_detail::rotx_quat_<Angle> >
+            {
+            typedef quat<Angle> type;
+            };
+
+        template <class Angle>
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::rotx_quat_<Angle> const &
+        rotx_quat( Angle const & angle )
+            {
+            return reinterpret_cast<qvm_detail::rotx_quat_<Angle> const &>(angle);
+            }
+
+        template <class A,class Angle>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<A>::value,
+            void>::type
+        set_rotx( A & a, Angle angle )
+            {
+            assign(a,rotx_quat(angle));
+            }
+
+        template <class A,class Angle>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<A>::value,
+            void>::type
+        rotate_x( A & a, Angle angle )
+            {
+            a *= rotx_quat(angle);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class T>
+            struct
+            roty_quat_
+                {
+                BOOST_QVM_INLINE_TRIVIAL
+                roty_quat_()
+                    {
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+
+                private:
+
+                roty_quat_( roty_quat_ const & );
+                roty_quat_ & operator=( roty_quat_ const & );
+                ~roty_quat_();
+                };
+
+            template <int I>
+            struct
+            roty_q_get
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & )
+                    {
+                    return scalar_traits<T>::value(0);
+                    }
+                };
+
+            template <>
+            struct
+            roty_q_get<2>
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & angle )
+                    {
+                    return sin<T>(angle/2);
+                    }
+                };
+
+            template <>
+            struct
+            roty_q_get<0>
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & angle )
+                    {
+                    return cos<T>(angle/2);
+                    }
+                };
+            }
+
+        template <class Angle>
+        struct
+        quat_traits< qvm_detail::roty_quat_<Angle> >
+            {
+            typedef qvm_detail::roty_quat_<Angle> this_quaternion;
+            typedef Angle scalar_type;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_quaternion const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<4);
+                return qvm_detail::roty_q_get<I>::get(reinterpret_cast<Angle const &>(x));
+                }
+            };
+
+        template <class Angle>
+        struct
+        deduce_quat< qvm_detail::roty_quat_<Angle> >
+            {
+            typedef quat<Angle> type;
+            };
+
+        template <class Angle>
+        struct
+        deduce_quat2< qvm_detail::roty_quat_<Angle>, qvm_detail::roty_quat_<Angle> >
+            {
+            typedef quat<Angle> type;
+            };
+
+        template <class Angle>
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::roty_quat_<Angle> const &
+        roty_quat( Angle const & angle )
+            {
+            return reinterpret_cast<qvm_detail::roty_quat_<Angle> const &>(angle);
+            }
+
+        template <class A,class Angle>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<A>::value,
+            void>::type
+        set_roty( A & a, Angle angle )
+            {
+            assign(a,roty_quat(angle));
+            }
+
+        template <class A,class Angle>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<A>::value,
+            void>::type
+        rotate_y( A & a, Angle angle )
+            {
+            a *= roty_quat(angle);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class T>
+            struct
+            rotz_quat_
+                {
+                BOOST_QVM_INLINE_TRIVIAL
+                rotz_quat_()
+                    {
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+
+                private:
+
+                rotz_quat_( rotz_quat_ const & );
+                rotz_quat_ & operator=( rotz_quat_ const & );
+                ~rotz_quat_();
+                };
+
+            template <int I>
+            struct
+            rotz_q_get
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & )
+                    {
+                    return scalar_traits<T>::value(0);
+                    }
+                };
+
+            template <>
+            struct
+            rotz_q_get<3>
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & angle )
+                    {
+                    return sin<T>(angle/2);
+                    }
+                };
+
+            template <>
+            struct
+            rotz_q_get<0>
+                {
+                template <class T>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                T
+                get( T const & angle )
+                    {
+                    return cos<T>(angle/2);
+                    }
+                };
+            }
+
+        template <class Angle>
+        struct
+        quat_traits< qvm_detail::rotz_quat_<Angle> >
+            {
+            typedef qvm_detail::rotz_quat_<Angle> this_quaternion;
+            typedef Angle scalar_type;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_quaternion const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<4);
+                return qvm_detail::rotz_q_get<I>::get(reinterpret_cast<Angle const &>(x));
+                }
+            };
+
+        template <class Angle>
+        struct
+        deduce_quat< qvm_detail::rotz_quat_<Angle> >
+            {
+            typedef quat<Angle> type;
+            };
+
+        template <class Angle>
+        struct
+        deduce_quat2< qvm_detail::rotz_quat_<Angle>, qvm_detail::rotz_quat_<Angle> >
+            {
+            typedef quat<Angle> type;
+            };
+
+        template <class Angle>
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::rotz_quat_<Angle> const &
+        rotz_quat( Angle const & angle )
+            {
+            return reinterpret_cast<qvm_detail::rotz_quat_<Angle> const &>(angle);
+            }
+
+        template <class A,class Angle>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<A>::value,
+            void>::type
+        set_rotz( A & a, Angle angle )
+            {
+            assign(a,rotz_quat(angle));
+            }
+
+        template <class A,class Angle>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<A>::value,
+            void>::type
+        rotate_z( A & a, Angle angle )
+            {
+            a *= rotz_quat(angle);
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_quat<A>::value && is_vec<B>::value && vec_traits<B>::dim==3,
+            typename quat_traits<A>::scalar_type>::type
+        axis_angle( A const & a, B & b )
+            {
+            typedef typename quat_traits<A>::scalar_type T;
+            T a0=quat_traits<A>::template read_element<0>(a);
+            T a1=quat_traits<A>::template read_element<1>(a);
+            T a2=quat_traits<A>::template read_element<2>(a);
+            T a3=quat_traits<A>::template read_element<3>(a);
+            if( a0>1 )
+                {
+                T const m2=a0*a0+a1*a1+a2*a2+a3*a3;
+                if( m2==scalar_traits<T>::value(0) )
+                    BOOST_QVM_THROW_EXCEPTION(zero_magnitude_error());
+                T const s=sqrt<T>(m2);
+                a0/=s;
+                a1/=s;
+                a2/=s;
+                a3/=s;
+                }
+            if( T s=sqrt<T>(1-a0*a0) )
+                {
+                vec_traits<B>::template write_element<0>(b) = a1/s;
+                vec_traits<B>::template write_element<1>(b) = a2/s;
+                vec_traits<B>::template write_element<2>(b) = a3/s;
+                }
+            else
+                {
+                typedef typename vec_traits<B>::scalar_type T;
+                vec_traits<B>::template write_element<0>(b) = scalar_traits<T>::value(1);
+                vec_traits<B>::template write_element<1>(b) = vec_traits<B>::template write_element<2>(b) = scalar_traits<T>::value(0);
+                }
+            return scalar_traits<T>::value(2) * qvm::acos(a0);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::assign;
+            using ::boost::qvm::cmp;
+            using ::boost::qvm::convert_to;
+            using ::boost::qvm::conjugate;
+            using ::boost::qvm::set_identity;
+            using ::boost::qvm::set_zero;
+            using ::boost::qvm::scalar_cast;
+            using ::boost::qvm::operator/=;
+            using ::boost::qvm::operator/;
+            using ::boost::qvm::dot;
+            using ::boost::qvm::operator==;
+            using ::boost::qvm::inverse;
+            using ::boost::qvm::mag_sqr;
+            using ::boost::qvm::mag;
+            using ::boost::qvm::slerp;
+            using ::boost::qvm::operator-=;
+            using ::boost::qvm::operator-;
+            using ::boost::qvm::operator*=;
+            using ::boost::qvm::operator*;
+            using ::boost::qvm::operator!=;
+            using ::boost::qvm::normalized;
+            using ::boost::qvm::normalize;
+            using ::boost::qvm::operator+=;
+            using ::boost::qvm::operator+;
+            using ::boost::qvm::qref;
+            using ::boost::qvm::rot_quat;
+            using ::boost::qvm::set_rot;
+            using ::boost::qvm::rotate;
+            using ::boost::qvm::rotx_quat;
+            using ::boost::qvm::set_rotx;
+            using ::boost::qvm::rotate_x;
+            using ::boost::qvm::roty_quat;
+            using ::boost::qvm::set_roty;
+            using ::boost::qvm::rotate_y;
+            using ::boost::qvm::rotz_quat;
+            using ::boost::qvm::set_rotz;
+            using ::boost::qvm::rotate_z;
+            }
+
+        ////////////////////////////////////////////////
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/quat_traits.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/quat_traits.hpp
new file mode 100644
index 00000000000..9c46a049eba
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/quat_traits.hpp
@@ -0,0 +1,49 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_EF321CBE275911E084A4550FDFD72085
+#define UUID_EF321CBE275911E084A4550FDFD72085
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class Q>
+        struct
+        quat_traits
+            {
+            typedef void scalar_type;
+            };
+
+        namespace
+        is_quaternion_detail
+            {
+            template <class>
+            struct
+            is_void
+                {
+                static bool const value=false;
+                };
+
+            template <>
+            struct
+            is_void<void>
+                {
+                static bool const value=true;
+                };
+            }
+
+        template <class T>
+        struct
+        is_quat
+            {
+            static bool const value=!is_quaternion_detail::is_void<typename quat_traits<T>::scalar_type>::value;
+            };
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/quat_traits_array.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/quat_traits_array.hpp
new file mode 100644
index 00000000000..f3b13d2dd56
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/quat_traits_array.hpp
@@ -0,0 +1,130 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_6D6B1EE2119A11E291554FEE6188709B
+#define UUID_6D6B1EE2119A11E291554FEE6188709B
+
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/deduce_quat.hpp>
+#include <boost/qvm/detail/remove_const.hpp>
+#include <boost/qvm/assert.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class T,int D>
+        struct
+        quat_traits<T[D]>
+            {
+            typedef void scalar_type;
+            };
+        template <class T,int D>
+        struct
+        quat_traits<T[D][4]>
+            {
+            typedef void scalar_type;
+            };
+        template <class T,int D>
+        struct
+        quat_traits<T[4][D]>
+            {
+            typedef void scalar_type;
+            };
+        template <class T>
+        struct
+        quat_traits<T[4][4]>
+            {
+            typedef void scalar_type;
+            };
+        template <class T,int M,int N>
+        struct
+        quat_traits<T[M][N]>
+            {
+            typedef void scalar_type;
+            };
+
+        template <class T>
+        struct
+        quat_traits<T[4]>
+            {
+            typedef T this_quaternion[4];
+            typedef typename qvm_detail::remove_const<T>::type scalar_type;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_quaternion const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<4);
+                return x[I];
+                }
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_quaternion & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<4);
+                return x[I];
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int i, this_quaternion const & x )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<4);
+                return x[i];
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int i, this_quaternion & x )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<4);
+                return x[i];
+                }
+            };
+
+        template <class T>
+        struct
+        deduce_quat<T[4]>
+            {
+            typedef quat<T> type;
+            };
+
+        template <class T>
+        struct
+        deduce_quat<T const[4]>
+            {
+            typedef quat<T> type;
+            };
+
+        template <class T1,class T2>
+        struct
+        deduce_quat2<T1[4],T2[4]>
+            {
+            typedef quat<typename deduce_scalar<T1,T2>::type> type;
+            };
+
+        template <class T>
+        T (&ptr_qref( T * ptr ))[4]
+            {
+            return *reinterpret_cast<T (*)[4]>(ptr);
+            }
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/quat_traits_defaults.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/quat_traits_defaults.hpp
new file mode 100644
index 00000000000..a343b2a3ada
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/quat_traits_defaults.hpp
@@ -0,0 +1,40 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_0595DEC2C72D11E6B6B77C2A07624D53
+#define UUID_0595DEC2C72D11E6B6B77C2A07624D53
+
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/assert.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class>
+        struct quat_traits;
+
+        template <class QuatType,class ScalarType>
+        struct
+        quat_traits_defaults
+            {
+            typedef QuatType quat_type;
+            typedef ScalarType scalar_type;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( quat_type const & x )
+                {
+                return quat_traits<quat_type>::template write_element<I>(const_cast<quat_type &>(x));
+                }
+            };
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/quat_vec_operations.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/quat_vec_operations.hpp
new file mode 100644
index 00000000000..bbdf33c3903
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/quat_vec_operations.hpp
@@ -0,0 +1,62 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_51968952D30A11DFAFE78CE3DFD72085
+#define UUID_51968952D30A11DFAFE78CE3DFD72085
+
+#include <boost/qvm/quat_traits.hpp>
+#include <boost/qvm/deduce_vec.hpp>
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/enable_if.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_quat<A>::value &&
+            is_vec<B>::value && vec_traits<B>::dim==3,
+            deduce_vec2<A,B,3> >::type
+        operator*( A const & a, B const & b )
+            {
+            typedef typename deduce_vec2<A,B,3>::type R;
+            typedef typename quat_traits<A>::scalar_type TA;
+            typedef typename vec_traits<B>::scalar_type TB;
+            TA const aa = quat_traits<A>::template read_element<0>(a);
+            TA const ab = quat_traits<A>::template read_element<1>(a);
+            TA const ac = quat_traits<A>::template read_element<2>(a);
+            TA const ad = quat_traits<A>::template read_element<3>(a);
+            TA const t2 = aa*ab;
+            TA const t3 = aa*ac;
+            TA const t4 = aa*ad;
+            TA const t5 = -ab*ab;
+            TA const t6 = ab*ac;
+            TA const t7 = ab*ad;
+            TA const t8 = -ac*ac;
+            TA const t9 = ac*ad;
+            TA const t10     = -ad*ad;
+            TB const bx = vec_traits<B>::template read_element<0>(b);
+            TB const by = vec_traits<B>::template read_element<1>(b);
+            TB const bz = vec_traits<B>::template read_element<2>(b);
+            R r;
+            vec_traits<R>::template write_element<0>(r) = 2*((t8+t10)*bx + (t6-t4)*by + (t3+t7)*bz) + bx;
+            vec_traits<R>::template write_element<1>(r) = 2*((t4+t6)*bx + (t5+t10)*by + (t9-t2)*bz) + by;
+            vec_traits<R>::template write_element<2>(r) = 2*((t7-t3)*bx + (t2+t9)*by + (t5+t8)*bz) + bz;
+            return r;
+            }
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            }
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/scalar_traits.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/scalar_traits.hpp
new file mode 100644
index 00000000000..8552dfa0abf
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/scalar_traits.hpp
@@ -0,0 +1,92 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_57E1C032B9F311DEB7D9BAFE55D89593
+#define UUID_57E1C032B9F311DEB7D9BAFE55D89593
+
+#include <boost/qvm/quat_traits.hpp>
+#include <boost/qvm/vec_traits.hpp>
+#include <boost/qvm/mat_traits.hpp>
+#include <boost/qvm/inline.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class Scalar>
+        struct
+        scalar_traits
+            {
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            Scalar
+            value( int v )
+                {
+                return Scalar(v);
+                }
+            };
+
+        template <class T>
+        struct
+        is_scalar
+            {
+            static bool const value=false;
+            };
+        template <> struct is_scalar<char> { static bool const value=true; };
+        template <> struct is_scalar<signed char> { static bool const value=true; };
+        template <> struct is_scalar<unsigned char> { static bool const value=true; };
+        template <> struct is_scalar<signed short> { static bool const value=true; };
+        template <> struct is_scalar<unsigned short> { static bool const value=true; };
+        template <> struct is_scalar<signed int> { static bool const value=true; };
+        template <> struct is_scalar<unsigned int> { static bool const value=true; };
+        template <> struct is_scalar<signed long> { static bool const value=true; };
+        template <> struct is_scalar<unsigned long> { static bool const value=true; };
+        template <> struct is_scalar<float> { static bool const value=true; };
+        template <> struct is_scalar<double> { static bool const value=true; };
+        template <> struct is_scalar<long double> { static bool const value=true; };
+
+        namespace
+        qvm_detail
+            {
+            template <class A,bool M=is_mat<A>::value,bool Q=is_quat<A>::value,bool V=is_vec<A>::value>
+            struct
+            scalar_impl
+                {
+                };
+
+            template <class A>
+            struct
+            scalar_impl<A,true,false,false>
+                {
+                typedef typename mat_traits<A>::scalar_type type;
+                };
+
+            template <class A>
+            struct
+            scalar_impl<A,false,true,false>
+                {
+                typedef typename quat_traits<A>::scalar_type type;
+                };
+
+            template <class A>
+            struct
+            scalar_impl<A,false,false,true>
+                {
+                typedef typename vec_traits<A>::scalar_type type;
+                };
+            }
+
+        template <class A>
+        struct
+        scalar
+            {
+            typedef typename qvm_detail::scalar_impl<A>::type type;
+            };
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/static_assert.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/static_assert.hpp
new file mode 100644
index 00000000000..e97ff4c5191
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/static_assert.hpp
@@ -0,0 +1,9 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_STATIC_ASSERT
+#include <boost/static_assert.hpp>
+#define BOOST_QVM_STATIC_ASSERT BOOST_STATIC_ASSERT
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/swizzle.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/swizzle.hpp
new file mode 100644
index 00000000000..9275f263ae1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/swizzle.hpp
@@ -0,0 +1,13 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_3B4919D8A41411DEB0818E4C56D89593
+#define UUID_3B4919D8A41411DEB0818E4C56D89593
+
+#include <boost/qvm/swizzle2.hpp>
+#include <boost/qvm/swizzle3.hpp>
+#include <boost/qvm/swizzle4.hpp>
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/swizzle2.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/swizzle2.hpp
new file mode 100644
index 00000000000..0a5771645e1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/swizzle2.hpp
@@ -0,0 +1,6 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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)
+
+#include <boost/qvm/gen/swizzle2.hpp>
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/swizzle3.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/swizzle3.hpp
new file mode 100644
index 00000000000..7a561db07e2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/swizzle3.hpp
@@ -0,0 +1,6 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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)
+
+#include <boost/qvm/gen/swizzle3.hpp>
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/swizzle4.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/swizzle4.hpp
new file mode 100644
index 00000000000..ee3592ea6b9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/swizzle4.hpp
@@ -0,0 +1,6 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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)
+
+#include <boost/qvm/gen/swizzle4.hpp>
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/throw_exception.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/throw_exception.hpp
new file mode 100644
index 00000000000..83a498ea6b5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/throw_exception.hpp
@@ -0,0 +1,9 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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_QVM_THROW_EXCEPTION
+#include <boost/throw_exception.hpp>
+#define BOOST_QVM_THROW_EXCEPTION BOOST_THROW_EXCEPTION
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/to_string.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/to_string.hpp
new file mode 100644
index 00000000000..d1826ea56e4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/to_string.hpp
@@ -0,0 +1,31 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_2812944066B011E29F616DCB6188709B
+#define UUID_2812944066B011E29F616DCB6188709B
+
+#include <boost/exception/to_string.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        namespace
+        qvm_to_string_detail
+            {
+            template <class T>
+            std::string
+            to_string( T const & x )
+                {
+                using boost::to_string;
+                return to_string(x);
+                }
+            }
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/vec.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/vec.hpp
new file mode 100644
index 00000000000..950e58f4298
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/vec.hpp
@@ -0,0 +1,89 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_44EB56F0A33711DEB31B41BB56D89593
+#define UUID_44EB56F0A33711DEB31B41BB56D89593
+
+#include <boost/qvm/detail/vec_assign.hpp>
+#include <boost/qvm/assert.hpp>
+#include <boost/qvm/static_assert.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class T,int D>
+        struct
+        vec
+            {
+            T a[D];
+            template <class R>
+            operator R() const
+                {
+                R r;
+                assign(r,*this);
+                return r;
+                }
+            };
+
+        template <class V>
+        struct vec_traits;
+
+        template <class T,int Dim>
+        struct
+        vec_traits< vec<T,Dim> >
+            {
+            typedef vec<T,Dim> this_vector;
+            typedef T scalar_type;
+            static int const dim=Dim;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_vector const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<dim);
+                return x.a[I];
+                }
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_vector & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<dim);
+                return x.a[I];
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int i, this_vector const & x )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<dim);
+                return x.a[i];
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int i, this_vector & x )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<dim);
+                return x.a[i];
+                }
+            };
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/vec_access.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/vec_access.hpp
new file mode 100644
index 00000000000..add176b03a1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/vec_access.hpp
@@ -0,0 +1,82 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_10F2D1EA17B511E0BA29FE0BDFD72085
+#define UUID_10F2D1EA17B511E0BA29FE0BDFD72085
+
+#include <boost/qvm/vec_traits.hpp>
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/static_assert.hpp>
+#include <boost/qvm/enable_if.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        ////////////////////////////////////////////////
+
+        template <int I,class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value,
+            typename vec_traits<V>::scalar_type>::type
+        A( V const & a )
+            {
+            BOOST_STATIC_ASSERT(I>=0);
+            BOOST_STATIC_ASSERT(I<vec_traits<V>::dim);
+            return vec_traits<V>::template read_element<I>(a);
+            }
+
+        template <int I,class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value,
+            typename vec_traits<V>::scalar_type &>::type
+        A( V & a )
+            {
+            BOOST_STATIC_ASSERT(I>=0);
+            BOOST_STATIC_ASSERT(I<vec_traits<V>::dim);
+            return vec_traits<V>::template write_element<I>(a);
+            }
+
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type>::type X( V const & a ) { BOOST_STATIC_ASSERT(0<vec_traits<V>::dim); return vec_traits<V>::template read_element<0>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type>::type Y( V const & a ) { BOOST_STATIC_ASSERT(1<vec_traits<V>::dim); return vec_traits<V>::template read_element<1>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type>::type Z( V const & a ) { BOOST_STATIC_ASSERT(2<vec_traits<V>::dim); return vec_traits<V>::template read_element<2>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type>::type W( V const & a ) { BOOST_STATIC_ASSERT(3<vec_traits<V>::dim); return vec_traits<V>::template read_element<3>(a); }
+
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type &>::type X( V & a ) { BOOST_STATIC_ASSERT(0<vec_traits<V>::dim); return vec_traits<V>::template write_element<0>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type &>::type Y( V & a ) { BOOST_STATIC_ASSERT(1<vec_traits<V>::dim); return vec_traits<V>::template write_element<1>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type &>::type Z( V & a ) { BOOST_STATIC_ASSERT(2<vec_traits<V>::dim); return vec_traits<V>::template write_element<2>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type &>::type W( V & a ) { BOOST_STATIC_ASSERT(3<vec_traits<V>::dim); return vec_traits<V>::template write_element<3>(a); }
+
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type>::type A0( V const & a ) { BOOST_STATIC_ASSERT(0<vec_traits<V>::dim); return vec_traits<V>::template read_element<0>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type>::type A1( V const & a ) { BOOST_STATIC_ASSERT(1<vec_traits<V>::dim); return vec_traits<V>::template read_element<1>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type>::type A2( V const & a ) { BOOST_STATIC_ASSERT(2<vec_traits<V>::dim); return vec_traits<V>::template read_element<2>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type>::type A3( V const & a ) { BOOST_STATIC_ASSERT(3<vec_traits<V>::dim); return vec_traits<V>::template read_element<3>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type>::type A4( V const & a ) { BOOST_STATIC_ASSERT(4<vec_traits<V>::dim); return vec_traits<V>::template read_element<4>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type>::type A5( V const & a ) { BOOST_STATIC_ASSERT(5<vec_traits<V>::dim); return vec_traits<V>::template read_element<5>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type>::type A6( V const & a ) { BOOST_STATIC_ASSERT(6<vec_traits<V>::dim); return vec_traits<V>::template read_element<6>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type>::type A7( V const & a ) { BOOST_STATIC_ASSERT(7<vec_traits<V>::dim); return vec_traits<V>::template read_element<7>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type>::type A8( V const & a ) { BOOST_STATIC_ASSERT(8<vec_traits<V>::dim); return vec_traits<V>::template read_element<8>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type>::type A9( V const & a ) { BOOST_STATIC_ASSERT(9<vec_traits<V>::dim); return vec_traits<V>::template read_element<9>(a); }
+
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type &>::type A0( V & a ) {  BOOST_STATIC_ASSERT(0<vec_traits<V>::dim); return vec_traits<V>::template write_element<0>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type &>::type A1( V & a ) {  BOOST_STATIC_ASSERT(1<vec_traits<V>::dim); return vec_traits<V>::template write_element<1>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type &>::type A2( V & a ) {  BOOST_STATIC_ASSERT(2<vec_traits<V>::dim); return vec_traits<V>::template write_element<2>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type &>::type A3( V & a ) {  BOOST_STATIC_ASSERT(3<vec_traits<V>::dim); return vec_traits<V>::template write_element<3>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type &>::type A4( V & a ) {  BOOST_STATIC_ASSERT(4<vec_traits<V>::dim); return vec_traits<V>::template write_element<4>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type &>::type A5( V & a ) {  BOOST_STATIC_ASSERT(5<vec_traits<V>::dim); return vec_traits<V>::template write_element<5>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type &>::type A6( V & a ) {  BOOST_STATIC_ASSERT(6<vec_traits<V>::dim); return vec_traits<V>::template write_element<6>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type &>::type A7( V & a ) {  BOOST_STATIC_ASSERT(7<vec_traits<V>::dim); return vec_traits<V>::template write_element<7>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type &>::type A8( V & a ) {  BOOST_STATIC_ASSERT(8<vec_traits<V>::dim); return vec_traits<V>::template write_element<8>(a); }
+        template <class V> BOOST_QVM_INLINE_TRIVIAL typename enable_if_c<is_vec<V>::value,typename vec_traits<V>::scalar_type &>::type A9( V & a ) {  BOOST_STATIC_ASSERT(9<vec_traits<V>::dim); return vec_traits<V>::template write_element<9>(a); }
+
+        ////////////////////////////////////////////////
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/vec_mat_operations.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/vec_mat_operations.hpp
new file mode 100644
index 00000000000..db84bd02054
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/vec_mat_operations.hpp
@@ -0,0 +1,168 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_A61EC088D31511DFA59D2B03E0D72085
+#define UUID_A61EC088D31511DFA59D2B03E0D72085
+
+#include <boost/qvm/vec_mat_operations2.hpp>
+#include <boost/qvm/vec_mat_operations3.hpp>
+#include <boost/qvm/vec_mat_operations4.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int M,int N>
+            struct
+            mul_mv_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_mat<A>::value && is_vec<B>::value &&
+            mat_traits<A>::cols==vec_traits<B>::dim &&
+            !qvm_detail::mul_mv_defined<mat_traits<A>::rows,mat_traits<A>::cols>::value,
+            deduce_vec2<A,B,mat_traits<A>::rows> >::type
+        operator*( A const & a, B const & b )
+            {
+            typedef typename deduce_vec2<A,B,mat_traits<A>::rows>::type R;
+            R r;
+            for( int i=0; i<mat_traits<A>::rows; ++i )
+                {
+                typedef typename vec_traits<R>::scalar_type Tr;
+                Tr x(scalar_traits<Tr>::value(0));
+                for( int j=0; j<mat_traits<A>::cols; ++j )
+                    x += mat_traits<A>::read_element_idx(i,j,a)*vec_traits<B>::read_element_idx(j,b);
+                vec_traits<R>::write_element_idx(i,r) = x;
+                }
+            return r;
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int M,int N>
+            struct
+            mul_vm_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_vec<A>::value && is_mat<B>::value &&
+            vec_traits<A>::dim==mat_traits<B>::rows &&
+            !qvm_detail::mul_vm_defined<mat_traits<B>::rows,mat_traits<B>::cols>::value,
+            deduce_vec2<A,B,mat_traits<B>::cols> >::type
+        operator*( A const & a, B const & b )
+            {
+            typedef typename deduce_vec2<A,B,mat_traits<B>::cols>::type R;
+            R r;
+            for( int i=0; i<mat_traits<B>::cols; ++i )
+                {
+                typedef typename vec_traits<R>::scalar_type Tr;
+                Tr x(scalar_traits<Tr>::value(0));
+                for( int j=0; j<mat_traits<B>::rows; ++j )
+                    x += vec_traits<A>::read_element_idx(j,a)*mat_traits<B>::read_element_idx(j,i,b);
+                vec_traits<R>::write_element_idx(i,r) = x;
+                }
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<A>::cols==4 &&
+            vec_traits<B>::dim==3,
+            deduce_vec2<A,B,3> >::type
+        transform_point( A const & a, B const & b )
+            {
+            typedef typename mat_traits<A>::scalar_type Ta;
+            typedef typename vec_traits<B>::scalar_type Tb;
+            Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
+            Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
+            Ta const a02 = mat_traits<A>::template read_element<0,2>(a);
+            Ta const a03 = mat_traits<A>::template read_element<0,3>(a);
+            Ta const a10 = mat_traits<A>::template read_element<1,0>(a);
+            Ta const a11 = mat_traits<A>::template read_element<1,1>(a);
+            Ta const a12 = mat_traits<A>::template read_element<1,2>(a);
+            Ta const a13 = mat_traits<A>::template read_element<1,3>(a);
+            Ta const a20 = mat_traits<A>::template read_element<2,0>(a);
+            Ta const a21 = mat_traits<A>::template read_element<2,1>(a);
+            Ta const a22 = mat_traits<A>::template read_element<2,2>(a);
+            Ta const a23 = mat_traits<A>::template read_element<2,3>(a);
+            Tb const b0 = vec_traits<B>::template read_element<0>(b);
+            Tb const b1 = vec_traits<B>::template read_element<1>(b);
+            Tb const b2 = vec_traits<B>::template read_element<2>(b);
+            typedef typename deduce_vec2<A,B,3>::type R;
+            BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==3);
+            R r;
+            vec_traits<R>::template write_element<0>(r)=a00*b0+a01*b1+a02*b2+a03;
+            vec_traits<R>::template write_element<1>(r)=a10*b0+a11*b1+a12*b2+a13;
+            vec_traits<R>::template write_element<2>(r)=a20*b0+a21*b1+a22*b2+a23;
+            return r;
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            mat_traits<A>::rows==4 && mat_traits<A>::cols==4 &&
+            vec_traits<B>::dim==3,
+            deduce_vec2<A,B,3> >::type
+        transform_vector( A const & a, B const & b )
+            {
+            typedef typename mat_traits<A>::scalar_type Ta;
+            typedef typename vec_traits<B>::scalar_type Tb;
+            Ta const a00 = mat_traits<A>::template read_element<0,0>(a);
+            Ta const a01 = mat_traits<A>::template read_element<0,1>(a);
+            Ta const a02 = mat_traits<A>::template read_element<0,2>(a);
+            Ta const a10 = mat_traits<A>::template read_element<1,0>(a);
+            Ta const a11 = mat_traits<A>::template read_element<1,1>(a);
+            Ta const a12 = mat_traits<A>::template read_element<1,2>(a);
+            Ta const a20 = mat_traits<A>::template read_element<2,0>(a);
+            Ta const a21 = mat_traits<A>::template read_element<2,1>(a);
+            Ta const a22 = mat_traits<A>::template read_element<2,2>(a);
+            Tb const b0 = vec_traits<B>::template read_element<0>(b);
+            Tb const b1 = vec_traits<B>::template read_element<1>(b);
+            Tb const b2 = vec_traits<B>::template read_element<2>(b);
+            typedef typename deduce_vec2<A,B,3>::type R;
+            BOOST_QVM_STATIC_ASSERT(vec_traits<R>::dim==3);
+            R r;
+            vec_traits<R>::template write_element<0>(r)=a00*b0+a01*b1+a02*b2;
+            vec_traits<R>::template write_element<1>(r)=a10*b0+a11*b1+a12*b2;
+            vec_traits<R>::template write_element<2>(r)=a20*b0+a21*b1+a22*b2;
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::operator*;
+            using ::boost::qvm::transform_point;
+            using ::boost::qvm::transform_vector;
+            }
+
+        ////////////////////////////////////////////////
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/vec_mat_operations2.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/vec_mat_operations2.hpp
new file mode 100644
index 00000000000..8d4a9b60141
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/vec_mat_operations2.hpp
@@ -0,0 +1,6 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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)
+
+#include <boost/qvm/gen/vec_mat_operations2.hpp>
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/vec_mat_operations3.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/vec_mat_operations3.hpp
new file mode 100644
index 00000000000..8265ab293dd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/vec_mat_operations3.hpp
@@ -0,0 +1,6 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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)
+
+#include <boost/qvm/gen/vec_mat_operations3.hpp>
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/vec_mat_operations4.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/vec_mat_operations4.hpp
new file mode 100644
index 00000000000..194005365e0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/vec_mat_operations4.hpp
@@ -0,0 +1,6 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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)
+
+#include <boost/qvm/gen/vec_mat_operations4.hpp>
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/vec_operations.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/vec_operations.hpp
new file mode 100644
index 00000000000..075e03fba91
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/vec_operations.hpp
@@ -0,0 +1,963 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_384AFF3AD23A11DFA80B754FE0D72085
+#define UUID_384AFF3AD23A11DFA80B754FE0D72085
+
+#include <boost/qvm/detail/vec_assign.hpp>
+#include <boost/qvm/vec_operations2.hpp>
+#include <boost/qvm/vec_operations3.hpp>
+#include <boost/qvm/vec_operations4.hpp>
+#include <boost/qvm/assert.hpp>
+#include <boost/qvm/scalar_traits.hpp>
+#include <string>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        namespace
+        qvm_detail
+            {
+            BOOST_QVM_INLINE_CRITICAL
+            void const *
+            get_valid_ptr_vec_operations()
+                {
+                static int const obj=0;
+                return &obj;
+                }
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_to_string_detail
+            {
+            template <class T>
+            std::string to_string( T const & x );
+            }
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            to_string_v_defined
+                {
+                static bool const value=false;
+                };
+
+            template <int I,int DimMinusOne>
+            struct
+            to_string_vector_elements
+                {
+                template <class A>
+                static
+                std::string
+                f( A const & a )
+                    {
+                    using namespace qvm_to_string_detail;
+                    return to_string(vec_traits<A>::template read_element<I>(a))+','+to_string_vector_elements<I+1,DimMinusOne>::f(a);
+                    }
+                };
+
+            template <int DimMinusOne>
+            struct
+            to_string_vector_elements<DimMinusOne,DimMinusOne>
+                {
+                template <class A>
+                static
+                std::string
+                f( A const & a )
+                    {
+                    using namespace qvm_to_string_detail;
+                    return to_string(vec_traits<A>::template read_element<DimMinusOne>(a));
+                    }
+                };
+            }
+
+        template <class A>
+        inline
+        typename boost::enable_if_c<
+            is_vec<A>::value  &&
+            !qvm_detail::to_string_v_defined<vec_traits<A>::dim>::value,
+            std::string>::type
+        to_string( A const & a )
+            {
+            return '('+qvm_detail::to_string_vector_elements<0,vec_traits<A>::dim-1>::f(a)+')';
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            convert_to_v_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class R,class A>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<R>::value && is_vec<A>::value &&
+            vec_traits<R>::dim==vec_traits<A>::dim &&
+            !qvm_detail::convert_to_v_defined<vec_traits<R>::dim>::value,
+            R>::type
+        convert_to( A const & a )
+            {
+            R r; assign(r,a);
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_vec<A>::value && is_vec<B>::value &&
+            vec_traits<A>::dim==3 && vec_traits<B>::dim==3,
+            deduce_vec2<A,B,3> >::type
+        cross( A const & a, B const & b )
+            {
+            typedef typename deduce_vec2<A,B,3>::type R;
+            R r;
+            vec_traits<R>::template write_element<0>(r)=
+                vec_traits<A>::template read_element<1>(a)*vec_traits<B>::template read_element<2>(b)-
+                vec_traits<A>::template read_element<2>(a)*vec_traits<B>::template read_element<1>(b);
+            vec_traits<R>::template write_element<1>(r)=
+                vec_traits<A>::template read_element<2>(a)*vec_traits<B>::template read_element<0>(b)-
+                vec_traits<A>::template read_element<0>(a)*vec_traits<B>::template read_element<2>(b);
+            vec_traits<R>::template write_element<2>(r)=
+                vec_traits<A>::template read_element<0>(a)*vec_traits<B>::template read_element<1>(b)-
+                vec_traits<A>::template read_element<1>(a)*vec_traits<B>::template read_element<0>(b);
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        template <class A,class B,class Cmp>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_vec<A>::value && is_vec<B>::value &&
+            vec_traits<A>::dim==vec_traits<B>::dim,
+            bool>::type
+        cmp( A const & a, B const & b, Cmp f )
+            {
+            typedef typename deduce_scalar<
+                typename vec_traits<A>::scalar_type,
+                typename vec_traits<B>::scalar_type>::type T;
+            int const dim=vec_traits<A>::dim;
+            T v1[dim]; assign(v1,a);
+            T v2[dim]; assign(v2,b);
+            for( int i=0; i!=dim; ++i )
+                if( !f(v1[i],v2[i]) )
+                    return false;
+            return true;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class T,int Dim>
+            class
+            zero_vec_
+                {
+                zero_vec_( zero_vec_ const & );
+                zero_vec_ & operator=( zero_vec_ const & );
+                ~zero_vec_();
+
+                public:
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <class V>
+        struct vec_traits;
+
+        template <class T,int Dim>
+        struct
+        vec_traits< qvm_detail::zero_vec_<T,Dim> >
+            {
+            typedef qvm_detail::zero_vec_<T,Dim> this_vector;
+            typedef T scalar_type;
+            static int const dim=Dim;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_vector const & )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<Dim);
+                return scalar_traits<scalar_type>::value(0);
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int i, this_vector const & )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<Dim);
+                return scalar_traits<scalar_type>::value(0);
+                }
+            };
+
+        template <class T,int Dim,int D>
+        struct
+        deduce_vec<qvm_detail::zero_vec_<T,Dim>,D>
+            {
+            typedef vec<T,D> type;
+            };
+
+        template <class T,int Dim>
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::zero_vec_<T,Dim> const &
+        zero_vec()
+            {
+            return *(qvm_detail::zero_vec_<T,Dim> const *)qvm_detail::get_valid_ptr_vec_operations();
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_vec<A>::value,
+            void>::type
+        set_zero( A & a )
+            {
+            assign(a,zero_vec<typename vec_traits<A>::scalar_type,vec_traits<A>::dim>());
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class OriginalType,class Scalar>
+            class
+            vector_scalar_cast_
+                {
+                vector_scalar_cast_( vector_scalar_cast_ const & );
+                vector_scalar_cast_ & operator=( vector_scalar_cast_ const & );
+                ~vector_scalar_cast_();
+
+                public:
+
+                template <class T>
+                BOOST_QVM_INLINE_TRIVIAL
+                vector_scalar_cast_ &
+                operator=( T const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+
+            template <bool> struct scalar_cast_vector_filter { };
+            template <> struct scalar_cast_vector_filter<true> { typedef int type; };
+            }
+
+        template <class OriginalType,class Scalar>
+        struct
+        vec_traits< qvm_detail::vector_scalar_cast_<OriginalType,Scalar> >
+            {
+            typedef Scalar scalar_type;
+            typedef qvm_detail::vector_scalar_cast_<OriginalType,Scalar> this_vector;
+            static int const dim=vec_traits<OriginalType>::dim;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_vector const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<dim);
+                return scalar_type(vec_traits<OriginalType>::template read_element<I>(reinterpret_cast<OriginalType const &>(x)));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int i, this_vector const & x )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<dim);
+                return scalar_type(vec_traits<OriginalType>::read_element_idx(i,reinterpret_cast<OriginalType const &>(x)));
+                }
+            };
+
+        template <class OriginalType,class Scalar,int D>
+        struct
+        deduce_vec<qvm_detail::vector_scalar_cast_<OriginalType,Scalar>,D>
+            {
+            typedef vec<Scalar,D> type;
+            };
+
+        template <class Scalar,class T>
+        BOOST_QVM_INLINE_TRIVIAL
+        qvm_detail::vector_scalar_cast_<T,Scalar> const &
+        scalar_cast( T const & x, typename qvm_detail::scalar_cast_vector_filter<is_vec<T>::value>::type=0 )
+            {
+            return reinterpret_cast<qvm_detail::vector_scalar_cast_<T,Scalar> const &>(x);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            div_eq_vs_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_vec<A>::value && is_scalar<B>::value &&
+            !qvm_detail::div_eq_vs_defined<vec_traits<A>::dim>::value,
+            A &>::type
+        operator/=( A & a, B b )
+            {
+            for( int i=0; i!=vec_traits<A>::dim; ++i )
+                vec_traits<A>::write_element_idx(i,a)/=b;
+            return a;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            div_vs_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_vec<A>::value && is_scalar<B>::value &&
+            !qvm_detail::div_vs_defined<vec_traits<A>::dim>::value,
+            deduce_vec<A> >::type
+        operator/( A const & a, B b )
+            {
+            typedef typename deduce_vec<A>::type R;
+            R r;
+            for( int i=0; i!=vec_traits<A>::dim; ++i )
+                vec_traits<R>::write_element_idx(i,r)=vec_traits<A>::read_element_idx(i,a)/b;
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            dot_vv_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_vec<A>::value && is_vec<B>::value &&
+            vec_traits<A>::dim==vec_traits<B>::dim &&
+            !qvm_detail::dot_vv_defined<vec_traits<A>::dim>::value,
+            deduce_scalar<typename vec_traits<A>::scalar_type,typename vec_traits<B>::scalar_type> >::type
+        dot( A const & a, B const & b )
+            {
+            typedef typename deduce_scalar<typename vec_traits<A>::scalar_type,typename vec_traits<B>::scalar_type>::type T;
+            T m(scalar_traits<T>::value(0));
+            for( int i=0; i!=vec_traits<A>::dim; ++i )
+                m+=vec_traits<A>::read_element_idx(i,a)*vec_traits<B>::read_element_idx(i,b);
+            return m;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            eq_vv_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_vec<A>::value && is_vec<B>::value &&
+            vec_traits<A>::dim==vec_traits<B>::dim &&
+            !qvm_detail::eq_vv_defined<vec_traits<A>::dim>::value,
+            bool>::type
+        operator==( A const & a, B const & b )
+            {
+            for( int i=0; i!=vec_traits<A>::dim; ++i )
+                if( vec_traits<A>::read_element_idx(i,a)!=vec_traits<B>::read_element_idx(i,b) )
+                    return false;
+            return true;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            mag_sqr_v_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_vec<A>::value &&
+            !qvm_detail::mag_sqr_v_defined<vec_traits<A>::dim>::value,
+            typename vec_traits<A>::scalar_type>::type
+        mag_sqr( A const & a )
+            {
+            typedef typename vec_traits<A>::scalar_type T;
+            T m(scalar_traits<T>::value(0));
+            for( int i=0; i!=vec_traits<A>::dim; ++i )
+                {
+                T x=vec_traits<A>::read_element_idx(i,a);
+                m+=x*x;
+                }
+            return m;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            mag_v_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_vec<A>::value &&
+            !qvm_detail::mag_v_defined<vec_traits<A>::dim>::value,
+            typename vec_traits<A>::scalar_type>::type
+        mag( A const & a )
+            {
+            typedef typename vec_traits<A>::scalar_type T;
+            T m(scalar_traits<T>::value(0));
+            for( int i=0; i!=vec_traits<A>::dim; ++i )
+                {
+                T x=vec_traits<A>::read_element_idx(i,a);
+                m+=x*x;
+                }
+            return sqrt<T>(m);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            minus_eq_vv_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_vec<A>::value && is_vec<B>::value &&
+            vec_traits<A>::dim==vec_traits<B>::dim &&
+            !qvm_detail::minus_eq_vv_defined<vec_traits<A>::dim>::value,
+            A &>::type
+        operator-=( A & a, B const & b )
+            {
+            for( int i=0; i!=vec_traits<A>::dim; ++i )
+                vec_traits<A>::write_element_idx(i,a)-=vec_traits<B>::read_element_idx(i,b);
+            return a;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            minus_v_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_vec<A>::value &&
+            !qvm_detail::minus_v_defined<vec_traits<A>::dim>::value,
+            deduce_vec<A> >::type
+        operator-( A const & a )
+            {
+            typedef typename deduce_vec<A>::type R;
+            R r;
+            for( int i=0; i!=vec_traits<A>::dim; ++i )
+                vec_traits<R>::write_element_idx(i,r)=-vec_traits<A>::read_element_idx(i,a);
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            minus_vv_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_vec<A>::value && is_vec<B>::value &&
+            vec_traits<A>::dim==vec_traits<B>::dim &&
+            !qvm_detail::minus_vv_defined<vec_traits<A>::dim>::value,
+            deduce_vec2<A,B,vec_traits<A>::dim> >::type
+        operator-( A const & a, B const & b )
+            {
+            typedef typename deduce_vec2<A,B,vec_traits<A>::dim>::type R;
+            R r;
+            for( int i=0; i!=vec_traits<A>::dim; ++i )
+                vec_traits<R>::write_element_idx(i,r)=vec_traits<A>::read_element_idx(i,a)-vec_traits<B>::read_element_idx(i,b);
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            mul_eq_vs_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_vec<A>::value && is_scalar<B>::value &&
+            !qvm_detail::mul_eq_vs_defined<vec_traits<A>::dim>::value,
+            A &>::type
+        operator*=( A & a, B b )
+            {
+            for( int i=0; i!=vec_traits<A>::dim; ++i )
+                vec_traits<A>::write_element_idx(i,a)*=b;
+            return a;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            mul_vs_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_vec<A>::value && is_scalar<B>::value &&
+            !qvm_detail::mul_vs_defined<vec_traits<A>::dim>::value,
+            deduce_vec<A> >::type
+        operator*( A const & a, B b )
+            {
+            typedef typename deduce_vec<A>::type R;
+            R r;
+            for( int i=0; i!=vec_traits<A>::dim; ++i )
+                vec_traits<R>::write_element_idx(i,r)=vec_traits<A>::read_element_idx(i,a)*b;
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            mul_sv_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_scalar<A>::value && is_vec<B>::value &&
+            !qvm_detail::mul_sv_defined<vec_traits<B>::dim>::value,
+            deduce_vec<B> >::type
+        operator*( A a, B const & b )
+            {
+            typedef typename deduce_vec<B>::type R;
+            R r;
+            for( int i=0; i!=vec_traits<B>::dim; ++i )
+                vec_traits<R>::write_element_idx(i,r)=a*vec_traits<B>::read_element_idx(i,b);
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            neq_vv_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_vec<A>::value && is_vec<B>::value &&
+            vec_traits<A>::dim==vec_traits<B>::dim &&
+            !qvm_detail::neq_vv_defined<vec_traits<A>::dim>::value,
+            bool>::type
+        operator!=( A const & a, B const & b )
+            {
+            for( int i=0; i!=vec_traits<A>::dim; ++i )
+                if( vec_traits<A>::read_element_idx(i,a)!=vec_traits<B>::read_element_idx(i,b) )
+                    return true;
+            return false;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            normalize_v_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_vec<A>::value &&
+            !qvm_detail::normalize_v_defined<vec_traits<A>::dim>::value,
+            deduce_vec<A> >::type
+        normalized( A const & a )
+            {
+            typedef typename vec_traits<A>::scalar_type T;
+            T m(scalar_traits<T>::value(0));
+            for( int i=0; i!=vec_traits<A>::dim; ++i )
+                {
+                T x=vec_traits<A>::read_element_idx(i,a);
+                m+=x*x;
+                }
+            if( m==scalar_traits<T>::value(0) )
+                BOOST_QVM_THROW_EXCEPTION(zero_magnitude_error());
+            T rm=scalar_traits<T>::value(1)/sqrt<T>(m);
+            typedef typename deduce_vec<A>::type R;
+            R r;
+            for( int i=0; i!=vec_traits<A>::dim; ++i )
+                vec_traits<R>::write_element_idx(i,r)=vec_traits<A>::read_element_idx(i,a)*rm;
+            return r;
+            }
+
+        template <class A>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_vec<A>::value &&
+            !qvm_detail::normalize_v_defined<vec_traits<A>::dim>::value,
+            void>::type
+        normalize( A & a )
+            {
+            typedef typename vec_traits<A>::scalar_type T;
+            T m(scalar_traits<T>::value(0));
+            for( int i=0; i!=vec_traits<A>::dim; ++i )
+                {
+                T x=vec_traits<A>::read_element_idx(i,a);
+                m+=x*x;
+                }
+            if( m==scalar_traits<T>::value(0) )
+                BOOST_QVM_THROW_EXCEPTION(zero_magnitude_error());
+            T rm=scalar_traits<T>::value(1)/sqrt<T>(m);
+            for( int i=0; i!=vec_traits<A>::dim; ++i )
+                vec_traits<A>::write_element_idx(i,a)*=rm;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            plus_eq_vv_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename enable_if_c<
+            is_vec<A>::value && is_vec<B>::value &&
+            vec_traits<A>::dim==vec_traits<B>::dim &&
+            !qvm_detail::plus_eq_vv_defined<vec_traits<A>::dim>::value,
+            A &>::type
+        operator+=( A & a, B const & b )
+            {
+            for( int i=0; i!=vec_traits<A>::dim; ++i )
+                vec_traits<A>::write_element_idx(i,a)+=vec_traits<B>::read_element_idx(i,b);
+            return a;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <int D>
+            struct
+            plus_vv_defined
+                {
+                static bool const value=false;
+                };
+            }
+
+        template <class A,class B>
+        BOOST_QVM_INLINE_OPERATIONS
+        typename lazy_enable_if_c<
+            is_vec<A>::value && is_vec<B>::value &&
+            vec_traits<A>::dim==vec_traits<B>::dim &&
+            !qvm_detail::plus_vv_defined<vec_traits<A>::dim>::value,
+            deduce_vec2<A,B,vec_traits<A>::dim> >::type
+        operator+( A const & a, B const & b )
+            {
+            typedef typename deduce_vec2<A,B,vec_traits<A>::dim>::type R;
+            R r;
+            for( int i=0; i!=vec_traits<A>::dim; ++i )
+                vec_traits<R>::write_element_idx(i,r)=vec_traits<A>::read_element_idx(i,a)+vec_traits<B>::read_element_idx(i,b);
+            return r;
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        qvm_detail
+            {
+            template <class T>
+            class
+            vref_
+                {
+                vref_( vref_ const & );
+                vref_ & operator=( vref_ const & );
+                ~vref_();
+
+                public:
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                vref_ &
+                operator=( R const & x )
+                    {
+                    assign(*this,x);
+                    return *this;
+                    }
+
+                template <class R>
+                BOOST_QVM_INLINE_TRIVIAL
+                operator R() const
+                    {
+                    R r;
+                    assign(r,*this);
+                    return r;
+                    }
+                };
+            }
+
+        template <class V>
+        struct
+        vec_traits< qvm_detail::vref_<V> >
+            {
+            typedef typename vec_traits<V>::scalar_type scalar_type;
+            typedef qvm_detail::vref_<V> this_vector;
+            static int const dim=vec_traits<V>::dim;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_vector const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<dim);
+                return vec_traits<V>::template read_element<I>(reinterpret_cast<V const &>(x));
+                }
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_vector & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<dim);
+                return vec_traits<V>::template write_element<I>(reinterpret_cast<V &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int i, this_vector const & x )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<dim);
+                return vec_traits<V>::read_element_idx(i,reinterpret_cast<V const &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int i, this_vector & x )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<dim);
+                return vec_traits<V>::write_element_idx(i,reinterpret_cast<V &>(x));
+                }
+            };
+
+        template <class V,int D>
+        struct
+        deduce_vec<qvm_detail::vref_<V>,D>
+            {
+            typedef vec<typename vec_traits<V>::scalar_type,D> type;
+            };
+
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value,
+            qvm_detail::vref_<V> const &>::type
+        vref( V const & a )
+            {
+            return reinterpret_cast<qvm_detail::vref_<V> const &>(a);
+            }
+
+        template <class V>
+        BOOST_QVM_INLINE_TRIVIAL
+        typename enable_if_c<
+            is_vec<V>::value,
+            qvm_detail::vref_<V> &>::type
+        vref( V & a )
+            {
+            return reinterpret_cast<qvm_detail::vref_<V> &>(a);
+            }
+
+        ////////////////////////////////////////////////
+
+        namespace
+        sfinae
+            {
+            using ::boost::qvm::to_string;
+            using ::boost::qvm::assign;
+            using ::boost::qvm::convert_to;
+            using ::boost::qvm::cross;
+            using ::boost::qvm::cmp;
+            using ::boost::qvm::set_zero;
+            using ::boost::qvm::scalar_cast;
+            using ::boost::qvm::operator/=;
+            using ::boost::qvm::operator/;
+            using ::boost::qvm::dot;
+            using ::boost::qvm::operator==;
+            using ::boost::qvm::mag_sqr;
+            using ::boost::qvm::mag;
+            using ::boost::qvm::operator-=;
+            using ::boost::qvm::operator-;
+            using ::boost::qvm::operator*=;
+            using ::boost::qvm::operator*;
+            using ::boost::qvm::operator!=;
+            using ::boost::qvm::normalized;
+            using ::boost::qvm::normalize;
+            using ::boost::qvm::operator+=;
+            using ::boost::qvm::operator+;
+            using ::boost::qvm::vref;
+            }
+
+        ////////////////////////////////////////////////
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/vec_operations2.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/vec_operations2.hpp
new file mode 100644
index 00000000000..bc1933d2999
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/vec_operations2.hpp
@@ -0,0 +1,6 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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)
+
+#include <boost/qvm/gen/vec_operations2.hpp>
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/vec_operations3.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/vec_operations3.hpp
new file mode 100644
index 00000000000..b979c597d55
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/vec_operations3.hpp
@@ -0,0 +1,6 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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)
+
+#include <boost/qvm/gen/vec_operations3.hpp>
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/vec_operations4.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/vec_operations4.hpp
new file mode 100644
index 00000000000..a08be2ad20d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/vec_operations4.hpp
@@ -0,0 +1,6 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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)
+
+#include <boost/qvm/gen/vec_operations4.hpp>
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/vec_traits.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/vec_traits.hpp
new file mode 100644
index 00000000000..9b4465a92fe
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/vec_traits.hpp
@@ -0,0 +1,32 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_01224884FC4111DF9570F7E4DED72085
+#define UUID_01224884FC4111DF9570F7E4DED72085
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class V>
+        struct
+        vec_traits
+            {
+            static int const dim=0;
+            typedef void scalar_type;
+            };
+
+        template <class T>
+        struct
+        is_vec
+            {
+            static bool const value=vec_traits<T>::dim>0;
+            };
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/vec_traits_array.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/vec_traits_array.hpp
new file mode 100644
index 00000000000..78c1333a67c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/vec_traits_array.hpp
@@ -0,0 +1,108 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_DEC6035EA1C211DEA5E8ECB856D89593
+#define UUID_DEC6035EA1C211DEA5E8ECB856D89593
+
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/deduce_vec.hpp>
+#include <boost/qvm/detail/remove_const.hpp>
+#include <boost/qvm/assert.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class T,int M,int N>
+        struct
+        vec_traits<T[M][N]>
+            {
+            static int const dim=0;
+            typedef void scalar_type;
+            };
+
+        template <class T,int Dim>
+        struct
+        vec_traits<T[Dim]>
+            {
+            typedef T this_vector[Dim];
+            typedef typename qvm_detail::remove_const<T>::type scalar_type;
+            static int const dim=Dim;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( this_vector const & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<Dim);
+                return x[I];
+                }
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element( this_vector & x )
+                {
+                BOOST_QVM_STATIC_ASSERT(I>=0);
+                BOOST_QVM_STATIC_ASSERT(I<Dim);
+                return x[I];
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int i, this_vector const & x )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<Dim);
+                return x[i];
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type &
+            write_element_idx( int i, this_vector & x )
+                {
+                BOOST_QVM_ASSERT(i>=0);
+                BOOST_QVM_ASSERT(i<Dim);
+                return x[i];
+                }
+            };
+
+        template <class T,int Dim,int D>
+        struct
+        deduce_vec<T[Dim],D>
+            {
+            typedef vec<T,D> type;
+            };
+
+        template <class T,int Dim,int D>
+        struct
+        deduce_vec<T const[Dim],D>
+            {
+            typedef vec<T,D> type;
+            };
+
+        template <class T1,class T2,int Dim,int D>
+        struct
+        deduce_vec2<T1[Dim],T2[Dim],D>
+            {
+            typedef vec<typename deduce_scalar<T1,T2>::type,D> type;
+            };
+
+        template <int Dim,class T>
+        T (&ptr_vref( T * ptr ))[Dim]
+            {
+            return *reinterpret_cast<T (*)[Dim]>(ptr);
+            }
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/qvm/vec_traits_defaults.hpp b/contrib/libboost/boost_1_65_0/boost/qvm/vec_traits_defaults.hpp
new file mode 100644
index 00000000000..80b5f858d02
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/qvm/vec_traits_defaults.hpp
@@ -0,0 +1,94 @@
+//Copyright (c) 2008-2016 Emil Dotchevski and Reverge Studios, Inc.
+
+//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 UUID_DFFD61ACC72311E6955FFF1F07624D53
+#define UUID_DFFD61ACC72311E6955FFF1F07624D53
+
+#include <boost/qvm/inline.hpp>
+#include <boost/qvm/assert.hpp>
+
+namespace
+boost
+    {
+    namespace
+    qvm
+        {
+        template <class>
+        struct vec_traits;
+
+        namespace
+        qvm_detail
+            {
+            template <int I,int N>
+            struct
+            vector_w
+                {
+                template <class A>
+                static
+                BOOST_QVM_INLINE_CRITICAL
+                typename vec_traits<A>::scalar_type &
+                write_element_idx( int i, A & a )
+                    {
+                    return I==i?
+                        vec_traits<A>::template write_element<I>(a) :
+                        vector_w<I+1,N>::write_element_idx(i,a);
+                    }
+                };
+
+            template <int N>
+            struct
+            vector_w<N,N>
+                {
+                template <class A>
+                static
+                BOOST_QVM_INLINE_TRIVIAL
+                typename vec_traits<A>::scalar_type &
+                write_element_idx( int, A & a )
+                    {
+                    BOOST_QVM_ASSERT(0);
+                    return vec_traits<A>::template write_element<0>(a);
+                    }
+                };
+            }
+
+        template <class VecType,class ScalarType,int Dim>
+        struct
+        vec_traits_defaults
+            {
+            typedef VecType vec_type;
+            typedef ScalarType scalar_type;
+            static int const dim=Dim;
+
+            template <int I>
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element( vec_type const & x )
+                {
+                return vec_traits<vec_type>::template write_element<I>(const_cast<vec_type &>(x));
+                }
+
+            static
+            BOOST_QVM_INLINE_CRITICAL
+            scalar_type
+            read_element_idx( int i, vec_type const & x )
+                {
+                return vec_traits<vec_type>::write_element_idx(i,const_cast<vec_type &>(x));
+                }
+
+            protected:
+
+            static
+            BOOST_QVM_INLINE_TRIVIAL
+            scalar_type &
+            write_element_idx( int i, vec_type & m )
+                {
+                return qvm_detail::vector_w<0,vec_traits<vec_type>::dim>::write_element_idx(i,m);
+                }
+            };
+        }
+    }
+
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/random.hpp b/contrib/libboost/boost_1_65_0/boost/random.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random.hpp
rename to contrib/libboost/boost_1_65_0/boost/random.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/additive_combine.hpp b/contrib/libboost/boost_1_65_0/boost/random/additive_combine.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/additive_combine.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/additive_combine.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/bernoulli_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/bernoulli_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/bernoulli_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/bernoulli_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/beta_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/beta_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/beta_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/beta_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/binomial_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/binomial_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/binomial_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/binomial_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/cauchy_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/cauchy_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/cauchy_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/cauchy_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/chi_squared_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/chi_squared_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/chi_squared_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/chi_squared_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/detail/auto_link.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/auto_link.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/detail/auto_link.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/detail/auto_link.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/detail/config.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/config.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/detail/config.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/detail/config.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/detail/const_mod.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/const_mod.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/detail/const_mod.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/detail/const_mod.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/detail/disable_warnings.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/disable_warnings.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/detail/disable_warnings.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/detail/disable_warnings.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/detail/enable_warnings.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/enable_warnings.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/detail/enable_warnings.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/detail/enable_warnings.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/detail/generator_bits.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/generator_bits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/detail/generator_bits.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/detail/generator_bits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/detail/generator_seed_seq.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/generator_seed_seq.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/detail/generator_seed_seq.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/detail/generator_seed_seq.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/random/detail/int_float_pair.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/int_float_pair.hpp
new file mode 100644
index 00000000000..de253a0ecbf
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/random/detail/int_float_pair.hpp
@@ -0,0 +1,121 @@
+/* boost random/detail/int_float_pair.hpp header file
+ *
+ * Copyright Jens Maurer 2000-2001
+ * Copyright Steven Watanabe 2010-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_DETAIL_INT_FLOAT_PAIR_HPP
+#define BOOST_RANDOM_DETAIL_INT_FLOAT_PAIR_HPP
+
+#include <utility>
+#include <boost/integer.hpp>
+#include <boost/integer/integer_mask.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/random/uniform_01.hpp>
+#include <boost/random/uniform_int_distribution.hpp>
+#include <boost/random/detail/signed_unsigned_tools.hpp>
+#include <boost/random/detail/integer_log2.hpp>
+#include <boost/mpl/bool.hpp>
+
+namespace boost {
+namespace random {
+namespace detail {
+
+template<class Engine>
+inline typename boost::make_unsigned<typename Engine::result_type>::type
+generate_one_digit(Engine& eng, std::size_t bits)
+{
+    typedef typename Engine::result_type base_result;
+    typedef typename boost::make_unsigned<base_result>::type base_unsigned;
+    
+    base_unsigned range =
+        detail::subtract<base_result>()((eng.max)(), (eng.min)());
+    base_unsigned y0_mask = (base_unsigned(2) << (bits - 1)) - 1;
+    base_unsigned y0 = (range + 1) & ~y0_mask;
+    base_unsigned u;
+    do {
+        u = detail::subtract<base_result>()(eng(), (eng.min)());
+    } while(y0 != 0 && u > base_unsigned(y0 - 1));
+    return u & y0_mask;
+}
+
+template<class RealType, std::size_t w, class Engine>
+std::pair<RealType, int> generate_int_float_pair(Engine& eng, boost::mpl::true_)
+{
+    typedef typename Engine::result_type base_result;
+    typedef typename boost::make_unsigned<base_result>::type base_unsigned;
+    
+    base_unsigned range =
+        detail::subtract<base_result>()((eng.max)(), (eng.min)());
+    
+    std::size_t m =
+        (range == (std::numeric_limits<base_unsigned>::max)()) ?
+            std::numeric_limits<base_unsigned>::digits :
+            detail::integer_log2(range + 1);
+            
+    int bucket = 0;
+    // process as many full digits as possible into the int part
+    for(std::size_t i = 0; i < w/m; ++i) {
+        base_unsigned u = generate_one_digit(eng, m);
+        bucket = (bucket << m) | u;
+    }
+    RealType r;
+
+    const std::size_t digits = std::numeric_limits<RealType>::digits;
+    {
+        base_unsigned u = generate_one_digit(eng, m);
+        base_unsigned mask = (base_unsigned(1) << (w%m)) - 1;
+        bucket = (bucket << (w%m)) | (mask & u);
+        const RealType mult = RealType(1)/RealType(base_unsigned(1) << (m - w%m));
+        // zero out unused bits
+        if (m - w%m > digits) {
+            u &= ~(base_unsigned(1) << (m - digits));
+        }
+        r = RealType(u >> (w%m)) * mult;
+    }
+    for(std::size_t i = m - w%m; i + m < digits; ++i) {
+        base_unsigned u = generate_one_digit(eng, m);
+        r += u;
+        r *= RealType(0.5)/RealType(base_unsigned(1) << (m - 1));
+    }
+    if (m - w%m < digits)
+    {
+        const std::size_t remaining = (digits - m + w%m) % m;
+        base_unsigned u = generate_one_digit(eng, m);
+        r += u & ((base_unsigned(2) << (remaining - 1)) - 1);
+        const RealType mult = RealType(0.5)/RealType(base_unsigned(1) << (remaining - 1));
+        r *= mult;
+    }
+    return std::make_pair(r, bucket);
+}
+
+template<class RealType, std::size_t w, class Engine>
+inline std::pair<RealType, int> generate_int_float_pair(Engine& eng, boost::mpl::false_)
+{
+    int bucket = uniform_int_distribution<>(0, (1 << w) - 1)(eng);
+    RealType r = uniform_01<RealType>()(eng);
+    return std::make_pair(r, bucket);
+}
+
+template<class RealType, std::size_t w, class Engine>
+inline std::pair<RealType, int> generate_int_float_pair(Engine& eng)
+{
+    typedef typename Engine::result_type base_result;
+    return generate_int_float_pair<RealType, w>(eng,
+        boost::is_integral<base_result>());
+}
+
+} // namespace detail
+} // namespace random
+} // namespace boost
+
+#endif // BOOST_RANDOM_DETAIL_INT_FLOAT_PAIR_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/random/detail/integer_log2.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/integer_log2.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/detail/integer_log2.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/detail/integer_log2.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/detail/iterator_mixin.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/iterator_mixin.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/detail/iterator_mixin.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/detail/iterator_mixin.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/detail/large_arithmetic.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/large_arithmetic.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/detail/large_arithmetic.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/detail/large_arithmetic.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/detail/operators.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/operators.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/detail/operators.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/detail/operators.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/detail/polynomial.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/polynomial.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/detail/polynomial.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/detail/polynomial.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/detail/ptr_helper.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/ptr_helper.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/detail/ptr_helper.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/detail/ptr_helper.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/detail/seed.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/seed.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/detail/seed.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/detail/seed.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/detail/seed_impl.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/seed_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/detail/seed_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/detail/seed_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/detail/signed_unsigned_tools.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/signed_unsigned_tools.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/detail/signed_unsigned_tools.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/detail/signed_unsigned_tools.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/detail/uniform_int_float.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/uniform_int_float.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/detail/uniform_int_float.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/detail/uniform_int_float.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/detail/vector_io.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/vector_io.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/detail/vector_io.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/detail/vector_io.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/discard_block.hpp b/contrib/libboost/boost_1_65_0/boost/random/discard_block.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/discard_block.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/discard_block.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/discrete_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/discrete_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/discrete_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/discrete_distribution.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/random/exponential_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/exponential_distribution.hpp
new file mode 100644
index 00000000000..b4b95c5472b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/random/exponential_distribution.hpp
@@ -0,0 +1,386 @@
+/* boost random/exponential_distribution.hpp header file
+ *
+ * Copyright Jens Maurer 2000-2001
+ * Copyright Steven Watanabe 2011
+ * Copyright Jason Rhinelander 2016
+ * 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$
+ *
+ * Revision history
+ *  2001-02-18  moved to individual header files
+ */
+
+#ifndef BOOST_RANDOM_EXPONENTIAL_DISTRIBUTION_HPP
+#define BOOST_RANDOM_EXPONENTIAL_DISTRIBUTION_HPP
+
+#include <boost/config/no_tr1/cmath.hpp>
+#include <iosfwd>
+#include <boost/assert.hpp>
+#include <boost/limits.hpp>
+#include <boost/random/detail/config.hpp>
+#include <boost/random/detail/operators.hpp>
+#include <boost/random/detail/int_float_pair.hpp>
+#include <boost/random/uniform_01.hpp>
+
+namespace boost {
+namespace random {
+
+namespace detail {
+
+// tables for the ziggurat algorithm
+template<class RealType>
+struct exponential_table {
+    static const RealType table_x[257];
+    static const RealType table_y[257];
+};
+
+template<class RealType>
+const RealType exponential_table<RealType>::table_x[257] = {
+    8.6971174701310497140, 7.6971174701310497140, 6.9410336293772123602, 6.4783784938325698538,
+    6.1441646657724730491, 5.8821443157953997963, 5.6664101674540337371, 5.4828906275260628694,
+    5.3230905057543986131, 5.1814872813015010392, 5.0542884899813047117, 4.9387770859012514838,
+    4.8329397410251125881, 4.7352429966017412526, 4.6444918854200854873, 4.5597370617073515513,
+    4.4802117465284221949, 4.4052876934735729805, 4.3344436803172730116, 4.2672424802773661873,
+    4.2033137137351843802, 4.1423408656640511251, 4.0840513104082974638, 4.0282085446479365106,
+    3.9746060666737884793, 3.9230625001354895926, 3.8734176703995089983, 3.8255294185223367372,
+    3.7792709924116678992, 3.7345288940397975350, 3.6912010902374189454, 3.6491955157608538478,
+    3.6084288131289096339, 3.5688252656483374051, 3.5303158891293438633, 3.4928376547740601814,
+    3.4563328211327607625, 3.4207483572511205323, 3.3860354424603017887, 3.3521490309001100106,
+    3.3190474709707487166, 3.2866921715990692095, 3.2550473085704501813, 3.2240795652862645207,
+    3.1937579032122407483, 3.1640533580259734580, 3.1349388580844407393, 3.1063890623398246660,
+    3.0783802152540905188, 3.0508900166154554479, 3.0238975044556767713, 2.9973829495161306949,
+    2.9713277599210896472, 2.9457143948950456386, 2.9205262865127406647, 2.8957477686001416838,
+    2.8713640120155362592, 2.8473609656351888266, 2.8237253024500354905, 2.8004443702507381944,
+    2.7775061464397572041, 2.7548991965623453650, 2.7326126361947007411, 2.7106360958679293686,
+    2.6889596887418041593, 2.6675739807732670816, 2.6464699631518093905, 2.6256390267977886123,
+    2.6050729387408355373, 2.5847638202141406911, 2.5647041263169053687, 2.5448866271118700928,
+    2.5253043900378279427, 2.5059507635285939648, 2.4868193617402096807, 2.4679040502973649846,
+    2.4491989329782498908, 2.4306983392644199088, 2.4123968126888708336, 2.3942890999214583288,
+    2.3763701405361408194, 2.3586350574093374601, 2.3410791477030346875, 2.3236978743901964559,
+    2.3064868582835798692, 2.2894418705322694265, 2.2725588255531546952, 2.2558337743672190441,
+    2.2392628983129087111, 2.2228425031110364013, 2.2065690132576635755, 2.1904389667232199235,
+    2.1744490099377744673, 2.1585958930438856781, 2.1428764653998416425, 2.1272876713173679737,
+    2.1118265460190418108, 2.0964902118017147637, 2.0812758743932248696, 2.0661808194905755036,
+    2.0512024094685848641, 2.0363380802487695916, 2.0215853383189260770, 2.0069417578945183144,
+    1.9924049782135764992, 1.9779727009573602295, 1.9636426877895480401, 1.9494127580071845659,
+    1.9352807862970511135, 1.9212447005915276767, 1.9073024800183871196, 1.8934521529393077332,
+    1.8796917950722108462, 1.8660195276928275962, 1.8524335159111751661, 1.8389319670188793980,
+    1.8255131289035192212, 1.8121752885263901413, 1.7989167704602903934, 1.7857359354841254047,
+    1.7726311792313049959, 1.7596009308890742369, 1.7466436519460739352, 1.7337578349855711926,
+    1.7209420025219350428, 1.7081947058780575683, 1.6955145241015377061, 1.6829000629175537544,
+    1.6703499537164519163, 1.6578628525741725325, 1.6454374393037234057, 1.6330724165359912048,
+    1.6207665088282577216, 1.6085184617988580769, 1.5963270412864831349, 1.5841910325326886695,
+    1.5721092393862294810, 1.5600804835278879161, 1.5481036037145133070, 1.5361774550410318943,
+    1.5243009082192260050, 1.5124728488721167573, 1.5006921768428164936, 1.4889578055167456003,
+    1.4772686611561334579, 1.4656236822457450411, 1.4540218188487932264, 1.4424620319720121876,
+    1.4309432929388794104, 1.4194645827699828254, 1.4080248915695353509, 1.3966232179170417110,
+    1.3852585682631217189, 1.3739299563284902176, 1.3626364025050864742, 1.3513769332583349176,
+    1.3401505805295045843, 1.3289563811371163220, 1.3177933761763245480, 1.3066606104151739482,
+    1.2955571316866007210, 1.2844819902750125450, 1.2734342382962410994, 1.2624129290696153434,
+    1.2514171164808525098, 1.2404458543344064544, 1.2294981956938491599, 1.2185731922087903071,
+    1.2076698934267612830, 1.1967873460884031665, 1.1859245934042023557, 1.1750806743109117687,
+    1.1642546227056790397, 1.1534454666557748056, 1.1426522275816728928, 1.1318739194110786733,
+    1.1211095477013306083, 1.1103581087274114281, 1.0996185885325976575, 1.0888899619385472598,
+    1.0781711915113727024, 1.0674612264799681530, 1.0567590016025518414, 1.0460634359770445503,
+    1.0353734317905289496, 1.0246878730026178052, 1.0140056239570971074, 1.0033255279156973717,
+    0.99264640550727647009, 0.98196705308506317914, 0.97128624098390397896, 0.96060271166866709917,
+    0.94991517776407659940, 0.93922231995526297952, 0.92852278474721113999, 0.91781518207004493915,
+    0.90709808271569100600, 0.89637001558989069006, 0.88562946476175228052, 0.87487486629102585352,
+    0.86410460481100519511, 0.85331700984237406386, 0.84251035181036928333, 0.83168283773427388393,
+    0.82083260655441252290, 0.80995772405741906620, 0.79905617735548788109, 0.78812586886949324977,
+    0.77716460975913043936, 0.76617011273543541328, 0.75513998418198289808, 0.74407171550050873971,
+    0.73296267358436604916, 0.72181009030875689912, 0.71061105090965570413, 0.69936248110323266174,
+    0.68806113277374858613, 0.67670356802952337911, 0.66528614139267855405, 0.65380497984766565353,
+    0.64225596042453703448, 0.63063468493349100113, 0.61893645139487678178, 0.60715622162030085137,
+    0.59528858429150359384, 0.58332771274877027785, 0.57126731653258903915, 0.55910058551154127652,
+    0.54682012516331112550, 0.53441788123716615385, 0.52188505159213564105, 0.50921198244365495319,
+    0.49638804551867159754, 0.48340149165346224782, 0.47023927508216945338, 0.45688684093142071279,
+    0.44332786607355296305, 0.42954394022541129589, 0.41551416960035700100, 0.40121467889627836229,
+    0.38661797794112021568, 0.37169214532991786118, 0.35639976025839443721, 0.34069648106484979674,
+    0.32452911701691008547, 0.30783295467493287307, 0.29052795549123115167, 0.27251318547846547924,
+    0.25365836338591284433, 0.23379048305967553619, 0.21267151063096745264, 0.18995868962243277774,
+    0.16512762256418831796, 0.13730498094001380420, 0.10483850756582017915, 0.063852163815003480173,
+    0
+};
+
+template<class RealType>
+const RealType exponential_table<RealType>::table_y[257] = {
+    0, 0.00045413435384149675545, 0.00096726928232717452884, 0.0015362997803015723824,
+    0.0021459677437189061793, 0.0027887987935740759640, 0.0034602647778369039855, 0.0041572951208337952532,
+    0.0048776559835423925804, 0.0056196422072054831710, 0.0063819059373191794422, 0.0071633531836349841425,
+    0.0079630774380170392396, 0.0087803149858089752347, 0.0096144136425022094101, 0.010464810181029979488,
+    0.011331013597834597488, 0.012212592426255380661, 0.013109164931254991070, 0.014020391403181937334,
+    0.014945968011691148079, 0.015885621839973162490, 0.016839106826039946359, 0.017806200410911360563,
+    0.018786700744696029497, 0.019780424338009741737, 0.020787204072578117603, 0.021806887504283582125,
+    0.022839335406385238829, 0.023884420511558170348, 0.024942026419731782971, 0.026012046645134218076,
+    0.027094383780955798424, 0.028188948763978634421, 0.029295660224637394015, 0.030414443910466605492,
+    0.031545232172893605499, 0.032687963508959533317, 0.033842582150874329031, 0.035009037697397411067,
+    0.036187284781931419754, 0.037377282772959360128, 0.038578995503074859626, 0.039792391023374122670,
+    0.041017441380414820816, 0.042254122413316231413, 0.043502413568888183301, 0.044762297732943280694,
+    0.046033761076175166762, 0.047316792913181548703, 0.048611385573379494401, 0.049917534282706374944,
+    0.051235237055126279830, 0.052564494593071689595, 0.053905310196046085104, 0.055257689676697038322,
+    0.056621641283742874438, 0.057997175631200659098, 0.059384305633420264487, 0.060783046445479636051,
+    0.062193415408540996150, 0.063615431999807331076, 0.065049117786753755036, 0.066494496385339779043,
+    0.067951593421936607770, 0.069420436498728751675, 0.070901055162371828426, 0.072393480875708743023,
+    0.073897746992364746308, 0.075413888734058408453, 0.076941943170480510100, 0.078481949201606426042,
+    0.080033947542319910023, 0.081597980709237420930, 0.083174093009632380354, 0.084762330532368125386,
+    0.086362741140756912277, 0.087975374467270219300, 0.089600281910032864534, 0.091237516631040162057,
+    0.092887133556043546523, 0.094549189376055853718, 0.096223742550432800103, 0.097910853311492199618,
+    0.099610583670637128826, 0.10132299742595363588, 0.10304816017125771553, 0.10478613930657016928,
+    0.10653700405000166218, 0.10830082545103379867, 0.11007767640518539026, 0.11186763167005629731,
+    0.11367076788274431301, 0.11548716357863353664, 0.11731689921155557057, 0.11916005717532768467,
+    0.12101672182667483729, 0.12288697950954513498, 0.12477091858083096578, 0.12666862943751066518,
+    0.12858020454522817870, 0.13050573846833078225, 0.13244532790138752023, 0.13439907170221363078,
+    0.13636707092642885841, 0.13834942886358021406, 0.14034625107486244210, 0.14235764543247220043,
+    0.14438372216063476473, 0.14642459387834493787, 0.14848037564386679222, 0.15055118500103990354,
+    0.15263714202744286154, 0.15473836938446807312, 0.15685499236936522013, 0.15898713896931420572,
+    0.16113493991759203183, 0.16329852875190180795, 0.16547804187493600915, 0.16767361861725019322,
+    0.16988540130252766513, 0.17211353531532005700, 0.17435816917135348788, 0.17661945459049489581,
+    0.17889754657247831241, 0.18119260347549629488, 0.18350478709776746150, 0.18583426276219711495,
+    0.18818119940425430485, 0.19054576966319540013, 0.19292814997677133873, 0.19532852067956322315,
+    0.19774706610509886464, 0.20018397469191127727, 0.20263943909370901930, 0.20511365629383770880,
+    0.20760682772422204205, 0.21011915938898825914, 0.21265086199297827522, 0.21520215107537867786,
+    0.21777324714870053264, 0.22036437584335949720, 0.22297576805812018050, 0.22560766011668406495,
+    0.22826029393071670664, 0.23093391716962742173, 0.23362878343743333945, 0.23634515245705964715,
+    0.23908329026244917002, 0.24184346939887722761, 0.24462596913189210901, 0.24743107566532763894,
+    0.25025908236886230967, 0.25311029001562948171, 0.25598500703041538015, 0.25888354974901621678,
+    0.26180624268936295243, 0.26475341883506220209, 0.26772541993204481808, 0.27072259679906003167,
+    0.27374530965280298302, 0.27679392844851734458, 0.27986883323697289920, 0.28297041453878076010,
+    0.28609907373707684673, 0.28925522348967773308, 0.29243928816189258772, 0.29565170428126120948,
+    0.29889292101558177099, 0.30216340067569352897, 0.30546361924459023541, 0.30879406693456016794,
+    0.31215524877417956945, 0.31554768522712893632, 0.31897191284495723773, 0.32242848495608914289,
+    0.32591797239355619822, 0.32944096426413633091, 0.33299806876180896713, 0.33658991402867758144,
+    0.34021714906678004560, 0.34388044470450243010, 0.34758049462163698567, 0.35131801643748334681,
+    0.35509375286678745925, 0.35890847294874976196, 0.36276297335481777335, 0.36665807978151414890,
+    0.37059464843514599421, 0.37457356761590215193, 0.37859575940958081092, 0.38266218149600982112,
+    0.38677382908413768115, 0.39093173698479710717, 0.39513698183329015336, 0.39939068447523107877,
+    0.40369401253053026739, 0.40804818315203238238, 0.41245446599716116772, 0.41691418643300289465,
+    0.42142872899761659635, 0.42599954114303435739, 0.43062813728845883923, 0.43531610321563659758,
+    0.44006510084235387501, 0.44487687341454851593, 0.44975325116275498919, 0.45469615747461548049,
+    0.45970761564213768669, 0.46478975625042618067, 0.46994482528395999841, 0.47517519303737738299,
+    0.48048336393045423016, 0.48587198734188493564, 0.49134386959403255500, 0.49690198724154955294,
+    0.50254950184134769289, 0.50828977641064283495, 0.51412639381474855788, 0.52006317736823356823,
+    0.52610421398361972602, 0.53225388026304326945, 0.53851687200286186590, 0.54489823767243963663,
+    0.55140341654064131685, 0.55803828226258748140, 0.56480919291240022434, 0.57172304866482579008,
+    0.57878735860284503057, 0.58601031847726802755, 0.59340090169173341521, 0.60096896636523224742,
+    0.60872538207962206507, 0.61668218091520762326, 0.62485273870366592605, 0.63325199421436607968,
+    0.64189671642726607018, 0.65080583341457104881, 0.66000084107899974178, 0.66950631673192477684,
+    0.67935057226476538741, 0.68956649611707798890, 0.70019265508278816709, 0.71127476080507597882,
+    0.72286765959357200702, 0.73503809243142351530, 0.74786862198519510742, 0.76146338884989624862,
+    0.77595685204011559675, 0.79152763697249565519, 0.80842165152300838005, 0.82699329664305033399,
+    0.84778550062398962096, 0.87170433238120363669, 0.90046992992574643800, 0.93814368086217467916,
+    1
+};
+
+template<class RealType = double>
+struct unit_exponential_distribution
+{
+    template<class Engine>
+    RealType operator()(Engine& eng) {
+        const double * const table_x = exponential_table<double>::table_x;
+        const double * const table_y = exponential_table<double>::table_y;
+        RealType shift(0);
+        for(;;) {
+            std::pair<RealType, int> vals = generate_int_float_pair<RealType, 8>(eng);
+            int i = vals.second;
+            RealType x = vals.first * RealType(table_x[i]);
+            if(x < RealType(table_x[i + 1])) return shift + x;
+            // For i=0 we need to generate from the tail, but because this is an exponential
+            // distribution, the tail looks exactly like the body, so we can simply repeat with a
+            // shift:
+            if (i == 0) shift += RealType(table_x[1]);
+            else {
+                RealType y01 = uniform_01<RealType>()(eng);
+                RealType y = RealType(table_y[i]) + y01 * RealType(table_y[i+1] - table_y[i]);
+
+                // All we care about is whether these are < or > 0; these values are equal to
+                // (lbound) or proportional to (ubound) `y` minus the lower/upper bound.
+                RealType y_above_ubound = RealType(table_x[i] - table_x[i+1]) * y01 - (RealType(table_x[i]) - x),
+                         y_above_lbound = y - (RealType(table_y[i+1]) + (RealType(table_x[i+1]) - x) * RealType(table_y[i+1]));
+
+                if (y_above_ubound < 0 // if above the upper bound reject immediately
+                        &&
+                        (
+                         y_above_lbound < 0 // If below the lower bound accept immediately
+                         ||
+                         y < f(x) // Otherwise it's between the bounds and we need a full check
+                        )
+                   ) {
+                    return x + shift;
+                }
+            }
+        }
+    }
+    static RealType f(RealType x) {
+        using std::exp;
+        return exp(-x);
+    }
+};
+
+} // namespace detail
+
+
+/**
+ * The exponential distribution is a model of \random_distribution with
+ * a single parameter lambda.
+ *
+ * It has \f$\displaystyle p(x) = \lambda e^{-\lambda x}\f$
+ *
+ * The implementation uses the "ziggurat" algorithm, as described in
+ *
+ *  @blockquote
+ *  "The Ziggurat Method for Generating Random Variables",
+ *  George Marsaglia and Wai Wan Tsang, Journal of Statistical Software
+ *  Volume 5, Number 8 (2000), 1-7.
+ *  @endblockquote
+ */
+template<class RealType = double>
+class exponential_distribution
+{
+public:
+    typedef RealType input_type;
+    typedef RealType result_type;
+
+    class param_type
+    {
+    public:
+
+        typedef exponential_distribution distribution_type;
+
+        /**
+         * Constructs parameters with a given lambda.
+         *
+         * Requires: lambda > 0
+         */
+        param_type(RealType lambda_arg = RealType(1.0))
+          : _lambda(lambda_arg) { BOOST_ASSERT(_lambda > RealType(0)); }
+
+        /** Returns the lambda parameter of the distribution. */
+        RealType lambda() const { return _lambda; }
+
+        /** Writes the parameters to a @c std::ostream. */
+        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
+        {
+            os << parm._lambda;
+            return os;
+        }
+        
+        /** Reads the parameters from a @c std::istream. */
+        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
+        {
+            is >> parm._lambda;
+            return is;
+        }
+
+        /** Returns true if the two sets of parameters are equal. */
+        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
+        { return lhs._lambda == rhs._lambda; }
+
+        /** Returns true if the two sets of parameters are different. */
+        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
+
+    private:
+        RealType _lambda;
+    };
+
+    /**
+     * Constructs an exponential_distribution with a given lambda.
+     *
+     * Requires: lambda > 0
+     */
+    explicit exponential_distribution(RealType lambda_arg = RealType(1.0))
+      : _lambda(lambda_arg) { BOOST_ASSERT(_lambda > RealType(0)); }
+
+    /**
+     * Constructs an exponential_distribution from its parameters
+     */
+    explicit exponential_distribution(const param_type& parm)
+      : _lambda(parm.lambda()) {}
+
+    // compiler-generated copy ctor and assignment operator are fine
+
+    /** Returns the lambda parameter of the distribution. */
+    RealType lambda() const { return _lambda; }
+
+    /** Returns the smallest value that the distribution can produce. */
+    RealType min BOOST_PREVENT_MACRO_SUBSTITUTION () const
+    { return RealType(0); }
+    /** 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(_lambda); }
+    /** Sets the parameters of the distribution. */
+    void param(const param_type& parm) { _lambda = parm.lambda(); }
+
+    /**
+     * Effects: Subsequent uses of the distribution do not depend
+     * on values produced by any engine prior to invoking reset.
+     */
+    void reset() { }
+
+    /**
+     * Returns a random variate distributed according to the
+     * exponential distribution.
+     */
+    template<class Engine>
+    result_type operator()(Engine& eng) const
+    { 
+        detail::unit_exponential_distribution<RealType> impl;
+        return impl(eng) / _lambda;
+    }
+
+    /**
+     * Returns a random variate distributed according to the exponential
+     * distribution with parameters specified by param.
+     */
+    template<class Engine>
+    result_type operator()(Engine& eng, const param_type& parm) const
+    { 
+        return exponential_distribution(parm)(eng);
+    }
+
+    /** Writes the distribution to a std::ostream. */
+    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, exponential_distribution, ed)
+    {
+        os << ed._lambda;
+        return os;
+    }
+
+    /** Reads the distribution from a std::istream. */
+    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, exponential_distribution, ed)
+    {
+        is >> ed._lambda;
+        return is;
+    }
+
+    /**
+     * Returns true iff the two distributions will produce identical
+     * sequences of values given equal generators.
+     */
+    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(exponential_distribution, lhs, rhs)
+    { return lhs._lambda == rhs._lambda; }
+    
+    /**
+     * Returns true iff the two distributions will produce different
+     * sequences of values given equal generators.
+     */
+    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(exponential_distribution)
+
+private:
+    result_type _lambda;
+};
+
+} // namespace random
+
+using random::exponential_distribution;
+
+} // namespace boost
+
+#endif // BOOST_RANDOM_EXPONENTIAL_DISTRIBUTION_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/random/extreme_value_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/extreme_value_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/extreme_value_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/extreme_value_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/fisher_f_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/fisher_f_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/fisher_f_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/fisher_f_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/gamma_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/gamma_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/gamma_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/gamma_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/generate_canonical.hpp b/contrib/libboost/boost_1_65_0/boost/random/generate_canonical.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/generate_canonical.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/generate_canonical.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/geometric_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/geometric_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/geometric_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/geometric_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/hyperexponential_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/hyperexponential_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/hyperexponential_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/hyperexponential_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/independent_bits.hpp b/contrib/libboost/boost_1_65_0/boost/random/independent_bits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/independent_bits.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/independent_bits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/inversive_congruential.hpp b/contrib/libboost/boost_1_65_0/boost/random/inversive_congruential.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/inversive_congruential.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/inversive_congruential.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/lagged_fibonacci.hpp b/contrib/libboost/boost_1_65_0/boost/random/lagged_fibonacci.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/lagged_fibonacci.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/lagged_fibonacci.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/laplace_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/laplace_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/laplace_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/laplace_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/linear_congruential.hpp b/contrib/libboost/boost_1_65_0/boost/random/linear_congruential.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/linear_congruential.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/linear_congruential.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/linear_feedback_shift.hpp b/contrib/libboost/boost_1_65_0/boost/random/linear_feedback_shift.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/linear_feedback_shift.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/linear_feedback_shift.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/lognormal_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/lognormal_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/lognormal_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/lognormal_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/mersenne_twister.hpp b/contrib/libboost/boost_1_65_0/boost/random/mersenne_twister.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/mersenne_twister.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/mersenne_twister.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/negative_binomial_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/negative_binomial_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/negative_binomial_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/negative_binomial_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/non_central_chi_squared_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/non_central_chi_squared_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/non_central_chi_squared_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/non_central_chi_squared_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/normal_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/normal_distribution.hpp
similarity index 78%
rename from contrib/libboost/boost_1_62_0/boost/random/normal_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/normal_distribution.hpp
index 6fffc4aef57..b7ff3eba9b6 100644
--- a/contrib/libboost/boost_1_62_0/boost/random/normal_distribution.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/random/normal_distribution.hpp
@@ -23,17 +23,11 @@
 #include <boost/assert.hpp>
 #include <boost/limits.hpp>
 #include <boost/static_assert.hpp>
-#include <boost/integer.hpp>
-#include <boost/integer/integer_mask.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/make_unsigned.hpp>
 #include <boost/random/detail/config.hpp>
 #include <boost/random/detail/operators.hpp>
-#include <boost/random/detail/integer_log2.hpp>
+#include <boost/random/detail/int_float_pair.hpp>
 #include <boost/random/uniform_01.hpp>
-#include <boost/random/uniform_int_distribution.hpp>
 #include <boost/random/exponential_distribution.hpp>
-#include <boost/mpl/bool.hpp>
 
 namespace boost {
 namespace random {
@@ -121,89 +115,6 @@ const RealType normal_table<RealType>::table_y[129] = {
     1
 };
 
-template<class Engine>
-inline typename boost::make_unsigned<typename Engine::result_type>::type
-generate_one_digit(Engine& eng, std::size_t bits)
-{
-    typedef typename Engine::result_type base_result;
-    typedef typename boost::make_unsigned<base_result>::type base_unsigned;
-    
-    base_unsigned range =
-        detail::subtract<base_result>()((eng.max)(), (eng.min)());
-    base_unsigned y0_mask = (base_unsigned(2) << (bits - 1)) - 1;
-    base_unsigned y0 = (range + 1) & ~y0_mask;
-    base_unsigned u;
-    do {
-        u = detail::subtract<base_result>()(eng(), (eng.min)());
-    } while(y0 != 0 && u > base_unsigned(y0 - 1));
-    return u & y0_mask;
-}
-
-template<class RealType, std::size_t w, class Engine>
-std::pair<RealType, int> generate_int_float_pair(Engine& eng, boost::mpl::true_)
-{
-    typedef typename Engine::result_type base_result;
-    typedef typename boost::make_unsigned<base_result>::type base_unsigned;
-    
-    base_unsigned range =
-        detail::subtract<base_result>()((eng.max)(), (eng.min)());
-    
-    std::size_t m =
-        (range == (std::numeric_limits<base_unsigned>::max)()) ?
-            std::numeric_limits<base_unsigned>::digits :
-            detail::integer_log2(range + 1);
-            
-    int bucket = 0;
-    // process as many full digits as possible into the int part
-    for(std::size_t i = 0; i < w/m; ++i) {
-        base_unsigned u = generate_one_digit(eng, m);
-        bucket = (bucket << m) | u;
-    }
-    RealType r;
-
-    const std::size_t digits = std::numeric_limits<RealType>::digits;
-    {
-        base_unsigned u = generate_one_digit(eng, m);
-        base_unsigned mask = (base_unsigned(1) << (w%m)) - 1;
-        bucket = (bucket << (w%m)) | (mask & u);
-        const RealType mult = RealType(1)/RealType(base_unsigned(1) << (m - w%m));
-        // zero out unused bits
-        if (m - w%m > digits) {
-            u &= ~(base_unsigned(1) << (m - digits));
-        }
-        r = RealType(u >> (w%m)) * mult;
-    }
-    for(std::size_t i = m - w%m; i + m < digits; ++i) {
-        base_unsigned u = generate_one_digit(eng, m);
-        r += u;
-        r *= RealType(0.5)/RealType(base_unsigned(1) << (m - 1));
-    }
-    if (m - w%m < digits)
-    {
-        const std::size_t remaining = (digits - m + w%m) % m;
-        base_unsigned u = generate_one_digit(eng, m);
-        r += u & ((base_unsigned(2) << (remaining - 1)) - 1);
-        const RealType mult = RealType(0.5)/RealType(base_unsigned(1) << (remaining - 1));
-        r *= mult;
-    }
-    return std::make_pair(r, bucket);
-}
-
-template<class RealType, std::size_t w, class Engine>
-inline std::pair<RealType, int> generate_int_float_pair(Engine& eng, boost::mpl::false_)
-{
-    int bucket = uniform_int_distribution<>(0, (1 << w) - 1)(eng);
-    RealType r = uniform_01<RealType>()(eng);
-    return std::make_pair(r, bucket);
-}
-
-template<class RealType, std::size_t w, class Engine>
-inline std::pair<RealType, int> generate_int_float_pair(Engine& eng)
-{
-    typedef typename Engine::result_type base_result;
-    return generate_int_float_pair<RealType, w>(eng,
-        boost::is_integral<base_result>());
-}
 
 template<class RealType = double>
 struct unit_normal_distribution
@@ -220,29 +131,77 @@ struct unit_normal_distribution
             RealType x = vals.first * RealType(table_x[i]);
             if(x < table_x[i + 1]) return x * sign;
             if(i == 0) return generate_tail(eng) * sign;
-            RealType y = RealType(table_y[i]) + uniform_01<RealType>()(eng) * RealType(table_y[i + 1] - table_y[i]);
-            if (y < f(x)) return x * sign;
+
+            RealType y01 = uniform_01<RealType>()(eng);
+            RealType y = RealType(table_y[i]) + y01 * RealType(table_y[i + 1] - table_y[i]);
+
+            // These store the value y - bound, or something proportional to that difference:
+            RealType y_above_ubound, y_above_lbound;
+
+            // There are three cases to consider:
+            // - convex regions (where x[i] > x[j] >= 1)
+            // - concave regions (where 1 <= x[i] < x[j])
+            // - region containing the inflection point (where x[i] > 1 > x[j])
+            // For convex (concave), exp^(-x^2/2) is bounded below (above) by the tangent at
+            // (x[i],y[i]) and is bounded above (below) by the diagonal line from (x[i+1],y[i+1]) to
+            // (x[i],y[i]).
+            //
+            // *If* the inflection point region satisfies slope(x[i+1]) < slope(diagonal), then we
+            // can treat the inflection region as a convex region: this condition is necessary and
+            // sufficient to ensure that the curve lies entirely below the diagonal (that, in turn,
+            // also implies that it will be above the tangent at x[i]).
+            //
+            // For the current table size (128), this is satisfied: slope(x[i+1]) = -0.60653 <
+            // slope(diag) = -0.60649, and so we have only two cases below instead of three.
+
+            if (table_x[i] >= 1) { // convex (incl. inflection)
+                y_above_ubound = RealType(table_x[i] - table_x[i+1]) * y01 - (RealType(table_x[i]) - x);
+                y_above_lbound = y - (RealType(table_y[i]) + (RealType(table_x[i]) - x) * RealType(table_y[i]) * RealType(table_x[i]));
+            }
+            else { // concave
+                y_above_lbound = RealType(table_x[i] - table_x[i+1]) * y01 - (RealType(table_x[i]) - x);
+                y_above_ubound = y - (RealType(table_y[i]) + (RealType(table_x[i]) - x) * RealType(table_y[i]) * RealType(table_x[i]));
+            }
+
+            if (y_above_ubound < 0 // if above the upper bound reject immediately
+                    &&
+                    (
+                     y_above_lbound < 0 // If below the lower bound accept immediately
+                     ||
+                     y < f(x) // Otherwise it's between the bounds and we need a full check
+                    )
+               ) {
+                return x * sign;
+            }
         }
     }
     static RealType f(RealType x) {
         using std::exp;
-        return exp(-x*x/2);
+        return exp(-(x*x/2));
     }
+    // Generate from the tail using rejection sampling from the exponential(x_1) distribution,
+    // shifted by x_1.  This looks a little different from the usual rejection sampling because it
+    // transforms the condition by taking the log of both sides, thus avoiding the costly exp() call
+    // on the RHS, then takes advantage of the fact that -log(unif01) is simply generating an
+    // exponential (by inverse cdf sampling) by replacing the log(unif01) on the LHS with a
+    // exponential(1) draw, y.
     template<class Engine>
     RealType generate_tail(Engine& eng) {
-        boost::random::exponential_distribution<RealType> exponential;
         const RealType tail_start = RealType(normal_table<double>::table_x[1]);
+        boost::random::exponential_distribution<RealType> exp_x(tail_start);
+        boost::random::exponential_distribution<RealType> exp_y;
         for(;;) {
-            RealType x = exponential(eng)/tail_start;
-            RealType y = exponential(eng);
+            RealType x = exp_x(eng);
+            RealType y = exp_y(eng);
+            // If we were doing non-transformed rejection sampling, this condition would be:
+            // if (unif01 < exp(-.5*x*x)) return x + tail_start;
             if(2*y > x*x) return x + tail_start;
         }
     }
 };
 
-}
+} // namespace detail
 
-// deterministic Box-Muller method, uses trigonometric functions
 
 /**
  * Instantiations of class template normal_distribution model a
@@ -252,6 +211,14 @@ struct unit_normal_distribution
  *   \frac{1}{\sqrt{2\pi}\sigma} e^{-\frac{(x-\mu)^2}{2\sigma^2}}
  * \f$,
  * where mean and sigma are the parameters of the distribution.
+ *
+ * The implementation uses the "ziggurat" algorithm, as described in
+ *
+ *  @blockquote
+ *  "The Ziggurat Method for Generating Random Variables",
+ *  George Marsaglia and Wai Wan Tsang, Journal of Statistical Software,
+ *  Volume 5, Number 8 (2000), 1-7.
+ *  @endblockquote
  */
 template<class RealType = double>
 class normal_distribution
diff --git a/contrib/libboost/boost_1_62_0/boost/random/piecewise_constant_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/piecewise_constant_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/piecewise_constant_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/piecewise_constant_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/piecewise_linear_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/piecewise_linear_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/piecewise_linear_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/piecewise_linear_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/poisson_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/poisson_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/poisson_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/poisson_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/random_device.hpp b/contrib/libboost/boost_1_65_0/boost/random/random_device.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/random_device.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/random_device.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/random_number_generator.hpp b/contrib/libboost/boost_1_65_0/boost/random/random_number_generator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/random_number_generator.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/random_number_generator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/ranlux.hpp b/contrib/libboost/boost_1_65_0/boost/random/ranlux.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/ranlux.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/ranlux.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/seed_seq.hpp b/contrib/libboost/boost_1_65_0/boost/random/seed_seq.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/seed_seq.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/seed_seq.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/shuffle_order.hpp b/contrib/libboost/boost_1_65_0/boost/random/shuffle_order.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/shuffle_order.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/shuffle_order.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/shuffle_output.hpp b/contrib/libboost/boost_1_65_0/boost/random/shuffle_output.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/shuffle_output.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/shuffle_output.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/student_t_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/student_t_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/student_t_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/student_t_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/subtract_with_carry.hpp b/contrib/libboost/boost_1_65_0/boost/random/subtract_with_carry.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/subtract_with_carry.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/subtract_with_carry.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/taus88.hpp b/contrib/libboost/boost_1_65_0/boost/random/taus88.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/taus88.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/taus88.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/traits.hpp b/contrib/libboost/boost_1_65_0/boost/random/traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/triangle_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/triangle_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/triangle_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/triangle_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/uniform_01.hpp b/contrib/libboost/boost_1_65_0/boost/random/uniform_01.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/uniform_01.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/uniform_01.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/uniform_int.hpp b/contrib/libboost/boost_1_65_0/boost/random/uniform_int.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/uniform_int.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/uniform_int.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/uniform_int_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/uniform_int_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/uniform_int_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/uniform_int_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/uniform_on_sphere.hpp b/contrib/libboost/boost_1_65_0/boost/random/uniform_on_sphere.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/uniform_on_sphere.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/uniform_on_sphere.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/uniform_real.hpp b/contrib/libboost/boost_1_65_0/boost/random/uniform_real.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/uniform_real.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/uniform_real.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/uniform_real_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/uniform_real_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/uniform_real_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/uniform_real_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/uniform_smallint.hpp b/contrib/libboost/boost_1_65_0/boost/random/uniform_smallint.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/uniform_smallint.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/uniform_smallint.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/variate_generator.hpp b/contrib/libboost/boost_1_65_0/boost/random/variate_generator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/variate_generator.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/variate_generator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/weibull_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/weibull_distribution.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/weibull_distribution.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/weibull_distribution.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/random/xor_combine.hpp b/contrib/libboost/boost_1_65_0/boost/random/xor_combine.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/random/xor_combine.hpp
rename to contrib/libboost/boost_1_65_0/boost/random/xor_combine.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/range.hpp b/contrib/libboost/boost_1_65_0/boost/range.hpp
new file mode 100644
index 00000000000..179ae224921
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/range.hpp
@@ -0,0 +1,23 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2003-2004. 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_HPP_27_07_04
+#define BOOST_RANGE_HPP_27_07_04
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/range/functions.hpp>
+#include <boost/range/metafunctions.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/sub_range.hpp>
+
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/range/adaptor/adjacent_filtered.hpp b/contrib/libboost/boost_1_65_0/boost/range/adaptor/adjacent_filtered.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/adaptor/adjacent_filtered.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/adaptor/adjacent_filtered.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/adaptor/argument_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/range/adaptor/argument_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/adaptor/argument_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/adaptor/argument_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/adaptor/copied.hpp b/contrib/libboost/boost_1_65_0/boost/range/adaptor/copied.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/adaptor/copied.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/adaptor/copied.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/adaptor/define_adaptor.hpp b/contrib/libboost/boost_1_65_0/boost/range/adaptor/define_adaptor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/adaptor/define_adaptor.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/adaptor/define_adaptor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/adaptor/filtered.hpp b/contrib/libboost/boost_1_65_0/boost/range/adaptor/filtered.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/adaptor/filtered.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/adaptor/filtered.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/adaptor/formatted.hpp b/contrib/libboost/boost_1_65_0/boost/range/adaptor/formatted.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/adaptor/formatted.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/adaptor/formatted.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/adaptor/indexed.hpp b/contrib/libboost/boost_1_65_0/boost/range/adaptor/indexed.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/adaptor/indexed.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/adaptor/indexed.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/adaptor/indirected.hpp b/contrib/libboost/boost_1_65_0/boost/range/adaptor/indirected.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/adaptor/indirected.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/adaptor/indirected.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/adaptor/map.hpp b/contrib/libboost/boost_1_65_0/boost/range/adaptor/map.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/adaptor/map.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/adaptor/map.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/adaptor/replaced.hpp b/contrib/libboost/boost_1_65_0/boost/range/adaptor/replaced.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/adaptor/replaced.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/adaptor/replaced.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/adaptor/replaced_if.hpp b/contrib/libboost/boost_1_65_0/boost/range/adaptor/replaced_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/adaptor/replaced_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/adaptor/replaced_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/adaptor/reversed.hpp b/contrib/libboost/boost_1_65_0/boost/range/adaptor/reversed.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/adaptor/reversed.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/adaptor/reversed.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/adaptor/sliced.hpp b/contrib/libboost/boost_1_65_0/boost/range/adaptor/sliced.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/adaptor/sliced.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/adaptor/sliced.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/adaptor/strided.hpp b/contrib/libboost/boost_1_65_0/boost/range/adaptor/strided.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/adaptor/strided.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/adaptor/strided.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/adaptor/tokenized.hpp b/contrib/libboost/boost_1_65_0/boost/range/adaptor/tokenized.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/adaptor/tokenized.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/adaptor/tokenized.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/adaptor/transformed.hpp b/contrib/libboost/boost_1_65_0/boost/range/adaptor/transformed.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/adaptor/transformed.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/adaptor/transformed.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/adaptor/type_erased.hpp b/contrib/libboost/boost_1_65_0/boost/range/adaptor/type_erased.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/adaptor/type_erased.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/adaptor/type_erased.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/adaptor/uniqued.hpp b/contrib/libboost/boost_1_65_0/boost/range/adaptor/uniqued.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/adaptor/uniqued.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/adaptor/uniqued.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/adaptors.hpp b/contrib/libboost/boost_1_65_0/boost/range/adaptors.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/adaptors.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/adaptors.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/adjacent_find.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/adjacent_find.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/adjacent_find.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/adjacent_find.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/binary_search.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/binary_search.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/binary_search.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/binary_search.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/copy.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/copy.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/copy.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/copy.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/copy_backward.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/copy_backward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/copy_backward.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/copy_backward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/count.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/count.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/count.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/count.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/count_if.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/count_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/count_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/count_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/equal.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/equal_range.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/equal_range.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/equal_range.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/equal_range.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/fill.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/fill.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/fill.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/fill.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/fill_n.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/fill_n.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/fill_n.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/fill_n.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/find.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/find.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/find.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/find.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/find_end.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/find_end.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/find_end.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/find_end.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/find_first_of.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/find_first_of.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/find_first_of.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/find_first_of.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/find_if.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/find_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/find_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/find_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/for_each.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/for_each.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/for_each.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/for_each.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/generate.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/generate.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/generate.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/generate.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/heap_algorithm.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/heap_algorithm.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/heap_algorithm.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/heap_algorithm.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/inplace_merge.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/inplace_merge.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/inplace_merge.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/inplace_merge.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/lexicographical_compare.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/lexicographical_compare.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/lexicographical_compare.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/lexicographical_compare.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/lower_bound.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/lower_bound.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/lower_bound.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/lower_bound.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/max_element.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/max_element.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/max_element.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/max_element.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/merge.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/merge.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/merge.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/merge.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/min_element.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/min_element.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/min_element.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/min_element.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/mismatch.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/mismatch.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/mismatch.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/mismatch.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/nth_element.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/nth_element.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/nth_element.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/nth_element.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/partial_sort.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/partial_sort.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/partial_sort.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/partial_sort.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/partial_sort_copy.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/partial_sort_copy.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/partial_sort_copy.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/partial_sort_copy.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/partition.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/partition.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/partition.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/partition.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/permutation.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/permutation.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/permutation.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/permutation.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/random_shuffle.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/random_shuffle.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/random_shuffle.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/random_shuffle.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/remove.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/remove.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/remove.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/remove.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/remove_copy.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/remove_copy.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/remove_copy.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/remove_copy.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/remove_copy_if.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/remove_copy_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/remove_copy_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/remove_copy_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/remove_if.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/remove_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/remove_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/remove_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/replace.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/replace.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/replace.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/replace.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/replace_copy.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/replace_copy.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/replace_copy.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/replace_copy.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/replace_copy_if.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/replace_copy_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/replace_copy_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/replace_copy_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/replace_if.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/replace_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/replace_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/replace_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/reverse.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/reverse.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/reverse.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/reverse.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/reverse_copy.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/reverse_copy.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/reverse_copy.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/reverse_copy.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/rotate.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/rotate.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/rotate.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/rotate.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/rotate_copy.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/rotate_copy.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/rotate_copy.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/rotate_copy.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/search.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/search.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/search.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/search.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/search_n.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/search_n.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/search_n.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/search_n.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/set_algorithm.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/set_algorithm.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/set_algorithm.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/set_algorithm.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/sort.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/sort.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/sort.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/sort.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/stable_partition.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/stable_partition.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/stable_partition.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/stable_partition.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/stable_sort.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/stable_sort.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/stable_sort.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/stable_sort.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/swap_ranges.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/swap_ranges.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/swap_ranges.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/swap_ranges.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/transform.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/transform.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/transform.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/transform.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/unique.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/unique.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/unique.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/unique.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/unique_copy.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/unique_copy.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/unique_copy.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/unique_copy.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm/upper_bound.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm/upper_bound.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm/upper_bound.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm/upper_bound.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm_ext.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm_ext.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm_ext.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm_ext.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm_ext/copy_n.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm_ext/copy_n.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm_ext/copy_n.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm_ext/copy_n.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm_ext/erase.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm_ext/erase.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm_ext/erase.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm_ext/erase.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm_ext/for_each.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm_ext/for_each.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm_ext/for_each.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm_ext/for_each.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm_ext/insert.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm_ext/insert.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm_ext/insert.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm_ext/insert.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm_ext/iota.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm_ext/iota.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm_ext/iota.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm_ext/iota.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm_ext/is_sorted.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm_ext/is_sorted.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm_ext/is_sorted.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm_ext/is_sorted.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm_ext/overwrite.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm_ext/overwrite.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm_ext/overwrite.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm_ext/overwrite.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm_ext/push_back.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm_ext/push_back.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm_ext/push_back.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm_ext/push_back.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/algorithm_ext/push_front.hpp b/contrib/libboost/boost_1_65_0/boost/range/algorithm_ext/push_front.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/algorithm_ext/push_front.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/algorithm_ext/push_front.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/any_range.hpp b/contrib/libboost/boost_1_65_0/boost/range/any_range.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/any_range.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/any_range.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/as_array.hpp b/contrib/libboost/boost_1_65_0/boost/range/as_array.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/as_array.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/as_array.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/as_literal.hpp b/contrib/libboost/boost_1_65_0/boost/range/as_literal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/as_literal.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/as_literal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/atl.hpp b/contrib/libboost/boost_1_65_0/boost/range/atl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/atl.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/atl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/begin.hpp b/contrib/libboost/boost_1_65_0/boost/range/begin.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/begin.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/begin.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/category.hpp b/contrib/libboost/boost_1_65_0/boost/range/category.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/category.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/category.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/combine.hpp b/contrib/libboost/boost_1_65_0/boost/range/combine.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/combine.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/combine.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/concepts.hpp b/contrib/libboost/boost_1_65_0/boost/range/concepts.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/concepts.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/concepts.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/config.hpp b/contrib/libboost/boost_1_65_0/boost/range/config.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/config.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/config.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/const_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/range/const_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/const_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/const_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/const_reverse_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/range/const_reverse_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/const_reverse_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/const_reverse_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/counting_range.hpp b/contrib/libboost/boost_1_65_0/boost/range/counting_range.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/counting_range.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/counting_range.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/any_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/any_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/any_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/any_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/any_iterator_buffer.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/any_iterator_buffer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/any_iterator_buffer.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/any_iterator_buffer.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/any_iterator_interface.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/any_iterator_interface.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/any_iterator_interface.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/any_iterator_interface.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/any_iterator_wrapper.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/any_iterator_wrapper.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/any_iterator_wrapper.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/any_iterator_wrapper.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/as_literal.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/as_literal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/as_literal.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/as_literal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/begin.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/begin.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/begin.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/begin.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/collection_traits.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/collection_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/collection_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/collection_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/collection_traits_detail.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/collection_traits_detail.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/collection_traits_detail.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/collection_traits_detail.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/combine_cxx03.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/combine_cxx03.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/combine_cxx03.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/combine_cxx03.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/combine_cxx11.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/combine_cxx11.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/combine_cxx11.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/combine_cxx11.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/combine_no_rvalue.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/combine_no_rvalue.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/combine_no_rvalue.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/combine_no_rvalue.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/combine_rvalue.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/combine_rvalue.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/combine_rvalue.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/combine_rvalue.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/common.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/common.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/common.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/common.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/default_constructible_unary_fn.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/default_constructible_unary_fn.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/default_constructible_unary_fn.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/default_constructible_unary_fn.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/demote_iterator_traversal_tag.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/demote_iterator_traversal_tag.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/demote_iterator_traversal_tag.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/demote_iterator_traversal_tag.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/detail_str.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/detail_str.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/detail_str.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/detail_str.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/difference_type.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/difference_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/difference_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/difference_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/empty.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/empty.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/empty.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/empty.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/end.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/end.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/end.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/end.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/extract_optional_type.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/extract_optional_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/extract_optional_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/extract_optional_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/has_member_size.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/has_member_size.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/has_member_size.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/has_member_size.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/implementation_help.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/implementation_help.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/implementation_help.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/implementation_help.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/join_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/join_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/join_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/join_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/microsoft.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/microsoft.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/microsoft.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/microsoft.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/misc_concept.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/misc_concept.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/misc_concept.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/misc_concept.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/msvc_has_iterator_workaround.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/msvc_has_iterator_workaround.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/msvc_has_iterator_workaround.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/msvc_has_iterator_workaround.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/range_return.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/range_return.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/range_return.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/range_return.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/remove_extent.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/remove_extent.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/remove_extent.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/remove_extent.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/safe_bool.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/safe_bool.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/safe_bool.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/safe_bool.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/sfinae.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/sfinae.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/sfinae.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/sfinae.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/size_type.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/size_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/size_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/size_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/sizer.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/sizer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/sizer.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/sizer.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/str_types.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/str_types.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/str_types.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/str_types.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/detail/value_type.hpp b/contrib/libboost/boost_1_65_0/boost/range/detail/value_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/detail/value_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/detail/value_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/difference_type.hpp b/contrib/libboost/boost_1_65_0/boost/range/difference_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/difference_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/difference_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/distance.hpp b/contrib/libboost/boost_1_65_0/boost/range/distance.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/distance.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/distance.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/empty.hpp b/contrib/libboost/boost_1_65_0/boost/range/empty.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/empty.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/empty.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/end.hpp b/contrib/libboost/boost_1_65_0/boost/range/end.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/end.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/end.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/functions.hpp b/contrib/libboost/boost_1_65_0/boost/range/functions.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/functions.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/functions.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/has_range_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/range/has_range_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/has_range_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/has_range_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/irange.hpp b/contrib/libboost/boost_1_65_0/boost/range/irange.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/irange.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/irange.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/istream_range.hpp b/contrib/libboost/boost_1_65_0/boost/range/istream_range.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/istream_range.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/istream_range.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/iterator.hpp b/contrib/libboost/boost_1_65_0/boost/range/iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/iterator_range.hpp b/contrib/libboost/boost_1_65_0/boost/range/iterator_range.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/iterator_range.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/iterator_range.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/iterator_range_core.hpp b/contrib/libboost/boost_1_65_0/boost/range/iterator_range_core.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/iterator_range_core.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/iterator_range_core.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/iterator_range_hash.hpp b/contrib/libboost/boost_1_65_0/boost/range/iterator_range_hash.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/iterator_range_hash.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/iterator_range_hash.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/iterator_range_io.hpp b/contrib/libboost/boost_1_65_0/boost/range/iterator_range_io.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/iterator_range_io.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/iterator_range_io.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/join.hpp b/contrib/libboost/boost_1_65_0/boost/range/join.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/join.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/join.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/metafunctions.hpp b/contrib/libboost/boost_1_65_0/boost/range/metafunctions.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/metafunctions.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/metafunctions.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/mfc.hpp b/contrib/libboost/boost_1_65_0/boost/range/mfc.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/mfc.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/mfc.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/mfc_map.hpp b/contrib/libboost/boost_1_65_0/boost/range/mfc_map.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/mfc_map.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/mfc_map.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/mutable_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/range/mutable_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/mutable_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/mutable_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/numeric.hpp b/contrib/libboost/boost_1_65_0/boost/range/numeric.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/numeric.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/numeric.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/pointer.hpp b/contrib/libboost/boost_1_65_0/boost/range/pointer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/pointer.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/pointer.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/range_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/range/range_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/range_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/range_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/rbegin.hpp b/contrib/libboost/boost_1_65_0/boost/range/rbegin.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/rbegin.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/rbegin.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/reference.hpp b/contrib/libboost/boost_1_65_0/boost/range/reference.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/reference.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/reference.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/rend.hpp b/contrib/libboost/boost_1_65_0/boost/range/rend.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/rend.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/rend.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/result_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/range/result_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/result_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/result_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/reverse_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/range/reverse_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/reverse_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/reverse_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/reverse_result_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/range/reverse_result_iterator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/reverse_result_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/reverse_result_iterator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/size.hpp b/contrib/libboost/boost_1_65_0/boost/range/size.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/size.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/size.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/size_type.hpp b/contrib/libboost/boost_1_65_0/boost/range/size_type.hpp
similarity index 95%
rename from contrib/libboost/boost_1_62_0/boost/range/size_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/size_type.hpp
index f41c32128d4..0a2ea81bb98 100644
--- a/contrib/libboost/boost_1_62_0/boost/range/size_type.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/range/size_type.hpp
@@ -83,11 +83,6 @@ namespace boost
         detail::range_size<T>
     { };
 
-    template< class T >
-    struct range_size<const T > :
-        detail::range_size<T>
-    { };
-
 } // namespace boost
 
 
diff --git a/contrib/libboost/boost_1_62_0/boost/range/sub_range.hpp b/contrib/libboost/boost_1_65_0/boost/range/sub_range.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/sub_range.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/sub_range.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/traversal.hpp b/contrib/libboost/boost_1_65_0/boost/range/traversal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/traversal.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/traversal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/range/value_type.hpp b/contrib/libboost/boost_1_65_0/boost/range/value_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/range/value_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/range/value_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/rational.hpp b/contrib/libboost/boost_1_65_0/boost/rational.hpp
similarity index 54%
rename from contrib/libboost/boost_1_62_0/boost/rational.hpp
rename to contrib/libboost/boost_1_65_0/boost/rational.hpp
index 2b74b05fd32..4fc06c9edcb 100644
--- a/contrib/libboost/boost_1_62_0/boost/rational.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/rational.hpp
@@ -32,7 +32,7 @@
 //  05 May 12  Reduced use of implicit gcd (Mario Lang)
 //  05 Nov 06  Change rational_cast to not depend on division between different
 //             types (Daryle Walker)
-//  04 Nov 06  Off-load GCD and LCM to Boost.Math; add some invariant checks;
+//  04 Nov 06  Off-load GCD and LCM to Boost.Integer; add some invariant checks;
 //             add std::numeric_limits<> requirement to help GCD (Daryle Walker)
 //  31 Oct 06  Recoded both operator< to use round-to-negative-infinity
 //             divisions; the rational-value version now uses continued fraction
@@ -83,6 +83,10 @@
 #include <limits>                // for std::numeric_limits
 #include <boost/static_assert.hpp>  // for BOOST_STATIC_ASSERT
 #include <boost/throw_exception.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_class.hpp>
+#include <boost/type_traits/is_same.hpp>
 
 // Control whether depreciated GCD and LCM functions are included (default: yes)
 #ifndef BOOST_CONTROL_RATIONAL_HAS_GCD
@@ -95,18 +99,34 @@ namespace boost {
 template <typename IntType>
 IntType gcd(IntType n, IntType m)
 {
-    // Defer to the version in Boost.Math
+    // Defer to the version in Boost.Integer
     return integer::gcd( n, m );
 }
 
 template <typename IntType>
 IntType lcm(IntType n, IntType m)
 {
-    // Defer to the version in Boost.Math
+    // Defer to the version in Boost.Integer
     return integer::lcm( n, m );
 }
 #endif  // BOOST_CONTROL_RATIONAL_HAS_GCD
 
+namespace rational_detail{
+
+   template <class FromInt, class ToInt>
+   struct is_compatible_integer
+   {
+      BOOST_STATIC_CONSTANT(bool, value = ((std::numeric_limits<FromInt>::is_specialized && std::numeric_limits<FromInt>::is_integer
+         && (std::numeric_limits<FromInt>::digits <= std::numeric_limits<ToInt>::digits)
+         && (std::numeric_limits<FromInt>::radix == std::numeric_limits<ToInt>::radix)
+         && ((std::numeric_limits<FromInt>::is_signed == false) || (std::numeric_limits<ToInt>::is_signed == true))
+         && is_convertible<FromInt, ToInt>::value)
+         || is_same<FromInt, ToInt>::value)
+         || (is_class<ToInt>::value && is_class<FromInt>::value && is_convertible<FromInt, ToInt>::value));
+   };
+
+}
+
 class bad_rational : public std::domain_error
 {
 public:
@@ -115,24 +135,7 @@ public:
 };
 
 template <typename IntType>
-class rational :
-    less_than_comparable < rational<IntType>,
-    equality_comparable < rational<IntType>,
-    less_than_comparable2 < rational<IntType>, IntType,
-    equality_comparable2 < rational<IntType>, IntType,
-    addable < rational<IntType>,
-    subtractable < rational<IntType>,
-    multipliable < rational<IntType>,
-    dividable < rational<IntType>,
-    addable2 < rational<IntType>, IntType,
-    subtractable2 < rational<IntType>, IntType,
-    subtractable2_left < rational<IntType>, IntType,
-    multipliable2 < rational<IntType>, IntType,
-    dividable2 < rational<IntType>, IntType,
-    dividable2_left < rational<IntType>, IntType,
-    incrementable < rational<IntType>,
-    decrementable < rational<IntType>
-    > > > > > > > > > > > > > > > >
+class rational
 {
     // Class-wide pre-conditions
     BOOST_STATIC_ASSERT( ::std::numeric_limits<IntType>::is_specialized );
@@ -149,26 +152,104 @@ public:
 
     BOOST_CONSTEXPR
     rational() : num(0), den(1) {}
-    BOOST_CONSTEXPR
-    rational(param_type n) : num(n), den(1) {}
-    rational(param_type n, param_type d) : num(n), den(d) { normalize(); }
+    template <class T>
+    BOOST_CONSTEXPR rational(const T& n, typename enable_if_c<
+       rational_detail::is_compatible_integer<T, IntType>::value
+    >::type const* = 0) : num(n), den(1) {}
+    template <class T, class U>
+    rational(const T& n, const U& d, typename enable_if_c<
+       rational_detail::is_compatible_integer<T, IntType>::value && rational_detail::is_compatible_integer<U, IntType>::value
+    >::type const* = 0) : num(n), den(d) {
+       normalize();
+    }
 
-#ifndef BOOST_NO_MEMBER_TEMPLATES
     template < typename NewType >
     BOOST_CONSTEXPR explicit
-       rational(rational<NewType> const &r)
+       rational(rational<NewType> const &r, typename enable_if_c<rational_detail::is_compatible_integer<NewType, IntType>::value>::type const* = 0)
        : num(r.numerator()), den(is_normalized(int_type(r.numerator()),
        int_type(r.denominator())) ? r.denominator() :
        (BOOST_THROW_EXCEPTION(bad_rational("bad rational: denormalized conversion")), 0)){}
-#endif
 
+    template < typename NewType >
+    BOOST_CONSTEXPR explicit
+       rational(rational<NewType> const &r, typename disable_if_c<rational_detail::is_compatible_integer<NewType, IntType>::value>::type const* = 0)
+       : num(r.numerator()), den(is_normalized(int_type(r.numerator()),
+       int_type(r.denominator())) && is_safe_narrowing_conversion(r.denominator()) && is_safe_narrowing_conversion(r.numerator()) ? r.denominator() :
+       (BOOST_THROW_EXCEPTION(bad_rational("bad rational: denormalized conversion")), 0)){}
     // Default copy constructor and assignment are fine
 
     // Add assignment from IntType
-    rational& operator=(param_type i) { num = i; den = 1; return *this; }
+    template <class T>
+    typename enable_if_c<
+       rational_detail::is_compatible_integer<T, IntType>::value, rational &
+    >::type operator=(const T& n) { return assign(static_cast<IntType>(n), static_cast<IntType>(1)); }
 
     // Assign in place
-    rational& assign(param_type n, param_type d);
+    template <class T, class U>
+    typename enable_if_c<
+       rational_detail::is_compatible_integer<T, IntType>::value && rational_detail::is_compatible_integer<U, IntType>::value, rational &
+    >::type assign(const T& n, const U& d)
+    {
+       return *this = rational<IntType>(static_cast<IntType>(n), static_cast<IntType>(d));
+    }
+    //
+    // The following overloads should probably *not* be provided - 
+    // but are provided for backwards compatibity reasons only.
+    // These allow for construction/assignment from types that
+    // are wider than IntType only if there is an implicit
+    // conversion from T to IntType, they will throw a bad_rational
+    // if the conversion results in loss of precision or undefined behaviour.
+    //
+    template <class T>
+    rational(const T& n, typename enable_if_c<
+       std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::is_integer
+       && !rational_detail::is_compatible_integer<T, IntType>::value
+       && (std::numeric_limits<T>::radix == std::numeric_limits<IntType>::radix)
+       && is_convertible<T, IntType>::value
+    >::type const* = 0)
+    {
+       assign(n, static_cast<T>(1));
+    }
+    template <class T, class U>
+    rational(const T& n, const U& d, typename enable_if_c<
+       (!rational_detail::is_compatible_integer<T, IntType>::value
+       || !rational_detail::is_compatible_integer<U, IntType>::value)
+       && std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::is_integer
+       && (std::numeric_limits<T>::radix == std::numeric_limits<IntType>::radix)
+       && is_convertible<T, IntType>::value &&
+       std::numeric_limits<U>::is_specialized && std::numeric_limits<U>::is_integer
+       && (std::numeric_limits<U>::radix == std::numeric_limits<IntType>::radix)
+       && is_convertible<U, IntType>::value
+    >::type const* = 0)
+    {
+       assign(n, d);
+    }
+    template <class T>
+    typename enable_if_c<
+       std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::is_integer
+       && !rational_detail::is_compatible_integer<T, IntType>::value
+       && (std::numeric_limits<T>::radix == std::numeric_limits<IntType>::radix)
+       && is_convertible<T, IntType>::value,
+       rational &
+    >::type operator=(const T& n) { return assign(n, static_cast<T>(1)); }
+
+    template <class T, class U>
+    typename enable_if_c<
+       (!rational_detail::is_compatible_integer<T, IntType>::value
+          || !rational_detail::is_compatible_integer<U, IntType>::value)
+       && std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::is_integer
+       && (std::numeric_limits<T>::radix == std::numeric_limits<IntType>::radix)
+       && is_convertible<T, IntType>::value &&
+       std::numeric_limits<U>::is_specialized && std::numeric_limits<U>::is_integer
+       && (std::numeric_limits<U>::radix == std::numeric_limits<IntType>::radix)
+       && is_convertible<U, IntType>::value,
+       rational &
+    >::type assign(const T& n, const U& d)
+    {
+       if(!is_safe_narrowing_conversion(n) || !is_safe_narrowing_conversion(d))
+          BOOST_THROW_EXCEPTION(bad_rational());
+       return *this = rational<IntType>(static_cast<IntType>(n), static_cast<IntType>(d));
+    }
 
     // Access to representation
     BOOST_CONSTEXPR
@@ -182,15 +263,66 @@ public:
     rational& operator*= (const rational& r);
     rational& operator/= (const rational& r);
 
-    rational& operator+= (param_type i) { num += i * den; return *this; }
-    rational& operator-= (param_type i) { num -= i * den; return *this; }
-    rational& operator*= (param_type i);
-    rational& operator/= (param_type i);
+    template <class T>
+    typename boost::enable_if_c<rational_detail::is_compatible_integer<T, IntType>::value, rational&>::type operator+= (const T& i)
+    {
+       num += i * den;
+       return *this;
+    }
+    template <class T>
+    typename boost::enable_if_c<rational_detail::is_compatible_integer<T, IntType>::value, rational&>::type operator-= (const T& i)
+    {
+       num -= i * den;
+       return *this;
+    }
+    template <class T>
+    typename boost::enable_if_c<rational_detail::is_compatible_integer<T, IntType>::value, rational&>::type operator*= (const T& i)
+    {
+       // Avoid overflow and preserve normalization
+       IntType gcd = integer::gcd(static_cast<IntType>(i), den);
+       num *= i / gcd;
+       den /= gcd;
+       return *this;
+    }
+    template <class T>
+    typename boost::enable_if_c<rational_detail::is_compatible_integer<T, IntType>::value, rational&>::type operator/= (const T& i)
+    {
+       // Avoid repeated construction
+       IntType const zero(0);
+
+       if(i == zero) BOOST_THROW_EXCEPTION(bad_rational());
+       if(num == zero) return *this;
+
+       // Avoid overflow and preserve normalization
+       IntType const gcd = integer::gcd(num, static_cast<IntType>(i));
+       num /= gcd;
+       den *= i / gcd;
+
+       if(den < zero) {
+          num = -num;
+          den = -den;
+       }
+
+       return *this;
+    }
 
     // Increment and decrement
     const rational& operator++() { num += den; return *this; }
     const rational& operator--() { num -= den; return *this; }
 
+    rational operator++(int)
+    {
+       rational t(*this);
+       ++(*this);
+       return t;
+    }
+    rational operator--(int)
+    {
+       rational t(*this);
+       --(*this);
+       return t;
+    }
+
     // Operator not
     BOOST_CONSTEXPR
     bool operator!() const { return !num; }
@@ -213,13 +345,37 @@ public:
 
     // Comparison operators
     bool operator< (const rational& r) const;
+    bool operator> (const rational& r) const { return r < *this; }
     BOOST_CONSTEXPR
     bool operator== (const rational& r) const;
 
-    bool operator< (param_type i) const;
-    bool operator> (param_type i) const;
-    BOOST_CONSTEXPR
-    bool operator== (param_type i) const;
+    template <class T>
+    typename boost::enable_if_c<rational_detail::is_compatible_integer<T, IntType>::value, bool>::type operator< (const T& i) const
+    {
+       // Avoid repeated construction
+       int_type const  zero(0);
+
+       // Break value into mixed-fraction form, w/ always-nonnegative remainder
+       BOOST_ASSERT(this->den > zero);
+       int_type  q = this->num / this->den, r = this->num % this->den;
+       while(r < zero)  { r += this->den; --q; }
+
+       // Compare with just the quotient, since the remainder always bumps the
+       // value up.  [Since q = floor(n/d), and if n/d < i then q < i, if n/d == i
+       // then q == i, if n/d == i + r/d then q == i, and if n/d >= i + 1 then
+       // q >= i + 1 > i; therefore n/d < i iff q < i.]
+       return q < i;
+    }
+    template <class T>
+    typename boost::enable_if_c<rational_detail::is_compatible_integer<T, IntType>::value, bool>::type operator>(const T& i) const
+    {
+       return operator==(i) ? false : !operator<(i);
+    }
+    template <class T>
+    BOOST_CONSTEXPR typename boost::enable_if_c<rational_detail::is_compatible_integer<T, IntType>::value, bool>::type operator== (const T& i) const
+    {
+       return ((den == IntType(1)) && (num == i));
+    }
 
 private:
     // Implementation - numerator and denominator (normalized).
@@ -251,15 +407,70 @@ private:
         return d > zero && ( n != zero || d == one ) && inner_abs( inner_gcd(n,
          d, zero), zero ) == one;
     }
+    //
+    // Conversion checks:
+    //
+    // (1) From an unsigned type with more digits than IntType:
+    //
+    template <class T>
+    BOOST_CONSTEXPR static typename boost::enable_if_c<(std::numeric_limits<T>::digits > std::numeric_limits<IntType>::digits) && (std::numeric_limits<T>::is_signed == false), bool>::type is_safe_narrowing_conversion(const T& val)
+    {
+       return val < (T(1) << std::numeric_limits<IntType>::digits);
+    }
+    //
+    // (2) From a signed type with more digits than IntType, and IntType also signed:
+    //
+    template <class T>
+    BOOST_CONSTEXPR static typename boost::enable_if_c<(std::numeric_limits<T>::digits > std::numeric_limits<IntType>::digits) && (std::numeric_limits<T>::is_signed == true) && (std::numeric_limits<IntType>::is_signed == true), bool>::type is_safe_narrowing_conversion(const T& val)
+    {
+       // Note that this check assumes IntType has a 2's complement representation,
+       // we don't want to try to convert a std::numeric_limits<IntType>::min() to
+       // a T because that conversion may not be allowed (this happens when IntType
+       // is from Boost.Multiprecision).
+       return (val < (T(1) << std::numeric_limits<IntType>::digits)) && (val >= -(T(1) << std::numeric_limits<IntType>::digits));
+    }
+    //
+    // (3) From a signed type with more digits than IntType, and IntType unsigned:
+    //
+    template <class T>
+    BOOST_CONSTEXPR static typename boost::enable_if_c<(std::numeric_limits<T>::digits > std::numeric_limits<IntType>::digits) && (std::numeric_limits<T>::is_signed == true) && (std::numeric_limits<IntType>::is_signed == false), bool>::type is_safe_narrowing_conversion(const T& val)
+    {
+       return (val < (T(1) << std::numeric_limits<IntType>::digits)) && (val >= 0);
+    }
+    //
+    // (4) From a signed type with fewer digits than IntType, and IntType unsigned:
+    //
+    template <class T>
+    BOOST_CONSTEXPR static typename boost::enable_if_c<(std::numeric_limits<T>::digits <= std::numeric_limits<IntType>::digits) && (std::numeric_limits<T>::is_signed == true) && (std::numeric_limits<IntType>::is_signed == false), bool>::type is_safe_narrowing_conversion(const T& val)
+    {
+       return val >= 0;
+    }
+    //
+    // (5) From an unsigned type with fewer digits than IntType, and IntType signed:
+    //
+    template <class T>
+    BOOST_CONSTEXPR static typename boost::enable_if_c<(std::numeric_limits<T>::digits <= std::numeric_limits<IntType>::digits) && (std::numeric_limits<T>::is_signed == false) && (std::numeric_limits<IntType>::is_signed == true), bool>::type is_safe_narrowing_conversion(const T&)
+    {
+       return true;
+    }
+    //
+    // (6) From an unsigned type with fewer digits than IntType, and IntType unsigned:
+    //
+    template <class T>
+    BOOST_CONSTEXPR static typename boost::enable_if_c<(std::numeric_limits<T>::digits <= std::numeric_limits<IntType>::digits) && (std::numeric_limits<T>::is_signed == false) && (std::numeric_limits<IntType>::is_signed == false), bool>::type is_safe_narrowing_conversion(const T&)
+    {
+       return true;
+    }
+    //
+    // (7) From an signed type with fewer digits than IntType, and IntType signed:
+    //
+    template <class T>
+    BOOST_CONSTEXPR static typename boost::enable_if_c<(std::numeric_limits<T>::digits <= std::numeric_limits<IntType>::digits) && (std::numeric_limits<T>::is_signed == true) && (std::numeric_limits<IntType>::is_signed == true), bool>::type is_safe_narrowing_conversion(const T&)
+    {
+       return true;
+    }
 };
 
-// Assign in place
-template <typename IntType>
-inline rational<IntType>& rational<IntType>::assign(param_type n, param_type d)
-{
-    return *this = rational( n, d );
-}
-
 // Unary plus and minus
 template <typename IntType>
 BOOST_CONSTEXPR
@@ -271,7 +482,7 @@ inline rational<IntType> operator+ (const rational<IntType>& r)
 template <typename IntType>
 inline rational<IntType> operator- (const rational<IntType>& r)
 {
-    return rational<IntType>(-r.numerator(), r.denominator());
+    return rational<IntType>(static_cast<IntType>(-r.numerator()), r.denominator());
 }
 
 // Arithmetic assignment operators
@@ -373,40 +584,155 @@ rational<IntType>& rational<IntType>::operator/= (const rational<IntType>& r)
     return *this;
 }
 
-// Mixed-mode operators
-template <typename IntType>
-inline rational<IntType>&
-rational<IntType>::operator*= (param_type i)
-{
-    // Avoid overflow and preserve normalization
-    IntType gcd = integer::gcd(i, den);
-    num *= i / gcd;
-    den /= gcd;
 
-    return *this;
+//
+// Non-member operators: previously these were provided by Boost.Operator, but these had a number of
+// drawbacks, most notably, that in order to allow inter-operability with IntType code such as this:
+//
+// rational<int> r(3);
+// assert(r == 3.5); // compiles and passes!!
+//
+// Happens to be allowed as well :-(
+//
+// There are three possible cases for each operator:
+// 1) rational op rational.
+// 2) rational op integer
+// 3) integer op rational
+// Cases (1) and (2) are folded into the one function.
+//
+template <class IntType, class Arg>
+inline typename boost::enable_if_c <
+   rational_detail::is_compatible_integer<Arg, IntType>::value || is_same<rational<IntType>, Arg>::value, rational<IntType> >::type
+   operator + (const rational<IntType>& a, const Arg& b)
+{
+      rational<IntType> t(a);
+      return t += b;
+}
+template <class Arg, class IntType>
+inline typename boost::enable_if_c <
+   rational_detail::is_compatible_integer<Arg, IntType>::value, rational<IntType> >::type
+   operator + (const Arg& b, const rational<IntType>& a)
+{
+      rational<IntType> t(a);
+      return t += b;
 }
 
-template <typename IntType>
-rational<IntType>&
-rational<IntType>::operator/= (param_type i)
+template <class IntType, class Arg>
+inline typename boost::enable_if_c <
+   rational_detail::is_compatible_integer<Arg, IntType>::value || is_same<rational<IntType>, Arg>::value, rational<IntType> >::type
+   operator - (const rational<IntType>& a, const Arg& b)
 {
-    // Avoid repeated construction
-    IntType const zero(0);
+      rational<IntType> t(a);
+      return t -= b;
+}
+template <class Arg, class IntType>
+inline typename boost::enable_if_c <
+   rational_detail::is_compatible_integer<Arg, IntType>::value, rational<IntType> >::type
+   operator - (const Arg& b, const rational<IntType>& a)
+{
+      rational<IntType> t(a);
+      return -(t -= b);
+}
 
-    if(i == zero) BOOST_THROW_EXCEPTION(bad_rational());
-    if (num == zero) return *this;
+template <class IntType, class Arg>
+inline typename boost::enable_if_c <
+   rational_detail::is_compatible_integer<Arg, IntType>::value || is_same<rational<IntType>, Arg>::value, rational<IntType> >::type
+   operator * (const rational<IntType>& a, const Arg& b)
+{
+      rational<IntType> t(a);
+      return t *= b;
+}
+template <class Arg, class IntType>
+inline typename boost::enable_if_c <
+   rational_detail::is_compatible_integer<Arg, IntType>::value, rational<IntType> >::type
+   operator * (const Arg& b, const rational<IntType>& a)
+{
+      rational<IntType> t(a);
+      return t *= b;
+}
 
-    // Avoid overflow and preserve normalization
-    IntType const gcd = integer::gcd(num, i);
-    num /= gcd;
-    den *= i / gcd;
+template <class IntType, class Arg>
+inline typename boost::enable_if_c <
+   rational_detail::is_compatible_integer<Arg, IntType>::value || is_same<rational<IntType>, Arg>::value, rational<IntType> >::type
+   operator / (const rational<IntType>& a, const Arg& b)
+{
+      rational<IntType> t(a);
+      return t /= b;
+}
+template <class Arg, class IntType>
+inline typename boost::enable_if_c <
+   rational_detail::is_compatible_integer<Arg, IntType>::value, rational<IntType> >::type
+   operator / (const Arg& b, const rational<IntType>& a)
+{
+      rational<IntType> t(b);
+      return t /= a;
+}
 
-    if (den < zero) {
-        num = -num;
-        den = -den;
-    }
+template <class IntType, class Arg>
+inline typename boost::enable_if_c <
+   rational_detail::is_compatible_integer<Arg, IntType>::value || is_same<rational<IntType>, Arg>::value, bool>::type
+   operator <= (const rational<IntType>& a, const Arg& b)
+{
+      return !(a > b);
+}
+template <class Arg, class IntType>
+inline typename boost::enable_if_c <
+   rational_detail::is_compatible_integer<Arg, IntType>::value, bool>::type
+   operator <= (const Arg& b, const rational<IntType>& a)
+{
+      return a >= b;
+}
 
-    return *this;
+template <class IntType, class Arg>
+inline typename boost::enable_if_c <
+   rational_detail::is_compatible_integer<Arg, IntType>::value || is_same<rational<IntType>, Arg>::value, bool>::type
+   operator >= (const rational<IntType>& a, const Arg& b)
+{
+      return !(a < b);
+}
+template <class Arg, class IntType>
+inline typename boost::enable_if_c <
+   rational_detail::is_compatible_integer<Arg, IntType>::value, bool>::type
+   operator >= (const Arg& b, const rational<IntType>& a)
+{
+      return a <= b;
+}
+
+template <class IntType, class Arg>
+inline typename boost::enable_if_c <
+   rational_detail::is_compatible_integer<Arg, IntType>::value || is_same<rational<IntType>, Arg>::value, bool>::type
+   operator != (const rational<IntType>& a, const Arg& b)
+{
+      return !(a == b);
+}
+template <class Arg, class IntType>
+inline typename boost::enable_if_c <
+   rational_detail::is_compatible_integer<Arg, IntType>::value, bool>::type
+   operator != (const Arg& b, const rational<IntType>& a)
+{
+      return !(b == a);
+}
+
+template <class Arg, class IntType>
+inline typename boost::enable_if_c <
+   rational_detail::is_compatible_integer<Arg, IntType>::value, bool>::type
+   operator < (const Arg& b, const rational<IntType>& a)
+{
+      return a > b;
+}
+template <class Arg, class IntType>
+inline typename boost::enable_if_c <
+   rational_detail::is_compatible_integer<Arg, IntType>::value, bool>::type
+   operator > (const Arg& b, const rational<IntType>& a)
+{
+      return a < b;
+}
+template <class Arg, class IntType>
+inline typename boost::enable_if_c <
+   rational_detail::is_compatible_integer<Arg, IntType>::value, bool>::type
+   operator == (const Arg& b, const rational<IntType>& a)
+{
+      return a == b;
 }
 
 // Comparison operators
@@ -494,30 +820,6 @@ bool rational<IntType>::operator< (const rational<IntType>& r) const
     }
 }
 
-template <typename IntType>
-bool rational<IntType>::operator< (param_type i) const
-{
-    // Avoid repeated construction
-    int_type const  zero( 0 );
-
-    // Break value into mixed-fraction form, w/ always-nonnegative remainder
-    BOOST_ASSERT( this->den > zero );
-    int_type  q = this->num / this->den, r = this->num % this->den;
-    while ( r < zero )  { r += this->den; --q; }
-
-    // Compare with just the quotient, since the remainder always bumps the
-    // value up.  [Since q = floor(n/d), and if n/d < i then q < i, if n/d == i
-    // then q == i, if n/d == i + r/d then q == i, and if n/d >= i + 1 then
-    // q >= i + 1 > i; therefore n/d < i iff q < i.]
-    return q < i;
-}
-
-template <typename IntType>
-bool rational<IntType>::operator> (param_type i) const
-{
-    return operator==(i)? false: !operator<(i);
-}
-
 template <typename IntType>
 BOOST_CONSTEXPR
 inline bool rational<IntType>::operator== (const rational<IntType>& r) const
@@ -525,13 +827,6 @@ inline bool rational<IntType>::operator== (const rational<IntType>& r) const
     return ((num == r.num) && (den == r.den));
 }
 
-template <typename IntType>
-BOOST_CONSTEXPR
-inline bool rational<IntType>::operator== (param_type i) const
-{
-    return ((den == IntType(1)) && (num == i));
-}
-
 // Invariant check
 template <typename IntType>
 inline bool rational<IntType>::test_invariant() const
diff --git a/contrib/libboost/boost_1_62_0/boost/ref.hpp b/contrib/libboost/boost_1_65_0/boost/ref.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/ref.hpp
rename to contrib/libboost/boost_1_65_0/boost/ref.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/scoped_array.hpp b/contrib/libboost/boost_1_65_0/boost/scoped_array.hpp
similarity index 87%
rename from contrib/libboost/boost_1_62_0/boost/scoped_array.hpp
rename to contrib/libboost/boost_1_65_0/boost/scoped_array.hpp
index c02fa316bcd..d91889b7cf1 100644
--- a/contrib/libboost/boost_1_62_0/boost/scoped_array.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/scoped_array.hpp
@@ -8,8 +8,7 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
-//  http://www.boost.org/libs/smart_ptr/scoped_array.htm
-//
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
 #include <boost/smart_ptr/scoped_array.hpp>
 
diff --git a/contrib/libboost/boost_1_62_0/boost/scoped_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/scoped_ptr.hpp
similarity index 87%
rename from contrib/libboost/boost_1_62_0/boost/scoped_ptr.hpp
rename to contrib/libboost/boost_1_65_0/boost/scoped_ptr.hpp
index cb916dac1d1..334a22e2fe1 100644
--- a/contrib/libboost/boost_1_62_0/boost/scoped_ptr.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/scoped_ptr.hpp
@@ -8,8 +8,7 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
-//  http://www.boost.org/libs/smart_ptr/scoped_ptr.htm
-//
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
 #include <boost/smart_ptr/scoped_ptr.hpp>
 
diff --git a/contrib/libboost/boost_1_62_0/boost/shared_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/shared_ptr.hpp
similarity index 85%
rename from contrib/libboost/boost_1_62_0/boost/shared_ptr.hpp
rename to contrib/libboost/boost_1_65_0/boost/shared_ptr.hpp
index d31978c9250..cb01b265881 100644
--- a/contrib/libboost/boost_1_62_0/boost/shared_ptr.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/shared_ptr.hpp
@@ -11,7 +11,7 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
-//  See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 #include <boost/smart_ptr/shared_ptr.hpp>
diff --git a/contrib/libboost/boost_1_65_0/boost/smart_ptr/allocate_local_shared_array.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/allocate_local_shared_array.hpp
new file mode 100644
index 00000000000..f46f11049bd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/allocate_local_shared_array.hpp
@@ -0,0 +1,228 @@
+/*
+Copyright 2017 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_SMART_PTR_ALLOCATE_LOCAL_SHARED_ARRAY_HPP
+#define BOOST_SMART_PTR_ALLOCATE_LOCAL_SHARED_ARRAY_HPP
+
+#include <boost/smart_ptr/allocate_shared_array.hpp>
+#include <boost/smart_ptr/local_shared_ptr.hpp>
+
+namespace boost {
+namespace detail {
+
+template<class>
+struct lsp_if_array { };
+
+template<class T>
+struct lsp_if_array<T[]> {
+    typedef boost::local_shared_ptr<T[]> type;
+};
+
+template<class>
+struct lsp_if_size_array { };
+
+template<class T, std::size_t N>
+struct lsp_if_size_array<T[N]> {
+    typedef boost::local_shared_ptr<T[N]> type;
+};
+
+class lsp_array_base
+    : public local_counted_base {
+public:
+    void set(sp_counted_base* base) BOOST_SP_NOEXCEPT {
+        count_ = shared_count(base);
+    }
+
+    virtual void local_cb_destroy() BOOST_SP_NOEXCEPT {
+        shared_count().swap(count_);
+    }
+
+    virtual shared_count local_cb_get_shared_count() const BOOST_SP_NOEXCEPT {
+        return count_;
+    }
+
+private:
+    shared_count count_;
+};
+
+template<class A>
+class lsp_array_state
+    : public sp_array_state<A> {
+public:
+    template<class U>
+    lsp_array_state(const U& other, std::size_t size) BOOST_SP_NOEXCEPT
+        : sp_array_state<A>(other, size) { }
+
+    lsp_array_base& base() BOOST_SP_NOEXCEPT {
+        return base_;
+    }
+
+private:
+    lsp_array_base base_;
+};
+
+template<class A, std::size_t N>
+class lsp_size_array_state
+    : public sp_size_array_state<A, N> {
+public:
+    template<class U>
+    lsp_size_array_state(const U& other, std::size_t size) BOOST_SP_NOEXCEPT
+        : sp_size_array_state<A, N>(other, size) { }
+
+    lsp_array_base& base() BOOST_SP_NOEXCEPT {
+        return base_;
+    }
+
+private:
+    lsp_array_base base_;
+};
+
+} /* detail */
+
+template<class T, class A>
+inline typename detail::lsp_if_array<T>::type
+allocate_local_shared(const A& allocator, std::size_t count)
+{
+    typedef typename detail::sp_array_element<T>::type type;
+    typedef typename detail::sp_array_scalar<T>::type scalar;
+    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
+    typedef detail::lsp_array_state<other> state;
+    typedef detail::sp_array_base<state> base;
+    std::size_t size = count * detail::sp_array_count<type>::value;
+    detail::sp_array_result<other, base> result(allocator, size);
+    base* node = result.get();
+    scalar* start = detail::sp_array_start<base, scalar>(node);
+    ::new(static_cast<void*>(node)) base(allocator, size, start);
+    detail::lsp_array_base& local = node->state().base();
+    local.set(node);
+    result.release();
+    return local_shared_ptr<T>(detail::lsp_internal_constructor_tag(),
+        reinterpret_cast<type*>(start), &local);
+}
+
+template<class T, class A>
+inline typename detail::lsp_if_size_array<T>::type
+allocate_local_shared(const A& allocator)
+{
+    enum {
+        size = detail::sp_array_count<T>::value
+    };
+    typedef typename detail::sp_array_element<T>::type type;
+    typedef typename detail::sp_array_scalar<T>::type scalar;
+    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
+    typedef detail::lsp_size_array_state<other, size> state;
+    typedef detail::sp_array_base<state> base;
+    detail::sp_array_result<other, base> result(allocator, size);
+    base* node = result.get();
+    scalar* start = detail::sp_array_start<base, scalar>(node);
+    ::new(static_cast<void*>(node)) base(allocator, size, start);
+    detail::lsp_array_base& local = node->state().base();
+    local.set(node);
+    result.release();
+    return local_shared_ptr<T>(detail::lsp_internal_constructor_tag(),
+        reinterpret_cast<type*>(start), &local);
+}
+
+template<class T, class A>
+inline typename detail::lsp_if_array<T>::type
+allocate_local_shared(const A& allocator, std::size_t count,
+    const typename detail::sp_array_element<T>::type& value)
+{
+    typedef typename detail::sp_array_element<T>::type type;
+    typedef typename detail::sp_array_scalar<T>::type scalar;
+    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
+    typedef detail::lsp_array_state<other> state;
+    typedef detail::sp_array_base<state> base;
+    std::size_t size = count * detail::sp_array_count<type>::value;
+    detail::sp_array_result<other, base> result(allocator, size);
+    base* node = result.get();
+    scalar* start = detail::sp_array_start<base, scalar>(node);
+    ::new(static_cast<void*>(node)) base(allocator, size,
+        reinterpret_cast<const scalar*>(&value),
+        detail::sp_array_count<type>::value, start);
+    detail::lsp_array_base& local = node->state().base();
+    local.set(node);
+    result.release();
+    return local_shared_ptr<T>(detail::lsp_internal_constructor_tag(),
+        reinterpret_cast<type*>(start), &local);
+}
+
+template<class T, class A>
+inline typename detail::lsp_if_size_array<T>::type
+allocate_local_shared(const A& allocator,
+    const typename detail::sp_array_element<T>::type& value)
+{
+    enum {
+        size = detail::sp_array_count<T>::value
+    };
+    typedef typename detail::sp_array_element<T>::type type;
+    typedef typename detail::sp_array_scalar<T>::type scalar;
+    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
+    typedef detail::lsp_size_array_state<other, size> state;
+    typedef detail::sp_array_base<state> base;
+    detail::sp_array_result<other, base> result(allocator, size);
+    base* node = result.get();
+    scalar* start = detail::sp_array_start<base, scalar>(node);
+    ::new(static_cast<void*>(node)) base(allocator, size,
+        reinterpret_cast<const scalar*>(&value),
+        detail::sp_array_count<type>::value, start);
+    detail::lsp_array_base& local = node->state().base();
+    local.set(node);
+    result.release();
+    return local_shared_ptr<T>(detail::lsp_internal_constructor_tag(),
+        reinterpret_cast<type*>(start), &local);
+}
+
+template<class T, class A>
+inline typename detail::lsp_if_array<T>::type
+allocate_local_shared_noinit(const A& allocator, std::size_t count)
+{
+    typedef typename detail::sp_array_element<T>::type type;
+    typedef typename detail::sp_array_scalar<T>::type scalar;
+    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
+    typedef detail::lsp_array_state<other> state;
+    typedef detail::sp_array_base<state, false> base;
+    std::size_t size = count * detail::sp_array_count<type>::value;
+    detail::sp_array_result<other, base> result(allocator, size);
+    base* node = result.get();
+    scalar* start = detail::sp_array_start<base, scalar>(node);
+    ::new(static_cast<void*>(node)) base(detail::sp_default(), allocator,
+        size, start);
+    detail::lsp_array_base& local = node->state().base();
+    local.set(node);
+    result.release();
+    return local_shared_ptr<T>(detail::lsp_internal_constructor_tag(),
+        reinterpret_cast<type*>(start), &local);
+}
+
+template<class T, class A>
+inline typename detail::lsp_if_size_array<T>::type
+allocate_local_shared_noinit(const A& allocator)
+{
+    enum {
+        size = detail::sp_array_count<T>::value
+    };
+    typedef typename detail::sp_array_element<T>::type type;
+    typedef typename detail::sp_array_scalar<T>::type scalar;
+    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
+    typedef detail::lsp_size_array_state<other, size> state;
+    typedef detail::sp_array_base<state, false> base;
+    detail::sp_array_result<other, base> result(allocator, size);
+    base* node = result.get();
+    scalar* start = detail::sp_array_start<base, scalar>(node);
+    ::new(static_cast<void*>(node)) base(detail::sp_default(), allocator,
+        size, start);
+    detail::lsp_array_base& local = node->state().base();
+    local.set(node);
+    result.release();
+    return local_shared_ptr<T>(detail::lsp_internal_constructor_tag(),
+        reinterpret_cast<type*>(start), &local);
+}
+
+} /* boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/smart_ptr/allocate_shared_array.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/allocate_shared_array.hpp
new file mode 100644
index 00000000000..23c35aff3f7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/allocate_shared_array.hpp
@@ -0,0 +1,697 @@
+/*
+Copyright 2012-2017 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_SMART_PTR_ALLOCATE_SHARED_ARRAY_HPP
+#define BOOST_SMART_PTR_ALLOCATE_SHARED_ARRAY_HPP
+
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/type_traits/has_trivial_assign.hpp>
+#include <boost/type_traits/has_trivial_constructor.hpp>
+#include <boost/type_traits/has_trivial_destructor.hpp>
+#include <boost/type_traits/type_with_alignment.hpp>
+
+namespace boost {
+namespace detail {
+
+template<class>
+struct sp_if_array { };
+
+template<class T>
+struct sp_if_array<T[]> {
+    typedef boost::shared_ptr<T[]> type;
+};
+
+template<class>
+struct sp_if_size_array { };
+
+template<class T, std::size_t N>
+struct sp_if_size_array<T[N]> {
+    typedef boost::shared_ptr<T[N]> type;
+};
+
+template<class>
+struct sp_array_element { };
+
+template<class T>
+struct sp_array_element<T[]> {
+    typedef T type;
+};
+
+template<class T, std::size_t N>
+struct sp_array_element<T[N]> {
+    typedef T type;
+};
+
+template<class T>
+struct sp_array_scalar {
+    typedef T type;
+};
+
+template<class T, std::size_t N>
+struct sp_array_scalar<T[N]> {
+    typedef typename sp_array_scalar<T>::type type;
+};
+
+template<class T, std::size_t N>
+struct sp_array_scalar<const T[N]> {
+    typedef typename sp_array_scalar<T>::type type;
+};
+
+template<class T, std::size_t N>
+struct sp_array_scalar<volatile T[N]> {
+    typedef typename sp_array_scalar<T>::type type;
+};
+
+template<class T, std::size_t N>
+struct sp_array_scalar<const volatile T[N]> {
+    typedef typename sp_array_scalar<T>::type type;
+};
+
+template<class T>
+struct sp_array_scalar<T[]> {
+    typedef typename sp_array_scalar<T>::type type;
+};
+
+template<class T>
+struct sp_array_scalar<const T[]> {
+    typedef typename sp_array_scalar<T>::type type;
+};
+
+template<class T>
+struct sp_array_scalar<volatile T[]> {
+    typedef typename sp_array_scalar<T>::type type;
+};
+
+template<class T>
+struct sp_array_scalar<const volatile T[]> {
+    typedef typename sp_array_scalar<T>::type type;
+};
+
+template<class T>
+struct sp_array_count {
+    enum {
+        value = 1
+    };
+};
+
+template<class T, std::size_t N>
+struct sp_array_count<T[N]> {
+    enum {
+        value = N * sp_array_count<T>::value
+    };
+};
+
+template<std::size_t N, std::size_t M>
+struct sp_max_size {
+    enum {
+        value = N < M ? M : N
+    };
+};
+
+template<std::size_t N, std::size_t M>
+struct sp_align_up {
+    enum {
+        value = (N + M - 1) & ~(M - 1)
+    };
+};
+
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+template<class A, class T>
+struct sp_bind_allocator {
+    typedef typename std::allocator_traits<A>::template rebind_alloc<T> type;
+};
+#else
+template<class A, class T>
+struct sp_bind_allocator {
+    typedef typename A::template rebind<T>::other type;
+};
+#endif
+
+template<class T>
+BOOST_CONSTEXPR inline std::size_t
+sp_objects(std::size_t size) BOOST_SP_NOEXCEPT
+{
+    return (size + sizeof(T) - 1) / sizeof(T);
+}
+
+template<bool, class = void>
+struct sp_enable { };
+
+template<class T>
+struct sp_enable<true, T> {
+    typedef T type;
+};
+
+template<bool E, class A, class T>
+inline typename sp_enable<!E && boost::has_trivial_destructor<T>::value>::type
+sp_array_destroy(A&, T*, std::size_t) BOOST_SP_NOEXCEPT { }
+
+template<bool E, class A, class T>
+inline typename sp_enable<!E &&
+    !boost::has_trivial_destructor<T>::value>::type
+sp_array_destroy(A&, T* start, std::size_t size)
+{
+    while (size > 0) {
+        start[--size].~T();
+    }
+}
+
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+template<bool E, class A, class T>
+inline typename sp_enable<E>::type
+sp_array_destroy(A& allocator, T* start, std::size_t size)
+{
+    while (size > 0) {
+        std::allocator_traits<A>::destroy(allocator, start + --size);
+    }
+}
+#endif
+
+template<bool E, class A, class T>
+inline typename sp_enable<!E &&
+    boost::has_trivial_constructor<T>::value &&
+    boost::has_trivial_assign<T>::value>::type
+sp_array_construct(A&, T* start, std::size_t size)
+{
+    for (std::size_t i = 0; i < size; ++i) {
+        start[i] = T();
+    }
+}
+
+template<bool E, class A, class T>
+inline typename sp_enable<!E &&
+    boost::has_trivial_constructor<T>::value &&
+    boost::has_trivial_assign<T>::value>::type
+sp_array_construct(A&, T* start, std::size_t size, const T* list,
+    std::size_t count)
+{
+    for (std::size_t i = 0; i < size; ++i) {
+        start[i] = list[i % count];
+    }
+}
+
+#if !defined(BOOST_NO_EXCEPTIONS)
+template<bool E, class A, class T>
+inline typename sp_enable<!E &&
+    !(boost::has_trivial_constructor<T>::value &&
+      boost::has_trivial_assign<T>::value)>::type
+sp_array_construct(A& none, T* start, std::size_t size)
+{
+    std::size_t i = 0;
+    try {
+        for (; i < size; ++i) {
+            ::new(static_cast<void*>(start + i)) T();
+        }
+    } catch (...) {
+        sp_array_destroy<E>(none, start, i);
+        throw;
+    }
+}
+
+template<bool E, class A, class T>
+inline typename sp_enable<!E &&
+    !(boost::has_trivial_constructor<T>::value &&
+      boost::has_trivial_assign<T>::value)>::type
+sp_array_construct(A& none, T* start, std::size_t size, const T* list,
+    std::size_t count)
+{
+    std::size_t i = 0;
+    try {
+        for (; i < size; ++i) {
+            ::new(static_cast<void*>(start + i)) T(list[i % count]);
+        }
+    } catch (...) {
+        sp_array_destroy<E>(none, start, i);
+        throw;
+    }
+}
+#else
+template<bool E, class A, class T>
+inline typename sp_enable<!E &&
+    !(boost::has_trivial_constructor<T>::value &&
+      boost::has_trivial_assign<T>::value)>::type
+sp_array_construct(A&, T* start, std::size_t size)
+{
+    for (std::size_t i = 0; i < size; ++i) {
+        ::new(static_cast<void*>(start + i)) T();
+    }
+}
+
+template<bool E, class A, class T>
+inline typename sp_enable<!E &&
+    !(boost::has_trivial_constructor<T>::value &&
+      boost::has_trivial_assign<T>::value)>::type
+sp_array_construct(A&, T* start, std::size_t size, const T* list,
+    std::size_t count)
+{
+    for (std::size_t i = 0; i < size; ++i) {
+        ::new(static_cast<void*>(start + i)) T(list[i % count]);
+    }
+}
+#endif
+
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+#if !defined(BOOST_NO_EXCEPTIONS)
+template<bool E, class A, class T>
+inline typename sp_enable<E>::type
+sp_array_construct(A& allocator, T* start, std::size_t size)
+{
+    std::size_t i = 0;
+    try {
+        for (i = 0; i < size; ++i) {
+            std::allocator_traits<A>::construct(allocator, start + i);
+        }
+    } catch (...) {
+        sp_array_destroy<E>(allocator, start, i);
+        throw;
+    }
+}
+
+template<bool E, class A, class T>
+inline typename sp_enable<E>::type
+sp_array_construct(A& allocator, T* start, std::size_t size, const T* list,
+    std::size_t count)
+{
+    std::size_t i = 0;
+    try {
+        for (i = 0; i < size; ++i) {
+            std::allocator_traits<A>::construct(allocator, start + i,
+                list[i % count]);
+        }
+    } catch (...) {
+        sp_array_destroy<E>(allocator, start, i);
+        throw;
+    }
+}
+#else
+template<bool E, class A, class T>
+inline typename sp_enable<E>::type
+sp_array_construct(A& allocator, T* start, std::size_t size)
+{
+    for (std::size_t i = 0; i < size; ++i) {
+        std::allocator_traits<A>::construct(allocator, start + i);
+    }
+}
+
+template<bool E, class A, class T>
+inline typename sp_enable<E>::type
+sp_array_construct(A& allocator, T* start, std::size_t size, const T* list,
+    std::size_t count)
+{
+    for (std::size_t i = 0; i < size; ++i) {
+        std::allocator_traits<A>::construct(allocator, start + i,
+            list[i % count]);
+    }
+}
+#endif
+#endif
+
+template<class A, class T>
+inline typename sp_enable<boost::has_trivial_constructor<T>::value>::type
+sp_array_default(A&, T*, std::size_t) BOOST_SP_NOEXCEPT { }
+
+#if !defined(BOOST_NO_EXCEPTIONS)
+template<class A, class T>
+inline typename sp_enable<!boost::has_trivial_constructor<T>::value>::type
+sp_array_default(A& none, T* start, std::size_t size)
+{
+    std::size_t i = 0;
+    try {
+        for (; i < size; ++i) {
+            ::new(static_cast<void*>(start + i)) T;
+        }
+    } catch (...) {
+        sp_array_destroy<false>(none, start, i);
+        throw;
+    }
+}
+#else
+template<bool E, class A, class T>
+inline typename sp_enable<!boost::has_trivial_constructor<T>::value>::type
+sp_array_default(A&, T* start, std::size_t size)
+{
+    for (std::size_t i = 0; i < size; ++i) {
+        ::new(static_cast<void*>(start + i)) T;
+    }
+}
+#endif
+
+template<class A>
+class sp_array_state {
+public:
+    typedef A type;
+
+    template<class U>
+    sp_array_state(const U& allocator, std::size_t size) BOOST_SP_NOEXCEPT
+        : allocator_(allocator),
+          size_(size) { }
+
+    A& allocator() BOOST_SP_NOEXCEPT {
+        return allocator_;
+    }
+
+    std::size_t size() const BOOST_SP_NOEXCEPT {
+        return size_;
+    }
+
+private:
+    A allocator_;
+    std::size_t size_;
+};
+
+template<class A, std::size_t N>
+class sp_size_array_state {
+public:
+    typedef A type;
+
+    template<class U>
+    sp_size_array_state(const U& allocator, std::size_t) BOOST_SP_NOEXCEPT
+        : allocator_(allocator) { }
+
+    A& allocator() BOOST_SP_NOEXCEPT {
+        return allocator_;
+    }
+
+    BOOST_CONSTEXPR std::size_t size() const BOOST_SP_NOEXCEPT {
+        return N;
+    }
+
+private:
+    A allocator_;
+};
+
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+template<class A>
+struct sp_use_construct {
+    enum {
+        value = true
+    };
+};
+
+template<class T>
+struct sp_use_construct<std::allocator<T> > {
+    enum {
+        value = false
+    };
+};
+#else
+template<class>
+struct sp_use_construct {
+    enum {
+        value = false
+    };
+};
+#endif
+
+template<class T, class U>
+struct sp_array_alignment {
+    enum {
+        value = sp_max_size<boost::alignment_of<T>::value,
+            boost::alignment_of<U>::value>::value
+    };
+};
+
+template<class T, class U>
+struct sp_array_offset {
+    enum {
+        value = sp_align_up<sizeof(T), sp_array_alignment<T, U>::value>::value
+    };
+};
+
+template<class T, class U>
+struct sp_array_storage {
+    enum {
+        value = sp_array_alignment<T, U>::value
+    };
+    typedef typename boost::type_with_alignment<value>::type type;
+};
+
+template<class T, class U>
+inline U*
+sp_array_start(void* base) BOOST_SP_NOEXCEPT
+{
+    enum {
+        size = sp_array_offset<T, U>::value
+    };
+    return reinterpret_cast<U*>(static_cast<char*>(base) + size);
+}
+
+template<class A, class T>
+class sp_array_creator {
+    typedef typename A::value_type scalar;
+
+    enum {
+        offset = sp_array_offset<T, scalar>::value
+    };
+
+    typedef typename sp_array_storage<T, scalar>::type type;
+
+public:
+    template<class U>
+    sp_array_creator(const U& other, std::size_t size) BOOST_SP_NOEXCEPT
+        : other_(other),
+          size_(sp_objects<type>(offset + sizeof(scalar) * size)) { }
+
+    T* create() {
+        return reinterpret_cast<T*>(other_.allocate(size_));
+    }
+
+    void destroy(T* base) {
+        other_.deallocate(reinterpret_cast<type*>(base), size_);
+    }
+
+private:
+    typename sp_bind_allocator<A, type>::type other_;
+    std::size_t size_;
+};
+
+struct sp_default { };
+
+template<class T, bool E = sp_use_construct<T>::value>
+class sp_array_base
+    : public sp_counted_base {
+    typedef typename T::type allocator;
+
+public:
+    typedef typename allocator::value_type type;
+
+    template<class A>
+    sp_array_base(const A& other, std::size_t size, type* start)
+        : state_(other, size) {
+        sp_array_construct<E>(state_.allocator(), start, state_.size());
+    }
+
+    template<class A>
+    sp_array_base(const A& other, std::size_t size, const type* list,
+        std::size_t count, type* start)
+        : state_(other, size) {
+        sp_array_construct<E>(state_.allocator(), start, state_.size(), list,
+            count);
+    }
+
+    template<class A>
+    sp_array_base(sp_default, const A& other, std::size_t size, type* start)
+        : state_(other, size) {
+        sp_array_default(state_.allocator(), start, state_.size());
+    }
+
+    T& state() BOOST_SP_NOEXCEPT {
+        return state_;
+    }
+
+    virtual void dispose() {
+        sp_array_destroy<E>(state_.allocator(),
+            sp_array_start<sp_array_base, type>(this), state_.size());
+    }
+
+    virtual void destroy() {
+        sp_array_creator<allocator, sp_array_base> other(state_.allocator(),
+            state_.size());
+        this->~sp_array_base();
+        other.destroy(this);
+    }
+
+    virtual void* get_deleter(const sp_typeinfo&) {
+        return 0;
+    }
+
+    virtual void* get_local_deleter(const sp_typeinfo&) {
+        return 0;
+    }
+
+    virtual void* get_untyped_deleter() {
+        return 0;
+    }
+
+private:
+    T state_;
+};
+
+template<class A, class T>
+struct sp_array_result {
+public:
+    template<class U>
+    sp_array_result(const U& other, std::size_t size)
+        : creator_(other, size),
+          result_(creator_.create()) { }
+
+    ~sp_array_result() {
+        if (result_) {
+            creator_.destroy(result_);
+        }
+    }
+
+    T* get() const {
+        return result_;
+    }
+
+    void release() {
+        result_ = 0;
+    }
+
+private:
+    sp_array_result(const sp_array_result&);
+    sp_array_result& operator=(const sp_array_result&);
+
+    sp_array_creator<A, T> creator_;
+    T* result_;
+};
+
+} /* detail */
+
+template<class T, class A>
+inline typename detail::sp_if_array<T>::type
+allocate_shared(const A& allocator, std::size_t count)
+{
+    typedef typename detail::sp_array_element<T>::type type;
+    typedef typename detail::sp_array_scalar<T>::type scalar;
+    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
+    typedef detail::sp_array_state<other> state;
+    typedef detail::sp_array_base<state> base;
+    std::size_t size = count * detail::sp_array_count<type>::value;
+    detail::sp_array_result<other, base> result(allocator, size);
+    detail::sp_counted_base* node = result.get();
+    scalar* start = detail::sp_array_start<base, scalar>(node);
+    ::new(static_cast<void*>(node)) base(allocator, size, start);
+    result.release();
+    return shared_ptr<T>(detail::sp_internal_constructor_tag(),
+        reinterpret_cast<type*>(start), detail::shared_count(node));
+}
+
+template<class T, class A>
+inline typename detail::sp_if_size_array<T>::type
+allocate_shared(const A& allocator)
+{
+    enum {
+        size = detail::sp_array_count<T>::value
+    };
+    typedef typename detail::sp_array_element<T>::type type;
+    typedef typename detail::sp_array_scalar<T>::type scalar;
+    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
+    typedef detail::sp_size_array_state<other, size> state;
+    typedef detail::sp_array_base<state> base;
+    detail::sp_array_result<other, base> result(allocator, size);
+    detail::sp_counted_base* node = result.get();
+    scalar* start = detail::sp_array_start<base, scalar>(node);
+    ::new(static_cast<void*>(node)) base(allocator, size, start);
+    result.release();
+    return shared_ptr<T>(detail::sp_internal_constructor_tag(),
+        reinterpret_cast<type*>(start), detail::shared_count(node));
+}
+
+template<class T, class A>
+inline typename detail::sp_if_array<T>::type
+allocate_shared(const A& allocator, std::size_t count,
+    const typename detail::sp_array_element<T>::type& value)
+{
+    typedef typename detail::sp_array_element<T>::type type;
+    typedef typename detail::sp_array_scalar<T>::type scalar;
+    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
+    typedef detail::sp_array_state<other> state;
+    typedef detail::sp_array_base<state> base;
+    std::size_t size = count * detail::sp_array_count<type>::value;
+    detail::sp_array_result<other, base> result(allocator, size);
+    detail::sp_counted_base* node = result.get();
+    scalar* start = detail::sp_array_start<base, scalar>(node);
+    ::new(static_cast<void*>(node)) base(allocator, size,
+        reinterpret_cast<const scalar*>(&value),
+        detail::sp_array_count<type>::value, start);
+    result.release();
+    return shared_ptr<T>(detail::sp_internal_constructor_tag(),
+        reinterpret_cast<type*>(start), detail::shared_count(node));
+}
+
+template<class T, class A>
+inline typename detail::sp_if_size_array<T>::type
+allocate_shared(const A& allocator,
+    const typename detail::sp_array_element<T>::type& value)
+{
+    enum {
+        size = detail::sp_array_count<T>::value
+    };
+    typedef typename detail::sp_array_element<T>::type type;
+    typedef typename detail::sp_array_scalar<T>::type scalar;
+    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
+    typedef detail::sp_size_array_state<other, size> state;
+    typedef detail::sp_array_base<state> base;
+    detail::sp_array_result<other, base> result(allocator, size);
+    detail::sp_counted_base* node = result.get();
+    scalar* start = detail::sp_array_start<base, scalar>(node);
+    ::new(static_cast<void*>(node)) base(allocator, size,
+        reinterpret_cast<const scalar*>(&value),
+        detail::sp_array_count<type>::value, start);
+    result.release();
+    return shared_ptr<T>(detail::sp_internal_constructor_tag(),
+        reinterpret_cast<type*>(start), detail::shared_count(node));
+}
+
+template<class T, class A>
+inline typename detail::sp_if_array<T>::type
+allocate_shared_noinit(const A& allocator, std::size_t count)
+{
+    typedef typename detail::sp_array_element<T>::type type;
+    typedef typename detail::sp_array_scalar<T>::type scalar;
+    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
+    typedef detail::sp_array_state<other> state;
+    typedef detail::sp_array_base<state, false> base;
+    std::size_t size = count * detail::sp_array_count<type>::value;
+    detail::sp_array_result<other, base> result(allocator, size);
+    detail::sp_counted_base* node = result.get();
+    scalar* start = detail::sp_array_start<base, scalar>(node);
+    ::new(static_cast<void*>(node)) base(detail::sp_default(), allocator,
+        size, start);
+    result.release();
+    return shared_ptr<T>(detail::sp_internal_constructor_tag(),
+        reinterpret_cast<type*>(start), detail::shared_count(node));
+}
+
+template<class T, class A>
+inline typename detail::sp_if_size_array<T>::type
+allocate_shared_noinit(const A& allocator)
+{
+    enum {
+        size = detail::sp_array_count<T>::value
+    };
+    typedef typename detail::sp_array_element<T>::type type;
+    typedef typename detail::sp_array_scalar<T>::type scalar;
+    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
+    typedef detail::sp_size_array_state<other, size> state;
+    typedef detail::sp_array_base<state, false> base;
+    detail::sp_array_result<other, base> result(allocator, size);
+    detail::sp_counted_base* node = result.get();
+    scalar* start = detail::sp_array_start<base, scalar>(node);
+    ::new(static_cast<void*>(node)) base(detail::sp_default(), allocator,
+        size, start);
+    result.release();
+    return shared_ptr<T>(detail::sp_internal_constructor_tag(),
+        reinterpret_cast<type*>(start), detail::shared_count(node));
+}
+
+} /* boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/smart_ptr/atomic_shared_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/atomic_shared_ptr.hpp
new file mode 100644
index 00000000000..d1efa8e2803
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/atomic_shared_ptr.hpp
@@ -0,0 +1,183 @@
+#ifndef BOOST_SMART_PTR_ATOMIC_SHARED_PTR_HPP_INCLUDED
+#define BOOST_SMART_PTR_ATOMIC_SHARED_PTR_HPP_INCLUDED
+
+//
+//  atomic_shared_ptr.hpp
+//
+//  Copyright 2017 Peter Dimov
+//
+//  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/smart_ptr/ for documentation.
+//
+
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/detail/spinlock.hpp>
+#include <cstring>
+
+namespace boost
+{
+
+template<class T> class atomic_shared_ptr
+{
+private:
+
+    boost::shared_ptr<T> p_;
+
+    mutable boost::detail::spinlock l_;
+
+    atomic_shared_ptr(const atomic_shared_ptr&);
+    atomic_shared_ptr& operator=(const atomic_shared_ptr&);
+
+private:
+
+    bool compare_exchange( shared_ptr<T>& v, shared_ptr<T> w ) BOOST_SP_NOEXCEPT
+    {
+        l_.lock();
+
+        if( p_._internal_equiv( v ) )
+        {
+            p_.swap( w );
+
+            l_.unlock();
+            return true;
+        }
+        else
+        {
+            shared_ptr<T> tmp( p_ );
+
+            l_.unlock();
+
+            tmp.swap( v );
+            return false;
+        }
+    }
+
+public:
+
+#if !defined( BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX ) && !defined( BOOST_NO_CXX11_CONSTEXPR )
+
+    constexpr atomic_shared_ptr() BOOST_SP_NOEXCEPT: l_ BOOST_DETAIL_SPINLOCK_INIT
+    {
+    }
+
+#else
+
+    atomic_shared_ptr() BOOST_SP_NOEXCEPT
+    {
+        boost::detail::spinlock init = BOOST_DETAIL_SPINLOCK_INIT;
+        std::memcpy( &l_, &init, sizeof( init ) );
+    }
+
+#endif
+
+    atomic_shared_ptr( shared_ptr<T> p ) BOOST_SP_NOEXCEPT
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+        : p_( std::move( p ) )
+#else
+        : p_( p )
+#endif
+    {
+        boost::detail::spinlock init = BOOST_DETAIL_SPINLOCK_INIT;
+        std::memcpy( &l_, &init, sizeof( init ) );
+    }
+
+    atomic_shared_ptr& operator=( shared_ptr<T> r ) BOOST_SP_NOEXCEPT
+    {
+        boost::detail::spinlock::scoped_lock lock( l_ );
+        p_.swap( r );
+
+        return *this;
+    }
+
+    BOOST_CONSTEXPR bool is_lock_free() const BOOST_SP_NOEXCEPT
+    {
+        return false;
+    }
+
+    shared_ptr<T> load( int = 0 ) const BOOST_SP_NOEXCEPT
+    {
+        boost::detail::spinlock::scoped_lock lock( l_ );
+        return p_;
+    }
+
+    operator shared_ptr<T>() const BOOST_SP_NOEXCEPT
+    {
+        boost::detail::spinlock::scoped_lock lock( l_ );
+        return p_;
+    }
+
+    void store( shared_ptr<T> r, int = 0 ) BOOST_SP_NOEXCEPT
+    {
+        boost::detail::spinlock::scoped_lock lock( l_ );
+        p_.swap( r );
+    }
+
+    shared_ptr<T> exchange( shared_ptr<T> r, int = 0 ) BOOST_SP_NOEXCEPT
+    {
+        {
+            boost::detail::spinlock::scoped_lock lock( l_ );
+            p_.swap( r );
+        }
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+        return std::move( r );
+
+#else
+
+        return r;
+
+#endif
+    }
+
+    bool compare_exchange_weak( shared_ptr<T>& v, const shared_ptr<T>& w, int, int ) BOOST_SP_NOEXCEPT
+    {
+        return compare_exchange( v, w );
+    }
+
+    bool compare_exchange_weak( shared_ptr<T>& v, const shared_ptr<T>& w, int = 0 ) BOOST_SP_NOEXCEPT
+    {
+        return compare_exchange( v, w );
+    }
+
+    bool compare_exchange_strong( shared_ptr<T>& v, const shared_ptr<T>& w, int, int ) BOOST_SP_NOEXCEPT
+    {
+        return compare_exchange( v, w );
+    }
+
+    bool compare_exchange_strong( shared_ptr<T>& v, const shared_ptr<T>& w, int = 0 ) BOOST_SP_NOEXCEPT
+    {
+        return compare_exchange( v, w );
+    }
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    bool compare_exchange_weak( shared_ptr<T>& v, shared_ptr<T>&& w, int, int ) BOOST_SP_NOEXCEPT
+    {
+        return compare_exchange( v, std::move( w ) );
+    }
+
+    bool compare_exchange_weak( shared_ptr<T>& v, shared_ptr<T>&& w, int = 0 ) BOOST_SP_NOEXCEPT
+    {
+        return compare_exchange( v, std::move( w ) );
+    }
+
+    bool compare_exchange_strong( shared_ptr<T>& v, shared_ptr<T>&& w, int, int ) BOOST_SP_NOEXCEPT
+    {
+        return compare_exchange( v, std::move( w ) );
+    }
+
+    bool compare_exchange_strong( shared_ptr<T>& v, shared_ptr<T>&& w, int = 0 ) BOOST_SP_NOEXCEPT
+    {
+        return compare_exchange( v, std::move( w ) );
+    }
+
+#endif
+};
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_SMART_PTR_ATOMIC_SHARED_PTR_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/bad_weak_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/bad_weak_ptr.hpp
similarity index 83%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/bad_weak_ptr.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/bad_weak_ptr.hpp
index 3e0a1b72867..b086be595f4 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/bad_weak_ptr.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/bad_weak_ptr.hpp
@@ -17,6 +17,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 
+#include <boost/config.hpp>
 #include <exception>
 
 #ifdef __BORLANDC__
@@ -36,6 +37,12 @@ namespace boost
 # pragma option push -pc
 #endif
 
+#if defined(BOOST_CLANG)
+// Intel C++ on Mac defines __clang__ but doesn't support the pragma
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
 class bad_weak_ptr: public std::exception
 {
 public:
@@ -46,6 +53,10 @@ public:
     }
 };
 
+#if defined(BOOST_CLANG)
+# pragma clang diagnostic pop
+#endif
+
 #if defined(__BORLANDC__) && __BORLANDC__ <= 0x564
 # pragma option pop
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count.hpp
similarity index 96%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count.hpp
index 8aefd44fdc1..6e4f71aa8e8 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count.hpp
@@ -73,6 +73,9 @@
 #elif defined( BOOST_DISABLE_THREADS ) && !defined( BOOST_SP_ENABLE_THREADS ) && !defined( BOOST_DISABLE_WIN32 )
 # include <boost/smart_ptr/detail/atomic_count_nt.hpp>
 
+#elif !defined( BOOST_NO_CXX11_HDR_ATOMIC )
+# include <boost/smart_ptr/detail/atomic_count_std_atomic.hpp>
+
 #elif defined( __GNUC__ ) && ( defined( __i386__ ) || defined( __x86_64__ ) ) && !defined( __PATHSCALE__ )
 # include <boost/smart_ptr/detail/atomic_count_gcc_x86.hpp>
 
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count_gcc.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count_gcc.hpp
similarity index 95%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count_gcc.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count_gcc.hpp
index 54807e944e2..df7e32365f4 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count_gcc.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count_gcc.hpp
@@ -9,7 +9,7 @@
 //  http://gcc.gnu.org/onlinedocs/porting/Thread-safety.html
 //
 //  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
-//  Copyright (c) 2002 Lars Gullik Bj�nnes <larsbj@lyx.org>
+//  Copyright (c) 2002 Lars Gullik Bjønnes <larsbj@lyx.org>
 //  Copyright 2003-2005 Peter Dimov
 //
 //  Distributed under the Boost Software License, Version 1.0. (See
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count_gcc_x86.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count_gcc_x86.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count_gcc_x86.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count_gcc_x86.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count_nt.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count_nt.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count_nt.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count_nt.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count_pt.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count_pt.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count_pt.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count_pt.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count_solaris.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count_solaris.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count_solaris.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count_solaris.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count_spin.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count_spin.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count_spin.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count_spin.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count_std_atomic.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count_std_atomic.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count_std_atomic.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count_std_atomic.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count_sync.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count_sync.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count_sync.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count_sync.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count_win32.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count_win32.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/atomic_count_win32.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/atomic_count_win32.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/lightweight_mutex.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/lightweight_mutex.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/lightweight_mutex.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/lightweight_mutex.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/local_counted_base.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/local_counted_base.hpp
new file mode 100644
index 00000000000..398b46dd1a0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/local_counted_base.hpp
@@ -0,0 +1,146 @@
+#ifndef BOOST_SMART_PTR_DETAIL_LOCAL_COUNTED_BASE_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_LOCAL_COUNTED_BASE_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  detail/local_counted_base.hpp
+//
+//  Copyright 2017 Peter Dimov
+//
+//  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/smart_ptr/ for documentation.
+
+#include <boost/smart_ptr/detail/shared_count.hpp>
+#include <boost/config.hpp>
+#include <utility>
+
+namespace boost
+{
+
+namespace detail
+{
+
+class local_counted_base
+{
+private:
+
+    local_counted_base & operator= ( local_counted_base const & );
+
+private:
+
+    // not 'int' or 'unsigned' to avoid aliasing and enable optimizations
+    enum count_type { min_ = 0, initial_ = 1, max_ = 2147483647 };
+
+    count_type local_use_count_;
+
+public:
+
+    BOOST_CONSTEXPR local_counted_base() BOOST_SP_NOEXCEPT: local_use_count_( initial_ )
+    {
+    }
+
+    BOOST_CONSTEXPR local_counted_base( local_counted_base const & ) BOOST_SP_NOEXCEPT: local_use_count_( initial_ )
+    {
+    }
+
+    virtual ~local_counted_base() /*BOOST_SP_NOEXCEPT*/
+    {
+    }
+
+    virtual void local_cb_destroy() BOOST_SP_NOEXCEPT = 0;
+
+    virtual boost::detail::shared_count local_cb_get_shared_count() const BOOST_SP_NOEXCEPT = 0;
+
+    void add_ref() BOOST_SP_NOEXCEPT
+    {
+#if defined( __has_builtin )
+# if __has_builtin( __builtin_assume )
+
+        __builtin_assume( local_use_count_ >= 1 );
+
+# endif
+#endif
+
+        local_use_count_ = static_cast<count_type>( local_use_count_ + 1 );
+    }
+
+    void release() BOOST_SP_NOEXCEPT
+    {
+        local_use_count_ = static_cast<count_type>( local_use_count_ - 1 );
+
+        if( local_use_count_ == 0 )
+        {
+            local_cb_destroy();
+        }
+    }
+
+    long local_use_count() const BOOST_SP_NOEXCEPT
+    {
+        return local_use_count_;
+    }
+};
+
+class local_counted_impl: public local_counted_base
+{
+private:
+
+    local_counted_impl( local_counted_impl const & );
+
+private:
+
+    shared_count pn_;
+
+public:
+
+    explicit local_counted_impl( shared_count const& pn ): pn_( pn )
+    {
+    }
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    explicit local_counted_impl( shared_count && pn ): pn_( std::move(pn) )
+    {
+    }
+
+#endif
+
+    virtual void local_cb_destroy() BOOST_SP_NOEXCEPT
+    {
+        delete this;
+    }
+
+    virtual boost::detail::shared_count local_cb_get_shared_count() const BOOST_SP_NOEXCEPT
+    {
+        return pn_;
+    }
+};
+
+class local_counted_impl_em: public local_counted_base
+{
+public:
+
+    shared_count pn_;
+
+    virtual void local_cb_destroy() BOOST_SP_NOEXCEPT
+    {
+        shared_count().swap( pn_ );
+    }
+
+    virtual boost::detail::shared_count local_cb_get_shared_count() const BOOST_SP_NOEXCEPT
+    {
+        return pn_;
+    }
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_SMART_PTR_DETAIL_LOCAL_COUNTED_BASE_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/local_sp_deleter.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/local_sp_deleter.hpp
new file mode 100644
index 00000000000..7d04f1dc527
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/local_sp_deleter.hpp
@@ -0,0 +1,91 @@
+#ifndef BOOST_SMART_PTR_DETAIL_LOCAL_SP_DELETER_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_LOCAL_SP_DELETER_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  detail/local_sp_deleter.hpp
+//
+//  Copyright 2017 Peter Dimov
+//
+//  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/smart_ptr/ for documentation.
+
+#include <boost/smart_ptr/detail/local_counted_base.hpp>
+#include <boost/config.hpp>
+
+namespace boost
+{
+
+namespace detail
+{
+
+template<class D> class local_sp_deleter: public local_counted_impl_em
+{
+private:
+
+    D d_;
+
+public:
+
+    local_sp_deleter(): d_()
+    {
+    }
+
+    explicit local_sp_deleter( D const& d ) BOOST_SP_NOEXCEPT: d_( d )
+    {
+    }
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    explicit local_sp_deleter( D&& d ) BOOST_SP_NOEXCEPT: d_( std::move(d) )
+    {
+    }
+
+#endif
+
+    D& deleter()
+    {
+        return d_;
+    }
+
+    template<class Y> void operator()( Y* p ) BOOST_SP_NOEXCEPT
+    {
+        d_( p );
+    }
+
+#if !defined( BOOST_NO_CXX11_NULLPTR )
+
+    void operator()( boost::detail::sp_nullptr_t p ) BOOST_SP_NOEXCEPT
+    {
+        d_( p );
+    }
+
+#endif
+};
+
+template<> class local_sp_deleter<void>
+{
+};
+
+template<class D> D * get_local_deleter( local_sp_deleter<D> * p )
+{
+    return &p->deleter();
+}
+
+inline void * get_local_deleter( local_sp_deleter<void> * /*p*/ )
+{
+    return 0;
+}
+
+} // namespace detail
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_SMART_PTR_DETAIL_LOCAL_SP_DELETER_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/lwm_nop.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/lwm_nop.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/lwm_nop.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/lwm_nop.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/lwm_pthreads.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/lwm_pthreads.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/lwm_pthreads.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/lwm_pthreads.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/lwm_win32_cs.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/lwm_win32_cs.hpp
similarity index 73%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/lwm_win32_cs.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/lwm_win32_cs.hpp
index a93cf09208f..7d3e1561667 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/lwm_win32_cs.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/lwm_win32_cs.hpp
@@ -21,7 +21,13 @@
 #include <boost/predef.h>
 
 #ifdef BOOST_USE_WINDOWS_H
-#  include <windows.h>
+
+#include <windows.h>
+
+#else
+
+struct _RTL_CRITICAL_SECTION;
+
 #endif
 
 namespace boost
@@ -47,13 +53,13 @@ struct critical_section
 };
 
 #if BOOST_PLAT_WINDOWS_RUNTIME
-extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSectionEx(critical_section *, unsigned long, unsigned long);
+extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSectionEx(::_RTL_CRITICAL_SECTION *, unsigned long, unsigned long);
 #else
-extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(critical_section *);
+extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(::_RTL_CRITICAL_SECTION *);
 #endif
-extern "C" __declspec(dllimport) void __stdcall EnterCriticalSection(critical_section *);
-extern "C" __declspec(dllimport) void __stdcall LeaveCriticalSection(critical_section *);
-extern "C" __declspec(dllimport) void __stdcall DeleteCriticalSection(critical_section *);
+extern "C" __declspec(dllimport) void __stdcall EnterCriticalSection(::_RTL_CRITICAL_SECTION *);
+extern "C" __declspec(dllimport) void __stdcall LeaveCriticalSection(::_RTL_CRITICAL_SECTION *);
+extern "C" __declspec(dllimport) void __stdcall DeleteCriticalSection(::_RTL_CRITICAL_SECTION *);
 
 #else
 
@@ -75,15 +81,15 @@ public:
     lightweight_mutex()
     {
 #if BOOST_PLAT_WINDOWS_RUNTIME
-        InitializeCriticalSectionEx(&cs_, 4000, 0);
+        boost::detail::InitializeCriticalSectionEx(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&cs_), 4000, 0);
 #else
-        InitializeCriticalSection(&cs_);
+        boost::detail::InitializeCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&cs_));
 #endif
     }
 
     ~lightweight_mutex()
     {
-        DeleteCriticalSection(&cs_);
+        boost::detail::DeleteCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&cs_));
     }
 
     class scoped_lock;
@@ -102,12 +108,12 @@ public:
 
         explicit scoped_lock(lightweight_mutex & m): m_(m)
         {
-            EnterCriticalSection(&m_.cs_);
+            boost::detail::EnterCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_.cs_));
         }
 
         ~scoped_lock()
         {
-            LeaveCriticalSection(&m_.cs_);
+            boost::detail::LeaveCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_.cs_));
         }
     };
 };
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/operator_bool.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/operator_bool.hpp
similarity index 81%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/operator_bool.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/operator_bool.hpp
index c0289b870bb..f9c5ef68036 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/operator_bool.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/operator_bool.hpp
@@ -9,14 +9,14 @@
 #if !defined( BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS ) && !defined( BOOST_NO_CXX11_NULLPTR )\
     && !(defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5130))
 
-    explicit operator bool () const BOOST_NOEXCEPT
+    explicit operator bool () const BOOST_SP_NOEXCEPT
     {
         return px != 0;
     }
 
 #elif ( defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, < 0x570) ) || defined(__CINT__)
 
-    operator bool () const BOOST_NOEXCEPT
+    operator bool () const BOOST_SP_NOEXCEPT
     {
         return px != 0;
     }
@@ -29,7 +29,7 @@
 
     typedef void (*unspecified_bool_type)( this_type*** );
 
-    operator unspecified_bool_type() const BOOST_NOEXCEPT
+    operator unspecified_bool_type() const BOOST_SP_NOEXCEPT
     {
         return px == 0? 0: unspecified_bool;
     }
@@ -41,7 +41,7 @@
 
     typedef element_type * (this_type::*unspecified_bool_type)() const;
 
-    operator unspecified_bool_type() const BOOST_NOEXCEPT
+    operator unspecified_bool_type() const BOOST_SP_NOEXCEPT
     {
         return px == 0? 0: &this_type::get;
     }
@@ -50,7 +50,7 @@
 
     typedef element_type * this_type::*unspecified_bool_type;
 
-    operator unspecified_bool_type() const BOOST_NOEXCEPT
+    operator unspecified_bool_type() const BOOST_SP_NOEXCEPT
     {
         return px == 0? 0: &this_type::px;
     }
@@ -58,7 +58,7 @@
 #endif
 
     // operator! is redundant, but some compilers need it
-    bool operator! () const BOOST_NOEXCEPT
+    bool operator! () const BOOST_SP_NOEXCEPT
     {
         return px == 0;
     }
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/quick_allocator.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/quick_allocator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/quick_allocator.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/quick_allocator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/shared_count.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/shared_count.hpp
similarity index 90%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/shared_count.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/shared_count.hpp
index 7996aa43254..ae7d0fb46f0 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/shared_count.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/shared_count.hpp
@@ -54,7 +54,7 @@ namespace boost
 namespace movelib
 {
 
-    template< class T, class D > class unique_ptr;
+template< class T, class D > class unique_ptr;
 
 } // namespace movelib
 
@@ -118,7 +118,14 @@ private:
 
 public:
 
-    shared_count(): pi_(0) // nothrow
+    BOOST_CONSTEXPR shared_count(): pi_(0) // nothrow
+#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
+        , id_(shared_count_id)
+#endif
+    {
+    }
+
+    BOOST_CONSTEXPR explicit shared_count( sp_counted_base * pi ): pi_( pi ) // nothrow
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(shared_count_id)
 #endif
@@ -249,18 +256,8 @@ public:
 
         try
         {
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-            impl_type * pi = std::allocator_traits<A2>::allocate( a2, 1 );
-            pi_ = pi;
-            std::allocator_traits<A2>::construct( a2, pi, p, d, a );
-
-#else
-
-            pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
+            pi_ = a2.allocate( 1 );
             ::new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
-
-#endif
         }
         catch(...)
         {
@@ -276,28 +273,11 @@ public:
 
 #else
 
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-        impl_type * pi = std::allocator_traits<A2>::allocate( a2, 1 );
-        pi_ = pi;
-
-#else
-
-        pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
-
-#endif
+        pi_ = a2.allocate( 1 );
 
         if( pi_ != 0 )
         {
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-            std::allocator_traits<A2>::construct( a2, pi, p, d, a );
-
-#else
-
             ::new( static_cast< void* >( pi_ ) ) impl_type( p, d, a );
-
-#endif
         }
         else
         {
@@ -333,18 +313,8 @@ public:
 
         try
         {
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-            impl_type * pi = std::allocator_traits<A2>::allocate( a2, 1 );
-            pi_ = pi;
-            std::allocator_traits<A2>::construct( a2, pi, p, a );
-
-#else
-
-            pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
+            pi_ = a2.allocate( 1 );
             ::new( static_cast< void* >( pi_ ) ) impl_type( p, a );
-
-#endif
         }
         catch(...)
         {
@@ -360,28 +330,11 @@ public:
 
 #else
 
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-        impl_type * pi = std::allocator_traits<A2>::allocate( a2, 1 );
-        pi_ = pi;
-
-#else
-
-        pi_ = a2.allocate( 1, static_cast< impl_type* >( 0 ) );
-
-#endif
+        pi_ = a2.allocate( 1 );
 
         if( pi_ != 0 )
         {
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-            std::allocator_traits<A2>::construct( a2, pi, p, a );
-
-#else
-
             ::new( static_cast< void* >( pi_ ) ) impl_type( p, a );
-
-#endif
         }
         else
         {
@@ -550,6 +503,11 @@ public:
         return pi_? pi_->get_deleter( ti ): 0;
     }
 
+    void * get_local_deleter( sp_typeinfo const & ti ) const
+    {
+        return pi_? pi_->get_local_deleter( ti ): 0;
+    }
+
     void * get_untyped_deleter() const
     {
         return pi_? pi_->get_untyped_deleter(): 0;
@@ -571,7 +529,7 @@ private:
 
 public:
 
-    weak_count(): pi_(0) // nothrow
+    BOOST_CONSTEXPR weak_count(): pi_(0) // nothrow
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         , id_(weak_count_id)
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_convertible.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_convertible.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_convertible.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_convertible.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base.hpp
similarity index 92%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base.hpp
index 0addf077d18..438613765b4 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base.hpp
@@ -20,7 +20,7 @@
 #include <boost/config.hpp>
 #include <boost/smart_ptr/detail/sp_has_sync.hpp>
 
-#if defined( __clang__ ) && defined( __has_extension )
+#if !defined( __c2__ ) && defined( __clang__ ) && defined( __has_extension )
 # if __has_extension( __c_atomic__ )
 #   define BOOST_SP_HAS_CLANG_C11_ATOMICS
 # endif
@@ -44,6 +44,9 @@
 #elif defined( BOOST_SP_HAS_CLANG_C11_ATOMICS )
 # include <boost/smart_ptr/detail/sp_counted_base_clang.hpp>
 
+#elif !defined( BOOST_NO_CXX11_HDR_ATOMIC )
+# include <boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp>
+
 #elif defined( __SNC__ )
 # include <boost/smart_ptr/detail/sp_counted_base_snc_ps3.hpp>
 
@@ -65,7 +68,7 @@
 #elif defined( __GNUC__ ) && ( defined( __powerpc__ ) || defined( __ppc__ ) || defined( __ppc ) ) && !defined(__PATHSCALE__) && !defined( _AIX )
 # include <boost/smart_ptr/detail/sp_counted_base_gcc_ppc.hpp>
 
-#elif defined( __GNUC__ ) && ( defined( __mips__ ) || defined( _mips ) ) && !defined(__PATHSCALE__)
+#elif defined( __GNUC__ ) && ( defined( __mips__ ) || defined( _mips ) ) && !defined(__PATHSCALE__) && !defined( __mips16 )
 # include <boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp>
 
 #elif defined( BOOST_SP_HAS_SYNC )
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_acc_ia64.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_acc_ia64.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_acc_ia64.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_acc_ia64.hpp
index cebc243d2e0..ec6f6ee1840 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_acc_ia64.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_acc_ia64.hpp
@@ -104,6 +104,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
     virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_aix.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_aix.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_aix.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_aix.hpp
index fe6c727e38f..ce8ee686ba0 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_aix.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_aix.hpp
@@ -96,6 +96,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
     virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_clang.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_clang.hpp
similarity index 92%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_clang.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_clang.hpp
index c66b985465a..8b3bfad9b6e 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_clang.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_clang.hpp
@@ -58,6 +58,11 @@ inline boost::int_least32_t atomic_conditional_increment( atomic_int_least32_t *
     }    
 }
 
+#if defined(__clang__)
+# pragma clang diagnostic push
+# pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+
 class sp_counted_base
 {
 private:
@@ -93,6 +98,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
     virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
@@ -133,6 +139,10 @@ public:
     }
 };
 
+#if defined(__clang__)
+# pragma clang diagnostic pop
+#endif
+
 } // namespace detail
 
 } // namespace boost
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_cw_ppc.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_cw_ppc.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_cw_ppc.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_cw_ppc.hpp
index 6c268e89211..065f7c3d149 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_cw_ppc.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_cw_ppc.hpp
@@ -124,6 +124,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
     virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_cw_x86.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_cw_x86.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_cw_x86.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_cw_x86.hpp
index 81eba6f1786..3a3d4d4119e 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_cw_x86.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_cw_x86.hpp
@@ -112,6 +112,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
     virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_gcc_ia64.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_gcc_ia64.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_gcc_ia64.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_gcc_ia64.hpp
index f6e39041571..6c3cce8d44a 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_gcc_ia64.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_gcc_ia64.hpp
@@ -111,6 +111,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
     virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp
index 545c8ae4fc1..76ac2a612d3 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_gcc_mips.hpp
@@ -135,6 +135,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
     virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_gcc_ppc.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_gcc_ppc.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_gcc_ppc.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_gcc_ppc.hpp
index 2e5bc0e8534..0fb807488ae 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_gcc_ppc.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_gcc_ppc.hpp
@@ -135,6 +135,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
     virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_gcc_sparc.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_gcc_sparc.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_gcc_sparc.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_gcc_sparc.hpp
index c6d20ce7ea1..b8bb707f1b9 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_gcc_sparc.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_gcc_sparc.hpp
@@ -120,6 +120,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
     virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp
index 173dce5c819..3d2dd61ed67 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_gcc_x86.hpp
@@ -127,6 +127,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
     virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_nt.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_nt.hpp
similarity index 96%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_nt.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_nt.hpp
index 5c901f9d16a..dea905c905f 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_nt.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_nt.hpp
@@ -59,6 +59,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
     virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_pt.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_pt.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_pt.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_pt.hpp
index a16d2d8652f..85f2563d5d5 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_pt.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_pt.hpp
@@ -71,6 +71,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
     virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_snc_ps3.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_snc_ps3.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_snc_ps3.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_snc_ps3.hpp
index 56ed79fa97f..7b5f9178a6b 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_snc_ps3.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_snc_ps3.hpp
@@ -115,6 +115,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
     virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_solaris.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_solaris.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_solaris.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_solaris.hpp
index 0e05fef4cb9..0db9c6cbd56 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_solaris.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_solaris.hpp
@@ -62,6 +62,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
     virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_spin.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_spin.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_spin.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_spin.hpp
index 77734e727de..faf503ad572 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_spin.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_spin.hpp
@@ -84,6 +84,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
     virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp
index cab84535919..7a188f8a664 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_std_atomic.hpp
@@ -90,6 +90,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
     virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_sync.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_sync.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_sync.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_sync.hpp
index fafed0e72eb..d2138e7c261 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_sync.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_sync.hpp
@@ -109,6 +109,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
     virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_vacpp_ppc.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_vacpp_ppc.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_vacpp_ppc.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_vacpp_ppc.hpp
index 162f309b566..f2de3b02d8e 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_vacpp_ppc.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_vacpp_ppc.hpp
@@ -104,6 +104,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
     virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_w32.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_w32.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_w32.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_w32.hpp
index 4ba509c6cd7..960e42e1282 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_base_w32.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_base_w32.hpp
@@ -67,6 +67,7 @@ public:
     }
 
     virtual void * get_deleter( sp_typeinfo const & ti ) = 0;
+    virtual void * get_local_deleter( sp_typeinfo const & ti ) = 0;
     virtual void * get_untyped_deleter() = 0;
 
     void add_ref_copy()
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_impl.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_impl.hpp
similarity index 89%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_impl.hpp
index 1222f3c9f4e..fa2f75eb1aa 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_counted_impl.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_counted_impl.hpp
@@ -26,6 +26,7 @@
 
 #include <boost/checked_delete.hpp>
 #include <boost/smart_ptr/detail/sp_counted_base.hpp>
+#include <boost/core/addressof.hpp>
 
 #if defined(BOOST_SP_USE_QUICK_ALLOCATOR)
 #include <boost/smart_ptr/detail/quick_allocator.hpp>
@@ -50,6 +51,19 @@ void sp_scalar_destructor_hook( void * px, std::size_t size, void * pn );
 namespace detail
 {
 
+// get_local_deleter
+
+template<class D> class local_sp_deleter;
+
+template<class D> D * get_local_deleter( D * /*p*/ )
+{
+    return 0;
+}
+
+template<class D> D * get_local_deleter( local_sp_deleter<D> * p );
+
+//
+
 template<class X> class sp_counted_impl_p: public sp_counted_base
 {
 private:
@@ -83,6 +97,11 @@ public:
         return 0;
     }
 
+    virtual void * get_local_deleter( sp_typeinfo const & )
+    {
+        return 0;
+    }
+
     virtual void * get_untyped_deleter()
     {
         return 0;
@@ -158,6 +177,11 @@ public:
         return ti == BOOST_SP_TYPEID(D)? &reinterpret_cast<char&>( del ): 0;
     }
 
+    virtual void * get_local_deleter( sp_typeinfo const & ti )
+    {
+        return ti == BOOST_SP_TYPEID(D)? boost::detail::get_local_deleter( boost::addressof( del ) ): 0;
+    }
+
     virtual void * get_untyped_deleter()
     {
         return &reinterpret_cast<char&>( del );
@@ -236,16 +260,8 @@ public:
 
         A2 a2( a_ );
 
-#if !defined( BOOST_NO_CXX11_ALLOCATOR )
-
-        std::allocator_traits<A2>::destroy( a2, this );
-
-#else
-
         this->~this_type();
 
-#endif
-
         a2.deallocate( this, 1 );
     }
 
@@ -254,6 +270,11 @@ public:
         return ti == BOOST_SP_TYPEID( D )? &reinterpret_cast<char&>( d_ ): 0;
     }
 
+    virtual void * get_local_deleter( sp_typeinfo const & ti )
+    {
+        return ti == BOOST_SP_TYPEID(D)? boost::detail::get_local_deleter( boost::addressof( d_ ) ): 0;
+    }
+
     virtual void * get_untyped_deleter()
     {
         return &reinterpret_cast<char&>( d_ );
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_disable_deprecated.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_disable_deprecated.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_disable_deprecated.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_disable_deprecated.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_forward.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_forward.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_forward.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_forward.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_has_sync.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_has_sync.hpp
similarity index 84%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_has_sync.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_has_sync.hpp
index 16de21d379a..e1debf0cc9b 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_has_sync.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_has_sync.hpp
@@ -22,15 +22,15 @@
 
 #ifndef BOOST_SP_NO_SYNC
 
-#if defined( __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 )
+#if !defined( __c2__ ) && defined( __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 )
 
 # define BOOST_SP_HAS_SYNC
 
-#elif defined( __IBMCPP__ ) && ( __IBMCPP__ >= 1210 )
+#elif defined( __IBMCPP__ ) && ( __IBMCPP__ >= 1210 ) && !defined( __COMPILER_VER__ )
 
 # define BOOST_SP_HAS_SYNC
 
-#elif defined( __GNUC__ ) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 )
+#elif !defined( __c2__ ) && defined( __GNUC__ ) && ( __GNUC__ * 100 + __GNUC_MINOR__ >= 401 )
 
 #define BOOST_SP_HAS_SYNC
 
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_interlocked.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_interlocked.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_interlocked.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_interlocked.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_noexcept.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_noexcept.hpp
new file mode 100644
index 00000000000..1287ba49525
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_noexcept.hpp
@@ -0,0 +1,48 @@
+#ifndef BOOST_SMART_PTR_DETAIL_SP_NOEXCEPT_HPP_INCLUDED
+#define BOOST_SMART_PTR_DETAIL_SP_NOEXCEPT_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  detail/sp_noexcept.hpp
+//
+//  Copyright 2016, 2017 Peter Dimov
+//
+//  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
+
+#include <boost/config.hpp>
+
+// BOOST_SP_NOEXCEPT
+
+#if defined( BOOST_MSVC ) && BOOST_MSVC >= 1700 && BOOST_MSVC < 1900
+
+#  define BOOST_SP_NOEXCEPT BOOST_NOEXCEPT_OR_NOTHROW
+
+#else
+
+#  define BOOST_SP_NOEXCEPT BOOST_NOEXCEPT
+
+#endif
+
+// BOOST_SP_NOEXCEPT_WITH_ASSERT
+
+#if defined(BOOST_DISABLE_ASSERTS) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && defined(NDEBUG) )
+
+#  define BOOST_SP_NOEXCEPT_WITH_ASSERT BOOST_SP_NOEXCEPT
+
+#elif defined(BOOST_ENABLE_ASSERT_HANDLER) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && !defined(NDEBUG) )
+
+#  define BOOST_SP_NOEXCEPT_WITH_ASSERT
+
+#else
+
+#  define BOOST_SP_NOEXCEPT_WITH_ASSERT BOOST_SP_NOEXCEPT
+
+#endif
+
+#endif  // #ifndef BOOST_SMART_PTR_DETAIL_SP_NOEXCEPT_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_nullptr_t.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_nullptr_t.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/sp_nullptr_t.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/sp_nullptr_t.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/spinlock.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/spinlock.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/spinlock.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/spinlock.hpp
index 19f93d7c6b4..0b618dfc155 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/spinlock.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/spinlock.hpp
@@ -43,6 +43,9 @@
 #elif defined( BOOST_SP_USE_PTHREADS )
 #  include <boost/smart_ptr/detail/spinlock_pt.hpp>
 
+#elif !defined( BOOST_NO_CXX11_HDR_ATOMIC )
+#  include <boost/smart_ptr/detail/spinlock_std_atomic.hpp>
+
 #elif defined(__GNUC__) && defined( __arm__ ) && !defined( __thumb__ )
 #  include <boost/smart_ptr/detail/spinlock_gcc_arm.hpp>
 
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/spinlock_gcc_arm.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/spinlock_gcc_arm.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/spinlock_gcc_arm.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/spinlock_gcc_arm.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/spinlock_nt.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/spinlock_nt.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/spinlock_nt.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/spinlock_nt.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/spinlock_pool.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/spinlock_pool.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/spinlock_pool.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/spinlock_pool.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/spinlock_pt.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/spinlock_pt.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/spinlock_pt.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/spinlock_pt.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/spinlock_std_atomic.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/spinlock_std_atomic.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/spinlock_std_atomic.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/spinlock_std_atomic.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/spinlock_sync.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/spinlock_sync.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/spinlock_sync.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/spinlock_sync.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/spinlock_w32.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/spinlock_w32.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/spinlock_w32.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/spinlock_w32.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/yield_k.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/yield_k.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/yield_k.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/yield_k.hpp
index 44d18364789..f8ca6b64676 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/detail/yield_k.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/detail/yield_k.hpp
@@ -33,7 +33,7 @@
 
 // BOOST_SMT_PAUSE
 
-#if defined(_MSC_VER) && _MSC_VER >= 1310 && ( defined(_M_IX86) || defined(_M_X64) )
+#if defined(_MSC_VER) && _MSC_VER >= 1310 && ( defined(_M_IX86) || defined(_M_X64) ) && !defined(__c2__)
 
 extern "C" void _mm_pause();
 
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/enable_shared_from_raw.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/enable_shared_from_raw.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/enable_shared_from_raw.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/enable_shared_from_raw.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/enable_shared_from_this.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/enable_shared_from_this.hpp
similarity index 73%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/enable_shared_from_this.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/enable_shared_from_this.hpp
index 4e3f243d289..fc4de0b5712 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/enable_shared_from_this.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/enable_shared_from_this.hpp
@@ -10,11 +10,12 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 //
-//  http://www.boost.org/libs/smart_ptr/enable_shared_from_this.html
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 #include <boost/smart_ptr/weak_ptr.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
 
@@ -25,20 +26,20 @@ template<class T> class enable_shared_from_this
 {
 protected:
 
-    enable_shared_from_this() BOOST_NOEXCEPT
+    BOOST_CONSTEXPR enable_shared_from_this() BOOST_SP_NOEXCEPT
     {
     }
 
-    enable_shared_from_this(enable_shared_from_this const &) BOOST_NOEXCEPT
+    BOOST_CONSTEXPR enable_shared_from_this(enable_shared_from_this const &) BOOST_SP_NOEXCEPT
     {
     }
 
-    enable_shared_from_this & operator=(enable_shared_from_this const &) BOOST_NOEXCEPT
+    enable_shared_from_this & operator=(enable_shared_from_this const &) BOOST_SP_NOEXCEPT
     {
         return *this;
     }
 
-    ~enable_shared_from_this() BOOST_NOEXCEPT // ~weak_ptr<T> newer throws, so this call also must not throw
+    ~enable_shared_from_this() BOOST_SP_NOEXCEPT // ~weak_ptr<T> newer throws, so this call also must not throw
     {
     }
 
@@ -58,12 +59,12 @@ public:
         return p;
     }
 
-    weak_ptr<T> weak_from_this() BOOST_NOEXCEPT
+    weak_ptr<T> weak_from_this() BOOST_SP_NOEXCEPT
     {
         return weak_this_;
     }
 
-    weak_ptr<T const> weak_from_this() const BOOST_NOEXCEPT
+    weak_ptr<T const> weak_from_this() const BOOST_SP_NOEXCEPT
     {
         return weak_this_;
     }
@@ -71,7 +72,7 @@ public:
 public: // actually private, but avoids compiler template friendship issues
 
     // Note: invoked automatically by shared_ptr; do not call
-    template<class X, class Y> void _internal_accept_owner( shared_ptr<X> const * ppx, Y * py ) const
+    template<class X, class Y> void _internal_accept_owner( shared_ptr<X> const * ppx, Y * py ) const BOOST_SP_NOEXCEPT
     {
         if( weak_this_.expired() )
         {
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/intrusive_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/intrusive_ptr.hpp
similarity index 81%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/intrusive_ptr.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/intrusive_ptr.hpp
index 1e9339732b4..0ab075d367b 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/intrusive_ptr.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/intrusive_ptr.hpp
@@ -6,11 +6,11 @@
 //
 //  Copyright (c) 2001, 2002 Peter Dimov
 //
-// 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)
+//  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/smart_ptr/intrusive_ptr.html for documentation.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 #include <boost/config.hpp>
@@ -19,6 +19,7 @@
 #include <boost/detail/workaround.hpp>
 #include <boost/smart_ptr/detail/sp_convertible.hpp>
 #include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 
 #include <boost/config/no_tr1/functional.hpp>           // for std::less
 
@@ -59,7 +60,7 @@ public:
 
     typedef T element_type;
 
-    BOOST_CONSTEXPR intrusive_ptr() BOOST_NOEXCEPT : px( 0 )
+    BOOST_CONSTEXPR intrusive_ptr() BOOST_SP_NOEXCEPT : px( 0 )
     {
     }
 
@@ -111,12 +112,12 @@ public:
 
 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 
-    intrusive_ptr(intrusive_ptr && rhs) BOOST_NOEXCEPT : px( rhs.px )
+    intrusive_ptr(intrusive_ptr && rhs) BOOST_SP_NOEXCEPT : px( rhs.px )
     {
         rhs.px = 0;
     }
 
-    intrusive_ptr & operator=(intrusive_ptr && rhs) BOOST_NOEXCEPT
+    intrusive_ptr & operator=(intrusive_ptr && rhs) BOOST_SP_NOEXCEPT
     {
         this_type( static_cast< intrusive_ptr && >( rhs ) ).swap(*this);
         return *this;
@@ -140,7 +141,7 @@ public:
     }
 
     template<class U>
-    intrusive_ptr & operator=(intrusive_ptr<U> && rhs) BOOST_NOEXCEPT
+    intrusive_ptr & operator=(intrusive_ptr<U> && rhs) BOOST_SP_NOEXCEPT
     {
         this_type( static_cast< intrusive_ptr<U> && >( rhs ) ).swap(*this);
         return *this;
@@ -160,7 +161,7 @@ public:
         return *this;
     }
 
-    void reset() BOOST_NOEXCEPT
+    void reset()
     {
         this_type().swap( *this );
     }
@@ -175,25 +176,25 @@ public:
         this_type( rhs, add_ref ).swap( *this );
     }
 
-    T * get() const BOOST_NOEXCEPT
+    T * get() const BOOST_SP_NOEXCEPT
     {
         return px;
     }
 
-    T * detach() BOOST_NOEXCEPT
+    T * detach() BOOST_SP_NOEXCEPT
     {
         T * ret = px;
         px = 0;
         return ret;
     }
 
-    T & operator*() const
+    T & operator*() const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         return *px;
     }
 
-    T * operator->() const
+    T * operator->() const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         return px;
@@ -202,7 +203,7 @@ public:
 // implicit conversion to "bool"
 #include <boost/smart_ptr/detail/operator_bool.hpp>
 
-    void swap(intrusive_ptr & rhs) BOOST_NOEXCEPT
+    void swap(intrusive_ptr & rhs) BOOST_SP_NOEXCEPT
     {
         T * tmp = px;
         px = rhs.px;
@@ -214,32 +215,32 @@ private:
     T * px;
 };
 
-template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b)
+template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
 {
     return a.get() == b.get();
 }
 
-template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b)
+template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
 {
     return a.get() != b.get();
 }
 
-template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, U * b)
+template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, U * b) BOOST_SP_NOEXCEPT
 {
     return a.get() == b;
 }
 
-template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, U * b)
+template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, U * b) BOOST_SP_NOEXCEPT
 {
     return a.get() != b;
 }
 
-template<class T, class U> inline bool operator==(T * a, intrusive_ptr<U> const & b)
+template<class T, class U> inline bool operator==(T * a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
 {
     return a == b.get();
 }
 
-template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> const & b)
+template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> const & b) BOOST_SP_NOEXCEPT
 {
     return a != b.get();
 }
@@ -248,7 +249,7 @@ template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> const
 
 // Resolve the ambiguity between our op!= and the one in rel_ops
 
-template<class T> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)
+template<class T> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b) BOOST_SP_NOEXCEPT
 {
     return a.get() != b.get();
 }
@@ -257,41 +258,41 @@ template<class T> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_p
 
 #if !defined( BOOST_NO_CXX11_NULLPTR )
 
-template<class T> inline bool operator==( intrusive_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
+template<class T> inline bool operator==( intrusive_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, intrusive_ptr<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator==( boost::detail::sp_nullptr_t, intrusive_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( intrusive_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( intrusive_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, intrusive_ptr<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, intrusive_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return p.get() != 0;
 }
 
 #endif
 
-template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b)
+template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b) BOOST_SP_NOEXCEPT
 {
     return std::less<T *>()(a.get(), b.get());
 }
 
-template<class T> void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs)
+template<class T> void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs) BOOST_SP_NOEXCEPT
 {
     lhs.swap(rhs);
 }
 
 // mem_fn support
 
-template<class T> T * get_pointer(intrusive_ptr<T> const & p)
+template<class T> T * get_pointer(intrusive_ptr<T> const & p) BOOST_SP_NOEXCEPT
 {
     return p.get();
 }
@@ -350,7 +351,7 @@ template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::
 
 template< class T > struct hash;
 
-template< class T > std::size_t hash_value( boost::intrusive_ptr<T> const & p )
+template< class T > std::size_t hash_value( boost::intrusive_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return boost::hash< T* >()( p.get() );
 }
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/intrusive_ref_counter.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/intrusive_ref_counter.hpp
similarity index 87%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/intrusive_ref_counter.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/intrusive_ref_counter.hpp
index b7587ea7a0a..c2f918d0a49 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/intrusive_ref_counter.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/intrusive_ref_counter.hpp
@@ -17,6 +17,7 @@
 
 #include <boost/config.hpp>
 #include <boost/smart_ptr/detail/atomic_count.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 
 #ifdef BOOST_HAS_PRAGMA_ONCE
 #pragma once
@@ -45,17 +46,17 @@ struct thread_unsafe_counter
 {
     typedef unsigned int type;
 
-    static unsigned int load(unsigned int const& counter) BOOST_NOEXCEPT
+    static unsigned int load(unsigned int const& counter) BOOST_SP_NOEXCEPT
     {
         return counter;
     }
 
-    static void increment(unsigned int& counter) BOOST_NOEXCEPT
+    static void increment(unsigned int& counter) BOOST_SP_NOEXCEPT
     {
         ++counter;
     }
 
-    static unsigned int decrement(unsigned int& counter) BOOST_NOEXCEPT
+    static unsigned int decrement(unsigned int& counter) BOOST_SP_NOEXCEPT
     {
         return --counter;
     }
@@ -71,17 +72,17 @@ struct thread_safe_counter
 {
     typedef boost::detail::atomic_count type;
 
-    static unsigned int load(boost::detail::atomic_count const& counter) BOOST_NOEXCEPT
+    static unsigned int load(boost::detail::atomic_count const& counter) BOOST_SP_NOEXCEPT
     {
         return static_cast< unsigned int >(static_cast< long >(counter));
     }
 
-    static void increment(boost::detail::atomic_count& counter) BOOST_NOEXCEPT
+    static void increment(boost::detail::atomic_count& counter) BOOST_SP_NOEXCEPT
     {
         ++counter;
     }
 
-    static unsigned int decrement(boost::detail::atomic_count& counter) BOOST_NOEXCEPT
+    static unsigned int decrement(boost::detail::atomic_count& counter) BOOST_SP_NOEXCEPT
     {
         return static_cast< unsigned int >(--counter);
     }
@@ -91,9 +92,9 @@ template< typename DerivedT, typename CounterPolicyT = thread_safe_counter >
 class intrusive_ref_counter;
 
 template< typename DerivedT, typename CounterPolicyT >
-void intrusive_ptr_add_ref(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_NOEXCEPT;
+void intrusive_ptr_add_ref(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT;
 template< typename DerivedT, typename CounterPolicyT >
-void intrusive_ptr_release(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_NOEXCEPT;
+void intrusive_ptr_release(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT;
 
 /*!
  * \brief A reference counter base class
@@ -121,7 +122,7 @@ public:
      *
      * \post <tt>use_count() == 0</tt>
      */
-    intrusive_ref_counter() BOOST_NOEXCEPT : m_ref_counter(0)
+    intrusive_ref_counter() BOOST_SP_NOEXCEPT : m_ref_counter(0)
     {
     }
 
@@ -130,7 +131,7 @@ public:
      *
      * \post <tt>use_count() == 0</tt>
      */
-    intrusive_ref_counter(intrusive_ref_counter const&) BOOST_NOEXCEPT : m_ref_counter(0)
+    intrusive_ref_counter(intrusive_ref_counter const&) BOOST_SP_NOEXCEPT : m_ref_counter(0)
     {
     }
 
@@ -139,12 +140,12 @@ public:
      *
      * \post The reference counter is not modified after assignment
      */
-    intrusive_ref_counter& operator= (intrusive_ref_counter const&) BOOST_NOEXCEPT { return *this; }
+    intrusive_ref_counter& operator= (intrusive_ref_counter const&) BOOST_SP_NOEXCEPT { return *this; }
 
     /*!
      * \return The reference counter
      */
-    unsigned int use_count() const BOOST_NOEXCEPT
+    unsigned int use_count() const BOOST_SP_NOEXCEPT
     {
         return CounterPolicyT::load(m_ref_counter);
     }
@@ -155,18 +156,18 @@ protected:
      */
     BOOST_DEFAULTED_FUNCTION(~intrusive_ref_counter(), {})
 
-    friend void intrusive_ptr_add_ref< DerivedT, CounterPolicyT >(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_NOEXCEPT;
-    friend void intrusive_ptr_release< DerivedT, CounterPolicyT >(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_NOEXCEPT;
+    friend void intrusive_ptr_add_ref< DerivedT, CounterPolicyT >(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT;
+    friend void intrusive_ptr_release< DerivedT, CounterPolicyT >(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT;
 };
 
 template< typename DerivedT, typename CounterPolicyT >
-inline void intrusive_ptr_add_ref(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_NOEXCEPT
+inline void intrusive_ptr_add_ref(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT
 {
     CounterPolicyT::increment(p->m_ref_counter);
 }
 
 template< typename DerivedT, typename CounterPolicyT >
-inline void intrusive_ptr_release(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_NOEXCEPT
+inline void intrusive_ptr_release(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_SP_NOEXCEPT
 {
     if (CounterPolicyT::decrement(p->m_ref_counter) == 0)
         delete static_cast< const DerivedT* >(p);
diff --git a/contrib/libboost/boost_1_65_0/boost/smart_ptr/local_shared_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/local_shared_ptr.hpp
new file mode 100644
index 00000000000..0d1fa0182e3
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/local_shared_ptr.hpp
@@ -0,0 +1,684 @@
+#ifndef BOOST_SMART_PTR_LOCAL_SHARED_PTR_HPP_INCLUDED
+#define BOOST_SMART_PTR_LOCAL_SHARED_PTR_HPP_INCLUDED
+
+//  local_shared_ptr.hpp
+//
+//  Copyright 2017 Peter Dimov
+//
+//  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/smart_ptr/ for documentation.
+
+#include <boost/smart_ptr/shared_ptr.hpp>
+
+namespace boost
+{
+
+template<class T> class local_shared_ptr;
+
+namespace detail
+{
+
+template< class E, class Y > inline void lsp_pointer_construct( boost::local_shared_ptr< E > * /*ppx*/, Y * p, boost::detail::local_counted_base * & pn )
+{
+    boost::detail::sp_assert_convertible< Y, E >();
+
+    typedef boost::detail::local_sp_deleter< boost::checked_deleter<Y> > D;
+
+    boost::shared_ptr<E> p2( p, D() );
+
+    D * pd = static_cast< D * >( p2._internal_get_untyped_deleter() );
+
+    pd->pn_ = p2._internal_count();
+
+    pn = pd;
+}
+
+template< class E, class Y > inline void lsp_pointer_construct( boost::local_shared_ptr< E[] > * /*ppx*/, Y * p, boost::detail::local_counted_base * & pn )
+{
+    boost::detail::sp_assert_convertible< Y[], E[] >();
+
+    typedef boost::detail::local_sp_deleter< boost::checked_array_deleter<E> > D;
+
+    boost::shared_ptr<E[]> p2( p, D() );
+
+    D * pd = static_cast< D * >( p2._internal_get_untyped_deleter() );
+
+    pd->pn_ = p2._internal_count();
+
+    pn = pd;
+}
+
+template< class E, std::size_t N, class Y > inline void lsp_pointer_construct( boost::local_shared_ptr< E[N] > * /*ppx*/, Y * p, boost::detail::local_counted_base * & pn )
+{
+    boost::detail::sp_assert_convertible< Y[N], E[N] >();
+
+    typedef boost::detail::local_sp_deleter< boost::checked_array_deleter<E> > D;
+
+    boost::shared_ptr<E[N]> p2( p, D() );
+
+    D * pd = static_cast< D * >( p2._internal_get_untyped_deleter() );
+
+    pd->pn_ = p2._internal_count();
+
+    pn = pd;
+}
+
+template< class E, class P, class D > inline void lsp_deleter_construct( boost::local_shared_ptr< E > * /*ppx*/, P p, D const& d, boost::detail::local_counted_base * & pn )
+{
+    typedef boost::detail::local_sp_deleter<D> D2;
+
+    boost::shared_ptr<E> p2( p, D2( d ) );
+
+    D2 * pd = static_cast< D2 * >( p2._internal_get_untyped_deleter() );
+
+    pd->pn_ = p2._internal_count();
+
+    pn = pd;
+}
+
+template< class E, class P, class D, class A > inline void lsp_allocator_construct( boost::local_shared_ptr< E > * /*ppx*/, P p, D const& d, A const& a, boost::detail::local_counted_base * & pn )
+{
+    typedef boost::detail::local_sp_deleter<D> D2;
+
+    boost::shared_ptr<E> p2( p, D2( d ), a );
+
+    D2 * pd = static_cast< D2 * >( p2._internal_get_untyped_deleter() );
+
+    pd->pn_ = p2._internal_count();
+
+    pn = pd;
+}
+
+struct lsp_internal_constructor_tag
+{
+};
+
+} // namespace detail
+
+//
+// local_shared_ptr
+//
+// as shared_ptr, but local to a thread.
+// reference count manipulations are non-atomic.
+//
+
+template<class T> class local_shared_ptr
+{
+private:
+
+    typedef local_shared_ptr this_type;
+
+public:
+
+    typedef typename boost::detail::sp_element<T>::type element_type;
+
+private:
+
+    element_type * px;
+    boost::detail::local_counted_base * pn;
+
+    template<class Y> friend class local_shared_ptr;
+
+public:
+
+    // destructor
+
+    ~local_shared_ptr() BOOST_SP_NOEXCEPT
+    {
+        if( pn )
+        {
+            pn->release();
+        }
+    }
+
+    // constructors
+
+    BOOST_CONSTEXPR local_shared_ptr() BOOST_SP_NOEXCEPT : px( 0 ), pn( 0 )
+    {
+    }
+
+#if !defined( BOOST_NO_CXX11_NULLPTR )
+
+    BOOST_CONSTEXPR local_shared_ptr( boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT : px( 0 ), pn( 0 )
+    {
+    }
+
+#endif
+
+    // internal constructor, used by make_shared
+    BOOST_CONSTEXPR local_shared_ptr( boost::detail::lsp_internal_constructor_tag, element_type * px_, boost::detail::local_counted_base * pn_ ) BOOST_SP_NOEXCEPT : px( px_ ), pn( pn_ )
+    {
+    }
+
+    template<class Y>
+    explicit local_shared_ptr( Y * p ): px( p ), pn( 0 )
+    {
+        boost::detail::lsp_pointer_construct( this, p, pn );
+    }
+
+    template<class Y, class D> local_shared_ptr( Y * p, D d ): px( p ), pn( 0 )
+    {
+        boost::detail::lsp_deleter_construct( this, p, d, pn );
+    }
+
+#if !defined( BOOST_NO_CXX11_NULLPTR )
+
+    template<class D> local_shared_ptr( boost::detail::sp_nullptr_t p, D d ): px( p ), pn( 0 )
+    {
+        boost::detail::lsp_deleter_construct( this, p, d, pn );
+    }
+
+#endif
+
+    template<class Y, class D, class A> local_shared_ptr( Y * p, D d, A a ): px( p ), pn( 0 )
+    {
+        boost::detail::lsp_allocator_construct( this, p, d, a, pn );
+    }
+
+#if !defined( BOOST_NO_CXX11_NULLPTR )
+
+    template<class D, class A> local_shared_ptr( boost::detail::sp_nullptr_t p, D d, A a ): px( p ), pn( 0 )
+    {
+        boost::detail::lsp_allocator_construct( this, p, d, a, pn );
+    }
+
+#endif
+
+    // construction from shared_ptr
+
+    template<class Y> local_shared_ptr( shared_ptr<Y> const & r,
+        typename boost::detail::sp_enable_if_convertible<Y, T>::type = boost::detail::sp_empty() )
+        : px( r.get() ), pn( 0 )
+    {
+        boost::detail::sp_assert_convertible< Y, T >();
+
+        if( r.use_count() != 0 )
+        {
+            pn = new boost::detail::local_counted_impl( r._internal_count() );
+        }
+    }
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    template<class Y> local_shared_ptr( shared_ptr<Y> && r,
+        typename boost::detail::sp_enable_if_convertible<Y, T>::type = boost::detail::sp_empty() )
+        : px( r.get() ), pn( 0 )
+    {
+        boost::detail::sp_assert_convertible< Y, T >();
+
+        if( r.use_count() != 0 )
+        {
+            pn = new boost::detail::local_counted_impl( r._internal_count() );
+            r.reset();
+        }
+    }
+
+#endif
+
+    // construction from unique_ptr
+
+#if !defined( BOOST_NO_CXX11_SMART_PTR ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    template< class Y, class D >
+    local_shared_ptr( std::unique_ptr< Y, D > && r,
+        typename boost::detail::sp_enable_if_convertible<Y, T>::type = boost::detail::sp_empty() )
+        : px( r.get() ), pn( 0 )
+    {
+        boost::detail::sp_assert_convertible< Y, T >();
+
+        if( px )
+        {
+            pn = new boost::detail::local_counted_impl( shared_ptr<T>( std::move(r) )._internal_count() );
+        }
+    }
+
+#endif
+
+    template< class Y, class D >
+    local_shared_ptr( boost::movelib::unique_ptr< Y, D > r ); // !
+    //	: px( r.get() ), pn( new boost::detail::local_counted_impl( shared_ptr<T>( std::move(r) ) ) )
+    //{
+    //	boost::detail::sp_assert_convertible< Y, T >();
+    //}
+
+    // copy constructor
+
+    local_shared_ptr( local_shared_ptr const & r ) BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
+    {
+        if( pn )
+        {
+            pn->add_ref();
+        }
+    }
+
+    // move constructor
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    local_shared_ptr( local_shared_ptr && r ) BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
+    {
+        r.px = 0;
+        r.pn = 0;
+    }
+
+#endif
+
+    // converting copy constructor
+
+    template<class Y> local_shared_ptr( local_shared_ptr<Y> const & r,
+        typename boost::detail::sp_enable_if_convertible<Y, T>::type = boost::detail::sp_empty() ) BOOST_SP_NOEXCEPT
+        : px( r.px ), pn( r.pn )
+    {
+        boost::detail::sp_assert_convertible< Y, T >();
+
+        if( pn )
+        {
+            pn->add_ref();
+        }
+    }
+
+    // converting move constructor
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    template<class Y> local_shared_ptr( local_shared_ptr<Y> && r,
+        typename boost::detail::sp_enable_if_convertible<Y, T>::type = boost::detail::sp_empty() ) BOOST_SP_NOEXCEPT
+        : px( r.px ), pn( r.pn )
+    {
+        boost::detail::sp_assert_convertible< Y, T >();
+
+        r.px = 0;
+        r.pn = 0;
+    }
+
+#endif
+
+    // aliasing
+
+    template<class Y>
+    local_shared_ptr( local_shared_ptr<Y> const & r, element_type * p ) BOOST_SP_NOEXCEPT : px( p ), pn( r.pn )
+    {
+        if( pn )
+        {
+            pn->add_ref();
+        }
+    }
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    template<class Y>
+    local_shared_ptr( local_shared_ptr<Y> && r, element_type * p ) BOOST_SP_NOEXCEPT : px( p ), pn( r.pn )
+    {
+        r.px = 0;
+        r.pn = 0;
+    }
+
+#endif
+
+    // assignment
+
+    local_shared_ptr & operator=( local_shared_ptr const & r ) BOOST_SP_NOEXCEPT
+    {
+        local_shared_ptr( r ).swap( *this );
+        return *this;
+    }
+
+    template<class Y> local_shared_ptr & operator=( local_shared_ptr<Y> const & r ) BOOST_SP_NOEXCEPT
+    {
+        local_shared_ptr( r ).swap( *this );
+        return *this;
+    }
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    local_shared_ptr & operator=( local_shared_ptr && r ) BOOST_SP_NOEXCEPT
+    {
+        local_shared_ptr( std::move( r ) ).swap( *this );
+        return *this;
+    }
+
+    template<class Y>
+    local_shared_ptr & operator=( local_shared_ptr<Y> && r ) BOOST_SP_NOEXCEPT
+    {
+        local_shared_ptr( std::move( r ) ).swap( *this );
+        return *this;
+    }
+
+#endif
+
+#if !defined( BOOST_NO_CXX11_NULLPTR )
+
+    local_shared_ptr & operator=( boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+    {
+        local_shared_ptr().swap(*this);
+        return *this;
+    }
+
+#endif
+
+#if !defined( BOOST_NO_CXX11_SMART_PTR ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    template<class Y, class D>
+    local_shared_ptr & operator=( std::unique_ptr<Y, D> && r )
+    {
+        local_shared_ptr( std::move(r) ).swap( *this );
+        return *this;
+    }
+
+#endif
+
+    template<class Y, class D>
+    local_shared_ptr & operator=( boost::movelib::unique_ptr<Y, D> r ); // !
+
+    // reset
+
+    void reset() BOOST_SP_NOEXCEPT
+    {
+        local_shared_ptr().swap( *this );
+    }
+
+    template<class Y> void reset( Y * p ) // Y must be complete
+    {
+        local_shared_ptr( p ).swap( *this );
+    }
+
+    template<class Y, class D> void reset( Y * p, D d )
+    {
+        local_shared_ptr( p, d ).swap( *this );
+    }
+
+    template<class Y, class D, class A> void reset( Y * p, D d, A a )
+    {
+        local_shared_ptr( p, d, a ).swap( *this );
+    }
+
+    template<class Y> void reset( local_shared_ptr<Y> const & r, element_type * p ) BOOST_SP_NOEXCEPT
+    {
+        local_shared_ptr( r, p ).swap( *this );
+    }
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    template<class Y> void reset( local_shared_ptr<Y> && r, element_type * p ) BOOST_SP_NOEXCEPT
+    {
+        local_shared_ptr( std::move( r ), p ).swap( *this );
+    }
+
+#endif
+
+    // accessors
+
+    typename boost::detail::sp_dereference< T >::type operator* () const BOOST_SP_NOEXCEPT
+    {
+        return *px;
+    }
+
+    typename boost::detail::sp_member_access< T >::type operator-> () const BOOST_SP_NOEXCEPT
+    {
+        return px;
+    }
+
+    typename boost::detail::sp_array_access< T >::type operator[] ( std::ptrdiff_t i ) const BOOST_SP_NOEXCEPT_WITH_ASSERT
+    {
+        BOOST_ASSERT( px != 0 );
+        BOOST_ASSERT( i >= 0 && ( i < boost::detail::sp_extent< T >::value || boost::detail::sp_extent< T >::value == 0 ) );
+
+        return static_cast< typename boost::detail::sp_array_access< T >::type >( px[ i ] );
+    }
+
+    element_type * get() const BOOST_SP_NOEXCEPT
+    {
+        return px;
+    }
+
+    // implicit conversion to "bool"
+#include <boost/smart_ptr/detail/operator_bool.hpp>
+
+    long local_use_count() const BOOST_SP_NOEXCEPT
+    {
+        return pn? pn->local_use_count(): 0;
+    }
+
+    // conversions to shared_ptr, weak_ptr
+
+#if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
+    template<class Y, class E = typename boost::detail::sp_enable_if_convertible<T,Y>::type> operator shared_ptr<Y>() const BOOST_SP_NOEXCEPT
+#else
+    template<class Y> operator shared_ptr<Y>() const BOOST_SP_NOEXCEPT
+#endif
+    {
+        boost::detail::sp_assert_convertible<T, Y>();
+
+        if( pn )
+        {
+            return shared_ptr<Y>( boost::detail::sp_internal_constructor_tag(), px, pn->local_cb_get_shared_count() );
+        }
+        else
+        {
+            return shared_ptr<Y>();
+        }
+    }
+
+#if !defined( BOOST_SP_NO_SP_CONVERTIBLE ) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
+    template<class Y, class E = typename boost::detail::sp_enable_if_convertible<T,Y>::type> operator weak_ptr<Y>() const BOOST_SP_NOEXCEPT
+#else
+    template<class Y> operator weak_ptr<Y>() const BOOST_SP_NOEXCEPT
+#endif
+    {
+        boost::detail::sp_assert_convertible<T, Y>();
+
+        if( pn )
+        {
+            return shared_ptr<Y>( boost::detail::sp_internal_constructor_tag(), px, pn->local_cb_get_shared_count() );
+        }
+        else
+        {
+            return weak_ptr<Y>();
+        }
+    }
+
+    // swap
+
+    void swap( local_shared_ptr & r ) BOOST_SP_NOEXCEPT
+    {
+        std::swap( px, r.px );
+        std::swap( pn, r.pn );
+    }
+
+    // owner_before
+
+    template<class Y> bool owner_before( local_shared_ptr<Y> const & r ) const BOOST_SP_NOEXCEPT
+    {
+        return std::less< boost::detail::local_counted_base* >()( pn, r.pn );
+    }
+};
+
+template<class T, class U> inline bool operator==( local_shared_ptr<T> const & a, local_shared_ptr<U> const & b ) BOOST_SP_NOEXCEPT
+{
+    return a.get() == b.get();
+}
+
+template<class T, class U> inline bool operator!=( local_shared_ptr<T> const & a, local_shared_ptr<U> const & b ) BOOST_SP_NOEXCEPT
+{
+    return a.get() != b.get();
+}
+
+#if !defined( BOOST_NO_CXX11_NULLPTR )
+
+template<class T> inline bool operator==( local_shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+{
+    return p.get() == 0;
+}
+
+template<class T> inline bool operator==( boost::detail::sp_nullptr_t, local_shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+{
+    return p.get() == 0;
+}
+
+template<class T> inline bool operator!=( local_shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
+{
+    return p.get() != 0;
+}
+
+template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, local_shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+{
+    return p.get() != 0;
+}
+
+#endif
+
+template<class T, class U> inline bool operator==( local_shared_ptr<T> const & a, shared_ptr<U> const & b ) BOOST_SP_NOEXCEPT
+{
+    return a.get() == b.get();
+}
+
+template<class T, class U> inline bool operator!=( local_shared_ptr<T> const & a, shared_ptr<U> const & b ) BOOST_SP_NOEXCEPT
+{
+    return a.get() != b.get();
+}
+
+template<class T, class U> inline bool operator==( shared_ptr<T> const & a, local_shared_ptr<U> const & b ) BOOST_SP_NOEXCEPT
+{
+    return a.get() == b.get();
+}
+
+template<class T, class U> inline bool operator!=( shared_ptr<T> const & a, local_shared_ptr<U> const & b ) BOOST_SP_NOEXCEPT
+{
+    return a.get() != b.get();
+}
+
+template<class T, class U> inline bool operator<(local_shared_ptr<T> const & a, local_shared_ptr<U> const & b) BOOST_SP_NOEXCEPT
+{
+    return a.owner_before( b );
+}
+
+template<class T> inline void swap( local_shared_ptr<T> & a, local_shared_ptr<T> & b ) BOOST_SP_NOEXCEPT
+{
+    a.swap( b );
+}
+
+template<class T, class U> local_shared_ptr<T> static_pointer_cast( local_shared_ptr<U> const & r ) BOOST_SP_NOEXCEPT
+{
+    (void) static_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename local_shared_ptr<T>::element_type E;
+
+    E * p = static_cast< E* >( r.get() );
+    return local_shared_ptr<T>( r, p );
+}
+
+template<class T, class U> local_shared_ptr<T> const_pointer_cast( local_shared_ptr<U> const & r ) BOOST_SP_NOEXCEPT
+{
+    (void) const_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename local_shared_ptr<T>::element_type E;
+
+    E * p = const_cast< E* >( r.get() );
+    return local_shared_ptr<T>( r, p );
+}
+
+template<class T, class U> local_shared_ptr<T> dynamic_pointer_cast( local_shared_ptr<U> const & r ) BOOST_SP_NOEXCEPT
+{
+    (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename local_shared_ptr<T>::element_type E;
+
+    E * p = dynamic_cast< E* >( r.get() );
+    return p? local_shared_ptr<T>( r, p ): local_shared_ptr<T>();
+}
+
+template<class T, class U> local_shared_ptr<T> reinterpret_pointer_cast( local_shared_ptr<U> const & r ) BOOST_SP_NOEXCEPT
+{
+    (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename local_shared_ptr<T>::element_type E;
+
+    E * p = reinterpret_cast< E* >( r.get() );
+    return local_shared_ptr<T>( r, p );
+}
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+template<class T, class U> local_shared_ptr<T> static_pointer_cast( local_shared_ptr<U> && r ) BOOST_SP_NOEXCEPT
+{
+    (void) static_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename local_shared_ptr<T>::element_type E;
+
+    E * p = static_cast< E* >( r.get() );
+    return local_shared_ptr<T>( std::move(r), p );
+}
+
+template<class T, class U> local_shared_ptr<T> const_pointer_cast( local_shared_ptr<U> && r ) BOOST_SP_NOEXCEPT
+{
+    (void) const_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename local_shared_ptr<T>::element_type E;
+
+    E * p = const_cast< E* >( r.get() );
+    return local_shared_ptr<T>( std::move(r), p );
+}
+
+template<class T, class U> local_shared_ptr<T> dynamic_pointer_cast( local_shared_ptr<U> && r ) BOOST_SP_NOEXCEPT
+{
+    (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename local_shared_ptr<T>::element_type E;
+
+    E * p = dynamic_cast< E* >( r.get() );
+    return p? local_shared_ptr<T>( std::move(r), p ): local_shared_ptr<T>();
+}
+
+template<class T, class U> local_shared_ptr<T> reinterpret_pointer_cast( local_shared_ptr<U> && r ) BOOST_SP_NOEXCEPT
+{
+    (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename local_shared_ptr<T>::element_type E;
+
+    E * p = reinterpret_cast< E* >( r.get() );
+    return local_shared_ptr<T>( std::move(r), p );
+}
+
+#endif // !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+// get_pointer() enables boost::mem_fn to recognize local_shared_ptr
+
+template<class T> inline typename local_shared_ptr<T>::element_type * get_pointer( local_shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+{
+    return p.get();
+}
+
+// operator<<
+
+#if !defined(BOOST_NO_IOSTREAM)
+
+template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< ( std::basic_ostream<E, T> & os, local_shared_ptr<Y> const & p )
+{
+    os << p.get();
+    return os;
+}
+
+#endif // !defined(BOOST_NO_IOSTREAM)
+
+// get_deleter
+
+template<class D, class T> D * get_deleter( local_shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+{
+    return get_deleter<D>( shared_ptr<T>( p ) );
+}
+
+// hash_value
+
+template< class T > struct hash;
+
+template< class T > std::size_t hash_value( local_shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+{
+    return boost::hash< typename local_shared_ptr<T>::element_type* >()( p.get() );
+}
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_SMART_PTR_LOCAL_SHARED_PTR_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_65_0/boost/smart_ptr/make_local_shared.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/make_local_shared.hpp
new file mode 100644
index 00000000000..23114fea268
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/make_local_shared.hpp
@@ -0,0 +1,17 @@
+#ifndef BOOST_SMART_PTR_MAKE_LOCAL_SHARED_HPP_INCLUDED
+#define BOOST_SMART_PTR_MAKE_LOCAL_SHARED_HPP_INCLUDED
+
+//  make_local_shared.hpp
+//
+//  Copyright 2017 Peter Dimov
+//
+//  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/smart_ptr/ for documentation.
+
+#include <boost/smart_ptr/make_local_shared_object.hpp>
+#include <boost/smart_ptr/make_local_shared_array.hpp>
+
+#endif // #ifndef BOOST_SMART_PTR_MAKE_LOCAL_SHARED_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_65_0/boost/smart_ptr/make_local_shared_array.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/make_local_shared_array.hpp
new file mode 100644
index 00000000000..663f83479bf
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/make_local_shared_array.hpp
@@ -0,0 +1,67 @@
+/*
+Copyright 2017 Peter Dimov
+Copyright 2017 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_SMART_PTR_MAKE_LOCAL_SHARED_ARRAY_HPP
+#define BOOST_SMART_PTR_MAKE_LOCAL_SHARED_ARRAY_HPP
+
+#include <boost/smart_ptr/allocate_local_shared_array.hpp>
+
+namespace boost {
+
+template<class T>
+inline typename detail::lsp_if_size_array<T>::type
+make_local_shared()
+{
+    return boost::allocate_local_shared<T>(std::allocator<typename
+        detail::sp_array_scalar<T>::type>());
+}
+
+template<class T>
+inline typename detail::lsp_if_size_array<T>::type
+make_local_shared(const typename detail::sp_array_element<T>::type& value)
+{
+    return boost::allocate_local_shared<T>(std::allocator<typename
+        detail::sp_array_scalar<T>::type>(), value);
+}
+
+template<class T>
+inline typename detail::lsp_if_array<T>::type
+make_local_shared(std::size_t size)
+{
+    return boost::allocate_local_shared<T>(std::allocator<typename
+        detail::sp_array_scalar<T>::type>(), size);
+}
+
+template<class T>
+inline typename detail::lsp_if_array<T>::type
+make_local_shared(std::size_t size,
+    const typename detail::sp_array_element<T>::type& value)
+{
+    return boost::allocate_local_shared<T>(std::allocator<typename
+        detail::sp_array_scalar<T>::type>(), size, value);
+}
+
+template<class T>
+inline typename detail::lsp_if_size_array<T>::type
+make_local_shared_noinit()
+{
+    return allocate_local_shared_noinit<T>(std::allocator<typename
+        detail::sp_array_scalar<T>::type>());
+}
+
+template<class T>
+inline typename detail::lsp_if_array<T>::type
+make_local_shared_noinit(std::size_t size)
+{
+    return allocate_local_shared_noinit<T>(std::allocator<typename
+        detail::sp_array_scalar<T>::type>(), size);
+}
+
+} /* boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/smart_ptr/make_local_shared_object.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/make_local_shared_object.hpp
new file mode 100644
index 00000000000..ab83d60e612
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/make_local_shared_object.hpp
@@ -0,0 +1,199 @@
+#ifndef BOOST_SMART_PTR_MAKE_LOCAL_SHARED_OBJECT_HPP_INCLUDED
+#define BOOST_SMART_PTR_MAKE_LOCAL_SHARED_OBJECT_HPP_INCLUDED
+
+//  make_local_shared_object.hpp
+//
+//  Copyright 2017 Peter Dimov
+//
+//  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/smart_ptr/ for documentation.
+
+#include <boost/smart_ptr/local_shared_ptr.hpp>
+#include <boost/smart_ptr/make_shared.hpp>
+#include <boost/config.hpp>
+#include <utility>
+#include <cstddef>
+
+namespace boost
+{
+
+namespace detail
+{
+
+// lsp_if_not_array
+
+template<class T> struct lsp_if_not_array
+{
+    typedef boost::local_shared_ptr<T> type;
+};
+
+template<class T> struct lsp_if_not_array<T[]>
+{
+};
+
+template<class T, std::size_t N> struct lsp_if_not_array<T[N]>
+{
+};
+
+// lsp_ms_deleter
+
+template<class T, class A> class lsp_ms_deleter: public local_counted_impl_em
+{
+private:
+
+    typedef typename sp_aligned_storage<sizeof(T), ::boost::alignment_of<T>::value>::type storage_type;
+
+    storage_type storage_;
+    A a_;
+    bool initialized_;
+
+private:
+
+    void destroy() BOOST_SP_NOEXCEPT
+    {
+        if( initialized_ )
+        {
+            T * p = reinterpret_cast< T* >( storage_.data_ );
+
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+            std::allocator_traits<A>::destroy( a_, p );
+
+#else
+
+            p->~T();
+
+#endif
+
+            initialized_ = false;
+        }
+    }
+
+public:
+
+    explicit lsp_ms_deleter( A const & a ) BOOST_SP_NOEXCEPT : a_( a ), initialized_( false )
+    {
+    }
+
+    // optimization: do not copy storage_
+    lsp_ms_deleter( lsp_ms_deleter const & r ) BOOST_SP_NOEXCEPT : a_( r.a_), initialized_( false )
+    {
+    }
+
+    ~lsp_ms_deleter() BOOST_SP_NOEXCEPT
+    {
+        destroy();
+    }
+
+    void operator()( T * ) BOOST_SP_NOEXCEPT
+    {
+        destroy();
+    }
+
+    static void operator_fn( T* ) BOOST_SP_NOEXCEPT // operator() can't be static
+    {
+    }
+
+    void * address() BOOST_SP_NOEXCEPT
+    {
+        return storage_.data_;
+    }
+
+    void set_initialized() BOOST_SP_NOEXCEPT
+    {
+        initialized_ = true;
+    }
+};
+
+} // namespace detail
+
+template<class T, class A, class... Args> typename boost::detail::lsp_if_not_array<T>::type allocate_local_shared( A const & a, Args&&... args )
+{
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+    typedef typename std::allocator_traits<A>::template rebind_alloc<T> A2;
+
+#else
+
+    typedef typename A::template rebind<T>::other A2;
+
+#endif
+
+    A2 a2( a );
+
+    typedef boost::detail::lsp_ms_deleter<T, A2> D;
+
+    boost::shared_ptr<T> pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag<D>(), a2 );
+
+    D * pd = static_cast< D* >( pt._internal_get_untyped_deleter() );
+    void * pv = pd->address();
+
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+    std::allocator_traits<A2>::construct( a2, static_cast< T* >( pv ), std::forward<Args>( args )... );
+
+#else
+
+    ::new( pv ) T( std::forward<Args>( args )... );
+
+#endif
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+
+    pd->pn_ = pt._internal_count();
+
+    return boost::local_shared_ptr<T>( boost::detail::lsp_internal_constructor_tag(), pt2, pd );
+}
+
+template<class T, class A> typename boost::detail::lsp_if_not_array<T>::type allocate_local_shared_noinit( A const & a )
+{
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+    typedef typename std::allocator_traits<A>::template rebind_alloc<T> A2;
+
+#else
+
+    typedef typename A::template rebind<T>::other A2;
+
+#endif
+
+    A2 a2( a );
+
+    typedef boost::detail::lsp_ms_deleter< T, std::allocator<T> > D;
+
+    boost::shared_ptr<T> pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag<D>(), a2 );
+
+    D * pd = static_cast< D* >( pt._internal_get_untyped_deleter() );
+    void * pv = pd->address();
+
+    ::new( pv ) T;
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+
+    pd->pn_ = pt._internal_count();
+
+    return boost::local_shared_ptr<T>( boost::detail::lsp_internal_constructor_tag(), pt2, pd );
+}
+
+template<class T, class... Args> typename boost::detail::lsp_if_not_array<T>::type make_local_shared( Args&&... args )
+{
+    return boost::allocate_local_shared<T>( std::allocator<T>(), std::forward<Args>(args)... );
+}
+
+template<class T> typename boost::detail::lsp_if_not_array<T>::type make_local_shared_noinit()
+{
+    return boost::allocate_shared_noinit<T>( std::allocator<T>() );
+}
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SMART_PTR_MAKE_SHARED_OBJECT_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/make_shared.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/make_shared.hpp
similarity index 88%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/make_shared.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/make_shared.hpp
index 8d0e3ea4006..dd9191c61d3 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/make_shared.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/make_shared.hpp
@@ -9,8 +9,7 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt
 //
-//  See http://www.boost.org/libs/smart_ptr/make_shared.html
-//  for documentation.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
 #include <boost/smart_ptr/make_shared_object.hpp>
 
diff --git a/contrib/libboost/boost_1_65_0/boost/smart_ptr/make_shared_array.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/make_shared_array.hpp
new file mode 100644
index 00000000000..2eaf4db71b8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/make_shared_array.hpp
@@ -0,0 +1,66 @@
+/*
+Copyright 2012-2017 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_SMART_PTR_MAKE_SHARED_ARRAY_HPP
+#define BOOST_SMART_PTR_MAKE_SHARED_ARRAY_HPP
+
+#include <boost/smart_ptr/allocate_shared_array.hpp>
+
+namespace boost {
+
+template<class T>
+inline typename detail::sp_if_size_array<T>::type
+make_shared()
+{
+    return boost::allocate_shared<T>(std::allocator<typename
+        detail::sp_array_scalar<T>::type>());
+}
+
+template<class T>
+inline typename detail::sp_if_size_array<T>::type
+make_shared(const typename detail::sp_array_element<T>::type& value)
+{
+    return boost::allocate_shared<T>(std::allocator<typename
+        detail::sp_array_scalar<T>::type>(), value);
+}
+
+template<class T>
+inline typename detail::sp_if_array<T>::type
+make_shared(std::size_t size)
+{
+    return boost::allocate_shared<T>(std::allocator<typename
+        detail::sp_array_scalar<T>::type>(), size);
+}
+
+template<class T>
+inline typename detail::sp_if_array<T>::type
+make_shared(std::size_t size,
+    const typename detail::sp_array_element<T>::type& value)
+{
+    return boost::allocate_shared<T>(std::allocator<typename
+        detail::sp_array_scalar<T>::type>(), size, value);
+}
+
+template<class T>
+inline typename detail::sp_if_size_array<T>::type
+make_shared_noinit()
+{
+    return allocate_shared_noinit<T>(std::allocator<typename
+        detail::sp_array_scalar<T>::type>());
+}
+
+template<class T>
+inline typename detail::sp_if_array<T>::type
+make_shared_noinit(std::size_t size)
+{
+    return allocate_shared_noinit<T>(std::allocator<typename
+        detail::sp_array_scalar<T>::type>(), size);
+}
+
+} /* boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/smart_ptr/make_shared_object.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/make_shared_object.hpp
new file mode 100644
index 00000000000..c681602dca2
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/make_shared_object.hpp
@@ -0,0 +1,801 @@
+#ifndef BOOST_SMART_PTR_MAKE_SHARED_OBJECT_HPP_INCLUDED
+#define BOOST_SMART_PTR_MAKE_SHARED_OBJECT_HPP_INCLUDED
+
+//  make_shared_object.hpp
+//
+//  Copyright (c) 2007, 2008, 2012 Peter Dimov
+//
+//  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/smart_ptr/ for documentation.
+
+#include <boost/config.hpp>
+#include <boost/move/core.hpp>
+#include <boost/move/utility_core.hpp>
+#include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/detail/sp_forward.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
+#include <boost/type_traits/type_with_alignment.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <cstddef>
+#include <new>
+
+namespace boost
+{
+
+namespace detail
+{
+
+template< std::size_t N, std::size_t A > struct sp_aligned_storage
+{
+    union type
+    {
+        char data_[ N ];
+        typename boost::type_with_alignment< A >::type align_;
+    };
+};
+
+template< class T > class sp_ms_deleter
+{
+private:
+
+    typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
+
+    bool initialized_;
+    storage_type storage_;
+
+private:
+
+    void destroy() BOOST_SP_NOEXCEPT
+    {
+        if( initialized_ )
+        {
+#if defined( __GNUC__ )
+
+            // fixes incorrect aliasing warning
+            T * p = reinterpret_cast< T* >( storage_.data_ );
+            p->~T();
+
+#else
+
+            reinterpret_cast< T* >( storage_.data_ )->~T();
+
+#endif
+
+            initialized_ = false;
+        }
+    }
+
+public:
+
+    sp_ms_deleter() BOOST_SP_NOEXCEPT : initialized_( false )
+    {
+    }
+
+    template<class A> explicit sp_ms_deleter( A const & ) BOOST_SP_NOEXCEPT : initialized_( false )
+    {
+    }
+
+    // optimization: do not copy storage_
+    sp_ms_deleter( sp_ms_deleter const & ) BOOST_SP_NOEXCEPT : initialized_( false )
+    {
+    }
+
+    ~sp_ms_deleter() BOOST_SP_NOEXCEPT
+    {
+        destroy();
+    }
+
+    void operator()( T * ) BOOST_SP_NOEXCEPT
+    {
+        destroy();
+    }
+
+    static void operator_fn( T* ) BOOST_SP_NOEXCEPT // operator() can't be static
+    {
+    }
+
+    void * address() BOOST_SP_NOEXCEPT
+    {
+        return storage_.data_;
+    }
+
+    void set_initialized() BOOST_SP_NOEXCEPT
+    {
+        initialized_ = true;
+    }
+};
+
+template< class T, class A > class sp_as_deleter
+{
+private:
+
+    typedef typename sp_aligned_storage< sizeof( T ), ::boost::alignment_of< T >::value >::type storage_type;
+
+    storage_type storage_;
+    A a_;
+    bool initialized_;
+
+private:
+
+    void destroy() BOOST_SP_NOEXCEPT
+    {
+        if( initialized_ )
+        {
+            T * p = reinterpret_cast< T* >( storage_.data_ );
+
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+            std::allocator_traits<A>::destroy( a_, p );
+
+#else
+
+            p->~T();
+
+#endif
+
+            initialized_ = false;
+        }
+    }
+
+public:
+
+    sp_as_deleter( A const & a ) BOOST_SP_NOEXCEPT : a_( a ), initialized_( false )
+    {
+    }
+
+    // optimization: do not copy storage_
+    sp_as_deleter( sp_as_deleter const & r ) BOOST_SP_NOEXCEPT : a_( r.a_), initialized_( false )
+    {
+    }
+
+    ~sp_as_deleter() BOOST_SP_NOEXCEPT
+    {
+        destroy();
+    }
+
+    void operator()( T * ) BOOST_SP_NOEXCEPT
+    {
+        destroy();
+    }
+
+    static void operator_fn( T* ) BOOST_SP_NOEXCEPT // operator() can't be static
+    {
+    }
+
+    void * address() BOOST_SP_NOEXCEPT
+    {
+        return storage_.data_;
+    }
+
+    void set_initialized() BOOST_SP_NOEXCEPT
+    {
+        initialized_ = true;
+    }
+};
+
+template< class T > struct sp_if_not_array
+{
+    typedef boost::shared_ptr< T > type;
+};
+
+#if !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
+
+template< class T > struct sp_if_not_array< T[] >
+{
+};
+
+#if !defined( __BORLANDC__ ) || !BOOST_WORKAROUND( __BORLANDC__, < 0x600 )
+
+template< class T, std::size_t N > struct sp_if_not_array< T[N] >
+{
+};
+
+#endif
+
+#endif
+
+} // namespace detail
+
+#if !defined( BOOST_NO_FUNCTION_TEMPLATE_ORDERING )
+# define BOOST_SP_MSD( T ) boost::detail::sp_inplace_tag< boost::detail::sp_ms_deleter< T > >()
+#else
+# define BOOST_SP_MSD( T ) boost::detail::sp_ms_deleter< T >()
+#endif
+
+// _noinit versions
+
+template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared_noinit()
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T;
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared_noinit( A const & a )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T;
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+#if !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+// Variadic templates, rvalue reference
+
+template< class T, class... Args > typename boost::detail::sp_if_not_array< T >::type make_shared( Args && ... args )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T( boost::detail::sp_forward<Args>( args )... );
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class... Args > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, Args && ... args )
+{
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+    typedef typename std::allocator_traits<A>::template rebind_alloc<T> A2;
+    A2 a2( a );
+
+    typedef boost::detail::sp_as_deleter< T, A2 > D;
+
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag<D>(), a2 );
+
+#else
+
+    typedef boost::detail::sp_ms_deleter< T > D;
+
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), boost::detail::sp_inplace_tag<D>(), a );
+
+#endif
+
+    D * pd = static_cast< D* >( pt._internal_get_untyped_deleter() );
+    void * pv = pd->address();
+
+#if !defined( BOOST_NO_CXX11_ALLOCATOR )
+
+    std::allocator_traits<A2>::construct( a2, static_cast< T* >( pv ), boost::detail::sp_forward<Args>( args )... );
+
+#else
+
+    ::new( pv ) T( boost::detail::sp_forward<Args>( args )... );
+
+#endif
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+#else // !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+// Common zero-argument versions
+
+template< class T > typename boost::detail::sp_if_not_array< T >::type make_shared()
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T();
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A > typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T();
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+// C++03 version
+
+template< class T, class A1 >
+typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::forward<A1>( a1 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1 >
+typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::forward<A1>( a1 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2 >
+typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2 >
+typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3 >
+typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3 >
+typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3, class A4 >
+typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4 >
+typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5 >
+typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 ),
+        boost::forward<A5>( a5 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4, class A5 >
+typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 ),
+        boost::forward<A5>( a5 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
+typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 ),
+        boost::forward<A5>( a5 ),
+        boost::forward<A6>( a6 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6 >
+typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 ),
+        boost::forward<A5>( a5 ),
+        boost::forward<A6>( a6 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
+typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 ),
+        boost::forward<A5>( a5 ),
+        boost::forward<A6>( a6 ),
+        boost::forward<A7>( a7 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
+typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 ),
+        boost::forward<A5>( a5 ),
+        boost::forward<A6>( a6 ),
+        boost::forward<A7>( a7 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
+typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7, BOOST_FWD_REF(A8) a8 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 ),
+        boost::forward<A5>( a5 ),
+        boost::forward<A6>( a6 ),
+        boost::forward<A7>( a7 ),
+        boost::forward<A8>( a8 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
+typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7, BOOST_FWD_REF(A8) a8 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 ),
+        boost::forward<A5>( a5 ),
+        boost::forward<A6>( a6 ),
+        boost::forward<A7>( a7 ),
+        boost::forward<A8>( a8 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
+typename boost::detail::sp_if_not_array< T >::type make_shared( BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7, BOOST_FWD_REF(A8) a8, BOOST_FWD_REF(A9) a9 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ) );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 ),
+        boost::forward<A5>( a5 ),
+        boost::forward<A6>( a6 ),
+        boost::forward<A7>( a7 ),
+        boost::forward<A8>( a8 ),
+        boost::forward<A9>( a9 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+template< class T, class A, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
+typename boost::detail::sp_if_not_array< T >::type allocate_shared( A const & a, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2, BOOST_FWD_REF(A3) a3, BOOST_FWD_REF(A4) a4, BOOST_FWD_REF(A5) a5, BOOST_FWD_REF(A6) a6, BOOST_FWD_REF(A7) a7, BOOST_FWD_REF(A8) a8, BOOST_FWD_REF(A9) a9 )
+{
+    boost::shared_ptr< T > pt( static_cast< T* >( 0 ), BOOST_SP_MSD( T ), a );
+
+    boost::detail::sp_ms_deleter< T > * pd = static_cast<boost::detail::sp_ms_deleter< T > *>( pt._internal_get_untyped_deleter() );
+
+    void * pv = pd->address();
+
+    ::new( pv ) T(
+        boost::forward<A1>( a1 ),
+        boost::forward<A2>( a2 ),
+        boost::forward<A3>( a3 ),
+        boost::forward<A4>( a4 ),
+        boost::forward<A5>( a5 ),
+        boost::forward<A6>( a6 ),
+        boost::forward<A7>( a7 ),
+        boost::forward<A8>( a8 ),
+        boost::forward<A9>( a9 )
+        );
+
+    pd->set_initialized();
+
+    T * pt2 = static_cast< T* >( pv );
+
+    boost::detail::sp_enable_shared_from_this( &pt, pt2, pt2 );
+    return boost::shared_ptr< T >( pt, pt2 );
+}
+
+#endif // !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+#undef BOOST_SP_MSD
+
+} // namespace boost
+
+#endif // #ifndef BOOST_SMART_PTR_MAKE_SHARED_OBJECT_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/make_unique.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/make_unique.hpp
similarity index 67%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/make_unique.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/make_unique.hpp
index d054e3dfe12..eed503392b8 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/make_unique.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/make_unique.hpp
@@ -1,10 +1,9 @@
 /*
-(c) 2014-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #ifndef BOOST_SMART_PTR_MAKE_UNIQUE_HPP
 #define BOOST_SMART_PTR_MAKE_UNIQUE_HPP
@@ -15,6 +14,7 @@ http://boost.org/LICENSE_1_0.txt
 
 namespace boost {
 namespace detail {
+
 template<class T>
 struct up_if_object {
     typedef std::unique_ptr<T> type;
@@ -56,10 +56,12 @@ template<class T>
 struct up_element<T[]> {
     typedef T type;
 };
+
 } /* detail */
 
 template<class T>
-inline typename detail::up_if_object<T>::type make_unique()
+inline typename detail::up_if_object<T>::type
+make_unique()
 {
     return std::unique_ptr<T>(new T());
 }
@@ -67,7 +69,7 @@ inline typename detail::up_if_object<T>::type make_unique()
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 template<class T, class... Args>
 inline typename detail::up_if_object<T>::type
-    make_unique(Args&&... args)
+make_unique(Args&&... args)
 {
     return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
 }
@@ -75,31 +77,34 @@ inline typename detail::up_if_object<T>::type
 
 template<class T>
 inline typename detail::up_if_object<T>::type
-    make_unique(typename detail::up_remove_reference<T>::type&& value)
+make_unique(typename detail::up_remove_reference<T>::type&& value)
 {
     return std::unique_ptr<T>(new T(std::move(value)));
 }
 
 template<class T>
-inline typename detail::up_if_object<T>::type make_unique_noinit()
+inline typename detail::up_if_object<T>::type
+make_unique_noinit()
 {
     return std::unique_ptr<T>(new T);
 }
 
 template<class T>
-inline typename detail::up_if_array<T>::type make_unique(std::size_t n)
+inline typename detail::up_if_array<T>::type
+make_unique(std::size_t size)
 {
-    return std::unique_ptr<T>(new
-        typename detail::up_element<T>::type[n]());
+    return std::unique_ptr<T>(new typename
+        detail::up_element<T>::type[size]());
 }
 
 template<class T>
 inline typename detail::up_if_array<T>::type
-    make_unique_noinit(std::size_t n)
+make_unique_noinit(std::size_t size)
 {
-    return std::unique_ptr<T>(new
-        typename detail::up_element<T>::type[n]);
+    return std::unique_ptr<T>(new typename
+        detail::up_element<T>::type[size]);
 }
+
 } /* boost */
 
 #endif
diff --git a/contrib/libboost/boost_1_65_0/boost/smart_ptr/owner_less.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/owner_less.hpp
new file mode 100644
index 00000000000..5f50aeb5b84
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/owner_less.hpp
@@ -0,0 +1,34 @@
+#ifndef BOOST_SMART_PTR_OWNER_LESS_HPP_INCLUDED
+#define BOOST_SMART_PTR_OWNER_LESS_HPP_INCLUDED
+
+//
+//  owner_less.hpp
+//
+//  Copyright (c) 2008 Frank Mori Hess
+//  Copyright (c) 2016 Peter Dimov
+//
+//  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/smart_ptr/ for documentation.
+//
+
+namespace boost
+{
+
+template<class T = void> struct owner_less
+{
+    typedef bool result_type;
+    typedef T first_argument_type;
+    typedef T second_argument_type;
+
+    template<class U, class V> bool operator()( U const & u, V const & v ) const
+    {
+        return u.owner_before( v );
+    }
+};
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_SMART_PTR_OWNER_LESS_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/scoped_array.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/scoped_array.hpp
similarity index 78%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/scoped_array.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/scoped_array.hpp
index e395e28f85d..05dd05aea8d 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/scoped_array.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/scoped_array.hpp
@@ -8,13 +8,13 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
-//  http://www.boost.org/libs/smart_ptr/scoped_array.htm
-//
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
 #include <boost/config.hpp>
 #include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 
 #include <boost/detail/workaround.hpp>
 
@@ -54,14 +54,14 @@ public:
 
     typedef T element_type;
 
-    explicit scoped_array( T * p = 0 ) BOOST_NOEXCEPT : px( p )
+    explicit scoped_array( T * p = 0 ) BOOST_SP_NOEXCEPT : px( p )
     {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         boost::sp_array_constructor_hook( px );
 #endif
     }
 
-    ~scoped_array() // never throws
+    ~scoped_array() BOOST_SP_NOEXCEPT
     {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         boost::sp_array_destructor_hook( px );
@@ -69,20 +69,20 @@ public:
         boost::checked_array_delete( px );
     }
 
-    void reset(T * p = 0) // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
+    void reset(T * p = 0) BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( p == 0 || p != px ); // catch self-reset errors
         this_type(p).swap(*this);
     }
 
-    T & operator[](std::ptrdiff_t i) const // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
+    T & operator[](std::ptrdiff_t i) const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         BOOST_ASSERT( i >= 0 );
         return px[i];
     }
 
-    T * get() const BOOST_NOEXCEPT
+    T * get() const BOOST_SP_NOEXCEPT
     {
         return px;
     }
@@ -90,7 +90,7 @@ public:
 // implicit conversion to "bool"
 #include <boost/smart_ptr/detail/operator_bool.hpp>
 
-    void swap(scoped_array & b) BOOST_NOEXCEPT
+    void swap(scoped_array & b) BOOST_SP_NOEXCEPT
     {
         T * tmp = b.px;
         b.px = px;
@@ -100,29 +100,29 @@ public:
 
 #if !defined( BOOST_NO_CXX11_NULLPTR )
 
-template<class T> inline bool operator==( scoped_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
+template<class T> inline bool operator==( scoped_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, scoped_array<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator==( boost::detail::sp_nullptr_t, scoped_array<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( scoped_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( scoped_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, scoped_array<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, scoped_array<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return p.get() != 0;
 }
 
 #endif
 
-template<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b) BOOST_NOEXCEPT
+template<class T> inline void swap(scoped_array<T> & a, scoped_array<T> & b) BOOST_SP_NOEXCEPT
 {
     a.swap(b);
 }
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/scoped_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/scoped_ptr.hpp
similarity index 80%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/scoped_ptr.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/scoped_ptr.hpp
index d5d8720f521..5325eba5ffe 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/scoped_ptr.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/scoped_ptr.hpp
@@ -8,14 +8,14 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
-//  http://www.boost.org/libs/smart_ptr/scoped_ptr.htm
-//
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 
 #include <boost/config.hpp>
 #include <boost/assert.hpp>
 #include <boost/checked_delete.hpp>
 #include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
 #include <boost/smart_ptr/detail/sp_disable_deprecated.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 #include <boost/detail/workaround.hpp>
 
 #ifndef BOOST_NO_AUTO_PTR
@@ -62,7 +62,7 @@ public:
 
     typedef T element_type;
 
-    explicit scoped_ptr( T * p = 0 ): px( p ) // never throws
+    explicit scoped_ptr( T * p = 0 ) BOOST_SP_NOEXCEPT : px( p )
     {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         boost::sp_scalar_constructor_hook( px );
@@ -71,7 +71,7 @@ public:
 
 #ifndef BOOST_NO_AUTO_PTR
 
-    explicit scoped_ptr( std::auto_ptr<T> p ) BOOST_NOEXCEPT : px( p.release() )
+    explicit scoped_ptr( std::auto_ptr<T> p ) BOOST_SP_NOEXCEPT : px( p.release() )
     {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         boost::sp_scalar_constructor_hook( px );
@@ -80,7 +80,7 @@ public:
 
 #endif
 
-    ~scoped_ptr() // never throws
+    ~scoped_ptr() BOOST_SP_NOEXCEPT
     {
 #if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
         boost::sp_scalar_destructor_hook( px );
@@ -88,25 +88,25 @@ public:
         boost::checked_delete( px );
     }
 
-    void reset(T * p = 0) // never throws
+    void reset(T * p = 0) BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( p == 0 || p != px ); // catch self-reset errors
         this_type(p).swap(*this);
     }
 
-    T & operator*() const // never throws
+    T & operator*() const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         return *px;
     }
 
-    T * operator->() const // never throws
+    T * operator->() const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         return px;
     }
 
-    T * get() const BOOST_NOEXCEPT
+    T * get() const BOOST_SP_NOEXCEPT
     {
         return px;
     }
@@ -114,7 +114,7 @@ public:
 // implicit conversion to "bool"
 #include <boost/smart_ptr/detail/operator_bool.hpp>
 
-    void swap(scoped_ptr & b) BOOST_NOEXCEPT
+    void swap(scoped_ptr & b) BOOST_SP_NOEXCEPT
     {
         T * tmp = b.px;
         b.px = px;
@@ -124,36 +124,36 @@ public:
 
 #if !defined( BOOST_NO_CXX11_NULLPTR )
 
-template<class T> inline bool operator==( scoped_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
+template<class T> inline bool operator==( scoped_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, scoped_ptr<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator==( boost::detail::sp_nullptr_t, scoped_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( scoped_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( scoped_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, scoped_ptr<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, scoped_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return p.get() != 0;
 }
 
 #endif
 
-template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) BOOST_NOEXCEPT
+template<class T> inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b) BOOST_SP_NOEXCEPT
 {
     a.swap(b);
 }
 
 // get_pointer(p) is a generic way to say p.get()
 
-template<class T> inline T * get_pointer(scoped_ptr<T> const & p) BOOST_NOEXCEPT
+template<class T> inline T * get_pointer(scoped_ptr<T> const & p) BOOST_SP_NOEXCEPT
 {
     return p.get();
 }
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/shared_array.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/shared_array.hpp
similarity index 79%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/shared_array.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/shared_array.hpp
index fd58071be04..3ffa7426c30 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/shared_array.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/shared_array.hpp
@@ -11,7 +11,7 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
-//  See http://www.boost.org/libs/smart_ptr/shared_array.htm for documentation.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 #include <boost/config.hpp>   // for broken compiler workarounds
@@ -24,6 +24,7 @@
 #include <boost/smart_ptr/shared_ptr.hpp>
 #include <boost/smart_ptr/detail/shared_count.hpp>
 #include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 #include <boost/detail/workaround.hpp>
 
 #include <cstddef>            // for std::ptrdiff_t
@@ -53,13 +54,13 @@ public:
 
     typedef T element_type;
 
-    shared_array() BOOST_NOEXCEPT : px( 0 ), pn()
+    shared_array() BOOST_SP_NOEXCEPT : px( 0 ), pn()
     {
     }
 
 #if !defined( BOOST_NO_CXX11_NULLPTR )
 
-    shared_array( boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT : px( 0 ), pn()
+    shared_array( boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT : px( 0 ), pn()
     {
     }
 
@@ -95,11 +96,11 @@ public:
 
 // ... except in C++0x, move disables the implicit copy
 
-    shared_array( shared_array const & r ) BOOST_NOEXCEPT : px( r.px ), pn( r.pn )
+    shared_array( shared_array const & r ) BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
     {
     }
 
-    shared_array( shared_array && r ) BOOST_NOEXCEPT : px( r.px ), pn()
+    shared_array( shared_array && r ) BOOST_SP_NOEXCEPT : px( r.px ), pn()
     {
         pn.swap( r.pn );
         r.px = 0;
@@ -119,7 +120,7 @@ public:
     shared_array( shared_array<Y> const & r )
 
 #endif
-    BOOST_NOEXCEPT : px( r.px ), pn( r.pn ) // never throws
+    BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
     {
         boost::detail::sp_assert_convertible< Y[], T[] >();
     }
@@ -127,13 +128,13 @@ public:
     // aliasing
 
     template< class Y >
-    shared_array( shared_array<Y> const & r, element_type * p ) BOOST_NOEXCEPT : px( p ), pn( r.pn )
+    shared_array( shared_array<Y> const & r, element_type * p ) BOOST_SP_NOEXCEPT : px( p ), pn( r.pn )
     {
     }
 
     // assignment
 
-    shared_array & operator=( shared_array const & r ) BOOST_NOEXCEPT
+    shared_array & operator=( shared_array const & r ) BOOST_SP_NOEXCEPT
     {
         this_type( r ).swap( *this );
         return *this;
@@ -142,7 +143,7 @@ public:
 #if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1400)
 
     template<class Y>
-    shared_array & operator=( shared_array<Y> const & r ) BOOST_NOEXCEPT
+    shared_array & operator=( shared_array<Y> const & r ) BOOST_SP_NOEXCEPT
     {
         this_type( r ).swap( *this );
         return *this;
@@ -152,14 +153,14 @@ public:
 
 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 
-    shared_array & operator=( shared_array && r ) BOOST_NOEXCEPT
+    shared_array & operator=( shared_array && r ) BOOST_SP_NOEXCEPT
     {
         this_type( static_cast< shared_array && >( r ) ).swap( *this );
         return *this;
     }
 
     template<class Y>
-    shared_array & operator=( shared_array<Y> && r ) BOOST_NOEXCEPT
+    shared_array & operator=( shared_array<Y> && r ) BOOST_SP_NOEXCEPT
     {
         this_type( static_cast< shared_array<Y> && >( r ) ).swap( *this );
         return *this;
@@ -167,7 +168,7 @@ public:
 
 #endif
 
-    void reset() BOOST_NOEXCEPT
+    void reset() BOOST_SP_NOEXCEPT
     {
         this_type().swap( *this );
     }
@@ -188,19 +189,19 @@ public:
         this_type( p, d, a ).swap( *this );
     }
 
-    template<class Y> void reset( shared_array<Y> const & r, element_type * p )
+    template<class Y> void reset( shared_array<Y> const & r, element_type * p ) BOOST_SP_NOEXCEPT
     {
         this_type( r, p ).swap( *this );
     }
 
-    T & operator[] (std::ptrdiff_t i) const // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
+    T & operator[] (std::ptrdiff_t i) const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT(px != 0);
         BOOST_ASSERT(i >= 0);
         return px[i];
     }
     
-    T * get() const BOOST_NOEXCEPT
+    T * get() const BOOST_SP_NOEXCEPT
     {
         return px;
     }
@@ -208,23 +209,23 @@ public:
 // implicit conversion to "bool"
 #include <boost/smart_ptr/detail/operator_bool.hpp>
 
-    bool unique() const BOOST_NOEXCEPT
+    bool unique() const BOOST_SP_NOEXCEPT
     {
         return pn.unique();
     }
 
-    long use_count() const BOOST_NOEXCEPT
+    long use_count() const BOOST_SP_NOEXCEPT
     {
         return pn.use_count();
     }
 
-    void swap(shared_array<T> & other) BOOST_NOEXCEPT
+    void swap(shared_array<T> & other) BOOST_SP_NOEXCEPT
     {
         std::swap(px, other.px);
         pn.swap(other.pn);
     }
 
-    void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const
+    void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const BOOST_SP_NOEXCEPT
     {
         return pn.get_deleter( ti );
     }
@@ -238,51 +239,51 @@ private:
 
 };  // shared_array
 
-template<class T> inline bool operator==(shared_array<T> const & a, shared_array<T> const & b) BOOST_NOEXCEPT
+template<class T> inline bool operator==(shared_array<T> const & a, shared_array<T> const & b) BOOST_SP_NOEXCEPT
 {
     return a.get() == b.get();
 }
 
-template<class T> inline bool operator!=(shared_array<T> const & a, shared_array<T> const & b) BOOST_NOEXCEPT
+template<class T> inline bool operator!=(shared_array<T> const & a, shared_array<T> const & b) BOOST_SP_NOEXCEPT
 {
     return a.get() != b.get();
 }
 
 #if !defined( BOOST_NO_CXX11_NULLPTR )
 
-template<class T> inline bool operator==( shared_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
+template<class T> inline bool operator==( shared_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, shared_array<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator==( boost::detail::sp_nullptr_t, shared_array<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( shared_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( shared_array<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, shared_array<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, shared_array<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return p.get() != 0;
 }
 
 #endif
 
-template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b) BOOST_NOEXCEPT
+template<class T> inline bool operator<(shared_array<T> const & a, shared_array<T> const & b) BOOST_SP_NOEXCEPT
 {
     return std::less<T*>()(a.get(), b.get());
 }
 
-template<class T> void swap(shared_array<T> & a, shared_array<T> & b) BOOST_NOEXCEPT
+template<class T> void swap(shared_array<T> & a, shared_array<T> & b) BOOST_SP_NOEXCEPT
 {
     a.swap(b);
 }
 
-template< class D, class T > D * get_deleter( shared_array<T> const & p )
+template< class D, class T > D * get_deleter( shared_array<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return static_cast< D * >( p._internal_get_deleter( BOOST_SP_TYPEID(D) ) );
 }
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/shared_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/shared_ptr.hpp
similarity index 77%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/shared_ptr.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/shared_ptr.hpp
index 77f68bebd0e..e8a302c74a6 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/shared_ptr.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/shared_ptr.hpp
@@ -11,7 +11,7 @@
 //  accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
-//  See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 #include <boost/config.hpp>   // for broken compiler workarounds
@@ -30,6 +30,7 @@
 #include <boost/smart_ptr/detail/sp_convertible.hpp>
 #include <boost/smart_ptr/detail/sp_nullptr_t.hpp>
 #include <boost/smart_ptr/detail/sp_disable_deprecated.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 
 #if !defined(BOOST_SP_NO_ATOMIC_ACCESS)
 #include <boost/smart_ptr/detail/spinlock_pool.hpp>
@@ -261,7 +262,7 @@ template< class T, class R > struct sp_enable_if_auto_ptr< std::auto_ptr< T >, R
 
 // sp_assert_convertible
 
-template< class Y, class T > inline void sp_assert_convertible()
+template< class Y, class T > inline void sp_assert_convertible() BOOST_SP_NOEXCEPT
 {
 #if !defined( BOOST_SP_NO_SP_CONVERTIBLE )
 
@@ -322,6 +323,10 @@ template< class T, std::size_t N, class Y > inline void sp_deleter_construct( bo
 
 #endif // !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )
 
+struct sp_internal_constructor_tag
+{
+};
+
 } // namespace detail
 
 
@@ -344,13 +349,25 @@ public:
 
     typedef typename boost::detail::sp_element< T >::type element_type;
 
-    shared_ptr() BOOST_NOEXCEPT : px( 0 ), pn() // never throws in 1.30+
+    BOOST_CONSTEXPR shared_ptr() BOOST_SP_NOEXCEPT : px( 0 ), pn()
     {
     }
 
 #if !defined( BOOST_NO_CXX11_NULLPTR )
 
-    shared_ptr( boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT : px( 0 ), pn() // never throws
+    BOOST_CONSTEXPR shared_ptr( boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT : px( 0 ), pn()
+    {
+    }
+
+#endif
+
+    BOOST_CONSTEXPR shared_ptr( boost::detail::sp_internal_constructor_tag, element_type * px_, boost::detail::shared_count const & pn_ ) BOOST_SP_NOEXCEPT : px( px_ ), pn( pn_ )
+    {
+    }
+
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+    BOOST_CONSTEXPR shared_ptr( boost::detail::sp_internal_constructor_tag, element_type * px_, boost::detail::shared_count && pn_ ) BOOST_SP_NOEXCEPT : px( px_ ), pn( std::move( pn_ ) )
     {
     }
 
@@ -402,7 +419,7 @@ public:
 
 // ... except in C++0x, move disables the implicit copy
 
-    shared_ptr( shared_ptr const & r ) BOOST_NOEXCEPT : px( r.px ), pn( r.pn )
+    shared_ptr( shared_ptr const & r ) BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
     {
     }
 
@@ -419,7 +436,7 @@ public:
 
     template<class Y>
     shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag )
-    BOOST_NOEXCEPT : px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() )
+    BOOST_SP_NOEXCEPT : px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() )
     {
         if( !pn.empty() )
         {
@@ -437,14 +454,14 @@ public:
     shared_ptr( shared_ptr<Y> const & r )
 
 #endif
-    BOOST_NOEXCEPT : px( r.px ), pn( r.pn )
+    BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
     {
         boost::detail::sp_assert_convertible< Y, T >();
     }
 
     // aliasing
     template< class Y >
-    shared_ptr( shared_ptr<Y> const & r, element_type * p ) BOOST_NOEXCEPT : px( p ), pn( r.pn )
+    shared_ptr( shared_ptr<Y> const & r, element_type * p ) BOOST_SP_NOEXCEPT : px( p ), pn( r.pn )
     {
     }
 
@@ -501,9 +518,12 @@ public:
         boost::detail::sp_assert_convertible< Y, T >();
 
         typename std::unique_ptr< Y, D >::pointer tmp = r.get();
-        pn = boost::detail::shared_count( r );
 
-        boost::detail::sp_deleter_construct( this, tmp );
+        if( tmp != 0 )
+        {
+            pn = boost::detail::shared_count( r );
+            boost::detail::sp_deleter_construct( this, tmp );
+        }
     }
 
 #endif
@@ -514,14 +534,17 @@ public:
         boost::detail::sp_assert_convertible< Y, T >();
 
         typename boost::movelib::unique_ptr< Y, D >::pointer tmp = r.get();
-        pn = boost::detail::shared_count( r );
 
-        boost::detail::sp_deleter_construct( this, tmp );
+        if( tmp != 0 )
+        {
+            pn = boost::detail::shared_count( r );
+            boost::detail::sp_deleter_construct( this, tmp );
+        }
     }
 
     // assignment
 
-    shared_ptr & operator=( shared_ptr const & r ) BOOST_NOEXCEPT
+    shared_ptr & operator=( shared_ptr const & r ) BOOST_SP_NOEXCEPT
     {
         this_type(r).swap(*this);
         return *this;
@@ -530,7 +553,7 @@ public:
 #if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1400)
 
     template<class Y>
-    shared_ptr & operator=(shared_ptr<Y> const & r) BOOST_NOEXCEPT
+    shared_ptr & operator=(shared_ptr<Y> const & r) BOOST_SP_NOEXCEPT
     {
         this_type(r).swap(*this);
         return *this;
@@ -591,10 +614,13 @@ public:
 
         shared_ptr tmp;
 
-        tmp.px = p;
-        tmp.pn = boost::detail::shared_count( r );
+        if( p != 0 )
+        {
+            tmp.px = p;
+            tmp.pn = boost::detail::shared_count( r );
 
-        boost::detail::sp_deleter_construct( &tmp, p );
+            boost::detail::sp_deleter_construct( &tmp, p );
+        }
 
         tmp.swap( *this );
 
@@ -605,7 +631,7 @@ public:
 
 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 
-    shared_ptr( shared_ptr && r ) BOOST_NOEXCEPT : px( r.px ), pn()
+    shared_ptr( shared_ptr && r ) BOOST_SP_NOEXCEPT : px( r.px ), pn()
     {
         pn.swap( r.pn );
         r.px = 0;
@@ -621,7 +647,7 @@ public:
     shared_ptr( shared_ptr<Y> && r )
 
 #endif
-    BOOST_NOEXCEPT : px( r.px ), pn()
+    BOOST_SP_NOEXCEPT : px( r.px ), pn()
     {
         boost::detail::sp_assert_convertible< Y, T >();
 
@@ -629,14 +655,14 @@ public:
         r.px = 0;
     }
 
-    shared_ptr & operator=( shared_ptr && r ) BOOST_NOEXCEPT
+    shared_ptr & operator=( shared_ptr && r ) BOOST_SP_NOEXCEPT
     {
         this_type( static_cast< shared_ptr && >( r ) ).swap( *this );
         return *this;
     }
 
     template<class Y>
-    shared_ptr & operator=( shared_ptr<Y> && r ) BOOST_NOEXCEPT
+    shared_ptr & operator=( shared_ptr<Y> && r ) BOOST_SP_NOEXCEPT
     {
         this_type( static_cast< shared_ptr<Y> && >( r ) ).swap( *this );
         return *this;
@@ -644,7 +670,7 @@ public:
 
     // aliasing move
     template<class Y>
-    shared_ptr( shared_ptr<Y> && r, element_type * p ) BOOST_NOEXCEPT : px( p ), pn()
+    shared_ptr( shared_ptr<Y> && r, element_type * p ) BOOST_SP_NOEXCEPT : px( p ), pn()
     {
         pn.swap( r.pn );
         r.px = 0;
@@ -654,7 +680,7 @@ public:
 
 #if !defined( BOOST_NO_CXX11_NULLPTR )
 
-    shared_ptr & operator=( boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT // never throws
+    shared_ptr & operator=( boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
     {
         this_type().swap(*this);
         return *this;
@@ -662,7 +688,7 @@ public:
 
 #endif
 
-    void reset() BOOST_NOEXCEPT // never throws in 1.30+
+    void reset() BOOST_SP_NOEXCEPT
     {
         this_type().swap(*this);
     }
@@ -683,36 +709,33 @@ public:
         this_type( p, d, a ).swap( *this );
     }
 
-    template<class Y> void reset( shared_ptr<Y> const & r, element_type * p )
+    template<class Y> void reset( shared_ptr<Y> const & r, element_type * p ) BOOST_SP_NOEXCEPT
     {
         this_type( r, p ).swap( *this );
     }
 
 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 
-    template<class Y> void reset( shared_ptr<Y> && r, element_type * p )
+    template<class Y> void reset( shared_ptr<Y> && r, element_type * p ) BOOST_SP_NOEXCEPT
     {
         this_type( static_cast< shared_ptr<Y> && >( r ), p ).swap( *this );
     }
 
 #endif
 
-    // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
-    typename boost::detail::sp_dereference< T >::type operator* () const
+    typename boost::detail::sp_dereference< T >::type operator* () const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         return *px;
     }
     
-    // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
-    typename boost::detail::sp_member_access< T >::type operator-> () const 
+    typename boost::detail::sp_member_access< T >::type operator-> () const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         return px;
     }
     
-    // never throws (but has a BOOST_ASSERT in it, so not marked with BOOST_NOEXCEPT)
-    typename boost::detail::sp_array_access< T >::type operator[] ( std::ptrdiff_t i ) const
+    typename boost::detail::sp_array_access< T >::type operator[] ( std::ptrdiff_t i ) const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         BOOST_ASSERT( i >= 0 && ( i < boost::detail::sp_extent< T >::value || boost::detail::sp_extent< T >::value == 0 ) );
@@ -720,7 +743,7 @@ public:
         return static_cast< typename boost::detail::sp_array_access< T >::type >( px[ i ] );
     }
 
-    element_type * get() const BOOST_NOEXCEPT
+    element_type * get() const BOOST_SP_NOEXCEPT
     {
         return px;
     }
@@ -728,47 +751,57 @@ public:
 // implicit conversion to "bool"
 #include <boost/smart_ptr/detail/operator_bool.hpp>
 
-    bool unique() const BOOST_NOEXCEPT
+    bool unique() const BOOST_SP_NOEXCEPT
     {
         return pn.unique();
     }
 
-    long use_count() const BOOST_NOEXCEPT
+    long use_count() const BOOST_SP_NOEXCEPT
     {
         return pn.use_count();
     }
 
-    void swap( shared_ptr & other ) BOOST_NOEXCEPT
+    void swap( shared_ptr & other ) BOOST_SP_NOEXCEPT
     {
         std::swap(px, other.px);
         pn.swap(other.pn);
     }
 
-    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const BOOST_NOEXCEPT
+    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const BOOST_SP_NOEXCEPT
     {
         return pn < rhs.pn;
     }
 
-    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const BOOST_NOEXCEPT
+    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const BOOST_SP_NOEXCEPT
     {
         return pn < rhs.pn;
     }
 
-    void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const BOOST_NOEXCEPT
+    void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const BOOST_SP_NOEXCEPT
     {
         return pn.get_deleter( ti );
     }
 
-    void * _internal_get_untyped_deleter() const BOOST_NOEXCEPT
+    void * _internal_get_local_deleter( boost::detail::sp_typeinfo const & ti ) const BOOST_SP_NOEXCEPT
+    {
+        return pn.get_local_deleter( ti );
+    }
+
+    void * _internal_get_untyped_deleter() const BOOST_SP_NOEXCEPT
     {
         return pn.get_untyped_deleter();
     }
 
-    bool _internal_equiv( shared_ptr const & r ) const BOOST_NOEXCEPT
+    bool _internal_equiv( shared_ptr const & r ) const BOOST_SP_NOEXCEPT
     {
         return px == r.px && pn == r.pn;
     }
 
+    boost::detail::shared_count _internal_count() const BOOST_NOEXCEPT
+    {
+        return pn;
+    }
+
 // Tasteless as this may seem, making all members public allows member templates
 // to work in the absence of member template friends. (Matthew Langston)
 
@@ -787,12 +820,12 @@ private:
 
 };  // shared_ptr
 
-template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b) BOOST_NOEXCEPT
+template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b) BOOST_SP_NOEXCEPT
 {
     return a.get() == b.get();
 }
 
-template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b) BOOST_NOEXCEPT
+template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b) BOOST_SP_NOEXCEPT
 {
     return a.get() != b.get();
 }
@@ -801,7 +834,7 @@ template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, share
 
 // Resolve the ambiguity between our op!= and the one in rel_ops
 
-template<class T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b) BOOST_NOEXCEPT
+template<class T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b) BOOST_SP_NOEXCEPT
 {
     return a.get() != b.get();
 }
@@ -810,39 +843,39 @@ template<class T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T>
 
 #if !defined( BOOST_NO_CXX11_NULLPTR )
 
-template<class T> inline bool operator==( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
+template<class T> inline bool operator==( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator==( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( shared_ptr<T> const & p, boost::detail::sp_nullptr_t ) BOOST_SP_NOEXCEPT
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) BOOST_NOEXCEPT
+template<class T> inline bool operator!=( boost::detail::sp_nullptr_t, shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return p.get() != 0;
 }
 
 #endif
 
-template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b) BOOST_NOEXCEPT
+template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b) BOOST_SP_NOEXCEPT
 {
     return a.owner_before( b );
 }
 
-template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b) BOOST_NOEXCEPT
+template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b) BOOST_SP_NOEXCEPT
 {
     a.swap(b);
 }
 
-template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> const & r ) BOOST_NOEXCEPT
+template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> const & r ) BOOST_SP_NOEXCEPT
 {
     (void) static_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -852,7 +885,7 @@ template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> cons
     return shared_ptr<T>( r, p );
 }
 
-template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> const & r ) BOOST_NOEXCEPT
+template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> const & r ) BOOST_SP_NOEXCEPT
 {
     (void) const_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -862,7 +895,7 @@ template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> const
     return shared_ptr<T>( r, p );
 }
 
-template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> const & r ) BOOST_NOEXCEPT
+template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> const & r ) BOOST_SP_NOEXCEPT
 {
     (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -872,7 +905,7 @@ template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> con
     return p? shared_ptr<T>( r, p ): shared_ptr<T>();
 }
 
-template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U> const & r ) BOOST_NOEXCEPT
+template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U> const & r ) BOOST_SP_NOEXCEPT
 {
     (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
 
@@ -882,9 +915,53 @@ template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U>
     return shared_ptr<T>( r, p );
 }
 
+#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
+template<class T, class U> shared_ptr<T> static_pointer_cast( shared_ptr<U> && r ) BOOST_SP_NOEXCEPT
+{
+    (void) static_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename shared_ptr<T>::element_type E;
+
+    E * p = static_cast< E* >( r.get() );
+    return shared_ptr<T>( std::move(r), p );
+}
+
+template<class T, class U> shared_ptr<T> const_pointer_cast( shared_ptr<U> && r ) BOOST_SP_NOEXCEPT
+{
+    (void) const_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename shared_ptr<T>::element_type E;
+
+    E * p = const_cast< E* >( r.get() );
+    return shared_ptr<T>( std::move(r), p );
+}
+
+template<class T, class U> shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> && r ) BOOST_SP_NOEXCEPT
+{
+    (void) dynamic_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename shared_ptr<T>::element_type E;
+
+    E * p = dynamic_cast< E* >( r.get() );
+    return p? shared_ptr<T>( std::move(r), p ): shared_ptr<T>();
+}
+
+template<class T, class U> shared_ptr<T> reinterpret_pointer_cast( shared_ptr<U> && r ) BOOST_SP_NOEXCEPT
+{
+    (void) reinterpret_cast< T* >( static_cast< U* >( 0 ) );
+
+    typedef typename shared_ptr<T>::element_type E;
+
+    E * p = reinterpret_cast< E* >( r.get() );
+    return shared_ptr<T>( std::move(r), p );
+}
+
+#endif // !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
+
 // get_pointer() enables boost::mem_fn to recognize shared_ptr
 
-template<class T> inline typename shared_ptr<T>::element_type * get_pointer(shared_ptr<T> const & p) BOOST_NOEXCEPT
+template<class T> inline typename shared_ptr<T>::element_type * get_pointer(shared_ptr<T> const & p) BOOST_SP_NOEXCEPT
 {
     return p.get();
 }
@@ -929,27 +1006,13 @@ template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::
 namespace detail
 {
 
-#if ( defined(__GNUC__) && BOOST_WORKAROUND(__GNUC__, < 3) ) || \
-    ( defined(__EDG_VERSION__) && BOOST_WORKAROUND(__EDG_VERSION__, <= 238) ) || \
-    ( defined(__HP_aCC) && BOOST_WORKAROUND(__HP_aCC, <= 33500) )
-
-// g++ 2.9x doesn't allow static_cast<X const *>(void *)
-// apparently EDG 2.38 and HP aCC A.03.35 also don't accept it
-
-template<class D, class T> D * basic_get_deleter(shared_ptr<T> const & p)
-{
-    void const * q = p._internal_get_deleter(BOOST_SP_TYPEID(D));
-    return const_cast<D *>(static_cast<D const *>(q));
-}
-
-#else
-
-template<class D, class T> D * basic_get_deleter( shared_ptr<T> const & p ) BOOST_NOEXCEPT
+template<class D, class T> D * basic_get_deleter( shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return static_cast<D *>( p._internal_get_deleter(BOOST_SP_TYPEID(D)) );
 }
 
-#endif
+template<class D, class T> D * basic_get_local_deleter( D *, shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT;
+template<class D, class T> D const * basic_get_local_deleter( D const *, shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT;
 
 class esft2_deleter_wrapper
 {
@@ -963,17 +1026,17 @@ public:
     {
     }
 
-    template< class T > void set_deleter( shared_ptr<T> const & deleter )
+    template< class T > void set_deleter( shared_ptr<T> const & deleter ) BOOST_SP_NOEXCEPT
     {
         deleter_ = deleter;
     }
 
-    template<typename D> D* get_deleter() const BOOST_NOEXCEPT
+    template<typename D> D* get_deleter() const BOOST_SP_NOEXCEPT
     {
         return boost::detail::basic_get_deleter<D>( deleter_ );
     }
 
-    template< class T> void operator()( T* )
+    template< class T> void operator()( T* ) BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( deleter_.use_count() <= 1 );
         deleter_.reset();
@@ -982,53 +1045,58 @@ public:
 
 } // namespace detail
 
-template<class D, class T> D * get_deleter( shared_ptr<T> const & p ) BOOST_NOEXCEPT
+template<class D, class T> D * get_deleter( shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
-    D *del = boost::detail::basic_get_deleter<D>(p);
+    D * d = boost::detail::basic_get_deleter<D>( p );
 
-    if(del == 0)
+    if( d == 0 )
+    {
+        d = boost::detail::basic_get_local_deleter( d, p );
+    }
+
+    if( d == 0 )
     {
         boost::detail::esft2_deleter_wrapper *del_wrapper = boost::detail::basic_get_deleter<boost::detail::esft2_deleter_wrapper>(p);
 // The following get_deleter method call is fully qualified because
 // older versions of gcc (2.95, 3.2.3) fail to compile it when written del_wrapper->get_deleter<D>()
-        if(del_wrapper) del = del_wrapper->::boost::detail::esft2_deleter_wrapper::get_deleter<D>();
+        if(del_wrapper) d = del_wrapper->::boost::detail::esft2_deleter_wrapper::get_deleter<D>();
     }
 
-    return del;
+    return d;
 }
 
 // atomic access
 
 #if !defined(BOOST_SP_NO_ATOMIC_ACCESS)
 
-template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * /*p*/ ) BOOST_NOEXCEPT
+template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * /*p*/ ) BOOST_SP_NOEXCEPT
 {
     return false;
 }
 
-template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p )
+template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p ) BOOST_SP_NOEXCEPT
 {
     boost::detail::spinlock_pool<2>::scoped_lock lock( p );
     return *p;
 }
 
-template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, /*memory_order mo*/ int )
+template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, /*memory_order mo*/ int ) BOOST_SP_NOEXCEPT
 {
     return atomic_load( p );
 }
 
-template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r )
+template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r ) BOOST_SP_NOEXCEPT
 {
     boost::detail::spinlock_pool<2>::scoped_lock lock( p );
     p->swap( r );
 }
 
-template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, /*memory_order mo*/ int )
+template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, /*memory_order mo*/ int ) BOOST_SP_NOEXCEPT
 {
     atomic_store( p, r ); // std::move( r )
 }
 
-template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r )
+template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r ) BOOST_SP_NOEXCEPT
 {
     boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
 
@@ -1039,12 +1107,12 @@ template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T
     return r; // return std::move( r )
 }
 
-template<class T> shared_ptr<T> atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, /*memory_order mo*/ int )
+template<class T> shared_ptr<T> inline atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, /*memory_order mo*/ int ) BOOST_SP_NOEXCEPT
 {
     return atomic_exchange( p, r ); // std::move( r )
 }
 
-template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w )
+template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w ) BOOST_SP_NOEXCEPT
 {
     boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );
 
@@ -1069,7 +1137,7 @@ template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T>
     }
 }
 
-template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, /*memory_order success*/ int, /*memory_order failure*/ int )
+template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, /*memory_order success*/ int, /*memory_order failure*/ int ) BOOST_SP_NOEXCEPT
 {
     return atomic_compare_exchange( p, v, w ); // std::move( w )
 }
@@ -1080,13 +1148,35 @@ template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> *
 
 template< class T > struct hash;
 
-template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p ) BOOST_NOEXCEPT
+template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
 {
     return boost::hash< typename boost::shared_ptr<T>::element_type* >()( p.get() );
 }
 
 } // namespace boost
 
+#include <boost/smart_ptr/detail/local_sp_deleter.hpp>
+
+namespace boost
+{
+
+namespace detail
+{
+
+template<class D, class T> D * basic_get_local_deleter( D *, shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+{
+    return static_cast<D *>( p._internal_get_local_deleter( BOOST_SP_TYPEID(local_sp_deleter<D>) ) );
+}
+
+template<class D, class T> D const * basic_get_local_deleter( D const *, shared_ptr<T> const & p ) BOOST_SP_NOEXCEPT
+{
+    return static_cast<D *>( p._internal_get_local_deleter( BOOST_SP_TYPEID(local_sp_deleter<D>) ) );
+}
+
+} // namespace detail
+
+} // namespace boost
+
 #if defined( BOOST_SP_DISABLE_DEPRECATED )
 #pragma GCC diagnostic pop
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/smart_ptr/weak_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/smart_ptr/weak_ptr.hpp
similarity index 74%
rename from contrib/libboost/boost_1_62_0/boost/smart_ptr/weak_ptr.hpp
rename to contrib/libboost/boost_1_65_0/boost/smart_ptr/weak_ptr.hpp
index e3e9ad9bde5..54d9ef37812 100644
--- a/contrib/libboost/boost_1_62_0/boost/smart_ptr/weak_ptr.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/smart_ptr/weak_ptr.hpp
@@ -6,16 +6,17 @@
 //
 //  Copyright (c) 2001, 2002, 2003 Peter Dimov
 //
-// 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)
+//  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/smart_ptr/weak_ptr.htm for documentation.
+//  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
 #include <memory> // boost.TR1 include order fix
 #include <boost/smart_ptr/detail/shared_count.hpp>
 #include <boost/smart_ptr/shared_ptr.hpp>
+#include <boost/smart_ptr/detail/sp_noexcept.hpp>
 
 namespace boost
 {
@@ -31,7 +32,7 @@ public:
 
     typedef typename boost::detail::sp_element< T >::type element_type;
 
-    weak_ptr() BOOST_NOEXCEPT : px(0), pn() // never throws in 1.30+
+    BOOST_CONSTEXPR weak_ptr() BOOST_SP_NOEXCEPT : px(0), pn()
     {
     }
 
@@ -41,11 +42,11 @@ public:
 
 // ... except in C++0x, move disables the implicit copy
 
-    weak_ptr( weak_ptr const & r ) BOOST_NOEXCEPT : px( r.px ), pn( r.pn )
+    weak_ptr( weak_ptr const & r ) BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
     {
     }
 
-    weak_ptr & operator=( weak_ptr const & r ) BOOST_NOEXCEPT
+    weak_ptr & operator=( weak_ptr const & r ) BOOST_SP_NOEXCEPT
     {
         px = r.px;
         pn = r.pn;
@@ -58,7 +59,7 @@ public:
 //  The "obvious" converting constructor implementation:
 //
 //  template<class Y>
-//  weak_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
+//  weak_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn)
 //  {
 //  }
 //
@@ -81,7 +82,7 @@ public:
     weak_ptr( weak_ptr<Y> const & r )
 
 #endif
-    BOOST_NOEXCEPT : px(r.lock().get()), pn(r.pn)
+    BOOST_SP_NOEXCEPT : px(r.lock().get()), pn(r.pn)
     {
         boost::detail::sp_assert_convertible< Y, T >();
     }
@@ -98,7 +99,7 @@ public:
     weak_ptr( weak_ptr<Y> && r )
 
 #endif
-    BOOST_NOEXCEPT : px( r.lock().get() ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
+    BOOST_SP_NOEXCEPT : px( r.lock().get() ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
     {
         boost::detail::sp_assert_convertible< Y, T >();
         r.px = 0;
@@ -106,13 +107,13 @@ public:
 
     // for better efficiency in the T == Y case
     weak_ptr( weak_ptr && r )
-    BOOST_NOEXCEPT : px( r.px ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
+    BOOST_SP_NOEXCEPT : px( r.px ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
     {
         r.px = 0;
     }
 
     // for better efficiency in the T == Y case
-    weak_ptr & operator=( weak_ptr && r ) BOOST_NOEXCEPT
+    weak_ptr & operator=( weak_ptr && r ) BOOST_SP_NOEXCEPT
     {
         this_type( static_cast< weak_ptr && >( r ) ).swap( *this );
         return *this;
@@ -131,7 +132,7 @@ public:
     weak_ptr( shared_ptr<Y> const & r )
 
 #endif
-    BOOST_NOEXCEPT : px( r.px ), pn( r.pn )
+    BOOST_SP_NOEXCEPT : px( r.px ), pn( r.pn )
     {
         boost::detail::sp_assert_convertible< Y, T >();
     }
@@ -139,7 +140,7 @@ public:
 #if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1300)
 
     template<class Y>
-    weak_ptr & operator=( weak_ptr<Y> const & r ) BOOST_NOEXCEPT
+    weak_ptr & operator=( weak_ptr<Y> const & r ) BOOST_SP_NOEXCEPT
     {
         boost::detail::sp_assert_convertible< Y, T >();
 
@@ -152,7 +153,7 @@ public:
 #if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
 
     template<class Y>
-    weak_ptr & operator=( weak_ptr<Y> && r ) BOOST_NOEXCEPT
+    weak_ptr & operator=( weak_ptr<Y> && r ) BOOST_SP_NOEXCEPT
     {
         this_type( static_cast< weak_ptr<Y> && >( r ) ).swap( *this );
         return *this;
@@ -161,7 +162,7 @@ public:
 #endif
 
     template<class Y>
-    weak_ptr & operator=( shared_ptr<Y> const & r ) BOOST_NOEXCEPT
+    weak_ptr & operator=( shared_ptr<Y> const & r ) BOOST_SP_NOEXCEPT
     {
         boost::detail::sp_assert_convertible< Y, T >();
 
@@ -173,50 +174,50 @@ public:
 
 #endif
 
-    shared_ptr<T> lock() const BOOST_NOEXCEPT
+    shared_ptr<T> lock() const BOOST_SP_NOEXCEPT
     {
         return shared_ptr<T>( *this, boost::detail::sp_nothrow_tag() );
     }
 
-    long use_count() const BOOST_NOEXCEPT
+    long use_count() const BOOST_SP_NOEXCEPT
     {
         return pn.use_count();
     }
 
-    bool expired() const BOOST_NOEXCEPT
+    bool expired() const BOOST_SP_NOEXCEPT
     {
         return pn.use_count() == 0;
     }
 
-    bool _empty() const // extension, not in std::weak_ptr
+    bool _empty() const BOOST_SP_NOEXCEPT // extension, not in std::weak_ptr
     {
         return pn.empty();
     }
 
-    void reset() BOOST_NOEXCEPT // never throws in 1.30+
+    void reset() BOOST_SP_NOEXCEPT
     {
         this_type().swap(*this);
     }
 
-    void swap(this_type & other) BOOST_NOEXCEPT
+    void swap(this_type & other) BOOST_SP_NOEXCEPT
     {
         std::swap(px, other.px);
         pn.swap(other.pn);
     }
 
     template<typename Y>
-    void _internal_aliasing_assign(weak_ptr<Y> const & r, element_type * px2)
+    void _internal_aliasing_assign(weak_ptr<Y> const & r, element_type * px2) BOOST_SP_NOEXCEPT
     {
         px = px2;
         pn = r.pn;
     }
 
-    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const BOOST_NOEXCEPT
+    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const BOOST_SP_NOEXCEPT
     {
         return pn < rhs.pn;
     }
 
-    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const BOOST_NOEXCEPT
+    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const BOOST_SP_NOEXCEPT
     {
         return pn < rhs.pn;
     }
@@ -238,12 +239,12 @@ private:
 
 };  // weak_ptr
 
-template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b) BOOST_NOEXCEPT
+template<class T, class U> inline bool operator<(weak_ptr<T> const & a, weak_ptr<U> const & b) BOOST_SP_NOEXCEPT
 {
     return a.owner_before( b );
 }
 
-template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b) BOOST_NOEXCEPT
+template<class T> void swap(weak_ptr<T> & a, weak_ptr<T> & b) BOOST_SP_NOEXCEPT
 {
     a.swap(b);
 }
diff --git a/contrib/libboost/boost_1_62_0/boost/static_assert.hpp b/contrib/libboost/boost_1_65_0/boost/static_assert.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/static_assert.hpp
rename to contrib/libboost/boost_1_65_0/boost/static_assert.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/swap.hpp b/contrib/libboost/boost_1_65_0/boost/swap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/swap.hpp
rename to contrib/libboost/boost_1_65_0/boost/swap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/system/api_config.hpp b/contrib/libboost/boost_1_65_0/boost/system/api_config.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/system/api_config.hpp
rename to contrib/libboost/boost_1_65_0/boost/system/api_config.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/system/config.hpp b/contrib/libboost/boost_1_65_0/boost/system/config.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/system/config.hpp
rename to contrib/libboost/boost_1_65_0/boost/system/config.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/system/cygwin_error.hpp b/contrib/libboost/boost_1_65_0/boost/system/cygwin_error.hpp
similarity index 92%
rename from contrib/libboost/boost_1_62_0/boost/system/cygwin_error.hpp
rename to contrib/libboost/boost_1_65_0/boost/system/cygwin_error.hpp
index ea3528b66d0..4f91cf3d730 100644
--- a/contrib/libboost/boost_1_62_0/boost/system/cygwin_error.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/system/cygwin_error.hpp
@@ -7,8 +7,8 @@
 
 //  See library home page at http://www.boost.org/libs/system
 
-#ifndef BOOST_CYGWIN_ERROR_HPP
-#define BOOST_CYGWIN_ERROR_HPP
+#ifndef BOOST_SYSTEM_CYGWIN_ERROR_HPP
+#define BOOST_SYSTEM_CYGWIN_ERROR_HPP
 
 //  This header is effectively empty for compiles on operating systems where
 //  it is not applicable.
@@ -53,4 +53,4 @@ namespace boost
 
 #endif  // __CYGWIN__
 
-#endif  // BOOST_CYGWIN_ERROR_HPP
+#endif  // BOOST_SYSTEM_CYGWIN_ERROR_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/system/detail/error_code.ipp b/contrib/libboost/boost_1_65_0/boost/system/detail/error_code.ipp
similarity index 65%
rename from contrib/libboost/boost_1_62_0/boost/system/detail/error_code.ipp
rename to contrib/libboost/boost_1_65_0/boost/system/detail/error_code.ipp
index 71c60f61da0..51ba3f4747e 100644
--- a/contrib/libboost/boost_1_62_0/boost/system/detail/error_code.ipp
+++ b/contrib/libboost/boost_1_65_0/boost/system/detail/error_code.ipp
@@ -1,4 +1,4 @@
-//  error_code support implementation file  ----------------------------------//
+//  error_code support implementation file  --------------------------------------------//
 
 //  Copyright Beman Dawes 2002, 2006
 //  Copyright (c) Microsoft Corporation 2014
@@ -7,7 +7,7 @@
 
 //  See library home page at http://www.boost.org/libs/system
 
-//----------------------------------------------------------------------------//
+//--------------------------------------------------------------------------------------//
 
 #include <boost/config/warning_disable.hpp>
 
@@ -21,7 +21,9 @@
 #include <cstring> // for strerror/strerror_r
 
 # if defined( BOOST_WINDOWS_API )
-#   include <windows.h>
+#   include <boost/detail/winapi/error_codes.hpp>
+#   include <boost/detail/winapi/error_handling.hpp>
+#   include <boost/detail/winapi/character_code_conversion.hpp>
 #   if !BOOST_PLAT_WINDOWS_RUNTIME
 #     include <boost/system/detail/local_free_on_destruction.hpp>
 #   endif
@@ -30,7 +32,7 @@
 #   endif
 # endif
 
-//----------------------------------------------------------------------------//
+//--------------------------------------------------------------------------------------//
 namespace boost
 {
     namespace system
@@ -39,7 +41,7 @@ namespace boost
 namespace
 {
 
-  //  standard error categories  ---------------------------------------------//
+  //  standard error categories  -------------------------------------------------------//
 
   class generic_error_category : public error_category
   {
@@ -84,7 +86,8 @@ namespace
   //   -- VMS doesn't provide strerror_r, but on this platform, strerror is
   //      thread safe.
   # if defined(BOOST_WINDOWS_API) || defined(__hpux) || defined(__sun)\
-     || (defined(__linux) && (!defined(__USE_XOPEN2K) || defined(BOOST_SYSTEM_USE_STRERROR)))\
+     || (defined(__linux) && (!defined(__USE_XOPEN2K)\
+     || defined(BOOST_SYSTEM_USE_STRERROR)))\
      || (defined(__osf__) && !defined(_REENTRANT))\
      || (defined(__INTEGRITY))\
      || (defined(__vms))\
@@ -156,14 +159,15 @@ namespace
   #  endif   // else POSIX version of strerror_r
   # endif  // else use strerror_r
   }
-  //  system_error_category implementation  --------------------------------//
+  //  system_error_category implementation  --------------------------------------------//
 
   const char * system_error_category::name() const BOOST_SYSTEM_NOEXCEPT
   {
     return "system";
   }
 
-  error_condition system_error_category::default_error_condition( int ev ) const BOOST_SYSTEM_NOEXCEPT
+  error_condition system_error_category::default_error_condition( int ev ) const
+    BOOST_SYSTEM_NOEXCEPT
   {
     using namespace boost::system::errc;
 #if defined(__PGI)
@@ -179,13 +183,19 @@ namespace
       if ( HRESULT_FACILITY( ev ) == FACILITY_WIN32 )
         ev = HRESULT_CODE( ev );
 #   endif
+# endif
+
+# if defined(BOOST_WINDOWS_API)
+
+    using namespace boost::detail::winapi; // for error codes
+
 # endif
 
     switch ( ev )
     {
     case 0: return make_error_condition( success );
 # if defined(BOOST_POSIX_API)
-    // POSIX-like O/S -> posix_errno decode table  ---------------------------//
+    // POSIX-like O/S -> posix_errno decode table  -------------------------------------//
     case E2BIG: return make_error_condition( argument_list_too_long );
     case EACCES: return make_error_condition( permission_denied );
     case EADDRINUSE: return make_error_condition( address_in_use );
@@ -279,80 +289,81 @@ namespace
   #else
     // Windows system -> posix_errno decode table  ---------------------------//
     // see WinError.h comments for descriptions of errors
-    case ERROR_ACCESS_DENIED: return make_error_condition( permission_denied );
-    case ERROR_ALREADY_EXISTS: return make_error_condition( file_exists );
-    case ERROR_BAD_UNIT: return make_error_condition( no_such_device );
-    case ERROR_BUFFER_OVERFLOW: return make_error_condition( filename_too_long );
-    case ERROR_BUSY: return make_error_condition( device_or_resource_busy );
-    case ERROR_BUSY_DRIVE: return make_error_condition( device_or_resource_busy );
-    case ERROR_CANNOT_MAKE: return make_error_condition( permission_denied );
-    case ERROR_CANTOPEN: return make_error_condition( io_error );
-    case ERROR_CANTREAD: return make_error_condition( io_error );
-    case ERROR_CANTWRITE: return make_error_condition( io_error );
-    case ERROR_CURRENT_DIRECTORY: return make_error_condition( permission_denied );
-    case ERROR_DEV_NOT_EXIST: return make_error_condition( no_such_device );
-    case ERROR_DEVICE_IN_USE: return make_error_condition( device_or_resource_busy );
-    case ERROR_DIR_NOT_EMPTY: return make_error_condition( directory_not_empty );
-    case ERROR_DIRECTORY: return make_error_condition( invalid_argument ); // WinError.h: "The directory name is invalid"
-    case ERROR_DISK_FULL: return make_error_condition( no_space_on_device );
-    case ERROR_FILE_EXISTS: return make_error_condition( file_exists );
-    case ERROR_FILE_NOT_FOUND: return make_error_condition( no_such_file_or_directory );
-    case ERROR_HANDLE_DISK_FULL: return make_error_condition( no_space_on_device );
-    case ERROR_INVALID_ACCESS: return make_error_condition( permission_denied );
-    case ERROR_INVALID_DRIVE: return make_error_condition( no_such_device );
-    case ERROR_INVALID_FUNCTION: return make_error_condition( function_not_supported );
-    case ERROR_INVALID_HANDLE: return make_error_condition( invalid_argument );
-    case ERROR_INVALID_NAME: return make_error_condition( invalid_argument );
-    case ERROR_LOCK_VIOLATION: return make_error_condition( no_lock_available );
-    case ERROR_LOCKED: return make_error_condition( no_lock_available );
-    case ERROR_NEGATIVE_SEEK: return make_error_condition( invalid_argument );
-    case ERROR_NOACCESS: return make_error_condition( permission_denied );
-    case ERROR_NOT_ENOUGH_MEMORY: return make_error_condition( not_enough_memory );
-    case ERROR_NOT_READY: return make_error_condition( resource_unavailable_try_again );
-    case ERROR_NOT_SAME_DEVICE: return make_error_condition( cross_device_link );
-    case ERROR_OPEN_FAILED: return make_error_condition( io_error );
-    case ERROR_OPEN_FILES: return make_error_condition( device_or_resource_busy );
-    case ERROR_OPERATION_ABORTED: return make_error_condition( operation_canceled );
-    case ERROR_OUTOFMEMORY: return make_error_condition( not_enough_memory );
-    case ERROR_PATH_NOT_FOUND: return make_error_condition( no_such_file_or_directory );
-    case ERROR_READ_FAULT: return make_error_condition( io_error );
-    case ERROR_RETRY: return make_error_condition( resource_unavailable_try_again );
-    case ERROR_SEEK: return make_error_condition( io_error );
-    case ERROR_SHARING_VIOLATION: return make_error_condition( permission_denied );
-    case ERROR_TOO_MANY_OPEN_FILES: return make_error_condition( too_many_files_open );
-    case ERROR_WRITE_FAULT: return make_error_condition( io_error );
-    case ERROR_WRITE_PROTECT: return make_error_condition( permission_denied );
-    case WSAEACCES: return make_error_condition( permission_denied );
-    case WSAEADDRINUSE: return make_error_condition( address_in_use );
-    case WSAEADDRNOTAVAIL: return make_error_condition( address_not_available );
-    case WSAEAFNOSUPPORT: return make_error_condition( address_family_not_supported );
-    case WSAEALREADY: return make_error_condition( connection_already_in_progress );
-    case WSAEBADF: return make_error_condition( bad_file_descriptor );
-    case WSAECONNABORTED: return make_error_condition( connection_aborted );
-    case WSAECONNREFUSED: return make_error_condition( connection_refused );
-    case WSAECONNRESET: return make_error_condition( connection_reset );
-    case WSAEDESTADDRREQ: return make_error_condition( destination_address_required );
-    case WSAEFAULT: return make_error_condition( bad_address );
-    case WSAEHOSTUNREACH: return make_error_condition( host_unreachable );
-    case WSAEINPROGRESS: return make_error_condition( operation_in_progress );
-    case WSAEINTR: return make_error_condition( interrupted );
-    case WSAEINVAL: return make_error_condition( invalid_argument );
-    case WSAEISCONN: return make_error_condition( already_connected );
-    case WSAEMFILE: return make_error_condition( too_many_files_open );
-    case WSAEMSGSIZE: return make_error_condition( message_size );
-    case WSAENAMETOOLONG: return make_error_condition( filename_too_long );
-    case WSAENETDOWN: return make_error_condition( network_down );
-    case WSAENETRESET: return make_error_condition( network_reset );
-    case WSAENETUNREACH: return make_error_condition( network_unreachable );
-    case WSAENOBUFS: return make_error_condition( no_buffer_space );
-    case WSAENOPROTOOPT: return make_error_condition( no_protocol_option );
-    case WSAENOTCONN: return make_error_condition( not_connected );
-    case WSAENOTSOCK: return make_error_condition( not_a_socket );
-    case WSAEOPNOTSUPP: return make_error_condition( operation_not_supported );
-    case WSAEPROTONOSUPPORT: return make_error_condition( protocol_not_supported );
-    case WSAEPROTOTYPE: return make_error_condition( wrong_protocol_type );
-    case WSAETIMEDOUT: return make_error_condition( timed_out );
-    case WSAEWOULDBLOCK: return make_error_condition( operation_would_block );
+    case ERROR_ACCESS_DENIED_: return make_error_condition( permission_denied );
+    case ERROR_ALREADY_EXISTS_: return make_error_condition( file_exists );
+    case ERROR_BAD_UNIT_: return make_error_condition( no_such_device );
+    case ERROR_BUFFER_OVERFLOW_: return make_error_condition( filename_too_long );
+    case ERROR_BUSY_: return make_error_condition( device_or_resource_busy );
+    case ERROR_BUSY_DRIVE_: return make_error_condition( device_or_resource_busy );
+    case ERROR_CANNOT_MAKE_: return make_error_condition( permission_denied );
+    case ERROR_CANTOPEN_: return make_error_condition( io_error );
+    case ERROR_CANTREAD_: return make_error_condition( io_error );
+    case ERROR_CANTWRITE_: return make_error_condition( io_error );
+    case ERROR_CURRENT_DIRECTORY_: return make_error_condition( permission_denied );
+    case ERROR_DEV_NOT_EXIST_: return make_error_condition( no_such_device );
+    case ERROR_DEVICE_IN_USE_: return make_error_condition( device_or_resource_busy );
+    case ERROR_DIR_NOT_EMPTY_: return make_error_condition( directory_not_empty );
+    case ERROR_DIRECTORY_: return make_error_condition( invalid_argument );\
+      // WinError.h: "The directory name is invalid"
+    case ERROR_DISK_FULL_: return make_error_condition( no_space_on_device );
+    case ERROR_FILE_EXISTS_: return make_error_condition( file_exists );
+    case ERROR_FILE_NOT_FOUND_: return make_error_condition( no_such_file_or_directory );
+    case ERROR_HANDLE_DISK_FULL_: return make_error_condition( no_space_on_device );
+    case ERROR_INVALID_ACCESS_: return make_error_condition( permission_denied );
+    case ERROR_INVALID_DRIVE_: return make_error_condition( no_such_device );
+    case ERROR_INVALID_FUNCTION_: return make_error_condition( function_not_supported );
+    case ERROR_INVALID_HANDLE_: return make_error_condition( invalid_argument );
+    case ERROR_INVALID_NAME_: return make_error_condition( invalid_argument );
+    case ERROR_LOCK_VIOLATION_: return make_error_condition( no_lock_available );
+    case ERROR_LOCKED_: return make_error_condition( no_lock_available );
+    case ERROR_NEGATIVE_SEEK_: return make_error_condition( invalid_argument );
+    case ERROR_NOACCESS_: return make_error_condition( permission_denied );
+    case ERROR_NOT_ENOUGH_MEMORY_: return make_error_condition( not_enough_memory );
+    case ERROR_NOT_READY_: return make_error_condition( resource_unavailable_try_again );
+    case ERROR_NOT_SAME_DEVICE_: return make_error_condition( cross_device_link );
+    case ERROR_OPEN_FAILED_: return make_error_condition( io_error );
+    case ERROR_OPEN_FILES_: return make_error_condition( device_or_resource_busy );
+    case ERROR_OPERATION_ABORTED_: return make_error_condition( operation_canceled );
+    case ERROR_OUTOFMEMORY_: return make_error_condition( not_enough_memory );
+    case ERROR_PATH_NOT_FOUND_: return make_error_condition( no_such_file_or_directory );
+    case ERROR_READ_FAULT_: return make_error_condition( io_error );
+    case ERROR_RETRY_: return make_error_condition( resource_unavailable_try_again );
+    case ERROR_SEEK_: return make_error_condition( io_error );
+    case ERROR_SHARING_VIOLATION_: return make_error_condition( permission_denied );
+    case ERROR_TOO_MANY_OPEN_FILES_: return make_error_condition( too_many_files_open );
+    case ERROR_WRITE_FAULT_: return make_error_condition( io_error );
+    case ERROR_WRITE_PROTECT_: return make_error_condition( permission_denied );
+    case WSAEACCES_: return make_error_condition( permission_denied );
+    case WSAEADDRINUSE_: return make_error_condition( address_in_use );
+    case WSAEADDRNOTAVAIL_: return make_error_condition( address_not_available );
+    case WSAEAFNOSUPPORT_: return make_error_condition( address_family_not_supported );
+    case WSAEALREADY_: return make_error_condition( connection_already_in_progress );
+    case WSAEBADF_: return make_error_condition( bad_file_descriptor );
+    case WSAECONNABORTED_: return make_error_condition( connection_aborted );
+    case WSAECONNREFUSED_: return make_error_condition( connection_refused );
+    case WSAECONNRESET_: return make_error_condition( connection_reset );
+    case WSAEDESTADDRREQ_: return make_error_condition( destination_address_required );
+    case WSAEFAULT_: return make_error_condition( bad_address );
+    case WSAEHOSTUNREACH_: return make_error_condition( host_unreachable );
+    case WSAEINPROGRESS_: return make_error_condition( operation_in_progress );
+    case WSAEINTR_: return make_error_condition( interrupted );
+    case WSAEINVAL_: return make_error_condition( invalid_argument );
+    case WSAEISCONN_: return make_error_condition( already_connected );
+    case WSAEMFILE_: return make_error_condition( too_many_files_open );
+    case WSAEMSGSIZE_: return make_error_condition( message_size );
+    case WSAENAMETOOLONG_: return make_error_condition( filename_too_long );
+    case WSAENETDOWN_: return make_error_condition( network_down );
+    case WSAENETRESET_: return make_error_condition( network_reset );
+    case WSAENETUNREACH_: return make_error_condition( network_unreachable );
+    case WSAENOBUFS_: return make_error_condition( no_buffer_space );
+    case WSAENOPROTOOPT_: return make_error_condition( no_protocol_option );
+    case WSAENOTCONN_: return make_error_condition( not_connected );
+    case WSAENOTSOCK_: return make_error_condition( not_a_socket );
+    case WSAEOPNOTSUPP_: return make_error_condition( operation_not_supported );
+    case WSAEPROTONOSUPPORT_: return make_error_condition( protocol_not_supported );
+    case WSAEPROTOTYPE_: return make_error_condition( wrong_protocol_type );
+    case WSAETIMEDOUT_: return make_error_condition( timed_out );
+    case WSAEWOULDBLOCK_: return make_error_condition( operation_would_block );
   #endif
     default: return error_condition( ev, system_category() );
     }
@@ -372,12 +383,13 @@ namespace
     std::wstring buf(128, wchar_t());
     for (;;)
     {
-        DWORD retval = ::FormatMessageW(
-            FORMAT_MESSAGE_FROM_SYSTEM |
-            FORMAT_MESSAGE_IGNORE_INSERTS,
+        boost::detail::winapi::DWORD_ retval = boost::detail::winapi::FormatMessageW(
+            boost::detail::winapi::FORMAT_MESSAGE_FROM_SYSTEM_ |
+            boost::detail::winapi::FORMAT_MESSAGE_IGNORE_INSERTS_,
             NULL,
             ev,
-            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
+            boost::detail::winapi::MAKELANGID_(boost::detail::winapi::LANG_NEUTRAL_,
+            boost::detail::winapi::SUBLANG_DEFAULT_), // Default language
             &buf[0],
             buf.size(),
             NULL
@@ -388,7 +400,8 @@ namespace
             buf.resize(retval);
             break;
         }
-        else if ( ::GetLastError() != ERROR_INSUFFICIENT_BUFFER )
+        else if (boost::detail::winapi::GetLastError() !=
+          boost::detail::winapi::ERROR_INSUFFICIENT_BUFFER_)
         {
             return std::string("Unknown error");
         }
@@ -399,23 +412,26 @@ namespace
     }
     
     int num_chars = (buf.size() + 1) * 2;
-    LPSTR narrow_buffer = (LPSTR)_alloca( num_chars );
-    if (::WideCharToMultiByte(CP_ACP, 0, buf.c_str(), -1, narrow_buffer, num_chars, NULL, NULL) == 0)
+    boost::detail::winapi::LPSTR_ narrow_buffer =
+      (boost::detail::winapi::LPSTR_)_alloca(num_chars);
+    if (boost::detail::winapi::WideCharToMultiByte(boost::detail::winapi::CP_ACP_, 0,
+      buf.c_str(), -1, narrow_buffer, num_chars, NULL, NULL) == 0)
     {
         return std::string("Unknown error");
     }
 
     std::string str( narrow_buffer );
 #else
-    LPVOID lpMsgBuf = 0;
-    DWORD retval = ::FormatMessageA(
-        FORMAT_MESSAGE_ALLOCATE_BUFFER |
-        FORMAT_MESSAGE_FROM_SYSTEM |
-        FORMAT_MESSAGE_IGNORE_INSERTS,
+    boost::detail::winapi::LPVOID_ lpMsgBuf = 0;
+    boost::detail::winapi::DWORD_ retval = boost::detail::winapi::FormatMessageA(
+        boost::detail::winapi::FORMAT_MESSAGE_ALLOCATE_BUFFER_ |
+        boost::detail::winapi::FORMAT_MESSAGE_FROM_SYSTEM_ |
+        boost::detail::winapi::FORMAT_MESSAGE_IGNORE_INSERTS_,
         NULL,
         ev,
-        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
-        (LPSTR) &lpMsgBuf,
+        boost::detail::winapi::MAKELANGID_(boost::detail::winapi::LANG_NEUTRAL_,
+        boost::detail::winapi::SUBLANG_DEFAULT_), // Default language
+        (boost::detail::winapi::LPSTR_) &lpMsgBuf,
         0,
         NULL
     );
@@ -423,7 +439,7 @@ namespace
     if (retval == 0)
         return std::string("Unknown error");
 
-    std::string str( static_cast<LPCSTR>(lpMsgBuf) );
+    std::string str(static_cast<boost::detail::winapi::LPCSTR_>(lpMsgBuf));
 # endif
     while ( str.size()
       && (str[str.size()-1] == '\n' || str[str.size()-1] == '\r') )
diff --git a/contrib/libboost/boost_1_62_0/boost/system/detail/local_free_on_destruction.hpp b/contrib/libboost/boost_1_65_0/boost/system/detail/local_free_on_destruction.hpp
similarity index 92%
rename from contrib/libboost/boost_1_62_0/boost/system/detail/local_free_on_destruction.hpp
rename to contrib/libboost/boost_1_65_0/boost/system/detail/local_free_on_destruction.hpp
index 110024f3d57..25f879b3b0f 100644
--- a/contrib/libboost/boost_1_62_0/boost/system/detail/local_free_on_destruction.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/system/detail/local_free_on_destruction.hpp
@@ -12,6 +12,8 @@
 #ifndef BOOST_SYSTEM_LOCAL_FREE_ON_EXIT_HPP
 #define BOOST_SYSTEM_LOCAL_FREE_ON_EXIT_HPP
 
+#include <boost/detail/winapi/local_memory.hpp>
+
 namespace boost {
 namespace system {
 namespace detail {
@@ -24,7 +26,7 @@ public:
 
   ~local_free_on_destruction()
   {
-    ::LocalFree(p_);
+    boost::detail::winapi::LocalFree(p_);
   }
 
 private:
diff --git a/contrib/libboost/boost_1_62_0/boost/system/error_code.hpp b/contrib/libboost/boost_1_65_0/boost/system/error_code.hpp
similarity index 71%
rename from contrib/libboost/boost_1_62_0/boost/system/error_code.hpp
rename to contrib/libboost/boost_1_65_0/boost/system/error_code.hpp
index d419f3701b1..0d64b2b72ed 100644
--- a/contrib/libboost/boost_1_62_0/boost/system/error_code.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/system/error_code.hpp
@@ -1,4 +1,4 @@
-//  boost/system/error_code.hpp  ---------------------------------------------//
+//  boost/system/error_code.hpp  -------------------------------------------------------//
 
 //  Copyright Beman Dawes 2006, 2007
 //  Copyright Christoper Kohlhoff 2007
@@ -8,8 +8,8 @@
 
 //  See library home page at http://www.boost.org/libs/system
 
-#ifndef BOOST_ERROR_CODE_HPP
-#define BOOST_ERROR_CODE_HPP
+#ifndef BOOST_SYSTEM_ERROR_CODE_HPP
+#define BOOST_SYSTEM_ERROR_CODE_HPP
 
 #include <boost/system/config.hpp>
 #include <boost/cstdint.hpp>
@@ -28,6 +28,10 @@
 #  error BOOST_POSIX_API or BOOST_WINDOWS_API must be defined
 #endif
 
+#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+#include <system_error>
+#endif
+
 #include <boost/config/abi_prefix.hpp> // must be the last #include
 
 #ifndef BOOST_SYSTEM_NOEXCEPT
@@ -39,10 +43,11 @@ namespace boost
   namespace system
   {
 
-    class error_code;
-    class error_condition;
+    class error_code;         // values defined by the operating system
+    class error_condition;    // portable generic values defined below, but ultimately
+                              // based on the POSIX standard
 
-    //  "Concept" helpers  ---------------------------------------------------//
+    //  "Concept" helpers  -------------------------------------------------------------//
 
     template< class T >
     struct is_error_code_enum { static const bool value = false; };
@@ -50,7 +55,7 @@ namespace boost
     template< class T >
     struct is_error_condition_enum { static const bool value = false; };
 
-    //  generic error_conditions  --------------------------------------------//
+    //  generic error_conditions  ------------------------------------------------------//
 
     namespace errc
     {
@@ -148,9 +153,9 @@ namespace boost
       { static const bool value = true; };
 
 
-    //  ----------------------------------------------------------------------//
+    //  --------------------------------------------------------------------------------//
 
-    //  Operating system specific interfaces  --------------------------------//
+    //  Operating system specific interfaces  ------------------------------------------//
 
 
     //  The interface is divided into general and system-specific portions to
@@ -178,52 +183,152 @@ namespace boost
     //  These headers are effectively empty for compiles on operating systems
     //  where they are not applicable.
 
-    //  ----------------------------------------------------------------------//
+    //  --------------------------------------------------------------------------------//
 
-    //  class error_category  ------------------------------------------------//
+    class error_category;
 
-    class error_category : public noncopyable
-    {
-    public:
-      virtual ~error_category(){}
+    //  predefined error categories  ---------------------------------------------------//
 
-      virtual const char *     name() const BOOST_SYSTEM_NOEXCEPT = 0;
-      virtual std::string      message( int ev ) const = 0;
-      inline virtual error_condition  default_error_condition( int ev ) const  BOOST_SYSTEM_NOEXCEPT;
-      inline virtual bool             equivalent( int code,
-                                           const error_condition & condition ) const  BOOST_SYSTEM_NOEXCEPT;
-      inline virtual bool             equivalent( const error_code & code,
-                                           int condition ) const  BOOST_SYSTEM_NOEXCEPT;
-
-      bool operator==(const error_category & rhs) const BOOST_SYSTEM_NOEXCEPT { return this == &rhs; }
-      bool operator!=(const error_category & rhs) const BOOST_SYSTEM_NOEXCEPT { return this != &rhs; }
-      bool operator<( const error_category & rhs ) const BOOST_SYSTEM_NOEXCEPT
-      {
-        return std::less<const error_category*>()( this, &rhs );
-      }
-    };
-
-    //  predefined error categories  -----------------------------------------//
-
-# ifdef BOOST_ERROR_CODE_HEADER_ONLY
+#ifdef BOOST_ERROR_CODE_HEADER_ONLY
     inline const error_category &  system_category() BOOST_SYSTEM_NOEXCEPT;
     inline const error_category &  generic_category() BOOST_SYSTEM_NOEXCEPT;
 #else
     BOOST_SYSTEM_DECL const error_category &  system_category() BOOST_SYSTEM_NOEXCEPT;
     BOOST_SYSTEM_DECL const error_category &  generic_category() BOOST_SYSTEM_NOEXCEPT;
 #endif
-    //  deprecated synonyms --------------------------------------------------//
+    //  deprecated synonyms ------------------------------------------------------------//
 
-# ifndef BOOST_SYSTEM_NO_DEPRECATED
+#ifndef BOOST_SYSTEM_NO_DEPRECATED
     inline const error_category &  get_system_category() { return system_category(); }
     inline const error_category &  get_generic_category() { return generic_category(); }
     inline const error_category &  get_posix_category() { return generic_category(); }
-    static const error_category &  posix_category = generic_category();
-    static const error_category &  errno_ecat     = generic_category();
-    static const error_category &  native_ecat    = system_category();
-# endif
+    static const error_category &  posix_category BOOST_ATTRIBUTE_UNUSED
+      = generic_category();
+    static const error_category &  errno_ecat     BOOST_ATTRIBUTE_UNUSED
+      = generic_category();
+    static const error_category &  native_ecat    BOOST_ATTRIBUTE_UNUSED
+      = system_category();
+#endif
 
-    //  class error_condition  -----------------------------------------------//
+    //  class error_category  ------------------------------------------------//
+
+    class error_category : public noncopyable
+    {
+#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+
+    private:
+
+      class std_category: public std::error_category
+      {
+      private:
+
+        boost::system::error_category const * pc_;
+
+      public:
+
+        explicit std_category( boost::system::error_category const * pc ): pc_( pc )
+        {
+        }
+
+        virtual const char * name() const BOOST_NOEXCEPT
+        {
+          return pc_->name();
+        }
+
+        virtual std::string message( int ev ) const
+        {
+          return pc_->message( ev );
+        }
+
+        virtual std::error_condition default_error_condition( int ev ) const
+          BOOST_NOEXCEPT;
+        virtual bool equivalent( int code, const std::error_condition & condition ) const
+          BOOST_NOEXCEPT;
+        virtual bool equivalent( const std::error_code & code, int condition ) const
+          BOOST_NOEXCEPT;
+      };
+
+      std_category std_cat_;
+
+    public:
+
+      error_category() BOOST_SYSTEM_NOEXCEPT: std_cat_( this ) {}
+
+      operator std::error_category const & () const BOOST_SYSTEM_NOEXCEPT
+      {
+        // do not map generic to std::generic on purpose; occasionally,
+        // there are two std::generic categories in a program, which leads
+        // to error codes/conditions mysteriously not being equal to themselves
+        return std_cat_;
+      }
+
+#else
+
+    // to maintain ABI compatibility between 03 and 11,
+    // define a class with the same layout
+
+    private:
+
+      class std_category
+      {
+      private:
+
+        boost::system::error_category const * pc_;
+
+      public:
+
+        explicit std_category( boost::system::error_category const * pc ): pc_( pc )
+        {
+        }
+
+        virtual ~std_category() {}
+
+        virtual const char * name() const BOOST_NOEXCEPT
+        {
+          return pc_->name();
+        }
+
+        // we can't define message, because (1) it returns an std::string,
+        // which can be different between 03 and 11, and (2) on mingw, there
+        // are actually two `message` functions, not one, so it doesn't work
+        // even if we do
+
+        // neither can we define default_error_condition or equivalent
+
+        // if these functions are called, it will crash, but that's still
+        // better than the alternative of having the class layout change
+      };
+
+      std_category std_cat_;
+
+    public:
+
+      error_category() BOOST_SYSTEM_NOEXCEPT: std_cat_( this ) {}
+
+#endif
+
+    public:
+      virtual ~error_category(){}
+
+      virtual const char *     name() const BOOST_SYSTEM_NOEXCEPT = 0;
+      virtual std::string      message( int ev ) const = 0;
+      inline virtual error_condition  default_error_condition( int ev ) const 
+        BOOST_SYSTEM_NOEXCEPT;
+      inline virtual bool             equivalent( int code,
+                                           const error_condition & condition ) const 
+        BOOST_SYSTEM_NOEXCEPT;
+      inline virtual bool             equivalent( const error_code & code,
+                                           int condition ) const  BOOST_SYSTEM_NOEXCEPT;
+
+      bool operator==(const error_category & rhs) const BOOST_SYSTEM_NOEXCEPT
+        { return this == &rhs; }
+      bool operator!=(const error_category & rhs) const BOOST_SYSTEM_NOEXCEPT
+        { return this != &rhs; }
+      bool operator<( const error_category & rhs ) const BOOST_SYSTEM_NOEXCEPT
+        { return std::less<const error_category*>()( this, &rhs ); }
+    };
+
+    //  class error_condition  ---------------------------------------------------------//
 
     //  error_conditions are portable, error_codes are system or library specific
 
@@ -233,11 +338,13 @@ namespace boost
 
       // constructors:
       error_condition() BOOST_SYSTEM_NOEXCEPT : m_val(0), m_cat(&generic_category()) {}
-      error_condition( int val, const error_category & cat ) BOOST_SYSTEM_NOEXCEPT : m_val(val), m_cat(&cat) {}
+      error_condition( int val, const error_category & cat ) BOOST_SYSTEM_NOEXCEPT
+        : m_val(val), m_cat(&cat) {}
 
       template <class ErrorConditionEnum>
         error_condition(ErrorConditionEnum e,
-          typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum> >::type* = 0) BOOST_SYSTEM_NOEXCEPT
+          typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum> >::type*
+            = 0) BOOST_SYSTEM_NOEXCEPT
       {
         *this = make_error_condition(e);
       }
@@ -251,7 +358,8 @@ namespace boost
       }
 
       template<typename ErrorConditionEnum>
-        typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum>, error_condition>::type &
+        typename boost::enable_if<is_error_condition_enum<ErrorConditionEnum>,
+          error_condition>::type &
           operator=( ErrorConditionEnum val ) BOOST_SYSTEM_NOEXCEPT
       {
         *this = make_error_condition(val);
@@ -300,13 +408,22 @@ namespace boost
           || (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
       }
 
+#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+
+      operator std::error_condition () const BOOST_SYSTEM_NOEXCEPT
+      {
+        return std::error_condition( value(), category() );
+      }
+
+#endif
+
     private:
       int                     m_val;
       const error_category *  m_cat;
 
     };
 
-    //  class error_code  ----------------------------------------------------//
+    //  class error_code  --------------------------------------------------------------//
 
     //  We want error_code to be a value type that can be copied without slicing
     //  and without requiring heap allocation, but we also want it to have
@@ -320,11 +437,13 @@ namespace boost
 
       // constructors:
       error_code() BOOST_SYSTEM_NOEXCEPT : m_val(0), m_cat(&system_category()) {}
-      error_code( int val, const error_category & cat ) BOOST_SYSTEM_NOEXCEPT : m_val(val), m_cat(&cat) {}
+      error_code( int val, const error_category & cat ) BOOST_SYSTEM_NOEXCEPT
+        : m_val(val), m_cat(&cat) {}
 
       template <class ErrorCodeEnum>
         error_code(ErrorCodeEnum e,
-          typename boost::enable_if<is_error_code_enum<ErrorCodeEnum> >::type* = 0) BOOST_SYSTEM_NOEXCEPT
+          typename boost::enable_if<is_error_code_enum<ErrorCodeEnum> >::type* = 0)
+          BOOST_SYSTEM_NOEXCEPT
       {
         *this = make_error_code(e);
       }
@@ -353,7 +472,8 @@ namespace boost
       // observers:
       int                     value() const  BOOST_SYSTEM_NOEXCEPT   { return m_val; }
       const error_category &  category() const BOOST_SYSTEM_NOEXCEPT { return *m_cat; }
-      error_condition         default_error_condition() const BOOST_SYSTEM_NOEXCEPT  { return m_cat->default_error_condition(value()); }
+      error_condition         default_error_condition() const BOOST_SYSTEM_NOEXCEPT
+        { return m_cat->default_error_condition(value()); }
       std::string             message() const  { return m_cat->message(value()); }
 
       typedef void (*unspecified_bool_type)();
@@ -387,6 +507,15 @@ namespace boost
           || (lhs.m_cat == rhs.m_cat && lhs.m_val < rhs.m_val);
       }
 
+#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+
+      operator std::error_code () const BOOST_SYSTEM_NOEXCEPT
+      {
+        return std::error_code( value(), category() );
+      }
+
+#endif
+
     private:
       int                     m_val;
       const error_category *  m_cat;
@@ -474,7 +603,7 @@ namespace boost
         + reinterpret_cast<std::size_t>(&ec.category());
     }
 
-    //  make_* functions for errc::errc_t  -----------------------------//
+    //  make_* functions for errc::errc_t  ---------------------------------------------//
 
     namespace errc
     {
@@ -487,9 +616,10 @@ namespace boost
         { return error_condition( e, generic_category() ); }
     }
 
-    //  error_category default implementation  -------------------------------//
+    //  error_category default implementation  -----------------------------------------//
 
-    error_condition error_category::default_error_condition( int ev ) const BOOST_SYSTEM_NOEXCEPT
+    error_condition error_category::default_error_condition( int ev ) const
+      BOOST_SYSTEM_NOEXCEPT
     {
       return error_condition( ev, *this );
     }
@@ -506,6 +636,80 @@ namespace boost
       return *this == code.category() && code.value() == condition;
     }
 
+#ifndef BOOST_NO_CXX11_HDR_SYSTEM_ERROR
+
+    inline std::error_condition error_category::std_category::default_error_condition(
+      int ev ) const BOOST_NOEXCEPT
+    {
+      return pc_->default_error_condition( ev );
+    }
+
+    inline bool error_category::std_category::equivalent( int code,
+      const std::error_condition & condition ) const BOOST_NOEXCEPT
+    {
+      if( condition.category() == *this )
+      {
+        boost::system::error_condition bn( condition.value(), *pc_ );
+        return pc_->equivalent( code, bn );
+      }
+      else if( condition.category() == std::generic_category()
+        || condition.category() == boost::system::generic_category() )
+      {
+        boost::system::error_condition bn( condition.value(),
+          boost::system::generic_category() );
+
+        return pc_->equivalent( code, bn );
+      }
+#ifndef BOOST_NO_RTTI
+      else if( std_category const* pc2 = dynamic_cast< std_category const* >(
+        &condition.category() ) )
+      {
+        boost::system::error_condition bn( condition.value(), *pc2->pc_ );
+        return pc_->equivalent( code, bn );
+      }
+#endif
+      else
+      {
+        return default_error_condition( code ) == condition;
+      }
+    }
+
+    inline bool error_category::std_category::equivalent( const std::error_code & code,
+      int condition ) const BOOST_NOEXCEPT
+    {
+      if( code.category() == *this )
+      {
+        boost::system::error_code bc( code.value(), *pc_ );
+        return pc_->equivalent( bc, condition );
+      }
+      else if( code.category() == std::generic_category()
+        || code.category() == boost::system::generic_category() )
+      {
+        boost::system::error_code bc( code.value(),
+          boost::system::generic_category() );
+
+        return pc_->equivalent( bc, condition );
+      }
+#ifndef BOOST_NO_RTTI
+      else if( std_category const* pc2 = dynamic_cast< std_category const* >(
+        &code.category() ) )
+      {
+        boost::system::error_code bc( code.value(), *pc2->pc_ );
+        return pc_->equivalent( bc, condition );
+      }
+#endif
+      else if( *pc_ == boost::system::generic_category() )
+      {
+        return std::generic_category().equivalent( code, condition );
+      }
+      else
+      {
+        return false;
+      }
+    }
+
+#endif
+
   } // namespace system
 } // namespace boost
 
@@ -515,6 +719,4 @@ namespace boost
 #   include <boost/system/detail/error_code.ipp>
 # endif
 
-#endif // BOOST_ERROR_CODE_HPP
-
-
+#endif // BOOST_SYSTEM_ERROR_CODE_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/system/linux_error.hpp b/contrib/libboost/boost_1_65_0/boost/system/linux_error.hpp
similarity index 96%
rename from contrib/libboost/boost_1_62_0/boost/system/linux_error.hpp
rename to contrib/libboost/boost_1_65_0/boost/system/linux_error.hpp
index 0eb22bf25a3..0873a7cd925 100644
--- a/contrib/libboost/boost_1_62_0/boost/system/linux_error.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/system/linux_error.hpp
@@ -7,8 +7,8 @@
 
 //  See library home page at http://www.boost.org/libs/system
 
-#ifndef BOOST_LINUX_ERROR_HPP
-#define BOOST_LINUX_ERROR_HPP
+#ifndef BOOST_SYSTEM_LINUX_ERROR_HPP
+#define BOOST_SYSTEM_LINUX_ERROR_HPP
 
 //  This header is effectively empty for compiles on operating systems where
 //  it is not applicable.
@@ -107,4 +107,4 @@ namespace boost
 
 #endif  // Linux
 
-#endif  // BOOST_LINUX_ERROR_HPP
+#endif  // BOOST_SYSTEM_LINUX_ERROR_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/system/system_error.hpp b/contrib/libboost/boost_1_65_0/boost/system/system_error.hpp
similarity index 84%
rename from contrib/libboost/boost_1_62_0/boost/system/system_error.hpp
rename to contrib/libboost/boost_1_65_0/boost/system/system_error.hpp
index b306aae4b9d..c5e7e402bac 100644
--- a/contrib/libboost/boost_1_62_0/boost/system/system_error.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/system/system_error.hpp
@@ -5,8 +5,8 @@
 //  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_SYSTEM_ERROR_HPP
-#define BOOST_SYSTEM_ERROR_HPP
+#ifndef BOOST_SYSTEM_SYSTEM_ERROR_HPP
+#define BOOST_SYSTEM_SYSTEM_ERROR_HPP
 
 #include <string>
 #include <stdexcept>
@@ -44,10 +44,10 @@ namespace boost
         const char * what_arg )
           : std::runtime_error(what_arg), m_error_code(ev,ecat) {}
 
-      virtual ~system_error() throw() {}
+      virtual ~system_error() BOOST_NOEXCEPT_OR_NOTHROW {}
 
-      const error_code &  code() const throw() { return m_error_code; }
-      const char *        what() const throw();
+      const error_code &  code() const BOOST_NOEXCEPT_OR_NOTHROW { return m_error_code; }
+      const char *        what() const BOOST_NOEXCEPT_OR_NOTHROW;
 
     private:
       error_code           m_error_code;
@@ -56,7 +56,7 @@ namespace boost
 
     //  implementation  ------------------------------------------------------//
 
-    inline const char * system_error::what() const throw()
+    inline const char * system_error::what() const BOOST_NOEXCEPT_OR_NOTHROW
     // see http://www.boost.org/more/error_handling.html for lazy build rationale
     {
       if ( m_what.empty() )
@@ -79,6 +79,6 @@ namespace boost
   } // namespace system
 } // namespace boost
 
-#endif // BOOST_SYSTEM_ERROR_HPP
+#endif // BOOST_SYSTEM_SYSTEM_ERROR_HPP
 
 
diff --git a/contrib/libboost/boost_1_65_0/boost/system/windows_error.hpp b/contrib/libboost/boost_1_65_0/boost/system/windows_error.hpp
new file mode 100644
index 00000000000..0fb7ea63525
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/system/windows_error.hpp
@@ -0,0 +1,128 @@
+//  boost/system/windows_error.hpp  ------------------------------------------//
+
+//  Copyright Beman Dawes 2007
+
+//  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 library home page at http://www.boost.org/libs/system
+
+#ifndef BOOST_SYSTEM_WINDOWS_ERROR_HPP
+#define BOOST_SYSTEM_WINDOWS_ERROR_HPP
+
+//  This header is effectively empty for compiles on operating systems where
+//  it is not applicable.
+
+#include <boost/system/config.hpp>
+
+#ifdef BOOST_WINDOWS_API
+
+#include <boost/system/error_code.hpp>
+
+//// Neither MinGW or Cygwin versions of winerror.h work if used alone, so on
+//// either of those platforms include the full windows.h
+//
+//#if defined(__MINGW32__) || defined(__CYGWIN__)
+//#include <windows.h>
+//#else
+//#include <winerror.h>
+//#endif
+
+#include <boost/detail/winapi/error_codes.hpp>
+
+namespace boost
+{
+  namespace system
+  {
+
+    //  Microsoft Windows  ---------------------------------------------------//
+
+    //  To construct an error_code after a API error:
+    //
+    //      error_code( ::GetLastError(), system_category() )
+
+    namespace windows_error
+    {
+      enum windows_error_code
+      {
+        success = 0,
+        // These names and values are based on Windows winerror.h
+        invalid_function = boost::detail::winapi::ERROR_INVALID_FUNCTION_,
+        file_not_found = boost::detail::winapi::ERROR_FILE_NOT_FOUND_,
+        path_not_found = boost::detail::winapi::ERROR_PATH_NOT_FOUND_,
+        too_many_open_files = boost::detail::winapi::ERROR_TOO_MANY_OPEN_FILES_,
+        access_denied = boost::detail::winapi::ERROR_ACCESS_DENIED_,
+        invalid_handle = boost::detail::winapi::ERROR_INVALID_HANDLE_,
+        arena_trashed = boost::detail::winapi::ERROR_ARENA_TRASHED_,
+        not_enough_memory = boost::detail::winapi::ERROR_NOT_ENOUGH_MEMORY_,
+        invalid_block = boost::detail::winapi::ERROR_INVALID_BLOCK_,
+        bad_environment = boost::detail::winapi::ERROR_BAD_ENVIRONMENT_,
+        bad_format = boost::detail::winapi::ERROR_BAD_FORMAT_,
+        invalid_access = boost::detail::winapi::ERROR_INVALID_ACCESS_,
+        outofmemory = boost::detail::winapi::ERROR_OUTOFMEMORY_,
+        invalid_drive = boost::detail::winapi::ERROR_INVALID_DRIVE_,
+        current_directory = boost::detail::winapi::ERROR_CURRENT_DIRECTORY_,
+        not_same_device = boost::detail::winapi::ERROR_NOT_SAME_DEVICE_,
+        no_more_files = boost::detail::winapi::ERROR_NO_MORE_FILES_,
+        write_protect = boost::detail::winapi::ERROR_WRITE_PROTECT_,
+        bad_unit = boost::detail::winapi::ERROR_BAD_UNIT_,
+        not_ready = boost::detail::winapi::ERROR_NOT_READY_,
+        bad_command = boost::detail::winapi::ERROR_BAD_COMMAND_,
+        crc = boost::detail::winapi::ERROR_CRC_,
+        bad_length = boost::detail::winapi::ERROR_BAD_LENGTH_,
+        seek = boost::detail::winapi::ERROR_SEEK_,
+        not_dos_disk = boost::detail::winapi::ERROR_NOT_DOS_DISK_,
+        sector_not_found = boost::detail::winapi::ERROR_SECTOR_NOT_FOUND_,
+        out_of_paper = boost::detail::winapi::ERROR_OUT_OF_PAPER_,
+        write_fault = boost::detail::winapi::ERROR_WRITE_FAULT_,
+        read_fault = boost::detail::winapi::ERROR_READ_FAULT_,
+        gen_failure = boost::detail::winapi::ERROR_GEN_FAILURE_,
+        sharing_violation = boost::detail::winapi::ERROR_SHARING_VIOLATION_,
+        lock_violation = boost::detail::winapi::ERROR_LOCK_VIOLATION_,
+        wrong_disk = boost::detail::winapi::ERROR_WRONG_DISK_,
+        sharing_buffer_exceeded = boost::detail::winapi::ERROR_SHARING_BUFFER_EXCEEDED_,
+        handle_eof = boost::detail::winapi::ERROR_HANDLE_EOF_,
+        handle_disk_full= boost::detail::winapi::ERROR_HANDLE_DISK_FULL_,
+        rem_not_list = boost::detail::winapi::ERROR_REM_NOT_LIST_,
+        dup_name = boost::detail::winapi::ERROR_DUP_NAME_,
+        bad_net_path = boost::detail::winapi::ERROR_BAD_NETPATH_,
+        network_busy = boost::detail::winapi::ERROR_NETWORK_BUSY_,
+        // ...
+        file_exists = boost::detail::winapi::ERROR_FILE_EXISTS_,
+        cannot_make = boost::detail::winapi::ERROR_CANNOT_MAKE_,
+        // ...
+        broken_pipe = boost::detail::winapi::ERROR_BROKEN_PIPE_,
+        open_failed = boost::detail::winapi::ERROR_OPEN_FAILED_,
+        buffer_overflow = boost::detail::winapi::ERROR_BUFFER_OVERFLOW_,
+        disk_full= boost::detail::winapi::ERROR_DISK_FULL_,
+        // ...
+        lock_failed = boost::detail::winapi::ERROR_LOCK_FAILED_,
+        busy = boost::detail::winapi::ERROR_BUSY_,
+        cancel_violation = boost::detail::winapi::ERROR_CANCEL_VIOLATION_,
+        already_exists = boost::detail::winapi::ERROR_ALREADY_EXISTS_
+        // ...
+
+        // TODO: add more Windows errors
+      };
+
+    }  // namespace windows
+
+# ifndef BOOST_SYSTEM_NO_DEPRECATED
+    namespace windows = windows_error;
+# endif
+
+    template<> struct is_error_code_enum<windows_error::windows_error_code>
+      { static const bool value = true; };
+
+    namespace windows_error
+    {
+      inline error_code make_error_code( windows_error_code e )
+        { return error_code( e, system_category() ); }
+    }
+
+  }  // namespace system
+}  // namespace boost
+
+#endif  // BOOST_WINDOWS_API
+
+#endif  // BOOST_SYSTEM_WINDOWS_ERROR_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/throw_exception.hpp b/contrib/libboost/boost_1_65_0/boost/throw_exception.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/throw_exception.hpp
rename to contrib/libboost/boost_1_65_0/boost/throw_exception.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/timer.hpp b/contrib/libboost/boost_1_65_0/boost/timer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/timer.hpp
rename to contrib/libboost/boost_1_65_0/boost/timer.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/token_functions.hpp b/contrib/libboost/boost_1_65_0/boost/token_functions.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/token_functions.hpp
rename to contrib/libboost/boost_1_65_0/boost/token_functions.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/token_iterator.hpp b/contrib/libboost/boost_1_65_0/boost/token_iterator.hpp
similarity index 96%
rename from contrib/libboost/boost_1_62_0/boost/token_iterator.hpp
rename to contrib/libboost/boost_1_65_0/boost/token_iterator.hpp
index 584fac28f41..42945d7ee97 100644
--- a/contrib/libboost/boost_1_62_0/boost/token_iterator.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/token_iterator.hpp
@@ -39,8 +39,11 @@ namespace boost
         >
   {
 
-      friend class iterator_core_access;
-
+#ifdef __DCC__ 
+      friend class boost::iterator_core_access; 
+#else 
+      friend class iterator_core_access; 
+#endif  
       TokenizerFunc f_;
       Iterator begin_;
       Iterator end_;
diff --git a/contrib/libboost/boost_1_62_0/boost/tokenizer.hpp b/contrib/libboost/boost_1_65_0/boost/tokenizer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/tokenizer.hpp
rename to contrib/libboost/boost_1_65_0/boost/tokenizer.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/tuple/detail/tuple_basic.hpp b/contrib/libboost/boost_1_65_0/boost/tuple/detail/tuple_basic.hpp
new file mode 100644
index 00000000000..5f26c7fdcb6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/tuple/detail/tuple_basic.hpp
@@ -0,0 +1,989 @@
+//  tuple_basic.hpp -----------------------------------------------------
+
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+//
+// 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)
+
+// For more information, see http://www.boost.org
+
+// Outside help:
+// This and that, Gary Powell.
+// Fixed return types for get_head/get_tail
+// ( and other bugs ) per suggestion of Jens Maurer
+// simplified element type accessors + bug fix  (Jeremy Siek)
+// Several changes/additions according to suggestions by Douglas Gregor,
+// William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes,
+// David Abrahams.
+
+// Revision history:
+// 2002 05 01 Hugo Duncan: Fix for Borland after Jaakko's previous changes
+// 2002 04 18 Jaakko: tuple element types can be void or plain function
+//                    types, as long as no object is created.
+//                    Tuple objects can no hold even noncopyable types
+//                    such as arrays.
+// 2001 10 22 John Maddock
+//      Fixes for Borland C++
+// 2001 08 30 David Abrahams
+//      Added default constructor for cons<>.
+// -----------------------------------------------------------------
+
+#ifndef BOOST_TUPLE_BASIC_HPP
+#define BOOST_TUPLE_BASIC_HPP
+
+
+#include <utility> // needed for the assignment from pair to tuple
+
+#include "boost/type_traits/cv_traits.hpp"
+#include "boost/type_traits/function_traits.hpp"
+#include "boost/utility/swap.hpp"
+
+#include "boost/detail/workaround.hpp" // needed for BOOST_WORKAROUND
+
+#if BOOST_GCC >= 40700
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
+#endif
+
+namespace boost {
+namespace tuples {
+
+// -- null_type --------------------------------------------------------
+struct null_type {};
+
+// a helper function to provide a const null_type type temporary
+namespace detail {
+  inline const null_type cnull() { return null_type(); }
+
+
+// -- if construct ------------------------------------------------
+// Proposed by Krzysztof Czarnecki and Ulrich Eisenecker
+
+template <bool If, class Then, class Else> struct IF { typedef Then RET; };
+
+template <class Then, class Else> struct IF<false, Then, Else> {
+  typedef Else RET;
+};
+
+} // end detail
+
+// - cons forward declaration -----------------------------------------------
+template <class HT, class TT> struct cons;
+
+
+// - tuple forward declaration -----------------------------------------------
+template <
+  class T0 = null_type, class T1 = null_type, class T2 = null_type,
+  class T3 = null_type, class T4 = null_type, class T5 = null_type,
+  class T6 = null_type, class T7 = null_type, class T8 = null_type,
+  class T9 = null_type>
+class tuple;
+
+// tuple_length forward declaration
+template<class T> struct length;
+
+
+
+namespace detail {
+
+// -- generate error template, referencing to non-existing members of this
+// template is used to produce compilation errors intentionally
+template<class T>
+class generate_error;
+
+template<int N>
+struct drop_front {
+    template<class Tuple>
+    struct apply {
+        typedef BOOST_DEDUCED_TYPENAME drop_front<N-1>::BOOST_NESTED_TEMPLATE
+            apply<Tuple> next;
+        typedef BOOST_DEDUCED_TYPENAME next::type::tail_type type;
+        static const type& call(const Tuple& tup) {
+            return next::call(tup).tail;
+        }
+    };
+};
+
+template<>
+struct drop_front<0> {
+    template<class Tuple>
+    struct apply {
+        typedef Tuple type;
+        static const type& call(const Tuple& tup) {
+            return tup;
+        }
+    };
+};
+
+} // end of namespace detail
+
+
+// -cons type accessors ----------------------------------------
+// typename tuples::element<N,T>::type gets the type of the
+// Nth element ot T, first element is at index 0
+// -------------------------------------------------------
+
+#ifndef BOOST_NO_CV_SPECIALIZATIONS
+
+template<int N, class T>
+struct element
+{
+  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
+      apply<T>::type::head_type type;
+};
+
+template<int N, class T>
+struct element<N, const T>
+{
+private:
+  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
+      apply<T>::type::head_type unqualified_type;
+public:
+#if BOOST_WORKAROUND(__BORLANDC__,<0x600)
+  typedef const unqualified_type type;
+#else
+  typedef BOOST_DEDUCED_TYPENAME boost::add_const<unqualified_type>::type type;
+#endif
+};
+#else // def BOOST_NO_CV_SPECIALIZATIONS
+
+namespace detail {
+
+template<int N, class T, bool IsConst>
+struct element_impl
+{
+  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
+      apply<T>::type::head_type type;
+};
+
+template<int N, class T>
+struct element_impl<N, T, true /* IsConst */>
+{
+  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
+      apply<T>::type::head_type unqualified_type;
+  typedef const unqualified_type type;
+};
+
+} // end of namespace detail
+
+
+template<int N, class T>
+struct element:
+  public detail::element_impl<N, T, ::boost::is_const<T>::value>
+{
+};
+
+#endif
+
+
+// -get function templates -----------------------------------------------
+// Usage: get<N>(aTuple)
+
+// -- some traits classes for get functions
+
+// access traits lifted from detail namespace to be part of the interface,
+// (Joel de Guzman's suggestion). Rationale: get functions are part of the
+// interface, so should the way to express their return types be.
+
+template <class T> struct access_traits {
+  typedef const T& const_type;
+  typedef T& non_const_type;
+
+  typedef const typename boost::remove_cv<T>::type& parameter_type;
+
+// used as the tuple constructors parameter types
+// Rationale: non-reference tuple element types can be cv-qualified.
+// It should be possible to initialize such types with temporaries,
+// and when binding temporaries to references, the reference must
+// be non-volatile and const. 8.5.3. (5)
+};
+
+template <class T> struct access_traits<T&> {
+
+  typedef T& const_type;
+  typedef T& non_const_type;
+
+  typedef T& parameter_type;
+};
+
+// get function for non-const cons-lists, returns a reference to the element
+
+template<int N, class HT, class TT>
+inline typename access_traits<
+                  typename element<N, cons<HT, TT> >::type
+                >::non_const_type
+get(cons<HT, TT>& c) {
+  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
+      apply<cons<HT, TT> > impl;
+  typedef BOOST_DEDUCED_TYPENAME impl::type cons_element;
+  return const_cast<cons_element&>(impl::call(c)).head;
+}
+
+// get function for const cons-lists, returns a const reference to
+// the element. If the element is a reference, returns the reference
+// as such (that is, can return a non-const reference)
+template<int N, class HT, class TT>
+inline typename access_traits<
+                  typename element<N, cons<HT, TT> >::type
+                >::const_type
+get(const cons<HT, TT>& c) {
+  typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
+      apply<cons<HT, TT> > impl;
+  return impl::call(c).head;
+}
+
+// -- the cons template  --------------------------------------------------
+namespace detail {
+
+//  These helper templates wrap void types and plain function types.
+//  The reationale is to allow one to write tuple types with those types
+//  as elements, even though it is not possible to instantiate such object.
+//  E.g: typedef tuple<void> some_type; // ok
+//  but: some_type x; // fails
+
+template <class T> class non_storeable_type {
+  non_storeable_type();
+};
+
+template <class T> struct wrap_non_storeable_type {
+  typedef typename IF<
+    ::boost::is_function<T>::value, non_storeable_type<T>, T
+  >::RET type;
+};
+template <> struct wrap_non_storeable_type<void> {
+  typedef non_storeable_type<void> type;
+};
+
+} // detail
+
+template <class HT, class TT>
+struct cons {
+
+  typedef HT head_type;
+  typedef TT tail_type;
+
+  typedef typename
+    detail::wrap_non_storeable_type<head_type>::type stored_head_type;
+
+  stored_head_type head;
+  tail_type tail;
+
+  typename access_traits<stored_head_type>::non_const_type
+  get_head() { return head; }
+
+  typename access_traits<tail_type>::non_const_type
+  get_tail() { return tail; }
+
+  typename access_traits<stored_head_type>::const_type
+  get_head() const { return head; }
+
+  typename access_traits<tail_type>::const_type
+  get_tail() const { return tail; }
+
+  cons() : head(), tail() {}
+  //  cons() : head(detail::default_arg<HT>::f()), tail() {}
+
+  // the argument for head is not strictly needed, but it prevents
+  // array type elements. This is good, since array type elements
+  // cannot be supported properly in any case (no assignment,
+  // copy works only if the tails are exactly the same type, ...)
+
+  cons(typename access_traits<stored_head_type>::parameter_type h,
+       const tail_type& t)
+    : head (h), tail(t) {}
+
+  template <class T1, class T2, class T3, class T4, class T5,
+            class T6, class T7, class T8, class T9, class T10>
+  cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5,
+        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
+    : head (t1),
+      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
+      {}
+
+  template <class T2, class T3, class T4, class T5,
+            class T6, class T7, class T8, class T9, class T10>
+  cons( const null_type& /*t1*/, T2& t2, T3& t3, T4& t4, T5& t5,
+        T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
+    : head (),
+      tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
+      {}
+
+
+  template <class HT2, class TT2>
+  cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}
+
+  template <class HT2, class TT2>
+  cons& operator=( const cons<HT2, TT2>& u ) {
+    head=u.head; tail=u.tail; return *this;
+  }
+
+  // must define assignment operator explicitly, implicit version is
+  // illformed if HT is a reference (12.8. (12))
+  cons& operator=(const cons& u) {
+    head = u.head; tail = u.tail;  return *this;
+  }
+
+  template <class T1, class T2>
+  cons& operator=( const std::pair<T1, T2>& u ) {
+    BOOST_STATIC_ASSERT(length<cons>::value == 2); // check length = 2
+    head = u.first; tail.head = u.second; return *this;
+  }
+
+  // get member functions (non-const and const)
+  template <int N>
+  typename access_traits<
+             typename element<N, cons<HT, TT> >::type
+           >::non_const_type
+  get() {
+    return boost::tuples::get<N>(*this); // delegate to non-member get
+  }
+
+  template <int N>
+  typename access_traits<
+             typename element<N, cons<HT, TT> >::type
+           >::const_type
+  get() const {
+    return boost::tuples::get<N>(*this); // delegate to non-member get
+  }
+};
+
+template <class HT>
+struct cons<HT, null_type> {
+
+  typedef HT head_type;
+  typedef null_type tail_type;
+  typedef cons<HT, null_type> self_type;
+
+  typedef typename
+    detail::wrap_non_storeable_type<head_type>::type stored_head_type;
+  stored_head_type head;
+
+  typename access_traits<stored_head_type>::non_const_type
+  get_head() { return head; }
+
+  null_type get_tail() { return null_type(); }
+
+  typename access_traits<stored_head_type>::const_type
+  get_head() const { return head; }
+
+  const null_type get_tail() const { return null_type(); }
+
+  //  cons() : head(detail::default_arg<HT>::f()) {}
+  cons() : head() {}
+
+  cons(typename access_traits<stored_head_type>::parameter_type h,
+       const null_type& = null_type())
+    : head (h) {}
+
+  template<class T1>
+  cons(T1& t1, const null_type&, const null_type&, const null_type&,
+       const null_type&, const null_type&, const null_type&,
+       const null_type&, const null_type&, const null_type&)
+  : head (t1) {}
+
+  cons(const null_type&,
+       const null_type&, const null_type&, const null_type&,
+       const null_type&, const null_type&, const null_type&,
+       const null_type&, const null_type&, const null_type&)
+  : head () {}
+
+  template <class HT2>
+  cons( const cons<HT2, null_type>& u ) : head(u.head) {}
+
+  template <class HT2>
+  cons& operator=(const cons<HT2, null_type>& u )
+  { head = u.head; return *this; }
+
+  // must define assignment operator explicitely, implicit version
+  // is illformed if HT is a reference
+  cons& operator=(const cons& u) { head = u.head; return *this; }
+
+  template <int N>
+  typename access_traits<
+             typename element<N, self_type>::type
+            >::non_const_type
+  get() {
+    return boost::tuples::get<N>(*this);
+  }
+
+  template <int N>
+  typename access_traits<
+             typename element<N, self_type>::type
+           >::const_type
+  get() const {
+    return boost::tuples::get<N>(*this);
+  }
+
+};
+
+// templates for finding out the length of the tuple -------------------
+
+template<class T>
+struct length  {
+  BOOST_STATIC_CONSTANT(int, value = 1 + length<typename T::tail_type>::value);
+};
+
+template<>
+struct length<tuple<> > {
+  BOOST_STATIC_CONSTANT(int, value = 0);
+};
+
+template<>
+struct length<tuple<> const> {
+  BOOST_STATIC_CONSTANT(int, value = 0);
+};
+
+template<>
+struct length<null_type> {
+  BOOST_STATIC_CONSTANT(int, value = 0);
+};
+
+template<>
+struct length<null_type const> {
+  BOOST_STATIC_CONSTANT(int, value = 0);
+};
+
+namespace detail {
+
+// Tuple to cons mapper --------------------------------------------------
+template <class T0, class T1, class T2, class T3, class T4,
+          class T5, class T6, class T7, class T8, class T9>
+struct map_tuple_to_cons
+{
+  typedef cons<T0,
+               typename map_tuple_to_cons<T1, T2, T3, T4, T5,
+                                          T6, T7, T8, T9, null_type>::type
+              > type;
+};
+
+// The empty tuple is a null_type
+template <>
+struct map_tuple_to_cons<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type>
+{
+  typedef null_type type;
+};
+
+} // end detail
+
+// -------------------------------------------------------------------
+// -- tuple ------------------------------------------------------
+template <class T0, class T1, class T2, class T3, class T4,
+          class T5, class T6, class T7, class T8, class T9>
+
+class tuple :
+  public detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
+{
+public:
+  typedef typename
+    detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type inherited;
+  typedef typename inherited::head_type head_type;
+  typedef typename inherited::tail_type tail_type;
+
+
+// access_traits<T>::parameter_type takes non-reference types as const T&
+  tuple() {}
+
+  tuple(typename access_traits<T0>::parameter_type t0)
+    : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1)
+    : inherited(t0, t1, detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2)
+    : inherited(t0, t1, t2, detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3)
+    : inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull(),
+                detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4)
+    : inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5)
+    : inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(),
+                detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5,
+        typename access_traits<T6>::parameter_type t6)
+    : inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(),
+                detail::cnull(), detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5,
+        typename access_traits<T6>::parameter_type t6,
+        typename access_traits<T7>::parameter_type t7)
+    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(),
+                detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5,
+        typename access_traits<T6>::parameter_type t6,
+        typename access_traits<T7>::parameter_type t7,
+        typename access_traits<T8>::parameter_type t8)
+    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, detail::cnull()) {}
+
+  tuple(typename access_traits<T0>::parameter_type t0,
+        typename access_traits<T1>::parameter_type t1,
+        typename access_traits<T2>::parameter_type t2,
+        typename access_traits<T3>::parameter_type t3,
+        typename access_traits<T4>::parameter_type t4,
+        typename access_traits<T5>::parameter_type t5,
+        typename access_traits<T6>::parameter_type t6,
+        typename access_traits<T7>::parameter_type t7,
+        typename access_traits<T8>::parameter_type t8,
+        typename access_traits<T9>::parameter_type t9)
+    : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}
+
+
+  template<class U1, class U2>
+  tuple(const cons<U1, U2>& p) : inherited(p) {}
+
+  template <class U1, class U2>
+  tuple& operator=(const cons<U1, U2>& k) {
+    inherited::operator=(k);
+    return *this;
+  }
+
+  template <class U1, class U2>
+  tuple& operator=(const std::pair<U1, U2>& k) {
+    BOOST_STATIC_ASSERT(length<tuple>::value == 2);// check_length = 2
+    this->head = k.first;
+    this->tail.head = k.second;
+    return *this;
+  }
+
+};
+
+// The empty tuple
+template <>
+class tuple<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type>  :
+  public null_type
+{
+public:
+  typedef null_type inherited;
+};
+
+
+// Swallows any assignment   (by Doug Gregor)
+namespace detail {
+
+struct swallow_assign;
+typedef void (detail::swallow_assign::*ignore_t)();
+struct swallow_assign {
+  swallow_assign(ignore_t(*)(ignore_t)) {}
+  template<typename T>
+  swallow_assign const& operator=(const T&) const {
+    return *this;
+  }
+};
+
+
+} // namespace detail
+
+// "ignore" allows tuple positions to be ignored when using "tie".
+inline detail::ignore_t ignore(detail::ignore_t) { return 0; }
+
+// ---------------------------------------------------------------------------
+// The call_traits for make_tuple
+// Honours the reference_wrapper class.
+
+// Must be instantiated with plain or const plain types (not with references)
+
+// from template<class T> foo(const T& t) : make_tuple_traits<const T>::type
+// from template<class T> foo(T& t) : make_tuple_traits<T>::type
+
+// Conversions:
+// T -> T,
+// references -> compile_time_error
+// reference_wrapper<T> -> T&
+// const reference_wrapper<T> -> T&
+// array -> const ref array
+
+
+template<class T>
+struct make_tuple_traits {
+  typedef T type;
+
+  // commented away, see below  (JJ)
+  //  typedef typename IF<
+  //  boost::is_function<T>::value,
+  //  T&,
+  //  T>::RET type;
+
+};
+
+// The is_function test was there originally for plain function types,
+// which can't be stored as such (we must either store them as references or
+// pointers). Such a type could be formed if make_tuple was called with a
+// reference to a function.
+// But this would mean that a const qualified function type was formed in
+// the make_tuple function and hence make_tuple can't take a function
+// reference as a parameter, and thus T can't be a function type.
+// So is_function test was removed.
+// (14.8.3. says that type deduction fails if a cv-qualified function type
+// is created. (It only applies for the case of explicitly specifying template
+// args, though?)) (JJ)
+
+template<class T>
+struct make_tuple_traits<T&> {
+  typedef typename
+     detail::generate_error<T&>::
+       do_not_use_with_reference_type error;
+};
+
+// Arrays can't be stored as plain types; convert them to references.
+// All arrays are converted to const. This is because make_tuple takes its
+// parameters as const T& and thus the knowledge of the potential
+// non-constness of actual argument is lost.
+template<class T, int n>  struct make_tuple_traits <T[n]> {
+  typedef const T (&type)[n];
+};
+
+template<class T, int n>
+struct make_tuple_traits<const T[n]> {
+  typedef const T (&type)[n];
+};
+
+template<class T, int n>  struct make_tuple_traits<volatile T[n]> {
+  typedef const volatile T (&type)[n];
+};
+
+template<class T, int n>
+struct make_tuple_traits<const volatile T[n]> {
+  typedef const volatile T (&type)[n];
+};
+
+template<class T>
+struct make_tuple_traits<reference_wrapper<T> >{
+  typedef T& type;
+};
+
+template<class T>
+struct make_tuple_traits<const reference_wrapper<T> >{
+  typedef T& type;
+};
+
+template<>
+struct make_tuple_traits<detail::ignore_t(detail::ignore_t)> {
+  typedef detail::swallow_assign type;
+};
+
+
+
+namespace detail {
+
+// a helper traits to make the make_tuple functions shorter (Vesa Karvonen's
+// suggestion)
+template <
+  class T0 = null_type, class T1 = null_type, class T2 = null_type,
+  class T3 = null_type, class T4 = null_type, class T5 = null_type,
+  class T6 = null_type, class T7 = null_type, class T8 = null_type,
+  class T9 = null_type
+>
+struct make_tuple_mapper {
+  typedef
+    tuple<typename make_tuple_traits<T0>::type,
+          typename make_tuple_traits<T1>::type,
+          typename make_tuple_traits<T2>::type,
+          typename make_tuple_traits<T3>::type,
+          typename make_tuple_traits<T4>::type,
+          typename make_tuple_traits<T5>::type,
+          typename make_tuple_traits<T6>::type,
+          typename make_tuple_traits<T7>::type,
+          typename make_tuple_traits<T8>::type,
+          typename make_tuple_traits<T9>::type> type;
+};
+
+} // end detail
+
+// -make_tuple function templates -----------------------------------
+inline tuple<> make_tuple() {
+  return tuple<>();
+}
+
+template<class T0>
+inline typename detail::make_tuple_mapper<T0>::type
+make_tuple(const T0& t0) {
+  typedef typename detail::make_tuple_mapper<T0>::type t;
+  return t(t0);
+}
+
+template<class T0, class T1>
+inline typename detail::make_tuple_mapper<T0, T1>::type
+make_tuple(const T0& t0, const T1& t1) {
+  typedef typename detail::make_tuple_mapper<T0, T1>::type t;
+  return t(t0, t1);
+}
+
+template<class T0, class T1, class T2>
+inline typename detail::make_tuple_mapper<T0, T1, T2>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2) {
+  typedef typename detail::make_tuple_mapper<T0, T1, T2>::type t;
+  return t(t0, t1, t2);
+}
+
+template<class T0, class T1, class T2, class T3>
+inline typename detail::make_tuple_mapper<T0, T1, T2, T3>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3) {
+  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3>::type t;
+  return t(t0, t1, t2, t3);
+}
+
+template<class T0, class T1, class T2, class T3, class T4>
+inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
+                  const T4& t4) {
+  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type t;
+  return t(t0, t1, t2, t3, t4);
+}
+
+template<class T0, class T1, class T2, class T3, class T4, class T5>
+inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
+                  const T4& t4, const T5& t5) {
+  typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type t;
+  return t(t0, t1, t2, t3, t4, t5);
+}
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
+inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
+                  const T4& t4, const T5& t5, const T6& t6) {
+  typedef typename detail::make_tuple_mapper
+           <T0, T1, T2, T3, T4, T5, T6>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6);
+}
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
+         class T7>
+inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
+                  const T4& t4, const T5& t5, const T6& t6, const T7& t7) {
+  typedef typename detail::make_tuple_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6, t7);
+}
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
+         class T7, class T8>
+inline typename detail::make_tuple_mapper
+  <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
+                  const T4& t4, const T5& t5, const T6& t6, const T7& t7,
+                  const T8& t8) {
+  typedef typename detail::make_tuple_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
+}
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
+         class T7, class T8, class T9>
+inline typename detail::make_tuple_mapper
+  <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
+make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
+                  const T4& t4, const T5& t5, const T6& t6, const T7& t7,
+                  const T8& t8, const T9& t9) {
+  typedef typename detail::make_tuple_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
+}
+
+namespace detail {
+
+template<class T>
+struct tie_traits {
+  typedef T& type;
+};
+
+template<>
+struct tie_traits<ignore_t(ignore_t)> {
+  typedef swallow_assign type;
+};
+
+template<>
+struct tie_traits<void> {
+  typedef null_type type;
+};
+
+template <
+  class T0 = void, class T1 = void, class T2 = void,
+  class T3 = void, class T4 = void, class T5 = void,
+  class T6 = void, class T7 = void, class T8 = void,
+  class T9 = void
+>
+struct tie_mapper {
+  typedef
+    tuple<typename tie_traits<T0>::type,
+          typename tie_traits<T1>::type,
+          typename tie_traits<T2>::type,
+          typename tie_traits<T3>::type,
+          typename tie_traits<T4>::type,
+          typename tie_traits<T5>::type,
+          typename tie_traits<T6>::type,
+          typename tie_traits<T7>::type,
+          typename tie_traits<T8>::type,
+          typename tie_traits<T9>::type> type;
+};
+
+}
+
+// Tie function templates -------------------------------------------------
+template<class T0>
+inline typename detail::tie_mapper<T0>::type
+tie(T0& t0) {
+  typedef typename detail::tie_mapper<T0>::type t;
+  return t(t0);
+}
+
+template<class T0, class T1>
+inline typename detail::tie_mapper<T0, T1>::type
+tie(T0& t0, T1& t1) {
+  typedef typename detail::tie_mapper<T0, T1>::type t;
+  return t(t0, t1);
+}
+
+template<class T0, class T1, class T2>
+inline typename detail::tie_mapper<T0, T1, T2>::type
+tie(T0& t0, T1& t1, T2& t2) {
+  typedef typename detail::tie_mapper<T0, T1, T2>::type t;
+  return t(t0, t1, t2);
+}
+
+template<class T0, class T1, class T2, class T3>
+inline typename detail::tie_mapper<T0, T1, T2, T3>::type
+tie(T0& t0, T1& t1, T2& t2, T3& t3) {
+  typedef typename detail::tie_mapper<T0, T1, T2, T3>::type t;
+  return t(t0, t1, t2, t3);
+}
+
+template<class T0, class T1, class T2, class T3, class T4>
+inline typename detail::tie_mapper<T0, T1, T2, T3, T4>::type
+tie(T0& t0, T1& t1, T2& t2, T3& t3,
+                  T4& t4) {
+  typedef typename detail::tie_mapper<T0, T1, T2, T3, T4>::type t;
+  return t(t0, t1, t2, t3, t4);
+}
+
+template<class T0, class T1, class T2, class T3, class T4, class T5>
+inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5>::type
+tie(T0& t0, T1& t1, T2& t2, T3& t3,
+                  T4& t4, T5& t5) {
+  typedef typename detail::tie_mapper<T0, T1, T2, T3, T4, T5>::type t;
+  return t(t0, t1, t2, t3, t4, t5);
+}
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
+inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5, T6>::type
+tie(T0& t0, T1& t1, T2& t2, T3& t3,
+                  T4& t4, T5& t5, T6& t6) {
+  typedef typename detail::tie_mapper
+           <T0, T1, T2, T3, T4, T5, T6>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6);
+}
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
+         class T7>
+inline typename detail::tie_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
+tie(T0& t0, T1& t1, T2& t2, T3& t3,
+                  T4& t4, T5& t5, T6& t6, T7& t7) {
+  typedef typename detail::tie_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6, t7);
+}
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
+         class T7, class T8>
+inline typename detail::tie_mapper
+  <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
+tie(T0& t0, T1& t1, T2& t2, T3& t3,
+                  T4& t4, T5& t5, T6& t6, T7& t7,
+                  T8& t8) {
+  typedef typename detail::tie_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
+}
+
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
+         class T7, class T8, class T9>
+inline typename detail::tie_mapper
+  <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
+tie(T0& t0, T1& t1, T2& t2, T3& t3,
+                  T4& t4, T5& t5, T6& t6, T7& t7,
+                  T8& t8, T9& t9) {
+  typedef typename detail::tie_mapper
+           <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
+  return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
+}
+
+template <class T0, class T1, class T2, class T3, class T4,
+          class T5, class T6, class T7, class T8, class T9>
+void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
+          tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs);
+inline void swap(null_type&, null_type&) {}
+template<class HH>
+inline void swap(cons<HH, null_type>& lhs, cons<HH, null_type>& rhs) {
+  ::boost::swap(lhs.head, rhs.head);
+}
+template<class HH, class TT>
+inline void swap(cons<HH, TT>& lhs, cons<HH, TT>& rhs) {
+  ::boost::swap(lhs.head, rhs.head);
+  ::boost::tuples::swap(lhs.tail, rhs.tail);
+}
+template <class T0, class T1, class T2, class T3, class T4,
+          class T5, class T6, class T7, class T8, class T9>
+inline void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
+          tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs) {
+  typedef tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> tuple_type;
+  typedef typename tuple_type::inherited base;
+  ::boost::tuples::swap(static_cast<base&>(lhs), static_cast<base&>(rhs));
+}
+
+} // end of namespace tuples
+} // end of namespace boost
+
+
+#if BOOST_GCC >= 40700
+#pragma GCC diagnostic pop
+#endif
+
+
+#endif // BOOST_TUPLE_BASIC_HPP
+
+
diff --git a/contrib/libboost/boost_1_65_0/boost/tuple/tuple.hpp b/contrib/libboost/boost_1_65_0/boost/tuple/tuple.hpp
new file mode 100644
index 00000000000..433d4b31657
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/tuple/tuple.hpp
@@ -0,0 +1,67 @@
+//  tuple.hpp - Boost Tuple Library --------------------------------------
+
+// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+//
+// 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)
+
+// For more information, see http://www.boost.org
+
+// ----------------------------------------------------------------- 
+
+#ifndef BOOST_TUPLE_HPP
+#define BOOST_TUPLE_HPP
+
+#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730
+// Work around a compiler bug.
+// boost::python::tuple has to be seen by the compiler before the
+// boost::tuple class template.
+namespace boost { namespace python { class tuple; }}
+#endif
+
+#include "boost/config.hpp"
+#include "boost/static_assert.hpp"
+
+// other compilers
+#include "boost/ref.hpp"
+#include "boost/tuple/detail/tuple_basic.hpp"
+
+
+namespace boost {    
+
+using tuples::tuple;
+using tuples::make_tuple;
+using tuples::tie;
+#if !defined(BOOST_NO_USING_TEMPLATE)
+using tuples::get;
+#else
+//
+// The "using tuples::get" statement causes the
+// Borland compiler to ICE, use forwarding
+// functions instead:
+//
+template<int N, class HT, class TT>
+inline typename tuples::access_traits<
+                  typename tuples::element<N, tuples::cons<HT, TT> >::type
+                >::non_const_type
+get(tuples::cons<HT, TT>& c) {
+  return tuples::get<N,HT,TT>(c);
+} 
+// get function for const cons-lists, returns a const reference to
+// the element. If the element is a reference, returns the reference
+// as such (that is, can return a non-const reference)
+template<int N, class HT, class TT>
+inline typename tuples::access_traits<
+                  typename tuples::element<N, tuples::cons<HT, TT> >::type
+                >::const_type
+get(const tuples::cons<HT, TT>& c) {
+  return tuples::get<N,HT,TT>(c);
+}
+
+#endif // BOOST_NO_USING_TEMPLATE
+   
+} // end namespace boost
+
+
+#endif // BOOST_TUPLE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/tuple/tuple_comparison.hpp b/contrib/libboost/boost_1_65_0/boost/tuple/tuple_comparison.hpp
new file mode 100644
index 00000000000..73723a15bc9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/tuple/tuple_comparison.hpp
@@ -0,0 +1,175 @@
+// tuple_comparison.hpp -----------------------------------------------------
+//  
+// Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+// Copyright (C) 2001 Gary Powell (gary.powell@sierra.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)
+// 
+// For more information, see http://www.boost.org
+// 
+// (The idea and first impl. of comparison operators was from Doug Gregor)
+
+// ----------------------------------------------------------------- 
+
+#ifndef BOOST_TUPLE_COMPARISON_HPP
+#define BOOST_TUPLE_COMPARISON_HPP
+
+#include "boost/tuple/tuple.hpp"
+
+// -------------------------------------------------------------
+// equality and comparison operators 
+//
+// == and != compare tuples elementwise
+// <, >, <= and >= use lexicographical ordering
+//
+// Any operator between tuples of different length fails at compile time
+// No dependencies between operators are assumed 
+// (i.e. !(a<b)  does not imply a>=b, a!=b does not imply a==b etc.
+// so any weirdnesses of elementary operators are respected).
+//
+// -------------------------------------------------------------
+
+
+namespace boost {
+namespace tuples {
+
+inline bool operator==(const null_type&, const null_type&) { return true; }
+inline bool operator>=(const null_type&, const null_type&) { return true; }
+inline bool operator<=(const null_type&, const null_type&) { return true; }
+inline bool operator!=(const null_type&, const null_type&) { return false; }
+inline bool operator<(const null_type&, const null_type&) { return false; }
+inline bool operator>(const null_type&, const null_type&) { return false; }
+
+
+namespace detail {
+  // comparison operators check statically the length of its operands and
+  // delegate the comparing task to the following functions. Hence
+  // the static check is only made once (should help the compiler).  
+  // These functions assume tuples to be of the same length.
+
+
+template<class T1, class T2>
+inline bool eq(const T1& lhs, const T2& rhs) {
+  return lhs.get_head() == rhs.get_head() &&
+         eq(lhs.get_tail(), rhs.get_tail());
+}
+template<>
+inline bool eq<null_type,null_type>(const null_type&, const null_type&) { return true; }
+
+template<class T1, class T2>
+inline bool neq(const T1& lhs, const T2& rhs) {
+  return lhs.get_head() != rhs.get_head()  ||
+         neq(lhs.get_tail(), rhs.get_tail());
+}
+template<>
+inline bool neq<null_type,null_type>(const null_type&, const null_type&) { return false; }
+
+template<class T1, class T2>
+inline bool lt(const T1& lhs, const T2& rhs) {
+  return lhs.get_head() < rhs.get_head()  ||
+          ( !(rhs.get_head() < lhs.get_head()) &&
+            lt(lhs.get_tail(), rhs.get_tail()));
+}
+template<>
+inline bool lt<null_type,null_type>(const null_type&, const null_type&) { return false; }
+
+template<class T1, class T2>
+inline bool gt(const T1& lhs, const T2& rhs) {
+  return lhs.get_head() > rhs.get_head()  ||
+          ( !(rhs.get_head() > lhs.get_head()) &&
+            gt(lhs.get_tail(), rhs.get_tail()));
+}
+template<>
+inline bool gt<null_type,null_type>(const null_type&, const null_type&) { return false; }
+
+template<class T1, class T2>
+inline bool lte(const T1& lhs, const T2& rhs) {
+  return lhs.get_head() <= rhs.get_head()  &&
+          ( !(rhs.get_head() <= lhs.get_head()) ||
+            lte(lhs.get_tail(), rhs.get_tail()));
+}
+template<>
+inline bool lte<null_type,null_type>(const null_type&, const null_type&) { return true; }
+
+template<class T1, class T2>
+inline bool gte(const T1& lhs, const T2& rhs) {
+  return lhs.get_head() >= rhs.get_head()  &&
+          ( !(rhs.get_head() >= lhs.get_head()) ||
+            gte(lhs.get_tail(), rhs.get_tail()));
+}
+template<>
+inline bool gte<null_type,null_type>(const null_type&, const null_type&) { return true; }
+
+} // end of namespace detail
+
+
+// equal ----
+
+template<class T1, class T2, class S1, class S2>
+inline bool operator==(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
+{
+  // check that tuple lengths are equal
+  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
+
+  return  detail::eq(lhs, rhs);
+}
+
+// not equal -----
+
+template<class T1, class T2, class S1, class S2>
+inline bool operator!=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
+{
+
+  // check that tuple lengths are equal
+  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
+
+  return detail::neq(lhs, rhs);
+}
+
+// <
+template<class T1, class T2, class S1, class S2>
+inline bool operator<(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
+{
+  // check that tuple lengths are equal
+  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
+
+  return detail::lt(lhs, rhs);
+}
+
+// >
+template<class T1, class T2, class S1, class S2>
+inline bool operator>(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
+{
+  // check that tuple lengths are equal
+  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
+
+  return detail::gt(lhs, rhs);
+}
+
+// <=
+template<class T1, class T2, class S1, class S2>
+inline bool operator<=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
+{
+  // check that tuple lengths are equal
+  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
+
+  return detail::lte(lhs, rhs);
+}
+
+// >=
+template<class T1, class T2, class S1, class S2>
+inline bool operator>=(const cons<T1, T2>& lhs, const cons<S1, S2>& rhs)
+{
+  // check that tuple lengths are equal
+  BOOST_STATIC_ASSERT(length<T2>::value == length<S2>::value);
+
+  return detail::gte(lhs, rhs);
+}
+
+} // end of namespace tuples
+} // end of namespace boost
+
+
+#endif // BOOST_TUPLE_COMPARISON_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/tuple/tuple_io.hpp b/contrib/libboost/boost_1_65_0/boost/tuple/tuple_io.hpp
new file mode 100644
index 00000000000..99cf36cb0da
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/tuple/tuple_io.hpp
@@ -0,0 +1,341 @@
+// tuple_io.hpp --------------------------------------------------------------
+
+// Copyright (C) 2001 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+//               2001 Gary Powell (gary.powell@sierra.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)
+// For more information, see http://www.boost.org 
+
+// ----------------------------------------------------------------------------
+
+#ifndef BOOST_TUPLE_IO_HPP
+#define BOOST_TUPLE_IO_HPP
+
+#include <istream>
+#include <ostream>
+
+#include <sstream>
+
+#include "boost/tuple/tuple.hpp"
+
+// This is ugly: one should be using twoargument isspace since whitspace can
+// be locale dependent, in theory at least.
+// not all libraries implement have the two-arg version, so we need to 
+// use the one-arg one, which one should get with <cctype> but there seem
+// to be exceptions to this.
+
+#if !defined (BOOST_NO_STD_LOCALE)
+
+#include <locale> // for two-arg isspace
+
+#else 
+
+#include <cctype> // for one-arg (old) isspace 
+#include <ctype.h> // Metrowerks does not find one-arg isspace from cctype
+
+#endif
+
+namespace boost {
+namespace tuples {
+
+namespace detail {
+
+class format_info {
+public:   
+
+   enum manipulator_type { open, close, delimiter };
+   BOOST_STATIC_CONSTANT(int, number_of_manipulators = delimiter + 1);
+private:
+   
+   static int get_stream_index (int m)
+   {
+     static const int stream_index[number_of_manipulators]
+        = { std::ios::xalloc(), std::ios::xalloc(), std::ios::xalloc() };
+
+     return stream_index[m];
+   }
+
+   format_info(const format_info&);
+   format_info();   
+
+
+public:
+
+   template<class CharType, class CharTrait>
+   static CharType get_manipulator(std::basic_ios<CharType, CharTrait>& i, 
+                                   manipulator_type m) {
+     // The manipulators are stored as long.
+     // A valid instanitation of basic_stream allows CharType to be any POD,
+     // hence, the static_cast may fail (it fails if long is not convertible 
+     // to CharType
+     CharType c = static_cast<CharType>(i.iword(get_stream_index(m)) ); 
+     // parentheses and space are the default manipulators
+     if (!c) {
+       switch(m) {
+         case detail::format_info::open :  c = i.widen('('); break;
+         case detail::format_info::close : c = i.widen(')'); break;
+         case detail::format_info::delimiter : c = i.widen(' '); break;
+       }
+     }
+     return c;
+   }
+
+
+   template<class CharType, class CharTrait>
+   static void set_manipulator(std::basic_ios<CharType, CharTrait>& i, 
+                               manipulator_type m, CharType c) {
+     // The manipulators are stored as long.
+     // A valid instanitation of basic_stream allows CharType to be any POD,
+     // hence, the static_cast may fail (it fails if CharType is not 
+     // convertible long.
+      i.iword(get_stream_index(m)) = static_cast<long>(c);
+   }
+};
+
+} // end of namespace detail
+ 
+template<class CharType>    
+class tuple_manipulator {
+  const detail::format_info::manipulator_type mt;
+  CharType f_c;
+public:
+  explicit tuple_manipulator(detail::format_info::manipulator_type m, 
+                             const char c = 0)
+     : mt(m), f_c(c) {}
+  
+   template<class CharTrait>
+  void set(std::basic_ios<CharType, CharTrait> &io) const {
+     detail::format_info::set_manipulator(io, mt, f_c);
+  }
+};
+
+
+template<class CharType, class CharTrait>
+inline std::basic_ostream<CharType, CharTrait>&
+operator<<(std::basic_ostream<CharType, CharTrait>& o, const tuple_manipulator<CharType>& m) {
+  m.set(o);
+  return o;
+}
+
+template<class CharType, class CharTrait>
+inline std::basic_istream<CharType, CharTrait>&
+operator>>(std::basic_istream<CharType, CharTrait>& i, const tuple_manipulator<CharType>& m) {
+  m.set(i);
+  return i;
+}
+
+   
+template<class CharType>
+inline tuple_manipulator<CharType> set_open(const CharType c) {
+   return tuple_manipulator<CharType>(detail::format_info::open, c);
+}
+
+template<class CharType>
+inline tuple_manipulator<CharType> set_close(const CharType c) {
+   return tuple_manipulator<CharType>(detail::format_info::close, c);
+}
+
+template<class CharType>
+inline tuple_manipulator<CharType> set_delimiter(const CharType c) {
+   return tuple_manipulator<CharType>(detail::format_info::delimiter, c);
+}
+
+
+
+   
+   
+// -------------------------------------------------------------
+// printing tuples to ostream in format (a b c)
+// parentheses and space are defaults, but can be overriden with manipulators
+// set_open, set_close and set_delimiter
+   
+namespace detail {
+
+// Note: The order of the print functions is critical 
+// to let a conforming compiler  find and select the correct one.
+
+
+template<class CharType, class CharTrait, class T1>
+inline std::basic_ostream<CharType, CharTrait>& 
+print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, null_type>& t) {
+  return o << t.head;
+}
+
+ 
+template<class CharType, class CharTrait>
+inline std::basic_ostream<CharType, CharTrait>& 
+print(std::basic_ostream<CharType, CharTrait>& o, const null_type&) { 
+  return o; 
+}
+
+template<class CharType, class CharTrait, class T1, class T2>
+inline std::basic_ostream<CharType, CharTrait>& 
+print(std::basic_ostream<CharType, CharTrait>& o, const cons<T1, T2>& t) {
+  
+  const CharType d = format_info::get_manipulator(o, format_info::delimiter);
+   
+  o << t.head;
+
+  o << d;
+
+  return print(o, t.tail);
+}
+
+template<class CharT, class Traits, class T>
+inline bool handle_width(std::basic_ostream<CharT, Traits>& o, const T& t) {
+    std::streamsize width = o.width();
+    if(width == 0) return false;
+
+    std::basic_ostringstream<CharT, Traits> ss;
+
+    ss.copyfmt(o);
+    ss.tie(0);
+    ss.width(0);
+
+    ss << t;
+    o << ss.str();
+
+    return true;
+}
+
+
+} // namespace detail
+
+
+template<class CharType, class CharTrait>
+inline std::basic_ostream<CharType, CharTrait>& 
+operator<<(std::basic_ostream<CharType, CharTrait>& o, 
+           const null_type& t) {
+  if (!o.good() ) return o;
+  if (detail::handle_width(o, t)) return o;
+ 
+  const CharType l = 
+    detail::format_info::get_manipulator(o, detail::format_info::open);
+  const CharType r = 
+    detail::format_info::get_manipulator(o, detail::format_info::close);
+   
+  o << l;
+  o << r;
+
+  return o;
+}
+
+template<class CharType, class CharTrait, class T1, class T2>
+inline std::basic_ostream<CharType, CharTrait>& 
+operator<<(std::basic_ostream<CharType, CharTrait>& o, 
+           const cons<T1, T2>& t) {
+  if (!o.good() ) return o;
+  if (detail::handle_width(o, t)) return o;
+ 
+  const CharType l = 
+    detail::format_info::get_manipulator(o, detail::format_info::open);
+  const CharType r = 
+    detail::format_info::get_manipulator(o, detail::format_info::close);
+   
+  o << l;   
+
+  detail::print(o, t);  
+
+  o << r;
+
+  return o;
+}
+
+   
+// -------------------------------------------------------------
+// input stream operators
+
+namespace detail {
+
+
+template<class CharType, class CharTrait>
+inline std::basic_istream<CharType, CharTrait>& 
+extract_and_check_delimiter(
+  std::basic_istream<CharType, CharTrait> &is, format_info::manipulator_type del)
+{
+  const CharType d = format_info::get_manipulator(is, del);
+
+#if defined (BOOST_NO_STD_LOCALE)
+  const bool is_delimiter = !isspace(d);
+#elif defined ( __BORLANDC__ )
+  const bool is_delimiter = !std::use_facet< std::ctype< CharType > >
+    (is.getloc() ).is( std::ctype_base::space, d);
+#else
+  const bool is_delimiter = (!std::isspace(d, is.getloc()) );            
+#endif
+
+  CharType c;
+  if (is_delimiter) { 
+    is >> c;
+    if (is.good() && c!=d) { 
+      is.setstate(std::ios::failbit);
+    }
+  } else {
+    is >> std::ws;
+  }
+  return is;
+}
+
+   
+template<class CharType, class CharTrait, class T1>
+inline  std::basic_istream<CharType, CharTrait> & 
+read (std::basic_istream<CharType, CharTrait> &is, cons<T1, null_type>& t1) {
+
+  if (!is.good()) return is;   
+   
+  return is >> t1.head; 
+}
+
+template<class CharType, class CharTrait, class T1, class T2>
+inline std::basic_istream<CharType, CharTrait>& 
+read(std::basic_istream<CharType, CharTrait> &is, cons<T1, T2>& t1) {
+
+  if (!is.good()) return is;
+   
+  is >> t1.head;
+
+
+  extract_and_check_delimiter(is, format_info::delimiter);
+
+  return read(is, t1.tail);
+}
+
+} // end namespace detail
+
+
+template<class CharType, class CharTrait>
+inline std::basic_istream<CharType, CharTrait>& 
+operator>>(std::basic_istream<CharType, CharTrait> &is, null_type&) {
+
+  if (!is.good() ) return is;
+
+  detail::extract_and_check_delimiter(is, detail::format_info::open);
+  detail::extract_and_check_delimiter(is, detail::format_info::close);
+
+  return is;
+}
+
+template<class CharType, class CharTrait, class T1, class T2>
+inline std::basic_istream<CharType, CharTrait>& 
+operator>>(std::basic_istream<CharType, CharTrait>& is, cons<T1, T2>& t1) {
+
+  if (!is.good() ) return is;
+
+  detail::extract_and_check_delimiter(is, detail::format_info::open);
+                      
+  detail::read(is, t1);
+   
+  detail::extract_and_check_delimiter(is, detail::format_info::close);
+
+  return is;
+}
+
+
+} // end of namespace tuples
+} // end of namespace boost
+
+#endif // BOOST_TUPLE_IO_HPP
+
+
diff --git a/contrib/libboost/boost_1_62_0/boost/type.hpp b/contrib/libboost/boost_1_65_0/boost/type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type.hpp
rename to contrib/libboost/boost_1_65_0/boost/type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_index.hpp b/contrib/libboost/boost_1_65_0/boost/type_index.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_index.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_index.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_index/ctti_type_index.hpp b/contrib/libboost/boost_1_65_0/boost/type_index/ctti_type_index.hpp
similarity index 99%
rename from contrib/libboost/boost_1_62_0/boost/type_index/ctti_type_index.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_index/ctti_type_index.hpp
index 611ad92e119..6832adeaf7b 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_index/ctti_type_index.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_index/ctti_type_index.hpp
@@ -22,6 +22,7 @@
 #include <boost/type_index/detail/compile_time_type_info.hpp>
 
 #include <cstring>
+#include <boost/functional/hash.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits/remove_cv.hpp>
 #include <boost/type_traits/remove_reference.hpp>
diff --git a/contrib/libboost/boost_1_62_0/boost/type_index/detail/compile_time_type_info.hpp b/contrib/libboost/boost_1_65_0/boost/type_index/detail/compile_time_type_info.hpp
similarity index 88%
rename from contrib/libboost/boost_1_62_0/boost/type_index/detail/compile_time_type_info.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_index/detail/compile_time_type_info.hpp
index 122a2ac013c..4eb2017ffc2 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_index/detail/compile_time_type_info.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_index/detail/compile_time_type_info.hpp
@@ -11,7 +11,7 @@
 
 /// \file compile_time_type_info.hpp
 /// \brief Contains helper macros and implementation details of boost::typeindex::ctti_type_index.
-/// Not intended for inclusion from user's code. 
+/// Not intended for inclusion from user's code.
 
 #include <boost/config.hpp>
 #include <boost/static_assert.hpp>
@@ -59,9 +59,12 @@
     // sizeof("static const char *boost::detail::ctti<") - 1, sizeof("]") - 1, true, "int>::n() [T = int"
     // note: checked on 3.1, 3.4
     BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(39, 1, true, "T = ")
-#elif defined(__GNUC__) && !defined(BOOST_NO_CXX14_CONSTEXPR)
-    // sizeof("static contexpr char boost::detail::ctti<T>::s() [with long unsigned int I = 0ul; T = ") - 1, sizeof("]") - 1
-    BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(87, 1, false, "")
+#elif defined(__GNUC__) && (__GNUC__ < 7) && !defined(BOOST_NO_CXX14_CONSTEXPR)
+    // sizeof("static constexpr char boost::detail::ctti<T>::s() [with unsigned int I = 0u; T = ") - 1, sizeof("]") - 1
+    BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(81, 1, false, "")
+#elif defined(__GNUC__) && (__GNUC__ >= 7) && !defined(BOOST_NO_CXX14_CONSTEXPR)
+    // sizeof("static constexpr char boost::detail::ctti<T>::s() [with unsigned int I = 0; T = ") - 1, sizeof("]") - 1
+    BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(80, 1, false, "")
 #elif defined(__GNUC__) && defined(BOOST_NO_CXX14_CONSTEXPR)
     // sizeof("static const char* boost::detail::ctti<T>::n() [with T = ") - 1, sizeof("]") - 1
     BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS(57, 1, false, "")
@@ -72,7 +75,7 @@
 
 #undef BOOST_TYPE_INDEX_REGISTER_CTTI_PARSING_PARAMS
 
-namespace boost { namespace typeindex { namespace detail { 
+namespace boost { namespace typeindex { namespace detail {
     template <bool Condition>
     BOOST_CXX14_CONSTEXPR inline void assert_compile_time_legths() BOOST_NOEXCEPT {
         BOOST_STATIC_ASSERT_MSG(
@@ -94,7 +97,7 @@ namespace boost { namespace typeindex { namespace detail {
         );
     }
 
-    template <std::size_t ArrayLength>
+    template <unsigned int ArrayLength>
     BOOST_CXX14_CONSTEXPR inline const char* skip_begining_runtime(const char* begin, boost::mpl::false_) BOOST_NOEXCEPT {
         return begin;
     }
@@ -136,7 +139,7 @@ namespace boost { namespace typeindex { namespace detail {
         return static_cast<int>(*v1) - *v2;
     }
 
-    template <std::size_t ArrayLength>
+    template <unsigned int ArrayLength>
     BOOST_CXX14_CONSTEXPR inline const char* skip_begining_runtime(const char* begin, boost::mpl::true_) BOOST_NOEXCEPT {
         const char* const it = constexpr_search(
             begin, begin + ArrayLength,
@@ -145,28 +148,28 @@ namespace boost { namespace typeindex { namespace detail {
         return (it == begin + ArrayLength ? begin : it + sizeof(ctti_skip_until_runtime) - 1);
     }
 
-    template <std::size_t ArrayLength>
+    template <unsigned int ArrayLength>
     BOOST_CXX14_CONSTEXPR inline const char* skip_begining(const char* begin) BOOST_NOEXCEPT {
         assert_compile_time_legths<(ArrayLength > ctti_skip_size_at_begin + ctti_skip_size_at_end)>();
         return skip_begining_runtime<ArrayLength - ctti_skip_size_at_begin>(
-            begin + ctti_skip_size_at_begin, 
+            begin + ctti_skip_size_at_begin,
             boost::mpl::bool_<ctti_skip_more_at_runtime>()
         );
     }
 
 #if !defined(__clang__) && defined(__GNUC__) && !defined(BOOST_NO_CXX14_CONSTEXPR)
-    template <std::size_t... I>
+    template <unsigned int... I>
     struct index_seq {};
 
     template <typename Left, typename Right>
     struct make_index_sequence_join;
 
-    template <std::size_t... Left, std::size_t... Right>
+    template <unsigned int... Left, unsigned int... Right>
     struct make_index_sequence_join<index_seq<Left...>, index_seq<Right...> > {
         typedef index_seq<Left..., Right...> type;
     };
 
-    template <std::size_t C, std::size_t D>
+    template <unsigned int C, unsigned int D>
     struct make_index_seq_impl {
         typedef typename make_index_sequence_join<
             typename make_index_seq_impl<C, D / 2>::type,
@@ -174,19 +177,19 @@ namespace boost { namespace typeindex { namespace detail {
         >::type type;
     };
 
-    template <std::size_t C>
+    template <unsigned int C>
     struct make_index_seq_impl<C, 0> {
         typedef index_seq<> type;
     };
 
-    template <std::size_t C>
+    template <unsigned int C>
     struct make_index_seq_impl<C, 1> {
         typedef index_seq<C> type;
     };
 
     template <char... C>
     struct cstring {
-        static constexpr std::size_t size_ = sizeof...(C);
+        static constexpr unsigned int size_ = sizeof...(C);
         static constexpr char data_[size_] = { C... };
     };
 
@@ -203,12 +206,12 @@ namespace boost { namespace detail {
 /// This name must be as short as possible, to avoid code bloat
 template <class T>
 struct ctti {
-   
+
 #if !defined(__clang__) && defined(__GNUC__) && !defined(BOOST_NO_CXX14_CONSTEXPR)
     //helper functions
-    template <std::size_t I>
+    template <unsigned int I>
     constexpr static char s() BOOST_NOEXCEPT { // step
-        constexpr std::size_t offset =
+        constexpr unsigned int offset =
                   (I >= 10u      ? 1u : 0u)
                 + (I >= 100u     ? 1u : 0u)
                 + (I >= 1000u    ? 1u : 0u)
@@ -226,17 +229,17 @@ struct ctti {
     #endif
     }
 
-    template <std::size_t ...Indexes>
+    template <unsigned int ...Indexes>
     constexpr static const char* impl(::boost::typeindex::detail::index_seq<Indexes...> ) BOOST_NOEXCEPT {
         return ::boost::typeindex::detail::cstring<s<Indexes>()...>::data_;
     }
 
-    template <std::size_t D = 0> // `D` means `Dummy`
+    template <unsigned int D = 0> // `D` means `Dummy`
     constexpr static const char* n() BOOST_NOEXCEPT {
     #if defined(BOOST_TYPE_INDEX_FUNCTION_SIGNATURE)
-        constexpr std::size_t size = sizeof(BOOST_TYPE_INDEX_FUNCTION_SIGNATURE);
+        constexpr unsigned int size = sizeof(BOOST_TYPE_INDEX_FUNCTION_SIGNATURE);
     #elif defined(__FUNCSIG__)
-        constexpr std::size_t size = sizeof(__FUNCSIG__);
+        constexpr unsigned int size = sizeof(__FUNCSIG__);
     #elif defined(__PRETTY_FUNCTION__) \
                     || defined(__GNUC__) \
                     || (defined(__SUNPRO_CC) && (__SUNPRO_CC >= 0x5130)) \
@@ -244,7 +247,7 @@ struct ctti {
                     || (defined(__ICC) && (__ICC >= 600)) \
                     || defined(__ghs__) \
                     || defined(__DMC__)
-        constexpr std::size_t size = sizeof(__PRETTY_FUNCTION__);
+        constexpr unsigned int size = sizeof(__PRETTY_FUNCTION__);
     #else
         boost::typeindex::detail::failed_to_get_function_name();
     #endif
@@ -286,4 +289,3 @@ struct ctti {
 }} // namespace boost::detail
 
 #endif // BOOST_TYPE_INDEX_DETAIL_COMPILE_TIME_TYPE_INFO_HPP
-
diff --git a/contrib/libboost/boost_1_62_0/boost/type_index/detail/ctti_register_class.hpp b/contrib/libboost/boost_1_65_0/boost/type_index/detail/ctti_register_class.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_index/detail/ctti_register_class.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_index/detail/ctti_register_class.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_index/detail/stl_register_class.hpp b/contrib/libboost/boost_1_65_0/boost/type_index/detail/stl_register_class.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_index/detail/stl_register_class.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_index/detail/stl_register_class.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast.hpp b/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast.hpp
new file mode 100644
index 00000000000..c72b11916b1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast.hpp
@@ -0,0 +1,28 @@
+//
+// Copyright (c) Chris Glover, 2016.
+//
+//
+// 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_TYPE_INDEX_RUNTIME_CAST_HPP
+#define BOOST_TYPE_INDEX_RUNTIME_CAST_HPP
+
+/// \file runtime_cast.hpp
+/// \brief Contains the basic utilities necessary to fully emulate
+/// dynamic_cast for language level constructs (raw pointers and references).
+///
+/// boost::typeindex::runtime_cast is a drop in replacement for dynamic_cast
+/// that can be used in situations where traditional rtti is either unavailable
+/// or undesirable.
+
+#include <boost/type_index/runtime_cast/register_runtime_class.hpp>
+#include <boost/type_index/runtime_cast/pointer_cast.hpp>
+#include <boost/type_index/runtime_cast/reference_cast.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+#endif // BOOST_TYPE_INDEX_RUNTIME_CAST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/boost_shared_ptr_cast.hpp b/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/boost_shared_ptr_cast.hpp
new file mode 100644
index 00000000000..e31f19d7286
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/boost_shared_ptr_cast.hpp
@@ -0,0 +1,46 @@
+//
+// Copyright (c) Chris Glover, 2016.
+//
+//
+// 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_TYPE_INDEX_RUNTIME_CAST_BOOST_SHARED_PTR_CAST_HPP
+#define BOOST_TYPE_INDEX_RUNTIME_CAST_BOOST_SHARED_PTR_CAST_HPP
+
+/// \file boost_shared_ptr_cast.hpp
+/// \brief Contains the overload of boost::typeindex::runtime_pointer_cast for
+/// boost::shared_ptr types.
+
+#include <boost/type_index/runtime_cast/detail/runtime_cast_impl.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/smart_ptr/shared_ptr.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+namespace boost { namespace typeindex {
+
+/// \brief Creates a new instance of std::shared_ptr whose stored pointer is obtained from u's
+/// stored pointer using a runtime_cast.
+///
+/// The new shared_ptr will share ownership with u, except that it is empty if the runtime_cast
+/// performed by runtime_pointer_cast returns a null pointer.
+/// \tparam T The desired target type to return a pointer of.
+/// \tparam U A complete class type of the source instance pointed to from u.
+/// \return If there exists a valid conversion from U* to T*, returns a boost::shared_ptr<T>
+/// that points to an address suitably offset from u.
+/// If no such conversion exists, returns boost::shared_ptr<T>();
+template<typename T, typename U>
+boost::shared_ptr<T> runtime_pointer_cast(boost::shared_ptr<U> const& u) {
+    T* value = detail::runtime_cast_impl<T>(u.get(), boost::is_base_and_derived<T, U>());
+    if(value)
+        return boost::shared_ptr<T>(u, value);
+    return boost::shared_ptr<T>();
+}
+
+}} // namespace boost::typeindex
+
+#endif // BOOST_TYPE_INDEX_RUNTIME_CAST_BOOST_SHARED_PTR_CAST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/detail/runtime_cast_impl.hpp b/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/detail/runtime_cast_impl.hpp
new file mode 100644
index 00000000000..6181df60f58
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/detail/runtime_cast_impl.hpp
@@ -0,0 +1,57 @@
+//
+// Copyright (c) Chris Glover, 2016.
+//
+//
+// 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_TYPE_INDEX_RUNTIME_CAST_DETAIL_RUNTIME_CAST_IMPL_HPP
+#define BOOST_TYPE_INDEX_RUNTIME_CAST_DETAIL_RUNTIME_CAST_IMPL_HPP
+
+/// \file runtime_cast_impl.hpp
+/// \brief Contains the overload of boost::typeindex::runtime_cast for
+/// pointer types.
+///
+/// boost::typeindex::runtime_cast can be used to emulate dynamic_cast
+/// functionality on platorms that don't provide it or should the user
+/// desire opt in functionality instead of enabling it system wide.
+
+#include <boost/type_index.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+namespace boost { namespace typeindex {
+
+namespace detail {
+
+template<typename T, typename U>
+T* runtime_cast_impl(U* u, boost::true_type) BOOST_NOEXCEPT {
+    return u;
+}
+
+template<typename T, typename U>
+T const* runtime_cast_impl(U const* u, boost::true_type) BOOST_NOEXCEPT {
+    return u;
+}
+
+template<typename T, typename U>
+T* runtime_cast_impl(U* u, boost::false_type) BOOST_NOEXCEPT {
+    return const_cast<T*>(static_cast<T const*>(
+        u->boost_type_index_find_instance_(boost::typeindex::type_id<T>())
+    ));
+}
+
+template<typename T, typename U>
+T const* runtime_cast_impl(U const* u, boost::false_type) BOOST_NOEXCEPT {
+    return static_cast<T const*>(u->boost_type_index_find_instance_(boost::typeindex::type_id<T>()));
+}
+
+} // namespace detail
+
+}} // namespace boost::typeindex
+
+#endif // BOOST_TYPE_INDEX_RUNTIME_CAST_DETAIL_RUNTIME_CAST_IMPL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/pointer_cast.hpp b/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/pointer_cast.hpp
new file mode 100644
index 00000000000..49a761390ca
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/pointer_cast.hpp
@@ -0,0 +1,74 @@
+//
+// Copyright (c) Chris Glover, 2016.
+//
+//
+// 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_TYPE_INDEX_RUNTIME_CAST_POINTER_CAST_HPP
+#define BOOST_TYPE_INDEX_RUNTIME_CAST_POINTER_CAST_HPP
+
+/// \file pointer_class.hpp
+/// \brief Contains the function overloads of boost::typeindex::runtime_cast for
+/// pointer types.
+#include <boost/type_index.hpp>
+#include <boost/type_index/runtime_cast/detail/runtime_cast_impl.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+namespace boost { namespace typeindex {
+
+/// \brief Safely converts pointers to classes up, down, and sideways along the inheritance hierarchy.
+/// \tparam T The desired target type. Like dynamic_cast, must be a pointer to complete class type.
+/// \tparam U A complete class type of the source instance, u.
+/// \return If there exists a valid conversion from U* to T, returns a T that points to
+/// an address suitably offset from u. If no such conversion exists, returns NULL.
+template<typename T, typename U>
+T runtime_cast(U* u) BOOST_NOEXCEPT {
+    typedef typename boost::remove_pointer<T>::type impl_type;
+    return detail::runtime_cast_impl<impl_type>(u, boost::is_base_and_derived<T, U>());
+}
+
+/// \brief Safely converts pointers to classes up, down, and sideways along the inheritance hierarchy.
+/// \tparam T The desired target type. Like dynamic_cast, must be a pointer to complete class type.
+/// \tparam U A complete class type of the source instance, u.
+/// \return If there exists a valid conversion from U* to T, returns a T that points to
+/// an address suitably offset from u. If no such conversion exists, returns NULL.
+template<typename T, typename U>
+T runtime_cast(U const* u) BOOST_NOEXCEPT {
+    typedef typename boost::remove_pointer<T>::type impl_type;
+    return detail::runtime_cast_impl<impl_type>(u, boost::is_base_and_derived<T, U>());
+}
+
+/// \brief Safely converts pointers to classes up, down, and sideways along the inheritance
+/// hierarchy.
+/// \tparam T The desired target type to return a pointer to.
+/// \tparam U A complete class type of the source instance, u.
+/// \return If there exists a valid conversion from U const* to T*, returns a T*
+/// that points to an address suitably offset from u.
+/// If no such conversion exists, returns NULL.
+template<typename T, typename U>
+T* runtime_pointer_cast(U* u) BOOST_NOEXCEPT {
+    return detail::runtime_cast_impl<T>(u, boost::is_base_and_derived<T, U>());
+}
+
+/// \brief Safely converts pointers to classes up, down, and sideways along the inheritance
+/// hierarchy.
+/// \tparam T The desired target type to return a pointer to.
+/// \tparam U A complete class type of the source instance, u.
+/// \return If there exists a valid conversion from U const* to T const*, returns a T const*
+/// that points to an address suitably offset from u.
+/// If no such conversion exists, returns NULL.
+template<typename T, typename U>
+T const* runtime_pointer_cast(U const* u) BOOST_NOEXCEPT {
+    return detail::runtime_cast_impl<T>(u, boost::is_base_and_derived<T, U>());
+}
+
+}} // namespace boost::typeindex
+
+#endif // BOOST_TYPE_INDEX_RUNTIME_CAST_POINTER_CAST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/reference_cast.hpp b/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/reference_cast.hpp
new file mode 100644
index 00000000000..1511f7d0313
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/reference_cast.hpp
@@ -0,0 +1,66 @@
+//
+// Copyright (c) Chris Glover, 2016.
+//
+//
+// 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_TYPE_INDEX_RUNTIME_CAST_REFERENCE_CAST_HPP
+#define BOOST_TYPE_INDEX_RUNTIME_CAST_REFERENCE_CAST_HPP
+
+/// \file reference_cast.hpp
+/// \brief Contains the overload of boost::typeindex::runtime_cast for
+/// reference types.
+
+#include <boost/core/addressof.hpp>
+#include <boost/type_index/runtime_cast/detail/runtime_cast_impl.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+namespace boost { namespace typeindex {
+
+/// \brief Indicates that runtime_cast was unable to perform the desired cast operation
+/// because the source instance was not also an instance of the target type.
+struct bad_runtime_cast : std::exception
+{};
+
+/// \brief Safely converts references to classes up, down, and sideways along the inheritance hierarchy.
+/// \tparam T The desired target type. Like dynamic_cast, must be a pointer to complete class type.
+/// \tparam U A complete class type of the source instance, u.
+/// \return If there exists a valid conversion from U& to T, returns a T that references an address
+/// suitably offset from u. If no such conversion exists, throws boost::typeindex::bad_runtime_cast.
+template<typename T, typename U>
+typename boost::add_reference<T>::type runtime_cast(U& u) {
+    typedef typename boost::remove_reference<T>::type impl_type;
+    impl_type* value = detail::runtime_cast_impl<impl_type>(
+        boost::addressof(u), boost::is_base_and_derived<T, U>());
+    if(!value)
+        BOOST_THROW_EXCEPTION(bad_runtime_cast());
+    return *value;
+}
+
+/// \brief Safely converts references to classes up, down, and sideways along the inheritance hierarchy.
+/// \tparam T The desired target type. Like dynamic_cast, must be a pointer to complete class type.
+/// \tparam U A complete class type of the source instance, u.
+/// \return If there exists a valid conversion from U const& to T const, returns a T const that references an address
+/// suitably offset from u. If no such conversion exists, throws boost::typeindex::bad_runtime_cast.
+template<typename T, typename U>
+typename boost::add_reference<const T>::type runtime_cast(U const& u) {
+    typedef typename boost::remove_reference<T>::type impl_type;
+    impl_type* value = detail::runtime_cast_impl<impl_type>(
+        boost::addressof(u), boost::is_base_and_derived<T, U>());
+    if(!value)
+        BOOST_THROW_EXCEPTION(bad_runtime_cast());
+    return *value;
+}
+
+}} // namespace boost::typeindex
+
+#endif // BOOST_TYPE_INDEX_RUNTIME_CAST_REFERENCE_CAST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/register_runtime_class.hpp b/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/register_runtime_class.hpp
new file mode 100644
index 00000000000..995007487bd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/register_runtime_class.hpp
@@ -0,0 +1,138 @@
+//
+// Copyright (c) Chris Glover, 2016.
+//
+//
+// 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_TYPE_INDEX_RUNTIME_CAST_REGISTER_RUNTIME_CLASS_HPP
+#define BOOST_TYPE_INDEX_RUNTIME_CAST_REGISTER_RUNTIME_CLASS_HPP
+
+/// \file register_runtime_class.hpp
+/// \brief Contains the macros BOOST_TYPE_INDEX_IMPLEMENT_RUNTIME_CAST and
+/// BOOST_TYPE_INDEX_REGISTER_RUNTIME_CLASS
+#include <boost/type_index.hpp>
+#include <boost/preprocessor/seq/for_each.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+namespace boost { namespace typeindex {
+
+namespace detail {
+
+template<typename T>
+inline type_index runtime_class_construct_type_id(T const*) {
+    return type_id<T>();
+}
+
+} // namespace detail
+
+}} // namespace boost::typeindex
+
+/// @cond
+
+#define BOOST_TYPE_INDEX_CHECK_BASE_(r, data, Base) \
+    if(void const* ret_val = this->Base::boost_type_index_find_instance_(idx)) return ret_val;
+
+/// @endcond
+
+/// \def BOOST_TYPE_INDEX_REGISTER_RUNTIME_CLASS
+/// \brief Macro used to make a class compatible with boost::typeindex::runtime_cast
+///
+/// BOOST_TYPE_INDEX_REGISTER_RUNTIME_CLASS generates a virtual function
+/// in the current class that, when combined with the supplied base class information, allows
+/// boost::typeindex::runtime_cast to accurately convert between dynamic types of instances of
+/// the current class.
+///
+/// BOOST_TYPE_INDEX_REGISTER_RUNTIME_CLASS also adds support for boost::typeindex::type_id_runtime
+/// by including BOOST_TYPE_INDEX_REGISTER_CLASS. It is typical that these features are used together,
+/// but in the event that BOOST_TYPE_INDEX_REGISTER_CLASS is undesirable in the current class,
+/// BOOST_TYPE_INDEX_IMPLEMENT_RUNTIME_CAST is provided.
+///
+/// \b Example:
+/// \code
+/// struct base1 {
+///     BOOST_TYPE_INDEX_REGISTER_RUNTIME_CLASS(BOOST_TYPE_INDEX_NO_BASE_CLASS)
+///     virtual ~base1();
+/// };
+///
+/// struct base2 {
+///     BOOST_TYPE_INDEX_REGISTER_RUNTIME_CLASS(BOOST_TYPE_INDEX_NO_BASE_CLASS)
+///     virtual ~base2();
+/// };
+///
+/// struct derived1 : base1 {
+///     BOOST_TYPE_INDEX_REGISTER_RUNTIME_CLASS((base1))
+/// };
+///
+/// struct derived2 : base1, base2 {
+///     BOOST_TYPE_INDEX_REGISTER_RUNTIME_CLASS((base1)(base2))
+/// };
+///
+/// ...
+///
+/// base1* pb1 = get_object();
+/// if(derived2* pb2 = boost::typeindex::runtime_cast<derived2*>(pb1)) {
+///     assert(boost::typeindex::type_id_runtime(*pb1)) == boost::typeindex::type_id<derived2>());
+/// }
+/// \endcode
+///
+/// \param base_class_seq A Boost.Preprocessor sequence of the current class' direct bases, or
+/// BOOST_TYPE_INDEX_NO_BASE_CLASS if this class has no direct base classes.
+#define BOOST_TYPE_INDEX_REGISTER_RUNTIME_CLASS(base_class_seq)                                                          \
+    BOOST_TYPE_INDEX_REGISTER_CLASS 																					 \
+    BOOST_TYPE_INDEX_IMPLEMENT_RUNTIME_CAST(base_class_seq)
+
+/// \def BOOST_TYPE_INDEX_IMPLEMENT_RUNTIME_CAST
+/// \brief Macro used to make a class compatible with boost::typeindex::runtime_cast without including
+/// support for boost::typeindex::type_id_runtime.
+///
+/// BOOST_TYPE_INDEX_IMPLEMENT_RUNTIME_CAST is provided as an alternative to BOOST_TYPE_INDEX_REGISTER_RUNTIME_CLASS
+/// in the event that support for boost::typeindex::type_id_runtime is undesirable.
+///
+/// \b Example:
+/// \code
+/// struct base1 {
+///     BOOST_TYPE_INDEX_IMPLEMENT_RUNTIME_CAST(BOOST_TYPE_INDEX_NO_BASE_CLASS)
+///     virtual ~base1();
+/// };
+///
+/// struct base2 {
+///     BOOST_TYPE_INDEX_IMPLEMENT_RUNTIME_CAST(BOOST_TYPE_INDEX_NO_BASE_CLASS)
+///     virtual ~base2();
+/// };
+///
+/// struct derived1 : base1 {
+///     BOOST_TYPE_INDEX_IMPLEMENT_RUNTIME_CAST((base1))
+/// };
+///
+/// struct derived2 : base1, base2 {
+///     BOOST_TYPE_INDEX_IMPLEMENT_RUNTIME_CAST((base1)(base2))
+/// };
+///
+/// ...
+///
+/// base1* pb1 = get_object();
+/// if(derived2* pb2 = boost::typeindex::runtime_cast<derived2*>(pb1))
+/// { /* can't call boost::typeindex::type_id_runtime(*pb1) here */ }
+/// \endcode
+///
+/// \param base_class_seq A Boost.Preprocessor sequence of the current class' direct bases, or
+/// BOOST_TYPE_INDEX_NO_BASE_CLASS if this class has no direct base classes.
+#define BOOST_TYPE_INDEX_IMPLEMENT_RUNTIME_CAST(base_class_seq)                                                          \
+    virtual void const* boost_type_index_find_instance_(boost::typeindex::type_index const& idx) const BOOST_NOEXCEPT {  \
+        if(idx == boost::typeindex::detail::runtime_class_construct_type_id(this))                                       \
+            return this;                                                                                                 \
+         BOOST_PP_SEQ_FOR_EACH(BOOST_TYPE_INDEX_CHECK_BASE_, _, base_class_seq)                                          \
+         return NULL;                                                                                                    \
+    }
+
+/// \def BOOST_TYPE_INDEX_NO_BASE_CLASS
+/// \brief Instructs BOOST_TYPE_INDEX_REGISTER_RUNTIME_CLASS and BOOST_TYPE_INDEX_IMPLEMENT_RUNTIME_CAST
+/// that this class has no base classes.
+#define BOOST_TYPE_INDEX_NO_BASE_CLASS BOOST_PP_SEQ_NIL
+
+#endif // BOOST_TYPE_INDEX_RUNTIME_CAST_REGISTER_RUNTIME_CLASS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/std_shared_ptr_cast.hpp b/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/std_shared_ptr_cast.hpp
new file mode 100644
index 00000000000..277a5242600
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/type_index/runtime_cast/std_shared_ptr_cast.hpp
@@ -0,0 +1,46 @@
+//
+// Copyright (c) Chris Glover, 2016.
+//
+//
+// 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_TYPE_INDEX_RUNTIME_CAST_STD_SHARED_PTR_CAST_HPP
+#define BOOST_TYPE_INDEX_RUNTIME_CAST_STD_SHARED_PTR_CAST_HPP
+
+/// \file std_shared_ptr_cast.hpp
+/// \brief Contains the overload of boost::typeindex::runtime_pointer_cast for
+/// std::shared_ptr types.
+
+#include <boost/type_index/runtime_cast/detail/runtime_cast_impl.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+#include <memory>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+# pragma once
+#endif
+
+namespace boost { namespace typeindex {
+
+/// \brief Creates a new instance of std::shared_ptr whose stored pointer is obtained from u's
+/// stored pointer using a runtime_cast.
+///
+/// The new shared_ptr will share ownership with u, except that it is empty if the runtime_cast
+/// performed by runtime_pointer_cast returns a null pointer.
+/// \tparam T The desired target type to return a pointer of.
+/// \tparam U A complete class type of the source instance pointed to from u.
+/// \return If there exists a valid conversion from U* to T*, returns a std::shared_ptr<T>
+/// that points to an address suitably offset from u.
+/// If no such conversion exists, returns std::shared_ptr<T>();
+template<typename T, typename U>
+std::shared_ptr<T> runtime_pointer_cast(std::shared_ptr<U> const& u) {
+    T* value = detail::runtime_cast_impl<T>(u.get(), boost::is_base_and_derived<T, U>());
+    if(value)
+        return std::shared_ptr<T>(u, value);
+    return std::shared_ptr<T>();
+}
+
+}} // namespace boost::typeindex
+
+#endif // BOOST_TYPE_INDEX_RUNTIME_CAST_STD_SHARED_PTR_CAST_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/type_index/stl_type_index.hpp b/contrib/libboost/boost_1_65_0/boost/type_index/stl_type_index.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/type_index/stl_type_index.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_index/stl_type_index.hpp
index a5add887163..dcc532d03ba 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_index/stl_type_index.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_index/stl_type_index.hpp
@@ -1,5 +1,5 @@
 //
-// Copyright (c) Antony Polukhin, 2013-2015.
+// Copyright (c) Antony Polukhin, 2013-2017.
 //
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -40,6 +40,12 @@
 #include <boost/mpl/if.hpp>
 #include <boost/mpl/or.hpp>
 
+#if !((defined(_MSC_VER) && _MSC_VER > 1600) \
+    || (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ > 5 && defined(__GXX_EXPERIMENTAL_CXX0X__)) \
+    || (defined(__GNUC__) && __GNUC__ > 4 && __cplusplus >= 201103 ))
+#   include <boost/functional/hash.hpp>
+#endif
+
 #if (defined(__EDG_VERSION__) && __EDG_VERSION__ < 245) \
         || (defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 744)
 #   include <boost/type_traits/is_signed.hpp>
@@ -174,7 +180,9 @@ inline std::string stl_type_index::pretty_name() const {
 
 
 inline std::size_t stl_type_index::hash_code() const BOOST_NOEXCEPT {
-#if _MSC_VER > 1600 || (__GNUC__ == 4 && __GNUC_MINOR__ > 5 && defined(__GXX_EXPERIMENTAL_CXX0X__))
+#if (defined(_MSC_VER) && _MSC_VER > 1600) \
+    || (defined(__GNUC__) && __GNUC__ == 4 && __GNUC_MINOR__ > 5 && defined(__GXX_EXPERIMENTAL_CXX0X__)) \
+    || (defined(__GNUC__) && __GNUC__ > 4 && __cplusplus >= 201103)
     return data_->hash_code();
 #else
     return boost::hash_range(raw_name(), raw_name() + std::strlen(raw_name()));
diff --git a/contrib/libboost/boost_1_62_0/boost/type_index/type_index_facade.hpp b/contrib/libboost/boost_1_65_0/boost/type_index/type_index_facade.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/type_index/type_index_facade.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_index/type_index_facade.hpp
index dd35df2caa3..110000c33d5 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_index/type_index_facade.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_index/type_index_facade.hpp
@@ -103,7 +103,8 @@ public:
 
     /// \b Override: This function \b may be redefined in Derived class. Overrides \b must not throw.
     /// \return Hash code of a type. By default hashes types by raw_name().
-    /// \note <boost/functional/hash.hpp> has to be included if this function is used.
+    /// \note Derived class header \b must include <boost/functional/hash.hpp>, \b unless this function is redefined in
+    /// Derived class to not use boost::hash_range().
     inline std::size_t hash_code() const BOOST_NOEXCEPT {
         const char* const name_raw = derived().raw_name();
         return boost::hash_range(name_raw, name_raw + std::strlen(name_raw));
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/type_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits.hpp
index 7d651ce28d5..dbc8c952c97 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits.hpp
@@ -130,11 +130,13 @@
 #include <boost/type_traits/is_volatile.hpp>
 #include <boost/type_traits/make_signed.hpp>
 #include <boost/type_traits/make_unsigned.hpp>
+#include <boost/type_traits/make_void.hpp>
 #include <boost/type_traits/rank.hpp>
 #include <boost/type_traits/remove_all_extents.hpp>
 #include <boost/type_traits/remove_bounds.hpp>
 #include <boost/type_traits/remove_const.hpp>
 #include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_cv_ref.hpp>
 #include <boost/type_traits/remove_extent.hpp>
 #include <boost/type_traits/remove_pointer.hpp>
 #include <boost/type_traits/remove_reference.hpp>
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/add_const.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/add_const.hpp
similarity index 91%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/add_const.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/add_const.hpp
index a9fb781c789..2d60118276c 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/add_const.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/add_const.hpp
@@ -41,6 +41,12 @@ namespace boost {
       typedef T& type;
    };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using add_const_t = typename add_const<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_ADD_CONST_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/add_cv.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/add_cv.hpp
similarity index 91%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/add_cv.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/add_cv.hpp
index e62ddee0c45..425d019bf6c 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/add_cv.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/add_cv.hpp
@@ -36,6 +36,12 @@ template <class T> struct add_cv{ typedef T const volatile type; };
 
 template <class T> struct add_cv<T&>{ typedef T& type; };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using add_cv_t = typename add_cv<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_ADD_CV_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/add_lvalue_reference.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/add_lvalue_reference.hpp
similarity index 80%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/add_lvalue_reference.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/add_lvalue_reference.hpp
index 41851a1f349..26b74e67ca3 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/add_lvalue_reference.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/add_lvalue_reference.hpp
@@ -22,6 +22,12 @@ template <class T> struct add_lvalue_reference<T&&>
 };
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;
+
+#endif
+
 }
 
 #endif  // BOOST_TYPE_TRAITS_EXT_ADD_LVALUE_REFERENCE__HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/add_pointer.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/add_pointer.hpp
similarity index 91%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/add_pointer.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/add_pointer.hpp
index 745f63a084f..85ad33a8d97 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/add_pointer.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/add_pointer.hpp
@@ -56,6 +56,12 @@ struct add_pointer
 
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using add_pointer_t = typename add_pointer<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_ADD_POINTER_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/add_reference.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/add_reference.hpp
similarity index 92%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/add_reference.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/add_reference.hpp
index 3c914154eec..33e9bc79bea 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/add_reference.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/add_reference.hpp
@@ -54,6 +54,13 @@ template <> struct add_reference<const volatile void> { typedef const volatile v
 template <> struct add_reference<volatile void> { typedef volatile void type; };
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+template <class T> using add_reference_t = typename add_reference<T>::type;
+
+#endif
+
+
 } // namespace boost
 
 #endif // BOOST_TT_ADD_REFERENCE_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/add_rvalue_reference.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/add_rvalue_reference.hpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/add_rvalue_reference.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/add_rvalue_reference.hpp
index 44ead348031..ad64894f777 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/add_rvalue_reference.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/add_rvalue_reference.hpp
@@ -58,6 +58,12 @@ template <class T> struct add_rvalue_reference
    typedef typename boost::type_traits_detail::add_rvalue_reference_imp<T>::type type;
 };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;
+
+#endif
+
 }  // namespace boost
 
 #endif  // BOOST_TYPE_TRAITS_EXT_ADD_RVALUE_REFERENCE__HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/add_volatile.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/add_volatile.hpp
similarity index 90%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/add_volatile.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/add_volatile.hpp
index 24f515c802f..253751a578e 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/add_volatile.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/add_volatile.hpp
@@ -35,6 +35,12 @@ template <class T> struct add_volatile{ typedef T volatile type; };
 
 template <class T> struct add_volatile<T&>{ typedef T& type; };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using add_volatile_t = typename add_volatile<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_ADD_VOLATILE_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/aligned_storage.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/aligned_storage.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/aligned_storage.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/aligned_storage.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/alignment_of.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/alignment_of.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/alignment_of.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/alignment_of.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/alignment_traits.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/alignment_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/alignment_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/alignment_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/arithmetic_traits.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/arithmetic_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/arithmetic_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/arithmetic_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/array_traits.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/array_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/array_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/array_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/broken_compiler_spec.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/broken_compiler_spec.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/broken_compiler_spec.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/broken_compiler_spec.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/common_type.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/common_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/common_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/common_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/composite_traits.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/composite_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/composite_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/composite_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/conditional.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/conditional.hpp
similarity index 81%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/conditional.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/conditional.hpp
index b7e82dbe824..5890198ba29 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/conditional.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/conditional.hpp
@@ -14,6 +14,12 @@ namespace boost {
 template <bool b, class T, class U> struct conditional { typedef T type; };
 template <class T, class U> struct conditional<false, T, U> { typedef U type; };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <bool b, class T, class U> using conditional_t = typename conditional<b, T, U>::type;
+
+#endif
+
 } // namespace boost
 
 
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/config.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/config.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/config.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/config.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/conversion_traits.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/conversion_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/conversion_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/conversion_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/copy_cv.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/copy_cv.hpp
similarity index 87%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/copy_cv.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/copy_cv.hpp
index 1605ca3356e..2f3dc37adc2 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/copy_cv.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/copy_cv.hpp
@@ -29,6 +29,12 @@ public:
     typedef typename boost::conditional<boost::is_volatile<U>::value, typename boost::add_volatile<CT>::type, CT>::type type;
 };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T, class U> using copy_cv_t = typename copy_cv<T, U>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // #ifndef BOOST_TYPE_TRAITS_COPY_CV_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/cv_traits.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/cv_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/cv_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/cv_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/decay.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/decay.hpp
similarity index 92%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/decay.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/decay.hpp
index 4e8118433ed..5b28d052fcd 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/decay.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/decay.hpp
@@ -37,6 +37,12 @@ namespace boost
        typedef typename boost::detail::decay_imp<Ty, boost::is_array<Ty>::value, boost::is_function<Ty>::value>::type type;
     };
     
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using decay_t = typename decay<T>::type;
+
+#endif
+
 } // namespace boost
 
 
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/declval.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/declval.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/declval.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/declval.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/bool_trait_def.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/bool_trait_def.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/bool_trait_def.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/bool_trait_def.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/bool_trait_undef.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/bool_trait_undef.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/bool_trait_undef.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/bool_trait_undef.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/common_arithmetic_type.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/common_arithmetic_type.hpp
similarity index 95%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/common_arithmetic_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/common_arithmetic_type.hpp
index 8c091583c5b..a7aff039297 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/common_arithmetic_type.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/common_arithmetic_type.hpp
@@ -46,7 +46,7 @@ template<> struct arithmetic_type<3>
 #endif
 
 // There are five standard signed integer types:
-// “signed char”, “short int”, “int”, “long int”, and “long long int”.
+// "signed char", "short int", "int", "long int", and "long long int".
 
 template<> struct arithmetic_type<4>
 {
@@ -79,8 +79,8 @@ template<> struct arithmetic_type<8>
 };
 
 // For each of the standard signed integer types, there exists a corresponding
-// (but different) standard unsigned integer type: “unsigned char”, “unsigned short int”,
-// “unsigned int”, “unsigned long int”, and “unsigned long long int”
+// (but different) standard unsigned integer type: "unsigned char", "unsigned short int",
+// "unsigned int", "unsigned long int", and "unsigned long long int"
 
 template<> struct arithmetic_type<9>
 {
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/common_type_impl.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/common_type_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/common_type_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/common_type_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/composite_member_pointer_type.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/composite_member_pointer_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/composite_member_pointer_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/composite_member_pointer_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/composite_pointer_type.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/composite_pointer_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/composite_pointer_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/composite_pointer_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/config.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/config.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/config.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/config.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/has_binary_operator.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/has_binary_operator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/has_binary_operator.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/has_binary_operator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/has_postfix_operator.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/has_postfix_operator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/has_postfix_operator.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/has_postfix_operator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/has_prefix_operator.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/has_prefix_operator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/has_prefix_operator.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/has_prefix_operator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/ice_and.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/ice_and.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/ice_and.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/ice_and.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/ice_eq.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/ice_eq.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/ice_eq.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/ice_eq.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/ice_not.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/ice_not.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/ice_not.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/ice_not.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/ice_or.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/ice_or.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/ice_or.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/ice_or.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/is_function_ptr_helper.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/is_function_ptr_helper.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/is_function_ptr_helper.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/is_function_ptr_helper.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/is_function_ptr_tester.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/is_function_ptr_tester.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/is_function_ptr_tester.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/is_function_ptr_tester.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/is_mem_fun_pointer_impl.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/is_mem_fun_pointer_tester.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/mp_defer.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/mp_defer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/mp_defer.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/mp_defer.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/template_arity_spec.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/template_arity_spec.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/template_arity_spec.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/template_arity_spec.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/detail/yes_no_type.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/detail/yes_no_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/detail/yes_no_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/detail/yes_no_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/extent.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/extent.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/extent.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/extent.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/floating_point_promotion.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/floating_point_promotion.hpp
similarity index 84%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/floating_point_promotion.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/floating_point_promotion.hpp
index 993e14ef4b2..0e709b74ae2 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/floating_point_promotion.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/floating_point_promotion.hpp
@@ -14,6 +14,12 @@ namespace boost {
    template<> struct floating_point_promotion<float volatile>{ typedef double volatile type; };
    template<> struct floating_point_promotion<float const volatile> { typedef double const volatile type; };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using floating_point_promotion_t = typename floating_point_promotion<T>::type;
+
+#endif
+
 }
 
 #endif // #ifndef FILE_boost_type_traits_floating_point_promotion_hpp_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/function_traits.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/function_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/function_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/function_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_bit_and.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_bit_and.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_bit_and.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_bit_and.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_bit_and_assign.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_bit_and_assign.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_bit_and_assign.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_bit_and_assign.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_bit_or.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_bit_or.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_bit_or.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_bit_or.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_bit_or_assign.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_bit_or_assign.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_bit_or_assign.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_bit_or_assign.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_bit_xor.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_bit_xor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_bit_xor.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_bit_xor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_bit_xor_assign.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_bit_xor_assign.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_bit_xor_assign.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_bit_xor_assign.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_complement.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_complement.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_complement.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_complement.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_dereference.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_dereference.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_dereference.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_dereference.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_divides.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_divides.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_divides.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_divides.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_divides_assign.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_divides_assign.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_divides_assign.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_divides_assign.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_greater.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_greater.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_greater.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_greater.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_greater_equal.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_greater_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_greater_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_greater_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_left_shift.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_left_shift.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_left_shift.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_left_shift.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_left_shift_assign.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_left_shift_assign.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_left_shift_assign.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_left_shift_assign.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_less.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_less.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_less.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_less.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_less_equal.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_less_equal.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_less_equal.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_less_equal.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_logical_and.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_logical_and.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_logical_and.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_logical_and.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_logical_not.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_logical_not.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_logical_not.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_logical_not.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_logical_or.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_logical_or.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_logical_or.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_logical_or.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_minus.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_minus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_minus.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_minus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_minus_assign.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_minus_assign.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_minus_assign.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_minus_assign.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_modulus.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_modulus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_modulus.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_modulus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_modulus_assign.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_modulus_assign.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_modulus_assign.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_modulus_assign.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_multiplies.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_multiplies.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_multiplies.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_multiplies.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_multiplies_assign.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_multiplies_assign.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_multiplies_assign.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_multiplies_assign.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_negate.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_negate.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_negate.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_negate.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_new_operator.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_new_operator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_new_operator.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_new_operator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_not_equal_to.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_not_equal_to.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_not_equal_to.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_not_equal_to.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_nothrow_assign.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_nothrow_assign.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_nothrow_assign.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_nothrow_assign.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_nothrow_constructor.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_nothrow_constructor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_nothrow_constructor.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_nothrow_constructor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_nothrow_copy.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_nothrow_copy.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_nothrow_copy.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_nothrow_copy.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_nothrow_destructor.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_nothrow_destructor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_nothrow_destructor.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_nothrow_destructor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_operator.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_operator.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_operator.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_operator.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_plus.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_plus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_plus.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_plus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_plus_assign.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_plus_assign.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_plus_assign.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_plus_assign.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_post_decrement.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_post_decrement.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_post_decrement.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_post_decrement.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_post_increment.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_post_increment.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_post_increment.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_post_increment.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_pre_decrement.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_pre_decrement.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_pre_decrement.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_pre_decrement.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_pre_increment.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_pre_increment.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_pre_increment.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_pre_increment.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_right_shift.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_right_shift.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_right_shift.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_right_shift.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_right_shift_assign.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_right_shift_assign.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_right_shift_assign.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_right_shift_assign.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_trivial_assign.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_trivial_assign.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_trivial_assign.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_trivial_assign.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_trivial_constructor.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_trivial_constructor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_trivial_constructor.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_trivial_constructor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_trivial_copy.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_trivial_copy.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_trivial_copy.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_trivial_copy.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_trivial_destructor.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_trivial_destructor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_trivial_destructor.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_trivial_destructor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_trivial_move_assign.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_trivial_move_assign.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_trivial_move_assign.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_trivial_move_assign.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_trivial_move_constructor.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_trivial_move_constructor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_trivial_move_constructor.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_trivial_move_constructor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_unary_minus.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_unary_minus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_unary_minus.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_unary_minus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_unary_plus.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_unary_plus.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_unary_plus.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_unary_plus.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/has_virtual_destructor.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/has_virtual_destructor.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/has_virtual_destructor.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/has_virtual_destructor.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/ice.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/ice.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/ice.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/ice.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/integral_constant.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/integral_constant.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/integral_constant.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/integral_constant.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/integral_promotion.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/integral_promotion.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/integral_promotion.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/integral_promotion.hpp
index 0478f563492..526f90ca993 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/integral_promotion.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/integral_promotion.hpp
@@ -175,6 +175,12 @@ public:
    typedef typename boost::type_traits::detail::integral_promotion<T, tag_type::value>::type type;
 };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using integral_promotion_t = typename integral_promotion<T>::type;
+
+#endif
+
 }
 
 #endif // #ifndef FILE_boost_type_traits_integral_promotion_hpp_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/intrinsics.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/intrinsics.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/intrinsics.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/intrinsics.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_abstract.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_abstract.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_abstract.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_abstract.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_arithmetic.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_arithmetic.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_arithmetic.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_arithmetic.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_array.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_array.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_array.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_array.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_assignable.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_assignable.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_assignable.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_assignable.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_base_and_derived.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_base_and_derived.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_base_and_derived.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_base_and_derived.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_base_of.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_base_of.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_base_of.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_base_of.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_base_of_tr1.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_base_of_tr1.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_base_of_tr1.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_base_of_tr1.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_class.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_class.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_class.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_class.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_complex.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_complex.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_complex.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_complex.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_compound.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_compound.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_compound.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_compound.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_const.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_const.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_const.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_const.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_constructible.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_constructible.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_constructible.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_constructible.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_convertible.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_convertible.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_convertible.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_convertible.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_copy_assignable.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_copy_assignable.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_copy_assignable.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_copy_assignable.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_copy_constructible.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_copy_constructible.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_copy_constructible.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_copy_constructible.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_default_constructible.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_default_constructible.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_default_constructible.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_default_constructible.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_destructible.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_destructible.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_destructible.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_destructible.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_empty.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_empty.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_empty.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_empty.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_enum.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_enum.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_enum.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_enum.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_final.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_final.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_final.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_final.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_float.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_float.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_float.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_float.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_floating_point.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_floating_point.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_floating_point.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_floating_point.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_function.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_function.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_function.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_function.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_fundamental.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_fundamental.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_fundamental.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_fundamental.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_integral.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_integral.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_integral.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_integral.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_lvalue_reference.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_lvalue_reference.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_lvalue_reference.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_lvalue_reference.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_member_function_pointer.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_member_function_pointer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_member_function_pointer.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_member_function_pointer.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_member_object_pointer.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_member_object_pointer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_member_object_pointer.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_member_object_pointer.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_member_pointer.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_member_pointer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_member_pointer.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_member_pointer.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_nothrow_move_assignable.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_nothrow_move_assignable.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_nothrow_move_assignable.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_nothrow_move_assignable.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_nothrow_move_constructible.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_nothrow_move_constructible.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_nothrow_move_constructible.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_nothrow_move_constructible.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_object.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_object.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_object.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_object.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_pod.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_pod.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_pod.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_pod.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_pointer.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_pointer.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_pointer.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_pointer.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_polymorphic.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_polymorphic.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_polymorphic.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_polymorphic.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_reference.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_reference.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_reference.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_reference.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_rvalue_reference.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_rvalue_reference.hpp
similarity index 95%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_rvalue_reference.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_rvalue_reference.hpp
index 50e88edee0e..a48edb5140e 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/is_rvalue_reference.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/is_rvalue_reference.hpp
@@ -1,5 +1,5 @@
 
-//  (C) John Maddock 2010. 
+//  (C) Copyright John Maddock 2010. 
 //  Use, modification and distribution are subject to the Boost Software License,
 //  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt).
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_same.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_same.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_same.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_same.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_scalar.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_scalar.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_scalar.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_scalar.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_signed.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_signed.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_signed.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_signed.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_stateless.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_stateless.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_stateless.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_stateless.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_union.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_union.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_union.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_union.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_unsigned.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_unsigned.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_unsigned.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_unsigned.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_virtual_base_of.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_virtual_base_of.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_virtual_base_of.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_virtual_base_of.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_void.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_void.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_void.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_void.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/is_volatile.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/is_volatile.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/is_volatile.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/is_volatile.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/make_signed.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/make_signed.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/make_signed.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/make_signed.hpp
index 0d2d5df61a1..6d8b1fb8d4b 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/make_signed.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/make_signed.hpp
@@ -125,6 +125,12 @@ public:
    >::type type;
 };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using make_signed_t = typename make_signed<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_ADD_REFERENCE_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/make_unsigned.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/make_unsigned.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/make_unsigned.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/make_unsigned.hpp
index 4b21ebaeb26..17a8a5b9296 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/make_unsigned.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/make_unsigned.hpp
@@ -124,6 +124,12 @@ public:
    >::type type;
 };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using make_unsigned_t = typename make_unsigned<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_ADD_REFERENCE_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_65_0/boost/type_traits/make_void.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/make_void.hpp
new file mode 100644
index 00000000000..f48823b0595
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/make_void.hpp
@@ -0,0 +1,52 @@
+/*
+Copyright 2017 Glen Joseph Fernandes
+<glenjofe -at- 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)
+*/
+
+#ifndef BOOST_TT_MAKE_VOID_HPP_INCLUDED
+#define BOOST_TT_MAKE_VOID_HPP_INCLUDED
+
+#include <boost/config.hpp>
+
+namespace boost {
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+template<class...>
+struct make_void {
+    typedef void type;
+};
+
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+template<class... Ts>
+using void_t = typename make_void<Ts...>::type;
+#endif
+
+#else /* BOOST_NO_CXX11_VARIADIC_TEMPLATES */
+
+template<class = void,
+         class = void,
+         class = void,
+         class = void,
+         class = void>
+struct make_void {
+    typedef void type;
+};
+
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+template<class A = void,
+         class B = void,
+         class C = void,
+         class D = void,
+         class E = void>
+using void_t = typename make_void<A, B, C, D, E>::type;
+#endif
+
+#endif
+
+} /* boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/object_traits.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/object_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/object_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/object_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/promote.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/promote.hpp
similarity index 83%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/promote.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/promote.hpp
index 587617a2878..1678e1ca3ec 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/promote.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/promote.hpp
@@ -14,6 +14,12 @@ namespace boost {
 
 template<class T> struct promote : public integral_promotion<typename floating_point_promotion<T>::type>{};
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using promote_t = typename promote<T>::type;
+
+#endif
+
 }
 
 #endif // #ifndef FILE_boost_type_traits_promote_hpp_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/rank.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/rank.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/rank.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/rank.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/reference_traits.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/reference_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/reference_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/reference_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/remove_all_extents.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/remove_all_extents.hpp
similarity index 92%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/remove_all_extents.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/remove_all_extents.hpp
index 90c90d35238..b9736db57e7 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/remove_all_extents.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/remove_all_extents.hpp
@@ -30,6 +30,12 @@ template <class T> struct remove_all_extents<T const volatile[]> : public remove
 #endif
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using remove_all_extents_t = typename remove_all_extents<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/remove_bounds.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/remove_bounds.hpp
similarity index 83%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/remove_bounds.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/remove_bounds.hpp
index 56988d24e01..cd0565d28f1 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/remove_bounds.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/remove_bounds.hpp
@@ -16,6 +16,13 @@ namespace boost
 
 template <class T> struct remove_bounds : public remove_extent<T> {};
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+template <class T> using remove_bounds_t = typename remove_bounds<T>::type;
+
+#endif
+
+
 } // namespace boost
 
 #endif // BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/remove_const.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/remove_const.hpp
similarity index 90%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/remove_const.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/remove_const.hpp
index e238962c6d0..6f1a193740b 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/remove_const.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/remove_const.hpp
@@ -28,6 +28,12 @@ namespace boost {
 #endif
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using remove_const_t = typename remove_const<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_REMOVE_CONST_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/remove_cv.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/remove_cv.hpp
similarity index 92%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/remove_cv.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/remove_cv.hpp
index 08393cfb819..57a96f29d63 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/remove_cv.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/remove_cv.hpp
@@ -34,6 +34,11 @@ template <class T> struct remove_cv<T volatile[]>{ typedef T type[]; };
 #endif
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using remove_cv_t = typename remove_cv<T>::type;
+
+#endif
 
 } // namespace boost
 
diff --git a/contrib/libboost/boost_1_65_0/boost/type_traits/remove_cv_ref.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/remove_cv_ref.hpp
new file mode 100644
index 00000000000..118945a6a05
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/remove_cv_ref.hpp
@@ -0,0 +1,30 @@
+
+//  (C) Copyright Peter Dimov 2017. 
+//  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_REMOVE_CV_REF_HPP_INCLUDED
+#define BOOST_TT_REMOVE_CV_REF_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+namespace boost {
+
+   template <class T> struct remove_cv_ref: remove_cv<typename remove_reference<T>::type> {};
+
+
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using remove_cv_ref_t = typename remove_cv_ref<T>::type;
+
+#endif
+
+} // namespace boost
+
+#endif // BOOST_TT_REMOVE_CV_REF_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/remove_extent.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/remove_extent.hpp
similarity index 92%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/remove_extent.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/remove_extent.hpp
index b6528e525b0..55d57301b70 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/remove_extent.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/remove_extent.hpp
@@ -30,6 +30,12 @@ template <typename T> struct remove_extent<T const volatile[]> { typedef T const
 #endif
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using remove_extent_t = typename remove_extent<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_REMOVE_BOUNDS_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/remove_pointer.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/remove_pointer.hpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/remove_pointer.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/remove_pointer.hpp
index 921665266fd..a7baa765f07 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/remove_pointer.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/remove_pointer.hpp
@@ -72,6 +72,12 @@ template <class T> struct remove_pointer<T*const volatile>{ typedef T type; };
 
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using remove_pointer_t = typename remove_pointer<T>::type;
+
+#endif
+
 } // namespace boost
 
 #endif // BOOST_TT_REMOVE_POINTER_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/remove_reference.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/remove_reference.hpp
similarity index 92%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/remove_reference.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/remove_reference.hpp
index f75e67783bb..70949fbb2a9 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/remove_reference.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/remove_reference.hpp
@@ -48,6 +48,11 @@ template <class T> struct remove_reference<T&volatile>{ typedef T type; };
 template <class T> struct remove_reference<T&const volatile>{ typedef T type; };
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using remove_reference_t = typename remove_reference<T>::type;
+
+#endif
 
 } // namespace boost
 
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/remove_volatile.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/remove_volatile.hpp
similarity index 90%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/remove_volatile.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/remove_volatile.hpp
index f5870f317f3..bf2c55796a1 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/remove_volatile.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/remove_volatile.hpp
@@ -28,6 +28,11 @@ namespace boost {
 #endif
 #endif
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+   template <class T> using remove_volatile_t = typename remove_volatile<T>::type;
+
+#endif
 
 } // namespace boost
 
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/same_traits.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/same_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/same_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/same_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/transform_traits.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/transform_traits.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/transform_traits.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/transform_traits.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/type_identity.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/type_identity.hpp
similarity index 78%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/type_identity.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/type_identity.hpp
index 6d2dd5b4dca..73cb3f3f9e1 100644
--- a/contrib/libboost/boost_1_62_0/boost/type_traits/type_identity.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/type_traits/type_identity.hpp
@@ -17,6 +17,13 @@ template<class T> struct type_identity
     typedef T type;
 };
 
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+template <class T> using type_identity_t = typename type_identity<T>::type;
+
+#endif
+
+
 } // namespace boost
 
 #endif // #ifndef BOOST_TYPE_TRAITS_TYPE_IDENTITY_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_62_0/boost/type_traits/type_with_alignment.hpp b/contrib/libboost/boost_1_65_0/boost/type_traits/type_with_alignment.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/type_traits/type_with_alignment.hpp
rename to contrib/libboost/boost_1_65_0/boost/type_traits/type_with_alignment.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/utility.hpp b/contrib/libboost/boost_1_65_0/boost/utility.hpp
similarity index 90%
rename from contrib/libboost/boost_1_62_0/boost/utility.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility.hpp
index 82177c8b471..0aacb8bc361 100644
--- a/contrib/libboost/boost_1_62_0/boost/utility.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/utility.hpp
@@ -14,8 +14,8 @@
 #include <boost/utility/binary.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/utility/identity_type.hpp>
-#include <boost/checked_delete.hpp>
+#include <boost/core/checked_delete.hpp>
+#include <boost/core/noncopyable.hpp>
 #include <boost/next_prior.hpp>
-#include <boost/noncopyable.hpp>
 
 #endif  // BOOST_UTILITY_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/addressof.hpp b/contrib/libboost/boost_1_65_0/boost/utility/addressof.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/utility/addressof.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/addressof.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/base_from_member.hpp b/contrib/libboost/boost_1_65_0/boost/utility/base_from_member.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/utility/base_from_member.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/base_from_member.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/binary.hpp b/contrib/libboost/boost_1_65_0/boost/utility/binary.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/utility/binary.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/binary.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/compare_pointees.hpp b/contrib/libboost/boost_1_65_0/boost/utility/compare_pointees.hpp
similarity index 87%
rename from contrib/libboost/boost_1_62_0/boost/utility/compare_pointees.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/compare_pointees.hpp
index 7e2515c6eea..5ab21cdee27 100644
--- a/contrib/libboost/boost_1_62_0/boost/utility/compare_pointees.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/utility/compare_pointees.hpp
@@ -33,8 +33,12 @@ bool equal_pointees ( OptionalPointee const& x, OptionalPointee const& y )
 }
 
 template<class OptionalPointee>
-struct equal_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
+struct equal_pointees_t
 {
+  typedef bool result_type;
+  typedef OptionalPointee first_argument_type;
+  typedef OptionalPointee second_argument_type;
+
   bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
     { return equal_pointees(x,y) ; }
 } ;
@@ -56,8 +60,12 @@ bool less_pointees ( OptionalPointee const& x, OptionalPointee const& y )
 }
 
 template<class OptionalPointee>
-struct less_pointees_t : std::binary_function<OptionalPointee,OptionalPointee,bool>
+struct less_pointees_t
 {
+  typedef bool result_type;
+  typedef OptionalPointee first_argument_type;
+  typedef OptionalPointee second_argument_type;
+
   bool operator() ( OptionalPointee const& x, OptionalPointee const& y ) const
     { return less_pointees(x,y) ; }
 } ;
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/declval.hpp b/contrib/libboost/boost_1_65_0/boost/utility/declval.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/utility/declval.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/declval.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/detail/in_place_factory_prefix.hpp b/contrib/libboost/boost_1_65_0/boost/utility/detail/in_place_factory_prefix.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/utility/detail/in_place_factory_prefix.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/detail/in_place_factory_prefix.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/detail/in_place_factory_suffix.hpp b/contrib/libboost/boost_1_65_0/boost/utility/detail/in_place_factory_suffix.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/utility/detail/in_place_factory_suffix.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/detail/in_place_factory_suffix.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/detail/result_of_iterate.hpp b/contrib/libboost/boost_1_65_0/boost/utility/detail/result_of_iterate.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/utility/detail/result_of_iterate.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/detail/result_of_iterate.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/empty_deleter.hpp b/contrib/libboost/boost_1_65_0/boost/utility/empty_deleter.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/utility/empty_deleter.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/empty_deleter.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/enable_if.hpp b/contrib/libboost/boost_1_65_0/boost/utility/enable_if.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/utility/enable_if.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/enable_if.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/explicit_operator_bool.hpp b/contrib/libboost/boost_1_65_0/boost/utility/explicit_operator_bool.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/utility/explicit_operator_bool.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/explicit_operator_bool.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/identity_type.hpp b/contrib/libboost/boost_1_65_0/boost/utility/identity_type.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/utility/identity_type.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/identity_type.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/in_place_factory.hpp b/contrib/libboost/boost_1_65_0/boost/utility/in_place_factory.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/utility/in_place_factory.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/in_place_factory.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/result_of.hpp b/contrib/libboost/boost_1_65_0/boost/utility/result_of.hpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/boost/utility/result_of.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/result_of.hpp
index 206ae3088af..cb16d099b67 100644
--- a/contrib/libboost/boost_1_62_0/boost/utility/result_of.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/utility/result_of.hpp
@@ -201,6 +201,11 @@ struct tr1_result_of_impl<F, FArgs, false>
 #define BOOST_PP_ITERATION_PARAMS_1 (3,(0,BOOST_RESULT_OF_NUM_ARGS,<boost/utility/detail/result_of_iterate.hpp>))
 #include BOOST_PP_ITERATE()
 
+#if 0
+// inform dependency trackers, as they can't see through macro includes
+#include <boost/utility/detail/result_of_iterate.hpp>
+#endif
+
 #else
 #  define BOOST_NO_RESULT_OF 1
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/string_ref.hpp b/contrib/libboost/boost_1_65_0/boost/utility/string_ref.hpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/boost/utility/string_ref.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/string_ref.hpp
index 5acf346fba6..d234e5444a4 100644
--- a/contrib/libboost/boost_1_62_0/boost/utility/string_ref.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/utility/string_ref.hpp
@@ -92,6 +92,13 @@ namespace boost {
         basic_string_ref(const std::basic_string<charT, traits, Allocator>& str)
             : ptr_(str.data()), len_(str.length()) {}
 
+// #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+//         // Constructing a string_ref from a temporary string is a bad idea
+//         template<typename Allocator>
+//         basic_string_ref(      std::basic_string<charT, traits, Allocator>&&)
+//             = delete;
+// #endif
+
         BOOST_CONSTEXPR basic_string_ref(const charT* str, size_type len) BOOST_NOEXCEPT
             : ptr_(str), len_(len) {}
 
@@ -155,9 +162,7 @@ namespace boost {
         basic_string_ref substr(size_type pos, size_type n=npos) const {
             if ( pos > size())
                 BOOST_THROW_EXCEPTION( std::out_of_range ( "string_ref::substr" ) );
-            if ( n == npos || pos + n > size())
-                n = size () - pos;
-            return basic_string_ref ( data() + pos, n );
+            return basic_string_ref(data() + pos, (std::min)(size() - pos, n));
             }
 
         int compare(basic_string_ref x) const {
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/string_ref_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/utility/string_ref_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/utility/string_ref_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/string_ref_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/string_view.hpp b/contrib/libboost/boost_1_65_0/boost/utility/string_view.hpp
similarity index 89%
rename from contrib/libboost/boost_1_62_0/boost/utility/string_view.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/string_view.hpp
index f5d5eb90602..09d52d2d349 100644
--- a/contrib/libboost/boost_1_62_0/boost/utility/string_view.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/utility/string_view.hpp
@@ -1,6 +1,6 @@
 /*
-   � Copyright (c) Marshall Clow 2012-2015.
-   � Copyright Beman Dawes 2015
+   Copyright (c) Marshall Clow 2012-2015.
+   Copyright (c) Beman Dawes 2015
 
    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)
@@ -91,9 +91,15 @@ namespace boost {
 #endif
 
       template<typename Allocator>
-        basic_string_view(const std::basic_string<charT, traits,
-          Allocator>& str) BOOST_NOEXCEPT
-        : ptr_(str.data()), len_(str.length()) {}
+        basic_string_view(const std::basic_string<charT, traits, Allocator>& str) BOOST_NOEXCEPT
+          : ptr_(str.data()), len_(str.length()) {}
+
+// #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+//       // Constructing a string_view from a temporary string is a bad idea
+//       template<typename Allocator>
+//         basic_string_view(      std::basic_string<charT, traits, Allocator>&&)
+//           = delete;
+// #endif
 
       BOOST_CONSTEXPR basic_string_view(const charT* str)
         : ptr_(str), len_(traits::length(str)) {}
@@ -121,10 +127,7 @@ namespace boost {
         BOOST_CONSTEXPR const_reference operator[](size_type pos) const BOOST_NOEXCEPT { return ptr_[pos]; }
 
         BOOST_CONSTEXPR const_reference at(size_t pos) const {
-            return pos >= len_ ? BOOST_THROW_EXCEPTION(std::out_of_range("boost::string_view::at")) : ptr_[pos];
-//             if ( pos >= len_ )
-//                 BOOST_THROW_EXCEPTION( std::out_of_range ( "boost::string_view::at" ) );
-//             return ptr_[pos];
+            return pos >= len_ ? BOOST_THROW_EXCEPTION(std::out_of_range("boost::string_view::at")), ptr_[0] : ptr_[pos];
             }
 
         BOOST_CONSTEXPR const_reference front() const                { return ptr_[0]; }
@@ -180,18 +183,14 @@ namespace boost {
             if (pos > size())
                 BOOST_THROW_EXCEPTION(std::out_of_range("string_view::copy" ));
             size_type rlen = (std::min)(n, len_ - pos);
-            // use std::copy(begin() + pos, begin() + pos + rlen, s) rather than
-            // std::copy_n(begin() + pos, rlen, s) to support pre-C++11 standard libraries
-            std::copy(begin() + pos, begin() + pos + rlen, s);
+    		traits_type::copy(s, data() + pos, rlen);
             return rlen;
             }
 
         BOOST_CXX14_CONSTEXPR basic_string_view substr(size_type pos, size_type n=npos) const {
             if ( pos > size())
                 BOOST_THROW_EXCEPTION( std::out_of_range ( "string_view::substr" ) );
-            if (n == npos || pos + n > size())
-                n = size () - pos;
-            return basic_string_view(data() + pos, n);
+            return basic_string_view(data() + pos, (std::min)(size() - pos, n));
             }
 
         BOOST_CXX14_CONSTEXPR int compare(basic_string_view x) const BOOST_NOEXCEPT {
@@ -369,7 +368,7 @@ namespace boost {
 //  Comparison operators
 //  Equality
     template<typename charT, typename traits>
-    inline bool operator==(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator==(basic_string_view<charT, traits> x,
                            basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         if (x.size () != y.size ()) return false;
         return x.compare(y) == 0;
@@ -377,7 +376,7 @@ namespace boost {
 
 //  Inequality
     template<typename charT, typename traits>
-    inline bool operator!=(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator!=(basic_string_view<charT, traits> x,
                            basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         if ( x.size () != y.size ()) return true;
         return x.compare(y) != 0;
@@ -385,173 +384,173 @@ namespace boost {
 
 //  Less than
     template<typename charT, typename traits>
-    inline bool operator<(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator<(basic_string_view<charT, traits> x,
                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return x.compare(y) < 0;
         }
 
 //  Greater than
     template<typename charT, typename traits>
-    inline bool operator>(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator>(basic_string_view<charT, traits> x,
                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return x.compare(y) > 0;
         }
 
 //  Less than or equal to
     template<typename charT, typename traits>
-    inline bool operator<=(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator<=(basic_string_view<charT, traits> x,
                            basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return x.compare(y) <= 0;
         }
 
 //  Greater than or equal to
     template<typename charT, typename traits>
-    inline bool operator>=(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator>=(basic_string_view<charT, traits> x,
                            basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return x.compare(y) >= 0;
         }
 
 // "sufficient additional overloads of comparison functions"
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator==(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator==(basic_string_view<charT, traits> x,
                      const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
         return x == basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator==(const std::basic_string<charT, traits, Allocator> & x,
+    inline BOOST_CXX14_CONSTEXPR bool operator==(const std::basic_string<charT, traits, Allocator> & x,
                                  basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) == y;
         }
 
     template<typename charT, typename traits>
-    inline bool operator==(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator==(basic_string_view<charT, traits> x,
                                               const charT * y) BOOST_NOEXCEPT {
         return x == basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits>
-    inline bool operator==(const charT * x,
+    inline BOOST_CXX14_CONSTEXPR bool operator==(const charT * x,
                            basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) == y;
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator!=(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator!=(basic_string_view<charT, traits> x,
                      const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
         return x != basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator!=(const std::basic_string<charT, traits, Allocator> & x,
+    inline BOOST_CXX14_CONSTEXPR bool operator!=(const std::basic_string<charT, traits, Allocator> & x,
                                  basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) != y;
         }
 
     template<typename charT, typename traits>
-    inline bool operator!=(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator!=(basic_string_view<charT, traits> x,
                            const charT * y) BOOST_NOEXCEPT {
         return x != basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits>
-    inline bool operator!=(const charT * x,
+    inline BOOST_CXX14_CONSTEXPR bool operator!=(const charT * x,
                            basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) != y;
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator<(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator<(basic_string_view<charT, traits> x,
                     const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
         return x < basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator<(const std::basic_string<charT, traits, Allocator> & x,
+    inline BOOST_CXX14_CONSTEXPR bool operator<(const std::basic_string<charT, traits, Allocator> & x,
                                 basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) < y;
         }
 
     template<typename charT, typename traits>
-    inline bool operator<(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator<(basic_string_view<charT, traits> x,
                           const charT * y) BOOST_NOEXCEPT {
         return x < basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits>
-    inline bool operator<(const charT * x,
+    inline BOOST_CXX14_CONSTEXPR bool operator<(const charT * x,
                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) < y;
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator>(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator>(basic_string_view<charT, traits> x,
                     const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
         return x > basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator>(const std::basic_string<charT, traits, Allocator> & x,
+    inline BOOST_CXX14_CONSTEXPR bool operator>(const std::basic_string<charT, traits, Allocator> & x,
                                 basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) > y;
         }
 
     template<typename charT, typename traits>
-    inline bool operator>(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator>(basic_string_view<charT, traits> x,
                           const charT * y) BOOST_NOEXCEPT {
         return x > basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits>
-    inline bool operator>(const charT * x,
+    inline BOOST_CXX14_CONSTEXPR bool operator>(const charT * x,
                           basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) > y;
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator<=(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator<=(basic_string_view<charT, traits> x,
                      const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
         return x <= basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator<=(const std::basic_string<charT, traits, Allocator> & x,
+    inline BOOST_CXX14_CONSTEXPR bool operator<=(const std::basic_string<charT, traits, Allocator> & x,
                                  basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) <= y;
         }
 
     template<typename charT, typename traits>
-    inline bool operator<=(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator<=(basic_string_view<charT, traits> x,
                            const charT * y) BOOST_NOEXCEPT {
         return x <= basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits>
-    inline bool operator<=(const charT * x,
+    inline BOOST_CXX14_CONSTEXPR bool operator<=(const charT * x,
                            basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) <= y;
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator>=(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator>=(basic_string_view<charT, traits> x,
                      const std::basic_string<charT, traits, Allocator> & y) BOOST_NOEXCEPT {
         return x >= basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits, typename Allocator>
-    inline bool operator>=(const std::basic_string<charT, traits, Allocator> & x,
+    inline BOOST_CXX14_CONSTEXPR bool operator>=(const std::basic_string<charT, traits, Allocator> & x,
                                  basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) >= y;
         }
 
     template<typename charT, typename traits>
-    inline bool operator>=(basic_string_view<charT, traits> x,
+    inline BOOST_CXX14_CONSTEXPR bool operator>=(basic_string_view<charT, traits> x,
                            const charT * y) BOOST_NOEXCEPT {
         return x >= basic_string_view<charT, traits>(y);
         }
 
     template<typename charT, typename traits>
-    inline bool operator>=(const charT * x,
+    inline BOOST_CXX14_CONSTEXPR bool operator>=(const charT * x,
                            basic_string_view<charT, traits> y) BOOST_NOEXCEPT {
         return basic_string_view<charT, traits>(x) >= y;
         }
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/string_view_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/utility/string_view_fwd.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/utility/string_view_fwd.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/string_view_fwd.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/swap.hpp b/contrib/libboost/boost_1_65_0/boost/utility/swap.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/utility/swap.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/swap.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/typed_in_place_factory.hpp b/contrib/libboost/boost_1_65_0/boost/utility/typed_in_place_factory.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/utility/typed_in_place_factory.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/typed_in_place_factory.hpp
diff --git a/contrib/libboost/boost_1_62_0/boost/utility/value_init.hpp b/contrib/libboost/boost_1_65_0/boost/utility/value_init.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/utility/value_init.hpp
rename to contrib/libboost/boost_1_65_0/boost/utility/value_init.hpp
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/apply_visitor.hpp b/contrib/libboost/boost_1_65_0/boost/variant/apply_visitor.hpp
new file mode 100644
index 00000000000..6ad54fb7002
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/apply_visitor.hpp
@@ -0,0 +1,20 @@
+//-----------------------------------------------------------------------------
+// boost variant/apply_visitor.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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_VARIANT_APPLY_VISITOR_HPP
+#define BOOST_VARIANT_APPLY_VISITOR_HPP
+
+#include <boost/variant/detail/apply_visitor_unary.hpp>
+#include <boost/variant/detail/apply_visitor_binary.hpp>
+#include <boost/variant/detail/apply_visitor_delayed.hpp>
+
+#endif // BOOST_VARIANT_APPLY_VISITOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/bad_visit.hpp b/contrib/libboost/boost_1_65_0/boost/variant/bad_visit.hpp
new file mode 100644
index 00000000000..e07657eab51
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/bad_visit.hpp
@@ -0,0 +1,41 @@
+//-----------------------------------------------------------------------------
+// boost variant/bad_visit.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-2003
+// Eric Friedman
+//
+// 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_VARIANT_BAD_VISIT_HPP
+#define BOOST_VARIANT_BAD_VISIT_HPP
+
+#include <exception>
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// class bad_visit
+//
+// Exception thrown when a visitation attempt via apply_visitor fails due
+// to invalid visited subtype or contents.
+//
+struct bad_visit
+    : std::exception
+{
+public: // std::exception interface
+
+    virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW
+    {
+        return "boost::bad_visit: "
+               "failed visitation using boost::apply_visitor";
+    }
+
+};
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_BAD_VISIT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/apply_visitor_binary.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/apply_visitor_binary.hpp
new file mode 100644
index 00000000000..6670cd8d27d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/apply_visitor_binary.hpp
@@ -0,0 +1,280 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/apply_visitor_binary.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-2003 Eric Friedman
+// Copyright (c) 2014 Antony Polukhin
+//
+// 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_VARIANT_DETAIL_APPLY_VISITOR_BINARY_HPP
+#define BOOST_VARIANT_DETAIL_APPLY_VISITOR_BINARY_HPP
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/variant/detail/generic_result_type.hpp>
+
+#include <boost/variant/detail/apply_visitor_unary.hpp>
+
+#if BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302))
+#include <boost/utility/enable_if.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/type_traits/is_const.hpp>
+#endif
+
+
+#if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
+#   include <boost/variant/detail/has_result_type.hpp>
+#endif
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// function template apply_visitor(visitor, visitable1, visitable2)
+//
+// Visits visitable1 and visitable2 such that their values (which we
+// shall call x and y, respectively) are used as arguments in the
+// expression visitor(x, y).
+//
+
+namespace detail { namespace variant {
+
+template <typename Visitor, typename Value1>
+class apply_visitor_binary_invoke
+{
+public: // visitor typedefs
+
+    typedef typename Visitor::result_type
+        result_type;
+
+private: // representation
+
+    Visitor& visitor_;
+    Value1& value1_;
+
+public: // structors
+
+    apply_visitor_binary_invoke(Visitor& visitor, Value1& value1) BOOST_NOEXCEPT
+        : visitor_(visitor)
+        , value1_(value1)
+    {
+    }
+
+public: // visitor interfaces
+
+    template <typename Value2>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    operator()(Value2& value2)
+    {
+        return visitor_(value1_, value2);
+    }
+
+private:
+    apply_visitor_binary_invoke& operator=(const apply_visitor_binary_invoke&);
+};
+
+template <typename Visitor, typename Visitable2>
+class apply_visitor_binary_unwrap
+{
+public: // visitor typedefs
+
+    typedef typename Visitor::result_type
+        result_type;
+
+private: // representation
+
+    Visitor& visitor_;
+    Visitable2& visitable2_;
+
+public: // structors
+
+    apply_visitor_binary_unwrap(Visitor& visitor, Visitable2& visitable2) BOOST_NOEXCEPT
+        : visitor_(visitor)
+        , visitable2_(visitable2)
+    {
+    }
+
+public: // visitor interfaces
+
+    template <typename Value1>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    operator()(Value1& value1)
+    {
+        apply_visitor_binary_invoke<
+              Visitor
+            , Value1
+            > invoker(visitor_, value1);
+
+        return boost::apply_visitor(invoker, visitable2_);
+    }
+
+private:
+    apply_visitor_binary_unwrap& operator=(const apply_visitor_binary_unwrap&);
+
+};
+
+}} // namespace detail::variant
+
+//
+// nonconst-visitor version:
+//
+
+#if !BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302))
+
+#   define BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(V) \
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename V::result_type) \
+    /**/
+
+#else // EDG-based compilers
+
+#   define BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(V) \
+    typename enable_if< \
+          mpl::not_< is_const< V > > \
+        , BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename V::result_type) \
+        >::type \
+    /**/
+
+#endif // EDG-based compilers workaround
+
+template <typename Visitor, typename Visitable1, typename Visitable2>
+inline
+    BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(Visitor)
+apply_visitor(
+      Visitor& visitor
+    , Visitable1& visitable1, Visitable2& visitable2
+    )
+{
+    ::boost::detail::variant::apply_visitor_binary_unwrap<
+          Visitor, Visitable2
+        > unwrapper(visitor, visitable2);
+
+    return boost::apply_visitor(unwrapper, visitable1);
+}
+
+#undef BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE
+
+//
+// const-visitor version:
+//
+
+template <typename Visitor, typename Visitable1, typename Visitable2>
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(
+          typename Visitor::result_type
+        )
+apply_visitor(
+      const Visitor& visitor
+    , Visitable1& visitable1, Visitable2& visitable2
+    )
+{
+    ::boost::detail::variant::apply_visitor_binary_unwrap<
+          const Visitor, Visitable2
+        > unwrapper(visitor, visitable2);
+
+    return boost::apply_visitor(unwrapper, visitable1);
+}
+
+
+#if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
+
+//////////////////////////////////////////////////////////////////////////
+// function template apply_visitor(visitor, visitable1, visitable2)
+//
+// C++14 part.
+//
+
+namespace detail { namespace variant {
+
+template <typename Visitor, typename Value1>
+class apply_visitor_binary_invoke_cpp14
+{
+    Visitor& visitor_;
+    Value1& value1_;
+
+public: // structors
+
+    apply_visitor_binary_invoke_cpp14(Visitor& visitor, Value1& value1) BOOST_NOEXCEPT
+        : visitor_(visitor)
+        , value1_(value1)
+    {
+    }
+
+public: // visitor interfaces
+
+    template <typename Value2>
+    decltype(auto) operator()(Value2& value2)
+    {
+        return visitor_(value1_, value2);
+    }
+
+private:
+    apply_visitor_binary_invoke_cpp14& operator=(const apply_visitor_binary_invoke_cpp14&);
+};
+
+template <typename Visitor, typename Visitable2>
+class apply_visitor_binary_unwrap_cpp14
+{
+    Visitor& visitor_;
+    Visitable2& visitable2_;
+
+public: // structors
+
+    apply_visitor_binary_unwrap_cpp14(Visitor& visitor, Visitable2& visitable2) BOOST_NOEXCEPT
+        : visitor_(visitor)
+        , visitable2_(visitable2)
+    {
+    }
+
+public: // visitor interfaces
+
+    template <typename Value1>
+    decltype(auto) operator()(Value1& value1)
+    {
+        apply_visitor_binary_invoke_cpp14<
+              Visitor
+            , Value1
+            > invoker(visitor_, value1);
+
+        return boost::apply_visitor(invoker, visitable2_);
+    }
+
+private:
+    apply_visitor_binary_unwrap_cpp14& operator=(const apply_visitor_binary_unwrap_cpp14&);
+};
+
+}} // namespace detail::variant
+
+template <typename Visitor, typename Visitable1, typename Visitable2>
+inline decltype(auto) apply_visitor(Visitor& visitor, Visitable1& visitable1, Visitable2& visitable2,
+    typename boost::disable_if<
+        boost::detail::variant::has_result_type<Visitor>
+    >::type* = 0)
+{
+    ::boost::detail::variant::apply_visitor_binary_unwrap_cpp14<
+          Visitor, Visitable2
+        > unwrapper(visitor, visitable2);
+
+    return boost::apply_visitor(unwrapper, visitable1);
+}
+
+template <typename Visitor, typename Visitable1, typename Visitable2>
+inline decltype(auto) apply_visitor(const Visitor& visitor, Visitable1& visitable1, Visitable2& visitable2,
+    typename boost::disable_if<
+        boost::detail::variant::has_result_type<Visitor>
+    >::type* = 0)
+{
+    ::boost::detail::variant::apply_visitor_binary_unwrap_cpp14<
+          const Visitor, Visitable2
+        > unwrapper(visitor, visitable2);
+
+    return boost::apply_visitor(unwrapper, visitable1);
+}
+
+#endif // !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_APPLY_VISITOR_BINARY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/apply_visitor_delayed.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/apply_visitor_delayed.hpp
new file mode 100644
index 00000000000..515a93ef013
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/apply_visitor_delayed.hpp
@@ -0,0 +1,151 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/apply_visitor_delayed.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-2003
+// Eric Friedman
+//
+// 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_VARIANT_DETAIL_APPLY_VISITOR_DELAYED_HPP
+#define BOOST_VARIANT_DETAIL_APPLY_VISITOR_DELAYED_HPP
+
+#include <boost/variant/detail/generic_result_type.hpp>
+
+#include <boost/variant/detail/apply_visitor_unary.hpp>
+#include <boost/variant/detail/apply_visitor_binary.hpp>
+#include <boost/variant/variant_fwd.hpp> // for BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES
+
+
+#include <boost/variant/detail/has_result_type.hpp>
+#include <boost/core/enable_if.hpp>
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// function template apply_visitor(visitor)
+//
+// Returns a function object, overloaded for unary and binary usage, that
+// visits its arguments using visitor (or a copy of visitor) via
+//  * apply_visitor( visitor, [argument] )
+// under unary invocation, or
+//  * apply_visitor( visitor, [argument1], [argument2] )
+// under binary invocation.
+//
+// NOTE: Unlike other apply_visitor forms, the visitor object must be
+//   non-const; this prevents user from giving temporary, to disastrous
+//   effect (i.e., returned function object would have dead reference).
+//
+
+template <typename Visitor>
+class apply_visitor_delayed_t
+{
+public: // visitor typedefs
+
+    typedef typename Visitor::result_type
+        result_type;
+
+private: // representation
+
+    Visitor& visitor_;
+
+public: // structors
+
+    explicit apply_visitor_delayed_t(Visitor& visitor) BOOST_NOEXCEPT
+      : visitor_(visitor)
+    {
+    }
+
+#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+
+public: // N-ary visitor interface
+    template <typename... Visitables>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    operator()(Visitables&... visitables) const
+    {
+        return apply_visitor(visitor_, visitables...);
+    }
+
+#else // !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+
+public: // unary visitor interface
+
+    template <typename Visitable>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    operator()(Visitable& visitable) const
+    {
+        return apply_visitor(visitor_, visitable);
+    }
+
+public: // binary visitor interface
+
+    template <typename Visitable1, typename Visitable2>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    operator()(Visitable1& visitable1, Visitable2& visitable2) const
+    {
+        return apply_visitor(visitor_, visitable1, visitable2);
+    }
+
+#endif // !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+
+private:
+    apply_visitor_delayed_t& operator=(const apply_visitor_delayed_t&);
+
+};
+
+template <typename Visitor>
+inline typename boost::enable_if<
+        boost::detail::variant::has_result_type<Visitor>,
+        apply_visitor_delayed_t<Visitor>
+    >::type apply_visitor(Visitor& visitor)
+{
+    return apply_visitor_delayed_t<Visitor>(visitor);
+}
+
+#if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276) \
+    && !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+
+template <typename Visitor>
+class apply_visitor_delayed_cpp14_t
+{
+private: // representation
+    Visitor& visitor_;
+
+public: // structors
+
+    explicit apply_visitor_delayed_cpp14_t(Visitor& visitor) BOOST_NOEXCEPT
+      : visitor_(visitor)
+    {
+    }
+
+public: // N-ary visitor interface
+    template <typename... Visitables>
+    decltype(auto) operator()(Visitables&... visitables) const
+    {
+        return apply_visitor(visitor_, visitables...);
+    }
+
+private:
+    apply_visitor_delayed_cpp14_t& operator=(const apply_visitor_delayed_cpp14_t&);
+
+};
+
+template <typename Visitor>
+inline  typename boost::disable_if<
+        boost::detail::variant::has_result_type<Visitor>,
+        apply_visitor_delayed_cpp14_t<Visitor>
+    >::type apply_visitor(Visitor& visitor)
+{
+    return apply_visitor_delayed_cpp14_t<Visitor>(visitor);
+}
+
+#endif // !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
+            // && !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_APPLY_VISITOR_DELAYED_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/apply_visitor_unary.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/apply_visitor_unary.hpp
new file mode 100644
index 00000000000..d4e2c166dce
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/apply_visitor_unary.hpp
@@ -0,0 +1,173 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/apply_visitor_unary.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-2003 Eric Friedman
+// Copyright (c) 2014 Antony Polukhin
+//
+// 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_VARIANT_DETAIL_APPLY_VISITOR_UNARY_HPP
+#define BOOST_VARIANT_DETAIL_APPLY_VISITOR_UNARY_HPP
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/variant/detail/generic_result_type.hpp>
+
+#if BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302))
+#include <boost/core/enable_if.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/type_traits/is_const.hpp>
+#endif
+
+#if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
+#   include <boost/mpl/distance.hpp>
+#   include <boost/mpl/advance.hpp>
+#   include <boost/mpl/deref.hpp>
+#   include <boost/mpl/size.hpp>
+#   include <boost/utility/declval.hpp>
+#   include <boost/core/enable_if.hpp>
+#   include <boost/variant/detail/has_result_type.hpp>
+#endif
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// function template apply_visitor(visitor, visitable)
+//
+// Visits visitable with visitor.
+//
+
+//
+// nonconst-visitor version:
+//
+
+#if !BOOST_WORKAROUND(__EDG__, BOOST_TESTED_AT(302))
+
+#   define BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(V) \
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename V::result_type) \
+    /**/
+
+#else // EDG-based compilers
+
+#   define BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(V) \
+    typename enable_if< \
+          mpl::not_< is_const< V > > \
+        , BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename V::result_type) \
+        >::type \
+    /**/
+
+#endif // EDG-based compilers workaround
+
+template <typename Visitor, typename Visitable>
+inline
+    BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE(Visitor)
+apply_visitor(Visitor& visitor, Visitable& visitable)
+{
+    return visitable.apply_visitor(visitor);
+}
+
+#undef BOOST_VARIANT_AUX_APPLY_VISITOR_NON_CONST_RESULT_TYPE
+
+//
+// const-visitor version:
+//
+
+template <typename Visitor, typename Visitable>
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+apply_visitor(const Visitor& visitor, Visitable& visitable)
+{
+    return visitable.apply_visitor(visitor);
+}
+
+
+#if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
+
+// C++14
+namespace detail { namespace variant {
+
+// This class serves only metaprogramming purposes. none of its methods must be called at runtime!
+template <class Visitor, class Variant>
+struct result_multideduce1 {
+    typedef typename Variant::types                 types;
+    typedef typename boost::mpl::begin<types>::type begin_it;
+    typedef typename boost::mpl::advance<
+        begin_it, boost::mpl::int_<boost::mpl::size<types>::type::value - 1>
+    >::type                                         last_it;
+
+    // For metaprogramming purposes ONLY! Do not use this method (and class) at runtime!
+    static Visitor& vis() BOOST_NOEXCEPT {
+        // Functions that work with lambdas must be defined in same translation unit.
+        // Because of that, we can not use `boost::decval<Visitor&>()` here.
+        Visitor&(*f)() = 0; // pointer to function
+        return f();
+    }
+
+    static decltype(auto) deduce_impl(last_it, unsigned /*helper*/) {
+        typedef typename boost::mpl::deref<last_it>::type value_t;
+        return vis()( boost::declval< value_t& >() );
+    }
+
+    template <class It>
+    static decltype(auto) deduce_impl(It, unsigned helper) {
+        typedef typename boost::mpl::next<It>::type next_t;
+        typedef typename boost::mpl::deref<It>::type value_t;
+        if (helper == boost::mpl::distance<begin_it, It>::type::value) {
+            return deduce_impl(next_t(), ++helper);
+        }
+
+        return vis()( boost::declval< value_t& >() );
+    }
+
+    static decltype(auto) deduce() {
+        return deduce_impl(begin_it(), 0);
+    }
+};
+
+template <class Visitor, class Variant>
+struct result_wrapper1
+{
+    typedef decltype(result_multideduce1<Visitor, Variant>::deduce()) result_type;
+
+    Visitor& visitor_;
+    explicit result_wrapper1(Visitor& visitor) BOOST_NOEXCEPT
+        : visitor_(visitor)
+    {}
+
+    template <class T>
+    result_type operator()(T& val) const {
+        return visitor_(val);
+    }
+};
+
+}} // namespace detail::variant
+
+template <typename Visitor, typename Visitable>
+inline decltype(auto) apply_visitor(Visitor& visitor, Visitable& visitable,
+    typename boost::disable_if<
+        boost::detail::variant::has_result_type<Visitor>
+    >::type* = 0)
+{
+    boost::detail::variant::result_wrapper1<Visitor, Visitable> cpp14_vis(visitor);
+    return visitable.apply_visitor(cpp14_vis);
+}
+
+template <typename Visitor, typename Visitable>
+inline decltype(auto) apply_visitor(const Visitor& visitor, Visitable& visitable,
+    typename boost::disable_if<
+        boost::detail::variant::has_result_type<Visitor>
+    >::type* = 0)
+{
+    boost::detail::variant::result_wrapper1<const Visitor, Visitable> cpp14_vis(visitor);
+    return visitable.apply_visitor(cpp14_vis);
+}
+
+#endif // !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_APPLY_VISITOR_UNARY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/backup_holder.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/backup_holder.hpp
new file mode 100644
index 00000000000..c11f12cf58d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/backup_holder.hpp
@@ -0,0 +1,95 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/backup_holder.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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_VARIANT_DETAIL_BACKUP_HOLDER_HPP
+#define BOOST_VARIANT_DETAIL_BACKUP_HOLDER_HPP
+
+#include <boost/config.hpp>
+#include <boost/assert.hpp>
+
+namespace boost {
+namespace detail { namespace variant {
+
+template <typename T>
+class backup_holder
+{
+private: // representation
+
+    T* backup_;
+
+public: // structors
+
+    ~backup_holder() BOOST_NOEXCEPT
+    {
+        delete backup_;
+    }
+
+    explicit backup_holder(T* backup) BOOST_NOEXCEPT
+        : backup_(backup)
+    {
+    }
+
+    backup_holder(const backup_holder&);
+
+public: // modifiers
+
+    backup_holder& operator=(const backup_holder& rhs)
+    {
+        *backup_ = rhs.get();
+        return *this;
+    }
+
+    backup_holder& operator=(const T& rhs)
+    {
+        *backup_ = rhs;
+        return *this;
+    }
+
+    void swap(backup_holder& rhs) BOOST_NOEXCEPT
+    {
+        T* tmp = rhs.backup_;
+        rhs.backup_ = this->backup_;
+        this->backup_ = tmp;
+    }
+
+public: // queries
+
+    T& get() BOOST_NOEXCEPT
+    {
+        return *backup_;
+    }
+
+    const T& get() const BOOST_NOEXCEPT
+    {
+        return *backup_;
+    }
+
+};
+
+template <typename T>
+backup_holder<T>::backup_holder(const backup_holder&)
+    : backup_(0)
+{
+    // not intended for copy, but do not want to prohibit syntactically
+    BOOST_ASSERT(false);
+}
+
+template <typename T>
+void swap(backup_holder<T>& lhs, backup_holder<T>& rhs) BOOST_NOEXCEPT
+{
+    lhs.swap(rhs);
+}
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_BACKUP_HOLDER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/cast_storage.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/cast_storage.hpp
new file mode 100644
index 00000000000..0320278c158
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/cast_storage.hpp
@@ -0,0 +1,42 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/cast_storage.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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_VARIANT_DETAIL_CAST_STORAGE_HPP
+#define BOOST_VARIANT_DETAIL_CAST_STORAGE_HPP
+
+#include <boost/config.hpp>
+
+namespace boost {
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) function template cast_storage
+//
+// Casts the given storage to the specified type, but with qualification.
+//
+
+template <typename T>
+inline T& cast_storage(void* storage)
+{
+    return *static_cast<T*>(storage);
+}
+
+template <typename T>
+inline const T& cast_storage(const void* storage)
+{
+    return *static_cast<const T*>(storage);
+}
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_CAST_STORAGE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/config.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/config.hpp
new file mode 100644
index 00000000000..70725e2cc8a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/config.hpp
@@ -0,0 +1,19 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/config.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003 Eric Friedman
+// Copyright (c) 2016 Antony Polukhin
+//
+// 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_VARIANT_DETAIL_CONFIG_HPP
+#define BOOST_VARIANT_DETAIL_CONFIG_HPP
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#endif // BOOST_VARIANT_DETAIL_CONFIG_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/element_index.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/element_index.hpp
new file mode 100644
index 00000000000..cc926f6cf83
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/element_index.hpp
@@ -0,0 +1,63 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/element_index.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2014-2015 Antony Polukhin
+//
+// 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_VARIANT_DETAIL_ELEMENT_INDEX_HPP
+#define BOOST_VARIANT_DETAIL_ELEMENT_INDEX_HPP
+
+#include <boost/config.hpp>
+#include <boost/variant/recursive_wrapper_fwd.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+#include <boost/mpl/find_if.hpp>
+
+namespace boost { namespace detail { namespace variant {
+
+template <class VariantElement, class T>
+struct variant_element_functor :
+    boost::mpl::or_<
+        boost::is_same<VariantElement, T>,
+        boost::is_same<VariantElement, boost::recursive_wrapper<T> >,
+        boost::is_same<VariantElement, T& >
+    >
+{};
+
+template <class Types, class T>
+struct element_iterator_impl :
+    boost::mpl::find_if<
+        Types,
+        boost::mpl::or_<
+            variant_element_functor<boost::mpl::_1, T>,
+            variant_element_functor<boost::mpl::_1, typename boost::remove_cv<T>::type >
+        >
+    >
+{};
+
+template <class Variant, class T>
+struct element_iterator :
+    element_iterator_impl< typename Variant::types, typename boost::remove_reference<T>::type >
+{};
+
+template <class Variant, class T>
+struct holds_element :
+    boost::mpl::not_<
+        boost::is_same<
+            typename boost::mpl::end<typename Variant::types>::type,
+            typename element_iterator<Variant, T>::type
+        >
+    >
+{};
+
+
+}}} // namespace boost::detail::variant
+
+#endif // BOOST_VARIANT_DETAIL_ELEMENT_INDEX_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/enable_recursive.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/enable_recursive.hpp
new file mode 100644
index 00000000000..757e0df5858
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/enable_recursive.hpp
@@ -0,0 +1,133 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/enable_recursive.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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_VARIANT_DETAIL_ENABLE_RECURSIVE_HPP
+#define BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_HPP
+
+#include <boost/variant/detail/enable_recursive_fwd.hpp>
+#include <boost/variant/variant_fwd.hpp>
+
+#if !defined(BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT)
+#   include <boost/mpl/apply.hpp>
+#   include <boost/mpl/eval_if.hpp>
+#   include <boost/mpl/lambda.hpp>
+#endif
+
+#include <boost/variant/detail/substitute.hpp>
+#include <boost/mpl/aux_/config/ctps.hpp>
+#include <boost/mpl/bool_fwd.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+#include <boost/variant/recursive_wrapper.hpp>
+
+namespace boost {
+namespace detail { namespace variant {
+
+#if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+#   define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(T,Dest,Source) \
+    substitute< T , Dest , Source > \
+    /**/
+
+#else // defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class template rebind1
+//
+// Limited workaround in case 'substitute' metafunction unavailable.
+//
+
+template <typename T, typename U1>
+struct rebind1
+{
+private:
+    typedef typename mpl::lambda<
+          mpl::identity<T>
+        >::type le_;
+
+public:
+    typedef typename mpl::eval_if<
+          is_same< le_, mpl::identity<T> >
+        , le_ // identity<T>
+        , mpl::apply1<le_, U1>
+        >::type type;
+};
+
+#   define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(T,Dest,Source) \
+    rebind1< T , Dest > \
+    /**/
+
+#endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction enable_recursive
+//
+// See boost/variant/detail/enable_recursive_fwd.hpp for more information.
+//
+
+
+template <typename T, typename RecursiveVariant, typename NoWrapper>
+struct enable_recursive
+    : BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(
+          T, RecursiveVariant, ::boost::recursive_variant_
+        )
+{
+};
+
+template <typename T, typename RecursiveVariant>
+struct enable_recursive< T,RecursiveVariant,mpl::false_ >
+{
+private: // helpers, for metafunction result (below)
+
+    typedef typename BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL(
+          T, RecursiveVariant, ::boost::recursive_variant_
+        )::type t_;
+
+public: // metafunction result
+
+    // [Wrap with recursive_wrapper only if rebind really changed something:]
+    typedef typename mpl::if_<
+          mpl::or_<
+              is_same< t_,T >
+            , is_reference<t_>
+            , is_pointer<t_>
+            >
+        , t_
+        , boost::recursive_wrapper<t_>
+        >::type type;
+
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction class quoted_enable_recursive
+//
+// Same behavior as enable_recursive metafunction (see above).
+//
+template <typename RecursiveVariant, typename NoWrapper>
+struct quoted_enable_recursive
+{
+    template <typename T>
+    struct apply
+        : enable_recursive<T, RecursiveVariant, NoWrapper>
+    {
+    };
+};
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/enable_recursive_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/enable_recursive_fwd.hpp
new file mode 100644
index 00000000000..cac156b1569
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/enable_recursive_fwd.hpp
@@ -0,0 +1,87 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/enable_recursive_fwd.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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_VARIANT_DETAIL_ENABLE_RECURSIVE_FWD_HPP
+#define BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_FWD_HPP
+
+#include <boost/mpl/aux_/config/ctps.hpp>
+
+#include <boost/mpl/bool_fwd.hpp>
+
+#   include <boost/mpl/bool.hpp>
+
+namespace boost {
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) tag recursive_flag
+//
+// Signifies that the variant should perform recursive substituion.
+//
+
+
+template <typename T>
+struct recursive_flag
+{
+    typedef T type;
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction is_recursive_flag
+//
+// Signifies that the variant should perform recursive substituion.
+//
+
+
+template <typename T>
+struct is_recursive_flag
+    : mpl::false_
+{
+};
+
+template <typename T>
+struct is_recursive_flag< recursive_flag<T> >
+    : mpl::true_
+{
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction enable_recursive
+//
+// Attempts recursive_variant_ tag substitution, wrapping with
+// boost::recursive_wrapper if substituion occurs w/ non-indirect result
+// (i.e., not a reference or pointer) *and* NoWrapper is false_.
+//
+template <
+      typename T
+    , typename RecursiveVariant
+    , typename NoWrapper = mpl::false_
+    >
+struct enable_recursive;
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction class quoted_enable_recursive
+//
+// Same behavior as enable_recursive metafunction (see above).
+//
+template <
+      typename RecursiveVariant
+    , typename NoWrapper = mpl::false_
+    >
+struct quoted_enable_recursive;
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_ENABLE_RECURSIVE_FWD_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/forced_return.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/forced_return.hpp
new file mode 100644
index 00000000000..333393a2ac7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/forced_return.hpp
@@ -0,0 +1,64 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/forced_return.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003 Eric Friedman
+// Copyright (c) 2015-2016 Antony Polukhin
+//
+// 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_VARIANT_DETAIL_FORCED_RETURN_HPP
+#define BOOST_VARIANT_DETAIL_FORCED_RETURN_HPP
+
+#include <boost/config.hpp>
+#include <boost/variant/detail/generic_result_type.hpp>
+#include <boost/assert.hpp>
+#include <cstdlib> // std::abort
+
+
+#ifdef BOOST_MSVC
+# pragma warning( push )
+# pragma warning( disable : 4702 ) // unreachable code
+#endif
+
+namespace boost { namespace detail { namespace variant {
+
+BOOST_NORETURN inline void forced_return_no_return() { // fixes `must return a value` warnings
+    using namespace std;
+    abort(); // some implementations have no std::abort
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) function template forced_return
+//
+// Logical error to permit invocation at runtime, but (artificially) satisfies
+// compile-time requirement of returning a result value.
+//
+template <typename T>
+BOOST_NORETURN inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T)
+forced_return()
+{
+    // logical error: should never be here! (see above)
+    BOOST_ASSERT(false);
+
+    forced_return_no_return();
+
+#ifdef BOOST_NO_NORETURN
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T) (*dummy)() = 0;
+    return dummy();
+#endif
+}
+
+}}} // namespace boost::detail::variant
+
+
+#ifdef BOOST_MSVC
+# pragma warning( pop )
+#endif
+
+#endif // BOOST_VARIANT_DETAIL_FORCED_RETURN_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/generic_result_type.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/generic_result_type.hpp
new file mode 100644
index 00000000000..8b1289cacc7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/generic_result_type.hpp
@@ -0,0 +1,88 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/generic_result_type.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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_VARIANT_DETAIL_GENERIC_RESULT_TYPE_HPP
+#define BOOST_VARIANT_DETAIL_GENERIC_RESULT_TYPE_HPP
+
+#include <boost/config.hpp>
+
+//////////////////////////////////////////////////////////////////////////
+// (workaround) macro BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE
+//
+// On compilers with BOOST_NO_VOID_RETURNS, this macro provides a route
+// to a single syntax for dealing with template functions that may (but
+// not necessarily) return nothing (i.e. void).
+//
+// BOOST_VARIANT_AUX_RETURN_VOID provided for compilers w/ (erroneous?)
+// warnings about non-void functions not returning a value.
+//
+
+#if !defined(BOOST_NO_VOID_RETURNS)
+
+#define BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T) \
+    T   \
+    /**/
+
+#define BOOST_VARIANT_AUX_RETURN_VOID  \
+    /**/
+
+#define BOOST_VARIANT_AUX_RETURN_VOID_TYPE \
+    void    \
+    /**/
+
+#else // defined(BOOST_NO_VOID_RETURNS)
+
+namespace boost {
+namespace detail { namespace variant {
+
+struct fake_return_void
+{
+    fake_return_void()
+    {
+    }
+
+    template <typename T>
+    fake_return_void(const T&)
+    {
+    }
+};
+
+template <typename T>
+struct no_void_returns_helper
+{
+    typedef T type;
+};
+
+template <>
+struct no_void_returns_helper<void>
+{
+    typedef fake_return_void type;
+};
+
+}} // namespace detail::variant
+} // namespace boost
+
+#define BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(T) \
+    BOOST_DEDUCED_TYPENAME                                           \
+        ::boost::detail::variant::no_void_returns_helper< T >::type  \
+    /**/
+
+#define BOOST_VARIANT_AUX_RETURN_VOID  \
+    return ::boost::detail::variant::fake_return_void()     \
+    /**/
+
+#define BOOST_VARIANT_AUX_RETURN_VOID_TYPE  \
+    ::boost::detail::variant::fake_return_void
+
+#endif // BOOST_NO_VOID_RETURNS workaround
+
+#endif // BOOST_VARIANT_DETAIL_GENERIC_RESULT_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/has_result_type.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/has_result_type.hpp
new file mode 100644
index 00000000000..80cd56ab119
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/has_result_type.hpp
@@ -0,0 +1,37 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/has_result_type.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2014-2015 Antony Polukhin
+//
+// 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_VARIANT_DETAIL_HAS_RESULT_TYPE_HPP
+#define BOOST_VARIANT_DETAIL_HAS_RESULT_TYPE_HPP
+
+#include <boost/config.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+
+namespace boost { namespace detail { namespace variant {
+
+template <typename T >
+struct has_result_type {
+private:
+    typedef char                      yes;
+    typedef struct { char array[2]; } no;
+
+    template<typename C> static yes test(typename boost::remove_reference<typename C::result_type>::type*);
+    template<typename C> static no  test(...);
+
+public:
+    BOOST_STATIC_CONSTANT(bool, value = sizeof(test<T>(0)) == sizeof(yes));
+};
+
+}}} // namespace boost::detail::variant
+
+#endif // BOOST_VARIANT_DETAIL_HAS_RESULT_TYPE_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/hash_variant.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/hash_variant.hpp
new file mode 100644
index 00000000000..958662ec698
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/hash_variant.hpp
@@ -0,0 +1,47 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/hash_variant.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2011
+// Antony Polukhin
+//
+// 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_HASH_VARIANT_FUNCTION_HPP
+#define BOOST_HASH_VARIANT_FUNCTION_HPP
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/variant/variant_fwd.hpp>
+#include <boost/variant/static_visitor.hpp>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/functional/hash_fwd.hpp>
+
+namespace boost {
+
+    namespace detail { namespace variant {
+        struct variant_hasher: public boost::static_visitor<std::size_t> {
+            template <class T>
+            std::size_t operator()(T const& val) const {
+                boost::hash<T> hasher;
+                return hasher(val);
+            }
+        };
+    }}
+
+    template < BOOST_VARIANT_ENUM_PARAMS(typename T) >
+    std::size_t hash_value(variant< BOOST_VARIANT_ENUM_PARAMS(T) > const& val) {
+        std::size_t seed = boost::apply_visitor(detail::variant::variant_hasher(), val);
+        hash_combine(seed, val.which());
+        return seed;
+    }
+}
+
+#endif
+
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/initializer.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/initializer.hpp
new file mode 100644
index 00000000000..4a54c273c27
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/initializer.hpp
@@ -0,0 +1,249 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/initializer.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-2003
+// Eric Friedman, Itay Maman
+//
+// 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_VARIANT_DETAIL_INITIALIZER_HPP
+#define BOOST_VARIANT_DETAIL_INITIALIZER_HPP
+
+#include <new> // for placement new
+
+#include <boost/config.hpp>
+
+#include <boost/call_traits.hpp>
+#include <boost/detail/reference_content.hpp>
+#include <boost/variant/recursive_wrapper_fwd.hpp>
+#include <boost/variant/detail/move.hpp>
+
+#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+#   include <boost/mpl/aux_/value_wknd.hpp>
+#   include <boost/mpl/int.hpp>
+#   include <boost/mpl/iter_fold.hpp>
+#   include <boost/mpl/next.hpp>
+#   include <boost/mpl/deref.hpp>
+#   include <boost/mpl/pair.hpp>
+#   include <boost/mpl/protect.hpp>
+#else
+#   include <boost/variant/variant_fwd.hpp>
+#   include <boost/preprocessor/cat.hpp>
+#   include <boost/preprocessor/enum.hpp>
+#   include <boost/preprocessor/repeat.hpp>
+#endif
+
+namespace boost {
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) support to simulate standard overload resolution rules
+//
+// The below initializers allows variant to follow standard overload
+// resolution rules over the specified set of bounded types.
+//
+// On compilers where using declarations in class templates can correctly
+// avoid name hiding, use an optimal solution based on the variant's typelist.
+//
+// Otherwise, use a preprocessor workaround based on knowledge of the fixed
+// size of the variant's psuedo-variadic template parameter list.
+//
+
+#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+// (detail) quoted metafunction make_initializer_node
+//
+// Exposes a pair whose first type is a node in the initializer hierarchy.
+//
+struct make_initializer_node
+{
+    template <typename BaseIndexPair, typename Iterator>
+    struct apply
+    {
+    private: // helpers, for metafunction result (below)
+
+        typedef typename BaseIndexPair::first
+            base;
+        typedef typename BaseIndexPair::second
+            index;
+
+        class initializer_node
+            : public base
+        {
+        private: // helpers, for static functions (below)
+
+            typedef typename mpl::deref<Iterator>::type
+                recursive_enabled_T;
+            typedef typename unwrap_recursive<recursive_enabled_T>::type
+                public_T;
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+            typedef boost::is_reference<public_T> 
+                is_reference_content_t;
+
+            typedef typename boost::mpl::if_<is_reference_content_t, public_T, const public_T& >::type 
+                param_T;
+
+            template <class T> struct disable_overload{};
+
+            typedef typename boost::mpl::if_<is_reference_content_t, disable_overload<public_T>, public_T&& >::type 
+                param2_T;
+#else
+            typedef typename call_traits<public_T>::param_type
+                param_T;
+#endif
+
+        public: // static functions
+
+            using base::initialize;
+
+            static int initialize(void* dest, param_T operand)
+            {
+                typedef typename boost::detail::make_reference_content<
+                      recursive_enabled_T
+                    >::type internal_T;
+
+                new(dest) internal_T(operand);
+                return BOOST_MPL_AUX_VALUE_WKND(index)::value; // which
+            }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+            static int initialize(void* dest, param2_T operand)
+            {
+                // This assert must newer trigger, because all the reference contents are
+                // handled by the initilize(void* dest, param_T operand) function above
+                BOOST_ASSERT(!is_reference_content_t::value);
+
+                typedef typename boost::mpl::if_<is_reference_content_t, param2_T, recursive_enabled_T>::type value_T;
+                new(dest) value_T( boost::detail::variant::move(operand) );
+                return BOOST_MPL_AUX_VALUE_WKND(index)::value; // which
+            }
+#endif
+        };
+
+        friend class initializer_node;
+
+    public: // metafunction result
+
+        typedef mpl::pair<
+              initializer_node
+            , typename mpl::next< index >::type
+            > type;
+
+    };
+};
+
+// (detail) class initializer_root
+//
+// Every level of the initializer hierarchy must expose the name
+// "initialize," so initializer_root provides a dummy function:
+//
+class initializer_root
+{
+public: // static functions
+
+    static void initialize();
+
+};
+
+#else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+    // Obsolete. Remove.
+    #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_PARAMS \
+          BOOST_VARIANT_ENUM_PARAMS(typename recursive_enabled_T) \
+    /**/
+
+    // Obsolete. Remove.
+    #define BOOST_VARIANT_AUX_PP_INITIALIZER_DEFINE_PARAM_T(N) \
+        typedef typename unwrap_recursive< \
+              BOOST_PP_CAT(recursive_enabled_T,N) \
+            >::type BOOST_PP_CAT(public_T,N); \
+        typedef typename call_traits< \
+              BOOST_PP_CAT(public_T,N) \
+            >::param_type BOOST_PP_CAT(param_T,N); \
+    /**/
+
+template < BOOST_VARIANT_ENUM_PARAMS(typename recursive_enabled_T) >
+struct preprocessor_list_initializer
+{
+public: // static functions
+
+    #define BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION(z,N,_) \
+        typedef typename unwrap_recursive< \
+              BOOST_PP_CAT(recursive_enabled_T,N) \
+            >::type BOOST_PP_CAT(public_T,N); \
+        typedef typename call_traits< \
+              BOOST_PP_CAT(public_T,N) \
+            >::param_type BOOST_PP_CAT(param_T,N); \
+        static int initialize( \
+              void* dest \
+            , BOOST_PP_CAT(param_T,N) operand \
+            ) \
+        { \
+            typedef typename boost::detail::make_reference_content< \
+                  BOOST_PP_CAT(recursive_enabled_T,N) \
+                >::type internal_T; \
+            \
+            new(dest) internal_T(operand); \
+            return (N); /*which*/ \
+        } \
+        /**/
+
+    BOOST_PP_REPEAT(
+          BOOST_VARIANT_LIMIT_TYPES
+        , BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION
+        , _
+        )
+
+    #undef BOOST_VARIANT_AUX_PP_INITIALIZE_FUNCTION
+
+};
+
+#endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround
+
+}} // namespace detail::variant
+} // namespace boost
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_AUX_INITIALIZER_T
+//
+// Given both the variant's typelist and a basename for forming the list of
+// bounded types (i.e., T becomes T1, T2, etc.), exposes the initializer
+// most appropriate to the current compiler.
+//
+
+#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+#define BOOST_VARIANT_AUX_INITIALIZER_T( mpl_seq, typename_base ) \
+    ::boost::mpl::iter_fold< \
+          mpl_seq \
+        , ::boost::mpl::pair< \
+              ::boost::detail::variant::initializer_root \
+            , ::boost::mpl::int_<0> \
+            > \
+        , ::boost::mpl::protect< \
+              ::boost::detail::variant::make_initializer_node \
+            > \
+        >::type::first \
+    /**/
+
+#else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+    // Obsolete. Remove.
+    #define BOOST_VARIANT_AUX_PP_INITIALIZER_TEMPLATE_ARGS(typename_base) \
+          BOOST_VARIANT_ENUM_PARAMS(typename_base) \
+        /**/
+
+#define BOOST_VARIANT_AUX_INITIALIZER_T( mpl_seq, typename_base ) \
+    ::boost::detail::variant::preprocessor_list_initializer< \
+          BOOST_VARIANT_ENUM_PARAMS(typename_base) \
+        > \
+    /**/
+
+#endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround
+
+#endif // BOOST_VARIANT_DETAIL_INITIALIZER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/make_variant_list.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/make_variant_list.hpp
new file mode 100644
index 00000000000..b7a0feffd02
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/make_variant_list.hpp
@@ -0,0 +1,73 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/make_variant_list.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-2003 Eric Friedman, Itay Maman
+// Copyright (c) 2013 Antony Polukhin
+//
+// 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_VARIANT_DETAIL_MAKE_VARIANT_LIST_HPP
+#define BOOST_VARIANT_DETAIL_MAKE_VARIANT_LIST_HPP
+
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/mpl/list.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/enum.hpp>
+
+namespace boost {
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction make_variant_list
+//
+// Provides a MPL-compatible sequence with the specified non-void types
+// as arguments.
+//
+// Rationale: see class template convert_void (variant_fwd.hpp) and using-
+// declaration workaround (below).
+//
+
+#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+
+template < typename... T >
+struct make_variant_list
+{
+    typedef typename mpl::list< T... >::type type;
+};
+
+#else // defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+
+template < BOOST_VARIANT_ENUM_PARAMS(typename T) >
+struct make_variant_list
+{
+public: // metafunction result
+
+    // [Define a macro to convert any void(NN) tags to mpl::void...]
+#   define BOOST_VARIANT_AUX_CONVERT_VOID(z, N,_)  \
+        typename convert_void< BOOST_PP_CAT(T,N) >::type
+
+    // [...so that the specified types can be passed to mpl::list...]
+    typedef typename mpl::list< 
+          BOOST_PP_ENUM(
+              BOOST_VARIANT_LIMIT_TYPES
+            , BOOST_VARIANT_AUX_CONVERT_VOID
+            , _
+            )
+        >::type type;
+
+    // [...and, finally, the conversion macro can be undefined:]
+#   undef BOOST_VARIANT_AUX_CONVERT_VOID
+
+};
+
+#endif // BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES workaround
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_MAKE_VARIANT_LIST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/move.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/move.hpp
new file mode 100644
index 00000000000..8900055b751
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/move.hpp
@@ -0,0 +1,53 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/move.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+//  Copyright (c) 2002-2003 Eric Friedman
+//  Copyright (c) 2002 by Andrei Alexandrescu
+//  Copyright (c) 2013-2014 Antony Polukhin
+//
+//  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 derivative of MoJO. Much thanks to Andrei for his initial work.
+//  See <http://www.cuj.com/experts/2102/alexandr.htm> for information on MOJO.
+//  Re-issued here under the Boost Software License, with permission of the original
+//  author (Andrei Alexandrescu).
+
+
+#ifndef BOOST_VARIANT_DETAIL_MOVE_HPP
+#define BOOST_VARIANT_DETAIL_MOVE_HPP
+
+#include <iterator> // for iterator_traits
+#include <new> // for placement new
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/move/move.hpp>
+#include <boost/move/adl_move_swap.hpp>
+
+namespace boost { namespace detail { namespace variant {
+
+using boost::move;
+
+//////////////////////////////////////////////////////////////////////////
+// function template move_swap
+//
+// Swaps using Koenig lookup but falls back to move-swap for primitive
+// types and on non-conforming compilers.
+//
+
+template <typename T>
+inline void move_swap(T& lhs, T& rhs)
+{
+    ::boost::adl_move_swap(lhs, rhs);
+}
+
+}}} // namespace boost::detail::variant
+
+#endif // BOOST_VARIANT_DETAIL_MOVE_HPP
+
+
+
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/multivisitors_cpp11_based.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/multivisitors_cpp11_based.hpp
new file mode 100644
index 00000000000..f9286b7dfd1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/multivisitors_cpp11_based.hpp
@@ -0,0 +1,183 @@
+//  Boost.Varaint
+//  Contains multivisitors that are implemented via variadic templates and std::tuple
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2013-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).
+
+#ifndef BOOST_VARIANT_DETAIL_MULTIVISITORS_CPP11_BASED_HPP
+#define BOOST_VARIANT_DETAIL_MULTIVISITORS_CPP11_BASED_HPP
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/variant/detail/apply_visitor_unary.hpp>
+#include <boost/variant/variant_fwd.hpp> // for BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES
+
+#if defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) || defined(BOOST_NO_CXX11_HDR_TUPLE)
+#   error "This file requires <tuple> and variadic templates support"
+#endif
+
+#include <tuple>
+
+namespace boost { 
+
+namespace detail { namespace variant {
+
+    // Implementing some of the C++14 features in C++11
+    template <std::size_t... I> class index_sequence {};
+
+    template <std::size_t N, std::size_t... I> 
+    struct make_index_sequence 
+        : make_index_sequence<N-1, N-1, I...> 
+    {};
+    template <std::size_t... I> 
+    struct make_index_sequence<0, I...> 
+        : index_sequence<I...> 
+    {};
+
+    template <class... Types>
+    std::tuple<Types&...> forward_as_tuple_simple(Types&... args) BOOST_NOEXCEPT
+    {
+        return std::tuple<Types&...>(args...);
+    }
+
+    // Implementing some of the helper tuple methods
+    template <std::size_t... I, typename Tuple>
+    std::tuple<typename std::tuple_element<I + 1, Tuple>::type...> 
+        tuple_tail_impl(const Tuple& tpl, index_sequence<I...>)
+    {
+        return std::tuple<
+            typename std::tuple_element<I + 1, Tuple>::type...
+        > (std::get<I + 1>(tpl)...);
+    }
+
+    template <typename Head, typename... Tail>
+    std::tuple<Tail...> tuple_tail(const std::tuple<Head, Tail...>& tpl)
+    {
+        return tuple_tail_impl(tpl, make_index_sequence<sizeof...(Tail)>());
+    }
+
+
+
+    // Forward declaration
+    template <typename Visitor, typename Visitables, typename... Values>
+    class one_by_one_visitor_and_value_referer;
+
+    template <typename Visitor, typename Visitables, typename... Values>
+    inline one_by_one_visitor_and_value_referer<Visitor, Visitables, Values... >
+        make_one_by_one_visitor_and_value_referer(
+            Visitor& visitor, Visitables visitables, std::tuple<Values&...> values
+        )
+    {
+        return one_by_one_visitor_and_value_referer<Visitor, Visitables, Values... > (
+            visitor, visitables, values
+        );
+    }
+
+    template <typename Visitor, typename Visitables, typename... Values>
+    class one_by_one_visitor_and_value_referer
+    {
+        Visitor&                        visitor_;
+        std::tuple<Values&...>          values_;
+        Visitables                      visitables_;
+
+    public: // structors
+        one_by_one_visitor_and_value_referer(
+                    Visitor& visitor, Visitables visitables, std::tuple<Values&...> values
+                ) BOOST_NOEXCEPT
+            : visitor_(visitor)
+            , values_(values)
+            , visitables_(visitables)
+        {}
+
+    public: // visitor interfaces
+        typedef typename Visitor::result_type result_type;
+
+        template <typename Value>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) operator()(Value& value) const
+        {
+            return ::boost::apply_visitor(
+                make_one_by_one_visitor_and_value_referer(
+                    visitor_,
+                    tuple_tail(visitables_),
+                    std::tuple_cat(values_, std::tuple<Value&>(value))
+                )
+                , std::get<0>(visitables_) // getting Head element
+            );
+        }
+
+    private:
+        one_by_one_visitor_and_value_referer& operator=(const one_by_one_visitor_and_value_referer&);
+    };
+
+    template <typename Visitor, typename... Values>
+    class one_by_one_visitor_and_value_referer<Visitor, std::tuple<>, Values...>
+    {
+        Visitor&                        visitor_;
+        std::tuple<Values&...>          values_;
+
+    public:
+        one_by_one_visitor_and_value_referer(
+                    Visitor& visitor, std::tuple<> /*visitables*/, std::tuple<Values&...> values
+                ) BOOST_NOEXCEPT
+            : visitor_(visitor)
+            , values_(values)
+        {}
+
+        typedef typename Visitor::result_type result_type;
+
+        template <class Tuple, std::size_t... I>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) do_call(Tuple t, index_sequence<I...>) const {
+            return visitor_(std::get<I>(t)...);
+        }
+
+        template <typename Value>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) operator()(Value& value) const
+        {
+            return do_call(
+                std::tuple_cat(values_, std::tuple<Value&>(value)),
+                make_index_sequence<sizeof...(Values) + 1>()
+            );
+        }
+    };
+
+}} // namespace detail::variant
+
+    template <class Visitor, class T1, class T2, class T3, class... TN>
+    inline BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+        apply_visitor(const Visitor& visitor, T1& v1, T2& v2, T3& v3, TN&... vn)
+    {
+        return ::boost::apply_visitor(
+            ::boost::detail::variant::make_one_by_one_visitor_and_value_referer(
+                visitor,
+                ::boost::detail::variant::forward_as_tuple_simple(v2, v3, vn...),
+                std::tuple<>()
+            ),
+            v1
+        );
+    }
+    
+    template <class Visitor, class T1, class T2, class T3, class... TN>
+    inline BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+        apply_visitor(Visitor& visitor, T1& v1, T2& v2, T3& v3, TN&... vn)
+    {
+        return ::boost::apply_visitor(
+            ::boost::detail::variant::make_one_by_one_visitor_and_value_referer(
+                visitor,
+                ::boost::detail::variant::forward_as_tuple_simple(v2, v3, vn...),
+                std::tuple<>()
+            ),
+            v1
+        );
+    }
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_MULTIVISITORS_CPP11_BASED_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/multivisitors_cpp14_based.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/multivisitors_cpp14_based.hpp
new file mode 100644
index 00000000000..a2af32864eb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/multivisitors_cpp14_based.hpp
@@ -0,0 +1,142 @@
+//  Boost.Varaint
+//  Contains multivisitors that are implemented via variadic templates, std::tuple
+//  and decltype(auto)
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2013-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).
+
+#ifndef BOOST_VARIANT_DETAIL_MULTIVISITORS_CPP14_BASED_HPP
+#define BOOST_VARIANT_DETAIL_MULTIVISITORS_CPP14_BASED_HPP
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/variant/detail/multivisitors_cpp14_based.hpp>
+
+namespace boost { 
+
+namespace detail { namespace variant {
+
+    // Forward declaration
+    template <typename Visitor, typename Visitables, typename... Values>
+    class one_by_one_visitor_and_value_referer_cpp14;
+
+    template <typename Visitor, typename Visitables, typename... Values>
+    inline one_by_one_visitor_and_value_referer_cpp14<Visitor, Visitables, Values... >
+        make_one_by_one_visitor_and_value_referer_cpp14(
+            Visitor& visitor, Visitables visitables, std::tuple<Values&...> values
+        )
+    {
+        return one_by_one_visitor_and_value_referer_cpp14<Visitor, Visitables, Values... > (
+            visitor, visitables, values
+        );
+    }
+
+    template <typename Visitor, typename Visitables, typename... Values>
+    class one_by_one_visitor_and_value_referer_cpp14
+    {
+        Visitor&                        visitor_;
+        std::tuple<Values&...>          values_;
+        Visitables                      visitables_;
+
+    public: // structors
+        one_by_one_visitor_and_value_referer_cpp14(
+                    Visitor& visitor, Visitables visitables, std::tuple<Values&...> values
+                ) BOOST_NOEXCEPT
+            : visitor_(visitor)
+            , values_(values)
+            , visitables_(visitables)
+        {}
+
+    public: // visitor interfaces
+        template <typename Value>
+        decltype(auto) operator()(Value& value) const
+        {
+            return ::boost::apply_visitor(
+                make_one_by_one_visitor_and_value_referer_cpp14(
+                    visitor_,
+                    tuple_tail(visitables_),
+                    std::tuple_cat(values_, std::tuple<Value&>(value))
+                )
+                , std::get<0>(visitables_) // getting Head element
+            );
+        }
+
+    private:
+        one_by_one_visitor_and_value_referer_cpp14& operator=(const one_by_one_visitor_and_value_referer_cpp14&);
+    };
+
+    template <typename Visitor, typename... Values>
+    class one_by_one_visitor_and_value_referer_cpp14<Visitor, std::tuple<>, Values...>
+    {
+        Visitor&                        visitor_;
+        std::tuple<Values&...>          values_;
+
+    public:
+        one_by_one_visitor_and_value_referer_cpp14(
+                    Visitor& visitor, std::tuple<> /*visitables*/, std::tuple<Values&...> values
+                ) BOOST_NOEXCEPT
+            : visitor_(visitor)
+            , values_(values)
+        {}
+
+        template <class Tuple, std::size_t... I>
+        decltype(auto) do_call(Tuple t, index_sequence<I...>) const {
+            return visitor_(std::get<I>(t)...);
+        }
+
+        template <typename Value>
+        decltype(auto) operator()(Value& value) const
+        {
+            return do_call(
+                std::tuple_cat(values_, std::tuple<Value&>(value)),
+                make_index_sequence<sizeof...(Values) + 1>()
+            );
+        }
+    };
+
+}} // namespace detail::variant
+
+    template <class Visitor, class T1, class T2, class T3, class... TN>
+    inline decltype(auto) apply_visitor(const Visitor& visitor, T1& v1, T2& v2, T3& v3, TN&... vn,
+        typename boost::disable_if<
+            boost::detail::variant::has_result_type<Visitor>
+        >::type* = 0)
+    {
+        return boost::apply_visitor(
+            ::boost::detail::variant::make_one_by_one_visitor_and_value_referer_cpp14(
+                visitor,
+                ::boost::detail::variant::forward_as_tuple_simple(v2, v3, vn...),
+                std::tuple<>()
+            ),
+            v1
+        );
+    }
+    
+
+    template <class Visitor, class T1, class T2, class T3, class... TN>
+    inline decltype(auto) apply_visitor(Visitor& visitor, T1& v1, T2& v2, T3& v3, TN&... vn,
+        typename boost::disable_if<
+            boost::detail::variant::has_result_type<Visitor>
+        >::type* = 0)
+    {
+        return ::boost::apply_visitor(
+            ::boost::detail::variant::make_one_by_one_visitor_and_value_referer_cpp14(
+                visitor,
+                ::boost::detail::variant::forward_as_tuple_simple(v2, v3, vn...),
+                std::tuple<>()
+            ),
+            v1
+        );
+    }
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_MULTIVISITORS_CPP14_BASED_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/multivisitors_preprocessor_based.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/multivisitors_preprocessor_based.hpp
new file mode 100644
index 00000000000..746df18550d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/multivisitors_preprocessor_based.hpp
@@ -0,0 +1,143 @@
+//  Boost.Varaint
+//  Contains multivisitors that are implemented via preprocessor magic
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2013-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).
+
+#ifndef BOOST_VARIANT_DETAIL_MULTIVISITORS_PREPROCESSOR_BASED_HPP
+#define BOOST_VARIANT_DETAIL_MULTIVISITORS_PREPROCESSOR_BASED_HPP
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/variant.hpp>
+#include <boost/bind.hpp>
+
+#include <boost/preprocessor/repetition.hpp>
+#include <boost/preprocessor/punctuation/comma_if.hpp>
+#include <boost/preprocessor/arithmetic/add.hpp>
+#include <boost/preprocessor/arithmetic/sub.hpp>
+
+#ifndef BOOST_VARAINT_MAX_MULTIVIZITOR_PARAMS
+#   define BOOST_VARAINT_MAX_MULTIVIZITOR_PARAMS 4
+#endif
+
+namespace boost { 
+
+namespace detail { namespace variant {
+
+    template <class VisitorT, class Visitable1T, class Visitable2T>
+    struct two_variables_holder {
+    private:
+        VisitorT&       visitor_;
+        Visitable1T&    visitable1_;
+        Visitable2T&    visitable2_;
+
+        // required to suppress warnings and ensure that we do not copy
+        // this visitor
+        two_variables_holder& operator=(const two_variables_holder&);
+
+    public:
+        typedef BOOST_DEDUCED_TYPENAME VisitorT::result_type result_type;
+
+        explicit two_variables_holder(VisitorT& visitor, Visitable1T& visitable1, Visitable2T& visitable2) BOOST_NOEXCEPT 
+            : visitor_(visitor)
+            , visitable1_(visitable1)
+            , visitable2_(visitable2)
+        {}
+
+#define BOOST_VARIANT_OPERATOR_BEG()                            \
+    return ::boost::apply_visitor(                              \
+    ::boost::bind<result_type>(boost::ref(visitor_), _1, _2     \
+    /**/
+
+#define BOOST_VARIANT_OPERATOR_END()                            \
+    ), visitable1_, visitable2_);                               \
+    /**/
+
+#define BOOST_VARANT_VISITORS_VARIABLES_PRINTER(z, n, data)     \
+    BOOST_PP_COMMA() boost::ref( BOOST_PP_CAT(vis, n) )         \
+    /**/
+
+#define BOOST_VARIANT_VISIT(z, n, data)                                                     \
+    template <BOOST_PP_ENUM_PARAMS(BOOST_PP_ADD(n, 1), class VisitableUnwrapped)>           \
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type) operator()(                          \
+        BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ADD(n, 1), VisitableUnwrapped, & vis)          \
+    ) const                                                                                 \
+    {                                                                                       \
+        BOOST_VARIANT_OPERATOR_BEG()                                                        \
+        BOOST_PP_REPEAT(BOOST_PP_ADD(n, 1), BOOST_VARANT_VISITORS_VARIABLES_PRINTER, ~)     \
+        BOOST_VARIANT_OPERATOR_END()                                                        \
+    }                                                                                       \
+    /**/
+
+BOOST_PP_REPEAT( BOOST_PP_SUB(BOOST_VARAINT_MAX_MULTIVIZITOR_PARAMS, 2), BOOST_VARIANT_VISIT, ~)
+#undef BOOST_VARIANT_OPERATOR_BEG
+#undef BOOST_VARIANT_OPERATOR_END
+#undef BOOST_VARANT_VISITORS_VARIABLES_PRINTER
+#undef BOOST_VARIANT_VISIT
+
+    };
+
+    template <class VisitorT, class Visitable1T, class Visitable2T>
+    inline two_variables_holder<VisitorT, Visitable1T, Visitable2T> make_two_variables_holder(
+            VisitorT& visitor, Visitable1T& visitable1, Visitable2T& visitable2
+        ) BOOST_NOEXCEPT
+    {
+        return two_variables_holder<VisitorT, Visitable1T, Visitable2T>(visitor, visitable1, visitable2);
+    }
+
+    template <class VisitorT, class Visitable1T, class Visitable2T>
+    inline two_variables_holder<const VisitorT, Visitable1T, Visitable2T> make_two_variables_holder(
+            const VisitorT& visitor, Visitable1T& visitable1, Visitable2T& visitable2
+        ) BOOST_NOEXCEPT
+    {
+        return two_variables_holder<const VisitorT, Visitable1T, Visitable2T>(visitor, visitable1, visitable2);
+    }
+
+}} // namespace detail::variant
+
+#define BOOST_VARIANT_APPLY_VISITOR_BEG()                                               \
+    return ::boost::apply_visitor(                                                      \
+            boost::detail::variant::make_two_variables_holder(visitor, var0 , var1),    \
+            var2                                                                        \
+    /**/
+
+#define BOOST_VARIANT_APPLY_VISITOR_END()                       \
+    );                                                          \
+    /**/
+
+#define BOOST_VARANT_VISITORS_VARIABLES_PRINTER(z, n, data)     \
+    BOOST_PP_COMMA() BOOST_PP_CAT(var, BOOST_PP_ADD(n, 3))      \
+    /**/
+
+#define BOOST_VARIANT_VISIT(z, n, data)                                                                 \
+    template <class Visitor BOOST_PP_COMMA() BOOST_PP_ENUM_PARAMS(BOOST_PP_ADD(n, 3), class T)>         \
+    inline BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(BOOST_DEDUCED_TYPENAME Visitor::result_type) apply_visitor( \
+        data BOOST_PP_COMMA() BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ADD(n, 3), T, & var)     \
+    )                                                                                                   \
+    {                                                                                                   \
+        BOOST_VARIANT_APPLY_VISITOR_BEG()                                                               \
+        BOOST_PP_REPEAT(n, BOOST_VARANT_VISITORS_VARIABLES_PRINTER, ~)                                  \
+        BOOST_VARIANT_APPLY_VISITOR_END()                                                               \
+    }                                                                                                   \
+    /**/
+
+BOOST_PP_REPEAT( BOOST_PP_SUB(BOOST_VARAINT_MAX_MULTIVIZITOR_PARAMS, 2), BOOST_VARIANT_VISIT, const Visitor& visitor)
+BOOST_PP_REPEAT( BOOST_PP_SUB(BOOST_VARAINT_MAX_MULTIVIZITOR_PARAMS, 2), BOOST_VARIANT_VISIT, Visitor& visitor)
+
+#undef BOOST_VARIANT_APPLY_VISITOR_BEG
+#undef BOOST_VARIANT_APPLY_VISITOR_END
+#undef BOOST_VARANT_VISITORS_VARIABLES_PRINTER
+#undef BOOST_VARIANT_VISIT
+    
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_MULTIVISITORS_PREPROCESSOR_BASED_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/over_sequence.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/over_sequence.hpp
new file mode 100644
index 00000000000..48394f072d8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/over_sequence.hpp
@@ -0,0 +1,58 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/over_sequence.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// Portions Copyright (C) 2002 David Abrahams
+//
+// 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_VARIANT_DETAIL_OVER_SEQUENCE_HPP
+#define BOOST_VARIANT_DETAIL_OVER_SEQUENCE_HPP
+
+#include <boost/mpl/aux_/config/ctps.hpp>
+
+
+namespace boost {
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class over_sequence
+//
+// Wrapper used to indicate bounded types for variant are from type sequence.
+//
+template <typename Types>
+struct over_sequence
+{
+    typedef Types type;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction is_over_sequence (modeled on code by David Abrahams)
+//
+// Indicates whether the specified type is of form over_sequence<...> or not.
+//
+
+
+template <typename T>
+struct is_over_sequence
+    : mpl::false_
+{
+};
+
+template <typename Types>
+struct is_over_sequence< over_sequence<Types> >
+    : mpl::true_
+{
+};
+
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_OVER_SEQUENCE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/substitute.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/substitute.hpp
new file mode 100644
index 00000000000..2579eb51bbd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/substitute.hpp
@@ -0,0 +1,253 @@
+
+#if !defined(BOOST_PP_IS_ITERATING)
+
+///// header body
+
+//-----------------------------------------------------------------------------
+// boost variant/detail/substitute.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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_VARIANT_DETAIL_SUBSTITUTE_HPP
+#define BOOST_VARIANT_DETAIL_SUBSTITUTE_HPP
+
+#include <boost/mpl/aux_/config/ctps.hpp>
+
+#include <boost/variant/detail/substitute_fwd.hpp>
+#include <boost/variant/variant_fwd.hpp> // for BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES
+#include <boost/mpl/aux_/lambda_arity_param.hpp>
+#include <boost/mpl/aux_/preprocessor/params.hpp>
+#include <boost/mpl/aux_/preprocessor/repeat.hpp>
+#include <boost/mpl/int_fwd.hpp>
+#include <boost/mpl/limits/arity.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/empty.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/preprocessor/iterate.hpp>
+
+namespace boost {
+namespace detail { namespace variant {
+
+#if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction substitute
+//
+// Substitutes one type for another in the given type expression.
+//
+
+//
+// primary template
+//
+template <
+      typename T, typename Dest, typename Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(
+          typename Arity /* = ... (see substitute_fwd.hpp) */
+        )
+    >
+struct substitute
+{
+    typedef T type;
+};
+
+//
+// tag substitution specializations
+//
+
+#define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG(CV_) \
+    template <typename Dest, typename Source> \
+    struct substitute< \
+          CV_ Source \
+        , Dest \
+        , Source \
+          BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>) \
+        > \
+    { \
+        typedef CV_ Dest type; \
+    }; \
+    /**/
+
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG( BOOST_PP_EMPTY() )
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG(const)
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG(volatile)
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG(const volatile)
+
+#undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_SUBSTITUTE_TAG
+
+//
+// pointer specializations
+//
+#define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER(CV_) \
+    template <typename T, typename Dest, typename Source> \
+    struct substitute< \
+          T * CV_ \
+        , Dest \
+        , Source \
+          BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>) \
+        > \
+    { \
+        typedef typename substitute< \
+              T, Dest, Source \
+            >::type * CV_ type; \
+    }; \
+    /**/
+
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER( BOOST_PP_EMPTY() )
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER(const)
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER(volatile)
+BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER(const volatile)
+
+#undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_IMPL_HANDLE_POINTER
+
+//
+// reference specializations
+//
+template <typename T, typename Dest, typename Source>
+struct substitute<
+      T&
+    , Dest
+    , Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>)
+    >
+{
+    typedef typename substitute<
+          T, Dest, Source
+        >::type & type;
+};
+
+//
+// template expression (i.e., F<...>) specializations
+//
+
+#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+template <
+      template <typename...> class F
+    , typename... Ts
+    , typename Dest
+    , typename Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(typename Arity)
+    >
+struct substitute<
+      F<Ts...>
+    , Dest
+    , Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(Arity)
+    >
+{
+    typedef F<typename substitute<
+          Ts, Dest, Source
+        >::type...> type;
+};
+#endif // !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+
+#define BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF_IMPL(N) \
+    typedef typename substitute< \
+          BOOST_PP_CAT(U,N), Dest, Source \
+        >::type BOOST_PP_CAT(u,N); \
+    /**/
+
+#define BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF(z, N, _) \
+    BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF_IMPL( BOOST_PP_INC(N) ) \
+    /**/
+
+#define BOOST_PP_ITERATION_LIMITS (0,BOOST_MPL_LIMIT_METAFUNCTION_ARITY)
+#define BOOST_PP_FILENAME_1 <boost/variant/detail/substitute.hpp>
+#include BOOST_PP_ITERATE()
+
+#undef BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF_IMPL
+#undef BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF
+
+#endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_SUBSTITUTE_HPP
+
+///// iteration, depth == 1
+
+#elif BOOST_PP_ITERATION_DEPTH() == 1
+#define i BOOST_PP_FRAME_ITERATION(1)
+
+#if i > 0
+
+//
+// template specializations
+//
+template <
+      template < BOOST_MPL_PP_PARAMS(i,typename P) > class T
+    , BOOST_MPL_PP_PARAMS(i,typename U)
+    , typename Dest
+    , typename Source
+    >
+struct substitute<
+      T< BOOST_MPL_PP_PARAMS(i,U) >
+    , Dest
+    , Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<( i )>)
+    >
+{
+private:
+    BOOST_MPL_PP_REPEAT(i, BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF, _)
+
+public:
+    typedef T< BOOST_MPL_PP_PARAMS(i,u) > type;
+};
+
+//
+// function specializations
+//
+template <
+      typename R
+    , BOOST_MPL_PP_PARAMS(i,typename U)
+    , typename Dest
+    , typename Source
+    >
+struct substitute<
+      R (*)( BOOST_MPL_PP_PARAMS(i,U) )
+    , Dest
+    , Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>)
+    >
+{
+private:
+    typedef typename substitute< R, Dest, Source >::type r;
+    BOOST_MPL_PP_REPEAT(i, BOOST_VARIANT_AUX_SUBSTITUTE_TYPEDEF, _)
+
+public:
+    typedef r (*type)( BOOST_MPL_PP_PARAMS(i,u) );
+};
+
+#elif i == 0
+
+//
+// zero-arg function specialization
+//
+template <
+      typename R, typename Dest, typename Source
+    >
+struct substitute<
+      R (*)( void )
+    , Dest
+    , Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(mpl::int_<-1>)
+    >
+{
+private:
+    typedef typename substitute< R, Dest, Source >::type r;
+
+public:
+    typedef r (*type)( void );
+};
+
+#endif // i
+
+#undef i
+#endif // BOOST_PP_IS_ITERATING
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/substitute_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/substitute_fwd.hpp
new file mode 100644
index 00000000000..cc490744e1f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/substitute_fwd.hpp
@@ -0,0 +1,58 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/substitute_fwd.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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_VARIANT_DETAIL_SUBSTITUTE_FWD_HPP
+#define BOOST_VARIANT_DETAIL_SUBSTITUTE_FWD_HPP
+
+#include <boost/mpl/aux_/lambda_arity_param.hpp>
+#include <boost/mpl/aux_/template_arity.hpp>
+#include <boost/mpl/int_fwd.hpp>
+
+
+///////////////////////////////////////////////////////////////////////////////
+// BOOST_VARIANT_DETAIL_NO_SUBSTITUTE
+//
+// Defined if 'substitute' is not implementable on the current compiler.
+//
+
+#include <boost/mpl/aux_/config/ctps.hpp>
+#include <boost/mpl/aux_/config/ttp.hpp>
+
+#if defined(BOOST_NO_TEMPLATE_TEMPLATE_PARAMETERS) \
+ && !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+#   define BOOST_VARIANT_DETAIL_NO_SUBSTITUTE
+#endif
+
+namespace boost {
+namespace detail { namespace variant {
+
+#if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction substitute
+//
+// Substitutes one type for another in the given type expression.
+//
+template <
+      typename T, typename Dest, typename Source
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(
+          typename Arity = mpl::int_< mpl::aux::template_arity<T>::value >
+        )
+    >
+struct substitute;
+
+#endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+}} // namespace detail::variant
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_SUBSTITUTE_FWD_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/variant_io.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/variant_io.hpp
new file mode 100644
index 00000000000..63df74f24b9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/variant_io.hpp
@@ -0,0 +1,95 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/variant_io.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-2003
+// Eric Friedman, Itay Maman
+//
+// 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_VARIANT_DETAIL_VARIANT_IO_HPP
+#define BOOST_VARIANT_DETAIL_VARIANT_IO_HPP
+
+#include <iosfwd> // for std::basic_ostream forward declare
+
+#include <boost/variant/variant_fwd.hpp>
+
+#include <boost/detail/templated_streams.hpp>
+#include <boost/variant/static_visitor.hpp>
+
+namespace boost {
+
+///////////////////////////////////////////////////////////////////////////////
+// function template operator<<
+//
+// Outputs the content of the given variant to the given ostream.
+//
+
+// forward declare (allows output of embedded variant< variant< ... >, ... >)
+template <
+      BOOST_TEMPLATED_STREAM_ARGS(E,T)
+    BOOST_TEMPLATED_STREAM_COMMA
+      BOOST_VARIANT_ENUM_PARAMS(typename U)
+    >
+inline BOOST_TEMPLATED_STREAM(ostream, E,T)& operator<<(
+      BOOST_TEMPLATED_STREAM(ostream, E,T)& out
+    , const variant< BOOST_VARIANT_ENUM_PARAMS(U) >& rhs
+    );
+
+namespace detail { namespace variant {
+
+template <typename OStream>
+class printer
+    : public boost::static_visitor<>
+{
+private: // representation
+
+    OStream& out_;
+
+public: // structors
+
+    explicit printer(OStream& out)
+        : out_( out )
+    {
+    }
+
+public: // visitor interface
+
+    template <typename T>
+    void operator()(const T& operand) const
+    {
+        out_ << operand;
+    }
+
+private:
+    printer& operator=(const printer&);
+
+};
+
+}} // namespace detail::variant
+
+template <
+      BOOST_TEMPLATED_STREAM_ARGS(E,T)
+    BOOST_TEMPLATED_STREAM_COMMA
+      BOOST_VARIANT_ENUM_PARAMS(typename U)
+    >
+inline BOOST_TEMPLATED_STREAM(ostream, E,T)& operator<<(
+      BOOST_TEMPLATED_STREAM(ostream, E,T)& out
+    , const variant< BOOST_VARIANT_ENUM_PARAMS(U) >& rhs
+    )
+{
+    detail::variant::printer<
+          BOOST_TEMPLATED_STREAM(ostream, E,T)
+        > visitor(out);
+
+    rhs.apply_visitor(visitor);
+
+    return out;
+}
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_DETAIL_VARIANT_IO_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/detail/visitation_impl.hpp b/contrib/libboost/boost_1_65_0/boost/variant/detail/visitation_impl.hpp
new file mode 100644
index 00000000000..d741a4ab29a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/detail/visitation_impl.hpp
@@ -0,0 +1,277 @@
+//-----------------------------------------------------------------------------
+// boost variant/detail/visitation_impl.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003
+// Eric Friedman
+//
+// 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_VARIANT_DETAIL_VISITATION_IMPL_HPP
+#define BOOST_VARIANT_DETAIL_VISITATION_IMPL_HPP
+
+#include <boost/config.hpp>
+
+#include <boost/variant/detail/backup_holder.hpp>
+#include <boost/variant/detail/cast_storage.hpp>
+#include <boost/variant/detail/forced_return.hpp>
+#include <boost/variant/detail/generic_result_type.hpp>
+#include <boost/variant/variant_fwd.hpp> // for BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/or.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/inc.hpp>
+#include <boost/preprocessor/repeat.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/has_nothrow_copy.hpp>
+#include <boost/type_traits/is_nothrow_move_constructible.hpp>
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) 
+# pragma warning (push) 
+# pragma warning (disable : 4702) //unreachable code 
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// BOOST_VARIANT_VISITATION_UNROLLING_LIMIT
+//
+// Unrolls variant's visitation mechanism to reduce template instantiation
+// and potentially increase runtime performance. (TODO: Investigate further.)
+//
+#if !defined(BOOST_VARIANT_VISITATION_UNROLLING_LIMIT)
+
+#ifndef BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES
+#   include <boost/mpl/limits/list.hpp>
+#   define BOOST_VARIANT_VISITATION_UNROLLING_LIMIT   \
+        BOOST_MPL_LIMIT_LIST_SIZE
+#else
+#   define BOOST_VARIANT_VISITATION_UNROLLING_LIMIT   \
+        BOOST_VARIANT_LIMIT_TYPES
+#endif
+
+#endif
+
+namespace boost {
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class apply_visitor_unrolled
+//
+// Tag type indicates when visitation_impl is unrolled.
+//
+struct apply_visitor_unrolled {};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class template visitation_impl_step
+//
+// "Never ending" iterator range facilitates visitation_impl unrolling.
+//
+
+
+template <typename Iter, typename LastIter>
+struct visitation_impl_step
+{
+    typedef typename mpl::deref<Iter>::type type;
+
+    typedef typename mpl::next<Iter>::type next_iter;
+    typedef visitation_impl_step<
+          next_iter, LastIter
+        > next;
+};
+
+template <typename LastIter>
+struct visitation_impl_step< LastIter,LastIter >
+{
+    typedef apply_visitor_unrolled type;
+    typedef visitation_impl_step next;
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) function template visitation_impl_invoke
+//
+// Invokes the given visitor on the specified type in the given storage.
+//
+
+template <typename Visitor, typename VoidPtrCV, typename T>
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+visitation_impl_invoke_impl(
+      int, Visitor& visitor, VoidPtrCV storage, T*
+    , mpl::true_// never_uses_backup
+    )
+{
+    return visitor.internal_visit(
+          cast_storage<T>(storage), 1L
+        );
+}
+
+template <typename Visitor, typename VoidPtrCV, typename T>
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+visitation_impl_invoke_impl(
+      int internal_which, Visitor& visitor, VoidPtrCV storage, T*
+    , mpl::false_// never_uses_backup
+    )
+{
+    if (internal_which >= 0)
+    {
+        return visitor.internal_visit(
+              cast_storage<T>(storage), 1L
+            );
+    }
+    else
+    {
+        return visitor.internal_visit(
+              cast_storage< backup_holder<T> >(storage), 1L
+            );
+    }
+}
+
+template <typename Visitor, typename VoidPtrCV, typename T, typename NoBackupFlag>
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+visitation_impl_invoke(
+      int internal_which, Visitor& visitor, VoidPtrCV storage, T* t
+    , NoBackupFlag
+    , int
+    )
+{
+    typedef typename mpl::or_<
+          NoBackupFlag
+        , is_nothrow_move_constructible<T>
+        , has_nothrow_copy<T>
+        >::type never_uses_backup;
+
+    return (visitation_impl_invoke_impl)(
+          internal_which, visitor, storage, t
+        , never_uses_backup()
+        );
+}
+
+template <typename Visitor, typename VoidPtrCV, typename NBF>
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+visitation_impl_invoke(int, Visitor&, VoidPtrCV, apply_visitor_unrolled*, NBF, long)
+{
+    // should never be here at runtime!
+    typedef typename Visitor::result_type result_type;
+    return ::boost::detail::variant::forced_return< result_type >();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) function template visitation_impl
+//
+// Invokes the given visitor on the type in the given variant storage.
+//
+
+template <
+      typename W, typename S
+    , typename Visitor, typename VPCV
+    , typename NBF
+    >
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+visitation_impl(
+      int, int, Visitor&, VPCV
+    , mpl::true_ // is_apply_visitor_unrolled
+    , NBF, W* = 0, S* = 0
+    )
+{
+    // should never be here at runtime!
+    typedef typename Visitor::result_type result_type;
+    return ::boost::detail::variant::forced_return< result_type >();
+}
+
+template <
+      typename Which, typename step0
+    , typename Visitor, typename VoidPtrCV
+    , typename NoBackupFlag
+    >
+inline
+    BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(typename Visitor::result_type)
+visitation_impl(
+      const int internal_which, const int logical_which
+    , Visitor& visitor, VoidPtrCV storage
+    , mpl::false_ // is_apply_visitor_unrolled
+    , NoBackupFlag no_backup_flag
+    , Which* = 0, step0* = 0
+    )
+{
+    // Typedef apply_visitor_unrolled steps and associated types...
+#   define BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_TYPEDEF(z, N, _) \
+    typedef typename BOOST_PP_CAT(step,N)::type BOOST_PP_CAT(T,N); \
+    typedef typename BOOST_PP_CAT(step,N)::next \
+        BOOST_PP_CAT(step, BOOST_PP_INC(N)); \
+    /**/
+
+    BOOST_PP_REPEAT(
+          BOOST_VARIANT_VISITATION_UNROLLING_LIMIT
+        , BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_TYPEDEF
+        , _
+        )
+
+#   undef BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_TYPEDEF
+
+    // ...switch on the target which-index value...
+    switch (logical_which)
+    {
+
+    // ...applying the appropriate case:
+#   define BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_CASE(z, N, _) \
+    case (Which::value + (N)): \
+        return (visitation_impl_invoke)( \
+              internal_which, visitor, storage \
+            , static_cast<BOOST_PP_CAT(T,N)*>(0) \
+            , no_backup_flag, 1L \
+            ); \
+    /**/
+
+    BOOST_PP_REPEAT(
+          BOOST_VARIANT_VISITATION_UNROLLING_LIMIT
+        , BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_CASE
+        , _
+        )
+
+#   undef BOOST_VARIANT_AUX_APPLY_VISITOR_STEP_CASE
+
+    default: break;
+    }
+
+    // If not handled in this iteration, continue unrolling:
+    typedef mpl::int_<
+          Which::value + (BOOST_VARIANT_VISITATION_UNROLLING_LIMIT)
+        > next_which;
+
+    typedef BOOST_PP_CAT(step, BOOST_VARIANT_VISITATION_UNROLLING_LIMIT)
+        next_step;
+
+    typedef typename next_step::type next_type;
+    typedef typename is_same< next_type,apply_visitor_unrolled >::type
+        is_apply_visitor_unrolled;
+
+    return detail::variant::visitation_impl(
+          internal_which, logical_which
+        , visitor, storage
+        , is_apply_visitor_unrolled()
+        , no_backup_flag
+        , static_cast<next_which*>(0), static_cast<next_step*>(0)
+        );
+}
+
+}} // namespace detail::variant
+} // namespace boost
+
+#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)  
+# pragma warning(pop)  
+#endif 
+
+#endif // BOOST_VARIANT_DETAIL_VISITATION_IMPL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/get.hpp b/contrib/libboost/boost_1_65_0/boost/variant/get.hpp
new file mode 100644
index 00000000000..fd702ba60c0
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/get.hpp
@@ -0,0 +1,372 @@
+//-----------------------------------------------------------------------------
+// boost variant/get.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003 Eric Friedman, Itay Maman
+// Copyright (c) 2014 Antony Polukhin
+//
+// 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_VARIANT_GET_HPP
+#define BOOST_VARIANT_GET_HPP
+
+#include <exception>
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/utility/addressof.hpp>
+#include <boost/variant/variant_fwd.hpp>
+#include <boost/variant/detail/element_index.hpp>
+#include <boost/variant/detail/move.hpp>
+
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/add_pointer.hpp>
+#include <boost/type_traits/is_lvalue_reference.hpp>
+
+namespace boost {
+
+#if defined(BOOST_CLANG)
+#   pragma clang diagnostic push
+#   pragma clang diagnostic ignored "-Wweak-vtables"
+#endif
+//////////////////////////////////////////////////////////////////////////
+// class bad_get
+//
+// The exception thrown in the event of a failed get of a value.
+//
+class BOOST_SYMBOL_VISIBLE bad_get
+    : public std::exception
+{
+public: // std::exception implementation
+
+    virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW
+    {
+        return "boost::bad_get: "
+               "failed value get using boost::get";
+    }
+
+};
+#if defined(BOOST_CLANG)
+#   pragma clang diagnostic pop
+#endif
+
+
+//////////////////////////////////////////////////////////////////////////
+// function template get<T>
+//
+// Retrieves content of given variant object if content is of type T.
+// Otherwise: pointer ver. returns 0; reference ver. throws bad_get.
+//
+
+namespace detail { namespace variant {
+
+// (detail) class template get_visitor
+//
+// Generic static visitor that: if the value is of the specified type,
+// returns a pointer to the value it visits; else a null pointer.
+//
+template <typename T>
+struct get_visitor
+{
+private: // private typedefs
+
+    typedef typename add_pointer<T>::type pointer;
+    typedef typename add_reference<T>::type reference;
+
+public: // visitor typedefs
+
+    typedef pointer result_type;
+
+public: // visitor interfaces
+
+    pointer operator()(reference operand) const BOOST_NOEXCEPT
+    {
+        return boost::addressof(operand);
+    }
+
+    template <typename U>
+    pointer operator()(const U&) const BOOST_NOEXCEPT
+    {
+        return static_cast<pointer>(0);
+    }
+};
+
+}} // namespace detail::variant
+
+#ifndef BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE
+#   if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551))
+#       define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t)
+#   else
+#       define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t)  \
+        , t* = 0
+#   endif
+#endif
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// relaxed_get<U>(variant) methods
+//
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_pointer<U>::type
+relaxed_get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    ) BOOST_NOEXCEPT
+{
+    typedef typename add_pointer<U>::type U_ptr;
+    if (!operand) return static_cast<U_ptr>(0);
+
+    detail::variant::get_visitor<U> v;
+    return operand->apply_visitor(v);
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_pointer<const U>::type
+relaxed_get(
+      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    ) BOOST_NOEXCEPT
+{
+    typedef typename add_pointer<const U>::type U_ptr;
+    if (!operand) return static_cast<U_ptr>(0);
+
+    detail::variant::get_visitor<const U> v;
+    return operand->apply_visitor(v);
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_reference<U>::type
+relaxed_get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+    typedef typename add_pointer<U>::type U_ptr;
+    U_ptr result = relaxed_get<U>(boost::addressof(operand));
+
+    if (!result)
+        boost::throw_exception(bad_get());
+    return *result;
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_reference<const U>::type
+relaxed_get(
+      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+    typedef typename add_pointer<const U>::type U_ptr;
+    U_ptr result = relaxed_get<const U>(boost::addressof(operand));
+
+    if (!result)
+        boost::throw_exception(bad_get());
+    return *result;
+}
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    U&&
+relaxed_get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >&& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+    typedef typename add_pointer<U>::type U_ptr;
+    U_ptr result = relaxed_get<U>(boost::addressof(operand));
+
+    if (!result)
+        boost::throw_exception(bad_get());
+    return static_cast<U&&>(*result);
+}
+#endif
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// strict_get<U>(variant) methods
+//
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_pointer<U>::type
+strict_get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    ) BOOST_NOEXCEPT
+{
+    BOOST_STATIC_ASSERT_MSG(
+        (boost::detail::variant::holds_element<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >, U >::value),
+        "boost::variant does not contain specified type U, "
+        "call to boost::get<U>(boost::variant<T...>*) will always return NULL"
+    );
+
+    return relaxed_get<U>(operand);
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_pointer<const U>::type
+strict_get(
+      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    ) BOOST_NOEXCEPT
+{
+    BOOST_STATIC_ASSERT_MSG(
+        (boost::detail::variant::holds_element<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >, const U >::value),
+        "boost::variant does not contain specified type U, "
+        "call to boost::get<U>(const boost::variant<T...>*) will always return NULL"
+    );
+
+    return relaxed_get<U>(operand);
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_reference<U>::type
+strict_get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+    BOOST_STATIC_ASSERT_MSG(
+        (boost::detail::variant::holds_element<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >, U >::value),
+        "boost::variant does not contain specified type U, "
+        "call to boost::get<U>(boost::variant<T...>&) will always throw boost::bad_get exception"
+    );
+
+    return relaxed_get<U>(operand);
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_reference<const U>::type
+strict_get(
+      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+    BOOST_STATIC_ASSERT_MSG(
+        (boost::detail::variant::holds_element<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >, const U >::value),
+        "boost::variant does not contain specified type U, "
+        "call to boost::get<U>(const boost::variant<T...>&) will always throw boost::bad_get exception"
+    );
+
+    return relaxed_get<U>(operand);
+}
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    U&&
+strict_get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >&& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+    BOOST_STATIC_ASSERT_MSG(
+        (!boost::is_lvalue_reference<U>::value),
+        "remove ampersand '&' from template type U in boost::get<U>(boost::variant<T...>&&) "
+    );
+
+    BOOST_STATIC_ASSERT_MSG(
+        (boost::detail::variant::holds_element<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >, U >::value),
+        "boost::variant does not contain specified type U, "
+        "call to boost::get<U>(const boost::variant<T...>&) will always throw boost::bad_get exception"
+    );
+
+    return relaxed_get<U>(detail::variant::move(operand));
+}
+#endif
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// get<U>(variant) methods
+//
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_pointer<U>::type
+get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    ) BOOST_NOEXCEPT
+{
+#ifdef BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT
+    return relaxed_get<U>(operand);
+#else
+    return strict_get<U>(operand);
+#endif
+
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_pointer<const U>::type
+get(
+      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    ) BOOST_NOEXCEPT
+{
+#ifdef BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT
+    return relaxed_get<U>(operand);
+#else
+    return strict_get<U>(operand);
+#endif
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_reference<U>::type
+get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+#ifdef BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT
+    return relaxed_get<U>(operand);
+#else
+    return strict_get<U>(operand);
+#endif
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_reference<const U>::type
+get(
+      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+#ifdef BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT
+    return relaxed_get<U>(operand);
+#else
+    return strict_get<U>(operand);
+#endif
+}
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    U&&
+get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >&& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+#ifdef BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT
+    return relaxed_get<U>(detail::variant::move(operand));
+#else
+    return strict_get<U>(detail::variant::move(operand));
+#endif
+}
+#endif
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_GET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/multivisitors.hpp b/contrib/libboost/boost_1_65_0/boost/variant/multivisitors.hpp
new file mode 100644
index 00000000000..18ae015ee49
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/multivisitors.hpp
@@ -0,0 +1,32 @@
+//  Boost.Varaint
+//  Multivisitors defined here 
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Antony Polukhin, 2013-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).
+
+#ifndef BOOST_VARIANT_MULTIVISITORS_HPP
+#define BOOST_VARIANT_MULTIVISITORS_HPP
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <boost/variant/variant_fwd.hpp> // for BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES
+
+#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_HDR_TUPLE)
+#   include <boost/variant/detail/multivisitors_cpp11_based.hpp>
+#   if !defined(BOOST_NO_CXX14_DECLTYPE_AUTO) && !defined(BOOST_NO_CXX11_DECLTYPE_N3276)
+#       include <boost/variant/detail/multivisitors_cpp14_based.hpp>
+#   endif
+#else
+#   include <boost/variant/detail/multivisitors_preprocessor_based.hpp>
+#endif
+
+#endif // BOOST_VARIANT_MULTIVISITORS_HPP
+
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/polymorphic_get.hpp b/contrib/libboost/boost_1_65_0/boost/variant/polymorphic_get.hpp
new file mode 100644
index 00000000000..c4ec0bfaaa6
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/polymorphic_get.hpp
@@ -0,0 +1,347 @@
+//-----------------------------------------------------------------------------
+// boost variant/polymorphic_get.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2013-2017 Antony Polukhin
+//
+// 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_VARIANT_POLYMORPHIC_GET_HPP
+#define BOOST_VARIANT_POLYMORPHIC_GET_HPP
+
+#include <exception>
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/utility/addressof.hpp>
+#include <boost/variant/variant_fwd.hpp>
+#include <boost/variant/get.hpp>
+
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/add_pointer.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/type_traits/is_const.hpp>
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// class bad_polymorphic_get
+//
+// The exception thrown in the event of a failed get of a value.
+//
+class BOOST_SYMBOL_VISIBLE bad_polymorphic_get
+    : public bad_get
+{
+public: // std::exception implementation
+
+    virtual const char * what() const BOOST_NOEXCEPT_OR_NOTHROW
+    {
+        return "boost::bad_polymorphic_get: "
+               "failed value get using boost::polymorphic_get";
+    }
+
+};
+
+//////////////////////////////////////////////////////////////////////////
+// function template get<T>
+//
+// Retrieves content of given variant object if content is of type T.
+// Otherwise: pointer ver. returns 0; reference ver. throws bad_get.
+//
+
+namespace detail { namespace variant {
+
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+// polymorphic metafunctions to detect index of a value
+//
+
+template <class Types, class T>
+struct element_polymorphic_iterator_impl :
+    boost::mpl::find_if<
+        Types,
+        boost::mpl::or_<
+            variant_element_functor<boost::mpl::_1, T>,
+            variant_element_functor<boost::mpl::_1, typename boost::remove_cv<T>::type >,
+            boost::is_base_of<T, boost::mpl::_1>
+        >
+    >
+{};
+
+template <class Variant, class T>
+struct holds_element_polymorphic :
+    boost::mpl::not_<
+        boost::is_same<
+            typename boost::mpl::end<typename Variant::types>::type,
+            typename element_polymorphic_iterator_impl<typename Variant::types, typename boost::remove_reference<T>::type >::type
+        >
+    >
+{};
+
+// (detail) class template get_polymorphic_visitor
+//
+// Generic static visitor that: if the value is of the specified
+// type or of a type derived from specified, returns a pointer
+// to the value it visits; else a null pointer.
+//
+template <typename Base>
+struct get_polymorphic_visitor
+{
+private: // private typedefs
+    typedef get_polymorphic_visitor<Base>       this_type;
+    typedef typename add_pointer<Base>::type    pointer;
+    typedef typename add_reference<Base>::type  reference;
+
+    pointer get(reference operand, boost::true_type) const BOOST_NOEXCEPT
+    {
+        return boost::addressof(operand);
+    }
+
+    template <class T>
+    pointer get(T&, boost::false_type) const BOOST_NOEXCEPT
+    {
+        return static_cast<pointer>(0);
+    }
+
+public: // visitor interfaces
+    typedef pointer result_type;
+
+    template <typename U>
+    pointer operator()(U& operand) const BOOST_NOEXCEPT
+    {
+        typedef typename boost::remove_reference<Base>::type base_t;
+        typedef boost::integral_constant<
+            bool,
+            (
+                boost::is_base_of<base_t, U>::value &&
+                (boost::is_const<base_t>::value || !boost::is_const<U>::value)
+            )
+            || boost::is_same<base_t, U>::value
+            || boost::is_same<typename boost::remove_cv<base_t>::type, U >::value
+        > tag_t;
+
+        return this_type::get(operand, tag_t());
+    }
+};
+
+}} // namespace detail::variant
+
+#ifndef BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE
+#   if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551))
+#       define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t)
+#   else
+#       define BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(t)  \
+        , t* = 0
+#   endif
+#endif
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////
+// polymorphic_relaxed_get
+//
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_pointer<U>::type
+polymorphic_relaxed_get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    ) BOOST_NOEXCEPT
+{
+    typedef typename add_pointer<U>::type U_ptr;
+    if (!operand) return static_cast<U_ptr>(0);
+
+    detail::variant::get_polymorphic_visitor<U> v;
+    return operand->apply_visitor(v);
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_pointer<const U>::type
+polymorphic_relaxed_get(
+      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    ) BOOST_NOEXCEPT
+{
+    typedef typename add_pointer<const U>::type U_ptr;
+    if (!operand) return static_cast<U_ptr>(0);
+
+    detail::variant::get_polymorphic_visitor<const U> v;
+    return operand->apply_visitor(v);
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_reference<U>::type
+polymorphic_relaxed_get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+    typedef typename add_pointer<U>::type U_ptr;
+    U_ptr result = polymorphic_relaxed_get<U>(&operand);
+
+    if (!result)
+        boost::throw_exception(bad_polymorphic_get());
+    return *result;
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_reference<const U>::type
+polymorphic_relaxed_get(
+      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+    typedef typename add_pointer<const U>::type U_ptr;
+    U_ptr result = polymorphic_relaxed_get<const U>(&operand);
+
+    if (!result)
+        boost::throw_exception(bad_polymorphic_get());
+    return *result;
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////////////////////
+// polymorphic_strict_get
+//
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_pointer<U>::type
+polymorphic_strict_get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    ) BOOST_NOEXCEPT
+{
+    BOOST_STATIC_ASSERT_MSG(
+        (boost::detail::variant::holds_element_polymorphic<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >, U >::value),
+        "boost::variant does not contain specified type U, "
+        "call to boost::polymorphic_get<U>(boost::variant<T...>*) will always return NULL"
+    );
+
+    return polymorphic_relaxed_get<U>(operand);
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_pointer<const U>::type
+polymorphic_strict_get(
+      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    ) BOOST_NOEXCEPT
+{
+    BOOST_STATIC_ASSERT_MSG(
+        (boost::detail::variant::holds_element_polymorphic<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >, U >::value),
+        "boost::variant does not contain specified type U, "
+        "call to boost::polymorphic_get<U>(const boost::variant<T...>*) will always return NULL"
+    );
+
+    return polymorphic_relaxed_get<U>(operand);
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_reference<U>::type
+polymorphic_strict_get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+    BOOST_STATIC_ASSERT_MSG(
+        (boost::detail::variant::holds_element_polymorphic<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >, U >::value),
+        "boost::variant does not contain specified type U, "
+        "call to boost::polymorphic_get<U>(boost::variant<T...>&) will always throw boost::bad_polymorphic_get exception"
+    );
+
+    return polymorphic_relaxed_get<U>(operand);
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_reference<const U>::type
+polymorphic_strict_get(
+      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+    BOOST_STATIC_ASSERT_MSG(
+        (boost::detail::variant::holds_element_polymorphic<boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >, U >::value),
+        "boost::variant does not contain specified type U, "
+        "call to boost::polymorphic_get<U>(const boost::variant<T...>&) will always throw boost::bad_polymorphic_get exception"
+    );
+
+    return polymorphic_relaxed_get<U>(operand);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// polymorphic_get<U>(variant) methods
+//
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_pointer<U>::type
+polymorphic_get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    ) BOOST_NOEXCEPT
+{
+#ifdef BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT
+    return polymorphic_relaxed_get<U>(operand);
+#else
+    return polymorphic_strict_get<U>(operand);
+#endif
+
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_pointer<const U>::type
+polymorphic_get(
+      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >* operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    ) BOOST_NOEXCEPT
+{
+#ifdef BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT
+    return polymorphic_relaxed_get<U>(operand);
+#else
+    return polymorphic_strict_get<U>(operand);
+#endif
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_reference<U>::type
+polymorphic_get(
+      boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+#ifdef BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT
+    return polymorphic_relaxed_get<U>(operand);
+#else
+    return polymorphic_strict_get<U>(operand);
+#endif
+}
+
+template <typename U, BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline
+    typename add_reference<const U>::type
+polymorphic_get(
+      const boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >& operand
+      BOOST_VARIANT_AUX_GET_EXPLICIT_TEMPLATE_TYPE(U)
+    )
+{
+#ifdef BOOST_VARIANT_USE_RELAXED_GET_BY_DEFAULT
+    return polymorphic_relaxed_get<U>(operand);
+#else
+    return polymorphic_strict_get<U>(operand);
+#endif
+}
+} // namespace boost
+
+#endif // BOOST_VARIANT_POLYMORPHIC_GET_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/recursive_variant.hpp b/contrib/libboost/boost_1_65_0/boost/variant/recursive_variant.hpp
new file mode 100644
index 00000000000..afba0be6406
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/recursive_variant.hpp
@@ -0,0 +1,209 @@
+//-----------------------------------------------------------------------------
+// boost variant/recursive_variant.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003 Eric Friedman
+// Copyright (c) 2013 Antony Polukhin
+//
+// 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_VARIANT_RECURSIVE_VARIANT_HPP
+#define BOOST_VARIANT_RECURSIVE_VARIANT_HPP
+
+#include <boost/variant/variant_fwd.hpp>
+#include <boost/variant/detail/enable_recursive.hpp>
+#include <boost/variant/detail/substitute_fwd.hpp>
+#include <boost/variant/detail/make_variant_list.hpp>
+#include <boost/variant/detail/over_sequence.hpp>
+
+#include <boost/mpl/aux_/lambda_arity_param.hpp>
+
+#include <boost/mpl/equal.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/protect.hpp>
+#include <boost/mpl/transform.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/repeat.hpp>
+
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/variant/variant.hpp>
+
+namespace boost {
+
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction specialization substitute
+//
+// Handles embedded variant types when substituting for recursive_variant_.
+//
+
+#if !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+template <
+      BOOST_VARIANT_ENUM_PARAMS(typename T)
+    , typename RecursiveVariant
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(typename Arity)
+    >
+struct substitute<
+      ::boost::variant<
+          recursive_flag< T0 >
+        , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T)
+        >
+    , RecursiveVariant
+    , ::boost::recursive_variant_
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(Arity)
+    >
+{
+    typedef ::boost::variant<
+          recursive_flag< T0 >
+        , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T)
+        > type;
+};
+
+template <
+      BOOST_VARIANT_ENUM_PARAMS(typename T)
+    , typename RecursiveVariant
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(typename Arity)
+    >
+struct substitute<
+      ::boost::variant<
+          ::boost::detail::variant::over_sequence< T0 >
+        , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T)
+        >
+    , RecursiveVariant
+    , ::boost::recursive_variant_
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(Arity)
+    >
+{
+private:
+
+    typedef T0 initial_types;
+
+    typedef typename mpl::transform<
+          initial_types
+        , mpl::protect< quoted_enable_recursive<RecursiveVariant,mpl::true_> >
+        >::type types;
+
+public:
+
+    typedef typename mpl::if_<
+          mpl::equal<initial_types, types, ::boost::is_same<mpl::_1, mpl::_2> >
+        , ::boost::variant<
+              ::boost::detail::variant::over_sequence< T0 >
+            , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T)
+            >
+        , ::boost::variant< over_sequence<types> >
+        >::type type;
+};
+
+template <
+      BOOST_VARIANT_ENUM_PARAMS(typename T)
+    , typename RecursiveVariant
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(typename Arity)
+    >
+struct substitute<
+      ::boost::variant< BOOST_VARIANT_ENUM_PARAMS(T) >
+    , RecursiveVariant
+    , ::boost::recursive_variant_
+      BOOST_MPL_AUX_LAMBDA_ARITY_PARAM(Arity)
+    >
+{
+#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+    
+    typedef ::boost::variant<
+        typename enable_recursive<   
+              T0              
+            , RecursiveVariant               
+            , mpl::true_                     
+        >::type,
+        typename enable_recursive<   
+              TN              
+            , RecursiveVariant               
+            , mpl::true_                     
+        >::type...  
+    > type;
+
+#else // defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+
+private: // helpers, for metafunction result (below)
+
+    #define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS(z,N,_)  \
+        typedef typename enable_recursive<   \
+              BOOST_PP_CAT(T,N)              \
+            , RecursiveVariant               \
+            , mpl::true_                     \
+            >::type BOOST_PP_CAT(wknd_T,N);  \
+        /**/
+
+    BOOST_PP_REPEAT(
+          BOOST_VARIANT_LIMIT_TYPES
+        , BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS
+        , _
+        )
+
+    #undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS
+
+public: // metafunction result
+
+    typedef ::boost::variant< BOOST_VARIANT_ENUM_PARAMS(wknd_T) > type;
+#endif // BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES workaround
+};
+
+#else // defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+//
+// no specializations: embedded variants unsupported on these compilers!
+//
+
+#endif // !defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE)
+
+}} // namespace detail::variant
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction make_recursive_variant
+//
+// See docs and boost/variant/variant_fwd.hpp for more information.
+//
+template < BOOST_VARIANT_ENUM_PARAMS(typename T) >
+struct make_recursive_variant
+{
+public: // metafunction result
+
+    typedef boost::variant<
+          detail::variant::recursive_flag< T0 >
+        , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T)
+        > type;
+
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction make_recursive_variant_over
+//
+// See docs and boost/variant/variant_fwd.hpp for more information.
+//
+template <typename Types>
+struct make_recursive_variant_over
+{
+private: // precondition assertions
+
+    BOOST_STATIC_ASSERT(( ::boost::mpl::is_sequence<Types>::value ));
+
+public: // metafunction result
+
+    typedef typename make_recursive_variant<
+          detail::variant::over_sequence< Types >
+        >::type type;
+
+};
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_RECURSIVE_VARIANT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/recursive_wrapper.hpp b/contrib/libboost/boost_1_65_0/boost/variant/recursive_wrapper.hpp
new file mode 100644
index 00000000000..ef32eddc0e7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/recursive_wrapper.hpp
@@ -0,0 +1,158 @@
+//-----------------------------------------------------------------------------
+// boost variant/recursive_wrapper.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-2003
+// Eric Friedman, Itay Maman
+//
+// 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_VARIANT_RECURSIVE_WRAPPER_HPP
+#define BOOST_VARIANT_RECURSIVE_WRAPPER_HPP
+
+#include <boost/variant/recursive_wrapper_fwd.hpp>
+#include <boost/variant/detail/move.hpp>
+#include <boost/checked_delete.hpp>
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// class template recursive_wrapper
+//
+// See docs and recursive_wrapper_fwd.hpp for more information.
+//
+
+template <typename T>
+class recursive_wrapper
+{
+public: // typedefs
+
+    typedef T type;
+
+private: // representation
+
+    T* p_;
+
+public: // structors
+
+    ~recursive_wrapper();
+    recursive_wrapper();
+
+    recursive_wrapper(const recursive_wrapper& operand);
+    recursive_wrapper(const T& operand);
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES 
+    recursive_wrapper(recursive_wrapper&& operand);
+    recursive_wrapper(T&& operand);
+#endif
+
+private: // helpers, for modifiers (below)
+
+    void assign(const T& rhs);
+
+public: // modifiers
+
+    recursive_wrapper& operator=(const recursive_wrapper& rhs)
+    {
+        assign( rhs.get() );
+        return *this;
+    }
+
+    recursive_wrapper& operator=(const T& rhs)
+    {
+        assign( rhs );
+        return *this;
+    }
+
+    void swap(recursive_wrapper& operand) BOOST_NOEXCEPT
+    {
+        T* temp = operand.p_;
+        operand.p_ = p_;
+        p_ = temp;
+    }
+
+    
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES 
+    recursive_wrapper& operator=(recursive_wrapper&& rhs) BOOST_NOEXCEPT
+    {
+        swap(rhs);
+        return *this;
+    }
+
+    recursive_wrapper& operator=(T&& rhs)
+    {
+        get() = detail::variant::move(rhs);
+        return *this;
+    }
+#endif
+
+public: // queries
+
+    T& get() { return *get_pointer(); }
+    const T& get() const { return *get_pointer(); }
+
+    T* get_pointer() { return p_; }
+    const T* get_pointer() const { return p_; }
+
+};
+
+template <typename T>
+recursive_wrapper<T>::~recursive_wrapper()
+{
+    boost::checked_delete(p_);
+}
+
+template <typename T>
+recursive_wrapper<T>::recursive_wrapper()
+    : p_(new T)
+{
+}
+
+template <typename T>
+recursive_wrapper<T>::recursive_wrapper(const recursive_wrapper& operand)
+    : p_(new T( operand.get() ))
+{
+}
+
+template <typename T>
+recursive_wrapper<T>::recursive_wrapper(const T& operand)
+    : p_(new T(operand))
+{
+}
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES 
+template <typename T>
+recursive_wrapper<T>::recursive_wrapper(recursive_wrapper&& operand)
+    : p_(new T( detail::variant::move(operand.get()) ))
+{
+}
+
+template <typename T>
+recursive_wrapper<T>::recursive_wrapper(T&& operand)
+    : p_(new T( detail::variant::move(operand) ))
+{
+}
+#endif
+
+template <typename T>
+void recursive_wrapper<T>::assign(const T& rhs)
+{
+    this->get() = rhs;
+}
+
+// function template swap
+//
+// Swaps two recursive_wrapper<T> objects of the same type T.
+//
+template <typename T>
+inline void swap(recursive_wrapper<T>& lhs, recursive_wrapper<T>& rhs) BOOST_NOEXCEPT
+{
+    lhs.swap(rhs);
+}
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_RECURSIVE_WRAPPER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/recursive_wrapper_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/variant/recursive_wrapper_fwd.hpp
new file mode 100644
index 00000000000..c40399f289d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/recursive_wrapper_fwd.hpp
@@ -0,0 +1,130 @@
+//-----------------------------------------------------------------------------
+// boost variant/recursive_wrapper_fwd.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002 Eric Friedman, Itay Maman
+// Copyright (c) 2016-2017 Antony Polukhin
+//
+// Portions Copyright (C) 2002 David Abrahams
+//
+// 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_VARIANT_RECURSIVE_WRAPPER_FWD_HPP
+#define BOOST_VARIANT_RECURSIVE_WRAPPER_FWD_HPP
+
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/aux_/config/ctps.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/type_traits/is_constructible.hpp>
+#include <boost/type_traits/is_nothrow_move_constructible.hpp>
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// class template recursive_wrapper
+//
+// Enables recursive types in templates by breaking cyclic dependencies.
+//
+// For example:
+//
+//   class my;
+//
+//   typedef variant< int, recursive_wrapper<my> > var;
+//
+//   class my {
+//     var var_;
+//     ...
+//   };
+//
+template <typename T> class recursive_wrapper;
+
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction is_constructible partial specializations.
+//
+// recursive_wrapper<T> is constructible only from T and recursive_wrapper<T>.
+//
+template <class T>          struct is_constructible<recursive_wrapper<T>, T>                            : boost::true_type{};
+template <class T>          struct is_constructible<recursive_wrapper<T>, const T>                      : boost::true_type{};
+template <class T>          struct is_constructible<recursive_wrapper<T>, T&>                           : boost::true_type{};
+template <class T>          struct is_constructible<recursive_wrapper<T>, const T&>                     : boost::true_type{};
+template <class T>          struct is_constructible<recursive_wrapper<T>, recursive_wrapper<T> >        : boost::true_type{};
+template <class T>          struct is_constructible<recursive_wrapper<T>, const recursive_wrapper<T> >  : boost::true_type{};
+template <class T>          struct is_constructible<recursive_wrapper<T>, recursive_wrapper<T>& >       : boost::true_type{};
+template <class T>          struct is_constructible<recursive_wrapper<T>, const recursive_wrapper<T>& > : boost::true_type{};
+
+template <class T, class U> struct is_constructible<recursive_wrapper<T>, U >                           : boost::false_type{};
+template <class T, class U> struct is_constructible<recursive_wrapper<T>, const U >                     : boost::false_type{};
+template <class T, class U> struct is_constructible<recursive_wrapper<T>, U& >                          : boost::false_type{};
+template <class T, class U> struct is_constructible<recursive_wrapper<T>, const U& >                    : boost::false_type{};
+template <class T, class U> struct is_constructible<recursive_wrapper<T>, recursive_wrapper<U> >        : boost::false_type{};
+template <class T, class U> struct is_constructible<recursive_wrapper<T>, const recursive_wrapper<U> >  : boost::false_type{};
+template <class T, class U> struct is_constructible<recursive_wrapper<T>, recursive_wrapper<U>& >       : boost::false_type{};
+template <class T, class U> struct is_constructible<recursive_wrapper<T>, const recursive_wrapper<U>& > : boost::false_type{};
+
+// recursive_wrapper is not nothrow move constructible, because it's constructor does dynamic memory allocation.
+// This specialisation is required to workaround GCC6 issue: https://svn.boost.org/trac/boost/ticket/12680
+template <class T> struct is_nothrow_move_constructible<recursive_wrapper<T> > : boost::false_type{};
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction is_recursive_wrapper (modeled on code by David Abrahams)
+//
+// True if specified type matches recursive_wrapper<T>.
+//
+
+namespace detail {
+
+
+template <typename T>
+struct is_recursive_wrapper_impl
+    : mpl::false_
+{
+};
+
+template <typename T>
+struct is_recursive_wrapper_impl< recursive_wrapper<T> >
+    : mpl::true_
+{
+};
+
+
+} // namespace detail
+
+template< typename T > struct is_recursive_wrapper
+    : public ::boost::integral_constant<bool,(::boost::detail::is_recursive_wrapper_impl<T>::value)>
+{
+public:
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_recursive_wrapper,(T))
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction unwrap_recursive
+//
+// If specified type T matches recursive_wrapper<U>, then U; else T.
+//
+
+
+template <typename T>
+struct unwrap_recursive
+{
+    typedef T type;
+
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,unwrap_recursive,(T))
+};
+
+template <typename T>
+struct unwrap_recursive< recursive_wrapper<T> >
+{
+    typedef T type;
+
+    BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,unwrap_recursive,(T))
+};
+
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_RECURSIVE_WRAPPER_FWD_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/static_visitor.hpp b/contrib/libboost/boost_1_65_0/boost/variant/static_visitor.hpp
new file mode 100644
index 00000000000..d1fc47e2725
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/static_visitor.hpp
@@ -0,0 +1,95 @@
+//-----------------------------------------------------------------------------
+// boost variant/static_visitor.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-2003
+// Eric Friedman
+//
+// 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_VARIANT_STATIC_VISITOR_HPP
+#define BOOST_VARIANT_STATIC_VISITOR_HPP
+
+#include <boost/config.hpp>
+#include <boost/detail/workaround.hpp>
+
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_base_and_derived.hpp>
+
+#include <boost/type_traits/integral_constant.hpp>
+#include <boost/mpl/aux_/lambda_support.hpp>
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// class template static_visitor
+//
+// An empty base class that typedefs the return type of a deriving static
+// visitor. The class is analogous to std::unary_function in this role.
+//
+
+namespace detail {
+
+    struct is_static_visitor_tag { };
+
+    typedef void static_visitor_default_return;
+
+} // namespace detail
+
+template <typename R = ::boost::detail::static_visitor_default_return>
+class static_visitor
+    : public detail::is_static_visitor_tag
+{
+public: // typedefs
+
+    typedef R result_type;
+
+protected: // for use as base class only
+#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS)
+    static_visitor() = default;
+    ~static_visitor() = default;
+#else
+    static_visitor()  BOOST_NOEXCEPT { }
+    ~static_visitor()  BOOST_NOEXCEPT { }
+#endif
+};
+
+//////////////////////////////////////////////////////////////////////////
+// metafunction is_static_visitor
+//
+// Value metafunction indicates whether the specified type derives from
+// static_visitor<...>.
+//
+// NOTE #1: This metafunction does NOT check whether the specified type
+//  fulfills the requirements of the StaticVisitor concept.
+//
+// NOTE #2: This template never needs to be specialized!
+//
+
+namespace detail {
+
+template <typename T>
+struct is_static_visitor_impl
+{
+    BOOST_STATIC_CONSTANT(bool, value = 
+        (::boost::is_base_and_derived< 
+            detail::is_static_visitor_tag,
+            T
+        >::value));
+};
+
+} // namespace detail
+
+template< typename T > struct is_static_visitor
+	: public ::boost::integral_constant<bool,(::boost::detail::is_static_visitor_impl<T>::value)>
+{
+public:
+    BOOST_MPL_AUX_LAMBDA_SUPPORT(1,is_static_visitor,(T))
+};
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_STATIC_VISITOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/variant.hpp b/contrib/libboost/boost_1_65_0/boost/variant/variant.hpp
new file mode 100644
index 00000000000..c3e2ccf8e53
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/variant.hpp
@@ -0,0 +1,2493 @@
+//-----------------------------------------------------------------------------
+// boost variant/variant.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-2003 Eric Friedman, Itay Maman
+// Copyright (c) 2012-2016 Antony Polukhin
+//
+// 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)
+
+// Thanks to Adam Romanek for providing patches for exception-disabled env.
+
+#ifndef BOOST_VARIANT_VARIANT_HPP
+#define BOOST_VARIANT_VARIANT_HPP
+
+#include <cstddef> // for std::size_t
+#include <new> // for placement new
+
+#include <boost/type_index.hpp>
+
+#include <boost/variant/detail/config.hpp>
+#include <boost/mpl/aux_/value_wknd.hpp>
+
+#include <boost/variant/variant_fwd.hpp>
+#include <boost/variant/detail/backup_holder.hpp>
+#include <boost/variant/detail/enable_recursive_fwd.hpp>
+#include <boost/variant/detail/forced_return.hpp>
+#include <boost/variant/detail/initializer.hpp>
+#include <boost/variant/detail/make_variant_list.hpp>
+#include <boost/variant/detail/over_sequence.hpp>
+#include <boost/variant/detail/visitation_impl.hpp>
+#include <boost/variant/detail/hash_variant.hpp>
+
+#include <boost/variant/detail/generic_result_type.hpp>
+#include <boost/variant/detail/move.hpp>
+
+#include <boost/detail/no_exceptions_support.hpp>
+#include <boost/detail/reference_content.hpp>
+#include <boost/aligned_storage.hpp>
+#include <boost/blank.hpp>
+#include <boost/math/common_factor_ct.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/repeat.hpp>
+#include <boost/type_traits/alignment_of.hpp>
+#include <boost/type_traits/add_const.hpp>
+#include <boost/type_traits/has_nothrow_constructor.hpp>
+#include <boost/type_traits/has_nothrow_copy.hpp>
+#include <boost/type_traits/is_nothrow_move_assignable.hpp>
+#include <boost/type_traits/is_nothrow_move_constructible.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/is_rvalue_reference.hpp>
+#include <boost/type_traits/is_constructible.hpp>
+#include <boost/type_traits/add_lvalue_reference.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/utility/declval.hpp>
+#include <boost/variant/recursive_wrapper_fwd.hpp>
+#include <boost/variant/static_visitor.hpp>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/begin_end.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/deref.hpp>
+#include <boost/mpl/empty.hpp>
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/find_if.hpp>
+#include <boost/mpl/fold.hpp>
+#include <boost/mpl/front.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/insert_range.hpp>
+#include <boost/mpl/int.hpp>
+#include <boost/mpl/is_sequence.hpp>
+#include <boost/mpl/iterator_range.hpp>
+#include <boost/mpl/iter_fold_if.hpp>
+#include <boost/mpl/list.hpp>
+#include <boost/mpl/logical.hpp>
+#include <boost/mpl/max_element.hpp>
+#include <boost/mpl/next.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/mpl/pair.hpp>
+#include <boost/mpl/protect.hpp>
+#include <boost/mpl/push_front.hpp>
+#include <boost/mpl/same_as.hpp>
+#include <boost/mpl/size_t.hpp>
+#include <boost/mpl/sizeof.hpp>
+#include <boost/mpl/transform.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+// Implementation Macros:
+//
+// BOOST_VARIANT_VISITATION_UNROLLING_LIMIT
+//   Defined in boost/variant/detail/visitation_impl.hpp.
+//
+// BOOST_VARIANT_MINIMIZE_SIZE
+//   When #defined, implementation employs all known means to minimize the
+//   size of variant obje   cts. However, often unsuccessful due to alignment
+//   issues, and potentially harmful to runtime speed, so not enabled by
+//   default. (TODO: Investigate further.)
+
+#if defined(BOOST_VARIANT_MINIMIZE_SIZE)
+#   include <climits> // for SCHAR_MAX
+#   include <boost/mpl/eval_if.hpp>
+#   include <boost/mpl/equal_to.hpp>
+#   include <boost/mpl/identity.hpp>
+#   include <boost/mpl/int.hpp>
+#   include <boost/mpl/if.hpp>
+#   include <boost/mpl/less.hpp>
+#   include <boost/mpl/long.hpp>
+#   include <boost/mpl/O1_size.hpp>
+#endif
+
+
+namespace boost {
+
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction max_value
+//
+// Finds the maximum value of the unary metafunction F over Sequence.
+//
+template <typename Sequence, typename F>
+struct max_value
+{
+private: // helpers, for metafunction result (below)
+
+    typedef typename mpl::transform1<Sequence, F>::type transformed_;
+    typedef typename mpl::max_element<transformed_
+          
+        >::type max_it;
+
+public: // metafunction result
+
+    typedef typename mpl::deref<max_it>::type
+        type;
+
+};
+
+struct add_alignment
+{
+    template <typename State, typename Item>
+    struct apply
+        : mpl::size_t<
+              ::boost::math::static_lcm<
+                  BOOST_MPL_AUX_VALUE_WKND(State)::value
+                , ::boost::alignment_of<Item>::value
+                >::value
+            >
+    {};
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction find_fallback_type
+//
+// Provides a fallback (i.e., nothrow default-constructible) type from the
+// specified sequence, or no_fallback_type if not found.
+//
+// This implementation is designed to prefer boost::blank over other potential
+// fallback types, regardless of its position in the specified sequence.
+//
+
+class no_fallback_type;
+
+struct find_fallback_type_pred
+{
+    template <typename Iterator>
+    struct apply
+    {
+    private:
+        typedef typename mpl::deref<Iterator>::type t_;
+
+    public:
+        typedef mpl::not_< has_nothrow_constructor<t_> > type;
+    };
+};
+
+template <typename Types>
+struct find_fallback_type
+{
+private: // helpers, for metafunction result (below)
+
+    typedef typename mpl::end<Types>::type end_it;
+
+    // [Find the first suitable fallback type...]
+
+    typedef typename mpl::iter_fold_if<
+          Types
+        , mpl::int_<0>, mpl::protect< mpl::next<> >
+        , mpl::protect< find_fallback_type_pred >
+        >::type first_result_;
+
+    typedef typename first_result_::first first_result_index;
+    typedef typename first_result_::second first_result_it;
+
+    // [...now search the rest of the sequence for boost::blank...]
+
+    typedef typename mpl::iter_fold_if<
+          mpl::iterator_range< first_result_it,end_it >
+        , first_result_index, mpl::protect< mpl::next<> >
+        , mpl::protect< mpl::not_same_as<boost::blank> >
+        >::type second_result_;
+
+    typedef typename second_result_::second second_result_it;
+
+public: // metafunction result
+
+    // [...and return the results of the search:]
+    typedef typename mpl::eval_if<
+          is_same< second_result_it,end_it >
+        , mpl::if_<
+              is_same< first_result_it,end_it >
+            , mpl::pair< no_fallback_type,no_fallback_type >
+            , first_result_
+            >
+        , mpl::identity< second_result_ >
+        >::type type;
+
+};
+
+#ifndef BOOST_NO_CXX11_NOEXCEPT
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction is_variant_move_noexcept_constructible
+//
+// Returns true_type if all the types are nothrow move constructible.
+//
+template <class Types>
+struct is_variant_move_noexcept_constructible {
+    typedef typename boost::mpl::find_if<
+        Types, mpl::not_<boost::is_nothrow_move_constructible<boost::mpl::_1> >
+    >::type iterator_t;
+
+    typedef typename boost::mpl::end<Types>::type end_t;
+    typedef typename boost::is_same<
+        iterator_t, end_t
+    >::type type;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction is_variant_move_noexcept_assignable
+//
+// Returns true_type if all the types are nothrow move constructible.
+//
+template <class Types>
+struct is_variant_move_noexcept_assignable {
+    typedef typename boost::mpl::find_if<
+        Types, mpl::not_<boost::is_nothrow_move_assignable<boost::mpl::_1> >
+    >::type iterator_t;
+
+    typedef typename boost::mpl::end<Types>::type end_t;
+    typedef typename boost::is_same<
+        iterator_t, end_t
+    >::type type;
+};
+#endif // BOOST_NO_CXX11_NOEXCEPT
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction is_variant_constructible_from
+//
+// Derives from true_type if at least one variant's type is constructible from T.
+//
+template <class T1, class T2>
+struct is_constructible_ext:
+    boost::mpl::or_<
+        boost::is_constructible<
+            T1,
+            T2
+        >,
+        boost::is_constructible<
+            T1,
+            typename boost::add_lvalue_reference<T2>::type
+        >
+    >
+{};
+
+template <class T, class Types>
+struct is_variant_constructible_from:
+    boost::mpl::not_< boost::is_same<
+        typename boost::mpl::find_if<
+            Types,
+            is_constructible_ext<boost::mpl::_1, T>
+        >::type,
+        typename boost::mpl::end<Types>::type
+    > >
+{};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), class Types>
+struct is_variant_constructible_from< boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Types >:
+    boost::is_same<
+        typename boost::mpl::find_if<
+            typename boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::recursive_enabled_types,
+            mpl::not_< is_variant_constructible_from< boost::mpl::_1, Types> >
+        >::type,
+        typename boost::mpl::end< typename boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>::recursive_enabled_types >::type
+    >
+{};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), class Types>
+struct is_variant_constructible_from< const boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>& , Types >:
+    is_variant_constructible_from<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Types >
+{};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), class Types>
+struct is_variant_constructible_from< boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>& , Types >:
+    is_variant_constructible_from<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Types >
+{};
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), class Types>
+struct is_variant_constructible_from< boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>&& , Types >:
+    is_variant_constructible_from<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Types >
+{};
+
+template <BOOST_VARIANT_ENUM_PARAMS(typename T), class Types>
+struct is_variant_constructible_from< boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)> const && , Types >:
+    is_variant_constructible_from<boost::variant<BOOST_VARIANT_ENUM_PARAMS(T)>, Types >
+{};
+
+#endif // #ifndef BOOST_NO_CXX11_RVALUE_REFERENCE
+
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) metafunction make_storage
+//
+// Provides an aligned storage type capable of holding any of the types
+// specified in the given type-sequence.
+//
+
+template <typename Types, typename NeverUsesBackupFlag>
+struct make_storage
+{
+private: // helpers, for metafunction result (below)
+
+    typedef typename mpl::eval_if<
+          NeverUsesBackupFlag
+        , mpl::identity< Types >
+        , mpl::push_front<
+              Types, backup_holder<void*>
+            >
+        >::type types;
+
+    typedef typename max_value<
+          types, mpl::sizeof_<mpl::_1>
+        >::type max_size;
+
+#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551))
+
+    typedef typename mpl::fold<
+          types
+        , mpl::size_t<1>
+        , add_alignment
+        >::type max_alignment;
+
+#else // borland
+
+    // temporary workaround -- use maximal alignment
+    typedef mpl::size_t< -1 > max_alignment;
+
+#endif // borland workaround
+
+public: // metafunction result
+
+    typedef ::boost::aligned_storage<
+          BOOST_MPL_AUX_VALUE_WKND(max_size)::value
+        , BOOST_MPL_AUX_VALUE_WKND(max_alignment)::value
+        > type;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class destroyer
+//
+// Internal visitor that destroys the value it visits.
+//
+struct destroyer
+    : public static_visitor<>
+{
+public: // visitor interfaces
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(T& operand, int) const BOOST_NOEXCEPT
+    {
+        operand.~T(); // must be noexcept
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0551)) || \
+    BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600))
+        (void)operand; // suppresses warnings
+#endif
+
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class template known_get
+//
+// Visitor that returns a reference to content of the specified type.
+//
+// Precondition: visited variant MUST contain logical content of type T.
+//
+template <typename T>
+class known_get
+    : public static_visitor<T&>
+{
+
+public: // visitor interface
+
+    T& operator()(T& operand) const BOOST_NOEXCEPT
+    {
+        return operand;
+    }
+
+    template <typename U>
+    T& operator()(U&) const
+    {
+        // logical error to be here: see precondition above
+        return ::boost::detail::variant::forced_return< T& >();
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class copy_into
+//
+// Internal visitor that copies the value it visits into the given buffer.
+//
+class copy_into
+    : public static_visitor<>
+{
+private: // representation
+
+    void* storage_;
+
+public: // structors
+
+    explicit copy_into(void* storage) BOOST_NOEXCEPT
+        : storage_(storage)
+    {
+    }
+
+public: // internal visitor interface
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(boost::detail::variant::backup_holder<T>& operand, long) const
+    {
+        new(storage_) T( operand.get() );
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(const boost::detail::variant::backup_holder<T>& operand, long) const
+    {
+        new(storage_) T( operand.get() );
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(const T& operand, int) const
+    {
+        new(storage_) T(operand);
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class move_into
+//
+// Internal visitor that moves the value it visits into the given buffer.
+//
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+class move_into
+    : public static_visitor<>
+{
+private: // representation
+
+    void* storage_;
+
+public: // structors
+
+    explicit move_into(void* storage) BOOST_NOEXCEPT
+        : storage_(storage)
+    {
+    }
+
+public: // internal visitor interface
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(boost::detail::variant::backup_holder<T>& operand, long) const
+    {
+        new(storage_) T( ::boost::detail::variant::move(operand.get()) );
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(T& operand, int) const BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(T(boost::declval<T>())))
+    {
+        new(storage_) T(::boost::detail::variant::move(operand));
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+};
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class assign_storage
+//
+// Internal visitor that assigns the given storage (which must be a
+// constructed value of the same type) to the value it visits.
+//
+struct assign_storage
+    : public static_visitor<>
+{
+private: // representation
+
+    const void* rhs_storage_;
+
+public: // structors
+
+    explicit assign_storage(const void* rhs_storage) BOOST_NOEXCEPT
+        : rhs_storage_(rhs_storage)
+    {
+    }
+
+public: // internal visitor interfaces
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(backup_holder<T>& lhs_content, long) const
+    {
+        lhs_content.get()
+            = static_cast< const backup_holder<T>* >(rhs_storage_)->get();
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(const backup_holder<T>& lhs_content, long) const
+    {
+        lhs_content.get()
+            = static_cast< const backup_holder<T>* >(rhs_storage_)->get();
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(T& lhs_content, int) const
+    {
+        // NOTE TO USER :
+        // Compile error here indicates one of variant's bounded types does
+        // not meet the requirements of the Assignable concept. Thus,
+        // variant is not Assignable.
+        //
+        // Hint: Are any of the bounded types const-qualified or references?
+        //
+        lhs_content = *static_cast< const T* >(rhs_storage_);
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class move_storage
+//
+// Internal visitor that moves the given storage (which must be a
+// constructed value of the same type) to the value it visits.
+//
+struct move_storage
+    : public static_visitor<>
+{
+private: // representation
+
+    void* rhs_storage_;
+
+public: // structors
+
+    explicit move_storage(void* rhs_storage) BOOST_NOEXCEPT
+        : rhs_storage_(rhs_storage)
+    {
+    }
+
+public: // internal visitor interfaces
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(backup_holder<T>& lhs_content, long) const
+    {
+        lhs_content.get()
+            = ::boost::detail::variant::move(static_cast<backup_holder<T>* >(rhs_storage_)->get());
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(const backup_holder<T>& lhs_content, long) const
+    {
+        lhs_content.get()
+            = ::boost::detail::variant::move(static_cast<backup_holder<T>* >(rhs_storage_)->get());
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(T& lhs_content, int) const
+    {
+        // NOTE TO USER :
+        // Compile error here indicates one of variant's bounded types does
+        // not meet the requirements of the Assignable concept. Thus,
+        // variant is not Assignable.
+        //
+        // Hint: Are any of the bounded types const-qualified or references?
+        //
+        lhs_content = ::boost::detail::variant::move(*static_cast<T* >(rhs_storage_));
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class direct_assigner
+//
+// Generic static visitor that: if and only if the visited value is of the
+// specified type, assigns the given value to the visited value and returns
+// true; else returns false.
+//
+template <typename T>
+class direct_assigner
+    : public static_visitor<bool>
+{
+private: // representation
+
+    const T& rhs_;
+
+public: // structors
+
+    explicit direct_assigner(const T& rhs) BOOST_NOEXCEPT
+        : rhs_(rhs)
+    {
+    }
+
+public: // visitor interface
+
+    bool operator()(T& lhs)
+    {
+        lhs = rhs_;
+        return true;
+    }
+
+    template <typename U>
+    bool operator()(U&) BOOST_NOEXCEPT
+    {
+        return false;
+    }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600))
+private:
+    // silence MSVC warning C4512: assignment operator could not be generated
+    direct_assigner& operator= (direct_assigner const&);
+#endif
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class direct_mover
+//
+// Generic static visitor that: if and only if the visited value is of the
+// specified type, move assigns the given value to the visited value and returns
+// true; else returns false.
+//
+template <typename T>
+class direct_mover
+    : public static_visitor<bool>
+{
+private: // representation
+
+    T& rhs_;
+
+public: // structors
+
+    explicit direct_mover(T& rhs) BOOST_NOEXCEPT
+        : rhs_(rhs)
+    {
+    }
+
+public: // visitor interface
+
+    bool operator()(T& lhs)
+    {
+        lhs = ::boost::detail::variant::move(rhs_);
+        return true;
+    }
+
+    template <typename U>
+    bool operator()(U&) BOOST_NOEXCEPT
+    {
+        return false;
+    }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600))
+private:
+    // silence MSVC warning C4512: assignment operator could not be generated
+    direct_mover& operator= (direct_mover const&);
+#endif
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class backup_assigner
+//
+// Internal visitor that "assigns" the given value to the visited value,
+// using backup to recover if the destroy-copy sequence fails.
+//
+// NOTE: This needs to be a friend of variant, as it needs access to
+// indicate_which, indicate_backup_which, etc.
+//
+template <typename Variant>
+class backup_assigner
+    : public static_visitor<>
+{
+private: // representation
+
+    Variant& lhs_;
+    int rhs_which_;
+    const void* rhs_content_;
+    void (*copy_rhs_content_)(void*, const void*);
+
+public: // structors
+
+    template<class RhsT>
+    backup_assigner(Variant& lhs, int rhs_which, const RhsT& rhs_content)
+        : lhs_(lhs)
+        , rhs_which_(rhs_which)
+        , rhs_content_(&rhs_content)
+        , copy_rhs_content_(&construct_impl<RhsT>)
+    {
+    }
+
+private: // helpers, for visitor interface (below)
+
+    template<class RhsT>
+    static void construct_impl(void* addr, const void* obj)
+    {
+        new(addr) RhsT(*static_cast<const RhsT*>(obj));
+    }
+
+    template <typename LhsT>
+    void backup_assign_impl(
+          backup_holder<LhsT>& lhs_content
+        , mpl::false_ // is_nothrow_move_constructible
+        , long
+        )
+    {
+        // Move lhs content to backup...
+        backup_holder<LhsT> backup_lhs_content(0);
+        backup_lhs_content.swap(lhs_content); // nothrow
+
+        // ...destroy lhs content...
+        lhs_content.~backup_holder<LhsT>(); // nothrow
+
+        BOOST_TRY
+        {
+            // ...and attempt to copy rhs content into lhs storage:
+            copy_rhs_content_(lhs_.storage_.address(), rhs_content_);
+        }
+        BOOST_CATCH (...)
+        {
+            // In case of failure, copy backup pointer to lhs storage...
+            new(lhs_.storage_.address())
+                    backup_holder<LhsT>( 0 ); // nothrow
+
+            static_cast<backup_holder<LhsT>* >(lhs_.storage_.address())
+                    ->swap(backup_lhs_content); // nothrow
+
+            // ...and rethrow:
+            BOOST_RETHROW;
+        }
+        BOOST_CATCH_END
+
+        // In case of success, indicate new content type:
+        lhs_.indicate_which(rhs_which_); // nothrow
+    }
+
+    template <typename LhsT>
+    void backup_assign_impl(
+          LhsT& lhs_content
+        , mpl::true_ // is_nothrow_move_constructible
+        , int
+        )
+    {
+        // Move lhs content to backup...
+        LhsT backup_lhs_content(
+              ::boost::detail::variant::move(lhs_content)
+            ); // nothrow
+
+        // ...destroy lhs content...
+        lhs_content.~LhsT(); // nothrow
+
+        BOOST_TRY
+        {
+            // ...and attempt to copy rhs content into lhs storage:
+            copy_rhs_content_(lhs_.storage_.address(), rhs_content_);
+        }
+        BOOST_CATCH (...)
+        {
+            // In case of failure, restore backup content to lhs storage...
+            new(lhs_.storage_.address())
+                LhsT(
+                      ::boost::detail::variant::move(backup_lhs_content)
+                    ); // nothrow
+
+            // ...and rethrow:
+            BOOST_RETHROW;
+        }
+        BOOST_CATCH_END
+
+        // In case of success, indicate new content type:
+        lhs_.indicate_which(rhs_which_); // nothrow
+    }
+
+    template <typename LhsT>
+    void backup_assign_impl(
+          LhsT& lhs_content
+        , mpl::false_ // is_nothrow_move_constructible
+        , int
+        )
+    {
+        // Backup lhs content...
+        LhsT* backup_lhs_ptr = new LhsT(lhs_content);
+
+        // ...destroy lhs content...
+        lhs_content.~LhsT(); // nothrow
+
+        BOOST_TRY
+        {
+            // ...and attempt to copy rhs content into lhs storage:
+            copy_rhs_content_(lhs_.storage_.address(), rhs_content_);
+        }
+        BOOST_CATCH (...)
+        {
+            // In case of failure, copy backup pointer to lhs storage...
+            new(lhs_.storage_.address())
+                backup_holder<LhsT>( backup_lhs_ptr ); // nothrow
+
+            // ...indicate now using backup...
+            lhs_.indicate_backup_which( lhs_.which() ); // nothrow
+
+            // ...and rethrow:
+            BOOST_RETHROW;
+        }
+        BOOST_CATCH_END
+
+        // In case of success, indicate new content type...
+        lhs_.indicate_which(rhs_which_); // nothrow
+
+        // ...and delete backup:
+        delete backup_lhs_ptr; // nothrow
+    }
+
+public: // visitor interface
+
+    template <typename LhsT>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    internal_visit(LhsT& lhs_content, int)
+    {
+        typedef typename is_nothrow_move_constructible<LhsT>::type
+            nothrow_move;
+
+        backup_assign_impl( lhs_content, nothrow_move(), 1L);
+
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600))
+private:
+    // silence MSVC warning C4512: assignment operator could not be generated
+    backup_assigner& operator= (backup_assigner const&);
+#endif
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class swap_with
+//
+// Visitor that swaps visited value with content of given variant.
+//
+// Precondition: Given variant MUST have same logical type as visited value.
+//
+template <typename Variant>
+struct swap_with
+    : public static_visitor<>
+{
+private: // representation
+
+    Variant& toswap_;
+
+public: // structors
+
+    explicit swap_with(Variant& toswap) BOOST_NOEXCEPT
+        : toswap_(toswap)
+    {
+    }
+
+public: // internal visitor interfaces
+
+    template <typename T>
+    void operator()(T& operand) const
+    {
+        // Since the precondition ensures types are same, get T...
+        known_get<T> getter;
+        T& other = toswap_.apply_visitor(getter);
+
+        // ...and swap:
+        ::boost::detail::variant::move_swap( operand, other );
+    }
+
+private:
+    swap_with& operator=(const swap_with&);
+
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class reflect
+//
+// Generic static visitor that performs a typeid on the value it visits.
+//
+
+class reflect
+    : public static_visitor<const boost::typeindex::type_info&>
+{
+public: // visitor interfaces
+
+    template <typename T>
+    const boost::typeindex::type_info& operator()(const T&) const BOOST_NOEXCEPT
+    {
+        return boost::typeindex::type_id<T>().type_info();
+    }
+
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class comparer
+//
+// Generic static visitor that compares the content of the given lhs variant
+// with the visited rhs content using Comp.
+//
+// Precondition: lhs.which() == rhs.which()
+//
+template <typename Variant, typename Comp>
+class comparer
+    : public static_visitor<bool>
+{
+private: // representation
+
+    const Variant& lhs_;
+
+public: // structors
+
+    explicit comparer(const Variant& lhs) BOOST_NOEXCEPT
+        : lhs_(lhs)
+    {
+    }
+
+public: // visitor interfaces
+
+    template <typename T>
+    bool operator()(T& rhs_content) const
+    {
+        // Since the precondition ensures lhs and rhs types are same, get T...
+        known_get<T> getter;
+        const T& lhs_content = lhs_.apply_visitor(getter);
+
+        // ...and compare lhs and rhs contents:
+        return Comp()(lhs_content, rhs_content);
+    }
+
+private:
+    comparer& operator=(const comparer&);
+
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class equal_comp
+//
+// Generic function object compares lhs with rhs using operator==.
+//
+struct equal_comp
+{
+    template <typename T>
+    bool operator()(const T& lhs, const T& rhs) const
+    {
+        return lhs == rhs;
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class less_comp
+//
+// Generic function object compares lhs with rhs using operator<.
+//
+struct less_comp
+{
+    template <typename T>
+    bool operator()(const T& lhs, const T& rhs) const
+    {
+        return lhs < rhs;
+    }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class template invoke_visitor
+//
+// Internal visitor that invokes the given visitor using:
+//  * for wrappers (e.g., recursive_wrapper), the wrapper's held value.
+//  * for all other values, the value itself.
+//
+template <typename Visitor>
+class invoke_visitor
+{
+private: // representation
+
+    Visitor& visitor_;
+
+public: // visitor typedefs
+
+    typedef typename Visitor::result_type
+        result_type;
+
+public: // structors
+
+    explicit invoke_visitor(Visitor& visitor) BOOST_NOEXCEPT
+        : visitor_(visitor)
+    {
+    }
+
+#if !defined(BOOST_NO_VOID_RETURNS)
+
+public: // internal visitor interfaces
+
+    template <typename T>
+    result_type internal_visit(T& operand, int)
+    {
+        return visitor_(operand);
+    }
+
+#   if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0564))
+    template <typename T>
+    result_type internal_visit(const T& operand, int)
+    {
+        return visitor_(operand);
+    }
+#   endif
+
+#else // defined(BOOST_NO_VOID_RETURNS)
+
+private: // helpers, for internal visitor interfaces (below)
+
+    template <typename T>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    visit_impl(T& operand, mpl::false_)
+    {
+        return visitor_(operand);
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    visit_impl(T& operand, mpl::true_)
+    {
+        visitor_(operand);
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+public: // internal visitor interfaces
+
+    template <typename T>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    internal_visit(T& operand, int)
+    {
+        typedef typename is_same<result_type, void>::type
+            has_void_result_type;
+
+        return visit_impl(operand, has_void_result_type());
+    }
+
+#endif // BOOST_NO_VOID_RETURNS) workaround
+
+public: // internal visitor interfaces, cont.
+
+    template <typename T>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    internal_visit(boost::recursive_wrapper<T>& operand, long)
+    {
+        return internal_visit( operand.get(), 1L );
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    internal_visit(const boost::recursive_wrapper<T>& operand, long)
+    {
+        return internal_visit( operand.get(), 1L );
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    internal_visit(boost::detail::reference_content<T>& operand, long)
+    {
+        return internal_visit( operand.get(), 1L );
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    internal_visit(const boost::detail::reference_content<T>& operand, long)
+    {
+        return internal_visit( operand.get(), 1L );
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    internal_visit(boost::detail::variant::backup_holder<T>& operand, long)
+    {
+        return internal_visit( operand.get(), 1L );
+    }
+
+    template <typename T>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    internal_visit(const boost::detail::variant::backup_holder<T>& operand, long)
+    {
+        return internal_visit( operand.get(), 1L );
+    }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600))
+private:
+    // silence MSVC warning C4512: assignment operator could not be generated
+    invoke_visitor& operator= (invoke_visitor const&);
+#endif
+};
+
+}} // namespace detail::variant
+
+///////////////////////////////////////////////////////////////////////////////
+// class template variant (concept inspired by Andrei Alexandrescu)
+//
+// See docs and boost/variant/variant_fwd.hpp for more information.
+//
+template <
+      typename T0_
+    , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(typename T)
+    >
+class variant
+{
+private: // helpers, for typedefs (below)
+
+    typedef variant wknd_self_t;
+
+    struct is_recursive_
+        : detail::variant::is_recursive_flag<T0_>
+    {
+    };
+
+    typedef typename mpl::eval_if<
+          is_recursive_
+        , T0_
+        , mpl::identity< T0_ >
+        >::type unwrapped_T0_;
+
+    struct is_sequence_based_
+        : detail::variant::is_over_sequence<unwrapped_T0_>
+    {
+    };
+
+#if !defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT)
+
+private: // helpers, for typedefs (below)
+
+    typedef typename mpl::eval_if<
+          is_sequence_based_
+        , unwrapped_T0_ // over_sequence<...>::type
+        , detail::variant::make_variant_list<
+              unwrapped_T0_
+            , BOOST_VARIANT_ENUM_SHIFTED_PARAMS(T)
+            >
+        >::type specified_types;
+
+    BOOST_STATIC_ASSERT((
+          ::boost::mpl::not_< mpl::empty<specified_types> >::value
+        ));
+
+public: // public typedefs
+    typedef typename mpl::eval_if<
+          is_recursive_
+        , mpl::transform<
+              specified_types
+            , mpl::protect<
+                  detail::variant::quoted_enable_recursive<wknd_self_t>
+                >
+            >
+        , mpl::identity< specified_types >
+        >::type recursive_enabled_types;    // used by is_variant_constructible_from<> trait
+
+    typedef typename mpl::transform<
+          recursive_enabled_types
+        , unwrap_recursive<mpl::_1>
+        >::type types;
+
+private: // internal typedefs
+
+    typedef typename mpl::transform<
+          recursive_enabled_types
+        , mpl::protect< detail::make_reference_content<> >
+        >::type internal_types;
+
+    typedef typename mpl::front<
+          internal_types
+        >::type internal_T0;
+
+#else // defined(BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT)
+
+private: // helpers, for typedefs (below)
+
+    typedef unwrapped_T0_ T0;
+
+    #define BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS(z,N,_) \
+        typedef typename mpl::eval_if< \
+              is_recursive_ \
+            , detail::variant::enable_recursive< \
+                  BOOST_PP_CAT(T,N) \
+                , wknd_self_t \
+                > \
+            , mpl::identity< BOOST_PP_CAT(T,N) > \
+            >::type BOOST_PP_CAT(recursive_enabled_T,N); \
+        /**/
+
+    BOOST_PP_REPEAT(
+          BOOST_VARIANT_LIMIT_TYPES
+        , BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS
+        , _
+        )
+
+    #undef BOOST_VARIANT_AUX_ENABLE_RECURSIVE_TYPEDEFS
+
+    #define BOOST_VARIANT_AUX_UNWRAP_RECURSIVE_TYPEDEFS(z,N,_) \
+        typedef typename unwrap_recursive< \
+              BOOST_PP_CAT(recursive_enabled_T,N) \
+            >::type BOOST_PP_CAT(public_T,N); \
+        /**/
+
+    BOOST_PP_REPEAT(
+          BOOST_VARIANT_LIMIT_TYPES
+        , BOOST_VARIANT_AUX_UNWRAP_RECURSIVE_TYPEDEFS
+        , _
+        )
+
+    #undef BOOST_VARIANT_AUX_UNWRAP_RECURSIVE_TYPEDEFS
+
+public: // public typedefs
+
+    typedef typename detail::variant::make_variant_list<
+          BOOST_VARIANT_ENUM_PARAMS(public_T)
+        >::type types;
+
+private: // helpers, for internal typedefs (below)
+
+    #define BOOST_VARIANT_AUX_MAKE_REFERENCE_CONTENT_TYPEDEFS(z,N,_) \
+        typedef detail::make_reference_content< \
+              BOOST_PP_CAT(recursive_enabled_T,N) \
+            >::type BOOST_PP_CAT(internal_T,N); \
+        /**/
+
+    BOOST_PP_REPEAT(
+          BOOST_VARIANT_LIMIT_TYPES
+        , BOOST_VARIANT_AUX_MAKE_REFERENCE_CONTENT_TYPEDEFS
+        , _
+        )
+
+    #undef BOOST_VARIANT_AUX_MAKE_REFERENCE_CONTENT_TYPEDEFS
+
+private: // internal typedefs
+
+    typedef typename detail::variant::make_variant_list<
+          BOOST_VARIANT_ENUM_PARAMS(internal_T)
+        >::type internal_types;
+
+private: // static precondition assertions
+
+    // NOTE TO USER :
+    // variant< type-sequence > syntax is not supported on this compiler!
+    //
+    BOOST_MPL_ASSERT_NOT(( is_sequence_based_ ));
+
+#endif // BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT workaround
+
+private: // helpers, for representation (below)
+
+    typedef typename detail::variant::find_fallback_type<
+          internal_types
+        >::type fallback_type_result_;
+
+    typedef typename fallback_type_result_::first
+        fallback_type_index_;
+    typedef typename fallback_type_result_::second
+        fallback_type_;
+
+    struct has_fallback_type_
+        : mpl::not_<
+              is_same< fallback_type_, detail::variant::no_fallback_type >
+            >
+    {
+    };
+
+    typedef has_fallback_type_
+        never_uses_backup_flag;
+
+    typedef typename detail::variant::make_storage<
+          internal_types, never_uses_backup_flag
+        >::type storage_t;
+
+#ifndef BOOST_NO_CXX11_NOEXCEPT
+    typedef typename detail::variant::is_variant_move_noexcept_constructible<
+        internal_types
+    > variant_move_noexcept_constructible;
+
+    typedef typename detail::variant::is_variant_move_noexcept_assignable<
+        internal_types
+    > variant_move_noexcept_assignable;
+
+#endif
+
+private: // helpers, for representation (below)
+
+    // which_ on:
+    // * [0,  size<internal_types>) indicates stack content
+    // * [-size<internal_types>, 0) indicates pointer to heap backup
+    // if which_ >= 0:
+    // * then which() -> which_
+    // * else which() -> -(which_ + 1)
+
+#if !defined(BOOST_VARIANT_MINIMIZE_SIZE)
+
+    typedef int which_t;
+
+#else // defined(BOOST_VARIANT_MINIMIZE_SIZE)
+
+    // [if O1_size available, then attempt which_t size optimization...]
+    // [select signed char if fewer than SCHAR_MAX types, else signed int:]
+    typedef typename mpl::eval_if<
+          mpl::equal_to< mpl::O1_size<internal_types>, mpl::long_<-1> >
+        , mpl::identity< int >
+        , mpl::if_<
+              mpl::less< mpl::O1_size<internal_types>, mpl::int_<SCHAR_MAX> >
+            , signed char
+            , int
+            >
+        >::type which_t;
+
+#endif // BOOST_VARIANT_MINIMIZE_SIZE switch
+
+// representation -- private when possible
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+    private:
+#else
+    public:
+#endif
+
+    which_t which_;
+    storage_t storage_;
+
+    void indicate_which(int which_arg) BOOST_NOEXCEPT
+    {
+        which_ = static_cast<which_t>( which_arg );
+    }
+
+    void indicate_backup_which(int which_arg) BOOST_NOEXCEPT
+    {
+        which_ = static_cast<which_t>( -(which_arg + 1) );
+    }
+
+private: // helpers, for queries (below)
+
+    bool using_backup() const BOOST_NOEXCEPT
+    {
+        return which_ < 0;
+    }
+
+public: // queries
+
+    int which() const BOOST_NOEXCEPT
+    {
+        // If using heap backup...
+        if (using_backup())
+            // ...then return adjusted which_:
+            return -(which_ + 1);
+
+        // Otherwise, return which_ directly:
+        return which_;
+    }
+
+private: // helpers, for structors (below)
+
+    struct initializer
+        : BOOST_VARIANT_AUX_INITIALIZER_T(
+              recursive_enabled_types, recursive_enabled_T
+            )
+    {
+    };
+
+    void destroy_content() BOOST_NOEXCEPT
+    {
+        detail::variant::destroyer visitor;
+        this->internal_apply_visitor(visitor);
+    }
+
+public: // structors
+
+    ~variant() BOOST_NOEXCEPT
+    {
+        destroy_content();
+    }
+
+    variant() 
+#if !(defined(__SUNPRO_CC) && BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5130))
+              BOOST_NOEXCEPT_IF(boost::has_nothrow_constructor<internal_T0>::value)
+#endif
+    {
+#ifdef _MSC_VER
+#pragma warning( push )
+// behavior change: an object of POD type constructed with an initializer of the form () will be default-initialized 
+#pragma warning( disable : 4345 ) 
+#endif
+        // NOTE TO USER :
+        // Compile error from here indicates that the first bound
+        // type is not default-constructible, and so variant cannot
+        // support its own default-construction.
+        //
+        new( storage_.address() ) internal_T0();
+        indicate_which(0); // zero is the index of the first bounded type
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+    }
+
+private: // helpers, for structors, cont. (below)
+
+    class convert_copy_into
+        : public static_visitor<int>
+    {
+    private: // representation
+
+        void* storage_;
+
+    public: // structors
+
+        explicit convert_copy_into(void* storage) BOOST_NOEXCEPT
+            : storage_(storage)
+        {
+        }
+
+    public: // internal visitor interfaces (below)
+
+        template <typename T>
+        int internal_visit(T& operand, int) const
+        {
+            // NOTE TO USER :
+            // Compile error here indicates one of the source variant's types 
+            // cannot be unambiguously converted to the destination variant's
+            // types (or that no conversion exists).
+            //
+            return initializer::initialize(storage_, operand);
+        }
+
+#   if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x0564))
+        template <typename T>
+        result_type internal_visit(const T& operand, int) const
+        {
+            return initializer::initialize(storage_, operand);
+        }
+#   endif
+
+        template <typename T>
+        int internal_visit(boost::detail::reference_content<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+
+        template <typename T>
+        int internal_visit(const boost::detail::reference_content<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+
+        template <typename T>
+        int internal_visit(boost::detail::variant::backup_holder<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+
+        template <typename T>
+        int internal_visit(const boost::detail::variant::backup_holder<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+
+        template <typename T>
+        int internal_visit(boost::recursive_wrapper<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+
+        template <typename T>
+        int internal_visit(const boost::recursive_wrapper<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+
+    };
+
+    friend class convert_copy_into;
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    class convert_move_into
+        : public static_visitor<int>
+    {
+    private: // representation
+
+        void* storage_;
+
+    public: // structors
+
+        explicit convert_move_into(void* storage) BOOST_NOEXCEPT
+            : storage_(storage)
+        {
+        }
+
+    public: // internal visitor interfaces (below)
+
+        template <typename T>
+        int internal_visit(T& operand, int) const
+        {
+            // NOTE TO USER :
+            // Compile error here indicates one of the source variant's types 
+            // cannot be unambiguously converted to the destination variant's
+            // types (or that no conversion exists).
+            //
+            return initializer::initialize(storage_, detail::variant::move(operand) );
+        }
+
+        template <typename T>
+        int internal_visit(boost::detail::reference_content<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+
+        template <typename T>
+        int internal_visit(const boost::detail::reference_content<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+
+        template <typename T>
+        int internal_visit(boost::detail::variant::backup_holder<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+
+        template <typename T>
+        int internal_visit(const boost::detail::variant::backup_holder<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+
+        template <typename T>
+        int internal_visit(boost::recursive_wrapper<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+
+        template <typename T>
+        int internal_visit(const boost::recursive_wrapper<T>& operand, long) const
+        {
+            return internal_visit( operand.get(), 1L );
+        }
+    };
+
+    friend class convert_move_into;
+#endif
+
+private: // helpers, for structors, below 
+
+    template <typename T>
+    void convert_construct(
+          T& operand
+        , int
+        , mpl::false_ = mpl::false_() // is_foreign_variant
+        )
+    {
+        // NOTE TO USER :
+        // Compile error here indicates that the given type is not 
+        // unambiguously convertible to one of the variant's types
+        // (or that no conversion exists).
+        //
+        indicate_which(
+              initializer::initialize(
+                  storage_.address()
+                , operand
+                )
+            );
+    }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    template <typename T>
+    typename boost::enable_if<boost::is_rvalue_reference<T&&> >::type convert_construct(
+          T&& operand
+        , int
+        , mpl::false_ = mpl::false_() // is_foreign_variant
+        )
+    {
+        // NOTE TO USER :
+        // Compile error here indicates that the given type is not 
+        // unambiguously convertible to one of the variant's types
+        // (or that no conversion exists).
+        //
+        indicate_which(
+              initializer::initialize(
+                  storage_.address()
+                , detail::variant::move(operand)
+                )
+            );
+    }
+#endif
+
+    template <typename Variant>
+    void convert_construct(
+          Variant& operand
+        , long
+        , mpl::true_// is_foreign_variant
+        )
+    {
+        convert_copy_into visitor(storage_.address());
+        indicate_which(
+              operand.internal_apply_visitor(visitor)
+            );
+    }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    template <typename Variant>
+    typename boost::enable_if<boost::is_rvalue_reference<Variant&&> >::type convert_construct(
+          Variant&& operand
+        , long
+        , mpl::true_// is_foreign_variant
+        )
+    {
+        convert_move_into visitor(storage_.address());
+        indicate_which(
+              operand.internal_apply_visitor(visitor)
+            );
+    }
+#endif
+
+    template <typename Variant>
+    void convert_construct_variant(Variant& operand)
+    {
+        // [Determine if the given variant is itself a bounded type, or if its
+        //  content needs to be converted (i.e., it is a 'foreign' variant):]
+        //
+
+        typedef typename mpl::find_if<
+              types
+            , is_same<
+                  add_const<mpl::_1>
+                , const Variant
+                >
+            >::type found_it;
+
+        typedef typename mpl::end<types>::type not_found;
+        typedef typename is_same<
+              found_it, not_found
+            >::type is_foreign_variant;
+
+        // Convert construct from operand:
+        convert_construct(
+              operand, 1L
+            , is_foreign_variant()
+            );
+    }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    template <typename Variant>
+    typename boost::enable_if<boost::is_rvalue_reference<Variant&&> >::type convert_construct_variant(Variant&& operand)
+    {
+        // [Determine if the given variant is itself a bounded type, or if its
+        //  content needs to be converted (i.e., it is a 'foreign' variant):]
+        //
+
+        typedef typename mpl::find_if<
+              types
+            , is_same<
+                  add_const<mpl::_1>
+                , const Variant
+                >
+            >::type found_it;
+
+        typedef typename mpl::end<types>::type not_found;
+        typedef typename is_same<
+              found_it, not_found
+            >::type is_foreign_variant;
+
+        // Convert move construct from operand:
+        convert_construct(
+              detail::variant::move(operand), 1L
+            , is_foreign_variant()
+            );
+    }
+#endif
+
+    template <BOOST_VARIANT_ENUM_PARAMS(typename U)>
+    typename boost::enable_if<mpl::or_<
+        boost::is_same<boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>, variant>,
+        boost::detail::variant::is_variant_constructible_from<boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>&, internal_types>
+    > >::type convert_construct(
+          boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>& operand
+        , long
+        )
+    {
+        convert_construct_variant(operand);
+    }
+
+    template <BOOST_VARIANT_ENUM_PARAMS(typename U)>
+    typename boost::enable_if<mpl::or_<
+        boost::is_same<boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>, variant>,
+        boost::detail::variant::is_variant_constructible_from<const boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>&, internal_types>
+    > >::type convert_construct(
+          const boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>& operand
+        , long
+        )
+    {
+        convert_construct_variant(operand);    
+    }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    template <BOOST_VARIANT_ENUM_PARAMS(typename U)>
+    typename boost::enable_if<mpl::or_<
+        boost::is_same<boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>, variant>,
+        boost::detail::variant::is_variant_constructible_from<boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>&&, internal_types>
+    > >::type convert_construct(
+          boost::variant<BOOST_VARIANT_ENUM_PARAMS(U)>&& operand
+        , long
+        )
+    {
+        convert_construct_variant( detail::variant::move(operand) );    
+    }
+#endif
+
+public: // structors, cont.
+
+    template <typename T>
+    variant(const T& operand,
+        typename boost::enable_if<mpl::or_<
+            mpl::and_<
+                mpl::not_< boost::is_same<T, variant> >,
+                boost::detail::variant::is_variant_constructible_from<const T&, internal_types>
+            >, 
+            boost::is_same<T, boost::recursive_variant_> > >::type* = 0)
+    {
+        convert_construct(operand, 1L);
+    }
+
+    template <typename T>
+    variant(
+          T& operand
+        , typename boost::enable_if<mpl::or_<
+            mpl::and_<
+                mpl::not_< is_const<T> >,
+                mpl::not_< boost::is_same<T, variant> >,
+                boost::detail::variant::is_variant_constructible_from<T&, internal_types>
+            >,
+            boost::is_same<T, boost::recursive_variant_> > >::type* = 0
+        )
+    {
+        convert_construct(operand, 1L);
+    }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    template <class T>
+    variant(T&& operand,
+        typename boost::enable_if<mpl::or_<
+            mpl::and_<
+                boost::is_rvalue_reference<T&&>,
+                mpl::not_< boost::is_const<T> >,
+                mpl::not_< boost::is_same<T, variant> >,
+                boost::detail::variant::is_variant_constructible_from<T&&, internal_types>
+            >,
+            boost::is_same<T, boost::recursive_variant_> > >::type* = 0)
+    {
+        convert_construct( detail::variant::move(operand), 1L);
+    }
+#endif
+
+public: // structors, cont.
+
+    // [MSVC6 requires copy constructor appear after template constructors]
+    variant(const variant& operand)
+    {
+        // Copy the value of operand into *this...
+        detail::variant::copy_into visitor( storage_.address() );
+        operand.internal_apply_visitor(visitor);
+
+        // ...and activate the *this's primary storage on success:
+        indicate_which(operand.which());
+    }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    variant(variant&& operand) BOOST_NOEXCEPT_IF(variant_move_noexcept_constructible::type::value)
+    {
+        // Move the value of operand into *this...
+        detail::variant::move_into visitor( storage_.address() );
+        operand.internal_apply_visitor(visitor);
+
+        // ...and activate the *this's primary storage on success:
+        indicate_which(operand.which());
+    }
+#endif
+
+private: // helpers, for modifiers (below)
+
+#   if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+    template <typename Variant>
+    friend class detail::variant::backup_assigner;
+#   endif
+
+    // class assigner
+    //
+    // Internal visitor that "assigns" the visited value to the given variant
+    // by appropriate destruction and copy-construction.
+    //
+
+    class assigner
+        : public static_visitor<>
+    {
+    protected: // representation
+
+        variant& lhs_;
+        const int rhs_which_;
+
+    public: // structors
+
+        assigner(variant& lhs, int rhs_which) BOOST_NOEXCEPT
+            : lhs_(lhs)
+            , rhs_which_(rhs_which)
+        {
+        }
+
+    protected: // helpers, for internal visitor interface (below)
+
+        template <typename RhsT, typename B1, typename B2>
+        void assign_impl(
+              const RhsT& rhs_content
+            , mpl::true_ // has_nothrow_copy
+            , B1 // is_nothrow_move_constructible
+            , B2 // has_fallback_type
+            ) const BOOST_NOEXCEPT
+        {
+            // Destroy lhs's content...
+            lhs_.destroy_content(); // nothrow
+
+            // ...copy rhs content into lhs's storage...
+            new(lhs_.storage_.address())
+                RhsT( rhs_content ); // nothrow
+
+            // ...and indicate new content type:
+            lhs_.indicate_which(rhs_which_); // nothrow
+        }
+
+        template <typename RhsT, typename B>
+        void assign_impl(
+              const RhsT& rhs_content
+            , mpl::false_ // has_nothrow_copy
+            , mpl::true_ // is_nothrow_move_constructible
+            , B // has_fallback_type
+            ) const
+        {
+            // Attempt to make a temporary copy (so as to move it below)...
+            RhsT temp(rhs_content);
+
+            // ...and upon success destroy lhs's content...
+            lhs_.destroy_content(); // nothrow
+
+            // ...move the temporary copy into lhs's storage...
+            new(lhs_.storage_.address())
+                RhsT( detail::variant::move(temp) ); // nothrow
+
+            // ...and indicate new content type:
+            lhs_.indicate_which(rhs_which_); // nothrow
+        }
+
+        void construct_fallback() const BOOST_NOEXCEPT {
+            // In case of failure, default-construct fallback type in lhs's storage...
+            new (lhs_.storage_.address())
+                fallback_type_; // nothrow
+
+            // ...indicate construction of fallback type...
+            lhs_.indicate_which(
+                  BOOST_MPL_AUX_VALUE_WKND(fallback_type_index_)::value
+                ); // nothrow
+        }
+
+        template <typename RhsT>
+        void assign_impl(
+              const RhsT& rhs_content
+            , mpl::false_ // has_nothrow_copy
+            , mpl::false_ // is_nothrow_move_constructible
+            , mpl::true_ // has_fallback_type
+            ) const
+        {
+            // Destroy lhs's content...
+            lhs_.destroy_content(); // nothrow
+
+            BOOST_TRY
+            {
+                // ...and attempt to copy rhs's content into lhs's storage:
+                new(lhs_.storage_.address())
+                    RhsT( rhs_content );
+            }
+            BOOST_CATCH (...)
+            {
+                construct_fallback();
+
+                // ...and rethrow:
+                BOOST_RETHROW;
+            }
+            BOOST_CATCH_END
+
+            // In the event of success, indicate new content type:
+            lhs_.indicate_which(rhs_which_); // nothrow
+        }
+
+        template <typename RhsT>
+        void assign_impl(
+              const RhsT& rhs_content
+            , mpl::false_ // has_nothrow_copy
+            , mpl::false_ // is_nothrow_move_constructible
+            , mpl::false_ // has_fallback_type
+            ) const
+        {
+            detail::variant::backup_assigner<wknd_self_t>
+                visitor(lhs_, rhs_which_, rhs_content);
+            lhs_.internal_apply_visitor(visitor);
+        }
+
+    public: // internal visitor interfaces
+
+        template <typename RhsT>
+            BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+        internal_visit(const RhsT& rhs_content, int) const
+        {
+            typedef typename has_nothrow_copy<RhsT>::type
+                nothrow_copy;
+            typedef typename mpl::or_< // reduces compile-time
+                  nothrow_copy
+                , is_nothrow_move_constructible<RhsT>
+                >::type nothrow_move_constructor;
+
+            assign_impl(
+                  rhs_content
+                , nothrow_copy()
+                , nothrow_move_constructor()
+                , has_fallback_type_()
+                );
+
+            BOOST_VARIANT_AUX_RETURN_VOID;
+        }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600))
+    private:
+        // silence MSVC warning C4512: assignment operator could not be generated
+        assigner& operator= (assigner const&);
+#endif
+    };
+    
+    friend class assigner;
+   
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    // class move_assigner
+    //
+    // Internal visitor that "move assigns" the visited value to the given variant
+    // by appropriate destruction and move-construction.
+    //
+
+    class move_assigner
+        : public assigner
+    {
+    public: // structors
+
+        move_assigner(variant& lhs, int rhs_which) BOOST_NOEXCEPT
+            : assigner(lhs, rhs_which)
+        {
+        }
+
+    private: // helpers, for internal visitor interface (below)
+        
+        template <typename RhsT, typename B2>
+        void assign_impl(
+              RhsT& rhs_content
+            , mpl::true_ // has_nothrow_copy
+            , mpl::false_ // is_nothrow_move_constructible
+            , B2 // has_fallback_type
+            ) const BOOST_NOEXCEPT
+        {
+            assigner::assign_impl(rhs_content, mpl::true_(), mpl::false_(), B2());
+        }
+
+        template <typename RhsT, typename B, typename B2>
+        void assign_impl(
+              RhsT& rhs_content
+            , B // has_nothrow_copy
+            , mpl::true_ // is_nothrow_move_constructible
+            , B2 // has_fallback_type
+            ) const BOOST_NOEXCEPT
+        {
+            // ...destroy lhs's content...
+            assigner::lhs_.destroy_content(); // nothrow
+
+            // ...move the rhs_content into lhs's storage...
+            new(assigner::lhs_.storage_.address())
+                RhsT( detail::variant::move(rhs_content) ); // nothrow
+
+            // ...and indicate new content type:
+            assigner::lhs_.indicate_which(assigner::rhs_which_); // nothrow
+        }
+
+        template <typename RhsT>
+        void assign_impl(
+              RhsT& rhs_content
+            , mpl::false_ // has_nothrow_copy
+            , mpl::false_ // is_nothrow_move_constructible
+            , mpl::true_ // has_fallback_type
+            ) const
+        {
+            // Destroy lhs's content...
+            assigner::lhs_.destroy_content(); // nothrow
+
+            BOOST_TRY
+            {
+                // ...and attempt to copy rhs's content into lhs's storage:
+                new(assigner::lhs_.storage_.address())
+                    RhsT( detail::variant::move(rhs_content) );
+            }
+            BOOST_CATCH (...)
+            {
+                assigner::construct_fallback();
+
+                // ...and rethrow:
+                BOOST_RETHROW;
+            }
+            BOOST_CATCH_END
+
+            // In the event of success, indicate new content type:
+            assigner::lhs_.indicate_which(assigner::rhs_which_); // nothrow
+        }
+        
+        template <typename RhsT>
+        void assign_impl(
+              RhsT& rhs_content
+            , mpl::false_ // has_nothrow_copy
+            , mpl::false_ // is_nothrow_move_constructible
+            , mpl::false_ // has_fallback_type
+            ) const
+        {
+            assigner::assign_impl(rhs_content, mpl::false_(), mpl::false_(), mpl::false_());
+        }
+
+    public: // internal visitor interfaces
+
+        template <typename RhsT>
+            BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+        internal_visit(RhsT& rhs_content, int) const
+        {
+            typedef typename is_nothrow_move_constructible<RhsT>::type
+                nothrow_move_constructor;
+            typedef typename mpl::or_< // reduces compile-time
+                  nothrow_move_constructor
+                , has_nothrow_copy<RhsT>
+                >::type nothrow_copy;
+
+            assign_impl(
+                  rhs_content
+                , nothrow_copy()
+                , nothrow_move_constructor()
+                , has_fallback_type_()
+                );
+
+            BOOST_VARIANT_AUX_RETURN_VOID;
+        }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1600))
+    private:
+        // silence MSVC warning C4512: assignment operator could not be generated
+        move_assigner& operator= (move_assigner const&);
+#endif
+    };
+
+    friend class move_assigner;
+#endif // BOOST_NO_CXX11_RVALUE_REFERENCES
+
+    void variant_assign(const variant& rhs)
+    {
+        // If the contained types are EXACTLY the same...
+        if (which_ == rhs.which_)
+        {
+            // ...then assign rhs's storage to lhs's content:
+            detail::variant::assign_storage visitor(rhs.storage_.address());
+            this->internal_apply_visitor(visitor);
+        }
+        else
+        {
+            // Otherwise, perform general (copy-based) variant assignment:
+            assigner visitor(*this, rhs.which());
+            rhs.internal_apply_visitor(visitor); 
+        }
+    }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    void variant_assign(variant&& rhs)
+    {
+        // If the contained types are EXACTLY the same...
+        if (which_ == rhs.which_)
+        {
+            // ...then move rhs's storage to lhs's content:
+            detail::variant::move_storage visitor(rhs.storage_.address());
+            this->internal_apply_visitor(visitor);
+        }
+        else
+        {
+            // Otherwise, perform general (move-based) variant assignment:
+            move_assigner visitor(*this, rhs.which());
+            rhs.internal_apply_visitor(visitor); 
+        }
+    }
+#endif // BOOST_NO_CXX11_RVALUE_REFERENCES
+
+private: // helpers, for modifiers (below)
+
+    template <typename T>
+    void assign(const T& rhs)
+    {
+        // If direct T-to-T assignment is not possible...
+        detail::variant::direct_assigner<T> direct_assign(rhs);
+        if (this->apply_visitor(direct_assign) == false)
+        {
+            // ...then convert rhs to variant and assign:
+            //
+            // While potentially inefficient, the following construction of a
+            // variant allows T as any type convertible to one of the bounded
+            // types without excessive code redundancy.
+            //
+            variant temp(rhs);
+            variant_assign( detail::variant::move(temp) );
+        }
+    }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    template <typename T>
+    void move_assign(T&& rhs)
+    {
+        // If direct T-to-T move assignment is not possible...
+        detail::variant::direct_mover<T> direct_move(rhs);
+        if (this->apply_visitor(direct_move) == false)
+        {
+            // ...then convert rhs to variant and assign:
+            //
+            // While potentially inefficient, the following construction of a
+            // variant allows T as any type convertible to one of the bounded
+            // types without excessive code redundancy.
+            //
+            variant temp( detail::variant::move(rhs) );
+            variant_assign( detail::variant::move(temp) );
+        }
+    }
+#endif // BOOST_NO_CXX11_RVALUE_REFERENCES
+
+public: // modifiers
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    template <class T>
+    typename boost::enable_if<
+        boost::mpl::and_<
+            boost::is_rvalue_reference<T&&>,
+            mpl::not_< boost::is_const<T> >,
+            boost::detail::variant::is_variant_constructible_from<T&&, internal_types>
+        >,
+        variant&
+    >::type operator=(T&& rhs) 
+    {
+        move_assign( detail::variant::move(rhs) );
+        return *this;
+    }
+#endif // BOOST_NO_CXX11_RVALUE_REFERENCES
+
+    template <typename T>
+    typename boost::enable_if<
+        mpl::or_<
+            boost::is_same<T, variant>,
+            boost::detail::variant::is_variant_constructible_from<const T&, internal_types>
+        >,
+        variant&
+    >::type operator=(const T& rhs)
+    {
+        assign(rhs);
+        return *this;
+    }
+
+    // [MSVC6 requires copy assign appear after templated operator=]
+    variant& operator=(const variant& rhs)
+    {
+        variant_assign(rhs);
+        return *this;
+    }
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    variant& operator=(variant&& rhs) 
+#if !defined(__GNUC__) || (__GNUC__ != 4) || (__GNUC_MINOR__ > 6) || defined(__clang__)
+        BOOST_NOEXCEPT_IF(variant_move_noexcept_constructible::type::value && variant_move_noexcept_assignable::type::value)
+#endif
+    {
+        variant_assign( detail::variant::move(rhs) );
+        return *this;
+    }
+#endif // BOOST_NO_CXX11_RVALUE_REFERENCES
+
+    void swap(variant& rhs)
+    {
+        // If the contained types are the same...
+        if (which() == rhs.which())
+        {
+            // ...then swap the values directly:
+            detail::variant::swap_with<variant> visitor(rhs);
+            this->apply_visitor(visitor);
+        }
+        else
+        {
+            // ...otherwise, perform general variant swap:
+            variant tmp( detail::variant::move(rhs) );
+            rhs = detail::variant::move(*this);
+            *this = detail::variant::move(tmp);
+        }
+    }
+
+public: // queries
+
+    //
+    // NOTE: member which() defined above.
+    //
+
+    bool empty() const BOOST_NOEXCEPT
+    {
+        return false;
+    }
+
+    const boost::typeindex::type_info& type() const
+    {
+        detail::variant::reflect visitor;
+        return this->apply_visitor(visitor);
+    }
+
+public: // prevent comparison with foreign types
+
+    template <typename U>
+    void operator==(const U&) const
+    {
+        BOOST_STATIC_ASSERT( false && sizeof(U) );
+    }
+
+    template <typename U>
+    void operator<(const U&) const
+    {
+        BOOST_STATIC_ASSERT( false && sizeof(U) );
+    }
+
+    template <typename U>
+    void operator!=(const U&) const
+    {
+        BOOST_STATIC_ASSERT( false && sizeof(U) );
+    }
+
+    template <typename U>
+    void operator>(const U&) const
+    {
+        BOOST_STATIC_ASSERT( false && sizeof(U) );
+    }
+
+    template <typename U>
+    void operator<=(const U&) const
+    {
+        BOOST_STATIC_ASSERT( false && sizeof(U) );
+    }
+
+    template <typename U>
+    void operator>=(const U&) const
+    {
+        BOOST_STATIC_ASSERT( false && sizeof(U) );
+    }
+
+public: // comparison operators
+
+    // [MSVC6 requires these operators appear after template operators]
+
+    bool operator==(const variant& rhs) const
+    {
+        if (this->which() != rhs.which())
+            return false;
+
+        detail::variant::comparer<
+              variant, detail::variant::equal_comp
+            > visitor(*this);
+        return rhs.apply_visitor(visitor);
+    }
+
+    bool operator<(const variant& rhs) const
+    {
+        //
+        // Dirk Schreib suggested this collating order.
+        //
+
+        if (this->which() != rhs.which())
+            return this->which() < rhs.which();
+
+        detail::variant::comparer<
+              variant, detail::variant::less_comp
+            > visitor(*this);
+        return rhs.apply_visitor(visitor);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////
+    // comparison operators != > <= >=
+    inline bool operator!=(const variant& rhs) const
+    {
+        return !(*this == rhs);
+    }
+
+    inline bool operator>(const variant& rhs) const
+    {
+        return rhs < *this;
+    }
+
+    inline bool operator<=(const variant& rhs) const
+    {
+        return !(*this > rhs);
+    }
+
+    inline bool operator>=(const variant& rhs) const
+    {
+        return !(*this < rhs);
+    }
+
+// helpers, for visitation support (below) -- private when possible
+#if !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+
+    template < BOOST_VARIANT_ENUM_PARAMS(typename U) >
+    friend class variant;
+
+private:
+
+#else// defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+
+public:
+
+#endif// !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
+
+    template <typename Visitor, typename VoidPtrCV>
+    static
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(
+              typename Visitor::result_type
+            )
+    internal_apply_visitor_impl(
+          int internal_which
+        , int logical_which
+        , Visitor& visitor
+        , VoidPtrCV storage
+        )
+    {
+        typedef mpl::int_<0> first_which;
+        typedef typename mpl::begin<internal_types>::type first_it;
+        typedef typename mpl::end<internal_types>::type last_it;
+
+        typedef detail::variant::visitation_impl_step<
+              first_it, last_it
+            > first_step;
+
+        return detail::variant::visitation_impl(
+              internal_which, logical_which
+            , visitor, storage, mpl::false_()
+            , never_uses_backup_flag()
+            , static_cast<first_which*>(0), static_cast<first_step*>(0)
+            );
+    }
+
+    template <typename Visitor>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(
+              typename Visitor::result_type
+            )
+    internal_apply_visitor(Visitor& visitor)
+    {
+        return internal_apply_visitor_impl(
+              which_, which(), visitor, storage_.address()
+            );
+    }
+
+    template <typename Visitor>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(
+              typename Visitor::result_type
+            )
+    internal_apply_visitor(Visitor& visitor) const
+    {
+        return internal_apply_visitor_impl(
+              which_, which(), visitor, storage_.address()
+            );
+    }
+
+public: // visitation support
+
+    template <typename Visitor>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(
+              typename Visitor::result_type
+            )
+    apply_visitor(Visitor& visitor)
+    {
+        detail::variant::invoke_visitor<Visitor> invoker(visitor);
+        return this->internal_apply_visitor(invoker);
+    }
+
+    template <typename Visitor>
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(
+              typename Visitor::result_type
+            )
+    apply_visitor(Visitor& visitor) const
+    {
+        detail::variant::invoke_visitor<Visitor> invoker(visitor);
+        return this->internal_apply_visitor(invoker);
+    }
+
+}; // class variant
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction make_variant_over
+//
+// See docs and boost/variant/variant_fwd.hpp for more information.
+//
+template <typename Types>
+struct make_variant_over
+{
+private: // precondition assertions
+
+    BOOST_STATIC_ASSERT(( ::boost::mpl::is_sequence<Types>::value ));
+    typedef typename boost::mpl::insert_range<
+      boost::mpl::list<>
+    , boost::mpl::end< boost::mpl::list<> >::type
+    , Types
+    >::type copied_sequence_t;
+
+public: // metafunction result
+
+    typedef variant<
+          detail::variant::over_sequence<copied_sequence_t>
+        > type;
+
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// function template swap
+//
+// Swaps two variants of the same type (i.e., identical specification).
+//
+template < BOOST_VARIANT_ENUM_PARAMS(typename T) >
+inline void swap(
+      variant< BOOST_VARIANT_ENUM_PARAMS(T) >& lhs
+    , variant< BOOST_VARIANT_ENUM_PARAMS(T) >& rhs
+    )
+{
+    lhs.swap(rhs);
+}
+
+} // namespace boost
+
+// implementation additions
+
+#if !defined(BOOST_NO_IOSTREAM)
+#include <boost/variant/detail/variant_io.hpp>
+#endif // BOOST_NO_IOSTREAM
+
+#endif // BOOST_VARIANT_VARIANT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/variant_fwd.hpp b/contrib/libboost/boost_1_65_0/boost/variant/variant_fwd.hpp
new file mode 100644
index 00000000000..b533f766682
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/variant_fwd.hpp
@@ -0,0 +1,322 @@
+//-----------------------------------------------------------------------------
+// boost variant/variant_fwd.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2003 Eric Friedman, Itay Maman
+// Copyright (c) 2013-2016 Antony Polukhin
+//
+// 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_VARIANT_VARIANT_FWD_HPP
+#define BOOST_VARIANT_VARIANT_FWD_HPP
+
+#include <boost/variant/detail/config.hpp>
+
+#include <boost/blank_fwd.hpp>
+#include <boost/mpl/arg.hpp>
+#include <boost/mpl/limits/arity.hpp>
+#include <boost/mpl/aux_/na.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/enum.hpp>
+#include <boost/preprocessor/enum_params.hpp>
+#include <boost/preprocessor/enum_shifted_params.hpp>
+#include <boost/preprocessor/repeat.hpp>
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT
+//
+// Defined if variant does not support make_variant_over (see below). 
+//
+#if defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+#   define BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT
+//
+// Defined if make_recursive_variant cannot be supported as documented.
+//
+// Note: Currently, MPL lambda facility is used as workaround if defined, and
+// so only types declared w/ MPL lambda workarounds will work.
+//
+
+#include <boost/variant/detail/substitute_fwd.hpp>
+
+#if defined(BOOST_VARIANT_DETAIL_NO_SUBSTITUTE) \
+  && !defined(BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT)
+#   define BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT
+#endif
+
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES
+//
+
+/* 
+    GCC before 4.0 had no variadic tempaltes; 
+    GCC 4.6 has incomplete implementation of variadic templates.
+
+    MSVC2015 Update 1 has variadic templates, but they have issues.
+
+    NOTE: Clang compiler defines __GNUC__
+*/
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) \
+  || (!defined(__clang__) && defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ < 7)) \
+  || (defined(_MSC_VER) && (_MSC_VER <= 1900)) \
+  || defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE) \
+  || defined (BOOST_VARIANT_NO_TYPE_SEQUENCE_SUPPORT)
+
+#ifndef BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES
+#   define BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES
+#endif
+
+#endif
+
+#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+#include <boost/preprocessor/seq/size.hpp>
+
+#define BOOST_VARIANT_CLASS_OR_TYPENAME_TO_SEQ_class class)(
+#define BOOST_VARIANT_CLASS_OR_TYPENAME_TO_SEQ_typename typename)(
+
+#define BOOST_VARIANT_CLASS_OR_TYPENAME_TO_VARIADIC_class class...
+#define BOOST_VARIANT_CLASS_OR_TYPENAME_TO_VARIADIC_typename typename...
+
+#define ARGS_VARIADER_1(x) x ## N...
+#define ARGS_VARIADER_2(x) BOOST_VARIANT_CLASS_OR_TYPENAME_TO_VARIADIC_ ## x ## N
+
+#define BOOST_VARIANT_MAKE_VARIADIC(sequence, x)        BOOST_VARIANT_MAKE_VARIADIC_I(BOOST_PP_SEQ_SIZE(sequence), x)
+#define BOOST_VARIANT_MAKE_VARIADIC_I(argscount, x)     BOOST_VARIANT_MAKE_VARIADIC_II(argscount, x)
+#define BOOST_VARIANT_MAKE_VARIADIC_II(argscount, orig) ARGS_VARIADER_ ## argscount(orig)
+
+///////////////////////////////////////////////////////////////////////////////
+// BOOST_VARIANT_ENUM_PARAMS and BOOST_VARIANT_ENUM_SHIFTED_PARAMS
+//
+// Convenience macro for enumeration of variant params.
+// When variadic templates are available expands:
+//      BOOST_VARIANT_ENUM_PARAMS(class Something)      => class Something0, class... SomethingN
+//      BOOST_VARIANT_ENUM_PARAMS(typename Something)   => typename Something0, typename... SomethingN
+//      BOOST_VARIANT_ENUM_PARAMS(Something)            => Something0, SomethingN...
+//      BOOST_VARIANT_ENUM_PARAMS(Something)            => Something0, SomethingN...
+//      BOOST_VARIANT_ENUM_SHIFTED_PARAMS(class Something)      => class... SomethingN
+//      BOOST_VARIANT_ENUM_SHIFTED_PARAMS(typename Something)   => typename... SomethingN
+//      BOOST_VARIANT_ENUM_SHIFTED_PARAMS(Something)            => SomethingN...
+//      BOOST_VARIANT_ENUM_SHIFTED_PARAMS(Something)            => SomethingN...
+//
+// Rationale: Cleaner, simpler code for clients of variant library. Minimal 
+// code modifications to move from C++03 to C++11.
+//
+// With BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES defined
+// will be used BOOST_VARIANT_ENUM_PARAMS and BOOST_VARIANT_ENUM_SHIFTED_PARAMS from below `#else`
+//
+
+#define BOOST_VARIANT_ENUM_PARAMS(x) \
+    x ## 0, \
+    BOOST_VARIANT_MAKE_VARIADIC( (BOOST_VARIANT_CLASS_OR_TYPENAME_TO_SEQ_ ## x), x) \
+    /**/
+
+#define BOOST_VARIANT_ENUM_SHIFTED_PARAMS(x) \
+    BOOST_VARIANT_MAKE_VARIADIC( (BOOST_VARIANT_CLASS_OR_TYPENAME_TO_SEQ_ ## x), x) \
+    /**/
+
+#else // defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_LIMIT_TYPES
+//
+// Implementation-defined preprocessor symbol describing the actual
+// length of variant's pseudo-variadic template parameter list.
+//
+#include <boost/mpl/limits/list.hpp>
+#define BOOST_VARIANT_LIMIT_TYPES \
+    BOOST_MPL_LIMIT_LIST_SIZE
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_RECURSIVE_VARIANT_MAX_ARITY
+//
+// Exposes maximum allowed arity of class templates with recursive_variant
+// arguments. That is,
+//   make_recursive_variant< ..., T<[1], recursive_variant_, ... [N]> >.
+//
+#include <boost/mpl/limits/arity.hpp>
+#define BOOST_VARIANT_RECURSIVE_VARIANT_MAX_ARITY \
+    BOOST_MPL_LIMIT_METAFUNCTION_ARITY
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_ENUM_PARAMS
+//
+// Convenience macro for enumeration of BOOST_VARIANT_LIMIT_TYPES params.
+//
+// Rationale: Cleaner, simpler code for clients of variant library.
+//
+#define BOOST_VARIANT_ENUM_PARAMS( param )  \
+    BOOST_PP_ENUM_PARAMS(BOOST_VARIANT_LIMIT_TYPES, param)
+
+///////////////////////////////////////////////////////////////////////////////
+// macro BOOST_VARIANT_ENUM_SHIFTED_PARAMS
+//
+// Convenience macro for enumeration of BOOST_VARIANT_LIMIT_TYPES-1 params.
+//
+#define BOOST_VARIANT_ENUM_SHIFTED_PARAMS( param )  \
+    BOOST_PP_ENUM_SHIFTED_PARAMS(BOOST_VARIANT_LIMIT_TYPES, param)
+
+#endif // BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES workaround
+
+
+namespace boost {
+
+namespace detail { namespace variant {
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) class void_ and class template convert_void
+// 
+// Provides the mechanism by which void(NN) types are converted to
+// mpl::void_ (and thus can be passed to mpl::list).
+//
+// Rationale: This is particularly needed for the using-declarations
+// workaround (below), but also to avoid associating mpl namespace with
+// variant in argument dependent lookups (which used to happen because of
+// defaulting of template parameters to mpl::void_).
+//
+
+struct void_;
+
+template <typename T>
+struct convert_void
+{
+    typedef T type;
+};
+
+template <>
+struct convert_void< void_ >
+{
+    typedef mpl::na type;
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// (workaround) BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE
+//
+// Needed to work around compilers that don't support using-declaration
+// overloads. (See the variant::initializer workarounds below.)
+//
+
+#if defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+// (detail) tags voidNN -- NN defined on [0, BOOST_VARIANT_LIMIT_TYPES)
+//
+// Defines void types that are each unique and specializations of
+// convert_void that yields mpl::na for each voidNN type.
+//
+
+#define BOOST_VARIANT_DETAIL_DEFINE_VOID_N(z,N,_)          \
+    struct BOOST_PP_CAT(void,N);                           \
+                                                           \
+    template <>                                            \
+    struct convert_void< BOOST_PP_CAT(void,N) >            \
+    {                                                      \
+        typedef mpl::na type;                              \
+    };                                                     \
+    /**/
+
+BOOST_PP_REPEAT(
+      BOOST_VARIANT_LIMIT_TYPES
+    , BOOST_VARIANT_DETAIL_DEFINE_VOID_N
+    , _
+    )
+
+#undef BOOST_VARIANT_DETAIL_DEFINE_VOID_N
+
+#endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround
+
+}} // namespace detail::variant
+
+#if !defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+#   define BOOST_VARIANT_AUX_DECLARE_PARAMS BOOST_VARIANT_ENUM_PARAMS(typename T)
+#else // defined(BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES)
+
+///////////////////////////////////////////////////////////////////////////////
+// (detail) macro BOOST_VARIANT_AUX_DECLARE_PARAM
+//
+// Template parameter list for variant and recursive_variant declarations.
+//
+
+#if !defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+#   define BOOST_VARIANT_AUX_DECLARE_PARAMS_IMPL(z, N, T) \
+    typename BOOST_PP_CAT(T,N) = detail::variant::void_ \
+    /**/
+
+#else // defined(BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE)
+
+#   define BOOST_VARIANT_AUX_DECLARE_PARAMS_IMPL(z, N, T) \
+    typename BOOST_PP_CAT(T,N) = BOOST_PP_CAT(detail::variant::void,N) \
+    /**/
+
+#endif // BOOST_NO_USING_DECLARATION_OVERLOADS_FROM_TYPENAME_BASE workaround
+
+#define BOOST_VARIANT_AUX_DECLARE_PARAMS \
+    BOOST_PP_ENUM( \
+          BOOST_VARIANT_LIMIT_TYPES \
+        , BOOST_VARIANT_AUX_DECLARE_PARAMS_IMPL \
+        , T \
+        ) \
+    /**/
+
+#endif // BOOST_VARIANT_DO_NOT_USE_VARIADIC_TEMPLATES workaround
+
+///////////////////////////////////////////////////////////////////////////////
+// class template variant (concept inspired by Andrei Alexandrescu)
+//
+// Efficient, type-safe bounded discriminated union.
+//
+// Preconditions:
+//  - Each type must be unique.
+//  - No type may be const-qualified.
+//
+// Proper declaration form:
+//   variant<types>    (where types is a type-sequence)
+// or
+//   variant<T0,T1,...,Tn>  (where T0 is NOT a type-sequence)
+//
+template < BOOST_VARIANT_AUX_DECLARE_PARAMS > class variant;
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction make_recursive_variant
+//
+// Exposes a boost::variant with recursive_variant_ tags (below) substituted
+// with the variant itself (wrapped as needed with boost::recursive_wrapper).
+//
+template < BOOST_VARIANT_AUX_DECLARE_PARAMS > struct make_recursive_variant;
+
+#undef BOOST_VARIANT_AUX_DECLARE_PARAMS_IMPL
+#undef BOOST_VARIANT_AUX_DECLARE_PARAMS
+
+///////////////////////////////////////////////////////////////////////////////
+// type recursive_variant_
+//
+// Tag type indicates where recursive variant substitution should occur.
+//
+#if !defined(BOOST_VARIANT_NO_FULL_RECURSIVE_VARIANT_SUPPORT)
+    struct recursive_variant_ {};
+#else
+    typedef mpl::arg<1> recursive_variant_;
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction make_variant_over
+//
+// Result is a variant w/ types of the specified type sequence.
+//
+template <typename Types> struct make_variant_over;
+
+///////////////////////////////////////////////////////////////////////////////
+// metafunction make_recursive_variant_over
+//
+// Result is a recursive variant w/ types of the specified type sequence.
+//
+template <typename Types> struct make_recursive_variant_over;
+
+} // namespace boost
+
+#endif // BOOST_VARIANT_VARIANT_FWD_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/variant/visitor_ptr.hpp b/contrib/libboost/boost_1_65_0/boost/variant/visitor_ptr.hpp
new file mode 100644
index 00000000000..61bc8dfc5f9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/variant/visitor_ptr.hpp
@@ -0,0 +1,117 @@
+//-----------------------------------------------------------------------------
+// boost variant/visitor_ptr.hpp header file
+// See http://www.boost.org for updates, documentation, and revision history.
+//-----------------------------------------------------------------------------
+//
+// Copyright (c) 2002-2003
+// Eric Friedman
+//
+// 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_VARIANT_VISITOR_PTR_HPP
+#define BOOST_VARIANT_VISITOR_PTR_HPP
+
+#include <boost/variant/bad_visit.hpp>
+#include <boost/variant/static_visitor.hpp>
+
+#include <boost/mpl/eval_if.hpp>
+#include <boost/mpl/identity.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/type_traits/add_reference.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/is_void.hpp>
+
+namespace boost {
+
+//////////////////////////////////////////////////////////////////////////
+// function template visitor_ptr
+//
+// Adapts a function pointer for use as visitor capable of handling
+// values of a single type. Throws bad_visit if inappropriately applied.
+//
+template <typename T, typename R>
+class visitor_ptr_t
+    : public static_visitor<R>
+{
+private: // representation
+
+    typedef R (*visitor_t)(T);
+
+    visitor_t visitor_;
+
+public: // typedefs
+
+    typedef R result_type;
+
+private: // private typedefs
+
+    typedef typename mpl::eval_if<
+          is_reference<T>
+        , mpl::identity<T>
+        , add_reference<const T>
+        >::type argument_fwd_type;
+
+public: // structors
+
+    explicit visitor_ptr_t(visitor_t visitor) BOOST_NOEXCEPT
+      : visitor_(visitor)
+    {
+    }
+
+public: // static visitor interfaces
+
+    template <typename U>
+    result_type operator()(const U&) const
+    {
+        boost::throw_exception(bad_visit());
+    }
+
+#if !defined(BOOST_NO_VOID_RETURNS)
+
+public: // static visitor interfaces, cont.
+
+    result_type operator()(argument_fwd_type operand) const
+    {
+        return visitor_(operand);
+    }
+
+#else // defined(BOOST_NO_VOID_RETURNS)
+
+private: // helpers, for static visitor interfaces (below)
+
+    result_type execute_impl(argument_fwd_type operand, mpl::false_) const
+    {
+        return visitor_(operand);
+    }
+
+        BOOST_VARIANT_AUX_RETURN_VOID_TYPE
+    execute_impl(argument_fwd_type operand, mpl::true_) const
+    {
+        visitor_(operand);
+        BOOST_VARIANT_AUX_RETURN_VOID;
+    }
+
+public: // static visitor interfaces, cont.
+
+        BOOST_VARIANT_AUX_GENERIC_RESULT_TYPE(result_type)
+    operator()(argument_fwd_type operand) const
+    {
+        typedef typename is_void<result_type>::type has_void_result;
+        return execute_impl(operand, has_void_result());
+    }
+
+#endif // BOOST_NO_VOID_RETURNS workaround
+
+};
+
+template <typename R, typename T>
+inline visitor_ptr_t<T,R> visitor_ptr(R (*visitor)(T))
+{
+    return visitor_ptr_t<T,R>(visitor);
+}
+
+} // namespace boost
+
+#endif// BOOST_VISITOR_VISITOR_PTR_HPP
diff --git a/contrib/libboost/boost_1_62_0/boost/version.hpp b/contrib/libboost/boost_1_65_0/boost/version.hpp
similarity index 94%
rename from contrib/libboost/boost_1_62_0/boost/version.hpp
rename to contrib/libboost/boost_1_65_0/boost/version.hpp
index a382352cd54..725165f44d5 100644
--- a/contrib/libboost/boost_1_62_0/boost/version.hpp
+++ b/contrib/libboost/boost_1_65_0/boost/version.hpp
@@ -19,7 +19,7 @@
 //  BOOST_VERSION / 100 % 1000 is the minor version
 //  BOOST_VERSION / 100000 is the major version
 
-#define BOOST_VERSION 106200
+#define BOOST_VERSION 106500
 
 //
 //  BOOST_LIB_VERSION must be defined to be the same as BOOST_VERSION
@@ -27,6 +27,6 @@
 //  number, y is the minor version number, and z is the patch level if not 0.
 //  This is used by <config/auto_link.hpp> to select which library version to link to.
 
-#define BOOST_LIB_VERSION "1_62"
+#define BOOST_LIB_VERSION "1_65"
 
 #endif
diff --git a/contrib/libboost/boost_1_62_0/boost/visit_each.hpp b/contrib/libboost/boost_1_65_0/boost/visit_each.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/boost/visit_each.hpp
rename to contrib/libboost/boost_1_65_0/boost/visit_each.hpp
diff --git a/contrib/libboost/boost_1_62_0/libs/filesystem/src/codecvt_error_category.cpp b/contrib/libboost/boost_1_65_0/libs/filesystem/src/codecvt_error_category.cpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/libs/filesystem/src/codecvt_error_category.cpp
rename to contrib/libboost/boost_1_65_0/libs/filesystem/src/codecvt_error_category.cpp
diff --git a/contrib/libboost/boost_1_62_0/libs/filesystem/src/operations.cpp b/contrib/libboost/boost_1_65_0/libs/filesystem/src/operations.cpp
similarity index 93%
rename from contrib/libboost/boost_1_62_0/libs/filesystem/src/operations.cpp
rename to contrib/libboost/boost_1_65_0/libs/filesystem/src/operations.cpp
index b5e0f661ba6..4114e02a1a3 100644
--- a/contrib/libboost/boost_1_62_0/libs/filesystem/src/operations.cpp
+++ b/contrib/libboost/boost_1_65_0/libs/filesystem/src/operations.cpp
@@ -101,6 +101,7 @@ using std::wstring;
       // See MinGW's windef.h
 #     define WINVER 0x501
 #   endif
+#   include <cwchar>
 #   include <io.h>
 #   include <windows.h>
 #   include <winnt.h>
@@ -328,9 +329,10 @@ namespace
 
   //  general helpers  -----------------------------------------------------------------//
 
-  bool is_empty_directory(const path& p)
+  bool is_empty_directory(const path& p, error_code* ec)
   {
-    return fs::directory_iterator(p)== end_dir_itr;
+    return (ec != 0 ? fs::directory_iterator(p, *ec) : fs::directory_iterator(p))
+      == end_dir_itr;
   }
 
   bool not_found_error(int errval); // forward declaration
@@ -382,16 +384,25 @@ namespace
     error_code* ec)
   {
     boost::uintmax_t count = 1;
-
     if (type == fs::directory_file)  // but not a directory symlink
     {
-      for (fs::directory_iterator itr(p);
-            itr != end_dir_itr; ++itr)
+      fs::directory_iterator itr;
+      if (ec != 0)
+      {
+        itr = fs::directory_iterator(p, *ec);
+        if (*ec)
+          return count;
+      }
+      else
+        itr = fs::directory_iterator(p);
+      for (; itr != end_dir_itr; ++itr)
       {
         fs::file_type tmp_type = query_file_type(itr->path(), ec);
         if (ec != 0 && *ec)
           return count;
         count += remove_all_aux(itr->path(), tmp_type, ec);
+        if (ec != 0 && *ec)
+          return count;
       }
     }
     remove_file_or_directory(p, type, ec);
@@ -507,25 +518,115 @@ namespace
       || errval == ERROR_BAD_PATHNAME  // "//nosuch" on Win64
       || errval == ERROR_BAD_NETPATH;  // "//nosuch" on Win32
   }
+  
+  // File name case-insensitive comparison needs to be locale- and collation-independent. 
+  // The approach used below follows a combined strategy described in the following
+  // articles:
+  // http://archives.miloush.net/michkap/archive/2005/10/17/481600.html
+  // http://archives.miloush.net/michkap/archive/2007/09/14/4900107.html
+  // http://archives.miloush.net/michkap/archive/2007/10/12/5396685.html
+  // CompareStringOrdinal is only available on newer systems and is just a wrapper of
+  // RtlCompareUnicodeString, but measurements showed that RtlEqualUnicodeString has better
+  // performance. Therefore we use RtlEqualUnicodeString, and if that does not exist 
+  // we perform the equivalent characterwise comparsion using LCMapString and uppercase 
+  // binary equality. Instead of calling RtlInitUnicodeString we use wcslen directly
+  // because that results in better performance as well.
 
-// some distributions of mingw as early as GLIBCXX__ 20110325 have _stricmp, but the
-// offical 4.6.2 release with __GLIBCXX__ 20111026  doesn't. Play it safe for now, and
-// only use _stricmp if _MSC_VER is defined
-#if defined(_MSC_VER) // || (defined(__GLIBCXX__) && __GLIBCXX__ >= 20110325)
-#  define BOOST_FILESYSTEM_STRICMP _stricmp
-#else
-#  define BOOST_FILESYSTEM_STRICMP strcmp
+  //  Windows ntdll.dll functions that may or may not be present
+  //  must be accessed through pointers
+  typedef struct _UNICODE_STRING {
+    USHORT Length;
+    USHORT MaximumLength;
+    PWSTR  Buffer;
+  } UNICODE_STRING;
+
+  typedef const UNICODE_STRING *PCUNICODE_STRING;
+
+  typedef BOOLEAN (WINAPI *PtrRtlEqualUnicodeString)(
+    /*_In_*/ PCUNICODE_STRING String1,
+    /*_In_*/ PCUNICODE_STRING String2,
+    /*_In_*/ BOOLEAN          CaseInSensitive
+  );
+
+  PtrRtlEqualUnicodeString rtl_equal_unicode_string_api = PtrRtlEqualUnicodeString(
+    ::GetProcAddress(
+      ::GetModuleHandleW(L"ntdll.dll"), "RtlEqualUnicodeString"));
+
+#ifndef LOCALE_INVARIANT
+#  define LOCALE_INVARIANT (MAKELCID(MAKELANGID(LANG_INVARIANT, SUBLANG_NEUTRAL), SORT_DEFAULT))
 #endif
 
+  bool equal_string_ordinal_ic_1(const wchar_t* s1, const wchar_t* s2)
+  {
+    std::size_t len1 = std::wcslen(s1);
+    UNICODE_STRING us1;
+    us1.Buffer = const_cast<wchar_t*>(s1);
+    us1.Length = static_cast<USHORT>(sizeof(*s1) * len1);
+    us1.MaximumLength = static_cast<USHORT>(us1.Length + sizeof(*s1));
+    std::size_t len2 = std::wcslen(s2);
+    UNICODE_STRING us2;
+    us2.Buffer = const_cast<wchar_t*>(s2);
+    us2.Length = static_cast<USHORT>(sizeof(*s2) * len2);
+    us2.MaximumLength = static_cast<USHORT>(us2.Length + sizeof(*s2));
+    BOOLEAN res = rtl_equal_unicode_string_api(&us1, &us2, TRUE);
+    return res != FALSE;
+  }
+
+  inline
+  wchar_t to_upper_invariant(wchar_t input)
+  {
+    wchar_t result;
+    // According to 
+    // https://msdn.microsoft.com/en-us/library/windows/desktop/dd318144(v=vs.85).aspx
+    // "When transforming between uppercase and lowercase, the function always maps a 
+    // single character to a single character."
+    int res = ::LCMapStringW(LOCALE_INVARIANT, LCMAP_UPPERCASE, &input, 1, &result, 1); 
+    if (res != 0)
+      return result;
+    assert(!"LCMapStringW failed to convert a character to upper case");
+    return input; // Should never happen, but this is a safe fallback.
+  }
+  
+  bool equal_string_ordinal_ic_2(const wchar_t* s1, const wchar_t* s2)
+  {
+    for (;; ++s1, ++s2)
+    {
+      const wchar_t c1 = *s1;
+      const wchar_t c2 = *s2;
+      if (c1 == c2)
+      {
+        if (!c1)
+          return true; // We have reached the end of both strings, no difference found.
+      }
+      else
+      {
+        if (!c1 || !c2)
+          return false; // We have reached the end of one string
+        // This needs to be upper case to match the behavior of the operating system,
+        // see http://archives.miloush.net/michkap/archive/2005/10/17/481600.html
+        const wchar_t u1 = to_upper_invariant(c1);
+        const wchar_t u2 = to_upper_invariant(c2);
+        if (u1 != u2)
+          return false; // strings are different
+      }
+    }
+  }  
+  
+  typedef bool (*Ptr_equal_string_ordinal_ic)(const wchar_t*, const wchar_t*);
+
+  Ptr_equal_string_ordinal_ic equal_string_ordinal_ic = 
+    rtl_equal_unicode_string_api ? equal_string_ordinal_ic_1 : equal_string_ordinal_ic_2;
+  
   perms make_permissions(const path& p, DWORD attr)
   {
     perms prms = fs::owner_read | fs::group_read | fs::others_read;
     if  ((attr & FILE_ATTRIBUTE_READONLY) == 0)
       prms |= fs::owner_write | fs::group_write | fs::others_write;
-    if (BOOST_FILESYSTEM_STRICMP(p.extension().string().c_str(), ".exe") == 0
-      || BOOST_FILESYSTEM_STRICMP(p.extension().string().c_str(), ".com") == 0
-      || BOOST_FILESYSTEM_STRICMP(p.extension().string().c_str(), ".bat") == 0
-      || BOOST_FILESYSTEM_STRICMP(p.extension().string().c_str(), ".cmd") == 0)
+    path ext = p.extension();
+    if (equal_string_ordinal_ic(ext.c_str(), L".exe")
+      || equal_string_ordinal_ic(ext.c_str(), L".com")
+      || equal_string_ordinal_ic(ext.c_str(), L".bat")
+      || equal_string_ordinal_ic(ext.c_str(), L".cmd"))
       prms |= fs::owner_exe | fs::group_exe | fs::others_exe;
     return prms;
   }
@@ -687,7 +788,7 @@ namespace
 
   PtrCreateHardLinkW create_hard_link_api = PtrCreateHardLinkW(
     ::GetProcAddress(
-      ::GetModuleHandle(TEXT("kernel32.dll")), "CreateHardLinkW"));
+      ::GetModuleHandleW(L"kernel32.dll"), "CreateHardLinkW"));
 
   typedef BOOLEAN (WINAPI *PtrCreateSymbolicLinkW)(
     /*__in*/ LPCWSTR lpSymlinkFileName,
@@ -697,7 +798,7 @@ namespace
 
   PtrCreateSymbolicLinkW create_symbolic_link_api = PtrCreateSymbolicLinkW(
     ::GetProcAddress(
-      ::GetModuleHandle(TEXT("kernel32.dll")), "CreateSymbolicLinkW"));
+      ::GetModuleHandleW(L"kernel32.dll"), "CreateSymbolicLinkW"));
 
 #endif
 
@@ -937,12 +1038,20 @@ namespace detail
  BOOST_FILESYSTEM_DECL
   bool create_directories(const path& p, system::error_code* ec)
   {
-    path filename(p.filename());
-    if ((filename.native().size() == 1 && filename.native()[0] == dot)
-      || (filename.native().size() == 2
-        && filename.native()[0] == dot && filename.native()[1] == dot))
-      return create_directories(p.parent_path(), ec);
+   if (p.empty())
+   {
+     if (ec == 0)
+       BOOST_FILESYSTEM_THROW(filesystem_error(
+         "boost::filesystem::create_directories", p,
+         system::errc::make_error_code(system::errc::invalid_argument)));
+     else
+       ec->assign(system::errc::invalid_argument, system::generic_category());
+     return false;
+   }
 
+    if (p.filename_is_dot() || p.filename_is_dot_dot())
+      return create_directories(p.parent_path(), ec);
+    
     error_code local_ec;
     file_status p_status = status(p, local_ec);
 
@@ -993,7 +1102,8 @@ namespace detail
     //  attempt to create directory failed
     int errval(BOOST_ERRNO);  // save reason for failure
     error_code dummy;
-    if (errval == BOOST_ERROR_ALREADY_EXISTS && is_directory(p, dummy))
+
+    if (is_directory(p, dummy))
     {
       if (ec != 0)
         ec->clear();
@@ -1006,6 +1116,7 @@ namespace detail
         p, error_code(errval, system_category())));
     else
       ec->assign(errval, system_category());
+
     return false;
   }
 
@@ -1298,7 +1409,7 @@ namespace detail
         p, ec, "boost::filesystem::is_empty"))
       return false;        
     return S_ISDIR(path_stat.st_mode)
-      ? is_empty_directory(p)
+      ? is_empty_directory(p, ec)
       : path_stat.st_size == 0;
 #   else
 
@@ -1310,7 +1421,7 @@ namespace detail
     if (ec != 0) ec->clear();
     return 
       (fad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
-        ? is_empty_directory(p)
+        ? is_empty_directory(p, ec)
         : (!fad.nFileSizeHigh && !fad.nFileSizeLow);
 #   endif
   }
@@ -1601,7 +1712,7 @@ namespace detail
 #   ifdef BOOST_POSIX_API
     struct BOOST_STATVFS vfs;
     space_info info;
-    if (!error(::BOOST_STATVFS(p.c_str(), &vfs)!= 0,
+    if (!error(::BOOST_STATVFS(p.c_str(), &vfs) ? BOOST_ERRNO : 0,
       p, ec, "boost::filesystem::space"))
     {
       info.capacity 
diff --git a/contrib/libboost/boost_1_62_0/libs/filesystem/src/path.cpp b/contrib/libboost/boost_1_65_0/libs/filesystem/src/path.cpp
similarity index 90%
rename from contrib/libboost/boost_1_62_0/libs/filesystem/src/path.cpp
rename to contrib/libboost/boost_1_65_0/libs/filesystem/src/path.cpp
index dcef9d02afa..a4588654bad 100644
--- a/contrib/libboost/boost_1_62_0/libs/filesystem/src/path.cpp
+++ b/contrib/libboost/boost_1_65_0/libs/filesystem/src/path.cpp
@@ -73,12 +73,10 @@ namespace
 
 # ifdef BOOST_WINDOWS_API
 
-  const wchar_t separator = L'/';
   const wchar_t* const separators = L"/\\";
   const wchar_t* separator_string = L"/";
   const wchar_t* preferred_separator_string = L"\\";
   const wchar_t colon = L':';
-  const wchar_t dot = L'.';
   const wchar_t questionmark = L'?';
 
   inline bool is_letter(wchar_t c)
@@ -88,23 +86,12 @@ namespace
 
 # else
 
-  const char separator = '/';
   const char* const separators = "/";
   const char* separator_string = "/";
   const char* preferred_separator_string = "/";
-  const char dot = '.';
 
 # endif
 
-  inline bool is_separator(fs::path::value_type c)
-  {
-    return c == separator
-#     ifdef BOOST_WINDOWS_API
-      || c == path::preferred_separator
-#     endif
-      ;
-  }
-
   bool is_root_separator(const string_type& str, size_type pos);
     // pos is position of the separator
 
@@ -145,13 +132,13 @@ namespace filesystem
     if (this == &p)  // self-append
     {
       path rhs(p);
-      if (!is_separator(rhs.m_pathname[0]))
+      if (!detail::is_directory_separator(rhs.m_pathname[0]))
         m_append_separator_if_needed();
       m_pathname += rhs.m_pathname;
     }
     else
     {
-      if (!is_separator(*p.m_pathname.begin()))
+      if (!detail::is_directory_separator(*p.m_pathname.begin()))
         m_append_separator_if_needed();
       m_pathname += p.m_pathname;
     }
@@ -166,13 +153,13 @@ namespace filesystem
       && ptr < m_pathname.data() + m_pathname.size())  // overlapping source
     {
       path rhs(ptr);
-      if (!is_separator(rhs.m_pathname[0]))
+      if (!detail::is_directory_separator(rhs.m_pathname[0]))
         m_append_separator_if_needed();
       m_pathname += rhs.m_pathname;
     }
     else
     {
-      if (!is_separator(*ptr))
+      if (!detail::is_directory_separator(*ptr))
         m_append_separator_if_needed();
       m_pathname += ptr;
     }
@@ -217,7 +204,7 @@ namespace filesystem
 #     ifdef BOOST_WINDOWS_API
       *(m_pathname.end()-1) != colon && 
 #     endif
-      !is_separator(*(m_pathname.end()-1)))
+      !detail::is_directory_separator(*(m_pathname.end()-1)))
     {
       string_type::size_type tmp(m_pathname.size());
       m_pathname += preferred_separator;
@@ -257,7 +244,8 @@ namespace filesystem
 
   path&  path::remove_trailing_separator()
   {
-    if (!m_pathname.empty() && is_separator(m_pathname[m_pathname.size() - 1]))
+    if (!m_pathname.empty()
+      && detail::is_directory_separator(m_pathname[m_pathname.size() - 1]))
       m_pathname.erase(m_pathname.size() - 1);
     return *this;
   }
@@ -294,8 +282,8 @@ namespace filesystem
     return (itr.m_pos != m_pathname.size()
       && (
           (itr.m_element.m_pathname.size() > 1
-            && is_separator(itr.m_element.m_pathname[0])
-            && is_separator(itr.m_element.m_pathname[1])
+            && detail::is_directory_separator(itr.m_element.m_pathname[0])
+            && detail::is_directory_separator(itr.m_element.m_pathname[1])
    )
 #       ifdef BOOST_WINDOWS_API
         || itr.m_element.m_pathname[itr.m_element.m_pathname.size()-1] == colon
@@ -319,7 +307,7 @@ namespace filesystem
     iterator itr(begin());
 
     for (; itr.m_pos != m_pathname.size()
-      && (is_separator(itr.m_element.m_pathname[0])
+      && (detail::is_directory_separator(itr.m_element.m_pathname[0])
 #     ifdef BOOST_WINDOWS_API
       || itr.m_element.m_pathname[itr.m_element.m_pathname.size()-1] == colon
 #     endif
@@ -333,14 +321,14 @@ namespace filesystem
     size_type end_pos(filename_pos(m_pathname, m_pathname.size()));
 
     bool filename_was_separator(m_pathname.size()
-      && is_separator(m_pathname[end_pos]));
+      && detail::is_directory_separator(m_pathname[end_pos]));
 
     // skip separators unless root directory
     size_type root_dir_pos(root_directory_start(m_pathname, end_pos));
     for (; 
       end_pos > 0
       && (end_pos-1) != root_dir_pos
-      && is_separator(m_pathname[end_pos-1])
+      && detail::is_directory_separator(m_pathname[end_pos-1])
       ;
       --end_pos) {}
 
@@ -362,7 +350,7 @@ namespace filesystem
     size_type pos(filename_pos(m_pathname, m_pathname.size()));
     return (m_pathname.size()
               && pos
-              && is_separator(m_pathname[pos])
+              && detail::is_directory_separator(m_pathname[pos])
               && !is_root_separator(m_pathname, pos))
       ? detail::dot_path()
       : path(m_pathname.c_str() + pos);
@@ -513,11 +501,11 @@ namespace
   bool is_root_separator(const string_type & str, size_type pos)
     // pos is position of the separator
   {
-    BOOST_ASSERT_MSG(!str.empty() && is_separator(str[pos]),
+    BOOST_ASSERT_MSG(!str.empty() && fs::detail::is_directory_separator(str[pos]),
       "precondition violation");
 
     // subsequent logic expects pos to be for leftmost slash of a set
-    while (pos > 0 && is_separator(str[pos-1]))
+    while (pos > 0 && fs::detail::is_directory_separator(str[pos-1]))
       --pos;
 
     //  "/" [...]
@@ -531,7 +519,8 @@ namespace
 # endif
 
     //  "//" name "/"
-    if (pos < 3 || !is_separator(str[0]) || !is_separator(str[1]))
+    if (pos < 3 || !fs::detail::is_directory_separator(str[0])
+      || !fs::detail::is_directory_separator(str[1]))
       return false;
 
     return str.find_first_of(separators, 2) == pos;
@@ -545,11 +534,11 @@ namespace
   {
     // case: "//"
     if (end_pos == 2 
-      && is_separator(str[0])
-      && is_separator(str[1])) return 0;
+      && fs::detail::is_directory_separator(str[0])
+      && fs::detail::is_directory_separator(str[1])) return 0;
 
     // case: ends in "/"
-    if (end_pos && is_separator(str[end_pos-1]))
+    if (end_pos && fs::detail::is_directory_separator(str[end_pos-1]))
       return end_pos-1;
     
     // set pos to start of last element
@@ -561,7 +550,7 @@ namespace
 #   endif
 
     return (pos == string_type::npos // path itself must be a filename (or empty)
-      || (pos == 1 && is_separator(str[0]))) // or net
+      || (pos == 1 && fs::detail::is_directory_separator(str[0]))) // or net
         ? 0 // so filename is entire string
         : pos + 1; // or starts after delimiter
   }
@@ -576,21 +565,21 @@ namespace
     // case "c:/"
     if (size > 2
       && path[1] == colon
-      && is_separator(path[2])) return 2;
+      && fs::detail::is_directory_separator(path[2])) return 2;
 #   endif
 
     // case "//"
     if (size == 2
-      && is_separator(path[0])
-      && is_separator(path[1])) return string_type::npos;
+      && fs::detail::is_directory_separator(path[0])
+      && fs::detail::is_directory_separator(path[1])) return string_type::npos;
 
 #   ifdef BOOST_WINDOWS_API
     // case "\\?\"
     if (size > 4
-      && is_separator(path[0])
-      && is_separator(path[1])
+      && fs::detail::is_directory_separator(path[0])
+      && fs::detail::is_directory_separator(path[1])
       && path[2] == questionmark
-      && is_separator(path[3]))
+      && fs::detail::is_directory_separator(path[3]))
     {
       string_type::size_type pos(path.find_first_of(separators, 4));
         return pos < size ? pos : string_type::npos;
@@ -599,16 +588,16 @@ namespace
 
     // case "//net {/}"
     if (size > 3
-      && is_separator(path[0])
-      && is_separator(path[1])
-      && !is_separator(path[2]))
+      && fs::detail::is_directory_separator(path[0])
+      && fs::detail::is_directory_separator(path[1])
+      && !fs::detail::is_directory_separator(path[2]))
     {
       string_type::size_type pos(path.find_first_of(separators, 2));
       return pos < size ? pos : string_type::npos;
     }
     
     // case "/"
-    if (size > 0 && is_separator(path[0])) return 0;
+    if (size > 0 && fs::detail::is_directory_separator(path[0])) return 0;
 
     return string_type::npos;
   }
@@ -632,22 +621,22 @@ namespace
     string_type::size_type cur(0);
     
     // deal with // [network]
-    if (size >= 2 && is_separator(src[0])
-      && is_separator(src[1])
+    if (size >= 2 && fs::detail::is_directory_separator(src[0])
+      && fs::detail::is_directory_separator(src[1])
       && (size == 2
-        || !is_separator(src[2])))
+        || !fs::detail::is_directory_separator(src[2])))
     { 
       cur += 2;
       element_size += 2;
     }
 
     // leading (not non-network) separator
-    else if (is_separator(src[0]))
+    else if (fs::detail::is_directory_separator(src[0]))
     {
       ++element_size;
       // bypass extra leading separators
       while (cur+1 < size
-        && is_separator(src[cur+1]))
+        && fs::detail::is_directory_separator(src[cur+1]))
       {
         ++cur;
         ++element_pos;
@@ -663,7 +652,7 @@ namespace
 #     ifdef BOOST_WINDOWS_API
       && src[cur] != colon
 #     endif
-      && !is_separator(src[cur]))
+      && !fs::detail::is_directory_separator(src[cur]))
     {
       ++cur;
       ++element_size;
@@ -772,12 +761,12 @@ namespace filesystem
 
     // both POSIX and Windows treat paths that begin with exactly two separators specially
     bool was_net(it.m_element.m_pathname.size() > 2
-      && is_separator(it.m_element.m_pathname[0])
-      && is_separator(it.m_element.m_pathname[1])
-      && !is_separator(it.m_element.m_pathname[2]));
+      && detail::is_directory_separator(it.m_element.m_pathname[0])
+      && detail::is_directory_separator(it.m_element.m_pathname[1])
+      && !detail::is_directory_separator(it.m_element.m_pathname[2]));
 
     // process separator (Windows drive spec is only case not a separator)
-    if (is_separator(it.m_path_ptr->m_pathname[it.m_pos]))
+    if (detail::is_directory_separator(it.m_path_ptr->m_pathname[it.m_pos]))
     {
       // detect root directory
       if (was_net
@@ -793,7 +782,7 @@ namespace filesystem
 
       // skip separators until it.m_pos points to the start of the next element
       while (it.m_pos != it.m_path_ptr->m_pathname.size()
-        && is_separator(it.m_path_ptr->m_pathname[it.m_pos]))
+        && detail::is_directory_separator(it.m_path_ptr->m_pathname[it.m_pos]))
         { ++it.m_pos; }
 
       // detect trailing separator, and treat it as ".", per POSIX spec
@@ -822,7 +811,7 @@ namespace filesystem
     // if at end and there was a trailing non-root '/', return "."
     if (it.m_pos == it.m_path_ptr->m_pathname.size()
       && it.m_path_ptr->m_pathname.size() > 1
-      && is_separator(it.m_path_ptr->m_pathname[it.m_pos-1])
+      && detail::is_directory_separator(it.m_path_ptr->m_pathname[it.m_pos-1])
       && !is_root_separator(it.m_path_ptr->m_pathname, it.m_pos-1) 
        )
     {
@@ -838,7 +827,7 @@ namespace filesystem
       ; 
       end_pos > 0
       && (end_pos-1) != root_dir_pos
-      && is_separator(it.m_path_ptr->m_pathname[end_pos-1])
+      && detail::is_directory_separator(it.m_path_ptr->m_pathname[end_pos-1])
       ;
       --end_pos) {}
 
diff --git a/contrib/libboost/boost_1_62_0/libs/filesystem/src/path_traits.cpp b/contrib/libboost/boost_1_65_0/libs/filesystem/src/path_traits.cpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/libs/filesystem/src/path_traits.cpp
rename to contrib/libboost/boost_1_65_0/libs/filesystem/src/path_traits.cpp
diff --git a/contrib/libboost/boost_1_62_0/libs/filesystem/src/portability.cpp b/contrib/libboost/boost_1_65_0/libs/filesystem/src/portability.cpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/libs/filesystem/src/portability.cpp
rename to contrib/libboost/boost_1_65_0/libs/filesystem/src/portability.cpp
diff --git a/contrib/libboost/boost_1_62_0/libs/filesystem/src/unique_path.cpp b/contrib/libboost/boost_1_65_0/libs/filesystem/src/unique_path.cpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/libs/filesystem/src/unique_path.cpp
rename to contrib/libboost/boost_1_65_0/libs/filesystem/src/unique_path.cpp
index d88cbb852eb..1b05c83944b 100644
--- a/contrib/libboost/boost_1_62_0/libs/filesystem/src/unique_path.cpp
+++ b/contrib/libboost/boost_1_65_0/libs/filesystem/src/unique_path.cpp
@@ -28,7 +28,9 @@
 # else // BOOST_WINDOWS_API
 #   include <windows.h>
 #   include <wincrypt.h>
-#   pragma comment(lib, "Advapi32.lib")
+#   ifdef _MSC_VER
+#      pragma comment(lib, "Advapi32.lib")
+#   endif
 # endif
 
 namespace {
diff --git a/contrib/libboost/boost_1_62_0/libs/filesystem/src/utf8_codecvt_facet.cpp b/contrib/libboost/boost_1_65_0/libs/filesystem/src/utf8_codecvt_facet.cpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/libs/filesystem/src/utf8_codecvt_facet.cpp
rename to contrib/libboost/boost_1_65_0/libs/filesystem/src/utf8_codecvt_facet.cpp
diff --git a/contrib/libboost/boost_1_62_0/libs/filesystem/src/windows_file_codecvt.cpp b/contrib/libboost/boost_1_65_0/libs/filesystem/src/windows_file_codecvt.cpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/libs/filesystem/src/windows_file_codecvt.cpp
rename to contrib/libboost/boost_1_65_0/libs/filesystem/src/windows_file_codecvt.cpp
diff --git a/contrib/libboost/boost_1_62_0/libs/filesystem/src/windows_file_codecvt.hpp b/contrib/libboost/boost_1_65_0/libs/filesystem/src/windows_file_codecvt.hpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/libs/filesystem/src/windows_file_codecvt.hpp
rename to contrib/libboost/boost_1_65_0/libs/filesystem/src/windows_file_codecvt.hpp
diff --git a/contrib/libboost/boost_1_62_0/libs/program_options/src/cmdline.cpp b/contrib/libboost/boost_1_65_0/libs/program_options/src/cmdline.cpp
similarity index 98%
rename from contrib/libboost/boost_1_62_0/libs/program_options/src/cmdline.cpp
rename to contrib/libboost/boost_1_65_0/libs/program_options/src/cmdline.cpp
index 49c7c93df94..5f8dc24109e 100644
--- a/contrib/libboost/boost_1_62_0/libs/program_options/src/cmdline.cpp
+++ b/contrib/libboost/boost_1_65_0/libs/program_options/src/cmdline.cpp
@@ -313,9 +313,6 @@ namespace boost { namespace program_options { namespace detail {
             if (!xd)
                 continue;
 
-            if (xd->semantic()->adjacent_tokens_only())
-                continue;
-
             unsigned min_tokens = xd->semantic()->min_tokens();
             unsigned max_tokens = xd->semantic()->max_tokens();
             if (min_tokens < max_tokens && opt.value.size() < max_tokens)
@@ -437,9 +434,6 @@ namespace boost { namespace program_options { namespace detail {
             // (the value in --foo=1) counts as a separate token, and if present
             // must be consumed. The following tokens on the command line may be
             // left unconsumed.
-
-            // We don't check if those tokens look like option, or not!
-
             unsigned min_tokens = d.semantic()->min_tokens();
             unsigned max_tokens = d.semantic()->max_tokens();
             
@@ -453,9 +447,8 @@ namespace boost { namespace program_options { namespace detail {
                         invalid_command_line_syntax(invalid_command_line_syntax::extra_parameter));
                 }
                 
-                // If an option wants, at minimum, N tokens, we grab them there,
-                // when adding these tokens as values to current option we check
-                // if they look like options
+                // Grab min_tokens values from other_tokens, but only if those tokens
+                // are not recognized as options themselves.
                 if (opt.value.size() <= min_tokens) 
                 {
                     min_tokens -= static_cast<unsigned>(opt.value.size());
@@ -465,7 +458,7 @@ namespace boost { namespace program_options { namespace detail {
                     min_tokens = 0;
                 }
 
-                // Everything's OK, move the values to the result.            
+                // Everything's OK, move the values to the result.
                 for(;!other_tokens.empty() && min_tokens--; ) 
                 {
                     // check if extra parameter looks like a known option
diff --git a/contrib/libboost/boost_1_62_0/libs/program_options/src/config_file.cpp b/contrib/libboost/boost_1_65_0/libs/program_options/src/config_file.cpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/libs/program_options/src/config_file.cpp
rename to contrib/libboost/boost_1_65_0/libs/program_options/src/config_file.cpp
diff --git a/contrib/libboost/boost_1_62_0/libs/program_options/src/convert.cpp b/contrib/libboost/boost_1_65_0/libs/program_options/src/convert.cpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/libs/program_options/src/convert.cpp
rename to contrib/libboost/boost_1_65_0/libs/program_options/src/convert.cpp
diff --git a/contrib/libboost/boost_1_62_0/libs/program_options/src/options_description.cpp b/contrib/libboost/boost_1_65_0/libs/program_options/src/options_description.cpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/libs/program_options/src/options_description.cpp
rename to contrib/libboost/boost_1_65_0/libs/program_options/src/options_description.cpp
diff --git a/contrib/libboost/boost_1_62_0/libs/program_options/src/parsers.cpp b/contrib/libboost/boost_1_65_0/libs/program_options/src/parsers.cpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/libs/program_options/src/parsers.cpp
rename to contrib/libboost/boost_1_65_0/libs/program_options/src/parsers.cpp
diff --git a/contrib/libboost/boost_1_62_0/libs/program_options/src/positional_options.cpp b/contrib/libboost/boost_1_65_0/libs/program_options/src/positional_options.cpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/libs/program_options/src/positional_options.cpp
rename to contrib/libboost/boost_1_65_0/libs/program_options/src/positional_options.cpp
diff --git a/contrib/libboost/boost_1_62_0/libs/program_options/src/split.cpp b/contrib/libboost/boost_1_65_0/libs/program_options/src/split.cpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/libs/program_options/src/split.cpp
rename to contrib/libboost/boost_1_65_0/libs/program_options/src/split.cpp
diff --git a/contrib/libboost/boost_1_62_0/libs/program_options/src/utf8_codecvt_facet.cpp b/contrib/libboost/boost_1_65_0/libs/program_options/src/utf8_codecvt_facet.cpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/libs/program_options/src/utf8_codecvt_facet.cpp
rename to contrib/libboost/boost_1_65_0/libs/program_options/src/utf8_codecvt_facet.cpp
diff --git a/contrib/libboost/boost_1_62_0/libs/program_options/src/value_semantic.cpp b/contrib/libboost/boost_1_65_0/libs/program_options/src/value_semantic.cpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/libs/program_options/src/value_semantic.cpp
rename to contrib/libboost/boost_1_65_0/libs/program_options/src/value_semantic.cpp
diff --git a/contrib/libboost/boost_1_62_0/libs/program_options/src/variables_map.cpp b/contrib/libboost/boost_1_65_0/libs/program_options/src/variables_map.cpp
similarity index 97%
rename from contrib/libboost/boost_1_62_0/libs/program_options/src/variables_map.cpp
rename to contrib/libboost/boost_1_65_0/libs/program_options/src/variables_map.cpp
index 9a6c5060fd6..bc85f7e34b6 100644
--- a/contrib/libboost/boost_1_62_0/libs/program_options/src/variables_map.cpp
+++ b/contrib/libboost/boost_1_65_0/libs/program_options/src/variables_map.cpp
@@ -42,16 +42,15 @@ namespace boost { namespace program_options {
         string option_name;
         string original_token;
 
+#ifndef BOOST_NO_EXCEPTIONS
         try
+#endif
         {
 
             // First, convert/store all given options
             for (i = 0; i < options.options.size(); ++i) {
 
                 option_name = options.options[i].string_key;
-                original_token = options.options[i].original_tokens.size() ?
-                                options.options[i].original_tokens[0] :
-                                option_name;
                 // Skip positional options without name
                 if (option_name.empty())
                     continue;
@@ -68,7 +67,7 @@ namespace boost { namespace program_options {
                 if (xm.m_final.count(option_name))
                     continue;
 
-                string original_token = options.options[i].original_tokens.size() ?
+                original_token = options.options[i].original_tokens.size() ?
                                         options.options[i].original_tokens[0]     : "";
                 const option_description& d = desc.find(option_name, false,
                                                         false, false);
diff --git a/contrib/libboost/boost_1_62_0/libs/program_options/src/winmain.cpp b/contrib/libboost/boost_1_65_0/libs/program_options/src/winmain.cpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/libs/program_options/src/winmain.cpp
rename to contrib/libboost/boost_1_65_0/libs/program_options/src/winmain.cpp
diff --git a/contrib/libboost/boost_1_62_0/libs/system/src/error_code.cpp b/contrib/libboost/boost_1_65_0/libs/system/src/error_code.cpp
similarity index 100%
rename from contrib/libboost/boost_1_62_0/libs/system/src/error_code.cpp
rename to contrib/libboost/boost_1_65_0/libs/system/src/error_code.cpp

From b4d7d8f1dec4a2ca8cd105b841a06e0659426aee Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Mon, 4 Sep 2017 22:30:52 +0300
Subject: [PATCH 069/266] Added missing files [#CLICKHOUSE-3276].

---
 .../boost_1_65_0/boost/core/addressof.hpp     | 274 +++++++++++
 .../boost/core/checked_delete.hpp             |  69 +++
 .../boost_1_65_0/boost/core/demangle.hpp      | 126 +++++
 .../boost_1_65_0/boost/core/enable_if.hpp     | 128 +++++
 .../boost/core/explicit_operator_bool.hpp     | 154 ++++++
 .../boost_1_65_0/boost/core/ignore_unused.hpp |  70 +++
 .../boost_1_65_0/boost/core/is_same.hpp       |  40 ++
 .../boost/core/lightweight_test.hpp           | 465 ++++++++++++++++++
 .../boost/core/lightweight_test_trait.hpp     |  56 +++
 .../boost/core/no_exceptions_support.hpp      |  44 ++
 .../boost_1_65_0/boost/core/noncopyable.hpp   |  48 ++
 .../boost_1_65_0/boost/core/null_deleter.hpp  |  44 ++
 .../boost/core/pointer_traits.hpp             | 258 ++++++++++
 .../libboost/boost_1_65_0/boost/core/ref.hpp  | 301 ++++++++++++
 .../boost_1_65_0/boost/core/scoped_enum.hpp   | 194 ++++++++
 .../libboost/boost_1_65_0/boost/core/swap.hpp |  60 +++
 .../boost_1_65_0/boost/core/typeinfo.hpp      | 151 ++++++
 .../boost/core/underlying_type.hpp            |  79 +++
 18 files changed, 2561 insertions(+)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/core/addressof.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/core/checked_delete.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/core/demangle.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/core/enable_if.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/core/explicit_operator_bool.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/core/ignore_unused.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/core/is_same.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/core/lightweight_test.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/core/lightweight_test_trait.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/core/no_exceptions_support.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/core/noncopyable.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/core/null_deleter.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/core/pointer_traits.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/core/ref.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/core/scoped_enum.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/core/swap.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/core/typeinfo.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/core/underlying_type.hpp

diff --git a/contrib/libboost/boost_1_65_0/boost/core/addressof.hpp b/contrib/libboost/boost_1_65_0/boost/core/addressof.hpp
new file mode 100644
index 00000000000..8ddda8be4a9
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/core/addressof.hpp
@@ -0,0 +1,274 @@
+/*
+Copyright (C) 2002 Brad King (brad.king@kitware.com)
+                   Douglas Gregor (gregod@cs.rpi.edu)
+
+Copyright (C) 2002, 2008, 2013 Peter Dimov
+
+Copyright (C) 2017 Glen Joseph Fernandes (glenjofe@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)
+*/
+
+#ifndef BOOST_CORE_ADDRESSOF_HPP
+#define BOOST_CORE_ADDRESSOF_HPP
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC_FULL_VER) && BOOST_MSVC_FULL_VER >= 190024215
+#define BOOST_CORE_HAS_BUILTIN_ADDRESSOF
+#elif defined(BOOST_GCC) && BOOST_GCC >= 70000
+#define BOOST_CORE_HAS_BUILTIN_ADDRESSOF
+#elif defined(__has_builtin)
+#if __has_builtin(__builtin_addressof)
+#define BOOST_CORE_HAS_BUILTIN_ADDRESSOF
+#endif
+#endif
+
+#if defined(BOOST_CORE_HAS_BUILTIN_ADDRESSOF)
+#if defined(BOOST_NO_CXX11_CONSTEXPR)
+#define BOOST_CORE_NO_CONSTEXPR_ADDRESSOF
+#endif
+
+namespace boost {
+
+template<class T>
+BOOST_CONSTEXPR inline T*
+addressof(T& o) BOOST_NOEXCEPT
+{
+    return __builtin_addressof(o);
+}
+
+} /* boost */
+#else
+#include <boost/config/workaround.hpp>
+#include <cstddef>
+
+namespace boost {
+namespace detail {
+
+template<class T>
+class addressof_ref {
+public:
+    BOOST_FORCEINLINE addressof_ref(T& o) BOOST_NOEXCEPT
+        : o_(o) { }
+    BOOST_FORCEINLINE operator T&() const BOOST_NOEXCEPT {
+        return o_;
+    }
+private:
+    addressof_ref& operator=(const addressof_ref&);
+    T& o_;
+};
+
+template<class T>
+struct address_of {
+    static BOOST_FORCEINLINE T* get(T& o, long) BOOST_NOEXCEPT {
+        return reinterpret_cast<T*>(&
+            const_cast<char&>(reinterpret_cast<const volatile char&>(o)));
+    }
+    static BOOST_FORCEINLINE T* get(T* p, int) BOOST_NOEXCEPT {
+        return p;
+    }
+};
+
+#if !defined(BOOST_NO_CXX11_NULLPTR)
+#if !defined(BOOST_NO_CXX11_DECLTYPE) && \
+    (defined(__INTEL_COMPILER) || \
+        (defined(__clang__) && !defined(_LIBCPP_VERSION)))
+typedef decltype(nullptr) addressof_null_t;
+#else
+typedef std::nullptr_t addressof_null_t;
+#endif
+
+template<>
+struct address_of<addressof_null_t> {
+    typedef addressof_null_t type;
+    static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT {
+        return &o;
+    }
+};
+
+template<>
+struct address_of<const addressof_null_t> {
+    typedef const addressof_null_t type;
+    static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT {
+        return &o;
+    }
+};
+
+template<>
+struct address_of<volatile addressof_null_t> {
+    typedef volatile addressof_null_t type;
+    static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT {
+        return &o;
+    }
+};
+
+template<>
+struct address_of<const volatile addressof_null_t> {
+    typedef const volatile addressof_null_t type;
+    static BOOST_FORCEINLINE type* get(type& o, int) BOOST_NOEXCEPT {
+        return &o;
+    }
+};
+#endif
+
+} /* detail */
+
+#if defined(BOOST_NO_CXX11_SFINAE_EXPR) || \
+    defined(BOOST_NO_CXX11_CONSTEXPR) || \
+    defined(BOOST_NO_CXX11_DECLTYPE)
+#define BOOST_CORE_NO_CONSTEXPR_ADDRESSOF
+
+template<class T>
+BOOST_FORCEINLINE T*
+addressof(T& o) BOOST_NOEXCEPT
+{
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x610)) || \
+    BOOST_WORKAROUND(__SUNPRO_CC, <= 0x5120)
+    return detail::address_of<T>::get(o, 0);
+#else
+    return detail::address_of<T>::get(detail::addressof_ref<T>(o), 0);
+#endif
+}
+
+#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x590))
+namespace detail {
+
+template<class T>
+struct addressof_result {
+    typedef T* type;
+};
+
+} /* detail */
+
+template<class T, std::size_t N>
+BOOST_FORCEINLINE typename detail::addressof_result<T[N]>::type
+addressof(T (&o)[N]) BOOST_NOEXCEPT
+{
+    return &o;
+}
+#endif
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+template<class T, std::size_t N>
+BOOST_FORCEINLINE
+T (*addressof(T (&o)[N]) BOOST_NOEXCEPT)[N]
+{
+   return reinterpret_cast<T(*)[N]>(&o);
+}
+
+template<class T, std::size_t N>
+BOOST_FORCEINLINE
+const T (*addressof(const T (&o)[N]) BOOST_NOEXCEPT)[N]
+{
+   return reinterpret_cast<const T(*)[N]>(&o);
+}
+#endif
+#else
+namespace detail {
+
+template<class T>
+T addressof_declval() BOOST_NOEXCEPT;
+
+template<class>
+struct addressof_void {
+    typedef void type;
+};
+
+template<class T, class E = void>
+struct addressof_member_operator {
+    static constexpr bool value = false;
+};
+
+template<class T>
+struct addressof_member_operator<T, typename
+    addressof_void<decltype(addressof_declval<T&>().operator&())>::type> {
+    static constexpr bool value = true;
+};
+
+#if BOOST_WORKAROUND(BOOST_INTEL, < 1600)
+struct addressof_addressable { };
+
+addressof_addressable*
+operator&(addressof_addressable&) BOOST_NOEXCEPT;
+#endif
+
+template<class T, class E = void>
+struct addressof_non_member_operator {
+    static constexpr bool value = false;
+};
+
+template<class T>
+struct addressof_non_member_operator<T, typename
+    addressof_void<decltype(operator&(addressof_declval<T&>()))>::type> {
+    static constexpr bool value = true;
+};
+
+template<class T, class E = void>
+struct addressof_expression {
+    static constexpr bool value = false;
+};
+
+template<class T>
+struct addressof_expression<T,
+    typename addressof_void<decltype(&addressof_declval<T&>())>::type> {
+    static constexpr bool value = true;
+};
+
+template<class T>
+struct addressof_is_constexpr {
+    static constexpr bool value = addressof_expression<T>::value &&
+        !addressof_member_operator<T>::value &&
+        !addressof_non_member_operator<T>::value;
+};
+
+template<bool E, class T>
+struct addressof_if { };
+
+template<class T>
+struct addressof_if<true, T> {
+    typedef T* type;
+};
+
+template<class T>
+BOOST_FORCEINLINE
+typename addressof_if<!addressof_is_constexpr<T>::value, T>::type
+addressof(T& o) BOOST_NOEXCEPT
+{
+    return address_of<T>::get(addressof_ref<T>(o), 0);
+}
+
+template<class T>
+constexpr BOOST_FORCEINLINE
+typename addressof_if<addressof_is_constexpr<T>::value, T>::type
+addressof(T& o) BOOST_NOEXCEPT
+{
+    return &o;
+}
+
+} /* detail */
+
+template<class T>
+constexpr BOOST_FORCEINLINE T*
+addressof(T& o) BOOST_NOEXCEPT
+{
+    return detail::addressof(o);
+}
+#endif
+
+} /* boost */
+#endif
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && \
+    !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+namespace boost {
+
+template<class T>
+const T* addressof(const T&&) = delete;
+
+} /* boost */
+#endif
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/core/checked_delete.hpp b/contrib/libboost/boost_1_65_0/boost/core/checked_delete.hpp
new file mode 100644
index 00000000000..b086e03e88a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/core/checked_delete.hpp
@@ -0,0 +1,69 @@
+#ifndef BOOST_CORE_CHECKED_DELETE_HPP
+#define BOOST_CORE_CHECKED_DELETE_HPP
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//
+//  boost/checked_delete.hpp
+//
+//  Copyright (c) 2002, 2003 Peter Dimov
+//  Copyright (c) 2003 Daniel Frey
+//  Copyright (c) 2003 Howard Hinnant
+//
+//  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/core/doc/html/core/checked_delete.html for documentation.
+//
+
+namespace boost
+{
+
+// verify that types are complete for increased safety
+
+template<class T> inline void checked_delete(T * x)
+{
+    // intentionally complex - simplification causes regressions
+    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
+    (void) sizeof(type_must_be_complete);
+    delete x;
+}
+
+template<class T> inline void checked_array_delete(T * x)
+{
+    typedef char type_must_be_complete[ sizeof(T)? 1: -1 ];
+    (void) sizeof(type_must_be_complete);
+    delete [] x;
+}
+
+template<class T> struct checked_deleter
+{
+    typedef void result_type;
+    typedef T * argument_type;
+
+    void operator()(T * x) const
+    {
+        // boost:: disables ADL
+        boost::checked_delete(x);
+    }
+};
+
+template<class T> struct checked_array_deleter
+{
+    typedef void result_type;
+    typedef T * argument_type;
+
+    void operator()(T * x) const
+    {
+        boost::checked_array_delete(x);
+    }
+};
+
+} // namespace boost
+
+#endif  // #ifndef BOOST_CORE_CHECKED_DELETE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/core/demangle.hpp b/contrib/libboost/boost_1_65_0/boost/core/demangle.hpp
new file mode 100644
index 00000000000..dc714d806cb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/core/demangle.hpp
@@ -0,0 +1,126 @@
+#ifndef BOOST_CORE_DEMANGLE_HPP_INCLUDED
+#define BOOST_CORE_DEMANGLE_HPP_INCLUDED
+
+// core::demangle
+//
+// Copyright 2014 Peter Dimov
+// Copyright 2014 Andrey Semashev
+//
+// 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
+
+#include <boost/config.hpp>
+#include <string>
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+// __has_include is currently supported by GCC and Clang. However GCC 4.9 may have issues and
+// returns 1 for 'defined( __has_include )', while '__has_include' is actually not supported:
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63662
+#if defined( __has_include ) && (!defined( BOOST_GCC ) || (__GNUC__ + 0) >= 5)
+# if __has_include(<cxxabi.h>)
+#  define BOOST_CORE_HAS_CXXABI_H
+# endif
+#elif defined( __GLIBCXX__ ) || defined( __GLIBCPP__ )
+# define BOOST_CORE_HAS_CXXABI_H
+#endif
+
+#if defined( BOOST_CORE_HAS_CXXABI_H )
+# include <cxxabi.h>
+// For some archtectures (mips, mips64, x86, x86_64) cxxabi.h in Android NDK is implemented by gabi++ library
+// (https://android.googlesource.com/platform/ndk/+/master/sources/cxx-stl/gabi++/), which does not implement
+// abi::__cxa_demangle(). We detect this implementation by checking the include guard here.
+# if defined( __GABIXX_CXXABI_H__ )
+#  undef BOOST_CORE_HAS_CXXABI_H
+# else
+#  include <cstdlib>
+#  include <cstddef>
+# endif
+#endif
+
+namespace boost
+{
+
+namespace core
+{
+
+inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT;
+inline void demangle_free( char const * name ) BOOST_NOEXCEPT;
+
+class scoped_demangled_name
+{
+private:
+    char const * m_p;
+
+public:
+    explicit scoped_demangled_name( char const * name ) BOOST_NOEXCEPT :
+        m_p( demangle_alloc( name ) )
+    {
+    }
+
+    ~scoped_demangled_name() BOOST_NOEXCEPT
+    {
+        demangle_free( m_p );
+    }
+
+    char const * get() const BOOST_NOEXCEPT
+    {
+        return m_p;
+    }
+
+    BOOST_DELETED_FUNCTION(scoped_demangled_name( scoped_demangled_name const& ))
+    BOOST_DELETED_FUNCTION(scoped_demangled_name& operator= ( scoped_demangled_name const& ))
+};
+
+
+#if defined( BOOST_CORE_HAS_CXXABI_H )
+
+inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT
+{
+    int status = 0;
+    std::size_t size = 0;
+    return abi::__cxa_demangle( name, NULL, &size, &status );
+}
+
+inline void demangle_free( char const * name ) BOOST_NOEXCEPT
+{
+    std::free( const_cast< char* >( name ) );
+}
+
+inline std::string demangle( char const * name )
+{
+    scoped_demangled_name demangled_name( name );
+    char const * p = demangled_name.get();
+    if( !p )
+        p = name;
+    return p;
+}
+
+#else
+
+inline char const * demangle_alloc( char const * name ) BOOST_NOEXCEPT
+{
+    return name;
+}
+
+inline void demangle_free( char const * ) BOOST_NOEXCEPT
+{
+}
+
+inline std::string demangle( char const * name )
+{
+    return name;
+}
+
+#endif
+
+} // namespace core
+
+} // namespace boost
+
+#undef BOOST_CORE_HAS_CXXABI_H
+
+#endif // #ifndef BOOST_CORE_DEMANGLE_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_65_0/boost/core/enable_if.hpp b/contrib/libboost/boost_1_65_0/boost/core/enable_if.hpp
new file mode 100644
index 00000000000..5dcef1e0354
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/core/enable_if.hpp
@@ -0,0 +1,128 @@
+// Boost enable_if library
+
+// Copyright 2003 (c) The Trustees of Indiana University.
+
+// 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)
+
+//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
+//             Jeremiah Willcock (jewillco at osl.iu.edu)
+//             Andrew Lumsdaine (lums at osl.iu.edu)
+
+
+#ifndef BOOST_CORE_ENABLE_IF_HPP
+#define BOOST_CORE_ENABLE_IF_HPP
+
+#include "boost/config.hpp"
+
+// Even the definition of enable_if causes problems on some compilers,
+// so it's macroed out for all compilers that do not support SFINAE
+
+#ifndef BOOST_NO_SFINAE
+
+namespace boost
+{
+  template<typename T, typename R=void>
+  struct enable_if_has_type
+  {
+    typedef R type;
+  };
+ 
+  template <bool B, class T = void>
+  struct enable_if_c {
+    typedef T type;
+  };
+
+  template <class T>
+  struct enable_if_c<false, T> {};
+
+  template <class Cond, class T = void> 
+  struct enable_if : public enable_if_c<Cond::value, T> {};
+
+  template <bool B, class T>
+  struct lazy_enable_if_c {
+    typedef typename T::type type;
+  };
+
+  template <class T>
+  struct lazy_enable_if_c<false, T> {};
+
+  template <class Cond, class T> 
+  struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
+
+
+  template <bool B, class T = void>
+  struct disable_if_c {
+    typedef T type;
+  };
+
+  template <class T>
+  struct disable_if_c<true, T> {};
+
+  template <class Cond, class T = void> 
+  struct disable_if : public disable_if_c<Cond::value, T> {};
+
+  template <bool B, class T>
+  struct lazy_disable_if_c {
+    typedef typename T::type type;
+  };
+
+  template <class T>
+  struct lazy_disable_if_c<true, T> {};
+
+  template <class Cond, class T> 
+  struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
+
+} // namespace boost
+
+#else
+
+namespace boost {
+
+  namespace detail { typedef void enable_if_default_T; }
+
+  template <typename T>
+  struct enable_if_does_not_work_on_this_compiler;
+
+  template<typename T, typename R=void>
+  struct enable_if_has_type : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <bool B, class T = detail::enable_if_default_T>
+  struct enable_if_c : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <bool B, class T = detail::enable_if_default_T> 
+  struct disable_if_c : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <bool B, class T = detail::enable_if_default_T> 
+  struct lazy_enable_if_c : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <bool B, class T = detail::enable_if_default_T> 
+  struct lazy_disable_if_c : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <class Cond, class T = detail::enable_if_default_T> 
+  struct enable_if : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <class Cond, class T = detail::enable_if_default_T> 
+  struct disable_if : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <class Cond, class T = detail::enable_if_default_T> 
+  struct lazy_enable_if : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+  template <class Cond, class T = detail::enable_if_default_T> 
+  struct lazy_disable_if : enable_if_does_not_work_on_this_compiler<T>
+  { };
+
+} // namespace boost
+
+#endif // BOOST_NO_SFINAE
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/core/explicit_operator_bool.hpp b/contrib/libboost/boost_1_65_0/boost/core/explicit_operator_bool.hpp
new file mode 100644
index 00000000000..a8936e2cd67
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/core/explicit_operator_bool.hpp
@@ -0,0 +1,154 @@
+/*
+ *          Copyright Andrey Semashev 2007 - 2013.
+ * 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)
+ */
+
+/*!
+ * \file   explicit_operator_bool.hpp
+ * \author Andrey Semashev
+ * \date   08.03.2009
+ *
+ * This header defines a compatibility macro that implements an unspecified
+ * \c bool operator idiom, which is superseded with explicit conversion operators in
+ * C++11.
+ */
+
+#ifndef BOOST_CORE_EXPLICIT_OPERATOR_BOOL_HPP
+#define BOOST_CORE_EXPLICIT_OPERATOR_BOOL_HPP
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
+
+/*!
+ * \brief The macro defines an explicit operator of conversion to \c bool
+ *
+ * The macro should be used inside the definition of a class that has to
+ * support the conversion. The class should also implement <tt>operator!</tt>,
+ * in terms of which the conversion operator will be implemented.
+ */
+#define BOOST_EXPLICIT_OPERATOR_BOOL()\
+    BOOST_FORCEINLINE explicit operator bool () const\
+    {\
+        return !this->operator! ();\
+    }
+
+/*!
+ * \brief The macro defines a noexcept explicit operator of conversion to \c bool
+ *
+ * The macro should be used inside the definition of a class that has to
+ * support the conversion. The class should also implement <tt>operator!</tt>,
+ * in terms of which the conversion operator will be implemented.
+ */
+#define BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()\
+    BOOST_FORCEINLINE explicit operator bool () const BOOST_NOEXCEPT\
+    {\
+        return !this->operator! ();\
+    }
+
+/*!
+ * \brief The macro defines a constexpr explicit operator of conversion to \c bool
+ *
+ * The macro should be used inside the definition of a class that has to
+ * support the conversion. The class should also implement <tt>operator!</tt>,
+ * in terms of which the conversion operator will be implemented.
+ */
+#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\
+    BOOST_FORCEINLINE BOOST_CONSTEXPR explicit operator bool () const BOOST_NOEXCEPT\
+    {\
+        return !this->operator! ();\
+    }
+
+#else // !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
+
+#if (defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)) && !defined(BOOST_NO_COMPILER_CONFIG)
+// Sun C++ 5.3 can't handle the safe_bool idiom, so don't use it
+#define BOOST_NO_UNSPECIFIED_BOOL
+#endif // (defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x530)) && !defined(BOOST_NO_COMPILER_CONFIG)
+
+#if !defined(BOOST_NO_UNSPECIFIED_BOOL)
+
+namespace boost {
+
+namespace detail {
+
+#if !defined(_MSC_VER) && !defined(__IBMCPP__)
+
+    struct unspecified_bool
+    {
+        // NOTE TO THE USER: If you see this in error messages then you tried
+        // to apply an unsupported operator on the object that supports
+        // explicit conversion to bool.
+        struct OPERATORS_NOT_ALLOWED;
+        static void true_value(OPERATORS_NOT_ALLOWED*) {}
+    };
+    typedef void (*unspecified_bool_type)(unspecified_bool::OPERATORS_NOT_ALLOWED*);
+
+#else
+
+    // MSVC and VACPP are too eager to convert pointer to function to void* even though they shouldn't
+    struct unspecified_bool
+    {
+        // NOTE TO THE USER: If you see this in error messages then you tried
+        // to apply an unsupported operator on the object that supports
+        // explicit conversion to bool.
+        struct OPERATORS_NOT_ALLOWED;
+        void true_value(OPERATORS_NOT_ALLOWED*) {}
+    };
+    typedef void (unspecified_bool::*unspecified_bool_type)(unspecified_bool::OPERATORS_NOT_ALLOWED*);
+
+#endif
+
+} // namespace detail
+
+} // namespace boost
+
+#define BOOST_EXPLICIT_OPERATOR_BOOL()\
+    BOOST_FORCEINLINE operator boost::detail::unspecified_bool_type () const\
+    {\
+        return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\
+    }
+
+#define BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()\
+    BOOST_FORCEINLINE operator boost::detail::unspecified_bool_type () const BOOST_NOEXCEPT\
+    {\
+        return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\
+    }
+
+#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\
+    BOOST_FORCEINLINE BOOST_CONSTEXPR operator boost::detail::unspecified_bool_type () const BOOST_NOEXCEPT\
+    {\
+        return (!this->operator! () ? &boost::detail::unspecified_bool::true_value : (boost::detail::unspecified_bool_type)0);\
+    }
+
+#else // !defined(BOOST_NO_UNSPECIFIED_BOOL)
+
+#define BOOST_EXPLICIT_OPERATOR_BOOL()\
+    BOOST_FORCEINLINE operator bool () const\
+    {\
+        return !this->operator! ();\
+    }
+
+#define BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()\
+    BOOST_FORCEINLINE operator bool () const BOOST_NOEXCEPT\
+    {\
+        return !this->operator! ();\
+    }
+
+#define BOOST_CONSTEXPR_EXPLICIT_OPERATOR_BOOL()\
+    BOOST_FORCEINLINE BOOST_CONSTEXPR operator bool () const BOOST_NOEXCEPT\
+    {\
+        return !this->operator! ();\
+    }
+
+#endif // !defined(BOOST_NO_UNSPECIFIED_BOOL)
+
+#endif // !defined(BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS)
+
+#endif // BOOST_CORE_EXPLICIT_OPERATOR_BOOL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/core/ignore_unused.hpp b/contrib/libboost/boost_1_65_0/boost/core/ignore_unused.hpp
new file mode 100644
index 00000000000..994e5f64763
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/core/ignore_unused.hpp
@@ -0,0 +1,70 @@
+// Copyright (c) 2014 Adam Wulkiewicz, Lodz, Poland.
+//
+// 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)
+
+#ifndef BOOST_CORE_IGNORE_UNUSED_HPP
+#define BOOST_CORE_IGNORE_UNUSED_HPP
+
+#include <boost/config.hpp>
+
+namespace boost {
+
+#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+
+template <typename... Ts>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(Ts const& ...)
+{}
+
+template <typename... Ts>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused()
+{}
+
+#else
+
+template <typename T1>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1 const&)
+{}
+
+template <typename T1, typename T2>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1 const&, T2 const&)
+{}
+
+template <typename T1, typename T2, typename T3>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1 const&, T2 const&, T3 const&)
+{}
+
+template <typename T1, typename T2, typename T3, typename T4>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1 const&, T2 const&, T3 const&, T4 const&)
+{}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused(T1 const&, T2 const&, T3 const&, T4 const&, T5 const&)
+{}
+
+template <typename T1>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused()
+{}
+
+template <typename T1, typename T2>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused()
+{}
+
+template <typename T1, typename T2, typename T3>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused()
+{}
+
+template <typename T1, typename T2, typename T3, typename T4>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused()
+{}
+
+template <typename T1, typename T2, typename T3, typename T4, typename T5>
+BOOST_FORCEINLINE BOOST_CXX14_CONSTEXPR void ignore_unused()
+{}
+
+#endif
+
+} // namespace boost
+
+#endif // BOOST_CORE_IGNORE_UNUSED_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/core/is_same.hpp b/contrib/libboost/boost_1_65_0/boost/core/is_same.hpp
new file mode 100644
index 00000000000..f373c654d5e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/core/is_same.hpp
@@ -0,0 +1,40 @@
+#ifndef BOOST_CORE_IS_SAME_HPP_INCLUDED
+#define BOOST_CORE_IS_SAME_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+// is_same<T1,T2>::value is true when T1 == T2
+//
+// Copyright 2014 Peter Dimov
+//
+// 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
+
+#include <boost/config.hpp>
+
+namespace boost
+{
+
+namespace core
+{
+
+template< class T1, class T2 > struct is_same
+{
+    BOOST_STATIC_CONSTANT( bool, value = false );
+};
+
+template< class T > struct is_same< T, T >
+{
+    BOOST_STATIC_CONSTANT( bool, value = true );
+};
+
+} // namespace core
+
+} // namespace boost
+
+#endif // #ifndef BOOST_CORE_IS_SAME_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_65_0/boost/core/lightweight_test.hpp b/contrib/libboost/boost_1_65_0/boost/core/lightweight_test.hpp
new file mode 100644
index 00000000000..603e905bb57
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/core/lightweight_test.hpp
@@ -0,0 +1,465 @@
+#ifndef BOOST_CORE_LIGHTWEIGHT_TEST_HPP
+#define BOOST_CORE_LIGHTWEIGHT_TEST_HPP
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+//
+//  boost/core/lightweight_test.hpp - lightweight test library
+//
+//  Copyright (c) 2002, 2009, 2014 Peter Dimov
+//  Copyright (2) Beman Dawes 2010, 2011
+//  Copyright (3) Ion Gaztanaga 2013
+//
+//  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
+//
+
+#include <boost/core/no_exceptions_support.hpp>
+#include <boost/assert.hpp>
+#include <boost/current_function.hpp>
+#include <iostream>
+#include <iterator>
+#include <cstring>
+#include <cstddef>
+
+//  IDE's like Visual Studio perform better if output goes to std::cout or
+//  some other stream, so allow user to configure output stream:
+#ifndef BOOST_LIGHTWEIGHT_TEST_OSTREAM
+# define BOOST_LIGHTWEIGHT_TEST_OSTREAM std::cerr
+#endif
+
+namespace boost
+{
+
+namespace detail
+{
+
+struct report_errors_reminder
+{
+    bool called_report_errors_function;
+
+    report_errors_reminder() : called_report_errors_function(false) {}
+
+    ~report_errors_reminder()
+    {
+        BOOST_ASSERT(called_report_errors_function);  // verify report_errors() was called  
+    }
+};
+
+inline report_errors_reminder& report_errors_remind()
+{
+    static report_errors_reminder r;
+    return r;
+}
+
+inline int & test_errors()
+{
+    static int x = 0;
+    report_errors_remind();
+    return x;
+}
+
+inline void test_failed_impl(char const * expr, char const * file, int line, char const * function)
+{
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM
+      << file << "(" << line << "): test '" << expr << "' failed in function '"
+      << function << "'" << std::endl;
+    ++test_errors();
+}
+
+inline void error_impl(char const * msg, char const * file, int line, char const * function)
+{
+    BOOST_LIGHTWEIGHT_TEST_OSTREAM
+      << file << "(" << line << "): " << msg << " in function '"
+      << function << "'" << std::endl;
+    ++test_errors();
+}
+
+inline void throw_failed_impl(char const * excep, char const * file, int line, char const * function)
+{
+   BOOST_LIGHTWEIGHT_TEST_OSTREAM
+    << file << "(" << line << "): Exception '" << excep << "' not thrown in function '"
+    << function << "'" << std::endl;
+   ++test_errors();
+}
+
+// In the comparisons below, it is possible that T and U are signed and unsigned integer types, which generates warnings in some compilers.
+// A cleaner fix would require common_type trait or some meta-programming, which would introduce a dependency on Boost.TypeTraits. To avoid
+// the dependency we just disable the warnings.
+#if defined(_MSC_VER)
+# pragma warning(push)
+# pragma warning(disable: 4389)
+#elif defined(__clang__) && defined(__has_warning)
+# if __has_warning("-Wsign-compare")
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wsign-compare"
+# endif
+#elif defined(__GNUC__) && !(defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 406
+# pragma GCC diagnostic push
+# pragma GCC diagnostic ignored "-Wsign-compare"
+#endif
+
+// specialize test output for char pointers to avoid printing as cstring
+template <class T> inline const T& test_output_impl(const T& v) { return v; }
+inline const void* test_output_impl(const char* v) { return v; }
+inline const void* test_output_impl(const unsigned char* v) { return v; }
+inline const void* test_output_impl(const signed char* v) { return v; }
+inline const void* test_output_impl(char* v) { return v; }
+inline const void* test_output_impl(unsigned char* v) { return v; }
+inline const void* test_output_impl(signed char* v) { return v; }
+template<class T> inline const void* test_output_impl(T volatile* v) { return const_cast<T*>(v); }
+
+#if !defined( BOOST_NO_CXX11_NULLPTR )
+inline const void* test_output_impl(std::nullptr_t v) { return v; }
+#endif
+
+template<class T, class U> inline void test_eq_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, T const & t, U const & u )
+{
+    if( t == u )
+    {
+        report_errors_remind();
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " == " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << test_output_impl(t) << "' != '" << test_output_impl(u) << "'" << std::endl;
+        ++test_errors();
+    }
+}
+
+template<class T, class U> inline void test_ne_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, T const & t, U const & u )
+{
+    if( t != u )
+    {
+        report_errors_remind();
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " != " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << test_output_impl(t) << "' == '" << test_output_impl(u) << "'" << std::endl;
+        ++test_errors();
+    }
+}
+
+template<class T, class U> inline void test_lt_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, T const & t, U const & u )
+{
+    if( t < u )
+    {
+        report_errors_remind();
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " < " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << test_output_impl(t) << "' >= '" << test_output_impl(u) << "'" << std::endl;
+        ++test_errors();
+    }
+}
+
+template<class T, class U> inline void test_le_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, T const & t, U const & u )
+{
+    if( t <= u )
+    {
+        report_errors_remind();
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " <= " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << test_output_impl(t) << "' > '" << test_output_impl(u) << "'" << std::endl;
+        ++test_errors();
+    }
+}
+
+template<class T, class U> inline void test_gt_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, T const & t, U const & u )
+{
+    if( t > u )
+    {
+        report_errors_remind();
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " > " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << test_output_impl(t) << "' <= '" << test_output_impl(u) << "'" << std::endl;
+        ++test_errors();
+    }
+}
+
+template<class T, class U> inline void test_ge_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, T const & t, U const & u )
+{
+    if( t >= u )
+    {
+        report_errors_remind();
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " >= " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << test_output_impl(t) << "' < '" << test_output_impl(u) << "'" << std::endl;
+        ++test_errors();
+    }
+}
+
+inline void test_cstr_eq_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, char const * const t, char const * const u )
+{
+    if( std::strcmp(t, u) == 0 )
+    {
+        report_errors_remind();
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " == " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << t << "' != '" << u << "'" << std::endl;
+        ++test_errors();
+    }
+}
+
+inline void test_cstr_ne_impl( char const * expr1, char const * expr2,
+  char const * file, int line, char const * function, char const * const t, char const * const u )
+{
+    if( std::strcmp(t, u) != 0 )
+    {
+        report_errors_remind();
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): test '" << expr1 << " == " << expr2
+            << "' failed in function '" << function << "': "
+            << "'" << t << "' == '" << u << "'" << std::endl;
+        ++test_errors();
+    }
+}
+
+template<class FormattedOutputFunction, class InputIterator1, class InputIterator2>
+void test_all_eq_impl(FormattedOutputFunction& output,
+                      char const * file, int line, char const * function,
+                      InputIterator1 first_begin, InputIterator1 first_end,
+                      InputIterator2 second_begin, InputIterator2 second_end)
+{
+    InputIterator1 first_it = first_begin;
+    InputIterator2 second_it = second_begin;
+    typename std::iterator_traits<InputIterator1>::difference_type first_index = 0;
+    typename std::iterator_traits<InputIterator2>::difference_type second_index = 0;
+    std::size_t error_count = 0;
+    const std::size_t max_count = 8;
+    do
+    {
+        while ((first_it != first_end) && (second_it != second_end) && (*first_it == *second_it))
+        {
+            ++first_it;
+            ++second_it;
+            ++first_index;
+            ++second_index;
+        }
+        if ((first_it == first_end) || (second_it == second_end))
+        {
+            break; // do-while
+        }
+        if (error_count == 0)
+        {
+            output << file << "(" << line << "): Container contents differ in function '" << function << "':";
+        }
+        else if (error_count >= max_count)
+        {
+            output << " ...";
+            break;
+        }
+        output << " [" << first_index << "] '" << test_output_impl(*first_it) << "' != '" << test_output_impl(*second_it) << "'";
+        ++first_it;
+        ++second_it;
+        ++first_index;
+        ++second_index;
+        ++error_count;
+    } while (first_it != first_end);
+
+    first_index += std::distance(first_it, first_end);
+    second_index += std::distance(second_it, second_end);
+    if (first_index != second_index)
+    {
+        if (error_count == 0)
+        {
+            output << file << "(" << line << "): Container sizes differ in function '" << function << "': size(" << first_index << ") != size(" << second_index << ")";
+        }
+        else
+        {
+            output << " [*] size(" << first_index << ") != size(" << second_index << ")";
+        }
+        ++error_count;
+    }
+
+    if (error_count == 0)
+    {
+        boost::detail::report_errors_remind();
+    }
+    else
+    {
+        output << std::endl;
+        ++boost::detail::test_errors();
+    }
+}
+
+template<class FormattedOutputFunction, class InputIterator1, class InputIterator2, typename BinaryPredicate>
+void test_all_with_impl(FormattedOutputFunction& output,
+                        char const * file, int line, char const * function,
+                        InputIterator1 first_begin, InputIterator1 first_end,
+                        InputIterator2 second_begin, InputIterator2 second_end,
+                        BinaryPredicate predicate)
+{
+    InputIterator1 first_it = first_begin;
+    InputIterator2 second_it = second_begin;
+    typename std::iterator_traits<InputIterator1>::difference_type first_index = 0;
+    typename std::iterator_traits<InputIterator2>::difference_type second_index = 0;
+    std::size_t error_count = 0;
+    const std::size_t max_count = 8;
+    do
+    {
+        while ((first_it != first_end) && (second_it != second_end) && predicate(*first_it, *second_it))
+        {
+            ++first_it;
+            ++second_it;
+            ++first_index;
+            ++second_index;
+        }
+        if ((first_it == first_end) || (second_it == second_end))
+        {
+            break; // do-while
+        }
+        if (error_count == 0)
+        {
+            output << file << "(" << line << "): Container contents differ in function '" << function << "':";
+        }
+        else if (error_count >= max_count)
+        {
+            output << " ...";
+            break;
+        }
+        output << " [" << first_index << "]";
+        ++first_it;
+        ++second_it;
+        ++first_index;
+        ++second_index;
+        ++error_count;
+    } while (first_it != first_end);
+
+    first_index += std::distance(first_it, first_end);
+    second_index += std::distance(second_it, second_end);
+    if (first_index != second_index)
+    {
+        if (error_count == 0)
+        {
+            output << file << "(" << line << "): Container sizes differ in function '" << function << "': size(" << first_index << ") != size(" << second_index << ")";
+        }
+        else
+        {
+            output << " [*] size(" << first_index << ") != size(" << second_index << ")";
+        }
+        ++error_count;
+    }
+
+    if (error_count == 0)
+    {
+        report_errors_remind();
+    }
+    else
+    {
+        output << std::endl;
+        ++test_errors();
+    }
+}
+
+#if defined(_MSC_VER)
+# pragma warning(pop)
+#elif defined(__clang__) && defined(__has_warning)
+# if __has_warning("-Wsign-compare")
+#  pragma clang diagnostic pop
+# endif
+#elif defined(__GNUC__) && !(defined(__INTEL_COMPILER) || defined(__ICL) || defined(__ICC) || defined(__ECC)) && (__GNUC__ * 100 + __GNUC_MINOR__) >= 406
+# pragma GCC diagnostic pop
+#endif
+
+} // namespace detail
+
+inline int report_errors()
+{
+    boost::detail::report_errors_remind().called_report_errors_function = true;
+
+    int errors = boost::detail::test_errors();
+
+    if( errors == 0 )
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+          << "No errors detected." << std::endl;
+        return 0;
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+          << errors << " error" << (errors == 1? "": "s") << " detected." << std::endl;
+        return 1;
+    }
+}
+
+} // namespace boost
+
+#define BOOST_TEST(expr) ((expr)? (void)0: ::boost::detail::test_failed_impl(#expr, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION))
+#define BOOST_TEST_NOT(expr) BOOST_TEST(!(expr))
+
+#define BOOST_ERROR(msg) ( ::boost::detail::error_impl(msg, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )
+
+#define BOOST_TEST_EQ(expr1,expr2) ( ::boost::detail::test_eq_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define BOOST_TEST_NE(expr1,expr2) ( ::boost::detail::test_ne_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+
+#define BOOST_TEST_LT(expr1,expr2) ( ::boost::detail::test_lt_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define BOOST_TEST_LE(expr1,expr2) ( ::boost::detail::test_le_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define BOOST_TEST_GT(expr1,expr2) ( ::boost::detail::test_gt_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define BOOST_TEST_GE(expr1,expr2) ( ::boost::detail::test_ge_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+
+#define BOOST_TEST_CSTR_EQ(expr1,expr2) ( ::boost::detail::test_cstr_eq_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+#define BOOST_TEST_CSTR_NE(expr1,expr2) ( ::boost::detail::test_cstr_ne_impl(#expr1, #expr2, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, expr1, expr2) )
+
+#define BOOST_TEST_ALL_EQ(begin1, end1, begin2, end2) ( ::boost::detail::test_all_eq_impl(BOOST_LIGHTWEIGHT_TEST_OSTREAM, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, begin1, end1, begin2, end2) )
+#define BOOST_TEST_ALL_WITH(begin1, end1, begin2, end2, predicate) ( ::boost::detail::test_all_with_impl(BOOST_LIGHTWEIGHT_TEST_OSTREAM, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, begin1, end1, begin2, end2, predicate) )
+
+#ifndef BOOST_NO_EXCEPTIONS
+   #define BOOST_TEST_THROWS( EXPR, EXCEP )                    \
+      try {                                                    \
+         EXPR;                                                 \
+         ::boost::detail::throw_failed_impl                    \
+         (#EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
+      }                                                        \
+      catch(EXCEP const&) {                                    \
+      }                                                        \
+      catch(...) {                                             \
+         ::boost::detail::throw_failed_impl                    \
+         (#EXCEP, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION); \
+      }                                                        \
+   //
+#else
+   #define BOOST_TEST_THROWS( EXPR, EXCEP )
+#endif
+
+#endif // #ifndef BOOST_CORE_LIGHTWEIGHT_TEST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/core/lightweight_test_trait.hpp b/contrib/libboost/boost_1_65_0/boost/core/lightweight_test_trait.hpp
new file mode 100644
index 00000000000..0e2aab4435d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/core/lightweight_test_trait.hpp
@@ -0,0 +1,56 @@
+#ifndef BOOST_CORE_LIGHTWEIGHT_TEST_TRAIT_HPP
+#define BOOST_CORE_LIGHTWEIGHT_TEST_TRAIT_HPP
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER)
+# pragma once
+#endif
+
+// boost/core/lightweight_test_trait.hpp
+//
+// BOOST_TEST_TRAIT_TRUE, BOOST_TEST_TRAIT_FALSE
+//
+// Copyright 2014 Peter Dimov
+//
+// 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
+
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/typeinfo.hpp>
+
+namespace boost
+{
+
+namespace detail
+{
+
+template< class T > inline void test_trait_impl( char const * trait, void (*)( T ),
+  bool expected, char const * file, int line, char const * function )
+{
+    if( T::value == expected )
+    {
+        report_errors_remind();
+    }
+    else
+    {
+        BOOST_LIGHTWEIGHT_TEST_OSTREAM
+            << file << "(" << line << "): predicate '" << trait << "' ["
+            << boost::core::demangled_name( BOOST_CORE_TYPEID(T) ) << "]"
+            << " test failed in function '" << function
+            << "' (should have been " << ( expected? "true": "false" ) << ")"
+            << std::endl;
+
+        ++test_errors();
+    }
+}
+
+} // namespace detail
+
+} // namespace boost
+
+#define BOOST_TEST_TRAIT_TRUE(type) ( ::boost::detail::test_trait_impl(#type, (void(*)type)0, true, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )
+#define BOOST_TEST_TRAIT_FALSE(type) ( ::boost::detail::test_trait_impl(#type, (void(*)type)0, false, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )
+
+#endif // #ifndef BOOST_CORE_LIGHTWEIGHT_TEST_TRAIT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/core/no_exceptions_support.hpp b/contrib/libboost/boost_1_65_0/boost/core/no_exceptions_support.hpp
new file mode 100644
index 00000000000..e2453d084ba
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/core/no_exceptions_support.hpp
@@ -0,0 +1,44 @@
+#ifndef BOOST_CORE_NO_EXCEPTIONS_SUPPORT_HPP
+#define BOOST_CORE_NO_EXCEPTIONS_SUPPORT_HPP
+
+#if defined(_MSC_VER)
+#  pragma once
+#endif
+
+//----------------------------------------------------------------------
+// (C) Copyright 2004 Pavel Vozenilek.
+// 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)
+//
+//
+// This file contains helper macros used when exception support may be
+// disabled (as indicated by macro BOOST_NO_EXCEPTIONS).
+//
+// Before picking up these macros you may consider using RAII techniques
+// to deal with exceptions - their syntax can be always the same with 
+// or without exception support enabled.
+//----------------------------------------------------------------------
+
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+
+#if !(defined BOOST_NO_EXCEPTIONS)
+#    define BOOST_TRY { try
+#    define BOOST_CATCH(x) catch(x)
+#    define BOOST_RETHROW throw;
+#    define BOOST_CATCH_END }
+#else
+#    if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
+#        define BOOST_TRY { if ("")
+#        define BOOST_CATCH(x) else if (!"")
+#    else
+#        define BOOST_TRY { if (true)
+#        define BOOST_CATCH(x) else if (false)
+#    endif
+#    define BOOST_RETHROW
+#    define BOOST_CATCH_END }
+#endif
+
+
+#endif 
diff --git a/contrib/libboost/boost_1_65_0/boost/core/noncopyable.hpp b/contrib/libboost/boost_1_65_0/boost/core/noncopyable.hpp
new file mode 100644
index 00000000000..6ae8c244dd4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/core/noncopyable.hpp
@@ -0,0 +1,48 @@
+//  Boost noncopyable.hpp header file  --------------------------------------//
+
+//  (C) Copyright Beman Dawes 1999-2003. 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/utility for documentation.
+
+#ifndef BOOST_CORE_NONCOPYABLE_HPP
+#define BOOST_CORE_NONCOPYABLE_HPP
+
+#include <boost/config.hpp>
+
+namespace boost {
+
+//  Private copy constructor and copy assignment ensure classes derived from
+//  class noncopyable cannot be copied.
+
+//  Contributed by Dave Abrahams
+
+namespace noncopyable_  // protection from unintended ADL
+{
+  class noncopyable
+  {
+  protected:
+#if !defined(BOOST_NO_CXX11_DEFAULTED_FUNCTIONS) && !defined(BOOST_NO_CXX11_NON_PUBLIC_DEFAULTED_FUNCTIONS)
+      BOOST_CONSTEXPR noncopyable() = default;
+      ~noncopyable() = default;
+#else
+      noncopyable() {}
+      ~noncopyable() {}
+#endif
+#if !defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+      noncopyable( const noncopyable& ) = delete;
+      noncopyable& operator=( const noncopyable& ) = delete;
+#else
+  private:  // emphasize the following members are private
+      noncopyable( const noncopyable& );
+      noncopyable& operator=( const noncopyable& );
+#endif
+  };
+}
+
+typedef noncopyable_::noncopyable noncopyable;
+
+} // namespace boost
+
+#endif  // BOOST_CORE_NONCOPYABLE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/core/null_deleter.hpp b/contrib/libboost/boost_1_65_0/boost/core/null_deleter.hpp
new file mode 100644
index 00000000000..f0af59034ef
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/core/null_deleter.hpp
@@ -0,0 +1,44 @@
+/*
+ *          Copyright Andrey Semashev 2007 - 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)
+ */
+/*!
+ * \file   null_deleter.hpp
+ * \author Andrey Semashev
+ * \date   22.04.2007
+ *
+ * This header contains a \c null_deleter implementation. This is an empty
+ * function object that receives a pointer and does nothing with it.
+ * Such empty deletion strategy may be convenient, for example, when
+ * constructing <tt>shared_ptr</tt>s that point to some object that should not be
+ * deleted (i.e. a variable on the stack or some global singleton, like <tt>std::cout</tt>).
+ */
+
+#ifndef BOOST_CORE_NULL_DELETER_HPP
+#define BOOST_CORE_NULL_DELETER_HPP
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+
+//! A function object that does nothing and can be used as an empty deleter for \c shared_ptr
+struct null_deleter
+{
+    //! Function object result type
+    typedef void result_type;
+    /*!
+     * Does nothing
+     */
+    template< typename T >
+    void operator() (T*) const BOOST_NOEXCEPT {}
+};
+
+} // namespace boost
+
+#endif // BOOST_CORE_NULL_DELETER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/core/pointer_traits.hpp b/contrib/libboost/boost_1_65_0/boost/core/pointer_traits.hpp
new file mode 100644
index 00000000000..ff1a5321dbc
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/core/pointer_traits.hpp
@@ -0,0 +1,258 @@
+/*
+Copyright 2017 Glen Joseph Fernandes
+(glenjofe@gmail.com)
+
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
+*/
+#ifndef BOOST_CORE_POINTER_TRAITS_HPP
+#define BOOST_CORE_POINTER_TRAITS_HPP
+
+#include <boost/config.hpp>
+#if !defined(BOOST_NO_CXX11_POINTER_TRAITS)
+#include <memory>
+#else
+#include <boost/core/addressof.hpp>
+#endif
+
+namespace boost {
+
+template<class T>
+struct pointer_traits;
+
+namespace detail {
+
+template<class U>
+inline typename boost::pointer_traits<U>::element_type*
+ptr_traits_address(const U& v) BOOST_NOEXCEPT
+{
+    return boost::pointer_traits<U>::to_address(v);
+}
+
+} /* detail */
+
+#if !defined(BOOST_NO_CXX11_POINTER_TRAITS)
+template<class T>
+struct pointer_traits
+    : std::pointer_traits<T> {
+    template<class U>
+    struct rebind_to {
+        typedef typename std::pointer_traits<T>::template rebind<U> type;
+    };
+    static typename std::pointer_traits<T>::element_type*
+    to_address(const T& v) BOOST_NOEXCEPT {
+        return detail::ptr_traits_address(v.operator->());
+    }
+};
+
+template<class T>
+struct pointer_traits<T*>
+    : std::pointer_traits<T*> {
+    template<class U>
+    struct rebind_to {
+        typedef U* type;
+    };
+    static T* to_address(T* v) BOOST_NOEXCEPT {
+        return v;
+    }
+};
+#else
+namespace detail {
+
+struct ptr_traits_none { char first, second; };
+
+template<class T>
+struct ptr_traits_has_element {
+private:
+    template<class U>
+    static ptr_traits_none call(...);
+    template<class U>
+    static char call(typename U::element_type* = 0);
+public:
+    static const bool value = sizeof(call<T>(0)) == 1;
+};
+
+template<class T>
+struct ptr_traits_first;
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+template<template<class, class...> class T, class U, class... Args>
+struct ptr_traits_first<T<U, Args...> > {
+    typedef U type;
+};
+#else
+template<template<class> class T, class U>
+struct ptr_traits_first<T<U> > {
+    typedef U type;
+};
+
+template<template<class, class> class T, class U1, class U2>
+struct ptr_traits_first<T<U1, U2> > {
+    typedef U1 type;
+};
+
+template<template<class, class, class> class T, class U1, class U2, class U3>
+struct ptr_traits_first<T<U1, U2, U3> > {
+    typedef U1 type;
+};
+#endif
+
+template<class T, bool = ptr_traits_has_element<T>::value>
+struct ptr_traits_element {
+    typedef typename T::element_type type;
+};
+
+template<class T>
+struct ptr_traits_element<T, false> {
+    typedef typename ptr_traits_first<T>::type type;
+};
+
+template<class T>
+struct ptr_traits_has_difference {
+private:
+    template<class U>
+    static ptr_traits_none call(...);
+    template<class U>
+    static char call(typename U::difference_type* = 0);
+public:
+    static const bool value = sizeof(call<T>(0)) == 1;
+};
+
+template<class T, bool = ptr_traits_has_difference<T>::value>
+struct ptr_traits_difference {
+    typedef typename T::difference_type type;
+};
+
+template<class T>
+struct ptr_traits_difference<T, false> {
+    typedef std::ptrdiff_t type;
+};
+
+template<class T, class V>
+struct ptr_traits_has_rebind {
+private:
+    template<class U>
+    static ptr_traits_none call(...);
+    template<class U>
+    static char call(typename U::template rebind<V>* = 0);
+public:
+    static const bool value = sizeof(call<T>(0)) == 1;
+};
+
+template<class T, class V>
+struct ptr_traits_rebind_to;
+
+#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+template<template<class, class...> class T, class U, class... Args, class V>
+struct ptr_traits_rebind_to<T<U, Args...>, V> {
+    typedef T<V, Args...> type;
+};
+#else
+template<template<class> class T, class U, class V>
+struct ptr_traits_rebind_to<T<U>, V> {
+    typedef T<V> type;
+};
+
+template<template<class, class> class T, class U1, class U2, class V>
+struct ptr_traits_rebind_to<T<U1, U2>, V> {
+    typedef T<V, U2> type;
+};
+
+template<template<class, class, class> class T,
+    class U1, class U2, class U3, class V>
+struct ptr_traits_rebind_to<T<U1, U2, U3>, V> {
+    typedef T<V, U2, U3> type;
+};
+#endif
+
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+template<class T, class U, bool = ptr_traits_has_rebind<T, U>::value>
+struct ptr_traits_rebind {
+    typedef typename T::template rebind<U> type;
+};
+
+template<class T, class U>
+struct ptr_traits_rebind<T, U, false> {
+    typedef typename ptr_traits_rebind_to<T, U>::type type;
+};
+#else
+template<class T, class U>
+struct ptr_traits_rebind {
+    typedef typename ptr_traits_rebind_to<T, U>::type type;
+};
+#endif
+
+template<class T>
+struct ptr_traits_value {
+    typedef T type;
+};
+
+template<>
+struct ptr_traits_value<void> {
+    typedef struct { } type;
+};
+
+} /* detail */
+
+template<class T>
+struct pointer_traits {
+    typedef T pointer;
+    typedef typename detail::ptr_traits_element<T>::type element_type;
+    typedef typename detail::ptr_traits_difference<T>::type difference_type;
+    template<class U>
+    struct rebind_to {
+        typedef typename detail::ptr_traits_rebind<T, U>::type type;
+    };
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+    template<class U>
+    using rebind = typename detail::ptr_traits_rebind<T, U>::type;
+#endif
+    static pointer
+    pointer_to(typename detail::ptr_traits_value<element_type>::type& v) {
+        return pointer::pointer_to(v);
+    }
+    static element_type* to_address(const pointer& v) BOOST_NOEXCEPT {
+        return detail::ptr_traits_address(v.operator->());
+    }
+};
+
+template<class T>
+struct pointer_traits<T*> {
+    typedef T* pointer;
+    typedef T element_type;
+    typedef std::ptrdiff_t difference_type;
+    template<class U>
+    struct rebind_to {
+        typedef U* type;
+    };
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+    template<class U>
+    using rebind = U*;
+#endif
+    static T*
+    pointer_to(typename detail::ptr_traits_value<T>::type& v) BOOST_NOEXCEPT {
+        return addressof(v);
+    }
+    static T* to_address(T* v) BOOST_NOEXCEPT {
+        return v;
+    }
+};
+#endif
+
+template<class T>
+inline typename pointer_traits<T>::element_type*
+to_address(const T& v) BOOST_NOEXCEPT
+{
+    return pointer_traits<T>::to_address(v);
+}
+
+template<class T>
+inline T*
+to_address(T* v) BOOST_NOEXCEPT
+{
+    return v;
+}
+
+} /* boost */
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/core/ref.hpp b/contrib/libboost/boost_1_65_0/boost/core/ref.hpp
new file mode 100644
index 00000000000..7d768ffc758
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/core/ref.hpp
@@ -0,0 +1,301 @@
+#ifndef BOOST_CORE_REF_HPP
+#define BOOST_CORE_REF_HPP
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+#include <boost/core/addressof.hpp>
+
+//
+//  ref.hpp - ref/cref, useful helper functions
+//
+//  Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
+//  Copyright (C) 2001, 2002 Peter Dimov
+//  Copyright (C) 2002 David Abrahams
+//
+//  Copyright (C) 2014 Glen Joseph Fernandes
+//  glenfe at live dot com
+//  Copyright (C) 2014 Agustin Berge
+//
+// 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/core/doc/html/core/ref.html for documentation.
+//
+
+/**
+ @file
+*/
+
+/**
+ Boost namespace.
+*/
+namespace boost
+{
+
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )
+
+    struct ref_workaround_tag {};
+
+#endif
+
+// reference_wrapper
+
+/**
+ @brief Contains a reference to an object of type `T`.
+
+ `reference_wrapper` is primarily used to "feed" references to
+ function templates (algorithms) that take their parameter by
+ value. It provides an implicit conversion to `T&`, which
+ usually allows the function templates to work on references
+ unmodified.
+*/
+template<class T> class reference_wrapper
+{
+public:
+    /**
+     Type `T`.
+    */
+    typedef T type;
+
+    /**
+     Constructs a `reference_wrapper` object that stores a
+     reference to `t`.
+
+     @remark Does not throw.
+    */
+    BOOST_FORCEINLINE explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}
+
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )
+
+    BOOST_FORCEINLINE explicit reference_wrapper( T & t, ref_workaround_tag ): t_( boost::addressof( t ) ) {}
+
+#endif
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+    /**
+     @remark Construction from a temporary object is disabled.
+    */
+    BOOST_DELETED_FUNCTION(reference_wrapper(T&& t))
+public:
+#endif
+
+    /**
+     @return The stored reference.
+     @remark Does not throw.
+    */
+    BOOST_FORCEINLINE operator T& () const { return *t_; }
+
+    /**
+     @return The stored reference.
+     @remark Does not throw.
+    */
+    BOOST_FORCEINLINE T& get() const { return *t_; }
+
+    /**
+     @return A pointer to the object referenced by the stored
+       reference.
+     @remark Does not throw.
+    */
+    BOOST_FORCEINLINE T* get_pointer() const { return t_; }
+
+private:
+
+    T* t_;
+};
+
+// ref
+
+/**
+ @cond
+*/
+#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) )
+#  define BOOST_REF_CONST
+#else
+#  define BOOST_REF_CONST const
+#endif
+/**
+ @endcond
+*/
+
+/**
+ @return `reference_wrapper<T>(t)`
+ @remark Does not throw.
+*/
+template<class T> BOOST_FORCEINLINE reference_wrapper<T> BOOST_REF_CONST ref( T & t )
+{
+#if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )
+
+    return reference_wrapper<T>( t, ref_workaround_tag() );
+
+#else
+
+    return reference_wrapper<T>( t );
+
+#endif
+}
+
+// cref
+
+/**
+ @return `reference_wrapper<T const>(t)`
+ @remark Does not throw.
+*/
+template<class T> BOOST_FORCEINLINE reference_wrapper<T const> BOOST_REF_CONST cref( T const & t )
+{
+    return reference_wrapper<T const>(t);
+}
+
+#undef BOOST_REF_CONST
+
+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+
+/**
+ @cond
+*/
+#if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
+#  define BOOST_REF_DELETE
+#else
+#  define BOOST_REF_DELETE = delete
+#endif
+/**
+ @endcond
+*/
+
+/**
+ @remark Construction from a temporary object is disabled.
+*/
+template<class T> void ref(T const&&) BOOST_REF_DELETE;
+
+/**
+ @remark Construction from a temporary object is disabled.
+*/
+template<class T> void cref(T const&&) BOOST_REF_DELETE;
+
+#undef BOOST_REF_DELETE
+
+#endif
+
+// is_reference_wrapper
+
+/**
+ @brief Determine if a type `T` is an instantiation of
+ `reference_wrapper`.
+
+ The value static constant will be true if the type `T` is a
+ specialization of `reference_wrapper`.
+*/
+template<typename T> struct is_reference_wrapper
+{
+    BOOST_STATIC_CONSTANT( bool, value = false );
+};
+
+/**
+ @cond
+*/
+template<typename T> struct is_reference_wrapper< reference_wrapper<T> >
+{
+    BOOST_STATIC_CONSTANT( bool, value = true );
+};
+
+#if !defined(BOOST_NO_CV_SPECIALIZATIONS)
+
+template<typename T> struct is_reference_wrapper< reference_wrapper<T> const >
+{
+    BOOST_STATIC_CONSTANT( bool, value = true );
+};
+
+template<typename T> struct is_reference_wrapper< reference_wrapper<T> volatile >
+{
+    BOOST_STATIC_CONSTANT( bool, value = true );
+};
+
+template<typename T> struct is_reference_wrapper< reference_wrapper<T> const volatile >
+{
+    BOOST_STATIC_CONSTANT( bool, value = true );
+};
+
+#endif // !defined(BOOST_NO_CV_SPECIALIZATIONS)
+
+/**
+ @endcond
+*/
+
+
+// unwrap_reference
+
+/**
+ @brief Find the type in a `reference_wrapper`.
+
+ The `typedef` type is `T::type` if `T` is a
+ `reference_wrapper`, `T` otherwise.
+*/
+template<typename T> struct unwrap_reference
+{
+    typedef T type;
+};
+
+/**
+ @cond
+*/
+template<typename T> struct unwrap_reference< reference_wrapper<T> >
+{
+    typedef T type;
+};
+
+#if !defined(BOOST_NO_CV_SPECIALIZATIONS)
+
+template<typename T> struct unwrap_reference< reference_wrapper<T> const >
+{
+    typedef T type;
+};
+
+template<typename T> struct unwrap_reference< reference_wrapper<T> volatile >
+{
+    typedef T type;
+};
+
+template<typename T> struct unwrap_reference< reference_wrapper<T> const volatile >
+{
+    typedef T type;
+};
+
+#endif // !defined(BOOST_NO_CV_SPECIALIZATIONS)
+
+/**
+ @endcond
+*/
+
+// unwrap_ref
+
+/**
+ @return `unwrap_reference<T>::type&(t)`
+ @remark Does not throw.
+*/
+template<class T> BOOST_FORCEINLINE typename unwrap_reference<T>::type& unwrap_ref( T & t )
+{
+    return t;
+}
+
+// get_pointer
+
+/**
+ @cond
+*/
+template<class T> BOOST_FORCEINLINE T* get_pointer( reference_wrapper<T> const & r )
+{
+    return r.get_pointer();
+}
+/**
+ @endcond
+*/
+
+} // namespace boost
+
+#endif // #ifndef BOOST_CORE_REF_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/core/scoped_enum.hpp b/contrib/libboost/boost_1_65_0/boost/core/scoped_enum.hpp
new file mode 100644
index 00000000000..56dd0ede439
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/core/scoped_enum.hpp
@@ -0,0 +1,194 @@
+//  scoped_enum.hpp  ---------------------------------------------------------//
+
+//  Copyright Beman Dawes, 2009
+//  Copyright (C) 2011-2012 Vicente J. Botet Escriba
+//  Copyright (C) 2012 Anthony Williams
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_CORE_SCOPED_ENUM_HPP
+#define BOOST_CORE_SCOPED_ENUM_HPP
+
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost
+{
+
+#ifdef BOOST_NO_CXX11_SCOPED_ENUMS
+
+  /**
+   * Meta-function to get the native enum type associated to an enum class or its emulation.
+   */
+  template <typename EnumType>
+  struct native_type
+  {
+    /**
+     * The member typedef type names the native enum type associated to the scoped enum,
+     * which is it self if the compiler supports scoped enums or EnumType::enum_type if it is an emulated scoped enum.
+     */
+    typedef typename EnumType::enum_type type;
+  };
+
+  /**
+   * Casts a scoped enum to its underlying type.
+   *
+   * This function is useful when working with scoped enum classes, which doens't implicitly convert to the underlying type.
+   * @param v A scoped enum.
+   * @returns The underlying type.
+   * @throws No-throws.
+   */
+  template <typename UnderlyingType, typename EnumType>
+  inline
+  BOOST_CONSTEXPR UnderlyingType underlying_cast(EnumType v) BOOST_NOEXCEPT
+  {
+    return v.get_underlying_value_();
+  }
+
+  /**
+   * Casts a scoped enum to its native enum type.
+   *
+   * This function is useful to make programs portable when the scoped enum emulation can not be use where native enums can.
+   *
+   * EnumType the scoped enum type
+   *
+   * @param v A scoped enum.
+   * @returns The native enum value.
+   * @throws No-throws.
+   */
+  template <typename EnumType>
+  inline
+  BOOST_CONSTEXPR typename EnumType::enum_type native_value(EnumType e) BOOST_NOEXCEPT
+  {
+    return e.get_native_value_();
+  }
+
+#else  // BOOST_NO_CXX11_SCOPED_ENUMS
+
+  template <typename EnumType>
+  struct native_type
+  {
+    typedef EnumType type;
+  };
+
+  template <typename UnderlyingType, typename EnumType>
+  inline
+  BOOST_CONSTEXPR UnderlyingType underlying_cast(EnumType v) BOOST_NOEXCEPT
+  {
+    return static_cast<UnderlyingType>(v);
+  }
+
+  template <typename EnumType>
+  inline
+  BOOST_CONSTEXPR EnumType native_value(EnumType e) BOOST_NOEXCEPT
+  {
+    return e;
+  }
+
+#endif // BOOST_NO_CXX11_SCOPED_ENUMS
+}
+
+
+#ifdef BOOST_NO_CXX11_SCOPED_ENUMS
+
+#ifndef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
+
+#define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR \
+     explicit BOOST_CONSTEXPR operator underlying_type() const BOOST_NOEXCEPT { return get_underlying_value_(); }
+
+#else
+
+#define BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR
+
+#endif
+
+/**
+ * Start a declaration of a scoped enum.
+ *
+ * @param EnumType The new scoped enum.
+ * @param UnderlyingType The underlying type.
+ */
+#define BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType, UnderlyingType)    \
+    struct EnumType {                                                   \
+        typedef void is_boost_scoped_enum_tag;                          \
+        typedef UnderlyingType underlying_type;                         \
+        EnumType() BOOST_NOEXCEPT {}                                    \
+        explicit BOOST_CONSTEXPR EnumType(underlying_type v) BOOST_NOEXCEPT : v_(v) {}                 \
+        BOOST_CONSTEXPR underlying_type get_underlying_value_() const BOOST_NOEXCEPT { return v_; }    \
+        BOOST_SCOPED_ENUM_UT_DECLARE_CONVERSION_OPERATOR                \
+    private:                                                            \
+        underlying_type v_;                                             \
+        typedef EnumType self_type;                                     \
+    public:                                                             \
+        enum enum_type
+
+#define BOOST_SCOPED_ENUM_DECLARE_END2() \
+        BOOST_CONSTEXPR enum_type get_native_value_() const BOOST_NOEXCEPT { return enum_type(v_); } \
+        friend BOOST_CONSTEXPR bool operator ==(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator ==(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)==rhs; } \
+        friend BOOST_CONSTEXPR bool operator ==(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs==enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator !=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator !=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)!=rhs; } \
+        friend BOOST_CONSTEXPR bool operator !=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs!=enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator <(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator <(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<rhs; } \
+        friend BOOST_CONSTEXPR bool operator <(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator <=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator <=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)<=rhs; } \
+        friend BOOST_CONSTEXPR bool operator <=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs<=enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator >(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator >(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>rhs; } \
+        friend BOOST_CONSTEXPR bool operator >(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator >=(self_type lhs, self_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=enum_type(rhs.v_); } \
+        friend BOOST_CONSTEXPR bool operator >=(self_type lhs, enum_type rhs) BOOST_NOEXCEPT { return enum_type(lhs.v_)>=rhs; } \
+        friend BOOST_CONSTEXPR bool operator >=(enum_type lhs, self_type rhs) BOOST_NOEXCEPT { return lhs>=enum_type(rhs.v_); } \
+    };
+
+#define BOOST_SCOPED_ENUM_DECLARE_END(EnumType) \
+    ; \
+    BOOST_CONSTEXPR EnumType(enum_type v) BOOST_NOEXCEPT : v_(v) {}                 \
+    BOOST_SCOPED_ENUM_DECLARE_END2()
+
+/**
+ * Starts a declaration of a scoped enum with the default int underlying type.
+ *
+ * @param EnumType The new scoped enum.
+ */
+#define BOOST_SCOPED_ENUM_DECLARE_BEGIN(EnumType) \
+  BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType,int)
+
+/**
+ * Name of the native enum type.
+ *
+ * @param EnumType The new scoped enum.
+ */
+#define BOOST_SCOPED_ENUM_NATIVE(EnumType) EnumType::enum_type
+/**
+ * Forward declares an scoped enum.
+ *
+ * @param EnumType The scoped enum.
+ */
+#define BOOST_SCOPED_ENUM_FORWARD_DECLARE(EnumType) struct EnumType
+
+#else  // BOOST_NO_CXX11_SCOPED_ENUMS
+
+#define BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(EnumType,UnderlyingType) enum class EnumType : UnderlyingType
+#define BOOST_SCOPED_ENUM_DECLARE_BEGIN(EnumType) enum class EnumType
+#define BOOST_SCOPED_ENUM_DECLARE_END2()
+#define BOOST_SCOPED_ENUM_DECLARE_END(EnumType) ;
+
+#define BOOST_SCOPED_ENUM_NATIVE(EnumType) EnumType
+#define BOOST_SCOPED_ENUM_FORWARD_DECLARE(EnumType) enum class EnumType
+
+#endif  // BOOST_NO_CXX11_SCOPED_ENUMS
+
+// Deprecated macros
+#define BOOST_SCOPED_ENUM_START(name) BOOST_SCOPED_ENUM_DECLARE_BEGIN(name)
+#define BOOST_SCOPED_ENUM_END BOOST_SCOPED_ENUM_DECLARE_END2()
+#define BOOST_SCOPED_ENUM(name) BOOST_SCOPED_ENUM_NATIVE(name)
+
+#endif  // BOOST_CORE_SCOPED_ENUM_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/core/swap.hpp b/contrib/libboost/boost_1_65_0/boost/core/swap.hpp
new file mode 100644
index 00000000000..baa1be970df
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/core/swap.hpp
@@ -0,0 +1,60 @@
+// Copyright (C) 2007, 2008 Steven Watanabe, Joseph Gauterin, Niels Dekker
+//
+// 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)
+// For more information, see http://www.boost.org
+
+
+#ifndef BOOST_CORE_SWAP_HPP
+#define BOOST_CORE_SWAP_HPP
+
+// Note: the implementation of this utility contains various workarounds:
+// - swap_impl is put outside the boost namespace, to avoid infinite
+// recursion (causing stack overflow) when swapping objects of a primitive
+// type.
+// - swap_impl has a using-directive, rather than a using-declaration,
+// because some compilers (including MSVC 7.1, Borland 5.9.3, and
+// Intel 8.1) don't do argument-dependent lookup when it has a
+// using-declaration instead.
+// - boost::swap has two template arguments, instead of one, to
+// avoid ambiguity when swapping objects of a Boost type that does
+// not have its own boost::swap overload.
+
+#include <utility> //for std::swap (C++11)
+#include <algorithm> //for std::swap (C++98)
+#include <cstddef> //for std::size_t
+#include <boost/config.hpp>
+
+namespace boost_swap_impl
+{
+  template<class T>
+  BOOST_GPU_ENABLED
+  void swap_impl(T& left, T& right)
+  {
+    using namespace std;//use std::swap if argument dependent lookup fails
+    swap(left,right);
+  }
+
+  template<class T, std::size_t N>
+  BOOST_GPU_ENABLED
+  void swap_impl(T (& left)[N], T (& right)[N])
+  {
+    for (std::size_t i = 0; i < N; ++i)
+    {
+      ::boost_swap_impl::swap_impl(left[i], right[i]);
+    }
+  }
+}
+
+namespace boost
+{
+  template<class T1, class T2>
+  BOOST_GPU_ENABLED
+  void swap(T1& left, T2& right)
+  {
+    ::boost_swap_impl::swap_impl(left, right);
+  }
+}
+
+#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/core/typeinfo.hpp b/contrib/libboost/boost_1_65_0/boost/core/typeinfo.hpp
new file mode 100644
index 00000000000..e67b4a3198b
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/core/typeinfo.hpp
@@ -0,0 +1,151 @@
+#ifndef BOOST_CORE_TYPEINFO_HPP_INCLUDED
+#define BOOST_CORE_TYPEINFO_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  core::typeinfo, BOOST_CORE_TYPEID
+//
+//  Copyright 2007, 2014 Peter Dimov
+//
+//  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)
+
+#include <boost/config.hpp>
+
+#if defined( BOOST_NO_TYPEID )
+
+#include <boost/current_function.hpp>
+#include <functional>
+
+namespace boost
+{
+
+namespace core
+{
+
+class typeinfo
+{
+private:
+
+    typeinfo( typeinfo const& );
+    typeinfo& operator=( typeinfo const& );
+
+    char const * name_;
+
+public:
+
+    explicit typeinfo( char const * name ): name_( name )
+    {
+    }
+
+    bool operator==( typeinfo const& rhs ) const
+    {
+        return this == &rhs;
+    }
+
+    bool operator!=( typeinfo const& rhs ) const
+    {
+        return this != &rhs;
+    }
+
+    bool before( typeinfo const& rhs ) const
+    {
+        return std::less< typeinfo const* >()( this, &rhs );
+    }
+
+    char const* name() const
+    {
+        return name_;
+    }
+};
+
+inline char const * demangled_name( core::typeinfo const & ti )
+{
+    return ti.name();
+}
+
+} // namespace core
+
+namespace detail
+{
+
+template<class T> struct core_typeid_
+{
+    static boost::core::typeinfo ti_;
+
+    static char const * name()
+    {
+        return BOOST_CURRENT_FUNCTION;
+    }
+};
+
+#if defined(__SUNPRO_CC)
+// see #4199, the Sun Studio compiler gets confused about static initialization 
+// constructor arguments. But an assignment works just fine. 
+template<class T> boost::core::typeinfo core_typeid_< T >::ti_ = core_typeid_< T >::name();
+#else
+template<class T> boost::core::typeinfo core_typeid_< T >::ti_(core_typeid_< T >::name());
+#endif
+
+template<class T> struct core_typeid_< T & >: core_typeid_< T >
+{
+};
+
+template<class T> struct core_typeid_< T const >: core_typeid_< T >
+{
+};
+
+template<class T> struct core_typeid_< T volatile >: core_typeid_< T >
+{
+};
+
+template<class T> struct core_typeid_< T const volatile >: core_typeid_< T >
+{
+};
+
+} // namespace detail
+
+} // namespace boost
+
+#define BOOST_CORE_TYPEID(T) (boost::detail::core_typeid_<T>::ti_)
+
+#else
+
+#include <boost/core/demangle.hpp>
+#include <typeinfo>
+
+namespace boost
+{
+
+namespace core
+{
+
+#if defined( BOOST_NO_STD_TYPEINFO )
+
+typedef ::type_info typeinfo;
+
+#else
+
+typedef std::type_info typeinfo;
+
+#endif
+
+inline std::string demangled_name( core::typeinfo const & ti )
+{
+    return core::demangle( ti.name() );
+}
+
+} // namespace core
+
+} // namespace boost
+
+#define BOOST_CORE_TYPEID(T) typeid(T)
+
+#endif
+
+#endif  // #ifndef BOOST_CORE_TYPEINFO_HPP_INCLUDED
diff --git a/contrib/libboost/boost_1_65_0/boost/core/underlying_type.hpp b/contrib/libboost/boost_1_65_0/boost/core/underlying_type.hpp
new file mode 100644
index 00000000000..7ecba313f45
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/core/underlying_type.hpp
@@ -0,0 +1,79 @@
+//  underlying_type.hpp  ---------------------------------------------------------//
+
+//  Copyright Beman Dawes, 2009
+//  Copyright (C) 2011-2012 Vicente J. Botet Escriba
+//  Copyright (C) 2012 Anthony Williams
+//  Copyright (C) 2014 Andrey Semashev
+
+//  Distributed under the Boost Software License, Version 1.0.
+//  See http://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_CORE_UNDERLYING_TYPE_HPP
+#define BOOST_CORE_UNDERLYING_TYPE_HPP
+
+#include <boost/config.hpp>
+
+// GCC 4.7 and later seem to provide std::underlying_type
+#if !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) || (defined(BOOST_GCC) && BOOST_GCC >= 40700 && defined(__GXX_EXPERIMENTAL_CXX0X__))
+#include <type_traits>
+#define BOOST_DETAIL_HAS_STD_UNDERLYING_TYPE
+#endif
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+namespace boost {
+
+namespace detail {
+
+template< typename EnumType, typename Void = void >
+struct underlying_type_impl;
+
+#if defined(BOOST_NO_CXX11_SCOPED_ENUMS)
+
+// Support for boost/core/scoped_enum.hpp
+template< typename EnumType >
+struct underlying_type_impl< EnumType, typename EnumType::is_boost_scoped_enum_tag >
+{
+    /**
+     * The member typedef type names the underlying type of EnumType. It is EnumType::underlying_type when the EnumType is an emulated scoped enum,
+     */
+    typedef typename EnumType::underlying_type type;
+};
+
+#endif
+
+#if defined(BOOST_DETAIL_HAS_STD_UNDERLYING_TYPE)
+
+template< typename EnumType, typename Void >
+struct underlying_type_impl
+{
+    typedef typename std::underlying_type< EnumType >::type type;
+};
+
+#endif
+
+} // namespace detail
+
+#if !defined(BOOST_NO_CXX11_SCOPED_ENUMS) && !defined(BOOST_DETAIL_HAS_STD_UNDERLYING_TYPE)
+#define BOOST_NO_UNDERLYING_TYPE
+#endif
+
+/**
+ * Meta-function to get the underlying type of a scoped enum.
+ *
+ * Requires EnumType must be an enum type or the emulation of a scoped enum.
+ * If BOOST_NO_UNDERLYING_TYPE is defined, the implementation will not be able
+ * to deduce the underlying type of enums. The user is expected to specialize
+ * this trait in this case.
+ */
+template< typename EnumType >
+struct underlying_type :
+    public detail::underlying_type_impl< EnumType >
+{
+};
+
+} // namespace boost
+
+#endif  // BOOST_CORE_UNDERLYING_TYPE_HPP

From 8971967651e60b7864bb9398c8463fd5cd77a089 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Mon, 4 Sep 2017 22:31:23 +0300
Subject: [PATCH 070/266] Added missing files [#CLICKHOUSE-3276].

---
 .../boost/geometry/core/access.hpp            | 399 ++++++++++++++++++
 .../boost/geometry/core/assert.hpp            |  43 ++
 .../boost/geometry/core/closure.hpp           | 202 +++++++++
 .../geometry/core/coordinate_dimension.hpp    | 127 ++++++
 .../boost/geometry/core/coordinate_system.hpp | 100 +++++
 .../boost/geometry/core/coordinate_type.hpp   | 108 +++++
 .../boost_1_65_0/boost/geometry/core/cs.hpp   | 269 ++++++++++++
 .../boost/geometry/core/exception.hpp         |  89 ++++
 .../boost/geometry/core/exterior_ring.hpp     | 145 +++++++
 .../boost/geometry/core/geometry_id.hpp       | 103 +++++
 .../boost/geometry/core/interior_rings.hpp    | 150 +++++++
 .../boost/geometry/core/interior_type.hpp     | 164 +++++++
 .../boost/geometry/core/is_areal.hpp          |  59 +++
 .../boost/geometry/core/mutable_range.hpp     |  98 +++++
 .../boost/geometry/core/point_order.hpp       | 187 ++++++++
 .../boost/geometry/core/point_type.hpp        | 162 +++++++
 .../boost/geometry/core/radian_access.hpp     | 263 ++++++++++++
 .../boost/geometry/core/radius.hpp            | 251 +++++++++++
 .../boost/geometry/core/reverse_dispatch.hpp  |  66 +++
 .../boost/geometry/core/ring_type.hpp         | 226 ++++++++++
 .../boost_1_65_0/boost/geometry/core/srs.hpp  | 196 +++++++++
 .../boost_1_65_0/boost/geometry/core/tag.hpp  |  69 +++
 .../boost/geometry/core/tag_cast.hpp          |  84 ++++
 .../boost_1_65_0/boost/geometry/core/tags.hpp | 150 +++++++
 .../geometry/core/topological_dimension.hpp   | 101 +++++
 25 files changed, 3811 insertions(+)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/access.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/assert.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/closure.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/coordinate_dimension.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/coordinate_system.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/coordinate_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/cs.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/exception.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/exterior_ring.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/geometry_id.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/interior_rings.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/interior_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/is_areal.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/mutable_range.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/point_order.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/point_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/radian_access.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/radius.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/reverse_dispatch.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/ring_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/srs.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/tag.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/tag_cast.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/tags.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/core/topological_dimension.hpp

diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/access.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/access.hpp
new file mode 100644
index 00000000000..866fb19a4df
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/access.hpp
@@ -0,0 +1,399 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_CORE_ACCESS_HPP
+#define BOOST_GEOMETRY_CORE_ACCESS_HPP
+
+
+#include <cstddef>
+
+#include <boost/core/ignore_unused.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+
+#include <boost/geometry/core/coordinate_type.hpp>
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/util/bare_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+/// Index of minimum corner of the box.
+int const min_corner = 0;
+
+/// Index of maximum corner of the box.
+int const max_corner = 1;
+
+namespace traits
+{
+
+/*!
+\brief Traits class which gives access (get,set) to points.
+\ingroup traits
+\par Geometries:
+///     @li point
+\par Specializations should provide, per Dimension
+///     @li static inline T get(G const&)
+///     @li static inline void set(G&, T const&)
+\tparam Geometry geometry-type
+\tparam Dimension dimension to access
+*/
+template <typename Geometry, std::size_t Dimension, typename Enable = void>
+struct access
+{
+   BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_POINT_TYPE, (types<Geometry>)
+        );
+};
+
+
+/*!
+\brief Traits class defining "get" and "set" to get
+    and set point coordinate values
+\tparam Geometry geometry (box, segment)
+\tparam Index index (min_corner/max_corner for box, 0/1 for segment)
+\tparam Dimension dimension
+\par Geometries:
+    - box
+    - segment
+\par Specializations should provide:
+    - static inline T get(G const&)
+    - static inline void set(G&, T const&)
+\ingroup traits
+*/
+template <typename Geometry, std::size_t Index, std::size_t Dimension>
+struct indexed_access {};
+
+
+} // namespace traits
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template
+<
+    typename Geometry,
+    typename CoordinateType,
+    std::size_t Index,
+    std::size_t Dimension
+>
+struct indexed_access_non_pointer
+{
+    static inline CoordinateType get(Geometry const& geometry)
+    {
+        return traits::indexed_access<Geometry, Index, Dimension>::get(geometry);
+    }
+    static inline void set(Geometry& b, CoordinateType const& value)
+    {
+        traits::indexed_access<Geometry, Index, Dimension>::set(b, value);
+    }
+};
+
+template
+<
+    typename Geometry,
+    typename CoordinateType,
+    std::size_t Index,
+    std::size_t Dimension
+>
+struct indexed_access_pointer
+{
+    static inline CoordinateType get(Geometry const* geometry)
+    {
+        return traits::indexed_access<typename boost::remove_pointer<Geometry>::type, Index, Dimension>::get(*geometry);
+    }
+    static inline void set(Geometry* geometry, CoordinateType const& value)
+    {
+        traits::indexed_access<typename boost::remove_pointer<Geometry>::type, Index, Dimension>::set(*geometry, value);
+    }
+};
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace core_dispatch
+{
+
+template
+<
+    typename Tag,
+    typename Geometry,
+    typename
+    CoordinateType,
+    std::size_t Dimension,
+    typename IsPointer
+>
+struct access
+{
+    //static inline T get(G const&) {}
+    //static inline void set(G& g, T const& value) {}
+};
+
+template
+<
+    typename Tag,
+    typename Geometry,
+    typename CoordinateType,
+    std::size_t Index,
+    std::size_t Dimension,
+    typename IsPointer
+>
+struct indexed_access
+{
+    //static inline T get(G const&) {}
+    //static inline void set(G& g, T const& value) {}
+};
+
+template <typename Point, typename CoordinateType, std::size_t Dimension>
+struct access<point_tag, Point, CoordinateType, Dimension, boost::false_type>
+{
+    static inline CoordinateType get(Point const& point)
+    {
+        return traits::access<Point, Dimension>::get(point);
+    }
+    static inline void set(Point& p, CoordinateType const& value)
+    {
+        traits::access<Point, Dimension>::set(p, value);
+    }
+};
+
+template <typename Point, typename CoordinateType, std::size_t Dimension>
+struct access<point_tag, Point, CoordinateType, Dimension, boost::true_type>
+{
+    static inline CoordinateType get(Point const* point)
+    {
+        return traits::access<typename boost::remove_pointer<Point>::type, Dimension>::get(*point);
+    }
+    static inline void set(Point* p, CoordinateType const& value)
+    {
+        traits::access<typename boost::remove_pointer<Point>::type, Dimension>::set(*p, value);
+    }
+};
+
+
+template
+<
+    typename Box,
+    typename CoordinateType,
+    std::size_t Index,
+    std::size_t Dimension
+>
+struct indexed_access<box_tag, Box, CoordinateType, Index, Dimension, boost::false_type>
+    : detail::indexed_access_non_pointer<Box, CoordinateType, Index, Dimension>
+{};
+
+template
+<
+    typename Box,
+    typename CoordinateType,
+    std::size_t Index,
+    std::size_t Dimension
+>
+struct indexed_access<box_tag, Box, CoordinateType, Index, Dimension, boost::true_type>
+    : detail::indexed_access_pointer<Box, CoordinateType, Index, Dimension>
+{};
+
+
+template
+<
+    typename Segment,
+    typename CoordinateType,
+    std::size_t Index,
+    std::size_t Dimension
+>
+struct indexed_access<segment_tag, Segment, CoordinateType, Index, Dimension, boost::false_type>
+    : detail::indexed_access_non_pointer<Segment, CoordinateType, Index, Dimension>
+{};
+
+
+template
+<
+    typename Segment,
+    typename CoordinateType,
+    std::size_t Index,
+    std::size_t Dimension
+>
+struct indexed_access<segment_tag, Segment, CoordinateType, Index, Dimension, boost::true_type>
+    : detail::indexed_access_pointer<Segment, CoordinateType, Index, Dimension>
+{};
+
+} // namespace core_dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+// Two dummy tags to distinguish get/set variants below.
+// They don't have to be specified by the user. The functions are distinguished
+// by template signature also, but for e.g. GCC this is not enough. So give them
+// a different signature.
+struct signature_getset_dimension {};
+struct signature_getset_index_dimension {};
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+/*!
+\brief Get coordinate value of a geometry (usually a point)
+\details \details_get_set
+\ingroup get
+\tparam Dimension \tparam_dimension_required
+\tparam Geometry \tparam_geometry (usually a Point Concept)
+\param geometry \param_geometry (usually a point)
+\return The coordinate value of specified dimension of specified geometry
+
+\qbk{[include reference/core/get_point.qbk]}
+*/
+template <std::size_t Dimension, typename Geometry>
+inline typename coordinate_type<Geometry>::type get(Geometry const& geometry
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+        , detail::signature_getset_dimension* dummy = 0
+#endif
+        )
+{
+    boost::ignore_unused(dummy);
+
+    typedef core_dispatch::access
+        <
+            typename tag<Geometry>::type,
+            typename geometry::util::bare_type<Geometry>::type,
+            typename coordinate_type<Geometry>::type,
+            Dimension,
+            typename boost::is_pointer<Geometry>::type
+        > coord_access_type;
+
+    return coord_access_type::get(geometry);
+}
+
+
+/*!
+\brief Set coordinate value of a geometry (usually a point)
+\details \details_get_set
+\tparam Dimension \tparam_dimension_required
+\tparam Geometry \tparam_geometry (usually a Point Concept)
+\param geometry geometry to assign coordinate to
+\param geometry \param_geometry (usually a point)
+\param value The coordinate value to set
+\ingroup set
+
+\qbk{[include reference/core/set_point.qbk]}
+*/
+template <std::size_t Dimension, typename Geometry>
+inline void set(Geometry& geometry
+        , typename coordinate_type<Geometry>::type const& value
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+        , detail::signature_getset_dimension* dummy = 0
+#endif
+        )
+{
+    boost::ignore_unused(dummy);
+
+    typedef core_dispatch::access
+        <
+            typename tag<Geometry>::type,
+            typename geometry::util::bare_type<Geometry>::type,
+            typename coordinate_type<Geometry>::type,
+            Dimension,
+            typename boost::is_pointer<Geometry>::type
+        > coord_access_type;
+
+    coord_access_type::set(geometry, value);
+}
+
+
+/*!
+\brief get coordinate value of a Box or Segment
+\details \details_get_set
+\tparam Index \tparam_index_required
+\tparam Dimension \tparam_dimension_required
+\tparam Geometry \tparam_box_or_segment
+\param geometry \param_geometry
+\return coordinate value
+\ingroup get
+
+\qbk{distinguish,with index}
+\qbk{[include reference/core/get_box.qbk]}
+*/
+template <std::size_t Index, std::size_t Dimension, typename Geometry>
+inline typename coordinate_type<Geometry>::type get(Geometry const& geometry
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+        , detail::signature_getset_index_dimension* dummy = 0
+#endif
+        )
+{
+    boost::ignore_unused(dummy);
+
+    typedef core_dispatch::indexed_access
+        <
+            typename tag<Geometry>::type,
+            typename geometry::util::bare_type<Geometry>::type,
+            typename coordinate_type<Geometry>::type,
+            Index,
+            Dimension,
+            typename boost::is_pointer<Geometry>::type
+        > coord_access_type;
+
+    return coord_access_type::get(geometry);
+}
+
+/*!
+\brief set coordinate value of a Box / Segment
+\details \details_get_set
+\tparam Index \tparam_index_required
+\tparam Dimension \tparam_dimension_required
+\tparam Geometry \tparam_box_or_segment
+\param geometry geometry to assign coordinate to
+\param geometry \param_geometry
+\param value The coordinate value to set
+\ingroup set
+
+\qbk{distinguish,with index}
+\qbk{[include reference/core/set_box.qbk]}
+*/
+template <std::size_t Index, std::size_t Dimension, typename Geometry>
+inline void set(Geometry& geometry
+        , typename coordinate_type<Geometry>::type const& value
+#ifndef DOXYGEN_SHOULD_SKIP_THIS
+        , detail::signature_getset_index_dimension* dummy = 0
+#endif
+        )
+{
+    boost::ignore_unused(dummy);
+
+    typedef core_dispatch::indexed_access
+        <
+            typename tag<Geometry>::type,
+            typename geometry::util::bare_type<Geometry>::type,
+            typename coordinate_type<Geometry>::type,
+            Index,
+            Dimension,
+            typename boost::is_pointer<Geometry>::type
+        > coord_access_type;
+
+    coord_access_type::set(geometry, value);
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_CORE_ACCESS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/assert.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/assert.hpp
new file mode 100644
index 00000000000..0f3ae6baeae
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/assert.hpp
@@ -0,0 +1,43 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
+// Copyright (c) 2007, 2014 Peter Dimov
+// Copyright (c) Beman Dawes 2011
+// Copyright (c) 2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_CORE_ASSERT_HPP
+#define BOOST_GEOMETRY_CORE_ASSERT_HPP
+
+#include <boost/assert.hpp>
+
+#undef BOOST_GEOMETRY_ASSERT
+#undef BOOST_GEOMETRY_ASSERT_MSG
+
+#if defined(BOOST_GEOMETRY_ENABLE_ASSERT_HANDLER) || ( defined(BOOST_GEOMETRY_ENABLE_ASSERT_DEBUG_HANDLER) && !defined(NDEBUG) )
+
+#include <boost/config.hpp> // for BOOST_LIKELY
+#include <boost/current_function.hpp>
+
+namespace boost { namespace geometry
+{
+    void assertion_failed(char const * expr, char const * function, char const * file, long line); // user defined
+    void assertion_failed_msg(char const * expr, char const * msg, char const * function, char const * file, long line); // user defined
+}} // namespace boost::geometry
+
+#define BOOST_GEOMETRY_ASSERT(expr) (BOOST_LIKELY(!!(expr))? ((void)0): ::boost::geometry::assertion_failed(#expr, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+#define BOOST_GEOMETRY_ASSERT_MSG(expr, msg) (BOOST_LIKELY(!!(expr))? ((void)0): ::boost::geometry::assertion_failed_msg(#expr, msg, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__))
+
+#else
+
+#define BOOST_GEOMETRY_ASSERT(expr) BOOST_ASSERT(expr)
+#define BOOST_GEOMETRY_ASSERT_MSG(expr, msg) BOOST_ASSERT_MSG(expr, msg)
+
+#endif
+
+#endif // BOOST_GEOMETRY_CORE_EXCEPTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/closure.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/closure.hpp
new file mode 100644
index 00000000000..405a5a5f352
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/closure.hpp
@@ -0,0 +1,202 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_CORE_CLOSURE_HPP
+#define BOOST_GEOMETRY_CORE_CLOSURE_HPP
+
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/size_t.hpp>
+#include <boost/range/value_type.hpp>
+
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/util/bare_type.hpp>
+
+namespace boost { namespace geometry
+{
+
+
+/*!
+\brief Enumerates options for defining if polygons are open or closed
+\ingroup enum
+\details The enumeration closure_selector describes options for if a polygon is
+    open or closed. In a closed polygon the very first point (per ring) should
+    be equal to the very last point.
+    The specific closing property of a polygon type is defined by the closure
+    metafunction. The closure metafunction defines a value, which is one of the
+    values enumerated in the closure_selector
+
+\qbk{
+[heading See also]
+[link geometry.reference.core.closure The closure metafunction]
+}
+*/
+enum closure_selector
+{
+    /// Rings are open: first point and last point are different, algorithms
+    /// close them explicitly on the fly
+    open = 0,
+    /// Rings are closed: first point and last point must be the same
+    closed = 1,
+    /// (Not yet implemented): algorithms first figure out if ring must be
+    /// closed on the fly
+    closure_undertermined = -1
+};
+
+namespace traits
+{
+
+/*!
+    \brief Traits class indicating if points within a
+        ring or (multi)polygon are closed (last point == first point),
+        open or not known.
+    \ingroup traits
+    \par Geometries:
+        - ring
+    \tparam G geometry
+*/
+template <typename G>
+struct closure
+{
+    static const closure_selector value = closed;
+};
+
+
+} // namespace traits
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace core_detail { namespace closure
+{
+
+struct closed
+{
+    static const closure_selector value = geometry::closed;
+};
+
+
+/// Metafunction to define the minimum size of a ring:
+/// 3 for open rings, 4 for closed rings
+template <closure_selector Closure>
+struct minimum_ring_size {};
+
+template <>
+struct minimum_ring_size<geometry::closed> : boost::mpl::size_t<4> {};
+
+template <>
+struct minimum_ring_size<geometry::open> : boost::mpl::size_t<3> {};
+
+
+}} // namespace detail::point_order
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace core_dispatch
+{
+
+template <typename Tag, typename Geometry>
+struct closure
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
+            , (types<Geometry>)
+        );
+};
+
+template <typename Box>
+struct closure<point_tag, Box> : public core_detail::closure::closed {};
+
+template <typename Box>
+struct closure<box_tag, Box> : public core_detail::closure::closed {};
+
+template <typename Box>
+struct closure<segment_tag, Box> : public core_detail::closure::closed {};
+
+template <typename LineString>
+struct closure<linestring_tag, LineString>
+    : public core_detail::closure::closed {};
+
+
+template <typename Ring>
+struct closure<ring_tag, Ring>
+{
+    static const closure_selector value
+        = geometry::traits::closure<Ring>::value;
+};
+
+// Specialization for Polygon: the closure is the closure of its rings
+template <typename Polygon>
+struct closure<polygon_tag, Polygon>
+{
+    static const closure_selector value = core_dispatch::closure
+        <
+            ring_tag,
+            typename ring_type<polygon_tag, Polygon>::type
+        >::value ;
+};
+
+template <typename MultiPoint>
+struct closure<multi_point_tag, MultiPoint>
+    : public core_detail::closure::closed {};
+
+template <typename MultiLinestring>
+struct closure<multi_linestring_tag, MultiLinestring>
+    : public core_detail::closure::closed {};
+
+// Specialization for MultiPolygon: the closure is the closure of Polygon's rings
+template <typename MultiPolygon>
+struct closure<multi_polygon_tag, MultiPolygon>
+{
+    static const closure_selector value = core_dispatch::closure
+        <
+            polygon_tag,
+            typename boost::range_value<MultiPolygon>::type
+        >::value ;
+};
+
+} // namespace core_dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+/*!
+\brief \brief_meta{value, closure (clockwise\, counterclockwise),
+    \meta_geometry_type}
+\tparam Geometry \tparam_geometry
+\ingroup core
+
+\qbk{[include reference/core/closure.qbk]}
+*/
+template <typename Geometry>
+struct closure
+{
+    static const closure_selector value = core_dispatch::closure
+        <
+            typename tag<Geometry>::type,
+            typename util::bare_type<Geometry>::type
+        >::value;
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_CORE_CLOSURE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/coordinate_dimension.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/coordinate_dimension.hpp
new file mode 100644
index 00000000000..19022f2fd23
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/coordinate_dimension.hpp
@@ -0,0 +1,127 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_CORE_COORDINATE_DIMENSION_HPP
+#define BOOST_GEOMETRY_CORE_COORDINATE_DIMENSION_HPP
+
+
+#include <cstddef>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/static_assert.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/util/bare_type.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace traits
+{
+
+/*!
+\brief Traits class indicating the number of dimensions of a point
+\par Geometries:
+    - point
+\par Specializations should provide:
+    - value (should be derived from boost::mpl::int_<D>
+\ingroup traits
+*/
+template <typename Point, typename Enable = void>
+struct dimension
+{
+   BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_POINT_TYPE, (types<Point>)
+        );
+};
+
+} // namespace traits
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace core_dispatch
+{
+
+// Base class derive from its own specialization of point-tag
+template <typename T, typename G>
+struct dimension : dimension<point_tag, typename point_type<T, G>::type> {};
+
+template <typename P>
+struct dimension<point_tag, P>
+    : traits::dimension<typename geometry::util::bare_type<P>::type>
+{
+    BOOST_MPL_ASSERT_MSG(
+        (traits::dimension<typename geometry::util::bare_type<P>::type>::value > 0),
+        INVALID_DIMENSION_VALUE,
+        (traits::dimension<typename geometry::util::bare_type<P>::type>)
+    );
+};
+
+} // namespace core_dispatch
+#endif
+
+/*!
+\brief \brief_meta{value, number of coordinates (the number of axes of any geometry), \meta_point_type}
+\tparam Geometry \tparam_geometry
+\ingroup core
+
+\qbk{[include reference/core/coordinate_dimension.qbk]}
+*/
+template <typename Geometry>
+struct dimension
+    : core_dispatch::dimension
+        <
+            typename tag<Geometry>::type,
+            typename geometry::util::bare_type<Geometry>::type
+        >
+{};
+
+/*!
+\brief assert_dimension, enables compile-time checking if coordinate dimensions are as expected
+\ingroup utility
+*/
+template <typename Geometry, int Dimensions>
+inline void assert_dimension()
+{
+    BOOST_STATIC_ASSERT(( static_cast<int>(dimension<Geometry>::value) == Dimensions ));
+}
+
+/*!
+\brief assert_dimension, enables compile-time checking if coordinate dimensions are as expected
+\ingroup utility
+*/
+template <typename Geometry, int Dimensions>
+inline void assert_dimension_less_equal()
+{
+    BOOST_STATIC_ASSERT(( static_cast<int>(dimension<Geometry>::type::value) <= Dimensions ));
+}
+
+template <typename Geometry, int Dimensions>
+inline void assert_dimension_greater_equal()
+{
+    BOOST_STATIC_ASSERT(( static_cast<int>(dimension<Geometry>::type::value) >= Dimensions ));
+}
+
+/*!
+\brief assert_dimension_equal, enables compile-time checking if coordinate dimensions of two geometries are equal
+\ingroup utility
+*/
+template <typename G1, typename G2>
+inline void assert_dimension_equal()
+{
+    BOOST_STATIC_ASSERT(( static_cast<size_t>(dimension<G1>::type::value) == static_cast<size_t>(dimension<G2>::type::value) ));
+}
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_CORE_COORDINATE_DIMENSION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/coordinate_system.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/coordinate_system.hpp
new file mode 100644
index 00000000000..d33353f4b4f
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/coordinate_system.hpp
@@ -0,0 +1,100 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_CORE_COORDINATE_SYSTEM_HPP
+#define BOOST_GEOMETRY_CORE_COORDINATE_SYSTEM_HPP
+
+
+#include <boost/mpl/assert.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/util/bare_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace traits
+{
+
+/*!
+\brief Traits class defining the coordinate system of a point, important for strategy selection
+\ingroup traits
+\par Geometries:
+    - point
+\par Specializations should provide:
+    - typedef CS type; (cs::cartesian, cs::spherical, etc)
+*/
+template <typename Point, typename Enable = void>
+struct coordinate_system
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_POINT_TYPE, (types<Point>)
+        );
+};
+
+} // namespace traits
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace core_dispatch
+{
+    template <typename GeometryTag, typename G>
+    struct coordinate_system
+    {
+        typedef typename point_type<GeometryTag, G>::type P;
+
+        // Call its own specialization on point-tag
+        typedef typename coordinate_system<point_tag, P>::type type;
+    };
+
+
+    template <typename Point>
+    struct coordinate_system<point_tag, Point>
+    {
+        typedef typename traits::coordinate_system
+            <
+                typename geometry::util::bare_type<Point>::type
+            >::type type;
+    };
+
+
+} // namespace core_dispatch
+#endif
+
+
+/*!
+\brief \brief_meta{type, coordinate system (cartesian\, spherical\, etc), \meta_point_type}
+\tparam Geometry \tparam_geometry
+\ingroup core
+
+\qbk{[include reference/core/coordinate_system.qbk]}
+*/
+template <typename Geometry>
+struct coordinate_system
+{
+    typedef typename core_dispatch::coordinate_system
+        <
+            typename tag<Geometry>::type,
+            typename geometry::util::bare_type<Geometry>::type
+        >::type type;
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_CORE_COORDINATE_SYSTEM_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/coordinate_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/coordinate_type.hpp
new file mode 100644
index 00000000000..47c028fec25
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/coordinate_type.hpp
@@ -0,0 +1,108 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2008-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_CORE_COORDINATE_TYPE_HPP
+#define BOOST_GEOMETRY_CORE_COORDINATE_TYPE_HPP
+
+
+#include <boost/mpl/assert.hpp>
+
+#include <boost/geometry/core/point_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/util/bare_type.hpp>
+#include <boost/geometry/util/promote_floating_point.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace traits
+{
+
+/*!
+\brief Traits class which indicate the coordinate type (double,float,...) of a point
+\ingroup traits
+\par Geometries:
+    - point
+\par Specializations should provide:
+    - typedef T type; (double,float,int,etc)
+*/
+template <typename Point, typename Enable = void>
+struct coordinate_type
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_POINT_TYPE, (types<Point>)
+        );
+};
+
+} // namespace traits
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace core_dispatch
+{
+
+template <typename GeometryTag, typename Geometry>
+struct coordinate_type
+{
+    typedef typename point_type<GeometryTag, Geometry>::type point_type;
+
+    // Call its own specialization on point-tag
+    typedef typename coordinate_type<point_tag, point_type>::type type;
+};
+
+template <typename Point>
+struct coordinate_type<point_tag, Point>
+{
+    typedef typename traits::coordinate_type
+        <
+            typename geometry::util::bare_type<Point>::type
+        >::type type;
+};
+
+
+} // namespace core_dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+/*!
+\brief \brief_meta{type, coordinate type (int\, float\, double\, etc), \meta_point_type}
+\tparam Geometry \tparam_geometry
+\ingroup core
+
+\qbk{[include reference/core/coordinate_type.qbk]}
+*/
+template <typename Geometry>
+struct coordinate_type
+{
+    typedef typename core_dispatch::coordinate_type
+                <
+                    typename tag<Geometry>::type,
+                    typename geometry::util::bare_type<Geometry>::type
+                >::type type;
+};
+
+template <typename Geometry>
+struct fp_coordinate_type
+{
+    typedef typename promote_floating_point
+        <
+            typename coordinate_type<Geometry>::type
+        >::type type;
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_CORE_COORDINATE_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/cs.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/cs.hpp
new file mode 100644
index 00000000000..301fb6b76fe
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/cs.hpp
@@ -0,0 +1,269 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2014 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2014 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2014 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_CORE_CS_HPP
+#define BOOST_GEOMETRY_CORE_CS_HPP
+
+#include <cstddef>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+
+#include <boost/geometry/core/coordinate_system.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+/*!
+\brief Unit of plane angle: Degrees
+\details Tag defining the unit of plane angle for spherical coordinate systems.
+    This tag specifies that coordinates are defined in degrees (-180 .. 180).
+    It has to be specified for some coordinate systems.
+\qbk{[include reference/core/degree_radian.qbk]}
+*/
+struct degree {};
+
+
+/*!
+\brief Unit of plane angle: Radians
+\details Tag defining the unit of plane angle for spherical coordinate systems.
+    This tag specifies that coordinates are defined in radians (-PI .. PI).
+    It has to be specified for some coordinate systems.
+\qbk{[include reference/core/degree_radian.qbk]}
+*/
+struct radian {};
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace core_detail
+{
+
+template <typename DegreeOrRadian>
+struct coordinate_system_units
+{
+    BOOST_MPL_ASSERT_MSG
+        ((false),
+         COORDINATE_SYSTEM_UNITS_MUST_BE_DEGREES_OR_RADIANS,
+         (types<DegreeOrRadian>));
+};
+
+template <>
+struct coordinate_system_units<geometry::degree>
+{
+    typedef geometry::degree units;
+};
+
+template <>
+struct coordinate_system_units<geometry::radian>
+{
+    typedef geometry::radian units;
+};
+
+} // namespace core_detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+namespace cs
+{
+
+/*!
+\brief Cartesian coordinate system
+\details Defines the Cartesian or rectangular coordinate system
+    where points are defined in 2 or 3 (or more)
+dimensions and usually (but not always) known as x,y,z
+\see http://en.wikipedia.org/wiki/Cartesian_coordinate_system
+\ingroup cs
+*/
+struct cartesian {};
+
+
+
+
+/*!
+\brief Geographic coordinate system, in degree or in radian
+\details Defines the geographic coordinate system where points
+    are defined in two angles and usually
+known as lat,long or lo,la or phi,lambda
+\see http://en.wikipedia.org/wiki/Geographic_coordinate_system
+\ingroup cs
+\note might be moved to extensions/gis/geographic
+*/
+template<typename DegreeOrRadian>
+struct geographic
+{
+    typedef typename core_detail::coordinate_system_units
+        <
+            DegreeOrRadian
+        >::units units;
+};
+
+
+
+/*!
+\brief Spherical (polar) coordinate system, in degree or in radian
+\details Defines the spherical coordinate system where points are
+    defined in two angles
+    and an optional radius usually known as r, theta, phi
+\par Coordinates:
+- coordinate 0:
+    0 <= phi < 2pi is the angle between the positive x-axis and the
+        line from the origin to the P projected onto the xy-plane.
+- coordinate 1:
+    0 <= theta <= pi is the angle between the positive z-axis and the
+        line formed between the origin and P.
+- coordinate 2 (if specified):
+    r >= 0 is the distance from the origin to a given point P.
+
+\see http://en.wikipedia.org/wiki/Spherical_coordinates
+\ingroup cs
+*/
+template<typename DegreeOrRadian>
+struct spherical
+{
+    typedef typename core_detail::coordinate_system_units
+        <
+            DegreeOrRadian
+        >::units units;
+};
+
+
+/*!
+\brief Spherical equatorial coordinate system, in degree or in radian
+\details This one resembles the geographic coordinate system, and has latitude
+    up from zero at the equator, to 90 at the pole
+    (opposite to the spherical(polar) coordinate system).
+    Used in astronomy and in GIS (but there is also the geographic)
+
+\see http://en.wikipedia.org/wiki/Spherical_coordinates
+\ingroup cs
+*/
+template<typename DegreeOrRadian>
+struct spherical_equatorial
+{
+    typedef typename core_detail::coordinate_system_units
+        <
+            DegreeOrRadian
+        >::units units;
+};
+
+
+
+/*!
+\brief Polar coordinate system
+\details Defines the polar coordinate system "in which each point
+    on a plane is determined by an angle and a distance"
+\see http://en.wikipedia.org/wiki/Polar_coordinates
+\ingroup cs
+*/
+template<typename DegreeOrRadian>
+struct polar
+{
+    typedef typename core_detail::coordinate_system_units
+        <
+            DegreeOrRadian
+        >::units units;
+};
+
+
+} // namespace cs
+
+
+namespace traits
+{
+
+/*!
+\brief Traits class defining coordinate system tag, bound to coordinate system
+\ingroup traits
+\tparam CoordinateSystem coordinate system
+*/
+template <typename CoordinateSystem>
+struct cs_tag
+{
+};
+
+
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+template<typename DegreeOrRadian>
+struct cs_tag<cs::geographic<DegreeOrRadian> >
+{
+    typedef geographic_tag type;
+};
+
+template<typename DegreeOrRadian>
+struct cs_tag<cs::spherical<DegreeOrRadian> >
+{
+    typedef spherical_polar_tag type;
+};
+
+template<typename DegreeOrRadian>
+struct cs_tag<cs::spherical_equatorial<DegreeOrRadian> >
+{
+    typedef spherical_equatorial_tag type;
+};
+
+
+template<>
+struct cs_tag<cs::cartesian>
+{
+    typedef cartesian_tag type;
+};
+
+
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+} // namespace traits
+
+/*!
+\brief Meta-function returning coordinate system tag (cs family) of any geometry
+\tparam Geometry \tparam_geometry
+\ingroup core
+*/
+template <typename Geometry>
+struct cs_tag
+{
+    typedef typename traits::cs_tag
+        <
+            typename geometry::coordinate_system<Geometry>::type
+        >::type type;
+};
+
+
+/*!
+\brief Meta-function to verify if a coordinate system is radian
+\tparam CoordinateSystem Any coordinate system.
+\ingroup core
+*/
+template <typename CoordinateSystem>
+struct is_radian : boost::true_type {};
+
+
+#ifndef DOXYGEN_NO_SPECIALIZATIONS
+
+// Specialization for any degree coordinate systems
+template <template<typename> class CoordinateSystem>
+struct is_radian< CoordinateSystem<degree> > : boost::false_type
+{
+};
+
+#endif // DOXYGEN_NO_SPECIALIZATIONS
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_CORE_CS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/exception.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/exception.hpp
new file mode 100644
index 00000000000..21abbd577b1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/exception.hpp
@@ -0,0 +1,89 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_CORE_EXCEPTION_HPP
+#define BOOST_GEOMETRY_CORE_EXCEPTION_HPP
+
+#include <exception>
+
+namespace boost { namespace geometry
+{
+
+/*!
+\brief Base exception class for Boost.Geometry algorithms
+\ingroup core
+\details This class is never thrown. All exceptions thrown in Boost.Geometry
+    are derived from exception, so it might be convenient to catch it.
+*/
+class exception : public std::exception
+{
+public:
+    virtual char const* what() const throw()
+    {
+        return "Boost.Geometry exception";
+    }
+};
+
+/*!
+\brief Invalid Input Exception
+\ingroup core
+\details The invalid_input_exception is thrown if an invalid attribute
+         is passed into a function, e.g. a DE-9IM mask string code containing
+         invalid characters passed into a de9im::mask constructor.
+ */
+class invalid_input_exception : public geometry::exception
+{
+public:
+
+    inline invalid_input_exception() {}
+
+    virtual char const* what() const throw()
+    {
+        return "Boost.Geometry Invalid-Input exception";
+    }
+};
+
+/*!
+\brief Empty Input Exception
+\ingroup core
+\details The empty_input_exception is thrown if free functions, e.g. distance,
+    are called with empty geometries, e.g. a linestring
+    without points, a polygon without points, an empty multi-geometry.
+\qbk{
+[heading See also]
+\* [link geometry.reference.algorithms.area the area function]
+\* [link geometry.reference.algorithms.distance the distance function]
+\* [link geometry.reference.algorithms.length the length function]
+}
+ */
+class empty_input_exception : public geometry::invalid_input_exception
+{
+public:
+
+    inline empty_input_exception() {}
+
+    virtual char const* what() const throw()
+    {
+        return "Boost.Geometry Empty-Input exception";
+    }
+};
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_CORE_EXCEPTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/exterior_ring.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/exterior_ring.hpp
new file mode 100644
index 00000000000..fa5a0a2b98c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/exterior_ring.hpp
@@ -0,0 +1,145 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_CORE_EXTERIOR_RING_HPP
+#define BOOST_GEOMETRY_CORE_EXTERIOR_RING_HPP
+
+
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/util/add_const_if_c.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace traits
+{
+
+
+/*!
+    \brief Traits class defining access to exterior_ring of a polygon
+    \details Should define const and non const access
+    \ingroup traits
+    \tparam Polygon the polygon type
+    \par Geometries:
+        - polygon
+    \par Specializations should provide:
+        - static inline RING& get(POLY& )
+        - static inline RING const& get(POLY const& )
+*/
+template <typename Polygon>
+struct exterior_ring
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_POLYGON_TYPE
+            , (types<Polygon>)
+        );
+};
+
+
+} // namespace traits
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace core_dispatch
+{
+
+
+template <typename Tag, typename Geometry>
+struct exterior_ring
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
+            , (types<Geometry>)
+        );
+};
+
+
+template <typename Polygon>
+struct exterior_ring<polygon_tag, Polygon>
+{
+    static
+    typename geometry::ring_return_type<Polygon>::type
+        apply(typename add_const_if_c
+            <
+                boost::is_const<Polygon>::type::value,
+                Polygon
+            >::type& polygon)
+    {
+        return traits::exterior_ring
+            <
+                typename boost::remove_const<Polygon>::type
+            >::get(polygon);
+    }
+};
+
+
+} // namespace core_dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+/*!
+    \brief Function to get the exterior_ring ring of a polygon
+    \ingroup exterior_ring
+    \note OGC compliance: instead of ExteriorRing
+    \tparam Polygon polygon type
+    \param polygon the polygon to get the exterior ring from
+    \return a reference to the exterior ring
+*/
+template <typename Polygon>
+inline typename ring_return_type<Polygon>::type exterior_ring(Polygon& polygon)
+{
+    return core_dispatch::exterior_ring
+        <
+            typename tag<Polygon>::type,
+            Polygon
+        >::apply(polygon);
+}
+
+
+/*!
+\brief Function to get the exterior ring of a polygon (const version)
+\ingroup exterior_ring
+\note OGC compliance: instead of ExteriorRing
+\tparam Polygon polygon type
+\param polygon the polygon to get the exterior ring from
+\return a const reference to the exterior ring
+
+\qbk{distinguish,const version}
+*/
+template <typename Polygon>
+inline typename ring_return_type<Polygon const>::type exterior_ring(
+        Polygon const& polygon)
+{
+    return core_dispatch::exterior_ring
+        <
+            typename tag<Polygon>::type,
+            Polygon const
+        >::apply(polygon);
+}
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_CORE_EXTERIOR_RING_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/geometry_id.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/geometry_id.hpp
new file mode 100644
index 00000000000..5fc5a800500
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/geometry_id.hpp
@@ -0,0 +1,103 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_CORE_GEOMETRY_ID_HPP
+#define BOOST_GEOMETRY_CORE_GEOMETRY_ID_HPP
+
+
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/int.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace core_dispatch
+{
+
+template <typename GeometryTag>
+struct geometry_id
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
+            , (types<GeometryTag>)
+        );
+};
+
+
+template <>
+struct geometry_id<point_tag>            : boost::mpl::int_<1> {};
+
+
+template <>
+struct geometry_id<linestring_tag>       : boost::mpl::int_<2> {};
+
+
+template <>
+struct geometry_id<polygon_tag>          : boost::mpl::int_<3> {};
+
+
+template <>
+struct geometry_id<multi_point_tag>      : boost::mpl::int_<4> {};
+
+
+template <>
+struct geometry_id<multi_linestring_tag> : boost::mpl::int_<5> {};
+
+
+template <>
+struct geometry_id<multi_polygon_tag>    : boost::mpl::int_<6> {};
+
+
+template <>
+struct geometry_id<segment_tag>          : boost::mpl::int_<92> {};
+
+
+template <>
+struct geometry_id<ring_tag>             : boost::mpl::int_<93> {};
+
+
+template <>
+struct geometry_id<box_tag>              : boost::mpl::int_<94> {};
+
+
+} // namespace core_dispatch
+#endif
+
+
+
+/*!
+\brief Meta-function returning the id of a geometry type
+\details The meta-function geometry_id defines a numerical ID (based on
+    boost::mpl::int_<...> ) for each geometry concept. A numerical ID is
+    sometimes useful, and within Boost.Geometry it is used for the
+    reverse_dispatch metafuntion.
+\note Used for e.g. reverse meta-function
+\ingroup core
+*/
+template <typename Geometry>
+struct geometry_id : core_dispatch::geometry_id<typename tag<Geometry>::type>
+{};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_CORE_GEOMETRY_ID_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/interior_rings.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/interior_rings.hpp
new file mode 100644
index 00000000000..798f4157791
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/interior_rings.hpp
@@ -0,0 +1,150 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_CORE_INTERIOR_RINGS_HPP
+#define BOOST_GEOMETRY_CORE_INTERIOR_RINGS_HPP
+
+#include <cstddef>
+
+#include <boost/mpl/assert.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/core/interior_type.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace traits
+{
+
+
+/*!
+    \brief Traits class defining access to interior_rings of a polygon
+    \details defines access (const and non const) to interior ring
+    \ingroup traits
+    \par Geometries:
+        - polygon
+    \par Specializations should provide:
+        - static inline INTERIOR& get(POLY&)
+        - static inline const INTERIOR& get(POLY const&)
+    \tparam Geometry geometry
+*/
+template <typename Geometry>
+struct interior_rings
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
+            , (types<Geometry>)
+        );
+};
+
+
+} // namespace traits
+
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace core_dispatch
+{
+
+template
+<
+    typename GeometryTag,
+    typename Geometry
+>
+struct interior_rings {};
+
+
+template <typename Polygon>
+struct interior_rings<polygon_tag, Polygon>
+{
+    static inline
+    typename geometry::interior_return_type<Polygon>::type
+                apply(Polygon& polygon)
+    {
+        return traits::interior_rings
+            <
+                typename boost::remove_const<Polygon>::type
+            >::get(polygon);
+    }
+};
+
+
+template <typename MultiPolygon>
+struct interior_type<multi_polygon_tag, MultiPolygon>
+{
+    typedef typename core_dispatch::interior_type
+        <
+            polygon_tag,
+            typename boost::range_value<MultiPolygon>::type
+        >::type type;
+};
+
+
+} // namespace core_dispatch
+#endif
+
+
+
+/*!
+\brief Function to get the interior rings of a polygon (non const version)
+\ingroup interior_rings
+\note OGC compliance: instead of InteriorRingN
+\tparam Polygon polygon type
+\param polygon the polygon to get the interior rings from
+\return the interior rings (possibly a reference)
+*/
+
+template <typename Polygon>
+inline typename interior_return_type<Polygon>::type interior_rings(Polygon& polygon)
+{
+    return core_dispatch::interior_rings
+        <
+            typename tag<Polygon>::type,
+            Polygon
+        >::apply(polygon);
+}
+
+
+/*!
+\brief Function to get the interior rings of a polygon (const version)
+\ingroup interior_rings
+\note OGC compliance: instead of InteriorRingN
+\tparam Polygon polygon type
+\param polygon the polygon to get the interior rings from
+\return the interior rings (possibly a const reference)
+
+\qbk{distinguish,const version}
+*/
+template <typename Polygon>
+inline typename interior_return_type<Polygon const>::type interior_rings(
+            Polygon const& polygon)
+{
+    return core_dispatch::interior_rings
+        <
+            typename tag<Polygon>::type,
+            Polygon const
+        >::apply(polygon);
+}
+
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_CORE_INTERIOR_RINGS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/interior_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/interior_type.hpp
new file mode 100644
index 00000000000..66544b79afb
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/interior_type.hpp
@@ -0,0 +1,164 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_CORE_INTERIOR_TYPE_HPP
+#define BOOST_GEOMETRY_CORE_INTERIOR_TYPE_HPP
+
+
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace traits
+{
+
+/*!
+\brief Traits class indicating interior container type of a polygon
+\details defines inner container type, so the container containing
+        the interior rings
+\ingroup traits
+\par Geometries:
+    - polygon
+\par Specializations should provide:
+    - typedef X type ( e.g. std::vector&lt;myring&lt;P&gt;&gt; )
+\tparam Geometry geometry
+*/
+template <typename Geometry>
+struct interior_const_type
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
+            , (types<Geometry>)
+        );
+};
+
+template <typename Geometry>
+struct interior_mutable_type
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
+            , (types<Geometry>)
+        );
+};
+
+
+} // namespace traits
+
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace core_dispatch
+{
+
+
+template <typename GeometryTag, typename Geometry>
+struct interior_return_type
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
+            , (types<Geometry>)
+        );
+};
+
+
+template <typename Polygon>
+struct interior_return_type<polygon_tag, Polygon>
+{
+    typedef typename boost::remove_const<Polygon>::type nc_polygon_type;
+
+    typedef typename boost::mpl::if_
+        <
+            boost::is_const<Polygon>,
+            typename traits::interior_const_type<nc_polygon_type>::type,
+            typename traits::interior_mutable_type<nc_polygon_type>::type
+        >::type type;
+};
+
+
+
+
+template <typename GeometryTag, typename Geometry>
+struct interior_type
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
+            , (types<Geometry>)
+        );
+};
+
+
+template <typename Polygon>
+struct interior_type<polygon_tag, Polygon>
+{
+    typedef typename boost::remove_reference
+        <
+            typename interior_return_type<polygon_tag, Polygon>::type
+        >::type type;
+};
+
+
+} // namespace core_dispatch
+#endif
+
+
+/*!
+\brief \brief_meta{type, interior_type (container type
+    of inner rings), \meta_geometry_type}
+\details Interior rings should be organized as a container
+    (std::vector, std::deque, boost::array) with
+    Boost.Range support. This metafunction defines the type
+    of the container.
+\tparam Geometry A type fullfilling the Polygon or MultiPolygon concept.
+\ingroup core
+
+\qbk{[include reference/core/interior_type.qbk]}
+*/
+template <typename Geometry>
+struct interior_type
+{
+    typedef typename core_dispatch::interior_type
+        <
+            typename tag<Geometry>::type,
+            Geometry
+        >::type type;
+};
+
+template <typename Geometry>
+struct interior_return_type
+{
+    typedef typename core_dispatch::interior_return_type
+        <
+            typename tag<Geometry>::type,
+            Geometry
+        >::type type;
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_CORE_INTERIOR_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/is_areal.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/is_areal.hpp
new file mode 100644
index 00000000000..23858605f49
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/is_areal.hpp
@@ -0,0 +1,59 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_CORE_IS_AREAL_HPP
+#define BOOST_GEOMETRY_CORE_IS_AREAL_HPP
+
+
+#include <boost/type_traits/integral_constant.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace core_dispatch
+{
+
+template <typename GeometryTag> struct is_areal : boost::false_type {};
+
+template <> struct is_areal<ring_tag> : boost::true_type {};
+template <> struct is_areal<box_tag> : boost::true_type {};
+template <> struct is_areal<polygon_tag> : boost::true_type {};
+template <> struct is_areal<multi_polygon_tag> : boost::true_type {};
+
+} // namespace core_dispatch
+#endif
+
+
+
+/*!
+    \brief Meta-function defining "true" for areal types (box, (multi)polygon, ring),
+    \note Used for tag dispatching and meta-function finetuning
+    \note Also a "ring" has areal properties within Boost.Geometry
+    \ingroup core
+*/
+template <typename Geometry>
+struct is_areal : core_dispatch::is_areal<typename tag<Geometry>::type>
+{};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_CORE_IS_AREAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/mutable_range.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/mutable_range.hpp
new file mode 100644
index 00000000000..7cb5137830c
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/mutable_range.hpp
@@ -0,0 +1,98 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_CORE_MUTABLE_RANGE_HPP
+#define BOOST_GEOMETRY_CORE_MUTABLE_RANGE_HPP
+
+
+#include <cstddef>
+
+#include <boost/range/value_type.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+namespace traits
+{
+
+/*!
+\brief Metafunction to define the argument passed to the three
+    traits classes clear, push_back and resize
+\ingroup mutable_range
+ */
+template <typename Range>
+struct rvalue_type
+{
+    typedef typename boost::remove_reference<Range>::type& type;
+};
+
+
+/*!
+\brief Traits class to clear a geometry
+\ingroup mutable_range
+ */
+template <typename Range>
+struct clear
+{
+    static inline void apply(typename rvalue_type<Range>::type range)
+    {
+        range.clear();
+    }
+};
+
+
+/*!
+\brief Traits class to append a point to a range (ring, linestring, multi*)
+\ingroup mutable_range
+ */
+template <typename Range>
+struct push_back
+{
+    typedef typename boost::range_value
+        <
+            typename boost::remove_reference<Range>::type
+        >::type item_type;
+
+    static inline void apply(typename rvalue_type<Range>::type range,
+                 item_type const& item)
+    {
+        range.push_back(item);
+    }
+};
+
+
+/*!
+\brief Traits class to append a point to a range (ring, linestring, multi*)
+\ingroup mutable_range
+ */
+template <typename Range>
+struct resize
+{
+    static inline void apply(typename rvalue_type<Range>::type range,
+                std::size_t new_size)
+    {
+        range.resize(new_size);
+    }
+};
+
+
+} // namespace traits
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_CORE_MUTABLE_RANGE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/point_order.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/point_order.hpp
new file mode 100644
index 00000000000..df6d4bbfffc
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/point_order.hpp
@@ -0,0 +1,187 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_CORE_POINT_ORDER_HPP
+#define BOOST_GEOMETRY_CORE_POINT_ORDER_HPP
+
+
+#include <boost/mpl/assert.hpp>
+#include <boost/range/value_type.hpp>
+
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/util/bare_type.hpp>
+
+namespace boost { namespace geometry
+{
+
+/*!
+\brief Enumerates options for the order of points within polygons
+\ingroup enum
+\details The enumeration order_selector describes options for the order of
+    points within a polygon. Polygons can be ordered either clockwise or
+    counterclockwise. The specific order of a polygon type is defined by the
+    point_order metafunction. The point_order metafunction defines a value,
+    which is one of the values enumerated in the order_selector
+
+\qbk{
+[heading See also]
+[link geometry.reference.core.point_order The point_order metafunction]
+}
+*/
+enum order_selector
+{
+    /// Points are ordered clockwise
+    clockwise = 1,
+    /// Points are ordered counter clockwise
+    counterclockwise = 2,
+    /// Points might be stored in any order, algorithms will determine it on the
+    /// fly (not yet supported)
+    order_undetermined = 0
+};
+
+namespace traits
+{
+
+/*!
+\brief Traits class indicating the order of contained points within a
+    ring or (multi)polygon, clockwise, counter clockwise or not known.
+\ingroup traits
+\tparam Ring ring
+*/
+template <typename Ring>
+struct point_order
+{
+    static const order_selector value = clockwise;
+};
+
+
+} // namespace traits
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail { namespace point_order
+{
+
+struct clockwise
+{
+    static const order_selector value = geometry::clockwise;
+};
+
+
+}} // namespace detail::point_order
+#endif // DOXYGEN_NO_DETAIL
+
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace core_dispatch
+{
+
+template <typename Tag, typename Geometry>
+struct point_order
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
+            , (types<Geometry>)
+        );
+};
+
+template <typename Point>
+struct point_order<point_tag, Point>
+    : public detail::point_order::clockwise {};
+
+template <typename Segment>
+struct point_order<segment_tag, Segment>
+    : public detail::point_order::clockwise {};
+
+
+template <typename Box>
+struct point_order<box_tag, Box>
+    : public detail::point_order::clockwise {};
+
+template <typename LineString>
+struct point_order<linestring_tag, LineString>
+    : public detail::point_order::clockwise {};
+
+
+template <typename Ring>
+struct point_order<ring_tag, Ring>
+{
+    static const order_selector value
+        = geometry::traits::point_order<Ring>::value;
+};
+
+// Specialization for polygon: the order is the order of its rings
+template <typename Polygon>
+struct point_order<polygon_tag, Polygon>
+{
+    static const order_selector value = core_dispatch::point_order
+        <
+            ring_tag,
+            typename ring_type<polygon_tag, Polygon>::type
+        >::value ;
+};
+
+template <typename MultiPoint>
+struct point_order<multi_point_tag, MultiPoint>
+    : public detail::point_order::clockwise {};
+
+template <typename MultiLinestring>
+struct point_order<multi_linestring_tag, MultiLinestring>
+    : public detail::point_order::clockwise {};
+
+
+// Specialization for multi_polygon: the order is the order of its polygons
+template <typename MultiPolygon>
+struct point_order<multi_polygon_tag, MultiPolygon>
+{
+    static const order_selector value = core_dispatch::point_order
+        <
+            polygon_tag,
+            typename boost::range_value<MultiPolygon>::type
+        >::value ;
+};
+
+} // namespace core_dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+/*!
+\brief \brief_meta{value, point order (clockwise\, counterclockwise),
+    \meta_geometry_type}
+\tparam Geometry \tparam_geometry
+\ingroup core
+
+\qbk{[include reference/core/point_order.qbk]}
+*/
+template <typename Geometry>
+struct point_order
+{
+    static const order_selector value = core_dispatch::point_order
+        <
+            typename tag<Geometry>::type,
+            typename util::bare_type<Geometry>::type
+        >::value;
+};
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_CORE_POINT_ORDER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/point_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/point_type.hpp
new file mode 100644
index 00000000000..f70e1fedd57
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/point_type.hpp
@@ -0,0 +1,162 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_CORE_POINT_TYPE_HPP
+#define BOOST_GEOMETRY_CORE_POINT_TYPE_HPP
+
+
+#include <boost/mpl/assert.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/type_traits/remove_const.hpp>
+
+#include <boost/geometry/core/ring_type.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/util/bare_type.hpp>
+
+namespace boost { namespace geometry
+{
+
+namespace traits
+{
+
+/*!
+\brief Traits class indicating the type of contained points
+\ingroup traits
+\par Geometries:
+    - all geometries except point
+\par Specializations should provide:
+    - typedef P type (where P should fulfil the Point concept)
+\tparam Geometry geometry
+*/
+template <typename Geometry>
+struct point_type
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_POINT_TYPE, (types<Geometry>)
+        );
+};
+
+
+} // namespace traits
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace core_dispatch
+{
+
+template <typename Tag, typename Geometry>
+struct point_type
+{
+    // Default: call traits to get point type
+    typedef typename boost::remove_const
+        <
+            typename traits::point_type<Geometry>::type
+        >::type type;
+};
+
+
+// Specialization for point: the point itself
+template <typename Point>
+struct point_type<point_tag, Point>
+{
+    typedef Point type;
+};
+
+
+// Specializations for linestring/ring, via boost::range
+template <typename Linestring>
+struct point_type<linestring_tag, Linestring>
+{
+    typedef typename boost::range_value<Linestring>::type type;
+};
+
+
+template <typename Ring>
+struct point_type<ring_tag, Ring>
+{
+    typedef typename boost::range_value<Ring>::type type;
+};
+
+
+// Specialization for polygon: the point-type is the point-type of its rings
+template <typename Polygon>
+struct point_type<polygon_tag, Polygon>
+{
+    typedef typename point_type
+        <
+            ring_tag,
+            typename ring_type<polygon_tag, Polygon>::type
+        >::type type;
+};
+
+
+template <typename MultiPoint>
+struct point_type<multi_point_tag, MultiPoint>
+{
+    typedef typename boost::range_value
+        <
+            MultiPoint
+        >::type type;
+};
+
+
+template <typename MultiLinestring>
+struct point_type<multi_linestring_tag, MultiLinestring>
+{
+    typedef typename point_type
+        <
+            linestring_tag,
+            typename boost::range_value<MultiLinestring>::type
+        >::type type;
+};
+
+
+template <typename MultiPolygon>
+struct point_type<multi_polygon_tag, MultiPolygon>
+{
+    typedef typename point_type
+        <
+            polygon_tag,
+            typename boost::range_value<MultiPolygon>::type
+        >::type type;
+};
+
+
+} // namespace core_dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+/*!
+\brief \brief_meta{type, point_type, \meta_geometry_type}
+\tparam Geometry \tparam_geometry
+\ingroup core
+
+\qbk{[include reference/core/point_type.qbk]}
+*/
+template <typename Geometry>
+struct point_type
+{
+    typedef typename core_dispatch::point_type
+        <
+            typename tag<Geometry>::type,
+            typename boost::geometry::util::bare_type<Geometry>::type
+        >::type type;
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_CORE_POINT_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/radian_access.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/radian_access.hpp
new file mode 100644
index 00000000000..993a6cc4c4d
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/radian_access.hpp
@@ -0,0 +1,263 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_CORE_RADIAN_ACCESS_HPP
+#define BOOST_GEOMETRY_CORE_RADIAN_ACCESS_HPP
+
+
+#include <cstddef>
+
+#include <boost/numeric/conversion/cast.hpp>
+
+#include <boost/geometry/core/access.hpp>
+#include <boost/geometry/core/cs.hpp>
+#include <boost/geometry/core/coordinate_type.hpp>
+
+
+#include <boost/geometry/util/math.hpp>
+
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template<std::size_t Dimension, typename Geometry>
+struct degree_radian_converter
+{
+    typedef typename fp_coordinate_type<Geometry>::type coordinate_type;
+
+    static inline coordinate_type get(Geometry const& geometry)
+    {
+        return boost::numeric_cast
+            <
+                coordinate_type
+            >(geometry::get<Dimension>(geometry)
+              * math::d2r<coordinate_type>());
+    }
+
+    static inline void set(Geometry& geometry, coordinate_type const& radians)
+    {
+        geometry::set<Dimension>(geometry, boost::numeric_cast
+            <
+                coordinate_type
+            >(radians * math::r2d<coordinate_type>()));
+    }
+
+};
+
+
+// Default, radian (or any other coordinate system) just works like "get"
+template <std::size_t Dimension, typename Geometry, typename DegreeOrRadian>
+struct radian_access
+{
+    typedef typename fp_coordinate_type<Geometry>::type coordinate_type;
+
+    static inline coordinate_type get(Geometry const& geometry)
+    {
+        return geometry::get<Dimension>(geometry);
+    }
+
+    static inline void set(Geometry& geometry, coordinate_type const& radians)
+    {
+        geometry::set<Dimension>(geometry, radians);
+    }
+};
+
+// Specialize, any "degree" coordinate system will be converted to radian
+// but only for dimension 0,1 (so: dimension 2 and heigher are untouched)
+
+template
+<
+    typename Geometry,
+    template<typename> class CoordinateSystem
+>
+struct radian_access<0, Geometry, CoordinateSystem<degree> >
+    : degree_radian_converter<0, Geometry>
+{};
+
+
+template
+<
+    typename Geometry,
+    template<typename> class CoordinateSystem
+>
+struct radian_access<1, Geometry, CoordinateSystem<degree> >
+    : degree_radian_converter<1, Geometry>
+{};
+
+
+template<std::size_t Index, std::size_t Dimension, typename Geometry>
+struct degree_radian_converter_box_segment
+{
+    typedef typename fp_coordinate_type<Geometry>::type coordinate_type;
+
+    static inline coordinate_type get(Geometry const& geometry)
+    {
+        return boost::numeric_cast
+            <
+                coordinate_type
+            >(geometry::get<Index, Dimension>(geometry)
+              * math::d2r<coordinate_type>());
+    }
+
+    static inline void set(Geometry& geometry, coordinate_type const& radians)
+    {
+        geometry::set<Index, Dimension>(geometry, boost::numeric_cast
+            <
+                coordinate_type
+            >(radians * math::r2d<coordinate_type>()));
+    }
+
+};
+
+
+// Default, radian (or any other coordinate system) just works like "get"
+template <std::size_t Index, std::size_t Dimension, typename Geometry, typename DegreeOrRadian>
+struct radian_access_box_segment
+{
+    typedef typename fp_coordinate_type<Geometry>::type coordinate_type;
+
+    static inline coordinate_type get(Geometry const& geometry)
+    {
+        return geometry::get<Index, Dimension>(geometry);
+    }
+
+    static inline void set(Geometry& geometry, coordinate_type const& radians)
+    {
+        geometry::set<Index, Dimension>(geometry, radians);
+    }
+};
+
+// Specialize, any "degree" coordinate system will be converted to radian
+// but only for dimension 0,1 (so: dimension 2 and heigher are untouched)
+
+template
+<
+    typename Geometry,
+    template<typename> class CoordinateSystem,
+    std::size_t Index
+>
+struct radian_access_box_segment<Index, 0, Geometry, CoordinateSystem<degree> >
+    : degree_radian_converter_box_segment<Index, 0, Geometry>
+{};
+
+
+template
+<
+    typename Geometry,
+    template<typename> class CoordinateSystem,
+    std::size_t Index
+>
+struct radian_access_box_segment<Index, 1, Geometry, CoordinateSystem<degree> >
+    : degree_radian_converter_box_segment<Index, 1, Geometry>
+{};
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+/*!
+\brief get coordinate value of a point, result is in Radian
+\details Result is in Radian, even if source coordinate system
+    is in Degrees
+\return coordinate value
+\ingroup get
+\tparam Dimension dimension
+\tparam Geometry geometry
+\param geometry geometry to get coordinate value from
+\note Only applicable to coordinate systems templatized by units,
+    e.g. spherical or geographic coordinate systems
+*/
+template <std::size_t Dimension, typename Geometry>
+inline typename fp_coordinate_type<Geometry>::type get_as_radian(Geometry const& geometry)
+{
+    return detail::radian_access<Dimension, Geometry,
+            typename coordinate_system<Geometry>::type>::get(geometry);
+}
+
+/*!
+\brief set coordinate value (in radian) to a point
+\details Coordinate value will be set correctly, if coordinate system of
+    point is in Degree, Radian value will be converted to Degree
+\ingroup set
+\tparam Dimension dimension
+\tparam Geometry geometry
+\param geometry geometry to assign coordinate to
+\param radians coordinate value to assign
+\note Only applicable to coordinate systems templatized by units,
+    e.g. spherical or geographic coordinate systems
+*/
+template <std::size_t Dimension, typename Geometry>
+inline void set_from_radian(Geometry& geometry,
+            typename fp_coordinate_type<Geometry>::type const& radians)
+{
+    detail::radian_access<Dimension, Geometry,
+            typename coordinate_system<Geometry>::type>::set(geometry, radians);
+}
+
+/*!
+\brief get coordinate value of a segment or box, result is in Radian
+\details Result is in Radian, even if source coordinate system
+    is in Degrees
+\return coordinate value
+\ingroup get
+\tparam Index index
+\tparam Dimension dimension
+\tparam Geometry geometry
+\param geometry geometry to get coordinate value from
+\note Only applicable to coordinate systems templatized by units,
+    e.g. spherical or geographic coordinate systems
+*/
+template <std::size_t Index, std::size_t Dimension, typename Geometry>
+inline typename fp_coordinate_type<Geometry>::type get_as_radian(Geometry const& geometry)
+{
+    return detail::radian_access_box_segment<Index, Dimension, Geometry,
+            typename coordinate_system<Geometry>::type>::get(geometry);
+}
+
+/*!
+\brief set coordinate value (in radian) to a segment or box
+\details Coordinate value will be set correctly, if coordinate system of
+    point is in Degree, Radian value will be converted to Degree
+\ingroup set
+\tparam Index index
+\tparam Dimension dimension
+\tparam Geometry geometry
+\param geometry geometry to assign coordinate to
+\param radians coordinate value to assign
+\note Only applicable to coordinate systems templatized by units,
+    e.g. spherical or geographic coordinate systems
+*/
+template <std::size_t Index, std::size_t Dimension, typename Geometry>
+inline void set_from_radian(Geometry& geometry,
+            typename fp_coordinate_type<Geometry>::type const& radians)
+{
+    detail::radian_access_box_segment<Index, Dimension, Geometry,
+            typename coordinate_system<Geometry>::type>::set(geometry, radians);
+}
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_CORE_RADIAN_ACCESS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/radius.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/radius.hpp
new file mode 100644
index 00000000000..6cbf6ac8f23
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/radius.hpp
@@ -0,0 +1,251 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_CORE_RADIUS_HPP
+#define BOOST_GEOMETRY_CORE_RADIUS_HPP
+
+
+#include <cstddef>
+
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_pointer.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/util/bare_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace traits
+{
+
+/*!
+    \brief Traits class to get/set radius of a circle/sphere/(ellipse)
+    \details the radius access meta-functions give read/write access to the radius of a circle or a sphere,
+    or to the major/minor axis or an ellipse, or to one of the 3 equatorial radii of an ellipsoid.
+
+    It should be specialized per geometry, in namespace core_dispatch. Those specializations should
+    forward the call via traits to the geometry class, which could be specified by the user.
+
+    There is a corresponding generic radius_get and radius_set function
+    \par Geometries:
+        - n-sphere (circle,sphere)
+        - upcoming ellipse
+    \par Specializations should provide:
+        - inline static T get(Geometry const& geometry)
+        - inline static void set(Geometry& geometry, T const& radius)
+    \ingroup traits
+*/
+template <typename Geometry, std::size_t Dimension>
+struct radius_access {};
+
+
+/*!
+    \brief Traits class indicating the type (double,float,...) of the radius of a circle or a sphere
+    \par Geometries:
+        - n-sphere (circle,sphere)
+        - upcoming ellipse
+    \par Specializations should provide:
+        - typedef T type (double,float,int,etc)
+    \ingroup traits
+*/
+template <typename Geometry>
+struct radius_type {};
+
+} // namespace traits
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace core_dispatch
+{
+
+template <typename Tag, typename Geometry>
+struct radius_type
+{
+    //typedef core_dispatch_specialization_required type;
+};
+
+/*!
+    \brief radius access meta-functions, used by concept n-sphere and upcoming ellipse.
+*/
+template <typename Tag,
+          typename Geometry,
+          std::size_t Dimension,
+          typename IsPointer>
+struct radius_access
+{
+    //static inline CoordinateType get(Geometry const& ) {}
+    //static inline void set(Geometry& g, CoordinateType const& value) {}
+};
+
+} // namespace core_dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+/*!
+    \brief Metafunction to get the type of radius of a circle / sphere / ellipse / etc.
+    \ingroup access
+    \tparam Geometry the type of geometry
+*/
+template <typename Geometry>
+struct radius_type
+{
+    typedef typename core_dispatch::radius_type
+                        <
+                            typename tag<Geometry>::type,
+                            typename util::bare_type<Geometry>::type
+                        >::type type;
+};
+
+/*!
+    \brief Function to get radius of a circle / sphere / ellipse / etc.
+    \return radius The radius for a given axis
+    \ingroup access
+    \param geometry the geometry to get the radius from
+    \tparam I index of the axis
+*/
+template <std::size_t I, typename Geometry>
+inline typename radius_type<Geometry>::type get_radius(Geometry const& geometry)
+{
+    return core_dispatch::radius_access
+            <
+                typename tag<Geometry>::type,
+                typename util::bare_type<Geometry>::type,
+                I,
+                typename boost::is_pointer<Geometry>::type
+            >::get(geometry);
+}
+
+/*!
+    \brief Function to set the radius of a circle / sphere / ellipse / etc.
+    \ingroup access
+    \tparam I index of the axis
+    \param geometry the geometry to change
+    \param radius the radius to set
+*/
+template <std::size_t I, typename Geometry>
+inline void set_radius(Geometry& geometry,
+                       typename radius_type<Geometry>::type const& radius)
+{
+    core_dispatch::radius_access
+        <
+            typename tag<Geometry>::type,
+            typename util::bare_type<Geometry>::type,
+            I,
+            typename boost::is_pointer<Geometry>::type
+        >::set(geometry, radius);
+}
+
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+template <typename Tag, typename Geometry, std::size_t Dimension>
+struct radius_access
+{
+    static inline typename radius_type<Geometry>::type get(Geometry const& geometry)
+    {
+        return traits::radius_access<Geometry, Dimension>::get(geometry);
+    }
+    static inline void set(Geometry& geometry,
+                           typename radius_type<Geometry>::type const& value)
+    {
+        traits::radius_access<Geometry, Dimension>::set(geometry, value);
+    }
+};
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace core_dispatch
+{
+
+template <typename Tag,
+          typename Geometry,
+          std::size_t Dimension>
+struct radius_access<Tag, Geometry, Dimension, boost::true_type>
+{
+    typedef typename geometry::radius_type<Geometry>::type radius_type;
+
+    static inline radius_type get(const Geometry * geometry)
+    {
+        return radius_access
+                <
+                    Tag,
+                    Geometry,
+                    Dimension,
+                    typename boost::is_pointer<Geometry>::type
+                >::get(*geometry);
+    }
+
+    static inline void set(Geometry * geometry, radius_type const& value)
+    {
+        return radius_access
+                <
+                    Tag,
+                    Geometry,
+                    Dimension,
+                    typename boost::is_pointer<Geometry>::type
+                >::set(*geometry, value);
+    }
+};
+
+
+template <typename Geometry>
+struct radius_type<srs_sphere_tag, Geometry>
+{
+    typedef typename traits::radius_type<Geometry>::type type;
+};
+
+template <typename Geometry, std::size_t Dimension>
+struct radius_access<srs_sphere_tag, Geometry, Dimension, boost::false_type>
+    : detail::radius_access<srs_sphere_tag, Geometry, Dimension>
+{
+    BOOST_STATIC_ASSERT(Dimension == 0);
+    //BOOST_STATIC_ASSERT(Dimension < 3);
+};
+
+template <typename Geometry>
+struct radius_type<srs_spheroid_tag, Geometry>
+{
+    typedef typename traits::radius_type<Geometry>::type type;
+};
+
+template <typename Geometry, std::size_t Dimension>
+struct radius_access<srs_spheroid_tag, Geometry, Dimension, boost::false_type>
+    : detail::radius_access<srs_spheroid_tag, Geometry, Dimension>
+{
+    BOOST_STATIC_ASSERT(Dimension == 0 || Dimension == 2);
+    //BOOST_STATIC_ASSERT(Dimension < 3);
+};
+
+} // namespace core_dispatch
+#endif // DOXYGEN_NO_DISPATCH
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_CORE_RADIUS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/reverse_dispatch.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/reverse_dispatch.hpp
new file mode 100644
index 00000000000..c95182a34d5
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/reverse_dispatch.hpp
@@ -0,0 +1,66 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_CORE_REVERSE_DISPATCH_HPP
+#define BOOST_GEOMETRY_CORE_REVERSE_DISPATCH_HPP
+
+
+#include <cstddef>
+
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/integral_constant.hpp>
+
+#include <boost/geometry/core/geometry_id.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DETAIL
+namespace detail
+{
+
+// Different geometries: reverse_dispatch if second ID < first ID
+template <std::size_t GeometryId1, std::size_t GeometryId2>
+struct reverse_dispatch : boost::mpl::if_c
+    <
+        (GeometryId1 > GeometryId2),
+        boost::true_type,
+        boost::false_type
+    >
+{};
+
+
+// Same geometry: never reverse_dispatch
+template <std::size_t GeometryId>
+struct reverse_dispatch<GeometryId, GeometryId> : boost::false_type {};
+
+
+} // namespace detail
+#endif // DOXYGEN_NO_DETAIL
+
+
+template <typename Geometry1, typename Geometry2>
+struct reverse_dispatch : detail::reverse_dispatch
+    <
+        geometry_id<Geometry1>::type::value,
+        geometry_id<Geometry2>::type::value
+    >
+{};
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_CORE_REVERSE_DISPATCH_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/ring_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/ring_type.hpp
new file mode 100644
index 00000000000..c0079311263
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/ring_type.hpp
@@ -0,0 +1,226 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2015 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2015 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2015 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2015.
+// Modifications copyright (c) 2015, Oracle and/or its affiliates.
+
+// Contributed and/or modified by Menelaos Karavelas, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_CORE_RING_TYPE_HPP
+#define BOOST_GEOMETRY_CORE_RING_TYPE_HPP
+
+
+#include <boost/mpl/assert.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/remove_reference.hpp>
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace traits
+{
+
+
+/*!
+\brief Traits class to indicate ring-type  of a polygon's exterior ring/interior rings
+\ingroup traits
+\par Geometries:
+    - polygon
+\par Specializations should provide:
+    - typedef XXX type ( e.g. ring<P> )
+\tparam Geometry geometry
+*/
+template <typename Geometry>
+struct ring_const_type
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
+            , (types<Geometry>)
+        );
+};
+
+template <typename Geometry>
+struct ring_mutable_type
+{
+    BOOST_MPL_ASSERT_MSG
+        (
+            false, NOT_IMPLEMENTED_FOR_THIS_GEOMETRY_TYPE
+            , (types<Geometry>)
+        );
+};
+
+
+} // namespace traits
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace core_dispatch
+{
+
+template <typename GeometryTag, typename Geometry>
+struct ring_return_type
+{};
+
+
+template <typename LineString>
+struct ring_return_type<linestring_tag, LineString>
+{
+    typedef LineString& type;
+};
+
+
+template <typename Ring>
+struct ring_return_type<ring_tag, Ring>
+{
+    typedef Ring& type;
+};
+
+
+template <typename Polygon>
+struct ring_return_type<polygon_tag, Polygon>
+{
+    typedef typename boost::remove_const<Polygon>::type nc_polygon_type;
+
+    typedef typename boost::mpl::if_
+        <
+            boost::is_const<Polygon>,
+            typename traits::ring_const_type<nc_polygon_type>::type,
+            typename traits::ring_mutable_type<nc_polygon_type>::type
+        >::type type;
+};
+
+
+template <typename MultiLinestring>
+struct ring_return_type<multi_linestring_tag, MultiLinestring>
+{
+    typedef typename ring_return_type
+        <
+            linestring_tag,
+            typename boost::mpl::if_
+                <
+                    boost::is_const<MultiLinestring>,
+                    typename boost::range_value<MultiLinestring>::type const,
+                    typename boost::range_value<MultiLinestring>::type
+                >::type
+        >::type type;
+};
+
+
+template <typename MultiPolygon>
+struct ring_return_type<multi_polygon_tag, MultiPolygon>
+{
+    typedef typename ring_return_type
+        <
+            polygon_tag,
+            typename boost::mpl::if_
+                <
+                    boost::is_const<MultiPolygon>,
+                    typename boost::range_value<MultiPolygon>::type const,
+                    typename boost::range_value<MultiPolygon>::type
+                >::type
+        >::type type;
+};
+
+
+template <typename GeometryTag, typename Geometry>
+struct ring_type
+{};
+
+
+template <typename Ring>
+struct ring_type<ring_tag, Ring>
+{
+    typedef Ring type;
+};
+
+
+template <typename Polygon>
+struct ring_type<polygon_tag, Polygon>
+{
+    typedef typename boost::remove_reference
+        <
+            typename ring_return_type<polygon_tag, Polygon>::type
+        >::type type;
+};
+
+
+template <typename MultiLinestring>
+struct ring_type<multi_linestring_tag, MultiLinestring>
+{
+    typedef typename boost::remove_reference
+        <
+            typename ring_return_type<multi_linestring_tag, MultiLinestring>::type
+        >::type type;
+};
+
+
+template <typename MultiPolygon>
+struct ring_type<multi_polygon_tag, MultiPolygon>
+{
+    typedef typename boost::remove_reference
+        <
+            typename ring_return_type<multi_polygon_tag, MultiPolygon>::type
+        >::type type;
+};
+
+
+} // namespace core_dispatch
+#endif
+
+
+/*!
+\brief \brief_meta{type, ring_type, \meta_geometry_type}
+\details A polygon contains one exterior ring
+    and zero or more interior rings (holes).
+    This metafunction retrieves the type of the rings.
+    Exterior ring and each of the interior rings all have the same ring_type.
+\tparam Geometry A type fullfilling the Ring, Polygon or MultiPolygon concept.
+\ingroup core
+
+\qbk{[include reference/core/ring_type.qbk]}
+*/
+template <typename Geometry>
+struct ring_type
+{
+    typedef typename core_dispatch::ring_type
+        <
+            typename tag<Geometry>::type,
+            Geometry
+        >::type type;
+};
+
+
+template <typename Geometry>
+struct ring_return_type
+{
+    typedef typename core_dispatch::ring_return_type
+        <
+            typename tag<Geometry>::type,
+            Geometry
+        >::type type;
+};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_CORE_RING_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/srs.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/srs.hpp
new file mode 100644
index 00000000000..5c78b9f1fc4
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/srs.hpp
@@ -0,0 +1,196 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014, 2016, 2017.
+// Modifications copyright (c) 2014-2017 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_CORE_SRS_HPP
+#define BOOST_GEOMETRY_CORE_SRS_HPP
+
+
+#include <cstddef>
+
+#include <boost/static_assert.hpp>
+
+#include <boost/geometry/core/radius.hpp>
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+    
+namespace srs
+{
+
+/*!
+    \brief Defines spheroid radius values for use in geographical CS calculations
+    \note See http://en.wikipedia.org/wiki/Figure_of_the_Earth
+          and http://en.wikipedia.org/wiki/World_Geodetic_System#A_new_World_Geodetic_System:_WGS84
+*/
+template <typename RadiusType>
+class spheroid
+{
+public:
+    spheroid(RadiusType const& a, RadiusType const& b)
+        : m_a(a)
+        , m_b(b)
+    {}
+
+    spheroid()
+        : m_a(RadiusType(6378137.0))
+        , m_b(RadiusType(6356752.3142451793))
+    {}
+
+    template <std::size_t I>
+    RadiusType get_radius() const
+    {
+        BOOST_STATIC_ASSERT(I < 3);
+
+        return I < 2 ? m_a : m_b;
+    }
+
+    template <std::size_t I>
+    void set_radius(RadiusType const& radius)
+    {
+        BOOST_STATIC_ASSERT(I < 3);
+
+        (I < 2 ? m_a : m_b) = radius;
+    }
+
+private:
+    RadiusType m_a, m_b; // equatorial radius, polar radius
+};
+
+} // namespace srs
+
+// Traits specializations for spheroid
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+template <typename RadiusType>
+struct tag< srs::spheroid<RadiusType> >
+{
+    typedef srs_spheroid_tag type;
+};
+
+template <typename RadiusType>
+struct radius_type< srs::spheroid<RadiusType> >
+{
+    typedef RadiusType type;
+};
+
+template <typename RadiusType, std::size_t Dimension>
+struct radius_access<srs::spheroid<RadiusType>, Dimension>
+{
+    typedef srs::spheroid<RadiusType> spheroid_type;
+
+    static inline RadiusType get(spheroid_type const& s)
+    {
+        return s.template get_radius<Dimension>();
+    }
+
+    static inline void set(spheroid_type& s, RadiusType const& value)
+    {
+        s.template set_radius<Dimension>(value);
+    }
+};
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+
+namespace srs
+{
+
+/*!
+    \brief Defines sphere radius value for use in spherical CS calculations
+*/
+template <typename RadiusType>
+class sphere
+{
+public:
+    explicit sphere(RadiusType const& r)
+        : m_r(r)
+    {}
+
+    sphere()
+        : m_r(RadiusType((2.0 * 6378137.0 + 6356752.3142451793) / 3.0))
+    {}
+
+    template <std::size_t I>
+    RadiusType get_radius() const
+    {
+        BOOST_STATIC_ASSERT(I < 3);
+
+        return m_r;
+    }
+
+    template <std::size_t I>
+    void set_radius(RadiusType const& radius)
+    {
+        BOOST_STATIC_ASSERT(I < 3);
+
+        m_r = radius;
+    }
+
+private:
+    RadiusType m_r; // radius
+};
+
+} // namespace srs
+
+// Traits specializations for sphere
+#ifndef DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+namespace traits
+{
+
+template <typename RadiusType>
+struct tag< srs::sphere<RadiusType> >
+{
+    typedef srs_sphere_tag type;
+};
+
+template <typename RadiusType>
+struct radius_type< srs::sphere<RadiusType> >
+{
+    typedef RadiusType type;
+};
+
+template <typename RadiusType, std::size_t Dimension>
+struct radius_access<srs::sphere<RadiusType>, Dimension>
+{
+    typedef srs::sphere<RadiusType> sphere_type;
+
+    static inline RadiusType get(sphere_type const& s)
+    {
+        return s.template get_radius<Dimension>();
+    }
+
+    static inline void set(sphere_type& s, RadiusType const& value)
+    {
+        s.template set_radius<Dimension>(value);
+    }
+};
+
+} // namespace traits
+#endif // DOXYGEN_NO_TRAITS_SPECIALIZATIONS
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_CORE_SRS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/tag.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/tag.hpp
new file mode 100644
index 00000000000..14a22427086
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/tag.hpp
@@ -0,0 +1,69 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_CORE_TAG_HPP
+#define BOOST_GEOMETRY_CORE_TAG_HPP
+
+
+#include <boost/geometry/core/tags.hpp>
+#include <boost/geometry/util/bare_type.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+namespace traits
+{
+
+/*!
+\brief Traits class to attach a tag to a geometry
+\details All geometries should implement a traits::tag<G>::type metafunction to indicate their
+    own geometry type.
+\ingroup traits
+\par Geometries:
+    - all geometries
+\par Specializations should provide:
+    - typedef XXX_tag type; (point_tag, box_tag, ...)
+\tparam Geometry geometry
+*/
+template <typename Geometry, typename Enable = void>
+struct tag
+{
+    typedef void type;
+};
+
+} // namespace traits
+
+
+
+/*!
+\brief \brief_meta{type, tag, \meta_geometry_type}
+\details With Boost.Geometry, tags are the driving force of the tag dispatching
+    mechanism. The tag metafunction is therefore used in every free function.
+\tparam Geometry \tparam_geometry
+\ingroup core
+
+\qbk{[include reference/core/tag.qbk]}
+*/
+template <typename Geometry>
+struct tag
+{
+    typedef typename traits::tag
+        <
+            typename geometry::util::bare_type<Geometry>::type
+        >::type type;
+};
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_CORE_TAG_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/tag_cast.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/tag_cast.hpp
new file mode 100644
index 00000000000..e03d841f49a
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/tag_cast.hpp
@@ -0,0 +1,84 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_CORE_TAG_CAST_HPP
+#define BOOST_GEOMETRY_CORE_TAG_CAST_HPP
+
+
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+
+namespace boost { namespace geometry
+{
+
+/*!
+\brief Metafunction defining a type being either the specified tag, or one
+    of the specified basetags if the type inherits from them.
+\details Tags can inherit each other. A multi_point inherits, for example,
+    both the multi_tag and the pointlike_tag. Often behaviour can be shared
+    between different geometry types. A tag, found by the metafunction tag,
+    can be casted to a more basic tag, and then dispatched by that tag.
+\ingroup core
+\tparam Tag The tag to be casted to one of the base tags
+\tparam BaseTag First base tag
+\tparam BaseTag2 Optional second base tag
+\tparam BaseTag3 Optional third base tag
+\tparam BaseTag4 Optional fourth base tag
+\tparam BaseTag5 Optional fifth base tag
+\tparam BaseTag6 Optional sixth base tag
+\tparam BaseTag7 Optional seventh base tag
+
+\qbk{[include reference/core/tag_cast.qbk]}
+*/
+template
+<
+    typename Tag,
+    typename BaseTag,
+    typename BaseTag2 = void,
+    typename BaseTag3 = void,
+    typename BaseTag4 = void,
+    typename BaseTag5 = void,
+    typename BaseTag6 = void,
+    typename BaseTag7 = void
+>
+struct tag_cast
+{
+    typedef typename boost::mpl::if_
+        <
+          typename boost::is_base_of<BaseTag, Tag>::type,
+          BaseTag,
+          // Try next one in line:
+          typename tag_cast
+            <
+                Tag, BaseTag2, BaseTag3, BaseTag4,
+                BaseTag5, BaseTag6, BaseTag7, void
+            >::type
+        >::type type;
+};
+
+#ifndef DOXYGEN_NO_SPECIALIZATIONS
+
+// Specialization for last one
+template <typename Tag>
+struct tag_cast<Tag, void, void, void, void, void, void, void>
+{
+    // If not found, take specified tag, so do not cast
+    typedef Tag type;
+};
+
+#endif // DOXYGEN_NO_SPECIALIZATIONS
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_CORE_TAG_CAST_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/tags.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/tags.hpp
new file mode 100644
index 00000000000..5d6acb18780
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/tags.hpp
@@ -0,0 +1,150 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2014.
+// Modifications copyright (c) 2014 Oracle and/or its affiliates.
+
+// Contributed and/or modified by Adam Wulkiewicz, on behalf of Oracle
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_CORE_TAGS_HPP
+#define BOOST_GEOMETRY_CORE_TAGS_HPP
+
+
+namespace boost { namespace geometry
+{
+
+// Tags defining strategies linked to coordinate systems
+
+/// Tag used for casting spherical/geographic coordinate systems
+struct spherical_tag {};
+
+
+/// Tag indicating Cartesian coordinate system family (cartesian,epsg)
+struct cartesian_tag {};
+
+/// Tag indicating Spherical polar coordinate system family
+struct spherical_polar_tag : spherical_tag {};
+
+/// Tag indicating Spherical equatorial coordinate system family
+struct spherical_equatorial_tag : spherical_tag {};
+
+/// Tag indicating Geographic coordinate system family (geographic)
+struct geographic_tag : spherical_tag {};
+
+
+// Tags defining coordinate systems reference models
+
+/// For reference spheroid defining parameters of geographical coordinate system
+struct srs_spheroid_tag {};
+
+/// For reference sphere defining parameters of spherical coordinate system
+struct srs_sphere_tag : srs_spheroid_tag {};
+
+
+// Tags defining tag hierarchy
+
+/// For single-geometries (point, linestring, polygon, box, ring, segment)
+struct single_tag {};
+
+
+/// For multiple-geometries (multi_point, multi_linestring, multi_polygon)
+struct multi_tag {};
+
+/// For point-like types (point, multi_point)
+struct pointlike_tag {};
+
+/// For linear types (linestring, multi-linestring, segment)
+struct linear_tag {};
+
+/// For areal types (polygon, multi_polygon, box, ring)
+struct areal_tag {};
+
+// Subset of areal types (polygon, multi_polygon, ring)
+struct polygonal_tag : areal_tag {};
+
+/// For volume types (also box (?), polyhedron)
+struct volumetric_tag {};
+
+
+// Tags defining geometry types
+
+
+/// "default" tag
+struct geometry_not_recognized_tag {};
+
+/// OGC Point identifying tag
+struct point_tag : single_tag, pointlike_tag {};
+
+/// OGC Linestring identifying tag
+struct linestring_tag : single_tag, linear_tag {};
+
+/// OGC Polygon identifying tag
+struct polygon_tag : single_tag, polygonal_tag {};
+
+/// Convenience (linear) ring identifying tag
+struct ring_tag : single_tag, polygonal_tag {};
+
+/// Convenience 2D or 3D box (mbr / aabb) identifying tag
+struct box_tag : single_tag, areal_tag {};
+
+/// Convenience segment (2-points) identifying tag
+struct segment_tag : single_tag, linear_tag {};
+
+
+/// OGC Multi point identifying tag
+struct multi_point_tag : multi_tag, pointlike_tag  {};
+
+/// OGC Multi linestring identifying tag
+struct multi_linestring_tag : multi_tag, linear_tag {};
+
+/// OGC Multi polygon identifying tag
+struct multi_polygon_tag : multi_tag, polygonal_tag {};
+
+/// OGC Geometry Collection identifying tag
+struct geometry_collection_tag : multi_tag {};
+
+
+/*!
+\brief Meta-function to get for a tag of a multi-geometry
+    the tag of the corresponding single-geometry
+*/
+template <typename Tag>
+struct single_tag_of
+{};
+
+#ifndef DOXYGEN_NO_DETAIL
+
+template <>
+struct single_tag_of<multi_point_tag>
+{
+    typedef point_tag type;
+};
+
+template <>
+struct single_tag_of<multi_linestring_tag>
+{
+    typedef linestring_tag type;
+};
+
+template <>
+struct single_tag_of<multi_polygon_tag>
+{
+    typedef polygon_tag type;
+};
+
+#endif
+
+
+}} // namespace boost::geometry
+
+#endif // BOOST_GEOMETRY_CORE_TAGS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/core/topological_dimension.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/core/topological_dimension.hpp
new file mode 100644
index 00000000000..22ed676fc61
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/core/topological_dimension.hpp
@@ -0,0 +1,101 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_CORE_TOPOLOGICAL_DIMENSION_HPP
+#define BOOST_GEOMETRY_CORE_TOPOLOGICAL_DIMENSION_HPP
+
+
+#include <boost/mpl/int.hpp>
+
+
+#include <boost/geometry/core/tag.hpp>
+#include <boost/geometry/core/tags.hpp>
+
+
+namespace boost { namespace geometry
+{
+
+
+#ifndef DOXYGEN_NO_DISPATCH
+namespace core_dispatch
+{
+
+
+template <typename GeometryTag>
+struct top_dim {};
+
+
+template <>
+struct top_dim<point_tag>      : boost::mpl::int_<0> {};
+
+
+template <>
+struct top_dim<linestring_tag> : boost::mpl::int_<1> {};
+
+
+template <>
+struct top_dim<segment_tag>    : boost::mpl::int_<1> {};
+
+
+// ring: topological dimension of two, but some people say: 1 !!
+// NOTE: This is not OGC LinearRing!
+template <>
+struct top_dim<ring_tag>       : boost::mpl::int_<2> {};
+
+
+// TODO: This is wrong! Boxes may have various topological dimensions
+template <>
+struct top_dim<box_tag>        : boost::mpl::int_<2> {};
+
+
+template <>
+struct top_dim<polygon_tag>    : boost::mpl::int_<2> {};
+
+
+template <>
+struct top_dim<multi_point_tag> : boost::mpl::int_<0> {};
+
+
+template <>
+struct top_dim<multi_linestring_tag> : boost::mpl::int_<1> {};
+
+
+template <>
+struct top_dim<multi_polygon_tag> : boost::mpl::int_<2> {};
+
+
+} // namespace core_dispatch
+#endif
+
+
+
+
+
+/*!
+    \brief Meta-function returning the topological dimension of a geometry
+    \details The topological dimension defines a point as 0-dimensional,
+        a linestring as 1-dimensional,
+        and a ring or polygon as 2-dimensional.
+    \see http://www.math.okstate.edu/mathdept/dynamics/lecnotes/node36.html
+    \ingroup core
+*/
+template <typename Geometry>
+struct topological_dimension
+    : core_dispatch::top_dim<typename tag<Geometry>::type> {};
+
+
+}} // namespace boost::geometry
+
+
+#endif // BOOST_GEOMETRY_CORE_TOPOLOGICAL_DIMENSION_HPP

From 14d5149293a4efc05d2e49e397275771750f0ff0 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Mon, 4 Sep 2017 22:33:17 +0300
Subject: [PATCH 071/266] Added missing files [#CLICKHOUSE-3276].

---
 .gitignore                                    |  1 +
 .../boost/geometry/multi/core/closure.hpp     | 19 ++++++++++++++
 .../boost/geometry/multi/core/geometry_id.hpp | 20 +++++++++++++++
 .../geometry/multi/core/interior_rings.hpp    | 22 ++++++++++++++++
 .../boost/geometry/multi/core/is_areal.hpp    | 22 ++++++++++++++++
 .../boost/geometry/multi/core/point_order.hpp | 21 ++++++++++++++++
 .../boost/geometry/multi/core/point_type.hpp  | 22 ++++++++++++++++
 .../boost/geometry/multi/core/ring_type.hpp   | 25 +++++++++++++++++++
 .../boost/geometry/multi/core/tags.hpp        | 22 ++++++++++++++++
 .../multi/core/topological_dimension.hpp      | 22 ++++++++++++++++
 10 files changed, 196 insertions(+)
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/core/closure.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/core/geometry_id.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/core/interior_rings.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/core/is_areal.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/core/point_order.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/core/point_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/core/ring_type.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/core/tags.hpp
 create mode 100644 contrib/libboost/boost_1_65_0/boost/geometry/multi/core/topological_dimension.hpp

diff --git a/.gitignore b/.gitignore
index 208b03861e6..02643f94e09 100644
--- a/.gitignore
+++ b/.gitignore
@@ -191,6 +191,7 @@ config-9001.xml
 *-preprocessed.xml
 
 core
+!core/
 vgcore*
 
 *.deb
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/closure.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/closure.hpp
new file mode 100644
index 00000000000..9e7cf3c248e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/closure.hpp
@@ -0,0 +1,19 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_CORE_CLOSURE_HPP
+#define BOOST_GEOMETRY_MULTI_CORE_CLOSURE_HPP
+
+#include <boost/geometry/core/closure.hpp>
+
+#endif // BOOST_GEOMETRY_MULTI_CORE_CLOSURE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/geometry_id.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/geometry_id.hpp
new file mode 100644
index 00000000000..7d5e888babd
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/geometry_id.hpp
@@ -0,0 +1,20 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_MULTI_CORE_GEOMETRY_ID_HPP
+#define BOOST_GEOMETRY_MULTI_CORE_GEOMETRY_ID_HPP
+
+#include <boost/geometry/core/geometry_id.hpp>
+
+#endif // BOOST_GEOMETRY_MULTI_CORE_GEOMETRY_ID_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/interior_rings.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/interior_rings.hpp
new file mode 100644
index 00000000000..deeeff81d0e
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/interior_rings.hpp
@@ -0,0 +1,22 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_MULTI_CORE_INTERIOR_RINGS_HPP
+#define BOOST_GEOMETRY_MULTI_CORE_INTERIOR_RINGS_HPP
+
+
+#include <boost/geometry/core/interior_rings.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_CORE_INTERIOR_RINGS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/is_areal.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/is_areal.hpp
new file mode 100644
index 00000000000..30f98527ab7
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/is_areal.hpp
@@ -0,0 +1,22 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_MULTI_CORE_IS_AREAL_HPP
+#define BOOST_GEOMETRY_MULTI_CORE_IS_AREAL_HPP
+
+
+#include <boost/geometry/core/is_areal.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_CORE_IS_AREAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/point_order.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/point_order.hpp
new file mode 100644
index 00000000000..119e55c3ba1
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/point_order.hpp
@@ -0,0 +1,21 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+#ifndef BOOST_GEOMETRY_MULTI_CORE_POINT_ORDER_HPP
+#define BOOST_GEOMETRY_MULTI_CORE_POINT_ORDER_HPP
+
+
+#include <boost/geometry/core/point_order.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_CORE_POINT_ORDER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/point_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/point_type.hpp
new file mode 100644
index 00000000000..a7277d09a91
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/point_type.hpp
@@ -0,0 +1,22 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_MULTI_CORE_POINT_TYPE_HPP
+#define BOOST_GEOMETRY_MULTI_CORE_POINT_TYPE_HPP
+
+
+#include <boost/geometry/core/point_type.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_CORE_POINT_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/ring_type.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/ring_type.hpp
new file mode 100644
index 00000000000..b27b5527c22
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/ring_type.hpp
@@ -0,0 +1,25 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// This file was modified by Oracle on 2013.
+// Modifications copyright (c) 2013, Oracle and/or its affiliates.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_MULTI_CORE_RING_TYPE_HPP
+#define BOOST_GEOMETRY_MULTI_CORE_RING_TYPE_HPP
+
+
+#include <boost/geometry/core/ring_type.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_CORE_RING_TYPE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/tags.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/tags.hpp
new file mode 100644
index 00000000000..fb0758d95f8
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/tags.hpp
@@ -0,0 +1,22 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_MULTI_CORE_TAGS_HPP
+#define BOOST_GEOMETRY_MULTI_CORE_TAGS_HPP
+
+
+#include <boost/geometry/core/tags.hpp>
+
+
+#endif // BOOST_GEOMETRY_MULTI_CORE_TAGS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/topological_dimension.hpp b/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/topological_dimension.hpp
new file mode 100644
index 00000000000..b4f1e89ae87
--- /dev/null
+++ b/contrib/libboost/boost_1_65_0/boost/geometry/multi/core/topological_dimension.hpp
@@ -0,0 +1,22 @@
+// Boost.Geometry (aka GGL, Generic Geometry Library)
+
+// Copyright (c) 2007-2012 Barend Gehrels, Amsterdam, the Netherlands.
+// Copyright (c) 2008-2012 Bruno Lalande, Paris, France.
+// Copyright (c) 2009-2012 Mateusz Loskot, London, UK.
+
+// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
+// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.
+
+// 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)
+
+
+#ifndef BOOST_GEOMETRY_MULTI_TOPOLOGICAL_DIMENSION_HPP
+#define BOOST_GEOMETRY_MULTI_TOPOLOGICAL_DIMENSION_HPP
+
+
+#include <boost/geometry/core/topological_dimension.hpp>
+
+
+#endif

From b37790d27e131c8d6bcb5749154dcbeebc050c76 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Mon, 4 Sep 2017 23:21:55 +0300
Subject: [PATCH 072/266] Minor modifications [#CLICKHOUSE-3201].

---
 dbms/src/Functions/FunctionsGeo.cpp | 65 ++++++++++++++++-------------
 1 file changed, 35 insertions(+), 30 deletions(-)

diff --git a/dbms/src/Functions/FunctionsGeo.cpp b/dbms/src/Functions/FunctionsGeo.cpp
index f8d3d4b2fbf..2dae9288d71 100644
--- a/dbms/src/Functions/FunctionsGeo.cpp
+++ b/dbms/src/Functions/FunctionsGeo.cpp
@@ -8,6 +8,7 @@
 #include <Interpreters/ExpressionActions.h>
 #include <DataTypes/DataTypeTuple.h>
 #include <Columns/ColumnTuple.h>
+#include <IO/WriteHelpers.h>
 
 
 namespace DB
@@ -29,6 +30,9 @@ using PointInPolygonFranklin = boost::geometry::strategy::within::franklin<Args.
 template <template <typename...> typename Strategy>
 class FunctionPointInPolygon : public IFunction
 {
+private:
+    using CoordinateType = Float64;
+
 public:
     static const char * name;
 
@@ -52,6 +56,7 @@ public:
         return 0;
     }
 
+
     void getReturnTypeAndPrerequisitesImpl(
         const ColumnsWithTypeAndName & arguments, DataTypePtr & out_return_type, ExpressionActions::Actions & out_prerequisites) override
     {
@@ -65,21 +70,22 @@ public:
             const DataTypeTuple * tuple = checkAndGetDataType<DataTypeTuple>(&*arguments[i].type);
             if (tuple == nullptr)
             {
-                throw Exception("Argument " + std::to_string(i+1) + " for function " + getName() + " must be tuple.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                throw Exception("Argument " + toString(i + 1) + " for function " + getName() + " must be tuple.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
             }
 
             const DataTypes & elems = tuple->getElements();
 
             if (elems.size() != 2)
             {
-                throw Exception("Tuple in argument " + std::to_string(i+1) + " must have exactly two elements.", ErrorCodes::BAD_ARGUMENTS);
+                throw Exception("Tuple in argument " + toString(i + 1) + " must have exactly two elements.", ErrorCodes::BAD_ARGUMENTS);
             }
 
             for (size_t elems_index = 0; elems_index < elems.size(); ++elems_index)
             {
-                if (!checkDataType<DataTypeFloat64>(&*elems[elems_index]))
+                if (!checkDataType<DataTypeNumber<CoordinateType>>(&*elems[elems_index]))
                 {
-                    throw Exception("Tuple element " + std::to_string(elems_index + 1) + " in argument " + std::to_string(i+1) + " must be Float64.", ErrorCodes::BAD_ARGUMENTS);
+                    throw Exception("Tuple element " + toString(elems_index + 1) + " in argument " + toString(i + 1)
+                        + " must be " + TypeName<CoordinateType>::get() + ".", ErrorCodes::BAD_ARGUMENTS);
                 }
             }
         }
@@ -87,31 +93,28 @@ public:
         out_return_type = std::make_shared<DataTypeUInt8>();
     }
 
+
     void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override
     {
-        if (block.rows() == 0)
-        {
-            return;
-        }
-
-        using PointType = boost::geometry::model::d2::point_xy<double>;
+        using PointType = boost::geometry::model::d2::point_xy<CoordinateType>;
         using PolygonType = boost::geometry::model::polygon<PointType>;
-        std::pair<double, double> min, max;
+        std::pair<CoordinateType, CoordinateType> min, max;
 
-        std::vector<PointType> polygon_points(arguments.size()-1);
+        std::vector<PointType> polygon_points(arguments.size() - 1);
 
         for (size_t i = 1; i < arguments.size(); ++i)
         {
             auto const_tuple_col = checkAndGetColumnConst<ColumnTuple>(block.getByPosition(arguments[i]).column.get());
             if (!const_tuple_col)
             {
-                throw Exception("Argument " + std::to_string(i+1) + " for function " + getName() + " must be constant tuple.", ErrorCodes::ILLEGAL_COLUMN);
+                throw Exception("Argument " + toString(i + 1) + " for function " + getName() + " must be constant tuple.", ErrorCodes::ILLEGAL_COLUMN);
             }
 
             TupleBackend data = const_tuple_col->getValue<Tuple>();
-            const double x = data[0].get<Float64>();
-            const double y = data[1].get<Float64>();
-            polygon_points[i-1] = PointType(x, y);
+            const CoordinateType x = data[0].get<Float64>();
+            const CoordinateType y = data[1].get<Float64>();
+            polygon_points[i - 1] = PointType(x, y);
+
             if (i == 1)
             {
                 min.first = x;
@@ -132,41 +135,43 @@ public:
         boost::geometry::assign_points(polygon, polygon_points);
 
         Strategy<PointType> strategy;
-        auto point_checker = [&](double x, double y) -> bool
+
+        auto point_checker = [&](CoordinateType x, CoordinateType y) -> bool
         {
             if (x < min.first || x > max.first || y < min.second || y > max.second)
-            {
                 return false;
-            }
+
             PointType point(x, y);
             return boost::geometry::covered_by(point, polygon, strategy);
         };
 
+        size_t rows = block.rows();
+
         auto point_column_const = checkAndGetColumnConst<ColumnTuple>(block.getByPosition(arguments[0]).column.get());
         if (point_column_const)
         {
             TupleBackend data = point_column_const->getValue<Tuple>();
-            const double point_x = data[0].get<Float64>();
-            const double point_y = data[1].get<Float64>();
-            UInt8 value = point_checker(point_x, point_y) ? 1 : 0;
-            block.getByPosition(result).column = DataTypeUInt8().createConstColumn(block.rows(), UInt64(value));
+            const CoordinateType point_x = data[0].get<Float64>();
+            const CoordinateType point_y = data[1].get<Float64>();
+            UInt8 value = point_checker(point_x, point_y);
+            block.getByPosition(result).column = DataTypeUInt8().createConstColumn(rows, UInt64(value));
             return;
         }
 
         auto & res = block.getByPosition(result);
-        res.column = std::make_shared<ColumnUInt8>(block.rows());
+        res.column = std::make_shared<ColumnUInt8>(rows);
         IColumn & result_column = *res.column;
         auto & result_data = static_cast<ColumnUInt8 &>(result_column).getData();
 
         auto point_column = checkAndGetColumn<ColumnTuple>(block.getByPosition(arguments[0]).column.get());
-        auto column_x = checkAndGetColumn<ColumnFloat64>(point_column->getData().getByPosition(0).column.get());
-        auto column_y = checkAndGetColumn<ColumnFloat64>(point_column->getData().getByPosition(1).column.get());
+        auto column_x = checkAndGetColumn<ColumnVector<CoordinateType>>(point_column->getData().getByPosition(0).column.get());
+        auto column_y = checkAndGetColumn<ColumnVector<CoordinateType>>(point_column->getData().getByPosition(1).column.get());
 
-        for (size_t i = 0; i < block.rows(); ++i)
+        for (size_t i = 0; i < rows; ++i)
         {
-            const double point_x = column_x->getElement(i);
-            const double point_y = column_y->getElement(i);
-            result_data[i] = point_checker(point_x, point_y) ? 1 : 0;
+            const CoordinateType point_x = column_x->getElement(i);
+            const CoordinateType point_y = column_y->getElement(i);
+            result_data[i] = point_checker(point_x, point_y);
         }
     }
 };

From 96061a9053a0d989bc78423c57e694bb88d95683 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Tue, 5 Sep 2017 00:35:28 +0300
Subject: [PATCH 073/266] Temporarily removed test for incomplete modification
 [#CLICKHOUSE-2].

---
 dbms/tests/queries/0_stateless/00498_http_head.reference | 0
 dbms/tests/queries/0_stateless/00498_http_head.sh        | 4 ----
 2 files changed, 4 deletions(-)
 delete mode 100644 dbms/tests/queries/0_stateless/00498_http_head.reference
 delete mode 100755 dbms/tests/queries/0_stateless/00498_http_head.sh

diff --git a/dbms/tests/queries/0_stateless/00498_http_head.reference b/dbms/tests/queries/0_stateless/00498_http_head.reference
deleted file mode 100644
index e69de29bb2d..00000000000
diff --git a/dbms/tests/queries/0_stateless/00498_http_head.sh b/dbms/tests/queries/0_stateless/00498_http_head.sh
deleted file mode 100755
index 558730d3ae3..00000000000
--- a/dbms/tests/queries/0_stateless/00498_http_head.sh
+++ /dev/null
@@ -1,4 +0,0 @@
-#!/usr/bin/env bash
-
-curl -s -X "HEAD" 'http://localhost:8123/?query=SELECT%201'
-curl -s -X "HEAD" 'http://localhost:8123/?query=select+*+from+system.numbers+limit+1000000'

From 057b2790b4f08e029db83559e180336fd6befb24 Mon Sep 17 00:00:00 2001
From: robot-metrika-test <robot-metrika-test@yandex-team.ru>
Date: Tue, 5 Sep 2017 00:37:29 +0300
Subject: [PATCH 074/266] Auto version update to [54286]

---
 dbms/cmake/version.cmake | 4 ++--
 debian/changelog         | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/dbms/cmake/version.cmake b/dbms/cmake/version.cmake
index 146988c0661..cd9a7744327 100644
--- a/dbms/cmake/version.cmake
+++ b/dbms/cmake/version.cmake
@@ -1,6 +1,6 @@
 # This strings autochanged from release_lib.sh:
-set(VERSION_DESCRIBE v1.1.54285-testing)
-set(VERSION_REVISION 54285)
+set(VERSION_DESCRIBE v1.1.54286-testing)
+set(VERSION_REVISION 54286)
 # end of autochange
 
 set (VERSION_MAJOR 1)
diff --git a/debian/changelog b/debian/changelog
index f88a93b6db1..5df6d6edaac 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,5 +1,5 @@
-clickhouse (1.1.54285) unstable; urgency=low
+clickhouse (1.1.54286) unstable; urgency=low
 
   * Modified source code
 
- --  <robot-metrika-test@yandex-team.ru>  Mon, 04 Sep 2017 17:31:53 +0300
+ --  <robot-metrika-test@yandex-team.ru>  Tue, 05 Sep 2017 00:37:29 +0300

From 2a7813049ea8dd8825de83fa60569f1e36b97efc Mon Sep 17 00:00:00 2001
From: proller <proller@users.noreply.github.com>
Date: Tue, 5 Sep 2017 04:08:26 +0300
Subject: [PATCH 075/266] LibDictionarySource : First lib dictionary version
 with only uint64 type support (#1150)

* Wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* Do not use ccache if ccache defined in CMAKE_CXX_COMPILER_LAUNCHER

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* Config: Allow multiple dictionaries_config

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* wip

* clean

* wip

* clean

* clean

* wip

* clean

* clean

* wip

* wip

* clean

* clean

* clean

* clean

* clean

* Requested changes

* Reqested changes

* Requested changes

* Requested changes

* Requested changes

* Requested changes

* requested changes

* Requested changes

* Requested changes

* requested changes

* Requested changes

* fix

* Requested changes

* Requested changes

* fix

* Requested changes

* Requested changes
---
 dbms/src/Common/SharedLibrary.cpp             |  43 ++++
 dbms/src/Common/SharedLibrary.h               |  36 +++
 dbms/src/DataStreams/IBlockInputStream.cpp    |   7 +
 dbms/src/DataStreams/IBlockInputStream.h      |   2 +-
 dbms/src/DataStreams/LazyBlockInputStream.h   |   7 -
 .../DataStreams/LimitByBlockInputStream.cpp   |   7 -
 .../src/DataStreams/LimitByBlockInputStream.h |   2 -
 dbms/src/DataStreams/NullBlockInputStream.cpp |  14 --
 dbms/src/DataStreams/NullBlockInputStream.h   |   1 -
 dbms/src/DataStreams/OneBlockInputStream.h    |   7 -
 .../Dictionaries/DictionarySourceFactory.cpp  |   5 +
 dbms/src/Dictionaries/HTTPDictionarySource.h  |   2 +-
 .../Dictionaries/LibraryDictionarySource.cpp  | 233 ++++++++++++++++++
 .../Dictionaries/LibraryDictionarySource.h    |  62 +++++
 .../LibraryDictionarySourceExternal.h         |  26 ++
 dbms/src/Interpreters/Compiler.cpp            |   4 +
 dbms/src/Interpreters/Compiler.h              |  49 +---
 dbms/tests/CMakeLists.txt                     |   2 +
 .../external_dictionaries/CMakeLists.txt      |   2 +
 .../dictionary_library/CMakeLists.txt         |  13 +
 .../dictionary_library/dictionary_library.cpp | 159 ++++++++++++
 .../dictionary_library/dictionary_library_c.c |  57 +++++
 .../dictionary_library_empty.cpp              |   1 +
 .../generate_and_test.py                      |  53 +++-
 debian/source/format                          |   2 +-
 25 files changed, 706 insertions(+), 90 deletions(-)
 create mode 100644 dbms/src/Common/SharedLibrary.cpp
 create mode 100644 dbms/src/Common/SharedLibrary.h
 delete mode 100644 dbms/src/DataStreams/NullBlockInputStream.cpp
 create mode 100644 dbms/src/Dictionaries/LibraryDictionarySource.cpp
 create mode 100644 dbms/src/Dictionaries/LibraryDictionarySource.h
 create mode 100644 dbms/src/Dictionaries/LibraryDictionarySourceExternal.h
 create mode 100644 dbms/tests/external_dictionaries/CMakeLists.txt
 create mode 100644 dbms/tests/external_dictionaries/dictionary_library/CMakeLists.txt
 create mode 100644 dbms/tests/external_dictionaries/dictionary_library/dictionary_library.cpp
 create mode 100644 dbms/tests/external_dictionaries/dictionary_library/dictionary_library_c.c
 create mode 100644 dbms/tests/external_dictionaries/dictionary_library/dictionary_library_empty.cpp

diff --git a/dbms/src/Common/SharedLibrary.cpp b/dbms/src/Common/SharedLibrary.cpp
new file mode 100644
index 00000000000..92083055098
--- /dev/null
+++ b/dbms/src/Common/SharedLibrary.cpp
@@ -0,0 +1,43 @@
+#include "SharedLibrary.h"
+#include <string>
+#include <dlfcn.h>
+#include <boost/core/noncopyable.hpp>
+#include "Exception.h"
+
+namespace DB
+{
+namespace ErrorCodes
+{
+    extern const int CANNOT_DLOPEN;
+    extern const int CANNOT_DLSYM;
+}
+
+SharedLibrary::SharedLibrary(const std::string & path)
+{
+    handle = dlopen(path.c_str(), RTLD_LAZY);
+    if (!handle)
+        throw Exception(std::string("Cannot dlopen: ") + dlerror(), ErrorCodes::CANNOT_DLOPEN);
+}
+
+SharedLibrary::~SharedLibrary()
+{
+    if (handle && dlclose(handle))
+        std::terminate();
+}
+
+void * SharedLibrary::getImpl(const std::string & name, bool no_throw)
+{
+    dlerror();
+
+    auto res = dlsym(handle, name.c_str());
+
+    if (char * error = dlerror())
+    {
+        if (no_throw)
+            return nullptr;
+        throw Exception(std::string("Cannot dlsym: ") + error, ErrorCodes::CANNOT_DLSYM);
+    }
+
+    return res;
+}
+}
diff --git a/dbms/src/Common/SharedLibrary.h b/dbms/src/Common/SharedLibrary.h
new file mode 100644
index 00000000000..2b55b396f12
--- /dev/null
+++ b/dbms/src/Common/SharedLibrary.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <boost/core/noncopyable.hpp>
+
+namespace DB
+{
+/** Allows you to open a dynamic library and get a pointer to a function from it.
+  */
+class SharedLibrary : private boost::noncopyable
+{
+public:
+    SharedLibrary(const std::string & path);
+
+    ~SharedLibrary();
+
+    template <typename Func>
+    Func get(const std::string & name)
+    {
+        return reinterpret_cast<Func>(getImpl(name));
+    }
+    template <typename Func>
+    Func tryGet(const std::string & name)
+    {
+        return reinterpret_cast<Func>(getImpl(name, true));
+    }
+
+private:
+    void * getImpl(const std::string & name, bool no_throw = false);
+
+    void * handle = nullptr;
+};
+
+using SharedLibraryPtr = std::shared_ptr<SharedLibrary>;
+}
diff --git a/dbms/src/DataStreams/IBlockInputStream.cpp b/dbms/src/DataStreams/IBlockInputStream.cpp
index 0d7818c3b29..d3c6f06cab9 100644
--- a/dbms/src/DataStreams/IBlockInputStream.cpp
+++ b/dbms/src/DataStreams/IBlockInputStream.cpp
@@ -134,6 +134,13 @@ void IBlockInputStream::getLeavesImpl(BlockInputStreams & res, BlockInputStreamP
             (*it)->getLeavesImpl(res, *it);
 }
 
+/// By default all instances is different streams
+String IBlockInputStream::getID() const
+{
+    std::stringstream res;
+    res << getName() << "(" << this << ")";
+    return res.str();
+};
 
 }
 
diff --git a/dbms/src/DataStreams/IBlockInputStream.h b/dbms/src/DataStreams/IBlockInputStream.h
index 24c4692e3f7..68490b9be2b 100644
--- a/dbms/src/DataStreams/IBlockInputStream.h
+++ b/dbms/src/DataStreams/IBlockInputStream.h
@@ -79,7 +79,7 @@ public:
       *  if several queries are executed simultaneously.
       * If the source can not be glued together with any other - return the object's address as an identifier.
       */
-    virtual String getID() const = 0;
+    virtual String getID() const;
 
     /// If this stream generates data in grouped by some keys, return true.
     virtual bool isGroupedOutput() const { return false; }
diff --git a/dbms/src/DataStreams/LazyBlockInputStream.h b/dbms/src/DataStreams/LazyBlockInputStream.h
index 795e26aa012..8229bedcf65 100644
--- a/dbms/src/DataStreams/LazyBlockInputStream.h
+++ b/dbms/src/DataStreams/LazyBlockInputStream.h
@@ -28,13 +28,6 @@ public:
 
     String getName() const override { return name; }
 
-    String getID() const override
-    {
-        std::stringstream res;
-        res << name << "(" << this << ")";
-        return res.str();
-    }
-
     void cancel() override
     {
         std::lock_guard<std::mutex> lock(cancel_mutex);
diff --git a/dbms/src/DataStreams/LimitByBlockInputStream.cpp b/dbms/src/DataStreams/LimitByBlockInputStream.cpp
index 7a8a2428b54..8e0125a891e 100644
--- a/dbms/src/DataStreams/LimitByBlockInputStream.cpp
+++ b/dbms/src/DataStreams/LimitByBlockInputStream.cpp
@@ -10,13 +10,6 @@ LimitByBlockInputStream::LimitByBlockInputStream(BlockInputStreamPtr input_, siz
     children.push_back(input_);
 }
 
-String LimitByBlockInputStream::getID() const
-{
-    std::stringstream res;
-    res << "LimitBy(" << this << ")";
-    return res.str();
-}
-
 Block LimitByBlockInputStream::readImpl()
 {
     /// Execute until end of stream or until
diff --git a/dbms/src/DataStreams/LimitByBlockInputStream.h b/dbms/src/DataStreams/LimitByBlockInputStream.h
index c90c4bbf72e..0460e799ad6 100644
--- a/dbms/src/DataStreams/LimitByBlockInputStream.h
+++ b/dbms/src/DataStreams/LimitByBlockInputStream.h
@@ -22,8 +22,6 @@ public:
 
     String getName() const override { return "LimitBy"; }
 
-    String getID() const override;
-
 protected:
     Block readImpl() override;
 
diff --git a/dbms/src/DataStreams/NullBlockInputStream.cpp b/dbms/src/DataStreams/NullBlockInputStream.cpp
deleted file mode 100644
index a0042561742..00000000000
--- a/dbms/src/DataStreams/NullBlockInputStream.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-
-#include <DataStreams/NullBlockInputStream.h>
-
-#include <sstream>
-
-namespace DB
-{
-String NullBlockInputStream::getID() const
-{
-    std::stringstream res;
-    res << this;
-    return res.str();
-}
-}
diff --git a/dbms/src/DataStreams/NullBlockInputStream.h b/dbms/src/DataStreams/NullBlockInputStream.h
index a68612afb19..fad7eb6629b 100644
--- a/dbms/src/DataStreams/NullBlockInputStream.h
+++ b/dbms/src/DataStreams/NullBlockInputStream.h
@@ -14,7 +14,6 @@ public:
     Block read() override { return Block(); }
     String getName() const override { return "Null"; }
 
-    String getID() const override;
 };
 
 }
diff --git a/dbms/src/DataStreams/OneBlockInputStream.h b/dbms/src/DataStreams/OneBlockInputStream.h
index a9f0f928696..1a7bbe7efb8 100644
--- a/dbms/src/DataStreams/OneBlockInputStream.h
+++ b/dbms/src/DataStreams/OneBlockInputStream.h
@@ -16,13 +16,6 @@ public:
 
     String getName() const override { return "One"; }
 
-    String getID() const override
-    {
-        std::stringstream res;
-        res << this;
-        return res.str();
-    }
-
 protected:
     Block readImpl() override
     {
diff --git a/dbms/src/Dictionaries/DictionarySourceFactory.cpp b/dbms/src/Dictionaries/DictionarySourceFactory.cpp
index a75618dbdac..e8dcb9e0d3d 100644
--- a/dbms/src/Dictionaries/DictionarySourceFactory.cpp
+++ b/dbms/src/Dictionaries/DictionarySourceFactory.cpp
@@ -6,6 +6,7 @@
 #include <Dictionaries/ClickHouseDictionarySource.h>
 #include <Dictionaries/ExecutableDictionarySource.h>
 #include <Dictionaries/HTTPDictionarySource.h>
+#include <Dictionaries/LibraryDictionarySource.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <DataTypes/DataTypeDate.h>
 #include <Core/FieldVisitors.h>
@@ -171,6 +172,10 @@ DictionarySourcePtr DictionarySourceFactory::create(
 
         return std::make_unique<HTTPDictionarySource>(dict_struct, config, config_prefix + ".http", sample_block, context);
     }
+    else if ("library" == source_type)
+    {
+        return std::make_unique<LibraryDictionarySource>(dict_struct, config, config_prefix + ".library", sample_block, context);
+    }
 
     throw Exception{
         name + ": unknown dictionary source type: " + source_type,
diff --git a/dbms/src/Dictionaries/HTTPDictionarySource.h b/dbms/src/Dictionaries/HTTPDictionarySource.h
index ddbe44aff47..8e8b8bfccd6 100644
--- a/dbms/src/Dictionaries/HTTPDictionarySource.h
+++ b/dbms/src/Dictionaries/HTTPDictionarySource.h
@@ -10,7 +10,7 @@ namespace Poco { class Logger; }
 namespace DB
 {
 
-/// Allows loading dictionaries from executable
+/// Allows loading dictionaries from http[s] source
 class HTTPDictionarySource final : public IDictionarySource
 {
 public:
diff --git a/dbms/src/Dictionaries/LibraryDictionarySource.cpp b/dbms/src/Dictionaries/LibraryDictionarySource.cpp
new file mode 100644
index 00000000000..52559f98e69
--- /dev/null
+++ b/dbms/src/Dictionaries/LibraryDictionarySource.cpp
@@ -0,0 +1,233 @@
+#include <DataStreams/OneBlockInputStream.h>
+#include <Dictionaries/LibraryDictionarySource.h>
+#include <Interpreters/Context.h>
+#include <Poco/File.h>
+#include "LibraryDictionarySourceExternal.h"
+#include <common/logger_useful.h>
+
+namespace DB
+{
+namespace ErrorCodes
+{
+    extern const int NOT_IMPLEMENTED;
+    extern const int SIZES_OF_COLUMNS_DOESNT_MATCH;
+    extern const int FILE_DOESNT_EXIST;
+}
+
+const std::string lib_config_settings = ".settings";
+
+class CStringsHolder
+{
+public:
+    using strings_type = std::vector<std::string>;
+    CStringsHolder(strings_type strings_pass)
+    {
+        strings_holder = strings_pass;
+        strings.size = strings_holder.size();
+        ptr_holder = std::make_unique<ClickHouseLibrary::CString[]>(strings.size);
+        strings.data = ptr_holder.get();
+        size_t i = 0;
+        for (auto & str : strings_holder)
+        {
+            strings.data[i] = str.c_str();
+            ++i;
+        }
+    }
+
+    ClickHouseLibrary::CStrings strings; // will pass pointer to lib
+
+private:
+    std::unique_ptr<ClickHouseLibrary::CString[]> ptr_holder = nullptr;
+    strings_type strings_holder;
+
+};
+
+CStringsHolder getLibSettings(const Poco::Util::AbstractConfiguration & config, const std::string & config_root)
+{
+    Poco::Util::AbstractConfiguration::Keys config_keys;
+    config.keys(config_root, config_keys);
+    CStringsHolder::strings_type strings;
+    for (const auto & key : config_keys)
+    {
+        std::string key_name = key;
+        auto bracket_pos = key.find('[');
+        if (bracket_pos != std::string::npos && bracket_pos > 0)
+            key_name = key.substr(0, bracket_pos);
+        strings.emplace_back(key_name);
+        strings.emplace_back(config.getString(config_root + '.' + key));
+    }
+    return CStringsHolder(strings);
+}
+
+bool dataToBlock(const void * data, Block & block)
+{
+    if (!data)
+        return true;
+    auto columns_received = static_cast<const ClickHouseLibrary::ColumnsUInt64 *>(data);
+    std::vector<IColumn *> columns(block.columns());
+    for (const auto i : ext::range(0, columns.size()))
+        columns[i] = block.getByPosition(i).column.get();
+    for (size_t col_n = 0; col_n < columns_received->size; ++col_n)
+    {
+        if (columns.size() != columns_received->data[col_n].size)
+            throw Exception("Received unexpected number of columns: " + std::to_string(columns_received->data[col_n].size) + ", must be"
+                    + std::to_string(columns.size()),
+                ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH);
+
+        for (size_t row_n = 0; row_n < columns_received->data[col_n].size; ++row_n)
+        {
+            columns[row_n]->insert(columns_received->data[col_n].data[row_n]);
+        }
+    }
+    return false;
+}
+
+LibraryDictionarySource::LibraryDictionarySource(const DictionaryStructure & dict_struct_,
+    const Poco::Util::AbstractConfiguration & config,
+    const std::string & config_prefix,
+    Block & sample_block,
+    const Context & context)
+    : log(&Logger::get("LibraryDictionarySource")),
+      dict_struct{dict_struct_},
+      config_prefix{config_prefix},
+      path{config.getString(config_prefix + ".path", "")},
+      sample_block{sample_block},
+      context(context)
+{
+    if (!Poco::File(path).exists())
+    {
+        throw Exception("LibraryDictionarySource: Can't load lib " + toString() + ": " + Poco::File(path).path() + " - File doesn't exist",
+            ErrorCodes::FILE_DOESNT_EXIST);
+    }
+    description.init(sample_block);
+    library = std::make_shared<SharedLibrary>(path);
+    settings = std::make_shared<CStringsHolder>(getLibSettings(config, config_prefix + lib_config_settings));
+}
+
+LibraryDictionarySource::LibraryDictionarySource(const LibraryDictionarySource & other)
+    : log(&Logger::get("LibraryDictionarySource")),
+      dict_struct{other.dict_struct},
+      config_prefix{other.config_prefix},
+      path{other.path},
+      sample_block{other.sample_block},
+      context(other.context)
+{
+}
+
+BlockInputStreamPtr LibraryDictionarySource::loadAll()
+{
+    LOG_TRACE(log, "loadAll " + toString());
+
+    auto columns_holder = std::make_unique<ClickHouseLibrary::CString[]>(dict_struct.attributes.size());
+    ClickHouseLibrary::CStrings columns{
+        reinterpret_cast<decltype(ClickHouseLibrary::CStrings::data)>(columns_holder.get()), dict_struct.attributes.size()};
+    size_t i = 0;
+    for (auto & a : dict_struct.attributes)
+    {
+        columns.data[i] = a.name.c_str();
+        ++i;
+    }
+    void * data_ptr = nullptr;
+
+    /// Get function pointer before dataAllocate call because library->get may throw.
+    auto fptr
+        = library->get<void * (*)(decltype(data_ptr), decltype(&settings->strings), decltype(&columns))>("ClickHouseDictionary_v1_loadAll");
+    data_ptr = library->get<void * (*)()>("ClickHouseDictionary_v1_dataAllocate")();
+    auto data = fptr(data_ptr, &settings->strings, &columns);
+    auto block = description.sample_block.cloneEmpty();
+    dataToBlock(data, block);
+    library->get<void (*)(void *)>("ClickHouseDictionary_v1_dataDelete")(data_ptr);
+    return std::make_shared<OneBlockInputStream>(block);
+}
+
+BlockInputStreamPtr LibraryDictionarySource::loadIds(const std::vector<UInt64> & ids)
+{
+    LOG_TRACE(log, "loadIds " << toString() << " size = " << ids.size());
+
+    const ClickHouseLibrary::VectorUInt64 ids_data{ids.data(), ids.size()};
+    auto columns_holder = std::make_unique<ClickHouseLibrary::CString[]>(dict_struct.attributes.size());
+    ClickHouseLibrary::CStrings columns_pass{
+        reinterpret_cast<decltype(ClickHouseLibrary::CStrings::data)>(columns_holder.get()), dict_struct.attributes.size()};
+    size_t i = 0;
+    for (auto & a : dict_struct.attributes)
+    {
+        columns_pass.data[i] = a.name.c_str();
+        ++i;
+    }
+    void * data_ptr = nullptr;
+
+    /// Get function pointer before dataAllocate call because library->get may throw.
+    auto fptr = library->get<void * (*)(decltype(data_ptr), decltype(&settings->strings), decltype(&columns_pass), decltype(&ids_data))>(
+        "ClickHouseDictionary_v1_loadIds");
+    data_ptr = library->get<void * (*)()>("ClickHouseDictionary_v1_dataAllocate")();
+    auto data = fptr(data_ptr, &settings->strings, &columns_pass, &ids_data);
+    auto block = description.sample_block.cloneEmpty();
+    dataToBlock(data, block);
+    library->get<void (*)(void * data_ptr)>("ClickHouseDictionary_v1_dataDelete")(data_ptr);
+    return std::make_shared<OneBlockInputStream>(block);
+}
+
+BlockInputStreamPtr LibraryDictionarySource::loadKeys(const Columns & key_columns, const std::vector<std::size_t> & requested_rows)
+{
+    LOG_TRACE(log, "loadKeys " << toString() << " size = " << requested_rows.size());
+
+    /*
+    auto columns_c = std::make_unique<ClickHouseLibrary::Columns>(key_columns.size() + 1);
+    size_t i = 0;
+    for (auto & column : key_columns)
+    {
+        columns_c[i] = column->getName().c_str();
+        ++i;
+    }
+    columns_c[i] = nullptr;
+*/
+    auto columns_holder = std::make_unique<ClickHouseLibrary::CString[]>(key_columns.size());
+    ClickHouseLibrary::CStrings columns_pass{
+        reinterpret_cast<decltype(ClickHouseLibrary::CStrings::data)>(columns_holder.get()), key_columns.size()};
+    size_t key_columns_n = 0;
+    for (auto & column : key_columns)
+    {
+        columns_pass.data[key_columns_n] = column->getName().c_str();
+        ++key_columns_n;
+    }
+    const ClickHouseLibrary::VectorUInt64 requested_rows_c{requested_rows.data(), requested_rows.size()};
+    void * data_ptr = nullptr;
+
+    /// Get function pointer before dataAllocate call because library->get may throw.
+    auto fptr
+        = library->get<void * (*)(decltype(data_ptr), decltype(&settings->strings), decltype(&columns_pass), decltype(&requested_rows_c))>(
+            "ClickHouseDictionary_v1_loadKeys");
+    data_ptr = library->get<void * (*)()>("ClickHouseDictionary_v1_dataAllocate")();
+    auto data = fptr(data_ptr, &settings->strings, &columns_pass, &requested_rows_c);
+    auto block = description.sample_block.cloneEmpty();
+    dataToBlock(data, block);
+    library->get<void (*)(void * data_ptr)>("ClickHouseDictionary_v1_dataDelete")(data_ptr);
+    return std::make_shared<OneBlockInputStream>(block);
+}
+
+bool LibraryDictionarySource::isModified() const
+{
+    auto fptr = library->tryGet<void * (*)(decltype(&settings->strings))>("ClickHouseDictionary_v1_isModified");
+    if (fptr)
+        return fptr(&settings->strings);
+    return true;
+}
+
+bool LibraryDictionarySource::supportsSelectiveLoad() const
+{
+    auto fptr = library->tryGet<void * (*)(decltype(&settings->strings))>("ClickHouseDictionary_v1_supportsSelectiveLoad");
+    if (fptr)
+        return fptr(&settings->strings);
+    return true;
+}
+
+DictionarySourcePtr LibraryDictionarySource::clone() const
+{
+    return std::make_unique<LibraryDictionarySource>(*this);
+}
+
+std::string LibraryDictionarySource::toString() const
+{
+    return path;
+}
+}
diff --git a/dbms/src/Dictionaries/LibraryDictionarySource.h b/dbms/src/Dictionaries/LibraryDictionarySource.h
new file mode 100644
index 00000000000..108bae5cd65
--- /dev/null
+++ b/dbms/src/Dictionaries/LibraryDictionarySource.h
@@ -0,0 +1,62 @@
+#pragma once
+
+#include <Common/SharedLibrary.h>
+#include <Dictionaries/DictionaryStructure.h>
+#include <Dictionaries/ExternalResultDescription.h>
+#include <Dictionaries/IDictionarySource.h>
+
+#include <iostream>
+
+namespace Poco
+{
+class Logger;
+}
+
+
+namespace DB
+{
+struct CStringsHolder;
+
+/// Allows loading dictionaries from dynamic libraries (.so)
+/// Experimental version
+/// Now supports only uint64 types
+class LibraryDictionarySource final : public IDictionarySource
+{
+public:
+    LibraryDictionarySource(const DictionaryStructure & dict_struct_,
+        const Poco::Util::AbstractConfiguration & config,
+        const std::string & config_prefix,
+        Block & sample_block,
+        const Context & context);
+
+    LibraryDictionarySource(const LibraryDictionarySource & other);
+
+    BlockInputStreamPtr loadAll() override;
+
+    BlockInputStreamPtr loadIds(const std::vector<UInt64> & ids) override;
+
+    BlockInputStreamPtr loadKeys(const Columns & key_columns, const std::vector<std::size_t> & requested_rows) override;
+
+    bool isModified() const override;
+
+    bool supportsSelectiveLoad() const override;
+
+    DictionarySourcePtr clone() const override;
+
+    std::string toString() const override;
+
+private:
+    Poco::Logger * log;
+
+    LocalDateTime getLastModification() const;
+
+    const DictionaryStructure dict_struct;
+    const std::string config_prefix;
+    const std::string path;
+    Block sample_block;
+    const Context & context;
+    SharedLibraryPtr library;
+    ExternalResultDescription description;
+    std::shared_ptr<CStringsHolder> settings;
+};
+}
diff --git a/dbms/src/Dictionaries/LibraryDictionarySourceExternal.h b/dbms/src/Dictionaries/LibraryDictionarySourceExternal.h
new file mode 100644
index 00000000000..3a3ecfff2c7
--- /dev/null
+++ b/dbms/src/Dictionaries/LibraryDictionarySourceExternal.h
@@ -0,0 +1,26 @@
+#pragma once
+
+namespace ClickHouseLibrary
+{
+using CString = const char *;
+using ColumnName = CString;
+using ColumnNames = ColumnName[];
+
+struct CStrings
+{
+    CString * data = nullptr;
+    uint64_t size = 0;
+};
+
+struct VectorUInt64
+{
+    const uint64_t * data = nullptr;
+    uint64_t size = 0;
+};
+
+struct ColumnsUInt64
+{
+    VectorUInt64 * data = nullptr;
+    uint64_t size = 0;
+};
+}
diff --git a/dbms/src/Interpreters/Compiler.cpp b/dbms/src/Interpreters/Compiler.cpp
index 8ca50c4de72..7dc37a92a2f 100644
--- a/dbms/src/Interpreters/Compiler.cpp
+++ b/dbms/src/Interpreters/Compiler.cpp
@@ -24,6 +24,10 @@ namespace ProfileEvents
 namespace DB
 {
 
+namespace ErrorCodes
+{
+    extern const int CANNOT_DLOPEN;
+}
 
 Compiler::Compiler(const std::string & path_, size_t threads)
     : path(path_), pool(threads)
diff --git a/dbms/src/Interpreters/Compiler.h b/dbms/src/Interpreters/Compiler.h
index ec2745f0a86..3f1fa8924ec 100644
--- a/dbms/src/Interpreters/Compiler.h
+++ b/dbms/src/Interpreters/Compiler.h
@@ -2,8 +2,6 @@
 
 #include <boost/core/noncopyable.hpp>
 
-#include <dlfcn.h>
-
 #include <iostream>
 #include <string>
 #include <mutex>
@@ -16,57 +14,12 @@
 #include <Core/Types.h>
 #include <Common/Exception.h>
 #include <Common/UInt128.h>
+#include <Common/SharedLibrary.h>
 #include <common/ThreadPool.h>
 
-
 namespace DB
 {
 
-namespace ErrorCodes
-{
-    extern const int CANNOT_DLOPEN;
-    extern const int CANNOT_DLSYM;
-}
-
-
-/** Allows you to open a dynamic library and get a pointer to a function from it.
-  */
-class SharedLibrary : private boost::noncopyable
-{
-public:
-    SharedLibrary(const std::string & path)
-    {
-        handle = dlopen(path.c_str(), RTLD_LAZY);
-        if (!handle)
-            throw Exception(std::string("Cannot dlopen: ") + dlerror(), ErrorCodes::CANNOT_DLOPEN);
-    }
-
-    ~SharedLibrary()
-    {
-        if (handle && dlclose(handle))
-            std::terminate();
-    }
-
-    template <typename Func>
-    Func get(const std::string & name)
-    {
-        dlerror();
-
-        Func res = reinterpret_cast<Func>(dlsym(handle, name.c_str()));
-
-        if (char * error = dlerror())
-            throw Exception(std::string("Cannot dlsym: ") + error, ErrorCodes::CANNOT_DLSYM);
-
-        return res;
-    }
-
-private:
-    void * handle;
-};
-
-using SharedLibraryPtr = std::shared_ptr<SharedLibrary>;
-
-
 /** Lets you compile a piece of code that uses the server's header files into the dynamic library.
   * Conducts statistic of calls, and initiates compilation only on the N-th call for one key.
   * Compilation is performed asynchronously, in separate threads, if there are free threads.
diff --git a/dbms/tests/CMakeLists.txt b/dbms/tests/CMakeLists.txt
index 3eff0f02cc9..99245ea0b5c 100644
--- a/dbms/tests/CMakeLists.txt
+++ b/dbms/tests/CMakeLists.txt
@@ -19,3 +19,5 @@ macro(grep_gtest_sources BASE_DIR DST_VAR)
     # Cold match files that are not in tests/ directories
     file(GLOB_RECURSE "${DST_VAR}" RELATIVE "${BASE_DIR}" "gtest*.cpp")
 endmacro()
+
+add_subdirectory (external_dictionaries)
diff --git a/dbms/tests/external_dictionaries/CMakeLists.txt b/dbms/tests/external_dictionaries/CMakeLists.txt
new file mode 100644
index 00000000000..70f0628bf3f
--- /dev/null
+++ b/dbms/tests/external_dictionaries/CMakeLists.txt
@@ -0,0 +1,2 @@
+
+add_subdirectory (dictionary_library)
diff --git a/dbms/tests/external_dictionaries/dictionary_library/CMakeLists.txt b/dbms/tests/external_dictionaries/dictionary_library/CMakeLists.txt
new file mode 100644
index 00000000000..98391dab4b4
--- /dev/null
+++ b/dbms/tests/external_dictionaries/dictionary_library/CMakeLists.txt
@@ -0,0 +1,13 @@
+
+add_library (dictionary_library SHARED "dictionary_library.cpp")
+target_include_directories (dictionary_library PRIVATE ${DBMS_INCLUDE_DIR})
+add_library (dictionary_library_c SHARED "dictionary_library_c.c")
+target_include_directories (dictionary_library_c PRIVATE ${DBMS_INCLUDE_DIR})
+add_library (dictionary_library_empty SHARED "dictionary_library_empty.cpp")
+target_include_directories (dictionary_library_empty PRIVATE ${DBMS_INCLUDE_DIR})
+
+# Don't change lib name in debug build
+# because result .so will be pointed in dictionary_*.xml
+set_target_properties(dictionary_library PROPERTIES DEBUG_POSTFIX "")
+set_target_properties(dictionary_library_c PROPERTIES DEBUG_POSTFIX "")
+set_target_properties(dictionary_library_empty PROPERTIES DEBUG_POSTFIX "")
diff --git a/dbms/tests/external_dictionaries/dictionary_library/dictionary_library.cpp b/dbms/tests/external_dictionaries/dictionary_library/dictionary_library.cpp
new file mode 100644
index 00000000000..d96e73b53f2
--- /dev/null
+++ b/dbms/tests/external_dictionaries/dictionary_library/dictionary_library.cpp
@@ -0,0 +1,159 @@
+/// c++ sample dictionary library
+
+#include <cstdint>
+#include <iostream>
+#include <memory>
+#include <vector>
+
+#include <Dictionaries/LibraryDictionarySourceExternal.h>
+
+//#define DUMPS(VAR) #VAR " = " << VAR
+//#define DUMP(VAR) std::cerr << __FILE__ << ":" << __LINE__ << " " << DUMPS(VAR) << "\n";
+
+struct DataHolder
+{
+    std::vector<std::vector<uint64_t>> vector;
+    std::unique_ptr<ClickHouseLibrary::VectorUInt64[]> columnsHolder;
+    ClickHouseLibrary::ColumnsUInt64 columns;
+};
+
+extern "C" {
+
+void * ClickHouseDictionary_v1_loadIds(
+    void * data_ptr, ClickHouseLibrary::CStrings * settings, ClickHouseLibrary::CStrings * columns, const struct ClickHouseLibrary::VectorUInt64 * ids)
+{
+    auto ptr = static_cast<DataHolder *>(data_ptr);
+    std::cerr << "loadIds lib call ptr=" << data_ptr << " => " << ptr << " size=" << ids->size << "\n";
+    if (settings)
+    {
+        std::cerr << "settings passed: " << settings->size << "\n";
+        for (size_t i = 0; i < settings->size; ++i)
+            std::cerr << "setting " << i << " :" << settings->data[i] << " \n";
+    }
+
+    if (columns)
+    {
+        std::cerr << "columns passed:" << columns->size << "\n";
+        for (size_t i = 0; i < columns->size; ++i)
+            std::cerr << "column " << i << " :" << columns->data[i] << "\n";
+    }
+    if (ptr)
+    {
+        if (ids)
+        {
+            std::cerr << "ids passed: " << ids->size << "\n";
+            for (size_t i = 0; i < ids->size; ++i)
+            {
+                std::cerr << "id " << i << " :" << ids->data[i] << " replying.\n";
+                ptr->vector.emplace_back(std::vector<uint64_t>{ids->data[i], ids->data[i] + 1, (1 + ids->data[i]) * 10, 65});
+            }
+        }
+
+        ptr->columnsHolder = std::make_unique<ClickHouseLibrary::VectorUInt64[]>(ptr->vector.size());
+        size_t i = 0;
+        for (auto & col : ptr->vector)
+        {
+            //DUMP(i);
+            //DUMP(col);
+            ptr->columnsHolder[i].size = col.size();
+            ptr->columnsHolder[i].data = col.data();
+            ++i;
+        }
+        ptr->columns.size = ptr->vector.size();
+        //DUMP(ptr->columns.size);
+        ptr->columns.data = ptr->columnsHolder.get();
+        //DUMP(ptr->columns.columns);
+        return static_cast<void *>(&ptr->columns);
+    }
+
+    return nullptr;
+}
+
+void * ClickHouseDictionary_v1_loadAll(void * data_ptr, ClickHouseLibrary::CStrings * settings, ClickHouseLibrary::CStrings * columns)
+{
+    auto ptr = static_cast<DataHolder *>(data_ptr);
+    std::cerr << "loadAll lib call ptr=" << data_ptr << " => " << ptr << "\n";
+    if (settings)
+    {
+        std::cerr << "settings passed: " << settings->size << "\n";
+        for (size_t i = 0; i < settings->size; ++i)
+        {
+            std::cerr << "setting " << i << " :" << settings->data[i] << " \n";
+        }
+    }
+
+    if (ptr)
+    {
+        for (size_t i = 0; i < 7; ++i)
+        {
+            std::cerr << "id " << i << " :"
+                      << " generating.\n";
+            ptr->vector.emplace_back(std::vector<uint64_t>{i, i + 1, (1 + i) * 10, 65});
+        }
+
+        ptr->columnsHolder = std::make_unique<ClickHouseLibrary::VectorUInt64[]>(ptr->vector.size());
+        size_t i = 0;
+        for (auto & col : ptr->vector)
+        {
+            ptr->columnsHolder[i].size = col.size();
+            ptr->columnsHolder[i].data = col.data();
+            ++i;
+        }
+        ptr->columns.size = ptr->vector.size();
+        //DUMP(ptr->columns.size);
+        ptr->columns.data = ptr->columnsHolder.get();
+        //DUMP(ptr->columns.columns);
+        return static_cast<void *>(&ptr->columns);
+    }
+    //return;
+    return nullptr;
+}
+
+void * ClickHouseDictionary_v1_loadKeys(void * data_ptr,
+    ClickHouseLibrary::CStrings * settings,
+    ClickHouseLibrary::CStrings * columns,
+    const ClickHouseLibrary::VectorUInt64 * requested_rows)
+{
+    auto ptr = static_cast<DataHolder *>(data_ptr);
+    std::cerr << "loadKeys lib call ptr=" << data_ptr << " => " << ptr << "\n";
+    if (settings)
+    {
+        std::cerr << "settings passed: " << settings->size << "\n";
+        for (size_t i = 0; i < settings->size; ++i)
+        {
+            std::cerr << "setting " << i << " :" << settings->data[i] << " \n";
+        }
+    }
+    if (columns)
+    {
+        std::cerr << "columns passed:" << columns->size << "\n";
+        for (size_t i = 0; i < columns->size; ++i)
+        {
+            std::cerr << "col " << i << " :" << columns->data[i] << "\n";
+        }
+    }
+    if (requested_rows)
+    {
+        std::cerr << "requested_rows passed: " << requested_rows->size << "\n";
+        for (size_t i = 0; i < requested_rows->size; ++i)
+        {
+            std::cerr << "id " << i << " :" << requested_rows->data[i] << "\n";
+        }
+    }
+
+    return nullptr;
+}
+
+void * ClickHouseDictionary_v1_dataAllocate()
+{
+    auto data_ptr = new DataHolder;
+    return data_ptr;
+}
+
+void ClickHouseDictionary_v1_dataDelete(void * data_ptr)
+{
+    auto ptr = static_cast<DataHolder *>(data_ptr);
+    delete ptr;
+    return;
+}
+}
diff --git a/dbms/tests/external_dictionaries/dictionary_library/dictionary_library_c.c b/dbms/tests/external_dictionaries/dictionary_library/dictionary_library_c.c
new file mode 100644
index 00000000000..936516aa9fc
--- /dev/null
+++ b/dbms/tests/external_dictionaries/dictionary_library/dictionary_library_c.c
@@ -0,0 +1,57 @@
+/// Pure c sample dictionary library
+
+#include <inttypes.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef const char * CString;
+
+typedef struct
+{
+    const uint64_t size;
+    const uint64_t * data;
+} ClickHouseLibVectorUInt64;
+
+typedef struct
+{
+    uint64_t size;
+    CString * data;
+} ClickHouseLibCStrings;
+
+void * ClickHouseDictionary_v1_loadIds(void * data_ptr, ClickHouseLibCStrings * settings, ClickHouseLibCStrings * columns, ClickHouseLibVectorUInt64 * ids)
+{
+    printf("loadIds c lib call ptr=%p size=%" PRIu64 "\n", data_ptr, ids->size);
+    return 0;
+}
+
+void * ClickHouseDictionary_v1_loadAll(void * data_ptr, ClickHouseLibCStrings * settings, ClickHouseLibCStrings * columns)
+{
+    printf("loadAll c lib call ptr=%p \n", data_ptr);
+    return 0;
+}
+
+void * ClickHouseDictionary_v1_loadKeys(void * data_ptr,
+    ClickHouseLibCStrings * settings,
+    ClickHouseLibCStrings * columns,
+    const ClickHouseLibVectorUInt64 * requested_rows)
+{
+    printf("loadKeys c lib call ptr=%p size=%" PRIu64 "\n", data_ptr, requested_rows->size);
+    return 0;
+}
+
+
+void * ClickHouseDictionary_v1_dataAllocate()
+{
+    int size = 100;
+    void * data_ptr = malloc(size);
+    printf("dataAllocate c lib call ptr=%p \n", data_ptr);
+    return data_ptr;
+}
+
+void ClickHouseDictionary_v1_dataDelete(void * data_ptr)
+{
+    printf("dataDelete c lib call ptr=%p \n", data_ptr);
+    free(data_ptr);
+    return;
+}
diff --git a/dbms/tests/external_dictionaries/dictionary_library/dictionary_library_empty.cpp b/dbms/tests/external_dictionaries/dictionary_library/dictionary_library_empty.cpp
new file mode 100644
index 00000000000..6845949e0c0
--- /dev/null
+++ b/dbms/tests/external_dictionaries/dictionary_library/dictionary_library_empty.cpp
@@ -0,0 +1 @@
+// test .so without any func
diff --git a/dbms/tests/external_dictionaries/generate_and_test.py b/dbms/tests/external_dictionaries/generate_and_test.py
index 87db6ee5456..a51bf9a1f17 100755
--- a/dbms/tests/external_dictionaries/generate_and_test.py
+++ b/dbms/tests/external_dictionaries/generate_and_test.py
@@ -114,6 +114,24 @@ def generate_structure(args):
             [ 'mongodb_user_flat', 0, True ],
         ])
 
+    if args.use_lib:
+        dictionaries.extend([
+            # [ 'library_flat', 0, True ],
+            # [ 'library_hashed', 0, True ],
+            # [ 'library_cache', 0, True ],
+            # [ 'library_complex_integers_key_hashed', 1, False ],
+            # [ 'library_complex_integers_key_cache', 1, False ],
+            # [ 'library_complex_mixed_key_hashed', 2, False ],
+            # [ 'library_complex_mixed_key_cache', 2, False ],
+            # [ 'library_c_flat', 0, True ],
+            # [ 'library_c_hashed', 0, True ],
+            # [ 'library_c_cache', 0, True ],
+            # [ 'library_c_complex_integers_key_hashed', 1, False ],
+            # [ 'library_c_complex_integers_key_cache', 1, False ],
+            # [ 'library_c_complex_mixed_key_hashed', 2, False ],
+            # [ 'library_c_complex_mixed_key_cache', 2, False ],
+        ])
+
 
 files = [ 'key_simple.tsv', 'key_complex_integers.tsv', 'key_complex_mixed.tsv' ]
 
@@ -370,6 +388,20 @@ def generate_dictionaries(args):
     </http>
     '''.format(https_host=args.https_host, https_port=args.https_port, https_path=args.https_path)
 
+    source_library = '''
+    <lib>
+        <filename>{filename}</filename>
+    </lib>
+    '''.format(filename=os.path.abspath('../../../build/dbms/tests/external_dictionaries/dictionary_library/libdictionary_library.so'))
+
+    # Todo?
+    #source_library_c = '''
+    #<lib>
+    #    <filename>{filename}</filename>
+    #</lib>
+    #'''.format(filename=os.path.abspath('../../../build/dbms/tests/external_dictionaries/dict_lib/libdict_library_c.so'))
+
+
     layout_flat = '<flat />'
     layout_hashed = '<hashed />'
     layout_cache = '<cache><size_in_cells>128</size_in_cells></cache>'
@@ -490,6 +522,24 @@ def generate_dictionaries(args):
         [ source_mongodb_user, layout_flat ],
     ])
 
+    if args.use_lib:
+        sources_and_layouts.extend([
+        #[ source_library, layout_flat ],
+        #[ source_library, layout_hashed ],
+        #[ source_library, layout_cache ],
+        #[ source_library, layout_complex_key_cache ],
+        #[ source_library, layout_complex_key_hashed ],
+        #[ source_library, layout_complex_key_hashed ],
+        #[ source_library, layout_complex_key_cache ],
+        #[ source_library_c, layout_flat ],
+        #[ source_library_c, layout_hashed ],
+        #[ source_library_c, layout_cache ],
+        #[ source_library_c, layout_complex_key_cache ],
+        #[ source_library_c, layout_complex_key_hashed ],
+        #[ source_library_c, layout_complex_key_hashed ],
+        #[ source_library_c, layout_complex_key_cache ],
+    ])
+
     for (name, key_idx, has_parent), (source, layout) in zip(dictionaries, sources_and_layouts):
         filename = os.path.join(args.generated, 'dictionary_%s.xml' % name)
         with open(filename, 'w') as file:
@@ -675,8 +725,9 @@ if __name__ == '__main__':
     parser.add_argument('-t', '--timeout', type = int, default = 10, help = 'Timeout for each test case in seconds')
 
     # Not complete disable. Now only skip data prepare. Todo: skip requests too. Now can be used with --no_break
+    parser.add_argument('--use_lib',   action='store_true', help = 'Use lib dictionaries')
     parser.add_argument('--no_mysql', action='store_true', help = 'Dont use mysql dictionaries')
-    parser.add_argument('--no_mongo', action='store_true', help = 'Use mongodb dictionaries')
+    parser.add_argument('--no_mongo', action='store_true', help = 'Dont use mongodb dictionaries')
     parser.add_argument('--mongo_host', default = 'localhost', help = 'mongo server host')
     parser.add_argument('--use_mongo_user', action='store_true', help = 'Test mongodb with user-pass')
 
diff --git a/debian/source/format b/debian/source/format
index 163aaf8d82b..89ae9db8f88 100644
--- a/debian/source/format
+++ b/debian/source/format
@@ -1 +1 @@
-3.0 (quilt)
+3.0 (native)

From 0e4d49570bf862bb598caf61f2b968f9da04cf8c Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Tue, 5 Sep 2017 20:13:00 +0300
Subject: [PATCH 076/266] LibraryDictionarySource fixes

---
 dbms/src/Dictionaries/LibraryDictionarySource.h      |  2 +-
 .../tests/external_dictionaries/generate_and_test.py | 12 ++++++------
 debian/source/format                                 |  2 +-
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/dbms/src/Dictionaries/LibraryDictionarySource.h b/dbms/src/Dictionaries/LibraryDictionarySource.h
index 108bae5cd65..fdde72ab7cc 100644
--- a/dbms/src/Dictionaries/LibraryDictionarySource.h
+++ b/dbms/src/Dictionaries/LibraryDictionarySource.h
@@ -15,7 +15,7 @@ class Logger;
 
 namespace DB
 {
-struct CStringsHolder;
+class CStringsHolder;
 
 /// Allows loading dictionaries from dynamic libraries (.so)
 /// Experimental version
diff --git a/dbms/tests/external_dictionaries/generate_and_test.py b/dbms/tests/external_dictionaries/generate_and_test.py
index a51bf9a1f17..097b152b56e 100755
--- a/dbms/tests/external_dictionaries/generate_and_test.py
+++ b/dbms/tests/external_dictionaries/generate_and_test.py
@@ -389,16 +389,16 @@ def generate_dictionaries(args):
     '''.format(https_host=args.https_host, https_port=args.https_port, https_path=args.https_path)
 
     source_library = '''
-    <lib>
-        <filename>{filename}</filename>
-    </lib>
+    <library>
+        <path>{filename}</path>
+    </library>
     '''.format(filename=os.path.abspath('../../../build/dbms/tests/external_dictionaries/dictionary_library/libdictionary_library.so'))
 
     # Todo?
     #source_library_c = '''
-    #<lib>
-    #    <filename>{filename}</filename>
-    #</lib>
+    #<library>
+    #    <path>{filename}</path>
+    #</library>
     #'''.format(filename=os.path.abspath('../../../build/dbms/tests/external_dictionaries/dict_lib/libdict_library_c.so'))
 
 
diff --git a/debian/source/format b/debian/source/format
index 89ae9db8f88..163aaf8d82b 100644
--- a/debian/source/format
+++ b/debian/source/format
@@ -1 +1 @@
-3.0 (native)
+3.0 (quilt)

From 44b44a13d2f94efc9f81c581ef5af17e128fb195 Mon Sep 17 00:00:00 2001
From: proller <proller@users.noreply.github.com>
Date: Tue, 5 Sep 2017 21:53:28 +0300
Subject: [PATCH 077/266] Fix http_head test (#1203)

* Fix http_head test
* Longer timeout
---
 dbms/tests/queries/0_stateless/00501_http_head.reference | 0
 dbms/tests/queries/0_stateless/00501_http_head.sh        | 4 ++++
 2 files changed, 4 insertions(+)
 create mode 100644 dbms/tests/queries/0_stateless/00501_http_head.reference
 create mode 100755 dbms/tests/queries/0_stateless/00501_http_head.sh

diff --git a/dbms/tests/queries/0_stateless/00501_http_head.reference b/dbms/tests/queries/0_stateless/00501_http_head.reference
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/dbms/tests/queries/0_stateless/00501_http_head.sh b/dbms/tests/queries/0_stateless/00501_http_head.sh
new file mode 100755
index 00000000000..4b99c841c45
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00501_http_head.sh
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+
+curl -s --max-time 0.5 -X "HEAD" 'http://localhost:8123/?query=SELECT%201'
+curl -s --max-time 0.5 -X "HEAD" 'http://localhost:8123/?query=select+*+from+system.numbers+limit+1000000'

From 3876340aebe4a1a418388f3e8d67c61474ff18c0 Mon Sep 17 00:00:00 2001
From: Vitaliy Lyudvichenko <vludv@yandex-team.ru>
Date: Wed, 30 Aug 2017 17:47:35 +0300
Subject: [PATCH 078/266] More correct Context deinitialization. Part 1.
 [#CLICKHOUSE-3117]

---
 dbms/src/Server/Server.cpp | 38 ++++++++++++++++++++------------------
 1 file changed, 20 insertions(+), 18 deletions(-)

diff --git a/dbms/src/Server/Server.cpp b/dbms/src/Server/Server.cpp
index e7820e296de..5130d612193 100644
--- a/dbms/src/Server/Server.cpp
+++ b/dbms/src/Server/Server.cpp
@@ -126,6 +126,15 @@ int Server::main(const std::vector<std::string> & args)
 
     StatusFile status{path + "status"};
 
+    SCOPE_EXIT({
+        /** Explicitly destroy Context. It is more convenient than in destructor of Server, because logger is still available.
+          * At this moment, no one could own shared part of Context.
+          */
+        global_context.reset();
+
+        LOG_DEBUG(log, "Destroyed global context.");
+    });
+
     /// Try to increase limit on number of open files.
     {
         rlimit rlim;
@@ -265,6 +274,17 @@ int Server::main(const std::vector<std::string> & args)
 
     global_context->setCurrentDatabase(default_database);
 
+    SCOPE_EXIT({
+        /** Ask to cancel background jobs all table engines,
+          *  and also query_log.
+          * It is important to do early, not in destructor of Context, because
+          *  table engines could use Context on destroy.
+          */
+        LOG_INFO(log, "Shutting down storages.");
+        global_context->shutdown();
+        LOG_DEBUG(log, "Shutted down storages.");
+    });
+
     bool has_resharding_worker = false;
     if (has_zookeeper && config().has("resharding"))
     {
@@ -281,24 +301,6 @@ int Server::main(const std::vector<std::string> & args)
         global_context->setDDLWorker(std::make_shared<DDLWorker>(ddl_zookeeper_path, *global_context, &config(), "distributed_ddl"));
     }
 
-    SCOPE_EXIT({
-        /** Ask to cancel background jobs all table engines,
-          *  and also query_log.
-          * It is important to do early, not in destructor of Context, because
-          *  table engines could use Context on destroy.
-          */
-        LOG_INFO(log, "Shutting down storages.");
-        global_context->shutdown();
-        LOG_DEBUG(log, "Shutted down storages.");
-
-        /** Explicitly destroy Context. It is more convenient than in destructor of Server, because logger is still available.
-          * At this moment, no one could own shared part of Context.
-          */
-        global_context.reset();
-
-        LOG_DEBUG(log, "Destroyed global context.");
-    });
-
     {
         Poco::Timespan keep_alive_timeout(config().getInt("keep_alive_timeout", 10), 0);
 

From d55d5eca46a8ffc1d3207955e559f87ecfdb0ee6 Mon Sep 17 00:00:00 2001
From: Vitaliy Lyudvichenko <vludv@yandex-team.ru>
Date: Mon, 4 Sep 2017 20:49:39 +0300
Subject: [PATCH 079/266] Remove extra Context reference and add required ones.
 Part 2. [#CLICKHOUSE-3117]

---
 .../AddingDefaultBlockInputStream.h           |  2 +-
 .../AddingDefaultBlockOutputStream.h          |  2 +-
 .../PushingToViewsBlockOutputStream.h         |  2 +-
 dbms/src/Interpreters/Context.cpp             | 19 +++++++------------
 dbms/src/Interpreters/Context.h               |  7 +++----
 dbms/src/Interpreters/DDLWorker.cpp           |  6 +++---
 dbms/src/Interpreters/DDLWorker.h             |  2 +-
 dbms/src/Interpreters/InterpreterAlterQuery.h |  2 +-
 .../src/Interpreters/InterpreterInsertQuery.h |  2 +-
 dbms/src/Interpreters/SystemLog.h             |  1 +
 dbms/src/Storages/IStorage.h                  |  2 +-
 .../Storages/MergeTree/ReshardingWorker.cpp   |  2 +-
 .../src/Storages/MergeTree/ReshardingWorker.h | 10 ++++++----
 dbms/src/Storages/StorageDistributed.cpp      |  2 +-
 dbms/src/Storages/StorageDistributed.h        |  2 +-
 .../Storages/StorageReplicatedMergeTree.cpp   |  2 +-
 .../src/Storages/StorageReplicatedMergeTree.h |  2 +-
 17 files changed, 32 insertions(+), 35 deletions(-)

diff --git a/dbms/src/DataStreams/AddingDefaultBlockInputStream.h b/dbms/src/DataStreams/AddingDefaultBlockInputStream.h
index d34d8b1adf4..b5be6742371 100644
--- a/dbms/src/DataStreams/AddingDefaultBlockInputStream.h
+++ b/dbms/src/DataStreams/AddingDefaultBlockInputStream.h
@@ -59,7 +59,7 @@ protected:
 private:
     NamesAndTypesListPtr required_columns;
     const ColumnDefaults column_defaults;
-    Context context;
+    cosnt Context & context;
 };
 
 }
diff --git a/dbms/src/DataStreams/AddingDefaultBlockOutputStream.h b/dbms/src/DataStreams/AddingDefaultBlockOutputStream.h
index e8f1cb30b80..b9955792f41 100644
--- a/dbms/src/DataStreams/AddingDefaultBlockOutputStream.h
+++ b/dbms/src/DataStreams/AddingDefaultBlockOutputStream.h
@@ -40,7 +40,7 @@ private:
     BlockOutputStreamPtr output;
     NamesAndTypesListPtr required_columns;
     const ColumnDefaults column_defaults;
-    Context context;
+    const Context & context;
     bool only_explicit_column_defaults;
 };
 
diff --git a/dbms/src/DataStreams/PushingToViewsBlockOutputStream.h b/dbms/src/DataStreams/PushingToViewsBlockOutputStream.h
index dba48d34cdf..21198825a46 100644
--- a/dbms/src/DataStreams/PushingToViewsBlockOutputStream.h
+++ b/dbms/src/DataStreams/PushingToViewsBlockOutputStream.h
@@ -72,7 +72,7 @@ public:
 private:
     StoragePtr storage;
     BlockOutputStreamPtr output;
-    Context context;
+    const Context & context;
     ASTPtr query_ptr;
     std::vector<std::pair<ASTPtr, BlockOutputStreamPtr>> views;
 };
diff --git a/dbms/src/Interpreters/Context.cpp b/dbms/src/Interpreters/Context.cpp
index ce12cc7ce7b..cf379b83dd9 100644
--- a/dbms/src/Interpreters/Context.cpp
+++ b/dbms/src/Interpreters/Context.cpp
@@ -262,7 +262,7 @@ Context::~Context()
 }
 
 
-InterserverIOHandler & Context::getInterserverIOHandler()                        { return shared->interserver_io_handler; }
+InterserverIOHandler & Context::getInterserverIOHandler()                       { return shared->interserver_io_handler; }
 
 std::unique_lock<Poco::Mutex> Context::getLock() const
 {
@@ -271,8 +271,8 @@ std::unique_lock<Poco::Mutex> Context::getLock() const
     return std::unique_lock<Poco::Mutex>(shared->mutex);
 }
 
-ProcessList & Context::getProcessList()                                            { return shared->process_list; }
-const ProcessList & Context::getProcessList() const                                { return shared->process_list; }
+ProcessList & Context::getProcessList()                                         { return shared->process_list; }
+const ProcessList & Context::getProcessList() const                             { return shared->process_list; }
 MergeList & Context::getMergeList()                                             { return shared->merge_list; }
 const MergeList & Context::getMergeList() const                                 { return shared->merge_list; }
 
@@ -1100,12 +1100,7 @@ void Context::setProcessListElement(ProcessList::Element * elem)
     process_list_elem = elem;
 }
 
-ProcessList::Element * Context::getProcessListElement()
-{
-    return process_list_elem;
-}
-
-const ProcessList::Element * Context::getProcessListElement() const
+ProcessList::Element * Context::getProcessListElement() const
 {
     return process_list_elem;
 }
@@ -1190,7 +1185,7 @@ void Context::setReshardingWorker(std::shared_ptr<ReshardingWorker> resharding_w
     shared->resharding_worker = resharding_worker;
 }
 
-ReshardingWorker & Context::getReshardingWorker()
+ReshardingWorker & Context::getReshardingWorker() const
 {
     auto lock = getLock();
     if (!shared->resharding_worker)
@@ -1207,11 +1202,11 @@ void Context::setDDLWorker(std::shared_ptr<DDLWorker> ddl_worker)
     shared->ddl_worker = ddl_worker;
 }
 
-DDLWorker & Context::getDDLWorker()
+DDLWorker & Context::getDDLWorker() const
 {
     auto lock = getLock();
     if (!shared->ddl_worker)
-        throw Exception("DDL background thread not initialized.", ErrorCodes::LOGICAL_ERROR);
+        throw Exception("DDL background thread is not initialized.", ErrorCodes::LOGICAL_ERROR);
     return *shared->ddl_worker;
 }
 
diff --git a/dbms/src/Interpreters/Context.h b/dbms/src/Interpreters/Context.h
index 9611de279ec..33087ff71b0 100644
--- a/dbms/src/Interpreters/Context.h
+++ b/dbms/src/Interpreters/Context.h
@@ -270,8 +270,7 @@ public:
       */
     void setProcessListElement(ProcessListElement * elem);
     /// Can return nullptr if the query was not inserted into the ProcessList.
-    ProcessListElement * getProcessListElement();
-    const ProcessListElement * getProcessListElement() const;
+    ProcessListElement * getProcessListElement() const;
 
     /// List all queries.
     ProcessList & getProcessList();
@@ -307,10 +306,10 @@ public:
     BackgroundProcessingPool & getBackgroundPool();
 
     void setReshardingWorker(std::shared_ptr<ReshardingWorker> resharding_worker);
-    ReshardingWorker & getReshardingWorker();
+    ReshardingWorker & getReshardingWorker() const;
 
     void setDDLWorker(std::shared_ptr<DDLWorker> ddl_worker);
-    DDLWorker & getDDLWorker();
+    DDLWorker & getDDLWorker() const;
 
     Clusters & getClusters() const;
     std::shared_ptr<Cluster> getCluster(const std::string & cluster_name) const;
diff --git a/dbms/src/Interpreters/DDLWorker.cpp b/dbms/src/Interpreters/DDLWorker.cpp
index 1519caf5763..481e7045bbe 100644
--- a/dbms/src/Interpreters/DDLWorker.cpp
+++ b/dbms/src/Interpreters/DDLWorker.cpp
@@ -932,7 +932,7 @@ class DDLQueryStatusInputSream : public IProfilingBlockInputStream
 {
 public:
 
-    DDLQueryStatusInputSream(const String & zk_node_path, const DDLLogEntry & entry, Context & context)
+    DDLQueryStatusInputSream(const String & zk_node_path, const DDLLogEntry & entry, const Context & context)
     : node_path(zk_node_path), context(context), watch(CLOCK_MONOTONIC_COARSE), log(&Logger::get("DDLQueryStatusInputSream"))
     {
         sample = Block{
@@ -1072,7 +1072,7 @@ private:
 
 private:
     String node_path;
-    Context & context;
+    const Context & context;
     Stopwatch watch;
     Logger * log;
 
@@ -1087,7 +1087,7 @@ private:
 };
 
 
-BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr_, Context & context)
+BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr_, const Context & context)
 {
     ASTPtr query_ptr;
 
diff --git a/dbms/src/Interpreters/DDLWorker.h b/dbms/src/Interpreters/DDLWorker.h
index f84f7ccba8b..f9c296d373a 100644
--- a/dbms/src/Interpreters/DDLWorker.h
+++ b/dbms/src/Interpreters/DDLWorker.h
@@ -18,7 +18,7 @@ struct DDLLogEntry;
 struct DDLTask;
 
 
-BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr, Context & context);
+BlockIO executeDDLQueryOnCluster(const ASTPtr & query_ptr, const Context & context);
 
 
 class DDLWorker
diff --git a/dbms/src/Interpreters/InterpreterAlterQuery.h b/dbms/src/Interpreters/InterpreterAlterQuery.h
index 753037072c7..4fd718cd781 100644
--- a/dbms/src/Interpreters/InterpreterAlterQuery.h
+++ b/dbms/src/Interpreters/InterpreterAlterQuery.h
@@ -120,7 +120,7 @@ private:
 
     ASTPtr query_ptr;
 
-    Context context;
+    const Context & context;
 
     static void parseAlter(const ASTAlterQuery::ParameterContainer & params,
         AlterCommands & out_alter_commands, PartitionCommands & out_partition_commands);
diff --git a/dbms/src/Interpreters/InterpreterInsertQuery.h b/dbms/src/Interpreters/InterpreterInsertQuery.h
index 7b9ccbd99ac..f353d0c59fd 100644
--- a/dbms/src/Interpreters/InterpreterInsertQuery.h
+++ b/dbms/src/Interpreters/InterpreterInsertQuery.h
@@ -30,7 +30,7 @@ private:
     Block getSampleBlock();
 
     ASTPtr query_ptr;
-    Context context;
+    const Context & context;
 };
 
 
diff --git a/dbms/src/Interpreters/SystemLog.h b/dbms/src/Interpreters/SystemLog.h
index 7b9f43a26a5..1df54449136 100644
--- a/dbms/src/Interpreters/SystemLog.h
+++ b/dbms/src/Interpreters/SystemLog.h
@@ -202,6 +202,7 @@ void SystemLog<LogElement>::threadFunction()
                 if (element.first)
                 {
                     /// Shutdown.
+                    /// NOTE: MergeTree engine can write data even it is already in shutdown state.
                     flush();
                     break;
                 }
diff --git a/dbms/src/Storages/IStorage.h b/dbms/src/Storages/IStorage.h
index a8d07d07e43..473792376c6 100644
--- a/dbms/src/Storages/IStorage.h
+++ b/dbms/src/Storages/IStorage.h
@@ -261,7 +261,7 @@ public:
         const Field & partition,
         const WeightedZooKeeperPaths & weighted_zookeeper_paths,
         const ASTPtr & sharding_key_expr, bool do_copy, const Field & coordinator,
-        Context & context)
+        const Context & context)
     {
         throw Exception("Method reshardPartition is not supported by storage " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
diff --git a/dbms/src/Storages/MergeTree/ReshardingWorker.cpp b/dbms/src/Storages/MergeTree/ReshardingWorker.cpp
index d0a93780162..bc1f866c8b8 100644
--- a/dbms/src/Storages/MergeTree/ReshardingWorker.cpp
+++ b/dbms/src/Storages/MergeTree/ReshardingWorker.cpp
@@ -320,7 +320,7 @@ std::string computeHashFromPartition(const std::string & data_path, const std::s
 ///
 
 ReshardingWorker::ReshardingWorker(const Poco::Util::AbstractConfiguration & config,
-    const std::string & config_name, Context & context_)
+    const std::string & config_name, const Context & context_)
     : context{context_}, get_zookeeper{[&]() { return context.getZooKeeper(); }}
 {
     Arguments arguments(config, config_name);
diff --git a/dbms/src/Storages/MergeTree/ReshardingWorker.h b/dbms/src/Storages/MergeTree/ReshardingWorker.h
index d39354ec6bf..ef0c14e16a0 100644
--- a/dbms/src/Storages/MergeTree/ReshardingWorker.h
+++ b/dbms/src/Storages/MergeTree/ReshardingWorker.h
@@ -2,10 +2,11 @@
 
 #include <Storages/MergeTree/ReshardingJob.h>
 #include <Storages/AlterCommands.h>
-#include <common/logger_useful.h>
+#include <Interpreters/Context.h>
 
 #include <Common/ZooKeeper/RWLock.h>
 #include <Common/ZooKeeper/SingleBarrier.h>
+#include <common/logger_useful.h>
 
 #include <Poco/Util/LayeredConfiguration.h>
 
@@ -14,10 +15,10 @@
 #include <atomic>
 #include <functional>
 
+
 namespace DB
 {
 
-class Context;
 class Cluster;
 class StorageReplicatedMergeTree;
 
@@ -42,7 +43,7 @@ public:
 
 public:
     ReshardingWorker(const Poco::Util::AbstractConfiguration & config,
-        const std::string & config_name, Context & context_);
+        const std::string & config_name, const Context & context_);
 
     ReshardingWorker(const ReshardingWorker &) = delete;
     ReshardingWorker & operator=(const ReshardingWorker &) = delete;
@@ -385,7 +386,8 @@ private:
     std::string distributed_lock_path;
     std::string coordination_path;
 
-    Context & context;
+    /// Use own Context (not reference) to execute queries in isolated environment
+    Context context;
     Logger * log = &Logger::get("ReshardingWorker");
 
     zkutil::EventPtr event = std::make_shared<Poco::Event>();
diff --git a/dbms/src/Storages/StorageDistributed.cpp b/dbms/src/Storages/StorageDistributed.cpp
index f389c57f8b8..7eb6e0b117e 100644
--- a/dbms/src/Storages/StorageDistributed.cpp
+++ b/dbms/src/Storages/StorageDistributed.cpp
@@ -273,7 +273,7 @@ void StorageDistributed::reshardPartitions(
     const Field & partition,
     const WeightedZooKeeperPaths & weighted_zookeeper_paths,
     const ASTPtr & sharding_key_expr, bool do_copy, const Field & coordinator,
-    Context & context)
+    const Context & context)
 {
     auto & resharding_worker = context.getReshardingWorker();
     if (!resharding_worker.isStarted())
diff --git a/dbms/src/Storages/StorageDistributed.h b/dbms/src/Storages/StorageDistributed.h
index d9e17b3d644..cd986803434 100644
--- a/dbms/src/Storages/StorageDistributed.h
+++ b/dbms/src/Storages/StorageDistributed.h
@@ -79,7 +79,7 @@ public:
         const Field & partition,
         const WeightedZooKeeperPaths & weighted_zookeeper_paths,
         const ASTPtr & sharding_key_expr, bool do_copy, const Field & coordinator,
-        Context & context) override;
+        const Context & context) override;
 
     /// From each replica, get a description of the corresponding local table.
     BlockInputStreams describe(const Context & context, const Settings & settings);
diff --git a/dbms/src/Storages/StorageReplicatedMergeTree.cpp b/dbms/src/Storages/StorageReplicatedMergeTree.cpp
index ef5728b9f04..f8e835d071d 100644
--- a/dbms/src/Storages/StorageReplicatedMergeTree.cpp
+++ b/dbms/src/Storages/StorageReplicatedMergeTree.cpp
@@ -3381,7 +3381,7 @@ void StorageReplicatedMergeTree::reshardPartitions(
     const Field & partition,
     const WeightedZooKeeperPaths & weighted_zookeeper_paths,
     const ASTPtr & sharding_key_expr, bool do_copy, const Field & coordinator,
-    Context & context)
+    const Context & context)
 {
     auto & resharding_worker = context.getReshardingWorker();
     if (!resharding_worker.isStarted())
diff --git a/dbms/src/Storages/StorageReplicatedMergeTree.h b/dbms/src/Storages/StorageReplicatedMergeTree.h
index 06b45ae8f1d..4379d38983d 100644
--- a/dbms/src/Storages/StorageReplicatedMergeTree.h
+++ b/dbms/src/Storages/StorageReplicatedMergeTree.h
@@ -146,7 +146,7 @@ public:
         const Field & partition,
         const WeightedZooKeeperPaths & weighted_zookeeper_paths,
         const ASTPtr & sharding_key_expr, bool do_copy, const Field & coordinator,
-        Context & context) override;
+        const Context & context) override;
 
     /** Removes a replica from ZooKeeper. If there are no other replicas, it deletes the entire table from ZooKeeper.
       */

From 325ceb85b5de000411bab8287aaf2585a4b901c3 Mon Sep 17 00:00:00 2001
From: Vitaliy Lyudvichenko <vludv@yandex-team.ru>
Date: Tue, 5 Sep 2017 17:16:07 +0300
Subject: [PATCH 080/266] Delete unusing files. [#CLICKHOUSE-2]

---
 .../AddingDefaultBlockInputStream.h           | 65 -------------------
 1 file changed, 65 deletions(-)
 delete mode 100644 dbms/src/DataStreams/AddingDefaultBlockInputStream.h

diff --git a/dbms/src/DataStreams/AddingDefaultBlockInputStream.h b/dbms/src/DataStreams/AddingDefaultBlockInputStream.h
deleted file mode 100644
index b5be6742371..00000000000
--- a/dbms/src/DataStreams/AddingDefaultBlockInputStream.h
+++ /dev/null
@@ -1,65 +0,0 @@
-#pragma once
-
-#include <DataStreams/IProfilingBlockInputStream.h>
-#include <Interpreters/evaluateMissingDefaults.h>
-#include <Columns/ColumnConst.h>
-#include <Interpreters/Context.h>
-#include <Storages/ColumnDefault.h>
-
-
-namespace DB
-{
-
-
-/** Adds missing columns to the block with default values.
-  * These columns are materialized (not constants).
-  */
-class AddingDefaultBlockInputStream : public IProfilingBlockInputStream
-{
-public:
-    AddingDefaultBlockInputStream(
-        BlockInputStreamPtr input_,
-        NamesAndTypesListPtr required_columns_,
-        const ColumnDefaults & column_defaults_,
-        const Context & context_)
-        : required_columns(required_columns_),
-          column_defaults(column_defaults_), context(context_)
-    {
-        children.push_back(input_);
-    }
-
-    String getName() const override { return "AddingDefault"; }
-
-    String getID() const override
-    {
-        std::stringstream res;
-        res << "AddingDefault(" << children.back()->getID();
-
-        for (NamesAndTypesList::const_iterator it = required_columns->begin(); it != required_columns->end(); ++it)
-            res << ", " << it->name << ", " << it->type->getName();
-
-        res << ")";
-        return res.str();
-    }
-
-protected:
-    Block readImpl() override
-    {
-        Block res = children.back()->read();
-        if (!res)
-            return res;
-        /** @todo if somehow block does not contain values for implicitly-defaulted columns that are prerequisites
-         *    for explicitly-defaulted ones, exception will be thrown during evaluating such columns
-         *    (implicitly-defaulted columns are evaluated on the line after following one. */
-        evaluateMissingDefaults(res, *required_columns, column_defaults, context);
-        res.addDefaults(*required_columns);
-        return res;
-    }
-
-private:
-    NamesAndTypesListPtr required_columns;
-    const ColumnDefaults column_defaults;
-    cosnt Context & context;
-};
-
-}

From d82b87aaefc48aa3c93f4c588820ab4f93e231fe Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 6 Sep 2017 04:57:27 +0300
Subject: [PATCH 081/266] Fixed redundand code in better way
 [#CLICKHOUSE-3281].

---
 .../Storages/MergeTree/MergeTreeDataPart.cpp  | 26 +++++++++----------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp b/dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp
index 3af6d0d8a91..eb1adf9fe33 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataPart.cpp
@@ -109,19 +109,19 @@ bool MergeTreeDataPartChecksums::read(ReadBuffer & in)
     readText(format_version, in);
     assertChar('\n', in);
 
-    if (format_version < 1 || format_version > 4)
-        throw Exception("Bad checksums format version: " + DB::toString(format_version), ErrorCodes::UNKNOWN_FORMAT);
-
-    if (format_version == 1)
-        return false;
-    if (format_version == 2)
-        return read_v2(in);
-    if (format_version == 3)
-        return read_v3(in);
-    if (format_version == 4)
-        return read_v4(in);
-
-    return false;
+    switch (format_version)
+    {
+        case 1:
+            return false;
+        case 2:
+            return read_v2(in);
+        case 3:
+            return read_v3(in);
+        case 4:
+            return read_v4(in);
+        default:
+            throw Exception("Bad checksums format version: " + DB::toString(format_version), ErrorCodes::UNKNOWN_FORMAT);
+    }
 }
 
 bool MergeTreeDataPartChecksums::read_v2(ReadBuffer & in)

From 31b598e1e355346eb3b7c837b8def69fbcd0ddb3 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 6 Sep 2017 05:01:22 +0300
Subject: [PATCH 082/266] Fixed bad code [#CLICKHOUSE-3281].

---
 dbms/src/Common/CombinedCardinalityEstimator.h        | 11 ++++-------
 dbms/src/Common/HyperLogLogWithSmallSetOptimization.h |  4 ++--
 2 files changed, 6 insertions(+), 9 deletions(-)

diff --git a/dbms/src/Common/CombinedCardinalityEstimator.h b/dbms/src/Common/CombinedCardinalityEstimator.h
index 94d21064a42..7390dde607f 100644
--- a/dbms/src/Common/CombinedCardinalityEstimator.h
+++ b/dbms/src/Common/CombinedCardinalityEstimator.h
@@ -228,6 +228,7 @@ private:
         if (getContainerType() != details::ContainerType::SMALL)
             throw Poco::Exception("Internal error", ErrorCodes::LOGICAL_ERROR);
 
+        CurrentMemoryTracker::alloc(sizeof(Medium));
         auto tmp_medium = std::make_unique<Medium>();
 
         for (const auto & x : small)
@@ -235,8 +236,6 @@ private:
 
         medium = tmp_medium.release();
         setContainerType(details::ContainerType::MEDIUM);
-
-        CurrentMemoryTracker::alloc(sizeof(medium));
     }
 
     void toLarge()
@@ -246,6 +245,7 @@ private:
         if ((container_type != details::ContainerType::SMALL) && (container_type != details::ContainerType::MEDIUM))
             throw Poco::Exception("Internal error", ErrorCodes::LOGICAL_ERROR);
 
+        CurrentMemoryTracker::alloc(sizeof(Large));
         auto tmp_large = std::make_unique<Large>();
 
         if (container_type == details::ContainerType::SMALL)
@@ -263,9 +263,6 @@ private:
 
         large = tmp_large.release();
         setContainerType(details::ContainerType::LARGE);
-
-        CurrentMemoryTracker::alloc(sizeof(large));
-
     }
 
     void NO_INLINE destroy()
@@ -279,14 +276,14 @@ private:
             delete medium;
             medium = nullptr;
 
-            CurrentMemoryTracker::free(sizeof(medium));
+            CurrentMemoryTracker::free(sizeof(Medium));
         }
         else if (container_type == details::ContainerType::LARGE)
         {
             delete large;
             large = nullptr;
 
-            CurrentMemoryTracker::free(sizeof(large));
+            CurrentMemoryTracker::free(sizeof(Large));
         }
     }
 
diff --git a/dbms/src/Common/HyperLogLogWithSmallSetOptimization.h b/dbms/src/Common/HyperLogLogWithSmallSetOptimization.h
index 5296a606121..164a434900a 100644
--- a/dbms/src/Common/HyperLogLogWithSmallSetOptimization.h
+++ b/dbms/src/Common/HyperLogLogWithSmallSetOptimization.h
@@ -37,7 +37,7 @@ private:
 
     void toLarge()
     {
-        CurrentMemoryTracker::alloc(sizeof(large));
+        CurrentMemoryTracker::alloc(sizeof(Large));
 
         /// At the time of copying data from `tiny`, setting the value of `large` is still not possible (otherwise it will overwrite some data).
         Large * tmp_large = new Large;
@@ -55,7 +55,7 @@ public:
         {
             delete large;
 
-            CurrentMemoryTracker::free(sizeof(large));
+            CurrentMemoryTracker::free(sizeof(Large));
         }
     }
 

From 3b6dd67178a10574efa6ba92d83588de04bfbabc Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 6 Sep 2017 05:11:01 +0300
Subject: [PATCH 083/266] Fixed nullptr dereference [#CLICKHOUSE-3281].

---
 dbms/src/Functions/FunctionsArray.cpp     | 3 +--
 dbms/src/Functions/FunctionsConditional.h | 6 +++---
 dbms/src/Functions/FunctionsMath.h        | 6 ++----
 3 files changed, 6 insertions(+), 9 deletions(-)

diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index 0e2270053b1..9e756922400 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -2413,8 +2413,7 @@ void FunctionRange::executeImpl(Block & block, const ColumnNumbers & arguments,
     {
         throw Exception{
             "Illegal column " + col->getName() + " of argument of function " + getName(),
-            ErrorCodes::ILLEGAL_COLUMN
-        };
+            ErrorCodes::ILLEGAL_COLUMN};
     }
 }
 
diff --git a/dbms/src/Functions/FunctionsConditional.h b/dbms/src/Functions/FunctionsConditional.h
index 38e0d134b0d..ad9dd4ac1c5 100644
--- a/dbms/src/Functions/FunctionsConditional.h
+++ b/dbms/src/Functions/FunctionsConditional.h
@@ -762,7 +762,7 @@ private:
                     : makeNullableColumnIfNot(arg_else.column);
             }
             else
-                throw Exception("Illegal column " + cond_col->getName() + " of first argument of function " + getName()
+                throw Exception("Illegal column " + arg_cond.column->getName() + " of first argument of function " + getName()
                     + ". Must be ColumnUInt8 or ColumnConstUInt8.",
                     ErrorCodes::ILLEGAL_COLUMN);
             return true;
@@ -802,7 +802,7 @@ private:
                     : block.getByPosition(result).type->createColumn()->cloneResized(block.rows());
             }
             else
-                throw Exception("Illegal column " + cond_col->getName() + " of first argument of function " + getName()
+                throw Exception("Illegal column " + arg_cond.column->getName() + " of first argument of function " + getName()
                     + ". Must be ColumnUInt8 or ColumnConstUInt8.",
                     ErrorCodes::ILLEGAL_COLUMN);
             return true;
@@ -1058,7 +1058,7 @@ public:
                     ErrorCodes::ILLEGAL_COLUMN);
         }
         else
-            throw Exception("Illegal column " + cond_col->getName() + " of first argument of function " + getName()
+            throw Exception("Illegal column " + arg_cond.column->getName() + " of first argument of function " + getName()
                 + ". Must be ColumnUInt8 or ColumnConstUInt8.",
                 ErrorCodes::ILLEGAL_COLUMN);
     }
diff --git a/dbms/src/Functions/FunctionsMath.h b/dbms/src/Functions/FunctionsMath.h
index fea7266e379..60ee1fadaca 100644
--- a/dbms/src/Functions/FunctionsMath.h
+++ b/dbms/src/Functions/FunctionsMath.h
@@ -92,8 +92,7 @@ private:
             {
                 throw Exception{
                     "Illegal type " + arg->getName() + " of argument of function " + getName(),
-                    ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT
-                };
+                    ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
             }
         };
 
@@ -158,8 +157,7 @@ private:
         {
             throw Exception{
                 "Illegal column " + arg->getName() + " of argument of function " + getName(),
-                ErrorCodes::ILLEGAL_COLUMN
-            };
+                ErrorCodes::ILLEGAL_COLUMN};
         }
     }
 };

From 452c40e85e67d9fcf7c5e3cf06d4d76b28689f87 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 6 Sep 2017 05:13:54 +0300
Subject: [PATCH 084/266] Fixed nullptr dereference [#CLICKHOUSE-3281].

---
 dbms/src/Analyzers/TypeAndConstantInference.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/dbms/src/Analyzers/TypeAndConstantInference.cpp b/dbms/src/Analyzers/TypeAndConstantInference.cpp
index 47c14ed9bfe..548a0e50c58 100644
--- a/dbms/src/Analyzers/TypeAndConstantInference.cpp
+++ b/dbms/src/Analyzers/TypeAndConstantInference.cpp
@@ -356,7 +356,6 @@ void processHigherOrderFunction(const String & column_name,
         if (lambda && lambda->name == "lambda")
         {
             const DataTypeExpression * lambda_type = typeid_cast<const DataTypeExpression *>(types[i].get());
-            const DataTypes & lambda_argument_types = lambda_type->getArgumentTypes();
 
             if (!lambda_type)
                 throw Exception("Logical error: IFunction::getLambdaArgumentTypes returned data type for lambda expression,"
@@ -369,6 +368,8 @@ void processHigherOrderFunction(const String & column_name,
 
             AnalyzeLambdas::LambdaParameters parameters = AnalyzeLambdas::extractLambdaParameters(lambda->arguments->children[0]);
 
+            const DataTypes & lambda_argument_types = lambda_type->getArgumentTypes();
+
             if (parameters.size() != lambda_argument_types.size())
                 throw Exception("DataTypeExpression for lambda function has different number of argument types than number of lambda parameters",
                     ErrorCodes::LOGICAL_ERROR);

From e1e0d517aa0529d37e207432ecfa77b70386a43b Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 6 Sep 2017 05:19:52 +0300
Subject: [PATCH 085/266] Fixed bad style in PerformanceTest
 [#CLICKHOUSE-3281].

---
 dbms/src/Server/PerformanceTest.cpp | 171 +++++++++++-----------------
 dbms/src/Server/main.cpp            |   4 +-
 2 files changed, 71 insertions(+), 104 deletions(-)

diff --git a/dbms/src/Server/PerformanceTest.cpp b/dbms/src/Server/PerformanceTest.cpp
index b421a437e94..81499dc254a 100644
--- a/dbms/src/Server/PerformanceTest.cpp
+++ b/dbms/src/Server/PerformanceTest.cpp
@@ -5,8 +5,8 @@
 #include <thread>
 #include <unistd.h>
 
-#include <boost/program_options.hpp>
 #include <boost/filesystem.hpp>
+#include <boost/program_options.hpp>
 #include <sys/stat.h>
 
 #include <common/DateLUT.h>
@@ -15,8 +15,8 @@
 #include <Client/Connection.h>
 #include <Common/ConcurrentBoundedQueue.h>
 #include <Common/Stopwatch.h>
-#include <common/ThreadPool.h>
 #include <Common/getFQDNOrHostName.h>
+#include <Common/getMultipleKeysFromConfig.h>
 #include <Common/getNumberOfPhysicalCPUCores.h>
 #include <Core/Types.h>
 #include <DataStreams/RemoteBlockInputStream.h>
@@ -24,8 +24,8 @@
 #include <IO/ReadHelpers.h>
 #include <IO/WriteBufferFromFile.h>
 #include <Interpreters/Settings.h>
+#include <common/ThreadPool.h>
 #include <common/getMemoryAmount.h>
-#include <Common/getMultipleKeysFromConfig.h>
 
 #include <Poco/AutoPtr.h>
 #include <Poco/Exception.h>
@@ -53,7 +53,8 @@ namespace ErrorCodes
     extern const int NOT_IMPLEMENTED;
 }
 
-static String pad(size_t padding) {
+static String pad(size_t padding)
+{
     return String(padding * 4, ' ');
 }
 
@@ -81,7 +82,7 @@ public:
     template <typename T>
     typename std::enable_if<std::is_arithmetic<T>::value>::type set(const String key, T value)
     {
-        set(key, std::to_string(value), /*wrap= */false);
+        set(key, std::to_string(value), /*wrap= */ false);
     }
 
     void set(const String key, const std::vector<JSONString> & run_infos)
@@ -101,7 +102,10 @@ public:
         content[key] = value;
     }
 
-    String asString() const { return asString(padding); }
+    String asString() const
+    {
+        return asString(padding);
+    }
     String asString(size_t padding) const
     {
         String repr = "{";
@@ -222,12 +226,12 @@ public:
         return !conditions_all_of.initialized_count && !conditions_any_of.initialized_count;
     }
 
-#define DEFINE_REPORT_FUNC(FUNC_NAME, CONDITION)                        \
-    void FUNC_NAME(UInt64 value)                                        \
-    {                                                                   \
-        conditions_all_of.report(value, conditions_all_of.CONDITION);   \
-        conditions_any_of.report(value, conditions_any_of.CONDITION);   \
-    }                                                                   \
+#define DEFINE_REPORT_FUNC(FUNC_NAME, CONDITION)                      \
+    void FUNC_NAME(UInt64 value)                                      \
+    {                                                                 \
+        conditions_all_of.report(value, conditions_all_of.CONDITION); \
+        conditions_any_of.report(value, conditions_any_of.CONDITION); \
+    }
 
     DEFINE_REPORT_FUNC(reportTotalTime, total_time_ms);
     DEFINE_REPORT_FUNC(reportRowsRead, rows_read);
@@ -241,9 +245,7 @@ public:
 
     bool areFulfilled() const
     {
-        return
-            (conditions_all_of.initialized_count
-                && conditions_all_of.fulfilled_count >= conditions_all_of.initialized_count)
+        return (conditions_all_of.initialized_count && conditions_all_of.fulfilled_count >= conditions_all_of.initialized_count)
             || (conditions_any_of.initialized_count && conditions_any_of.fulfilled_count);
     }
 
@@ -318,8 +320,8 @@ struct Stats
                 result += "\n";
             }
             result += FOUR_SPACES + "0.95:   " + std::to_string(sampler.quantileInterpolated(95 / 100.0)) + "\n";
-            result += FOUR_SPACES + "0.99: "   + std::to_string(sampler.quantileInterpolated(99 / 100.0)) + "\n";
-            result += FOUR_SPACES + "0.999: "  + std::to_string(sampler.quantileInterpolated(99.9 / 100.)) + "\n";
+            result += FOUR_SPACES + "0.99: " + std::to_string(sampler.quantileInterpolated(99 / 100.0)) + "\n";
+            result += FOUR_SPACES + "0.999: " + std::to_string(sampler.quantileInterpolated(99.9 / 100.)) + "\n";
             result += FOUR_SPACES + "0.9999: " + std::to_string(sampler.quantileInterpolated(99.99 / 100.));
 
             return result;
@@ -476,7 +478,7 @@ struct Stats
     }
 };
 
-double Stats::avg_rows_speed_precision  = 0.001;
+double Stats::avg_rows_speed_precision = 0.001;
 double Stats::avg_bytes_speed_precision = 0.001;
 
 class PerformanceTest
@@ -484,8 +486,7 @@ class PerformanceTest
 public:
     using Strings = std::vector<String>;
 
-    PerformanceTest(
-        const String & host_,
+    PerformanceTest(const String & host_,
         const UInt16 port_,
         const String & default_database_,
         const String & user_,
@@ -498,8 +499,7 @@ public:
         Strings && tests_names_,
         Strings && skip_names_,
         Strings && tests_names_regexp_,
-        Strings && skip_names_regexp_
-    )
+        Strings && skip_names_regexp_)
         : connection(host_, port_, default_database_, user_, password_),
           gotSIGINT(false),
           lite_output(lite_output_),
@@ -593,11 +593,9 @@ private:
 
     /// Removes configurations that has a given value. If leave is true, the logic is reversed.
     void removeConfigurationsIf(
-            std::vector<XMLConfigurationPtr> & configs,
-            FilterType filter_type, const Strings & values, bool leave = false)
+        std::vector<XMLConfigurationPtr> & configs, FilterType filter_type, const Strings & values, bool leave = false)
     {
-        auto checker = [&filter_type, &values, &leave](XMLConfigurationPtr & config)
-        {
+        auto checker = [&filter_type, &values, &leave](XMLConfigurationPtr & config) {
             if (values.size() == 0)
                 return false;
 
@@ -612,7 +610,8 @@ private:
                 for (size_t i = 0; i != tags_keys.size(); ++i)
                     tags[i] = config->getString("tags.tag[" + std::to_string(i) + "]");
 
-                for (const String & config_tag : tags) {
+                for (const String & config_tag : tags)
+                {
                     if (std::find(values.begin(), values.end(), config_tag) != values.end())
                         remove_or_not = true;
                 }
@@ -631,8 +630,7 @@ private:
                     return std::regex_search(config_name, pattern);
                 };
 
-                remove_or_not = config->has("name") ? (std::find_if(values.begin(), values.end(), regex_checker) != values.end())
-                                                    : false;
+                remove_or_not = config->has("name") ? (std::find_if(values.begin(), values.end(), regex_checker) != values.end()) : false;
             }
 
             if (leave)
@@ -672,7 +670,8 @@ private:
         for (const String & precondition : preconditions)
         {
             if (precondition == "flush_disk_cache")
-                if (system("(>&2 echo 'Flushing disk cache...') && (sudo sh -c 'echo 3 > /proc/sys/vm/drop_caches') && (>&2 echo 'Flushed.')"))
+                if (system(
+                        "(>&2 echo 'Flushing disk cache...') && (sudo sh -c 'echo 3 > /proc/sys/vm/drop_caches') && (>&2 echo 'Flushed.')"))
                 {
                     std::cerr << "Failed to flush disk cache" << std::endl;
                     return false;
@@ -784,8 +783,7 @@ private:
     }
 
     void extractSettings(
-            const XMLConfigurationPtr & config, const String & key,
-            const Strings & settings_list, std::map<String, String> & settings_to_apply)
+        const XMLConfigurationPtr & config, const String & key, const Strings & settings_list, std::map<String, String> & settings_to_apply)
     {
         for (const String & setup : settings_list)
         {
@@ -834,15 +832,15 @@ private:
             /// and, if found any settings in test's xml configuration
             /// with the same name, sets its value to settings
             std::map<String, String>::iterator it;
-            #define EXTRACT_SETTING(TYPE, NAME, DEFAULT) \
-                it = settings_to_apply.find(#NAME);      \
-                if (it != settings_to_apply.end())       \
-                    settings.set(#NAME, settings_to_apply[#NAME]);
+#define EXTRACT_SETTING(TYPE, NAME, DEFAULT) \
+    it = settings_to_apply.find(#NAME);      \
+    if (it != settings_to_apply.end())       \
+        settings.set(#NAME, settings_to_apply[#NAME]);
 
             APPLY_FOR_SETTINGS(EXTRACT_SETTING)
             APPLY_FOR_LIMITS(EXTRACT_SETTING)
 
-            #undef EXTRACT_SETTING
+#undef EXTRACT_SETTING
 
             if (std::find(config_settings.begin(), config_settings.end(), "average_rows_speed_precision") != config_settings.end())
             {
@@ -1074,10 +1072,8 @@ private:
 
         RemoteBlockInputStream stream(connection, query, global_context, &settings);
 
-        stream.setProgressCallback([&](const Progress & value)
-            {
-                this->checkFulfilledConditionsAndUpdate(value, stream, statistics, stop_conditions);
-            });
+        stream.setProgressCallback(
+            [&](const Progress & value) { this->checkFulfilledConditionsAndUpdate(value, stream, statistics, stop_conditions); });
 
         stream.readPrefix();
         while (Block block = stream.read())
@@ -1091,10 +1087,7 @@ private:
     }
 
     void checkFulfilledConditionsAndUpdate(
-            const Progress & progress,
-            RemoteBlockInputStream & stream,
-            Stats & statistics,
-            TestStopConditions & stop_conditions)
+        const Progress & progress, RemoteBlockInputStream & stream, Stats & statistics, TestStopConditions & stop_conditions)
     {
         statistics.add(progress.rows, progress.bytes);
 
@@ -1102,10 +1095,8 @@ private:
         stop_conditions.reportBytesReadUncompressed(statistics.total_bytes_read);
         stop_conditions.reportTotalTime(statistics.watch.elapsed() / (1000 * 1000));
         stop_conditions.reportMinTimeNotChangingFor(statistics.min_time_watch.elapsed() / (1000 * 1000));
-        stop_conditions.reportMaxSpeedNotChangingFor(
-                statistics.max_rows_speed_watch.elapsed() / (1000 * 1000));
-        stop_conditions.reportAverageSpeedNotChangingFor(
-                statistics.avg_rows_speed_watch.elapsed() / (1000 * 1000));
+        stop_conditions.reportMaxSpeedNotChangingFor(statistics.max_rows_speed_watch.elapsed() / (1000 * 1000));
+        stop_conditions.reportAverageSpeedNotChangingFor(statistics.avg_rows_speed_watch.elapsed() / (1000 * 1000));
 
         if (stop_conditions.areFulfilled())
         {
@@ -1128,8 +1119,7 @@ private:
 
         for (size_t i = 0; i != xml_substitutions.size(); ++i)
         {
-            const ConfigurationPtr xml_substitution(
-                    substitutions_view->createView("substitution[" + std::to_string(i) + "]"));
+            const ConfigurationPtr xml_substitution(substitutions_view->createView("substitution[" + std::to_string(i) + "]"));
 
             /// Property values for substitution will be stored in a vector
             /// accessible by property name
@@ -1273,7 +1263,6 @@ public:
                 }
 
 
-
                 if (exec_type == ExecutionType::Loop)
                 {
                     /// in seconds
@@ -1291,9 +1280,9 @@ public:
 
                             quantiles.set(quantile_key, statistics.sampler.quantileInterpolated(percent / 100.0));
                         }
-                        quantiles.set("0.95",   statistics.sampler.quantileInterpolated(95    / 100.0));
-                        quantiles.set("0.99",   statistics.sampler.quantileInterpolated(99    / 100.0));
-                        quantiles.set("0.999",  statistics.sampler.quantileInterpolated(99.9  / 100.0));
+                        quantiles.set("0.95", statistics.sampler.quantileInterpolated(95 / 100.0));
+                        quantiles.set("0.99", statistics.sampler.quantileInterpolated(99 / 100.0));
+                        quantiles.set("0.999", statistics.sampler.quantileInterpolated(99.9 / 100.0));
                         quantiles.set("0.9999", statistics.sampler.quantileInterpolated(99.99 / 100.0));
 
                         runJSON.set("quantiles", quantiles.asString());
@@ -1303,16 +1292,13 @@ public:
                         runJSON.set("total_time", statistics.total_time);
 
                     if (std::find(metrics.begin(), metrics.end(), "queries_per_second") != metrics.end())
-                        runJSON.set("queries_per_second", double(statistics.queries) /
-                                                          statistics.total_time);
+                        runJSON.set("queries_per_second", double(statistics.queries) / statistics.total_time);
 
                     if (std::find(metrics.begin(), metrics.end(), "rows_per_second") != metrics.end())
-                        runJSON.set("rows_per_second", double(statistics.total_rows_read) /
-                                                       statistics.total_time);
+                        runJSON.set("rows_per_second", double(statistics.total_rows_read) / statistics.total_time);
 
                     if (std::find(metrics.begin(), metrics.end(), "bytes_per_second") != metrics.end())
-                        runJSON.set("bytes_per_second", double(statistics.total_bytes_read) /
-                                                        statistics.total_time);
+                        runJSON.set("bytes_per_second", double(statistics.total_bytes_read) / statistics.total_time);
                 }
                 else
                 {
@@ -1387,7 +1373,7 @@ static void getFilesFromDir(const FS::path & dir, std::vector<String> & input_fi
     }
 }
 
-int mainEntryClickhousePerformanceTest(int argc, char ** argv)
+int mainEntryClickHousePerformanceTest(int argc, char ** argv)
 {
     using namespace DB;
 
@@ -1397,22 +1383,17 @@ int mainEntryClickhousePerformanceTest(int argc, char ** argv)
         using Strings = std::vector<String>;
 
         boost::program_options::options_description desc("Allowed options");
-        desc.add_options()
-            ("help",                                                                     "produce help message")
-            ("lite",                                                                     "use lite version of output")
-            ("profiles-file",        value<String>()->default_value(""),            "Specify a file with global profiles")
-            ("host,h",               value<String>()->default_value("localhost"),   "")
-            ("port",                 value<UInt16>()->default_value(9000),               "")
-            ("database",             value<String>()->default_value("default"),     "")
-            ("user",                 value<String>()->default_value("default"),     "")
-            ("password",             value<String>()->default_value(""),            "")
-            ("tags",                 value<Strings>()->multitoken(),                     "Run only tests with tag")
-            ("skip-tags",            value<Strings>()->multitoken(),                     "Do not run tests with tag")
-            ("names",                value<Strings>()->multitoken(),                     "Run tests with specific name")
-            ("skip-names",           value<Strings>()->multitoken(),                     "Do not run tests with name")
-            ("names-regexp",         value<Strings>()->multitoken(),                     "Run tests with names matching regexp")
-            ("skip-names-regexp",    value<Strings>()->multitoken(),                     "Do not run tests with names matching regexp")
-            ("recursive,r",                                                              "Recurse in directories to find all xml's");
+        desc.add_options()("help", "produce help message")("lite", "use lite version of output")(
+            "profiles-file", value<String>()->default_value(""), "Specify a file with global profiles")(
+            "host,h", value<String>()->default_value("localhost"), "")("port", value<UInt16>()->default_value(9000), "")(
+            "database", value<String>()->default_value("default"), "")("user", value<String>()->default_value("default"), "")(
+            "password", value<String>()->default_value(""), "")("tags", value<Strings>()->multitoken(), "Run only tests with tag")(
+            "skip-tags", value<Strings>()->multitoken(), "Do not run tests with tag")("names",
+            value<Strings>()->multitoken(),
+            "Run tests with specific name")("skip-names", value<Strings>()->multitoken(), "Do not run tests with name")(
+            "names-regexp", value<Strings>()->multitoken(), "Run tests with names matching regexp")("skip-names-regexp",
+            value<Strings>()->multitoken(),
+            "Do not run tests with names matching regexp")("recursive,r", "Recurse in directories to find all xml's");
 
         /// These options will not be displayed in --help
         boost::program_options::options_description hidden("Hidden options");
@@ -1468,7 +1449,7 @@ int mainEntryClickhousePerformanceTest(int argc, char ** argv)
 
                 if (FS::is_directory(file))
                 {
-                    input_files.erase( std::remove(input_files.begin(), input_files.end(), filename) , input_files.end() );
+                    input_files.erase(std::remove(input_files.begin(), input_files.end(), filename), input_files.end());
                     getFilesFromDir(file, input_files, recursive);
                 }
                 else
@@ -1479,27 +1460,14 @@ int mainEntryClickhousePerformanceTest(int argc, char ** argv)
             }
         }
 
-        Strings tests_tags = options.count("tags")
-            ? options["tags"].as<Strings>()
-            : Strings({});
-        Strings skip_tags = options.count("skip-tags")
-            ? options["skip-tags"].as<Strings>()
-            : Strings({});
-        Strings tests_names = options.count("names")
-            ? options["names"].as<Strings>()
-            : Strings({});
-        Strings skip_names = options.count("skip-names")
-            ? options["skip-names"].as<Strings>()
-            : Strings({});
-        Strings tests_names_regexp = options.count("names-regexp")
-            ? options["names-regexp"].as<Strings>()
-            : Strings({});
-        Strings skip_names_regexp = options.count("skip-names-regexp")
-            ? options["skip-names-regexp"].as<Strings>()
-            : Strings({});
+        Strings tests_tags = options.count("tags") ? options["tags"].as<Strings>() : Strings({});
+        Strings skip_tags = options.count("skip-tags") ? options["skip-tags"].as<Strings>() : Strings({});
+        Strings tests_names = options.count("names") ? options["names"].as<Strings>() : Strings({});
+        Strings skip_names = options.count("skip-names") ? options["skip-names"].as<Strings>() : Strings({});
+        Strings tests_names_regexp = options.count("names-regexp") ? options["names-regexp"].as<Strings>() : Strings({});
+        Strings skip_names_regexp = options.count("skip-names-regexp") ? options["skip-names-regexp"].as<Strings>() : Strings({});
 
-        PerformanceTest performanceTest(
-            options["host"].as<String>(),
+        PerformanceTest performanceTest(options["host"].as<String>(),
             options["port"].as<UInt16>(),
             options["database"].as<String>(),
             options["user"].as<String>(),
@@ -1512,12 +1480,11 @@ int mainEntryClickhousePerformanceTest(int argc, char ** argv)
             std::move(tests_names),
             std::move(skip_names),
             std::move(tests_names_regexp),
-            std::move(skip_names_regexp)
-        );
+            std::move(skip_names_regexp));
     }
     catch (...)
     {
-        std::cout << getCurrentExceptionMessage(/*with stacktrace = */true) << std::endl;
+        std::cout << getCurrentExceptionMessage(/*with stacktrace = */ true) << std::endl;
         return getCurrentExceptionCode();
     }
 
diff --git a/dbms/src/Server/main.cpp b/dbms/src/Server/main.cpp
index 62c411bfbdf..f1d0a7b4deb 100644
--- a/dbms/src/Server/main.cpp
+++ b/dbms/src/Server/main.cpp
@@ -11,7 +11,7 @@ int mainEntryClickHouseServer(int argc, char ** argv);
 int mainEntryClickHouseClient(int argc, char ** argv);
 int mainEntryClickHouseLocal(int argc, char ** argv);
 int mainEntryClickHouseBenchmark(int argc, char ** argv);
-int mainEntryClickhousePerformanceTest(int argc, char ** argv);
+int mainEntryClickHousePerformanceTest(int argc, char ** argv);
 int mainEntryClickHouseExtractFromConfig(int argc, char ** argv);
 
 static bool isClickhouseApp(const std::string & app_suffix, std::vector<char *> & argv)
@@ -55,7 +55,7 @@ int main(int argc_, char ** argv_)
     else if (isClickhouseApp("server", argv)) /// --server arg should be cut
         main_func = mainEntryClickHouseServer;
     else if (isClickhouseApp("performance-test", argv))
-        main_func = mainEntryClickhousePerformanceTest;
+        main_func = mainEntryClickHousePerformanceTest;
     else if (isClickhouseApp("extract-from-config", argv))
         main_func = mainEntryClickHouseExtractFromConfig;
 

From 9290d26c58d1fdc53b3471ac6f4b09165b5352d1 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 6 Sep 2017 05:25:01 +0300
Subject: [PATCH 086/266] Removed some garbage from PerformanceTest
 [#CLICKHOUSE-3281].

---
 dbms/src/Server/PerformanceTest.cpp | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/dbms/src/Server/PerformanceTest.cpp b/dbms/src/Server/PerformanceTest.cpp
index 81499dc254a..5c12956b984 100644
--- a/dbms/src/Server/PerformanceTest.cpp
+++ b/dbms/src/Server/PerformanceTest.cpp
@@ -74,7 +74,7 @@ public:
 
         bool reserved = (value[0] == '[' || value[0] == '{' || value == "null");
         if (!reserved && wrap)
-            value = '\"' + value + '\"';
+            value = '"' + value + '"';
 
         content[key] = value;
     }
@@ -115,7 +115,7 @@ public:
             if (it != content.begin())
                 repr += ',';
             /// construct "key": "value" string with padding
-            repr += "\n" + pad(padding) + '\"' + it->first + '\"' + ": " + it->second;
+            repr += "\n" + pad(padding) + '"' + it->first + '"' + ": " + it->second;
         }
 
         repr += "\n" + pad(padding - 1) + '}';
@@ -380,7 +380,8 @@ struct Stats
         double & avg_speed_value)
     {
         avg_speed_value = ((avg_speed_value * number_of_info_batches) + new_speed_info);
-        avg_speed_value /= (++number_of_info_batches);
+        ++number_of_info_batches;
+        avg_speed_value /= number_of_info_batches;
 
         if (avg_speed_first == 0)
         {
@@ -670,12 +671,14 @@ private:
         for (const String & precondition : preconditions)
         {
             if (precondition == "flush_disk_cache")
+            {
                 if (system(
                         "(>&2 echo 'Flushing disk cache...') && (sudo sh -c 'echo 3 > /proc/sys/vm/drop_caches') && (>&2 echo 'Flushed.')"))
                 {
                     std::cerr << "Failed to flush disk cache" << std::endl;
                     return false;
                 }
+            }
 
             if (precondition == "ram_size")
             {
@@ -753,7 +756,7 @@ private:
             {
                 if (!checkPreconditions(test_config))
                 {
-                    std::cerr << "Preconditions are not fulfilled for test \"" + test_config->getString("name", "") + "\" ";
+                    std::cerr << "Preconditions are not fulfilled for test '" + test_config->getString("name", "") + "' ";
                     continue;
                 }
 
@@ -1222,7 +1225,7 @@ public:
                 String array_string = "[";
                 for (size_t i = 0; i != values.size(); ++i)
                 {
-                    array_string += '\"' + values[i] + '\"';
+                    array_string += '"' + values[i] + '"';
                     if (i != values.size() - 1)
                     {
                         array_string += ", ";
@@ -1360,7 +1363,7 @@ public:
 static void getFilesFromDir(const FS::path & dir, std::vector<String> & input_files, const bool recursive = false)
 {
     if (dir.extension().string() == ".xml")
-        std::cerr << "Warning: \"" + dir.string() + "\" is a directory, but has .xml extension" << std::endl;
+        std::cerr << "Warning: '" + dir.string() + "' is a directory, but has .xml extension" << std::endl;
 
     FS::directory_iterator end;
     for (FS::directory_iterator it(dir); it != end; ++it)
@@ -1445,7 +1448,7 @@ int mainEntryClickHousePerformanceTest(int argc, char ** argv)
                 FS::path file(filename);
 
                 if (!FS::exists(file))
-                    throw DB::Exception("File \"" + filename + "\" does not exist", 1);
+                    throw DB::Exception("File '" + filename + "' does not exist", 1);
 
                 if (FS::is_directory(file))
                 {
@@ -1455,7 +1458,7 @@ int mainEntryClickHousePerformanceTest(int argc, char ** argv)
                 else
                 {
                     if (file.extension().string() != ".xml")
-                        throw DB::Exception("File \"" + filename + "\" does not have .xml extension", 1);
+                        throw DB::Exception("File '" + filename + "' does not have .xml extension", 1);
                 }
             }
         }

From 426da39acbbf5b0251e7d4d788df35b7dfe9016a Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 6 Sep 2017 05:33:24 +0300
Subject: [PATCH 087/266] Fixed bad code in PerformanceTest [#CLICKHOUSE-3281].

---
 dbms/src/Server/PerformanceTest.cpp | 31 ++++++++++++++++-------------
 1 file changed, 17 insertions(+), 14 deletions(-)

diff --git a/dbms/src/Server/PerformanceTest.cpp b/dbms/src/Server/PerformanceTest.cpp
index 5c12956b984..36caebe9e41 100644
--- a/dbms/src/Server/PerformanceTest.cpp
+++ b/dbms/src/Server/PerformanceTest.cpp
@@ -39,7 +39,7 @@
   * The tool walks through given or default folder in order to find files with
   * tests' descriptions and launches it.
   */
-namespace FS = boost::filesystem;
+namespace fs = boost::filesystem;
 using String = std::string;
 const String FOUR_SPACES = "    ";
 
@@ -879,7 +879,7 @@ private:
             if (filename.empty())
                 throw DB::Exception("Empty file name", 1);
 
-            bool tsv = FS::path(filename).extension().string() == ".tsv";
+            bool tsv = fs::path(filename).extension().string() == ".tsv";
 
             ReadBufferFromFile query_file(filename);
 
@@ -1360,18 +1360,18 @@ public:
 };
 }
 
-static void getFilesFromDir(const FS::path & dir, std::vector<String> & input_files, const bool recursive = false)
+static void getFilesFromDir(const fs::path & dir, std::vector<String> & input_files, const bool recursive = false)
 {
     if (dir.extension().string() == ".xml")
         std::cerr << "Warning: '" + dir.string() + "' is a directory, but has .xml extension" << std::endl;
 
-    FS::directory_iterator end;
-    for (FS::directory_iterator it(dir); it != end; ++it)
+    fs::directory_iterator end;
+    for (fs::directory_iterator it(dir); it != end; ++it)
     {
-        const FS::path file = (*it);
-        if (recursive && FS::is_directory(file))
+        const fs::path file = (*it);
+        if (recursive && fs::is_directory(file))
             getFilesFromDir(file, input_files, recursive);
-        else if (!FS::is_directory(file) && file.extension().string() == ".xml")
+        else if (!fs::is_directory(file) && file.extension().string() == ".xml")
             input_files.push_back(file.string());
     }
 }
@@ -1427,7 +1427,7 @@ int mainEntryClickHousePerformanceTest(int argc, char ** argv)
         if (!options.count("input-files"))
         {
             std::cerr << "Trying to find test scenario files in the current folder...";
-            FS::path curr_dir(".");
+            fs::path curr_dir(".");
 
             getFilesFromDir(curr_dir, input_files, recursive);
 
@@ -1442,25 +1442,28 @@ int mainEntryClickHousePerformanceTest(int argc, char ** argv)
         else
         {
             input_files = options["input-files"].as<Strings>();
+            Strings collected_files;
 
             for (const String filename : input_files)
             {
-                FS::path file(filename);
+                fs::path file(filename);
 
-                if (!FS::exists(file))
+                if (!fs::exists(file))
                     throw DB::Exception("File '" + filename + "' does not exist", 1);
 
-                if (FS::is_directory(file))
+                if (fs::is_directory(file))
                 {
-                    input_files.erase(std::remove(input_files.begin(), input_files.end(), filename), input_files.end());
-                    getFilesFromDir(file, input_files, recursive);
+                    getFilesFromDir(file, collected_files, recursive);
                 }
                 else
                 {
                     if (file.extension().string() != ".xml")
                         throw DB::Exception("File '" + filename + "' does not have .xml extension", 1);
+                    collected_files.push_back(filename);
                 }
             }
+
+            input_files = std::move(collected_files);
         }
 
         Strings tests_tags = options.count("tags") ? options["tags"].as<Strings>() : Strings({});

From 7237445356f7f89dc697ffa7afb5e47109cabdba Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 6 Sep 2017 05:36:00 +0300
Subject: [PATCH 088/266] Fixed another bad code in PerformanceTest
 [#CLICKHOUSE-3281].

---
 dbms/src/Server/PerformanceTest.cpp | 221 ++++++++++++++--------------
 1 file changed, 109 insertions(+), 112 deletions(-)

diff --git a/dbms/src/Server/PerformanceTest.cpp b/dbms/src/Server/PerformanceTest.cpp
index 36caebe9e41..f33f1df9c04 100644
--- a/dbms/src/Server/PerformanceTest.cpp
+++ b/dbms/src/Server/PerformanceTest.cpp
@@ -152,7 +152,7 @@ struct StopConditionsSet
             else if (key == "average_speed_not_changing_for_ms")
                 average_speed_not_changing_for_ms.value = stop_conditions_view->getUInt64(key);
             else
-                throw DB::Exception("Met unkown stop condition: " + key, 1);
+                throw DB::Exception("Met unkown stop condition: " + key);
 
             ++initialized_count;
         }
@@ -860,12 +860,12 @@ private:
 
         if (!test_config->has("query") && !test_config->has("query_file"))
         {
-            throw DB::Exception("Missing query fields in test's config: " + test_name, 1);
+            throw DB::Exception("Missing query fields in test's config: " + test_name);
         }
 
         if (test_config->has("query") && test_config->has("query_file"))
         {
-            throw DB::Exception("Found both query and query_file fields. Choose only one", 1);
+            throw DB::Exception("Found both query and query_file fields. Choose only one");
         }
 
         if (test_config->has("query"))
@@ -877,7 +877,7 @@ private:
         {
             const String filename = test_config->getString("query_file");
             if (filename.empty())
-                throw DB::Exception("Empty file name", 1);
+                throw DB::Exception("Empty file name");
 
             bool tsv = fs::path(filename).extension().string() == ".tsv";
 
@@ -901,13 +901,13 @@ private:
 
         if (queries.empty())
         {
-            throw DB::Exception("Did not find any query to execute: " + test_name, 1);
+            throw DB::Exception("Did not find any query to execute: " + test_name);
         }
 
         if (test_config->has("substitutions"))
         {
             if (queries.size() > 1)
-                throw DB::Exception("Only one query is allowed when using substitutions", 1);
+                throw DB::Exception("Only one query is allowed when using substitutions");
 
             /// Make "subconfig" of inner xml block
             ConfigurationPtr substitutions_view(test_config->createView("substitutions"));
@@ -918,7 +918,7 @@ private:
 
         if (!test_config->has("type"))
         {
-            throw DB::Exception("Missing type property in config: " + test_name, 1);
+            throw DB::Exception("Missing type property in config: " + test_name);
         }
 
         String config_exec_type = test_config->getString("type");
@@ -927,9 +927,9 @@ private:
         else if (config_exec_type == "once")
             exec_type = ExecutionType::Once;
         else
-            throw DB::Exception("Unknown type " + config_exec_type + " in :" + test_name, 1);
+            throw DB::Exception("Unknown type " + config_exec_type + " in :" + test_name);
 
-        times_to_run = test_config->getUInt("times_to_run", 1);
+        times_to_run = test_config->getUInt("times_to_run");
 
         stop_conditions_by_run.clear();
         TestStopConditions stop_conditions_template;
@@ -940,7 +940,7 @@ private:
         }
 
         if (stop_conditions_template.empty())
-            throw DB::Exception("No termination conditions were found in config", 1);
+            throw DB::Exception("No termination conditions were found in config");
 
         for (size_t i = 0; i < times_to_run * queries.size(); ++i)
             stop_conditions_by_run.push_back(stop_conditions_template);
@@ -967,7 +967,7 @@ private:
         else
         {
             if (lite_output)
-                throw DB::Exception("Specify main_metric for lite output", 1);
+                throw DB::Exception("Specify main_metric for lite output");
         }
 
         if (metrics.size() > 0)
@@ -1015,7 +1015,7 @@ private:
             {
                 if (std::find(non_loop_metrics.begin(), non_loop_metrics.end(), metric) != non_loop_metrics.end())
                 {
-                    throw DB::Exception("Wrong type of metric for loop execution type (" + metric + ")", 1);
+                    throw DB::Exception("Wrong type of metric for loop execution type (" + metric + ")");
                 }
             }
         }
@@ -1025,7 +1025,7 @@ private:
             {
                 if (std::find(loop_metrics.begin(), loop_metrics.end(), metric) != loop_metrics.end())
                 {
-                    throw DB::Exception("Wrong type of metric for non-loop execution type (" + metric + ")", 1);
+                    throw DB::Exception("Wrong type of metric for non-loop execution type (" + metric + ")");
                 }
             }
         }
@@ -1377,122 +1377,119 @@ static void getFilesFromDir(const fs::path & dir, std::vector<String> & input_fi
 }
 
 int mainEntryClickHousePerformanceTest(int argc, char ** argv)
+try
 {
-    using namespace DB;
+    using boost::program_options::value;
+    using Strings = std::vector<String>;
 
-    try
+    boost::program_options::options_description desc("Allowed options");
+    desc.add_options()("help", "produce help message")("lite", "use lite version of output")(
+        "profiles-file", value<String>()->default_value(""), "Specify a file with global profiles")(
+        "host,h", value<String>()->default_value("localhost"), "")("port", value<UInt16>()->default_value(9000), "")(
+        "database", value<String>()->default_value("default"), "")("user", value<String>()->default_value("default"), "")(
+        "password", value<String>()->default_value(""), "")("tags", value<Strings>()->multitoken(), "Run only tests with tag")(
+        "skip-tags", value<Strings>()->multitoken(), "Do not run tests with tag")("names",
+        value<Strings>()->multitoken(),
+        "Run tests with specific name")("skip-names", value<Strings>()->multitoken(), "Do not run tests with name")(
+        "names-regexp", value<Strings>()->multitoken(), "Run tests with names matching regexp")("skip-names-regexp",
+        value<Strings>()->multitoken(),
+        "Do not run tests with names matching regexp")("recursive,r", "Recurse in directories to find all xml's");
+
+    /// These options will not be displayed in --help
+    boost::program_options::options_description hidden("Hidden options");
+    hidden.add_options()("input-files", value<std::vector<String>>(), "");
+
+    /// But they will be legit, though. And they must be given without name
+    boost::program_options::positional_options_description positional;
+    positional.add("input-files", -1);
+
+    boost::program_options::options_description cmdline_options;
+    cmdline_options.add(desc).add(hidden);
+
+    boost::program_options::variables_map options;
+    boost::program_options::store(
+        boost::program_options::command_line_parser(argc, argv).options(cmdline_options).positional(positional).run(), options);
+    boost::program_options::notify(options);
+
+    if (options.count("help"))
     {
-        using boost::program_options::value;
-        using Strings = std::vector<String>;
+        std::cout << "Usage: " << argv[0] << " [options] [test_file ...] [tests_folder]\n";
+        std::cout << desc << "\n";
+        return 0;
+    }
 
-        boost::program_options::options_description desc("Allowed options");
-        desc.add_options()("help", "produce help message")("lite", "use lite version of output")(
-            "profiles-file", value<String>()->default_value(""), "Specify a file with global profiles")(
-            "host,h", value<String>()->default_value("localhost"), "")("port", value<UInt16>()->default_value(9000), "")(
-            "database", value<String>()->default_value("default"), "")("user", value<String>()->default_value("default"), "")(
-            "password", value<String>()->default_value(""), "")("tags", value<Strings>()->multitoken(), "Run only tests with tag")(
-            "skip-tags", value<Strings>()->multitoken(), "Do not run tests with tag")("names",
-            value<Strings>()->multitoken(),
-            "Run tests with specific name")("skip-names", value<Strings>()->multitoken(), "Do not run tests with name")(
-            "names-regexp", value<Strings>()->multitoken(), "Run tests with names matching regexp")("skip-names-regexp",
-            value<Strings>()->multitoken(),
-            "Do not run tests with names matching regexp")("recursive,r", "Recurse in directories to find all xml's");
+    Strings input_files;
+    bool recursive = options.count("recursive");
 
-        /// These options will not be displayed in --help
-        boost::program_options::options_description hidden("Hidden options");
-        hidden.add_options()("input-files", value<std::vector<String>>(), "");
+    if (!options.count("input-files"))
+    {
+        std::cerr << "Trying to find test scenario files in the current folder...";
+        fs::path curr_dir(".");
 
-        /// But they will be legit, though. And they must be given without name
-        boost::program_options::positional_options_description positional;
-        positional.add("input-files", -1);
+        getFilesFromDir(curr_dir, input_files, recursive);
 
-        boost::program_options::options_description cmdline_options;
-        cmdline_options.add(desc).add(hidden);
-
-        boost::program_options::variables_map options;
-        boost::program_options::store(
-            boost::program_options::command_line_parser(argc, argv).options(cmdline_options).positional(positional).run(), options);
-        boost::program_options::notify(options);
-
-        if (options.count("help"))
+        if (input_files.empty())
         {
-            std::cout << "Usage: " << argv[0] << " [options] [test_file ...] [tests_folder]\n";
-            std::cout << desc << "\n";
-            return 0;
-        }
-
-        Strings input_files;
-        bool recursive = options.count("recursive");
-
-        if (!options.count("input-files"))
-        {
-            std::cerr << "Trying to find test scenario files in the current folder...";
-            fs::path curr_dir(".");
-
-            getFilesFromDir(curr_dir, input_files, recursive);
-
-            if (input_files.empty())
-            {
-                std::cerr << std::endl;
-                throw DB::Exception("Did not find any xml files", 1);
-            }
-            else
-                std::cerr << " found " << input_files.size() << " files." << std::endl;
+            std::cerr << std::endl;
+            throw DB::Exception("Did not find any xml files");
         }
         else
+            std::cerr << " found " << input_files.size() << " files." << std::endl;
+    }
+    else
+    {
+        input_files = options["input-files"].as<Strings>();
+        Strings collected_files;
+
+        for (const String filename : input_files)
         {
-            input_files = options["input-files"].as<Strings>();
-            Strings collected_files;
+            fs::path file(filename);
 
-            for (const String filename : input_files)
+            if (!fs::exists(file))
+                throw DB::Exception("File '" + filename + "' does not exist");
+
+            if (fs::is_directory(file))
             {
-                fs::path file(filename);
-
-                if (!fs::exists(file))
-                    throw DB::Exception("File '" + filename + "' does not exist", 1);
-
-                if (fs::is_directory(file))
-                {
-                    getFilesFromDir(file, collected_files, recursive);
-                }
-                else
-                {
-                    if (file.extension().string() != ".xml")
-                        throw DB::Exception("File '" + filename + "' does not have .xml extension", 1);
-                    collected_files.push_back(filename);
-                }
+                getFilesFromDir(file, collected_files, recursive);
+            }
+            else
+            {
+                if (file.extension().string() != ".xml")
+                    throw DB::Exception("File '" + filename + "' does not have .xml extension");
+                collected_files.push_back(filename);
             }
-
-            input_files = std::move(collected_files);
         }
 
-        Strings tests_tags = options.count("tags") ? options["tags"].as<Strings>() : Strings({});
-        Strings skip_tags = options.count("skip-tags") ? options["skip-tags"].as<Strings>() : Strings({});
-        Strings tests_names = options.count("names") ? options["names"].as<Strings>() : Strings({});
-        Strings skip_names = options.count("skip-names") ? options["skip-names"].as<Strings>() : Strings({});
-        Strings tests_names_regexp = options.count("names-regexp") ? options["names-regexp"].as<Strings>() : Strings({});
-        Strings skip_names_regexp = options.count("skip-names-regexp") ? options["skip-names-regexp"].as<Strings>() : Strings({});
+        input_files = std::move(collected_files);
+    }
 
-        PerformanceTest performanceTest(options["host"].as<String>(),
-            options["port"].as<UInt16>(),
-            options["database"].as<String>(),
-            options["user"].as<String>(),
-            options["password"].as<String>(),
-            options.count("lite") > 0,
-            options["profiles-file"].as<String>(),
-            std::move(input_files),
-            std::move(tests_tags),
-            std::move(skip_tags),
-            std::move(tests_names),
-            std::move(skip_names),
-            std::move(tests_names_regexp),
-            std::move(skip_names_regexp));
-    }
-    catch (...)
-    {
-        std::cout << getCurrentExceptionMessage(/*with stacktrace = */ true) << std::endl;
-        return getCurrentExceptionCode();
-    }
+    Strings tests_tags = options.count("tags") ? options["tags"].as<Strings>() : Strings({});
+    Strings skip_tags = options.count("skip-tags") ? options["skip-tags"].as<Strings>() : Strings({});
+    Strings tests_names = options.count("names") ? options["names"].as<Strings>() : Strings({});
+    Strings skip_names = options.count("skip-names") ? options["skip-names"].as<Strings>() : Strings({});
+    Strings tests_names_regexp = options.count("names-regexp") ? options["names-regexp"].as<Strings>() : Strings({});
+    Strings skip_names_regexp = options.count("skip-names-regexp") ? options["skip-names-regexp"].as<Strings>() : Strings({});
+
+    DB::PerformanceTest performanceTest(options["host"].as<String>(),
+        options["port"].as<UInt16>(),
+        options["database"].as<String>(),
+        options["user"].as<String>(),
+        options["password"].as<String>(),
+        options.count("lite") > 0,
+        options["profiles-file"].as<String>(),
+        std::move(input_files),
+        std::move(tests_tags),
+        std::move(skip_tags),
+        std::move(tests_names),
+        std::move(skip_names),
+        std::move(tests_names_regexp),
+        std::move(skip_names_regexp));
 
     return 0;
 }
+catch (...)
+{
+    std::cout << DB::getCurrentExceptionMessage(/*with stacktrace = */ true) << std::endl;
+    int code = DB::getCurrentExceptionCode();
+    return code ? code : 1;
+}

From 5b952f0c55e71bf189143f27e59518f7b954ada7 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 6 Sep 2017 05:37:36 +0300
Subject: [PATCH 089/266] Fixed error in StringRange [#CLICKHOUSE-3281].

---
 dbms/src/Parsers/StringRange.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/dbms/src/Parsers/StringRange.h b/dbms/src/Parsers/StringRange.h
index fef8b547250..0c901bf5309 100644
--- a/dbms/src/Parsers/StringRange.h
+++ b/dbms/src/Parsers/StringRange.h
@@ -25,6 +25,7 @@ struct StringRange
         {
             first = token_begin->begin;
             second = token_begin->begin;
+            return;
         }
 
         TokenIterator token_last = token_end;

From ee469f7a98f86f28a14c7d7aec2fdb1af1276de3 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 6 Sep 2017 05:39:55 +0300
Subject: [PATCH 090/266] Fixed redundant code [#CLICKHOUSE-3281].

---
 dbms/src/Functions/FunctionsComparison.h | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/dbms/src/Functions/FunctionsComparison.h b/dbms/src/Functions/FunctionsComparison.h
index 7f7f0bdc72c..ab7cd27e84a 100644
--- a/dbms/src/Functions/FunctionsComparison.h
+++ b/dbms/src/Functions/FunctionsComparison.h
@@ -1062,9 +1062,6 @@ public:
             || (left_is_date_time && right_is_date_time)
             || (left_is_date_time && right_is_string)
             || (left_is_string && right_is_date_time)
-            || (left_is_date_time && right_is_date_time)
-            || (left_is_date_time && right_is_string)
-            || (left_is_string && right_is_date_time)
             || (left_is_uuid && right_is_uuid)
             || (left_is_uuid && right_is_string)
             || (left_is_string && right_is_uuid)

From 24ac5a68e19f8f849b4d0f1cb7a2217a04b976f1 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 6 Sep 2017 05:42:17 +0300
Subject: [PATCH 091/266] More uniform style [#CLICKHOUSE-3281].

---
 dbms/src/Common/formatIPv6.cpp       | 2 +-
 dbms/src/Functions/FunctionsCoding.h | 6 +++---
 dbms/src/Interpreters/DNSCache.cpp   | 2 +-
 dbms/src/Server/Server.cpp           | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/dbms/src/Common/formatIPv6.cpp b/dbms/src/Common/formatIPv6.cpp
index 8d1e9542cf7..80fa369cb6e 100644
--- a/dbms/src/Common/formatIPv6.cpp
+++ b/dbms/src/Common/formatIPv6.cpp
@@ -54,7 +54,7 @@ static void formatIPv4(const unsigned char * src, char *& dst, UInt8 zeroed_tail
 void formatIPv6(const unsigned char * src, char *& dst, UInt8 zeroed_tail_bytes_count)
 {
     struct { int base, len; } best{-1}, cur{-1};
-    std::array<uint16_t, IPV6_BINARY_LENGTH / sizeof(uint16_t)> words{};
+    std::array<UInt16, IPV6_BINARY_LENGTH / sizeof(UInt16)> words{};
 
     /** Preprocess:
         *    Copy the input (bytewise) array into a wordwise array.
diff --git a/dbms/src/Functions/FunctionsCoding.h b/dbms/src/Functions/FunctionsCoding.h
index 048b9b88d2d..b73a81e1e43 100644
--- a/dbms/src/Functions/FunctionsCoding.h
+++ b/dbms/src/Functions/FunctionsCoding.h
@@ -325,7 +325,7 @@ public:
         auto endp = tp + ipv6_bytes_length;
         auto curtok = src;
         auto saw_xdigit = false;
-        uint16_t val{};
+        UInt16 val{};
         unsigned char * colonp = nullptr;
 
         while (const auto ch = *src++)
@@ -355,7 +355,7 @@ public:
                     continue;
                 }
 
-                if (tp + sizeof(uint16_t) > endp)
+                if (tp + sizeof(UInt16) > endp)
                     return clear_dst();
 
                 *tp++ = static_cast<unsigned char>((val >> 8) & 0xffu);
@@ -380,7 +380,7 @@ public:
 
         if (saw_xdigit)
         {
-            if (tp + sizeof(uint16_t) > endp)
+            if (tp + sizeof(UInt16) > endp)
                 return clear_dst();
 
             *tp++ = static_cast<unsigned char>((val >> 8) & 0xffu);
diff --git a/dbms/src/Interpreters/DNSCache.cpp b/dbms/src/Interpreters/DNSCache.cpp
index d12007e908e..e4ea9e119da 100644
--- a/dbms/src/Interpreters/DNSCache.cpp
+++ b/dbms/src/Interpreters/DNSCache.cpp
@@ -59,7 +59,7 @@ static void splitHostAndPort(const std::string & host_and_port, std::string & ou
     {
         struct servent * se = getservbyname(port_str.c_str(), nullptr);
         if (se)
-            out_port = ntohs(static_cast<uint16_t>(se->s_port));
+            out_port = ntohs(static_cast<UInt16>(se->s_port));
         else
             throw Exception("Service not found", ErrorCodes::BAD_ARGUMENTS);
     }
diff --git a/dbms/src/Server/Server.cpp b/dbms/src/Server/Server.cpp
index 5130d612193..c41a408f726 100644
--- a/dbms/src/Server/Server.cpp
+++ b/dbms/src/Server/Server.cpp
@@ -321,7 +321,7 @@ int Server::main(const std::vector<std::string> & args)
             try_listen = true;
         }
 
-        auto make_socket_address = [&](const std::string & host, std::uint16_t port) {
+        auto make_socket_address = [&](const std::string & host, UInt16 port) {
             Poco::Net::SocketAddress socket_address;
             try
             {

From e03ca48d84c7fd875b40f503be1dafe115760252 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 6 Sep 2017 05:42:44 +0300
Subject: [PATCH 092/266] More uniform style [#CLICKHOUSE-3281].

---
 dbms/src/Server/Server.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/dbms/src/Server/Server.cpp b/dbms/src/Server/Server.cpp
index c41a408f726..8167f85e2f9 100644
--- a/dbms/src/Server/Server.cpp
+++ b/dbms/src/Server/Server.cpp
@@ -321,7 +321,8 @@ int Server::main(const std::vector<std::string> & args)
             try_listen = true;
         }
 
-        auto make_socket_address = [&](const std::string & host, UInt16 port) {
+        auto make_socket_address = [&](const std::string & host, UInt16 port)
+        {
             Poco::Net::SocketAddress socket_address;
             try
             {

From 60263d943e3979cd06fa1617975cbb44295b3cd8 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 6 Sep 2017 05:48:21 +0300
Subject: [PATCH 093/266] IPv6StringToNum: fixed missing overflow check
 [#CLICKHOUSE-3281].

---
 dbms/src/Functions/FunctionsCoding.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/dbms/src/Functions/FunctionsCoding.h b/dbms/src/Functions/FunctionsCoding.h
index b73a81e1e43..3158b8225cf 100644
--- a/dbms/src/Functions/FunctionsCoding.h
+++ b/dbms/src/Functions/FunctionsCoding.h
@@ -325,9 +325,10 @@ public:
         auto endp = tp + ipv6_bytes_length;
         auto curtok = src;
         auto saw_xdigit = false;
-        UInt16 val{};
+        UInt32 val{};
         unsigned char * colonp = nullptr;
 
+        /// Assuming zero-terminated string.
         while (const auto ch = *src++)
         {
             const auto num = unhex(ch);

From ff8940ddbe7ca1e82de71cefff6c32a0fab4eac4 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 6 Sep 2017 06:00:33 +0300
Subject: [PATCH 094/266] Fixed bad code [#CLICKHOUSE-3281].

---
 dbms/src/Common/formatIPv6.cpp       | 28 +++++++++++++++++++---------
 dbms/src/Functions/FunctionsCoding.h | 20 +++++++++++++-------
 2 files changed, 32 insertions(+), 16 deletions(-)

diff --git a/dbms/src/Common/formatIPv6.cpp b/dbms/src/Common/formatIPv6.cpp
index 80fa369cb6e..3401ea8378a 100644
--- a/dbms/src/Common/formatIPv6.cpp
+++ b/dbms/src/Common/formatIPv6.cpp
@@ -8,30 +8,40 @@ namespace DB
 {
 
 /// integer logarithm, return ceil(log(value, base)) (the smallest integer greater or equal  than log(value, base)
-static constexpr uint32_t int_log(const uint32_t value, const uint32_t base, const bool carry = false)
+static constexpr UInt32 intLog(const UInt32 value, const UInt32 base, const bool carry)
 {
-    return value >= base ? 1 + int_log(value / base, base, value % base || carry) : value % base > 1 || carry;
+    return value >= base ? 1 + intLog(value / base, base, value % base || carry) : value % base > 1 || carry;
 }
 
-/// print integer in desired base, faster than sprintf
-template <uint32_t base, typename T, uint32_t buffer_size = sizeof(T) * int_log(256, base, false)>
-static void print_integer(char *& out, T value)
+/// Print integer in desired base, faster than sprintf.
+/// NOTE This is not the best way. See https://github.com/miloyip/itoa-benchmark
+/// But it doesn't matter here.
+template <UInt32 base, typename T>
+static void printInteger(char *& out, T value)
 {
     if (value == 0)
         *out++ = '0';
     else
     {
+        constexpr size_t buffer_size = sizeof(T) * intLog(256, base, false);
+
         char buf[buffer_size];
         auto ptr = buf;
 
         while (value > 0)
         {
-            *ptr++ = hexDigitLowercase(value % base);
+            *ptr = hexDigitLowercase(value % base);
+            ++ptr;
             value /= base;
         }
 
+        /// Copy to out reversed.
         while (ptr != buf)
-            *out++ = *--ptr;
+        {
+            --ptr;
+            *out = *ptr;
+            ++out;
+        }
     }
 }
 
@@ -43,7 +53,7 @@ static void formatIPv4(const unsigned char * src, char *& dst, UInt8 zeroed_tail
     for (const auto i : ext::range(0, IPV4_BINARY_LENGTH))
     {
         UInt8 byte = (i < limit) ? src[i] : 0;
-        print_integer<10, UInt8>(dst, byte);
+        printInteger<10, UInt8>(dst, byte);
 
         if (i != IPV4_BINARY_LENGTH - 1)
             *dst++ = '.';
@@ -112,7 +122,7 @@ void formatIPv6(const unsigned char * src, char *& dst, UInt8 zeroed_tail_bytes_
             break;
         }
 
-        print_integer<16>(dst, words[i]);
+        printInteger<16>(dst, words[i]);
     }
 
     /// Was it a trailing run of 0x00's?
diff --git a/dbms/src/Functions/FunctionsCoding.h b/dbms/src/Functions/FunctionsCoding.h
index 3158b8225cf..eac1cdfbc82 100644
--- a/dbms/src/Functions/FunctionsCoding.h
+++ b/dbms/src/Functions/FunctionsCoding.h
@@ -472,24 +472,29 @@ public:
         char * begin = out;
 
         /// Write everything backwards.
-        for (size_t offset = 0; offset <= 24; offset += 8)
+        for (size_t octet = 0; octet < 4; ++octet)
         {
-            if (offset > 0)
-                *(out++) = '.';
+            if (octet > 0)
+            {
+                *out = '.';
+                ++out;
+            }
 
             /// Get the next byte.
-            UInt32 value = (ip >> offset) & static_cast<UInt32>(255);
+            UInt32 value = (ip >> (octet * 8)) & static_cast<UInt32>(0xFF);
 
             /// Faster than sprintf.
             if (value == 0)
             {
-                *(out++) = '0';
+                *out = '0';
+                ++out;
             }
             else
             {
                 while (value > 0)
                 {
-                    *(out++) = '0' + value % 10;
+                    *out = '0' + value % 10;
+                    ++out;
                     value /= 10;
                 }
             }
@@ -498,7 +503,8 @@ public:
         /// And reverse.
         std::reverse(begin, out);
 
-        *(out++) = '\0';
+        *out = '\0';
+        ++out;
     }
 
     bool useDefaultImplementationForConstants() const override { return true; }

From b370551e676ddfc8739e4f9190293ffeb14edb1b Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 6 Sep 2017 06:17:06 +0300
Subject: [PATCH 095/266] Fixed redundant code in IPv4NumToStringClassC
 function and removed copy-paste [#CLICKHOUSE-3281].

---
 dbms/src/Functions/FunctionsCoding.cpp |   8 +-
 dbms/src/Functions/FunctionsCoding.h   | 160 +++++++------------------
 2 files changed, 46 insertions(+), 122 deletions(-)

diff --git a/dbms/src/Functions/FunctionsCoding.cpp b/dbms/src/Functions/FunctionsCoding.cpp
index 7de54862438..adc660df78f 100644
--- a/dbms/src/Functions/FunctionsCoding.cpp
+++ b/dbms/src/Functions/FunctionsCoding.cpp
@@ -4,15 +4,19 @@
 namespace DB
 {
 
+struct NameFunctionIPv4NumToString { static constexpr auto name = "IPv4NumToString"; };
+struct NameFunctionIPv4NumToStringClassC { static constexpr auto name = "IPv4NumToStringClassC"; };
+
+
 void registerFunctionsCoding(FunctionFactory & factory)
 {
     factory.registerFunction<FunctionToStringCutToZero>();
     factory.registerFunction<FunctionIPv6NumToString>();
     factory.registerFunction<FunctionCutIPv6>();
     factory.registerFunction<FunctionIPv6StringToNum>();
-    factory.registerFunction<FunctionIPv4NumToString>();
+    factory.registerFunction<FunctionIPv4NumToString<0, NameFunctionIPv4NumToString>>();
+    factory.registerFunction<FunctionIPv4NumToString<1, NameFunctionIPv4NumToStringClassC>>();
     factory.registerFunction<FunctionIPv4StringToNum>();
-    factory.registerFunction<FunctionIPv4NumToStringClassC>();
     factory.registerFunction<FunctionIPv4ToIPv6>();
     factory.registerFunction<FunctionMACNumToString>();
     factory.registerFunction<FunctionMACStringTo<ParseMACImpl>>();
diff --git a/dbms/src/Functions/FunctionsCoding.h b/dbms/src/Functions/FunctionsCoding.h
index eac1cdfbc82..4429c639285 100644
--- a/dbms/src/Functions/FunctionsCoding.h
+++ b/dbms/src/Functions/FunctionsCoding.h
@@ -444,35 +444,30 @@ public:
 };
 
 
+/** If mask_tail_octets > 0, the last specified number of octets will be filled with "xxx".
+  */
+template <size_t mask_tail_octets, typename Name>
 class FunctionIPv4NumToString : public IFunction
 {
-public:
-    static constexpr auto name = "IPv4NumToString";
-    static FunctionPtr create(const Context & context) { return std::make_shared<FunctionIPv4NumToString>(); }
-
-    String getName() const override
-    {
-        return name;
-    }
-
-    size_t getNumberOfArguments() const override { return 1; }
-    bool isInjective(const Block &) override { return true; }
-
-    DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
-    {
-        if (!checkDataType<DataTypeUInt32>(&*arguments[0]))
-            throw Exception("Illegal type " + arguments[0]->getName() + " of argument of function " + getName() + ", expected UInt32",
-            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
-
-        return std::make_shared<DataTypeString>();
-    }
-
+private:
     static void formatIP(UInt32 ip, char *& out)
     {
         char * begin = out;
 
-        /// Write everything backwards.
-        for (size_t octet = 0; octet < 4; ++octet)
+        for (size_t octet = 0; octet < mask_tail_octets; ++octet)
+        {
+            if (octet > 0)
+            {
+                *out = '.';
+                ++out;
+            }
+
+            memcpy(out, "xxx", 3);  /// Strange choice, but meets the specification.
+            out += 3;
+        }
+
+        /// Write everything backwards. NOTE The loop is unrolled.
+        for (size_t octet = mask_tail_octets; octet < 4; ++octet)
         {
             if (octet > 0)
             {
@@ -483,7 +478,7 @@ public:
             /// Get the next byte.
             UInt32 value = (ip >> (octet * 8)) & static_cast<UInt32>(0xFF);
 
-            /// Faster than sprintf.
+            /// Faster than sprintf. NOTE Actually not good enough. LUT will be better.
             if (value == 0)
             {
                 *out = '0';
@@ -507,6 +502,27 @@ public:
         ++out;
     }
 
+public:
+    static constexpr auto name = Name::name;
+    static FunctionPtr create(const Context & context) { return std::make_shared<FunctionIPv4NumToString<mask_tail_octets, Name>>(); }
+
+    String getName() const override
+    {
+        return name;
+    }
+
+    size_t getNumberOfArguments() const override { return 1; }
+    bool isInjective(const Block &) override { return mask_tail_octets == 0; }
+
+    DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
+    {
+        if (!checkDataType<DataTypeUInt32>(&*arguments[0]))
+            throw Exception("Illegal type " + arguments[0]->getName() + " of argument of function " + getName() + ", expected UInt32",
+            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+
+        return std::make_shared<DataTypeString>();
+    }
+
     bool useDefaultImplementationForConstants() const override { return true; }
 
     void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override
@@ -621,102 +637,6 @@ public:
 };
 
 
-class FunctionIPv4NumToStringClassC : public IFunction
-{
-public:
-    static constexpr auto name = "IPv4NumToStringClassC";
-    static FunctionPtr create(const Context & context) { return std::make_shared<FunctionIPv4NumToStringClassC>(); }
-
-    String getName() const override
-    {
-        return name;
-    }
-
-    size_t getNumberOfArguments() const override { return 1; }
-
-    DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
-    {
-        if (!checkDataType<DataTypeUInt32>(&*arguments[0]))
-            throw Exception("Illegal type " + arguments[0]->getName() + " of argument of function " + getName() + ", expected UInt32",
-            ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
-
-        return std::make_shared<DataTypeString>();
-    }
-
-    static void formatIP(UInt32 ip, char *& out)
-    {
-        char * begin = out;
-
-        for (auto i = 0; i < 3; ++i)
-            *(out++) = 'x';
-
-        /// Write everything backwards.
-        for (size_t offset = 8; offset <= 24; offset += 8)
-        {
-            if (offset > 0)
-                *(out++) = '.';
-
-            /// Get the next byte.
-            UInt32 value = (ip >> offset) & static_cast<UInt32>(255);
-
-            /// Faster than sprintf.
-            if (value == 0)
-            {
-                *(out++) = '0';
-            }
-            else
-            {
-                while (value > 0)
-                {
-                    *(out++) = '0' + value % 10;
-                    value /= 10;
-                }
-            }
-        }
-
-        /// And reverse.
-        std::reverse(begin, out);
-
-        *(out++) = '\0';
-    }
-
-    bool useDefaultImplementationForConstants() const override { return true; }
-
-    void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override
-    {
-        const ColumnPtr & column = block.getByPosition(arguments[0]).column;
-
-        if (const ColumnUInt32 * col = typeid_cast<const ColumnUInt32 *>(column.get()))
-        {
-            const ColumnUInt32::Container_t & vec_in = col->getData();
-
-            std::shared_ptr<ColumnString> col_res = std::make_shared<ColumnString>();
-            block.getByPosition(result).column = col_res;
-
-            ColumnString::Chars_t & vec_res = col_res->getChars();
-            ColumnString::Offsets_t & offsets_res = col_res->getOffsets();
-
-            vec_res.resize(vec_in.size() * (IPV4_MAX_TEXT_LENGTH + 1)); /// the longest value is: 255.255.255.255\0
-            offsets_res.resize(vec_in.size());
-            char * begin = reinterpret_cast<char *>(&vec_res[0]);
-            char * pos = begin;
-
-            for (size_t i = 0; i < vec_in.size(); ++i)
-            {
-                formatIP(vec_in[i], pos);
-                offsets_res[i] = pos - begin;
-            }
-
-            vec_res.resize(pos - begin);
-        }
-        else
-            throw Exception("Illegal column " + block.getByPosition(arguments[0]).column->getName()
-            + " of argument of function " + getName(),
-            ErrorCodes::ILLEGAL_COLUMN);
-    }
-};
-
-
 class FunctionIPv4ToIPv6 : public IFunction
 {
 public:

From 7e460444741309b510321466f72815cc3069b1f6 Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Wed, 6 Sep 2017 18:19:03 +0300
Subject: [PATCH 096/266] Fix test 00501_http_head

---
 .../queries/0_stateless/00501_http_head.reference    | 12 ++++++++++++
 dbms/tests/queries/0_stateless/00501_http_head.sh    |  4 ++--
 2 files changed, 14 insertions(+), 2 deletions(-)

diff --git a/dbms/tests/queries/0_stateless/00501_http_head.reference b/dbms/tests/queries/0_stateless/00501_http_head.reference
index e69de29bb2d..8bbf4ff0b36 100644
--- a/dbms/tests/queries/0_stateless/00501_http_head.reference
+++ b/dbms/tests/queries/0_stateless/00501_http_head.reference
@@ -0,0 +1,12 @@
+< HTTP/1.1 200 OK
+< Connection: Keep-Alive
+< Content-Type: text/tab-separated-values; charset=UTF-8
+< Transfer-Encoding: chunked
+< Keep-Alive: timeout=3
+< 
+< HTTP/1.1 200 OK
+< Connection: Keep-Alive
+< Content-Type: text/tab-separated-values; charset=UTF-8
+< Transfer-Encoding: chunked
+< Keep-Alive: timeout=3
+< 
diff --git a/dbms/tests/queries/0_stateless/00501_http_head.sh b/dbms/tests/queries/0_stateless/00501_http_head.sh
index 4b99c841c45..79699041736 100755
--- a/dbms/tests/queries/0_stateless/00501_http_head.sh
+++ b/dbms/tests/queries/0_stateless/00501_http_head.sh
@@ -1,4 +1,4 @@
 #!/usr/bin/env bash
 
-curl -s --max-time 0.5 -X "HEAD" 'http://localhost:8123/?query=SELECT%201'
-curl -s --max-time 0.5 -X "HEAD" 'http://localhost:8123/?query=select+*+from+system.numbers+limit+1000000'
+( curl -v --max-time 0.3 -X "HEAD" 'http://localhost:18123/?query=SELECT%201';
+  curl -v --max-time 0.3 -X "HEAD" 'http://localhost:18123/?query=select+*+from+system.numbers+limit+1000000' ) 2>&1 | grep -e "^<" | grep -v "Date:"

From 16bd99493b9b3be49487ab3595892b82e79d2357 Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Wed, 6 Sep 2017 20:16:17 +0300
Subject: [PATCH 097/266] Reverse tests order

---
 dbms/tests/clickhouse-test | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbms/tests/clickhouse-test b/dbms/tests/clickhouse-test
index 4b188920d64..21d30bf1876 100755
--- a/dbms/tests/clickhouse-test
+++ b/dbms/tests/clickhouse-test
@@ -93,7 +93,7 @@ def main(args):
                 print("Won't run stateful tests because test data wasn't loaded. See README.txt.")
                 continue
 
-            for case in sorted(filter(lambda case: re.search(args.test, case) if args.test else True, os.listdir(suite_dir))):
+            for case in sorted(filter(lambda case: re.search(args.test, case) if args.test else True, os.listdir(suite_dir)), reverse=True):
                 if SERVER_DIED:
                     break
 

From 888214e33df6e933efacb6bd0c179b177092c07c Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Wed, 6 Sep 2017 21:39:04 +0300
Subject: [PATCH 098/266] Revert "Reverse tests order" - need smarter reverse

This reverts commit 16bd99493b9b3be49487ab3595892b82e79d2357.
---
 dbms/tests/clickhouse-test | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbms/tests/clickhouse-test b/dbms/tests/clickhouse-test
index 21d30bf1876..4b188920d64 100755
--- a/dbms/tests/clickhouse-test
+++ b/dbms/tests/clickhouse-test
@@ -93,7 +93,7 @@ def main(args):
                 print("Won't run stateful tests because test data wasn't loaded. See README.txt.")
                 continue
 
-            for case in sorted(filter(lambda case: re.search(args.test, case) if args.test else True, os.listdir(suite_dir)), reverse=True):
+            for case in sorted(filter(lambda case: re.search(args.test, case) if args.test else True, os.listdir(suite_dir))):
                 if SERVER_DIED:
                     break
 

From b538df661a007c3a795cbfa821e38fd25a6c3d3e Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Wed, 6 Sep 2017 22:07:22 +0300
Subject: [PATCH 099/266] Again fix test 00501_http_head

---
 .../0_stateless/00501_http_head.reference     | 24 +++++++++----------
 .../queries/0_stateless/00501_http_head.sh    |  4 ++--
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/dbms/tests/queries/0_stateless/00501_http_head.reference b/dbms/tests/queries/0_stateless/00501_http_head.reference
index 8bbf4ff0b36..9727c63b2d8 100644
--- a/dbms/tests/queries/0_stateless/00501_http_head.reference
+++ b/dbms/tests/queries/0_stateless/00501_http_head.reference
@@ -1,12 +1,12 @@
-< HTTP/1.1 200 OK
-< Connection: Keep-Alive
-< Content-Type: text/tab-separated-values; charset=UTF-8
-< Transfer-Encoding: chunked
-< Keep-Alive: timeout=3
-< 
-< HTTP/1.1 200 OK
-< Connection: Keep-Alive
-< Content-Type: text/tab-separated-values; charset=UTF-8
-< Transfer-Encoding: chunked
-< Keep-Alive: timeout=3
-< 
+HTTP/1.1 200 OK
+Connection: Keep-Alive
+Content-Type: text/tab-separated-values; charset=UTF-8
+Transfer-Encoding: chunked
+Keep-Alive: timeout=3
+
+HTTP/1.1 200 OK
+Connection: Keep-Alive
+Content-Type: text/tab-separated-values; charset=UTF-8
+Transfer-Encoding: chunked
+Keep-Alive: timeout=3
+
diff --git a/dbms/tests/queries/0_stateless/00501_http_head.sh b/dbms/tests/queries/0_stateless/00501_http_head.sh
index 79699041736..332b06dc944 100755
--- a/dbms/tests/queries/0_stateless/00501_http_head.sh
+++ b/dbms/tests/queries/0_stateless/00501_http_head.sh
@@ -1,4 +1,4 @@
 #!/usr/bin/env bash
 
-( curl -v --max-time 0.3 -X "HEAD" 'http://localhost:18123/?query=SELECT%201';
-  curl -v --max-time 0.3 -X "HEAD" 'http://localhost:18123/?query=select+*+from+system.numbers+limit+1000000' ) 2>&1 | grep -e "^<" | grep -v "Date:"
+( curl -s --head "${CLICKHOUSE_URL:=http://localhost:8123/}?query=SELECT%201";
+  curl -s --head "${CLICKHOUSE_URL:=http://localhost:8123/}?query=select+*+from+system.numbers+limit+1000000" ) | grep -v "Date:"

From 7c2327f3c8c8880696bf92b45429793f4cf04b11 Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Wed, 6 Sep 2017 21:40:49 +0300
Subject: [PATCH 100/266] LibraryDictionarySource: fix compile on macos and
 32bit

---
 dbms/src/Dictionaries/LibraryDictionarySource.cpp | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/dbms/src/Dictionaries/LibraryDictionarySource.cpp b/dbms/src/Dictionaries/LibraryDictionarySource.cpp
index 52559f98e69..e61f1c85384 100644
--- a/dbms/src/Dictionaries/LibraryDictionarySource.cpp
+++ b/dbms/src/Dictionaries/LibraryDictionarySource.cpp
@@ -120,7 +120,7 @@ BlockInputStreamPtr LibraryDictionarySource::loadAll()
 
     auto columns_holder = std::make_unique<ClickHouseLibrary::CString[]>(dict_struct.attributes.size());
     ClickHouseLibrary::CStrings columns{
-        reinterpret_cast<decltype(ClickHouseLibrary::CStrings::data)>(columns_holder.get()), dict_struct.attributes.size()};
+        static_cast<decltype(ClickHouseLibrary::CStrings::data)>(columns_holder.get()), dict_struct.attributes.size()};
     size_t i = 0;
     for (auto & a : dict_struct.attributes)
     {
@@ -147,7 +147,7 @@ BlockInputStreamPtr LibraryDictionarySource::loadIds(const std::vector<UInt64> &
     const ClickHouseLibrary::VectorUInt64 ids_data{ids.data(), ids.size()};
     auto columns_holder = std::make_unique<ClickHouseLibrary::CString[]>(dict_struct.attributes.size());
     ClickHouseLibrary::CStrings columns_pass{
-        reinterpret_cast<decltype(ClickHouseLibrary::CStrings::data)>(columns_holder.get()), dict_struct.attributes.size()};
+        static_cast<decltype(ClickHouseLibrary::CStrings::data)>(columns_holder.get()), dict_struct.attributes.size()};
     size_t i = 0;
     for (auto & a : dict_struct.attributes)
     {
@@ -183,14 +183,14 @@ BlockInputStreamPtr LibraryDictionarySource::loadKeys(const Columns & key_column
 */
     auto columns_holder = std::make_unique<ClickHouseLibrary::CString[]>(key_columns.size());
     ClickHouseLibrary::CStrings columns_pass{
-        reinterpret_cast<decltype(ClickHouseLibrary::CStrings::data)>(columns_holder.get()), key_columns.size()};
+        static_cast<decltype(ClickHouseLibrary::CStrings::data)>(columns_holder.get()), key_columns.size()};
     size_t key_columns_n = 0;
     for (auto & column : key_columns)
     {
         columns_pass.data[key_columns_n] = column->getName().c_str();
         ++key_columns_n;
     }
-    const ClickHouseLibrary::VectorUInt64 requested_rows_c{requested_rows.data(), requested_rows.size()};
+    const ClickHouseLibrary::VectorUInt64 requested_rows_c{static_cast<decltype(ClickHouseLibrary::VectorUInt64::data)>(requested_rows.data()), requested_rows.size()};
     void * data_ptr = nullptr;
 
     /// Get function pointer before dataAllocate call because library->get may throw.

From 7142e43be6b4d42d791eb2c0c9c65c4b9b960c88 Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Wed, 6 Sep 2017 22:21:52 +0300
Subject: [PATCH 101/266] Fix compile 32bit

---
 dbms/src/Dictionaries/LibraryDictionarySource.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbms/src/Dictionaries/LibraryDictionarySource.cpp b/dbms/src/Dictionaries/LibraryDictionarySource.cpp
index e61f1c85384..d571a71fae8 100644
--- a/dbms/src/Dictionaries/LibraryDictionarySource.cpp
+++ b/dbms/src/Dictionaries/LibraryDictionarySource.cpp
@@ -190,7 +190,7 @@ BlockInputStreamPtr LibraryDictionarySource::loadKeys(const Columns & key_column
         columns_pass.data[key_columns_n] = column->getName().c_str();
         ++key_columns_n;
     }
-    const ClickHouseLibrary::VectorUInt64 requested_rows_c{static_cast<decltype(ClickHouseLibrary::VectorUInt64::data)>(requested_rows.data()), requested_rows.size()};
+    const ClickHouseLibrary::VectorUInt64 requested_rows_c{reinterpret_cast<decltype(ClickHouseLibrary::VectorUInt64::data)>(requested_rows.data()), requested_rows.size()};
     void * data_ptr = nullptr;
 
     /// Get function pointer before dataAllocate call because library->get may throw.

From 3022d0b8a0177164fb2a410c7b70d996be1c7e85 Mon Sep 17 00:00:00 2001
From: Ivan Blinkov <ivan@blinkov.ru>
Date: Wed, 6 Sep 2017 22:28:19 +0300
Subject: [PATCH 102/266] YQL-3278: add some links to ClickHouse Meetup in
 Berlin on October 5, 2017 (#1199)

* update presentations

* CLICKHOUSE-2936: redirect from clickhouse.yandex.ru and clickhouse.yandex.com

* update submodule

* lost files

* CLICKHOUSE-2981: prefer sphinx docs over original reference

* CLICKHOUSE-2981: docs styles more similar to main website + add flags to switch language links

* update presentations

* Less confusing directory structure (docs -> doc/reference/)

* Minify sphinx docs too

* Website release script: fail fast + pass docker hash on deploy

* Do not underline links in docs

* shorter

* cleanup docker images

* tune nginx config

* CLICKHOUSE-3043: get rid of habrastorage links

* Lost translation

* CLICKHOUSE-2936: temporary client-side redirect

* behaves weird in test

* put redirect back

* CLICKHOUSE-3047: copy docs txts to public too

* move to proper file

* remove old pages to avoid confusion

* Remove reference redirect warning for now

* Refresh README.md

* Yellow buttons in docs

* Use svg flags instead of unicode ones in docs

* fix test website instance

* Put flags to separate files

* wrong flag

* Copy Yandex.Metrica introduction from main page to docs

* Yet another home page structure change, couple new blocks (CLICKHOUSE-3045)

* Update Contacts section

* CLICKHOUSE-2849: more detailed legal information

* CLICKHOUSE-2978 preparation - split by files

* More changes in Contacts block

* Tune texts on index page

* update presentations

* One more benchmark

* Add usage sections to index page, adapted from slides

* Get the roadmap started, based on slides from last ClickHouse Meetup

* CLICKHOUSE-2977: some rendering tuning

* Get rid of excessive section in the end of getting started

* Make headers linkable

* CLICKHOUSE-2981: links to editing reference - https://github.com/yandex/ClickHouse/issues/849

* CLICKHOUSE-2981: fix mobile styles in docs

* Ban crawling of duplicating docs

* Open some external links in new tab

* Ban old docs too

* Lots of trivial fixes in english docs

* Lots of trivial fixes in russian docs

* Remove getting started copies in markdown

* Add Yandex.Webmaster

* Fix some sphinx warnings

* More warnings fixed in english docs

* More sphinx warnings fixed

* Add code-block:: text

* More code-block:: text

* These headers look not that well

* Better switch between documentation languages

* merge use_case.rst into ya_metrika_task.rst

* Edit the agg_functions.rst texts

* Add lost empty lines

* Lost blank lines

* Add new logo sizes

* update presentations

* Next step in migrating to new documentation

* Fix all warnings in en reference

* Fix all warnings in ru reference

* Re-arrange existing reference

* Move operation tips to main reference

* Fix typos noticed by milovidov@

* Get rid of zookeeper.md

* Looks like duplicate of tutorial.html

* Fix some mess with html tags in tutorial

* No idea why nobody noticed this before, but it was completely not clear whet to get the data

* Match code block styling between main and tutorial pages (in favor of the latter)

* Get rid of some copypaste in tutorial

* Normalize header styles

* Move example_datasets to sphinx

* Move presentations submodule to website

* Move and update README.md

* No point in duplicating articles from habrahabr here

* Move development-related docs as is for now

* doc/reference/ -> docs/ (to match the URL on website)

* Adapt links to match the previous commit

* Adapt development docs to rst (still lacks translation and strikethrough support)

* clean on release

* blacklist presentations in gulp

* strikethrough support in sphinx

* just copy development folder for now

* fix weird introduction in style article

* Style guide translation (WIP)

* Finish style guide translation to English

* gulp clean separately

* Update year in LICENSE

* Initial CONTRIBUTING.md

* Fix remaining links to old docs in tutorial

* Some tutorial fixes

* Typo

* Another typo

* Update list of authors from yandex-team accoding to git log

* Fix diff with master

* couple fixes in en what_is_clickhouse.rst

* Try different link to blog in Russian

* Swap words

* Slightly larger line height

* CLICKHOUSE-3089: disable hyphenation in docs

* update presentations

* Fix copying of txt files

* update submodule

* CLICKHOUSE-3108: fix overflow issues in mobile version

* Less weird tutorial header in mobile version

* CLICKHOUSE-3073: skip sourcemaps by default

* CLICKHOUSE-3067: rename item in docs navigation

* fix list markup

* CLICKHOUSE-3067: some documentation style tuning

* CLICKHOUSE-3067: less laggy single page documentation

* update presentations

* YQL-3278: add some links to ClickHouse Meetup in Berlin on October 5, 2017
---
 docs/en/conf.py    |  1 +
 website/index.css  | 17 +++++++++++++++--
 website/index.html |  5 +++++
 3 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/docs/en/conf.py b/docs/en/conf.py
index c58139ce779..b35129346ce 100644
--- a/docs/en/conf.py
+++ b/docs/en/conf.py
@@ -125,6 +125,7 @@ html_theme_options = {
     'link': '#08f',
     'link_hover': 'red',
     'extra_nav_links': collections.OrderedDict([
+        ('ClickHouse Meetup Berlin', 'https://events.yandex.com/events/meetings/05-10-2017/'),
         ('Switch to Russian <img id="svg-flag" src="/docs/en/_static/ru.svg" width="20" height="12" />', '#ru'),
         ('Single page documentation', '/docs/en/single/'),
         ('Website home', '/'),
diff --git a/website/index.css b/website/index.css
index bd419701f44..3f72e172b83 100644
--- a/website/index.css
+++ b/website/index.css
@@ -209,9 +209,22 @@ a:hover, a:active {
     margin-top: 0;
 }
 
-#performance {
+#performance, #announcement {
     background: #fc0;
 }
+#announcement {
+    margin: 0 0 60px 0;
+    padding: 20px 0;
+}
+#announcement-link {
+    color: #000;
+    text-decoration: underline;
+    font: 400 200%/133% 'Yandex Sans Display Web',Arial,sans-serif;
+    margin: 1em 0;
+}
+#announcement-link:hover {
+    color: #000;
+}
 
 #call_to_action, #benchmark_learn_more {
     text-decoration: none;
@@ -402,7 +415,7 @@ img {
     }
 
     #hero {
-        padding: 40px 0 10px 0;
+        padding: 40px 0 0 0;
     }
 
     .desktop-only {
diff --git a/website/index.html b/website/index.html
index b0c8e052ed4..ca5364f0802 100644
--- a/website/index.html
+++ b/website/index.html
@@ -90,6 +90,11 @@
         <div class="clear"></div>
     </div>
 </div>
+<div id="announcement" class="colored-block">
+    <div class="page">
+        <a id="announcement-link" href="https://events.yandex.com/events/meetings/05-10-2017/" target="_blank">ClickHouse Meetup in Berlin on October 5, 2017</a>
+    </div>
+</div>
 
 <div class="page">
     <h2 id="slogan">ClickHouse. Just makes you think faster.</h2>

From e3e506d4495488daaf0108a5c7511307bba85281 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 6 Sep 2017 23:01:44 +0300
Subject: [PATCH 103/266] Fixed with_mergeable_state option for
 clickhouse-benchmark [#CLICKHOUSE-3282].

---
 dbms/src/Server/Benchmark.cpp | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/dbms/src/Server/Benchmark.cpp b/dbms/src/Server/Benchmark.cpp
index 986a2efac09..f3bd262ad6f 100644
--- a/dbms/src/Server/Benchmark.cpp
+++ b/dbms/src/Server/Benchmark.cpp
@@ -15,6 +15,7 @@
 #include <Common/Stopwatch.h>
 #include <common/ThreadPool.h>
 #include <AggregateFunctions/ReservoirSampler.h>
+#include <AggregateFunctions/registerAggregateFunctions.h>
 
 #include <boost/program_options.hpp>
 
@@ -71,6 +72,10 @@ public:
     {
         std::cerr << std::fixed << std::setprecision(3);
 
+        /// This is needed to receive blocks with columns of AggregateFunction data type
+        /// (example: when using stage = 'with_mergeable_state')
+        registerAggregateFunctions();
+
         if (stage == "complete")
             query_processing_stage = QueryProcessingStage::Complete;
         else if (stage == "fetch_columns")

From 76957f77c46a9a522f9e25fbaf9681c1daf39afe Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 6 Sep 2017 23:02:11 +0300
Subject: [PATCH 104/266] Removed strange empty space [#CLICKHOUSE-2].

---
 libs/libdaemon/src/BaseDaemon.cpp | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/libs/libdaemon/src/BaseDaemon.cpp b/libs/libdaemon/src/BaseDaemon.cpp
index 434545b89cc..56bb0826479 100644
--- a/libs/libdaemon/src/BaseDaemon.cpp
+++ b/libs/libdaemon/src/BaseDaemon.cpp
@@ -328,11 +328,6 @@ private:
         static const int max_frames = 50;
         void * frames[max_frames];
 
-
-
-
-
-
 #if USE_UNWIND
         int frames_size = backtraceLibUnwind(frames, max_frames, context);
 

From ea19c4494f1279fabc6575e9c77c37b4ad0a10bc Mon Sep 17 00:00:00 2001
From: proller <proller@users.noreply.github.com>
Date: Wed, 6 Sep 2017 23:13:21 +0300
Subject: [PATCH 105/266] Better test reverse (#1207)

* Again fix test 00501_http_head

* Better test reverse

* Fix test reverse sort

* Update clickhouse-test
---
 dbms/tests/clickhouse-test | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/dbms/tests/clickhouse-test b/dbms/tests/clickhouse-test
index 4b188920d64..58304f1768e 100755
--- a/dbms/tests/clickhouse-test
+++ b/dbms/tests/clickhouse-test
@@ -93,7 +93,12 @@ def main(args):
                 print("Won't run stateful tests because test data wasn't loaded. See README.txt.")
                 continue
 
-            for case in sorted(filter(lambda case: re.search(args.test, case) if args.test else True, os.listdir(suite_dir))):
+            # Reverse sort order: we want run newest test first.
+            # And not reverse subtests
+            def key_func(item):
+                prefix, suffix = item.split('_', 1)
+                return -int(prefix), suffix
+            for case in sorted(filter(lambda case: re.search(args.test, case) if args.test else True, os.listdir(suite_dir)), key=key_func):
                 if SERVER_DIED:
                     break
 

From 9c37dfd75f40e74a56c87beeec2d705355a6168f Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 6 Sep 2017 23:24:40 +0300
Subject: [PATCH 106/266] Fixed common source of errors while deploying newer
 version of ClickHouse [#CLICKHOUSE-3282].

---
 dbms/src/Interpreters/Compiler.cpp | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/dbms/src/Interpreters/Compiler.cpp b/dbms/src/Interpreters/Compiler.cpp
index 7dc37a92a2f..e798c8add55 100644
--- a/dbms/src/Interpreters/Compiler.cpp
+++ b/dbms/src/Interpreters/Compiler.cpp
@@ -181,6 +181,17 @@ SharedLibraryPtr Compiler::getOrCount(
 }
 
 
+/// This will guarantee that code will compile only when version of headers match version of running server.
+static void addCodeToAssertHeadersMatch(WriteBuffer & out)
+{
+    out <<
+        "#include <Common/config_version.h>\n"
+        "#if VERSION_REVISION != " << ClickHouseRevision::get() << "\n"
+        "#error \"ClickHouse headers revision doesn't match runtime revision of the server.\"\n"
+        "#endif\n\n";
+}
+
+
 void Compiler::compile(
     HashedKey hashed_key,
     std::string file_name,
@@ -197,6 +208,8 @@ void Compiler::compile(
 
     {
         WriteBufferFromFile out(cpp_file_path);
+
+        addCodeToAssertHeadersMatch(out);
         out << get_code();
     }
 

From 0d11c735fb13f5526d3f5d902380a3e26e4ee475 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 6 Sep 2017 23:47:08 +0300
Subject: [PATCH 107/266] Addition to prev. revision [#CLICKHOUSE-3282].

---
 copy_headers.sh | 1 +
 1 file changed, 1 insertion(+)

diff --git a/copy_headers.sh b/copy_headers.sh
index 1254c397bfe..7b0202889f4 100755
--- a/copy_headers.sh
+++ b/copy_headers.sh
@@ -28,6 +28,7 @@ fi
 
 for src_file in $($CLANG -M -xc++ -std=gnu++1z -Wall -Werror -msse4 -mcx16 -mpopcnt -O3 -g -fPIC \
     $(cat "$SOURCE_PATH/build/include_directories.txt") \
+    "$SOURCE_PATH/build/dbms/src/Common/config_version.h" \
     "$SOURCE_PATH/dbms/src/Interpreters/SpecializedAggregator.h" |
     tr -d '\\' |
     sed -r -e 's/^\w+\.o://');

From b5f94b67381ceea3f920fcc35ea5f38090c47b7a Mon Sep 17 00:00:00 2001
From: robot-metrika-test <robot-metrika-test@yandex-team.ru>
Date: Wed, 6 Sep 2017 23:49:16 +0300
Subject: [PATCH 108/266] Auto version update to [54287]

---
 dbms/cmake/version.cmake | 4 ++--
 debian/changelog         | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/dbms/cmake/version.cmake b/dbms/cmake/version.cmake
index cd9a7744327..41e08de697d 100644
--- a/dbms/cmake/version.cmake
+++ b/dbms/cmake/version.cmake
@@ -1,6 +1,6 @@
 # This strings autochanged from release_lib.sh:
-set(VERSION_DESCRIBE v1.1.54286-testing)
-set(VERSION_REVISION 54286)
+set(VERSION_DESCRIBE v1.1.54287-testing)
+set(VERSION_REVISION 54287)
 # end of autochange
 
 set (VERSION_MAJOR 1)
diff --git a/debian/changelog b/debian/changelog
index 5df6d6edaac..2d309002fe3 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,5 +1,5 @@
-clickhouse (1.1.54286) unstable; urgency=low
+clickhouse (1.1.54287) unstable; urgency=low
 
   * Modified source code
 
- --  <robot-metrika-test@yandex-team.ru>  Tue, 05 Sep 2017 00:37:29 +0300
+ --  <robot-metrika-test@yandex-team.ru>  Wed, 06 Sep 2017 23:49:16 +0300

From be4deb79793a5d4e18dd8e8dabae1bfa509fb500 Mon Sep 17 00:00:00 2001
From: proller <proller@users.noreply.github.com>
Date: Thu, 7 Sep 2017 00:04:23 +0300
Subject: [PATCH 109/266] Fix test order (#1209)

* Again fix test 00501_http_head

* Better test reverse

* Fix test reverse sort

* Update clickhouse-test
---
 ...reference => 00028_shard_big_non_agg_aj_distributed.reference} | 0
 ...distributed.sql => 00028_shard_big_non_agg_aj_distributed.sql} | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename dbms/tests/queries/0_stateless/{00029_shard_big_non_agg_aj_distributed.reference => 00028_shard_big_non_agg_aj_distributed.reference} (100%)
 rename dbms/tests/queries/0_stateless/{00029_shard_big_non_agg_aj_distributed.sql => 00028_shard_big_non_agg_aj_distributed.sql} (100%)

diff --git a/dbms/tests/queries/0_stateless/00029_shard_big_non_agg_aj_distributed.reference b/dbms/tests/queries/0_stateless/00028_shard_big_non_agg_aj_distributed.reference
similarity index 100%
rename from dbms/tests/queries/0_stateless/00029_shard_big_non_agg_aj_distributed.reference
rename to dbms/tests/queries/0_stateless/00028_shard_big_non_agg_aj_distributed.reference
diff --git a/dbms/tests/queries/0_stateless/00029_shard_big_non_agg_aj_distributed.sql b/dbms/tests/queries/0_stateless/00028_shard_big_non_agg_aj_distributed.sql
similarity index 100%
rename from dbms/tests/queries/0_stateless/00029_shard_big_non_agg_aj_distributed.sql
rename to dbms/tests/queries/0_stateless/00028_shard_big_non_agg_aj_distributed.sql

From 90f1d8689bfa4003bc4604e8c7d9760a74e0336b Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Thu, 7 Sep 2017 00:42:20 +0300
Subject: [PATCH 110/266] Addition to prev. revision [#CLICKHOUSE-3282].

---
 copy_headers.sh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/copy_headers.sh b/copy_headers.sh
index 7b0202889f4..25787566e32 100755
--- a/copy_headers.sh
+++ b/copy_headers.sh
@@ -34,7 +34,7 @@ for src_file in $($CLANG -M -xc++ -std=gnu++1z -Wall -Werror -msse4 -mcx16 -mpop
     sed -r -e 's/^\w+\.o://');
 do
     dst_file=$src_file;
-    mkdir -p "$DST/$(echo $dst_file | sed -r -e 's/\/[^/]*$/\//')";
+    mkdir -p "$DST/$(echo $dst_file | sed -r -e 's/build\///; s/\/[^/]*$/\//;')";
     cp "$src_file" "$DST/$dst_file";
 done
 

From d422777d9cf9a51908d10db11d05f961334b7294 Mon Sep 17 00:00:00 2001
From: proller <proller@users.noreply.github.com>
Date: Thu, 7 Sep 2017 03:12:39 +0300
Subject: [PATCH 111/266] ShellCommand: automatic wait call in destructor
 (#1210)

* ShellCommand: automatic wait call in destructor

* ShellCommand: tryWait in destructor

* Update ShellCommand.cpp

* Update ShellCommand.cpp
---
 dbms/src/Common/ShellCommand.cpp             | 11 +++++++++--
 dbms/src/Common/ShellCommand.h               |  3 +++
 dbms/src/Common/tests/shell_command_test.cpp | 11 +++++++++++
 3 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/dbms/src/Common/ShellCommand.cpp b/dbms/src/Common/ShellCommand.cpp
index a4c16ee5c48..00010799aee 100644
--- a/dbms/src/Common/ShellCommand.cpp
+++ b/dbms/src/Common/ShellCommand.cpp
@@ -66,8 +66,8 @@ namespace
     enum class ReturnCodes : int
     {
         CANNOT_DUP_STDIN    = 42,   /// The value is not important, but it is chosen so that it's rare to conflict with the program return code.
-        CANNOT_DUP_STDOUT     = 43,
-        CANNOT_DUP_STDERR     = 44,
+        CANNOT_DUP_STDOUT   = 43,
+        CANNOT_DUP_STDERR   = 44,
         CANNOT_EXEC         = 45,
     };
 }
@@ -76,6 +76,11 @@ namespace
 namespace DB
 {
 
+ShellCommand::~ShellCommand()
+{
+    if (!wait_called)
+        tryWait();
+}
 
 std::unique_ptr<ShellCommand> ShellCommand::executeImpl(const char * filename, char * const argv[], bool pipe_stdin_only)
 {
@@ -176,6 +181,8 @@ std::unique_ptr<ShellCommand> ShellCommand::executeDirect(const std::string & pa
 
 int ShellCommand::tryWait()
 {
+    wait_called = true;
+
     int status = 0;
     if (-1 == waitpid(pid, &status, 0))
         throwFromErrno("Cannot waitpid", ErrorCodes::CANNOT_WAITPID);
diff --git a/dbms/src/Common/ShellCommand.h b/dbms/src/Common/ShellCommand.h
index a558216fcbf..8df7de1de35 100644
--- a/dbms/src/Common/ShellCommand.h
+++ b/dbms/src/Common/ShellCommand.h
@@ -27,6 +27,7 @@ class ShellCommand
 {
 private:
     pid_t pid;
+    bool wait_called = false;
 
     ShellCommand(pid_t pid, int in_fd, int out_fd, int err_fd)
         : pid(pid), in(in_fd), out(out_fd), err(err_fd) {};
@@ -38,6 +39,8 @@ public:
     ReadBufferFromFile out;
     ReadBufferFromFile err;
 
+    ~ShellCommand();
+
     /// Run the command using /bin/sh -c
     static std::unique_ptr<ShellCommand> execute(const std::string & command, bool pipe_stdin_only = false);
 
diff --git a/dbms/src/Common/tests/shell_command_test.cpp b/dbms/src/Common/tests/shell_command_test.cpp
index 564567373c8..81fadfd4a51 100644
--- a/dbms/src/Common/tests/shell_command_test.cpp
+++ b/dbms/src/Common/tests/shell_command_test.cpp
@@ -5,6 +5,8 @@
 #include <IO/WriteBufferFromFileDescriptor.h>
 #include <IO/ReadBufferFromString.h>
 
+#include <chrono>
+#include <thread>
 
 using namespace DB;
 
@@ -43,6 +45,15 @@ try
 
         command->wait();
     }
+
+    // <defunct> hunting:
+    for (int i = 0; i < 1000; ++i) {
+        auto command = ShellCommand::execute("echo " + std::to_string(i));
+        //command->wait(); // now automatic
+    }
+
+    // std::cerr << "inspect me: ps auxwwf" << "\n";
+    // std::this_thread::sleep_for(std::chrono::seconds(100));
 }
 catch (...)
 {

From 89933328f1899443ceb43f97f1d985e0c1630e30 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Thu, 7 Sep 2017 05:33:59 +0300
Subject: [PATCH 112/266] Fixed build [#CLICKHOUSE-3284].

---
 copy_headers.sh | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/copy_headers.sh b/copy_headers.sh
index 25787566e32..69a1d366180 100755
--- a/copy_headers.sh
+++ b/copy_headers.sh
@@ -34,7 +34,8 @@ for src_file in $($CLANG -M -xc++ -std=gnu++1z -Wall -Werror -msse4 -mcx16 -mpop
     sed -r -e 's/^\w+\.o://');
 do
     dst_file=$src_file;
-    mkdir -p "$DST/$(echo $dst_file | sed -r -e 's/build\///; s/\/[^/]*$/\//;')";
+    dst_file=$(echo $dst_file | sed -r -e 's/build\///')    # for simplicity reasons, will put generated headers near the rest.
+    mkdir -p "$DST/$(echo $dst_file | sed -r -e 's/\/[^/]*$/\//')";
     cp "$src_file" "$DST/$dst_file";
 done
 

From 17edcdec96b01d988e749f44c4be0194f8546aee Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Thu, 7 Sep 2017 06:33:53 +0300
Subject: [PATCH 113/266] Updated zstd to version 1.3.1, properly
 [#CLICKHOUSE-3277].

---
 .../libzstd/include/zstd/common/bitstream.h   |  81 ++-
 .../include/zstd/common/error_private.c       |  18 +-
 .../include/zstd/common/error_private.h       |   8 +-
 contrib/libzstd/include/zstd/common/fse.h     |  16 +-
 .../include/zstd/common/fse_decompress.c      |  25 +-
 contrib/libzstd/include/zstd/common/huf.h     |  11 +-
 contrib/libzstd/include/zstd/common/mem.h     |  12 +-
 contrib/libzstd/include/zstd/common/pool.c    |  88 ++-
 contrib/libzstd/include/zstd/common/pool.h    |  20 +-
 .../libzstd/include/zstd/common/threading.h   |  11 +-
 contrib/libzstd/include/zstd/common/xxhash.c  |  50 +-
 .../libzstd/include/zstd/common/zstd_common.c |   8 +-
 .../libzstd/include/zstd/common/zstd_errors.h |  62 +-
 .../include/zstd/common/zstd_internal.h       | 113 ++--
 .../include/zstd/compress/fse_compress.c      |  26 +-
 .../include/zstd/compress/huf_compress.c      |   7 +-
 .../include/zstd/compress/zstd_compress.c     | 622 +++++++++---------
 .../libzstd/include/zstd/compress/zstd_opt.h  | 234 +++----
 .../include/zstd/compress/zstdmt_compress.c   | 377 ++++++-----
 .../include/zstd/compress/zstdmt_compress.h   |  19 +-
 .../include/zstd/decompress/huf_decompress.c  |  32 +-
 .../include/zstd/decompress/zstd_decompress.c | 210 +++---
 .../libzstd/include/zstd/deprecated/zbuff.h   |   8 +-
 .../include/zstd/deprecated/zbuff_common.c    |   9 +-
 .../include/zstd/deprecated/zbuff_compress.c  |   8 +-
 .../zstd/deprecated/zbuff_decompress.c        |   8 +-
 .../libzstd/include/zstd/dictBuilder/cover.c  |  16 +-
 .../libzstd/include/zstd/dictBuilder/zdict.c  |  10 +-
 .../libzstd/include/zstd/dictBuilder/zdict.h  |   8 +-
 .../libzstd/include/zstd/legacy/zstd_legacy.h |  12 +-
 .../libzstd/include/zstd/legacy/zstd_v01.c    |   8 +-
 .../libzstd/include/zstd/legacy/zstd_v01.h    |   8 +-
 .../libzstd/include/zstd/legacy/zstd_v02.c    |   8 +-
 .../libzstd/include/zstd/legacy/zstd_v02.h    |   8 +-
 .../libzstd/include/zstd/legacy/zstd_v03.c    |   8 +-
 .../libzstd/include/zstd/legacy/zstd_v03.h    |   8 +-
 .../libzstd/include/zstd/legacy/zstd_v04.c    |  10 +-
 .../libzstd/include/zstd/legacy/zstd_v04.h    |   8 +-
 .../libzstd/include/zstd/legacy/zstd_v05.c    |  10 +-
 .../libzstd/include/zstd/legacy/zstd_v05.h    |   8 +-
 .../libzstd/include/zstd/legacy/zstd_v06.c    |  10 +-
 .../libzstd/include/zstd/legacy/zstd_v06.h    |   8 +-
 .../libzstd/include/zstd/legacy/zstd_v07.c    |   8 +-
 .../libzstd/include/zstd/legacy/zstd_v07.h    |   8 +-
 contrib/libzstd/include/zstd/zstd.h           |  30 +-
 45 files changed, 1164 insertions(+), 1113 deletions(-)

diff --git a/contrib/libzstd/include/zstd/common/bitstream.h b/contrib/libzstd/include/zstd/common/bitstream.h
index 07b85026c95..06121f21c5b 100644
--- a/contrib/libzstd/include/zstd/common/bitstream.h
+++ b/contrib/libzstd/include/zstd/common/bitstream.h
@@ -80,9 +80,9 @@ extern "C" {
 *  bitStream encoding API (write forward)
 ********************************************/
 /* bitStream can mix input from multiple sources.
-*  A critical property of these streams is that they encode and decode in **reverse** direction.
-*  So the first bit sequence you add will be the last to be read, like a LIFO stack.
-*/
+ * A critical property of these streams is that they encode and decode in **reverse** direction.
+ * So the first bit sequence you add will be the last to be read, like a LIFO stack.
+ */
 typedef struct
 {
     size_t bitContainer;
@@ -203,7 +203,7 @@ static const unsigned BIT_mask[] = { 0, 1, 3, 7, 0xF, 0x1F, 0x3F, 0x7F,
 /*! BIT_initCStream() :
  *  `dstCapacity` must be > sizeof(size_t)
  *  @return : 0 if success,
-              otherwise an error code (can be tested using ERR_isError() ) */
+ *            otherwise an error code (can be tested using ERR_isError()) */
 MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC,
                                   void* startPtr, size_t dstCapacity)
 {
@@ -217,8 +217,8 @@ MEM_STATIC size_t BIT_initCStream(BIT_CStream_t* bitC,
 }
 
 /*! BIT_addBits() :
-    can add up to 26 bits into `bitC`.
-    Does not check for register overflow ! */
+ *  can add up to 26 bits into `bitC`.
+ *  Note : does not check for register overflow ! */
 MEM_STATIC void BIT_addBits(BIT_CStream_t* bitC,
                             size_t value, unsigned nbBits)
 {
@@ -268,7 +268,7 @@ MEM_STATIC void BIT_flushBits(BIT_CStream_t* bitC)
 
 /*! BIT_closeCStream() :
  *  @return : size of CStream, in bytes,
-              or 0 if it could not fit into dstBuffer */
+ *            or 0 if it could not fit into dstBuffer */
 MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC)
 {
     BIT_addBitsFast(bitC, 1, 1);   /* endMark */
@@ -279,14 +279,14 @@ MEM_STATIC size_t BIT_closeCStream(BIT_CStream_t* bitC)
 
 
 /*-********************************************************
-* bitStream decoding
+*  bitStream decoding
 **********************************************************/
 /*! BIT_initDStream() :
-*   Initialize a BIT_DStream_t.
-*   `bitD` : a pointer to an already allocated BIT_DStream_t structure.
-*   `srcSize` must be the *exact* size of the bitStream, in bytes.
-*   @return : size of stream (== srcSize) or an errorCode if a problem is detected
-*/
+ *  Initialize a BIT_DStream_t.
+ * `bitD` : a pointer to an already allocated BIT_DStream_t structure.
+ * `srcSize` must be the *exact* size of the bitStream, in bytes.
+ * @return : size of stream (== srcSize), or an errorCode if a problem is detected
+ */
 MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, size_t srcSize)
 {
     if (srcSize < 1) { memset(bitD, 0, sizeof(*bitD)); return ERROR(srcSize_wrong); }
@@ -305,29 +305,30 @@ MEM_STATIC size_t BIT_initDStream(BIT_DStream_t* bitD, const void* srcBuffer, si
         bitD->bitContainer = *(const BYTE*)(bitD->start);
         switch(srcSize)
         {
-	    case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);
-	            /* fall-through */
+        case 7: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[6]) << (sizeof(bitD->bitContainer)*8 - 16);
+                /* fall-through */
 
-	    case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);
-	            /* fall-through */
+        case 6: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[5]) << (sizeof(bitD->bitContainer)*8 - 24);
+                /* fall-through */
 
-	    case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);
-	            /* fall-through */
+        case 5: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[4]) << (sizeof(bitD->bitContainer)*8 - 32);
+                /* fall-through */
 
-	    case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24;
-	            /* fall-through */
+        case 4: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[3]) << 24;
+                /* fall-through */
 
-	    case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16;
-	            /* fall-through */
+        case 3: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[2]) << 16;
+                /* fall-through */
 
-	    case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) <<  8;
-	            /* fall-through */
+        case 2: bitD->bitContainer += (size_t)(((const BYTE*)(srcBuffer))[1]) <<  8;
+                /* fall-through */
 
-            default: break;
+        default: break;
+        }
+        {   BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
+            bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0;
+            if (lastByte == 0) return ERROR(corruption_detected);  /* endMark not present */
         }
-        { BYTE const lastByte = ((const BYTE*)srcBuffer)[srcSize-1];
-          bitD->bitsConsumed = lastByte ? 8 - BIT_highbit32(lastByte) : 0;
-          if (lastByte == 0) return ERROR(GENERIC); /* endMark not present */ }
         bitD->bitsConsumed += (U32)(sizeof(bitD->bitContainer) - srcSize)*8;
     }
 
@@ -363,9 +364,8 @@ MEM_STATIC size_t BIT_getLowerBits(size_t bitContainer, U32 const nbBits)
  *  local register is not modified.
  *  On 32-bits, maxNbBits==24.
  *  On 64-bits, maxNbBits==56.
- *  @return : value extracted
- */
- MEM_STATIC size_t BIT_lookBits(const BIT_DStream_t* bitD, U32 nbBits)
+ * @return : value extracted */
+MEM_STATIC size_t BIT_lookBits(const BIT_DStream_t* bitD, U32 nbBits)
 {
 #if defined(__BMI__) && defined(__GNUC__)   /* experimental; fails if bitD->bitsConsumed + nbBits > sizeof(bitD->bitContainer)*8 */
     return BIT_getMiddleBits(bitD->bitContainer, (sizeof(bitD->bitContainer)*8) - bitD->bitsConsumed - nbBits, nbBits);
@@ -392,8 +392,7 @@ MEM_STATIC void BIT_skipBits(BIT_DStream_t* bitD, U32 nbBits)
 /*! BIT_readBits() :
  *  Read (consume) next n bits from local register and update.
  *  Pay attention to not read more than nbBits contained into local register.
- *  @return : extracted value.
- */
+ * @return : extracted value. */
 MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits)
 {
     size_t const value = BIT_lookBits(bitD, nbBits);
@@ -402,7 +401,7 @@ MEM_STATIC size_t BIT_readBits(BIT_DStream_t* bitD, U32 nbBits)
 }
 
 /*! BIT_readBitsFast() :
-*   unsafe version; only works only if nbBits >= 1 */
+ *  unsafe version; only works only if nbBits >= 1 */
 MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits)
 {
     size_t const value = BIT_lookBitsFast(bitD, nbBits);
@@ -412,10 +411,10 @@ MEM_STATIC size_t BIT_readBitsFast(BIT_DStream_t* bitD, U32 nbBits)
 }
 
 /*! BIT_reloadDStream() :
-*   Refill `bitD` from buffer previously set in BIT_initDStream() .
-*   This function is safe, it guarantees it will not read beyond src buffer.
-*   @return : status of `BIT_DStream_t` internal register.
-              if status == BIT_DStream_unfinished, internal register is filled with >= (sizeof(bitD->bitContainer)*8 - 7) bits */
+ *  Refill `bitD` from buffer previously set in BIT_initDStream() .
+ *  This function is safe, it guarantees it will not read beyond src buffer.
+ * @return : status of `BIT_DStream_t` internal register.
+ *           when status == BIT_DStream_unfinished, internal register is filled with at least 25 or 57 bits */
 MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
 {
     if (bitD->bitsConsumed > (sizeof(bitD->bitContainer)*8))  /* overflow detected, like end of stream */
@@ -446,8 +445,8 @@ MEM_STATIC BIT_DStream_status BIT_reloadDStream(BIT_DStream_t* bitD)
 }
 
 /*! BIT_endOfDStream() :
-*   @return Tells if DStream has exactly reached its end (all bits consumed).
-*/
+ * @return : 1 if DStream has _exactly_ reached its end (all bits consumed).
+ */
 MEM_STATIC unsigned BIT_endOfDStream(const BIT_DStream_t* DStream)
 {
     return ((DStream->ptr == DStream->start) && (DStream->bitsConsumed == sizeof(DStream->bitContainer)*8));
diff --git a/contrib/libzstd/include/zstd/common/error_private.c b/contrib/libzstd/include/zstd/common/error_private.c
index 2d752cd23a7..b5b14b509cf 100644
--- a/contrib/libzstd/include/zstd/common/error_private.c
+++ b/contrib/libzstd/include/zstd/common/error_private.c
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 /* The purpose of this file is to have a single list of error strings embedded in binary */
@@ -20,19 +20,17 @@ const char* ERR_getErrorString(ERR_enum code)
     case PREFIX(GENERIC):  return "Error (generic)";
     case PREFIX(prefix_unknown): return "Unknown frame descriptor";
     case PREFIX(version_unsupported): return "Version not supported";
-    case PREFIX(parameter_unknown): return "Unknown parameter type";
     case PREFIX(frameParameter_unsupported): return "Unsupported frame parameter";
-    case PREFIX(frameParameter_unsupportedBy32bits): return "Frame parameter unsupported in 32-bits mode";
     case PREFIX(frameParameter_windowTooLarge): return "Frame requires too much memory for decoding";
-    case PREFIX(compressionParameter_unsupported): return "Compression parameter is not supported";
-    case PREFIX(compressionParameter_outOfBound): return "Compression parameter is out of bound";
+    case PREFIX(corruption_detected): return "Corrupted block detected";
+    case PREFIX(checksum_wrong): return "Restored data doesn't match checksum";
+    case PREFIX(parameter_unsupported): return "Unsupported parameter";
+    case PREFIX(parameter_outOfBound): return "Parameter is out of bound";
     case PREFIX(init_missing): return "Context should be init first";
     case PREFIX(memory_allocation): return "Allocation error : not enough memory";
     case PREFIX(stage_wrong): return "Operation not authorized at current processing stage";
     case PREFIX(dstSize_tooSmall): return "Destination buffer is too small";
     case PREFIX(srcSize_wrong): return "Src size is incorrect";
-    case PREFIX(corruption_detected): return "Corrupted block detected";
-    case PREFIX(checksum_wrong): return "Restored data doesn't match checksum";
     case PREFIX(tableLog_tooLarge): return "tableLog requires too much memory : unsupported";
     case PREFIX(maxSymbolValue_tooLarge): return "Unsupported max Symbol Value : too large";
     case PREFIX(maxSymbolValue_tooSmall): return "Specified maxSymbolValue is too small";
diff --git a/contrib/libzstd/include/zstd/common/error_private.h b/contrib/libzstd/include/zstd/common/error_private.h
index 1bc2e495481..9dd9a87cfac 100644
--- a/contrib/libzstd/include/zstd/common/error_private.h
+++ b/contrib/libzstd/include/zstd/common/error_private.h
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 /* Note : this module is expected to remain private, do not expose it */
diff --git a/contrib/libzstd/include/zstd/common/fse.h b/contrib/libzstd/include/zstd/common/fse.h
index 6d5d41def19..1c44f837507 100644
--- a/contrib/libzstd/include/zstd/common/fse.h
+++ b/contrib/libzstd/include/zstd/common/fse.h
@@ -31,13 +31,14 @@
    You can contact the author at :
    - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
 ****************************************************************** */
-#ifndef FSE_H
-#define FSE_H
 
 #if defined (__cplusplus)
 extern "C" {
 #endif
 
+#ifndef FSE_H
+#define FSE_H
+
 
 /*-*****************************************
 *  Dependencies
@@ -297,8 +298,10 @@ FSE_decompress_usingDTable() result will tell how many bytes were regenerated (<
 If there is an error, the function will return an error code, which can be tested using FSE_isError(). (ex: dst buffer too small)
 */
 
+#endif  /* FSE_H */
 
-#ifdef FSE_STATIC_LINKING_ONLY
+#if defined(FSE_STATIC_LINKING_ONLY) && !defined(FSE_H_FSE_STATIC_LINKING_ONLY)
+#define FSE_H_FSE_STATIC_LINKING_ONLY
 
 /* *** Dependency *** */
 #include "bitstream.h"
@@ -381,6 +384,11 @@ size_t FSE_buildDTable_rle (FSE_DTable* dt, unsigned char symbolValue);
 size_t FSE_decompress_wksp(void* dst, size_t dstCapacity, const void* cSrc, size_t cSrcSize, FSE_DTable* workSpace, unsigned maxLog);
 /**< same as FSE_decompress(), using an externally allocated `workSpace` produced with `FSE_DTABLE_SIZE_U32(maxLog)` */
 
+typedef enum {
+   FSE_repeat_none,  /**< Cannot use the previous table */
+   FSE_repeat_check, /**< Can use the previous table but it must be checked */
+   FSE_repeat_valid  /**< Can use the previous table and it is asumed to be valid */
+ } FSE_repeat;
 
 /* *****************************************
 *  FSE symbol compression API
@@ -694,5 +702,3 @@ MEM_STATIC unsigned FSE_endOfDState(const FSE_DState_t* DStatePtr)
 #if defined (__cplusplus)
 }
 #endif
-
-#endif  /* FSE_H */
diff --git a/contrib/libzstd/include/zstd/common/fse_decompress.c b/contrib/libzstd/include/zstd/common/fse_decompress.c
index 8474a4c079b..8e3f0035f69 100644
--- a/contrib/libzstd/include/zstd/common/fse_decompress.c
+++ b/contrib/libzstd/include/zstd/common/fse_decompress.c
@@ -33,35 +33,16 @@
 ****************************************************************** */
 
 
-/* **************************************************************
-*  Compiler specifics
-****************************************************************/
-#ifdef _MSC_VER    /* Visual Studio */
-#  define FORCE_INLINE static __forceinline
-#  include <intrin.h>                    /* For Visual 2005 */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */
-#else
-#  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
-#    ifdef __GNUC__
-#      define FORCE_INLINE static inline __attribute__((always_inline))
-#    else
-#      define FORCE_INLINE static inline
-#    endif
-#  else
-#    define FORCE_INLINE static
-#  endif /* __STDC_VERSION__ */
-#endif
-
-
 /* **************************************************************
 *  Includes
 ****************************************************************/
 #include <stdlib.h>     /* malloc, free, qsort */
 #include <string.h>     /* memcpy, memset */
 #include "bitstream.h"
+#include "compiler.h"
 #define FSE_STATIC_LINKING_ONLY
 #include "fse.h"
+#include "error_private.h"
 
 
 /* **************************************************************
@@ -216,7 +197,7 @@ size_t FSE_buildDTable_raw (FSE_DTable* dt, unsigned nbBits)
     return 0;
 }
 
-FORCE_INLINE size_t FSE_decompress_usingDTable_generic(
+FORCE_INLINE_TEMPLATE size_t FSE_decompress_usingDTable_generic(
           void* dst, size_t maxDstSize,
     const void* cSrc, size_t cSrcSize,
     const FSE_DTable* dt, const unsigned fast)
diff --git a/contrib/libzstd/include/zstd/common/huf.h b/contrib/libzstd/include/zstd/common/huf.h
index dabd359915a..2b3015a84c1 100644
--- a/contrib/libzstd/include/zstd/common/huf.h
+++ b/contrib/libzstd/include/zstd/common/huf.h
@@ -31,13 +31,13 @@
    You can contact the author at :
    - Source repository : https://github.com/Cyan4973/FiniteStateEntropy
 ****************************************************************** */
-#ifndef HUF_H_298734234
-#define HUF_H_298734234
 
 #if defined (__cplusplus)
 extern "C" {
 #endif
 
+#ifndef HUF_H_298734234
+#define HUF_H_298734234
 
 /* *** Dependencies *** */
 #include <stddef.h>    /* size_t */
@@ -124,6 +124,7 @@ HUF_PUBLIC_API size_t HUF_compress4X_wksp (void* dst, size_t dstCapacity, const
 #define HUF_DECOMPRESS_WORKSPACE_SIZE (2 << 10)
 #define HUF_DECOMPRESS_WORKSPACE_SIZE_U32 (HUF_DECOMPRESS_WORKSPACE_SIZE / sizeof(U32))
 
+#endif   /* HUF_H_298734234 */
 
 /* ******************************************************************
  *  WARNING !!
@@ -132,7 +133,8 @@ HUF_PUBLIC_API size_t HUF_compress4X_wksp (void* dst, size_t dstCapacity, const
  *  because they are not guaranteed to remain stable in the future.
  *  Only consider them in association with static linking.
  *******************************************************************/
-#ifdef HUF_STATIC_LINKING_ONLY
+#if defined(HUF_STATIC_LINKING_ONLY) && !defined(HUF_H_HUF_STATIC_LINKING_ONLY)
+#define HUF_H_HUF_STATIC_LINKING_ONLY
 
 /* *** Dependencies *** */
 #include "mem.h"   /* U32 */
@@ -295,9 +297,6 @@ size_t HUF_decompress1X4_usingDTable(void* dst, size_t maxDstSize, const void* c
 
 #endif /* HUF_STATIC_LINKING_ONLY */
 
-
 #if defined (__cplusplus)
 }
 #endif
-
-#endif   /* HUF_H_298734234 */
diff --git a/contrib/libzstd/include/zstd/common/mem.h b/contrib/libzstd/include/zstd/common/mem.h
index b0e5bf60b43..df85404fb86 100644
--- a/contrib/libzstd/include/zstd/common/mem.h
+++ b/contrib/libzstd/include/zstd/common/mem.h
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 #ifndef MEM_H_MODULE
@@ -110,7 +110,7 @@ Only use if no other choice to achieve best performance on target platform */
 MEM_STATIC U16 MEM_read16(const void* memPtr) { return *(const U16*) memPtr; }
 MEM_STATIC U32 MEM_read32(const void* memPtr) { return *(const U32*) memPtr; }
 MEM_STATIC U64 MEM_read64(const void* memPtr) { return *(const U64*) memPtr; }
-MEM_STATIC U64 MEM_readST(const void* memPtr) { return *(const size_t*) memPtr; }
+MEM_STATIC size_t MEM_readST(const void* memPtr) { return *(const size_t*) memPtr; }
 
 MEM_STATIC void MEM_write16(void* memPtr, U16 value) { *(U16*)memPtr = value; }
 MEM_STATIC void MEM_write32(void* memPtr, U32 value) { *(U32*)memPtr = value; }
@@ -131,7 +131,7 @@ MEM_STATIC void MEM_write64(void* memPtr, U64 value) { *(U64*)memPtr = value; }
 MEM_STATIC U16 MEM_read16(const void* ptr) { return ((const unalign*)ptr)->u16; }
 MEM_STATIC U32 MEM_read32(const void* ptr) { return ((const unalign*)ptr)->u32; }
 MEM_STATIC U64 MEM_read64(const void* ptr) { return ((const unalign*)ptr)->u64; }
-MEM_STATIC U64 MEM_readST(const void* ptr) { return ((const unalign*)ptr)->st; }
+MEM_STATIC size_t MEM_readST(const void* ptr) { return ((const unalign*)ptr)->st; }
 
 MEM_STATIC void MEM_write16(void* memPtr, U16 value) { ((unalign*)memPtr)->u16 = value; }
 MEM_STATIC void MEM_write32(void* memPtr, U32 value) { ((unalign*)memPtr)->u32 = value; }
diff --git a/contrib/libzstd/include/zstd/common/pool.c b/contrib/libzstd/include/zstd/common/pool.c
index 749fa4f2f7b..a227044f7f1 100644
--- a/contrib/libzstd/include/zstd/common/pool.c
+++ b/contrib/libzstd/include/zstd/common/pool.c
@@ -1,10 +1,10 @@
-/**
- * Copyright (c) 2016-present, Facebook, Inc.
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 
@@ -39,6 +39,12 @@ struct POOL_ctx_s {
     size_t queueHead;
     size_t queueTail;
     size_t queueSize;
+
+    /* The number of threads working on jobs */
+    size_t numThreadsBusy;
+    /* Indicates if the queue is empty */
+    int queueEmpty;
+
     /* The mutex protects the queue */
     pthread_mutex_t queueMutex;
     /* Condition variable for pushers to wait on when the queue is full */
@@ -60,30 +66,41 @@ static void* POOL_thread(void* opaque) {
     for (;;) {
         /* Lock the mutex and wait for a non-empty queue or until shutdown */
         pthread_mutex_lock(&ctx->queueMutex);
-        while (ctx->queueHead == ctx->queueTail && !ctx->shutdown) {
+
+        while (ctx->queueEmpty && !ctx->shutdown) {
             pthread_cond_wait(&ctx->queuePopCond, &ctx->queueMutex);
         }
         /* empty => shutting down: so stop */
-        if (ctx->queueHead == ctx->queueTail) {
+        if (ctx->queueEmpty) {
             pthread_mutex_unlock(&ctx->queueMutex);
             return opaque;
         }
         /* Pop a job off the queue */
         {   POOL_job const job = ctx->queue[ctx->queueHead];
             ctx->queueHead = (ctx->queueHead + 1) % ctx->queueSize;
+            ctx->numThreadsBusy++;
+            ctx->queueEmpty = ctx->queueHead == ctx->queueTail;
             /* Unlock the mutex, signal a pusher, and run the job */
             pthread_mutex_unlock(&ctx->queueMutex);
             pthread_cond_signal(&ctx->queuePushCond);
+
             job.function(job.opaque);
-        }
-    }
+
+            /* If the intended queue size was 0, signal after finishing job */
+            if (ctx->queueSize == 1) {
+                pthread_mutex_lock(&ctx->queueMutex);
+                ctx->numThreadsBusy--;
+                pthread_mutex_unlock(&ctx->queueMutex);
+                pthread_cond_signal(&ctx->queuePushCond);
+        }   }
+    }  /* for (;;) */
     /* Unreachable */
 }
 
 POOL_ctx *POOL_create(size_t numThreads, size_t queueSize) {
     POOL_ctx *ctx;
     /* Check the parameters */
-    if (!numThreads || !queueSize) { return NULL; }
+    if (!numThreads) { return NULL; }
     /* Allocate the context and zero initialize */
     ctx = (POOL_ctx *)calloc(1, sizeof(POOL_ctx));
     if (!ctx) { return NULL; }
@@ -92,15 +109,17 @@ POOL_ctx *POOL_create(size_t numThreads, size_t queueSize) {
      * and full queues.
      */
     ctx->queueSize = queueSize + 1;
-    ctx->queue = (POOL_job *)malloc(ctx->queueSize * sizeof(POOL_job));
+    ctx->queue = (POOL_job*) malloc(ctx->queueSize * sizeof(POOL_job));
     ctx->queueHead = 0;
     ctx->queueTail = 0;
-    pthread_mutex_init(&ctx->queueMutex, NULL);
-    pthread_cond_init(&ctx->queuePushCond, NULL);
-    pthread_cond_init(&ctx->queuePopCond, NULL);
+    ctx->numThreadsBusy = 0;
+    ctx->queueEmpty = 1;
+    (void)pthread_mutex_init(&ctx->queueMutex, NULL);
+    (void)pthread_cond_init(&ctx->queuePushCond, NULL);
+    (void)pthread_cond_init(&ctx->queuePopCond, NULL);
     ctx->shutdown = 0;
     /* Allocate space for the thread handles */
-    ctx->threads = (pthread_t *)malloc(numThreads * sizeof(pthread_t));
+    ctx->threads = (pthread_t*)malloc(numThreads * sizeof(pthread_t));
     ctx->numThreads = 0;
     /* Check for errors */
     if (!ctx->threads || !ctx->queue) { POOL_free(ctx); return NULL; }
@@ -153,22 +172,37 @@ size_t POOL_sizeof(POOL_ctx *ctx) {
         + ctx->numThreads * sizeof(pthread_t);
 }
 
-void POOL_add(void *ctxVoid, POOL_function function, void *opaque) {
-    POOL_ctx *ctx = (POOL_ctx *)ctxVoid;
+/**
+ * Returns 1 if the queue is full and 0 otherwise.
+ *
+ * If the queueSize is 1 (the pool was created with an intended queueSize of 0),
+ * then a queue is empty if there is a thread free and no job is waiting.
+ */
+static int isQueueFull(POOL_ctx const* ctx) {
+    if (ctx->queueSize > 1) {
+        return ctx->queueHead == ((ctx->queueTail + 1) % ctx->queueSize);
+    } else {
+        return ctx->numThreadsBusy == ctx->numThreads ||
+               !ctx->queueEmpty;
+    }
+}
+
+void POOL_add(void* ctxVoid, POOL_function function, void *opaque) {
+    POOL_ctx* const ctx = (POOL_ctx*)ctxVoid;
     if (!ctx) { return; }
 
     pthread_mutex_lock(&ctx->queueMutex);
     {   POOL_job const job = {function, opaque};
+
         /* Wait until there is space in the queue for the new job */
-        size_t newTail = (ctx->queueTail + 1) % ctx->queueSize;
-        while (ctx->queueHead == newTail && !ctx->shutdown) {
+        while (isQueueFull(ctx) && !ctx->shutdown) {
           pthread_cond_wait(&ctx->queuePushCond, &ctx->queueMutex);
-          newTail = (ctx->queueTail + 1) % ctx->queueSize;
         }
         /* The queue is still going => there is space */
         if (!ctx->shutdown) {
+            ctx->queueEmpty = 0;
             ctx->queue[ctx->queueTail] = job;
-            ctx->queueTail = newTail;
+            ctx->queueTail = (ctx->queueTail + 1) % ctx->queueSize;
         }
     }
     pthread_mutex_unlock(&ctx->queueMutex);
@@ -183,22 +217,22 @@ struct POOL_ctx_s {
   int data;
 };
 
-POOL_ctx *POOL_create(size_t numThreads, size_t queueSize) {
+POOL_ctx* POOL_create(size_t numThreads, size_t queueSize) {
   (void)numThreads;
   (void)queueSize;
-  return (POOL_ctx *)malloc(sizeof(POOL_ctx));
+  return (POOL_ctx*)malloc(sizeof(POOL_ctx));
 }
 
-void POOL_free(POOL_ctx *ctx) {
-  if (ctx) free(ctx);
+void POOL_free(POOL_ctx* ctx) {
+    free(ctx);
 }
 
-void POOL_add(void *ctx, POOL_function function, void *opaque) {
+void POOL_add(void* ctx, POOL_function function, void* opaque) {
   (void)ctx;
   function(opaque);
 }
 
-size_t POOL_sizeof(POOL_ctx *ctx) {
+size_t POOL_sizeof(POOL_ctx* ctx) {
     if (ctx==NULL) return 0;  /* supports sizeof NULL */
     return sizeof(*ctx);
 }
diff --git a/contrib/libzstd/include/zstd/common/pool.h b/contrib/libzstd/include/zstd/common/pool.h
index 386cd674b7c..264c5c9ca7e 100644
--- a/contrib/libzstd/include/zstd/common/pool.h
+++ b/contrib/libzstd/include/zstd/common/pool.h
@@ -1,11 +1,12 @@
-/**
- * Copyright (c) 2016-present, Facebook, Inc.
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
+
 #ifndef POOL_H
 #define POOL_H
 
@@ -19,11 +20,10 @@ extern "C" {
 typedef struct POOL_ctx_s POOL_ctx;
 
 /*! POOL_create() :
-    Create a thread pool with at most `numThreads` threads.
-    `numThreads` must be at least 1.
-    The maximum number of queued jobs before blocking is `queueSize`.
-    `queueSize` must be at least 1.
-    @return : The POOL_ctx pointer on success else NULL.
+ *  Create a thread pool with at most `numThreads` threads.
+ * `numThreads` must be at least 1.
+ *  The maximum number of queued jobs before blocking is `queueSize`.
+ * @return : POOL_ctx pointer on success, else NULL.
 */
 POOL_ctx *POOL_create(size_t numThreads, size_t queueSize);
 
diff --git a/contrib/libzstd/include/zstd/common/threading.h b/contrib/libzstd/include/zstd/common/threading.h
index c0086139ea3..ab09977a86d 100644
--- a/contrib/libzstd/include/zstd/common/threading.h
+++ b/contrib/libzstd/include/zstd/common/threading.h
@@ -1,4 +1,3 @@
-
 /**
  * Copyright (c) 2016 Tino Reichardt
  * All rights reserved.
@@ -42,14 +41,14 @@ extern "C" {
 
 /* mutex */
 #define pthread_mutex_t           CRITICAL_SECTION
-#define pthread_mutex_init(a,b)   InitializeCriticalSection((a))
+#define pthread_mutex_init(a,b)   (InitializeCriticalSection((a)), 0)
 #define pthread_mutex_destroy(a)  DeleteCriticalSection((a))
 #define pthread_mutex_lock(a)     EnterCriticalSection((a))
 #define pthread_mutex_unlock(a)   LeaveCriticalSection((a))
 
 /* condition variable */
 #define pthread_cond_t             CONDITION_VARIABLE
-#define pthread_cond_init(a, b)    InitializeConditionVariable((a))
+#define pthread_cond_init(a, b)    (InitializeConditionVariable((a)), 0)
 #define pthread_cond_destroy(a)    /* No delete */
 #define pthread_cond_wait(a, b)    SleepConditionVariableCS((a), (b), INFINITE)
 #define pthread_cond_signal(a)     WakeConditionVariable((a))
@@ -80,14 +79,14 @@ int _pthread_join(pthread_t* thread, void** value_ptr);
 #else  /* ZSTD_MULTITHREAD not defined */
 /* No multithreading support */
 
-#define pthread_mutex_t int   /* #define rather than typedef, as sometimes pthread support is implicit, resulting in duplicated symbols */
-#define pthread_mutex_init(a,b)
+#define pthread_mutex_t int   /* #define rather than typedef, because sometimes pthread support is implicit, resulting in duplicated symbols */
+#define pthread_mutex_init(a,b)    ((void)a, 0)
 #define pthread_mutex_destroy(a)
 #define pthread_mutex_lock(a)
 #define pthread_mutex_unlock(a)
 
 #define pthread_cond_t int
-#define pthread_cond_init(a,b)
+#define pthread_cond_init(a,b)     ((void)a, 0)
 #define pthread_cond_destroy(a)
 #define pthread_cond_wait(a,b)
 #define pthread_cond_signal(a)
diff --git a/contrib/libzstd/include/zstd/common/xxhash.c b/contrib/libzstd/include/zstd/common/xxhash.c
index eb44222c5fc..9d9c0e963cb 100644
--- a/contrib/libzstd/include/zstd/common/xxhash.c
+++ b/contrib/libzstd/include/zstd/common/xxhash.c
@@ -113,19 +113,25 @@ static void* XXH_memcpy(void* dest, const void* src, size_t size) { return memcp
 /* *************************************
 *  Compiler Specific Options
 ***************************************/
-#ifdef _MSC_VER    /* Visual Studio */
-#  pragma warning(disable : 4127)      /* disable: C4127: conditional expression is constant */
-#  define FORCE_INLINE static __forceinline
+#if defined (__GNUC__) || defined(__cplusplus) || defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
+#  define INLINE_KEYWORD inline
 #else
-#  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
-#    ifdef __GNUC__
-#      define FORCE_INLINE static inline __attribute__((always_inline))
-#    else
-#      define FORCE_INLINE static inline
-#    endif
-#  else
-#    define FORCE_INLINE static
-#  endif /* __STDC_VERSION__ */
+#  define INLINE_KEYWORD
+#endif
+
+#if defined(__GNUC__)
+#  define FORCE_INLINE_ATTR __attribute__((always_inline))
+#elif defined(_MSC_VER)
+#  define FORCE_INLINE_ATTR __forceinline
+#else
+#  define FORCE_INLINE_ATTR
+#endif
+
+#define FORCE_INLINE_TEMPLATE static INLINE_KEYWORD FORCE_INLINE_ATTR
+
+
+#ifdef _MSC_VER
+#  pragma warning(disable : 4127)      /* disable: C4127: conditional expression is constant */
 #endif
 
 
@@ -248,7 +254,7 @@ typedef enum { XXH_bigEndian=0, XXH_littleEndian=1 } XXH_endianess;
 *****************************/
 typedef enum { XXH_aligned, XXH_unaligned } XXH_alignment;
 
-FORCE_INLINE U32 XXH_readLE32_align(const void* ptr, XXH_endianess endian, XXH_alignment align)
+FORCE_INLINE_TEMPLATE U32 XXH_readLE32_align(const void* ptr, XXH_endianess endian, XXH_alignment align)
 {
     if (align==XXH_unaligned)
         return endian==XXH_littleEndian ? XXH_read32(ptr) : XXH_swap32(XXH_read32(ptr));
@@ -256,7 +262,7 @@ FORCE_INLINE U32 XXH_readLE32_align(const void* ptr, XXH_endianess endian, XXH_a
         return endian==XXH_littleEndian ? *(const U32*)ptr : XXH_swap32(*(const U32*)ptr);
 }
 
-FORCE_INLINE U32 XXH_readLE32(const void* ptr, XXH_endianess endian)
+FORCE_INLINE_TEMPLATE U32 XXH_readLE32(const void* ptr, XXH_endianess endian)
 {
     return XXH_readLE32_align(ptr, endian, XXH_unaligned);
 }
@@ -266,7 +272,7 @@ static U32 XXH_readBE32(const void* ptr)
     return XXH_CPU_LITTLE_ENDIAN ? XXH_swap32(XXH_read32(ptr)) : XXH_read32(ptr);
 }
 
-FORCE_INLINE U64 XXH_readLE64_align(const void* ptr, XXH_endianess endian, XXH_alignment align)
+FORCE_INLINE_TEMPLATE U64 XXH_readLE64_align(const void* ptr, XXH_endianess endian, XXH_alignment align)
 {
     if (align==XXH_unaligned)
         return endian==XXH_littleEndian ? XXH_read64(ptr) : XXH_swap64(XXH_read64(ptr));
@@ -274,7 +280,7 @@ FORCE_INLINE U64 XXH_readLE64_align(const void* ptr, XXH_endianess endian, XXH_a
         return endian==XXH_littleEndian ? *(const U64*)ptr : XXH_swap64(*(const U64*)ptr);
 }
 
-FORCE_INLINE U64 XXH_readLE64(const void* ptr, XXH_endianess endian)
+FORCE_INLINE_TEMPLATE U64 XXH_readLE64(const void* ptr, XXH_endianess endian)
 {
     return XXH_readLE64_align(ptr, endian, XXH_unaligned);
 }
@@ -335,7 +341,7 @@ static U32 XXH32_round(U32 seed, U32 input)
     return seed;
 }
 
-FORCE_INLINE U32 XXH32_endian_align(const void* input, size_t len, U32 seed, XXH_endianess endian, XXH_alignment align)
+FORCE_INLINE_TEMPLATE U32 XXH32_endian_align(const void* input, size_t len, U32 seed, XXH_endianess endian, XXH_alignment align)
 {
     const BYTE* p = (const BYTE*)input;
     const BYTE* bEnd = p + len;
@@ -435,7 +441,7 @@ static U64 XXH64_mergeRound(U64 acc, U64 val)
     return acc;
 }
 
-FORCE_INLINE U64 XXH64_endian_align(const void* input, size_t len, U64 seed, XXH_endianess endian, XXH_alignment align)
+FORCE_INLINE_TEMPLATE U64 XXH64_endian_align(const void* input, size_t len, U64 seed, XXH_endianess endian, XXH_alignment align)
 {
     const BYTE* p = (const BYTE*)input;
     const BYTE* const bEnd = p + len;
@@ -584,7 +590,7 @@ XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, unsigned long
 }
 
 
-FORCE_INLINE XXH_errorcode XXH32_update_endian (XXH32_state_t* state, const void* input, size_t len, XXH_endianess endian)
+FORCE_INLINE_TEMPLATE XXH_errorcode XXH32_update_endian (XXH32_state_t* state, const void* input, size_t len, XXH_endianess endian)
 {
     const BYTE* p = (const BYTE*)input;
     const BYTE* const bEnd = p + len;
@@ -654,7 +660,7 @@ XXH_PUBLIC_API XXH_errorcode XXH32_update (XXH32_state_t* state_in, const void*
 
 
 
-FORCE_INLINE U32 XXH32_digest_endian (const XXH32_state_t* state, XXH_endianess endian)
+FORCE_INLINE_TEMPLATE U32 XXH32_digest_endian (const XXH32_state_t* state, XXH_endianess endian)
 {
     const BYTE * p = (const BYTE*)state->mem32;
     const BYTE* const bEnd = (const BYTE*)(state->mem32) + state->memsize;
@@ -704,7 +710,7 @@ XXH_PUBLIC_API unsigned int XXH32_digest (const XXH32_state_t* state_in)
 
 /* **** XXH64 **** */
 
-FORCE_INLINE XXH_errorcode XXH64_update_endian (XXH64_state_t* state, const void* input, size_t len, XXH_endianess endian)
+FORCE_INLINE_TEMPLATE XXH_errorcode XXH64_update_endian (XXH64_state_t* state, const void* input, size_t len, XXH_endianess endian)
 {
     const BYTE* p = (const BYTE*)input;
     const BYTE* const bEnd = p + len;
@@ -771,7 +777,7 @@ XXH_PUBLIC_API XXH_errorcode XXH64_update (XXH64_state_t* state_in, const void*
 
 
 
-FORCE_INLINE U64 XXH64_digest_endian (const XXH64_state_t* state, XXH_endianess endian)
+FORCE_INLINE_TEMPLATE U64 XXH64_digest_endian (const XXH64_state_t* state, XXH_endianess endian)
 {
     const BYTE * p = (const BYTE*)state->mem64;
     const BYTE* const bEnd = (const BYTE*)state->mem64 + state->memsize;
diff --git a/contrib/libzstd/include/zstd/common/zstd_common.c b/contrib/libzstd/include/zstd/common/zstd_common.c
index f6816723815..08384cabf59 100644
--- a/contrib/libzstd/include/zstd/common/zstd_common.c
+++ b/contrib/libzstd/include/zstd/common/zstd_common.c
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 
diff --git a/contrib/libzstd/include/zstd/common/zstd_errors.h b/contrib/libzstd/include/zstd/common/zstd_errors.h
index 19f1597aa34..a69387b714a 100644
--- a/contrib/libzstd/include/zstd/common/zstd_errors.h
+++ b/contrib/libzstd/include/zstd/common/zstd_errors.h
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 #ifndef ZSTD_ERRORS_H_398273423
@@ -37,43 +37,41 @@ extern "C" {
 /*-****************************************
  *  error codes list
  *  note : this API is still considered unstable
- *         it should not be used with a dynamic library
+ *         and shall not be used with a dynamic library.
  *         only static linking is allowed
  ******************************************/
 typedef enum {
-  ZSTD_error_no_error,
-  ZSTD_error_GENERIC,
-  ZSTD_error_prefix_unknown,
-  ZSTD_error_version_unsupported,
-  ZSTD_error_parameter_unknown,
-  ZSTD_error_frameParameter_unsupported,
-  ZSTD_error_frameParameter_unsupportedBy32bits,
-  ZSTD_error_frameParameter_windowTooLarge,
-  ZSTD_error_compressionParameter_unsupported,
-  ZSTD_error_compressionParameter_outOfBound,
-  ZSTD_error_init_missing,
-  ZSTD_error_memory_allocation,
-  ZSTD_error_stage_wrong,
-  ZSTD_error_dstSize_tooSmall,
-  ZSTD_error_srcSize_wrong,
-  ZSTD_error_corruption_detected,
-  ZSTD_error_checksum_wrong,
-  ZSTD_error_tableLog_tooLarge,
-  ZSTD_error_maxSymbolValue_tooLarge,
-  ZSTD_error_maxSymbolValue_tooSmall,
-  ZSTD_error_dictionary_corrupted,
-  ZSTD_error_dictionary_wrong,
-  ZSTD_error_dictionaryCreation_failed,
-  ZSTD_error_frameIndex_tooLarge,
-  ZSTD_error_seekableIO,
-  ZSTD_error_maxCode
+  ZSTD_error_no_error = 0,
+  ZSTD_error_GENERIC  = 1,
+  ZSTD_error_prefix_unknown                = 10,
+  ZSTD_error_version_unsupported           = 12,
+  ZSTD_error_frameParameter_unsupported    = 14,
+  ZSTD_error_frameParameter_windowTooLarge = 16,
+  ZSTD_error_corruption_detected = 20,
+  ZSTD_error_checksum_wrong      = 22,
+  ZSTD_error_dictionary_corrupted      = 30,
+  ZSTD_error_dictionary_wrong          = 32,
+  ZSTD_error_dictionaryCreation_failed = 34,
+  ZSTD_error_parameter_unsupported   = 40,
+  ZSTD_error_parameter_outOfBound    = 42,
+  ZSTD_error_tableLog_tooLarge       = 44,
+  ZSTD_error_maxSymbolValue_tooLarge = 46,
+  ZSTD_error_maxSymbolValue_tooSmall = 48,
+  ZSTD_error_stage_wrong       = 60,
+  ZSTD_error_init_missing      = 62,
+  ZSTD_error_memory_allocation = 64,
+  ZSTD_error_dstSize_tooSmall = 70,
+  ZSTD_error_srcSize_wrong    = 72,
+  ZSTD_error_frameIndex_tooLarge = 100,
+  ZSTD_error_seekableIO          = 102,
+  ZSTD_error_maxCode = 120  /* never EVER use this value directly, it may change in future versions! Use ZSTD_isError() instead */
 } ZSTD_ErrorCode;
 
 /*! ZSTD_getErrorCode() :
     convert a `size_t` function result into a `ZSTD_ErrorCode` enum type,
     which can be used to compare with enum list published above */
 ZSTDERRORLIB_API ZSTD_ErrorCode ZSTD_getErrorCode(size_t functionResult);
-ZSTDERRORLIB_API const char* ZSTD_getErrorString(ZSTD_ErrorCode code);
+ZSTDERRORLIB_API const char* ZSTD_getErrorString(ZSTD_ErrorCode code);   /**< Same as ZSTD_getErrorName, but using a `ZSTD_ErrorCode` enum argument */
 
 
 #if defined (__cplusplus)
diff --git a/contrib/libzstd/include/zstd/common/zstd_internal.h b/contrib/libzstd/include/zstd/common/zstd_internal.h
index f2c4e6249fb..2610528608d 100644
--- a/contrib/libzstd/include/zstd/common/zstd_internal.h
+++ b/contrib/libzstd/include/zstd/common/zstd_internal.h
@@ -1,55 +1,28 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 #ifndef ZSTD_CCOMMON_H_MODULE
 #define ZSTD_CCOMMON_H_MODULE
 
-/*-*******************************************************
-*  Compiler specifics
-*********************************************************/
-#ifdef _MSC_VER    /* Visual Studio */
-#  define FORCE_INLINE static __forceinline
-#  include <intrin.h>                    /* For Visual 2005 */
-#  pragma warning(disable : 4100)        /* disable: C4100: unreferenced formal parameter */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#  pragma warning(disable : 4204)        /* disable: C4204: non-constant aggregate initializer */
-#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */
-#else
-#  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
-#    ifdef __GNUC__
-#      define FORCE_INLINE static inline __attribute__((always_inline))
-#    else
-#      define FORCE_INLINE static inline
-#    endif
-#  else
-#    define FORCE_INLINE static
-#  endif /* __STDC_VERSION__ */
-#endif
-
-#ifdef _MSC_VER
-#  define FORCE_NOINLINE static __declspec(noinline)
-#else
-#  ifdef __GNUC__
-#    define FORCE_NOINLINE static __attribute__((__noinline__))
-#  else
-#    define FORCE_NOINLINE static
-#  endif
-#endif
-
 
 /*-*************************************
 *  Dependencies
 ***************************************/
+#include "compiler.h"
 #include "mem.h"
 #include "error_private.h"
 #define ZSTD_STATIC_LINKING_ONLY
 #include "zstd.h"
+#define FSE_STATIC_LINKING_ONLY
+#include "fse.h"
+#define HUF_STATIC_LINKING_ONLY
+#include "huf.h"
 #ifndef XXH_STATIC_LINKING_ONLY
 #  define XXH_STATIC_LINKING_ONLY  /* XXH64_state_t */
 #endif
@@ -211,20 +184,6 @@ MEM_STATIC void ZSTD_wildcopy_e(void* dst, const void* src, void* dstEnd)   /* s
 *********************************************/
 typedef struct ZSTD_stats_s ZSTD_stats_t;
 
-typedef struct {
-    U32 off;
-    U32 len;
-} ZSTD_match_t;
-
-typedef struct {
-    U32 price;
-    U32 off;
-    U32 mlen;
-    U32 litlen;
-    U32 rep[ZSTD_REP_NUM];
-} ZSTD_optimal_t;
-
-
 typedef struct seqDef_s {
     U32 offset;
     U16 litLength;
@@ -242,13 +201,31 @@ typedef struct {
     BYTE* ofCode;
     U32   longLengthID;   /* 0 == no longLength; 1 == Lit.longLength; 2 == Match.longLength; */
     U32   longLengthPos;
-    /* opt */
-    ZSTD_optimal_t* priceTable;
-    ZSTD_match_t* matchTable;
-    U32* matchLengthFreq;
-    U32* litLengthFreq;
+    U32   rep[ZSTD_REP_NUM];
+    U32   repToConfirm[ZSTD_REP_NUM];
+} seqStore_t;
+
+typedef struct {
+    U32 off;
+    U32 len;
+} ZSTD_match_t;
+
+typedef struct {
+    U32 price;
+    U32 off;
+    U32 mlen;
+    U32 litlen;
+    U32 rep[ZSTD_REP_NUM];
+} ZSTD_optimal_t;
+
+typedef struct {
     U32* litFreq;
+    U32* litLengthFreq;
+    U32* matchLengthFreq;
     U32* offCodeFreq;
+    ZSTD_match_t* matchTable;
+    ZSTD_optimal_t* priceTable;
+
     U32  matchLengthSum;
     U32  matchSum;
     U32  litLengthSum;
@@ -264,7 +241,19 @@ typedef struct {
     U32  cachedPrice;
     U32  cachedLitLength;
     const BYTE* cachedLiterals;
-} seqStore_t;
+} optState_t;
+
+typedef struct {
+    U32 hufCTable[HUF_CTABLE_SIZE_U32(255)];
+    FSE_CTable offcodeCTable[FSE_CTABLE_SIZE_U32(OffFSELog, MaxOff)];
+    FSE_CTable matchlengthCTable[FSE_CTABLE_SIZE_U32(MLFSELog, MaxML)];
+    FSE_CTable litlengthCTable[FSE_CTABLE_SIZE_U32(LLFSELog, MaxLL)];
+    U32 workspace[HUF_WORKSPACE_SIZE_U32];
+    HUF_repeat hufCTable_repeatMode;
+    FSE_repeat offcode_repeatMode;
+    FSE_repeat matchlength_repeatMode;
+    FSE_repeat litlength_repeatMode;
+} ZSTD_entropyCTables_t;
 
 const seqStore_t* ZSTD_getSeqStore(const ZSTD_CCtx* ctx);
 void ZSTD_seqToCodes(const seqStore_t* seqStorePtr);
@@ -331,4 +320,16 @@ size_t ZSTD_compressStream_generic(ZSTD_CStream* zcs,
 ZSTD_parameters ZSTD_getParamsFromCDict(const ZSTD_CDict* cdict);
 
 
+typedef struct {
+    blockType_e blockType;
+    U32 lastBlock;
+    U32 origSize;
+} blockProperties_t;
+
+/*! ZSTD_getcBlockSize() :
+*   Provides the size of compressed block from block header `src` */
+size_t ZSTD_getcBlockSize(const void* src, size_t srcSize,
+                          blockProperties_t* bpPtr);
+
+
 #endif   /* ZSTD_CCOMMON_H_MODULE */
diff --git a/contrib/libzstd/include/zstd/compress/fse_compress.c b/contrib/libzstd/include/zstd/compress/fse_compress.c
index 26e8052ddcc..cc9fa73514a 100644
--- a/contrib/libzstd/include/zstd/compress/fse_compress.c
+++ b/contrib/libzstd/include/zstd/compress/fse_compress.c
@@ -32,27 +32,6 @@
     - Public forum : https://groups.google.com/forum/#!forum/lz4c
 ****************************************************************** */
 
-/* **************************************************************
-*  Compiler specifics
-****************************************************************/
-#ifdef _MSC_VER    /* Visual Studio */
-#  define FORCE_INLINE static __forceinline
-#  include <intrin.h>                    /* For Visual 2005 */
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */
-#else
-#  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
-#    ifdef __GNUC__
-#      define FORCE_INLINE static inline __attribute__((always_inline))
-#    else
-#      define FORCE_INLINE static inline
-#    endif
-#  else
-#    define FORCE_INLINE static
-#  endif /* __STDC_VERSION__ */
-#endif
-
-
 /* **************************************************************
 *  Includes
 ****************************************************************/
@@ -60,13 +39,16 @@
 #include <string.h>     /* memcpy, memset */
 #include <stdio.h>      /* printf (debug) */
 #include "bitstream.h"
+#include "compiler.h"
 #define FSE_STATIC_LINKING_ONLY
 #include "fse.h"
+#include "error_private.h"
 
 
 /* **************************************************************
 *  Error Management
 ****************************************************************/
+#define FSE_isError ERR_isError
 #define FSE_STATIC_ASSERT(c) { enum { FSE_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
 
 
@@ -781,7 +763,7 @@ size_t FSE_compress_usingCTable (void* dst, size_t dstSize,
 
 size_t FSE_compressBound(size_t size) { return FSE_COMPRESSBOUND(size); }
 
-#define CHECK_V_F(e, f) size_t const e = f; if (ERR_isError(e)) return f
+#define CHECK_V_F(e, f) size_t const e = f; if (ERR_isError(e)) return e
 #define CHECK_F(f)   { CHECK_V_F(_var_err__, f); }
 
 /* FSE_compress_wksp() :
diff --git a/contrib/libzstd/include/zstd/compress/huf_compress.c b/contrib/libzstd/include/zstd/compress/huf_compress.c
index 7af0789a9c5..2a47c182052 100644
--- a/contrib/libzstd/include/zstd/compress/huf_compress.c
+++ b/contrib/libzstd/include/zstd/compress/huf_compress.c
@@ -50,13 +50,15 @@
 #include "fse.h"        /* header compression */
 #define HUF_STATIC_LINKING_ONLY
 #include "huf.h"
+#include "error_private.h"
 
 
 /* **************************************************************
 *  Error Management
 ****************************************************************/
+#define HUF_isError ERR_isError
 #define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
-#define CHECK_V_F(e, f) size_t const e = f; if (ERR_isError(e)) return f
+#define CHECK_V_F(e, f) size_t const e = f; if (ERR_isError(e)) return e
 #define CHECK_F(f)   { CHECK_V_F(_var_err__, f); }
 
 
@@ -436,7 +438,7 @@ static void HUF_encodeSymbol(BIT_CStream_t* bitCPtr, U32 symbol, const HUF_CElt*
 
 size_t HUF_compressBound(size_t size) { return HUF_COMPRESSBOUND(size); }
 
-#define HUF_FLUSHBITS(s)  (fast ? BIT_flushBitsFast(s) : BIT_flushBits(s))
+#define HUF_FLUSHBITS(s)  BIT_flushBits(s)
 
 #define HUF_FLUSHBITS_1(stream) \
     if (sizeof((stream)->bitContainer)*8 < HUF_TABLELOG_MAX*2+7) HUF_FLUSHBITS(stream)
@@ -451,7 +453,6 @@ size_t HUF_compress1X_usingCTable(void* dst, size_t dstSize, const void* src, si
     BYTE* const oend = ostart + dstSize;
     BYTE* op = ostart;
     size_t n;
-    const unsigned fast = (dstSize >= HUF_BLOCKBOUND(srcSize));
     BIT_CStream_t bitC;
 
     /* init */
diff --git a/contrib/libzstd/include/zstd/compress/zstd_compress.c b/contrib/libzstd/include/zstd/compress/zstd_compress.c
index 9300357f2d3..0322c03eb31 100644
--- a/contrib/libzstd/include/zstd/compress/zstd_compress.c
+++ b/contrib/libzstd/include/zstd/compress/zstd_compress.c
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 
@@ -36,13 +36,6 @@ static const U32 g_searchStrength = 8;   /* control skip over incompressible dat
 #define HASH_READ_SIZE 8
 typedef enum { ZSTDcs_created=0, ZSTDcs_init, ZSTDcs_ongoing, ZSTDcs_ending } ZSTD_compressionStage_e;
 
-/* entropy tables always have same size */
-static size_t const hufCTable_size = HUF_CTABLE_SIZE(255);
-static size_t const litlengthCTable_size = FSE_CTABLE_SIZE(LLFSELog, MaxLL);
-static size_t const offcodeCTable_size = FSE_CTABLE_SIZE(OffFSELog, MaxOff);
-static size_t const matchlengthCTable_size = FSE_CTABLE_SIZE(MLFSELog, MaxML);
-static size_t const entropyScratchSpace_size = HUF_WORKSPACE_SIZE;
-
 
 /*-*************************************
 *  Helper functions
@@ -89,8 +82,6 @@ struct ZSTD_CCtx_s {
     U32   loadedDictEnd;    /* index of end of dictionary */
     U32   forceWindow;      /* force back-references to respect limit of 1<<wLog, even for dictionary */
     ZSTD_compressionStage_e stage;
-    U32   rep[ZSTD_REP_NUM];
-    U32   repToConfirm[ZSTD_REP_NUM];
     U32   dictID;
     int   compressionLevel;
     ZSTD_parameters requestedParams;
@@ -105,16 +96,11 @@ struct ZSTD_CCtx_s {
     size_t staticSize;
 
     seqStore_t seqStore;    /* sequences storage ptrs */
+    optState_t optState;
     U32* hashTable;
     U32* hashTable3;
     U32* chainTable;
-    HUF_repeat hufCTable_repeatMode;
-    HUF_CElt* hufCTable;
-    U32 fseCTables_ready;
-    FSE_CTable* offcodeCTable;
-    FSE_CTable* matchlengthCTable;
-    FSE_CTable* litlengthCTable;
-    unsigned* entropyScratchSpace;
+    ZSTD_entropyCTables_t* entropy;
 
     /* streaming */
     char*  inBuff;
@@ -174,19 +160,9 @@ ZSTD_CCtx* ZSTD_initStaticCCtx(void *workspace, size_t workspaceSize)
     cctx->workSpaceSize = workspaceSize - sizeof(ZSTD_CCtx);
 
     /* entropy space (never moves) */
-    /* note : this code should be shared with resetCCtx, rather than copy/pasted */
-    {   void* ptr = cctx->workSpace;
-        cctx->hufCTable = (HUF_CElt*)ptr;
-        ptr = (char*)cctx->hufCTable + hufCTable_size;
-        cctx->offcodeCTable = (FSE_CTable*) ptr;
-        ptr = (char*)ptr + offcodeCTable_size;
-        cctx->matchlengthCTable = (FSE_CTable*) ptr;
-        ptr = (char*)ptr + matchlengthCTable_size;
-        cctx->litlengthCTable = (FSE_CTable*) ptr;
-        ptr = (char*)ptr + litlengthCTable_size;
-        assert(((size_t)ptr & 3) == 0);   /* ensure correct alignment */
-        cctx->entropyScratchSpace = (unsigned*) ptr;
-    }
+    if (cctx->workSpaceSize < sizeof(ZSTD_entropyCTables_t)) return NULL;
+    assert(((size_t)cctx->workSpace & 7) == 0);   /* ensure correct alignment */
+    cctx->entropy = (ZSTD_entropyCTables_t*)cctx->workSpace;
 
     return cctx;
 }
@@ -237,7 +213,7 @@ size_t ZSTD_setCCtxParameter(ZSTD_CCtx* cctx, ZSTD_CCtxParameter param, unsigned
     ZSTD_STATIC_ASSERT(ZSTD_dm_auto==0);
     ZSTD_STATIC_ASSERT(ZSTD_dm_rawContent==1);
     case ZSTD_p_forceRawDict : cctx->dictMode = (ZSTD_dictMode_e)(value>0); return 0;
-    default: return ERROR(parameter_unknown);
+    default: return ERROR(parameter_unsupported);
     }
 }
 
@@ -251,9 +227,9 @@ static void ZSTD_cLevelToCParams(ZSTD_CCtx* cctx)
     cctx->compressionLevel = ZSTD_CLEVEL_CUSTOM;
 }
 
-#define CLAMPCHECK(val,min,max) {                       \
-    if (((val)<(min)) | ((val)>(max))) {                \
-        return ERROR(compressionParameter_outOfBound);  \
+#define CLAMPCHECK(val,min,max) {            \
+    if (((val)<(min)) | ((val)>(max))) {     \
+        return ERROR(parameter_outOfBound);  \
 }   }
 
 size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned value)
@@ -349,7 +325,7 @@ size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned v
         /* restrict dictionary mode, to "rawContent" or "fullDict" only */
         ZSTD_STATIC_ASSERT((U32)ZSTD_dm_fullDict > (U32)ZSTD_dm_rawContent);
         if (value > (unsigned)ZSTD_dm_fullDict)
-            return ERROR(compressionParameter_outOfBound);
+            return ERROR(parameter_outOfBound);
         cctx->dictMode = (ZSTD_dictMode_e)value;
         return 0;
 
@@ -370,31 +346,31 @@ size_t ZSTD_CCtx_setParameter(ZSTD_CCtx* cctx, ZSTD_cParameter param, unsigned v
         if (value==0) return 0;
         DEBUGLOG(5, " setting nbThreads : %u", value);
 #ifndef ZSTD_MULTITHREAD
-        if (value > 1) return ERROR(compressionParameter_unsupported);
+        if (value > 1) return ERROR(parameter_unsupported);
 #endif
         if ((value>1) && (cctx->nbThreads != value)) {
             if (cctx->staticSize)  /* MT not compatible with static alloc */
-                return ERROR(compressionParameter_unsupported);
+                return ERROR(parameter_unsupported);
             ZSTDMT_freeCCtx(cctx->mtctx);
             cctx->nbThreads = 1;
-            cctx->mtctx = ZSTDMT_createCCtx(value);
+            cctx->mtctx = ZSTDMT_createCCtx_advanced(value, cctx->customMem);
             if (cctx->mtctx == NULL) return ERROR(memory_allocation);
         }
         cctx->nbThreads = value;
         return 0;
 
     case ZSTD_p_jobSize:
-        if (cctx->nbThreads <= 1) return ERROR(compressionParameter_unsupported);
+        if (cctx->nbThreads <= 1) return ERROR(parameter_unsupported);
         assert(cctx->mtctx != NULL);
         return ZSTDMT_setMTCtxParameter(cctx->mtctx, ZSTDMT_p_sectionSize, value);
 
     case ZSTD_p_overlapSizeLog:
         DEBUGLOG(5, " setting overlap with nbThreads == %u", cctx->nbThreads);
-        if (cctx->nbThreads <= 1) return ERROR(compressionParameter_unsupported);
+        if (cctx->nbThreads <= 1) return ERROR(parameter_unsupported);
         assert(cctx->mtctx != NULL);
         return ZSTDMT_setMTCtxParameter(cctx->mtctx, ZSTDMT_p_overlapSectionLog, value);
 
-    default: return ERROR(parameter_unknown);
+    default: return ERROR(parameter_unsupported);
     }
 }
 
@@ -474,7 +450,8 @@ size_t ZSTD_checkCParams(ZSTD_compressionParameters cParams)
     CLAMPCHECK(cParams.searchLog, ZSTD_SEARCHLOG_MIN, ZSTD_SEARCHLOG_MAX);
     CLAMPCHECK(cParams.searchLength, ZSTD_SEARCHLENGTH_MIN, ZSTD_SEARCHLENGTH_MAX);
     CLAMPCHECK(cParams.targetLength, ZSTD_TARGETLENGTH_MIN, ZSTD_TARGETLENGTH_MAX);
-    if ((U32)(cParams.strategy) > (U32)ZSTD_btultra) return ERROR(compressionParameter_unsupported);
+    if ((U32)(cParams.strategy) > (U32)ZSTD_btultra)
+        return ERROR(parameter_unsupported);
     return 0;
 }
 
@@ -551,9 +528,7 @@ size_t ZSTD_estimateCCtxSize_advanced(ZSTD_compressionParameters cParams)
     size_t const hSize = ((size_t)1) << cParams.hashLog;
     U32    const hashLog3 = (cParams.searchLength>3) ? 0 : MIN(ZSTD_HASHLOG3_MAX, cParams.windowLog);
     size_t const h3Size = ((size_t)1) << hashLog3;
-    size_t const entropySpace = hufCTable_size + litlengthCTable_size
-                              + offcodeCTable_size + matchlengthCTable_size
-                              + entropyScratchSpace_size;
+    size_t const entropySpace = sizeof(ZSTD_entropyCTables_t);
     size_t const tableSpace = (chainSize + hSize + h3Size) * sizeof(U32);
 
     size_t const optBudget = ((MaxML+1) + (MaxLL+1) + (MaxOff+1) + (1<<Litbits))*sizeof(U32)
@@ -620,8 +595,8 @@ static size_t ZSTD_continueCCtx(ZSTD_CCtx* cctx, ZSTD_parameters params, U64 ple
     cctx->stage = ZSTDcs_init;
     cctx->dictID = 0;
     cctx->loadedDictEnd = 0;
-    { int i; for (i=0; i<ZSTD_REP_NUM; i++) cctx->rep[i] = repStartValue[i]; }
-    cctx->seqStore.litLengthSum = 0;  /* force reset of btopt stats */
+    { int i; for (i=0; i<ZSTD_REP_NUM; i++) cctx->seqStore.rep[i] = repStartValue[i]; }
+    cctx->optState.litLengthSum = 0;  /* force reset of btopt stats */
     XXH64_reset(&cctx->xxhState, 0);
     return 0;
 }
@@ -641,8 +616,10 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
     if (crp == ZSTDcrp_continue) {
         if (ZSTD_equivalentParams(params.cParams, zc->appliedParams.cParams)) {
             DEBUGLOG(5, "ZSTD_equivalentParams()==1");
-            zc->fseCTables_ready = 0;
-            zc->hufCTable_repeatMode = HUF_repeat_none;
+            zc->entropy->hufCTable_repeatMode = HUF_repeat_none;
+            zc->entropy->offcode_repeatMode = FSE_repeat_none;
+            zc->entropy->matchlength_repeatMode = FSE_repeat_none;
+            zc->entropy->litlength_repeatMode = FSE_repeat_none;
             return ZSTD_continueCCtx(zc, params, pledgedSrcSize);
     }   }
 
@@ -662,9 +639,7 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
         void* ptr;
 
         /* Check if workSpace is large enough, alloc a new one if needed */
-        {   size_t const entropySpace = hufCTable_size + litlengthCTable_size
-                                  + offcodeCTable_size + matchlengthCTable_size
-                                  + entropyScratchSpace_size;
+        {   size_t const entropySpace = sizeof(ZSTD_entropyCTables_t);
             size_t const optPotentialSpace = ((MaxML+1) + (MaxLL+1) + (MaxOff+1) + (1<<Litbits)) * sizeof(U32)
                                   + (ZSTD_OPT_NUM+1) * (sizeof(ZSTD_match_t)+sizeof(ZSTD_optimal_t));
             size_t const optSpace = ( (params.cParams.strategy == ZSTD_btopt)
@@ -689,16 +664,9 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
                 ptr = zc->workSpace;
 
                 /* entropy space */
-                zc->hufCTable = (HUF_CElt*)ptr;
-                ptr = (char*)zc->hufCTable + hufCTable_size;  /* note : HUF_CElt* is incomplete type, size is estimated via macro */
-                zc->offcodeCTable = (FSE_CTable*) ptr;
-                ptr = (char*)ptr + offcodeCTable_size;
-                zc->matchlengthCTable = (FSE_CTable*) ptr;
-                ptr = (char*)ptr + matchlengthCTable_size;
-                zc->litlengthCTable = (FSE_CTable*) ptr;
-                ptr = (char*)ptr + litlengthCTable_size;
-                assert(((size_t)ptr & 3) == 0);   /* ensure correct alignment */
-                zc->entropyScratchSpace = (unsigned*) ptr;
+                assert(((size_t)zc->workSpace & 3) == 0);   /* ensure correct alignment */
+                assert(zc->workSpaceSize >= sizeof(ZSTD_entropyCTables_t));
+                zc->entropy = (ZSTD_entropyCTables_t*)zc->workSpace;
         }   }
 
         /* init params */
@@ -715,39 +683,35 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
         zc->stage = ZSTDcs_init;
         zc->dictID = 0;
         zc->loadedDictEnd = 0;
-        zc->fseCTables_ready = 0;
-        zc->hufCTable_repeatMode = HUF_repeat_none;
+        zc->entropy->hufCTable_repeatMode = HUF_repeat_none;
+        zc->entropy->offcode_repeatMode = FSE_repeat_none;
+        zc->entropy->matchlength_repeatMode = FSE_repeat_none;
+        zc->entropy->litlength_repeatMode = FSE_repeat_none;
         zc->nextToUpdate = 1;
         zc->nextSrc = NULL;
         zc->base = NULL;
         zc->dictBase = NULL;
         zc->dictLimit = 0;
         zc->lowLimit = 0;
-        { int i; for (i=0; i<ZSTD_REP_NUM; i++) zc->rep[i] = repStartValue[i]; }
+        { int i; for (i=0; i<ZSTD_REP_NUM; i++) zc->seqStore.rep[i] = repStartValue[i]; }
         zc->hashLog3 = hashLog3;
-        zc->seqStore.litLengthSum = 0;
+        zc->optState.litLengthSum = 0;
 
-        /* ensure entropy tables are close together at the beginning */
-        assert((void*)zc->hufCTable == zc->workSpace);
-        assert((char*)zc->offcodeCTable == (char*)zc->hufCTable + hufCTable_size);
-        assert((char*)zc->matchlengthCTable == (char*)zc->offcodeCTable + offcodeCTable_size);
-        assert((char*)zc->litlengthCTable == (char*)zc->matchlengthCTable + matchlengthCTable_size);
-        assert((char*)zc->entropyScratchSpace == (char*)zc->litlengthCTable + litlengthCTable_size);
-        ptr = (char*)zc->entropyScratchSpace + entropyScratchSpace_size;
+        ptr = zc->entropy + 1;
 
         /* opt parser space */
         if ((params.cParams.strategy == ZSTD_btopt) || (params.cParams.strategy == ZSTD_btultra)) {
             DEBUGLOG(5, "reserving optimal parser space");
             assert(((size_t)ptr & 3) == 0);  /* ensure ptr is properly aligned */
-            zc->seqStore.litFreq = (U32*)ptr;
-            zc->seqStore.litLengthFreq = zc->seqStore.litFreq + (1<<Litbits);
-            zc->seqStore.matchLengthFreq = zc->seqStore.litLengthFreq + (MaxLL+1);
-            zc->seqStore.offCodeFreq = zc->seqStore.matchLengthFreq + (MaxML+1);
-            ptr = zc->seqStore.offCodeFreq + (MaxOff+1);
-            zc->seqStore.matchTable = (ZSTD_match_t*)ptr;
-            ptr = zc->seqStore.matchTable + ZSTD_OPT_NUM+1;
-            zc->seqStore.priceTable = (ZSTD_optimal_t*)ptr;
-            ptr = zc->seqStore.priceTable + ZSTD_OPT_NUM+1;
+            zc->optState.litFreq = (U32*)ptr;
+            zc->optState.litLengthFreq = zc->optState.litFreq + (1<<Litbits);
+            zc->optState.matchLengthFreq = zc->optState.litLengthFreq + (MaxLL+1);
+            zc->optState.offCodeFreq = zc->optState.matchLengthFreq + (MaxML+1);
+            ptr = zc->optState.offCodeFreq + (MaxOff+1);
+            zc->optState.matchTable = (ZSTD_match_t*)ptr;
+            ptr = zc->optState.matchTable + ZSTD_OPT_NUM+1;
+            zc->optState.priceTable = (ZSTD_optimal_t*)ptr;
+            ptr = zc->optState.priceTable + ZSTD_OPT_NUM+1;
         }
 
         /* table Space */
@@ -783,7 +747,7 @@ static size_t ZSTD_resetCCtx_internal(ZSTD_CCtx* zc,
  *        do not use with extDict variant ! */
 void ZSTD_invalidateRepCodes(ZSTD_CCtx* cctx) {
     int i;
-    for (i=0; i<ZSTD_REP_NUM; i++) cctx->rep[i] = 0;
+    for (i=0; i<ZSTD_REP_NUM; i++) cctx->seqStore.rep[i] = 0;
 }
 
 
@@ -830,16 +794,7 @@ static size_t ZSTD_copyCCtx_internal(ZSTD_CCtx* dstCCtx,
     dstCCtx->dictID       = srcCCtx->dictID;
 
     /* copy entropy tables */
-    dstCCtx->fseCTables_ready = srcCCtx->fseCTables_ready;
-    if (srcCCtx->fseCTables_ready) {
-        memcpy(dstCCtx->litlengthCTable, srcCCtx->litlengthCTable, litlengthCTable_size);
-        memcpy(dstCCtx->matchlengthCTable, srcCCtx->matchlengthCTable, matchlengthCTable_size);
-        memcpy(dstCCtx->offcodeCTable, srcCCtx->offcodeCTable, offcodeCTable_size);
-    }
-    dstCCtx->hufCTable_repeatMode = srcCCtx->hufCTable_repeatMode;
-    if (srcCCtx->hufCTable_repeatMode) {
-        memcpy(dstCCtx->hufCTable, srcCCtx->hufCTable, hufCTable_size);
-    }
+    memcpy(dstCCtx->entropy, srcCCtx->entropy, sizeof(ZSTD_entropyCTables_t));
 
     return 0;
 }
@@ -956,7 +911,8 @@ static size_t ZSTD_compressRleLiteralsBlock (void* dst, size_t dstCapacity, cons
 
 static size_t ZSTD_minGain(size_t srcSize) { return (srcSize >> 6) + 2; }
 
-static size_t ZSTD_compressLiterals (ZSTD_CCtx* zc,
+static size_t ZSTD_compressLiterals (ZSTD_entropyCTables_t * entropy,
+                                     ZSTD_strategy strategy,
                                      void* dst, size_t dstCapacity,
                                const void* src, size_t srcSize)
 {
@@ -970,28 +926,28 @@ static size_t ZSTD_compressLiterals (ZSTD_CCtx* zc,
 
     /* small ? don't even attempt compression (speed opt) */
 #   define LITERAL_NOENTROPY 63
-    {   size_t const minLitSize = zc->hufCTable_repeatMode == HUF_repeat_valid ? 6 : LITERAL_NOENTROPY;
+    {   size_t const minLitSize = entropy->hufCTable_repeatMode == HUF_repeat_valid ? 6 : LITERAL_NOENTROPY;
         if (srcSize <= minLitSize) return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);
     }
 
     if (dstCapacity < lhSize+1) return ERROR(dstSize_tooSmall);   /* not enough space for compression */
-    {   HUF_repeat repeat = zc->hufCTable_repeatMode;
-        int const preferRepeat = zc->appliedParams.cParams.strategy < ZSTD_lazy ? srcSize <= 1024 : 0;
+    {   HUF_repeat repeat = entropy->hufCTable_repeatMode;
+        int const preferRepeat = strategy < ZSTD_lazy ? srcSize <= 1024 : 0;
         if (repeat == HUF_repeat_valid && lhSize == 3) singleStream = 1;
         cLitSize = singleStream ? HUF_compress1X_repeat(ostart+lhSize, dstCapacity-lhSize, src, srcSize, 255, 11,
-                                      zc->entropyScratchSpace, entropyScratchSpace_size, zc->hufCTable, &repeat, preferRepeat)
+                                      entropy->workspace, sizeof(entropy->workspace), (HUF_CElt*)entropy->hufCTable, &repeat, preferRepeat)
                                 : HUF_compress4X_repeat(ostart+lhSize, dstCapacity-lhSize, src, srcSize, 255, 11,
-                                      zc->entropyScratchSpace, entropyScratchSpace_size, zc->hufCTable, &repeat, preferRepeat);
+                                      entropy->workspace, sizeof(entropy->workspace), (HUF_CElt*)entropy->hufCTable, &repeat, preferRepeat);
         if (repeat != HUF_repeat_none) { hType = set_repeat; }    /* reused the existing table */
-        else { zc->hufCTable_repeatMode = HUF_repeat_check; }       /* now have a table to reuse */
+        else { entropy->hufCTable_repeatMode = HUF_repeat_check; }       /* now have a table to reuse */
     }
 
-    if ((cLitSize==0) | (cLitSize >= srcSize - minGain)) {
-        zc->hufCTable_repeatMode = HUF_repeat_none;
+    if ((cLitSize==0) | (cLitSize >= srcSize - minGain) | ERR_isError(cLitSize)) {
+        entropy->hufCTable_repeatMode = HUF_repeat_none;
         return ZSTD_noCompressLiterals(dst, dstCapacity, src, srcSize);
     }
     if (cLitSize==1) {
-        zc->hufCTable_repeatMode = HUF_repeat_none;
+        entropy->hufCTable_repeatMode = HUF_repeat_none;
         return ZSTD_compressRleLiteralsBlock(dst, dstCapacity, src, srcSize);
     }
 
@@ -1062,17 +1018,154 @@ void ZSTD_seqToCodes(const seqStore_t* seqStorePtr)
         mlCodeTable[seqStorePtr->longLengthPos] = MaxML;
 }
 
-MEM_STATIC size_t ZSTD_compressSequences (ZSTD_CCtx* zc,
-                              void* dst, size_t dstCapacity,
-                              size_t srcSize)
+MEM_STATIC symbolEncodingType_e ZSTD_selectEncodingType(FSE_repeat* repeatMode,
+        size_t const mostFrequent, size_t nbSeq, U32 defaultNormLog)
 {
-    const int longOffsets = zc->appliedParams.cParams.windowLog > STREAM_ACCUMULATOR_MIN;
-    const seqStore_t* seqStorePtr = &(zc->seqStore);
+#define MIN_SEQ_FOR_DYNAMIC_FSE   64
+#define MAX_SEQ_FOR_STATIC_FSE  1000
+
+    if ((mostFrequent == nbSeq) && (nbSeq > 2)) {
+        *repeatMode = FSE_repeat_check;
+        return set_rle;
+    }
+    if ((*repeatMode == FSE_repeat_valid) && (nbSeq < MAX_SEQ_FOR_STATIC_FSE)) {
+        return set_repeat;
+    }
+    if ((nbSeq < MIN_SEQ_FOR_DYNAMIC_FSE) || (mostFrequent < (nbSeq >> (defaultNormLog-1)))) {
+        *repeatMode = FSE_repeat_valid;
+        return set_basic;
+    }
+    *repeatMode = FSE_repeat_check;
+    return set_compressed;
+}
+
+MEM_STATIC size_t ZSTD_buildCTable(void* dst, size_t dstCapacity,
+        FSE_CTable* CTable, U32 FSELog, symbolEncodingType_e type,
+        U32* count, U32 max,
+        BYTE const* codeTable, size_t nbSeq,
+        S16 const* defaultNorm, U32 defaultNormLog, U32 defaultMax,
+        void* workspace, size_t workspaceSize)
+{
+    BYTE* op = (BYTE*)dst;
+    BYTE const* const oend = op + dstCapacity;
+
+    switch (type) {
+    case set_rle:
+        *op = codeTable[0];
+        CHECK_F(FSE_buildCTable_rle(CTable, (BYTE)max));
+        return 1;
+    case set_repeat:
+        return 0;
+    case set_basic:
+        CHECK_F(FSE_buildCTable_wksp(CTable, defaultNorm, defaultMax, defaultNormLog, workspace, workspaceSize));
+        return 0;
+    case set_compressed: {
+        S16 norm[MaxSeq + 1];
+        size_t nbSeq_1 = nbSeq;
+        const U32 tableLog = FSE_optimalTableLog(FSELog, nbSeq, max);
+        if (count[codeTable[nbSeq-1]] > 1) {
+            count[codeTable[nbSeq-1]]--;
+            nbSeq_1--;
+        }
+        CHECK_F(FSE_normalizeCount(norm, tableLog, count, nbSeq_1, max));
+        {   size_t const NCountSize = FSE_writeNCount(op, oend - op, norm, max, tableLog);   /* overflow protected */
+            if (FSE_isError(NCountSize)) return NCountSize;
+            CHECK_F(FSE_buildCTable_wksp(CTable, norm, max, tableLog, workspace, workspaceSize));
+            return NCountSize;
+        }
+    }
+    default: return assert(0), ERROR(GENERIC);
+    }
+}
+
+MEM_STATIC size_t ZSTD_encodeSequences(void* dst, size_t dstCapacity,
+    FSE_CTable const* CTable_MatchLength, BYTE const* mlCodeTable,
+    FSE_CTable const* CTable_OffsetBits, BYTE const* ofCodeTable,
+    FSE_CTable const* CTable_LitLength, BYTE const* llCodeTable,
+    seqDef const* sequences, size_t nbSeq, int longOffsets)
+{
+    BIT_CStream_t blockStream;
+    FSE_CState_t  stateMatchLength;
+    FSE_CState_t  stateOffsetBits;
+    FSE_CState_t  stateLitLength;
+
+    CHECK_E(BIT_initCStream(&blockStream, dst, dstCapacity), dstSize_tooSmall); /* not enough space remaining */
+
+    /* first symbols */
+    FSE_initCState2(&stateMatchLength, CTable_MatchLength, mlCodeTable[nbSeq-1]);
+    FSE_initCState2(&stateOffsetBits,  CTable_OffsetBits,  ofCodeTable[nbSeq-1]);
+    FSE_initCState2(&stateLitLength,   CTable_LitLength,   llCodeTable[nbSeq-1]);
+    BIT_addBits(&blockStream, sequences[nbSeq-1].litLength, LL_bits[llCodeTable[nbSeq-1]]);
+    if (MEM_32bits()) BIT_flushBits(&blockStream);
+    BIT_addBits(&blockStream, sequences[nbSeq-1].matchLength, ML_bits[mlCodeTable[nbSeq-1]]);
+    if (MEM_32bits()) BIT_flushBits(&blockStream);
+    if (longOffsets) {
+        U32 const ofBits = ofCodeTable[nbSeq-1];
+        int const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1);
+        if (extraBits) {
+            BIT_addBits(&blockStream, sequences[nbSeq-1].offset, extraBits);
+            BIT_flushBits(&blockStream);
+        }
+        BIT_addBits(&blockStream, sequences[nbSeq-1].offset >> extraBits,
+                    ofBits - extraBits);
+    } else {
+        BIT_addBits(&blockStream, sequences[nbSeq-1].offset, ofCodeTable[nbSeq-1]);
+    }
+    BIT_flushBits(&blockStream);
+
+    {   size_t n;
+        for (n=nbSeq-2 ; n<nbSeq ; n--) {      /* intentional underflow */
+            BYTE const llCode = llCodeTable[n];
+            BYTE const ofCode = ofCodeTable[n];
+            BYTE const mlCode = mlCodeTable[n];
+            U32  const llBits = LL_bits[llCode];
+            U32  const ofBits = ofCode;                                     /* 32b*/  /* 64b*/
+            U32  const mlBits = ML_bits[mlCode];
+                                                                            /* (7)*/  /* (7)*/
+            FSE_encodeSymbol(&blockStream, &stateOffsetBits, ofCode);       /* 15 */  /* 15 */
+            FSE_encodeSymbol(&blockStream, &stateMatchLength, mlCode);      /* 24 */  /* 24 */
+            if (MEM_32bits()) BIT_flushBits(&blockStream);                  /* (7)*/
+            FSE_encodeSymbol(&blockStream, &stateLitLength, llCode);        /* 16 */  /* 33 */
+            if (MEM_32bits() || (ofBits+mlBits+llBits >= 64-7-(LLFSELog+MLFSELog+OffFSELog)))
+                BIT_flushBits(&blockStream);                                /* (7)*/
+            BIT_addBits(&blockStream, sequences[n].litLength, llBits);
+            if (MEM_32bits() && ((llBits+mlBits)>24)) BIT_flushBits(&blockStream);
+            BIT_addBits(&blockStream, sequences[n].matchLength, mlBits);
+            if (MEM_32bits()) BIT_flushBits(&blockStream);                  /* (7)*/
+            if (longOffsets) {
+                int const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1);
+                if (extraBits) {
+                    BIT_addBits(&blockStream, sequences[n].offset, extraBits);
+                    BIT_flushBits(&blockStream);                            /* (7)*/
+                }
+                BIT_addBits(&blockStream, sequences[n].offset >> extraBits,
+                            ofBits - extraBits);                            /* 31 */
+            } else {
+                BIT_addBits(&blockStream, sequences[n].offset, ofBits);     /* 31 */
+            }
+            BIT_flushBits(&blockStream);                                    /* (7)*/
+    }   }
+
+    FSE_flushCState(&blockStream, &stateMatchLength);
+    FSE_flushCState(&blockStream, &stateOffsetBits);
+    FSE_flushCState(&blockStream, &stateLitLength);
+
+    {   size_t const streamSize = BIT_closeCStream(&blockStream);
+        if (streamSize==0) return ERROR(dstSize_tooSmall);   /* not enough space */
+        return streamSize;
+    }
+}
+
+MEM_STATIC size_t ZSTD_compressSequences_internal(seqStore_t* seqStorePtr,
+                              ZSTD_entropyCTables_t* entropy,
+                              ZSTD_compressionParameters const* cParams,
+                              void* dst, size_t dstCapacity)
+{
+    const int longOffsets = cParams->windowLog > STREAM_ACCUMULATOR_MIN;
     U32 count[MaxSeq+1];
-    S16 norm[MaxSeq+1];
-    FSE_CTable* CTable_LitLength = zc->litlengthCTable;
-    FSE_CTable* CTable_OffsetBits = zc->offcodeCTable;
-    FSE_CTable* CTable_MatchLength = zc->matchlengthCTable;
+    FSE_CTable* CTable_LitLength = entropy->litlengthCTable;
+    FSE_CTable* CTable_OffsetBits = entropy->offcodeCTable;
+    FSE_CTable* CTable_MatchLength = entropy->matchlengthCTable;
     U32 LLtype, Offtype, MLtype;   /* compressed, raw or rle */
     const seqDef* const sequences = seqStorePtr->sequencesStart;
     const BYTE* const ofCodeTable = seqStorePtr->ofCode;
@@ -1083,13 +1176,16 @@ MEM_STATIC size_t ZSTD_compressSequences (ZSTD_CCtx* zc,
     BYTE* op = ostart;
     size_t const nbSeq = seqStorePtr->sequences - seqStorePtr->sequencesStart;
     BYTE* seqHead;
-    BYTE scratchBuffer[1<<MAX(MLFSELog,LLFSELog)];
+
+    ZSTD_STATIC_ASSERT(sizeof(entropy->workspace) >= (1<<MAX(MLFSELog,LLFSELog)));
 
     /* Compress literals */
     {   const BYTE* const literals = seqStorePtr->litStart;
         size_t const litSize = seqStorePtr->lit - literals;
-        size_t const cSize = ZSTD_compressLiterals(zc, op, dstCapacity, literals, litSize);
-        if (ZSTD_isError(cSize)) return cSize;
+        size_t const cSize = ZSTD_compressLiterals(
+                entropy, cParams->strategy, op, dstCapacity, literals, litSize);
+        if (ZSTD_isError(cSize))
+          return cSize;
         op += cSize;
     }
 
@@ -1098,179 +1194,91 @@ MEM_STATIC size_t ZSTD_compressSequences (ZSTD_CCtx* zc,
     if (nbSeq < 0x7F) *op++ = (BYTE)nbSeq;
     else if (nbSeq < LONGNBSEQ) op[0] = (BYTE)((nbSeq>>8) + 0x80), op[1] = (BYTE)nbSeq, op+=2;
     else op[0]=0xFF, MEM_writeLE16(op+1, (U16)(nbSeq - LONGNBSEQ)), op+=3;
-    if (nbSeq==0) goto _check_compressibility;
+    if (nbSeq==0) return op - ostart;
 
     /* seqHead : flags for FSE encoding type */
     seqHead = op++;
 
-#define MIN_SEQ_FOR_DYNAMIC_FSE   64
-#define MAX_SEQ_FOR_STATIC_FSE  1000
-
     /* convert length/distances into codes */
     ZSTD_seqToCodes(seqStorePtr);
-
     /* CTable for Literal Lengths */
     {   U32 max = MaxLL;
-        size_t const mostFrequent = FSE_countFast_wksp(count, &max, llCodeTable, nbSeq, zc->entropyScratchSpace);
-        if ((mostFrequent == nbSeq) && (nbSeq > 2)) {
-            *op++ = llCodeTable[0];
-            FSE_buildCTable_rle(CTable_LitLength, (BYTE)max);
-            LLtype = set_rle;
-        } else if ((zc->fseCTables_ready) && (nbSeq < MAX_SEQ_FOR_STATIC_FSE)) {
-            LLtype = set_repeat;
-        } else if ((nbSeq < MIN_SEQ_FOR_DYNAMIC_FSE) || (mostFrequent < (nbSeq >> (LL_defaultNormLog-1)))) {
-            FSE_buildCTable_wksp(CTable_LitLength, LL_defaultNorm, MaxLL, LL_defaultNormLog, scratchBuffer, sizeof(scratchBuffer));
-            LLtype = set_basic;
-        } else {
-            size_t nbSeq_1 = nbSeq;
-            const U32 tableLog = FSE_optimalTableLog(LLFSELog, nbSeq, max);
-            if (count[llCodeTable[nbSeq-1]]>1) { count[llCodeTable[nbSeq-1]]--; nbSeq_1--; }
-            FSE_normalizeCount(norm, tableLog, count, nbSeq_1, max);
-            { size_t const NCountSize = FSE_writeNCount(op, oend-op, norm, max, tableLog);   /* overflow protected */
-              if (FSE_isError(NCountSize)) return NCountSize;
-              op += NCountSize; }
-            FSE_buildCTable_wksp(CTable_LitLength, norm, max, tableLog, scratchBuffer, sizeof(scratchBuffer));
-            LLtype = set_compressed;
+        size_t const mostFrequent = FSE_countFast_wksp(count, &max, llCodeTable, nbSeq, entropy->workspace);
+        LLtype = ZSTD_selectEncodingType(&entropy->litlength_repeatMode, mostFrequent, nbSeq, LL_defaultNormLog);
+        {   size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_LitLength, LLFSELog, (symbolEncodingType_e)LLtype,
+                    count, max, llCodeTable, nbSeq, LL_defaultNorm, LL_defaultNormLog, MaxLL,
+                    entropy->workspace, sizeof(entropy->workspace));
+            if (ZSTD_isError(countSize)) return countSize;
+            op += countSize;
     }   }
-
     /* CTable for Offsets */
     {   U32 max = MaxOff;
-        size_t const mostFrequent = FSE_countFast_wksp(count, &max, ofCodeTable, nbSeq, zc->entropyScratchSpace);
-        if ((mostFrequent == nbSeq) && (nbSeq > 2)) {
-            *op++ = ofCodeTable[0];
-            FSE_buildCTable_rle(CTable_OffsetBits, (BYTE)max);
-            Offtype = set_rle;
-        } else if ((zc->fseCTables_ready) && (nbSeq < MAX_SEQ_FOR_STATIC_FSE)) {
-            Offtype = set_repeat;
-        } else if ((nbSeq < MIN_SEQ_FOR_DYNAMIC_FSE) || (mostFrequent < (nbSeq >> (OF_defaultNormLog-1)))) {
-            FSE_buildCTable_wksp(CTable_OffsetBits, OF_defaultNorm, MaxOff, OF_defaultNormLog, scratchBuffer, sizeof(scratchBuffer));
-            Offtype = set_basic;
-        } else {
-            size_t nbSeq_1 = nbSeq;
-            const U32 tableLog = FSE_optimalTableLog(OffFSELog, nbSeq, max);
-            if (count[ofCodeTable[nbSeq-1]]>1) { count[ofCodeTable[nbSeq-1]]--; nbSeq_1--; }
-            FSE_normalizeCount(norm, tableLog, count, nbSeq_1, max);
-            { size_t const NCountSize = FSE_writeNCount(op, oend-op, norm, max, tableLog);   /* overflow protected */
-              if (FSE_isError(NCountSize)) return NCountSize;
-              op += NCountSize; }
-            FSE_buildCTable_wksp(CTable_OffsetBits, norm, max, tableLog, scratchBuffer, sizeof(scratchBuffer));
-            Offtype = set_compressed;
+        size_t const mostFrequent = FSE_countFast_wksp(count, &max, ofCodeTable, nbSeq, entropy->workspace);
+        Offtype = ZSTD_selectEncodingType(&entropy->offcode_repeatMode, mostFrequent, nbSeq, OF_defaultNormLog);
+        {   size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_OffsetBits, OffFSELog, (symbolEncodingType_e)Offtype,
+                    count, max, ofCodeTable, nbSeq, OF_defaultNorm, OF_defaultNormLog, MaxOff,
+                    entropy->workspace, sizeof(entropy->workspace));
+            if (ZSTD_isError(countSize)) return countSize;
+            op += countSize;
     }   }
-
     /* CTable for MatchLengths */
     {   U32 max = MaxML;
-        size_t const mostFrequent = FSE_countFast_wksp(count, &max, mlCodeTable, nbSeq, zc->entropyScratchSpace);
-        if ((mostFrequent == nbSeq) && (nbSeq > 2)) {
-            *op++ = *mlCodeTable;
-            FSE_buildCTable_rle(CTable_MatchLength, (BYTE)max);
-            MLtype = set_rle;
-        } else if ((zc->fseCTables_ready) && (nbSeq < MAX_SEQ_FOR_STATIC_FSE)) {
-            MLtype = set_repeat;
-        } else if ((nbSeq < MIN_SEQ_FOR_DYNAMIC_FSE) || (mostFrequent < (nbSeq >> (ML_defaultNormLog-1)))) {
-            FSE_buildCTable_wksp(CTable_MatchLength, ML_defaultNorm, MaxML, ML_defaultNormLog, scratchBuffer, sizeof(scratchBuffer));
-            MLtype = set_basic;
-        } else {
-            size_t nbSeq_1 = nbSeq;
-            const U32 tableLog = FSE_optimalTableLog(MLFSELog, nbSeq, max);
-            if (count[mlCodeTable[nbSeq-1]]>1) { count[mlCodeTable[nbSeq-1]]--; nbSeq_1--; }
-            FSE_normalizeCount(norm, tableLog, count, nbSeq_1, max);
-            { size_t const NCountSize = FSE_writeNCount(op, oend-op, norm, max, tableLog);   /* overflow protected */
-              if (FSE_isError(NCountSize)) return NCountSize;
-              op += NCountSize; }
-            FSE_buildCTable_wksp(CTable_MatchLength, norm, max, tableLog, scratchBuffer, sizeof(scratchBuffer));
-            MLtype = set_compressed;
+        size_t const mostFrequent = FSE_countFast_wksp(count, &max, mlCodeTable, nbSeq, entropy->workspace);
+        MLtype = ZSTD_selectEncodingType(&entropy->matchlength_repeatMode, mostFrequent, nbSeq, ML_defaultNormLog);
+        {   size_t const countSize = ZSTD_buildCTable(op, oend - op, CTable_MatchLength, MLFSELog, (symbolEncodingType_e)MLtype,
+                    count, max, mlCodeTable, nbSeq, ML_defaultNorm, ML_defaultNormLog, MaxML,
+                    entropy->workspace, sizeof(entropy->workspace));
+            if (ZSTD_isError(countSize)) return countSize;
+            op += countSize;
     }   }
 
     *seqHead = (BYTE)((LLtype<<6) + (Offtype<<4) + (MLtype<<2));
-    zc->fseCTables_ready = 0;
 
-    /* Encoding Sequences */
-    {   BIT_CStream_t blockStream;
-        FSE_CState_t  stateMatchLength;
-        FSE_CState_t  stateOffsetBits;
-        FSE_CState_t  stateLitLength;
-
-        CHECK_E(BIT_initCStream(&blockStream, op, oend-op), dstSize_tooSmall); /* not enough space remaining */
-
-        /* first symbols */
-        FSE_initCState2(&stateMatchLength, CTable_MatchLength, mlCodeTable[nbSeq-1]);
-        FSE_initCState2(&stateOffsetBits,  CTable_OffsetBits,  ofCodeTable[nbSeq-1]);
-        FSE_initCState2(&stateLitLength,   CTable_LitLength,   llCodeTable[nbSeq-1]);
-        BIT_addBits(&blockStream, sequences[nbSeq-1].litLength, LL_bits[llCodeTable[nbSeq-1]]);
-        if (MEM_32bits()) BIT_flushBits(&blockStream);
-        BIT_addBits(&blockStream, sequences[nbSeq-1].matchLength, ML_bits[mlCodeTable[nbSeq-1]]);
-        if (MEM_32bits()) BIT_flushBits(&blockStream);
-        if (longOffsets) {
-            U32 const ofBits = ofCodeTable[nbSeq-1];
-            int const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1);
-            if (extraBits) {
-                BIT_addBits(&blockStream, sequences[nbSeq-1].offset, extraBits);
-                BIT_flushBits(&blockStream);
-            }
-            BIT_addBits(&blockStream, sequences[nbSeq-1].offset >> extraBits,
-                        ofBits - extraBits);
-        } else {
-            BIT_addBits(&blockStream, sequences[nbSeq-1].offset, ofCodeTable[nbSeq-1]);
-        }
-        BIT_flushBits(&blockStream);
-
-        {   size_t n;
-            for (n=nbSeq-2 ; n<nbSeq ; n--) {      /* intentional underflow */
-                BYTE const llCode = llCodeTable[n];
-                BYTE const ofCode = ofCodeTable[n];
-                BYTE const mlCode = mlCodeTable[n];
-                U32  const llBits = LL_bits[llCode];
-                U32  const ofBits = ofCode;                                     /* 32b*/  /* 64b*/
-                U32  const mlBits = ML_bits[mlCode];
-                                                                                /* (7)*/  /* (7)*/
-                FSE_encodeSymbol(&blockStream, &stateOffsetBits, ofCode);       /* 15 */  /* 15 */
-                FSE_encodeSymbol(&blockStream, &stateMatchLength, mlCode);      /* 24 */  /* 24 */
-                if (MEM_32bits()) BIT_flushBits(&blockStream);                  /* (7)*/
-                FSE_encodeSymbol(&blockStream, &stateLitLength, llCode);        /* 16 */  /* 33 */
-                if (MEM_32bits() || (ofBits+mlBits+llBits >= 64-7-(LLFSELog+MLFSELog+OffFSELog)))
-                    BIT_flushBits(&blockStream);                                /* (7)*/
-                BIT_addBits(&blockStream, sequences[n].litLength, llBits);
-                if (MEM_32bits() && ((llBits+mlBits)>24)) BIT_flushBits(&blockStream);
-                BIT_addBits(&blockStream, sequences[n].matchLength, mlBits);
-                if (MEM_32bits()) BIT_flushBits(&blockStream);                  /* (7)*/
-                if (longOffsets) {
-                    int const extraBits = ofBits - MIN(ofBits, STREAM_ACCUMULATOR_MIN-1);
-                    if (extraBits) {
-                        BIT_addBits(&blockStream, sequences[n].offset, extraBits);
-                        BIT_flushBits(&blockStream);                            /* (7)*/
-                    }
-                    BIT_addBits(&blockStream, sequences[n].offset >> extraBits,
-                                ofBits - extraBits);                            /* 31 */
-                } else {
-                    BIT_addBits(&blockStream, sequences[n].offset, ofBits);     /* 31 */
-                }
-                BIT_flushBits(&blockStream);                                    /* (7)*/
-        }   }
-
-        FSE_flushCState(&blockStream, &stateMatchLength);
-        FSE_flushCState(&blockStream, &stateOffsetBits);
-        FSE_flushCState(&blockStream, &stateLitLength);
-
-        {   size_t const streamSize = BIT_closeCStream(&blockStream);
-            if (streamSize==0) return ERROR(dstSize_tooSmall);   /* not enough space */
-            op += streamSize;
-    }   }
-
-    /* check compressibility */
-_check_compressibility:
-    {   size_t const minGain = ZSTD_minGain(srcSize);
-        size_t const maxCSize = srcSize - minGain;
-        if ((size_t)(op-ostart) >= maxCSize) {
-            zc->hufCTable_repeatMode = HUF_repeat_none;
-            return 0;
-    }   }
-
-    /* confirm repcodes */
-    { int i; for (i=0; i<ZSTD_REP_NUM; i++) zc->rep[i] = zc->repToConfirm[i]; }
+    {   size_t const streamSize = ZSTD_encodeSequences(op, oend - op,
+                CTable_MatchLength, mlCodeTable,
+                CTable_OffsetBits, ofCodeTable,
+                CTable_LitLength, llCodeTable,
+                sequences, nbSeq, longOffsets);
+        if (ZSTD_isError(streamSize)) return streamSize;
+        op += streamSize;
+    }
 
     return op - ostart;
 }
 
+MEM_STATIC size_t ZSTD_compressSequences(seqStore_t* seqStorePtr,
+                              ZSTD_entropyCTables_t* entropy,
+                              ZSTD_compressionParameters const* cParams,
+                              void* dst, size_t dstCapacity,
+                              size_t srcSize)
+{
+    size_t const cSize = ZSTD_compressSequences_internal(seqStorePtr, entropy, cParams,
+                                                         dst, dstCapacity);
+    size_t const minGain = ZSTD_minGain(srcSize);
+    size_t const maxCSize = srcSize - minGain;
+    /* If the srcSize <= dstCapacity, then there is enough space to write a
+     * raw uncompressed block. Since we ran out of space, the block must not
+     * be compressible, so fall back to a raw uncompressed block.
+     */
+    int const uncompressibleError = cSize == ERROR(dstSize_tooSmall) && srcSize <= dstCapacity;
+
+    if (ZSTD_isError(cSize) && !uncompressibleError)
+        return cSize;
+    /* Check compressibility */
+    if (cSize >= maxCSize || uncompressibleError) {
+        entropy->hufCTable_repeatMode = HUF_repeat_none;
+        entropy->offcode_repeatMode = FSE_repeat_none;
+        entropy->matchlength_repeatMode = FSE_repeat_none;
+        entropy->litlength_repeatMode = FSE_repeat_none;
+        return 0;
+    }
+    assert(!ZSTD_isError(cSize));
+
+    /* confirm repcodes */
+    { int i; for (i=0; i<ZSTD_REP_NUM; i++) seqStorePtr->rep[i] = seqStorePtr->repToConfirm[i]; }
+    return cSize;
+}
+
 
 /*! ZSTD_storeSeq() :
     Store a sequence (literal length, literals, offset code and match length code) into seqStore_t.
@@ -1475,7 +1483,7 @@ static void ZSTD_fillHashTable (ZSTD_CCtx* zc, const void* end, const U32 mls)
 }
 
 
-FORCE_INLINE
+FORCE_INLINE_TEMPLATE
 void ZSTD_compressBlock_fast_generic(ZSTD_CCtx* cctx,
                                const void* src, size_t srcSize,
                                const U32 mls)
@@ -1491,7 +1499,7 @@ void ZSTD_compressBlock_fast_generic(ZSTD_CCtx* cctx,
     const BYTE* const lowest = base + lowestIndex;
     const BYTE* const iend = istart + srcSize;
     const BYTE* const ilimit = iend - HASH_READ_SIZE;
-    U32 offset_1=cctx->rep[0], offset_2=cctx->rep[1];
+    U32 offset_1=seqStorePtr->rep[0], offset_2=seqStorePtr->rep[1];
     U32 offsetSaved = 0;
 
     /* init */
@@ -1552,8 +1560,8 @@ void ZSTD_compressBlock_fast_generic(ZSTD_CCtx* cctx,
     }   }   }
 
     /* save reps for next block */
-    cctx->repToConfirm[0] = offset_1 ? offset_1 : offsetSaved;
-    cctx->repToConfirm[1] = offset_2 ? offset_2 : offsetSaved;
+    seqStorePtr->repToConfirm[0] = offset_1 ? offset_1 : offsetSaved;
+    seqStorePtr->repToConfirm[1] = offset_2 ? offset_2 : offsetSaved;
 
     /* Last Literals */
     {   size_t const lastLLSize = iend - anchor;
@@ -1601,7 +1609,7 @@ static void ZSTD_compressBlock_fast_extDict_generic(ZSTD_CCtx* ctx,
     const BYTE* const dictEnd = dictBase + dictLimit;
     const BYTE* const iend = istart + srcSize;
     const BYTE* const ilimit = iend - 8;
-    U32 offset_1=ctx->rep[0], offset_2=ctx->rep[1];
+    U32 offset_1=seqStorePtr->rep[0], offset_2=seqStorePtr->rep[1];
 
     /* Search Loop */
     while (ip < ilimit) {  /* < instead of <=, because (ip+1) */
@@ -1667,7 +1675,7 @@ static void ZSTD_compressBlock_fast_extDict_generic(ZSTD_CCtx* ctx,
     }   }   }
 
     /* save reps for next block */
-    ctx->repToConfirm[0] = offset_1; ctx->repToConfirm[1] = offset_2;
+    seqStorePtr->repToConfirm[0] = offset_1; seqStorePtr->repToConfirm[1] = offset_2;
 
     /* Last Literals */
     {   size_t const lastLLSize = iend - anchor;
@@ -1718,7 +1726,7 @@ static void ZSTD_fillDoubleHashTable (ZSTD_CCtx* cctx, const void* end, const U3
 }
 
 
-FORCE_INLINE
+FORCE_INLINE_TEMPLATE
 void ZSTD_compressBlock_doubleFast_generic(ZSTD_CCtx* cctx,
                                  const void* src, size_t srcSize,
                                  const U32 mls)
@@ -1736,7 +1744,7 @@ void ZSTD_compressBlock_doubleFast_generic(ZSTD_CCtx* cctx,
     const BYTE* const lowest = base + lowestIndex;
     const BYTE* const iend = istart + srcSize;
     const BYTE* const ilimit = iend - HASH_READ_SIZE;
-    U32 offset_1=cctx->rep[0], offset_2=cctx->rep[1];
+    U32 offset_1=seqStorePtr->rep[0], offset_2=seqStorePtr->rep[1];
     U32 offsetSaved = 0;
 
     /* init */
@@ -1823,8 +1831,8 @@ void ZSTD_compressBlock_doubleFast_generic(ZSTD_CCtx* cctx,
     }   }   }
 
     /* save reps for next block */
-    cctx->repToConfirm[0] = offset_1 ? offset_1 : offsetSaved;
-    cctx->repToConfirm[1] = offset_2 ? offset_2 : offsetSaved;
+    seqStorePtr->repToConfirm[0] = offset_1 ? offset_1 : offsetSaved;
+    seqStorePtr->repToConfirm[1] = offset_2 ? offset_2 : offsetSaved;
 
     /* Last Literals */
     {   size_t const lastLLSize = iend - anchor;
@@ -1873,7 +1881,7 @@ static void ZSTD_compressBlock_doubleFast_extDict_generic(ZSTD_CCtx* ctx,
     const BYTE* const dictEnd = dictBase + dictLimit;
     const BYTE* const iend = istart + srcSize;
     const BYTE* const ilimit = iend - 8;
-    U32 offset_1=ctx->rep[0], offset_2=ctx->rep[1];
+    U32 offset_1=seqStorePtr->rep[0], offset_2=seqStorePtr->rep[1];
 
     /* Search Loop */
     while (ip < ilimit) {  /* < instead of <=, because (ip+1) */
@@ -1973,7 +1981,7 @@ static void ZSTD_compressBlock_doubleFast_extDict_generic(ZSTD_CCtx* ctx,
     }   }   }
 
     /* save reps for next block */
-    ctx->repToConfirm[0] = offset_1; ctx->repToConfirm[1] = offset_2;
+    seqStorePtr->repToConfirm[0] = offset_1; seqStorePtr->repToConfirm[1] = offset_2;
 
     /* Last Literals */
     {   size_t const lastLLSize = iend - anchor;
@@ -2276,7 +2284,7 @@ static size_t ZSTD_BtFindBestMatch_selectMLS_extDict (
 
 /* Update chains up to ip (excluded)
    Assumption : always within prefix (i.e. not within extDict) */
-FORCE_INLINE
+FORCE_INLINE_TEMPLATE
 U32 ZSTD_insertAndFindFirstIndex (ZSTD_CCtx* zc, const BYTE* ip, U32 mls)
 {
     U32* const hashTable  = zc->hashTable;
@@ -2300,7 +2308,7 @@ U32 ZSTD_insertAndFindFirstIndex (ZSTD_CCtx* zc, const BYTE* ip, U32 mls)
 
 
 /* inlining is important to hardwire a hot branch (template emulation) */
-FORCE_INLINE
+FORCE_INLINE_TEMPLATE
 size_t ZSTD_HcFindBestMatch_generic (
                         ZSTD_CCtx* zc,   /* Index table will be updated */
                         const BYTE* const ip, const BYTE* const iLimit,
@@ -2352,7 +2360,7 @@ size_t ZSTD_HcFindBestMatch_generic (
 }
 
 
-FORCE_INLINE size_t ZSTD_HcFindBestMatch_selectMLS (
+FORCE_INLINE_TEMPLATE size_t ZSTD_HcFindBestMatch_selectMLS (
                         ZSTD_CCtx* zc,
                         const BYTE* ip, const BYTE* const iLimit,
                         size_t* offsetPtr,
@@ -2369,7 +2377,7 @@ FORCE_INLINE size_t ZSTD_HcFindBestMatch_selectMLS (
 }
 
 
-FORCE_INLINE size_t ZSTD_HcFindBestMatch_extDict_selectMLS (
+FORCE_INLINE_TEMPLATE size_t ZSTD_HcFindBestMatch_extDict_selectMLS (
                         ZSTD_CCtx* zc,
                         const BYTE* ip, const BYTE* const iLimit,
                         size_t* offsetPtr,
@@ -2389,7 +2397,7 @@ FORCE_INLINE size_t ZSTD_HcFindBestMatch_extDict_selectMLS (
 /* *******************************
 *  Common parser - lazy strategy
 *********************************/
-FORCE_INLINE
+FORCE_INLINE_TEMPLATE
 void ZSTD_compressBlock_lazy_generic(ZSTD_CCtx* ctx,
                                      const void* src, size_t srcSize,
                                      const U32 searchMethod, const U32 depth)
@@ -2409,7 +2417,7 @@ void ZSTD_compressBlock_lazy_generic(ZSTD_CCtx* ctx,
                         size_t* offsetPtr,
                         U32 maxNbAttempts, U32 matchLengthSearch);
     searchMax_f const searchMax = searchMethod ? ZSTD_BtFindBestMatch_selectMLS : ZSTD_HcFindBestMatch_selectMLS;
-    U32 offset_1 = ctx->rep[0], offset_2 = ctx->rep[1], savedOffset=0;
+    U32 offset_1 = seqStorePtr->rep[0], offset_2 = seqStorePtr->rep[1], savedOffset=0;
 
     /* init */
     ip += (ip==base);
@@ -2519,8 +2527,8 @@ _storeSequence:
     }   }
 
     /* Save reps for next block */
-    ctx->repToConfirm[0] = offset_1 ? offset_1 : savedOffset;
-    ctx->repToConfirm[1] = offset_2 ? offset_2 : savedOffset;
+    seqStorePtr->repToConfirm[0] = offset_1 ? offset_1 : savedOffset;
+    seqStorePtr->repToConfirm[1] = offset_2 ? offset_2 : savedOffset;
 
     /* Last Literals */
     {   size_t const lastLLSize = iend - anchor;
@@ -2551,7 +2559,7 @@ static void ZSTD_compressBlock_greedy(ZSTD_CCtx* ctx, const void* src, size_t sr
 }
 
 
-FORCE_INLINE
+FORCE_INLINE_TEMPLATE
 void ZSTD_compressBlock_lazy_extDict_generic(ZSTD_CCtx* ctx,
                                      const void* src, size_t srcSize,
                                      const U32 searchMethod, const U32 depth)
@@ -2578,7 +2586,7 @@ void ZSTD_compressBlock_lazy_extDict_generic(ZSTD_CCtx* ctx,
                         U32 maxNbAttempts, U32 matchLengthSearch);
     searchMax_f searchMax = searchMethod ? ZSTD_BtFindBestMatch_selectMLS_extDict : ZSTD_HcFindBestMatch_extDict_selectMLS;
 
-    U32 offset_1 = ctx->rep[0], offset_2 = ctx->rep[1];
+    U32 offset_1 = seqStorePtr->rep[0], offset_2 = seqStorePtr->rep[1];
 
     /* init */
     ctx->nextToUpdate3 = ctx->nextToUpdate;
@@ -2714,7 +2722,7 @@ _storeSequence:
     }   }
 
     /* Save reps for next block */
-    ctx->repToConfirm[0] = offset_1; ctx->repToConfirm[1] = offset_2;
+    seqStorePtr->repToConfirm[0] = offset_1; seqStorePtr->repToConfirm[1] = offset_2;
 
     /* Last Literals */
     {   size_t const lastLLSize = iend - anchor;
@@ -2823,7 +2831,7 @@ static size_t ZSTD_compressBlock_internal(ZSTD_CCtx* zc, void* dst, size_t dstCa
     if (current > zc->nextToUpdate + 384)
         zc->nextToUpdate = current - MIN(192, (U32)(current - zc->nextToUpdate - 384));   /* limited update after finding a very long match */
     blockCompressor(zc, src, srcSize);
-    return ZSTD_compressSequences(zc, dst, dstCapacity, srcSize);
+    return ZSTD_compressSequences(&zc->seqStore, zc->entropy, &zc->appliedParams.cParams, dst, dstCapacity, srcSize);
 }
 
 
@@ -3000,7 +3008,6 @@ static size_t ZSTD_compressContinue_internal (ZSTD_CCtx* cctx,
         return fhSize;
 }
 
-
 size_t ZSTD_compressContinue (ZSTD_CCtx* cctx,
                               void* dst, size_t dstCapacity,
                         const void* src, size_t srcSize)
@@ -3106,13 +3113,14 @@ static size_t ZSTD_loadZstdDictionary(ZSTD_CCtx* cctx, const void* dict, size_t
     const BYTE* const dictEnd = dictPtr + dictSize;
     short offcodeNCount[MaxOff+1];
     unsigned offcodeMaxValue = MaxOff;
-    BYTE scratchBuffer[1<<MAX(MLFSELog,LLFSELog)];
+
+    ZSTD_STATIC_ASSERT(sizeof(cctx->entropy->workspace) >= (1<<MAX(MLFSELog,LLFSELog)));
 
     dictPtr += 4;   /* skip magic number */
     cctx->dictID = cctx->appliedParams.fParams.noDictIDFlag ? 0 :  MEM_readLE32(dictPtr);
     dictPtr += 4;
 
-    {   size_t const hufHeaderSize = HUF_readCTable(cctx->hufCTable, 255, dictPtr, dictEnd-dictPtr);
+    {   size_t const hufHeaderSize = HUF_readCTable((HUF_CElt*)cctx->entropy->hufCTable, 255, dictPtr, dictEnd-dictPtr);
         if (HUF_isError(hufHeaderSize)) return ERROR(dictionary_corrupted);
         dictPtr += hufHeaderSize;
     }
@@ -3122,7 +3130,7 @@ static size_t ZSTD_loadZstdDictionary(ZSTD_CCtx* cctx, const void* dict, size_t
         if (FSE_isError(offcodeHeaderSize)) return ERROR(dictionary_corrupted);
         if (offcodeLog > OffFSELog) return ERROR(dictionary_corrupted);
         /* Defer checking offcodeMaxValue because we need to know the size of the dictionary content */
-        CHECK_E( FSE_buildCTable_wksp(cctx->offcodeCTable, offcodeNCount, offcodeMaxValue, offcodeLog, scratchBuffer, sizeof(scratchBuffer)),
+        CHECK_E( FSE_buildCTable_wksp(cctx->entropy->offcodeCTable, offcodeNCount, offcodeMaxValue, offcodeLog, cctx->entropy->workspace, sizeof(cctx->entropy->workspace)),
                  dictionary_corrupted);
         dictPtr += offcodeHeaderSize;
     }
@@ -3134,7 +3142,7 @@ static size_t ZSTD_loadZstdDictionary(ZSTD_CCtx* cctx, const void* dict, size_t
         if (matchlengthLog > MLFSELog) return ERROR(dictionary_corrupted);
         /* Every match length code must have non-zero probability */
         CHECK_F( ZSTD_checkDictNCount(matchlengthNCount, matchlengthMaxValue, MaxML));
-        CHECK_E( FSE_buildCTable_wksp(cctx->matchlengthCTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog, scratchBuffer, sizeof(scratchBuffer)),
+        CHECK_E( FSE_buildCTable_wksp(cctx->entropy->matchlengthCTable, matchlengthNCount, matchlengthMaxValue, matchlengthLog, cctx->entropy->workspace, sizeof(cctx->entropy->workspace)),
                  dictionary_corrupted);
         dictPtr += matchlengthHeaderSize;
     }
@@ -3146,15 +3154,15 @@ static size_t ZSTD_loadZstdDictionary(ZSTD_CCtx* cctx, const void* dict, size_t
         if (litlengthLog > LLFSELog) return ERROR(dictionary_corrupted);
         /* Every literal length code must have non-zero probability */
         CHECK_F( ZSTD_checkDictNCount(litlengthNCount, litlengthMaxValue, MaxLL));
-        CHECK_E( FSE_buildCTable_wksp(cctx->litlengthCTable, litlengthNCount, litlengthMaxValue, litlengthLog, scratchBuffer, sizeof(scratchBuffer)),
+        CHECK_E( FSE_buildCTable_wksp(cctx->entropy->litlengthCTable, litlengthNCount, litlengthMaxValue, litlengthLog, cctx->entropy->workspace, sizeof(cctx->entropy->workspace)),
                  dictionary_corrupted);
         dictPtr += litlengthHeaderSize;
     }
 
     if (dictPtr+12 > dictEnd) return ERROR(dictionary_corrupted);
-    cctx->rep[0] = MEM_readLE32(dictPtr+0);
-    cctx->rep[1] = MEM_readLE32(dictPtr+4);
-    cctx->rep[2] = MEM_readLE32(dictPtr+8);
+    cctx->seqStore.rep[0] = MEM_readLE32(dictPtr+0);
+    cctx->seqStore.rep[1] = MEM_readLE32(dictPtr+4);
+    cctx->seqStore.rep[2] = MEM_readLE32(dictPtr+8);
     dictPtr += 12;
 
     {   size_t const dictContentSize = (size_t)(dictEnd - dictPtr);
@@ -3168,12 +3176,14 @@ static size_t ZSTD_loadZstdDictionary(ZSTD_CCtx* cctx, const void* dict, size_t
         /* All repCodes must be <= dictContentSize and != 0*/
         {   U32 u;
             for (u=0; u<3; u++) {
-                if (cctx->rep[u] == 0) return ERROR(dictionary_corrupted);
-                if (cctx->rep[u] > dictContentSize) return ERROR(dictionary_corrupted);
+                if (cctx->seqStore.rep[u] == 0) return ERROR(dictionary_corrupted);
+                if (cctx->seqStore.rep[u] > dictContentSize) return ERROR(dictionary_corrupted);
         }   }
 
-        cctx->fseCTables_ready = 1;
-        cctx->hufCTable_repeatMode = HUF_repeat_valid;
+        cctx->entropy->hufCTable_repeatMode = HUF_repeat_valid;
+        cctx->entropy->offcode_repeatMode = FSE_repeat_valid;
+        cctx->entropy->matchlength_repeatMode = FSE_repeat_valid;
+        cctx->entropy->litlength_repeatMode = FSE_repeat_valid;
         return ZSTD_loadDictionaryContent(cctx, dictPtr, dictContentSize);
     }
 }
diff --git a/contrib/libzstd/include/zstd/compress/zstd_opt.h b/contrib/libzstd/include/zstd/compress/zstd_opt.h
index e8e98915ea3..ae24732c7d8 100644
--- a/contrib/libzstd/include/zstd/compress/zstd_opt.h
+++ b/contrib/libzstd/include/zstd/compress/zstd_opt.h
@@ -1,10 +1,10 @@
-/**
- * Copyright (c) 2016-present, Przemyslaw Skibinski, Yann Collet, Facebook, Inc.
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 
@@ -22,173 +22,173 @@
 /*-*************************************
 *  Price functions for optimal parser
 ***************************************/
-FORCE_INLINE void ZSTD_setLog2Prices(seqStore_t* ssPtr)
+static void ZSTD_setLog2Prices(optState_t* optPtr)
 {
-    ssPtr->log2matchLengthSum = ZSTD_highbit32(ssPtr->matchLengthSum+1);
-    ssPtr->log2litLengthSum = ZSTD_highbit32(ssPtr->litLengthSum+1);
-    ssPtr->log2litSum = ZSTD_highbit32(ssPtr->litSum+1);
-    ssPtr->log2offCodeSum = ZSTD_highbit32(ssPtr->offCodeSum+1);
-    ssPtr->factor = 1 + ((ssPtr->litSum>>5) / ssPtr->litLengthSum) + ((ssPtr->litSum<<1) / (ssPtr->litSum + ssPtr->matchSum));
+    optPtr->log2matchLengthSum = ZSTD_highbit32(optPtr->matchLengthSum+1);
+    optPtr->log2litLengthSum = ZSTD_highbit32(optPtr->litLengthSum+1);
+    optPtr->log2litSum = ZSTD_highbit32(optPtr->litSum+1);
+    optPtr->log2offCodeSum = ZSTD_highbit32(optPtr->offCodeSum+1);
+    optPtr->factor = 1 + ((optPtr->litSum>>5) / optPtr->litLengthSum) + ((optPtr->litSum<<1) / (optPtr->litSum + optPtr->matchSum));
 }
 
 
-MEM_STATIC void ZSTD_rescaleFreqs(seqStore_t* ssPtr, const BYTE* src, size_t srcSize)
+static void ZSTD_rescaleFreqs(optState_t* optPtr, const BYTE* src, size_t srcSize)
 {
     unsigned u;
 
-    ssPtr->cachedLiterals = NULL;
-    ssPtr->cachedPrice = ssPtr->cachedLitLength = 0;
-    ssPtr->staticPrices = 0;
+    optPtr->cachedLiterals = NULL;
+    optPtr->cachedPrice = optPtr->cachedLitLength = 0;
+    optPtr->staticPrices = 0;
 
-    if (ssPtr->litLengthSum == 0) {
-        if (srcSize <= 1024) ssPtr->staticPrices = 1;
+    if (optPtr->litLengthSum == 0) {
+        if (srcSize <= 1024) optPtr->staticPrices = 1;
 
-        assert(ssPtr->litFreq!=NULL);
+        assert(optPtr->litFreq!=NULL);
         for (u=0; u<=MaxLit; u++)
-            ssPtr->litFreq[u] = 0;
+            optPtr->litFreq[u] = 0;
         for (u=0; u<srcSize; u++)
-            ssPtr->litFreq[src[u]]++;
+            optPtr->litFreq[src[u]]++;
 
-        ssPtr->litSum = 0;
-        ssPtr->litLengthSum = MaxLL+1;
-        ssPtr->matchLengthSum = MaxML+1;
-        ssPtr->offCodeSum = (MaxOff+1);
-        ssPtr->matchSum = (ZSTD_LITFREQ_ADD<<Litbits);
+        optPtr->litSum = 0;
+        optPtr->litLengthSum = MaxLL+1;
+        optPtr->matchLengthSum = MaxML+1;
+        optPtr->offCodeSum = (MaxOff+1);
+        optPtr->matchSum = (ZSTD_LITFREQ_ADD<<Litbits);
 
         for (u=0; u<=MaxLit; u++) {
-            ssPtr->litFreq[u] = 1 + (ssPtr->litFreq[u]>>ZSTD_FREQ_DIV);
-            ssPtr->litSum += ssPtr->litFreq[u];
+            optPtr->litFreq[u] = 1 + (optPtr->litFreq[u]>>ZSTD_FREQ_DIV);
+            optPtr->litSum += optPtr->litFreq[u];
         }
         for (u=0; u<=MaxLL; u++)
-            ssPtr->litLengthFreq[u] = 1;
+            optPtr->litLengthFreq[u] = 1;
         for (u=0; u<=MaxML; u++)
-            ssPtr->matchLengthFreq[u] = 1;
+            optPtr->matchLengthFreq[u] = 1;
         for (u=0; u<=MaxOff; u++)
-            ssPtr->offCodeFreq[u] = 1;
+            optPtr->offCodeFreq[u] = 1;
     } else {
-        ssPtr->matchLengthSum = 0;
-        ssPtr->litLengthSum = 0;
-        ssPtr->offCodeSum = 0;
-        ssPtr->matchSum = 0;
-        ssPtr->litSum = 0;
+        optPtr->matchLengthSum = 0;
+        optPtr->litLengthSum = 0;
+        optPtr->offCodeSum = 0;
+        optPtr->matchSum = 0;
+        optPtr->litSum = 0;
 
         for (u=0; u<=MaxLit; u++) {
-            ssPtr->litFreq[u] = 1 + (ssPtr->litFreq[u]>>(ZSTD_FREQ_DIV+1));
-            ssPtr->litSum += ssPtr->litFreq[u];
+            optPtr->litFreq[u] = 1 + (optPtr->litFreq[u]>>(ZSTD_FREQ_DIV+1));
+            optPtr->litSum += optPtr->litFreq[u];
         }
         for (u=0; u<=MaxLL; u++) {
-            ssPtr->litLengthFreq[u] = 1 + (ssPtr->litLengthFreq[u]>>(ZSTD_FREQ_DIV+1));
-            ssPtr->litLengthSum += ssPtr->litLengthFreq[u];
+            optPtr->litLengthFreq[u] = 1 + (optPtr->litLengthFreq[u]>>(ZSTD_FREQ_DIV+1));
+            optPtr->litLengthSum += optPtr->litLengthFreq[u];
         }
         for (u=0; u<=MaxML; u++) {
-            ssPtr->matchLengthFreq[u] = 1 + (ssPtr->matchLengthFreq[u]>>ZSTD_FREQ_DIV);
-            ssPtr->matchLengthSum += ssPtr->matchLengthFreq[u];
-            ssPtr->matchSum += ssPtr->matchLengthFreq[u] * (u + 3);
+            optPtr->matchLengthFreq[u] = 1 + (optPtr->matchLengthFreq[u]>>ZSTD_FREQ_DIV);
+            optPtr->matchLengthSum += optPtr->matchLengthFreq[u];
+            optPtr->matchSum += optPtr->matchLengthFreq[u] * (u + 3);
         }
-        ssPtr->matchSum *= ZSTD_LITFREQ_ADD;
+        optPtr->matchSum *= ZSTD_LITFREQ_ADD;
         for (u=0; u<=MaxOff; u++) {
-            ssPtr->offCodeFreq[u] = 1 + (ssPtr->offCodeFreq[u]>>ZSTD_FREQ_DIV);
-            ssPtr->offCodeSum += ssPtr->offCodeFreq[u];
+            optPtr->offCodeFreq[u] = 1 + (optPtr->offCodeFreq[u]>>ZSTD_FREQ_DIV);
+            optPtr->offCodeSum += optPtr->offCodeFreq[u];
         }
     }
 
-    ZSTD_setLog2Prices(ssPtr);
+    ZSTD_setLog2Prices(optPtr);
 }
 
 
-FORCE_INLINE U32 ZSTD_getLiteralPrice(seqStore_t* ssPtr, U32 litLength, const BYTE* literals)
+static U32 ZSTD_getLiteralPrice(optState_t* optPtr, U32 litLength, const BYTE* literals)
 {
     U32 price, u;
 
-    if (ssPtr->staticPrices)
+    if (optPtr->staticPrices)
         return ZSTD_highbit32((U32)litLength+1) + (litLength*6);
 
     if (litLength == 0)
-        return ssPtr->log2litLengthSum - ZSTD_highbit32(ssPtr->litLengthFreq[0]+1);
+        return optPtr->log2litLengthSum - ZSTD_highbit32(optPtr->litLengthFreq[0]+1);
 
     /* literals */
-    if (ssPtr->cachedLiterals == literals) {
-        U32 const additional = litLength - ssPtr->cachedLitLength;
-        const BYTE* literals2 = ssPtr->cachedLiterals + ssPtr->cachedLitLength;
-        price = ssPtr->cachedPrice + additional * ssPtr->log2litSum;
+    if (optPtr->cachedLiterals == literals) {
+        U32 const additional = litLength - optPtr->cachedLitLength;
+        const BYTE* literals2 = optPtr->cachedLiterals + optPtr->cachedLitLength;
+        price = optPtr->cachedPrice + additional * optPtr->log2litSum;
         for (u=0; u < additional; u++)
-            price -= ZSTD_highbit32(ssPtr->litFreq[literals2[u]]+1);
-        ssPtr->cachedPrice = price;
-        ssPtr->cachedLitLength = litLength;
+            price -= ZSTD_highbit32(optPtr->litFreq[literals2[u]]+1);
+        optPtr->cachedPrice = price;
+        optPtr->cachedLitLength = litLength;
     } else {
-        price = litLength * ssPtr->log2litSum;
+        price = litLength * optPtr->log2litSum;
         for (u=0; u < litLength; u++)
-            price -= ZSTD_highbit32(ssPtr->litFreq[literals[u]]+1);
+            price -= ZSTD_highbit32(optPtr->litFreq[literals[u]]+1);
 
         if (litLength >= 12) {
-            ssPtr->cachedLiterals = literals;
-            ssPtr->cachedPrice = price;
-            ssPtr->cachedLitLength = litLength;
+            optPtr->cachedLiterals = literals;
+            optPtr->cachedPrice = price;
+            optPtr->cachedLitLength = litLength;
         }
     }
 
     /* literal Length */
     {   const BYTE LL_deltaCode = 19;
         const BYTE llCode = (litLength>63) ? (BYTE)ZSTD_highbit32(litLength) + LL_deltaCode : LL_Code[litLength];
-        price += LL_bits[llCode] + ssPtr->log2litLengthSum - ZSTD_highbit32(ssPtr->litLengthFreq[llCode]+1);
+        price += LL_bits[llCode] + optPtr->log2litLengthSum - ZSTD_highbit32(optPtr->litLengthFreq[llCode]+1);
     }
 
     return price;
 }
 
 
-FORCE_INLINE U32 ZSTD_getPrice(seqStore_t* seqStorePtr, U32 litLength, const BYTE* literals, U32 offset, U32 matchLength, const int ultra)
+FORCE_INLINE_TEMPLATE U32 ZSTD_getPrice(optState_t* optPtr, U32 litLength, const BYTE* literals, U32 offset, U32 matchLength, const int ultra)
 {
     /* offset */
     U32 price;
     BYTE const offCode = (BYTE)ZSTD_highbit32(offset+1);
 
-    if (seqStorePtr->staticPrices)
-        return ZSTD_getLiteralPrice(seqStorePtr, litLength, literals) + ZSTD_highbit32((U32)matchLength+1) + 16 + offCode;
+    if (optPtr->staticPrices)
+        return ZSTD_getLiteralPrice(optPtr, litLength, literals) + ZSTD_highbit32((U32)matchLength+1) + 16 + offCode;
 
-    price = offCode + seqStorePtr->log2offCodeSum - ZSTD_highbit32(seqStorePtr->offCodeFreq[offCode]+1);
+    price = offCode + optPtr->log2offCodeSum - ZSTD_highbit32(optPtr->offCodeFreq[offCode]+1);
     if (!ultra && offCode >= 20) price += (offCode-19)*2;
 
     /* match Length */
     {   const BYTE ML_deltaCode = 36;
         const BYTE mlCode = (matchLength>127) ? (BYTE)ZSTD_highbit32(matchLength) + ML_deltaCode : ML_Code[matchLength];
-        price += ML_bits[mlCode] + seqStorePtr->log2matchLengthSum - ZSTD_highbit32(seqStorePtr->matchLengthFreq[mlCode]+1);
+        price += ML_bits[mlCode] + optPtr->log2matchLengthSum - ZSTD_highbit32(optPtr->matchLengthFreq[mlCode]+1);
     }
 
-    return price + ZSTD_getLiteralPrice(seqStorePtr, litLength, literals) + seqStorePtr->factor;
+    return price + ZSTD_getLiteralPrice(optPtr, litLength, literals) + optPtr->factor;
 }
 
 
-MEM_STATIC void ZSTD_updatePrice(seqStore_t* seqStorePtr, U32 litLength, const BYTE* literals, U32 offset, U32 matchLength)
+static void ZSTD_updatePrice(optState_t* optPtr, U32 litLength, const BYTE* literals, U32 offset, U32 matchLength)
 {
     U32 u;
 
     /* literals */
-    seqStorePtr->litSum += litLength*ZSTD_LITFREQ_ADD;
+    optPtr->litSum += litLength*ZSTD_LITFREQ_ADD;
     for (u=0; u < litLength; u++)
-        seqStorePtr->litFreq[literals[u]] += ZSTD_LITFREQ_ADD;
+        optPtr->litFreq[literals[u]] += ZSTD_LITFREQ_ADD;
 
     /* literal Length */
     {   const BYTE LL_deltaCode = 19;
         const BYTE llCode = (litLength>63) ? (BYTE)ZSTD_highbit32(litLength) + LL_deltaCode : LL_Code[litLength];
-        seqStorePtr->litLengthFreq[llCode]++;
-        seqStorePtr->litLengthSum++;
+        optPtr->litLengthFreq[llCode]++;
+        optPtr->litLengthSum++;
     }
 
     /* match offset */
     {   BYTE const offCode = (BYTE)ZSTD_highbit32(offset+1);
-        seqStorePtr->offCodeSum++;
-        seqStorePtr->offCodeFreq[offCode]++;
+        optPtr->offCodeSum++;
+        optPtr->offCodeFreq[offCode]++;
     }
 
     /* match Length */
     {   const BYTE ML_deltaCode = 36;
         const BYTE mlCode = (matchLength>127) ? (BYTE)ZSTD_highbit32(matchLength) + ML_deltaCode : ML_Code[matchLength];
-        seqStorePtr->matchLengthFreq[mlCode]++;
-        seqStorePtr->matchLengthSum++;
+        optPtr->matchLengthFreq[mlCode]++;
+        optPtr->matchLengthSum++;
     }
 
-    ZSTD_setLog2Prices(seqStorePtr);
+    ZSTD_setLog2Prices(optPtr);
 }
 
 
@@ -203,7 +203,7 @@ MEM_STATIC void ZSTD_updatePrice(seqStore_t* seqStorePtr, U32 litLength, const B
 
 
 /* function safe only for comparisons */
-MEM_STATIC U32 ZSTD_readMINMATCH(const void* memPtr, U32 length)
+static U32 ZSTD_readMINMATCH(const void* memPtr, U32 length)
 {
     switch (length)
     {
@@ -219,7 +219,7 @@ MEM_STATIC U32 ZSTD_readMINMATCH(const void* memPtr, U32 length)
 
 /* Update hashTable3 up to ip (excluded)
    Assumption : always within prefix (i.e. not within extDict) */
-FORCE_INLINE
+static
 U32 ZSTD_insertAndFindFirstIndexHash3 (ZSTD_CCtx* zc, const BYTE* ip)
 {
     U32* const hashTable3  = zc->hashTable3;
@@ -412,11 +412,12 @@ static U32 ZSTD_BtGetAllMatches_selectMLS_extDict (
 /*-*******************************
 *  Optimal parser
 *********************************/
-FORCE_INLINE
+FORCE_INLINE_TEMPLATE
 void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                                     const void* src, size_t srcSize, const int ultra)
 {
     seqStore_t* seqStorePtr = &(ctx->seqStore);
+    optState_t* optStatePtr = &(ctx->optState);
     const BYTE* const istart = (const BYTE*)src;
     const BYTE* ip = istart;
     const BYTE* anchor = istart;
@@ -430,16 +431,16 @@ void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
     const U32 mls = ctx->appliedParams.cParams.searchLength;
     const U32 minMatch = (ctx->appliedParams.cParams.searchLength == 3) ? 3 : 4;
 
-    ZSTD_optimal_t* opt = seqStorePtr->priceTable;
-    ZSTD_match_t* matches = seqStorePtr->matchTable;
+    ZSTD_optimal_t* opt = optStatePtr->priceTable;
+    ZSTD_match_t* matches = optStatePtr->matchTable;
     const BYTE* inr;
     U32 offset, rep[ZSTD_REP_NUM];
 
     /* init */
     ctx->nextToUpdate3 = ctx->nextToUpdate;
-    ZSTD_rescaleFreqs(seqStorePtr, (const BYTE*)src, srcSize);
+    ZSTD_rescaleFreqs(optStatePtr, (const BYTE*)src, srcSize);
     ip += (ip==prefixStart);
-    { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) rep[i]=ctx->rep[i]; }
+    { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) rep[i]=seqStorePtr->rep[i]; }
 
     /* Match Loop */
     while (ip < ilimit) {
@@ -462,7 +463,7 @@ void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                     }
                     best_off = i - (ip == anchor);
                     do {
-                        price = ZSTD_getPrice(seqStorePtr, litlen, anchor, best_off, mlen - MINMATCH, ultra);
+                        price = ZSTD_getPrice(optStatePtr, litlen, anchor, best_off, mlen - MINMATCH, ultra);
                         if (mlen > last_pos || price < opt[mlen].price)
                             SET_PRICE(mlen, mlen, i, litlen, price);   /* note : macro modifies last_pos */
                         mlen--;
@@ -487,7 +488,7 @@ void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
             mlen = (u>0) ? matches[u-1].len+1 : best_mlen;
             best_mlen = matches[u].len;
             while (mlen <= best_mlen) {
-                price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[u].off-1, mlen - MINMATCH, ultra);
+                price = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[u].off-1, mlen - MINMATCH, ultra);
                 if (mlen > last_pos || price < opt[mlen].price)
                     SET_PRICE(mlen, mlen, matches[u].off, litlen, price);   /* note : macro modifies last_pos */
                 mlen++;
@@ -507,12 +508,12 @@ void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
            if (opt[cur-1].mlen == 1) {
                 litlen = opt[cur-1].litlen + 1;
                 if (cur > litlen) {
-                    price = opt[cur - litlen].price + ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-litlen);
+                    price = opt[cur - litlen].price + ZSTD_getLiteralPrice(optStatePtr, litlen, inr-litlen);
                 } else
-                    price = ZSTD_getLiteralPrice(seqStorePtr, litlen, anchor);
+                    price = ZSTD_getLiteralPrice(optStatePtr, litlen, anchor);
            } else {
                 litlen = 1;
-                price = opt[cur - 1].price + ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-1);
+                price = opt[cur - 1].price + ZSTD_getLiteralPrice(optStatePtr, litlen, inr-1);
            }
 
            if (cur > last_pos || price <= opt[cur].price)
@@ -554,12 +555,12 @@ void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                            if (opt[cur].mlen == 1) {
                                 litlen = opt[cur].litlen;
                                 if (cur > litlen) {
-                                    price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, inr-litlen, best_off, mlen - MINMATCH, ultra);
+                                    price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, inr-litlen, best_off, mlen - MINMATCH, ultra);
                                 } else
-                                    price = ZSTD_getPrice(seqStorePtr, litlen, anchor, best_off, mlen - MINMATCH, ultra);
+                                    price = ZSTD_getPrice(optStatePtr, litlen, anchor, best_off, mlen - MINMATCH, ultra);
                             } else {
                                 litlen = 0;
-                                price = opt[cur].price + ZSTD_getPrice(seqStorePtr, 0, NULL, best_off, mlen - MINMATCH, ultra);
+                                price = opt[cur].price + ZSTD_getPrice(optStatePtr, 0, NULL, best_off, mlen - MINMATCH, ultra);
                             }
 
                             if (cur + mlen > last_pos || price <= opt[cur + mlen].price)
@@ -586,12 +587,12 @@ void ZSTD_compressBlock_opt_generic(ZSTD_CCtx* ctx,
                     if (opt[cur].mlen == 1) {
                         litlen = opt[cur].litlen;
                         if (cur > litlen)
-                            price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, ip+cur-litlen, matches[u].off-1, mlen - MINMATCH, ultra);
+                            price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, ip+cur-litlen, matches[u].off-1, mlen - MINMATCH, ultra);
                         else
-                            price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[u].off-1, mlen - MINMATCH, ultra);
+                            price = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[u].off-1, mlen - MINMATCH, ultra);
                     } else {
                         litlen = 0;
-                        price = opt[cur].price + ZSTD_getPrice(seqStorePtr, 0, NULL, matches[u].off-1, mlen - MINMATCH, ultra);
+                        price = opt[cur].price + ZSTD_getPrice(optStatePtr, 0, NULL, matches[u].off-1, mlen - MINMATCH, ultra);
                     }
 
                     if (cur + mlen > last_pos || (price < opt[cur + mlen].price))
@@ -645,13 +646,13 @@ _storeSequence:   /* cur, last_pos, best_mlen, best_off have to be set */
                 if (litLength==0) offset--;
             }
 
-            ZSTD_updatePrice(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH);
+            ZSTD_updatePrice(optStatePtr, litLength, anchor, offset, mlen-MINMATCH);
             ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH);
             anchor = ip = ip + mlen;
     }    }   /* for (cur=0; cur < last_pos; ) */
 
     /* Save reps for next block */
-    { int i; for (i=0; i<ZSTD_REP_NUM; i++) ctx->repToConfirm[i] = rep[i]; }
+    { int i; for (i=0; i<ZSTD_REP_NUM; i++) seqStorePtr->repToConfirm[i] = rep[i]; }
 
     /* Last Literals */
     {   size_t const lastLLSize = iend - anchor;
@@ -661,11 +662,12 @@ _storeSequence:   /* cur, last_pos, best_mlen, best_off have to be set */
 }
 
 
-FORCE_INLINE
+FORCE_INLINE_TEMPLATE
 void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
                                      const void* src, size_t srcSize, const int ultra)
 {
     seqStore_t* seqStorePtr = &(ctx->seqStore);
+    optState_t* optStatePtr = &(ctx->optState);
     const BYTE* const istart = (const BYTE*)src;
     const BYTE* ip = istart;
     const BYTE* anchor = istart;
@@ -683,16 +685,16 @@ void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
     const U32 mls = ctx->appliedParams.cParams.searchLength;
     const U32 minMatch = (ctx->appliedParams.cParams.searchLength == 3) ? 3 : 4;
 
-    ZSTD_optimal_t* opt = seqStorePtr->priceTable;
-    ZSTD_match_t* matches = seqStorePtr->matchTable;
+    ZSTD_optimal_t* opt = optStatePtr->priceTable;
+    ZSTD_match_t* matches = optStatePtr->matchTable;
     const BYTE* inr;
 
     /* init */
     U32 offset, rep[ZSTD_REP_NUM];
-    { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) rep[i]=ctx->rep[i]; }
+    { U32 i; for (i=0; i<ZSTD_REP_NUM; i++) rep[i]=seqStorePtr->rep[i]; }
 
     ctx->nextToUpdate3 = ctx->nextToUpdate;
-    ZSTD_rescaleFreqs(seqStorePtr, (const BYTE*)src, srcSize);
+    ZSTD_rescaleFreqs(optStatePtr, (const BYTE*)src, srcSize);
     ip += (ip==prefixStart);
 
     /* Match Loop */
@@ -726,7 +728,7 @@ void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
                     best_off = i - (ip==anchor);
                     litlen = opt[0].litlen;
                     do {
-                        price = ZSTD_getPrice(seqStorePtr, litlen, anchor, best_off, mlen - MINMATCH, ultra);
+                        price = ZSTD_getPrice(optStatePtr, litlen, anchor, best_off, mlen - MINMATCH, ultra);
                         if (mlen > last_pos || price < opt[mlen].price)
                             SET_PRICE(mlen, mlen, i, litlen, price);   /* note : macro modifies last_pos */
                         mlen--;
@@ -756,7 +758,7 @@ void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
             best_mlen = matches[u].len;
             litlen = opt[0].litlen;
             while (mlen <= best_mlen) {
-                price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[u].off-1, mlen - MINMATCH, ultra);
+                price = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[u].off-1, mlen - MINMATCH, ultra);
                 if (mlen > last_pos || price < opt[mlen].price)
                     SET_PRICE(mlen, mlen, matches[u].off, litlen, price);
                 mlen++;
@@ -773,12 +775,12 @@ void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
             if (opt[cur-1].mlen == 1) {
                 litlen = opt[cur-1].litlen + 1;
                 if (cur > litlen) {
-                    price = opt[cur - litlen].price + ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-litlen);
+                    price = opt[cur - litlen].price + ZSTD_getLiteralPrice(optStatePtr, litlen, inr-litlen);
                 } else
-                    price = ZSTD_getLiteralPrice(seqStorePtr, litlen, anchor);
+                    price = ZSTD_getLiteralPrice(optStatePtr, litlen, anchor);
             } else {
                 litlen = 1;
-                price = opt[cur - 1].price + ZSTD_getLiteralPrice(seqStorePtr, litlen, inr-1);
+                price = opt[cur - 1].price + ZSTD_getLiteralPrice(optStatePtr, litlen, inr-1);
             }
 
             if (cur > last_pos || price <= opt[cur].price)
@@ -826,12 +828,12 @@ void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
                             if (opt[cur].mlen == 1) {
                                 litlen = opt[cur].litlen;
                                 if (cur > litlen) {
-                                    price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, inr-litlen, best_off, mlen - MINMATCH, ultra);
+                                    price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, inr-litlen, best_off, mlen - MINMATCH, ultra);
                                 } else
-                                    price = ZSTD_getPrice(seqStorePtr, litlen, anchor, best_off, mlen - MINMATCH, ultra);
+                                    price = ZSTD_getPrice(optStatePtr, litlen, anchor, best_off, mlen - MINMATCH, ultra);
                             } else {
                                 litlen = 0;
-                                price = opt[cur].price + ZSTD_getPrice(seqStorePtr, 0, NULL, best_off, mlen - MINMATCH, ultra);
+                                price = opt[cur].price + ZSTD_getPrice(optStatePtr, 0, NULL, best_off, mlen - MINMATCH, ultra);
                             }
 
                             if (cur + mlen > last_pos || price <= opt[cur + mlen].price)
@@ -858,12 +860,12 @@ void ZSTD_compressBlock_opt_extDict_generic(ZSTD_CCtx* ctx,
                     if (opt[cur].mlen == 1) {
                         litlen = opt[cur].litlen;
                         if (cur > litlen)
-                            price = opt[cur - litlen].price + ZSTD_getPrice(seqStorePtr, litlen, ip+cur-litlen, matches[u].off-1, mlen - MINMATCH, ultra);
+                            price = opt[cur - litlen].price + ZSTD_getPrice(optStatePtr, litlen, ip+cur-litlen, matches[u].off-1, mlen - MINMATCH, ultra);
                         else
-                            price = ZSTD_getPrice(seqStorePtr, litlen, anchor, matches[u].off-1, mlen - MINMATCH, ultra);
+                            price = ZSTD_getPrice(optStatePtr, litlen, anchor, matches[u].off-1, mlen - MINMATCH, ultra);
                     } else {
                         litlen = 0;
-                        price = opt[cur].price + ZSTD_getPrice(seqStorePtr, 0, NULL, matches[u].off-1, mlen - MINMATCH, ultra);
+                        price = opt[cur].price + ZSTD_getPrice(optStatePtr, 0, NULL, matches[u].off-1, mlen - MINMATCH, ultra);
                     }
 
                     if (cur + mlen > last_pos || (price < opt[cur + mlen].price))
@@ -918,13 +920,13 @@ _storeSequence:   /* cur, last_pos, best_mlen, best_off have to be set */
                 if (litLength==0) offset--;
             }
 
-            ZSTD_updatePrice(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH);
+            ZSTD_updatePrice(optStatePtr, litLength, anchor, offset, mlen-MINMATCH);
             ZSTD_storeSeq(seqStorePtr, litLength, anchor, offset, mlen-MINMATCH);
             anchor = ip = ip + mlen;
     }    }   /* for (cur=0; cur < last_pos; ) */
 
     /* Save reps for next block */
-    { int i; for (i=0; i<ZSTD_REP_NUM; i++) ctx->repToConfirm[i] = rep[i]; }
+    { int i; for (i=0; i<ZSTD_REP_NUM; i++) seqStorePtr->repToConfirm[i] = rep[i]; }
 
     /* Last Literals */
     {   size_t lastLLSize = iend - anchor;
diff --git a/contrib/libzstd/include/zstd/compress/zstdmt_compress.c b/contrib/libzstd/include/zstd/compress/zstdmt_compress.c
index 0cee01eacb8..8564bc43921 100644
--- a/contrib/libzstd/include/zstd/compress/zstdmt_compress.c
+++ b/contrib/libzstd/include/zstd/compress/zstdmt_compress.c
@@ -1,15 +1,16 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 
 /* ======   Tuning parameters   ====== */
-#define ZSTDMT_NBTHREADS_MAX 128
+#define ZSTDMT_NBTHREADS_MAX 256
+#define ZSTDMT_OVERLAPLOG_DEFAULT 6
 
 
 /* ======   Compiler specifics   ====== */
@@ -73,6 +74,7 @@ static unsigned long long GetCurrentClockTimeMicroseconds(void)
 
 
 /* =====   Buffer Pool   ===== */
+/* a single Buffer Pool can be invoked from multiple threads in parallel */
 
 typedef struct buffer_s {
     void* start;
@@ -82,6 +84,8 @@ typedef struct buffer_s {
 static const buffer_t g_nullBuffer = { NULL, 0 };
 
 typedef struct ZSTDMT_bufferPool_s {
+    pthread_mutex_t poolMutex;
+    size_t bufferSize;
     unsigned totalBuffers;
     unsigned nbBuffers;
     ZSTD_customMem cMem;
@@ -90,10 +94,15 @@ typedef struct ZSTDMT_bufferPool_s {
 
 static ZSTDMT_bufferPool* ZSTDMT_createBufferPool(unsigned nbThreads, ZSTD_customMem cMem)
 {
-    unsigned const maxNbBuffers = 2*nbThreads + 2;
+    unsigned const maxNbBuffers = 2*nbThreads + 3;
     ZSTDMT_bufferPool* const bufPool = (ZSTDMT_bufferPool*)ZSTD_calloc(
         sizeof(ZSTDMT_bufferPool) + (maxNbBuffers-1) * sizeof(buffer_t), cMem);
     if (bufPool==NULL) return NULL;
+    if (pthread_mutex_init(&bufPool->poolMutex, NULL)) {
+        ZSTD_free(bufPool, cMem);
+        return NULL;
+    }
+    bufPool->bufferSize = 64 KB;
     bufPool->totalBuffers = maxNbBuffers;
     bufPool->nbBuffers = 0;
     bufPool->cMem = cMem;
@@ -106,6 +115,7 @@ static void ZSTDMT_freeBufferPool(ZSTDMT_bufferPool* bufPool)
     if (!bufPool) return;   /* compatibility with free on NULL */
     for (u=0; u<bufPool->totalBuffers; u++)
         ZSTD_free(bufPool->bTable[u].start, bufPool->cMem);
+    pthread_mutex_destroy(&bufPool->poolMutex);
     ZSTD_free(bufPool, bufPool->cMem);
 }
 
@@ -116,65 +126,85 @@ static size_t ZSTDMT_sizeof_bufferPool(ZSTDMT_bufferPool* bufPool)
                             + (bufPool->totalBuffers - 1) * sizeof(buffer_t);
     unsigned u;
     size_t totalBufferSize = 0;
+    pthread_mutex_lock(&bufPool->poolMutex);
     for (u=0; u<bufPool->totalBuffers; u++)
         totalBufferSize += bufPool->bTable[u].size;
+    pthread_mutex_unlock(&bufPool->poolMutex);
 
     return poolSize + totalBufferSize;
 }
 
-/** ZSTDMT_getBuffer() :
- *  assumption : invocation from main thread only ! */
-static buffer_t ZSTDMT_getBuffer(ZSTDMT_bufferPool* pool, size_t bSize)
+static void ZSTDMT_setBufferSize(ZSTDMT_bufferPool* bufPool, size_t bSize)
 {
-    if (pool->nbBuffers) {   /* try to use an existing buffer */
-        buffer_t const buf = pool->bTable[--(pool->nbBuffers)];
+    bufPool->bufferSize = bSize;
+}
+
+/** ZSTDMT_getBuffer() :
+ *  assumption : bufPool must be valid */
+static buffer_t ZSTDMT_getBuffer(ZSTDMT_bufferPool* bufPool)
+{
+    size_t const bSize = bufPool->bufferSize;
+    DEBUGLOG(5, "ZSTDMT_getBuffer");
+    pthread_mutex_lock(&bufPool->poolMutex);
+    if (bufPool->nbBuffers) {   /* try to use an existing buffer */
+        buffer_t const buf = bufPool->bTable[--(bufPool->nbBuffers)];
         size_t const availBufferSize = buf.size;
-        if ((availBufferSize >= bSize) & (availBufferSize <= 10*bSize))
+        if ((availBufferSize >= bSize) & (availBufferSize <= 10*bSize)) {
             /* large enough, but not too much */
+            pthread_mutex_unlock(&bufPool->poolMutex);
             return buf;
+        }
         /* size conditions not respected : scratch this buffer, create new one */
-        ZSTD_free(buf.start, pool->cMem);
+        DEBUGLOG(5, "existing buffer does not meet size conditions => freeing");
+        ZSTD_free(buf.start, bufPool->cMem);
     }
+    pthread_mutex_unlock(&bufPool->poolMutex);
     /* create new buffer */
+    DEBUGLOG(5, "create a new buffer");
     {   buffer_t buffer;
-        void* const start = ZSTD_malloc(bSize, pool->cMem);
-        if (start==NULL) bSize = 0;
+        void* const start = ZSTD_malloc(bSize, bufPool->cMem);
         buffer.start = start;   /* note : start can be NULL if malloc fails ! */
-        buffer.size = bSize;
+        buffer.size = (start==NULL) ? 0 : bSize;
         return buffer;
     }
 }
 
 /* store buffer for later re-use, up to pool capacity */
-static void ZSTDMT_releaseBuffer(ZSTDMT_bufferPool* pool, buffer_t buf)
+static void ZSTDMT_releaseBuffer(ZSTDMT_bufferPool* bufPool, buffer_t buf)
 {
-    if (buf.start == NULL) return;   /* release on NULL */
-    if (pool->nbBuffers < pool->totalBuffers) {
-        pool->bTable[pool->nbBuffers++] = buf;   /* store for later re-use */
+    if (buf.start == NULL) return;   /* compatible with release on NULL */
+    DEBUGLOG(5, "ZSTDMT_releaseBuffer");
+    pthread_mutex_lock(&bufPool->poolMutex);
+    if (bufPool->nbBuffers < bufPool->totalBuffers) {
+        bufPool->bTable[bufPool->nbBuffers++] = buf;  /* stored for later use */
+        pthread_mutex_unlock(&bufPool->poolMutex);
         return;
     }
+    pthread_mutex_unlock(&bufPool->poolMutex);
     /* Reached bufferPool capacity (should not happen) */
-    ZSTD_free(buf.start, pool->cMem);
+    DEBUGLOG(5, "buffer pool capacity reached => freeing ");
+    ZSTD_free(buf.start, bufPool->cMem);
 }
 
 
 /* =====   CCtx Pool   ===== */
+/* a single CCtx Pool can be invoked from multiple threads in parallel */
 
 typedef struct {
+    pthread_mutex_t poolMutex;
     unsigned totalCCtx;
     unsigned availCCtx;
     ZSTD_customMem cMem;
     ZSTD_CCtx* cctx[1];   /* variable size */
 } ZSTDMT_CCtxPool;
 
-/* assumption : CCtxPool invocation only from main thread */
-
 /* note : all CCtx borrowed from the pool should be released back to the pool _before_ freeing the pool */
 static void ZSTDMT_freeCCtxPool(ZSTDMT_CCtxPool* pool)
 {
     unsigned u;
     for (u=0; u<pool->totalCCtx; u++)
         ZSTD_freeCCtx(pool->cctx[u]);  /* note : compatible with free on NULL */
+    pthread_mutex_destroy(&pool->poolMutex);
     ZSTD_free(pool, pool->cMem);
 }
 
@@ -186,6 +216,10 @@ static ZSTDMT_CCtxPool* ZSTDMT_createCCtxPool(unsigned nbThreads,
     ZSTDMT_CCtxPool* const cctxPool = (ZSTDMT_CCtxPool*) ZSTD_calloc(
         sizeof(ZSTDMT_CCtxPool) + (nbThreads-1)*sizeof(ZSTD_CCtx*), cMem);
     if (!cctxPool) return NULL;
+    if (pthread_mutex_init(&cctxPool->poolMutex, NULL)) {
+        ZSTD_free(cctxPool, cMem);
+        return NULL;
+    }
     cctxPool->cMem = cMem;
     cctxPool->totalCCtx = nbThreads;
     cctxPool->availCCtx = 1;   /* at least one cctx for single-thread mode */
@@ -198,50 +232,57 @@ static ZSTDMT_CCtxPool* ZSTDMT_createCCtxPool(unsigned nbThreads,
 /* only works during initialization phase, not during compression */
 static size_t ZSTDMT_sizeof_CCtxPool(ZSTDMT_CCtxPool* cctxPool)
 {
-    unsigned const nbThreads = cctxPool->totalCCtx;
-    size_t const poolSize = sizeof(*cctxPool)
-                            + (nbThreads-1)*sizeof(ZSTD_CCtx*);
-    unsigned u;
-    size_t totalCCtxSize = 0;
-    for (u=0; u<nbThreads; u++)
-        totalCCtxSize += ZSTD_sizeof_CCtx(cctxPool->cctx[u]);
-
-    return poolSize + totalCCtxSize;
+    pthread_mutex_lock(&cctxPool->poolMutex);
+    {   unsigned const nbThreads = cctxPool->totalCCtx;
+        size_t const poolSize = sizeof(*cctxPool)
+                                + (nbThreads-1)*sizeof(ZSTD_CCtx*);
+        unsigned u;
+        size_t totalCCtxSize = 0;
+        for (u=0; u<nbThreads; u++) {
+            totalCCtxSize += ZSTD_sizeof_CCtx(cctxPool->cctx[u]);
+        }
+        pthread_mutex_unlock(&cctxPool->poolMutex);
+        return poolSize + totalCCtxSize;
+    }
 }
 
-static ZSTD_CCtx* ZSTDMT_getCCtx(ZSTDMT_CCtxPool* pool)
+static ZSTD_CCtx* ZSTDMT_getCCtx(ZSTDMT_CCtxPool* cctxPool)
 {
-    if (pool->availCCtx) {
-        pool->availCCtx--;
-        return pool->cctx[pool->availCCtx];
-    }
-    return ZSTD_createCCtx();   /* note : can be NULL, when creation fails ! */
+    DEBUGLOG(5, "ZSTDMT_getCCtx");
+    pthread_mutex_lock(&cctxPool->poolMutex);
+    if (cctxPool->availCCtx) {
+        cctxPool->availCCtx--;
+        {   ZSTD_CCtx* const cctx = cctxPool->cctx[cctxPool->availCCtx];
+            pthread_mutex_unlock(&cctxPool->poolMutex);
+            return cctx;
+    }   }
+    pthread_mutex_unlock(&cctxPool->poolMutex);
+    DEBUGLOG(5, "create one more CCtx");
+    return ZSTD_createCCtx_advanced(cctxPool->cMem);   /* note : can be NULL, when creation fails ! */
 }
 
 static void ZSTDMT_releaseCCtx(ZSTDMT_CCtxPool* pool, ZSTD_CCtx* cctx)
 {
     if (cctx==NULL) return;   /* compatibility with release on NULL */
+    pthread_mutex_lock(&pool->poolMutex);
     if (pool->availCCtx < pool->totalCCtx)
         pool->cctx[pool->availCCtx++] = cctx;
-    else
+    else {
         /* pool overflow : should not happen, since totalCCtx==nbThreads */
+        DEBUGLOG(5, "CCtx pool overflow : free cctx");
         ZSTD_freeCCtx(cctx);
+    }
+    pthread_mutex_unlock(&pool->poolMutex);
 }
 
 
 /* =====   Thread worker   ===== */
 
 typedef struct {
-    buffer_t buffer;
-    size_t filled;
-} inBuff_t;
-
-typedef struct {
-    ZSTD_CCtx* cctx;
     buffer_t src;
     const void* srcStart;
-    size_t   srcSize;
     size_t   dictSize;
+    size_t   srcSize;
     buffer_t dstBuff;
     size_t   cSize;
     size_t   dstFlushed;
@@ -253,6 +294,8 @@ typedef struct {
     pthread_cond_t* jobCompleted_cond;
     ZSTD_parameters params;
     const ZSTD_CDict* cdict;
+    ZSTDMT_CCtxPool* cctxPool;
+    ZSTDMT_bufferPool* bufPool;
     unsigned long long fullFrameSize;
 } ZSTDMT_jobDescription;
 
@@ -260,37 +303,56 @@ typedef struct {
 void ZSTDMT_compressChunk(void* jobDescription)
 {
     ZSTDMT_jobDescription* const job = (ZSTDMT_jobDescription*)jobDescription;
+    ZSTD_CCtx* cctx = ZSTDMT_getCCtx(job->cctxPool);
     const void* const src = (const char*)job->srcStart + job->dictSize;
-    buffer_t const dstBuff = job->dstBuff;
+    buffer_t dstBuff = job->dstBuff;
     DEBUGLOG(5, "job (first:%u) (last:%u) : dictSize %u, srcSize %u",
                  job->firstChunk, job->lastChunk, (U32)job->dictSize, (U32)job->srcSize);
+
+    if (cctx==NULL) {
+        job->cSize = ERROR(memory_allocation);
+        goto _endJob;
+    }
+
+    if (dstBuff.start == NULL) {
+        dstBuff = ZSTDMT_getBuffer(job->bufPool);
+        if (dstBuff.start==NULL) {
+            job->cSize = ERROR(memory_allocation);
+            goto _endJob;
+        }
+        job->dstBuff = dstBuff;
+    }
+
     if (job->cdict) {  /* should only happen for first segment */
-        size_t const initError = ZSTD_compressBegin_usingCDict_advanced(job->cctx, job->cdict, job->params.fParams, job->fullFrameSize);
+        size_t const initError = ZSTD_compressBegin_usingCDict_advanced(cctx, job->cdict, job->params.fParams, job->fullFrameSize);
         DEBUGLOG(5, "using CDict");
         if (ZSTD_isError(initError)) { job->cSize = initError; goto _endJob; }
     } else {  /* srcStart points at reloaded section */
         if (!job->firstChunk) job->params.fParams.contentSizeFlag = 0;  /* ensure no srcSize control */
-        {   size_t const dictModeError = ZSTD_setCCtxParameter(job->cctx, ZSTD_p_forceRawDict, 1);  /* Force loading dictionary in "content-only" mode (no header analysis) */
-            size_t const initError = ZSTD_compressBegin_advanced(job->cctx, job->srcStart, job->dictSize, job->params, job->fullFrameSize);
+        {   size_t const dictModeError = ZSTD_setCCtxParameter(cctx, ZSTD_p_forceRawDict, 1);  /* Force loading dictionary in "content-only" mode (no header analysis) */
+            size_t const initError = ZSTD_compressBegin_advanced(cctx, job->srcStart, job->dictSize, job->params, job->fullFrameSize);
             if (ZSTD_isError(initError) || ZSTD_isError(dictModeError)) { job->cSize = initError; goto _endJob; }
-            ZSTD_setCCtxParameter(job->cctx, ZSTD_p_forceWindow, 1);
+            ZSTD_setCCtxParameter(cctx, ZSTD_p_forceWindow, 1);
     }   }
     if (!job->firstChunk) {  /* flush and overwrite frame header when it's not first segment */
-        size_t const hSize = ZSTD_compressContinue(job->cctx, dstBuff.start, dstBuff.size, src, 0);
+        size_t const hSize = ZSTD_compressContinue(cctx, dstBuff.start, dstBuff.size, src, 0);
         if (ZSTD_isError(hSize)) { job->cSize = hSize; goto _endJob; }
-        ZSTD_invalidateRepCodes(job->cctx);
+        ZSTD_invalidateRepCodes(cctx);
     }
 
     DEBUGLOG(5, "Compressing : ");
     DEBUG_PRINTHEX(4, job->srcStart, 12);
     job->cSize = (job->lastChunk) ?
-                 ZSTD_compressEnd     (job->cctx, dstBuff.start, dstBuff.size, src, job->srcSize) :
-                 ZSTD_compressContinue(job->cctx, dstBuff.start, dstBuff.size, src, job->srcSize);
+                 ZSTD_compressEnd     (cctx, dstBuff.start, dstBuff.size, src, job->srcSize) :
+                 ZSTD_compressContinue(cctx, dstBuff.start, dstBuff.size, src, job->srcSize);
     DEBUGLOG(5, "compressed %u bytes into %u bytes   (first:%u) (last:%u)",
                 (unsigned)job->srcSize, (unsigned)job->cSize, job->firstChunk, job->lastChunk);
     DEBUGLOG(5, "dstBuff.size : %u ; => %s", (U32)dstBuff.size, ZSTD_getErrorName(job->cSize));
 
 _endJob:
+    ZSTDMT_releaseCCtx(job->cctxPool, cctx);
+    ZSTDMT_releaseBuffer(job->bufPool, job->src);
+    job->src = g_nullBuffer; job->srcStart = NULL;
     PTHREAD_MUTEX_LOCK(job->jobCompleted_mutex);
     job->jobCompleted = 1;
     job->jobScanned = 0;
@@ -303,15 +365,19 @@ _endJob:
 /* =====   Multi-threaded compression   ===== */
 /* ------------------------------------------ */
 
+typedef struct {
+    buffer_t buffer;
+    size_t filled;
+} inBuff_t;
+
 struct ZSTDMT_CCtx_s {
     POOL_ctx* factory;
     ZSTDMT_jobDescription* jobs;
-    ZSTDMT_bufferPool* buffPool;
+    ZSTDMT_bufferPool* bufPool;
     ZSTDMT_CCtxPool* cctxPool;
     pthread_mutex_t jobCompleted_mutex;
     pthread_cond_t jobCompleted_cond;
     size_t targetSectionSize;
-    size_t marginSize;
     size_t inBuffSize;
     size_t dictSize;
     size_t targetDictSize;
@@ -324,7 +390,7 @@ struct ZSTDMT_CCtx_s {
     unsigned nextJobID;
     unsigned frameEnded;
     unsigned allJobsCompleted;
-    unsigned overlapRLog;
+    unsigned overlapLog;
     unsigned long long frameContentSize;
     size_t sectionSize;
     ZSTD_customMem cMem;
@@ -347,7 +413,8 @@ ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced(unsigned nbThreads, ZSTD_customMem cMem)
     U32 nbJobs = nbThreads + 2;
     DEBUGLOG(3, "ZSTDMT_createCCtx_advanced");
 
-    if ((nbThreads < 1) | (nbThreads > ZSTDMT_NBTHREADS_MAX)) return NULL;
+    if (nbThreads < 1) return NULL;
+    nbThreads = MIN(nbThreads , ZSTDMT_NBTHREADS_MAX);
     if ((cMem.customAlloc!=NULL) ^ (cMem.customFree!=NULL))
         /* invalid custom allocator */
         return NULL;
@@ -358,18 +425,24 @@ ZSTDMT_CCtx* ZSTDMT_createCCtx_advanced(unsigned nbThreads, ZSTD_customMem cMem)
     mtctx->nbThreads = nbThreads;
     mtctx->allJobsCompleted = 1;
     mtctx->sectionSize = 0;
-    mtctx->overlapRLog = 3;
-    mtctx->factory = POOL_create(nbThreads, 1);
+    mtctx->overlapLog = ZSTDMT_OVERLAPLOG_DEFAULT;
+    mtctx->factory = POOL_create(nbThreads, 0);
     mtctx->jobs = ZSTDMT_allocJobsTable(&nbJobs, cMem);
     mtctx->jobIDMask = nbJobs - 1;
-    mtctx->buffPool = ZSTDMT_createBufferPool(nbThreads, cMem);
+    mtctx->bufPool = ZSTDMT_createBufferPool(nbThreads, cMem);
     mtctx->cctxPool = ZSTDMT_createCCtxPool(nbThreads, cMem);
-    if (!mtctx->factory | !mtctx->jobs | !mtctx->buffPool | !mtctx->cctxPool) {
+    if (!mtctx->factory | !mtctx->jobs | !mtctx->bufPool | !mtctx->cctxPool) {
+        ZSTDMT_freeCCtx(mtctx);
+        return NULL;
+    }
+    if (pthread_mutex_init(&mtctx->jobCompleted_mutex, NULL)) {
+        ZSTDMT_freeCCtx(mtctx);
+        return NULL;
+    }
+    if (pthread_cond_init(&mtctx->jobCompleted_cond, NULL)) {
         ZSTDMT_freeCCtx(mtctx);
         return NULL;
     }
-    pthread_mutex_init(&mtctx->jobCompleted_mutex, NULL);   /* Todo : check init function return */
-    pthread_cond_init(&mtctx->jobCompleted_cond, NULL);
     DEBUGLOG(3, "mt_cctx created, for %u threads", nbThreads);
     return mtctx;
 }
@@ -386,15 +459,13 @@ static void ZSTDMT_releaseAllJobResources(ZSTDMT_CCtx* mtctx)
     unsigned jobID;
     DEBUGLOG(3, "ZSTDMT_releaseAllJobResources");
     for (jobID=0; jobID <= mtctx->jobIDMask; jobID++) {
-        ZSTDMT_releaseBuffer(mtctx->buffPool, mtctx->jobs[jobID].dstBuff);
+        ZSTDMT_releaseBuffer(mtctx->bufPool, mtctx->jobs[jobID].dstBuff);
         mtctx->jobs[jobID].dstBuff = g_nullBuffer;
-        ZSTDMT_releaseBuffer(mtctx->buffPool, mtctx->jobs[jobID].src);
+        ZSTDMT_releaseBuffer(mtctx->bufPool, mtctx->jobs[jobID].src);
         mtctx->jobs[jobID].src = g_nullBuffer;
-        ZSTDMT_releaseCCtx(mtctx->cctxPool, mtctx->jobs[jobID].cctx);
-        mtctx->jobs[jobID].cctx = NULL;
     }
     memset(mtctx->jobs, 0, (mtctx->jobIDMask+1)*sizeof(ZSTDMT_jobDescription));
-    ZSTDMT_releaseBuffer(mtctx->buffPool, mtctx->inBuff.buffer);
+    ZSTDMT_releaseBuffer(mtctx->bufPool, mtctx->inBuff.buffer);
     mtctx->inBuff.buffer = g_nullBuffer;
     mtctx->allJobsCompleted = 1;
 }
@@ -404,7 +475,7 @@ size_t ZSTDMT_freeCCtx(ZSTDMT_CCtx* mtctx)
     if (mtctx==NULL) return 0;   /* compatible with free on NULL */
     POOL_free(mtctx->factory);
     if (!mtctx->allJobsCompleted) ZSTDMT_releaseAllJobResources(mtctx); /* stop workers first */
-    ZSTDMT_freeBufferPool(mtctx->buffPool);  /* release job resources into pools first */
+    ZSTDMT_freeBufferPool(mtctx->bufPool);  /* release job resources into pools first */
     ZSTD_free(mtctx->jobs, mtctx->cMem);
     ZSTDMT_freeCCtxPool(mtctx->cctxPool);
     ZSTD_freeCDict(mtctx->cdictLocal);
@@ -418,11 +489,11 @@ size_t ZSTDMT_sizeof_CCtx(ZSTDMT_CCtx* mtctx)
 {
     if (mtctx == NULL) return 0;   /* supports sizeof NULL */
     return sizeof(*mtctx)
-        + POOL_sizeof(mtctx->factory)
-        + ZSTDMT_sizeof_bufferPool(mtctx->buffPool)
-        + (mtctx->jobIDMask+1) * sizeof(ZSTDMT_jobDescription)
-        + ZSTDMT_sizeof_CCtxPool(mtctx->cctxPool)
-        + ZSTD_sizeof_CDict(mtctx->cdictLocal);
+            + POOL_sizeof(mtctx->factory)
+            + ZSTDMT_sizeof_bufferPool(mtctx->bufPool)
+            + (mtctx->jobIDMask+1) * sizeof(ZSTDMT_jobDescription)
+            + ZSTDMT_sizeof_CCtxPool(mtctx->cctxPool)
+            + ZSTD_sizeof_CDict(mtctx->cdictLocal);
 }
 
 size_t ZSTDMT_setMTCtxParameter(ZSTDMT_CCtx* mtctx, ZSDTMT_parameter parameter, unsigned value)
@@ -434,10 +505,10 @@ size_t ZSTDMT_setMTCtxParameter(ZSTDMT_CCtx* mtctx, ZSDTMT_parameter parameter,
         return 0;
     case ZSTDMT_p_overlapSectionLog :
         DEBUGLOG(5, "ZSTDMT_p_overlapSectionLog : %u", value);
-        mtctx->overlapRLog = (value >= 9) ? 0 : 9 - value;
+        mtctx->overlapLog = (value >= 9) ? 9 : value;
         return 0;
     default :
-        return ERROR(compressionParameter_unsupported);
+        return ERROR(parameter_unsupported);
     }
 }
 
@@ -459,12 +530,13 @@ static unsigned computeNbChunks(size_t srcSize, unsigned windowLog, unsigned nbT
 
 
 size_t ZSTDMT_compress_advanced(ZSTDMT_CCtx* mtctx,
-                           void* dst, size_t dstCapacity,
-                     const void* src, size_t srcSize,
-                     const ZSTD_CDict* cdict,
-                           ZSTD_parameters const params,
-                           unsigned overlapRLog)
+                               void* dst, size_t dstCapacity,
+                         const void* src, size_t srcSize,
+                         const ZSTD_CDict* cdict,
+                               ZSTD_parameters const params,
+                               unsigned overlapLog)
 {
+    unsigned const overlapRLog = (overlapLog>9) ? 0 : 9-overlapLog;
     size_t const overlapSize = (overlapRLog>=9) ? 0 : (size_t)1 << (params.cParams.windowLog - overlapRLog);
     unsigned nbChunks = computeNbChunks(srcSize, params.cParams.windowLog, mtctx->nbThreads);
     size_t const proposedChunkSize = (srcSize + (nbChunks-1)) / nbChunks;
@@ -473,6 +545,7 @@ size_t ZSTDMT_compress_advanced(ZSTDMT_CCtx* mtctx,
     size_t remainingSrcSize = srcSize;
     unsigned const compressWithinDst = (dstCapacity >= ZSTD_compressBound(srcSize)) ? nbChunks : (unsigned)(dstCapacity / ZSTD_compressBound(avgChunkSize));  /* presumes avgChunkSize >= 256 KB, which should be the case */
     size_t frameStartPos = 0, dstBufferPos = 0;
+    XXH64_state_t xxh64;
 
     DEBUGLOG(4, "nbChunks  : %2u   (chunkSize : %u bytes)   ", nbChunks, (U32)avgChunkSize);
     if (nbChunks==1) {   /* fallback to single-thread mode */
@@ -480,7 +553,9 @@ size_t ZSTDMT_compress_advanced(ZSTDMT_CCtx* mtctx,
         if (cdict) return ZSTD_compress_usingCDict_advanced(cctx, dst, dstCapacity, src, srcSize, cdict, params.fParams);
         return ZSTD_compress_advanced(cctx, dst, dstCapacity, src, srcSize, NULL, 0, params);
     }
-    assert(avgChunkSize >= 256 KB);  /* condition for ZSTD_compressBound(A) + ZSTD_compressBound(B) <= ZSTD_compressBound(A+B), which is useful to avoid allocating extra buffers */
+    assert(avgChunkSize >= 256 KB);  /* condition for ZSTD_compressBound(A) + ZSTD_compressBound(B) <= ZSTD_compressBound(A+B), which is required for compressWithinDst */
+    ZSTDMT_setBufferSize(mtctx->bufPool, ZSTD_compressBound(avgChunkSize) );
+    XXH64_reset(&xxh64, 0);
 
     if (nbChunks > mtctx->jobIDMask+1) {  /* enlarge job table */
         U32 nbJobs = nbChunks;
@@ -496,17 +571,10 @@ size_t ZSTDMT_compress_advanced(ZSTDMT_CCtx* mtctx,
             size_t const chunkSize = MIN(remainingSrcSize, avgChunkSize);
             size_t const dstBufferCapacity = ZSTD_compressBound(chunkSize);
             buffer_t const dstAsBuffer = { (char*)dst + dstBufferPos, dstBufferCapacity };
-            buffer_t const dstBuffer = u < compressWithinDst ? dstAsBuffer : ZSTDMT_getBuffer(mtctx->buffPool, dstBufferCapacity);
-            ZSTD_CCtx* const cctx = ZSTDMT_getCCtx(mtctx->cctxPool);
+            buffer_t const dstBuffer = u < compressWithinDst ? dstAsBuffer : g_nullBuffer;
             size_t dictSize = u ? overlapSize : 0;
 
-            if ((cctx==NULL) || (dstBuffer.start==NULL)) {
-                mtctx->jobs[u].cSize = ERROR(memory_allocation);   /* job result */
-                mtctx->jobs[u].jobCompleted = 1;
-                nbChunks = u+1;   /* only wait and free u jobs, instead of initially expected nbChunks ones */
-                break;   /* let's wait for previous jobs to complete, but don't start new ones */
-            }
-
+            mtctx->jobs[u].src = g_nullBuffer;
             mtctx->jobs[u].srcStart = srcStart + frameStartPos - dictSize;
             mtctx->jobs[u].dictSize = dictSize;
             mtctx->jobs[u].srcSize = chunkSize;
@@ -516,13 +584,18 @@ size_t ZSTDMT_compress_advanced(ZSTDMT_CCtx* mtctx,
             /* do not calculate checksum within sections, but write it in header for first section */
             if (u!=0) mtctx->jobs[u].params.fParams.checksumFlag = 0;
             mtctx->jobs[u].dstBuff = dstBuffer;
-            mtctx->jobs[u].cctx = cctx;
+            mtctx->jobs[u].cctxPool = mtctx->cctxPool;
+            mtctx->jobs[u].bufPool = mtctx->bufPool;
             mtctx->jobs[u].firstChunk = (u==0);
             mtctx->jobs[u].lastChunk = (u==nbChunks-1);
             mtctx->jobs[u].jobCompleted = 0;
             mtctx->jobs[u].jobCompleted_mutex = &mtctx->jobCompleted_mutex;
             mtctx->jobs[u].jobCompleted_cond = &mtctx->jobCompleted_cond;
 
+            if (params.fParams.checksumFlag) {
+                XXH64_update(&xxh64, srcStart + frameStartPos, chunkSize);
+            }
+
             DEBUGLOG(5, "posting job %u   (%u bytes)", u, (U32)chunkSize);
             DEBUG_PRINTHEX(6, mtctx->jobs[u].srcStart, 12);
             POOL_add(mtctx->factory, ZSTDMT_compressChunk, &mtctx->jobs[u]);
@@ -533,8 +606,8 @@ size_t ZSTDMT_compress_advanced(ZSTDMT_CCtx* mtctx,
     }   }
 
     /* collect result */
-    {   unsigned chunkID;
-        size_t error = 0, dstPos = 0;
+    {   size_t error = 0, dstPos = 0;
+        unsigned chunkID;
         for (chunkID=0; chunkID<nbChunks; chunkID++) {
             DEBUGLOG(5, "waiting for chunk %u ", chunkID);
             PTHREAD_MUTEX_LOCK(&mtctx->jobCompleted_mutex);
@@ -545,8 +618,6 @@ size_t ZSTDMT_compress_advanced(ZSTDMT_CCtx* mtctx,
             pthread_mutex_unlock(&mtctx->jobCompleted_mutex);
             DEBUGLOG(5, "ready to write chunk %u ", chunkID);
 
-            ZSTDMT_releaseCCtx(mtctx->cctxPool, mtctx->jobs[chunkID].cctx);
-            mtctx->jobs[chunkID].cctx = NULL;
             mtctx->jobs[chunkID].srcStart = NULL;
             {   size_t const cSize = mtctx->jobs[chunkID].cSize;
                 if (ZSTD_isError(cSize)) error = cSize;
@@ -556,13 +627,25 @@ size_t ZSTDMT_compress_advanced(ZSTDMT_CCtx* mtctx,
                         memmove((char*)dst + dstPos, mtctx->jobs[chunkID].dstBuff.start, cSize);  /* may overlap when chunk compressed within dst */
                     if (chunkID >= compressWithinDst) {  /* chunk compressed into its own buffer, which must be released */
                         DEBUGLOG(5, "releasing buffer %u>=%u", chunkID, compressWithinDst);
-                        ZSTDMT_releaseBuffer(mtctx->buffPool, mtctx->jobs[chunkID].dstBuff);
+                        ZSTDMT_releaseBuffer(mtctx->bufPool, mtctx->jobs[chunkID].dstBuff);
                     }
                     mtctx->jobs[chunkID].dstBuff = g_nullBuffer;
                 }
                 dstPos += cSize ;
             }
-        }
+        }  /* for (chunkID=0; chunkID<nbChunks; chunkID++) */
+
+        DEBUGLOG(4, "checksumFlag : %u ", params.fParams.checksumFlag);
+        if (params.fParams.checksumFlag) {
+            U32 const checksum = (U32)XXH64_digest(&xxh64);
+            if (dstPos + 4 > dstCapacity) {
+                error = ERROR(dstSize_tooSmall);
+            } else {
+                DEBUGLOG(4, "writing checksum : %08X \n", checksum);
+                MEM_writeLE32((char*)dst + dstPos, checksum);
+                dstPos += 4;
+        }   }
+
         if (!error) DEBUGLOG(4, "compressed size : %u  ", (U32)dstPos);
         return error ? error : dstPos;
     }
@@ -574,10 +657,10 @@ size_t ZSTDMT_compressCCtx(ZSTDMT_CCtx* mtctx,
                      const void* src, size_t srcSize,
                            int compressionLevel)
 {
-    U32 const overlapRLog = (compressionLevel >= ZSTD_maxCLevel()) ? 0 : 3;
+    U32 const overlapLog = (compressionLevel >= ZSTD_maxCLevel()) ? 9 : ZSTDMT_OVERLAPLOG_DEFAULT;
     ZSTD_parameters params = ZSTD_getParams(compressionLevel, srcSize, 0);
     params.fParams.contentSizeFlag = 1;
-    return ZSTDMT_compress_advanced(mtctx, dst, dstCapacity, src, srcSize, NULL, params, overlapRLog);
+    return ZSTDMT_compress_advanced(mtctx, dst, dstCapacity, src, srcSize, NULL, params, overlapLog);
 }
 
 
@@ -615,8 +698,8 @@ size_t ZSTDMT_initCStream_internal(ZSTDMT_CCtx* zcs,
     if (zcs->nbThreads==1) {
         DEBUGLOG(4, "single thread mode");
         return ZSTD_initCStream_internal(zcs->cctxPool->cctx[0],
-                                dict, dictSize, cdict,
-                                params, pledgedSrcSize);
+                                        dict, dictSize, cdict,
+                                        params, pledgedSrcSize);
     }
 
     if (zcs->allJobsCompleted == 0) {   /* previous compression not correctly finished */
@@ -642,18 +725,16 @@ size_t ZSTDMT_initCStream_internal(ZSTDMT_CCtx* zcs,
         zcs->cdict = cdict;
     }
 
-    zcs->targetDictSize = (zcs->overlapRLog>=9) ? 0 : (size_t)1 << (zcs->params.cParams.windowLog - zcs->overlapRLog);
-    DEBUGLOG(4, "overlapRLog : %u ", zcs->overlapRLog);
+    zcs->targetDictSize = (zcs->overlapLog==0) ? 0 : (size_t)1 << (zcs->params.cParams.windowLog - (9 - zcs->overlapLog));
+    DEBUGLOG(4, "overlapLog : %u ", zcs->overlapLog);
     DEBUGLOG(4, "overlap Size : %u KB", (U32)(zcs->targetDictSize>>10));
     zcs->targetSectionSize = zcs->sectionSize ? zcs->sectionSize : (size_t)1 << (zcs->params.cParams.windowLog + 2);
     zcs->targetSectionSize = MAX(ZSTDMT_SECTION_SIZE_MIN, zcs->targetSectionSize);
     zcs->targetSectionSize = MAX(zcs->targetDictSize, zcs->targetSectionSize);
     DEBUGLOG(4, "Section Size : %u KB", (U32)(zcs->targetSectionSize>>10));
-    zcs->marginSize = zcs->targetSectionSize >> 2;
-    zcs->inBuffSize = zcs->targetDictSize + zcs->targetSectionSize + zcs->marginSize;
-    zcs->inBuff.buffer = ZSTDMT_getBuffer(zcs->buffPool, zcs->inBuffSize);
-    if (zcs->inBuff.buffer.start == NULL) return ERROR(memory_allocation);
-    zcs->inBuff.filled = 0;
+    zcs->inBuffSize = zcs->targetDictSize + zcs->targetSectionSize;
+    ZSTDMT_setBufferSize(zcs->bufPool, MAX(zcs->inBuffSize, ZSTD_compressBound(zcs->targetSectionSize)) );
+    zcs->inBuff.buffer = g_nullBuffer;
     zcs->dictSize = 0;
     zcs->doneJobID = 0;
     zcs->nextJobID = 0;
@@ -664,8 +745,9 @@ size_t ZSTDMT_initCStream_internal(ZSTDMT_CCtx* zcs,
 }
 
 size_t ZSTDMT_initCStream_advanced(ZSTDMT_CCtx* mtctx,
-                                const void* dict, size_t dictSize,
-                                ZSTD_parameters params, unsigned long long pledgedSrcSize)
+                             const void* dict, size_t dictSize,
+                                   ZSTD_parameters params,
+                                   unsigned long long pledgedSrcSize)
 {
     DEBUGLOG(5, "ZSTDMT_initCStream_advanced");
     return ZSTDMT_initCStream_internal(mtctx, dict, dictSize, NULL, params, pledgedSrcSize);
@@ -701,19 +783,8 @@ size_t ZSTDMT_initCStream(ZSTDMT_CCtx* zcs, int compressionLevel) {
 
 static size_t ZSTDMT_createCompressionJob(ZSTDMT_CCtx* zcs, size_t srcSize, unsigned endFrame)
 {
-    size_t const dstBufferCapacity = ZSTD_compressBound(srcSize);
-    buffer_t const dstBuffer = ZSTDMT_getBuffer(zcs->buffPool, dstBufferCapacity);
-    ZSTD_CCtx* const cctx = ZSTDMT_getCCtx(zcs->cctxPool);
     unsigned const jobID = zcs->nextJobID & zcs->jobIDMask;
 
-    if ((cctx==NULL) || (dstBuffer.start==NULL)) {
-        zcs->jobs[jobID].jobCompleted = 1;
-        zcs->nextJobID++;
-        ZSTDMT_waitForAllJobsCompleted(zcs);
-        ZSTDMT_releaseAllJobResources(zcs);
-        return ERROR(memory_allocation);
-    }
-
     DEBUGLOG(4, "preparing job %u to compress %u bytes with %u preload ",
                 zcs->nextJobID, (U32)srcSize, (U32)zcs->dictSize);
     zcs->jobs[jobID].src = zcs->inBuff.buffer;
@@ -726,8 +797,9 @@ static size_t ZSTDMT_createCompressionJob(ZSTDMT_CCtx* zcs, size_t srcSize, unsi
     if (zcs->nextJobID) zcs->jobs[jobID].params.fParams.checksumFlag = 0;
     zcs->jobs[jobID].cdict = zcs->nextJobID==0 ? zcs->cdict : NULL;
     zcs->jobs[jobID].fullFrameSize = zcs->frameContentSize;
-    zcs->jobs[jobID].dstBuff = dstBuffer;
-    zcs->jobs[jobID].cctx = cctx;
+    zcs->jobs[jobID].dstBuff = g_nullBuffer;
+    zcs->jobs[jobID].cctxPool = zcs->cctxPool;
+    zcs->jobs[jobID].bufPool = zcs->bufPool;
     zcs->jobs[jobID].firstChunk = (zcs->nextJobID==0);
     zcs->jobs[jobID].lastChunk = endFrame;
     zcs->jobs[jobID].jobCompleted = 0;
@@ -735,11 +807,13 @@ static size_t ZSTDMT_createCompressionJob(ZSTDMT_CCtx* zcs, size_t srcSize, unsi
     zcs->jobs[jobID].jobCompleted_mutex = &zcs->jobCompleted_mutex;
     zcs->jobs[jobID].jobCompleted_cond = &zcs->jobCompleted_cond;
 
+    if (zcs->params.fParams.checksumFlag)
+        XXH64_update(&zcs->xxhState, (const char*)zcs->inBuff.buffer.start + zcs->dictSize, srcSize);
+
     /* get a new buffer for next input */
     if (!endFrame) {
         size_t const newDictSize = MIN(srcSize + zcs->dictSize, zcs->targetDictSize);
-        DEBUGLOG(5, "ZSTDMT_createCompressionJob::endFrame = %u", endFrame);
-        zcs->inBuff.buffer = ZSTDMT_getBuffer(zcs->buffPool, zcs->inBuffSize);
+        zcs->inBuff.buffer = ZSTDMT_getBuffer(zcs->bufPool);
         if (zcs->inBuff.buffer.start == NULL) {   /* not enough memory to allocate next input buffer */
             zcs->jobs[jobID].jobCompleted = 1;
             zcs->nextJobID++;
@@ -747,26 +821,20 @@ static size_t ZSTDMT_createCompressionJob(ZSTDMT_CCtx* zcs, size_t srcSize, unsi
             ZSTDMT_releaseAllJobResources(zcs);
             return ERROR(memory_allocation);
         }
-        DEBUGLOG(5, "inBuff currently filled to %u", (U32)zcs->inBuff.filled);
         zcs->inBuff.filled -= srcSize + zcs->dictSize - newDictSize;
-        DEBUGLOG(5, "new job : inBuff filled to %u, with %u dict and %u src",
-                    (U32)zcs->inBuff.filled, (U32)newDictSize,
-                    (U32)(zcs->inBuff.filled - newDictSize));
         memmove(zcs->inBuff.buffer.start,
             (const char*)zcs->jobs[jobID].srcStart + zcs->dictSize + srcSize - newDictSize,
             zcs->inBuff.filled);
-        DEBUGLOG(5, "new inBuff pre-filled");
         zcs->dictSize = newDictSize;
     } else {   /* if (endFrame==1) */
-        DEBUGLOG(5, "ZSTDMT_createCompressionJob::endFrame = %u", endFrame);
         zcs->inBuff.buffer = g_nullBuffer;
         zcs->inBuff.filled = 0;
         zcs->dictSize = 0;
         zcs->frameEnded = 1;
-        if (zcs->nextJobID == 0)
+        if (zcs->nextJobID == 0) {
             /* single chunk exception : checksum is calculated directly within worker thread */
             zcs->params.fParams.checksumFlag = 0;
-    }
+    }   }
 
     DEBUGLOG(4, "posting job %u : %u bytes  (end:%u) (note : doneJob = %u=>%u)",
                 zcs->nextJobID,
@@ -804,11 +872,8 @@ static size_t ZSTDMT_flushNextJob(ZSTDMT_CCtx* zcs, ZSTD_outBuffer* output, unsi
                 ZSTDMT_releaseAllJobResources(zcs);
                 return job.cSize;
             }
-            ZSTDMT_releaseCCtx(zcs->cctxPool, job.cctx);
-            zcs->jobs[wJobID].cctx = NULL;
             DEBUGLOG(5, "zcs->params.fParams.checksumFlag : %u ", zcs->params.fParams.checksumFlag);
             if (zcs->params.fParams.checksumFlag) {
-                XXH64_update(&zcs->xxhState, (const char*)job.srcStart + job.dictSize, job.srcSize);
                 if (zcs->frameEnded && (zcs->doneJobID+1 == zcs->nextJobID)) {  /* write checksum at end of last section */
                     U32 const checksum = (U32)XXH64_digest(&zcs->xxhState);
                     DEBUGLOG(5, "writing checksum : %08X \n", checksum);
@@ -816,9 +881,6 @@ static size_t ZSTDMT_flushNextJob(ZSTDMT_CCtx* zcs, ZSTD_outBuffer* output, unsi
                     job.cSize += 4;
                     zcs->jobs[wJobID].cSize += 4;
             }   }
-            ZSTDMT_releaseBuffer(zcs->buffPool, job.src);
-            zcs->jobs[wJobID].srcStart = NULL;
-            zcs->jobs[wJobID].src = g_nullBuffer;
             zcs->jobs[wJobID].jobScanned = 1;
         }
         {   size_t const toWrite = MIN(job.cSize - job.dstFlushed, output->size - output->pos);
@@ -828,7 +890,7 @@ static size_t ZSTDMT_flushNextJob(ZSTDMT_CCtx* zcs, ZSTD_outBuffer* output, unsi
             job.dstFlushed += toWrite;
         }
         if (job.dstFlushed == job.cSize) {   /* output buffer fully flushed => move to next one */
-            ZSTDMT_releaseBuffer(zcs->buffPool, job.dstBuff);
+            ZSTDMT_releaseBuffer(zcs->bufPool, job.dstBuff);
             zcs->jobs[wJobID].dstBuff = g_nullBuffer;
             zcs->jobs[wJobID].jobCompleted = 0;
             zcs->doneJobID++;
@@ -852,18 +914,18 @@ size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,
                                      ZSTD_inBuffer* input,
                                      ZSTD_EndDirective endOp)
 {
-    size_t const newJobThreshold = mtctx->dictSize + mtctx->targetSectionSize + mtctx->marginSize;
+    size_t const newJobThreshold = mtctx->dictSize + mtctx->targetSectionSize;
     assert(output->pos <= output->size);
     assert(input->pos  <= input->size);
     if ((mtctx->frameEnded) && (endOp==ZSTD_e_continue)) {
         /* current frame being ended. Only flush/end are allowed. Or start new frame with init */
         return ERROR(stage_wrong);
     }
-    if (mtctx->nbThreads==1) {
+    if (mtctx->nbThreads==1) {  /* delegate to single-thread (synchronous) */
         return ZSTD_compressStream_generic(mtctx->cctxPool->cctx[0], output, input, endOp);
     }
 
-    /* single-pass shortcut (note : this is blocking-mode) */
+    /* single-pass shortcut (note : this is synchronous-mode) */
     if ( (mtctx->nextJobID==0)      /* just started */
       && (mtctx->inBuff.filled==0)  /* nothing buffered */
       && (endOp==ZSTD_e_end)        /* end order */
@@ -871,24 +933,29 @@ size_t ZSTDMT_compressStream_generic(ZSTDMT_CCtx* mtctx,
         size_t const cSize = ZSTDMT_compress_advanced(mtctx,
                 (char*)output->dst + output->pos, output->size - output->pos,
                 (const char*)input->src + input->pos, input->size - input->pos,
-                mtctx->cdict, mtctx->params, mtctx->overlapRLog);
+                mtctx->cdict, mtctx->params, mtctx->overlapLog);
         if (ZSTD_isError(cSize)) return cSize;
         input->pos = input->size;
         output->pos += cSize;
-        ZSTDMT_releaseBuffer(mtctx->buffPool, mtctx->inBuff.buffer);  /* was allocated in initStream */
+        ZSTDMT_releaseBuffer(mtctx->bufPool, mtctx->inBuff.buffer);  /* was allocated in initStream */
         mtctx->allJobsCompleted = 1;
         mtctx->frameEnded = 1;
         return 0;
     }
 
     /* fill input buffer */
-    if ((input->src) && (mtctx->inBuff.buffer.start)) {   /* support NULL input */
-        size_t const toLoad = MIN(input->size - input->pos, mtctx->inBuffSize - mtctx->inBuff.filled);
-        DEBUGLOG(2, "inBuff:%08X;  inBuffSize=%u;  ToCopy=%u", (U32)(size_t)mtctx->inBuff.buffer.start, (U32)mtctx->inBuffSize, (U32)toLoad);
-        memcpy((char*)mtctx->inBuff.buffer.start + mtctx->inBuff.filled, (const char*)input->src + input->pos, toLoad);
-        input->pos += toLoad;
-        mtctx->inBuff.filled += toLoad;
-    }
+    if (input->size > input->pos) {   /* support NULL input */
+        if (mtctx->inBuff.buffer.start == NULL) {
+            mtctx->inBuff.buffer = ZSTDMT_getBuffer(mtctx->bufPool);
+            if (mtctx->inBuff.buffer.start == NULL) return ERROR(memory_allocation);
+            mtctx->inBuff.filled = 0;
+        }
+        {   size_t const toLoad = MIN(input->size - input->pos, mtctx->inBuffSize - mtctx->inBuff.filled);
+            DEBUGLOG(5, "inBuff:%08X;  inBuffSize=%u;  ToCopy=%u", (U32)(size_t)mtctx->inBuff.buffer.start, (U32)mtctx->inBuffSize, (U32)toLoad);
+            memcpy((char*)mtctx->inBuff.buffer.start + mtctx->inBuff.filled, (const char*)input->src + input->pos, toLoad);
+            input->pos += toLoad;
+            mtctx->inBuff.filled += toLoad;
+    }   }
 
     if ( (mtctx->inBuff.filled >= newJobThreshold)  /* filled enough : let's compress */
       && (mtctx->nextJobID <= mtctx->doneJobID + mtctx->jobIDMask) ) {   /* avoid overwriting job round buffer */
diff --git a/contrib/libzstd/include/zstd/compress/zstdmt_compress.h b/contrib/libzstd/include/zstd/compress/zstdmt_compress.h
index fad63b6d861..0f0fc2b03fc 100644
--- a/contrib/libzstd/include/zstd/compress/zstdmt_compress.h
+++ b/contrib/libzstd/include/zstd/compress/zstdmt_compress.h
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
  #ifndef ZSTDMT_COMPRESS_H
@@ -15,10 +15,11 @@
  #endif
 
 
-/* Note : All prototypes defined in this file are labelled experimental.
- *        No guarantee of API continuity is provided on any of them.
- *        In fact, the expectation is that these prototypes will be replaced
- *        by ZSTD_compress_generic() API in the near future */
+/* Note : This is an internal API.
+ *        Some methods are still exposed (ZSTDLIB_API),
+ *        because it used to be the only way to invoke MT compression.
+ *        Now, it's recommended to use ZSTD_compress_generic() instead.
+ *        These methods will stop being exposed in a future version */
 
 /* ===   Dependencies   === */
 #include <stddef.h>                /* size_t */
@@ -67,7 +68,7 @@ ZSTDLIB_API size_t ZSTDMT_compress_advanced(ZSTDMT_CCtx* mtctx,
                                      const void* src, size_t srcSize,
                                      const ZSTD_CDict* cdict,
                                            ZSTD_parameters const params,
-                                           unsigned overlapRLog);
+                                           unsigned overlapLog);
 
 ZSTDLIB_API size_t ZSTDMT_initCStream_advanced(ZSTDMT_CCtx* mtctx,
                                         const void* dict, size_t dictSize,   /* dict can be released after init, a local copy is preserved within zcs */
diff --git a/contrib/libzstd/include/zstd/decompress/huf_decompress.c b/contrib/libzstd/include/zstd/decompress/huf_decompress.c
index 2a1b70ea5ef..79ded96bf61 100644
--- a/contrib/libzstd/include/zstd/decompress/huf_decompress.c
+++ b/contrib/libzstd/include/zstd/decompress/huf_decompress.c
@@ -32,38 +32,22 @@
     - Public forum : https://groups.google.com/forum/#!forum/lz4c
 ****************************************************************** */
 
-/* **************************************************************
-*  Compiler specifics
-****************************************************************/
-#ifdef _MSC_VER    /* Visual Studio */
-#  define FORCE_INLINE static __forceinline
-#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
-#else
-#  if defined (__cplusplus) || defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
-#    ifdef __GNUC__
-#      define FORCE_INLINE static inline __attribute__((always_inline))
-#    else
-#      define FORCE_INLINE static inline
-#    endif
-#  else
-#    define FORCE_INLINE static
-#  endif /* __STDC_VERSION__ */
-#endif
-
-
 /* **************************************************************
 *  Dependencies
 ****************************************************************/
 #include <string.h>     /* memcpy, memset */
 #include "bitstream.h"  /* BIT_* */
+#include "compiler.h"
 #include "fse.h"        /* header compression */
 #define HUF_STATIC_LINKING_ONLY
 #include "huf.h"
+#include "error_private.h"
 
 
 /* **************************************************************
 *  Error Management
 ****************************************************************/
+#define HUF_isError ERR_isError
 #define HUF_STATIC_ASSERT(c) { enum { HUF_static_assert = 1/(int)(!!(c)) }; }   /* use only *after* variable declarations */
 
 
@@ -180,7 +164,7 @@ static BYTE HUF_decodeSymbolX2(BIT_DStream_t* Dstream, const HUF_DEltX2* dt, con
     if (MEM_64bits()) \
         HUF_DECODE_SYMBOLX2_0(ptr, DStreamPtr)
 
-FORCE_INLINE size_t HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX2* const dt, const U32 dtLog)
+HINT_INLINE size_t HUF_decodeStreamX2(BYTE* p, BIT_DStream_t* const bitDPtr, BYTE* const pEnd, const HUF_DEltX2* const dt, const U32 dtLog)
 {
     BYTE* const pStart = p;
 
@@ -639,7 +623,7 @@ static U32 HUF_decodeLastSymbolX4(void* op, BIT_DStream_t* DStream, const HUF_DE
     if (MEM_64bits()) \
         ptr += HUF_decodeSymbolX4(ptr, DStreamPtr, dt, dtLog)
 
-FORCE_INLINE size_t HUF_decodeStreamX4(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, const HUF_DEltX4* const dt, const U32 dtLog)
+HINT_INLINE size_t HUF_decodeStreamX4(BYTE* p, BIT_DStream_t* bitDPtr, BYTE* const pEnd, const HUF_DEltX4* const dt, const U32 dtLog)
 {
     BYTE* const pStart = p;
 
@@ -917,11 +901,11 @@ static const algo_time_t algoTime[16 /* Quantization */][3 /* single, double, qu
 *   Tells which decoder is likely to decode faster,
 *   based on a set of pre-determined metrics.
 *   @return : 0==HUF_decompress4X2, 1==HUF_decompress4X4 .
-*   Assumption : 0 < cSrcSize < dstSize <= 128 KB */
+*   Assumption : 0 < cSrcSize, dstSize <= 128 KB */
 U32 HUF_selectDecoder (size_t dstSize, size_t cSrcSize)
 {
     /* decoder timing evaluation */
-    U32 const Q = (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 since dstSize > cSrcSize */
+    U32 const Q = cSrcSize >= dstSize ? 15 : (U32)(cSrcSize * 16 / dstSize);   /* Q < 16 */
     U32 const D256 = (U32)(dstSize >> 8);
     U32 const DTime0 = algoTime[Q][0].tableTime + (algoTime[Q][0].decode256Time * D256);
     U32 DTime1 = algoTime[Q][1].tableTime + (algoTime[Q][1].decode256Time * D256);
@@ -977,7 +961,7 @@ size_t HUF_decompress4X_hufOnly_wksp(HUF_DTable* dctx, void* dst,
 {
     /* validation checks */
     if (dstSize == 0) return ERROR(dstSize_tooSmall);
-    if ((cSrcSize >= dstSize) || (cSrcSize <= 1)) return ERROR(corruption_detected);   /* invalid */
+    if (cSrcSize == 0) return ERROR(corruption_detected);
 
     {   U32 const algoNb = HUF_selectDecoder(dstSize, cSrcSize);
         return algoNb ? HUF_decompress4X4_DCtx_wksp(dctx, dst, dstSize, cSrc, cSrcSize, workSpace, wkspSize):
diff --git a/contrib/libzstd/include/zstd/decompress/zstd_decompress.c b/contrib/libzstd/include/zstd/decompress/zstd_decompress.c
index 003d703a5eb..d2bc545e52c 100644
--- a/contrib/libzstd/include/zstd/decompress/zstd_decompress.c
+++ b/contrib/libzstd/include/zstd/decompress/zstd_decompress.c
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 
@@ -53,15 +53,6 @@
 #  include "zstd_legacy.h"
 #endif
 
-#if defined(_MSC_VER) && !defined(_M_IA64)  /* _mm_prefetch() is not defined for ia64 */
-#  include <mmintrin.h>   /* https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx */
-#  define ZSTD_PREFETCH(ptr)   _mm_prefetch((const char*)ptr, _MM_HINT_T0)
-#elif defined(__GNUC__)
-#  define ZSTD_PREFETCH(ptr)   __builtin_prefetch(ptr, 0, 0)
-#else
-#  define ZSTD_PREFETCH(ptr)   /* disabled */
-#endif
-
 
 /*-*************************************
 *  Errors
@@ -95,7 +86,7 @@ typedef struct {
     HUF_DTable hufTable[HUF_DTABLE_SIZE(HufLog)];  /* can accommodate HUF_decompress4X */
     U32 workspace[HUF_DECOMPRESS_WORKSPACE_SIZE_U32];
     U32 rep[ZSTD_REP_NUM];
-} ZSTD_entropyTables_t;
+} ZSTD_entropyDTables_t;
 
 struct ZSTD_DCtx_s
 {
@@ -103,7 +94,7 @@ struct ZSTD_DCtx_s
     const FSE_DTable* MLTptr;
     const FSE_DTable* OFTptr;
     const HUF_DTable* HUFptr;
-    ZSTD_entropyTables_t entropy;
+    ZSTD_entropyDTables_t entropy;
     const void* previousDstEnd;   /* detect continuity */
     const void* base;             /* start of current segment */
     const void* vBase;            /* virtual start of previous segment if it was just before current one */
@@ -304,15 +295,18 @@ size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t src
                 return ZSTD_skippableHeaderSize; /* magic number + frame length */
             memset(zfhPtr, 0, sizeof(*zfhPtr));
             zfhPtr->frameContentSize = MEM_readLE32((const char *)src + 4);
-            zfhPtr->windowSize = 0; /* windowSize==0 means a frame is skippable */
+            zfhPtr->frameType = ZSTD_skippableFrame;
+            zfhPtr->windowSize = 0;
             return 0;
         }
         return ERROR(prefix_unknown);
     }
 
     /* ensure there is enough `srcSize` to fully read/decode frame header */
-    { size_t const fhsize = ZSTD_frameHeaderSize(src, srcSize);
-      if (srcSize < fhsize) return fhsize; }
+    {   size_t const fhsize = ZSTD_frameHeaderSize(src, srcSize);
+        if (srcSize < fhsize) return fhsize;
+        zfhPtr->headerSize = (U32)fhsize;
+    }
 
     {   BYTE const fhdByte = ip[4];
         size_t pos = 5;
@@ -320,24 +314,23 @@ size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t src
         U32 const checksumFlag = (fhdByte>>2)&1;
         U32 const singleSegment = (fhdByte>>5)&1;
         U32 const fcsID = fhdByte>>6;
-        U32 const windowSizeMax = 1U << ZSTD_WINDOWLOG_MAX;
-        U32 windowSize = 0;
+        U64 windowSize = 0;
         U32 dictID = 0;
-        U64 frameContentSize = 0;
+        U64 frameContentSize = ZSTD_CONTENTSIZE_UNKNOWN;
         if ((fhdByte & 0x08) != 0)
-            return ERROR(frameParameter_unsupported);   /* reserved bits, must be zero */
+            return ERROR(frameParameter_unsupported); /* reserved bits, must be zero */
+
         if (!singleSegment) {
             BYTE const wlByte = ip[pos++];
             U32 const windowLog = (wlByte >> 3) + ZSTD_WINDOWLOG_ABSOLUTEMIN;
             if (windowLog > ZSTD_WINDOWLOG_MAX)
                 return ERROR(frameParameter_windowTooLarge);
-            windowSize = (1U << windowLog);
+            windowSize = (1ULL << windowLog);
             windowSize += (windowSize >> 3) * (wlByte&7);
         }
-
         switch(dictIDSizeCode)
         {
-            default:   /* impossible */
+            default: assert(0);  /* impossible */
             case 0 : break;
             case 1 : dictID = ip[pos]; pos++; break;
             case 2 : dictID = MEM_readLE16(ip+pos); pos+=2; break;
@@ -345,14 +338,15 @@ size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t src
         }
         switch(fcsID)
         {
-            default:   /* impossible */
+            default: assert(0);  /* impossible */
             case 0 : if (singleSegment) frameContentSize = ip[pos]; break;
             case 1 : frameContentSize = MEM_readLE16(ip+pos)+256; break;
             case 2 : frameContentSize = MEM_readLE32(ip+pos); break;
             case 3 : frameContentSize = MEM_readLE64(ip+pos); break;
         }
-        if (!windowSize) windowSize = (U32)frameContentSize;
-        if (windowSize > windowSizeMax) return ERROR(frameParameter_windowTooLarge);
+        if (singleSegment) windowSize = frameContentSize;
+
+        zfhPtr->frameType = ZSTD_frame;
         zfhPtr->frameContentSize = frameContentSize;
         zfhPtr->windowSize = windowSize;
         zfhPtr->dictID = dictID;
@@ -362,10 +356,10 @@ size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t src
 }
 
 /** ZSTD_getFrameContentSize() :
-*   compatible with legacy mode
-*   @return : decompressed size of the single frame pointed to be `src` if known, otherwise
-*             - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined
-*             - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small) */
+ *  compatible with legacy mode
+ * @return : decompressed size of the single frame pointed to be `src` if known, otherwise
+ *         - ZSTD_CONTENTSIZE_UNKNOWN if the size cannot be determined
+ *         - ZSTD_CONTENTSIZE_ERROR if an error occurred (e.g. invalid magic number, srcSize too small) */
 unsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize)
 {
 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
@@ -374,17 +368,14 @@ unsigned long long ZSTD_getFrameContentSize(const void *src, size_t srcSize)
         return ret == 0 ? ZSTD_CONTENTSIZE_UNKNOWN : ret;
     }
 #endif
-    {   ZSTD_frameHeader fParams;
-        if (ZSTD_getFrameHeader(&fParams, src, srcSize) != 0) return ZSTD_CONTENTSIZE_ERROR;
-        if (fParams.windowSize == 0) {
-            /* Either skippable or empty frame, size == 0 either way */
+    {   ZSTD_frameHeader zfh;
+        if (ZSTD_getFrameHeader(&zfh, src, srcSize) != 0)
+            return ZSTD_CONTENTSIZE_ERROR;
+        if (zfh.frameType == ZSTD_skippableFrame) {
             return 0;
-        } else if (fParams.frameContentSize != 0) {
-            return fParams.frameContentSize;
         } else {
-            return ZSTD_CONTENTSIZE_UNKNOWN;
-        }
-    }
+            return zfh.frameContentSize;
+    }   }
 }
 
 /** ZSTD_findDecompressedSize() :
@@ -442,7 +433,8 @@ unsigned long long ZSTD_findDecompressedSize(const void* src, size_t srcSize)
 *   compatible with legacy mode
 *   @return : decompressed size if known, 0 otherwise
               note : 0 can mean any of the following :
-                   - decompressed size is not present within frame header
+                   - frame content is empty
+                   - decompressed size field is not present in frame header
                    - frame header unknown / not supported
                    - frame header not complete (`srcSize` too small) */
 unsigned long long ZSTD_getDecompressedSize(const void* src, size_t srcSize)
@@ -460,19 +452,13 @@ static size_t ZSTD_decodeFrameHeader(ZSTD_DCtx* dctx, const void* src, size_t he
     size_t const result = ZSTD_getFrameHeader(&(dctx->fParams), src, headerSize);
     if (ZSTD_isError(result)) return result;  /* invalid header */
     if (result>0) return ERROR(srcSize_wrong);   /* headerSize too small */
-    if (dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID)) return ERROR(dictionary_wrong);
+    if (dctx->fParams.dictID && (dctx->dictID != dctx->fParams.dictID))
+        return ERROR(dictionary_wrong);
     if (dctx->fParams.checksumFlag) XXH64_reset(&dctx->xxhState, 0);
     return 0;
 }
 
 
-typedef struct
-{
-    blockType_e blockType;
-    U32 lastBlock;
-    U32 origSize;
-} blockProperties_t;
-
 /*! ZSTD_getcBlockSize() :
 *   Provides the size of compressed block from block header `src` */
 size_t ZSTD_getcBlockSize(const void* src, size_t srcSize,
@@ -958,7 +944,7 @@ static seq_t ZSTD_decodeSequence(seqState_t* seqState)
 }
 
 
-FORCE_INLINE
+HINT_INLINE
 size_t ZSTD_execSequence(BYTE* op,
                          BYTE* const oend, seq_t sequence,
                          const BYTE** litPtr, const BYTE* const litLimit,
@@ -1102,7 +1088,7 @@ static size_t ZSTD_decompressSequences(
 }
 
 
-FORCE_INLINE seq_t ZSTD_decodeSequenceLong_generic(seqState_t* seqState, int const longOffsets)
+FORCE_INLINE_TEMPLATE seq_t ZSTD_decodeSequenceLong_generic(seqState_t* seqState, int const longOffsets)
 {
     seq_t seq;
 
@@ -1202,7 +1188,7 @@ static seq_t ZSTD_decodeSequenceLong(seqState_t* seqState, unsigned const window
     }
 }
 
-FORCE_INLINE
+HINT_INLINE
 size_t ZSTD_execSequenceLong(BYTE* op,
                                 BYTE* const oend, seq_t sequence,
                                 const BYTE** litPtr, const BYTE* const litLimit,
@@ -1338,7 +1324,7 @@ static size_t ZSTD_decompressSequencesLong(
             seq_t const sequence = ZSTD_decodeSequenceLong(&seqState, windowSize32);
             size_t const oneSeqSize = ZSTD_execSequenceLong(op, oend, sequences[(seqNb-ADVANCED_SEQS) & STOSEQ_MASK], &litPtr, litEnd, base, vBase, dictEnd);
             if (ZSTD_isError(oneSeqSize)) return oneSeqSize;
-            ZSTD_PREFETCH(sequence.match);
+            PREFETCH(sequence.match);
             sequences[seqNb&STOSEQ_MASK] = sequence;
             op += oneSeqSize;
         }
@@ -1440,28 +1426,26 @@ size_t ZSTD_generateNxBytes(void* dst, size_t dstCapacity, BYTE byte, size_t len
 size_t ZSTD_findFrameCompressedSize(const void *src, size_t srcSize)
 {
 #if defined(ZSTD_LEGACY_SUPPORT) && (ZSTD_LEGACY_SUPPORT >= 1)
-    if (ZSTD_isLegacy(src, srcSize)) return ZSTD_findFrameCompressedSizeLegacy(src, srcSize);
+    if (ZSTD_isLegacy(src, srcSize))
+        return ZSTD_findFrameCompressedSizeLegacy(src, srcSize);
 #endif
-    if (srcSize >= ZSTD_skippableHeaderSize &&
-            (MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START) {
+    if ( (srcSize >= ZSTD_skippableHeaderSize)
+      && (MEM_readLE32(src) & 0xFFFFFFF0U) == ZSTD_MAGIC_SKIPPABLE_START ) {
         return ZSTD_skippableHeaderSize + MEM_readLE32((const BYTE*)src + 4);
     } else {
         const BYTE* ip = (const BYTE*)src;
         const BYTE* const ipstart = ip;
         size_t remainingSize = srcSize;
-        ZSTD_frameHeader fParams;
+        ZSTD_frameHeader zfh;
 
-        size_t const headerSize = ZSTD_frameHeaderSize(ip, remainingSize);
-        if (ZSTD_isError(headerSize)) return headerSize;
-
-        /* Frame Header */
-        {   size_t const ret = ZSTD_getFrameHeader(&fParams, ip, remainingSize);
+        /* Extract Frame Header */
+        {   size_t const ret = ZSTD_getFrameHeader(&zfh, src, srcSize);
             if (ZSTD_isError(ret)) return ret;
             if (ret > 0) return ERROR(srcSize_wrong);
         }
 
-        ip += headerSize;
-        remainingSize -= headerSize;
+        ip += zfh.headerSize;
+        remainingSize -= zfh.headerSize;
 
         /* Loop on each block */
         while (1) {
@@ -1469,7 +1453,8 @@ size_t ZSTD_findFrameCompressedSize(const void *src, size_t srcSize)
             size_t const cBlockSize = ZSTD_getcBlockSize(ip, remainingSize, &blockProperties);
             if (ZSTD_isError(cBlockSize)) return cBlockSize;
 
-            if (ZSTD_blockHeaderSize + cBlockSize > remainingSize) return ERROR(srcSize_wrong);
+            if (ZSTD_blockHeaderSize + cBlockSize > remainingSize)
+                return ERROR(srcSize_wrong);
 
             ip += ZSTD_blockHeaderSize + cBlockSize;
             remainingSize -= ZSTD_blockHeaderSize + cBlockSize;
@@ -1477,7 +1462,7 @@ size_t ZSTD_findFrameCompressedSize(const void *src, size_t srcSize)
             if (blockProperties.lastBlock) break;
         }
 
-        if (fParams.checksumFlag) {   /* Frame content checksum */
+        if (zfh.checksumFlag) {   /* Final frame content checksum */
             if (remainingSize < 4) return ERROR(srcSize_wrong);
             ip += 4;
             remainingSize -= 4;
@@ -1490,8 +1475,8 @@ size_t ZSTD_findFrameCompressedSize(const void *src, size_t srcSize)
 /*! ZSTD_decompressFrame() :
 *   @dctx must be properly initialized */
 static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx,
-                                 void* dst, size_t dstCapacity,
-                                 const void** srcPtr, size_t *srcSizePtr)
+                                   void* dst, size_t dstCapacity,
+                             const void** srcPtr, size_t *srcSizePtr)
 {
     const BYTE* ip = (const BYTE*)(*srcPtr);
     BYTE* const ostart = (BYTE* const)dst;
@@ -1500,13 +1485,15 @@ static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx,
     size_t remainingSize = *srcSizePtr;
 
     /* check */
-    if (remainingSize < ZSTD_frameHeaderSize_min+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
+    if (remainingSize < ZSTD_frameHeaderSize_min+ZSTD_blockHeaderSize)
+        return ERROR(srcSize_wrong);
 
     /* Frame Header */
     {   size_t const frameHeaderSize = ZSTD_frameHeaderSize(ip, ZSTD_frameHeaderSize_prefix);
         if (ZSTD_isError(frameHeaderSize)) return frameHeaderSize;
-        if (remainingSize < frameHeaderSize+ZSTD_blockHeaderSize) return ERROR(srcSize_wrong);
-        CHECK_F(ZSTD_decodeFrameHeader(dctx, ip, frameHeaderSize));
+        if (remainingSize < frameHeaderSize+ZSTD_blockHeaderSize)
+            return ERROR(srcSize_wrong);
+        CHECK_F( ZSTD_decodeFrameHeader(dctx, ip, frameHeaderSize) );
         ip += frameHeaderSize; remainingSize -= frameHeaderSize;
     }
 
@@ -1538,14 +1525,15 @@ static size_t ZSTD_decompressFrame(ZSTD_DCtx* dctx,
         }
 
         if (ZSTD_isError(decodedSize)) return decodedSize;
-        if (dctx->fParams.checksumFlag) XXH64_update(&dctx->xxhState, op, decodedSize);
+        if (dctx->fParams.checksumFlag)
+            XXH64_update(&dctx->xxhState, op, decodedSize);
         op += decodedSize;
         ip += cBlockSize;
         remainingSize -= cBlockSize;
         if (blockProperties.lastBlock) break;
     }
 
-    if (dctx->fParams.checksumFlag) {   /* Frame content checksum verification */
+    if (dctx->fParams.checksumFlag) { /* Frame content checksum verification */
         U32 const checkCalc = (U32)XXH64_digest(&dctx->xxhState);
         U32 checkRead;
         if (remainingSize<4) return ERROR(checksum_wrong);
@@ -1567,17 +1555,13 @@ static size_t ZSTD_DDictDictSize(const ZSTD_DDict* ddict);
 static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
                                         void* dst, size_t dstCapacity,
                                   const void* src, size_t srcSize,
-                                  const void *dict, size_t dictSize,
+                                  const void* dict, size_t dictSize,
                                   const ZSTD_DDict* ddict)
 {
     void* const dststart = dst;
+    assert(dict==NULL || ddict==NULL);  /* either dict or ddict set, not both */
 
     if (ddict) {
-        if (dict) {
-            /* programmer error, these two cases should be mutually exclusive */
-            return ERROR(GENERIC);
-        }
-
         dict = ZSTD_DDictDictContent(ddict);
         dictSize = ZSTD_DDictDictSize(ddict);
     }
@@ -1590,7 +1574,7 @@ static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
             size_t decodedSize;
             size_t const frameSize = ZSTD_findFrameCompressedSizeLegacy(src, srcSize);
             if (ZSTD_isError(frameSize)) return frameSize;
-            /* legacy support is incompatible with static dctx */
+            /* legacy support is not compatible with static dctx */
             if (dctx->staticSize) return ERROR(memory_allocation);
 
             decodedSize = ZSTD_decompressLegacy(dst, dstCapacity, src, frameSize, dict, dictSize);
@@ -1613,16 +1597,13 @@ static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
                     return ERROR(srcSize_wrong);
                 skippableSize = MEM_readLE32((const BYTE *)src + 4) +
                                 ZSTD_skippableHeaderSize;
-                if (srcSize < skippableSize) {
-                    return ERROR(srcSize_wrong);
-                }
+                if (srcSize < skippableSize) return ERROR(srcSize_wrong);
 
                 src = (const BYTE *)src + skippableSize;
                 srcSize -= skippableSize;
                 continue;
-            } else {
-                return ERROR(prefix_unknown);
             }
+            return ERROR(prefix_unknown);
         }
 
         if (ddict) {
@@ -1638,12 +1619,11 @@ static size_t ZSTD_decompressMultiFrame(ZSTD_DCtx* dctx,
         {   const size_t res = ZSTD_decompressFrame(dctx, dst, dstCapacity,
                                                     &src, &srcSize);
             if (ZSTD_isError(res)) return res;
-            /* don't need to bounds check this, ZSTD_decompressFrame will have
-             * already */
+            /* no need to bound check, ZSTD_decompressFrame already has */
             dst = (BYTE*)dst + res;
             dstCapacity -= res;
         }
-    }
+    }  /* while (srcSize >= ZSTD_frameHeaderSize_prefix) */
 
     if (srcSize) return ERROR(srcSize_wrong); /* input not entirely consumed */
 
@@ -1742,7 +1722,7 @@ size_t ZSTD_decompressContinue(ZSTD_DCtx* dctx, void* dst, size_t dstCapacity, c
             return 0;
         }
         dctx->expected = 0;   /* not necessary to copy more */
-
+        /* fall-through */
     case ZSTDds_decodeFrameHeader:
         assert(src != NULL);
         memcpy(dctx->headerBuffer + ZSTD_frameHeaderSize_prefix, src, dctx->expected);
@@ -1853,7 +1833,7 @@ static size_t ZSTD_refDictContent(ZSTD_DCtx* dctx, const void* dict, size_t dict
 /* ZSTD_loadEntropy() :
  * dict : must point at beginning of a valid zstd dictionary
  * @return : size of entropy tables read */
-static size_t ZSTD_loadEntropy(ZSTD_entropyTables_t* entropy, const void* const dict, size_t const dictSize)
+static size_t ZSTD_loadEntropy(ZSTD_entropyDTables_t* entropy, const void* const dict, size_t const dictSize)
 {
     const BYTE* dictPtr = (const BYTE*)dict;
     const BYTE* const dictEnd = dictPtr + dictSize;
@@ -1931,8 +1911,9 @@ static size_t ZSTD_decompress_insertDictionary(ZSTD_DCtx* dctx, const void* dict
 
 size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize)
 {
-    CHECK_F(ZSTD_decompressBegin(dctx));
-    if (dict && dictSize) CHECK_E(ZSTD_decompress_insertDictionary(dctx, dict, dictSize), dictionary_corrupted);
+    CHECK_F( ZSTD_decompressBegin(dctx) );
+    if (dict && dictSize)
+        CHECK_E(ZSTD_decompress_insertDictionary(dctx, dict, dictSize), dictionary_corrupted);
     return 0;
 }
 
@@ -1943,7 +1924,7 @@ struct ZSTD_DDict_s {
     void* dictBuffer;
     const void* dictContent;
     size_t dictSize;
-    ZSTD_entropyTables_t entropy;
+    ZSTD_entropyDTables_t entropy;
     U32 dictID;
     U32 entropyPresent;
     ZSTD_customMem cMem;
@@ -1961,7 +1942,7 @@ static size_t ZSTD_DDictDictSize(const ZSTD_DDict* ddict)
 
 size_t ZSTD_decompressBegin_usingDDict(ZSTD_DCtx* dstDCtx, const ZSTD_DDict* ddict)
 {
-    CHECK_F(ZSTD_decompressBegin(dstDCtx));
+    CHECK_F( ZSTD_decompressBegin(dstDCtx) );
     if (ddict) {   /* support begin on NULL */
         dstDCtx->dictID = ddict->dictID;
         dstDCtx->base = ddict->dictContent;
@@ -2142,7 +2123,7 @@ unsigned ZSTD_getDictID_fromDDict(const ZSTD_DDict* ddict)
  *  ZSTD_getFrameHeader(), which will provide a more precise error code. */
 unsigned ZSTD_getDictID_fromFrame(const void* src, size_t srcSize)
 {
-    ZSTD_frameHeader zfp = { 0 , 0 , 0 , 0 };
+    ZSTD_frameHeader zfp = { 0, 0, ZSTD_frame, 0, 0, 0 };
     size_t const hError = ZSTD_getFrameHeader(&zfp, src, srcSize);
     if (ZSTD_isError(hError)) return 0;
     return zfp.dictID;
@@ -2237,7 +2218,7 @@ size_t ZSTD_setDStreamParameter(ZSTD_DStream* zds,
 {
     switch(paramType)
     {
-        default : return ERROR(parameter_unknown);
+        default : return ERROR(parameter_unsupported);
         case DStream_p_maxWindowSize : zds->maxWindowSize = paramValue ? paramValue : (U32)(-1); break;
     }
     return 0;
@@ -2254,16 +2235,19 @@ size_t ZSTD_estimateDStreamSize(size_t windowSize)
     size_t const blockSize = MIN(windowSize, ZSTD_BLOCKSIZE_MAX);
     size_t const inBuffSize = blockSize;  /* no block can be larger */
     size_t const outBuffSize = windowSize + blockSize + (WILDCOPY_OVERLENGTH * 2);
-    return sizeof(ZSTD_DStream) + ZSTD_estimateDCtxSize() + inBuffSize + outBuffSize;
+    return ZSTD_estimateDCtxSize() + inBuffSize + outBuffSize;
 }
 
 ZSTDLIB_API size_t ZSTD_estimateDStreamSize_fromFrame(const void* src, size_t srcSize)
 {
-    ZSTD_frameHeader fh;
-    size_t const err = ZSTD_getFrameHeader(&fh, src, srcSize);
+    U32 const windowSizeMax = 1U << ZSTD_WINDOWLOG_MAX;
+    ZSTD_frameHeader zfh;
+    size_t const err = ZSTD_getFrameHeader(&zfh, src, srcSize);
     if (ZSTD_isError(err)) return err;
     if (err>0) return ERROR(srcSize_wrong);
-    return ZSTD_estimateDStreamSize(fh.windowSize);
+    if (zfh.windowSize > windowSizeMax)
+        return ERROR(frameParameter_windowTooLarge);
+    return ZSTD_estimateDStreamSize((size_t)zfh.windowSize);
 }
 
 
@@ -2314,16 +2298,14 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
                         size_t const dictSize = zds->ddict ? zds->ddict->dictSize : 0;
                         /* legacy support is incompatible with static dctx */
                         if (zds->staticSize) return ERROR(memory_allocation);
-                        CHECK_F(ZSTD_initLegacyStream(&zds->legacyContext, zds->previousLegacyVersion, legacyVersion,
-                                                       dict, dictSize));
+                        CHECK_F(ZSTD_initLegacyStream(&zds->legacyContext,
+                                    zds->previousLegacyVersion, legacyVersion,
+                                    dict, dictSize));
                         zds->legacyVersion = zds->previousLegacyVersion = legacyVersion;
-                        return ZSTD_decompressLegacyStream(zds->legacyContext, zds->legacyVersion, output, input);
-                    } else {
-                        return hSize; /* error */
+                        return ZSTD_decompressLegacyStream(zds->legacyContext, legacyVersion, output, input);
                     }
-#else
-                    return hSize;
 #endif
+                    return hSize; /* error */
                 }
                 if (hSize != 0) {   /* need more input */
                     size_t const toLoad = hSize - zds->lhSize;   /* if hSize!=0, hSize > zds->lhSize */
@@ -2374,8 +2356,8 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
             if (zds->fParams.windowSize > zds->maxWindowSize) return ERROR(frameParameter_windowTooLarge);
 
             /* Adapt buffer sizes to frame header instructions */
-            {   size_t const blockSize = MIN(zds->fParams.windowSize, ZSTD_BLOCKSIZE_MAX);
-                size_t const neededOutSize = zds->fParams.windowSize + blockSize + WILDCOPY_OVERLENGTH * 2;
+            {   size_t const blockSize = (size_t)(MIN(zds->fParams.windowSize, ZSTD_BLOCKSIZE_MAX));
+                size_t const neededOutSize = (size_t)(zds->fParams.windowSize + blockSize + WILDCOPY_OVERLENGTH * 2);
                 zds->blockSize = blockSize;
                 if ((zds->inBuffSize < blockSize) || (zds->outBuffSize < neededOutSize)) {
                     size_t const bufferSize = blockSize + neededOutSize;
@@ -2400,7 +2382,7 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
                     zds->outBuffSize = neededOutSize;
             }   }
             zds->streamStage = zdss_read;
-            /* pass-through */
+            /* fall-through */
 
         case zdss_read:
             DEBUGLOG(5, "stage zdss_read");
@@ -2425,8 +2407,7 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
             }   }
             if (ip==iend) { someMoreWork = 0; break; }   /* no more input */
             zds->streamStage = zdss_load;
-            /* pass-through */
-
+            /* fall-through */
         case zdss_load:
             {   size_t const neededInSize = ZSTD_nextSrcSizeToDecompress(zds);
                 size_t const toLoad = neededInSize - zds->inPos;   /* should always be <= remaining space within inBuff */
@@ -2448,8 +2429,7 @@ size_t ZSTD_decompressStream(ZSTD_DStream* zds, ZSTD_outBuffer* output, ZSTD_inB
                     zds->outEnd = zds->outStart +  decodedSize;
             }   }
             zds->streamStage = zdss_flush;
-            /* pass-through */
-
+            /* fall-through */
         case zdss_flush:
             {   size_t const toFlushSize = zds->outEnd - zds->outStart;
                 size_t const flushedSize = ZSTD_limitCopy(op, oend-op, zds->outBuff + zds->outStart, toFlushSize);
diff --git a/contrib/libzstd/include/zstd/deprecated/zbuff.h b/contrib/libzstd/include/zstd/deprecated/zbuff.h
index f62091976c7..e6ea84ad3b4 100644
--- a/contrib/libzstd/include/zstd/deprecated/zbuff.h
+++ b/contrib/libzstd/include/zstd/deprecated/zbuff.h
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 /* ***************************************************************
diff --git a/contrib/libzstd/include/zstd/deprecated/zbuff_common.c b/contrib/libzstd/include/zstd/deprecated/zbuff_common.c
index 9fff6eb2095..2de45bec170 100644
--- a/contrib/libzstd/include/zstd/deprecated/zbuff_common.c
+++ b/contrib/libzstd/include/zstd/deprecated/zbuff_common.c
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 /*-*************************************
@@ -23,4 +23,3 @@ unsigned ZBUFF_isError(size_t errorCode) { return ERR_isError(errorCode); }
 /*! ZBUFF_getErrorName() :
 *   provides error code string from function result (useful for debugging) */
 const char* ZBUFF_getErrorName(size_t errorCode) { return ERR_getErrorName(errorCode); }
-
diff --git a/contrib/libzstd/include/zstd/deprecated/zbuff_compress.c b/contrib/libzstd/include/zstd/deprecated/zbuff_compress.c
index 5a37a0027ae..4444e95d8fd 100644
--- a/contrib/libzstd/include/zstd/deprecated/zbuff_compress.c
+++ b/contrib/libzstd/include/zstd/deprecated/zbuff_compress.c
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 
diff --git a/contrib/libzstd/include/zstd/deprecated/zbuff_decompress.c b/contrib/libzstd/include/zstd/deprecated/zbuff_decompress.c
index d9c155e08eb..a819d7f4042 100644
--- a/contrib/libzstd/include/zstd/deprecated/zbuff_decompress.c
+++ b/contrib/libzstd/include/zstd/deprecated/zbuff_decompress.c
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 
diff --git a/contrib/libzstd/include/zstd/dictBuilder/cover.c b/contrib/libzstd/include/zstd/dictBuilder/cover.c
index 06c1b9fadb7..3d445ae8b81 100644
--- a/contrib/libzstd/include/zstd/dictBuilder/cover.c
+++ b/contrib/libzstd/include/zstd/dictBuilder/cover.c
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 /* *****************************************************************************
@@ -714,11 +714,9 @@ typedef struct COVER_best_s {
  * Initialize the `COVER_best_t`.
  */
 static void COVER_best_init(COVER_best_t *best) {
-  if (!best) {
-    return;
-  }
-  pthread_mutex_init(&best->mutex, NULL);
-  pthread_cond_init(&best->cond, NULL);
+  if (best==NULL) return; /* compatible with init on NULL */
+  (void)pthread_mutex_init(&best->mutex, NULL);
+  (void)pthread_cond_init(&best->cond, NULL);
   best->liveJobs = 0;
   best->dict = NULL;
   best->dictSize = 0;
diff --git a/contrib/libzstd/include/zstd/dictBuilder/zdict.c b/contrib/libzstd/include/zstd/dictBuilder/zdict.c
index 742586eacdd..c2871c2ccfb 100644
--- a/contrib/libzstd/include/zstd/dictBuilder/zdict.c
+++ b/contrib/libzstd/include/zstd/dictBuilder/zdict.c
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 
@@ -695,7 +695,7 @@ static size_t ZDICT_analyzeEntropy(void*  dstBuffer, size_t maxDstSize,
         DISPLAYLEVEL(1, "Not enough memory \n");
         goto _cleanup;
     }
-    if (offcodeMax>OFFCODE_MAX) { eSize = ERROR(dictionary_wrong); goto _cleanup; }   /* too large dictionary */
+    if (offcodeMax>OFFCODE_MAX) { eSize = ERROR(dictionaryCreation_failed); goto _cleanup; }   /* too large dictionary */
     for (u=0; u<256; u++) countLit[u] = 1;   /* any character must be described */
     for (u=0; u<=offcodeMax; u++) offcodeCount[u] = 1;
     for (u=0; u<=MaxML; u++) matchLengthCount[u] = 1;
diff --git a/contrib/libzstd/include/zstd/dictBuilder/zdict.h b/contrib/libzstd/include/zstd/dictBuilder/zdict.h
index 7bfbb351a1d..3d72a465e5e 100644
--- a/contrib/libzstd/include/zstd/dictBuilder/zdict.h
+++ b/contrib/libzstd/include/zstd/dictBuilder/zdict.h
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 #ifndef DICTBUILDER_H_001
diff --git a/contrib/libzstd/include/zstd/legacy/zstd_legacy.h b/contrib/libzstd/include/zstd/legacy/zstd_legacy.h
index 3c9798f880e..1126e24669f 100644
--- a/contrib/libzstd/include/zstd/legacy/zstd_legacy.h
+++ b/contrib/libzstd/include/zstd/legacy/zstd_legacy.h
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 #ifndef ZSTD_LEGACY_H
@@ -123,6 +123,7 @@ MEM_STATIC size_t ZSTD_decompressLegacy(
                const void* dict,size_t dictSize)
 {
     U32 const version = ZSTD_isLegacy(src, compressedSize);
+    (void)dst; (void)dstCapacity; (void)dict; (void)dictSize;  /* unused when ZSTD_LEGACY_SUPPORT >= 8 */
     switch(version)
     {
 #if (ZSTD_LEGACY_SUPPORT <= 1)
@@ -223,6 +224,7 @@ MEM_STATIC size_t ZSTD_freeLegacyStreamContext(void* legacyContext, U32 version)
         case 1 :
         case 2 :
         case 3 :
+            (void)legacyContext;
             return ERROR(version_unsupported);
 #if (ZSTD_LEGACY_SUPPORT <= 4)
         case 4 : return ZBUFFv04_freeDCtx((ZBUFFv04_DCtx*)legacyContext);
@@ -250,6 +252,7 @@ MEM_STATIC size_t ZSTD_initLegacyStream(void** legacyContext, U32 prevVersion, U
         case 1 :
         case 2 :
         case 3 :
+            (void)dict; (void)dictSize;
             return 0;
 #if (ZSTD_LEGACY_SUPPORT <= 4)
         case 4 :
@@ -306,6 +309,7 @@ MEM_STATIC size_t ZSTD_decompressLegacyStream(void* legacyContext, U32 version,
         case 1 :
         case 2 :
         case 3 :
+            (void)legacyContext; (void)output; (void)input;
             return ERROR(version_unsupported);
 #if (ZSTD_LEGACY_SUPPORT <= 4)
         case 4 :
diff --git a/contrib/libzstd/include/zstd/legacy/zstd_v01.c b/contrib/libzstd/include/zstd/legacy/zstd_v01.c
index cf5354d6a9b..45f421ae6f2 100644
--- a/contrib/libzstd/include/zstd/legacy/zstd_v01.c
+++ b/contrib/libzstd/include/zstd/legacy/zstd_v01.c
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 
diff --git a/contrib/libzstd/include/zstd/legacy/zstd_v01.h b/contrib/libzstd/include/zstd/legacy/zstd_v01.h
index 13cb3acfdc3..a91c6a133ba 100644
--- a/contrib/libzstd/include/zstd/legacy/zstd_v01.h
+++ b/contrib/libzstd/include/zstd/legacy/zstd_v01.h
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 #ifndef ZSTD_V01_H_28739879432
diff --git a/contrib/libzstd/include/zstd/legacy/zstd_v02.c b/contrib/libzstd/include/zstd/legacy/zstd_v02.c
index 3cf8f477825..dc1ec0e7c67 100644
--- a/contrib/libzstd/include/zstd/legacy/zstd_v02.c
+++ b/contrib/libzstd/include/zstd/legacy/zstd_v02.c
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 
diff --git a/contrib/libzstd/include/zstd/legacy/zstd_v02.h b/contrib/libzstd/include/zstd/legacy/zstd_v02.h
index d14f0293cbe..63cb3b8d578 100644
--- a/contrib/libzstd/include/zstd/legacy/zstd_v02.h
+++ b/contrib/libzstd/include/zstd/legacy/zstd_v02.h
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 #ifndef ZSTD_V02_H_4174539423
diff --git a/contrib/libzstd/include/zstd/legacy/zstd_v03.c b/contrib/libzstd/include/zstd/legacy/zstd_v03.c
index f438330a469..8257de7e6cd 100644
--- a/contrib/libzstd/include/zstd/legacy/zstd_v03.c
+++ b/contrib/libzstd/include/zstd/legacy/zstd_v03.c
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 
diff --git a/contrib/libzstd/include/zstd/legacy/zstd_v03.h b/contrib/libzstd/include/zstd/legacy/zstd_v03.h
index 07f7597bb7c..e38e0109b13 100644
--- a/contrib/libzstd/include/zstd/legacy/zstd_v03.h
+++ b/contrib/libzstd/include/zstd/legacy/zstd_v03.h
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 #ifndef ZSTD_V03_H_298734209782
diff --git a/contrib/libzstd/include/zstd/legacy/zstd_v04.c b/contrib/libzstd/include/zstd/legacy/zstd_v04.c
index 8b8e23cb09c..951561a6cc8 100644
--- a/contrib/libzstd/include/zstd/legacy/zstd_v04.c
+++ b/contrib/libzstd/include/zstd/legacy/zstd_v04.c
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 
@@ -2776,7 +2776,7 @@ static size_t ZSTD_decodeFrameHeader_Part2(ZSTD_DCtx* zc, const void* src, size_
     size_t result;
     if (srcSize != zc->headerSize) return ERROR(srcSize_wrong);
     result = ZSTD_getFrameParams(&(zc->params), src, srcSize);
-    if ((MEM_32bits()) && (zc->params.windowLog > 25)) return ERROR(frameParameter_unsupportedBy32bits);
+    if ((MEM_32bits()) && (zc->params.windowLog > 25)) return ERROR(frameParameter_unsupported);
     return result;
 }
 
diff --git a/contrib/libzstd/include/zstd/legacy/zstd_v04.h b/contrib/libzstd/include/zstd/legacy/zstd_v04.h
index 1b5439d3924..a7d6623305f 100644
--- a/contrib/libzstd/include/zstd/legacy/zstd_v04.h
+++ b/contrib/libzstd/include/zstd/legacy/zstd_v04.h
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 #ifndef ZSTD_V04_H_91868324769238
diff --git a/contrib/libzstd/include/zstd/legacy/zstd_v05.c b/contrib/libzstd/include/zstd/legacy/zstd_v05.c
index e929618a3bf..4a1d4d4bd93 100644
--- a/contrib/libzstd/include/zstd/legacy/zstd_v05.c
+++ b/contrib/libzstd/include/zstd/legacy/zstd_v05.c
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 
@@ -2888,7 +2888,7 @@ static size_t ZSTDv05_decodeFrameHeader_Part2(ZSTDv05_DCtx* zc, const void* src,
     if (srcSize != zc->headerSize)
         return ERROR(srcSize_wrong);
     result = ZSTDv05_getFrameParams(&(zc->params), src, srcSize);
-    if ((MEM_32bits()) && (zc->params.windowLog > 25)) return ERROR(frameParameter_unsupportedBy32bits);
+    if ((MEM_32bits()) && (zc->params.windowLog > 25)) return ERROR(frameParameter_unsupported);
     return result;
 }
 
diff --git a/contrib/libzstd/include/zstd/legacy/zstd_v05.h b/contrib/libzstd/include/zstd/legacy/zstd_v05.h
index 8ce662fd9fc..a333bd127bd 100644
--- a/contrib/libzstd/include/zstd/legacy/zstd_v05.h
+++ b/contrib/libzstd/include/zstd/legacy/zstd_v05.h
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 #ifndef ZSTDv05_H
diff --git a/contrib/libzstd/include/zstd/legacy/zstd_v06.c b/contrib/libzstd/include/zstd/legacy/zstd_v06.c
index 26f0929da6f..a285a09016f 100644
--- a/contrib/libzstd/include/zstd/legacy/zstd_v06.c
+++ b/contrib/libzstd/include/zstd/legacy/zstd_v06.c
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 
@@ -3084,7 +3084,7 @@ size_t ZSTDv06_getFrameParams(ZSTDv06_frameParams* fparamsPtr, const void* src,
 static size_t ZSTDv06_decodeFrameHeader(ZSTDv06_DCtx* zc, const void* src, size_t srcSize)
 {
     size_t const result = ZSTDv06_getFrameParams(&(zc->fParams), src, srcSize);
-    if ((MEM_32bits()) && (zc->fParams.windowLog > 25)) return ERROR(frameParameter_unsupportedBy32bits);
+    if ((MEM_32bits()) && (zc->fParams.windowLog > 25)) return ERROR(frameParameter_unsupported);
     return result;
 }
 
diff --git a/contrib/libzstd/include/zstd/legacy/zstd_v06.h b/contrib/libzstd/include/zstd/legacy/zstd_v06.h
index 10c9c772597..ee043a17909 100644
--- a/contrib/libzstd/include/zstd/legacy/zstd_v06.h
+++ b/contrib/libzstd/include/zstd/legacy/zstd_v06.h
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 #ifndef ZSTDv06_H
diff --git a/contrib/libzstd/include/zstd/legacy/zstd_v07.c b/contrib/libzstd/include/zstd/legacy/zstd_v07.c
index 6669b71cea4..ad392e90b61 100644
--- a/contrib/libzstd/include/zstd/legacy/zstd_v07.c
+++ b/contrib/libzstd/include/zstd/legacy/zstd_v07.c
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 
diff --git a/contrib/libzstd/include/zstd/legacy/zstd_v07.h b/contrib/libzstd/include/zstd/legacy/zstd_v07.h
index cc95c661bc9..68d18e9636b 100644
--- a/contrib/libzstd/include/zstd/legacy/zstd_v07.h
+++ b/contrib/libzstd/include/zstd/legacy/zstd_v07.h
@@ -1,10 +1,10 @@
-/**
+/*
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
 
 #ifndef ZSTDv07_H_235446
diff --git a/contrib/libzstd/include/zstd/zstd.h b/contrib/libzstd/include/zstd/zstd.h
index 58e9a5606db..13b4563fd69 100644
--- a/contrib/libzstd/include/zstd/zstd.h
+++ b/contrib/libzstd/include/zstd/zstd.h
@@ -2,11 +2,10 @@
  * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
  * All rights reserved.
  *
- * This source code is licensed under the BSD-style license found in the
- * LICENSE file in the root directory of this source tree. An additional grant
- * of patent rights can be found in the PATENTS file in the same directory.
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
  */
-
 #if defined (__cplusplus)
 extern "C" {
 #endif
@@ -59,7 +58,7 @@ extern "C" {
 /*------   Version   ------*/
 #define ZSTD_VERSION_MAJOR    1
 #define ZSTD_VERSION_MINOR    3
-#define ZSTD_VERSION_RELEASE  0
+#define ZSTD_VERSION_RELEASE  1
 
 #define ZSTD_VERSION_NUMBER  (ZSTD_VERSION_MAJOR *100*100 + ZSTD_VERSION_MINOR *100 + ZSTD_VERSION_RELEASE)
 ZSTDLIB_API unsigned ZSTD_versionNumber(void);   /**< useful to check dll version */
@@ -425,13 +424,6 @@ typedef struct {
     ZSTD_frameParameters fParams;
 } ZSTD_parameters;
 
-typedef struct {
-    unsigned long long frameContentSize;
-    size_t windowSize;
-    unsigned dictID;
-    unsigned checksumFlag;
-} ZSTD_frameHeader;
-
 /*= Custom memory allocation functions */
 typedef void* (*ZSTD_allocFunction) (void* opaque, size_t size);
 typedef void  (*ZSTD_freeFunction) (void* opaque, void* address);
@@ -809,7 +801,6 @@ ZSTDLIB_API size_t ZSTD_compressContinue(ZSTD_CCtx* cctx, void* dst, size_t dstC
 ZSTDLIB_API size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t dstCapacity, const void* src, size_t srcSize);
 
 
-
 /*-
   Buffer-less streaming decompression (synchronous mode)
 
@@ -874,6 +865,15 @@ ZSTDLIB_API size_t ZSTD_compressEnd(ZSTD_CCtx* cctx, void* dst, size_t dstCapaci
 */
 
 /*=====   Buffer-less streaming decompression functions  =====*/
+typedef enum { ZSTD_frame, ZSTD_skippableFrame } ZSTD_frameType_e;
+typedef struct {
+    unsigned long long frameContentSize; /* ZSTD_CONTENTSIZE_UNKNOWN means this field is not available. 0 means "empty" */
+    unsigned long long windowSize;       /* can be very large, up to <= frameContentSize */
+    ZSTD_frameType_e frameType;          /* if == ZSTD_skippableFrame, frameContentSize is the size of skippable content */
+    unsigned headerSize;
+    unsigned dictID;
+    unsigned checksumFlag;
+} ZSTD_frameHeader;
 ZSTDLIB_API size_t ZSTD_getFrameHeader(ZSTD_frameHeader* zfhPtr, const void* src, size_t srcSize);   /**< doesn't consume input */
 ZSTDLIB_API size_t ZSTD_decompressBegin(ZSTD_DCtx* dctx);
 ZSTDLIB_API size_t ZSTD_decompressBegin_usingDict(ZSTD_DCtx* dctx, const void* dict, size_t dictSize);
@@ -953,7 +953,9 @@ typedef enum {
                               * Special: value 0 means "do not change strategy". */
 
     /* frame parameters */
-    ZSTD_p_contentSizeFlag=200, /* Content size is written into frame header _whenever known_ (default:1) */
+    ZSTD_p_contentSizeFlag=200, /* Content size is written into frame header _whenever known_ (default:1)
+                              * note that content size must be known at the beginning,
+                              * it is sent using ZSTD_CCtx_setPledgedSrcSize() */
     ZSTD_p_checksumFlag,     /* A 32-bits checksum of content is written at end of frame (default:0) */
     ZSTD_p_dictIDFlag,       /* When applicable, dictID of dictionary is provided in frame header (default:1) */
 

From 88e2dd9d74a74b291f2e221159803e1321ca9ac5 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Thu, 7 Sep 2017 06:47:18 +0300
Subject: [PATCH 114/266] Added missing file [#CLICKHOUSE-3282].

---
 .../libzstd/include/zstd/common/compiler.h    | 85 +++++++++++++++++++
 1 file changed, 85 insertions(+)
 create mode 100644 contrib/libzstd/include/zstd/common/compiler.h

diff --git a/contrib/libzstd/include/zstd/common/compiler.h b/contrib/libzstd/include/zstd/common/compiler.h
new file mode 100644
index 00000000000..d7225c443e9
--- /dev/null
+++ b/contrib/libzstd/include/zstd/common/compiler.h
@@ -0,0 +1,85 @@
+/*
+ * Copyright (c) 2016-present, Yann Collet, Facebook, Inc.
+ * All rights reserved.
+ *
+ * This source code is licensed under both the BSD-style license (found in the
+ * LICENSE file in the root directory of this source tree) and the GPLv2 (found
+ * in the COPYING file in the root directory of this source tree).
+ */
+
+#ifndef ZSTD_COMPILER_H
+#define ZSTD_COMPILER_H
+
+/*-*******************************************************
+*  Compiler specifics
+*********************************************************/
+/* force inlining */
+#if defined (__GNUC__) || defined(__cplusplus) || defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L   /* C99 */
+#  define INLINE_KEYWORD inline
+#else
+#  define INLINE_KEYWORD
+#endif
+
+#if defined(__GNUC__)
+#  define FORCE_INLINE_ATTR __attribute__((always_inline))
+#elif defined(_MSC_VER)
+#  define FORCE_INLINE_ATTR __forceinline
+#else
+#  define FORCE_INLINE_ATTR
+#endif
+
+/**
+ * FORCE_INLINE_TEMPLATE is used to define C "templates", which take constant
+ * parameters. They must be inlined for the compiler to elimininate the constant
+ * branches.
+ */
+#define FORCE_INLINE_TEMPLATE static INLINE_KEYWORD FORCE_INLINE_ATTR
+/**
+ * HINT_INLINE is used to help the compiler generate better code. It is *not*
+ * used for "templates", so it can be tweaked based on the compilers
+ * performance.
+ *
+ * gcc-4.8 and gcc-4.9 have been shown to benefit from leaving off the
+ * always_inline attribute.
+ *
+ * clang up to 5.0.0 (trunk) benefit tremendously from the always_inline
+ * attribute.
+ */
+#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 8 && __GNUC__ < 5
+#  define HINT_INLINE static INLINE_KEYWORD
+#else
+#  define HINT_INLINE static INLINE_KEYWORD FORCE_INLINE_ATTR
+#endif
+
+/* force no inlining */
+#ifdef _MSC_VER
+#  define FORCE_NOINLINE static __declspec(noinline)
+#else
+#  ifdef __GNUC__
+#    define FORCE_NOINLINE static __attribute__((__noinline__))
+#  else
+#    define FORCE_NOINLINE static
+#  endif
+#endif
+
+/* prefetch */
+#if defined(_MSC_VER) && (defined(_M_X64) || defined(_M_I86))  /* _mm_prefetch() is not defined outside of x86/x64 */
+#  include <mmintrin.h>   /* https://msdn.microsoft.com/fr-fr/library/84szxsww(v=vs.90).aspx */
+#  define PREFETCH(ptr)   _mm_prefetch((const char*)ptr, _MM_HINT_T0)
+#elif defined(__GNUC__)
+#  define PREFETCH(ptr)   __builtin_prefetch(ptr, 0, 0)
+#else
+#  define PREFETCH(ptr)   /* disabled */
+#endif
+
+/* disable warnings */
+#ifdef _MSC_VER    /* Visual Studio */
+#  include <intrin.h>                    /* For Visual 2005 */
+#  pragma warning(disable : 4100)        /* disable: C4100: unreferenced formal parameter */
+#  pragma warning(disable : 4127)        /* disable: C4127: conditional expression is constant */
+#  pragma warning(disable : 4204)        /* disable: C4204: non-constant aggregate initializer */
+#  pragma warning(disable : 4214)        /* disable: C4214: non-int bitfields */
+#  pragma warning(disable : 4324)        /* disable: C4324: padded structure */
+#endif
+
+#endif /* ZSTD_COMPILER_H */

From 657e333dba99106dae8790dfa42abd9e81b01c0a Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Thu, 7 Sep 2017 07:02:29 +0300
Subject: [PATCH 115/266] Added "Uptime" asynchronous metric
 [#CLICKHOUSE-3282].

---
 dbms/src/Interpreters/AsynchronousMetrics.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/dbms/src/Interpreters/AsynchronousMetrics.cpp b/dbms/src/Interpreters/AsynchronousMetrics.cpp
index 12a9c6dc8ca..823e6eab2e3 100644
--- a/dbms/src/Interpreters/AsynchronousMetrics.cpp
+++ b/dbms/src/Interpreters/AsynchronousMetrics.cpp
@@ -126,6 +126,8 @@ void AsynchronousMetrics::update()
         }
     }
 
+    set("Uptime", context.getUptimeSeconds());
+
     {
         auto databases = context.getDatabases();
 

From 4017622ffb4cfd3a7a870a6c19a6d388459d3e96 Mon Sep 17 00:00:00 2001
From: Vadim Skipin <vskipin@yandex-team.ru>
Date: Thu, 7 Sep 2017 17:38:35 +0300
Subject: [PATCH 116/266] CLICKHOUSE-3289: Do not use Application singleton

---
 dbms/src/Common/isLocalAddress.cpp            |  3 +--
 dbms/src/Common/isLocalAddress.h              |  2 +-
 .../ClickHouseDictionarySource.cpp            |  2 +-
 dbms/src/Functions/FunctionsMiscellaneous.cpp |  2 +-
 dbms/src/Interpreters/Cluster.cpp             | 24 +++++++++----------
 dbms/src/Interpreters/Cluster.h               |  4 ++--
 dbms/src/Interpreters/DDLWorker.cpp           |  8 +++----
 .../TableFunctions/TableFunctionRemote.cpp    |  2 +-
 8 files changed, 23 insertions(+), 24 deletions(-)

diff --git a/dbms/src/Common/isLocalAddress.cpp b/dbms/src/Common/isLocalAddress.cpp
index a1b24f2e0ce..d78ac869d5f 100644
--- a/dbms/src/Common/isLocalAddress.cpp
+++ b/dbms/src/Common/isLocalAddress.cpp
@@ -9,9 +9,8 @@
 namespace DB
 {
 
-bool isLocalAddress(const Poco::Net::SocketAddress & address)
+bool isLocalAddress(const Poco::Net::SocketAddress & address, UInt16 clickhouse_port)
 {
-    const UInt16 clickhouse_port = Poco::Util::Application::instance().config().getInt("tcp_port", 0);
     static auto interfaces = Poco::Net::NetworkInterface::list();
 
     if (clickhouse_port == address.port())
diff --git a/dbms/src/Common/isLocalAddress.h b/dbms/src/Common/isLocalAddress.h
index d63b42dbb97..6e15490eeed 100644
--- a/dbms/src/Common/isLocalAddress.h
+++ b/dbms/src/Common/isLocalAddress.h
@@ -20,6 +20,6 @@ namespace DB
      * - only the first address is taken for each network interface;
      * - the routing rules that affect which network interface we go to the specified address are not checked.
      */
-    bool isLocalAddress(const Poco::Net::SocketAddress & address);
+    bool isLocalAddress(const Poco::Net::SocketAddress & address, UInt16 clickhouse_port);
 
 }
diff --git a/dbms/src/Dictionaries/ClickHouseDictionarySource.cpp b/dbms/src/Dictionaries/ClickHouseDictionarySource.cpp
index 894d3207094..535d09586c6 100644
--- a/dbms/src/Dictionaries/ClickHouseDictionarySource.cpp
+++ b/dbms/src/Dictionaries/ClickHouseDictionarySource.cpp
@@ -45,7 +45,7 @@ ClickHouseDictionarySource::ClickHouseDictionarySource(
         where{config.getString(config_prefix + ".where", "")},
         query_builder{dict_struct, db, table, where, ExternalQueryBuilder::Backticks},
         sample_block{sample_block}, context(context),
-        is_local{isLocalAddress({ host, port })},
+        is_local{isLocalAddress({ host, port }, config.getInt("tcp_port", 0))},
         pool{is_local ? nullptr : createPool(host, port, db, user, password)},
         load_all_query{query_builder.composeLoadAllQuery()}
 {}
diff --git a/dbms/src/Functions/FunctionsMiscellaneous.cpp b/dbms/src/Functions/FunctionsMiscellaneous.cpp
index 7ff48b85bb9..c18bbe9dc93 100644
--- a/dbms/src/Functions/FunctionsMiscellaneous.cpp
+++ b/dbms/src/Functions/FunctionsMiscellaneous.cpp
@@ -1709,7 +1709,7 @@ void FunctionHasColumnInTable::executeImpl(Block & block, const ColumnNumbers &
     else
     {
         std::vector<std::vector<String>> host_names = {{ host_name }};
-        auto cluster = std::make_shared<Cluster>(global_context.getSettings(), host_names, !user_name.empty() ? user_name : "default", password);
+        auto cluster = std::make_shared<Cluster>(global_context.getSettings(), host_names, !user_name.empty() ? user_name : "default", password, global_context.getTCPPort());
         auto names_and_types_list = std::make_shared<NamesAndTypesList>(getStructureOfRemoteTable(*cluster, database_name, table_name, global_context));
         const auto & names = names_and_types_list->getNames();
         has_column = std::find(names.begin(), names.end(), column_name) != names.end();
diff --git a/dbms/src/Interpreters/Cluster.cpp b/dbms/src/Interpreters/Cluster.cpp
index d1196cf7d4e..304a0dd32d6 100644
--- a/dbms/src/Interpreters/Cluster.cpp
+++ b/dbms/src/Interpreters/Cluster.cpp
@@ -29,7 +29,7 @@ namespace
 /// Default shard weight.
 static constexpr UInt32 default_weight = 1;
 
-inline bool isLocal(const Cluster::Address & address)
+inline bool isLocal(const Cluster::Address & address, UInt16 clickhouse_port)
 {
     ///    If there is replica, for which:
     /// - its port is the same that the server is listening;
@@ -41,7 +41,7 @@ inline bool isLocal(const Cluster::Address & address)
     /// Also, replica is considered non-local, if it has default database set
     ///  (only reason is to avoid query rewrite).
 
-    return address.default_database.empty() && isLocalAddress(address.resolved_address);
+    return address.default_database.empty() && isLocalAddress(address.resolved_address, clickhouse_port);
 }
 
 
@@ -61,23 +61,23 @@ Poco::Net::SocketAddress resolveSocketAddress(const String & host_and_port)
 
 Cluster::Address::Address(Poco::Util::AbstractConfiguration & config, const String & config_prefix)
 {
+    UInt16 clickhouse_port = config.getInt("tcp_port", 0);
+
     host_name = config.getString(config_prefix + ".host");
     port = static_cast<UInt16>(config.getInt(config_prefix + ".port"));
     resolved_address = resolveSocketAddress(host_name, port);
     user = config.getString(config_prefix + ".user", "default");
     password = config.getString(config_prefix + ".password", "");
     default_database = config.getString(config_prefix + ".default_database", "");
-    is_local = isLocal(*this);
+    is_local = isLocal(*this, clickhouse_port);
 }
 
 
-Cluster::Address::Address(const String & host_port_, const String & user_, const String & password_)
+Cluster::Address::Address(const String & host_port_, const String & user_, const String & password_, UInt16 clickhouse_port)
     : user(user_), password(password_)
 {
-    UInt16 default_port = static_cast<UInt16>(Poco::Util::Application::instance().config().getInt("tcp_port", 0));
-
     /// It's like that 'host_port_' string contains port. If condition is met, it doesn't necessarily mean that port exists (example: [::]).
-    if ((nullptr != strchr(host_port_.c_str(), ':')) || !default_port)
+    if ((nullptr != strchr(host_port_.c_str(), ':')) || !clickhouse_port)
     {
         resolved_address = resolveSocketAddress(host_port_);
         host_name = host_port_.substr(0, host_port_.find(':'));
@@ -85,11 +85,11 @@ Cluster::Address::Address(const String & host_port_, const String & user_, const
     }
     else
     {
-        resolved_address = resolveSocketAddress(host_port_, default_port);
+        resolved_address = resolveSocketAddress(host_port_, clickhouse_port);
         host_name = host_port_;
-        port = default_port;
+        port = clickhouse_port;
     }
-    is_local = isLocal(*this);
+    is_local = isLocal(*this, clickhouse_port);
 }
 
 
@@ -333,7 +333,7 @@ Cluster::Cluster(Poco::Util::AbstractConfiguration & config, const Settings & se
 
 
 Cluster::Cluster(const Settings & settings, const std::vector<std::vector<String>> & names,
-                 const String & username, const String & password)
+                 const String & username, const String & password, UInt16 clickhouse_port)
 {
     UInt32 current_shard_num = 1;
 
@@ -341,7 +341,7 @@ Cluster::Cluster(const Settings & settings, const std::vector<std::vector<String
     {
         Addresses current;
         for (auto & replica : shard)
-            current.emplace_back(replica, username, password);
+            current.emplace_back(replica, username, password, clickhouse_port);
 
         addresses_with_failover.emplace_back(current);
 
diff --git a/dbms/src/Interpreters/Cluster.h b/dbms/src/Interpreters/Cluster.h
index 0dc476bc04f..6d75286636d 100644
--- a/dbms/src/Interpreters/Cluster.h
+++ b/dbms/src/Interpreters/Cluster.h
@@ -20,7 +20,7 @@ public:
 
     /// Construct a cluster by the names of shards and replicas. Local are treated as well as remote ones.
     Cluster(const Settings & settings, const std::vector<std::vector<String>> & names,
-            const String & username, const String & password);
+            const String & username, const String & password, UInt16 clickhouse_port);
 
     Cluster(const Cluster &) = delete;
     Cluster & operator=(const Cluster &) = delete;
@@ -59,7 +59,7 @@ public:
 
         Address() = default;
         Address(Poco::Util::AbstractConfiguration & config, const String & config_prefix);
-        Address(const String & host_port_, const String & user_, const String & password_);
+        Address(const String & host_port_, const String & user_, const String & password_, UInt16 clickhouse_port);
 
         /// Returns 'escaped_host_name:port'
         String toString() const;
diff --git a/dbms/src/Interpreters/DDLWorker.cpp b/dbms/src/Interpreters/DDLWorker.cpp
index 481e7045bbe..73dd4a9e686 100644
--- a/dbms/src/Interpreters/DDLWorker.cpp
+++ b/dbms/src/Interpreters/DDLWorker.cpp
@@ -82,11 +82,11 @@ struct HostID
         return host_name + ":" + DB::toString(port);
     }
 
-    bool isLocalAddress() const
+    bool isLocalAddress(UInt16 clickhouse_port) const
     {
         try
         {
-            return DB::isLocalAddress(Poco::Net::SocketAddress(DNSCache::instance().resolveHost(host_name), port));
+            return DB::isLocalAddress(Poco::Net::SocketAddress(host_name, port), clickhouse_port);
         }
         catch (const Poco::Exception & e)
         {
@@ -287,7 +287,7 @@ bool DDLWorker::initAndCheckTask(const String & entry_name, String & out_reason)
     bool host_in_hostlist = false;
     for (const HostID & host : task->entry.hosts)
     {
-        if (!host.isLocalAddress())
+        if (!host.isLocalAddress(context.getTCPPort()))
             continue;
 
         if (host_in_hostlist)
@@ -464,7 +464,7 @@ void DDLWorker::parseQueryAndResolveHost(DDLTask & task)
         {
             const Cluster::Address & address = shards[shard_num][replica_num];
 
-            if (isLocalAddress(address.resolved_address))
+            if (isLocalAddress(address.resolved_address, context.getTCPPort()))
             {
                 if (found_via_resolving)
                 {
diff --git a/dbms/src/TableFunctions/TableFunctionRemote.cpp b/dbms/src/TableFunctions/TableFunctionRemote.cpp
index d1240c93832..8ea29059488 100644
--- a/dbms/src/TableFunctions/TableFunctionRemote.cpp
+++ b/dbms/src/TableFunctions/TableFunctionRemote.cpp
@@ -274,7 +274,7 @@ StoragePtr TableFunctionRemote::execute(const ASTPtr & ast_function, const Conte
     if (names.empty())
         throw Exception("Shard list is empty after parsing first argument", ErrorCodes::BAD_ARGUMENTS);
 
-    auto cluster = std::make_shared<Cluster>(context.getSettings(), names, username, password);
+    auto cluster = std::make_shared<Cluster>(context.getSettings(), names, username, password, context.getTCPPort());
 
     auto res = StorageDistributed::createWithOwnCluster(
         getName(),

From 39a4401f054e6e3d06745947b8bea3bda7273511 Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Thu, 7 Sep 2017 20:55:02 +0300
Subject: [PATCH 117/266] Update Cluster.h

---
 dbms/src/Interpreters/Cluster.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/dbms/src/Interpreters/Cluster.h b/dbms/src/Interpreters/Cluster.h
index 6d75286636d..230d357d7e2 100644
--- a/dbms/src/Interpreters/Cluster.h
+++ b/dbms/src/Interpreters/Cluster.h
@@ -19,6 +19,8 @@ public:
     Cluster(Poco::Util::AbstractConfiguration & config, const Settings & settings, const String & cluster_name);
 
     /// Construct a cluster by the names of shards and replicas. Local are treated as well as remote ones.
+    /// 'clickhouse_port' - port that this server instance listen for queries.
+    /// This parameter is needed only to check that some address is local (points to ourself).
     Cluster(const Settings & settings, const std::vector<std::vector<String>> & names,
             const String & username, const String & password, UInt16 clickhouse_port);
 

From 45eda97e3914be2b0e96e2e7f375cd6d133fd135 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Thu, 7 Sep 2017 20:55:55 +0300
Subject: [PATCH 118/266] Fixed bug in usage of ZSTD [#CLICKHOUSE-3282].

---
 dbms/src/IO/CompressedReadBufferBase.cpp | 4 ++--
 dbms/src/IO/CompressedWriteBuffer.cpp    | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/dbms/src/IO/CompressedReadBufferBase.cpp b/dbms/src/IO/CompressedReadBufferBase.cpp
index 1c51a3e1900..26038c1a198 100644
--- a/dbms/src/IO/CompressedReadBufferBase.cpp
+++ b/dbms/src/IO/CompressedReadBufferBase.cpp
@@ -54,8 +54,8 @@ size_t CompressedReadBufferBase::readCompressedData(size_t & size_decompressed,
     size_t & size_compressed = size_compressed_without_checksum;
 
     if (method == static_cast<UInt8>(CompressionMethodByte::LZ4) ||
-            method == static_cast<UInt8>(CompressionMethodByte::ZSTD) ||
-            method == static_cast<UInt8>(CompressionMethodByte::NONE))
+        method == static_cast<UInt8>(CompressionMethodByte::ZSTD) ||
+        method == static_cast<UInt8>(CompressionMethodByte::NONE))
     {
         size_compressed = unalignedLoad<UInt32>(&own_compressed_buffer[1]);
         size_decompressed = unalignedLoad<UInt32>(&own_compressed_buffer[5]);
diff --git a/dbms/src/IO/CompressedWriteBuffer.cpp b/dbms/src/IO/CompressedWriteBuffer.cpp
index 4575278b12c..25bf1b4c967 100644
--- a/dbms/src/IO/CompressedWriteBuffer.cpp
+++ b/dbms/src/IO/CompressedWriteBuffer.cpp
@@ -80,7 +80,7 @@ void CompressedWriteBuffer::nextImpl()
 
             size_t res = ZSTD_compress(
                 &compressed_buffer[header_size],
-                compressed_buffer.size(),
+                compressed_buffer.size() - header_size,
                 working_buffer.begin(),
                 uncompressed_size,
                 1);

From 0dcee75180920c502d4b69323caeba97f2fd2a73 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Thu, 7 Sep 2017 22:13:37 +0300
Subject: [PATCH 119/266] Supporessed useless false positive errors found by
 cppcheck [#CLICKHOUSE-3300].

---
 CMakeLists.txt                                   | 3 +++
 dbms/src/Functions/FunctionsArray.cpp            | 2 +-
 dbms/src/Storages/StorageReplicatedMergeTree.cpp | 5 ++---
 3 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index fe0838b2ff5..2ec52c7f427 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -27,6 +27,9 @@ endif ()
 cmake_policy (SET CMP0014 OLD) # Ignore warning about CMakeLists.txt in each directory
 cmake_policy (SET CMP0012 NEW) # Don't dereference TRUE and FALSE
 
+# Write compile_commands.json
+set(CMAKE_EXPORT_COMPILE_COMMANDS 1)
+
 find_program (CCACHE_FOUND ccache)
 if (CCACHE_FOUND AND NOT CMAKE_CXX_COMPILER_LAUNCHER MATCHES "ccache" AND NOT CMAKE_CXX_COMPILER MATCHES "ccache")
   set_property (GLOBAL PROPERTY RULE_LAUNCH_COMPILE "ccache")
diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index 9e756922400..e66788aa6b6 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -1071,7 +1071,7 @@ DataTypePtr FunctionArrayElement::getReturnTypeImpl(const DataTypes & arguments)
 void FunctionArrayElement::executeImpl(Block & block, const ColumnNumbers & arguments, size_t result)
 {
     /// Check nullability.
-    bool is_nullable;
+    bool is_nullable = false;
 
     const ColumnArray * col_array = nullptr;
     const ColumnConst * col_const_array = nullptr;
diff --git a/dbms/src/Storages/StorageReplicatedMergeTree.cpp b/dbms/src/Storages/StorageReplicatedMergeTree.cpp
index f8e835d071d..a35052db311 100644
--- a/dbms/src/Storages/StorageReplicatedMergeTree.cpp
+++ b/dbms/src/Storages/StorageReplicatedMergeTree.cpp
@@ -2402,7 +2402,7 @@ void StorageReplicatedMergeTree::alter(const AlterCommands & params,
 
     LOG_DEBUG(log, "Doing ALTER");
 
-    int new_columns_version;
+    int new_columns_version = -1;   /// Initialization is to suppress (useless) false positive warning found by cppcheck.
     String new_columns_str;
     zkutil::Stat stat;
 
@@ -2427,8 +2427,7 @@ void StorageReplicatedMergeTree::alter(const AlterCommands & params,
 
         new_columns_str = ColumnsDescription<false>{
             new_columns, new_materialized_columns,
-            new_alias_columns, new_column_defaults
-        }.toString();
+            new_alias_columns, new_column_defaults}.toString();
 
         /// Do ALTER.
         getZooKeeper()->set(zookeeper_path + "/columns", new_columns_str, -1, &stat);

From 8b313ab99ec6330d26d64596666725f717a29e51 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 00:04:48 +0300
Subject: [PATCH 120/266] Fixed warnings found by cppcheck [#CLICKHOUSE-3300].

---
 dbms/src/Columns/ColumnFixedString.cpp        |   2 +-
 dbms/src/Columns/ColumnString.cpp             |   2 +-
 dbms/src/Columns/ColumnsCommon.cpp            |   4 +-
 dbms/src/Common/Exception.cpp                 |   2 +-
 dbms/src/Common/Exception.h                   |  15 +--
 dbms/src/Common/NetException.h                |   8 +-
 dbms/src/Common/SharedLibrary.h               |   9 +-
 dbms/src/Common/ZooKeeper/SingleBarrier.cpp   |   3 +-
 dbms/src/Common/ZooKeeper/ZooKeeper.cpp       |  11 +-
 .../tests/zkutil_expiration_test.cpp          |   3 +-
 dbms/src/Common/tests/compact_array.cpp       |   2 +-
 dbms/src/Common/tests/int_hashes_perf.cpp     |  20 ++--
 dbms/src/Common/tests/lru_cache.cpp           |   2 +-
 dbms/src/Core/tests/rvo_test.cpp              |   4 +-
 ...ggregatedMemoryEfficientBlockInputStream.h |   2 +-
 .../SummingSortedBlockInputStream.cpp         |  16 +--
 dbms/src/DataTypes/DataTypeArray.cpp          |   2 +-
 dbms/src/DataTypes/DataTypeNumberBase.cpp     |   6 +-
 dbms/src/DataTypes/tests/data_type_string.cpp |  10 +-
 dbms/src/Databases/DatabaseCloud.cpp          |   4 +-
 .../Dictionaries/LibraryDictionarySource.cpp  |  21 +++-
 .../Dictionaries/LibraryDictionarySource.h    |   2 +
 .../Conditional/StringArrayEvaluator.cpp      |   6 +-
 dbms/src/Functions/FunctionsArray.cpp         |   2 +-
 dbms/src/Functions/FunctionsCharset.cpp       |   2 +-
 dbms/src/Functions/FunctionsMiscellaneous.cpp |   4 +-
 .../Functions/tests/functions_arithmetic.cpp  |   3 +-
 .../tests/logical_functions_performance.cpp   |   4 +-
 dbms/src/IO/BufferWithOwnMemory.h             |   2 +-
 dbms/src/IO/MemoryReadWriteBuffer.cpp         |  20 ++--
 dbms/src/IO/ReadHelpers.cpp                   |   1 +
 dbms/src/IO/WriteHelpers.cpp                  |  24 +---
 dbms/src/IO/tests/compressed_buffer.cpp       |   1 -
 dbms/src/IO/tests/read_buffer_aio.cpp         |   4 +-
 dbms/src/IO/tests/write_buffer_aio.cpp        |   4 +-
 dbms/src/Interpreters/Aggregator.cpp          |   2 +-
 dbms/src/Interpreters/Context.cpp             |   2 +-
 dbms/src/Interpreters/DDLWorker.cpp           |   2 +-
 .../src/Interpreters/ExternalDictionaries.cpp |   9 +-
 dbms/src/Interpreters/ProcessList.cpp         |   2 +-
 dbms/src/Interpreters/Users.cpp               |   4 +-
 dbms/src/Interpreters/sortBlock.cpp           |   4 +-
 .../Interpreters/tests/hash_map_string.cpp    |   2 +-
 .../tests/hash_map_string_small.cpp           |   2 +-
 dbms/src/Parsers/ASTSelectQuery.cpp           |   2 +-
 dbms/src/Parsers/ParserCase.cpp               |   4 +-
 dbms/src/Server/InterserverIOHTTPHandler.h    |   2 +-
 dbms/src/Server/PerformanceTest.cpp           |   9 +-
 dbms/src/Server/ReplicasStatusHandler.h       |   2 +-
 dbms/src/Server/RootRequestHandler.h          |   2 +-
 dbms/src/Server/StatusFile.h                  |   2 +-
 dbms/src/Server/TCPHandlerFactory.h           |   2 +-
 .../MergeTree/MergeTreeBaseBlockInputStream.h |   1 -
 .../MergeTree/MergeTreeBlockInputStream.cpp   |   2 -
 .../MergeTree/MergeTreeBlockInputStream.h     |   2 +
 .../MergeTreeThreadBlockInputStream.cpp       |   2 -
 dbms/src/Storages/MergeTree/PKCondition.cpp   |   2 +-
 .../Storages/MergeTree/ReshardingWorker.cpp   |   4 +-
 .../MergeTree/SimpleMergeSelector.cpp         |   2 +-
 dbms/src/Storages/StorageBuffer.cpp           | 106 +++++++++---------
 dbms/src/Storages/StorageCloud.cpp            |   2 +
 dbms/src/Storages/StorageFile.cpp             |   2 +-
 dbms/src/Storages/StorageLog.cpp              |   2 +-
 dbms/src/Storages/StorageMemory.cpp           |   2 +-
 .../Storages/StorageReplicatedMergeTree.cpp   |   2 +-
 dbms/src/Storages/StorageStripeLog.cpp        |   2 +-
 dbms/src/Storages/StorageTinyLog.cpp          |   2 +-
 dbms/src/Storages/StorageTrivialBuffer.cpp    |   2 +-
 .../dictionary_library/dictionary_library.cpp |   5 +-
 libs/libdaemon/src/BaseDaemon.cpp             |   8 +-
 libs/libmysqlxx/src/Pool.cpp                  |  16 +--
 utils/iotest/iotest.cpp                       |  24 +---
 utils/iotest/iotest_aio.cpp                   |  44 +-------
 utils/test-data-generator/MarkovModel.h       |   2 +-
 74 files changed, 219 insertions(+), 298 deletions(-)

diff --git a/dbms/src/Columns/ColumnFixedString.cpp b/dbms/src/Columns/ColumnFixedString.cpp
index 7e76195980e..946763f3f7a 100644
--- a/dbms/src/Columns/ColumnFixedString.cpp
+++ b/dbms/src/Columns/ColumnFixedString.cpp
@@ -102,7 +102,7 @@ template <bool positive>
 struct ColumnFixedString::less
 {
     const ColumnFixedString & parent;
-    less(const ColumnFixedString & parent_) : parent(parent_) {}
+    explicit less(const ColumnFixedString & parent_) : parent(parent_) {}
     bool operator()(size_t lhs, size_t rhs) const
     {
         /// TODO: memcmp slows down.
diff --git a/dbms/src/Columns/ColumnString.cpp b/dbms/src/Columns/ColumnString.cpp
index cfe0097f189..17fb9b53667 100644
--- a/dbms/src/Columns/ColumnString.cpp
+++ b/dbms/src/Columns/ColumnString.cpp
@@ -163,7 +163,7 @@ template <bool positive>
 struct ColumnString::less
 {
     const ColumnString & parent;
-    less(const ColumnString & parent_) : parent(parent_) {}
+    explicit less(const ColumnString & parent_) : parent(parent_) {}
     bool operator()(size_t lhs, size_t rhs) const
     {
         size_t left_len = parent.sizeAt(lhs);
diff --git a/dbms/src/Columns/ColumnsCommon.cpp b/dbms/src/Columns/ColumnsCommon.cpp
index 441a4eb1acd..4812e5ac24e 100644
--- a/dbms/src/Columns/ColumnsCommon.cpp
+++ b/dbms/src/Columns/ColumnsCommon.cpp
@@ -103,7 +103,7 @@ namespace
         IColumn::Offsets_t & res_offsets;
         IColumn::Offset_t current_src_offset = 0;
 
-        ResultOffsetsBuilder(IColumn::Offsets_t * res_offsets_) : res_offsets(*res_offsets_) {}
+        explicit ResultOffsetsBuilder(IColumn::Offsets_t * res_offsets_) : res_offsets(*res_offsets_) {}
 
         void reserve(ssize_t result_size_hint, size_t src_size)
         {
@@ -147,7 +147,7 @@ namespace
 
     struct NoResultOffsetsBuilder
     {
-        NoResultOffsetsBuilder(IColumn::Offsets_t * res_offsets_) {}
+        explicit NoResultOffsetsBuilder(IColumn::Offsets_t * res_offsets_) {}
         void reserve(ssize_t result_size_hint, size_t src_size) {}
         void insertOne(size_t array_size) {}
 
diff --git a/dbms/src/Common/Exception.cpp b/dbms/src/Common/Exception.cpp
index d1176f73d07..8a512f48f89 100644
--- a/dbms/src/Common/Exception.cpp
+++ b/dbms/src/Common/Exception.cpp
@@ -30,7 +30,6 @@ void throwFromErrno(const std::string & s, int code, int e)
     const size_t buf_size = 128;
     char buf[buf_size];
 #ifndef _GNU_SOURCE
-    const char * unknown_message = "Unknown error ";
     int rc = strerror_r(e, buf, buf_size);
 #ifdef __APPLE__
     if (rc != 0 && rc != EINVAL)
@@ -40,6 +39,7 @@ void throwFromErrno(const std::string & s, int code, int e)
     {
         std::string tmp = std::to_string(code);
         const char * code = tmp.c_str();
+        const char * unknown_message = "Unknown error ";
         strcpy(buf, unknown_message);
         strcpy(buf + strlen(unknown_message), code);
     }
diff --git a/dbms/src/Common/Exception.h b/dbms/src/Common/Exception.h
index ecf3790d790..a978ba4a303 100644
--- a/dbms/src/Common/Exception.h
+++ b/dbms/src/Common/Exception.h
@@ -17,19 +17,12 @@ namespace DB
 class Exception : public Poco::Exception
 {
 public:
-    Exception(int code = 0) : Poco::Exception(code) {}
+    Exception() {}  /// For deferred initialization.
     Exception(const std::string & msg, int code = 0) : Poco::Exception(msg, code) {}
     Exception(const std::string & msg, const std::string & arg, int code = 0) : Poco::Exception(msg, arg, code) {}
     Exception(const std::string & msg, const Exception & exc, int code = 0) : Poco::Exception(msg, exc, code), trace(exc.trace) {}
-    Exception(const Exception & exc) : Poco::Exception(exc), trace(exc.trace) {}
     explicit Exception(const Poco::Exception & exc) : Poco::Exception(exc.displayText()) {}
-    ~Exception() throw() override {}
-    Exception & operator = (const Exception & exc)
-    {
-        Poco::Exception::operator=(exc);
-        trace = exc.trace;
-        return *this;
-    }
+
     const char * name() const throw() override { return "DB::Exception"; }
     const char * className() const throw() override { return "DB::Exception"; }
     DB::Exception * clone() const override { return new DB::Exception(*this); }
@@ -49,16 +42,12 @@ private:
 class ErrnoException : public Exception
 {
 public:
-    ErrnoException(int code = 0, int saved_errno_ = 0)
-        : Exception(code), saved_errno(saved_errno_) {}
     ErrnoException(const std::string & msg, int code = 0, int saved_errno_ = 0)
         : Exception(msg, code), saved_errno(saved_errno_) {}
     ErrnoException(const std::string & msg, const std::string & arg, int code = 0, int saved_errno_ = 0)
         : Exception(msg, arg, code), saved_errno(saved_errno_) {}
     ErrnoException(const std::string & msg, const Exception & exc, int code = 0, int saved_errno_ = 0)
         : Exception(msg, exc, code), saved_errno(saved_errno_) {}
-    ErrnoException(const ErrnoException & exc)
-        : Exception(exc), saved_errno(exc.saved_errno) {}
 
     int getErrno() const { return saved_errno; }
 
diff --git a/dbms/src/Common/NetException.h b/dbms/src/Common/NetException.h
index aef98bcd079..b2b12e85648 100644
--- a/dbms/src/Common/NetException.h
+++ b/dbms/src/Common/NetException.h
@@ -5,23 +5,21 @@
 
 namespace DB
 {
+
 class NetException : public DB::Exception
 {
 public:
-    explicit NetException(int code = 0) : DB::Exception(code) {}
     NetException(const std::string & msg, int code = 0) : DB::Exception(msg, code) {}
     NetException(const std::string & msg, const std::string & arg, int code = 0) : DB::Exception(msg, arg, code) {}
     NetException(const std::string & msg, const DB::Exception & exc, int code = 0) : DB::Exception(msg, exc, code) {}
 
     explicit NetException(const DB::Exception & exc) : DB::Exception(exc) {}
     explicit NetException(const Poco::Exception & exc) : DB::Exception(exc.displayText()) {}
-    NetException(const DB::NetException & exc) = default;
-
-    ~NetException() throw() override {}
 
     const char * name() const throw() override { return "DB::NetException"; }
     const char * className() const throw() override { return "DB::NetException"; }
     DB::NetException * clone() const override { return new DB::NetException(*this); }
     void rethrow() const override { throw *this; }
 };
-}
\ No newline at end of file
+
+}
diff --git a/dbms/src/Common/SharedLibrary.h b/dbms/src/Common/SharedLibrary.h
index 2b55b396f12..96c8f6fe025 100644
--- a/dbms/src/Common/SharedLibrary.h
+++ b/dbms/src/Common/SharedLibrary.h
@@ -2,16 +2,18 @@
 
 #include <memory>
 #include <string>
-#include <boost/core/noncopyable.hpp>
+#include <boost/noncopyable.hpp>
+
 
 namespace DB
 {
-/** Allows you to open a dynamic library and get a pointer to a function from it.
+
+    /** Allows you to open a dynamic library and get a pointer to a function from it.
   */
 class SharedLibrary : private boost::noncopyable
 {
 public:
-    SharedLibrary(const std::string & path);
+    explicit SharedLibrary(const std::string & path);
 
     ~SharedLibrary();
 
@@ -33,4 +35,5 @@ private:
 };
 
 using SharedLibraryPtr = std::shared_ptr<SharedLibrary>;
+
 }
diff --git a/dbms/src/Common/ZooKeeper/SingleBarrier.cpp b/dbms/src/Common/ZooKeeper/SingleBarrier.cpp
index ba6e21e0797..54fa2c3d2d0 100644
--- a/dbms/src/Common/ZooKeeper/SingleBarrier.cpp
+++ b/dbms/src/Common/ZooKeeper/SingleBarrier.cpp
@@ -67,8 +67,6 @@ void SingleBarrier::enter(UInt64 timeout)
 {
     __sync_synchronize();
 
-    bool is_first_crossing = true;
-
     RWLock lock{get_zookeeper, path + "/lock"};
 
     try
@@ -92,6 +90,7 @@ void SingleBarrier::enter(UInt64 timeout)
             throw KeeperException{code};
 
         Stopwatch watch;
+        bool is_first_crossing = true;
 
         while (true)
         {
diff --git a/dbms/src/Common/ZooKeeper/ZooKeeper.cpp b/dbms/src/Common/ZooKeeper/ZooKeeper.cpp
index 29f42ac2a30..05c5c16d3d2 100644
--- a/dbms/src/Common/ZooKeeper/ZooKeeper.cpp
+++ b/dbms/src/Common/ZooKeeper/ZooKeeper.cpp
@@ -33,17 +33,14 @@ const int CreateMode::Ephemeral = ZOO_EPHEMERAL;
 const int CreateMode::EphemeralSequential = ZOO_EPHEMERAL | ZOO_SEQUENCE;
 const int CreateMode::PersistentSequential = ZOO_SEQUENCE;
 
-void check(int32_t code, const std::string path = "")
+
+static void check(int32_t code, const std::string & path)
 {
     if (code != ZOK)
-    {
-        if (path.size())
-            throw KeeperException(code, path);
-        else
-            throw KeeperException(code);
-    }
+        throw KeeperException(code, path);
 }
 
+
 struct WatchContext
 {
     /// ZooKeeper instance exists for the entire WatchContext lifetime.
diff --git a/dbms/src/Common/ZooKeeper/tests/zkutil_expiration_test.cpp b/dbms/src/Common/ZooKeeper/tests/zkutil_expiration_test.cpp
index 4ee2b147447..6855e63ce3c 100644
--- a/dbms/src/Common/ZooKeeper/tests/zkutil_expiration_test.cpp
+++ b/dbms/src/Common/ZooKeeper/tests/zkutil_expiration_test.cpp
@@ -39,8 +39,7 @@ int main(int argc, char ** argv)
                 int code;
                 try
                 {
-                    code = zk.tryMulti(ops);std::string unused;
-                    //code = zk.tryCreate("/test", "", zkutil::CreateMode::Persistent, unused);
+                    code = zk.tryMulti(ops);
                 }
                 catch (zkutil::KeeperException & e)
                 {
diff --git a/dbms/src/Common/tests/compact_array.cpp b/dbms/src/Common/tests/compact_array.cpp
index d7c09850ec3..e83496514a1 100644
--- a/dbms/src/Common/tests/compact_array.cpp
+++ b/dbms/src/Common/tests/compact_array.cpp
@@ -54,7 +54,7 @@ struct Test
                 wb.write(reinterpret_cast<const char *>(&store), sizeof(store));
                 const unsigned char * p = reinterpret_cast<const unsigned char *>(&store);
                 for (size_t i = 0; i < sizeof(store); ++i)
-                    ++p;
+                    ++*p;
             }
 
             {
diff --git a/dbms/src/Common/tests/int_hashes_perf.cpp b/dbms/src/Common/tests/int_hashes_perf.cpp
index 990292e4e66..ae64c84f53c 100644
--- a/dbms/src/Common/tests/int_hashes_perf.cpp
+++ b/dbms/src/Common/tests/int_hashes_perf.cpp
@@ -306,16 +306,16 @@ int main(int argc, char ** argv)
 
     setAffinity();
 
-    if (!method || method == 0) test<identity>  (n, &data[0], "0: identity");
-    if (!method || method == 1) test<intHash32> (n, &data[0], "1: intHash32");
-    if (!method || method == 2) test<intHash64> (n, &data[0], "2: intHash64");
-    if (!method || method == 3) test<hash3>     (n, &data[0], "3: two rounds");
-    if (!method || method == 4) test<hash4>     (n, &data[0], "4: two rounds and two variables");
-    if (!method || method == 5) test<hash5>     (n, &data[0], "5: two rounds with less ops");
-    if (!method || method == 6) test<murmurMix> (n, &data[0], "6: murmur64 mixer");
-    if (!method || method == 7) test<mulShift>  (n, &data[0], "7: mulShift");
-    if (!method || method == 8) test<tabulation>(n, &data[0], "8: tabulation");
-    if (!method || method == 9) test<crc32Hash> (n, &data[0], "9: crc32");
+    if (!method || method == 1) test<identity>  (n, &data[0], "0: identity");
+    if (!method || method == 2) test<intHash32> (n, &data[0], "1: intHash32");
+    if (!method || method == 3) test<intHash64> (n, &data[0], "2: intHash64");
+    if (!method || method == 4) test<hash3>     (n, &data[0], "3: two rounds");
+    if (!method || method == 5) test<hash4>     (n, &data[0], "4: two rounds and two variables");
+    if (!method || method == 6) test<hash5>     (n, &data[0], "5: two rounds with less ops");
+    if (!method || method == 7) test<murmurMix> (n, &data[0], "6: murmur64 mixer");
+    if (!method || method == 8) test<mulShift>  (n, &data[0], "7: mulShift");
+    if (!method || method == 9) test<tabulation>(n, &data[0], "8: tabulation");
+    if (!method || method == 10) test<crc32Hash> (n, &data[0], "9: crc32");
 
     return 0;
 }
diff --git a/dbms/src/Common/tests/lru_cache.cpp b/dbms/src/Common/tests/lru_cache.cpp
index c311b88494c..90de5903673 100644
--- a/dbms/src/Common/tests/lru_cache.cpp
+++ b/dbms/src/Common/tests/lru_cache.cpp
@@ -46,7 +46,7 @@ void run()
     }
 }
 
-void runTest(unsigned int num, const std::function<bool()> func)
+void runTest(unsigned int num, const std::function<bool()> & func)
 {
     bool ok;
 
diff --git a/dbms/src/Core/tests/rvo_test.cpp b/dbms/src/Core/tests/rvo_test.cpp
index 143b511c816..aa6cc1a3a6b 100644
--- a/dbms/src/Core/tests/rvo_test.cpp
+++ b/dbms/src/Core/tests/rvo_test.cpp
@@ -8,7 +8,7 @@ struct C
 {
     volatile int data;
 
-    C(int n = 0) : data(n) {}
+    explicit C(int n = 0) : data(n) {}
 
     C(const C & x)
     {
@@ -140,7 +140,7 @@ C f10()
 
 C f11()
 {
-    return rand() % 2 ? f1() : f2();
+    return (rand() % 2) ? f1() : f2();
 }
 
 C f12()
diff --git a/dbms/src/DataStreams/MergingAggregatedMemoryEfficientBlockInputStream.h b/dbms/src/DataStreams/MergingAggregatedMemoryEfficientBlockInputStream.h
index 17655e0edbf..1b1de6f90af 100644
--- a/dbms/src/DataStreams/MergingAggregatedMemoryEfficientBlockInputStream.h
+++ b/dbms/src/DataStreams/MergingAggregatedMemoryEfficientBlockInputStream.h
@@ -146,7 +146,7 @@ private:
         /// An event by which the main thread is telling merging threads that it is possible to process the next group of blocks.
         std::condition_variable have_space;
 
-        ParallelMergeData(size_t max_threads) : pool(max_threads) {}
+        explicit ParallelMergeData(size_t max_threads) : pool(max_threads) {}
     };
 
     std::unique_ptr<ParallelMergeData> parallel_merge_data;
diff --git a/dbms/src/DataStreams/SummingSortedBlockInputStream.cpp b/dbms/src/DataStreams/SummingSortedBlockInputStream.cpp
index 2aa27c37a4d..e1610d3a68d 100644
--- a/dbms/src/DataStreams/SummingSortedBlockInputStream.cpp
+++ b/dbms/src/DataStreams/SummingSortedBlockInputStream.cpp
@@ -241,7 +241,7 @@ void SummingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std:
     /// If it is zero, and without it the output stream will be empty, we will write it anyway.
     if (!current_row_is_zero || !output_is_non_empty)
     {
-        ++merged_rows;
+        ++merged_rows;  /// Dead store (result is unused). Left for clarity.
         insertCurrentRow(merged_columns);
     }
 
@@ -257,15 +257,15 @@ class FieldVisitorSum : public StaticVisitor<bool>
 private:
     const Field & rhs;
 public:
-    FieldVisitorSum(const Field & rhs_) : rhs(rhs_) {}
+    explicit FieldVisitorSum(const Field & rhs_) : rhs(rhs_) {}
 
-    bool operator() (UInt64     & x) const { x += get<UInt64>(rhs); return x != 0; }
-    bool operator() (Int64         & x) const { x += get<Int64>(rhs); return x != 0; }
-    bool operator() (Float64     & x) const { x += get<Float64>(rhs); return x != 0; }
+    bool operator() (UInt64 & x) const { x += get<UInt64>(rhs); return x != 0; }
+    bool operator() (Int64 & x) const { x += get<Int64>(rhs); return x != 0; }
+    bool operator() (Float64 & x) const { x += get<Float64>(rhs); return x != 0; }
 
-    bool operator() (Null         & x) const { throw Exception("Cannot sum Nulls", ErrorCodes::LOGICAL_ERROR); }
-    bool operator() (String     & x) const { throw Exception("Cannot sum Strings", ErrorCodes::LOGICAL_ERROR); }
-    bool operator() (Array         & x) const { throw Exception("Cannot sum Arrays", ErrorCodes::LOGICAL_ERROR); }
+    bool operator() (Null & x) const { throw Exception("Cannot sum Nulls", ErrorCodes::LOGICAL_ERROR); }
+    bool operator() (String & x) const { throw Exception("Cannot sum Strings", ErrorCodes::LOGICAL_ERROR); }
+    bool operator() (Array & x) const { throw Exception("Cannot sum Arrays", ErrorCodes::LOGICAL_ERROR); }
 };
 
 
diff --git a/dbms/src/DataTypes/DataTypeArray.cpp b/dbms/src/DataTypes/DataTypeArray.cpp
index c6609656c46..fb13f6bab1e 100644
--- a/dbms/src/DataTypes/DataTypeArray.cpp
+++ b/dbms/src/DataTypes/DataTypeArray.cpp
@@ -230,11 +230,11 @@ static void deserializeTextImpl(IColumn & column, ReadBuffer & istr, Reader && r
     IColumn & nested_column = column_array.getData();
 
     size_t size = 0;
-    bool first = true;
     assertChar('[', istr);
 
     try
     {
+        bool first = true;
         while (!istr.eof() && *istr.position() != ']')
         {
             if (!first)
diff --git a/dbms/src/DataTypes/DataTypeNumberBase.cpp b/dbms/src/DataTypes/DataTypeNumberBase.cpp
index 6b2515c0274..b7fe9dbd14c 100644
--- a/dbms/src/DataTypes/DataTypeNumberBase.cpp
+++ b/dbms/src/DataTypes/DataTypeNumberBase.cpp
@@ -113,9 +113,6 @@ void DataTypeNumberBase<T>::serializeTextJSON(const IColumn & column, size_t row
 template <typename T>
 void DataTypeNumberBase<T>::deserializeTextJSON(IColumn & column, ReadBuffer & istr) const
 {
-    static constexpr bool is_uint8 = std::is_same<T, UInt8>::value;
-    static constexpr bool is_int8 = std::is_same<T, Int8>::value;
-
     bool has_quote = false;
     if (!istr.eof() && *istr.position() == '"')        /// We understand the number both in quotes and without.
     {
@@ -135,6 +132,9 @@ void DataTypeNumberBase<T>::deserializeTextJSON(IColumn & column, ReadBuffer & i
     }
     else
     {
+        static constexpr bool is_uint8 = std::is_same<T, UInt8>::value;
+        static constexpr bool is_int8 = std::is_same<T, Int8>::value;
+
         if (is_uint8 || is_int8)
         {
             // extra conditions to parse true/false strings into 1/0
diff --git a/dbms/src/DataTypes/tests/data_type_string.cpp b/dbms/src/DataTypes/tests/data_type_string.cpp
index 9da44127e3c..d5e6624a958 100644
--- a/dbms/src/DataTypes/tests/data_type_string.cpp
+++ b/dbms/src/DataTypes/tests/data_type_string.cpp
@@ -5,8 +5,8 @@
 
 #include <Common/Stopwatch.h>
 
-#include <IO/ReadBufferFromFileDescriptor.h>
-#include <IO/WriteBufferFromFileDescriptor.h>
+#include <IO/ReadBufferFromFile.h>
+#include <IO/WriteBufferFromFile.h>
 #include <Columns/ColumnString.h>
 #include <DataTypes/DataTypeString.h>
 
@@ -35,8 +35,7 @@ try
             offsets[i] = (i + 1) * size;
         }
 
-        std::ofstream ostr("test");
-        WriteBufferFromFileDescriptor out_buf(STDOUT_FILENO);
+        WriteBufferFromFile out_buf("test");
 
         stopwatch.restart();
         data_type.serializeBinaryBulk(*column, out_buf, 0, 0);
@@ -48,8 +47,7 @@ try
     {
         std::shared_ptr<ColumnString> column = std::make_shared<ColumnString>();
 
-        std::ifstream istr("test");
-        ReadBufferFromFileDescriptor in_buf(STDIN_FILENO);
+        ReadBufferFromFile in_buf("test");
 
         stopwatch.restart();
         data_type.deserializeBinaryBulk(*column, in_buf, n, 0);
diff --git a/dbms/src/Databases/DatabaseCloud.cpp b/dbms/src/Databases/DatabaseCloud.cpp
index 62c7914b0b2..8ec75a0b92a 100644
--- a/dbms/src/Databases/DatabaseCloud.cpp
+++ b/dbms/src/Databases/DatabaseCloud.cpp
@@ -176,7 +176,7 @@ struct TableSet
     using Container = std::map<String, TableDescription>;
     Container map;
 
-    TableSet(const String & data)
+    explicit TableSet(const String & data)
     {
         ReadBufferFromString in(data);
         read(in);
@@ -466,7 +466,7 @@ private:
     }
 
 public:
-    DatabaseCloudIterator(DatabasePtr database)
+    explicit DatabaseCloudIterator(DatabasePtr database)
         : owned_database(database),
         zookeeper(parent().context.getZooKeeper()),
         zookeeper_path(parent().zookeeper_path + "/tables/" + parent().name),
diff --git a/dbms/src/Dictionaries/LibraryDictionarySource.cpp b/dbms/src/Dictionaries/LibraryDictionarySource.cpp
index d571a71fae8..3b8d35dfc93 100644
--- a/dbms/src/Dictionaries/LibraryDictionarySource.cpp
+++ b/dbms/src/Dictionaries/LibraryDictionarySource.cpp
@@ -14,13 +14,12 @@ namespace ErrorCodes
     extern const int FILE_DOESNT_EXIST;
 }
 
-const std::string lib_config_settings = ".settings";
 
 class CStringsHolder
 {
 public:
-    using strings_type = std::vector<std::string>;
-    CStringsHolder(strings_type strings_pass)
+    using Container = std::vector<std::string>;
+    explicit CStringsHolder(const Container & strings_pass)
     {
         strings_holder = strings_pass;
         strings.size = strings_holder.size();
@@ -38,15 +37,22 @@ public:
 
 private:
     std::unique_ptr<ClickHouseLibrary::CString[]> ptr_holder = nullptr;
-    strings_type strings_holder;
+    Container strings_holder;
 
 };
 
+
+namespace
+{
+
+const std::string lib_config_settings = ".settings";
+
+
 CStringsHolder getLibSettings(const Poco::Util::AbstractConfiguration & config, const std::string & config_root)
 {
     Poco::Util::AbstractConfiguration::Keys config_keys;
     config.keys(config_root, config_keys);
-    CStringsHolder::strings_type strings;
+    CStringsHolder::Container strings;
     for (const auto & key : config_keys)
     {
         std::string key_name = key;
@@ -59,10 +65,12 @@ CStringsHolder getLibSettings(const Poco::Util::AbstractConfiguration & config,
     return CStringsHolder(strings);
 }
 
+
 bool dataToBlock(const void * data, Block & block)
 {
     if (!data)
         return true;
+
     auto columns_received = static_cast<const ClickHouseLibrary::ColumnsUInt64 *>(data);
     std::vector<IColumn *> columns(block.columns());
     for (const auto i : ext::range(0, columns.size()))
@@ -82,6 +90,9 @@ bool dataToBlock(const void * data, Block & block)
     return false;
 }
 
+}
+
+
 LibraryDictionarySource::LibraryDictionarySource(const DictionaryStructure & dict_struct_,
     const Poco::Util::AbstractConfiguration & config,
     const std::string & config_prefix,
diff --git a/dbms/src/Dictionaries/LibraryDictionarySource.h b/dbms/src/Dictionaries/LibraryDictionarySource.h
index fdde72ab7cc..4835ba02afe 100644
--- a/dbms/src/Dictionaries/LibraryDictionarySource.h
+++ b/dbms/src/Dictionaries/LibraryDictionarySource.h
@@ -7,6 +7,7 @@
 
 #include <iostream>
 
+
 namespace Poco
 {
 class Logger;
@@ -15,6 +16,7 @@ class Logger;
 
 namespace DB
 {
+
 class CStringsHolder;
 
 /// Allows loading dictionaries from dynamic libraries (.so)
diff --git a/dbms/src/Functions/Conditional/StringArrayEvaluator.cpp b/dbms/src/Functions/Conditional/StringArrayEvaluator.cpp
index b01f19e6a21..2977914897d 100644
--- a/dbms/src/Functions/Conditional/StringArrayEvaluator.cpp
+++ b/dbms/src/Functions/Conditional/StringArrayEvaluator.cpp
@@ -44,7 +44,7 @@ using VarCallback = std::function<size_t(ColumnString::Chars_t & to_data,
 /// the code slightly simpler to read.
 struct Chunk
 {
-    Chunk(const VarCallback & var_callback_)
+    explicit Chunk(const VarCallback & var_callback_)
         : var_callback{var_callback_}
     {
     }
@@ -90,7 +90,7 @@ public:
 
     Chunk get() const override
     {
-        return {var_callback};
+        return Chunk{var_callback};
     }
 
     void next() override
@@ -174,7 +174,7 @@ public:
 
     Chunk get() const override
     {
-        return {var_callback};
+        return Chunk{var_callback};
     }
 
     void next() override
diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp
index e66788aa6b6..bf26faa78fa 100644
--- a/dbms/src/Functions/FunctionsArray.cpp
+++ b/dbms/src/Functions/FunctionsArray.cpp
@@ -2304,7 +2304,7 @@ DataTypePtr FunctionRange::getReturnTypeImpl(const DataTypes & arguments) const
 
     if (!checkDataType<DataTypeUInt8>(arg) &&
         !checkDataType<DataTypeUInt16>(arg) &&
-        !checkDataType<DataTypeUInt32>(arg) &
+        !checkDataType<DataTypeUInt32>(arg) &&
         !checkDataType<DataTypeUInt64>(arg))
     {
         throw Exception{
diff --git a/dbms/src/Functions/FunctionsCharset.cpp b/dbms/src/Functions/FunctionsCharset.cpp
index dc0efa30a07..2642632afbe 100644
--- a/dbms/src/Functions/FunctionsCharset.cpp
+++ b/dbms/src/Functions/FunctionsCharset.cpp
@@ -44,7 +44,7 @@ private:
     {
         UConverter * impl;
 
-        Converter(const String & charset)
+        explicit Converter(const String & charset)
         {
             UErrorCode status = U_ZERO_ERROR;
             impl = ucnv_open(charset.data(), &status);
diff --git a/dbms/src/Functions/FunctionsMiscellaneous.cpp b/dbms/src/Functions/FunctionsMiscellaneous.cpp
index c18bbe9dc93..7772c39394c 100644
--- a/dbms/src/Functions/FunctionsMiscellaneous.cpp
+++ b/dbms/src/Functions/FunctionsMiscellaneous.cpp
@@ -1280,7 +1280,7 @@ public:
         return std::make_shared<FunctionUptime>(context.getUptimeSeconds());
     }
 
-    FunctionUptime(time_t uptime_) : uptime(uptime_)
+    explicit FunctionUptime(time_t uptime_) : uptime(uptime_)
     {
     }
 
@@ -1598,7 +1598,7 @@ public:
         return std::make_shared<FunctionHasColumnInTable>(context.getGlobalContext());
     }
 
-    FunctionHasColumnInTable(const Context & global_context_) : global_context(global_context_)
+    explicit FunctionHasColumnInTable(const Context & global_context_) : global_context(global_context_)
     {
     }
 
diff --git a/dbms/src/Functions/tests/functions_arithmetic.cpp b/dbms/src/Functions/tests/functions_arithmetic.cpp
index 189bef0a39b..1798ae7a47f 100644
--- a/dbms/src/Functions/tests/functions_arithmetic.cpp
+++ b/dbms/src/Functions/tests/functions_arithmetic.cpp
@@ -49,8 +49,6 @@ try
     arg_nums.push_back(0);
     arg_nums.push_back(1);
 
-    size_t res_num = 2;
-
     DataTypePtr res_type = f.getReturnType(arg_types);
 
     ColumnWithTypeAndName descr_res;
@@ -61,6 +59,7 @@ try
         Stopwatch stopwatch;
         stopwatch.start();
 
+        size_t res_num = 2;
         f.execute(block, arg_nums, res_num);
 
         stopwatch.stop();
diff --git a/dbms/src/Functions/tests/logical_functions_performance.cpp b/dbms/src/Functions/tests/logical_functions_performance.cpp
index 09cf1784a3c..a2d76416a5a 100644
--- a/dbms/src/Functions/tests/logical_functions_performance.cpp
+++ b/dbms/src/Functions/tests/logical_functions_performance.cpp
@@ -75,7 +75,7 @@ struct AssociativeOperationImpl
     AssociativeOperationImpl<Op, N - 1> continuation;
 
     /// Remembers the last N columns from in.
-    AssociativeOperationImpl(UInt8ColumnPtrs & in)
+    explicit AssociativeOperationImpl(UInt8ColumnPtrs & in)
         : vec(in[in.size() - N]->getData()), continuation(in) {}
 
     /// Returns a combination of values in the i-th row of all columns stored in the constructor.
@@ -97,7 +97,7 @@ struct AssociativeOperationImpl<Op, 1>
 
     const UInt8 * vec;
 
-    AssociativeOperationImpl(UInt8ColumnPtrs & in)
+    explicit AssociativeOperationImpl(UInt8ColumnPtrs & in)
         : vec(&in[in.size() - 1]->getData()[0]) {}
 
     inline UInt8 apply(size_t i) const
diff --git a/dbms/src/IO/BufferWithOwnMemory.h b/dbms/src/IO/BufferWithOwnMemory.h
index 89ffcf053ac..43040efd042 100644
--- a/dbms/src/IO/BufferWithOwnMemory.h
+++ b/dbms/src/IO/BufferWithOwnMemory.h
@@ -86,6 +86,7 @@ struct Memory : boost::noncopyable, Allocator<false>
         }
     }
 
+private:
     static size_t align(const size_t value, const size_t alignment)
     {
         if (!alignment)
@@ -94,7 +95,6 @@ struct Memory : boost::noncopyable, Allocator<false>
         return (value + alignment - 1) / alignment * alignment;
     }
 
-private:
     void alloc()
     {
         if (!m_capacity)
diff --git a/dbms/src/IO/MemoryReadWriteBuffer.cpp b/dbms/src/IO/MemoryReadWriteBuffer.cpp
index c007d611ce3..4f849f157ab 100644
--- a/dbms/src/IO/MemoryReadWriteBuffer.cpp
+++ b/dbms/src/IO/MemoryReadWriteBuffer.cpp
@@ -15,12 +15,10 @@ namespace ErrorCodes
 class ReadBufferFromMemoryWriteBuffer : public ReadBuffer, boost::noncopyable, private Allocator<false>
 {
 public:
-
-    ReadBufferFromMemoryWriteBuffer(MemoryWriteBuffer && origin)
-    :
-    ReadBuffer(nullptr, 0),
-    chunk_list(std::move(origin.chunk_list)),
-    end_pos(origin.position())
+    explicit ReadBufferFromMemoryWriteBuffer(MemoryWriteBuffer && origin)
+    : ReadBuffer(nullptr, 0),
+        chunk_list(std::move(origin.chunk_list)),
+        end_pos(origin.position())
     {
         chunk_head = chunk_list.begin();
         setChunk();
@@ -76,11 +74,16 @@ private:
 
 
 MemoryWriteBuffer::MemoryWriteBuffer(size_t max_total_size_, size_t initial_chunk_size_, double growth_rate_, size_t max_chunk_size_)
-: WriteBuffer(nullptr, 0), max_total_size(max_total_size_), initial_chunk_size(initial_chunk_size_), max_chunk_size(max_chunk_size_), growth_rate(growth_rate_)
+    : WriteBuffer(nullptr, 0),
+    max_total_size(max_total_size_),
+    initial_chunk_size(initial_chunk_size_),
+    max_chunk_size(max_chunk_size_),
+    growth_rate(growth_rate_)
 {
     addChunk();
 }
 
+
 void MemoryWriteBuffer::nextImpl()
 {
     if (unlikely(hasPendingData()))
@@ -93,6 +96,7 @@ void MemoryWriteBuffer::nextImpl()
     addChunk();
 }
 
+
 void MemoryWriteBuffer::addChunk()
 {
     size_t next_chunk_size;
@@ -126,6 +130,7 @@ void MemoryWriteBuffer::addChunk()
     set(chunk_tail->begin(), chunk_tail->size());
 }
 
+
 std::shared_ptr<ReadBuffer> MemoryWriteBuffer::getReadBufferImpl()
 {
     auto res = std::make_shared<ReadBufferFromMemoryWriteBuffer>(std::move(*this));
@@ -137,6 +142,7 @@ std::shared_ptr<ReadBuffer> MemoryWriteBuffer::getReadBufferImpl()
     return res;
 }
 
+
 MemoryWriteBuffer::~MemoryWriteBuffer()
 {
     for (const auto & range : chunk_list)
diff --git a/dbms/src/IO/ReadHelpers.cpp b/dbms/src/IO/ReadHelpers.cpp
index 9853baef198..6d9f66307a6 100644
--- a/dbms/src/IO/ReadHelpers.cpp
+++ b/dbms/src/IO/ReadHelpers.cpp
@@ -49,6 +49,7 @@ void parseUUID(const UInt8 * src36, std::reverse_iterator<UInt8 *> dst16)
 {
     /// If string is not like UUID - implementation specific behaviour.
 
+    /// FIXME This code looks like trash.
     parseHex(&src36[0], dst16 + 8, 4);
     parseHex(&src36[9], dst16 + 12, 2);
     parseHex(&src36[14], dst16 + 14, 2);
diff --git a/dbms/src/IO/WriteHelpers.cpp b/dbms/src/IO/WriteHelpers.cpp
index 282ca23464a..39b39ae7284 100644
--- a/dbms/src/IO/WriteHelpers.cpp
+++ b/dbms/src/IO/WriteHelpers.cpp
@@ -1,6 +1,7 @@
 #include <IO/WriteHelpers.h>
 #include <inttypes.h>
-#include <stdio.h>
+#include <Common/hex.h>
+
 
 namespace DB
 {
@@ -8,30 +9,11 @@ namespace DB
 template <typename IteratorSrc, typename IteratorDst>
 void formatHex(IteratorSrc src, IteratorDst dst, const size_t num_bytes)
 {
-    /// More optimal than lookup table by nibbles.
-    constexpr auto hex =
-        "000102030405060708090a0b0c0d0e0f"
-        "101112131415161718191a1b1c1d1e1f"
-        "202122232425262728292a2b2c2d2e2f"
-        "303132333435363738393a3b3c3d3e3f"
-        "404142434445464748494a4b4c4d4e4f"
-        "505152535455565758595a5b5c5d5e5f"
-        "606162636465666768696a6b6c6d6e6f"
-        "707172737475767778797a7b7c7d7e7f"
-        "808182838485868788898a8b8c8d8e8f"
-        "909192939495969798999a9b9c9d9e9f"
-        "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
-        "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
-        "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"
-        "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
-        "e0e1e2e3e4e5e6e7e8e9eaebecedeeef"
-        "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";
-
     size_t src_pos = 0;
     size_t dst_pos = 0;
     for (; src_pos < num_bytes; ++src_pos)
     {
-        memcpy(&dst[dst_pos], &hex[src[src_pos] * 2], 2);
+        writeHexByteLowercase(src[src_pos], &dst[dst_pos]);
         dst_pos += 2;
     }
 }
diff --git a/dbms/src/IO/tests/compressed_buffer.cpp b/dbms/src/IO/tests/compressed_buffer.cpp
index f663474b035..2bdb6b17be6 100644
--- a/dbms/src/IO/tests/compressed_buffer.cpp
+++ b/dbms/src/IO/tests/compressed_buffer.cpp
@@ -43,7 +43,6 @@ int main(int argc, char ** argv)
         {
             DB::ReadBufferFromFile buf("test1");
             DB::CompressedReadBuffer compressed_buf(buf);
-            std::string s;
 
             stopwatch.restart();
             for (size_t i = 0; i < n; ++i)
diff --git a/dbms/src/IO/tests/read_buffer_aio.cpp b/dbms/src/IO/tests/read_buffer_aio.cpp
index 56fbeab5d8b..1b0a36c22f9 100644
--- a/dbms/src/IO/tests/read_buffer_aio.cpp
+++ b/dbms/src/IO/tests/read_buffer_aio.cpp
@@ -20,7 +20,7 @@ void prepare3(std::string  & filename, std::string & buf);
 void prepare4(std::string  & filename, std::string & buf);
 std::string createTmpFile();
 void die(const std::string & msg);
-void runTest(unsigned int num, const std::function<bool()> func);
+void runTest(unsigned int num, const std::function<bool()> & func);
 
 bool test1(const std::string & filename);
 bool test2(const std::string & filename, const std::string & buf);
@@ -184,7 +184,7 @@ void die(const std::string & msg)
     ::exit(EXIT_FAILURE);
 }
 
-void runTest(unsigned int num, const std::function<bool()> func)
+void runTest(unsigned int num, const std::function<bool()> & func)
 {
     bool ok;
 
diff --git a/dbms/src/IO/tests/write_buffer_aio.cpp b/dbms/src/IO/tests/write_buffer_aio.cpp
index 5394d67a36d..a325c834022 100644
--- a/dbms/src/IO/tests/write_buffer_aio.cpp
+++ b/dbms/src/IO/tests/write_buffer_aio.cpp
@@ -15,7 +15,7 @@ namespace fs = boost::filesystem;
 
 void run();
 void die(const std::string & msg);
-void runTest(unsigned int num, const std::function<bool()> func);
+void runTest(unsigned int num, const std::function<bool()> & func);
 std::string createTmpFile();
 std::string generateString(size_t n);
 
@@ -60,7 +60,7 @@ void die(const std::string & msg)
     ::exit(EXIT_FAILURE);
 }
 
-void runTest(unsigned int num, const std::function<bool()> func)
+void runTest(unsigned int num, const std::function<bool()> & func)
 {
     bool ok;
 
diff --git a/dbms/src/Interpreters/Aggregator.cpp b/dbms/src/Interpreters/Aggregator.cpp
index 4cfd5967a1d..8b038f6aa67 100644
--- a/dbms/src/Interpreters/Aggregator.cpp
+++ b/dbms/src/Interpreters/Aggregator.cpp
@@ -1734,7 +1734,7 @@ private:
         std::mutex mutex;
         std::condition_variable condvar;
 
-        ParallelMergeData(size_t threads) : pool(threads) {}
+        explicit ParallelMergeData(size_t threads) : pool(threads) {}
 
         ~ParallelMergeData()
         {
diff --git a/dbms/src/Interpreters/Context.cpp b/dbms/src/Interpreters/Context.cpp
index cf379b83dd9..06900b87037 100644
--- a/dbms/src/Interpreters/Context.cpp
+++ b/dbms/src/Interpreters/Context.cpp
@@ -100,7 +100,7 @@ struct ContextShared
     mutable zkutil::ZooKeeperPtr zookeeper;                 /// Client for ZooKeeper.
 
     String interserver_io_host;                             /// The host name by which this server is available for other servers.
-    int interserver_io_port;                                /// and port,
+    UInt16 interserver_io_port = 0;                         /// and port.
 
     String path;                                            /// Path to the data directory, with a slash at the end.
     String tmp_path;                                        /// The path to the temporary files that occur when processing the request.
diff --git a/dbms/src/Interpreters/DDLWorker.cpp b/dbms/src/Interpreters/DDLWorker.cpp
index 73dd4a9e686..eda33e983ee 100644
--- a/dbms/src/Interpreters/DDLWorker.cpp
+++ b/dbms/src/Interpreters/DDLWorker.cpp
@@ -62,7 +62,7 @@ struct HostID
 
     HostID() = default;
 
-    HostID(const Cluster::Address & address)
+    explicit HostID(const Cluster::Address & address)
     : host_name(address.host_name), port(address.port) {}
 
     static HostID fromString(const String & host_port_str)
diff --git a/dbms/src/Interpreters/ExternalDictionaries.cpp b/dbms/src/Interpreters/ExternalDictionaries.cpp
index 2930c12b4a9..9fcb8510404 100644
--- a/dbms/src/Interpreters/ExternalDictionaries.cpp
+++ b/dbms/src/Interpreters/ExternalDictionaries.cpp
@@ -320,19 +320,16 @@ void ExternalDictionaries::reloadFromConfigFile(const std::string & config_path,
                         {
                             failed_dict_it->second = FailedDictionaryInfo{
                                 std::move(dict_ptr),
-                                std::chrono::system_clock::now() + std::chrono::seconds{backoff_initial_sec}
-                            };
+                                std::chrono::system_clock::now() + std::chrono::seconds{backoff_initial_sec}};
                         }
                         else
                             failed_dictionaries.emplace(name, FailedDictionaryInfo{
                                 std::move(dict_ptr),
-                                std::chrono::system_clock::now() + std::chrono::seconds{backoff_initial_sec}
-                            });
+                                std::chrono::system_clock::now() + std::chrono::seconds{backoff_initial_sec}});
 
                         std::rethrow_exception(exception_ptr);
                     }
-
-                    if (!dict_ptr->isCached())
+                    else if (!dict_ptr->isCached())
                     {
                         const auto & lifetime = dict_ptr->getLifetime();
                         if (lifetime.min_sec != 0 && lifetime.max_sec != 0)
diff --git a/dbms/src/Interpreters/ProcessList.cpp b/dbms/src/Interpreters/ProcessList.cpp
index 99b256e77e9..afa61220a6d 100644
--- a/dbms/src/Interpreters/ProcessList.cpp
+++ b/dbms/src/Interpreters/ProcessList.cpp
@@ -245,10 +245,10 @@ ProcessList::CancellationCode ProcessList::sendCancelToQuery(const String & curr
 
     BlockInputStreamPtr input_stream;
     BlockOutputStreamPtr output_stream;
-    IProfilingBlockInputStream * input_stream_casted;
 
     if (elem->tryGetQueryStreams(input_stream, output_stream))
     {
+        IProfilingBlockInputStream * input_stream_casted;
         if (input_stream && (input_stream_casted = dynamic_cast<IProfilingBlockInputStream *>(input_stream.get())))
         {
             input_stream_casted->cancel();
diff --git a/dbms/src/Interpreters/Users.cpp b/dbms/src/Interpreters/Users.cpp
index ae98811b95c..4f2a21ba402 100644
--- a/dbms/src/Interpreters/Users.cpp
+++ b/dbms/src/Interpreters/Users.cpp
@@ -162,7 +162,7 @@ private:
     }
 
 public:
-    HostExactPattern(const String & host_) : host(host_) {}
+    explicit HostExactPattern(const String & host_) : host(host_) {}
 
     bool contains(const Poco::Net::IPAddress & addr) const override
     {
@@ -192,7 +192,7 @@ private:
     }
 
 public:
-    HostRegexpPattern(const String & host_regexp_) : host_regexp(host_regexp_) {}
+    explicit HostRegexpPattern(const String & host_regexp_) : host_regexp(host_regexp_) {}
 
     bool contains(const Poco::Net::IPAddress & addr) const override
     {
diff --git a/dbms/src/Interpreters/sortBlock.cpp b/dbms/src/Interpreters/sortBlock.cpp
index 58cbb75a6ec..73015222e99 100644
--- a/dbms/src/Interpreters/sortBlock.cpp
+++ b/dbms/src/Interpreters/sortBlock.cpp
@@ -50,7 +50,7 @@ struct PartialSortingLess
 {
     const ColumnsWithSortDescriptions & columns;
 
-    PartialSortingLess(const ColumnsWithSortDescriptions & columns_) : columns(columns_) {}
+    explicit PartialSortingLess(const ColumnsWithSortDescriptions & columns_) : columns(columns_) {}
 
     bool operator() (size_t a, size_t b) const
     {
@@ -70,7 +70,7 @@ struct PartialSortingLessWithCollation
 {
     const ColumnsWithSortDescriptions & columns;
 
-    PartialSortingLessWithCollation(const ColumnsWithSortDescriptions & columns_) : columns(columns_) {}
+    explicit PartialSortingLessWithCollation(const ColumnsWithSortDescriptions & columns_) : columns(columns_) {}
 
     bool operator() (size_t a, size_t b) const
     {
diff --git a/dbms/src/Interpreters/tests/hash_map_string.cpp b/dbms/src/Interpreters/tests/hash_map_string.cpp
index 817d03876e4..6fbe2f084de 100644
--- a/dbms/src/Interpreters/tests/hash_map_string.cpp
+++ b/dbms/src/Interpreters/tests/hash_map_string.cpp
@@ -40,7 +40,7 @@ struct CompactStringRef
     }
 
     CompactStringRef(const unsigned char * data_, size_t size_) : CompactStringRef(reinterpret_cast<const char *>(data_), size_) {}
-    CompactStringRef(const std::string & s) : CompactStringRef(s.data(), s.size()) {}
+    explicit CompactStringRef(const std::string & s) : CompactStringRef(s.data(), s.size()) {}
     CompactStringRef() {}
 
     const char * data() const { return reinterpret_cast<const char *>(reinterpret_cast<intptr_t>(data_mixed) & 0x0000FFFFFFFFFFFFULL); }
diff --git a/dbms/src/Interpreters/tests/hash_map_string_small.cpp b/dbms/src/Interpreters/tests/hash_map_string_small.cpp
index cbd98451dd4..588fdcc0116 100644
--- a/dbms/src/Interpreters/tests/hash_map_string_small.cpp
+++ b/dbms/src/Interpreters/tests/hash_map_string_small.cpp
@@ -49,7 +49,7 @@ struct SmallStringRef
     }
 
     SmallStringRef(const unsigned char * data_, size_t size_) : SmallStringRef(reinterpret_cast<const char *>(data_), size_) {}
-    SmallStringRef(const std::string & s) : SmallStringRef(s.data(), s.size()) {}
+    explicit SmallStringRef(const std::string & s) : SmallStringRef(s.data(), s.size()) {}
     SmallStringRef() {}
 
     std::string toString() const { return std::string(data(), size); }
diff --git a/dbms/src/Parsers/ASTSelectQuery.cpp b/dbms/src/Parsers/ASTSelectQuery.cpp
index 9c47e16bdbc..b4feb245224 100644
--- a/dbms/src/Parsers/ASTSelectQuery.cpp
+++ b/dbms/src/Parsers/ASTSelectQuery.cpp
@@ -82,7 +82,7 @@ void ASTSelectQuery::rewriteSelectExpressionList(const Names & required_column_n
     struct Arrow
     {
         Arrow() = default;
-        Arrow(size_t to_position_) :
+        explicit Arrow(size_t to_position_) :
             to_position(to_position_), is_selected(true)
         {
         }
diff --git a/dbms/src/Parsers/ParserCase.cpp b/dbms/src/Parsers/ParserCase.cpp
index dfa30bf8355..7a03a8d0307 100644
--- a/dbms/src/Parsers/ParserCase.cpp
+++ b/dbms/src/Parsers/ParserCase.cpp
@@ -26,10 +26,8 @@ bool ParserCase::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
         return ParserFunction{}.parse(pos, node, expected);
     }
 
-    bool has_case_expr = false;
-
     auto old_pos = pos;
-    has_case_expr = !s_when.parse(pos, node, expected);
+    bool has_case_expr = !s_when.parse(pos, node, expected);
     pos = old_pos;
 
     ASTs args;
diff --git a/dbms/src/Server/InterserverIOHTTPHandler.h b/dbms/src/Server/InterserverIOHTTPHandler.h
index a2132a39840..bf9fef59982 100644
--- a/dbms/src/Server/InterserverIOHTTPHandler.h
+++ b/dbms/src/Server/InterserverIOHTTPHandler.h
@@ -19,7 +19,7 @@ namespace DB
 class InterserverIOHTTPHandler : public Poco::Net::HTTPRequestHandler
 {
 public:
-    InterserverIOHTTPHandler(IServer & server_)
+    explicit InterserverIOHTTPHandler(IServer & server_)
         : server(server_)
         , log(&Poco::Logger::get("InterserverIOHTTPHandler"))
     {
diff --git a/dbms/src/Server/PerformanceTest.cpp b/dbms/src/Server/PerformanceTest.cpp
index f33f1df9c04..26e779bfac4 100644
--- a/dbms/src/Server/PerformanceTest.cpp
+++ b/dbms/src/Server/PerformanceTest.cpp
@@ -58,6 +58,8 @@ static String pad(size_t padding)
     return String(padding * 4, ' ');
 }
 
+
+/// NOTE The code is totally wrong.
 class JSONString
 {
 private:
@@ -65,7 +67,7 @@ private:
     size_t padding;
 
 public:
-    JSONString(size_t padding_ = 1) : padding(padding_){};
+    explicit JSONString(size_t padding_ = 1) : padding(padding_){};
 
     void set(const String key, String value, bool wrap = true)
     {
@@ -1041,16 +1043,13 @@ private:
             TestStopConditions & stop_conditions = stop_conditions_by_run[run_index];
             Stats & statistics = statistics_by_run[run_index];
 
-            size_t iteration = 0;
-
             statistics.clear();
             execute(query, statistics, stop_conditions);
 
             if (exec_type == ExecutionType::Loop)
             {
-                while (!gotSIGINT)
+                for (size_t iteration = 1; !gotSIGINT; ++iteration)
                 {
-                    ++iteration;
                     stop_conditions.reportIterations(iteration);
                     if (stop_conditions.areFulfilled())
                         break;
diff --git a/dbms/src/Server/ReplicasStatusHandler.h b/dbms/src/Server/ReplicasStatusHandler.h
index feb6279a6d7..02759bbc8ac 100644
--- a/dbms/src/Server/ReplicasStatusHandler.h
+++ b/dbms/src/Server/ReplicasStatusHandler.h
@@ -15,7 +15,7 @@ private:
     Context & context;
 
 public:
-    ReplicasStatusHandler(Context & context_);
+    explicit ReplicasStatusHandler(Context & context_);
 
     void handleRequest(Poco::Net::HTTPServerRequest & request, Poco::Net::HTTPServerResponse & response) override;
 };
diff --git a/dbms/src/Server/RootRequestHandler.h b/dbms/src/Server/RootRequestHandler.h
index eed65485577..73261471bb1 100644
--- a/dbms/src/Server/RootRequestHandler.h
+++ b/dbms/src/Server/RootRequestHandler.h
@@ -15,7 +15,7 @@ private:
     IServer & server;
 
 public:
-    RootRequestHandler(IServer & server_) : server(server_)
+    explicit RootRequestHandler(IServer & server_) : server(server_)
     {
     }
 
diff --git a/dbms/src/Server/StatusFile.h b/dbms/src/Server/StatusFile.h
index 906a84b1d61..0dde3e3d16f 100644
--- a/dbms/src/Server/StatusFile.h
+++ b/dbms/src/Server/StatusFile.h
@@ -13,7 +13,7 @@ namespace DB
 class StatusFile : private boost::noncopyable
 {
 public:
-    StatusFile(const std::string & path_);
+    explicit StatusFile(const std::string & path_);
     ~StatusFile();
 
 private:
diff --git a/dbms/src/Server/TCPHandlerFactory.h b/dbms/src/Server/TCPHandlerFactory.h
index 3abde2ef393..1f454b35a8f 100644
--- a/dbms/src/Server/TCPHandlerFactory.h
+++ b/dbms/src/Server/TCPHandlerFactory.h
@@ -17,7 +17,7 @@ private:
     Poco::Logger * log;
 
 public:
-    TCPHandlerFactory(IServer & server_)
+    explicit TCPHandlerFactory(IServer & server_)
         : server(server_)
         , log(&Logger::get("TCPHandlerFactory"))
     {
diff --git a/dbms/src/Storages/MergeTree/MergeTreeBaseBlockInputStream.h b/dbms/src/Storages/MergeTree/MergeTreeBaseBlockInputStream.h
index ccfac96ccb2..455c0d97435 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeBaseBlockInputStream.h
+++ b/dbms/src/Storages/MergeTree/MergeTreeBaseBlockInputStream.h
@@ -72,7 +72,6 @@ protected:
     MergeTreeReaderPtr reader;
     MergeTreeReaderPtr pre_reader;
 
-    Logger * log;
     size_t max_block_size_marks;
 };
 
diff --git a/dbms/src/Storages/MergeTree/MergeTreeBlockInputStream.cpp b/dbms/src/Storages/MergeTree/MergeTreeBlockInputStream.cpp
index 8fe0dc0e6ea..29506d42e27 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeBlockInputStream.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeBlockInputStream.cpp
@@ -45,8 +45,6 @@ MergeTreeBlockInputStream::MergeTreeBlockInputStream(
     check_columns(check_columns),
     path(data_part->getFullPath())
 {
-    log = &Logger::get("MergeTreeBlockInputStream");
-
     /// Let's estimate total number of rows for progress bar.
     size_t total_rows = 0;
     for (const auto & range : all_mark_ranges)
diff --git a/dbms/src/Storages/MergeTree/MergeTreeBlockInputStream.h b/dbms/src/Storages/MergeTree/MergeTreeBlockInputStream.h
index 0df9ccde54c..6eb9c2e8577 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeBlockInputStream.h
+++ b/dbms/src/Storages/MergeTree/MergeTreeBlockInputStream.h
@@ -68,6 +68,8 @@ private:
     bool check_columns;
     String path;
     bool is_first_task = true;
+
+    Logger * log = &Logger::get("MergeTreeBlockInputStream");
 };
 
 }
diff --git a/dbms/src/Storages/MergeTree/MergeTreeThreadBlockInputStream.cpp b/dbms/src/Storages/MergeTree/MergeTreeThreadBlockInputStream.cpp
index b4df68f684a..0914f3f59f1 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeThreadBlockInputStream.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeThreadBlockInputStream.cpp
@@ -36,8 +36,6 @@ MergeTreeThreadBlockInputStream::MergeTreeThreadBlockInputStream(
     }
     else
         min_marks_to_read = min_marks_to_read_;
-
-    log = &Logger::get("MergeTreeThreadBlockInputStream");
 }
 
 
diff --git a/dbms/src/Storages/MergeTree/PKCondition.cpp b/dbms/src/Storages/MergeTree/PKCondition.cpp
index 621b322c31a..7eb95b44aab 100644
--- a/dbms/src/Storages/MergeTree/PKCondition.cpp
+++ b/dbms/src/Storages/MergeTree/PKCondition.cpp
@@ -837,9 +837,9 @@ bool PKCondition::mayBeTrueInRangeImpl(const std::vector<Range> & key_ranges, co
 
             /// The case when the column is wrapped in a chain of possibly monotonic functions.
             Range key_range_transformed;
-            bool evaluation_is_not_possible = false;
             if (!element.monotonic_functions_chain.empty())
             {
+                bool evaluation_is_not_possible = false;
                 key_range_transformed = *key_range;
                 DataTypePtr current_type = data_types[element.key_column];
                 for (auto & func : element.monotonic_functions_chain)
diff --git a/dbms/src/Storages/MergeTree/ReshardingWorker.cpp b/dbms/src/Storages/MergeTree/ReshardingWorker.cpp
index bc1f866c8b8..e0d0086c3fe 100644
--- a/dbms/src/Storages/MergeTree/ReshardingWorker.cpp
+++ b/dbms/src/Storages/MergeTree/ReshardingWorker.cpp
@@ -115,7 +115,7 @@ public:
     {
     }
 
-    Status(const std::string & str)
+    explicit Status(const std::string & str)
     {
         size_t pos = str.find(',');
         code = static_cast<ReshardingWorker::StatusCode>(std::stoull(str.substr(0, pos)));
@@ -2094,8 +2094,6 @@ ReshardingWorker::StatusCode ReshardingWorker::getStatusCommon(const std::string
 
 std::string ReshardingWorker::dumpCoordinatorState(const std::string & coordinator_id)
 {
-    std::string out;
-
     auto current_host = getFQDNOrHostName();
 
     WriteBufferFromOwnString buf;
diff --git a/dbms/src/Storages/MergeTree/SimpleMergeSelector.cpp b/dbms/src/Storages/MergeTree/SimpleMergeSelector.cpp
index 093120ff2f4..041b8431271 100644
--- a/dbms/src/Storages/MergeTree/SimpleMergeSelector.cpp
+++ b/dbms/src/Storages/MergeTree/SimpleMergeSelector.cpp
@@ -101,7 +101,7 @@ bool allow(
 //    std::cerr << "sum_size: " << sum_size << "\n";
 
     /// Map size to 0..1 using logarithmic scale
-    double size_normalized = mapPiecewiseLinearToUnit(log(1 + sum_size), log(1 + settings.min_size_to_lower_base), log(1 + settings.max_size_to_lower_base));
+    double size_normalized = mapPiecewiseLinearToUnit(log1p(sum_size), log1p(settings.min_size_to_lower_base), log1p(settings.max_size_to_lower_base));
 
 //    std::cerr << "size_normalized: " << size_normalized << "\n";
 
diff --git a/dbms/src/Storages/StorageBuffer.cpp b/dbms/src/Storages/StorageBuffer.cpp
index e8241fec0ad..1ceb2d8ac1e 100644
--- a/dbms/src/Storages/StorageBuffer.cpp
+++ b/dbms/src/Storages/StorageBuffer.cpp
@@ -210,7 +210,7 @@ static void appendBlock(const Block & from, Block & to)
 class BufferBlockOutputStream : public IBlockOutputStream
 {
 public:
-    BufferBlockOutputStream(StorageBuffer & storage_) : storage(storage_) {}
+    explicit BufferBlockOutputStream(StorageBuffer & storage_) : storage(storage_) {}
 
     void write(const Block & block) override
     {
@@ -440,67 +440,65 @@ void StorageBuffer::flushBuffer(Buffer & buffer, bool check_thresholds)
     size_t bytes = 0;
     time_t time_passed = 0;
 
+    std::lock_guard<std::mutex> lock(buffer.mutex);
+
+    block_to_write = buffer.data.cloneEmpty();
+
+    rows = buffer.data.rows();
+    bytes = buffer.data.bytes();
+    if (buffer.first_write_time)
+        time_passed = current_time - buffer.first_write_time;
+
+    if (check_thresholds)
     {
-        std::lock_guard<std::mutex> lock(buffer.mutex);
+        if (!checkThresholdsImpl(rows, bytes, time_passed))
+            return;
+    }
+    else
+    {
+        if (rows == 0)
+            return;
+    }
 
-        block_to_write = buffer.data.cloneEmpty();
+    buffer.data.swap(block_to_write);
+    buffer.first_write_time = 0;
 
-        rows = buffer.data.rows();
-        bytes = buffer.data.bytes();
-        if (buffer.first_write_time)
-            time_passed = current_time - buffer.first_write_time;
+    CurrentMetrics::sub(CurrentMetrics::StorageBufferRows, block_to_write.rows());
+    CurrentMetrics::sub(CurrentMetrics::StorageBufferBytes, block_to_write.bytes());
 
-        if (check_thresholds)
-        {
-            if (!checkThresholdsImpl(rows, bytes, time_passed))
-                return;
-        }
-        else
-        {
-            if (rows == 0)
-                return;
-        }
+    ProfileEvents::increment(ProfileEvents::StorageBufferFlush);
+
+    LOG_TRACE(log, "Flushing buffer with " << rows << " rows, " << bytes << " bytes, age " << time_passed << " seconds.");
+
+    if (no_destination)
+        return;
+
+    /** For simplicity, buffer is locked during write.
+        * We could unlock buffer temporary, but it would lead to too much difficulties:
+        * - data, that is written, will not be visible for SELECTs;
+        * - new data could be appended to buffer, and in case of exception, we must merge it with old data, that has not been written;
+        * - this could lead to infinite memory growth.
+        */
+    try
+    {
+        writeBlockToDestination(block_to_write, context.tryGetTable(destination_database, destination_table));
+    }
+    catch (...)
+    {
+        ProfileEvents::increment(ProfileEvents::StorageBufferErrorOnFlush);
+
+        /// Return the block to its place in the buffer.
+
+        CurrentMetrics::add(CurrentMetrics::StorageBufferRows, block_to_write.rows());
+        CurrentMetrics::add(CurrentMetrics::StorageBufferBytes, block_to_write.bytes());
 
         buffer.data.swap(block_to_write);
-        buffer.first_write_time = 0;
 
-        CurrentMetrics::sub(CurrentMetrics::StorageBufferRows, block_to_write.rows());
-        CurrentMetrics::sub(CurrentMetrics::StorageBufferBytes, block_to_write.bytes());
+        if (!buffer.first_write_time)
+            buffer.first_write_time = current_time;
 
-        ProfileEvents::increment(ProfileEvents::StorageBufferFlush);
-
-        LOG_TRACE(log, "Flushing buffer with " << rows << " rows, " << bytes << " bytes, age " << time_passed << " seconds.");
-
-        if (no_destination)
-            return;
-
-        /** For simplicity, buffer is locked during write.
-          * We could unlock buffer temporary, but it would lead to too much difficulties:
-          * - data, that is written, will not be visible for SELECTs;
-          * - new data could be appended to buffer, and in case of exception, we must merge it with old data, that has not been written;
-          * - this could lead to infinite memory growth.
-          */
-        try
-        {
-            writeBlockToDestination(block_to_write, context.tryGetTable(destination_database, destination_table));
-        }
-        catch (...)
-        {
-            ProfileEvents::increment(ProfileEvents::StorageBufferErrorOnFlush);
-
-            /// Return the block to its place in the buffer.
-
-            CurrentMetrics::add(CurrentMetrics::StorageBufferRows, block_to_write.rows());
-            CurrentMetrics::add(CurrentMetrics::StorageBufferBytes, block_to_write.bytes());
-
-            buffer.data.swap(block_to_write);
-
-            if (!buffer.first_write_time)
-                buffer.first_write_time = current_time;
-
-            /// After a while, the next write attempt will happen.
-            throw;
-        }
+        /// After a while, the next write attempt will happen.
+        throw;
     }
 }
 
diff --git a/dbms/src/Storages/StorageCloud.cpp b/dbms/src/Storages/StorageCloud.cpp
index ee926e81659..41daff34dda 100644
--- a/dbms/src/Storages/StorageCloud.cpp
+++ b/dbms/src/Storages/StorageCloud.cpp
@@ -26,6 +26,8 @@ StorageCloud::StorageCloud(
         throw Exception("DatabaseCloud is detached", ErrorCodes::LOGICAL_ERROR);
 
     DatabaseCloud & db = static_cast<DatabaseCloud &>(*owned_db);
+
+    /// This code is unfinished.
 }
 
 }
diff --git a/dbms/src/Storages/StorageFile.cpp b/dbms/src/Storages/StorageFile.cpp
index 5a8c1e94f1e..febd73f83e9 100644
--- a/dbms/src/Storages/StorageFile.cpp
+++ b/dbms/src/Storages/StorageFile.cpp
@@ -180,7 +180,7 @@ class StorageFileBlockOutputStream : public IBlockOutputStream
 {
 public:
 
-    StorageFileBlockOutputStream(StorageFile & storage_)
+    explicit StorageFileBlockOutputStream(StorageFile & storage_)
         : storage(storage_), lock(storage.rwlock)
     {
         if (storage.use_table_fd)
diff --git a/dbms/src/Storages/StorageLog.cpp b/dbms/src/Storages/StorageLog.cpp
index 2bcdc6e1a57..9ea51f86f31 100644
--- a/dbms/src/Storages/StorageLog.cpp
+++ b/dbms/src/Storages/StorageLog.cpp
@@ -133,7 +133,7 @@ private:
 class LogBlockOutputStream : public IBlockOutputStream
 {
 public:
-    LogBlockOutputStream(StorageLog & storage_)
+    explicit LogBlockOutputStream(StorageLog & storage_)
         : storage(storage_),
         lock(storage.rwlock),
         marks_stream(storage.marks_file.path(), 4096, O_APPEND | O_CREAT | O_WRONLY),
diff --git a/dbms/src/Storages/StorageMemory.cpp b/dbms/src/Storages/StorageMemory.cpp
index abd45d365c9..e3b3d53d6f8 100644
--- a/dbms/src/Storages/StorageMemory.cpp
+++ b/dbms/src/Storages/StorageMemory.cpp
@@ -61,7 +61,7 @@ private:
 class MemoryBlockOutputStream : public IBlockOutputStream
 {
 public:
-    MemoryBlockOutputStream(StorageMemory & storage_) : storage(storage_) {}
+    explicit MemoryBlockOutputStream(StorageMemory & storage_) : storage(storage_) {}
 
     void write(const Block & block) override
     {
diff --git a/dbms/src/Storages/StorageReplicatedMergeTree.cpp b/dbms/src/Storages/StorageReplicatedMergeTree.cpp
index a35052db311..38100cd0bd5 100644
--- a/dbms/src/Storages/StorageReplicatedMergeTree.cpp
+++ b/dbms/src/Storages/StorageReplicatedMergeTree.cpp
@@ -380,7 +380,7 @@ namespace
     {
         const MergeTreeData & data;
 
-        TableMetadata(const MergeTreeData & data_)
+        explicit TableMetadata(const MergeTreeData & data_)
             : data(data_) {}
 
         void write(WriteBuffer & out) const
diff --git a/dbms/src/Storages/StorageStripeLog.cpp b/dbms/src/Storages/StorageStripeLog.cpp
index fc7fe894b71..d7e4cc7fff5 100644
--- a/dbms/src/Storages/StorageStripeLog.cpp
+++ b/dbms/src/Storages/StorageStripeLog.cpp
@@ -114,7 +114,7 @@ private:
 class StripeLogBlockOutputStream : public IBlockOutputStream
 {
 public:
-    StripeLogBlockOutputStream(StorageStripeLog & storage_)
+    explicit StripeLogBlockOutputStream(StorageStripeLog & storage_)
         : storage(storage_), lock(storage.rwlock),
         data_out_compressed(storage.full_path() + "data.bin", DBMS_DEFAULT_BUFFER_SIZE, O_WRONLY | O_APPEND | O_CREAT),
         data_out(data_out_compressed, CompressionMethod::LZ4, storage.max_compress_block_size),
diff --git a/dbms/src/Storages/StorageTinyLog.cpp b/dbms/src/Storages/StorageTinyLog.cpp
index 484fe417d30..9435d45094c 100644
--- a/dbms/src/Storages/StorageTinyLog.cpp
+++ b/dbms/src/Storages/StorageTinyLog.cpp
@@ -96,7 +96,7 @@ private:
 class TinyLogBlockOutputStream : public IBlockOutputStream
 {
 public:
-    TinyLogBlockOutputStream(StorageTinyLog & storage_)
+    explicit TinyLogBlockOutputStream(StorageTinyLog & storage_)
         : storage(storage_)
     {
         for (const auto & col : storage.getColumnsList())
diff --git a/dbms/src/Storages/StorageTrivialBuffer.cpp b/dbms/src/Storages/StorageTrivialBuffer.cpp
index 9dafe302766..06e693b3494 100644
--- a/dbms/src/Storages/StorageTrivialBuffer.cpp
+++ b/dbms/src/Storages/StorageTrivialBuffer.cpp
@@ -279,7 +279,7 @@ void StorageTrivialBuffer::flush(bool check_thresholds, bool is_called_from_back
 class TrivialBufferBlockOutputStream : public IBlockOutputStream
 {
 public:
-    TrivialBufferBlockOutputStream(StorageTrivialBuffer & buffer_) : buffer(buffer_) {}
+    explicit TrivialBufferBlockOutputStream(StorageTrivialBuffer & buffer_) : buffer(buffer_) {}
     void write(const Block & block) override
     {
         if (!block)
diff --git a/dbms/tests/external_dictionaries/dictionary_library/dictionary_library.cpp b/dbms/tests/external_dictionaries/dictionary_library/dictionary_library.cpp
index d96e73b53f2..fa2c333766f 100644
--- a/dbms/tests/external_dictionaries/dictionary_library/dictionary_library.cpp
+++ b/dbms/tests/external_dictionaries/dictionary_library/dictionary_library.cpp
@@ -23,7 +23,10 @@ void * ClickHouseDictionary_v1_loadIds(
     void * data_ptr, ClickHouseLibrary::CStrings * settings, ClickHouseLibrary::CStrings * columns, const struct ClickHouseLibrary::VectorUInt64 * ids)
 {
     auto ptr = static_cast<DataHolder *>(data_ptr);
-    std::cerr << "loadIds lib call ptr=" << data_ptr << " => " << ptr << " size=" << ids->size << "\n";
+
+    if (ids)
+        std::cerr << "loadIds lib call ptr=" << data_ptr << " => " << ptr << " size=" << ids->size << "\n";
+
     if (settings)
     {
         std::cerr << "settings passed: " << settings->size << "\n";
diff --git a/libs/libdaemon/src/BaseDaemon.cpp b/libs/libdaemon/src/BaseDaemon.cpp
index 56bb0826479..375f8dfa9cb 100644
--- a/libs/libdaemon/src/BaseDaemon.cpp
+++ b/libs/libdaemon/src/BaseDaemon.cpp
@@ -223,9 +223,9 @@ public:
         StopThread = -2
     };
 
-    SignalListener(BaseDaemon & daemon_)
-    : log(&Logger::get("BaseDaemon"))
-    , daemon(daemon_)
+    explicit SignalListener(BaseDaemon & daemon_)
+        : log(&Logger::get("BaseDaemon"))
+        , daemon(daemon_)
     {
     }
 
@@ -400,7 +400,7 @@ static void terminate_handler()
     if (terminating)
     {
         abort();
-        return;
+        return; /// Just for convenience.
     }
 
     terminating = true;
diff --git a/libs/libmysqlxx/src/Pool.cpp b/libs/libmysqlxx/src/Pool.cpp
index a5683659a32..b2217caf6fa 100644
--- a/libs/libmysqlxx/src/Pool.cpp
+++ b/libs/libmysqlxx/src/Pool.cpp
@@ -85,8 +85,8 @@ Pool::~Pool()
 {
     std::lock_guard<std::mutex> lock(mutex);
 
-    for (Connections::iterator it = connections.begin(); it != connections.end(); it++)
-        delete static_cast<Connection *>(*it);
+    for (auto & connection : connections)
+        delete static_cast<Connection *>(connection);
 }
 
 
@@ -97,10 +97,10 @@ Pool::Entry Pool::Get()
     initialize();
     for (;;)
     {
-        for (Connections::iterator it = connections.begin(); it != connections.end(); it++)
+        for (auto & connection : connections)
         {
-            if ((*it)->ref_count == 0)
-                return Entry(*it, this);
+            if (connection->ref_count == 0)
+                return Entry(connection, this);
         }
 
         if (connections.size() < static_cast<size_t>(max_connections))
@@ -124,11 +124,11 @@ Pool::Entry Pool::tryGet()
     initialize();
 
     /// Searching for connection which was established but wasn't used.
-    for (Connections::iterator it = connections.begin(); it != connections.end(); ++it)
+    for (auto & connection : connections)
     {
-        if ((*it)->ref_count == 0)
+        if (connection->ref_count == 0)
         {
-            Entry res(*it, this);
+            Entry res(connection, this);
             return res.tryForceConnected() ? res : Entry();
         }
     }
diff --git a/utils/iotest/iotest.cpp b/utils/iotest/iotest.cpp
index bc6f2eae67a..eb5999d02a9 100644
--- a/utils/iotest/iotest.cpp
+++ b/utils/iotest/iotest.cpp
@@ -17,6 +17,8 @@
 #include <common/ThreadPool.h>
 #include <Common/Stopwatch.h>
 
+#include <IO/BufferWithOwnMemory.h>
+
 #include <cstdlib>
 
 #ifdef __APPLE__
@@ -37,29 +39,9 @@ enum Mode
 };
 
 
-struct AlignedBuffer
-{
-    int size;
-    char * data;
-
-    AlignedBuffer(int size_)
-    {
-        size_t page = sysconf(_SC_PAGESIZE);
-        size = size_;
-        int rc = posix_memalign(reinterpret_cast<void **>(&data), page, (size + page - 1) / page * page);
-        if (data == nullptr || rc != 0)
-            throwFromErrno("memalign failed");
-    }
-
-    ~AlignedBuffer()
-    {
-        free(data);
-    }
-};
-
 void thread(int fd, int mode, size_t min_offset, size_t max_offset, size_t block_size, size_t count)
 {
-    AlignedBuffer direct_buf(block_size);
+    DB::Memory direct_buf(block_size, sysconf(_SC_PAGESIZE));
     std::vector<char> simple_buf(block_size);
 
     char * buf;
diff --git a/utils/iotest/iotest_aio.cpp b/utils/iotest/iotest_aio.cpp
index ecc4b04b172..eba52895b16 100644
--- a/utils/iotest/iotest_aio.cpp
+++ b/utils/iotest/iotest_aio.cpp
@@ -16,6 +16,8 @@
 #include <common/ThreadPool.h>
 #include <Common/Stopwatch.h>
 
+#include <IO/BufferWithOwnMemory.h>
+
 #include <stdlib.h>
 #if !defined(__APPLE__) && !defined(__FreeBSD__)
 #include <malloc.h>
@@ -61,42 +63,6 @@ enum Mode
 };
 
 
-struct AlignedBuffer
-{
-    int size = 0;
-    char * data = nullptr;
-
-    AlignedBuffer() {}
-
-    void init(int size_)
-    {
-        uninit();
-        size_t page = sysconf(_SC_PAGESIZE);
-        size = size_;
-        data = static_cast<char*>(memalign(page, (size + page - 1) / page * page));
-        if (!data)
-            throwFromErrno("memalign failed");
-    }
-
-    void uninit()
-    {
-        if (data)
-            free(data);
-        data = nullptr;
-        size = 0;
-    }
-
-    AlignedBuffer(int size_) : size(0), data(NULL)
-    {
-        init(size_);
-    }
-
-    ~AlignedBuffer()
-    {
-        uninit();
-    }
-};
-
 struct AioContext
 {
     aio_context_t ctx;
@@ -119,11 +85,9 @@ void thread(int fd, int mode, size_t min_offset, size_t max_offset, size_t block
 {
     AioContext ctx;
 
-    std::vector<AlignedBuffer> buffers(buffers_count);
+    std::vector<DB::Memory> buffers(buffers_count);
     for (size_t i = 0; i < buffers_count; ++i)
-    {
-        buffers[i].init(block_size);
-    }
+        buffers[i] = DB::Memory(block_size, sysconf(_SC_PAGESIZE));
 
     drand48_data rand_data;
     timespec times;
diff --git a/utils/test-data-generator/MarkovModel.h b/utils/test-data-generator/MarkovModel.h
index fcd2d9bd308..19bde2cb31d 100644
--- a/utils/test-data-generator/MarkovModel.h
+++ b/utils/test-data-generator/MarkovModel.h
@@ -74,7 +74,7 @@ private:
     }
 
 public:
-    MarkovModel(size_t n_) : n(n_) {}
+    explicit MarkovModel(size_t n_) : n(n_) {}
     MarkovModel() {}
 
     void consume(const char * data, size_t size)

From 9befe805e237738b371e27959791e767a7753b67 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 00:09:58 +0300
Subject: [PATCH 121/266] Added instruction for cppcheck usage
 [#CLICKHOUSE-3300].

---
 dbms/tests/instructions/cppcheck.txt | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 dbms/tests/instructions/cppcheck.txt

diff --git a/dbms/tests/instructions/cppcheck.txt b/dbms/tests/instructions/cppcheck.txt
new file mode 100644
index 00000000000..af985624b13
--- /dev/null
+++ b/dbms/tests/instructions/cppcheck.txt
@@ -0,0 +1,17 @@
+# Install cppcheck
+
+mkdir cppcheck && cd cppcheck
+git clone git@github.com:danmar/cppcheck.git .
+mkdir build && cd build
+CC=gcc-7 CXX=g++-7 cmake -D CMAKE_BUILD_TYPE=Release ..
+make -j24
+sudo make install
+
+# Perform analysis
+# cd ClickHouse_clean
+
+cppcheck -j24 -i contrib -i build --enable=all . 2> cppcheck-errors.txt
+
+# Check is pretty fast.
+# It doesn't understand atomics, lambdas, std::rethrow_exception, macros, it have poor logic inference.
+# But the result is worth looking and at least few real errors found.

From 3de701850c6b25d27827ccdc46bdde2c8ad3277b Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 00:13:30 +0300
Subject: [PATCH 122/266] Added instruction for Coverity usage
 [#CLICKHOUSE-3285].

---
 dbms/tests/instructions/coverity.txt | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 dbms/tests/instructions/coverity.txt

diff --git a/dbms/tests/instructions/coverity.txt b/dbms/tests/instructions/coverity.txt
new file mode 100644
index 00000000000..59d94a9e54d
--- /dev/null
+++ b/dbms/tests/instructions/coverity.txt
@@ -0,0 +1,28 @@
+# Download tool at https://scan.coverity.com/download?tab=cxx
+
+tar xf cov-analysis-linux64-2017.07.tar.gz
+export PATH=$PATH:/home/milovidov/cov-analysis-linux64-2017.07/bin
+
+mkdir ClickHouse_coverity
+cd ClickHouse_coverity
+git clone git@github.com:yandex/ClickHouse.git .
+
+mkdir build
+cd build
+
+# "Debug" is for faster build
+CC=gcc-7 CXX=g++-7 cmake -D CMAKE_BUILD_TYPE=Debug -D CCACHE_FOUND=0 ..
+
+# Build all targets that we don't want to analyze.
+cd contrib && make -j24 && cd ..
+
+cov-configure --comptype gcc --compiler gcc-7 --template
+
+cov-build --dir cov-int make -j24
+
+# Build is painful slow. Some targets compile in about one hour. Total time is about 4..5 hours.
+
+tar czvf clickhouse.tgz cov-int
+
+# tarball is 1.2 GB.
+# Upload result at https://scan.coverity.com/projects/yandex-clickhouse/builds/new

From 79f65f4fd53117ff2a1fef8ec88b4c68a2a74673 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 00:19:43 +0300
Subject: [PATCH 123/266] Addition to prev. revision [#CLICKHOUSE-3300].

---
 utils/iotest/iotest.cpp     | 2 +-
 utils/iotest/iotest_aio.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/utils/iotest/iotest.cpp b/utils/iotest/iotest.cpp
index eb5999d02a9..2c91e11cd41 100644
--- a/utils/iotest/iotest.cpp
+++ b/utils/iotest/iotest.cpp
@@ -46,7 +46,7 @@ void thread(int fd, int mode, size_t min_offset, size_t max_offset, size_t block
 
     char * buf;
     if ((mode & MODE_DIRECT))
-        buf = direct_buf.data;
+        buf = direct_buf.data();
     else
         buf = &simple_buf[0];
 
diff --git a/utils/iotest/iotest_aio.cpp b/utils/iotest/iotest_aio.cpp
index eba52895b16..f23ce99dcf6 100644
--- a/utils/iotest/iotest_aio.cpp
+++ b/utils/iotest/iotest_aio.cpp
@@ -117,7 +117,7 @@ void thread(int fd, int mode, size_t min_offset, size_t max_offset, size_t block
             ++blocks_sent;
             ++in_progress;
 
-            char * buf = buffers[i].data;
+            char * buf = buffers[i].data();
 
             long rand_result1 = 0;
             long rand_result2 = 0;

From 6307661c35d3b722e72a0bde7b75004f303309c3 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 00:26:25 +0300
Subject: [PATCH 124/266] Addition to prev. revision [#CLICKHOUSE-3300].

---
 dbms/src/Parsers/TokenIterator.h                  | 2 +-
 dbms/src/Storages/MergeTree/LevelMergeSelector.h  | 2 +-
 dbms/src/Storages/MergeTree/SimpleMergeSelector.h | 2 +-
 dbms/tests/instructions/cppcheck.txt              | 8 +++++---
 libs/libcommon/include/common/ThreadPool.h        | 2 +-
 5 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/dbms/src/Parsers/TokenIterator.h b/dbms/src/Parsers/TokenIterator.h
index 642721eb37a..71d2edfef42 100644
--- a/dbms/src/Parsers/TokenIterator.h
+++ b/dbms/src/Parsers/TokenIterator.h
@@ -57,7 +57,7 @@ private:
     size_t index = 0;
 
 public:
-    TokenIterator(Tokens & tokens) : tokens(&tokens) {}
+    explicit TokenIterator(Tokens & tokens) : tokens(&tokens) {}
 
     const Token & get() { return (*tokens)[index]; }
     const Token & operator*() { return get(); }
diff --git a/dbms/src/Storages/MergeTree/LevelMergeSelector.h b/dbms/src/Storages/MergeTree/LevelMergeSelector.h
index d524ac6d5f2..fa35500dcae 100644
--- a/dbms/src/Storages/MergeTree/LevelMergeSelector.h
+++ b/dbms/src/Storages/MergeTree/LevelMergeSelector.h
@@ -17,7 +17,7 @@ public:
         size_t parts_to_merge = 10;
     };
 
-    LevelMergeSelector(const Settings & settings) : settings(settings) {}
+    explicit LevelMergeSelector(const Settings & settings) : settings(settings) {}
 
     PartsInPartition select(
         const Partitions & partitions,
diff --git a/dbms/src/Storages/MergeTree/SimpleMergeSelector.h b/dbms/src/Storages/MergeTree/SimpleMergeSelector.h
index 17eb0aa2839..28918f072ed 100644
--- a/dbms/src/Storages/MergeTree/SimpleMergeSelector.h
+++ b/dbms/src/Storages/MergeTree/SimpleMergeSelector.h
@@ -71,7 +71,7 @@ public:
         double heuristic_to_remove_small_parts_at_right_max_ratio = 0.01;
     };
 
-    SimpleMergeSelector(const Settings & settings) : settings(settings) {}
+    explicit SimpleMergeSelector(const Settings & settings) : settings(settings) {}
 
     PartsInPartition select(
         const Partitions & partitions,
diff --git a/dbms/tests/instructions/cppcheck.txt b/dbms/tests/instructions/cppcheck.txt
index af985624b13..5cad3b245a8 100644
--- a/dbms/tests/instructions/cppcheck.txt
+++ b/dbms/tests/instructions/cppcheck.txt
@@ -8,10 +8,12 @@ make -j24
 sudo make install
 
 # Perform analysis
-# cd ClickHouse_clean
+# cd ClickHouse_clean/build
 
-cppcheck -j24 -i contrib -i build --enable=all . 2> cppcheck-errors.txt
+cppcheck -j24 --project=compile_commands.json --enable=all 2> cppcheck-errors.txt
 
 # Check is pretty fast.
-# It doesn't understand atomics, lambdas, std::rethrow_exception, macros, it have poor logic inference.
+# It gives many false positives.
 # But the result is worth looking and at least few real errors found.
+
+grep -v -F 'contrib/' cppcheck-errors.txt
diff --git a/libs/libcommon/include/common/ThreadPool.h b/libs/libcommon/include/common/ThreadPool.h
index 7e20294ec08..15952042a04 100644
--- a/libs/libcommon/include/common/ThreadPool.h
+++ b/libs/libcommon/include/common/ThreadPool.h
@@ -20,7 +20,7 @@ public:
     using Job = std::function<void()>;
 
     /// Size is constant, all threads are created immediately.
-    ThreadPool(size_t m_size);
+    explicit ThreadPool(size_t m_size);
 
     /// Add new job. Locks until free thread in pool become available or exception in one of threads was thrown.
     /// If an exception in some thread was thrown, method silently returns, and exception will be rethrown only on call to 'wait' function.

From 742f369ac8ef1e7a9dc7a8766adfc0a9b70985e9 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 00:35:21 +0300
Subject: [PATCH 125/266] Addition to prev. revision [#CLICKHOUSE-3300].

---
 dbms/tests/instructions/cppcheck.txt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/dbms/tests/instructions/cppcheck.txt b/dbms/tests/instructions/cppcheck.txt
index 5cad3b245a8..6d370a57ec3 100644
--- a/dbms/tests/instructions/cppcheck.txt
+++ b/dbms/tests/instructions/cppcheck.txt
@@ -11,6 +11,8 @@ sudo make install
 # cd ClickHouse_clean/build
 
 cppcheck -j24 --project=compile_commands.json --enable=all 2> cppcheck-errors.txt
+# or
+# cppcheck -j24 -i contrib -i build --enable=all . 2> cppcheck-errors.txt
 
 # Check is pretty fast.
 # It gives many false positives.

From 5a87ebf262f6157d193df5379145ecf16de67108 Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Thu, 7 Sep 2017 22:19:32 +0300
Subject: [PATCH 126/266] Try fix macos build

---
 dbms/src/Dictionaries/LibraryDictionarySource.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbms/src/Dictionaries/LibraryDictionarySource.cpp b/dbms/src/Dictionaries/LibraryDictionarySource.cpp
index 3b8d35dfc93..b600715f4a0 100644
--- a/dbms/src/Dictionaries/LibraryDictionarySource.cpp
+++ b/dbms/src/Dictionaries/LibraryDictionarySource.cpp
@@ -155,7 +155,7 @@ BlockInputStreamPtr LibraryDictionarySource::loadIds(const std::vector<UInt64> &
 {
     LOG_TRACE(log, "loadIds " << toString() << " size = " << ids.size());
 
-    const ClickHouseLibrary::VectorUInt64 ids_data{ids.data(), ids.size()};
+    const ClickHouseLibrary::VectorUInt64 ids_data{static_cast<decltype(ClickHouseLibrary::VectorUInt64::data)>(ids.data()), ids.size()};
     auto columns_holder = std::make_unique<ClickHouseLibrary::CString[]>(dict_struct.attributes.size());
     ClickHouseLibrary::CStrings columns_pass{
         static_cast<decltype(ClickHouseLibrary::CStrings::data)>(columns_holder.get()), dict_struct.attributes.size()};

From 1cd09ac12faed4caee2a781a43edfd2a79d49112 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 03:25:25 +0300
Subject: [PATCH 127/266] Updated script to build latest clang [#CLICKHOUSE-2].

---
 utils/prepare-environment/install-clang.sh | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/utils/prepare-environment/install-clang.sh b/utils/prepare-environment/install-clang.sh
index 0adc70c139b..d1ca427ad4e 100755
--- a/utils/prepare-environment/install-clang.sh
+++ b/utils/prepare-environment/install-clang.sh
@@ -14,9 +14,15 @@ cd llvm
 svn co "http://llvm.org/svn/llvm-project/llvm/${BRANCH}" llvm
 cd llvm/tools
 svn co "http://llvm.org/svn/llvm-project/cfe/${BRANCH}" clang
-cd ..
-cd projects/
+svn co "http://llvm.org/svn/llvm-project/lld/${BRANCH}" lld
+svn co "http://llvm.org/svn/llvm-project/polly/${BRANCH}" polly
+cd clang/tools
+svn co "http://llvm.org/svn/llvm-project/clang-tools-extra/${BRANCH}" extra
+cd ../../../..
+cd llvm/projects/
 svn co "http://llvm.org/svn/llvm-project/compiler-rt/${BRANCH}" compiler-rt
+svn co "http://llvm.org/svn/llvm-project/libcxx/${BRANCH}" libcxx
+svn co "http://llvm.org/svn/llvm-project/libcxxabi/${BRANCH}" libcxxabi
 cd ../..
 mkdir build
 cd build/

From e9ae1938706c8c6e4aab478c0356b1dcf4d300e9 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 05:29:47 +0300
Subject: [PATCH 128/266] Implemented some suggestions from clang-tidy (part 1)
 [#CLICKHOUSE-3301].

---
 dbms/src/Common/Exception.h                   |  2 +-
 dbms/src/Core/ColumnWithTypeAndName.h         |  4 ++--
 dbms/src/Core/SortDescription.h               | 14 ++++++-------
 .../DataStreams/AggregatingBlockInputStream.h |  4 ++--
 .../AsynchronousBlockInputStream.h            |  4 ++--
 .../DataStreams/BlockExtraInfoInputStream.h   |  4 ++--
 .../DataStreams/DistinctBlockInputStream.cpp  |  4 ++--
 .../DataStreams/DistinctBlockInputStream.h    |  2 +-
 .../DistinctSortedBlockInputStream.cpp        |  6 +++---
 .../DistinctSortedBlockInputStream.h          |  4 ++--
 .../ExpressionBlockInputStream.cpp            |  4 ++--
 .../DataStreams/ExpressionBlockInputStream.h  |  2 +-
 .../DataStreams/FilterBlockInputStream.cpp    |  8 ++++----
 dbms/src/DataStreams/FilterBlockInputStream.h |  4 ++--
 dbms/src/DataStreams/ForkBlockInputStreams.h  |  2 +-
 .../src/DataStreams/LimitBlockInputStream.cpp |  4 ++--
 dbms/src/DataStreams/LimitBlockInputStream.h  |  2 +-
 .../DataStreams/LimitByBlockInputStream.cpp   |  4 ++--
 .../src/DataStreams/LimitByBlockInputStream.h |  2 +-
 .../MaterializingBlockInputStream.cpp         |  4 ++--
 .../MaterializingBlockInputStream.h           |  2 +-
 .../MergeSortingBlockInputStream.h            |  4 ++--
 .../MergingAggregatedBlockInputStream.h       |  4 ++--
 .../NullAndDoCopyBlockInputStream.h           |  2 +-
 .../NullableAdapterBlockInputStream.cpp       |  4 ++--
 .../NullableAdapterBlockInputStream.h         |  2 +-
 .../ParallelAggregatingBlockInputStream.cpp   |  2 +-
 .../ParallelAggregatingBlockInputStream.h     |  2 +-
 .../src/DataStreams/ParallelInputsProcessor.h |  4 ++--
 .../PartialSortingBlockInputStream.h          |  2 +-
 dbms/src/DataStreams/tests/glue_streams.cpp   |  2 +-
 dbms/src/IO/WriteHelpers.h                    |  8 ++++----
 dbms/src/Interpreters/Aggregator.cpp          |  4 ++--
 dbms/src/Interpreters/Aggregator.h            |  4 ++--
 .../Interpreters/InterpreterSelectQuery.cpp   | 20 +++++++++----------
 .../src/Interpreters/InterpreterSelectQuery.h |  4 ++--
 dbms/src/Interpreters/SettingsCommon.h        |  4 ++--
 libs/libmysqlxx/include/mysqlxx/Connection.h  |  6 +++---
 libs/libmysqlxx/include/mysqlxx/Manip.h       |  8 ++++----
 39 files changed, 86 insertions(+), 86 deletions(-)

diff --git a/dbms/src/Common/Exception.h b/dbms/src/Common/Exception.h
index a978ba4a303..756434a73ef 100644
--- a/dbms/src/Common/Exception.h
+++ b/dbms/src/Common/Exception.h
@@ -116,7 +116,7 @@ typename std::enable_if<std::is_pointer<T>::value, T>::type exception_cast(std::
 {
     try
     {
-        std::rethrow_exception(e);
+        std::rethrow_exception(std::move(e));
     }
     catch (typename std::remove_pointer<T>::type & concrete)
     {
diff --git a/dbms/src/Core/ColumnWithTypeAndName.h b/dbms/src/Core/ColumnWithTypeAndName.h
index 09da42ccf30..edf61430abf 100644
--- a/dbms/src/Core/ColumnWithTypeAndName.h
+++ b/dbms/src/Core/ColumnWithTypeAndName.h
@@ -19,11 +19,11 @@ struct ColumnWithTypeAndName
     String name;
 
     ColumnWithTypeAndName() {}
-    ColumnWithTypeAndName(const ColumnPtr & column_, const DataTypePtr & type_, const String name_)
+    ColumnWithTypeAndName(const ColumnPtr & column_, const DataTypePtr & type_, const String & name_)
         : column(column_), type(type_), name(name_) {}
 
     /// Uses type->createColumn() to create column
-    ColumnWithTypeAndName(const DataTypePtr & type_, const String name_)
+    ColumnWithTypeAndName(const DataTypePtr & type_, const String & name_)
         : column(type_->createColumn()), type(type_), name(name_) {}
 
     ColumnWithTypeAndName cloneEmpty() const;
diff --git a/dbms/src/Core/SortDescription.h b/dbms/src/Core/SortDescription.h
index 70069b4beb9..3c757cc8c21 100644
--- a/dbms/src/Core/SortDescription.h
+++ b/dbms/src/Core/SortDescription.h
@@ -14,17 +14,17 @@ namespace DB
 /// Description of the sorting rule by one column.
 struct SortColumnDescription
 {
-    std::string column_name;                        /// The name of the column.
-    size_t column_number;                    /// Column number (used if no name is given).
-    int direction;                            /// 1 - ascending, -1 - descending.
-    int nulls_direction;                    /// 1 - NULLs and NaNs are greater, -1 - less.
-                                            /// To achieve NULLS LAST, set it equal to direction, to achieve NULLS FIRST, set it opposite.
-    std::shared_ptr<Collator> collator;        /// Collator for locale-specific comparison of strings
+    std::string column_name; /// The name of the column.
+    size_t column_number;    /// Column number (used if no name is given).
+    int direction;           /// 1 - ascending, -1 - descending.
+    int nulls_direction;     /// 1 - NULLs and NaNs are greater, -1 - less.
+                             /// To achieve NULLS LAST, set it equal to direction, to achieve NULLS FIRST, set it opposite.
+    std::shared_ptr<Collator> collator; /// Collator for locale-specific comparison of strings
 
     SortColumnDescription(size_t column_number_, int direction_, int nulls_direction_, const std::shared_ptr<Collator> & collator_ = nullptr)
         : column_number(column_number_), direction(direction_), nulls_direction(nulls_direction_), collator(collator_) {}
 
-    SortColumnDescription(std::string column_name_, int direction_, int nulls_direction_, const std::shared_ptr<Collator> & collator_ = nullptr)
+    SortColumnDescription(const std::string & column_name_, int direction_, int nulls_direction_, const std::shared_ptr<Collator> & collator_ = nullptr)
         : column_name(column_name_), column_number(0), direction(direction_), nulls_direction(nulls_direction_), collator(collator_) {}
 
     /// For IBlockInputStream.
diff --git a/dbms/src/DataStreams/AggregatingBlockInputStream.h b/dbms/src/DataStreams/AggregatingBlockInputStream.h
index 8bc92c3c3ec..ea93188afba 100644
--- a/dbms/src/DataStreams/AggregatingBlockInputStream.h
+++ b/dbms/src/DataStreams/AggregatingBlockInputStream.h
@@ -22,10 +22,10 @@ public:
       * Aggregate functions are searched everywhere in the expression.
       * Columns corresponding to keys and arguments of aggregate functions must already be computed.
       */
-    AggregatingBlockInputStream(BlockInputStreamPtr input_, const Aggregator::Params & params_, bool final_)
+    AggregatingBlockInputStream(const BlockInputStreamPtr & input, const Aggregator::Params & params_, bool final_)
         : params(params_), aggregator(params), final(final_)
     {
-        children.push_back(input_);
+        children.push_back(input);
     }
 
     String getName() const override { return "Aggregating"; }
diff --git a/dbms/src/DataStreams/AsynchronousBlockInputStream.h b/dbms/src/DataStreams/AsynchronousBlockInputStream.h
index c14cb5bbd90..4ee17c2d30f 100644
--- a/dbms/src/DataStreams/AsynchronousBlockInputStream.h
+++ b/dbms/src/DataStreams/AsynchronousBlockInputStream.h
@@ -28,9 +28,9 @@ namespace DB
 class AsynchronousBlockInputStream : public IProfilingBlockInputStream
 {
 public:
-    AsynchronousBlockInputStream(BlockInputStreamPtr in_)
+    AsynchronousBlockInputStream(const BlockInputStreamPtr & in)
     {
-        children.push_back(in_);
+        children.push_back(in);
     }
 
     String getName() const override { return "Asynchronous"; }
diff --git a/dbms/src/DataStreams/BlockExtraInfoInputStream.h b/dbms/src/DataStreams/BlockExtraInfoInputStream.h
index fb3c7e03817..c1a6d77874b 100644
--- a/dbms/src/DataStreams/BlockExtraInfoInputStream.h
+++ b/dbms/src/DataStreams/BlockExtraInfoInputStream.h
@@ -11,10 +11,10 @@ namespace DB
 class BlockExtraInfoInputStream : public IProfilingBlockInputStream
 {
 public:
-    BlockExtraInfoInputStream(BlockInputStreamPtr input_, const BlockExtraInfo & block_extra_info_)
+    BlockExtraInfoInputStream(const BlockInputStreamPtr & input, const BlockExtraInfo & block_extra_info_)
         : block_extra_info(block_extra_info_)
     {
-        children.push_back(input_);
+        children.push_back(input);
     }
 
     BlockExtraInfo getBlockExtraInfo() const override
diff --git a/dbms/src/DataStreams/DistinctBlockInputStream.cpp b/dbms/src/DataStreams/DistinctBlockInputStream.cpp
index f27c1ee0f62..d308eb9f17b 100644
--- a/dbms/src/DataStreams/DistinctBlockInputStream.cpp
+++ b/dbms/src/DataStreams/DistinctBlockInputStream.cpp
@@ -8,14 +8,14 @@ namespace ErrorCodes
     extern const int SET_SIZE_LIMIT_EXCEEDED;
 }
 
-DistinctBlockInputStream::DistinctBlockInputStream(BlockInputStreamPtr input_, const Limits & limits, size_t limit_hint_, Names columns_)
+DistinctBlockInputStream::DistinctBlockInputStream(const BlockInputStreamPtr & input, const Limits & limits, size_t limit_hint_, Names columns_)
     : columns_names(columns_)
     , limit_hint(limit_hint_)
     , max_rows(limits.max_rows_in_distinct)
     , max_bytes(limits.max_bytes_in_distinct)
     , overflow_mode(limits.distinct_overflow_mode)
 {
-    children.push_back(input_);
+    children.push_back(input);
 }
 
 String DistinctBlockInputStream::getID() const
diff --git a/dbms/src/DataStreams/DistinctBlockInputStream.h b/dbms/src/DataStreams/DistinctBlockInputStream.h
index 41a9e7a2087..7120d3e04a9 100644
--- a/dbms/src/DataStreams/DistinctBlockInputStream.h
+++ b/dbms/src/DataStreams/DistinctBlockInputStream.h
@@ -18,7 +18,7 @@ class DistinctBlockInputStream : public IProfilingBlockInputStream
 {
 public:
     /// Empty columns_ means all collumns.
-    DistinctBlockInputStream(BlockInputStreamPtr input_, const Limits & limits, size_t limit_hint_, Names columns_);
+    DistinctBlockInputStream(const BlockInputStreamPtr & input, const Limits & limits, size_t limit_hint_, Names columns_);
 
     String getName() const override { return "Distinct"; }
 
diff --git a/dbms/src/DataStreams/DistinctSortedBlockInputStream.cpp b/dbms/src/DataStreams/DistinctSortedBlockInputStream.cpp
index 1dc33a78eab..2c8ab1e1d8e 100644
--- a/dbms/src/DataStreams/DistinctSortedBlockInputStream.cpp
+++ b/dbms/src/DataStreams/DistinctSortedBlockInputStream.cpp
@@ -8,15 +8,15 @@ namespace ErrorCodes
     extern const int SET_SIZE_LIMIT_EXCEEDED;
 }
 
-DistinctSortedBlockInputStream::DistinctSortedBlockInputStream(BlockInputStreamPtr input_, const Limits & limits, size_t limit_hint_, Names columns_)
-    : description( input_->getSortDescription() )
+DistinctSortedBlockInputStream::DistinctSortedBlockInputStream(const BlockInputStreamPtr & input, const Limits & limits, size_t limit_hint_, Names columns_)
+    : description(input->getSortDescription())
     , columns_names(columns_)
     , limit_hint(limit_hint_)
     , max_rows(limits.max_rows_in_distinct)
     , max_bytes(limits.max_bytes_in_distinct)
     , overflow_mode(limits.distinct_overflow_mode)
 {
-    children.push_back(input_);
+    children.push_back(input);
 }
 
 String DistinctSortedBlockInputStream::getID() const
diff --git a/dbms/src/DataStreams/DistinctSortedBlockInputStream.h b/dbms/src/DataStreams/DistinctSortedBlockInputStream.h
index bf5bbb6c90c..28601f4bb04 100644
--- a/dbms/src/DataStreams/DistinctSortedBlockInputStream.h
+++ b/dbms/src/DataStreams/DistinctSortedBlockInputStream.h
@@ -21,7 +21,7 @@ class DistinctSortedBlockInputStream : public IProfilingBlockInputStream
 {
 public:
     /// Empty columns_ means all collumns.
-    DistinctSortedBlockInputStream(BlockInputStreamPtr input_, const Limits & limits, size_t limit_hint_, Names columns_);
+    DistinctSortedBlockInputStream(const BlockInputStreamPtr & input, const Limits & limits, size_t limit_hint_, Names columns_);
 
     String getName() const override { return "DistinctSorted"; }
 
@@ -50,7 +50,7 @@ private:
         ClearableSetVariants & variants) const;
 
     const SortDescription & description;
-    
+
     struct PreviousBlock
     {
         Block block;
diff --git a/dbms/src/DataStreams/ExpressionBlockInputStream.cpp b/dbms/src/DataStreams/ExpressionBlockInputStream.cpp
index 916de1496b9..6130df31b51 100644
--- a/dbms/src/DataStreams/ExpressionBlockInputStream.cpp
+++ b/dbms/src/DataStreams/ExpressionBlockInputStream.cpp
@@ -5,10 +5,10 @@
 namespace DB
 {
 
-ExpressionBlockInputStream::ExpressionBlockInputStream(BlockInputStreamPtr input_, ExpressionActionsPtr expression_)
+ExpressionBlockInputStream::ExpressionBlockInputStream(const BlockInputStreamPtr & input, ExpressionActionsPtr expression_)
     : expression(expression_)
 {
-    children.push_back(input_);
+    children.push_back(input);
 }
 
 String ExpressionBlockInputStream::getName() const { return "Expression"; }
diff --git a/dbms/src/DataStreams/ExpressionBlockInputStream.h b/dbms/src/DataStreams/ExpressionBlockInputStream.h
index 6e5b166bad8..c57ea928d54 100644
--- a/dbms/src/DataStreams/ExpressionBlockInputStream.h
+++ b/dbms/src/DataStreams/ExpressionBlockInputStream.h
@@ -19,7 +19,7 @@ private:
     using ExpressionActionsPtr = std::shared_ptr<ExpressionActions>;
 
 public:
-    ExpressionBlockInputStream(BlockInputStreamPtr input_, ExpressionActionsPtr expression_);
+    ExpressionBlockInputStream(const BlockInputStreamPtr & input, ExpressionActionsPtr expression_);
 
     String getName() const override;
     String getID() const override;
diff --git a/dbms/src/DataStreams/FilterBlockInputStream.cpp b/dbms/src/DataStreams/FilterBlockInputStream.cpp
index dcf619bcfd7..be0e9182c08 100644
--- a/dbms/src/DataStreams/FilterBlockInputStream.cpp
+++ b/dbms/src/DataStreams/FilterBlockInputStream.cpp
@@ -17,16 +17,16 @@ namespace ErrorCodes
 }
 
 
-FilterBlockInputStream::FilterBlockInputStream(BlockInputStreamPtr input_, ExpressionActionsPtr expression_, ssize_t filter_column_)
+FilterBlockInputStream::FilterBlockInputStream(const BlockInputStreamPtr & input, ExpressionActionsPtr expression_, ssize_t filter_column_)
     : expression(expression_), filter_column(filter_column_)
 {
-    children.push_back(input_);
+    children.push_back(input);
 }
 
-FilterBlockInputStream::FilterBlockInputStream(BlockInputStreamPtr input_, ExpressionActionsPtr expression_, const String & filter_column_name_)
+FilterBlockInputStream::FilterBlockInputStream(const BlockInputStreamPtr & input, ExpressionActionsPtr expression_, const String & filter_column_name_)
     : expression(expression_), filter_column(-1), filter_column_name(filter_column_name_)
 {
-    children.push_back(input_);
+    children.push_back(input);
 }
 
 
diff --git a/dbms/src/DataStreams/FilterBlockInputStream.h b/dbms/src/DataStreams/FilterBlockInputStream.h
index 3f0cda420c6..95ade939256 100644
--- a/dbms/src/DataStreams/FilterBlockInputStream.h
+++ b/dbms/src/DataStreams/FilterBlockInputStream.h
@@ -20,8 +20,8 @@ private:
 
 public:
     /// filter_column_ - the number of the column with filter conditions.
-    FilterBlockInputStream(BlockInputStreamPtr input_, ExpressionActionsPtr expression_, ssize_t filter_column_);
-    FilterBlockInputStream(BlockInputStreamPtr input_, ExpressionActionsPtr expression_, const String & filter_column_name_);
+    FilterBlockInputStream(const BlockInputStreamPtr & input, ExpressionActionsPtr expression_, ssize_t filter_column_);
+    FilterBlockInputStream(const BlockInputStreamPtr & input, ExpressionActionsPtr expression_, const String & filter_column_name_);
 
     String getName() const override;
     String getID() const override;
diff --git a/dbms/src/DataStreams/ForkBlockInputStreams.h b/dbms/src/DataStreams/ForkBlockInputStreams.h
index e10e0d3f8fd..504cfc5bdbe 100644
--- a/dbms/src/DataStreams/ForkBlockInputStreams.h
+++ b/dbms/src/DataStreams/ForkBlockInputStreams.h
@@ -18,7 +18,7 @@ namespace DB
 class ForkBlockInputStreams : private boost::noncopyable
 {
 public:
-    ForkBlockInputStreams(BlockInputStreamPtr source_) : source(source_) {}
+    ForkBlockInputStreams(const BlockInputStreamPtr & source_) : source(source_) {}
 
     /// Create a source. Call the function as many times as many forked sources you need.
     BlockInputStreamPtr createInput()
diff --git a/dbms/src/DataStreams/LimitBlockInputStream.cpp b/dbms/src/DataStreams/LimitBlockInputStream.cpp
index 56edf6d1e98..7939d1f73ca 100644
--- a/dbms/src/DataStreams/LimitBlockInputStream.cpp
+++ b/dbms/src/DataStreams/LimitBlockInputStream.cpp
@@ -6,10 +6,10 @@
 namespace DB
 {
 
-LimitBlockInputStream::LimitBlockInputStream(BlockInputStreamPtr input_, size_t limit_, size_t offset_, bool always_read_till_end_)
+LimitBlockInputStream::LimitBlockInputStream(const BlockInputStreamPtr & input, size_t limit_, size_t offset_, bool always_read_till_end_)
     : limit(limit_), offset(offset_), always_read_till_end(always_read_till_end_)
 {
-    children.push_back(input_);
+    children.push_back(input);
 }
 
 
diff --git a/dbms/src/DataStreams/LimitBlockInputStream.h b/dbms/src/DataStreams/LimitBlockInputStream.h
index 1588441ee91..23bd5739aaf 100644
--- a/dbms/src/DataStreams/LimitBlockInputStream.h
+++ b/dbms/src/DataStreams/LimitBlockInputStream.h
@@ -17,7 +17,7 @@ public:
       * If always_read_till_end = true - reads all the data to the end, but ignores them. This is necessary in rare cases:
       *  when otherwise, due to the cancellation of the request, we would not have received the data for GROUP BY WITH TOTALS from the remote server.
       */
-    LimitBlockInputStream(BlockInputStreamPtr input_, size_t limit_, size_t offset_, bool always_read_till_end_ = false);
+    LimitBlockInputStream(const BlockInputStreamPtr & input, size_t limit_, size_t offset_, bool always_read_till_end_ = false);
 
     String getName() const override { return "Limit"; }
 
diff --git a/dbms/src/DataStreams/LimitByBlockInputStream.cpp b/dbms/src/DataStreams/LimitByBlockInputStream.cpp
index 8e0125a891e..6182dd3413b 100644
--- a/dbms/src/DataStreams/LimitByBlockInputStream.cpp
+++ b/dbms/src/DataStreams/LimitByBlockInputStream.cpp
@@ -3,11 +3,11 @@
 namespace DB
 {
 
-LimitByBlockInputStream::LimitByBlockInputStream(BlockInputStreamPtr input_, size_t group_size_, Names columns_)
+LimitByBlockInputStream::LimitByBlockInputStream(const BlockInputStreamPtr & input, size_t group_size_, Names columns_)
     : columns_names(columns_)
     , group_size(group_size_)
 {
-    children.push_back(input_);
+    children.push_back(input);
 }
 
 Block LimitByBlockInputStream::readImpl()
diff --git a/dbms/src/DataStreams/LimitByBlockInputStream.h b/dbms/src/DataStreams/LimitByBlockInputStream.h
index 0460e799ad6..54874d37f1e 100644
--- a/dbms/src/DataStreams/LimitByBlockInputStream.h
+++ b/dbms/src/DataStreams/LimitByBlockInputStream.h
@@ -18,7 +18,7 @@ namespace DB
 class LimitByBlockInputStream : public IProfilingBlockInputStream
 {
 public:
-    LimitByBlockInputStream(BlockInputStreamPtr input_, size_t group_size_, Names columns_);
+    LimitByBlockInputStream(const BlockInputStreamPtr & input, size_t group_size_, Names columns_);
 
     String getName() const override { return "LimitBy"; }
 
diff --git a/dbms/src/DataStreams/MaterializingBlockInputStream.cpp b/dbms/src/DataStreams/MaterializingBlockInputStream.cpp
index fefdfb3be26..640eb87b103 100644
--- a/dbms/src/DataStreams/MaterializingBlockInputStream.cpp
+++ b/dbms/src/DataStreams/MaterializingBlockInputStream.cpp
@@ -5,9 +5,9 @@
 namespace DB
 {
 
-MaterializingBlockInputStream::MaterializingBlockInputStream(BlockInputStreamPtr input_)
+MaterializingBlockInputStream::MaterializingBlockInputStream(const BlockInputStreamPtr & input)
 {
-    children.push_back(input_);
+    children.push_back(input);
 }
 
 String MaterializingBlockInputStream::getName() const
diff --git a/dbms/src/DataStreams/MaterializingBlockInputStream.h b/dbms/src/DataStreams/MaterializingBlockInputStream.h
index 654249e309a..feeca05298e 100644
--- a/dbms/src/DataStreams/MaterializingBlockInputStream.h
+++ b/dbms/src/DataStreams/MaterializingBlockInputStream.h
@@ -10,7 +10,7 @@ namespace DB
 class MaterializingBlockInputStream : public IProfilingBlockInputStream
 {
 public:
-    MaterializingBlockInputStream(BlockInputStreamPtr input_);
+    MaterializingBlockInputStream(const BlockInputStreamPtr & input);
     String getName() const override;
     String getID() const override;
 
diff --git a/dbms/src/DataStreams/MergeSortingBlockInputStream.h b/dbms/src/DataStreams/MergeSortingBlockInputStream.h
index ce59bb184b0..4a97d214a79 100644
--- a/dbms/src/DataStreams/MergeSortingBlockInputStream.h
+++ b/dbms/src/DataStreams/MergeSortingBlockInputStream.h
@@ -69,13 +69,13 @@ class MergeSortingBlockInputStream : public IProfilingBlockInputStream
 {
 public:
     /// limit - if not 0, allowed to return just first 'limit' rows in sorted order.
-    MergeSortingBlockInputStream(BlockInputStreamPtr input_, SortDescription & description_,
+    MergeSortingBlockInputStream(const BlockInputStreamPtr & input, SortDescription & description_,
         size_t max_merged_block_size_, size_t limit_,
         size_t max_bytes_before_external_sort_, const std::string & tmp_path_)
         : description(description_), max_merged_block_size(max_merged_block_size_), limit(limit_),
         max_bytes_before_external_sort(max_bytes_before_external_sort_), tmp_path(tmp_path_)
     {
-        children.push_back(input_);
+        children.push_back(input);
     }
 
     String getName() const override { return "MergeSorting"; }
diff --git a/dbms/src/DataStreams/MergingAggregatedBlockInputStream.h b/dbms/src/DataStreams/MergingAggregatedBlockInputStream.h
index 2346f7bd221..f133524d0f1 100644
--- a/dbms/src/DataStreams/MergingAggregatedBlockInputStream.h
+++ b/dbms/src/DataStreams/MergingAggregatedBlockInputStream.h
@@ -14,10 +14,10 @@ namespace DB
 class MergingAggregatedBlockInputStream : public IProfilingBlockInputStream
 {
 public:
-    MergingAggregatedBlockInputStream(BlockInputStreamPtr input_, const Aggregator::Params & params, bool final_, size_t max_threads_)
+    MergingAggregatedBlockInputStream(const BlockInputStreamPtr & input, const Aggregator::Params & params, bool final_, size_t max_threads_)
         : aggregator(params), final(final_), max_threads(max_threads_)
     {
-        children.push_back(input_);
+        children.push_back(input);
     }
 
     String getName() const override { return "MergingAggregated"; }
diff --git a/dbms/src/DataStreams/NullAndDoCopyBlockInputStream.h b/dbms/src/DataStreams/NullAndDoCopyBlockInputStream.h
index 3aa39e2da23..cd7823f236d 100644
--- a/dbms/src/DataStreams/NullAndDoCopyBlockInputStream.h
+++ b/dbms/src/DataStreams/NullAndDoCopyBlockInputStream.h
@@ -20,7 +20,7 @@ using BlockOutputStreamPtr = std::shared_ptr<IBlockOutputStream>;
 class NullAndDoCopyBlockInputStream : public IProfilingBlockInputStream
 {
 public:
-    NullAndDoCopyBlockInputStream(BlockInputStreamPtr input_, BlockOutputStreamPtr output_)
+    NullAndDoCopyBlockInputStream(const BlockInputStreamPtr & input_, BlockOutputStreamPtr output_)
         : input(input_), output(output_)
     {
         children.push_back(input_);
diff --git a/dbms/src/DataStreams/NullableAdapterBlockInputStream.cpp b/dbms/src/DataStreams/NullableAdapterBlockInputStream.cpp
index c7b87d4b86d..49a349ec980 100644
--- a/dbms/src/DataStreams/NullableAdapterBlockInputStream.cpp
+++ b/dbms/src/DataStreams/NullableAdapterBlockInputStream.cpp
@@ -17,11 +17,11 @@ extern const int TYPE_MISMATCH;
 }
 
 NullableAdapterBlockInputStream::NullableAdapterBlockInputStream(
-    BlockInputStreamPtr input_,
+    const BlockInputStreamPtr & input,
     const Block & in_sample_, const Block & out_sample_)
 {
     buildActions(in_sample_, out_sample_);
-    children.push_back(input_);
+    children.push_back(input);
 }
 
 String NullableAdapterBlockInputStream::getID() const
diff --git a/dbms/src/DataStreams/NullableAdapterBlockInputStream.h b/dbms/src/DataStreams/NullableAdapterBlockInputStream.h
index e58920cd147..917733cc6d4 100644
--- a/dbms/src/DataStreams/NullableAdapterBlockInputStream.h
+++ b/dbms/src/DataStreams/NullableAdapterBlockInputStream.h
@@ -18,7 +18,7 @@ namespace DB
 class NullableAdapterBlockInputStream : public IProfilingBlockInputStream
 {
 public:
-    NullableAdapterBlockInputStream(BlockInputStreamPtr input_, const Block & in_sample_,
+    NullableAdapterBlockInputStream(const BlockInputStreamPtr & input, const Block & in_sample_,
         const Block & out_sample_);
 
     String getName() const override { return "NullableAdapterBlockInputStream"; }
diff --git a/dbms/src/DataStreams/ParallelAggregatingBlockInputStream.cpp b/dbms/src/DataStreams/ParallelAggregatingBlockInputStream.cpp
index 40c71d244fc..92bfe5e1f9e 100644
--- a/dbms/src/DataStreams/ParallelAggregatingBlockInputStream.cpp
+++ b/dbms/src/DataStreams/ParallelAggregatingBlockInputStream.cpp
@@ -16,7 +16,7 @@ namespace DB
 
 
 ParallelAggregatingBlockInputStream::ParallelAggregatingBlockInputStream(
-    BlockInputStreams inputs, BlockInputStreamPtr additional_input_at_end,
+    const BlockInputStreams & inputs, const BlockInputStreamPtr & additional_input_at_end,
     const Aggregator::Params & params_, bool final_, size_t max_threads_, size_t temporary_data_merge_threads_)
     : params(params_), aggregator(params),
     final(final_), max_threads(std::min(inputs.size(), max_threads_)), temporary_data_merge_threads(temporary_data_merge_threads_),
diff --git a/dbms/src/DataStreams/ParallelAggregatingBlockInputStream.h b/dbms/src/DataStreams/ParallelAggregatingBlockInputStream.h
index 3bc08e75ea3..f76ef4e13b8 100644
--- a/dbms/src/DataStreams/ParallelAggregatingBlockInputStream.h
+++ b/dbms/src/DataStreams/ParallelAggregatingBlockInputStream.h
@@ -22,7 +22,7 @@ public:
     /** Columns from key_names and arguments of aggregate functions must already be computed.
       */
     ParallelAggregatingBlockInputStream(
-        BlockInputStreams inputs, BlockInputStreamPtr additional_input_at_end,
+        const BlockInputStreams & inputs, const BlockInputStreamPtr & additional_input_at_end,
         const Aggregator::Params & params_, bool final_, size_t max_threads_, size_t temporary_data_merge_threads_);
 
     String getName() const override { return "ParallelAggregating"; }
diff --git a/dbms/src/DataStreams/ParallelInputsProcessor.h b/dbms/src/DataStreams/ParallelInputsProcessor.h
index cdf17e1ab4f..c00c9f26ffa 100644
--- a/dbms/src/DataStreams/ParallelInputsProcessor.h
+++ b/dbms/src/DataStreams/ParallelInputsProcessor.h
@@ -76,7 +76,7 @@ public:
       * - where you must first make JOIN in parallel, while noting which keys are not found,
       *   and only after the completion of this work, create blocks of keys that are not found.
       */
-    ParallelInputsProcessor(BlockInputStreams inputs_, BlockInputStreamPtr additional_input_at_end_, size_t max_threads_, Handler & handler_)
+    ParallelInputsProcessor(const BlockInputStreams & inputs_, const BlockInputStreamPtr & additional_input_at_end_, size_t max_threads_, Handler & handler_)
         : inputs(inputs_), additional_input_at_end(additional_input_at_end_), max_threads(std::min(inputs_.size(), max_threads_)), handler(handler_)
     {
         for (size_t i = 0; i < inputs_.size(); ++i)
@@ -155,7 +155,7 @@ private:
         size_t i;        /// The source number (for debugging).
 
         InputData() {}
-        InputData(BlockInputStreamPtr & in_, size_t i_) : in(in_), i(i_) {}
+        InputData(const BlockInputStreamPtr & in_, size_t i_) : in(in_), i(i_) {}
     };
 
     template <StreamUnionMode mode2 = mode>
diff --git a/dbms/src/DataStreams/PartialSortingBlockInputStream.h b/dbms/src/DataStreams/PartialSortingBlockInputStream.h
index 924fdb0e2bf..f46fa8e5ca5 100644
--- a/dbms/src/DataStreams/PartialSortingBlockInputStream.h
+++ b/dbms/src/DataStreams/PartialSortingBlockInputStream.h
@@ -15,7 +15,7 @@ class PartialSortingBlockInputStream : public IProfilingBlockInputStream
 {
 public:
     /// limit - if not 0, then you can sort each block not completely, but only `limit` first rows by order.
-    PartialSortingBlockInputStream(BlockInputStreamPtr input_, SortDescription & description_, size_t limit_ = 0)
+    PartialSortingBlockInputStream(const BlockInputStreamPtr & input_, SortDescription & description_, size_t limit_ = 0)
         : description(description_), limit(limit_)
     {
         children.push_back(input_);
diff --git a/dbms/src/DataStreams/tests/glue_streams.cpp b/dbms/src/DataStreams/tests/glue_streams.cpp
index 78205b9c0ce..8982f2c0ef6 100644
--- a/dbms/src/DataStreams/tests/glue_streams.cpp
+++ b/dbms/src/DataStreams/tests/glue_streams.cpp
@@ -15,7 +15,7 @@
 using namespace DB;
 
 
-void inputThread(BlockInputStreamPtr in, BlockOutputStreamPtr out, WriteBuffer & wb, std::mutex & mutex)
+void inputThread(const BlockInputStreamPtr & in, BlockOutputStreamPtr out, WriteBuffer & wb, std::mutex & mutex)
 {
     while (Block block = in->read())
     {
diff --git a/dbms/src/IO/WriteHelpers.h b/dbms/src/IO/WriteHelpers.h
index 76def04e0a4..6c0cf219bac 100644
--- a/dbms/src/IO/WriteHelpers.h
+++ b/dbms/src/IO/WriteHelpers.h
@@ -197,7 +197,7 @@ inline void writeJSONString(const char * begin, const char * end, WriteBuffer &
                 break;
             default:
                 UInt8 c = *it;
-                if (0x00 <= c && c <= 0x1F)
+                if (c <= 0x1F)
                 {
                     /// Escaping of ASCII control characters.
 
@@ -207,7 +207,7 @@ inline void writeJSONString(const char * begin, const char * end, WriteBuffer &
                     writeCString("\\u00", buf);
                     writeChar('0' + higher_half, buf);
 
-                    if (0 <= lower_half && lower_half <= 9)
+                    if (lower_half <= 9)
                         writeChar('0' + lower_half, buf);
                     else
                         writeChar('A' + lower_half - 10, buf);
@@ -522,7 +522,7 @@ inline void writeDateText(DayNum_t date, WriteBuffer & buf)
     buf.write(s, 10);
 }
 
-inline void writeDateText(LocalDate date, WriteBuffer & buf)
+inline void writeDateText(const LocalDate & date, WriteBuffer & buf)
 {
     char s[10] = {'0', '0', '0', '0', '-', '0', '0', '-', '0', '0'};
 
@@ -577,7 +577,7 @@ inline void writeDateTimeText(time_t datetime, WriteBuffer & buf, const DateLUTI
 }
 
 template <char date_delimeter = '-', char time_delimeter = ':'>
-inline void writeDateTimeText(LocalDateTime datetime, WriteBuffer & buf)
+inline void writeDateTimeText(const LocalDateTime & datetime, WriteBuffer & buf)
 {
     char s[19] = {'0', '0', '0', '0', date_delimeter, '0', '0', date_delimeter, '0', '0', ' ', '0', '0', time_delimeter, '0', '0', time_delimeter, '0', '0'};
 
diff --git a/dbms/src/Interpreters/Aggregator.cpp b/dbms/src/Interpreters/Aggregator.cpp
index 8b038f6aa67..be4badb2af0 100644
--- a/dbms/src/Interpreters/Aggregator.cpp
+++ b/dbms/src/Interpreters/Aggregator.cpp
@@ -1034,7 +1034,7 @@ bool Aggregator::checkLimits(size_t result_size, bool & no_more_keys) const
 }
 
 
-void Aggregator::execute(BlockInputStreamPtr stream, AggregatedDataVariants & result)
+void Aggregator::execute(const BlockInputStreamPtr & stream, AggregatedDataVariants & result)
 {
     if (isCancelled())
         return;
@@ -1989,7 +1989,7 @@ void NO_INLINE Aggregator::mergeWithoutKeyStreamsImpl(
 }
 
 
-void Aggregator::mergeStream(BlockInputStreamPtr stream, AggregatedDataVariants & result, size_t max_threads)
+void Aggregator::mergeStream(const BlockInputStreamPtr & stream, AggregatedDataVariants & result, size_t max_threads)
 {
     if (isCancelled())
         return;
diff --git a/dbms/src/Interpreters/Aggregator.h b/dbms/src/Interpreters/Aggregator.h
index 2003759fbbf..ee0b0e6cd87 100644
--- a/dbms/src/Interpreters/Aggregator.h
+++ b/dbms/src/Interpreters/Aggregator.h
@@ -1039,7 +1039,7 @@ public:
     }
 
     /// Aggregate the source. Get the result in the form of one of the data structures.
-    void execute(BlockInputStreamPtr stream, AggregatedDataVariants & result);
+    void execute(const BlockInputStreamPtr & stream, AggregatedDataVariants & result);
 
     using AggregateColumns = std::vector<ConstColumnPlainPtrs>;
     using AggregateColumnsData = std::vector<ColumnAggregateFunction::Container_t *>;
@@ -1067,7 +1067,7 @@ public:
     /** Merge the stream of partially aggregated blocks into one data structure.
       * (Pre-aggregate several blocks that represent the result of independent aggregations from remote servers.)
       */
-    void mergeStream(BlockInputStreamPtr stream, AggregatedDataVariants & result, size_t max_threads);
+    void mergeStream(const BlockInputStreamPtr & stream, AggregatedDataVariants & result, size_t max_threads);
 
     /// Merge several partially aggregated blocks into one.
     /// Precondition: for all blocks block.info.is_overflows flag must be the same.
diff --git a/dbms/src/Interpreters/InterpreterSelectQuery.cpp b/dbms/src/Interpreters/InterpreterSelectQuery.cpp
index c5518e7de35..da2a9e2e0d4 100644
--- a/dbms/src/Interpreters/InterpreterSelectQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterSelectQuery.cpp
@@ -69,7 +69,7 @@ namespace ErrorCodes
 InterpreterSelectQuery::~InterpreterSelectQuery() = default;
 
 
-void InterpreterSelectQuery::init(BlockInputStreamPtr input, const Names & required_column_names)
+void InterpreterSelectQuery::init(const BlockInputStreamPtr & input, const Names & required_column_names)
 {
     ProfileEvents::increment(ProfileEvents::SelectQuery);
 
@@ -126,7 +126,7 @@ void InterpreterSelectQuery::init(BlockInputStreamPtr input, const Names & requi
     }
 }
 
-void InterpreterSelectQuery::basicInit(BlockInputStreamPtr input_)
+void InterpreterSelectQuery::basicInit(const BlockInputStreamPtr & input)
 {
     auto query_table = query.table();
 
@@ -171,8 +171,8 @@ void InterpreterSelectQuery::basicInit(BlockInputStreamPtr input_)
         if (!context.tryGetExternalTable(it.first))
             context.addExternalTable(it.first, it.second);
 
-    if (input_)
-        streams.push_back(input_);
+    if (input)
+        streams.push_back(input);
 
     if (is_first_select_inside_union_all)
     {
@@ -200,7 +200,7 @@ void InterpreterSelectQuery::initQueryAnalyzer()
 }
 
 InterpreterSelectQuery::InterpreterSelectQuery(const ASTPtr & query_ptr_, const Context & context_, QueryProcessingStage::Enum to_stage_,
-    size_t subquery_depth_, BlockInputStreamPtr input_)
+    size_t subquery_depth_, BlockInputStreamPtr input)
     : query_ptr(query_ptr_)
     , query(typeid_cast<ASTSelectQuery &>(*query_ptr))
     , context(context_)
@@ -209,7 +209,7 @@ InterpreterSelectQuery::InterpreterSelectQuery(const ASTPtr & query_ptr_, const
     , is_first_select_inside_union_all(query.isUnionAllHead())
     , log(&Logger::get("InterpreterSelectQuery"))
 {
-    init(input_);
+    init(input);
 }
 
 InterpreterSelectQuery::InterpreterSelectQuery(OnlyAnalyzeTag, const ASTPtr & query_ptr_, const Context & context_)
@@ -226,14 +226,14 @@ InterpreterSelectQuery::InterpreterSelectQuery(OnlyAnalyzeTag, const ASTPtr & qu
 
 InterpreterSelectQuery::InterpreterSelectQuery(const ASTPtr & query_ptr_, const Context & context_,
     const Names & required_column_names_,
-    QueryProcessingStage::Enum to_stage_, size_t subquery_depth_, BlockInputStreamPtr input_)
-    : InterpreterSelectQuery(query_ptr_, context_, required_column_names_, {}, to_stage_, subquery_depth_, input_)
+    QueryProcessingStage::Enum to_stage_, size_t subquery_depth_, BlockInputStreamPtr input)
+    : InterpreterSelectQuery(query_ptr_, context_, required_column_names_, {}, to_stage_, subquery_depth_, input)
 {
 }
 
 InterpreterSelectQuery::InterpreterSelectQuery(const ASTPtr & query_ptr_, const Context & context_,
     const Names & required_column_names_,
-    const NamesAndTypesList & table_column_names_, QueryProcessingStage::Enum to_stage_, size_t subquery_depth_, BlockInputStreamPtr input_)
+    const NamesAndTypesList & table_column_names_, QueryProcessingStage::Enum to_stage_, size_t subquery_depth_, BlockInputStreamPtr input)
     : query_ptr(query_ptr_)
     , query(typeid_cast<ASTSelectQuery &>(*query_ptr))
     , context(context_)
@@ -243,7 +243,7 @@ InterpreterSelectQuery::InterpreterSelectQuery(const ASTPtr & query_ptr_, const
     , is_first_select_inside_union_all(query.isUnionAllHead())
     , log(&Logger::get("InterpreterSelectQuery"))
 {
-    init(input_, required_column_names_);
+    init(input, required_column_names_);
 }
 
 bool InterpreterSelectQuery::hasAsterisk() const
diff --git a/dbms/src/Interpreters/InterpreterSelectQuery.h b/dbms/src/Interpreters/InterpreterSelectQuery.h
index 83b1722b2cc..a7e8ea1445e 100644
--- a/dbms/src/Interpreters/InterpreterSelectQuery.h
+++ b/dbms/src/Interpreters/InterpreterSelectQuery.h
@@ -93,8 +93,8 @@ private:
         const ASTPtr & query_ptr_,
         const Context & context_);
 
-    void init(BlockInputStreamPtr input, const Names & required_column_names = Names{});
-    void basicInit(BlockInputStreamPtr input);
+    void init(const BlockInputStreamPtr & input, const Names & required_column_names = Names{});
+    void basicInit(const BlockInputStreamPtr & input);
     void initQueryAnalyzer();
 
     /// Execute one SELECT query from the UNION ALL chain.
diff --git a/dbms/src/Interpreters/SettingsCommon.h b/dbms/src/Interpreters/SettingsCommon.h
index e3cf90eee11..69fbee54d9e 100644
--- a/dbms/src/Interpreters/SettingsCommon.h
+++ b/dbms/src/Interpreters/SettingsCommon.h
@@ -219,7 +219,7 @@ struct SettingMilliseconds
     SettingMilliseconds(UInt64 milliseconds = 0) : value(milliseconds * 1000) {}
 
     operator Poco::Timespan() const { return value; }
-    SettingMilliseconds & operator= (Poco::Timespan x) { set(x); return *this; }
+    SettingMilliseconds & operator= (const Poco::Timespan & x) { set(x); return *this; }
 
     Poco::Timespan::TimeDiff totalMilliseconds() const { return value.totalMilliseconds(); }
 
@@ -228,7 +228,7 @@ struct SettingMilliseconds
         return DB::toString(totalMilliseconds());
     }
 
-    void set(Poco::Timespan x)
+    void set(const Poco::Timespan & x)
     {
         value = x;
         changed = true;
diff --git a/libs/libmysqlxx/include/mysqlxx/Connection.h b/libs/libmysqlxx/include/mysqlxx/Connection.h
index 7ecb3c6fdc5..c704faa3212 100644
--- a/libs/libmysqlxx/include/mysqlxx/Connection.h
+++ b/libs/libmysqlxx/include/mysqlxx/Connection.h
@@ -47,7 +47,7 @@ private:
   * In order to use connection in other thread, you should call MySQL C API function mysql_thread_init() before and
   * mysql_thread_end() after working with it.
   */
-class Connection : private boost::noncopyable
+class Connection final : private boost::noncopyable
 {
 public:
     /// For delayed initialisation
@@ -69,10 +69,10 @@ public:
     /// All settings will be got from config_name section of configuration.
     Connection(const std::string & config_name);
 
-    virtual ~Connection();
+    ~Connection();
 
     /// Provides delayed initialization or reconnection with other settings.
-    virtual void connect(const char * db,
+    void connect(const char * db,
         const char * server,
         const char * user,
         const char * password,
diff --git a/libs/libmysqlxx/include/mysqlxx/Manip.h b/libs/libmysqlxx/include/mysqlxx/Manip.h
index 11fab8264dd..c02d9e10515 100644
--- a/libs/libmysqlxx/include/mysqlxx/Manip.h
+++ b/libs/libmysqlxx/include/mysqlxx/Manip.h
@@ -50,8 +50,8 @@ struct EscapeManipResult
     typename std::enable_if<std::is_arithmetic<T>::value, std::ostream &>::type
     operator<< (T value) { return ostr << value; }
 
-    std::ostream & operator<< (LocalDate value)                { return ostr << value; }
-    std::ostream & operator<< (LocalDateTime value)            { return ostr << value; }
+    std::ostream & operator<< (const LocalDate & value)      { return ostr << value; }
+    std::ostream & operator<< (const LocalDateTime & value)  { return ostr << value; }
 
     std::ostream & operator<< (const std::string & value)
     {
@@ -172,8 +172,8 @@ public:
     typename std::enable_if<std::is_arithmetic<T>::value, std::ostream &>::type
     operator<< (T value) { return ostr << value; }
 
-    std::ostream & operator<< (LocalDate value)                { return ostr << '\'' << value << '\''; }
-    std::ostream & operator<< (LocalDateTime value)            { return ostr << '\'' << value << '\''; }
+    std::ostream & operator<< (const LocalDate & value)     { return ostr << '\'' << value << '\''; }
+    std::ostream & operator<< (const LocalDateTime & value) { return ostr << '\'' << value << '\''; }
 
     std::ostream & operator<< (const std::string & value)
     {

From abad3f432d4b97acf47a8db0598aa8965b1c49bf Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 05:31:58 +0300
Subject: [PATCH 129/266] Added instruction to run clang-tidy
 [#CLICKHOUSE-3301].

---
 dbms/tests/instructions/clang-tidy.txt | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 dbms/tests/instructions/clang-tidy.txt

diff --git a/dbms/tests/instructions/clang-tidy.txt b/dbms/tests/instructions/clang-tidy.txt
new file mode 100644
index 00000000000..952e5f04a72
--- /dev/null
+++ b/dbms/tests/instructions/clang-tidy.txt
@@ -0,0 +1,11 @@
+# Install latest clang with extra tools.
+# Look at utils/prepare-environment/install-clang.sh
+
+sudo apt-get install jq
+
+cd build
+CC=clang CXX=clang++ cmake ..
+
+cd ..
+
+jq '.[] | .file' build/compile_commands.json | grep -v -F 'contrib' | head -n1 | xargs -I{} clang-tidy {} -p build -header-filter='dbms|libs' -checks='boost-*,bugprone-*,clang-analyzer-*,performance-*'

From d19d9f8589d8e39d104a7ad8cd7d56c79324c250 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 05:37:02 +0300
Subject: [PATCH 130/266] Implemented some suggestions from clang-tidy (part 2)
 [#CLICKHOUSE-3301].

---
 dbms/src/Columns/IColumn.h             | 2 +-
 dbms/src/Interpreters/SettingsCommon.h | 4 ++--
 utils/zookeeper-cli/zookeeper-cli.cpp  | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/dbms/src/Columns/IColumn.h b/dbms/src/Columns/IColumn.h
index 2b5925f889d..ff27021e584 100644
--- a/dbms/src/Columns/IColumn.h
+++ b/dbms/src/Columns/IColumn.h
@@ -284,7 +284,7 @@ protected:
             column = cloneEmpty();
 
         {
-            size_t reserve_size = num_rows / num_columns * 1.1;    /// 1.1 is just a guess. Better to use n-sigma rule.
+            size_t reserve_size = num_rows * 1.1 / num_columns;    /// 1.1 is just a guess. Better to use n-sigma rule.
 
             if (reserve_size > 1)
                 for (auto & column : columns)
diff --git a/dbms/src/Interpreters/SettingsCommon.h b/dbms/src/Interpreters/SettingsCommon.h
index 69fbee54d9e..55ffc48dff1 100644
--- a/dbms/src/Interpreters/SettingsCommon.h
+++ b/dbms/src/Interpreters/SettingsCommon.h
@@ -167,7 +167,7 @@ struct SettingSeconds
     SettingSeconds(UInt64 seconds = 0) : value(seconds, 0) {}
 
     operator Poco::Timespan() const { return value; }
-    SettingSeconds & operator= (Poco::Timespan x) { set(x); return *this; }
+    SettingSeconds & operator= (const Poco::Timespan & x) { set(x); return *this; }
 
     Poco::Timespan::TimeDiff totalSeconds() const { return value.totalSeconds(); }
 
@@ -176,7 +176,7 @@ struct SettingSeconds
         return DB::toString(totalSeconds());
     }
 
-    void set(Poco::Timespan x)
+    void set(const Poco::Timespan & x)
     {
         value = x;
         changed = true;
diff --git a/utils/zookeeper-cli/zookeeper-cli.cpp b/utils/zookeeper-cli/zookeeper-cli.cpp
index d6d49116ff7..266bf5bb34d 100644
--- a/utils/zookeeper-cli/zookeeper-cli.cpp
+++ b/utils/zookeeper-cli/zookeeper-cli.cpp
@@ -25,7 +25,7 @@ void printStat(const zkutil::Stat & s)
     std::cout << "  pzxid: " << s.pzxid << std::endl;
 }
 
-void waitForWatch(zkutil::EventPtr event)
+void waitForWatch(const zkutil::EventPtr & event)
 {
     std::cout << "waiting for watch" << std::endl;
     event->wait();

From f1c98dac3c4af9f8d4e011498bef16684a4d7fd0 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 05:42:47 +0300
Subject: [PATCH 131/266] Updated instruction to run clang-tidy
 [#CLICKHOUSE-3301].

---
 dbms/tests/instructions/clang-tidy.txt | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/dbms/tests/instructions/clang-tidy.txt b/dbms/tests/instructions/clang-tidy.txt
index 952e5f04a72..cc6cc2e9556 100644
--- a/dbms/tests/instructions/clang-tidy.txt
+++ b/dbms/tests/instructions/clang-tidy.txt
@@ -8,4 +8,7 @@ CC=clang CXX=clang++ cmake ..
 
 cd ..
 
-jq '.[] | .file' build/compile_commands.json | grep -v -F 'contrib' | head -n1 | xargs -I{} clang-tidy {} -p build -header-filter='dbms|libs' -checks='boost-*,bugprone-*,clang-analyzer-*,performance-*'
+for i in $(jq --raw-output '.[] | .file' build/compile_commands.json | grep -v -F 'contrib'); do
+    echo "$i";
+    clang-tidy "$i" -p build -header-filter='dbms|libs' -checks='boost-*,bugprone-*,clang-analyzer-*,performance-*'; 
+done

From d29c77adea08af7922d7b82e56ccee2f2d11783f Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 06:47:27 +0300
Subject: [PATCH 132/266] Implemented some suggestions from clang-tidy (part 3)
 [#CLICKHOUSE-3301].

---
 dbms/src/Analyzers/CollectAliases.h           |  2 +-
 dbms/src/Columns/ColumnSet.h                  |  2 +-
 .../AddingDefaultBlockOutputStream.h          |  2 +-
 .../BlockInputStreamFromRowInputStream.cpp    |  2 +-
 .../BlockInputStreamFromRowInputStream.h      |  2 +-
 dbms/src/DataStreams/CSVRowInputStream.cpp    |  4 +-
 .../CollapsingFinalBlockInputStream.h         | 12 ++-
 .../DataStreams/CountingBlockOutputStream.h   |  6 +-
 .../CreatingSetsBlockInputStream.cpp          | 27 +++---
 .../CreatingSetsBlockInputStream.h            |  2 +-
 .../DataStreams/DistinctBlockInputStream.cpp  | 28 +++---
 .../DataStreams/DistinctBlockInputStream.h    |  2 +-
 .../DistinctSortedBlockInputStream.cpp        | 24 +++--
 .../ExpressionBlockInputStream.cpp            |  2 +-
 .../DataStreams/ExpressionBlockInputStream.h  |  2 +-
 .../DataStreams/FilterBlockInputStream.cpp    |  4 +-
 dbms/src/DataStreams/FilterBlockInputStream.h |  4 +-
 .../FilterColumnsBlockInputStream.h           |  4 +-
 dbms/src/DataStreams/IBlockInputStream.cpp    |  4 +-
 dbms/src/DataStreams/IBlockInputStream.h      |  2 +-
 .../IProfilingBlockInputStream.cpp            | 96 +++++++++----------
 .../DataStreams/IProfilingBlockInputStream.h  |  2 +-
 .../DataStreams/LimitByBlockInputStream.cpp   |  4 +-
 .../src/DataStreams/LimitByBlockInputStream.h |  2 +-
 ...ggregatedMemoryEfficientBlockInputStream.h |  4 +-
 .../TotalsHavingBlockInputStream.cpp          |  4 +-
 .../TotalsHavingBlockInputStream.h            |  4 +-
 dbms/src/DataTypes/DataTypeArray.cpp          |  4 +-
 dbms/src/DataTypes/DataTypeArray.h            |  4 +-
 dbms/src/DataTypes/DataTypeExpression.h       |  2 +-
 dbms/src/DataTypes/DataTypeNested.cpp         |  2 +-
 dbms/src/DataTypes/DataTypeNested.h           |  2 +-
 dbms/src/DataTypes/DataTypeNullable.cpp       |  2 +-
 dbms/src/DataTypes/DataTypeNullable.h         |  2 +-
 dbms/src/DataTypes/DataTypeTuple.h            |  2 +-
 .../Dictionaries/DictionaryBlockInputStream.h |  2 +-
 dbms/src/Dictionaries/DictionaryStructure.cpp |  2 +-
 .../ExecutableDictionarySource.cpp            |  2 +-
 dbms/src/Dictionaries/FlatDictionary.cpp      |  2 +-
 dbms/src/Interpreters/Aggregator.cpp          | 24 +++--
 dbms/src/Interpreters/Compiler.cpp            |  2 +-
 dbms/src/Interpreters/Context.cpp             |  4 +-
 dbms/src/Interpreters/Context.h               |  2 +-
 dbms/src/Interpreters/ExpressionActions.h     |  2 +-
 dbms/src/Interpreters/ExpressionAnalyzer.cpp  | 12 +--
 dbms/src/Interpreters/ExpressionAnalyzer.h    | 12 +--
 .../Interpreters/InterpreterSelectQuery.cpp   |  2 +-
 dbms/src/Interpreters/Join.cpp                | 24 +++--
 dbms/src/Interpreters/ProcessList.cpp         |  2 +-
 dbms/src/Interpreters/ProcessList.h           |  2 +-
 dbms/src/Interpreters/Set.cpp                 | 24 +++--
 dbms/src/Storages/MergeTree/PKCondition.cpp   |  2 +-
 dbms/src/Storages/MergeTree/PKCondition.h     |  2 +-
 53 files changed, 211 insertions(+), 186 deletions(-)

diff --git a/dbms/src/Analyzers/CollectAliases.h b/dbms/src/Analyzers/CollectAliases.h
index 0c6046bc509..46ce74909f8 100644
--- a/dbms/src/Analyzers/CollectAliases.h
+++ b/dbms/src/Analyzers/CollectAliases.h
@@ -41,7 +41,7 @@ struct CollectAliases
         ASTPtr node;
         Kind kind;
 
-        AliasInfo(ASTPtr node, Kind kind) : node(node), kind(kind) {}
+        AliasInfo(const ASTPtr & node, Kind kind) : node(node), kind(kind) {}
     };
 
     using Aliases = std::unordered_map<String, AliasInfo>;
diff --git a/dbms/src/Columns/ColumnSet.h b/dbms/src/Columns/ColumnSet.h
index 59e9c85a904..7e07d38f5c6 100644
--- a/dbms/src/Columns/ColumnSet.h
+++ b/dbms/src/Columns/ColumnSet.h
@@ -17,7 +17,7 @@ using ConstSetPtr = std::shared_ptr<const Set>;
 class ColumnSet final : public IColumnDummy
 {
 public:
-    ColumnSet(size_t s_, ConstSetPtr data_) : IColumnDummy(s_), data(data_) {}
+    ColumnSet(size_t s_, const ConstSetPtr & data_) : IColumnDummy(s_), data(data_) {}
 
     /// The column is not a constant. Otherwise, the column will be used in calculations in ExpressionActions::prepare, when a set from subquery is not ready yet.
     bool isConst() const override { return false; }
diff --git a/dbms/src/DataStreams/AddingDefaultBlockOutputStream.h b/dbms/src/DataStreams/AddingDefaultBlockOutputStream.h
index b9955792f41..a6e86ca16d0 100644
--- a/dbms/src/DataStreams/AddingDefaultBlockOutputStream.h
+++ b/dbms/src/DataStreams/AddingDefaultBlockOutputStream.h
@@ -18,7 +18,7 @@ class AddingDefaultBlockOutputStream : public IBlockOutputStream
 {
 public:
     AddingDefaultBlockOutputStream(
-        BlockOutputStreamPtr output_,
+        const BlockOutputStreamPtr & output_,
         NamesAndTypesListPtr required_columns_,
         const ColumnDefaults & column_defaults_,
         const Context & context_,
diff --git a/dbms/src/DataStreams/BlockInputStreamFromRowInputStream.cpp b/dbms/src/DataStreams/BlockInputStreamFromRowInputStream.cpp
index 48ea7eb5f0a..dd0eb257331 100644
--- a/dbms/src/DataStreams/BlockInputStreamFromRowInputStream.cpp
+++ b/dbms/src/DataStreams/BlockInputStreamFromRowInputStream.cpp
@@ -18,7 +18,7 @@ namespace ErrorCodes
 
 
 BlockInputStreamFromRowInputStream::BlockInputStreamFromRowInputStream(
-    RowInputStreamPtr row_input_,
+    const RowInputStreamPtr & row_input_,
     const Block & sample_,
     size_t max_block_size_,
     UInt64 allow_errors_num_,
diff --git a/dbms/src/DataStreams/BlockInputStreamFromRowInputStream.h b/dbms/src/DataStreams/BlockInputStreamFromRowInputStream.h
index b589a767065..f5c2f2f35e1 100644
--- a/dbms/src/DataStreams/BlockInputStreamFromRowInputStream.h
+++ b/dbms/src/DataStreams/BlockInputStreamFromRowInputStream.h
@@ -18,7 +18,7 @@ class BlockInputStreamFromRowInputStream : public IProfilingBlockInputStream
 public:
     /** sample_ - block with zero rows, that structure describes how to interpret values */
     BlockInputStreamFromRowInputStream(
-        RowInputStreamPtr row_input_,
+        const RowInputStreamPtr & row_input_,
         const Block & sample_,
         size_t max_block_size_,
         UInt64 allow_errors_num_,
diff --git a/dbms/src/DataStreams/CSVRowInputStream.cpp b/dbms/src/DataStreams/CSVRowInputStream.cpp
index edfc096b973..24c81cb3185 100644
--- a/dbms/src/DataStreams/CSVRowInputStream.cpp
+++ b/dbms/src/DataStreams/CSVRowInputStream.cpp
@@ -206,8 +206,8 @@ bool CSVRowInputStream::parseRowAndPrintDiagnosticInfo(Block & block,
             << "name: " << sample.safeGetByPosition(i).name << ", " << std::string(max_length_of_column_name - sample.safeGetByPosition(i).name.size(), ' ')
             << "type: " << data_types[i]->getName() << ", " << std::string(max_length_of_data_type_name - data_types[i]->getName().size(), ' ');
 
-        auto prev_position = istr.position();
-        auto curr_position = istr.position();
+        BufferBase::Position prev_position = istr.position();
+        BufferBase::Position curr_position = istr.position();
         std::exception_ptr exception;
 
         try
diff --git a/dbms/src/DataStreams/CollapsingFinalBlockInputStream.h b/dbms/src/DataStreams/CollapsingFinalBlockInputStream.h
index 7896e96232d..5782742a425 100644
--- a/dbms/src/DataStreams/CollapsingFinalBlockInputStream.h
+++ b/dbms/src/DataStreams/CollapsingFinalBlockInputStream.h
@@ -15,11 +15,13 @@ namespace DB
 class CollapsingFinalBlockInputStream : public IProfilingBlockInputStream
 {
 public:
-    CollapsingFinalBlockInputStream(BlockInputStreams inputs_, const SortDescription & description_,
-                                     const String & sign_column_name_)
+    CollapsingFinalBlockInputStream(
+        const BlockInputStreams & inputs,
+        const SortDescription & description_,
+        const String & sign_column_name_)
         : description(description_), sign_column_name(sign_column_name_)
     {
-        children.insert(children.end(), inputs_.begin(), inputs_.end());
+        children.insert(children.end(), inputs.begin(), inputs.end());
     }
 
     ~CollapsingFinalBlockInputStream();
@@ -55,10 +57,10 @@ private:
 
     struct MergingBlock : boost::noncopyable
     {
-        MergingBlock(Block block_,
+        MergingBlock(const Block & block_,
                      size_t stream_index_,
                      const SortDescription & desc,
-                     String sign_column_name,
+                     const String & sign_column_name,
                      BlockPlainPtrs * output_blocks)
             : block(block_), stream_index(stream_index_), output_blocks(output_blocks)
         {
diff --git a/dbms/src/DataStreams/CountingBlockOutputStream.h b/dbms/src/DataStreams/CountingBlockOutputStream.h
index f0fac50f7f0..63ece36c2b0 100644
--- a/dbms/src/DataStreams/CountingBlockOutputStream.h
+++ b/dbms/src/DataStreams/CountingBlockOutputStream.h
@@ -16,7 +16,7 @@ public:
     CountingBlockOutputStream(const BlockOutputStreamPtr & stream_)
         : stream(stream_) {}
 
-    void setProgressCallback(ProgressCallback callback)
+    void setProgressCallback(const ProgressCallback & callback)
     {
         progress_callback = callback;
     }
@@ -35,9 +35,9 @@ public:
 
     void writePrefix() override                         { stream->writePrefix(); }
     void writeSuffix() override                         { stream->writeSuffix(); }
-    void flush() override                                 { stream->flush(); }
+    void flush() override                               { stream->flush(); }
     void onProgress(const Progress & progress) override { stream->onProgress(progress); }
-    String getContentType() const override                { return stream->getContentType(); }
+    String getContentType() const override              { return stream->getContentType(); }
 
 protected:
 
diff --git a/dbms/src/DataStreams/CreatingSetsBlockInputStream.cpp b/dbms/src/DataStreams/CreatingSetsBlockInputStream.cpp
index 995b043983e..0d6ad4a097e 100644
--- a/dbms/src/DataStreams/CreatingSetsBlockInputStream.cpp
+++ b/dbms/src/DataStreams/CreatingSetsBlockInputStream.cpp
@@ -117,18 +117,21 @@ void CreatingSetsBlockInputStream::createOne(SubqueryForSet & subquery)
             if ((max_rows_to_transfer && rows_to_transfer > max_rows_to_transfer)
                 || (max_bytes_to_transfer && bytes_to_transfer > max_bytes_to_transfer))
             {
-                if (transfer_overflow_mode == OverflowMode::THROW)
-                    throw Exception("IN/JOIN external table size limit exceeded."
-                        " Rows: " + toString(rows_to_transfer)
-                        + ", limit: " + toString(max_rows_to_transfer)
-                        + ". Bytes: " + toString(bytes_to_transfer)
-                        + ", limit: " + toString(max_bytes_to_transfer) + ".",
-                        ErrorCodes::SET_SIZE_LIMIT_EXCEEDED);
-
-                if (transfer_overflow_mode == OverflowMode::BREAK)
-                    done_with_table = true;
-
-                throw Exception("Logical error: unknown overflow mode", ErrorCodes::LOGICAL_ERROR);
+                switch (transfer_overflow_mode)
+                {
+                    case OverflowMode::THROW:
+                        throw Exception("IN/JOIN external table size limit exceeded."
+                            " Rows: " + toString(rows_to_transfer)
+                            + ", limit: " + toString(max_rows_to_transfer)
+                            + ". Bytes: " + toString(bytes_to_transfer)
+                            + ", limit: " + toString(max_bytes_to_transfer) + ".",
+                            ErrorCodes::SET_SIZE_LIMIT_EXCEEDED);
+                    case OverflowMode::BREAK:
+                        done_with_table = true;
+                        break;
+                    default:
+                        throw Exception("Logical error: unknown overflow mode", ErrorCodes::LOGICAL_ERROR);
+                }
             }
         }
 
diff --git a/dbms/src/DataStreams/CreatingSetsBlockInputStream.h b/dbms/src/DataStreams/CreatingSetsBlockInputStream.h
index cae282e9970..605caac90bc 100644
--- a/dbms/src/DataStreams/CreatingSetsBlockInputStream.h
+++ b/dbms/src/DataStreams/CreatingSetsBlockInputStream.h
@@ -18,7 +18,7 @@ class CreatingSetsBlockInputStream : public IProfilingBlockInputStream
 {
 public:
     CreatingSetsBlockInputStream(
-        BlockInputStreamPtr input,
+        const BlockInputStreamPtr & input,
         const SubqueriesForSets & subqueries_for_sets_,
         const Limits & limits)
         : subqueries_for_sets(subqueries_for_sets_),
diff --git a/dbms/src/DataStreams/DistinctBlockInputStream.cpp b/dbms/src/DataStreams/DistinctBlockInputStream.cpp
index d308eb9f17b..dbb6d5b63f8 100644
--- a/dbms/src/DataStreams/DistinctBlockInputStream.cpp
+++ b/dbms/src/DataStreams/DistinctBlockInputStream.cpp
@@ -8,8 +8,8 @@ namespace ErrorCodes
     extern const int SET_SIZE_LIMIT_EXCEEDED;
 }
 
-DistinctBlockInputStream::DistinctBlockInputStream(const BlockInputStreamPtr & input, const Limits & limits, size_t limit_hint_, Names columns_)
-    : columns_names(columns_)
+DistinctBlockInputStream::DistinctBlockInputStream(const BlockInputStreamPtr & input, const Limits & limits, size_t limit_hint_, const Names & columns)
+    : columns_names(columns)
     , limit_hint(limit_hint_)
     , max_rows(limits.max_rows_in_distinct)
     , max_bytes(limits.max_bytes_in_distinct)
@@ -68,18 +68,22 @@ Block DistinctBlockInputStream::readImpl()
 
         if (!checkLimits())
         {
-            if (overflow_mode == OverflowMode::THROW)
-                throw Exception("DISTINCT-Set size limit exceeded."
-                    " Rows: " + toString(data.getTotalRowCount()) +
-                    ", limit: " + toString(max_rows) +
-                    ". Bytes: " + toString(data.getTotalByteCount()) +
-                    ", limit: " + toString(max_bytes) + ".",
-                    ErrorCodes::SET_SIZE_LIMIT_EXCEEDED);
+            switch (overflow_mode)
+            {
+                case OverflowMode::THROW:
+                    throw Exception("DISTINCT-Set size limit exceeded."
+                        " Rows: " + toString(data.getTotalRowCount()) +
+                        ", limit: " + toString(max_rows) +
+                        ". Bytes: " + toString(data.getTotalByteCount()) +
+                        ", limit: " + toString(max_bytes) + ".",
+                        ErrorCodes::SET_SIZE_LIMIT_EXCEEDED);
 
-            if (overflow_mode == OverflowMode::BREAK)
-                return Block();
+                case OverflowMode::BREAK:
+                    return Block();
 
-            throw Exception("Logical error: unknown overflow mode", ErrorCodes::LOGICAL_ERROR);
+                default:
+                    throw Exception("Logical error: unknown overflow mode", ErrorCodes::LOGICAL_ERROR);
+            }
         }
 
         size_t all_columns = block.columns();
diff --git a/dbms/src/DataStreams/DistinctBlockInputStream.h b/dbms/src/DataStreams/DistinctBlockInputStream.h
index 7120d3e04a9..a422a05e8e3 100644
--- a/dbms/src/DataStreams/DistinctBlockInputStream.h
+++ b/dbms/src/DataStreams/DistinctBlockInputStream.h
@@ -18,7 +18,7 @@ class DistinctBlockInputStream : public IProfilingBlockInputStream
 {
 public:
     /// Empty columns_ means all collumns.
-    DistinctBlockInputStream(const BlockInputStreamPtr & input, const Limits & limits, size_t limit_hint_, Names columns_);
+    DistinctBlockInputStream(const BlockInputStreamPtr & input, const Limits & limits, size_t limit_hint_, const Names & columns);
 
     String getName() const override { return "Distinct"; }
 
diff --git a/dbms/src/DataStreams/DistinctSortedBlockInputStream.cpp b/dbms/src/DataStreams/DistinctSortedBlockInputStream.cpp
index 2c8ab1e1d8e..7afa82fbcff 100644
--- a/dbms/src/DataStreams/DistinctSortedBlockInputStream.cpp
+++ b/dbms/src/DataStreams/DistinctSortedBlockInputStream.cpp
@@ -71,18 +71,22 @@ Block DistinctSortedBlockInputStream::readImpl()
 
         if (!checkLimits())
         {
-            if (overflow_mode == OverflowMode::THROW)
-                throw Exception("DISTINCT-Set size limit exceeded."
-                    " Rows: " + toString(data.getTotalRowCount()) +
-                    ", limit: " + toString(max_rows) +
-                    ". Bytes: " + toString(data.getTotalByteCount()) +
-                    ", limit: " + toString(max_bytes) + ".",
-                    ErrorCodes::SET_SIZE_LIMIT_EXCEEDED);
+            switch (overflow_mode)
+            {
+                case OverflowMode::THROW:
+                    throw Exception("DISTINCT-Set size limit exceeded."
+                        " Rows: " + toString(data.getTotalRowCount()) +
+                        ", limit: " + toString(max_rows) +
+                        ". Bytes: " + toString(data.getTotalByteCount()) +
+                        ", limit: " + toString(max_bytes) + ".",
+                        ErrorCodes::SET_SIZE_LIMIT_EXCEEDED);
 
-            if (overflow_mode == OverflowMode::BREAK)
-                return Block();
+                case OverflowMode::BREAK:
+                    return Block();
 
-            throw Exception("Logical error: unknown overflow mode", ErrorCodes::LOGICAL_ERROR);
+                default:
+                    throw Exception("Logical error: unknown overflow mode", ErrorCodes::LOGICAL_ERROR);
+            }
         }
 
         prev_block.block = block;
diff --git a/dbms/src/DataStreams/ExpressionBlockInputStream.cpp b/dbms/src/DataStreams/ExpressionBlockInputStream.cpp
index 6130df31b51..369150796f7 100644
--- a/dbms/src/DataStreams/ExpressionBlockInputStream.cpp
+++ b/dbms/src/DataStreams/ExpressionBlockInputStream.cpp
@@ -5,7 +5,7 @@
 namespace DB
 {
 
-ExpressionBlockInputStream::ExpressionBlockInputStream(const BlockInputStreamPtr & input, ExpressionActionsPtr expression_)
+ExpressionBlockInputStream::ExpressionBlockInputStream(const BlockInputStreamPtr & input, const ExpressionActionsPtr & expression_)
     : expression(expression_)
 {
     children.push_back(input);
diff --git a/dbms/src/DataStreams/ExpressionBlockInputStream.h b/dbms/src/DataStreams/ExpressionBlockInputStream.h
index c57ea928d54..11d498332a3 100644
--- a/dbms/src/DataStreams/ExpressionBlockInputStream.h
+++ b/dbms/src/DataStreams/ExpressionBlockInputStream.h
@@ -19,7 +19,7 @@ private:
     using ExpressionActionsPtr = std::shared_ptr<ExpressionActions>;
 
 public:
-    ExpressionBlockInputStream(const BlockInputStreamPtr & input, ExpressionActionsPtr expression_);
+    ExpressionBlockInputStream(const BlockInputStreamPtr & input, const ExpressionActionsPtr & expression_);
 
     String getName() const override;
     String getID() const override;
diff --git a/dbms/src/DataStreams/FilterBlockInputStream.cpp b/dbms/src/DataStreams/FilterBlockInputStream.cpp
index be0e9182c08..fa560a79419 100644
--- a/dbms/src/DataStreams/FilterBlockInputStream.cpp
+++ b/dbms/src/DataStreams/FilterBlockInputStream.cpp
@@ -17,13 +17,13 @@ namespace ErrorCodes
 }
 
 
-FilterBlockInputStream::FilterBlockInputStream(const BlockInputStreamPtr & input, ExpressionActionsPtr expression_, ssize_t filter_column_)
+FilterBlockInputStream::FilterBlockInputStream(const BlockInputStreamPtr & input, const ExpressionActionsPtr & expression_, ssize_t filter_column_)
     : expression(expression_), filter_column(filter_column_)
 {
     children.push_back(input);
 }
 
-FilterBlockInputStream::FilterBlockInputStream(const BlockInputStreamPtr & input, ExpressionActionsPtr expression_, const String & filter_column_name_)
+FilterBlockInputStream::FilterBlockInputStream(const BlockInputStreamPtr & input, const ExpressionActionsPtr & expression_, const String & filter_column_name_)
     : expression(expression_), filter_column(-1), filter_column_name(filter_column_name_)
 {
     children.push_back(input);
diff --git a/dbms/src/DataStreams/FilterBlockInputStream.h b/dbms/src/DataStreams/FilterBlockInputStream.h
index 95ade939256..651fab7f514 100644
--- a/dbms/src/DataStreams/FilterBlockInputStream.h
+++ b/dbms/src/DataStreams/FilterBlockInputStream.h
@@ -20,8 +20,8 @@ private:
 
 public:
     /// filter_column_ - the number of the column with filter conditions.
-    FilterBlockInputStream(const BlockInputStreamPtr & input, ExpressionActionsPtr expression_, ssize_t filter_column_);
-    FilterBlockInputStream(const BlockInputStreamPtr & input, ExpressionActionsPtr expression_, const String & filter_column_name_);
+    FilterBlockInputStream(const BlockInputStreamPtr & input, const ExpressionActionsPtr & expression_, ssize_t filter_column_);
+    FilterBlockInputStream(const BlockInputStreamPtr & input, const ExpressionActionsPtr & expression_, const String & filter_column_name_);
 
     String getName() const override;
     String getID() const override;
diff --git a/dbms/src/DataStreams/FilterColumnsBlockInputStream.h b/dbms/src/DataStreams/FilterColumnsBlockInputStream.h
index dabf9ffb7bb..07a9f6bd093 100644
--- a/dbms/src/DataStreams/FilterColumnsBlockInputStream.h
+++ b/dbms/src/DataStreams/FilterColumnsBlockInputStream.h
@@ -13,10 +13,10 @@ class FilterColumnsBlockInputStream : public IProfilingBlockInputStream
 {
 public:
     FilterColumnsBlockInputStream(
-        BlockInputStreamPtr input_, const Names & columns_to_save_, bool throw_if_column_not_found_)
+        const BlockInputStreamPtr & input, const Names & columns_to_save_, bool throw_if_column_not_found_)
         : columns_to_save(columns_to_save_), throw_if_column_not_found(throw_if_column_not_found_)
     {
-        children.push_back(input_);
+        children.push_back(input);
     }
 
     String getName() const override
diff --git a/dbms/src/DataStreams/IBlockInputStream.cpp b/dbms/src/DataStreams/IBlockInputStream.cpp
index d3c6f06cab9..ac179115678 100644
--- a/dbms/src/DataStreams/IBlockInputStream.cpp
+++ b/dbms/src/DataStreams/IBlockInputStream.cpp
@@ -99,7 +99,7 @@ void IBlockInputStream::dumpTree(std::ostream & ostr, size_t indent, size_t mult
 BlockInputStreams IBlockInputStream::getLeaves()
 {
     BlockInputStreams res;
-    getLeavesImpl(res);
+    getLeavesImpl(res, nullptr);
     return res;
 }
 
@@ -122,7 +122,7 @@ void IBlockInputStream::getLeafRowsBytes(size_t & rows, size_t & bytes)
 }
 
 
-void IBlockInputStream::getLeavesImpl(BlockInputStreams & res, BlockInputStreamPtr this_shared_ptr)
+void IBlockInputStream::getLeavesImpl(BlockInputStreams & res, const BlockInputStreamPtr & this_shared_ptr)
 {
     if (children.empty())
     {
diff --git a/dbms/src/DataStreams/IBlockInputStream.h b/dbms/src/DataStreams/IBlockInputStream.h
index 68490b9be2b..fccccbd67e6 100644
--- a/dbms/src/DataStreams/IBlockInputStream.h
+++ b/dbms/src/DataStreams/IBlockInputStream.h
@@ -113,7 +113,7 @@ protected:
     BlockInputStreams children;
 
 private:
-    void getLeavesImpl(BlockInputStreams & res, BlockInputStreamPtr this_shared_ptr = nullptr);
+    void getLeavesImpl(BlockInputStreams & res, const BlockInputStreamPtr & this_shared_ptr);
 
     size_t checkDepthImpl(size_t max_depth, size_t level) const;
 
diff --git a/dbms/src/DataStreams/IProfilingBlockInputStream.cpp b/dbms/src/DataStreams/IProfilingBlockInputStream.cpp
index 2c3e6603bf1..1b10f4899d7 100644
--- a/dbms/src/DataStreams/IProfilingBlockInputStream.cpp
+++ b/dbms/src/DataStreams/IProfilingBlockInputStream.cpp
@@ -142,53 +142,45 @@ void IProfilingBlockInputStream::updateExtremes(Block & block)
 
 bool IProfilingBlockInputStream::checkLimits()
 {
+    auto handle_overflow_mode = [this] (OverflowMode mode, const String & message, int code)
+    {
+        switch (mode)
+        {
+            case OverflowMode::THROW:
+                throw Exception(message, code);
+            case OverflowMode::BREAK:
+                return false;
+            default:
+                throw Exception("Logical error: unknown overflow mode", ErrorCodes::LOGICAL_ERROR);
+        }
+    };
+
     if (limits.mode == LIMITS_CURRENT)
     {
         /// Check current stream limitations (i.e. max_result_{rows,bytes})
 
         if (limits.max_rows_to_read && info.rows > limits.max_rows_to_read)
-        {
-            if (limits.read_overflow_mode == OverflowMode::THROW)
-                throw Exception(std::string("Limit for result rows")
+            return handle_overflow_mode(limits.read_overflow_mode,
+                std::string("Limit for result rows")
                     + " exceeded: read " + toString(info.rows)
                     + " rows, maximum: " + toString(limits.max_rows_to_read),
-                    ErrorCodes::TOO_MUCH_ROWS);
-
-            if (limits.read_overflow_mode == OverflowMode::BREAK)
-                return false;
-
-            throw Exception("Logical error: unknown overflow mode", ErrorCodes::LOGICAL_ERROR);
-        }
+                ErrorCodes::TOO_MUCH_ROWS);
 
         if (limits.max_bytes_to_read && info.bytes > limits.max_bytes_to_read)
-        {
-            if (limits.read_overflow_mode == OverflowMode::THROW)
-                throw Exception(std::string("Limit for result bytes (uncompressed)")
+            return handle_overflow_mode(limits.read_overflow_mode,
+                std::string("Limit for result bytes (uncompressed)")
                     + " exceeded: read " + toString(info.bytes)
                     + " bytes, maximum: " + toString(limits.max_bytes_to_read),
-                    ErrorCodes::TOO_MUCH_BYTES);
-
-            if (limits.read_overflow_mode == OverflowMode::BREAK)
-                return false;
-
-            throw Exception("Logical error: unknown overflow mode", ErrorCodes::LOGICAL_ERROR);
-        }
+                ErrorCodes::TOO_MUCH_BYTES);
     }
 
     if (limits.max_execution_time != 0
         && info.total_stopwatch.elapsed() > static_cast<UInt64>(limits.max_execution_time.totalMicroseconds()) * 1000)
-    {
-        if (limits.timeout_overflow_mode == OverflowMode::THROW)
-            throw Exception("Timeout exceeded: elapsed " + toString(info.total_stopwatch.elapsedSeconds())
+        return handle_overflow_mode(limits.timeout_overflow_mode,
+            "Timeout exceeded: elapsed " + toString(info.total_stopwatch.elapsedSeconds())
                 + " seconds, maximum: " + toString(limits.max_execution_time.totalMicroseconds() / 1000000.0),
             ErrorCodes::TIMEOUT_EXCEEDED);
 
-        if (limits.timeout_overflow_mode == OverflowMode::BREAK)
-            return false;
-
-        throw Exception("Logical error: unknown overflow mode", ErrorCodes::LOGICAL_ERROR);
-    }
-
     return true;
 }
 
@@ -244,28 +236,36 @@ void IProfilingBlockInputStream::progressImpl(const Progress & value)
             && ((limits.max_rows_to_read && total_rows_estimate > limits.max_rows_to_read)
                 || (limits.max_bytes_to_read && bytes_processed > limits.max_bytes_to_read)))
         {
-            if (limits.read_overflow_mode == OverflowMode::THROW)
+            switch (limits.read_overflow_mode)
             {
-                if (limits.max_rows_to_read && total_rows_estimate > limits.max_rows_to_read)
-                    throw Exception("Limit for rows to read exceeded: " + toString(total_rows_estimate)
-                        + " rows read (or to read), maximum: " + toString(limits.max_rows_to_read),
-                        ErrorCodes::TOO_MUCH_ROWS);
-                else
-                    throw Exception("Limit for (uncompressed) bytes to read exceeded: " + toString(bytes_processed)
-                        + " bytes read, maximum: " + toString(limits.max_bytes_to_read),
-                        ErrorCodes::TOO_MUCH_BYTES);
-            }
-            else if (limits.read_overflow_mode == OverflowMode::BREAK)
-            {
-                /// For `break`, we will stop only if so many lines were actually read, and not just supposed to be read.
-                if ((limits.max_rows_to_read && rows_processed > limits.max_rows_to_read)
-                    || (limits.max_bytes_to_read && bytes_processed > limits.max_bytes_to_read))
+                case OverflowMode::THROW:
                 {
-                    cancel();
+                    if (limits.max_rows_to_read && total_rows_estimate > limits.max_rows_to_read)
+                        throw Exception("Limit for rows to read exceeded: " + toString(total_rows_estimate)
+                            + " rows read (or to read), maximum: " + toString(limits.max_rows_to_read),
+                            ErrorCodes::TOO_MUCH_ROWS);
+                    else
+                        throw Exception("Limit for (uncompressed) bytes to read exceeded: " + toString(bytes_processed)
+                            + " bytes read, maximum: " + toString(limits.max_bytes_to_read),
+                            ErrorCodes::TOO_MUCH_BYTES);
+                    break;
                 }
+
+                case OverflowMode::BREAK:
+                {
+                    /// For `break`, we will stop only if so many lines were actually read, and not just supposed to be read.
+                    if ((limits.max_rows_to_read && rows_processed > limits.max_rows_to_read)
+                        || (limits.max_bytes_to_read && bytes_processed > limits.max_bytes_to_read))
+                    {
+                        cancel();
+                    }
+
+                    break;
+                }
+
+                default:
+                    throw Exception("Logical error: unknown overflow mode", ErrorCodes::LOGICAL_ERROR);
             }
-            else
-                throw Exception("Logical error: unknown overflow mode", ErrorCodes::LOGICAL_ERROR);
         }
 
         size_t total_rows = process_list_elem->progress_in.total_rows;
@@ -317,7 +317,7 @@ void IProfilingBlockInputStream::cancel()
 }
 
 
-void IProfilingBlockInputStream::setProgressCallback(ProgressCallback callback)
+void IProfilingBlockInputStream::setProgressCallback(const ProgressCallback & callback)
 {
     progress_callback = callback;
 
diff --git a/dbms/src/DataStreams/IProfilingBlockInputStream.h b/dbms/src/DataStreams/IProfilingBlockInputStream.h
index a5a2b043a51..8fa9eb6731b 100644
--- a/dbms/src/DataStreams/IProfilingBlockInputStream.h
+++ b/dbms/src/DataStreams/IProfilingBlockInputStream.h
@@ -69,7 +69,7 @@ public:
       * The function takes the number of rows in the last block, the number of bytes in the last block.
       * Note that the callback can be called from different threads.
       */
-    void setProgressCallback(ProgressCallback callback);
+    void setProgressCallback(const ProgressCallback & callback);
 
 
     /** In this method:
diff --git a/dbms/src/DataStreams/LimitByBlockInputStream.cpp b/dbms/src/DataStreams/LimitByBlockInputStream.cpp
index 6182dd3413b..ba25c1b93a6 100644
--- a/dbms/src/DataStreams/LimitByBlockInputStream.cpp
+++ b/dbms/src/DataStreams/LimitByBlockInputStream.cpp
@@ -3,8 +3,8 @@
 namespace DB
 {
 
-LimitByBlockInputStream::LimitByBlockInputStream(const BlockInputStreamPtr & input, size_t group_size_, Names columns_)
-    : columns_names(columns_)
+LimitByBlockInputStream::LimitByBlockInputStream(const BlockInputStreamPtr & input, size_t group_size_, const Names & columns)
+    : columns_names(columns)
     , group_size(group_size_)
 {
     children.push_back(input);
diff --git a/dbms/src/DataStreams/LimitByBlockInputStream.h b/dbms/src/DataStreams/LimitByBlockInputStream.h
index 54874d37f1e..96aea7092d1 100644
--- a/dbms/src/DataStreams/LimitByBlockInputStream.h
+++ b/dbms/src/DataStreams/LimitByBlockInputStream.h
@@ -18,7 +18,7 @@ namespace DB
 class LimitByBlockInputStream : public IProfilingBlockInputStream
 {
 public:
-    LimitByBlockInputStream(const BlockInputStreamPtr & input, size_t group_size_, Names columns_);
+    LimitByBlockInputStream(const BlockInputStreamPtr & input, size_t group_size_, const Names & columns);
 
     String getName() const override { return "LimitBy"; }
 
diff --git a/dbms/src/DataStreams/MergingAggregatedMemoryEfficientBlockInputStream.h b/dbms/src/DataStreams/MergingAggregatedMemoryEfficientBlockInputStream.h
index 1b1de6f90af..f1300ee12af 100644
--- a/dbms/src/DataStreams/MergingAggregatedMemoryEfficientBlockInputStream.h
+++ b/dbms/src/DataStreams/MergingAggregatedMemoryEfficientBlockInputStream.h
@@ -56,7 +56,7 @@ namespace DB
   *  data from sources can also be read in several threads (reading_threads)
   *  for optimal performance in the presence of a fast network or disks (from where these blocks are read).
   */
-class MergingAggregatedMemoryEfficientBlockInputStream : public IProfilingBlockInputStream
+class MergingAggregatedMemoryEfficientBlockInputStream final : public IProfilingBlockInputStream
 {
 public:
     MergingAggregatedMemoryEfficientBlockInputStream(
@@ -137,7 +137,7 @@ private:
         std::exception_ptr exception;
         /// It is necessary to give out blocks in the order of the key (bucket_num).
         /// If the value is an empty block, you need to wait for its merge.
-        /// (This means the promise that there will be data here, which is important because the data should be given out 
+        /// (This means the promise that there will be data here, which is important because the data should be given out
         /// in the order of the key - bucket_num)
         std::map<int, Block> merged_blocks;
         std::mutex merged_blocks_mutex;
diff --git a/dbms/src/DataStreams/TotalsHavingBlockInputStream.cpp b/dbms/src/DataStreams/TotalsHavingBlockInputStream.cpp
index c6e0dcb1a8e..fcc80071aba 100644
--- a/dbms/src/DataStreams/TotalsHavingBlockInputStream.cpp
+++ b/dbms/src/DataStreams/TotalsHavingBlockInputStream.cpp
@@ -16,8 +16,8 @@ namespace ErrorCodes
 
 
 TotalsHavingBlockInputStream::TotalsHavingBlockInputStream(
-    BlockInputStreamPtr input_,
-    bool overflow_row_, ExpressionActionsPtr expression_,
+    const BlockInputStreamPtr & input_,
+    bool overflow_row_, const ExpressionActionsPtr & expression_,
     const std::string & filter_column_, TotalsMode totals_mode_, double auto_include_threshold_)
     : overflow_row(overflow_row_),
     expression(expression_), filter_column_name(filter_column_), totals_mode(totals_mode_),
diff --git a/dbms/src/DataStreams/TotalsHavingBlockInputStream.h b/dbms/src/DataStreams/TotalsHavingBlockInputStream.h
index 42137947427..e2e79ee2b03 100644
--- a/dbms/src/DataStreams/TotalsHavingBlockInputStream.h
+++ b/dbms/src/DataStreams/TotalsHavingBlockInputStream.h
@@ -20,8 +20,8 @@ private:
 
 public:
     TotalsHavingBlockInputStream(
-        BlockInputStreamPtr input_,
-        bool overflow_row_, ExpressionActionsPtr expression_,
+        const BlockInputStreamPtr & input_,
+        bool overflow_row_, const ExpressionActionsPtr & expression_,
         const std::string & filter_column_, TotalsMode totals_mode_, double auto_include_threshold_);
 
     String getName() const override { return "TotalsHaving"; }
diff --git a/dbms/src/DataTypes/DataTypeArray.cpp b/dbms/src/DataTypes/DataTypeArray.cpp
index fb13f6bab1e..f725bdad42b 100644
--- a/dbms/src/DataTypes/DataTypeArray.cpp
+++ b/dbms/src/DataTypes/DataTypeArray.cpp
@@ -29,13 +29,13 @@ namespace ErrorCodes
 }
 
 
-DataTypeArray::DataTypeArray(DataTypePtr nested_)
+DataTypeArray::DataTypeArray(const DataTypePtr & nested_)
     : enriched_nested(std::make_pair(nested_, std::make_shared<DataTypeVoid>())), nested{nested_}
 {
     offsets = std::make_shared<DataTypeNumber<ColumnArray::Offset_t>>();
 }
 
-DataTypeArray::DataTypeArray(DataTypeTraits::EnrichedDataTypePtr enriched_nested_)
+DataTypeArray::DataTypeArray(const DataTypeTraits::EnrichedDataTypePtr & enriched_nested_)
     : enriched_nested{enriched_nested_}, nested{enriched_nested.first}
 {
     offsets = std::make_shared<DataTypeNumber<ColumnArray::Offset_t>>();
diff --git a/dbms/src/DataTypes/DataTypeArray.h b/dbms/src/DataTypes/DataTypeArray.h
index 423d27e1889..012d73fb3f5 100644
--- a/dbms/src/DataTypes/DataTypeArray.h
+++ b/dbms/src/DataTypes/DataTypeArray.h
@@ -19,8 +19,8 @@ private:
     DataTypePtr offsets;
 
 public:
-    DataTypeArray(DataTypePtr nested_);
-    DataTypeArray(DataTypeTraits::EnrichedDataTypePtr enriched_nested_);
+    DataTypeArray(const DataTypePtr & nested_);
+    DataTypeArray(const DataTypeTraits::EnrichedDataTypePtr & enriched_nested_);
 
     std::string getName() const override
     {
diff --git a/dbms/src/DataTypes/DataTypeExpression.h b/dbms/src/DataTypes/DataTypeExpression.h
index d9f1bbe7598..5bf0752217f 100644
--- a/dbms/src/DataTypes/DataTypeExpression.h
+++ b/dbms/src/DataTypes/DataTypeExpression.h
@@ -16,7 +16,7 @@ private:
 
 public:
     /// Some types could be still unknown.
-    DataTypeExpression(DataTypes argument_types_ = DataTypes(), DataTypePtr return_type_ = nullptr)
+    DataTypeExpression(const DataTypes & argument_types_ = DataTypes(), const DataTypePtr & return_type_ = nullptr)
         : argument_types(argument_types_), return_type(return_type_) {}
 
     std::string getName() const override;
diff --git a/dbms/src/DataTypes/DataTypeNested.cpp b/dbms/src/DataTypes/DataTypeNested.cpp
index bf81432198b..4f51b302048 100644
--- a/dbms/src/DataTypes/DataTypeNested.cpp
+++ b/dbms/src/DataTypes/DataTypeNested.cpp
@@ -22,7 +22,7 @@ namespace ErrorCodes
 }
 
 
-DataTypeNested::DataTypeNested(NamesAndTypesListPtr nested_)
+DataTypeNested::DataTypeNested(const NamesAndTypesListPtr & nested_)
     : nested(nested_)
 {
 }
diff --git a/dbms/src/DataTypes/DataTypeNested.h b/dbms/src/DataTypes/DataTypeNested.h
index 0af35a7912e..b086450b4ef 100644
--- a/dbms/src/DataTypes/DataTypeNested.h
+++ b/dbms/src/DataTypes/DataTypeNested.h
@@ -17,7 +17,7 @@ private:
     NamesAndTypesListPtr nested;
 
 public:
-    DataTypeNested(NamesAndTypesListPtr nested_);
+    DataTypeNested(const NamesAndTypesListPtr & nested_);
 
     std::string getName() const override;
     const char * getFamilyName() const override { return "Nested"; }
diff --git a/dbms/src/DataTypes/DataTypeNullable.cpp b/dbms/src/DataTypes/DataTypeNullable.cpp
index d26462c4721..40fb3ba77c7 100644
--- a/dbms/src/DataTypes/DataTypeNullable.cpp
+++ b/dbms/src/DataTypes/DataTypeNullable.cpp
@@ -21,7 +21,7 @@ namespace ErrorCodes
 }
 
 
-DataTypeNullable::DataTypeNullable(DataTypePtr nested_data_type_)
+DataTypeNullable::DataTypeNullable(const DataTypePtr & nested_data_type_)
     : nested_data_type{nested_data_type_}
 {
     if (!nested_data_type->canBeInsideNullable())
diff --git a/dbms/src/DataTypes/DataTypeNullable.h b/dbms/src/DataTypes/DataTypeNullable.h
index 07e9dd8a9fa..4f1fdf902bc 100644
--- a/dbms/src/DataTypes/DataTypeNullable.h
+++ b/dbms/src/DataTypes/DataTypeNullable.h
@@ -11,7 +11,7 @@ namespace DB
 class DataTypeNullable final : public IDataType
 {
 public:
-    DataTypeNullable(DataTypePtr nested_data_type_);
+    DataTypeNullable(const DataTypePtr & nested_data_type_);
     std::string getName() const override { return "Nullable(" + nested_data_type->getName() + ")"; }
     const char * getFamilyName() const override { return "Nullable"; }
     bool isNullable() const override { return true; }
diff --git a/dbms/src/DataTypes/DataTypeTuple.h b/dbms/src/DataTypes/DataTypeTuple.h
index 10813276057..498e246a6e6 100644
--- a/dbms/src/DataTypes/DataTypeTuple.h
+++ b/dbms/src/DataTypes/DataTypeTuple.h
@@ -16,7 +16,7 @@ class DataTypeTuple final : public IDataType
 private:
     DataTypes elems;
 public:
-    DataTypeTuple(DataTypes elems_) : elems(elems_) {}
+    DataTypeTuple(const DataTypes & elems_) : elems(elems_) {}
 
     std::string getName() const override;
     const char * getFamilyName() const override { return "Tuple"; }
diff --git a/dbms/src/Dictionaries/DictionaryBlockInputStream.h b/dbms/src/Dictionaries/DictionaryBlockInputStream.h
index 1d80b32c65a..a2f3fb31584 100644
--- a/dbms/src/Dictionaries/DictionaryBlockInputStream.h
+++ b/dbms/src/Dictionaries/DictionaryBlockInputStream.h
@@ -250,7 +250,7 @@ Block DictionaryBlockInputStream<DictionaryType, Key>::fillBlock(
     data_types.reserve(keys.size());
     const DictionaryStructure& dictionaty_structure = dictionary->getStructure();
     if (data_types.empty() && dictionaty_structure.key)
-        for (const auto key : *dictionaty_structure.key)
+        for (const auto & key : *dictionaty_structure.key)
             data_types.push_back(key.type);
 
     for (const auto & column : view)
diff --git a/dbms/src/Dictionaries/DictionaryStructure.cpp b/dbms/src/Dictionaries/DictionaryStructure.cpp
index 8c8ce000b6e..f96c0f9262b 100644
--- a/dbms/src/Dictionaries/DictionaryStructure.cpp
+++ b/dbms/src/Dictionaries/DictionaryStructure.cpp
@@ -220,7 +220,7 @@ bool DictionaryStructure::isKeySizeFixed() const
     if (!key)
         return true;
 
-    for (const auto key_i : * key)
+    for (const auto & key_i : *key)
         if (key_i.underlying_type == AttributeUnderlyingType::String)
             return false;
 
diff --git a/dbms/src/Dictionaries/ExecutableDictionarySource.cpp b/dbms/src/Dictionaries/ExecutableDictionarySource.cpp
index c34a189a31e..a3a3c40ba65 100644
--- a/dbms/src/Dictionaries/ExecutableDictionarySource.cpp
+++ b/dbms/src/Dictionaries/ExecutableDictionarySource.cpp
@@ -54,7 +54,7 @@ BlockInputStreamPtr ExecutableDictionarySource::loadAll()
 /** A stream, that also runs and waits for background thread
   * (that will feed data into pipe to be read from the other side of the pipe).
   */
-class BlockInputStreamWithBackgroundThread : public IProfilingBlockInputStream
+class BlockInputStreamWithBackgroundThread final : public IProfilingBlockInputStream
 {
 public:
     BlockInputStreamWithBackgroundThread(
diff --git a/dbms/src/Dictionaries/FlatDictionary.cpp b/dbms/src/Dictionaries/FlatDictionary.cpp
index d851d484757..973defc855f 100644
--- a/dbms/src/Dictionaries/FlatDictionary.cpp
+++ b/dbms/src/Dictionaries/FlatDictionary.cpp
@@ -366,7 +366,7 @@ void FlatDictionary::createAttributeImpl<String>(Attribute & attribute, const Fi
 {
     attribute.string_arena = std::make_unique<Arena>();
     auto & null_value_ref = std::get<StringRef>(attribute.null_values);
-    const String string = null_value.get<typename NearestFieldType<String>::Type>();
+    const String & string = null_value.get<typename NearestFieldType<String>::Type>();
     const auto string_in_arena = attribute.string_arena->insert(string.data(), string.size());
     null_value_ref = StringRef{string_in_arena, string.size()};
     std::get<ContainerPtrType<StringRef>>(attribute.arrays) =
diff --git a/dbms/src/Interpreters/Aggregator.cpp b/dbms/src/Interpreters/Aggregator.cpp
index be4badb2af0..e4f544a3b05 100644
--- a/dbms/src/Interpreters/Aggregator.cpp
+++ b/dbms/src/Interpreters/Aggregator.cpp
@@ -1018,16 +1018,20 @@ bool Aggregator::checkLimits(size_t result_size, bool & no_more_keys) const
 {
     if (!no_more_keys && params.max_rows_to_group_by && result_size > params.max_rows_to_group_by)
     {
-        if (params.group_by_overflow_mode == OverflowMode::THROW)
-            throw Exception("Limit for rows to GROUP BY exceeded: has " + toString(result_size)
-                + " rows, maximum: " + toString(params.max_rows_to_group_by),
-                ErrorCodes::TOO_MUCH_ROWS);
-        else if (params.group_by_overflow_mode == OverflowMode::BREAK)
-            return false;
-        else if (params.group_by_overflow_mode == OverflowMode::ANY)
-            no_more_keys = true;
-        else
-            throw Exception("Logical error: unknown overflow mode", ErrorCodes::LOGICAL_ERROR);
+        switch (params.group_by_overflow_mode)
+        {
+            case OverflowMode::THROW:
+                throw Exception("Limit for rows to GROUP BY exceeded: has " + toString(result_size)
+                    + " rows, maximum: " + toString(params.max_rows_to_group_by),
+                    ErrorCodes::TOO_MUCH_ROWS);
+
+            case OverflowMode::BREAK:
+                return false;
+
+            case OverflowMode::ANY:
+                no_more_keys = true;
+                break;
+        }
     }
 
     return true;
diff --git a/dbms/src/Interpreters/Compiler.cpp b/dbms/src/Interpreters/Compiler.cpp
index e798c8add55..c6283ebf8d3 100644
--- a/dbms/src/Interpreters/Compiler.cpp
+++ b/dbms/src/Interpreters/Compiler.cpp
@@ -37,7 +37,7 @@ Compiler::Compiler(const std::string & path_, size_t threads)
     Poco::DirectoryIterator dir_end;
     for (Poco::DirectoryIterator dir_it(path); dir_end != dir_it; ++dir_it)
     {
-        std::string name = dir_it.name();
+        const std::string & name = dir_it.name();
         if (endsWith(name, ".so"))
         {
             files.insert(name.substr(0, name.size() - 3));
diff --git a/dbms/src/Interpreters/Context.cpp b/dbms/src/Interpreters/Context.cpp
index 06900b87037..a2812495c69 100644
--- a/dbms/src/Interpreters/Context.cpp
+++ b/dbms/src/Interpreters/Context.cpp
@@ -770,7 +770,7 @@ StoragePtr Context::getTableImpl(const String & database_name, const String & ta
 }
 
 
-void Context::addExternalTable(const String & table_name, StoragePtr storage)
+void Context::addExternalTable(const String & table_name, const StoragePtr & storage)
 {
     if (external_tables.end() != external_tables.find(table_name))
         throw Exception("Temporary table " + table_name + " already exists.", ErrorCodes::TABLE_ALREADY_EXISTS);
@@ -1217,7 +1217,7 @@ void Context::setZooKeeper(zkutil::ZooKeeperPtr zookeeper)
     if (shared->zookeeper)
         throw Exception("ZooKeeper client has already been set.", ErrorCodes::LOGICAL_ERROR);
 
-    shared->zookeeper = zookeeper;
+    shared->zookeeper = std::move(zookeeper);
 }
 
 zkutil::ZooKeeperPtr Context::getZooKeeper() const
diff --git a/dbms/src/Interpreters/Context.h b/dbms/src/Interpreters/Context.h
index 33087ff71b0..8795c5a9799 100644
--- a/dbms/src/Interpreters/Context.h
+++ b/dbms/src/Interpreters/Context.h
@@ -173,7 +173,7 @@ public:
     StoragePtr tryGetExternalTable(const String & table_name) const;
     StoragePtr getTable(const String & database_name, const String & table_name) const;
     StoragePtr tryGetTable(const String & database_name, const String & table_name) const;
-    void addExternalTable(const String & table_name, StoragePtr storage);
+    void addExternalTable(const String & table_name, const StoragePtr & storage);
     StoragePtr tryRemoveExternalTable(const String & table_name);
 
     void addDatabase(const String & database_name, const DatabasePtr & database);
diff --git a/dbms/src/Interpreters/ExpressionActions.h b/dbms/src/Interpreters/ExpressionActions.h
index 84556ded0c2..cbeab9f8d5d 100644
--- a/dbms/src/Interpreters/ExpressionActions.h
+++ b/dbms/src/Interpreters/ExpressionActions.h
@@ -237,7 +237,7 @@ struct ExpressionActionsChain
         ExpressionActionsPtr actions;
         Names required_output;
 
-        Step(ExpressionActionsPtr actions_ = nullptr, Names required_output_ = Names())
+        Step(const ExpressionActionsPtr & actions_ = nullptr, const Names & required_output_ = Names())
             : actions(actions_), required_output(required_output_) {}
     };
 
diff --git a/dbms/src/Interpreters/ExpressionAnalyzer.cpp b/dbms/src/Interpreters/ExpressionAnalyzer.cpp
index e3cafeb0e3e..bdfaf4f6713 100644
--- a/dbms/src/Interpreters/ExpressionAnalyzer.cpp
+++ b/dbms/src/Interpreters/ExpressionAnalyzer.cpp
@@ -153,7 +153,7 @@ void removeDuplicateColumns(NamesAndTypesList & columns)
 ExpressionAnalyzer::ExpressionAnalyzer(
     const ASTPtr & ast_,
     const Context & context_,
-    StoragePtr storage_,
+    const StoragePtr & storage_,
     const NamesAndTypesList & columns_,
     size_t subquery_depth_,
     bool do_global_)
@@ -1853,7 +1853,7 @@ struct ExpressionAnalyzer::ScopeStack
 };
 
 
-void ExpressionAnalyzer::getRootActions(ASTPtr ast, bool no_subqueries, bool only_consts, ExpressionActionsPtr & actions)
+void ExpressionAnalyzer::getRootActions(const ASTPtr & ast, bool no_subqueries, bool only_consts, ExpressionActionsPtr & actions)
 {
     ScopeStack scopes(actions, settings);
     getActionsImpl(ast, no_subqueries, only_consts, scopes);
@@ -1919,7 +1919,7 @@ void ExpressionAnalyzer::getArrayJoinedColumns()
 
 
 /// Fills the array_join_result_to_source: on which columns-arrays to replicate, and how to call them after that.
-void ExpressionAnalyzer::getArrayJoinedColumnsImpl(ASTPtr ast)
+void ExpressionAnalyzer::getArrayJoinedColumnsImpl(const ASTPtr & ast)
 {
     if (typeid_cast<ASTTablesInSelectQuery *>(ast.get()))
         return;
@@ -1973,7 +1973,7 @@ void ExpressionAnalyzer::getArrayJoinedColumnsImpl(ASTPtr ast)
 }
 
 
-void ExpressionAnalyzer::getActionsImpl(ASTPtr ast, bool no_subqueries, bool only_consts, ScopeStack & actions_stack)
+void ExpressionAnalyzer::getActionsImpl(const ASTPtr & ast, bool no_subqueries, bool only_consts, ScopeStack & actions_stack)
 {
     /// If the result of the calculation already exists in the block.
     if ((typeid_cast<ASTFunction *>(ast.get()) || typeid_cast<ASTLiteral *>(ast.get()))
@@ -2615,7 +2615,7 @@ Block ExpressionAnalyzer::getSelectSampleBlock()
     return temp_actions->getSampleBlock();
 }
 
-void ExpressionAnalyzer::getActionsBeforeAggregation(ASTPtr ast, ExpressionActionsPtr & actions, bool no_subqueries)
+void ExpressionAnalyzer::getActionsBeforeAggregation(const ASTPtr & ast, ExpressionActionsPtr & actions, bool no_subqueries)
 {
     ASTFunction * node = typeid_cast<ASTFunction *>(ast.get());
 
@@ -2848,7 +2848,7 @@ Names ExpressionAnalyzer::getRequiredColumns()
 }
 
 
-void ExpressionAnalyzer::getRequiredColumnsImpl(ASTPtr ast,
+void ExpressionAnalyzer::getRequiredColumnsImpl(const ASTPtr & ast,
     NameSet & required_columns, NameSet & ignored_names,
     const NameSet & available_joined_columns, NameSet & required_joined_columns)
 {
diff --git a/dbms/src/Interpreters/ExpressionAnalyzer.h b/dbms/src/Interpreters/ExpressionAnalyzer.h
index 44b5b6d78ee..52ebbb91d3a 100644
--- a/dbms/src/Interpreters/ExpressionAnalyzer.h
+++ b/dbms/src/Interpreters/ExpressionAnalyzer.h
@@ -69,7 +69,7 @@ public:
     ExpressionAnalyzer(
         const ASTPtr & ast_,
         const Context & context_,
-        StoragePtr storage_,
+        const StoragePtr & storage_,
         const NamesAndTypesList & columns_,
         size_t subquery_depth_ = 0,
         bool do_global_ = false);
@@ -269,17 +269,17 @@ private:
     void addExternalStorage(ASTPtr & subquery_or_table_name);
 
     void getArrayJoinedColumns();
-    void getArrayJoinedColumnsImpl(ASTPtr ast);
+    void getArrayJoinedColumnsImpl(const ASTPtr & ast);
     void addMultipleArrayJoinAction(ExpressionActionsPtr & actions) const;
 
     void addJoinAction(ExpressionActionsPtr & actions, bool only_types) const;
 
     struct ScopeStack;
-    void getActionsImpl(ASTPtr ast, bool no_subqueries, bool only_consts, ScopeStack & actions_stack);
+    void getActionsImpl(const ASTPtr & ast, bool no_subqueries, bool only_consts, ScopeStack & actions_stack);
 
-    void getRootActions(ASTPtr ast, bool no_subqueries, bool only_consts, ExpressionActionsPtr & actions);
+    void getRootActions(const ASTPtr & ast, bool no_subqueries, bool only_consts, ExpressionActionsPtr & actions);
 
-    void getActionsBeforeAggregation(ASTPtr ast, ExpressionActionsPtr & actions, bool no_subqueries);
+    void getActionsBeforeAggregation(const ASTPtr & ast, ExpressionActionsPtr & actions, bool no_subqueries);
 
     /** Add aggregation keys to aggregation_keys, aggregate functions to aggregate_descriptions,
       * Create a set of columns aggregated_columns resulting after the aggregation, if any,
@@ -295,7 +295,7 @@ private:
       * The set of columns available_joined_columns are the columns available from JOIN, they are not needed for reading from the main table.
       * Put in required_joined_columns the set of columns available from JOIN and needed.
       */
-    void getRequiredColumnsImpl(ASTPtr ast,
+    void getRequiredColumnsImpl(const ASTPtr & ast,
         NameSet & required_columns, NameSet & ignored_names,
         const NameSet & available_joined_columns, NameSet & required_joined_columns);
 
diff --git a/dbms/src/Interpreters/InterpreterSelectQuery.cpp b/dbms/src/Interpreters/InterpreterSelectQuery.cpp
index da2a9e2e0d4..dcbb35424db 100644
--- a/dbms/src/Interpreters/InterpreterSelectQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterSelectQuery.cpp
@@ -167,7 +167,7 @@ void InterpreterSelectQuery::basicInit(const BlockInputStreamPtr & input)
     query_analyzer = std::make_unique<ExpressionAnalyzer>(query_ptr, context, storage, table_column_names, subquery_depth, !only_analyze);
 
     /// Save the new temporary tables in the query context
-    for (auto & it : query_analyzer->getExternalTables())
+    for (const auto & it : query_analyzer->getExternalTables())
         if (!context.tryGetExternalTable(it.first))
             context.addExternalTable(it.first, it.second);
 
diff --git a/dbms/src/Interpreters/Join.cpp b/dbms/src/Interpreters/Join.cpp
index a7139fe68b1..28f43d6d213 100644
--- a/dbms/src/Interpreters/Join.cpp
+++ b/dbms/src/Interpreters/Join.cpp
@@ -525,18 +525,22 @@ bool Join::insertFromBlock(const Block & block)
 
     if (!checkSizeLimits())
     {
-        if (overflow_mode == OverflowMode::THROW)
-            throw Exception("Join size limit exceeded."
-                " Rows: " + toString(getTotalRowCount()) +
-                ", limit: " + toString(max_rows) +
-                ". Bytes: " + toString(getTotalByteCount()) +
-                ", limit: " + toString(max_bytes) + ".",
-                ErrorCodes::SET_SIZE_LIMIT_EXCEEDED);
+        switch (overflow_mode)
+        {
+            case OverflowMode::THROW:
+                throw Exception("Join size limit exceeded."
+                    " Rows: " + toString(getTotalRowCount()) +
+                    ", limit: " + toString(max_rows) +
+                    ". Bytes: " + toString(getTotalByteCount()) +
+                    ", limit: " + toString(max_bytes) + ".",
+                    ErrorCodes::SET_SIZE_LIMIT_EXCEEDED);
 
-        if (overflow_mode == OverflowMode::BREAK)
-            return false;
+            case OverflowMode::BREAK:
+                return false;
 
-        throw Exception("Logical error: unknown overflow mode", ErrorCodes::LOGICAL_ERROR);
+            default:
+                throw Exception("Logical error: unknown overflow mode", ErrorCodes::LOGICAL_ERROR);
+        }
     }
 
     return true;
diff --git a/dbms/src/Interpreters/ProcessList.cpp b/dbms/src/Interpreters/ProcessList.cpp
index afa61220a6d..0c7e0ef0ea0 100644
--- a/dbms/src/Interpreters/ProcessList.cpp
+++ b/dbms/src/Interpreters/ProcessList.cpp
@@ -206,7 +206,7 @@ bool ProcessListElement::tryGetQueryStreams(BlockInputStreamPtr & in, BlockOutpu
 }
 
 
-void ProcessList::addTemporaryTable(ProcessListElement & elem, const String & table_name, StoragePtr storage)
+void ProcessList::addTemporaryTable(ProcessListElement & elem, const String & table_name, const StoragePtr & storage)
 {
     std::lock_guard<std::mutex> lock(mutex);
 
diff --git a/dbms/src/Interpreters/ProcessList.h b/dbms/src/Interpreters/ProcessList.h
index c853f4a06bc..6bc31a7ecf5 100644
--- a/dbms/src/Interpreters/ProcessList.h
+++ b/dbms/src/Interpreters/ProcessList.h
@@ -274,7 +274,7 @@ public:
     }
 
     /// Register temporary table. Then it is accessible by query_id and name.
-    void addTemporaryTable(ProcessListElement & elem, const String & table_name, StoragePtr storage);
+    void addTemporaryTable(ProcessListElement & elem, const String & table_name, const StoragePtr & storage);
 
     enum class CancellationCode
     {
diff --git a/dbms/src/Interpreters/Set.cpp b/dbms/src/Interpreters/Set.cpp
index 4939e245f71..d93097c0fc9 100644
--- a/dbms/src/Interpreters/Set.cpp
+++ b/dbms/src/Interpreters/Set.cpp
@@ -181,18 +181,22 @@ bool Set::insertFromBlock(const Block & block, bool create_ordered_set)
 
     if (!checkSetSizeLimits())
     {
-        if (overflow_mode == OverflowMode::THROW)
-            throw Exception("IN-set size exceeded."
-                " Rows: " + toString(data.getTotalRowCount()) +
-                ", limit: " + toString(max_rows) +
-                ". Bytes: " + toString(data.getTotalByteCount()) +
-                ", limit: " + toString(max_bytes) + ".",
-                ErrorCodes::SET_SIZE_LIMIT_EXCEEDED);
+        switch (overflow_mode)
+        {
+            case OverflowMode::THROW:
+                throw Exception("IN-set size exceeded."
+                    " Rows: " + toString(data.getTotalRowCount()) +
+                    ", limit: " + toString(max_rows) +
+                    ". Bytes: " + toString(data.getTotalByteCount()) +
+                    ", limit: " + toString(max_bytes) + ".",
+                    ErrorCodes::SET_SIZE_LIMIT_EXCEEDED);
 
-        if (overflow_mode == OverflowMode::BREAK)
-            return false;
+            case OverflowMode::BREAK:
+                return false;
 
-        throw Exception("Logical error: unknown overflow mode", ErrorCodes::LOGICAL_ERROR);
+            default:
+                throw Exception("Logical error: unknown overflow mode", ErrorCodes::LOGICAL_ERROR);
+        }
     }
 
     return true;
diff --git a/dbms/src/Storages/MergeTree/PKCondition.cpp b/dbms/src/Storages/MergeTree/PKCondition.cpp
index 7eb95b44aab..1e5cef69ef9 100644
--- a/dbms/src/Storages/MergeTree/PKCondition.cpp
+++ b/dbms/src/Storages/MergeTree/PKCondition.cpp
@@ -223,7 +223,7 @@ PKCondition::PKCondition(
     const Context & context,
     const NamesAndTypesList & all_columns,
     const SortDescription & sort_descr_,
-    ExpressionActionsPtr pk_expr_)
+    const ExpressionActionsPtr & pk_expr_)
     : sort_descr(sort_descr_), pk_expr(pk_expr_), prepared_sets(query_info.sets)
 {
     for (size_t i = 0; i < sort_descr.size(); ++i)
diff --git a/dbms/src/Storages/MergeTree/PKCondition.h b/dbms/src/Storages/MergeTree/PKCondition.h
index 5c48df5becc..07deeb2ceaf 100644
--- a/dbms/src/Storages/MergeTree/PKCondition.h
+++ b/dbms/src/Storages/MergeTree/PKCondition.h
@@ -207,7 +207,7 @@ public:
         const Context & context,
         const NamesAndTypesList & all_columns,
         const SortDescription & sort_descr,
-        ExpressionActionsPtr pk_expr);
+        const ExpressionActionsPtr & pk_expr);
 
     /// Whether the condition is feasible in the key range.
     /// left_pk and right_pk must contain all fields in the sort_descr in the appropriate order.

From 8c9ec83a33e3d3174df649be423c2886d170e707 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 07:10:43 +0300
Subject: [PATCH 133/266] Implemented some suggestions from clang-tidy (part 4)
 [#CLICKHOUSE-3301].

---
 dbms/src/Common/tests/compact_array.cpp                 | 3 ---
 dbms/src/DataStreams/CollapsingFinalBlockInputStream.h  | 2 +-
 dbms/src/DataStreams/DistinctSortedBlockInputStream.cpp | 4 ++--
 dbms/src/DataStreams/DistinctSortedBlockInputStream.h   | 2 +-
 dbms/src/DataStreams/IProfilingBlockInputStream.cpp     | 2 +-
 dbms/tests/instructions/clang-tidy.txt                  | 1 +
 6 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/dbms/src/Common/tests/compact_array.cpp b/dbms/src/Common/tests/compact_array.cpp
index e83496514a1..89ed1068abb 100644
--- a/dbms/src/Common/tests/compact_array.cpp
+++ b/dbms/src/Common/tests/compact_array.cpp
@@ -52,9 +52,6 @@ struct Test
             {
                 DB::WriteBufferFromFile wb(filename);
                 wb.write(reinterpret_cast<const char *>(&store), sizeof(store));
-                const unsigned char * p = reinterpret_cast<const unsigned char *>(&store);
-                for (size_t i = 0; i < sizeof(store); ++i)
-                    ++*p;
             }
 
             {
diff --git a/dbms/src/DataStreams/CollapsingFinalBlockInputStream.h b/dbms/src/DataStreams/CollapsingFinalBlockInputStream.h
index 5782742a425..89a87fe41e3 100644
--- a/dbms/src/DataStreams/CollapsingFinalBlockInputStream.h
+++ b/dbms/src/DataStreams/CollapsingFinalBlockInputStream.h
@@ -181,7 +181,7 @@ private:
         size_t pos;
 
         Cursor() {}
-        explicit Cursor(MergingBlockPtr block_, size_t pos_ = 0) : block(block_), pos(pos_) {}
+        explicit Cursor(const MergingBlockPtr & block_, size_t pos_ = 0) : block(block_), pos(pos_) {}
 
         bool operator< (const Cursor & rhs) const
         {
diff --git a/dbms/src/DataStreams/DistinctSortedBlockInputStream.cpp b/dbms/src/DataStreams/DistinctSortedBlockInputStream.cpp
index 7afa82fbcff..166f6c2dd6f 100644
--- a/dbms/src/DataStreams/DistinctSortedBlockInputStream.cpp
+++ b/dbms/src/DataStreams/DistinctSortedBlockInputStream.cpp
@@ -8,9 +8,9 @@ namespace ErrorCodes
     extern const int SET_SIZE_LIMIT_EXCEEDED;
 }
 
-DistinctSortedBlockInputStream::DistinctSortedBlockInputStream(const BlockInputStreamPtr & input, const Limits & limits, size_t limit_hint_, Names columns_)
+DistinctSortedBlockInputStream::DistinctSortedBlockInputStream(const BlockInputStreamPtr & input, const Limits & limits, size_t limit_hint_, const Names & columns)
     : description(input->getSortDescription())
-    , columns_names(columns_)
+    , columns_names(columns)
     , limit_hint(limit_hint_)
     , max_rows(limits.max_rows_in_distinct)
     , max_bytes(limits.max_bytes_in_distinct)
diff --git a/dbms/src/DataStreams/DistinctSortedBlockInputStream.h b/dbms/src/DataStreams/DistinctSortedBlockInputStream.h
index 28601f4bb04..dae1e489e18 100644
--- a/dbms/src/DataStreams/DistinctSortedBlockInputStream.h
+++ b/dbms/src/DataStreams/DistinctSortedBlockInputStream.h
@@ -21,7 +21,7 @@ class DistinctSortedBlockInputStream : public IProfilingBlockInputStream
 {
 public:
     /// Empty columns_ means all collumns.
-    DistinctSortedBlockInputStream(const BlockInputStreamPtr & input, const Limits & limits, size_t limit_hint_, Names columns_);
+    DistinctSortedBlockInputStream(const BlockInputStreamPtr & input, const Limits & limits, size_t limit_hint_, const Names & columns);
 
     String getName() const override { return "DistinctSorted"; }
 
diff --git a/dbms/src/DataStreams/IProfilingBlockInputStream.cpp b/dbms/src/DataStreams/IProfilingBlockInputStream.cpp
index 1b10f4899d7..beacaa7f79d 100644
--- a/dbms/src/DataStreams/IProfilingBlockInputStream.cpp
+++ b/dbms/src/DataStreams/IProfilingBlockInputStream.cpp
@@ -142,7 +142,7 @@ void IProfilingBlockInputStream::updateExtremes(Block & block)
 
 bool IProfilingBlockInputStream::checkLimits()
 {
-    auto handle_overflow_mode = [this] (OverflowMode mode, const String & message, int code)
+    auto handle_overflow_mode = [] (OverflowMode mode, const String & message, int code)
     {
         switch (mode)
         {
diff --git a/dbms/tests/instructions/clang-tidy.txt b/dbms/tests/instructions/clang-tidy.txt
index cc6cc2e9556..27234f7a101 100644
--- a/dbms/tests/instructions/clang-tidy.txt
+++ b/dbms/tests/instructions/clang-tidy.txt
@@ -1,3 +1,4 @@
+# http://clang.llvm.org/extra/clang-tidy/
 # Install latest clang with extra tools.
 # Look at utils/prepare-environment/install-clang.sh
 

From b282c8fcbbf05ddd3e5fc78c48628bdd3bafd0fe Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 07:11:39 +0300
Subject: [PATCH 134/266] Implemented some suggestions from clang-tidy (part 5)
 [#CLICKHOUSE-3301].

---
 dbms/src/Common/tests/lru_cache.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbms/src/Common/tests/lru_cache.cpp b/dbms/src/Common/tests/lru_cache.cpp
index 90de5903673..70c4eed2132 100644
--- a/dbms/src/Common/tests/lru_cache.cpp
+++ b/dbms/src/Common/tests/lru_cache.cpp
@@ -12,7 +12,7 @@ namespace
 {
 
 void run();
-void runTest(unsigned int num, const std::function<bool()> func);
+void runTest(unsigned int num, const std::function<bool()> & func);
 bool test1();
 bool test2();
 bool test_concurrent();

From 5993e62f5bb5535817f49b2fdb7935a93622b57b Mon Sep 17 00:00:00 2001
From: robot-metrika-test <robot-metrika-test@yandex-team.ru>
Date: Fri, 8 Sep 2017 07:26:49 +0300
Subject: [PATCH 135/266] Auto version update to [54288]

---
 dbms/cmake/version.cmake | 4 ++--
 debian/changelog         | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/dbms/cmake/version.cmake b/dbms/cmake/version.cmake
index 41e08de697d..7486c7f884c 100644
--- a/dbms/cmake/version.cmake
+++ b/dbms/cmake/version.cmake
@@ -1,6 +1,6 @@
 # This strings autochanged from release_lib.sh:
-set(VERSION_DESCRIBE v1.1.54287-testing)
-set(VERSION_REVISION 54287)
+set(VERSION_DESCRIBE v1.1.54288-testing)
+set(VERSION_REVISION 54288)
 # end of autochange
 
 set (VERSION_MAJOR 1)
diff --git a/debian/changelog b/debian/changelog
index 2d309002fe3..5c978faf8f1 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,5 +1,5 @@
-clickhouse (1.1.54287) unstable; urgency=low
+clickhouse (1.1.54288) unstable; urgency=low
 
   * Modified source code
 
- --  <robot-metrika-test@yandex-team.ru>  Wed, 06 Sep 2017 23:49:16 +0300
+ --  <robot-metrika-test@yandex-team.ru>  Fri, 08 Sep 2017 07:26:49 +0300

From 4799f28dadc31f4c967f5304cf5465c307ee1573 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 07:39:03 +0300
Subject: [PATCH 136/266] Implemented some suggestions from clang-tidy (part 6)
 [#CLICKHOUSE-3301].

---
 dbms/src/Common/Exception.cpp           | 6 +++---
 dbms/src/Interpreters/NullableUtils.cpp | 1 +
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/dbms/src/Common/Exception.cpp b/dbms/src/Common/Exception.cpp
index 8a512f48f89..9a14ab72d19 100644
--- a/dbms/src/Common/Exception.cpp
+++ b/dbms/src/Common/Exception.cpp
@@ -166,7 +166,7 @@ void tryLogException(std::exception_ptr e, const char * log_name, const std::str
 {
     try
     {
-        std::rethrow_exception(e);
+        std::rethrow_exception(std::move(e));
     }
     catch (...)
     {
@@ -178,7 +178,7 @@ void tryLogException(std::exception_ptr e, Poco::Logger * logger, const std::str
 {
     try
     {
-        std::rethrow_exception(e);
+        std::rethrow_exception(std::move(e));
     }
     catch (...)
     {
@@ -220,7 +220,7 @@ std::string getExceptionMessage(std::exception_ptr e, bool with_stacktrace)
 {
     try
     {
-        std::rethrow_exception(e);
+        std::rethrow_exception(std::move(e));
     }
     catch (...)
     {
diff --git a/dbms/src/Interpreters/NullableUtils.cpp b/dbms/src/Interpreters/NullableUtils.cpp
index da8747bcd40..f221eb1f9eb 100644
--- a/dbms/src/Interpreters/NullableUtils.cpp
+++ b/dbms/src/Interpreters/NullableUtils.cpp
@@ -34,6 +34,7 @@ void extractNestedColumnsAndNullMap(ConstColumnPlainPtrs & key_columns, ColumnPt
                 }
                 else
                 {
+                    mutable_null_map = &static_cast<ColumnUInt8 &>(*null_map_holder).getData();
                     const PaddedPODArray<UInt8> & other_null_map = column_nullable.getNullMap();
                     for (size_t i = 0, size = mutable_null_map->size(); i < size; ++i)
                         (*mutable_null_map)[i] |= other_null_map[i];

From 71d29acdfb13431e253bfffa8fd0c769e8df5d7d Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 07:43:57 +0300
Subject: [PATCH 137/266] Implemented some suggestions from clang-tidy (part 7)
 [#CLICKHOUSE-3301].

---
 dbms/src/Common/Exception.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbms/src/Common/Exception.h b/dbms/src/Common/Exception.h
index 756434a73ef..0cbe58b4caf 100644
--- a/dbms/src/Common/Exception.h
+++ b/dbms/src/Common/Exception.h
@@ -59,7 +59,7 @@ private:
 using Exceptions = std::vector<std::exception_ptr>;
 
 
-void throwFromErrno(const std::string & s, int code = 0, int the_errno = errno);
+[[noreturn]] void throwFromErrno(const std::string & s, int code = 0, int the_errno = errno);
 
 
 /** Try to write an exception to the log (and forget about it).

From dc4976f5625c395d43f3fe40215d75f29c47db15 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 07:58:57 +0300
Subject: [PATCH 138/266] Implemented some suggestions from clang-tidy (part 8)
 [#CLICKHOUSE-3301].

---
 dbms/src/Columns/ColumnFixedString.cpp       |  2 +-
 dbms/src/Common/VirtualColumnUtils.cpp       |  4 ++--
 dbms/src/Common/localBackup.cpp              |  4 ++--
 dbms/src/Common/localBackup.h                |  2 +-
 dbms/src/Common/tests/hash_table.cpp         | 16 ----------------
 dbms/src/DataStreams/UnionBlockInputStream.h |  2 +-
 dbms/src/Functions/IFunction.cpp             |  4 ++--
 dbms/src/IO/UncompressedCache.h              |  2 +-
 dbms/src/Storages/StorageLog.cpp             |  4 ++--
 dbms/src/Storages/StorageMergeTree.cpp       |  2 +-
 dbms/src/Storages/StorageStripeLog.cpp       |  4 ++--
 dbms/src/Storages/StorageTinyLog.cpp         |  4 ++--
 12 files changed, 17 insertions(+), 33 deletions(-)

diff --git a/dbms/src/Columns/ColumnFixedString.cpp b/dbms/src/Columns/ColumnFixedString.cpp
index 946763f3f7a..ad846d45603 100644
--- a/dbms/src/Columns/ColumnFixedString.cpp
+++ b/dbms/src/Columns/ColumnFixedString.cpp
@@ -196,9 +196,9 @@ ColumnPtr ColumnFixedString::filter(const IColumn::Filter & filt, ssize_t result
         }
         else
         {
+            size_t res_chars_size = res->chars.size();
             for (size_t i = 0; i < SIMD_BYTES; ++i)
             {
-                size_t res_chars_size = res->chars.size();
                 if (filt_pos[i])
                 {
                     res->chars.resize(res_chars_size + n);
diff --git a/dbms/src/Common/VirtualColumnUtils.cpp b/dbms/src/Common/VirtualColumnUtils.cpp
index 448281deeda..c403372c000 100644
--- a/dbms/src/Common/VirtualColumnUtils.cpp
+++ b/dbms/src/Common/VirtualColumnUtils.cpp
@@ -88,7 +88,7 @@ void rewriteEntityInAst(ASTPtr ast, const String & column_name, const Field & va
 }
 
 /// Verifying that the function depends only on the specified columns
-static bool isValidFunction(ASTPtr expression, const NameSet & columns)
+static bool isValidFunction(const ASTPtr & expression, const NameSet & columns)
 {
     for (size_t i = 0; i < expression->children.size(); ++i)
         if (!isValidFunction(expression->children[i], columns))
@@ -103,7 +103,7 @@ static bool isValidFunction(ASTPtr expression, const NameSet & columns)
 }
 
 /// Extract all subfunctions of the main conjunction, but depending only on the specified columns
-static void extractFunctions(ASTPtr expression, const NameSet & columns, std::vector<ASTPtr> & result)
+static void extractFunctions(const ASTPtr & expression, const NameSet & columns, std::vector<ASTPtr> & result)
 {
     const ASTFunction * function = typeid_cast<const ASTFunction *>(&*expression);
     if (function && function->name == "and")
diff --git a/dbms/src/Common/localBackup.cpp b/dbms/src/Common/localBackup.cpp
index da9cf9988c2..3b93e0ee452 100644
--- a/dbms/src/Common/localBackup.cpp
+++ b/dbms/src/Common/localBackup.cpp
@@ -20,7 +20,7 @@ namespace ErrorCodes
 }
 
 
-static void localBackupImpl(Poco::Path source_path, Poco::Path destination_path, size_t level)
+static void localBackupImpl(const Poco::Path & source_path, const Poco::Path & destination_path, size_t level)
 {
     if (level >= 1000)
         throw DB::Exception("Too deep recursion", DB::ErrorCodes::TOO_DEEP_RECURSION);
@@ -73,7 +73,7 @@ static void localBackupImpl(Poco::Path source_path, Poco::Path destination_path,
     }
 }
 
-void localBackup(Poco::Path source_path, Poco::Path destination_path)
+void localBackup(const Poco::Path & source_path, const Poco::Path & destination_path)
 {
     if (Poco::File(destination_path).exists()
         && Poco::DirectoryIterator(destination_path) != Poco::DirectoryIterator())
diff --git a/dbms/src/Common/localBackup.h b/dbms/src/Common/localBackup.h
index 91107294e26..ccb6a24316e 100644
--- a/dbms/src/Common/localBackup.h
+++ b/dbms/src/Common/localBackup.h
@@ -13,4 +13,4 @@
   *  and is intended to be used as a simple means of protection against a human or program error,
   *  but not from a hardware failure.
   */
-void localBackup(Poco::Path source_path, Poco::Path destination_path);
+void localBackup(const Poco::Path & source_path, const Poco::Path & destination_path);
diff --git a/dbms/src/Common/tests/hash_table.cpp b/dbms/src/Common/tests/hash_table.cpp
index 86289d440a3..26c8e676546 100644
--- a/dbms/src/Common/tests/hash_table.cpp
+++ b/dbms/src/Common/tests/hash_table.cpp
@@ -35,22 +35,6 @@ int main(int argc, char ** argv)
         std::cerr << "dump: " << wb.str() << std::endl;
     }
 
-    {
-        using Cont = HashMap<int, std::string, DefaultHash<int>, HashTableGrower<1>>;
-        Cont cont;
-
-        cont.insert(Cont::value_type(1, "Hello, world!"));
-        cont[1] = "Goodbye.";
-
-        for (auto x : cont)
-            std::cerr << x.first << " -> " << x.second << std::endl;
-
-        DB::WriteBufferFromOwnString wb;
-        cont.writeText(wb);
-
-        std::cerr << "dump: " << wb.str() << std::endl;
-    }
-
     {
         using Cont = HashSet<
             DB::UInt128,
diff --git a/dbms/src/DataStreams/UnionBlockInputStream.h b/dbms/src/DataStreams/UnionBlockInputStream.h
index 2267a8ae218..b72344cdede 100644
--- a/dbms/src/DataStreams/UnionBlockInputStream.h
+++ b/dbms/src/DataStreams/UnionBlockInputStream.h
@@ -63,7 +63,7 @@ struct OutputData<StreamUnionMode::ExtraInfo>
   */
 
 template <StreamUnionMode mode = StreamUnionMode::Basic>
-class UnionBlockInputStream : public IProfilingBlockInputStream
+class UnionBlockInputStream final : public IProfilingBlockInputStream
 {
 public:
     using ExceptionCallback = std::function<void()>;
diff --git a/dbms/src/Functions/IFunction.cpp b/dbms/src/Functions/IFunction.cpp
index 6fe66910cfe..b2c00d62d77 100644
--- a/dbms/src/Functions/IFunction.cpp
+++ b/dbms/src/Functions/IFunction.cpp
@@ -107,7 +107,7 @@ ColumnsWithTypeAndName toNestedColumns(const ColumnsWithTypeAndName & args)
             auto nullable_col = static_cast<const ColumnNullable *>(arg.column.get());
             ColumnPtr nested_col = (nullable_col) ? nullable_col->getNestedColumn() : nullptr;
             auto nullable_type = static_cast<const DataTypeNullable *>(arg.type.get());
-            DataTypePtr nested_type = nullable_type->getNestedType();
+            const DataTypePtr & nested_type = nullable_type->getNestedType();
 
             new_args.emplace_back(nested_col, nested_type, arg.name);
         }
@@ -129,7 +129,7 @@ DataTypes toNestedDataTypes(const DataTypes & args)
         if (arg->isNullable())
         {
             auto nullable_type = static_cast<const DataTypeNullable *>(arg.get());
-            DataTypePtr nested_type = nullable_type->getNestedType();
+            const DataTypePtr & nested_type = nullable_type->getNestedType();
             new_args.push_back(nested_type);
         }
         else
diff --git a/dbms/src/IO/UncompressedCache.h b/dbms/src/IO/UncompressedCache.h
index 05fbb0f2b31..08875403594 100644
--- a/dbms/src/IO/UncompressedCache.h
+++ b/dbms/src/IO/UncompressedCache.h
@@ -69,7 +69,7 @@ public:
         return res;
     }
 
-    void set(const Key & key, MappedPtr mapped)
+    void set(const Key & key, const MappedPtr & mapped)
     {
         Base::set(key, mapped);
         ProfileEvents::increment(ProfileEvents::UncompressedCacheWeightLost, current_weight_lost);
diff --git a/dbms/src/Storages/StorageLog.cpp b/dbms/src/Storages/StorageLog.cpp
index 9ea51f86f31..9361121844f 100644
--- a/dbms/src/Storages/StorageLog.cpp
+++ b/dbms/src/Storages/StorageLog.cpp
@@ -49,7 +49,7 @@ namespace ErrorCodes
 }
 
 
-class LogBlockInputStream : public IProfilingBlockInputStream
+class LogBlockInputStream final : public IProfilingBlockInputStream
 {
 public:
     LogBlockInputStream(
@@ -130,7 +130,7 @@ private:
 };
 
 
-class LogBlockOutputStream : public IBlockOutputStream
+class LogBlockOutputStream final : public IBlockOutputStream
 {
 public:
     explicit LogBlockOutputStream(StorageLog & storage_)
diff --git a/dbms/src/Storages/StorageMergeTree.cpp b/dbms/src/Storages/StorageMergeTree.cpp
index 3b9acc41af7..2ccbc8a59ca 100644
--- a/dbms/src/Storages/StorageMergeTree.cpp
+++ b/dbms/src/Storages/StorageMergeTree.cpp
@@ -500,7 +500,7 @@ void StorageMergeTree::attachPartition(const ASTPtr & query, const Field & field
         ActiveDataPartSet active_parts;
         for (Poco::DirectoryIterator it = Poco::DirectoryIterator(full_path + source_dir); it != Poco::DirectoryIterator(); ++it)
         {
-            String name = it.name();
+            const String & name = it.name();
             MergeTreePartInfo part_info;
             if (!MergeTreePartInfo::tryParsePartName(name, &part_info)
                 || part_info.partition_id != partition_id)
diff --git a/dbms/src/Storages/StorageStripeLog.cpp b/dbms/src/Storages/StorageStripeLog.cpp
index d7e4cc7fff5..351daa0e999 100644
--- a/dbms/src/Storages/StorageStripeLog.cpp
+++ b/dbms/src/Storages/StorageStripeLog.cpp
@@ -40,7 +40,7 @@ namespace ErrorCodes
 }
 
 
-class StripeLogBlockInputStream : public IProfilingBlockInputStream
+class StripeLogBlockInputStream final : public IProfilingBlockInputStream
 {
 public:
     StripeLogBlockInputStream(const NameSet & column_names_, StorageStripeLog & storage_, size_t max_read_buffer_size_,
@@ -111,7 +111,7 @@ private:
 };
 
 
-class StripeLogBlockOutputStream : public IBlockOutputStream
+class StripeLogBlockOutputStream final : public IBlockOutputStream
 {
 public:
     explicit StripeLogBlockOutputStream(StorageStripeLog & storage_)
diff --git a/dbms/src/Storages/StorageTinyLog.cpp b/dbms/src/Storages/StorageTinyLog.cpp
index 9435d45094c..f0ce7d48281 100644
--- a/dbms/src/Storages/StorageTinyLog.cpp
+++ b/dbms/src/Storages/StorageTinyLog.cpp
@@ -52,7 +52,7 @@ namespace ErrorCodes
 }
 
 
-class TinyLogBlockInputStream : public IProfilingBlockInputStream
+class TinyLogBlockInputStream final : public IProfilingBlockInputStream
 {
 public:
     TinyLogBlockInputStream(size_t block_size_, const Names & column_names_, StorageTinyLog & storage_, size_t max_read_buffer_size_)
@@ -93,7 +93,7 @@ private:
 };
 
 
-class TinyLogBlockOutputStream : public IBlockOutputStream
+class TinyLogBlockOutputStream final : public IBlockOutputStream
 {
 public:
     explicit TinyLogBlockOutputStream(StorageTinyLog & storage_)

From a81028377ebdfe4e8ca98cceed6bb1ddced00718 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 08:03:21 +0300
Subject: [PATCH 139/266] Implemented some suggestions from clang-tidy (part 9)
 [#CLICKHOUSE-3301].

---
 dbms/src/IO/tests/valid_utf8.cpp            | 8 ++++----
 dbms/src/Storages/tests/seek_speed_test.cpp | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/dbms/src/IO/tests/valid_utf8.cpp b/dbms/src/IO/tests/valid_utf8.cpp
index ccf176386f9..7033574b99d 100644
--- a/dbms/src/IO/tests/valid_utf8.cpp
+++ b/dbms/src/IO/tests/valid_utf8.cpp
@@ -13,10 +13,10 @@ int main(int argc, char ** argv)
     {
         std::string test1 = "kjhsgdfkjhg2378rtzgvxkz877%^&^*%&^*&*";
         std::string test2 = "{\"asd\" = \"qw1\",\"qwe24\" = \"3asd\"}";
-        test2[test2.find("1")] = char(127 + 64);
-        test2[test2.find("2")] = char(127 + 64 + 32);
-        test2[test2.find("3")] = char(127 + 64 + 32 + 16);
-        test2[test2.find("4")] = char(127 + 64 + 32 + 16 + 8);
+        test2[test2.find('1')] = char(127 + 64);
+        test2[test2.find('2')] = char(127 + 64 + 32);
+        test2[test2.find('3')] = char(127 + 64 + 32 + 16);
+        test2[test2.find('4')] = char(127 + 64 + 32 + 16 + 8);
 
         std::string str;
         {
diff --git a/dbms/src/Storages/tests/seek_speed_test.cpp b/dbms/src/Storages/tests/seek_speed_test.cpp
index bb06f7b95bf..3d5e8bcc6d2 100644
--- a/dbms/src/Storages/tests/seek_speed_test.cpp
+++ b/dbms/src/Storages/tests/seek_speed_test.cpp
@@ -33,7 +33,7 @@ int main(int argc, const char ** argv)
     UInt64 size = Poco::File(argv[1]).getSize();
     UInt64 pos = 0;
     DB::ReadBufferFromFile in(argv[1], buf_size);
-    char * buf = new char[block];
+    auto buf = std::make_unique<char[]>(block);
     int checksum = 0;
     UInt64 bytes_read = 0;
 

From 5d3cc618913c62a5e9b6756f967ae76076c86915 Mon Sep 17 00:00:00 2001
From: Vadim Skipin <vskipin@yandex-team.ru>
Date: Fri, 8 Sep 2017 14:57:43 +0300
Subject: [PATCH 140/266] CLICKHOUSE-3289: Do not use Application singleton #2

---
 dbms/src/IO/HTTPCommon.cpp                        |  8 ++++----
 dbms/src/IO/HTTPCommon.h                          |  2 +-
 dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp | 11 ++++++++---
 dbms/src/IO/WriteBufferFromHTTPServerResponse.h   |  2 ++
 dbms/src/Server/HTTPHandler.cpp                   |  9 +++++++--
 dbms/src/Server/HTTPHandlerFactory.h              |  2 +-
 dbms/src/Server/InterserverIOHTTPHandler.cpp      |  5 ++++-
 dbms/src/Server/PingRequestHandler.cpp            |  4 +++-
 dbms/src/Server/PingRequestHandler.h              |  9 +++++++++
 dbms/src/Server/ReplicasStatusHandler.cpp         |  3 ++-
 dbms/src/Server/RootRequestHandler.cpp            |  7 +++++--
 dbms/src/Server/RootRequestHandler.h              |  4 ++--
 12 files changed, 48 insertions(+), 18 deletions(-)

diff --git a/dbms/src/IO/HTTPCommon.cpp b/dbms/src/IO/HTTPCommon.cpp
index 7e06377f002..6aea408eaa5 100644
--- a/dbms/src/IO/HTTPCommon.cpp
+++ b/dbms/src/IO/HTTPCommon.cpp
@@ -15,14 +15,14 @@
 
 namespace DB
 {
-void setResponseDefaultHeaders(Poco::Net::HTTPServerResponse & response)
+void setResponseDefaultHeaders(Poco::Net::HTTPServerResponse & response, int keep_alive_timeout)
 {
     if (!response.getKeepAlive())
         return;
 
-    Poco::Timespan keep_alive_timeout(Poco::Util::Application::instance().config().getInt("keep_alive_timeout", 10), 0);
-    if (keep_alive_timeout.totalSeconds())
-        response.set("Keep-Alive", "timeout=" + std::to_string(keep_alive_timeout.totalSeconds()));
+    Poco::Timespan timeout(keep_alive_timeout, 0);
+    if (timeout.totalSeconds())
+        response.set("Keep-Alive", "timeout=" + std::to_string(timeout.totalSeconds()));
 }
 
 std::once_flag ssl_init_once;
diff --git a/dbms/src/IO/HTTPCommon.h b/dbms/src/IO/HTTPCommon.h
index 851400652b7..1278d6cd679 100644
--- a/dbms/src/IO/HTTPCommon.h
+++ b/dbms/src/IO/HTTPCommon.h
@@ -14,7 +14,7 @@ namespace Poco
 namespace DB
 {
 
-void setResponseDefaultHeaders(Poco::Net::HTTPServerResponse & response);
+void setResponseDefaultHeaders(Poco::Net::HTTPServerResponse & response, int keep_alive_timeout);
 
 extern std::once_flag ssl_init_once;
 void SSLInit();
diff --git a/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp b/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp
index 26179b05873..70302d72aa6 100644
--- a/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp
+++ b/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp
@@ -27,7 +27,7 @@ void WriteBufferFromHTTPServerResponse::startSendHeaders()
         if (add_cors_header)
             response.set("Access-Control-Allow-Origin", "*");
 
-        setResponseDefaultHeaders(response);
+        setResponseDefaultHeaders(response, keep_alive_timeout);
 
 #if POCO_CLICKHOUSE_PATCH
         if (request.getMethod() != Poco::Net::HTTPRequest::HTTP_HEAD)
@@ -131,11 +131,16 @@ void WriteBufferFromHTTPServerResponse::nextImpl()
 WriteBufferFromHTTPServerResponse::WriteBufferFromHTTPServerResponse(
     Poco::Net::HTTPServerRequest & request_,
     Poco::Net::HTTPServerResponse & response_,
+    int keep_alive_timeout_,
     bool compress_,
     ZlibCompressionMethod compression_method_,
     size_t size)
-    : BufferWithOwnMemory<WriteBuffer>(size), request(request_), response(response_),
-    compress(compress_), compression_method(compression_method_)
+    : BufferWithOwnMemory<WriteBuffer>(size)
+    , request(request_)
+    , response(response_)
+    , keep_alive_timeout(keep_alive_timeout_)
+    , compress(compress_)
+    , compression_method(compression_method_)
 {
 }
 
diff --git a/dbms/src/IO/WriteBufferFromHTTPServerResponse.h b/dbms/src/IO/WriteBufferFromHTTPServerResponse.h
index 54cfc15bb6f..d3dcb0de6e1 100644
--- a/dbms/src/IO/WriteBufferFromHTTPServerResponse.h
+++ b/dbms/src/IO/WriteBufferFromHTTPServerResponse.h
@@ -50,6 +50,7 @@ private:
     bool compress = false;
     ZlibCompressionMethod compression_method;
     int compression_level = Z_DEFAULT_COMPRESSION;
+    int keep_alive_timeout = 0;
 
     std::ostream * response_body_ostr = nullptr;
 
@@ -86,6 +87,7 @@ public:
     WriteBufferFromHTTPServerResponse(
         Poco::Net::HTTPServerRequest & request_,
         Poco::Net::HTTPServerResponse & response_,
+        int keep_alive_timeout,
         bool compress_ = false,        /// If true - set Content-Encoding header and compress the result.
         ZlibCompressionMethod compression_method_ = ZlibCompressionMethod::Gzip,
         size_t size = DBMS_DEFAULT_BUFFER_SIZE);
diff --git a/dbms/src/Server/HTTPHandler.cpp b/dbms/src/Server/HTTPHandler.cpp
index 272b32da707..b3e9165ad06 100644
--- a/dbms/src/Server/HTTPHandler.cpp
+++ b/dbms/src/Server/HTTPHandler.cpp
@@ -229,6 +229,8 @@ void HTTPHandler::processQuery(
     std::string quota_key = request.get("X-ClickHouse-Quota", params.get("quota_key", ""));
     std::string query_id = params.get("query_id", "");
 
+    const auto & config = server.config();
+
     Context context = server.context();
     context.setGlobalContext(server.context());
 
@@ -246,7 +248,7 @@ void HTTPHandler::processQuery(
     if (session_is_set)
     {
         session_id = params.get("session_id");
-        session_timeout = parseSessionTimeout(server.config(), params);
+        session_timeout = parseSessionTimeout(config, params);
         std::string session_check = params.get("session_check", "");
 
         session = context.acquireSession(session_id, session_timeout, session_check == "1");
@@ -296,8 +298,11 @@ void HTTPHandler::processQuery(
     size_t buffer_size_http = DBMS_DEFAULT_BUFFER_SIZE;
     size_t buffer_size_memory = (buffer_size_total > buffer_size_http) ? buffer_size_total : 0;
 
+    int keep_alive_timeout = config.getInt("keep_alive_timeout", 10);
+
     used_output.out = std::make_shared<WriteBufferFromHTTPServerResponse>(
-        request, response, client_supports_http_compression, http_response_compression_method, buffer_size_http);
+        request, response, keep_alive_timeout,
+        client_supports_http_compression, http_response_compression_method, buffer_size_http);
     if (internal_compression)
         used_output.out_maybe_compressed = std::make_shared<CompressedWriteBuffer>(*used_output.out);
     else
diff --git a/dbms/src/Server/HTTPHandlerFactory.h b/dbms/src/Server/HTTPHandlerFactory.h
index 7ba25b0d194..34c49ce1671 100644
--- a/dbms/src/Server/HTTPHandlerFactory.h
+++ b/dbms/src/Server/HTTPHandlerFactory.h
@@ -47,7 +47,7 @@ public:
             if (uri == "/")
                 return new RootRequestHandler(server);
             if (uri == "/ping")
-                return new PingRequestHandler;
+                return new PingRequestHandler(server);
             else if (startsWith(uri, "/replicas_status"))
                 return new ReplicasStatusHandler(server.context());
         }
diff --git a/dbms/src/Server/InterserverIOHTTPHandler.cpp b/dbms/src/Server/InterserverIOHTTPHandler.cpp
index c3813442897..41ce723b433 100644
--- a/dbms/src/Server/InterserverIOHTTPHandler.cpp
+++ b/dbms/src/Server/InterserverIOHTTPHandler.cpp
@@ -36,7 +36,10 @@ void InterserverIOHTTPHandler::processQuery(Poco::Net::HTTPServerRequest & reque
 
     ReadBufferFromIStream body(request.stream());
 
-    WriteBufferFromHTTPServerResponse out(request, response);
+    const auto & config = server.config();
+    int keep_alive_timeout = config.getInt("keep_alive_timeout", 10);
+
+    WriteBufferFromHTTPServerResponse out(request, response, keep_alive_timeout);
 
     auto endpoint = server.context().getInterserverIOHandler().getEndpoint(endpoint_name);
 
diff --git a/dbms/src/Server/PingRequestHandler.cpp b/dbms/src/Server/PingRequestHandler.cpp
index 492d2a5d9d1..4489145f35b 100644
--- a/dbms/src/Server/PingRequestHandler.cpp
+++ b/dbms/src/Server/PingRequestHandler.cpp
@@ -16,7 +16,9 @@ void PingRequestHandler::handleRequest(
 {
     try
     {
-        setResponseDefaultHeaders(response);
+        const auto & config = server.config();
+        setResponseDefaultHeaders(response, config.getInt("keep_alive_timeout", 10));
+
         const char * data = "Ok.\n";
         response.sendBuffer(data, strlen(data));
     }
diff --git a/dbms/src/Server/PingRequestHandler.h b/dbms/src/Server/PingRequestHandler.h
index f81b45e376e..3728fb40adb 100644
--- a/dbms/src/Server/PingRequestHandler.h
+++ b/dbms/src/Server/PingRequestHandler.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include "IServer.h"
+
 #include <Poco/Net/HTTPRequestHandler.h>
 
 
@@ -9,7 +11,14 @@ namespace DB
 /// Response with "Ok.\n". Used for availability checks.
 class PingRequestHandler : public Poco::Net::HTTPRequestHandler
 {
+private:
+    IServer & server;
+
 public:
+    explicit PingRequestHandler(IServer & server_) : server(server_)
+    {
+    }
+
     void handleRequest(
         Poco::Net::HTTPServerRequest & request,
         Poco::Net::HTTPServerResponse & response) override;
diff --git a/dbms/src/Server/ReplicasStatusHandler.cpp b/dbms/src/Server/ReplicasStatusHandler.cpp
index fc50ba7f48c..27323c593d4 100644
--- a/dbms/src/Server/ReplicasStatusHandler.cpp
+++ b/dbms/src/Server/ReplicasStatusHandler.cpp
@@ -62,7 +62,8 @@ void ReplicasStatusHandler::handleRequest(Poco::Net::HTTPServerRequest & request
             }
         }
 
-        setResponseDefaultHeaders(response);
+        const auto & config = context.getConfigRef();
+        setResponseDefaultHeaders(response, config.getInt("keep_alive_timeout", 10));
 
         if (ok && !verbose)
         {
diff --git a/dbms/src/Server/RootRequestHandler.cpp b/dbms/src/Server/RootRequestHandler.cpp
index 6020f9f5850..32eccd78cc4 100644
--- a/dbms/src/Server/RootRequestHandler.cpp
+++ b/dbms/src/Server/RootRequestHandler.cpp
@@ -16,9 +16,12 @@ void RootRequestHandler::handleRequest(
 {
     try
     {
-        setResponseDefaultHeaders(response);
+        const auto & config = server.config();
+        setResponseDefaultHeaders(response, config.getInt("keep_alive_timeout", 10));
+
         response.setContentType("text/html; charset=UTF-8");
-        const std::string data = server.config().getString("http_server_default_response", "Ok.\n");
+
+        const std::string data = config.getString("http_server_default_response", "Ok.\n");
         response.sendBuffer(data.data(), data.size());
     }
     catch (...)
diff --git a/dbms/src/Server/RootRequestHandler.h b/dbms/src/Server/RootRequestHandler.h
index 73261471bb1..1b6d53eeeda 100644
--- a/dbms/src/Server/RootRequestHandler.h
+++ b/dbms/src/Server/RootRequestHandler.h
@@ -1,9 +1,9 @@
 #pragma once
 
-#include <Poco/Net/HTTPRequestHandler.h>
-
 #include "IServer.h"
 
+#include <Poco/Net/HTTPRequestHandler.h>
+
 
 namespace DB
 {

From c8aa9f0f559baa49ab7c88d72778dcef0ca88c66 Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 19:35:31 +0300
Subject: [PATCH 141/266] Update WriteBufferFromHTTPServerResponse.h

---
 dbms/src/IO/WriteBufferFromHTTPServerResponse.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbms/src/IO/WriteBufferFromHTTPServerResponse.h b/dbms/src/IO/WriteBufferFromHTTPServerResponse.h
index d3dcb0de6e1..47ba573bbde 100644
--- a/dbms/src/IO/WriteBufferFromHTTPServerResponse.h
+++ b/dbms/src/IO/WriteBufferFromHTTPServerResponse.h
@@ -87,7 +87,7 @@ public:
     WriteBufferFromHTTPServerResponse(
         Poco::Net::HTTPServerRequest & request_,
         Poco::Net::HTTPServerResponse & response_,
-        int keep_alive_timeout,
+        int keep_alive_timeout_,
         bool compress_ = false,        /// If true - set Content-Encoding header and compress the result.
         ZlibCompressionMethod compression_method_ = ZlibCompressionMethod::Gzip,
         size_t size = DBMS_DEFAULT_BUFFER_SIZE);

From db4c3f6e4866cfeb5111448dc74da9a10e50b702 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 19:41:35 +0300
Subject: [PATCH 142/266] Fixed build; clarifications [#CLICKHOUSE-3289].

---
 dbms/src/IO/HTTPCommon.cpp                        | 2 +-
 dbms/src/IO/HTTPCommon.h                          | 2 +-
 dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp | 2 +-
 dbms/src/IO/WriteBufferFromHTTPServerResponse.h   | 4 ++--
 dbms/src/Server/HTTPHandler.cpp                   | 2 +-
 dbms/src/Server/InterserverIOHTTPHandler.cpp      | 2 +-
 dbms/src/Server/PingRequestHandler.cpp            | 2 +-
 dbms/src/Server/ReplicasStatusHandler.cpp         | 2 +-
 dbms/src/Server/RootRequestHandler.cpp            | 2 +-
 dbms/src/Server/Server.cpp                        | 4 ++--
 10 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/dbms/src/IO/HTTPCommon.cpp b/dbms/src/IO/HTTPCommon.cpp
index 6aea408eaa5..7ca9058896f 100644
--- a/dbms/src/IO/HTTPCommon.cpp
+++ b/dbms/src/IO/HTTPCommon.cpp
@@ -15,7 +15,7 @@
 
 namespace DB
 {
-void setResponseDefaultHeaders(Poco::Net::HTTPServerResponse & response, int keep_alive_timeout)
+void setResponseDefaultHeaders(Poco::Net::HTTPServerResponse & response, unsigned keep_alive_timeout)
 {
     if (!response.getKeepAlive())
         return;
diff --git a/dbms/src/IO/HTTPCommon.h b/dbms/src/IO/HTTPCommon.h
index 1278d6cd679..c7fe7d5e7f8 100644
--- a/dbms/src/IO/HTTPCommon.h
+++ b/dbms/src/IO/HTTPCommon.h
@@ -14,7 +14,7 @@ namespace Poco
 namespace DB
 {
 
-void setResponseDefaultHeaders(Poco::Net::HTTPServerResponse & response, int keep_alive_timeout);
+void setResponseDefaultHeaders(Poco::Net::HTTPServerResponse & response, unsigned keep_alive_timeout);
 
 extern std::once_flag ssl_init_once;
 void SSLInit();
diff --git a/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp b/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp
index 70302d72aa6..51b5b20bba9 100644
--- a/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp
+++ b/dbms/src/IO/WriteBufferFromHTTPServerResponse.cpp
@@ -131,7 +131,7 @@ void WriteBufferFromHTTPServerResponse::nextImpl()
 WriteBufferFromHTTPServerResponse::WriteBufferFromHTTPServerResponse(
     Poco::Net::HTTPServerRequest & request_,
     Poco::Net::HTTPServerResponse & response_,
-    int keep_alive_timeout_,
+    unsigned keep_alive_timeout_,
     bool compress_,
     ZlibCompressionMethod compression_method_,
     size_t size)
diff --git a/dbms/src/IO/WriteBufferFromHTTPServerResponse.h b/dbms/src/IO/WriteBufferFromHTTPServerResponse.h
index 47ba573bbde..775cd9f30c6 100644
--- a/dbms/src/IO/WriteBufferFromHTTPServerResponse.h
+++ b/dbms/src/IO/WriteBufferFromHTTPServerResponse.h
@@ -47,10 +47,10 @@ private:
     Poco::Net::HTTPServerResponse & response;
 
     bool add_cors_header = false;
+    unsigned keep_alive_timeout = 0;
     bool compress = false;
     ZlibCompressionMethod compression_method;
     int compression_level = Z_DEFAULT_COMPRESSION;
-    int keep_alive_timeout = 0;
 
     std::ostream * response_body_ostr = nullptr;
 
@@ -87,7 +87,7 @@ public:
     WriteBufferFromHTTPServerResponse(
         Poco::Net::HTTPServerRequest & request_,
         Poco::Net::HTTPServerResponse & response_,
-        int keep_alive_timeout_,
+        unsigned keep_alive_timeout_,
         bool compress_ = false,        /// If true - set Content-Encoding header and compress the result.
         ZlibCompressionMethod compression_method_ = ZlibCompressionMethod::Gzip,
         size_t size = DBMS_DEFAULT_BUFFER_SIZE);
diff --git a/dbms/src/Server/HTTPHandler.cpp b/dbms/src/Server/HTTPHandler.cpp
index b3e9165ad06..85641950367 100644
--- a/dbms/src/Server/HTTPHandler.cpp
+++ b/dbms/src/Server/HTTPHandler.cpp
@@ -298,7 +298,7 @@ void HTTPHandler::processQuery(
     size_t buffer_size_http = DBMS_DEFAULT_BUFFER_SIZE;
     size_t buffer_size_memory = (buffer_size_total > buffer_size_http) ? buffer_size_total : 0;
 
-    int keep_alive_timeout = config.getInt("keep_alive_timeout", 10);
+    unsigned keep_alive_timeout = config.getUInt("keep_alive_timeout", 10);
 
     used_output.out = std::make_shared<WriteBufferFromHTTPServerResponse>(
         request, response, keep_alive_timeout,
diff --git a/dbms/src/Server/InterserverIOHTTPHandler.cpp b/dbms/src/Server/InterserverIOHTTPHandler.cpp
index 41ce723b433..a70421ca986 100644
--- a/dbms/src/Server/InterserverIOHTTPHandler.cpp
+++ b/dbms/src/Server/InterserverIOHTTPHandler.cpp
@@ -37,7 +37,7 @@ void InterserverIOHTTPHandler::processQuery(Poco::Net::HTTPServerRequest & reque
     ReadBufferFromIStream body(request.stream());
 
     const auto & config = server.config();
-    int keep_alive_timeout = config.getInt("keep_alive_timeout", 10);
+    unsigned keep_alive_timeout = config.getUInt("keep_alive_timeout", 10);
 
     WriteBufferFromHTTPServerResponse out(request, response, keep_alive_timeout);
 
diff --git a/dbms/src/Server/PingRequestHandler.cpp b/dbms/src/Server/PingRequestHandler.cpp
index 4489145f35b..21d45366044 100644
--- a/dbms/src/Server/PingRequestHandler.cpp
+++ b/dbms/src/Server/PingRequestHandler.cpp
@@ -17,7 +17,7 @@ void PingRequestHandler::handleRequest(
     try
     {
         const auto & config = server.config();
-        setResponseDefaultHeaders(response, config.getInt("keep_alive_timeout", 10));
+        setResponseDefaultHeaders(response, config.getUInt("keep_alive_timeout", 10));
 
         const char * data = "Ok.\n";
         response.sendBuffer(data, strlen(data));
diff --git a/dbms/src/Server/ReplicasStatusHandler.cpp b/dbms/src/Server/ReplicasStatusHandler.cpp
index 27323c593d4..dfbd6cfc765 100644
--- a/dbms/src/Server/ReplicasStatusHandler.cpp
+++ b/dbms/src/Server/ReplicasStatusHandler.cpp
@@ -63,7 +63,7 @@ void ReplicasStatusHandler::handleRequest(Poco::Net::HTTPServerRequest & request
         }
 
         const auto & config = context.getConfigRef();
-        setResponseDefaultHeaders(response, config.getInt("keep_alive_timeout", 10));
+        setResponseDefaultHeaders(response, config.getUInt("keep_alive_timeout", 10));
 
         if (ok && !verbose)
         {
diff --git a/dbms/src/Server/RootRequestHandler.cpp b/dbms/src/Server/RootRequestHandler.cpp
index 32eccd78cc4..e01661be6b4 100644
--- a/dbms/src/Server/RootRequestHandler.cpp
+++ b/dbms/src/Server/RootRequestHandler.cpp
@@ -17,7 +17,7 @@ void RootRequestHandler::handleRequest(
     try
     {
         const auto & config = server.config();
-        setResponseDefaultHeaders(response, config.getInt("keep_alive_timeout", 10));
+        setResponseDefaultHeaders(response, config.getUInt("keep_alive_timeout", 10));
 
         response.setContentType("text/html; charset=UTF-8");
 
diff --git a/dbms/src/Server/Server.cpp b/dbms/src/Server/Server.cpp
index 8167f85e2f9..53534463359 100644
--- a/dbms/src/Server/Server.cpp
+++ b/dbms/src/Server/Server.cpp
@@ -302,9 +302,9 @@ int Server::main(const std::vector<std::string> & args)
     }
 
     {
-        Poco::Timespan keep_alive_timeout(config().getInt("keep_alive_timeout", 10), 0);
+        Poco::Timespan keep_alive_timeout(config().getUInt("keep_alive_timeout", 10), 0);
 
-        Poco::ThreadPool server_pool(3, config().getInt("max_connections", 1024));
+        Poco::ThreadPool server_pool(3, config().getUInt("max_connections", 1024));
         Poco::Net::HTTPServerParams::Ptr http_params = new Poco::Net::HTTPServerParams;
         http_params->setTimeout(settings.receive_timeout);
         http_params->setKeepAliveTimeout(keep_alive_timeout);

From 9afe76e212f7bcb48f67706ad3a7ca129ab26864 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 19:46:56 +0300
Subject: [PATCH 143/266] Minor modification [#CLICKHOUSE-2].

---
 dbms/src/Interpreters/Users.cpp | 6 +++---
 dbms/src/Interpreters/Users.h   | 3 ---
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/dbms/src/Interpreters/Users.cpp b/dbms/src/Interpreters/Users.cpp
index 4f2a21ba402..887649232ac 100644
--- a/dbms/src/Interpreters/Users.cpp
+++ b/dbms/src/Interpreters/Users.cpp
@@ -284,8 +284,8 @@ User::User(const String & name_, const String & config_elem, Poco::Util::Abstrac
             throw Exception("password_sha256_hex for user " + name + " has length " + toString(password_sha256_hex.size()) + " but must be exactly 64 symbols.", ErrorCodes::BAD_ARGUMENTS);
     }
 
-    profile     = config.getString(config_elem + ".profile");
-    quota         = config.getString(config_elem + ".quota");
+    profile = config.getString(config_elem + ".profile");
+    quota = config.getString(config_elem + ".quota");
 
     addresses.addFromConfig(config_elem + ".networks", config);
 
@@ -314,7 +314,7 @@ void Users::loadFromConfig(Poco::Util::AbstractConfiguration & config)
     config.keys("users", config_keys);
 
     for (const std::string & key : config_keys)
-        cont[key] = User(key, "users." + key, config);
+        cont.emplace(std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple(key, "users." + key, config));
 }
 
 const User & Users::get(const String & user_name, const String & password, const Poco::Net::IPAddress & address) const
diff --git a/dbms/src/Interpreters/Users.h b/dbms/src/Interpreters/Users.h
index e28aced8d91..723b1f07324 100644
--- a/dbms/src/Interpreters/Users.h
+++ b/dbms/src/Interpreters/Users.h
@@ -67,9 +67,6 @@ struct User
     DatabaseSet databases;
 
     User(const String & name_, const String & config_elem, Poco::Util::AbstractConfiguration & config);
-
-    /// For insertion to containers.
-    User() {}
 };
 
 

From fce84167977285af923dae9210cc45f2dadb47a9 Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Fri, 8 Sep 2017 21:24:15 +0300
Subject: [PATCH 144/266] Try fix macos build

---
 dbms/src/Dictionaries/LibraryDictionarySource.cpp       | 5 +++--
 dbms/src/Dictionaries/LibraryDictionarySourceExternal.h | 2 ++
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/dbms/src/Dictionaries/LibraryDictionarySource.cpp b/dbms/src/Dictionaries/LibraryDictionarySource.cpp
index b600715f4a0..5785f176fe9 100644
--- a/dbms/src/Dictionaries/LibraryDictionarySource.cpp
+++ b/dbms/src/Dictionaries/LibraryDictionarySource.cpp
@@ -4,6 +4,7 @@
 #include <Poco/File.h>
 #include "LibraryDictionarySourceExternal.h"
 #include <common/logger_useful.h>
+#include <ext/bit_cast.h>
 
 namespace DB
 {
@@ -155,7 +156,7 @@ BlockInputStreamPtr LibraryDictionarySource::loadIds(const std::vector<UInt64> &
 {
     LOG_TRACE(log, "loadIds " << toString() << " size = " << ids.size());
 
-    const ClickHouseLibrary::VectorUInt64 ids_data{static_cast<decltype(ClickHouseLibrary::VectorUInt64::data)>(ids.data()), ids.size()};
+    const ClickHouseLibrary::VectorUInt64 ids_data{ext::bit_cast<decltype(ClickHouseLibrary::VectorUInt64::data)>(ids.data()), ids.size()};
     auto columns_holder = std::make_unique<ClickHouseLibrary::CString[]>(dict_struct.attributes.size());
     ClickHouseLibrary::CStrings columns_pass{
         static_cast<decltype(ClickHouseLibrary::CStrings::data)>(columns_holder.get()), dict_struct.attributes.size()};
@@ -201,7 +202,7 @@ BlockInputStreamPtr LibraryDictionarySource::loadKeys(const Columns & key_column
         columns_pass.data[key_columns_n] = column->getName().c_str();
         ++key_columns_n;
     }
-    const ClickHouseLibrary::VectorUInt64 requested_rows_c{reinterpret_cast<decltype(ClickHouseLibrary::VectorUInt64::data)>(requested_rows.data()), requested_rows.size()};
+    const ClickHouseLibrary::VectorUInt64 requested_rows_c{ext::bit_cast<decltype(ClickHouseLibrary::VectorUInt64::data)>(requested_rows.data()), requested_rows.size()};
     void * data_ptr = nullptr;
 
     /// Get function pointer before dataAllocate call because library->get may throw.
diff --git a/dbms/src/Dictionaries/LibraryDictionarySourceExternal.h b/dbms/src/Dictionaries/LibraryDictionarySourceExternal.h
index 3a3ecfff2c7..3a7af5acfce 100644
--- a/dbms/src/Dictionaries/LibraryDictionarySourceExternal.h
+++ b/dbms/src/Dictionaries/LibraryDictionarySourceExternal.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <cstdint>
+
 namespace ClickHouseLibrary
 {
 using CString = const char *;

From 57d244d739b5f06fd9f2e3ba050b238f39ac3227 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 8 Sep 2017 23:24:11 +0300
Subject: [PATCH 145/266] Removed usage of deprecated C++ feature
 [#CLICKHOUSE-3174].

---
 .../libpoco/Foundation/include/Poco/DirectoryIteratorStrategy.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/libpoco/Foundation/include/Poco/DirectoryIteratorStrategy.h b/contrib/libpoco/Foundation/include/Poco/DirectoryIteratorStrategy.h
index d4ce2bb8af1..b229ca41d73 100644
--- a/contrib/libpoco/Foundation/include/Poco/DirectoryIteratorStrategy.h
+++ b/contrib/libpoco/Foundation/include/Poco/DirectoryIteratorStrategy.h
@@ -34,7 +34,7 @@ class Foundation_API TraverseBase
 {
 public:
 	typedef std::stack<DirectoryIterator> Stack;
-	typedef std::pointer_to_unary_function<const Stack&, UInt16> DepthFunPtr;
+	typedef std::function<UInt16(const Stack&)> DepthFunPtr;
 
 	enum
 	{

From ed1c0820f00c33b54eda7750b3b3c746a70038c7 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 9 Sep 2017 02:25:42 +0300
Subject: [PATCH 146/266] Fixed minor issue found by Coverity
 [#CLICKHOUSE-3285].

---
 dbms/src/Storages/System/StorageSystemGraphite.cpp | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/dbms/src/Storages/System/StorageSystemGraphite.cpp b/dbms/src/Storages/System/StorageSystemGraphite.cpp
index 109d6baafa7..2bb0d64a3f5 100644
--- a/dbms/src/Storages/System/StorageSystemGraphite.cpp
+++ b/dbms/src/Storages/System/StorageSystemGraphite.cpp
@@ -13,6 +13,11 @@
 namespace DB
 {
 
+namespace ErrorCodes
+{
+    extern const int NO_ELEMENTS_IN_CONFIG;
+}
+
 namespace
 {
 
@@ -42,7 +47,11 @@ static Pattern readOnePattern(
 
     config.keys(path, keys);
 
-    for (const auto & key : keys) {
+    if (keys.empty())
+        throw Exception("Empty pattern in Graphite rollup configuration", ErrorCodes::NO_ELEMENTS_IN_CONFIG);
+
+    for (const auto & key : keys)
+    {
         const String key_path = path + "." + key;
 
         if (startsWith(key, "regexp"))
@@ -74,7 +83,8 @@ static std::vector<Pattern> readPatterns(
 
     config.keys(section, keys);
 
-    for (const auto & key : keys) {
+    for (const auto & key : keys)
+    {
         if (startsWith(key, "pattern"))
         {
             Pattern pattern(readOnePattern(config, section + "." + key));

From 94b975e7f9e63724c0210627da04f5c509967691 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 9 Sep 2017 02:31:18 +0300
Subject: [PATCH 147/266] Removed function deprecated in C++
 [#CLICKHOUSE-3174].

---
 dbms/src/DataStreams/narrowBlockInputStreams.cpp | 5 ++++-
 dbms/src/Storages/StorageReplicatedMergeTree.cpp | 8 ++++----
 dbms/src/Storages/StorageReplicatedMergeTree.h   | 4 ++++
 3 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/dbms/src/DataStreams/narrowBlockInputStreams.cpp b/dbms/src/DataStreams/narrowBlockInputStreams.cpp
index 567ef97c20a..25927e451e4 100644
--- a/dbms/src/DataStreams/narrowBlockInputStreams.cpp
+++ b/dbms/src/DataStreams/narrowBlockInputStreams.cpp
@@ -1,3 +1,5 @@
+#include <random>
+#include <Common/randomSeed.h>
 #include <DataStreams/ConcatBlockInputStream.h>
 
 
@@ -18,7 +20,8 @@ BlockInputStreams narrowBlockInputStreams(BlockInputStreams & inputs, size_t wid
     for (size_t i = 0; i < size; ++i)
         distribution[i] = i % width;
 
-    std::random_shuffle(distribution.begin(), distribution.end());
+    std::mt19937 generator(randomSeed());
+    std::shuffle(distribution.begin(), distribution.end(), generator);
 
     for (size_t i = 0; i < size; ++i)
         partitions[distribution[i]].push_back(inputs[i]);
diff --git a/dbms/src/Storages/StorageReplicatedMergeTree.cpp b/dbms/src/Storages/StorageReplicatedMergeTree.cpp
index 38100cd0bd5..96fe887613f 100644
--- a/dbms/src/Storages/StorageReplicatedMergeTree.cpp
+++ b/dbms/src/Storages/StorageReplicatedMergeTree.cpp
@@ -638,7 +638,7 @@ void StorageReplicatedMergeTree::createReplica()
     zookeeper->exists(replica_path, &stat);
     auto my_create_time = stat.czxid;
 
-    std::random_shuffle(replicas.begin(), replicas.end());
+    std::shuffle(replicas.begin(), replicas.end(), rng);
     for (const String & replica : replicas)
     {
         if (!zookeeper->exists(zookeeper_path + "/replicas/" + replica, &stat))
@@ -881,7 +881,7 @@ void StorageReplicatedMergeTree::checkPartAndAddToZooKeeper(
     int expected_columns_version = columns_version;
 
     Strings replicas = zookeeper->getChildren(zookeeper_path + "/replicas");
-    std::random_shuffle(replicas.begin(), replicas.end());
+    std::shuffle(replicas.begin(), replicas.end(), rng);
     String expected_columns_str = part->columns.toString();
 
     for (const String & replica : replicas)
@@ -1931,7 +1931,7 @@ String StorageReplicatedMergeTree::findReplicaHavingPart(const String & part_nam
     Strings replicas = zookeeper->getChildren(zookeeper_path + "/replicas");
 
     /// Select replicas in uniformly random order.
-    std::random_shuffle(replicas.begin(), replicas.end());
+    std::shuffle(replicas.begin(), replicas.end(), rng);
 
     for (const String & replica : replicas)
     {
@@ -1956,7 +1956,7 @@ String StorageReplicatedMergeTree::findReplicaHavingCoveringPart(const LogEntry
     Strings replicas = zookeeper->getChildren(zookeeper_path + "/replicas");
 
     /// Select replicas in uniformly random order.
-    std::random_shuffle(replicas.begin(), replicas.end());
+    std::shuffle(replicas.begin(), replicas.end(), rng);
 
     for (const String & replica : replicas)
     {
diff --git a/dbms/src/Storages/StorageReplicatedMergeTree.h b/dbms/src/Storages/StorageReplicatedMergeTree.h
index 4379d38983d..0793231b16e 100644
--- a/dbms/src/Storages/StorageReplicatedMergeTree.h
+++ b/dbms/src/Storages/StorageReplicatedMergeTree.h
@@ -2,6 +2,7 @@
 
 #include <ext/shared_ptr_helper.h>
 #include <atomic>
+#include <random>
 #include <Storages/IStorage.h>
 #include <Storages/MergeTree/MergeTreeData.h>
 #include <Storages/MergeTree/MergeTreeDataMerger.h>
@@ -21,6 +22,7 @@
 #include <Storages/MergeTree/RemoteQueryExecutor.h>
 #include <Storages/MergeTree/RemotePartChecker.h>
 #include <DataTypes/DataTypesNumber.h>
+#include <Common/randomSeed.h>
 #include <Common/ZooKeeper/ZooKeeper.h>
 #include <Common/ZooKeeper/LeaderElection.h>
 
@@ -319,6 +321,8 @@ private:
 
     Logger * log;
 
+    std::mt19937 rng{randomSeed()};
+
     StorageReplicatedMergeTree(
         const String & zookeeper_path_,
         const String & replica_name_,

From c0324aeb66881f0080bbba264ee5b1fea990cf72 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 9 Sep 2017 02:40:48 +0300
Subject: [PATCH 148/266] Removed useless header [#CLICKHOUSE-3174].

---
 dbms/src/AggregateFunctions/ReservoirSamplerDeterministic.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/dbms/src/AggregateFunctions/ReservoirSamplerDeterministic.h b/dbms/src/AggregateFunctions/ReservoirSamplerDeterministic.h
index a4cd4e158d1..003bc1d2d29 100644
--- a/dbms/src/AggregateFunctions/ReservoirSamplerDeterministic.h
+++ b/dbms/src/AggregateFunctions/ReservoirSamplerDeterministic.h
@@ -12,7 +12,6 @@
 #include <IO/WriteHelpers.h>
 #include <Common/PODArray.h>
 #include <Poco/Exception.h>
-#include <boost/random.hpp>
 
 
  /// Implementation of Reservoir Sampling algorithm. Incrementally selects from the added objects a random subset of the `sample_count` size.

From 7896e9d65fec342a814c8eed30c467239cb114e0 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 9 Sep 2017 02:43:28 +0300
Subject: [PATCH 149/266] Imported pcg-random library (Reason: rng with small
 size of state, fast initialization, good performance and quality, with
 interface compatible with C++ standard library. Cause: boost::random::taus88
 in latest Boost 1.65 is incompatible with C++17 standard) [#CLICKHOUSE-3174].

---
 contrib/libpcg-random/LICENSE-APACHE.txt      |  201 ++
 contrib/libpcg-random/README.md               |   52 +
 contrib/libpcg-random/include/pcg_extras.hpp  |  639 ++++++
 contrib/libpcg-random/include/pcg_random.hpp  | 1771 +++++++++++++++++
 contrib/libpcg-random/include/pcg_uint128.hpp |  748 +++++++
 5 files changed, 3411 insertions(+)
 create mode 100644 contrib/libpcg-random/LICENSE-APACHE.txt
 create mode 100644 contrib/libpcg-random/README.md
 create mode 100644 contrib/libpcg-random/include/pcg_extras.hpp
 create mode 100644 contrib/libpcg-random/include/pcg_random.hpp
 create mode 100644 contrib/libpcg-random/include/pcg_uint128.hpp

diff --git a/contrib/libpcg-random/LICENSE-APACHE.txt b/contrib/libpcg-random/LICENSE-APACHE.txt
new file mode 100644
index 00000000000..8dada3edaf5
--- /dev/null
+++ b/contrib/libpcg-random/LICENSE-APACHE.txt
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/contrib/libpcg-random/README.md b/contrib/libpcg-random/README.md
new file mode 100644
index 00000000000..c6e579cc2cc
--- /dev/null
+++ b/contrib/libpcg-random/README.md
@@ -0,0 +1,52 @@
+# PCG Random Number Generation, C++ Edition
+
+[PCG-Random website]: http://www.pcg-random.org
+
+This code provides an implementation of the PCG family of random number
+generators, which are fast, statistically excellent, and offer a number of
+useful features.
+
+Full details can be found at the [PCG-Random website].  This version
+of the code provides many family members -- if you just want one
+simple generator, you may prefer the minimal C version of the library.
+
+There are two kinds of generator, normal generators and extended generators.
+Extended generators provide *k* dimensional equidistribution and can perform
+party tricks, but generally speaking most people only need the normal
+generators.
+
+There are two ways to access the generators, using a convenience typedef
+or by using the underlying templates directly (similar to C++11's `std::mt19937` typedef vs its `std::mersenne_twister_engine` template).  For most users, the convenience typedef is what you want, and probably you're fine with `pcg32` for 32-bit numbers.  If you want 64-bit numbers, either use `pcg64` (or, if you're on a 32-bit system, making 64 bits from two calls to `pcg32_k2` may be faster).
+
+## Documentation and Examples
+
+Visit [PCG-Random website] for information on how to use this library, or look
+at the sample code in the `sample` directory -- hopefully it should be fairly
+self explanatory.
+
+## Building
+
+The code is written in C++11, as an include-only library (i.e., there is
+nothing you need to build).  There are some provided demo programs and tests
+however.  On a Unix-style system (e.g., Linux, Mac OS X) you should be able
+to just type
+
+    make
+
+To build the demo programs.
+
+## Testing
+
+Run
+
+    make test
+
+## Directory Structure
+
+The directories are arranged as follows:
+
+* `include` -- contains `pcg_random.hpp` and supporting include files
+* `test-high` -- test code for the high-level API where the functions have
+  shorter, less scary-looking names.
+* `sample` -- sample code, some similar to the code in `test-high` but more 
+  human readable, some other examples too
diff --git a/contrib/libpcg-random/include/pcg_extras.hpp b/contrib/libpcg-random/include/pcg_extras.hpp
new file mode 100644
index 00000000000..9bbe8edfe9a
--- /dev/null
+++ b/contrib/libpcg-random/include/pcg_extras.hpp
@@ -0,0 +1,639 @@
+/*
+ * PCG Random Number Generation for C++
+ *
+ * Copyright 2014-2017 Melissa O'Neill <oneill@pcg-random.org>,
+ *                     and the PCG Project contributors.
+ *
+ * SPDX-License-Identifier: (Apache-2.0 OR MIT)
+ *
+ * Licensed under the Apache License, Version 2.0 (provided in
+ * LICENSE-APACHE.txt and at http://www.apache.org/licenses/LICENSE-2.0)
+ * or under the MIT license (provided in LICENSE-MIT.txt and at
+ * http://opensource.org/licenses/MIT), at your option. This file may not
+ * be copied, modified, or distributed except according to those terms.
+ *
+ * Distributed on an "AS IS" BASIS, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied.  See your chosen license for details.
+ *
+ * For additional information about the PCG random number generation scheme,
+ * visit http://www.pcg-random.org/.
+ */
+
+/*
+ * This file provides support code that is useful for random-number generation
+ * but not specific to the PCG generation scheme, including:
+ *      - 128-bit int support for platforms where it isn't available natively
+ *      - bit twiddling operations
+ *      - I/O of 128-bit and 8-bit integers
+ *      - Handling the evilness of SeedSeq
+ *      - Support for efficiently producing random numbers less than a given
+ *        bound
+ */
+
+#ifndef PCG_EXTRAS_HPP_INCLUDED
+#define PCG_EXTRAS_HPP_INCLUDED 1
+
+#include <cinttypes>
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <cassert>
+#include <limits>
+#include <iostream>
+#include <type_traits>
+#include <utility>
+#include <locale>
+#include <iterator>
+
+#ifdef __GNUC__
+    #include <cxxabi.h>
+#endif
+
+/*
+ * Abstractions for compiler-specific directives
+ */
+
+#ifdef __GNUC__
+    #define PCG_NOINLINE __attribute__((noinline))
+#else
+    #define PCG_NOINLINE
+#endif
+
+/*
+ * Some members of the PCG library use 128-bit math.  When compiling on 64-bit
+ * platforms, both GCC and Clang provide 128-bit integer types that are ideal
+ * for the job.
+ *
+ * On 32-bit platforms (or with other compilers), we fall back to a C++
+ * class that provides 128-bit unsigned integers instead.  It may seem
+ * like we're reinventing the wheel here, because libraries already exist
+ * that support large integers, but most existing libraries provide a very
+ * generic multiprecision code, but here we're operating at a fixed size.
+ * Also, most other libraries are fairly heavyweight.  So we use a direct
+ * implementation.  Sadly, it's much slower than hand-coded assembly or
+ * direct CPU support.
+ *
+ */
+#if __SIZEOF_INT128__
+    namespace pcg_extras {
+        typedef __uint128_t pcg128_t;
+    }
+    #define PCG_128BIT_CONSTANT(high,low) \
+            ((pcg128_t(high) << 64) + low)
+#else
+    #include "pcg_uint128.hpp"
+    namespace pcg_extras {
+        typedef pcg_extras::uint_x4<uint32_t,uint64_t> pcg128_t;
+    }
+    #define PCG_128BIT_CONSTANT(high,low) \
+            pcg128_t(high,low)
+    #define PCG_EMULATED_128BIT_MATH 1
+#endif
+
+
+namespace pcg_extras {
+
+/*
+ * We often need to represent a "number of bits".  When used normally, these
+ * numbers are never greater than 128, so an unsigned char is plenty.
+ * If you're using a nonstandard generator of a larger size, you can set
+ * PCG_BITCOUNT_T to have it define it as a larger size.  (Some compilers
+ * might produce faster code if you set it to an unsigned int.)
+ */
+
+#ifndef PCG_BITCOUNT_T
+    typedef uint8_t bitcount_t;
+#else
+    typedef PCG_BITCOUNT_T bitcount_t;
+#endif
+
+/*
+ * C++ requires us to be able to serialize RNG state by printing or reading
+ * it from a stream.  Because we use 128-bit ints, we also need to be able
+ * ot print them, so here is code to do so.
+ *
+ * This code provides enough functionality to print 128-bit ints in decimal
+ * and zero-padded in hex.  It's not a full-featured implementation.
+ */
+
+template <typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits>& out, pcg128_t value)
+{
+    auto desired_base = out.flags() & out.basefield;
+    bool want_hex = desired_base == out.hex;
+
+    if (want_hex) {
+        uint64_t highpart = uint64_t(value >> 64);
+        uint64_t lowpart  = uint64_t(value);
+        auto desired_width = out.width();
+        if (desired_width > 16) {
+            out.width(desired_width - 16);
+        }
+        if (highpart != 0 || desired_width > 16)
+            out << highpart;
+        CharT oldfill = '\0';
+        if (highpart != 0) {
+            out.width(16);
+            oldfill = out.fill('0');
+        }
+        auto oldflags = out.setf(decltype(desired_base){}, out.showbase);
+        out << lowpart;
+        out.setf(oldflags);
+        if (highpart != 0) {
+            out.fill(oldfill);
+        }
+        return out;
+    }
+    constexpr size_t MAX_CHARS_128BIT = 40;
+
+    char buffer[MAX_CHARS_128BIT];
+    char* pos = buffer+sizeof(buffer);
+    *(--pos) = '\0';
+    constexpr auto BASE = pcg128_t(10ULL);
+    do {
+        auto div = value / BASE;
+        auto mod = uint32_t(value - (div * BASE));
+        *(--pos) = '0' + char(mod);
+        value = div;
+    } while(value != pcg128_t(0ULL));
+    return out << pos;
+}
+
+template <typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits>& in, pcg128_t& value)
+{
+    typename std::basic_istream<CharT,Traits>::sentry s(in);
+
+    if (!s)
+         return in;
+
+    constexpr auto BASE = pcg128_t(10ULL);
+    pcg128_t current(0ULL);
+    bool did_nothing = true;
+    bool overflow = false;
+    for(;;) {
+        CharT wide_ch = in.get();
+        if (!in.good())
+            break;
+        auto ch = in.narrow(wide_ch, '\0');
+        if (ch < '0' || ch > '9') {
+            in.unget();
+            break;
+        }
+        did_nothing = false;
+        pcg128_t digit(uint32_t(ch - '0'));
+        pcg128_t timesbase = current*BASE;
+        overflow = overflow || timesbase < current;
+        current = timesbase + digit;
+        overflow = overflow || current < digit;
+    }
+
+    if (did_nothing || overflow) {
+        in.setstate(std::ios::failbit);
+        if (overflow)
+            current = ~pcg128_t(0ULL);
+    }
+
+    value = current;
+
+    return in;
+}
+
+/*
+ * Likewise, if people use tiny rngs, we'll be serializing uint8_t.
+ * If we just used the provided IO operators, they'd read/write chars,
+ * not ints, so we need to define our own.  We *can* redefine this operator
+ * here because we're in our own namespace.
+ */
+
+template <typename CharT, typename Traits>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits>&out, uint8_t value)
+{
+    return out << uint32_t(value);
+}
+
+template <typename CharT, typename Traits>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits>& in, uint8_t& target)
+{
+    uint32_t value = 0xdecea5edU;
+    in >> value;
+    if (!in && value == 0xdecea5edU)
+        return in;
+    if (value > uint8_t(~0)) {
+        in.setstate(std::ios::failbit);
+        value = ~0U;
+    }
+    target = uint8_t(value);
+    return in;
+}
+
+/* Unfortunately, the above functions don't get found in preference to the
+ * built in ones, so we create some more specific overloads that will.
+ * Ugh.
+ */
+
+inline std::ostream& operator<<(std::ostream& out, uint8_t value)
+{
+    return pcg_extras::operator<< <char>(out, value);
+}
+
+inline std::istream& operator>>(std::istream& in, uint8_t& value)
+{
+    return pcg_extras::operator>> <char>(in, value);
+}
+
+
+
+/*
+ * Useful bitwise operations.
+ */
+
+/*
+ * XorShifts are invertable, but they are someting of a pain to invert.
+ * This function backs them out.  It's used by the whacky "inside out"
+ * generator defined later.
+ */
+
+template <typename itype>
+inline itype unxorshift(itype x, bitcount_t bits, bitcount_t shift)
+{
+    if (2*shift >= bits) {
+        return x ^ (x >> shift);
+    }
+    itype lowmask1 = (itype(1U) << (bits - shift*2)) - 1;
+    itype highmask1 = ~lowmask1;
+    itype top1 = x;
+    itype bottom1 = x & lowmask1;
+    top1 ^= top1 >> shift;
+    top1 &= highmask1;
+    x = top1 | bottom1;
+    itype lowmask2 = (itype(1U) << (bits - shift)) - 1;
+    itype bottom2 = x & lowmask2;
+    bottom2 = unxorshift(bottom2, bits - shift, shift);
+    bottom2 &= lowmask1;
+    return top1 | bottom2;
+}
+
+/*
+ * Rotate left and right.
+ *
+ * In ideal world, compilers would spot idiomatic rotate code and convert it
+ * to a rotate instruction.  Of course, opinions vary on what the correct
+ * idiom is and how to spot it.  For clang, sometimes it generates better
+ * (but still crappy) code if you define PCG_USE_ZEROCHECK_ROTATE_IDIOM.
+ */
+
+template <typename itype>
+inline itype rotl(itype value, bitcount_t rot)
+{
+    constexpr bitcount_t bits = sizeof(itype) * 8;
+    constexpr bitcount_t mask = bits - 1;
+#if PCG_USE_ZEROCHECK_ROTATE_IDIOM
+    return rot ? (value << rot) | (value >> (bits - rot)) : value;
+#else
+    return (value << rot) | (value >> ((- rot) & mask));
+#endif
+}
+
+template <typename itype>
+inline itype rotr(itype value, bitcount_t rot)
+{
+    constexpr bitcount_t bits = sizeof(itype) * 8;
+    constexpr bitcount_t mask = bits - 1;
+#if PCG_USE_ZEROCHECK_ROTATE_IDIOM
+    return rot ? (value >> rot) | (value << (bits - rot)) : value;
+#else
+    return (value >> rot) | (value << ((- rot) & mask));
+#endif
+}
+
+/* Unfortunately, both Clang and GCC sometimes perform poorly when it comes
+ * to properly recognizing idiomatic rotate code, so for we also provide
+ * assembler directives (enabled with PCG_USE_INLINE_ASM).  Boo, hiss.
+ * (I hope that these compilers get better so that this code can die.)
+ *
+ * These overloads will be preferred over the general template code above.
+ */
+#if PCG_USE_INLINE_ASM && __GNUC__ && (__x86_64__  || __i386__)
+
+inline uint8_t rotr(uint8_t value, bitcount_t rot)
+{
+    asm ("rorb   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
+    return value;
+}
+
+inline uint16_t rotr(uint16_t value, bitcount_t rot)
+{
+    asm ("rorw   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
+    return value;
+}
+
+inline uint32_t rotr(uint32_t value, bitcount_t rot)
+{
+    asm ("rorl   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
+    return value;
+}
+
+#if __x86_64__
+inline uint64_t rotr(uint64_t value, bitcount_t rot)
+{
+    asm ("rorq   %%cl, %0" : "=r" (value) : "0" (value), "c" (rot));
+    return value;
+}
+#endif // __x86_64__
+
+#endif // PCG_USE_INLINE_ASM
+
+
+/*
+ * The C++ SeedSeq concept (modelled by seed_seq) can fill an array of
+ * 32-bit integers with seed data, but sometimes we want to produce
+ * larger or smaller integers.
+ *
+ * The following code handles this annoyance.
+ *
+ * uneven_copy will copy an array of 32-bit ints to an array of larger or
+ * smaller ints (actually, the code is general it only needing forward
+ * iterators).  The copy is identical to the one that would be performed if
+ * we just did memcpy on a standard little-endian machine, but works
+ * regardless of the endian of the machine (or the weirdness of the ints
+ * involved).
+ *
+ * generate_to initializes an array of integers using a SeedSeq
+ * object.  It is given the size as a static constant at compile time and
+ * tries to avoid memory allocation.  If we're filling in 32-bit constants
+ * we just do it directly.  If we need a separate buffer and it's small,
+ * we allocate it on the stack.  Otherwise, we fall back to heap allocation.
+ * Ugh.
+ *
+ * generate_one produces a single value of some integral type using a
+ * SeedSeq object.
+ */
+
+ /* uneven_copy helper, case where destination ints are less than 32 bit. */
+
+template<class SrcIter, class DestIter>
+SrcIter uneven_copy_impl(
+    SrcIter src_first, DestIter dest_first, DestIter dest_last,
+    std::true_type)
+{
+    typedef typename std::iterator_traits<SrcIter>::value_type  src_t;
+    typedef typename std::iterator_traits<DestIter>::value_type dest_t;
+
+    constexpr bitcount_t SRC_SIZE  = sizeof(src_t);
+    constexpr bitcount_t DEST_SIZE = sizeof(dest_t);
+    constexpr bitcount_t DEST_BITS = DEST_SIZE * 8;
+    constexpr bitcount_t SCALE     = SRC_SIZE / DEST_SIZE;
+
+    size_t count = 0;
+    src_t value = 0;
+
+    while (dest_first != dest_last) {
+        if ((count++ % SCALE) == 0)
+            value = *src_first++;       // Get more bits
+        else
+            value >>= DEST_BITS;        // Move down bits
+
+        *dest_first++ = dest_t(value);  // Truncates, ignores high bits.
+    }
+    return src_first;
+}
+
+ /* uneven_copy helper, case where destination ints are more than 32 bit. */
+
+template<class SrcIter, class DestIter>
+SrcIter uneven_copy_impl(
+    SrcIter src_first, DestIter dest_first, DestIter dest_last,
+    std::false_type)
+{
+    typedef typename std::iterator_traits<SrcIter>::value_type  src_t;
+    typedef typename std::iterator_traits<DestIter>::value_type dest_t;
+
+    constexpr auto SRC_SIZE  = sizeof(src_t);
+    constexpr auto SRC_BITS  = SRC_SIZE * 8;
+    constexpr auto DEST_SIZE = sizeof(dest_t);
+    constexpr auto SCALE     = (DEST_SIZE+SRC_SIZE-1) / SRC_SIZE;
+
+    while (dest_first != dest_last) {
+        dest_t value(0UL);
+        unsigned int shift = 0;
+
+        for (size_t i = 0; i < SCALE; ++i) {
+            value |= dest_t(*src_first++) << shift;
+            shift += SRC_BITS;
+        }
+
+        *dest_first++ = value;
+    }
+    return src_first;
+}
+
+/* uneven_copy, call the right code for larger vs. smaller */
+
+template<class SrcIter, class DestIter>
+inline SrcIter uneven_copy(SrcIter src_first,
+                           DestIter dest_first, DestIter dest_last)
+{
+    typedef typename std::iterator_traits<SrcIter>::value_type  src_t;
+    typedef typename std::iterator_traits<DestIter>::value_type dest_t;
+
+    constexpr bool DEST_IS_SMALLER = sizeof(dest_t) < sizeof(src_t);
+
+    return uneven_copy_impl(src_first, dest_first, dest_last,
+                            std::integral_constant<bool, DEST_IS_SMALLER>{});
+}
+
+/* generate_to, fill in a fixed-size array of integral type using a SeedSeq
+ * (actually works for any random-access iterator)
+ */
+
+template <size_t size, typename SeedSeq, typename DestIter>
+inline void generate_to_impl(SeedSeq&& generator, DestIter dest,
+                             std::true_type)
+{
+    generator.generate(dest, dest+size);
+}
+
+template <size_t size, typename SeedSeq, typename DestIter>
+void generate_to_impl(SeedSeq&& generator, DestIter dest,
+                      std::false_type)
+{
+    typedef typename std::iterator_traits<DestIter>::value_type dest_t;
+    constexpr auto DEST_SIZE = sizeof(dest_t);
+    constexpr auto GEN_SIZE  = sizeof(uint32_t);
+
+    constexpr bool GEN_IS_SMALLER = GEN_SIZE < DEST_SIZE;
+    constexpr size_t FROM_ELEMS =
+        GEN_IS_SMALLER
+            ? size * ((DEST_SIZE+GEN_SIZE-1) / GEN_SIZE)
+            : (size + (GEN_SIZE / DEST_SIZE) - 1)
+                / ((GEN_SIZE / DEST_SIZE) + GEN_IS_SMALLER);
+                        //  this odd code ^^^^^^^^^^^^^^^^^ is work-around for
+                        //  a bug: http://llvm.org/bugs/show_bug.cgi?id=21287
+
+    if (FROM_ELEMS <= 1024) {
+        uint32_t buffer[FROM_ELEMS];
+        generator.generate(buffer, buffer+FROM_ELEMS);
+        uneven_copy(buffer, dest, dest+size);
+    } else {
+        uint32_t* buffer = static_cast<uint32_t*>(malloc(GEN_SIZE * FROM_ELEMS));
+        generator.generate(buffer, buffer+FROM_ELEMS);
+        uneven_copy(buffer, dest, dest+size);
+        free(static_cast<void*>(buffer));
+    }
+}
+
+template <size_t size, typename SeedSeq, typename DestIter>
+inline void generate_to(SeedSeq&& generator, DestIter dest)
+{
+    typedef typename std::iterator_traits<DestIter>::value_type dest_t;
+    constexpr bool IS_32BIT = sizeof(dest_t) == sizeof(uint32_t);
+
+    generate_to_impl<size>(std::forward<SeedSeq>(generator), dest,
+                           std::integral_constant<bool, IS_32BIT>{});
+}
+
+/* generate_one, produce a value of integral type using a SeedSeq
+ * (optionally, we can have it produce more than one and pick which one
+ * we want)
+ */
+
+template <typename UInt, size_t i = 0UL, size_t N = i+1UL, typename SeedSeq>
+inline UInt generate_one(SeedSeq&& generator)
+{
+    UInt result[N];
+    generate_to<N>(std::forward<SeedSeq>(generator), result);
+    return result[i];
+}
+
+template <typename RngType>
+auto bounded_rand(RngType& rng, typename RngType::result_type upper_bound)
+        -> typename RngType::result_type
+{
+    typedef typename RngType::result_type rtype;
+    rtype threshold = (RngType::max() - RngType::min() + rtype(1) - upper_bound)
+                    % upper_bound;
+    for (;;) {
+        rtype r = rng() - RngType::min();
+        if (r >= threshold)
+            return r % upper_bound;
+    }
+}
+
+template <typename Iter, typename RandType>
+void shuffle(Iter from, Iter to, RandType&& rng)
+{
+    typedef typename std::iterator_traits<Iter>::difference_type delta_t;
+    typedef typename std::remove_reference<RandType>::type::result_type result_t;
+    auto count = to - from;
+    while (count > 1) {
+        delta_t chosen = delta_t(bounded_rand(rng, result_t(count)));
+        --count;
+        --to;
+        using std::swap;
+        swap(*(from + chosen), *to);
+    }
+}
+
+/*
+ * Although std::seed_seq is useful, it isn't everything.  Often we want to
+ * initialize a random-number generator some other way, such as from a random
+ * device.
+ *
+ * Technically, it does not meet the requirements of a SeedSequence because
+ * it lacks some of the rarely-used member functions (some of which would
+ * be impossible to provide).  However the C++ standard is quite specific
+ * that actual engines only called the generate method, so it ought not to be
+ * a problem in practice.
+ */
+
+template <typename RngType>
+class seed_seq_from {
+private:
+    RngType rng_;
+
+    typedef uint_least32_t result_type;
+
+public:
+    template<typename... Args>
+    seed_seq_from(Args&&... args) :
+        rng_(std::forward<Args>(args)...)
+    {
+        // Nothing (else) to do...
+    }
+
+    template<typename Iter>
+    void generate(Iter start, Iter finish)
+    {
+        for (auto i = start; i != finish; ++i)
+            *i = result_type(rng_());
+    }
+
+    constexpr size_t size() const
+    {
+        return (sizeof(typename RngType::result_type) > sizeof(result_type)
+                && RngType::max() > ~size_t(0UL))
+             ? ~size_t(0UL)
+             : size_t(RngType::max());
+    }
+};
+
+/*
+ * Sometimes you might want a distinct seed based on when the program
+ * was compiled.  That way, a particular instance of the program will
+ * behave the same way, but when recompiled it'll produce a different
+ * value.
+ */
+
+template <typename IntType>
+struct static_arbitrary_seed {
+private:
+    static constexpr IntType fnv(IntType hash, const char* pos) {
+        return *pos == '\0'
+             ? hash
+             : fnv((hash * IntType(16777619U)) ^ *pos, (pos+1));
+    }
+
+public:
+    static constexpr IntType value = fnv(IntType(2166136261U ^ sizeof(IntType)),
+                        __DATE__ __TIME__ __FILE__);
+};
+
+// Sometimes, when debugging or testing, it's handy to be able print the name
+// of a (in human-readable form).  This code allows the idiom:
+//
+//      cout << printable_typename<my_foo_type_t>()
+//
+// to print out my_foo_type_t (or its concrete type if it is a synonym)
+
+#if __cpp_rtti || __GXX_RTTI
+
+template <typename T>
+struct printable_typename {};
+
+template <typename T>
+std::ostream& operator<<(std::ostream& out, printable_typename<T>) {
+    const char *implementation_typename = typeid(T).name();
+#ifdef __GNUC__
+    int status;
+    char* pretty_name =
+        abi::__cxa_demangle(implementation_typename, NULL, NULL, &status);
+    if (status == 0)
+        out << pretty_name;
+    free(static_cast<void*>(pretty_name));
+    if (status == 0)
+        return out;
+#endif
+    out << implementation_typename;
+    return out;
+}
+
+#endif  // __cpp_rtti || __GXX_RTTI
+
+} // namespace pcg_extras
+
+#endif // PCG_EXTRAS_HPP_INCLUDED
diff --git a/contrib/libpcg-random/include/pcg_random.hpp b/contrib/libpcg-random/include/pcg_random.hpp
new file mode 100644
index 00000000000..ea441013d18
--- /dev/null
+++ b/contrib/libpcg-random/include/pcg_random.hpp
@@ -0,0 +1,1771 @@
+/*
+ * PCG Random Number Generation for C++
+ *
+ * Copyright 2014-2017 Melissa O'Neill <oneill@pcg-random.org>,
+ *                     and the PCG Project contributors.
+ *
+ * SPDX-License-Identifier: (Apache-2.0 OR MIT)
+ *
+ * Licensed under the Apache License, Version 2.0 (provided in
+ * LICENSE-APACHE.txt and at http://www.apache.org/licenses/LICENSE-2.0)
+ * or under the MIT license (provided in LICENSE-MIT.txt and at
+ * http://opensource.org/licenses/MIT), at your option. This file may not
+ * be copied, modified, or distributed except according to those terms.
+ *
+ * Distributed on an "AS IS" BASIS, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied.  See your chosen license for details.
+ *
+ * For additional information about the PCG random number generation scheme,
+ * visit http://www.pcg-random.org/.
+ */
+
+/*
+ * This code provides the reference implementation of the PCG family of
+ * random number generators.  The code is complex because it implements
+ *
+ *      - several members of the PCG family, specifically members corresponding
+ *        to the output functions:
+ *             - XSH RR         (good for 64-bit state, 32-bit output)
+ *             - XSH RS         (good for 64-bit state, 32-bit output)
+ *             - XSL RR         (good for 128-bit state, 64-bit output)
+ *             - RXS M XS       (statistically most powerful generator)
+ *             - XSL RR RR      (good for 128-bit state, 128-bit output)
+ *             - and RXS, RXS M, XSH, XSL       (mostly for testing)
+ *      - at potentially *arbitrary* bit sizes
+ *      - with four different techniques for random streams (MCG, one-stream
+ *        LCG, settable-stream LCG, unique-stream LCG)
+ *      - and the extended generation schemes allowing arbitrary periods
+ *      - with all features of C++11 random number generation (and more),
+ *        some of which are somewhat painful, including
+ *            - initializing with a SeedSequence which writes 32-bit values
+ *              to memory, even though the state of the generator may not
+ *              use 32-bit values (it might use smaller or larger integers)
+ *            - I/O for RNGs and a prescribed format, which needs to handle
+ *              the issue that 8-bit and 128-bit integers don't have working
+ *              I/O routines (e.g., normally 8-bit = char, not integer)
+ *            - equality and inequality for RNGs
+ *      - and a number of convenience typedefs to mask all the complexity
+ *
+ * The code employes a fairly heavy level of abstraction, and has to deal
+ * with various C++ minutia.  If you're looking to learn about how the PCG
+ * scheme works, you're probably best of starting with one of the other
+ * codebases (see www.pcg-random.org).  But if you're curious about the
+ * constants for the various output functions used in those other, simpler,
+ * codebases, this code shows how they are calculated.
+ *
+ * On the positive side, at least there are convenience typedefs so that you
+ * can say
+ *
+ *      pcg32 myRNG;
+ *
+ * rather than:
+ *
+ *      pcg_detail::engine<
+ *          uint32_t,                                           // Output Type
+ *          uint64_t,                                           // State Type
+ *          pcg_detail::xsh_rr_mixin<uint32_t, uint64_t>, true, // Output Func
+ *          pcg_detail::specific_stream<uint64_t>,              // Stream Kind
+ *          pcg_detail::default_multiplier<uint64_t>            // LCG Mult
+ *      > myRNG;
+ *
+ */
+
+#ifndef PCG_RAND_HPP_INCLUDED
+#define PCG_RAND_HPP_INCLUDED 1
+
+#include <algorithm>
+#include <cinttypes>
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <cassert>
+#include <limits>
+#include <iostream>
+#include <iterator>
+#include <type_traits>
+#include <utility>
+#include <locale>
+#include <new>
+#include <stdexcept>
+
+#ifdef _MSC_VER
+    #pragma warning(disable:4146)
+#endif
+
+#ifdef _MSC_VER
+    #define PCG_ALWAYS_INLINE _forceinline
+#elif __GNUC__
+    #define PCG_ALWAYS_INLINE __attribute__((always_inline))
+#else
+    #define PCG_ALWAYS_INLINE inline
+#endif
+
+/*
+ * The pcg_extras namespace contains some support code that is likley to
+ * be useful for a variety of RNGs, including:
+ *      - 128-bit int support for platforms where it isn't available natively
+ *      - bit twiddling operations
+ *      - I/O of 128-bit and 8-bit integers
+ *      - Handling the evilness of SeedSeq
+ *      - Support for efficiently producing random numbers less than a given
+ *        bound
+ */
+
+#include "pcg_extras.hpp"
+
+namespace pcg_detail {
+
+using namespace pcg_extras;
+
+/*
+ * The LCG generators need some constants to function.  This code lets you
+ * look up the constant by *type*.  For example
+ *
+ *      default_multiplier<uint32_t>::multiplier()
+ *
+ * gives you the default multipler for 32-bit integers.  We use the name
+ * of the constant and not a generic word like value to allow these classes
+ * to be used as mixins.
+ */
+
+template <typename T>
+struct default_multiplier {
+    // Not defined for an arbitrary type
+};
+
+template <typename T>
+struct default_increment {
+    // Not defined for an arbitrary type
+};
+
+#define PCG_DEFINE_CONSTANT(type, what, kind, constant) \
+        template <>                                     \
+        struct what ## _ ## kind<type> {                \
+            static constexpr type kind() {              \
+                return constant;                        \
+            }                                           \
+        };
+
+PCG_DEFINE_CONSTANT(uint8_t,  default, multiplier, 141U)
+PCG_DEFINE_CONSTANT(uint8_t,  default, increment,  77U)
+
+PCG_DEFINE_CONSTANT(uint16_t, default, multiplier, 12829U)
+PCG_DEFINE_CONSTANT(uint16_t, default, increment,  47989U)
+
+PCG_DEFINE_CONSTANT(uint32_t, default, multiplier, 747796405U)
+PCG_DEFINE_CONSTANT(uint32_t, default, increment,  2891336453U)
+
+PCG_DEFINE_CONSTANT(uint64_t, default, multiplier, 6364136223846793005ULL)
+PCG_DEFINE_CONSTANT(uint64_t, default, increment,  1442695040888963407ULL)
+
+PCG_DEFINE_CONSTANT(pcg128_t, default, multiplier,
+        PCG_128BIT_CONSTANT(2549297995355413924ULL,4865540595714422341ULL))
+PCG_DEFINE_CONSTANT(pcg128_t, default, increment,
+        PCG_128BIT_CONSTANT(6364136223846793005ULL,1442695040888963407ULL))
+
+
+/*
+ * Each PCG generator is available in four variants, based on how it applies
+ * the additive constant for its underlying LCG; the variations are:
+ *
+ *     single stream   - all instances use the same fixed constant, thus
+ *                       the RNG always somewhere in same sequence
+ *     mcg             - adds zero, resulting in a single stream and reduced
+ *                       period
+ *     specific stream - the constant can be changed at any time, selecting
+ *                       a different random sequence
+ *     unique stream   - the constant is based on the memory addresss of the
+ *                       object, thus every RNG has its own unique sequence
+ *
+ * This variation is provided though mixin classes which define a function
+ * value called increment() that returns the nesessary additive constant.
+ */
+
+
+
+/*
+ * unique stream
+ */
+
+
+template <typename itype>
+class unique_stream {
+protected:
+    static constexpr bool is_mcg = false;
+
+    // Is never called, but is provided for symmetry with specific_stream
+    void set_stream(...)
+    {
+        abort();
+    }
+
+public:
+    typedef itype state_type;
+
+    constexpr itype increment() const {
+        return itype(reinterpret_cast<unsigned long>(this) | 1);
+    }
+
+    constexpr itype stream() const
+    {
+         return increment() >> 1;
+    }
+
+    static constexpr bool can_specify_stream = false;
+
+    static constexpr size_t streams_pow2()
+    {
+        return (sizeof(itype) < sizeof(size_t) ? sizeof(itype)
+                                               : sizeof(size_t))*8 - 1u;
+    }
+
+protected:
+    constexpr unique_stream() = default;
+};
+
+
+/*
+ * no stream (mcg)
+ */
+
+template <typename itype>
+class no_stream {
+protected:
+    static constexpr bool is_mcg = true;
+
+    // Is never called, but is provided for symmetry with specific_stream
+    void set_stream(...)
+    {
+        abort();
+    }
+
+public:
+    typedef itype state_type;
+
+    static constexpr itype increment() {
+        return 0;
+    }
+
+    static constexpr bool can_specify_stream = false;
+
+    static constexpr size_t streams_pow2()
+    {
+        return 0u;
+    }
+
+protected:
+    constexpr no_stream() = default;
+};
+
+
+/*
+ * single stream/sequence (oneseq)
+ */
+
+template <typename itype>
+class oneseq_stream : public default_increment<itype> {
+protected:
+    static constexpr bool is_mcg = false;
+
+    // Is never called, but is provided for symmetry with specific_stream
+    void set_stream(...)
+    {
+        abort();
+    }
+
+public:
+    typedef itype state_type;
+
+    static constexpr itype stream()
+    {
+         return default_increment<itype>::increment() >> 1;
+    }
+
+    static constexpr bool can_specify_stream = false;
+
+    static constexpr size_t streams_pow2()
+    {
+        return 0u;
+    }
+
+protected:
+    constexpr oneseq_stream() = default;
+};
+
+
+/*
+ * specific stream
+ */
+
+template <typename itype>
+class specific_stream {
+protected:
+    static constexpr bool is_mcg = false;
+
+    itype inc_ = default_increment<itype>::increment();
+
+public:
+    typedef itype state_type;
+    typedef itype stream_state;
+
+    constexpr itype increment() const {
+        return inc_;
+    }
+
+    itype stream()
+    {
+         return inc_ >> 1;
+    }
+
+    void set_stream(itype specific_seq)
+    {
+         inc_ = (specific_seq << 1) | 1;
+    }
+
+    static constexpr bool can_specify_stream = true;
+
+    static constexpr size_t streams_pow2()
+    {
+        return (sizeof(itype)*8) - 1u;
+    }
+
+protected:
+    specific_stream() = default;
+
+    specific_stream(itype specific_seq)
+        : inc_(itype(specific_seq << 1) | itype(1U))
+    {
+        // Nothing (else) to do.
+    }
+};
+
+
+/*
+ * This is where it all comes together.  This function joins together three
+ * mixin classes which define
+ *    - the LCG additive constant (the stream)
+ *    - the LCG multiplier
+ *    - the output function
+ * in addition, we specify the type of the LCG state, and the result type,
+ * and whether to use the pre-advance version of the state for the output
+ * (increasing instruction-level parallelism) or the post-advance version
+ * (reducing register pressure).
+ *
+ * Given the high level of parameterization, the code has to use some
+ * template-metaprogramming tricks to handle some of the suble variations
+ * involved.
+ */
+
+template <typename xtype, typename itype,
+          typename output_mixin,
+          bool output_previous = true,
+          typename stream_mixin = oneseq_stream<itype>,
+          typename multiplier_mixin = default_multiplier<itype> >
+class engine : protected output_mixin,
+               public stream_mixin,
+               protected multiplier_mixin {
+protected:
+    itype state_;
+
+    struct can_specify_stream_tag {};
+    struct no_specifiable_stream_tag {};
+
+    using stream_mixin::increment;
+    using multiplier_mixin::multiplier;
+
+public:
+    typedef xtype result_type;
+    typedef itype state_type;
+
+    static constexpr size_t period_pow2()
+    {
+        return sizeof(state_type)*8 - 2*stream_mixin::is_mcg;
+    }
+
+    // It would be nice to use std::numeric_limits for these, but
+    // we can't be sure that it'd be defined for the 128-bit types.
+
+    static constexpr result_type min()
+    {
+        return result_type(0UL);
+    }
+
+    static constexpr result_type max()
+    {
+        return result_type(~result_type(0UL));
+    }
+
+protected:
+    itype bump(itype state)
+    {
+        return state * multiplier() + increment();
+    }
+
+    itype base_generate()
+    {
+        return state_ = bump(state_);
+    }
+
+    itype base_generate0()
+    {
+        itype old_state = state_;
+        state_ = bump(state_);
+        return old_state;
+    }
+
+public:
+    result_type operator()()
+    {
+        if (output_previous)
+            return this->output(base_generate0());
+        else
+            return this->output(base_generate());
+    }
+
+    result_type operator()(result_type upper_bound)
+    {
+        return bounded_rand(*this, upper_bound);
+    }
+
+protected:
+    static itype advance(itype state, itype delta,
+                         itype cur_mult, itype cur_plus);
+
+    static itype distance(itype cur_state, itype newstate, itype cur_mult,
+                          itype cur_plus, itype mask = ~itype(0U));
+
+    itype distance(itype newstate, itype mask = itype(~itype(0U))) const
+    {
+        return distance(state_, newstate, multiplier(), increment(), mask);
+    }
+
+public:
+    void advance(itype delta)
+    {
+        state_ = advance(state_, delta, this->multiplier(), this->increment());
+    }
+
+    void backstep(itype delta)
+    {
+        advance(-delta);
+    }
+
+    void discard(itype delta)
+    {
+        advance(delta);
+    }
+
+    bool wrapped()
+    {
+        if (stream_mixin::is_mcg) {
+            // For MCGs, the low order two bits never change. In this
+            // implementation, we keep them fixed at 3 to make this test
+            // easier.
+            return state_ == 3;
+        } else {
+            return state_ == 0;
+        }
+    }
+
+    engine(itype state = itype(0xcafef00dd15ea5e5ULL))
+        : state_(this->is_mcg ? state|state_type(3U)
+                              : bump(state + this->increment()))
+    {
+        // Nothing else to do.
+    }
+
+    // This function may or may not exist.  It thus has to be a template
+    // to use SFINAE; users don't have to worry about its template-ness.
+
+    template <typename sm = stream_mixin>
+    engine(itype state, typename sm::stream_state stream_seed)
+        : stream_mixin(stream_seed),
+          state_(this->is_mcg ? state|state_type(3U)
+                              : bump(state + this->increment()))
+    {
+        // Nothing else to do.
+    }
+
+    template<typename SeedSeq>
+    engine(SeedSeq&& seedSeq, typename std::enable_if<
+                  !stream_mixin::can_specify_stream
+               && !std::is_convertible<SeedSeq, itype>::value
+               && !std::is_convertible<SeedSeq, engine>::value,
+               no_specifiable_stream_tag>::type = {})
+        : engine(generate_one<itype>(std::forward<SeedSeq>(seedSeq)))
+    {
+        // Nothing else to do.
+    }
+
+    template<typename SeedSeq>
+    engine(SeedSeq&& seedSeq, typename std::enable_if<
+                   stream_mixin::can_specify_stream
+               && !std::is_convertible<SeedSeq, itype>::value
+               && !std::is_convertible<SeedSeq, engine>::value,
+        can_specify_stream_tag>::type = {})
+        : engine(generate_one<itype,1,2>(seedSeq),
+                 generate_one<itype,0,2>(seedSeq))
+    {
+        // Nothing else to do.
+    }
+
+
+    template<typename... Args>
+    void seed(Args&&... args)
+    {
+        new (this) engine(std::forward<Args>(args)...);
+    }
+
+    template <typename xtype1, typename itype1,
+              typename output_mixin1, bool output_previous1,
+              typename stream_mixin_lhs, typename multiplier_mixin_lhs,
+              typename stream_mixin_rhs, typename multiplier_mixin_rhs>
+    friend bool operator==(const engine<xtype1,itype1,
+                                     output_mixin1,output_previous1,
+                                     stream_mixin_lhs, multiplier_mixin_lhs>&,
+                           const engine<xtype1,itype1,
+                                     output_mixin1,output_previous1,
+                                     stream_mixin_rhs, multiplier_mixin_rhs>&);
+
+    template <typename xtype1, typename itype1,
+              typename output_mixin1, bool output_previous1,
+              typename stream_mixin_lhs, typename multiplier_mixin_lhs,
+              typename stream_mixin_rhs, typename multiplier_mixin_rhs>
+    friend itype1 operator-(const engine<xtype1,itype1,
+                                     output_mixin1,output_previous1,
+                                     stream_mixin_lhs, multiplier_mixin_lhs>&,
+                            const engine<xtype1,itype1,
+                                     output_mixin1,output_previous1,
+                                     stream_mixin_rhs, multiplier_mixin_rhs>&);
+
+    template <typename CharT, typename Traits,
+              typename xtype1, typename itype1,
+              typename output_mixin1, bool output_previous1,
+              typename stream_mixin1, typename multiplier_mixin1>
+    friend std::basic_ostream<CharT,Traits>&
+    operator<<(std::basic_ostream<CharT,Traits>& out,
+               const engine<xtype1,itype1,
+                              output_mixin1,output_previous1,
+                              stream_mixin1, multiplier_mixin1>&);
+
+    template <typename CharT, typename Traits,
+              typename xtype1, typename itype1,
+              typename output_mixin1, bool output_previous1,
+              typename stream_mixin1, typename multiplier_mixin1>
+    friend std::basic_istream<CharT,Traits>&
+    operator>>(std::basic_istream<CharT,Traits>& in,
+               engine<xtype1, itype1,
+                        output_mixin1, output_previous1,
+                        stream_mixin1, multiplier_mixin1>& rng);
+};
+
+template <typename CharT, typename Traits,
+          typename xtype, typename itype,
+          typename output_mixin, bool output_previous,
+          typename stream_mixin, typename multiplier_mixin>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits>& out,
+           const engine<xtype,itype,
+                          output_mixin,output_previous,
+                          stream_mixin, multiplier_mixin>& rng)
+{
+    auto orig_flags = out.flags(std::ios_base::dec | std::ios_base::left);
+    auto space = out.widen(' ');
+    auto orig_fill = out.fill();
+
+    out << rng.multiplier() << space
+        << rng.increment() << space
+        << rng.state_;
+
+    out.flags(orig_flags);
+    out.fill(orig_fill);
+    return out;
+}
+
+
+template <typename CharT, typename Traits,
+          typename xtype, typename itype,
+          typename output_mixin, bool output_previous,
+          typename stream_mixin, typename multiplier_mixin>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits>& in,
+           engine<xtype,itype,
+                    output_mixin,output_previous,
+                    stream_mixin, multiplier_mixin>& rng)
+{
+    auto orig_flags = in.flags(std::ios_base::dec | std::ios_base::skipws);
+
+    itype multiplier, increment, state;
+    in >> multiplier >> increment >> state;
+
+    if (!in.fail()) {
+        bool good = true;
+        if (multiplier != rng.multiplier()) {
+           good = false;
+        } else if (rng.can_specify_stream) {
+           rng.set_stream(increment >> 1);
+        } else if (increment != rng.increment()) {
+           good = false;
+        }
+        if (good) {
+            rng.state_ = state;
+        } else {
+            in.clear(std::ios::failbit);
+        }
+    }
+
+    in.flags(orig_flags);
+    return in;
+}
+
+
+template <typename xtype, typename itype,
+          typename output_mixin, bool output_previous,
+          typename stream_mixin, typename multiplier_mixin>
+itype engine<xtype,itype,output_mixin,output_previous,stream_mixin,
+             multiplier_mixin>::advance(
+    itype state, itype delta, itype cur_mult, itype cur_plus)
+{
+    // The method used here is based on Brown, "Random Number Generation
+    // with Arbitrary Stride,", Transactions of the American Nuclear
+    // Society (Nov. 1994).  The algorithm is very similar to fast
+    // exponentiation.
+    //
+    // Even though delta is an unsigned integer, we can pass a
+    // signed integer to go backwards, it just goes "the long way round".
+
+    constexpr itype ZERO = 0u;  // itype may be a non-trivial types, so
+    constexpr itype ONE  = 1u;  // we define some ugly constants.
+    itype acc_mult = 1;
+    itype acc_plus = 0;
+    while (delta > ZERO) {
+       if (delta & ONE) {
+          acc_mult *= cur_mult;
+          acc_plus = acc_plus*cur_mult + cur_plus;
+       }
+       cur_plus = (cur_mult+ONE)*cur_plus;
+       cur_mult *= cur_mult;
+       delta >>= 1;
+    }
+    return acc_mult * state + acc_plus;
+}
+
+template <typename xtype, typename itype,
+          typename output_mixin, bool output_previous,
+          typename stream_mixin, typename multiplier_mixin>
+itype engine<xtype,itype,output_mixin,output_previous,stream_mixin,
+               multiplier_mixin>::distance(
+    itype cur_state, itype newstate, itype cur_mult, itype cur_plus, itype mask)
+{
+    constexpr itype ONE  = 1u;  // itype could be weird, so use constant
+    itype the_bit = stream_mixin::is_mcg ? itype(4u) : itype(1u);
+    itype distance = 0u;
+    while ((cur_state & mask) != (newstate & mask)) {
+       if ((cur_state & the_bit) != (newstate & the_bit)) {
+           cur_state = cur_state * cur_mult + cur_plus;
+           distance |= the_bit;
+       }
+       assert((cur_state & the_bit) == (newstate & the_bit));
+       the_bit <<= 1;
+       cur_plus = (cur_mult+ONE)*cur_plus;
+       cur_mult *= cur_mult;
+    }
+    return stream_mixin::is_mcg ? distance >> 2 : distance;
+}
+
+template <typename xtype, typename itype,
+          typename output_mixin, bool output_previous,
+          typename stream_mixin_lhs, typename multiplier_mixin_lhs,
+          typename stream_mixin_rhs, typename multiplier_mixin_rhs>
+itype operator-(const engine<xtype,itype,
+                               output_mixin,output_previous,
+                               stream_mixin_lhs, multiplier_mixin_lhs>& lhs,
+               const engine<xtype,itype,
+                               output_mixin,output_previous,
+                               stream_mixin_rhs, multiplier_mixin_rhs>& rhs)
+{
+    static_assert(
+        std::is_same<stream_mixin_lhs, stream_mixin_rhs>::value &&
+            std::is_same<multiplier_mixin_lhs, multiplier_mixin_rhs>::value,
+        "Incomparable generators");
+    return rhs.distance(lhs.state_);
+}
+
+
+template <typename xtype, typename itype,
+          typename output_mixin, bool output_previous,
+          typename stream_mixin_lhs, typename multiplier_mixin_lhs,
+          typename stream_mixin_rhs, typename multiplier_mixin_rhs>
+bool operator==(const engine<xtype,itype,
+                               output_mixin,output_previous,
+                               stream_mixin_lhs, multiplier_mixin_lhs>& lhs,
+                const engine<xtype,itype,
+                               output_mixin,output_previous,
+                               stream_mixin_rhs, multiplier_mixin_rhs>& rhs)
+{
+    return    (lhs.multiplier() == rhs.multiplier())
+           && (lhs.increment()  == rhs.increment())
+           && (lhs.state_       == rhs.state_);
+}
+
+template <typename xtype, typename itype,
+          typename output_mixin, bool output_previous,
+          typename stream_mixin_lhs, typename multiplier_mixin_lhs,
+          typename stream_mixin_rhs, typename multiplier_mixin_rhs>
+inline bool operator!=(const engine<xtype,itype,
+                               output_mixin,output_previous,
+                               stream_mixin_lhs, multiplier_mixin_lhs>& lhs,
+                       const engine<xtype,itype,
+                               output_mixin,output_previous,
+                               stream_mixin_rhs, multiplier_mixin_rhs>& rhs)
+{
+    return !operator==(lhs,rhs);
+}
+
+
+template <typename xtype, typename itype,
+         template<typename XT,typename IT> class output_mixin,
+         bool output_previous = (sizeof(itype) <= 8)>
+using oneseq_base  = engine<xtype, itype,
+                        output_mixin<xtype, itype>, output_previous,
+                        oneseq_stream<itype> >;
+
+template <typename xtype, typename itype,
+         template<typename XT,typename IT> class output_mixin,
+         bool output_previous = (sizeof(itype) <= 8)>
+using unique_base = engine<xtype, itype,
+                         output_mixin<xtype, itype>, output_previous,
+                         unique_stream<itype> >;
+
+template <typename xtype, typename itype,
+         template<typename XT,typename IT> class output_mixin,
+         bool output_previous = (sizeof(itype) <= 8)>
+using setseq_base = engine<xtype, itype,
+                         output_mixin<xtype, itype>, output_previous,
+                         specific_stream<itype> >;
+
+template <typename xtype, typename itype,
+         template<typename XT,typename IT> class output_mixin,
+         bool output_previous = (sizeof(itype) <= 8)>
+using mcg_base = engine<xtype, itype,
+                      output_mixin<xtype, itype>, output_previous,
+                      no_stream<itype> >;
+
+/*
+ * OUTPUT FUNCTIONS.
+ *
+ * These are the core of the PCG generation scheme.  They specify how to
+ * turn the base LCG's internal state into the output value of the final
+ * generator.
+ *
+ * They're implemented as mixin classes.
+ *
+ * All of the classes have code that is written to allow it to be applied
+ * at *arbitrary* bit sizes, although in practice they'll only be used at
+ * standard sizes supported by C++.
+ */
+
+/*
+ * XSH RS -- high xorshift, followed by a random shift
+ *
+ * Fast.  A good performer.
+ */
+
+template <typename xtype, typename itype>
+struct xsh_rs_mixin {
+    static xtype output(itype internal)
+    {
+        constexpr bitcount_t bits        = bitcount_t(sizeof(itype) * 8);
+        constexpr bitcount_t xtypebits   = bitcount_t(sizeof(xtype) * 8);
+        constexpr bitcount_t sparebits   = bits - xtypebits;
+        constexpr bitcount_t opbits =
+                              sparebits-5 >= 64 ? 5
+                            : sparebits-4 >= 32 ? 4
+                            : sparebits-3 >= 16 ? 3
+                            : sparebits-2 >= 4  ? 2
+                            : sparebits-1 >= 1  ? 1
+                            :                     0;
+        constexpr bitcount_t mask = (1 << opbits) - 1;
+        constexpr bitcount_t maxrandshift  = mask;
+        constexpr bitcount_t topspare     = opbits;
+        constexpr bitcount_t bottomspare = sparebits - topspare;
+        constexpr bitcount_t xshift     = topspare + (xtypebits+maxrandshift)/2;
+        bitcount_t rshift =
+            opbits ? bitcount_t(internal >> (bits - opbits)) & mask : 0;
+        internal ^= internal >> xshift;
+        xtype result = xtype(internal >> (bottomspare - maxrandshift + rshift));
+        return result;
+    }
+};
+
+/*
+ * XSH RR -- high xorshift, followed by a random rotate
+ *
+ * Fast.  A good performer.  Slightly better statistically than XSH RS.
+ */
+
+template <typename xtype, typename itype>
+struct xsh_rr_mixin {
+    static xtype output(itype internal)
+    {
+        constexpr bitcount_t bits        = bitcount_t(sizeof(itype) * 8);
+        constexpr bitcount_t xtypebits   = bitcount_t(sizeof(xtype)*8);
+        constexpr bitcount_t sparebits   = bits - xtypebits;
+        constexpr bitcount_t wantedopbits =
+                              xtypebits >= 128 ? 7
+                            : xtypebits >=  64 ? 6
+                            : xtypebits >=  32 ? 5
+                            : xtypebits >=  16 ? 4
+                            :                    3;
+        constexpr bitcount_t opbits =
+                              sparebits >= wantedopbits ? wantedopbits
+                                                        : sparebits;
+        constexpr bitcount_t amplifier = wantedopbits - opbits;
+        constexpr bitcount_t mask = (1 << opbits) - 1;
+        constexpr bitcount_t topspare    = opbits;
+        constexpr bitcount_t bottomspare = sparebits - topspare;
+        constexpr bitcount_t xshift      = (topspare + xtypebits)/2;
+        bitcount_t rot = opbits ? bitcount_t(internal >> (bits - opbits)) & mask
+                                : 0;
+        bitcount_t amprot = (rot << amplifier) & mask;
+        internal ^= internal >> xshift;
+        xtype result = xtype(internal >> bottomspare);
+        result = rotr(result, amprot);
+        return result;
+    }
+};
+
+/*
+ * RXS -- random xorshift
+ */
+
+template <typename xtype, typename itype>
+struct rxs_mixin {
+static xtype output_rxs(itype internal)
+    {
+        constexpr bitcount_t bits        = bitcount_t(sizeof(itype) * 8);
+        constexpr bitcount_t xtypebits   = bitcount_t(sizeof(xtype)*8);
+        constexpr bitcount_t shift       = bits - xtypebits;
+        constexpr bitcount_t extrashift  = (xtypebits - shift)/2;
+        bitcount_t rshift = shift > 64+8 ? (internal >> (bits - 6)) & 63
+                       : shift > 32+4 ? (internal >> (bits - 5)) & 31
+                       : shift > 16+2 ? (internal >> (bits - 4)) & 15
+                       : shift >  8+1 ? (internal >> (bits - 3)) & 7
+                       : shift >  4+1 ? (internal >> (bits - 2)) & 3
+                       : shift >  2+1 ? (internal >> (bits - 1)) & 1
+                       :              0;
+        internal ^= internal >> (shift + extrashift - rshift);
+        xtype result = internal >> rshift;
+        return result;
+    }
+};
+
+/*
+ * RXS M XS -- random xorshift, mcg multiply, fixed xorshift
+ *
+ * The most statistically powerful generator, but all those steps
+ * make it slower than some of the others.  We give it the rottenest jobs.
+ *
+ * Because it's usually used in contexts where the state type and the
+ * result type are the same, it is a permutation and is thus invertable.
+ * We thus provide a function to invert it.  This function is used to
+ * for the "inside out" generator used by the extended generator.
+ */
+
+/* Defined type-based concepts for the multiplication step.  They're actually
+ * all derived by truncating the 128-bit, which was computed to be a good
+ * "universal" constant.
+ */
+
+template <typename T>
+struct mcg_multiplier {
+    // Not defined for an arbitrary type
+};
+
+template <typename T>
+struct mcg_unmultiplier {
+    // Not defined for an arbitrary type
+};
+
+PCG_DEFINE_CONSTANT(uint8_t,  mcg, multiplier,   217U)
+PCG_DEFINE_CONSTANT(uint8_t,  mcg, unmultiplier, 105U)
+
+PCG_DEFINE_CONSTANT(uint16_t, mcg, multiplier,   62169U)
+PCG_DEFINE_CONSTANT(uint16_t, mcg, unmultiplier, 28009U)
+
+PCG_DEFINE_CONSTANT(uint32_t, mcg, multiplier,   277803737U)
+PCG_DEFINE_CONSTANT(uint32_t, mcg, unmultiplier, 2897767785U)
+
+PCG_DEFINE_CONSTANT(uint64_t, mcg, multiplier,   12605985483714917081ULL)
+PCG_DEFINE_CONSTANT(uint64_t, mcg, unmultiplier, 15009553638781119849ULL)
+
+PCG_DEFINE_CONSTANT(pcg128_t, mcg, multiplier,
+        PCG_128BIT_CONSTANT(17766728186571221404ULL, 12605985483714917081ULL))
+PCG_DEFINE_CONSTANT(pcg128_t, mcg, unmultiplier,
+        PCG_128BIT_CONSTANT(14422606686972528997ULL, 15009553638781119849ULL))
+
+
+template <typename xtype, typename itype>
+struct rxs_m_xs_mixin {
+    static xtype output(itype internal)
+    {
+        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
+        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
+        constexpr bitcount_t opbits = xtypebits >= 128 ? 6
+                                 : xtypebits >=  64 ? 5
+                                 : xtypebits >=  32 ? 4
+                                 : xtypebits >=  16 ? 3
+                                 :                    2;
+        constexpr bitcount_t shift = bits - xtypebits;
+        constexpr bitcount_t mask = (1 << opbits) - 1;
+        bitcount_t rshift =
+            opbits ? bitcount_t(internal >> (bits - opbits)) & mask : 0;
+        internal ^= internal >> (opbits + rshift);
+        internal *= mcg_multiplier<itype>::multiplier();
+        xtype result = internal >> shift;
+        result ^= result >> ((2U*xtypebits+2U)/3U);
+        return result;
+    }
+
+    static itype unoutput(itype internal)
+    {
+        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
+        constexpr bitcount_t opbits = bits >= 128 ? 6
+                                 : bits >=  64 ? 5
+                                 : bits >=  32 ? 4
+                                 : bits >=  16 ? 3
+                                 :               2;
+        constexpr bitcount_t mask = (1 << opbits) - 1;
+
+        internal = unxorshift(internal, bits, (2U*bits+2U)/3U);
+
+        internal *= mcg_unmultiplier<itype>::unmultiplier();
+
+        bitcount_t rshift = opbits ? (internal >> (bits - opbits)) & mask : 0;
+        internal = unxorshift(internal, bits, opbits + rshift);
+
+        return internal;
+    }
+};
+
+
+/*
+ * RXS M -- random xorshift, mcg multiply
+ */
+
+template <typename xtype, typename itype>
+struct rxs_m_mixin {
+    static xtype output(itype internal)
+    {
+        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
+        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
+        constexpr bitcount_t opbits = xtypebits >= 128 ? 6
+                                 : xtypebits >=  64 ? 5
+                                 : xtypebits >=  32 ? 4
+                                 : xtypebits >=  16 ? 3
+                                 :                    2;
+        constexpr bitcount_t shift = bits - xtypebits;
+        constexpr bitcount_t mask = (1 << opbits) - 1;
+        bitcount_t rshift = opbits ? (internal >> (bits - opbits)) & mask : 0;
+        internal ^= internal >> (opbits + rshift);
+        internal *= mcg_multiplier<itype>::multiplier();
+        xtype result = internal >> shift;
+        return result;
+    }
+};
+
+/*
+ * XSL RR -- fixed xorshift (to low bits), random rotate
+ *
+ * Useful for 128-bit types that are split across two CPU registers.
+ */
+
+template <typename xtype, typename itype>
+struct xsl_rr_mixin {
+    static xtype output(itype internal)
+    {
+        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
+        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
+        constexpr bitcount_t sparebits = bits - xtypebits;
+        constexpr bitcount_t wantedopbits = xtypebits >= 128 ? 7
+                                       : xtypebits >=  64 ? 6
+                                       : xtypebits >=  32 ? 5
+                                       : xtypebits >=  16 ? 4
+                                       :                    3;
+        constexpr bitcount_t opbits = sparebits >= wantedopbits ? wantedopbits
+                                                             : sparebits;
+        constexpr bitcount_t amplifier = wantedopbits - opbits;
+        constexpr bitcount_t mask = (1 << opbits) - 1;
+        constexpr bitcount_t topspare = sparebits;
+        constexpr bitcount_t bottomspare = sparebits - topspare;
+        constexpr bitcount_t xshift = (topspare + xtypebits) / 2;
+
+        bitcount_t rot =
+            opbits ? bitcount_t(internal >> (bits - opbits)) & mask : 0;
+        bitcount_t amprot = (rot << amplifier) & mask;
+        internal ^= internal >> xshift;
+        xtype result = xtype(internal >> bottomspare);
+        result = rotr(result, amprot);
+        return result;
+    }
+};
+
+
+/*
+ * XSL RR RR -- fixed xorshift (to low bits), random rotate (both parts)
+ *
+ * Useful for 128-bit types that are split across two CPU registers.
+ * If you really want an invertable 128-bit RNG, I guess this is the one.
+ */
+
+template <typename T> struct halfsize_trait {};
+template <> struct halfsize_trait<pcg128_t>  { typedef uint64_t type; };
+template <> struct halfsize_trait<uint64_t>  { typedef uint32_t type; };
+template <> struct halfsize_trait<uint32_t>  { typedef uint16_t type; };
+template <> struct halfsize_trait<uint16_t>  { typedef uint8_t type;  };
+
+template <typename xtype, typename itype>
+struct xsl_rr_rr_mixin {
+    typedef typename halfsize_trait<itype>::type htype;
+
+    static itype output(itype internal)
+    {
+        constexpr bitcount_t htypebits = bitcount_t(sizeof(htype) * 8);
+        constexpr bitcount_t bits      = bitcount_t(sizeof(itype) * 8);
+        constexpr bitcount_t sparebits = bits - htypebits;
+        constexpr bitcount_t wantedopbits = htypebits >= 128 ? 7
+                                       : htypebits >=  64 ? 6
+                                       : htypebits >=  32 ? 5
+                                       : htypebits >=  16 ? 4
+                                       :                    3;
+        constexpr bitcount_t opbits = sparebits >= wantedopbits ? wantedopbits
+                                                                : sparebits;
+        constexpr bitcount_t amplifier = wantedopbits - opbits;
+        constexpr bitcount_t mask = (1 << opbits) - 1;
+        constexpr bitcount_t topspare = sparebits;
+        constexpr bitcount_t xshift = (topspare + htypebits) / 2;
+
+        bitcount_t rot =
+            opbits ? bitcount_t(internal >> (bits - opbits)) & mask : 0;
+        bitcount_t amprot = (rot << amplifier) & mask;
+        internal ^= internal >> xshift;
+        htype lowbits = htype(internal);
+        lowbits = rotr(lowbits, amprot);
+        htype highbits = htype(internal >> topspare);
+        bitcount_t rot2 = lowbits & mask;
+        bitcount_t amprot2 = (rot2 << amplifier) & mask;
+        highbits = rotr(highbits, amprot2);
+        return (itype(highbits) << topspare) ^ itype(lowbits);
+    }
+};
+
+
+/*
+ * XSH -- fixed xorshift (to high bits)
+ *
+ * You shouldn't use this at 64-bits or less.
+ */
+
+template <typename xtype, typename itype>
+struct xsh_mixin {
+    static xtype output(itype internal)
+    {
+        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
+        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
+        constexpr bitcount_t sparebits = bits - xtypebits;
+        constexpr bitcount_t topspare = 0;
+        constexpr bitcount_t bottomspare = sparebits - topspare;
+        constexpr bitcount_t xshift = (topspare + xtypebits) / 2;
+
+        internal ^= internal >> xshift;
+        xtype result = internal >> bottomspare;
+        return result;
+    }
+};
+
+/*
+ * XSL -- fixed xorshift (to low bits)
+ *
+ * You shouldn't use this at 64-bits or less.
+ */
+
+template <typename xtype, typename itype>
+struct xsl_mixin {
+    inline xtype output(itype internal)
+    {
+        constexpr bitcount_t xtypebits = bitcount_t(sizeof(xtype) * 8);
+        constexpr bitcount_t bits = bitcount_t(sizeof(itype) * 8);
+        constexpr bitcount_t sparebits = bits - xtypebits;
+        constexpr bitcount_t topspare = sparebits;
+        constexpr bitcount_t bottomspare = sparebits - topspare;
+        constexpr bitcount_t xshift = (topspare + xtypebits) / 2;
+
+        internal ^= internal >> xshift;
+        xtype result = internal >> bottomspare;
+        return result;
+    }
+};
+
+/* ---- End of Output Functions ---- */
+
+
+template <typename baseclass>
+struct inside_out : private baseclass {
+    inside_out() = delete;
+
+    typedef typename baseclass::result_type result_type;
+    typedef typename baseclass::state_type  state_type;
+    static_assert(sizeof(result_type) == sizeof(state_type),
+                  "Require a RNG whose output function is a permutation");
+
+    static bool external_step(result_type& randval, size_t i)
+    {
+        state_type state = baseclass::unoutput(randval);
+        state = state * baseclass::multiplier() + baseclass::increment()
+                + state_type(i*2);
+        result_type result = baseclass::output(state);
+        randval = result;
+        state_type zero =
+            baseclass::is_mcg ? state & state_type(3U) : state_type(0U);
+        return result == zero;
+    }
+
+    static bool external_advance(result_type& randval, size_t i,
+                                 result_type delta, bool forwards = true)
+    {
+        state_type state = baseclass::unoutput(randval);
+        state_type mult  = baseclass::multiplier();
+        state_type inc   = baseclass::increment() + state_type(i*2);
+        state_type zero =
+            baseclass::is_mcg ? state & state_type(3U) : state_type(0U);
+        state_type dist_to_zero = baseclass::distance(state, zero, mult, inc);
+        bool crosses_zero =
+            forwards ? dist_to_zero <= delta
+                     : (-dist_to_zero) <= delta;
+        if (!forwards)
+            delta = -delta;
+        state = baseclass::advance(state, delta, mult, inc);
+        randval = baseclass::output(state);
+        return crosses_zero;
+    }
+};
+
+
+template <bitcount_t table_pow2, bitcount_t advance_pow2, typename baseclass, typename extvalclass, bool kdd = true>
+class extended : public baseclass {
+public:
+    typedef typename baseclass::state_type  state_type;
+    typedef typename baseclass::result_type result_type;
+    typedef inside_out<extvalclass> insideout;
+
+private:
+    static constexpr bitcount_t rtypebits = sizeof(result_type)*8;
+    static constexpr bitcount_t stypebits = sizeof(state_type)*8;
+
+    static constexpr bitcount_t tick_limit_pow2 = 64U;
+
+    static constexpr size_t table_size  = 1UL << table_pow2;
+    static constexpr size_t table_shift = stypebits - table_pow2;
+    static constexpr state_type table_mask =
+        (state_type(1U) << table_pow2) - state_type(1U);
+
+    static constexpr bool   may_tick  =
+        (advance_pow2 < stypebits) && (advance_pow2 < tick_limit_pow2);
+    static constexpr size_t tick_shift = stypebits - advance_pow2;
+    static constexpr state_type tick_mask  =
+        may_tick ? state_type(
+                       (uint64_t(1) << (advance_pow2*may_tick)) - 1)
+                                        // ^-- stupidity to appease GCC warnings
+                 : ~state_type(0U);
+
+    static constexpr bool may_tock = stypebits < tick_limit_pow2;
+
+    result_type data_[table_size];
+
+    PCG_NOINLINE void advance_table();
+
+    PCG_NOINLINE void advance_table(state_type delta, bool isForwards = true);
+
+    result_type& get_extended_value()
+    {
+        state_type state = this->state_;
+        if (kdd && baseclass::is_mcg) {
+            // The low order bits of an MCG are constant, so drop them.
+            state >>= 2;
+        }
+        size_t index       = kdd ? state &  table_mask
+                                 : state >> table_shift;
+
+        if (may_tick) {
+            bool tick = kdd ? (state & tick_mask) == state_type(0u)
+                            : (state >> tick_shift) == state_type(0u);
+            if (tick)
+                    advance_table();
+        }
+        if (may_tock) {
+            bool tock = state == state_type(0u);
+            if (tock)
+                advance_table();
+        }
+        return data_[index];
+    }
+
+public:
+    static constexpr size_t period_pow2()
+    {
+        return baseclass::period_pow2() + table_size*extvalclass::period_pow2();
+    }
+
+    PCG_ALWAYS_INLINE result_type operator()()
+    {
+        result_type rhs = get_extended_value();
+        result_type lhs = this->baseclass::operator()();
+        return lhs ^ rhs;
+    }
+
+    result_type operator()(result_type upper_bound)
+    {
+        return bounded_rand(*this, upper_bound);
+    }
+
+    void set(result_type wanted)
+    {
+        result_type& rhs = get_extended_value();
+        result_type lhs = this->baseclass::operator()();
+        rhs = lhs ^ wanted;
+    }
+
+    void advance(state_type distance, bool forwards = true);
+
+    void backstep(state_type distance)
+    {
+        advance(distance, false);
+    }
+
+    extended(const result_type* data)
+        : baseclass()
+    {
+        datainit(data);
+    }
+
+    extended(const result_type* data, state_type seed)
+        : baseclass(seed)
+    {
+        datainit(data);
+    }
+
+    // This function may or may not exist.  It thus has to be a template
+    // to use SFINAE; users don't have to worry about its template-ness.
+
+    template <typename bc = baseclass>
+    extended(const result_type* data, state_type seed,
+            typename bc::stream_state stream_seed)
+        : baseclass(seed, stream_seed)
+    {
+        datainit(data);
+    }
+
+    extended()
+        : baseclass()
+    {
+        selfinit();
+    }
+
+    extended(state_type seed)
+        : baseclass(seed)
+    {
+        selfinit();
+    }
+
+    // This function may or may not exist.  It thus has to be a template
+    // to use SFINAE; users don't have to worry about its template-ness.
+
+    template <typename bc = baseclass>
+    extended(state_type seed, typename bc::stream_state stream_seed)
+        : baseclass(seed, stream_seed)
+    {
+        selfinit();
+    }
+
+private:
+    void selfinit();
+    void datainit(const result_type* data);
+
+public:
+
+    template<typename SeedSeq, typename = typename std::enable_if<
+           !std::is_convertible<SeedSeq, result_type>::value
+        && !std::is_convertible<SeedSeq, extended>::value>::type>
+    extended(SeedSeq&& seedSeq)
+        : baseclass(seedSeq)
+    {
+        generate_to<table_size>(seedSeq, data_);
+    }
+
+    template<typename... Args>
+    void seed(Args&&... args)
+    {
+        new (this) extended(std::forward<Args>(args)...);
+    }
+
+    template <bitcount_t table_pow2_, bitcount_t advance_pow2_,
+              typename baseclass_, typename extvalclass_, bool kdd_>
+    friend bool operator==(const extended<table_pow2_, advance_pow2_,
+                                              baseclass_, extvalclass_, kdd_>&,
+                           const extended<table_pow2_, advance_pow2_,
+                                              baseclass_, extvalclass_, kdd_>&);
+
+    template <typename CharT, typename Traits,
+              bitcount_t table_pow2_, bitcount_t advance_pow2_,
+              typename baseclass_, typename extvalclass_, bool kdd_>
+    friend std::basic_ostream<CharT,Traits>&
+    operator<<(std::basic_ostream<CharT,Traits>& out,
+               const extended<table_pow2_, advance_pow2_,
+                              baseclass_, extvalclass_, kdd_>&);
+
+    template <typename CharT, typename Traits,
+              bitcount_t table_pow2_, bitcount_t advance_pow2_,
+              typename baseclass_, typename extvalclass_, bool kdd_>
+    friend std::basic_istream<CharT,Traits>&
+    operator>>(std::basic_istream<CharT,Traits>& in,
+               extended<table_pow2_, advance_pow2_,
+                        baseclass_, extvalclass_, kdd_>&);
+
+};
+
+
+template <bitcount_t table_pow2, bitcount_t advance_pow2,
+          typename baseclass, typename extvalclass, bool kdd>
+void extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::datainit(
+         const result_type* data)
+{
+    for (size_t i = 0; i < table_size; ++i)
+        data_[i] = data[i];
+}
+
+template <bitcount_t table_pow2, bitcount_t advance_pow2,
+          typename baseclass, typename extvalclass, bool kdd>
+void extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::selfinit()
+{
+    // We need to fill the extended table with something, and we have
+    // very little provided data, so we use the base generator to
+    // produce values.  Although not ideal (use a seed sequence, folks!),
+    // unexpected correlations are mitigated by
+    //      - using XOR differences rather than the number directly
+    //      - the way the table is accessed, its values *won't* be accessed
+    //        in the same order the were written.
+    //      - any strange correlations would only be apparent if we
+    //        were to backstep the generator so that the base generator
+    //        was generating the same values again
+    result_type xdiff = baseclass::operator()() - baseclass::operator()();
+    for (size_t i = 0; i < table_size; ++i) {
+        data_[i] = baseclass::operator()() ^ xdiff;
+    }
+}
+
+template <bitcount_t table_pow2, bitcount_t advance_pow2,
+          typename baseclass, typename extvalclass, bool kdd>
+bool operator==(const extended<table_pow2, advance_pow2,
+                               baseclass, extvalclass, kdd>& lhs,
+                const extended<table_pow2, advance_pow2,
+                               baseclass, extvalclass, kdd>& rhs)
+{
+    auto& base_lhs = static_cast<const baseclass&>(lhs);
+    auto& base_rhs = static_cast<const baseclass&>(rhs);
+    return base_lhs == base_rhs
+        && std::equal(
+               std::begin(lhs.data_), std::end(lhs.data_),
+               std::begin(rhs.data_)
+           );
+}
+
+template <bitcount_t table_pow2, bitcount_t advance_pow2,
+          typename baseclass, typename extvalclass, bool kdd>
+inline bool operator!=(const extended<table_pow2, advance_pow2,
+                                      baseclass, extvalclass, kdd>& lhs,
+                       const extended<table_pow2, advance_pow2,
+                                      baseclass, extvalclass, kdd>& rhs)
+{
+    return !operator==(lhs, rhs);
+}
+
+template <typename CharT, typename Traits,
+          bitcount_t table_pow2, bitcount_t advance_pow2,
+          typename baseclass, typename extvalclass, bool kdd>
+std::basic_ostream<CharT,Traits>&
+operator<<(std::basic_ostream<CharT,Traits>& out,
+           const extended<table_pow2, advance_pow2,
+                          baseclass, extvalclass, kdd>& rng)
+{
+    auto orig_flags = out.flags(std::ios_base::dec | std::ios_base::left);
+    auto space = out.widen(' ');
+    auto orig_fill = out.fill();
+
+    out << rng.multiplier() << space
+        << rng.increment() << space
+        << rng.state_;
+
+    for (const auto& datum : rng.data_)
+        out << space << datum;
+
+    out.flags(orig_flags);
+    out.fill(orig_fill);
+    return out;
+}
+
+template <typename CharT, typename Traits,
+          bitcount_t table_pow2, bitcount_t advance_pow2,
+          typename baseclass, typename extvalclass, bool kdd>
+std::basic_istream<CharT,Traits>&
+operator>>(std::basic_istream<CharT,Traits>& in,
+           extended<table_pow2, advance_pow2,
+                    baseclass, extvalclass, kdd>& rng)
+{
+    extended<table_pow2, advance_pow2, baseclass, extvalclass> new_rng;
+    auto& base_rng = static_cast<baseclass&>(new_rng);
+    in >> base_rng;
+
+    if (in.fail())
+        return in;
+
+    auto orig_flags = in.flags(std::ios_base::dec | std::ios_base::skipws);
+
+    for (auto& datum : new_rng.data_) {
+        in >> datum;
+        if (in.fail())
+            goto bail;
+    }
+
+    rng = new_rng;
+
+bail:
+    in.flags(orig_flags);
+    return in;
+}
+
+
+
+template <bitcount_t table_pow2, bitcount_t advance_pow2,
+          typename baseclass, typename extvalclass, bool kdd>
+void
+extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::advance_table()
+{
+    bool carry = false;
+    for (size_t i = 0; i < table_size; ++i) {
+        if (carry) {
+            carry = insideout::external_step(data_[i],i+1);
+        }
+        bool carry2 = insideout::external_step(data_[i],i+1);
+        carry = carry || carry2;
+    }
+}
+
+template <bitcount_t table_pow2, bitcount_t advance_pow2,
+          typename baseclass, typename extvalclass, bool kdd>
+void
+extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::advance_table(
+        state_type delta, bool isForwards)
+{
+    typedef typename baseclass::state_type   base_state_t;
+    typedef typename extvalclass::state_type ext_state_t;
+    constexpr bitcount_t basebits = sizeof(base_state_t)*8;
+    constexpr bitcount_t extbits  = sizeof(ext_state_t)*8;
+    static_assert(basebits <= extbits || advance_pow2 > 0,
+                  "Current implementation might overflow its carry");
+
+    base_state_t carry = 0;
+    for (size_t i = 0; i < table_size; ++i) {
+        base_state_t total_delta = carry + delta;
+        ext_state_t  trunc_delta = ext_state_t(total_delta);
+        if (basebits > extbits) {
+            carry = total_delta >> extbits;
+        } else {
+            carry = 0;
+        }
+        carry +=
+            insideout::external_advance(data_[i],i+1, trunc_delta, isForwards);
+    }
+}
+
+template <bitcount_t table_pow2, bitcount_t advance_pow2,
+          typename baseclass, typename extvalclass, bool kdd>
+void extended<table_pow2,advance_pow2,baseclass,extvalclass,kdd>::advance(
+    state_type distance, bool forwards)
+{
+    static_assert(kdd,
+        "Efficient advance is too hard for non-kdd extension. "
+        "For a weak advance, cast to base class");
+    state_type zero =
+        baseclass::is_mcg ? this->state_ & state_type(3U) : state_type(0U);
+    if (may_tick) {
+        state_type ticks = distance >> (advance_pow2*may_tick);
+                                        // ^-- stupidity to appease GCC
+                                        // warnings
+        state_type adv_mask =
+            baseclass::is_mcg ? tick_mask << 2 : tick_mask;
+        state_type next_advance_distance = this->distance(zero, adv_mask);
+        if (!forwards)
+            next_advance_distance = (-next_advance_distance) & tick_mask;
+        if (next_advance_distance < (distance & tick_mask)) {
+            ++ticks;
+        }
+        if (ticks)
+            advance_table(ticks, forwards);
+    }
+    if (forwards) {
+        if (may_tock && this->distance(zero) <= distance)
+            advance_table();
+        baseclass::advance(distance);
+    } else {
+        if (may_tock && -(this->distance(zero)) <= distance)
+            advance_table(state_type(1U), false);
+        baseclass::advance(-distance);
+    }
+}
+
+} // namespace pcg_detail
+
+namespace pcg_engines {
+
+using namespace pcg_detail;
+
+/* Predefined types for XSH RS */
+
+typedef oneseq_base<uint8_t,  uint16_t, xsh_rs_mixin>  oneseq_xsh_rs_16_8;
+typedef oneseq_base<uint16_t, uint32_t, xsh_rs_mixin>  oneseq_xsh_rs_32_16;
+typedef oneseq_base<uint32_t, uint64_t, xsh_rs_mixin>  oneseq_xsh_rs_64_32;
+typedef oneseq_base<uint64_t, pcg128_t, xsh_rs_mixin>  oneseq_xsh_rs_128_64;
+
+typedef unique_base<uint8_t,  uint16_t, xsh_rs_mixin>  unique_xsh_rs_16_8;
+typedef unique_base<uint16_t, uint32_t, xsh_rs_mixin>  unique_xsh_rs_32_16;
+typedef unique_base<uint32_t, uint64_t, xsh_rs_mixin>  unique_xsh_rs_64_32;
+typedef unique_base<uint64_t, pcg128_t, xsh_rs_mixin>  unique_xsh_rs_128_64;
+
+typedef setseq_base<uint8_t,  uint16_t, xsh_rs_mixin>  setseq_xsh_rs_16_8;
+typedef setseq_base<uint16_t, uint32_t, xsh_rs_mixin>  setseq_xsh_rs_32_16;
+typedef setseq_base<uint32_t, uint64_t, xsh_rs_mixin>  setseq_xsh_rs_64_32;
+typedef setseq_base<uint64_t, pcg128_t, xsh_rs_mixin>  setseq_xsh_rs_128_64;
+
+typedef mcg_base<uint8_t,  uint16_t, xsh_rs_mixin>  mcg_xsh_rs_16_8;
+typedef mcg_base<uint16_t, uint32_t, xsh_rs_mixin>  mcg_xsh_rs_32_16;
+typedef mcg_base<uint32_t, uint64_t, xsh_rs_mixin>  mcg_xsh_rs_64_32;
+typedef mcg_base<uint64_t, pcg128_t, xsh_rs_mixin>  mcg_xsh_rs_128_64;
+
+/* Predefined types for XSH RR */
+
+typedef oneseq_base<uint8_t,  uint16_t, xsh_rr_mixin>  oneseq_xsh_rr_16_8;
+typedef oneseq_base<uint16_t, uint32_t, xsh_rr_mixin>  oneseq_xsh_rr_32_16;
+typedef oneseq_base<uint32_t, uint64_t, xsh_rr_mixin>  oneseq_xsh_rr_64_32;
+typedef oneseq_base<uint64_t, pcg128_t, xsh_rr_mixin>  oneseq_xsh_rr_128_64;
+
+typedef unique_base<uint8_t,  uint16_t, xsh_rr_mixin>  unique_xsh_rr_16_8;
+typedef unique_base<uint16_t, uint32_t, xsh_rr_mixin>  unique_xsh_rr_32_16;
+typedef unique_base<uint32_t, uint64_t, xsh_rr_mixin>  unique_xsh_rr_64_32;
+typedef unique_base<uint64_t, pcg128_t, xsh_rr_mixin>  unique_xsh_rr_128_64;
+
+typedef setseq_base<uint8_t,  uint16_t, xsh_rr_mixin>  setseq_xsh_rr_16_8;
+typedef setseq_base<uint16_t, uint32_t, xsh_rr_mixin>  setseq_xsh_rr_32_16;
+typedef setseq_base<uint32_t, uint64_t, xsh_rr_mixin>  setseq_xsh_rr_64_32;
+typedef setseq_base<uint64_t, pcg128_t, xsh_rr_mixin>  setseq_xsh_rr_128_64;
+
+typedef mcg_base<uint8_t,  uint16_t, xsh_rr_mixin>  mcg_xsh_rr_16_8;
+typedef mcg_base<uint16_t, uint32_t, xsh_rr_mixin>  mcg_xsh_rr_32_16;
+typedef mcg_base<uint32_t, uint64_t, xsh_rr_mixin>  mcg_xsh_rr_64_32;
+typedef mcg_base<uint64_t, pcg128_t, xsh_rr_mixin>  mcg_xsh_rr_128_64;
+
+
+/* Predefined types for RXS M XS */
+
+typedef oneseq_base<uint8_t,  uint8_t, rxs_m_xs_mixin>   oneseq_rxs_m_xs_8_8;
+typedef oneseq_base<uint16_t, uint16_t, rxs_m_xs_mixin>  oneseq_rxs_m_xs_16_16;
+typedef oneseq_base<uint32_t, uint32_t, rxs_m_xs_mixin>  oneseq_rxs_m_xs_32_32;
+typedef oneseq_base<uint64_t, uint64_t, rxs_m_xs_mixin>  oneseq_rxs_m_xs_64_64;
+typedef oneseq_base<pcg128_t, pcg128_t, rxs_m_xs_mixin>  oneseq_rxs_m_xs_128_128;
+
+typedef unique_base<uint8_t,  uint8_t, rxs_m_xs_mixin>  unique_rxs_m_xs_8_8;
+typedef unique_base<uint16_t, uint16_t, rxs_m_xs_mixin> unique_rxs_m_xs_16_16;
+typedef unique_base<uint32_t, uint32_t, rxs_m_xs_mixin> unique_rxs_m_xs_32_32;
+typedef unique_base<uint64_t, uint64_t, rxs_m_xs_mixin> unique_rxs_m_xs_64_64;
+typedef unique_base<pcg128_t, pcg128_t, rxs_m_xs_mixin> unique_rxs_m_xs_128_128;
+
+typedef setseq_base<uint8_t,  uint8_t, rxs_m_xs_mixin>  setseq_rxs_m_xs_8_8;
+typedef setseq_base<uint16_t, uint16_t, rxs_m_xs_mixin> setseq_rxs_m_xs_16_16;
+typedef setseq_base<uint32_t, uint32_t, rxs_m_xs_mixin> setseq_rxs_m_xs_32_32;
+typedef setseq_base<uint64_t, uint64_t, rxs_m_xs_mixin> setseq_rxs_m_xs_64_64;
+typedef setseq_base<pcg128_t, pcg128_t, rxs_m_xs_mixin> setseq_rxs_m_xs_128_128;
+
+                // MCG versions don't make sense here, so aren't defined.
+
+/* Predefined types for XSL RR (only defined for "large" types) */
+
+typedef oneseq_base<uint32_t, uint64_t, xsl_rr_mixin>  oneseq_xsl_rr_64_32;
+typedef oneseq_base<uint64_t, pcg128_t, xsl_rr_mixin>  oneseq_xsl_rr_128_64;
+
+typedef unique_base<uint32_t, uint64_t, xsl_rr_mixin>  unique_xsl_rr_64_32;
+typedef unique_base<uint64_t, pcg128_t, xsl_rr_mixin>  unique_xsl_rr_128_64;
+
+typedef setseq_base<uint32_t, uint64_t, xsl_rr_mixin>  setseq_xsl_rr_64_32;
+typedef setseq_base<uint64_t, pcg128_t, xsl_rr_mixin>  setseq_xsl_rr_128_64;
+
+typedef mcg_base<uint32_t, uint64_t, xsl_rr_mixin>  mcg_xsl_rr_64_32;
+typedef mcg_base<uint64_t, pcg128_t, xsl_rr_mixin>  mcg_xsl_rr_128_64;
+
+
+/* Predefined types for XSL RR RR (only defined for "large" types) */
+
+typedef oneseq_base<uint64_t, uint64_t, xsl_rr_rr_mixin>
+    oneseq_xsl_rr_rr_64_64;
+typedef oneseq_base<pcg128_t, pcg128_t, xsl_rr_rr_mixin>
+    oneseq_xsl_rr_rr_128_128;
+
+typedef unique_base<uint64_t, uint64_t, xsl_rr_rr_mixin>
+    unique_xsl_rr_rr_64_64;
+typedef unique_base<pcg128_t, pcg128_t, xsl_rr_rr_mixin>
+    unique_xsl_rr_rr_128_128;
+
+typedef setseq_base<uint64_t, uint64_t, xsl_rr_rr_mixin>
+    setseq_xsl_rr_rr_64_64;
+typedef setseq_base<pcg128_t, pcg128_t, xsl_rr_rr_mixin>
+    setseq_xsl_rr_rr_128_128;
+
+                // MCG versions don't make sense here, so aren't defined.
+
+/* Extended generators */
+
+template <bitcount_t table_pow2, bitcount_t advance_pow2,
+          typename BaseRNG, bool kdd = true>
+using ext_std8 = extended<table_pow2, advance_pow2, BaseRNG,
+                          oneseq_rxs_m_xs_8_8, kdd>;
+
+template <bitcount_t table_pow2, bitcount_t advance_pow2,
+          typename BaseRNG, bool kdd = true>
+using ext_std16 = extended<table_pow2, advance_pow2, BaseRNG,
+                           oneseq_rxs_m_xs_16_16, kdd>;
+
+template <bitcount_t table_pow2, bitcount_t advance_pow2,
+          typename BaseRNG, bool kdd = true>
+using ext_std32 = extended<table_pow2, advance_pow2, BaseRNG,
+                           oneseq_rxs_m_xs_32_32, kdd>;
+
+template <bitcount_t table_pow2, bitcount_t advance_pow2,
+          typename BaseRNG, bool kdd = true>
+using ext_std64 = extended<table_pow2, advance_pow2, BaseRNG,
+                           oneseq_rxs_m_xs_64_64, kdd>;
+
+
+template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
+using ext_oneseq_rxs_m_xs_32_32 =
+          ext_std32<table_pow2, advance_pow2, oneseq_rxs_m_xs_32_32, kdd>;
+
+template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
+using ext_mcg_xsh_rs_64_32 =
+          ext_std32<table_pow2, advance_pow2, mcg_xsh_rs_64_32, kdd>;
+
+template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
+using ext_oneseq_xsh_rs_64_32 =
+          ext_std32<table_pow2, advance_pow2, oneseq_xsh_rs_64_32, kdd>;
+
+template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
+using ext_setseq_xsh_rr_64_32 =
+          ext_std32<table_pow2, advance_pow2, setseq_xsh_rr_64_32, kdd>;
+
+template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
+using ext_mcg_xsl_rr_128_64 =
+          ext_std64<table_pow2, advance_pow2, mcg_xsl_rr_128_64, kdd>;
+
+template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
+using ext_oneseq_xsl_rr_128_64 =
+          ext_std64<table_pow2, advance_pow2, oneseq_xsl_rr_128_64, kdd>;
+
+template <bitcount_t table_pow2, bitcount_t advance_pow2, bool kdd = true>
+using ext_setseq_xsl_rr_128_64 =
+          ext_std64<table_pow2, advance_pow2, setseq_xsl_rr_128_64, kdd>;
+
+} // namespace pcg_engines
+
+typedef pcg_engines::setseq_xsh_rr_64_32        pcg32;
+typedef pcg_engines::oneseq_xsh_rr_64_32        pcg32_oneseq;
+typedef pcg_engines::unique_xsh_rr_64_32        pcg32_unique;
+typedef pcg_engines::mcg_xsh_rs_64_32           pcg32_fast;
+
+typedef pcg_engines::setseq_xsl_rr_128_64       pcg64;
+typedef pcg_engines::oneseq_xsl_rr_128_64       pcg64_oneseq;
+typedef pcg_engines::unique_xsl_rr_128_64       pcg64_unique;
+typedef pcg_engines::mcg_xsl_rr_128_64          pcg64_fast;
+
+typedef pcg_engines::setseq_rxs_m_xs_8_8        pcg8_once_insecure;
+typedef pcg_engines::setseq_rxs_m_xs_16_16      pcg16_once_insecure;
+typedef pcg_engines::setseq_rxs_m_xs_32_32      pcg32_once_insecure;
+typedef pcg_engines::setseq_rxs_m_xs_64_64      pcg64_once_insecure;
+typedef pcg_engines::setseq_xsl_rr_rr_128_128   pcg128_once_insecure;
+
+typedef pcg_engines::oneseq_rxs_m_xs_8_8        pcg8_oneseq_once_insecure;
+typedef pcg_engines::oneseq_rxs_m_xs_16_16      pcg16_oneseq_once_insecure;
+typedef pcg_engines::oneseq_rxs_m_xs_32_32      pcg32_oneseq_once_insecure;
+typedef pcg_engines::oneseq_rxs_m_xs_64_64      pcg64_oneseq_once_insecure;
+typedef pcg_engines::oneseq_xsl_rr_rr_128_128   pcg128_oneseq_once_insecure;
+
+
+// These two extended RNGs provide two-dimensionally equidistributed
+// 32-bit generators.  pcg32_k2_fast occupies the same space as pcg64,
+// and can be called twice to generate 64 bits, but does not required
+// 128-bit math; on 32-bit systems, it's faster than pcg64 as well.
+
+typedef pcg_engines::ext_setseq_xsh_rr_64_32<1,16,true>     pcg32_k2;
+typedef pcg_engines::ext_oneseq_xsh_rs_64_32<1,32,true>     pcg32_k2_fast;
+
+// These eight extended RNGs have about as much state as arc4random
+//
+//  - the k variants are k-dimensionally equidistributed
+//  - the c variants offer better crypographic security
+//
+// (just how good the cryptographic security is is an open question)
+
+typedef pcg_engines::ext_setseq_xsh_rr_64_32<6,16,true>     pcg32_k64;
+typedef pcg_engines::ext_mcg_xsh_rs_64_32<6,32,true>        pcg32_k64_oneseq;
+typedef pcg_engines::ext_oneseq_xsh_rs_64_32<6,32,true>     pcg32_k64_fast;
+
+typedef pcg_engines::ext_setseq_xsh_rr_64_32<6,16,false>    pcg32_c64;
+typedef pcg_engines::ext_oneseq_xsh_rs_64_32<6,32,false>    pcg32_c64_oneseq;
+typedef pcg_engines::ext_mcg_xsh_rs_64_32<6,32,false>       pcg32_c64_fast;
+
+typedef pcg_engines::ext_setseq_xsl_rr_128_64<5,16,true>    pcg64_k32;
+typedef pcg_engines::ext_oneseq_xsl_rr_128_64<5,128,true>   pcg64_k32_oneseq;
+typedef pcg_engines::ext_mcg_xsl_rr_128_64<5,128,true>      pcg64_k32_fast;
+
+typedef pcg_engines::ext_setseq_xsl_rr_128_64<5,16,false>   pcg64_c32;
+typedef pcg_engines::ext_oneseq_xsl_rr_128_64<5,128,false>  pcg64_c32_oneseq;
+typedef pcg_engines::ext_mcg_xsl_rr_128_64<5,128,false>     pcg64_c32_fast;
+
+// These eight extended RNGs have more state than the Mersenne twister
+//
+//  - the k variants are k-dimensionally equidistributed
+//  - the c variants offer better crypographic security
+//
+// (just how good the cryptographic security is is an open question)
+
+typedef pcg_engines::ext_setseq_xsh_rr_64_32<10,16,true>    pcg32_k1024;
+typedef pcg_engines::ext_oneseq_xsh_rs_64_32<10,32,true>    pcg32_k1024_fast;
+
+typedef pcg_engines::ext_setseq_xsh_rr_64_32<10,16,false>   pcg32_c1024;
+typedef pcg_engines::ext_oneseq_xsh_rs_64_32<10,32,false>   pcg32_c1024_fast;
+
+typedef pcg_engines::ext_setseq_xsl_rr_128_64<10,16,true>   pcg64_k1024;
+typedef pcg_engines::ext_oneseq_xsl_rr_128_64<10,128,true>  pcg64_k1024_fast;
+
+typedef pcg_engines::ext_setseq_xsl_rr_128_64<10,16,false>  pcg64_c1024;
+typedef pcg_engines::ext_oneseq_xsl_rr_128_64<10,128,false> pcg64_c1024_fast;
+
+// These generators have an insanely huge period (2^524352), and is suitable
+// for silly party tricks, such as dumping out 64 KB ZIP files at an arbitrary
+// point in the future.   [Actually, over the full period of the generator, it
+// will produce every 64 KB ZIP file 2^64 times!]
+
+typedef pcg_engines::ext_setseq_xsh_rr_64_32<14,16,true>    pcg32_k16384;
+typedef pcg_engines::ext_oneseq_xsh_rs_64_32<14,32,true>    pcg32_k16384_fast;
+
+#ifdef _MSC_VER
+    #pragma warning(default:4146)
+#endif
+
+#endif // PCG_RAND_HPP_INCLUDED
diff --git a/contrib/libpcg-random/include/pcg_uint128.hpp b/contrib/libpcg-random/include/pcg_uint128.hpp
new file mode 100644
index 00000000000..1a1f61b9366
--- /dev/null
+++ b/contrib/libpcg-random/include/pcg_uint128.hpp
@@ -0,0 +1,748 @@
+/*
+ * PCG Random Number Generation for C++
+ *
+ * Copyright 2014-2017 Melissa O'Neill <oneill@pcg-random.org>,
+ *                     and the PCG Project contributors.
+ *
+ * SPDX-License-Identifier: (Apache-2.0 OR MIT)
+ *
+ * Licensed under the Apache License, Version 2.0 (provided in
+ * LICENSE-APACHE.txt and at http://www.apache.org/licenses/LICENSE-2.0)
+ * or under the MIT license (provided in LICENSE-MIT.txt and at
+ * http://opensource.org/licenses/MIT), at your option. This file may not
+ * be copied, modified, or distributed except according to those terms.
+ *
+ * Distributed on an "AS IS" BASIS, WITHOUT WARRANTY OF ANY KIND, either
+ * express or implied.  See your chosen license for details.
+ *
+ * For additional information about the PCG random number generation scheme,
+ * visit http://www.pcg-random.org/.
+ */
+
+/*
+ * This code provides a a C++ class that can provide 128-bit (or higher)
+ * integers.  To produce 2K-bit integers, it uses two K-bit integers,
+ * placed in a union that allowes the code to also see them as four K/2 bit
+ * integers (and access them either directly name, or by index).
+ *
+ * It may seem like we're reinventing the wheel here, because several
+ * libraries already exist that support large integers, but most existing
+ * libraries provide a very generic multiprecision code, but here we're
+ * operating at a fixed size.  Also, most other libraries are fairly
+ * heavyweight.  So we use a direct implementation.  Sadly, it's much slower
+ * than hand-coded assembly or direct CPU support.
+ */
+
+#ifndef PCG_UINT128_HPP_INCLUDED
+#define PCG_UINT128_HPP_INCLUDED 1
+
+#include <cstdint>
+#include <cstdio>
+#include <cassert>
+#include <climits>
+#include <utility>
+#include <initializer_list>
+#include <type_traits>
+
+/*
+ * We want to lay the type out the same way that a native type would be laid
+ * out, which means we must know the machine's endian, at compile time.
+ * This ugliness attempts to do so.
+ */
+
+#ifndef PCG_LITTLE_ENDIAN
+    #if defined(__BYTE_ORDER__)
+        #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+            #define PCG_LITTLE_ENDIAN 1
+        #elif __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+            #define PCG_LITTLE_ENDIAN 0
+        #else
+            #error __BYTE_ORDER__ does not match a standard endian, pick a side
+        #endif
+    #elif __LITTLE_ENDIAN__ || _LITTLE_ENDIAN
+        #define PCG_LITTLE_ENDIAN 1
+    #elif __BIG_ENDIAN__ || _BIG_ENDIAN
+        #define PCG_LITTLE_ENDIAN 0
+    #elif __x86_64 || __x86_64__ || _M_X64 || __i386 || __i386__ || _M_IX86
+        #define PCG_LITTLE_ENDIAN 1
+    #elif __powerpc__ || __POWERPC__ || __ppc__ || __PPC__ \
+          || __m68k__ || __mc68000__
+        #define PCG_LITTLE_ENDIAN 0
+    #else
+        #error Unable to determine target endianness
+    #endif
+#endif
+
+namespace pcg_extras {
+
+// Recent versions of GCC have intrinsics we can use to quickly calculate
+// the number of leading and trailing zeros in a number.  If possible, we
+// use them, otherwise we fall back to old-fashioned bit twiddling to figure
+// them out.
+
+#ifndef PCG_BITCOUNT_T
+    typedef uint8_t bitcount_t;
+#else
+    typedef PCG_BITCOUNT_T bitcount_t;
+#endif
+
+/*
+ * Provide some useful helper functions
+ *      * flog2                 floor(log2(x))
+ *      * trailingzeros         number of trailing zero bits
+ */
+
+#ifdef __GNUC__         // Any GNU-compatible compiler supporting C++11 has
+                        // some useful intrinsics we can use.
+
+inline bitcount_t flog2(uint32_t v)
+{
+    return 31 - __builtin_clz(v);
+}
+
+inline bitcount_t trailingzeros(uint32_t v)
+{
+    return __builtin_ctz(v);
+}
+
+inline bitcount_t flog2(uint64_t v)
+{
+#if UINT64_MAX == ULONG_MAX
+    return 63 - __builtin_clzl(v);
+#elif UINT64_MAX == ULLONG_MAX
+    return 63 - __builtin_clzll(v);
+#else
+    #error Cannot find a function for uint64_t
+#endif
+}
+
+inline bitcount_t trailingzeros(uint64_t v)
+{
+#if UINT64_MAX == ULONG_MAX
+    return __builtin_ctzl(v);
+#elif UINT64_MAX == ULLONG_MAX
+    return __builtin_ctzll(v);
+#else
+    #error Cannot find a function for uint64_t
+#endif
+}
+
+#else                   // Otherwise, we fall back to bit twiddling
+                        // implementations
+
+inline bitcount_t flog2(uint32_t v)
+{
+    // Based on code by Eric Cole and Mark Dickinson, which appears at
+    // https://graphics.stanford.edu/~seander/bithacks.html#IntegerLogDeBruijn
+
+    static const uint8_t multiplyDeBruijnBitPos[32] = {
+      0, 9, 1, 10, 13, 21, 2, 29, 11, 14, 16, 18, 22, 25, 3, 30,
+      8, 12, 20, 28, 15, 17, 24, 7, 19, 27, 23, 6, 26, 5, 4, 31
+    };
+
+    v |= v >> 1; // first round down to one less than a power of 2
+    v |= v >> 2;
+    v |= v >> 4;
+    v |= v >> 8;
+    v |= v >> 16;
+
+    return multiplyDeBruijnBitPos[(uint32_t)(v * 0x07C4ACDDU) >> 27];
+}
+
+inline bitcount_t trailingzeros(uint32_t v)
+{
+    static const uint8_t multiplyDeBruijnBitPos[32] = {
+      0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
+      31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
+    };
+
+    return multiplyDeBruijnBitPos[((uint32_t)((v & -v) * 0x077CB531U)) >> 27];
+}
+
+inline bitcount_t flog2(uint64_t v)
+{
+    uint32_t high = v >> 32;
+    uint32_t low  = uint32_t(v);
+
+    return high ? 32+flog2(high) : flog2(low);
+}
+
+inline bitcount_t trailingzeros(uint64_t v)
+{
+    uint32_t high = v >> 32;
+    uint32_t low  = uint32_t(v);
+
+    return low ? trailingzeros(low) : trailingzeros(high)+32;
+}
+
+#endif
+
+template <typename UInt>
+inline bitcount_t clog2(UInt v)
+{
+    return flog2(v) + ((v & (-v)) != v);
+}
+
+template <typename UInt>
+inline UInt addwithcarry(UInt x, UInt y, bool carryin, bool* carryout)
+{
+    UInt half_result = y + carryin;
+    UInt result = x + half_result;
+    *carryout = (half_result < y) || (result < x);
+    return result;
+}
+
+template <typename UInt>
+inline UInt subwithcarry(UInt x, UInt y, bool carryin, bool* carryout)
+{
+    UInt half_result = y + carryin;
+    UInt result = x - half_result;
+    *carryout = (half_result < y) || (result > x);
+    return result;
+}
+
+
+template <typename UInt, typename UIntX2>
+class uint_x4 {
+// private:
+public:
+    union {
+#if PCG_LITTLE_ENDIAN
+        struct {
+            UInt v0, v1, v2, v3;
+        } w;
+        struct {
+            UIntX2 v01, v23;
+        } d;
+#else
+        struct {
+            UInt v3, v2, v1, v0;
+        } w;
+        struct {
+            UIntX2 v23, v01;
+        } d;
+#endif
+        // For the array access versions, the code that uses the array
+        // must handle endian itself.  Yuck.
+        UInt wa[4];
+        UIntX2 da[2];
+    };
+
+public:
+    uint_x4() = default;
+
+    constexpr uint_x4(UInt v3, UInt v2, UInt v1, UInt v0)
+#if PCG_LITTLE_ENDIAN
+       : w{v0, v1, v2, v3}
+#else
+       : w{v3, v2, v1, v0}
+#endif
+    {
+        // Nothing (else) to do
+    }
+
+    constexpr uint_x4(UIntX2 v23, UIntX2 v01)
+#if PCG_LITTLE_ENDIAN
+       : d{v01,v23}
+#else
+       : d{v23,v01}
+#endif
+    {
+        // Nothing (else) to do
+    }
+
+    template<class Integral,
+             typename std::enable_if<(std::is_integral<Integral>::value
+                                      && sizeof(Integral) <= sizeof(UIntX2))
+                                    >::type* = nullptr>
+    constexpr uint_x4(Integral v01)
+#if PCG_LITTLE_ENDIAN
+       : d{UIntX2(v01),0UL}
+#else
+       : d{0UL,UIntX2(v01)}
+#endif
+    {
+        // Nothing (else) to do
+    }
+
+    explicit constexpr operator uint64_t() const
+    {
+        return d.v01;
+    }
+
+    explicit constexpr operator uint32_t() const
+    {
+        return w.v0;
+    }
+
+    explicit constexpr operator int() const
+    {
+        return w.v0;
+    }
+
+    explicit constexpr operator uint16_t() const
+    {
+        return w.v0;
+    }
+
+    explicit constexpr operator uint8_t() const
+    {
+        return w.v0;
+    }
+
+    typedef typename std::conditional<std::is_same<uint64_t,
+                                                   unsigned long>::value,
+                                      unsigned long long,
+                                      unsigned long>::type
+            uint_missing_t;
+
+    explicit constexpr operator uint_missing_t() const
+    {
+        return d.v01;
+    }
+
+    explicit constexpr operator bool() const
+    {
+        return d.v01 || d.v23;
+    }
+
+    template<typename U, typename V>
+    friend uint_x4<U,V> operator*(const uint_x4<U,V>&, const uint_x4<U,V>&);
+
+    template<typename U, typename V>
+    friend std::pair< uint_x4<U,V>,uint_x4<U,V> >
+        divmod(const uint_x4<U,V>&, const uint_x4<U,V>&);
+
+    template<typename U, typename V>
+    friend uint_x4<U,V> operator+(const uint_x4<U,V>&, const uint_x4<U,V>&);
+
+    template<typename U, typename V>
+    friend uint_x4<U,V> operator-(const uint_x4<U,V>&, const uint_x4<U,V>&);
+
+    template<typename U, typename V>
+    friend uint_x4<U,V> operator<<(const uint_x4<U,V>&, const uint_x4<U,V>&);
+
+    template<typename U, typename V>
+    friend uint_x4<U,V> operator>>(const uint_x4<U,V>&, const uint_x4<U,V>&);
+
+    template<typename U, typename V>
+    friend uint_x4<U,V> operator&(const uint_x4<U,V>&, const uint_x4<U,V>&);
+
+    template<typename U, typename V>
+    friend uint_x4<U,V> operator|(const uint_x4<U,V>&, const uint_x4<U,V>&);
+
+    template<typename U, typename V>
+    friend uint_x4<U,V> operator^(const uint_x4<U,V>&, const uint_x4<U,V>&);
+
+    template<typename U, typename V>
+    friend bool operator==(const uint_x4<U,V>&, const uint_x4<U,V>&);
+
+    template<typename U, typename V>
+    friend bool operator!=(const uint_x4<U,V>&, const uint_x4<U,V>&);
+
+    template<typename U, typename V>
+    friend bool operator<(const uint_x4<U,V>&, const uint_x4<U,V>&);
+
+    template<typename U, typename V>
+    friend bool operator<=(const uint_x4<U,V>&, const uint_x4<U,V>&);
+
+    template<typename U, typename V>
+    friend bool operator>(const uint_x4<U,V>&, const uint_x4<U,V>&);
+
+    template<typename U, typename V>
+    friend bool operator>=(const uint_x4<U,V>&, const uint_x4<U,V>&);
+
+    template<typename U, typename V>
+    friend uint_x4<U,V> operator~(const uint_x4<U,V>&);
+
+    template<typename U, typename V>
+    friend uint_x4<U,V> operator-(const uint_x4<U,V>&);
+
+    template<typename U, typename V>
+    friend bitcount_t flog2(const uint_x4<U,V>&);
+
+    template<typename U, typename V>
+    friend bitcount_t trailingzeros(const uint_x4<U,V>&);
+
+    uint_x4& operator*=(const uint_x4& rhs)
+    {
+        uint_x4 result = *this * rhs;
+        return *this = result;
+    }
+
+    uint_x4& operator/=(const uint_x4& rhs)
+    {
+        uint_x4 result = *this / rhs;
+        return *this = result;
+    }
+
+    uint_x4& operator%=(const uint_x4& rhs)
+    {
+        uint_x4 result = *this % rhs;
+        return *this = result;
+    }
+
+    uint_x4& operator+=(const uint_x4& rhs)
+    {
+        uint_x4 result = *this + rhs;
+        return *this = result;
+    }
+
+    uint_x4& operator-=(const uint_x4& rhs)
+    {
+        uint_x4 result = *this - rhs;
+        return *this = result;
+    }
+
+    uint_x4& operator&=(const uint_x4& rhs)
+    {
+        uint_x4 result = *this & rhs;
+        return *this = result;
+    }
+
+    uint_x4& operator|=(const uint_x4& rhs)
+    {
+        uint_x4 result = *this | rhs;
+        return *this = result;
+    }
+
+    uint_x4& operator^=(const uint_x4& rhs)
+    {
+        uint_x4 result = *this ^ rhs;
+        return *this = result;
+    }
+
+    uint_x4& operator>>=(bitcount_t shift)
+    {
+        uint_x4 result = *this >> shift;
+        return *this = result;
+    }
+
+    uint_x4& operator<<=(bitcount_t shift)
+    {
+        uint_x4 result = *this << shift;
+        return *this = result;
+    }
+
+};
+
+template<typename U, typename V>
+bitcount_t flog2(const uint_x4<U,V>& v)
+{
+#if PCG_LITTLE_ENDIAN
+    for (uint8_t i = 4; i !=0; /* dec in loop */) {
+        --i;
+#else
+    for (uint8_t i = 0; i < 4; ++i) {
+#endif
+        if (v.wa[i] == 0)
+             continue;
+        return flog2(v.wa[i]) + (sizeof(U)*CHAR_BIT)*i;
+    }
+    abort();
+}
+
+template<typename U, typename V>
+bitcount_t trailingzeros(const uint_x4<U,V>& v)
+{
+#if PCG_LITTLE_ENDIAN
+    for (uint8_t i = 0; i < 4; ++i) {
+#else
+    for (uint8_t i = 4; i !=0; /* dec in loop */) {
+        --i;
+#endif
+        if (v.wa[i] != 0)
+            return trailingzeros(v.wa[i]) + (sizeof(U)*CHAR_BIT)*i;
+    }
+    return (sizeof(U)*CHAR_BIT)*4;
+}
+
+template <typename UInt, typename UIntX2>
+std::pair< uint_x4<UInt,UIntX2>, uint_x4<UInt,UIntX2> >
+    divmod(const uint_x4<UInt,UIntX2>& orig_dividend,
+           const uint_x4<UInt,UIntX2>& divisor)
+{
+    // If the dividend is less than the divisor, the answer is always zero.
+    // This takes care of boundary cases like 0/x (which would otherwise be
+    // problematic because we can't take the log of zero.  (The boundary case
+    // of division by zero is undefined.)
+    if (orig_dividend < divisor)
+        return { uint_x4<UInt,UIntX2>(0UL), orig_dividend };
+
+    auto dividend = orig_dividend;
+
+    auto log2_divisor  = flog2(divisor);
+    auto log2_dividend = flog2(dividend);
+    // assert(log2_dividend >= log2_divisor);
+    bitcount_t logdiff = log2_dividend - log2_divisor;
+
+    constexpr uint_x4<UInt,UIntX2> ONE(1UL);
+    if (logdiff == 0)
+        return { ONE, dividend - divisor };
+
+    // Now we change the log difference to
+    //  floor(log2(divisor)) - ceil(log2(dividend))
+    // to ensure that we *underestimate* the result.
+    logdiff -= 1;
+
+    uint_x4<UInt,UIntX2> quotient(0UL);
+
+    auto qfactor = ONE << logdiff;
+    auto factor  = divisor << logdiff;
+
+    do {
+        dividend -= factor;
+        quotient += qfactor;
+        while (dividend < factor) {
+            factor  >>= 1;
+            qfactor >>= 1;
+        }
+    } while (dividend >= divisor);
+
+    return { quotient, dividend };
+}
+
+template <typename UInt, typename UIntX2>
+uint_x4<UInt,UIntX2> operator/(const uint_x4<UInt,UIntX2>& dividend,
+                               const uint_x4<UInt,UIntX2>& divisor)
+{
+    return divmod(dividend, divisor).first;
+}
+
+template <typename UInt, typename UIntX2>
+uint_x4<UInt,UIntX2> operator%(const uint_x4<UInt,UIntX2>& dividend,
+                               const uint_x4<UInt,UIntX2>& divisor)
+{
+    return divmod(dividend, divisor).second;
+}
+
+
+template <typename UInt, typename UIntX2>
+uint_x4<UInt,UIntX2> operator*(const uint_x4<UInt,UIntX2>& a,
+                               const uint_x4<UInt,UIntX2>& b)
+{
+    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};
+    bool carryin = false;
+    bool carryout;
+    UIntX2 a0b0 = UIntX2(a.w.v0) * UIntX2(b.w.v0);
+    r.w.v0 = UInt(a0b0);
+    r.w.v1 = UInt(a0b0 >> 32);
+
+    UIntX2 a1b0 = UIntX2(a.w.v1) * UIntX2(b.w.v0);
+    r.w.v2 = UInt(a1b0 >> 32);
+    r.w.v1 = addwithcarry(r.w.v1, UInt(a1b0), carryin, &carryout);
+    carryin = carryout;
+    r.w.v2 = addwithcarry(r.w.v2, UInt(0U), carryin, &carryout);
+    carryin = carryout;
+    r.w.v3 = addwithcarry(r.w.v3, UInt(0U), carryin, &carryout);
+
+    UIntX2 a0b1 = UIntX2(a.w.v0) * UIntX2(b.w.v1);
+    carryin = false;
+    r.w.v2 = addwithcarry(r.w.v2, UInt(a0b1 >> 32), carryin, &carryout);
+    carryin = carryout;
+    r.w.v3 = addwithcarry(r.w.v3, UInt(0U), carryin, &carryout);
+
+    carryin = false;
+    r.w.v1 = addwithcarry(r.w.v1, UInt(a0b1), carryin, &carryout);
+    carryin = carryout;
+    r.w.v2 = addwithcarry(r.w.v2, UInt(0U), carryin, &carryout);
+    carryin = carryout;
+    r.w.v3 = addwithcarry(r.w.v3, UInt(0U), carryin, &carryout);
+
+    UIntX2 a1b1 = UIntX2(a.w.v1) * UIntX2(b.w.v1);
+    carryin = false;
+    r.w.v2 = addwithcarry(r.w.v2, UInt(a1b1), carryin, &carryout);
+    carryin = carryout;
+    r.w.v3 = addwithcarry(r.w.v3, UInt(a1b1 >> 32), carryin, &carryout);
+
+    r.d.v23 += a.d.v01 * b.d.v23 + a.d.v23 * b.d.v01;
+
+    return r;
+}
+
+
+template <typename UInt, typename UIntX2>
+uint_x4<UInt,UIntX2> operator+(const uint_x4<UInt,UIntX2>& a,
+                               const uint_x4<UInt,UIntX2>& b)
+{
+    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};
+
+    bool carryin = false;
+    bool carryout;
+    r.w.v0 = addwithcarry(a.w.v0, b.w.v0, carryin, &carryout);
+    carryin = carryout;
+    r.w.v1 = addwithcarry(a.w.v1, b.w.v1, carryin, &carryout);
+    carryin = carryout;
+    r.w.v2 = addwithcarry(a.w.v2, b.w.v2, carryin, &carryout);
+    carryin = carryout;
+    r.w.v3 = addwithcarry(a.w.v3, b.w.v3, carryin, &carryout);
+
+    return r;
+}
+
+template <typename UInt, typename UIntX2>
+uint_x4<UInt,UIntX2> operator-(const uint_x4<UInt,UIntX2>& a,
+                               const uint_x4<UInt,UIntX2>& b)
+{
+    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};
+
+    bool carryin = false;
+    bool carryout;
+    r.w.v0 = subwithcarry(a.w.v0, b.w.v0, carryin, &carryout);
+    carryin = carryout;
+    r.w.v1 = subwithcarry(a.w.v1, b.w.v1, carryin, &carryout);
+    carryin = carryout;
+    r.w.v2 = subwithcarry(a.w.v2, b.w.v2, carryin, &carryout);
+    carryin = carryout;
+    r.w.v3 = subwithcarry(a.w.v3, b.w.v3, carryin, &carryout);
+
+    return r;
+}
+
+
+template <typename UInt, typename UIntX2>
+uint_x4<UInt,UIntX2> operator&(const uint_x4<UInt,UIntX2>& a,
+                               const uint_x4<UInt,UIntX2>& b)
+{
+    return uint_x4<UInt,UIntX2>(a.d.v23 & b.d.v23, a.d.v01 & b.d.v01);
+}
+
+template <typename UInt, typename UIntX2>
+uint_x4<UInt,UIntX2> operator|(const uint_x4<UInt,UIntX2>& a,
+                               const uint_x4<UInt,UIntX2>& b)
+{
+    return uint_x4<UInt,UIntX2>(a.d.v23 | b.d.v23, a.d.v01 | b.d.v01);
+}
+
+template <typename UInt, typename UIntX2>
+uint_x4<UInt,UIntX2> operator^(const uint_x4<UInt,UIntX2>& a,
+                               const uint_x4<UInt,UIntX2>& b)
+{
+    return uint_x4<UInt,UIntX2>(a.d.v23 ^ b.d.v23, a.d.v01 ^ b.d.v01);
+}
+
+template <typename UInt, typename UIntX2>
+uint_x4<UInt,UIntX2> operator~(const uint_x4<UInt,UIntX2>& v)
+{
+    return uint_x4<UInt,UIntX2>(~v.d.v23, ~v.d.v01);
+}
+
+template <typename UInt, typename UIntX2>
+uint_x4<UInt,UIntX2> operator-(const uint_x4<UInt,UIntX2>& v)
+{
+    return uint_x4<UInt,UIntX2>(0UL,0UL) - v;
+}
+
+template <typename UInt, typename UIntX2>
+bool operator==(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
+{
+    return (a.d.v01 == b.d.v01) && (a.d.v23 == b.d.v23);
+}
+
+template <typename UInt, typename UIntX2>
+bool operator!=(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
+{
+    return !operator==(a,b);
+}
+
+
+template <typename UInt, typename UIntX2>
+bool operator<(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
+{
+    return (a.d.v23 < b.d.v23)
+           || ((a.d.v23 == b.d.v23) && (a.d.v01 < b.d.v01));
+}
+
+template <typename UInt, typename UIntX2>
+bool operator>(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
+{
+    return operator<(b,a);
+}
+
+template <typename UInt, typename UIntX2>
+bool operator<=(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
+{
+    return !(operator<(b,a));
+}
+
+template <typename UInt, typename UIntX2>
+bool operator>=(const uint_x4<UInt,UIntX2>& a, const uint_x4<UInt,UIntX2>& b)
+{
+    return !(operator<(a,b));
+}
+
+
+
+template <typename UInt, typename UIntX2>
+uint_x4<UInt,UIntX2> operator<<(const uint_x4<UInt,UIntX2>& v,
+                                const bitcount_t shift)
+{
+    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};
+    const bitcount_t bits    = sizeof(UInt) * CHAR_BIT;
+    const bitcount_t bitmask = bits - 1;
+    const bitcount_t shiftdiv = shift / bits;
+    const bitcount_t shiftmod = shift & bitmask;
+
+    if (shiftmod) {
+        UInt carryover = 0;
+#if PCG_LITTLE_ENDIAN
+        for (uint8_t out = shiftdiv, in = 0; out < 4; ++out, ++in) {
+#else
+        for (uint8_t out = 4-shiftdiv, in = 4; out != 0; /* dec in loop */) {
+            --out, --in;
+#endif
+            r.wa[out] = (v.wa[in] << shiftmod) | carryover;
+            carryover = (v.wa[in] >> (bits - shiftmod));
+        }
+    } else {
+#if PCG_LITTLE_ENDIAN
+        for (uint8_t out = shiftdiv, in = 0; out < 4; ++out, ++in) {
+#else
+        for (uint8_t out = 4-shiftdiv, in = 4; out != 0; /* dec in loop */) {
+            --out, --in;
+#endif
+            r.wa[out] = v.wa[in];
+        }
+    }
+
+    return r;
+}
+
+template <typename UInt, typename UIntX2>
+uint_x4<UInt,UIntX2> operator>>(const uint_x4<UInt,UIntX2>& v,
+                                const bitcount_t shift)
+{
+    uint_x4<UInt,UIntX2> r = {0U, 0U, 0U, 0U};
+    const bitcount_t bits    = sizeof(UInt) * CHAR_BIT;
+    const bitcount_t bitmask = bits - 1;
+    const bitcount_t shiftdiv = shift / bits;
+    const bitcount_t shiftmod = shift & bitmask;
+
+    if (shiftmod) {
+        UInt carryover = 0;
+#if PCG_LITTLE_ENDIAN
+        for (uint8_t out = 4-shiftdiv, in = 4; out != 0; /* dec in loop */) {
+            --out, --in;
+#else
+        for (uint8_t out = shiftdiv, in = 0; out < 4; ++out, ++in) {
+#endif
+            r.wa[out] = (v.wa[in] >> shiftmod) | carryover;
+            carryover = (v.wa[in] << (bits - shiftmod));
+        }
+    } else {
+#if PCG_LITTLE_ENDIAN
+        for (uint8_t out = 4-shiftdiv, in = 4; out != 0; /* dec in loop */) {
+            --out, --in;
+#else
+        for (uint8_t out = shiftdiv, in = 0; out < 4; ++out, ++in) {
+#endif
+            r.wa[out] = v.wa[in];
+        }
+    }
+
+    return r;
+}
+
+} // namespace pcg_extras
+
+#endif // PCG_UINT128_HPP_INCLUDED

From f9679a40b144b4e96ba0d7ea73e1252535e26896 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 9 Sep 2017 02:57:52 +0300
Subject: [PATCH 150/266] Added README describing source of imported pcg-random
 library [#CLICKHOUSE-3174].

---
 contrib/libpcg-random/README | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 contrib/libpcg-random/README

diff --git a/contrib/libpcg-random/README b/contrib/libpcg-random/README
new file mode 100644
index 00000000000..6b72706dce0
--- /dev/null
+++ b/contrib/libpcg-random/README
@@ -0,0 +1,2 @@
+https://github.com/imneme/pcg-cpp
+0ca2e8ea6ba212bdfbc6219c2313c45917e34b8d

From be79166199fc0ee9c04a622f3894f2d52ee14448 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 9 Sep 2017 02:58:42 +0300
Subject: [PATCH 151/266] Using pcg-random instead of boost::random::taus88
 [#CLICKHOUSE-3174].

---
 cmake/lib_name.cmake                           | 1 +
 dbms/src/AggregateFunctions/CMakeLists.txt     | 1 +
 dbms/src/AggregateFunctions/ReservoirSampler.h | 4 ++--
 dbms/src/Server/CMakeLists.txt                 | 3 ++-
 4 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/cmake/lib_name.cmake b/cmake/lib_name.cmake
index ea1144ec305..9e56f549bed 100644
--- a/cmake/lib_name.cmake
+++ b/cmake/lib_name.cmake
@@ -4,3 +4,4 @@ set(CITYHASH_CONTRIB_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/contrib/libcityhash/in
 set(COMMON_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/libs/libcommon/include ${ClickHouse_BINARY_DIR}/libs/libcommon/include)
 set(DBMS_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/dbms/src ${ClickHouse_BINARY_DIR}/dbms/src)
 set(DOUBLE_CONVERSION_CONTRIB_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/contrib/libdouble-conversion)
+set(PCG_RANDOM_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/contrib/libpcg-random/include)
diff --git a/dbms/src/AggregateFunctions/CMakeLists.txt b/dbms/src/AggregateFunctions/CMakeLists.txt
index f3fb20b6101..4414d89f4a0 100644
--- a/dbms/src/AggregateFunctions/CMakeLists.txt
+++ b/dbms/src/AggregateFunctions/CMakeLists.txt
@@ -29,3 +29,4 @@ list(REMOVE_ITEM clickhouse_aggregate_functions_headers
 add_library(clickhouse_aggregate_functions ${clickhouse_aggregate_functions_sources})
 target_link_libraries(clickhouse_aggregate_functions dbms)
 target_include_directories (clickhouse_aggregate_functions PRIVATE ${COMMON_INCLUDE_DIR})
+target_include_directories (clickhouse_aggregate_functions PRIVATE ${PCG_RANDOM_INCLUDE_DIR})
diff --git a/dbms/src/AggregateFunctions/ReservoirSampler.h b/dbms/src/AggregateFunctions/ReservoirSampler.h
index 1f3c909e2a9..9dae2900d11 100644
--- a/dbms/src/AggregateFunctions/ReservoirSampler.h
+++ b/dbms/src/AggregateFunctions/ReservoirSampler.h
@@ -10,7 +10,7 @@
 #include <IO/WriteHelpers.h>
 #include <Common/PODArray.h>
 #include <Poco/Exception.h>
-#include <boost/random.hpp>
+#include <pcg_random.hpp>
 
 
 /// Implementing the Reservoir Sampling algorithm. Incrementally selects from the added objects a random subset of the sample_count size.
@@ -196,7 +196,7 @@ private:
     size_t sample_count;
     size_t total_values = 0;
     Array samples;
-    boost::taus88 rng;
+    pcg32_fast rng;
     bool sorted = false;
 
 
diff --git a/dbms/src/Server/CMakeLists.txt b/dbms/src/Server/CMakeLists.txt
index 7741ba83e4d..864a37f4ff8 100644
--- a/dbms/src/Server/CMakeLists.txt
+++ b/dbms/src/Server/CMakeLists.txt
@@ -31,10 +31,11 @@ install (FILES clickhouse-client.xml DESTINATION ${CLICKHOUSE_ETC_DIR}/clickhous
 
 add_library (clickhouse-benchmark Benchmark.cpp)
 target_link_libraries (clickhouse-benchmark dbms ${Boost_PROGRAM_OPTIONS_LIBRARY})
+target_include_directories (clickhouse-benchmark PRIVATE ${PCG_RANDOM_INCLUDE_DIR})
 
 add_library (clickhouse-performance-test PerformanceTest.cpp)
 target_link_libraries (clickhouse-performance-test dbms ${Boost_PROGRAM_OPTIONS_LIBRARY})
-
+target_include_directories (clickhouse-performance-test PRIVATE ${PCG_RANDOM_INCLUDE_DIR})
 
 add_executable(clickhouse main.cpp)
 target_include_directories(clickhouse PRIVATE ${COMMON_INCLUDE_DIR})

From b5c6bb64167b07dd504290f36d304b784d2e1333 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 9 Sep 2017 03:01:29 +0300
Subject: [PATCH 152/266] Removed boost::random library [#CLICKHOUSE-3174].

---
 .../libboost/boost_1_65_0/boost/random.hpp    |  91 --
 .../boost/random/additive_combine.hpp         | 283 ------
 .../boost/random/bernoulli_distribution.hpp   | 197 ----
 .../boost/random/beta_distribution.hpp        | 184 ----
 .../boost/random/binomial_distribution.hpp    | 434 ---------
 .../boost/random/cauchy_distribution.hpp      | 214 -----
 .../boost/random/chi_squared_distribution.hpp | 209 -----
 .../boost/random/detail/auto_link.hpp         |  40 -
 .../boost/random/detail/config.hpp            |  18 -
 .../boost/random/detail/const_mod.hpp         | 216 -----
 .../boost/random/detail/disable_warnings.hpp  |  29 -
 .../boost/random/detail/enable_warnings.hpp   |  22 -
 .../boost/random/detail/generator_bits.hpp    |  36 -
 .../random/detail/generator_seed_seq.hpp      |  40 -
 .../boost/random/detail/int_float_pair.hpp    | 121 ---
 .../boost/random/detail/integer_log2.hpp      |  84 --
 .../boost/random/detail/iterator_mixin.hpp    |  45 -
 .../boost/random/detail/large_arithmetic.hpp  | 122 ---
 .../boost/random/detail/operators.hpp         |  84 --
 .../boost/random/detail/polynomial.hpp        | 384 --------
 .../boost/random/detail/ptr_helper.hpp        |  67 --
 .../boost_1_65_0/boost/random/detail/seed.hpp | 115 ---
 .../boost/random/detail/seed_impl.hpp         | 398 --------
 .../random/detail/signed_unsigned_tools.hpp   |  89 --
 .../boost/random/detail/uniform_int_float.hpp |  76 --
 .../boost/random/detail/vector_io.hpp         |  75 --
 .../boost/random/discard_block.hpp            | 241 -----
 .../boost/random/discrete_distribution.hpp    | 636 -------------
 .../boost/random/exponential_distribution.hpp | 386 --------
 .../random/extreme_value_distribution.hpp     | 177 ----
 .../boost/random/fisher_f_distribution.hpp    | 183 ----
 .../boost/random/gamma_distribution.hpp       | 292 ------
 .../boost/random/generate_canonical.hpp       |  96 --
 .../boost/random/geometric_distribution.hpp   | 267 ------
 .../random/hyperexponential_distribution.hpp  | 883 ------------------
 .../boost/random/independent_bits.hpp         | 271 ------
 .../boost/random/inversive_congruential.hpp   | 267 ------
 .../boost/random/lagged_fibonacci.hpp         | 537 -----------
 .../boost/random/laplace_distribution.hpp     | 175 ----
 .../boost/random/linear_congruential.hpp      | 466 ---------
 .../boost/random/linear_feedback_shift.hpp    | 217 -----
 .../boost/random/lognormal_distribution.hpp   | 254 -----
 .../boost/random/mersenne_twister.hpp         | 682 --------------
 .../random/negative_binomial_distribution.hpp | 220 -----
 .../non_central_chi_squared_distribution.hpp  | 221 -----
 .../boost/random/normal_distribution.hpp      | 374 --------
 .../piecewise_constant_distribution.hpp       | 466 ---------
 .../random/piecewise_linear_distribution.hpp  | 531 -----------
 .../boost/random/poisson_distribution.hpp     | 360 -------
 .../boost/random/random_device.hpp            | 143 ---
 .../boost/random/random_number_generator.hpp  |  73 --
 .../boost_1_65_0/boost/random/ranlux.hpp      |  99 --
 .../boost_1_65_0/boost/random/seed_seq.hpp    | 118 ---
 .../boost/random/shuffle_order.hpp            | 269 ------
 .../boost/random/shuffle_output.hpp           |  51 -
 .../boost/random/student_t_distribution.hpp   | 180 ----
 .../boost/random/subtract_with_carry.hpp      | 613 ------------
 .../boost_1_65_0/boost/random/taus88.hpp      |  45 -
 .../boost_1_65_0/boost/random/traits.hpp      | 107 ---
 .../boost/random/triangle_distribution.hpp    | 232 -----
 .../boost_1_65_0/boost/random/uniform_01.hpp  | 257 -----
 .../boost_1_65_0/boost/random/uniform_int.hpp |  99 --
 .../boost/random/uniform_int_distribution.hpp | 419 ---------
 .../boost/random/uniform_on_sphere.hpp        | 284 ------
 .../boost/random/uniform_real.hpp             |  82 --
 .../random/uniform_real_distribution.hpp      | 241 -----
 .../boost/random/uniform_smallint.hpp         | 307 ------
 .../boost/random/variate_generator.hpp        | 122 ---
 .../boost/random/weibull_distribution.hpp     | 177 ----
 .../boost_1_65_0/boost/random/xor_combine.hpp | 208 -----
 70 files changed, 16001 deletions(-)
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/additive_combine.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/bernoulli_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/beta_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/binomial_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/cauchy_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/chi_squared_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/detail/auto_link.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/detail/config.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/detail/const_mod.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/detail/disable_warnings.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/detail/enable_warnings.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/detail/generator_bits.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/detail/generator_seed_seq.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/detail/int_float_pair.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/detail/integer_log2.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/detail/iterator_mixin.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/detail/large_arithmetic.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/detail/operators.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/detail/polynomial.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/detail/ptr_helper.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/detail/seed.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/detail/seed_impl.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/detail/signed_unsigned_tools.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/detail/uniform_int_float.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/detail/vector_io.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/discard_block.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/discrete_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/exponential_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/extreme_value_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/fisher_f_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/gamma_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/generate_canonical.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/geometric_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/hyperexponential_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/independent_bits.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/inversive_congruential.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/lagged_fibonacci.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/laplace_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/linear_congruential.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/linear_feedback_shift.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/lognormal_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/mersenne_twister.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/negative_binomial_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/non_central_chi_squared_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/normal_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/piecewise_constant_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/piecewise_linear_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/poisson_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/random_device.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/random_number_generator.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/ranlux.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/seed_seq.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/shuffle_order.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/shuffle_output.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/student_t_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/subtract_with_carry.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/taus88.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/traits.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/triangle_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/uniform_01.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/uniform_int.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/uniform_int_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/uniform_on_sphere.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/uniform_real.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/uniform_real_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/uniform_smallint.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/variate_generator.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/weibull_distribution.hpp
 delete mode 100644 contrib/libboost/boost_1_65_0/boost/random/xor_combine.hpp

diff --git a/contrib/libboost/boost_1_65_0/boost/random.hpp b/contrib/libboost/boost_1_65_0/boost/random.hpp
deleted file mode 100644
index a164e7eb1ae..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random.hpp
+++ /dev/null
@@ -1,91 +0,0 @@
-/* boost random.hpp header file
- *
- * Copyright Jens Maurer 2000-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/random for documentation.
- *
- * $Id$
- *
- * Revision history
- *  2000-02-18  portability fixes (thanks to Beman Dawes)
- *  2000-02-21  shuffle_output, inversive_congruential_schrage,
- *              generator_iterator, uniform_smallint
- *  2000-02-23  generic modulus arithmetic helper, removed *_schrage classes,
- *              implemented Streamable and EqualityComparable concepts for 
- *              generators, added Bernoulli distribution and Box-Muller
- *              transform
- *  2000-03-01  cauchy, lognormal, triangle distributions; fixed 
- *              uniform_smallint; renamed gaussian to normal distribution
- *  2000-03-05  implemented iterator syntax for distribution functions
- *  2000-04-21  removed some optimizations for better BCC/MSVC compatibility
- *  2000-05-10  adapted to BCC and MSVC
- *  2000-06-13  incorporated review results
- *  2000-07-06  moved basic templates from namespace detail to random
- *  2000-09-23  warning removals and int64 fixes (Ed Brey)
- *  2000-09-24  added lagged_fibonacci generator (Matthias Troyer)
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_HPP
-#define BOOST_RANDOM_HPP
-
-// generators
-#include <boost/random/additive_combine.hpp>
-#include <boost/random/discard_block.hpp>
-#include <boost/random/independent_bits.hpp>
-#include <boost/random/inversive_congruential.hpp>
-#include <boost/random/lagged_fibonacci.hpp>
-#include <boost/random/linear_congruential.hpp>
-#include <boost/random/linear_feedback_shift.hpp>
-#include <boost/random/mersenne_twister.hpp>
-#include <boost/random/ranlux.hpp>
-#include <boost/random/shuffle_order.hpp>
-#include <boost/random/shuffle_output.hpp>
-#include <boost/random/subtract_with_carry.hpp>
-#include <boost/random/taus88.hpp>
-#include <boost/random/xor_combine.hpp>
-
-// misc
-#include <boost/random/generate_canonical.hpp>
-#include <boost/random/seed_seq.hpp>
-#include <boost/random/random_number_generator.hpp>
-#include <boost/random/variate_generator.hpp>
-
-// distributions
-#include <boost/random/bernoulli_distribution.hpp>
-#include <boost/random/beta_distribution.hpp>
-#include <boost/random/binomial_distribution.hpp>
-#include <boost/random/cauchy_distribution.hpp>
-#include <boost/random/chi_squared_distribution.hpp>
-#include <boost/random/discrete_distribution.hpp>
-#include <boost/random/exponential_distribution.hpp>
-#include <boost/random/extreme_value_distribution.hpp>
-#include <boost/random/fisher_f_distribution.hpp>
-#include <boost/random/gamma_distribution.hpp>
-#include <boost/random/geometric_distribution.hpp>
-#include <boost/random/hyperexponential_distribution.hpp>
-#include <boost/random/laplace_distribution.hpp>
-#include <boost/random/lognormal_distribution.hpp>
-#include <boost/random/negative_binomial_distribution.hpp>
-#include <boost/random/non_central_chi_squared_distribution.hpp>
-#include <boost/random/normal_distribution.hpp>
-#include <boost/random/piecewise_constant_distribution.hpp>
-#include <boost/random/piecewise_linear_distribution.hpp>
-#include <boost/random/poisson_distribution.hpp>
-#include <boost/random/student_t_distribution.hpp>
-#include <boost/random/triangle_distribution.hpp>
-#include <boost/random/uniform_01.hpp>
-#include <boost/random/uniform_int.hpp>
-#include <boost/random/uniform_int_distribution.hpp>
-#include <boost/random/uniform_on_sphere.hpp>
-#include <boost/random/uniform_real.hpp>
-#include <boost/random/uniform_real_distribution.hpp>
-#include <boost/random/uniform_smallint.hpp>
-#include <boost/random/weibull_distribution.hpp>
-
-#include <boost/random/generate_canonical.hpp>
-
-#endif // BOOST_RANDOM_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/additive_combine.hpp b/contrib/libboost/boost_1_65_0/boost/random/additive_combine.hpp
deleted file mode 100644
index d786e18473a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/additive_combine.hpp
+++ /dev/null
@@ -1,283 +0,0 @@
-/* boost random/additive_combine.hpp header file
- *
- * Copyright Jens Maurer 2000-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 for most recent version including documentation.
- *
- * $Id$
- *
- * Revision history
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_ADDITIVE_COMBINE_HPP
-#define BOOST_RANDOM_ADDITIVE_COMBINE_HPP
-
-#include <istream>
-#include <iosfwd>
-#include <algorithm> // for std::min and std::max
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/detail/seed.hpp>
-#include <boost/random/linear_congruential.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * An instantiation of class template @c additive_combine_engine models a
- * \pseudo_random_number_generator. It combines two multiplicative
- * \linear_congruential_engine number generators, i.e. those with @c c = 0.
- * It is described in
- *
- *  @blockquote
- *  "Efficient and Portable Combined Random Number Generators", Pierre L'Ecuyer,
- *  Communications of the ACM, Vol. 31, No. 6, June 1988, pp. 742-749, 774
- *  @endblockquote
- *
- * The template parameters MLCG1 and MLCG2 shall denote two different
- * \linear_congruential_engine number generators, each with c = 0. Each
- * invocation returns a random number
- * X(n) := (MLCG1(n) - MLCG2(n)) mod (m1 - 1),
- * where m1 denotes the modulus of MLCG1. 
- */
-template<class MLCG1, class MLCG2>
-class additive_combine_engine
-{
-public:
-    typedef MLCG1 first_base;
-    typedef MLCG2 second_base;
-    typedef typename MLCG1::result_type result_type;
-
-    // Required by old Boost.Random concept
-    BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
-    /**
-     * Returns the smallest value that the generator can produce
-     */
-    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return 1; }
-    /**
-     * Returns the largest value that the generator can produce
-     */
-    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return MLCG1::modulus-1; }
-
-    /**
-     * Constructs an @c additive_combine_engine using the
-     * default constructors of the two base generators.
-     */
-    additive_combine_engine() : _mlcg1(), _mlcg2() { }
-    /**
-     * Constructs an @c additive_combine_engine, using seed as
-     * the constructor argument for both base generators.
-     */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(additive_combine_engine,
-        result_type, seed_arg)
-    {
-        _mlcg1.seed(seed_arg);
-        _mlcg2.seed(seed_arg);
-    }
-    /**
-     * Constructs an @c additive_combine_engine, using seq as
-     * the constructor argument for both base generators.
-     *
-     * @xmlwarning
-     * The semantics of this function are liable to change.
-     * A @c seed_seq is designed to generate all the seeds
-     * in one shot, but this seeds the two base engines
-     * independantly and probably ends up giving the same
-     * sequence to both.
-     * @endxmlwarning
-     */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(additive_combine_engine,
-        SeedSeq, seq)
-    {
-        _mlcg1.seed(seq);
-        _mlcg2.seed(seq);
-    }
-    /**
-     * Constructs an @c additive_combine_engine, using
-     * @c seed1 and @c seed2 as the constructor argument to
-     * the first and second base generators, respectively.
-     */
-    additive_combine_engine(typename MLCG1::result_type seed1, 
-                            typename MLCG2::result_type seed2)
-      : _mlcg1(seed1), _mlcg2(seed2) { }
-    /**
-     * Contructs an @c additive_combine_engine with
-     * values from the range defined by the input iterators first
-     * and last.  first will be modified to point to the element
-     * after the last one used.
-     *
-     * Throws: @c std::invalid_argument if the input range is too small.
-     *
-     * Exception Safety: Basic
-     */
-    template<class It> additive_combine_engine(It& first, It last)
-      : _mlcg1(first, last), _mlcg2(first, last) { }
-
-    /**
-     * Seeds an @c additive_combine_engine using the default
-     * seeds of the two base generators.
-     */
-    void seed()
-    {
-        _mlcg1.seed();
-        _mlcg2.seed();
-    }
-
-    /**
-     * Seeds an @c additive_combine_engine, using @c seed as the
-     * seed for both base generators.
-     */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(additive_combine_engine,
-        result_type, seed_arg)
-    {
-        _mlcg1.seed(seed_arg);
-        _mlcg2.seed(seed_arg);
-    }
-
-    /**
-     * Seeds an @c additive_combine_engine, using @c seq to
-     * seed both base generators.
-     *
-     * See the warning on the corresponding constructor.
-     */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(additive_combine_engine,
-        SeedSeq, seq)
-    {
-        _mlcg1.seed(seq);
-        _mlcg2.seed(seq);
-    }
-
-    /**
-     * Seeds an @c additive_combine generator, using @c seed1 and @c seed2 as
-     * the seeds to the first and second base generators, respectively.
-     */
-    void seed(typename MLCG1::result_type seed1,
-              typename MLCG2::result_type seed2)
-    {
-        _mlcg1.seed(seed1);
-        _mlcg2.seed(seed2);
-    }
-
-    /**
-     * Seeds an @c additive_combine_engine with
-     * values from the range defined by the input iterators first
-     * and last.  first will be modified to point to the element
-     * after the last one used.
-     *
-     * Throws: @c std::invalid_argument if the input range is too small.
-     *
-     * Exception Safety: Basic
-     */
-    template<class It> void seed(It& first, It last)
-    {
-        _mlcg1.seed(first, last);
-        _mlcg2.seed(first, last);
-    }
-
-    /** Returns the next value of the generator. */
-    result_type operator()() {
-        result_type val1 = _mlcg1();
-        result_type val2 = _mlcg2();
-        if(val2 < val1) return val1 - val2;
-        else return val1 - val2 + MLCG1::modulus - 1;
-    }
-  
-    /** Fills a range with random values */
-    template<class Iter>
-    void generate(Iter first, Iter last)
-    { detail::generate_from_int(*this, first, last); }
-
-    /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z)
-    {
-        _mlcg1.discard(z);
-        _mlcg2.discard(z);
-    }
-
-    /**
-     * Writes the state of an @c additive_combine_engine to a @c
-     * std::ostream.  The textual representation of an @c
-     * additive_combine_engine is the textual representation of
-     * the first base generator followed by the textual representation
-     * of the second base generator.
-     */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, additive_combine_engine, r)
-    { os << r._mlcg1 << ' ' << r._mlcg2; return os; }
-
-    /**
-     * Reads the state of an @c additive_combine_engine from a
-     * @c std::istream.
-     */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, additive_combine_engine, r)
-    { is >> r._mlcg1 >> std::ws >> r._mlcg2; return is; }
-
-    /**
-     * Returns: true iff the two @c additive_combine_engines will
-     * produce the same sequence of values.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(additive_combine_engine, x, y)
-    { return x._mlcg1 == y._mlcg1 && x._mlcg2 == y._mlcg2; }
-    /**
-     * Returns: true iff the two @c additive_combine_engines will
-     * produce different sequences of values.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(additive_combine_engine)
-
-private:
-    MLCG1 _mlcg1;
-    MLCG2 _mlcg2;
-};
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-template<class MLCG1, class MLCG2>
-const bool additive_combine_engine<MLCG1, MLCG2>::has_fixed_range;
-#endif
-
-/// \cond show_deprecated
-
-/** Provided for backwards compatibility. */
-template<class MLCG1, class MLCG2, typename MLCG1::result_type val = 0>
-class additive_combine : public additive_combine_engine<MLCG1, MLCG2>
-{
-    typedef additive_combine_engine<MLCG1, MLCG2> base_t;
-public:
-    typedef typename base_t::result_type result_type;
-    additive_combine() {}
-    template<class T>
-    additive_combine(T& arg) : base_t(arg) {}
-    template<class T>
-    additive_combine(const T& arg) : base_t(arg) {}
-    template<class It>
-    additive_combine(It& first, It last) : base_t(first, last) {}
-};
-
-/// \endcond
-
-/**
- * The specialization \ecuyer1988 was suggested in
- *
- *  @blockquote
- *  "Efficient and Portable Combined Random Number Generators", Pierre L'Ecuyer,
- *  Communications of the ACM, Vol. 31, No. 6, June 1988, pp. 742-749, 774
- *  @endblockquote
- */
-typedef additive_combine_engine<
-    linear_congruential_engine<uint32_t, 40014, 0, 2147483563>,
-    linear_congruential_engine<uint32_t, 40692, 0, 2147483399>
-> ecuyer1988;
-
-} // namespace random
-
-using random::ecuyer1988;
-
-} // namespace boost
-
-#endif // BOOST_RANDOM_ADDITIVE_COMBINE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/bernoulli_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/bernoulli_distribution.hpp
deleted file mode 100644
index d66bae4389d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/bernoulli_distribution.hpp
+++ /dev/null
@@ -1,197 +0,0 @@
-/* boost random/bernoulli_distribution.hpp header file
- *
- * Copyright Jens Maurer 2000-2001
- * 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$
- *
- * Revision history
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_BERNOULLI_DISTRIBUTION_HPP
-#define BOOST_RANDOM_BERNOULLI_DISTRIBUTION_HPP
-
-#include <iosfwd>
-#include <boost/assert.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/operators.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * Instantiations of class template \bernoulli_distribution model a
- * \random_distribution. Such a random distribution produces bool values
- * distributed with probabilities P(true) = p and P(false) = 1-p. p is
- * the parameter of the distribution.
- */
-template<class RealType = double>
-class bernoulli_distribution
-{
-public:
-    // In principle, this could work with both integer and floating-point
-    // types.  Generating floating-point random numbers in the first
-    // place is probably more expensive, so use integer as input.
-    typedef int input_type;
-    typedef bool result_type;
-
-    class param_type
-    {
-    public:
-
-        typedef bernoulli_distribution distribution_type;
-
-        /** 
-         * Constructs the parameters of the distribution.
-         *
-         * Requires: 0 <= p <= 1
-         */
-        explicit param_type(RealType p_arg = RealType(0.5))
-          : _p(p_arg)
-        {
-            BOOST_ASSERT(_p >= 0);
-            BOOST_ASSERT(_p <= 1);
-        }
-
-        /** Returns the p parameter of the distribution. */
-        RealType p() const { return _p; }
-
-        /** Writes the parameters to a std::ostream. */
-        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
-        {
-            os << parm._p;
-            return os;
-        }
-
-        /** Reads the parameters from a std::istream. */
-        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
-        {
-            is >> parm._p;
-            return is;
-        }
-
-        /** Returns true if the two sets of parameters are equal. */
-        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        { return lhs._p == rhs._p; }
-
-        /** Returns true if the two sets of parameters are different. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-
-    private:
-        RealType _p;
-    };
-
-    /** 
-     * Constructs a \bernoulli_distribution object.
-     * p is the parameter of the distribution.
-     *
-     * Requires: 0 <= p <= 1
-     */
-    explicit bernoulli_distribution(const RealType& p_arg = RealType(0.5)) 
-      : _p(p_arg)
-    {
-        BOOST_ASSERT(_p >= 0);
-        BOOST_ASSERT(_p <= 1);
-    }
-    /**
-     * Constructs \bernoulli_distribution from its parameters
-     */
-    explicit bernoulli_distribution(const param_type& parm)
-      : _p(parm.p()) {}
-
-    // compiler-generated copy ctor and assignment operator are fine
-
-    /**
-     * Returns: The "p" parameter of the distribution.
-     */
-    RealType p() const { return _p; }
-
-    /** Returns the smallest value that the distribution can produce. */
-    bool min BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    { return false; }
-    /** Returns the largest value that the distribution can produce. */
-    bool max BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    { return true; }
-
-    /** Returns the parameters of the distribution. */
-    param_type param() const { return param_type(_p); }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm) { _p = parm.p(); }
-
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { }
-
-    /**
-     * Returns: a random variate distributed according to the
-     * \bernoulli_distribution.
-     */
-    template<class Engine>
-    bool operator()(Engine& eng) const
-    {
-        if(_p == RealType(0))
-            return false;
-        else
-            return RealType(eng() - (eng.min)()) <= _p * RealType((eng.max)()-(eng.min)());
-    }
-
-    /**
-     * Returns: a random variate distributed according to the
-     * \bernoulli_distribution with parameters specified by param.
-     */
-    template<class Engine>
-    bool operator()(Engine& eng, const param_type& parm) const
-    {
-        return bernoulli_distribution(parm)(eng);
-    }
-
-    /**
-     * Writes the parameters of the distribution to a @c std::ostream.
-     */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, bernoulli_distribution, bd)
-    {
-        os << bd._p;
-        return os;
-    }
-
-    /**
-     * Reads the parameters of the distribution from a @c std::istream.
-     */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, bernoulli_distribution, bd)
-    {
-        is >> bd._p;
-        return is;
-    }
-
-    /**
-     * Returns true iff the two distributions will produce identical
-     * sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(bernoulli_distribution, lhs, rhs)
-    { return lhs._p == rhs._p; }
-    
-    /**
-     * Returns true iff the two distributions will produce different
-     * sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(bernoulli_distribution)
-
-private:
-    RealType _p;
-};
-
-} // namespace random
-
-using random::bernoulli_distribution;
-
-} // namespace boost
-
-#endif // BOOST_RANDOM_BERNOULLI_DISTRIBUTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/beta_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/beta_distribution.hpp
deleted file mode 100644
index dabb72bfe2d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/beta_distribution.hpp
+++ /dev/null
@@ -1,184 +0,0 @@
-/* boost random/beta_distribution.hpp header file
- *
- * Copyright Steven Watanabe 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 including documentation.
- *
- * $Id$
- */
-
-#ifndef BOOST_RANDOM_BETA_DISTRIBUTION_HPP
-#define BOOST_RANDOM_BETA_DISTRIBUTION_HPP
-
-#include <cassert>
-#include <istream>
-#include <iosfwd>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/gamma_distribution.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * The beta distribution is a real-valued distribution which produces
- * values in the range [0, 1].  It has two parameters, alpha and beta.
- *
- * It has \f$\displaystyle p(x) = \frac{x^{\alpha-1}(1-x)^{\beta-1}}{B(\alpha, \beta)}\f$.
- */
-template<class RealType = double>
-class beta_distribution {
-public:
-    typedef RealType result_type;
-    typedef RealType input_type;
-
-    class param_type {
-    public:
-        typedef beta_distribution distribution_type;
-
-        /**
-         * Constructs a @c param_type from the "alpha" and "beta" parameters
-         * of the distribution.
-         *
-         * Requires: alpha > 0, beta > 0
-         */
-        explicit param_type(RealType alpha_arg = RealType(1.0),
-                            RealType beta_arg = RealType(1.0))
-          : _alpha(alpha_arg), _beta(beta_arg)
-        {
-            assert(alpha_arg > 0);
-            assert(beta_arg > 0);
-        }
-
-        /** Returns the "alpha" parameter of the distribtuion. */
-        RealType alpha() const { return _alpha; }
-        /** Returns the "beta" parameter of the distribution. */
-        RealType beta() const { return _beta; }
-
-        /** Writes a @c param_type to a @c std::ostream. */
-        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
-        { os << parm._alpha << ' ' << parm._beta; return os; }
-
-        /** Reads a @c param_type from a @c std::istream. */
-        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
-        { is >> parm._alpha >> std::ws >> parm._beta; return is; }
-
-        /** Returns true if the two sets of parameters are the same. */
-        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        { return lhs._alpha == rhs._alpha && lhs._beta == rhs._beta; }
-        
-        /** Returns true if the two sets of parameters are the different. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-
-    private:
-        RealType _alpha;
-        RealType _beta;
-    };
-
-    /**
-     * Constructs an @c beta_distribution from its "alpha" and "beta" parameters.
-     *
-     * Requires: alpha > 0, beta > 0
-     */
-    explicit beta_distribution(RealType alpha_arg = RealType(1.0),
-                               RealType beta_arg = RealType(1.0))
-      : _alpha(alpha_arg), _beta(beta_arg)
-    {
-        assert(alpha_arg > 0);
-        assert(beta_arg > 0);
-    }
-    /** Constructs an @c beta_distribution from its parameters. */
-    explicit beta_distribution(const param_type& parm)
-      : _alpha(parm.alpha()), _beta(parm.beta())
-    {}
-
-    /**
-     * Returns a random variate distributed according to the
-     * beta distribution.
-     */
-    template<class URNG>
-    RealType operator()(URNG& urng) const
-    {
-        RealType a = gamma_distribution<RealType>(_alpha, RealType(1.0))(urng);
-        RealType b = gamma_distribution<RealType>(_beta, RealType(1.0))(urng);
-        return a / (a + b);
-    }
-
-    /**
-     * Returns a random variate distributed accordint to the beta
-     * distribution with parameters specified by @c param.
-     */
-    template<class URNG>
-    RealType operator()(URNG& urng, const param_type& parm) const
-    {
-        return beta_distribution(parm)(urng);
-    }
-
-    /** Returns the "alpha" parameter of the distribution. */
-    RealType alpha() const { return _alpha; }
-    /** Returns the "beta" parameter of the distribution. */
-    RealType beta() const { return _beta; }
-
-    /** Returns the smallest value that the distribution can produce. */
-    RealType min BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    { return RealType(0.0); }
-    /** Returns the largest value that the distribution can produce. */
-    RealType max BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    { return RealType(1.0); }
-
-    /** Returns the parameters of the distribution. */
-    param_type param() const { return param_type(_alpha, _beta); }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        _alpha = parm.alpha();
-        _beta = parm.beta();
-    }
-
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { }
-
-    /** Writes an @c beta_distribution to a @c std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, beta_distribution, wd)
-    {
-        os << wd.param();
-        return os;
-    }
-
-    /** Reads an @c beta_distribution from a @c std::istream. */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, beta_distribution, wd)
-    {
-        param_type parm;
-        if(is >> parm) {
-            wd.param(parm);
-        }
-        return is;
-    }
-
-    /**
-     * Returns true if the two instances of @c beta_distribution will
-     * return identical sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(beta_distribution, lhs, rhs)
-    { return lhs._alpha == rhs._alpha && lhs._beta == rhs._beta; }
-    
-    /**
-     * Returns true if the two instances of @c beta_distribution will
-     * return different sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(beta_distribution)
-
-private:
-    RealType _alpha;
-    RealType _beta;
-};
-
-} // namespace random
-} // namespace boost
-
-#endif // BOOST_RANDOM_BETA_DISTRIBUTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/binomial_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/binomial_distribution.hpp
deleted file mode 100644
index 3efc905746c..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/binomial_distribution.hpp
+++ /dev/null
@@ -1,434 +0,0 @@
-/* boost random/binomial_distribution.hpp header file
- *
- * Copyright Steven Watanabe 2010
- * 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_BINOMIAL_DISTRIBUTION_HPP_INCLUDED
-#define BOOST_RANDOM_BINOMIAL_DISTRIBUTION_HPP_INCLUDED
-
-#include <boost/config/no_tr1/cmath.hpp>
-#include <cstdlib>
-#include <iosfwd>
-
-#include <boost/random/detail/config.hpp>
-#include <boost/random/uniform_01.hpp>
-
-#include <boost/random/detail/disable_warnings.hpp>
-
-namespace boost {
-namespace random {
-
-namespace detail {
-
-template<class RealType>
-struct binomial_table {
-    static const RealType table[10];
-};
-
-template<class RealType>
-const RealType binomial_table<RealType>::table[10] = {
-    0.08106146679532726,
-    0.04134069595540929,
-    0.02767792568499834,
-    0.02079067210376509,
-    0.01664469118982119,
-    0.01387612882307075,
-    0.01189670994589177,
-    0.01041126526197209,
-    0.009255462182712733,
-    0.008330563433362871
-};
-
-}
-
-/**
- * The binomial distribution is an integer valued distribution with
- * two parameters, @c t and @c p.  The values of the distribution
- * are within the range [0,t].
- *
- * The distribution function is
- * \f$\displaystyle P(k) = {t \choose k}p^k(1-p)^{t-k}\f$.
- *
- * The algorithm used is the BTRD algorithm described in
- *
- *  @blockquote
- *  "The generation of binomial random variates", Wolfgang Hormann,
- *  Journal of Statistical Computation and Simulation, Volume 46,
- *  Issue 1 & 2 April 1993 , pages 101 - 110
- *  @endblockquote
- */
-template<class IntType = int, class RealType = double>
-class binomial_distribution {
-public:
-    typedef IntType result_type;
-    typedef RealType input_type;
-
-    class param_type {
-    public:
-        typedef binomial_distribution distribution_type;
-        /**
-         * Construct a param_type object.  @c t and @c p
-         * are the parameters of the distribution.
-         *
-         * Requires: t >=0 && 0 <= p <= 1
-         */
-        explicit param_type(IntType t_arg = 1, RealType p_arg = RealType (0.5))
-          : _t(t_arg), _p(p_arg)
-        {}
-        /** Returns the @c t parameter of the distribution. */
-        IntType t() const { return _t; }
-        /** Returns the @c p parameter of the distribution. */
-        RealType p() const { return _p; }
-#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
-        /** Writes the parameters of the distribution to a @c std::ostream. */
-        template<class CharT, class Traits>
-        friend std::basic_ostream<CharT,Traits>&
-        operator<<(std::basic_ostream<CharT,Traits>& os,
-                   const param_type& parm)
-        {
-            os << parm._p << " " << parm._t;
-            return os;
-        }
-    
-        /** Reads the parameters of the distribution from a @c std::istream. */
-        template<class CharT, class Traits>
-        friend std::basic_istream<CharT,Traits>&
-        operator>>(std::basic_istream<CharT,Traits>& is, param_type& parm)
-        {
-            is >> parm._p >> std::ws >> parm._t;
-            return is;
-        }
-#endif
-        /** Returns true if the parameters have the same values. */
-        friend bool operator==(const param_type& lhs, const param_type& rhs)
-        {
-            return lhs._t == rhs._t && lhs._p == rhs._p;
-        }
-        /** Returns true if the parameters have different values. */
-        friend bool operator!=(const param_type& lhs, const param_type& rhs)
-        {
-            return !(lhs == rhs);
-        }
-    private:
-        IntType _t;
-        RealType _p;
-    };
-    
-    /**
-     * Construct a @c binomial_distribution object. @c t and @c p
-     * are the parameters of the distribution.
-     *
-     * Requires: t >=0 && 0 <= p <= 1
-     */
-    explicit binomial_distribution(IntType t_arg = 1,
-                                   RealType p_arg = RealType(0.5))
-      : _t(t_arg), _p(p_arg)
-    {
-        init();
-    }
-    
-    /**
-     * Construct an @c binomial_distribution object from the
-     * parameters.
-     */
-    explicit binomial_distribution(const param_type& parm)
-      : _t(parm.t()), _p(parm.p())
-    {
-        init();
-    }
-    
-    /**
-     * Returns a random variate distributed according to the
-     * binomial distribution.
-     */
-    template<class URNG>
-    IntType operator()(URNG& urng) const
-    {
-        if(use_inversion()) {
-            if(0.5 < _p) {
-                return _t - invert(_t, 1-_p, urng);
-            } else {
-                return invert(_t, _p, urng);
-            }
-        } else if(0.5 < _p) {
-            return _t - generate(urng);
-        } else {
-            return generate(urng);
-        }
-    }
-    
-    /**
-     * Returns a random variate distributed according to the
-     * binomial distribution with parameters specified by @c param.
-     */
-    template<class URNG>
-    IntType operator()(URNG& urng, const param_type& parm) const
-    {
-        return binomial_distribution(parm)(urng);
-    }
-
-    /** Returns the @c t parameter of the distribution. */
-    IntType t() const { return _t; }
-    /** Returns the @c p parameter of the distribution. */
-    RealType p() const { return _p; }
-
-    /** Returns the smallest value that the distribution can produce. */
-    IntType min BOOST_PREVENT_MACRO_SUBSTITUTION() const { return 0; }
-    /** Returns the largest value that the distribution can produce. */
-    IntType max BOOST_PREVENT_MACRO_SUBSTITUTION() const { return _t; }
-
-    /** Returns the parameters of the distribution. */
-    param_type param() const { return param_type(_t, _p); }
-    /** Sets parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        _t = parm.t();
-        _p = parm.p();
-        init();
-    }
-
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { }
-
-#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
-    /** Writes the parameters of the distribution to a @c std::ostream. */
-    template<class CharT, class Traits>
-    friend std::basic_ostream<CharT,Traits>&
-    operator<<(std::basic_ostream<CharT,Traits>& os,
-               const binomial_distribution& bd)
-    {
-        os << bd.param();
-        return os;
-    }
-    
-    /** Reads the parameters of the distribution from a @c std::istream. */
-    template<class CharT, class Traits>
-    friend std::basic_istream<CharT,Traits>&
-    operator>>(std::basic_istream<CharT,Traits>& is, binomial_distribution& bd)
-    {
-        bd.read(is);
-        return is;
-    }
-#endif
-
-    /** Returns true if the two distributions will produce the same
-        sequence of values, given equal generators. */
-    friend bool operator==(const binomial_distribution& lhs,
-                           const binomial_distribution& rhs)
-    {
-        return lhs._t == rhs._t && lhs._p == rhs._p;
-    }
-    /** Returns true if the two distributions could produce different
-        sequences of values, given equal generators. */
-    friend bool operator!=(const binomial_distribution& lhs,
-                           const binomial_distribution& rhs)
-    {
-        return !(lhs == rhs);
-    }
-
-private:
-
-    /// @cond show_private
-
-    template<class CharT, class Traits>
-    void read(std::basic_istream<CharT, Traits>& is) {
-        param_type parm;
-        if(is >> parm) {
-            param(parm);
-        }
-    }
-
-    bool use_inversion() const
-    {
-        // BTRD is safe when np >= 10
-        return m < 11;
-    }
-
-    // computes the correction factor for the Stirling approximation
-    // for log(k!)
-    static RealType fc(IntType k)
-    {
-        if(k < 10) return detail::binomial_table<RealType>::table[k];
-        else {
-            RealType ikp1 = RealType(1) / (k + 1);
-            return (RealType(1)/12
-                 - (RealType(1)/360
-                 - (RealType(1)/1260)*(ikp1*ikp1))*(ikp1*ikp1))*ikp1;
-        }
-    }
-
-    void init()
-    {
-        using std::sqrt;
-        using std::pow;
-
-        RealType p = (0.5 < _p)? (1 - _p) : _p;
-        IntType t = _t;
-        
-        m = static_cast<IntType>((t+1)*p);
-
-        if(use_inversion()) {
-            q_n = pow((1 - p), static_cast<RealType>(t));
-        } else {
-            btrd.r = p/(1-p);
-            btrd.nr = (t+1)*btrd.r;
-            btrd.npq = t*p*(1-p);
-            RealType sqrt_npq = sqrt(btrd.npq);
-            btrd.b = 1.15 + 2.53 * sqrt_npq;
-            btrd.a = -0.0873 + 0.0248*btrd.b + 0.01*p;
-            btrd.c = t*p + 0.5;
-            btrd.alpha = (2.83 + 5.1/btrd.b) * sqrt_npq;
-            btrd.v_r = 0.92 - 4.2/btrd.b;
-            btrd.u_rv_r = 0.86*btrd.v_r;
-        }
-    }
-
-    template<class URNG>
-    result_type generate(URNG& urng) const
-    {
-        using std::floor;
-        using std::abs;
-        using std::log;
-
-        while(true) {
-            RealType u;
-            RealType v = uniform_01<RealType>()(urng);
-            if(v <= btrd.u_rv_r) {
-                u = v/btrd.v_r - 0.43;
-                return static_cast<IntType>(floor(
-                    (2*btrd.a/(0.5 - abs(u)) + btrd.b)*u + btrd.c));
-            }
-
-            if(v >= btrd.v_r) {
-                u = uniform_01<RealType>()(urng) - 0.5;
-            } else {
-                u = v/btrd.v_r - 0.93;
-                u = ((u < 0)? -0.5 : 0.5) - u;
-                v = uniform_01<RealType>()(urng) * btrd.v_r;
-            }
-
-            RealType us = 0.5 - abs(u);
-            IntType k = static_cast<IntType>(floor((2*btrd.a/us + btrd.b)*u + btrd.c));
-            if(k < 0 || k > _t) continue;
-            v = v*btrd.alpha/(btrd.a/(us*us) + btrd.b);
-            RealType km = abs(k - m);
-            if(km <= 15) {
-                RealType f = 1;
-                if(m < k) {
-                    IntType i = m;
-                    do {
-                        ++i;
-                        f = f*(btrd.nr/i - btrd.r);
-                    } while(i != k);
-                } else if(m > k) {
-                    IntType i = k;
-                    do {
-                        ++i;
-                        v = v*(btrd.nr/i - btrd.r);
-                    } while(i != m);
-                }
-                if(v <= f) return k;
-                else continue;
-            } else {
-                // final acceptance/rejection
-                v = log(v);
-                RealType rho =
-                    (km/btrd.npq)*(((km/3. + 0.625)*km + 1./6)/btrd.npq + 0.5);
-                RealType t = -km*km/(2*btrd.npq);
-                if(v < t - rho) return k;
-                if(v > t + rho) continue;
-
-                IntType nm = _t - m + 1;
-                RealType h = (m + 0.5)*log((m + 1)/(btrd.r*nm))
-                           + fc(m) + fc(_t - m);
-
-                IntType nk = _t - k + 1;
-                if(v <= h + (_t+1)*log(static_cast<RealType>(nm)/nk)
-                          + (k + 0.5)*log(nk*btrd.r/(k+1))
-                          - fc(k)
-                          - fc(_t - k))
-                {
-                    return k;
-                } else {
-                    continue;
-                }
-            }
-        }
-    }
-
-    template<class URNG>
-    IntType invert(IntType t, RealType p, URNG& urng) const
-    {
-        RealType q = 1 - p;
-        RealType s = p / q;
-        RealType a = (t + 1) * s;
-        RealType r = q_n;
-        RealType u = uniform_01<RealType>()(urng);
-        IntType x = 0;
-        while(u > r) {
-            u = u - r;
-            ++x;
-            RealType r1 = ((a/x) - s) * r;
-            // If r gets too small then the round-off error
-            // becomes a problem.  At this point, p(i) is
-            // decreasing exponentially, so if we just call
-            // it 0, it's close enough.  Note that the
-            // minimum value of q_n is about 1e-7, so we
-            // may need to be a little careful to make sure that
-            // we don't terminate the first time through the loop
-            // for float.  (Hence the test that r is decreasing)
-            if(r1 < std::numeric_limits<RealType>::epsilon() && r1 < r) {
-                break;
-            }
-            r = r1;
-        }
-        return x;
-    }
-
-    // parameters
-    IntType _t;
-    RealType _p;
-
-    // common data
-    IntType m;
-
-    union {
-        // for btrd
-        struct {
-            RealType r;
-            RealType nr;
-            RealType npq;
-            RealType b;
-            RealType a;
-            RealType c;
-            RealType alpha;
-            RealType v_r;
-            RealType u_rv_r;
-        } btrd;
-        // for inversion
-        RealType q_n;
-    };
-
-    /// @endcond
-};
-
-}
-
-// backwards compatibility
-using random::binomial_distribution;
-
-}
-
-#include <boost/random/detail/enable_warnings.hpp>
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/random/cauchy_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/cauchy_distribution.hpp
deleted file mode 100644
index 998e523447b..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/cauchy_distribution.hpp
+++ /dev/null
@@ -1,214 +0,0 @@
-/* boost random/cauchy_distribution.hpp header file
- *
- * Copyright Jens Maurer 2000-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 for most recent version including documentation.
- *
- * $Id$
- *
- * Revision history
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_CAUCHY_DISTRIBUTION_HPP
-#define BOOST_RANDOM_CAUCHY_DISTRIBUTION_HPP
-
-#include <boost/config/no_tr1/cmath.hpp>
-#include <iosfwd>
-#include <istream>
-#include <boost/limits.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/uniform_01.hpp>
-
-namespace boost {
-namespace random {
-
-// Cauchy distribution: 
-
-/**
- * The cauchy distribution is a continuous distribution with two
- * parameters, median and sigma.
- *
- * It has \f$\displaystyle p(x) = \frac{\sigma}{\pi(\sigma^2 + (x-m)^2)}\f$
- */
-template<class RealType = double>
-class cauchy_distribution
-{
-public:
-    typedef RealType input_type;
-    typedef RealType result_type;
-
-    class param_type
-    {
-    public:
-
-        typedef cauchy_distribution distribution_type;
-
-        /** Constructs the parameters of the cauchy distribution. */
-        explicit param_type(RealType median_arg = RealType(0.0),
-                            RealType sigma_arg = RealType(1.0))
-          : _median(median_arg), _sigma(sigma_arg) {}
-
-        // backwards compatibility for Boost.Random
-
-        /** Returns the median of the distribution. */
-        RealType median() const { return _median; }
-        /** Returns the sigma parameter of the distribution. */
-        RealType sigma() const { return _sigma; }
-
-        // The new names in C++0x.
-
-        /** Returns the median of the distribution. */
-        RealType a() const { return _median; }
-        /** Returns the sigma parameter of the distribution. */
-        RealType b() const { return _sigma; }
-
-        /** Writes the parameters to a std::ostream. */
-        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
-        {
-            os << parm._median << " " << parm._sigma;
-            return os;
-        }
-
-        /** Reads the parameters from a std::istream. */
-        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
-        {
-            is >> parm._median >> std::ws >> parm._sigma;
-            return is;
-        }
-
-        /** Returns true if the two sets of parameters are equal. */
-        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        { return lhs._median == rhs._median && lhs._sigma == rhs._sigma; }
-
-        /** Returns true if the two sets of parameters are different. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-
-    private:
-        RealType _median;
-        RealType _sigma;
-    };
-
-    /**
-     * Constructs a \cauchy_distribution with the paramters @c median
-     * and @c sigma.
-     */
-    explicit cauchy_distribution(RealType median_arg = RealType(0.0), 
-                                 RealType sigma_arg = RealType(1.0))
-      : _median(median_arg), _sigma(sigma_arg) { }
-    
-    /**
-     * Constructs a \cauchy_distribution from it's parameters.
-     */
-    explicit cauchy_distribution(const param_type& parm)
-      : _median(parm.median()), _sigma(parm.sigma()) { }
-
-    // compiler-generated copy ctor and assignment operator are fine
-
-    // backwards compatibility for Boost.Random
-
-    /** Returns: the "median" parameter of the distribution */
-    RealType median() const { return _median; }
-    /** Returns: the "sigma" parameter of the distribution */
-    RealType sigma() const { return _sigma; }
-    
-    // The new names in C++0x
-
-    /** Returns: the "median" parameter of the distribution */
-    RealType a() const { return _median; }
-    /** Returns: the "sigma" parameter of the distribution */
-    RealType b() const { return _sigma; }
-
-    /** 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)(); }
-
-    param_type param() const { return param_type(_median, _sigma); }
-
-    void param(const param_type& parm)
-    {
-        _median = parm.median();
-        _sigma = parm.sigma();
-    }
-
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { }
-
-    /**
-     * Returns: A random variate distributed according to the
-     * cauchy distribution.
-     */
-    template<class Engine>
-    result_type operator()(Engine& eng)
-    {
-        // Can we have a boost::mathconst please?
-        const result_type pi = result_type(3.14159265358979323846);
-        using std::tan;
-        RealType val = uniform_01<RealType>()(eng)-result_type(0.5);
-        return _median + _sigma * tan(pi*val);
-    }
-
-    /**
-     * Returns: A random variate distributed according to the
-     * cauchy distribution with parameters specified by param.
-     */
-    template<class Engine>
-    result_type operator()(Engine& eng, const param_type& parm)
-    {
-        return cauchy_distribution(parm)(eng);
-    }
-
-    /**
-     * Writes the distribution to a @c std::ostream.
-     */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, cauchy_distribution, cd)
-    {
-        os << cd._median << " " << cd._sigma;
-        return os;
-    }
-
-    /**
-     * Reads the distribution from a @c std::istream.
-     */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, cauchy_distribution, cd)
-    {
-        is >> cd._median >> std::ws >> cd._sigma;
-        return is;
-    }
-
-    /**
-     * Returns true if the two distributions will produce
-     * identical sequences of values, given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(cauchy_distribution, lhs, rhs)
-    { return lhs._median == rhs._median && lhs._sigma == rhs._sigma; }
-
-    /**
-     * Returns true if the two distributions may produce
-     * different sequences of values, given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(cauchy_distribution)
-
-private:
-    RealType _median;
-    RealType _sigma;
-};
-
-} // namespace random
-
-using random::cauchy_distribution;
-
-} // namespace boost
-
-#endif // BOOST_RANDOM_CAUCHY_DISTRIBUTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/chi_squared_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/chi_squared_distribution.hpp
deleted file mode 100644
index f0fcce5c5dd..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/chi_squared_distribution.hpp
+++ /dev/null
@@ -1,209 +0,0 @@
-/* boost random/chi_squared_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_CHI_SQUARED_DISTRIBUTION_HPP_INCLUDED
-#define BOOST_RANDOM_CHI_SQUARED_DISTRIBUTION_HPP_INCLUDED
-
-#include <iosfwd>
-#include <boost/limits.hpp>
-
-#include <boost/random/detail/config.hpp>
-#include <boost/random/gamma_distribution.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * The chi squared distribution is a real valued distribution with
- * one parameter, @c n.  The distribution produces values > 0.
- *
- * The distribution function is
- * \f$\displaystyle P(x) = \frac{x^{(n/2)-1}e^{-x/2}}{\Gamma(n/2)2^{n/2}}\f$.
- */
-template<class RealType = double>
-class chi_squared_distribution {
-public:
-    typedef RealType result_type;
-    typedef RealType input_type;
-
-    class param_type {
-    public:
-        typedef chi_squared_distribution distribution_type;
-        /**
-         * Construct a param_type object.  @c n
-         * is the parameter of the distribution.
-         *
-         * Requires: t >=0 && 0 <= p <= 1
-         */
-        explicit param_type(RealType n_arg = RealType(1))
-          : _n(n_arg)
-        {}
-        /** Returns the @c n parameter of the distribution. */
-        RealType n() const { return _n; }
-#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
-        /** Writes the parameters of the distribution to a @c std::ostream. */
-        template<class CharT, class Traits>
-        friend std::basic_ostream<CharT,Traits>&
-        operator<<(std::basic_ostream<CharT,Traits>& os,
-                   const param_type& parm)
-        {
-            os << parm._n;
-            return os;
-        }
-    
-        /** Reads the parameters of the distribution from a @c std::istream. */
-        template<class CharT, class Traits>
-        friend std::basic_istream<CharT,Traits>&
-        operator>>(std::basic_istream<CharT,Traits>& is, param_type& parm)
-        {
-            is >> parm._n;
-            return is;
-        }
-#endif
-        /** Returns true if the parameters have the same values. */
-        friend bool operator==(const param_type& lhs, const param_type& rhs)
-        {
-            return lhs._n == rhs._n;
-        }
-        /** Returns true if the parameters have different values. */
-        friend bool operator!=(const param_type& lhs, const param_type& rhs)
-        {
-            return !(lhs == rhs);
-        }
-    private:
-        RealType _n;
-    };
-    
-    /**
-     * Construct a @c chi_squared_distribution object. @c n
-     * is the parameter of the distribution.
-     *
-     * Requires: t >=0 && 0 <= p <= 1
-     */
-    explicit chi_squared_distribution(RealType n_arg = RealType(1))
-      : _impl(static_cast<RealType>(n_arg / 2))
-    {
-    }
-    
-    /**
-     * Construct an @c chi_squared_distribution object from the
-     * parameters.
-     */
-    explicit chi_squared_distribution(const param_type& parm)
-      : _impl(static_cast<RealType>(parm.n() / 2))
-    {
-    }
-    
-    /**
-     * Returns a random variate distributed according to the
-     * chi squared distribution.
-     */
-    template<class URNG>
-    RealType operator()(URNG& urng)
-    {
-        return 2 * _impl(urng);
-    }
-    
-    /**
-     * Returns a random variate distributed according to the
-     * chi squared distribution with parameters specified by @c param.
-     */
-    template<class URNG>
-    RealType operator()(URNG& urng, const param_type& parm) const
-    {
-        return chi_squared_distribution(parm)(urng);
-    }
-
-    /** Returns the @c n parameter of the distribution. */
-    RealType n() const { return 2 * _impl.alpha(); }
-
-    /** Returns the smallest value that the distribution can produce. */
-    RealType min BOOST_PREVENT_MACRO_SUBSTITUTION() const { return 0; }
-    /** 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 parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        typedef gamma_distribution<RealType> impl_type;
-        typename impl_type::param_type impl_parm(static_cast<RealType>(parm.n() / 2));
-        _impl.param(impl_parm);
-    }
-
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { _impl.reset(); }
-
-#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
-    /** Writes the parameters of the distribution to a @c std::ostream. */
-    template<class CharT, class Traits>
-    friend std::basic_ostream<CharT,Traits>&
-    operator<<(std::basic_ostream<CharT,Traits>& os,
-               const chi_squared_distribution& c2d)
-    {
-        os << c2d.param();
-        return os;
-    }
-    
-    /** Reads the parameters of the distribution from a @c std::istream. */
-    template<class CharT, class Traits>
-    friend std::basic_istream<CharT,Traits>&
-    operator>>(std::basic_istream<CharT,Traits>& is,
-               chi_squared_distribution& c2d)
-    {
-        c2d.read(is);
-        return is;
-    }
-#endif
-
-    /** Returns true if the two distributions will produce the same
-        sequence of values, given equal generators. */
-    friend bool operator==(const chi_squared_distribution& lhs,
-                           const chi_squared_distribution& rhs)
-    {
-        return lhs._impl == rhs._impl;
-    }
-    /** Returns true if the two distributions could produce different
-        sequences of values, given equal generators. */
-    friend bool operator!=(const chi_squared_distribution& lhs,
-                           const chi_squared_distribution& rhs)
-    {
-        return !(lhs == rhs);
-    }
-
-private:
-
-    /// @cond show_private
-
-    template<class CharT, class Traits>
-    void read(std::basic_istream<CharT, Traits>& is) {
-        param_type parm;
-        if(is >> parm) {
-            param(parm);
-        }
-    }
-
-    gamma_distribution<RealType> _impl;
-
-    /// @endcond
-};
-
-}
-
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/random/detail/auto_link.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/auto_link.hpp
deleted file mode 100644
index acbebdd4f01..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/detail/auto_link.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-/* boost random auto_link.hpp header file
- *
- * Copyright Steven Watanabe 2010
- * 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)
- *
- * $Id$
- */
-
-#ifndef BOOST_RANDOM_DETAIL_AUTO_LINK_HPP
-#define BOOST_RANDOM_DETAIL_AUTO_LINK_HPP
-
-#include <boost/config.hpp>
-
-#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_RANDOM_DYN_LINK)
-    #if defined(BOOST_RANDOM_SOURCE)
-        #define BOOST_RANDOM_DECL BOOST_SYMBOL_EXPORT
-    #else
-        #define BOOST_RANDOM_DECL BOOST_SYMBOL_IMPORT
-    #endif
-#endif
-
-#ifndef BOOST_RANDOM_DECL
-    #define BOOST_RANDOM_DECL
-#endif
-
-#if !defined(BOOST_RANDOM_NO_LIB) && !defined(BOOST_ALL_NO_LIB) && !defined(BOOST_RANDOM_SOURCE)
-
-#define BOOST_LIB_NAME boost_random
-
-#if defined(BOOST_RANDOM_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)
-    #define BOOST_DYN_LINK
-#endif
-
-#include <boost/config/auto_link.hpp>
-
-#endif
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/random/detail/config.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/config.hpp
deleted file mode 100644
index 724ab194520..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/detail/config.hpp
+++ /dev/null
@@ -1,18 +0,0 @@
-/* boost random/detail/config.hpp header file
- *
- * Copyright Steven Watanabe 2009
- * 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$
- */
-
-#include <boost/config.hpp>
-
-#if (defined(BOOST_NO_OPERATORS_IN_NAMESPACE) || defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)) \
-    && !defined(BOOST_MSVC)
-    #define BOOST_RANDOM_NO_STREAM_OPERATORS
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/random/detail/const_mod.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/const_mod.hpp
deleted file mode 100644
index e0a43ab2499..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/detail/const_mod.hpp
+++ /dev/null
@@ -1,216 +0,0 @@
-/* boost random/detail/const_mod.hpp header file
- *
- * Copyright Jens Maurer 2000-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 for most recent version including documentation.
- *
- * $Id$
- *
- * Revision history
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_CONST_MOD_HPP
-#define BOOST_RANDOM_CONST_MOD_HPP
-
-#include <boost/assert.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/integer_traits.hpp>
-#include <boost/type_traits/make_unsigned.hpp>
-#include <boost/random/detail/large_arithmetic.hpp>
-
-#include <boost/random/detail/disable_warnings.hpp>
-
-namespace boost {
-namespace random {
-
-template<class IntType, IntType m>
-class const_mod
-{
-public:
-  static IntType apply(IntType x)
-  {
-    if(((unsigned_m() - 1) & unsigned_m()) == 0)
-      return (unsigned_type(x)) & (unsigned_m() - 1);
-    else {
-      IntType suppress_warnings = (m == 0);
-      BOOST_ASSERT(suppress_warnings == 0);
-      return x % (m + suppress_warnings);
-    }
-  }
-
-  static IntType add(IntType x, IntType c)
-  {
-    if(((unsigned_m() - 1) & unsigned_m()) == 0)
-      return (unsigned_type(x) + unsigned_type(c)) & (unsigned_m() - 1);
-    else if(c == 0)
-      return x;
-    else if(x < m - c)
-      return x + c;
-    else
-      return x - (m - c);
-  }
-
-  static IntType mult(IntType a, IntType x)
-  {
-    if(((unsigned_m() - 1) & unsigned_m()) == 0)
-      return unsigned_type(a) * unsigned_type(x) & (unsigned_m() - 1);
-    else if(a == 0)
-      return 0;
-    else if(a == 1)
-      return x;
-    else if(m <= traits::const_max/a)      // i.e. a*m <= max
-      return mult_small(a, x);
-    else if(traits::is_signed && (m%a < m/a))
-      return mult_schrage(a, x);
-    else
-      return mult_general(a, x);
-  }
-
-  static IntType mult_add(IntType a, IntType x, IntType c)
-  {
-    if(((unsigned_m() - 1) & unsigned_m()) == 0)
-      return (unsigned_type(a) * unsigned_type(x) + unsigned_type(c)) & (unsigned_m() - 1);
-    else if(a == 0)
-      return c;
-    else if(m <= (traits::const_max-c)/a) {  // i.e. a*m+c <= max
-      IntType suppress_warnings = (m == 0);
-      BOOST_ASSERT(suppress_warnings == 0);
-      return (a*x+c) % (m + suppress_warnings);
-    } else
-      return add(mult(a, x), c);
-  }
-
-  static IntType pow(IntType a, boost::uintmax_t exponent)
-  {
-      IntType result = 1;
-      while(exponent != 0) {
-          if(exponent % 2 == 1) {
-              result = mult(result, a);
-          }
-          a = mult(a, a);
-          exponent /= 2;
-      }
-      return result;
-  }
-
-  static IntType invert(IntType x)
-  { return x == 0 ? 0 : (m == 0? invert_euclidian0(x) : invert_euclidian(x)); }
-
-private:
-  typedef integer_traits<IntType> traits;
-  typedef typename make_unsigned<IntType>::type unsigned_type;
-
-  const_mod();      // don't instantiate
-
-  static IntType mult_small(IntType a, IntType x)
-  {
-    IntType suppress_warnings = (m == 0);
-    BOOST_ASSERT(suppress_warnings == 0);
-    return a*x % (m + suppress_warnings);
-  }
-
-  static IntType mult_schrage(IntType a, IntType value)
-  {
-    const IntType q = m / a;
-    const IntType r = m % a;
-
-    BOOST_ASSERT(r < q);        // check that overflow cannot happen
-
-    return sub(a*(value%q), r*(value/q));
-  }
-
-  static IntType mult_general(IntType a, IntType b)
-  {
-    IntType suppress_warnings = (m == 0);
-    BOOST_ASSERT(suppress_warnings == 0);
-    IntType modulus = m + suppress_warnings;
-    BOOST_ASSERT(modulus == m);
-    if(::boost::uintmax_t(modulus) <=
-        (::std::numeric_limits< ::boost::uintmax_t>::max)() / modulus)
-    {
-      return static_cast<IntType>(boost::uintmax_t(a) * b % modulus);
-    } else {
-      return static_cast<IntType>(detail::mulmod(a, b, modulus));
-    }
-  }
-
-  static IntType sub(IntType a, IntType b)
-  {
-    if(a < b)
-      return m - (b - a);
-    else
-      return a - b;
-  }
-
-  static unsigned_type unsigned_m()
-  {
-      if(m == 0) {
-          return unsigned_type((std::numeric_limits<IntType>::max)()) + 1;
-      } else {
-          return unsigned_type(m);
-      }
-  }
-
-  // invert c in the finite field (mod m) (m must be prime)
-  static IntType invert_euclidian(IntType c)
-  {
-    // we are interested in the gcd factor for c, because this is our inverse
-    BOOST_ASSERT(c > 0);
-    IntType l1 = 0;
-    IntType l2 = 1;
-    IntType n = c;
-    IntType p = m;
-    for(;;) {
-      IntType q = p / n;
-      l1 += q * l2;
-      p -= q * n;
-      if(p == 0)
-        return l2;
-      IntType q2 = n / p;
-      l2 += q2 * l1;
-      n -= q2 * p;
-      if(n == 0)
-        return m - l1;
-    }
-  }
-
-  // invert c in the finite field (mod m) (c must be relatively prime to m)
-  static IntType invert_euclidian0(IntType c)
-  {
-    // we are interested in the gcd factor for c, because this is our inverse
-    BOOST_ASSERT(c > 0);
-    if(c == 1) return 1;
-    IntType l1 = 0;
-    IntType l2 = 1;
-    IntType n = c;
-    IntType p = m;
-    IntType max = (std::numeric_limits<IntType>::max)();
-    IntType q = max / n;
-    BOOST_ASSERT(max % n != n - 1 && "c must be relatively prime to m.");
-    l1 += q * l2;
-    p = max - q * n + 1;
-    for(;;) {
-      if(p == 0)
-        return l2;
-      IntType q2 = n / p;
-      l2 += q2 * l1;
-      n -= q2 * p;
-      if(n == 0)
-        return m - l1;
-      q = p / n;
-      l1 += q * l2;
-      p -= q * n;
-    }
-  }
-};
-
-} // namespace random
-} // namespace boost
-
-#include <boost/random/detail/enable_warnings.hpp>
-
-#endif // BOOST_RANDOM_CONST_MOD_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/detail/disable_warnings.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/disable_warnings.hpp
deleted file mode 100644
index 4582dcb1a7d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/detail/disable_warnings.hpp
+++ /dev/null
@@ -1,29 +0,0 @@
-/* boost random/detail/disable_warnings.hpp header file
- *
- * Copyright Steven Watanabe 2009
- * 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$
- *
- */
-
-// No #include guard.  This header is intended to be included multiple times.
-
-#include <boost/config.hpp>
-
-#ifdef BOOST_MSVC
-#pragma warning(push)
-#pragma warning(disable:4512)
-#pragma warning(disable:4127)
-#pragma warning(disable:4724)
-#pragma warning(disable:4800) // 'int' : forcing value to bool 'true' or 'false' (performance warning)
-#endif
-
-#if defined(BOOST_GCC) && BOOST_GCC >= 40600
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wlogical-op"
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/random/detail/enable_warnings.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/enable_warnings.hpp
deleted file mode 100644
index 24f3bb3f583..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/detail/enable_warnings.hpp
+++ /dev/null
@@ -1,22 +0,0 @@
-/* boost random/detail/enable_warnings.hpp header file
- *
- * Copyright Steven Watanabe 2009
- * 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$
- *
- */
-
-// No #include guard.  This header is intended to be included multiple times.
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-#if defined(BOOST_GCC) && BOOST_GCC >= 40600
-#pragma GCC diagnostic pop
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/random/detail/generator_bits.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/generator_bits.hpp
deleted file mode 100644
index 05276142cbc..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/detail/generator_bits.hpp
+++ /dev/null
@@ -1,36 +0,0 @@
-/* boost random/detail/generator_bits.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_DETAIL_GENERATOR_BITS_HPP
-#define BOOST_RANDOM_DETAIL_GENERATOR_BITS_HPP
-
-#include <boost/limits.hpp>
-
-namespace boost {
-namespace random {
-namespace detail {
-
-// This is a temporary measure that retains backwards
-// compatibility.
-template<class URNG>
-struct generator_bits {
-    static std::size_t value() {
-        return std::numeric_limits<typename URNG::result_type>::digits;
-    }
-};
-
-} // namespace detail
-} // namespace random
-} // namespace boost
-
-#endif // BOOST_RANDOM_DETAIL_GENERATOR_BITS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/detail/generator_seed_seq.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/generator_seed_seq.hpp
deleted file mode 100644
index 7e134834649..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/detail/generator_seed_seq.hpp
+++ /dev/null
@@ -1,40 +0,0 @@
-/* boost random/mersenne_twister.hpp header file
- *
- * Copyright Jens Maurer 2000-2001
- * Copyright Steven Watanabe 2010
- * 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_DETAIL_GENERATOR_SEED_SEQ_HPP_INCLUDED
-#define BOOST_RANDOM_DETAIL_GENERATOR_SEED_SEQ_HPP_INCLUDED
-
-namespace boost {
-namespace random {
-namespace detail {
-
-template<class Generator>
-class generator_seed_seq {
-public:
-    generator_seed_seq(Generator& g) : gen(&g) {}
-    template<class It>
-    void generate(It first, It last) {
-        for(; first != last; ++first) {
-            *first = (*gen)();
-        }
-    }
-private:
-    Generator* gen;
-};
-
-}
-}
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/random/detail/int_float_pair.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/int_float_pair.hpp
deleted file mode 100644
index de253a0ecbf..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/detail/int_float_pair.hpp
+++ /dev/null
@@ -1,121 +0,0 @@
-/* boost random/detail/int_float_pair.hpp header file
- *
- * Copyright Jens Maurer 2000-2001
- * Copyright Steven Watanabe 2010-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_DETAIL_INT_FLOAT_PAIR_HPP
-#define BOOST_RANDOM_DETAIL_INT_FLOAT_PAIR_HPP
-
-#include <utility>
-#include <boost/integer.hpp>
-#include <boost/integer/integer_mask.hpp>
-#include <boost/type_traits/make_unsigned.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/random/uniform_01.hpp>
-#include <boost/random/uniform_int_distribution.hpp>
-#include <boost/random/detail/signed_unsigned_tools.hpp>
-#include <boost/random/detail/integer_log2.hpp>
-#include <boost/mpl/bool.hpp>
-
-namespace boost {
-namespace random {
-namespace detail {
-
-template<class Engine>
-inline typename boost::make_unsigned<typename Engine::result_type>::type
-generate_one_digit(Engine& eng, std::size_t bits)
-{
-    typedef typename Engine::result_type base_result;
-    typedef typename boost::make_unsigned<base_result>::type base_unsigned;
-    
-    base_unsigned range =
-        detail::subtract<base_result>()((eng.max)(), (eng.min)());
-    base_unsigned y0_mask = (base_unsigned(2) << (bits - 1)) - 1;
-    base_unsigned y0 = (range + 1) & ~y0_mask;
-    base_unsigned u;
-    do {
-        u = detail::subtract<base_result>()(eng(), (eng.min)());
-    } while(y0 != 0 && u > base_unsigned(y0 - 1));
-    return u & y0_mask;
-}
-
-template<class RealType, std::size_t w, class Engine>
-std::pair<RealType, int> generate_int_float_pair(Engine& eng, boost::mpl::true_)
-{
-    typedef typename Engine::result_type base_result;
-    typedef typename boost::make_unsigned<base_result>::type base_unsigned;
-    
-    base_unsigned range =
-        detail::subtract<base_result>()((eng.max)(), (eng.min)());
-    
-    std::size_t m =
-        (range == (std::numeric_limits<base_unsigned>::max)()) ?
-            std::numeric_limits<base_unsigned>::digits :
-            detail::integer_log2(range + 1);
-            
-    int bucket = 0;
-    // process as many full digits as possible into the int part
-    for(std::size_t i = 0; i < w/m; ++i) {
-        base_unsigned u = generate_one_digit(eng, m);
-        bucket = (bucket << m) | u;
-    }
-    RealType r;
-
-    const std::size_t digits = std::numeric_limits<RealType>::digits;
-    {
-        base_unsigned u = generate_one_digit(eng, m);
-        base_unsigned mask = (base_unsigned(1) << (w%m)) - 1;
-        bucket = (bucket << (w%m)) | (mask & u);
-        const RealType mult = RealType(1)/RealType(base_unsigned(1) << (m - w%m));
-        // zero out unused bits
-        if (m - w%m > digits) {
-            u &= ~(base_unsigned(1) << (m - digits));
-        }
-        r = RealType(u >> (w%m)) * mult;
-    }
-    for(std::size_t i = m - w%m; i + m < digits; ++i) {
-        base_unsigned u = generate_one_digit(eng, m);
-        r += u;
-        r *= RealType(0.5)/RealType(base_unsigned(1) << (m - 1));
-    }
-    if (m - w%m < digits)
-    {
-        const std::size_t remaining = (digits - m + w%m) % m;
-        base_unsigned u = generate_one_digit(eng, m);
-        r += u & ((base_unsigned(2) << (remaining - 1)) - 1);
-        const RealType mult = RealType(0.5)/RealType(base_unsigned(1) << (remaining - 1));
-        r *= mult;
-    }
-    return std::make_pair(r, bucket);
-}
-
-template<class RealType, std::size_t w, class Engine>
-inline std::pair<RealType, int> generate_int_float_pair(Engine& eng, boost::mpl::false_)
-{
-    int bucket = uniform_int_distribution<>(0, (1 << w) - 1)(eng);
-    RealType r = uniform_01<RealType>()(eng);
-    return std::make_pair(r, bucket);
-}
-
-template<class RealType, std::size_t w, class Engine>
-inline std::pair<RealType, int> generate_int_float_pair(Engine& eng)
-{
-    typedef typename Engine::result_type base_result;
-    return generate_int_float_pair<RealType, w>(eng,
-        boost::is_integral<base_result>());
-}
-
-} // namespace detail
-} // namespace random
-} // namespace boost
-
-#endif // BOOST_RANDOM_DETAIL_INT_FLOAT_PAIR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/detail/integer_log2.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/integer_log2.hpp
deleted file mode 100644
index 248243a4b2e..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/detail/integer_log2.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-/* boost random/detail/integer_log2.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_DETAIL_INTEGER_LOG2_HPP
-#define BOOST_RANDOM_DETAIL_INTEGER_LOG2_HPP
-
-#include <boost/config.hpp>
-#include <boost/limits.hpp>
-#include <boost/pending/integer_log2.hpp>
-
-namespace boost {
-namespace random {
-namespace detail {
-
-#if !defined(BOOST_NO_CXX11_CONSTEXPR)
-#define BOOST_RANDOM_DETAIL_CONSTEXPR constexpr
-#elif defined(BOOST_MSVC)
-#define BOOST_RANDOM_DETAIL_CONSTEXPR __forceinline
-#elif defined(__GNUC__) && __GNUC__ >= 4
-#define BOOST_RANDOM_DETAIL_CONSTEXPR inline __attribute__((__const__)) __attribute__((__always_inline__))
-#else
-#define BOOST_RANDOM_DETAIL_CONSTEXPR inline
-#endif
-
-template<int Shift>
-struct integer_log2_impl
-{
-#if defined(BOOST_NO_CXX11_CONSTEXPR)
-    template<class T>
-    BOOST_RANDOM_DETAIL_CONSTEXPR static int apply(T t, int accum)
-    {
-        int update = ((t >> Shift) != 0) * Shift;
-        return integer_log2_impl<Shift / 2>::apply(t >> update, accum + update);
-    }
-#else
-    template<class T>
-    BOOST_RANDOM_DETAIL_CONSTEXPR static int apply2(T t, int accum, int update)
-    {
-        return integer_log2_impl<Shift / 2>::apply(t >> update, accum + update);
-    }
-
-    template<class T>
-    BOOST_RANDOM_DETAIL_CONSTEXPR static int apply(T t, int accum)
-    {
-        return apply2(t, accum, ((t >> Shift) != 0) * Shift);
-    }
-#endif
-};
-
-template<>
-struct integer_log2_impl<1>
-{
-    template<class T>
-    BOOST_RANDOM_DETAIL_CONSTEXPR static int apply(T t, int accum)
-    {
-        return int(t >> 1) + accum;
-    }
-};
-
-template<class T>
-BOOST_RANDOM_DETAIL_CONSTEXPR int integer_log2(T t)
-{
-    return integer_log2_impl<
-        ::boost::detail::max_pow2_less<
-            ::std::numeric_limits<T>::digits, 4
-        >::value
-    >::apply(t, 0);
-}
-
-} // namespace detail
-} // namespace random
-} // namespace boost
-
-#endif // BOOST_RANDOM_DETAIL_INTEGER_LOG2_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/detail/iterator_mixin.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/iterator_mixin.hpp
deleted file mode 100644
index 57ff75cecab..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/detail/iterator_mixin.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-/* boost random/detail/iterator_mixin.hpp header file
- *
- * Copyright Jens Maurer 2000-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 for most recent version including documentation.
- *
- * Revision history
- */
-
-#ifndef BOOST_ITERATOR_MIXIN_HPP
-#define BOOST_ITERATOR_MIXIN_HPP
-
-#include <boost/operators.hpp>
-
-namespace boost {
-
-// must be in boost namespace, otherwise the inline friend trick fails
-template<class Generator, class ResultType>
-class generator_iterator_mixin_adapter
-  : incrementable<Generator>, equality_comparable<Generator>
-{
-public:
-  typedef std::input_iterator_tag iterator_category;
-  typedef ResultType value_type;
-  typedef std::ptrdiff_t difference_type;
-  typedef const value_type * pointer;
-  typedef const value_type & reference;
-  Generator& operator++() { v = cast()(); return cast(); }
-  const value_type& operator*() const { return v; }
-
-protected:
-  // instantiate from derived classes only
-  generator_iterator_mixin_adapter() { }
-  void iterator_init() { operator++(); }
-private:
-  Generator & cast() { return static_cast<Generator&>(*this); }
-  value_type v;
-};
-
-} // namespace boost
-
-#endif // BOOST_ITERATOR_MIXIN_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/detail/large_arithmetic.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/large_arithmetic.hpp
deleted file mode 100644
index 66f6b4e6156..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/detail/large_arithmetic.hpp
+++ /dev/null
@@ -1,122 +0,0 @@
-/* boost random/detail/large_arithmetic.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_DETAIL_LARGE_ARITHMETIC_HPP
-#define BOOST_RANDOM_DETAIL_LARGE_ARITHMETIC_HPP
-
-#include <boost/cstdint.hpp>
-#include <boost/integer.hpp>
-#include <boost/limits.hpp>
-#include <boost/random/detail/integer_log2.hpp>
-
-#include <boost/random/detail/disable_warnings.hpp>
-
-namespace boost {
-namespace random {
-namespace detail {
-
-struct div_t {
-    boost::uintmax_t quotient;
-    boost::uintmax_t remainder;
-};
-
-inline div_t muldivmod(boost::uintmax_t a, boost::uintmax_t b, boost::uintmax_t m)
-{
-    const int bits =
-        ::std::numeric_limits< ::boost::uintmax_t>::digits / 2;
-    const ::boost::uintmax_t mask = (::boost::uintmax_t(1) << bits) - 1;
-    typedef ::boost::uint_t<bits>::fast digit_t;
-
-    int shift = std::numeric_limits< ::boost::uintmax_t>::digits - 1
-        - detail::integer_log2(m);
-
-    a <<= shift;
-    m <<= shift;
-
-    digit_t product[4] = { 0, 0, 0, 0 };
-    digit_t a_[2] = { digit_t(a & mask), digit_t((a >> bits) & mask) };
-    digit_t b_[2] = { digit_t(b & mask), digit_t((b >> bits) & mask) };
-    digit_t m_[2] = { digit_t(m & mask), digit_t((m >> bits) & mask) };
-
-    // multiply a * b
-    for(int i = 0; i < 2; ++i) {
-        digit_t carry = 0;
-        for(int j = 0; j < 2; ++j) {
-            ::boost::uint64_t temp = ::boost::uintmax_t(a_[i]) * b_[j] +
-                carry + product[i + j];
-            product[i + j] = digit_t(temp & mask);
-            carry = digit_t(temp >> bits);
-        }
-        if(carry != 0) {
-            product[i + 2] += carry;
-        }
-    }
-
-    digit_t quotient[2];
-
-    if(m == 0) {
-        div_t result = {
-            ((::boost::uintmax_t(product[3]) << bits) | product[2]),
-            ((::boost::uintmax_t(product[1]) << bits) | product[0]) >> shift,
-        };
-        return result;
-    }
-
-    // divide product / m
-    for(int i = 3; i >= 2; --i) {
-        ::boost::uintmax_t temp =
-            ::boost::uintmax_t(product[i]) << bits | product[i - 1];
-
-        digit_t q = digit_t((product[i] == m_[1]) ? mask : temp / m_[1]);
-
-        ::boost::uintmax_t rem =
-            ((temp - ::boost::uintmax_t(q) * m_[1]) << bits) + product[i - 2];
-
-        ::boost::uintmax_t diff = m_[0] * ::boost::uintmax_t(q);
-
-        int error = 0;
-        if(diff > rem) {
-            if(diff - rem > m) {
-                error = 2;
-            } else {
-                error = 1;
-            }
-        }
-        q -= error;
-        rem = rem + error * m - diff;
-
-        quotient[i - 2] = q;
-        product[i] = 0;
-        product[i-1] = static_cast<digit_t>((rem >> bits) & mask);
-        product[i-2] = static_cast<digit_t>(rem & mask);
-    }
-
-    div_t result = {
-        ((::boost::uintmax_t(quotient[1]) << bits) | quotient[0]),
-        ((::boost::uintmax_t(product[1]) << bits) | product[0]) >> shift,
-    };
-    return result;
-}
-
-inline boost::uintmax_t muldiv(boost::uintmax_t a, boost::uintmax_t b, boost::uintmax_t m)
-{ return detail::muldivmod(a, b, m).quotient; }
-
-inline boost::uintmax_t mulmod(boost::uintmax_t a, boost::uintmax_t b, boost::uintmax_t m)
-{ return detail::muldivmod(a, b, m).remainder; }
-
-} // namespace detail
-} // namespace random
-} // namespace boost
-
-#include <boost/random/detail/enable_warnings.hpp>
-
-#endif // BOOST_RANDOM_DETAIL_LARGE_ARITHMETIC_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/detail/operators.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/operators.hpp
deleted file mode 100644
index 597343c9070..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/detail/operators.hpp
+++ /dev/null
@@ -1,84 +0,0 @@
-/* boost random/detail/operators.hpp header file
- *
- * Copyright Steven Watanabe 2010-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_DETAIL_OPERATORS_HPP
-#define BOOST_RANDOM_DETAIL_OPERATORS_HPP
-
-#include <boost/random/detail/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1310)   \
-    || BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
-
-#define BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, T, t)                  \
-    template<class CharT, class Traits>                                 \
-    friend std::basic_ostream<CharT,Traits>&                            \
-    operator<<(std::basic_ostream<CharT,Traits>& os, const T& t) {      \
-        t.print(os, t);                                                 \
-        return os;                                                      \
-    }                                                                   \
-    template<class CharT, class Traits>                                 \
-    static std::basic_ostream<CharT,Traits>&                            \
-    print(std::basic_ostream<CharT,Traits>& os, const T& t)
-
-#define BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, T, t)                  \
-    template<class CharT, class Traits>                                 \
-    friend std::basic_istream<CharT,Traits>&                            \
-    operator>>(std::basic_istream<CharT,Traits>& is, T& t) {            \
-        t.read(is, t);                                                  \
-        return is;                                                      \
-    }                                                                   \
-    template<class CharT, class Traits>                                 \
-    static std::basic_istream<CharT,Traits>&                            \
-    read(std::basic_istream<CharT,Traits>& is, T& t)
-
-#endif
-
-#if defined(__BORLANDC__)
-
-#define BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(T, lhs, rhs)              \
-    bool operator==(const T& rhs) const                                 \
-    { return T::is_equal(*this, rhs); }                                 \
-    static bool is_equal(const T& lhs, const T& rhs)
-
-#define BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(T)                      \
-    bool operator!=(const T& rhs) const                                 \
-    { return !T::is_equal(*this, rhs); }
-
-#endif
-
-#ifndef BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR
-#define BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, T, t)                  \
-    template<class CharT, class Traits>                                 \
-    friend std::basic_ostream<CharT,Traits>&                            \
-    operator<<(std::basic_ostream<CharT,Traits>& os, const T& t)
-#endif
-
-#ifndef BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR
-#define BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, T, t)                  \
-    template<class CharT, class Traits>                                 \
-    friend std::basic_istream<CharT,Traits>&                            \
-    operator>>(std::basic_istream<CharT,Traits>& is, T& t)
-#endif
-
-#ifndef BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR
-#define BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(T, lhs, rhs)              \
-    friend bool operator==(const T& lhs, const T& rhs)
-#endif
-
-#ifndef BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR
-#define BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(T)                      \
-    friend bool operator!=(const T& lhs, const T& rhs)                  \
-    { return !(lhs == rhs); }
-#endif
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/random/detail/polynomial.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/polynomial.hpp
deleted file mode 100644
index a8c4b269f1f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/detail/polynomial.hpp
+++ /dev/null
@@ -1,384 +0,0 @@
-/* boost random/detail/polynomial.hpp header file
- *
- * Copyright Steven Watanabe 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 including documentation.
- *
- * $Id$
- */
-
-#ifndef BOOST_RANDOM_DETAIL_POLYNOMIAL_HPP
-#define BOOST_RANDOM_DETAIL_POLYNOMIAL_HPP
-
-#include <cstddef>
-#include <limits>
-#include <vector>
-#include <algorithm>
-#include <boost/assert.hpp>
-#include <boost/cstdint.hpp>
-
-namespace boost {
-namespace random {
-namespace detail {
-
-class polynomial_ops {
-public:
-    typedef unsigned long digit_t;
-
-    static void add(std::size_t size, const digit_t * lhs,
-                       const digit_t * rhs, digit_t * output)
-    {
-        for(std::size_t i = 0; i < size; ++i) {
-            output[i] = lhs[i] ^ rhs[i];
-        }
-    }
-
-    static void add_shifted_inplace(std::size_t size, const digit_t * lhs,
-                                    digit_t * output, std::size_t shift)
-    {
-        if(shift == 0) {
-            add(size, lhs, output, output);
-            return;
-        }
-        std::size_t bits = std::numeric_limits<digit_t>::digits;
-        digit_t prev = 0;
-        for(std::size_t i = 0; i < size; ++i) {
-            digit_t tmp = lhs[i];
-            output[i] ^= (tmp << shift) | (prev >> (bits-shift));
-            prev = tmp;
-        }
-        output[size] ^= (prev >> (bits-shift));
-    }
-
-    static void multiply_simple(std::size_t size, const digit_t * lhs,
-                                   const digit_t * rhs, digit_t * output)
-    {
-        std::size_t bits = std::numeric_limits<digit_t>::digits;
-        for(std::size_t i = 0; i < 2*size; ++i) {
-            output[i] = 0;
-        }
-        for(std::size_t i = 0; i < size; ++i) {
-            for(std::size_t j = 0; j < bits; ++j) {
-                if((lhs[i] & (digit_t(1) << j)) != 0) {
-                    add_shifted_inplace(size, rhs, output + i, j);
-                }
-            }
-        }
-    }
-
-    // memory requirements: (size - cutoff) * 4 + next_smaller
-    static void multiply_karatsuba(std::size_t size,
-                               const digit_t * lhs, const digit_t * rhs,
-                               digit_t * output)
-    {
-        if(size < 64) {
-            multiply_simple(size, lhs, rhs, output);
-            return;
-        }
-        // split in half
-        std::size_t cutoff = size/2;
-        multiply_karatsuba(cutoff, lhs, rhs, output);
-        multiply_karatsuba(size - cutoff, lhs + cutoff, rhs + cutoff,
-                              output + cutoff*2);
-        std::vector<digit_t> local1(size - cutoff);
-        std::vector<digit_t> local2(size - cutoff);
-        // combine the digits for the inner multiply
-        add(cutoff, lhs, lhs + cutoff, &local1[0]);
-        if(size & 1) local1[cutoff] = lhs[size - 1];
-        add(cutoff, rhs + cutoff, rhs, &local2[0]);
-        if(size & 1) local2[cutoff] = rhs[size - 1];
-        std::vector<digit_t> local3((size - cutoff) * 2);
-        multiply_karatsuba(size - cutoff, &local1[0], &local2[0], &local3[0]);
-        add(cutoff * 2, output, &local3[0], &local3[0]);
-        add((size - cutoff) * 2, output + cutoff*2, &local3[0], &local3[0]);
-        // Finally, add the inner result
-        add((size - cutoff) * 2, output + cutoff, &local3[0], output + cutoff);
-    }
-    
-    static void multiply_add_karatsuba(std::size_t size,
-                                       const digit_t * lhs, const digit_t * rhs,
-                                       digit_t * output)
-    {
-        std::vector<digit_t> buf(size * 2);
-        multiply_karatsuba(size, lhs, rhs, &buf[0]);
-        add(size * 2, &buf[0], output, output);
-    }
-
-    static void multiply(const digit_t * lhs, std::size_t lhs_size,
-                         const digit_t * rhs, std::size_t rhs_size,
-                         digit_t * output)
-    {
-        std::fill_n(output, lhs_size + rhs_size, digit_t(0));
-        multiply_add(lhs, lhs_size, rhs, rhs_size, output);
-    }
-
-    static void multiply_add(const digit_t * lhs, std::size_t lhs_size,
-                             const digit_t * rhs, std::size_t rhs_size,
-                             digit_t * output)
-    {
-        // split into pieces that can be passed to
-        // karatsuba multiply.
-        while(lhs_size != 0) {
-            if(lhs_size < rhs_size) {
-                std::swap(lhs, rhs);
-                std::swap(lhs_size, rhs_size);
-            }
-            
-            multiply_add_karatsuba(rhs_size, lhs, rhs, output);
-            
-            lhs += rhs_size;
-            lhs_size -= rhs_size;
-            output += rhs_size;
-        }
-    }
-
-    static void copy_bits(const digit_t * x, std::size_t low, std::size_t high,
-                   digit_t * out)
-    {
-        const std::size_t bits = std::numeric_limits<digit_t>::digits;
-        std::size_t offset = low/bits;
-        x += offset;
-        low -= offset*bits;
-        high -= offset*bits;
-        std::size_t n = (high-low)/bits;
-        if(low == 0) {
-            for(std::size_t i = 0; i < n; ++i) {
-                out[i] = x[i];
-            }
-        } else {
-            for(std::size_t i = 0; i < n; ++i) {
-                out[i] = (x[i] >> low) | (x[i+1] << (bits-low));
-            }
-        }
-        if((high-low)%bits) {
-            digit_t low_mask = (digit_t(1) << ((high-low)%bits)) - 1;
-            digit_t result = (x[n] >> low);
-            if(low != 0 && (n+1)*bits < high) {
-                result |= (x[n+1] << (bits-low));
-            }
-            out[n] = (result & low_mask);
-        }
-    }
-
-    static void shift_left(digit_t * val, std::size_t size, std::size_t shift)
-    {
-        const std::size_t bits = std::numeric_limits<digit_t>::digits;
-        BOOST_ASSERT(shift > 0);
-        BOOST_ASSERT(shift < bits);
-        digit_t prev = 0;
-        for(std::size_t i = 0; i < size; ++i) {
-            digit_t tmp = val[i];
-            val[i] = (prev >> (bits - shift)) | (val[i] << shift);
-            prev = tmp;
-        }
-    }
-
-    static digit_t sqr(digit_t val) {
-        const std::size_t bits = std::numeric_limits<digit_t>::digits;
-        digit_t mask = (digit_t(1) << bits/2) - 1;
-        for(std::size_t i = bits; i > 1; i /= 2) {
-            val = ((val & ~mask) << i/2) | (val & mask);
-            mask = mask & (mask >> i/4);
-            mask = mask | (mask << i/2);
-        }
-        return val;
-    }
-
-    static void sqr(digit_t * val, std::size_t size)
-    {
-        const std::size_t bits = std::numeric_limits<digit_t>::digits;
-        digit_t mask = (digit_t(1) << bits/2) - 1;
-        for(std::size_t i = 0; i < size; ++i) {
-            digit_t x = val[size - i - 1];
-            val[(size - i - 1) * 2] = sqr(x & mask);
-            val[(size - i - 1) * 2 + 1] = sqr(x >> bits/2);
-        }
-    }
-
-    // optimized for the case when the modulus has few bits set.
-    struct sparse_mod {
-        sparse_mod(const digit_t * divisor, std::size_t divisor_bits)
-        {
-            const std::size_t bits = std::numeric_limits<digit_t>::digits;
-            _remainder_bits = divisor_bits - 1;
-            for(std::size_t i = 0; i < divisor_bits; ++i) {
-                if(divisor[i/bits] & (digit_t(1) << i%bits)) {
-                    _bit_indices.push_back(i);
-                }
-            }
-            BOOST_ASSERT(_bit_indices.back() == divisor_bits - 1);
-            _bit_indices.pop_back();
-            if(_bit_indices.empty()) {
-                _block_bits = divisor_bits;
-                _lower_bits = 0;
-            } else {
-                _block_bits = divisor_bits - _bit_indices.back() - 1;
-                _lower_bits = _bit_indices.back() + 1;
-            }
-            
-            _partial_quotient.resize((_block_bits + bits - 1)/bits);
-        }
-        void operator()(digit_t * dividend, std::size_t dividend_bits)
-        {
-            const std::size_t bits = std::numeric_limits<digit_t>::digits;
-            while(dividend_bits > _remainder_bits) {
-                std::size_t block_start = (std::max)(dividend_bits - _block_bits, _remainder_bits);
-                std::size_t block_size = (dividend_bits - block_start + bits - 1) / bits;
-                copy_bits(dividend, block_start, dividend_bits, &_partial_quotient[0]);
-                for(std::size_t i = 0; i < _bit_indices.size(); ++i) {
-                    std::size_t pos = _bit_indices[i] + block_start - _remainder_bits;
-                    add_shifted_inplace(block_size, &_partial_quotient[0], dividend + pos/bits, pos%bits);
-                }
-                add_shifted_inplace(block_size, &_partial_quotient[0], dividend + block_start/bits, block_start%bits);
-                dividend_bits = block_start;
-            }
-        }
-        std::vector<digit_t> _partial_quotient;
-        std::size_t _remainder_bits;
-        std::size_t _block_bits;
-        std::size_t _lower_bits;
-        std::vector<std::size_t> _bit_indices;
-    };
-
-    // base should have the same number of bits as mod
-    // base, and mod should both be able to hold a power
-    // of 2 >= mod_bits.  out needs to be twice as large.
-    static void mod_pow_x(boost::uintmax_t exponent, const digit_t * mod, std::size_t mod_bits, digit_t * out)
-    {
-        const std::size_t bits = std::numeric_limits<digit_t>::digits;
-        const std::size_t n = (mod_bits + bits - 1) / bits;
-        const std::size_t highbit = mod_bits - 1;
-        if(exponent == 0) {
-            out[0] = 1;
-            std::fill_n(out + 1, n - 1, digit_t(0));
-            return;
-        }
-        boost::uintmax_t i = std::numeric_limits<boost::uintmax_t>::digits - 1;
-        while(((boost::uintmax_t(1) << i) & exponent) == 0) {
-            --i;
-        }
-        out[0] = 2;
-        std::fill_n(out + 1, n - 1, digit_t(0));
-        sparse_mod m(mod, mod_bits);
-        while(i--) {
-            sqr(out, n);
-            m(out, 2 * mod_bits - 1);
-            if((boost::uintmax_t(1) << i) & exponent) {
-                shift_left(out, n, 1);
-                if(out[highbit / bits] & (digit_t(1) << highbit%bits))
-                    add(n, out, mod, out);
-            }
-        }
-    }
-};
-
-class polynomial
-{
-    typedef polynomial_ops::digit_t digit_t;
-public:
-    polynomial() : _size(0) {}
-    class reference {
-    public:
-        reference(digit_t &value, int idx)
-            : _value(value), _idx(idx) {}
-        operator bool() const { return (_value & (digit_t(1) << _idx)) != 0; }
-        reference& operator=(bool b)
-        {
-            if(b) {
-                _value |= (digit_t(1) << _idx);
-            } else {
-                _value &= ~(digit_t(1) << _idx);
-            }
-            return *this;
-        }
-        reference &operator^=(bool b)
-        {
-            _value ^= (digit_t(b) << _idx);
-            return *this;
-        }
-
-        reference &operator=(const reference &other)
-        {
-            return *this = static_cast<bool>(other);
-        }
-    private:
-        digit_t &_value;
-        int _idx;
-    };
-    reference operator[](std::size_t i)
-    {
-        static const std::size_t bits = std::numeric_limits<digit_t>::digits;
-        ensure_bit(i);
-        return reference(_storage[i/bits], i%bits);
-    }
-    bool operator[](std::size_t i) const
-    {
-        static const std::size_t bits = std::numeric_limits<digit_t>::digits;
-        if(i < size())
-            return (_storage[i/bits] & (digit_t(1) << (i%bits))) != 0;
-        else
-            return false;
-    }
-    std::size_t size() const
-    {
-        return _size;
-    }
-    void resize(std::size_t n)
-    {
-        static const std::size_t bits = std::numeric_limits<digit_t>::digits;
-        _storage.resize((n + bits - 1)/bits);
-        // clear the high order bits in case we're shrinking.
-        if(n%bits) {
-            _storage.back() &= ((digit_t(1) << (n%bits)) - 1);
-        }
-        _size = n;
-    }
-    friend polynomial operator*(const polynomial &lhs, const polynomial &rhs);
-    friend polynomial mod_pow_x(boost::uintmax_t exponent, polynomial mod);
-private:
-    std::vector<polynomial_ops::digit_t> _storage;
-    std::size_t _size;
-    void ensure_bit(std::size_t i)
-    {
-        if(i >= size()) {
-            resize(i + 1);
-        }
-    }
-    void normalize()
-    {
-        while(size() && (*this)[size() - 1] == 0)
-            resize(size() - 1);
-    }
-};
-
-inline polynomial operator*(const polynomial &lhs, const polynomial &rhs)
-{
-    polynomial result;
-    result._storage.resize(lhs._storage.size() + rhs._storage.size());
-    polynomial_ops::multiply(&lhs._storage[0], lhs._storage.size(),
-                             &rhs._storage[0], rhs._storage.size(),
-                             &result._storage[0]);
-    result._size = lhs._size + rhs._size;
-    return result;
-}
-
-inline polynomial mod_pow_x(boost::uintmax_t exponent, polynomial mod)
-{
-    polynomial result;
-    mod.normalize();
-    std::size_t mod_size = mod.size();
-    result._storage.resize(mod._storage.size() * 2);
-    result._size = mod.size() * 2;
-    polynomial_ops::mod_pow_x(exponent, &mod._storage[0], mod_size, &result._storage[0]);
-    result.resize(mod.size() - 1);
-    return result;
-}
-
-}
-}
-}
-
-#endif // BOOST_RANDOM_DETAIL_POLYNOMIAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/detail/ptr_helper.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/ptr_helper.hpp
deleted file mode 100644
index f1b983d9367..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/detail/ptr_helper.hpp
+++ /dev/null
@@ -1,67 +0,0 @@
-/* boost random/detail/ptr_helper.hpp header file
- *
- * Copyright Jens Maurer 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 including documentation.
- *
- * $Id$
- *
- */
-
-#ifndef BOOST_RANDOM_DETAIL_PTR_HELPER_HPP
-#define BOOST_RANDOM_DETAIL_PTR_HELPER_HPP
-
-#include <boost/config.hpp>
-
-
-namespace boost {
-namespace random {
-namespace detail {
-
-// type_traits could help here, but I don't want to depend on type_traits.
-template<class T>
-struct ptr_helper
-{
-  typedef T value_type;
-  typedef T& reference_type;
-  typedef const T& rvalue_type;
-  static reference_type ref(T& r) { return r; }
-  static const T& ref(const T& r) { return r; }
-};
-
-template<class T>
-struct ptr_helper<T&>
-{
-  typedef T value_type;
-  typedef T& reference_type;
-  typedef T& rvalue_type;
-  static reference_type ref(T& r) { return r; }
-  static const T& ref(const T& r) { return r; }
-};
-
-template<class T>
-struct ptr_helper<T*>
-{
-  typedef T value_type;
-  typedef T& reference_type;
-  typedef T* rvalue_type;
-  static reference_type ref(T * p) { return *p; }
-  static const T& ref(const T * p) { return *p; }
-};
-
-} // namespace detail
-} // namespace random
-} // namespace boost
-
-//
-// BOOST_RANDOM_PTR_HELPER_SPEC --
-//
-//  Helper macro for broken compilers defines specializations of
-//  ptr_helper.
-//
-# define BOOST_RANDOM_PTR_HELPER_SPEC(T)
-
-#endif // BOOST_RANDOM_DETAIL_PTR_HELPER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/detail/seed.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/seed.hpp
deleted file mode 100644
index 557482ad4b1..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/detail/seed.hpp
+++ /dev/null
@@ -1,115 +0,0 @@
-/* boost random/detail/seed.hpp header file
- *
- * Copyright Steven Watanabe 2009
- * 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_DETAIL_SEED_HPP
-#define BOOST_RANDOM_DETAIL_SEED_HPP
-
-#include <boost/config.hpp>
-
-// Sun seems to have trouble with the use of SFINAE for the
-// templated constructor.  So does Borland.
-#if !defined(BOOST_NO_SFINAE) && !defined(__SUNPRO_CC) && !defined(__BORLANDC__)
-
-#include <boost/utility/enable_if.hpp>
-#include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/mpl/bool.hpp>
-
-namespace boost {
-namespace random {
-namespace detail {
-
-template<class T>
-struct disable_seed : boost::disable_if<boost::is_arithmetic<T> > {};
-
-template<class Engine, class T>
-struct disable_constructor : disable_seed<T> {};
-
-template<class Engine>
-struct disable_constructor<Engine, Engine> {};
-
-#define BOOST_RANDOM_DETAIL_GENERATOR_CONSTRUCTOR(Self, Generator, gen) \
-    template<class Generator>                                           \
-    explicit Self(Generator& gen, typename ::boost::random::detail::disable_constructor<Self, Generator>::type* = 0)
-
-#define BOOST_RANDOM_DETAIL_GENERATOR_SEED(Self, Generator, gen)    \
-    template<class Generator>                                       \
-    void seed(Generator& gen, typename ::boost::random::detail::disable_seed<Generator>::type* = 0)
-
-#define BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(Self, SeedSeq, seq)    \
-    template<class SeedSeq>                                             \
-    explicit Self(SeedSeq& seq, typename ::boost::random::detail::disable_constructor<Self, SeedSeq>::type* = 0)
-
-#define BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(Self, SeedSeq, seq)   \
-    template<class SeedSeq>                                     \
-    void seed(SeedSeq& seq, typename ::boost::random::detail::disable_seed<SeedSeq>::type* = 0)
-
-#define BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(Self, T, x)  \
-    explicit Self(const T& x)
-
-#define BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(Self, T, x) \
-    void seed(const T& x)
-}
-}
-}
-
-#else
-
-#include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/mpl/bool.hpp>
-
-#define BOOST_RANDOM_DETAIL_GENERATOR_CONSTRUCTOR(Self, Generator, gen) \
-    Self(Self& other) { *this = other; }                                \
-    Self(const Self& other) { *this = other; }                          \
-    template<class Generator>                                           \
-    explicit Self(Generator& gen) {                                     \
-        boost_random_constructor_impl(gen, ::boost::is_arithmetic<Generator>());\
-    }                                                                   \
-    template<class Generator>                                           \
-    void boost_random_constructor_impl(Generator& gen, ::boost::mpl::false_)
-
-#define BOOST_RANDOM_DETAIL_GENERATOR_SEED(Self, Generator, gen)    \
-    template<class Generator>                                       \
-    void seed(Generator& gen) {                                     \
-        boost_random_seed_impl(gen, ::boost::is_arithmetic<Generator>());\
-    }\
-    template<class Generator>\
-    void boost_random_seed_impl(Generator& gen, ::boost::mpl::false_)
-
-#define BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(Self, SeedSeq, seq)    \
-    Self(Self& other) { *this = other; }                                \
-    Self(const Self& other) { *this = other; }                          \
-    template<class SeedSeq>                                             \
-    explicit Self(SeedSeq& seq) {                                       \
-        boost_random_constructor_impl(seq, ::boost::is_arithmetic<SeedSeq>());\
-    }                                                                   \
-    template<class SeedSeq>                                             \
-    void boost_random_constructor_impl(SeedSeq& seq, ::boost::mpl::false_)
-
-#define BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(Self, SeedSeq, seq)           \
-    template<class SeedSeq>                                             \
-    void seed(SeedSeq& seq) {                                           \
-        boost_random_seed_impl(seq, ::boost::is_arithmetic<SeedSeq>()); \
-    }                                                                   \
-    template<class SeedSeq>                                             \
-    void boost_random_seed_impl(SeedSeq& seq, ::boost::mpl::false_)
-
-#define BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(Self, T, x)  \
-    explicit Self(const T& x) { boost_random_constructor_impl(x, ::boost::mpl::true_()); }\
-    void boost_random_constructor_impl(const T& x, ::boost::mpl::true_)
-
-#define BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(Self, T, x) \
-    void seed(const T& x) { boost_random_seed_impl(x, ::boost::mpl::true_()); }\
-    void boost_random_seed_impl(const T& x, ::boost::mpl::true_)
-
-#endif
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/random/detail/seed_impl.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/seed_impl.hpp
deleted file mode 100644
index 918a2944579..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/detail/seed_impl.hpp
+++ /dev/null
@@ -1,398 +0,0 @@
-/* boost random/detail/seed.hpp header file
- *
- * Copyright Steven Watanabe 2009
- * 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_DETAIL_SEED_IMPL_HPP
-#define BOOST_RANDOM_DETAIL_SEED_IMPL_HPP
-
-#include <stdexcept>
-#include <boost/cstdint.hpp>
-#include <boost/throw_exception.hpp>
-#include <boost/config/no_tr1/cmath.hpp>
-#include <boost/integer/integer_mask.hpp>
-#include <boost/integer/static_log2.hpp>
-#include <boost/random/traits.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/mpl/int.hpp>
-#include <boost/random/detail/const_mod.hpp>
-#include <boost/random/detail/integer_log2.hpp>
-#include <boost/random/detail/signed_unsigned_tools.hpp>
-#include <boost/random/detail/generator_bits.hpp>
-
-#include <boost/random/detail/disable_warnings.hpp>
-
-namespace boost {
-namespace random {
-namespace detail {
-
-// finds the seed type of an engine, given its
-// result_type.  If the result_type is integral
-// the seed type is the same.  If the result_type
-// is floating point, the seed type is uint32_t
-template<class T>
-struct seed_type
-{
-    typedef typename boost::mpl::if_<boost::is_integral<T>,
-        T,
-        boost::uint32_t
-    >::type type;
-};
-
-template<int N>
-struct const_pow_impl
-{
-    template<class T>
-    static T call(T arg, int n, T result)
-    {
-        return const_pow_impl<N / 2>::call(T(arg * arg), n / 2,
-            n%2 == 0? result : T(result * arg));
-    }
-};
-
-template<>
-struct const_pow_impl<0>
-{
-    template<class T>
-    static T call(T, int, T result)
-    {
-        return result;
-    }
-};
-
-// requires N is an upper bound on n
-template<int N, class T>
-inline T const_pow(T arg, int n) { return const_pow_impl<N>::call(arg, n, T(1)); }
-
-template<class T>
-inline T pow2(int n)
-{
-    typedef unsigned int_type;
-    const int max_bits = std::numeric_limits<int_type>::digits;
-    T multiplier = T(int_type(1) << (max_bits - 1)) * 2;
-    return (int_type(1) << (n % max_bits)) *
-        const_pow<std::numeric_limits<T>::digits / max_bits>(multiplier, n / max_bits);
-}
-
-template<class Engine, class Iter>
-void generate_from_real(Engine& eng, Iter begin, Iter end)
-{
-    using std::fmod;
-    typedef typename Engine::result_type RealType;
-    const int Bits = detail::generator_bits<Engine>::value();
-    int remaining_bits = 0;
-    boost::uint_least32_t saved_bits = 0;
-    RealType multiplier = pow2<RealType>( Bits);
-    RealType mult32 = RealType(4294967296.0); // 2^32
-    while(true) {
-        RealType val = eng() * multiplier;
-        int available_bits = Bits;
-        // Make sure the compiler can optimize this out
-        // if it isn't possible.
-        if(Bits < 32 && available_bits < 32 - remaining_bits) {
-            saved_bits |= boost::uint_least32_t(val) << remaining_bits;
-            remaining_bits += Bits;
-        } else {
-            // If Bits < 32, then remaining_bits != 0, since
-            // if remaining_bits == 0, available_bits < 32 - 0,
-            // and we won't get here to begin with.
-            if(Bits < 32 || remaining_bits != 0) {
-                boost::uint_least32_t divisor =
-                    (boost::uint_least32_t(1) << (32 - remaining_bits));
-                boost::uint_least32_t extra_bits = boost::uint_least32_t(fmod(val, mult32)) & (divisor - 1);
-                val = val / divisor;
-                *begin++ = saved_bits | (extra_bits << remaining_bits);
-                if(begin == end) return;
-                available_bits -= 32 - remaining_bits;
-                remaining_bits = 0;
-            }
-            // If Bits < 32 we should never enter this loop
-            if(Bits >= 32) {
-                for(; available_bits >= 32; available_bits -= 32) {
-                    boost::uint_least32_t word = boost::uint_least32_t(fmod(val, mult32));
-                    val /= mult32;
-                    *begin++ = word;
-                    if(begin == end) return;
-                }
-            }
-            remaining_bits = available_bits;
-            saved_bits = static_cast<boost::uint_least32_t>(val);
-        }
-    }
-}
-
-template<class Engine, class Iter>
-void generate_from_int(Engine& eng, Iter begin, Iter end)
-{
-    typedef typename Engine::result_type IntType;
-    typedef typename boost::random::traits::make_unsigned<IntType>::type unsigned_type;
-    int remaining_bits = 0;
-    boost::uint_least32_t saved_bits = 0;
-    unsigned_type range = boost::random::detail::subtract<IntType>()((eng.max)(), (eng.min)());
-
-    int bits =
-        (range == (std::numeric_limits<unsigned_type>::max)()) ?
-            std::numeric_limits<unsigned_type>::digits :
-            detail::integer_log2(range + 1);
-
-    {
-        int discarded_bits = detail::integer_log2(bits);
-        unsigned_type excess = (range + 1) >> (bits - discarded_bits);
-        if(excess != 0) {
-            int extra_bits = detail::integer_log2((excess - 1) ^ excess);
-            bits = bits - discarded_bits + extra_bits;
-        }
-    }
-
-    unsigned_type mask = (static_cast<unsigned_type>(2) << (bits - 1)) - 1;
-    unsigned_type limit = ((range + 1) & ~mask) - 1;
-
-    while(true) {
-        unsigned_type val;
-        do {
-            val = boost::random::detail::subtract<IntType>()(eng(), (eng.min)());
-        } while(limit != range && val > limit);
-        val &= mask;
-        int available_bits = bits;
-        if(available_bits == 32) {
-            *begin++ = static_cast<boost::uint_least32_t>(val) & 0xFFFFFFFFu;
-            if(begin == end) return;
-        } else if(available_bits % 32 == 0) {
-            for(int i = 0; i < available_bits / 32; ++i) {
-                boost::uint_least32_t word = boost::uint_least32_t(val) & 0xFFFFFFFFu;
-                int suppress_warning = (bits >= 32);
-                BOOST_ASSERT(suppress_warning == 1);
-                val >>= (32 * suppress_warning);
-                *begin++ = word;
-                if(begin == end) return;
-            }
-        } else if(bits < 32 && available_bits < 32 - remaining_bits) {
-            saved_bits |= boost::uint_least32_t(val) << remaining_bits;
-            remaining_bits += bits;
-        } else {
-            if(bits < 32 || remaining_bits != 0) {
-                boost::uint_least32_t extra_bits = boost::uint_least32_t(val) & ((boost::uint_least32_t(1) << (32 - remaining_bits)) - 1);
-                val >>= 32 - remaining_bits;
-                *begin++ = saved_bits | (extra_bits << remaining_bits);
-                if(begin == end) return;
-                available_bits -= 32 - remaining_bits;
-                remaining_bits = 0;
-            }
-            if(bits >= 32) {
-                for(; available_bits >= 32; available_bits -= 32) {
-                    boost::uint_least32_t word = boost::uint_least32_t(val) & 0xFFFFFFFFu;
-                    int suppress_warning = (bits >= 32);
-                    BOOST_ASSERT(suppress_warning == 1);
-                    val >>= (32 * suppress_warning);
-                    *begin++ = word;
-                    if(begin == end) return;
-                }
-            }
-            remaining_bits = available_bits;
-            saved_bits = static_cast<boost::uint_least32_t>(val);
-        }
-    }
-}
-
-template<class Engine, class Iter>
-void generate_impl(Engine& eng, Iter first, Iter last, boost::mpl::true_)
-{
-    return detail::generate_from_int(eng, first, last);
-}
-
-template<class Engine, class Iter>
-void generate_impl(Engine& eng, Iter first, Iter last, boost::mpl::false_)
-{
-    return detail::generate_from_real(eng, first, last);
-}
-
-template<class Engine, class Iter>
-void generate(Engine& eng, Iter first, Iter last)
-{
-    return detail::generate_impl(eng, first, last, boost::random::traits::is_integral<typename Engine::result_type>());
-}
-
-
-
-template<class IntType, IntType m, class SeedSeq>
-IntType seed_one_int(SeedSeq& seq)
-{
-    static const int log = ::boost::mpl::if_c<(m == 0),
-        ::boost::mpl::int_<(::std::numeric_limits<IntType>::digits)>,
-        ::boost::static_log2<m> >::type::value;
-    static const int k =
-        (log + ((~(static_cast<IntType>(2) << (log - 1)) & m)? 32 : 31)) / 32;
-    ::boost::uint_least32_t array[log / 32 + 4];
-    seq.generate(&array[0], &array[0] + k + 3);
-    IntType s = 0;
-    for(int j = 0; j < k; ++j) {
-        IntType digit = const_mod<IntType, m>::apply(IntType(array[j+3]));
-        IntType mult = IntType(1) << 32*j;
-        s = const_mod<IntType, m>::mult_add(mult, digit, s);
-    }
-    return s;
-}
-
-template<class IntType, IntType m, class Iter>
-IntType get_one_int(Iter& first, Iter last)
-{
-    static const int log = ::boost::mpl::if_c<(m == 0),
-        ::boost::mpl::int_<(::std::numeric_limits<IntType>::digits)>,
-        ::boost::static_log2<m> >::type::value;
-    static const int k =
-        (log + ((~(static_cast<IntType>(2) << (log - 1)) & m)? 32 : 31)) / 32;
-    IntType s = 0;
-    for(int j = 0; j < k; ++j) {
-        if(first == last) {
-            boost::throw_exception(::std::invalid_argument("Not enough elements in call to seed."));
-        }
-        IntType digit = const_mod<IntType, m>::apply(IntType(*first++));
-        IntType mult = IntType(1) << 32*j;
-        s = const_mod<IntType, m>::mult_add(mult, digit, s);
-    }
-    return s;
-}
-
-// TODO: work in-place whenever possible
-template<int w, std::size_t n, class SeedSeq, class UIntType>
-void seed_array_int_impl(SeedSeq& seq, UIntType (&x)[n])
-{
-    boost::uint_least32_t storage[((w+31)/32) * n];
-    seq.generate(&storage[0], &storage[0] + ((w+31)/32) * n);
-    for(std::size_t j = 0; j < n; j++) {
-        UIntType val = 0;
-        for(std::size_t k = 0; k < (w+31)/32; ++k) {
-            val += static_cast<UIntType>(storage[(w+31)/32*j + k]) << 32*k;
-        }
-        x[j] = val & ::boost::low_bits_mask_t<w>::sig_bits;
-    }
-}
-
-template<int w, std::size_t n, class SeedSeq, class IntType>
-inline void seed_array_int_impl(SeedSeq& seq, IntType (&x)[n], boost::mpl::true_)
-{
-    BOOST_STATIC_ASSERT_MSG(boost::is_integral<IntType>::value, "Sorry but this routine has not been ported to non built-in integers as it relies on a reinterpret_cast.");
-    typedef typename boost::make_unsigned<IntType>::type unsigned_array[n];
-    seed_array_int_impl<w>(seq, reinterpret_cast<unsigned_array&>(x));
-}
-
-template<int w, std::size_t n, class SeedSeq, class IntType>
-inline void seed_array_int_impl(SeedSeq& seq, IntType (&x)[n], boost::mpl::false_)
-{
-    seed_array_int_impl<w>(seq, x);
-}
-
-template<int w, std::size_t n, class SeedSeq, class IntType>
-inline void seed_array_int(SeedSeq& seq, IntType (&x)[n])
-{
-    seed_array_int_impl<w>(seq, x, boost::random::traits::is_signed<IntType>());
-}
-
-template<int w, std::size_t n, class Iter, class UIntType>
-void fill_array_int_impl(Iter& first, Iter last, UIntType (&x)[n])
-{
-    for(std::size_t j = 0; j < n; j++) {
-        UIntType val = 0;
-        for(std::size_t k = 0; k < (w+31)/32; ++k) {
-            if(first == last) {
-                boost::throw_exception(std::invalid_argument("Not enough elements in call to seed."));
-            }
-            val += static_cast<UIntType>(*first++) << 32*k;
-        }
-        x[j] = val & ::boost::low_bits_mask_t<w>::sig_bits;
-    }
-}
-
-template<int w, std::size_t n, class Iter, class IntType>
-inline void fill_array_int_impl(Iter& first, Iter last, IntType (&x)[n], boost::mpl::true_)
-{
-    BOOST_STATIC_ASSERT_MSG(boost::is_integral<IntType>::value, "Sorry but this routine has not been ported to non built-in integers as it relies on a reinterpret_cast.");
-    typedef typename boost::make_unsigned<IntType>::type unsigned_array[n];
-    fill_array_int_impl<w>(first, last, reinterpret_cast<unsigned_array&>(x));
-}
-
-template<int w, std::size_t n, class Iter, class IntType>
-inline void fill_array_int_impl(Iter& first, Iter last, IntType (&x)[n], boost::mpl::false_)
-{
-    fill_array_int_impl<w>(first, last, x);
-}
-
-template<int w, std::size_t n, class Iter, class IntType>
-inline void fill_array_int(Iter& first, Iter last, IntType (&x)[n])
-{
-    fill_array_int_impl<w>(first, last, x, boost::random::traits::is_signed<IntType>());
-}
-
-template<int w, std::size_t n, class RealType>
-void seed_array_real_impl(const boost::uint_least32_t* storage, RealType (&x)[n])
-{
-    boost::uint_least32_t mask = ~((~boost::uint_least32_t(0)) << (w%32));
-    RealType two32 = 4294967296.0;
-    const RealType divisor = RealType(1)/detail::pow2<RealType>(w);
-    unsigned int j;
-    for(j = 0; j < n; ++j) {
-        RealType val = RealType(0);
-        RealType mult = divisor;
-        for(int k = 0; k < w/32; ++k) {
-            val += *storage++ * mult;
-            mult *= two32;
-        }
-        if(mask != 0) {
-            val += (*storage++ & mask) * mult;
-        }
-        BOOST_ASSERT(val >= 0);
-        BOOST_ASSERT(val < 1);
-        x[j] = val;
-    }
-}
-
-template<int w, std::size_t n, class SeedSeq, class RealType>
-void seed_array_real(SeedSeq& seq, RealType (&x)[n])
-{
-    using std::pow;
-    boost::uint_least32_t storage[((w+31)/32) * n];
-    seq.generate(&storage[0], &storage[0] + ((w+31)/32) * n);
-    seed_array_real_impl<w>(storage, x);
-}
-
-template<int w, std::size_t n, class Iter, class RealType>
-void fill_array_real(Iter& first, Iter last, RealType (&x)[n])
-{
-    boost::uint_least32_t mask = ~((~boost::uint_least32_t(0)) << (w%32));
-    RealType two32 = 4294967296.0;
-    const RealType divisor = RealType(1)/detail::pow2<RealType>(w);
-    unsigned int j;
-    for(j = 0; j < n; ++j) {
-        RealType val = RealType(0);
-        RealType mult = divisor;
-        for(int k = 0; k < w/32; ++k, ++first) {
-            if(first == last) boost::throw_exception(std::invalid_argument("Not enough elements in call to seed."));
-            val += *first * mult;
-            mult *= two32;
-        }
-        if(mask != 0) {
-            if(first == last) boost::throw_exception(std::invalid_argument("Not enough elements in call to seed."));
-            val += (*first & mask) * mult;
-            ++first;
-        }
-        BOOST_ASSERT(val >= 0);
-        BOOST_ASSERT(val < 1);
-        x[j] = val;
-    }
-}
-
-}
-}
-}
-
-#include <boost/random/detail/enable_warnings.hpp>
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/random/detail/signed_unsigned_tools.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/signed_unsigned_tools.hpp
deleted file mode 100644
index 1979908a312..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/detail/signed_unsigned_tools.hpp
+++ /dev/null
@@ -1,89 +0,0 @@
-/* boost random/detail/signed_unsigned_tools.hpp header file
- *
- * Copyright Jens Maurer 2006
- * 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.
- */
-
-#ifndef BOOST_RANDOM_DETAIL_SIGNED_UNSIGNED_TOOLS
-#define BOOST_RANDOM_DETAIL_SIGNED_UNSIGNED_TOOLS
-
-#include <boost/limits.hpp>
-#include <boost/config.hpp>
-#include <boost/random/traits.hpp>
-
-namespace boost {
-namespace random {
-namespace detail {
-
-
-/*
- * Compute x - y, we know that x >= y, return an unsigned value.
- */
-
-template<class T, bool sgn = std::numeric_limits<T>::is_signed && std::numeric_limits<T>::is_bounded>
-struct subtract { };
-
-template<class T>
-struct subtract<T, /* signed */ false>
-{
-  typedef T result_type;
-  result_type operator()(T x, T y) { return x - y; }
-};
-
-template<class T>
-struct subtract<T, /* signed */ true>
-{
-  typedef typename boost::random::traits::make_unsigned_or_unbounded<T>::type result_type;
-  result_type operator()(T x, T y)
-  {
-    if (y >= 0)   // because x >= y, it follows that x >= 0, too
-      return result_type(x) - result_type(y);
-    if (x >= 0)   // y < 0
-      // avoid the nasty two's complement case for y == min()
-      return result_type(x) + result_type(-(y+1)) + 1;
-    // both x and y are negative: no signed overflow
-    return result_type(x - y);
-  }
-};
-
-/*
- * Compute x + y, x is unsigned, result fits in type of "y".
- */
-
-template<class T1, class T2, bool sgn = (std::numeric_limits<T2>::is_signed && (std::numeric_limits<T1>::digits >= std::numeric_limits<T2>::digits))>
-struct add { };
-
-template<class T1, class T2>
-struct add<T1, T2, /* signed or else T2 has more digits than T1 so the cast always works - needed when T2 is a multiprecision type and T1 is a native integer */ false>
-{
-  typedef T2 result_type;
-  result_type operator()(T1 x, T2 y) { return T2(x) + y; }
-};
-
-template<class T1, class T2>
-struct add<T1, T2, /* signed */ true>
-{
-  typedef T2 result_type;
-  result_type operator()(T1 x, T2 y)
-  {
-    if (y >= 0)
-      return T2(x) + y;
-    // y < 0
-    if (x > T1(-(y+1)))  // result >= 0 after subtraction
-      // avoid the nasty two's complement edge case for y == min()
-      return T2(x - T1(-(y+1)) - 1);
-    // abs(x) < abs(y), thus T2 able to represent x
-    return T2(x) + y;
-  }
-};
-
-} // namespace detail
-} // namespace random
-} // namespace boost
-
-#endif // BOOST_RANDOM_DETAIL_SIGNED_UNSIGNED_TOOLS
-
diff --git a/contrib/libboost/boost_1_65_0/boost/random/detail/uniform_int_float.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/uniform_int_float.hpp
deleted file mode 100644
index 393c455bcde..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/detail/uniform_int_float.hpp
+++ /dev/null
@@ -1,76 +0,0 @@
-/* boost random/detail/uniform_int_float.hpp header file
- *
- * Copyright Jens Maurer 2000-2001
- * 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_DETAIL_UNIFORM_INT_FLOAT_HPP
-#define BOOST_RANDOM_DETAIL_UNIFORM_INT_FLOAT_HPP
-
-#include <boost/limits.hpp>
-#include <boost/config.hpp>
-#include <boost/integer.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/generator_bits.hpp>
-
-#include <boost/random/detail/disable_warnings.hpp>
-
-namespace boost {
-namespace random {
-namespace detail {
-
-template<class URNG>
-class uniform_int_float
-{
-public:
-    typedef URNG base_type;
-    typedef typename base_type::result_type base_result;
-
-    typedef typename boost::uint_t<
-        (std::numeric_limits<boost::uintmax_t>::digits <
-            std::numeric_limits<base_result>::digits)?
-        std::numeric_limits<boost::uintmax_t>::digits :
-        std::numeric_limits<base_result>::digits
-    >::fast result_type;
-
-    uniform_int_float(base_type& rng)
-      : _rng(rng) {}
-
-    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return 0; }
-    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    {
-        std::size_t digits = std::numeric_limits<result_type>::digits;
-        if(detail::generator_bits<URNG>::value() < digits) {
-            digits = detail::generator_bits<URNG>::value();
-        }
-        return (result_type(2) << (digits - 1)) - 1;
-    }
-    base_type& base() { return _rng; }
-    const base_type& base() const { return _rng; }
-
-    result_type operator()()
-    {
-        base_result range = static_cast<base_result>((max)())+1;
-        return static_cast<result_type>(_rng() * range);
-    }
-
-private:
-    base_type& _rng;
-};
-
-} // namespace detail
-} // namespace random
-} // namespace boost
-
-#include <boost/random/detail/enable_warnings.hpp>
-
-#endif // BOOST_RANDOM_DETAIL_UNIFORM_INT_FLOAT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/detail/vector_io.hpp b/contrib/libboost/boost_1_65_0/boost/random/detail/vector_io.hpp
deleted file mode 100644
index 24508c210e1..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/detail/vector_io.hpp
+++ /dev/null
@@ -1,75 +0,0 @@
-/* boost random/vector_io.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_DETAIL_VECTOR_IO_HPP
-#define BOOST_RANDOM_DETAIL_VECTOR_IO_HPP
-
-#include <vector>
-#include <iosfwd>
-#include <istream>
-
-namespace boost {
-namespace random {
-namespace detail {
-
-template<class CharT, class Traits, class T>
-void print_vector(std::basic_ostream<CharT, Traits>& os,
-                  const std::vector<T>& vec)
-{
-    typename std::vector<T>::const_iterator
-        iter = vec.begin(),
-        end =  vec.end();
-    os << os.widen('[');
-    if(iter != end) {
-        os << *iter;
-        ++iter;
-        for(; iter != end; ++iter)
-        {
-            os << os.widen(' ') << *iter;
-        }
-    }
-    os << os.widen(']');
-}
-
-template<class CharT, class Traits, class T>
-void read_vector(std::basic_istream<CharT, Traits>& is, std::vector<T>& vec)
-{
-    CharT ch;
-    if(!(is >> ch)) {
-        return;
-    }
-    if(ch != is.widen('[')) {
-        is.putback(ch);
-        is.setstate(std::ios_base::failbit);
-        return;
-    }
-    T val;
-    while(is >> std::ws >> val) {
-        vec.push_back(val);
-    }
-    if(is.fail()) {
-        is.clear();
-        if(!(is >> ch)) {
-            return;
-        }
-        if(ch != is.widen(']')) {
-            is.putback(ch);
-            is.setstate(std::ios_base::failbit);
-        }
-    }
-}
-
-}
-}
-}
-
-#endif // BOOST_RANDOM_DETAIL_VECTOR_IO_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/discard_block.hpp b/contrib/libboost/boost_1_65_0/boost/random/discard_block.hpp
deleted file mode 100644
index f3c6b82b87f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/discard_block.hpp
+++ /dev/null
@@ -1,241 +0,0 @@
-/* boost random/discard_block.hpp header file
- *
- * Copyright Jens Maurer 2002
- * Copyright Steven Watanabe 2010
- * 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$
- *
- * Revision history
- *  2001-03-02  created
- */
-
-#ifndef BOOST_RANDOM_DISCARD_BLOCK_HPP
-#define BOOST_RANDOM_DISCARD_BLOCK_HPP
-
-#include <iostream>
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/limits.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/seed.hpp>
-#include <boost/random/detail/seed_impl.hpp>
-
-
-namespace boost {
-namespace random {
-
-/**
- * The class template \discard_block_engine is a model of
- * \pseudo_random_number_generator.  It modifies
- * another generator by discarding parts of its output.
- * Out of every block of @c p results, the first @c r
- * will be returned and the rest discarded.
- *
- * Requires: 0 < p <= r
- */
-template<class UniformRandomNumberGenerator, std::size_t p, std::size_t r>
-class discard_block_engine
-{
-    typedef typename detail::seed_type<
-        typename UniformRandomNumberGenerator::result_type>::type seed_type;
-public:
-    typedef UniformRandomNumberGenerator base_type;
-    typedef typename base_type::result_type result_type;
-
-    BOOST_STATIC_CONSTANT(std::size_t, block_size = p);
-    BOOST_STATIC_CONSTANT(std::size_t, used_block = r);
-
-    BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
-    BOOST_STATIC_CONSTANT(std::size_t, total_block = p);
-    BOOST_STATIC_CONSTANT(std::size_t, returned_block = r);
-
-    BOOST_STATIC_ASSERT(total_block >= returned_block);
-
-    /** Uses the default seed for the base generator. */
-    discard_block_engine() : _rng(), _n(0) { }
-    /** Constructs a new \discard_block_engine with a copy of rng. */
-    explicit discard_block_engine(const base_type & rng) : _rng(rng), _n(0) { }
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    /** Constructs a new \discard_block_engine with rng. */
-    explicit discard_block_engine(base_type && rng) : _rng(rng), _n(0) { }
-#endif
-
-    /**
-     * Creates a new \discard_block_engine and seeds the underlying
-     * generator with @c value
-     */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(discard_block_engine,
-                                               seed_type, value)
-    { _rng.seed(value); _n = 0; }
-    
-    /**
-     * Creates a new \discard_block_engine and seeds the underlying
-     * generator with @c seq
-     */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(discard_block_engine, SeedSeq, seq)
-    { _rng.seed(seq); _n = 0; }
-    
-    /**
-     * Creates a new \discard_block_engine and seeds the underlying
-     * generator with first and last.
-     */
-    template<class It> discard_block_engine(It& first, It last)
-      : _rng(first, last), _n(0) { }
-    
-    /** default seeds the underlying generator. */
-    void seed() { _rng.seed(); _n = 0; }
-    /** Seeds the underlying generator with s. */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(discard_block_engine, seed_type, s)
-    { _rng.seed(s); _n = 0; }
-    /** Seeds the underlying generator with seq. */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(discard_block_engine, SeedSeq, seq)
-    { _rng.seed(seq); _n = 0; }
-    /** Seeds the underlying generator with first and last. */
-    template<class It> void seed(It& first, It last)
-    { _rng.seed(first, last); _n = 0; }
-
-    /** Returns the underlying engine. */
-    const base_type& base() const { return _rng; }
-
-    /** Returns the next value of the generator. */
-    result_type operator()()
-    {
-        if(_n >= returned_block) {
-            // discard values of random number generator
-            // Don't use discard, since we still need to
-            // be somewhat compatible with TR1.
-            // _rng.discard(total_block - _n);
-            for(std::size_t i = 0; i < total_block - _n; ++i) {
-                _rng();
-            }
-            _n = 0;
-        }
-        ++_n;
-        return _rng();
-    }
-
-    void discard(boost::uintmax_t z)
-    {
-        for(boost::uintmax_t j = 0; j < z; ++j) {
-            (*this)();
-        }
-    }
-
-    template<class It>
-    void generate(It first, It last)
-    { detail::generate(*this, first, last); }
-
-    /**
-     * Returns the smallest value that the generator can produce.
-     * This is the same as the minimum of the underlying generator.
-     */
-    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return (base_type::min)(); }
-    /**
-     * Returns the largest value that the generator can produce.
-     * This is the same as the maximum of the underlying generator.
-     */
-    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return (base_type::max)(); }
-
-#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
-    /** Writes a \discard_block_engine to a @c std::ostream. */
-    template<class CharT, class Traits>
-    friend std::basic_ostream<CharT,Traits>&
-    operator<<(std::basic_ostream<CharT,Traits>& os,
-               const discard_block_engine& s)
-    {
-        os << s._rng << ' ' << s._n;
-        return os;
-    }
-
-    /** Reads a \discard_block_engine from a @c std::istream. */
-    template<class CharT, class Traits>
-    friend std::basic_istream<CharT,Traits>&
-    operator>>(std::basic_istream<CharT,Traits>& is, discard_block_engine& s)
-    {
-        is >> s._rng >> std::ws >> s._n;
-        return is;
-    }
-#endif
-
-    /** Returns true if the two generators will produce identical sequences. */
-    friend bool operator==(const discard_block_engine& x,
-                           const discard_block_engine& y)
-    { return x._rng == y._rng && x._n == y._n; }
-    /** Returns true if the two generators will produce different sequences. */
-    friend bool operator!=(const discard_block_engine& x,
-                           const discard_block_engine& y)
-    { return !(x == y); }
-
-private:
-    base_type _rng;
-    std::size_t _n;
-};
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-//  A definition is required even for integral static constants
-template<class URNG, std::size_t p, std::size_t r>
-const bool discard_block_engine<URNG, p, r>::has_fixed_range;
-template<class URNG, std::size_t p, std::size_t r>
-const std::size_t discard_block_engine<URNG, p, r>::total_block;
-template<class URNG, std::size_t p, std::size_t r>
-const std::size_t discard_block_engine<URNG, p, r>::returned_block;
-template<class URNG, std::size_t p, std::size_t r>
-const std::size_t discard_block_engine<URNG, p, r>::block_size;
-template<class URNG, std::size_t p, std::size_t r>
-const std::size_t discard_block_engine<URNG, p, r>::used_block;
-#endif
-
-/// \cond \show_deprecated
-
-template<class URNG, int p, int r>
-class discard_block : public discard_block_engine<URNG, p, r>
-{
-    typedef discard_block_engine<URNG, p, r> base_t;
-public:
-    typedef typename base_t::result_type result_type;
-    discard_block() {}
-    template<class T>
-    discard_block(T& arg) : base_t(arg) {}
-    template<class T>
-    discard_block(const T& arg) : base_t(arg) {}
-    template<class It>
-    discard_block(It& first, It last) : base_t(first, last) {}
-    result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return (this->base().min)(); }
-    result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return (this->base().max)(); }
-};
-
-/// \endcond
-
-namespace detail {
-
-    template<class Engine>
-    struct generator_bits;
-    
-    template<class URNG, std::size_t p, std::size_t r>
-    struct generator_bits<discard_block_engine<URNG, p, r> > {
-        static std::size_t value() { return generator_bits<URNG>::value(); }
-    };
-
-    template<class URNG, int p, int r>
-    struct generator_bits<discard_block<URNG, p, r> > {
-        static std::size_t value() { return generator_bits<URNG>::value(); }
-    };
-
-}
-
-} // namespace random
-
-} // namespace boost
-
-#endif // BOOST_RANDOM_DISCARD_BLOCK_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/discrete_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/discrete_distribution.hpp
deleted file mode 100644
index 3d14d4a02c7..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/discrete_distribution.hpp
+++ /dev/null
@@ -1,636 +0,0 @@
-/* boost random/discrete_distribution.hpp header file
- *
- * Copyright Steven Watanabe 2009-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_DISCRETE_DISTRIBUTION_HPP_INCLUDED
-#define BOOST_RANDOM_DISCRETE_DISTRIBUTION_HPP_INCLUDED
-
-#include <vector>
-#include <limits>
-#include <numeric>
-#include <utility>
-#include <iterator>
-#include <boost/assert.hpp>
-#include <boost/random/uniform_01.hpp>
-#include <boost/random/uniform_int_distribution.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/detail/vector_io.hpp>
-
-#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
-#include <initializer_list>
-#endif
-
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-#include <boost/random/detail/disable_warnings.hpp>
-
-namespace boost {
-namespace random {
-namespace detail {
-
-template<class IntType, class WeightType>
-struct integer_alias_table {
-    WeightType get_weight(IntType bin) const {
-        WeightType result = _average;
-        if(bin < _excess) ++result;
-        return result;
-    }
-    template<class Iter>
-    WeightType init_average(Iter begin, Iter end) {
-        WeightType weight_average = 0;
-        IntType excess = 0;
-        IntType n = 0;
-        // weight_average * n + excess == current partial sum
-        // This is a bit messy, but it's guaranteed not to overflow
-        for(Iter iter = begin; iter != end; ++iter) {
-            ++n;
-            if(*iter < weight_average) {
-                WeightType diff = weight_average - *iter;
-                weight_average -= diff / n;
-                if(diff % n > excess) {
-                    --weight_average;
-                    excess += n - diff % n;
-                } else {
-                    excess -= diff % n;
-                }
-            } else {
-                WeightType diff = *iter - weight_average;
-                weight_average += diff / n;
-                if(diff % n < n - excess) {
-                    excess += diff % n;
-                } else {
-                    ++weight_average;
-                    excess -= n - diff % n;
-                }
-            }
-        }
-        _alias_table.resize(static_cast<std::size_t>(n));
-        _average = weight_average;
-        _excess = excess;
-        return weight_average;
-    }
-    void init_empty()
-    {
-        _alias_table.clear();
-        _alias_table.push_back(std::make_pair(static_cast<WeightType>(1),
-                                              static_cast<IntType>(0)));
-        _average = static_cast<WeightType>(1);
-        _excess = static_cast<IntType>(0);
-    }
-    bool operator==(const integer_alias_table& other) const
-    {
-        return _alias_table == other._alias_table &&
-            _average == other._average && _excess == other._excess;
-    }
-    static WeightType normalize(WeightType val, WeightType average)
-    {
-        return val;
-    }
-    static void normalize(std::vector<WeightType>&) {}
-    template<class URNG>
-    WeightType test(URNG &urng) const
-    {
-        return uniform_int_distribution<WeightType>(0, _average)(urng);
-    }
-    bool accept(IntType result, WeightType val) const
-    {
-        return result < _excess || val < _average;
-    }
-    static WeightType try_get_sum(const std::vector<WeightType>& weights)
-    {
-        WeightType result = static_cast<WeightType>(0);
-        for(typename std::vector<WeightType>::const_iterator
-                iter = weights.begin(), end = weights.end();
-            iter != end; ++iter)
-        {
-            if((std::numeric_limits<WeightType>::max)() - result > *iter) {
-                return static_cast<WeightType>(0);
-            }
-            result += *iter;
-        }
-        return result;
-    }
-    template<class URNG>
-    static WeightType generate_in_range(URNG &urng, WeightType max)
-    {
-        return uniform_int_distribution<WeightType>(
-            static_cast<WeightType>(0), max-1)(urng);
-    }
-    typedef std::vector<std::pair<WeightType, IntType> > alias_table_t;
-    alias_table_t _alias_table;
-    WeightType _average;
-    IntType _excess;
-};
-
-template<class IntType, class WeightType>
-struct real_alias_table {
-    WeightType get_weight(IntType) const
-    {
-        return WeightType(1.0);
-    }
-    template<class Iter>
-    WeightType init_average(Iter first, Iter last)
-    {
-        std::size_t size = std::distance(first, last);
-        WeightType weight_sum =
-            std::accumulate(first, last, static_cast<WeightType>(0));
-        _alias_table.resize(size);
-        return weight_sum / size;
-    }
-    void init_empty()
-    {
-        _alias_table.clear();
-        _alias_table.push_back(std::make_pair(static_cast<WeightType>(1),
-                                              static_cast<IntType>(0)));
-    }
-    bool operator==(const real_alias_table& other) const
-    {
-        return _alias_table == other._alias_table;
-    }
-    static WeightType normalize(WeightType val, WeightType average)
-    {
-        return val / average;
-    }
-    static void normalize(std::vector<WeightType>& weights)
-    {
-        WeightType sum =
-            std::accumulate(weights.begin(), weights.end(),
-                            static_cast<WeightType>(0));
-        for(typename std::vector<WeightType>::iterator
-                iter = weights.begin(),
-                end = weights.end();
-            iter != end; ++iter)
-        {
-            *iter /= sum;
-        }
-    }
-    template<class URNG>
-    WeightType test(URNG &urng) const
-    {
-        return uniform_01<WeightType>()(urng);
-    }
-    bool accept(IntType, WeightType) const
-    {
-        return true;
-    }
-    static WeightType try_get_sum(const std::vector<WeightType>& weights)
-    {
-        return static_cast<WeightType>(1);
-    }
-    template<class URNG>
-    static WeightType generate_in_range(URNG &urng, WeightType)
-    {
-        return uniform_01<WeightType>()(urng);
-    }
-    typedef std::vector<std::pair<WeightType, IntType> > alias_table_t;
-    alias_table_t _alias_table;
-};
-
-template<bool IsIntegral>
-struct select_alias_table;
-
-template<>
-struct select_alias_table<true> {
-    template<class IntType, class WeightType>
-    struct apply {
-        typedef integer_alias_table<IntType, WeightType> type;
-    };
-};
-
-template<>
-struct select_alias_table<false> {
-    template<class IntType, class WeightType>
-    struct apply {
-        typedef real_alias_table<IntType, WeightType> type;
-    };
-};
-
-}
-
-/**
- * The class @c discrete_distribution models a \random_distribution.
- * It produces integers in the range [0, n) with the probability
- * of producing each value is specified by the parameters of the
- * distribution.
- */
-template<class IntType = int, class WeightType = double>
-class discrete_distribution {
-public:
-    typedef WeightType input_type;
-    typedef IntType result_type;
-
-    class param_type {
-    public:
-
-        typedef discrete_distribution distribution_type;
-
-        /**
-         * Constructs a @c param_type object, representing a distribution
-         * with \f$p(0) = 1\f$ and \f$p(k|k>0) = 0\f$.
-         */
-        param_type() : _probabilities(1, static_cast<WeightType>(1)) {}
-        /**
-         * If @c first == @c last, equivalent to the default constructor.
-         * Otherwise, the values of the range represent weights for the
-         * possible values of the distribution.
-         */
-        template<class Iter>
-        param_type(Iter first, Iter last) : _probabilities(first, last)
-        {
-            normalize();
-        }
-#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
-        /**
-         * If wl.size() == 0, equivalent to the default constructor.
-         * Otherwise, the values of the @c initializer_list represent
-         * weights for the possible values of the distribution.
-         */
-        param_type(const std::initializer_list<WeightType>& wl)
-          : _probabilities(wl)
-        {
-            normalize();
-        }
-#endif
-        /**
-         * If the range is empty, equivalent to the default constructor.
-         * Otherwise, the elements of the range represent
-         * weights for the possible values of the distribution.
-         */
-        template<class Range>
-        explicit param_type(const Range& range)
-          : _probabilities(boost::begin(range), boost::end(range))
-        {
-            normalize();
-        }
-
-        /**
-         * If nw is zero, equivalent to the default constructor.
-         * Otherwise, the range of the distribution is [0, nw),
-         * and the weights are found by  calling fw with values
-         * evenly distributed between \f$\mbox{xmin} + \delta/2\f$ and
-         * \f$\mbox{xmax} - \delta/2\f$, where
-         * \f$\delta = (\mbox{xmax} - \mbox{xmin})/\mbox{nw}\f$.
-         */
-        template<class Func>
-        param_type(std::size_t nw, double xmin, double xmax, Func fw)
-        {
-            std::size_t n = (nw == 0) ? 1 : nw;
-            double delta = (xmax - xmin) / n;
-            BOOST_ASSERT(delta > 0);
-            for(std::size_t k = 0; k < n; ++k) {
-                _probabilities.push_back(fw(xmin + k*delta + delta/2));
-            }
-            normalize();
-        }
-
-        /**
-         * Returns a vector containing the probabilities of each possible
-         * value of the distribution.
-         */
-        std::vector<WeightType> probabilities() const
-        {
-            return _probabilities;
-        }
-
-        /** Writes the parameters to a @c std::ostream. */
-        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
-        {
-            detail::print_vector(os, parm._probabilities);
-            return os;
-        }
-        
-        /** Reads the parameters from a @c std::istream. */
-        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
-        {
-            std::vector<WeightType> temp;
-            detail::read_vector(is, temp);
-            if(is) {
-                parm._probabilities.swap(temp);
-            }
-            return is;
-        }
-
-        /** Returns true if the two sets of parameters are the same. */
-        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        {
-            return lhs._probabilities == rhs._probabilities;
-        }
-        /** Returns true if the two sets of parameters are different. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-    private:
-        /// @cond show_private
-        friend class discrete_distribution;
-        explicit param_type(const discrete_distribution& dist)
-          : _probabilities(dist.probabilities())
-        {}
-        void normalize()
-        {
-            impl_type::normalize(_probabilities);
-        }
-        std::vector<WeightType> _probabilities;
-        /// @endcond
-    };
-
-    /**
-     * Creates a new @c discrete_distribution object that has
-     * \f$p(0) = 1\f$ and \f$p(i|i>0) = 0\f$.
-     */
-    discrete_distribution()
-    {
-        _impl.init_empty();
-    }
-    /**
-     * Constructs a discrete_distribution from an iterator range.
-     * If @c first == @c last, equivalent to the default constructor.
-     * Otherwise, the values of the range represent weights for the
-     * possible values of the distribution.
-     */
-    template<class Iter>
-    discrete_distribution(Iter first, Iter last)
-    {
-        init(first, last);
-    }
-#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
-    /**
-     * Constructs a @c discrete_distribution from a @c std::initializer_list.
-     * If the @c initializer_list is empty, equivalent to the default
-     * constructor.  Otherwise, the values of the @c initializer_list
-     * represent weights for the possible values of the distribution.
-     * For example, given the distribution
-     *
-     * @code
-     * discrete_distribution<> dist{1, 4, 5};
-     * @endcode
-     *
-     * The probability of a 0 is 1/10, the probability of a 1 is 2/5,
-     * the probability of a 2 is 1/2, and no other values are possible.
-     */
-    discrete_distribution(std::initializer_list<WeightType> wl)
-    {
-        init(wl.begin(), wl.end());
-    }
-#endif
-    /**
-     * Constructs a discrete_distribution from a Boost.Range range.
-     * If the range is empty, equivalent to the default constructor.
-     * Otherwise, the values of the range represent weights for the
-     * possible values of the distribution.
-     */
-    template<class Range>
-    explicit discrete_distribution(const Range& range)
-    {
-        init(boost::begin(range), boost::end(range));
-    }
-    /**
-     * Constructs a discrete_distribution that approximates a function.
-     * If nw is zero, equivalent to the default constructor.
-     * Otherwise, the range of the distribution is [0, nw),
-     * and the weights are found by  calling fw with values
-     * evenly distributed between \f$\mbox{xmin} + \delta/2\f$ and
-     * \f$\mbox{xmax} - \delta/2\f$, where
-     * \f$\delta = (\mbox{xmax} - \mbox{xmin})/\mbox{nw}\f$.
-     */
-    template<class Func>
-    discrete_distribution(std::size_t nw, double xmin, double xmax, Func fw)
-    {
-        std::size_t n = (nw == 0) ? 1 : nw;
-        double delta = (xmax - xmin) / n;
-        BOOST_ASSERT(delta > 0);
-        std::vector<WeightType> weights;
-        for(std::size_t k = 0; k < n; ++k) {
-            weights.push_back(fw(xmin + k*delta + delta/2));
-        }
-        init(weights.begin(), weights.end());
-    }
-    /**
-     * Constructs a discrete_distribution from its parameters.
-     */
-    explicit discrete_distribution(const param_type& parm)
-    {
-        param(parm);
-    }
-
-    /**
-     * Returns a value distributed according to the parameters of the
-     * discrete_distribution.
-     */
-    template<class URNG>
-    IntType operator()(URNG& urng) const
-    {
-        BOOST_ASSERT(!_impl._alias_table.empty());
-        IntType result;
-        WeightType test;
-        do {
-            result = uniform_int_distribution<IntType>((min)(), (max)())(urng);
-            test = _impl.test(urng);
-        } while(!_impl.accept(result, test));
-        if(test < _impl._alias_table[static_cast<std::size_t>(result)].first) {
-            return result;
-        } else {
-            return(_impl._alias_table[static_cast<std::size_t>(result)].second);
-        }
-    }
-    
-    /**
-     * Returns a value distributed according to the parameters
-     * specified by param.
-     */
-    template<class URNG>
-    IntType operator()(URNG& urng, const param_type& parm) const
-    {
-        if(WeightType limit = impl_type::try_get_sum(parm._probabilities)) {
-            WeightType val = impl_type::generate_in_range(urng, limit);
-            WeightType sum = 0;
-            std::size_t result = 0;
-            for(typename std::vector<WeightType>::const_iterator
-                    iter = parm._probabilities.begin(),
-                    end = parm._probabilities.end();
-                iter != end; ++iter, ++result)
-            {
-                sum += *iter;
-                if(sum > val) {
-                    return result;
-                }
-            }
-            // This shouldn't be reachable, but round-off error
-            // can prevent any match from being found when val is
-            // very close to 1.
-            return static_cast<IntType>(parm._probabilities.size() - 1);
-        } else {
-            // WeightType is integral and sum(parm._probabilities)
-            // would overflow.  Just use the easy solution.
-            return discrete_distribution(parm)(urng);
-        }
-    }
-    
-    /** Returns the smallest value that the distribution can produce. */
-    result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return 0; }
-    /** Returns the largest value that the distribution can produce. */
-    result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    { return static_cast<result_type>(_impl._alias_table.size() - 1); }
-
-    /**
-     * Returns a vector containing the probabilities of each
-     * value of the distribution.  For example, given
-     *
-     * @code
-     * discrete_distribution<> dist = { 1, 4, 5 };
-     * std::vector<double> p = dist.param();
-     * @endcode
-     *
-     * the vector, p will contain {0.1, 0.4, 0.5}.
-     *
-     * If @c WeightType is integral, then the weights
-     * will be returned unchanged.
-     */
-    std::vector<WeightType> probabilities() const
-    {
-        std::vector<WeightType> result(_impl._alias_table.size(), static_cast<WeightType>(0));
-        std::size_t i = 0;
-        for(typename impl_type::alias_table_t::const_iterator
-                iter = _impl._alias_table.begin(),
-                end = _impl._alias_table.end();
-                iter != end; ++iter, ++i)
-        {
-            WeightType val = iter->first;
-            result[i] += val;
-            result[static_cast<std::size_t>(iter->second)] += _impl.get_weight(i) - val;
-        }
-        impl_type::normalize(result);
-        return(result);
-    }
-
-    /** Returns the parameters of the distribution. */
-    param_type param() const
-    {
-        return param_type(*this);
-    }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        init(parm._probabilities.begin(), parm._probabilities.end());
-    }
-    
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() {}
-
-    /** Writes a distribution to a @c std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, discrete_distribution, dd)
-    {
-        os << dd.param();
-        return os;
-    }
-
-    /** Reads a distribution from a @c std::istream */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, discrete_distribution, dd)
-    {
-        param_type parm;
-        if(is >> parm) {
-            dd.param(parm);
-        }
-        return is;
-    }
-
-    /**
-     * Returns true if the two distributions will return the
-     * same sequence of values, when passed equal generators.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(discrete_distribution, lhs, rhs)
-    {
-        return lhs._impl == rhs._impl;
-    }
-    /**
-     * Returns true if the two distributions may return different
-     * sequences of values, when passed equal generators.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(discrete_distribution)
-
-private:
-
-    /// @cond show_private
-
-    template<class Iter>
-    void init(Iter first, Iter last, std::input_iterator_tag)
-    {
-        std::vector<WeightType> temp(first, last);
-        init(temp.begin(), temp.end());
-    }
-    template<class Iter>
-    void init(Iter first, Iter last, std::forward_iterator_tag)
-    {
-        std::vector<std::pair<WeightType, IntType> > below_average;
-        std::vector<std::pair<WeightType, IntType> > above_average;
-        WeightType weight_average = _impl.init_average(first, last);
-        WeightType normalized_average = _impl.get_weight(0);
-        std::size_t i = 0;
-        for(; first != last; ++first, ++i) {
-            WeightType val = impl_type::normalize(*first, weight_average);
-            std::pair<WeightType, IntType> elem(val, static_cast<IntType>(i));
-            if(val < normalized_average) {
-                below_average.push_back(elem);
-            } else {
-                above_average.push_back(elem);
-            }
-        }
-
-        typename impl_type::alias_table_t::iterator
-            b_iter = below_average.begin(),
-            b_end = below_average.end(),
-            a_iter = above_average.begin(),
-            a_end = above_average.end()
-            ;
-        while(b_iter != b_end && a_iter != a_end) {
-            _impl._alias_table[static_cast<std::size_t>(b_iter->second)] =
-                std::make_pair(b_iter->first, a_iter->second);
-            a_iter->first -= (_impl.get_weight(b_iter->second) - b_iter->first);
-            if(a_iter->first < normalized_average) {
-                *b_iter = *a_iter++;
-            } else {
-                ++b_iter;
-            }
-        }
-        for(; b_iter != b_end; ++b_iter) {
-            _impl._alias_table[static_cast<std::size_t>(b_iter->second)].first =
-                _impl.get_weight(b_iter->second);
-        }
-        for(; a_iter != a_end; ++a_iter) {
-            _impl._alias_table[static_cast<std::size_t>(a_iter->second)].first =
-                _impl.get_weight(a_iter->second);
-        }
-    }
-    template<class Iter>
-    void init(Iter first, Iter last)
-    {
-        if(first == last) {
-            _impl.init_empty();
-        } else {
-            typename std::iterator_traits<Iter>::iterator_category category;
-            init(first, last, category);
-        }
-    }
-    typedef typename detail::select_alias_table<
-        (::boost::is_integral<WeightType>::value)
-    >::template apply<IntType, WeightType>::type impl_type;
-    impl_type _impl;
-    /// @endcond
-};
-
-}
-}
-
-#include <boost/random/detail/enable_warnings.hpp>
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/random/exponential_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/exponential_distribution.hpp
deleted file mode 100644
index b4b95c5472b..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/exponential_distribution.hpp
+++ /dev/null
@@ -1,386 +0,0 @@
-/* boost random/exponential_distribution.hpp header file
- *
- * Copyright Jens Maurer 2000-2001
- * Copyright Steven Watanabe 2011
- * Copyright Jason Rhinelander 2016
- * 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$
- *
- * Revision history
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_EXPONENTIAL_DISTRIBUTION_HPP
-#define BOOST_RANDOM_EXPONENTIAL_DISTRIBUTION_HPP
-
-#include <boost/config/no_tr1/cmath.hpp>
-#include <iosfwd>
-#include <boost/assert.hpp>
-#include <boost/limits.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/detail/int_float_pair.hpp>
-#include <boost/random/uniform_01.hpp>
-
-namespace boost {
-namespace random {
-
-namespace detail {
-
-// tables for the ziggurat algorithm
-template<class RealType>
-struct exponential_table {
-    static const RealType table_x[257];
-    static const RealType table_y[257];
-};
-
-template<class RealType>
-const RealType exponential_table<RealType>::table_x[257] = {
-    8.6971174701310497140, 7.6971174701310497140, 6.9410336293772123602, 6.4783784938325698538,
-    6.1441646657724730491, 5.8821443157953997963, 5.6664101674540337371, 5.4828906275260628694,
-    5.3230905057543986131, 5.1814872813015010392, 5.0542884899813047117, 4.9387770859012514838,
-    4.8329397410251125881, 4.7352429966017412526, 4.6444918854200854873, 4.5597370617073515513,
-    4.4802117465284221949, 4.4052876934735729805, 4.3344436803172730116, 4.2672424802773661873,
-    4.2033137137351843802, 4.1423408656640511251, 4.0840513104082974638, 4.0282085446479365106,
-    3.9746060666737884793, 3.9230625001354895926, 3.8734176703995089983, 3.8255294185223367372,
-    3.7792709924116678992, 3.7345288940397975350, 3.6912010902374189454, 3.6491955157608538478,
-    3.6084288131289096339, 3.5688252656483374051, 3.5303158891293438633, 3.4928376547740601814,
-    3.4563328211327607625, 3.4207483572511205323, 3.3860354424603017887, 3.3521490309001100106,
-    3.3190474709707487166, 3.2866921715990692095, 3.2550473085704501813, 3.2240795652862645207,
-    3.1937579032122407483, 3.1640533580259734580, 3.1349388580844407393, 3.1063890623398246660,
-    3.0783802152540905188, 3.0508900166154554479, 3.0238975044556767713, 2.9973829495161306949,
-    2.9713277599210896472, 2.9457143948950456386, 2.9205262865127406647, 2.8957477686001416838,
-    2.8713640120155362592, 2.8473609656351888266, 2.8237253024500354905, 2.8004443702507381944,
-    2.7775061464397572041, 2.7548991965623453650, 2.7326126361947007411, 2.7106360958679293686,
-    2.6889596887418041593, 2.6675739807732670816, 2.6464699631518093905, 2.6256390267977886123,
-    2.6050729387408355373, 2.5847638202141406911, 2.5647041263169053687, 2.5448866271118700928,
-    2.5253043900378279427, 2.5059507635285939648, 2.4868193617402096807, 2.4679040502973649846,
-    2.4491989329782498908, 2.4306983392644199088, 2.4123968126888708336, 2.3942890999214583288,
-    2.3763701405361408194, 2.3586350574093374601, 2.3410791477030346875, 2.3236978743901964559,
-    2.3064868582835798692, 2.2894418705322694265, 2.2725588255531546952, 2.2558337743672190441,
-    2.2392628983129087111, 2.2228425031110364013, 2.2065690132576635755, 2.1904389667232199235,
-    2.1744490099377744673, 2.1585958930438856781, 2.1428764653998416425, 2.1272876713173679737,
-    2.1118265460190418108, 2.0964902118017147637, 2.0812758743932248696, 2.0661808194905755036,
-    2.0512024094685848641, 2.0363380802487695916, 2.0215853383189260770, 2.0069417578945183144,
-    1.9924049782135764992, 1.9779727009573602295, 1.9636426877895480401, 1.9494127580071845659,
-    1.9352807862970511135, 1.9212447005915276767, 1.9073024800183871196, 1.8934521529393077332,
-    1.8796917950722108462, 1.8660195276928275962, 1.8524335159111751661, 1.8389319670188793980,
-    1.8255131289035192212, 1.8121752885263901413, 1.7989167704602903934, 1.7857359354841254047,
-    1.7726311792313049959, 1.7596009308890742369, 1.7466436519460739352, 1.7337578349855711926,
-    1.7209420025219350428, 1.7081947058780575683, 1.6955145241015377061, 1.6829000629175537544,
-    1.6703499537164519163, 1.6578628525741725325, 1.6454374393037234057, 1.6330724165359912048,
-    1.6207665088282577216, 1.6085184617988580769, 1.5963270412864831349, 1.5841910325326886695,
-    1.5721092393862294810, 1.5600804835278879161, 1.5481036037145133070, 1.5361774550410318943,
-    1.5243009082192260050, 1.5124728488721167573, 1.5006921768428164936, 1.4889578055167456003,
-    1.4772686611561334579, 1.4656236822457450411, 1.4540218188487932264, 1.4424620319720121876,
-    1.4309432929388794104, 1.4194645827699828254, 1.4080248915695353509, 1.3966232179170417110,
-    1.3852585682631217189, 1.3739299563284902176, 1.3626364025050864742, 1.3513769332583349176,
-    1.3401505805295045843, 1.3289563811371163220, 1.3177933761763245480, 1.3066606104151739482,
-    1.2955571316866007210, 1.2844819902750125450, 1.2734342382962410994, 1.2624129290696153434,
-    1.2514171164808525098, 1.2404458543344064544, 1.2294981956938491599, 1.2185731922087903071,
-    1.2076698934267612830, 1.1967873460884031665, 1.1859245934042023557, 1.1750806743109117687,
-    1.1642546227056790397, 1.1534454666557748056, 1.1426522275816728928, 1.1318739194110786733,
-    1.1211095477013306083, 1.1103581087274114281, 1.0996185885325976575, 1.0888899619385472598,
-    1.0781711915113727024, 1.0674612264799681530, 1.0567590016025518414, 1.0460634359770445503,
-    1.0353734317905289496, 1.0246878730026178052, 1.0140056239570971074, 1.0033255279156973717,
-    0.99264640550727647009, 0.98196705308506317914, 0.97128624098390397896, 0.96060271166866709917,
-    0.94991517776407659940, 0.93922231995526297952, 0.92852278474721113999, 0.91781518207004493915,
-    0.90709808271569100600, 0.89637001558989069006, 0.88562946476175228052, 0.87487486629102585352,
-    0.86410460481100519511, 0.85331700984237406386, 0.84251035181036928333, 0.83168283773427388393,
-    0.82083260655441252290, 0.80995772405741906620, 0.79905617735548788109, 0.78812586886949324977,
-    0.77716460975913043936, 0.76617011273543541328, 0.75513998418198289808, 0.74407171550050873971,
-    0.73296267358436604916, 0.72181009030875689912, 0.71061105090965570413, 0.69936248110323266174,
-    0.68806113277374858613, 0.67670356802952337911, 0.66528614139267855405, 0.65380497984766565353,
-    0.64225596042453703448, 0.63063468493349100113, 0.61893645139487678178, 0.60715622162030085137,
-    0.59528858429150359384, 0.58332771274877027785, 0.57126731653258903915, 0.55910058551154127652,
-    0.54682012516331112550, 0.53441788123716615385, 0.52188505159213564105, 0.50921198244365495319,
-    0.49638804551867159754, 0.48340149165346224782, 0.47023927508216945338, 0.45688684093142071279,
-    0.44332786607355296305, 0.42954394022541129589, 0.41551416960035700100, 0.40121467889627836229,
-    0.38661797794112021568, 0.37169214532991786118, 0.35639976025839443721, 0.34069648106484979674,
-    0.32452911701691008547, 0.30783295467493287307, 0.29052795549123115167, 0.27251318547846547924,
-    0.25365836338591284433, 0.23379048305967553619, 0.21267151063096745264, 0.18995868962243277774,
-    0.16512762256418831796, 0.13730498094001380420, 0.10483850756582017915, 0.063852163815003480173,
-    0
-};
-
-template<class RealType>
-const RealType exponential_table<RealType>::table_y[257] = {
-    0, 0.00045413435384149675545, 0.00096726928232717452884, 0.0015362997803015723824,
-    0.0021459677437189061793, 0.0027887987935740759640, 0.0034602647778369039855, 0.0041572951208337952532,
-    0.0048776559835423925804, 0.0056196422072054831710, 0.0063819059373191794422, 0.0071633531836349841425,
-    0.0079630774380170392396, 0.0087803149858089752347, 0.0096144136425022094101, 0.010464810181029979488,
-    0.011331013597834597488, 0.012212592426255380661, 0.013109164931254991070, 0.014020391403181937334,
-    0.014945968011691148079, 0.015885621839973162490, 0.016839106826039946359, 0.017806200410911360563,
-    0.018786700744696029497, 0.019780424338009741737, 0.020787204072578117603, 0.021806887504283582125,
-    0.022839335406385238829, 0.023884420511558170348, 0.024942026419731782971, 0.026012046645134218076,
-    0.027094383780955798424, 0.028188948763978634421, 0.029295660224637394015, 0.030414443910466605492,
-    0.031545232172893605499, 0.032687963508959533317, 0.033842582150874329031, 0.035009037697397411067,
-    0.036187284781931419754, 0.037377282772959360128, 0.038578995503074859626, 0.039792391023374122670,
-    0.041017441380414820816, 0.042254122413316231413, 0.043502413568888183301, 0.044762297732943280694,
-    0.046033761076175166762, 0.047316792913181548703, 0.048611385573379494401, 0.049917534282706374944,
-    0.051235237055126279830, 0.052564494593071689595, 0.053905310196046085104, 0.055257689676697038322,
-    0.056621641283742874438, 0.057997175631200659098, 0.059384305633420264487, 0.060783046445479636051,
-    0.062193415408540996150, 0.063615431999807331076, 0.065049117786753755036, 0.066494496385339779043,
-    0.067951593421936607770, 0.069420436498728751675, 0.070901055162371828426, 0.072393480875708743023,
-    0.073897746992364746308, 0.075413888734058408453, 0.076941943170480510100, 0.078481949201606426042,
-    0.080033947542319910023, 0.081597980709237420930, 0.083174093009632380354, 0.084762330532368125386,
-    0.086362741140756912277, 0.087975374467270219300, 0.089600281910032864534, 0.091237516631040162057,
-    0.092887133556043546523, 0.094549189376055853718, 0.096223742550432800103, 0.097910853311492199618,
-    0.099610583670637128826, 0.10132299742595363588, 0.10304816017125771553, 0.10478613930657016928,
-    0.10653700405000166218, 0.10830082545103379867, 0.11007767640518539026, 0.11186763167005629731,
-    0.11367076788274431301, 0.11548716357863353664, 0.11731689921155557057, 0.11916005717532768467,
-    0.12101672182667483729, 0.12288697950954513498, 0.12477091858083096578, 0.12666862943751066518,
-    0.12858020454522817870, 0.13050573846833078225, 0.13244532790138752023, 0.13439907170221363078,
-    0.13636707092642885841, 0.13834942886358021406, 0.14034625107486244210, 0.14235764543247220043,
-    0.14438372216063476473, 0.14642459387834493787, 0.14848037564386679222, 0.15055118500103990354,
-    0.15263714202744286154, 0.15473836938446807312, 0.15685499236936522013, 0.15898713896931420572,
-    0.16113493991759203183, 0.16329852875190180795, 0.16547804187493600915, 0.16767361861725019322,
-    0.16988540130252766513, 0.17211353531532005700, 0.17435816917135348788, 0.17661945459049489581,
-    0.17889754657247831241, 0.18119260347549629488, 0.18350478709776746150, 0.18583426276219711495,
-    0.18818119940425430485, 0.19054576966319540013, 0.19292814997677133873, 0.19532852067956322315,
-    0.19774706610509886464, 0.20018397469191127727, 0.20263943909370901930, 0.20511365629383770880,
-    0.20760682772422204205, 0.21011915938898825914, 0.21265086199297827522, 0.21520215107537867786,
-    0.21777324714870053264, 0.22036437584335949720, 0.22297576805812018050, 0.22560766011668406495,
-    0.22826029393071670664, 0.23093391716962742173, 0.23362878343743333945, 0.23634515245705964715,
-    0.23908329026244917002, 0.24184346939887722761, 0.24462596913189210901, 0.24743107566532763894,
-    0.25025908236886230967, 0.25311029001562948171, 0.25598500703041538015, 0.25888354974901621678,
-    0.26180624268936295243, 0.26475341883506220209, 0.26772541993204481808, 0.27072259679906003167,
-    0.27374530965280298302, 0.27679392844851734458, 0.27986883323697289920, 0.28297041453878076010,
-    0.28609907373707684673, 0.28925522348967773308, 0.29243928816189258772, 0.29565170428126120948,
-    0.29889292101558177099, 0.30216340067569352897, 0.30546361924459023541, 0.30879406693456016794,
-    0.31215524877417956945, 0.31554768522712893632, 0.31897191284495723773, 0.32242848495608914289,
-    0.32591797239355619822, 0.32944096426413633091, 0.33299806876180896713, 0.33658991402867758144,
-    0.34021714906678004560, 0.34388044470450243010, 0.34758049462163698567, 0.35131801643748334681,
-    0.35509375286678745925, 0.35890847294874976196, 0.36276297335481777335, 0.36665807978151414890,
-    0.37059464843514599421, 0.37457356761590215193, 0.37859575940958081092, 0.38266218149600982112,
-    0.38677382908413768115, 0.39093173698479710717, 0.39513698183329015336, 0.39939068447523107877,
-    0.40369401253053026739, 0.40804818315203238238, 0.41245446599716116772, 0.41691418643300289465,
-    0.42142872899761659635, 0.42599954114303435739, 0.43062813728845883923, 0.43531610321563659758,
-    0.44006510084235387501, 0.44487687341454851593, 0.44975325116275498919, 0.45469615747461548049,
-    0.45970761564213768669, 0.46478975625042618067, 0.46994482528395999841, 0.47517519303737738299,
-    0.48048336393045423016, 0.48587198734188493564, 0.49134386959403255500, 0.49690198724154955294,
-    0.50254950184134769289, 0.50828977641064283495, 0.51412639381474855788, 0.52006317736823356823,
-    0.52610421398361972602, 0.53225388026304326945, 0.53851687200286186590, 0.54489823767243963663,
-    0.55140341654064131685, 0.55803828226258748140, 0.56480919291240022434, 0.57172304866482579008,
-    0.57878735860284503057, 0.58601031847726802755, 0.59340090169173341521, 0.60096896636523224742,
-    0.60872538207962206507, 0.61668218091520762326, 0.62485273870366592605, 0.63325199421436607968,
-    0.64189671642726607018, 0.65080583341457104881, 0.66000084107899974178, 0.66950631673192477684,
-    0.67935057226476538741, 0.68956649611707798890, 0.70019265508278816709, 0.71127476080507597882,
-    0.72286765959357200702, 0.73503809243142351530, 0.74786862198519510742, 0.76146338884989624862,
-    0.77595685204011559675, 0.79152763697249565519, 0.80842165152300838005, 0.82699329664305033399,
-    0.84778550062398962096, 0.87170433238120363669, 0.90046992992574643800, 0.93814368086217467916,
-    1
-};
-
-template<class RealType = double>
-struct unit_exponential_distribution
-{
-    template<class Engine>
-    RealType operator()(Engine& eng) {
-        const double * const table_x = exponential_table<double>::table_x;
-        const double * const table_y = exponential_table<double>::table_y;
-        RealType shift(0);
-        for(;;) {
-            std::pair<RealType, int> vals = generate_int_float_pair<RealType, 8>(eng);
-            int i = vals.second;
-            RealType x = vals.first * RealType(table_x[i]);
-            if(x < RealType(table_x[i + 1])) return shift + x;
-            // For i=0 we need to generate from the tail, but because this is an exponential
-            // distribution, the tail looks exactly like the body, so we can simply repeat with a
-            // shift:
-            if (i == 0) shift += RealType(table_x[1]);
-            else {
-                RealType y01 = uniform_01<RealType>()(eng);
-                RealType y = RealType(table_y[i]) + y01 * RealType(table_y[i+1] - table_y[i]);
-
-                // All we care about is whether these are < or > 0; these values are equal to
-                // (lbound) or proportional to (ubound) `y` minus the lower/upper bound.
-                RealType y_above_ubound = RealType(table_x[i] - table_x[i+1]) * y01 - (RealType(table_x[i]) - x),
-                         y_above_lbound = y - (RealType(table_y[i+1]) + (RealType(table_x[i+1]) - x) * RealType(table_y[i+1]));
-
-                if (y_above_ubound < 0 // if above the upper bound reject immediately
-                        &&
-                        (
-                         y_above_lbound < 0 // If below the lower bound accept immediately
-                         ||
-                         y < f(x) // Otherwise it's between the bounds and we need a full check
-                        )
-                   ) {
-                    return x + shift;
-                }
-            }
-        }
-    }
-    static RealType f(RealType x) {
-        using std::exp;
-        return exp(-x);
-    }
-};
-
-} // namespace detail
-
-
-/**
- * The exponential distribution is a model of \random_distribution with
- * a single parameter lambda.
- *
- * It has \f$\displaystyle p(x) = \lambda e^{-\lambda x}\f$
- *
- * The implementation uses the "ziggurat" algorithm, as described in
- *
- *  @blockquote
- *  "The Ziggurat Method for Generating Random Variables",
- *  George Marsaglia and Wai Wan Tsang, Journal of Statistical Software
- *  Volume 5, Number 8 (2000), 1-7.
- *  @endblockquote
- */
-template<class RealType = double>
-class exponential_distribution
-{
-public:
-    typedef RealType input_type;
-    typedef RealType result_type;
-
-    class param_type
-    {
-    public:
-
-        typedef exponential_distribution distribution_type;
-
-        /**
-         * Constructs parameters with a given lambda.
-         *
-         * Requires: lambda > 0
-         */
-        param_type(RealType lambda_arg = RealType(1.0))
-          : _lambda(lambda_arg) { BOOST_ASSERT(_lambda > RealType(0)); }
-
-        /** Returns the lambda parameter of the distribution. */
-        RealType lambda() const { return _lambda; }
-
-        /** Writes the parameters to a @c std::ostream. */
-        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
-        {
-            os << parm._lambda;
-            return os;
-        }
-        
-        /** Reads the parameters from a @c std::istream. */
-        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
-        {
-            is >> parm._lambda;
-            return is;
-        }
-
-        /** Returns true if the two sets of parameters are equal. */
-        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        { return lhs._lambda == rhs._lambda; }
-
-        /** Returns true if the two sets of parameters are different. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-
-    private:
-        RealType _lambda;
-    };
-
-    /**
-     * Constructs an exponential_distribution with a given lambda.
-     *
-     * Requires: lambda > 0
-     */
-    explicit exponential_distribution(RealType lambda_arg = RealType(1.0))
-      : _lambda(lambda_arg) { BOOST_ASSERT(_lambda > RealType(0)); }
-
-    /**
-     * Constructs an exponential_distribution from its parameters
-     */
-    explicit exponential_distribution(const param_type& parm)
-      : _lambda(parm.lambda()) {}
-
-    // compiler-generated copy ctor and assignment operator are fine
-
-    /** Returns the lambda parameter of the distribution. */
-    RealType lambda() const { return _lambda; }
-
-    /** Returns the smallest value that the distribution can produce. */
-    RealType min BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    { return RealType(0); }
-    /** 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(_lambda); }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm) { _lambda = parm.lambda(); }
-
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { }
-
-    /**
-     * Returns a random variate distributed according to the
-     * exponential distribution.
-     */
-    template<class Engine>
-    result_type operator()(Engine& eng) const
-    { 
-        detail::unit_exponential_distribution<RealType> impl;
-        return impl(eng) / _lambda;
-    }
-
-    /**
-     * Returns a random variate distributed according to the exponential
-     * distribution with parameters specified by param.
-     */
-    template<class Engine>
-    result_type operator()(Engine& eng, const param_type& parm) const
-    { 
-        return exponential_distribution(parm)(eng);
-    }
-
-    /** Writes the distribution to a std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, exponential_distribution, ed)
-    {
-        os << ed._lambda;
-        return os;
-    }
-
-    /** Reads the distribution from a std::istream. */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, exponential_distribution, ed)
-    {
-        is >> ed._lambda;
-        return is;
-    }
-
-    /**
-     * Returns true iff the two distributions will produce identical
-     * sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(exponential_distribution, lhs, rhs)
-    { return lhs._lambda == rhs._lambda; }
-    
-    /**
-     * Returns true iff the two distributions will produce different
-     * sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(exponential_distribution)
-
-private:
-    result_type _lambda;
-};
-
-} // namespace random
-
-using random::exponential_distribution;
-
-} // namespace boost
-
-#endif // BOOST_RANDOM_EXPONENTIAL_DISTRIBUTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/extreme_value_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/extreme_value_distribution.hpp
deleted file mode 100644
index 419c3da651d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/extreme_value_distribution.hpp
+++ /dev/null
@@ -1,177 +0,0 @@
-/* boost random/extreme_value_distribution.hpp header file
- *
- * Copyright Steven Watanabe 2010
- * 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_EXTREME_VALUE_DISTRIBUTION_HPP
-#define BOOST_RANDOM_EXTREME_VALUE_DISTRIBUTION_HPP
-
-#include <boost/config/no_tr1/cmath.hpp>
-#include <iosfwd>
-#include <istream>
-#include <boost/config.hpp>
-#include <boost/limits.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/uniform_01.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * The extreme value distribution is a real valued distribution with two
- * parameters a and b.
- *
- * It has \f$\displaystyle p(x) = \frac{1}{b}e^{\frac{a-x}{b} - e^\frac{a-x}{b}}\f$.
- */
-template<class RealType = double>
-class extreme_value_distribution {
-public:
-    typedef RealType result_type;
-    typedef RealType input_type;
-
-    class param_type {
-    public:
-        typedef extreme_value_distribution distribution_type;
-
-        /**
-         * Constructs a @c param_type from the "a" and "b" parameters
-         * of the distribution.
-         *
-         * Requires: b > 0
-         */
-        explicit param_type(RealType a_arg = 1.0, RealType b_arg = 1.0)
-          : _a(a_arg), _b(b_arg)
-        {}
-
-        /** Returns the "a" parameter of the distribtuion. */
-        RealType a() const { return _a; }
-        /** Returns the "b" parameter of the distribution. */
-        RealType b() const { return _b; }
-
-        /** Writes a @c param_type to a @c std::ostream. */
-        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
-        { os << parm._a << ' ' << parm._b; return os; }
-
-        /** Reads a @c param_type from a @c std::istream. */
-        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
-        { is >> parm._a >> std::ws >> parm._b; return is; }
-
-        /** Returns true if the two sets of parameters are the same. */
-        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        { return lhs._a == rhs._a && lhs._b == rhs._b; }
-        
-        /** Returns true if the two sets of parameters are the different. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-
-    private:
-        RealType _a;
-        RealType _b;
-    };
-
-    /**
-     * Constructs an @c extreme_value_distribution from its "a" and "b" parameters.
-     *
-     * Requires: b > 0
-     */
-    explicit extreme_value_distribution(RealType a_arg = 1.0, RealType b_arg = 1.0)
-      : _a(a_arg), _b(b_arg)
-    {}
-    /** Constructs an @c extreme_value_distribution from its parameters. */
-    explicit extreme_value_distribution(const param_type& parm)
-      : _a(parm.a()), _b(parm.b())
-    {}
-
-    /**
-     * Returns a random variate distributed according to the
-     * @c extreme_value_distribution.
-     */
-    template<class URNG>
-    RealType operator()(URNG& urng) const
-    {
-        using std::log;
-        return _a - log(-log(uniform_01<RealType>()(urng))) * _b;
-    }
-
-    /**
-     * Returns a random variate distributed accordint to the extreme
-     * value distribution with parameters specified by @c param.
-     */
-    template<class URNG>
-    RealType operator()(URNG& urng, const param_type& parm) const
-    {
-        return extreme_value_distribution(parm)(urng);
-    }
-
-    /** Returns the "a" parameter of the distribution. */
-    RealType a() const { return _a; }
-    /** Returns the "b" parameter of the distribution. */
-    RealType b() const { return _b; }
-
-    /** 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(_a, _b); }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        _a = parm.a();
-        _b = parm.b();
-    }
-
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { }
-
-    /** Writes an @c extreme_value_distribution to a @c std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, extreme_value_distribution, wd)
-    {
-        os << wd.param();
-        return os;
-    }
-
-    /** Reads an @c extreme_value_distribution from a @c std::istream. */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, extreme_value_distribution, wd)
-    {
-        param_type parm;
-        if(is >> parm) {
-            wd.param(parm);
-        }
-        return is;
-    }
-
-    /**
-     * Returns true if the two instances of @c extreme_value_distribution will
-     * return identical sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(extreme_value_distribution, lhs, rhs)
-    { return lhs._a == rhs._a && lhs._b == rhs._b; }
-    
-    /**
-     * Returns true if the two instances of @c extreme_value_distribution will
-     * return different sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(extreme_value_distribution)
-
-private:
-    RealType _a;
-    RealType _b;
-};
-
-} // namespace random
-} // namespace boost
-
-#endif // BOOST_RANDOM_EXTREME_VALUE_DISTRIBUTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/fisher_f_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/fisher_f_distribution.hpp
deleted file mode 100644
index cdf14da8f6c..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/fisher_f_distribution.hpp
+++ /dev/null
@@ -1,183 +0,0 @@
-/* boost random/fisher_f_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_FISHER_F_DISTRIBUTION_HPP
-#define BOOST_RANDOM_FISHER_F_DISTRIBUTION_HPP
-
-#include <iosfwd>
-#include <istream>
-#include <boost/config.hpp>
-#include <boost/limits.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/chi_squared_distribution.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * The Fisher F distribution is a real valued distribution with two
- * parameters m and n.
- *
- * It has \f$\displaystyle p(x) =
- *   \frac{\Gamma((m+n)/2)}{\Gamma(m/2)\Gamma(n/2)}
- *   \left(\frac{m}{n}\right)^{m/2}
- *   x^{(m/2)-1} \left(1+\frac{mx}{n}\right)^{-(m+n)/2}
- * \f$.
- */
-template<class RealType = double>
-class fisher_f_distribution {
-public:
-    typedef RealType result_type;
-    typedef RealType input_type;
-
-    class param_type {
-    public:
-        typedef fisher_f_distribution distribution_type;
-
-        /**
-         * Constructs a @c param_type from the "m" and "n" parameters
-         * of the distribution.
-         *
-         * Requires: m > 0 and n > 0
-         */
-        explicit param_type(RealType m_arg = RealType(1.0),
-                            RealType n_arg = RealType(1.0))
-          : _m(m_arg), _n(n_arg)
-        {}
-
-        /** Returns the "m" parameter of the distribtuion. */
-        RealType m() const { return _m; }
-        /** Returns the "n" parameter 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._m << ' ' << 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._m >> std::ws >> 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._m == rhs._m && lhs._n == rhs._n; }
-        
-        /** Returns true if the two sets of parameters are the different. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-
-    private:
-        RealType _m;
-        RealType _n;
-    };
-
-    /**
-     * Constructs a @c fisher_f_distribution from its "m" and "n" parameters.
-     *
-     * Requires: m > 0 and n > 0
-     */
-    explicit fisher_f_distribution(RealType m_arg = RealType(1.0),
-                                   RealType n_arg = RealType(1.0))
-      : _impl_m(m_arg), _impl_n(n_arg)
-    {}
-    /** Constructs an @c fisher_f_distribution from its parameters. */
-    explicit fisher_f_distribution(const param_type& parm)
-      : _impl_m(parm.m()), _impl_n(parm.n())
-    {}
-
-    /**
-     * Returns a random variate distributed according to the
-     * F distribution.
-     */
-    template<class URNG>
-    RealType operator()(URNG& urng)
-    {
-        return (_impl_m(urng) * n()) / (_impl_n(urng) * m());
-    }
-
-    /**
-     * Returns a random variate distributed according to the
-     * F distribution with parameters specified by @c param.
-     */
-    template<class URNG>
-    RealType operator()(URNG& urng, const param_type& parm) const
-    {
-        return fisher_f_distribution(parm)(urng);
-    }
-
-    /** Returns the "m" parameter of the distribution. */
-    RealType m() const { return _impl_m.n(); }
-    /** Returns the "n" parameter of the distribution. */
-    RealType n() const { return _impl_n.n(); }
-
-    /** Returns the smallest value that the distribution can produce. */
-    RealType min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return 0; }
-    /** 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(m(), n()); }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        typedef chi_squared_distribution<RealType> impl_type;
-        typename impl_type::param_type m_param(parm.m());
-        _impl_m.param(m_param);
-        typename impl_type::param_type n_param(parm.n());
-        _impl_n.param(n_param);
-    }
-
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { }
-
-    /** Writes an @c fisher_f_distribution to a @c std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, fisher_f_distribution, fd)
-    {
-        os << fd.param();
-        return os;
-    }
-
-    /** Reads an @c fisher_f_distribution from a @c std::istream. */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, fisher_f_distribution, fd)
-    {
-        param_type parm;
-        if(is >> parm) {
-            fd.param(parm);
-        }
-        return is;
-    }
-
-    /**
-     * Returns true if the two instances of @c fisher_f_distribution will
-     * return identical sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(fisher_f_distribution, lhs, rhs)
-    { return lhs._impl_m == rhs._impl_m && lhs._impl_n == rhs._impl_n; }
-    
-    /**
-     * Returns true if the two instances of @c fisher_f_distribution will
-     * return different sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(fisher_f_distribution)
-
-private:
-    chi_squared_distribution<RealType> _impl_m;
-    chi_squared_distribution<RealType> _impl_n;
-};
-
-} // namespace random
-} // namespace boost
-
-#endif // BOOST_RANDOM_EXTREME_VALUE_DISTRIBUTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/gamma_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/gamma_distribution.hpp
deleted file mode 100644
index c9bda4ca9d3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/gamma_distribution.hpp
+++ /dev/null
@@ -1,292 +0,0 @@
-/* boost random/gamma_distribution.hpp header file
- *
- * Copyright Jens Maurer 2002
- * Copyright Steven Watanabe 2010
- * 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_GAMMA_DISTRIBUTION_HPP
-#define BOOST_RANDOM_GAMMA_DISTRIBUTION_HPP
-
-#include <boost/config/no_tr1/cmath.hpp>
-#include <istream>
-#include <iosfwd>
-#include <boost/assert.hpp>
-#include <boost/limits.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/exponential_distribution.hpp>
-
-namespace boost {
-namespace random {
-
-// The algorithm is taken from Knuth
-
-/**
- * The gamma distribution is a continuous distribution with two
- * parameters alpha and beta.  It produces values > 0.
- *
- * It has
- * \f$\displaystyle p(x) = x^{\alpha-1}\frac{e^{-x/\beta}}{\beta^\alpha\Gamma(\alpha)}\f$.
- */
-template<class RealType = double>
-class gamma_distribution
-{
-public:
-    typedef RealType input_type;
-    typedef RealType result_type;
-
-    class param_type
-    {
-    public:
-        typedef gamma_distribution distribution_type;
-
-        /**
-         * Constructs a @c param_type object from the "alpha" and "beta"
-         * parameters.
-         *
-         * Requires: alpha > 0 && beta > 0
-         */
-        param_type(const RealType& alpha_arg = RealType(1.0),
-                   const RealType& beta_arg = RealType(1.0))
-          : _alpha(alpha_arg), _beta(beta_arg)
-        {
-        }
-
-        /** Returns the "alpha" parameter of the distribution. */
-        RealType alpha() const { return _alpha; }
-        /** Returns the "beta" parameter of the distribution. */
-        RealType beta() const { return _beta; }
-
-#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
-        /** Writes the parameters to a @c std::ostream. */
-        template<class CharT, class Traits>
-        friend std::basic_ostream<CharT, Traits>&
-        operator<<(std::basic_ostream<CharT, Traits>& os,
-                   const param_type& parm)
-        {
-            os << parm._alpha << ' ' << parm._beta;
-            return os;
-        }
-        
-        /** Reads the parameters from a @c std::istream. */
-        template<class CharT, class Traits>
-        friend std::basic_istream<CharT, Traits>&
-        operator>>(std::basic_istream<CharT, Traits>& is, param_type& parm)
-        {
-            is >> parm._alpha >> std::ws >> parm._beta;
-            return is;
-        }
-#endif
-
-        /** Returns true if the two sets of parameters are the same. */
-        friend bool operator==(const param_type& lhs, const param_type& rhs)
-        {
-            return lhs._alpha == rhs._alpha && lhs._beta == rhs._beta;
-        }
-        /** Returns true if the two sets fo parameters are different. */
-        friend bool operator!=(const param_type& lhs, const param_type& rhs)
-        {
-            return !(lhs == rhs);
-        }
-    private:
-        RealType _alpha;
-        RealType _beta;
-    };
-
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-    BOOST_STATIC_ASSERT(!std::numeric_limits<RealType>::is_integer);
-#endif
-
-    /**
-     * Creates a new gamma_distribution with parameters "alpha" and "beta".
-     *
-     * Requires: alpha > 0 && beta > 0
-     */
-    explicit gamma_distribution(const result_type& alpha_arg = result_type(1.0),
-                                const result_type& beta_arg = result_type(1.0))
-      : _exp(result_type(1)), _alpha(alpha_arg), _beta(beta_arg)
-    {
-        BOOST_ASSERT(_alpha > result_type(0));
-        BOOST_ASSERT(_beta > result_type(0));
-        init();
-    }
-
-    /** Constructs a @c gamma_distribution from its parameters. */
-    explicit gamma_distribution(const param_type& parm)
-      : _exp(result_type(1)), _alpha(parm.alpha()), _beta(parm.beta())
-    {
-        init();
-    }
-
-    // compiler-generated copy ctor and assignment operator are fine
-
-    /** Returns the "alpha" paramter of the distribution. */
-    RealType alpha() const { return _alpha; }
-    /** Returns the "beta" parameter of the distribution. */
-    RealType beta() const { return _beta; }
-    /** Returns the smallest value that the distribution can produce. */
-    RealType min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return 0; }
-    /* 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(_alpha, _beta); }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        _alpha = parm.alpha();
-        _beta = parm.beta();
-        init();
-    }
-    
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { _exp.reset(); }
-
-    /**
-     * Returns a random variate distributed according to
-     * the gamma distribution.
-     */
-    template<class Engine>
-    result_type operator()(Engine& eng)
-    {
-#ifndef BOOST_NO_STDC_NAMESPACE
-        // allow for Koenig lookup
-        using std::tan; using std::sqrt; using std::exp; using std::log;
-        using std::pow;
-#endif
-        if(_alpha == result_type(1)) {
-            return _exp(eng) * _beta;
-        } else if(_alpha > result_type(1)) {
-            // Can we have a boost::mathconst please?
-            const result_type pi = result_type(3.14159265358979323846);
-            for(;;) {
-                result_type y = tan(pi * uniform_01<RealType>()(eng));
-                result_type x = sqrt(result_type(2)*_alpha-result_type(1))*y
-                    + _alpha-result_type(1);
-                if(x <= result_type(0))
-                    continue;
-                if(uniform_01<RealType>()(eng) >
-                    (result_type(1)+y*y) * exp((_alpha-result_type(1))
-                                               *log(x/(_alpha-result_type(1)))
-                                               - sqrt(result_type(2)*_alpha
-                                                      -result_type(1))*y))
-                    continue;
-                return x * _beta;
-            }
-        } else /* alpha < 1.0 */ {
-            for(;;) {
-                result_type u = uniform_01<RealType>()(eng);
-                result_type y = _exp(eng);
-                result_type x, q;
-                if(u < _p) {
-                    x = exp(-y/_alpha);
-                    q = _p*exp(-x);
-                } else {
-                    x = result_type(1)+y;
-                    q = _p + (result_type(1)-_p) * pow(x,_alpha-result_type(1));
-                }
-                if(u >= q)
-                    continue;
-                return x * _beta;
-            }
-        }
-    }
-
-    template<class URNG>
-    RealType operator()(URNG& urng, const param_type& parm) const
-    {
-        return gamma_distribution(parm)(urng);
-    }
-
-#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
-    /** Writes a @c gamma_distribution to a @c std::ostream. */
-    template<class CharT, class Traits>
-    friend std::basic_ostream<CharT,Traits>&
-    operator<<(std::basic_ostream<CharT,Traits>& os,
-               const gamma_distribution& gd)
-    {
-        os << gd.param();
-        return os;
-    }
-    
-    /** Reads a @c gamma_distribution from a @c std::istream. */
-    template<class CharT, class Traits>
-    friend std::basic_istream<CharT,Traits>&
-    operator>>(std::basic_istream<CharT,Traits>& is, gamma_distribution& gd)
-    {
-        gd.read(is);
-        return is;
-    }
-#endif
-
-    /**
-     * Returns true if the two distributions will produce identical
-     * sequences of random variates given equal generators.
-     */
-    friend bool operator==(const gamma_distribution& lhs,
-                           const gamma_distribution& rhs)
-    {
-        return lhs._alpha == rhs._alpha
-            && lhs._beta == rhs._beta
-            && lhs._exp == rhs._exp;
-    }
-
-    /**
-     * Returns true if the two distributions can produce different
-     * sequences of random variates, given equal generators.
-     */
-    friend bool operator!=(const gamma_distribution& lhs,
-                           const gamma_distribution& rhs)
-    {
-        return !(lhs == rhs);
-    }
-
-private:
-    /// \cond hide_private_members
-
-    template<class CharT, class Traits>
-    void read(std::basic_istream<CharT, Traits>& is)
-    {
-        param_type parm;
-        if(is >> parm) {
-            param(parm);
-        }
-    }
-
-    void init()
-    {
-#ifndef BOOST_NO_STDC_NAMESPACE
-        // allow for Koenig lookup
-        using std::exp;
-#endif
-        _p = exp(result_type(1)) / (_alpha + exp(result_type(1)));
-    }
-    /// \endcond
-
-    exponential_distribution<RealType> _exp;
-    result_type _alpha;
-    result_type _beta;
-    // some data precomputed from the parameters
-    result_type _p;
-};
-
-
-} // namespace random
-
-using random::gamma_distribution;
-
-} // namespace boost
-
-#endif // BOOST_RANDOM_GAMMA_DISTRIBUTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/generate_canonical.hpp b/contrib/libboost/boost_1_65_0/boost/random/generate_canonical.hpp
deleted file mode 100644
index 112784742b1..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/generate_canonical.hpp
+++ /dev/null
@@ -1,96 +0,0 @@
-/* boost random/generate_canonical.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_GENERATE_CANONICAL_HPP
-#define BOOST_RANDOM_GENERATE_CANONICAL_HPP
-
-#include <algorithm>
-#include <boost/assert.hpp>
-#include <boost/config/no_tr1/cmath.hpp>
-#include <boost/limits.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/random/detail/signed_unsigned_tools.hpp>
-#include <boost/random/detail/generator_bits.hpp>
-
-namespace boost {
-namespace random {
-
-namespace detail {
-
-template<class RealType, std::size_t bits, class URNG>
-RealType generate_canonical_impl(URNG& g, boost::mpl::true_ /*is_integral*/)
-{
-    using std::pow;
-    typedef typename URNG::result_type base_result;
-    std::size_t digits = std::numeric_limits<RealType>::digits;
-    RealType R = RealType((g.max)()) - RealType((g.min)()) + 1;
-    RealType mult = R;
-    RealType limit =
-        pow(RealType(2),
-            RealType((std::min)(static_cast<std::size_t>(bits), digits)));
-    RealType S = RealType(detail::subtract<base_result>()(g(), (g.min)()));
-    while(mult < limit) {
-        RealType inc = RealType(detail::subtract<base_result>()(g(), (g.min)()));
-        S += inc * mult;
-        mult *= R;
-    }
-    return S / mult;
-}
-
-template<class RealType, std::size_t bits, class URNG>
-RealType generate_canonical_impl(URNG& g, boost::mpl::false_ /*is_integral*/)
-{
-    using std::pow;
-    using std::floor;
-    BOOST_ASSERT((g.min)() == 0);
-    BOOST_ASSERT((g.max)() == 1);
-    std::size_t digits = std::numeric_limits<RealType>::digits;
-    std::size_t engine_bits = detail::generator_bits<URNG>::value();
-    std::size_t b = (std::min)(bits, digits);
-    RealType R = pow(RealType(2), RealType(engine_bits));
-    RealType mult = R;
-    RealType limit = pow(RealType(2), RealType(b));
-    RealType S = RealType(g() - (g.min)());
-    while(mult < limit) {
-        RealType inc(floor((RealType(g()) - RealType((g.min)())) * R));
-        S += inc * mult;
-        mult *= R;
-    }
-    return S / mult;
-}
-
-}
-
-/**
- * Returns a value uniformly distributed in the range [0, 1)
- * with at least @c bits random bits.
- */
-template<class RealType, std::size_t bits, class URNG>
-RealType generate_canonical(URNG& g)
-{
-    RealType result = detail::generate_canonical_impl<RealType, bits>(
-        g, boost::random::traits::is_integral<typename URNG::result_type>());
-    BOOST_ASSERT(result >= 0);
-    BOOST_ASSERT(result <= 1);
-    if(result == 1) {
-        result -= std::numeric_limits<RealType>::epsilon() / 2;
-        BOOST_ASSERT(result != 1);
-    }
-    return result;
-}
-
-} // namespace random
-} // namespace boost
-
-#endif // BOOST_RANDOM_GENERATE_CANONICAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/geometric_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/geometric_distribution.hpp
deleted file mode 100644
index 90374cff71b..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/geometric_distribution.hpp
+++ /dev/null
@@ -1,267 +0,0 @@
-/* boost random/geometric_distribution.hpp header file
- *
- * Copyright Jens Maurer 2000-2001
- * 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$
- *
- * Revision history
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_GEOMETRIC_DISTRIBUTION_HPP
-#define BOOST_RANDOM_GEOMETRIC_DISTRIBUTION_HPP
-
-#include <boost/config/no_tr1/cmath.hpp>          // std::log
-#include <iosfwd>
-#include <ios>
-#include <boost/assert.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/uniform_01.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * An instantiation of the class template @c geometric_distribution models
- * a \random_distribution.  The distribution produces positive
- * integers which are the number of bernoulli trials
- * with probability @c p required to get one that fails.
- *
- * For the geometric distribution, \f$p(i) = p(1-p)^{i}\f$.
- *
- * @xmlwarning
- * This distribution has been updated to match the C++ standard.
- * Its behavior has changed from the original
- * boost::geometric_distribution.  A backwards compatible
- * wrapper is provided in namespace boost.
- * @endxmlwarning
- */
-template<class IntType = int, class RealType = double>
-class geometric_distribution
-{
-public:
-    typedef RealType input_type;
-    typedef IntType result_type;
-
-    class param_type
-    {
-    public:
-
-        typedef geometric_distribution distribution_type;
-
-        /** Constructs the parameters with p. */
-        explicit param_type(RealType p_arg = RealType(0.5))
-          : _p(p_arg)
-        {
-            BOOST_ASSERT(RealType(0) < _p && _p < RealType(1));
-        }
-
-        /** Returns the p parameter of the distribution. */
-        RealType p() const { return _p; }
-
-        /** Writes the parameters to a std::ostream. */
-        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
-        {
-            os << parm._p;
-            return os;
-        }
-
-        /** Reads the parameters from a std::istream. */
-        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
-        {
-            double p_in;
-            if(is >> p_in) {
-                if(p_in > RealType(0) && p_in < RealType(1)) {
-                    parm._p = p_in;
-                } else {
-                    is.setstate(std::ios_base::failbit);
-                }
-            }
-            return is;
-        }
-
-        /** Returns true if the two sets of parameters are equal. */
-        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        { return lhs._p == rhs._p; }
-
-        /** Returns true if the two sets of parameters are different. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-
-
-    private:
-        RealType _p;
-    };
-
-    /**
-     * Contructs a new geometric_distribution with the paramter @c p.
-     *
-     * Requires: 0 < p < 1
-     */
-    explicit geometric_distribution(const RealType& p_arg = RealType(0.5))
-      : _p(p_arg)
-    {
-        BOOST_ASSERT(RealType(0) < _p && _p < RealType(1));
-        init();
-    }
-
-    /** Constructs a new geometric_distribution from its parameters. */
-    explicit geometric_distribution(const param_type& parm)
-      : _p(parm.p())
-    {
-        init();
-    }
-
-    // compiler-generated copy ctor and assignment operator are fine
-
-    /** Returns: the distribution parameter @c p  */
-    RealType p() const { return _p; }
-
-    /** Returns the smallest value that the distribution can produce. */
-    IntType min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return IntType(0); }
-
-    /** Returns the largest value that the distribution can produce. */
-    IntType max BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    { return (std::numeric_limits<IntType>::max)(); }
-
-    /** Returns the parameters of the distribution. */
-    param_type param() const { return param_type(_p); }
-
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        _p = parm.p();
-        init();
-    }
-  
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { }
-
-    /**
-     * Returns a random variate distributed according to the
-     * geometric_distribution.
-     */
-    template<class Engine>
-    result_type operator()(Engine& eng) const
-    {
-        using std::log;
-        using std::floor;
-        RealType x = RealType(1) - boost::uniform_01<RealType>()(eng);
-        return IntType(floor(log(x) / _log_1mp));
-    }
-
-    /**
-     * Returns a random variate distributed according to the
-     * geometric distribution with parameters specified by param.
-     */
-    template<class Engine>
-    result_type operator()(Engine& eng, const param_type& parm) const
-    { return geometric_distribution(parm)(eng); }
-
-    /** Writes the distribution to a @c std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, geometric_distribution, gd)
-    {
-        os << gd._p;
-        return os;
-    }
-
-    /** Reads the distribution from a @c std::istream. */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, geometric_distribution, gd)
-    {
-        param_type parm;
-        if(is >> parm) {
-            gd.param(parm);
-        }
-        return is;
-    }
-
-    /**
-     * Returns true if the two distributions will produce identical
-     * sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(geometric_distribution, lhs, rhs)
-    { return lhs._p == rhs._p; }
-
-    /**
-     * Returns true if the two distributions may produce different
-     * sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(geometric_distribution)
-
-private:
-
-    /// \cond show_private
-
-    void init()
-    {
-        using std::log;
-        _log_1mp = log(1 - _p);
-    }
-
-    RealType _p;
-    RealType _log_1mp;
-
-    /// \endcond
-};
-
-} // namespace random
-
-/// \cond show_deprecated
-
-/**
- * Provided for backwards compatibility.  This class is
- * deprecated.  It provides the old behavior of geometric_distribution
- * with \f$p(i) = (1-p) p^{i-1}\f$.
- */
-template<class IntType = int, class RealType = double>
-class geometric_distribution
-{
-public:
-    typedef RealType input_type;
-    typedef IntType result_type;
-
-    explicit geometric_distribution(RealType p_arg = RealType(0.5))
-      : _impl(1 - p_arg) {}
-
-    RealType p() const { return 1 - _impl.p(); }
-
-    void reset() {}
-
-    template<class Engine>
-    IntType operator()(Engine& eng) const { return _impl(eng) + IntType(1); }
-
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, geometric_distribution, gd)
-    {
-        os << gd.p();
-        return os;
-    }
-
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, geometric_distribution, gd)
-    {
-        RealType val;
-        if(is >> val) {
-            typename impl_type::param_type impl_param(1 - val);
-            gd._impl.param(impl_param);
-        }
-        return is;
-    }
-
-private:
-    typedef random::geometric_distribution<IntType, RealType> impl_type;
-    impl_type _impl;
-};
-
-/// \endcond
-
-} // namespace boost
-
-#endif // BOOST_RANDOM_GEOMETRIC_DISTRIBUTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/hyperexponential_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/hyperexponential_distribution.hpp
deleted file mode 100644
index 046d0fc4016..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/hyperexponential_distribution.hpp
+++ /dev/null
@@ -1,883 +0,0 @@
-/* boost random/hyperexponential_distribution.hpp header file
- *
- * Copyright Marco Guazzone 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 including documentation.
- *
- * Much of the code here taken by boost::math::hyperexponential_distribution.
- * To this end, we would like to thank Paul Bristow and John Maddock for their
- * valuable feedback.
- *
- * \author Marco Guazzone (marco.guazzone@gmail.com)
- */
-
-#ifndef BOOST_RANDOM_HYPEREXPONENTIAL_DISTRIBUTION_HPP
-#define BOOST_RANDOM_HYPEREXPONENTIAL_DISTRIBUTION_HPP
-
-
-#include <boost/config.hpp>
-#include <boost/math/special_functions/fpclassify.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/detail/vector_io.hpp>
-#include <boost/random/discrete_distribution.hpp>
-#include <boost/random/exponential_distribution.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/size.hpp>
-#include <boost/type_traits/has_pre_increment.hpp>
-#include <cassert>
-#include <cmath>
-#include <cstddef>
-#include <iterator>
-#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
-# include <initializer_list>
-#endif // BOOST_NO_CXX11_HDR_INITIALIZER_LIST
-#include <iostream>
-#include <limits>
-#include <numeric>
-#include <vector>
-
-
-namespace boost { namespace random {
-
-namespace hyperexp_detail {
-
-template <typename T>
-std::vector<T>& normalize(std::vector<T>& v)
-{
-    if (v.size() == 0)
-    {
-        return v;
-    }
-
-    const T sum = std::accumulate(v.begin(), v.end(), static_cast<T>(0));
-    T final_sum = 0;
-
-    const typename std::vector<T>::iterator end = --v.end();
-    for (typename std::vector<T>::iterator it = v.begin();
-         it != end;
-         ++it)
-    {
-        *it /= sum;
-        final_sum += *it;
-    }
-    *end = 1-final_sum; // avoids round off errors thus ensuring the probabilities really sum to 1
-
-    return v;
-}
-
-template <typename RealT>
-bool check_probabilities(std::vector<RealT> const& probabilities)
-{
-    const std::size_t n = probabilities.size();
-    RealT sum = 0;
-    for (std::size_t i = 0; i < n; ++i)
-    {
-        if (probabilities[i] < 0
-            || probabilities[i] > 1
-            || !(boost::math::isfinite)(probabilities[i]))
-        {
-            return false;
-        }
-        sum += probabilities[i];
-    }
-
-    //NOTE: the check below seems to fail on some architectures.
-    //      So we commented it.
-    //// - We try to keep phase probabilities correctly normalized in the distribution constructors
-    //// - However in practice we have to allow for a very slight divergence from a sum of exactly 1:
-    ////if (std::abs(sum-1) > (std::numeric_limits<RealT>::epsilon()*2))
-    //// This is from Knuth "The Art of Computer Programming: Vol.2, 3rd Ed", and can be used to
-    //// check is two numbers are approximately equal
-    //const RealT one = 1;
-    //const RealT tol = std::numeric_limits<RealT>::epsilon()*2.0;
-    //if (std::abs(sum-one) > (std::max(std::abs(sum), std::abs(one))*tol))
-    //{
-    //    return false;
-    //}
-
-    return true;
-}
-
-template <typename RealT>
-bool check_rates(std::vector<RealT> const& rates)
-{
-    const std::size_t n = rates.size();
-    for (std::size_t i = 0; i < n; ++i)
-    {
-        if (rates[i] <= 0
-            || !(boost::math::isfinite)(rates[i]))
-        {
-            return false;
-        }
-    }
-    return true;
-}
-
-template <typename RealT>
-bool check_params(std::vector<RealT> const& probabilities, std::vector<RealT> const& rates)
-{
-    if (probabilities.size() != rates.size())
-    {
-        return false;
-    }
-
-    return check_probabilities(probabilities)
-           && check_rates(rates);
-}
-
-} // Namespace hyperexp_detail
-
-
-/**
- * The hyperexponential distribution is a real-valued continuous distribution
- * with two parameters, the <em>phase probability vector</em> \c probs and the
- * <em>rate vector</em> \c rates.
- *
- * A \f$k\f$-phase hyperexponential distribution is a mixture of \f$k\f$
- * exponential distributions.
- * For this reason, it is also referred to as <em>mixed exponential
- * distribution</em> or <em>parallel \f$k\f$-phase exponential
- * distribution</em>.
- *
- * A \f$k\f$-phase hyperexponential distribution is characterized by two
- * parameters, namely a <em>phase probability vector</em> \f$\mathbf{\alpha}=(\alpha_1,\ldots,\alpha_k)\f$ and a <em>rate vector</em> \f$\mathbf{\lambda}=(\lambda_1,\ldots,\lambda_k)\f$.
- *
- * A \f$k\f$-phase hyperexponential distribution is frequently used in
- * <em>queueing theory</em> to model the distribution of the superposition of
- * \f$k\f$ independent events, like, for instance, the  service time distribution
- * of a queueing station with \f$k\f$ servers in parallel where the \f$i\f$-th
- * server is chosen with probability \f$\alpha_i\f$ and its service time
- * distribution is an exponential distribution with rate \f$\lambda_i\f$
- * (Allen,1990; Papadopolous et al.,1993; Trivedi,2002).
- *
- * For instance, CPUs service-time distribution in a computing system has often
- * been observed to possess such a distribution (Rosin,1965).
- * Also, the arrival of different types of customer to a single queueing station
- * is often modeled as a hyperexponential distribution (Papadopolous et al.,1993).
- * Similarly, if a product manufactured in several parallel assemply lines and
- * the outputs are merged, the failure density of the overall product is likely
- * to be hyperexponential (Trivedi,2002).
- *
- * Finally, since the hyperexponential distribution exhibits a high Coefficient
- * of Variation (CoV), that is a CoV > 1, it is especially suited to fit
- * empirical data with large CoV (Feitelson,2014; Wolski et al.,2013) and to
- * approximate <em>long-tail probability distributions</em> (Feldmann et al.,1998).
- *
- * See (Boost,2014) for more information and examples.
- *
- * A \f$k\f$-phase hyperexponential distribution has a probability density
- * function
- * \f[
- *  f(x) = \sum_{i=1}^k \alpha_i \lambda_i e^{-x\lambda_i}
- * \f]
- * where:
- * - \f$k\f$ is the <em>number of phases</em> and also the size of the input
- *   vector parameters,
- * - \f$\mathbf{\alpha}=(\alpha_1,\ldots,\alpha_k)\f$ is the <em>phase probability
- *   vector</em> parameter, and
- * - \f$\mathbf{\lambda}=(\lambda_1,\ldots,\lambda_k)\f$ is the <em>rate vector</em>
- *   parameter.
- * .
- *
- * Given a \f$k\f$-phase hyperexponential distribution with phase probability
- * vector \f$\mathbf{\alpha}\f$ and rate vector \f$\mathbf{\lambda}\f$, the
- * random variate generation algorithm consists of the following steps (Tyszer,1999):
- * -# Generate a random variable \f$U\f$ uniformly distribution on the interval \f$(0,1)\f$.
- * -# Use \f$U\f$ to select the appropriate \f$\lambda_i\f$ (e.g., the
- *  <em>alias method</em> can possibly be used for this step).
- * -# Generate an exponentially distributed random variable \f$X\f$ with rate parameter \f$\lambda_i\f$.
- * -# Return \f$X\f$.
- * .
- *
- * References:
- * -# A.O. Allen, <em>Probability, Statistics, and Queuing Theory with Computer Science Applications, Second Edition</em>, Academic Press, 1990.
- * -# Boost C++ Libraries, <em>Boost.Math / Statistical Distributions: Hyperexponential Distribution</em>, Online: http://www.boost.org/doc/libs/release/libs/math/doc/html/dist.html , 2014.
- * -# D.G. Feitelson, <em>Workload Modeling for Computer Systems Performance Evaluation</em>, Cambridge University Press, 2014
- * -# A. Feldmann and W. Whitt, <em>Fitting mixtures of exponentials to long-tail distributions to analyze network performance models</em>, Performance Evaluation 31(3-4):245, doi:10.1016/S0166-5316(97)00003-5, 1998.
- * -# H.T. Papadopolous, C. Heavey and J. Browne, <em>Queueing Theory in Manufacturing Systems Analysis and Design</em>, Chapman & Hall/CRC, 1993, p. 35.
- * -# R.F. Rosin, <em>Determining a computing center environment</em>, Communications of the ACM 8(7):463-468, 1965.
- * -# K.S. Trivedi, <em>Probability and Statistics with Reliability, Queueing, and Computer Science Applications</em>, John Wiley & Sons, Inc., 2002.
- * -# J. Tyszer, <em>Object-Oriented Computer Simulation of Discrete-Event Systems</em>, Springer, 1999.
- * -# Wikipedia, <em>Hyperexponential Distribution</em>, Online: http://en.wikipedia.org/wiki/Hyperexponential_distribution , 2014.
- * -# Wolfram Mathematica, <em>Hyperexponential Distribution</em>, Online: http://reference.wolfram.com/language/ref/HyperexponentialDistribution.html , 2014.
- * .
- *
- * \author Marco Guazzone (marco.guazzone@gmail.com)
- */
-template<class RealT = double>
-class hyperexponential_distribution
-{
-    public: typedef RealT result_type;
-    public: typedef RealT input_type;
-
-
-    /**
-     * The parameters of a hyperexponential distribution.
-     *
-     * Stores the <em>phase probability vector</em> and the <em>rate vector</em>
-     * of the hyperexponential distribution.
-     *
-     * \author Marco Guazzone (marco.guazzone@gmail.com)
-     */
-    public: class param_type
-    {
-        public: typedef hyperexponential_distribution distribution_type;
-
-        /**
-         * Constructs a \c param_type with the default parameters
-         * of the distribution.
-         */
-        public: param_type()
-        : probs_(1, 1),
-          rates_(1, 1)
-        {
-        }
-
-        /**
-         * Constructs a \c param_type from the <em>phase probability vector</em>
-         * and <em>rate vector</em> parameters of the distribution.
-         *
-         * The <em>phase probability vector</em> parameter is given by the range
-         * defined by [\a prob_first, \a prob_last) iterator pair, and the
-         * <em>rate vector</em> parameter is given by the range defined by
-         * [\a rate_first, \a rate_last) iterator pair.
-         *
-         * \tparam ProbIterT Must meet the requirements of \c InputIterator concept (ISO,2014,sec. 24.2.3 [input.iterators]).
-         * \tparam RateIterT Must meet the requirements of \c InputIterator concept (ISO,2014,sec. 24.2.3 [input.iterators]).
-         *
-         * \param prob_first The iterator to the beginning of the range of non-negative real elements representing the phase probabilities; if elements don't sum to 1, they are normalized.
-         * \param prob_last The iterator to the ending of the range of non-negative real elements representing the phase probabilities; if elements don't sum to 1, they are normalized.
-         * \param rate_first The iterator to the beginning of the range of non-negative real elements representing the rates.
-         * \param rate_last The iterator to the ending of the range of non-negative real elements representing the rates.
-         *
-         * References:
-         * -# ISO, <em>ISO/IEC 14882-2014: Information technology - Programming languages - C++</em>, 2014
-         * .
-         */
-        public: template <typename ProbIterT, typename RateIterT>
-                param_type(ProbIterT prob_first, ProbIterT prob_last,
-                           RateIterT rate_first, RateIterT rate_last)
-        : probs_(prob_first, prob_last),
-          rates_(rate_first, rate_last)
-        {
-            hyperexp_detail::normalize(probs_);
-
-            assert( hyperexp_detail::check_params(probs_, rates_) );
-        }
-
-        /**
-         * Constructs a \c param_type from the <em>phase probability vector</em>
-         * and <em>rate vector</em> parameters of the distribution.
-         *
-         * The <em>phase probability vector</em> parameter is given by the range
-         * defined by \a prob_range, and the <em>rate vector</em> parameter is
-         * given by the range defined by \a rate_range.
-         *
-         * \tparam ProbRangeT Must meet the requirements of <a href="boost:/libs/range/doc/html/range/concepts.html">Range</a> concept.
-         * \tparam RateRangeT Must meet the requirements of <a href="boost:/libs/range/doc/html/range/concepts.html">Range</a> concept.
-         *
-         * \param prob_range The range of non-negative real elements representing the phase probabilities; if elements don't sum to 1, they are normalized.
-         * \param rate_range The range of positive real elements representing the rates.
-         *
-         * \note
-         *  The final \c disable_if parameter is an implementation detail that
-         *  differentiates between this two argument constructor and the
-         *  iterator-based two argument constructor described below.
-         */
-        //  We SFINAE this out of existance if either argument type is
-        //  incrementable as in that case the type is probably an iterator:
-        public: template <typename ProbRangeT, typename RateRangeT>
-                param_type(ProbRangeT const& prob_range,
-                           RateRangeT const& rate_range,
-                           typename boost::disable_if_c<boost::has_pre_increment<ProbRangeT>::value || boost::has_pre_increment<RateRangeT>::value>::type* = 0)
-        : probs_(boost::begin(prob_range), boost::end(prob_range)),
-          rates_(boost::begin(rate_range), boost::end(rate_range))
-        {
-            hyperexp_detail::normalize(probs_);
-
-            assert( hyperexp_detail::check_params(probs_, rates_) );
-        }
-
-        /**
-         * Constructs a \c param_type from the <em>rate vector</em> parameter of
-         * the distribution and with equal phase probabilities.
-         *
-         * The <em>rate vector</em> parameter is given by the range defined by
-         * [\a rate_first, \a rate_last) iterator pair, and the <em>phase
-         * probability vector</em> parameter is set to the equal phase
-         * probabilities (i.e., to a vector of the same length \f$k\f$ of the
-         * <em>rate vector</em> and with each element set to \f$1.0/k\f$).
-         *
-         * \tparam RateIterT Must meet the requirements of \c InputIterator concept (ISO,2014,sec. 24.2.3 [input.iterators]).
-         * \tparam RateIterT2 Must meet the requirements of \c InputIterator concept (ISO,2014,sec. 24.2.3 [input.iterators]).
-         *
-         * \param rate_first The iterator to the beginning of the range of non-negative real elements representing the rates.
-         * \param rate_last The iterator to the ending of the range of non-negative real elements representing the rates.
-         *
-         * \note
-         *  The final \c disable_if parameter is an implementation detail that
-         *  differentiates between this two argument constructor and the
-         *  range-based two argument constructor described above.
-         *
-         * References:
-         * -# ISO, <em>ISO/IEC 14882-2014: Information technology - Programming languages - C++</em>, 2014
-         * .
-         */
-        //  We SFINAE this out of existance if the argument type is
-        //  incrementable as in that case the type is probably an iterator.
-        public: template <typename RateIterT>
-                param_type(RateIterT rate_first, 
-                           RateIterT rate_last,  
-                           typename boost::enable_if_c<boost::has_pre_increment<RateIterT>::value>::type* = 0)
-        : probs_(std::distance(rate_first, rate_last), 1), // will be normalized below
-          rates_(rate_first, rate_last)
-        {
-            assert(probs_.size() == rates_.size());
-        }
-
-        /**
-         * Constructs a @c param_type from the "rates" parameters
-         * of the distribution and with equal phase probabilities.
-         *
-         * The <em>rate vector</em> parameter is given by the range defined by
-         * \a rate_range, and the <em>phase probability vector</em> parameter is
-         * set to the equal phase probabilities (i.e., to a vector of the same
-         * length \f$k\f$ of the <em>rate vector</em> and with each element set
-         * to \f$1.0/k\f$).
-         *
-         * \tparam RateRangeT Must meet the requirements of <a href="boost:/libs/range/doc/html/range/concepts.html">Range</a> concept.
-         *
-         * \param rate_range The range of positive real elements representing the rates.
-         */
-        public: template <typename RateRangeT>
-                param_type(RateRangeT const& rate_range)
-        : probs_(boost::size(rate_range), 1), // Will be normalized below
-          rates_(boost::begin(rate_range), boost::end(rate_range))
-        {
-            hyperexp_detail::normalize(probs_);
-
-            assert( hyperexp_detail::check_params(probs_, rates_) );
-        }
-
-#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
-        /**
-         * Constructs a \c param_type from the <em>phase probability vector</em>
-         * and <em>rate vector</em> parameters of the distribution.
-         *
-         * The <em>phase probability vector</em> parameter is given by the
-         * <em>brace-init-list</em> (ISO,2014,sec. 8.5.4 [dcl.init.list])
-         * defined by \a l1, and the <em>rate vector</em> parameter is given by the
-         * <em>brace-init-list</em> (ISO,2014,sec. 8.5.4 [dcl.init.list])
-         * defined by \a l2.
-         *
-         * \param l1 The initializer list for inizializing the phase probability vector.
-         * \param l2 The initializer list for inizializing the rate vector.
-         *
-         * References:
-         * -# ISO, <em>ISO/IEC 14882-2014: Information technology - Programming languages - C++</em>, 2014
-         * .
-         */
-        public: param_type(std::initializer_list<RealT> l1, std::initializer_list<RealT> l2)
-        : probs_(l1.begin(), l1.end()),
-          rates_(l2.begin(), l2.end())
-        {
-            hyperexp_detail::normalize(probs_);
-
-            assert( hyperexp_detail::check_params(probs_, rates_) );
-        }
-
-        /**
-         * Constructs a \c param_type from the <em>rate vector</em> parameter
-         * of the distribution and with equal phase probabilities.
-         *
-         * The <em>rate vector</em> parameter is given by the
-         * <em>brace-init-list</em> (ISO,2014,sec. 8.5.4 [dcl.init.list])
-         * defined by \a l1, and the <em>phase probability vector</em> parameter is
-         * set to the equal phase probabilities (i.e., to a vector of the same
-         * length \f$k\f$ of the <em>rate vector</em> and with each element set
-         * to \f$1.0/k\f$).
-         *
-         * \param l1 The initializer list for inizializing the rate vector.
-         *
-         * References:
-         * -# ISO, <em>ISO/IEC 14882-2014: Information technology - Programming languages - C++</em>, 2014
-         * .
-         */
-        public: param_type(std::initializer_list<RealT> l1)
-        : probs_(std::distance(l1.begin(), l1.end()), 1), // Will be normalized below
-          rates_(l1.begin(), l1.end())
-        {
-            hyperexp_detail::normalize(probs_);
-
-            assert( hyperexp_detail::check_params(probs_, rates_) );
-        }
-#endif // BOOST_NO_CXX11_HDR_INITIALIZER_LIST
-
-        /**
-         * Gets the <em>phase probability vector</em> parameter of the distribtuion.
-         *
-         * \return The <em>phase probability vector</em> parameter of the distribution.
-         *
-         * \note
-         *  The returned probabilities are the normalized version of the ones
-         *  passed at construction time.
-         */
-        public: std::vector<RealT> probabilities() const
-        {
-            return probs_;
-        }
-
-        /**
-         * Gets the <em>rate vector</em> parameter of the distribtuion.
-         *
-         * \return The <em>rate vector</em> parameter of the distribution.
-         */
-        public: std::vector<RealT> rates() const
-        {
-            return rates_;
-        }
-
-        /** Writes a \c param_type to a \c std::ostream. */
-        public: BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, param)
-        {
-            detail::print_vector(os, param.probs_);
-            os << ' ';
-            detail::print_vector(os, param.rates_);
-
-            return os;
-        }
-
-        /** Reads a \c param_type from a \c std::istream. */
-        public: BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, param)
-        {
-            // NOTE: if \c std::ios_base::exceptions is set, the code below may
-            //       throw in case of a I/O failure.
-            //       To prevent leaving the state of \c param inconsistent:
-            //       - if an exception is thrown, the state of \c param is left
-            //         unchanged (i.e., is the same as the one at the beginning
-            //         of the function's execution), and
-            //       - the state of \c param only after reading the whole input.
-
-            std::vector<RealT> probs;
-            std::vector<RealT> rates;
-
-            // Reads probability and rate vectors
-            detail::read_vector(is, probs);
-            if (!is)
-            {
-                return is;
-            }
-            is >> std::ws;
-            detail::read_vector(is, rates);
-            if (!is)
-            {
-                return is;
-            }
-
-            // Update the state of the param_type object
-            if (probs.size() > 0)
-            {
-                param.probs_.swap(probs);
-                probs.clear();
-            }
-            if (rates.size() > 0)
-            {
-                param.rates_.swap(rates);
-                rates.clear();
-            }
-
-            bool fail = false;
-
-            // Adjust vector sizes (if needed)
-            if (param.probs_.size() != param.rates_.size()
-                || param.probs_.size() == 0)
-            {
-                fail = true;
-
-                const std::size_t np = param.probs_.size();
-                const std::size_t nr = param.rates_.size();
-
-                if (np > nr)
-                {
-                    param.rates_.resize(np, 1);
-                }
-                else if (nr > np)
-                {
-                    param.probs_.resize(nr, 1);
-                }
-                else
-                {
-                    param.probs_.resize(1, 1);
-                    param.rates_.resize(1, 1);
-                }
-            }
-
-            // Normalize probabilities
-            // NOTE: this cannot be done earlier since the probability vector
-            //       can be changed due to size conformance
-            hyperexp_detail::normalize(param.probs_);
-
-            // Set the error state in the underlying stream in case of invalid input
-            if (fail)
-            {
-                // This throws an exception if ios_base::exception(failbit) is enabled
-                is.setstate(std::ios_base::failbit);
-            }
-
-            //post: vector size conformance
-            assert(param.probs_.size() == param.rates_.size());
-
-            return is;
-        }
-
-        /** Returns true if the two sets of parameters are the same. */
-        public: BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        {
-            return lhs.probs_ == rhs.probs_
-                   && lhs.rates_ == rhs.rates_;
-        }
-        
-        /** Returns true if the two sets of parameters are the different. */
-        public: BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-
-
-        private: std::vector<RealT> probs_; ///< The <em>phase probability vector</em> parameter of the distribution
-        private: std::vector<RealT> rates_; ///< The <em>rate vector</em> parameter of the distribution
-    }; // param_type
-
-
-    /**
-     * Constructs a 1-phase \c hyperexponential_distribution (i.e., an
-     * exponential distribution) with rate 1.
-     */
-    public: hyperexponential_distribution()
-    : dd_(std::vector<RealT>(1, 1)),
-      rates_(1, 1)
-    {
-        // empty
-    }
-
-    /**
-     * Constructs a \c hyperexponential_distribution from the <em>phase
-     * probability vector</em> and <em>rate vector</em> parameters of the
-     * distribution.
-     *
-     * The <em>phase probability vector</em> parameter is given by the range
-     * defined by [\a prob_first, \a prob_last) iterator pair, and the
-     * <em>rate vector</em> parameter is given by the range defined by
-     * [\a rate_first, \a rate_last) iterator pair.
-     *
-     * \tparam ProbIterT Must meet the requirements of \c InputIterator concept (ISO,2014,sec. 24.2.3 [input.iterators]).
-     * \tparam RateIterT Must meet the requirements of \c InputIterator concept (ISO,2014,sec. 24.2.3 [input.iterators]).
-     *
-     * \param prob_first The iterator to the beginning of the range of non-negative real elements representing the phase probabilities; if elements don't sum to 1, they are normalized.
-     * \param prob_last The iterator to the ending of the range of non-negative real elements representing the phase probabilities; if elements don't sum to 1, they are normalized.
-     * \param rate_first The iterator to the beginning of the range of non-negative real elements representing the rates.
-     * \param rate_last The iterator to the ending of the range of non-negative real elements representing the rates.
-     *
-     * References:
-     * -# ISO, <em>ISO/IEC 14882-2014: Information technology - Programming languages - C++</em>, 2014
-     * .
-     */
-    public: template <typename ProbIterT, typename RateIterT>
-            hyperexponential_distribution(ProbIterT prob_first, ProbIterT prob_last,
-                                          RateIterT rate_first, RateIterT rate_last)
-    : dd_(prob_first, prob_last),
-      rates_(rate_first, rate_last)
-    {
-        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
-    }
-
-    /**
-     * Constructs a \c hyperexponential_distribution from the <em>phase
-     * probability vector</em> and <em>rate vector</em> parameters of the
-     * distribution.
-     *
-     * The <em>phase probability vector</em> parameter is given by the range
-     * defined by \a prob_range, and the <em>rate vector</em> parameter is
-     * given by the range defined by \a rate_range.
-     *
-     * \tparam ProbRangeT Must meet the requirements of <a href="boost:/libs/range/doc/html/range/concepts.html">Range</a> concept.
-     * \tparam RateRangeT Must meet the requirements of <a href="boost:/libs/range/doc/html/range/concepts.html">Range</a> concept.
-     *
-     * \param prob_range The range of non-negative real elements representing the phase probabilities; if elements don't sum to 1, they are normalized.
-     * \param rate_range The range of positive real elements representing the rates.
-     *
-     * \note
-     *  The final \c disable_if parameter is an implementation detail that
-     *  differentiates between this two argument constructor and the
-     *  iterator-based two argument constructor described below.
-     */
-    //  We SFINAE this out of existance if either argument type is
-    //  incrementable as in that case the type is probably an iterator:
-    public: template <typename ProbRangeT, typename RateRangeT>
-            hyperexponential_distribution(ProbRangeT const& prob_range,
-                                          RateRangeT const& rate_range,
-                                          typename boost::disable_if_c<boost::has_pre_increment<ProbRangeT>::value || boost::has_pre_increment<RateRangeT>::value>::type* = 0)
-    : dd_(prob_range),
-      rates_(boost::begin(rate_range), boost::end(rate_range))
-    {
-        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
-    }
-
-    /**
-     * Constructs a \c hyperexponential_distribution from the <em>rate
-     * vector</em> parameter of the distribution and with equal phase
-     * probabilities.
-     *
-     * The <em>rate vector</em> parameter is given by the range defined by
-     * [\a rate_first, \a rate_last) iterator pair, and the <em>phase
-     * probability vector</em> parameter is set to the equal phase
-     * probabilities (i.e., to a vector of the same length \f$k\f$ of the
-     * <em>rate vector</em> and with each element set to \f$1.0/k\f$).
-     *
-     * \tparam RateIterT Must meet the requirements of \c InputIterator concept (ISO,2014,sec. 24.2.3 [input.iterators]).
-     * \tparam RateIterT2 Must meet the requirements of \c InputIterator concept (ISO,2014,sec. 24.2.3 [input.iterators]).
-     *
-     * \param rate_first The iterator to the beginning of the range of non-negative real elements representing the rates.
-     * \param rate_last The iterator to the ending of the range of non-negative real elements representing the rates.
-     *
-     * \note
-     *  The final \c disable_if parameter is an implementation detail that
-     *  differentiates between this two argument constructor and the
-     *  range-based two argument constructor described above.
-     *
-     * References:
-     * -# ISO, <em>ISO/IEC 14882-2014: Information technology - Programming languages - C++</em>, 2014
-     * .
-     */
-    //  We SFINAE this out of existance if the argument type is
-    //  incrementable as in that case the type is probably an iterator.
-    public: template <typename RateIterT>
-            hyperexponential_distribution(RateIterT rate_first,
-                                          RateIterT rate_last,
-                                          typename boost::enable_if_c<boost::has_pre_increment<RateIterT>::value>::type* = 0)
-    : dd_(std::vector<RealT>(std::distance(rate_first, rate_last), 1)),
-      rates_(rate_first, rate_last)
-    {
-        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
-    }
-
-    /**
-     * Constructs a @c param_type from the "rates" parameters
-     * of the distribution and with equal phase probabilities.
-     *
-     * The <em>rate vector</em> parameter is given by the range defined by
-     * \a rate_range, and the <em>phase probability vector</em> parameter is
-     * set to the equal phase probabilities (i.e., to a vector of the same
-     * length \f$k\f$ of the <em>rate vector</em> and with each element set
-     * to \f$1.0/k\f$).
-     *
-     * \tparam RateRangeT Must meet the requirements of <a href="boost:/libs/range/doc/html/range/concepts.html">Range</a> concept.
-     *
-     * \param rate_range The range of positive real elements representing the rates.
-     */
-    public: template <typename RateRangeT>
-            hyperexponential_distribution(RateRangeT const& rate_range)
-    : dd_(std::vector<RealT>(boost::size(rate_range), 1)),
-      rates_(boost::begin(rate_range), boost::end(rate_range))
-    {
-        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
-    }
-
-    /**
-     * Constructs a \c hyperexponential_distribution from its parameters.
-     *
-     * \param param The parameters of the distribution.
-     */
-    public: explicit hyperexponential_distribution(param_type const& param)
-    : dd_(param.probabilities()),
-      rates_(param.rates())
-    {
-        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
-    }
-
-#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
-    /**
-     * Constructs a \c hyperexponential_distribution from the <em>phase
-     * probability vector</em> and <em>rate vector</em> parameters of the
-     * distribution.
-     *
-     * The <em>phase probability vector</em> parameter is given by the
-     * <em>brace-init-list</em> (ISO,2014,sec. 8.5.4 [dcl.init.list])
-     * defined by \a l1, and the <em>rate vector</em> parameter is given by the
-     * <em>brace-init-list</em> (ISO,2014,sec. 8.5.4 [dcl.init.list])
-     * defined by \a l2.
-     *
-     * \param l1 The initializer list for inizializing the phase probability vector.
-     * \param l2 The initializer list for inizializing the rate vector.
-     *
-     * References:
-     * -# ISO, <em>ISO/IEC 14882-2014: Information technology - Programming languages - C++</em>, 2014
-     * .
-     */
-    public: hyperexponential_distribution(std::initializer_list<RealT> const& l1, std::initializer_list<RealT> const& l2)
-    : dd_(l1.begin(), l1.end()),
-      rates_(l2.begin(), l2.end())
-    {
-        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
-    }
-
-    /**
-     * Constructs a \c hyperexponential_distribution from the <em>rate
-     * vector</em> parameter of the distribution and with equal phase
-     * probabilities.
-     *
-     * The <em>rate vector</em> parameter is given by the
-     * <em>brace-init-list</em> (ISO,2014,sec. 8.5.4 [dcl.init.list])
-     * defined by \a l1, and the <em>phase probability vector</em> parameter is
-     * set to the equal phase probabilities (i.e., to a vector of the same
-     * length \f$k\f$ of the <em>rate vector</em> and with each element set
-     * to \f$1.0/k\f$).
-     *
-     * \param l1 The initializer list for inizializing the rate vector.
-     *
-     * References:
-     * -# ISO, <em>ISO/IEC 14882-2014: Information technology - Programming languages - C++</em>, 2014
-     * .
-     */
-    public: hyperexponential_distribution(std::initializer_list<RealT> const& l1)
-    : dd_(std::vector<RealT>(std::distance(l1.begin(), l1.end()), 1)),
-      rates_(l1.begin(), l1.end())
-    {
-        assert( hyperexp_detail::check_params(dd_.probabilities(), rates_) );
-    }
-#endif
-
-    /**
-     * Gets a random variate distributed according to the
-     * hyperexponential distribution.
-     *
-     * \tparam URNG Must meet the requirements of \uniform_random_number_generator.
-     *
-     * \param urng A uniform random number generator object.
-     *
-     * \return A random variate distributed according to the hyperexponential distribution.
-     */
-    public: template<class URNG>\
-            RealT operator()(URNG& urng) const
-    {
-        const int i = dd_(urng);
-
-        return boost::random::exponential_distribution<RealT>(rates_[i])(urng);
-    }
-
-    /**
-     * Gets a random variate distributed according to the hyperexponential
-     * distribution with parameters specified by \c param.
-     *
-     * \tparam URNG Must meet the requirements of \uniform_random_number_generator.
-     *
-     * \param urng A uniform random number generator object.
-     * \param param A distribution parameter object.
-     *
-     * \return A random variate distributed according to the hyperexponential distribution.
-     *  distribution with parameters specified by \c param.
-     */
-    public: template<class URNG>
-            RealT operator()(URNG& urng, const param_type& param) const
-    {
-        return hyperexponential_distribution(param)(urng);
-    }
-
-    /** Returns the number of phases of the distribution. */
-    public: std::size_t num_phases() const
-    {
-        return rates_.size();
-    }
-
-    /** Returns the <em>phase probability vector</em> parameter of the distribution. */
-    public: std::vector<RealT> probabilities() const
-    {
-        return dd_.probabilities();
-    }
-
-    /** Returns the <em>rate vector</em> parameter of the distribution. */
-    public: std::vector<RealT> rates() const
-    {
-        return rates_;
-    }
-
-    /** Returns the smallest value that the distribution can produce. */
-    public: RealT min BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    {
-        return 0;
-    }
-
-    /** Returns the largest value that the distribution can produce. */
-    public: RealT max BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    {
-        return std::numeric_limits<RealT>::infinity();
-    }
-
-    /** Returns the parameters of the distribution. */
-    public: param_type param() const
-    {
-        std::vector<RealT> probs = dd_.probabilities();
-
-        return param_type(probs.begin(), probs.end(), rates_.begin(), rates_.end());
-    }
-
-    /** Sets the parameters of the distribution. */
-    public: void param(param_type const& param)
-    {
-        dd_.param(typename boost::random::discrete_distribution<int,RealT>::param_type(param.probabilities()));
-        rates_ = param.rates();
-    }
-
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    public: void reset()
-    {
-        // empty
-    }
-
-    /** Writes an @c hyperexponential_distribution to a @c std::ostream. */
-    public: BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, hyperexponential_distribution, hd)
-    {
-        os << hd.param();
-        return os;
-    }
-
-    /** Reads an @c hyperexponential_distribution from a @c std::istream. */
-    public: BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, hyperexponential_distribution, hd)
-    {
-        param_type param;
-        if(is >> param)
-        {
-            hd.param(param);
-        }
-        return is;
-    }
-
-    /**
-     * Returns true if the two instances of @c hyperexponential_distribution will
-     * return identical sequences of values given equal generators.
-     */
-    public: BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(hyperexponential_distribution, lhs, rhs)
-    {
-        return lhs.dd_ == rhs.dd_
-               && lhs.rates_ == rhs.rates_;
-    }
-    
-    /**
-     * Returns true if the two instances of @c hyperexponential_distribution will
-     * return different sequences of values given equal generators.
-     */
-    public: BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(hyperexponential_distribution)
-
-
-    private: boost::random::discrete_distribution<int,RealT> dd_; ///< The \c discrete_distribution used to sample the phase probability and choose the rate
-    private: std::vector<RealT> rates_; ///< The <em>rate vector</em> parameter of the distribution
-}; // hyperexponential_distribution
-
-}} // namespace boost::random
-
-
-#endif // BOOST_RANDOM_HYPEREXPONENTIAL_DISTRIBUTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/independent_bits.hpp b/contrib/libboost/boost_1_65_0/boost/random/independent_bits.hpp
deleted file mode 100644
index dec63b3f46d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/independent_bits.hpp
+++ /dev/null
@@ -1,271 +0,0 @@
-/* boost random/independent_bits.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_INDEPENDENT_BITS_HPP
-#define BOOST_RANDOM_INDEPENDENT_BITS_HPP
-
-#include <istream>
-#include <iosfwd>
-#include <boost/assert.hpp>
-#include <boost/limits.hpp>
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/integer/integer_mask.hpp>
-#include <boost/random/traits.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/integer_log2.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/detail/seed.hpp>
-#include <boost/random/detail/seed_impl.hpp>
-#include <boost/random/detail/signed_unsigned_tools.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * An instantiation of class template @c independent_bits_engine
- * model a \pseudo_random_number_generator.  It generates random
- * numbers distributed between [0, 2^w) by combining one or
- * more invocations of the base engine.
- *
- * Requires: 0 < w <= std::numeric_limits<UIntType>::digits
- */
-template<class Engine, std::size_t w, class UIntType>
-class independent_bits_engine
-{
-public:
-    typedef Engine base_type;
-    typedef UIntType result_type;
-    typedef typename Engine::result_type base_result_type;
-
-    // Required by old Boost.Random concept
-    BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
-
-    /** Returns the smallest value that the generator can produce. */
-    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return 0; }
-    /** Returns the largest value that the generator can produce. */
-    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return max_imp(boost::is_integral<UIntType>()); }
-
-    /**
-     * Constructs an @c independent_bits_engine using the
-     * default constructor of the base generator.
-     */
-    independent_bits_engine() { }
-
-    /**
-     * Constructs an @c independent_bits_engine, using seed as
-     * the constructor argument for both base generators.
-     */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(independent_bits_engine,
-        base_result_type, seed_arg)
-    {
-        _base.seed(seed_arg);
-    }
-
-    /**
-     * Constructs an @c independent_bits_engine, using seq as
-     * the constructor argument for the base generator.
-     */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(independent_bits_engine,
-        SeedSeq, seq)
-    { _base.seed(seq); }
-
-    /** Constructs an @c independent_bits_engine by copying @c base. */
-    independent_bits_engine(const base_type& base_arg) : _base(base_arg) {}
-
-    /**
-     * Contructs an @c independent_bits_engine with
-     * values from the range defined by the input iterators first
-     * and last.  first will be modified to point to the element
-     * after the last one used.
-     *
-     * Throws: @c std::invalid_argument if the input range is too small.
-     *
-     * Exception Safety: Basic
-     */
-    template<class It>
-    independent_bits_engine(It& first, It last) : _base(first, last) { }
-
-    /**
-     * Seeds an @c independent_bits_engine using the default
-     * seed of the base generator.
-     */
-    void seed() { _base.seed(); }
-
-    /**
-     * Seeds an @c independent_bits_engine, using @c seed as the
-     * seed for the base generator.
-     */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(independent_bits_engine,
-        base_result_type, seed_arg)
-    { _base.seed(seed_arg); }
-
-    /**
-     * Seeds an @c independent_bits_engine, using @c seq to
-     * seed the base generator.
-     */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(independent_bits_engine,
-        SeedSeq, seq)
-    { _base.seed(seq); }
-
-    /**
-     * Seeds an @c independent_bits_engine with
-     * values from the range defined by the input iterators first
-     * and last.  first will be modified to point to the element
-     * after the last one used.
-     *
-     * Throws: @c std::invalid_argument if the input range is too small.
-     *
-     * Exception Safety: Basic
-     */
-    template<class It> void seed(It& first, It last)
-    { _base.seed(first, last); }
-
-    /** Returns the next value of the generator. */
-    result_type operator()()
-    {
-        // While it may seem wasteful to recalculate this
-        // every time, both msvc and gcc can propagate
-        // constants, resolving this at compile time.
-        base_unsigned range =
-            detail::subtract<base_result_type>()((_base.max)(), (_base.min)());
-        std::size_t m =
-            (range == (std::numeric_limits<base_unsigned>::max)()) ?
-                std::numeric_limits<base_unsigned>::digits :
-                detail::integer_log2(range + 1);
-        std::size_t n = (w + m - 1) / m;
-        std::size_t w0, n0;
-        base_unsigned y0, y1;
-        base_unsigned y0_mask, y1_mask;
-        calc_params(n, range, w0, n0, y0, y1, y0_mask, y1_mask);
-        if(base_unsigned(range - y0 + 1) > y0 / n) {
-            // increment n and try again.
-            ++n;
-            calc_params(n, range, w0, n0, y0, y1, y0_mask, y1_mask);
-        }
-
-        BOOST_ASSERT(n0*w0 + (n - n0)*(w0 + 1) == w);
-
-        result_type S = 0;
-        for(std::size_t k = 0; k < n0; ++k) {
-            base_unsigned u;
-            do {
-                u = detail::subtract<base_result_type>()(_base(), (_base.min)());
-            } while(u > base_unsigned(y0 - 1));
-            S = (S << w0) + (u & y0_mask);
-        }
-        for(std::size_t k = 0; k < (n - n0); ++k) {
-            base_unsigned u;
-            do {
-                u = detail::subtract<base_result_type>()(_base(), (_base.min)());
-            } while(u > base_unsigned(y1 - 1));
-            S = (S << (w0 + 1)) + (u & y1_mask);
-        }
-        return S;
-    }
-  
-    /** Fills a range with random values */
-    template<class Iter>
-    void generate(Iter first, Iter last)
-    { detail::generate_from_int(*this, first, last); }
-
-    /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z)
-    {
-        for(boost::uintmax_t i = 0; i < z; ++i) {
-            (*this)();
-        }
-    }
-
-    const base_type& base() const { return _base; }
-
-    /**
-     * Writes the textual representation if the generator to a @c std::ostream.
-     * The textual representation of the engine is the textual representation
-     * of the base engine.
-     */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, independent_bits_engine, r)
-    {
-        os << r._base;
-        return os;
-    }
-
-    /**
-     * Reads the state of an @c independent_bits_engine from a
-     * @c std::istream.
-     */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, independent_bits_engine, r)
-    {
-        is >> r._base;
-        return is;
-    }
-
-    /**
-     * Returns: true iff the two @c independent_bits_engines will
-     * produce the same sequence of values.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(independent_bits_engine, x, y)
-    { return x._base == y._base; }
-    /**
-     * Returns: true iff the two @c independent_bits_engines will
-     * produce different sequences of values.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(independent_bits_engine)
-
-private:
-
-    /// \cond show_private
-    typedef typename boost::random::traits::make_unsigned<base_result_type>::type base_unsigned;
-
-    static UIntType max_imp(const boost::true_type&)
-    {
-       return boost::low_bits_mask_t<w>::sig_bits;
-    }
-    static UIntType max_imp(const boost::false_type&)
-    {
-       // We have a multiprecision integer type:
-       BOOST_STATIC_ASSERT(std::numeric_limits<UIntType>::is_specialized);
-       return w < std::numeric_limits<UIntType>::digits ? UIntType((UIntType(1) << w) - 1) : UIntType((((UIntType(1) << (w - 1)) - 1) << 1) | 1u);
-    }
-
-    void calc_params(
-        std::size_t n, base_unsigned range,
-        std::size_t& w0, std::size_t& n0,
-        base_unsigned& y0, base_unsigned& y1,
-        base_unsigned& y0_mask, base_unsigned& y1_mask)
-    {
-        BOOST_ASSERT(w >= n);
-        w0 = w/n;
-        n0 = n - w % n;
-        y0_mask = (base_unsigned(2) << (w0 - 1)) - 1;
-        y1_mask = (y0_mask << 1) | 1;
-        y0 = (range + 1) & ~y0_mask;
-        y1 = (range + 1) & ~y1_mask;
-        BOOST_ASSERT(y0 != 0 || base_unsigned(range + 1) == 0);
-    }
-    /// \endcond
-
-    Engine _base;
-};
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-template<class Engine, std::size_t w, class UIntType>
-const bool independent_bits_engine<Engine, w, UIntType>::has_fixed_range;
-#endif
-
-} // namespace random
-} // namespace boost
-
-#endif // BOOST_RANDOM_INDEPENDENT_BITS_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/inversive_congruential.hpp b/contrib/libboost/boost_1_65_0/boost/random/inversive_congruential.hpp
deleted file mode 100644
index 2329c0db3a9..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/inversive_congruential.hpp
+++ /dev/null
@@ -1,267 +0,0 @@
-/* boost random/inversive_congruential.hpp header file
- *
- * Copyright Jens Maurer 2000-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 for most recent version including documentation.
- *
- * $Id$
- *
- * Revision history
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_INVERSIVE_CONGRUENTIAL_HPP
-#define BOOST_RANDOM_INVERSIVE_CONGRUENTIAL_HPP
-
-#include <iosfwd>
-#include <stdexcept>
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/integer/static_log2.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/const_mod.hpp>
-#include <boost/random/detail/seed.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/detail/seed_impl.hpp>
-
-#include <boost/random/detail/disable_warnings.hpp>
-
-namespace boost {
-namespace random {
-
-// Eichenauer and Lehn 1986
-/**
- * Instantiations of class template @c inversive_congruential_engine model a
- * \pseudo_random_number_generator. It uses the inversive congruential
- * algorithm (ICG) described in
- *
- *  @blockquote
- *  "Inversive pseudorandom number generators: concepts, results and links",
- *  Peter Hellekalek, In: "Proceedings of the 1995 Winter Simulation
- *  Conference", C. Alexopoulos, K. Kang, W.R. Lilegdon, and D. Goldsman
- *  (editors), 1995, pp. 255-262. ftp://random.mat.sbg.ac.at/pub/data/wsc95.ps
- *  @endblockquote
- *
- * The output sequence is defined by x(n+1) = (a*inv(x(n)) - b) (mod p),
- * where x(0), a, b, and the prime number p are parameters of the generator.
- * The expression inv(k) denotes the multiplicative inverse of k in the
- * field of integer numbers modulo p, with inv(0) := 0.
- *
- * The template parameter IntType shall denote a signed integral type large
- * enough to hold p; a, b, and p are the parameters of the generators. The
- * template parameter val is the validation value checked by validation.
- *
- * @xmlnote
- * The implementation currently uses the Euclidian Algorithm to compute
- * the multiplicative inverse. Therefore, the inversive generators are about
- * 10-20 times slower than the others (see section"performance"). However,
- * the paper talks of only 3x slowdown, so the Euclidian Algorithm is probably
- * not optimal for calculating the multiplicative inverse.
- * @endxmlnote
- */
-template<class IntType, IntType a, IntType b, IntType p>
-class inversive_congruential_engine
-{
-public:
-    typedef IntType result_type;
-    BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
-
-    BOOST_STATIC_CONSTANT(result_type, multiplier = a);
-    BOOST_STATIC_CONSTANT(result_type, increment = b);
-    BOOST_STATIC_CONSTANT(result_type, modulus = p);
-    BOOST_STATIC_CONSTANT(IntType, default_seed = 1);
-
-    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return b == 0 ? 1 : 0; }
-    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () { return p-1; }
-    
-    /**
-     * Constructs an @c inversive_congruential_engine, seeding it with
-     * the default seed.
-     */
-    inversive_congruential_engine() { seed(); }
-
-    /**
-     * Constructs an @c inversive_congruential_engine, seeding it with @c x0.
-     */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(inversive_congruential_engine,
-                                               IntType, x0)
-    { seed(x0); }
-    
-    /**
-     * Constructs an @c inversive_congruential_engine, seeding it with values
-     * produced by a call to @c seq.generate().
-     */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(inversive_congruential_engine,
-                                             SeedSeq, seq)
-    { seed(seq); }
-    
-    /**
-     * Constructs an @c inversive_congruential_engine, seeds it
-     * with values taken from the itrator range [first, last),
-     * and adjusts first to point to the element after the last one
-     * used.  If there are not enough elements, throws @c std::invalid_argument.
-     *
-     * first and last must be input iterators.
-     */
-    template<class It> inversive_congruential_engine(It& first, It last)
-    { seed(first, last); }
-
-    /**
-     * Calls seed(default_seed)
-     */
-    void seed() { seed(default_seed); }
-  
-    /**
-     * If c mod m is zero and x0 mod m is zero, changes the current value of
-     * the generator to 1. Otherwise, changes it to x0 mod m. If c is zero,
-     * distinct seeds in the range [1,m) will leave the generator in distinct
-     * states. If c is not zero, the range is [0,m).
-     */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(inversive_congruential_engine, IntType, x0)
-    {
-        // wrap _x if it doesn't fit in the destination
-        if(modulus == 0) {
-            _value = x0;
-        } else {
-            _value = x0 % modulus;
-        }
-        // handle negative seeds
-        if(_value <= 0 && _value != 0) {
-            _value += modulus;
-        }
-        // adjust to the correct range
-        if(increment == 0 && _value == 0) {
-            _value = 1;
-        }
-        BOOST_ASSERT(_value >= (min)());
-        BOOST_ASSERT(_value <= (max)());
-    }
-
-    /**
-     * Seeds an @c inversive_congruential_engine using values from a SeedSeq.
-     */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(inversive_congruential_engine, SeedSeq, seq)
-    { seed(detail::seed_one_int<IntType, modulus>(seq)); }
-    
-    /**
-     * seeds an @c inversive_congruential_engine with values taken
-     * from the itrator range [first, last) and adjusts @c first to
-     * point to the element after the last one used.  If there are
-     * not enough elements, throws @c std::invalid_argument.
-     *
-     * @c first and @c last must be input iterators.
-     */
-    template<class It> void seed(It& first, It last)
-    { seed(detail::get_one_int<IntType, modulus>(first, last)); }
-
-    /** Returns the next output of the generator. */
-    IntType operator()()
-    {
-        typedef const_mod<IntType, p> do_mod;
-        _value = do_mod::mult_add(a, do_mod::invert(_value), b);
-        return _value;
-    }
-  
-    /** Fills a range with random values */
-    template<class Iter>
-    void generate(Iter first, Iter last)
-    { detail::generate_from_int(*this, first, last); }
-
-    /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z)
-    {
-        for(boost::uintmax_t j = 0; j < z; ++j) {
-            (*this)();
-        }
-    }
-
-    /**
-     * Writes the textual representation of the generator to a @c std::ostream.
-     */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, inversive_congruential_engine, x)
-    {
-        os << x._value;
-        return os;
-    }
-
-    /**
-     * Reads the textual representation of the generator from a @c std::istream.
-     */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, inversive_congruential_engine, x)
-    {
-        is >> x._value;
-        return is;
-    }
-
-    /**
-     * Returns true if the two generators will produce identical
-     * sequences of outputs.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(inversive_congruential_engine, x, y)
-    { return x._value == y._value; }
-
-    /**
-     * Returns true if the two generators will produce different
-     * sequences of outputs.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(inversive_congruential_engine)
-
-private:
-    IntType _value;
-};
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-//  A definition is required even for integral static constants
-template<class IntType, IntType a, IntType b, IntType p>
-const bool inversive_congruential_engine<IntType, a, b, p>::has_fixed_range;
-template<class IntType, IntType a, IntType b, IntType p>
-const typename inversive_congruential_engine<IntType, a, b, p>::result_type inversive_congruential_engine<IntType, a, b, p>::multiplier;
-template<class IntType, IntType a, IntType b, IntType p>
-const typename inversive_congruential_engine<IntType, a, b, p>::result_type inversive_congruential_engine<IntType, a, b, p>::increment;
-template<class IntType, IntType a, IntType b, IntType p>
-const typename inversive_congruential_engine<IntType, a, b, p>::result_type inversive_congruential_engine<IntType, a, b, p>::modulus;
-template<class IntType, IntType a, IntType b, IntType p>
-const typename inversive_congruential_engine<IntType, a, b, p>::result_type inversive_congruential_engine<IntType, a, b, p>::default_seed;
-#endif
-
-/// \cond show_deprecated
-
-// provided for backwards compatibility
-template<class IntType, IntType a, IntType b, IntType p, IntType val = 0>
-class inversive_congruential : public inversive_congruential_engine<IntType, a, b, p>
-{
-    typedef inversive_congruential_engine<IntType, a, b, p> base_type;
-public:
-    inversive_congruential(IntType x0 = 1) : base_type(x0) {}
-    template<class It>
-    inversive_congruential(It& first, It last) : base_type(first, last) {}
-};
-
-/// \endcond
-
-/**
- * The specialization hellekalek1995 was suggested in
- *
- *  @blockquote
- *  "Inversive pseudorandom number generators: concepts, results and links",
- *  Peter Hellekalek, In: "Proceedings of the 1995 Winter Simulation
- *  Conference", C. Alexopoulos, K. Kang, W.R. Lilegdon, and D. Goldsman
- *  (editors), 1995, pp. 255-262. ftp://random.mat.sbg.ac.at/pub/data/wsc95.ps
- *  @endblockquote
- */
-typedef inversive_congruential_engine<uint32_t, 9102, 2147483647-36884165,
-  2147483647> hellekalek1995;
-
-} // namespace random
-
-using random::hellekalek1995;
-
-} // namespace boost
-
-#include <boost/random/detail/enable_warnings.hpp>
-
-#endif // BOOST_RANDOM_INVERSIVE_CONGRUENTIAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/lagged_fibonacci.hpp b/contrib/libboost/boost_1_65_0/boost/random/lagged_fibonacci.hpp
deleted file mode 100644
index 5a809f3e494..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/lagged_fibonacci.hpp
+++ /dev/null
@@ -1,537 +0,0 @@
-/* boost random/lagged_fibonacci.hpp header file
- *
- * Copyright Jens Maurer 2000-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 for most recent version including documentation.
- *
- * $Id$
- *
- * Revision history
- *  2013-10-14  fixed some warnings with Wshadow (mgaunard)
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_LAGGED_FIBONACCI_HPP
-#define BOOST_RANDOM_LAGGED_FIBONACCI_HPP
-
-#include <istream>
-#include <iosfwd>
-#include <algorithm>     // std::max
-#include <iterator>
-#include <boost/config/no_tr1/cmath.hpp>         // std::pow
-#include <boost/config.hpp>
-#include <boost/limits.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/integer/integer_mask.hpp>
-#include <boost/random/linear_congruential.hpp>
-#include <boost/random/uniform_01.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/seed.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/detail/generator_seed_seq.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * Instantiations of class template \lagged_fibonacci_engine model a
- * \pseudo_random_number_generator. It uses a lagged Fibonacci
- * algorithm with two lags @c p and @c q:
- * x(i) = x(i-p) + x(i-q) (mod 2<sup>w</sup>) with p > q.
- */
-template<class UIntType, int w, unsigned int p, unsigned int q>
-class lagged_fibonacci_engine
-{
-public:
-    typedef UIntType result_type;
-    BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
-    BOOST_STATIC_CONSTANT(int, word_size = w);
-    BOOST_STATIC_CONSTANT(unsigned int, long_lag = p);
-    BOOST_STATIC_CONSTANT(unsigned int, short_lag = q);
-
-    BOOST_STATIC_CONSTANT(UIntType, default_seed = 331u);
-
-    /** Returns the smallest value that the generator can produce. */
-    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return 0; }
-    /** Returns the largest value that the generator can produce. */
-    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return low_bits_mask_t<w>::sig_bits; }
-
-    /** Creates a new @c lagged_fibonacci_engine and calls @c seed(). */
-    lagged_fibonacci_engine() { seed(); }
-
-    /** Creates a new @c lagged_fibonacci_engine and calls @c seed(value). */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(lagged_fibonacci_engine,
-        UIntType, value)
-    { seed(value); }
-
-    /** Creates a new @c lagged_fibonacci_engine and calls @c seed(seq). */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(lagged_fibonacci_engine,
-        SeedSeq, seq)
-    { seed(seq); }
-
-    /**
-     * Creates a new @c lagged_fibonacci_engine and calls @c seed(first, last).
-     */
-    template<class It> lagged_fibonacci_engine(It& first, It last)
-    { seed(first, last); }
-
-    // compiler-generated copy ctor and assignment operator are fine
-
-    /** Calls @c seed(default_seed). */
-    void seed() { seed(default_seed); }
-
-    /**
-     * Sets the state of the generator to values produced by
-     * a \minstd_rand0 generator.
-     */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(lagged_fibonacci_engine,
-        UIntType, value)
-    {
-        minstd_rand0 intgen(static_cast<boost::uint32_t>(value));
-        detail::generator_seed_seq<minstd_rand0> gen(intgen);
-        seed(gen);
-    }
-
-    /**
-     * Sets the state of the generator using values produced by seq.
-     */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(lagged_fibonacci_engine, SeedSeq, seq)
-    {
-        detail::seed_array_int<w>(seq, x);
-        i = long_lag;
-    }
-
-    /**
-     * Sets the state of the generator to values from the iterator
-     * range [first, last).  If there are not enough elements in the
-     * range [first, last) throws @c std::invalid_argument.
-     */
-    template<class It>
-    void seed(It& first, It last)
-    {
-        detail::fill_array_int<w>(first, last, x);
-        i = long_lag;
-    }
-
-    /** Returns the next value of the generator. */
-    result_type operator()()
-    {
-        if(i >= long_lag)
-            fill();
-        return x[i++];
-    }
-
-    /** Fills a range with random values */
-    template<class Iter>
-    void generate(Iter first, Iter last)
-    { detail::generate_from_int(*this, first, last); }
-
-    /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z)
-    {
-        for(boost::uintmax_t j = 0; j < z; ++j) {
-            (*this)();
-        }
-    }
-
-    /**
-     * Writes the textual representation of the generator to a @c std::ostream.
-     */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, lagged_fibonacci_engine, f)
-    {
-        os << f.i;
-        for(unsigned int j = 0; j < f.long_lag; ++j)
-            os << ' ' << f.x[j];
-        return os;
-    }
-
-    /**
-     * Reads the textual representation of the generator from a @c std::istream.
-     */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, lagged_fibonacci_engine, f)
-    {
-        is >> f.i >> std::ws;
-        for(unsigned int j = 0; j < f.long_lag; ++j)
-            is >> f.x[j] >> std::ws;
-        return is;
-    }
-
-    /**
-     * Returns true if the two generators will produce identical
-     * sequences of outputs.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(lagged_fibonacci_engine, x_, y_)
-    { return x_.i == y_.i && std::equal(x_.x, x_.x+long_lag, y_.x); }
-
-    /**
-     * Returns true if the two generators will produce different
-     * sequences of outputs.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(lagged_fibonacci_engine)
-
-private:
-    /// \cond show_private
-    void fill();
-    /// \endcond
-
-    unsigned int i;
-    UIntType x[long_lag];
-};
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-//  A definition is required even for integral static constants
-template<class UIntType, int w, unsigned int p, unsigned int q>
-const bool lagged_fibonacci_engine<UIntType, w, p, q>::has_fixed_range;
-template<class UIntType, int w, unsigned int p, unsigned int q>
-const unsigned int lagged_fibonacci_engine<UIntType, w, p, q>::long_lag;
-template<class UIntType, int w, unsigned int p, unsigned int q>
-const unsigned int lagged_fibonacci_engine<UIntType, w, p, q>::short_lag;
-template<class UIntType, int w, unsigned int p, unsigned int q>
-const UIntType lagged_fibonacci_engine<UIntType, w, p, q>::default_seed;
-#endif
-
-/// \cond show_private
-
-template<class UIntType, int w, unsigned int p, unsigned int q>
-void lagged_fibonacci_engine<UIntType, w, p, q>::fill()
-{
-    // two loops to avoid costly modulo operations
-    {  // extra scope for MSVC brokenness w.r.t. for scope
-    for(unsigned int j = 0; j < short_lag; ++j)
-        x[j] = (x[j] + x[j+(long_lag-short_lag)]) & low_bits_mask_t<w>::sig_bits;
-    }
-    for(unsigned int j = short_lag; j < long_lag; ++j)
-        x[j] = (x[j] + x[j-short_lag]) & low_bits_mask_t<w>::sig_bits;
-    i = 0;
-}
-
-/// \endcond
-
-/// \cond show_deprecated
-
-// provided for backwards compatibility
-template<class UIntType, int w, unsigned int p, unsigned int q, UIntType v = 0>
-class lagged_fibonacci : public lagged_fibonacci_engine<UIntType, w, p, q>
-{
-    typedef lagged_fibonacci_engine<UIntType, w, p, q> base_type;
-public:
-    lagged_fibonacci() {}
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(lagged_fibonacci, UIntType, val)
-    { this->seed(val); }
-    BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(lagged_fibonacci, SeedSeq, seq)
-    { this->seed(seq); }
-    template<class It>
-    lagged_fibonacci(It& first, It last) : base_type(first, last) {}
-};
-
-/// \endcond
-
-// lagged Fibonacci generator for the range [0..1)
-// contributed by Matthias Troyer
-// for p=55, q=24 originally by G. J. Mitchell and D. P. Moore 1958
-
-/**
- * Instantiations of class template @c lagged_fibonacci_01 model a
- * \pseudo_random_number_generator. It uses a lagged Fibonacci
- * algorithm with two lags @c p and @c q, evaluated in floating-point
- * arithmetic: x(i) = x(i-p) + x(i-q) (mod 1) with p > q. See
- *
- *  @blockquote
- *  "Uniform random number generators for supercomputers", Richard Brent,
- *  Proc. of Fifth Australian Supercomputer Conference, Melbourne,
- *  Dec. 1992, pp. 704-706.
- *  @endblockquote
- *
- * @xmlnote
- * The quality of the generator crucially depends on the choice
- * of the parameters. User code should employ one of the sensibly
- * parameterized generators such as \lagged_fibonacci607 instead.
- * @endxmlnote
- *
- * The generator requires considerable amounts of memory for the storage
- * of its state array. For example, \lagged_fibonacci607 requires about
- * 4856 bytes and \lagged_fibonacci44497 requires about 350 KBytes.
- */
-template<class RealType, int w, unsigned int p, unsigned int q>
-class lagged_fibonacci_01_engine
-{
-public:
-    typedef RealType result_type;
-    BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
-    BOOST_STATIC_CONSTANT(int, word_size = w);
-    BOOST_STATIC_CONSTANT(unsigned int, long_lag = p);
-    BOOST_STATIC_CONSTANT(unsigned int, short_lag = q);
-
-    BOOST_STATIC_CONSTANT(boost::uint32_t, default_seed = 331u);
-
-    /** Constructs a @c lagged_fibonacci_01 generator and calls @c seed(). */
-    lagged_fibonacci_01_engine() { seed(); }
-    /** Constructs a @c lagged_fibonacci_01 generator and calls @c seed(value). */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(lagged_fibonacci_01_engine, uint32_t, value)
-    { seed(value); }
-    /** Constructs a @c lagged_fibonacci_01 generator and calls @c seed(gen). */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(lagged_fibonacci_01_engine, SeedSeq, seq)
-    { seed(seq); }
-    template<class It> lagged_fibonacci_01_engine(It& first, It last)
-    { seed(first, last); }
-
-    // compiler-generated copy ctor and assignment operator are fine
-
-    /** Calls seed(default_seed). */
-    void seed() { seed(default_seed); }
-
-    /**
-     * Constructs a \minstd_rand0 generator with the constructor parameter
-     * value and calls seed with it. Distinct seeds in the range
-     * [1, 2147483647) will produce generators with different states. Other
-     * seeds will be equivalent to some seed within this range. See
-     * \linear_congruential_engine for details.
-     */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(lagged_fibonacci_01_engine, boost::uint32_t, value)
-    {
-        minstd_rand0 intgen(value);
-        detail::generator_seed_seq<minstd_rand0> gen(intgen);
-        seed(gen);
-    }
-
-    /**
-     * Seeds this @c lagged_fibonacci_01_engine using values produced by
-     * @c seq.generate.
-     */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(lagged_fibonacci_01_engine, SeedSeq, seq)
-    {
-        detail::seed_array_real<w>(seq, x);
-        i = long_lag;
-    }
-
-    /**
-     * Seeds this @c lagged_fibonacci_01_engine using values from the
-     * iterator range [first, last).  If there are not enough elements
-     * in the range, throws @c std::invalid_argument.
-     */
-    template<class It>
-    void seed(It& first, It last)
-    {
-        detail::fill_array_real<w>(first, last, x);
-        i = long_lag;
-    }
-
-    /** Returns the smallest value that the generator can produce. */
-    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return result_type(0); }
-    /** Returns the upper bound of the generators outputs. */
-    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () { return result_type(1); }
-
-    /** Returns the next value of the generator. */
-    result_type operator()()
-    {
-        if(i >= long_lag)
-            fill();
-        return x[i++];
-    }
-
-    /** Fills a range with random values */
-    template<class Iter>
-    void generate(Iter first, Iter last)
-    { return detail::generate_from_real(*this, first, last); }
-
-    /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z)
-    {
-        for(boost::uintmax_t j = 0; j < z; ++j) {
-            (*this)();
-        }
-    }
-
-    /**
-     * Writes the textual representation of the generator to a @c std::ostream.
-     */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, lagged_fibonacci_01_engine, f)
-    {
-        // allow for Koenig lookup
-        using std::pow;
-        os << f.i;
-        std::ios_base::fmtflags oldflags = os.flags(os.dec | os.fixed | os.left);
-        for(unsigned int j = 0; j < f.long_lag; ++j)
-            os << ' ' << f.x[j] * f.modulus();
-        os.flags(oldflags);
-        return os;
-    }
-
-    /**
-     * Reads the textual representation of the generator from a @c std::istream.
-     */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, lagged_fibonacci_01_engine, f)
-    {
-        is >> f.i;
-        for(unsigned int j = 0; j < f.long_lag; ++j) {
-            typename lagged_fibonacci_01_engine::result_type value;
-            is >> std::ws >> value;
-            f.x[j] = value / f.modulus();
-        }
-        return is;
-    }
-
-    /**
-     * Returns true if the two generators will produce identical
-     * sequences of outputs.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(lagged_fibonacci_01_engine, x_, y_)
-    { return x_.i == y_.i && std::equal(x_.x, x_.x+long_lag, y_.x); }
-
-    /**
-     * Returns true if the two generators will produce different
-     * sequences of outputs.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(lagged_fibonacci_01_engine)
-
-private:
-    /// \cond show_private
-    void fill();
-    static RealType modulus()
-    {
-        using std::pow;
-        return pow(RealType(2), word_size);
-    }
-    /// \endcond
-    unsigned int i;
-    RealType x[long_lag];
-};
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-//  A definition is required even for integral static constants
-template<class RealType, int w, unsigned int p, unsigned int q>
-const bool lagged_fibonacci_01_engine<RealType, w, p, q>::has_fixed_range;
-template<class RealType, int w, unsigned int p, unsigned int q>
-const unsigned int lagged_fibonacci_01_engine<RealType, w, p, q>::long_lag;
-template<class RealType, int w, unsigned int p, unsigned int q>
-const unsigned int lagged_fibonacci_01_engine<RealType, w, p, q>::short_lag;
-template<class RealType, int w, unsigned int p, unsigned int q>
-const int lagged_fibonacci_01_engine<RealType,w,p,q>::word_size;
-template<class RealType, int w, unsigned int p, unsigned int q>
-const boost::uint32_t lagged_fibonacci_01_engine<RealType,w,p,q>::default_seed;
-#endif
-
-/// \cond show_private
-template<class RealType, int w, unsigned int p, unsigned int q>
-void lagged_fibonacci_01_engine<RealType, w, p, q>::fill()
-{
-    // two loops to avoid costly modulo operations
-    {  // extra scope for MSVC brokenness w.r.t. for scope
-    for(unsigned int j = 0; j < short_lag; ++j) {
-        RealType t = x[j] + x[j+(long_lag-short_lag)];
-        if(t >= RealType(1))
-            t -= RealType(1);
-        x[j] = t;
-    }
-    }
-    for(unsigned int j = short_lag; j < long_lag; ++j) {
-        RealType t = x[j] + x[j-short_lag];
-        if(t >= RealType(1))
-            t -= RealType(1);
-        x[j] = t;
-    }
-    i = 0;
-}
-/// \endcond
-
-/// \cond show_deprecated
-
-// provided for backwards compatibility
-template<class RealType, int w, unsigned int p, unsigned int q>
-class lagged_fibonacci_01 : public lagged_fibonacci_01_engine<RealType, w, p, q>
-{
-    typedef lagged_fibonacci_01_engine<RealType, w, p, q> base_type;
-public:
-    lagged_fibonacci_01() {}
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(lagged_fibonacci_01, boost::uint32_t, val)
-    { this->seed(val); }
-    BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(lagged_fibonacci_01, SeedSeq, seq)
-    { this->seed(seq); }
-    template<class It>
-    lagged_fibonacci_01(It& first, It last) : base_type(first, last) {}
-};
-
-/// \endcond
-
-namespace detail {
-
-template<class Engine>
-struct generator_bits;
-
-template<class RealType, int w, unsigned int p, unsigned int q>
-struct generator_bits<lagged_fibonacci_01_engine<RealType, w, p, q> >
-{
-    static std::size_t value() { return w; }
-};
-
-template<class RealType, int w, unsigned int p, unsigned int q>
-struct generator_bits<lagged_fibonacci_01<RealType, w, p, q> >
-{
-    static std::size_t value() { return w; }
-};
-
-}
-
-#ifdef BOOST_RANDOM_DOXYGEN
-namespace detail {
-/**
- * The specializations lagged_fibonacci607 ... lagged_fibonacci44497
- * use well tested lags.
- *
- * See
- *
- *  @blockquote
- *  "On the Periods of Generalized Fibonacci Recurrences", Richard P. Brent
- *  Computer Sciences Laboratory Australian National University, December 1992
- *  @endblockquote
- *
- * The lags used here can be found in
- *
- *  @blockquote
- *  "Uniform random number generators for supercomputers", Richard Brent,
- *  Proc. of Fifth Australian Supercomputer Conference, Melbourne,
- *  Dec. 1992, pp. 704-706.
- *  @endblockquote
- */
-struct lagged_fibonacci_doc {};
-}
-#endif
-
-/** @copydoc boost::random::detail::lagged_fibonacci_doc */
-typedef lagged_fibonacci_01_engine<double, 48, 607, 273> lagged_fibonacci607;
-/** @copydoc boost::random::detail::lagged_fibonacci_doc */
-typedef lagged_fibonacci_01_engine<double, 48, 1279, 418> lagged_fibonacci1279;
-/** @copydoc boost::random::detail::lagged_fibonacci_doc */
-typedef lagged_fibonacci_01_engine<double, 48, 2281, 1252> lagged_fibonacci2281;
-/** @copydoc boost::random::detail::lagged_fibonacci_doc */
-typedef lagged_fibonacci_01_engine<double, 48, 3217, 576> lagged_fibonacci3217;
-/** @copydoc boost::random::detail::lagged_fibonacci_doc */
-typedef lagged_fibonacci_01_engine<double, 48, 4423, 2098> lagged_fibonacci4423;
-/** @copydoc boost::random::detail::lagged_fibonacci_doc */
-typedef lagged_fibonacci_01_engine<double, 48, 9689, 5502> lagged_fibonacci9689;
-/** @copydoc boost::random::detail::lagged_fibonacci_doc */
-typedef lagged_fibonacci_01_engine<double, 48, 19937, 9842> lagged_fibonacci19937;
-/** @copydoc boost::random::detail::lagged_fibonacci_doc */
-typedef lagged_fibonacci_01_engine<double, 48, 23209, 13470> lagged_fibonacci23209;
-/** @copydoc boost::random::detail::lagged_fibonacci_doc */
-typedef lagged_fibonacci_01_engine<double, 48, 44497, 21034> lagged_fibonacci44497;
-
-} // namespace random
-
-using random::lagged_fibonacci607;
-using random::lagged_fibonacci1279;
-using random::lagged_fibonacci2281;
-using random::lagged_fibonacci3217;
-using random::lagged_fibonacci4423;
-using random::lagged_fibonacci9689;
-using random::lagged_fibonacci19937;
-using random::lagged_fibonacci23209;
-using random::lagged_fibonacci44497;
-
-} // namespace boost
-
-#endif // BOOST_RANDOM_LAGGED_FIBONACCI_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/laplace_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/laplace_distribution.hpp
deleted file mode 100644
index ec176a59c1f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/laplace_distribution.hpp
+++ /dev/null
@@ -1,175 +0,0 @@
-/* boost random/laplace_distribution.hpp header file
- *
- * Copyright Steven Watanabe 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 including documentation.
- *
- * $Id$
- */
-
-#ifndef BOOST_RANDOM_LAPLACE_DISTRIBUTION_HPP
-#define BOOST_RANDOM_LAPLACE_DISTRIBUTION_HPP
-
-#include <cassert>
-#include <istream>
-#include <iosfwd>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/exponential_distribution.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * The laplace distribution is a real-valued distribution with
- * two parameters, mean and beta.
- *
- * It has \f$\displaystyle p(x) = \frac{e^-{\frac{|x-\mu|}{\beta}}}{2\beta}\f$.
- */
-template<class RealType = double>
-class laplace_distribution {
-public:
-    typedef RealType result_type;
-    typedef RealType input_type;
-
-    class param_type {
-    public:
-        typedef laplace_distribution distribution_type;
-
-        /**
-         * Constructs a @c param_type from the "mean" and "beta" parameters
-         * of the distribution.
-         */
-        explicit param_type(RealType mean_arg = RealType(0.0),
-                            RealType beta_arg = RealType(1.0))
-          : _mean(mean_arg), _beta(beta_arg)
-        {}
-
-        /** Returns the "mean" parameter of the distribtuion. */
-        RealType mean() const { return _mean; }
-        /** Returns the "beta" parameter of the distribution. */
-        RealType beta() const { return _beta; }
-
-        /** Writes a @c param_type to a @c std::ostream. */
-        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
-        { os << parm._mean << ' ' << parm._beta; return os; }
-
-        /** Reads a @c param_type from a @c std::istream. */
-        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
-        { is >> parm._mean >> std::ws >> parm._beta; return is; }
-
-        /** Returns true if the two sets of parameters are the same. */
-        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        { return lhs._mean == rhs._mean && lhs._beta == rhs._beta; }
-        
-        /** Returns true if the two sets of parameters are the different. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-
-    private:
-        RealType _mean;
-        RealType _beta;
-    };
-
-    /**
-     * Constructs an @c laplace_distribution from its "mean" and "beta" parameters.
-     */
-    explicit laplace_distribution(RealType mean_arg = RealType(0.0),
-                               RealType beta_arg = RealType(1.0))
-      : _mean(mean_arg), _beta(beta_arg)
-    {}
-    /** Constructs an @c laplace_distribution from its parameters. */
-    explicit laplace_distribution(const param_type& parm)
-      : _mean(parm.mean()), _beta(parm.beta())
-    {}
-
-    /**
-     * Returns a random variate distributed according to the
-     * laplace distribution.
-     */
-    template<class URNG>
-    RealType operator()(URNG& urng) const
-    {
-        RealType exponential = exponential_distribution<RealType>()(urng);
-        if(uniform_01<RealType>()(urng) < 0.5)
-            exponential = -exponential;
-        return _mean + _beta * exponential;
-    }
-
-    /**
-     * Returns a random variate distributed accordint to the laplace
-     * distribution with parameters specified by @c param.
-     */
-    template<class URNG>
-    RealType operator()(URNG& urng, const param_type& parm) const
-    {
-        return laplace_distribution(parm)(urng);
-    }
-
-    /** Returns the "mean" parameter of the distribution. */
-    RealType mean() const { return _mean; }
-    /** Returns the "beta" parameter of the distribution. */
-    RealType beta() const { return _beta; }
-
-    /** Returns the smallest value that the distribution can produce. */
-    RealType min BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    { return RealType(-std::numeric_limits<RealType>::infinity()); }
-    /** Returns the largest value that the distribution can produce. */
-    RealType max BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    { return RealType(std::numeric_limits<RealType>::infinity()); }
-
-    /** Returns the parameters of the distribution. */
-    param_type param() const { return param_type(_mean, _beta); }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        _mean = parm.mean();
-        _beta = parm.beta();
-    }
-
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { }
-
-    /** Writes an @c laplace_distribution to a @c std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, laplace_distribution, wd)
-    {
-        os << wd.param();
-        return os;
-    }
-
-    /** Reads an @c laplace_distribution from a @c std::istream. */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, laplace_distribution, wd)
-    {
-        param_type parm;
-        if(is >> parm) {
-            wd.param(parm);
-        }
-        return is;
-    }
-
-    /**
-     * Returns true if the two instances of @c laplace_distribution will
-     * return identical sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(laplace_distribution, lhs, rhs)
-    { return lhs._mean == rhs._mean && lhs._beta == rhs._beta; }
-    
-    /**
-     * Returns true if the two instances of @c laplace_distribution will
-     * return different sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(laplace_distribution)
-
-private:
-    RealType _mean;
-    RealType _beta;
-};
-
-} // namespace random
-} // namespace boost
-
-#endif // BOOST_RANDOM_LAPLACE_DISTRIBUTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/linear_congruential.hpp b/contrib/libboost/boost_1_65_0/boost/random/linear_congruential.hpp
deleted file mode 100644
index de3a1d07491..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/linear_congruential.hpp
+++ /dev/null
@@ -1,466 +0,0 @@
-/* boost random/linear_congruential.hpp header file
- *
- * Copyright Jens Maurer 2000-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 for most recent version including documentation.
- *
- * $Id$
- *
- * Revision history
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_LINEAR_CONGRUENTIAL_HPP
-#define BOOST_RANDOM_LINEAR_CONGRUENTIAL_HPP
-
-#include <iostream>
-#include <stdexcept>
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/limits.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/integer/static_log2.hpp>
-#include <boost/mpl/if.hpp>
-#include <boost/type_traits/is_arithmetic.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/const_mod.hpp>
-#include <boost/random/detail/seed.hpp>
-#include <boost/random/detail/seed_impl.hpp>
-#include <boost/detail/workaround.hpp>
-
-#include <boost/random/detail/disable_warnings.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * Instantiations of class template linear_congruential_engine model a
- * \pseudo_random_number_generator. Linear congruential pseudo-random
- * number generators are described in:
- *
- *  @blockquote
- *  "Mathematical methods in large-scale computing units", D. H. Lehmer,
- *  Proc. 2nd Symposium on Large-Scale Digital Calculating Machines,
- *  Harvard University Press, 1951, pp. 141-146
- *  @endblockquote
- *
- * Let x(n) denote the sequence of numbers returned by some pseudo-random
- * number generator. Then for the linear congruential generator,
- * x(n+1) := (a * x(n) + c) mod m. Parameters for the generator are
- * x(0), a, c, m. The template parameter IntType shall denote an integral
- * type. It must be large enough to hold values a, c, and m. The template
- * parameters a and c must be smaller than m.
- *
- * Note: The quality of the generator crucially depends on the choice of
- * the parameters. User code should use one of the sensibly parameterized
- * generators such as minstd_rand instead.
- */
-template<class IntType, IntType a, IntType c, IntType m>
-class linear_congruential_engine
-{
-public:
-    typedef IntType result_type;
-
-    // Required for old Boost.Random concept
-    BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
-
-    BOOST_STATIC_CONSTANT(IntType, multiplier = a);
-    BOOST_STATIC_CONSTANT(IntType, increment = c);
-    BOOST_STATIC_CONSTANT(IntType, modulus = m);
-    BOOST_STATIC_CONSTANT(IntType, default_seed = 1);
-    
-    BOOST_STATIC_ASSERT(std::numeric_limits<IntType>::is_integer);
-    BOOST_STATIC_ASSERT(m == 0 || a < m);
-    BOOST_STATIC_ASSERT(m == 0 || c < m);
-    
-    /**
-     * Constructs a @c linear_congruential_engine, using the default seed
-     */
-    linear_congruential_engine() { seed(); }
-
-    /**
-     * Constructs a @c linear_congruential_engine, seeding it with @c x0.
-     */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(linear_congruential_engine,
-                                               IntType, x0)
-    { seed(x0); }
-    
-    /**
-     * Constructs a @c linear_congruential_engine, seeding it with values
-     * produced by a call to @c seq.generate().
-     */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(linear_congruential_engine,
-                                             SeedSeq, seq)
-    { seed(seq); }
-
-    /**
-     * Constructs a @c linear_congruential_engine  and seeds it
-     * with values taken from the itrator range [first, last)
-     * and adjusts first to point to the element after the last one
-     * used.  If there are not enough elements, throws @c std::invalid_argument.
-     *
-     * first and last must be input iterators.
-     */
-    template<class It>
-    linear_congruential_engine(It& first, It last)
-    {
-        seed(first, last);
-    }
-
-    // compiler-generated copy constructor and assignment operator are fine
-
-    /**
-     * Calls seed(default_seed)
-     */
-    void seed() { seed(default_seed); }
-
-    /**
-     * If c mod m is zero and x0 mod m is zero, changes the current value of
-     * the generator to 1. Otherwise, changes it to x0 mod m. If c is zero,
-     * distinct seeds in the range [1,m) will leave the generator in distinct
-     * states. If c is not zero, the range is [0,m).
-     */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(linear_congruential_engine, IntType, x0)
-    {
-        // wrap _x if it doesn't fit in the destination
-        if(modulus == 0) {
-            _x = x0;
-        } else {
-            _x = x0 % modulus;
-        }
-        // handle negative seeds
-        if(_x <= 0 && _x != 0) {
-            _x += modulus;
-        }
-        // adjust to the correct range
-        if(increment == 0 && _x == 0) {
-            _x = 1;
-        }
-        BOOST_ASSERT(_x >= (min)());
-        BOOST_ASSERT(_x <= (max)());
-    }
-
-    /**
-     * Seeds a @c linear_congruential_engine using values from a SeedSeq.
-     */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(linear_congruential_engine, SeedSeq, seq)
-    { seed(detail::seed_one_int<IntType, m>(seq)); }
-
-    /**
-     * seeds a @c linear_congruential_engine with values taken
-     * from the itrator range [first, last) and adjusts @c first to
-     * point to the element after the last one used.  If there are
-     * not enough elements, throws @c std::invalid_argument.
-     *
-     * @c first and @c last must be input iterators.
-     */
-    template<class It>
-    void seed(It& first, It last)
-    { seed(detail::get_one_int<IntType, m>(first, last)); }
-
-    /**
-     * Returns the smallest value that the @c linear_congruential_engine
-     * can produce.
-     */
-    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return c == 0 ? 1 : 0; }
-    /**
-     * Returns the largest value that the @c linear_congruential_engine
-     * can produce.
-     */
-    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return modulus-1; }
-
-    /** Returns the next value of the @c linear_congruential_engine. */
-    IntType operator()()
-    {
-        _x = const_mod<IntType, m>::mult_add(a, _x, c);
-        return _x;
-    }
-  
-    /** Fills a range with random values */
-    template<class Iter>
-    void generate(Iter first, Iter last)
-    { detail::generate_from_int(*this, first, last); }
-
-    /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z)
-    {
-        typedef const_mod<IntType, m> mod_type;
-        IntType b_inv = mod_type::invert(a-1);
-        IntType b_gcd = mod_type::mult(a-1, b_inv);
-        if(b_gcd == 1) {
-            IntType a_z = mod_type::pow(a, z);
-            _x = mod_type::mult_add(a_z, _x, 
-                mod_type::mult(mod_type::mult(c, b_inv), a_z - 1));
-        } else {
-            // compute (a^z - 1)*c % (b_gcd * m) / (b / b_gcd) * inv(b / b_gcd)
-            // we're storing the intermediate result / b_gcd
-            IntType a_zm1_over_gcd = 0;
-            IntType a_km1_over_gcd = (a - 1) / b_gcd;
-            boost::uintmax_t exponent = z;
-            while(exponent != 0) {
-                if(exponent % 2 == 1) {
-                    a_zm1_over_gcd =
-                        mod_type::mult_add(
-                            b_gcd,
-                            mod_type::mult(a_zm1_over_gcd, a_km1_over_gcd),
-                            mod_type::add(a_zm1_over_gcd, a_km1_over_gcd));
-                }
-                a_km1_over_gcd = mod_type::mult_add(
-                    b_gcd,
-                    mod_type::mult(a_km1_over_gcd, a_km1_over_gcd),
-                    mod_type::add(a_km1_over_gcd, a_km1_over_gcd));
-                exponent /= 2;
-            }
-            
-            IntType a_z = mod_type::mult_add(b_gcd, a_zm1_over_gcd, 1);
-            IntType num = mod_type::mult(c, a_zm1_over_gcd);
-            b_inv = mod_type::invert((a-1)/b_gcd);
-            _x = mod_type::mult_add(a_z, _x, mod_type::mult(b_inv, num));
-        }
-    }
-
-    friend bool operator==(const linear_congruential_engine& x,
-                           const linear_congruential_engine& y)
-    { return x._x == y._x; }
-    friend bool operator!=(const linear_congruential_engine& x,
-                           const linear_congruential_engine& y)
-    { return !(x == y); }
-    
-#if !defined(BOOST_RANDOM_NO_STREAM_OPERATORS)
-    /** Writes a @c linear_congruential_engine to a @c std::ostream. */
-    template<class CharT, class Traits>
-    friend std::basic_ostream<CharT,Traits>&
-    operator<<(std::basic_ostream<CharT,Traits>& os,
-               const linear_congruential_engine& lcg)
-    {
-        return os << lcg._x;
-    }
-
-    /** Reads a @c linear_congruential_engine from a @c std::istream. */
-    template<class CharT, class Traits>
-    friend std::basic_istream<CharT,Traits>&
-    operator>>(std::basic_istream<CharT,Traits>& is,
-               linear_congruential_engine& lcg)
-    {
-        lcg.read(is);
-        return is;
-    }
-#endif
-
-private:
-
-    /// \cond show_private
-
-    template<class CharT, class Traits>
-    void read(std::basic_istream<CharT, Traits>& is) {
-        IntType x;
-        if(is >> x) {
-            if(x >= (min)() && x <= (max)()) {
-                _x = x;
-            } else {
-                is.setstate(std::ios_base::failbit);
-            }
-        }
-    }
-
-    /// \endcond
-
-    IntType _x;
-};
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-//  A definition is required even for integral static constants
-template<class IntType, IntType a, IntType c, IntType m>
-const bool linear_congruential_engine<IntType, a, c, m>::has_fixed_range;
-template<class IntType, IntType a, IntType c, IntType m>
-const IntType linear_congruential_engine<IntType,a,c,m>::multiplier;
-template<class IntType, IntType a, IntType c, IntType m>
-const IntType linear_congruential_engine<IntType,a,c,m>::increment;
-template<class IntType, IntType a, IntType c, IntType m>
-const IntType linear_congruential_engine<IntType,a,c,m>::modulus;
-template<class IntType, IntType a, IntType c, IntType m>
-const IntType linear_congruential_engine<IntType,a,c,m>::default_seed;
-#endif
-
-/// \cond show_deprecated
-
-// provided for backwards compatibility
-template<class IntType, IntType a, IntType c, IntType m, IntType val = 0>
-class linear_congruential : public linear_congruential_engine<IntType, a, c, m>
-{
-    typedef linear_congruential_engine<IntType, a, c, m> base_type;
-public:
-    linear_congruential(IntType x0 = 1) : base_type(x0) {}
-    template<class It>
-    linear_congruential(It& first, It last) : base_type(first, last) {}
-};
-
-/// \endcond
-
-/**
- * The specialization \minstd_rand0 was originally suggested in
- *
- *  @blockquote
- *  A pseudo-random number generator for the System/360, P.A. Lewis,
- *  A.S. Goodman, J.M. Miller, IBM Systems Journal, Vol. 8, No. 2,
- *  1969, pp. 136-146
- *  @endblockquote
- *
- * It is examined more closely together with \minstd_rand in
- *
- *  @blockquote
- *  "Random Number Generators: Good ones are hard to find",
- *  Stephen K. Park and Keith W. Miller, Communications of
- *  the ACM, Vol. 31, No. 10, October 1988, pp. 1192-1201 
- *  @endblockquote
- */
-typedef linear_congruential_engine<uint32_t, 16807, 0, 2147483647> minstd_rand0;
-
-/** The specialization \minstd_rand was suggested in
- *
- *  @blockquote
- *  "Random Number Generators: Good ones are hard to find",
- *  Stephen K. Park and Keith W. Miller, Communications of
- *  the ACM, Vol. 31, No. 10, October 1988, pp. 1192-1201
- *  @endblockquote
- */
-typedef linear_congruential_engine<uint32_t, 48271, 0, 2147483647> minstd_rand;
-
-
-#if !defined(BOOST_NO_INT64_T) && !defined(BOOST_NO_INTEGRAL_INT64_T)
-/**
- * Class @c rand48 models a \pseudo_random_number_generator. It uses
- * the linear congruential algorithm with the parameters a = 0x5DEECE66D,
- * c = 0xB, m = 2**48. It delivers identical results to the @c lrand48()
- * function available on some systems (assuming lcong48 has not been called).
- *
- * It is only available on systems where @c uint64_t is provided as an
- * integral type, so that for example static in-class constants and/or
- * enum definitions with large @c uint64_t numbers work.
- */
-class rand48 
-{
-public:
-    typedef boost::uint32_t result_type;
-
-    BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
-    /**
-     * Returns the smallest value that the generator can produce
-     */
-    static uint32_t min BOOST_PREVENT_MACRO_SUBSTITUTION () { return 0; }
-    /**
-     * Returns the largest value that the generator can produce
-     */
-    static uint32_t max BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return 0x7FFFFFFF; }
-  
-    /** Seeds the generator with the default seed. */
-    rand48() : lcf(cnv(static_cast<uint32_t>(1))) {}
-    /**
-     * Constructs a \rand48 generator with x(0) := (x0 << 16) | 0x330e.
-     */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(rand48, result_type, x0)
-    { seed(x0); }
-    /**
-     * Seeds the generator with values produced by @c seq.generate().
-     */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(rand48, SeedSeq, seq)
-    { seed(seq); }
-    /**
-     * Seeds the generator using values from an iterator range,
-     * and updates first to point one past the last value consumed.
-     */
-    template<class It> rand48(It& first, It last) : lcf(first, last) { }
-
-    // compiler-generated copy ctor and assignment operator are fine
-
-    /** Seeds the generator with the default seed. */
-    void seed() { seed(static_cast<uint32_t>(1)); }
-    /**
-     * Changes the current value x(n) of the generator to (x0 << 16) | 0x330e.
-     */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(rand48, result_type, x0)
-    { lcf.seed(cnv(x0)); }
-    /**
-     * Seeds the generator using values from an iterator range,
-     * and updates first to point one past the last value consumed.
-     */
-    template<class It> void seed(It& first, It last) { lcf.seed(first,last); }
-    /**
-     * Seeds the generator with values produced by @c seq.generate().
-     */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(rand48, SeedSeq, seq)
-    { lcf.seed(seq); }
-
-    /**  Returns the next value of the generator. */
-    uint32_t operator()() { return static_cast<uint32_t>(lcf() >> 17); }
-    
-    /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z) { lcf.discard(z); }
-  
-    /** Fills a range with random values */
-    template<class Iter>
-    void generate(Iter first, Iter last)
-    {
-        for(; first != last; ++first) {
-            *first = (*this)();
-        }
-    }
-
-#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
-    /**  Writes a @c rand48 to a @c std::ostream. */
-    template<class CharT,class Traits>
-    friend std::basic_ostream<CharT,Traits>&
-    operator<<(std::basic_ostream<CharT,Traits>& os, const rand48& r)
-    { os << r.lcf; return os; }
-
-    /** Reads a @c rand48 from a @c std::istream. */
-    template<class CharT,class Traits>
-    friend std::basic_istream<CharT,Traits>&
-    operator>>(std::basic_istream<CharT,Traits>& is, rand48& r)
-    { is >> r.lcf; return is; }
-#endif
-
-    /**
-     * Returns true if the two generators will produce identical
-     * sequences of values.
-     */
-    friend bool operator==(const rand48& x, const rand48& y)
-    { return x.lcf == y.lcf; }
-    /**
-     * Returns true if the two generators will produce different
-     * sequences of values.
-     */
-    friend bool operator!=(const rand48& x, const rand48& y)
-    { return !(x == y); }
-private:
-    /// \cond show_private
-    typedef random::linear_congruential_engine<uint64_t,
-        // xxxxULL is not portable
-        uint64_t(0xDEECE66DUL) | (uint64_t(0x5) << 32),
-        0xB, uint64_t(1)<<48> lcf_t;
-    lcf_t lcf;
-
-    static boost::uint64_t cnv(boost::uint32_t x)
-    { return (static_cast<uint64_t>(x) << 16) | 0x330e; }
-    /// \endcond
-};
-#endif /* !BOOST_NO_INT64_T && !BOOST_NO_INTEGRAL_INT64_T */
-
-} // namespace random
-
-using random::minstd_rand0;
-using random::minstd_rand;
-using random::rand48;
-
-} // namespace boost
-
-#include <boost/random/detail/enable_warnings.hpp>
-
-#endif // BOOST_RANDOM_LINEAR_CONGRUENTIAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/linear_feedback_shift.hpp b/contrib/libboost/boost_1_65_0/boost/random/linear_feedback_shift.hpp
deleted file mode 100644
index a695dfde97f..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/linear_feedback_shift.hpp
+++ /dev/null
@@ -1,217 +0,0 @@
-/* boost random/linear_feedback_shift.hpp header file
- *
- * Copyright Jens Maurer 2002
- * 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_LINEAR_FEEDBACK_SHIFT_HPP
-#define BOOST_RANDOM_LINEAR_FEEDBACK_SHIFT_HPP
-
-#include <iosfwd>
-#include <stdexcept>
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/integer/integer_mask.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/seed.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/detail/seed_impl.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * Instatiations of @c linear_feedback_shift model a
- * \pseudo_random_number_generator.  It was originally
- * proposed in
- *
- *  @blockquote
- *  "Random numbers generated by linear recurrence modulo two.",
- *  Tausworthe, R. C.(1965), Mathematics of Computation 19, 201-209.
- *  @endblockquote
- */
-template<class UIntType, int w, int k, int q, int s>
-class linear_feedback_shift_engine
-{
-public:
-    typedef UIntType result_type;
-    BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
-    BOOST_STATIC_CONSTANT(int, word_size = w);
-    BOOST_STATIC_CONSTANT(int, exponent1 = k);
-    BOOST_STATIC_CONSTANT(int, exponent2 = q);
-    BOOST_STATIC_CONSTANT(int, step_size = s);
-    BOOST_STATIC_CONSTANT(UIntType, default_seed = 341);
-
-    /** Returns the smallest value that the generator can produce. */
-    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return 0; }
-    /** Returns the largest value that the generator can produce. */
-    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return wordmask(); }
-
-    BOOST_STATIC_ASSERT(w > 0);
-    BOOST_STATIC_ASSERT(q > 0);
-    BOOST_STATIC_ASSERT(k < w);
-    BOOST_STATIC_ASSERT(0 < 2*q && 2*q < k);
-    BOOST_STATIC_ASSERT(0 < s && s <= k-q);
-
-    /** Constructs a @c linear_feedback_shift_engine, using the default seed. */
-    linear_feedback_shift_engine() { seed(); }
-    
-    /** Constructs a @c linear_feedback_shift_engine, seeding it with s0. */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(linear_feedback_shift_engine,
-        UIntType, s0)
-    { seed(s0); }
-    
-    /** Constructs a @c linear_feedback_shift_engine, seeding it with seq. */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(linear_feedback_shift_engine,
-        SeedSeq, seq)
-    { seed(seq); }
-    
-    /**
-     * Constructs a @c linear_feedback_shift_engine, seeding it with 
-     * values from the range [first, last).
-     */
-    template<class It> linear_feedback_shift_engine(It& first, It last)
-    { seed(first, last); }
-    
-    /** Seeds a @c linear_feedback_shift_engine with the default seed. */
-    void seed() {  seed(default_seed); }
-    
-    /** Seeds a @c linear_feedback_shift_engine with @c s0. */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(linear_feedback_shift_engine,
-        UIntType, s0)
-    {
-        value = s0 & wordmask();
-        if(value < (1 << (w-k))) {
-            value += 1 << (w-k);
-        }
-    }
-    
-    /**
-     * Seeds a @c linear_feedback_shift_engine with values
-     * produced by @c seq.generate().
-     */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(linear_feedback_shift_engine,
-        SeedSeq, seq)
-    { seed(detail::seed_one_int<UIntType, (UIntType(2) << (w - 1))>(seq)); }
-    
-    /**
-     * Seeds a @c linear_feedback_shift_engine with values
-     * from the range [first, last).
-     */
-    template<class It> void seed(It& first, It last)
-    {
-        seed(detail::get_one_int<UIntType, (UIntType(2) << (w - 1))>(first, last));
-    }
-
-    /** Returns the next value of the generator. */
-    result_type operator()()
-    {
-        const UIntType b = (((value << q) ^ value) & wordmask()) >> (k-s);
-        const UIntType mask = (wordmask() << (w-k)) & wordmask();
-        value = ((value & mask) << s) ^ b;
-        return value;
-    }
-  
-    /** Fills a range with random values */
-    template<class Iter>
-    void generate(Iter first, Iter last)
-    { detail::generate_from_int(*this, first, last); }
-
-    /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z)
-    {
-        for(boost::uintmax_t j = 0; j < z; ++j) {
-            (*this)();
-        }
-    }
-    
-    /**
-     * Writes the textual representation of the generator to a @c std::ostream.
-     */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, linear_feedback_shift_engine, x)
-    {
-        os << x.value;
-        return os;
-    }
-    
-    /**
-     * Reads the textual representation of the generator from a @c std::istream.
-     */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, linear_feedback_shift_engine, x)
-    {
-        is >> x.value;
-        return is;
-    }
-
-    /**
-     * Returns true if the two generators will produce identical
-     * sequences of outputs.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(linear_feedback_shift_engine, x, y)
-    { return x.value == y.value; }
-    
-    /**
-     * Returns true if the two generators will produce different
-     * sequences of outputs.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(linear_feedback_shift_engine)
-
-private:
-    /// \cond show_private
-    static UIntType wordmask() { return boost::low_bits_mask_t<w>::sig_bits; }
-    /// \endcond
-    UIntType value;
-};
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-//  A definition is required even for integral static constants
-template<class UIntType, int w, int k, int q, int s>
-const bool linear_feedback_shift_engine<UIntType, w, k, q, s>::has_fixed_range;
-template<class UIntType, int w, int k, int q, int s>
-const int linear_feedback_shift_engine<UIntType, w, k, q, s>::word_size;
-template<class UIntType, int w, int k, int q, int s>
-const int linear_feedback_shift_engine<UIntType, w, k, q, s>::exponent1;
-template<class UIntType, int w, int k, int q, int s>
-const int linear_feedback_shift_engine<UIntType, w, k, q, s>::exponent2;
-template<class UIntType, int w, int k, int q, int s>
-const int linear_feedback_shift_engine<UIntType, w, k, q, s>::step_size;
-template<class UIntType, int w, int k, int q, int s>
-const UIntType linear_feedback_shift_engine<UIntType, w, k, q, s>::default_seed;
-#endif
-
-/// \cond show_deprecated
-
-/** Provided for backwards compatibility. */
-template<class UIntType, int w, int k, int q, int s, UIntType v = 0>
-class linear_feedback_shift :
-    public linear_feedback_shift_engine<UIntType, w, k, q, s>
-{
-    typedef linear_feedback_shift_engine<UIntType, w, k, q, s> base_type;
-public:
-    linear_feedback_shift() {}
-    BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(linear_feedback_shift,
-        SeedSeq, seq)
-    { seed(seq); }
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(linear_feedback_shift,
-        UIntType, val)
-    { seed(val); }
-    template<class It>
-    linear_feedback_shift(It& first, It last) : base_type(first, last) {}
-};
-
-/// \endcond
-
-} // namespace random
-} // namespace boost
-
-#endif // BOOST_RANDOM_LINEAR_FEEDBACK_SHIFT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/lognormal_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/lognormal_distribution.hpp
deleted file mode 100644
index 7ed1e13abf4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/lognormal_distribution.hpp
+++ /dev/null
@@ -1,254 +0,0 @@
-/* boost random/lognormal_distribution.hpp header file
- *
- * Copyright Jens Maurer 2000-2001
- * 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$
- *
- * Revision history
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_LOGNORMAL_DISTRIBUTION_HPP
-#define BOOST_RANDOM_LOGNORMAL_DISTRIBUTION_HPP
-
-#include <boost/config/no_tr1/cmath.hpp>      // std::exp, std::sqrt
-#include <cassert>
-#include <iosfwd>
-#include <istream>
-#include <boost/limits.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/normal_distribution.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * Instantiations of class template lognormal_distribution model a
- * \random_distribution. Such a distribution produces random numbers
- * with \f$\displaystyle p(x) = \frac{1}{x s \sqrt{2\pi}} e^{\frac{-\left(\log(x)-m\right)^2}{2s^2}}\f$
- * for x > 0.
- *
- * @xmlwarning
- * This distribution has been updated to match the C++ standard.
- * Its behavior has changed from the original
- * boost::lognormal_distribution.  A backwards compatible
- * version is provided in namespace boost.
- * @endxmlwarning
- */
-template<class RealType = double>
-class lognormal_distribution
-{
-public:
-    typedef typename normal_distribution<RealType>::input_type input_type;
-    typedef RealType result_type;
-
-    class param_type
-    {
-    public:
-
-        typedef lognormal_distribution distribution_type;
-
-        /** Constructs the parameters of a lognormal_distribution. */
-        explicit param_type(RealType m_arg = RealType(0.0),
-                            RealType s_arg = RealType(1.0))
-          : _m(m_arg), _s(s_arg) {}
-
-        /** Returns the "m" parameter of the distribution. */
-        RealType m() const { return _m; }
-
-        /** Returns the "s" parameter of the distribution. */
-        RealType s() const { return _s; }
-
-        /** Writes the parameters to a std::ostream. */
-        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
-        {
-            os << parm._m << " " << parm._s;
-            return os;
-        }
-
-        /** Reads the parameters from a std::istream. */
-        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
-        {
-            is >> parm._m >> std::ws >> parm._s;
-            return is;
-        }
-
-        /** Returns true if the two sets of parameters are equal. */
-        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        { return lhs._m == rhs._m && lhs._s == rhs._s; }
-
-        /** Returns true if the two sets of parameters are different. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-
-    private:
-        RealType _m;
-        RealType _s;
-    };
-
-    /**
-     * Constructs a lognormal_distribution. @c m and @c s are the
-     * parameters of the distribution.
-     */
-    explicit lognormal_distribution(RealType m_arg = RealType(0.0),
-                                    RealType s_arg = RealType(1.0))
-      : _normal(m_arg, s_arg) {}
-
-    /**
-     * Constructs a lognormal_distribution from its parameters.
-     */
-    explicit lognormal_distribution(const param_type& parm)
-      : _normal(parm.m(), parm.s()) {}
-
-    // compiler-generated copy ctor and assignment operator are fine
-
-    /** Returns the m parameter of the distribution. */
-    RealType m() const { return _normal.mean(); }
-    /** Returns the s parameter of the distribution. */
-    RealType s() const { return _normal.sigma(); }
-
-    /** Returns the smallest value that the distribution can produce. */
-    RealType min BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    { return RealType(0); }
-    /** 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(m(), s()); }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        typedef normal_distribution<RealType> normal_type;
-        typename normal_type::param_type normal_param(parm.m(), parm.s());
-        _normal.param(normal_param);
-    }
-    
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { _normal.reset(); }
-
-    /**
-     * Returns a random variate distributed according to the
-     * lognormal distribution.
-     */
-    template<class Engine>
-    result_type operator()(Engine& eng)
-    {
-        using std::exp;
-        return exp(_normal(eng));
-    }
-
-    /**
-     * Returns a random variate distributed according to the
-     * lognormal distribution with parameters specified by param.
-     */
-    template<class Engine>
-    result_type operator()(Engine& eng, const param_type& parm)
-    { return lognormal_distribution(parm)(eng); }
-
-    /** Writes the distribution to a @c std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, lognormal_distribution, ld)
-    {
-        os << ld._normal;
-        return os;
-    }
-
-    /** Reads the distribution from a @c std::istream. */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, lognormal_distribution, ld)
-    {
-        is >> ld._normal;
-        return is;
-    }
-
-    /**
-     * Returns true if the two distributions will produce identical
-     * sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(lognormal_distribution, lhs, rhs)
-    { return lhs._normal == rhs._normal; }
-
-    /**
-     * Returns true if the two distributions may produce different
-     * sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(lognormal_distribution)
-
-private:
-    normal_distribution<result_type> _normal;
-};
-
-} // namespace random
-
-/// \cond show_deprecated
-
-/**
- * Provided for backwards compatibility.  This class is
- * deprecated.  It provides the old behavior of lognormal_distribution with
- * \f$\displaystyle p(x) = \frac{1}{x \sigma_N \sqrt{2\pi}} e^{\frac{-\left(\log(x)-\mu_N\right)^2}{2\sigma_N^2}}\f$
- * for x > 0, where \f$\displaystyle \mu_N = \log\left(\frac{\mu^2}{\sqrt{\sigma^2 + \mu^2}}\right)\f$ and
- * \f$\displaystyle \sigma_N = \sqrt{\log\left(1 + \frac{\sigma^2}{\mu^2}\right)}\f$.
- */
-template<class RealType = double>
-class lognormal_distribution
-{
-public:
-    typedef typename normal_distribution<RealType>::input_type input_type;
-    typedef RealType result_type;
-
-    lognormal_distribution(RealType mean_arg = RealType(1.0),
-                           RealType sigma_arg = RealType(1.0))
-      : _mean(mean_arg), _sigma(sigma_arg)
-    {
-        init();
-    }
-    RealType mean() const { return _mean; }
-    RealType sigma() const { return _sigma; }
-    void reset() { _normal.reset(); }
-    template<class Engine>
-    RealType operator()(Engine& eng)
-    {
-        using std::exp;
-        return exp(_normal(eng) * _nsigma + _nmean);
-    }
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, lognormal_distribution, ld)
-    {
-        os << ld._normal << " " << ld._mean << " " << ld._sigma;
-        return os;
-    }
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, lognormal_distribution, ld)
-    {
-        is >> ld._normal >> std::ws >> ld._mean >> std::ws >> ld._sigma;
-        ld.init();
-        return is;
-    }
-private:
-    /// \cond show_private
-    void init()
-    {
-        using std::log;
-        using std::sqrt;
-        _nmean = log(_mean*_mean/sqrt(_sigma*_sigma + _mean*_mean));
-        _nsigma = sqrt(log(_sigma*_sigma/_mean/_mean+result_type(1)));
-    }
-    RealType _mean;
-    RealType _sigma;
-    RealType _nmean;
-    RealType _nsigma;
-    normal_distribution<RealType> _normal;
-    /// \endcond
-};
-
-/// \endcond
-
-} // namespace boost
-
-#endif // BOOST_RANDOM_LOGNORMAL_DISTRIBUTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/mersenne_twister.hpp b/contrib/libboost/boost_1_65_0/boost/random/mersenne_twister.hpp
deleted file mode 100644
index ce73e6825f3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/mersenne_twister.hpp
+++ /dev/null
@@ -1,682 +0,0 @@
-/* boost random/mersenne_twister.hpp header file
- *
- * Copyright Jens Maurer 2000-2001
- * Copyright Steven Watanabe 2010
- * 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$
- *
- * Revision history
- *  2013-10-14  fixed some warnings with Wshadow (mgaunard)
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_MERSENNE_TWISTER_HPP
-#define BOOST_RANDOM_MERSENNE_TWISTER_HPP
-
-#include <iosfwd>
-#include <istream>
-#include <stdexcept>
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/integer/integer_mask.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/ptr_helper.hpp>
-#include <boost/random/detail/seed.hpp>
-#include <boost/random/detail/seed_impl.hpp>
-#include <boost/random/detail/generator_seed_seq.hpp>
-#include <boost/random/detail/polynomial.hpp>
-
-#include <boost/random/detail/disable_warnings.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * Instantiations of class template mersenne_twister_engine model a
- * \pseudo_random_number_generator. It uses the algorithm described in
- *
- *  @blockquote
- *  "Mersenne Twister: A 623-dimensionally equidistributed uniform
- *  pseudo-random number generator", Makoto Matsumoto and Takuji Nishimura,
- *  ACM Transactions on Modeling and Computer Simulation: Special Issue on
- *  Uniform Random Number Generation, Vol. 8, No. 1, January 1998, pp. 3-30.
- *  @endblockquote
- *
- * @xmlnote
- * The boost variant has been implemented from scratch and does not
- * derive from or use mt19937.c provided on the above WWW site. However, it
- * was verified that both produce identical output.
- * @endxmlnote
- *
- * The seeding from an integer was changed in April 2005 to address a
- * <a href="http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/emt19937ar.html">weakness</a>.
- *
- * The quality of the generator crucially depends on the choice of the
- * parameters.  User code should employ one of the sensibly parameterized
- * generators such as \mt19937 instead.
- *
- * The generator requires considerable amounts of memory for the storage of
- * its state array. For example, \mt11213b requires about 1408 bytes and
- * \mt19937 requires about 2496 bytes.
- */
-template<class UIntType,
-         std::size_t w, std::size_t n, std::size_t m, std::size_t r,
-         UIntType a, std::size_t u, UIntType d, std::size_t s,
-         UIntType b, std::size_t t,
-         UIntType c, std::size_t l, UIntType f>
-class mersenne_twister_engine
-{
-public:
-    typedef UIntType result_type;
-    BOOST_STATIC_CONSTANT(std::size_t, word_size = w);
-    BOOST_STATIC_CONSTANT(std::size_t, state_size = n);
-    BOOST_STATIC_CONSTANT(std::size_t, shift_size = m);
-    BOOST_STATIC_CONSTANT(std::size_t, mask_bits = r);
-    BOOST_STATIC_CONSTANT(UIntType, xor_mask = a);
-    BOOST_STATIC_CONSTANT(std::size_t, tempering_u = u);
-    BOOST_STATIC_CONSTANT(UIntType, tempering_d = d);
-    BOOST_STATIC_CONSTANT(std::size_t, tempering_s = s);
-    BOOST_STATIC_CONSTANT(UIntType, tempering_b = b);
-    BOOST_STATIC_CONSTANT(std::size_t, tempering_t = t);
-    BOOST_STATIC_CONSTANT(UIntType, tempering_c = c);
-    BOOST_STATIC_CONSTANT(std::size_t, tempering_l = l);
-    BOOST_STATIC_CONSTANT(UIntType, initialization_multiplier = f);
-    BOOST_STATIC_CONSTANT(UIntType, default_seed = 5489u);
-
-    // backwards compatibility
-    BOOST_STATIC_CONSTANT(UIntType, parameter_a = a);
-    BOOST_STATIC_CONSTANT(std::size_t, output_u = u);
-    BOOST_STATIC_CONSTANT(std::size_t, output_s = s);
-    BOOST_STATIC_CONSTANT(UIntType, output_b = b);
-    BOOST_STATIC_CONSTANT(std::size_t, output_t = t);
-    BOOST_STATIC_CONSTANT(UIntType, output_c = c);
-    BOOST_STATIC_CONSTANT(std::size_t, output_l = l);
-
-    // old Boost.Random concept requirements
-    BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
-
-
-    /**
-     * Constructs a @c mersenne_twister_engine and calls @c seed().
-     */
-    mersenne_twister_engine() { seed(); }
-
-    /**
-     * Constructs a @c mersenne_twister_engine and calls @c seed(value).
-     */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(mersenne_twister_engine,
-                                               UIntType, value)
-    { seed(value); }
-    template<class It> mersenne_twister_engine(It& first, It last)
-    { seed(first,last); }
-
-    /**
-     * Constructs a mersenne_twister_engine and calls @c seed(gen).
-     *
-     * @xmlnote
-     * The copy constructor will always be preferred over
-     * the templated constructor.
-     * @endxmlnote
-     */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(mersenne_twister_engine,
-                                             SeedSeq, seq)
-    { seed(seq); }
-
-    // compiler-generated copy ctor and assignment operator are fine
-
-    /** Calls @c seed(default_seed). */
-    void seed() { seed(default_seed); }
-
-    /**
-     * Sets the state x(0) to v mod 2w. Then, iteratively,
-     * sets x(i) to
-     * (i + f * (x(i-1) xor (x(i-1) rshift w-2))) mod 2<sup>w</sup>
-     * for i = 1 .. n-1. x(n) is the first value to be returned by operator().
-     */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(mersenne_twister_engine, UIntType, value)
-    {
-        // New seeding algorithm from
-        // http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/emt19937ar.html
-        // In the previous versions, MSBs of the seed affected only MSBs of the
-        // state x[].
-        const UIntType mask = (max)();
-        x[0] = value & mask;
-        for (i = 1; i < n; i++) {
-            // See Knuth "The Art of Computer Programming"
-            // Vol. 2, 3rd ed., page 106
-            x[i] = (f * (x[i-1] ^ (x[i-1] >> (w-2))) + i) & mask;
-        }
-
-        normalize_state();
-    }
-
-    /**
-     * Seeds a mersenne_twister_engine using values produced by seq.generate().
-     */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(mersenne_twister_engine, SeeqSeq, seq)
-    {
-        detail::seed_array_int<w>(seq, x);
-        i = n;
-
-        normalize_state();
-    }
-
-    /** Sets the state of the generator using values from an iterator range. */
-    template<class It>
-    void seed(It& first, It last)
-    {
-        detail::fill_array_int<w>(first, last, x);
-        i = n;
-
-        normalize_state();
-    }
-
-    /** Returns the smallest value that the generator can produce. */
-    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return 0; }
-    /** Returns the largest value that the generator can produce. */
-    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return boost::low_bits_mask_t<w>::sig_bits; }
-
-    /** Produces the next value of the generator. */
-    result_type operator()();
-
-    /** Fills a range with random values */
-    template<class Iter>
-    void generate(Iter first, Iter last)
-    { detail::generate_from_int(*this, first, last); }
-
-    /**
-     * Advances the state of the generator by @c z steps.  Equivalent to
-     *
-     * @code
-     * for(unsigned long long i = 0; i < z; ++i) {
-     *     gen();
-     * }
-     * @endcode
-     */
-    void discard(boost::uintmax_t z)
-    {
-#ifndef BOOST_RANDOM_MERSENNE_TWISTER_DISCARD_THRESHOLD
-#define BOOST_RANDOM_MERSENNE_TWISTER_DISCARD_THRESHOLD 10000000
-#endif
-        if(z > BOOST_RANDOM_MERSENNE_TWISTER_DISCARD_THRESHOLD) {
-            discard_many(z);
-        } else {
-            for(boost::uintmax_t j = 0; j < z; ++j) {
-                (*this)();
-            }
-        }
-    }
-
-#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
-    /** Writes a mersenne_twister_engine to a @c std::ostream */
-    template<class CharT, class Traits>
-    friend std::basic_ostream<CharT,Traits>&
-    operator<<(std::basic_ostream<CharT,Traits>& os,
-               const mersenne_twister_engine& mt)
-    {
-        mt.print(os);
-        return os;
-    }
-
-    /** Reads a mersenne_twister_engine from a @c std::istream */
-    template<class CharT, class Traits>
-    friend std::basic_istream<CharT,Traits>&
-    operator>>(std::basic_istream<CharT,Traits>& is,
-               mersenne_twister_engine& mt)
-    {
-        for(std::size_t j = 0; j < mt.state_size; ++j)
-            is >> mt.x[j] >> std::ws;
-        // MSVC (up to 7.1) and Borland (up to 5.64) don't handle the template
-        // value parameter "n" available from the class template scope, so use
-        // the static constant with the same value
-        mt.i = mt.state_size;
-        return is;
-    }
-#endif
-
-    /**
-     * Returns true if the two generators are in the same state,
-     * and will thus produce identical sequences.
-     */
-    friend bool operator==(const mersenne_twister_engine& x_,
-                           const mersenne_twister_engine& y_)
-    {
-        if(x_.i < y_.i) return x_.equal_imp(y_);
-        else return y_.equal_imp(x_);
-    }
-
-    /**
-     * Returns true if the two generators are in different states.
-     */
-    friend bool operator!=(const mersenne_twister_engine& x_,
-                           const mersenne_twister_engine& y_)
-    { return !(x_ == y_); }
-
-private:
-    /// \cond show_private
-
-    void twist();
-
-    /**
-     * Does the work of operator==.  This is in a member function
-     * for portability.  Some compilers, such as msvc 7.1 and
-     * Sun CC 5.10 can't access template parameters or static
-     * members of the class from inline friend functions.
-     *
-     * requires i <= other.i
-     */
-    bool equal_imp(const mersenne_twister_engine& other) const
-    {
-        UIntType back[n];
-        std::size_t offset = other.i - i;
-        for(std::size_t j = 0; j + offset < n; ++j)
-            if(x[j] != other.x[j+offset])
-                return false;
-        rewind(&back[n-1], offset);
-        for(std::size_t j = 0; j < offset; ++j)
-            if(back[j + n - offset] != other.x[j])
-                return false;
-        return true;
-    }
-
-    /**
-     * Does the work of operator<<.  This is in a member function
-     * for portability.
-     */
-    template<class CharT, class Traits>
-    void print(std::basic_ostream<CharT, Traits>& os) const
-    {
-        UIntType data[n];
-        for(std::size_t j = 0; j < i; ++j) {
-            data[j + n - i] = x[j];
-        }
-        if(i != n) {
-            rewind(&data[n - i - 1], n - i);
-        }
-        os << data[0];
-        for(std::size_t j = 1; j < n; ++j) {
-            os << ' ' << data[j];
-        }
-    }
-
-    /**
-     * Copies z elements of the state preceding x[0] into
-     * the array whose last element is last.
-     */
-    void rewind(UIntType* last, std::size_t z) const
-    {
-        const UIntType upper_mask = (~static_cast<UIntType>(0)) << r;
-        const UIntType lower_mask = ~upper_mask;
-        UIntType y0 = x[m-1] ^ x[n-1];
-        if(y0 & (static_cast<UIntType>(1) << (w-1))) {
-            y0 = ((y0 ^ a) << 1) | 1;
-        } else {
-            y0 = y0 << 1;
-        }
-        for(std::size_t sz = 0; sz < z; ++sz) {
-            UIntType y1 =
-                rewind_find(last, sz, m-1) ^ rewind_find(last, sz, n-1);
-            if(y1 & (static_cast<UIntType>(1) << (w-1))) {
-                y1 = ((y1 ^ a) << 1) | 1;
-            } else {
-                y1 = y1 << 1;
-            }
-            *(last - sz) = (y0 & upper_mask) | (y1 & lower_mask);
-            y0 = y1;
-        }
-    }
-
-    /**
-     * Converts an arbitrary array into a valid generator state.
-     * First we normalize x[0], so that it contains the same
-     * value we would get by running the generator forwards
-     * and then in reverse.  (The low order r bits are redundant).
-     * Then, if the state consists of all zeros, we set the
-     * high order bit of x[0] to 1.  This function only needs to
-     * be called by seed, since the state transform preserves
-     * this relationship.
-     */
-    void normalize_state()
-    {
-        const UIntType upper_mask = (~static_cast<UIntType>(0)) << r;
-        const UIntType lower_mask = ~upper_mask;
-        UIntType y0 = x[m-1] ^ x[n-1];
-        if(y0 & (static_cast<UIntType>(1) << (w-1))) {
-            y0 = ((y0 ^ a) << 1) | 1;
-        } else {
-            y0 = y0 << 1;
-        }
-        x[0] = (x[0] & upper_mask) | (y0 & lower_mask);
-
-        // fix up the state if it's all zeroes.
-        for(std::size_t j = 0; j < n; ++j) {
-            if(x[j] != 0) return;
-        }
-        x[0] = static_cast<UIntType>(1) << (w-1);
-    }
-
-    /**
-     * Given a pointer to the last element of the rewind array,
-     * and the current size of the rewind array, finds an element
-     * relative to the next available slot in the rewind array.
-     */
-    UIntType
-    rewind_find(UIntType* last, std::size_t size, std::size_t j) const
-    {
-        std::size_t index = (j + n - size + n - 1) % n;
-        if(index < n - size) {
-            return x[index];
-        } else {
-            return *(last - (n - 1 - index));
-        }
-    }
-
-    /**
-     * Optimized algorithm for large jumps.
-     *
-     * Hiroshi Haramoto, Makoto Matsumoto, and Pierre L'Ecuyer. 2008.
-     * A Fast Jump Ahead Algorithm for Linear Recurrences in a Polynomial
-     * Space. In Proceedings of the 5th international conference on
-     * Sequences and Their Applications (SETA '08).
-     * DOI=10.1007/978-3-540-85912-3_26
-     */
-    void discard_many(boost::uintmax_t z)
-    {
-        // Compute the minimal polynomial, phi(t)
-        // This depends only on the transition function,
-        // which is constant.  The characteristic
-        // polynomial is the same as the minimal
-        // polynomial for a maximum period generator
-        // (which should be all specializations of
-        // mersenne_twister.)  Even if it weren't,
-        // the characteristic polynomial is guaranteed
-        // to be a multiple of the minimal polynomial,
-        // which is good enough.
-        detail::polynomial phi = get_characteristic_polynomial();
-
-        // calculate g(t) = t^z % phi(t)
-        detail::polynomial g = mod_pow_x(z, phi);
-
-        // h(s_0, t) = \sum_{i=0}^{2k-1}o(s_i)t^{2k-i-1}
-        detail::polynomial h;
-        const std::size_t num_bits = w*n - r;
-        for(std::size_t j = 0; j < num_bits * 2; ++j) {
-            // Yes, we're advancing the generator state
-            // here, but it doesn't matter because
-            // we're going to overwrite it completely
-            // in reconstruct_state.
-            if(i >= n) twist();
-            h[2*num_bits - j - 1] = x[i++] & UIntType(1);
-        }
-        // g(t)h(s_0, t)
-        detail::polynomial gh = g * h;
-        detail::polynomial result;
-        for(std::size_t j = 0; j <= num_bits; ++j) {
-            result[j] = gh[2*num_bits - j - 1];
-        }
-        reconstruct_state(result);
-    }
-    static detail::polynomial get_characteristic_polynomial()
-    {
-        const std::size_t num_bits = w*n - r;
-        detail::polynomial helper;
-        helper[num_bits - 1] = 1;
-        mersenne_twister_engine tmp;
-        tmp.reconstruct_state(helper);
-        // Skip the first num_bits elements, since we
-        // already know what they are.
-        for(std::size_t j = 0; j < num_bits; ++j) {
-            if(tmp.i >= n) tmp.twist();
-            if(j == num_bits - 1)
-                assert((tmp.x[tmp.i] & 1) == 1);
-            else
-                assert((tmp.x[tmp.i] & 1) == 0);
-            ++tmp.i;
-        }
-        detail::polynomial phi;
-        phi[num_bits] = 1;
-        detail::polynomial next_bits = tmp.as_polynomial(num_bits);
-        for(std::size_t j = 0; j < num_bits; ++j) {
-            int val = next_bits[j] ^ phi[num_bits-j-1];
-            phi[num_bits-j-1] = val;
-            if(val) {
-                for(std::size_t k = j + 1; k < num_bits; ++k) {
-                    phi[num_bits-k-1] ^= next_bits[k-j-1];
-                }
-            }
-        }
-        return phi;
-    }
-    detail::polynomial as_polynomial(std::size_t size) {
-        detail::polynomial result;
-        for(std::size_t j = 0; j < size; ++j) {
-            if(i >= n) twist();
-            result[j] = x[i++] & UIntType(1);
-        }
-        return result;
-    }
-    void reconstruct_state(const detail::polynomial& p)
-    {
-        const UIntType upper_mask = (~static_cast<UIntType>(0)) << r;
-        const UIntType lower_mask = ~upper_mask;
-        const std::size_t num_bits = w*n - r;
-        for(std::size_t j = num_bits - n + 1; j <= num_bits; ++j)
-            x[j % n] = p[j];
-
-        UIntType y0 = 0;
-        for(std::size_t j = num_bits + 1; j >= n - 1; --j) {
-            UIntType y1 = x[j % n] ^ x[(j + m) % n];
-            if(p[j - n + 1])
-                y1 = (y1 ^ a) << UIntType(1) | UIntType(1);
-            else
-                y1 = y1 << UIntType(1);
-            x[(j + 1) % n] = (y0 & upper_mask) | (y1 & lower_mask);
-            y0 = y1;
-        }
-        i = 0;
-    }
-
-    /// \endcond
-
-    // state representation: next output is o(x(i))
-    //   x[0]  ... x[k] x[k+1] ... x[n-1]   represents
-    //  x(i-k) ... x(i) x(i+1) ... x(i-k+n-1)
-
-    UIntType x[n];
-    std::size_t i;
-};
-
-/// \cond show_private
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-//  A definition is required even for integral static constants
-#define BOOST_RANDOM_MT_DEFINE_CONSTANT(type, name)                         \
-template<class UIntType, std::size_t w, std::size_t n, std::size_t m,       \
-    std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s,    \
-    UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f>       \
-const type mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::name
-BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, word_size);
-BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, state_size);
-BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, shift_size);
-BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, mask_bits);
-BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, xor_mask);
-BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, tempering_u);
-BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, tempering_d);
-BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, tempering_s);
-BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, tempering_b);
-BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, tempering_t);
-BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, tempering_c);
-BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, tempering_l);
-BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, initialization_multiplier);
-BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, default_seed);
-BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, parameter_a);
-BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, output_u );
-BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, output_s);
-BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, output_b);
-BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, output_t);
-BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, output_c);
-BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, output_l);
-BOOST_RANDOM_MT_DEFINE_CONSTANT(bool, has_fixed_range);
-#undef BOOST_RANDOM_MT_DEFINE_CONSTANT
-#endif
-
-template<class UIntType,
-         std::size_t w, std::size_t n, std::size_t m, std::size_t r,
-         UIntType a, std::size_t u, UIntType d, std::size_t s,
-         UIntType b, std::size_t t,
-         UIntType c, std::size_t l, UIntType f>
-void
-mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::twist()
-{
-    const UIntType upper_mask = (~static_cast<UIntType>(0)) << r;
-    const UIntType lower_mask = ~upper_mask;
-
-    const std::size_t unroll_factor = 6;
-    const std::size_t unroll_extra1 = (n-m) % unroll_factor;
-    const std::size_t unroll_extra2 = (m-1) % unroll_factor;
-
-    // split loop to avoid costly modulo operations
-    {  // extra scope for MSVC brokenness w.r.t. for scope
-        for(std::size_t j = 0; j < n-m-unroll_extra1; j++) {
-            UIntType y = (x[j] & upper_mask) | (x[j+1] & lower_mask);
-            x[j] = x[j+m] ^ (y >> 1) ^ ((x[j+1]&1) * a);
-        }
-    }
-    {
-        for(std::size_t j = n-m-unroll_extra1; j < n-m; j++) {
-            UIntType y = (x[j] & upper_mask) | (x[j+1] & lower_mask);
-            x[j] = x[j+m] ^ (y >> 1) ^ ((x[j+1]&1) * a);
-        }
-    }
-    {
-        for(std::size_t j = n-m; j < n-1-unroll_extra2; j++) {
-            UIntType y = (x[j] & upper_mask) | (x[j+1] & lower_mask);
-            x[j] = x[j-(n-m)] ^ (y >> 1) ^ ((x[j+1]&1) * a);
-        }
-    }
-    {
-        for(std::size_t j = n-1-unroll_extra2; j < n-1; j++) {
-            UIntType y = (x[j] & upper_mask) | (x[j+1] & lower_mask);
-            x[j] = x[j-(n-m)] ^ (y >> 1) ^ ((x[j+1]&1) * a);
-        }
-    }
-    // last iteration
-    UIntType y = (x[n-1] & upper_mask) | (x[0] & lower_mask);
-    x[n-1] = x[m-1] ^ (y >> 1) ^ ((x[0]&1) * a);
-    i = 0;
-}
-/// \endcond
-
-template<class UIntType,
-         std::size_t w, std::size_t n, std::size_t m, std::size_t r,
-         UIntType a, std::size_t u, UIntType d, std::size_t s,
-         UIntType b, std::size_t t,
-         UIntType c, std::size_t l, UIntType f>
-inline typename
-mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::result_type
-mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::operator()()
-{
-    if(i == n)
-        twist();
-    // Step 4
-    UIntType z = x[i];
-    ++i;
-    z ^= ((z >> u) & d);
-    z ^= ((z << s) & b);
-    z ^= ((z << t) & c);
-    z ^= (z >> l);
-    return z;
-}
-
-/**
- * The specializations \mt11213b and \mt19937 are from
- *
- *  @blockquote
- *  "Mersenne Twister: A 623-dimensionally equidistributed
- *  uniform pseudo-random number generator", Makoto Matsumoto
- *  and Takuji Nishimura, ACM Transactions on Modeling and
- *  Computer Simulation: Special Issue on Uniform Random Number
- *  Generation, Vol. 8, No. 1, January 1998, pp. 3-30.
- *  @endblockquote
- */
-typedef mersenne_twister_engine<uint32_t,32,351,175,19,0xccab8ee7,
-    11,0xffffffff,7,0x31b6ab00,15,0xffe50000,17,1812433253> mt11213b;
-
-/**
- * The specializations \mt11213b and \mt19937 are from
- *
- *  @blockquote
- *  "Mersenne Twister: A 623-dimensionally equidistributed
- *  uniform pseudo-random number generator", Makoto Matsumoto
- *  and Takuji Nishimura, ACM Transactions on Modeling and
- *  Computer Simulation: Special Issue on Uniform Random Number
- *  Generation, Vol. 8, No. 1, January 1998, pp. 3-30.
- *  @endblockquote
- */
-typedef mersenne_twister_engine<uint32_t,32,624,397,31,0x9908b0df,
-    11,0xffffffff,7,0x9d2c5680,15,0xefc60000,18,1812433253> mt19937;
-
-#if !defined(BOOST_NO_INT64_T) && !defined(BOOST_NO_INTEGRAL_INT64_T)
-typedef mersenne_twister_engine<uint64_t,64,312,156,31,
-    UINT64_C(0xb5026f5aa96619e9),29,UINT64_C(0x5555555555555555),17,
-    UINT64_C(0x71d67fffeda60000),37,UINT64_C(0xfff7eee000000000),43,
-    UINT64_C(6364136223846793005)> mt19937_64;
-#endif
-
-/// \cond show_deprecated
-
-template<class UIntType,
-         int w, int n, int m, int r,
-         UIntType a, int u, std::size_t s,
-         UIntType b, int t,
-         UIntType c, int l, UIntType v>
-class mersenne_twister :
-    public mersenne_twister_engine<UIntType,
-        w, n, m, r, a, u, ~(UIntType)0, s, b, t, c, l, 1812433253>
-{
-    typedef mersenne_twister_engine<UIntType,
-        w, n, m, r, a, u, ~(UIntType)0, s, b, t, c, l, 1812433253> base_type;
-public:
-    mersenne_twister() {}
-    BOOST_RANDOM_DETAIL_GENERATOR_CONSTRUCTOR(mersenne_twister, Gen, gen)
-    { seed(gen); }
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(mersenne_twister, UIntType, val)
-    { seed(val); }
-    template<class It>
-    mersenne_twister(It& first, It last) : base_type(first, last) {}
-    void seed() { base_type::seed(); }
-    BOOST_RANDOM_DETAIL_GENERATOR_SEED(mersenne_twister, Gen, gen)
-    {
-        detail::generator_seed_seq<Gen> seq(gen);
-        base_type::seed(seq);
-    }
-    BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(mersenne_twister, UIntType, val)
-    { base_type::seed(val); }
-    template<class It>
-    void seed(It& first, It last) { base_type::seed(first, last); }
-};
-
-/// \endcond
-
-} // namespace random
-
-using random::mt11213b;
-using random::mt19937;
-using random::mt19937_64;
-
-} // namespace boost
-
-BOOST_RANDOM_PTR_HELPER_SPEC(boost::mt11213b)
-BOOST_RANDOM_PTR_HELPER_SPEC(boost::mt19937)
-BOOST_RANDOM_PTR_HELPER_SPEC(boost::mt19937_64)
-
-#include <boost/random/detail/enable_warnings.hpp>
-
-#endif // BOOST_RANDOM_MERSENNE_TWISTER_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/negative_binomial_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/negative_binomial_distribution.hpp
deleted file mode 100644
index cbe26fad25c..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/negative_binomial_distribution.hpp
+++ /dev/null
@@ -1,220 +0,0 @@
-/* boost random/negative_binomial_distribution.hpp header file
- *
- * Copyright Steven Watanabe 2010
- * 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_NEGATIVE_BINOMIAL_DISTRIBUTION_HPP_INCLUDED
-#define BOOST_RANDOM_NEGATIVE_BINOMIAL_DISTRIBUTION_HPP_INCLUDED
-
-#include <iosfwd>
-
-#include <boost/limits.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/gamma_distribution.hpp>
-#include <boost/random/poisson_distribution.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * The negative binomial distribution is an integer valued
- * distribution with two parameters, @c k and @c p.  The
- * distribution produces non-negative values.
- *
- * The distribution function is
- * \f$\displaystyle P(i) = {k+i-1\choose i}p^k(1-p)^i\f$.
- *
- * This implementation uses a gamma-poisson mixture.
- */
-template<class IntType = int, class RealType = double>
-class negative_binomial_distribution {
-public:
-    typedef IntType result_type;
-    typedef RealType input_type;
-
-    class param_type {
-    public:
-        typedef negative_binomial_distribution distribution_type;
-        /**
-         * Construct a param_type object.  @c k and @c p
-         * are the parameters of the distribution.
-         *
-         * Requires: k >=0 && 0 <= p <= 1
-         */
-        explicit param_type(IntType k_arg = 1, RealType p_arg = RealType (0.5))
-          : _k(k_arg), _p(p_arg)
-        {}
-        /** Returns the @c k parameter of the distribution. */
-        IntType k() const { return _k; }
-        /** Returns the @c p parameter of the distribution. */
-        RealType p() const { return _p; }
-#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
-        /** Writes the parameters of the distribution to a @c std::ostream. */
-        template<class CharT, class Traits>
-        friend std::basic_ostream<CharT,Traits>&
-        operator<<(std::basic_ostream<CharT,Traits>& os,
-                   const param_type& parm)
-        {
-            os << parm._p << " " << parm._k;
-            return os;
-        }
-    
-        /** Reads the parameters of the distribution from a @c std::istream. */
-        template<class CharT, class Traits>
-        friend std::basic_istream<CharT,Traits>&
-        operator>>(std::basic_istream<CharT,Traits>& is, param_type& parm)
-        {
-            is >> parm._p >> std::ws >> parm._k;
-            return is;
-        }
-#endif
-        /** Returns true if the parameters have the same values. */
-        friend bool operator==(const param_type& lhs, const param_type& rhs)
-        {
-            return lhs._k == rhs._k && lhs._p == rhs._p;
-        }
-        /** Returns true if the parameters have different values. */
-        friend bool operator!=(const param_type& lhs, const param_type& rhs)
-        {
-            return !(lhs == rhs);
-        }
-    private:
-        IntType _k;
-        RealType _p;
-    };
-    
-    /**
-     * Construct a @c negative_binomial_distribution object. @c k and @c p
-     * are the parameters of the distribution.
-     *
-     * Requires: k >=0 && 0 <= p <= 1
-     */
-    explicit negative_binomial_distribution(IntType k_arg = 1,
-                                            RealType p_arg = RealType(0.5))
-      : _k(k_arg), _p(p_arg)
-    {}
-    
-    /**
-     * Construct an @c negative_binomial_distribution object from the
-     * parameters.
-     */
-    explicit negative_binomial_distribution(const param_type& parm)
-      : _k(parm.k()), _p(parm.p())
-    {}
-    
-    /**
-     * Returns a random variate distributed according to the
-     * negative binomial distribution.
-     */
-    template<class URNG>
-    IntType operator()(URNG& urng) const
-    {
-        gamma_distribution<RealType> gamma(_k, (1-_p)/_p);
-        poisson_distribution<IntType, RealType> poisson(gamma(urng));
-        return poisson(urng);
-    }
-    
-    /**
-     * Returns a random variate distributed according to the negative
-     * binomial distribution with parameters specified by @c param.
-     */
-    template<class URNG>
-    IntType operator()(URNG& urng, const param_type& parm) const
-    {
-        return negative_binomial_distribution(parm)(urng);
-    }
-
-    /** Returns the @c k parameter of the distribution. */
-    IntType k() const { return _k; }
-    /** Returns the @c p parameter of the distribution. */
-    RealType p() const { return _p; }
-
-    /** Returns the smallest value that the distribution can produce. */
-    IntType min BOOST_PREVENT_MACRO_SUBSTITUTION() const { return 0; }
-    /** Returns the largest value that the distribution can produce. */
-    IntType max BOOST_PREVENT_MACRO_SUBSTITUTION() const
-    { return (std::numeric_limits<IntType>::max)(); }
-
-    /** Returns the parameters of the distribution. */
-    param_type param() const { return param_type(_k, _p); }
-    /** Sets parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        _k = parm.k();
-        _p = parm.p();
-    }
-
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { }
-
-#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
-    /** Writes the parameters of the distribution to a @c std::ostream. */
-    template<class CharT, class Traits>
-    friend std::basic_ostream<CharT,Traits>&
-    operator<<(std::basic_ostream<CharT,Traits>& os,
-               const negative_binomial_distribution& bd)
-    {
-        os << bd.param();
-        return os;
-    }
-    
-    /** Reads the parameters of the distribution from a @c std::istream. */
-    template<class CharT, class Traits>
-    friend std::basic_istream<CharT,Traits>&
-    operator>>(std::basic_istream<CharT,Traits>& is,
-               negative_binomial_distribution& bd)
-    {
-        bd.read(is);
-        return is;
-    }
-#endif
-
-    /** Returns true if the two distributions will produce the same
-        sequence of values, given equal generators. */
-    friend bool operator==(const negative_binomial_distribution& lhs,
-                           const negative_binomial_distribution& rhs)
-    {
-        return lhs._k == rhs._k && lhs._p == rhs._p;
-    }
-    /** Returns true if the two distributions could produce different
-        sequences of values, given equal generators. */
-    friend bool operator!=(const negative_binomial_distribution& lhs,
-                           const negative_binomial_distribution& rhs)
-    {
-        return !(lhs == rhs);
-    }
-
-private:
-
-    /// @cond \show_private
-
-    template<class CharT, class Traits>
-    void read(std::basic_istream<CharT, Traits>& is) {
-        param_type parm;
-        if(is >> parm) {
-            param(parm);
-        }
-    }
-
-    // parameters
-    IntType _k;
-    RealType _p;
-
-    /// @endcond
-};
-
-}
-
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/random/non_central_chi_squared_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/non_central_chi_squared_distribution.hpp
deleted file mode 100644
index 28c9ff6d9a4..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/non_central_chi_squared_distribution.hpp
+++ /dev/null
@@ -1,221 +0,0 @@
-/* boost random/non_central_chi_squared_distribution.hpp header file
- *
- * Copyright Thijs van den Berg 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 including documentation.
- *
- * $Id$
- */
-
-#ifndef BOOST_RANDOM_NON_CENTRAL_CHI_SQUARED_DISTRIBUTION_HPP
-#define BOOST_RANDOM_NON_CENTRAL_CHI_SQUARED_DISTRIBUTION_HPP
-
-#include <boost/config/no_tr1/cmath.hpp>
-#include <iosfwd>
-#include <istream>
-#include <boost/limits.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/uniform_real_distribution.hpp>
-#include <boost/random/normal_distribution.hpp>
-#include <boost/random/chi_squared_distribution.hpp>
-#include <boost/random/poisson_distribution.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * The noncentral chi-squared distribution is a real valued distribution with
- * two parameter, @c k and @c lambda.  The distribution produces values > 0.
- *
- * This is the distribution of the sum of squares of k Normal distributed
- * variates each with variance one and \f$\lambda\f$ the sum of squares of the
- * normal means.
- *
- * The distribution function is
- * \f$\displaystyle P(x) = \frac{1}{2} e^{-(x+\lambda)/2} \left( \frac{x}{\lambda} \right)^{k/4-1/2} I_{k/2-1}( \sqrt{\lambda x} )\f$.
- *  where  \f$\displaystyle I_\nu(z)\f$ is a modified Bessel function of the
- * first kind.
- *
- * The algorithm is taken from
- *
- *  @blockquote
- *  "Monte Carlo Methods in Financial Engineering", Paul Glasserman,
- *  2003, XIII, 596 p, Stochastic Modelling and Applied Probability, Vol. 53,
- *  ISBN 978-0-387-21617-1, p 124, Fig. 3.5.
- *  @endblockquote
- */
-template <typename RealType = double>
-class non_central_chi_squared_distribution {
-public:
-    typedef RealType result_type;
-    typedef RealType input_type;
-    
-    class param_type {
-    public:
-        typedef non_central_chi_squared_distribution distribution_type;
-        
-        /**
-         * Constructs the parameters of a non_central_chi_squared_distribution.
-         * @c k and @c lambda are the parameter of the distribution.
-         *
-         * Requires: k > 0 && lambda > 0
-         */
-        explicit
-        param_type(RealType k_arg = RealType(1), RealType lambda_arg = RealType(1))
-        : _k(k_arg), _lambda(lambda_arg)
-        {
-            BOOST_ASSERT(k_arg > RealType(0));
-            BOOST_ASSERT(lambda_arg > RealType(0));
-        }
-        
-        /** Returns the @c k parameter of the distribution */
-        RealType k() const { return _k; }
-        
-        /** Returns the @c lambda parameter of the distribution */
-        RealType lambda() const { return _lambda; }
-
-        /** Writes the parameters of the distribution to a @c std::ostream. */
-        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
-        {
-            os << parm._k << ' ' << parm._lambda;
-            return os;
-        }
-        
-        /** Reads the parameters of the distribution from a @c std::istream. */
-        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
-        {
-            is >> parm._k >> std::ws >> parm._lambda;
-            return is;
-        }
-
-        /** Returns true if the parameters have the same values. */
-        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        { return lhs._k == rhs._k && lhs._lambda == rhs._lambda; }
-        
-        /** Returns true if the parameters have different values. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-        
-    private:
-        RealType _k;
-        RealType _lambda;
-    };
-
-    /**
-     * Construct a @c non_central_chi_squared_distribution object. @c k and
-     * @c lambda are the parameter of the distribution.
-     *
-     * Requires: k > 0 && lambda > 0
-     */
-    explicit
-    non_central_chi_squared_distribution(RealType k_arg = RealType(1), RealType lambda_arg = RealType(1))
-      : _param(k_arg, lambda_arg)
-    {
-        BOOST_ASSERT(k_arg > RealType(0));
-        BOOST_ASSERT(lambda_arg > RealType(0));
-    }
-
-    /**
-     * Construct a @c non_central_chi_squared_distribution object from the parameter.
-     */
-    explicit
-    non_central_chi_squared_distribution(const param_type& parm)
-      : _param( parm )
-    { }
-    
-    /**
-     * Returns a random variate distributed according to the
-     * non central chi squared distribution specified by @c param.
-     */
-    template<typename URNG>
-    RealType operator()(URNG& eng, const param_type& parm) const
-    { return non_central_chi_squared_distribution(parm)(eng); }
-    
-    /**
-     * Returns a random variate distributed according to the
-     * non central chi squared distribution.
-     */
-    template<typename URNG> 
-    RealType operator()(URNG& eng) 
-    {
-        using std::sqrt;
-        if (_param.k() > 1) {
-            boost::random::normal_distribution<RealType> n_dist;
-            boost::random::chi_squared_distribution<RealType> c_dist(_param.k() - RealType(1));
-            RealType _z = n_dist(eng);
-            RealType _x = c_dist(eng);
-            RealType term1 = _z + sqrt(_param.lambda());
-            return term1*term1 + _x;
-        }
-        else {
-            boost::random::poisson_distribution<> p_dist(_param.lambda()/RealType(2));
-            boost::random::poisson_distribution<>::result_type _p = p_dist(eng);
-            boost::random::chi_squared_distribution<RealType> c_dist(_param.k() + RealType(2)*_p);
-            return c_dist(eng);
-        }
-    }
-
-    /** Returns the @c k parameter of the distribution. */
-    RealType k() const { return _param.k(); }
-    
-    /** Returns the @c lambda parameter of the distribution. */
-    RealType lambda() const { return _param.lambda(); }
-    
-    /** Returns the parameters of the distribution. */
-    param_type param() const { return _param; }
-    
-    /** Sets parameters of the distribution. */
-    void param(const param_type& parm) { _param = parm; }
-    
-    /** Resets the distribution, so that subsequent uses does not depend on values already produced by it.*/
-    void reset() {}
-    
-    /** Returns the smallest value that the distribution can produce. */
-    RealType min BOOST_PREVENT_MACRO_SUBSTITUTION() const
-    { return RealType(0); }
-    
-    /** Returns the largest value that the distribution can produce. */
-    RealType max BOOST_PREVENT_MACRO_SUBSTITUTION() const
-    { return (std::numeric_limits<RealType>::infinity)(); }
-
-    /** Writes the parameters of the distribution to a @c std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, non_central_chi_squared_distribution, dist)
-    {
-        os << dist.param();
-        return os;
-    }
-    
-    /** reads the parameters of the distribution from a @c std::istream. */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, non_central_chi_squared_distribution, dist)
-    {
-        param_type parm;
-        if(is >> parm) {
-            dist.param(parm);
-        }
-        return is;
-    }
-
-    /** Returns true if two distributions have the same parameters and produce 
-        the same sequence of random numbers given equal generators.*/
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(non_central_chi_squared_distribution, lhs, rhs)
-    { return lhs.param() == rhs.param(); }
-    
-    /** Returns true if two distributions have different parameters and/or can produce 
-       different sequences of random numbers given equal generators.*/
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(non_central_chi_squared_distribution)
-    
-private:
-
-    /// @cond show_private
-    param_type  _param;
-    /// @endcond
-};
-
-} // namespace random
-} // namespace boost
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/random/normal_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/normal_distribution.hpp
deleted file mode 100644
index b7ff3eba9b6..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/normal_distribution.hpp
+++ /dev/null
@@ -1,374 +0,0 @@
-/* boost random/normal_distribution.hpp header file
- *
- * Copyright Jens Maurer 2000-2001
- * Copyright Steven Watanabe 2010-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$
- *
- * Revision history
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_NORMAL_DISTRIBUTION_HPP
-#define BOOST_RANDOM_NORMAL_DISTRIBUTION_HPP
-
-#include <boost/config/no_tr1/cmath.hpp>
-#include <istream>
-#include <iosfwd>
-#include <boost/assert.hpp>
-#include <boost/limits.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/detail/int_float_pair.hpp>
-#include <boost/random/uniform_01.hpp>
-#include <boost/random/exponential_distribution.hpp>
-
-namespace boost {
-namespace random {
-
-namespace detail {
-
-// tables for the ziggurat algorithm
-template<class RealType>
-struct normal_table {
-    static const RealType table_x[129];
-    static const RealType table_y[129];
-};
-
-template<class RealType>
-const RealType normal_table<RealType>::table_x[129] = {
-    3.7130862467403632609, 3.4426198558966521214, 3.2230849845786185446, 3.0832288582142137009,
-    2.9786962526450169606, 2.8943440070186706210, 2.8231253505459664379, 2.7611693723841538514,
-    2.7061135731187223371, 2.6564064112581924999, 2.6109722484286132035, 2.5690336259216391328,
-    2.5300096723854666170, 2.4934545220919507609, 2.4590181774083500943, 2.4264206455302115930,
-    2.3954342780074673425, 2.3658713701139875435, 2.3375752413355307354, 2.3104136836950021558,
-    2.2842740596736568056, 2.2590595738653295251, 2.2346863955870569803, 2.2110814088747278106,
-    2.1881804320720206093, 2.1659267937448407377, 2.1442701823562613518, 2.1231657086697899595,
-    2.1025731351849988838, 2.0824562379877246441, 2.0627822745039633575, 2.0435215366506694976,
-    2.0246469733729338782, 2.0061338699589668403, 1.9879595741230607243, 1.9701032608497132242,
-    1.9525457295488889058, 1.9352692282919002011, 1.9182573008597320303, 1.9014946531003176140,
-    1.8849670357028692380, 1.8686611409895420085, 1.8525645117230870617, 1.8366654602533840447,
-    1.8209529965910050740, 1.8054167642140487420, 1.7900469825946189862, 1.7748343955807692457,
-    1.7597702248942318749, 1.7448461281083765085, 1.7300541605582435350, 1.7153867407081165482,
-    1.7008366185643009437, 1.6863968467734863258, 1.6720607540918522072, 1.6578219209482075462,
-    1.6436741568569826489, 1.6296114794646783962, 1.6156280950371329644, 1.6017183802152770587,
-    1.5878768648844007019, 1.5740982160167497219, 1.5603772223598406870, 1.5467087798535034608,
-    1.5330878776675560787, 1.5195095847593707806, 1.5059690368565502602, 1.4924614237746154081,
-    1.4789819769830978546, 1.4655259573357946276, 1.4520886428822164926, 1.4386653166774613138,
-    1.4252512545068615734, 1.4118417124397602509, 1.3984319141236063517, 1.3850170377251486449,
-    1.3715922024197322698, 1.3581524543224228739, 1.3446927517457130432, 1.3312079496576765017,
-    1.3176927832013429910, 1.3041418501204215390, 1.2905495919178731508, 1.2769102735516997175,
-    1.2632179614460282310, 1.2494664995643337480, 1.2356494832544811749, 1.2217602305309625678,
-    1.2077917504067576028, 1.1937367078237721994, 1.1795873846544607035, 1.1653356361550469083,
-    1.1509728421389760651, 1.1364898520030755352, 1.1218769225722540661, 1.1071236475235353980,
-    1.0922188768965537614, 1.0771506248819376573, 1.0619059636836193998, 1.0464709007525802629,
-    1.0308302360564555907, 1.0149673952392994716, 0.99886423348064351303, 0.98250080350276038481,
-    0.96585507938813059489, 0.94890262549791195381, 0.93161619660135381056, 0.91396525100880177644,
-    0.89591535256623852894, 0.87742742909771569142, 0.85845684317805086354, 0.83895221428120745572,
-    0.81885390668331772331, 0.79809206062627480454, 0.77658398787614838598, 0.75423066443451007146,
-    0.73091191062188128150, 0.70647961131360803456, 0.68074791864590421664, 0.65347863871504238702,
-    0.62435859730908822111, 0.59296294244197797913, 0.55869217837551797140, 0.52065603872514491759,
-    0.47743783725378787681, 0.42654798630330512490, 0.36287143102841830424, 0.27232086470466385065,
-    0
-};
-
-template<class RealType>
-const RealType normal_table<RealType>::table_y[129] = {
-    0, 0.0026696290839025035092, 0.0055489952208164705392, 0.0086244844129304709682,
-    0.011839478657982313715, 0.015167298010672042468, 0.018592102737165812650, 0.022103304616111592615,
-    0.025693291936149616572, 0.029356317440253829618, 0.033087886146505155566, 0.036884388786968774128,
-    0.040742868074790604632, 0.044660862200872429800, 0.048636295860284051878, 0.052667401903503169793,
-    0.056752663481538584188, 0.060890770348566375972, 0.065080585213631873753, 0.069321117394180252601,
-    0.073611501884754893389, 0.077950982514654714188, 0.082338898242957408243, 0.086774671895542968998,
-    0.091257800827634710201, 0.09578784912257815216, 0.10036444102954554013, 0.10498725541035453978,
-    0.10965602101581776100, 0.11437051244988827452, 0.11913054670871858767, 0.12393598020398174246,
-    0.12878670619710396109, 0.13368265258464764118, 0.13862377998585103702, 0.14361008009193299469,
-    0.14864157424369696566, 0.15371831220958657066, 0.15884037114093507813, 0.16400785468492774791,
-    0.16922089223892475176, 0.17447963833240232295, 0.17978427212496211424, 0.18513499701071343216,
-    0.19053204032091372112, 0.19597565311811041399, 0.20146611007620324118, 0.20700370944187380064,
-    0.21258877307373610060, 0.21822164655637059599, 0.22390269938713388747, 0.22963232523430270355,
-    0.23541094226572765600, 0.24123899354775131610, 0.24711694751469673582, 0.25304529850976585934,
-    0.25902456739871074263, 0.26505530225816194029, 0.27113807914102527343, 0.27727350292189771153,
-    0.28346220822601251779, 0.28970486044581049771, 0.29600215684985583659, 0.30235482778947976274,
-    0.30876363800925192282, 0.31522938806815752222, 0.32175291587920862031, 0.32833509837615239609,
-    0.33497685331697116147, 0.34167914123501368412, 0.34844296754987246935, 0.35526938485154714435,
-    0.36215949537303321162, 0.36911445366827513952, 0.37613546951445442947, 0.38322381105988364587,
-    0.39038080824138948916, 0.39760785649804255208, 0.40490642081148835099, 0.41227804010702462062,
-    0.41972433205403823467, 0.42724699830956239880, 0.43484783025466189638, 0.44252871528024661483,
-    0.45029164368692696086, 0.45813871627287196483, 0.46607215269457097924, 0.47409430069824960453,
-    0.48220764633483869062, 0.49041482528932163741, 0.49871863547658432422, 0.50712205108130458951,
-    0.51562823824987205196, 0.52424057267899279809, 0.53296265938998758838, 0.54179835503172412311,
-    0.55075179312105527738, 0.55982741271069481791, 0.56902999107472161225, 0.57836468112670231279,
-    0.58783705444182052571, 0.59745315095181228217, 0.60721953663260488551, 0.61714337082656248870,
-    0.62723248525781456578, 0.63749547734314487428, 0.64794182111855080873, 0.65858200005865368016,
-    0.66942766735770616891, 0.68049184100641433355, 0.69178914344603585279, 0.70333609902581741633,
-    0.71515150742047704368, 0.72725691835450587793, 0.73967724368333814856, 0.75244155918570380145,
-    0.76558417390923599480, 0.77914608594170316563, 0.79317701178385921053, 0.80773829469612111340,
-    0.82290721139526200050, 0.83878360531064722379, 0.85550060788506428418, 0.87324304892685358879,
-    0.89228165080230272301, 0.91304364799203805999, 0.93628268170837107547, 0.96359969315576759960,
-    1
-};
-
-
-template<class RealType = double>
-struct unit_normal_distribution
-{
-    template<class Engine>
-    RealType operator()(Engine& eng) {
-        const double * const table_x = normal_table<double>::table_x;
-        const double * const table_y = normal_table<double>::table_y;
-        for(;;) {
-            std::pair<RealType, int> vals = generate_int_float_pair<RealType, 8>(eng);
-            int i = vals.second;
-            int sign = (i & 1) * 2 - 1;
-            i = i >> 1;
-            RealType x = vals.first * RealType(table_x[i]);
-            if(x < table_x[i + 1]) return x * sign;
-            if(i == 0) return generate_tail(eng) * sign;
-
-            RealType y01 = uniform_01<RealType>()(eng);
-            RealType y = RealType(table_y[i]) + y01 * RealType(table_y[i + 1] - table_y[i]);
-
-            // These store the value y - bound, or something proportional to that difference:
-            RealType y_above_ubound, y_above_lbound;
-
-            // There are three cases to consider:
-            // - convex regions (where x[i] > x[j] >= 1)
-            // - concave regions (where 1 <= x[i] < x[j])
-            // - region containing the inflection point (where x[i] > 1 > x[j])
-            // For convex (concave), exp^(-x^2/2) is bounded below (above) by the tangent at
-            // (x[i],y[i]) and is bounded above (below) by the diagonal line from (x[i+1],y[i+1]) to
-            // (x[i],y[i]).
-            //
-            // *If* the inflection point region satisfies slope(x[i+1]) < slope(diagonal), then we
-            // can treat the inflection region as a convex region: this condition is necessary and
-            // sufficient to ensure that the curve lies entirely below the diagonal (that, in turn,
-            // also implies that it will be above the tangent at x[i]).
-            //
-            // For the current table size (128), this is satisfied: slope(x[i+1]) = -0.60653 <
-            // slope(diag) = -0.60649, and so we have only two cases below instead of three.
-
-            if (table_x[i] >= 1) { // convex (incl. inflection)
-                y_above_ubound = RealType(table_x[i] - table_x[i+1]) * y01 - (RealType(table_x[i]) - x);
-                y_above_lbound = y - (RealType(table_y[i]) + (RealType(table_x[i]) - x) * RealType(table_y[i]) * RealType(table_x[i]));
-            }
-            else { // concave
-                y_above_lbound = RealType(table_x[i] - table_x[i+1]) * y01 - (RealType(table_x[i]) - x);
-                y_above_ubound = y - (RealType(table_y[i]) + (RealType(table_x[i]) - x) * RealType(table_y[i]) * RealType(table_x[i]));
-            }
-
-            if (y_above_ubound < 0 // if above the upper bound reject immediately
-                    &&
-                    (
-                     y_above_lbound < 0 // If below the lower bound accept immediately
-                     ||
-                     y < f(x) // Otherwise it's between the bounds and we need a full check
-                    )
-               ) {
-                return x * sign;
-            }
-        }
-    }
-    static RealType f(RealType x) {
-        using std::exp;
-        return exp(-(x*x/2));
-    }
-    // Generate from the tail using rejection sampling from the exponential(x_1) distribution,
-    // shifted by x_1.  This looks a little different from the usual rejection sampling because it
-    // transforms the condition by taking the log of both sides, thus avoiding the costly exp() call
-    // on the RHS, then takes advantage of the fact that -log(unif01) is simply generating an
-    // exponential (by inverse cdf sampling) by replacing the log(unif01) on the LHS with a
-    // exponential(1) draw, y.
-    template<class Engine>
-    RealType generate_tail(Engine& eng) {
-        const RealType tail_start = RealType(normal_table<double>::table_x[1]);
-        boost::random::exponential_distribution<RealType> exp_x(tail_start);
-        boost::random::exponential_distribution<RealType> exp_y;
-        for(;;) {
-            RealType x = exp_x(eng);
-            RealType y = exp_y(eng);
-            // If we were doing non-transformed rejection sampling, this condition would be:
-            // if (unif01 < exp(-.5*x*x)) return x + tail_start;
-            if(2*y > x*x) return x + tail_start;
-        }
-    }
-};
-
-} // namespace detail
-
-
-/**
- * Instantiations of class template normal_distribution model a
- * \random_distribution. Such a distribution produces random numbers
- * @c x distributed with probability density function
- * \f$\displaystyle p(x) =
- *   \frac{1}{\sqrt{2\pi}\sigma} e^{-\frac{(x-\mu)^2}{2\sigma^2}}
- * \f$,
- * where mean and sigma are the parameters of the distribution.
- *
- * The implementation uses the "ziggurat" algorithm, as described in
- *
- *  @blockquote
- *  "The Ziggurat Method for Generating Random Variables",
- *  George Marsaglia and Wai Wan Tsang, Journal of Statistical Software,
- *  Volume 5, Number 8 (2000), 1-7.
- *  @endblockquote
- */
-template<class RealType = double>
-class normal_distribution
-{
-public:
-    typedef RealType input_type;
-    typedef RealType result_type;
-
-    class param_type {
-    public:
-        typedef normal_distribution distribution_type;
-
-        /**
-         * Constructs a @c param_type with a given mean and
-         * standard deviation.
-         *
-         * Requires: sigma >= 0
-         */
-        explicit param_type(RealType mean_arg = RealType(0.0),
-                            RealType sigma_arg = RealType(1.0))
-          : _mean(mean_arg),
-            _sigma(sigma_arg)
-        {}
-
-        /** Returns the mean of the distribution. */
-        RealType mean() const { return _mean; }
-
-        /** Returns the standand deviation of the distribution. */
-        RealType sigma() const { return _sigma; }
-
-        /** Writes a @c param_type to a @c std::ostream. */
-        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
-        { os << parm._mean << " " << parm._sigma ; return os; }
-
-        /** Reads a @c param_type from a @c std::istream. */
-        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
-        { is >> parm._mean >> std::ws >> parm._sigma; return is; }
-
-        /** Returns true if the two sets of parameters are the same. */
-        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        { return lhs._mean == rhs._mean && lhs._sigma == rhs._sigma; }
-        
-        /** Returns true if the two sets of parameters are the different. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-
-    private:
-        RealType _mean;
-        RealType _sigma;
-    };
-
-    /**
-     * Constructs a @c normal_distribution object. @c mean and @c sigma are
-     * the parameters for the distribution.
-     *
-     * Requires: sigma >= 0
-     */
-    explicit normal_distribution(const RealType& mean_arg = RealType(0.0),
-                                 const RealType& sigma_arg = RealType(1.0))
-      : _mean(mean_arg), _sigma(sigma_arg)
-    {
-        BOOST_ASSERT(_sigma >= RealType(0));
-    }
-
-    /**
-     * Constructs a @c normal_distribution object from its parameters.
-     */
-    explicit normal_distribution(const param_type& parm)
-      : _mean(parm.mean()), _sigma(parm.sigma())
-    {}
-
-    /**  Returns the mean of the distribution. */
-    RealType mean() const { return _mean; }
-    /** Returns the standard deviation of the distribution. */
-    RealType sigma() const { return _sigma; }
-
-    /** 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(_mean, _sigma); }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        _mean = parm.mean();
-        _sigma = parm.sigma();
-    }
-
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { }
-
-    /**  Returns a normal variate. */
-    template<class Engine>
-    result_type operator()(Engine& eng)
-    {
-        detail::unit_normal_distribution<RealType> impl;
-        return impl(eng) * _sigma + _mean;
-    }
-
-    /** Returns a normal variate with parameters specified by @c param. */
-    template<class URNG>
-    result_type operator()(URNG& urng, const param_type& parm)
-    {
-        return normal_distribution(parm)(urng);
-    }
-
-    /** Writes a @c normal_distribution to a @c std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, normal_distribution, nd)
-    {
-        os << nd._mean << " " << nd._sigma;
-        return os;
-    }
-
-    /** Reads a @c normal_distribution from a @c std::istream. */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, normal_distribution, nd)
-    {
-        is >> std::ws >> nd._mean >> std::ws >> nd._sigma;
-        return is;
-    }
-
-    /**
-     * Returns true if the two instances of @c normal_distribution will
-     * return identical sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(normal_distribution, lhs, rhs)
-    {
-        return lhs._mean == rhs._mean && lhs._sigma == rhs._sigma;
-    }
-
-    /**
-     * Returns true if the two instances of @c normal_distribution will
-     * return different sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(normal_distribution)
-
-private:
-    RealType _mean, _sigma;
-
-};
-
-} // namespace random
-
-using random::normal_distribution;
-
-} // namespace boost
-
-#endif // BOOST_RANDOM_NORMAL_DISTRIBUTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/piecewise_constant_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/piecewise_constant_distribution.hpp
deleted file mode 100644
index 488f41c0e34..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/piecewise_constant_distribution.hpp
+++ /dev/null
@@ -1,466 +0,0 @@
-/* boost random/piecewise_constant_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_PIECEWISE_CONSTANT_DISTRIBUTION_HPP_INCLUDED
-#define BOOST_RANDOM_PIECEWISE_CONSTANT_DISTRIBUTION_HPP_INCLUDED
-
-#include <vector>
-#include <numeric>
-#include <boost/assert.hpp>
-#include <boost/random/uniform_real.hpp>
-#include <boost/random/discrete_distribution.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/detail/vector_io.hpp>
-
-#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
-#include <initializer_list>
-#endif
-
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * The class @c piecewise_constant_distribution models a \random_distribution.
- */
-template<class RealType = double, class WeightType = double>
-class piecewise_constant_distribution {
-public:
-    typedef std::size_t input_type;
-    typedef RealType result_type;
-
-    class param_type {
-    public:
-
-        typedef piecewise_constant_distribution distribution_type;
-
-        /**
-         * Constructs a @c param_type object, representing a distribution
-         * that produces values uniformly distributed in the range [0, 1).
-         */
-        param_type()
-        {
-            _weights.push_back(WeightType(1));
-            _intervals.push_back(RealType(0));
-            _intervals.push_back(RealType(1));
-        }
-        /**
-         * Constructs a @c param_type object from two iterator ranges
-         * containing the interval boundaries and the interval weights.
-         * If there are less than two boundaries, then this is equivalent to
-         * the default constructor and creates a single interval, [0, 1).
-         *
-         * The values of the interval boundaries must be strictly
-         * increasing, and the number of weights must be one less than
-         * the number of interval boundaries.  If there are extra
-         * weights, they are ignored.
-         */
-        template<class IntervalIter, class WeightIter>
-        param_type(IntervalIter intervals_first, IntervalIter intervals_last,
-                   WeightIter weight_first)
-          : _intervals(intervals_first, intervals_last)
-        {
-            if(_intervals.size() < 2) {
-                _intervals.clear();
-                _intervals.push_back(RealType(0));
-                _intervals.push_back(RealType(1));
-                _weights.push_back(WeightType(1));
-            } else {
-                _weights.reserve(_intervals.size() - 1);
-                for(std::size_t i = 0; i < _intervals.size() - 1; ++i) {
-                    _weights.push_back(*weight_first++);
-                }
-            }
-        }
-#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
-        /**
-         * Constructs a @c param_type object from an
-         * initializer_list containing the interval boundaries
-         * and a unary function specifying the weights.  Each
-         * weight is determined by calling the function at the
-         * midpoint of the corresponding interval.
-         *
-         * If the initializer_list contains less than two elements,
-         * this is equivalent to the default constructor and the
-         * distribution will produce values uniformly distributed
-         * in the range [0, 1).
-         */
-        template<class T, class F>
-        param_type(const std::initializer_list<T>& il, F f)
-          : _intervals(il.begin(), il.end())
-        {
-            if(_intervals.size() < 2) {
-                _intervals.clear();
-                _intervals.push_back(RealType(0));
-                _intervals.push_back(RealType(1));
-                _weights.push_back(WeightType(1));
-            } else {
-                _weights.reserve(_intervals.size() - 1);
-                for(std::size_t i = 0; i < _intervals.size() - 1; ++i) {
-                    RealType midpoint = (_intervals[i] + _intervals[i + 1]) / 2;
-                    _weights.push_back(f(midpoint));
-                }
-            }
-        }
-#endif
-        /**
-         * Constructs a @c param_type object from Boost.Range
-         * ranges holding the interval boundaries and the weights.  If
-         * there are less than two interval boundaries, this is equivalent
-         * to the default constructor and the distribution will produce
-         * values uniformly distributed in the range [0, 1).  The
-         * number of weights must be one less than the number of
-         * interval boundaries.
-         */
-        template<class IntervalRange, class WeightRange>
-        param_type(const IntervalRange& intervals_arg,
-                   const WeightRange& weights_arg)
-          : _intervals(boost::begin(intervals_arg), boost::end(intervals_arg)),
-            _weights(boost::begin(weights_arg), boost::end(weights_arg))
-        {
-            if(_intervals.size() < 2) {
-                _intervals.clear();
-                _intervals.push_back(RealType(0));
-                _intervals.push_back(RealType(1));
-                _weights.push_back(WeightType(1));
-            }
-        }
-
-        /**
-         * Constructs the parameters for a distribution that approximates a
-         * function.  The range of the distribution is [xmin, xmax).  This
-         * range is divided into nw equally sized intervals and the weights
-         * are found by calling the unary function f on the midpoints of the
-         * intervals.
-         */
-        template<class F>
-        param_type(std::size_t nw, RealType xmin, RealType xmax, F f)
-        {
-            std::size_t n = (nw == 0) ? 1 : nw;
-            double delta = (xmax - xmin) / n;
-            BOOST_ASSERT(delta > 0);
-            for(std::size_t k = 0; k < n; ++k) {
-                _weights.push_back(f(xmin + k*delta + delta/2));
-                _intervals.push_back(xmin + k*delta);
-            }
-            _intervals.push_back(xmax);
-        }
-
-        /**  Returns a vector containing the interval boundaries. */
-        std::vector<RealType> intervals() const { return _intervals; }
-
-        /**
-         * Returns a vector containing the probability densities
-         * over all the intervals of the distribution.
-         */
-        std::vector<RealType> densities() const
-        {
-            RealType sum = std::accumulate(_weights.begin(), _weights.end(),
-                                             static_cast<RealType>(0));
-            std::vector<RealType> result;
-            result.reserve(_weights.size());
-            for(std::size_t i = 0; i < _weights.size(); ++i) {
-                RealType width = _intervals[i + 1] - _intervals[i];
-                result.push_back(_weights[i] / (sum * width));
-            }
-            return result;
-        }
-
-        /** Writes the parameters to a @c std::ostream. */
-        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
-        {
-            detail::print_vector(os, parm._intervals);
-            detail::print_vector(os, parm._weights);
-            return os;
-        }
-        
-        /** Reads the parameters from a @c std::istream. */
-        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
-        {
-            std::vector<RealType> new_intervals;
-            std::vector<WeightType> new_weights;
-            detail::read_vector(is, new_intervals);
-            detail::read_vector(is, new_weights);
-            if(is) {
-                parm._intervals.swap(new_intervals);
-                parm._weights.swap(new_weights);
-            }
-            return is;
-        }
-
-        /** Returns true if the two sets of parameters are the same. */
-        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        {
-            return lhs._intervals == rhs._intervals
-                && lhs._weights == rhs._weights;
-        }
-        /** Returns true if the two sets of parameters are different. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-
-    private:
-
-        friend class piecewise_constant_distribution;
-
-        std::vector<RealType> _intervals;
-        std::vector<WeightType> _weights;
-    };
-
-    /**
-     * Creates a new @c piecewise_constant_distribution with
-     * a single interval, [0, 1).
-     */
-    piecewise_constant_distribution()
-    {
-        _intervals.push_back(RealType(0));
-        _intervals.push_back(RealType(1));
-    }
-    /**
-     * Constructs a piecewise_constant_distribution from two iterator ranges
-     * containing the interval boundaries and the interval weights.
-     * If there are less than two boundaries, then this is equivalent to
-     * the default constructor and creates a single interval, [0, 1).
-     *
-     * The values of the interval boundaries must be strictly
-     * increasing, and the number of weights must be one less than
-     * the number of interval boundaries.  If there are extra
-     * weights, they are ignored.
-     *
-     * For example,
-     *
-     * @code
-     * double intervals[] = { 0.0, 1.0, 4.0 };
-     * double weights[] = { 1.0, 1.0 };
-     * piecewise_constant_distribution<> dist(
-     *     &intervals[0], &intervals[0] + 3, &weights[0]);
-     * @endcode
-     *
-     * The distribution has a 50% chance of producing a
-     * value between 0 and 1 and a 50% chance of producing
-     * a value between 1 and 4.
-     */
-    template<class IntervalIter, class WeightIter>
-    piecewise_constant_distribution(IntervalIter first_interval,
-                                    IntervalIter last_interval,
-                                    WeightIter first_weight)
-      : _intervals(first_interval, last_interval)
-    {
-        if(_intervals.size() < 2) {
-            _intervals.clear();
-            _intervals.push_back(RealType(0));
-            _intervals.push_back(RealType(1));
-        } else {
-            std::vector<WeightType> actual_weights;
-            actual_weights.reserve(_intervals.size() - 1);
-            for(std::size_t i = 0; i < _intervals.size() - 1; ++i) {
-                actual_weights.push_back(*first_weight++);
-            }
-            typedef discrete_distribution<std::size_t, WeightType> bins_type;
-            typename bins_type::param_type bins_param(actual_weights);
-            _bins.param(bins_param);
-        }
-    }
-#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
-    /**
-     * Constructs a piecewise_constant_distribution from an
-     * initializer_list containing the interval boundaries
-     * and a unary function specifying the weights.  Each
-     * weight is determined by calling the function at the
-     * midpoint of the corresponding interval.
-     *
-     * If the initializer_list contains less than two elements,
-     * this is equivalent to the default constructor and the
-     * distribution will produce values uniformly distributed
-     * in the range [0, 1).
-     */
-    template<class T, class F>
-    piecewise_constant_distribution(std::initializer_list<T> il, F f)
-      : _intervals(il.begin(), il.end())
-    {
-        if(_intervals.size() < 2) {
-            _intervals.clear();
-            _intervals.push_back(RealType(0));
-            _intervals.push_back(RealType(1));
-        } else {
-            std::vector<WeightType> actual_weights;
-            actual_weights.reserve(_intervals.size() - 1);
-            for(std::size_t i = 0; i < _intervals.size() - 1; ++i) {
-                RealType midpoint = (_intervals[i] + _intervals[i + 1]) / 2;
-                actual_weights.push_back(f(midpoint));
-            }
-            typedef discrete_distribution<std::size_t, WeightType> bins_type;
-            typename bins_type::param_type bins_param(actual_weights);
-            _bins.param(bins_param);
-        }
-    }
-#endif
-    /**
-     * Constructs a piecewise_constant_distribution from Boost.Range
-     * ranges holding the interval boundaries and the weights.  If
-     * there are less than two interval boundaries, this is equivalent
-     * to the default constructor and the distribution will produce
-     * values uniformly distributed in the range [0, 1).  The
-     * number of weights must be one less than the number of
-     * interval boundaries.
-     */
-    template<class IntervalsRange, class WeightsRange>
-    piecewise_constant_distribution(const IntervalsRange& intervals_arg,
-                                    const WeightsRange& weights_arg)
-      : _bins(weights_arg),
-        _intervals(boost::begin(intervals_arg), boost::end(intervals_arg))
-    {
-        if(_intervals.size() < 2) {
-            _intervals.clear();
-            _intervals.push_back(RealType(0));
-            _intervals.push_back(RealType(1));
-        }
-    }
-    /**
-     * Constructs a piecewise_constant_distribution that approximates a
-     * function.  The range of the distribution is [xmin, xmax).  This
-     * range is divided into nw equally sized intervals and the weights
-     * are found by calling the unary function f on the midpoints of the
-     * intervals.
-     */
-    template<class F>
-    piecewise_constant_distribution(std::size_t nw,
-                                    RealType xmin,
-                                    RealType xmax,
-                                    F f)
-      : _bins(nw, xmin, xmax, f)
-    {
-        if(nw == 0) { nw = 1; }
-        RealType delta = (xmax - xmin) / nw;
-        _intervals.reserve(nw + 1);
-        for(std::size_t i = 0; i < nw; ++i) {
-            _intervals.push_back(xmin + i * delta);
-        }
-        _intervals.push_back(xmax);
-    }
-    /**
-     * Constructs a piecewise_constant_distribution from its parameters.
-     */
-    explicit piecewise_constant_distribution(const param_type& parm)
-      : _bins(parm._weights),
-        _intervals(parm._intervals)
-    {
-    }
-
-    /**
-     * Returns a value distributed according to the parameters of the
-     * piecewist_constant_distribution.
-     */
-    template<class URNG>
-    RealType operator()(URNG& urng) const
-    {
-        std::size_t i = _bins(urng);
-        return uniform_real<RealType>(_intervals[i], _intervals[i+1])(urng);
-    }
-    
-    /**
-     * Returns a value distributed according to the parameters
-     * specified by param.
-     */
-    template<class URNG>
-    RealType operator()(URNG& urng, const param_type& parm) const
-    {
-        return piecewise_constant_distribution(parm)(urng);
-    }
-    
-    /** Returns the smallest value that the distribution can produce. */
-    result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    { return _intervals.front(); }
-    /** Returns the largest value that the distribution can produce. */
-    result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    { return _intervals.back(); }
-
-    /**
-     * Returns a vector containing the probability density
-     * over each interval.
-     */
-    std::vector<RealType> densities() const
-    {
-        std::vector<RealType> result(_bins.probabilities());
-        for(std::size_t i = 0; i < result.size(); ++i) {
-            result[i] /= (_intervals[i+1] - _intervals[i]);
-        }
-        return(result);
-    }
-    /**  Returns a vector containing the interval boundaries. */
-    std::vector<RealType> intervals() const { return _intervals; }
-
-    /** Returns the parameters of the distribution. */
-    param_type param() const
-    {
-        return param_type(_intervals, _bins.probabilities());
-    }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        std::vector<RealType> new_intervals(parm._intervals);
-        typedef discrete_distribution<std::size_t, WeightType> bins_type;
-        typename bins_type::param_type bins_param(parm._weights);
-        _bins.param(bins_param);
-        _intervals.swap(new_intervals);
-    }
-    
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { _bins.reset(); }
-
-    /** Writes a distribution to a @c std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(
-        os, piecewise_constant_distribution, pcd)
-    {
-        os << pcd.param();
-        return os;
-    }
-
-    /** Reads a distribution from a @c std::istream */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(
-        is, piecewise_constant_distribution, pcd)
-    {
-        param_type parm;
-        if(is >> parm) {
-            pcd.param(parm);
-        }
-        return is;
-    }
-
-    /**
-     * Returns true if the two distributions will return the
-     * same sequence of values, when passed equal generators.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(
-        piecewise_constant_distribution, lhs,  rhs)
-    {
-        return lhs._bins == rhs._bins && lhs._intervals == rhs._intervals;
-    }
-    /**
-     * Returns true if the two distributions may return different
-     * sequences of values, when passed equal generators.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(piecewise_constant_distribution)
-
-private:
-    discrete_distribution<std::size_t, WeightType> _bins;
-    std::vector<RealType> _intervals;
-};
-
-}
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/random/piecewise_linear_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/piecewise_linear_distribution.hpp
deleted file mode 100644
index 541c57fb826..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/piecewise_linear_distribution.hpp
+++ /dev/null
@@ -1,531 +0,0 @@
-/* boost random/piecewise_linear_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_PIECEWISE_LINEAR_DISTRIBUTION_HPP_INCLUDED
-#define BOOST_RANDOM_PIECEWISE_LINEAR_DISTRIBUTION_HPP_INCLUDED
-
-#include <vector>
-#include <algorithm>
-#include <cmath>
-#include <cstdlib>
-#include <boost/assert.hpp>
-#include <boost/random/uniform_real.hpp>
-#include <boost/random/discrete_distribution.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/detail/vector_io.hpp>
-
-#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
-#include <initializer_list>
-#endif
-
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * The class @c piecewise_linear_distribution models a \random_distribution.
- */
-template<class RealType = double>
-class piecewise_linear_distribution {
-public:
-    typedef std::size_t input_type;
-    typedef RealType result_type;
-
-    class param_type {
-    public:
-
-        typedef piecewise_linear_distribution distribution_type;
-
-        /**
-         * Constructs a @c param_type object, representing a distribution
-         * that produces values uniformly distributed in the range [0, 1).
-         */
-        param_type()
-        {
-            _weights.push_back(RealType(1));
-            _weights.push_back(RealType(1));
-            _intervals.push_back(RealType(0));
-            _intervals.push_back(RealType(1));
-        }
-        /**
-         * Constructs a @c param_type object from two iterator ranges
-         * containing the interval boundaries and weights at the boundaries.
-         * If there are fewer than two boundaries, then this is equivalent to
-         * the default constructor and the distribution will produce values
-         * uniformly distributed in the range [0, 1).
-         *
-         * The values of the interval boundaries must be strictly
-         * increasing, and the number of weights must be the same as
-         * the number of interval boundaries.  If there are extra
-         * weights, they are ignored.
-         */
-        template<class IntervalIter, class WeightIter>
-        param_type(IntervalIter intervals_first, IntervalIter intervals_last,
-                   WeightIter weight_first)
-          : _intervals(intervals_first, intervals_last)
-        {
-            if(_intervals.size() < 2) {
-                _intervals.clear();
-                _weights.push_back(RealType(1));
-                _weights.push_back(RealType(1));
-                _intervals.push_back(RealType(0));
-                _intervals.push_back(RealType(1));
-            } else {
-                _weights.reserve(_intervals.size());
-                for(std::size_t i = 0; i < _intervals.size(); ++i) {
-                    _weights.push_back(*weight_first++);
-                }
-            }
-        }
-#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
-        /**
-         * Constructs a @c param_type object from an initializer_list
-         * containing the interval boundaries and a unary function
-         * specifying the weights at the boundaries.  Each weight is
-         * determined by calling the function at the corresponding point.
-         *
-         * If the initializer_list contains fewer than two elements,
-         * this is equivalent to the default constructor and the
-         * distribution will produce values uniformly distributed
-         * in the range [0, 1).
-         */
-        template<class T, class F>
-        param_type(const std::initializer_list<T>& il, F f)
-          : _intervals(il.begin(), il.end())
-        {
-            if(_intervals.size() < 2) {
-                _intervals.clear();
-                _weights.push_back(RealType(1));
-                _weights.push_back(RealType(1));
-                _intervals.push_back(RealType(0));
-                _intervals.push_back(RealType(1));
-            } else {
-                _weights.reserve(_intervals.size());
-                for(typename std::vector<RealType>::const_iterator
-                    iter = _intervals.begin(), end = _intervals.end();
-                    iter != end; ++iter)
-                {
-                    _weights.push_back(f(*iter));
-                }
-            }
-        }
-#endif
-        /**
-         * Constructs a @c param_type object from Boost.Range ranges holding
-         * the interval boundaries and the weights at the boundaries.  If
-         * there are fewer than two interval boundaries, this is equivalent
-         * to the default constructor and the distribution will produce
-         * values uniformly distributed in the range [0, 1).  The
-         * number of weights must be equal to the number of
-         * interval boundaries.
-         */
-        template<class IntervalRange, class WeightRange>
-        param_type(const IntervalRange& intervals_arg,
-                   const WeightRange& weights_arg)
-          : _intervals(boost::begin(intervals_arg), boost::end(intervals_arg)),
-            _weights(boost::begin(weights_arg), boost::end(weights_arg))
-        {
-            if(_intervals.size() < 2) {
-                _weights.clear();
-                _weights.push_back(RealType(1));
-                _weights.push_back(RealType(1));
-                _intervals.clear();
-                _intervals.push_back(RealType(0));
-                _intervals.push_back(RealType(1));
-            }
-        }
-
-        /**
-         * Constructs the parameters for a distribution that approximates a
-         * function.  The range of the distribution is [xmin, xmax).  This
-         * range is divided into nw equally sized intervals and the weights
-         * are found by calling the unary function f on the boundaries of the
-         * intervals.
-         */
-        template<class F>
-        param_type(std::size_t nw, RealType xmin, RealType xmax, F f)
-        {
-            std::size_t n = (nw == 0) ? 1 : nw;
-            double delta = (xmax - xmin) / n;
-            BOOST_ASSERT(delta > 0);
-            for(std::size_t k = 0; k < n; ++k) {
-                _weights.push_back(f(xmin + k*delta));
-                _intervals.push_back(xmin + k*delta);
-            }
-            _weights.push_back(f(xmax));
-            _intervals.push_back(xmax);
-        }
-
-        /**  Returns a vector containing the interval boundaries. */
-        std::vector<RealType> intervals() const { return _intervals; }
-
-        /**
-         * Returns a vector containing the probability densities
-         * at all the interval boundaries.
-         */
-        std::vector<RealType> densities() const
-        {
-            RealType sum = static_cast<RealType>(0);
-            for(std::size_t i = 0; i < _intervals.size() - 1; ++i) {
-                RealType width = _intervals[i + 1] - _intervals[i];
-                sum += (_weights[i] + _weights[i + 1]) * width / 2;
-            }
-            std::vector<RealType> result;
-            result.reserve(_weights.size());
-            for(typename std::vector<RealType>::const_iterator
-                iter = _weights.begin(), end = _weights.end();
-                iter != end; ++iter)
-            {
-                result.push_back(*iter / sum);
-            }
-            return result;
-        }
-
-        /** Writes the parameters to a @c std::ostream. */
-        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
-        {
-            detail::print_vector(os, parm._intervals);
-            detail::print_vector(os, parm._weights);
-            return os;
-        }
-        
-        /** Reads the parameters from a @c std::istream. */
-        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
-        {
-            std::vector<RealType> new_intervals;
-            std::vector<RealType> new_weights;
-            detail::read_vector(is, new_intervals);
-            detail::read_vector(is, new_weights);
-            if(is) {
-                parm._intervals.swap(new_intervals);
-                parm._weights.swap(new_weights);
-            }
-            return is;
-        }
-
-        /** Returns true if the two sets of parameters are the same. */
-        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        {
-            return lhs._intervals == rhs._intervals
-                && lhs._weights == rhs._weights;
-        }
-        /** Returns true if the two sets of parameters are different. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-
-    private:
-        friend class piecewise_linear_distribution;
-
-        std::vector<RealType> _intervals;
-        std::vector<RealType> _weights;
-    };
-
-    /**
-     * Creates a new @c piecewise_linear_distribution that
-     * produces values uniformly distributed in the range [0, 1).
-     */
-    piecewise_linear_distribution()
-    {
-        default_init();
-    }
-    /**
-     * Constructs a piecewise_linear_distribution from two iterator ranges
-     * containing the interval boundaries and the weights at the boundaries.
-     * If there are fewer than two boundaries, then this is equivalent to
-     * the default constructor and creates a distribution that
-     * produces values uniformly distributed in the range [0, 1).
-     *
-     * The values of the interval boundaries must be strictly
-     * increasing, and the number of weights must be equal to
-     * the number of interval boundaries.  If there are extra
-     * weights, they are ignored.
-     *
-     * For example,
-     *
-     * @code
-     * double intervals[] = { 0.0, 1.0, 2.0 };
-     * double weights[] = { 0.0, 1.0, 0.0 };
-     * piecewise_constant_distribution<> dist(
-     *     &intervals[0], &intervals[0] + 3, &weights[0]);
-     * @endcode
-     *
-     * produces a triangle distribution.
-     */
-    template<class IntervalIter, class WeightIter>
-    piecewise_linear_distribution(IntervalIter first_interval,
-                                  IntervalIter last_interval,
-                                  WeightIter first_weight)
-      : _intervals(first_interval, last_interval)
-    {
-        if(_intervals.size() < 2) {
-            default_init();
-        } else {
-            _weights.reserve(_intervals.size());
-            for(std::size_t i = 0; i < _intervals.size(); ++i) {
-                _weights.push_back(*first_weight++);
-            }
-            init();
-        }
-    }
-#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
-    /**
-     * Constructs a piecewise_linear_distribution from an
-     * initializer_list containing the interval boundaries
-     * and a unary function specifying the weights.  Each
-     * weight is determined by calling the function at the
-     * corresponding interval boundary.
-     *
-     * If the initializer_list contains fewer than two elements,
-     * this is equivalent to the default constructor and the
-     * distribution will produce values uniformly distributed
-     * in the range [0, 1).
-     */
-    template<class T, class F>
-    piecewise_linear_distribution(std::initializer_list<T> il, F f)
-      : _intervals(il.begin(), il.end())
-    {
-        if(_intervals.size() < 2) {
-            default_init();
-        } else {
-            _weights.reserve(_intervals.size());
-            for(typename std::vector<RealType>::const_iterator
-                iter = _intervals.begin(), end = _intervals.end();
-                iter != end; ++iter)
-            {
-                _weights.push_back(f(*iter));
-            }
-            init();
-        }
-    }
-#endif
-    /**
-     * Constructs a piecewise_linear_distribution from Boost.Range
-     * ranges holding the interval boundaries and the weights.  If
-     * there are fewer than two interval boundaries, this is equivalent
-     * to the default constructor and the distribution will produce
-     * values uniformly distributed in the range [0, 1).  The
-     * number of weights must be equal to the number of
-     * interval boundaries.
-     */
-    template<class IntervalsRange, class WeightsRange>
-    piecewise_linear_distribution(const IntervalsRange& intervals_arg,
-                                  const WeightsRange& weights_arg)
-      : _intervals(boost::begin(intervals_arg), boost::end(intervals_arg)),
-        _weights(boost::begin(weights_arg), boost::end(weights_arg))
-    {
-        if(_intervals.size() < 2) {
-            default_init();
-        } else {
-            init();
-        }
-    }
-    /**
-     * Constructs a piecewise_linear_distribution that approximates a
-     * function.  The range of the distribution is [xmin, xmax).  This
-     * range is divided into nw equally sized intervals and the weights
-     * are found by calling the unary function f on the interval boundaries.
-     */
-    template<class F>
-    piecewise_linear_distribution(std::size_t nw,
-                                  RealType xmin,
-                                  RealType xmax,
-                                  F f)
-    {
-        if(nw == 0) { nw = 1; }
-        RealType delta = (xmax - xmin) / nw;
-        _intervals.reserve(nw + 1);
-        for(std::size_t i = 0; i < nw; ++i) {
-            RealType x = xmin + i * delta;
-            _intervals.push_back(x);
-            _weights.push_back(f(x));
-        }
-        _intervals.push_back(xmax);
-        _weights.push_back(f(xmax));
-        init();
-    }
-    /**
-     * Constructs a piecewise_linear_distribution from its parameters.
-     */
-    explicit piecewise_linear_distribution(const param_type& parm)
-      : _intervals(parm._intervals),
-        _weights(parm._weights)
-    {
-        init();
-    }
-
-    /**
-     * Returns a value distributed according to the parameters of the
-     * piecewise_linear_distribution.
-     */
-    template<class URNG>
-    RealType operator()(URNG& urng) const
-    {
-        std::size_t i = _bins(urng);
-        bool is_in_rectangle = (i % 2 == 0);
-        i = i / 2;
-        uniform_real<RealType> dist(_intervals[i], _intervals[i+1]);
-        if(is_in_rectangle) {
-            return dist(urng);
-        } else if(_weights[i] < _weights[i+1]) {
-            return (std::max)(dist(urng), dist(urng));
-        } else {
-            return (std::min)(dist(urng), dist(urng));
-        }
-    }
-    
-    /**
-     * Returns a value distributed according to the parameters
-     * specified by param.
-     */
-    template<class URNG>
-    RealType operator()(URNG& urng, const param_type& parm) const
-    {
-        return piecewise_linear_distribution(parm)(urng);
-    }
-    
-    /** Returns the smallest value that the distribution can produce. */
-    result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    { return _intervals.front(); }
-    /** Returns the largest value that the distribution can produce. */
-    result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    { return _intervals.back(); }
-
-    /**
-     * Returns a vector containing the probability densities
-     * at the interval boundaries.
-     */
-    std::vector<RealType> densities() const
-    {
-        RealType sum = static_cast<RealType>(0);
-        for(std::size_t i = 0; i < _intervals.size() - 1; ++i) {
-            RealType width = _intervals[i + 1] - _intervals[i];
-            sum += (_weights[i] + _weights[i + 1]) * width / 2;
-        }
-        std::vector<RealType> result;
-        result.reserve(_weights.size());
-        for(typename std::vector<RealType>::const_iterator
-            iter = _weights.begin(), end = _weights.end();
-            iter != end; ++iter)
-        {
-            result.push_back(*iter / sum);
-        }
-        return result;
-    }
-    /**  Returns a vector containing the interval boundaries. */
-    std::vector<RealType> intervals() const { return _intervals; }
-
-    /** Returns the parameters of the distribution. */
-    param_type param() const
-    {
-        return param_type(_intervals, _weights);
-    }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        std::vector<RealType> new_intervals(parm._intervals);
-        std::vector<RealType> new_weights(parm._weights);
-        init(new_intervals, new_weights);
-        _intervals.swap(new_intervals);
-        _weights.swap(new_weights);
-    }
-    
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { _bins.reset(); }
-
-    /** Writes a distribution to a @c std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(
-        os, piecewise_linear_distribution, pld)
-    {
-        os << pld.param();
-        return os;
-    }
-
-    /** Reads a distribution from a @c std::istream */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(
-        is, piecewise_linear_distribution, pld)
-    {
-        param_type parm;
-        if(is >> parm) {
-            pld.param(parm);
-        }
-        return is;
-    }
-
-    /**
-     * Returns true if the two distributions will return the
-     * same sequence of values, when passed equal generators.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(
-        piecewise_linear_distribution, lhs,  rhs)
-    {
-        return lhs._intervals == rhs._intervals && lhs._weights == rhs._weights;
-    }
-    /**
-     * Returns true if the two distributions may return different
-     * sequences of values, when passed equal generators.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(piecewise_linear_distribution)
-
-private:
-
-    /// @cond \show_private
-
-    void init(const std::vector<RealType>& intervals_arg,
-              const std::vector<RealType>& weights_arg)
-    {
-        using std::abs;
-        std::vector<RealType> bin_weights;
-        bin_weights.reserve((intervals_arg.size() - 1) * 2);
-        for(std::size_t i = 0; i < intervals_arg.size() - 1; ++i) {
-            RealType width = intervals_arg[i + 1] - intervals_arg[i];
-            RealType w1 = weights_arg[i];
-            RealType w2 = weights_arg[i + 1];
-            bin_weights.push_back((std::min)(w1, w2) * width);
-            bin_weights.push_back(abs(w1 - w2) * width / 2);
-        }
-        typedef discrete_distribution<std::size_t, RealType> bins_type;
-        typename bins_type::param_type bins_param(bin_weights);
-        _bins.param(bins_param);
-    }
-
-    void init()
-    {
-        init(_intervals, _weights);
-    }
-
-    void default_init()
-    {
-        _intervals.clear();
-        _intervals.push_back(RealType(0));
-        _intervals.push_back(RealType(1));
-        _weights.clear();
-        _weights.push_back(RealType(1));
-        _weights.push_back(RealType(1));
-        init();
-    }
-
-    discrete_distribution<std::size_t, RealType> _bins;
-    std::vector<RealType> _intervals;
-    std::vector<RealType> _weights;
-
-    /// @endcond
-};
-
-}
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/random/poisson_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/poisson_distribution.hpp
deleted file mode 100644
index 759f206e429..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/poisson_distribution.hpp
+++ /dev/null
@@ -1,360 +0,0 @@
-/* boost random/poisson_distribution.hpp header file
- *
- * Copyright Jens Maurer 2002
- * Copyright Steven Watanabe 2010
- * 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_POISSON_DISTRIBUTION_HPP
-#define BOOST_RANDOM_POISSON_DISTRIBUTION_HPP
-
-#include <boost/config/no_tr1/cmath.hpp>
-#include <cstdlib>
-#include <iosfwd>
-#include <boost/assert.hpp>
-#include <boost/limits.hpp>
-#include <boost/random/uniform_01.hpp>
-#include <boost/random/detail/config.hpp>
-
-#include <boost/random/detail/disable_warnings.hpp>
-
-namespace boost {
-namespace random {
-
-namespace detail {
-
-template<class RealType>
-struct poisson_table {
-    static RealType value[10];
-};
-
-template<class RealType>
-RealType poisson_table<RealType>::value[10] = {
-    0.0,
-    0.0,
-    0.69314718055994529,
-    1.7917594692280550,
-    3.1780538303479458,
-    4.7874917427820458,
-    6.5792512120101012,
-    8.5251613610654147,
-    10.604602902745251,
-    12.801827480081469
-};
-
-}
-
-/**
- * An instantiation of the class template @c poisson_distribution is a
- * model of \random_distribution.  The poisson distribution has
- * \f$p(i) = \frac{e^{-\lambda}\lambda^i}{i!}\f$
- *
- * This implementation is based on the PTRD algorithm described
- * 
- *  @blockquote
- *  "The transformed rejection method for generating Poisson random variables",
- *  Wolfgang Hormann, Insurance: Mathematics and Economics
- *  Volume 12, Issue 1, February 1993, Pages 39-45
- *  @endblockquote
- */
-template<class IntType = int, class RealType = double>
-class poisson_distribution {
-public:
-    typedef IntType result_type;
-    typedef RealType input_type;
-
-    class param_type {
-    public:
-        typedef poisson_distribution distribution_type;
-        /**
-         * Construct a param_type object with the parameter "mean"
-         *
-         * Requires: mean > 0
-         */
-        explicit param_type(RealType mean_arg = RealType(1))
-          : _mean(mean_arg)
-        {
-            BOOST_ASSERT(_mean > 0);
-        }
-        /* Returns the "mean" parameter of the distribution. */
-        RealType mean() const { return _mean; }
-#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
-        /** Writes the parameters of the distribution to a @c std::ostream. */
-        template<class CharT, class Traits>
-        friend std::basic_ostream<CharT, Traits>&
-        operator<<(std::basic_ostream<CharT, Traits>& os,
-                   const param_type& parm)
-        {
-            os << parm._mean;
-            return os;
-        }
-
-        /** Reads the parameters of the distribution from a @c std::istream. */
-        template<class CharT, class Traits>
-        friend std::basic_istream<CharT, Traits>&
-        operator>>(std::basic_istream<CharT, Traits>& is, param_type& parm)
-        {
-            is >> parm._mean;
-            return is;
-        }
-#endif
-        /** Returns true if the parameters have the same values. */
-        friend bool operator==(const param_type& lhs, const param_type& rhs)
-        {
-            return lhs._mean == rhs._mean;
-        }
-        /** Returns true if the parameters have different values. */
-        friend bool operator!=(const param_type& lhs, const param_type& rhs)
-        {
-            return !(lhs == rhs);
-        }
-    private:
-        RealType _mean;
-    };
-    
-    /**
-     * Constructs a @c poisson_distribution with the parameter @c mean.
-     *
-     * Requires: mean > 0
-     */
-    explicit poisson_distribution(RealType mean_arg = RealType(1))
-      : _mean(mean_arg)
-    {
-        BOOST_ASSERT(_mean > 0);
-        init();
-    }
-    
-    /**
-     * Construct an @c poisson_distribution object from the
-     * parameters.
-     */
-    explicit poisson_distribution(const param_type& parm)
-      : _mean(parm.mean())
-    {
-        init();
-    }
-    
-    /**
-     * Returns a random variate distributed according to the
-     * poisson distribution.
-     */
-    template<class URNG>
-    IntType operator()(URNG& urng) const
-    {
-        if(use_inversion()) {
-            return invert(urng);
-        } else {
-            return generate(urng);
-        }
-    }
-
-    /**
-     * Returns a random variate distributed according to the
-     * poisson distribution with parameters specified by param.
-     */
-    template<class URNG>
-    IntType operator()(URNG& urng, const param_type& parm) const
-    {
-        return poisson_distribution(parm)(urng);
-    }
-
-    /** Returns the "mean" parameter of the distribution. */
-    RealType mean() const { return _mean; }
-    
-    /** Returns the smallest value that the distribution can produce. */
-    IntType min BOOST_PREVENT_MACRO_SUBSTITUTION() const { return 0; }
-    /** Returns the largest value that the distribution can produce. */
-    IntType max BOOST_PREVENT_MACRO_SUBSTITUTION() const
-    { return (std::numeric_limits<IntType>::max)(); }
-
-    /** Returns the parameters of the distribution. */
-    param_type param() const { return param_type(_mean); }
-    /** Sets parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        _mean = parm.mean();
-        init();
-    }
-
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { }
-
-#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
-    /** Writes the parameters of the distribution to a @c std::ostream. */
-    template<class CharT, class Traits>
-    friend std::basic_ostream<CharT,Traits>&
-    operator<<(std::basic_ostream<CharT,Traits>& os,
-               const poisson_distribution& pd)
-    {
-        os << pd.param();
-        return os;
-    }
-    
-    /** Reads the parameters of the distribution from a @c std::istream. */
-    template<class CharT, class Traits>
-    friend std::basic_istream<CharT,Traits>&
-    operator>>(std::basic_istream<CharT,Traits>& is, poisson_distribution& pd)
-    {
-        pd.read(is);
-        return is;
-    }
-#endif
-    
-    /** Returns true if the two distributions will produce the same
-        sequence of values, given equal generators. */
-    friend bool operator==(const poisson_distribution& lhs,
-                           const poisson_distribution& rhs)
-    {
-        return lhs._mean == rhs._mean;
-    }
-    /** Returns true if the two distributions could produce different
-        sequences of values, given equal generators. */
-    friend bool operator!=(const poisson_distribution& lhs,
-                           const poisson_distribution& rhs)
-    {
-        return !(lhs == rhs);
-    }
-
-private:
-
-    /// @cond show_private
-
-    template<class CharT, class Traits>
-    void read(std::basic_istream<CharT, Traits>& is) {
-        param_type parm;
-        if(is >> parm) {
-            param(parm);
-        }
-    }
-
-    bool use_inversion() const
-    {
-        return _mean < 10;
-    }
-
-    static RealType log_factorial(IntType k)
-    {
-        BOOST_ASSERT(k >= 0);
-        BOOST_ASSERT(k < 10);
-        return detail::poisson_table<RealType>::value[k];
-    }
-
-    void init()
-    {
-        using std::sqrt;
-        using std::exp;
-
-        if(use_inversion()) {
-            _exp_mean = exp(-_mean);
-        } else {
-            _ptrd.smu = sqrt(_mean);
-            _ptrd.b = 0.931 + 2.53 * _ptrd.smu;
-            _ptrd.a = -0.059 + 0.02483 * _ptrd.b;
-            _ptrd.inv_alpha = 1.1239 + 1.1328 / (_ptrd.b - 3.4);
-            _ptrd.v_r = 0.9277 - 3.6224 / (_ptrd.b - 2);
-        }
-    }
-    
-    template<class URNG>
-    IntType generate(URNG& urng) const
-    {
-        using std::floor;
-        using std::abs;
-        using std::log;
-
-        while(true) {
-            RealType u;
-            RealType v = uniform_01<RealType>()(urng);
-            if(v <= 0.86 * _ptrd.v_r) {
-                u = v / _ptrd.v_r - 0.43;
-                return static_cast<IntType>(floor(
-                    (2*_ptrd.a/(0.5-abs(u)) + _ptrd.b)*u + _mean + 0.445));
-            }
-
-            if(v >= _ptrd.v_r) {
-                u = uniform_01<RealType>()(urng) - 0.5;
-            } else {
-                u = v/_ptrd.v_r - 0.93;
-                u = ((u < 0)? -0.5 : 0.5) - u;
-                v = uniform_01<RealType>()(urng) * _ptrd.v_r;
-            }
-
-            RealType us = 0.5 - abs(u);
-            if(us < 0.013 && v > us) {
-                continue;
-            }
-
-            RealType k = floor((2*_ptrd.a/us + _ptrd.b)*u+_mean+0.445);
-            v = v*_ptrd.inv_alpha/(_ptrd.a/(us*us) + _ptrd.b);
-
-            RealType log_sqrt_2pi = 0.91893853320467267;
-
-            if(k >= 10) {
-                if(log(v*_ptrd.smu) <= (k + 0.5)*log(_mean/k)
-                               - _mean
-                               - log_sqrt_2pi
-                               + k
-                               - (1/12. - (1/360. - 1/(1260.*k*k))/(k*k))/k) {
-                    return static_cast<IntType>(k);
-                }
-            } else if(k >= 0) {
-                if(log(v) <= k*log(_mean)
-                           - _mean
-                           - log_factorial(static_cast<IntType>(k))) {
-                    return static_cast<IntType>(k);
-                }
-            }
-        }
-    }
-
-    template<class URNG>
-    IntType invert(URNG& urng) const
-    {
-        RealType p = _exp_mean;
-        IntType x = 0;
-        RealType u = uniform_01<RealType>()(urng);
-        while(u > p) {
-            u = u - p;
-            ++x;
-            p = _mean * p / x;
-        }
-        return x;
-    }
-
-    RealType _mean;
-
-    union {
-        // for ptrd
-        struct {
-            RealType v_r;
-            RealType a;
-            RealType b;
-            RealType smu;
-            RealType inv_alpha;
-        } _ptrd;
-        // for inversion
-        RealType _exp_mean;
-    };
-
-    /// @endcond
-};
-
-} // namespace random
-
-using random::poisson_distribution;
-
-} // namespace boost
-
-#include <boost/random/detail/enable_warnings.hpp>
-
-#endif // BOOST_RANDOM_POISSON_DISTRIBUTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/random_device.hpp b/contrib/libboost/boost_1_65_0/boost/random/random_device.hpp
deleted file mode 100644
index 8f3903c953c..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/random_device.hpp
+++ /dev/null
@@ -1,143 +0,0 @@
-/* boost random/random_device.hpp header file
- *
- * Copyright Jens Maurer 2000
- * Copyright Steven Watanabe 2010-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)
- *
- * $Id$
- *
- * Revision history
- *  2000-02-18  Portability fixes (thanks to Beman Dawes)
- */
-
-//  See http://www.boost.org/libs/random for documentation.
-
-
-#ifndef BOOST_RANDOM_RANDOM_DEVICE_HPP
-#define BOOST_RANDOM_RANDOM_DEVICE_HPP
-
-#include <string>
-#include <boost/config.hpp>
-#include <boost/noncopyable.hpp>
-#include <boost/random/detail/auto_link.hpp>
-#include <boost/system/config.hpp> // force autolink to find Boost.System
-
-namespace boost {
-namespace random {
-
-/**
- * Class \random_device models a \nondeterministic_random_number_generator.
- * It uses one or more implementation-defined stochastic processes to
- * generate a sequence of uniformly distributed non-deterministic random
- * numbers. For those environments where a non-deterministic random number
- * generator is not available, class random_device must not be implemented. See
- *
- *  @blockquote
- *  "Randomness Recommendations for Security", D. Eastlake, S. Crocker,
- *  J. Schiller, Network Working Group, RFC 1750, December 1994
- *  @endblockquote
- *
- * for further discussions. 
- *
- * @xmlnote
- * Some operating systems abstract the computer hardware enough
- * to make it difficult to non-intrusively monitor stochastic processes.
- * However, several do provide a special device for exactly this purpose.
- * It seems to be impossible to emulate the functionality using Standard
- * C++ only, so users should be aware that this class may not be available
- * on all platforms.
- * @endxmlnote
- *
- * <b>Implementation Note for Linux</b>
- *
- * On the Linux operating system, token is interpreted as a filesystem
- * path. It is assumed that this path denotes an operating system
- * pseudo-device which generates a stream of non-deterministic random
- * numbers. The pseudo-device should never signal an error or end-of-file.
- * Otherwise, @c std::ios_base::failure is thrown. By default,
- * \random_device uses the /dev/urandom pseudo-device to retrieve
- * the random numbers. Another option would be to specify the /dev/random
- * pseudo-device, which blocks on reads if the entropy pool has no more
- * random bits available.
- *
- * <b>Implementation Note for Windows</b>
- *
- * On the Windows operating system, token is interpreted as the name
- * of a cryptographic service provider.  By default \random_device uses
- * MS_DEF_PROV.
- *
- * <b>Performance</b>
- *
- * The test program <a href="\boost/libs/random/performance/nondet_random_speed.cpp">
- * nondet_random_speed.cpp</a> measures the execution times of the
- * random_device.hpp implementation of the above algorithms in a tight
- * loop. The performance has been evaluated on an
- * Intel(R) Core(TM) i7 CPU Q 840 \@ 1.87GHz, 1867 Mhz with
- * Visual C++ 2010, Microsoft Windows 7 Professional and with gcc 4.4.5,
- * Ubuntu Linux 2.6.35-25-generic.
- *
- * <table cols="2">
- *   <tr><th>Platform</th><th>time per invocation [microseconds]</th></tr>
- *   <tr><td> Windows </td><td>2.9</td></tr>
- *   <tr><td> Linux </td><td>1.7</td></tr>
- * </table>
- *
- * The measurement error is estimated at +/- 1 usec.
- */
-class random_device : private noncopyable
-{
-public:
-    typedef unsigned int result_type;
-    BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
-
-    /** Returns the smallest value that the \random_device can produce. */
-    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return 0; }
-    /** Returns the largest value that the \random_device can produce. */
-    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () { return ~0u; }
-
-    /** Constructs a @c random_device, optionally using the default device. */
-    BOOST_RANDOM_DECL random_device();
-    /** 
-     * Constructs a @c random_device, optionally using the given token as an
-     * access specification (for example, a URL) to some implementation-defined
-     * service for monitoring a stochastic process. 
-     */
-    BOOST_RANDOM_DECL explicit random_device(const std::string& token);
-
-    BOOST_RANDOM_DECL ~random_device();
-
-    /**
-     * Returns: An entropy estimate for the random numbers returned by
-     * operator(), in the range min() to log2( max()+1). A deterministic
-     * random number generator (e.g. a pseudo-random number engine)
-     * has entropy 0.
-     *
-     * Throws: Nothing.
-     */
-    BOOST_RANDOM_DECL double entropy() const;
-    /** Returns a random value in the range [min, max]. */
-    BOOST_RANDOM_DECL unsigned int operator()();
-
-    /** Fills a range with random 32-bit values. */
-    template<class Iter>
-    void generate(Iter begin, Iter end)
-    {
-        for(; begin != end; ++begin) {
-            *begin = (*this)();
-        }
-    }
-
-private:
-    class impl;
-    impl * pimpl;
-};
-
-} // namespace random
-
-using random::random_device;
-
-} // namespace boost
-
-#endif /* BOOST_RANDOM_RANDOM_DEVICE_HPP */
diff --git a/contrib/libboost/boost_1_65_0/boost/random/random_number_generator.hpp b/contrib/libboost/boost_1_65_0/boost/random/random_number_generator.hpp
deleted file mode 100644
index ac975e32987..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/random_number_generator.hpp
+++ /dev/null
@@ -1,73 +0,0 @@
-/* boost random/random_number_generator.hpp header file
- *
- * Copyright Jens Maurer 2000-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 for most recent version including documentation.
- *
- * $Id$
- *
- * Revision history
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_RANDOM_NUMBER_GENERATOR_HPP
-#define BOOST_RANDOM_RANDOM_NUMBER_GENERATOR_HPP
-
-#include <boost/assert.hpp>
-#include <boost/random/uniform_int_distribution.hpp>
-
-#include <boost/random/detail/disable_warnings.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * Instantiations of class template random_number_generator model a
- * RandomNumberGenerator (std:25.2.11 [lib.alg.random.shuffle]). On
- * each invocation, it returns a uniformly distributed integer in
- * the range [0..n).
- *
- * The template parameter IntType shall denote some integer-like value type.
- */
-template<class URNG, class IntType = long>
-class random_number_generator
-{
-public:
-    typedef URNG base_type;
-    typedef IntType argument_type;
-    typedef IntType result_type;
-    /**
-     * Constructs a random_number_generator functor with the given
-     * \uniform_random_number_generator as the underlying source of
-     * random numbers.
-     */
-    random_number_generator(base_type& rng) : _rng(rng) {}
-
-    // compiler-generated copy ctor is fine
-    // assignment is disallowed because there is a reference member
-
-    /**
-     * Returns a value in the range [0, n)
-     */
-    result_type operator()(argument_type n)
-    {
-        BOOST_ASSERT(n > 0);
-        return uniform_int_distribution<IntType>(0, n-1)(_rng);
-    }
-
-private:
-    base_type& _rng;
-};
-
-} // namespace random
-
-using random::random_number_generator;
-
-} // namespace boost
-
-#include <boost/random/detail/enable_warnings.hpp>
-
-#endif // BOOST_RANDOM_RANDOM_NUMBER_GENERATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/ranlux.hpp b/contrib/libboost/boost_1_65_0/boost/random/ranlux.hpp
deleted file mode 100644
index 82a7ca66f12..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/ranlux.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-/* boost random/ranlux.hpp header file
- *
- * Copyright Jens Maurer 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 including documentation.
- *
- * $Id$
- *
- * Revision history
- *  2001-02-18  created
- */
-
-#ifndef BOOST_RANDOM_RANLUX_HPP
-#define BOOST_RANDOM_RANLUX_HPP
-
-#include <boost/config.hpp>
-#include <boost/random/subtract_with_carry.hpp>
-#include <boost/random/discard_block.hpp>
-
-namespace boost {
-
-namespace random {
-
-namespace detail {
-/**
- * The ranlux family of generators are described in
- *
- *  @blockquote
- *  "A portable high-quality random number generator for lattice field theory
- *  calculations", M. Luescher, Computer Physics Communications, 79 (1994)
- *  pp 100-110. 
- *  @endblockquote
- *
- * The levels are given in
- * 
- *  @blockquote
- *  "RANLUX: A Fortran implementation of the high-quality
- *  pseudorandom number generator of Luescher", F. James,
- *  Computer Physics Communications 79 (1994) 111-114
- *  @endblockquote
- */
-class ranlux_documentation {};
-}
-
-typedef subtract_with_carry_engine<uint32_t, 24, 10, 24> ranlux_base;
-typedef subtract_with_carry_01_engine<float, 24, 10, 24> ranlux_base_01;
-typedef subtract_with_carry_01_engine<double, 48, 10, 24> ranlux64_base_01;
-
-
-/** @copydoc boost::random::detail::ranlux_documentation */
-typedef discard_block_engine<ranlux_base, 223, 24> ranlux3;
-/** @copydoc boost::random::detail::ranlux_documentation */
-typedef discard_block_engine<ranlux_base, 389, 24> ranlux4;
-
-/** @copydoc boost::random::detail::ranlux_documentation */
-typedef discard_block_engine<ranlux_base_01, 223, 24> ranlux3_01;
-/** @copydoc boost::random::detail::ranlux_documentation */
-typedef discard_block_engine<ranlux_base_01, 389, 24> ranlux4_01;
-
-/** @copydoc boost::random::detail::ranlux_documentation */
-typedef discard_block_engine<ranlux64_base_01, 223, 24> ranlux64_3_01;
-/** @copydoc boost::random::detail::ranlux_documentation */
-typedef discard_block_engine<ranlux64_base_01, 389, 24> ranlux64_4_01;
-
-#if !defined(BOOST_NO_INT64_T) && !defined(BOOST_NO_INTEGRAL_INT64_T)
-typedef subtract_with_carry_engine<uint64_t, 48, 10, 24> ranlux64_base;
-/** @copydoc boost::random::detail::ranlux_documentation */
-typedef discard_block_engine<ranlux64_base, 223, 24> ranlux64_3;
-/** @copydoc boost::random::detail::ranlux_documentation */
-typedef discard_block_engine<ranlux64_base, 389, 24> ranlux64_4;
-#endif /* !BOOST_NO_INT64_T && !BOOST_NO_INTEGRAL_INT64_T */
-
-
-typedef subtract_with_carry_engine<uint32_t, 24, 10, 24> ranlux24_base;
-typedef subtract_with_carry_engine<uint64_t, 48, 5, 12> ranlux48_base;
-
-typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
-#if !defined(BOOST_NO_INT64_T) && !defined(BOOST_NO_INTEGRAL_INT64_T)
-typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
-#endif
-}
-
-using random::ranlux3;
-using random::ranlux4;
-using random::ranlux3_01;
-using random::ranlux4_01;
-using random::ranlux64_3_01;
-using random::ranlux64_4_01;
-#if !defined(BOOST_NO_INT64_T) && !defined(BOOST_NO_INTEGRAL_INT64_T)
-using random::ranlux64_3;
-using random::ranlux64_4;
-#endif
-
-} // namespace boost
-
-#endif // BOOST_RANDOM_LINEAR_CONGRUENTIAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/seed_seq.hpp b/contrib/libboost/boost_1_65_0/boost/random/seed_seq.hpp
deleted file mode 100644
index d76aef4f5e5..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/seed_seq.hpp
+++ /dev/null
@@ -1,118 +0,0 @@
-/* boost random/seed_seq.hpp header file
- *
- * Copyright Steven Watanabe 2010
- * 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_SEED_SEQ_HPP
-#define BOOST_RANDOM_SEED_SEQ_HPP
-
-#include <boost/config.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <cstddef>
-#include <vector>
-#include <algorithm>
-#include <iterator>
-
-#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
-#include <initializer_list>
-#endif
-
-namespace boost {
-namespace random {
-
-/**
- * The class @c seed_seq stores a sequence of 32-bit words
- * for seeding a \pseudo_random_number_generator.  These
- * words will be combined to fill the entire state of the
- * generator.
- */
-class seed_seq {
-public:
-    typedef boost::uint_least32_t result_type;
-
-    /** Initializes a seed_seq to hold an empty sequence. */
-    seed_seq() {}
-#ifndef BOOST_NO_CXX11_HDR_INITIALIZER_LIST
-    /** Initializes the sequence from an initializer_list. */
-    template<class T>
-    seed_seq(const std::initializer_list<T>& il) : v(il.begin(), il.end()) {}
-#endif
-    /** Initializes the sequence from an iterator range. */
-    template<class Iter>
-    seed_seq(Iter first, Iter last) : v(first, last) {}
-    /** Initializes the sequence from Boost.Range range. */
-    template<class Range>
-    explicit seed_seq(const Range& range)
-      : v(boost::begin(range), boost::end(range)) {}
-
-    /**
-     * Fills a range with 32-bit values based on the stored sequence.
-     *
-     * Requires: Iter must be a Random Access Iterator whose value type
-     * is an unsigned integral type at least 32 bits wide.
-     */
-    template<class Iter>
-    void generate(Iter first, Iter last) const
-    {
-        typedef typename std::iterator_traits<Iter>::value_type value_type;
-        std::fill(first, last, static_cast<value_type>(0x8b8b8b8bu));
-        std::size_t s = v.size();
-        std::size_t n = last - first;
-        std::size_t t =
-            (n >= 623) ? 11 :
-            (n >=  68) ?  7 :
-            (n >=  39) ?  5 :
-            (n >=   7) ?  3 :
-            (n - 1)/2;
-        std::size_t p = (n - t) / 2;
-        std::size_t q = p + t;
-        std::size_t m = (std::max)(s+1, n);
-        value_type mask = 0xffffffffu;
-        for(std::size_t k = 0; k < m; ++k) {
-            value_type r1 = static_cast<value_type>
-                (*(first + k%n) ^ *(first + (k+p)%n) ^ *(first + (k+n-1)%n));
-            r1 = r1 ^ (r1 >> 27);
-            r1 = (r1 * 1664525u) & mask;
-            value_type r2 = static_cast<value_type>(r1 +
-                ((k == 0) ? s :
-                 (k <= s) ? k % n + v[k - 1] :
-                 (k % n)));
-            *(first + (k+p)%n) = (*(first + (k+p)%n) + r1) & mask;
-            *(first + (k+q)%n) = (*(first + (k+q)%n) + r2) & mask;
-            *(first + k%n) = r2;
-        }
-        for(std::size_t k = m; k < m + n; ++k) {
-            value_type r3 = static_cast<value_type>
-                ((*(first + k%n) + *(first + (k+p)%n) + *(first + (k+n-1)%n))
-                & mask);
-            r3 = r3 ^ (r3 >> 27);
-            r3 = (r3 * 1566083941u) & mask;
-            value_type r4 = static_cast<value_type>(r3 - k%m);
-            *(first + (k+p)%n) ^= r3;
-            *(first + (k+q)%n) ^= r4;
-            *(first + k%n) = r4;
-        }
-    }
-    /** Returns the size of the sequence. */
-    std::size_t size() const { return v.size(); }
-    /** Writes the stored sequence to iter. */
-    template<class Iter>
-    void param(Iter out) { std::copy(v.begin(), v.end(), out); }
-private:
-    std::vector<result_type> v;
-};
-
-}
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/random/shuffle_order.hpp b/contrib/libboost/boost_1_65_0/boost/random/shuffle_order.hpp
deleted file mode 100644
index 54645303e80..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/shuffle_order.hpp
+++ /dev/null
@@ -1,269 +0,0 @@
-/* boost random/shuffle_order.hpp header file
- *
- * Copyright Jens Maurer 2000-2001
- * Copyright Steven Watanabe 2010
- * 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_SHUFFLE_ORDER_HPP
-#define BOOST_RANDOM_SHUFFLE_ORDER_HPP
-
-#include <iostream>
-#include <algorithm>     // std::copy
-#include <cassert>
-#include <boost/config.hpp>
-#include <boost/limits.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/detail/seed.hpp>
-#include <boost/random/detail/signed_unsigned_tools.hpp>
-#include <boost/random/linear_congruential.hpp>
-
-#include <boost/random/detail/disable_warnings.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * Instatiations of class template @c shuffle_order_engine model a
- * \pseudo_random_number_generator. It mixes the output
- * of some (usually \linear_congruential_engine)
- * \uniform_random_number_generator to get better statistical properties.
- * The algorithm is described in
- *
- *  @blockquote
- *  "Improving a poor random number generator", Carter Bays
- *  and S.D. Durham, ACM Transactions on Mathematical Software,
- *  Vol 2, No. 1, March 1976, pp. 59-64.
- *  http://doi.acm.org/10.1145/355666.355670
- *  @endblockquote
- *
- * The output of the base generator is buffered in an array of
- * length k. Every output X(n) has a second role: It gives an
- * index into the array where X(n+1) will be retrieved. Used
- * array elements are replaced with fresh output from the base
- * generator.
- *
- * Template parameters are the base generator and the array
- * length k, which should be around 100.
- */
-template<class UniformRandomNumberGenerator, std::size_t k>
-class shuffle_order_engine
-{
-public:
-    typedef UniformRandomNumberGenerator base_type;
-    typedef typename base_type::result_type result_type;
-
-    BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
-    BOOST_STATIC_CONSTANT(std::size_t, buffer_size = k);
-    BOOST_STATIC_CONSTANT(std::size_t, table_size = k);
-
-    BOOST_STATIC_ASSERT(std::numeric_limits<result_type>::is_integer);
-    BOOST_STATIC_ASSERT(k > 0);
-
-    /**
-     * Constructs a @c shuffle_order_engine by invoking the
-     * default constructor of the base generator.
-     *
-     * Complexity: Exactly k+1 invocations of the base generator.
-     */
-    shuffle_order_engine() : _rng() { init(); }
-    /**
-     * Constructs a @c shuffle_output_engine by invoking the one-argument
-     * constructor of the base generator with the parameter seed.
-     *
-     * Complexity: Exactly k+1 invocations of the base generator.
-     */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(shuffle_order_engine,
-                                               result_type, s)
-    { _rng.seed(s); init(); }
-    BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(shuffle_order_engine, SeedSeq, seq)
-    { _rng.seed(seq); init(); }
-    /**
-     * Constructs a @c shuffle_output_engine by using a copy
-     * of the provided generator.
-     *
-     * Precondition: The template argument UniformRandomNumberGenerator
-     * shall denote a CopyConstructible type.
-     *
-     * Complexity: Exactly k+1 invocations of the base generator.
-     */
-    explicit shuffle_order_engine(const base_type & rng) : _rng(rng) { init(); }
-
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-    explicit shuffle_order_engine(base_type&& rng) : _rng(rng) { init(); }
-#endif
-
-    template<class It> shuffle_order_engine(It& first, It last)
-      : _rng(first, last) { init(); }
-    void seed() { _rng.seed(); init(); }
-    /**
-     * Invokes the one-argument seed method of the base generator
-     * with the parameter seed and re-initializes the internal buffer array.
-     *
-     * Complexity: Exactly k+1 invocations of the base generator.
-     */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(shuffle_order_engine,
-        result_type, seed_arg)
-    { _rng.seed(seed_arg); init(); }
-    /**
-     * Invokes the one-argument seed method of the base generator
-     * with the parameter seq and re-initializes the internal buffer array.
-     *
-     * Complexity: Exactly k+1 invocations of the base generator.
-     */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(shuffle_order_engine, SeedSeq, seq)
-    { _rng.seed(seq); init(); }
-    template<class It> void seed(It& first, It last)
-    { _rng.seed(first, last); init(); }
-
-    const base_type& base() const { return _rng; }
-
-    result_type operator()() {
-        // calculating the range every time may seem wasteful.  However, this
-        // makes the information locally available for the optimizer.
-        typedef typename boost::random::traits::make_unsigned<result_type>::type base_unsigned;
-        const base_unsigned brange =
-            detail::subtract<result_type>()((max)(), (min)());
-        const base_unsigned off =
-            detail::subtract<result_type>()(y, (min)());
-
-        base_unsigned j;
-        if(k == 1) {
-            j = 0;
-        } else if(brange < (std::numeric_limits<base_unsigned>::max)() / k) {
-            // try to do it in the native type if we know that it won't
-            // overflow
-            j = k * off / (brange + 1);
-        } else if(brange < (std::numeric_limits<uintmax_t>::max)() / k) {
-            // Otherwise try to use uint64_t
-            j = static_cast<base_unsigned>(
-                static_cast<uintmax_t>(off) * k /
-                (static_cast<uintmax_t>(brange) + 1));
-        } else {
-            boost::uintmax_t divisor =
-                static_cast<boost::uintmax_t>(brange) + 1;
-            j = static_cast<base_unsigned>(detail::muldiv(off, k, divisor));
-        }
-        // assert(0 <= j && j < k);
-        y = v[j];
-        v[j] = _rng();
-        return y;
-    }
-
-    /** Advances the generator by z steps. */
-    void discard(boost::uintmax_t z)
-    {
-        for(boost::uintmax_t j = 0; j < z; ++j) {
-            (*this)();
-        }
-    }
-
-    /** Fills a range with pseudo-random values. */
-    template<class Iter>
-    void generate(Iter first, Iter last)
-    { detail::generate_from_int(*this, first, last); }
-
-    /** Returns the smallest value that the generator can produce. */
-    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return (base_type::min)(); }
-    /** Returns the largest value that the generator can produce. */
-    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return (base_type::max)(); }
-
-    /** Writes a @c shuffle_order_engine to a @c std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, shuffle_order_engine, s)
-    {
-        os << s._rng;
-        for(std::size_t i = 0; i < k; ++i)
-            os << ' ' << s.v[i];
-        os << ' ' << s.y;
-        return os;
-    }
-
-    /** Reads a @c shuffle_order_engine from a @c std::istream. */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, shuffle_order_engine, s)
-    {
-        is >> s._rng;
-        for(std::size_t i = 0; i < k; ++i)
-            is >> std::ws >> s.v[i];
-        is >> std::ws >> s.y;
-        return is;
-    }
-
-    /** Returns true if the two generators will produce identical sequences. */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(shuffle_order_engine, x, y)
-    { return x._rng == y._rng && x.y == y.y && std::equal(x.v, x.v+k, y.v); }
-    /** Returns true if the two generators will produce different sequences. */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(shuffle_order_engine)
-
-private:
-
-    /// \cond show_private
-
-    void init()
-    {
-        // we cannot use std::generate, because it uses pass-by-value for _rng
-        for(result_type * p = v; p != v+k; ++p)
-            *p = _rng();
-        y = _rng();
-    }
-
-    /// \endcond
-
-    base_type _rng;
-    result_type v[k];
-    result_type y;
-};
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-//  A definition is required even for integral static constants
-template<class URNG, std::size_t k>
-const bool shuffle_order_engine<URNG, k>::has_fixed_range;
-template<class URNG, std::size_t k>
-const std::size_t shuffle_order_engine<URNG, k>::table_size;
-template<class URNG, std::size_t k>
-const std::size_t shuffle_order_engine<URNG, k>::buffer_size;
-#endif
-
-/**
- * According to Harry Erwin (private e-mail), the specialization
- * @c kreutzer1986 was suggested in:
- *
- * @blockquote
- * "System Simulation: Programming Styles and Languages (International
- * Computer Science Series)", Wolfgang Kreutzer, Addison-Wesley, December 1986.
- * @endblockquote
- */
-typedef shuffle_order_engine<
-    linear_congruential_engine<uint32_t, 1366, 150889, 714025>,
-    97> kreutzer1986;
-
-/**
- * The specialization @c knuth_b is specified by the C++ standard.
- * It is described in
- *
- * @blockquote
- * "The Art of Computer Programming, Second Edition, Volume 2,
- * Seminumerical Algorithms", Donald Knuth, Addison-Wesley, 1981.
- * @endblockquote
- */
-typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
-
-} // namespace random
-
-using random::kreutzer1986;
-
-} // namespace boost
-
-#include <boost/random/detail/enable_warnings.hpp>
-
-#endif // BOOST_RANDOM_SHUFFLE_OUTPUT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/shuffle_output.hpp b/contrib/libboost/boost_1_65_0/boost/random/shuffle_output.hpp
deleted file mode 100644
index 478e1029bd8..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/shuffle_output.hpp
+++ /dev/null
@@ -1,51 +0,0 @@
-/* boost random/shuffle_output.hpp header file
- *
- * Copyright Jens Maurer 2000-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 for most recent version including documentation.
- *
- * $Id$
- *
- * Revision history
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_SHUFFLE_OUTPUT_HPP
-#define BOOST_RANDOM_SHUFFLE_OUTPUT_HPP
-
-#include <boost/random/shuffle_order.hpp>
-
-namespace boost {
-namespace random {
-
-/// \cond
-
-template<typename URNG, int k, 
-         typename URNG::result_type val = 0> 
-class shuffle_output : public shuffle_order_engine<URNG, k>
-{
-    typedef shuffle_order_engine<URNG, k> base_t;
-public:
-    typedef typename base_t::result_type result_type;
-    shuffle_output() {}
-    template<class T>
-    explicit shuffle_output(T& arg) : base_t(arg) {}
-    template<class T>
-    explicit shuffle_output(const T& arg) : base_t(arg) {}
-    template<class It>
-    shuffle_output(It& first, It last) : base_t(first, last) {}
-    result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return (this->base().min)(); }
-    result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return (this->base().max)(); }
-};
-
-/// \endcond
-
-}
-}
-
-#endif // BOOST_RANDOM_SHUFFLE_OUTPUT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/student_t_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/student_t_distribution.hpp
deleted file mode 100644
index e28b0e3bfb3..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/student_t_distribution.hpp
+++ /dev/null
@@ -1,180 +0,0 @@
-/* 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
diff --git a/contrib/libboost/boost_1_65_0/boost/random/subtract_with_carry.hpp b/contrib/libboost/boost_1_65_0/boost/random/subtract_with_carry.hpp
deleted file mode 100644
index acaf69ac698..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/subtract_with_carry.hpp
+++ /dev/null
@@ -1,613 +0,0 @@
-/* boost random/subtract_with_carry.hpp header file
- *
- * Copyright Jens Maurer 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 including documentation.
- *
- * $Id$
- *
- * Revision history
- *  2002-03-02  created
- */
-
-#ifndef BOOST_RANDOM_SUBTRACT_WITH_CARRY_HPP
-#define BOOST_RANDOM_SUBTRACT_WITH_CARRY_HPP
-
-#include <boost/config/no_tr1/cmath.hpp>         // std::pow
-#include <iostream>
-#include <algorithm>     // std::equal
-#include <stdexcept>
-#include <boost/config.hpp>
-#include <boost/limits.hpp>
-#include <boost/cstdint.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/integer/static_log2.hpp>
-#include <boost/integer/integer_mask.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/seed.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/detail/seed_impl.hpp>
-#include <boost/random/detail/generator_seed_seq.hpp>
-#include <boost/random/linear_congruential.hpp>
-
-
-namespace boost {
-namespace random {
-
-namespace detail {
-   
-struct subtract_with_carry_discard
-{
-    template<class Engine>
-    static void apply(Engine& eng, boost::uintmax_t z)
-    {
-        typedef typename Engine::result_type IntType;
-        const std::size_t short_lag = Engine::short_lag;
-        const std::size_t long_lag = Engine::long_lag;
-        std::size_t k = eng.k;
-        IntType carry = eng.carry;
-        if(k != 0) {
-            // increment k until it becomes 0.
-            if(k < short_lag) {
-                std::size_t limit = (short_lag - k) < z?
-                    short_lag : (k + static_cast<std::size_t>(z));
-                for(std::size_t j = k; j < limit; ++j) {
-                    carry = eng.do_update(j, j + long_lag - short_lag, carry);
-                }
-            }
-            std::size_t limit = (long_lag - k) < z?
-                long_lag : (k + static_cast<std::size_t>(z));
-            std::size_t start = (k < short_lag ? short_lag : k);
-            for(std::size_t j = start; j < limit; ++j) {
-                carry = eng.do_update(j, j - short_lag, carry);
-            }
-        }
-
-        k = ((z % long_lag) + k) % long_lag;
-
-        if(k < z) {
-            // main loop: update full blocks from k = 0 to long_lag
-            for(std::size_t i = 0; i < (z - k) / long_lag; ++i) {
-                for(std::size_t j = 0; j < short_lag; ++j) {
-                    carry = eng.do_update(j, j + long_lag - short_lag, carry);
-                }
-                for(std::size_t j = short_lag; j < long_lag; ++j) {
-                    carry = eng.do_update(j, j - short_lag, carry);
-                }
-            }
-
-            // Update the last partial block
-            std::size_t limit = short_lag < k? short_lag : k; 
-            for(std::size_t j = 0; j < limit; ++j) {
-                carry = eng.do_update(j, j + long_lag - short_lag, carry);
-            }
-            for(std::size_t j = short_lag; j < k; ++j) {
-                carry = eng.do_update(j, j - short_lag, carry);
-            }
-        }
-        eng.carry = carry;
-        eng.k = k;
-    }
-};
-
-}
-
-/**
- * Instantiations of @c subtract_with_carry_engine model a
- * \pseudo_random_number_generator.  The algorithm is
- * described in
- *
- *  @blockquote
- *  "A New Class of Random Number Generators", George
- *  Marsaglia and Arif Zaman, Annals of Applied Probability,
- *  Volume 1, Number 3 (1991), 462-480.
- *  @endblockquote
- */
-template<class IntType, std::size_t w, std::size_t s, std::size_t r>
-class subtract_with_carry_engine
-{
-public:
-    typedef IntType result_type;
-    BOOST_STATIC_CONSTANT(std::size_t, word_size = w);
-    BOOST_STATIC_CONSTANT(std::size_t, long_lag = r);
-    BOOST_STATIC_CONSTANT(std::size_t, short_lag = s);
-    BOOST_STATIC_CONSTANT(uint32_t, default_seed = 19780503u);
-
-    // Required by the old Boost.Random concepts
-    BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
-    // Backwards compatibility
-    BOOST_STATIC_CONSTANT(result_type, modulus = (result_type(1) << w));
-    
-    BOOST_STATIC_ASSERT(std::numeric_limits<result_type>::is_integer);
-
-    /**
-     * Constructs a new @c subtract_with_carry_engine and seeds
-     * it with the default seed.
-     */
-    subtract_with_carry_engine() { seed(); }
-    /**
-     * Constructs a new @c subtract_with_carry_engine and seeds
-     * it with @c value.
-     */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(subtract_with_carry_engine,
-                                               IntType, value)
-    { seed(value); }
-    /**
-     * Constructs a new @c subtract_with_carry_engine and seeds
-     * it with values produced by @c seq.generate().
-     */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(subtract_with_carry_engine,
-                                             SeedSeq, seq)
-    { seed(seq); }
-    /**
-     * Constructs a new @c subtract_with_carry_engine and seeds
-     * it with values from a range.  first is updated to point
-     * one past the last value consumed.  If there are not
-     * enough elements in the range to fill the entire state of
-     * the generator, throws @c std::invalid_argument.
-     */
-    template<class It> subtract_with_carry_engine(It& first, It last)
-    { seed(first,last); }
-
-    // compiler-generated copy ctor and assignment operator are fine
-
-    /** Seeds the generator with the default seed. */
-    void seed() { seed(default_seed); }
-    BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(subtract_with_carry_engine,
-                                        IntType, value)
-    {
-        typedef linear_congruential_engine<uint32_t,40014,0,2147483563> gen_t;
-        gen_t intgen(static_cast<boost::uint32_t>(value == 0 ? default_seed : value));
-        detail::generator_seed_seq<gen_t> gen(intgen);
-        seed(gen);
-    }
-
-    /** Seeds the generator with values produced by @c seq.generate(). */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(subtract_with_carry, SeedSeq, seq)
-    {
-        detail::seed_array_int<w>(seq, x);
-        carry = (x[long_lag-1] == 0);
-        k = 0;
-    }
-
-    /**
-     * Seeds the generator with values from a range.  Updates @c first to
-     * point one past the last consumed value.  If the range does not
-     * contain enough elements to fill the entire state of the generator,
-     * throws @c std::invalid_argument.
-     */
-    template<class It>
-    void seed(It& first, It last)
-    {
-        detail::fill_array_int<w>(first, last, x);
-        carry = (x[long_lag-1] == 0);
-        k = 0;
-    }
-
-    /** Returns the smallest value that the generator can produce. */
-    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return 0; }
-    /** Returns the largest value that the generator can produce. */
-    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return boost::low_bits_mask_t<w>::sig_bits; }
-
-    /** Returns the next value of the generator. */
-    result_type operator()()
-    {
-        std::size_t short_index =
-            (k < short_lag)?
-                (k + long_lag - short_lag) :
-                (k - short_lag);
-        carry = do_update(k, short_index, carry);
-        IntType result = x[k];
-        ++k;
-        if(k >= long_lag)
-            k = 0;
-        return result;
-    }
-
-    /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z)
-    {
-        detail::subtract_with_carry_discard::apply(*this, z);
-    }
-
-    /** Fills a range with random values. */
-    template<class It>
-    void generate(It first, It last)
-    { detail::generate_from_int(*this, first, last); }
- 
-    /** Writes a @c subtract_with_carry_engine to a @c std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, subtract_with_carry_engine, f)
-    {
-        for(unsigned int j = 0; j < f.long_lag; ++j)
-            os << f.compute(j) << ' ';
-        os << f.carry;
-        return os;
-    }
-
-    /** Reads a @c subtract_with_carry_engine from a @c std::istream. */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, subtract_with_carry_engine, f)
-    {
-        for(unsigned int j = 0; j < f.long_lag; ++j)
-            is >> f.x[j] >> std::ws;
-        is >> f.carry;
-        f.k = 0;
-        return is;
-    }
-
-    /**
-     * Returns true if the two generators will produce identical
-     * sequences of values.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(subtract_with_carry_engine, x, y)
-    {
-        for(unsigned int j = 0; j < r; ++j)
-            if(x.compute(j) != y.compute(j))
-                return false;
-        return true;
-    }
-
-    /**
-     * Returns true if the two generators will produce different
-     * sequences of values.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(subtract_with_carry_engine)
-
-private:
-    /// \cond show_private
-    // returns x(i-r+index), where index is in 0..r-1
-    IntType compute(unsigned int index) const
-    {
-        return x[(k+index) % long_lag];
-    }
-
-    friend struct detail::subtract_with_carry_discard;
-
-    IntType do_update(std::size_t current, std::size_t short_index, IntType carry)
-    {
-        IntType delta;
-        IntType temp = x[current] + carry;
-        if (x[short_index] >= temp) {
-            // x(n) >= 0
-            delta =  x[short_index] - temp;
-            carry = 0;
-        } else {
-            // x(n) < 0
-            delta = modulus - temp + x[short_index];
-            carry = 1;
-        }
-        x[current] = delta;
-        return carry;
-    }
-    /// \endcond
-
-    // state representation; next output (state) is x(i)
-    //   x[0]  ... x[k] x[k+1] ... x[long_lag-1]     represents
-    //  x(i-k) ... x(i) x(i+1) ... x(i-k+long_lag-1)
-    // speed: base: 20-25 nsec
-    // ranlux_4: 230 nsec, ranlux_7: 430 nsec, ranlux_14: 810 nsec
-    // This state representation makes operator== and save/restore more
-    // difficult, because we've already computed "too much" and thus
-    // have to undo some steps to get at x(i-r) etc.
-
-    // state representation: next output (state) is x(i)
-    //   x[0]  ... x[k] x[k+1]          ... x[long_lag-1]     represents
-    //  x(i-k) ... x(i) x(i-long_lag+1) ... x(i-k-1)
-    // speed: base 28 nsec
-    // ranlux_4: 370 nsec, ranlux_7: 688 nsec, ranlux_14: 1343 nsec
-    IntType x[long_lag];
-    std::size_t k;
-    IntType carry;
-};
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-//  A definition is required even for integral static constants
-template<class IntType, std::size_t w, std::size_t s, std::size_t r>
-const bool subtract_with_carry_engine<IntType, w, s, r>::has_fixed_range;
-template<class IntType, std::size_t w, std::size_t s, std::size_t r>
-const IntType subtract_with_carry_engine<IntType, w, s, r>::modulus;
-template<class IntType, std::size_t w, std::size_t s, std::size_t r>
-const std::size_t subtract_with_carry_engine<IntType, w, s, r>::word_size;
-template<class IntType, std::size_t w, std::size_t s, std::size_t r>
-const std::size_t subtract_with_carry_engine<IntType, w, s, r>::long_lag;
-template<class IntType, std::size_t w, std::size_t s, std::size_t r>
-const std::size_t subtract_with_carry_engine<IntType, w, s, r>::short_lag;
-template<class IntType, std::size_t w, std::size_t s, std::size_t r>
-const uint32_t subtract_with_carry_engine<IntType, w, s, r>::default_seed;
-#endif
-
-
-// use a floating-point representation to produce values in [0..1)
-/**
- * Instantiations of \subtract_with_carry_01_engine model a
- * \pseudo_random_number_generator.  The algorithm is
- * described in
- *
- *  @blockquote
- *  "A New Class of Random Number Generators", George
- *  Marsaglia and Arif Zaman, Annals of Applied Probability,
- *  Volume 1, Number 3 (1991), 462-480.
- *  @endblockquote
- */
-template<class RealType, std::size_t w, std::size_t s, std::size_t r>
-class subtract_with_carry_01_engine
-{
-public:
-    typedef RealType result_type;
-    BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
-    BOOST_STATIC_CONSTANT(std::size_t, word_size = w);
-    BOOST_STATIC_CONSTANT(std::size_t, long_lag = r);
-    BOOST_STATIC_CONSTANT(std::size_t, short_lag = s);
-    BOOST_STATIC_CONSTANT(boost::uint32_t, default_seed = 19780503u);
-
-    BOOST_STATIC_ASSERT(!std::numeric_limits<result_type>::is_integer);
-
-    /** Creates a new \subtract_with_carry_01_engine using the default seed. */
-    subtract_with_carry_01_engine() { init_modulus(); seed(); }
-    /** Creates a new subtract_with_carry_01_engine and seeds it with value. */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(subtract_with_carry_01_engine,
-                                               boost::uint32_t, value)
-    { init_modulus(); seed(value); }
-    /**
-     * Creates a new \subtract_with_carry_01_engine and seeds with values
-     * produced by seq.generate().
-     */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(subtract_with_carry_01_engine,
-                                             SeedSeq, seq)
-    { init_modulus(); seed(seq); }
-    /**
-     * Creates a new \subtract_with_carry_01_engine and seeds it with values
-     * from a range.  Advances first to point one past the last consumed
-     * value.  If the range does not contain enough elements to fill the
-     * entire state, throws @c std::invalid_argument.
-     */
-    template<class It> subtract_with_carry_01_engine(It& first, It last)
-    { init_modulus(); seed(first,last); }
-
-private:
-    /// \cond show_private
-    void init_modulus()
-    {
-#ifndef BOOST_NO_STDC_NAMESPACE
-        // allow for Koenig lookup
-        using std::pow;
-#endif
-        _modulus = pow(RealType(2), RealType(word_size));
-    }
-    /// \endcond
-
-public:
-    // compiler-generated copy ctor and assignment operator are fine
-
-    /** Seeds the generator with the default seed. */
-    void seed() { seed(default_seed); }
-
-    /** Seeds the generator with @c value. */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(subtract_with_carry_01_engine,
-                                        boost::uint32_t, value)
-    {
-        typedef linear_congruential_engine<uint32_t, 40014, 0, 2147483563> gen_t;
-        gen_t intgen(value == 0 ? default_seed : value);
-        detail::generator_seed_seq<gen_t> gen(intgen);
-        seed(gen);
-    }
-
-    /** Seeds the generator with values produced by @c seq.generate(). */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(subtract_with_carry_01_engine,
-                                      SeedSeq, seq)
-    {
-        detail::seed_array_real<w>(seq, x);
-        carry = (x[long_lag-1] ? result_type(0) : result_type(1 / _modulus));
-        k = 0;
-    }
-
-    /**
-     * Seeds the generator with values from a range.  Updates first to
-     * point one past the last consumed element.  If there are not
-     * enough elements in the range to fill the entire state, throws
-     * @c std::invalid_argument.
-     */
-    template<class It>
-    void seed(It& first, It last)
-    {
-        detail::fill_array_real<w>(first, last, x);
-        carry = (x[long_lag-1] ? result_type(0) : result_type(1 / _modulus));
-        k = 0;
-    }
-
-    /** Returns the smallest value that the generator can produce. */
-    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return result_type(0); }
-    /** Returns the largest value that the generator can produce. */
-    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
-    { return result_type(1); }
-
-    /** Returns the next value of the generator. */
-    result_type operator()()
-    {
-        std::size_t short_index =
-            (k < short_lag) ?
-                (k + long_lag - short_lag) :
-                (k - short_lag);
-        carry = do_update(k, short_index, carry);
-        RealType result = x[k];
-        ++k;
-        if(k >= long_lag)
-            k = 0;
-        return result;
-    }
-
-    /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z)
-    { detail::subtract_with_carry_discard::apply(*this, z); }
-
-    /** Fills a range with random values. */
-    template<class Iter>
-    void generate(Iter first, Iter last)
-    { detail::generate_from_real(*this, first, last); }
-
-    /** Writes a \subtract_with_carry_01_engine to a @c std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, subtract_with_carry_01_engine, f)
-    {
-        std::ios_base::fmtflags oldflags =
-            os.flags(os.dec | os.fixed | os.left); 
-        for(unsigned int j = 0; j < f.long_lag; ++j)
-            os << (f.compute(j) * f._modulus) << ' ';
-        os << (f.carry * f._modulus);
-        os.flags(oldflags);
-        return os;
-    }
-    
-    /** Reads a \subtract_with_carry_01_engine from a @c std::istream. */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, subtract_with_carry_01_engine, f)
-    {
-        RealType value;
-        for(unsigned int j = 0; j < long_lag; ++j) {
-            is >> value >> std::ws;
-            f.x[j] = value / f._modulus;
-        }
-        is >> value;
-        f.carry = value / f._modulus;
-        f.k = 0;
-        return is;
-    }
-
-    /** Returns true if the two generators will produce identical sequences. */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(subtract_with_carry_01_engine, x, y)
-    {
-        for(unsigned int j = 0; j < r; ++j)
-            if(x.compute(j) != y.compute(j))
-                return false;
-        return true;
-    }
-
-    /** Returns true if the two generators will produce different sequences. */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(subtract_with_carry_01_engine)
-
-private:
-    /// \cond show_private
-    RealType compute(unsigned int index) const
-    {
-        return x[(k+index) % long_lag];
-    }
-
-    friend struct detail::subtract_with_carry_discard;
-
-    RealType do_update(std::size_t current, std::size_t short_index, RealType carry)
-    {
-        RealType delta = x[short_index] - x[current] - carry;
-        if(delta < 0) {
-            delta += RealType(1);
-            carry = RealType(1)/_modulus;
-        } else {
-            carry = 0;
-        }
-        x[current] = delta;
-        return carry;
-    }
-    /// \endcond
-    std::size_t k;
-    RealType carry;
-    RealType x[long_lag];
-    RealType _modulus;
-};
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-//  A definition is required even for integral static constants
-template<class RealType, std::size_t w, std::size_t s, std::size_t r>
-const bool subtract_with_carry_01_engine<RealType, w, s, r>::has_fixed_range;
-template<class RealType, std::size_t w, std::size_t s, std::size_t r>
-const std::size_t subtract_with_carry_01_engine<RealType, w, s, r>::word_size;
-template<class RealType, std::size_t w, std::size_t s, std::size_t r>
-const std::size_t subtract_with_carry_01_engine<RealType, w, s, r>::long_lag;
-template<class RealType, std::size_t w, std::size_t s, std::size_t r>
-const std::size_t subtract_with_carry_01_engine<RealType, w, s, r>::short_lag;
-template<class RealType, std::size_t w, std::size_t s, std::size_t r>
-const uint32_t subtract_with_carry_01_engine<RealType, w, s, r>::default_seed;
-#endif
-
-
-/// \cond show_deprecated
-
-template<class IntType, IntType m, unsigned s, unsigned r, IntType v>
-class subtract_with_carry :
-    public subtract_with_carry_engine<IntType,
-        boost::static_log2<m>::value, s, r>
-{
-    typedef subtract_with_carry_engine<IntType,
-        boost::static_log2<m>::value, s, r> base_type;
-public:
-    subtract_with_carry() {}
-    BOOST_RANDOM_DETAIL_GENERATOR_CONSTRUCTOR(subtract_with_carry, Gen, gen)
-    { seed(gen); }
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(subtract_with_carry,
-                                               IntType, val)
-    { seed(val); }
-    template<class It>
-    subtract_with_carry(It& first, It last) : base_type(first, last) {}
-    void seed() { base_type::seed(); }
-    BOOST_RANDOM_DETAIL_GENERATOR_SEED(subtract_with_carry, Gen, gen)
-    {
-        detail::generator_seed_seq<Gen> seq(gen);
-        base_type::seed(seq);
-    }
-    BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(subtract_with_carry, IntType, val)
-    { base_type::seed(val); }
-    template<class It>
-    void seed(It& first, It last) { base_type::seed(first, last); }
-};
-
-template<class RealType, int w, unsigned s, unsigned r, int v = 0>
-class subtract_with_carry_01 :
-    public subtract_with_carry_01_engine<RealType, w, s, r>
-{
-    typedef subtract_with_carry_01_engine<RealType, w, s, r> base_type;
-public:
-    subtract_with_carry_01() {}
-    BOOST_RANDOM_DETAIL_GENERATOR_CONSTRUCTOR(subtract_with_carry_01, Gen, gen)
-    { seed(gen); }
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(subtract_with_carry_01,
-                                               uint32_t, val)
-    { seed(val); }
-    template<class It>
-    subtract_with_carry_01(It& first, It last) : base_type(first, last) {}
-    void seed() { base_type::seed(); }
-    BOOST_RANDOM_DETAIL_GENERATOR_SEED(subtract_with_carry_01, Gen, gen)
-    {
-        detail::generator_seed_seq<Gen> seq(gen);
-        base_type::seed(seq);
-    }
-    BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(subtract_with_carry_01, uint32_t, val)
-    { base_type::seed(val); }
-    template<class It>
-    void seed(It& first, It last) { base_type::seed(first, last); }
-};
-
-/// \endcond
-
-namespace detail {
-
-template<class Engine>
-struct generator_bits;
-
-template<class RealType, std::size_t w, std::size_t s, std::size_t r>
-struct generator_bits<subtract_with_carry_01_engine<RealType, w, s, r> > {
-    static std::size_t value() { return w; }
-};
-
-template<class RealType, int w, unsigned s, unsigned r, int v>
-struct generator_bits<subtract_with_carry_01<RealType, w, s, r, v> > {
-    static std::size_t value() { return w; }
-};
-
-}
-
-} // namespace random
-} // namespace boost
-
-#endif // BOOST_RANDOM_SUBTRACT_WITH_CARRY_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/taus88.hpp b/contrib/libboost/boost_1_65_0/boost/random/taus88.hpp
deleted file mode 100644
index 68214f3aed0..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/taus88.hpp
+++ /dev/null
@@ -1,45 +0,0 @@
-/* boost random/taus88.hpp header file
- *
- * Copyright Jens Maurer 2000-2001
- * 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/libs/random for documentation.
- *
- * $Id$
- *
- */
-
-#ifndef BOOST_RANDOM_TAUS88_HPP
-#define BOOST_RANDOM_TAUS88_HPP
-
-#include <boost/random/linear_feedback_shift.hpp>
-#include <boost/random/xor_combine.hpp>
-
-namespace boost {
-namespace random {
-
-/** 
- * The specialization taus88 was suggested in
- *
- *  @blockquote
- *  "Maximally Equidistributed Combined Tausworthe Generators",
- *  Pierre L'Ecuyer, Mathematics of Computation, Volume 65,
- *  Number 213, January 1996, Pages 203-213
- *  @endblockquote
- */
-typedef xor_combine_engine<
-    xor_combine_engine<
-        linear_feedback_shift_engine<uint32_t, 32, 31, 13, 12>, 0,
-        linear_feedback_shift_engine<uint32_t, 32, 29, 2, 4>, 0>, 0,
-    linear_feedback_shift_engine<uint32_t, 32, 28, 3, 17>, 0> taus88;
-
-} // namespace random
-
-using random::taus88;
-
-} // namespace boost
-
-#endif // BOOST_RANDOM_TAUS88_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/traits.hpp b/contrib/libboost/boost_1_65_0/boost/random/traits.hpp
deleted file mode 100644
index 975421a4d0a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/traits.hpp
+++ /dev/null
@@ -1,107 +0,0 @@
-/* boost random/traits.hpp header file
- *
- * Copyright John Maddock 2015
- * 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.
- *
- * These traits classes serve two purposes: they are designed to mostly
- * work out of the box for multiprecision types (ie number types that are
- * C++ class types and not integers or floats from type-traits point of view),
- * they are also a potential point of specialization for user-defined
- * number types.
- *
- * $Id$
- */
-
-#ifndef BOOST_RANDOM_TRAITS_HPP
-#define BOOST_RANDOM_TRAITS_HPP
-
-#include <boost/type_traits/is_signed.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/make_unsigned.hpp>
-#include <boost/mpl/bool.hpp>
-#include <limits>
-
-namespace boost {
-namespace random {
-namespace traits {
-   // \cond show_private
-   template <class T, bool intrinsic>
-   struct make_unsigned_imp
-   {
-      typedef typename boost::make_unsigned<T>::type type;
-   };
-   template <class T>
-   struct make_unsigned_imp<T, false>
-   {
-      BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_specialized);
-      BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_signed == false);
-      BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_integer == true);
-      typedef T type;
-   };
-   // \endcond
-   /** \brief Converts the argument type T to an unsigned type.
-   *
-   * This trait has a single member `type` which is the unsigned type corresponding to T.
-   * Note that
-   * if T is signed, then member `type` *should define a type with one more bit precision than T*.  For built-in
-   * types this trait defaults to `boost::make_unsigned<T>::type`.  For user defined types it simply asserts that
-   * the argument type T is an unsigned integer (using std::numeric_limits).
-   * User defined specializations may be provided for other cases.
-   */
-   template <class T>
-   struct make_unsigned
-   // \cond show_private
-      : public make_unsigned_imp < T, boost::is_integral<T>::value > 
-      // \endcond
-   {};
-   // \cond show_private
-   template <class T, bool intrinsic>
-   struct make_unsigned_or_unbounded_imp
-   {
-      typedef typename boost::make_unsigned<T>::type type;
-   };
-   template <class T>
-   struct make_unsigned_or_unbounded_imp<T, false>
-   {
-      BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_specialized);
-      BOOST_STATIC_ASSERT((std::numeric_limits<T>::is_signed == false) || (std::numeric_limits<T>::is_bounded == false));
-      BOOST_STATIC_ASSERT(std::numeric_limits<T>::is_integer == true);
-      typedef T type;
-   };
-   // \endcond
-   /** \brief Converts the argument type T to either an unsigned type or an unbounded integer type.
-   *
-   * This trait has a single member `type` which is either the unsigned type corresponding to T or an unbounded
-   * integer type.  This trait is used to generate types suitable for the calculation of a range: as a result
-   * if T is signed, then member `type` *should define a type with one more bit precision than T*.  For built-in
-   * types this trait defaults to `boost::make_unsigned<T>::type`.  For user defined types it simply asserts that
-   * the argument type T is either an unbounded integer, or an unsigned one (using std::numeric_limits).
-   * User defined specializations may be provided for other cases.
-   */
-   template <class T>
-   struct make_unsigned_or_unbounded
-      // \cond show_private
-      : public make_unsigned_or_unbounded_imp < T, boost::is_integral<T>::value > 
-      // \endcond
-   {};
-   /** \brief Traits class that indicates whether type T is an integer
-   */
-   template <class T>
-   struct is_integral
-      : public mpl::bool_<boost::is_integral<T>::value || (std::numeric_limits<T>::is_integer)>
-   {};
-   /** \brief Traits class that indicates whether type T is a signed integer
-   */
-   template <class T> struct is_signed
-      : public mpl::bool_ < boost::is_signed<T>::value || (std::numeric_limits<T>::is_specialized && std::numeric_limits<T>::is_integer && std::numeric_limits<T>::is_signed)>
-   {};
-
-}
-}
-}
-
-#endif
diff --git a/contrib/libboost/boost_1_65_0/boost/random/triangle_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/triangle_distribution.hpp
deleted file mode 100644
index 6d37e2bb926..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/triangle_distribution.hpp
+++ /dev/null
@@ -1,232 +0,0 @@
-/* boost random/triangle_distribution.hpp header file
- *
- * Copyright Jens Maurer 2000-2001
- * 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$
- *
- * Revision history
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_TRIANGLE_DISTRIBUTION_HPP
-#define BOOST_RANDOM_TRIANGLE_DISTRIBUTION_HPP
-
-#include <boost/config/no_tr1/cmath.hpp>
-#include <iosfwd>
-#include <ios>
-#include <istream>
-#include <boost/assert.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/uniform_01.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * Instantiations of @c triangle_distribution model a \random_distribution.
- * A @c triangle_distribution has three parameters, @c a, @c b, and @c c,
- * which are the smallest, the most probable and the largest values of
- * the distribution respectively.
- */
-template<class RealType = double>
-class triangle_distribution
-{
-public:
-    typedef RealType input_type;
-    typedef RealType result_type;
-
-    class param_type
-    {
-    public:
-
-        typedef triangle_distribution distribution_type;
-
-        /** Constructs the parameters of a @c triangle_distribution. */
-        explicit param_type(RealType a_arg = RealType(0.0),
-                            RealType b_arg = RealType(0.5),
-                            RealType c_arg = RealType(1.0))
-          : _a(a_arg), _b(b_arg), _c(c_arg)
-        {
-            BOOST_ASSERT(_a <= _b && _b <= _c);
-        }
-
-        /** Returns the minimum value of the distribution. */
-        RealType a() const { return _a; }
-        /** Returns the mode of the distribution. */
-        RealType b() const { return _b; }
-        /** Returns the maximum value of the distribution. */
-        RealType c() const { return _c; }
-
-        /** Writes the parameters to a @c std::ostream. */
-        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
-        {
-            os << parm._a << " " << parm._b << " " << parm._c;
-            return os;
-        }
-
-        /** Reads the parameters from a @c std::istream. */
-        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
-        {
-            double a_in, b_in, c_in;
-            if(is >> a_in >> std::ws >> b_in >> std::ws >> c_in) {
-                if(a_in <= b_in && b_in <= c_in) {
-                    parm._a = a_in;
-                    parm._b = b_in;
-                    parm._c = c_in;
-                } else {
-                    is.setstate(std::ios_base::failbit);
-                }
-            }
-            return is;
-        }
-
-        /** Returns true if the two sets of parameters are equal. */
-        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        { return lhs._a == rhs._a && lhs._b == rhs._b && lhs._c == rhs._c; }
-
-        /** Returns true if the two sets of parameters are different. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-
-    private:
-        RealType _a;
-        RealType _b;
-        RealType _c;
-    };
-
-    /**
-     * Constructs a @c triangle_distribution with the parameters
-     * @c a, @c b, and @c c.
-     *
-     * Preconditions: a <= b <= c.
-     */
-    explicit triangle_distribution(RealType a_arg = RealType(0.0),
-                                   RealType b_arg = RealType(0.5),
-                                   RealType c_arg = RealType(1.0))
-      : _a(a_arg), _b(b_arg), _c(c_arg)
-    {
-        BOOST_ASSERT(_a <= _b && _b <= _c);
-        init();
-    }
-
-    /** Constructs a @c triangle_distribution from its parameters. */
-    explicit triangle_distribution(const param_type& parm)
-      : _a(parm.a()), _b(parm.b()), _c(parm.c())
-    {
-        init();
-    }
-
-    // compiler-generated copy ctor and assignment operator are fine
-
-    /** Returns the @c a parameter of the distribution */
-    result_type a() const { return _a; }
-    /** Returns the @c b parameter of the distribution */
-    result_type b() const { return _b; }
-    /** Returns the @c c parameter of the distribution */
-    result_type c() const { return _c; }
-
-    /** Returns the smallest value that the distribution can produce. */
-    RealType min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return _a; }
-    /** Returns the largest value that the distribution can produce. */
-    RealType max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return _c; }
-
-    /** Returns the parameters of the distribution. */
-    param_type param() const { return param_type(_a, _b, _c); }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        _a = parm.a();
-        _b = parm.b();
-        _c = parm.c();
-        init();
-    }
-
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { }
-
-    /**
-     * Returns a random variate distributed according to the
-     * triangle distribution.
-     */
-    template<class Engine>
-    result_type operator()(Engine& eng)
-    {
-        using std::sqrt;
-        result_type u = uniform_01<result_type>()(eng);
-        if( u <= q1 )
-            return _a + p1*sqrt(u);
-        else
-        return _c - d3*sqrt(d2*u-d1);
-    }
-
-    /**
-     * Returns a random variate distributed according to the
-     * triangle distribution with parameters specified by param.
-     */
-    template<class Engine>
-    result_type operator()(Engine& eng, const param_type& parm)
-    { return triangle_distribution(parm)(eng); }
-
-    /** Writes the distribution to a @c std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, triangle_distribution, td)
-    {
-        os << td.param();
-        return os;
-    }
-
-    /** Reads the distribution from a @c std::istream. */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, triangle_distribution, td)
-    {
-        param_type parm;
-        if(is >> parm) {
-            td.param(parm);
-        }
-        return is;
-    }
-
-    /**
-     * Returns true if the two distributions will produce identical
-     * sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(triangle_distribution, lhs, rhs)
-    { return lhs._a == rhs._a && lhs._b == rhs._b && lhs._c == rhs._c; }
-
-    /**
-     * Returns true if the two distributions may produce different
-     * sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(triangle_distribution)
-
-private:
-    /// \cond show_private
-    void init()
-    {
-        using std::sqrt;
-        d1 = _b - _a;
-        d2 = _c - _a;
-        d3 = sqrt(_c - _b);
-        q1 = d1 / d2;
-        p1 = sqrt(d1 * d2);
-    }
-    /// \endcond
-
-    RealType _a, _b, _c;
-    RealType d1, d2, d3, q1, p1;
-};
-
-} // namespace random
-
-using random::triangle_distribution;
-
-} // namespace boost
-
-#endif // BOOST_RANDOM_TRIANGLE_DISTRIBUTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/uniform_01.hpp b/contrib/libboost/boost_1_65_0/boost/random/uniform_01.hpp
deleted file mode 100644
index 37258f58064..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/uniform_01.hpp
+++ /dev/null
@@ -1,257 +0,0 @@
-/* boost random/uniform_01.hpp header file
- *
- * Copyright Jens Maurer 2000-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 for most recent version including documentation.
- *
- * $Id$
- *
- * Revision history
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_UNIFORM_01_HPP
-#define BOOST_RANDOM_UNIFORM_01_HPP
-
-#include <iostream>
-#include <boost/config.hpp>
-#include <boost/limits.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/ptr_helper.hpp>
-
-#include <boost/random/detail/disable_warnings.hpp>
-
-namespace boost {
-namespace random {
-
-#ifdef BOOST_RANDOM_DOXYGEN
-
-/**
- * The distribution function uniform_01 models a \random_distribution.
- * On each invocation, it returns a random floating-point value
- * uniformly distributed in the range [0..1).
- *
- * The template parameter RealType shall denote a float-like value type
- * with support for binary operators +, -, and /.
- *
- * Note: The current implementation is buggy, because it may not fill
- * all of the mantissa with random bits. I'm unsure how to fill a
- * (to-be-invented) @c boost::bigfloat class with random bits efficiently.
- * It's probably time for a traits class.
- */
-template<class RealType = double>
-class uniform_01
-{
-public:
-  typedef RealType input_type;
-  typedef RealType result_type;
-  result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const;
-  result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const;
-  void reset();
-
-  template<class Engine>
-  result_type operator()(Engine& eng);
-
-#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
-  template<class CharT, class Traits>
-  friend std::basic_ostream<CharT,Traits>&
-  operator<<(std::basic_ostream<CharT,Traits>& os, const new_uniform_01&)
-  {
-    return os;
-  }
-
-  template<class CharT, class Traits>
-  friend std::basic_istream<CharT,Traits>&
-  operator>>(std::basic_istream<CharT,Traits>& is, new_uniform_01&)
-  {
-    return is;
-  }
-#endif
-};
-
-#else
-
-namespace detail {
-
-template<class RealType>
-class new_uniform_01
-{
-public:
-  typedef RealType input_type;
-  typedef RealType result_type;
-  // compiler-generated copy ctor and copy assignment are fine
-  result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return result_type(0); }
-  result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return result_type(1); }
-  void reset() { }
-
-  template<class Engine>
-  result_type operator()(Engine& eng) {
-    for (;;) {
-      typedef typename Engine::result_type base_result;
-      result_type factor = result_type(1) /
-              (result_type(base_result((eng.max)()-(eng.min)())) +
-               result_type(std::numeric_limits<base_result>::is_integer ? 1 : 0));
-      result_type result = result_type(base_result(eng() - (eng.min)())) * factor;
-      if (result < result_type(1))
-        return result;
-    }
-  }
-
-#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
-  template<class CharT, class Traits>
-  friend std::basic_ostream<CharT,Traits>&
-  operator<<(std::basic_ostream<CharT,Traits>& os, const new_uniform_01&)
-  {
-    return os;
-  }
-
-  template<class CharT, class Traits>
-  friend std::basic_istream<CharT,Traits>&
-  operator>>(std::basic_istream<CharT,Traits>& is, new_uniform_01&)
-  {
-    return is;
-  }
-#endif
-};
-
-template<class UniformRandomNumberGenerator, class RealType>
-class backward_compatible_uniform_01
-{
-  typedef boost::random::detail::ptr_helper<UniformRandomNumberGenerator> traits;
-public:
-  typedef UniformRandomNumberGenerator base_type;
-  typedef RealType result_type;
-
-  BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
-
-#if !defined(BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS)
-  BOOST_STATIC_ASSERT(!std::numeric_limits<RealType>::is_integer);
-#endif
-
-  explicit backward_compatible_uniform_01(typename traits::rvalue_type rng)
-    : _rng(rng),
-      _factor(result_type(1) /
-              (result_type((base().max)()-(base().min)()) +
-               result_type(std::numeric_limits<base_result>::is_integer ? 1 : 0)))
-  {
-  }
-  // compiler-generated copy ctor and copy assignment are fine
-
-  result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return result_type(0); }
-  result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return result_type(1); }
-  typename traits::value_type& base() { return traits::ref(_rng); }
-  const typename traits::value_type& base() const { return traits::ref(_rng); }
-  void reset() { }
-
-  result_type operator()() {
-    for (;;) {
-      result_type result = result_type(base()() - (base().min)()) * _factor;
-      if (result < result_type(1))
-        return result;
-    }
-  }
-
-#if !defined(BOOST_NO_OPERATORS_IN_NAMESPACE) && !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-  template<class CharT, class Traits>
-  friend std::basic_ostream<CharT,Traits>&
-  operator<<(std::basic_ostream<CharT,Traits>& os, const backward_compatible_uniform_01& u)
-  {
-    os << u._rng;
-    return os;
-  }
-
-  template<class CharT, class Traits>
-  friend std::basic_istream<CharT,Traits>&
-  operator>>(std::basic_istream<CharT,Traits>& is, backward_compatible_uniform_01& u)
-  {
-    is >> u._rng;
-    return is;
-  }
-#endif
-
-private:
-  typedef typename traits::value_type::result_type base_result;
-  UniformRandomNumberGenerator _rng;
-  result_type _factor;
-};
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-//  A definition is required even for integral static constants
-template<class UniformRandomNumberGenerator, class RealType>
-const bool backward_compatible_uniform_01<UniformRandomNumberGenerator, RealType>::has_fixed_range;
-#endif
-
-template<class UniformRandomNumberGenerator, bool is_number = std::numeric_limits<UniformRandomNumberGenerator>::is_specialized>
-struct select_uniform_01
-{
-  template<class RealType>
-  struct apply
-  {
-    typedef backward_compatible_uniform_01<UniformRandomNumberGenerator, RealType> type;
-  };
-};
-
-template<class Num>
-struct select_uniform_01<Num, true>
-{
-  template<class RealType>
-  struct apply
-  {
-    typedef new_uniform_01<Num> type;
-  };
-};
-
-}
-
-// Because it is so commonly used: uniform distribution on the real [0..1)
-// range.  This allows for specializations to avoid a costly int -> float
-// conversion plus float multiplication
-template<class UniformRandomNumberGenerator = double, class RealType = double>
-class uniform_01
-  : public detail::select_uniform_01<UniformRandomNumberGenerator>::BOOST_NESTED_TEMPLATE apply<RealType>::type
-{
-  typedef typename detail::select_uniform_01<UniformRandomNumberGenerator>::BOOST_NESTED_TEMPLATE apply<RealType>::type impl_type;
-  typedef boost::random::detail::ptr_helper<UniformRandomNumberGenerator> traits;
-public:
-
-  uniform_01() {}
-
-  explicit uniform_01(typename traits::rvalue_type rng)
-    : impl_type(rng)
-  {
-  }
-
-#if !defined(BOOST_NO_OPERATORS_IN_NAMESPACE) && !defined(BOOST_NO_MEMBER_TEMPLATE_FRIENDS)
-  template<class CharT, class Traits>
-  friend std::basic_ostream<CharT,Traits>&
-  operator<<(std::basic_ostream<CharT,Traits>& os, const uniform_01& u)
-  {
-    os << static_cast<const impl_type&>(u);
-    return os;
-  }
-
-  template<class CharT, class Traits>
-  friend std::basic_istream<CharT,Traits>&
-  operator>>(std::basic_istream<CharT,Traits>& is, uniform_01& u)
-  {
-    is >> static_cast<impl_type&>(u);
-    return is;
-  }
-#endif
-};
-
-#endif
-
-} // namespace random
-
-using random::uniform_01;
-
-} // namespace boost
-
-#include <boost/random/detail/enable_warnings.hpp>
-
-#endif // BOOST_RANDOM_UNIFORM_01_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/uniform_int.hpp b/contrib/libboost/boost_1_65_0/boost/random/uniform_int.hpp
deleted file mode 100644
index 4362652593d..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/uniform_int.hpp
+++ /dev/null
@@ -1,99 +0,0 @@
-/* boost random/uniform_int.hpp header file
- *
- * Copyright Jens Maurer 2000-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 for most recent version including documentation.
- *
- * $Id$
- *
- * Revision history
- *  2001-04-08  added min<max assertion (N. Becker)
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_UNIFORM_INT_HPP
-#define BOOST_RANDOM_UNIFORM_INT_HPP
-
-#include <boost/assert.hpp>
-#include <boost/random/uniform_int_distribution.hpp>
-
-namespace boost {
-
-/**
- * The distribution function uniform_int models a \random_distribution.
- * On each invocation, it returns a random integer value uniformly
- * distributed in the set of integer numbers {min, min+1, min+2, ..., max}.
- *
- * The template parameter IntType shall denote an integer-like value type.
- *
- * This class is deprecated.  Please use @c uniform_int_distribution in
- * new code.
- */
-template<class IntType = int>
-class uniform_int : public random::uniform_int_distribution<IntType>
-{
-    typedef random::uniform_int_distribution<IntType> base_type;
-public:
-
-    class param_type : public base_type::param_type
-    {
-    public:
-        typedef uniform_int distribution_type;
-        /**
-         * Constructs the parameters of a uniform_int distribution.
-         *
-         * Requires: min <= max
-         */
-        explicit param_type(IntType min_arg = 0, IntType max_arg = 9)
-          : base_type::param_type(min_arg, max_arg)
-        {}
-    };
-
-    /**
-     * Constructs a uniform_int object. @c min and @c max are
-     * the parameters of the distribution.
-     *
-     * Requires: min <= max
-     */
-    explicit uniform_int(IntType min_arg = 0, IntType max_arg = 9)
-      : base_type(min_arg, max_arg)
-    {}
-
-    /** Constructs a uniform_int distribution from its parameters. */
-    explicit uniform_int(const param_type& parm)
-      : base_type(parm)
-    {}
-
-    /** Returns the parameters of the distribution */
-    param_type param() const { return param_type(this->a(), this->b()); }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm) { this->base_type::param(parm); }
-
-    // Codergear seems to have trouble with a using declaration here
-
-    template<class Engine>
-    IntType operator()(Engine& eng) const
-    {
-        return static_cast<const base_type&>(*this)(eng);
-    }
-
-    template<class Engine>
-    IntType operator()(Engine& eng, const param_type& parm) const
-    {
-        return static_cast<const base_type&>(*this)(eng, parm);
-    }
-
-    template<class Engine>
-    IntType operator()(Engine& eng, IntType n) const
-    {
-        BOOST_ASSERT(n > 0);
-        return static_cast<const base_type&>(*this)(eng, param_type(0, n - 1));
-    }
-};
-
-} // namespace boost
-
-#endif // BOOST_RANDOM_UNIFORM_INT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/uniform_int_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/uniform_int_distribution.hpp
deleted file mode 100644
index e0d3a9bebcd..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/uniform_int_distribution.hpp
+++ /dev/null
@@ -1,419 +0,0 @@
-/* boost random/uniform_int_distribution.hpp header file
- *
- * Copyright Jens Maurer 2000-2001
- * 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$
- *
- * Revision history
- *  2001-04-08  added min<max assertion (N. Becker)
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_UNIFORM_INT_DISTRIBUTION_HPP
-#define BOOST_RANDOM_UNIFORM_INT_DISTRIBUTION_HPP
-
-#include <iosfwd>
-#include <ios>
-#include <istream>
-#include <boost/config.hpp>
-#include <boost/limits.hpp>
-#include <boost/assert.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/detail/uniform_int_float.hpp>
-#include <boost/random/detail/signed_unsigned_tools.hpp>
-#include <boost/random/traits.hpp>
-#include <boost/mpl/bool.hpp>
-#ifdef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
-#include <boost/mpl/if.hpp>
-#endif
-
-namespace boost {
-namespace random {
-namespace detail {
-    
-
-#ifdef BOOST_MSVC
-#pragma warning(push)
-// disable division by zero warning, since we can't
-// actually divide by zero.
-#pragma warning(disable:4723)
-#endif
-
-template<class Engine, class T>
-T generate_uniform_int(
-    Engine& eng, T min_value, T max_value,
-    boost::mpl::true_ /** is_integral<Engine::result_type> */)
-{
-    typedef T result_type;
-    typedef typename boost::random::traits::make_unsigned_or_unbounded<T>::type range_type;
-    typedef typename Engine::result_type base_result;
-    // ranges are always unsigned or unbounded
-    typedef typename boost::random::traits::make_unsigned_or_unbounded<base_result>::type base_unsigned;
-    const range_type range = random::detail::subtract<result_type>()(max_value, min_value);
-    const base_result bmin = (eng.min)();
-    const base_unsigned brange =
-      random::detail::subtract<base_result>()((eng.max)(), (eng.min)());
-
-    if(range == 0) {
-      return min_value;    
-    } else if(brange == range) {
-      // this will probably never happen in real life
-      // basically nothing to do; just take care we don't overflow / underflow
-      base_unsigned v = random::detail::subtract<base_result>()(eng(), bmin);
-      return random::detail::add<base_unsigned, result_type>()(v, min_value);
-    } else if(brange < range) {
-      // use rejection method to handle things like 0..3 --> 0..4
-      for(;;) {
-        // concatenate several invocations of the base RNG
-        // take extra care to avoid overflows
-
-        //  limit == floor((range+1)/(brange+1))
-        //  Therefore limit*(brange+1) <= range+1
-        range_type limit;
-        if(range == (std::numeric_limits<range_type>::max)()) {
-          limit = range/(range_type(brange)+1);
-          if(range % (range_type(brange)+1) == range_type(brange))
-            ++limit;
-        } else {
-          limit = (range+1)/(range_type(brange)+1);
-        }
-
-        // We consider "result" as expressed to base (brange+1):
-        // For every power of (brange+1), we determine a random factor
-        range_type result = range_type(0);
-        range_type mult = range_type(1);
-
-        // loop invariants:
-        //  result < mult
-        //  mult <= range
-        while(mult <= limit) {
-          // Postcondition: result <= range, thus no overflow
-          //
-          // limit*(brange+1)<=range+1                   def. of limit       (1)
-          // eng()-bmin<=brange                          eng() post.         (2)
-          // and mult<=limit.                            loop condition      (3)
-          // Therefore mult*(eng()-bmin+1)<=range+1      by (1),(2),(3)      (4)
-          // Therefore mult*(eng()-bmin)+mult<=range+1   rearranging (4)     (5)
-          // result<mult                                 loop invariant      (6)
-          // Therefore result+mult*(eng()-bmin)<range+1  by (5), (6)         (7)
-          //
-          // Postcondition: result < mult*(brange+1)
-          //
-          // result<mult                                 loop invariant      (1)
-          // eng()-bmin<=brange                          eng() post.         (2)
-          // Therefore result+mult*(eng()-bmin) <
-          //           mult+mult*(eng()-bmin)            by (1)              (3)
-          // Therefore result+(eng()-bmin)*mult <
-          //           mult+mult*brange                  by (2), (3)         (4)
-          // Therefore result+(eng()-bmin)*mult <
-          //           mult*(brange+1)                   by (4)
-          result += static_cast<range_type>(static_cast<range_type>(random::detail::subtract<base_result>()(eng(), bmin)) * mult);
-
-          // equivalent to (mult * (brange+1)) == range+1, but avoids overflow.
-          if(mult * range_type(brange) == range - mult + 1) {
-              // The destination range is an integer power of
-              // the generator's range.
-              return(result);
-          }
-
-          // Postcondition: mult <= range
-          // 
-          // limit*(brange+1)<=range+1                   def. of limit       (1)
-          // mult<=limit                                 loop condition      (2)
-          // Therefore mult*(brange+1)<=range+1          by (1), (2)         (3)
-          // mult*(brange+1)!=range+1                    preceding if        (4)
-          // Therefore mult*(brange+1)<range+1           by (3), (4)         (5)
-          // 
-          // Postcondition: result < mult
-          //
-          // See the second postcondition on the change to result. 
-          mult *= range_type(brange)+range_type(1);
-        }
-        // loop postcondition: range/mult < brange+1
-        //
-        // mult > limit                                  loop condition      (1)
-        // Suppose range/mult >= brange+1                Assumption          (2)
-        // range >= mult*(brange+1)                      by (2)              (3)
-        // range+1 > mult*(brange+1)                     by (3)              (4)
-        // range+1 > (limit+1)*(brange+1)                by (1), (4)         (5)
-        // (range+1)/(brange+1) > limit+1                by (5)              (6)
-        // limit < floor((range+1)/(brange+1))           by (6)              (7)
-        // limit==floor((range+1)/(brange+1))            def. of limit       (8)
-        // not (2)                                       reductio            (9)
-        //
-        // loop postcondition: (range/mult)*mult+(mult-1) >= range
-        //
-        // (range/mult)*mult + range%mult == range       identity            (1)
-        // range%mult < mult                             def. of %           (2)
-        // (range/mult)*mult+mult > range                by (1), (2)         (3)
-        // (range/mult)*mult+(mult-1) >= range           by (3)              (4)
-        //
-        // Note that the maximum value of result at this point is (mult-1),
-        // so after this final step, we generate numbers that can be
-        // at least as large as range.  We have to really careful to avoid
-        // overflow in this final addition and in the rejection.  Anything
-        // that overflows is larger than range and can thus be rejected.
-
-        // range/mult < brange+1  -> no endless loop
-        range_type result_increment =
-            generate_uniform_int(
-                eng,
-                static_cast<range_type>(0),
-                static_cast<range_type>(range/mult),
-                boost::mpl::true_());
-        if(std::numeric_limits<range_type>::is_bounded && ((std::numeric_limits<range_type>::max)() / mult < result_increment)) {
-          // The multiplcation would overflow.  Reject immediately.
-          continue;
-        }
-        result_increment *= mult;
-        // unsigned integers are guaranteed to wrap on overflow.
-        result += result_increment;
-        if(result < result_increment) {
-          // The addition overflowed.  Reject.
-          continue;
-        }
-        if(result > range) {
-          // Too big.  Reject.
-          continue;
-        }
-        return random::detail::add<range_type, result_type>()(result, min_value);
-      }
-    } else {                   // brange > range
-#ifdef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
-      typedef typename mpl::if_c<
-         std::numeric_limits<range_type>::is_specialized && std::numeric_limits<base_unsigned>::is_specialized
-         && (std::numeric_limits<range_type>::digits >= std::numeric_limits<base_unsigned>::digits),
-         range_type, base_unsigned>::type mixed_range_type;
-#else
-      typedef base_unsigned mixed_range_type;
-#endif
-
-      mixed_range_type bucket_size;
-      // it's safe to add 1 to range, as long as we cast it first,
-      // because we know that it is less than brange.  However,
-      // we do need to be careful not to cause overflow by adding 1
-      // to brange.  We use mixed_range_type throughout for mixed
-      // arithmetic between base_unsigned and range_type - in the case
-      // that range_type has more bits than base_unsigned it is always
-      // safe to use range_type for this albeit it may be more effient
-      // to use base_unsigned.  The latter is a narrowing conversion though
-      // which may be disallowed if range_type is a multiprecision type
-      // and there are no explicit converison operators.
-
-      if(brange == (std::numeric_limits<base_unsigned>::max)()) {
-        bucket_size = static_cast<mixed_range_type>(brange) / (static_cast<mixed_range_type>(range)+1);
-        if(static_cast<mixed_range_type>(brange) % (static_cast<mixed_range_type>(range)+1) == static_cast<mixed_range_type>(range)) {
-          ++bucket_size;
-        }
-      } else {
-        bucket_size = static_cast<mixed_range_type>(brange + 1) / (static_cast<mixed_range_type>(range)+1);
-      }
-      for(;;) {
-        mixed_range_type result =
-          random::detail::subtract<base_result>()(eng(), bmin);
-        result /= bucket_size;
-        // result and range are non-negative, and result is possibly larger
-        // than range, so the cast is safe
-        if(result <= static_cast<mixed_range_type>(range))
-          return random::detail::add<mixed_range_type, result_type>()(result, min_value);
-      }
-    }
-}
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-template<class Engine, class T>
-inline T generate_uniform_int(
-    Engine& eng, T min_value, T max_value,
-    boost::mpl::false_ /** is_integral<Engine::result_type> */)
-{
-    uniform_int_float<Engine> wrapper(eng);
-    return generate_uniform_int(wrapper, min_value, max_value, boost::mpl::true_());
-}
-
-template<class Engine, class T>
-inline T generate_uniform_int(Engine& eng, T min_value, T max_value)
-{
-    typedef typename Engine::result_type base_result;
-    return generate_uniform_int(eng, min_value, max_value,
-        boost::random::traits::is_integral<base_result>());
-}
-
-}
-
-/**
- * The class template uniform_int_distribution models a \random_distribution.
- * On each invocation, it returns a random integer value uniformly
- * distributed in the set of integers {min, min+1, min+2, ..., max}.
- *
- * The template parameter IntType shall denote an integer-like value type.
- */
-template<class IntType = int>
-class uniform_int_distribution
-{
-public:
-    typedef IntType input_type;
-    typedef IntType result_type;
-
-    class param_type
-    {
-    public:
-
-        typedef uniform_int_distribution distribution_type;
-
-        /**
-         * Constructs the parameters of a uniform_int_distribution.
-         *
-         * Requires min <= max
-         */
-        explicit param_type(
-            IntType min_arg = 0,
-            IntType max_arg = (std::numeric_limits<IntType>::max)())
-          : _min(min_arg), _max(max_arg)
-        {
-            BOOST_ASSERT(_min <= _max);
-        }
-
-        /** Returns the minimum value of the distribution. */
-        IntType a() const { return _min; }
-        /** Returns the maximum value of the distribution. */
-        IntType b() const { return _max; }
-
-        /** Writes the parameters to a @c std::ostream. */
-        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
-        {
-            os << parm._min << " " << parm._max;
-            return os;
-        }
-
-        /** Reads the parameters from a @c std::istream. */
-        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
-        {
-            IntType min_in, max_in;
-            if(is >> min_in >> std::ws >> max_in) {
-                if(min_in <= max_in) {
-                    parm._min = min_in;
-                    parm._max = max_in;
-                } else {
-                    is.setstate(std::ios_base::failbit);
-                }
-            }
-            return is;
-        }
-
-        /** Returns true if the two sets of parameters are equal. */
-        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        { return lhs._min == rhs._min && lhs._max == rhs._max; }
-
-        /** Returns true if the two sets of parameters are different. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-
-    private:
-
-        IntType _min;
-        IntType _max;
-    };
-
-    /**
-     * Constructs a uniform_int_distribution. @c min and @c max are
-     * the parameters of the distribution.
-     *
-     * Requires: min <= max
-     */
-    explicit uniform_int_distribution(
-        IntType min_arg = 0,
-        IntType max_arg = (std::numeric_limits<IntType>::max)())
-      : _min(min_arg), _max(max_arg)
-    {
-        BOOST_ASSERT(min_arg <= max_arg);
-    }
-    /** Constructs a uniform_int_distribution from its parameters. */
-    explicit uniform_int_distribution(const param_type& parm)
-      : _min(parm.a()), _max(parm.b()) {}
-
-    /**  Returns the minimum value of the distribution */
-    IntType min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return _min; }
-    /**  Returns the maximum value of the distribution */
-    IntType max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return _max; }
-
-    /**  Returns the minimum value of the distribution */
-    IntType a() const { return _min; }
-    /**  Returns the maximum value of the distribution */
-    IntType b() const { return _max; }
-
-    /** Returns the parameters of the distribution. */
-    param_type param() const { return param_type(_min, _max); }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        _min = parm.a();
-        _max = parm.b();
-    }
-
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { }
-
-    /** Returns an integer uniformly distributed in the range [min, max]. */
-    template<class Engine>
-    result_type operator()(Engine& eng) const
-    { return detail::generate_uniform_int(eng, _min, _max); }
-
-    /**
-     * Returns an integer uniformly distributed in the range
-     * [param.a(), param.b()].
-     */
-    template<class Engine>
-    result_type operator()(Engine& eng, const param_type& parm) const
-    { return detail::generate_uniform_int(eng, parm.a(), parm.b()); }
-
-    /** Writes the distribution to a @c std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, uniform_int_distribution, ud)
-    {
-        os << ud.param();
-        return os;
-    }
-
-    /** Reads the distribution from a @c std::istream. */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, uniform_int_distribution, ud)
-    {
-        param_type parm;
-        if(is >> parm) {
-            ud.param(parm);
-        }
-        return is;
-    }
-
-    /**
-     * Returns true if the two distributions will produce identical sequences
-     * of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(uniform_int_distribution, lhs, rhs)
-    { return lhs._min == rhs._min && lhs._max == rhs._max; }
-    
-    /**
-     * Returns true if the two distributions may produce different sequences
-     * of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(uniform_int_distribution)
-
-private:
-    IntType _min;
-    IntType _max;
-};
-
-} // namespace random
-} // namespace boost
-
-#endif // BOOST_RANDOM_UNIFORM_INT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/uniform_on_sphere.hpp b/contrib/libboost/boost_1_65_0/boost/random/uniform_on_sphere.hpp
deleted file mode 100644
index 72c25ef7814..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/uniform_on_sphere.hpp
+++ /dev/null
@@ -1,284 +0,0 @@
-/* boost random/uniform_on_sphere.hpp header file
- *
- * Copyright Jens Maurer 2000-2001
- * 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$
- *
- * Revision history
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_UNIFORM_ON_SPHERE_HPP
-#define BOOST_RANDOM_UNIFORM_ON_SPHERE_HPP
-
-#include <vector>
-#include <algorithm>     // std::transform
-#include <functional>    // std::bind2nd, std::divides
-#include <boost/assert.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/normal_distribution.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * Instantiations of class template uniform_on_sphere model a
- * \random_distribution. Such a distribution produces random
- * numbers uniformly distributed on the unit sphere of arbitrary
- * dimension @c dim. The @c Cont template parameter must be a STL-like
- * container type with begin and end operations returning non-const
- * ForwardIterators of type @c Cont::iterator. 
- */
-template<class RealType = double, class Cont = std::vector<RealType> >
-class uniform_on_sphere
-{
-public:
-    typedef RealType input_type;
-    typedef Cont result_type;
-
-    class param_type
-    {
-    public:
-
-        typedef uniform_on_sphere distribution_type;
-
-        /**
-         * Constructs the parameters of a uniform_on_sphere
-         * distribution, given the dimension of the sphere.
-         */
-        explicit param_type(int dim_arg = 2) : _dim(dim_arg)
-        {
-            BOOST_ASSERT(_dim >= 0);
-        }
-
-        /** Returns the dimension of the sphere. */
-        int dim() const { return _dim; }
-
-        /** Writes the parameters to a @c std::ostream. */
-        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
-        {
-            os << parm._dim;
-            return os;
-        }
-
-        /** Reads the parameters from a @c std::istream. */
-        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
-        {
-            is >> parm._dim;
-            return is;
-        }
-
-        /** Returns true if the two sets of parameters are equal. */
-        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        { return lhs._dim == rhs._dim; }
-
-        /** Returns true if the two sets of parameters are different. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-
-    private:
-        int _dim;
-    };
-
-    /**
-     * Constructs a @c uniform_on_sphere distribution.
-     * @c dim is the dimension of the sphere.
-     *
-     * Requires: dim >= 0
-     */
-    explicit uniform_on_sphere(int dim_arg = 2)
-      : _container(dim_arg), _dim(dim_arg) { }
-
-    /**
-     * Constructs a @c uniform_on_sphere distribution from its parameters.
-     */
-    explicit uniform_on_sphere(const param_type& parm)
-      : _container(parm.dim()), _dim(parm.dim()) { }
-
-    // compiler-generated copy ctor and assignment operator are fine
-
-    /** Returns the dimension of the sphere. */
-    int dim() const { return _dim; }
-
-    /** Returns the parameters of the distribution. */
-    param_type param() const { return param_type(_dim); }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        _dim = parm.dim();
-        _container.resize(_dim);
-    }
-
-    /**
-     * Returns the smallest value that the distribution can produce.
-     * Note that this is required to approximate the standard library's
-     * requirements.  The behavior is defined according to lexicographical
-     * comparison so that for a container type of std::vector,
-     * dist.min() <= x <= dist.max() where x is any value produced
-     * by the distribution.
-     */
-    result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    {
-        result_type result(_dim);
-        if(_dim != 0) {
-            result.front() = RealType(-1.0);
-        }
-        return result;
-    }
-    /**
-     * Returns the largest value that the distribution can produce.
-     * Note that this is required to approximate the standard library's
-     * requirements.  The behavior is defined according to lexicographical
-     * comparison so that for a container type of std::vector,
-     * dist.min() <= x <= dist.max() where x is any value produced
-     * by the distribution.
-     */
-    result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const
-    {
-        result_type result(_dim);
-        if(_dim != 0) {
-            result.front() = RealType(1.0);
-        }
-        return result;
-    }
-
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() {}
-
-    /**
-     * Returns a point uniformly distributed over the surface of
-     * a sphere of dimension dim().
-     */
-    template<class Engine>
-    const result_type & operator()(Engine& eng)
-    {
-        using std::sqrt;
-        switch(_dim)
-        {
-        case 0: break;
-        case 1:
-            {
-                if(uniform_01<RealType>()(eng) < 0.5) {
-                    *_container.begin() = -1;
-                } else {
-                    *_container.begin() = 1;
-                }
-                break;
-            }
-        case 2:
-            {
-                uniform_01<RealType> uniform;
-                RealType sqsum;
-                RealType x, y;
-                do {
-                    x = uniform(eng) * 2 - 1;
-                    y = uniform(eng) * 2 - 1;
-                    sqsum = x*x + y*y;
-                } while(sqsum == 0 || sqsum > 1);
-                RealType mult = 1/sqrt(sqsum);
-                typename Cont::iterator iter = _container.begin();
-                *iter = x * mult;
-                iter++;
-                *iter = y * mult;
-                break;
-            }
-        case 3:
-            {
-                uniform_01<RealType> uniform;
-                RealType sqsum;
-                RealType x, y;
-                do {
-                    x = uniform(eng) * 2 - 1;
-                    y = uniform(eng) * 2 - 1;
-                    sqsum = x*x + y*y;
-                } while(sqsum > 1);
-                RealType mult = 2 * sqrt(1 - sqsum);
-                typename Cont::iterator iter = _container.begin();
-                *iter = x * mult;
-                ++iter;
-                *iter = y * mult;
-                ++iter;
-                *iter = 2 * sqsum - 1;
-                break;
-            }
-        default:
-            {
-                detail::unit_normal_distribution<RealType> normal;
-                RealType sqsum;
-                do {
-                    sqsum = 0;
-                    for(typename Cont::iterator it = _container.begin();
-                        it != _container.end();
-                        ++it) {
-                        RealType val = normal(eng);
-                        *it = val;
-                        sqsum += val * val;
-                    }
-                } while(sqsum == 0);
-                // for all i: result[i] /= sqrt(sqsum)
-                std::transform(_container.begin(), _container.end(), _container.begin(),
-                               std::bind2nd(std::multiplies<RealType>(), 1/sqrt(sqsum)));
-            }
-        }
-        return _container;
-    }
-
-    /**
-     * Returns a point uniformly distributed over the surface of
-     * a sphere of dimension param.dim().
-     */
-    template<class Engine>
-    result_type operator()(Engine& eng, const param_type& parm) const
-    {
-        return uniform_on_sphere(parm)(eng);
-    }
-
-    /** Writes the distribution to a @c std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, uniform_on_sphere, sd)
-    {
-        os << sd._dim;
-        return os;
-    }
-
-    /** Reads the distribution from a @c std::istream. */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, uniform_on_sphere, sd)
-    {
-        is >> sd._dim;
-        sd._container.resize(sd._dim);
-        return is;
-    }
-
-    /**
-     * Returns true if the two distributions will produce identical
-     * sequences of values, given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(uniform_on_sphere, lhs, rhs)
-    { return lhs._dim == rhs._dim; }
-
-    /**
-     * Returns true if the two distributions may produce different
-     * sequences of values, given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(uniform_on_sphere)
-
-private:
-    result_type _container;
-    int _dim;
-};
-
-} // namespace random
-
-using random::uniform_on_sphere;
-
-} // namespace boost
-
-#endif // BOOST_RANDOM_UNIFORM_ON_SPHERE_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/uniform_real.hpp b/contrib/libboost/boost_1_65_0/boost/random/uniform_real.hpp
deleted file mode 100644
index c98626e7792..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/uniform_real.hpp
+++ /dev/null
@@ -1,82 +0,0 @@
-/* boost random/uniform_real.hpp header file
- *
- * Copyright Jens Maurer 2000-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 for most recent version including documentation.
- *
- * $Id$
- *
- * Revision history
- *  2001-04-08  added min<max assertion (N. Becker)
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_UNIFORM_REAL_HPP
-#define BOOST_RANDOM_UNIFORM_REAL_HPP
-
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/limits.hpp>
-#include <boost/random/uniform_real_distribution.hpp>
-
-namespace boost {
-
-/**
- * The distribution function uniform_real models a random distribution.
- * On each invocation, it returns a random floating-point value uniformly
- * distributed in the range [min..max).
- *
- * This class is deprecated.  Please use @c uniform_real_distribution in
- * new code.
- */
-template<class RealType = double>
-class uniform_real : public random::uniform_real_distribution<RealType>
-{
-    typedef random::uniform_real_distribution<RealType> base_type;
-public:
-
-    class param_type : public base_type::param_type
-    {
-    public:
-        typedef uniform_real distribution_type;
-        /**
-         * Constructs the parameters of a uniform_real distribution.
-         *
-         * Requires: min <= max
-         */
-        explicit param_type(RealType min_arg = RealType(0.0),
-                            RealType max_arg = RealType(1.0))
-          : base_type::param_type(min_arg, max_arg)
-        {}
-    };
-
-    /**
-     * Constructs a uniform_real object. @c min and @c max are the
-     * parameters of the distribution.
-     *
-     * Requires: min <= max
-     */
-    explicit uniform_real(RealType min_arg = RealType(0.0),
-                          RealType max_arg = RealType(1.0))
-      : base_type(min_arg, max_arg)
-    {
-        BOOST_ASSERT(min_arg < max_arg);
-    }
-
-    /** Constructs a uniform_real distribution from its parameters. */
-    explicit uniform_real(const param_type& parm)
-      : base_type(parm)
-    {}
-
-    /** Returns the parameters of the distribution */
-    param_type param() const { return param_type(this->a(), this->b()); }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm) { this->base_type::param(parm); }
-};
-
-} // namespace boost
-
-#endif // BOOST_RANDOM_UNIFORM_REAL_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/uniform_real_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/uniform_real_distribution.hpp
deleted file mode 100644
index 820fce9314c..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/uniform_real_distribution.hpp
+++ /dev/null
@@ -1,241 +0,0 @@
-/* boost random/uniform_real_distribution.hpp header file
- *
- * Copyright Jens Maurer 2000-2001
- * 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_UNIFORM_REAL_DISTRIBUTION_HPP
-#define BOOST_RANDOM_UNIFORM_REAL_DISTRIBUTION_HPP
-
-#include <iosfwd>
-#include <ios>
-#include <istream>
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/detail/signed_unsigned_tools.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/mpl/bool.hpp>
-
-namespace boost {
-namespace random {
-namespace detail {
-
-template<class Engine, class T>
-T generate_uniform_real(
-    Engine& eng, T min_value, T max_value,
-    boost::mpl::false_  /** is_integral<Engine::result_type> */)
-{
-    for(;;) {
-        typedef T result_type;
-        result_type numerator = static_cast<T>(eng() - (eng.min)());
-        result_type divisor = static_cast<T>((eng.max)() - (eng.min)());
-        BOOST_ASSERT(divisor > 0);
-        BOOST_ASSERT(numerator >= 0 && numerator <= divisor);
-        T result = numerator / divisor * (max_value - min_value) + min_value;
-        if(result < max_value) return result;
-    }
-}
-
-template<class Engine, class T>
-T generate_uniform_real(
-    Engine& eng, T min_value, T max_value,
-    boost::mpl::true_  /** is_integral<Engine::result_type> */)
-{
-    for(;;) {
-        typedef T result_type;
-        typedef typename Engine::result_type base_result;
-        result_type numerator = static_cast<T>(subtract<base_result>()(eng(), (eng.min)()));
-        result_type divisor = static_cast<T>(subtract<base_result>()((eng.max)(), (eng.min)())) + 1;
-        BOOST_ASSERT(divisor > 0);
-        BOOST_ASSERT(numerator >= 0 && numerator <= divisor);
-        T result = numerator / divisor * (max_value - min_value) + min_value;
-        if(result < max_value) return result;
-    }
-}
-
-template<class Engine, class T>
-inline T generate_uniform_real(Engine& eng, T min_value, T max_value)
-{
-    if(max_value / 2 - min_value / 2 > (std::numeric_limits<T>::max)() / 2)
-        return 2 * generate_uniform_real(eng, T(min_value / 2), T(max_value / 2));
-    typedef typename Engine::result_type base_result;
-    return generate_uniform_real(eng, min_value, max_value,
-        boost::is_integral<base_result>());
-}
-
-}
-
-/**
- * The class template uniform_real_distribution models a \random_distribution.
- * On each invocation, it returns a random floating-point value uniformly
- * distributed in the range [min..max).
- */
-template<class RealType = double>
-class uniform_real_distribution
-{
-public:
-    typedef RealType input_type;
-    typedef RealType result_type;
-
-    class param_type
-    {
-    public:
-
-        typedef uniform_real_distribution distribution_type;
-
-        /**
-         * Constructs the parameters of a uniform_real_distribution.
-         *
-         * Requires min <= max
-         */
-        explicit param_type(RealType min_arg = RealType(0.0),
-                            RealType max_arg = RealType(1.0))
-          : _min(min_arg), _max(max_arg)
-        {
-            BOOST_ASSERT(_min < _max);
-        }
-
-        /** Returns the minimum value of the distribution. */
-        RealType a() const { return _min; }
-        /** Returns the maximum value of the distribution. */
-        RealType b() const { return _max; }
-
-        /** Writes the parameters to a @c std::ostream. */
-        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
-        {
-            os << parm._min << " " << parm._max;
-            return os;
-        }
-
-        /** Reads the parameters from a @c std::istream. */
-        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
-        {
-            RealType min_in, max_in;
-            if(is >> min_in >> std::ws >> max_in) {
-                if(min_in <= max_in) {
-                    parm._min = min_in;
-                    parm._max = max_in;
-                } else {
-                    is.setstate(std::ios_base::failbit);
-                }
-            }
-            return is;
-        }
-
-        /** Returns true if the two sets of parameters are equal. */
-        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        { return lhs._min == rhs._min && lhs._max == rhs._max; }
-
-        /** Returns true if the two sets of parameters are different. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-
-    private:
-
-        RealType _min;
-        RealType _max;
-    };
-
-    /**
-     * Constructs a uniform_real_distribution. @c min and @c max are
-     * the parameters of the distribution.
-     *
-     * Requires: min <= max
-     */
-    explicit uniform_real_distribution(
-        RealType min_arg = RealType(0.0),
-        RealType max_arg = RealType(1.0))
-      : _min(min_arg), _max(max_arg)
-    {
-        BOOST_ASSERT(min_arg < max_arg);
-    }
-    /** Constructs a uniform_real_distribution from its parameters. */
-    explicit uniform_real_distribution(const param_type& parm)
-      : _min(parm.a()), _max(parm.b()) {}
-
-    /**  Returns the minimum value of the distribution */
-    RealType min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return _min; }
-    /**  Returns the maximum value of the distribution */
-    RealType max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return _max; }
-
-    /**  Returns the minimum value of the distribution */
-    RealType a() const { return _min; }
-    /**  Returns the maximum value of the distribution */
-    RealType b() const { return _max; }
-
-    /** Returns the parameters of the distribution. */
-    param_type param() const { return param_type(_min, _max); }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        _min = parm.a();
-        _max = parm.b();
-    }
-
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { }
-
-    /** Returns a value uniformly distributed in the range [min, max). */
-    template<class Engine>
-    result_type operator()(Engine& eng) const
-    { return detail::generate_uniform_real(eng, _min, _max); }
-
-    /**
-     * Returns a value uniformly distributed in the range
-     * [param.a(), param.b()).
-     */
-    template<class Engine>
-    result_type operator()(Engine& eng, const param_type& parm) const
-    { return detail::generate_uniform_real(eng, parm.a(), parm.b()); }
-
-    /** Writes the distribution to a @c std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, uniform_real_distribution, ud)
-    {
-        os << ud.param();
-        return os;
-    }
-
-    /** Reads the distribution from a @c std::istream. */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, uniform_real_distribution, ud)
-    {
-        param_type parm;
-        if(is >> parm) {
-            ud.param(parm);
-        }
-        return is;
-    }
-
-    /**
-     * Returns true if the two distributions will produce identical sequences
-     * of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(uniform_real_distribution, lhs, rhs)
-    { return lhs._min == rhs._min && lhs._max == rhs._max; }
-    
-    /**
-     * Returns true if the two distributions may produce different sequences
-     * of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(uniform_real_distribution)
-
-private:
-    RealType _min;
-    RealType _max;
-};
-
-} // namespace random
-} // namespace boost
-
-#endif // BOOST_RANDOM_UNIFORM_INT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/uniform_smallint.hpp b/contrib/libboost/boost_1_65_0/boost/random/uniform_smallint.hpp
deleted file mode 100644
index c1afd7fbcdf..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/uniform_smallint.hpp
+++ /dev/null
@@ -1,307 +0,0 @@
-/* boost random/uniform_smallint.hpp header file
- *
- * Copyright Jens Maurer 2000-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 for most recent version including documentation.
- *
- * $Id$
- *
- * Revision history
- *  2001-04-08  added min<max assertion (N. Becker)
- *  2001-02-18  moved to individual header files
- */
-
-#ifndef BOOST_RANDOM_UNIFORM_SMALLINT_HPP
-#define BOOST_RANDOM_UNIFORM_SMALLINT_HPP
-
-#include <istream>
-#include <iosfwd>
-#include <boost/assert.hpp>
-#include <boost/config.hpp>
-#include <boost/limits.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/detail/signed_unsigned_tools.hpp>
-#include <boost/random/uniform_01.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/mpl/bool.hpp>
-
-#ifdef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
-#include <boost/mpl/if.hpp>
-#endif
-
-namespace boost {
-namespace random {
-
-// uniform integer distribution on a small range [min, max]
-
-/**
- * The distribution function uniform_smallint models a \random_distribution.
- * On each invocation, it returns a random integer value uniformly distributed
- * in the set of integer numbers {min, min+1, min+2, ..., max}. It assumes
- * that the desired range (max-min+1) is small compared to the range of the
- * underlying source of random numbers and thus makes no attempt to limit
- * quantization errors.
- *
- * Let \f$r_{\mathtt{out}} = (\mbox{max}-\mbox{min}+1)\f$ the desired range of
- * integer numbers, and
- * let \f$r_{\mathtt{base}}\f$ be the range of the underlying source of random
- * numbers. Then, for the uniform distribution, the theoretical probability
- * for any number i in the range \f$r_{\mathtt{out}}\f$ will be
- * \f$\displaystyle p_{\mathtt{out}}(i) = \frac{1}{r_{\mathtt{out}}}\f$.
- * Likewise, assume a uniform distribution on \f$r_{\mathtt{base}}\f$ for
- * the underlying source of random numbers, i.e.
- * \f$\displaystyle p_{\mathtt{base}}(i) = \frac{1}{r_{\mathtt{base}}}\f$.
- * Let \f$p_{\mathtt{out\_s}}(i)\f$ denote the random
- * distribution generated by @c uniform_smallint. Then the sum over all
- * i in \f$r_{\mathtt{out}}\f$ of
- * \f$\displaystyle
- * \left(\frac{p_{\mathtt{out\_s}}(i)}{p_{\mathtt{out}}(i)} - 1\right)^2\f$
- * shall not exceed
- * \f$\displaystyle \frac{r_{\mathtt{out}}}{r_{\mathtt{base}}^2}
- * (r_{\mathtt{base}} \mbox{ mod } r_{\mathtt{out}})
- * (r_{\mathtt{out}} - r_{\mathtt{base}} \mbox{ mod } r_{\mathtt{out}})\f$.
- *
- * The template parameter IntType shall denote an integer-like value type.
- *
- * @xmlnote
- * The property above is the square sum of the relative differences
- * in probabilities between the desired uniform distribution
- * \f$p_{\mathtt{out}}(i)\f$ and the generated distribution
- * \f$p_{\mathtt{out\_s}}(i)\f$.
- * The property can be fulfilled with the calculation
- * \f$(\mbox{base\_rng} \mbox{ mod } r_{\mathtt{out}})\f$, as follows:
- * Let \f$r = r_{\mathtt{base}} \mbox{ mod } r_{\mathtt{out}}\f$.
- * The base distribution on \f$r_{\mathtt{base}}\f$ is folded onto the
- * range \f$r_{\mathtt{out}}\f$. The numbers i < r have assigned
- * \f$\displaystyle
- * \left\lfloor\frac{r_{\mathtt{base}}}{r_{\mathtt{out}}}\right\rfloor+1\f$
- * numbers of the base distribution, the rest has only \f$\displaystyle
- * \left\lfloor\frac{r_{\mathtt{base}}}{r_{\mathtt{out}}}\right\rfloor\f$.
- * Therefore,
- * \f$\displaystyle p_{\mathtt{out\_s}}(i) =
- * \left(\left\lfloor\frac{r_{\mathtt{base}}}
- * {r_{\mathtt{out}}}\right\rfloor+1\right) /
- * r_{\mathtt{base}}\f$ for i < r and \f$\displaystyle p_{\mathtt{out\_s}}(i) =
- * \left\lfloor\frac{r_{\mathtt{base}}}
- * {r_{\mathtt{out}}}\right\rfloor/r_{\mathtt{base}}\f$ otherwise.
- * Substituting this in the
- * above sum formula leads to the desired result.
- * @endxmlnote
- *
- * Note: The upper bound for
- * \f$(r_{\mathtt{base}} \mbox{ mod } r_{\mathtt{out}})
- * (r_{\mathtt{out}} - r_{\mathtt{base}} \mbox{ mod } r_{\mathtt{out}})\f$ is
- * \f$\displaystyle \frac{r_{\mathtt{out}}^2}{4}\f$.  Regarding the upper bound
- * for the square sum of the relative quantization error of
- * \f$\displaystyle \frac{r_\mathtt{out}^3}{4r_{\mathtt{base}}^2}\f$, it
- * seems wise to either choose \f$r_{\mathtt{base}}\f$ so that
- * \f$r_{\mathtt{base}} > 10r_{\mathtt{out}}^2\f$ or ensure that
- * \f$r_{\mathtt{base}}\f$ is
- * divisible by \f$r_{\mathtt{out}}\f$.
- */
-template<class IntType = int>
-class uniform_smallint
-{
-public:
-    typedef IntType input_type;
-    typedef IntType result_type;
-
-    class param_type
-    {
-    public:
-
-        typedef uniform_smallint distribution_type;
-
-        /** constructs the parameters of a @c uniform_smallint distribution. */
-        param_type(IntType min_arg = 0, IntType max_arg = 9)
-          : _min(min_arg), _max(max_arg)
-        {
-            BOOST_ASSERT(_min <= _max);
-        }
-
-        /** Returns the minimum value. */
-        IntType a() const { return _min; }
-        /** Returns the maximum value. */
-        IntType b() const { return _max; }
-        
-
-        /** Writes the parameters to a @c std::ostream. */
-        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
-        {
-            os << parm._min << " " << parm._max;
-            return os;
-        }
-    
-        /** Reads the parameters from a @c std::istream. */
-        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
-        {
-            is >> parm._min >> std::ws >> parm._max;
-            return is;
-        }
-
-        /** Returns true if the two sets of parameters are equal. */
-        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        { return lhs._min == rhs._min && lhs._max == rhs._max; }
-
-        /** Returns true if the two sets of parameters are different. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-
-    private:
-        IntType _min;
-        IntType _max;
-    };
-
-    /**
-     * Constructs a @c uniform_smallint. @c min and @c max are the
-     * lower and upper bounds of the output range, respectively.
-     */
-    explicit uniform_smallint(IntType min_arg = 0, IntType max_arg = 9)
-      : _min(min_arg), _max(max_arg) {}
-
-    /**
-     * Constructs a @c uniform_smallint from its parameters.
-     */
-    explicit uniform_smallint(const param_type& parm)
-      : _min(parm.a()), _max(parm.b()) {}
-
-    /** Returns the minimum value of the distribution. */
-    result_type a() const { return _min; }
-    /** Returns the maximum value of the distribution. */
-    result_type b() const { return _max; }
-    /** Returns the minimum value of the distribution. */
-    result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return _min; }
-    /** Returns the maximum value of the distribution. */
-    result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return _max; }
-
-    /** Returns the parameters of the distribution. */
-    param_type param() const { return param_type(_min, _max); }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        _min = parm.a();
-        _max = parm.b();
-    }
-
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { }
-
-    /** Returns a value uniformly distributed in the range [min(), max()]. */
-    template<class Engine>
-    result_type operator()(Engine& eng) const
-    {
-        typedef typename Engine::result_type base_result;
-        return generate(eng, boost::random::traits::is_integral<base_result>());
-    }
-
-    /** Returns a value uniformly distributed in the range [param.a(), param.b()]. */
-    template<class Engine>
-    result_type operator()(Engine& eng, const param_type& parm) const
-    { return uniform_smallint(parm)(eng); }
-
-    /** Writes the distribution to a @c std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, uniform_smallint, ud)
-    {
-        os << ud._min << " " << ud._max;
-        return os;
-    }
-    
-    /** Reads the distribution from a @c std::istream. */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, uniform_smallint, ud)
-    {
-        is >> ud._min >> std::ws >> ud._max;
-        return is;
-    }
-
-    /**
-     * Returns true if the two distributions will produce identical
-     * sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(uniform_smallint, lhs, rhs)
-    { return lhs._min == rhs._min && lhs._max == rhs._max; }
-    
-    /**
-     * Returns true if the two distributions may produce different
-     * sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(uniform_smallint)
-
-private:
-    
-    // \cond show_private
-    template<class Engine>
-    result_type generate(Engine& eng, boost::mpl::true_) const
-    {
-        // equivalent to (eng() - eng.min()) % (_max - _min + 1) + _min,
-        // but guarantees no overflow.
-        typedef typename Engine::result_type base_result;
-        typedef typename boost::random::traits::make_unsigned<base_result>::type base_unsigned;
-        typedef typename boost::random::traits::make_unsigned_or_unbounded<result_type>::type range_type;
-#ifdef BOOST_NO_CXX11_EXPLICIT_CONVERSION_OPERATORS
-        typedef typename mpl::if_c<
-           std::numeric_limits<range_type>::is_specialized && std::numeric_limits<base_unsigned>::is_specialized
-           && (std::numeric_limits<range_type>::digits >= std::numeric_limits<base_unsigned>::digits),
-           range_type, base_unsigned>::type mixed_range_type;
-#else
-        typedef base_unsigned mixed_range_type;
-#endif
-        range_type range = random::detail::subtract<result_type>()(_max, _min);
-        base_unsigned base_range =
-            random::detail::subtract<base_result>()((eng.max)(), (eng.min)());
-        base_unsigned val =
-            random::detail::subtract<base_result>()(eng(), (eng.min)());
-        if(range >= base_range) {
-            return boost::random::detail::add<range_type, result_type>()(
-                static_cast<range_type>(val), _min);
-        } else {
-            // This involves mixed arithmetic between the base generators range
-            // type, and the result_type's range type.  mixed_range_type is
-            // normally the same as base_unsigned which is the most efficient
-            // option, but requires a narrowing explcit cast if result_type
-            // is a multiprecision type.  If no such casts are available then use
-            // multiprecision arithmetic throughout instead.
-            mixed_range_type modulus = static_cast<mixed_range_type>(range)+1;
-            return boost::random::detail::add<range_type, result_type>()(
-                static_cast<mixed_range_type>(val) % modulus, _min);
-        }
-    }
-    
-    template<class Engine>
-    result_type generate(Engine& eng, boost::mpl::false_) const
-    {
-        typedef typename Engine::result_type base_result;
-        typedef typename boost::random::traits::make_unsigned<result_type>::type range_type;
-        range_type range = random::detail::subtract<result_type>()(_max, _min);
-        base_result val = boost::uniform_01<base_result>()(eng);
-        // what is the worst that can possibly happen here?
-        // base_result may not be able to represent all the values in [0, range]
-        // exactly.  If this happens, it will cause round off error and we
-        // won't be able to produce all the values in the range.  We don't
-        // care about this because the user has already told us not to by
-        // using uniform_smallint.  However, we do need to be careful
-        // to clamp the result, or floating point rounding can produce
-        // an out of range result.
-        range_type offset = static_cast<range_type>(val * (static_cast<base_result>(range) + 1));
-        if(offset > range) return _max;
-        return boost::random::detail::add<range_type, result_type>()(offset , _min);
-    }
-    // \endcond
-
-    result_type _min;
-    result_type _max;
-};
-
-} // namespace random
-
-using random::uniform_smallint;
-
-} // namespace boost
-
-#endif // BOOST_RANDOM_UNIFORM_SMALLINT_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/variate_generator.hpp b/contrib/libboost/boost_1_65_0/boost/random/variate_generator.hpp
deleted file mode 100644
index 6d5aac4e472..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/variate_generator.hpp
+++ /dev/null
@@ -1,122 +0,0 @@
-/* boost random/variate_generator.hpp header file
- *
- * Copyright Jens Maurer 2002
- * 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_RANDOM_GENERATOR_HPP
-#define BOOST_RANDOM_RANDOM_GENERATOR_HPP
-
-#include <boost/random/detail/ptr_helper.hpp>
-
-#include <boost/random/detail/disable_warnings.hpp>
-
-namespace boost {
-
-/// \cond hide_private_members
-
-namespace random {
-
-///\endcond
-
-/**
- * A random variate generator is used to join a random number
- * generator together with a random number distribution.
- * Boost.Random provides a vast choice of \generators as well
- * as \distributions.
- *
- * The argument for the template parameter Engine shall be of
- * the form U, U&, or U*, where U models a
- * \uniform_random_number_generator.  Then, the member
- * engine_value_type names U (not the pointer or reference to U).
- *
- * Specializations of @c variate_generator satisfy the
- * requirements of CopyConstructible. They also satisfy the
- * requirements of Assignable unless the template parameter
- * Engine is of the form U&.
- *
- * The complexity of all functions specified in this section
- * is constant. No function described in this section except
- * the constructor throws an exception.
- */
-template<class Engine, class Distribution>
-class variate_generator
-{
-private:
-    typedef boost::random::detail::ptr_helper<Engine> helper_type;
-public:
-    typedef typename helper_type::value_type engine_value_type;
-    typedef Engine engine_type;
-    typedef Distribution distribution_type;
-    typedef typename Distribution::result_type result_type;
-
-    /**
-     * Constructs a @c variate_generator object with the associated
-     * \uniform_random_number_generator eng and the associated
-     * \random_distribution d.
-     *
-     * Throws: If and what the copy constructor of Engine or
-     * Distribution throws.
-     */
-    variate_generator(Engine e, Distribution d)
-      : _eng(e), _dist(d) { }
-
-    /** Returns: distribution()(engine()) */
-    result_type operator()() { return _dist(engine()); }
-    /**
-     * Returns: distribution()(engine(), value).
-     */
-    template<class T>
-    result_type operator()(const T& value) { return _dist(engine(), value); }
-
-    /**
-     * Returns: A reference to the associated uniform random number generator.
-     */
-    engine_value_type& engine() { return helper_type::ref(_eng); }
-    /**
-     * Returns: A reference to the associated uniform random number generator.
-     */
-    const engine_value_type& engine() const { return helper_type::ref(_eng); }
-
-    /** Returns: A reference to the associated \random_distribution. */
-    distribution_type& distribution() { return _dist; }
-    /**
-     * Returns: A reference to the associated random distribution.
-     */
-    const distribution_type& distribution() const { return _dist; }
-
-    /**
-     * Precondition: distribution().min() is well-formed
-     *
-     * Returns: distribution().min()
-     */
-    result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return (distribution().min)(); }
-    /**
-     * Precondition: distribution().max() is well-formed
-     *
-     * Returns: distribution().max()
-     */
-    result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return (distribution().max)(); }
-
-private:
-    Engine _eng;
-    distribution_type _dist;
-};
-
-} // namespace random
-
-using random::variate_generator;
-
-} // namespace boost
-
-#include <boost/random/detail/enable_warnings.hpp>
-
-#endif // BOOST_RANDOM_RANDOM_GENERATOR_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/weibull_distribution.hpp b/contrib/libboost/boost_1_65_0/boost/random/weibull_distribution.hpp
deleted file mode 100644
index 55e3c04903a..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/weibull_distribution.hpp
+++ /dev/null
@@ -1,177 +0,0 @@
-/* boost random/weibull_distribution.hpp header file
- *
- * Copyright Steven Watanabe 2010
- * 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_WEIBULL_DISTRIBUTION_HPP
-#define BOOST_RANDOM_WEIBULL_DISTRIBUTION_HPP
-
-#include <boost/config/no_tr1/cmath.hpp>
-#include <iosfwd>
-#include <istream>
-#include <boost/config.hpp>
-#include <boost/limits.hpp>
-#include <boost/random/detail/operators.hpp>
-#include <boost/random/uniform_01.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * The Weibull distribution is a real valued distribution with two
- * parameters a and b, producing values >= 0.
- *
- * It has \f$\displaystyle p(x) = \frac{a}{b}\left(\frac{x}{b}\right)^{a-1}e^{-\left(\frac{x}{b}\right)^a}\f$.
- */
-template<class RealType = double>
-class weibull_distribution {
-public:
-    typedef RealType result_type;
-    typedef RealType input_type;
-
-    class param_type {
-    public:
-        typedef weibull_distribution distribution_type;
-
-        /**
-         * Constructs a @c param_type from the "a" and "b" parameters
-         * of the distribution.
-         *
-         * Requires: a > 0 && b > 0
-         */
-        explicit param_type(RealType a_arg = 1.0, RealType b_arg = 1.0)
-          : _a(a_arg), _b(b_arg)
-        {}
-
-        /** Returns the "a" parameter of the distribtuion. */
-        RealType a() const { return _a; }
-        /** Returns the "b" parameter of the distribution. */
-        RealType b() const { return _b; }
-
-        /** Writes a @c param_type to a @c std::ostream. */
-        BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
-        { os << parm._a << ' ' << parm._b; return os; }
-
-        /** Reads a @c param_type from a @c std::istream. */
-        BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
-        { is >> parm._a >> std::ws >> parm._b; return is; }
-
-        /** Returns true if the two sets of parameters are the same. */
-        BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
-        { return lhs._a == rhs._a && lhs._b == rhs._b; }
-        
-        /** Returns true if the two sets of parameters are the different. */
-        BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
-
-    private:
-        RealType _a;
-        RealType _b;
-    };
-
-    /**
-     * Constructs a @c weibull_distribution from its "a" and "b" parameters.
-     *
-     * Requires: a > 0 && b > 0
-     */
-    explicit weibull_distribution(RealType a_arg = 1.0, RealType b_arg = 1.0)
-      : _a(a_arg), _b(b_arg)
-    {}
-    /** Constructs a @c weibull_distribution from its parameters. */
-    explicit weibull_distribution(const param_type& parm)
-      : _a(parm.a()), _b(parm.b())
-    {}
-
-    /**
-     * Returns a random variate distributed according to the
-     * @c weibull_distribution.
-     */
-    template<class URNG>
-    RealType operator()(URNG& urng) const
-    {
-        using std::pow;
-        using std::log;
-        return _b*pow(-log(1 - uniform_01<RealType>()(urng)), 1/_a);
-    }
-
-    /**
-     * Returns a random variate distributed accordint to the Weibull
-     * distribution with parameters specified by @c param.
-     */
-    template<class URNG>
-    RealType operator()(URNG& urng, const param_type& parm) const
-    {
-        return weibull_distribution(parm)(urng);
-    }
-
-    /** Returns the "a" parameter of the distribution. */
-    RealType a() const { return _a; }
-    /** Returns the "b" parameter of the distribution. */
-    RealType b() const { return _b; }
-
-    /** Returns the smallest value that the distribution can produce. */
-    RealType min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return 0; }
-    /** 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(_a, _b); }
-    /** Sets the parameters of the distribution. */
-    void param(const param_type& parm)
-    {
-        _a = parm.a();
-        _b = parm.b();
-    }
-
-    /**
-     * Effects: Subsequent uses of the distribution do not depend
-     * on values produced by any engine prior to invoking reset.
-     */
-    void reset() { }
-
-    /** Writes a @c weibull_distribution to a @c std::ostream. */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, weibull_distribution, wd)
-    {
-        os << wd.param();
-        return os;
-    }
-
-    /** Reads a @c weibull_distribution from a @c std::istream. */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, weibull_distribution, wd)
-    {
-        param_type parm;
-        if(is >> parm) {
-            wd.param(parm);
-        }
-        return is;
-    }
-
-    /**
-     * Returns true if the two instances of @c weibull_distribution will
-     * return identical sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(weibull_distribution, lhs, rhs)
-    { return lhs._a == rhs._a && lhs._b == rhs._b; }
-    
-    /**
-     * Returns true if the two instances of @c weibull_distribution will
-     * return different sequences of values given equal generators.
-     */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(weibull_distribution)
-
-private:
-    RealType _a;
-    RealType _b;
-};
-
-} // namespace random
-} // namespace boost
-
-#endif // BOOST_RANDOM_WEIBULL_DISTRIBUTION_HPP
diff --git a/contrib/libboost/boost_1_65_0/boost/random/xor_combine.hpp b/contrib/libboost/boost_1_65_0/boost/random/xor_combine.hpp
deleted file mode 100644
index fe8a58b40f1..00000000000
--- a/contrib/libboost/boost_1_65_0/boost/random/xor_combine.hpp
+++ /dev/null
@@ -1,208 +0,0 @@
-/* boost random/xor_combine.hpp header file
- *
- * Copyright Jens Maurer 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 including documentation.
- *
- * $Id$
- *
- */
-
-#ifndef BOOST_RANDOM_XOR_COMBINE_HPP
-#define BOOST_RANDOM_XOR_COMBINE_HPP
-
-#include <istream>
-#include <iosfwd>
-#include <cassert>
-#include <algorithm> // for std::min and std::max
-#include <boost/config.hpp>
-#include <boost/limits.hpp>
-#include <boost/cstdint.hpp>     // uint32_t
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/seed.hpp>
-#include <boost/random/detail/seed_impl.hpp>
-#include <boost/random/detail/operators.hpp>
-
-namespace boost {
-namespace random {
-
-/**
- * Instantiations of @c xor_combine_engine model a
- * \pseudo_random_number_generator.  To produce its output it
- * invokes each of the base generators, shifts their results
- * and xors them together.
- */
-template<class URNG1, int s1, class URNG2, int s2>
-class xor_combine_engine
-{
-public:
-    typedef URNG1 base1_type;
-    typedef URNG2 base2_type;
-    typedef typename base1_type::result_type result_type;
-
-    BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
-    BOOST_STATIC_CONSTANT(int, shift1 = s1);
-    BOOST_STATIC_CONSTANT(int, shift2 = s2);
-
-    /**
-     * Constructors a @c xor_combine_engine by default constructing
-     * both base generators.
-     */
-    xor_combine_engine() : _rng1(), _rng2() { }
-
-    /** Constructs a @c xor_combine by copying two base generators. */
-    xor_combine_engine(const base1_type & rng1, const base2_type & rng2)
-      : _rng1(rng1), _rng2(rng2) { }
-
-    /**
-     * Constructs a @c xor_combine_engine, seeding both base generators
-     * with @c v.
-     *
-     * @xmlwarning
-     * The exact algorithm used by this function may change in the future.
-     * @endxmlwarning
-     */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(xor_combine_engine,
-        result_type, v)
-    { seed(v); }
-
-    /**
-     * Constructs a @c xor_combine_engine, seeding both base generators
-     * with values produced by @c seq.
-     */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(xor_combine_engine,
-        SeedSeq, seq)
-    { seed(seq); }
-
-    /**
-     * Constructs a @c xor_combine_engine, seeding both base generators
-     * with values from the iterator range [first, last) and changes
-     * first to point to the element after the last one used.  If there
-     * are not enough elements in the range to seed both generators,
-     * throws @c std::invalid_argument.
-     */
-    template<class It> xor_combine_engine(It& first, It last)
-      : _rng1(first, last), _rng2( /* advanced by other call */ first, last) { }
-
-    /** Calls @c seed() for both base generators. */
-    void seed() { _rng1.seed(); _rng2.seed(); }
-
-    /** @c seeds both base generators with @c v. */
-    BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(xor_combine_engine, result_type, v)
-    { _rng1.seed(v); _rng2.seed(v); }
-
-    /** @c seeds both base generators with values produced by @c seq. */
-    BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(xor_combine_engine, SeedSeq, seq)
-    { _rng1.seed(seq); _rng2.seed(seq); }
-
-    /**
-     * seeds both base generators with values from the iterator
-     * range [first, last) and changes first to point to the element
-     * after the last one used.  If there are not enough elements in
-     * the range to seed both generators, throws @c std::invalid_argument.
-     */
-    template<class It> void seed(It& first, It last)
-    {
-        _rng1.seed(first, last);
-        _rng2.seed(first, last);
-    }
-
-    /** Returns the first base generator. */
-    const base1_type& base1() const { return _rng1; }
-
-    /** Returns the second base generator. */
-    const base2_type& base2() const { return _rng2; }
-
-    /** Returns the next value of the generator. */
-    result_type operator()()
-    {
-        return (_rng1() << s1) ^ (_rng2() << s2);
-    }
-  
-    /** Fills a range with random values */
-    template<class Iter>
-    void generate(Iter first, Iter last)
-    { detail::generate_from_int(*this, first, last); }
-
-    /** Advances the state of the generator by @c z. */
-    void discard(boost::uintmax_t z)
-    {
-        _rng1.discard(z);
-        _rng2.discard(z);
-    }
-
-    /** Returns the smallest value that the generator can produce. */
-    static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () { return (std::min)((URNG1::min)(), (URNG2::min)()); }
-    /** Returns the largest value that the generator can produce. */
-    static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () { return (std::max)((URNG1::min)(), (URNG2::max)()); }
-
-    /**
-     * Writes the textual representation of the generator to a @c std::ostream.
-     */
-    BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, xor_combine_engine, s)
-    {
-        os << s._rng1 << ' ' << s._rng2;
-        return os;
-    }
-    
-    /**
-     * Reads the textual representation of the generator from a @c std::istream.
-     */
-    BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, xor_combine_engine, s)
-    {
-        is >> s._rng1 >> std::ws >> s._rng2;
-        return is;
-    }
-    
-    /** Returns true if the two generators will produce identical sequences. */
-    BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(xor_combine_engine, x, y)
-    { return x._rng1 == y._rng1 && x._rng2 == y._rng2; }
-    
-    /** Returns true if the two generators will produce different sequences. */
-    BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(xor_combine_engine)
-
-private:
-    base1_type _rng1;
-    base2_type _rng2;
-};
-
-#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
-//  A definition is required even for integral static constants
-template<class URNG1, int s1, class URNG2, int s2>
-const bool xor_combine_engine<URNG1, s1, URNG2, s2>::has_fixed_range;
-template<class URNG1, int s1, class URNG2, int s2>
-const int xor_combine_engine<URNG1, s1, URNG2, s2>::shift1;
-template<class URNG1, int s1, class URNG2, int s2>
-const int xor_combine_engine<URNG1, s1, URNG2, s2>::shift2;
-#endif
-
-/// \cond show_private
-
-/** Provided for backwards compatibility. */
-template<class URNG1, int s1, class URNG2, int s2,
-    typename URNG1::result_type v = 0>
-class xor_combine : public xor_combine_engine<URNG1, s1, URNG2, s2>
-{
-    typedef xor_combine_engine<URNG1, s1, URNG2, s2> base_type;
-public:
-    typedef typename base_type::result_type result_type;
-    xor_combine() {}
-    xor_combine(result_type val) : base_type(val) {}
-    template<class It>
-    xor_combine(It& first, It last) : base_type(first, last) {}
-    xor_combine(const URNG1 & rng1, const URNG2 & rng2)
-      : base_type(rng1, rng2) { }
-
-    result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return (std::min)((this->base1().min)(), (this->base2().min)()); }
-    result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return (std::max)((this->base1().min)(), (this->base2().max)()); }
-};
-
-/// \endcond
-
-} // namespace random
-} // namespace boost
-
-#endif // BOOST_RANDOM_XOR_COMBINE_HPP

From a0f6f406c865374b5dc4348a9cbc74f12eef8637 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 9 Sep 2017 03:06:06 +0300
Subject: [PATCH 153/266] Initial support for build with libc++ instead of
 libstdc++ (incomplete) [#CLICKHOUSE-3174].

---
 CMakeLists.txt | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2ec52c7f427..f3669a53afb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -89,18 +89,25 @@ else ()
     set (CXX11_ABI_FLAGS "")
 endif ()
 
-set (COMPILER_FLAGS                       "${COMPILER_FLAGS} ${CXX11_ABI_FLAGS}")
+set (COMPILER_FLAGS                      "${COMPILER_FLAGS} ${CXX11_ABI_FLAGS}")
 
 option (PIPE "-pipe compiler option [less /tmp usage, more ram usage]" ON)
 if (PIPE)
-    set (COMPILER_FLAGS                   "${COMPILER_FLAGS} -pipe")
+    set (COMPILER_FLAGS                  "${COMPILER_FLAGS} -pipe")
 endif ()
 
 include (cmake/test_cpu.cmake)
 
 option (ARCHNATIVE "Enable -march=native compiler flag" OFF)
 if (ARCHNATIVE)
-    set (COMPILER_FLAGS                   "${COMPILER_FLAGS} -march=native")
+    set (COMPILER_FLAGS                  "${COMPILER_FLAGS} -march=native")
+endif ()
+
+option (USE_LIBCXX "Use libc++ and libc++abi instead of libstdc++ (only make sense on Linux with Clang)" OFF)
+if (USE_LIBCXX)
+    set (COMPILER_FLAGS                  "${COMPILER_FLAGS} -pthread") # NOTE: Why this is not the default and why this is needed only with libc++?
+    set (CMAKE_CXX_FLAGS                 "${CMAKE_CXX_FLAGS} -stdlib=libc++")
+    set (CMAKE_CXX_FLAGS_DEBUG           "${CMAKE_CXX_FLAGS_DEBUG} -D_LIBCPP_DEBUG=1") # More checks in debug build.
 endif ()
 
 set (CMAKE_BUILD_COLOR_MAKEFILE          ON)
@@ -115,11 +122,18 @@ set (CMAKE_C_FLAGS_RELWITHDEBINFO        "${CMAKE_C_FLAGS_RELWITHDEBINFO} -O3")
 set (CMAKE_C_FLAGS_DEBUG                 "${CMAKE_C_FLAGS_DEBUG} -O0 -g3 -ggdb3 -fno-inline")
 
 if (NOT APPLE AND NOT (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_SYSTEM MATCHES "FreeBSD"))
-    set (CMAKE_EXE_LINKER_FLAGS          "${CMAKE_EXE_LINKER_FLAGS} -static-libgcc -static-libstdc++")
+    set (CMAKE_EXE_LINKER_FLAGS          "${CMAKE_EXE_LINKER_FLAGS} -static-libgcc")
+    if (NOT USE_LIBCXX)
+        set (CMAKE_EXE_LINKER_FLAGS      "${CMAKE_EXE_LINKER_FLAGS} -static-libstdc++")
+    endif ()
 endif ()
 
 if (NOT APPLE)
     set (CMAKE_EXE_LINKER_FLAGS          "${CMAKE_EXE_LINKER_FLAGS} ${GLIBC_COMPATIBILITY_LINK_FLAGS} ${CXX11_ABI_FLAGS}")
+
+    if (USE_LIBCXX AND (CMAKE_CXX_COMPILER_ID STREQUAL "Clang"))
+        set (CMAKE_EXE_LINKER_FLAGS      "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libc++ -Wl,-Bstatic -lc++ -lc++abi -Wl,-Bdynamic")
+    endif ()
 endif ()
 
 include (cmake/test_compiler.cmake)

From 84c0470bcbfe1ab84b595d71655e6fb95e7c90bc Mon Sep 17 00:00:00 2001
From: proller <proller@users.noreply.github.com>
Date: Sat, 9 Sep 2017 03:32:34 +0300
Subject: [PATCH 154/266] cmake: ccache detect proper version (#1222)

---
 CMakeLists.txt          |  8 ++------
 cmake/find_ccache.cmake | 15 +++++++++++++++
 2 files changed, 17 insertions(+), 6 deletions(-)
 create mode 100644 cmake/find_ccache.cmake

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f3669a53afb..985e5bfc6e9 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -30,11 +30,7 @@ cmake_policy (SET CMP0012 NEW) # Don't dereference TRUE and FALSE
 # Write compile_commands.json
 set(CMAKE_EXPORT_COMPILE_COMMANDS 1)
 
-find_program (CCACHE_FOUND ccache)
-if (CCACHE_FOUND AND NOT CMAKE_CXX_COMPILER_LAUNCHER MATCHES "ccache" AND NOT CMAKE_CXX_COMPILER MATCHES "ccache")
-  set_property (GLOBAL PROPERTY RULE_LAUNCH_COMPILE "ccache")
-  set_property (GLOBAL PROPERTY RULE_LAUNCH_LINK "ccache")
-endif ()
+include (cmake/find_ccache.cmake)
 
 if (NOT CMAKE_BUILD_TYPE OR CMAKE_BUILD_TYPE STREQUAL "None")
     message (STATUS "CMAKE_BUILD_TYPE is not set, set to default = RELWITHDEBINFO")
@@ -190,7 +186,7 @@ if (UNBUNDLED OR NOT (CMAKE_SYSTEM MATCHES "Linux" OR APPLE) OR ARCH_32)
     option (NO_WERROR "Disable -Werror compiler option" ON)
 endif ()
 
-message (STATUS "Building for: ${CMAKE_SYSTEM} ${CMAKE_SYSTEM_PROCESSOR} ${CMAKE_LIBRARY_ARCHITECTURE} ; USE_STATIC_LIBRARIES=${USE_STATIC_LIBRARIES} MAKE_STATIC_LIBRARIES=${MAKE_STATIC_LIBRARIES} UNBUNDLED=${UNBUNDLED} CCACHE=${CCACHE_FOUND}")
+message (STATUS "Building for: ${CMAKE_SYSTEM} ${CMAKE_SYSTEM_PROCESSOR} ${CMAKE_LIBRARY_ARCHITECTURE} ; USE_STATIC_LIBRARIES=${USE_STATIC_LIBRARIES} MAKE_STATIC_LIBRARIES=${MAKE_STATIC_LIBRARIES} UNBUNDLED=${UNBUNDLED} CCACHE=${CCACHE_FOUND} ${CCACHE_VERSION}")
 
 include(GNUInstallDirs)
 
diff --git a/cmake/find_ccache.cmake b/cmake/find_ccache.cmake
new file mode 100644
index 00000000000..beb4e306156
--- /dev/null
+++ b/cmake/find_ccache.cmake
@@ -0,0 +1,15 @@
+
+find_program (CCACHE_FOUND ccache)
+if (CCACHE_FOUND AND NOT CMAKE_CXX_COMPILER_LAUNCHER MATCHES "ccache" AND NOT CMAKE_CXX_COMPILER MATCHES "ccache")
+    execute_process(COMMAND ${CCACHE_FOUND} "-V" OUTPUT_VARIABLE CCACHE_VERSION)
+    string(REGEX REPLACE "ccache version ([0-9\\.]+).*" "\\1" CCACHE_VERSION ${CCACHE_VERSION} )
+    string(COMPARE GREATER ${CCACHE_VERSION} "3.2.0" CCACHE_VERSION_OK)
+
+    if (CCACHE_VERSION_OK)
+       #message(STATUS "Using ${CCACHE_FOUND} ${CCACHE_VERSION}")
+       set_property (GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE_FOUND})
+       set_property (GLOBAL PROPERTY RULE_LAUNCH_LINK ${CCACHE_FOUND})
+    else ()
+       message(STATUS "Not using ${CCACHE_FOUND} ${CCACHE_VERSION} bug: https://bugzilla.samba.org/show_bug.cgi?id=8118")
+    endif ()
+endif ()

From c46c6b66d5f7b121221fdfd610e1cfb792f48191 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 9 Sep 2017 03:36:53 +0300
Subject: [PATCH 155/266] Fixed static linking of libc++ (ugly)
 [#CLICKHOUSE-3174].

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index f3669a53afb..3220b59f77a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -132,7 +132,7 @@ if (NOT APPLE)
     set (CMAKE_EXE_LINKER_FLAGS          "${CMAKE_EXE_LINKER_FLAGS} ${GLIBC_COMPATIBILITY_LINK_FLAGS} ${CXX11_ABI_FLAGS}")
 
     if (USE_LIBCXX AND (CMAKE_CXX_COMPILER_ID STREQUAL "Clang"))
-        set (CMAKE_EXE_LINKER_FLAGS      "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libc++ -Wl,-Bstatic -lc++ -lc++abi -Wl,-Bdynamic")
+        link_libraries (-Wl,-Bstatic -stdlib=libc++ -static-libstdc++ c++ c++abi -Wl,-Bdynamic)
     endif ()
 endif ()
 

From cb70a5a77c53c4309d8aee4a1b6c3544a4404342 Mon Sep 17 00:00:00 2001
From: proller <proller@users.noreply.github.com>
Date: Sat, 9 Sep 2017 03:40:21 +0300
Subject: [PATCH 156/266] Try fix macos build (#1221)

* Try fix macos build

* Try fix macos build
---
 dbms/src/Dictionaries/LibraryDictionarySource.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbms/src/Dictionaries/LibraryDictionarySource.cpp b/dbms/src/Dictionaries/LibraryDictionarySource.cpp
index 5785f176fe9..a2e073594fc 100644
--- a/dbms/src/Dictionaries/LibraryDictionarySource.cpp
+++ b/dbms/src/Dictionaries/LibraryDictionarySource.cpp
@@ -85,7 +85,7 @@ bool dataToBlock(const void * data, Block & block)
 
         for (size_t row_n = 0; row_n < columns_received->data[col_n].size; ++row_n)
         {
-            columns[row_n]->insert(columns_received->data[col_n].data[row_n]);
+            columns[row_n]->insert(static_cast<UInt64>(columns_received->data[col_n].data[row_n]));
         }
     }
     return false;

From 32d8d7d90803762ad227cea21e673b610cb08c97 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 9 Sep 2017 04:01:36 +0300
Subject: [PATCH 157/266] Fixed build with libc++ [#CLICKHOUSE-3174].

---
 CMakeLists.txt | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index e4b719d3c73..87c4ef63e65 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -119,16 +119,14 @@ set (CMAKE_C_FLAGS_DEBUG                 "${CMAKE_C_FLAGS_DEBUG} -O0 -g3 -ggdb3
 
 if (NOT APPLE AND NOT (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_SYSTEM MATCHES "FreeBSD"))
     set (CMAKE_EXE_LINKER_FLAGS          "${CMAKE_EXE_LINKER_FLAGS} -static-libgcc")
-    if (NOT USE_LIBCXX)
-        set (CMAKE_EXE_LINKER_FLAGS      "${CMAKE_EXE_LINKER_FLAGS} -static-libstdc++")
-    endif ()
+    set (CMAKE_EXE_LINKER_FLAGS          "${CMAKE_EXE_LINKER_FLAGS} -static-libstdc++")
 endif ()
 
 if (NOT APPLE)
     set (CMAKE_EXE_LINKER_FLAGS          "${CMAKE_EXE_LINKER_FLAGS} ${GLIBC_COMPATIBILITY_LINK_FLAGS} ${CXX11_ABI_FLAGS}")
 
     if (USE_LIBCXX AND (CMAKE_CXX_COMPILER_ID STREQUAL "Clang"))
-        link_libraries (-Wl,-Bstatic -stdlib=libc++ -static-libstdc++ c++ c++abi -Wl,-Bdynamic)
+        link_libraries (-Wl,-Bstatic -stdlib=libc++ c++ c++abi -Wl,-Bdynamic)
     endif ()
 endif ()
 

From 0e9681cdc281171deb4ba2bdb1edc5ceb66c697a Mon Sep 17 00:00:00 2001
From: proller <proller@users.noreply.github.com>
Date: Sat, 9 Sep 2017 04:04:36 +0300
Subject: [PATCH 158/266] Always use ccache for gcc (#1223)

* Try fix macos build

* Try fix macos build

* Alvays use ccache for gcc
---
 cmake/find_ccache.cmake | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmake/find_ccache.cmake b/cmake/find_ccache.cmake
index beb4e306156..926002a44ae 100644
--- a/cmake/find_ccache.cmake
+++ b/cmake/find_ccache.cmake
@@ -5,7 +5,7 @@ if (CCACHE_FOUND AND NOT CMAKE_CXX_COMPILER_LAUNCHER MATCHES "ccache" AND NOT CM
     string(REGEX REPLACE "ccache version ([0-9\\.]+).*" "\\1" CCACHE_VERSION ${CCACHE_VERSION} )
     string(COMPARE GREATER ${CCACHE_VERSION} "3.2.0" CCACHE_VERSION_OK)
 
-    if (CCACHE_VERSION_OK)
+    if (CCACHE_VERSION_OK OR NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
        #message(STATUS "Using ${CCACHE_FOUND} ${CCACHE_VERSION}")
        set_property (GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE_FOUND})
        set_property (GLOBAL PROPERTY RULE_LAUNCH_LINK ${CCACHE_FOUND})

From 92d7d6bd44907a080d4efb94b2cc25ace2e97930 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 9 Sep 2017 05:12:53 +0300
Subject: [PATCH 159/266] Fixed error that reproduced only when using libc++
 [#CLICKHOUSE-3174].

---
 dbms/src/Interpreters/Aggregator.cpp | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/dbms/src/Interpreters/Aggregator.cpp b/dbms/src/Interpreters/Aggregator.cpp
index e4f544a3b05..cf97941c8c2 100644
--- a/dbms/src/Interpreters/Aggregator.cpp
+++ b/dbms/src/Interpreters/Aggregator.cpp
@@ -1605,7 +1605,7 @@ void NO_INLINE Aggregator::mergeBucketImpl(
 
 
 /** Combines aggregation states together, turns them into blocks, and outputs streams.
-  * If the aggregation states are two-level, then it produces blocks strictly in order bucket_num.
+  * If the aggregation states are two-level, then it produces blocks strictly in order of 'bucket_num'.
   * (This is important for distributed processing.)
   * In doing so, it can handle different buckets in parallel, using up to `threads` threads.
   */
@@ -1636,6 +1636,16 @@ public:
         return res.str();
     }
 
+    ~MergingAndConvertingBlockInputStream()
+    {
+        LOG_TRACE(&Logger::get(__PRETTY_FUNCTION__), "Waiting for threads to finish");
+
+        /// We need to wait for threads to finish before destructor of 'parallel_merge_data',
+        ///  because the threads access 'parallel_merge_data'.
+        if (parallel_merge_data)
+            parallel_merge_data->pool.wait();
+    }
+
 protected:
     Block readImpl() override
     {
@@ -1732,19 +1742,13 @@ private:
 
     struct ParallelMergeData
     {
-        ThreadPool pool;
         std::map<Int32, Block> ready_blocks;
         std::exception_ptr exception;
         std::mutex mutex;
         std::condition_variable condvar;
+        ThreadPool pool;
 
         explicit ParallelMergeData(size_t threads) : pool(threads) {}
-
-        ~ParallelMergeData()
-        {
-            LOG_TRACE(&Logger::get(__PRETTY_FUNCTION__), "Waiting for threads to finish");
-            pool.wait();
-        }
     };
 
     std::unique_ptr<ParallelMergeData> parallel_merge_data;

From 4ba8d5a3c6655f7590678e3900d6abd24b6a76a5 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 9 Sep 2017 06:30:31 +0300
Subject: [PATCH 160/266] Updated build instruction [#CLICKHOUSE-3174].

---
 docs/en/development/build.rst | 30 +-----------------------------
 docs/ru/development/build.rst | 30 +-----------------------------
 2 files changed, 2 insertions(+), 58 deletions(-)

diff --git a/docs/en/development/build.rst b/docs/en/development/build.rst
index 180689e2417..93bfbbe60ab 100644
--- a/docs/en/development/build.rst
+++ b/docs/en/development/build.rst
@@ -122,35 +122,7 @@ Install recent version of clang.
 
 Clang is embedded into ClickHouse package and used at runtime. Minimum version is 3.8.0. It is optional.
 
-
-You can build clang from sources:
-
-.. code-block:: bash
-
-    cd ..
-    sudo apt-get install subversion
-    mkdir llvm
-    cd llvm
-    svn co http://llvm.org/svn/llvm-project/llvm/tags/RELEASE_400/final llvm
-    cd llvm/tools
-    svn co http://llvm.org/svn/llvm-project/cfe/tags/RELEASE_400/final clang
-    cd ..
-    cd projects/
-    svn co http://llvm.org/svn/llvm-project/compiler-rt/tags/RELEASE_400/final compiler-rt
-    cd ../..
-    mkdir build
-    cd build/
-    cmake -D CMAKE_BUILD_TYPE:STRING=Release ../llvm
-    make -j $THREADS
-    sudo make install
-    hash clang
-
-Or install it from packages. On Ubuntu 16.04 or newer:
-
-.. code-block:: bash
-
-    sudo apt-get install clang
-
+To install clang, look at ``utils/prepare-environment/install-clang.sh``
 
 You may also build ClickHouse with clang for development purposes.
 For production releases, GCC is used.
diff --git a/docs/ru/development/build.rst b/docs/ru/development/build.rst
index 180689e2417..93bfbbe60ab 100644
--- a/docs/ru/development/build.rst
+++ b/docs/ru/development/build.rst
@@ -122,35 +122,7 @@ Install recent version of clang.
 
 Clang is embedded into ClickHouse package and used at runtime. Minimum version is 3.8.0. It is optional.
 
-
-You can build clang from sources:
-
-.. code-block:: bash
-
-    cd ..
-    sudo apt-get install subversion
-    mkdir llvm
-    cd llvm
-    svn co http://llvm.org/svn/llvm-project/llvm/tags/RELEASE_400/final llvm
-    cd llvm/tools
-    svn co http://llvm.org/svn/llvm-project/cfe/tags/RELEASE_400/final clang
-    cd ..
-    cd projects/
-    svn co http://llvm.org/svn/llvm-project/compiler-rt/tags/RELEASE_400/final compiler-rt
-    cd ../..
-    mkdir build
-    cd build/
-    cmake -D CMAKE_BUILD_TYPE:STRING=Release ../llvm
-    make -j $THREADS
-    sudo make install
-    hash clang
-
-Or install it from packages. On Ubuntu 16.04 or newer:
-
-.. code-block:: bash
-
-    sudo apt-get install clang
-
+To install clang, look at ``utils/prepare-environment/install-clang.sh``
 
 You may also build ClickHouse with clang for development purposes.
 For production releases, GCC is used.

From 5a8f45c13189d92cc667ddaf20bbb8ec7577b5f8 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 9 Sep 2017 06:46:18 +0300
Subject: [PATCH 161/266] Fixed insignificant error, shown by TSan
 [#CLICKHOUSE-2].

---
 dbms/src/Common/LRUCache.h | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/dbms/src/Common/LRUCache.h b/dbms/src/Common/LRUCache.h
index 85be0d5d0e4..4899d8f35e7 100644
--- a/dbms/src/Common/LRUCache.h
+++ b/dbms/src/Common/LRUCache.h
@@ -5,6 +5,7 @@
 #include <memory>
 #include <chrono>
 #include <mutex>
+#include <atomic>
 
 #include <common/logger_useful.h>
 
@@ -254,8 +255,8 @@ private:
     const Delay expiration_delay;
 
     mutable std::mutex mutex;
-    size_t hits = 0;
-    size_t misses = 0;
+    std::atomic<size_t> hits {0};
+    std::atomic<size_t> misses {0};
 
     WeightFunction weight_function;
 

From 253893bf4da36cf0a5c97f293240c16b5633dbb0 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 9 Sep 2017 07:06:54 +0300
Subject: [PATCH 162/266] Fixed insignificant error, shown by TSan
 [#CLICKHOUSE-2].

---
 dbms/src/Common/MemoryTracker.cpp | 12 ++++++------
 dbms/src/Common/MemoryTracker.h   |  5 +++--
 2 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/dbms/src/Common/MemoryTracker.cpp b/dbms/src/Common/MemoryTracker.cpp
index 72bbd983328..76695b1bd19 100644
--- a/dbms/src/Common/MemoryTracker.cpp
+++ b/dbms/src/Common/MemoryTracker.cpp
@@ -49,7 +49,7 @@ void MemoryTracker::alloc(Int64 size)
 {
     Int64 will_be = amount += size;
 
-    if (!next)
+    if (!next.load(std::memory_order_relaxed))
         CurrentMetrics::add(metric, size);
 
     Int64 current_limit = limit.load(std::memory_order_relaxed);
@@ -89,8 +89,8 @@ void MemoryTracker::alloc(Int64 size)
     if (will_be > peak.load(std::memory_order_relaxed))        /// Races doesn't matter. Could rewrite with CAS, but not worth.
         peak.store(will_be, std::memory_order_relaxed);
 
-    if (next)
-        next->alloc(size);
+    if (auto loaded_next = next.load(std::memory_order_relaxed))
+        loaded_next->alloc(size);
 }
 
 
@@ -108,8 +108,8 @@ void MemoryTracker::free(Int64 size)
     amount -= size_to_subtract;
     /// NOTE above code is not atomic. It's easy to fix.
 
-    if (next)
-        next->free(size);
+    if (auto loaded_next = next.load(std::memory_order_relaxed))
+        loaded_next->free(size);
     else
         CurrentMetrics::sub(metric, size_to_subtract);
 }
@@ -117,7 +117,7 @@ void MemoryTracker::free(Int64 size)
 
 void MemoryTracker::reset()
 {
-    if (!next)
+    if (!next.load(std::memory_order_relaxed))
         CurrentMetrics::sub(metric, amount);
 
     amount.store(0, std::memory_order_relaxed);
diff --git a/dbms/src/Common/MemoryTracker.h b/dbms/src/Common/MemoryTracker.h
index c06fc33444e..acc8da1e8e2 100644
--- a/dbms/src/Common/MemoryTracker.h
+++ b/dbms/src/Common/MemoryTracker.h
@@ -26,7 +26,7 @@ class MemoryTracker
 
     /// Singly-linked list. All information will be passed to subsequent memory trackers also (it allows to implement trackers hierarchy).
     /// In terms of tree nodes it is the list of parents. Lifetime of these trackers should "include" lifetime of current tracker.
-    MemoryTracker * next = nullptr;
+    std::atomic<MemoryTracker *> next {};
 
     /// You could specify custom metric to track memory usage.
     CurrentMetrics::Metric metric = CurrentMetrics::MemoryTracking;
@@ -78,9 +78,10 @@ public:
         fault_probability = value;
     }
 
+    /// next should be changed only once: from nullptr to some value.
     void setNext(MemoryTracker * elem)
     {
-        next = elem;
+        next.store(elem, std::memory_order_relaxed);
     }
 
     /// The memory consumption could be shown in realtime via CurrentMetrics counter

From 2e74123075ebcc5612b693f806f9b7c577e602bd Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 9 Sep 2017 07:08:04 +0300
Subject: [PATCH 163/266] Fixed insignificant error in Poco, shown by TSan
 [#CLICKHOUSE-2].

---
 .../libpoco/Net/include/Poco/Net/TCPServer.h   | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/contrib/libpoco/Net/include/Poco/Net/TCPServer.h b/contrib/libpoco/Net/include/Poco/Net/TCPServer.h
index fccb658f77b..78fd718d451 100644
--- a/contrib/libpoco/Net/include/Poco/Net/TCPServer.h
+++ b/contrib/libpoco/Net/include/Poco/Net/TCPServer.h
@@ -28,6 +28,8 @@
 #include "Poco/Thread.h"
 #include "Poco/ThreadPool.h"
 
+#include <atomic>
+
 
 namespace Poco {
 namespace Net {
@@ -63,7 +65,7 @@ class Net_API TCPServer: public Poco::Runnable
 	/// on the number of connections waiting to be served.
 	///
 	/// It is possible to specify a maximum number of queued connections.
-	/// This prevents the connection queue from overflowing in the 
+	/// This prevents the connection queue from overflowing in the
 	/// case of an extreme server load. In such a case, connections that
 	/// cannot be queued are silently and immediately closed.
 	///
@@ -121,7 +123,7 @@ public:
 
 	const TCPServerParams& params() const;
 		/// Returns a const reference to the TCPServerParam object
-		/// used by the server's TCPServerDispatcher.	
+		/// used by the server's TCPServerDispatcher.
 
 	void start();
 		/// Starts the server. A new thread will be
@@ -138,7 +140,7 @@ public:
 		/// Already handled connections will continue to be served.
 		///
 		/// Once the server has been stopped, it cannot be restarted.
-		
+
 	int currentThreads() const;
 		/// Returns the number of currently used connection threads.
 
@@ -147,13 +149,13 @@ public:
 
 	int totalConnections() const;
 		/// Returns the total number of handled connections.
-		
+
 	int currentConnections() const;
 		/// Returns the number of currently handled connections.
 
 	int maxConcurrentConnections() const;
-		/// Returns the maximum number of concurrently handled connections.	
-		
+		/// Returns the maximum number of concurrently handled connections.
+
 	int queuedConnections() const;
 		/// Returns the number of queued connections.
 
@@ -180,11 +182,11 @@ private:
 	TCPServer();
 	TCPServer(const TCPServer&);
 	TCPServer& operator = (const TCPServer&);
-	
+
 	ServerSocket         _socket;
 	TCPServerDispatcher* _pDispatcher;
 	Poco::Thread         _thread;
-	bool                 _stopped;
+	std::atomic<bool>    _stopped;
 };
 
 

From 0c41b876472606e856f557a68765a4a87dfb7167 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 10 Sep 2017 01:26:01 +0300
Subject: [PATCH 164/266] Fixed insignificant error in Poco, shown by TSan
 [#CLICKHOUSE-2].

---
 .../Foundation/src/DirectoryWatcher.cpp       | 69 ++++++++++---------
 .../include/Poco/Net/HTTPServerConnection.h   |  6 +-
 .../include/Poco/Net/TCPServerDispatcher.h    | 26 +++----
 3 files changed, 53 insertions(+), 48 deletions(-)

diff --git a/contrib/libpoco/Foundation/src/DirectoryWatcher.cpp b/contrib/libpoco/Foundation/src/DirectoryWatcher.cpp
index 52af9d55145..f67a6d15e9b 100644
--- a/contrib/libpoco/Foundation/src/DirectoryWatcher.cpp
+++ b/contrib/libpoco/Foundation/src/DirectoryWatcher.cpp
@@ -45,6 +45,7 @@
 #endif
 #include <algorithm>
 #include <map>
+#include <atomic>
 
 
 namespace Poco {
@@ -66,7 +67,7 @@ public:
 	{
 		return _owner;
 	}
-	
+
 	virtual void run() = 0;
 	virtual void stop() = 0;
 	virtual bool supportsMoveEvents() const = 0;
@@ -78,21 +79,21 @@ protected:
 			size(0)
 		{
 		}
-		
+
 		ItemInfo(const ItemInfo& other):
 			path(other.path),
 			size(other.size),
 			lastModified(other.lastModified)
 		{
 		}
-		
+
 		explicit ItemInfo(const File& f):
 			path(f.path()),
 			size(f.isFile() ? f.getSize() : 0),
 			lastModified(f.getLastModified())
 		{
 		}
-		
+
 		std::string path;
 		File::FileSize size;
 		Timestamp lastModified;
@@ -109,7 +110,7 @@ protected:
 			++it;
 		}
 	}
-	
+
 	void compare(ItemInfoMap& oldEntries, ItemInfoMap& newEntries)
 	{
 		for (ItemInfoMap::iterator itn = newEntries.begin(); itn != newEntries.end(); ++itn)
@@ -150,7 +151,7 @@ private:
 	DirectoryWatcherStrategy();
 	DirectoryWatcherStrategy(const DirectoryWatcherStrategy&);
 	DirectoryWatcherStrategy& operator = (const DirectoryWatcherStrategy&);
-	
+
 	DirectoryWatcher& _owner;
 };
 
@@ -168,21 +169,21 @@ public:
 		if (!_hStopped)
 			throw SystemException("cannot create event");
 	}
-	
+
 	~WindowsDirectoryWatcherStrategy()
 	{
 		CloseHandle(_hStopped);
 	}
-	
+
 	void run()
 	{
 		ItemInfoMap entries;
 		scan(entries);
-		
+
 		DWORD filter = FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_DIR_NAME;
 		if (owner().eventMask() & DirectoryWatcher::DW_ITEM_MODIFIED)
 			filter |= FILE_NOTIFY_CHANGE_SIZE | FILE_NOTIFY_CHANGE_LAST_WRITE;
-		
+
 		std::string path(owner().directory().path());
 #if defined(POCO_WIN32_UTF8)
 		std::wstring upath;
@@ -204,7 +205,7 @@ public:
 			}
 			return;
 		}
-		
+
 		bool stopped = false;
 		while (!stopped)
 		{
@@ -237,21 +238,21 @@ public:
 			catch (Poco::Exception& exc)
 			{
 				owner().scanError(&owner(), exc);
-			}			
+			}
 		}
 		FindCloseChangeNotification(hChange);
 	}
-	
+
 	void stop()
 	{
 		SetEvent(_hStopped);
 	}
-	
+
 	bool supportsMoveEvents() const
 	{
 		return false;
 	}
-	
+
 private:
 	HANDLE _hStopped;
 };
@@ -271,12 +272,12 @@ public:
 		_fd = inotify_init();
 		if (_fd == -1) throw Poco::IOException("cannot initialize inotify", errno);
 	}
-	
+
 	~LinuxDirectoryWatcherStrategy()
 	{
 		close(_fd);
 	}
-	
+
 	void run()
 	{
 		int mask = 0;
@@ -302,7 +303,7 @@ public:
 				owner().scanError(&owner(), exc);
 			}
 		}
-		
+
 		Poco::Buffer<char> buffer(4096);
 		while (!_stopped)
 		{
@@ -323,16 +324,16 @@ public:
 					while (n > 0)
 					{
 						struct inotify_event* pEvent = reinterpret_cast<struct inotify_event*>(buffer.begin() + i);
-						
+
 						if (pEvent->len > 0)
-						{						
+						{
 							if (!owner().eventsSuspended())
 							{
 								Poco::Path p(owner().directory().path());
 								p.makeDirectory();
 								p.setFileName(pEvent->name);
 								Poco::File f(p.toString());
-	
+
 								if ((pEvent->mask & IN_CREATE) && (owner().eventMask() & DirectoryWatcher::DW_ITEM_ADDED))
 								{
 									DirectoryWatcher::DirectoryEvent ev(f, DirectoryWatcher::DW_ITEM_ADDED);
@@ -360,7 +361,7 @@ public:
 								}
 							}
 						}
-						
+
 						i += sizeof(inotify_event) + pEvent->len;
 						n -= sizeof(inotify_event) + pEvent->len;
 					}
@@ -368,12 +369,12 @@ public:
 			}
 		}
 	}
-	
+
 	void stop()
 	{
 		_stopped = true;
 	}
-	
+
 	bool supportsMoveEvents() const
 	{
 		return true;
@@ -381,7 +382,7 @@ public:
 
 private:
 	int _fd;
-	bool _stopped;
+	std::atomic<bool> _stopped;
 };
 
 
@@ -464,7 +465,7 @@ public:
 private:
 	int _queueFD;
 	int _dirFD;
-	bool _stopped;
+	std::atomic<bool> _stopped;
 };
 
 
@@ -478,11 +479,11 @@ public:
 		DirectoryWatcherStrategy(owner)
 	{
 	}
-	
+
 	~PollingDirectoryWatcherStrategy()
 	{
 	}
-	
+
 	void run()
 	{
 		ItemInfoMap entries;
@@ -502,7 +503,7 @@ public:
 			}
 		}
 	}
-	
+
 	void stop()
 	{
 		_stopped.set();
@@ -529,7 +530,7 @@ DirectoryWatcher::DirectoryWatcher(const std::string& path, int eventMask, int s
 	init();
 }
 
-	
+
 DirectoryWatcher::DirectoryWatcher(const Poco::File& directory, int eventMask, int scanInterval):
 	_directory(directory),
 	_eventMask(eventMask),
@@ -552,11 +553,11 @@ DirectoryWatcher::~DirectoryWatcher()
 	}
 }
 
-	
+
 void DirectoryWatcher::suspendEvents()
 {
 	poco_assert (_eventsSuspended > 0);
-	
+
 	_eventsSuspended--;
 }
 
@@ -571,7 +572,7 @@ void DirectoryWatcher::init()
 {
 	if (!_directory.exists())
 		throw Poco::FileNotFoundException(_directory.path());
-		
+
 	if (!_directory.isDirectory())
 		throw Poco::InvalidArgumentException("not a directory", _directory.path());
 
@@ -587,7 +588,7 @@ void DirectoryWatcher::init()
 	_thread.start(*this);
 }
 
-	
+
 void DirectoryWatcher::run()
 {
 	_pStrategy->run();
diff --git a/contrib/libpoco/Net/include/Poco/Net/HTTPServerConnection.h b/contrib/libpoco/Net/include/Poco/Net/HTTPServerConnection.h
index 5076332b9ea..6cc5b51744a 100644
--- a/contrib/libpoco/Net/include/Poco/Net/HTTPServerConnection.h
+++ b/contrib/libpoco/Net/include/Poco/Net/HTTPServerConnection.h
@@ -27,6 +27,8 @@
 #include "Poco/Net/HTTPServerParams.h"
 #include "Poco/Mutex.h"
 
+#include <atomic>
+
 
 namespace Poco {
 namespace Net {
@@ -45,7 +47,7 @@ public:
 
 	virtual ~HTTPServerConnection();
 		/// Destroys the HTTPServerConnection.
-		
+
 	void run();
 		/// Handles all HTTP requests coming in.
 
@@ -56,7 +58,7 @@ protected:
 private:
 	HTTPServerParams::Ptr          _pParams;
 	HTTPRequestHandlerFactory::Ptr _pFactory;
-	bool _stopped;
+	std::atomic<bool> _stopped;
 	Poco::FastMutex _mutex;
 };
 
diff --git a/contrib/libpoco/Net/include/Poco/Net/TCPServerDispatcher.h b/contrib/libpoco/Net/include/Poco/Net/TCPServerDispatcher.h
index a485617f319..7a23eba2090 100644
--- a/contrib/libpoco/Net/include/Poco/Net/TCPServerDispatcher.h
+++ b/contrib/libpoco/Net/include/Poco/Net/TCPServerDispatcher.h
@@ -29,6 +29,8 @@
 #include "Poco/ThreadPool.h"
 #include "Poco/Mutex.h"
 
+#include <atomic>
+
 
 namespace Poco {
 namespace Net {
@@ -52,35 +54,35 @@ public:
 	void release();
 		/// Decrements the object's reference count
 		/// and deletes the object if the count
-		/// reaches zero.	
+		/// reaches zero.
 
 	void run();
 		/// Runs the dispatcher.
-		
+
 	void enqueue(const StreamSocket& socket);
 		/// Queues the given socket connection.
 
 	void stop();
 		/// Stops the dispatcher.
-			
+
 	int currentThreads() const;
 		/// Returns the number of currently used threads.
 
 	int maxThreads() const;
 		/// Returns the maximum number of threads available.
-		
+
 	int totalConnections() const;
 		/// Returns the total number of handled connections.
-		
+
 	int currentConnections() const;
-		/// Returns the number of currently handled connections.	
+		/// Returns the number of currently handled connections.
 
 	int maxConcurrentConnections() const;
-		/// Returns the maximum number of concurrently handled connections.	
-		
+		/// Returns the maximum number of concurrently handled connections.
+
 	int queuedConnections() const;
-		/// Returns the number of queued connections.	
-	
+		/// Returns the number of queued connections.
+
 	int refusedConnections() const;
 		/// Returns the number of refused connections.
 
@@ -93,7 +95,7 @@ protected:
 
 	void beginConnection();
 		/// Updates the performance counters.
-		
+
 	void endConnection();
 		/// Updates the performance counters.
 
@@ -109,7 +111,7 @@ private:
 	int  _currentConnections;
 	int  _maxConcurrentConnections;
 	int  _refusedConnections;
-	bool _stopped;
+	std::atomic<bool> _stopped;
 	Poco::NotificationQueue         _queue;
 	TCPServerConnectionFactory::Ptr _pConnectionFactory;
 	Poco::ThreadPool&               _threadPool;

From fe717a4d6e169030cd7d43d6c5cdd87a73777d0d Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 10 Sep 2017 01:28:38 +0300
Subject: [PATCH 165/266] Fixed not an issue, shown by TSan; minor
 modifications [#CLICKHOUSE-2].

---
 dbms/src/Interpreters/Quota.cpp | 45 ++++++++++++++++++++++-----------
 dbms/src/Interpreters/Quota.h   | 39 ++++++++++++++++++++--------
 2 files changed, 58 insertions(+), 26 deletions(-)

diff --git a/dbms/src/Interpreters/Quota.cpp b/dbms/src/Interpreters/Quota.cpp
index ff459e88ece..4a3d40aa7fa 100644
--- a/dbms/src/Interpreters/Quota.cpp
+++ b/dbms/src/Interpreters/Quota.cpp
@@ -37,10 +37,11 @@ template void QuotaValues<size_t>::initFromConfig(const String & config_elem, Po
 template void QuotaValues<std::atomic<size_t>>::initFromConfig(const String & config_elem, Poco::Util::AbstractConfiguration & config);
 
 
-void QuotaForInterval::initFromConfig(const String & config_elem, time_t duration_, time_t offset_, Poco::Util::AbstractConfiguration & config)
+void QuotaForInterval::initFromConfig(const String & config_elem, time_t duration_, bool randomize_, time_t offset_, Poco::Util::AbstractConfiguration & config)
 {
-    rounded_time = 0;
+    rounded_time.store(0, std::memory_order_relaxed);
     duration = duration_;
+    randomize = randomize_;
     offset = offset_;
     max.initFromConfig(config_elem, config);
 }
@@ -61,8 +62,10 @@ String QuotaForInterval::toString() const
 {
     std::stringstream res;
 
+    auto loaded_rounded_time = rounded_time.load(std::memory_order_relaxed);
+
     res << std::fixed << std::setprecision(3)
-        << "Interval:       " << LocalDateTime(rounded_time) << " - " << LocalDateTime(rounded_time + duration) << ".\n"
+        << "Interval:       " << LocalDateTime(loaded_rounded_time) << " - " << LocalDateTime(loaded_rounded_time + duration) << ".\n"
         << "Queries:        " << used.queries         << ".\n"
         << "Errors:         " << used.errors         << ".\n"
         << "Result rows:    " << used.result_rows     << ".\n"
@@ -107,10 +110,22 @@ void QuotaForInterval::checkAndAddExecutionTime(time_t current_time, const Strin
 
 void QuotaForInterval::updateTime(time_t current_time)
 {
-    if (current_time >= rounded_time + static_cast<int>(duration))
+    /** If current time is greater than end of interval,
+      *  then clear accumulated quota values and switch to next interval [rounded_time, rounded_time + duration).
+      */
+
+    auto loaded_rounded_time = rounded_time.load(std::memory_order_acquire);
+    while (true)
     {
-        rounded_time = (current_time - offset) / duration * duration + offset;
-        used.clear();
+        if (current_time < loaded_rounded_time + static_cast<time_t>(duration))
+            break;
+
+        time_t new_rounded_time = (current_time - offset) / duration * duration + offset;
+        if (rounded_time.compare_exchange_strong(loaded_rounded_time, new_rounded_time))
+        {
+            used.clear();
+            break;
+        }
     }
 }
 
@@ -136,7 +151,7 @@ void QuotaForInterval::check(
 
         message << " has been exceeded. "
             << resource_name << ": " << used_amount << ", max: " << max_amount << ". "
-            << "Interval will end at " << LocalDateTime(rounded_time + duration) << ". "
+            << "Interval will end at " << LocalDateTime(rounded_time.load(std::memory_order_relaxed) + duration) << ". "
             << "Name of quota template: '" << quota_name << "'.";
 
         throw Exception(message.str(), ErrorCodes::QUOTA_EXPIRED);
@@ -158,14 +173,14 @@ void QuotaForIntervals::initFromConfig(const String & config_elem, Poco::Util::A
         time_t duration = config.getInt(interval_config_elem + ".duration", 0);
         time_t offset = 0;
 
-        if (!duration) /// Skip quaotas with zero duration
+        if (!duration) /// Skip quotas with zero duration
             continue;
 
         bool randomize = config.getBool(interval_config_elem + ".randomize", false);
         if (randomize)
             offset = std::uniform_int_distribution<decltype(duration)>(0, duration - 1)(rng);
 
-        cont[duration].initFromConfig(interval_config_elem, duration, offset, config);
+        cont[duration].initFromConfig(interval_config_elem, duration, randomize, offset, config);
     }
 }
 
@@ -182,7 +197,7 @@ void QuotaForIntervals::setMax(const QuotaForIntervals & quota)
     for (auto & x : quota.cont)
     {
         if (!cont.count(x.first))
-            cont[x.first] = x.second;
+            cont.emplace(x.first, x.second);
         else
             cont[x.first].max = x.second.max;
     }
@@ -254,7 +269,7 @@ void Quota::loadFromConfig(const String & config_elem, const String & name_, Poc
 
     QuotaForIntervals new_max(name, {});
     new_max.initFromConfig(config_elem, config, rng);
-    if (!(new_max == max))
+    if (!new_max.hasEqualConfiguration(max))
     {
         max = new_max;
         for (auto & quota : quota_for_keys)
@@ -310,9 +325,9 @@ void Quotas::loadFromConfig(Poco::Util::AbstractConfiguration & config)
 
     for (Poco::Util::AbstractConfiguration::Keys::const_iterator it = config_keys.begin(); it != config_keys.end(); ++it)
     {
-        if (!cont[*it])
-            cont[*it] = std::make_unique<Quota>();
-        cont[*it]->loadFromConfig("quotas." + *it, *it, config, rng);
+        if (!cont.count(*it))
+            cont.try_emplace(*it);
+        cont[*it].loadFromConfig("quotas." + *it, *it, config, rng);
     }
 }
 
@@ -322,7 +337,7 @@ QuotaForIntervalsPtr Quotas::get(const String & name, const String & quota_key,
     if (cont.end() == it)
         throw Exception("Unknown quota " + name, ErrorCodes::UNKNOWN_QUOTA);
 
-    return it->second->get(quota_key, user_name, ip);
+    return it->second.get(quota_key, user_name, ip);
 }
 
 }
diff --git a/dbms/src/Interpreters/Quota.h b/dbms/src/Interpreters/Quota.h
index 0421ce0df6d..3331af1cfa2 100644
--- a/dbms/src/Interpreters/Quota.h
+++ b/dbms/src/Interpreters/Quota.h
@@ -99,16 +99,17 @@ inline auto QuotaValues<std::atomic<size_t>>::tuple() const
 /// Time, rounded down to start of interval; limits for that interval and accumulated values.
 struct QuotaForInterval
 {
-    time_t rounded_time = 0;
+    std::atomic<time_t> rounded_time {0};
     size_t duration = 0;
+    bool randomize = false;
     time_t offset = 0;        /// Offset of interval for randomization (to avoid DoS if intervals for many users end at one time).
     QuotaValues<size_t> max;
     QuotaValues<std::atomic<size_t>> used;
 
-    QuotaForInterval() {}
+    QuotaForInterval() = default;
     QuotaForInterval(time_t duration_) : duration(duration_) {}
 
-    void initFromConfig(const String & config_elem, time_t duration_, time_t offset_, Poco::Util::AbstractConfiguration & config);
+    void initFromConfig(const String & config_elem, time_t duration_, bool randomize_, time_t offset_, Poco::Util::AbstractConfiguration & config);
 
     /// Increase current value.
     void addQuery() noexcept;
@@ -125,14 +126,30 @@ struct QuotaForInterval
     /// Get a text, describing what quota is exceeded.
     String toString() const;
 
+    /// Only compare configuration, not accumulated (used) values or random offsets.
     bool operator== (const QuotaForInterval & rhs) const
     {
-        return
-            rounded_time    == rhs.rounded_time &&
-            duration        == rhs.duration &&
-            max                == rhs.max &&
-            used            == rhs.used;
+        return randomize == rhs.randomize
+            && duration == rhs.duration
+            && max == rhs.max;
     }
+
+    QuotaForInterval & operator= (const QuotaForInterval & rhs)
+    {
+        rounded_time.store(rhs.rounded_time.load(std::memory_order_relaxed));
+        duration = rhs.duration;
+        randomize = rhs.randomize;
+        offset = rhs.offset;
+        max = rhs.max;
+        used = rhs.used;
+        return *this;
+    }
+
+    QuotaForInterval(const QuotaForInterval & rhs)
+    {
+        *this = rhs;
+    }
+
 private:
     /// Reset counters of used resources, if interval for quota is expired.
     void updateTime(time_t current_time);
@@ -192,7 +209,7 @@ public:
     /// Get text, describing what part of quota has been exceeded.
     String toString() const;
 
-    bool operator== (const QuotaForIntervals & rhs) const
+    bool hasEqualConfiguration(const QuotaForIntervals & rhs) const
     {
         return cont == rhs.cont && quota_name == rhs.quota_name;
     }
@@ -233,13 +250,13 @@ class Quotas
 {
 private:
     /// Name of quota -> quota.
-    using Container = std::unordered_map<String, std::unique_ptr<Quota>>;
+    using Container = std::unordered_map<String, Quota>;
     Container cont;
 
 public:
     void loadFromConfig(Poco::Util::AbstractConfiguration & config);
     QuotaForIntervalsPtr get(const String & name, const String & quota_key,
-                            const String & user_name, const Poco::Net::IPAddress & ip);
+        const String & user_name, const Poco::Net::IPAddress & ip);
 };
 
 }

From 93f1e274fb29b6a7cb20676252085a19d8d5a62d Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 10 Sep 2017 01:43:11 +0300
Subject: [PATCH 166/266] Removed unused code from pcg-random, that generates
 compiler warning by default [#CLICKHOUSE-2].

---
 contrib/libpcg-random/include/pcg_extras.hpp | 21 --------------------
 1 file changed, 21 deletions(-)

diff --git a/contrib/libpcg-random/include/pcg_extras.hpp b/contrib/libpcg-random/include/pcg_extras.hpp
index 9bbe8edfe9a..929c756b151 100644
--- a/contrib/libpcg-random/include/pcg_extras.hpp
+++ b/contrib/libpcg-random/include/pcg_extras.hpp
@@ -582,27 +582,6 @@ public:
     }
 };
 
-/*
- * Sometimes you might want a distinct seed based on when the program
- * was compiled.  That way, a particular instance of the program will
- * behave the same way, but when recompiled it'll produce a different
- * value.
- */
-
-template <typename IntType>
-struct static_arbitrary_seed {
-private:
-    static constexpr IntType fnv(IntType hash, const char* pos) {
-        return *pos == '\0'
-             ? hash
-             : fnv((hash * IntType(16777619U)) ^ *pos, (pos+1));
-    }
-
-public:
-    static constexpr IntType value = fnv(IntType(2166136261U ^ sizeof(IntType)),
-                        __DATE__ __TIME__ __FILE__);
-};
-
 // Sometimes, when debugging or testing, it's handy to be able print the name
 // of a (in human-readable form).  This code allows the idiom:
 //

From a6d5e9c7e8c352f2561813ef2669c816ac8f8d72 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 10 Sep 2017 02:04:22 +0300
Subject: [PATCH 167/266] Fixed not an issue, shown by TSan [#CLICKHOUSE-2].

---
 dbms/src/Storages/Distributed/DirectoryMonitor.h | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/dbms/src/Storages/Distributed/DirectoryMonitor.h b/dbms/src/Storages/Distributed/DirectoryMonitor.h
index cb7ff07a5ef..f1b6546c195 100644
--- a/dbms/src/Storages/Distributed/DirectoryMonitor.h
+++ b/dbms/src/Storages/Distributed/DirectoryMonitor.h
@@ -2,6 +2,7 @@
 
 #include <Storages/StorageDistributed.h>
 
+#include <atomic>
 #include <thread>
 #include <mutex>
 #include <condition_variable>
@@ -45,7 +46,7 @@ private:
     std::chrono::milliseconds default_sleep_time;
     std::chrono::milliseconds sleep_time;
     std::chrono::time_point<std::chrono::system_clock> last_decrease_time {std::chrono::system_clock::now()};
-    bool quit {false};
+    std::atomic<bool> quit {false};
     std::mutex mutex;
     std::condition_variable cond;
     Logger * log;

From 5a8f47a640ca38ddee81eacf1626dcc0d24a9896 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 10 Sep 2017 02:07:32 +0300
Subject: [PATCH 168/266] Fixed not an issue, shown by TSan [#CLICKHOUSE-2].

---
 dbms/src/Storages/Distributed/DirectoryMonitor.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbms/src/Storages/Distributed/DirectoryMonitor.cpp b/dbms/src/Storages/Distributed/DirectoryMonitor.cpp
index 03831ba8428..668500853e9 100644
--- a/dbms/src/Storages/Distributed/DirectoryMonitor.cpp
+++ b/dbms/src/Storages/Distributed/DirectoryMonitor.cpp
@@ -115,7 +115,7 @@ void StorageDistributedDirectoryMonitor::run()
 
     std::unique_lock<std::mutex> lock{mutex};
 
-    const auto quit_requested = [this] { return quit; };
+    const auto quit_requested = [this] { return quit.load(std::memory_order_relaxed); };
 
     while (!quit_requested())
     {

From cd540c26747e9b71543a364eff7c1cf7c00a9ff8 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 10 Sep 2017 02:17:38 +0300
Subject: [PATCH 169/266] Replaced Mersenne Twister to PCG-Random
 [#CLICKHOUSE-2].

---
 dbms/CMakeLists.txt                           |  1 +
 dbms/src/AggregateFunctions/CMakeLists.txt    |  1 -
 dbms/src/Common/ArrayCache.h                  |  3 ++-
 dbms/src/Common/ZooKeeper/ZooKeeper.cpp       |  7 ++++---
 dbms/src/Common/tests/array_cache.cpp         |  3 ++-
 .../Common/tests/gtest_rw_lock_fifo.cpp.cpp   |  7 ++++---
 .../DataStreams/narrowBlockInputStreams.cpp   |  3 ++-
 dbms/src/Dictionaries/CacheDictionary.cpp     |  2 +-
 dbms/src/Dictionaries/CacheDictionary.h       |  4 ++--
 .../ComplexKeyCacheDictionary.cpp             |  2 +-
 .../Dictionaries/ComplexKeyCacheDictionary.h  |  4 ++--
 dbms/src/Interpreters/Context.cpp             |  4 ++--
 dbms/src/Interpreters/DDLWorker.cpp           |  6 +++++-
 dbms/src/Interpreters/ExternalDictionaries.h  |  5 +++--
 dbms/src/Interpreters/Quota.cpp               |  7 ++++---
 dbms/src/Interpreters/Quota.h                 |  6 +++---
 dbms/src/Server/Benchmark.cpp                 |  3 ++-
 .../MergeTree/BackgroundProcessingPool.cpp    |  4 +++-
 .../Storages/MergeTree/ReshardingWorker.cpp   | 20 ++++++-------------
 .../src/Storages/StorageReplicatedMergeTree.h |  4 ++--
 utils/iotest/iotest.cpp                       |  8 +++-----
 utils/iotest/iotest_nonblock.cpp              |  8 +++-----
 utils/test-data-generator/main.cpp            |  5 +++--
 utils/test-data-generator/markov-model.cpp    |  3 ++-
 24 files changed, 62 insertions(+), 58 deletions(-)

diff --git a/dbms/CMakeLists.txt b/dbms/CMakeLists.txt
index 0feacf7f849..dbf23edc479 100644
--- a/dbms/CMakeLists.txt
+++ b/dbms/CMakeLists.txt
@@ -206,6 +206,7 @@ target_link_libraries (dbms
 target_include_directories (dbms BEFORE PRIVATE ${DIVIDE_INCLUDE_DIR})
 target_include_directories (dbms BEFORE PRIVATE ${SPARCEHASH_INCLUDE_DIR})
 target_include_directories (dbms PUBLIC ${DBMS_INCLUDE_DIR})
+target_include_directories (dbms PUBLIC ${PCG_RANDOM_INCLUDE_DIR})
 
 # only for copy_headers.sh:
 target_include_directories (dbms PRIVATE ${COMMON_INCLUDE_DIR})
diff --git a/dbms/src/AggregateFunctions/CMakeLists.txt b/dbms/src/AggregateFunctions/CMakeLists.txt
index 4414d89f4a0..f3fb20b6101 100644
--- a/dbms/src/AggregateFunctions/CMakeLists.txt
+++ b/dbms/src/AggregateFunctions/CMakeLists.txt
@@ -29,4 +29,3 @@ list(REMOVE_ITEM clickhouse_aggregate_functions_headers
 add_library(clickhouse_aggregate_functions ${clickhouse_aggregate_functions_sources})
 target_link_libraries(clickhouse_aggregate_functions dbms)
 target_include_directories (clickhouse_aggregate_functions PRIVATE ${COMMON_INCLUDE_DIR})
-target_include_directories (clickhouse_aggregate_functions PRIVATE ${PCG_RANDOM_INCLUDE_DIR})
diff --git a/dbms/src/Common/ArrayCache.h b/dbms/src/Common/ArrayCache.h
index 38ec9f88bd7..eda20ca6bf2 100644
--- a/dbms/src/Common/ArrayCache.h
+++ b/dbms/src/Common/ArrayCache.h
@@ -5,6 +5,7 @@
 #include <list>
 #include <memory>
 #include <random>
+#include <pcg_random.hpp>
 #include <unordered_map>
 #include <sys/mman.h>
 #include <boost/intrusive/list.hpp>
@@ -160,7 +161,7 @@ private:
 
     mutable std::mutex mutex;
 
-    std::mt19937_64 rng {static_cast<std::mt19937_64::result_type>(randomSeed())};
+    pcg64 rng{randomSeed()};
 
     struct Chunk : private boost::noncopyable
     {
diff --git a/dbms/src/Common/ZooKeeper/ZooKeeper.cpp b/dbms/src/Common/ZooKeeper/ZooKeeper.cpp
index 05c5c16d3d2..765bf494580 100644
--- a/dbms/src/Common/ZooKeeper/ZooKeeper.cpp
+++ b/dbms/src/Common/ZooKeeper/ZooKeeper.cpp
@@ -1,9 +1,11 @@
 #include <random>
+#include <pcg_random.hpp>
 #include <functional>
 #include <Common/ZooKeeper/ZooKeeper.h>
 #include <common/logger_useful.h>
 #include <Common/ProfileEvents.h>
 #include <Common/StringUtils.h>
+#include <Common/randomSeed.h>
 
 
 namespace ProfileEvents
@@ -137,9 +139,8 @@ struct ZooKeeperArgs
         }
 
         /// Shuffle the hosts to distribute the load among ZooKeeper nodes.
-        std::random_device rd;
-        std::mt19937 g(rd());
-        std::shuffle(hosts_strings.begin(), hosts_strings.end(), g);
+        pcg64 rng(randomSeed());
+        std::shuffle(hosts_strings.begin(), hosts_strings.end(), rng);
 
         for (auto & host : hosts_strings)
         {
diff --git a/dbms/src/Common/tests/array_cache.cpp b/dbms/src/Common/tests/array_cache.cpp
index 8dec433e3d6..b962e86c53c 100644
--- a/dbms/src/Common/tests/array_cache.cpp
+++ b/dbms/src/Common/tests/array_cache.cpp
@@ -1,6 +1,7 @@
 #include <iostream>
 #include <cstring>
 #include <thread>
+#include <pcg_random.hpp>
 #include <Common/ArrayCache.h>
 #include <IO/ReadHelpers.h>
 
@@ -51,7 +52,7 @@ int main(int argc, char ** argv)
     {
         threads.emplace_back([&]
         {
-            std::mt19937 generator(randomSeed());
+            pcg64 generator(randomSeed());
 
             for (size_t i = 0; i < num_iterations; ++i)
             {
diff --git a/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp b/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp
index 8dee71fb379..48f04e9fc01 100644
--- a/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp
+++ b/dbms/src/Common/tests/gtest_rw_lock_fifo.cpp.cpp
@@ -4,6 +4,7 @@
 #include <common/Types.h>
 #include <common/ThreadPool.h>
 #include <random>
+#include <pcg_random.hpp>
 #include <thread>
 #include <atomic>
 #include <iomanip>
@@ -23,7 +24,7 @@ TEST(Common, RWLockFIFO_1)
     static auto fifo_lock = RWLockFIFO::create();
 
     static thread_local std::random_device rd;
-    static thread_local std::mt19937 gen(rd());
+    static thread_local pcg64 gen(rd());
 
     auto func = [&] (size_t threads, int round) {
         for (int  i = 0; i < cycles; ++i)
@@ -85,7 +86,7 @@ TEST(Common, RWLockFIFO_Recursive)
     static auto fifo_lock = RWLockFIFO::create();
 
     static thread_local std::random_device rd;
-    static thread_local std::mt19937 gen(rd());
+    static thread_local pcg64 gen(rd());
 
     std::thread t1([&] () {
         for (int i = 0; i < 2 * cycles; ++i)
@@ -106,7 +107,7 @@ TEST(Common, RWLockFIFO_Recursive)
             std::this_thread::sleep_for(sleep_for);
 
             auto lock2 = fifo_lock->getLock(RWLockFIFO::Read);
-            
+
             EXPECT_ANY_THROW({fifo_lock->getLock(RWLockFIFO::Write);});
         }
 
diff --git a/dbms/src/DataStreams/narrowBlockInputStreams.cpp b/dbms/src/DataStreams/narrowBlockInputStreams.cpp
index 25927e451e4..07c26bc9b67 100644
--- a/dbms/src/DataStreams/narrowBlockInputStreams.cpp
+++ b/dbms/src/DataStreams/narrowBlockInputStreams.cpp
@@ -1,4 +1,5 @@
 #include <random>
+#include <pcg_random.hpp>
 #include <Common/randomSeed.h>
 #include <DataStreams/ConcatBlockInputStream.h>
 
@@ -20,7 +21,7 @@ BlockInputStreams narrowBlockInputStreams(BlockInputStreams & inputs, size_t wid
     for (size_t i = 0; i < size; ++i)
         distribution[i] = i % width;
 
-    std::mt19937 generator(randomSeed());
+    pcg64 generator(randomSeed());
     std::shuffle(distribution.begin(), distribution.end(), generator);
 
     for (size_t i = 0; i < size; ++i)
diff --git a/dbms/src/Dictionaries/CacheDictionary.cpp b/dbms/src/Dictionaries/CacheDictionary.cpp
index f69fbd607f4..b9d33f5ac16 100644
--- a/dbms/src/Dictionaries/CacheDictionary.cpp
+++ b/dbms/src/Dictionaries/CacheDictionary.cpp
@@ -68,7 +68,7 @@ CacheDictionary::CacheDictionary(const std::string & name, const DictionaryStruc
         size{roundUpToPowerOfTwoOrZero(std::max(size, size_t(max_collision_length)))},
         size_overlap_mask{this->size - 1},
         cells{this->size},
-        rnd_engine{randomSeed()}
+        rnd_engine(randomSeed())
 {
     if (!this->source_ptr->supportsSelectiveLoad())
         throw Exception{
diff --git a/dbms/src/Dictionaries/CacheDictionary.h b/dbms/src/Dictionaries/CacheDictionary.h
index 45bfceb16ad..ac0854fc84e 100644
--- a/dbms/src/Dictionaries/CacheDictionary.h
+++ b/dbms/src/Dictionaries/CacheDictionary.h
@@ -13,7 +13,7 @@
 #include <vector>
 #include <map>
 #include <tuple>
-#include <random>
+#include <pcg_random.hpp>
 #include <shared_mutex>
 
 
@@ -260,7 +260,7 @@ private:
     Attribute * hierarchical_attribute = nullptr;
     std::unique_ptr<ArenaWithFreeLists> string_arena;
 
-    mutable std::mt19937_64 rnd_engine;
+    mutable pcg64 rnd_engine;
 
     mutable size_t bytes_allocated = 0;
     mutable std::atomic<size_t> element_count{0};
diff --git a/dbms/src/Dictionaries/ComplexKeyCacheDictionary.cpp b/dbms/src/Dictionaries/ComplexKeyCacheDictionary.cpp
index b8f5c8c1dfd..37cfc759e6c 100644
--- a/dbms/src/Dictionaries/ComplexKeyCacheDictionary.cpp
+++ b/dbms/src/Dictionaries/ComplexKeyCacheDictionary.cpp
@@ -57,7 +57,7 @@ ComplexKeyCacheDictionary::ComplexKeyCacheDictionary(const std::string & name, c
     : name{name}, dict_struct(dict_struct), source_ptr{std::move(source_ptr)}, dict_lifetime(dict_lifetime),
     size{roundUpToPowerOfTwoOrZero(std::max(size, size_t(max_collision_length)))},
     size_overlap_mask{this->size - 1},
-    rnd_engine{randomSeed()}
+    rnd_engine(randomSeed())
 {
     if (!this->source_ptr->supportsSelectiveLoad())
         throw Exception{
diff --git a/dbms/src/Dictionaries/ComplexKeyCacheDictionary.h b/dbms/src/Dictionaries/ComplexKeyCacheDictionary.h
index 2b806b51316..09e6330efdd 100644
--- a/dbms/src/Dictionaries/ComplexKeyCacheDictionary.h
+++ b/dbms/src/Dictionaries/ComplexKeyCacheDictionary.h
@@ -3,7 +3,6 @@
 #include <atomic>
 #include <chrono>
 #include <map>
-#include <random>
 #include <tuple>
 #include <vector>
 #include <shared_mutex>
@@ -19,6 +18,7 @@
 #include <ext/bit_cast.h>
 #include <ext/map.h>
 #include <ext/scope_guard.h>
+#include <pcg_random.hpp>
 
 
 namespace ProfileEvents
@@ -721,7 +721,7 @@ private:
     std::unique_ptr<SmallObjectPool> fixed_size_keys_pool = key_size_is_fixed ? std::make_unique<SmallObjectPool>(key_size) : nullptr;
     std::unique_ptr<ArenaWithFreeLists> string_arena;
 
-    mutable std::mt19937_64 rnd_engine;
+    mutable pcg64 rnd_engine;
 
     mutable size_t bytes_allocated = 0;
     mutable std::atomic<size_t> element_count{0};
diff --git a/dbms/src/Interpreters/Context.cpp b/dbms/src/Interpreters/Context.cpp
index a2812495c69..3663597f334 100644
--- a/dbms/src/Interpreters/Context.cpp
+++ b/dbms/src/Interpreters/Context.cpp
@@ -1,6 +1,5 @@
 #include <map>
 #include <set>
-#include <random>
 
 #include <boost/functional/hash/hash.hpp>
 #include <Poco/Mutex.h>
@@ -9,6 +8,7 @@
 #include <Poco/Net/IPAddress.h>
 
 #include <common/logger_useful.h>
+#include <pcg_random.hpp>
 
 #include <Common/Macros.h>
 #include <Common/escapeForFileName.h>
@@ -175,7 +175,7 @@ struct ContextShared
 
     Context::ApplicationType application_type = Context::ApplicationType::SERVER;
 
-    std::mt19937_64 rng{randomSeed()};
+    pcg64 rng{randomSeed()};
 
     ContextShared()
     {
diff --git a/dbms/src/Interpreters/DDLWorker.cpp b/dbms/src/Interpreters/DDLWorker.cpp
index eda33e983ee..c2afea4a79f 100644
--- a/dbms/src/Interpreters/DDLWorker.cpp
+++ b/dbms/src/Interpreters/DDLWorker.cpp
@@ -21,6 +21,7 @@
 #include <Common/getFQDNOrHostName.h>
 #include <Common/setThreadName.h>
 #include <Common/Stopwatch.h>
+#include <Common/randomSeed.h>
 
 #include <DataTypes/DataTypesNumber.h>
 #include <DataTypes/DataTypeString.h>
@@ -34,6 +35,9 @@
 #include <Common/isLocalAddress.h>
 #include <Poco/Timestamp.h>
 
+#include <random>
+#include <pcg_random.hpp>
+
 
 namespace DB
 {
@@ -655,7 +659,7 @@ void DDLWorker::processTaskAlter(
         bool alter_executed_by_any_replica = false;
         {
             auto lock = createSimpleZooKeeperLock(zookeeper, shard_path, "lock", task.host_id_str);
-            std::mt19937 rng(StringRefHash{}(task.host_id_str) + reinterpret_cast<intptr_t>(&rng));
+            pcg64 rng(randomSeed());
 
             for (int num_tries = 0; num_tries < 10; ++num_tries)
             {
diff --git a/dbms/src/Interpreters/ExternalDictionaries.h b/dbms/src/Interpreters/ExternalDictionaries.h
index 7419f44a627..84488118e19 100644
--- a/dbms/src/Interpreters/ExternalDictionaries.h
+++ b/dbms/src/Interpreters/ExternalDictionaries.h
@@ -13,7 +13,8 @@
 #include <thread>
 #include <unordered_map>
 #include <chrono>
-#include <random>
+#include <pcg_random.hpp>
+
 
 namespace DB
 {
@@ -74,7 +75,7 @@ private:
       */
     std::unordered_map<std::string, std::chrono::system_clock::time_point> update_times;
 
-    std::mt19937_64 rnd_engine{randomSeed()};
+    pcg64 rnd_engine{randomSeed()};
 
     Context & context;
 
diff --git a/dbms/src/Interpreters/Quota.cpp b/dbms/src/Interpreters/Quota.cpp
index 4a3d40aa7fa..65fdda86fa5 100644
--- a/dbms/src/Interpreters/Quota.cpp
+++ b/dbms/src/Interpreters/Quota.cpp
@@ -8,6 +8,7 @@
 #include <Interpreters/Quota.h>
 
 #include <set>
+#include <random>
 
 
 namespace DB
@@ -159,7 +160,7 @@ void QuotaForInterval::check(
 }
 
 
-void QuotaForIntervals::initFromConfig(const String & config_elem, Poco::Util::AbstractConfiguration & config, std::mt19937 & rng)
+void QuotaForIntervals::initFromConfig(const String & config_elem, Poco::Util::AbstractConfiguration & config, pcg64 & rng)
 {
     Poco::Util::AbstractConfiguration::Keys config_keys;
     config.keys(config_elem, config_keys);
@@ -250,7 +251,7 @@ String QuotaForIntervals::toString() const
 }
 
 
-void Quota::loadFromConfig(const String & config_elem, const String & name_, Poco::Util::AbstractConfiguration & config, std::mt19937 & rng)
+void Quota::loadFromConfig(const String & config_elem, const String & name_, Poco::Util::AbstractConfiguration & config, pcg64 & rng)
 {
     name = name_;
 
@@ -308,7 +309,7 @@ QuotaForIntervalsPtr Quota::get(const String & quota_key, const String & user_na
 
 void Quotas::loadFromConfig(Poco::Util::AbstractConfiguration & config)
 {
-    std::mt19937 rng;
+    pcg64 rng;
 
     Poco::Util::AbstractConfiguration::Keys config_keys;
     config.keys("quotas", config_keys);
diff --git a/dbms/src/Interpreters/Quota.h b/dbms/src/Interpreters/Quota.h
index 3331af1cfa2..8df01fe9593 100644
--- a/dbms/src/Interpreters/Quota.h
+++ b/dbms/src/Interpreters/Quota.h
@@ -3,7 +3,7 @@
 #include <cstring>
 #include <unordered_map>
 #include <memory>
-#include <random>
+#include <pcg_random.hpp>
 
 #include <Poco/Timespan.h>
 
@@ -191,7 +191,7 @@ public:
         return cont.empty();
     }
 
-    void initFromConfig(const String & config_elem, Poco::Util::AbstractConfiguration & config, std::mt19937 & rng);
+    void initFromConfig(const String & config_elem, Poco::Util::AbstractConfiguration & config, pcg64 & rng);
 
     /// Set maximum values (limits) from passed argument.
     /// Remove intervals that does not exist in argument. Add intervals from argument, that we don't have.
@@ -241,7 +241,7 @@ struct Quota
 
     bool keyed_by_ip = false;
 
-    void loadFromConfig(const String & config_elem, const String & name_, Poco::Util::AbstractConfiguration & config, std::mt19937 & rng);
+    void loadFromConfig(const String & config_elem, const String & name_, Poco::Util::AbstractConfiguration & config, pcg64 & rng);
     QuotaForIntervalsPtr get(const String & quota_key, const String & user_name, const Poco::Net::IPAddress & ip);
 };
 
diff --git a/dbms/src/Server/Benchmark.cpp b/dbms/src/Server/Benchmark.cpp
index f3bd262ad6f..8d7f1057a2f 100644
--- a/dbms/src/Server/Benchmark.cpp
+++ b/dbms/src/Server/Benchmark.cpp
@@ -8,6 +8,7 @@
 #include <fstream>
 #include <iomanip>
 #include <random>
+#include <pcg_random.hpp>
 
 #include <Poco/File.h>
 #include <Poco/Util/Application.h>
@@ -230,7 +231,7 @@ private:
 
     void run()
     {
-        std::mt19937 generator(randomSeed());
+        pcg64 generator(randomSeed());
         std::uniform_int_distribution<size_t> distribution(0, queries.size() - 1);
 
         for (size_t i = 0; i < concurrency; ++i)
diff --git a/dbms/src/Storages/MergeTree/BackgroundProcessingPool.cpp b/dbms/src/Storages/MergeTree/BackgroundProcessingPool.cpp
index c0a7c1c0214..12b7edf32dc 100644
--- a/dbms/src/Storages/MergeTree/BackgroundProcessingPool.cpp
+++ b/dbms/src/Storages/MergeTree/BackgroundProcessingPool.cpp
@@ -2,10 +2,12 @@
 #include <Common/setThreadName.h>
 #include <Common/CurrentMetrics.h>
 #include <Common/MemoryTracker.h>
+#include <Common/randomSeed.h>
 #include <IO/WriteHelpers.h>
 #include <common/logger_useful.h>
 #include <Storages/MergeTree/BackgroundProcessingPool.h>
 
+#include <pcg_random.hpp>
 #include <random>
 
 
@@ -115,7 +117,7 @@ void BackgroundProcessingPool::threadFunction()
     memory_tracker.setMetric(CurrentMetrics::MemoryTrackingInBackgroundProcessingPool);
     current_memory_tracker = &memory_tracker;
 
-    std::mt19937 rng(reinterpret_cast<intptr_t>(&rng));
+    pcg64 rng(randomSeed());
     std::this_thread::sleep_for(std::chrono::duration<double>(std::uniform_real_distribution<double>(0, sleep_seconds_random_part)(rng)));
 
     while (!shutdown)
diff --git a/dbms/src/Storages/MergeTree/ReshardingWorker.cpp b/dbms/src/Storages/MergeTree/ReshardingWorker.cpp
index e0d0086c3fe..08b5ed51504 100644
--- a/dbms/src/Storages/MergeTree/ReshardingWorker.cpp
+++ b/dbms/src/Storages/MergeTree/ReshardingWorker.cpp
@@ -31,11 +31,14 @@
 #include <Poco/DirectoryIterator.h>
 #include <Poco/File.h>
 
+#include <boost/noncopyable.hpp>
+
 #include <future>
 #include <chrono>
 #include <cstdlib>
 #include <ctime>
-#include <random>
+#include <pcg_random.hpp>
+
 
 namespace DB
 {
@@ -1391,19 +1394,8 @@ void ReshardingWorker::executeAttach(LogRecord & log_record)
     /// Description of tasks for each replica of a shard.
     /// For fault tolerance purposes, some fields are provided
     /// to perform attempts on more than one replica if needed.
-    struct ShardTaskInfo
+    struct ShardTaskInfo : private boost::noncopyable
     {
-        ShardTaskInfo()
-        {
-            rng = std::mt19937(randomSeed());
-        }
-
-        ShardTaskInfo(const ShardTaskInfo &) = delete;
-        ShardTaskInfo & operator=(const ShardTaskInfo &) = delete;
-
-        ShardTaskInfo(ShardTaskInfo &&) = default;
-        ShardTaskInfo & operator=(ShardTaskInfo &&) = default;
-
         /// one task for each replica
         std::vector<TaskInfo> shard_tasks;
         /// index to the replica to be used
@@ -1411,7 +1403,7 @@ void ReshardingWorker::executeAttach(LogRecord & log_record)
         /// result of the operation on the current replica
         bool is_success = false;
         /// For pseudo-random number generation.
-        std::mt19937 rng;
+        pcg64 rng{randomSeed()};
     };
 
     const WeightedZooKeeperPath & weighted_path = current_job.paths[log_record.shard_no];
diff --git a/dbms/src/Storages/StorageReplicatedMergeTree.h b/dbms/src/Storages/StorageReplicatedMergeTree.h
index 0793231b16e..25562c778f1 100644
--- a/dbms/src/Storages/StorageReplicatedMergeTree.h
+++ b/dbms/src/Storages/StorageReplicatedMergeTree.h
@@ -2,7 +2,7 @@
 
 #include <ext/shared_ptr_helper.h>
 #include <atomic>
-#include <random>
+#include <pcg_random.hpp>
 #include <Storages/IStorage.h>
 #include <Storages/MergeTree/MergeTreeData.h>
 #include <Storages/MergeTree/MergeTreeDataMerger.h>
@@ -321,7 +321,7 @@ private:
 
     Logger * log;
 
-    std::mt19937 rng{randomSeed()};
+    pcg64 rng{randomSeed()};
 
     StorageReplicatedMergeTree(
         const String & zookeeper_path_,
diff --git a/utils/iotest/iotest.cpp b/utils/iotest/iotest.cpp
index 2c91e11cd41..439672fc25c 100644
--- a/utils/iotest/iotest.cpp
+++ b/utils/iotest/iotest.cpp
@@ -7,12 +7,14 @@
 #include <iomanip>
 #include <vector>
 #include <random>
+#include <pcg_random.hpp>
 
 #include <Poco/NumberParser.h>
 #include <Poco/NumberFormatter.h>
 #include <Poco/Exception.h>
 
 #include <Common/Exception.h>
+#include <Common/randomSeed.h>
 
 #include <common/ThreadPool.h>
 #include <Common/Stopwatch.h>
@@ -50,11 +52,7 @@ void thread(int fd, int mode, size_t min_offset, size_t max_offset, size_t block
     else
         buf = &simple_buf[0];
 
-    std::mt19937 rng;
-
-    timespec times;
-    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &times);
-    rng.seed(times.tv_nsec);
+    pcg64 rng(randomSeed());
 
     for (size_t i = 0; i < count; ++i)
     {
diff --git a/utils/iotest/iotest_nonblock.cpp b/utils/iotest/iotest_nonblock.cpp
index 5482e0ddaa7..fdd25860825 100644
--- a/utils/iotest/iotest_nonblock.cpp
+++ b/utils/iotest/iotest_nonblock.cpp
@@ -13,12 +13,14 @@
 #include <vector>
 
 #include <random>
+#include <pcg_random.hpp>
 
 #include <Poco/NumberParser.h>
 #include <Poco/NumberFormatter.h>
 #include <Poco/Exception.h>
 
 #include <Common/Exception.h>
+#include <Common/randomSeed.h>
 
 #include <common/ThreadPool.h>
 #include <Common/Stopwatch.h>
@@ -77,11 +79,7 @@ int mainImpl(int argc, char ** argv)
 
     std::vector<char> buf(block_size);
 
-    std::mt19937 rng;
-
-    timespec times;
-    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &times);
-    rng.seed(times.tv_nsec);
+    pcg64 rng(randomSeed());
 
     Stopwatch watch;
 
diff --git a/utils/test-data-generator/main.cpp b/utils/test-data-generator/main.cpp
index 4d16195cb72..2a0db1e4b3d 100644
--- a/utils/test-data-generator/main.cpp
+++ b/utils/test-data-generator/main.cpp
@@ -1,5 +1,6 @@
 #include <iostream>
 #include <random>
+#include <pcg_random.hpp>
 #include <cmath>
 
 #include <IO/WriteBufferFromFileDescriptor.h>
@@ -42,8 +43,8 @@ struct Models
 struct Generator
 {
     WriteBufferFromFileDescriptor out;
-    std::mt19937_64 random;
-    std::mt19937_64 random_with_seed;
+    pcg64 random;
+    pcg64 random_with_seed;
     Models models;
 
 //    UInt64 WatchID = random();
diff --git a/utils/test-data-generator/markov-model.cpp b/utils/test-data-generator/markov-model.cpp
index 08f7a3f72a9..87849f8f398 100644
--- a/utils/test-data-generator/markov-model.cpp
+++ b/utils/test-data-generator/markov-model.cpp
@@ -1,5 +1,6 @@
 #include <iostream>
 #include <random>
+#include <pcg_random.hpp>
 
 #include <boost/program_options.hpp>
 
@@ -47,7 +48,7 @@ try
     ReadBufferFromFileDescriptor in(STDIN_FILENO);
     WriteBufferFromFileDescriptor out(STDOUT_FILENO);
 
-    std::mt19937 random;
+    pcg64 random;
 
     if (options.count("seed"))
         random.seed(options["seed"].as<UInt64>());

From cf5fd27b9484ca301b38dd3818e818845f62c011 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 10 Sep 2017 04:39:40 +0300
Subject: [PATCH 170/266] Clarifications [#CLICKHOUSE-2].

---
 dbms/src/DataStreams/AsynchronousBlockInputStream.h | 2 +-
 dbms/src/DataStreams/IBlockInputStream.h            | 2 ++
 dbms/src/DataStreams/IProfilingBlockInputStream.h   | 8 +++++---
 3 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/dbms/src/DataStreams/AsynchronousBlockInputStream.h b/dbms/src/DataStreams/AsynchronousBlockInputStream.h
index 4ee17c2d30f..e72b2f6489f 100644
--- a/dbms/src/DataStreams/AsynchronousBlockInputStream.h
+++ b/dbms/src/DataStreams/AsynchronousBlockInputStream.h
@@ -115,7 +115,7 @@ protected:
             return res;
 
         /// Start the next block calculation
-        block = Block();
+        block.clear();
         next();
 
         return res;
diff --git a/dbms/src/DataStreams/IBlockInputStream.h b/dbms/src/DataStreams/IBlockInputStream.h
index fccccbd67e6..8e4b6d4abc0 100644
--- a/dbms/src/DataStreams/IBlockInputStream.h
+++ b/dbms/src/DataStreams/IBlockInputStream.h
@@ -49,6 +49,8 @@ public:
 
     /** Read next block.
       * If there are no more blocks, return an empty block (for which operator `bool` returns false).
+      * NOTE: Only one thread can read from one instance of IBlockInputStream simultaneously.
+      * This also applies for readPrefix, readSuffix.
       */
     virtual Block read() = 0;
 
diff --git a/dbms/src/DataStreams/IProfilingBlockInputStream.h b/dbms/src/DataStreams/IProfilingBlockInputStream.h
index 8fa9eb6731b..166560be154 100644
--- a/dbms/src/DataStreams/IProfilingBlockInputStream.h
+++ b/dbms/src/DataStreams/IProfilingBlockInputStream.h
@@ -174,8 +174,6 @@ protected:
     ProgressCallback progress_callback;
     ProcessListElement * process_list_elem = nullptr;
 
-    bool enabled_extremes = false;
-
     /// Additional information that can be generated during the work process.
 
     /// Total values during aggregation.
@@ -184,6 +182,10 @@ protected:
     Block extremes;
     /// The approximate total number of rows to read. For progress bar.
     size_t total_rows_approx = 0;
+
+private:
+    bool enabled_extremes = false;
+
     /// Information about the approximate total number of rows is collected in the parent source.
     bool collected_total_rows_approx = false;
 
@@ -218,7 +220,7 @@ protected:
     void collectTotalRowsApprox();
 
     /** Send information about the approximate total number of rows to the progress bar.
-      * It is done so that sending occurs only in the upper source.
+      * It is done so that sending occurs only in the upper stream.
       */
     void collectAndSendTotalRowsApprox();
 };

From dc5eca0bebf41bf91b88ec3bcc24e664e5d22f3d Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 10 Sep 2017 05:06:16 +0300
Subject: [PATCH 171/266] Fixed awful translation [#CLICKHOUSE-2].

---
 dbms/src/Client/MultiplexedConnections.h        | 2 +-
 dbms/src/DataStreams/RemoteBlockInputStream.cpp | 2 +-
 dbms/src/Server/TCPHandler.cpp                  | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/dbms/src/Client/MultiplexedConnections.h b/dbms/src/Client/MultiplexedConnections.h
index 1765741c649..817a37b1d93 100644
--- a/dbms/src/Client/MultiplexedConnections.h
+++ b/dbms/src/Client/MultiplexedConnections.h
@@ -43,7 +43,7 @@ public:
     /// Get packet from any replica.
     Connection::Packet receivePacket();
 
-    /// Get information about the last received package.
+    /// Get information about the last received packet.
     BlockExtraInfo getBlockExtraInfo() const;
 
     /// Break all active connections.
diff --git a/dbms/src/DataStreams/RemoteBlockInputStream.cpp b/dbms/src/DataStreams/RemoteBlockInputStream.cpp
index c20b0e7a60a..4d60d9ae5fd 100644
--- a/dbms/src/DataStreams/RemoteBlockInputStream.cpp
+++ b/dbms/src/DataStreams/RemoteBlockInputStream.cpp
@@ -236,7 +236,7 @@ void RemoteBlockInputStream::readSuffixImpl()
     /// Send the request to abort the execution of the request, if not already sent.
     tryCancel("Cancelling query because enough data has been read");
 
-    /// Get the remaining packages so that there is no out of sync in the connections to the replicas.
+    /// Get the remaining packets so that there is no out of sync in the connections to the replicas.
     Connection::Packet packet = multiplexed_connections->drain();
     switch (packet.type)
     {
diff --git a/dbms/src/Server/TCPHandler.cpp b/dbms/src/Server/TCPHandler.cpp
index 011454a5159..7ca2a1cbf8b 100644
--- a/dbms/src/Server/TCPHandler.cpp
+++ b/dbms/src/Server/TCPHandler.cpp
@@ -315,7 +315,7 @@ void TCPHandler::processOrdinaryQuery()
             {
                 if (isQueryCancelled())
                 {
-        /// A package was received requesting to stop execution of the request.
+                    /// A packet was received requesting to stop execution of the request.
                     async_in.cancel();
                     break;
                 }

From 98ad6a5db3239ac6567ee96e90973b935dcac39b Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 10 Sep 2017 05:30:45 +0300
Subject: [PATCH 172/266] Simplification [#CLICKHOUSE-2].

---
 .../AsynchronousBlockInputStream.h            | 42 ++++++++-----------
 1 file changed, 17 insertions(+), 25 deletions(-)

diff --git a/dbms/src/DataStreams/AsynchronousBlockInputStream.h b/dbms/src/DataStreams/AsynchronousBlockInputStream.h
index e72b2f6489f..cd4116a8325 100644
--- a/dbms/src/DataStreams/AsynchronousBlockInputStream.h
+++ b/dbms/src/DataStreams/AsynchronousBlockInputStream.h
@@ -57,10 +57,7 @@ public:
         if (started)
         {
             pool.wait();
-            if (exception)
-                std::rethrow_exception(exception);
             children.back()->readSuffix();
-            started = false;
         }
     }
 
@@ -82,18 +79,23 @@ public:
 
     ~AsynchronousBlockInputStream() override
     {
-        if (started)
-            pool.wait();
+        try
+        {
+            pool.wait();    /// It's ok to call wait even if there is no active threads.
+        }
+        catch (...)
+        {
+            tryLogCurrentException(__PRETTY_FUNCTION__);
+        }
     }
 
 protected:
-    ThreadPool pool{1};
+    ThreadPool pool{1}; /// Rethrows exceptions automatically on wait.
     Poco::Event ready;
     bool started = false;
     bool first = true;
 
     Block block;
-    std::exception_ptr exception;
 
 
     Block readImpl() override
@@ -101,15 +103,12 @@ protected:
         /// If there were no calculations yet, calculate the first block synchronously
         if (!started)
         {
-            calculate(current_memory_tracker);
             started = true;
+            calculate(current_memory_tracker);
         }
         else    /// If the calculations are already in progress - wait for the result
             pool.wait();
 
-        if (exception)
-            std::rethrow_exception(exception);
-
         Block res = block;
         if (!res)
             return res;
@@ -134,22 +133,15 @@ protected:
     {
         CurrentMetrics::Increment metric_increment{CurrentMetrics::QueryThread};
 
-        try
+        if (first)
         {
-            if (first)
-            {
-                first = false;
-                setThreadName("AsyncBlockInput");
-                current_memory_tracker = memory_tracker;
-                children.back()->readPrefix();
-            }
+            first = false;
+            setThreadName("AsyncBlockInput");
+            current_memory_tracker = memory_tracker;
+            children.back()->readPrefix();
+        }
 
-            block = children.back()->read();
-        }
-        catch (...)
-        {
-            exception = std::current_exception();
-        }
+        block = children.back()->read();
 
         ready.set();
     }

From 2c424c7989dd9143ee460805ed949791b6a75d7e Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 10 Sep 2017 06:17:05 +0300
Subject: [PATCH 173/266] Added description of possible race condition
 [#CLICKHOUSE-2].

---
 dbms/src/DataStreams/LazyBlockInputStream.h | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/dbms/src/DataStreams/LazyBlockInputStream.h b/dbms/src/DataStreams/LazyBlockInputStream.h
index 8229bedcf65..8cf4f3a293d 100644
--- a/dbms/src/DataStreams/LazyBlockInputStream.h
+++ b/dbms/src/DataStreams/LazyBlockInputStream.h
@@ -60,6 +60,23 @@ protected:
             {
                 std::lock_guard<std::mutex> lock(cancel_mutex);
 
+                /** TODO Data race here. See IProfilingBlockInputStream::collectAndSendTotalRowsApprox.
+                    Assume following pipeline:
+
+                    RemoteBlockInputStream
+                     AsynchronousBlockInputStream
+                      LazyBlockInputStream
+
+                    RemoteBlockInputStream calls AsynchronousBlockInputStream::readPrefix
+                     and AsynchronousBlockInputStream spawns a thread and returns.
+
+                    The separate thread will call LazyBlockInputStream::read
+                     LazyBlockInputStream::read will add more children to itself
+
+                    In the same moment, in main thread, RemoteBlockInputStream::read is called,
+                     then IProfilingBlockInputStream::collectAndSendTotalRowsApprox is called
+                     and iterates over set of children.
+                  */
                 children.push_back(input);
 
                 if (isCancelled() && p_input)

From 02a0317db635c264d2df1228a4af39f963d34b5d Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 10 Sep 2017 06:29:40 +0300
Subject: [PATCH 174/266] Updated instruction of installation of clang: added
 useful tool [#CLICKHOUSE-2].

---
 utils/prepare-environment/install-clang.sh | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/utils/prepare-environment/install-clang.sh b/utils/prepare-environment/install-clang.sh
index d1ca427ad4e..b58e0d8f20a 100755
--- a/utils/prepare-environment/install-clang.sh
+++ b/utils/prepare-environment/install-clang.sh
@@ -9,20 +9,29 @@ THREADS=$(grep -c ^processor /proc/cpuinfo)
 
 cd ~
 sudo apt-get install -y subversion cmake3
+
 mkdir llvm
 cd llvm
 svn co "http://llvm.org/svn/llvm-project/llvm/${BRANCH}" llvm
+
 cd llvm/tools
 svn co "http://llvm.org/svn/llvm-project/cfe/${BRANCH}" clang
 svn co "http://llvm.org/svn/llvm-project/lld/${BRANCH}" lld
 svn co "http://llvm.org/svn/llvm-project/polly/${BRANCH}" polly
+
 cd clang/tools
 svn co "http://llvm.org/svn/llvm-project/clang-tools-extra/${BRANCH}" extra
+
+git clone https://github.com/include-what-you-use/include-what-you-use.git
+echo 'add_subdirectory(include-what-you-use)' >> CMakeLists.txt
+sudo apt-get install libncurses5-dev
+
 cd ../../../..
 cd llvm/projects/
 svn co "http://llvm.org/svn/llvm-project/compiler-rt/${BRANCH}" compiler-rt
 svn co "http://llvm.org/svn/llvm-project/libcxx/${BRANCH}" libcxx
 svn co "http://llvm.org/svn/llvm-project/libcxxabi/${BRANCH}" libcxxabi
+
 cd ../..
 mkdir build
 cd build/

From 7405dd57423836580035be774b9578a79b1605e0 Mon Sep 17 00:00:00 2001
From: Bulat Gaifullin <b.gaifullin@corp.mail.ru>
Date: Sun, 10 Sep 2017 00:26:02 +0300
Subject: [PATCH 175/266] Add ssl options for MySQL connection  #1217

---
 libs/libmysqlxx/include/mysqlxx/Connection.h | 28 +++++++++++-
 libs/libmysqlxx/include/mysqlxx/Pool.h       |  3 ++
 libs/libmysqlxx/src/Connection.cpp           | 18 +++++++-
 libs/libmysqlxx/src/Pool.cpp                 | 46 ++++++++++++++------
 4 files changed, 78 insertions(+), 17 deletions(-)

diff --git a/libs/libmysqlxx/include/mysqlxx/Connection.h b/libs/libmysqlxx/include/mysqlxx/Connection.h
index c704faa3212..93efb7d7002 100644
--- a/libs/libmysqlxx/include/mysqlxx/Connection.h
+++ b/libs/libmysqlxx/include/mysqlxx/Connection.h
@@ -43,6 +43,12 @@ private:
   * Or using socket:
   *        mysqlxx::Connection connection("Test", "localhost", "root", "qwerty", 0, "/path/to/socket/file.sock");
   *
+  * Or using custom certificate authority file:
+  *        mysqlxx::Connection connection("Test", "localhost", "root", "qwerty", 3306, "/path/to/ca/file.pem");
+  *
+  * Or using custom certificate and key file:
+  *        mysqlxx::Connection connection("Test", "localhost", "root", "qwerty", 3306, "", "/path/to/cert/file.pem", "/path/to/key/file.pem");
+  *
   * Attention! It's strictly recommended to use connection in thread where it was created.
   * In order to use connection in other thread, you should call MySQL C API function mysql_thread_init() before and
   * mysql_thread_end() after working with it.
@@ -62,6 +68,9 @@ public:
         const char * password = 0,
         unsigned port = 0,
         const char * socket = "",
+        const char * ssl_ca = "",
+        const char * ssl_cert = "",
+        const char * ssl_key = "",
         unsigned timeout = MYSQLXX_DEFAULT_TIMEOUT,
         unsigned rw_timeout = MYSQLXX_DEFAULT_RW_TIMEOUT);
 
@@ -78,6 +87,9 @@ public:
         const char * password,
         unsigned port,
         const char * socket,
+        const char* ssl_ca,
+        const char* ssl_cert,
+        const char* ssl_key,
         unsigned timeout = MYSQLXX_DEFAULT_TIMEOUT,
         unsigned rw_timeout = MYSQLXX_DEFAULT_RW_TIMEOUT);
 
@@ -91,6 +103,9 @@ public:
         std::string password = cfg.getString(config_name + ".password");
         unsigned port = cfg.getInt(config_name + ".port", 0);
         std::string socket = cfg.getString(config_name + ".socket", "");
+        std::string ssl_ca = cfg.getString(config_name + ".ssl_ca", "");
+        std::string ssl_cert = cfg.getString(config_name + ".ssl_cert", "");
+        std::string ssl_key = cfg.getString(config_name + ".ssl_key", "");
 
         unsigned timeout =
             cfg.getInt(config_name + ".connect_timeout",
@@ -102,7 +117,18 @@ public:
                 cfg.getInt("mysql_rw_timeout",
                     MYSQLXX_DEFAULT_RW_TIMEOUT));
 
-        connect(db.c_str(), server.c_str(), user.c_str(), password.c_str(), port, socket.c_str(), timeout, rw_timeout);
+        connect(
+                db.c_str(),
+                server.c_str(),
+                user.c_str(),
+                password.c_str(),
+                port,
+                socket.c_str(),
+                ssl_ca.c_str(),
+                ssl_cert.c_str(),
+                ssl_key.c_str(),
+                timeout,
+                rw_timeout);
     }
 
     /// If MySQL connection was established.
diff --git a/libs/libmysqlxx/include/mysqlxx/Pool.h b/libs/libmysqlxx/include/mysqlxx/Pool.h
index 88921735355..d3ab7044cde 100644
--- a/libs/libmysqlxx/include/mysqlxx/Pool.h
+++ b/libs/libmysqlxx/include/mysqlxx/Pool.h
@@ -231,6 +231,9 @@ private:
     std::string socket;
     unsigned connect_timeout;
     unsigned rw_timeout;
+    std::string ssl_ca;
+    std::string ssl_cert;
+    std::string ssl_key;
 
     /// True if connection was established at least once.
     bool was_successful{false};
diff --git a/libs/libmysqlxx/src/Connection.cpp b/libs/libmysqlxx/src/Connection.cpp
index f76ce3d473a..8d8bcb57fc3 100644
--- a/libs/libmysqlxx/src/Connection.cpp
+++ b/libs/libmysqlxx/src/Connection.cpp
@@ -3,6 +3,10 @@
 #include <mysqlxx/Connection.h>
 #include <mysqlxx/Exception.h>
 
+static inline const char* ifNotEmpty(const char* s)
+{
+    return s && *s ? s : nullptr;
+}
 
 namespace mysqlxx
 {
@@ -35,12 +39,15 @@ Connection::Connection(
     const char* password,
     unsigned port,
     const char * socket,
+    const char* ssl_ca,
+    const char* ssl_cert,
+    const char* ssl_key,
     unsigned timeout,
     unsigned rw_timeout)
     : driver(std::make_unique<MYSQL>())
 {
     is_connected = false;
-    connect(db, server, user, password, port, socket, timeout, rw_timeout);
+    connect(db, server, user, password, port, socket, ssl_ca, ssl_cert, ssl_key, timeout, rw_timeout);
 }
 
 Connection::Connection(const std::string & config_name)
@@ -62,6 +69,9 @@ void Connection::connect(const char* db,
     const char* password,
     unsigned port,
     const char * socket,
+    const char* ssl_ca,
+    const char* ssl_cert,
+    const char* ssl_key,
     unsigned timeout,
     unsigned rw_timeout)
 {
@@ -88,7 +98,11 @@ void Connection::connect(const char* db,
     if (mysql_options(driver.get(), MYSQL_OPT_LOCAL_INFILE, nullptr))
         throw ConnectionFailed(errorMessage(driver.get()), mysql_errno(driver.get()));
 
-    if (!mysql_real_connect(driver.get(), server, user, password, db, port, *socket ? socket : nullptr, driver->client_flag))
+    /// Specifies particular ssl key and certificate if it needs
+    if (mysql_ssl_set(driver.get(), ifNotEmpty(ssl_key), ifNotEmpty(ssl_cert), ifNotEmpty(ssl_ca), nullptr, nullptr))
+        throw ConnectionFailed(errorMessage(driver.get()), mysql_errno(driver.get()));
+
+    if (!mysql_real_connect(driver.get(), server, user, password, db, port, ifNotEmpty(socket), driver->client_flag))
         throw ConnectionFailed(errorMessage(driver.get()), mysql_errno(driver.get()));
 
     /// Sets UTF-8 as default encoding.
diff --git a/libs/libmysqlxx/src/Pool.cpp b/libs/libmysqlxx/src/Pool.cpp
index b2217caf6fa..23d231e1aae 100644
--- a/libs/libmysqlxx/src/Pool.cpp
+++ b/libs/libmysqlxx/src/Pool.cpp
@@ -56,6 +56,15 @@ Pool::Pool(const Poco::Util::AbstractConfiguration & cfg, const std::string & co
         socket = cfg.has(config_name + ".socket")
             ? cfg.getString(config_name + ".socket")
             : cfg.getString(parent_config_name + ".socket", "");
+        ssl_ca = cfg.has(config_name + ".ssl_ca")
+            ? cfg.getString(config_name + ".ssl_ca")
+            : cfg.getString(parent_config_name + ".ssl_ca", "");
+        ssl_cert = cfg.has(config_name + ".ssl_cert")
+            ? cfg.getString(config_name + ".ssl_cert")
+            : cfg.getString(parent_config_name + ".ssl_cert", "");
+        ssl_key = cfg.has(config_name + ".ssl_key")
+            ? cfg.getString(config_name + ".ssl_key")
+            : cfg.getString(parent_config_name + ".ssl_key", "");
     }
     else
     {
@@ -68,6 +77,9 @@ Pool::Pool(const Poco::Util::AbstractConfiguration & cfg, const std::string & co
 
         port = cfg.getInt(config_name + ".port", 0);
         socket = cfg.getString(config_name + ".socket", "");
+        ssl_ca = cfg.getString(config_name + ".ssl_ca", "");
+        ssl_cert = cfg.getString(config_name + ".ssl_cert", "");
+        ssl_key = cfg.getString(config_name + ".ssl_key", "");
     }
 
     connect_timeout = cfg.getInt(config_name + ".connect_timeout",
@@ -167,13 +179,16 @@ void Pool::Entry::forceConnected() const
         app.logger().information("MYSQL: Reconnecting to " + pool->description);
         data->conn.connect(
             pool->db.c_str(),
-                           pool->server.c_str(),
-                           pool->user.c_str(),
-                           pool->password.c_str(),
-                           pool->port,
-                           pool->socket.c_str(),
-                     pool->connect_timeout,
-                     pool->rw_timeout);
+            pool->server.c_str(),
+            pool->user.c_str(),
+            pool->password.c_str(),
+            pool->port,
+            pool->socket.c_str(),
+            pool->ssl_ca.c_str(),
+            pool->ssl_cert.c_str(),
+            pool->ssl_key.c_str(),
+            pool->connect_timeout,
+            pool->rw_timeout);
     }
     while (!data->conn.ping());
 }
@@ -205,13 +220,16 @@ Pool::Connection * Pool::allocConnection(bool dont_throw_if_failed_first_time)
 
         conn->conn.connect(
             db.c_str(),
-                           server.c_str(),
-                           user.c_str(),
-                           password.c_str(),
-                           port,
-                           socket.c_str(),
-                     connect_timeout,
-                     rw_timeout);
+            server.c_str(),
+            user.c_str(),
+            password.c_str(),
+            port,
+            socket.c_str(),
+            ssl_ca.c_str(),
+            ssl_cert.c_str(),
+            ssl_key.c_str(),
+            connect_timeout,
+            rw_timeout);
     }
     catch (mysqlxx::ConnectionFailed & e)
     {

From fabfed6f22811084b041bbf06dc1428655c4f7f9 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 10 Sep 2017 09:51:27 +0300
Subject: [PATCH 176/266] Added support for "include-what-you-use" tool
 [#CLICKHOUSE-2].

---
 CMakeLists.txt      | 12 ++++++++++++
 dbms/CMakeLists.txt |  4 ++++
 2 files changed, 16 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 87c4ef63e65..69b20377459 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -156,6 +156,18 @@ set (CMAKE_C_FLAGS_MSAN                  "${CMAKE_C_FLAGS_MSAN}    ${SAN_FLAGS}
 set (CMAKE_CXX_FLAGS_TSAN                "${CMAKE_CXX_FLAGS_TSAN}  ${SAN_FLAGS} -fsanitize=thread")
 set (CMAKE_C_FLAGS_TSAN                  "${CMAKE_C_FLAGS_TSAN}    ${SAN_FLAGS} -fsanitize=thread")
 
+# Using "include-what-you-use" tool.
+option (USE_INCLUDE_WHAT_YOU_USE "Use 'include-what-you-use' tool" OFF)
+if (USE_INCLUDE_WHAT_YOU_USE)
+    find_program(IWYU_PATH NAMES include-what-you-use iwyu)
+    if (NOT IWYU_PATH)
+        message(FATAL_ERROR "Could not find the program include-what-you-use")
+    endif()
+    if (${CMAKE_VERSION} VERSION_LESS "3.3.0")
+        message(FATAL_ERROR "include-what-you-use requires CMake version at least 3.3.")
+    endif()
+endif ()
+
 # Flags for test coverage
 if (TEST_COVERAGE)
     set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fprofile-arcs -ftest-coverage -DIS_DEBUG")
diff --git a/dbms/CMakeLists.txt b/dbms/CMakeLists.txt
index dbf23edc479..6ae88e0df3e 100644
--- a/dbms/CMakeLists.txt
+++ b/dbms/CMakeLists.txt
@@ -1,3 +1,7 @@
+if (USE_INCLUDE_WHAT_YOU_USE)
+    set (CMAKE_CXX_INCLUDE_WHAT_YOU_USE ${IWYU_PATH})
+endif ()
+
 include(${CMAKE_CURRENT_SOURCE_DIR}/cmake/find_vectorclass.cmake)
 
 set (CONFIG_VERSION ${CMAKE_CURRENT_BINARY_DIR}/src/Common/config_version.h)

From 104c6d9ddf41ba0c8c6d16353ec7ccc469992380 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Mon, 11 Sep 2017 08:33:36 +0300
Subject: [PATCH 177/266] Fixed warning in Poco [#CLICKHOUSE-2].

---
 contrib/libpoco/MongoDB/include/Poco/MongoDB/Element.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contrib/libpoco/MongoDB/include/Poco/MongoDB/Element.h b/contrib/libpoco/MongoDB/include/Poco/MongoDB/Element.h
index d2aff4a1caa..258e0e8b494 100644
--- a/contrib/libpoco/MongoDB/include/Poco/MongoDB/Element.h
+++ b/contrib/libpoco/MongoDB/include/Poco/MongoDB/Element.h
@@ -79,7 +79,7 @@ inline std::string Element::name() const
 class ElementComparator
 {
 public:
-	bool operator()(const Element::Ptr& s1, const Element::Ptr& s2)
+	bool operator()(const Element::Ptr& s1, const Element::Ptr& s2) const
 	{
 		return s1->name() < s2->name();
 	}

From 9cafeb9e85ce094969e79ce46b85233bc682de4f Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Mon, 11 Sep 2017 08:51:15 +0300
Subject: [PATCH 178/266] Fixed not-an-issue found by Coverity [#CLICKHOUSE-2].

---
 dbms/src/IO/WriteBufferFromString.h | 2 +-
 dbms/src/IO/WriteBufferFromVector.h | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/dbms/src/IO/WriteBufferFromString.h b/dbms/src/IO/WriteBufferFromString.h
index 9545562669f..fe1be32266f 100644
--- a/dbms/src/IO/WriteBufferFromString.h
+++ b/dbms/src/IO/WriteBufferFromString.h
@@ -22,7 +22,7 @@ private:
     {
         size_t old_size = s.size();
         s.resize(old_size * 2);
-        internal_buffer = Buffer(reinterpret_cast<Position>(&s[old_size]), reinterpret_cast<Position>(&*s.end()));
+        internal_buffer = Buffer(reinterpret_cast<Position>(&s[old_size]), reinterpret_cast<Position>(&s[s.size()]));
         working_buffer = internal_buffer;
     }
 
diff --git a/dbms/src/IO/WriteBufferFromVector.h b/dbms/src/IO/WriteBufferFromVector.h
index bea92121bfe..3c5ed53889c 100644
--- a/dbms/src/IO/WriteBufferFromVector.h
+++ b/dbms/src/IO/WriteBufferFromVector.h
@@ -24,7 +24,7 @@ private:
     {
         size_t old_size = vector.size();
         vector.resize(old_size * 2);
-        internal_buffer = Buffer(reinterpret_cast<Position>(&vector[old_size]), reinterpret_cast<Position>(&*vector.end()));
+        internal_buffer = Buffer(reinterpret_cast<Position>(&vector[old_size]), reinterpret_cast<Position>(vector.data() + vector.size()));
         working_buffer = internal_buffer;
     }
 

From 7576cb2c186c2d47b895185d621d2154953d238d Mon Sep 17 00:00:00 2001
From: Vadim Skipin <vskipin@yandex-team.ru>
Date: Mon, 11 Sep 2017 13:23:13 +0300
Subject: [PATCH 179/266] fix LRU cache definition

---
 dbms/src/Common/LRUCache.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbms/src/Common/LRUCache.h b/dbms/src/Common/LRUCache.h
index 4899d8f35e7..5b296da1959 100644
--- a/dbms/src/Common/LRUCache.h
+++ b/dbms/src/Common/LRUCache.h
@@ -29,7 +29,7 @@ struct TrivialWeightFunction
 /// Cache starts to evict entries when their total weight exceeds max_size and when expiration time of these
 /// entries is due.
 /// Value weight should not change after insertion.
-template <typename TKey, typename TMapped, typename HashFunction = std::hash<TMapped>, typename WeightFunction = TrivialWeightFunction<TMapped>>
+template <typename TKey, typename TMapped, typename HashFunction = std::hash<TKey>, typename WeightFunction = TrivialWeightFunction<TMapped>>
 class LRUCache
 {
 public:

From 06c7d4315fa8492de260a3b359bdc3abcf9efab0 Mon Sep 17 00:00:00 2001
From: proller <proller@users.noreply.github.com>
Date: Mon, 11 Sep 2017 18:51:32 +0300
Subject: [PATCH 180/266] Cmake fixes (#CLICKHOUSE-3303) (#1229)

* Cmake fixes (#CLICKHOUSE-3303)
---
 CMakeLists.txt          | 5 +++--
 cmake/find_ccache.cmake | 3 +--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 69b20377459..3e0fe38e84a 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -36,6 +36,7 @@ if (NOT CMAKE_BUILD_TYPE OR CMAKE_BUILD_TYPE STREQUAL "None")
     message (STATUS "CMAKE_BUILD_TYPE is not set, set to default = RELWITHDEBINFO")
     set (CMAKE_BUILD_TYPE "RELWITHDEBINFO")
 endif ()
+string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE_UC)
 message (STATUS "CMAKE_BUILD_TYPE: " ${CMAKE_BUILD_TYPE} )
 
 # ASan - build type with address sanitizer
@@ -234,8 +235,8 @@ include (libs/libmysqlxx/cmake/find_mysqlclient.cmake)
 include (libs/libdaemon/cmake/find_unwind.cmake)
 
 
-set (FULL_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE}}")
-set (FULL_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE}}")
+set (FULL_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE_UC}}")
+set (FULL_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UC}}")
 message (STATUS "C_FLAGS    = ${FULL_C_FLAGS}")
 message (STATUS "CXX_FLAGS  = ${FULL_CXX_FLAGS}")
 message (STATUS "LINK_FLAGS = ${CMAKE_EXE_LINKER_FLAGS}")
diff --git a/cmake/find_ccache.cmake b/cmake/find_ccache.cmake
index 926002a44ae..22372c3cbfe 100644
--- a/cmake/find_ccache.cmake
+++ b/cmake/find_ccache.cmake
@@ -3,9 +3,8 @@ find_program (CCACHE_FOUND ccache)
 if (CCACHE_FOUND AND NOT CMAKE_CXX_COMPILER_LAUNCHER MATCHES "ccache" AND NOT CMAKE_CXX_COMPILER MATCHES "ccache")
     execute_process(COMMAND ${CCACHE_FOUND} "-V" OUTPUT_VARIABLE CCACHE_VERSION)
     string(REGEX REPLACE "ccache version ([0-9\\.]+).*" "\\1" CCACHE_VERSION ${CCACHE_VERSION} )
-    string(COMPARE GREATER ${CCACHE_VERSION} "3.2.0" CCACHE_VERSION_OK)
 
-    if (CCACHE_VERSION_OK OR NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    if (CCACHE_VERSION VERSION_GREATER "3.2.0" OR NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
        #message(STATUS "Using ${CCACHE_FOUND} ${CCACHE_VERSION}")
        set_property (GLOBAL PROPERTY RULE_LAUNCH_COMPILE ${CCACHE_FOUND})
        set_property (GLOBAL PROPERTY RULE_LAUNCH_LINK ${CCACHE_FOUND})

From 9ab64b4706c4f1abc2c9273a4da788026614f5ec Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Mon, 11 Sep 2017 21:03:32 +0300
Subject: [PATCH 181/266] Added link to Go library by Denis Korolev
 [#CLICKHOUSE-3].

---
 docs/en/interfaces/third-party_client_libraries.rst | 3 ++-
 docs/ru/interfaces/third-party_client_libraries.rst | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/docs/en/interfaces/third-party_client_libraries.rst b/docs/en/interfaces/third-party_client_libraries.rst
index 6d32eab73da..9cacf91f555 100644
--- a/docs/en/interfaces/third-party_client_libraries.rst
+++ b/docs/en/interfaces/third-party_client_libraries.rst
@@ -12,9 +12,10 @@ There exist third-party client libraries for ClickHouse:
     - `PhpClickHouseClient <https://github.com/SevaCode/PhpClickHouseClient>`_
     - `phpClickHouse <https://github.com/smi2/phpClickHouse>`_
 * Go
-    - `clickhouse (Go) <https://github.com/kshvakov/clickhouse/>`_
+    - `clickhouse <https://github.com/kshvakov/clickhouse/>`_
     - `go-clickhouse <https://github.com/roistat/go-clickhouse>`_
     - `mailru\go-clickhouse <https://github.com/mailru/go-clickhouse>`_
+    - `golang-clickhouse <https://github.com/leprosus/golang-clickhouse>`_
 * NodeJs
     - `clickhouse (NodeJs) <https://github.com/TimonKK/clickhouse>`_
     - `node-clickhouse <https://github.com/apla/node-clickhouse>`_
diff --git a/docs/ru/interfaces/third-party_client_libraries.rst b/docs/ru/interfaces/third-party_client_libraries.rst
index 6c8a0f09359..9757af0f712 100644
--- a/docs/ru/interfaces/third-party_client_libraries.rst
+++ b/docs/ru/interfaces/third-party_client_libraries.rst
@@ -12,9 +12,10 @@
     - `PhpClickHouseClient <https://github.com/SevaCode/PhpClickHouseClient>`_
     - `phpClickHouse <https://github.com/smi2/phpClickHouse>`_
 * Go
-    - `clickhouse (Go) <https://github.com/kshvakov/clickhouse/>`_
+    - `clickhouse <https://github.com/kshvakov/clickhouse/>`_
     - `go-clickhouse <https://github.com/roistat/go-clickhouse>`_
     - `mailru\go-clickhouse <https://github.com/mailru/go-clickhouse>`_
+    - `golang-clickhouse <https://github.com/leprosus/golang-clickhouse>`_
 * NodeJs
     - `clickhouse (NodeJs) <https://github.com/TimonKK/clickhouse>`_
     - `node-clickhouse <https://github.com/apla/node-clickhouse>`_

From 5054d503070a04dc172053516da2f26eb82121c1 Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Mon, 11 Sep 2017 20:22:43 +0300
Subject: [PATCH 182/266] Remove too noisy message (#CLICKHOUSE-3304)

---
 dbms/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp
index dc24c934baf..9f0a4498762 100644
--- a/dbms/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp
+++ b/dbms/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp
@@ -532,8 +532,6 @@ bool ReplicatedMergeTreeQueue::isNotCoveredByFuturePartsImpl(const String & new_
 
         if (future_part.contains(result_part))
         {
-            out_reason = "Not executing log entry for part " + new_part_name
-                + " because another log entry for covering part " + future_part_name + " is being processed.";
             return false;
         }
     }

From e0a1e6982b9f1962b1443186974a1164b0f143d6 Mon Sep 17 00:00:00 2001
From: Vadim Skipin <vskipin@yandex-team.ru>
Date: Mon, 11 Sep 2017 15:39:01 +0300
Subject: [PATCH 183/266] Context parameter added to the IDatabase methods

---
 dbms/src/Databases/DatabaseDictionary.cpp     | 69 +++++++------
 dbms/src/Databases/DatabaseDictionary.h       | 70 ++++++++-----
 dbms/src/Databases/DatabaseMemory.cpp         | 99 ++++++++++++-------
 dbms/src/Databases/DatabaseMemory.h           | 51 +++++++---
 dbms/src/Databases/DatabaseOrdinary.cpp       | 47 ++++++---
 dbms/src/Databases/DatabaseOrdinary.h         | 38 ++++---
 dbms/src/Databases/IDatabase.h                | 44 ++++++---
 dbms/src/Interpreters/AsynchronousMetrics.cpp |  2 +-
 dbms/src/Interpreters/Context.cpp             | 12 +--
 .../Interpreters/InterpreterCreateQuery.cpp   |  2 +-
 .../src/Interpreters/InterpreterDropQuery.cpp |  6 +-
 .../Interpreters/InterpreterRenameQuery.cpp   |  2 +-
 dbms/src/Server/ReplicasStatusHandler.cpp     |  2 +-
 dbms/src/Storages/StorageMerge.cpp            |  4 +-
 .../Storages/System/StorageSystemColumns.cpp  |  2 +-
 .../Storages/System/StorageSystemParts.cpp    |  2 +-
 .../Storages/System/StorageSystemReplicas.cpp |  2 +-
 .../System/StorageSystemReplicationQueue.cpp  |  2 +-
 .../Storages/System/StorageSystemTables.cpp   |  4 +-
 .../src/TableFunctions/TableFunctionMerge.cpp |  2 +-
 20 files changed, 301 insertions(+), 161 deletions(-)

diff --git a/dbms/src/Databases/DatabaseDictionary.cpp b/dbms/src/Databases/DatabaseDictionary.cpp
index 5c32988845e..f0ca52ad6fc 100644
--- a/dbms/src/Databases/DatabaseDictionary.cpp
+++ b/dbms/src/Databases/DatabaseDictionary.cpp
@@ -46,13 +46,17 @@ Tables DatabaseDictionary::loadTables()
     return tables;
 }
 
-bool DatabaseDictionary::isTableExist(const String & table_name) const
+bool DatabaseDictionary::isTableExist(
+    const Context & context,
+    const String & table_name) const
 {
     const std::lock_guard<std::mutex> lock_dictionaries {external_dictionaries.dictionaries_mutex};
     return external_dictionaries.dictionaries.count(table_name) && !deleted_tables.count(table_name);
 }
 
-StoragePtr DatabaseDictionary::tryGetTable(const String & table_name)
+StoragePtr DatabaseDictionary::tryGetTable(
+    const Context & context,
+    const String & table_name)
 {
     const std::lock_guard<std::mutex> lock_dictionaries {external_dictionaries.dictionaries_mutex};
 
@@ -75,12 +79,12 @@ StoragePtr DatabaseDictionary::tryGetTable(const String & table_name)
     return {};
 }
 
-DatabaseIteratorPtr DatabaseDictionary::getIterator()
+DatabaseIteratorPtr DatabaseDictionary::getIterator(const Context & context)
 {
     return std::make_unique<DatabaseSnaphotIterator>(loadTables());
 }
 
-bool DatabaseDictionary::empty() const
+bool DatabaseDictionary::empty(const Context & context) const
 {
     const std::lock_guard<std::mutex> lock_dictionaries {external_dictionaries.dictionaries_mutex};
     for (const auto & pair : external_dictionaries.dictionaries)
@@ -99,39 +103,58 @@ void DatabaseDictionary::attachTable(const String & table_name, const StoragePtr
     throw Exception("DatabaseDictionary: attachTable() is not supported", ErrorCodes::NOT_IMPLEMENTED);
 }
 
-void DatabaseDictionary::createTable(const String & table_name,
-                                     const StoragePtr & table,
-                                     const ASTPtr & query,
-                                     const String & engine,
-                                     const Settings & settings)
+void DatabaseDictionary::createTable(
+    const Context & context,
+    const String & table_name,
+    const StoragePtr & table,
+    const ASTPtr & query,
+    const String & engine)
 {
     throw Exception("DatabaseDictionary: createTable() is not supported", ErrorCodes::NOT_IMPLEMENTED);
 }
 
-void DatabaseDictionary::removeTable(const String & table_name)
+void DatabaseDictionary::removeTable(
+    const Context & context,
+    const String & table_name)
 {
-    if (!isTableExist(table_name))
+    if (!isTableExist(context, table_name))
         throw Exception("Table " + name + "." + table_name + " doesn't exist.", ErrorCodes::UNKNOWN_TABLE);
 
     const std::lock_guard<std::mutex> lock_dictionaries {external_dictionaries.dictionaries_mutex};
     deleted_tables.insert(table_name);
 }
 
-void DatabaseDictionary::renameTable(const Context & context,
-                                     const String & table_name,
-                                     IDatabase & to_database,
-                                     const String & to_table_name,
-                                     const Settings & settings)
+void DatabaseDictionary::renameTable(
+    const Context & context,
+    const String & table_name,
+    IDatabase & to_database,
+    const String & to_table_name)
 {
     throw Exception("DatabaseDictionary: renameTable() is not supported", ErrorCodes::NOT_IMPLEMENTED);
 }
 
-time_t DatabaseDictionary::getTableMetadataModificationTime(const String & table_name)
+void DatabaseDictionary::alterTable(
+    const Context & context,
+    const String & name,
+    const NamesAndTypesList & columns,
+    const NamesAndTypesList & materialized_columns,
+    const NamesAndTypesList & alias_columns,
+    const ColumnDefaults & column_defaults,
+    const ASTModifier & engine_modifier)
+{
+    throw Exception("DatabaseDictionary: alterTable() is not supported", ErrorCodes::NOT_IMPLEMENTED);
+}
+
+time_t DatabaseDictionary::getTableMetadataModificationTime(
+    const Context & context,
+    const String & table_name)
 {
     return static_cast<time_t>(0);
 }
 
-ASTPtr DatabaseDictionary::getCreateQuery(const String & table_name) const
+ASTPtr DatabaseDictionary::getCreateQuery(
+    const Context & context,
+    const String & table_name) const
 {
     throw Exception("DatabaseDictionary: getCreateQuery() is not supported", ErrorCodes::NOT_IMPLEMENTED);
     return nullptr;
@@ -146,14 +169,4 @@ void DatabaseDictionary::drop()
     /// Additional actions to delete database are not required.
 }
 
-void DatabaseDictionary::alterTable(const Context & context,
-                                    const String & name,
-                                    const NamesAndTypesList & columns,
-                                    const NamesAndTypesList & materialized_columns,
-                                    const NamesAndTypesList & alias_columns,
-                                    const ColumnDefaults & column_defaults,
-                                    const ASTModifier & engine_modifier)
-{
-    throw Exception("DatabaseDictionary: alterTable() is not supported", ErrorCodes::NOT_IMPLEMENTED);
-}
 }
diff --git a/dbms/src/Databases/DatabaseDictionary.h b/dbms/src/Databases/DatabaseDictionary.h
index 6dfe4aeed06..fe0e2ffeb93 100644
--- a/dbms/src/Databases/DatabaseDictionary.h
+++ b/dbms/src/Databases/DatabaseDictionary.h
@@ -39,45 +39,63 @@ public:
     {
         return "Dictionary";
     }
-    void loadTables(Context & context, ThreadPool * thread_pool, bool has_force_restore_data_flag) override;
 
-    bool isTableExist(const String & table_name) const override;
-    StoragePtr tryGetTable(const String & table_name) override;
+    void loadTables(
+        Context & context,
+        ThreadPool * thread_pool,
+        bool has_force_restore_data_flag) override;
 
-    DatabaseIteratorPtr getIterator() override;
+    bool isTableExist(
+        const Context & context,
+        const String & table_name) const override;
 
-    bool empty() const override;
+    StoragePtr tryGetTable(
+        const Context & context,
+        const String & table_name) override;
 
-    void createTable(const String & table_name,
-                     const StoragePtr & table,
-                     const ASTPtr & query,
-                     const String & engine,
-                     const Settings & settings) override;
+    DatabaseIteratorPtr getIterator(const Context & context) override;
 
-    void removeTable(const String & table_name) override;
+    bool empty(const Context & context) const override;
+
+    void createTable(
+        const Context & context,
+        const String & table_name,
+        const StoragePtr & table,
+        const ASTPtr & query,
+        const String & engine) override;
+
+    void removeTable(
+        const Context & context,
+        const String & table_name) override;
 
     void attachTable(const String & table_name, const StoragePtr & table) override;
     StoragePtr detachTable(const String & table_name) override;
 
-    void renameTable(const Context & context,
-                     const String & table_name,
-                     IDatabase & to_database,
-                     const String & to_table_name,
-                     const Settings & settings) override;
+    void renameTable(
+        const Context & context,
+        const String & table_name,
+        IDatabase & to_database,
+        const String & to_table_name) override;
 
-    time_t getTableMetadataModificationTime(const String & table_name) override;
+    void alterTable(
+        const Context & context,
+        const String & name,
+        const NamesAndTypesList & columns,
+        const NamesAndTypesList & materialized_columns,
+        const NamesAndTypesList & alias_columns,
+        const ColumnDefaults & column_defaults,
+        const ASTModifier & engine_modifier) override;
 
-    ASTPtr getCreateQuery(const String & table_name) const override;
+    time_t getTableMetadataModificationTime(
+        const Context & context,
+        const String & table_name) override;
+
+    ASTPtr getCreateQuery(
+        const Context & context,
+        const String & table_name) const override;
 
     void shutdown() override;
     void drop() override;
-
-    void alterTable(const Context & context,
-                    const String & name,
-                    const NamesAndTypesList & columns,
-                    const NamesAndTypesList & materialized_columns,
-                    const NamesAndTypesList & alias_columns,
-                    const ColumnDefaults & column_defaults,
-                    const ASTModifier & engine_modifier) override;
 };
+
 }
diff --git a/dbms/src/Databases/DatabaseMemory.cpp b/dbms/src/Databases/DatabaseMemory.cpp
index 2d9ee679d58..aae8f781cde 100644
--- a/dbms/src/Databases/DatabaseMemory.cpp
+++ b/dbms/src/Databases/DatabaseMemory.cpp
@@ -13,20 +13,27 @@ namespace ErrorCodes
     extern const int LOGICAL_ERROR;
 }
 
-void DatabaseMemory::loadTables(Context & context, ThreadPool * thread_pool, bool has_force_restore_data_flag)
+void DatabaseMemory::loadTables(
+    Context & context,
+    ThreadPool * thread_pool,
+    bool has_force_restore_data_flag)
 {
     log = &Logger::get("DatabaseMemory(" + name + ")");
 
     /// Nothing to load.
 }
 
-bool DatabaseMemory::isTableExist(const String & table_name) const
+bool DatabaseMemory::isTableExist(
+    const Context & context,
+    const String & table_name) const
 {
     std::lock_guard<std::mutex> lock(mutex);
     return tables.count(table_name);
 }
 
-StoragePtr DatabaseMemory::tryGetTable(const String & table_name)
+StoragePtr DatabaseMemory::tryGetTable(
+    const Context & context,
+    const String & table_name)
 {
     std::lock_guard<std::mutex> lock(mutex);
     auto it = tables.find(table_name);
@@ -35,13 +42,13 @@ StoragePtr DatabaseMemory::tryGetTable(const String & table_name)
     return it->second;
 }
 
-DatabaseIteratorPtr DatabaseMemory::getIterator()
+DatabaseIteratorPtr DatabaseMemory::getIterator(const Context & context)
 {
     std::lock_guard<std::mutex> lock(mutex);
     return std::make_unique<DatabaseSnaphotIterator>(tables);
 }
 
-bool DatabaseMemory::empty() const
+bool DatabaseMemory::empty(const Context & context) const
 {
     std::lock_guard<std::mutex> lock(mutex);
     return tables.empty();
@@ -70,50 +77,31 @@ void DatabaseMemory::attachTable(const String & table_name, const StoragePtr & t
 }
 
 void DatabaseMemory::createTable(
-    const String & table_name, const StoragePtr & table, const ASTPtr & query, const String & engine, const Settings & settings)
+    const Context & context,
+    const String & table_name,
+    const StoragePtr & table,
+    const ASTPtr & query,
+    const String & engine)
 {
     attachTable(table_name, table);
 }
 
-void DatabaseMemory::removeTable(const String & table_name)
+void DatabaseMemory::removeTable(
+    const Context & context,
+    const String & table_name)
 {
     detachTable(table_name);
 }
 
 void DatabaseMemory::renameTable(
-    const Context & context, const String & table_name, IDatabase & to_database, const String & to_table_name, const Settings & settings)
+    const Context & context,
+    const String & table_name,
+    IDatabase & to_database,
+    const String & to_table_name)
 {
     throw Exception("DatabaseMemory: renameTable() is not supported", ErrorCodes::NOT_IMPLEMENTED);
 }
 
-time_t DatabaseMemory::getTableMetadataModificationTime(const String & table_name)
-{
-    return static_cast<time_t>(0);
-}
-
-ASTPtr DatabaseMemory::getCreateQuery(const String & table_name) const
-{
-    throw Exception("DatabaseMemory: getCreateQuery() is not supported", ErrorCodes::NOT_IMPLEMENTED);
-    return nullptr;
-}
-
-void DatabaseMemory::shutdown()
-{
-    /// You can not hold a lock during shutdown.
-    /// Because inside `shutdown` function tables can work with database, and mutex is not recursive.
-
-    for (auto iterator = getIterator(); iterator->isValid(); iterator->next())
-        iterator->table()->shutdown();
-
-    std::lock_guard<std::mutex> lock(mutex);
-    tables.clear();
-}
-
-void DatabaseMemory::drop()
-{
-    /// Additional actions to delete database are not required.
-}
-
 void DatabaseMemory::alterTable(
     const Context & context,
     const String & name,
@@ -126,4 +114,43 @@ void DatabaseMemory::alterTable(
     throw Exception("DatabaseMemory: alterTable() is not supported", ErrorCodes::NOT_IMPLEMENTED);
 }
 
+time_t DatabaseMemory::getTableMetadataModificationTime(
+    const Context & context,
+    const String & table_name)
+{
+    return static_cast<time_t>(0);
+}
+
+ASTPtr DatabaseMemory::getCreateQuery(
+    const Context & context,
+    const String & table_name) const
+{
+    throw Exception("DatabaseMemory: getCreateQuery() is not supported", ErrorCodes::NOT_IMPLEMENTED);
+    return nullptr;
+}
+
+void DatabaseMemory::shutdown()
+{
+    /// You can not hold a lock during shutdown.
+    /// Because inside `shutdown` function tables can work with database, and mutex is not recursive.
+
+    Tables tables_snapshot;
+    {
+        std::lock_guard<std::mutex> lock(mutex);
+        tables_snapshot = tables;
+    }
+
+    for (const auto & kv: tables_snapshot) {
+        kv.second->shutdown();
+    }
+
+    std::lock_guard<std::mutex> lock(mutex);
+    tables.clear();
+}
+
+void DatabaseMemory::drop()
+{
+    /// Additional actions to delete database are not required.
+}
+
 }
diff --git a/dbms/src/Databases/DatabaseMemory.h b/dbms/src/Databases/DatabaseMemory.h
index 4dc75c7dfff..d4d15ad61e0 100644
--- a/dbms/src/Databases/DatabaseMemory.h
+++ b/dbms/src/Databases/DatabaseMemory.h
@@ -31,32 +31,42 @@ public:
 
     String getEngineName() const override { return "Memory"; }
 
-    void loadTables(Context & context, ThreadPool * thread_pool, bool has_force_restore_data_flag) override;
+    void loadTables(
+        Context & context,
+        ThreadPool * thread_pool,
+        bool has_force_restore_data_flag) override;
 
-    bool isTableExist(const String & table_name) const override;
-    StoragePtr tryGetTable(const String & table_name) override;
+    bool empty(const Context & context) const override;
 
-    DatabaseIteratorPtr getIterator() override;
+    DatabaseIteratorPtr getIterator(const Context & context) override;
 
-    bool empty() const override;
+    bool isTableExist(
+        const Context & context,
+        const String & table_name) const override;
+
+    StoragePtr tryGetTable(
+        const Context & context,
+        const String & table_name) override;
 
     void createTable(
-        const String & table_name, const StoragePtr & table, const ASTPtr & query, const String & engine, const Settings & settings) override;
+        const Context & context,
+        const String & table_name,
+        const StoragePtr & table,
+        const ASTPtr & query,
+        const String & engine) override;
 
-    void removeTable(const String & table_name) override;
+    void removeTable(
+        const Context & context,
+        const String & table_name) override;
 
     void attachTable(const String & table_name, const StoragePtr & table) override;
     StoragePtr detachTable(const String & table_name) override;
 
     void renameTable(
-        const Context & context, const String & table_name, IDatabase & to_database, const String & to_table_name, const Settings & settings) override;
-
-    time_t getTableMetadataModificationTime(const String & table_name) override;
-
-    ASTPtr getCreateQuery(const String & table_name) const override;
-
-    void shutdown() override;
-    void drop() override;
+        const Context & context,
+        const String & table_name,
+        IDatabase & to_database,
+        const String & to_table_name) override;
 
     void alterTable(
         const Context & context,
@@ -66,6 +76,17 @@ public:
         const NamesAndTypesList & alias_columns,
         const ColumnDefaults & column_defaults,
         const ASTModifier & engine_modifier) override;
+
+    time_t getTableMetadataModificationTime(
+        const Context & context,
+        const String & table_name) override;
+
+    ASTPtr getCreateQuery(
+        const Context & context,
+        const String & table_name) const override;
+
+    void shutdown() override;
+    void drop() override;
 };
 
 }
diff --git a/dbms/src/Databases/DatabaseOrdinary.cpp b/dbms/src/Databases/DatabaseOrdinary.cpp
index 609b20c6383..67b4a4e986a 100644
--- a/dbms/src/Databases/DatabaseOrdinary.cpp
+++ b/dbms/src/Databases/DatabaseOrdinary.cpp
@@ -97,7 +97,10 @@ DatabaseOrdinary::DatabaseOrdinary(
 }
 
 
-void DatabaseOrdinary::loadTables(Context & context, ThreadPool * thread_pool, bool has_force_restore_data_flag)
+void DatabaseOrdinary::loadTables(
+    Context & context,
+    ThreadPool * thread_pool,
+    bool has_force_restore_data_flag)
 {
     log = &Logger::get("DatabaseOrdinary (" + name + ")");
 
@@ -241,8 +244,14 @@ void DatabaseOrdinary::startupTables(ThreadPool * thread_pool)
 
 
 void DatabaseOrdinary::createTable(
-    const String & table_name, const StoragePtr & table, const ASTPtr & query, const String & engine, const Settings & settings)
+    const Context & context,
+    const String & table_name,
+    const StoragePtr & table,
+    const ASTPtr & query,
+    const String & engine)
 {
+    const auto & settings = context.getSettingsRef();
+
     /// Create a file with metadata if necessary - if the query is not ATTACH.
     /// Write the query of `ATTACH table` to it.
 
@@ -298,7 +307,9 @@ void DatabaseOrdinary::createTable(
 }
 
 
-void DatabaseOrdinary::removeTable(const String & table_name)
+void DatabaseOrdinary::removeTable(
+    const Context & context,
+    const String & table_name)
 {
     StoragePtr res = detachTable(table_name);
 
@@ -332,14 +343,17 @@ static ASTPtr getCreateQueryImpl(const String & path, const String & table_name)
 
 
 void DatabaseOrdinary::renameTable(
-    const Context & context, const String & table_name, IDatabase & to_database, const String & to_table_name, const Settings & settings)
+    const Context & context,
+    const String & table_name,
+    IDatabase & to_database,
+    const String & to_table_name)
 {
     DatabaseOrdinary * to_database_concrete = typeid_cast<DatabaseOrdinary *>(&to_database);
 
     if (!to_database_concrete)
         throw Exception("Moving tables between databases of different engines is not supported", ErrorCodes::NOT_IMPLEMENTED);
 
-    StoragePtr table = tryGetTable(table_name);
+    StoragePtr table = tryGetTable(context, table_name);
 
     if (!table)
         throw Exception("Table " + name + "." + table_name + " doesn't exist.", ErrorCodes::UNKNOWN_TABLE);
@@ -366,12 +380,14 @@ void DatabaseOrdinary::renameTable(
     ast_create_query.table = to_table_name;
 
     /// NOTE Non-atomic.
-    to_database_concrete->createTable(to_table_name, table, ast, table->getName(), settings);
-    removeTable(table_name);
+    to_database_concrete->createTable(context, to_table_name, table, ast, table->getName());
+    removeTable(context, table_name);
 }
 
 
-time_t DatabaseOrdinary::getTableMetadataModificationTime(const String & table_name)
+time_t DatabaseOrdinary::getTableMetadataModificationTime(
+    const Context & context,
+    const String & table_name)
 {
     String table_metadata_path = getTableMetadataPath(path, table_name);
     Poco::File meta_file(table_metadata_path);
@@ -387,7 +403,9 @@ time_t DatabaseOrdinary::getTableMetadataModificationTime(const String & table_n
 }
 
 
-ASTPtr DatabaseOrdinary::getCreateQuery(const String & table_name) const
+ASTPtr DatabaseOrdinary::getCreateQuery(
+    const Context & context,
+    const String & table_name) const
 {
     ASTPtr ast = getCreateQueryImpl(path, table_name);
 
@@ -404,8 +422,15 @@ void DatabaseOrdinary::shutdown()
     /// You can not hold a lock during shutdown.
     /// Because inside `shutdown` function the tables can work with database, and mutex is not recursive.
 
-    for (auto iterator = getIterator(); iterator->isValid(); iterator->next())
-        iterator->table()->shutdown();
+    Tables tables_snapshot;
+    {
+        std::lock_guard<std::mutex> lock(mutex);
+        tables_snapshot = tables;
+    }
+
+    for (const auto & kv: tables_snapshot) {
+        kv.second->shutdown();
+    }
 
     std::lock_guard<std::mutex> lock(mutex);
     tables.clear();
diff --git a/dbms/src/Databases/DatabaseOrdinary.h b/dbms/src/Databases/DatabaseOrdinary.h
index 6e04bd57d5d..5666beb007f 100644
--- a/dbms/src/Databases/DatabaseOrdinary.h
+++ b/dbms/src/Databases/DatabaseOrdinary.h
@@ -20,22 +20,27 @@ public:
 
     String getEngineName() const override { return "Ordinary"; }
 
-    void loadTables(Context & context, ThreadPool * thread_pool, bool has_force_restore_data_flag) override;
+    void loadTables(
+        Context & context,
+        ThreadPool * thread_pool,
+        bool has_force_restore_data_flag) override;
 
     void createTable(
-        const String & table_name, const StoragePtr & table, const ASTPtr & query, const String & engine, const Settings & settings) override;
+        const Context & context,
+        const String & table_name,
+        const StoragePtr & table,
+        const ASTPtr & query,
+        const String & engine) override;
 
-    void removeTable(const String & table_name) override;
+    void removeTable(
+        const Context & context,
+        const String & table_name) override;
 
     void renameTable(
-        const Context & context, const String & table_name, IDatabase & to_database, const String & to_table_name, const Settings & settings) override;
-
-    time_t getTableMetadataModificationTime(const String & table_name) override;
-
-    ASTPtr getCreateQuery(const String & table_name) const override;
-
-    void shutdown() override;
-    void drop() override;
+        const Context & context,
+        const String & table_name,
+        IDatabase & to_database,
+        const String & to_table_name) override;
 
     void alterTable(
         const Context & context,
@@ -46,6 +51,17 @@ public:
         const ColumnDefaults & column_defaults,
         const ASTModifier & engine_modifier) override;
 
+    time_t getTableMetadataModificationTime(
+        const Context & context,
+        const String & table_name) override;
+
+    ASTPtr getCreateQuery(
+        const Context & context,
+        const String & table_name) const override;
+
+    void shutdown() override;
+    void drop() override;
+
 private:
     void startupTables(ThreadPool * thread_pool);
 };
diff --git a/dbms/src/Databases/IDatabase.h b/dbms/src/Databases/IDatabase.h
index 027c11c3cd6..33f0b637224 100644
--- a/dbms/src/Databases/IDatabase.h
+++ b/dbms/src/Databases/IDatabase.h
@@ -59,27 +59,40 @@ public:
 
     /// Load a set of existing tables. If thread_pool is specified, use it.
     /// You can call only once, right after the object is created.
-    virtual void loadTables(Context & context, ThreadPool * thread_pool, bool has_force_restore_data_flag) = 0;
+    virtual void loadTables(
+        Context & context,
+        ThreadPool * thread_pool,
+        bool has_force_restore_data_flag) = 0;
 
     /// Check the existence of the table.
-    virtual bool isTableExist(const String & name) const = 0;
+    virtual bool isTableExist(
+        const Context & context,
+        const String & name) const = 0;
 
     /// Get the table for work. Return nullptr if there is no table.
-    virtual StoragePtr tryGetTable(const String & name) = 0;
+    virtual StoragePtr tryGetTable(
+        const Context & context,
+        const String & name) = 0;
 
     /// Get an iterator that allows you to pass through all the tables.
     /// It is possible to have "hidden" tables that are not visible when passing through, but are visible if you get them by name using the functions above.
-    virtual DatabaseIteratorPtr getIterator() = 0;
+    virtual DatabaseIteratorPtr getIterator(const Context & context) = 0;
 
     /// Is the database empty.
-    virtual bool empty() const = 0;
+    virtual bool empty(const Context & context) const = 0;
 
     /// Add the table to the database. Record its presence in the metadata.
     virtual void createTable(
-        const String & name, const StoragePtr & table, const ASTPtr & query, const String & engine, const Settings & settings) = 0;
+        const Context & context,
+        const String & name,
+        const StoragePtr & table,
+        const ASTPtr & query,
+        const String & engine) = 0;
 
     /// Delete the table from the database and return it. Delete the metadata.
-    virtual void removeTable(const String & name) = 0;
+    virtual void removeTable(
+        const Context & context,
+        const String & name) = 0;
 
     /// Add a table to the database, but do not add it to the metadata. The database may not support this method.
     virtual void attachTable(const String & name, const StoragePtr & table) = 0;
@@ -89,10 +102,10 @@ public:
 
     /// Rename the table and possibly move the table to another database.
     virtual void renameTable(
-        const Context & context, const String & name, IDatabase & to_database, const String & to_name, const Settings & settings) = 0;
-
-    /// Returns time of table's metadata change, 0 if there is no corresponding metadata file.
-    virtual time_t getTableMetadataModificationTime(const String & name) = 0;
+        const Context & context,
+        const String & name,
+        IDatabase & to_database,
+        const String & to_name) = 0;
 
     using ASTModifier = std::function<void(ASTPtr &)>;
 
@@ -107,8 +120,15 @@ public:
         const ColumnDefaults & column_defaults,
         const ASTModifier & engine_modifier) = 0;
 
+    /// Returns time of table's metadata change, 0 if there is no corresponding metadata file.
+    virtual time_t getTableMetadataModificationTime(
+        const Context & context,
+        const String & name) = 0;
+
     /// Get the CREATE TABLE query for the table. It can also provide information for detached tables for which there is metadata.
-    virtual ASTPtr getCreateQuery(const String & name) const = 0;
+    virtual ASTPtr getCreateQuery(
+        const Context & context,
+        const String & name) const = 0;
 
     /// Ask all tables to complete the background threads they are using and delete all table objects.
     virtual void shutdown() = 0;
diff --git a/dbms/src/Interpreters/AsynchronousMetrics.cpp b/dbms/src/Interpreters/AsynchronousMetrics.cpp
index 823e6eab2e3..fcc3394c3d0 100644
--- a/dbms/src/Interpreters/AsynchronousMetrics.cpp
+++ b/dbms/src/Interpreters/AsynchronousMetrics.cpp
@@ -146,7 +146,7 @@ void AsynchronousMetrics::update()
 
         for (const auto & db : databases)
         {
-            for (auto iterator = db.second->getIterator(); iterator->isValid(); iterator->next())
+            for (auto iterator = db.second->getIterator(context); iterator->isValid(); iterator->next())
             {
                 auto & table = iterator->table();
                 StorageMergeTree * table_merge_tree = typeid_cast<StorageMergeTree *>(table.get());
diff --git a/dbms/src/Interpreters/Context.cpp b/dbms/src/Interpreters/Context.cpp
index 3663597f334..1e0023a1b3e 100644
--- a/dbms/src/Interpreters/Context.cpp
+++ b/dbms/src/Interpreters/Context.cpp
@@ -621,7 +621,7 @@ bool Context::isTableExist(const String & database_name, const String & table_na
 
     Databases::const_iterator it = shared->databases.find(db);
     return shared->databases.end() != it
-        && it->second->isTableExist(table_name);
+        && it->second->isTableExist(*this, table_name);
 }
 
 
@@ -645,7 +645,7 @@ void Context::assertTableExists(const String & database_name, const String & tab
     if (shared->databases.end() == it)
         throw Exception("Database " + db + " doesn't exist", ErrorCodes::UNKNOWN_DATABASE);
 
-    if (!it->second->isTableExist(table_name))
+    if (!it->second->isTableExist(*this, table_name))
         throw Exception("Table " + db + "." + table_name + " doesn't exist.", ErrorCodes::UNKNOWN_TABLE);
 }
 
@@ -659,7 +659,7 @@ void Context::assertTableDoesntExist(const String & database_name, const String
         checkDatabaseAccessRights(db);
 
     Databases::const_iterator it = shared->databases.find(db);
-    if (shared->databases.end() != it && it->second->isTableExist(table_name))
+    if (shared->databases.end() != it && it->second->isTableExist(*this, table_name))
         throw Exception("Table " + db + "." + table_name + " already exists.", ErrorCodes::TABLE_ALREADY_EXISTS);
 }
 
@@ -758,7 +758,7 @@ StoragePtr Context::getTableImpl(const String & database_name, const String & ta
         return {};
     }
 
-    auto table = it->second->tryGetTable(table_name);
+    auto table = it->second->tryGetTable(*this, table_name);
     if (!table)
     {
         if (exception)
@@ -826,7 +826,7 @@ std::unique_ptr<DDLGuard> Context::getDDLGuardIfTableDoesntExist(const String &
     auto lock = getLock();
 
     Databases::const_iterator it = shared->databases.find(database);
-    if (shared->databases.end() != it && it->second->isTableExist(table))
+    if (shared->databases.end() != it && it->second->isTableExist(*this, table))
         return {};
 
     return getDDLGuard(database, table, message);
@@ -859,7 +859,7 @@ ASTPtr Context::getCreateQuery(const String & database_name, const String & tabl
     String db = resolveDatabase(database_name, current_database);
     assertDatabaseExists(db);
 
-    return shared->databases[db]->getCreateQuery(table_name);
+    return shared->databases[db]->getCreateQuery(*this, table_name);
 }
 
 
diff --git a/dbms/src/Interpreters/InterpreterCreateQuery.cpp b/dbms/src/Interpreters/InterpreterCreateQuery.cpp
index 3be60614bd2..6d570ad09d4 100644
--- a/dbms/src/Interpreters/InterpreterCreateQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterCreateQuery.cpp
@@ -549,7 +549,7 @@ BlockIO InterpreterCreateQuery::createTable(ASTCreateQuery & create)
         if (create.is_temporary)
             context.getSessionContext().addExternalTable(table_name, res);
         else
-            context.getDatabase(database_name)->createTable(table_name, res, query_ptr, storage_name, context.getSettingsRef());
+            context.getDatabase(database_name)->createTable(context, table_name, res, query_ptr, storage_name);
     }
 
     res->startup();
diff --git a/dbms/src/Interpreters/InterpreterDropQuery.cpp b/dbms/src/Interpreters/InterpreterDropQuery.cpp
index cefb092820f..3d769b3e583 100644
--- a/dbms/src/Interpreters/InterpreterDropQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterDropQuery.cpp
@@ -99,7 +99,7 @@ BlockIO InterpreterDropQuery::execute()
             return {};
         }
 
-        for (auto iterator = database->getIterator(); iterator->isValid(); iterator->next())
+        for (auto iterator = database->getIterator(context); iterator->isValid(); iterator->next())
             tables_to_drop.emplace_back(iterator->table(), context.getDDLGuard(database_name, iterator->name(),
                 "Table " + database_name + "." + iterator->name() + " is dropping or detaching right now"));
     }
@@ -128,7 +128,7 @@ BlockIO InterpreterDropQuery::execute()
         else
         {
             /// Delete table metdata and table itself from memory
-            database->removeTable(current_table_name);
+            database->removeTable(context, current_table_name);
             /// Delete table data
             table.first->drop();
 
@@ -151,7 +151,7 @@ BlockIO InterpreterDropQuery::execute()
         context.assertDatabaseExists(database_name);
 
         /// Someone could have time to create a table in the database to be deleted while we deleted the tables without the context lock.
-        if (!context.getDatabase(database_name)->empty())
+        if (!context.getDatabase(database_name)->empty(context))
             throw Exception("New table appeared in database being dropped. Try dropping it again.", ErrorCodes::DATABASE_NOT_EMPTY);
 
         /// Delete database information from the RAM
diff --git a/dbms/src/Interpreters/InterpreterRenameQuery.cpp b/dbms/src/Interpreters/InterpreterRenameQuery.cpp
index d626e80a06b..8068463a845 100644
--- a/dbms/src/Interpreters/InterpreterRenameQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterRenameQuery.cpp
@@ -118,7 +118,7 @@ BlockIO InterpreterRenameQuery::execute()
         context.assertTableDoesntExist(elem.to_database_name, elem.to_table_name);
 
         context.getDatabase(elem.from_database_name)->renameTable(
-            context, elem.from_table_name, *context.getDatabase(elem.to_database_name), elem.to_table_name, context.getSettingsRef());
+            context, elem.from_table_name, *context.getDatabase(elem.to_database_name), elem.to_table_name);
     }
 
     return {};
diff --git a/dbms/src/Server/ReplicasStatusHandler.cpp b/dbms/src/Server/ReplicasStatusHandler.cpp
index dfbd6cfc765..f1709be880c 100644
--- a/dbms/src/Server/ReplicasStatusHandler.cpp
+++ b/dbms/src/Server/ReplicasStatusHandler.cpp
@@ -40,7 +40,7 @@ void ReplicasStatusHandler::handleRequest(Poco::Net::HTTPServerRequest & request
         /// Iterate through all the replicated tables.
         for (const auto & db : databases)
         {
-            for (auto iterator = db.second->getIterator(); iterator->isValid(); iterator->next())
+            for (auto iterator = db.second->getIterator(context); iterator->isValid(); iterator->next())
             {
                 auto & table = iterator->table();
                 StorageReplicatedMergeTree * table_replicated = typeid_cast<StorageReplicatedMergeTree *>(table.get());
diff --git a/dbms/src/Storages/StorageMerge.cpp b/dbms/src/Storages/StorageMerge.cpp
index d5a33ba1323..6f83e98ff59 100644
--- a/dbms/src/Storages/StorageMerge.cpp
+++ b/dbms/src/Storages/StorageMerge.cpp
@@ -58,7 +58,7 @@ StorageMerge::StorageMerge(
 bool StorageMerge::isRemote() const
 {
     auto database = context.getDatabase(source_database);
-    auto iterator = database->getIterator();
+    auto iterator = database->getIterator(context);
 
     while (iterator->isValid())
     {
@@ -327,7 +327,7 @@ StorageMerge::StorageListWithLocks StorageMerge::getSelectedTables() const
 {
     StorageListWithLocks selected_tables;
     auto database = context.getDatabase(source_database);
-    auto iterator = database->getIterator();
+    auto iterator = database->getIterator(context);
 
     while (iterator->isValid())
     {
diff --git a/dbms/src/Storages/System/StorageSystemColumns.cpp b/dbms/src/Storages/System/StorageSystemColumns.cpp
index b0df8444fcb..58b30d6455f 100644
--- a/dbms/src/Storages/System/StorageSystemColumns.cpp
+++ b/dbms/src/Storages/System/StorageSystemColumns.cpp
@@ -74,7 +74,7 @@ BlockInputStreams StorageSystemColumns::read(
             const DatabasePtr database = databases.at(database_name);
             offsets[i] = i ? offsets[i - 1] : 0;
 
-            for (auto iterator = database->getIterator(); iterator->isValid(); iterator->next())
+            for (auto iterator = database->getIterator(context); iterator->isValid(); iterator->next())
             {
                 const String & table_name = iterator->name();
                 storages.emplace(std::piecewise_construct,
diff --git a/dbms/src/Storages/System/StorageSystemParts.cpp b/dbms/src/Storages/System/StorageSystemParts.cpp
index 3b053aed166..b3835740f33 100644
--- a/dbms/src/Storages/System/StorageSystemParts.cpp
+++ b/dbms/src/Storages/System/StorageSystemParts.cpp
@@ -93,7 +93,7 @@ BlockInputStreams StorageSystemParts::read(
             const DatabasePtr database = databases.at(database_name);
 
             offsets[i] = i ? offsets[i - 1] : 0;
-            for (auto iterator = database->getIterator(); iterator->isValid(); iterator->next())
+            for (auto iterator = database->getIterator(context); iterator->isValid(); iterator->next())
             {
                 String table_name = iterator->name();
                 StoragePtr storage = iterator->table();
diff --git a/dbms/src/Storages/System/StorageSystemReplicas.cpp b/dbms/src/Storages/System/StorageSystemReplicas.cpp
index 9a1074154ae..e907a48d762 100644
--- a/dbms/src/Storages/System/StorageSystemReplicas.cpp
+++ b/dbms/src/Storages/System/StorageSystemReplicas.cpp
@@ -62,7 +62,7 @@ BlockInputStreams StorageSystemReplicas::read(
     /// We collect a set of replicated tables.
     std::map<String, std::map<String, StoragePtr>> replicated_tables;
     for (const auto & db : context.getDatabases())
-        for (auto iterator = db.second->getIterator(); iterator->isValid(); iterator->next())
+        for (auto iterator = db.second->getIterator(context); iterator->isValid(); iterator->next())
             if (typeid_cast<const StorageReplicatedMergeTree *>(iterator->table().get()))
                 replicated_tables[db.first][iterator->name()] = iterator->table();
 
diff --git a/dbms/src/Storages/System/StorageSystemReplicationQueue.cpp b/dbms/src/Storages/System/StorageSystemReplicationQueue.cpp
index 5c3c7f5d931..ddea933578d 100644
--- a/dbms/src/Storages/System/StorageSystemReplicationQueue.cpp
+++ b/dbms/src/Storages/System/StorageSystemReplicationQueue.cpp
@@ -60,7 +60,7 @@ BlockInputStreams StorageSystemReplicationQueue::read(
 
     std::map<String, std::map<String, StoragePtr>> replicated_tables;
     for (const auto & db : context.getDatabases())
-        for (auto iterator = db.second->getIterator(); iterator->isValid(); iterator->next())
+        for (auto iterator = db.second->getIterator(context); iterator->isValid(); iterator->next())
             if (typeid_cast<const StorageReplicatedMergeTree *>(iterator->table().get()))
                 replicated_tables[db.first][iterator->name()] = iterator->table();
 
diff --git a/dbms/src/Storages/System/StorageSystemTables.cpp b/dbms/src/Storages/System/StorageSystemTables.cpp
index 3f91703c507..f39186487ac 100644
--- a/dbms/src/Storages/System/StorageSystemTables.cpp
+++ b/dbms/src/Storages/System/StorageSystemTables.cpp
@@ -100,13 +100,13 @@ BlockInputStreams StorageSystemTables::read(
             continue;
         }
 
-        for (auto iterator = database->getIterator(); iterator->isValid(); iterator->next())
+        for (auto iterator = database->getIterator(context); iterator->isValid(); iterator->next())
         {
             auto table_name = iterator->name();
             col_db.column->insert(database_name);
             col_name.column->insert(table_name);
             col_engine.column->insert(iterator->table()->getName());
-            col_meta_mod_time.column->insert(static_cast<UInt64>(database->getTableMetadataModificationTime(table_name)));
+            col_meta_mod_time.column->insert(static_cast<UInt64>(database->getTableMetadataModificationTime(context, table_name)));
         }
     }
 
diff --git a/dbms/src/TableFunctions/TableFunctionMerge.cpp b/dbms/src/TableFunctions/TableFunctionMerge.cpp
index d6e2c7d4dc7..cf9f96f2f8d 100644
--- a/dbms/src/TableFunctions/TableFunctionMerge.cpp
+++ b/dbms/src/TableFunctions/TableFunctionMerge.cpp
@@ -33,7 +33,7 @@ static NamesAndTypesList chooseColumns(const String & source_database, const Str
 
     {
         auto database = context.getDatabase(source_database);
-        auto iterator = database->getIterator();
+        auto iterator = database->getIterator(context);
 
         while (iterator->isValid())
         {

From a80ebcdbc2b4ca6cda5afd64577b08f2bbe3a172 Mon Sep 17 00:00:00 2001
From: leozhang <johnson.scut@gmail.com>
Date: Tue, 12 Sep 2017 18:10:25 +0800
Subject: [PATCH 184/266] fix union all bug #1059

---
 .../Interpreters/InterpreterSelectQuery.cpp   | 21 ++++++++++++++++++-
 .../src/Interpreters/InterpreterSelectQuery.h |  1 +
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/dbms/src/Interpreters/InterpreterSelectQuery.cpp b/dbms/src/Interpreters/InterpreterSelectQuery.cpp
index dcbb35424db..b1eee8fc068 100644
--- a/dbms/src/Interpreters/InterpreterSelectQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterSelectQuery.cpp
@@ -100,7 +100,7 @@ void InterpreterSelectQuery::init(const BlockInputStreamPtr & input, const Names
         }
     }
 
-    if (is_first_select_inside_union_all && hasAsterisk())
+    if (is_first_select_inside_union_all && (hasAsterisk() || hasAggregation(&query)))
     {
         basicInit(input);
 
@@ -126,6 +126,25 @@ void InterpreterSelectQuery::init(const BlockInputStreamPtr & input, const Names
     }
 }
 
+bool InterpreterSelectQuery::hasAggregation(ASTSelectQuery * query_ptr){
+    if(!query_ptr) {
+        return false;
+    }
+    if(query_ptr->group_expression_list || query_ptr->having_expression) {
+        return true;
+    }
+    ASTPtr tail = query_ptr->next_union_all;
+    while(tail) {
+        ASTPtr head = tail;
+        ASTSelectQuery & head_query = static_cast<ASTSelectQuery &>(*head);
+        if(head_query.group_expression_list || head_query.having_expression) {
+            return true;
+        }
+        tail = head_query.next_union_all;
+    }
+    return false;
+}
+
 void InterpreterSelectQuery::basicInit(const BlockInputStreamPtr & input)
 {
     auto query_table = query.table();
diff --git a/dbms/src/Interpreters/InterpreterSelectQuery.h b/dbms/src/Interpreters/InterpreterSelectQuery.h
index a7e8ea1445e..28e2226c916 100644
--- a/dbms/src/Interpreters/InterpreterSelectQuery.h
+++ b/dbms/src/Interpreters/InterpreterSelectQuery.h
@@ -96,6 +96,7 @@ private:
     void init(const BlockInputStreamPtr & input, const Names & required_column_names = Names{});
     void basicInit(const BlockInputStreamPtr & input);
     void initQueryAnalyzer();
+    bool hasAggregation(ASTSelectQuery * query_ptr);
 
     /// Execute one SELECT query from the UNION ALL chain.
     void executeSingleQuery();

From af323d4e168957f8e49ba4a72e337217adee59c4 Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Tue, 12 Sep 2017 20:04:49 +0300
Subject: [PATCH 185/266] Update InterpreterSelectQuery.cpp

---
 .../Interpreters/InterpreterSelectQuery.cpp   | 23 +++++++------------
 1 file changed, 8 insertions(+), 15 deletions(-)

diff --git a/dbms/src/Interpreters/InterpreterSelectQuery.cpp b/dbms/src/Interpreters/InterpreterSelectQuery.cpp
index b1eee8fc068..e9b5a12c0b2 100644
--- a/dbms/src/Interpreters/InterpreterSelectQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterSelectQuery.cpp
@@ -100,7 +100,7 @@ void InterpreterSelectQuery::init(const BlockInputStreamPtr & input, const Names
         }
     }
 
-    if (is_first_select_inside_union_all && (hasAsterisk() || hasAggregation(&query)))
+    if (is_first_select_inside_union_all && (hasAsterisk() || hasAggregation(query)))
     {
         basicInit(input);
 
@@ -126,22 +126,15 @@ void InterpreterSelectQuery::init(const BlockInputStreamPtr & input, const Names
     }
 }
 
-bool InterpreterSelectQuery::hasAggregation(ASTSelectQuery * query_ptr){
-    if(!query_ptr) {
-        return false;
-    }
-    if(query_ptr->group_expression_list || query_ptr->having_expression) {
-        return true;
-    }
-    ASTPtr tail = query_ptr->next_union_all;
-    while(tail) {
-        ASTPtr head = tail;
-        ASTSelectQuery & head_query = static_cast<ASTSelectQuery &>(*head);
-        if(head_query.group_expression_list || head_query.having_expression) {
+bool InterpreterSelectQuery::hasAggregation(const ASTSelectQuery & query_ptr)
+{
+    for (const IAST * head = query_ptr.get(); head; head = head->next_union_all.get())
+    {
+        const ASTSelectQuery & head_query = static_cast<const ASTSelectQuery &>(*head);
+        if (head_query.group_expression_list || head_query.having_expression)
             return true;
-        }
-        tail = head_query.next_union_all;
     }
+
     return false;
 }
 

From c4c8057a280f40fd80736e2ac830b8bd02bad1d2 Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Tue, 12 Sep 2017 20:05:14 +0300
Subject: [PATCH 186/266] Update InterpreterSelectQuery.h

---
 dbms/src/Interpreters/InterpreterSelectQuery.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbms/src/Interpreters/InterpreterSelectQuery.h b/dbms/src/Interpreters/InterpreterSelectQuery.h
index 28e2226c916..0a7c6227774 100644
--- a/dbms/src/Interpreters/InterpreterSelectQuery.h
+++ b/dbms/src/Interpreters/InterpreterSelectQuery.h
@@ -96,7 +96,7 @@ private:
     void init(const BlockInputStreamPtr & input, const Names & required_column_names = Names{});
     void basicInit(const BlockInputStreamPtr & input);
     void initQueryAnalyzer();
-    bool hasAggregation(ASTSelectQuery * query_ptr);
+    bool hasAggregation(const ASTSelectQuery & query_ptr);
 
     /// Execute one SELECT query from the UNION ALL chain.
     void executeSingleQuery();

From 4bf1f39190366acc7d4c6bb1e36ed6453f2deb56 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Tue, 12 Sep 2017 20:21:02 +0300
Subject: [PATCH 187/266] Fixed build [#CLICKHOUSE-2].

---
 dbms/src/Interpreters/InterpreterSelectQuery.cpp | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/dbms/src/Interpreters/InterpreterSelectQuery.cpp b/dbms/src/Interpreters/InterpreterSelectQuery.cpp
index e9b5a12c0b2..550213caefc 100644
--- a/dbms/src/Interpreters/InterpreterSelectQuery.cpp
+++ b/dbms/src/Interpreters/InterpreterSelectQuery.cpp
@@ -128,12 +128,9 @@ void InterpreterSelectQuery::init(const BlockInputStreamPtr & input, const Names
 
 bool InterpreterSelectQuery::hasAggregation(const ASTSelectQuery & query_ptr)
 {
-    for (const IAST * head = query_ptr.get(); head; head = head->next_union_all.get())
-    {
-        const ASTSelectQuery & head_query = static_cast<const ASTSelectQuery &>(*head);
-        if (head_query.group_expression_list || head_query.having_expression)
+    for (const ASTSelectQuery * elem = &query_ptr; elem; elem = static_cast<const ASTSelectQuery *>(elem->next_union_all.get()))
+        if (elem->group_expression_list || elem->having_expression)
             return true;
-    }
 
     return false;
 }

From 3db51ee3887854051eb8152c8e82f6056f575e0b Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Tue, 12 Sep 2017 20:50:32 +0300
Subject: [PATCH 188/266] Fixed typo on the website [#EDIT-25728].

---
 website/index.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/website/index.html b/website/index.html
index ca5364f0802..0a22c5a289e 100644
--- a/website/index.html
+++ b/website/index.html
@@ -165,7 +165,7 @@
         on the market. It&nbsp;processes hundreds of millions to more than a billion rows and tens of gigabytes of data
         per single server per second.</p>
 
-    <p>ClickHouse uses all available hardware to it's full potential to process each query as fast as possible. The peak
+    <p>ClickHouse uses all available hardware to its full potential to process each query as fast as possible. The peak
         processing performance for a single query <span class="grey">(after decompression, only used columns)</span>
         stands at more than 2&nbsp;terabytes per second.</p>
 </div>

From 12cf25bbe2f3c13e4d4d65b04478e4886fbe242e Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Tue, 12 Sep 2017 22:43:30 +0300
Subject: [PATCH 189/266] Added link to RPM packages in documentation
 [#CLICKHOUSE-3].

---
 docs/en/getting_started/index.rst | 2 ++
 docs/ru/getting_started/index.rst | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/docs/en/getting_started/index.rst b/docs/en/getting_started/index.rst
index 9a322ae6807..41a5dcf7182 100644
--- a/docs/en/getting_started/index.rst
+++ b/docs/en/getting_started/index.rst
@@ -74,6 +74,8 @@ Other methods of installation
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 The Docker image is located here: https://hub.docker.com/r/yandex/clickhouse-server/
 
+There are RPM packages for CentOS, RHEL: https://github.com/Altinity/clickhouse-rpm-install
+
 There is Gentoo overlay located here: https://github.com/kmeaw/clickhouse-overlay
 
 
diff --git a/docs/ru/getting_started/index.rst b/docs/ru/getting_started/index.rst
index dead1211166..36bd2824e6e 100644
--- a/docs/ru/getting_started/index.rst
+++ b/docs/ru/getting_started/index.rst
@@ -76,6 +76,8 @@ ClickHouse содержит настройки ограничения досту
 ~~~~~~~~~~~~~~~~~~~~~~~
 Docker образ: https://hub.docker.com/r/yandex/clickhouse-server/
 
+RPM пакеты для CentOS, RHEL: https://github.com/Altinity/clickhouse-rpm-install
+
 Gentoo overlay: https://github.com/kmeaw/clickhouse-overlay
 
 

From a4c5cf000917b4b39ba5c0091f8741a59e04d9d2 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Tue, 12 Sep 2017 22:47:39 +0300
Subject: [PATCH 190/266] Fixed bad translation [#CLICKHOUSE-3].

---
 docs/en/getting_started/index.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/docs/en/getting_started/index.rst b/docs/en/getting_started/index.rst
index 41a5dcf7182..af8946f76b4 100644
--- a/docs/en/getting_started/index.rst
+++ b/docs/en/getting_started/index.rst
@@ -58,7 +58,7 @@ You can compile packages and install them. You can also use programs without ins
     Client: dbms/src/Client/
     Server: dbms/src/Server/
 
-For the server, create a catalog with data, such as:
+For the server, create a directory with data, such as:
 
 .. code-block:: text
 
@@ -88,7 +88,7 @@ To start the server (as a daemon), run:
 
     sudo service clickhouse-server start
 
-View the logs in the catalog `/var/log/clickhouse-server/`
+View the logs in the directory `/var/log/clickhouse-server/`
 
 If the server doesn't start, check the configurations in the file `/etc/clickhouse-server/config.xml`
 

From 9a58e26b8c652445ad5f2a6c8c590578cf35cc27 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Wed, 13 Sep 2017 00:06:11 +0300
Subject: [PATCH 191/266] Added comment [#CLICKHOUSE-2].

---
 dbms/src/Common/RadixSort.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/dbms/src/Common/RadixSort.h b/dbms/src/Common/RadixSort.h
index e22fdd01c2b..4f9cf260a64 100644
--- a/dbms/src/Common/RadixSort.h
+++ b/dbms/src/Common/RadixSort.h
@@ -185,6 +185,7 @@ public:
         Element * swap_buffer = reinterpret_cast<Element *>(allocator.allocate(size * sizeof(Element)));
 
         /// Transform the array and calculate the histogram.
+        /// NOTE This is slightly suboptimal. Look at https://github.com/powturbo/TurboHist
         for (size_t i = 0; i < size; ++i)
         {
             if (!Traits::Transform::transform_is_simple)

From 68f48253c93ec74494de09e12cb433a32d381c5f Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Wed, 13 Sep 2017 17:24:54 +0300
Subject: [PATCH 192/266] Tests: catch xml internal error

---
 dbms/tests/clickhouse-test | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/dbms/tests/clickhouse-test b/dbms/tests/clickhouse-test
index 58304f1768e..13a3b422d9c 100755
--- a/dbms/tests/clickhouse-test
+++ b/dbms/tests/clickhouse-test
@@ -203,9 +203,12 @@ def main(args):
                                     failure = et.Element("failure", attrib = {"message": "result differs with reference"})
                                     report_testcase.append(failure)
 
-                                    stdout_element = et.Element("system-out")
-                                    stdout_element.text = et.CDATA(diff)
-                                    report_testcase.append(stdout_element)
+                                    try:
+                                        stdout_element = et.Element("system-out")
+                                        stdout_element.text = et.CDATA(diff)
+                                        report_testcase.append(stdout_element)
+                                    except Exception as e:
+                                        print("{0} - test internal error\n{1}".format(MSG_FAIL, e))
 
                                     failures = failures + 1
                                     print("{0} - result differs with reference:\n{1}".format(MSG_FAIL, diff.encode('utf-8')))

From 8a7e604a2a5dd2540e73706bd329126ca7fcd65c Mon Sep 17 00:00:00 2001
From: proller <proller@users.noreply.github.com>
Date: Wed, 13 Sep 2017 21:08:38 +0300
Subject: [PATCH 193/266] Tests fixes (#1238)

* Tests: catch xml internal error

* Tests fixes
---
 dbms/tests/clickhouse-test                                     | 3 ++-
 ...6_clear_column_in_partition_concurrent_zookeeper.reference} | 0
 ...=> 00446_clear_column_in_partition_concurrent_zookeeper.sh} | 0
 ...nce => 00446_clear_column_in_partition_zookeeper.reference} | 0
 ...ition.sql => 00446_clear_column_in_partition_zookeeper.sql} | 0
 5 files changed, 2 insertions(+), 1 deletion(-)
 rename dbms/tests/queries/0_stateless/{00446_clear_column_in_partition_concurrent.reference => 00446_clear_column_in_partition_concurrent_zookeeper.reference} (100%)
 rename dbms/tests/queries/0_stateless/{00446_clear_column_in_partition_concurrent.sh => 00446_clear_column_in_partition_concurrent_zookeeper.sh} (100%)
 rename dbms/tests/queries/0_stateless/{00446_clear_column_in_partition.reference => 00446_clear_column_in_partition_zookeeper.reference} (100%)
 rename dbms/tests/queries/0_stateless/{00446_clear_column_in_partition.sql => 00446_clear_column_in_partition_zookeeper.sql} (100%)

diff --git a/dbms/tests/clickhouse-test b/dbms/tests/clickhouse-test
index 13a3b422d9c..86d6fed4e12 100755
--- a/dbms/tests/clickhouse-test
+++ b/dbms/tests/clickhouse-test
@@ -238,13 +238,14 @@ if __name__ == '__main__':
     parser.add_argument('-o', '--output', help = 'Output xUnit compliant test report directory')
     parser.add_argument('-t', '--timeout', type = int, default = 600, help = 'Timeout for each test case in seconds')
     parser.add_argument('test', nargs = '?', help = 'Optional test case name regex')
+    parser.add_argument('--stop', action = 'store_true', default = None, dest = 'stop', help = 'Stop on network errors ')
 
     group = parser.add_mutually_exclusive_group(required = False)
     group.add_argument('--zookeeper', action = 'store_true', default = None, dest = 'zookeeper', help = 'Run zookeeper related tests')
     group.add_argument('--no-zookeeper', action = 'store_false', default = None, dest = 'zookeeper', help = 'Do not run zookeeper related tests')
+    group = parser.add_mutually_exclusive_group(required = False)
     group.add_argument('--shard', action = 'store_true', default = None, dest = 'shard', help = 'Run sharding related tests (required to clickhouse-server listen 127.0.0.2 127.0.0.3)')
     group.add_argument('--no-shard', action = 'store_false', default = None, dest = 'shard', help = 'Do not run shard related tests')
-    group.add_argument('--stop', action = 'store_true', default = None, dest = 'stop', help = 'Stop on network errors ')
 
     args = parser.parse_args()
 
diff --git a/dbms/tests/queries/0_stateless/00446_clear_column_in_partition_concurrent.reference b/dbms/tests/queries/0_stateless/00446_clear_column_in_partition_concurrent_zookeeper.reference
similarity index 100%
rename from dbms/tests/queries/0_stateless/00446_clear_column_in_partition_concurrent.reference
rename to dbms/tests/queries/0_stateless/00446_clear_column_in_partition_concurrent_zookeeper.reference
diff --git a/dbms/tests/queries/0_stateless/00446_clear_column_in_partition_concurrent.sh b/dbms/tests/queries/0_stateless/00446_clear_column_in_partition_concurrent_zookeeper.sh
similarity index 100%
rename from dbms/tests/queries/0_stateless/00446_clear_column_in_partition_concurrent.sh
rename to dbms/tests/queries/0_stateless/00446_clear_column_in_partition_concurrent_zookeeper.sh
diff --git a/dbms/tests/queries/0_stateless/00446_clear_column_in_partition.reference b/dbms/tests/queries/0_stateless/00446_clear_column_in_partition_zookeeper.reference
similarity index 100%
rename from dbms/tests/queries/0_stateless/00446_clear_column_in_partition.reference
rename to dbms/tests/queries/0_stateless/00446_clear_column_in_partition_zookeeper.reference
diff --git a/dbms/tests/queries/0_stateless/00446_clear_column_in_partition.sql b/dbms/tests/queries/0_stateless/00446_clear_column_in_partition_zookeeper.sql
similarity index 100%
rename from dbms/tests/queries/0_stateless/00446_clear_column_in_partition.sql
rename to dbms/tests/queries/0_stateless/00446_clear_column_in_partition_zookeeper.sql

From 2bb487c333e994947f04fc54d7ef08fbfbccb8ee Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Wed, 13 Sep 2017 22:02:24 +0300
Subject: [PATCH 194/266] fixed string concat wih first array argument in block

---
 dbms/src/Functions/FunctionsString.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dbms/src/Functions/FunctionsString.cpp b/dbms/src/Functions/FunctionsString.cpp
index de1d3686fc0..0766ee47587 100644
--- a/dbms/src/Functions/FunctionsString.cpp
+++ b/dbms/src/Functions/FunctionsString.cpp
@@ -705,7 +705,7 @@ public:
 
     void executeImpl(Block & block, const ColumnNumbers & arguments, const size_t result) override
     {
-        if (!is_injective && !arguments.empty() && checkDataType<DataTypeArray>(block.getByPosition(0).type.get()))
+        if (!is_injective && !arguments.empty() && checkDataType<DataTypeArray>(block.getByPosition(arguments[0]).type.get()))
             return FunctionArrayConcat().executeImpl(block, arguments, result);
 
         if (arguments.size() == 2)

From c14263a9fa8f2bc14c2531fcff227b8ccd57f2e4 Mon Sep 17 00:00:00 2001
From: Nikolai Kochetov <nik-kochetov@yandex-team.ru>
Date: Wed, 13 Sep 2017 22:09:33 +0300
Subject: [PATCH 195/266] added test

---
 .../0_stateless/00502_string_concat_with_array.reference        | 2 ++
 .../queries/0_stateless/00502_string_concat_with_array.sql      | 1 +
 2 files changed, 3 insertions(+)
 create mode 100644 dbms/tests/queries/0_stateless/00502_string_concat_with_array.reference
 create mode 100644 dbms/tests/queries/0_stateless/00502_string_concat_with_array.sql

diff --git a/dbms/tests/queries/0_stateless/00502_string_concat_with_array.reference b/dbms/tests/queries/0_stateless/00502_string_concat_with_array.reference
new file mode 100644
index 00000000000..3ae3ec73944
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00502_string_concat_with_array.reference
@@ -0,0 +1,2 @@
+[0]	00
+[1]	11
diff --git a/dbms/tests/queries/0_stateless/00502_string_concat_with_array.sql b/dbms/tests/queries/0_stateless/00502_string_concat_with_array.sql
new file mode 100644
index 00000000000..8bfcaa8daaf
--- /dev/null
+++ b/dbms/tests/queries/0_stateless/00502_string_concat_with_array.sql
@@ -0,0 +1 @@
+select  a, b || b from (select [number] as a, toString(number) as b from system.numbers limit 2);

From 5e25c40a26f5499afa09916cad2df243a1a4daef Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Thu, 14 Sep 2017 07:24:20 +0300
Subject: [PATCH 196/266] Fixed error found by Coverity [#CLICKHOUSE-2].

---
 dbms/src/Common/ConcurrentBoundedQueue.h | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/dbms/src/Common/ConcurrentBoundedQueue.h b/dbms/src/Common/ConcurrentBoundedQueue.h
index 52338286fac..d3f67c5d4f1 100644
--- a/dbms/src/Common/ConcurrentBoundedQueue.h
+++ b/dbms/src/Common/ConcurrentBoundedQueue.h
@@ -39,7 +39,7 @@ namespace detail
     }
 };
 
-/** A very simple thread-safe queue of limited length.
+/** A very simple thread-safe queue of limited size.
   * If you try to pop an item from an empty queue, the thread is blocked until the queue becomes nonempty.
   * If you try to push an element into an overflowed queue, the thread is blocked until space appears in the queue.
   */
@@ -47,7 +47,6 @@ template <typename T>
 class ConcurrentBoundedQueue
 {
 private:
-    size_t max_fill;
     std::queue<T> queue;
     Poco::FastMutex mutex;
     Poco::Semaphore fill_count;

From a43b9ec398f68300f125509583d03b29b2926bc6 Mon Sep 17 00:00:00 2001
From: proller <proller@github.com>
Date: Wed, 13 Sep 2017 21:09:21 +0300
Subject: [PATCH 197/266] Revert "Simplification [#CLICKHOUSE-2]."

This reverts commit 98ad6a5db3239ac6567ee96e90973b935dcac39b.
---
 .../AsynchronousBlockInputStream.h            | 42 +++++++++++--------
 1 file changed, 25 insertions(+), 17 deletions(-)

diff --git a/dbms/src/DataStreams/AsynchronousBlockInputStream.h b/dbms/src/DataStreams/AsynchronousBlockInputStream.h
index cd4116a8325..e72b2f6489f 100644
--- a/dbms/src/DataStreams/AsynchronousBlockInputStream.h
+++ b/dbms/src/DataStreams/AsynchronousBlockInputStream.h
@@ -57,7 +57,10 @@ public:
         if (started)
         {
             pool.wait();
+            if (exception)
+                std::rethrow_exception(exception);
             children.back()->readSuffix();
+            started = false;
         }
     }
 
@@ -79,23 +82,18 @@ public:
 
     ~AsynchronousBlockInputStream() override
     {
-        try
-        {
-            pool.wait();    /// It's ok to call wait even if there is no active threads.
-        }
-        catch (...)
-        {
-            tryLogCurrentException(__PRETTY_FUNCTION__);
-        }
+        if (started)
+            pool.wait();
     }
 
 protected:
-    ThreadPool pool{1}; /// Rethrows exceptions automatically on wait.
+    ThreadPool pool{1};
     Poco::Event ready;
     bool started = false;
     bool first = true;
 
     Block block;
+    std::exception_ptr exception;
 
 
     Block readImpl() override
@@ -103,12 +101,15 @@ protected:
         /// If there were no calculations yet, calculate the first block synchronously
         if (!started)
         {
-            started = true;
             calculate(current_memory_tracker);
+            started = true;
         }
         else    /// If the calculations are already in progress - wait for the result
             pool.wait();
 
+        if (exception)
+            std::rethrow_exception(exception);
+
         Block res = block;
         if (!res)
             return res;
@@ -133,15 +134,22 @@ protected:
     {
         CurrentMetrics::Increment metric_increment{CurrentMetrics::QueryThread};
 
-        if (first)
+        try
         {
-            first = false;
-            setThreadName("AsyncBlockInput");
-            current_memory_tracker = memory_tracker;
-            children.back()->readPrefix();
-        }
+            if (first)
+            {
+                first = false;
+                setThreadName("AsyncBlockInput");
+                current_memory_tracker = memory_tracker;
+                children.back()->readPrefix();
+            }
 
-        block = children.back()->read();
+            block = children.back()->read();
+        }
+        catch (...)
+        {
+            exception = std::current_exception();
+        }
 
         ready.set();
     }

From 826c354ff5fbf687baf2b7bf6d7cab31d59f5653 Mon Sep 17 00:00:00 2001
From: Vitaliy Lyudvichenko <vludv@yandex-team.ru>
Date: Thu, 14 Sep 2017 16:56:54 +0300
Subject: [PATCH 198/266] Fixed merges progress bar. [#CLICKHOUSE-2]

---
 dbms/src/DataStreams/ColumnGathererStream.cpp      |  7 ++++++-
 .../src/Storages/MergeTree/MergeTreeDataMerger.cpp | 14 +++++++-------
 dbms/src/Storages/System/StorageSystemMerges.cpp   |  2 +-
 dbms/tests/queries/0_stateless/00155_merges.sh     |  5 +++++
 4 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/dbms/src/DataStreams/ColumnGathererStream.cpp b/dbms/src/DataStreams/ColumnGathererStream.cpp
index fef47a9d175..760af89e0b2 100644
--- a/dbms/src/DataStreams/ColumnGathererStream.cpp
+++ b/dbms/src/DataStreams/ColumnGathererStream.cpp
@@ -118,8 +118,13 @@ void ColumnGathererStream::fetchNewBlock(Source & source, size_t source_num)
 void ColumnGathererStream::readSuffixImpl()
 {
     const BlockStreamProfileInfo & profile_info = getProfileInfo();
+
+    /// Don't print info for small parts (< 10M rows)
+    if (profile_info.rows < 10000000)
+        return;
+
     double seconds = profile_info.total_stopwatch.elapsedSeconds();
-    LOG_DEBUG(log, std::fixed << std::setprecision(2)
+    LOG_TRACE(log, std::fixed << std::setprecision(2)
         << "Gathered column " << name
         << " (" << static_cast<double>(profile_info.bytes) / profile_info.rows << " bytes/elem.)"
         << " in " << seconds << " sec., "
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataMerger.cpp b/dbms/src/Storages/MergeTree/MergeTreeDataMerger.cpp
index c9638a1137f..e0961430e58 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataMerger.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataMerger.cpp
@@ -386,7 +386,7 @@ public:
   * - amount of merged rows and their size (PK columns subset is used in case of Vertical merge)
   * - time elapsed for current merge.
   */
-class MergeProgressCallback : public ProgressCallback
+class MergeProgressCallback
 {
 public:
     MergeProgressCallback(MergeList::Entry & merge_entry_, UInt64 & watch_prev_elapsed_)
@@ -540,14 +540,14 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMerger::mergePartsToTemporaryPart
     BlockInputStreams src_streams;
     UInt64 watch_prev_elapsed = 0;
 
-    for (size_t i = 0; i < parts.size(); ++i)
+    for (const auto & part : parts)
     {
         auto input = std::make_unique<MergeTreeBlockInputStream>(
-            data, parts[i], DEFAULT_MERGE_BLOCK_SIZE, 0, 0, merging_column_names, MarkRanges(1, MarkRange(0, parts[i]->size)),
+            data, part, DEFAULT_MERGE_BLOCK_SIZE, 0, 0, merging_column_names, MarkRanges(1, MarkRange(0, part->size)),
             false, nullptr, "", true, aio_threshold, DBMS_DEFAULT_BUFFER_SIZE, false);
 
-        input->setProgressCallback(
-            MergeProgressCallback{merge_entry, sum_input_rows_upper_bound, column_sizes, watch_prev_elapsed, merge_alg});
+        input->setProgressCallback(MergeProgressCallback(
+                merge_entry, sum_input_rows_upper_bound, column_sizes, watch_prev_elapsed, merge_alg));
 
         if (data.merging_params.mode != MergeTreeData::MergingParams::Unsorted)
             src_streams.emplace_back(std::make_shared<MaterializingBlockInputStream>(
@@ -680,8 +680,8 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMerger::mergePartsToTemporaryPart
                     data, parts[part_num], DEFAULT_MERGE_BLOCK_SIZE, 0, 0, column_name_, MarkRanges{MarkRange(0, parts[part_num]->size)},
                     false, nullptr, "", true, aio_threshold, DBMS_DEFAULT_BUFFER_SIZE, false, Names{}, 0, true);
 
-                column_part_stream->setProgressCallback(
-                    MergeProgressCallbackVerticalStep{merge_entry, sum_input_rows_exact, column_sizes, column_name, watch_prev_elapsed});
+                column_part_stream->setProgressCallback(MergeProgressCallbackVerticalStep(
+                        merge_entry, sum_input_rows_exact, column_sizes, column_name, watch_prev_elapsed));
 
                 column_part_streams[part_num] = std::move(column_part_stream);
             }
diff --git a/dbms/src/Storages/System/StorageSystemMerges.cpp b/dbms/src/Storages/System/StorageSystemMerges.cpp
index 81f20aab9e6..8b1781ad46d 100644
--- a/dbms/src/Storages/System/StorageSystemMerges.cpp
+++ b/dbms/src/Storages/System/StorageSystemMerges.cpp
@@ -54,7 +54,7 @@ BlockInputStreams StorageSystemMerges::read(
         block.getByPosition(i++).column->insert(merge.database);
         block.getByPosition(i++).column->insert(merge.table);
         block.getByPosition(i++).column->insert(merge.elapsed);
-        block.getByPosition(i++).column->insert(std::min(1., merge.progress)); /// little cheat
+        block.getByPosition(i++).column->insert(merge.progress);
         block.getByPosition(i++).column->insert(merge.num_parts);
         block.getByPosition(i++).column->insert(merge.source_part_names);
         block.getByPosition(i++).column->insert(merge.result_part_name);
diff --git a/dbms/tests/queries/0_stateless/00155_merges.sh b/dbms/tests/queries/0_stateless/00155_merges.sh
index 9e18cb8061f..36602d5b87d 100755
--- a/dbms/tests/queries/0_stateless/00155_merges.sh
+++ b/dbms/tests/queries/0_stateless/00155_merges.sh
@@ -63,6 +63,8 @@ function test {
     echo
 }
 
+merged_rows_0=`clickhouse-client -q "select value from system.events where event = 'MergedRows'"`
+
 test 8191 8191
 test 8191 8192
 test 8192 8191
@@ -76,4 +78,7 @@ test 8193 8194
 test 8194 8193
 test 8194 8194
 
+merged_rows_1=`clickhouse-client -q "select value from system.events where event = 'MergedRows'"`
+[[ $merged_rows_1 -le $merged_rows_0 ]]
+
 cleanup

From 7284ac69c057b8ffcf7d77c97a7d41fc9e39ffa0 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 02:33:46 +0300
Subject: [PATCH 199/266] Updated changelog [#CLICKHOUSE-2].

---
 CHANGELOG_RU.md | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/CHANGELOG_RU.md b/CHANGELOG_RU.md
index 6ac2620cbac..b85828d6a7b 100644
--- a/CHANGELOG_RU.md
+++ b/CHANGELOG_RU.md
@@ -1,3 +1,44 @@
+# Релиз ClickHouse 1.1.54289
+
+## Новые возможности:
+* Запросы `SYSTEM` для административных действий с сервером: `SYSTEM RELOAD DICTIONARY`, `SYSTEM RELOAD DICTIONARIES`, `SYSTEM DROP DNS CACHE`, `SYSTEM SHUTDOWN`, `SYSTEM KILL`.
+* Добавлены функции для работы с массивами: `concat`, `arraySlice`, `arrayPushBack`, `arrayPushFront`, `arrayPopBack`, `arrayPopFront`.
+* Добавлены параметры `root` и `identity` для конфигурации ZooKeeper. Это позволяет использовать разных пользователей одного ZooKeeper кластера.
+* Добавлены агрегатные функции `groupBitAnd`, `groupBitOr`, `groupBitXor` (для совместимости доступны также под именами `BIT_AND`, `BIT_OR`, `BIT_XOR`).
+* Возможность загрузки внешних словарей из MySQL с указанием сокета на файловой системе.
+* Возможность загрузки внешних словарей из MySQL через SSL соединение (параметры `ssl_cert`, `ssl_key`, `ssl_ca`).
+* Добавлена настройка `max_network_bandwidth_for_user` для ограничения общего потребления сети для всех запросов одного пользователя.
+* Поддержка `DROP TABLE` для временных таблиц.
+* Поддержка чтения значений типа `DateTime` в формате unix timestamp из форматов `CSV` и `JSONEachRow`.
+* Включено по-умолчанию отключение отстающих реплик при распределённых запросах (по-умолчанию порог равен 5 минутам).
+* Используются FIFO блокировки при ALTER: выполнение ALTER не будет неограниченно блокироваться при непрерывно выполняющихся запросах.
+* Возможность задать `umask` в конфигурационном файле.
+* Увеличена производительность запросов с `DISTINCT`.
+
+## Исправления ошибок:
+* Более оптимальная процедура удаления старых нод в ZooKeeper. Ранее в случае очень частых вставок, старые ноды могли не успевать удаляться, что приводило, в том числе, к очень долгому завершению сервера.
+* Исправлена рандомизация при выборе хостов для соединения с ZooKeeper.
+* Исправлено отключение отстающей реплики при распределённых запросах, если реплика является localhost.
+* Исправлена ошибка, в связи с которой кусок данных таблицы типа `ReplicatedMergeTree` мог становиться битым после выполнения `ALTER MODIFY` элемента `Nested` структуры.
+* Исправлена ошибка приводящая к возможному зависанию SELECT запросов.
+* Доработки распределённых DDL запросов.
+* Исправлен запрос `CREATE TABLE ... AS <materialized view>`.
+* Исправлен дедлок при запросе `ALTER ... CLEAR COLUMN IN PARTITION` для `Buffer` таблиц.
+* Исправлено использование неправильного значения по-умолчанию для `Enum`-ов (0 вместо минимального) при использовании форматов `JSONEachRow` и `TSKV`.
+* Исправлено появление zombie процессов при работе со словарём с источником `executable`.
+* Исправлен segfault при запросе HEAD.
+
+## Обратно несовместимые изменения:
+* Изменён генератор случайных чисел для агрегатных функций `quantile`, `quantileDeterministic`. Функция `quantileDeterministic` может выдавать другой результат. Если вам важно, чтобы функция `quantileDeterministic` возвращала тот же результат, что и раньше, обращайтесь к разработчикам ClickHouse.
+
+## Улучшения процесса разработки и сборки ClickHouse:
+* Возможность сборки с помощью `pbuilder`.
+* Возможность сборки с использованием `libc++` вместо `libstdc++` под Linux.
+* Добавлены инструкции для использования статических анализаторов кода `Coverity`, `clang-tidy`, `cppcheck`.
+
+## На что обратить внимание при обновлении:
+* Увеличено значение по-умолчанию для настройки MergeTree `max_bytes_to_merge_at_max_space_in_pool` (максимальный суммарный размер кусков в байтах для мержа) со 100 GiB до 150 GiB. Это может привести к запуску больших мержей после обновления сервера, что может вызвать повышенную нагрузку на дисковую подсистему. Если же на серверах, где это происходит, количество свободного места менее чем в два раза больше суммарного объёма выполняющихся мержей, то в связи с этим перестанут выполняться какие-либо другие мержи, включая мержи мелких кусков. Это приведёт к тому, что INSERT-ы будут отклоняться с сообщением "Merges are processing significantly slower than inserts". Для наблюдения, используйте запрос `SELECT * FROM system.merges`. Вы также можете смотреть на метрику `DiskSpaceReservedForMerge` в таблице `system.metrics` или в Graphite. Для исправления этой ситуации можно ничего не делать, так как она нормализуется сама после завершения больших мержей. Если же вас это не устраивает, вы можете вернуть настройку `max_bytes_to_merge_at_max_space_in_pool` в старое значение, прописав в config.xml в секции `<merge_tree>` `<m
+
 # Релиз ClickHouse 1.1.54284
 
 * Релиз содержит изменения к предыдущему релизу 1.1.54282, которые исправляют утечку записей о кусках в ZooKeeper

From b813babd25679b92f44cc3bf907a1dafd286312c Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 02:34:57 +0300
Subject: [PATCH 200/266] Updated changelog [#CLICKHOUSE-2].

---
 CHANGELOG_RU.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG_RU.md b/CHANGELOG_RU.md
index b85828d6a7b..f846e60714b 100644
--- a/CHANGELOG_RU.md
+++ b/CHANGELOG_RU.md
@@ -37,7 +37,7 @@
 * Добавлены инструкции для использования статических анализаторов кода `Coverity`, `clang-tidy`, `cppcheck`.
 
 ## На что обратить внимание при обновлении:
-* Увеличено значение по-умолчанию для настройки MergeTree `max_bytes_to_merge_at_max_space_in_pool` (максимальный суммарный размер кусков в байтах для мержа) со 100 GiB до 150 GiB. Это может привести к запуску больших мержей после обновления сервера, что может вызвать повышенную нагрузку на дисковую подсистему. Если же на серверах, где это происходит, количество свободного места менее чем в два раза больше суммарного объёма выполняющихся мержей, то в связи с этим перестанут выполняться какие-либо другие мержи, включая мержи мелких кусков. Это приведёт к тому, что INSERT-ы будут отклоняться с сообщением "Merges are processing significantly slower than inserts". Для наблюдения, используйте запрос `SELECT * FROM system.merges`. Вы также можете смотреть на метрику `DiskSpaceReservedForMerge` в таблице `system.metrics` или в Graphite. Для исправления этой ситуации можно ничего не делать, так как она нормализуется сама после завершения больших мержей. Если же вас это не устраивает, вы можете вернуть настройку `max_bytes_to_merge_at_max_space_in_pool` в старое значение, прописав в config.xml в секции `<merge_tree>` `<m
+* Увеличено значение по-умолчанию для настройки MergeTree `max_bytes_to_merge_at_max_space_in_pool` (максимальный суммарный размер кусков в байтах для мержа) со 100 GiB до 150 GiB. Это может привести к запуску больших мержей после обновления сервера, что может вызвать повышенную нагрузку на дисковую подсистему. Если же на серверах, где это происходит, количество свободного места менее чем в два раза больше суммарного объёма выполняющихся мержей, то в связи с этим перестанут выполняться какие-либо другие мержи, включая мержи мелких кусков. Это приведёт к тому, что INSERT-ы будут отклоняться с сообщением "Merges are processing significantly slower than inserts". Для наблюдения, используйте запрос `SELECT * FROM system.merges`. Вы также можете смотреть на метрику `DiskSpaceReservedForMerge` в таблице `system.metrics` или в Graphite. Для исправления этой ситуации можно ничего не делать, так как она нормализуется сама после завершения больших мержей. Если же вас это не устраивает, вы можете вернуть настройку `max_bytes_to_merge_at_max_space_in_pool` в старое значение, прописав в config.xml в секции `<merge_tree>` `<max_bytes_to_merge_at_max_space_in_pool>107374182400</max_bytes_to_merge_at_max_space_in_pool>` и перезапустить сервер.
 
 # Релиз ClickHouse 1.1.54284
 

From 2fe24c0ca120026dc4d0ae54049d9d93d7747919 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 02:36:42 +0300
Subject: [PATCH 201/266] Updated changelog [#CLICKHOUSE-2].

---
 CHANGELOG_RU.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CHANGELOG_RU.md b/CHANGELOG_RU.md
index f846e60714b..95acfef6466 100644
--- a/CHANGELOG_RU.md
+++ b/CHANGELOG_RU.md
@@ -3,7 +3,7 @@
 ## Новые возможности:
 * Запросы `SYSTEM` для административных действий с сервером: `SYSTEM RELOAD DICTIONARY`, `SYSTEM RELOAD DICTIONARIES`, `SYSTEM DROP DNS CACHE`, `SYSTEM SHUTDOWN`, `SYSTEM KILL`.
 * Добавлены функции для работы с массивами: `concat`, `arraySlice`, `arrayPushBack`, `arrayPushFront`, `arrayPopBack`, `arrayPopFront`.
-* Добавлены параметры `root` и `identity` для конфигурации ZooKeeper. Это позволяет использовать разных пользователей одного ZooKeeper кластера.
+* Добавлены параметры `root` и `identity` для конфигурации ZooKeeper. Это позволяет изолировать разных пользователей одного ZooKeeper кластера.
 * Добавлены агрегатные функции `groupBitAnd`, `groupBitOr`, `groupBitXor` (для совместимости доступны также под именами `BIT_AND`, `BIT_OR`, `BIT_XOR`).
 * Возможность загрузки внешних словарей из MySQL с указанием сокета на файловой системе.
 * Возможность загрузки внешних словарей из MySQL через SSL соединение (параметры `ssl_cert`, `ssl_key`, `ssl_ca`).

From 2a5391fda8cbba62857626aed33bc88b1ae97b58 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 02:45:45 +0300
Subject: [PATCH 202/266] Updated changelog [#CLICKHOUSE-2].

---
 CHANGELOG_RU.md | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/CHANGELOG_RU.md b/CHANGELOG_RU.md
index 95acfef6466..4003edde1fd 100644
--- a/CHANGELOG_RU.md
+++ b/CHANGELOG_RU.md
@@ -28,9 +28,6 @@
 * Исправлено появление zombie процессов при работе со словарём с источником `executable`.
 * Исправлен segfault при запросе HEAD.
 
-## Обратно несовместимые изменения:
-* Изменён генератор случайных чисел для агрегатных функций `quantile`, `quantileDeterministic`. Функция `quantileDeterministic` может выдавать другой результат. Если вам важно, чтобы функция `quantileDeterministic` возвращала тот же результат, что и раньше, обращайтесь к разработчикам ClickHouse.
-
 ## Улучшения процесса разработки и сборки ClickHouse:
 * Возможность сборки с помощью `pbuilder`.
 * Возможность сборки с использованием `libc++` вместо `libstdc++` под Linux.

From c37a387ff8c50b2d87cf2d143a973399576442e8 Mon Sep 17 00:00:00 2001
From: Evgeny Konkov <konkov@yandex-team.ru>
Date: Thu, 14 Sep 2017 20:13:40 +0300
Subject: [PATCH 203/266] remove control characters from diff output in order
 to properly save diff output in junit xml report files.

---
 dbms/tests/clickhouse-test | 23 ++++++++++++++++++-----
 1 file changed, 18 insertions(+), 5 deletions(-)

diff --git a/dbms/tests/clickhouse-test b/dbms/tests/clickhouse-test
index 86d6fed4e12..64ae054c181 100755
--- a/dbms/tests/clickhouse-test
+++ b/dbms/tests/clickhouse-test
@@ -29,6 +29,19 @@ MSG_OK = OP_SQUARE_BRACKET + colored(" OK ", "green", attrs=['bold']) + CL_SQUAR
 MSG_SKIPPED = OP_SQUARE_BRACKET + colored(" SKIPPED ", "cyan", attrs=['bold']) + CL_SQUARE_BRACKET
 
 
+def remove_control_characters(s):
+    """
+    https://github.com/html5lib/html5lib-python/issues/96#issuecomment-43438438
+    """
+    def str_to_int(s, default, base=10):
+        if int(s, base) < 0x10000:
+            return unichr(int(s, base))
+        return default
+    s = re.sub(ur"&#(\d+);?", lambda c: str_to_int(c.group(1), c.group(0)), s)
+    s = re.sub(ur"&#[xX]([0-9a-fA-F]+);?", lambda c: str_to_int(c.group(1), c.group(0), base=16), s)
+    s = re.sub(ur"[\x00-\x08\x0b\x0e-\x1f\x7f]", "", s)
+    return s
+
 def main(args):
 
     SERVER_DIED = False
@@ -202,14 +215,14 @@ def main(args):
 
                                     failure = et.Element("failure", attrib = {"message": "result differs with reference"})
                                     report_testcase.append(failure)
-
+                                    
+                                    stdout_element = et.Element("system-out")
                                     try:
-                                        stdout_element = et.Element("system-out")
                                         stdout_element.text = et.CDATA(diff)
-                                        report_testcase.append(stdout_element)
                                     except Exception as e:
-                                        print("{0} - test internal error\n{1}".format(MSG_FAIL, e))
-
+                                        stdout_element.text = et.CDATA(remove_control_characters(diff))
+                                    
+                                    report_testcase.append(stdout_element)
                                     failures = failures + 1
                                     print("{0} - result differs with reference:\n{1}".format(MSG_FAIL, diff.encode('utf-8')))
                                 else:

From e95ab368328ba8bd59f0ceb4525039e35a9cb814 Mon Sep 17 00:00:00 2001
From: Evgeny Konkov <konkov@yandex-team.ru>
Date: Fri, 15 Sep 2017 00:35:26 +0300
Subject: [PATCH 204/266] handle test errors

---
 dbms/tests/clickhouse-test | 218 +++++++++++++++++++------------------
 1 file changed, 114 insertions(+), 104 deletions(-)

diff --git a/dbms/tests/clickhouse-test b/dbms/tests/clickhouse-test
index 64ae054c181..43b45e1ec29 100755
--- a/dbms/tests/clickhouse-test
+++ b/dbms/tests/clickhouse-test
@@ -120,119 +120,129 @@ def main(args):
                     (name, ext) = os.path.splitext(case)
                     report_testcase = et.Element("testcase", attrib = {"name": name})
 
-                    print "{0:70}".format(name + ": "),
-                    sys.stdout.flush()
-
-                    if not args.zookeeper and 'zookeeper' in name:
-                        report_testcase.append(et.Element("skipped", attrib = {"message": "no zookeeper"}))
-                        print(MSG_SKIPPED + " - no zookeeper")
-                    elif not args.shard and 'shard' in name:
-                        report_testcase.append(et.Element("skipped", attrib = {"message": "no shard"}))
-                        print(MSG_SKIPPED + " - no shard")
-                    else:
-                        reference_file = os.path.join(suite_dir, name) + '.reference'
-                        stdout_file = os.path.join(suite_dir, name) + '.stdout'
-                        stderr_file = os.path.join(suite_dir, name) + '.stderr'
-
-                        if ext == '.sql':
-                            command = "{0} --multiquery < {1} > {2} 2> {3}".format(args.client, case_file, stdout_file, stderr_file)
+                    try:
+                        print "{0:70}".format(name + ": "),
+                        sys.stdout.flush()
+                        
+                        print 1/0
+    
+                        if not args.zookeeper and 'zookeeper' in name:
+                            report_testcase.append(et.Element("skipped", attrib = {"message": "no zookeeper"}))
+                            print(MSG_SKIPPED + " - no zookeeper")
+                        elif not args.shard and 'shard' in name:
+                            report_testcase.append(et.Element("skipped", attrib = {"message": "no shard"}))
+                            print(MSG_SKIPPED + " - no shard")
                         else:
-                            command = "{0} > {1} 2> {2}".format(case_file, stdout_file, stderr_file)
-
-                        proc = Popen(command, shell = True)
-                        start_time = datetime.now()
-                        while (datetime.now() - start_time).total_seconds() < args.timeout and proc.poll() is None:
-                            sleep(0)
-
-                        if proc.returncode is None:
-                            try:
-                                proc.kill()
-                            except OSError as e:
-                                if e.errno != ESRCH:
-                                    raise
-
-                            failure = et.Element("failure", attrib = {"message": "Timeout"})
-                            report_testcase.append(failure)
-
-                            failures = failures + 1
-                            print("{0} - Timeout!".format(MSG_FAIL))
-                        else:
-                            stdout = open(stdout_file, 'r').read() if os.path.exists(stdout_file) else ''
-                            stdout = unicode(stdout, errors='replace', encoding='utf-8')
-                            stderr = open(stderr_file, 'r').read() if os.path.exists(stderr_file) else ''
-                            stderr = unicode(stderr, errors='replace', encoding='utf-8')
-
-                            if proc.returncode != 0:
-                                failure = et.Element("failure", attrib = {"message": "return code {}".format(proc.returncode)})
+                            reference_file = os.path.join(suite_dir, name) + '.reference'
+                            stdout_file = os.path.join(suite_dir, name) + '.stdout'
+                            stderr_file = os.path.join(suite_dir, name) + '.stderr'
+    
+                            if ext == '.sql':
+                                command = "{0} --multiquery < {1} > {2} 2> {3}".format(args.client, case_file, stdout_file, stderr_file)
+                            else:
+                                command = "{0} > {1} 2> {2}".format(case_file, stdout_file, stderr_file)
+    
+                            proc = Popen(command, shell = True)
+                            start_time = datetime.now()
+                            while (datetime.now() - start_time).total_seconds() < args.timeout and proc.poll() is None:
+                                sleep(0)
+    
+                            if proc.returncode is None:
+                                try:
+                                    proc.kill()
+                                except OSError as e:
+                                    if e.errno != ESRCH:
+                                        raise
+    
+                                failure = et.Element("failure", attrib = {"message": "Timeout"})
                                 report_testcase.append(failure)
-
-                                stdout_element = et.Element("system-out")
-                                stdout_element.text = et.CDATA(stdout)
-                                report_testcase.append(stdout_element)
-
+    
                                 failures = failures + 1
-                                print("{0} - return code {1}".format(MSG_FAIL, proc.returncode))
-
-                                if stderr:
+                                print("{0} - Timeout!".format(MSG_FAIL))
+                            else:
+                                stdout = open(stdout_file, 'r').read() if os.path.exists(stdout_file) else ''
+                                stdout = unicode(stdout, errors='replace', encoding='utf-8')
+                                stderr = open(stderr_file, 'r').read() if os.path.exists(stderr_file) else ''
+                                stderr = unicode(stderr, errors='replace', encoding='utf-8')
+    
+                                if proc.returncode != 0:
+                                    failure = et.Element("failure", attrib = {"message": "return code {}".format(proc.returncode)})
+                                    report_testcase.append(failure)
+    
+                                    stdout_element = et.Element("system-out")
+                                    stdout_element.text = et.CDATA(stdout)
+                                    report_testcase.append(stdout_element)
+    
+                                    failures = failures + 1
+                                    print("{0} - return code {1}".format(MSG_FAIL, proc.returncode))
+    
+                                    if stderr:
+                                        stderr_element = et.Element("system-err")
+                                        stderr_element.text = et.CDATA(stderr)
+                                        report_testcase.append(stderr_element)
+                                        print(stderr)
+    
+                                    if args.stop and ('Connection refused' in stderr or 'Attempt to read after eof' in stderr) and not 'Received exception from server' in stderr:
+                                        SERVER_DIED = True
+    
+                                elif stderr:
+                                    failure = et.Element("failure", attrib = {"message": "having stderror"})
+                                    report_testcase.append(failure)
+    
                                     stderr_element = et.Element("system-err")
                                     stderr_element.text = et.CDATA(stderr)
                                     report_testcase.append(stderr_element)
-                                    print(stderr)
-
-                                if args.stop and ('Connection refused' in stderr or 'Attempt to read after eof' in stderr) and not 'Received exception from server' in stderr:
-                                    SERVER_DIED = True
-
-                            elif stderr:
-                                failure = et.Element("failure", attrib = {"message": "having stderror"})
-                                report_testcase.append(failure)
-
-                                stderr_element = et.Element("system-err")
-                                stderr_element.text = et.CDATA(stderr)
-                                report_testcase.append(stderr_element)
-
-                                failures = failures + 1
-                                print("{0} - having stderror:\n{1}".format(MSG_FAIL, stderr.encode('utf-8')))
-                            elif 'Exception' in stdout:
-                                failure = et.Element("error", attrib = {"message": "having exception"})
-                                report_testcase.append(failure)
-
-                                stdout_element = et.Element("system-out")
-                                stdout_element.text = et.CDATA(stdout)
-                                report_testcase.append(stdout_element)
-
-                                failures = failures + 1
-                                print("{0} - having exception:\n{1}".format(MSG_FAIL, stdout.encode('utf-8')))
-                            elif not os.path.isfile(reference_file):
-                                skipped = et.Element("skipped", attrib = {"message": "no reference file"})
-                                report_testcase.append(skipped)
-                                print("{0} - no reference file".format(MSG_UNKNOWN))
-                            else:
-                                result_is_different = subprocess.call(['cmp', '-s', reference_file, stdout_file], stdout = PIPE)
-
-                                if result_is_different:
-                                    (diff, _) = Popen(['diff', '--side-by-side', reference_file, stdout_file], stdout = PIPE).communicate()
-                                    diff = unicode(diff, errors='replace', encoding='utf-8')
-
-                                    failure = et.Element("failure", attrib = {"message": "result differs with reference"})
-                                    report_testcase.append(failure)
-                                    
-                                    stdout_element = et.Element("system-out")
-                                    try:
-                                        stdout_element.text = et.CDATA(diff)
-                                    except Exception as e:
-                                        stdout_element.text = et.CDATA(remove_control_characters(diff))
-                                    
-                                    report_testcase.append(stdout_element)
+    
                                     failures = failures + 1
-                                    print("{0} - result differs with reference:\n{1}".format(MSG_FAIL, diff.encode('utf-8')))
+                                    print("{0} - having stderror:\n{1}".format(MSG_FAIL, stderr.encode('utf-8')))
+                                elif 'Exception' in stdout:
+                                    failure = et.Element("error", attrib = {"message": "having exception"})
+                                    report_testcase.append(failure)
+    
+                                    stdout_element = et.Element("system-out")
+                                    stdout_element.text = et.CDATA(stdout)
+                                    report_testcase.append(stdout_element)
+    
+                                    failures = failures + 1
+                                    print("{0} - having exception:\n{1}".format(MSG_FAIL, stdout.encode('utf-8')))
+                                elif not os.path.isfile(reference_file):
+                                    skipped = et.Element("skipped", attrib = {"message": "no reference file"})
+                                    report_testcase.append(skipped)
+                                    print("{0} - no reference file".format(MSG_UNKNOWN))
                                 else:
-                                    print(MSG_OK)
-                                    if os.path.exists(stdout_file):
-                                        os.remove(stdout_file)
-                                    if os.path.exists(stderr_file):
-                                        os.remove(stderr_file)
+                                    result_is_different = subprocess.call(['cmp', '-s', reference_file, stdout_file], stdout = PIPE)
+    
+                                    if result_is_different:
+                                        (diff, _) = Popen(['diff', '--side-by-side', reference_file, stdout_file], stdout = PIPE).communicate()
+                                        diff = unicode(diff, errors='replace', encoding='utf-8')
+    
+                                        failure = et.Element("failure", attrib = {"message": "result differs with reference"})
+                                        report_testcase.append(failure)
+                                        
+                                        stdout_element = et.Element("system-out")
+                                        try:
+                                            stdout_element.text = et.CDATA(diff)
+                                        except:
+                                            stdout_element.text = et.CDATA(remove_control_characters(diff))
+                                        
+                                        report_testcase.append(stdout_element)
+                                        failures = failures + 1
+                                        print("{0} - result differs with reference:\n{1}".format(MSG_FAIL, diff.encode('utf-8')))
+                                    else:
+                                        print(MSG_OK)
+                                        if os.path.exists(stdout_file):
+                                            os.remove(stdout_file)
+                                        if os.path.exists(stderr_file):
+                                            os.remove(stderr_file)
+                    except:
+                        (exc_type, exc_value) = sys.exc_info()[:2]
+                        error = et.Element("error", attrib = {"type": exc_type.__name__, "message": str(exc_value)})
+                        report_testcase.append(error)
 
-                    dump_report(args.output, suite, name, report_testcase)
+                        failures = failures + 1
+                        print("{0} - Test internal error: {1}\n{2}".format(MSG_FAIL, exc_type.__name__, exc_value))
+                    finally:
+                        dump_report(args.output, suite, name, report_testcase)
 
             failures_total = failures_total + failures
 

From 6d41f6859c3f02a0b6aae1f684f127ff0228fbcd Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 05:58:17 +0300
Subject: [PATCH 205/266] Imported https://github.com/skywind3000/FastMemcpy at
 a74a33a1fb6d400252ab73e417d12f622dd8fe61 [#CLICKHOUSE-2].

---
 libs/libmemcpy/FastMemcpy.h | 692 ++++++++++++++++++++++++++++++++++++
 libs/libmemcpy/LICENSE      |  22 ++
 libs/libmemcpy/README.md    |  97 +++++
 3 files changed, 811 insertions(+)
 create mode 100644 libs/libmemcpy/FastMemcpy.h
 create mode 100644 libs/libmemcpy/LICENSE
 create mode 100644 libs/libmemcpy/README.md

diff --git a/libs/libmemcpy/FastMemcpy.h b/libs/libmemcpy/FastMemcpy.h
new file mode 100644
index 00000000000..65c249dabc1
--- /dev/null
+++ b/libs/libmemcpy/FastMemcpy.h
@@ -0,0 +1,692 @@
+//=====================================================================
+//
+// FastMemcpy.c - skywind3000@163.com, 2015
+//
+// feature:
+// 50% speed up in avg. vs standard memcpy (tested in vc2012/gcc5.1)
+//
+//=====================================================================
+#ifndef __FAST_MEMCPY_H__
+#define __FAST_MEMCPY_H__
+
+#include <stddef.h>
+#include <stdint.h>
+#include <emmintrin.h>
+
+
+//---------------------------------------------------------------------
+// force inline for compilers
+//---------------------------------------------------------------------
+#ifndef INLINE
+#ifdef __GNUC__
+#if (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))
+    #define INLINE         __inline__ __attribute__((always_inline))
+#else
+    #define INLINE         __inline__
+#endif
+#elif defined(_MSC_VER)
+	#define INLINE __forceinline
+#elif (defined(__BORLANDC__) || defined(__WATCOMC__))
+    #define INLINE __inline
+#else
+    #define INLINE 
+#endif
+#endif
+
+
+
+//---------------------------------------------------------------------
+// fast copy for different sizes
+//---------------------------------------------------------------------
+static INLINE void memcpy_sse2_16(void *dst, const void *src) {
+	__m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+	_mm_storeu_si128(((__m128i*)dst) + 0, m0);
+}
+
+static INLINE void memcpy_sse2_32(void *dst, const void *src) {
+	__m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+	__m128i m1 = _mm_loadu_si128(((const __m128i*)src) + 1);
+	_mm_storeu_si128(((__m128i*)dst) + 0, m0);
+	_mm_storeu_si128(((__m128i*)dst) + 1, m1);
+}
+
+static INLINE void memcpy_sse2_64(void *dst, const void *src) {
+	__m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+	__m128i m1 = _mm_loadu_si128(((const __m128i*)src) + 1);
+	__m128i m2 = _mm_loadu_si128(((const __m128i*)src) + 2);
+	__m128i m3 = _mm_loadu_si128(((const __m128i*)src) + 3);
+	_mm_storeu_si128(((__m128i*)dst) + 0, m0);
+	_mm_storeu_si128(((__m128i*)dst) + 1, m1);
+	_mm_storeu_si128(((__m128i*)dst) + 2, m2);
+	_mm_storeu_si128(((__m128i*)dst) + 3, m3);
+}
+
+static INLINE void memcpy_sse2_128(void *dst, const void *src) {
+	__m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+	__m128i m1 = _mm_loadu_si128(((const __m128i*)src) + 1);
+	__m128i m2 = _mm_loadu_si128(((const __m128i*)src) + 2);
+	__m128i m3 = _mm_loadu_si128(((const __m128i*)src) + 3);
+	__m128i m4 = _mm_loadu_si128(((const __m128i*)src) + 4);
+	__m128i m5 = _mm_loadu_si128(((const __m128i*)src) + 5);
+	__m128i m6 = _mm_loadu_si128(((const __m128i*)src) + 6);
+	__m128i m7 = _mm_loadu_si128(((const __m128i*)src) + 7);
+	_mm_storeu_si128(((__m128i*)dst) + 0, m0);
+	_mm_storeu_si128(((__m128i*)dst) + 1, m1);
+	_mm_storeu_si128(((__m128i*)dst) + 2, m2);
+	_mm_storeu_si128(((__m128i*)dst) + 3, m3);
+	_mm_storeu_si128(((__m128i*)dst) + 4, m4);
+	_mm_storeu_si128(((__m128i*)dst) + 5, m5);
+	_mm_storeu_si128(((__m128i*)dst) + 6, m6);
+	_mm_storeu_si128(((__m128i*)dst) + 7, m7);
+}
+
+
+//---------------------------------------------------------------------
+// tiny memory copy with jump table optimized
+//---------------------------------------------------------------------
+static INLINE void *memcpy_tiny(void *dst, const void *src, size_t size) {
+	unsigned char *dd = ((unsigned char*)dst) + size;
+	const unsigned char *ss = ((const unsigned char*)src) + size;
+
+	switch (size) { 
+	case 64:
+		memcpy_sse2_64(dd - 64, ss - 64);
+	case 0:
+		break;
+
+	case 65:
+		memcpy_sse2_64(dd - 65, ss - 65);
+	case 1:
+		dd[-1] = ss[-1];
+		break;
+
+	case 66:
+		memcpy_sse2_64(dd - 66, ss - 66);
+	case 2:
+		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+		break;
+
+	case 67:
+		memcpy_sse2_64(dd - 67, ss - 67);
+	case 3:
+		*((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
+		dd[-1] = ss[-1];
+		break;
+
+	case 68:
+		memcpy_sse2_64(dd - 68, ss - 68);
+	case 4:
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 69:
+		memcpy_sse2_64(dd - 69, ss - 69);
+	case 5:
+		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+		dd[-1] = ss[-1];
+		break;
+
+	case 70:
+		memcpy_sse2_64(dd - 70, ss - 70);
+	case 6:
+		*((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
+		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+		break;
+
+	case 71:
+		memcpy_sse2_64(dd - 71, ss - 71);
+	case 7:
+		*((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 72:
+		memcpy_sse2_64(dd - 72, ss - 72);
+	case 8:
+		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+		break;
+
+	case 73:
+		memcpy_sse2_64(dd - 73, ss - 73);
+	case 9:
+		*((uint64_t*)(dd - 9)) = *((uint64_t*)(ss - 9));
+		dd[-1] = ss[-1];
+		break;
+
+	case 74:
+		memcpy_sse2_64(dd - 74, ss - 74);
+	case 10:
+		*((uint64_t*)(dd - 10)) = *((uint64_t*)(ss - 10));
+		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+		break;
+
+	case 75:
+		memcpy_sse2_64(dd - 75, ss - 75);
+	case 11:
+		*((uint64_t*)(dd - 11)) = *((uint64_t*)(ss - 11));
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 76:
+		memcpy_sse2_64(dd - 76, ss - 76);
+	case 12:
+		*((uint64_t*)(dd - 12)) = *((uint64_t*)(ss - 12));
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 77:
+		memcpy_sse2_64(dd - 77, ss - 77);
+	case 13:
+		*((uint64_t*)(dd - 13)) = *((uint64_t*)(ss - 13));
+		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+		dd[-1] = ss[-1];
+		break;
+
+	case 78:
+		memcpy_sse2_64(dd - 78, ss - 78);
+	case 14:
+		*((uint64_t*)(dd - 14)) = *((uint64_t*)(ss - 14));
+		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+		break;
+
+	case 79:
+		memcpy_sse2_64(dd - 79, ss - 79);
+	case 15:
+		*((uint64_t*)(dd - 15)) = *((uint64_t*)(ss - 15));
+		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+		break;
+
+	case 80:
+		memcpy_sse2_64(dd - 80, ss - 80);
+	case 16:
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 81:
+		memcpy_sse2_64(dd - 81, ss - 81);
+	case 17:
+		memcpy_sse2_16(dd - 17, ss - 17);
+		dd[-1] = ss[-1];
+		break;
+
+	case 82:
+		memcpy_sse2_64(dd - 82, ss - 82);
+	case 18:
+		memcpy_sse2_16(dd - 18, ss - 18);
+		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+		break;
+
+	case 83:
+		memcpy_sse2_64(dd - 83, ss - 83);
+	case 19:
+		memcpy_sse2_16(dd - 19, ss - 19);
+		*((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
+		dd[-1] = ss[-1];
+		break;
+
+	case 84:
+		memcpy_sse2_64(dd - 84, ss - 84);
+	case 20:
+		memcpy_sse2_16(dd - 20, ss - 20);
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 85:
+		memcpy_sse2_64(dd - 85, ss - 85);
+	case 21:
+		memcpy_sse2_16(dd - 21, ss - 21);
+		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+		dd[-1] = ss[-1];
+		break;
+
+	case 86:
+		memcpy_sse2_64(dd - 86, ss - 86);
+	case 22:
+		memcpy_sse2_16(dd - 22, ss - 22);
+		*((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
+		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+		break;
+
+	case 87:
+		memcpy_sse2_64(dd - 87, ss - 87);
+	case 23:
+		memcpy_sse2_16(dd - 23, ss - 23);
+		*((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 88:
+		memcpy_sse2_64(dd - 88, ss - 88);
+	case 24:
+		memcpy_sse2_16(dd - 24, ss - 24);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 89:
+		memcpy_sse2_64(dd - 89, ss - 89);
+	case 25:
+		memcpy_sse2_16(dd - 25, ss - 25);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 90:
+		memcpy_sse2_64(dd - 90, ss - 90);
+	case 26:
+		memcpy_sse2_16(dd - 26, ss - 26);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 91:
+		memcpy_sse2_64(dd - 91, ss - 91);
+	case 27:
+		memcpy_sse2_16(dd - 27, ss - 27);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 92:
+		memcpy_sse2_64(dd - 92, ss - 92);
+	case 28:
+		memcpy_sse2_16(dd - 28, ss - 28);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 93:
+		memcpy_sse2_64(dd - 93, ss - 93);
+	case 29:
+		memcpy_sse2_16(dd - 29, ss - 29);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 94:
+		memcpy_sse2_64(dd - 94, ss - 94);
+	case 30:
+		memcpy_sse2_16(dd - 30, ss - 30);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 95:
+		memcpy_sse2_64(dd - 95, ss - 95);
+	case 31:
+		memcpy_sse2_16(dd - 31, ss - 31);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 96:
+		memcpy_sse2_64(dd - 96, ss - 96);
+	case 32:
+		memcpy_sse2_32(dd - 32, ss - 32);
+		break;
+
+	case 97:
+		memcpy_sse2_64(dd - 97, ss - 97);
+	case 33:
+		memcpy_sse2_32(dd - 33, ss - 33);
+		dd[-1] = ss[-1];
+		break;
+
+	case 98:
+		memcpy_sse2_64(dd - 98, ss - 98);
+	case 34:
+		memcpy_sse2_32(dd - 34, ss - 34);
+		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+		break;
+
+	case 99:
+		memcpy_sse2_64(dd - 99, ss - 99);
+	case 35:
+		memcpy_sse2_32(dd - 35, ss - 35);
+		*((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
+		dd[-1] = ss[-1];
+		break;
+
+	case 100:
+		memcpy_sse2_64(dd - 100, ss - 100);
+	case 36:
+		memcpy_sse2_32(dd - 36, ss - 36);
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 101:
+		memcpy_sse2_64(dd - 101, ss - 101);
+	case 37:
+		memcpy_sse2_32(dd - 37, ss - 37);
+		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+		dd[-1] = ss[-1];
+		break;
+
+	case 102:
+		memcpy_sse2_64(dd - 102, ss - 102);
+	case 38:
+		memcpy_sse2_32(dd - 38, ss - 38);
+		*((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
+		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+		break;
+
+	case 103:
+		memcpy_sse2_64(dd - 103, ss - 103);
+	case 39:
+		memcpy_sse2_32(dd - 39, ss - 39);
+		*((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 104:
+		memcpy_sse2_64(dd - 104, ss - 104);
+	case 40:
+		memcpy_sse2_32(dd - 40, ss - 40);
+		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+		break;
+
+	case 105:
+		memcpy_sse2_64(dd - 105, ss - 105);
+	case 41:
+		memcpy_sse2_32(dd - 41, ss - 41);
+		*((uint64_t*)(dd - 9)) = *((uint64_t*)(ss - 9));
+		dd[-1] = ss[-1];
+		break;
+
+	case 106:
+		memcpy_sse2_64(dd - 106, ss - 106);
+	case 42:
+		memcpy_sse2_32(dd - 42, ss - 42);
+		*((uint64_t*)(dd - 10)) = *((uint64_t*)(ss - 10));
+		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+		break;
+
+	case 107:
+		memcpy_sse2_64(dd - 107, ss - 107);
+	case 43:
+		memcpy_sse2_32(dd - 43, ss - 43);
+		*((uint64_t*)(dd - 11)) = *((uint64_t*)(ss - 11));
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 108:
+		memcpy_sse2_64(dd - 108, ss - 108);
+	case 44:
+		memcpy_sse2_32(dd - 44, ss - 44);
+		*((uint64_t*)(dd - 12)) = *((uint64_t*)(ss - 12));
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 109:
+		memcpy_sse2_64(dd - 109, ss - 109);
+	case 45:
+		memcpy_sse2_32(dd - 45, ss - 45);
+		*((uint64_t*)(dd - 13)) = *((uint64_t*)(ss - 13));
+		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+		dd[-1] = ss[-1];
+		break;
+
+	case 110:
+		memcpy_sse2_64(dd - 110, ss - 110);
+	case 46:
+		memcpy_sse2_32(dd - 46, ss - 46);
+		*((uint64_t*)(dd - 14)) = *((uint64_t*)(ss - 14));
+		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+		break;
+
+	case 111:
+		memcpy_sse2_64(dd - 111, ss - 111);
+	case 47:
+		memcpy_sse2_32(dd - 47, ss - 47);
+		*((uint64_t*)(dd - 15)) = *((uint64_t*)(ss - 15));
+		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+		break;
+
+	case 112:
+		memcpy_sse2_64(dd - 112, ss - 112);
+	case 48:
+		memcpy_sse2_32(dd - 48, ss - 48);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 113:
+		memcpy_sse2_64(dd - 113, ss - 113);
+	case 49:
+		memcpy_sse2_32(dd - 49, ss - 49);
+		memcpy_sse2_16(dd - 17, ss - 17);
+		dd[-1] = ss[-1];
+		break;
+
+	case 114:
+		memcpy_sse2_64(dd - 114, ss - 114);
+	case 50:
+		memcpy_sse2_32(dd - 50, ss - 50);
+		memcpy_sse2_16(dd - 18, ss - 18);
+		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+		break;
+
+	case 115:
+		memcpy_sse2_64(dd - 115, ss - 115);
+	case 51:
+		memcpy_sse2_32(dd - 51, ss - 51);
+		memcpy_sse2_16(dd - 19, ss - 19);
+		*((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
+		dd[-1] = ss[-1];
+		break;
+
+	case 116:
+		memcpy_sse2_64(dd - 116, ss - 116);
+	case 52:
+		memcpy_sse2_32(dd - 52, ss - 52);
+		memcpy_sse2_16(dd - 20, ss - 20);
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 117:
+		memcpy_sse2_64(dd - 117, ss - 117);
+	case 53:
+		memcpy_sse2_32(dd - 53, ss - 53);
+		memcpy_sse2_16(dd - 21, ss - 21);
+		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+		dd[-1] = ss[-1];
+		break;
+
+	case 118:
+		memcpy_sse2_64(dd - 118, ss - 118);
+	case 54:
+		memcpy_sse2_32(dd - 54, ss - 54);
+		memcpy_sse2_16(dd - 22, ss - 22);
+		*((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
+		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+		break;
+
+	case 119:
+		memcpy_sse2_64(dd - 119, ss - 119);
+	case 55:
+		memcpy_sse2_32(dd - 55, ss - 55);
+		memcpy_sse2_16(dd - 23, ss - 23);
+		*((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 120:
+		memcpy_sse2_64(dd - 120, ss - 120);
+	case 56:
+		memcpy_sse2_32(dd - 56, ss - 56);
+		memcpy_sse2_16(dd - 24, ss - 24);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 121:
+		memcpy_sse2_64(dd - 121, ss - 121);
+	case 57:
+		memcpy_sse2_32(dd - 57, ss - 57);
+		memcpy_sse2_16(dd - 25, ss - 25);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 122:
+		memcpy_sse2_64(dd - 122, ss - 122);
+	case 58:
+		memcpy_sse2_32(dd - 58, ss - 58);
+		memcpy_sse2_16(dd - 26, ss - 26);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 123:
+		memcpy_sse2_64(dd - 123, ss - 123);
+	case 59:
+		memcpy_sse2_32(dd - 59, ss - 59);
+		memcpy_sse2_16(dd - 27, ss - 27);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 124:
+		memcpy_sse2_64(dd - 124, ss - 124);
+	case 60:
+		memcpy_sse2_32(dd - 60, ss - 60);
+		memcpy_sse2_16(dd - 28, ss - 28);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 125:
+		memcpy_sse2_64(dd - 125, ss - 125);
+	case 61:
+		memcpy_sse2_32(dd - 61, ss - 61);
+		memcpy_sse2_16(dd - 29, ss - 29);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 126:
+		memcpy_sse2_64(dd - 126, ss - 126);
+	case 62:
+		memcpy_sse2_32(dd - 62, ss - 62);
+		memcpy_sse2_16(dd - 30, ss - 30);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 127:
+		memcpy_sse2_64(dd - 127, ss - 127);
+	case 63:
+		memcpy_sse2_32(dd - 63, ss - 63);
+		memcpy_sse2_16(dd - 31, ss - 31);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 128:
+		memcpy_sse2_128(dd - 128, ss - 128);
+		break;
+	}
+
+	return dst;
+}
+
+
+//---------------------------------------------------------------------
+// main routine
+//---------------------------------------------------------------------
+static void* memcpy_fast(void *destination, const void *source, size_t size)
+{
+	unsigned char *dst = (unsigned char*)destination;
+	const unsigned char *src = (const unsigned char*)source;
+	static size_t cachesize = 0x200000; // L2-cache size
+	size_t padding;
+
+	// small memory copy
+	if (size <= 128) {
+		return memcpy_tiny(dst, src, size);
+	}
+
+	// align destination to 16 bytes boundary
+	padding = (16 - (((size_t)dst) & 15)) & 15;
+
+	if (padding > 0) {
+		__m128i head = _mm_loadu_si128((const __m128i*)src);
+		_mm_storeu_si128((__m128i*)dst, head);
+		dst += padding;
+		src += padding;
+		size -= padding;
+	}
+
+	// medium size copy
+	if (size <= cachesize) {
+		__m128i c0, c1, c2, c3, c4, c5, c6, c7;
+
+		for (; size >= 128; size -= 128) {
+			c0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+			c1 = _mm_loadu_si128(((const __m128i*)src) + 1);
+			c2 = _mm_loadu_si128(((const __m128i*)src) + 2);
+			c3 = _mm_loadu_si128(((const __m128i*)src) + 3);
+			c4 = _mm_loadu_si128(((const __m128i*)src) + 4);
+			c5 = _mm_loadu_si128(((const __m128i*)src) + 5);
+			c6 = _mm_loadu_si128(((const __m128i*)src) + 6);
+			c7 = _mm_loadu_si128(((const __m128i*)src) + 7);
+			_mm_prefetch((const char*)(src + 256), _MM_HINT_NTA);
+			src += 128;
+			_mm_store_si128((((__m128i*)dst) + 0), c0);
+			_mm_store_si128((((__m128i*)dst) + 1), c1);
+			_mm_store_si128((((__m128i*)dst) + 2), c2);
+			_mm_store_si128((((__m128i*)dst) + 3), c3);
+			_mm_store_si128((((__m128i*)dst) + 4), c4);
+			_mm_store_si128((((__m128i*)dst) + 5), c5);
+			_mm_store_si128((((__m128i*)dst) + 6), c6);
+			_mm_store_si128((((__m128i*)dst) + 7), c7);
+			dst += 128;
+		}
+	}
+	else {		// big memory copy
+		__m128i c0, c1, c2, c3, c4, c5, c6, c7;
+
+		_mm_prefetch((const char*)(src), _MM_HINT_NTA);
+
+		if ((((size_t)src) & 15) == 0) {	// source aligned
+			for (; size >= 128; size -= 128) {
+				c0 = _mm_load_si128(((const __m128i*)src) + 0);
+				c1 = _mm_load_si128(((const __m128i*)src) + 1);
+				c2 = _mm_load_si128(((const __m128i*)src) + 2);
+				c3 = _mm_load_si128(((const __m128i*)src) + 3);
+				c4 = _mm_load_si128(((const __m128i*)src) + 4);
+				c5 = _mm_load_si128(((const __m128i*)src) + 5);
+				c6 = _mm_load_si128(((const __m128i*)src) + 6);
+				c7 = _mm_load_si128(((const __m128i*)src) + 7);
+				_mm_prefetch((const char*)(src + 256), _MM_HINT_NTA);
+				src += 128;
+				_mm_stream_si128((((__m128i*)dst) + 0), c0);
+				_mm_stream_si128((((__m128i*)dst) + 1), c1);
+				_mm_stream_si128((((__m128i*)dst) + 2), c2);
+				_mm_stream_si128((((__m128i*)dst) + 3), c3);
+				_mm_stream_si128((((__m128i*)dst) + 4), c4);
+				_mm_stream_si128((((__m128i*)dst) + 5), c5);
+				_mm_stream_si128((((__m128i*)dst) + 6), c6);
+				_mm_stream_si128((((__m128i*)dst) + 7), c7);
+				dst += 128;
+			}
+		}
+		else {							// source unaligned
+			for (; size >= 128; size -= 128) {
+				c0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+				c1 = _mm_loadu_si128(((const __m128i*)src) + 1);
+				c2 = _mm_loadu_si128(((const __m128i*)src) + 2);
+				c3 = _mm_loadu_si128(((const __m128i*)src) + 3);
+				c4 = _mm_loadu_si128(((const __m128i*)src) + 4);
+				c5 = _mm_loadu_si128(((const __m128i*)src) + 5);
+				c6 = _mm_loadu_si128(((const __m128i*)src) + 6);
+				c7 = _mm_loadu_si128(((const __m128i*)src) + 7);
+				_mm_prefetch((const char*)(src + 256), _MM_HINT_NTA);
+				src += 128;
+				_mm_stream_si128((((__m128i*)dst) + 0), c0);
+				_mm_stream_si128((((__m128i*)dst) + 1), c1);
+				_mm_stream_si128((((__m128i*)dst) + 2), c2);
+				_mm_stream_si128((((__m128i*)dst) + 3), c3);
+				_mm_stream_si128((((__m128i*)dst) + 4), c4);
+				_mm_stream_si128((((__m128i*)dst) + 5), c5);
+				_mm_stream_si128((((__m128i*)dst) + 6), c6);
+				_mm_stream_si128((((__m128i*)dst) + 7), c7);
+				dst += 128;
+			}
+		}
+		_mm_sfence();
+	}
+
+	memcpy_tiny(dst, src, size);
+
+	return destination;
+}
+
+
+#endif
+
+
+
diff --git a/libs/libmemcpy/LICENSE b/libs/libmemcpy/LICENSE
new file mode 100644
index 00000000000..c449da6aa8a
--- /dev/null
+++ b/libs/libmemcpy/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Linwei
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
diff --git a/libs/libmemcpy/README.md b/libs/libmemcpy/README.md
new file mode 100644
index 00000000000..2c63dc21a81
--- /dev/null
+++ b/libs/libmemcpy/README.md
@@ -0,0 +1,97 @@
+Build
+=====
+
+with gcc:
+> gcc -O3 -msse2 FastMemcpy.c -o FastMemcpy
+
+with msvc:
+> cl -nologo -O2 FastMemcpy.c
+
+Features
+========
+
+* 50% speedup in avg. vs traditional memcpy in msvc 2012 or gcc 4.9
+* small size copy optimized with jump table
+* medium size copy optimized with sse2 vector copy 
+* huge size copy optimized with cache prefetch & movntdq
+
+Reference
+=========
+
+[Using Block Prefetch for Optimized Memory Performance](http://files.rsdn.ru/23380/AMD_block_prefetch_paper.pdf)
+
+The artical only focused on aligned huge memory copy. You need handle other conditions by your self.
+
+
+Results
+=======
+
+```
+result: gcc4.9 (msvc 2012 got a similar result):
+ 
+benchmark(size=32 bytes, times=16777216):
+result(dst aligned, src aligned): memcpy_fast=81ms memcpy=281 ms
+result(dst aligned, src unalign): memcpy_fast=88ms memcpy=254 ms
+result(dst unalign, src aligned): memcpy_fast=87ms memcpy=245 ms
+result(dst unalign, src unalign): memcpy_fast=81ms memcpy=258 ms
+
+benchmark(size=64 bytes, times=16777216):
+result(dst aligned, src aligned): memcpy_fast=91ms memcpy=364 ms
+result(dst aligned, src unalign): memcpy_fast=95ms memcpy=336 ms
+result(dst unalign, src aligned): memcpy_fast=96ms memcpy=353 ms
+result(dst unalign, src unalign): memcpy_fast=99ms memcpy=346 ms
+
+benchmark(size=512 bytes, times=8388608):
+result(dst aligned, src aligned): memcpy_fast=124ms memcpy=242 ms
+result(dst aligned, src unalign): memcpy_fast=166ms memcpy=555 ms
+result(dst unalign, src aligned): memcpy_fast=168ms memcpy=602 ms
+result(dst unalign, src unalign): memcpy_fast=174ms memcpy=614 ms
+
+benchmark(size=1024 bytes, times=4194304):
+result(dst aligned, src aligned): memcpy_fast=119ms memcpy=171 ms
+result(dst aligned, src unalign): memcpy_fast=182ms memcpy=442 ms
+result(dst unalign, src aligned): memcpy_fast=163ms memcpy=466 ms
+result(dst unalign, src unalign): memcpy_fast=168ms memcpy=472 ms
+
+benchmark(size=4096 bytes, times=524288):
+result(dst aligned, src aligned): memcpy_fast=68ms memcpy=82 ms
+result(dst aligned, src unalign): memcpy_fast=94ms memcpy=226 ms
+result(dst unalign, src aligned): memcpy_fast=134ms memcpy=216 ms
+result(dst unalign, src unalign): memcpy_fast=84ms memcpy=188 ms
+
+benchmark(size=8192 bytes, times=262144):
+result(dst aligned, src aligned): memcpy_fast=55ms memcpy=70 ms
+result(dst aligned, src unalign): memcpy_fast=75ms memcpy=192 ms
+result(dst unalign, src aligned): memcpy_fast=79ms memcpy=223 ms
+result(dst unalign, src unalign): memcpy_fast=91ms memcpy=219 ms
+
+benchmark(size=1048576 bytes, times=2048):
+result(dst aligned, src aligned): memcpy_fast=181ms memcpy=165 ms
+result(dst aligned, src unalign): memcpy_fast=192ms memcpy=303 ms
+result(dst unalign, src aligned): memcpy_fast=218ms memcpy=310 ms
+result(dst unalign, src unalign): memcpy_fast=183ms memcpy=307 ms
+
+benchmark(size=4194304 bytes, times=512):
+result(dst aligned, src aligned): memcpy_fast=263ms memcpy=398 ms
+result(dst aligned, src unalign): memcpy_fast=269ms memcpy=433 ms
+result(dst unalign, src aligned): memcpy_fast=306ms memcpy=497 ms
+result(dst unalign, src unalign): memcpy_fast=285ms memcpy=417 ms
+
+benchmark(size=8388608 bytes, times=256):
+result(dst aligned, src aligned): memcpy_fast=287ms memcpy=421 ms
+result(dst aligned, src unalign): memcpy_fast=288ms memcpy=430 ms
+result(dst unalign, src aligned): memcpy_fast=285ms memcpy=510 ms
+result(dst unalign, src unalign): memcpy_fast=291ms memcpy=440 ms
+
+benchmark random access:
+memcpy_fast=487ms memcpy=1000ms
+
+```
+
+
+About
+=====
+
+skywind
+
+http://www.skywind.me

From 347cf3092b8ef9c4c7c91dc401c9e24c8a835d35 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 06:00:06 +0300
Subject: [PATCH 206/266] Modified whitespaces [#CLICKHOUSE-2].

---
 libs/libmemcpy/FastMemcpy.h | 1384 +++++++++++++++++------------------
 libs/libmemcpy/README.md    |   16 +-
 2 files changed, 700 insertions(+), 700 deletions(-)

diff --git a/libs/libmemcpy/FastMemcpy.h b/libs/libmemcpy/FastMemcpy.h
index 65c249dabc1..306bd19ac58 100644
--- a/libs/libmemcpy/FastMemcpy.h
+++ b/libs/libmemcpy/FastMemcpy.h
@@ -1,692 +1,692 @@
-//=====================================================================
-//
-// FastMemcpy.c - skywind3000@163.com, 2015
-//
-// feature:
-// 50% speed up in avg. vs standard memcpy (tested in vc2012/gcc5.1)
-//
-//=====================================================================
-#ifndef __FAST_MEMCPY_H__
-#define __FAST_MEMCPY_H__
-
-#include <stddef.h>
-#include <stdint.h>
-#include <emmintrin.h>
-
-
-//---------------------------------------------------------------------
-// force inline for compilers
-//---------------------------------------------------------------------
-#ifndef INLINE
-#ifdef __GNUC__
-#if (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))
-    #define INLINE         __inline__ __attribute__((always_inline))
-#else
-    #define INLINE         __inline__
-#endif
-#elif defined(_MSC_VER)
-	#define INLINE __forceinline
-#elif (defined(__BORLANDC__) || defined(__WATCOMC__))
-    #define INLINE __inline
-#else
-    #define INLINE 
-#endif
-#endif
-
-
-
-//---------------------------------------------------------------------
-// fast copy for different sizes
-//---------------------------------------------------------------------
-static INLINE void memcpy_sse2_16(void *dst, const void *src) {
-	__m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
-	_mm_storeu_si128(((__m128i*)dst) + 0, m0);
-}
-
-static INLINE void memcpy_sse2_32(void *dst, const void *src) {
-	__m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
-	__m128i m1 = _mm_loadu_si128(((const __m128i*)src) + 1);
-	_mm_storeu_si128(((__m128i*)dst) + 0, m0);
-	_mm_storeu_si128(((__m128i*)dst) + 1, m1);
-}
-
-static INLINE void memcpy_sse2_64(void *dst, const void *src) {
-	__m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
-	__m128i m1 = _mm_loadu_si128(((const __m128i*)src) + 1);
-	__m128i m2 = _mm_loadu_si128(((const __m128i*)src) + 2);
-	__m128i m3 = _mm_loadu_si128(((const __m128i*)src) + 3);
-	_mm_storeu_si128(((__m128i*)dst) + 0, m0);
-	_mm_storeu_si128(((__m128i*)dst) + 1, m1);
-	_mm_storeu_si128(((__m128i*)dst) + 2, m2);
-	_mm_storeu_si128(((__m128i*)dst) + 3, m3);
-}
-
-static INLINE void memcpy_sse2_128(void *dst, const void *src) {
-	__m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
-	__m128i m1 = _mm_loadu_si128(((const __m128i*)src) + 1);
-	__m128i m2 = _mm_loadu_si128(((const __m128i*)src) + 2);
-	__m128i m3 = _mm_loadu_si128(((const __m128i*)src) + 3);
-	__m128i m4 = _mm_loadu_si128(((const __m128i*)src) + 4);
-	__m128i m5 = _mm_loadu_si128(((const __m128i*)src) + 5);
-	__m128i m6 = _mm_loadu_si128(((const __m128i*)src) + 6);
-	__m128i m7 = _mm_loadu_si128(((const __m128i*)src) + 7);
-	_mm_storeu_si128(((__m128i*)dst) + 0, m0);
-	_mm_storeu_si128(((__m128i*)dst) + 1, m1);
-	_mm_storeu_si128(((__m128i*)dst) + 2, m2);
-	_mm_storeu_si128(((__m128i*)dst) + 3, m3);
-	_mm_storeu_si128(((__m128i*)dst) + 4, m4);
-	_mm_storeu_si128(((__m128i*)dst) + 5, m5);
-	_mm_storeu_si128(((__m128i*)dst) + 6, m6);
-	_mm_storeu_si128(((__m128i*)dst) + 7, m7);
-}
-
-
-//---------------------------------------------------------------------
-// tiny memory copy with jump table optimized
-//---------------------------------------------------------------------
-static INLINE void *memcpy_tiny(void *dst, const void *src, size_t size) {
-	unsigned char *dd = ((unsigned char*)dst) + size;
-	const unsigned char *ss = ((const unsigned char*)src) + size;
-
-	switch (size) { 
-	case 64:
-		memcpy_sse2_64(dd - 64, ss - 64);
-	case 0:
-		break;
-
-	case 65:
-		memcpy_sse2_64(dd - 65, ss - 65);
-	case 1:
-		dd[-1] = ss[-1];
-		break;
-
-	case 66:
-		memcpy_sse2_64(dd - 66, ss - 66);
-	case 2:
-		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
-		break;
-
-	case 67:
-		memcpy_sse2_64(dd - 67, ss - 67);
-	case 3:
-		*((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
-		dd[-1] = ss[-1];
-		break;
-
-	case 68:
-		memcpy_sse2_64(dd - 68, ss - 68);
-	case 4:
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 69:
-		memcpy_sse2_64(dd - 69, ss - 69);
-	case 5:
-		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
-		dd[-1] = ss[-1];
-		break;
-
-	case 70:
-		memcpy_sse2_64(dd - 70, ss - 70);
-	case 6:
-		*((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
-		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
-		break;
-
-	case 71:
-		memcpy_sse2_64(dd - 71, ss - 71);
-	case 7:
-		*((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 72:
-		memcpy_sse2_64(dd - 72, ss - 72);
-	case 8:
-		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
-		break;
-
-	case 73:
-		memcpy_sse2_64(dd - 73, ss - 73);
-	case 9:
-		*((uint64_t*)(dd - 9)) = *((uint64_t*)(ss - 9));
-		dd[-1] = ss[-1];
-		break;
-
-	case 74:
-		memcpy_sse2_64(dd - 74, ss - 74);
-	case 10:
-		*((uint64_t*)(dd - 10)) = *((uint64_t*)(ss - 10));
-		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
-		break;
-
-	case 75:
-		memcpy_sse2_64(dd - 75, ss - 75);
-	case 11:
-		*((uint64_t*)(dd - 11)) = *((uint64_t*)(ss - 11));
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 76:
-		memcpy_sse2_64(dd - 76, ss - 76);
-	case 12:
-		*((uint64_t*)(dd - 12)) = *((uint64_t*)(ss - 12));
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 77:
-		memcpy_sse2_64(dd - 77, ss - 77);
-	case 13:
-		*((uint64_t*)(dd - 13)) = *((uint64_t*)(ss - 13));
-		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
-		dd[-1] = ss[-1];
-		break;
-
-	case 78:
-		memcpy_sse2_64(dd - 78, ss - 78);
-	case 14:
-		*((uint64_t*)(dd - 14)) = *((uint64_t*)(ss - 14));
-		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
-		break;
-
-	case 79:
-		memcpy_sse2_64(dd - 79, ss - 79);
-	case 15:
-		*((uint64_t*)(dd - 15)) = *((uint64_t*)(ss - 15));
-		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
-		break;
-
-	case 80:
-		memcpy_sse2_64(dd - 80, ss - 80);
-	case 16:
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 81:
-		memcpy_sse2_64(dd - 81, ss - 81);
-	case 17:
-		memcpy_sse2_16(dd - 17, ss - 17);
-		dd[-1] = ss[-1];
-		break;
-
-	case 82:
-		memcpy_sse2_64(dd - 82, ss - 82);
-	case 18:
-		memcpy_sse2_16(dd - 18, ss - 18);
-		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
-		break;
-
-	case 83:
-		memcpy_sse2_64(dd - 83, ss - 83);
-	case 19:
-		memcpy_sse2_16(dd - 19, ss - 19);
-		*((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
-		dd[-1] = ss[-1];
-		break;
-
-	case 84:
-		memcpy_sse2_64(dd - 84, ss - 84);
-	case 20:
-		memcpy_sse2_16(dd - 20, ss - 20);
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 85:
-		memcpy_sse2_64(dd - 85, ss - 85);
-	case 21:
-		memcpy_sse2_16(dd - 21, ss - 21);
-		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
-		dd[-1] = ss[-1];
-		break;
-
-	case 86:
-		memcpy_sse2_64(dd - 86, ss - 86);
-	case 22:
-		memcpy_sse2_16(dd - 22, ss - 22);
-		*((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
-		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
-		break;
-
-	case 87:
-		memcpy_sse2_64(dd - 87, ss - 87);
-	case 23:
-		memcpy_sse2_16(dd - 23, ss - 23);
-		*((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 88:
-		memcpy_sse2_64(dd - 88, ss - 88);
-	case 24:
-		memcpy_sse2_16(dd - 24, ss - 24);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 89:
-		memcpy_sse2_64(dd - 89, ss - 89);
-	case 25:
-		memcpy_sse2_16(dd - 25, ss - 25);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 90:
-		memcpy_sse2_64(dd - 90, ss - 90);
-	case 26:
-		memcpy_sse2_16(dd - 26, ss - 26);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 91:
-		memcpy_sse2_64(dd - 91, ss - 91);
-	case 27:
-		memcpy_sse2_16(dd - 27, ss - 27);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 92:
-		memcpy_sse2_64(dd - 92, ss - 92);
-	case 28:
-		memcpy_sse2_16(dd - 28, ss - 28);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 93:
-		memcpy_sse2_64(dd - 93, ss - 93);
-	case 29:
-		memcpy_sse2_16(dd - 29, ss - 29);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 94:
-		memcpy_sse2_64(dd - 94, ss - 94);
-	case 30:
-		memcpy_sse2_16(dd - 30, ss - 30);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 95:
-		memcpy_sse2_64(dd - 95, ss - 95);
-	case 31:
-		memcpy_sse2_16(dd - 31, ss - 31);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 96:
-		memcpy_sse2_64(dd - 96, ss - 96);
-	case 32:
-		memcpy_sse2_32(dd - 32, ss - 32);
-		break;
-
-	case 97:
-		memcpy_sse2_64(dd - 97, ss - 97);
-	case 33:
-		memcpy_sse2_32(dd - 33, ss - 33);
-		dd[-1] = ss[-1];
-		break;
-
-	case 98:
-		memcpy_sse2_64(dd - 98, ss - 98);
-	case 34:
-		memcpy_sse2_32(dd - 34, ss - 34);
-		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
-		break;
-
-	case 99:
-		memcpy_sse2_64(dd - 99, ss - 99);
-	case 35:
-		memcpy_sse2_32(dd - 35, ss - 35);
-		*((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
-		dd[-1] = ss[-1];
-		break;
-
-	case 100:
-		memcpy_sse2_64(dd - 100, ss - 100);
-	case 36:
-		memcpy_sse2_32(dd - 36, ss - 36);
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 101:
-		memcpy_sse2_64(dd - 101, ss - 101);
-	case 37:
-		memcpy_sse2_32(dd - 37, ss - 37);
-		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
-		dd[-1] = ss[-1];
-		break;
-
-	case 102:
-		memcpy_sse2_64(dd - 102, ss - 102);
-	case 38:
-		memcpy_sse2_32(dd - 38, ss - 38);
-		*((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
-		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
-		break;
-
-	case 103:
-		memcpy_sse2_64(dd - 103, ss - 103);
-	case 39:
-		memcpy_sse2_32(dd - 39, ss - 39);
-		*((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 104:
-		memcpy_sse2_64(dd - 104, ss - 104);
-	case 40:
-		memcpy_sse2_32(dd - 40, ss - 40);
-		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
-		break;
-
-	case 105:
-		memcpy_sse2_64(dd - 105, ss - 105);
-	case 41:
-		memcpy_sse2_32(dd - 41, ss - 41);
-		*((uint64_t*)(dd - 9)) = *((uint64_t*)(ss - 9));
-		dd[-1] = ss[-1];
-		break;
-
-	case 106:
-		memcpy_sse2_64(dd - 106, ss - 106);
-	case 42:
-		memcpy_sse2_32(dd - 42, ss - 42);
-		*((uint64_t*)(dd - 10)) = *((uint64_t*)(ss - 10));
-		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
-		break;
-
-	case 107:
-		memcpy_sse2_64(dd - 107, ss - 107);
-	case 43:
-		memcpy_sse2_32(dd - 43, ss - 43);
-		*((uint64_t*)(dd - 11)) = *((uint64_t*)(ss - 11));
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 108:
-		memcpy_sse2_64(dd - 108, ss - 108);
-	case 44:
-		memcpy_sse2_32(dd - 44, ss - 44);
-		*((uint64_t*)(dd - 12)) = *((uint64_t*)(ss - 12));
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 109:
-		memcpy_sse2_64(dd - 109, ss - 109);
-	case 45:
-		memcpy_sse2_32(dd - 45, ss - 45);
-		*((uint64_t*)(dd - 13)) = *((uint64_t*)(ss - 13));
-		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
-		dd[-1] = ss[-1];
-		break;
-
-	case 110:
-		memcpy_sse2_64(dd - 110, ss - 110);
-	case 46:
-		memcpy_sse2_32(dd - 46, ss - 46);
-		*((uint64_t*)(dd - 14)) = *((uint64_t*)(ss - 14));
-		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
-		break;
-
-	case 111:
-		memcpy_sse2_64(dd - 111, ss - 111);
-	case 47:
-		memcpy_sse2_32(dd - 47, ss - 47);
-		*((uint64_t*)(dd - 15)) = *((uint64_t*)(ss - 15));
-		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
-		break;
-
-	case 112:
-		memcpy_sse2_64(dd - 112, ss - 112);
-	case 48:
-		memcpy_sse2_32(dd - 48, ss - 48);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 113:
-		memcpy_sse2_64(dd - 113, ss - 113);
-	case 49:
-		memcpy_sse2_32(dd - 49, ss - 49);
-		memcpy_sse2_16(dd - 17, ss - 17);
-		dd[-1] = ss[-1];
-		break;
-
-	case 114:
-		memcpy_sse2_64(dd - 114, ss - 114);
-	case 50:
-		memcpy_sse2_32(dd - 50, ss - 50);
-		memcpy_sse2_16(dd - 18, ss - 18);
-		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
-		break;
-
-	case 115:
-		memcpy_sse2_64(dd - 115, ss - 115);
-	case 51:
-		memcpy_sse2_32(dd - 51, ss - 51);
-		memcpy_sse2_16(dd - 19, ss - 19);
-		*((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
-		dd[-1] = ss[-1];
-		break;
-
-	case 116:
-		memcpy_sse2_64(dd - 116, ss - 116);
-	case 52:
-		memcpy_sse2_32(dd - 52, ss - 52);
-		memcpy_sse2_16(dd - 20, ss - 20);
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 117:
-		memcpy_sse2_64(dd - 117, ss - 117);
-	case 53:
-		memcpy_sse2_32(dd - 53, ss - 53);
-		memcpy_sse2_16(dd - 21, ss - 21);
-		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
-		dd[-1] = ss[-1];
-		break;
-
-	case 118:
-		memcpy_sse2_64(dd - 118, ss - 118);
-	case 54:
-		memcpy_sse2_32(dd - 54, ss - 54);
-		memcpy_sse2_16(dd - 22, ss - 22);
-		*((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
-		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
-		break;
-
-	case 119:
-		memcpy_sse2_64(dd - 119, ss - 119);
-	case 55:
-		memcpy_sse2_32(dd - 55, ss - 55);
-		memcpy_sse2_16(dd - 23, ss - 23);
-		*((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 120:
-		memcpy_sse2_64(dd - 120, ss - 120);
-	case 56:
-		memcpy_sse2_32(dd - 56, ss - 56);
-		memcpy_sse2_16(dd - 24, ss - 24);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 121:
-		memcpy_sse2_64(dd - 121, ss - 121);
-	case 57:
-		memcpy_sse2_32(dd - 57, ss - 57);
-		memcpy_sse2_16(dd - 25, ss - 25);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 122:
-		memcpy_sse2_64(dd - 122, ss - 122);
-	case 58:
-		memcpy_sse2_32(dd - 58, ss - 58);
-		memcpy_sse2_16(dd - 26, ss - 26);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 123:
-		memcpy_sse2_64(dd - 123, ss - 123);
-	case 59:
-		memcpy_sse2_32(dd - 59, ss - 59);
-		memcpy_sse2_16(dd - 27, ss - 27);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 124:
-		memcpy_sse2_64(dd - 124, ss - 124);
-	case 60:
-		memcpy_sse2_32(dd - 60, ss - 60);
-		memcpy_sse2_16(dd - 28, ss - 28);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 125:
-		memcpy_sse2_64(dd - 125, ss - 125);
-	case 61:
-		memcpy_sse2_32(dd - 61, ss - 61);
-		memcpy_sse2_16(dd - 29, ss - 29);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 126:
-		memcpy_sse2_64(dd - 126, ss - 126);
-	case 62:
-		memcpy_sse2_32(dd - 62, ss - 62);
-		memcpy_sse2_16(dd - 30, ss - 30);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 127:
-		memcpy_sse2_64(dd - 127, ss - 127);
-	case 63:
-		memcpy_sse2_32(dd - 63, ss - 63);
-		memcpy_sse2_16(dd - 31, ss - 31);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 128:
-		memcpy_sse2_128(dd - 128, ss - 128);
-		break;
-	}
-
-	return dst;
-}
-
-
-//---------------------------------------------------------------------
-// main routine
-//---------------------------------------------------------------------
-static void* memcpy_fast(void *destination, const void *source, size_t size)
-{
-	unsigned char *dst = (unsigned char*)destination;
-	const unsigned char *src = (const unsigned char*)source;
-	static size_t cachesize = 0x200000; // L2-cache size
-	size_t padding;
-
-	// small memory copy
-	if (size <= 128) {
-		return memcpy_tiny(dst, src, size);
-	}
-
-	// align destination to 16 bytes boundary
-	padding = (16 - (((size_t)dst) & 15)) & 15;
-
-	if (padding > 0) {
-		__m128i head = _mm_loadu_si128((const __m128i*)src);
-		_mm_storeu_si128((__m128i*)dst, head);
-		dst += padding;
-		src += padding;
-		size -= padding;
-	}
-
-	// medium size copy
-	if (size <= cachesize) {
-		__m128i c0, c1, c2, c3, c4, c5, c6, c7;
-
-		for (; size >= 128; size -= 128) {
-			c0 = _mm_loadu_si128(((const __m128i*)src) + 0);
-			c1 = _mm_loadu_si128(((const __m128i*)src) + 1);
-			c2 = _mm_loadu_si128(((const __m128i*)src) + 2);
-			c3 = _mm_loadu_si128(((const __m128i*)src) + 3);
-			c4 = _mm_loadu_si128(((const __m128i*)src) + 4);
-			c5 = _mm_loadu_si128(((const __m128i*)src) + 5);
-			c6 = _mm_loadu_si128(((const __m128i*)src) + 6);
-			c7 = _mm_loadu_si128(((const __m128i*)src) + 7);
-			_mm_prefetch((const char*)(src + 256), _MM_HINT_NTA);
-			src += 128;
-			_mm_store_si128((((__m128i*)dst) + 0), c0);
-			_mm_store_si128((((__m128i*)dst) + 1), c1);
-			_mm_store_si128((((__m128i*)dst) + 2), c2);
-			_mm_store_si128((((__m128i*)dst) + 3), c3);
-			_mm_store_si128((((__m128i*)dst) + 4), c4);
-			_mm_store_si128((((__m128i*)dst) + 5), c5);
-			_mm_store_si128((((__m128i*)dst) + 6), c6);
-			_mm_store_si128((((__m128i*)dst) + 7), c7);
-			dst += 128;
-		}
-	}
-	else {		// big memory copy
-		__m128i c0, c1, c2, c3, c4, c5, c6, c7;
-
-		_mm_prefetch((const char*)(src), _MM_HINT_NTA);
-
-		if ((((size_t)src) & 15) == 0) {	// source aligned
-			for (; size >= 128; size -= 128) {
-				c0 = _mm_load_si128(((const __m128i*)src) + 0);
-				c1 = _mm_load_si128(((const __m128i*)src) + 1);
-				c2 = _mm_load_si128(((const __m128i*)src) + 2);
-				c3 = _mm_load_si128(((const __m128i*)src) + 3);
-				c4 = _mm_load_si128(((const __m128i*)src) + 4);
-				c5 = _mm_load_si128(((const __m128i*)src) + 5);
-				c6 = _mm_load_si128(((const __m128i*)src) + 6);
-				c7 = _mm_load_si128(((const __m128i*)src) + 7);
-				_mm_prefetch((const char*)(src + 256), _MM_HINT_NTA);
-				src += 128;
-				_mm_stream_si128((((__m128i*)dst) + 0), c0);
-				_mm_stream_si128((((__m128i*)dst) + 1), c1);
-				_mm_stream_si128((((__m128i*)dst) + 2), c2);
-				_mm_stream_si128((((__m128i*)dst) + 3), c3);
-				_mm_stream_si128((((__m128i*)dst) + 4), c4);
-				_mm_stream_si128((((__m128i*)dst) + 5), c5);
-				_mm_stream_si128((((__m128i*)dst) + 6), c6);
-				_mm_stream_si128((((__m128i*)dst) + 7), c7);
-				dst += 128;
-			}
-		}
-		else {							// source unaligned
-			for (; size >= 128; size -= 128) {
-				c0 = _mm_loadu_si128(((const __m128i*)src) + 0);
-				c1 = _mm_loadu_si128(((const __m128i*)src) + 1);
-				c2 = _mm_loadu_si128(((const __m128i*)src) + 2);
-				c3 = _mm_loadu_si128(((const __m128i*)src) + 3);
-				c4 = _mm_loadu_si128(((const __m128i*)src) + 4);
-				c5 = _mm_loadu_si128(((const __m128i*)src) + 5);
-				c6 = _mm_loadu_si128(((const __m128i*)src) + 6);
-				c7 = _mm_loadu_si128(((const __m128i*)src) + 7);
-				_mm_prefetch((const char*)(src + 256), _MM_HINT_NTA);
-				src += 128;
-				_mm_stream_si128((((__m128i*)dst) + 0), c0);
-				_mm_stream_si128((((__m128i*)dst) + 1), c1);
-				_mm_stream_si128((((__m128i*)dst) + 2), c2);
-				_mm_stream_si128((((__m128i*)dst) + 3), c3);
-				_mm_stream_si128((((__m128i*)dst) + 4), c4);
-				_mm_stream_si128((((__m128i*)dst) + 5), c5);
-				_mm_stream_si128((((__m128i*)dst) + 6), c6);
-				_mm_stream_si128((((__m128i*)dst) + 7), c7);
-				dst += 128;
-			}
-		}
-		_mm_sfence();
-	}
-
-	memcpy_tiny(dst, src, size);
-
-	return destination;
-}
-
-
-#endif
-
-
-
+//=====================================================================
+//
+// FastMemcpy.c - skywind3000@163.com, 2015
+//
+// feature:
+// 50% speed up in avg. vs standard memcpy (tested in vc2012/gcc5.1)
+//
+//=====================================================================
+#ifndef __FAST_MEMCPY_H__
+#define __FAST_MEMCPY_H__
+
+#include <stddef.h>
+#include <stdint.h>
+#include <emmintrin.h>
+
+
+//---------------------------------------------------------------------
+// force inline for compilers
+//---------------------------------------------------------------------
+#ifndef INLINE
+#ifdef __GNUC__
+#if (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))
+    #define INLINE         __inline__ __attribute__((always_inline))
+#else
+    #define INLINE         __inline__
+#endif
+#elif defined(_MSC_VER)
+    #define INLINE __forceinline
+#elif (defined(__BORLANDC__) || defined(__WATCOMC__))
+    #define INLINE __inline
+#else
+    #define INLINE
+#endif
+#endif
+
+
+
+//---------------------------------------------------------------------
+// fast copy for different sizes
+//---------------------------------------------------------------------
+static INLINE void memcpy_sse2_16(void *dst, const void *src) {
+    __m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+    _mm_storeu_si128(((__m128i*)dst) + 0, m0);
+}
+
+static INLINE void memcpy_sse2_32(void *dst, const void *src) {
+    __m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+    __m128i m1 = _mm_loadu_si128(((const __m128i*)src) + 1);
+    _mm_storeu_si128(((__m128i*)dst) + 0, m0);
+    _mm_storeu_si128(((__m128i*)dst) + 1, m1);
+}
+
+static INLINE void memcpy_sse2_64(void *dst, const void *src) {
+    __m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+    __m128i m1 = _mm_loadu_si128(((const __m128i*)src) + 1);
+    __m128i m2 = _mm_loadu_si128(((const __m128i*)src) + 2);
+    __m128i m3 = _mm_loadu_si128(((const __m128i*)src) + 3);
+    _mm_storeu_si128(((__m128i*)dst) + 0, m0);
+    _mm_storeu_si128(((__m128i*)dst) + 1, m1);
+    _mm_storeu_si128(((__m128i*)dst) + 2, m2);
+    _mm_storeu_si128(((__m128i*)dst) + 3, m3);
+}
+
+static INLINE void memcpy_sse2_128(void *dst, const void *src) {
+    __m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+    __m128i m1 = _mm_loadu_si128(((const __m128i*)src) + 1);
+    __m128i m2 = _mm_loadu_si128(((const __m128i*)src) + 2);
+    __m128i m3 = _mm_loadu_si128(((const __m128i*)src) + 3);
+    __m128i m4 = _mm_loadu_si128(((const __m128i*)src) + 4);
+    __m128i m5 = _mm_loadu_si128(((const __m128i*)src) + 5);
+    __m128i m6 = _mm_loadu_si128(((const __m128i*)src) + 6);
+    __m128i m7 = _mm_loadu_si128(((const __m128i*)src) + 7);
+    _mm_storeu_si128(((__m128i*)dst) + 0, m0);
+    _mm_storeu_si128(((__m128i*)dst) + 1, m1);
+    _mm_storeu_si128(((__m128i*)dst) + 2, m2);
+    _mm_storeu_si128(((__m128i*)dst) + 3, m3);
+    _mm_storeu_si128(((__m128i*)dst) + 4, m4);
+    _mm_storeu_si128(((__m128i*)dst) + 5, m5);
+    _mm_storeu_si128(((__m128i*)dst) + 6, m6);
+    _mm_storeu_si128(((__m128i*)dst) + 7, m7);
+}
+
+
+//---------------------------------------------------------------------
+// tiny memory copy with jump table optimized
+//---------------------------------------------------------------------
+static INLINE void *memcpy_tiny(void *dst, const void *src, size_t size) {
+    unsigned char *dd = ((unsigned char*)dst) + size;
+    const unsigned char *ss = ((const unsigned char*)src) + size;
+
+    switch (size) {
+    case 64:
+        memcpy_sse2_64(dd - 64, ss - 64);
+    case 0:
+        break;
+
+    case 65:
+        memcpy_sse2_64(dd - 65, ss - 65);
+    case 1:
+        dd[-1] = ss[-1];
+        break;
+
+    case 66:
+        memcpy_sse2_64(dd - 66, ss - 66);
+    case 2:
+        *((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+        break;
+
+    case 67:
+        memcpy_sse2_64(dd - 67, ss - 67);
+    case 3:
+        *((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
+        dd[-1] = ss[-1];
+        break;
+
+    case 68:
+        memcpy_sse2_64(dd - 68, ss - 68);
+    case 4:
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 69:
+        memcpy_sse2_64(dd - 69, ss - 69);
+    case 5:
+        *((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+        dd[-1] = ss[-1];
+        break;
+
+    case 70:
+        memcpy_sse2_64(dd - 70, ss - 70);
+    case 6:
+        *((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
+        *((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+        break;
+
+    case 71:
+        memcpy_sse2_64(dd - 71, ss - 71);
+    case 7:
+        *((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 72:
+        memcpy_sse2_64(dd - 72, ss - 72);
+    case 8:
+        *((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+        break;
+
+    case 73:
+        memcpy_sse2_64(dd - 73, ss - 73);
+    case 9:
+        *((uint64_t*)(dd - 9)) = *((uint64_t*)(ss - 9));
+        dd[-1] = ss[-1];
+        break;
+
+    case 74:
+        memcpy_sse2_64(dd - 74, ss - 74);
+    case 10:
+        *((uint64_t*)(dd - 10)) = *((uint64_t*)(ss - 10));
+        *((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+        break;
+
+    case 75:
+        memcpy_sse2_64(dd - 75, ss - 75);
+    case 11:
+        *((uint64_t*)(dd - 11)) = *((uint64_t*)(ss - 11));
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 76:
+        memcpy_sse2_64(dd - 76, ss - 76);
+    case 12:
+        *((uint64_t*)(dd - 12)) = *((uint64_t*)(ss - 12));
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 77:
+        memcpy_sse2_64(dd - 77, ss - 77);
+    case 13:
+        *((uint64_t*)(dd - 13)) = *((uint64_t*)(ss - 13));
+        *((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+        dd[-1] = ss[-1];
+        break;
+
+    case 78:
+        memcpy_sse2_64(dd - 78, ss - 78);
+    case 14:
+        *((uint64_t*)(dd - 14)) = *((uint64_t*)(ss - 14));
+        *((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+        break;
+
+    case 79:
+        memcpy_sse2_64(dd - 79, ss - 79);
+    case 15:
+        *((uint64_t*)(dd - 15)) = *((uint64_t*)(ss - 15));
+        *((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+        break;
+
+    case 80:
+        memcpy_sse2_64(dd - 80, ss - 80);
+    case 16:
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 81:
+        memcpy_sse2_64(dd - 81, ss - 81);
+    case 17:
+        memcpy_sse2_16(dd - 17, ss - 17);
+        dd[-1] = ss[-1];
+        break;
+
+    case 82:
+        memcpy_sse2_64(dd - 82, ss - 82);
+    case 18:
+        memcpy_sse2_16(dd - 18, ss - 18);
+        *((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+        break;
+
+    case 83:
+        memcpy_sse2_64(dd - 83, ss - 83);
+    case 19:
+        memcpy_sse2_16(dd - 19, ss - 19);
+        *((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
+        dd[-1] = ss[-1];
+        break;
+
+    case 84:
+        memcpy_sse2_64(dd - 84, ss - 84);
+    case 20:
+        memcpy_sse2_16(dd - 20, ss - 20);
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 85:
+        memcpy_sse2_64(dd - 85, ss - 85);
+    case 21:
+        memcpy_sse2_16(dd - 21, ss - 21);
+        *((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+        dd[-1] = ss[-1];
+        break;
+
+    case 86:
+        memcpy_sse2_64(dd - 86, ss - 86);
+    case 22:
+        memcpy_sse2_16(dd - 22, ss - 22);
+        *((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
+        *((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+        break;
+
+    case 87:
+        memcpy_sse2_64(dd - 87, ss - 87);
+    case 23:
+        memcpy_sse2_16(dd - 23, ss - 23);
+        *((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 88:
+        memcpy_sse2_64(dd - 88, ss - 88);
+    case 24:
+        memcpy_sse2_16(dd - 24, ss - 24);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 89:
+        memcpy_sse2_64(dd - 89, ss - 89);
+    case 25:
+        memcpy_sse2_16(dd - 25, ss - 25);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 90:
+        memcpy_sse2_64(dd - 90, ss - 90);
+    case 26:
+        memcpy_sse2_16(dd - 26, ss - 26);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 91:
+        memcpy_sse2_64(dd - 91, ss - 91);
+    case 27:
+        memcpy_sse2_16(dd - 27, ss - 27);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 92:
+        memcpy_sse2_64(dd - 92, ss - 92);
+    case 28:
+        memcpy_sse2_16(dd - 28, ss - 28);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 93:
+        memcpy_sse2_64(dd - 93, ss - 93);
+    case 29:
+        memcpy_sse2_16(dd - 29, ss - 29);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 94:
+        memcpy_sse2_64(dd - 94, ss - 94);
+    case 30:
+        memcpy_sse2_16(dd - 30, ss - 30);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 95:
+        memcpy_sse2_64(dd - 95, ss - 95);
+    case 31:
+        memcpy_sse2_16(dd - 31, ss - 31);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 96:
+        memcpy_sse2_64(dd - 96, ss - 96);
+    case 32:
+        memcpy_sse2_32(dd - 32, ss - 32);
+        break;
+
+    case 97:
+        memcpy_sse2_64(dd - 97, ss - 97);
+    case 33:
+        memcpy_sse2_32(dd - 33, ss - 33);
+        dd[-1] = ss[-1];
+        break;
+
+    case 98:
+        memcpy_sse2_64(dd - 98, ss - 98);
+    case 34:
+        memcpy_sse2_32(dd - 34, ss - 34);
+        *((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+        break;
+
+    case 99:
+        memcpy_sse2_64(dd - 99, ss - 99);
+    case 35:
+        memcpy_sse2_32(dd - 35, ss - 35);
+        *((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
+        dd[-1] = ss[-1];
+        break;
+
+    case 100:
+        memcpy_sse2_64(dd - 100, ss - 100);
+    case 36:
+        memcpy_sse2_32(dd - 36, ss - 36);
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 101:
+        memcpy_sse2_64(dd - 101, ss - 101);
+    case 37:
+        memcpy_sse2_32(dd - 37, ss - 37);
+        *((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+        dd[-1] = ss[-1];
+        break;
+
+    case 102:
+        memcpy_sse2_64(dd - 102, ss - 102);
+    case 38:
+        memcpy_sse2_32(dd - 38, ss - 38);
+        *((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
+        *((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+        break;
+
+    case 103:
+        memcpy_sse2_64(dd - 103, ss - 103);
+    case 39:
+        memcpy_sse2_32(dd - 39, ss - 39);
+        *((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 104:
+        memcpy_sse2_64(dd - 104, ss - 104);
+    case 40:
+        memcpy_sse2_32(dd - 40, ss - 40);
+        *((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+        break;
+
+    case 105:
+        memcpy_sse2_64(dd - 105, ss - 105);
+    case 41:
+        memcpy_sse2_32(dd - 41, ss - 41);
+        *((uint64_t*)(dd - 9)) = *((uint64_t*)(ss - 9));
+        dd[-1] = ss[-1];
+        break;
+
+    case 106:
+        memcpy_sse2_64(dd - 106, ss - 106);
+    case 42:
+        memcpy_sse2_32(dd - 42, ss - 42);
+        *((uint64_t*)(dd - 10)) = *((uint64_t*)(ss - 10));
+        *((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+        break;
+
+    case 107:
+        memcpy_sse2_64(dd - 107, ss - 107);
+    case 43:
+        memcpy_sse2_32(dd - 43, ss - 43);
+        *((uint64_t*)(dd - 11)) = *((uint64_t*)(ss - 11));
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 108:
+        memcpy_sse2_64(dd - 108, ss - 108);
+    case 44:
+        memcpy_sse2_32(dd - 44, ss - 44);
+        *((uint64_t*)(dd - 12)) = *((uint64_t*)(ss - 12));
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 109:
+        memcpy_sse2_64(dd - 109, ss - 109);
+    case 45:
+        memcpy_sse2_32(dd - 45, ss - 45);
+        *((uint64_t*)(dd - 13)) = *((uint64_t*)(ss - 13));
+        *((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+        dd[-1] = ss[-1];
+        break;
+
+    case 110:
+        memcpy_sse2_64(dd - 110, ss - 110);
+    case 46:
+        memcpy_sse2_32(dd - 46, ss - 46);
+        *((uint64_t*)(dd - 14)) = *((uint64_t*)(ss - 14));
+        *((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+        break;
+
+    case 111:
+        memcpy_sse2_64(dd - 111, ss - 111);
+    case 47:
+        memcpy_sse2_32(dd - 47, ss - 47);
+        *((uint64_t*)(dd - 15)) = *((uint64_t*)(ss - 15));
+        *((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+        break;
+
+    case 112:
+        memcpy_sse2_64(dd - 112, ss - 112);
+    case 48:
+        memcpy_sse2_32(dd - 48, ss - 48);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 113:
+        memcpy_sse2_64(dd - 113, ss - 113);
+    case 49:
+        memcpy_sse2_32(dd - 49, ss - 49);
+        memcpy_sse2_16(dd - 17, ss - 17);
+        dd[-1] = ss[-1];
+        break;
+
+    case 114:
+        memcpy_sse2_64(dd - 114, ss - 114);
+    case 50:
+        memcpy_sse2_32(dd - 50, ss - 50);
+        memcpy_sse2_16(dd - 18, ss - 18);
+        *((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+        break;
+
+    case 115:
+        memcpy_sse2_64(dd - 115, ss - 115);
+    case 51:
+        memcpy_sse2_32(dd - 51, ss - 51);
+        memcpy_sse2_16(dd - 19, ss - 19);
+        *((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
+        dd[-1] = ss[-1];
+        break;
+
+    case 116:
+        memcpy_sse2_64(dd - 116, ss - 116);
+    case 52:
+        memcpy_sse2_32(dd - 52, ss - 52);
+        memcpy_sse2_16(dd - 20, ss - 20);
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 117:
+        memcpy_sse2_64(dd - 117, ss - 117);
+    case 53:
+        memcpy_sse2_32(dd - 53, ss - 53);
+        memcpy_sse2_16(dd - 21, ss - 21);
+        *((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+        dd[-1] = ss[-1];
+        break;
+
+    case 118:
+        memcpy_sse2_64(dd - 118, ss - 118);
+    case 54:
+        memcpy_sse2_32(dd - 54, ss - 54);
+        memcpy_sse2_16(dd - 22, ss - 22);
+        *((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
+        *((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+        break;
+
+    case 119:
+        memcpy_sse2_64(dd - 119, ss - 119);
+    case 55:
+        memcpy_sse2_32(dd - 55, ss - 55);
+        memcpy_sse2_16(dd - 23, ss - 23);
+        *((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 120:
+        memcpy_sse2_64(dd - 120, ss - 120);
+    case 56:
+        memcpy_sse2_32(dd - 56, ss - 56);
+        memcpy_sse2_16(dd - 24, ss - 24);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 121:
+        memcpy_sse2_64(dd - 121, ss - 121);
+    case 57:
+        memcpy_sse2_32(dd - 57, ss - 57);
+        memcpy_sse2_16(dd - 25, ss - 25);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 122:
+        memcpy_sse2_64(dd - 122, ss - 122);
+    case 58:
+        memcpy_sse2_32(dd - 58, ss - 58);
+        memcpy_sse2_16(dd - 26, ss - 26);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 123:
+        memcpy_sse2_64(dd - 123, ss - 123);
+    case 59:
+        memcpy_sse2_32(dd - 59, ss - 59);
+        memcpy_sse2_16(dd - 27, ss - 27);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 124:
+        memcpy_sse2_64(dd - 124, ss - 124);
+    case 60:
+        memcpy_sse2_32(dd - 60, ss - 60);
+        memcpy_sse2_16(dd - 28, ss - 28);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 125:
+        memcpy_sse2_64(dd - 125, ss - 125);
+    case 61:
+        memcpy_sse2_32(dd - 61, ss - 61);
+        memcpy_sse2_16(dd - 29, ss - 29);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 126:
+        memcpy_sse2_64(dd - 126, ss - 126);
+    case 62:
+        memcpy_sse2_32(dd - 62, ss - 62);
+        memcpy_sse2_16(dd - 30, ss - 30);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 127:
+        memcpy_sse2_64(dd - 127, ss - 127);
+    case 63:
+        memcpy_sse2_32(dd - 63, ss - 63);
+        memcpy_sse2_16(dd - 31, ss - 31);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 128:
+        memcpy_sse2_128(dd - 128, ss - 128);
+        break;
+    }
+
+    return dst;
+}
+
+
+//---------------------------------------------------------------------
+// main routine
+//---------------------------------------------------------------------
+static void* memcpy_fast(void *destination, const void *source, size_t size)
+{
+    unsigned char *dst = (unsigned char*)destination;
+    const unsigned char *src = (const unsigned char*)source;
+    static size_t cachesize = 0x200000; // L2-cache size
+    size_t padding;
+
+    // small memory copy
+    if (size <= 128) {
+        return memcpy_tiny(dst, src, size);
+    }
+
+    // align destination to 16 bytes boundary
+    padding = (16 - (((size_t)dst) & 15)) & 15;
+
+    if (padding > 0) {
+        __m128i head = _mm_loadu_si128((const __m128i*)src);
+        _mm_storeu_si128((__m128i*)dst, head);
+        dst += padding;
+        src += padding;
+        size -= padding;
+    }
+
+    // medium size copy
+    if (size <= cachesize) {
+        __m128i c0, c1, c2, c3, c4, c5, c6, c7;
+
+        for (; size >= 128; size -= 128) {
+            c0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+            c1 = _mm_loadu_si128(((const __m128i*)src) + 1);
+            c2 = _mm_loadu_si128(((const __m128i*)src) + 2);
+            c3 = _mm_loadu_si128(((const __m128i*)src) + 3);
+            c4 = _mm_loadu_si128(((const __m128i*)src) + 4);
+            c5 = _mm_loadu_si128(((const __m128i*)src) + 5);
+            c6 = _mm_loadu_si128(((const __m128i*)src) + 6);
+            c7 = _mm_loadu_si128(((const __m128i*)src) + 7);
+            _mm_prefetch((const char*)(src + 256), _MM_HINT_NTA);
+            src += 128;
+            _mm_store_si128((((__m128i*)dst) + 0), c0);
+            _mm_store_si128((((__m128i*)dst) + 1), c1);
+            _mm_store_si128((((__m128i*)dst) + 2), c2);
+            _mm_store_si128((((__m128i*)dst) + 3), c3);
+            _mm_store_si128((((__m128i*)dst) + 4), c4);
+            _mm_store_si128((((__m128i*)dst) + 5), c5);
+            _mm_store_si128((((__m128i*)dst) + 6), c6);
+            _mm_store_si128((((__m128i*)dst) + 7), c7);
+            dst += 128;
+        }
+    }
+    else {        // big memory copy
+        __m128i c0, c1, c2, c3, c4, c5, c6, c7;
+
+        _mm_prefetch((const char*)(src), _MM_HINT_NTA);
+
+        if ((((size_t)src) & 15) == 0) {    // source aligned
+            for (; size >= 128; size -= 128) {
+                c0 = _mm_load_si128(((const __m128i*)src) + 0);
+                c1 = _mm_load_si128(((const __m128i*)src) + 1);
+                c2 = _mm_load_si128(((const __m128i*)src) + 2);
+                c3 = _mm_load_si128(((const __m128i*)src) + 3);
+                c4 = _mm_load_si128(((const __m128i*)src) + 4);
+                c5 = _mm_load_si128(((const __m128i*)src) + 5);
+                c6 = _mm_load_si128(((const __m128i*)src) + 6);
+                c7 = _mm_load_si128(((const __m128i*)src) + 7);
+                _mm_prefetch((const char*)(src + 256), _MM_HINT_NTA);
+                src += 128;
+                _mm_stream_si128((((__m128i*)dst) + 0), c0);
+                _mm_stream_si128((((__m128i*)dst) + 1), c1);
+                _mm_stream_si128((((__m128i*)dst) + 2), c2);
+                _mm_stream_si128((((__m128i*)dst) + 3), c3);
+                _mm_stream_si128((((__m128i*)dst) + 4), c4);
+                _mm_stream_si128((((__m128i*)dst) + 5), c5);
+                _mm_stream_si128((((__m128i*)dst) + 6), c6);
+                _mm_stream_si128((((__m128i*)dst) + 7), c7);
+                dst += 128;
+            }
+        }
+        else {                            // source unaligned
+            for (; size >= 128; size -= 128) {
+                c0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+                c1 = _mm_loadu_si128(((const __m128i*)src) + 1);
+                c2 = _mm_loadu_si128(((const __m128i*)src) + 2);
+                c3 = _mm_loadu_si128(((const __m128i*)src) + 3);
+                c4 = _mm_loadu_si128(((const __m128i*)src) + 4);
+                c5 = _mm_loadu_si128(((const __m128i*)src) + 5);
+                c6 = _mm_loadu_si128(((const __m128i*)src) + 6);
+                c7 = _mm_loadu_si128(((const __m128i*)src) + 7);
+                _mm_prefetch((const char*)(src + 256), _MM_HINT_NTA);
+                src += 128;
+                _mm_stream_si128((((__m128i*)dst) + 0), c0);
+                _mm_stream_si128((((__m128i*)dst) + 1), c1);
+                _mm_stream_si128((((__m128i*)dst) + 2), c2);
+                _mm_stream_si128((((__m128i*)dst) + 3), c3);
+                _mm_stream_si128((((__m128i*)dst) + 4), c4);
+                _mm_stream_si128((((__m128i*)dst) + 5), c5);
+                _mm_stream_si128((((__m128i*)dst) + 6), c6);
+                _mm_stream_si128((((__m128i*)dst) + 7), c7);
+                dst += 128;
+            }
+        }
+        _mm_sfence();
+    }
+
+    memcpy_tiny(dst, src, size);
+
+    return destination;
+}
+
+
+#endif
+
+
+
diff --git a/libs/libmemcpy/README.md b/libs/libmemcpy/README.md
index 2c63dc21a81..91e01d4a5a0 100644
--- a/libs/libmemcpy/README.md
+++ b/libs/libmemcpy/README.md
@@ -1,8 +1,8 @@
 Build
 =====
-
-with gcc:
-> gcc -O3 -msse2 FastMemcpy.c -o FastMemcpy
+
+with gcc:
+> gcc -O3 -msse2 FastMemcpy.c -o FastMemcpy
 
 with msvc:
 > cl -nologo -O2 FastMemcpy.c
@@ -10,10 +10,10 @@ with msvc:
 Features
 ========
 
-* 50% speedup in avg. vs traditional memcpy in msvc 2012 or gcc 4.9
-* small size copy optimized with jump table
-* medium size copy optimized with sse2 vector copy 
-* huge size copy optimized with cache prefetch & movntdq
+* 50% speedup in avg. vs traditional memcpy in msvc 2012 or gcc 4.9
+* small size copy optimized with jump table
+* medium size copy optimized with sse2 vector copy
+* huge size copy optimized with cache prefetch & movntdq
 
 Reference
 =========
@@ -28,7 +28,7 @@ Results
 
 ```
 result: gcc4.9 (msvc 2012 got a similar result):
- 
+
 benchmark(size=32 bytes, times=16777216):
 result(dst aligned, src aligned): memcpy_fast=81ms memcpy=281 ms
 result(dst aligned, src unalign): memcpy_fast=88ms memcpy=254 ms

From d9a4acb779ef8d58f52cdb26bafbac16bdcd918d Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 06:01:16 +0300
Subject: [PATCH 207/266] Fixed comment [#CLICKHOUSE-2].

---
 libs/libmemcpy/FastMemcpy.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libs/libmemcpy/FastMemcpy.h b/libs/libmemcpy/FastMemcpy.h
index 306bd19ac58..9cb8bb2d019 100644
--- a/libs/libmemcpy/FastMemcpy.h
+++ b/libs/libmemcpy/FastMemcpy.h
@@ -581,7 +581,7 @@ static void* memcpy_fast(void *destination, const void *source, size_t size)
 {
     unsigned char *dst = (unsigned char*)destination;
     const unsigned char *src = (const unsigned char*)source;
-    static size_t cachesize = 0x200000; // L2-cache size
+    static size_t cachesize = 0x200000; // something around half of LL-cache size
     size_t padding;
 
     // small memory copy

From 2695407a44e81a06ecda27c7c01049e4403e95a1 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 06:26:40 +0300
Subject: [PATCH 208/266] Preparation [#CLICKHOUSE-2].

---
 libs/libmemcpy/FastMemcpy.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/libs/libmemcpy/FastMemcpy.h b/libs/libmemcpy/FastMemcpy.h
index 9cb8bb2d019..f6c79eaba60 100644
--- a/libs/libmemcpy/FastMemcpy.h
+++ b/libs/libmemcpy/FastMemcpy.h
@@ -577,11 +577,10 @@ static INLINE void *memcpy_tiny(void *dst, const void *src, size_t size) {
 //---------------------------------------------------------------------
 // main routine
 //---------------------------------------------------------------------
-static void* memcpy_fast(void *destination, const void *source, size_t size)
+static INLINE void* memcpy_fast(void *destination, const void *source, size_t size)
 {
     unsigned char *dst = (unsigned char*)destination;
     const unsigned char *src = (const unsigned char*)source;
-    static size_t cachesize = 0x200000; // something around half of LL-cache size
     size_t padding;
 
     // small memory copy
@@ -601,7 +600,8 @@ static void* memcpy_fast(void *destination, const void *source, size_t size)
     }
 
     // medium size copy
-    if (size <= cachesize) {
+    if (size <= 0x200000)   // something around half of LL-cache size
+    {
         __m128i c0, c1, c2, c3, c4, c5, c6, c7;
 
         for (; size >= 128; size -= 128) {

From 4331b52a1592536d8a0c22ec29d15b065f363877 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 06:27:37 +0300
Subject: [PATCH 209/266] Added wrapper [#CLICKHOUSE-2].

---
 libs/CMakeLists.txt           |  1 +
 libs/libmemcpy/CMakeLists.txt |  1 +
 libs/libmemcpy/memcpy.c       |  3 +++
 libs/libmemcpy/memcpy.h       | 17 +++++++++++++++++
 4 files changed, 22 insertions(+)
 create mode 100644 libs/libmemcpy/CMakeLists.txt
 create mode 100644 libs/libmemcpy/memcpy.c
 create mode 100644 libs/libmemcpy/memcpy.h

diff --git a/libs/CMakeLists.txt b/libs/CMakeLists.txt
index e5887d0813f..3420ba2ebc8 100644
--- a/libs/CMakeLists.txt
+++ b/libs/CMakeLists.txt
@@ -6,6 +6,7 @@ endif ()
 add_subdirectory (libcommon)
 add_subdirectory (libpocoext)
 add_subdirectory (libdaemon)
+add_subdirectory (libmemcpy)
 
 if (USE_MYSQL)
     add_subdirectory (libmysqlxx)
diff --git a/libs/libmemcpy/CMakeLists.txt b/libs/libmemcpy/CMakeLists.txt
new file mode 100644
index 00000000000..c06085aacca
--- /dev/null
+++ b/libs/libmemcpy/CMakeLists.txt
@@ -0,0 +1 @@
+add_library (memcpy memcpy.c)
diff --git a/libs/libmemcpy/memcpy.c b/libs/libmemcpy/memcpy.c
new file mode 100644
index 00000000000..9e1b175bc57
--- /dev/null
+++ b/libs/libmemcpy/memcpy.c
@@ -0,0 +1,3 @@
+#include "memcpy.h"
+
+/// This is needed to generate an object file for linking.
diff --git a/libs/libmemcpy/memcpy.h b/libs/libmemcpy/memcpy.h
new file mode 100644
index 00000000000..902133ed3ae
--- /dev/null
+++ b/libs/libmemcpy/memcpy.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include "FastMemcpy.h"
+
+void * __attribute__((__weak__)) memcpy(void * __restrict destination, const void * __restrict source, size_t size)
+{
+    return memcpy_fast(destination, source, size);
+}
+
+#ifdef __cplusplus
+}
+#endif

From 1f818dfa78a47ce10b378459d02b4d837419cc2e Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 06:28:57 +0300
Subject: [PATCH 210/266] Moved third-party sources deeper [#CLICKHOUSE-2].

---
 libs/libmemcpy/{ => impl}/FastMemcpy.h | 0
 libs/libmemcpy/{ => impl}/LICENSE      | 0
 libs/libmemcpy/{ => impl}/README.md    | 0
 libs/libmemcpy/memcpy.h                | 2 +-
 4 files changed, 1 insertion(+), 1 deletion(-)
 rename libs/libmemcpy/{ => impl}/FastMemcpy.h (100%)
 rename libs/libmemcpy/{ => impl}/LICENSE (100%)
 rename libs/libmemcpy/{ => impl}/README.md (100%)

diff --git a/libs/libmemcpy/FastMemcpy.h b/libs/libmemcpy/impl/FastMemcpy.h
similarity index 100%
rename from libs/libmemcpy/FastMemcpy.h
rename to libs/libmemcpy/impl/FastMemcpy.h
diff --git a/libs/libmemcpy/LICENSE b/libs/libmemcpy/impl/LICENSE
similarity index 100%
rename from libs/libmemcpy/LICENSE
rename to libs/libmemcpy/impl/LICENSE
diff --git a/libs/libmemcpy/README.md b/libs/libmemcpy/impl/README.md
similarity index 100%
rename from libs/libmemcpy/README.md
rename to libs/libmemcpy/impl/README.md
diff --git a/libs/libmemcpy/memcpy.h b/libs/libmemcpy/memcpy.h
index 902133ed3ae..1f898d4aff6 100644
--- a/libs/libmemcpy/memcpy.h
+++ b/libs/libmemcpy/memcpy.h
@@ -5,7 +5,7 @@ extern "C"
 {
 #endif
 
-#include "FastMemcpy.h"
+#include "impl/FastMemcpy.h"
 
 void * __attribute__((__weak__)) memcpy(void * __restrict destination, const void * __restrict source, size_t size)
 {

From b700af1d2764e75db1da83b4bc2af0b87f14c427 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 06:44:34 +0300
Subject: [PATCH 211/266] Removed build of shared library and test executables
 for libzlib-ng [#CLICKHOUSE-2].

---
 contrib/libzlib-ng/CMakeLists.txt | 57 ++-----------------------------
 1 file changed, 2 insertions(+), 55 deletions(-)

diff --git a/contrib/libzlib-ng/CMakeLists.txt b/contrib/libzlib-ng/CMakeLists.txt
index 7054ab81115..cd2eeb97c55 100644
--- a/contrib/libzlib-ng/CMakeLists.txt
+++ b/contrib/libzlib-ng/CMakeLists.txt
@@ -489,39 +489,15 @@ if(MINGW OR MSYS)
     set(ZLIB_DLL_SRCS ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj)
 endif(MINGW OR MSYS)
 
-add_library(zlib SHARED ${ZLIB_SRCS} ${ZLIB_GZFILE_SRCS} ${ZLIB_ARCH_SRCS} ${ZLIB_ASMS} ${ZLIB_DLL_SRCS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
 add_library(zlibstatic STATIC ${ZLIB_SRCS} ${ZLIB_GZFILE_SRCS} ${ZLIB_ARCH_SRCS} ${ZLIB_ASMS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
 
-set_target_properties(zlib PROPERTIES DEFINE_SYMBOL ZLIB_DLL)
-set_target_properties(zlib PROPERTIES SOVERSION 1)
-
-if(NOT CYGWIN)
-    # This property causes shared libraries on Linux to have the full version
-    # encoded into their final filename.  We disable this on Cygwin because
-    # it causes cygz-${ZLIB_FULL_VERSION}.dll to be created when cygz.dll
-    # seems to be the default.
-    #
-    # This has no effect with MSVC, on that platform the version info for
-    # the DLL comes from the resource file win32/zlib1.rc
-    set_target_properties(zlib PROPERTIES VERSION ${ZLIB_FULL_VERSION})
-endif()
-
 if(UNIX)
     # On unix-like platforms the library is almost always called libz
-   set_target_properties(zlib zlibstatic PROPERTIES OUTPUT_NAME z)
-   if(NOT APPLE)
-     set_target_properties(zlib PROPERTIES LINK_FLAGS "-Wl,--version-script,\"${CMAKE_CURRENT_SOURCE_DIR}/zlib.map\"")
-   endif()
-elseif(MSYS)
-   # Suppress version number from shared library name
-   set(CMAKE_SHARED_LIBRARY_NAME_WITH_VERSION 0)
-elseif(BUILD_SHARED_LIBS AND WIN32)
-    # Creates zlib1.dll when building shared library version
-    set_target_properties(zlib PROPERTIES SUFFIX "1.dll")
+   set_target_properties(zlibstatic PROPERTIES OUTPUT_NAME z)
 endif()
 
 if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL )
-    install(TARGETS zlib zlibstatic
+    install(TARGETS zlibstatic
         RUNTIME DESTINATION "${INSTALL_BIN_DIR}"
         ARCHIVE DESTINATION "${INSTALL_LIB_DIR}"
         LIBRARY DESTINATION "${INSTALL_LIB_DIR}" )
@@ -529,35 +505,6 @@ endif()
 if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL )
     install(FILES ${ZLIB_PUBLIC_HDRS} DESTINATION "${INSTALL_INC_DIR}")
 endif()
-if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
-    install(FILES zlib.3 DESTINATION "${INSTALL_MAN_DIR}/man3")
-endif()
 if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
     install(FILES ${ZLIB_PC} DESTINATION "${INSTALL_PKGCONFIG_DIR}")
 endif()
-
-#============================================================================
-# Example binaries
-#============================================================================
-
-if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-	set (CMAKE_EXE_LINKER_FLAGS "")
-endif ()
-
-add_executable(example test/example.c)
-target_link_libraries(example zlib)
-add_test(example example)
-
-add_executable(minigzip test/minigzip.c)
-target_link_libraries(minigzip zlib)
-
-if(HAVE_OFF64_T)
-    add_executable(example64 test/example.c)
-    target_link_libraries(example64 zlib)
-    set_target_properties(example64 PROPERTIES COMPILE_FLAGS "-D_FILE_OFFSET_BITS=64")
-    add_test(example64 example64)
-
-    add_executable(minigzip64 test/minigzip.c)
-    target_link_libraries(minigzip64 zlib)
-    set_target_properties(minigzip64 PROPERTIES COMPILE_FLAGS "-D_FILE_OFFSET_BITS=64")
-endif()

From 09002844f209fd5f140f353e428deebe959077e8 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 08:06:52 +0300
Subject: [PATCH 212/266] Using internal memcpy [#CLICKHOUSE-2].

---
 libs/libcommon/CMakeLists.txt | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/libs/libcommon/CMakeLists.txt b/libs/libcommon/CMakeLists.txt
index a3a4ff14326..3b6489d0bc7 100644
--- a/libs/libcommon/CMakeLists.txt
+++ b/libs/libcommon/CMakeLists.txt
@@ -90,7 +90,8 @@ target_link_libraries (
     ${Boost_FILESYSTEM_LIBRARY}
     ${MALLOC_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}
-    ${RT_LIBRARIES})
+    ${RT_LIBRARIES}
+    memcpy)
 
 if (ENABLE_TESTS)
     add_subdirectory (src/tests)

From c7f036e2bb86086aa3bb1fb5e6e6059f6a500a46 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 08:07:42 +0300
Subject: [PATCH 213/266] Added README [#CLICKHOUSE-2].

---
 libs/libmemcpy/README.md | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 libs/libmemcpy/README.md

diff --git a/libs/libmemcpy/README.md b/libs/libmemcpy/README.md
new file mode 100644
index 00000000000..d3dd14ac55b
--- /dev/null
+++ b/libs/libmemcpy/README.md
@@ -0,0 +1,20 @@
+Internal implementation of `memcpy` function.
+
+It has the following advantages over `libc`-supplied implementation:
+- it is linked statically, so the function is called directly, not through a `PLT` (procedure lookup table of shared library);
+- it is linked statically, so the function can have position-dependent code;
+- your binaries will not depend on `glibc`'s memcpy, that forces dependency on specific symbol version like `memcpy@@GLIBC_2.14` and consequently on specific version of `glibc` library;
+- you can include `memcpy.h` directly and the function has the chance to be inlined, which is beneficial for small but unknown at compile time sizes of memory regions;
+- this version of `memcpy` pretend to be faster (in our benchmarks, the difference is withing few percents).
+
+Currently it uses the implementation from **Linwei** (skywind3000@163.com).
+Look at https://www.zhihu.com/question/35172305 for discussion.
+
+Drawbacks:
+- only use SSE 2, doesn't use wider (AVX, AVX 512) vector registers when available;
+- no CPU dispatching; doesn't take into account actual cache size.
+
+Also worth to look at:
+- simple implementation from Facebook: https://github.com/facebook/folly/blob/master/folly/memcpy.S
+- implementation from Agner Fog: http://www.agner.org/optimize/
+- glibc source code.

From a44208ba2517b0803c65c53b477b45ba1fcf9008 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 08:27:09 +0300
Subject: [PATCH 214/266] Refined "GLIBC_COMPATIBILITY" option
 [#CLICKHOUSE-3275].

---
 CMakeLists.txt                                |  6 +-
 libs/CMakeLists.txt                           |  9 ++-
 libs/libcommon/CMakeLists.txt                 | 11 ++-
 .../include/common/glibc_compatibility.h      | 79 -------------------
 libs/libglibc-compatibility/CMakeLists.txt    |  1 +
 .../glibc-compatibility.c                     | 52 ++++++++++++
 .../glibc-compatibility.h                     | 37 +++++++++
 7 files changed, 111 insertions(+), 84 deletions(-)
 delete mode 100644 libs/libcommon/include/common/glibc_compatibility.h
 create mode 100644 libs/libglibc-compatibility/CMakeLists.txt
 create mode 100644 libs/libglibc-compatibility/glibc-compatibility.c
 create mode 100644 libs/libglibc-compatibility/glibc-compatibility.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3e0fe38e84a..a671fe1b775 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -71,11 +71,11 @@ if (USE_STATIC_LIBRARIES)
     list(REVERSE CMAKE_FIND_LIBRARY_SUFFIXES)
 endif ()
 
-option (GLIBC_COMPATIBILITY "Set to TRUE to enable compatibility with older glibc libraries. Note that it is not compatible with ASan." OFF)
+option (USE_INTERNAL_MEMCPY "Use internal implementation of 'memcpy' function instead of provided by libc. Only for x86_64." ON)
+option (GLIBC_COMPATIBILITY "Set to TRUE to enable compatibility with older glibc libraries. Implies USE_INTERNAL_MEMCPY." OFF)
 
 if (GLIBC_COMPATIBILITY)
-    set (GLIBC_COMPATIBILITY_COMPILE_FLAGS   "-include ${ClickHouse_SOURCE_DIR}/libs/libcommon/include/common/glibc_compatibility.h")
-    set (GLIBC_COMPATIBILITY_LINK_FLAGS      "-Wl,--wrap=memcpy")
+    set (USE_INTERNAL_MEMCPY ON)
 endif ()
 
 if (CXX11_ABI STREQUAL ENABLE)
diff --git a/libs/CMakeLists.txt b/libs/CMakeLists.txt
index 3420ba2ebc8..970d2be15b4 100644
--- a/libs/CMakeLists.txt
+++ b/libs/CMakeLists.txt
@@ -6,7 +6,14 @@ endif ()
 add_subdirectory (libcommon)
 add_subdirectory (libpocoext)
 add_subdirectory (libdaemon)
-add_subdirectory (libmemcpy)
+
+if (USE_INTERNAL_MEMCPY)
+    add_subdirectory (libmemcpy)
+endif()
+
+if (GLIBC_COMPATIBILITY)
+    add_subdirectory (libglibc-compatibility)
+endif ()
 
 if (USE_MYSQL)
     add_subdirectory (libmysqlxx)
diff --git a/libs/libcommon/CMakeLists.txt b/libs/libcommon/CMakeLists.txt
index 3b6489d0bc7..3ba10c85636 100644
--- a/libs/libcommon/CMakeLists.txt
+++ b/libs/libcommon/CMakeLists.txt
@@ -75,6 +75,14 @@ else ()
     message (STATUS "Disabling libtcmalloc for valgrind better analysis")
 endif ()
 
+if (GLIBC_COMPATIBILITY)
+    set (GLIBC_COMPATIBILITY_LIBRARIES glibc-compatibility)
+endif ()
+
+if (USE_INTERNAL_MEMCPY)
+    set (MEMCPY_LIBRARIES memcpy)
+endif ()
+
 find_package (Threads)
 
 target_include_directories (common BEFORE PRIVATE ${CCTZ_INCLUDE_DIR})
@@ -91,7 +99,8 @@ target_link_libraries (
     ${MALLOC_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}
     ${RT_LIBRARIES}
-    memcpy)
+    ${GLIBC_COMPATIBILITY_LIBRARIES}
+    ${MEMCPY_LIBRARIES})
 
 if (ENABLE_TESTS)
     add_subdirectory (src/tests)
diff --git a/libs/libcommon/include/common/glibc_compatibility.h b/libs/libcommon/include/common/glibc_compatibility.h
deleted file mode 100644
index b2a13176f27..00000000000
--- a/libs/libcommon/include/common/glibc_compatibility.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/** Allows to build programs with libc 2.18 and run on systems with at least libc 2.11,
-  *  such as Ubuntu Lucid or CentOS 6.
-  *
-  * Highly experimental, not recommended, disabled by default.
-  *
-  * To use, include this file with -include compiler parameter.
-  * And add -Wl,--wrap=memcpy for linking.
-  *
-  * Also look at http://www.lightofdawn.org/wiki/wiki.cgi/NewAppsOnOldGlibc
-  *
-  * If you want even older systems, such as Ubuntu Hardy,
-  *  add fallocate, pipe2, __longjmp_chk, __vasprintf_chk.
-  */
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-#include <stdlib.h>
-#include <sys/select.h>
-
-__attribute__((__weak__)) long int __fdelt_chk(long int d)
-{
-    if (d < 0 || d >= FD_SETSIZE)
-        abort();
-    return d / __NFDBITS;
-}
-
-#include <sys/poll.h>
-
-__attribute__((__weak__)) int __poll_chk(struct pollfd * fds, nfds_t nfds, int timeout, __SIZE_TYPE__ fdslen)
-{
-    if (fdslen / sizeof(*fds) < nfds)
-        abort();
-    return poll(fds, nfds, timeout);
-}
-
-
-__attribute__((__weak__)) void * __memcpy_glibc_2_2_5(void *, const void *, size_t);
-
-__asm__(".symver __memcpy_glibc_2_2_5, memcpy@GLIBC_2.2.5");
-
-__attribute__((__weak__)) void * __wrap_memcpy(void * dest, const void * src, size_t n)
-{
-    return __memcpy_glibc_2_2_5(dest, src, n);
-}
-
-
-__attribute__((__weak__)) size_t __pthread_get_minstack(const pthread_attr_t * attr)
-{
-    return 1048576;        /// This is a guess. Don't sure it is correct.
-}
-
-#include <string.h>
-#include <signal.h>
-#include <unistd.h>
-#include <sys/syscall.h>
-
-extern long int syscall (long int __sysno, ...) __THROW;
-
-__attribute__((__weak__)) int __gai_sigqueue(int sig, const union sigval val, pid_t caller_pid)
-{
-    siginfo_t info;
-
-    memset(&info, 0, sizeof(siginfo_t));
-    info.si_signo = sig;
-    info.si_code = SI_ASYNCNL;
-    info.si_pid = caller_pid;
-    info.si_uid = getuid();
-    info.si_value = val;
-
-    return syscall(__NR_rt_sigqueueinfo, info.si_pid, sig, &info);
-}
-
-
-#if defined (__cplusplus)
-}
-#endif
diff --git a/libs/libglibc-compatibility/CMakeLists.txt b/libs/libglibc-compatibility/CMakeLists.txt
new file mode 100644
index 00000000000..e8c5a4ba757
--- /dev/null
+++ b/libs/libglibc-compatibility/CMakeLists.txt
@@ -0,0 +1 @@
+add_library (glibc-compatibility glibc-compatibility.c)
diff --git a/libs/libglibc-compatibility/glibc-compatibility.c b/libs/libglibc-compatibility/glibc-compatibility.c
new file mode 100644
index 00000000000..5524017b61f
--- /dev/null
+++ b/libs/libglibc-compatibility/glibc-compatibility.c
@@ -0,0 +1,52 @@
+#include "glibc-compatibility.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#include <sys/select.h>
+#include <stdlib.h>
+
+long int __fdelt_chk(long int d)
+{
+    if (d < 0 || d >= FD_SETSIZE)
+        abort();
+    return d / __NFDBITS;
+}
+
+
+int __poll_chk(struct pollfd * fds, nfds_t nfds, int timeout, size_t fdslen)
+{
+    if (fdslen / sizeof(*fds) < nfds)
+        abort();
+    return poll(fds, nfds, timeout);
+}
+
+
+size_t __pthread_get_minstack(const pthread_attr_t * attr)
+{
+    return 1048576;        /// This is a guess. Don't sure it is correct.
+}
+
+#include <string.h>
+#include <sys/syscall.h>
+
+extern long int syscall (long int __sysno, ...) __THROW;
+
+int __gai_sigqueue(int sig, const union sigval val, pid_t caller_pid)
+{
+    siginfo_t info;
+
+    memset(&info, 0, sizeof(siginfo_t));
+    info.si_signo = sig;
+    info.si_code = SI_ASYNCNL;
+    info.si_pid = caller_pid;
+    info.si_uid = getuid();
+    info.si_value = val;
+
+    return syscall(__NR_rt_sigqueueinfo, info.si_pid, sig, &info);
+}
+
+#if defined (__cplusplus)
+}
+#endif
diff --git a/libs/libglibc-compatibility/glibc-compatibility.h b/libs/libglibc-compatibility/glibc-compatibility.h
new file mode 100644
index 00000000000..aeea2fc4adb
--- /dev/null
+++ b/libs/libglibc-compatibility/glibc-compatibility.h
@@ -0,0 +1,37 @@
+#pragma once
+
+/** Allows to build programs with libc 2.18 and run on systems with at least libc 2.11,
+  *  such as Ubuntu Lucid or CentOS 6.
+  *
+  * Highly experimental, not recommended, disabled by default.
+  *
+  * Also look at http://www.lightofdawn.org/wiki/wiki.cgi/NewAppsOnOldGlibc
+  *
+  * If you want even older systems, such as Ubuntu Hardy,
+  *  add fallocate, pipe2, __longjmp_chk, __vasprintf_chk.
+  */
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+__attribute__((__weak__)) long int __fdelt_chk(long int d);
+
+#include <sys/poll.h>
+#include <stddef.h>
+
+__attribute__((__weak__)) int __poll_chk(struct pollfd * fds, nfds_t nfds, int timeout, size_t fdslen);
+
+#include <pthread.h>
+
+__attribute__((__weak__)) size_t __pthread_get_minstack(const pthread_attr_t * attr);
+
+#include <signal.h>
+#include <unistd.h>
+
+__attribute__((__weak__)) int __gai_sigqueue(int sig, const union sigval val, pid_t caller_pid);
+
+#if defined (__cplusplus)
+}
+#endif

From dd8348421ceac19af30279af73eb30ddc5aee600 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 08:43:43 +0300
Subject: [PATCH 215/266] Simplification [#CLICKHOUSE-3275].

---
 .../glibc-compatibility.c                     | 16 +++++++-
 .../glibc-compatibility.h                     | 37 -------------------
 2 files changed, 15 insertions(+), 38 deletions(-)
 delete mode 100644 libs/libglibc-compatibility/glibc-compatibility.h

diff --git a/libs/libglibc-compatibility/glibc-compatibility.c b/libs/libglibc-compatibility/glibc-compatibility.c
index 5524017b61f..cb0dd617bdf 100644
--- a/libs/libglibc-compatibility/glibc-compatibility.c
+++ b/libs/libglibc-compatibility/glibc-compatibility.c
@@ -1,4 +1,13 @@
-#include "glibc-compatibility.h"
+/** Allows to build programs with libc 2.18 and run on systems with at least libc 2.11,
+  *  such as Ubuntu Lucid or CentOS 6.
+  *
+  * Highly experimental, not recommended, disabled by default.
+  *
+  * Also look at http://www.lightofdawn.org/wiki/wiki.cgi/NewAppsOnOldGlibc
+  *
+  * If you want even older systems, such as Ubuntu Hardy,
+  *  add fallocate, pipe2, __longjmp_chk, __vasprintf_chk.
+  */
 
 #if defined (__cplusplus)
 extern "C" {
@@ -14,6 +23,8 @@ long int __fdelt_chk(long int d)
     return d / __NFDBITS;
 }
 
+#include <sys/poll.h>
+#include <stddef.h>
 
 int __poll_chk(struct pollfd * fds, nfds_t nfds, int timeout, size_t fdslen)
 {
@@ -22,12 +33,15 @@ int __poll_chk(struct pollfd * fds, nfds_t nfds, int timeout, size_t fdslen)
     return poll(fds, nfds, timeout);
 }
 
+#include <pthread.h>
 
 size_t __pthread_get_minstack(const pthread_attr_t * attr)
 {
     return 1048576;        /// This is a guess. Don't sure it is correct.
 }
 
+#include <signal.h>
+#include <unistd.h>
 #include <string.h>
 #include <sys/syscall.h>
 
diff --git a/libs/libglibc-compatibility/glibc-compatibility.h b/libs/libglibc-compatibility/glibc-compatibility.h
deleted file mode 100644
index aeea2fc4adb..00000000000
--- a/libs/libglibc-compatibility/glibc-compatibility.h
+++ /dev/null
@@ -1,37 +0,0 @@
-#pragma once
-
-/** Allows to build programs with libc 2.18 and run on systems with at least libc 2.11,
-  *  such as Ubuntu Lucid or CentOS 6.
-  *
-  * Highly experimental, not recommended, disabled by default.
-  *
-  * Also look at http://www.lightofdawn.org/wiki/wiki.cgi/NewAppsOnOldGlibc
-  *
-  * If you want even older systems, such as Ubuntu Hardy,
-  *  add fallocate, pipe2, __longjmp_chk, __vasprintf_chk.
-  */
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-__attribute__((__weak__)) long int __fdelt_chk(long int d);
-
-#include <sys/poll.h>
-#include <stddef.h>
-
-__attribute__((__weak__)) int __poll_chk(struct pollfd * fds, nfds_t nfds, int timeout, size_t fdslen);
-
-#include <pthread.h>
-
-__attribute__((__weak__)) size_t __pthread_get_minstack(const pthread_attr_t * attr);
-
-#include <signal.h>
-#include <unistd.h>
-
-__attribute__((__weak__)) int __gai_sigqueue(int sig, const union sigval val, pid_t caller_pid);
-
-#if defined (__cplusplus)
-}
-#endif

From db431bf9496f8e9f74087207ff6db91a09c297bc Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 10:24:53 +0300
Subject: [PATCH 216/266] Better GLIBC_COMPATIBILITY option [#CLICKHOUSE-3275].

---
 CMakeLists.txt                                |   2 +-
 libs/libglibc-compatibility/CMakeLists.txt    |   3 +-
 .../glibc-compatibility.c                     |  92 ++++--
 libs/libglibc-compatibility/musl/COPYRIGHT    | 163 +++++++++++
 libs/libglibc-compatibility/musl/README       |   6 +
 libs/libglibc-compatibility/musl/fallocate.c  |  10 +
 libs/libglibc-compatibility/musl/lgamma.c     | 268 ++++++++++++++++++
 libs/libglibc-compatibility/musl/longjmp.s    |  22 ++
 libs/libglibc-compatibility/musl/pipe2.c      |  24 ++
 libs/libglibc-compatibility/musl/vasprintf.c  |  15 +
 10 files changed, 580 insertions(+), 25 deletions(-)
 create mode 100644 libs/libglibc-compatibility/musl/COPYRIGHT
 create mode 100644 libs/libglibc-compatibility/musl/README
 create mode 100644 libs/libglibc-compatibility/musl/fallocate.c
 create mode 100644 libs/libglibc-compatibility/musl/lgamma.c
 create mode 100644 libs/libglibc-compatibility/musl/longjmp.s
 create mode 100644 libs/libglibc-compatibility/musl/pipe2.c
 create mode 100644 libs/libglibc-compatibility/musl/vasprintf.c

diff --git a/CMakeLists.txt b/CMakeLists.txt
index a671fe1b775..98d8fcd578b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -192,7 +192,7 @@ if (UNBUNDLED)
 else ()
     set(NOT_UNBUNDLED 1)
 endif ()
-# Using system libs can cause lot of warnings in includes. 
+# Using system libs can cause lot of warnings in includes.
 if (UNBUNDLED OR NOT (CMAKE_SYSTEM MATCHES "Linux" OR APPLE) OR ARCH_32)
     option (NO_WERROR "Disable -Werror compiler option" ON)
 endif ()
diff --git a/libs/libglibc-compatibility/CMakeLists.txt b/libs/libglibc-compatibility/CMakeLists.txt
index e8c5a4ba757..9521dba9eab 100644
--- a/libs/libglibc-compatibility/CMakeLists.txt
+++ b/libs/libglibc-compatibility/CMakeLists.txt
@@ -1 +1,2 @@
-add_library (glibc-compatibility glibc-compatibility.c)
+enable_language (ASM)
+add_library (glibc-compatibility glibc-compatibility.c musl/pipe2.c musl/fallocate.c musl/longjmp.s musl/vasprintf.c musl/lgamma.c)
diff --git a/libs/libglibc-compatibility/glibc-compatibility.c b/libs/libglibc-compatibility/glibc-compatibility.c
index cb0dd617bdf..e06bac8e290 100644
--- a/libs/libglibc-compatibility/glibc-compatibility.c
+++ b/libs/libglibc-compatibility/glibc-compatibility.c
@@ -1,18 +1,46 @@
-/** Allows to build programs with libc 2.18 and run on systems with at least libc 2.11,
+/** Allows to build programs with libc 2.18 and run on systems with at least libc 2.4,
   *  such as Ubuntu Lucid or CentOS 6.
   *
   * Highly experimental, not recommended, disabled by default.
   *
   * Also look at http://www.lightofdawn.org/wiki/wiki.cgi/NewAppsOnOldGlibc
-  *
-  * If you want even older systems, such as Ubuntu Hardy,
-  *  add fallocate, pipe2, __longjmp_chk, __vasprintf_chk.
   */
 
 #if defined (__cplusplus)
 extern "C" {
 #endif
 
+#include <pthread.h>
+
+size_t __pthread_get_minstack(const pthread_attr_t * attr)
+{
+    return 1048576;        /// This is a guess. Don't sure it is correct.
+}
+
+#include <signal.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/syscall.h>
+
+long int syscall(long int __sysno, ...) __THROW;
+
+int __gai_sigqueue(int sig, const union sigval val, pid_t caller_pid)
+{
+    siginfo_t info;
+
+    memset(&info, 0, sizeof(siginfo_t));
+    info.si_signo = sig;
+    info.si_code = SI_ASYNCNL;
+    info.si_pid = caller_pid;
+    info.si_uid = getuid();
+    info.si_value = val;
+
+    return syscall(__NR_rt_sigqueueinfo, info.si_pid, sig, &info);
+}
+
+
+/// NOTE This disables some of FORTIFY_SOURCE functionality.
+
 #include <sys/select.h>
 #include <stdlib.h>
 
@@ -33,34 +61,52 @@ int __poll_chk(struct pollfd * fds, nfds_t nfds, int timeout, size_t fdslen)
     return poll(fds, nfds, timeout);
 }
 
-#include <pthread.h>
+#include <setjmp.h>
 
-size_t __pthread_get_minstack(const pthread_attr_t * attr)
+void longjmp(jmp_buf env, int val);
+
+void __longjmp_chk(jmp_buf env, int val)
 {
-    return 1048576;        /// This is a guess. Don't sure it is correct.
+    return longjmp(env, val);
 }
 
-#include <signal.h>
-#include <unistd.h>
-#include <string.h>
-#include <sys/syscall.h>
+#include <stdio.h>
 
-extern long int syscall (long int __sysno, ...) __THROW;
+int vasprintf(char **s, const char *fmt, va_list ap);
 
-int __gai_sigqueue(int sig, const union sigval val, pid_t caller_pid)
+int __vasprintf_chk(char **s, const char *fmt, va_list ap)
 {
-    siginfo_t info;
-
-    memset(&info, 0, sizeof(siginfo_t));
-    info.si_signo = sig;
-    info.si_code = SI_ASYNCNL;
-    info.si_pid = caller_pid;
-    info.si_uid = getuid();
-    info.si_value = val;
-
-    return syscall(__NR_rt_sigqueueinfo, info.si_pid, sig, &info);
+    return vasprintf(s, fmt, ap);
 }
 
+size_t __fread_chk(void *ptr, size_t size, size_t nmemb, FILE *stream)
+{
+    return fread(ptr, size, nmemb, stream);
+}
+
+
+#include <stdarg.h>
+
+int vsscanf(const char *str, const char *format, va_list ap);
+
+int __isoc99_vsscanf(const char *str, const char *format, va_list ap)
+{
+    return vsscanf(str, format, ap);
+}
+
+int sscanf(const char *restrict s, const char *restrict fmt, ...)
+{
+    int ret;
+    va_list ap;
+    va_start(ap, fmt);
+    ret = vsscanf(s, fmt, ap);
+    va_end(ap);
+    return ret;
+}
+
+int __isoc99_sscanf(const char *str, const char *format, ...) __attribute__((weak, alias("sscanf")));
+
+
 #if defined (__cplusplus)
 }
 #endif
diff --git a/libs/libglibc-compatibility/musl/COPYRIGHT b/libs/libglibc-compatibility/musl/COPYRIGHT
new file mode 100644
index 00000000000..f0ee3b78d87
--- /dev/null
+++ b/libs/libglibc-compatibility/musl/COPYRIGHT
@@ -0,0 +1,163 @@
+musl as a whole is licensed under the following standard MIT license:
+
+----------------------------------------------------------------------
+Copyright © 2005-2014 Rich Felker, et al.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+----------------------------------------------------------------------
+
+Authors/contributors include:
+
+Alex Dowad
+Alexander Monakov
+Anthony G. Basile
+Arvid Picciani
+Bobby Bingham
+Boris Brezillon
+Brent Cook
+Chris Spiegel
+Clément Vasseur
+Daniel Micay
+Denys Vlasenko
+Emil Renner Berthing
+Felix Fietkau
+Felix Janda
+Gianluca Anzolin
+Hauke Mehrtens
+Hiltjo Posthuma
+Isaac Dunham
+Jaydeep Patil
+Jens Gustedt
+Jeremy Huntwork
+Jo-Philipp Wich
+Joakim Sindholt
+John Spencer
+Josiah Worcester
+Justin Cormack
+Khem Raj
+Kylie McClain
+Luca Barbato
+Luka Perkov
+M Farkas-Dyck (Strake)
+Mahesh Bodapati
+Michael Forney
+Natanael Copa
+Nicholas J. Kain
+orc
+Pascal Cuoq
+Petr Hosek
+Pierre Carrier
+Rich Felker
+Richard Pennington
+Shiz
+sin
+Solar Designer
+Stefan Kristiansson
+Szabolcs Nagy
+Timo Teräs
+Trutz Behn
+Valentin Ochs
+William Haddon
+
+Portions of this software are derived from third-party works licensed
+under terms compatible with the above MIT license:
+
+The TRE regular expression implementation (src/regex/reg* and
+src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
+under a 2-clause BSD license (license text in the source files). The
+included version has been heavily modified by Rich Felker in 2012, in
+the interests of size, simplicity, and namespace cleanliness.
+
+Much of the math library code (src/math/* and src/complex/*) is
+Copyright © 1993,2004 Sun Microsystems or
+Copyright © 2003-2011 David Schultz or
+Copyright © 2003-2009 Steven G. Kargl or
+Copyright © 2003-2009 Bruce D. Evans or
+Copyright © 2008 Stephen L. Moshier
+and labelled as such in comments in the individual source files. All
+have been licensed under extremely permissive terms.
+
+The ARM memcpy code (src/string/arm/memcpy_el.S) is Copyright © 2008
+The Android Open Source Project and is licensed under a two-clause BSD
+license. It was taken from Bionic libc, used on Android.
+
+The implementation of DES for crypt (src/crypt/crypt_des.c) is
+Copyright © 1994 David Burren. It is licensed under a BSD license.
+
+The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
+originally written by Solar Designer and placed into the public
+domain. The code also comes with a fallback permissive license for use
+in jurisdictions that may not recognize the public domain.
+
+The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
+Valentin Ochs and is licensed under an MIT-style license.
+
+The BSD PRNG implementation (src/prng/random.c) and XSI search API
+(src/search/*.c) functions are Copyright © 2011 Szabolcs Nagy and
+licensed under following terms: "Permission to use, copy, modify,
+and/or distribute this code for any purpose with or without fee is
+hereby granted. There is no warranty."
+
+The x86_64 port was written by Nicholas J. Kain and is licensed under
+the standard MIT terms.
+
+The mips and microblaze ports were originally written by Richard
+Pennington for use in the ellcc project. The original code was adapted
+by Rich Felker for build system and code conventions during upstream
+integration. It is licensed under the standard MIT terms.
+
+The mips64 port was contributed by Imagination Technologies and is
+licensed under the standard MIT terms.
+
+The powerpc port was also originally written by Richard Pennington,
+and later supplemented and integrated by John Spencer. It is licensed
+under the standard MIT terms.
+
+All other files which have no copyright comments are original works
+produced specifically for use as part of this library, written either
+by Rich Felker, the main author of the library, or by one or more
+contibutors listed above. Details on authorship of individual files
+can be found in the git version control history of the project. The
+omission of copyright and license comments in each file is in the
+interest of source tree size.
+
+In addition, permission is hereby granted for all public header files
+(include/* and arch/*/bits/*) and crt files intended to be linked into
+applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
+the copyright notice and permission notice otherwise required by the
+license, and to use these files without any requirement of
+attribution. These files include substantial contributions from:
+
+Bobby Bingham
+John Spencer
+Nicholas J. Kain
+Rich Felker
+Richard Pennington
+Stefan Kristiansson
+Szabolcs Nagy
+
+all of whom have explicitly granted such permission.
+
+This file previously contained text expressing a belief that most of
+the files covered by the above exception were sufficiently trivial not
+to be subject to copyright, resulting in confusion over whether it
+negated the permissions granted in the license. In the spirit of
+permissive licensing, and of not having licensing issues being an
+obstacle to adoption, that text has been removed.
diff --git a/libs/libglibc-compatibility/musl/README b/libs/libglibc-compatibility/musl/README
new file mode 100644
index 00000000000..11f6caa2d7e
--- /dev/null
+++ b/libs/libglibc-compatibility/musl/README
@@ -0,0 +1,6 @@
+Tiny pieces extracted from MUSL library.
+
+git://git.musl-libc.org/musl
+c10bc61508dc52b8315084e628f36a6c3c2dabb1
+
+NOTE: Files was edited.
diff --git a/libs/libglibc-compatibility/musl/fallocate.c b/libs/libglibc-compatibility/musl/fallocate.c
new file mode 100644
index 00000000000..31e63822c94
--- /dev/null
+++ b/libs/libglibc-compatibility/musl/fallocate.c
@@ -0,0 +1,10 @@
+#define _GNU_SOURCE
+#include <fcntl.h>
+#include <sys/syscall.h>
+
+extern long int syscall (long int __sysno, ...) __THROW;
+
+int fallocate(int fd, int mode, off_t base, off_t len)
+{
+	return syscall(SYS_fallocate, fd, mode, base, len);
+}
diff --git a/libs/libglibc-compatibility/musl/lgamma.c b/libs/libglibc-compatibility/musl/lgamma.c
new file mode 100644
index 00000000000..55a1f9e46a4
--- /dev/null
+++ b/libs/libglibc-compatibility/musl/lgamma.c
@@ -0,0 +1,268 @@
+/* origin: FreeBSD /usr/src/lib/msun/src/e_lgamma_r.c */
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunSoft, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ *
+ */
+/* lgamma_r(x, signgamp)
+ * Reentrant version of the logarithm of the Gamma function
+ * with user provide pointer for the sign of Gamma(x).
+ *
+ * Method:
+ *   1. Argument Reduction for 0 < x <= 8
+ *      Since gamma(1+s)=s*gamma(s), for x in [0,8], we may
+ *      reduce x to a number in [1.5,2.5] by
+ *              lgamma(1+s) = log(s) + lgamma(s)
+ *      for example,
+ *              lgamma(7.3) = log(6.3) + lgamma(6.3)
+ *                          = log(6.3*5.3) + lgamma(5.3)
+ *                          = log(6.3*5.3*4.3*3.3*2.3) + lgamma(2.3)
+ *   2. Polynomial approximation of lgamma around its
+ *      minimun ymin=1.461632144968362245 to maintain monotonicity.
+ *      On [ymin-0.23, ymin+0.27] (i.e., [1.23164,1.73163]), use
+ *              Let z = x-ymin;
+ *              lgamma(x) = -1.214862905358496078218 + z^2*poly(z)
+ *      where
+ *              poly(z) is a 14 degree polynomial.
+ *   2. Rational approximation in the primary interval [2,3]
+ *      We use the following approximation:
+ *              s = x-2.0;
+ *              lgamma(x) = 0.5*s + s*P(s)/Q(s)
+ *      with accuracy
+ *              |P/Q - (lgamma(x)-0.5s)| < 2**-61.71
+ *      Our algorithms are based on the following observation
+ *
+ *                             zeta(2)-1    2    zeta(3)-1    3
+ * lgamma(2+s) = s*(1-Euler) + --------- * s  -  --------- * s  + ...
+ *                                 2                 3
+ *
+ *      where Euler = 0.5771... is the Euler constant, which is very
+ *      close to 0.5.
+ *
+ *   3. For x>=8, we have
+ *      lgamma(x)~(x-0.5)log(x)-x+0.5*log(2pi)+1/(12x)-1/(360x**3)+....
+ *      (better formula:
+ *         lgamma(x)~(x-0.5)*(log(x)-1)-.5*(log(2pi)-1) + ...)
+ *      Let z = 1/x, then we approximation
+ *              f(z) = lgamma(x) - (x-0.5)(log(x)-1)
+ *      by
+ *                                  3       5             11
+ *              w = w0 + w1*z + w2*z  + w3*z  + ... + w6*z
+ *      where
+ *              |w - f(z)| < 2**-58.74
+ *
+ *   4. For negative x, since (G is gamma function)
+ *              -x*G(-x)*G(x) = pi/sin(pi*x),
+ *      we have
+ *              G(x) = pi/(sin(pi*x)*(-x)*G(-x))
+ *      since G(-x) is positive, sign(G(x)) = sign(sin(pi*x)) for x<0
+ *      Hence, for x<0, signgam = sign(sin(pi*x)) and
+ *              lgamma(x) = log(|Gamma(x)|)
+ *                        = log(pi/(|x*sin(pi*x)|)) - lgamma(-x);
+ *      Note: one should avoid compute pi*(-x) directly in the
+ *            computation of sin(pi*(-x)).
+ *
+ *   5. Special Cases
+ *              lgamma(2+s) ~ s*(1-Euler) for tiny s
+ *              lgamma(1) = lgamma(2) = 0
+ *              lgamma(x) ~ -log(|x|) for tiny x
+ *              lgamma(0) = lgamma(neg.integer) = inf and raise divide-by-zero
+ *              lgamma(inf) = inf
+ *              lgamma(-inf) = inf (bug for bug compatible with C99!?)
+ *
+ */
+
+static const double
+pi  =  3.14159265358979311600e+00, /* 0x400921FB, 0x54442D18 */
+a0  =  7.72156649015328655494e-02, /* 0x3FB3C467, 0xE37DB0C8 */
+a1  =  3.22467033424113591611e-01, /* 0x3FD4A34C, 0xC4A60FAD */
+a2  =  6.73523010531292681824e-02, /* 0x3FB13E00, 0x1A5562A7 */
+a3  =  2.05808084325167332806e-02, /* 0x3F951322, 0xAC92547B */
+a4  =  7.38555086081402883957e-03, /* 0x3F7E404F, 0xB68FEFE8 */
+a5  =  2.89051383673415629091e-03, /* 0x3F67ADD8, 0xCCB7926B */
+a6  =  1.19270763183362067845e-03, /* 0x3F538A94, 0x116F3F5D */
+a7  =  5.10069792153511336608e-04, /* 0x3F40B6C6, 0x89B99C00 */
+a8  =  2.20862790713908385557e-04, /* 0x3F2CF2EC, 0xED10E54D */
+a9  =  1.08011567247583939954e-04, /* 0x3F1C5088, 0x987DFB07 */
+a10 =  2.52144565451257326939e-05, /* 0x3EFA7074, 0x428CFA52 */
+a11 =  4.48640949618915160150e-05, /* 0x3F07858E, 0x90A45837 */
+tc  =  1.46163214496836224576e+00, /* 0x3FF762D8, 0x6356BE3F */
+tf  = -1.21486290535849611461e-01, /* 0xBFBF19B9, 0xBCC38A42 */
+/* tt = -(tail of tf) */
+tt  = -3.63867699703950536541e-18, /* 0xBC50C7CA, 0xA48A971F */
+t0  =  4.83836122723810047042e-01, /* 0x3FDEF72B, 0xC8EE38A2 */
+t1  = -1.47587722994593911752e-01, /* 0xBFC2E427, 0x8DC6C509 */
+t2  =  6.46249402391333854778e-02, /* 0x3FB08B42, 0x94D5419B */
+t3  = -3.27885410759859649565e-02, /* 0xBFA0C9A8, 0xDF35B713 */
+t4  =  1.79706750811820387126e-02, /* 0x3F9266E7, 0x970AF9EC */
+t5  = -1.03142241298341437450e-02, /* 0xBF851F9F, 0xBA91EC6A */
+t6  =  6.10053870246291332635e-03, /* 0x3F78FCE0, 0xE370E344 */
+t7  = -3.68452016781138256760e-03, /* 0xBF6E2EFF, 0xB3E914D7 */
+t8  =  2.25964780900612472250e-03, /* 0x3F6282D3, 0x2E15C915 */
+t9  = -1.40346469989232843813e-03, /* 0xBF56FE8E, 0xBF2D1AF1 */
+t10 =  8.81081882437654011382e-04, /* 0x3F4CDF0C, 0xEF61A8E9 */
+t11 = -5.38595305356740546715e-04, /* 0xBF41A610, 0x9C73E0EC */
+t12 =  3.15632070903625950361e-04, /* 0x3F34AF6D, 0x6C0EBBF7 */
+t13 = -3.12754168375120860518e-04, /* 0xBF347F24, 0xECC38C38 */
+t14 =  3.35529192635519073543e-04, /* 0x3F35FD3E, 0xE8C2D3F4 */
+u0  = -7.72156649015328655494e-02, /* 0xBFB3C467, 0xE37DB0C8 */
+u1  =  6.32827064025093366517e-01, /* 0x3FE4401E, 0x8B005DFF */
+u2  =  1.45492250137234768737e+00, /* 0x3FF7475C, 0xD119BD6F */
+u3  =  9.77717527963372745603e-01, /* 0x3FEF4976, 0x44EA8450 */
+u4  =  2.28963728064692451092e-01, /* 0x3FCD4EAE, 0xF6010924 */
+u5  =  1.33810918536787660377e-02, /* 0x3F8B678B, 0xBF2BAB09 */
+v1  =  2.45597793713041134822e+00, /* 0x4003A5D7, 0xC2BD619C */
+v2  =  2.12848976379893395361e+00, /* 0x40010725, 0xA42B18F5 */
+v3  =  7.69285150456672783825e-01, /* 0x3FE89DFB, 0xE45050AF */
+v4  =  1.04222645593369134254e-01, /* 0x3FBAAE55, 0xD6537C88 */
+v5  =  3.21709242282423911810e-03, /* 0x3F6A5ABB, 0x57D0CF61 */
+s0  = -7.72156649015328655494e-02, /* 0xBFB3C467, 0xE37DB0C8 */
+s1  =  2.14982415960608852501e-01, /* 0x3FCB848B, 0x36E20878 */
+s2  =  3.25778796408930981787e-01, /* 0x3FD4D98F, 0x4F139F59 */
+s3  =  1.46350472652464452805e-01, /* 0x3FC2BB9C, 0xBEE5F2F7 */
+s4  =  2.66422703033638609560e-02, /* 0x3F9B481C, 0x7E939961 */
+s5  =  1.84028451407337715652e-03, /* 0x3F5E26B6, 0x7368F239 */
+s6  =  3.19475326584100867617e-05, /* 0x3F00BFEC, 0xDD17E945 */
+r1  =  1.39200533467621045958e+00, /* 0x3FF645A7, 0x62C4AB74 */
+r2  =  7.21935547567138069525e-01, /* 0x3FE71A18, 0x93D3DCDC */
+r3  =  1.71933865632803078993e-01, /* 0x3FC601ED, 0xCCFBDF27 */
+r4  =  1.86459191715652901344e-02, /* 0x3F9317EA, 0x742ED475 */
+r5  =  7.77942496381893596434e-04, /* 0x3F497DDA, 0xCA41A95B */
+r6  =  7.32668430744625636189e-06, /* 0x3EDEBAF7, 0xA5B38140 */
+w0  =  4.18938533204672725052e-01, /* 0x3FDACFE3, 0x90C97D69 */
+w1  =  8.33333333333329678849e-02, /* 0x3FB55555, 0x5555553B */
+w2  = -2.77777777728775536470e-03, /* 0xBF66C16C, 0x16B02E5C */
+w3  =  7.93650558643019558500e-04, /* 0x3F4A019F, 0x98CF38B6 */
+w4  = -5.95187557450339963135e-04, /* 0xBF4380CB, 0x8C0FE741 */
+w5  =  8.36339918996282139126e-04, /* 0x3F4B67BA, 0x4CDAD5D1 */
+w6  = -1.63092934096575273989e-03; /* 0xBF5AB89D, 0x0B9E43E4 */
+
+#include <stdint.h>
+#include <math.h>
+
+double lgamma_r(double x, int *signgamp)
+{
+	union {double f; uint64_t i;} u = {x};
+	double_t t,y,z,nadj,p,p1,p2,p3,q,r,w;
+	uint32_t ix;
+	int sign,i;
+
+	/* purge off +-inf, NaN, +-0, tiny and negative arguments */
+	*signgamp = 1;
+	sign = u.i>>63;
+	ix = u.i>>32 & 0x7fffffff;
+	if (ix >= 0x7ff00000)
+		return x*x;
+	if (ix < (0x3ff-70)<<20) {  /* |x|<2**-70, return -log(|x|) */
+		if(sign) {
+			x = -x;
+			*signgamp = -1;
+		}
+		return -log(x);
+	}
+	if (sign) {
+		x = -x;
+		t = sin(pi * x);
+		if (t == 0.0) /* -integer */
+			return 1.0/(x-x);
+		if (t > 0.0)
+			*signgamp = -1;
+		else
+			t = -t;
+		nadj = log(pi/(t*x));
+	}
+
+	/* purge off 1 and 2 */
+	if ((ix == 0x3ff00000 || ix == 0x40000000) && (uint32_t)u.i == 0)
+		r = 0;
+	/* for x < 2.0 */
+	else if (ix < 0x40000000) {
+		if (ix <= 0x3feccccc) {   /* lgamma(x) = lgamma(x+1)-log(x) */
+			r = -log(x);
+			if (ix >= 0x3FE76944) {
+				y = 1.0 - x;
+				i = 0;
+			} else if (ix >= 0x3FCDA661) {
+				y = x - (tc-1.0);
+				i = 1;
+			} else {
+				y = x;
+				i = 2;
+			}
+		} else {
+			r = 0.0;
+			if (ix >= 0x3FFBB4C3) {  /* [1.7316,2] */
+				y = 2.0 - x;
+				i = 0;
+			} else if(ix >= 0x3FF3B4C4) {  /* [1.23,1.73] */
+				y = x - tc;
+				i = 1;
+			} else {
+				y = x - 1.0;
+				i = 2;
+			}
+		}
+		switch (i) {
+		case 0:
+			z = y*y;
+			p1 = a0+z*(a2+z*(a4+z*(a6+z*(a8+z*a10))));
+			p2 = z*(a1+z*(a3+z*(a5+z*(a7+z*(a9+z*a11)))));
+			p = y*p1+p2;
+			r += (p-0.5*y);
+			break;
+		case 1:
+			z = y*y;
+			w = z*y;
+			p1 = t0+w*(t3+w*(t6+w*(t9 +w*t12)));    /* parallel comp */
+			p2 = t1+w*(t4+w*(t7+w*(t10+w*t13)));
+			p3 = t2+w*(t5+w*(t8+w*(t11+w*t14)));
+			p = z*p1-(tt-w*(p2+y*p3));
+			r += tf + p;
+			break;
+		case 2:
+			p1 = y*(u0+y*(u1+y*(u2+y*(u3+y*(u4+y*u5)))));
+			p2 = 1.0+y*(v1+y*(v2+y*(v3+y*(v4+y*v5))));
+			r += -0.5*y + p1/p2;
+		}
+	} else if (ix < 0x40200000) {  /* x < 8.0 */
+		i = (int)x;
+		y = x - (double)i;
+		p = y*(s0+y*(s1+y*(s2+y*(s3+y*(s4+y*(s5+y*s6))))));
+		q = 1.0+y*(r1+y*(r2+y*(r3+y*(r4+y*(r5+y*r6)))));
+		r = 0.5*y+p/q;
+		z = 1.0;    /* lgamma(1+s) = log(s) + lgamma(s) */
+		switch (i) {
+		case 7: z *= y + 6.0;  /* FALLTHRU */
+		case 6: z *= y + 5.0;  /* FALLTHRU */
+		case 5: z *= y + 4.0;  /* FALLTHRU */
+		case 4: z *= y + 3.0;  /* FALLTHRU */
+		case 3: z *= y + 2.0;  /* FALLTHRU */
+			r += log(z);
+			break;
+		}
+	} else if (ix < 0x43900000) {  /* 8.0 <= x < 2**58 */
+		t = log(x);
+		z = 1.0/x;
+		y = z*z;
+		w = w0+z*(w1+y*(w2+y*(w3+y*(w4+y*(w5+y*w6)))));
+		r = (x-0.5)*(t-1.0)+w;
+	} else                         /* 2**58 <= x <= inf */
+		r =  x*(log(x)-1.0);
+	if (sign)
+		r = nadj - r;
+	return r;
+}
+
+
+int signgam;
+
+double lgamma(double x)
+{
+	return lgamma_r(x, &signgam);
+}
diff --git a/libs/libglibc-compatibility/musl/longjmp.s b/libs/libglibc-compatibility/musl/longjmp.s
new file mode 100644
index 00000000000..e175a4b9606
--- /dev/null
+++ b/libs/libglibc-compatibility/musl/longjmp.s
@@ -0,0 +1,22 @@
+/* Copyright 2011-2012 Nicholas J. Kain, licensed under standard MIT license */
+.global _longjmp
+.global longjmp
+.type _longjmp,@function
+.type longjmp,@function
+_longjmp:
+longjmp:
+	mov %rsi,%rax           /* val will be longjmp return */
+	test %rax,%rax
+	jnz 1f
+	inc %rax                /* if val==0, val=1 per longjmp semantics */
+1:
+	mov (%rdi),%rbx         /* rdi is the jmp_buf, restore regs from it */
+	mov 8(%rdi),%rbp
+	mov 16(%rdi),%r12
+	mov 24(%rdi),%r13
+	mov 32(%rdi),%r14
+	mov 40(%rdi),%r15
+	mov 48(%rdi),%rdx       /* this ends up being the stack pointer */
+	mov %rdx,%rsp
+	mov 56(%rdi),%rdx       /* this is the instruction pointer */
+	jmp *%rdx               /* goto saved address without altering rsp */
diff --git a/libs/libglibc-compatibility/musl/pipe2.c b/libs/libglibc-compatibility/musl/pipe2.c
new file mode 100644
index 00000000000..061f2e07313
--- /dev/null
+++ b/libs/libglibc-compatibility/musl/pipe2.c
@@ -0,0 +1,24 @@
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/syscall.h>
+
+extern long int syscall (long int __sysno, ...) __THROW;
+
+int pipe2(int fd[2], int flag)
+{
+	if (!flag) return pipe(fd);
+	int ret = syscall(SYS_pipe2, fd, flag);
+	if (ret != -ENOSYS) return -ret;
+	ret = pipe(fd);
+	if (ret) return ret;
+	if (flag & O_CLOEXEC) {
+		syscall(SYS_fcntl, fd[0], F_SETFD, FD_CLOEXEC);
+		syscall(SYS_fcntl, fd[1], F_SETFD, FD_CLOEXEC);
+	}
+	if (flag & O_NONBLOCK) {
+		syscall(SYS_fcntl, fd[0], F_SETFL, O_NONBLOCK);
+		syscall(SYS_fcntl, fd[1], F_SETFL, O_NONBLOCK);
+	}
+	return 0;
+}
diff --git a/libs/libglibc-compatibility/musl/vasprintf.c b/libs/libglibc-compatibility/musl/vasprintf.c
new file mode 100644
index 00000000000..08251bc20ec
--- /dev/null
+++ b/libs/libglibc-compatibility/musl/vasprintf.c
@@ -0,0 +1,15 @@
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+
+int vasprintf(char **s, const char *fmt, va_list ap)
+{
+	va_list ap2;
+	va_copy(ap2, ap);
+	int l = vsnprintf(0, 0, fmt, ap2);
+	va_end(ap2);
+
+	if (l<0 || !(*s=malloc(l+1U))) return -1;
+	return vsnprintf(*s, l+1U, fmt, ap);
+}

From 705c159eaf44cc4fe51028aa0b851b49de3352af Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 10:29:03 +0300
Subject: [PATCH 217/266] Better GLIBC_COMPATIBILITY option [#CLICKHOUSE-3275].

---
 libs/libglibc-compatibility/glibc-compatibility.c | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/libs/libglibc-compatibility/glibc-compatibility.c b/libs/libglibc-compatibility/glibc-compatibility.c
index e06bac8e290..6aed44a3efd 100644
--- a/libs/libglibc-compatibility/glibc-compatibility.c
+++ b/libs/libglibc-compatibility/glibc-compatibility.c
@@ -70,7 +70,7 @@ void __longjmp_chk(jmp_buf env, int val)
     return longjmp(env, val);
 }
 
-#include <stdio.h>
+#include <stdarg.h>
 
 int vasprintf(char **s, const char *fmt, va_list ap);
 
@@ -79,14 +79,13 @@ int __vasprintf_chk(char **s, const char *fmt, va_list ap)
     return vasprintf(s, fmt, ap);
 }
 
-size_t __fread_chk(void *ptr, size_t size, size_t nmemb, FILE *stream)
+size_t fread(void *ptr, size_t size, size_t nmemb, void *stream);
+
+size_t __fread_chk(void *ptr, size_t size, size_t nmemb, void *stream)
 {
     return fread(ptr, size, nmemb, stream);
 }
 
-
-#include <stdarg.h>
-
 int vsscanf(const char *str, const char *format, va_list ap);
 
 int __isoc99_vsscanf(const char *str, const char *format, va_list ap)

From 4f4c972019259cd7ffd4e6a3f7ad3b9092f5cde9 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 10:32:27 +0300
Subject: [PATCH 218/266] Better GLIBC_COMPATIBILITY option [#CLICKHOUSE-3275].

---
 libs/libglibc-compatibility/musl/lgamma.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libs/libglibc-compatibility/musl/lgamma.c b/libs/libglibc-compatibility/musl/lgamma.c
index 55a1f9e46a4..b0e4f3aa537 100644
--- a/libs/libglibc-compatibility/musl/lgamma.c
+++ b/libs/libglibc-compatibility/musl/lgamma.c
@@ -149,7 +149,7 @@ w6  = -1.63092934096575273989e-03; /* 0xBF5AB89D, 0x0B9E43E4 */
 double lgamma_r(double x, int *signgamp)
 {
 	union {double f; uint64_t i;} u = {x};
-	double_t t,y,z,nadj,p,p1,p2,p3,q,r,w;
+	double_t t,y,z,nadj=0,p,p1,p2,p3,q,r,w;
 	uint32_t ix;
 	int sign,i;
 

From c4b8f0067aef3ac12c4aa738df74eaedfedf0122 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 10:51:38 +0300
Subject: [PATCH 219/266] Better GLIBC_COMPATIBILITY option [#CLICKHOUSE-3275].

---
 libs/libglibc-compatibility/glibc-compatibility.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/libs/libglibc-compatibility/glibc-compatibility.c b/libs/libglibc-compatibility/glibc-compatibility.c
index 6aed44a3efd..367bd2de765 100644
--- a/libs/libglibc-compatibility/glibc-compatibility.c
+++ b/libs/libglibc-compatibility/glibc-compatibility.c
@@ -105,6 +105,13 @@ int sscanf(const char *restrict s, const char *restrict fmt, ...)
 
 int __isoc99_sscanf(const char *str, const char *format, ...) __attribute__((weak, alias("sscanf")));
 
+int open(const char *path, int oflag);
+
+int __open_2(const char *path, int oflag)
+{
+    return open(path, oflag);
+}
+
 
 #if defined (__cplusplus)
 }

From 84dad4538a1f148096eb4072486070e0daaae02e Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 12:18:52 +0300
Subject: [PATCH 220/266] Fixed incompatibility of debian packages with older
 systems [#CLICKHOUSE-3275].

---
 debian/clickhouse-client.postinst | 3 +++
 debian/rules                      | 5 ++++-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/debian/clickhouse-client.postinst b/debian/clickhouse-client.postinst
index 2e84aad51ed..06b4b8654b0 100644
--- a/debian/clickhouse-client.postinst
+++ b/debian/clickhouse-client.postinst
@@ -1,2 +1,5 @@
+#!/bin/sh
+set -e
+
 mkdir -p /etc/clickhouse-client/conf.d
 chown -R clickhouse: /etc/clickhouse-client
diff --git a/debian/rules b/debian/rules
index c74140a2c51..4738dde4fb6 100755
--- a/debian/rules
+++ b/debian/rules
@@ -95,4 +95,7 @@ endif
 	dh_install --list-missing --sourcedir=$(DESTDIR)
 
 override_dh_shlibdeps:
-	dh_shlibdeps -Xdebian/clickhouse-server-base/usr/share/clickhouse/bin/*
+	true # We depend only on libc and dh_shlibdeps gives us wrong (too strict) dependency.
+
+override_dh_builddeb:
+	dh_builddeb -- -Z gzip # Older systems don't have "xz", so use "gzip" instead.

From ea3a36e15af786f54105031f581192ee9a3cbcd3 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 12:49:50 +0300
Subject: [PATCH 221/266] Fixed readme [#CLICKHOUSE-3275].

---
 libs/libmemcpy/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libs/libmemcpy/README.md b/libs/libmemcpy/README.md
index d3dd14ac55b..e253f6bf5dd 100644
--- a/libs/libmemcpy/README.md
+++ b/libs/libmemcpy/README.md
@@ -5,7 +5,7 @@ It has the following advantages over `libc`-supplied implementation:
 - it is linked statically, so the function can have position-dependent code;
 - your binaries will not depend on `glibc`'s memcpy, that forces dependency on specific symbol version like `memcpy@@GLIBC_2.14` and consequently on specific version of `glibc` library;
 - you can include `memcpy.h` directly and the function has the chance to be inlined, which is beneficial for small but unknown at compile time sizes of memory regions;
-- this version of `memcpy` pretend to be faster (in our benchmarks, the difference is withing few percents).
+- this version of `memcpy` pretend to be faster (in our benchmarks, the difference is within few percents).
 
 Currently it uses the implementation from **Linwei** (skywind3000@163.com).
 Look at https://www.zhihu.com/question/35172305 for discussion.

From 7dc2cd91a78a2798e204cea2f010a0569e1023b1 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 05:58:17 +0300
Subject: [PATCH 222/266] Imported https://github.com/skywind3000/FastMemcpy at
 a74a33a1fb6d400252ab73e417d12f622dd8fe61 [#CLICKHOUSE-2].

---
 libs/libmemcpy/FastMemcpy.h | 692 ++++++++++++++++++++++++++++++++++++
 libs/libmemcpy/LICENSE      |  22 ++
 libs/libmemcpy/README.md    |  97 +++++
 3 files changed, 811 insertions(+)
 create mode 100644 libs/libmemcpy/FastMemcpy.h
 create mode 100644 libs/libmemcpy/LICENSE
 create mode 100644 libs/libmemcpy/README.md

diff --git a/libs/libmemcpy/FastMemcpy.h b/libs/libmemcpy/FastMemcpy.h
new file mode 100644
index 00000000000..65c249dabc1
--- /dev/null
+++ b/libs/libmemcpy/FastMemcpy.h
@@ -0,0 +1,692 @@
+//=====================================================================
+//
+// FastMemcpy.c - skywind3000@163.com, 2015
+//
+// feature:
+// 50% speed up in avg. vs standard memcpy (tested in vc2012/gcc5.1)
+//
+//=====================================================================
+#ifndef __FAST_MEMCPY_H__
+#define __FAST_MEMCPY_H__
+
+#include <stddef.h>
+#include <stdint.h>
+#include <emmintrin.h>
+
+
+//---------------------------------------------------------------------
+// force inline for compilers
+//---------------------------------------------------------------------
+#ifndef INLINE
+#ifdef __GNUC__
+#if (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))
+    #define INLINE         __inline__ __attribute__((always_inline))
+#else
+    #define INLINE         __inline__
+#endif
+#elif defined(_MSC_VER)
+	#define INLINE __forceinline
+#elif (defined(__BORLANDC__) || defined(__WATCOMC__))
+    #define INLINE __inline
+#else
+    #define INLINE 
+#endif
+#endif
+
+
+
+//---------------------------------------------------------------------
+// fast copy for different sizes
+//---------------------------------------------------------------------
+static INLINE void memcpy_sse2_16(void *dst, const void *src) {
+	__m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+	_mm_storeu_si128(((__m128i*)dst) + 0, m0);
+}
+
+static INLINE void memcpy_sse2_32(void *dst, const void *src) {
+	__m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+	__m128i m1 = _mm_loadu_si128(((const __m128i*)src) + 1);
+	_mm_storeu_si128(((__m128i*)dst) + 0, m0);
+	_mm_storeu_si128(((__m128i*)dst) + 1, m1);
+}
+
+static INLINE void memcpy_sse2_64(void *dst, const void *src) {
+	__m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+	__m128i m1 = _mm_loadu_si128(((const __m128i*)src) + 1);
+	__m128i m2 = _mm_loadu_si128(((const __m128i*)src) + 2);
+	__m128i m3 = _mm_loadu_si128(((const __m128i*)src) + 3);
+	_mm_storeu_si128(((__m128i*)dst) + 0, m0);
+	_mm_storeu_si128(((__m128i*)dst) + 1, m1);
+	_mm_storeu_si128(((__m128i*)dst) + 2, m2);
+	_mm_storeu_si128(((__m128i*)dst) + 3, m3);
+}
+
+static INLINE void memcpy_sse2_128(void *dst, const void *src) {
+	__m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+	__m128i m1 = _mm_loadu_si128(((const __m128i*)src) + 1);
+	__m128i m2 = _mm_loadu_si128(((const __m128i*)src) + 2);
+	__m128i m3 = _mm_loadu_si128(((const __m128i*)src) + 3);
+	__m128i m4 = _mm_loadu_si128(((const __m128i*)src) + 4);
+	__m128i m5 = _mm_loadu_si128(((const __m128i*)src) + 5);
+	__m128i m6 = _mm_loadu_si128(((const __m128i*)src) + 6);
+	__m128i m7 = _mm_loadu_si128(((const __m128i*)src) + 7);
+	_mm_storeu_si128(((__m128i*)dst) + 0, m0);
+	_mm_storeu_si128(((__m128i*)dst) + 1, m1);
+	_mm_storeu_si128(((__m128i*)dst) + 2, m2);
+	_mm_storeu_si128(((__m128i*)dst) + 3, m3);
+	_mm_storeu_si128(((__m128i*)dst) + 4, m4);
+	_mm_storeu_si128(((__m128i*)dst) + 5, m5);
+	_mm_storeu_si128(((__m128i*)dst) + 6, m6);
+	_mm_storeu_si128(((__m128i*)dst) + 7, m7);
+}
+
+
+//---------------------------------------------------------------------
+// tiny memory copy with jump table optimized
+//---------------------------------------------------------------------
+static INLINE void *memcpy_tiny(void *dst, const void *src, size_t size) {
+	unsigned char *dd = ((unsigned char*)dst) + size;
+	const unsigned char *ss = ((const unsigned char*)src) + size;
+
+	switch (size) { 
+	case 64:
+		memcpy_sse2_64(dd - 64, ss - 64);
+	case 0:
+		break;
+
+	case 65:
+		memcpy_sse2_64(dd - 65, ss - 65);
+	case 1:
+		dd[-1] = ss[-1];
+		break;
+
+	case 66:
+		memcpy_sse2_64(dd - 66, ss - 66);
+	case 2:
+		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+		break;
+
+	case 67:
+		memcpy_sse2_64(dd - 67, ss - 67);
+	case 3:
+		*((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
+		dd[-1] = ss[-1];
+		break;
+
+	case 68:
+		memcpy_sse2_64(dd - 68, ss - 68);
+	case 4:
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 69:
+		memcpy_sse2_64(dd - 69, ss - 69);
+	case 5:
+		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+		dd[-1] = ss[-1];
+		break;
+
+	case 70:
+		memcpy_sse2_64(dd - 70, ss - 70);
+	case 6:
+		*((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
+		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+		break;
+
+	case 71:
+		memcpy_sse2_64(dd - 71, ss - 71);
+	case 7:
+		*((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 72:
+		memcpy_sse2_64(dd - 72, ss - 72);
+	case 8:
+		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+		break;
+
+	case 73:
+		memcpy_sse2_64(dd - 73, ss - 73);
+	case 9:
+		*((uint64_t*)(dd - 9)) = *((uint64_t*)(ss - 9));
+		dd[-1] = ss[-1];
+		break;
+
+	case 74:
+		memcpy_sse2_64(dd - 74, ss - 74);
+	case 10:
+		*((uint64_t*)(dd - 10)) = *((uint64_t*)(ss - 10));
+		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+		break;
+
+	case 75:
+		memcpy_sse2_64(dd - 75, ss - 75);
+	case 11:
+		*((uint64_t*)(dd - 11)) = *((uint64_t*)(ss - 11));
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 76:
+		memcpy_sse2_64(dd - 76, ss - 76);
+	case 12:
+		*((uint64_t*)(dd - 12)) = *((uint64_t*)(ss - 12));
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 77:
+		memcpy_sse2_64(dd - 77, ss - 77);
+	case 13:
+		*((uint64_t*)(dd - 13)) = *((uint64_t*)(ss - 13));
+		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+		dd[-1] = ss[-1];
+		break;
+
+	case 78:
+		memcpy_sse2_64(dd - 78, ss - 78);
+	case 14:
+		*((uint64_t*)(dd - 14)) = *((uint64_t*)(ss - 14));
+		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+		break;
+
+	case 79:
+		memcpy_sse2_64(dd - 79, ss - 79);
+	case 15:
+		*((uint64_t*)(dd - 15)) = *((uint64_t*)(ss - 15));
+		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+		break;
+
+	case 80:
+		memcpy_sse2_64(dd - 80, ss - 80);
+	case 16:
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 81:
+		memcpy_sse2_64(dd - 81, ss - 81);
+	case 17:
+		memcpy_sse2_16(dd - 17, ss - 17);
+		dd[-1] = ss[-1];
+		break;
+
+	case 82:
+		memcpy_sse2_64(dd - 82, ss - 82);
+	case 18:
+		memcpy_sse2_16(dd - 18, ss - 18);
+		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+		break;
+
+	case 83:
+		memcpy_sse2_64(dd - 83, ss - 83);
+	case 19:
+		memcpy_sse2_16(dd - 19, ss - 19);
+		*((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
+		dd[-1] = ss[-1];
+		break;
+
+	case 84:
+		memcpy_sse2_64(dd - 84, ss - 84);
+	case 20:
+		memcpy_sse2_16(dd - 20, ss - 20);
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 85:
+		memcpy_sse2_64(dd - 85, ss - 85);
+	case 21:
+		memcpy_sse2_16(dd - 21, ss - 21);
+		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+		dd[-1] = ss[-1];
+		break;
+
+	case 86:
+		memcpy_sse2_64(dd - 86, ss - 86);
+	case 22:
+		memcpy_sse2_16(dd - 22, ss - 22);
+		*((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
+		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+		break;
+
+	case 87:
+		memcpy_sse2_64(dd - 87, ss - 87);
+	case 23:
+		memcpy_sse2_16(dd - 23, ss - 23);
+		*((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 88:
+		memcpy_sse2_64(dd - 88, ss - 88);
+	case 24:
+		memcpy_sse2_16(dd - 24, ss - 24);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 89:
+		memcpy_sse2_64(dd - 89, ss - 89);
+	case 25:
+		memcpy_sse2_16(dd - 25, ss - 25);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 90:
+		memcpy_sse2_64(dd - 90, ss - 90);
+	case 26:
+		memcpy_sse2_16(dd - 26, ss - 26);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 91:
+		memcpy_sse2_64(dd - 91, ss - 91);
+	case 27:
+		memcpy_sse2_16(dd - 27, ss - 27);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 92:
+		memcpy_sse2_64(dd - 92, ss - 92);
+	case 28:
+		memcpy_sse2_16(dd - 28, ss - 28);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 93:
+		memcpy_sse2_64(dd - 93, ss - 93);
+	case 29:
+		memcpy_sse2_16(dd - 29, ss - 29);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 94:
+		memcpy_sse2_64(dd - 94, ss - 94);
+	case 30:
+		memcpy_sse2_16(dd - 30, ss - 30);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 95:
+		memcpy_sse2_64(dd - 95, ss - 95);
+	case 31:
+		memcpy_sse2_16(dd - 31, ss - 31);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 96:
+		memcpy_sse2_64(dd - 96, ss - 96);
+	case 32:
+		memcpy_sse2_32(dd - 32, ss - 32);
+		break;
+
+	case 97:
+		memcpy_sse2_64(dd - 97, ss - 97);
+	case 33:
+		memcpy_sse2_32(dd - 33, ss - 33);
+		dd[-1] = ss[-1];
+		break;
+
+	case 98:
+		memcpy_sse2_64(dd - 98, ss - 98);
+	case 34:
+		memcpy_sse2_32(dd - 34, ss - 34);
+		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+		break;
+
+	case 99:
+		memcpy_sse2_64(dd - 99, ss - 99);
+	case 35:
+		memcpy_sse2_32(dd - 35, ss - 35);
+		*((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
+		dd[-1] = ss[-1];
+		break;
+
+	case 100:
+		memcpy_sse2_64(dd - 100, ss - 100);
+	case 36:
+		memcpy_sse2_32(dd - 36, ss - 36);
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 101:
+		memcpy_sse2_64(dd - 101, ss - 101);
+	case 37:
+		memcpy_sse2_32(dd - 37, ss - 37);
+		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+		dd[-1] = ss[-1];
+		break;
+
+	case 102:
+		memcpy_sse2_64(dd - 102, ss - 102);
+	case 38:
+		memcpy_sse2_32(dd - 38, ss - 38);
+		*((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
+		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+		break;
+
+	case 103:
+		memcpy_sse2_64(dd - 103, ss - 103);
+	case 39:
+		memcpy_sse2_32(dd - 39, ss - 39);
+		*((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 104:
+		memcpy_sse2_64(dd - 104, ss - 104);
+	case 40:
+		memcpy_sse2_32(dd - 40, ss - 40);
+		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+		break;
+
+	case 105:
+		memcpy_sse2_64(dd - 105, ss - 105);
+	case 41:
+		memcpy_sse2_32(dd - 41, ss - 41);
+		*((uint64_t*)(dd - 9)) = *((uint64_t*)(ss - 9));
+		dd[-1] = ss[-1];
+		break;
+
+	case 106:
+		memcpy_sse2_64(dd - 106, ss - 106);
+	case 42:
+		memcpy_sse2_32(dd - 42, ss - 42);
+		*((uint64_t*)(dd - 10)) = *((uint64_t*)(ss - 10));
+		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+		break;
+
+	case 107:
+		memcpy_sse2_64(dd - 107, ss - 107);
+	case 43:
+		memcpy_sse2_32(dd - 43, ss - 43);
+		*((uint64_t*)(dd - 11)) = *((uint64_t*)(ss - 11));
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 108:
+		memcpy_sse2_64(dd - 108, ss - 108);
+	case 44:
+		memcpy_sse2_32(dd - 44, ss - 44);
+		*((uint64_t*)(dd - 12)) = *((uint64_t*)(ss - 12));
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 109:
+		memcpy_sse2_64(dd - 109, ss - 109);
+	case 45:
+		memcpy_sse2_32(dd - 45, ss - 45);
+		*((uint64_t*)(dd - 13)) = *((uint64_t*)(ss - 13));
+		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+		dd[-1] = ss[-1];
+		break;
+
+	case 110:
+		memcpy_sse2_64(dd - 110, ss - 110);
+	case 46:
+		memcpy_sse2_32(dd - 46, ss - 46);
+		*((uint64_t*)(dd - 14)) = *((uint64_t*)(ss - 14));
+		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+		break;
+
+	case 111:
+		memcpy_sse2_64(dd - 111, ss - 111);
+	case 47:
+		memcpy_sse2_32(dd - 47, ss - 47);
+		*((uint64_t*)(dd - 15)) = *((uint64_t*)(ss - 15));
+		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+		break;
+
+	case 112:
+		memcpy_sse2_64(dd - 112, ss - 112);
+	case 48:
+		memcpy_sse2_32(dd - 48, ss - 48);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 113:
+		memcpy_sse2_64(dd - 113, ss - 113);
+	case 49:
+		memcpy_sse2_32(dd - 49, ss - 49);
+		memcpy_sse2_16(dd - 17, ss - 17);
+		dd[-1] = ss[-1];
+		break;
+
+	case 114:
+		memcpy_sse2_64(dd - 114, ss - 114);
+	case 50:
+		memcpy_sse2_32(dd - 50, ss - 50);
+		memcpy_sse2_16(dd - 18, ss - 18);
+		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+		break;
+
+	case 115:
+		memcpy_sse2_64(dd - 115, ss - 115);
+	case 51:
+		memcpy_sse2_32(dd - 51, ss - 51);
+		memcpy_sse2_16(dd - 19, ss - 19);
+		*((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
+		dd[-1] = ss[-1];
+		break;
+
+	case 116:
+		memcpy_sse2_64(dd - 116, ss - 116);
+	case 52:
+		memcpy_sse2_32(dd - 52, ss - 52);
+		memcpy_sse2_16(dd - 20, ss - 20);
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 117:
+		memcpy_sse2_64(dd - 117, ss - 117);
+	case 53:
+		memcpy_sse2_32(dd - 53, ss - 53);
+		memcpy_sse2_16(dd - 21, ss - 21);
+		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+		dd[-1] = ss[-1];
+		break;
+
+	case 118:
+		memcpy_sse2_64(dd - 118, ss - 118);
+	case 54:
+		memcpy_sse2_32(dd - 54, ss - 54);
+		memcpy_sse2_16(dd - 22, ss - 22);
+		*((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
+		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+		break;
+
+	case 119:
+		memcpy_sse2_64(dd - 119, ss - 119);
+	case 55:
+		memcpy_sse2_32(dd - 55, ss - 55);
+		memcpy_sse2_16(dd - 23, ss - 23);
+		*((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
+		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+		break;
+
+	case 120:
+		memcpy_sse2_64(dd - 120, ss - 120);
+	case 56:
+		memcpy_sse2_32(dd - 56, ss - 56);
+		memcpy_sse2_16(dd - 24, ss - 24);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 121:
+		memcpy_sse2_64(dd - 121, ss - 121);
+	case 57:
+		memcpy_sse2_32(dd - 57, ss - 57);
+		memcpy_sse2_16(dd - 25, ss - 25);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 122:
+		memcpy_sse2_64(dd - 122, ss - 122);
+	case 58:
+		memcpy_sse2_32(dd - 58, ss - 58);
+		memcpy_sse2_16(dd - 26, ss - 26);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 123:
+		memcpy_sse2_64(dd - 123, ss - 123);
+	case 59:
+		memcpy_sse2_32(dd - 59, ss - 59);
+		memcpy_sse2_16(dd - 27, ss - 27);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 124:
+		memcpy_sse2_64(dd - 124, ss - 124);
+	case 60:
+		memcpy_sse2_32(dd - 60, ss - 60);
+		memcpy_sse2_16(dd - 28, ss - 28);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 125:
+		memcpy_sse2_64(dd - 125, ss - 125);
+	case 61:
+		memcpy_sse2_32(dd - 61, ss - 61);
+		memcpy_sse2_16(dd - 29, ss - 29);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 126:
+		memcpy_sse2_64(dd - 126, ss - 126);
+	case 62:
+		memcpy_sse2_32(dd - 62, ss - 62);
+		memcpy_sse2_16(dd - 30, ss - 30);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 127:
+		memcpy_sse2_64(dd - 127, ss - 127);
+	case 63:
+		memcpy_sse2_32(dd - 63, ss - 63);
+		memcpy_sse2_16(dd - 31, ss - 31);
+		memcpy_sse2_16(dd - 16, ss - 16);
+		break;
+
+	case 128:
+		memcpy_sse2_128(dd - 128, ss - 128);
+		break;
+	}
+
+	return dst;
+}
+
+
+//---------------------------------------------------------------------
+// main routine
+//---------------------------------------------------------------------
+static void* memcpy_fast(void *destination, const void *source, size_t size)
+{
+	unsigned char *dst = (unsigned char*)destination;
+	const unsigned char *src = (const unsigned char*)source;
+	static size_t cachesize = 0x200000; // L2-cache size
+	size_t padding;
+
+	// small memory copy
+	if (size <= 128) {
+		return memcpy_tiny(dst, src, size);
+	}
+
+	// align destination to 16 bytes boundary
+	padding = (16 - (((size_t)dst) & 15)) & 15;
+
+	if (padding > 0) {
+		__m128i head = _mm_loadu_si128((const __m128i*)src);
+		_mm_storeu_si128((__m128i*)dst, head);
+		dst += padding;
+		src += padding;
+		size -= padding;
+	}
+
+	// medium size copy
+	if (size <= cachesize) {
+		__m128i c0, c1, c2, c3, c4, c5, c6, c7;
+
+		for (; size >= 128; size -= 128) {
+			c0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+			c1 = _mm_loadu_si128(((const __m128i*)src) + 1);
+			c2 = _mm_loadu_si128(((const __m128i*)src) + 2);
+			c3 = _mm_loadu_si128(((const __m128i*)src) + 3);
+			c4 = _mm_loadu_si128(((const __m128i*)src) + 4);
+			c5 = _mm_loadu_si128(((const __m128i*)src) + 5);
+			c6 = _mm_loadu_si128(((const __m128i*)src) + 6);
+			c7 = _mm_loadu_si128(((const __m128i*)src) + 7);
+			_mm_prefetch((const char*)(src + 256), _MM_HINT_NTA);
+			src += 128;
+			_mm_store_si128((((__m128i*)dst) + 0), c0);
+			_mm_store_si128((((__m128i*)dst) + 1), c1);
+			_mm_store_si128((((__m128i*)dst) + 2), c2);
+			_mm_store_si128((((__m128i*)dst) + 3), c3);
+			_mm_store_si128((((__m128i*)dst) + 4), c4);
+			_mm_store_si128((((__m128i*)dst) + 5), c5);
+			_mm_store_si128((((__m128i*)dst) + 6), c6);
+			_mm_store_si128((((__m128i*)dst) + 7), c7);
+			dst += 128;
+		}
+	}
+	else {		// big memory copy
+		__m128i c0, c1, c2, c3, c4, c5, c6, c7;
+
+		_mm_prefetch((const char*)(src), _MM_HINT_NTA);
+
+		if ((((size_t)src) & 15) == 0) {	// source aligned
+			for (; size >= 128; size -= 128) {
+				c0 = _mm_load_si128(((const __m128i*)src) + 0);
+				c1 = _mm_load_si128(((const __m128i*)src) + 1);
+				c2 = _mm_load_si128(((const __m128i*)src) + 2);
+				c3 = _mm_load_si128(((const __m128i*)src) + 3);
+				c4 = _mm_load_si128(((const __m128i*)src) + 4);
+				c5 = _mm_load_si128(((const __m128i*)src) + 5);
+				c6 = _mm_load_si128(((const __m128i*)src) + 6);
+				c7 = _mm_load_si128(((const __m128i*)src) + 7);
+				_mm_prefetch((const char*)(src + 256), _MM_HINT_NTA);
+				src += 128;
+				_mm_stream_si128((((__m128i*)dst) + 0), c0);
+				_mm_stream_si128((((__m128i*)dst) + 1), c1);
+				_mm_stream_si128((((__m128i*)dst) + 2), c2);
+				_mm_stream_si128((((__m128i*)dst) + 3), c3);
+				_mm_stream_si128((((__m128i*)dst) + 4), c4);
+				_mm_stream_si128((((__m128i*)dst) + 5), c5);
+				_mm_stream_si128((((__m128i*)dst) + 6), c6);
+				_mm_stream_si128((((__m128i*)dst) + 7), c7);
+				dst += 128;
+			}
+		}
+		else {							// source unaligned
+			for (; size >= 128; size -= 128) {
+				c0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+				c1 = _mm_loadu_si128(((const __m128i*)src) + 1);
+				c2 = _mm_loadu_si128(((const __m128i*)src) + 2);
+				c3 = _mm_loadu_si128(((const __m128i*)src) + 3);
+				c4 = _mm_loadu_si128(((const __m128i*)src) + 4);
+				c5 = _mm_loadu_si128(((const __m128i*)src) + 5);
+				c6 = _mm_loadu_si128(((const __m128i*)src) + 6);
+				c7 = _mm_loadu_si128(((const __m128i*)src) + 7);
+				_mm_prefetch((const char*)(src + 256), _MM_HINT_NTA);
+				src += 128;
+				_mm_stream_si128((((__m128i*)dst) + 0), c0);
+				_mm_stream_si128((((__m128i*)dst) + 1), c1);
+				_mm_stream_si128((((__m128i*)dst) + 2), c2);
+				_mm_stream_si128((((__m128i*)dst) + 3), c3);
+				_mm_stream_si128((((__m128i*)dst) + 4), c4);
+				_mm_stream_si128((((__m128i*)dst) + 5), c5);
+				_mm_stream_si128((((__m128i*)dst) + 6), c6);
+				_mm_stream_si128((((__m128i*)dst) + 7), c7);
+				dst += 128;
+			}
+		}
+		_mm_sfence();
+	}
+
+	memcpy_tiny(dst, src, size);
+
+	return destination;
+}
+
+
+#endif
+
+
+
diff --git a/libs/libmemcpy/LICENSE b/libs/libmemcpy/LICENSE
new file mode 100644
index 00000000000..c449da6aa8a
--- /dev/null
+++ b/libs/libmemcpy/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Linwei
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
diff --git a/libs/libmemcpy/README.md b/libs/libmemcpy/README.md
new file mode 100644
index 00000000000..2c63dc21a81
--- /dev/null
+++ b/libs/libmemcpy/README.md
@@ -0,0 +1,97 @@
+Build
+=====
+
+with gcc:
+> gcc -O3 -msse2 FastMemcpy.c -o FastMemcpy
+
+with msvc:
+> cl -nologo -O2 FastMemcpy.c
+
+Features
+========
+
+* 50% speedup in avg. vs traditional memcpy in msvc 2012 or gcc 4.9
+* small size copy optimized with jump table
+* medium size copy optimized with sse2 vector copy 
+* huge size copy optimized with cache prefetch & movntdq
+
+Reference
+=========
+
+[Using Block Prefetch for Optimized Memory Performance](http://files.rsdn.ru/23380/AMD_block_prefetch_paper.pdf)
+
+The artical only focused on aligned huge memory copy. You need handle other conditions by your self.
+
+
+Results
+=======
+
+```
+result: gcc4.9 (msvc 2012 got a similar result):
+ 
+benchmark(size=32 bytes, times=16777216):
+result(dst aligned, src aligned): memcpy_fast=81ms memcpy=281 ms
+result(dst aligned, src unalign): memcpy_fast=88ms memcpy=254 ms
+result(dst unalign, src aligned): memcpy_fast=87ms memcpy=245 ms
+result(dst unalign, src unalign): memcpy_fast=81ms memcpy=258 ms
+
+benchmark(size=64 bytes, times=16777216):
+result(dst aligned, src aligned): memcpy_fast=91ms memcpy=364 ms
+result(dst aligned, src unalign): memcpy_fast=95ms memcpy=336 ms
+result(dst unalign, src aligned): memcpy_fast=96ms memcpy=353 ms
+result(dst unalign, src unalign): memcpy_fast=99ms memcpy=346 ms
+
+benchmark(size=512 bytes, times=8388608):
+result(dst aligned, src aligned): memcpy_fast=124ms memcpy=242 ms
+result(dst aligned, src unalign): memcpy_fast=166ms memcpy=555 ms
+result(dst unalign, src aligned): memcpy_fast=168ms memcpy=602 ms
+result(dst unalign, src unalign): memcpy_fast=174ms memcpy=614 ms
+
+benchmark(size=1024 bytes, times=4194304):
+result(dst aligned, src aligned): memcpy_fast=119ms memcpy=171 ms
+result(dst aligned, src unalign): memcpy_fast=182ms memcpy=442 ms
+result(dst unalign, src aligned): memcpy_fast=163ms memcpy=466 ms
+result(dst unalign, src unalign): memcpy_fast=168ms memcpy=472 ms
+
+benchmark(size=4096 bytes, times=524288):
+result(dst aligned, src aligned): memcpy_fast=68ms memcpy=82 ms
+result(dst aligned, src unalign): memcpy_fast=94ms memcpy=226 ms
+result(dst unalign, src aligned): memcpy_fast=134ms memcpy=216 ms
+result(dst unalign, src unalign): memcpy_fast=84ms memcpy=188 ms
+
+benchmark(size=8192 bytes, times=262144):
+result(dst aligned, src aligned): memcpy_fast=55ms memcpy=70 ms
+result(dst aligned, src unalign): memcpy_fast=75ms memcpy=192 ms
+result(dst unalign, src aligned): memcpy_fast=79ms memcpy=223 ms
+result(dst unalign, src unalign): memcpy_fast=91ms memcpy=219 ms
+
+benchmark(size=1048576 bytes, times=2048):
+result(dst aligned, src aligned): memcpy_fast=181ms memcpy=165 ms
+result(dst aligned, src unalign): memcpy_fast=192ms memcpy=303 ms
+result(dst unalign, src aligned): memcpy_fast=218ms memcpy=310 ms
+result(dst unalign, src unalign): memcpy_fast=183ms memcpy=307 ms
+
+benchmark(size=4194304 bytes, times=512):
+result(dst aligned, src aligned): memcpy_fast=263ms memcpy=398 ms
+result(dst aligned, src unalign): memcpy_fast=269ms memcpy=433 ms
+result(dst unalign, src aligned): memcpy_fast=306ms memcpy=497 ms
+result(dst unalign, src unalign): memcpy_fast=285ms memcpy=417 ms
+
+benchmark(size=8388608 bytes, times=256):
+result(dst aligned, src aligned): memcpy_fast=287ms memcpy=421 ms
+result(dst aligned, src unalign): memcpy_fast=288ms memcpy=430 ms
+result(dst unalign, src aligned): memcpy_fast=285ms memcpy=510 ms
+result(dst unalign, src unalign): memcpy_fast=291ms memcpy=440 ms
+
+benchmark random access:
+memcpy_fast=487ms memcpy=1000ms
+
+```
+
+
+About
+=====
+
+skywind
+
+http://www.skywind.me

From d4d346b8ef61368f63cfe0c2c313fcd24a3138a7 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 06:00:06 +0300
Subject: [PATCH 223/266] Modified whitespaces [#CLICKHOUSE-2].

---
 libs/libmemcpy/FastMemcpy.h | 1384 +++++++++++++++++------------------
 libs/libmemcpy/README.md    |   16 +-
 2 files changed, 700 insertions(+), 700 deletions(-)

diff --git a/libs/libmemcpy/FastMemcpy.h b/libs/libmemcpy/FastMemcpy.h
index 65c249dabc1..306bd19ac58 100644
--- a/libs/libmemcpy/FastMemcpy.h
+++ b/libs/libmemcpy/FastMemcpy.h
@@ -1,692 +1,692 @@
-//=====================================================================
-//
-// FastMemcpy.c - skywind3000@163.com, 2015
-//
-// feature:
-// 50% speed up in avg. vs standard memcpy (tested in vc2012/gcc5.1)
-//
-//=====================================================================
-#ifndef __FAST_MEMCPY_H__
-#define __FAST_MEMCPY_H__
-
-#include <stddef.h>
-#include <stdint.h>
-#include <emmintrin.h>
-
-
-//---------------------------------------------------------------------
-// force inline for compilers
-//---------------------------------------------------------------------
-#ifndef INLINE
-#ifdef __GNUC__
-#if (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))
-    #define INLINE         __inline__ __attribute__((always_inline))
-#else
-    #define INLINE         __inline__
-#endif
-#elif defined(_MSC_VER)
-	#define INLINE __forceinline
-#elif (defined(__BORLANDC__) || defined(__WATCOMC__))
-    #define INLINE __inline
-#else
-    #define INLINE 
-#endif
-#endif
-
-
-
-//---------------------------------------------------------------------
-// fast copy for different sizes
-//---------------------------------------------------------------------
-static INLINE void memcpy_sse2_16(void *dst, const void *src) {
-	__m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
-	_mm_storeu_si128(((__m128i*)dst) + 0, m0);
-}
-
-static INLINE void memcpy_sse2_32(void *dst, const void *src) {
-	__m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
-	__m128i m1 = _mm_loadu_si128(((const __m128i*)src) + 1);
-	_mm_storeu_si128(((__m128i*)dst) + 0, m0);
-	_mm_storeu_si128(((__m128i*)dst) + 1, m1);
-}
-
-static INLINE void memcpy_sse2_64(void *dst, const void *src) {
-	__m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
-	__m128i m1 = _mm_loadu_si128(((const __m128i*)src) + 1);
-	__m128i m2 = _mm_loadu_si128(((const __m128i*)src) + 2);
-	__m128i m3 = _mm_loadu_si128(((const __m128i*)src) + 3);
-	_mm_storeu_si128(((__m128i*)dst) + 0, m0);
-	_mm_storeu_si128(((__m128i*)dst) + 1, m1);
-	_mm_storeu_si128(((__m128i*)dst) + 2, m2);
-	_mm_storeu_si128(((__m128i*)dst) + 3, m3);
-}
-
-static INLINE void memcpy_sse2_128(void *dst, const void *src) {
-	__m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
-	__m128i m1 = _mm_loadu_si128(((const __m128i*)src) + 1);
-	__m128i m2 = _mm_loadu_si128(((const __m128i*)src) + 2);
-	__m128i m3 = _mm_loadu_si128(((const __m128i*)src) + 3);
-	__m128i m4 = _mm_loadu_si128(((const __m128i*)src) + 4);
-	__m128i m5 = _mm_loadu_si128(((const __m128i*)src) + 5);
-	__m128i m6 = _mm_loadu_si128(((const __m128i*)src) + 6);
-	__m128i m7 = _mm_loadu_si128(((const __m128i*)src) + 7);
-	_mm_storeu_si128(((__m128i*)dst) + 0, m0);
-	_mm_storeu_si128(((__m128i*)dst) + 1, m1);
-	_mm_storeu_si128(((__m128i*)dst) + 2, m2);
-	_mm_storeu_si128(((__m128i*)dst) + 3, m3);
-	_mm_storeu_si128(((__m128i*)dst) + 4, m4);
-	_mm_storeu_si128(((__m128i*)dst) + 5, m5);
-	_mm_storeu_si128(((__m128i*)dst) + 6, m6);
-	_mm_storeu_si128(((__m128i*)dst) + 7, m7);
-}
-
-
-//---------------------------------------------------------------------
-// tiny memory copy with jump table optimized
-//---------------------------------------------------------------------
-static INLINE void *memcpy_tiny(void *dst, const void *src, size_t size) {
-	unsigned char *dd = ((unsigned char*)dst) + size;
-	const unsigned char *ss = ((const unsigned char*)src) + size;
-
-	switch (size) { 
-	case 64:
-		memcpy_sse2_64(dd - 64, ss - 64);
-	case 0:
-		break;
-
-	case 65:
-		memcpy_sse2_64(dd - 65, ss - 65);
-	case 1:
-		dd[-1] = ss[-1];
-		break;
-
-	case 66:
-		memcpy_sse2_64(dd - 66, ss - 66);
-	case 2:
-		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
-		break;
-
-	case 67:
-		memcpy_sse2_64(dd - 67, ss - 67);
-	case 3:
-		*((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
-		dd[-1] = ss[-1];
-		break;
-
-	case 68:
-		memcpy_sse2_64(dd - 68, ss - 68);
-	case 4:
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 69:
-		memcpy_sse2_64(dd - 69, ss - 69);
-	case 5:
-		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
-		dd[-1] = ss[-1];
-		break;
-
-	case 70:
-		memcpy_sse2_64(dd - 70, ss - 70);
-	case 6:
-		*((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
-		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
-		break;
-
-	case 71:
-		memcpy_sse2_64(dd - 71, ss - 71);
-	case 7:
-		*((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 72:
-		memcpy_sse2_64(dd - 72, ss - 72);
-	case 8:
-		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
-		break;
-
-	case 73:
-		memcpy_sse2_64(dd - 73, ss - 73);
-	case 9:
-		*((uint64_t*)(dd - 9)) = *((uint64_t*)(ss - 9));
-		dd[-1] = ss[-1];
-		break;
-
-	case 74:
-		memcpy_sse2_64(dd - 74, ss - 74);
-	case 10:
-		*((uint64_t*)(dd - 10)) = *((uint64_t*)(ss - 10));
-		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
-		break;
-
-	case 75:
-		memcpy_sse2_64(dd - 75, ss - 75);
-	case 11:
-		*((uint64_t*)(dd - 11)) = *((uint64_t*)(ss - 11));
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 76:
-		memcpy_sse2_64(dd - 76, ss - 76);
-	case 12:
-		*((uint64_t*)(dd - 12)) = *((uint64_t*)(ss - 12));
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 77:
-		memcpy_sse2_64(dd - 77, ss - 77);
-	case 13:
-		*((uint64_t*)(dd - 13)) = *((uint64_t*)(ss - 13));
-		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
-		dd[-1] = ss[-1];
-		break;
-
-	case 78:
-		memcpy_sse2_64(dd - 78, ss - 78);
-	case 14:
-		*((uint64_t*)(dd - 14)) = *((uint64_t*)(ss - 14));
-		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
-		break;
-
-	case 79:
-		memcpy_sse2_64(dd - 79, ss - 79);
-	case 15:
-		*((uint64_t*)(dd - 15)) = *((uint64_t*)(ss - 15));
-		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
-		break;
-
-	case 80:
-		memcpy_sse2_64(dd - 80, ss - 80);
-	case 16:
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 81:
-		memcpy_sse2_64(dd - 81, ss - 81);
-	case 17:
-		memcpy_sse2_16(dd - 17, ss - 17);
-		dd[-1] = ss[-1];
-		break;
-
-	case 82:
-		memcpy_sse2_64(dd - 82, ss - 82);
-	case 18:
-		memcpy_sse2_16(dd - 18, ss - 18);
-		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
-		break;
-
-	case 83:
-		memcpy_sse2_64(dd - 83, ss - 83);
-	case 19:
-		memcpy_sse2_16(dd - 19, ss - 19);
-		*((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
-		dd[-1] = ss[-1];
-		break;
-
-	case 84:
-		memcpy_sse2_64(dd - 84, ss - 84);
-	case 20:
-		memcpy_sse2_16(dd - 20, ss - 20);
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 85:
-		memcpy_sse2_64(dd - 85, ss - 85);
-	case 21:
-		memcpy_sse2_16(dd - 21, ss - 21);
-		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
-		dd[-1] = ss[-1];
-		break;
-
-	case 86:
-		memcpy_sse2_64(dd - 86, ss - 86);
-	case 22:
-		memcpy_sse2_16(dd - 22, ss - 22);
-		*((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
-		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
-		break;
-
-	case 87:
-		memcpy_sse2_64(dd - 87, ss - 87);
-	case 23:
-		memcpy_sse2_16(dd - 23, ss - 23);
-		*((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 88:
-		memcpy_sse2_64(dd - 88, ss - 88);
-	case 24:
-		memcpy_sse2_16(dd - 24, ss - 24);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 89:
-		memcpy_sse2_64(dd - 89, ss - 89);
-	case 25:
-		memcpy_sse2_16(dd - 25, ss - 25);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 90:
-		memcpy_sse2_64(dd - 90, ss - 90);
-	case 26:
-		memcpy_sse2_16(dd - 26, ss - 26);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 91:
-		memcpy_sse2_64(dd - 91, ss - 91);
-	case 27:
-		memcpy_sse2_16(dd - 27, ss - 27);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 92:
-		memcpy_sse2_64(dd - 92, ss - 92);
-	case 28:
-		memcpy_sse2_16(dd - 28, ss - 28);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 93:
-		memcpy_sse2_64(dd - 93, ss - 93);
-	case 29:
-		memcpy_sse2_16(dd - 29, ss - 29);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 94:
-		memcpy_sse2_64(dd - 94, ss - 94);
-	case 30:
-		memcpy_sse2_16(dd - 30, ss - 30);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 95:
-		memcpy_sse2_64(dd - 95, ss - 95);
-	case 31:
-		memcpy_sse2_16(dd - 31, ss - 31);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 96:
-		memcpy_sse2_64(dd - 96, ss - 96);
-	case 32:
-		memcpy_sse2_32(dd - 32, ss - 32);
-		break;
-
-	case 97:
-		memcpy_sse2_64(dd - 97, ss - 97);
-	case 33:
-		memcpy_sse2_32(dd - 33, ss - 33);
-		dd[-1] = ss[-1];
-		break;
-
-	case 98:
-		memcpy_sse2_64(dd - 98, ss - 98);
-	case 34:
-		memcpy_sse2_32(dd - 34, ss - 34);
-		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
-		break;
-
-	case 99:
-		memcpy_sse2_64(dd - 99, ss - 99);
-	case 35:
-		memcpy_sse2_32(dd - 35, ss - 35);
-		*((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
-		dd[-1] = ss[-1];
-		break;
-
-	case 100:
-		memcpy_sse2_64(dd - 100, ss - 100);
-	case 36:
-		memcpy_sse2_32(dd - 36, ss - 36);
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 101:
-		memcpy_sse2_64(dd - 101, ss - 101);
-	case 37:
-		memcpy_sse2_32(dd - 37, ss - 37);
-		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
-		dd[-1] = ss[-1];
-		break;
-
-	case 102:
-		memcpy_sse2_64(dd - 102, ss - 102);
-	case 38:
-		memcpy_sse2_32(dd - 38, ss - 38);
-		*((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
-		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
-		break;
-
-	case 103:
-		memcpy_sse2_64(dd - 103, ss - 103);
-	case 39:
-		memcpy_sse2_32(dd - 39, ss - 39);
-		*((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 104:
-		memcpy_sse2_64(dd - 104, ss - 104);
-	case 40:
-		memcpy_sse2_32(dd - 40, ss - 40);
-		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
-		break;
-
-	case 105:
-		memcpy_sse2_64(dd - 105, ss - 105);
-	case 41:
-		memcpy_sse2_32(dd - 41, ss - 41);
-		*((uint64_t*)(dd - 9)) = *((uint64_t*)(ss - 9));
-		dd[-1] = ss[-1];
-		break;
-
-	case 106:
-		memcpy_sse2_64(dd - 106, ss - 106);
-	case 42:
-		memcpy_sse2_32(dd - 42, ss - 42);
-		*((uint64_t*)(dd - 10)) = *((uint64_t*)(ss - 10));
-		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
-		break;
-
-	case 107:
-		memcpy_sse2_64(dd - 107, ss - 107);
-	case 43:
-		memcpy_sse2_32(dd - 43, ss - 43);
-		*((uint64_t*)(dd - 11)) = *((uint64_t*)(ss - 11));
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 108:
-		memcpy_sse2_64(dd - 108, ss - 108);
-	case 44:
-		memcpy_sse2_32(dd - 44, ss - 44);
-		*((uint64_t*)(dd - 12)) = *((uint64_t*)(ss - 12));
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 109:
-		memcpy_sse2_64(dd - 109, ss - 109);
-	case 45:
-		memcpy_sse2_32(dd - 45, ss - 45);
-		*((uint64_t*)(dd - 13)) = *((uint64_t*)(ss - 13));
-		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
-		dd[-1] = ss[-1];
-		break;
-
-	case 110:
-		memcpy_sse2_64(dd - 110, ss - 110);
-	case 46:
-		memcpy_sse2_32(dd - 46, ss - 46);
-		*((uint64_t*)(dd - 14)) = *((uint64_t*)(ss - 14));
-		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
-		break;
-
-	case 111:
-		memcpy_sse2_64(dd - 111, ss - 111);
-	case 47:
-		memcpy_sse2_32(dd - 47, ss - 47);
-		*((uint64_t*)(dd - 15)) = *((uint64_t*)(ss - 15));
-		*((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
-		break;
-
-	case 112:
-		memcpy_sse2_64(dd - 112, ss - 112);
-	case 48:
-		memcpy_sse2_32(dd - 48, ss - 48);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 113:
-		memcpy_sse2_64(dd - 113, ss - 113);
-	case 49:
-		memcpy_sse2_32(dd - 49, ss - 49);
-		memcpy_sse2_16(dd - 17, ss - 17);
-		dd[-1] = ss[-1];
-		break;
-
-	case 114:
-		memcpy_sse2_64(dd - 114, ss - 114);
-	case 50:
-		memcpy_sse2_32(dd - 50, ss - 50);
-		memcpy_sse2_16(dd - 18, ss - 18);
-		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
-		break;
-
-	case 115:
-		memcpy_sse2_64(dd - 115, ss - 115);
-	case 51:
-		memcpy_sse2_32(dd - 51, ss - 51);
-		memcpy_sse2_16(dd - 19, ss - 19);
-		*((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
-		dd[-1] = ss[-1];
-		break;
-
-	case 116:
-		memcpy_sse2_64(dd - 116, ss - 116);
-	case 52:
-		memcpy_sse2_32(dd - 52, ss - 52);
-		memcpy_sse2_16(dd - 20, ss - 20);
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 117:
-		memcpy_sse2_64(dd - 117, ss - 117);
-	case 53:
-		memcpy_sse2_32(dd - 53, ss - 53);
-		memcpy_sse2_16(dd - 21, ss - 21);
-		*((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
-		dd[-1] = ss[-1];
-		break;
-
-	case 118:
-		memcpy_sse2_64(dd - 118, ss - 118);
-	case 54:
-		memcpy_sse2_32(dd - 54, ss - 54);
-		memcpy_sse2_16(dd - 22, ss - 22);
-		*((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
-		*((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
-		break;
-
-	case 119:
-		memcpy_sse2_64(dd - 119, ss - 119);
-	case 55:
-		memcpy_sse2_32(dd - 55, ss - 55);
-		memcpy_sse2_16(dd - 23, ss - 23);
-		*((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
-		*((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
-		break;
-
-	case 120:
-		memcpy_sse2_64(dd - 120, ss - 120);
-	case 56:
-		memcpy_sse2_32(dd - 56, ss - 56);
-		memcpy_sse2_16(dd - 24, ss - 24);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 121:
-		memcpy_sse2_64(dd - 121, ss - 121);
-	case 57:
-		memcpy_sse2_32(dd - 57, ss - 57);
-		memcpy_sse2_16(dd - 25, ss - 25);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 122:
-		memcpy_sse2_64(dd - 122, ss - 122);
-	case 58:
-		memcpy_sse2_32(dd - 58, ss - 58);
-		memcpy_sse2_16(dd - 26, ss - 26);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 123:
-		memcpy_sse2_64(dd - 123, ss - 123);
-	case 59:
-		memcpy_sse2_32(dd - 59, ss - 59);
-		memcpy_sse2_16(dd - 27, ss - 27);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 124:
-		memcpy_sse2_64(dd - 124, ss - 124);
-	case 60:
-		memcpy_sse2_32(dd - 60, ss - 60);
-		memcpy_sse2_16(dd - 28, ss - 28);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 125:
-		memcpy_sse2_64(dd - 125, ss - 125);
-	case 61:
-		memcpy_sse2_32(dd - 61, ss - 61);
-		memcpy_sse2_16(dd - 29, ss - 29);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 126:
-		memcpy_sse2_64(dd - 126, ss - 126);
-	case 62:
-		memcpy_sse2_32(dd - 62, ss - 62);
-		memcpy_sse2_16(dd - 30, ss - 30);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 127:
-		memcpy_sse2_64(dd - 127, ss - 127);
-	case 63:
-		memcpy_sse2_32(dd - 63, ss - 63);
-		memcpy_sse2_16(dd - 31, ss - 31);
-		memcpy_sse2_16(dd - 16, ss - 16);
-		break;
-
-	case 128:
-		memcpy_sse2_128(dd - 128, ss - 128);
-		break;
-	}
-
-	return dst;
-}
-
-
-//---------------------------------------------------------------------
-// main routine
-//---------------------------------------------------------------------
-static void* memcpy_fast(void *destination, const void *source, size_t size)
-{
-	unsigned char *dst = (unsigned char*)destination;
-	const unsigned char *src = (const unsigned char*)source;
-	static size_t cachesize = 0x200000; // L2-cache size
-	size_t padding;
-
-	// small memory copy
-	if (size <= 128) {
-		return memcpy_tiny(dst, src, size);
-	}
-
-	// align destination to 16 bytes boundary
-	padding = (16 - (((size_t)dst) & 15)) & 15;
-
-	if (padding > 0) {
-		__m128i head = _mm_loadu_si128((const __m128i*)src);
-		_mm_storeu_si128((__m128i*)dst, head);
-		dst += padding;
-		src += padding;
-		size -= padding;
-	}
-
-	// medium size copy
-	if (size <= cachesize) {
-		__m128i c0, c1, c2, c3, c4, c5, c6, c7;
-
-		for (; size >= 128; size -= 128) {
-			c0 = _mm_loadu_si128(((const __m128i*)src) + 0);
-			c1 = _mm_loadu_si128(((const __m128i*)src) + 1);
-			c2 = _mm_loadu_si128(((const __m128i*)src) + 2);
-			c3 = _mm_loadu_si128(((const __m128i*)src) + 3);
-			c4 = _mm_loadu_si128(((const __m128i*)src) + 4);
-			c5 = _mm_loadu_si128(((const __m128i*)src) + 5);
-			c6 = _mm_loadu_si128(((const __m128i*)src) + 6);
-			c7 = _mm_loadu_si128(((const __m128i*)src) + 7);
-			_mm_prefetch((const char*)(src + 256), _MM_HINT_NTA);
-			src += 128;
-			_mm_store_si128((((__m128i*)dst) + 0), c0);
-			_mm_store_si128((((__m128i*)dst) + 1), c1);
-			_mm_store_si128((((__m128i*)dst) + 2), c2);
-			_mm_store_si128((((__m128i*)dst) + 3), c3);
-			_mm_store_si128((((__m128i*)dst) + 4), c4);
-			_mm_store_si128((((__m128i*)dst) + 5), c5);
-			_mm_store_si128((((__m128i*)dst) + 6), c6);
-			_mm_store_si128((((__m128i*)dst) + 7), c7);
-			dst += 128;
-		}
-	}
-	else {		// big memory copy
-		__m128i c0, c1, c2, c3, c4, c5, c6, c7;
-
-		_mm_prefetch((const char*)(src), _MM_HINT_NTA);
-
-		if ((((size_t)src) & 15) == 0) {	// source aligned
-			for (; size >= 128; size -= 128) {
-				c0 = _mm_load_si128(((const __m128i*)src) + 0);
-				c1 = _mm_load_si128(((const __m128i*)src) + 1);
-				c2 = _mm_load_si128(((const __m128i*)src) + 2);
-				c3 = _mm_load_si128(((const __m128i*)src) + 3);
-				c4 = _mm_load_si128(((const __m128i*)src) + 4);
-				c5 = _mm_load_si128(((const __m128i*)src) + 5);
-				c6 = _mm_load_si128(((const __m128i*)src) + 6);
-				c7 = _mm_load_si128(((const __m128i*)src) + 7);
-				_mm_prefetch((const char*)(src + 256), _MM_HINT_NTA);
-				src += 128;
-				_mm_stream_si128((((__m128i*)dst) + 0), c0);
-				_mm_stream_si128((((__m128i*)dst) + 1), c1);
-				_mm_stream_si128((((__m128i*)dst) + 2), c2);
-				_mm_stream_si128((((__m128i*)dst) + 3), c3);
-				_mm_stream_si128((((__m128i*)dst) + 4), c4);
-				_mm_stream_si128((((__m128i*)dst) + 5), c5);
-				_mm_stream_si128((((__m128i*)dst) + 6), c6);
-				_mm_stream_si128((((__m128i*)dst) + 7), c7);
-				dst += 128;
-			}
-		}
-		else {							// source unaligned
-			for (; size >= 128; size -= 128) {
-				c0 = _mm_loadu_si128(((const __m128i*)src) + 0);
-				c1 = _mm_loadu_si128(((const __m128i*)src) + 1);
-				c2 = _mm_loadu_si128(((const __m128i*)src) + 2);
-				c3 = _mm_loadu_si128(((const __m128i*)src) + 3);
-				c4 = _mm_loadu_si128(((const __m128i*)src) + 4);
-				c5 = _mm_loadu_si128(((const __m128i*)src) + 5);
-				c6 = _mm_loadu_si128(((const __m128i*)src) + 6);
-				c7 = _mm_loadu_si128(((const __m128i*)src) + 7);
-				_mm_prefetch((const char*)(src + 256), _MM_HINT_NTA);
-				src += 128;
-				_mm_stream_si128((((__m128i*)dst) + 0), c0);
-				_mm_stream_si128((((__m128i*)dst) + 1), c1);
-				_mm_stream_si128((((__m128i*)dst) + 2), c2);
-				_mm_stream_si128((((__m128i*)dst) + 3), c3);
-				_mm_stream_si128((((__m128i*)dst) + 4), c4);
-				_mm_stream_si128((((__m128i*)dst) + 5), c5);
-				_mm_stream_si128((((__m128i*)dst) + 6), c6);
-				_mm_stream_si128((((__m128i*)dst) + 7), c7);
-				dst += 128;
-			}
-		}
-		_mm_sfence();
-	}
-
-	memcpy_tiny(dst, src, size);
-
-	return destination;
-}
-
-
-#endif
-
-
-
+//=====================================================================
+//
+// FastMemcpy.c - skywind3000@163.com, 2015
+//
+// feature:
+// 50% speed up in avg. vs standard memcpy (tested in vc2012/gcc5.1)
+//
+//=====================================================================
+#ifndef __FAST_MEMCPY_H__
+#define __FAST_MEMCPY_H__
+
+#include <stddef.h>
+#include <stdint.h>
+#include <emmintrin.h>
+
+
+//---------------------------------------------------------------------
+// force inline for compilers
+//---------------------------------------------------------------------
+#ifndef INLINE
+#ifdef __GNUC__
+#if (__GNUC__ > 3) || ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 1))
+    #define INLINE         __inline__ __attribute__((always_inline))
+#else
+    #define INLINE         __inline__
+#endif
+#elif defined(_MSC_VER)
+    #define INLINE __forceinline
+#elif (defined(__BORLANDC__) || defined(__WATCOMC__))
+    #define INLINE __inline
+#else
+    #define INLINE
+#endif
+#endif
+
+
+
+//---------------------------------------------------------------------
+// fast copy for different sizes
+//---------------------------------------------------------------------
+static INLINE void memcpy_sse2_16(void *dst, const void *src) {
+    __m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+    _mm_storeu_si128(((__m128i*)dst) + 0, m0);
+}
+
+static INLINE void memcpy_sse2_32(void *dst, const void *src) {
+    __m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+    __m128i m1 = _mm_loadu_si128(((const __m128i*)src) + 1);
+    _mm_storeu_si128(((__m128i*)dst) + 0, m0);
+    _mm_storeu_si128(((__m128i*)dst) + 1, m1);
+}
+
+static INLINE void memcpy_sse2_64(void *dst, const void *src) {
+    __m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+    __m128i m1 = _mm_loadu_si128(((const __m128i*)src) + 1);
+    __m128i m2 = _mm_loadu_si128(((const __m128i*)src) + 2);
+    __m128i m3 = _mm_loadu_si128(((const __m128i*)src) + 3);
+    _mm_storeu_si128(((__m128i*)dst) + 0, m0);
+    _mm_storeu_si128(((__m128i*)dst) + 1, m1);
+    _mm_storeu_si128(((__m128i*)dst) + 2, m2);
+    _mm_storeu_si128(((__m128i*)dst) + 3, m3);
+}
+
+static INLINE void memcpy_sse2_128(void *dst, const void *src) {
+    __m128i m0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+    __m128i m1 = _mm_loadu_si128(((const __m128i*)src) + 1);
+    __m128i m2 = _mm_loadu_si128(((const __m128i*)src) + 2);
+    __m128i m3 = _mm_loadu_si128(((const __m128i*)src) + 3);
+    __m128i m4 = _mm_loadu_si128(((const __m128i*)src) + 4);
+    __m128i m5 = _mm_loadu_si128(((const __m128i*)src) + 5);
+    __m128i m6 = _mm_loadu_si128(((const __m128i*)src) + 6);
+    __m128i m7 = _mm_loadu_si128(((const __m128i*)src) + 7);
+    _mm_storeu_si128(((__m128i*)dst) + 0, m0);
+    _mm_storeu_si128(((__m128i*)dst) + 1, m1);
+    _mm_storeu_si128(((__m128i*)dst) + 2, m2);
+    _mm_storeu_si128(((__m128i*)dst) + 3, m3);
+    _mm_storeu_si128(((__m128i*)dst) + 4, m4);
+    _mm_storeu_si128(((__m128i*)dst) + 5, m5);
+    _mm_storeu_si128(((__m128i*)dst) + 6, m6);
+    _mm_storeu_si128(((__m128i*)dst) + 7, m7);
+}
+
+
+//---------------------------------------------------------------------
+// tiny memory copy with jump table optimized
+//---------------------------------------------------------------------
+static INLINE void *memcpy_tiny(void *dst, const void *src, size_t size) {
+    unsigned char *dd = ((unsigned char*)dst) + size;
+    const unsigned char *ss = ((const unsigned char*)src) + size;
+
+    switch (size) {
+    case 64:
+        memcpy_sse2_64(dd - 64, ss - 64);
+    case 0:
+        break;
+
+    case 65:
+        memcpy_sse2_64(dd - 65, ss - 65);
+    case 1:
+        dd[-1] = ss[-1];
+        break;
+
+    case 66:
+        memcpy_sse2_64(dd - 66, ss - 66);
+    case 2:
+        *((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+        break;
+
+    case 67:
+        memcpy_sse2_64(dd - 67, ss - 67);
+    case 3:
+        *((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
+        dd[-1] = ss[-1];
+        break;
+
+    case 68:
+        memcpy_sse2_64(dd - 68, ss - 68);
+    case 4:
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 69:
+        memcpy_sse2_64(dd - 69, ss - 69);
+    case 5:
+        *((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+        dd[-1] = ss[-1];
+        break;
+
+    case 70:
+        memcpy_sse2_64(dd - 70, ss - 70);
+    case 6:
+        *((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
+        *((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+        break;
+
+    case 71:
+        memcpy_sse2_64(dd - 71, ss - 71);
+    case 7:
+        *((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 72:
+        memcpy_sse2_64(dd - 72, ss - 72);
+    case 8:
+        *((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+        break;
+
+    case 73:
+        memcpy_sse2_64(dd - 73, ss - 73);
+    case 9:
+        *((uint64_t*)(dd - 9)) = *((uint64_t*)(ss - 9));
+        dd[-1] = ss[-1];
+        break;
+
+    case 74:
+        memcpy_sse2_64(dd - 74, ss - 74);
+    case 10:
+        *((uint64_t*)(dd - 10)) = *((uint64_t*)(ss - 10));
+        *((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+        break;
+
+    case 75:
+        memcpy_sse2_64(dd - 75, ss - 75);
+    case 11:
+        *((uint64_t*)(dd - 11)) = *((uint64_t*)(ss - 11));
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 76:
+        memcpy_sse2_64(dd - 76, ss - 76);
+    case 12:
+        *((uint64_t*)(dd - 12)) = *((uint64_t*)(ss - 12));
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 77:
+        memcpy_sse2_64(dd - 77, ss - 77);
+    case 13:
+        *((uint64_t*)(dd - 13)) = *((uint64_t*)(ss - 13));
+        *((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+        dd[-1] = ss[-1];
+        break;
+
+    case 78:
+        memcpy_sse2_64(dd - 78, ss - 78);
+    case 14:
+        *((uint64_t*)(dd - 14)) = *((uint64_t*)(ss - 14));
+        *((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+        break;
+
+    case 79:
+        memcpy_sse2_64(dd - 79, ss - 79);
+    case 15:
+        *((uint64_t*)(dd - 15)) = *((uint64_t*)(ss - 15));
+        *((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+        break;
+
+    case 80:
+        memcpy_sse2_64(dd - 80, ss - 80);
+    case 16:
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 81:
+        memcpy_sse2_64(dd - 81, ss - 81);
+    case 17:
+        memcpy_sse2_16(dd - 17, ss - 17);
+        dd[-1] = ss[-1];
+        break;
+
+    case 82:
+        memcpy_sse2_64(dd - 82, ss - 82);
+    case 18:
+        memcpy_sse2_16(dd - 18, ss - 18);
+        *((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+        break;
+
+    case 83:
+        memcpy_sse2_64(dd - 83, ss - 83);
+    case 19:
+        memcpy_sse2_16(dd - 19, ss - 19);
+        *((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
+        dd[-1] = ss[-1];
+        break;
+
+    case 84:
+        memcpy_sse2_64(dd - 84, ss - 84);
+    case 20:
+        memcpy_sse2_16(dd - 20, ss - 20);
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 85:
+        memcpy_sse2_64(dd - 85, ss - 85);
+    case 21:
+        memcpy_sse2_16(dd - 21, ss - 21);
+        *((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+        dd[-1] = ss[-1];
+        break;
+
+    case 86:
+        memcpy_sse2_64(dd - 86, ss - 86);
+    case 22:
+        memcpy_sse2_16(dd - 22, ss - 22);
+        *((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
+        *((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+        break;
+
+    case 87:
+        memcpy_sse2_64(dd - 87, ss - 87);
+    case 23:
+        memcpy_sse2_16(dd - 23, ss - 23);
+        *((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 88:
+        memcpy_sse2_64(dd - 88, ss - 88);
+    case 24:
+        memcpy_sse2_16(dd - 24, ss - 24);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 89:
+        memcpy_sse2_64(dd - 89, ss - 89);
+    case 25:
+        memcpy_sse2_16(dd - 25, ss - 25);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 90:
+        memcpy_sse2_64(dd - 90, ss - 90);
+    case 26:
+        memcpy_sse2_16(dd - 26, ss - 26);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 91:
+        memcpy_sse2_64(dd - 91, ss - 91);
+    case 27:
+        memcpy_sse2_16(dd - 27, ss - 27);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 92:
+        memcpy_sse2_64(dd - 92, ss - 92);
+    case 28:
+        memcpy_sse2_16(dd - 28, ss - 28);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 93:
+        memcpy_sse2_64(dd - 93, ss - 93);
+    case 29:
+        memcpy_sse2_16(dd - 29, ss - 29);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 94:
+        memcpy_sse2_64(dd - 94, ss - 94);
+    case 30:
+        memcpy_sse2_16(dd - 30, ss - 30);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 95:
+        memcpy_sse2_64(dd - 95, ss - 95);
+    case 31:
+        memcpy_sse2_16(dd - 31, ss - 31);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 96:
+        memcpy_sse2_64(dd - 96, ss - 96);
+    case 32:
+        memcpy_sse2_32(dd - 32, ss - 32);
+        break;
+
+    case 97:
+        memcpy_sse2_64(dd - 97, ss - 97);
+    case 33:
+        memcpy_sse2_32(dd - 33, ss - 33);
+        dd[-1] = ss[-1];
+        break;
+
+    case 98:
+        memcpy_sse2_64(dd - 98, ss - 98);
+    case 34:
+        memcpy_sse2_32(dd - 34, ss - 34);
+        *((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+        break;
+
+    case 99:
+        memcpy_sse2_64(dd - 99, ss - 99);
+    case 35:
+        memcpy_sse2_32(dd - 35, ss - 35);
+        *((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
+        dd[-1] = ss[-1];
+        break;
+
+    case 100:
+        memcpy_sse2_64(dd - 100, ss - 100);
+    case 36:
+        memcpy_sse2_32(dd - 36, ss - 36);
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 101:
+        memcpy_sse2_64(dd - 101, ss - 101);
+    case 37:
+        memcpy_sse2_32(dd - 37, ss - 37);
+        *((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+        dd[-1] = ss[-1];
+        break;
+
+    case 102:
+        memcpy_sse2_64(dd - 102, ss - 102);
+    case 38:
+        memcpy_sse2_32(dd - 38, ss - 38);
+        *((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
+        *((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+        break;
+
+    case 103:
+        memcpy_sse2_64(dd - 103, ss - 103);
+    case 39:
+        memcpy_sse2_32(dd - 39, ss - 39);
+        *((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 104:
+        memcpy_sse2_64(dd - 104, ss - 104);
+    case 40:
+        memcpy_sse2_32(dd - 40, ss - 40);
+        *((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+        break;
+
+    case 105:
+        memcpy_sse2_64(dd - 105, ss - 105);
+    case 41:
+        memcpy_sse2_32(dd - 41, ss - 41);
+        *((uint64_t*)(dd - 9)) = *((uint64_t*)(ss - 9));
+        dd[-1] = ss[-1];
+        break;
+
+    case 106:
+        memcpy_sse2_64(dd - 106, ss - 106);
+    case 42:
+        memcpy_sse2_32(dd - 42, ss - 42);
+        *((uint64_t*)(dd - 10)) = *((uint64_t*)(ss - 10));
+        *((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+        break;
+
+    case 107:
+        memcpy_sse2_64(dd - 107, ss - 107);
+    case 43:
+        memcpy_sse2_32(dd - 43, ss - 43);
+        *((uint64_t*)(dd - 11)) = *((uint64_t*)(ss - 11));
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 108:
+        memcpy_sse2_64(dd - 108, ss - 108);
+    case 44:
+        memcpy_sse2_32(dd - 44, ss - 44);
+        *((uint64_t*)(dd - 12)) = *((uint64_t*)(ss - 12));
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 109:
+        memcpy_sse2_64(dd - 109, ss - 109);
+    case 45:
+        memcpy_sse2_32(dd - 45, ss - 45);
+        *((uint64_t*)(dd - 13)) = *((uint64_t*)(ss - 13));
+        *((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+        dd[-1] = ss[-1];
+        break;
+
+    case 110:
+        memcpy_sse2_64(dd - 110, ss - 110);
+    case 46:
+        memcpy_sse2_32(dd - 46, ss - 46);
+        *((uint64_t*)(dd - 14)) = *((uint64_t*)(ss - 14));
+        *((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+        break;
+
+    case 111:
+        memcpy_sse2_64(dd - 111, ss - 111);
+    case 47:
+        memcpy_sse2_32(dd - 47, ss - 47);
+        *((uint64_t*)(dd - 15)) = *((uint64_t*)(ss - 15));
+        *((uint64_t*)(dd - 8)) = *((uint64_t*)(ss - 8));
+        break;
+
+    case 112:
+        memcpy_sse2_64(dd - 112, ss - 112);
+    case 48:
+        memcpy_sse2_32(dd - 48, ss - 48);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 113:
+        memcpy_sse2_64(dd - 113, ss - 113);
+    case 49:
+        memcpy_sse2_32(dd - 49, ss - 49);
+        memcpy_sse2_16(dd - 17, ss - 17);
+        dd[-1] = ss[-1];
+        break;
+
+    case 114:
+        memcpy_sse2_64(dd - 114, ss - 114);
+    case 50:
+        memcpy_sse2_32(dd - 50, ss - 50);
+        memcpy_sse2_16(dd - 18, ss - 18);
+        *((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+        break;
+
+    case 115:
+        memcpy_sse2_64(dd - 115, ss - 115);
+    case 51:
+        memcpy_sse2_32(dd - 51, ss - 51);
+        memcpy_sse2_16(dd - 19, ss - 19);
+        *((uint16_t*)(dd - 3)) = *((uint16_t*)(ss - 3));
+        dd[-1] = ss[-1];
+        break;
+
+    case 116:
+        memcpy_sse2_64(dd - 116, ss - 116);
+    case 52:
+        memcpy_sse2_32(dd - 52, ss - 52);
+        memcpy_sse2_16(dd - 20, ss - 20);
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 117:
+        memcpy_sse2_64(dd - 117, ss - 117);
+    case 53:
+        memcpy_sse2_32(dd - 53, ss - 53);
+        memcpy_sse2_16(dd - 21, ss - 21);
+        *((uint32_t*)(dd - 5)) = *((uint32_t*)(ss - 5));
+        dd[-1] = ss[-1];
+        break;
+
+    case 118:
+        memcpy_sse2_64(dd - 118, ss - 118);
+    case 54:
+        memcpy_sse2_32(dd - 54, ss - 54);
+        memcpy_sse2_16(dd - 22, ss - 22);
+        *((uint32_t*)(dd - 6)) = *((uint32_t*)(ss - 6));
+        *((uint16_t*)(dd - 2)) = *((uint16_t*)(ss - 2));
+        break;
+
+    case 119:
+        memcpy_sse2_64(dd - 119, ss - 119);
+    case 55:
+        memcpy_sse2_32(dd - 55, ss - 55);
+        memcpy_sse2_16(dd - 23, ss - 23);
+        *((uint32_t*)(dd - 7)) = *((uint32_t*)(ss - 7));
+        *((uint32_t*)(dd - 4)) = *((uint32_t*)(ss - 4));
+        break;
+
+    case 120:
+        memcpy_sse2_64(dd - 120, ss - 120);
+    case 56:
+        memcpy_sse2_32(dd - 56, ss - 56);
+        memcpy_sse2_16(dd - 24, ss - 24);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 121:
+        memcpy_sse2_64(dd - 121, ss - 121);
+    case 57:
+        memcpy_sse2_32(dd - 57, ss - 57);
+        memcpy_sse2_16(dd - 25, ss - 25);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 122:
+        memcpy_sse2_64(dd - 122, ss - 122);
+    case 58:
+        memcpy_sse2_32(dd - 58, ss - 58);
+        memcpy_sse2_16(dd - 26, ss - 26);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 123:
+        memcpy_sse2_64(dd - 123, ss - 123);
+    case 59:
+        memcpy_sse2_32(dd - 59, ss - 59);
+        memcpy_sse2_16(dd - 27, ss - 27);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 124:
+        memcpy_sse2_64(dd - 124, ss - 124);
+    case 60:
+        memcpy_sse2_32(dd - 60, ss - 60);
+        memcpy_sse2_16(dd - 28, ss - 28);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 125:
+        memcpy_sse2_64(dd - 125, ss - 125);
+    case 61:
+        memcpy_sse2_32(dd - 61, ss - 61);
+        memcpy_sse2_16(dd - 29, ss - 29);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 126:
+        memcpy_sse2_64(dd - 126, ss - 126);
+    case 62:
+        memcpy_sse2_32(dd - 62, ss - 62);
+        memcpy_sse2_16(dd - 30, ss - 30);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 127:
+        memcpy_sse2_64(dd - 127, ss - 127);
+    case 63:
+        memcpy_sse2_32(dd - 63, ss - 63);
+        memcpy_sse2_16(dd - 31, ss - 31);
+        memcpy_sse2_16(dd - 16, ss - 16);
+        break;
+
+    case 128:
+        memcpy_sse2_128(dd - 128, ss - 128);
+        break;
+    }
+
+    return dst;
+}
+
+
+//---------------------------------------------------------------------
+// main routine
+//---------------------------------------------------------------------
+static void* memcpy_fast(void *destination, const void *source, size_t size)
+{
+    unsigned char *dst = (unsigned char*)destination;
+    const unsigned char *src = (const unsigned char*)source;
+    static size_t cachesize = 0x200000; // L2-cache size
+    size_t padding;
+
+    // small memory copy
+    if (size <= 128) {
+        return memcpy_tiny(dst, src, size);
+    }
+
+    // align destination to 16 bytes boundary
+    padding = (16 - (((size_t)dst) & 15)) & 15;
+
+    if (padding > 0) {
+        __m128i head = _mm_loadu_si128((const __m128i*)src);
+        _mm_storeu_si128((__m128i*)dst, head);
+        dst += padding;
+        src += padding;
+        size -= padding;
+    }
+
+    // medium size copy
+    if (size <= cachesize) {
+        __m128i c0, c1, c2, c3, c4, c5, c6, c7;
+
+        for (; size >= 128; size -= 128) {
+            c0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+            c1 = _mm_loadu_si128(((const __m128i*)src) + 1);
+            c2 = _mm_loadu_si128(((const __m128i*)src) + 2);
+            c3 = _mm_loadu_si128(((const __m128i*)src) + 3);
+            c4 = _mm_loadu_si128(((const __m128i*)src) + 4);
+            c5 = _mm_loadu_si128(((const __m128i*)src) + 5);
+            c6 = _mm_loadu_si128(((const __m128i*)src) + 6);
+            c7 = _mm_loadu_si128(((const __m128i*)src) + 7);
+            _mm_prefetch((const char*)(src + 256), _MM_HINT_NTA);
+            src += 128;
+            _mm_store_si128((((__m128i*)dst) + 0), c0);
+            _mm_store_si128((((__m128i*)dst) + 1), c1);
+            _mm_store_si128((((__m128i*)dst) + 2), c2);
+            _mm_store_si128((((__m128i*)dst) + 3), c3);
+            _mm_store_si128((((__m128i*)dst) + 4), c4);
+            _mm_store_si128((((__m128i*)dst) + 5), c5);
+            _mm_store_si128((((__m128i*)dst) + 6), c6);
+            _mm_store_si128((((__m128i*)dst) + 7), c7);
+            dst += 128;
+        }
+    }
+    else {        // big memory copy
+        __m128i c0, c1, c2, c3, c4, c5, c6, c7;
+
+        _mm_prefetch((const char*)(src), _MM_HINT_NTA);
+
+        if ((((size_t)src) & 15) == 0) {    // source aligned
+            for (; size >= 128; size -= 128) {
+                c0 = _mm_load_si128(((const __m128i*)src) + 0);
+                c1 = _mm_load_si128(((const __m128i*)src) + 1);
+                c2 = _mm_load_si128(((const __m128i*)src) + 2);
+                c3 = _mm_load_si128(((const __m128i*)src) + 3);
+                c4 = _mm_load_si128(((const __m128i*)src) + 4);
+                c5 = _mm_load_si128(((const __m128i*)src) + 5);
+                c6 = _mm_load_si128(((const __m128i*)src) + 6);
+                c7 = _mm_load_si128(((const __m128i*)src) + 7);
+                _mm_prefetch((const char*)(src + 256), _MM_HINT_NTA);
+                src += 128;
+                _mm_stream_si128((((__m128i*)dst) + 0), c0);
+                _mm_stream_si128((((__m128i*)dst) + 1), c1);
+                _mm_stream_si128((((__m128i*)dst) + 2), c2);
+                _mm_stream_si128((((__m128i*)dst) + 3), c3);
+                _mm_stream_si128((((__m128i*)dst) + 4), c4);
+                _mm_stream_si128((((__m128i*)dst) + 5), c5);
+                _mm_stream_si128((((__m128i*)dst) + 6), c6);
+                _mm_stream_si128((((__m128i*)dst) + 7), c7);
+                dst += 128;
+            }
+        }
+        else {                            // source unaligned
+            for (; size >= 128; size -= 128) {
+                c0 = _mm_loadu_si128(((const __m128i*)src) + 0);
+                c1 = _mm_loadu_si128(((const __m128i*)src) + 1);
+                c2 = _mm_loadu_si128(((const __m128i*)src) + 2);
+                c3 = _mm_loadu_si128(((const __m128i*)src) + 3);
+                c4 = _mm_loadu_si128(((const __m128i*)src) + 4);
+                c5 = _mm_loadu_si128(((const __m128i*)src) + 5);
+                c6 = _mm_loadu_si128(((const __m128i*)src) + 6);
+                c7 = _mm_loadu_si128(((const __m128i*)src) + 7);
+                _mm_prefetch((const char*)(src + 256), _MM_HINT_NTA);
+                src += 128;
+                _mm_stream_si128((((__m128i*)dst) + 0), c0);
+                _mm_stream_si128((((__m128i*)dst) + 1), c1);
+                _mm_stream_si128((((__m128i*)dst) + 2), c2);
+                _mm_stream_si128((((__m128i*)dst) + 3), c3);
+                _mm_stream_si128((((__m128i*)dst) + 4), c4);
+                _mm_stream_si128((((__m128i*)dst) + 5), c5);
+                _mm_stream_si128((((__m128i*)dst) + 6), c6);
+                _mm_stream_si128((((__m128i*)dst) + 7), c7);
+                dst += 128;
+            }
+        }
+        _mm_sfence();
+    }
+
+    memcpy_tiny(dst, src, size);
+
+    return destination;
+}
+
+
+#endif
+
+
+
diff --git a/libs/libmemcpy/README.md b/libs/libmemcpy/README.md
index 2c63dc21a81..91e01d4a5a0 100644
--- a/libs/libmemcpy/README.md
+++ b/libs/libmemcpy/README.md
@@ -1,8 +1,8 @@
 Build
 =====
-
-with gcc:
-> gcc -O3 -msse2 FastMemcpy.c -o FastMemcpy
+
+with gcc:
+> gcc -O3 -msse2 FastMemcpy.c -o FastMemcpy
 
 with msvc:
 > cl -nologo -O2 FastMemcpy.c
@@ -10,10 +10,10 @@ with msvc:
 Features
 ========
 
-* 50% speedup in avg. vs traditional memcpy in msvc 2012 or gcc 4.9
-* small size copy optimized with jump table
-* medium size copy optimized with sse2 vector copy 
-* huge size copy optimized with cache prefetch & movntdq
+* 50% speedup in avg. vs traditional memcpy in msvc 2012 or gcc 4.9
+* small size copy optimized with jump table
+* medium size copy optimized with sse2 vector copy
+* huge size copy optimized with cache prefetch & movntdq
 
 Reference
 =========
@@ -28,7 +28,7 @@ Results
 
 ```
 result: gcc4.9 (msvc 2012 got a similar result):
- 
+
 benchmark(size=32 bytes, times=16777216):
 result(dst aligned, src aligned): memcpy_fast=81ms memcpy=281 ms
 result(dst aligned, src unalign): memcpy_fast=88ms memcpy=254 ms

From 85dfdafaeb190ada99a87eb51ada937ec0203fb4 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 06:01:16 +0300
Subject: [PATCH 224/266] Fixed comment [#CLICKHOUSE-2].

---
 libs/libmemcpy/FastMemcpy.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libs/libmemcpy/FastMemcpy.h b/libs/libmemcpy/FastMemcpy.h
index 306bd19ac58..9cb8bb2d019 100644
--- a/libs/libmemcpy/FastMemcpy.h
+++ b/libs/libmemcpy/FastMemcpy.h
@@ -581,7 +581,7 @@ static void* memcpy_fast(void *destination, const void *source, size_t size)
 {
     unsigned char *dst = (unsigned char*)destination;
     const unsigned char *src = (const unsigned char*)source;
-    static size_t cachesize = 0x200000; // L2-cache size
+    static size_t cachesize = 0x200000; // something around half of LL-cache size
     size_t padding;
 
     // small memory copy

From ab8ac9c143a721d68e92e884f3a1bcb8de75459c Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 06:26:40 +0300
Subject: [PATCH 225/266] Preparation [#CLICKHOUSE-2].

---
 libs/libmemcpy/FastMemcpy.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/libs/libmemcpy/FastMemcpy.h b/libs/libmemcpy/FastMemcpy.h
index 9cb8bb2d019..f6c79eaba60 100644
--- a/libs/libmemcpy/FastMemcpy.h
+++ b/libs/libmemcpy/FastMemcpy.h
@@ -577,11 +577,10 @@ static INLINE void *memcpy_tiny(void *dst, const void *src, size_t size) {
 //---------------------------------------------------------------------
 // main routine
 //---------------------------------------------------------------------
-static void* memcpy_fast(void *destination, const void *source, size_t size)
+static INLINE void* memcpy_fast(void *destination, const void *source, size_t size)
 {
     unsigned char *dst = (unsigned char*)destination;
     const unsigned char *src = (const unsigned char*)source;
-    static size_t cachesize = 0x200000; // something around half of LL-cache size
     size_t padding;
 
     // small memory copy
@@ -601,7 +600,8 @@ static void* memcpy_fast(void *destination, const void *source, size_t size)
     }
 
     // medium size copy
-    if (size <= cachesize) {
+    if (size <= 0x200000)   // something around half of LL-cache size
+    {
         __m128i c0, c1, c2, c3, c4, c5, c6, c7;
 
         for (; size >= 128; size -= 128) {

From effbbfd035251b7732ef5a4a2083eab7d0f9a9d9 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 06:27:37 +0300
Subject: [PATCH 226/266] Added wrapper [#CLICKHOUSE-2].

---
 libs/CMakeLists.txt           |  1 +
 libs/libmemcpy/CMakeLists.txt |  1 +
 libs/libmemcpy/memcpy.c       |  3 +++
 libs/libmemcpy/memcpy.h       | 17 +++++++++++++++++
 4 files changed, 22 insertions(+)
 create mode 100644 libs/libmemcpy/CMakeLists.txt
 create mode 100644 libs/libmemcpy/memcpy.c
 create mode 100644 libs/libmemcpy/memcpy.h

diff --git a/libs/CMakeLists.txt b/libs/CMakeLists.txt
index e5887d0813f..3420ba2ebc8 100644
--- a/libs/CMakeLists.txt
+++ b/libs/CMakeLists.txt
@@ -6,6 +6,7 @@ endif ()
 add_subdirectory (libcommon)
 add_subdirectory (libpocoext)
 add_subdirectory (libdaemon)
+add_subdirectory (libmemcpy)
 
 if (USE_MYSQL)
     add_subdirectory (libmysqlxx)
diff --git a/libs/libmemcpy/CMakeLists.txt b/libs/libmemcpy/CMakeLists.txt
new file mode 100644
index 00000000000..c06085aacca
--- /dev/null
+++ b/libs/libmemcpy/CMakeLists.txt
@@ -0,0 +1 @@
+add_library (memcpy memcpy.c)
diff --git a/libs/libmemcpy/memcpy.c b/libs/libmemcpy/memcpy.c
new file mode 100644
index 00000000000..9e1b175bc57
--- /dev/null
+++ b/libs/libmemcpy/memcpy.c
@@ -0,0 +1,3 @@
+#include "memcpy.h"
+
+/// This is needed to generate an object file for linking.
diff --git a/libs/libmemcpy/memcpy.h b/libs/libmemcpy/memcpy.h
new file mode 100644
index 00000000000..902133ed3ae
--- /dev/null
+++ b/libs/libmemcpy/memcpy.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include "FastMemcpy.h"
+
+void * __attribute__((__weak__)) memcpy(void * __restrict destination, const void * __restrict source, size_t size)
+{
+    return memcpy_fast(destination, source, size);
+}
+
+#ifdef __cplusplus
+}
+#endif

From 50cf5623a2b86c37dd4678f854a50e3434353d84 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 06:28:57 +0300
Subject: [PATCH 227/266] Moved third-party sources deeper [#CLICKHOUSE-2].

---
 libs/libmemcpy/{ => impl}/FastMemcpy.h | 0
 libs/libmemcpy/{ => impl}/LICENSE      | 0
 libs/libmemcpy/{ => impl}/README.md    | 0
 libs/libmemcpy/memcpy.h                | 2 +-
 4 files changed, 1 insertion(+), 1 deletion(-)
 rename libs/libmemcpy/{ => impl}/FastMemcpy.h (100%)
 rename libs/libmemcpy/{ => impl}/LICENSE (100%)
 rename libs/libmemcpy/{ => impl}/README.md (100%)

diff --git a/libs/libmemcpy/FastMemcpy.h b/libs/libmemcpy/impl/FastMemcpy.h
similarity index 100%
rename from libs/libmemcpy/FastMemcpy.h
rename to libs/libmemcpy/impl/FastMemcpy.h
diff --git a/libs/libmemcpy/LICENSE b/libs/libmemcpy/impl/LICENSE
similarity index 100%
rename from libs/libmemcpy/LICENSE
rename to libs/libmemcpy/impl/LICENSE
diff --git a/libs/libmemcpy/README.md b/libs/libmemcpy/impl/README.md
similarity index 100%
rename from libs/libmemcpy/README.md
rename to libs/libmemcpy/impl/README.md
diff --git a/libs/libmemcpy/memcpy.h b/libs/libmemcpy/memcpy.h
index 902133ed3ae..1f898d4aff6 100644
--- a/libs/libmemcpy/memcpy.h
+++ b/libs/libmemcpy/memcpy.h
@@ -5,7 +5,7 @@ extern "C"
 {
 #endif
 
-#include "FastMemcpy.h"
+#include "impl/FastMemcpy.h"
 
 void * __attribute__((__weak__)) memcpy(void * __restrict destination, const void * __restrict source, size_t size)
 {

From c20822056698890c7dd115fd91e7894d52602dc4 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 06:44:34 +0300
Subject: [PATCH 228/266] Removed build of shared library and test executables
 for libzlib-ng [#CLICKHOUSE-2].

---
 contrib/libzlib-ng/CMakeLists.txt | 57 ++-----------------------------
 1 file changed, 2 insertions(+), 55 deletions(-)

diff --git a/contrib/libzlib-ng/CMakeLists.txt b/contrib/libzlib-ng/CMakeLists.txt
index 7054ab81115..cd2eeb97c55 100644
--- a/contrib/libzlib-ng/CMakeLists.txt
+++ b/contrib/libzlib-ng/CMakeLists.txt
@@ -489,39 +489,15 @@ if(MINGW OR MSYS)
     set(ZLIB_DLL_SRCS ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj)
 endif(MINGW OR MSYS)
 
-add_library(zlib SHARED ${ZLIB_SRCS} ${ZLIB_GZFILE_SRCS} ${ZLIB_ARCH_SRCS} ${ZLIB_ASMS} ${ZLIB_DLL_SRCS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
 add_library(zlibstatic STATIC ${ZLIB_SRCS} ${ZLIB_GZFILE_SRCS} ${ZLIB_ARCH_SRCS} ${ZLIB_ASMS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
 
-set_target_properties(zlib PROPERTIES DEFINE_SYMBOL ZLIB_DLL)
-set_target_properties(zlib PROPERTIES SOVERSION 1)
-
-if(NOT CYGWIN)
-    # This property causes shared libraries on Linux to have the full version
-    # encoded into their final filename.  We disable this on Cygwin because
-    # it causes cygz-${ZLIB_FULL_VERSION}.dll to be created when cygz.dll
-    # seems to be the default.
-    #
-    # This has no effect with MSVC, on that platform the version info for
-    # the DLL comes from the resource file win32/zlib1.rc
-    set_target_properties(zlib PROPERTIES VERSION ${ZLIB_FULL_VERSION})
-endif()
-
 if(UNIX)
     # On unix-like platforms the library is almost always called libz
-   set_target_properties(zlib zlibstatic PROPERTIES OUTPUT_NAME z)
-   if(NOT APPLE)
-     set_target_properties(zlib PROPERTIES LINK_FLAGS "-Wl,--version-script,\"${CMAKE_CURRENT_SOURCE_DIR}/zlib.map\"")
-   endif()
-elseif(MSYS)
-   # Suppress version number from shared library name
-   set(CMAKE_SHARED_LIBRARY_NAME_WITH_VERSION 0)
-elseif(BUILD_SHARED_LIBS AND WIN32)
-    # Creates zlib1.dll when building shared library version
-    set_target_properties(zlib PROPERTIES SUFFIX "1.dll")
+   set_target_properties(zlibstatic PROPERTIES OUTPUT_NAME z)
 endif()
 
 if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL )
-    install(TARGETS zlib zlibstatic
+    install(TARGETS zlibstatic
         RUNTIME DESTINATION "${INSTALL_BIN_DIR}"
         ARCHIVE DESTINATION "${INSTALL_LIB_DIR}"
         LIBRARY DESTINATION "${INSTALL_LIB_DIR}" )
@@ -529,35 +505,6 @@ endif()
 if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL )
     install(FILES ${ZLIB_PUBLIC_HDRS} DESTINATION "${INSTALL_INC_DIR}")
 endif()
-if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
-    install(FILES zlib.3 DESTINATION "${INSTALL_MAN_DIR}/man3")
-endif()
 if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
     install(FILES ${ZLIB_PC} DESTINATION "${INSTALL_PKGCONFIG_DIR}")
 endif()
-
-#============================================================================
-# Example binaries
-#============================================================================
-
-if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-	set (CMAKE_EXE_LINKER_FLAGS "")
-endif ()
-
-add_executable(example test/example.c)
-target_link_libraries(example zlib)
-add_test(example example)
-
-add_executable(minigzip test/minigzip.c)
-target_link_libraries(minigzip zlib)
-
-if(HAVE_OFF64_T)
-    add_executable(example64 test/example.c)
-    target_link_libraries(example64 zlib)
-    set_target_properties(example64 PROPERTIES COMPILE_FLAGS "-D_FILE_OFFSET_BITS=64")
-    add_test(example64 example64)
-
-    add_executable(minigzip64 test/minigzip.c)
-    target_link_libraries(minigzip64 zlib)
-    set_target_properties(minigzip64 PROPERTIES COMPILE_FLAGS "-D_FILE_OFFSET_BITS=64")
-endif()

From cd9c387ed48caa0dc0d7a14a6145faae68f6fe34 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 08:06:52 +0300
Subject: [PATCH 229/266] Using internal memcpy [#CLICKHOUSE-2].

---
 libs/libcommon/CMakeLists.txt | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/libs/libcommon/CMakeLists.txt b/libs/libcommon/CMakeLists.txt
index a3a4ff14326..3b6489d0bc7 100644
--- a/libs/libcommon/CMakeLists.txt
+++ b/libs/libcommon/CMakeLists.txt
@@ -90,7 +90,8 @@ target_link_libraries (
     ${Boost_FILESYSTEM_LIBRARY}
     ${MALLOC_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}
-    ${RT_LIBRARIES})
+    ${RT_LIBRARIES}
+    memcpy)
 
 if (ENABLE_TESTS)
     add_subdirectory (src/tests)

From 165518d4b065c1a0ed556e96bb62c88c7057cf47 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 08:07:42 +0300
Subject: [PATCH 230/266] Added README [#CLICKHOUSE-2].

---
 libs/libmemcpy/README.md | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 libs/libmemcpy/README.md

diff --git a/libs/libmemcpy/README.md b/libs/libmemcpy/README.md
new file mode 100644
index 00000000000..d3dd14ac55b
--- /dev/null
+++ b/libs/libmemcpy/README.md
@@ -0,0 +1,20 @@
+Internal implementation of `memcpy` function.
+
+It has the following advantages over `libc`-supplied implementation:
+- it is linked statically, so the function is called directly, not through a `PLT` (procedure lookup table of shared library);
+- it is linked statically, so the function can have position-dependent code;
+- your binaries will not depend on `glibc`'s memcpy, that forces dependency on specific symbol version like `memcpy@@GLIBC_2.14` and consequently on specific version of `glibc` library;
+- you can include `memcpy.h` directly and the function has the chance to be inlined, which is beneficial for small but unknown at compile time sizes of memory regions;
+- this version of `memcpy` pretend to be faster (in our benchmarks, the difference is withing few percents).
+
+Currently it uses the implementation from **Linwei** (skywind3000@163.com).
+Look at https://www.zhihu.com/question/35172305 for discussion.
+
+Drawbacks:
+- only use SSE 2, doesn't use wider (AVX, AVX 512) vector registers when available;
+- no CPU dispatching; doesn't take into account actual cache size.
+
+Also worth to look at:
+- simple implementation from Facebook: https://github.com/facebook/folly/blob/master/folly/memcpy.S
+- implementation from Agner Fog: http://www.agner.org/optimize/
+- glibc source code.

From 860c19bad3685d5dd1bc5f7d173fe80d3985135f Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 08:27:09 +0300
Subject: [PATCH 231/266] Refined "GLIBC_COMPATIBILITY" option
 [#CLICKHOUSE-3275].

---
 CMakeLists.txt                                |  6 +-
 libs/CMakeLists.txt                           |  9 ++-
 libs/libcommon/CMakeLists.txt                 | 11 ++-
 .../include/common/glibc_compatibility.h      | 79 -------------------
 libs/libglibc-compatibility/CMakeLists.txt    |  1 +
 .../glibc-compatibility.c                     | 52 ++++++++++++
 .../glibc-compatibility.h                     | 37 +++++++++
 7 files changed, 111 insertions(+), 84 deletions(-)
 delete mode 100644 libs/libcommon/include/common/glibc_compatibility.h
 create mode 100644 libs/libglibc-compatibility/CMakeLists.txt
 create mode 100644 libs/libglibc-compatibility/glibc-compatibility.c
 create mode 100644 libs/libglibc-compatibility/glibc-compatibility.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3e0fe38e84a..a671fe1b775 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -71,11 +71,11 @@ if (USE_STATIC_LIBRARIES)
     list(REVERSE CMAKE_FIND_LIBRARY_SUFFIXES)
 endif ()
 
-option (GLIBC_COMPATIBILITY "Set to TRUE to enable compatibility with older glibc libraries. Note that it is not compatible with ASan." OFF)
+option (USE_INTERNAL_MEMCPY "Use internal implementation of 'memcpy' function instead of provided by libc. Only for x86_64." ON)
+option (GLIBC_COMPATIBILITY "Set to TRUE to enable compatibility with older glibc libraries. Implies USE_INTERNAL_MEMCPY." OFF)
 
 if (GLIBC_COMPATIBILITY)
-    set (GLIBC_COMPATIBILITY_COMPILE_FLAGS   "-include ${ClickHouse_SOURCE_DIR}/libs/libcommon/include/common/glibc_compatibility.h")
-    set (GLIBC_COMPATIBILITY_LINK_FLAGS      "-Wl,--wrap=memcpy")
+    set (USE_INTERNAL_MEMCPY ON)
 endif ()
 
 if (CXX11_ABI STREQUAL ENABLE)
diff --git a/libs/CMakeLists.txt b/libs/CMakeLists.txt
index 3420ba2ebc8..970d2be15b4 100644
--- a/libs/CMakeLists.txt
+++ b/libs/CMakeLists.txt
@@ -6,7 +6,14 @@ endif ()
 add_subdirectory (libcommon)
 add_subdirectory (libpocoext)
 add_subdirectory (libdaemon)
-add_subdirectory (libmemcpy)
+
+if (USE_INTERNAL_MEMCPY)
+    add_subdirectory (libmemcpy)
+endif()
+
+if (GLIBC_COMPATIBILITY)
+    add_subdirectory (libglibc-compatibility)
+endif ()
 
 if (USE_MYSQL)
     add_subdirectory (libmysqlxx)
diff --git a/libs/libcommon/CMakeLists.txt b/libs/libcommon/CMakeLists.txt
index 3b6489d0bc7..3ba10c85636 100644
--- a/libs/libcommon/CMakeLists.txt
+++ b/libs/libcommon/CMakeLists.txt
@@ -75,6 +75,14 @@ else ()
     message (STATUS "Disabling libtcmalloc for valgrind better analysis")
 endif ()
 
+if (GLIBC_COMPATIBILITY)
+    set (GLIBC_COMPATIBILITY_LIBRARIES glibc-compatibility)
+endif ()
+
+if (USE_INTERNAL_MEMCPY)
+    set (MEMCPY_LIBRARIES memcpy)
+endif ()
+
 find_package (Threads)
 
 target_include_directories (common BEFORE PRIVATE ${CCTZ_INCLUDE_DIR})
@@ -91,7 +99,8 @@ target_link_libraries (
     ${MALLOC_LIBRARIES}
     ${CMAKE_THREAD_LIBS_INIT}
     ${RT_LIBRARIES}
-    memcpy)
+    ${GLIBC_COMPATIBILITY_LIBRARIES}
+    ${MEMCPY_LIBRARIES})
 
 if (ENABLE_TESTS)
     add_subdirectory (src/tests)
diff --git a/libs/libcommon/include/common/glibc_compatibility.h b/libs/libcommon/include/common/glibc_compatibility.h
deleted file mode 100644
index b2a13176f27..00000000000
--- a/libs/libcommon/include/common/glibc_compatibility.h
+++ /dev/null
@@ -1,79 +0,0 @@
-/** Allows to build programs with libc 2.18 and run on systems with at least libc 2.11,
-  *  such as Ubuntu Lucid or CentOS 6.
-  *
-  * Highly experimental, not recommended, disabled by default.
-  *
-  * To use, include this file with -include compiler parameter.
-  * And add -Wl,--wrap=memcpy for linking.
-  *
-  * Also look at http://www.lightofdawn.org/wiki/wiki.cgi/NewAppsOnOldGlibc
-  *
-  * If you want even older systems, such as Ubuntu Hardy,
-  *  add fallocate, pipe2, __longjmp_chk, __vasprintf_chk.
-  */
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-#include <stdlib.h>
-#include <sys/select.h>
-
-__attribute__((__weak__)) long int __fdelt_chk(long int d)
-{
-    if (d < 0 || d >= FD_SETSIZE)
-        abort();
-    return d / __NFDBITS;
-}
-
-#include <sys/poll.h>
-
-__attribute__((__weak__)) int __poll_chk(struct pollfd * fds, nfds_t nfds, int timeout, __SIZE_TYPE__ fdslen)
-{
-    if (fdslen / sizeof(*fds) < nfds)
-        abort();
-    return poll(fds, nfds, timeout);
-}
-
-
-__attribute__((__weak__)) void * __memcpy_glibc_2_2_5(void *, const void *, size_t);
-
-__asm__(".symver __memcpy_glibc_2_2_5, memcpy@GLIBC_2.2.5");
-
-__attribute__((__weak__)) void * __wrap_memcpy(void * dest, const void * src, size_t n)
-{
-    return __memcpy_glibc_2_2_5(dest, src, n);
-}
-
-
-__attribute__((__weak__)) size_t __pthread_get_minstack(const pthread_attr_t * attr)
-{
-    return 1048576;        /// This is a guess. Don't sure it is correct.
-}
-
-#include <string.h>
-#include <signal.h>
-#include <unistd.h>
-#include <sys/syscall.h>
-
-extern long int syscall (long int __sysno, ...) __THROW;
-
-__attribute__((__weak__)) int __gai_sigqueue(int sig, const union sigval val, pid_t caller_pid)
-{
-    siginfo_t info;
-
-    memset(&info, 0, sizeof(siginfo_t));
-    info.si_signo = sig;
-    info.si_code = SI_ASYNCNL;
-    info.si_pid = caller_pid;
-    info.si_uid = getuid();
-    info.si_value = val;
-
-    return syscall(__NR_rt_sigqueueinfo, info.si_pid, sig, &info);
-}
-
-
-#if defined (__cplusplus)
-}
-#endif
diff --git a/libs/libglibc-compatibility/CMakeLists.txt b/libs/libglibc-compatibility/CMakeLists.txt
new file mode 100644
index 00000000000..e8c5a4ba757
--- /dev/null
+++ b/libs/libglibc-compatibility/CMakeLists.txt
@@ -0,0 +1 @@
+add_library (glibc-compatibility glibc-compatibility.c)
diff --git a/libs/libglibc-compatibility/glibc-compatibility.c b/libs/libglibc-compatibility/glibc-compatibility.c
new file mode 100644
index 00000000000..5524017b61f
--- /dev/null
+++ b/libs/libglibc-compatibility/glibc-compatibility.c
@@ -0,0 +1,52 @@
+#include "glibc-compatibility.h"
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+#include <sys/select.h>
+#include <stdlib.h>
+
+long int __fdelt_chk(long int d)
+{
+    if (d < 0 || d >= FD_SETSIZE)
+        abort();
+    return d / __NFDBITS;
+}
+
+
+int __poll_chk(struct pollfd * fds, nfds_t nfds, int timeout, size_t fdslen)
+{
+    if (fdslen / sizeof(*fds) < nfds)
+        abort();
+    return poll(fds, nfds, timeout);
+}
+
+
+size_t __pthread_get_minstack(const pthread_attr_t * attr)
+{
+    return 1048576;        /// This is a guess. Don't sure it is correct.
+}
+
+#include <string.h>
+#include <sys/syscall.h>
+
+extern long int syscall (long int __sysno, ...) __THROW;
+
+int __gai_sigqueue(int sig, const union sigval val, pid_t caller_pid)
+{
+    siginfo_t info;
+
+    memset(&info, 0, sizeof(siginfo_t));
+    info.si_signo = sig;
+    info.si_code = SI_ASYNCNL;
+    info.si_pid = caller_pid;
+    info.si_uid = getuid();
+    info.si_value = val;
+
+    return syscall(__NR_rt_sigqueueinfo, info.si_pid, sig, &info);
+}
+
+#if defined (__cplusplus)
+}
+#endif
diff --git a/libs/libglibc-compatibility/glibc-compatibility.h b/libs/libglibc-compatibility/glibc-compatibility.h
new file mode 100644
index 00000000000..aeea2fc4adb
--- /dev/null
+++ b/libs/libglibc-compatibility/glibc-compatibility.h
@@ -0,0 +1,37 @@
+#pragma once
+
+/** Allows to build programs with libc 2.18 and run on systems with at least libc 2.11,
+  *  such as Ubuntu Lucid or CentOS 6.
+  *
+  * Highly experimental, not recommended, disabled by default.
+  *
+  * Also look at http://www.lightofdawn.org/wiki/wiki.cgi/NewAppsOnOldGlibc
+  *
+  * If you want even older systems, such as Ubuntu Hardy,
+  *  add fallocate, pipe2, __longjmp_chk, __vasprintf_chk.
+  */
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+
+__attribute__((__weak__)) long int __fdelt_chk(long int d);
+
+#include <sys/poll.h>
+#include <stddef.h>
+
+__attribute__((__weak__)) int __poll_chk(struct pollfd * fds, nfds_t nfds, int timeout, size_t fdslen);
+
+#include <pthread.h>
+
+__attribute__((__weak__)) size_t __pthread_get_minstack(const pthread_attr_t * attr);
+
+#include <signal.h>
+#include <unistd.h>
+
+__attribute__((__weak__)) int __gai_sigqueue(int sig, const union sigval val, pid_t caller_pid);
+
+#if defined (__cplusplus)
+}
+#endif

From 8254bbe7b87263c5e911ba5e0b9bc3f967c39871 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 08:43:43 +0300
Subject: [PATCH 232/266] Simplification [#CLICKHOUSE-3275].

---
 .../glibc-compatibility.c                     | 16 +++++++-
 .../glibc-compatibility.h                     | 37 -------------------
 2 files changed, 15 insertions(+), 38 deletions(-)
 delete mode 100644 libs/libglibc-compatibility/glibc-compatibility.h

diff --git a/libs/libglibc-compatibility/glibc-compatibility.c b/libs/libglibc-compatibility/glibc-compatibility.c
index 5524017b61f..cb0dd617bdf 100644
--- a/libs/libglibc-compatibility/glibc-compatibility.c
+++ b/libs/libglibc-compatibility/glibc-compatibility.c
@@ -1,4 +1,13 @@
-#include "glibc-compatibility.h"
+/** Allows to build programs with libc 2.18 and run on systems with at least libc 2.11,
+  *  such as Ubuntu Lucid or CentOS 6.
+  *
+  * Highly experimental, not recommended, disabled by default.
+  *
+  * Also look at http://www.lightofdawn.org/wiki/wiki.cgi/NewAppsOnOldGlibc
+  *
+  * If you want even older systems, such as Ubuntu Hardy,
+  *  add fallocate, pipe2, __longjmp_chk, __vasprintf_chk.
+  */
 
 #if defined (__cplusplus)
 extern "C" {
@@ -14,6 +23,8 @@ long int __fdelt_chk(long int d)
     return d / __NFDBITS;
 }
 
+#include <sys/poll.h>
+#include <stddef.h>
 
 int __poll_chk(struct pollfd * fds, nfds_t nfds, int timeout, size_t fdslen)
 {
@@ -22,12 +33,15 @@ int __poll_chk(struct pollfd * fds, nfds_t nfds, int timeout, size_t fdslen)
     return poll(fds, nfds, timeout);
 }
 
+#include <pthread.h>
 
 size_t __pthread_get_minstack(const pthread_attr_t * attr)
 {
     return 1048576;        /// This is a guess. Don't sure it is correct.
 }
 
+#include <signal.h>
+#include <unistd.h>
 #include <string.h>
 #include <sys/syscall.h>
 
diff --git a/libs/libglibc-compatibility/glibc-compatibility.h b/libs/libglibc-compatibility/glibc-compatibility.h
deleted file mode 100644
index aeea2fc4adb..00000000000
--- a/libs/libglibc-compatibility/glibc-compatibility.h
+++ /dev/null
@@ -1,37 +0,0 @@
-#pragma once
-
-/** Allows to build programs with libc 2.18 and run on systems with at least libc 2.11,
-  *  such as Ubuntu Lucid or CentOS 6.
-  *
-  * Highly experimental, not recommended, disabled by default.
-  *
-  * Also look at http://www.lightofdawn.org/wiki/wiki.cgi/NewAppsOnOldGlibc
-  *
-  * If you want even older systems, such as Ubuntu Hardy,
-  *  add fallocate, pipe2, __longjmp_chk, __vasprintf_chk.
-  */
-
-#if defined (__cplusplus)
-extern "C" {
-#endif
-
-
-__attribute__((__weak__)) long int __fdelt_chk(long int d);
-
-#include <sys/poll.h>
-#include <stddef.h>
-
-__attribute__((__weak__)) int __poll_chk(struct pollfd * fds, nfds_t nfds, int timeout, size_t fdslen);
-
-#include <pthread.h>
-
-__attribute__((__weak__)) size_t __pthread_get_minstack(const pthread_attr_t * attr);
-
-#include <signal.h>
-#include <unistd.h>
-
-__attribute__((__weak__)) int __gai_sigqueue(int sig, const union sigval val, pid_t caller_pid);
-
-#if defined (__cplusplus)
-}
-#endif

From 660926c2150651c05edf77d189a6ae7cf15f423f Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 10:24:53 +0300
Subject: [PATCH 233/266] Better GLIBC_COMPATIBILITY option [#CLICKHOUSE-3275].

---
 CMakeLists.txt                                |   2 +-
 libs/libglibc-compatibility/CMakeLists.txt    |   3 +-
 .../glibc-compatibility.c                     |  92 ++++--
 libs/libglibc-compatibility/musl/COPYRIGHT    | 163 +++++++++++
 libs/libglibc-compatibility/musl/README       |   6 +
 libs/libglibc-compatibility/musl/fallocate.c  |  10 +
 libs/libglibc-compatibility/musl/lgamma.c     | 268 ++++++++++++++++++
 libs/libglibc-compatibility/musl/longjmp.s    |  22 ++
 libs/libglibc-compatibility/musl/pipe2.c      |  24 ++
 libs/libglibc-compatibility/musl/vasprintf.c  |  15 +
 10 files changed, 580 insertions(+), 25 deletions(-)
 create mode 100644 libs/libglibc-compatibility/musl/COPYRIGHT
 create mode 100644 libs/libglibc-compatibility/musl/README
 create mode 100644 libs/libglibc-compatibility/musl/fallocate.c
 create mode 100644 libs/libglibc-compatibility/musl/lgamma.c
 create mode 100644 libs/libglibc-compatibility/musl/longjmp.s
 create mode 100644 libs/libglibc-compatibility/musl/pipe2.c
 create mode 100644 libs/libglibc-compatibility/musl/vasprintf.c

diff --git a/CMakeLists.txt b/CMakeLists.txt
index a671fe1b775..98d8fcd578b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -192,7 +192,7 @@ if (UNBUNDLED)
 else ()
     set(NOT_UNBUNDLED 1)
 endif ()
-# Using system libs can cause lot of warnings in includes. 
+# Using system libs can cause lot of warnings in includes.
 if (UNBUNDLED OR NOT (CMAKE_SYSTEM MATCHES "Linux" OR APPLE) OR ARCH_32)
     option (NO_WERROR "Disable -Werror compiler option" ON)
 endif ()
diff --git a/libs/libglibc-compatibility/CMakeLists.txt b/libs/libglibc-compatibility/CMakeLists.txt
index e8c5a4ba757..9521dba9eab 100644
--- a/libs/libglibc-compatibility/CMakeLists.txt
+++ b/libs/libglibc-compatibility/CMakeLists.txt
@@ -1 +1,2 @@
-add_library (glibc-compatibility glibc-compatibility.c)
+enable_language (ASM)
+add_library (glibc-compatibility glibc-compatibility.c musl/pipe2.c musl/fallocate.c musl/longjmp.s musl/vasprintf.c musl/lgamma.c)
diff --git a/libs/libglibc-compatibility/glibc-compatibility.c b/libs/libglibc-compatibility/glibc-compatibility.c
index cb0dd617bdf..e06bac8e290 100644
--- a/libs/libglibc-compatibility/glibc-compatibility.c
+++ b/libs/libglibc-compatibility/glibc-compatibility.c
@@ -1,18 +1,46 @@
-/** Allows to build programs with libc 2.18 and run on systems with at least libc 2.11,
+/** Allows to build programs with libc 2.18 and run on systems with at least libc 2.4,
   *  such as Ubuntu Lucid or CentOS 6.
   *
   * Highly experimental, not recommended, disabled by default.
   *
   * Also look at http://www.lightofdawn.org/wiki/wiki.cgi/NewAppsOnOldGlibc
-  *
-  * If you want even older systems, such as Ubuntu Hardy,
-  *  add fallocate, pipe2, __longjmp_chk, __vasprintf_chk.
   */
 
 #if defined (__cplusplus)
 extern "C" {
 #endif
 
+#include <pthread.h>
+
+size_t __pthread_get_minstack(const pthread_attr_t * attr)
+{
+    return 1048576;        /// This is a guess. Don't sure it is correct.
+}
+
+#include <signal.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/syscall.h>
+
+long int syscall(long int __sysno, ...) __THROW;
+
+int __gai_sigqueue(int sig, const union sigval val, pid_t caller_pid)
+{
+    siginfo_t info;
+
+    memset(&info, 0, sizeof(siginfo_t));
+    info.si_signo = sig;
+    info.si_code = SI_ASYNCNL;
+    info.si_pid = caller_pid;
+    info.si_uid = getuid();
+    info.si_value = val;
+
+    return syscall(__NR_rt_sigqueueinfo, info.si_pid, sig, &info);
+}
+
+
+/// NOTE This disables some of FORTIFY_SOURCE functionality.
+
 #include <sys/select.h>
 #include <stdlib.h>
 
@@ -33,34 +61,52 @@ int __poll_chk(struct pollfd * fds, nfds_t nfds, int timeout, size_t fdslen)
     return poll(fds, nfds, timeout);
 }
 
-#include <pthread.h>
+#include <setjmp.h>
 
-size_t __pthread_get_minstack(const pthread_attr_t * attr)
+void longjmp(jmp_buf env, int val);
+
+void __longjmp_chk(jmp_buf env, int val)
 {
-    return 1048576;        /// This is a guess. Don't sure it is correct.
+    return longjmp(env, val);
 }
 
-#include <signal.h>
-#include <unistd.h>
-#include <string.h>
-#include <sys/syscall.h>
+#include <stdio.h>
 
-extern long int syscall (long int __sysno, ...) __THROW;
+int vasprintf(char **s, const char *fmt, va_list ap);
 
-int __gai_sigqueue(int sig, const union sigval val, pid_t caller_pid)
+int __vasprintf_chk(char **s, const char *fmt, va_list ap)
 {
-    siginfo_t info;
-
-    memset(&info, 0, sizeof(siginfo_t));
-    info.si_signo = sig;
-    info.si_code = SI_ASYNCNL;
-    info.si_pid = caller_pid;
-    info.si_uid = getuid();
-    info.si_value = val;
-
-    return syscall(__NR_rt_sigqueueinfo, info.si_pid, sig, &info);
+    return vasprintf(s, fmt, ap);
 }
 
+size_t __fread_chk(void *ptr, size_t size, size_t nmemb, FILE *stream)
+{
+    return fread(ptr, size, nmemb, stream);
+}
+
+
+#include <stdarg.h>
+
+int vsscanf(const char *str, const char *format, va_list ap);
+
+int __isoc99_vsscanf(const char *str, const char *format, va_list ap)
+{
+    return vsscanf(str, format, ap);
+}
+
+int sscanf(const char *restrict s, const char *restrict fmt, ...)
+{
+    int ret;
+    va_list ap;
+    va_start(ap, fmt);
+    ret = vsscanf(s, fmt, ap);
+    va_end(ap);
+    return ret;
+}
+
+int __isoc99_sscanf(const char *str, const char *format, ...) __attribute__((weak, alias("sscanf")));
+
+
 #if defined (__cplusplus)
 }
 #endif
diff --git a/libs/libglibc-compatibility/musl/COPYRIGHT b/libs/libglibc-compatibility/musl/COPYRIGHT
new file mode 100644
index 00000000000..f0ee3b78d87
--- /dev/null
+++ b/libs/libglibc-compatibility/musl/COPYRIGHT
@@ -0,0 +1,163 @@
+musl as a whole is licensed under the following standard MIT license:
+
+----------------------------------------------------------------------
+Copyright © 2005-2014 Rich Felker, et al.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+----------------------------------------------------------------------
+
+Authors/contributors include:
+
+Alex Dowad
+Alexander Monakov
+Anthony G. Basile
+Arvid Picciani
+Bobby Bingham
+Boris Brezillon
+Brent Cook
+Chris Spiegel
+Clément Vasseur
+Daniel Micay
+Denys Vlasenko
+Emil Renner Berthing
+Felix Fietkau
+Felix Janda
+Gianluca Anzolin
+Hauke Mehrtens
+Hiltjo Posthuma
+Isaac Dunham
+Jaydeep Patil
+Jens Gustedt
+Jeremy Huntwork
+Jo-Philipp Wich
+Joakim Sindholt
+John Spencer
+Josiah Worcester
+Justin Cormack
+Khem Raj
+Kylie McClain
+Luca Barbato
+Luka Perkov
+M Farkas-Dyck (Strake)
+Mahesh Bodapati
+Michael Forney
+Natanael Copa
+Nicholas J. Kain
+orc
+Pascal Cuoq
+Petr Hosek
+Pierre Carrier
+Rich Felker
+Richard Pennington
+Shiz
+sin
+Solar Designer
+Stefan Kristiansson
+Szabolcs Nagy
+Timo Teräs
+Trutz Behn
+Valentin Ochs
+William Haddon
+
+Portions of this software are derived from third-party works licensed
+under terms compatible with the above MIT license:
+
+The TRE regular expression implementation (src/regex/reg* and
+src/regex/tre*) is Copyright © 2001-2008 Ville Laurikari and licensed
+under a 2-clause BSD license (license text in the source files). The
+included version has been heavily modified by Rich Felker in 2012, in
+the interests of size, simplicity, and namespace cleanliness.
+
+Much of the math library code (src/math/* and src/complex/*) is
+Copyright © 1993,2004 Sun Microsystems or
+Copyright © 2003-2011 David Schultz or
+Copyright © 2003-2009 Steven G. Kargl or
+Copyright © 2003-2009 Bruce D. Evans or
+Copyright © 2008 Stephen L. Moshier
+and labelled as such in comments in the individual source files. All
+have been licensed under extremely permissive terms.
+
+The ARM memcpy code (src/string/arm/memcpy_el.S) is Copyright © 2008
+The Android Open Source Project and is licensed under a two-clause BSD
+license. It was taken from Bionic libc, used on Android.
+
+The implementation of DES for crypt (src/crypt/crypt_des.c) is
+Copyright © 1994 David Burren. It is licensed under a BSD license.
+
+The implementation of blowfish crypt (src/crypt/crypt_blowfish.c) was
+originally written by Solar Designer and placed into the public
+domain. The code also comes with a fallback permissive license for use
+in jurisdictions that may not recognize the public domain.
+
+The smoothsort implementation (src/stdlib/qsort.c) is Copyright © 2011
+Valentin Ochs and is licensed under an MIT-style license.
+
+The BSD PRNG implementation (src/prng/random.c) and XSI search API
+(src/search/*.c) functions are Copyright © 2011 Szabolcs Nagy and
+licensed under following terms: "Permission to use, copy, modify,
+and/or distribute this code for any purpose with or without fee is
+hereby granted. There is no warranty."
+
+The x86_64 port was written by Nicholas J. Kain and is licensed under
+the standard MIT terms.
+
+The mips and microblaze ports were originally written by Richard
+Pennington for use in the ellcc project. The original code was adapted
+by Rich Felker for build system and code conventions during upstream
+integration. It is licensed under the standard MIT terms.
+
+The mips64 port was contributed by Imagination Technologies and is
+licensed under the standard MIT terms.
+
+The powerpc port was also originally written by Richard Pennington,
+and later supplemented and integrated by John Spencer. It is licensed
+under the standard MIT terms.
+
+All other files which have no copyright comments are original works
+produced specifically for use as part of this library, written either
+by Rich Felker, the main author of the library, or by one or more
+contibutors listed above. Details on authorship of individual files
+can be found in the git version control history of the project. The
+omission of copyright and license comments in each file is in the
+interest of source tree size.
+
+In addition, permission is hereby granted for all public header files
+(include/* and arch/*/bits/*) and crt files intended to be linked into
+applications (crt/*, ldso/dlstart.c, and arch/*/crt_arch.h) to omit
+the copyright notice and permission notice otherwise required by the
+license, and to use these files without any requirement of
+attribution. These files include substantial contributions from:
+
+Bobby Bingham
+John Spencer
+Nicholas J. Kain
+Rich Felker
+Richard Pennington
+Stefan Kristiansson
+Szabolcs Nagy
+
+all of whom have explicitly granted such permission.
+
+This file previously contained text expressing a belief that most of
+the files covered by the above exception were sufficiently trivial not
+to be subject to copyright, resulting in confusion over whether it
+negated the permissions granted in the license. In the spirit of
+permissive licensing, and of not having licensing issues being an
+obstacle to adoption, that text has been removed.
diff --git a/libs/libglibc-compatibility/musl/README b/libs/libglibc-compatibility/musl/README
new file mode 100644
index 00000000000..11f6caa2d7e
--- /dev/null
+++ b/libs/libglibc-compatibility/musl/README
@@ -0,0 +1,6 @@
+Tiny pieces extracted from MUSL library.
+
+git://git.musl-libc.org/musl
+c10bc61508dc52b8315084e628f36a6c3c2dabb1
+
+NOTE: Files was edited.
diff --git a/libs/libglibc-compatibility/musl/fallocate.c b/libs/libglibc-compatibility/musl/fallocate.c
new file mode 100644
index 00000000000..31e63822c94
--- /dev/null
+++ b/libs/libglibc-compatibility/musl/fallocate.c
@@ -0,0 +1,10 @@
+#define _GNU_SOURCE
+#include <fcntl.h>
+#include <sys/syscall.h>
+
+extern long int syscall (long int __sysno, ...) __THROW;
+
+int fallocate(int fd, int mode, off_t base, off_t len)
+{
+	return syscall(SYS_fallocate, fd, mode, base, len);
+}
diff --git a/libs/libglibc-compatibility/musl/lgamma.c b/libs/libglibc-compatibility/musl/lgamma.c
new file mode 100644
index 00000000000..55a1f9e46a4
--- /dev/null
+++ b/libs/libglibc-compatibility/musl/lgamma.c
@@ -0,0 +1,268 @@
+/* origin: FreeBSD /usr/src/lib/msun/src/e_lgamma_r.c */
+/*
+ * ====================================================
+ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+ *
+ * Developed at SunSoft, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ *
+ */
+/* lgamma_r(x, signgamp)
+ * Reentrant version of the logarithm of the Gamma function
+ * with user provide pointer for the sign of Gamma(x).
+ *
+ * Method:
+ *   1. Argument Reduction for 0 < x <= 8
+ *      Since gamma(1+s)=s*gamma(s), for x in [0,8], we may
+ *      reduce x to a number in [1.5,2.5] by
+ *              lgamma(1+s) = log(s) + lgamma(s)
+ *      for example,
+ *              lgamma(7.3) = log(6.3) + lgamma(6.3)
+ *                          = log(6.3*5.3) + lgamma(5.3)
+ *                          = log(6.3*5.3*4.3*3.3*2.3) + lgamma(2.3)
+ *   2. Polynomial approximation of lgamma around its
+ *      minimun ymin=1.461632144968362245 to maintain monotonicity.
+ *      On [ymin-0.23, ymin+0.27] (i.e., [1.23164,1.73163]), use
+ *              Let z = x-ymin;
+ *              lgamma(x) = -1.214862905358496078218 + z^2*poly(z)
+ *      where
+ *              poly(z) is a 14 degree polynomial.
+ *   2. Rational approximation in the primary interval [2,3]
+ *      We use the following approximation:
+ *              s = x-2.0;
+ *              lgamma(x) = 0.5*s + s*P(s)/Q(s)
+ *      with accuracy
+ *              |P/Q - (lgamma(x)-0.5s)| < 2**-61.71
+ *      Our algorithms are based on the following observation
+ *
+ *                             zeta(2)-1    2    zeta(3)-1    3
+ * lgamma(2+s) = s*(1-Euler) + --------- * s  -  --------- * s  + ...
+ *                                 2                 3
+ *
+ *      where Euler = 0.5771... is the Euler constant, which is very
+ *      close to 0.5.
+ *
+ *   3. For x>=8, we have
+ *      lgamma(x)~(x-0.5)log(x)-x+0.5*log(2pi)+1/(12x)-1/(360x**3)+....
+ *      (better formula:
+ *         lgamma(x)~(x-0.5)*(log(x)-1)-.5*(log(2pi)-1) + ...)
+ *      Let z = 1/x, then we approximation
+ *              f(z) = lgamma(x) - (x-0.5)(log(x)-1)
+ *      by
+ *                                  3       5             11
+ *              w = w0 + w1*z + w2*z  + w3*z  + ... + w6*z
+ *      where
+ *              |w - f(z)| < 2**-58.74
+ *
+ *   4. For negative x, since (G is gamma function)
+ *              -x*G(-x)*G(x) = pi/sin(pi*x),
+ *      we have
+ *              G(x) = pi/(sin(pi*x)*(-x)*G(-x))
+ *      since G(-x) is positive, sign(G(x)) = sign(sin(pi*x)) for x<0
+ *      Hence, for x<0, signgam = sign(sin(pi*x)) and
+ *              lgamma(x) = log(|Gamma(x)|)
+ *                        = log(pi/(|x*sin(pi*x)|)) - lgamma(-x);
+ *      Note: one should avoid compute pi*(-x) directly in the
+ *            computation of sin(pi*(-x)).
+ *
+ *   5. Special Cases
+ *              lgamma(2+s) ~ s*(1-Euler) for tiny s
+ *              lgamma(1) = lgamma(2) = 0
+ *              lgamma(x) ~ -log(|x|) for tiny x
+ *              lgamma(0) = lgamma(neg.integer) = inf and raise divide-by-zero
+ *              lgamma(inf) = inf
+ *              lgamma(-inf) = inf (bug for bug compatible with C99!?)
+ *
+ */
+
+static const double
+pi  =  3.14159265358979311600e+00, /* 0x400921FB, 0x54442D18 */
+a0  =  7.72156649015328655494e-02, /* 0x3FB3C467, 0xE37DB0C8 */
+a1  =  3.22467033424113591611e-01, /* 0x3FD4A34C, 0xC4A60FAD */
+a2  =  6.73523010531292681824e-02, /* 0x3FB13E00, 0x1A5562A7 */
+a3  =  2.05808084325167332806e-02, /* 0x3F951322, 0xAC92547B */
+a4  =  7.38555086081402883957e-03, /* 0x3F7E404F, 0xB68FEFE8 */
+a5  =  2.89051383673415629091e-03, /* 0x3F67ADD8, 0xCCB7926B */
+a6  =  1.19270763183362067845e-03, /* 0x3F538A94, 0x116F3F5D */
+a7  =  5.10069792153511336608e-04, /* 0x3F40B6C6, 0x89B99C00 */
+a8  =  2.20862790713908385557e-04, /* 0x3F2CF2EC, 0xED10E54D */
+a9  =  1.08011567247583939954e-04, /* 0x3F1C5088, 0x987DFB07 */
+a10 =  2.52144565451257326939e-05, /* 0x3EFA7074, 0x428CFA52 */
+a11 =  4.48640949618915160150e-05, /* 0x3F07858E, 0x90A45837 */
+tc  =  1.46163214496836224576e+00, /* 0x3FF762D8, 0x6356BE3F */
+tf  = -1.21486290535849611461e-01, /* 0xBFBF19B9, 0xBCC38A42 */
+/* tt = -(tail of tf) */
+tt  = -3.63867699703950536541e-18, /* 0xBC50C7CA, 0xA48A971F */
+t0  =  4.83836122723810047042e-01, /* 0x3FDEF72B, 0xC8EE38A2 */
+t1  = -1.47587722994593911752e-01, /* 0xBFC2E427, 0x8DC6C509 */
+t2  =  6.46249402391333854778e-02, /* 0x3FB08B42, 0x94D5419B */
+t3  = -3.27885410759859649565e-02, /* 0xBFA0C9A8, 0xDF35B713 */
+t4  =  1.79706750811820387126e-02, /* 0x3F9266E7, 0x970AF9EC */
+t5  = -1.03142241298341437450e-02, /* 0xBF851F9F, 0xBA91EC6A */
+t6  =  6.10053870246291332635e-03, /* 0x3F78FCE0, 0xE370E344 */
+t7  = -3.68452016781138256760e-03, /* 0xBF6E2EFF, 0xB3E914D7 */
+t8  =  2.25964780900612472250e-03, /* 0x3F6282D3, 0x2E15C915 */
+t9  = -1.40346469989232843813e-03, /* 0xBF56FE8E, 0xBF2D1AF1 */
+t10 =  8.81081882437654011382e-04, /* 0x3F4CDF0C, 0xEF61A8E9 */
+t11 = -5.38595305356740546715e-04, /* 0xBF41A610, 0x9C73E0EC */
+t12 =  3.15632070903625950361e-04, /* 0x3F34AF6D, 0x6C0EBBF7 */
+t13 = -3.12754168375120860518e-04, /* 0xBF347F24, 0xECC38C38 */
+t14 =  3.35529192635519073543e-04, /* 0x3F35FD3E, 0xE8C2D3F4 */
+u0  = -7.72156649015328655494e-02, /* 0xBFB3C467, 0xE37DB0C8 */
+u1  =  6.32827064025093366517e-01, /* 0x3FE4401E, 0x8B005DFF */
+u2  =  1.45492250137234768737e+00, /* 0x3FF7475C, 0xD119BD6F */
+u3  =  9.77717527963372745603e-01, /* 0x3FEF4976, 0x44EA8450 */
+u4  =  2.28963728064692451092e-01, /* 0x3FCD4EAE, 0xF6010924 */
+u5  =  1.33810918536787660377e-02, /* 0x3F8B678B, 0xBF2BAB09 */
+v1  =  2.45597793713041134822e+00, /* 0x4003A5D7, 0xC2BD619C */
+v2  =  2.12848976379893395361e+00, /* 0x40010725, 0xA42B18F5 */
+v3  =  7.69285150456672783825e-01, /* 0x3FE89DFB, 0xE45050AF */
+v4  =  1.04222645593369134254e-01, /* 0x3FBAAE55, 0xD6537C88 */
+v5  =  3.21709242282423911810e-03, /* 0x3F6A5ABB, 0x57D0CF61 */
+s0  = -7.72156649015328655494e-02, /* 0xBFB3C467, 0xE37DB0C8 */
+s1  =  2.14982415960608852501e-01, /* 0x3FCB848B, 0x36E20878 */
+s2  =  3.25778796408930981787e-01, /* 0x3FD4D98F, 0x4F139F59 */
+s3  =  1.46350472652464452805e-01, /* 0x3FC2BB9C, 0xBEE5F2F7 */
+s4  =  2.66422703033638609560e-02, /* 0x3F9B481C, 0x7E939961 */
+s5  =  1.84028451407337715652e-03, /* 0x3F5E26B6, 0x7368F239 */
+s6  =  3.19475326584100867617e-05, /* 0x3F00BFEC, 0xDD17E945 */
+r1  =  1.39200533467621045958e+00, /* 0x3FF645A7, 0x62C4AB74 */
+r2  =  7.21935547567138069525e-01, /* 0x3FE71A18, 0x93D3DCDC */
+r3  =  1.71933865632803078993e-01, /* 0x3FC601ED, 0xCCFBDF27 */
+r4  =  1.86459191715652901344e-02, /* 0x3F9317EA, 0x742ED475 */
+r5  =  7.77942496381893596434e-04, /* 0x3F497DDA, 0xCA41A95B */
+r6  =  7.32668430744625636189e-06, /* 0x3EDEBAF7, 0xA5B38140 */
+w0  =  4.18938533204672725052e-01, /* 0x3FDACFE3, 0x90C97D69 */
+w1  =  8.33333333333329678849e-02, /* 0x3FB55555, 0x5555553B */
+w2  = -2.77777777728775536470e-03, /* 0xBF66C16C, 0x16B02E5C */
+w3  =  7.93650558643019558500e-04, /* 0x3F4A019F, 0x98CF38B6 */
+w4  = -5.95187557450339963135e-04, /* 0xBF4380CB, 0x8C0FE741 */
+w5  =  8.36339918996282139126e-04, /* 0x3F4B67BA, 0x4CDAD5D1 */
+w6  = -1.63092934096575273989e-03; /* 0xBF5AB89D, 0x0B9E43E4 */
+
+#include <stdint.h>
+#include <math.h>
+
+double lgamma_r(double x, int *signgamp)
+{
+	union {double f; uint64_t i;} u = {x};
+	double_t t,y,z,nadj,p,p1,p2,p3,q,r,w;
+	uint32_t ix;
+	int sign,i;
+
+	/* purge off +-inf, NaN, +-0, tiny and negative arguments */
+	*signgamp = 1;
+	sign = u.i>>63;
+	ix = u.i>>32 & 0x7fffffff;
+	if (ix >= 0x7ff00000)
+		return x*x;
+	if (ix < (0x3ff-70)<<20) {  /* |x|<2**-70, return -log(|x|) */
+		if(sign) {
+			x = -x;
+			*signgamp = -1;
+		}
+		return -log(x);
+	}
+	if (sign) {
+		x = -x;
+		t = sin(pi * x);
+		if (t == 0.0) /* -integer */
+			return 1.0/(x-x);
+		if (t > 0.0)
+			*signgamp = -1;
+		else
+			t = -t;
+		nadj = log(pi/(t*x));
+	}
+
+	/* purge off 1 and 2 */
+	if ((ix == 0x3ff00000 || ix == 0x40000000) && (uint32_t)u.i == 0)
+		r = 0;
+	/* for x < 2.0 */
+	else if (ix < 0x40000000) {
+		if (ix <= 0x3feccccc) {   /* lgamma(x) = lgamma(x+1)-log(x) */
+			r = -log(x);
+			if (ix >= 0x3FE76944) {
+				y = 1.0 - x;
+				i = 0;
+			} else if (ix >= 0x3FCDA661) {
+				y = x - (tc-1.0);
+				i = 1;
+			} else {
+				y = x;
+				i = 2;
+			}
+		} else {
+			r = 0.0;
+			if (ix >= 0x3FFBB4C3) {  /* [1.7316,2] */
+				y = 2.0 - x;
+				i = 0;
+			} else if(ix >= 0x3FF3B4C4) {  /* [1.23,1.73] */
+				y = x - tc;
+				i = 1;
+			} else {
+				y = x - 1.0;
+				i = 2;
+			}
+		}
+		switch (i) {
+		case 0:
+			z = y*y;
+			p1 = a0+z*(a2+z*(a4+z*(a6+z*(a8+z*a10))));
+			p2 = z*(a1+z*(a3+z*(a5+z*(a7+z*(a9+z*a11)))));
+			p = y*p1+p2;
+			r += (p-0.5*y);
+			break;
+		case 1:
+			z = y*y;
+			w = z*y;
+			p1 = t0+w*(t3+w*(t6+w*(t9 +w*t12)));    /* parallel comp */
+			p2 = t1+w*(t4+w*(t7+w*(t10+w*t13)));
+			p3 = t2+w*(t5+w*(t8+w*(t11+w*t14)));
+			p = z*p1-(tt-w*(p2+y*p3));
+			r += tf + p;
+			break;
+		case 2:
+			p1 = y*(u0+y*(u1+y*(u2+y*(u3+y*(u4+y*u5)))));
+			p2 = 1.0+y*(v1+y*(v2+y*(v3+y*(v4+y*v5))));
+			r += -0.5*y + p1/p2;
+		}
+	} else if (ix < 0x40200000) {  /* x < 8.0 */
+		i = (int)x;
+		y = x - (double)i;
+		p = y*(s0+y*(s1+y*(s2+y*(s3+y*(s4+y*(s5+y*s6))))));
+		q = 1.0+y*(r1+y*(r2+y*(r3+y*(r4+y*(r5+y*r6)))));
+		r = 0.5*y+p/q;
+		z = 1.0;    /* lgamma(1+s) = log(s) + lgamma(s) */
+		switch (i) {
+		case 7: z *= y + 6.0;  /* FALLTHRU */
+		case 6: z *= y + 5.0;  /* FALLTHRU */
+		case 5: z *= y + 4.0;  /* FALLTHRU */
+		case 4: z *= y + 3.0;  /* FALLTHRU */
+		case 3: z *= y + 2.0;  /* FALLTHRU */
+			r += log(z);
+			break;
+		}
+	} else if (ix < 0x43900000) {  /* 8.0 <= x < 2**58 */
+		t = log(x);
+		z = 1.0/x;
+		y = z*z;
+		w = w0+z*(w1+y*(w2+y*(w3+y*(w4+y*(w5+y*w6)))));
+		r = (x-0.5)*(t-1.0)+w;
+	} else                         /* 2**58 <= x <= inf */
+		r =  x*(log(x)-1.0);
+	if (sign)
+		r = nadj - r;
+	return r;
+}
+
+
+int signgam;
+
+double lgamma(double x)
+{
+	return lgamma_r(x, &signgam);
+}
diff --git a/libs/libglibc-compatibility/musl/longjmp.s b/libs/libglibc-compatibility/musl/longjmp.s
new file mode 100644
index 00000000000..e175a4b9606
--- /dev/null
+++ b/libs/libglibc-compatibility/musl/longjmp.s
@@ -0,0 +1,22 @@
+/* Copyright 2011-2012 Nicholas J. Kain, licensed under standard MIT license */
+.global _longjmp
+.global longjmp
+.type _longjmp,@function
+.type longjmp,@function
+_longjmp:
+longjmp:
+	mov %rsi,%rax           /* val will be longjmp return */
+	test %rax,%rax
+	jnz 1f
+	inc %rax                /* if val==0, val=1 per longjmp semantics */
+1:
+	mov (%rdi),%rbx         /* rdi is the jmp_buf, restore regs from it */
+	mov 8(%rdi),%rbp
+	mov 16(%rdi),%r12
+	mov 24(%rdi),%r13
+	mov 32(%rdi),%r14
+	mov 40(%rdi),%r15
+	mov 48(%rdi),%rdx       /* this ends up being the stack pointer */
+	mov %rdx,%rsp
+	mov 56(%rdi),%rdx       /* this is the instruction pointer */
+	jmp *%rdx               /* goto saved address without altering rsp */
diff --git a/libs/libglibc-compatibility/musl/pipe2.c b/libs/libglibc-compatibility/musl/pipe2.c
new file mode 100644
index 00000000000..061f2e07313
--- /dev/null
+++ b/libs/libglibc-compatibility/musl/pipe2.c
@@ -0,0 +1,24 @@
+#include <unistd.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/syscall.h>
+
+extern long int syscall (long int __sysno, ...) __THROW;
+
+int pipe2(int fd[2], int flag)
+{
+	if (!flag) return pipe(fd);
+	int ret = syscall(SYS_pipe2, fd, flag);
+	if (ret != -ENOSYS) return -ret;
+	ret = pipe(fd);
+	if (ret) return ret;
+	if (flag & O_CLOEXEC) {
+		syscall(SYS_fcntl, fd[0], F_SETFD, FD_CLOEXEC);
+		syscall(SYS_fcntl, fd[1], F_SETFD, FD_CLOEXEC);
+	}
+	if (flag & O_NONBLOCK) {
+		syscall(SYS_fcntl, fd[0], F_SETFL, O_NONBLOCK);
+		syscall(SYS_fcntl, fd[1], F_SETFL, O_NONBLOCK);
+	}
+	return 0;
+}
diff --git a/libs/libglibc-compatibility/musl/vasprintf.c b/libs/libglibc-compatibility/musl/vasprintf.c
new file mode 100644
index 00000000000..08251bc20ec
--- /dev/null
+++ b/libs/libglibc-compatibility/musl/vasprintf.c
@@ -0,0 +1,15 @@
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+
+int vasprintf(char **s, const char *fmt, va_list ap)
+{
+	va_list ap2;
+	va_copy(ap2, ap);
+	int l = vsnprintf(0, 0, fmt, ap2);
+	va_end(ap2);
+
+	if (l<0 || !(*s=malloc(l+1U))) return -1;
+	return vsnprintf(*s, l+1U, fmt, ap);
+}

From 148421d10f24202a8e8f68ab6a55f342b18afa9d Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 10:29:03 +0300
Subject: [PATCH 234/266] Better GLIBC_COMPATIBILITY option [#CLICKHOUSE-3275].

---
 libs/libglibc-compatibility/glibc-compatibility.c | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/libs/libglibc-compatibility/glibc-compatibility.c b/libs/libglibc-compatibility/glibc-compatibility.c
index e06bac8e290..6aed44a3efd 100644
--- a/libs/libglibc-compatibility/glibc-compatibility.c
+++ b/libs/libglibc-compatibility/glibc-compatibility.c
@@ -70,7 +70,7 @@ void __longjmp_chk(jmp_buf env, int val)
     return longjmp(env, val);
 }
 
-#include <stdio.h>
+#include <stdarg.h>
 
 int vasprintf(char **s, const char *fmt, va_list ap);
 
@@ -79,14 +79,13 @@ int __vasprintf_chk(char **s, const char *fmt, va_list ap)
     return vasprintf(s, fmt, ap);
 }
 
-size_t __fread_chk(void *ptr, size_t size, size_t nmemb, FILE *stream)
+size_t fread(void *ptr, size_t size, size_t nmemb, void *stream);
+
+size_t __fread_chk(void *ptr, size_t size, size_t nmemb, void *stream)
 {
     return fread(ptr, size, nmemb, stream);
 }
 
-
-#include <stdarg.h>
-
 int vsscanf(const char *str, const char *format, va_list ap);
 
 int __isoc99_vsscanf(const char *str, const char *format, va_list ap)

From a3f3ed12ab95ea4c972ffbb3a1b91c7f8a0c5e96 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 10:32:27 +0300
Subject: [PATCH 235/266] Better GLIBC_COMPATIBILITY option [#CLICKHOUSE-3275].

---
 libs/libglibc-compatibility/musl/lgamma.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libs/libglibc-compatibility/musl/lgamma.c b/libs/libglibc-compatibility/musl/lgamma.c
index 55a1f9e46a4..b0e4f3aa537 100644
--- a/libs/libglibc-compatibility/musl/lgamma.c
+++ b/libs/libglibc-compatibility/musl/lgamma.c
@@ -149,7 +149,7 @@ w6  = -1.63092934096575273989e-03; /* 0xBF5AB89D, 0x0B9E43E4 */
 double lgamma_r(double x, int *signgamp)
 {
 	union {double f; uint64_t i;} u = {x};
-	double_t t,y,z,nadj,p,p1,p2,p3,q,r,w;
+	double_t t,y,z,nadj=0,p,p1,p2,p3,q,r,w;
 	uint32_t ix;
 	int sign,i;
 

From 1544187f7b8a1a7d48ff6f7621139ee3009ba480 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 10:51:38 +0300
Subject: [PATCH 236/266] Better GLIBC_COMPATIBILITY option [#CLICKHOUSE-3275].

---
 libs/libglibc-compatibility/glibc-compatibility.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/libs/libglibc-compatibility/glibc-compatibility.c b/libs/libglibc-compatibility/glibc-compatibility.c
index 6aed44a3efd..367bd2de765 100644
--- a/libs/libglibc-compatibility/glibc-compatibility.c
+++ b/libs/libglibc-compatibility/glibc-compatibility.c
@@ -105,6 +105,13 @@ int sscanf(const char *restrict s, const char *restrict fmt, ...)
 
 int __isoc99_sscanf(const char *str, const char *format, ...) __attribute__((weak, alias("sscanf")));
 
+int open(const char *path, int oflag);
+
+int __open_2(const char *path, int oflag)
+{
+    return open(path, oflag);
+}
+
 
 #if defined (__cplusplus)
 }

From 9b8722b0b505d8a985c085ed45605f7e837ac5b3 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 12:18:52 +0300
Subject: [PATCH 237/266] Fixed incompatibility of debian packages with older
 systems [#CLICKHOUSE-3275].

---
 debian/clickhouse-client.postinst | 3 +++
 debian/rules                      | 5 ++++-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/debian/clickhouse-client.postinst b/debian/clickhouse-client.postinst
index 2e84aad51ed..06b4b8654b0 100644
--- a/debian/clickhouse-client.postinst
+++ b/debian/clickhouse-client.postinst
@@ -1,2 +1,5 @@
+#!/bin/sh
+set -e
+
 mkdir -p /etc/clickhouse-client/conf.d
 chown -R clickhouse: /etc/clickhouse-client
diff --git a/debian/rules b/debian/rules
index c74140a2c51..4738dde4fb6 100755
--- a/debian/rules
+++ b/debian/rules
@@ -95,4 +95,7 @@ endif
 	dh_install --list-missing --sourcedir=$(DESTDIR)
 
 override_dh_shlibdeps:
-	dh_shlibdeps -Xdebian/clickhouse-server-base/usr/share/clickhouse/bin/*
+	true # We depend only on libc and dh_shlibdeps gives us wrong (too strict) dependency.
+
+override_dh_builddeb:
+	dh_builddeb -- -Z gzip # Older systems don't have "xz", so use "gzip" instead.

From 5d038312b79f4555153e530abd28474f1cdeaddc Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 12:49:50 +0300
Subject: [PATCH 238/266] Fixed readme [#CLICKHOUSE-3275].

---
 libs/libmemcpy/README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libs/libmemcpy/README.md b/libs/libmemcpy/README.md
index d3dd14ac55b..e253f6bf5dd 100644
--- a/libs/libmemcpy/README.md
+++ b/libs/libmemcpy/README.md
@@ -5,7 +5,7 @@ It has the following advantages over `libc`-supplied implementation:
 - it is linked statically, so the function can have position-dependent code;
 - your binaries will not depend on `glibc`'s memcpy, that forces dependency on specific symbol version like `memcpy@@GLIBC_2.14` and consequently on specific version of `glibc` library;
 - you can include `memcpy.h` directly and the function has the chance to be inlined, which is beneficial for small but unknown at compile time sizes of memory regions;
-- this version of `memcpy` pretend to be faster (in our benchmarks, the difference is withing few percents).
+- this version of `memcpy` pretend to be faster (in our benchmarks, the difference is within few percents).
 
 Currently it uses the implementation from **Linwei** (skywind3000@163.com).
 Look at https://www.zhihu.com/question/35172305 for discussion.

From 3523059be9bbde604ec9da33375dadf0a9eb9641 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 13:12:50 +0300
Subject: [PATCH 239/266] Increased inline depth for clang (it must inline as
 good as gcc) [#CLICKHOUSE-2].

---
 CMakeLists.txt | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 69b20377459..b65f625142f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -106,6 +106,11 @@ if (USE_LIBCXX)
     set (CMAKE_CXX_FLAGS_DEBUG           "${CMAKE_CXX_FLAGS_DEBUG} -D_LIBCPP_DEBUG=1") # More checks in debug build.
 endif ()
 
+# Special options for better optimized code with clang
+if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    set (CMAKE_CXX_FLAGS_RELWITHDEBINFO  "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -mllvm -inline-threshold=10000")
+endif ()
+
 set (CMAKE_BUILD_COLOR_MAKEFILE          ON)
 set (CMAKE_CXX_FLAGS                     "${CMAKE_CXX_FLAGS} ${COMPILER_FLAGS} -std=gnu++1z ${PLATFORM_EXTRA_CXX_FLAG} -fno-omit-frame-pointer ${COMMON_WARNING_FLAGS} ${CXX_WARNING_FLAGS} ${GLIBC_COMPATIBILITY_COMPILE_FLAGS}")
 #set (CMAKE_CXX_FLAGS_RELEASE             "${CMAKE_CXX_FLAGS_RELEASE}")

From cfd4120f4a587660f2d223590cb648cc37a34e5e Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 14:08:39 +0300
Subject: [PATCH 240/266] Fixed build with increased inline-depth in clang
 [#CLICKHOUSE-2].

---
 dbms/src/Dictionaries/ComplexKeyCacheDictionary.cpp | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/dbms/src/Dictionaries/ComplexKeyCacheDictionary.cpp b/dbms/src/Dictionaries/ComplexKeyCacheDictionary.cpp
index 37cfc759e6c..489557f8a85 100644
--- a/dbms/src/Dictionaries/ComplexKeyCacheDictionary.cpp
+++ b/dbms/src/Dictionaries/ComplexKeyCacheDictionary.cpp
@@ -466,6 +466,17 @@ StringRef ComplexKeyCacheDictionary::placeKeysInPool(
     return { place, sum_keys_size };
 }
 
+/// Explicit instantiations.
+
+template StringRef ComplexKeyCacheDictionary::placeKeysInPool<Arena>(
+    const size_t row, const Columns & key_columns, StringRefs & keys,
+    const std::vector<DictionaryAttribute> & key_attributes, Arena & pool);
+
+template StringRef ComplexKeyCacheDictionary::placeKeysInPool<ArenaWithFreeLists>(
+    const size_t row, const Columns & key_columns, StringRefs & keys,
+    const std::vector<DictionaryAttribute> & key_attributes, ArenaWithFreeLists & pool);
+
+
 StringRef ComplexKeyCacheDictionary::placeKeysInFixedSizePool(
     const size_t row, const Columns & key_columns) const
 {

From 23d94797c348956187645c55d4aed955b781bf72 Mon Sep 17 00:00:00 2001
From: Amy Krishnevsky <krishnevsky@yandex-team.ru>
Date: Fri, 15 Sep 2017 14:16:02 +0300
Subject: [PATCH 241/266] Translate update to changelog.md

---
 CHANGELOG.md | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8a7a389bac9..30a1b4b2558 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,41 @@
+# ClickHouse release 1.1.54289
+
+## New features:
+* `SYSTEM` requests for server administration: `SYSTEM RELOAD DICTIONARY`, `SYSTEM RELOAD DICTIONARIES`, `SYSTEM DROP DNS CACHE`, `SYSTEM SHUTDOWN`, `SYSTEM KILL`.
+* Added functions for working with arrays: `concat`, `arraySlice`, `arrayPushBack`, `arrayPushFront`, `arrayPopBack`, `arrayPopFront`.
+* Added the `root` and `identity` parameters for the ZooKeeper configuration. This allows you to isolate individual users on the same ZooKeeper cluster.
+* Added the aggregate functions `groupBitAnd`, `groupBitOr`, and `groupBitXor` (for compatibility, they can also be accessed with the names `BIT_AND`, `BIT_OR`, and `BIT_XOR`).
+* External dictionaries can be loaded from MySQL by specifying a socket in the file system.
+* External dictionaries can be loaded from MySQL over SSL (the `ssl_cert`, `ssl_key`, and `ssl_ca` parameters).
+* Added the `max_network_bandwidth_for_user` setting to restrict the overall bandwidth use for requests per user.
+* Support for `DROP TABLE` for temporary tables.
+* Support for reading `DateTime` values in Unix timestamp format from the `CSV` and `JSONEachRow` formats.
+* Lagging replicas in distributed queries are now excluded by default (the default threshold is 5 minutes).
+* FIFO blocking is used during ALTER: an ALTER query isn't blocked indefinitely for continuously running queries.
+* Option to set `umask` in the config file.
+* Improved performance for queries with `DISTINCT`.
+
+## Bug fixes:
+* Improved the process for deleting old nodes in ZooKeeper. Previously, old nodes sometimes didn't get deleted if there were frequent inserts, which caused the server to be slow to shut down, among other things.
+* Fixed randomization when choosing hosts for the connection to ZooKeeper.
+* Fixed the exclusion of lagging replicas in distributed queries if the replica is localhost.
+* Fixed an error where a data part in a `ReplicatedMergeTree` table could be broken after running `ALTER MODIFY` on an element in a `Nested` structure.
+* Fixed an error that could cause SELECT queries to "hang". 
+* Improvements to distributed DDL queries.
+* Fixed the query `CREATE TABLE ... AS <materialized view>`.
+* Resolved the deadlock in the `ALTER ... CLEAR COLUMN IN PARTITION` query for `Buffer` tables.
+* Fixed the invalid default value for `Enum`s (0 instead of the minimum) when using the `JSONEachRow` and `TSKV` formats.
+* Resolved the appearance of zombie processes when using a dictionary with an `executable` source.
+* Fixed the segfault for the HEAD query.
+
+## Improvements to development workflow and ClickHouse assembly:
+* You can use `pbuilder` to build ClickHouse.
+* You can use `libc++` instead of `libstdc++` for builds on Linux.
+* Added instructions for using static code analysis tools: `Coverity`, `clang-tidy`, and `cppcheck`.
+
+## Please note when upgrading:
+* There is now a higher default value for the MergeTree setting `max_bytes_to_merge_at_max_space_in_pool` (the maximum total size of data parts to merge, in bytes): it has increased from 100 GiB to 150 GiB. This might result in large merges running after the server upgrade, which could cause an increased load on the disk subsystem. If the free space available on the server is less than twice the total amount of the merges that are running, this will cause all other merges to stop running, including merges of small data parts. As a result, INSERT requests will fail with the message "Merges are processing significantly slower than inserts." Use the `SELECT * FROM system.merges` request to monitor the situation. You can also check the `DiskSpaceReservedForMerge` metric in the `system.metrics` table, or in Graphite. You don't need to do anything to fix this, since the issue will resolve itself once the large merges finish. If you find this unacceptable, you can restore the previous value for the `max_bytes_to_merge_at_max_space_in_pool` setting (to do this, go to the `<merge_tree>` section in config.xml, set `<max_bytes_to_merge_at_max_space_in_pool>107374182400</max_bytes_to_merge_at_max_space_in_pool>` and restart the server).
+
 # ClickHouse release 1.1.54284
 
 * This is bugfix release for previous 1.1.54282 release. It fixes ZooKeeper nodes leak in `parts/` directory.

From 2bba5b2f02b63665d8f9755f2c50f960c1dcf668 Mon Sep 17 00:00:00 2001
From: alexey-milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 14:33:45 +0300
Subject: [PATCH 242/266] Update CHANGELOG.md

---
 CHANGELOG.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 30a1b4b2558..a926e5cdc4b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,22 +1,22 @@
 # ClickHouse release 1.1.54289
 
 ## New features:
-* `SYSTEM` requests for server administration: `SYSTEM RELOAD DICTIONARY`, `SYSTEM RELOAD DICTIONARIES`, `SYSTEM DROP DNS CACHE`, `SYSTEM SHUTDOWN`, `SYSTEM KILL`.
+* `SYSTEM` queries for server administration: `SYSTEM RELOAD DICTIONARY`, `SYSTEM RELOAD DICTIONARIES`, `SYSTEM DROP DNS CACHE`, `SYSTEM SHUTDOWN`, `SYSTEM KILL`.
 * Added functions for working with arrays: `concat`, `arraySlice`, `arrayPushBack`, `arrayPushFront`, `arrayPopBack`, `arrayPopFront`.
 * Added the `root` and `identity` parameters for the ZooKeeper configuration. This allows you to isolate individual users on the same ZooKeeper cluster.
 * Added the aggregate functions `groupBitAnd`, `groupBitOr`, and `groupBitXor` (for compatibility, they can also be accessed with the names `BIT_AND`, `BIT_OR`, and `BIT_XOR`).
-* External dictionaries can be loaded from MySQL by specifying a socket in the file system.
+* External dictionaries can be loaded from MySQL by specifying a socket in the filesystem.
 * External dictionaries can be loaded from MySQL over SSL (the `ssl_cert`, `ssl_key`, and `ssl_ca` parameters).
-* Added the `max_network_bandwidth_for_user` setting to restrict the overall bandwidth use for requests per user.
+* Added the `max_network_bandwidth_for_user` setting to restrict the overall bandwidth use for queries per user.
 * Support for `DROP TABLE` for temporary tables.
 * Support for reading `DateTime` values in Unix timestamp format from the `CSV` and `JSONEachRow` formats.
 * Lagging replicas in distributed queries are now excluded by default (the default threshold is 5 minutes).
-* FIFO blocking is used during ALTER: an ALTER query isn't blocked indefinitely for continuously running queries.
+* FIFO locking is used during ALTER: an ALTER query isn't blocked indefinitely for continuously running queries.
 * Option to set `umask` in the config file.
 * Improved performance for queries with `DISTINCT`.
 
 ## Bug fixes:
-* Improved the process for deleting old nodes in ZooKeeper. Previously, old nodes sometimes didn't get deleted if there were frequent inserts, which caused the server to be slow to shut down, among other things.
+* Improved the process for deleting old nodes in ZooKeeper. Previously, old nodes sometimes didn't get deleted if there were very frequent inserts, which caused the server to be slow to shut down, among other things.
 * Fixed randomization when choosing hosts for the connection to ZooKeeper.
 * Fixed the exclusion of lagging replicas in distributed queries if the replica is localhost.
 * Fixed an error where a data part in a `ReplicatedMergeTree` table could be broken after running `ALTER MODIFY` on an element in a `Nested` structure.
@@ -26,9 +26,9 @@
 * Resolved the deadlock in the `ALTER ... CLEAR COLUMN IN PARTITION` query for `Buffer` tables.
 * Fixed the invalid default value for `Enum`s (0 instead of the minimum) when using the `JSONEachRow` and `TSKV` formats.
 * Resolved the appearance of zombie processes when using a dictionary with an `executable` source.
-* Fixed the segfault for the HEAD query.
+* Fixed segfault for the HEAD query.
 
-## Improvements to development workflow and ClickHouse assembly:
+## Improvements to development workflow and ClickHouse build:
 * You can use `pbuilder` to build ClickHouse.
 * You can use `libc++` instead of `libstdc++` for builds on Linux.
 * Added instructions for using static code analysis tools: `Coverity`, `clang-tidy`, and `cppcheck`.

From 86c46ad1bdd0fc90903a569d169a9f8ae9195ac2 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 15:16:12 +0300
Subject: [PATCH 243/266] Unification [#CLICKHOUSE-2].

---
 .../AggregateFunctionGroupArray.cpp           |   2 +-
 .../AggregateFunctionStatistics.h             |  30 ++--
 dbms/src/AggregateFunctions/Helpers.h         |   4 +-
 .../src/AggregateFunctions/ReservoirSampler.h |   6 +-
 .../src/Common/CombinedCardinalityEstimator.h |   4 +-
 dbms/src/Common/ConcurrentBoundedQueue.h      |   8 +-
 dbms/src/Common/HyperLogLogCounter.h          |  20 +--
 dbms/src/Common/PoolWithFailoverBase.h        |  10 +-
 dbms/src/Common/UInt128.h                     |   2 +-
 dbms/src/Common/ZooKeeper/ZooKeeperHolder.h   |   4 +-
 dbms/src/Common/tests/AvalancheTest.h         |   6 +-
 .../tests/hopscotch-map/src/hopscotch_hash.h  | 156 +++++++++---------
 .../tests/hopscotch-map/src/hopscotch_map.h   |  68 ++++----
 .../hopscotch-map/src/hopscotch_sc_map.h      |  68 ++++----
 .../hopscotch-map/src/hopscotch_sc_set.h      |  40 ++---
 .../tests/hopscotch-map/src/hopscotch_set.h   |  40 ++---
 dbms/src/Core/AccurateComparison.h            |  48 +++---
 dbms/src/Core/QualifiedTableName.h            |   2 +-
 .../AggregatingSortedBlockInputStream.cpp     |   4 +-
 .../AggregatingSortedBlockInputStream.h       |   4 +-
 .../CollapsingSortedBlockInputStream.cpp      |   2 +-
 .../CollapsingSortedBlockInputStream.h        |   2 +-
 dbms/src/DataStreams/ColumnGathererStream.h   |   4 +-
 .../GraphiteRollupSortedBlockInputStream.cpp  |   2 +-
 .../GraphiteRollupSortedBlockInputStream.h    |   2 +-
 .../MergingSortedBlockInputStream.h           |   6 +-
 .../ReplacingSortedBlockInputStream.cpp       |   2 +-
 .../ReplacingSortedBlockInputStream.h         |   2 +-
 .../SummingSortedBlockInputStream.cpp         |   8 +-
 .../SummingSortedBlockInputStream.h           |   8 +-
 dbms/src/DataStreams/UnionBlockInputStream.h  |   4 +-
 .../Dictionaries/DictionaryBlockInputStream.h |  60 +++----
 .../RangeDictionaryBlockInputStream.h         |  30 ++--
 dbms/src/Functions/FunctionsComparison.h      |   2 +-
 dbms/src/Functions/FunctionsConversion.h      |   8 +-
 dbms/src/Functions/FunctionsDateTime.h        |   2 +-
 dbms/src/Functions/FunctionsFindCluster.h     |   6 +-
 dbms/src/Functions/FunctionsHigherOrder.h     |   2 +-
 dbms/src/Functions/FunctionsLogical.h         |   8 +-
 dbms/src/Functions/FunctionsReinterpret.h     |   6 +-
 dbms/src/Functions/FunctionsRound.h           |  86 +++++-----
 dbms/src/Functions/FunctionsVisitParam.h      |   4 +-
 .../tests/logical_functions_performance.cpp   |   6 +-
 dbms/src/IO/HashingWriteBuffer.cpp            |   2 +-
 dbms/src/IO/HashingWriteBuffer.h              |   2 +-
 dbms/src/IO/ReadHelpers.cpp                   |   2 +-
 dbms/src/IO/ReadHelpers.h                     |  10 +-
 dbms/src/Parsers/ParserCreateQuery.h          |   8 +-
 dbms/src/Storages/ColumnDefault.h             |   2 +-
 dbms/src/Storages/MarkCache.h                 |   2 +-
 dbms/src/Storages/StorageDictionary.h         |   2 +-
 51 files changed, 409 insertions(+), 409 deletions(-)

diff --git a/dbms/src/AggregateFunctions/AggregateFunctionGroupArray.cpp b/dbms/src/AggregateFunctions/AggregateFunctionGroupArray.cpp
index 6019cb3bf06..ead604e30ee 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionGroupArray.cpp
+++ b/dbms/src/AggregateFunctions/AggregateFunctionGroupArray.cpp
@@ -8,7 +8,7 @@ namespace DB
 namespace
 {
 
-template <template <typename, typename> class AggregateFunctionTemplate, class Data, typename ... TArgs>
+template <template <typename, typename> class AggregateFunctionTemplate, typename Data, typename ... TArgs>
 static IAggregateFunction * createWithNumericOrTimeType(const IDataType & argument_type, TArgs && ... args)
 {
          if (typeid_cast<const DataTypeDate     *>(&argument_type)) return new AggregateFunctionTemplate<UInt16, Data>(std::forward<TArgs>(args)...);
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionStatistics.h b/dbms/src/AggregateFunctions/AggregateFunctionStatistics.h
index 4ab999dd904..f20fb333497 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionStatistics.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionStatistics.h
@@ -47,7 +47,7 @@ bool areComparable(UInt64 a, UInt64 b)
   * Source: "Updating formulae and a pairwise algorithm for computing sample variances"
   * (Chan et al., Stanford University, 12.1979)
   */
-template<typename T, typename Op>
+template <typename T, typename Op>
 class AggregateFunctionVarianceData
 {
 public:
@@ -109,7 +109,7 @@ private:
 
 /** The main code for the implementation of varSamp, stddevSamp, varPop, stddevPop.
   */
-template<typename T, typename Op>
+template <typename T, typename Op>
 class AggregateFunctionVariance final
     : public IUnaryAggregateFunction<AggregateFunctionVarianceData<T, Op>,
         AggregateFunctionVariance<T, Op>>
@@ -214,7 +214,7 @@ struct AggregateFunctionStdDevPopImpl
 /** If `compute_marginal_moments` flag is set this class provides the successor
   * CovarianceData support of marginal moments for calculating the correlation.
   */
-template<bool compute_marginal_moments>
+template <bool compute_marginal_moments>
 class BaseCovarianceData
 {
 protected:
@@ -224,7 +224,7 @@ protected:
     void deserialize(const ReadBuffer & buf) {}
 };
 
-template<>
+template <>
 class BaseCovarianceData<true>
 {
 protected:
@@ -262,7 +262,7 @@ protected:
   * (J. Bennett et al., Sandia National Laboratories,
   *  2009 IEEE International Conference on Cluster Computing)
   */
-template<typename T, typename U, typename Op, bool compute_marginal_moments>
+template <typename T, typename U, typename Op, bool compute_marginal_moments>
 class CovarianceData : public BaseCovarianceData<compute_marginal_moments>
 {
 private:
@@ -348,13 +348,13 @@ public:
         Base::deserialize(buf);
     }
 
-    template<bool compute = compute_marginal_moments>
+    template <bool compute = compute_marginal_moments>
     void publish(IColumn & to, typename std::enable_if<compute>::type * = nullptr) const
     {
         static_cast<ColumnFloat64 &>(to).getData().push_back(Op::apply(co_moment, Base::left_m2, Base::right_m2, count));
     }
 
-    template<bool compute = compute_marginal_moments>
+    template <bool compute = compute_marginal_moments>
     void publish(IColumn & to, typename std::enable_if<!compute>::type * = nullptr) const
     {
         static_cast<ColumnFloat64 &>(to).getData().push_back(Op::apply(co_moment, count));
@@ -367,7 +367,7 @@ private:
     Float64 co_moment = 0.0;
 };
 
-template<typename T, typename U, typename Op, bool compute_marginal_moments = false>
+template <typename T, typename U, typename Op, bool compute_marginal_moments = false>
 class AggregateFunctionCovariance final
     : public IBinaryAggregateFunction<
         CovarianceData<T, U, Op, compute_marginal_moments>,
@@ -465,25 +465,25 @@ struct AggregateFunctionCorrImpl
     }
 };
 
-template<typename T>
+template <typename T>
 using AggregateFunctionVarSamp = AggregateFunctionVariance<T, AggregateFunctionVarSampImpl>;
 
-template<typename T>
+template <typename T>
 using AggregateFunctionStdDevSamp = AggregateFunctionVariance<T, AggregateFunctionStdDevSampImpl>;
 
-template<typename T>
+template <typename T>
 using AggregateFunctionVarPop = AggregateFunctionVariance<T, AggregateFunctionVarPopImpl>;
 
-template<typename T>
+template <typename T>
 using AggregateFunctionStdDevPop = AggregateFunctionVariance<T, AggregateFunctionStdDevPopImpl>;
 
-template<typename T, typename U>
+template <typename T, typename U>
 using AggregateFunctionCovarSamp = AggregateFunctionCovariance<T, U, AggregateFunctionCovarSampImpl>;
 
-template<typename T, typename U>
+template <typename T, typename U>
 using AggregateFunctionCovarPop = AggregateFunctionCovariance<T, U, AggregateFunctionCovarPopImpl>;
 
-template<typename T, typename U>
+template <typename T, typename U>
 using AggregateFunctionCorr = AggregateFunctionCovariance<T, U, AggregateFunctionCorrImpl, true>;
 
 }
diff --git a/dbms/src/AggregateFunctions/Helpers.h b/dbms/src/AggregateFunctions/Helpers.h
index a07fa630032..6e76cd28916 100644
--- a/dbms/src/AggregateFunctions/Helpers.h
+++ b/dbms/src/AggregateFunctions/Helpers.h
@@ -34,7 +34,7 @@ static IAggregateFunction * createWithNumericType(const IDataType & argument_typ
         return nullptr;
 }
 
-template <template <typename, typename> class AggregateFunctionTemplate, class Data>
+template <template <typename, typename> class AggregateFunctionTemplate, typename Data>
 static IAggregateFunction * createWithNumericType(const IDataType & argument_type)
 {
          if (typeid_cast<const DataTypeUInt8 *>(&argument_type)) return new AggregateFunctionTemplate<UInt8, Data>;
@@ -53,7 +53,7 @@ static IAggregateFunction * createWithNumericType(const IDataType & argument_typ
         return nullptr;
 }
 
-template <template <typename, typename> class AggregateFunctionTemplate, class Data, typename ... TArgs>
+template <template <typename, typename> class AggregateFunctionTemplate, typename Data, typename ... TArgs>
 static IAggregateFunction * createWithNumericType(const IDataType & argument_type, TArgs && ... args)
 {
          if (typeid_cast<const DataTypeUInt8 *>(&argument_type)) return new AggregateFunctionTemplate<UInt8, Data>(std::forward<TArgs>(args)...);
diff --git a/dbms/src/AggregateFunctions/ReservoirSampler.h b/dbms/src/AggregateFunctions/ReservoirSampler.h
index 9dae2900d11..cbb2743dc53 100644
--- a/dbms/src/AggregateFunctions/ReservoirSampler.h
+++ b/dbms/src/AggregateFunctions/ReservoirSampler.h
@@ -30,7 +30,7 @@ namespace ReservoirSamplerOnEmpty
     };
 }
 
-template<typename ResultType, bool IsFloatingPoint>
+template <typename ResultType, bool IsFloatingPoint>
 struct NanLikeValueConstructor
 {
     static ResultType getValue()
@@ -38,7 +38,7 @@ struct NanLikeValueConstructor
         return std::numeric_limits<ResultType>::quiet_NaN();
     }
 };
-template<typename ResultType>
+template <typename ResultType>
 struct NanLikeValueConstructor<ResultType, false>
 {
     static ResultType getValue()
@@ -47,7 +47,7 @@ struct NanLikeValueConstructor<ResultType, false>
     }
 };
 
-template<typename T, ReservoirSamplerOnEmpty::Enum OnEmpty = ReservoirSamplerOnEmpty::THROW, typename Comparer = std::less<T>>
+template <typename T, ReservoirSamplerOnEmpty::Enum OnEmpty = ReservoirSamplerOnEmpty::THROW, typename Comparer = std::less<T>>
 class ReservoirSampler
 {
 public:
diff --git a/dbms/src/Common/CombinedCardinalityEstimator.h b/dbms/src/Common/CombinedCardinalityEstimator.h
index 7390dde607f..31d91cb5195 100644
--- a/dbms/src/Common/CombinedCardinalityEstimator.h
+++ b/dbms/src/Common/CombinedCardinalityEstimator.h
@@ -287,13 +287,13 @@ private:
         }
     }
 
-    template<typename T>
+    template <typename T>
     inline T & getContainer()
     {
         return *reinterpret_cast<T *>(address & mask);
     }
 
-    template<typename T>
+    template <typename T>
     inline const T & getContainer() const
     {
         return *reinterpret_cast<T *>(address & mask);
diff --git a/dbms/src/Common/ConcurrentBoundedQueue.h b/dbms/src/Common/ConcurrentBoundedQueue.h
index d3f67c5d4f1..d650e81bf42 100644
--- a/dbms/src/Common/ConcurrentBoundedQueue.h
+++ b/dbms/src/Common/ConcurrentBoundedQueue.h
@@ -11,10 +11,10 @@
 
 namespace detail
 {
-    template <class T, bool is_nothrow_move_assignable = std::is_nothrow_move_assignable<T>::value>
+    template <typename T, bool is_nothrow_move_assignable = std::is_nothrow_move_assignable<T>::value>
     struct MoveOrCopyIfThrow;
 
-    template <class T>
+    template <typename T>
     struct MoveOrCopyIfThrow<T, true>
     {
         void operator()(T && src, T & dst) const
@@ -23,7 +23,7 @@ namespace detail
         }
     };
 
-    template <class T>
+    template <typename T>
     struct MoveOrCopyIfThrow<T, false>
     {
         void operator()(T && src, T & dst) const
@@ -32,7 +32,7 @@ namespace detail
         }
     };
 
-    template <class T>
+    template <typename T>
     void moveOrCopyIfThrow(T && src, T & dst)
     {
         MoveOrCopyIfThrow<T>()(std::forward<T>(src), dst);
diff --git a/dbms/src/Common/HyperLogLogCounter.h b/dbms/src/Common/HyperLogLogCounter.h
index 37699cf7efb..6477dccf751 100644
--- a/dbms/src/Common/HyperLogLogCounter.h
+++ b/dbms/src/Common/HyperLogLogCounter.h
@@ -36,7 +36,7 @@ namespace details
 {
 
 /// Look-up table of logarithms for integer numbers, used in HyperLogLogCounter.
-template<UInt8 K>
+template <UInt8 K>
 struct LogLUT
 {
     LogLUT()
@@ -60,15 +60,15 @@ private:
     double log_table[M + 1];
 };
 
-template<UInt8 K> struct MinCounterTypeHelper;
-template<> struct MinCounterTypeHelper<0>    { using Type = UInt8; };
-template<> struct MinCounterTypeHelper<1>    { using Type = UInt16; };
-template<> struct MinCounterTypeHelper<2>    { using Type = UInt32; };
-template<> struct MinCounterTypeHelper<3>    { using Type = UInt64; };
+template <UInt8 K> struct MinCounterTypeHelper;
+template <> struct MinCounterTypeHelper<0>    { using Type = UInt8; };
+template <> struct MinCounterTypeHelper<1>    { using Type = UInt16; };
+template <> struct MinCounterTypeHelper<2>    { using Type = UInt32; };
+template <> struct MinCounterTypeHelper<3>    { using Type = UInt64; };
 
 /// Auxiliary structure for automatic determining minimum size of counter's type depending on its maximum value.
 /// Used in HyperLogLogCounter in order to spend memory efficiently.
-template<UInt64 MaxValue> struct MinCounterType
+template <UInt64 MaxValue> struct MinCounterType
 {
     using Type = typename MinCounterTypeHelper<
         (MaxValue >= 1 << 8) +
@@ -78,7 +78,7 @@ template<UInt64 MaxValue> struct MinCounterType
 };
 
 /// Denominator of expression for HyperLogLog algorithm.
-template<UInt8 precision, int max_rank, typename HashValueType, typename DenominatorType,
+template <UInt8 precision, int max_rank, typename HashValueType, typename DenominatorType,
     DenominatorMode denominator_mode, typename Enable = void>
 class __attribute__ ((packed)) Denominator;
 
@@ -118,7 +118,7 @@ struct IntermediateDenominator<HashValueType, DenominatorType, DenominatorMode::
 /// "Lightweight" implementation of expression's denominator for HyperLogLog algorithm.
 /// Uses minimum amount of memory, but estimates may be unstable.
 /// Satisfiable when rank storage is small enough.
-template<UInt8 precision, int max_rank, typename HashValueType, typename DenominatorType,
+template <UInt8 precision, int max_rank, typename HashValueType, typename DenominatorType,
     DenominatorMode denominator_mode>
 class __attribute__ ((packed)) Denominator<precision, max_rank, HashValueType, DenominatorType,
     denominator_mode,
@@ -162,7 +162,7 @@ private:
 /// Fully-functional version of expression's denominator for HyperLogLog algorithm.
 /// Spends more space that lightweight version. Estimates will always be stable.
 /// Used when rank storage is big.
-template<UInt8 precision, int max_rank, typename HashValueType, typename DenominatorType,
+template <UInt8 precision, int max_rank, typename HashValueType, typename DenominatorType,
     DenominatorMode denominator_mode>
 class __attribute__ ((packed)) Denominator<precision, max_rank, HashValueType, DenominatorType,
     denominator_mode,
diff --git a/dbms/src/Common/PoolWithFailoverBase.h b/dbms/src/Common/PoolWithFailoverBase.h
index 6d436051685..63420f12ac1 100644
--- a/dbms/src/Common/PoolWithFailoverBase.h
+++ b/dbms/src/Common/PoolWithFailoverBase.h
@@ -137,7 +137,7 @@ protected:
     Logger * log;
 };
 
-template<typename TNestedPool>
+template <typename TNestedPool>
 typename TNestedPool::Entry
 PoolWithFailoverBase<TNestedPool>::get(const TryGetEntryFunc & try_get_entry, const GetPriorityFunc & get_priority)
 {
@@ -149,7 +149,7 @@ PoolWithFailoverBase<TNestedPool>::get(const TryGetEntryFunc & try_get_entry, co
     return results[0].entry;
 }
 
-template<typename TNestedPool>
+template <typename TNestedPool>
 std::vector<typename PoolWithFailoverBase<TNestedPool>::TryResult>
 PoolWithFailoverBase<TNestedPool>::getMany(
         size_t min_entries, size_t max_entries,
@@ -293,7 +293,7 @@ PoolWithFailoverBase<TNestedPool>::getMany(
     return try_results;
 }
 
-template<typename TNestedPool>
+template <typename TNestedPool>
 void PoolWithFailoverBase<TNestedPool>::reportError(const Entry & entry)
 {
     for (size_t i = 0; i < nested_pools.size(); ++i)
@@ -308,7 +308,7 @@ void PoolWithFailoverBase<TNestedPool>::reportError(const Entry & entry)
     throw DB::Exception("Can't find pool to report error.");
 }
 
-template<typename TNestedPool>
+template <typename TNestedPool>
 struct PoolWithFailoverBase<TNestedPool>::PoolState
 {
     UInt64 error_count = 0;
@@ -330,7 +330,7 @@ private:
     std::minstd_rand rng = std::minstd_rand(randomSeed());
 };
 
-template<typename TNestedPool>
+template <typename TNestedPool>
 typename PoolWithFailoverBase<TNestedPool>::PoolStates
 PoolWithFailoverBase<TNestedPool>::updatePoolStates()
 {
diff --git a/dbms/src/Common/UInt128.h b/dbms/src/Common/UInt128.h
index cf264f1ea8d..7be3dc85987 100644
--- a/dbms/src/Common/UInt128.h
+++ b/dbms/src/Common/UInt128.h
@@ -50,7 +50,7 @@ struct UInt128
     template <typename T> bool inline operator<= (const T rhs) const { return *this <= UInt128(rhs); }
     template <typename T> bool inline operator<  (const T rhs) const { return *this <  UInt128(rhs); }
 
-    template<typename T> explicit operator T() const { return static_cast<T>(low); }
+    template <typename T> explicit operator T() const { return static_cast<T>(low); }
 
 #if !__clang__
 #pragma GCC diagnostic pop
diff --git a/dbms/src/Common/ZooKeeper/ZooKeeperHolder.h b/dbms/src/Common/ZooKeeper/ZooKeeperHolder.h
index 831cd442003..7f8455f61d4 100644
--- a/dbms/src/Common/ZooKeeper/ZooKeeperHolder.h
+++ b/dbms/src/Common/ZooKeeper/ZooKeeperHolder.h
@@ -19,7 +19,7 @@ public:
     ZooKeeperHolder() = default;
 
     /// вызывать из одного потока - не thread safe
-    template <class... Args>
+    template <typename... Args>
     void init(Args&&... args);
     /// был ли класс инициализирован
     bool isInitialized() const { return ptr != nullptr; }
@@ -75,7 +75,7 @@ private:
     static std::string nullptr_exception_message;
 };
 
-template <class... Args>
+template <typename... Args>
 void ZooKeeperHolder::init(Args&&... args)
 {
     ptr = std::make_shared<ZooKeeper>(std::forward<Args>(args)...);
diff --git a/dbms/src/Common/tests/AvalancheTest.h b/dbms/src/Common/tests/AvalancheTest.h
index 8d3f2352f0d..0c0c09fc30e 100644
--- a/dbms/src/Common/tests/AvalancheTest.h
+++ b/dbms/src/Common/tests/AvalancheTest.h
@@ -38,7 +38,7 @@ inline uint32_t getbit ( const void * block, int len, uint32_t bit )
   return 0;
 }
 
-template< typename T >
+template < typename T >
 inline uint32_t getbit ( T & blob, uint32_t bit )
 {
   return getbit(&blob,sizeof(blob),bit);
@@ -54,7 +54,7 @@ inline void flipbit ( void * block, int len, uint32_t bit )
   if(byte < len) b[byte] ^= (1 << bit);
 }
 
-template< typename T >
+template < typename T >
 inline void flipbit ( T & blob, uint32_t bit )
 {
   flipbit(&blob,sizeof(blob),bit);
@@ -146,7 +146,7 @@ bool AvalancheTest ( pfHash hash, const int reps )
 // BIC test variant - store all intermediate data in a table, draw diagram
 // afterwards (much faster)
 
-template< typename keytype, typename hashtype >
+template < typename keytype, typename hashtype >
 void BicTest3 ( pfHash hash, const int reps, bool verbose = true )
 {
   const int keybytes = sizeof(keytype);
diff --git a/dbms/src/Common/tests/hopscotch-map/src/hopscotch_hash.h b/dbms/src/Common/tests/hopscotch-map/src/hopscotch_hash.h
index 2840c8880b5..24a8166b6ad 100644
--- a/dbms/src/Common/tests/hopscotch-map/src/hopscotch_hash.h
+++ b/dbms/src/Common/tests/hopscotch-map/src/hopscotch_hash.h
@@ -146,7 +146,7 @@ private:
  * Grow the map by GrowthFactor::num/GrowthFactor::den and use a modulo to map a hash
  * to a bucket. Slower but it can be usefull if you want a slower growth.
  */
-template<class GrowthFactor = std::ratio<3, 2>>
+template <typename GrowthFactor = std::ratio<3, 2>>
 class mod_growth_policy {
 public:
     mod_growth_policy(std::size_t& min_bucket_count_in_out) {
@@ -212,7 +212,7 @@ static constexpr const std::array<std::size_t, 39> PRIMES = {{
     1610612741ul, 3221225473ul, 4294967291ul
 }};
 
-template<unsigned int IPrime>
+template <unsigned int IPrime>
 static std::size_t mod(std::size_t hash) { return hash % PRIMES[IPrime]; }
 
 // MOD_PRIME[iprime](hash) returns hash % PRIMES[iprime]. This table allows for faster modulo as the
@@ -274,26 +274,26 @@ namespace detail_hopscotch_hash {
     
     
     
-template<typename T>
+template <typename T>
 struct make_void {
     using type = void;
 };
 
 
-template<typename T, typename = void>
+template <typename T, typename = void>
 struct has_is_transparent : std::false_type {
 };
 
-template<typename T>
+template <typename T>
 struct has_is_transparent<T, typename make_void<typename T::is_transparent>::type> : std::true_type {
 };
 
 
-template<typename T, typename = void>
+template <typename T, typename = void>
 struct has_key_compare : std::false_type {
 };
 
-template<typename T>
+template <typename T>
 struct has_key_compare<T, typename make_void<typename T::key_compare>::type> : std::true_type {
 };
 
@@ -305,29 +305,29 @@ struct has_key_compare<T, typename make_void<typename T::key_compare>::type> : s
  * smallest_type_for_min_bits::type returns the smallest type that can fit MinBits.
  */
 static const size_t SMALLEST_TYPE_MAX_BITS_SUPPORTED = 64;
-template<unsigned int MinBits, typename Enable = void>
+template <unsigned int MinBits, typename Enable = void>
 class smallest_type_for_min_bits {
 };
 
-template<unsigned int MinBits>
+template <unsigned int MinBits>
 class smallest_type_for_min_bits<MinBits, typename std::enable_if<(MinBits > 0) && (MinBits <= 8)>::type> {
 public:
     using type = std::uint_least8_t;
 };
 
-template<unsigned int MinBits>
+template <unsigned int MinBits>
 class smallest_type_for_min_bits<MinBits, typename std::enable_if<(MinBits > 8) && (MinBits <= 16)>::type> {
 public:
     using type = std::uint_least16_t;
 };
 
-template<unsigned int MinBits>
+template <unsigned int MinBits>
 class smallest_type_for_min_bits<MinBits, typename std::enable_if<(MinBits > 16) && (MinBits <= 32)>::type> {
 public:
     using type = std::uint_least32_t;
 };
 
-template<unsigned int MinBits>
+template <unsigned int MinBits>
 class smallest_type_for_min_bits<MinBits, typename std::enable_if<(MinBits > 32) && (MinBits <= 64)>::type> {
 public:
     using type = std::uint_least64_t;
@@ -353,7 +353,7 @@ public:
 static const std::size_t NB_RESERVED_BITS_IN_NEIGHBORHOOD = 2; 
 
 
-template<bool StoreHash>
+template <bool StoreHash>
 class hopscotch_bucket_hash {
 public:    
     using hash_type = std::false_type;
@@ -375,7 +375,7 @@ protected:
     }
 };
 
-template<>
+template <>
 class hopscotch_bucket_hash<true> {
 public:
     using hash_type = std::uint_least32_t;
@@ -402,7 +402,7 @@ private:
     hash_type m_hash;
 };
 
-template<typename ValueType, unsigned int NeighborhoodSize, bool StoreHash>
+template <typename ValueType, unsigned int NeighborhoodSize, bool StoreHash>
 class hopscotch_bucket: public hopscotch_bucket_hash<StoreHash> {
 private:
     static const size_t MIN_NEIGHBORHOOD_SIZE = 4;
@@ -529,7 +529,7 @@ public:
         return *reinterpret_cast<const value_type*>(std::addressof(m_value));
     }
     
-    template<typename... Args>
+    template <typename... Args>
     void set_value_of_empty_bucket(std::size_t hash, Args&&... value_type_args) {
         tsl_assert(empty());
         
@@ -617,7 +617,7 @@ private:
  * OverflowContainer will be used as containers for overflown elements. Usually it should be a list<ValueType>
  * or a set<Key>/map<Key, T>.
  */
-template<class ValueType,
+template <typename ValueType,
          class KeySelect,
          class ValueSelect,
          class Hash,
@@ -629,11 +629,11 @@ template<class ValueType,
          class OverflowContainer>
 class hopscotch_hash: private Hash, private KeyEqual, private GrowthPolicy {
 private:
-    template<typename U>
+    template <typename U>
     using has_mapped_type = typename std::integral_constant<bool, !std::is_same<U, void>::value>;
     
 public:
-    template<bool is_const>
+    template <bool is_const>
     class hopscotch_iterator;
     
     using key_type = typename KeySelect::key_type;
@@ -680,7 +680,7 @@ public:
      * In case of a map, to get a modifiable reference to the value associated to a key (the '.second' in the 
      * stored pair), you have to call 'value()'.
      */
-    template<bool is_const>
+    template <bool is_const>
     class hopscotch_iterator {
         friend class hopscotch_hash;
     private:
@@ -724,7 +724,7 @@ public:
             return KeySelect()(*m_overflow_iterator);
         }
 
-        template<class U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+        template <typename U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
         typename std::conditional<
                         is_const, 
                         const typename U::value_type&, 
@@ -791,7 +791,7 @@ public:
 
     
 public:
-    template<class OC = OverflowContainer, typename std::enable_if<!has_key_compare<OC>::value>::type* = nullptr>
+    template <typename OC = OverflowContainer, typename std::enable_if<!has_key_compare<OC>::value>::type* = nullptr>
     hopscotch_hash(size_type bucket_count, 
                   const Hash& hash,
                   const KeyEqual& equal,
@@ -814,7 +814,7 @@ public:
         this->max_load_factor(max_load_factor);
     }
     
-    template<class OC = OverflowContainer, typename std::enable_if<has_key_compare<OC>::value>::type* = nullptr>
+    template <typename OC = OverflowContainer, typename std::enable_if<has_key_compare<OC>::value>::type* = nullptr>
     hopscotch_hash(size_type bucket_count, 
                   const Hash& hash,
                   const KeyEqual& equal,
@@ -949,7 +949,7 @@ public:
         return insert_impl(value); 
     }
         
-    template<class P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr>
+    template <typename P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr>
     std::pair<iterator, bool> insert(P&& value) { 
         return emplace(std::forward<P>(value)); 
     }
@@ -967,7 +967,7 @@ public:
         return insert(value).first; 
     }
         
-    template<class P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr>
+    template <typename P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr>
     iterator insert(const_iterator hint, P&& value) {
         return emplace_hint(hint, std::forward<P>(value)); 
     }
@@ -981,7 +981,7 @@ public:
     }
     
     
-    template<class InputIt>
+    template <typename InputIt>
     void insert(InputIt first, InputIt last) {
         if(std::is_base_of<std::forward_iterator_tag, 
                            typename std::iterator_traits<InputIt>::iterator_category>::value) 
@@ -1003,18 +1003,18 @@ public:
     }
     
     
-    template<class M>
+    template <typename M>
     std::pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj) { 
         return insert_or_assign_impl(k, std::forward<M>(obj)); 
     }
 
-    template<class M>
+    template <typename M>
     std::pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj) { 
         return insert_or_assign_impl(std::move(k), std::forward<M>(obj)); 
     }
     
     
-    template<class M>
+    template <typename M>
     iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj) {
         if(hint != cend() && compare_keys(KeySelect()(*hint), k)) { 
             auto it = mutable_iterator(hint); 
@@ -1026,7 +1026,7 @@ public:
         return insert_or_assign(k, std::forward<M>(obj)).first;
     }
     
-    template<class M>
+    template <typename M>
     iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj) {
         if(hint != cend() && compare_keys(KeySelect()(*hint), k)) {
             auto it = mutable_iterator(hint); 
@@ -1039,27 +1039,27 @@ public:
     }
     
     
-    template<class... Args>
+    template <typename... Args>
     std::pair<iterator, bool> emplace(Args&&... args) {
         return insert(value_type(std::forward<Args>(args)...));
     }
     
-    template<class... Args>
+    template <typename... Args>
     iterator emplace_hint(const_iterator hint, Args&&... args) {
         return insert(hint, value_type(std::forward<Args>(args)...));        
     }
     
-    template<class... Args>
+    template <typename... Args>
     std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args) { 
         return try_emplace_impl(k, std::forward<Args>(args)...);
     }
     
-    template<class... Args>
+    template <typename... Args>
     std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args) {
         return try_emplace_impl(std::move(k), std::forward<Args>(args)...);
     }
     
-    template<class... Args>
+    template <typename... Args>
     iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args) { 
         if(hint != cend() && compare_keys(KeySelect()(*hint), k)) { 
             return mutable_iterator(hint); 
@@ -1068,7 +1068,7 @@ public:
         return try_emplace(k, std::forward<Args>(args)...).first;
     }
     
-    template<class... Args>
+    template <typename... Args>
     iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args) {
         if(hint != cend() && compare_keys(KeySelect()(*hint), k)) { 
             return mutable_iterator(hint); 
@@ -1111,12 +1111,12 @@ public:
         return to_delete;
     }
     
-    template<class K>
+    template <typename K>
     size_type erase(const K& key) {
         return erase(key, hash_key(key));
     }
     
-    template<class K>
+    template <typename K>
     size_type erase(const K& key, std::size_t hash) {
         const std::size_t ibucket_for_hash = bucket_for_hash(hash);
         
@@ -1157,23 +1157,23 @@ public:
     /*
      * Lookup
      */
-    template<class K, class U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+    template <typename K, typename U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
     typename U::value_type& at(const K& key) {
         return at(key, hash_key(key));
     }
     
-    template<class K, class U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+    template <typename K, typename U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
     typename U::value_type& at(const K& key, std::size_t hash) {
         return const_cast<typename U::value_type&>(static_cast<const hopscotch_hash*>(this)->at(key, hash));
     }
     
     
-    template<class K, class U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+    template <typename K, typename U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
     const typename U::value_type& at(const K& key) const {
         return at(key, hash_key(key));
     }
     
-    template<class K, class U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+    template <typename K, typename U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
     const typename U::value_type& at(const K& key, std::size_t hash) const {
         using T = typename U::value_type;
         
@@ -1187,7 +1187,7 @@ public:
     }
     
     
-    template<class K, class U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+    template <typename K, typename U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
     typename U::value_type& operator[](K&& key) {
         using T = typename U::value_type;
         
@@ -1206,57 +1206,57 @@ public:
     }
     
     
-    template<class K>
+    template <typename K>
     size_type count(const K& key) const {
         return count(key, hash_key(key));
     }
     
-    template<class K>
+    template <typename K>
     size_type count(const K& key, std::size_t hash) const {
         return count_impl(key, hash, m_buckets.cbegin() + bucket_for_hash(hash));
     }
     
     
-    template<class K>
+    template <typename K>
     iterator find(const K& key) {
         return find(key, hash_key(key));
     }
     
-    template<class K>
+    template <typename K>
     iterator find(const K& key, std::size_t hash) {
         return find_impl(key, hash, m_buckets.begin() + bucket_for_hash(hash));
     }
     
     
-    template<class K>
+    template <typename K>
     const_iterator find(const K& key) const {
         return find(key, hash_key(key));
     }
     
-    template<class K>
+    template <typename K>
     const_iterator find(const K& key, std::size_t hash) const {
         return find_impl(key, hash, m_buckets.begin() + bucket_for_hash(hash));
     }
     
     
-    template<class K>
+    template <typename K>
     std::pair<iterator, iterator> equal_range(const K& key) {
         return equal_range(key, hash_key(key));
     }
     
-    template<class K>
+    template <typename K>
     std::pair<iterator, iterator> equal_range(const K& key, std::size_t hash) {
         iterator it = find(key, hash);
         return std::make_pair(it, (it == end())?it:std::next(it));
     }
     
     
-    template<class K>
+    template <typename K>
     std::pair<const_iterator, const_iterator> equal_range(const K& key) const {
         return equal_range(key, hash_key(key));
     }
     
-    template<class K>
+    template <typename K>
     std::pair<const_iterator, const_iterator> equal_range(const K& key, std::size_t hash) const {
         const_iterator it = find(key, hash);
         return std::make_pair(it, (it == cend())?it:std::next(it));
@@ -1339,19 +1339,19 @@ public:
         return m_overflow_elements.size();
     }
     
-    template<class U = OverflowContainer, typename std::enable_if<has_key_compare<U>::value>::type* = nullptr>
+    template <typename U = OverflowContainer, typename std::enable_if<has_key_compare<U>::value>::type* = nullptr>
     typename U::key_compare key_comp() const {
         return m_overflow_elements.key_comp();
     }
     
     
 private:
-    template<class K>
+    template <typename K>
     std::size_t hash_key(const K& key) const {
         return Hash::operator()(key);
     }
     
-    template<class K1, class K2>
+    template <typename K1, typename K2>
     bool compare_keys(const K1& key1, const K2& key2) const {
         return KeyEqual::operator()(key1, key2);
     }
@@ -1365,7 +1365,7 @@ private:
                   std::is_copy_constructible<value_type>::value, 
                   "value_type must be either copy constructible or nothrow move constructible.");
     
-    template<typename U = value_type, 
+    template <typename U = value_type, 
              typename std::enable_if<std::is_nothrow_move_constructible<U>::value>::type* = nullptr>
     void rehash_impl(size_type count) {
         hopscotch_hash new_map = new_hopscotch_hash(count);
@@ -1425,7 +1425,7 @@ private:
         new_map.swap(*this);
     }
     
-    template<typename U = value_type, 
+    template <typename U = value_type, 
              typename std::enable_if<std::is_copy_constructible<U>::value && 
                                      !std::is_nothrow_move_constructible<U>::value>::type* = nullptr>
     void rehash_impl(size_type count) {
@@ -1499,7 +1499,7 @@ private:
     
 
     
-    template<class K, class M>
+    template <typename K, typename M>
     std::pair<iterator, bool> insert_or_assign_impl(K&& key, M&& obj) {
         auto it = try_emplace_impl(std::forward<K>(key), std::forward<M>(obj));
         if(!it.second) {
@@ -1509,7 +1509,7 @@ private:
         return it;
     }
     
-    template<typename P, class... Args>
+    template <typename P, typename... Args>
     std::pair<iterator, bool> try_emplace_impl(P&& key, Args&&... args_value) {
         const std::size_t hash = hash_key(key);
         const std::size_t ibucket_for_hash = bucket_for_hash(hash);
@@ -1525,7 +1525,7 @@ private:
                                                    std::forward_as_tuple(std::forward<Args>(args_value)...));
     }
     
-    template<typename P>
+    template <typename P>
     std::pair<iterator, bool> insert_impl(P&& value) {
         const std::size_t hash = hash_key(KeySelect()(value));
         const std::size_t ibucket_for_hash = bucket_for_hash(hash);
@@ -1540,7 +1540,7 @@ private:
         return insert_impl(ibucket_for_hash, hash, std::forward<P>(value));
     }
     
-    template<typename... Args>
+    template <typename... Args>
     std::pair<iterator, bool> insert_impl(std::size_t ibucket_for_hash, std::size_t hash, Args&&... value_type_args) {
         if((m_nb_elements - m_overflow_elements.size()) >= m_load_threshold) {
             rehash(GrowthPolicy::next_bucket_count());
@@ -1624,7 +1624,7 @@ private:
      * 
      * Return bucket iterator to ibucket_empty
      */
-    template<typename... Args>
+    template <typename... Args>
     iterator_buckets insert_in_bucket(std::size_t ibucket_empty, std::size_t ibucket_for_hash,
                                       std::size_t hash, Args&&... value_type_args) 
     {
@@ -1682,7 +1682,7 @@ private:
     
     
     
-    template<class K, class U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+    template <typename K, typename U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
     typename U::value_type* find_value_impl(const K& key, std::size_t hash, iterator_buckets it_bucket) {
         return const_cast<typename U::value_type*>(
                     static_cast<const hopscotch_hash*>(this)->find_value_impl(key, hash, it_bucket));
@@ -1693,7 +1693,7 @@ private:
      *
      * Return null if no value for key (TODO use std::optional when available).
      */
-    template<class K, class U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
+    template <typename K, typename U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
     const typename U::value_type* find_value_impl(const K& key, std::size_t hash, 
                                                   const_iterator_buckets it_bucket) const 
     {
@@ -1712,7 +1712,7 @@ private:
         return nullptr;
     }
     
-    template<class K>
+    template <typename K>
     size_type count_impl(const K& key, std::size_t hash, const_iterator_buckets it_bucket) const {
         if(find_in_buckets(key, hash, it_bucket) != m_buckets.cend()) {
             return 1;
@@ -1725,7 +1725,7 @@ private:
         }
     }
     
-    template<class K>
+    template <typename K>
     iterator find_impl(const K& key, std::size_t hash, iterator_buckets it_bucket) {
         auto it = find_in_buckets(key, hash, it_bucket);
         if(it != m_buckets.end()) {
@@ -1739,7 +1739,7 @@ private:
         return iterator(m_buckets.end(), m_buckets.end(), find_in_overflow(key));
     }
     
-    template<class K>
+    template <typename K>
     const_iterator find_impl(const K& key, std::size_t hash, const_iterator_buckets it_bucket) const {
         auto it = find_in_buckets(key, hash, it_bucket);
         if(it != m_buckets.cend()) {
@@ -1754,14 +1754,14 @@ private:
         return const_iterator(m_buckets.cend(), m_buckets.cend(), find_in_overflow(key));
     }
     
-    template<class K>
+    template <typename K>
     iterator_buckets find_in_buckets(const K& key, std::size_t hash, iterator_buckets it_bucket) {   
         auto it_find = static_cast<const hopscotch_hash*>(this)->find_in_buckets(key, hash, it_bucket); 
         return m_buckets.begin() + std::distance(m_buckets.cbegin(), it_find);
     }
 
     
-    template<class K>
+    template <typename K>
     const_iterator_buckets find_in_buckets(const K& key, std::size_t hash, const_iterator_buckets it_bucket) const {      
         (void) hash; // Avoid warning of unused variable when StoreHash is false;
 
@@ -1791,7 +1791,7 @@ private:
     
 
     
-    template<class K, class U = OverflowContainer, typename std::enable_if<!has_key_compare<U>::value>::type* = nullptr>
+    template <typename K, typename U = OverflowContainer, typename std::enable_if<!has_key_compare<U>::value>::type* = nullptr>
     iterator_overflow find_in_overflow(const K& key) {
         return std::find_if(m_overflow_elements.begin(), m_overflow_elements.end(), 
                             [&](const value_type& value) { 
@@ -1799,7 +1799,7 @@ private:
                             });
     }
     
-    template<class K, class U = OverflowContainer, typename std::enable_if<!has_key_compare<U>::value>::type* = nullptr>
+    template <typename K, typename U = OverflowContainer, typename std::enable_if<!has_key_compare<U>::value>::type* = nullptr>
     const_iterator_overflow find_in_overflow(const K& key) const {
         return std::find_if(m_overflow_elements.cbegin(), m_overflow_elements.cend(), 
                             [&](const value_type& value) { 
@@ -1807,37 +1807,37 @@ private:
                             });
     }
     
-    template<class K, class U = OverflowContainer, typename std::enable_if<has_key_compare<U>::value>::type* = nullptr>
+    template <typename K, typename U = OverflowContainer, typename std::enable_if<has_key_compare<U>::value>::type* = nullptr>
     iterator_overflow find_in_overflow(const K& key) {
         return m_overflow_elements.find(key);
     }
     
-    template<class K, class U = OverflowContainer, typename std::enable_if<has_key_compare<U>::value>::type* = nullptr>
+    template <typename K, typename U = OverflowContainer, typename std::enable_if<has_key_compare<U>::value>::type* = nullptr>
     const_iterator_overflow find_in_overflow(const K& key) const {
         return m_overflow_elements.find(key);
     }
     
     
     
-    template<class... Args, class U = OverflowContainer, typename std::enable_if<!has_key_compare<U>::value>::type* = nullptr>
+    template <typename... Args, typename U = OverflowContainer, typename std::enable_if<!has_key_compare<U>::value>::type* = nullptr>
     iterator_overflow insert_in_overflow(Args&&... value_type_args) {
         return m_overflow_elements.emplace(m_overflow_elements.end(), std::forward<Args>(value_type_args)...);
     }
     
-    template<class... Args, class U = OverflowContainer, typename std::enable_if<has_key_compare<U>::value>::type* = nullptr>
+    template <typename... Args, typename U = OverflowContainer, typename std::enable_if<has_key_compare<U>::value>::type* = nullptr>
     iterator_overflow insert_in_overflow(Args&&... value_type_args) {
         return m_overflow_elements.emplace(std::forward<Args>(value_type_args)...).first;
     }
     
     
     
-    template<class U = OverflowContainer, typename std::enable_if<!has_key_compare<U>::value>::type* = nullptr>
+    template <typename U = OverflowContainer, typename std::enable_if<!has_key_compare<U>::value>::type* = nullptr>
     hopscotch_hash new_hopscotch_hash(size_type bucket_count) {
         return hopscotch_hash(bucket_count, static_cast<Hash&>(*this), static_cast<KeyEqual&>(*this), 
                               get_allocator(), m_max_load_factor);
     }
     
-    template<class U = OverflowContainer, typename std::enable_if<has_key_compare<U>::value>::type* = nullptr>
+    template <typename U = OverflowContainer, typename std::enable_if<has_key_compare<U>::value>::type* = nullptr>
     hopscotch_hash new_hopscotch_hash(size_type bucket_count) {
         return hopscotch_hash(bucket_count, static_cast<Hash&>(*this), static_cast<KeyEqual&>(*this), 
                               get_allocator(), m_max_load_factor, m_overflow_elements.key_comp());
diff --git a/dbms/src/Common/tests/hopscotch-map/src/hopscotch_map.h b/dbms/src/Common/tests/hopscotch-map/src/hopscotch_map.h
index e7b9c2c3d3f..f6eb29ae116 100644
--- a/dbms/src/Common/tests/hopscotch-map/src/hopscotch_map.h
+++ b/dbms/src/Common/tests/hopscotch-map/src/hopscotch_map.h
@@ -68,7 +68,7 @@ namespace tsl {
  *    insert will invalidate the iterators). Or if there is a rehash.
  *  - erase: iterator on the erased element is the only one which become invalid.
  */
-template<class Key, 
+template <typename Key, 
          class T, 
          class Hash = std::hash<Key>,
          class KeyEqual = std::equal_to<Key>,
@@ -78,7 +78,7 @@ template<class Key,
          class GrowthPolicy = tsl::power_of_two_growth_policy>
 class hopscotch_map {
 private:    
-    template<typename U>
+    template <typename U>
     using has_is_transparent = tsl::detail_hopscotch_hash::has_is_transparent<U>;
     
     class KeySelect {
@@ -161,7 +161,7 @@ public:
     explicit hopscotch_map(const Allocator& alloc) : hopscotch_map(ht::DEFAULT_INIT_BUCKETS_SIZE, alloc) {
     }
     
-    template<class InputIt>
+    template <typename InputIt>
     hopscotch_map(InputIt first, InputIt last,
                 size_type bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE,
                 const Hash& hash = Hash(),
@@ -171,14 +171,14 @@ public:
         insert(first, last);
     }
     
-    template<class InputIt>
+    template <typename InputIt>
     hopscotch_map(InputIt first, InputIt last,
                 size_type bucket_count,
                 const Allocator& alloc) : hopscotch_map(first, last, bucket_count, Hash(), KeyEqual(), alloc)
     {
     }
     
-    template<class InputIt>
+    template <typename InputIt>
     hopscotch_map(InputIt first, InputIt last,
                 size_type bucket_count,
                 const Hash& hash,
@@ -254,7 +254,7 @@ public:
         return m_ht.insert(value); 
     }
         
-    template<class P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr>
+    template <typename P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr>
     std::pair<iterator, bool> insert(P&& value) { 
         return m_ht.insert(std::forward<P>(value)); 
     }
@@ -268,7 +268,7 @@ public:
         return m_ht.insert(hint, value); 
     }
         
-    template<class P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr>
+    template <typename P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr>
     iterator insert(const_iterator hint, P&& value) { 
         return m_ht.insert(hint, std::forward<P>(value));
     }
@@ -278,7 +278,7 @@ public:
     }
     
     
-    template<class InputIt>
+    template <typename InputIt>
     void insert(InputIt first, InputIt last) { 
         m_ht.insert(first, last); 
     }
@@ -290,22 +290,22 @@ public:
     
     
     
-    template<class M>
+    template <typename M>
     std::pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj) { 
         return m_ht.insert_or_assign(k, std::forward<M>(obj)); 
     }
 
-    template<class M>
+    template <typename M>
     std::pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj) { 
         return m_ht.insert_or_assign(std::move(k), std::forward<M>(obj)); 
     }
     
-    template<class M>
+    template <typename M>
     iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj) {
         return m_ht.insert_or_assign(hint, k, std::forward<M>(obj));
     }
     
-    template<class M>
+    template <typename M>
     iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj) {
         return m_ht.insert_or_assign(hint, std::move(k), std::forward<M>(obj));
     }
@@ -319,7 +319,7 @@ public:
      * 
      * Mainly here for compatibility with the std::unordered_map interface.
      */
-    template<class... Args>
+    template <typename... Args>
     std::pair<iterator, bool> emplace(Args&&... args) { 
         return m_ht.emplace(std::forward<Args>(args)...); 
     }
@@ -333,7 +333,7 @@ public:
      * 
      * Mainly here for compatibility with the std::unordered_map interface.
      */
-    template<class... Args>
+    template <typename... Args>
     iterator emplace_hint(const_iterator hint, Args&&... args) {
         return m_ht.emplace_hint(hint, std::forward<Args>(args)...);
     }
@@ -341,22 +341,22 @@ public:
     
     
     
-    template<class... Args>
+    template <typename... Args>
     std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args) { 
         return m_ht.try_emplace(k, std::forward<Args>(args)...);
     }
     
-    template<class... Args>
+    template <typename... Args>
     std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args) {
         return m_ht.try_emplace(std::move(k), std::forward<Args>(args)...);
     }
     
-    template<class... Args>
+    template <typename... Args>
     iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args) {
         return m_ht.try_emplace(hint, k, std::forward<Args>(args)...);
     }
     
-    template<class... Args>
+    template <typename... Args>
     iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args) {
         return m_ht.try_emplace(hint, std::move(k), std::forward<Args>(args)...);
     }
@@ -381,7 +381,7 @@ public:
      * This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. 
      * If so, K must be hashable and comparable to Key.
      */
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     size_type erase(const K& key) { return m_ht.erase(key); }
     
     /**
@@ -390,7 +390,7 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup to the value if you already have the hash.
      */    
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     size_type erase(const K& key, std::size_t precalculated_hash) { 
         return m_ht.erase(key, precalculated_hash); 
     }
@@ -424,7 +424,7 @@ public:
      * This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. 
      * If so, K must be hashable and comparable to Key.
      */
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     T& at(const K& key) { return m_ht.at(key); }
 
     /**
@@ -433,20 +433,20 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
      */    
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     T& at(const K& key, std::size_t precalculated_hash) { return m_ht.at(key, precalculated_hash); }
     
     
     /**
      * @copydoc at(const K& key)
      */
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     const T& at(const K& key) const { return m_ht.at(key); }
     
     /**
      * @copydoc at(const K& key, std::size_t precalculated_hash)
      */    
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     const T& at(const K& key, std::size_t precalculated_hash) const { return m_ht.at(key, precalculated_hash); }
     
     
@@ -472,7 +472,7 @@ public:
      * This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. 
      * If so, K must be hashable and comparable to Key.
      */
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     size_type count(const K& key) const { return m_ht.count(key); }
     
     /**
@@ -481,7 +481,7 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
      */     
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     size_type count(const K& key, std::size_t precalculated_hash) const { return m_ht.count(key, precalculated_hash); }
     
     
@@ -508,7 +508,7 @@ public:
      * This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. 
      * If so, K must be hashable and comparable to Key.
      */
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     iterator find(const K& key) { return m_ht.find(key); }
     
     /**
@@ -517,13 +517,13 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
      */
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     iterator find(const K& key, std::size_t precalculated_hash) { return m_ht.find(key, precalculated_hash); }
     
     /**
      * @copydoc find(const K& key)
      */
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     const_iterator find(const K& key) const { return m_ht.find(key); }
     
     /**
@@ -532,7 +532,7 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
      */
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     const_iterator find(const K& key, std::size_t precalculated_hash) const { 
         return m_ht.find(key, precalculated_hash); 
     }
@@ -563,7 +563,7 @@ public:
      * This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. 
      * If so, K must be hashable and comparable to Key.
      */
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     std::pair<iterator, iterator> equal_range(const K& key) { return m_ht.equal_range(key); }
     
     
@@ -573,7 +573,7 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
      */
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     std::pair<iterator, iterator> equal_range(const K& key, std::size_t precalculated_hash) { 
         return m_ht.equal_range(key, precalculated_hash); 
     }
@@ -581,13 +581,13 @@ public:
     /**
      * @copydoc equal_range(const K& key)
      */
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     std::pair<const_iterator, const_iterator> equal_range(const K& key) const { return m_ht.equal_range(key); }
     
     /**
      * @copydoc equal_range(const K& key, std::size_t precalculated_hash)
      */    
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     std::pair<const_iterator, const_iterator> equal_range(const K& key, std::size_t precalculated_hash) const { 
         return m_ht.equal_range(key, precalculated_hash); 
     }
diff --git a/dbms/src/Common/tests/hopscotch-map/src/hopscotch_sc_map.h b/dbms/src/Common/tests/hopscotch-map/src/hopscotch_sc_map.h
index 6af85f3867c..7e77427553d 100644
--- a/dbms/src/Common/tests/hopscotch-map/src/hopscotch_sc_map.h
+++ b/dbms/src/Common/tests/hopscotch-map/src/hopscotch_sc_map.h
@@ -53,7 +53,7 @@ namespace tsl {
  * 
  * @copydoc hopscotch_map
  */
-template<class Key, 
+template <typename Key, 
          class T, 
          class Hash = std::hash<Key>,
          class KeyEqual = std::equal_to<Key>,
@@ -64,7 +64,7 @@ template<class Key,
          class GrowthPolicy = tsl::power_of_two_growth_policy>
 class hopscotch_sc_map {
 private:
-    template<typename U>
+    template <typename U>
     using has_is_transparent = tsl::detail_hopscotch_hash::has_is_transparent<U>;
     
     class KeySelect {
@@ -150,7 +150,7 @@ public:
     explicit hopscotch_sc_map(const Allocator& alloc) : hopscotch_sc_map(ht::DEFAULT_INIT_BUCKETS_SIZE, alloc) {
     }
     
-    template<class InputIt>
+    template <typename InputIt>
     hopscotch_sc_map(InputIt first, InputIt last,
                 size_type bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE,
                 const Hash& hash = Hash(),
@@ -160,14 +160,14 @@ public:
         insert(first, last);
     }
     
-    template<class InputIt>
+    template <typename InputIt>
     hopscotch_sc_map(InputIt first, InputIt last,
                 size_type bucket_count,
                 const Allocator& alloc) : hopscotch_sc_map(first, last, bucket_count, Hash(), KeyEqual(), alloc)
     {
     }
     
-    template<class InputIt>
+    template <typename InputIt>
     hopscotch_sc_map(InputIt first, InputIt last,
                 size_type bucket_count,
                 const Hash& hash,
@@ -243,7 +243,7 @@ public:
         return m_ht.insert(value); 
     }
         
-    template<class P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr>
+    template <typename P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr>
     std::pair<iterator, bool> insert(P&& value) { 
         return m_ht.insert(std::forward<P>(value)); 
     }
@@ -257,7 +257,7 @@ public:
         return m_ht.insert(hint, value); 
     }
         
-    template<class P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr>
+    template <typename P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr>
     iterator insert(const_iterator hint, P&& value) { 
         return m_ht.insert(hint, std::forward<P>(value));
     }
@@ -267,7 +267,7 @@ public:
     }
     
     
-    template<class InputIt>
+    template <typename InputIt>
     void insert(InputIt first, InputIt last) { 
         m_ht.insert(first, last); 
     }
@@ -279,22 +279,22 @@ public:
     
     
     
-    template<class M>
+    template <typename M>
     std::pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj) { 
         return m_ht.insert_or_assign(k, std::forward<M>(obj)); 
     }
 
-    template<class M>
+    template <typename M>
     std::pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj) { 
         return m_ht.insert_or_assign(std::move(k), std::forward<M>(obj)); 
     }
     
-    template<class M>
+    template <typename M>
     iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj) {
         return m_ht.insert_or_assign(hint, k, std::forward<M>(obj));
     }
     
-    template<class M>
+    template <typename M>
     iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj) {
         return m_ht.insert_or_assign(hint, std::move(k), std::forward<M>(obj));
     }
@@ -307,7 +307,7 @@ public:
      * 
      * Mainly here for compatibility with the std::unordered_map interface.
      */
-    template<class... Args>
+    template <typename... Args>
     std::pair<iterator, bool> emplace(Args&&... args) { 
         return m_ht.emplace(std::forward<Args>(args)...); 
     }
@@ -321,7 +321,7 @@ public:
      * 
      * Mainly here for compatibility with the std::unordered_map interface.
      */
-    template<class... Args>
+    template <typename... Args>
     iterator emplace_hint(const_iterator hint, Args&&... args) {
         return m_ht.emplace_hint(hint, std::forward<Args>(args)...);
     }
@@ -329,22 +329,22 @@ public:
     
     
     
-    template<class... Args>
+    template <typename... Args>
     std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args) { 
         return m_ht.try_emplace(k, std::forward<Args>(args)...);
     }
     
-    template<class... Args>
+    template <typename... Args>
     std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args) {
         return m_ht.try_emplace(std::move(k), std::forward<Args>(args)...);
     }
     
-    template<class... Args>
+    template <typename... Args>
     iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args) {
         return m_ht.try_emplace(hint, k, std::forward<Args>(args)...);
     }
     
-    template<class... Args>
+    template <typename... Args>
     iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args) {
         return m_ht.try_emplace(hint, std::move(k), std::forward<Args>(args)...);
     }
@@ -370,7 +370,7 @@ public:
      * and Compare::is_transparent exist. 
      * If so, K must be hashable and comparable to Key.
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     size_type erase(const K& key) { return m_ht.erase(key); }
     
@@ -380,7 +380,7 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup to the value if you already have the hash.
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     size_type erase(const K& key, std::size_t precalculated_hash) { return m_ht.erase(key, precalculated_hash); }
     
@@ -412,7 +412,7 @@ public:
      * and Compare::is_transparent exist. 
      * If so, K must be hashable and comparable to Key.
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     T& at(const K& key) { return m_ht.at(key); }
     
@@ -422,21 +422,21 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
      */    
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     T& at(const K& key, std::size_t precalculated_hash) { return m_ht.at(key, precalculated_hash); }
     
     /**
      * @copydoc at(const K& key)
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     const T& at(const K& key) const { return m_ht.at(key); }
     
     /**
      * @copydoc at(const K& key, std::size_t precalculated_hash)
      */    
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     const T& at(const K& key, std::size_t precalculated_hash) const { return m_ht.at(key, precalculated_hash); }
     
@@ -462,7 +462,7 @@ public:
      * and Compare::is_transparent exist. 
      * If so, K must be hashable and comparable to Key.
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     size_type count(const K& key) const { return m_ht.count(key); }
     
@@ -472,7 +472,7 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
      */     
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     size_type count(const K& key, std::size_t precalculated_hash) const { return m_ht.count(key, precalculated_hash); }
     
@@ -499,7 +499,7 @@ public:
      * and Compare::is_transparent exist. 
      * If so, K must be hashable and comparable to Key.
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     iterator find(const K& key) { return m_ht.find(key); }
     
@@ -509,21 +509,21 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     iterator find(const K& key, std::size_t precalculated_hash) { return m_ht.find(key, precalculated_hash); }
     
     /**
      * @copydoc find(const K& key)
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     const_iterator find(const K& key) const { return m_ht.find(key); }
     
     /**
      * @copydoc find(const K& key, std::size_t precalculated_hash)
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     const_iterator find(const K& key, std::size_t precalculated_hash) const { return m_ht.find(key, precalculated_hash); }
     
@@ -554,7 +554,7 @@ public:
      * and Compare::is_transparent exist. 
      * If so, K must be hashable and comparable to Key.
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     std::pair<iterator, iterator> equal_range(const K& key) { return m_ht.equal_range(key); }
     
@@ -564,7 +564,7 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
      */    
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     std::pair<iterator, iterator> equal_range(const K& key, std::size_t precalculated_hash) { 
         return m_ht.equal_range(key, precalculated_hash); 
@@ -573,14 +573,14 @@ public:
     /**
      * @copydoc equal_range(const K& key)
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     std::pair<const_iterator, const_iterator> equal_range(const K& key) const { return m_ht.equal_range(key); }
     
     /**
      * @copydoc equal_range(const K& key, std::size_t precalculated_hash)
      */    
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     std::pair<const_iterator, const_iterator> equal_range(const K& key, std::size_t precalculated_hash) const { 
         return m_ht.equal_range(key, precalculated_hash); 
diff --git a/dbms/src/Common/tests/hopscotch-map/src/hopscotch_sc_set.h b/dbms/src/Common/tests/hopscotch-map/src/hopscotch_sc_set.h
index 29eb1d5e3b7..044c28c7994 100644
--- a/dbms/src/Common/tests/hopscotch-map/src/hopscotch_sc_set.h
+++ b/dbms/src/Common/tests/hopscotch-map/src/hopscotch_sc_set.h
@@ -53,7 +53,7 @@ namespace tsl {
  * 
  * @copydoc hopscotch_set
  */
-template<class Key, 
+template <typename Key, 
          class Hash = std::hash<Key>,
          class KeyEqual = std::equal_to<Key>,
          class Compare = std::less<Key>,
@@ -63,7 +63,7 @@ template<class Key,
          class GrowthPolicy = tsl::power_of_two_growth_policy>
 class hopscotch_sc_set {
 private:    
-    template<typename U>
+    template <typename U>
     using has_is_transparent = tsl::detail_hopscotch_hash::has_is_transparent<U>;
     
     class KeySelect {
@@ -133,7 +133,7 @@ public:
     explicit hopscotch_sc_set(const Allocator& alloc) : hopscotch_sc_set(ht::DEFAULT_INIT_BUCKETS_SIZE, alloc) {
     }
     
-    template<class InputIt>
+    template <typename InputIt>
     hopscotch_sc_set(InputIt first, InputIt last,
                 size_type bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE,
                 const Hash& hash = Hash(),
@@ -143,14 +143,14 @@ public:
         insert(first, last);
     }
     
-    template<class InputIt>
+    template <typename InputIt>
     hopscotch_sc_set(InputIt first, InputIt last,
                 size_type bucket_count,
                 const Allocator& alloc) : hopscotch_sc_set(first, last, bucket_count, Hash(), KeyEqual(), alloc)
     {
     }
     
-    template<class InputIt>
+    template <typename InputIt>
     hopscotch_sc_set(InputIt first, InputIt last,
                 size_type bucket_count,
                 const Hash& hash,
@@ -228,7 +228,7 @@ public:
     iterator insert(const_iterator hint, const value_type& value) { return m_ht.insert(hint, value); }
     iterator insert(const_iterator hint, value_type&& value) { return m_ht.insert(hint, std::move(value)); }
     
-    template<class InputIt>
+    template <typename InputIt>
     void insert(InputIt first, InputIt last) { m_ht.insert(first, last); }
     void insert(std::initializer_list<value_type> ilist) { m_ht.insert(ilist.begin(), ilist.end()); }
 
@@ -241,7 +241,7 @@ public:
      * 
      * Mainly here for compatibility with the std::unordered_map interface.
      */
-    template<class... Args>
+    template <typename... Args>
     std::pair<iterator, bool> emplace(Args&&... args) { return m_ht.emplace(std::forward<Args>(args)...); }
     
     
@@ -253,7 +253,7 @@ public:
      * 
      * Mainly here for compatibility with the std::unordered_map interface.
      */
-    template<class... Args>
+    template <typename... Args>
     iterator emplace_hint(const_iterator hint, Args&&... args) {
         return m_ht.emplace_hint(hint, std::forward<Args>(args)...);
     }
@@ -279,7 +279,7 @@ public:
      * and Compare::is_transparent exist. 
      * If so, K must be hashable and comparable to Key.
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     size_type erase(const K& key) { return m_ht.erase(key); }
     
@@ -289,7 +289,7 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup to the value if you already have the hash.
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     size_type erase(const K& key, std::size_t precalculated_hash) { return m_ht.erase(key, precalculated_hash); }
     
@@ -315,7 +315,7 @@ public:
      * and Compare::is_transparent exist. 
      * If so, K must be hashable and comparable to Key.
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     size_type count(const K& key) const { return m_ht.count(key); }
     
@@ -325,7 +325,7 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     size_type count(const K& key, std::size_t precalculated_hash) const { return m_ht.count(key, precalculated_hash); }
     
@@ -352,7 +352,7 @@ public:
      * and Compare::is_transparent exist. 
      * If so, K must be hashable and comparable to Key.
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     iterator find(const K& key) { return m_ht.find(key); }
     
@@ -362,14 +362,14 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     iterator find(const K& key, std::size_t precalculated_hash) { return m_ht.find(key, precalculated_hash); }
     
     /**
      * @copydoc find(const K& key)
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     const_iterator find(const K& key) const { return m_ht.find(key); }
     
@@ -379,7 +379,7 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     const_iterator find(const K& key, std::size_t precalculated_hash) const { return m_ht.find(key, precalculated_hash); }
     
@@ -410,7 +410,7 @@ public:
      * and Compare::is_transparent exist. 
      * If so, K must be hashable and comparable to Key.
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     std::pair<iterator, iterator> equal_range(const K& key) { return m_ht.equal_range(key); }
     
@@ -420,7 +420,7 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     std::pair<iterator, iterator> equal_range(const K& key, std::size_t precalculated_hash) { 
         return m_ht.equal_range(key, precalculated_hash); 
@@ -429,14 +429,14 @@ public:
     /**
      * @copydoc equal_range(const K& key)
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     std::pair<const_iterator, const_iterator> equal_range(const K& key) const { return m_ht.equal_range(key); }    
     
     /**
      * @copydoc equal_range(const K& key, std::size_t precalculated_hash)
      */
-    template<class K, class KE = KeyEqual, class CP = Compare, 
+    template <typename K, typename KE = KeyEqual, typename CP = Compare, 
              typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> 
     std::pair<const_iterator, const_iterator> equal_range(const K& key, std::size_t precalculated_hash) const { 
         return m_ht.equal_range(key, precalculated_hash); 
diff --git a/dbms/src/Common/tests/hopscotch-map/src/hopscotch_set.h b/dbms/src/Common/tests/hopscotch-map/src/hopscotch_set.h
index 72be57fa7e3..03de663c428 100644
--- a/dbms/src/Common/tests/hopscotch-map/src/hopscotch_set.h
+++ b/dbms/src/Common/tests/hopscotch-map/src/hopscotch_set.h
@@ -68,7 +68,7 @@ namespace tsl {
  *    insert will invalidate the iterators). Or if there is a rehash.
  *  - erase: iterator on the erased element is the only one which become invalid.
  */
-template<class Key, 
+template <typename Key, 
          class Hash = std::hash<Key>,
          class KeyEqual = std::equal_to<Key>,
          class Allocator = std::allocator<Key>,
@@ -77,7 +77,7 @@ template<class Key,
          class GrowthPolicy = tsl::power_of_two_growth_policy>
 class hopscotch_set {
 private:    
-    template<typename U>
+    template <typename U>
     using has_is_transparent = tsl::detail_hopscotch_hash::has_is_transparent<U>;
     
     class KeySelect {
@@ -145,7 +145,7 @@ public:
     explicit hopscotch_set(const Allocator& alloc) : hopscotch_set(ht::DEFAULT_INIT_BUCKETS_SIZE, alloc) {
     }
     
-    template<class InputIt>
+    template <typename InputIt>
     hopscotch_set(InputIt first, InputIt last,
                 size_type bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE,
                 const Hash& hash = Hash(),
@@ -155,14 +155,14 @@ public:
         insert(first, last);
     }
     
-    template<class InputIt>
+    template <typename InputIt>
     hopscotch_set(InputIt first, InputIt last,
                 size_type bucket_count,
                 const Allocator& alloc) : hopscotch_set(first, last, bucket_count, Hash(), KeyEqual(), alloc)
     {
     }
     
-    template<class InputIt>
+    template <typename InputIt>
     hopscotch_set(InputIt first, InputIt last,
                 size_type bucket_count,
                 const Hash& hash,
@@ -240,7 +240,7 @@ public:
     iterator insert(const_iterator hint, const value_type& value) { return m_ht.insert(hint, value); }
     iterator insert(const_iterator hint, value_type&& value) { return m_ht.insert(hint, std::move(value)); }
     
-    template<class InputIt>
+    template <typename InputIt>
     void insert(InputIt first, InputIt last) { m_ht.insert(first, last); }
     void insert(std::initializer_list<value_type> ilist) { m_ht.insert(ilist.begin(), ilist.end()); }
 
@@ -253,7 +253,7 @@ public:
      * 
      * Mainly here for compatibility with the std::unordered_map interface.
      */
-    template<class... Args>
+    template <typename... Args>
     std::pair<iterator, bool> emplace(Args&&... args) { return m_ht.emplace(std::forward<Args>(args)...); }
     
     
@@ -265,7 +265,7 @@ public:
      * 
      * Mainly here for compatibility with the std::unordered_map interface.
      */
-    template<class... Args>
+    template <typename... Args>
     iterator emplace_hint(const_iterator hint, Args&&... args) {
         return m_ht.emplace_hint(hint, std::forward<Args>(args)...);
     }
@@ -290,7 +290,7 @@ public:
      * This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. 
      * If so, K must be hashable and comparable to Key.
      */
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     size_type erase(const K& key) { return m_ht.erase(key); }
     
     /**
@@ -299,7 +299,7 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup to the value if you already have the hash.
      */    
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     size_type erase(const K& key, std::size_t precalculated_hash) { 
         return m_ht.erase(key, precalculated_hash); 
     }
@@ -325,7 +325,7 @@ public:
      * This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. 
      * If so, K must be hashable and comparable to Key.
      */
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     size_type count(const K& key) const { return m_ht.count(key); }
     
     /**
@@ -334,7 +334,7 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
      */
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     size_type count(const K& key, std::size_t precalculated_hash) const { return m_ht.count(key, precalculated_hash); }
     
     
@@ -359,7 +359,7 @@ public:
      * This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. 
      * If so, K must be hashable and comparable to Key.
      */
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     iterator find(const K& key) { return m_ht.find(key); }
     
     /**
@@ -368,13 +368,13 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
      */
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     iterator find(const K& key, std::size_t precalculated_hash) { return m_ht.find(key, precalculated_hash); }
     
     /**
      * @copydoc find(const K& key)
      */
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     const_iterator find(const K& key) const { return m_ht.find(key); }
     
     /**
@@ -383,7 +383,7 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
      */
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     const_iterator find(const K& key, std::size_t precalculated_hash) const { return m_ht.find(key, precalculated_hash); }
     
     
@@ -412,7 +412,7 @@ public:
      * This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. 
      * If so, K must be hashable and comparable to Key.
      */
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     std::pair<iterator, iterator> equal_range(const K& key) { return m_ht.equal_range(key); }
     
     /**
@@ -421,7 +421,7 @@ public:
      * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
      * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
      */    
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     std::pair<iterator, iterator> equal_range(const K& key, std::size_t precalculated_hash) { 
         return m_ht.equal_range(key, precalculated_hash); 
     }
@@ -429,13 +429,13 @@ public:
     /**
      * @copydoc equal_range(const K& key)
      */
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     std::pair<const_iterator, const_iterator> equal_range(const K& key) const { return m_ht.equal_range(key); }
 
     /**
      * @copydoc equal_range(const K& key, std::size_t precalculated_hash)
      */    
-    template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
+    template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> 
     std::pair<const_iterator, const_iterator> equal_range(const K& key, std::size_t precalculated_hash) const { 
         return m_ht.equal_range(key, precalculated_hash); 
     }
diff --git a/dbms/src/Core/AccurateComparison.h b/dbms/src/Core/AccurateComparison.h
index 029cde06d7f..b8be096d9bb 100644
--- a/dbms/src/Core/AccurateComparison.h
+++ b/dbms/src/Core/AccurateComparison.h
@@ -161,7 +161,7 @@ inline bool_if_safe_conversion<A, B> greaterOp(A a, B b)
 
 constexpr DB::Int64 MAX_INT64_WITH_EXACT_FLOAT64_REPR = 9007199254740992LL; // 2^53
 
-template<>
+template <>
 inline bool greaterOp<DB::Float64, DB::Int64>(DB::Float64 f, DB::Int64 i)
 {
     if (-MAX_INT64_WITH_EXACT_FLOAT64_REPR <= i && i <= MAX_INT64_WITH_EXACT_FLOAT64_REPR)
@@ -171,7 +171,7 @@ inline bool greaterOp<DB::Float64, DB::Int64>(DB::Float64 f, DB::Int64 i)
             || (f > static_cast<DB::Float64>(std::numeric_limits<DB::Int64>::min()) && static_cast<DB::Int64>(f) > i);
 }
 
-template<>
+template <>
 inline bool greaterOp<DB::Int64, DB::Float64>(DB::Int64 i, DB::Float64 f)
 {
     if (-MAX_INT64_WITH_EXACT_FLOAT64_REPR <= i && i <= MAX_INT64_WITH_EXACT_FLOAT64_REPR)
@@ -181,7 +181,7 @@ inline bool greaterOp<DB::Int64, DB::Float64>(DB::Int64 i, DB::Float64 f)
             || (f < static_cast<DB::Float64>(std::numeric_limits<DB::Int64>::max()) && i > static_cast<DB::Int64>(f));
 }
 
-template<>
+template <>
 inline bool greaterOp<DB::Float64, DB::UInt64>(DB::Float64 f, DB::UInt64 u)
 {
     if (u <= static_cast<DB::UInt64>(MAX_INT64_WITH_EXACT_FLOAT64_REPR))
@@ -191,7 +191,7 @@ inline bool greaterOp<DB::Float64, DB::UInt64>(DB::Float64 f, DB::UInt64 u)
             || (f >= 0 && static_cast<DB::UInt64>(f) > u);
 }
 
-template<>
+template <>
 inline bool greaterOp<DB::UInt64, DB::Float64>(DB::UInt64 u, DB::Float64 f)
 {
     if (u <= static_cast<DB::UInt64>(MAX_INT64_WITH_EXACT_FLOAT64_REPR))
@@ -202,49 +202,49 @@ inline bool greaterOp<DB::UInt64, DB::Float64>(DB::UInt64 u, DB::Float64 f)
 }
 
 // Case 3b for float32
-template<>
+template <>
 inline bool greaterOp<DB::Float32, DB::Int64>(DB::Float32 f, DB::Int64 i)
 {
     return greaterOp(static_cast<DB::Float64>(f), i);
 }
 
-template<>
+template <>
 inline bool greaterOp<DB::Int64, DB::Float32>(DB::Int64 i, DB::Float32 f)
 {
     return greaterOp(i, static_cast<DB::Float64>(f));
 }
 
-template<>
+template <>
 inline bool greaterOp<DB::Float32, DB::UInt64>(DB::Float32 f, DB::UInt64 u)
 {
     return greaterOp(static_cast<DB::Float64>(f), u);
 }
 
-template<>
+template <>
 inline bool greaterOp<DB::UInt64, DB::Float32>(DB::UInt64 u, DB::Float32 f)
 {
     return greaterOp(u, static_cast<DB::Float64>(f));
 }
 
-template<>
+template <>
 inline bool greaterOp<DB::Float64, DB::UInt128>(DB::Float64 f, DB::UInt128 u)
 {
     return u.low == 0 && greaterOp(f, u.high);
 }
 
-template<>
+template <>
 inline bool greaterOp<DB::UInt128, DB::Float64>(DB::UInt128 u, DB::Float64 f)
 {
     return u.low != 0 || greaterOp(u.high, f);
 }
 
-template<>
+template <>
 inline bool greaterOp<DB::Float32, DB::UInt128>(DB::Float32 f, DB::UInt128 u)
 {
     return greaterOp(static_cast<DB::Float64>(f), u);
 }
 
-template<>
+template <>
 inline bool greaterOp<DB::UInt128, DB::Float32>(DB::UInt128 u, DB::Float32 f)
 {
     return greaterOp(u, static_cast<DB::Float64>(f));
@@ -262,73 +262,73 @@ inline bool_if_safe_conversion<A, B> equalsOp(A a, B b)
     return a == b;
 }
 
-template<>
+template <>
 inline bool equalsOp<DB::Float64, DB::UInt64>(DB::Float64 f, DB::UInt64 u)
 {
     return static_cast<DB::UInt64>(f) == u && f == static_cast<DB::Float64>(u);
 }
 
-template<>
+template <>
 inline bool equalsOp<DB::UInt64, DB::Float64>(DB::UInt64 u, DB::Float64 f)
 {
     return u == static_cast<DB::UInt64>(f) && static_cast<DB::Float64>(u) == f;
 }
 
-template<>
+template <>
 inline bool equalsOp<DB::Float64, DB::Int64>(DB::Float64 f, DB::Int64 u)
 {
     return static_cast<DB::Int64>(f) == u && f == static_cast<DB::Float64>(u);
 }
 
-template<>
+template <>
 inline bool equalsOp<DB::Int64, DB::Float64>(DB::Int64 u, DB::Float64 f)
 {
     return u == static_cast<DB::Int64>(f) && static_cast<DB::Float64>(u) == f;
 }
 
-template<>
+template <>
 inline bool equalsOp<DB::Float32, DB::UInt64>(DB::Float32 f, DB::UInt64 u)
 {
     return static_cast<DB::UInt64>(f) == u && f == static_cast<DB::Float32>(u);
 }
 
-template<>
+template <>
 inline bool equalsOp<DB::UInt64, DB::Float32>(DB::UInt64 u, DB::Float32 f)
 {
     return u == static_cast<DB::UInt64>(f) && static_cast<DB::Float32>(u) == f;
 }
 
-template<>
+template <>
 inline bool equalsOp<DB::Float32, DB::Int64>(DB::Float32 f, DB::Int64 u)
 {
     return static_cast<DB::Int64>(f) == u && f == static_cast<DB::Float32>(u);
 }
 
-template<>
+template <>
 inline bool equalsOp<DB::Int64, DB::Float32>(DB::Int64 u, DB::Float32 f)
 {
     return u == static_cast<DB::Int64>(f) && static_cast<DB::Float32>(u) == f;
 }
 
-template<>
+template <>
 inline bool equalsOp<DB::UInt128, DB::Float64>(DB::UInt128 u, DB::Float64 f)
 {
     return u.low == 0 && equalsOp(static_cast<UInt64>(u.high), f);
 }
 
-template<>
+template <>
 inline bool equalsOp<DB::UInt128, DB::Float32>(DB::UInt128 u, DB::Float32 f)
 {
     return equalsOp(u, static_cast<DB::Float64>(f));
 }
 
-template<>
+template <>
 inline bool equalsOp<DB::Float64, DB::UInt128>(DB::Float64 f, DB::UInt128 u)
 {
     return equalsOp(u, f);
 }
 
-template<>
+template <>
 inline bool equalsOp<DB::Float32, DB::UInt128>(DB::Float32 f, DB::UInt128 u)
 {
     return equalsOp(static_cast<DB::Float64>(f), u);
diff --git a/dbms/src/Core/QualifiedTableName.h b/dbms/src/Core/QualifiedTableName.h
index ab57fe719f7..6337cc1ccbf 100644
--- a/dbms/src/Core/QualifiedTableName.h
+++ b/dbms/src/Core/QualifiedTableName.h
@@ -36,7 +36,7 @@ struct QualifiedTableName
 namespace std
 {
 
-template<> struct hash<DB::QualifiedTableName>
+template <> struct hash<DB::QualifiedTableName>
 {
     using argument_type = DB::QualifiedTableName;
     using result_type = size_t;
diff --git a/dbms/src/DataStreams/AggregatingSortedBlockInputStream.cpp b/dbms/src/DataStreams/AggregatingSortedBlockInputStream.cpp
index 113b6a92ecc..37f2ca59c68 100644
--- a/dbms/src/DataStreams/AggregatingSortedBlockInputStream.cpp
+++ b/dbms/src/DataStreams/AggregatingSortedBlockInputStream.cpp
@@ -68,7 +68,7 @@ Block AggregatingSortedBlockInputStream::readImpl()
 }
 
 
-template<class TSortCursor>
+template <typename TSortCursor>
 void AggregatingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue)
 {
     size_t merged_rows = 0;
@@ -133,7 +133,7 @@ void AggregatingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns,
 }
 
 
-template <class TSortCursor>
+template <typename TSortCursor>
 void AggregatingSortedBlockInputStream::addRow(TSortCursor & cursor)
 {
     for (size_t i = 0, size = column_numbers_to_aggregate.size(); i < size; ++i)
diff --git a/dbms/src/DataStreams/AggregatingSortedBlockInputStream.h b/dbms/src/DataStreams/AggregatingSortedBlockInputStream.h
index 4f1ee6424b3..756cadc4383 100644
--- a/dbms/src/DataStreams/AggregatingSortedBlockInputStream.h
+++ b/dbms/src/DataStreams/AggregatingSortedBlockInputStream.h
@@ -70,12 +70,12 @@ private:
     /** We support two different cursors - with Collation and without.
      *  Templates are used instead of polymorphic SortCursor and calls to virtual functions.
      */
-    template <class TSortCursor>
+    template <typename TSortCursor>
     void merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue);
 
     /** Extract all states of aggregate functions and merge them with the current group.
       */
-    template <class TSortCursor>
+    template <typename TSortCursor>
     void addRow(TSortCursor & cursor);
 };
 
diff --git a/dbms/src/DataStreams/CollapsingSortedBlockInputStream.cpp b/dbms/src/DataStreams/CollapsingSortedBlockInputStream.cpp
index ea1eff48a37..424f5934761 100644
--- a/dbms/src/DataStreams/CollapsingSortedBlockInputStream.cpp
+++ b/dbms/src/DataStreams/CollapsingSortedBlockInputStream.cpp
@@ -136,7 +136,7 @@ Block CollapsingSortedBlockInputStream::readImpl()
 }
 
 
-template<class TSortCursor>
+template <typename TSortCursor>
 void CollapsingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue)
 {
     size_t merged_rows = 0;
diff --git a/dbms/src/DataStreams/CollapsingSortedBlockInputStream.h b/dbms/src/DataStreams/CollapsingSortedBlockInputStream.h
index 4eb3cc1a248..26e7e50c612 100644
--- a/dbms/src/DataStreams/CollapsingSortedBlockInputStream.h
+++ b/dbms/src/DataStreams/CollapsingSortedBlockInputStream.h
@@ -90,7 +90,7 @@ private:
     /** We support two different cursors - with Collation and without.
      *  Templates are used instead of polymorphic SortCursors and calls to virtual functions.
      */
-    template<class TSortCursor>
+    template <typename TSortCursor>
     void merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue);
 
     /// Output to result rows for the current primary key.
diff --git a/dbms/src/DataStreams/ColumnGathererStream.h b/dbms/src/DataStreams/ColumnGathererStream.h
index dc86bdb72c0..66ad2645e2f 100644
--- a/dbms/src/DataStreams/ColumnGathererStream.h
+++ b/dbms/src/DataStreams/ColumnGathererStream.h
@@ -68,7 +68,7 @@ public:
     void readSuffixImpl() override;
 
     /// for use in implementations of IColumn::gather()
-    template<typename Column>
+    template <typename Column>
     void gather(Column & column_res);
 
 private:
@@ -110,7 +110,7 @@ private:
     Poco::Logger * log;
 };
 
-template<typename Column>
+template <typename Column>
 void ColumnGathererStream::gather(Column & column_res)
 {
     if (source_to_fully_copy) /// Was set on a previous iteration
diff --git a/dbms/src/DataStreams/GraphiteRollupSortedBlockInputStream.cpp b/dbms/src/DataStreams/GraphiteRollupSortedBlockInputStream.cpp
index b0693cf00fe..f21bc74ed09 100644
--- a/dbms/src/DataStreams/GraphiteRollupSortedBlockInputStream.cpp
+++ b/dbms/src/DataStreams/GraphiteRollupSortedBlockInputStream.cpp
@@ -218,7 +218,7 @@ void GraphiteRollupSortedBlockInputStream::merge(ColumnPlainPtrs & merged_column
 }
 
 
-template <class TSortCursor>
+template <typename TSortCursor>
 void GraphiteRollupSortedBlockInputStream::startNextRow(ColumnPlainPtrs & merged_columns, TSortCursor & cursor, const Graphite::Pattern * next_pattern)
 {
     /// Copy unmodified column values.
diff --git a/dbms/src/DataStreams/GraphiteRollupSortedBlockInputStream.h b/dbms/src/DataStreams/GraphiteRollupSortedBlockInputStream.h
index 7a6b4f49e28..94197967cd4 100644
--- a/dbms/src/DataStreams/GraphiteRollupSortedBlockInputStream.h
+++ b/dbms/src/DataStreams/GraphiteRollupSortedBlockInputStream.h
@@ -199,7 +199,7 @@ private:
     void merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue);
 
     /// Insert the values into the resulting columns, which will not be changed in the future.
-    template <class TSortCursor>
+    template <typename TSortCursor>
     void startNextRow(ColumnPlainPtrs & merged_columns, TSortCursor & cursor, const Graphite::Pattern * next_pattern);
 
     /// Insert the calculated `time`, `value`, `version` values into the resulting columns by the last group of rows.
diff --git a/dbms/src/DataStreams/MergingSortedBlockInputStream.h b/dbms/src/DataStreams/MergingSortedBlockInputStream.h
index 15e6407ea32..77d77ec9cb2 100644
--- a/dbms/src/DataStreams/MergingSortedBlockInputStream.h
+++ b/dbms/src/DataStreams/MergingSortedBlockInputStream.h
@@ -153,7 +153,7 @@ protected:
     /// These methods are used in Collapsing/Summing/Aggregating... SortedBlockInputStream-s.
 
     /// Save the row pointed to by cursor in `row`.
-    template <class TSortCursor>
+    template <typename TSortCursor>
     void setRow(Row & row, TSortCursor & cursor)
     {
         for (size_t i = 0; i < num_columns; ++i)
@@ -185,7 +185,7 @@ protected:
         }
     }
 
-    template <class TSortCursor>
+    template <typename TSortCursor>
     void setRowRef(RowRef & row_ref, TSortCursor & cursor)
     {
         row_ref.row_num = cursor.impl->pos;
@@ -195,7 +195,7 @@ protected:
             row_ref.columns[i] = cursor->all_columns[i];
     }
 
-    template <class TSortCursor>
+    template <typename TSortCursor>
     void setPrimaryKeyRef(RowRef & row_ref, TSortCursor & cursor)
     {
         row_ref.row_num = cursor.impl->pos;
diff --git a/dbms/src/DataStreams/ReplacingSortedBlockInputStream.cpp b/dbms/src/DataStreams/ReplacingSortedBlockInputStream.cpp
index 7c6052444a1..9b1a489bae6 100644
--- a/dbms/src/DataStreams/ReplacingSortedBlockInputStream.cpp
+++ b/dbms/src/DataStreams/ReplacingSortedBlockInputStream.cpp
@@ -58,7 +58,7 @@ Block ReplacingSortedBlockInputStream::readImpl()
 }
 
 
-template<class TSortCursor>
+template <typename TSortCursor>
 void ReplacingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue)
 {
     size_t merged_rows = 0;
diff --git a/dbms/src/DataStreams/ReplacingSortedBlockInputStream.h b/dbms/src/DataStreams/ReplacingSortedBlockInputStream.h
index a07a330a749..beb1775e61e 100644
--- a/dbms/src/DataStreams/ReplacingSortedBlockInputStream.h
+++ b/dbms/src/DataStreams/ReplacingSortedBlockInputStream.h
@@ -63,7 +63,7 @@ private:
 
     PODArray<RowSourcePart> current_row_sources;   /// Sources of rows with the current primary key
 
-    template<class TSortCursor>
+    template <typename TSortCursor>
     void merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue);
 
     /// Output into result the rows for current primary key.
diff --git a/dbms/src/DataStreams/SummingSortedBlockInputStream.cpp b/dbms/src/DataStreams/SummingSortedBlockInputStream.cpp
index e1610d3a68d..e82169d7f77 100644
--- a/dbms/src/DataStreams/SummingSortedBlockInputStream.cpp
+++ b/dbms/src/DataStreams/SummingSortedBlockInputStream.cpp
@@ -176,7 +176,7 @@ Block SummingSortedBlockInputStream::readImpl()
 }
 
 
-template <class TSortCursor>
+template <typename TSortCursor>
 void SummingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue)
 {
     size_t merged_rows = 0;
@@ -269,7 +269,7 @@ public:
 };
 
 
-template <class TSortCursor>
+template <typename TSortCursor>
 bool SummingSortedBlockInputStream::mergeMaps(Row & row, TSortCursor & cursor)
 {
     bool non_empty_map_present = false;
@@ -283,7 +283,7 @@ bool SummingSortedBlockInputStream::mergeMaps(Row & row, TSortCursor & cursor)
 }
 
 
-template <class TSortCursor>
+template <typename TSortCursor>
 bool SummingSortedBlockInputStream::mergeMap(const MapDescription & desc, Row & row, TSortCursor & cursor)
 {
     /// Strongly non-optimal.
@@ -367,7 +367,7 @@ bool SummingSortedBlockInputStream::mergeMap(const MapDescription & desc, Row &
 }
 
 
-template <class TSortCursor>
+template <typename TSortCursor>
 bool SummingSortedBlockInputStream::addRow(Row & row, TSortCursor & cursor)
 {
     bool res = mergeMaps(row, cursor);    /// Is there at least one non-zero number or non-empty array
diff --git a/dbms/src/DataStreams/SummingSortedBlockInputStream.h b/dbms/src/DataStreams/SummingSortedBlockInputStream.h
index b401d469d21..1e1bbd9499a 100644
--- a/dbms/src/DataStreams/SummingSortedBlockInputStream.h
+++ b/dbms/src/DataStreams/SummingSortedBlockInputStream.h
@@ -90,7 +90,7 @@ private:
     /** We support two different cursors - with Collation and without.
      *  Templates are used instead of polymorphic SortCursor and calls to virtual functions.
      */
-    template <class TSortCursor>
+    template <typename TSortCursor>
     void merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue);
 
     /// Insert the summed row for the current group into the result.
@@ -99,16 +99,16 @@ private:
     /** For nested Map, a merge by key is performed with the ejection of rows of nested arrays, in which
       * all items are zero.
       */
-    template <class TSortCursor>
+    template <typename TSortCursor>
     bool mergeMaps(Row & row, TSortCursor & cursor);
 
-    template <class TSortCursor>
+    template <typename TSortCursor>
     bool mergeMap(const MapDescription & map, Row & row, TSortCursor & cursor);
 
     /** Add the row under the cursor to the `row`.
       * Returns false if the result is zero.
       */
-    template <class TSortCursor>
+    template <typename TSortCursor>
     bool addRow(Row & row, TSortCursor & cursor);
 };
 
diff --git a/dbms/src/DataStreams/UnionBlockInputStream.h b/dbms/src/DataStreams/UnionBlockInputStream.h
index b72344cdede..a032f34a6a9 100644
--- a/dbms/src/DataStreams/UnionBlockInputStream.h
+++ b/dbms/src/DataStreams/UnionBlockInputStream.h
@@ -237,13 +237,13 @@ protected:
     }
 
 private:
-    template<StreamUnionMode mode2 = mode>
+    template <StreamUnionMode mode2 = mode>
     BlockExtraInfo doGetBlockExtraInfo(typename std::enable_if<mode2 == StreamUnionMode::ExtraInfo>::type * = nullptr) const
     {
         return received_payload.extra_info;
     }
 
-    template<StreamUnionMode mode2 = mode>
+    template <StreamUnionMode mode2 = mode>
     BlockExtraInfo doGetBlockExtraInfo(typename std::enable_if<mode2 == StreamUnionMode::Basic>::type * = nullptr) const
     {
         throw Exception("Method getBlockExtraInfo is not supported for mode StreamUnionMode::Basic",
diff --git a/dbms/src/Dictionaries/DictionaryBlockInputStream.h b/dbms/src/Dictionaries/DictionaryBlockInputStream.h
index a2f3fb31584..595f19cac29 100644
--- a/dbms/src/Dictionaries/DictionaryBlockInputStream.h
+++ b/dbms/src/Dictionaries/DictionaryBlockInputStream.h
@@ -19,7 +19,7 @@ namespace DB
  * BlockInputStream implementation for external dictionaries
  * read() returns single block consisting of the in-memory contents of the dictionaries
  */
-template <class DictionaryType, class Key>
+template <typename DictionaryType, typename Key>
 class DictionaryBlockInputStream : public DictionaryBlockInputStreamBase
 {
 public:
@@ -51,13 +51,13 @@ protected:
 private:
     // pointer types to getXXX functions
     // for single key dictionaries
-    template <class Type>
+    template <typename Type>
     using DictionaryGetter = void (DictionaryType::*)(
                                  const std::string &, const PaddedPODArray<Key> &, PaddedPODArray<Type> &) const;
     using DictionaryStringGetter = void (DictionaryType::*)(
                                        const std::string &, const PaddedPODArray<Key> &, ColumnString *) const;
     // for complex complex key dictionaries
-    template <class Type>
+    template <typename Type>
     using GetterByKey = void (DictionaryType::*)(
                             const std::string &, const Columns &, const DataTypes &, PaddedPODArray<Type> & out) const;
     using StringGetterByKey = void (DictionaryType::*)(
@@ -65,34 +65,34 @@ private:
 
     // call getXXX
     // for single key dictionaries
-    template <class Type, class Container>
+    template <typename Type, typename Container>
     void callGetter(DictionaryGetter<Type> getter, const PaddedPODArray<Key> & ids,
                     const Columns & keys, const DataTypes & data_types,
                     Container & container, const DictionaryAttribute & attribute, const DictionaryType & dictionary) const;
-    template <class Container>
+    template <typename Container>
     void callGetter(DictionaryStringGetter getter, const PaddedPODArray<Key> & ids,
                     const Columns & keys, const DataTypes & data_types,
                     Container & container, const DictionaryAttribute & attribute, const DictionaryType & dictionary) const;
     // for complex complex key dictionaries
-    template <class Type, class Container>
+    template <typename Type, typename Container>
     void callGetter(GetterByKey<Type> getter, const PaddedPODArray<Key> & ids,
                     const Columns & keys, const DataTypes & data_types,
                     Container & container, const DictionaryAttribute & attribute, const DictionaryType & dictionary) const;
-    template <class Container>
+    template <typename Container>
     void callGetter(StringGetterByKey getter, const PaddedPODArray<Key> & ids,
                     const Columns & keys, const DataTypes & data_types,
                     Container & container, const DictionaryAttribute & attribute, const DictionaryType & dictionary) const;
 
-    template <template <class> class Getter, class StringGetter>
+    template <template <typename> class Getter, typename StringGetter>
     Block fillBlock(const PaddedPODArray<Key> & ids, const Columns & keys,
                     const DataTypes & types, ColumnsWithTypeAndName && view) const;
 
 
-    template <class AttributeType, class Getter>
+    template <typename AttributeType, typename Getter>
     ColumnPtr getColumnFromAttribute(Getter getter, const PaddedPODArray<Key> & ids,
                                      const Columns & keys, const DataTypes & data_types,
                                      const DictionaryAttribute & attribute, const DictionaryType & dictionary) const;
-    template <class Getter>
+    template <typename Getter>
     ColumnPtr getColumnFromStringAttribute(Getter getter, const PaddedPODArray<Key> & ids,
                                            const Columns & keys, const DataTypes & data_types,
                                            const DictionaryAttribute& attribute, const DictionaryType& dictionary) const;
@@ -115,7 +115,7 @@ private:
     GetColumnsFunction get_view_columns_function;
 };
 
-template <class DictionaryType, class Key>
+template <typename DictionaryType, typename Key>
 DictionaryBlockInputStream<DictionaryType, Key>::DictionaryBlockInputStream(
     std::shared_ptr<const IDictionaryBase> dictionary, size_t max_block_size,
     PaddedPODArray<Key> && ids, const Names& column_names)
@@ -127,7 +127,7 @@ DictionaryBlockInputStream<DictionaryType, Key>::DictionaryBlockInputStream(
 {
 }
 
-template <class DictionaryType, class Key>
+template <typename DictionaryType, typename Key>
 DictionaryBlockInputStream<DictionaryType, Key>::DictionaryBlockInputStream(
     std::shared_ptr<const IDictionaryBase> dictionary, size_t max_block_size,
     const std::vector<StringRef> & keys, const Names& column_names)
@@ -140,7 +140,7 @@ DictionaryBlockInputStream<DictionaryType, Key>::DictionaryBlockInputStream(
     fillKeyColumns(keys, 0, keys.size(), dictionaty_structure, key_columns);
 }
 
-template <class DictionaryType, class Key>
+template <typename DictionaryType, typename Key>
 DictionaryBlockInputStream<DictionaryType, Key>::DictionaryBlockInputStream(
     std::shared_ptr<const IDictionaryBase> dictionary, size_t max_block_size,
     const Columns & data_columns, const Names & column_names,
@@ -155,7 +155,7 @@ DictionaryBlockInputStream<DictionaryType, Key>::DictionaryBlockInputStream(
 {
 }
 
-template <class DictionaryType, class Key>
+template <typename DictionaryType, typename Key>
 Block DictionaryBlockInputStream<DictionaryType, Key>::getBlock(size_t start, size_t length) const
 {
     if (!key_columns.empty())
@@ -197,8 +197,8 @@ Block DictionaryBlockInputStream<DictionaryType, Key>::getBlock(size_t start, si
     }
 }
 
-template <class DictionaryType, class Key>
-template <class Type, class Container>
+template <typename DictionaryType, typename Key>
+template <typename Type, typename Container>
 void DictionaryBlockInputStream<DictionaryType, Key>::callGetter(
     DictionaryGetter<Type> getter, const PaddedPODArray<Key> & ids,
     const Columns & keys, const DataTypes & data_types,
@@ -207,8 +207,8 @@ void DictionaryBlockInputStream<DictionaryType, Key>::callGetter(
     (dictionary.*getter)(attribute.name, ids, container);
 }
 
-template <class DictionaryType, class Key>
-template <class Container>
+template <typename DictionaryType, typename Key>
+template <typename Container>
 void DictionaryBlockInputStream<DictionaryType, Key>::callGetter(
     DictionaryStringGetter getter, const PaddedPODArray<Key> & ids,
     const Columns & keys, const DataTypes & data_types,
@@ -217,8 +217,8 @@ void DictionaryBlockInputStream<DictionaryType, Key>::callGetter(
     (dictionary.*getter)(attribute.name, ids, container);
 }
 
-template <class DictionaryType, class Key>
-template <class Type, class Container>
+template <typename DictionaryType, typename Key>
+template <typename Type, typename Container>
 void DictionaryBlockInputStream<DictionaryType, Key>::callGetter(
     GetterByKey<Type> getter, const PaddedPODArray<Key> & ids,
     const Columns & keys, const DataTypes & data_types,
@@ -227,8 +227,8 @@ void DictionaryBlockInputStream<DictionaryType, Key>::callGetter(
     (dictionary.*getter)(attribute.name, keys, data_types, container);
 }
 
-template <class DictionaryType, class Key>
-template <class Container>
+template <typename DictionaryType, typename Key>
+template <typename Container>
 void DictionaryBlockInputStream<DictionaryType, Key>::callGetter(
     StringGetterByKey getter, const PaddedPODArray<Key> & ids,
     const Columns & keys, const DataTypes & data_types,
@@ -237,8 +237,8 @@ void DictionaryBlockInputStream<DictionaryType, Key>::callGetter(
     (dictionary.*getter)(attribute.name, keys, data_types, container);
 }
 
-template <class DictionaryType, class Key>
-template <template <class> class Getter, class StringGetter>
+template <typename DictionaryType, typename Key>
+template <template <typename> class Getter, typename StringGetter>
 Block DictionaryBlockInputStream<DictionaryType, Key>::fillBlock(
     const PaddedPODArray<Key>& ids, const Columns& keys, const DataTypes & types, ColumnsWithTypeAndName && view) const
 {
@@ -317,8 +317,8 @@ Block DictionaryBlockInputStream<DictionaryType, Key>::fillBlock(
     return Block(block_columns);
 }
 
-template <class DictionaryType, class Key>
-template <class AttributeType, class Getter>
+template <typename DictionaryType, typename Key>
+template <typename AttributeType, typename Getter>
 ColumnPtr DictionaryBlockInputStream<DictionaryType, Key>::getColumnFromAttribute(
     Getter getter, const PaddedPODArray<Key> & ids,
     const Columns & keys, const DataTypes & data_types,
@@ -332,8 +332,8 @@ ColumnPtr DictionaryBlockInputStream<DictionaryType, Key>::getColumnFromAttribut
     return ColumnPtr(std::move(column_vector));
 }
 
-template <class DictionaryType, class Key>
-template <class Getter>
+template <typename DictionaryType, typename Key>
+template <typename Getter>
 ColumnPtr DictionaryBlockInputStream<DictionaryType, Key>::getColumnFromStringAttribute(
     Getter getter, const PaddedPODArray<Key> & ids,
     const Columns & keys, const DataTypes & data_types,
@@ -345,7 +345,7 @@ ColumnPtr DictionaryBlockInputStream<DictionaryType, Key>::getColumnFromStringAt
     return column_string;
 }
 
-template <class DictionaryType, class Key>
+template <typename DictionaryType, typename Key>
 ColumnPtr DictionaryBlockInputStream<DictionaryType, Key>::getColumnFromIds(const PaddedPODArray<Key>& ids) const
 {
     auto column_vector = std::make_shared<ColumnVector<UInt64>>();
@@ -357,7 +357,7 @@ ColumnPtr DictionaryBlockInputStream<DictionaryType, Key>::getColumnFromIds(cons
     return column_vector;
 }
 
-template <class DictionaryType, class Key>
+template <typename DictionaryType, typename Key>
 void DictionaryBlockInputStream<DictionaryType, Key>::fillKeyColumns(
     const std::vector<StringRef> & keys, size_t start, size_t size,
     const DictionaryStructure& dictionary_structure, ColumnsWithTypeAndName & columns) const
diff --git a/dbms/src/Dictionaries/RangeDictionaryBlockInputStream.h b/dbms/src/Dictionaries/RangeDictionaryBlockInputStream.h
index a55e8a702f1..462a0fe8f0c 100644
--- a/dbms/src/Dictionaries/RangeDictionaryBlockInputStream.h
+++ b/dbms/src/Dictionaries/RangeDictionaryBlockInputStream.h
@@ -17,7 +17,7 @@ namespace DB
  * BlockInputStream implementation for external dictionaries
  * read() returns single block consisting of the in-memory contents of the dictionaries
  */
-template <class DictionaryType, class Key>
+template <typename DictionaryType, typename Key>
 class RangeDictionaryBlockInputStream : public DictionaryBlockInputStreamBase
 {
 public:
@@ -35,20 +35,20 @@ protected:
     Block getBlock(size_t start, size_t length) const override;
 
 private:
-    template <class Type>
+    template <typename Type>
     using DictionaryGetter = void (DictionaryType::*)(const std::string &, const PaddedPODArray<Key> &,
                              const PaddedPODArray<UInt16> &, PaddedPODArray<Type> &) const;
 
-    template <class AttributeType>
+    template <typename AttributeType>
     ColumnPtr getColumnFromAttribute(DictionaryGetter<AttributeType> getter,
                                      const PaddedPODArray<Key>& ids, const PaddedPODArray<UInt16> & dates,
                                      const DictionaryAttribute& attribute, const DictionaryType& dictionary) const;
     ColumnPtr getColumnFromAttributeString(const PaddedPODArray<Key>& ids, const PaddedPODArray<UInt16> & dates,
                                            const DictionaryAttribute& attribute, const DictionaryType& dictionary) const;
-    template <class T>
+    template <typename T>
     ColumnPtr getColumnFromPODArray(const PaddedPODArray<T>& array) const;
 
-    template <class T>
+    template <typename T>
     void addSpecialColumn(
         const std::experimental::optional<DictionarySpecialAttribute>& attribute, DataTypePtr type,
         const std::string & default_name, const std::unordered_set<std::string> & column_names,
@@ -65,7 +65,7 @@ private:
 };
 
 
-template <class DictionaryType, class Key>
+template <typename DictionaryType, typename Key>
 RangeDictionaryBlockInputStream<DictionaryType, Key>::RangeDictionaryBlockInputStream(
     DictionatyPtr dictionary, size_t max_column_size, const Names & column_names, PaddedPODArray<Key> && ids,
     PaddedPODArray<UInt16> && start_dates, PaddedPODArray<UInt16> && end_dates)
@@ -75,7 +75,7 @@ RangeDictionaryBlockInputStream<DictionaryType, Key>::RangeDictionaryBlockInputS
 {
 }
 
-template <class DictionaryType, class Key>
+template <typename DictionaryType, typename Key>
 Block RangeDictionaryBlockInputStream<DictionaryType, Key>::getBlock(size_t start, size_t length) const
 {
     PaddedPODArray<Key> block_ids;
@@ -95,8 +95,8 @@ Block RangeDictionaryBlockInputStream<DictionaryType, Key>::getBlock(size_t star
     return fillBlock(block_ids, block_start_dates, block_end_dates);
 }
 
-template <class DictionaryType, class Key>
-template <class AttributeType>
+template <typename DictionaryType, typename Key>
+template <typename AttributeType>
 ColumnPtr RangeDictionaryBlockInputStream<DictionaryType, Key>::getColumnFromAttribute(
     DictionaryGetter<AttributeType> getter, const PaddedPODArray<Key>& ids,
     const PaddedPODArray<UInt16> & dates, const DictionaryAttribute& attribute, const DictionaryType& dictionary) const
@@ -106,7 +106,7 @@ ColumnPtr RangeDictionaryBlockInputStream<DictionaryType, Key>::getColumnFromAtt
     return ColumnPtr(std::move(column_vector));
 }
 
-template <class DictionaryType, class Key>
+template <typename DictionaryType, typename Key>
 ColumnPtr RangeDictionaryBlockInputStream<DictionaryType, Key>::getColumnFromAttributeString(
     const PaddedPODArray<Key>& ids, const PaddedPODArray<UInt16> & dates,
     const DictionaryAttribute& attribute, const DictionaryType& dictionary) const
@@ -116,8 +116,8 @@ ColumnPtr RangeDictionaryBlockInputStream<DictionaryType, Key>::getColumnFromAtt
     return ColumnPtr(std::move(column_string));
 }
 
-template <class DictionaryType, class Key>
-template <class T>
+template <typename DictionaryType, typename Key>
+template <typename T>
 ColumnPtr RangeDictionaryBlockInputStream<DictionaryType, Key>::getColumnFromPODArray(const PaddedPODArray<T>& array) const
 {
     auto column_vector = std::make_unique<ColumnVector<T>>();
@@ -130,8 +130,8 @@ ColumnPtr RangeDictionaryBlockInputStream<DictionaryType, Key>::getColumnFromPOD
 }
 
 
-template <class DictionaryType, class Key>
-template <class T>
+template <typename DictionaryType, typename Key>
+template <typename T>
 void RangeDictionaryBlockInputStream<DictionaryType, Key>::addSpecialColumn(
     const std::experimental::optional<DictionarySpecialAttribute> & attribute, DataTypePtr type,
     const std::string& default_name, const std::unordered_set<std::string> & column_names,
@@ -146,7 +146,7 @@ void RangeDictionaryBlockInputStream<DictionaryType, Key>::addSpecialColumn(
     }
 }
 
-template <class DictionaryType, class Key>
+template <typename DictionaryType, typename Key>
 Block RangeDictionaryBlockInputStream<DictionaryType, Key>::fillBlock(
     const PaddedPODArray<Key>& ids,
     const PaddedPODArray<UInt16> & start_dates, const PaddedPODArray<UInt16> & end_dates) const
diff --git a/dbms/src/Functions/FunctionsComparison.h b/dbms/src/Functions/FunctionsComparison.h
index ab7cd27e84a..a9fefcfe66e 100644
--- a/dbms/src/Functions/FunctionsComparison.h
+++ b/dbms/src/Functions/FunctionsComparison.h
@@ -90,7 +90,7 @@ template <typename A, typename B> struct GreaterOrEqualsOp
 };
 
 
-template<typename A, typename B, typename Op>
+template <typename A, typename B, typename Op>
 struct NumComparisonImpl
 {
     /// If you don't specify NO_INLINE, the compiler will inline this function, but we don't need this as this function contains tight loop inside.
diff --git a/dbms/src/Functions/FunctionsConversion.h b/dbms/src/Functions/FunctionsConversion.h
index 4cdd92970ae..bfb31d14a28 100644
--- a/dbms/src/Functions/FunctionsConversion.h
+++ b/dbms/src/Functions/FunctionsConversion.h
@@ -705,7 +705,7 @@ private:
         }
     }
 
-    template<typename ToDataType2 = ToDataType, typename Name2 = Name>
+    template <typename ToDataType2 = ToDataType, typename Name2 = Name>
     DataTypePtr getReturnTypeInternal(const DataTypes & arguments,
         typename std::enable_if<!(std::is_same<ToDataType2, DataTypeString>::value ||
             std::is_same<Name2, NameToUnixTimestamp>::value ||
@@ -721,7 +721,7 @@ private:
 
     /** Conversion of anything to String. For DateTime, it allows second optional argument - time zone.
       */
-    template<typename ToDataType2 = ToDataType, typename Name2 = Name>
+    template <typename ToDataType2 = ToDataType, typename Name2 = Name>
     DataTypePtr getReturnTypeInternal(const DataTypes & arguments,
         typename std::enable_if<std::is_same<ToDataType2, DataTypeString>::value>::type * = nullptr) const
     {
@@ -747,7 +747,7 @@ private:
         return std::make_shared<ToDataType2>();
     }
 
-    template<typename ToDataType2 = ToDataType, typename Name2 = Name>
+    template <typename ToDataType2 = ToDataType, typename Name2 = Name>
     DataTypePtr getReturnTypeInternal(const DataTypes & arguments,
         typename std::enable_if<std::is_same<Name2, NameToUnixTimestamp>::value, void>::type * = nullptr) const
     {
@@ -773,7 +773,7 @@ private:
         return std::make_shared<ToDataType2>();
     }
 
-    template<typename ToDataType2 = ToDataType, typename Name2 = Name>
+    template <typename ToDataType2 = ToDataType, typename Name2 = Name>
     DataTypePtr getReturnTypeInternal(const DataTypes & arguments,
         typename std::enable_if<std::is_same<Name2, NameToDate>::value>::type * = nullptr) const
     {
diff --git a/dbms/src/Functions/FunctionsDateTime.h b/dbms/src/Functions/FunctionsDateTime.h
index e10aff4b05b..61859dfe141 100644
--- a/dbms/src/Functions/FunctionsDateTime.h
+++ b/dbms/src/Functions/FunctionsDateTime.h
@@ -466,7 +466,7 @@ struct ToYYYYMMDDhhmmssImpl
 };
 
 
-template<typename FromType, typename ToType, typename Transform>
+template <typename FromType, typename ToType, typename Transform>
 struct Transformer
 {
     static void vector(const PaddedPODArray<FromType> & vec_from, PaddedPODArray<ToType> & vec_to, const DateLUTImpl & time_zone)
diff --git a/dbms/src/Functions/FunctionsFindCluster.h b/dbms/src/Functions/FunctionsFindCluster.h
index eb712295ce5..3b7fd9d9a5d 100644
--- a/dbms/src/Functions/FunctionsFindCluster.h
+++ b/dbms/src/Functions/FunctionsFindCluster.h
@@ -167,7 +167,7 @@ protected:
 
     // Match the type of the centrods array and convert them to Float64, because we
     // don't want to have problems calculating negative distances of UInts
-    template<typename CentroidsType>
+    template <typename CentroidsType>
     bool fillCentroids(const IColumn * centroids_array_untyped, std::vector<Float64> & centroids)
     {
         const ColumnConst * const_centroids_array = checkAndGetColumnConst<ColumnVector<Array>>(centroids_array_untyped);
@@ -191,7 +191,7 @@ protected:
         return true;
     }
 
-    template<typename CentroidsType, typename OutputType>
+    template <typename CentroidsType, typename OutputType>
     bool executeOperation(const IColumn * in_untyped, IColumn * out_untyped, const IColumn * centroids_array_untyped)
     {
         // Match the type of the output
@@ -220,7 +220,7 @@ protected:
         return true;
     }
 
-    template<typename InputType, typename OutputType, typename CentroidsType>
+    template <typename InputType, typename OutputType, typename CentroidsType>
     bool executeOperationTyped(const IColumn * in_untyped, PaddedPODArray<OutputType> & dst, const IColumn * centroids_array_untyped)
     {
         const auto maybe_const = in_untyped->convertToFullColumnIfConst();
diff --git a/dbms/src/Functions/FunctionsHigherOrder.h b/dbms/src/Functions/FunctionsHigherOrder.h
index e09135deeaa..dde39a63924 100644
--- a/dbms/src/Functions/FunctionsHigherOrder.h
+++ b/dbms/src/Functions/FunctionsHigherOrder.h
@@ -331,7 +331,7 @@ struct ArraySumImpl
         throw Exception("arraySum cannot add values of type " + expression_return->getName(), ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
     }
 
-    template <class Element, class Result>
+    template <typename Element, typename Result>
     static bool executeType(const ColumnPtr & mapped, const ColumnArray::Offsets_t & offsets, ColumnPtr & res_ptr)
     {
         const ColumnVector<Element> * column = checkAndGetColumn<ColumnVector<Element>>(&*mapped);
diff --git a/dbms/src/Functions/FunctionsLogical.h b/dbms/src/Functions/FunctionsLogical.h
index 99fcf84a0a8..9d2a9b174db 100644
--- a/dbms/src/Functions/FunctionsLogical.h
+++ b/dbms/src/Functions/FunctionsLogical.h
@@ -24,7 +24,7 @@ namespace ErrorCodes
   * Accept any numeric types, return a UInt8 containing 0 or 1.
   */
 
-template<typename B>
+template <typename B>
 struct AndImpl
 {
     static inline bool isSaturable()
@@ -43,7 +43,7 @@ struct AndImpl
     }
 };
 
-template<typename B>
+template <typename B>
 struct OrImpl
 {
     static inline bool isSaturable()
@@ -62,7 +62,7 @@ struct OrImpl
     }
 };
 
-template<typename B>
+template <typename B>
 struct XorImpl
 {
     static inline bool isSaturable()
@@ -81,7 +81,7 @@ struct XorImpl
     }
 };
 
-template<typename A>
+template <typename A>
 struct NotImpl
 {
     using ResultType = UInt8;
diff --git a/dbms/src/Functions/FunctionsReinterpret.h b/dbms/src/Functions/FunctionsReinterpret.h
index 5f50e364da4..d97ae4d3feb 100644
--- a/dbms/src/Functions/FunctionsReinterpret.h
+++ b/dbms/src/Functions/FunctionsReinterpret.h
@@ -27,7 +27,7 @@ namespace ErrorCodes
   */
 
 
-template<typename Name>
+template <typename Name>
 class FunctionReinterpretAsStringImpl : public IFunction
 {
 public:
@@ -52,7 +52,7 @@ public:
         return std::make_shared<DataTypeString>();
     }
 
-    template<typename T>
+    template <typename T>
     bool executeType(Block & block, const ColumnNumbers & arguments, size_t result)
     {
         if (auto col_from = checkAndGetColumn<ColumnVector<T>>(block.getByPosition(arguments[0]).column.get()))
@@ -112,7 +112,7 @@ public:
 };
 
 
-template<typename ToDataType, typename Name>
+template <typename ToDataType, typename Name>
 class FunctionReinterpretStringAs : public IFunction
 {
 public:
diff --git a/dbms/src/Functions/FunctionsRound.h b/dbms/src/Functions/FunctionsRound.h
index 928030d47c0..3cc5b453337 100644
--- a/dbms/src/Functions/FunctionsRound.h
+++ b/dbms/src/Functions/FunctionsRound.h
@@ -37,7 +37,7 @@ namespace ErrorCodes
     * - N = 0: round to an integer
     */
 
-template<typename A>
+template <typename A>
 struct RoundToExp2Impl
 {
     using ResultType = A;
@@ -48,7 +48,7 @@ struct RoundToExp2Impl
     }
 };
 
-template<>
+template <>
 struct RoundToExp2Impl<Float32>
 {
     using ResultType = Float32;
@@ -59,7 +59,7 @@ struct RoundToExp2Impl<Float32>
     }
 };
 
-template<>
+template <>
 struct RoundToExp2Impl<Float64>
 {
     using ResultType = Float64;
@@ -70,7 +70,7 @@ struct RoundToExp2Impl<Float64>
     }
 };
 
-template<typename A>
+template <typename A>
 struct RoundDurationImpl
 {
     using ResultType = UInt16;
@@ -96,7 +96,7 @@ struct RoundDurationImpl
     }
 };
 
-template<typename A>
+template <typename A>
 struct RoundAgeImpl
 {
     using ResultType = UInt8;
@@ -116,17 +116,17 @@ struct RoundAgeImpl
 /** Quick calculation of the remainder of the division to apply to the rounding of integers.
     * Without verification, because the divisor is always positive.
     */
-template<typename T, typename Enable = void>
+template <typename T, typename Enable = void>
 struct FastModulo;
 
-template<typename T>
+template <typename T>
 struct FastModulo<T, typename std::enable_if<std::is_integral<T>::value>::type>
 {
 private:
-    template<typename InputType, typename Enable = void>
+    template <typename InputType, typename Enable = void>
     struct Extend;
 
-    template<typename InputType>
+    template <typename InputType>
     struct Extend<InputType,
         typename std::enable_if<std::is_same<InputType, Int8>::value
             || std::is_same<InputType, Int16>::value>::type>
@@ -134,7 +134,7 @@ private:
         using Type = Int64;
     };
 
-    template<typename InputType>
+    template <typename InputType>
     struct Extend<InputType,
         typename std::enable_if<std::is_same<InputType, UInt8>::value
             || std::is_same<InputType, UInt16>::value>::type>
@@ -142,7 +142,7 @@ private:
         using Type = UInt64;
     };
 
-    template<typename InputType>
+    template <typename InputType>
     struct Extend<InputType,
         typename std::enable_if<std::is_integral<InputType>::value
             && (sizeof(InputType) >= 4)>::type>
@@ -186,10 +186,10 @@ enum ScaleMode
 
 /** Implementing low-level rounding functions for integer values.
     */
-template<typename T, int rounding_mode, ScaleMode scale_mode, typename Enable = void>
+template <typename T, int rounding_mode, ScaleMode scale_mode, typename Enable = void>
 struct IntegerRoundingComputation;
 
-template<typename T, int rounding_mode, ScaleMode scale_mode>
+template <typename T, int rounding_mode, ScaleMode scale_mode>
 struct IntegerRoundingComputation<T, rounding_mode, scale_mode,
     typename std::enable_if<std::is_integral<T>::value
         && ((scale_mode == PositiveScale) || (scale_mode == ZeroScale))>::type>
@@ -207,7 +207,7 @@ struct IntegerRoundingComputation<T, rounding_mode, scale_mode,
     }
 };
 
-template<typename T>
+template <typename T>
 struct IntegerRoundingComputation<T, _MM_FROUND_NINT, NegativeScale,
     typename std::enable_if<std::is_integral<T>::value>::type>
 {
@@ -234,7 +234,7 @@ struct IntegerRoundingComputation<T, _MM_FROUND_NINT, NegativeScale,
     }
 };
 
-template<typename T>
+template <typename T>
 struct IntegerRoundingComputation<T, _MM_FROUND_CEIL, NegativeScale,
     typename std::enable_if<std::is_integral<T>::value>::type>
 {
@@ -256,7 +256,7 @@ struct IntegerRoundingComputation<T, _MM_FROUND_CEIL, NegativeScale,
     }
 };
 
-template<typename T>
+template <typename T>
 struct IntegerRoundingComputation<T, _MM_FROUND_FLOOR, NegativeScale,
     typename std::enable_if<std::is_integral<T>::value>::type>
 {
@@ -360,10 +360,10 @@ protected:
 
 /** Implementation of low-level round-off functions for floating-point values.
     */
-template<typename T, int rounding_mode, ScaleMode scale_mode>
+template <typename T, int rounding_mode, ScaleMode scale_mode>
 class FloatRoundingComputation;
 
-template<int rounding_mode>
+template <int rounding_mode>
 class FloatRoundingComputation<Float32, rounding_mode, PositiveScale>
     : public BaseFloatRoundingComputation<Float32>
 {
@@ -389,7 +389,7 @@ public:
     }
 };
 
-template<int rounding_mode>
+template <int rounding_mode>
 class FloatRoundingComputation<Float32, rounding_mode, NegativeScale>
     : public BaseFloatRoundingComputation<Float32>
 {
@@ -433,7 +433,7 @@ private:
     }
 };
 
-template<int rounding_mode>
+template <int rounding_mode>
 class FloatRoundingComputation<Float32, rounding_mode, ZeroScale>
     : public BaseFloatRoundingComputation<Float32>
 {
@@ -454,7 +454,7 @@ public:
     }
 };
 
-template<int rounding_mode>
+template <int rounding_mode>
 class FloatRoundingComputation<Float64, rounding_mode, PositiveScale>
     : public BaseFloatRoundingComputation<Float64>
 {
@@ -480,7 +480,7 @@ public:
     }
 };
 
-template<int rounding_mode>
+template <int rounding_mode>
 class FloatRoundingComputation<Float64, rounding_mode, NegativeScale>
     : public BaseFloatRoundingComputation<Float64>
 {
@@ -524,7 +524,7 @@ private:
     }
 };
 
-template<int rounding_mode>
+template <int rounding_mode>
 class FloatRoundingComputation<Float64, rounding_mode, ZeroScale>
     : public BaseFloatRoundingComputation<Float64>
 {
@@ -622,12 +622,12 @@ public:
 
 /** Implementing high-level rounding functions.
     */
-template<typename T, int rounding_mode, ScaleMode scale_mode, typename Enable = void>
+template <typename T, int rounding_mode, ScaleMode scale_mode, typename Enable = void>
 struct FunctionRoundingImpl;
 
 /** Implement high-level rounding functions for integer values.
     */
-template<typename T, int rounding_mode, ScaleMode scale_mode>
+template <typename T, int rounding_mode, ScaleMode scale_mode>
 struct FunctionRoundingImpl<T, rounding_mode, scale_mode,
     typename std::enable_if<std::is_integral<T>::value && (scale_mode != NullScale)>::type>
 {
@@ -659,7 +659,7 @@ public:
 
 /** Implement high-level round-off functions for floating-point values.
     */
-template<typename T, int rounding_mode, ScaleMode scale_mode>
+template <typename T, int rounding_mode, ScaleMode scale_mode>
 struct FunctionRoundingImpl<T, rounding_mode, scale_mode,
     typename std::enable_if<std::is_floating_point<T>::value && (scale_mode != NullScale)>::type>
 {
@@ -739,7 +739,7 @@ public:
 
 /** Implementation of high-level rounding functions in the case when a zero value is returned.
     */
-template<typename T, int rounding_mode, ScaleMode scale_mode>
+template <typename T, int rounding_mode, ScaleMode scale_mode>
 struct FunctionRoundingImpl<T, rounding_mode, scale_mode,
     typename std::enable_if<scale_mode == NullScale>::type>
 {
@@ -761,13 +761,13 @@ namespace
 {
     /// Individual degrees of the number 10.
 
-    template<size_t N>
+    template <size_t N>
     struct PowerOf10
     {
         static const size_t value = 10 * PowerOf10<N - 1>::value;
     };
 
-    template<>
+    template <>
     struct PowerOf10<0>
     {
         static const size_t value = 1;
@@ -776,30 +776,30 @@ namespace
 
 /// Declaring and defining a container containing a table of powers of 10.
 
-template<size_t... TArgs>
+template <size_t... TArgs>
 struct TableContainer
 {
     static const std::array<size_t, sizeof...(TArgs)> values;
 };
 
-template<size_t... TArgs>
+template <size_t... TArgs>
 const std::array<size_t, sizeof...(TArgs)> TableContainer<TArgs...>::values {{ TArgs... }};
 
 /// The generator of the first N degrees.
 
-template<size_t N, size_t... TArgs>
+template <size_t N, size_t... TArgs>
 struct FillArrayImpl
 {
     using result = typename FillArrayImpl<N - 1, PowerOf10<N>::value, TArgs...>::result;
 };
 
-template<size_t... TArgs>
+template <size_t... TArgs>
 struct FillArrayImpl<0, TArgs...>
 {
     using result = TableContainer<PowerOf10<0>::value, TArgs...>;
 };
 
-template<size_t N>
+template <size_t N>
 struct FillArray
 {
     using result = typename FillArrayImpl<N - 1>::result;
@@ -809,10 +809,10 @@ struct FillArray
     * then converts it to a value that can be used in operations of
     * multiplication and division. Therefore, it is called a scale.
     */
-template<typename T, typename U, typename Enable = void>
+template <typename T, typename U, typename Enable = void>
 struct ScaleForRightType;
 
-template<typename T, typename U>
+template <typename T, typename U>
 struct ScaleForRightType<T, U,
     typename std::enable_if<
         std::is_floating_point<T>::value
@@ -857,7 +857,7 @@ struct ScaleForRightType<T, U,
     }
 };
 
-template<typename T, typename U>
+template <typename T, typename U>
 struct ScaleForRightType<T, U,
     typename std::enable_if<
         std::is_floating_point<T>::value
@@ -888,7 +888,7 @@ struct ScaleForRightType<T, U,
     }
 };
 
-template<typename T, typename U>
+template <typename T, typename U>
 struct ScaleForRightType<T, U,
     typename std::enable_if<
         std::is_integral<T>::value
@@ -925,7 +925,7 @@ struct ScaleForRightType<T, U,
     }
 };
 
-template<typename T, typename U>
+template <typename T, typename U>
 struct ScaleForRightType<T, U,
     typename std::enable_if<
         std::is_integral<T>::value
@@ -946,7 +946,7 @@ struct ScaleForRightType<T, U,
 
 /** Turn the precision parameter into a scale.
     */
-template<typename T>
+template <typename T>
 struct ScaleForLeftType
 {
     static inline void apply(const ColumnPtr & column, ScaleMode & scale_mode, size_t & scale)
@@ -1025,7 +1025,7 @@ struct Dispatcher
     * (U)Int8/16/32/64 or Float32/64, and accept an additional optional
     * parameter (default is 0).
     */
-template<typename Name, int rounding_mode>
+template <typename Name, int rounding_mode>
 class FunctionRounding : public IFunction
 {
 public:
@@ -1033,13 +1033,13 @@ public:
     static FunctionPtr create(const Context & context) { return std::make_shared<FunctionRounding>(); }
 
 private:
-    template<typename T>
+    template <typename T>
     bool checkType(const IDataType * type) const
     {
         return typeid_cast<const T *>(type);
     }
 
-    template<typename T>
+    template <typename T>
     bool executeForType(Block & block, const ColumnNumbers & arguments, size_t result)
     {
         if (auto col = checkAndGetColumn<ColumnVector<T>>(block.getByPosition(arguments[0]).column.get()))
diff --git a/dbms/src/Functions/FunctionsVisitParam.h b/dbms/src/Functions/FunctionsVisitParam.h
index 279bb0cf252..4db8f54b559 100644
--- a/dbms/src/Functions/FunctionsVisitParam.h
+++ b/dbms/src/Functions/FunctionsVisitParam.h
@@ -49,7 +49,7 @@ struct HasParam
     }
 };
 
-template<typename NumericType>
+template <typename NumericType>
 struct ExtractNumericType
 {
     using ResultType = NumericType;
@@ -239,7 +239,7 @@ struct ExtractParamImpl
 
 /** For the case where the type of field to extract is a string.
  */
-template<typename ParamExtractor>
+template <typename ParamExtractor>
 struct ExtractParamToStringImpl
 {
     static void vector(const ColumnString::Chars_t & data, const ColumnString::Offsets_t & offsets,
diff --git a/dbms/src/Functions/tests/logical_functions_performance.cpp b/dbms/src/Functions/tests/logical_functions_performance.cpp
index a2d76416a5a..946a2f2d44d 100644
--- a/dbms/src/Functions/tests/logical_functions_performance.cpp
+++ b/dbms/src/Functions/tests/logical_functions_performance.cpp
@@ -18,7 +18,7 @@ namespace ErrorCodes
 }
 
 
-template<typename B>
+template <typename B>
 struct AndImpl
 {
     static inline UInt8 apply(UInt8 a, B b)
@@ -27,7 +27,7 @@ struct AndImpl
     }
 };
 
-template<typename B>
+template <typename B>
 struct OrImpl
 {
     static inline UInt8 apply(UInt8 a, B b)
@@ -36,7 +36,7 @@ struct OrImpl
     }
 };
 
-template<typename B>
+template <typename B>
 struct XorImpl
 {
     static inline UInt8 apply(UInt8 a, B b)
diff --git a/dbms/src/IO/HashingWriteBuffer.cpp b/dbms/src/IO/HashingWriteBuffer.cpp
index be5461578ba..d2461d4f52c 100644
--- a/dbms/src/IO/HashingWriteBuffer.cpp
+++ b/dbms/src/IO/HashingWriteBuffer.cpp
@@ -7,7 +7,7 @@ namespace DB
 
 /// computation of the hash depends on the partitioning of blocks
 /// so you need to compute a hash of n complete pieces and one incomplete
-template <class Buffer>
+template <typename Buffer>
 void IHashingBuffer<Buffer>::calculateHash(DB::BufferBase::Position data, size_t len)
 {
     if (len)
diff --git a/dbms/src/IO/HashingWriteBuffer.h b/dbms/src/IO/HashingWriteBuffer.h
index 55689fbaec6..7a3eb6a172c 100644
--- a/dbms/src/IO/HashingWriteBuffer.h
+++ b/dbms/src/IO/HashingWriteBuffer.h
@@ -11,7 +11,7 @@
 namespace DB
 {
 
-template <class Buffer>
+template <typename Buffer>
 class IHashingBuffer : public BufferWithOwnMemory<Buffer>
 {
 public:
diff --git a/dbms/src/IO/ReadHelpers.cpp b/dbms/src/IO/ReadHelpers.cpp
index 6d9f66307a6..f0bcdee56d4 100644
--- a/dbms/src/IO/ReadHelpers.cpp
+++ b/dbms/src/IO/ReadHelpers.cpp
@@ -19,7 +19,7 @@ namespace ErrorCodes
     extern const int INCORRECT_DATA;
 }
 
-template <class IteratorSrc, class IteratorDst>
+template <typename IteratorSrc, typename IteratorDst>
 void parseHex(IteratorSrc src, IteratorDst dst, const size_t num_bytes)
 {
     size_t src_pos = 0;
diff --git a/dbms/src/IO/ReadHelpers.h b/dbms/src/IO/ReadHelpers.h
index 1c4e93bbd06..9209680a7ed 100644
--- a/dbms/src/IO/ReadHelpers.h
+++ b/dbms/src/IO/ReadHelpers.h
@@ -344,14 +344,14 @@ void readIntTextUnsafe(T & x, ReadBuffer & buf)
         x = -x;
 }
 
-template<typename T>
+template <typename T>
 void tryReadIntTextUnsafe(T & x, ReadBuffer & buf)
 {
     return readIntTextUnsafe<T, false>(x, buf);
 }
 
 
-template <bool throw_exception, class ExcepFun, class NoExcepFun, class... Args>
+template <bool throw_exception, typename ExcepFun, typename NoExcepFun, typename... Args>
 bool exceptionPolicySelector(ExcepFun && excep_f, NoExcepFun && no_excep_f, Args &&... args)
 {
     if (throw_exception)
@@ -482,13 +482,13 @@ ReturnType readFloatTextImpl(T & x, ReadBuffer & buf)
     return ReturnType(true);
 }
 
-template <class T>
+template <typename T>
 inline bool tryReadFloatText(T & x, ReadBuffer & buf)
 {
     return readFloatTextImpl<T, bool>(x, buf);
 }
 
-template <class T>
+template <typename T>
 inline void readFloatText(T & x, ReadBuffer & buf)
 {
     readFloatTextImpl<T, void>(x, buf);
@@ -569,7 +569,7 @@ struct NullSink
 void parseUUID(const UInt8 * src36, UInt8 * dst16);
 void parseUUID(const UInt8 * src36, std::reverse_iterator<UInt8 *> dst16);
 
-template<class IteratorSrc, class IteratorDst>
+template <typename IteratorSrc, typename IteratorDst>
 void formatHex(IteratorSrc src, IteratorDst dst, const size_t num_bytes);
 
 /// In YYYY-MM-DD format
diff --git a/dbms/src/Parsers/ParserCreateQuery.h b/dbms/src/Parsers/ParserCreateQuery.h
index b2987395adc..3aa78f9cc5c 100644
--- a/dbms/src/Parsers/ParserCreateQuery.h
+++ b/dbms/src/Parsers/ParserCreateQuery.h
@@ -56,7 +56,7 @@ protected:
 };
 
 
-template <class NameParser>
+template <typename NameParser>
 class IParserNameTypePair : public IParserBase
 {
 protected:
@@ -69,7 +69,7 @@ using ParserNameTypePair = IParserNameTypePair<ParserIdentifier>;
 /** Name and type separated by a space. The name can contain a dot. For example, Hits.URL String. */
 using ParserCompoundNameTypePair = IParserNameTypePair<ParserCompoundIdentifier>;
 
-template <class NameParser>
+template <typename NameParser>
 bool IParserNameTypePair<NameParser>::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
 {
     NameParser name_parser;
@@ -101,7 +101,7 @@ protected:
 };
 
 
-template <class NameParser>
+template <typename NameParser>
 class IParserColumnDeclaration : public IParserBase
 {
 protected:
@@ -112,7 +112,7 @@ protected:
 using ParserColumnDeclaration = IParserColumnDeclaration<ParserIdentifier>;
 using ParserCompoundColumnDeclaration = IParserColumnDeclaration<ParserCompoundIdentifier>;
 
-template <class NameParser>
+template <typename NameParser>
 bool IParserColumnDeclaration<NameParser>::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
 {
     NameParser name_parser;
diff --git a/dbms/src/Storages/ColumnDefault.h b/dbms/src/Storages/ColumnDefault.h
index 299955a80e8..b7094ab3d64 100644
--- a/dbms/src/Storages/ColumnDefault.h
+++ b/dbms/src/Storages/ColumnDefault.h
@@ -21,7 +21,7 @@ enum class ColumnDefaultType
 
 namespace std
 {
-    template<> struct hash<DB::ColumnDefaultType>
+    template <> struct hash<DB::ColumnDefaultType>
     {
         size_t operator()(const DB::ColumnDefaultType type) const
         {
diff --git a/dbms/src/Storages/MarkCache.h b/dbms/src/Storages/MarkCache.h
index d89b21869a8..3ddef1b3b46 100644
--- a/dbms/src/Storages/MarkCache.h
+++ b/dbms/src/Storages/MarkCache.h
@@ -53,7 +53,7 @@ public:
         return key;
     }
 
-    template<typename LoadFunc>
+    template <typename LoadFunc>
     MappedPtr getOrSet(const Key & key, LoadFunc && load)
     {
         auto result = Base::getOrSet(key, load);
diff --git a/dbms/src/Storages/StorageDictionary.h b/dbms/src/Storages/StorageDictionary.h
index 9ad2998658a..c3f28f31027 100644
--- a/dbms/src/Storages/StorageDictionary.h
+++ b/dbms/src/Storages/StorageDictionary.h
@@ -69,7 +69,7 @@ private:
 
     void checkNamesAndTypesCompatibleWithDictionary(const DictionaryStructure & dictionaryStructure) const;
 
-    template <class ForwardIterator>
+    template <typename ForwardIterator>
     std::string generateNamesAndTypesDescription(ForwardIterator begin, ForwardIterator end) const
     {
         if (begin == end)

From 21fe32b929bd25955007aa998338e069fabbc424 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 15:17:01 +0300
Subject: [PATCH 244/266] Fixed build in clang with raised up inline-depth
 [#CLICKHOUSE-2].

---
 .../MergingSortedBlockInputStream.cpp         | 57 +++++++++++--------
 1 file changed, 32 insertions(+), 25 deletions(-)

diff --git a/dbms/src/DataStreams/MergingSortedBlockInputStream.cpp b/dbms/src/DataStreams/MergingSortedBlockInputStream.cpp
index b6d4e566a74..b35a739e8bd 100644
--- a/dbms/src/DataStreams/MergingSortedBlockInputStream.cpp
+++ b/dbms/src/DataStreams/MergingSortedBlockInputStream.cpp
@@ -174,6 +174,38 @@ Block MergingSortedBlockInputStream::readImpl()
     return merged_block;
 }
 
+
+template <typename TSortCursor>
+void MergingSortedBlockInputStream::fetchNextBlock(const TSortCursor & current, std::priority_queue<TSortCursor> & queue)
+{
+    size_t i = 0;
+    size_t size = cursors.size();
+    for (; i < size; ++i)
+    {
+        if (&cursors[i] == current.impl)
+        {
+            source_blocks[i] = new detail::SharedBlock(children[i]->read());
+            if (*source_blocks[i])
+            {
+                cursors[i].reset(*source_blocks[i]);
+                queue.push(TSortCursor(&cursors[i]));
+            }
+
+            break;
+        }
+    }
+
+    if (i == size)
+        throw Exception("Logical error in MergingSortedBlockInputStream", ErrorCodes::LOGICAL_ERROR);
+}
+
+template
+void MergingSortedBlockInputStream::fetchNextBlock<SortCursor>(const SortCursor & current, std::priority_queue<SortCursor> & queue);
+
+template
+void MergingSortedBlockInputStream::fetchNextBlock<SortCursorWithCollation>(const SortCursorWithCollation & current, std::priority_queue<SortCursorWithCollation> & queue);
+
+
 template <typename TSortCursor>
 void MergingSortedBlockInputStream::merge(Block & merged_block, ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue)
 {
@@ -321,31 +353,6 @@ void MergingSortedBlockInputStream::merge(Block & merged_block, ColumnPlainPtrs
 }
 
 
-template <typename TSortCursor>
-void MergingSortedBlockInputStream::fetchNextBlock(const TSortCursor & current, std::priority_queue<TSortCursor> & queue)
-{
-    size_t i = 0;
-    size_t size = cursors.size();
-    for (; i < size; ++i)
-    {
-        if (&cursors[i] == current.impl)
-        {
-            source_blocks[i] = new detail::SharedBlock(children[i]->read());
-            if (*source_blocks[i])
-            {
-                cursors[i].reset(*source_blocks[i]);
-                queue.push(TSortCursor(&cursors[i]));
-            }
-
-            break;
-        }
-    }
-
-    if (i == size)
-        throw Exception("Logical error in MergingSortedBlockInputStream", ErrorCodes::LOGICAL_ERROR);
-}
-
-
 void MergingSortedBlockInputStream::readSuffixImpl()
 {
      if (quiet)

From 094c18bb46fc5d8ea7cbff80755187b7f4f7e81a Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 16:26:50 +0300
Subject: [PATCH 245/266] Fixed error in boost::filesystem: NULL pointer
 dereference (reproduced with increased inline-depth in clang)
 [#CLICKHOUSE-2].

---
 .../boost_1_65_0/libs/filesystem/src/operations.cpp        | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/contrib/libboost/boost_1_65_0/libs/filesystem/src/operations.cpp b/contrib/libboost/boost_1_65_0/libs/filesystem/src/operations.cpp
index 4114e02a1a3..fb4c8f60973 100644
--- a/contrib/libboost/boost_1_65_0/libs/filesystem/src/operations.cpp
+++ b/contrib/libboost/boost_1_65_0/libs/filesystem/src/operations.cpp
@@ -2394,7 +2394,12 @@ namespace detail
         && (filename.size()== 1
           || (filename[1] == dot
             && filename.size()== 2)))
-        {  it.increment(*ec); }
+        {
+            if (ec)
+                it.increment(*ec);
+            else
+                it.increment();
+        }
     }
   }
 

From bf5ef11933a6f5a44f31601a9d607baae57d06e7 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Fri, 15 Sep 2017 17:30:13 +0300
Subject: [PATCH 246/266] Properly specify inline-depth for clang
 [#CLICKHOUSE-2].

---
 CMakeLists.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ec0d54ca299..ac9b76a009d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -109,7 +109,7 @@ endif ()
 
 # Special options for better optimized code with clang
 if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-    set (CMAKE_CXX_FLAGS_RELWITHDEBINFO  "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -mllvm -inline-threshold=10000")
+    set (CMAKE_CXX_FLAGS_RELWITHDEBINFO  "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -Wno-unused-command-line-argument -mllvm -inline-threshold=10000")
 endif ()
 
 set (CMAKE_BUILD_COLOR_MAKEFILE          ON)

From 3791b93c76e4a2c6c75fc3d2259ce69d327b4736 Mon Sep 17 00:00:00 2001
From: Alexey Zatelepin <ztlpn@yandex-team.ru>
Date: Sat, 16 Sep 2017 01:26:12 +0300
Subject: [PATCH 247/266] remove junk

---
 dbms/tests/clickhouse-test | 2 --
 1 file changed, 2 deletions(-)

diff --git a/dbms/tests/clickhouse-test b/dbms/tests/clickhouse-test
index 43b45e1ec29..1be3175aa7f 100755
--- a/dbms/tests/clickhouse-test
+++ b/dbms/tests/clickhouse-test
@@ -124,8 +124,6 @@ def main(args):
                         print "{0:70}".format(name + ": "),
                         sys.stdout.flush()
                         
-                        print 1/0
-    
                         if not args.zookeeper and 'zookeeper' in name:
                             report_testcase.append(et.Element("skipped", attrib = {"message": "no zookeeper"}))
                             print(MSG_SKIPPED + " - no zookeeper")

From 65ad717938aec1d3e367c99ffcff8caf065fed25 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 16 Sep 2017 18:55:31 +0300
Subject: [PATCH 248/266] Whitespaces [#CLICKHOUSE-2].

---
 dbms/tests/clickhouse-test | 42 +++++++++++++++++++-------------------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/dbms/tests/clickhouse-test b/dbms/tests/clickhouse-test
index 43b45e1ec29..4c7084f845c 100755
--- a/dbms/tests/clickhouse-test
+++ b/dbms/tests/clickhouse-test
@@ -123,9 +123,9 @@ def main(args):
                     try:
                         print "{0:70}".format(name + ": "),
                         sys.stdout.flush()
-                        
+
                         print 1/0
-    
+
                         if not args.zookeeper and 'zookeeper' in name:
                             report_testcase.append(et.Element("skipped", attrib = {"message": "no zookeeper"}))
                             print(MSG_SKIPPED + " - no zookeeper")
@@ -136,27 +136,27 @@ def main(args):
                             reference_file = os.path.join(suite_dir, name) + '.reference'
                             stdout_file = os.path.join(suite_dir, name) + '.stdout'
                             stderr_file = os.path.join(suite_dir, name) + '.stderr'
-    
+
                             if ext == '.sql':
                                 command = "{0} --multiquery < {1} > {2} 2> {3}".format(args.client, case_file, stdout_file, stderr_file)
                             else:
                                 command = "{0} > {1} 2> {2}".format(case_file, stdout_file, stderr_file)
-    
+
                             proc = Popen(command, shell = True)
                             start_time = datetime.now()
                             while (datetime.now() - start_time).total_seconds() < args.timeout and proc.poll() is None:
                                 sleep(0)
-    
+
                             if proc.returncode is None:
                                 try:
                                     proc.kill()
                                 except OSError as e:
                                     if e.errno != ESRCH:
                                         raise
-    
+
                                 failure = et.Element("failure", attrib = {"message": "Timeout"})
                                 report_testcase.append(failure)
-    
+
                                 failures = failures + 1
                                 print("{0} - Timeout!".format(MSG_FAIL))
                             else:
@@ -164,45 +164,45 @@ def main(args):
                                 stdout = unicode(stdout, errors='replace', encoding='utf-8')
                                 stderr = open(stderr_file, 'r').read() if os.path.exists(stderr_file) else ''
                                 stderr = unicode(stderr, errors='replace', encoding='utf-8')
-    
+
                                 if proc.returncode != 0:
                                     failure = et.Element("failure", attrib = {"message": "return code {}".format(proc.returncode)})
                                     report_testcase.append(failure)
-    
+
                                     stdout_element = et.Element("system-out")
                                     stdout_element.text = et.CDATA(stdout)
                                     report_testcase.append(stdout_element)
-    
+
                                     failures = failures + 1
                                     print("{0} - return code {1}".format(MSG_FAIL, proc.returncode))
-    
+
                                     if stderr:
                                         stderr_element = et.Element("system-err")
                                         stderr_element.text = et.CDATA(stderr)
                                         report_testcase.append(stderr_element)
                                         print(stderr)
-    
+
                                     if args.stop and ('Connection refused' in stderr or 'Attempt to read after eof' in stderr) and not 'Received exception from server' in stderr:
                                         SERVER_DIED = True
-    
+
                                 elif stderr:
                                     failure = et.Element("failure", attrib = {"message": "having stderror"})
                                     report_testcase.append(failure)
-    
+
                                     stderr_element = et.Element("system-err")
                                     stderr_element.text = et.CDATA(stderr)
                                     report_testcase.append(stderr_element)
-    
+
                                     failures = failures + 1
                                     print("{0} - having stderror:\n{1}".format(MSG_FAIL, stderr.encode('utf-8')))
                                 elif 'Exception' in stdout:
                                     failure = et.Element("error", attrib = {"message": "having exception"})
                                     report_testcase.append(failure)
-    
+
                                     stdout_element = et.Element("system-out")
                                     stdout_element.text = et.CDATA(stdout)
                                     report_testcase.append(stdout_element)
-    
+
                                     failures = failures + 1
                                     print("{0} - having exception:\n{1}".format(MSG_FAIL, stdout.encode('utf-8')))
                                 elif not os.path.isfile(reference_file):
@@ -211,20 +211,20 @@ def main(args):
                                     print("{0} - no reference file".format(MSG_UNKNOWN))
                                 else:
                                     result_is_different = subprocess.call(['cmp', '-s', reference_file, stdout_file], stdout = PIPE)
-    
+
                                     if result_is_different:
                                         (diff, _) = Popen(['diff', '--side-by-side', reference_file, stdout_file], stdout = PIPE).communicate()
                                         diff = unicode(diff, errors='replace', encoding='utf-8')
-    
+
                                         failure = et.Element("failure", attrib = {"message": "result differs with reference"})
                                         report_testcase.append(failure)
-                                        
+
                                         stdout_element = et.Element("system-out")
                                         try:
                                             stdout_element.text = et.CDATA(diff)
                                         except:
                                             stdout_element.text = et.CDATA(remove_control_characters(diff))
-                                        
+
                                         report_testcase.append(stdout_element)
                                         failures = failures + 1
                                         print("{0} - result differs with reference:\n{1}".format(MSG_FAIL, diff.encode('utf-8')))

From 25f2f032d1cf1935c161cc1d4abc0f9454d09280 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 16 Sep 2017 19:38:27 +0300
Subject: [PATCH 249/266] Added function "trunc"; simplifications
 [#CLICKHOUSE-2].

---
 dbms/src/Functions/FunctionsRound.cpp |   1 +
 dbms/src/Functions/FunctionsRound.h   | 454 ++++++++++----------------
 2 files changed, 175 insertions(+), 280 deletions(-)

diff --git a/dbms/src/Functions/FunctionsRound.cpp b/dbms/src/Functions/FunctionsRound.cpp
index c252787c9aa..f1e6398ae5c 100644
--- a/dbms/src/Functions/FunctionsRound.cpp
+++ b/dbms/src/Functions/FunctionsRound.cpp
@@ -12,6 +12,7 @@ void registerFunctionsRound(FunctionFactory & factory)
     factory.registerFunction<FunctionRound>();
     factory.registerFunction<FunctionCeil>();
     factory.registerFunction<FunctionFloor>();
+    factory.registerFunction<FunctionTrunc>();
 }
 
 }
diff --git a/dbms/src/Functions/FunctionsRound.h b/dbms/src/Functions/FunctionsRound.h
index 3cc5b453337..243685819af 100644
--- a/dbms/src/Functions/FunctionsRound.h
+++ b/dbms/src/Functions/FunctionsRound.h
@@ -12,6 +12,11 @@
     #include <smmintrin.h>
 #endif
 
+/** If you want negative zeros will be replaced by zeros in result of calculations.
+  * Disabled by performance reasons.
+#define NO_NEGATIVE_ZEROS
+  */
+
 
 namespace DB
 {
@@ -113,170 +118,100 @@ struct RoundAgeImpl
     }
 };
 
-/** Quick calculation of the remainder of the division to apply to the rounding of integers.
-    * Without verification, because the divisor is always positive.
-    */
-template <typename T, typename Enable = void>
-struct FastModulo;
-
-template <typename T>
-struct FastModulo<T, typename std::enable_if<std::is_integral<T>::value>::type>
-{
-private:
-    template <typename InputType, typename Enable = void>
-    struct Extend;
-
-    template <typename InputType>
-    struct Extend<InputType,
-        typename std::enable_if<std::is_same<InputType, Int8>::value
-            || std::is_same<InputType, Int16>::value>::type>
-    {
-        using Type = Int64;
-    };
-
-    template <typename InputType>
-    struct Extend<InputType,
-        typename std::enable_if<std::is_same<InputType, UInt8>::value
-            || std::is_same<InputType, UInt16>::value>::type>
-    {
-        using Type = UInt64;
-    };
-
-    template <typename InputType>
-    struct Extend<InputType,
-        typename std::enable_if<std::is_integral<InputType>::value
-            && (sizeof(InputType) >= 4)>::type>
-    {
-        using Type = InputType;
-    };
-
-    using U = typename Extend<T>::Type;
-
-public:
-    using Divisor = std::pair<size_t, typename libdivide::divider<U>>;
-
-    static inline Divisor prepare(size_t b)
-    {
-        return std::make_pair(b, libdivide::divider<U>(b));
-    }
-
-    static inline T compute(T a, const Divisor & divisor)
-    {
-        U val = static_cast<U>(a);
-        U rem = val - (val / divisor.second) * static_cast<U>(divisor.first);
-        return static_cast<T>(rem);
-    }
-};
 
 /** This parameter controls the behavior of the rounding functions.
-    */
-enum ScaleMode
+  */
+enum class ScaleMode
 {
-    PositiveScale,    // round to a number with N decimal places after the decimal point
-    NegativeScale,    // round to an integer with N zero characters
-    ZeroScale,        // round to an integer
-    NullScale         // return zero value
+    Positive,   // round to a number with N decimal places after the decimal point
+    Negative,   // round to an integer with N zero characters
+    Zero,       // round to an integer
+    Null        // return zero value
 };
 
-#if !defined(_MM_FROUND_NINT)
-#define _MM_FROUND_NINT  0
-#define _MM_FROUND_FLOOR 1
-#define _MM_FROUND_CEIL  2
+enum class RoundingMode
+{
+#if __SSE4_1__
+    Round   = _MM_FROUND_TO_NEAREST_INT | _MM_FROUND_NO_EXC,
+    Floor   = _MM_FROUND_TO_NEG_INF | _MM_FROUND_NO_EXC,
+    Ceil    = _MM_FROUND_TO_POS_INF | _MM_FROUND_NO_EXC,
+    Trunc   = _MM_FROUND_TO_ZERO | _MM_FROUND_NO_EXC,
+#else
+    Round   = 8,    /// Values are correspond to above just in case.
+    Floor   = 9,
+    Ceil    = 10,
+    Trunc   = 11,
 #endif
+};
+
 
 /** Implementing low-level rounding functions for integer values.
-    */
-template <typename T, int rounding_mode, ScaleMode scale_mode, typename Enable = void>
-struct IntegerRoundingComputation;
-
-template <typename T, int rounding_mode, ScaleMode scale_mode>
-struct IntegerRoundingComputation<T, rounding_mode, scale_mode,
-    typename std::enable_if<std::is_integral<T>::value
-        && ((scale_mode == PositiveScale) || (scale_mode == ZeroScale))>::type>
+  */
+template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode>
+struct IntegerRoundingComputation
 {
-    using Divisor = int;
-
-    static inline Divisor prepare(size_t scale)
+    template <size_t scale>
+    static inline T computeImpl(T x)
     {
-        return 0;
+        switch (rounding_mode)
+        {
+            case RoundingMode::Trunc:
+                return x / scale * scale;
+            case RoundingMode::Floor:
+                if (x < 0)
+                    x -= scale - 1;
+                return x / scale * scale;
+            case RoundingMode::Ceil:
+                if (x >= 0)
+                    x += scale - 1;
+                return x / scale * scale;
+            case RoundingMode::Round:
+                return (x + scale / 2) / scale * scale;
+        }
     }
 
-    static inline T compute(T in, const Divisor & scale)
+    static inline T compute(T x, size_t scale)
     {
-        return in;
+        switch (scale_mode)
+        {
+            case ScaleMode::Null:
+                return 0;
+            case ScaleMode::Zero:
+                return x;
+            case ScaleMode::Positive:
+                return x;
+            case ScaleMode::Negative:
+            {
+                switch (scale)
+                {
+                    case 10ULL: return computeImpl<10ULL>(x);
+                    case 100ULL: return computeImpl<100ULL>(x);
+                    case 1000ULL: return computeImpl<1000ULL>(x);
+                    case 10000ULL: return computeImpl<10000ULL>(x);
+                    case 100000ULL: return computeImpl<100000ULL>(x);
+                    case 1000000ULL: return computeImpl<1000000ULL>(x);
+                    case 10000000ULL: return computeImpl<10000000ULL>(x);
+                    case 100000000ULL: return computeImpl<100000000ULL>(x);
+                    case 1000000000ULL: return computeImpl<1000000000ULL>(x);
+                    case 10000000000ULL: return computeImpl<10000000000ULL>(x);
+                    case 100000000000ULL: return computeImpl<100000000000ULL>(x);
+                    case 1000000000000ULL: return computeImpl<1000000000000ULL>(x);
+                    case 10000000000000ULL: return computeImpl<10000000000000ULL>(x);
+                    case 100000000000000ULL: return computeImpl<100000000000000ULL>(x);
+                    case 1000000000000000ULL: return computeImpl<1000000000000000ULL>(x);
+                    case 10000000000000000ULL: return computeImpl<10000000000000000ULL>(x);
+                    case 100000000000000000ULL: return computeImpl<100000000000000000ULL>(x);
+                    case 1000000000000000000ULL: return computeImpl<1000000000000000000ULL>(x);
+                    case 10000000000000000000ULL: return computeImpl<10000000000000000000ULL>(x);
+                    default:
+                        throw Exception("Logical error: unexpected 'scale' parameter passed to function IntegerRoundingComputation::compute",
+                            ErrorCodes::LOGICAL_ERROR);
+                }
+            }
+        }
     }
 };
 
-template <typename T>
-struct IntegerRoundingComputation<T, _MM_FROUND_NINT, NegativeScale,
-    typename std::enable_if<std::is_integral<T>::value>::type>
-{
-    using Op = FastModulo<T>;
-    using Divisor = typename Op::Divisor;
-
-    static inline Divisor prepare(size_t scale)
-    {
-        return Op::prepare(scale);
-    }
-
-    static inline T compute(T in, const Divisor & scale)
-    {
-        T factor = (in < 0) ? -1 : 1;
-        in *= factor;
-        T rem = Op::compute(in, scale);
-        in -= rem;
-        T res;
-        if ((2 * rem) < static_cast<T>(scale.first))
-            res = in;
-        else
-            res = in + scale.first;
-        return factor * res;
-    }
-};
-
-template <typename T>
-struct IntegerRoundingComputation<T, _MM_FROUND_CEIL, NegativeScale,
-    typename std::enable_if<std::is_integral<T>::value>::type>
-{
-    using Op = FastModulo<T>;
-    using Divisor = typename Op::Divisor;
-
-    static inline Divisor prepare(size_t scale)
-    {
-        return Op::prepare(scale);
-    }
-
-    static inline T compute(T in, const Divisor & scale)
-    {
-        T factor = (in < 0) ? -1 : 1;
-        in *= factor;
-        T rem = Op::compute(in, scale);
-        T res = in - rem + scale.first;
-        return factor * res;
-    }
-};
-
-template <typename T>
-struct IntegerRoundingComputation<T, _MM_FROUND_FLOOR, NegativeScale,
-    typename std::enable_if<std::is_integral<T>::value>::type>
-{
-    using Op = FastModulo<T>;
-    using Divisor = typename Op::Divisor;
-
-    static inline Divisor prepare(size_t scale)
-    {
-        return Op::prepare(scale);
-    }
-
-    static inline T compute(T in, const Divisor & scale)
-    {
-        T factor = (in < 0) ? -1 : 1;
-        in *= factor;
-        T rem = Op::compute(in, scale);
-        T res = in - rem;
-        return factor * res;
-    }
-};
 
 #if __SSE4_1__
 template <typename T>
@@ -290,17 +225,6 @@ public:
     static const size_t data_count = 4;
 
 protected:
-    /// Prevent the appearance of negative zeros defined in the IEEE-754 standard.
-    static inline void normalize(__m128 & val, const __m128 & mask)
-    {
-        __m128 mask1 = _mm_cmpeq_ps(val, getZero());
-        __m128 mask2 = _mm_and_ps(mask, mask1);
-        mask2 = _mm_cmpeq_ps(mask2, getZero());
-        mask2 = _mm_min_ps(mask2, getTwo());
-        mask2 = _mm_sub_ps(mask2, getOne());
-        val = _mm_mul_ps(val, mask2);
-    }
-
     static inline const __m128 & getZero()
     {
         static const __m128 zero = _mm_set1_ps(0.0);
@@ -328,17 +252,6 @@ public:
     static const size_t data_count = 2;
 
 protected:
-    /// Prevent the occurrence of negative zeros defined in the IEEE-754 standard.
-    static inline void normalize(__m128d & val, const __m128d & mask)
-    {
-        __m128d mask1 = _mm_cmpeq_pd(val, getZero());
-        __m128d mask2 = _mm_and_pd(mask, mask1);
-        mask2 = _mm_cmpeq_pd(mask2, getZero());
-        mask2 = _mm_min_pd(mask2, getTwo());
-        mask2 = _mm_sub_pd(mask2, getOne());
-        val = _mm_mul_pd(val, mask2);
-    }
-
     static inline const __m128d & getZero()
     {
         static const __m128d zero = _mm_set1_pd(0.0);
@@ -360,11 +273,11 @@ protected:
 
 /** Implementation of low-level round-off functions for floating-point values.
     */
-template <typename T, int rounding_mode, ScaleMode scale_mode>
+template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode>
 class FloatRoundingComputation;
 
-template <int rounding_mode>
-class FloatRoundingComputation<Float32, rounding_mode, PositiveScale>
+template <RoundingMode rounding_mode>
+class FloatRoundingComputation<Float32, rounding_mode, ScaleMode::Positive>
     : public BaseFloatRoundingComputation<Float32>
 {
 public:
@@ -377,20 +290,18 @@ public:
     static inline void compute(const Float32 * __restrict in, const Scale & scale, Float32 * __restrict out)
     {
         __m128 val = _mm_loadu_ps(in);
-        __m128 mask = _mm_cmplt_ps(val, getZero());
 
         /// Rounding algorithm.
         val = _mm_mul_ps(val, scale);
-        val = _mm_round_ps(val, rounding_mode);
+        val = _mm_round_ps(val, int(rounding_mode));
         val = _mm_div_ps(val, scale);
 
-        normalize(val, mask);
         _mm_storeu_ps(out, val);
     }
 };
 
-template <int rounding_mode>
-class FloatRoundingComputation<Float32, rounding_mode, NegativeScale>
+template <RoundingMode rounding_mode>
+class FloatRoundingComputation<Float32, rounding_mode, ScaleMode::Negative>
     : public BaseFloatRoundingComputation<Float32>
 {
 public:
@@ -403,23 +314,22 @@ public:
     static inline void compute(const Float32 * __restrict in, const Scale & scale, Float32 * __restrict out)
     {
         __m128 val = _mm_loadu_ps(in);
-        __m128 mask = _mm_cmplt_ps(val, getZero());
 
         /// Turn negative values into positive values.
-        __m128 factor = _mm_cmpge_ps(val, getZero());
-        factor = _mm_min_ps(factor, getTwo());
-        factor = _mm_sub_ps(factor, getOne());
-        val = _mm_mul_ps(val, factor);
+        __m128 sign = _mm_cmpge_ps(val, getZero());
+        sign = _mm_min_ps(sign, getTwo());
+        sign = _mm_sub_ps(sign, getOne());
+        val = _mm_mul_ps(val, sign);
 
         /// Rounding algorithm.
         val = _mm_div_ps(val, scale);
         __m128 res = _mm_cmpge_ps(val, getOneTenth());
-        val = _mm_round_ps(val, rounding_mode);
+        val = _mm_round_ps(val, int(rounding_mode));
         val = _mm_mul_ps(val, scale);
         val = _mm_and_ps(val, res);
 
         /// Return the real signs of all values.
-        val = _mm_mul_ps(val, factor);
+        val = _mm_mul_ps(val, sign);
 
         normalize(val, mask);
         _mm_storeu_ps(out, val);
@@ -433,8 +343,8 @@ private:
     }
 };
 
-template <int rounding_mode>
-class FloatRoundingComputation<Float32, rounding_mode, ZeroScale>
+template <RoundingMode rounding_mode>
+class FloatRoundingComputation<Float32, rounding_mode, ScaleMode::Zero>
     : public BaseFloatRoundingComputation<Float32>
 {
 public:
@@ -445,17 +355,13 @@ public:
     static inline void compute(const Float32 * __restrict in, const Scale & scale, Float32 * __restrict out)
     {
         __m128 val = _mm_loadu_ps(in);
-        __m128 mask = _mm_cmplt_ps(val, getZero());
-
-        val = _mm_round_ps(val, rounding_mode);
-
-        normalize(val, mask);
+        val = _mm_round_ps(val, int(rounding_mode));
         _mm_storeu_ps(out, val);
     }
 };
 
-template <int rounding_mode>
-class FloatRoundingComputation<Float64, rounding_mode, PositiveScale>
+template <RoundingMode rounding_mode>
+class FloatRoundingComputation<Float64, rounding_mode, ScaleMode::Positive>
     : public BaseFloatRoundingComputation<Float64>
 {
 public:
@@ -468,20 +374,18 @@ public:
     static inline void compute(const Float64 * __restrict in, const Scale & scale, Float64 * __restrict out)
     {
         __m128d val = _mm_loadu_pd(in);
-        __m128d mask = _mm_cmplt_pd(val, getZero());
 
         /// Rounding algorithm.
         val = _mm_mul_pd(val, scale);
-        val = _mm_round_pd(val, rounding_mode);
+        val = _mm_round_pd(val, int(rounding_mode));
         val = _mm_div_pd(val, scale);
 
-        normalize(val, mask);
         _mm_storeu_pd(out, val);
     }
 };
 
-template <int rounding_mode>
-class FloatRoundingComputation<Float64, rounding_mode, NegativeScale>
+template <RoundingMode rounding_mode>
+class FloatRoundingComputation<Float64, rounding_mode, ScaleMode::Negative>
     : public BaseFloatRoundingComputation<Float64>
 {
 public:
@@ -494,25 +398,23 @@ public:
     static inline void compute(const Float64 * __restrict in, const Scale & scale, Float64 * __restrict out)
     {
         __m128d val = _mm_loadu_pd(in);
-        __m128d mask = _mm_cmplt_pd(val, getZero());
 
         /// Turn negative values into positive values.
-        __m128d factor = _mm_cmpge_pd(val, getZero());
-        factor = _mm_min_pd(factor, getTwo());
-        factor = _mm_sub_pd(factor, getOne());
-        val = _mm_mul_pd(val, factor);
+        __m128d sign = _mm_cmpge_pd(val, getZero());
+        sign = _mm_min_pd(sign, getTwo());
+        sign = _mm_sub_pd(sign, getOne());
+        val = _mm_mul_pd(val, sign);
 
         /// Rounding algorithm.
         val = _mm_div_pd(val, scale);
         __m128d res = _mm_cmpge_pd(val, getOneTenth());
-        val = _mm_round_pd(val, rounding_mode);
+        val = _mm_round_pd(val, int(rounding_mode));
         val = _mm_mul_pd(val, scale);
         val = _mm_and_pd(val, res);
 
         /// Return the real signs of all values.
-        val = _mm_mul_pd(val, factor);
+        val = _mm_mul_pd(val, sign);
 
-        normalize(val, mask);
         _mm_storeu_pd(out, val);
     }
 
@@ -524,8 +426,8 @@ private:
     }
 };
 
-template <int rounding_mode>
-class FloatRoundingComputation<Float64, rounding_mode, ZeroScale>
+template <RoundingMode rounding_mode>
+class FloatRoundingComputation<Float64, rounding_mode, ScaleMode::Zero>
     : public BaseFloatRoundingComputation<Float64>
 {
 public:
@@ -536,34 +438,26 @@ public:
     static inline void compute(const Float64 * __restrict in, const Scale & scale, Float64 * __restrict out)
     {
         __m128d val = _mm_loadu_pd(in);
-        __m128d mask = _mm_cmplt_pd(val, getZero());
-
-        val = _mm_round_pd(val, rounding_mode);
-
-        normalize(val, mask);
+        val = _mm_round_pd(val, int(rounding_mode));
         _mm_storeu_pd(out, val);
     }
 };
 #else
+
 /// Implementation for ARM. Not vectorized. Does not fix negative zeros.
 
-template <int mode>
-float roundWithMode(float x)
-{
-    if (mode == _MM_FROUND_NINT)     return roundf(x);
-    if (mode == _MM_FROUND_FLOOR)     return floorf(x);
-    if (mode == _MM_FROUND_CEIL)     return ceilf(x);
-    __builtin_unreachable();
-}
+template <RoundingMode rounding_mode> float roundWithMode(float x);
+template <> float roundWithMode<RoundingMode::Round>(float x) { return roundf(x); }
+template <> float roundWithMode<RoundingMode::Floor>(float x) { return floorf(x); }
+template <> float roundWithMode<RoundingMode::Ceil>(float x) { return ceilf(x); }
+template <> float roundWithMode<RoundingMode::Trunc>(float x) { return truncf(x); }
+
+template <RoundingMode rounding_mode> double roundWithMode(double x);
+template <> double roundWithMode<RoundingMode::Round>(double x) { return round(x); }
+template <> double roundWithMode<RoundingMode::Floor>(double x) { return floor(x); }
+template <> double roundWithMode<RoundingMode::Ceil>(double x) { return ceil(x); }
+template <> double roundWithMode<RoundingMode::Trunc>(double x) { return trunc(x); }
 
-template <int mode>
-double roundWithMode(double x)
-{
-    if (mode == _MM_FROUND_NINT)     return round(x);
-    if (mode == _MM_FROUND_FLOOR)     return floor(x);
-    if (mode == _MM_FROUND_CEIL)     return ceil(x);
-    __builtin_unreachable();
-}
 
 template <typename T>
 class BaseFloatRoundingComputation
@@ -578,11 +472,11 @@ public:
     }
 };
 
-template <typename T, int rounding_mode, ScaleMode scale_mode>
+template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode>
 class FloatRoundingComputation;
 
-template <typename T, int rounding_mode>
-class FloatRoundingComputation<T, rounding_mode, PositiveScale>
+template <typename T, RoundingMode rounding_mode>
+class FloatRoundingComputation<T, rounding_mode, ScaleMode::Positive>
     : public BaseFloatRoundingComputation<T>
 {
 public:
@@ -592,8 +486,8 @@ public:
     }
 };
 
-template <typename T, int rounding_mode>
-class FloatRoundingComputation<T, rounding_mode, NegativeScale>
+template <typename T, RoundingMode rounding_mode>
+class FloatRoundingComputation<T, rounding_mode, ScaleMode::Negative>
     : public BaseFloatRoundingComputation<T>
 {
 public:
@@ -603,8 +497,8 @@ public:
     }
 };
 
-template <typename T, int rounding_mode>
-class FloatRoundingComputation<T, rounding_mode, ZeroScale>
+template <typename T, RoundingMode rounding_mode>
+class FloatRoundingComputation<T, rounding_mode, ScaleMode::Zero>
     : public BaseFloatRoundingComputation<T>
 {
 public:
@@ -621,15 +515,15 @@ public:
 
 
 /** Implementing high-level rounding functions.
-    */
-template <typename T, int rounding_mode, ScaleMode scale_mode, typename Enable = void>
+  */
+template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode, typename Enable = void>
 struct FunctionRoundingImpl;
 
 /** Implement high-level rounding functions for integer values.
-    */
-template <typename T, int rounding_mode, ScaleMode scale_mode>
+  */
+template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode>
 struct FunctionRoundingImpl<T, rounding_mode, scale_mode,
-    typename std::enable_if<std::is_integral<T>::value && (scale_mode != NullScale)>::type>
+    typename std::enable_if<std::is_integral<T>::value && (scale_mode != ScaleMode::Null)>::type>
 {
 private:
     using Op = IntegerRoundingComputation<T, rounding_mode, scale_mode>;
@@ -637,31 +531,28 @@ private:
 public:
     static inline void apply(const PaddedPODArray<T> & in, size_t scale, typename ColumnVector<T>::Container_t & out)
     {
-        auto divisor = Op::prepare(scale);
-
         const T* begin_in = &in[0];
         const T* end_in = begin_in + in.size();
 
         T* __restrict p_out = &out[0];
         for (const T* __restrict p_in = begin_in; p_in != end_in; ++p_in)
         {
-            *p_out = Op::compute(*p_in, divisor);
+            *p_out = Op::compute(*p_in, scale);
             ++p_out;
         }
     }
 
     static inline T apply(T val, size_t scale)
     {
-        auto divisor = Op::prepare(scale);
-        return Op::compute(val, divisor);
+        return Op::compute(val, scale);
     }
 };
 
 /** Implement high-level round-off functions for floating-point values.
-    */
-template <typename T, int rounding_mode, ScaleMode scale_mode>
+  */
+template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode>
 struct FunctionRoundingImpl<T, rounding_mode, scale_mode,
-    typename std::enable_if<std::is_floating_point<T>::value && (scale_mode != NullScale)>::type>
+    typename std::enable_if<std::is_floating_point<T>::value && (scale_mode != ScaleMode::Null)>::type>
 {
 private:
     using Op = FloatRoundingComputation<T, rounding_mode, scale_mode>;
@@ -739,9 +630,9 @@ public:
 
 /** Implementation of high-level rounding functions in the case when a zero value is returned.
     */
-template <typename T, int rounding_mode, ScaleMode scale_mode>
+template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode>
 struct FunctionRoundingImpl<T, rounding_mode, scale_mode,
-    typename std::enable_if<scale_mode == NullScale>::type>
+    typename std::enable_if<scale_mode == ScaleMode::Null>::type>
 {
 public:
     static inline void apply(const PaddedPODArray<T> & in, size_t scale, typename ColumnVector<T>::Container_t & out)
@@ -806,9 +697,9 @@ struct FillArray
 };
 
 /** This pattern defines the precision that the round/ceil/floor functions use,
-    * then converts it to a value that can be used in operations of
-    * multiplication and division. Therefore, it is called a scale.
-    */
+  * then converts it to a value that can be used in operations of
+  * multiplication and division. Therefore, it is called a scale.
+  */
 template <typename T, typename U, typename Enable = void>
 struct ScaleForRightType;
 
@@ -831,23 +722,23 @@ struct ScaleForRightType<T, U,
         {
             if (val < -static_cast<U>(std::numeric_limits<T>::digits10))
             {
-                scale_mode = NullScale;
+                scale_mode = ScaleMode::Null;
                 scale = 1;
             }
             else
             {
-                scale_mode = NegativeScale;
+                scale_mode = ScaleMode::Negative;
                 scale = PowersOf10::values[-val];
             }
         }
         else if (val == 0)
         {
-            scale_mode = ZeroScale;
+            scale_mode = ScaleMode::Zero;
             scale = 1;
         }
         else
         {
-            scale_mode = PositiveScale;
+            scale_mode = ScaleMode::Positive;
             if (val > std::numeric_limits<T>::digits10)
                 val = static_cast<U>(std::numeric_limits<T>::digits10);
             scale = PowersOf10::values[val];
@@ -873,12 +764,12 @@ struct ScaleForRightType<T, U,
         U val = precision_col->template getValue<U>();
         if (val == 0)
         {
-            scale_mode = ZeroScale;
+            scale_mode = ScaleMode::Zero;
             scale = 1;
         }
         else
         {
-            scale_mode = PositiveScale;
+            scale_mode = ScaleMode::Positive;
             if (val > static_cast<U>(std::numeric_limits<T>::digits10))
                 val = static_cast<U>(std::numeric_limits<T>::digits10);
             scale = PowersOf10::values[val];
@@ -906,18 +797,18 @@ struct ScaleForRightType<T, U,
         {
             if (val < -std::numeric_limits<T>::digits10)
             {
-                scale_mode = NullScale;
+                scale_mode = ScaleMode::Null;
                 scale = 1;
             }
             else
             {
-                scale_mode = NegativeScale;
+                scale_mode = ScaleMode::Negative;
                 scale = PowersOf10::values[-val];
             }
         }
         else
         {
-            scale_mode = ZeroScale;
+            scale_mode = ScaleMode::Zero;
             scale = 1;
         }
 
@@ -937,7 +828,7 @@ struct ScaleForRightType<T, U,
         if (!precision_col)
             return false;
 
-        scale_mode = ZeroScale;
+        scale_mode = ScaleMode::Zero;
         scale = 1;
 
         return true;
@@ -970,7 +861,7 @@ struct ScaleForLeftType
 
 /** The main template that applies the rounding function to a value or column.
     */
-template <typename T, int rounding_mode, ScaleMode scale_mode>
+template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode>
 struct Cruncher
 {
     using Op = FunctionRoundingImpl<T, rounding_mode, scale_mode>;
@@ -992,7 +883,7 @@ struct Cruncher
 
 /** Select the appropriate processing algorithm depending on the scale.
   */
-template <typename T, typename ColumnType, int rounding_mode>
+template <typename T, typename ColumnType, RoundingMode rounding_mode>
 struct Dispatcher
 {
     static inline void apply(Block & block, const ColumnType * col, const ColumnNumbers & arguments, size_t result)
@@ -1004,18 +895,18 @@ struct Dispatcher
             ScaleForLeftType<T>::apply(block.getByPosition(arguments[1]).column, scale_mode, scale);
         else
         {
-            scale_mode = ZeroScale;
+            scale_mode = ScaleMode::Zero;
             scale = 1;
         }
 
-        if (scale_mode == PositiveScale)
-            Cruncher<T, rounding_mode, PositiveScale>::apply(block, col, arguments, result, scale);
-        else if (scale_mode == ZeroScale)
-            Cruncher<T, rounding_mode, ZeroScale>::apply(block, col, arguments, result, scale);
-        else if (scale_mode == NegativeScale)
-            Cruncher<T, rounding_mode, NegativeScale>::apply(block, col, arguments, result, scale);
-        else if (scale_mode == NullScale)
-            Cruncher<T, rounding_mode, NullScale>::apply(block, col, arguments, result, scale);
+        if (scale_mode == ScaleMode::Positive)
+            Cruncher<T, rounding_mode, ScaleMode::Positive>::apply(block, col, arguments, result, scale);
+        else if (scale_mode == ScaleMode::Zero)
+            Cruncher<T, rounding_mode, ScaleMode::Zero>::apply(block, col, arguments, result, scale);
+        else if (scale_mode == ScaleMode::Negative)
+            Cruncher<T, rounding_mode, ScaleMode::Negative>::apply(block, col, arguments, result, scale);
+        else if (scale_mode == ScaleMode::Null)
+            Cruncher<T, rounding_mode, ScaleMode::Null>::apply(block, col, arguments, result, scale);
         else
             throw Exception("Illegal operation", ErrorCodes::LOGICAL_ERROR);
     }
@@ -1025,7 +916,7 @@ struct Dispatcher
     * (U)Int8/16/32/64 or Float32/64, and accept an additional optional
     * parameter (default is 0).
     */
-template <typename Name, int rounding_mode>
+template <typename Name, RoundingMode rounding_mode>
 class FunctionRounding : public IFunction
 {
 public:
@@ -1130,17 +1021,20 @@ public:
 struct NameRoundToExp2 { static constexpr auto name = "roundToExp2"; };
 struct NameRoundDuration { static constexpr auto name = "roundDuration"; };
 struct NameRoundAge { static constexpr auto name = "roundAge"; };
+
 struct NameRound { static constexpr auto name = "round"; };
 struct NameCeil { static constexpr auto name = "ceil"; };
 struct NameFloor { static constexpr auto name = "floor"; };
+struct NameTrunc { static constexpr auto name = "trunc"; };
 
 using FunctionRoundToExp2 = FunctionUnaryArithmetic<RoundToExp2Impl, NameRoundToExp2, false>;
 using FunctionRoundDuration = FunctionUnaryArithmetic<RoundDurationImpl, NameRoundDuration, false>;
 using FunctionRoundAge = FunctionUnaryArithmetic<RoundAgeImpl, NameRoundAge, false>;
 
-using FunctionRound = FunctionRounding<NameRound, _MM_FROUND_NINT>;
-using FunctionFloor = FunctionRounding<NameFloor, _MM_FROUND_FLOOR>;
-using FunctionCeil = FunctionRounding<NameCeil, _MM_FROUND_CEIL>;
+using FunctionRound = FunctionRounding<NameRound, RoundingMode::Round>;
+using FunctionFloor = FunctionRounding<NameFloor, RoundingMode::Floor>;
+using FunctionCeil = FunctionRounding<NameCeil, RoundingMode::Ceil>;
+using FunctionTrunc = FunctionRounding<NameTrunc, RoundingMode::Trunc>;
 
 
 struct PositiveMonotonicity

From 000250759881b7309da88c4994bf6728c2fb22cc Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 16 Sep 2017 19:47:05 +0300
Subject: [PATCH 250/266] Added function "trunc"; simplifications
 [#CLICKHOUSE-2].

---
 dbms/src/Functions/FunctionsRound.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/dbms/src/Functions/FunctionsRound.h b/dbms/src/Functions/FunctionsRound.h
index 243685819af..df46b2390db 100644
--- a/dbms/src/Functions/FunctionsRound.h
+++ b/dbms/src/Functions/FunctionsRound.h
@@ -331,7 +331,6 @@ public:
         /// Return the real signs of all values.
         val = _mm_mul_ps(val, sign);
 
-        normalize(val, mask);
         _mm_storeu_ps(out, val);
     }
 

From ad13a8c79d6751a9bc3ba07a74bccb334b03fd6c Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 16 Sep 2017 21:36:16 +0300
Subject: [PATCH 251/266] Fixed half of bad code [#CLICKHOUSE-2].

---
 dbms/src/Columns/ColumnConst.h      |   2 +-
 dbms/src/Functions/FunctionsRound.h | 786 ++++++----------------------
 2 files changed, 150 insertions(+), 638 deletions(-)

diff --git a/dbms/src/Columns/ColumnConst.h b/dbms/src/Columns/ColumnConst.h
index 16afaee1c4f..8db8ba06830 100644
--- a/dbms/src/Columns/ColumnConst.h
+++ b/dbms/src/Columns/ColumnConst.h
@@ -19,7 +19,7 @@ namespace ErrorCodes
 /** ColumnConst contains another column with single element,
   *  but looks like a column with arbitary amount of same elements.
   */
-class ColumnConst : public IColumn
+class ColumnConst final : public IColumn
 {
 private:
     ColumnPtr data;
diff --git a/dbms/src/Functions/FunctionsRound.h b/dbms/src/Functions/FunctionsRound.h
index df46b2390db..01447e0c675 100644
--- a/dbms/src/Functions/FunctionsRound.h
+++ b/dbms/src/Functions/FunctionsRound.h
@@ -126,7 +126,6 @@ enum class ScaleMode
     Positive,   // round to a number with N decimal places after the decimal point
     Negative,   // round to an integer with N zero characters
     Zero,       // round to an integer
-    Null        // return zero value
 };
 
 enum class RoundingMode
@@ -150,6 +149,13 @@ enum class RoundingMode
 template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode>
 struct IntegerRoundingComputation
 {
+    static const size_t data_count = 1;
+
+    static size_t prepare(size_t scale)
+    {
+        return scale;
+    }
+
     template <size_t scale>
     static inline T computeImpl(T x)
     {
@@ -174,8 +180,6 @@ struct IntegerRoundingComputation
     {
         switch (scale_mode)
         {
-            case ScaleMode::Null:
-                return 0;
             case ScaleMode::Zero:
                 return x;
             case ScaleMode::Positive:
@@ -210,10 +214,17 @@ struct IntegerRoundingComputation
             }
         }
     }
+
+    static inline void compute(const T * __restrict in, size_t scale, T * __restrict out)
+    {
+        *out = compute(*in, scale);
+    }
+
 };
 
 
 #if __SSE4_1__
+
 template <typename T>
 class BaseFloatRoundingComputation;
 
@@ -221,26 +232,20 @@ template <>
 class BaseFloatRoundingComputation<Float32>
 {
 public:
-    using Scale = __m128;
+    using ScalarType = Float32;
+    using VectorType = __m128;
     static const size_t data_count = 4;
 
-protected:
-    static inline const __m128 & getZero()
-    {
-        static const __m128 zero = _mm_set1_ps(0.0);
-        return zero;
-    }
+    static VectorType load(const ScalarType * in) { return _mm_loadu_ps(in); }
+    static VectorType load1(const ScalarType in) { return _mm_load1_ps(&in); }
+    static void store(ScalarType * out, VectorType val) { _mm_storeu_ps(out, val);}
+    static VectorType multiply(VectorType val, VectorType scale) { return _mm_mul_ps(val, scale); }
+    static VectorType divide(VectorType val, VectorType scale) { return _mm_div_ps(val, scale); }
+    template <RoundingMode mode> static VectorType apply(VectorType val) { return _mm_round_ps(val, int(mode)); }
 
-    static inline const __m128 & getOne()
+    static VectorType prepare(size_t scale)
     {
-        static const __m128 one = _mm_set1_ps(1.0);
-        return one;
-    }
-
-    static inline const __m128 & getTwo()
-    {
-        static const __m128 two = _mm_set1_ps(2.0);
-        return two;
+        return load1(scale);
     }
 };
 
@@ -248,625 +253,170 @@ template <>
 class BaseFloatRoundingComputation<Float64>
 {
 public:
-    using Scale = __m128d;
+    using ScalarType = Float64;
+    using VectorType = __m128d;
     static const size_t data_count = 2;
 
-protected:
-    static inline const __m128d & getZero()
-    {
-        static const __m128d zero = _mm_set1_pd(0.0);
-        return zero;
-    }
+    static VectorType load(const ScalarType * in) { return _mm_loadu_pd(in); }
+    static VectorType load1(const ScalarType in) { return _mm_load1_pd(&in); }
+    static void store(ScalarType * out, VectorType val) { _mm_storeu_pd(out, val);}
+    static VectorType multiply(VectorType val, VectorType scale) { return _mm_mul_pd(val, scale); }
+    static VectorType divide(VectorType val, VectorType scale) { return _mm_div_pd(val, scale); }
+    template <RoundingMode mode> static VectorType apply(VectorType val) { return _mm_round_pd(val, int(mode)); }
 
-    static inline const __m128d & getOne()
+    static VectorType prepare(size_t scale)
     {
-        static const __m128d one = _mm_set1_pd(1.0);
-        return one;
-    }
-
-    static inline const __m128d & getTwo()
-    {
-        static const __m128d two = _mm_set1_pd(2.0);
-        return two;
+        return load1(scale);
     }
 };
 
-/** Implementation of low-level round-off functions for floating-point values.
-    */
-template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode>
-class FloatRoundingComputation;
-
-template <RoundingMode rounding_mode>
-class FloatRoundingComputation<Float32, rounding_mode, ScaleMode::Positive>
-    : public BaseFloatRoundingComputation<Float32>
-{
-public:
-    static inline void prepare(size_t scale, Scale & mm_scale)
-    {
-        Float32 fscale = static_cast<Float32>(scale);
-        mm_scale = _mm_load1_ps(&fscale);
-    }
-
-    static inline void compute(const Float32 * __restrict in, const Scale & scale, Float32 * __restrict out)
-    {
-        __m128 val = _mm_loadu_ps(in);
-
-        /// Rounding algorithm.
-        val = _mm_mul_ps(val, scale);
-        val = _mm_round_ps(val, int(rounding_mode));
-        val = _mm_div_ps(val, scale);
-
-        _mm_storeu_ps(out, val);
-    }
-};
-
-template <RoundingMode rounding_mode>
-class FloatRoundingComputation<Float32, rounding_mode, ScaleMode::Negative>
-    : public BaseFloatRoundingComputation<Float32>
-{
-public:
-    static inline void prepare(size_t scale, Scale & mm_scale)
-    {
-        Float32 fscale = static_cast<Float32>(scale);
-        mm_scale = _mm_load1_ps(&fscale);
-    }
-
-    static inline void compute(const Float32 * __restrict in, const Scale & scale, Float32 * __restrict out)
-    {
-        __m128 val = _mm_loadu_ps(in);
-
-        /// Turn negative values into positive values.
-        __m128 sign = _mm_cmpge_ps(val, getZero());
-        sign = _mm_min_ps(sign, getTwo());
-        sign = _mm_sub_ps(sign, getOne());
-        val = _mm_mul_ps(val, sign);
-
-        /// Rounding algorithm.
-        val = _mm_div_ps(val, scale);
-        __m128 res = _mm_cmpge_ps(val, getOneTenth());
-        val = _mm_round_ps(val, int(rounding_mode));
-        val = _mm_mul_ps(val, scale);
-        val = _mm_and_ps(val, res);
-
-        /// Return the real signs of all values.
-        val = _mm_mul_ps(val, sign);
-
-        _mm_storeu_ps(out, val);
-    }
-
-private:
-    static inline const __m128 & getOneTenth()
-    {
-        static const __m128 one_tenth = _mm_set1_ps(0.1);
-        return one_tenth;
-    }
-};
-
-template <RoundingMode rounding_mode>
-class FloatRoundingComputation<Float32, rounding_mode, ScaleMode::Zero>
-    : public BaseFloatRoundingComputation<Float32>
-{
-public:
-    static inline void prepare(size_t scale, Scale & mm_scale)
-    {
-    }
-
-    static inline void compute(const Float32 * __restrict in, const Scale & scale, Float32 * __restrict out)
-    {
-        __m128 val = _mm_loadu_ps(in);
-        val = _mm_round_ps(val, int(rounding_mode));
-        _mm_storeu_ps(out, val);
-    }
-};
-
-template <RoundingMode rounding_mode>
-class FloatRoundingComputation<Float64, rounding_mode, ScaleMode::Positive>
-    : public BaseFloatRoundingComputation<Float64>
-{
-public:
-    static inline void prepare(size_t scale, Scale & mm_scale)
-    {
-        Float64 fscale = static_cast<Float64>(scale);
-        mm_scale = _mm_load1_pd(&fscale);
-    }
-
-    static inline void compute(const Float64 * __restrict in, const Scale & scale, Float64 * __restrict out)
-    {
-        __m128d val = _mm_loadu_pd(in);
-
-        /// Rounding algorithm.
-        val = _mm_mul_pd(val, scale);
-        val = _mm_round_pd(val, int(rounding_mode));
-        val = _mm_div_pd(val, scale);
-
-        _mm_storeu_pd(out, val);
-    }
-};
-
-template <RoundingMode rounding_mode>
-class FloatRoundingComputation<Float64, rounding_mode, ScaleMode::Negative>
-    : public BaseFloatRoundingComputation<Float64>
-{
-public:
-    static inline void prepare(size_t scale, Scale & mm_scale)
-    {
-        Float64 fscale = static_cast<Float64>(scale);
-        mm_scale = _mm_load1_pd(&fscale);
-    }
-
-    static inline void compute(const Float64 * __restrict in, const Scale & scale, Float64 * __restrict out)
-    {
-        __m128d val = _mm_loadu_pd(in);
-
-        /// Turn negative values into positive values.
-        __m128d sign = _mm_cmpge_pd(val, getZero());
-        sign = _mm_min_pd(sign, getTwo());
-        sign = _mm_sub_pd(sign, getOne());
-        val = _mm_mul_pd(val, sign);
-
-        /// Rounding algorithm.
-        val = _mm_div_pd(val, scale);
-        __m128d res = _mm_cmpge_pd(val, getOneTenth());
-        val = _mm_round_pd(val, int(rounding_mode));
-        val = _mm_mul_pd(val, scale);
-        val = _mm_and_pd(val, res);
-
-        /// Return the real signs of all values.
-        val = _mm_mul_pd(val, sign);
-
-        _mm_storeu_pd(out, val);
-    }
-
-private:
-    static inline const __m128d & getOneTenth()
-    {
-        static const __m128d one_tenth = _mm_set1_pd(0.1);
-        return one_tenth;
-    }
-};
-
-template <RoundingMode rounding_mode>
-class FloatRoundingComputation<Float64, rounding_mode, ScaleMode::Zero>
-    : public BaseFloatRoundingComputation<Float64>
-{
-public:
-    static inline void prepare(size_t scale, Scale & mm_scale)
-    {
-    }
-
-    static inline void compute(const Float64 * __restrict in, const Scale & scale, Float64 * __restrict out)
-    {
-        __m128d val = _mm_loadu_pd(in);
-        val = _mm_round_pd(val, int(rounding_mode));
-        _mm_storeu_pd(out, val);
-    }
-};
 #else
 
-/// Implementation for ARM. Not vectorized. Does not fix negative zeros.
+/// Implementation for ARM. Not vectorized.
 
-template <RoundingMode rounding_mode> float roundWithMode(float x);
-template <> float roundWithMode<RoundingMode::Round>(float x) { return roundf(x); }
-template <> float roundWithMode<RoundingMode::Floor>(float x) { return floorf(x); }
-template <> float roundWithMode<RoundingMode::Ceil>(float x) { return ceilf(x); }
-template <> float roundWithMode<RoundingMode::Trunc>(float x) { return truncf(x); }
-
-template <RoundingMode rounding_mode> double roundWithMode(double x);
-template <> double roundWithMode<RoundingMode::Round>(double x) { return round(x); }
-template <> double roundWithMode<RoundingMode::Floor>(double x) { return floor(x); }
-template <> double roundWithMode<RoundingMode::Ceil>(double x) { return ceil(x); }
-template <> double roundWithMode<RoundingMode::Trunc>(double x) { return trunc(x); }
+inline float roundWithMode(float x, RoundingMode mode)
+{
+    switch (mode)
+    {
+        case RoundingMode::Round: return roundf(x);
+        case RoundingMode::Floor: return floorf(x);
+        case RoundingMode::Ceil: return ceilf(x);
+        case RoundingMode::Trunc: return truncf(x);
+    }
+}
 
+inline double roundWithMode(double x, RoundingMode mode)
+{
+    switch (mode)
+    {
+        case RoundingMode::Round: return round(x);
+        case RoundingMode::Floor: return floor(x);
+        case RoundingMode::Ceil: return ceil(x);
+        case RoundingMode::Trunc: return trunc(x);
+    }
+}
 
 template <typename T>
 class BaseFloatRoundingComputation
 {
 public:
-    using Scale = T;
+    using ScalarType = T;
+    using VectorType = T;
     static const size_t data_count = 1;
 
-    static inline void prepare(size_t scale, Scale & mm_scale)
+    static VectorType load(const ScalarType * in) { return *in; }
+    static VectorType load1(const ScalarType in) { return in; }
+    static VectorType store(ScalarType * out, ScalarType val) { return *out = val;}
+    static VectorType multiply(VectorType val, VectorType scale) { return val * scale; }
+    static VectorType divide(VectorType val, VectorType scale) { return val / scale; }
+    template <RoundingMode mode> static VectorType apply(VectorType val) { return roundWithMode(val, mode); }
+
+    static VectorType prepare(size_t scale)
     {
-        mm_scale = static_cast<T>(scale);
+        return load1(scale);
     }
 };
 
-template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode>
-class FloatRoundingComputation;
-
-template <typename T, RoundingMode rounding_mode>
-class FloatRoundingComputation<T, rounding_mode, ScaleMode::Positive>
-    : public BaseFloatRoundingComputation<T>
-{
-public:
-    static inline void compute(const T * __restrict in, const T & scale, T * __restrict out)
-    {
-        out[0] = roundWithMode<rounding_mode>(in[0] * scale) / scale;
-    }
-};
-
-template <typename T, RoundingMode rounding_mode>
-class FloatRoundingComputation<T, rounding_mode, ScaleMode::Negative>
-    : public BaseFloatRoundingComputation<T>
-{
-public:
-    static inline void compute(const T * __restrict in, const T & scale, T * __restrict out)
-    {
-        out[0] = roundWithMode<rounding_mode>(in[0] / scale) * scale;
-    }
-};
-
-template <typename T, RoundingMode rounding_mode>
-class FloatRoundingComputation<T, rounding_mode, ScaleMode::Zero>
-    : public BaseFloatRoundingComputation<T>
-{
-public:
-    static inline void prepare(size_t scale, T & mm_scale)
-    {
-    }
-
-    static inline void compute(const T * __restrict in, const T & scale, T * __restrict out)
-    {
-        out[0] = roundWithMode<rounding_mode>(in[0]);
-    }
-};
 #endif
 
 
+/** Implementation of low-level round-off functions for floating-point values.
+  */
+template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode>
+class FloatRoundingComputation : public BaseFloatRoundingComputation<T>
+{
+    using Base = BaseFloatRoundingComputation<T>;
+
+public:
+    static inline void compute(const T * __restrict in, const typename Base::VectorType & scale, T * __restrict out)
+    {
+        auto val = Base::load(in);
+
+        if (scale_mode == ScaleMode::Positive)
+            val = Base::multiply(val, scale);
+        else if (scale_mode == ScaleMode::Negative)
+            val = Base::divide(val, scale);
+
+        val = Base::template apply<rounding_mode>(val);
+
+        if (scale_mode == ScaleMode::Positive)
+            val = Base::divide(val, scale);
+        else if (scale_mode == ScaleMode::Negative)
+            val = Base::multiply(val, scale);
+
+        Base::store(out, val);
+    }
+};
+
+
 /** Implementing high-level rounding functions.
   */
-template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode, typename Enable = void>
-struct FunctionRoundingImpl;
-
-/** Implement high-level rounding functions for integer values.
-  */
 template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode>
-struct FunctionRoundingImpl<T, rounding_mode, scale_mode,
-    typename std::enable_if<std::is_integral<T>::value && (scale_mode != ScaleMode::Null)>::type>
+struct FunctionRoundingImpl
 {
 private:
-    using Op = IntegerRoundingComputation<T, rounding_mode, scale_mode>;
+    using Op = typename std::conditional<std::is_floating_point<T>::value,
+        FloatRoundingComputation<T, rounding_mode, scale_mode>,
+        IntegerRoundingComputation<T, rounding_mode, scale_mode>>::type;
 
-public:
-    static inline void apply(const PaddedPODArray<T> & in, size_t scale, typename ColumnVector<T>::Container_t & out)
-    {
-        const T* begin_in = &in[0];
-        const T* end_in = begin_in + in.size();
-
-        T* __restrict p_out = &out[0];
-        for (const T* __restrict p_in = begin_in; p_in != end_in; ++p_in)
-        {
-            *p_out = Op::compute(*p_in, scale);
-            ++p_out;
-        }
-    }
-
-    static inline T apply(T val, size_t scale)
-    {
-        return Op::compute(val, scale);
-    }
-};
-
-/** Implement high-level round-off functions for floating-point values.
-  */
-template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode>
-struct FunctionRoundingImpl<T, rounding_mode, scale_mode,
-    typename std::enable_if<std::is_floating_point<T>::value && (scale_mode != ScaleMode::Null)>::type>
-{
-private:
-    using Op = FloatRoundingComputation<T, rounding_mode, scale_mode>;
     using Data = std::array<T, Op::data_count>;
-    using Scale = typename Op::Scale;
 
 public:
-    static inline void apply(const PaddedPODArray<T> & in, size_t scale, typename ColumnVector<T>::Container_t & out)
+    static NO_INLINE void apply(const PaddedPODArray<T> & in, size_t scale, typename ColumnVector<T>::Container_t & out)
     {
-        Scale mm_scale;
-        Op::prepare(scale, mm_scale);
+        auto mm_scale = Op::prepare(scale);
 
         const size_t data_count = std::tuple_size<Data>();
 
-        const T* begin_in = &in[0];
-        const T* end_in = begin_in + in.size();
+        const T* end_in = in.data() + in.size();
+        const T* limit = in.data() + in.size() / data_count * data_count;
 
-        T* begin_out = &out[0];
-        const T* end_out = begin_out + out.size();
+        const T* __restrict p_in = in.data();
+        T* __restrict p_out = out.data();
 
-        const T* limit = begin_in + in.size() / data_count * data_count;
-
-        const T* __restrict p_in = begin_in;
-        T* __restrict p_out = begin_out;
-        for (; p_in < limit; p_in += data_count)
+        while (p_in < limit)
         {
             Op::compute(p_in, mm_scale, p_out);
+            p_in += data_count;
             p_out += data_count;
         }
 
         if (p_in < end_in)
         {
-            Data tmp{{}};
-            T* begin_tmp = &tmp[0];
-            const T* end_tmp = begin_tmp + data_count;
+            Data tmp_src{{}};
+            Data tmp_dst;
 
-            for (T* __restrict p_tmp = begin_tmp; (p_tmp != end_tmp) && (p_in != end_in); ++p_tmp)
-            {
-                *p_tmp = *p_in;
-                ++p_in;
-            }
+            size_t tail_size_bytes = (end_in - p_in) * sizeof(*p_in);
 
-            Data res;
-            const T* begin_res = &res[0];
-            const T* end_res = begin_res + data_count;
-
-            Op::compute(reinterpret_cast<T *>(&tmp), mm_scale, reinterpret_cast<T *>(&res));
-
-            for (const T* __restrict p_res = begin_res; (p_res != end_res) && (p_out != end_out); ++p_res)
-            {
-                *p_out = *p_res;
-                ++p_out;
-            }
-        }
-    }
-
-    static inline T apply(T val, size_t scale)
-    {
-        if (val == 0)
-            return val;
-        else
-        {
-            Scale mm_scale;
-            Op::prepare(scale, mm_scale);
-
-            Data tmp{{}};
-            tmp[0] = val;
-
-            Data res;
-            Op::compute(reinterpret_cast<T *>(&tmp), mm_scale, reinterpret_cast<T *>(&res));
-            return res[0];
+            memcpy(&tmp_src, p_in, tail_size_bytes);
+            Op::compute(reinterpret_cast<T *>(&tmp_src), mm_scale, reinterpret_cast<T *>(&tmp_dst));
+            memcpy(p_out, &tmp_dst, tail_size_bytes);
         }
     }
 };
 
-/** Implementation of high-level rounding functions in the case when a zero value is returned.
-    */
-template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode>
-struct FunctionRoundingImpl<T, rounding_mode, scale_mode,
-    typename std::enable_if<scale_mode == ScaleMode::Null>::type>
-{
-public:
-    static inline void apply(const PaddedPODArray<T> & in, size_t scale, typename ColumnVector<T>::Container_t & out)
-    {
-        ::memset(reinterpret_cast<T *>(&out[0]), 0, in.size() * sizeof(T));
-    }
 
-    static inline T apply(T val, size_t scale)
-    {
-        return 0;
-    }
-};
-
-/// The following code generates a table of powers of 10 during the build.
-
-namespace
-{
-    /// Individual degrees of the number 10.
-
-    template <size_t N>
-    struct PowerOf10
-    {
-        static const size_t value = 10 * PowerOf10<N - 1>::value;
-    };
-
-    template <>
-    struct PowerOf10<0>
-    {
-        static const size_t value = 1;
-    };
-}
-
-/// Declaring and defining a container containing a table of powers of 10.
-
-template <size_t... TArgs>
-struct TableContainer
-{
-    static const std::array<size_t, sizeof...(TArgs)> values;
-};
-
-template <size_t... TArgs>
-const std::array<size_t, sizeof...(TArgs)> TableContainer<TArgs...>::values {{ TArgs... }};
-
-/// The generator of the first N degrees.
-
-template <size_t N, size_t... TArgs>
-struct FillArrayImpl
-{
-    using result = typename FillArrayImpl<N - 1, PowerOf10<N>::value, TArgs...>::result;
-};
-
-template <size_t... TArgs>
-struct FillArrayImpl<0, TArgs...>
-{
-    using result = TableContainer<PowerOf10<0>::value, TArgs...>;
-};
-
-template <size_t N>
-struct FillArray
-{
-    using result = typename FillArrayImpl<N - 1>::result;
-};
-
-/** This pattern defines the precision that the round/ceil/floor functions use,
-  * then converts it to a value that can be used in operations of
-  * multiplication and division. Therefore, it is called a scale.
+/** Select the appropriate processing algorithm depending on the scale.
   */
-template <typename T, typename U, typename Enable = void>
-struct ScaleForRightType;
-
-template <typename T, typename U>
-struct ScaleForRightType<T, U,
-    typename std::enable_if<
-        std::is_floating_point<T>::value
-        && std::is_signed<U>::value>::type>
+template <typename T, RoundingMode rounding_mode>
+struct Dispatcher
 {
-    static inline bool apply(const ColumnPtr & column, ScaleMode & scale_mode, size_t & scale)
+    static void apply(Block & block, const ColumnVector<T> * col, const ColumnNumbers & arguments, size_t result)
     {
-        using PowersOf10 = typename FillArray<std::numeric_limits<T>::digits10 + 1>::result;
+        ScaleMode scale_mode;
+        size_t scale = 1;
+        Int64 scale_arg = 0;
 
-        auto precision_col = checkAndGetColumnConst<ColumnVector<U>>(column.get());
-        if (!precision_col)
-            return false;
+        if (arguments.size() == 2)
+        {
+            const IColumn & scale_column = *block.getByPosition(arguments[1]).column;
+            if (!scale_column.isConst())
+                throw Exception("Scale argument for rounding functions must be constant.", ErrorCodes::ILLEGAL_COLUMN);
 
-        U val = precision_col->template getValue<U>();
-        if (val < 0)
-        {
-            if (val < -static_cast<U>(std::numeric_limits<T>::digits10))
-            {
-                scale_mode = ScaleMode::Null;
-                scale = 1;
-            }
-            else
-            {
-                scale_mode = ScaleMode::Negative;
-                scale = PowersOf10::values[-val];
-            }
-        }
-        else if (val == 0)
-        {
-            scale_mode = ScaleMode::Zero;
-            scale = 1;
-        }
-        else
-        {
-            scale_mode = ScaleMode::Positive;
-            if (val > std::numeric_limits<T>::digits10)
-                val = static_cast<U>(std::numeric_limits<T>::digits10);
-            scale = PowersOf10::values[val];
+            scale_arg = applyVisitor(FieldVisitorConvertToNumber<Int64>(),
+                static_cast<const ColumnConst &>(scale_column).getField());
         }
 
-        return true;
-    }
-};
-
-template <typename T, typename U>
-struct ScaleForRightType<T, U,
-    typename std::enable_if<
-        std::is_floating_point<T>::value
-        && std::is_unsigned<U>::value>::type>
-{
-    static inline bool apply(const ColumnPtr & column, ScaleMode & scale_mode, size_t & scale)
-    {
-        using PowersOf10 = typename FillArray<std::numeric_limits<T>::digits10 + 1>::result;
-        auto precision_col = checkAndGetColumnConst<ColumnVector<U>>(column.get());
-        if (!precision_col)
-            return false;
-
-        U val = precision_col->template getValue<U>();
-        if (val == 0)
-        {
-            scale_mode = ScaleMode::Zero;
-            scale = 1;
-        }
-        else
-        {
-            scale_mode = ScaleMode::Positive;
-            if (val > static_cast<U>(std::numeric_limits<T>::digits10))
-                val = static_cast<U>(std::numeric_limits<T>::digits10);
-            scale = PowersOf10::values[val];
-        }
-
-        return true;
-    }
-};
-
-template <typename T, typename U>
-struct ScaleForRightType<T, U,
-    typename std::enable_if<
-        std::is_integral<T>::value
-        && std::is_signed<U>::value>::type>
-{
-    static inline bool apply(const ColumnPtr & column, ScaleMode & scale_mode, size_t & scale)
-    {
-        using PowersOf10 = typename FillArray<std::numeric_limits<T>::digits10 + 1>::result;
-        auto precision_col = checkAndGetColumnConst<ColumnVector<U>>(column.get());
-        if (!precision_col)
-            return false;
-
-        U val = precision_col->template getValue<U>();
-        if (val < 0)
-        {
-            if (val < -std::numeric_limits<T>::digits10)
-            {
-                scale_mode = ScaleMode::Null;
-                scale = 1;
-            }
-            else
-            {
-                scale_mode = ScaleMode::Negative;
-                scale = PowersOf10::values[-val];
-            }
-        }
-        else
-        {
-            scale_mode = ScaleMode::Zero;
-            scale = 1;
-        }
-
-        return true;
-    }
-};
-
-template <typename T, typename U>
-struct ScaleForRightType<T, U,
-    typename std::enable_if<
-        std::is_integral<T>::value
-        && std::is_unsigned<U>::value>::type>
-{
-    static inline bool apply(const ColumnPtr & column, ScaleMode & scale_mode, size_t & scale)
-    {
-        auto precision_col = checkAndGetColumnConst<ColumnVector<U>>(column.get());
-        if (!precision_col)
-            return false;
-
-        scale_mode = ScaleMode::Zero;
-        scale = 1;
-
-        return true;
-    }
-};
-
-/** Turn the precision parameter into a scale.
-    */
-template <typename T>
-struct ScaleForLeftType
-{
-    static inline void apply(const ColumnPtr & column, ScaleMode & scale_mode, size_t & scale)
-    {
-        if (!( ScaleForRightType<T, UInt8>::apply(column, scale_mode, scale)
-            || ScaleForRightType<T, UInt16>::apply(column, scale_mode, scale)
-            || ScaleForRightType<T, UInt16>::apply(column, scale_mode, scale)
-            || ScaleForRightType<T, UInt32>::apply(column, scale_mode, scale)
-            || ScaleForRightType<T, UInt64>::apply(column, scale_mode, scale)
-            || ScaleForRightType<T, Int8>::apply(column, scale_mode, scale)
-            || ScaleForRightType<T, Int16>::apply(column, scale_mode, scale)
-            || ScaleForRightType<T, Int32>::apply(column, scale_mode, scale)
-            || ScaleForRightType<T, Int64>::apply(column, scale_mode, scale)
-            || ScaleForRightType<T, Float32>::apply(column, scale_mode, scale)
-            || ScaleForRightType<T, Float64>::apply(column, scale_mode, scale)))
-        {
-            throw Exception("Internal error", ErrorCodes::LOGICAL_ERROR);
-        }
-    }
-};
-
-/** The main template that applies the rounding function to a value or column.
-    */
-template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode>
-struct Cruncher
-{
-    using Op = FunctionRoundingImpl<T, rounding_mode, scale_mode>;
-
-    static inline void apply(Block & block, const ColumnVector<T> * col, const ColumnNumbers & arguments, size_t result, size_t scale)
-    {
         auto col_res = std::make_shared<ColumnVector<T>>();
         block.getByPosition(result).column = col_res;
 
@@ -876,45 +426,31 @@ struct Cruncher
         if (vec_res.empty())
             return;
 
-        Op::apply(col->getData(), scale, vec_res);
-    }
-};
-
-/** Select the appropriate processing algorithm depending on the scale.
-  */
-template <typename T, typename ColumnType, RoundingMode rounding_mode>
-struct Dispatcher
-{
-    static inline void apply(Block & block, const ColumnType * col, const ColumnNumbers & arguments, size_t result)
-    {
-        ScaleMode scale_mode;
-        size_t scale;
-
-        if (arguments.size() == 2)
-            ScaleForLeftType<T>::apply(block.getByPosition(arguments[1]).column, scale_mode, scale);
-        else
+        if (scale_arg == 0)
         {
             scale_mode = ScaleMode::Zero;
             scale = 1;
+            FunctionRoundingImpl<T, rounding_mode, ScaleMode::Zero>::apply(col->getData(), scale, vec_res);
+        }
+        else if (scale_arg > 0)
+        {
+            scale_mode = ScaleMode::Positive;
+            scale = pow(10, scale_arg);
+            FunctionRoundingImpl<T, rounding_mode, ScaleMode::Positive>::apply(col->getData(), scale, vec_res);
         }
-
-        if (scale_mode == ScaleMode::Positive)
-            Cruncher<T, rounding_mode, ScaleMode::Positive>::apply(block, col, arguments, result, scale);
-        else if (scale_mode == ScaleMode::Zero)
-            Cruncher<T, rounding_mode, ScaleMode::Zero>::apply(block, col, arguments, result, scale);
-        else if (scale_mode == ScaleMode::Negative)
-            Cruncher<T, rounding_mode, ScaleMode::Negative>::apply(block, col, arguments, result, scale);
-        else if (scale_mode == ScaleMode::Null)
-            Cruncher<T, rounding_mode, ScaleMode::Null>::apply(block, col, arguments, result, scale);
         else
-            throw Exception("Illegal operation", ErrorCodes::LOGICAL_ERROR);
+        {
+            scale_mode = ScaleMode::Negative;
+            scale = pow(10, -scale_arg);
+            FunctionRoundingImpl<T, rounding_mode, ScaleMode::Negative>::apply(col->getData(), scale, vec_res);
+        }
     }
 };
 
 /** A template for functions that round the value of an input parameter of type
-    * (U)Int8/16/32/64 or Float32/64, and accept an additional optional
-    * parameter (default is 0).
-    */
+  * (U)Int8/16/32/64 or Float32/64, and accept an additional optional
+  * parameter (default is 0).
+  */
 template <typename Name, RoundingMode rounding_mode>
 class FunctionRounding : public IFunction
 {
@@ -923,18 +459,12 @@ public:
     static FunctionPtr create(const Context & context) { return std::make_shared<FunctionRounding>(); }
 
 private:
-    template <typename T>
-    bool checkType(const IDataType * type) const
-    {
-        return typeid_cast<const T *>(type);
-    }
-
     template <typename T>
     bool executeForType(Block & block, const ColumnNumbers & arguments, size_t result)
     {
         if (auto col = checkAndGetColumn<ColumnVector<T>>(block.getByPosition(arguments[0]).column.get()))
         {
-            Dispatcher<T, ColumnVector<T>, rounding_mode>::apply(block, col, arguments, result);
+            Dispatcher<T, rounding_mode>::apply(block, col, arguments, result);
             return true;
         }
         return false;
@@ -957,29 +487,10 @@ public:
                 + toString(arguments.size()) + ", should be 1 or 2.",
                 ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
 
-        if (arguments.size() == 2)
-        {
-            const IDataType * type = &*arguments[1];
-            if (!( checkType<DataTypeUInt8>(type)
-                || checkType<DataTypeUInt16>(type)
-                || checkType<DataTypeUInt32>(type)
-                || checkType<DataTypeUInt64>(type)
-                || checkType<DataTypeInt8>(type)
-                || checkType<DataTypeInt16>(type)
-                || checkType<DataTypeInt32>(type)
-                || checkType<DataTypeInt64>(type)
-                || checkType<DataTypeFloat32>(type)
-                || checkType<DataTypeFloat64>(type)))
-            {
-                throw Exception("Illegal type in second argument of function " + getName(),
-                                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
-            }
-        }
-
-        const IDataType * type = &*arguments[0];
-        if (!type->behavesAsNumber())
-            throw Exception("Illegal type " + arguments[0]->getName() + " of argument of function " + getName(),
-                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+        for (const auto & type : arguments)
+            if (!type->behavesAsNumber())
+                throw Exception("Illegal type " + arguments[0]->getName() + " of argument of function " + getName(),
+                    ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
         return arguments[0];
     }
@@ -1017,6 +528,7 @@ public:
     }
 };
 
+
 struct NameRoundToExp2 { static constexpr auto name = "roundToExp2"; };
 struct NameRoundDuration { static constexpr auto name = "roundDuration"; };
 struct NameRoundAge { static constexpr auto name = "roundAge"; };

From 84d61b501cccd95891291703f07b17188849a9e0 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 16 Sep 2017 22:31:20 +0300
Subject: [PATCH 252/266] FunctionsRound: continue [#CLICKHOUSE-2].

---
 dbms/src/Functions/FunctionsRound.h | 53 +++++++++++------------------
 1 file changed, 20 insertions(+), 33 deletions(-)

diff --git a/dbms/src/Functions/FunctionsRound.h b/dbms/src/Functions/FunctionsRound.h
index 01447e0c675..185f23380ac 100644
--- a/dbms/src/Functions/FunctionsRound.h
+++ b/dbms/src/Functions/FunctionsRound.h
@@ -144,7 +144,7 @@ enum class RoundingMode
 };
 
 
-/** Implementing low-level rounding functions for integer values.
+/** Rounding functions for integer values.
   */
 template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode>
 struct IntegerRoundingComputation
@@ -156,27 +156,40 @@ struct IntegerRoundingComputation
         return scale;
     }
 
-    template <size_t scale>
-    static inline T computeImpl(T x)
+    static ALWAYS_INLINE T computeImpl(T x, T scale)
     {
         switch (rounding_mode)
         {
             case RoundingMode::Trunc:
+            {
                 return x / scale * scale;
+            }
             case RoundingMode::Floor:
+            {
                 if (x < 0)
                     x -= scale - 1;
                 return x / scale * scale;
+            }
             case RoundingMode::Ceil:
+            {
                 if (x >= 0)
                     x += scale - 1;
                 return x / scale * scale;
+            }
             case RoundingMode::Round:
-                return (x + scale / 2) / scale * scale;
+            {
+                bool negative = x < 0;
+                if (negative)
+                    x = -x;
+                x = (x + scale / 2) / scale * scale;
+                if (negative)
+                    x = -x;
+                return x;
+            }
         }
     }
 
-    static inline T compute(T x, size_t scale)
+    static ALWAYS_INLINE T compute(T x, T scale)
     {
         switch (scale_mode)
         {
@@ -185,37 +198,11 @@ struct IntegerRoundingComputation
             case ScaleMode::Positive:
                 return x;
             case ScaleMode::Negative:
-            {
-                switch (scale)
-                {
-                    case 10ULL: return computeImpl<10ULL>(x);
-                    case 100ULL: return computeImpl<100ULL>(x);
-                    case 1000ULL: return computeImpl<1000ULL>(x);
-                    case 10000ULL: return computeImpl<10000ULL>(x);
-                    case 100000ULL: return computeImpl<100000ULL>(x);
-                    case 1000000ULL: return computeImpl<1000000ULL>(x);
-                    case 10000000ULL: return computeImpl<10000000ULL>(x);
-                    case 100000000ULL: return computeImpl<100000000ULL>(x);
-                    case 1000000000ULL: return computeImpl<1000000000ULL>(x);
-                    case 10000000000ULL: return computeImpl<10000000000ULL>(x);
-                    case 100000000000ULL: return computeImpl<100000000000ULL>(x);
-                    case 1000000000000ULL: return computeImpl<1000000000000ULL>(x);
-                    case 10000000000000ULL: return computeImpl<10000000000000ULL>(x);
-                    case 100000000000000ULL: return computeImpl<100000000000000ULL>(x);
-                    case 1000000000000000ULL: return computeImpl<1000000000000000ULL>(x);
-                    case 10000000000000000ULL: return computeImpl<10000000000000000ULL>(x);
-                    case 100000000000000000ULL: return computeImpl<100000000000000000ULL>(x);
-                    case 1000000000000000000ULL: return computeImpl<1000000000000000000ULL>(x);
-                    case 10000000000000000000ULL: return computeImpl<10000000000000000000ULL>(x);
-                    default:
-                        throw Exception("Logical error: unexpected 'scale' parameter passed to function IntegerRoundingComputation::compute",
-                            ErrorCodes::LOGICAL_ERROR);
-                }
-            }
+                return computeImpl(x, scale);
         }
     }
 
-    static inline void compute(const T * __restrict in, size_t scale, T * __restrict out)
+    static ALWAYS_INLINE void compute(const T * __restrict in, size_t scale, T * __restrict out)
     {
         *out = compute(*in, scale);
     }

From d48725f9a72a956cbf4200cbadf239ee7c5a4917 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 16 Sep 2017 22:33:49 +0300
Subject: [PATCH 253/266] FunctionsRound: continue [#CLICKHOUSE-2].

---
 dbms/src/Functions/FunctionsRound.h | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/dbms/src/Functions/FunctionsRound.h b/dbms/src/Functions/FunctionsRound.h
index 185f23380ac..cdace8f99fb 100644
--- a/dbms/src/Functions/FunctionsRound.h
+++ b/dbms/src/Functions/FunctionsRound.h
@@ -390,7 +390,6 @@ struct Dispatcher
 {
     static void apply(Block & block, const ColumnVector<T> * col, const ColumnNumbers & arguments, size_t result)
     {
-        ScaleMode scale_mode;
         size_t scale = 1;
         Int64 scale_arg = 0;
 
@@ -415,19 +414,16 @@ struct Dispatcher
 
         if (scale_arg == 0)
         {
-            scale_mode = ScaleMode::Zero;
             scale = 1;
             FunctionRoundingImpl<T, rounding_mode, ScaleMode::Zero>::apply(col->getData(), scale, vec_res);
         }
         else if (scale_arg > 0)
         {
-            scale_mode = ScaleMode::Positive;
             scale = pow(10, scale_arg);
             FunctionRoundingImpl<T, rounding_mode, ScaleMode::Positive>::apply(col->getData(), scale, vec_res);
         }
         else
         {
-            scale_mode = ScaleMode::Negative;
             scale = pow(10, -scale_arg);
             FunctionRoundingImpl<T, rounding_mode, ScaleMode::Negative>::apply(col->getData(), scale, vec_res);
         }

From c2595934f1d47ed63b7014aeb365893e9be979c9 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sat, 16 Sep 2017 23:17:19 +0300
Subject: [PATCH 254/266] FunctionsRound: continue [#CLICKHOUSE-2].

---
 dbms/src/Functions/FunctionsRound.h | 68 ++++++++++++++++++++++++++---
 1 file changed, 63 insertions(+), 5 deletions(-)

diff --git a/dbms/src/Functions/FunctionsRound.h b/dbms/src/Functions/FunctionsRound.h
index cdace8f99fb..5d2a22b671d 100644
--- a/dbms/src/Functions/FunctionsRound.h
+++ b/dbms/src/Functions/FunctionsRound.h
@@ -339,13 +339,10 @@ public:
 /** Implementing high-level rounding functions.
   */
 template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode>
-struct FunctionRoundingImpl
+struct FloatRoundingImpl
 {
 private:
-    using Op = typename std::conditional<std::is_floating_point<T>::value,
-        FloatRoundingComputation<T, rounding_mode, scale_mode>,
-        IntegerRoundingComputation<T, rounding_mode, scale_mode>>::type;
-
+    using Op = FloatRoundingComputation<T, rounding_mode, scale_mode>;
     using Data = std::array<T, Op::data_count>;
 
 public:
@@ -382,6 +379,67 @@ public:
     }
 };
 
+template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode>
+struct IntegerRoundingImpl
+{
+private:
+    using Op = IntegerRoundingComputation<T, rounding_mode, scale_mode>;
+    using Data = T;
+
+public:
+    template <size_t scale>
+    static NO_INLINE void applyImpl(const PaddedPODArray<T> & in, typename ColumnVector<T>::Container_t & out)
+    {
+        const T* end_in = in.data() + in.size();
+
+        const T* __restrict p_in = in.data();
+        T* __restrict p_out = out.data();
+
+        while (p_in < end_in)
+        {
+            Op::compute(p_in, scale, p_out);
+            ++p_in;
+            ++p_out;
+        }
+    }
+
+    static NO_INLINE void apply(const PaddedPODArray<T> & in, size_t scale, typename ColumnVector<T>::Container_t & out)
+    {
+        /// Manual function cloning for compiler to generate integer division by constant.
+        switch (scale)
+        {
+            case 1ULL: return applyImpl<1ULL>(in, out);
+            case 10ULL: return applyImpl<10ULL>(in, out);
+            case 100ULL: return applyImpl<100ULL>(in, out);
+            case 1000ULL: return applyImpl<1000ULL>(in, out);
+            case 10000ULL: return applyImpl<10000ULL>(in, out);
+            case 100000ULL: return applyImpl<100000ULL>(in, out);
+            case 1000000ULL: return applyImpl<1000000ULL>(in, out);
+            case 10000000ULL: return applyImpl<10000000ULL>(in, out);
+            case 100000000ULL: return applyImpl<100000000ULL>(in, out);
+            case 1000000000ULL: return applyImpl<1000000000ULL>(in, out);
+            case 10000000000ULL: return applyImpl<10000000000ULL>(in, out);
+            case 100000000000ULL: return applyImpl<100000000000ULL>(in, out);
+            case 1000000000000ULL: return applyImpl<1000000000000ULL>(in, out);
+            case 10000000000000ULL: return applyImpl<10000000000000ULL>(in, out);
+            case 100000000000000ULL: return applyImpl<100000000000000ULL>(in, out);
+            case 1000000000000000ULL: return applyImpl<1000000000000000ULL>(in, out);
+            case 10000000000000000ULL: return applyImpl<10000000000000000ULL>(in, out);
+            case 100000000000000000ULL: return applyImpl<100000000000000000ULL>(in, out);
+            case 1000000000000000000ULL: return applyImpl<1000000000000000000ULL>(in, out);
+            case 10000000000000000000ULL: return applyImpl<10000000000000000000ULL>(in, out);
+            default:
+                throw Exception("Logical error: unexpected 'scale' parameter passed to function IntegerRoundingComputation::compute",
+                    ErrorCodes::LOGICAL_ERROR);
+        }
+    }
+};
+
+template <typename T, RoundingMode rounding_mode, ScaleMode scale_mode>
+using FunctionRoundingImpl = typename std::conditional<std::is_floating_point<T>::value,
+    FloatRoundingImpl<T, rounding_mode, scale_mode>,
+    IntegerRoundingImpl<T, rounding_mode, scale_mode>>::type;
+
 
 /** Select the appropriate processing algorithm depending on the scale.
   */

From 5224345c03025b6d912e8978359396e4000e2735 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 17 Sep 2017 01:11:20 +0300
Subject: [PATCH 255/266] Added function aliases for 'trunc' [#CLICKHOUSE-2].

---
 dbms/src/Functions/FunctionsRound.cpp | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/dbms/src/Functions/FunctionsRound.cpp b/dbms/src/Functions/FunctionsRound.cpp
index f1e6398ae5c..8098b6fd430 100644
--- a/dbms/src/Functions/FunctionsRound.cpp
+++ b/dbms/src/Functions/FunctionsRound.cpp
@@ -9,10 +9,15 @@ void registerFunctionsRound(FunctionFactory & factory)
     factory.registerFunction<FunctionRoundToExp2>();
     factory.registerFunction<FunctionRoundDuration>();
     factory.registerFunction<FunctionRoundAge>();
-    factory.registerFunction<FunctionRound>();
-    factory.registerFunction<FunctionCeil>();
-    factory.registerFunction<FunctionFloor>();
-    factory.registerFunction<FunctionTrunc>();
+
+    factory.registerFunction("round", FunctionRound::create, FunctionFactory::CaseInsensitive);
+    factory.registerFunction("floor", FunctionFloor::create, FunctionFactory::CaseInsensitive);
+    factory.registerFunction("ceil", FunctionCeil::create, FunctionFactory::CaseInsensitive);
+    factory.registerFunction("trunc", FunctionTrunc::create, FunctionFactory::CaseInsensitive);
+
+    /// Compatibility aliases.
+    factory.registerFunction("ceiling", FunctionCeil::create, FunctionFactory::CaseInsensitive);
+    factory.registerFunction("truncate", FunctionTrunc::create, FunctionFactory::CaseInsensitive);
 }
 
 }

From b80788a2f451757bcf50c4a4a19dfc32c57bf2cb Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 17 Sep 2017 01:12:24 +0300
Subject: [PATCH 256/266] Better implementation of "roundToExp2" function
 [#CLICKHOUSE-2].

---
 dbms/src/Functions/FunctionsRound.h | 60 +++++++++++++++++------------
 1 file changed, 35 insertions(+), 25 deletions(-)

diff --git a/dbms/src/Functions/FunctionsRound.h b/dbms/src/Functions/FunctionsRound.h
index 5d2a22b671d..efeae9d5a15 100644
--- a/dbms/src/Functions/FunctionsRound.h
+++ b/dbms/src/Functions/FunctionsRound.h
@@ -7,11 +7,13 @@
 #include <cmath>
 #include <type_traits>
 #include <array>
+#include <ext/bit_cast.h>
 
 #if __SSE4_1__
     #include <smmintrin.h>
 #endif
 
+
 /** If you want negative zeros will be replaced by zeros in result of calculations.
   * Disabled by performance reasons.
 #define NO_NEGATIVE_ZEROS
@@ -42,38 +44,46 @@ namespace ErrorCodes
     * - N = 0: round to an integer
     */
 
-template <typename A>
+template <typename T>
+inline typename std::enable_if<std::is_integral<T>::value && (sizeof(T) <= sizeof(UInt32)), T>::type
+roundDownToPowerOfTwo(T x)
+{
+    return x <= 0 ? 0 : (T(1) << (31 - __builtin_clz(x)));
+}
+
+template <typename T>
+inline typename std::enable_if<std::is_integral<T>::value && (sizeof(T) == sizeof(UInt64)), T>::type
+roundDownToPowerOfTwo(T x)
+{
+    return x <= 0 ? 0 : (T(1) << (63 - __builtin_clzll(x)));
+}
+
+template <typename T>
+inline typename std::enable_if<std::is_same<T, Float32>::value, T>::type
+roundDownToPowerOfTwo(T x)
+{
+    return ext::bit_cast<T>(ext::bit_cast<UInt32>(x) & ~((1ULL << 23) - 1));
+}
+
+template <typename T>
+inline typename std::enable_if<std::is_same<T, Float64>::value, T>::type
+roundDownToPowerOfTwo(T x)
+{
+    return ext::bit_cast<T>(ext::bit_cast<UInt64>(x) & ~((1ULL << 52) - 1));
+}
+
+
+template <typename T>
 struct RoundToExp2Impl
 {
-    using ResultType = A;
+    using ResultType = T;
 
-    static inline A apply(A x)
+    static inline T apply(T x)
     {
-        return x <= 0 ? static_cast<A>(0) : (static_cast<A>(1) << static_cast<UInt64>(log2(static_cast<double>(x))));
+        return roundDownToPowerOfTwo<T>(x);
     }
 };
 
-template <>
-struct RoundToExp2Impl<Float32>
-{
-    using ResultType = Float32;
-
-    static inline Float32 apply(Float32 x)
-    {
-        return static_cast<Float32>(x < 1 ? 0. : pow(2., floor(log2(x))));
-    }
-};
-
-template <>
-struct RoundToExp2Impl<Float64>
-{
-    using ResultType = Float64;
-
-    static inline Float64 apply(Float64 x)
-    {
-        return x < 1 ? 0. : pow(2., floor(log2(x)));
-    }
-};
 
 template <typename A>
 struct RoundDurationImpl

From a5e8c5e8f50b5bcd541c7daddb3c5bcea0ddbcf8 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 17 Sep 2017 01:24:48 +0300
Subject: [PATCH 257/266] Better [#CLICKHOUSE-2].

---
 dbms/src/Functions/FunctionsArithmetic.h | 8 ++++----
 dbms/src/Functions/FunctionsLogical.h    | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/dbms/src/Functions/FunctionsArithmetic.h b/dbms/src/Functions/FunctionsArithmetic.h
index 4d5f8fd5e14..2e07e385f14 100644
--- a/dbms/src/Functions/FunctionsArithmetic.h
+++ b/dbms/src/Functions/FunctionsArithmetic.h
@@ -38,21 +38,21 @@ struct BinaryOperationImplBase
 {
     using ResultType = ResultType_;
 
-    static void vector_vector(const PaddedPODArray<A> & a, const PaddedPODArray<B> & b, PaddedPODArray<ResultType> & c)
+    static void NO_INLINE vector_vector(const PaddedPODArray<A> & a, const PaddedPODArray<B> & b, PaddedPODArray<ResultType> & c)
     {
         size_t size = a.size();
         for (size_t i = 0; i < size; ++i)
             c[i] = Op::template apply<ResultType>(a[i], b[i]);
     }
 
-    static void vector_constant(const PaddedPODArray<A> & a, B b, PaddedPODArray<ResultType> & c)
+    static void NO_INLINE vector_constant(const PaddedPODArray<A> & a, B b, PaddedPODArray<ResultType> & c)
     {
         size_t size = a.size();
         for (size_t i = 0; i < size; ++i)
             c[i] = Op::template apply<ResultType>(a[i], b);
     }
 
-    static void constant_vector(A a, const PaddedPODArray<B> & b, PaddedPODArray<ResultType> & c)
+    static void NO_INLINE constant_vector(A a, const PaddedPODArray<B> & b, PaddedPODArray<ResultType> & c)
     {
         size_t size = b.size();
         for (size_t i = 0; i < size; ++i)
@@ -76,7 +76,7 @@ struct UnaryOperationImpl
 {
     using ResultType = typename Op::ResultType;
 
-    static void vector(const PaddedPODArray<A> & a, PaddedPODArray<ResultType> & c)
+    static void NO_INLINE vector(const PaddedPODArray<A> & a, PaddedPODArray<ResultType> & c)
     {
         size_t size = a.size();
         for (size_t i = 0; i < size; ++i)
diff --git a/dbms/src/Functions/FunctionsLogical.h b/dbms/src/Functions/FunctionsLogical.h
index 9d2a9b174db..c5672ae87ca 100644
--- a/dbms/src/Functions/FunctionsLogical.h
+++ b/dbms/src/Functions/FunctionsLogical.h
@@ -101,7 +101,7 @@ template <typename Op, size_t N>
 struct AssociativeOperationImpl
 {
     /// Erases the N last columns from `in` (if there are less, then all) and puts into `result` their combination.
-    static void execute(UInt8ColumnPtrs & in, UInt8Container & result)
+    static void NO_INLINE execute(UInt8ColumnPtrs & in, UInt8Container & result)
     {
         if (N > in.size())
         {

From 268771efa9d1f855813ce7ad68a84111ccbfd6de Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 17 Sep 2017 01:32:04 +0300
Subject: [PATCH 258/266] Miscellaneous [#CLICKHOUSE-2].

---
 libs/libglibc-compatibility/glibc-compatibility.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libs/libglibc-compatibility/glibc-compatibility.c b/libs/libglibc-compatibility/glibc-compatibility.c
index 367bd2de765..9a8b8d67f36 100644
--- a/libs/libglibc-compatibility/glibc-compatibility.c
+++ b/libs/libglibc-compatibility/glibc-compatibility.c
@@ -39,8 +39,6 @@ int __gai_sigqueue(int sig, const union sigval val, pid_t caller_pid)
 }
 
 
-/// NOTE This disables some of FORTIFY_SOURCE functionality.
-
 #include <sys/select.h>
 #include <stdlib.h>
 
@@ -65,6 +63,8 @@ int __poll_chk(struct pollfd * fds, nfds_t nfds, int timeout, size_t fdslen)
 
 void longjmp(jmp_buf env, int val);
 
+/// NOTE This disables some of FORTIFY_SOURCE functionality.
+
 void __longjmp_chk(jmp_buf env, int val)
 {
     return longjmp(env, val);

From 7a85eab26008d4a81bb690b3ed678a0a45689b88 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 17 Sep 2017 01:33:05 +0300
Subject: [PATCH 259/266] Disabled increased inline-depth for clang
 [#CLICKHOUSE-2].

---
 CMakeLists.txt | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index ac9b76a009d..e642734a33c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -108,9 +108,9 @@ if (USE_LIBCXX)
 endif ()
 
 # Special options for better optimized code with clang
-if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-    set (CMAKE_CXX_FLAGS_RELWITHDEBINFO  "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -Wno-unused-command-line-argument -mllvm -inline-threshold=10000")
-endif ()
+#if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+#    set (CMAKE_CXX_FLAGS_RELWITHDEBINFO  "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -Wno-unused-command-line-argument -mllvm -inline-threshold=10000")
+#endif ()
 
 set (CMAKE_BUILD_COLOR_MAKEFILE          ON)
 set (CMAKE_CXX_FLAGS                     "${CMAKE_CXX_FLAGS} ${COMPILER_FLAGS} -std=gnu++1z ${PLATFORM_EXTRA_CXX_FLAG} -fno-omit-frame-pointer ${COMMON_WARNING_FLAGS} ${CXX_WARNING_FLAGS} ${GLIBC_COMPATIBILITY_COMPILE_FLAGS}")

From a726f2831c29fab4f3b453571f47cbc33c5622c4 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 17 Sep 2017 01:41:20 +0300
Subject: [PATCH 260/266] Enabled "GLIBC_COMPATIBILITY" option by default
 [#CLICKHOUSE-3275].

---
 CMakeLists.txt                                    | 9 +++++++--
 libs/libglibc-compatibility/glibc-compatibility.c | 2 --
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index e642734a33c..a73871109ae 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -71,8 +71,13 @@ if (USE_STATIC_LIBRARIES)
     list(REVERSE CMAKE_FIND_LIBRARY_SUFFIXES)
 endif ()
 
-option (USE_INTERNAL_MEMCPY "Use internal implementation of 'memcpy' function instead of provided by libc. Only for x86_64." ON)
-option (GLIBC_COMPATIBILITY "Set to TRUE to enable compatibility with older glibc libraries. Implies USE_INTERNAL_MEMCPY." OFF)
+if (CMAKE_SYSTEM_PROCESSOR MATCHES "amd64.*|x86_64.*|AMD64.*")
+    option (USE_INTERNAL_MEMCPY "Use internal implementation of 'memcpy' function instead of provided by libc. Only for x86_64." ON)
+
+    if (CMAKE_SYSTEM MATCHES "Linux")
+        option (GLIBC_COMPATIBILITY "Set to TRUE to enable compatibility with older glibc libraries. Only for x86_64, Linux. Implies USE_INTERNAL_MEMCPY." ON)
+    endif()
+endif ()
 
 if (GLIBC_COMPATIBILITY)
     set (USE_INTERNAL_MEMCPY ON)
diff --git a/libs/libglibc-compatibility/glibc-compatibility.c b/libs/libglibc-compatibility/glibc-compatibility.c
index 9a8b8d67f36..5f9d8106794 100644
--- a/libs/libglibc-compatibility/glibc-compatibility.c
+++ b/libs/libglibc-compatibility/glibc-compatibility.c
@@ -1,8 +1,6 @@
 /** Allows to build programs with libc 2.18 and run on systems with at least libc 2.4,
   *  such as Ubuntu Lucid or CentOS 6.
   *
-  * Highly experimental, not recommended, disabled by default.
-  *
   * Also look at http://www.lightofdawn.org/wiki/wiki.cgi/NewAppsOnOldGlibc
   */
 

From bc622c4c45ae07fcd7fe37d208827c005e4d2385 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 17 Sep 2017 03:13:26 +0300
Subject: [PATCH 261/266] Better [#CLICKHOUSE-2].

---
 dbms/src/Common/CurrentMetrics.h  | 10 +++++-----
 dbms/src/Common/MemoryTracker.cpp | 28 +++++++++++++++++-----------
 dbms/src/Common/ProfileEvents.h   |  2 +-
 3 files changed, 23 insertions(+), 17 deletions(-)

diff --git a/dbms/src/Common/CurrentMetrics.h b/dbms/src/Common/CurrentMetrics.h
index e677bd2e1d8..82384475e3c 100644
--- a/dbms/src/Common/CurrentMetrics.h
+++ b/dbms/src/Common/CurrentMetrics.h
@@ -36,13 +36,13 @@ namespace CurrentMetrics
     /// Set value of specified metric.
     inline void set(Metric metric, Value value)
     {
-        values[metric] = value;
+        values[metric].store(value, std::memory_order_relaxed);
     }
 
     /// Add value for specified metric. You must subtract value later; or see class Increment below.
     inline void add(Metric metric, Value value = 1)
     {
-        values[metric] += value;
+        values[metric].fetch_add(value, std::memory_order_relaxed);
     }
 
     inline void sub(Metric metric, Value value = 1)
@@ -70,7 +70,7 @@ namespace CurrentMetrics
         ~Increment()
         {
             if (what)
-                *what -= amount;
+                what->fetch_sub(amount, std::memory_order_relaxed);
         }
 
         Increment(Increment && old)
@@ -88,14 +88,14 @@ namespace CurrentMetrics
 
         void changeTo(Value new_amount)
         {
-            *what += new_amount - amount;
+            what->fetch_add(new_amount - amount, std::memory_order_relaxed);
             amount = new_amount;
         }
 
         /// Subtract value before destructor.
         void destroy()
         {
-            *what -= amount;
+            what->fetch_sub(amount, std::memory_order_relaxed);
             what = nullptr;
         }
     };
diff --git a/dbms/src/Common/MemoryTracker.cpp b/dbms/src/Common/MemoryTracker.cpp
index 76695b1bd19..a5312d3949e 100644
--- a/dbms/src/Common/MemoryTracker.cpp
+++ b/dbms/src/Common/MemoryTracker.cpp
@@ -32,8 +32,8 @@ MemoryTracker::~MemoryTracker()
       *  then memory usage of 'next' memory trackers will be underestimated,
       *  because amount will be decreased twice (first - here, second - when real 'free' happens).
       */
-    if (amount)
-        free(amount);
+    if (auto value = amount.load(std::memory_order_relaxed))
+        free(value);
 }
 
 
@@ -47,7 +47,11 @@ void MemoryTracker::logPeakMemoryUsage() const
 
 void MemoryTracker::alloc(Int64 size)
 {
-    Int64 will_be = amount += size;
+    /** Using memory_order_relaxed means that if allocations are done simultaneously,
+      *  we allow exception about memory limit exceeded to be thrown only on next allocation.
+      * So, we allow over-allocations.
+      */
+    Int64 will_be = size + amount.fetch_add(size, std::memory_order_relaxed);
 
     if (!next.load(std::memory_order_relaxed))
         CurrentMetrics::add(metric, size);
@@ -96,29 +100,31 @@ void MemoryTracker::alloc(Int64 size)
 
 void MemoryTracker::free(Int64 size)
 {
+    Int64 new_amount = amount.fetch_sub(size, std::memory_order_relaxed) - size;
+
     /** Sometimes, query could free some data, that was allocated outside of query context.
       * Example: cache eviction.
       * To avoid negative memory usage, we "saturate" amount.
       * Memory usage will be calculated with some error.
+      * NOTE The code is not atomic. Not worth to fix.
       */
-    Int64 size_to_subtract = size;
-    if (size_to_subtract > amount)
-        size_to_subtract = amount;
-
-    amount -= size_to_subtract;
-    /// NOTE above code is not atomic. It's easy to fix.
+    if (new_amount < 0)
+    {
+        amount.fetch_sub(new_amount);
+        size += new_amount;
+    }
 
     if (auto loaded_next = next.load(std::memory_order_relaxed))
         loaded_next->free(size);
     else
-        CurrentMetrics::sub(metric, size_to_subtract);
+        CurrentMetrics::sub(metric, size);
 }
 
 
 void MemoryTracker::reset()
 {
     if (!next.load(std::memory_order_relaxed))
-        CurrentMetrics::sub(metric, amount);
+        CurrentMetrics::sub(metric, amount.load(std::memory_order_relaxed));
 
     amount.store(0, std::memory_order_relaxed);
     peak.store(0, std::memory_order_relaxed);
diff --git a/dbms/src/Common/ProfileEvents.h b/dbms/src/Common/ProfileEvents.h
index 1d5dceb0e27..0cb88f0ceed 100644
--- a/dbms/src/Common/ProfileEvents.h
+++ b/dbms/src/Common/ProfileEvents.h
@@ -24,7 +24,7 @@ namespace ProfileEvents
     /// Increment a counter for event. Thread-safe.
     inline void increment(Event event, Count amount = 1)
     {
-        counters[event] += amount;
+        counters[event].fetch_add(amount, std::memory_order_relaxed);
     }
 
     /// Get index just after last event identifier.

From 565902fc4d6c7a276f47e806f925a1dd74b609e7 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 17 Sep 2017 20:58:30 +0300
Subject: [PATCH 262/266] Added comment; fixed test [#CLICKHOUSE-2].

---
 dbms/src/Functions/FunctionsRound.h           |   47 +-
 .../00161_rounding_functions.reference        | 1541 ++++++++---------
 .../0_stateless/00161_rounding_functions.sql  |  999 +----------
 3 files changed, 760 insertions(+), 1827 deletions(-)

diff --git a/dbms/src/Functions/FunctionsRound.h b/dbms/src/Functions/FunctionsRound.h
index efeae9d5a15..c1c953e68e7 100644
--- a/dbms/src/Functions/FunctionsRound.h
+++ b/dbms/src/Functions/FunctionsRound.h
@@ -14,12 +14,6 @@
 #endif
 
 
-/** If you want negative zeros will be replaced by zeros in result of calculations.
-  * Disabled by performance reasons.
-#define NO_NEGATIVE_ZEROS
-  */
-
-
 namespace DB
 {
 
@@ -30,18 +24,25 @@ namespace ErrorCodes
 
 
 /** Rounding Functions:
-    * roundToExp2 - down to the nearest power of two;
-    * roundDuration - down to the nearest of: 0, 1, 10, 30, 60, 120, 180, 240, 300, 600, 1200, 1800, 3600, 7200, 18000, 36000;
-    * roundAge - down to the nearest of: 0, 18, 25, 35, 45, 55.
+    * round(x, N) - rounding to nearest (N = 0 by default). Use banker's rounding for floating point numbers.
+    * floor(x, N) is the largest number <= x (N = 0 by default).
+    * ceil(x, N) is the smallest number >= x (N = 0 by default).
+    * trunc(x, N) - is the largest by absolute value number that is not greater than x by absolute value (N = 0 by default).
     *
-    * round(x, N) - arithmetic rounding (N = 0 by default).
-    * ceil(x, N) is the smallest number that is at least x (N = 0 by default).
-    * floor(x, N) is the largest number that is not greater than x (N = 0 by default).
-    *
-    * The value of the parameter N:
+    * The value of the parameter N (scale):
     * - N > 0: round to the number with N decimal places after the decimal point
     * - N < 0: round to an integer with N zero characters
     * - N = 0: round to an integer
+    *
+    * Type of the result is the type of argument.
+    * For integer arguments, when passing negative scale, overflow can occur.
+    * In that case, the behavior is implementation specific.
+    *
+    * roundToExp2 - down to the nearest power of two (see below);
+    *
+    * Deprecated functions:
+    * roundDuration - down to the nearest of: 0, 1, 10, 30, 60, 120, 180, 240, 300, 600, 1200, 1800, 3600, 7200, 18000, 36000;
+    * roundAge - down to the nearest of: 0, 18, 25, 35, 45, 55.
     */
 
 template <typename T>
@@ -72,6 +73,16 @@ roundDownToPowerOfTwo(T x)
     return ext::bit_cast<T>(ext::bit_cast<UInt64>(x) & ~((1ULL << 52) - 1));
 }
 
+/** For integer data types:
+  * - if number is greater than zero, round it down to nearest power of two (example: roundToExp2(100) = 64, roundToExp2(64) = 64);
+  * - otherwise, return 0.
+  *
+  * For floating point data types: zero out mantissa, but leave exponent.
+  * - if number is greater than zero, round it down to nearest power of two (example: roundToExp2(3) = 2);
+  * - negative powers are also used (example: roundToExp2(0.7) = 0.5);
+  * - if number is zero, return zero;
+  * - if number is less than zero, the result is symmetrical: roundToExp2(x) = -roundToExp2(-x). (example: roundToExp2(-0.3) = -0.25);
+  */
 
 template <typename T>
 struct RoundToExp2Impl
@@ -467,8 +478,12 @@ struct Dispatcher
             if (!scale_column.isConst())
                 throw Exception("Scale argument for rounding functions must be constant.", ErrorCodes::ILLEGAL_COLUMN);
 
-            scale_arg = applyVisitor(FieldVisitorConvertToNumber<Int64>(),
-                static_cast<const ColumnConst &>(scale_column).getField());
+            Field scale_field = static_cast<const ColumnConst &>(scale_column).getField();
+            if (scale_field.getType() != Field::Types::UInt64
+                && scale_field.getType() != Field::Types::Int64)
+                throw Exception("Scale argument for rounding functions must have integer type.", ErrorCodes::ILLEGAL_COLUMN);
+
+            scale_arg = scale_field.get<Int64>();
         }
 
         auto col_res = std::make_shared<ColumnVector<T>>();
diff --git a/dbms/tests/queries/0_stateless/00161_rounding_functions.reference b/dbms/tests/queries/0_stateless/00161_rounding_functions.reference
index 009a2080687..9fa1965657e 100644
--- a/dbms/tests/queries/0_stateless/00161_rounding_functions.reference
+++ b/dbms/tests/queries/0_stateless/00161_rounding_functions.reference
@@ -1,857 +1,684 @@
-0	0	0
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
-3	3	2
-2	2	2
--3	-2	-3
--2	-2	-3
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-10	20	10
-10	20	10
-10	20	10
-10	20	10
-13	20	10
-13	20	10
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-0	0	0
-0	0	0
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-10	20	10
-10	20	10
-10	20	10
-10	20	10
-13	20	10
-13	20	10
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-10	20	10
-10	20	10
-10	20	10
-10	20	10
-13	20	10
-13	20	10
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-10	20	10
-10	20	10
-10	20	10
-10	20	10
-13	20	10
-13	20	10
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-10	20	10
-10	20	10
-10	20	10
-10	20	10
-13	20	10
-13	20	10
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-0	0	0
-0	0	0
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-10	20	10
-10	20	10
-10	20	10
-10	20	10
-13	20	10
-13	20	10
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-10	20	10
-10	20	10
-10	20	10
-10	20	10
-13	20	10
-13	20	10
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-10	20	10
-10	20	10
-10	20	10
-10	20	10
-13	20	10
-13	20	10
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-10	20	10
-10	20	10
-10	20	10
-10	20	10
-13	20	10
-13	20	10
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-13	13	13
-10	20	10
-10	20	10
-10	20	10
-10	20	10
-13	20	10
-13	20	10
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-0	100	0
-0	100	0
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--10	-20	-10
--10	-20	-10
--10	-20	-10
--10	-20	-10
--13	-20	-10
--13	-20	-10
-0	-100	0
-0	-100	0
-0	-100	0
-0	-100	0
-0	0	0
-0	0	0
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--10	-20	-10
--10	-20	-10
--10	-20	-10
--10	-20	-10
--13	-20	-10
--13	-20	-10
-0	-100	0
-0	-100	0
-0	-100	0
-0	-100	0
-0	-100	0
-0	-100	0
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--10	-20	-10
--10	-20	-10
--10	-20	-10
--10	-20	-10
--13	-20	-10
--13	-20	-10
-0	-100	0
-0	-100	0
-0	-100	0
-0	-100	0
-0	-100	0
-0	-100	0
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--10	-20	-10
--10	-20	-10
--10	-20	-10
--10	-20	-10
--13	-20	-10
--13	-20	-10
-0	-100	0
-0	-100	0
-0	-100	0
-0	-100	0
-0	-100	0
-0	-100	0
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--10	-20	-10
--10	-20	-10
--10	-20	-10
--10	-20	-10
--13	-20	-10
--13	-20	-10
-0	-100	0
-0	-100	0
-0	-100	0
-0	-100	0
-0	-100	0
-0	-100	0
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--13	-13	-13
--10	-20	-10
--10	-20	-10
--10	-20	-10
--10	-20	-10
--13	-20	-10
--13	-20	-10
-0	-100	0
-0	-100	0
-0	-100	0
-0	-100	0
-0	-100	0
-0	-100	0
-2.72	2.72	2.71
-2.72	2.72	2.71
-2.72	2.72	2.71
-2.72	2.72	2.71
-2.72	2.72	2.71
-2.72	2.72	2.71
-2.72	2.72	2.71
-2.72	2.72	2.71
-2.72	2.72	2.71
-2.72	2.72	2.71
-2.7	2.8	2.7
-2.7	2.8	2.7
-2.7	2.8	2.7
-2.7	2.8	2.7
-2.7	2.8	2.7
-2.7	2.8	2.7
-2.7	2.8	2.7
-2.7	2.8	2.7
-2.7	2.8	2.7
-2.7	2.8	2.7
-3	3	2
-3	3	2
-3	3	2
-3	3	2
-3	3	2
-3	3	2
-3	3	2
-3	3	2
-3	3	2
-0	10	0
-0	10	0
-0	10	0
-0	10	0
-2.7	10	0
-2.7	10	0
-0	0	0
-0	0	0
-0	0	0
-0	0	0
-0	0	0
-0	0	0
--2.72	-2.71	-2.72
--2.72	-2.71	-2.72
--2.72	-2.71	-2.72
--2.72	-2.71	-2.72
--2.72	-2.71	-2.72
--2.72	-2.71	-2.72
--2.72	-2.71	-2.72
--2.72	-2.71	-2.72
--2.72	-2.71	-2.72
--2.72	-2.71	-2.72
--2.7	-2.7	-2.8
--2.7	-2.7	-2.8
--2.7	-2.7	-2.8
--2.7	-2.7	-2.8
--2.7	-2.7	-2.8
--2.7	-2.7	-2.8
--2.7	-2.7	-2.8
--2.7	-2.7	-2.8
--2.7	-2.7	-2.8
--2.7	-2.7	-2.8
--3	-2	-3
--3	-2	-3
--3	-2	-3
--3	-2	-3
--3	-2	-3
--3	-2	-3
--3	-2	-3
--3	-2	-3
--3	-2	-3
-0	-10	0
-0	-10	0
-0	-10	0
-0	-10	0
--2.7	-10	0
--2.7	-10	0
-0	0	0
-0	0	0
-0	0	0
-0	0	0
-0	0	0
-0	0	0
-13112220	13112230	13112220
-13112200	13112300	13112200
-13112000	13113000	13112000
-13110000	13120000	13110000
-13100000	13200000	13100000
-13000000	14000000	13000000
-10000000	20000000	10000000
-0	100000000	0
-0	1000000000	0
-0	0	0
-0	0	0
-0	0	0
-0	0	0
-0	0	0
-0	0	0
-0	0	0
-0	0	0
-0	0	0
-0	0	0
-0	0	0
-2.7	2.8	2.7
-2.72	2.72	2.71
-2.718	2.719	2.718
-2.7183	2.7183	2.7182
-2.71828	2.71829	2.71828
-2.718282	2.718282	2.718281
-2.7182818	2.7182819	2.7182818
-2.71828183	2.71828183	2.71828182
-2.718281828	2.718281829	2.718281828
-2.7182818285	2.7182818285	2.7182818284
-2.71828182846	2.71828182846	2.71828182845
-2.718281828459	2.71828182846	2.718281828459
-2.718281828459	2.7182818284591	2.718281828459
-2.71828182845904	2.71828182845905	2.71828182845904
-2.718281828459045	2.718281828459045	2.718281828459045
-2.718281828459045	2.718281828459045	2.718281828459045
-2.718281828459045	2.718281828459045	2.718281828459045
-2.718281828459045	2.718281828459045	2.718281828459045
-2.718281828459045	2.718281828459045	2.718281828459045
-2.718281828459045	2.718281828459045	2.718281828459045
-3.718
-3.718
-3.218
-3.718
-3.218
-2.918
-3.718
-3.218
-2.918
-2.818
-3.718
-3.218
-2.918
-2.818
-2.777
-3.718
-3.218
-2.918
-2.818
-2.777
-2.757
-3.718
-3.218
-2.918
-2.818
-2.777
-2.757
-2.745
-3.718
-3.218
-2.918
-2.818
-2.777
-2.757
-2.745
-2.738
-3.718
-3.218
-2.918
-2.818
-2.777
-2.757
-2.745
-2.738
-2.734
-3.718
-3.218
-2.918
-2.818
-2.777
-2.757
-2.745
-2.738
-2.734
-2.73
-0
-0
-0
+0	0	0	0	0
+1	1	1	1	1
+2	2	2	2	2
+3	3	3	3	3
+4	4	4	4	4
+5	5	5	5	5
+6	6	6	6	6
+7	7	7	7	7
+8	8	8	8	8
+9	9	9	9	9
+10	10	10	10	10
+11	11	11	11	11
+12	12	12	12	12
+13	13	13	13	13
+14	14	14	14	14
+15	15	15	15	15
+16	16	16	16	16
+17	17	17	17	17
+18	18	18	18	18
+19	19	19	19	19
+0	0	0	0	0
+1	1	1	1	1
+2	2	2	2	2
+3	3	3	3	3
+4	4	4	4	4
+5	5	5	5	5
+6	6	6	6	6
+7	7	7	7	7
+8	8	8	8	8
+9	9	9	9	9
+10	10	10	10	10
+11	11	11	11	11
+12	12	12	12	12
+13	13	13	13	13
+14	14	14	14	14
+15	15	15	15	15
+16	16	16	16	16
+17	17	17	17	17
+18	18	18	18	18
+19	19	19	19	19
+0	0	0	0	0
+1	1	1	1	1
+2	2	2	2	2
+3	3	3	3	3
+4	4	4	4	4
+5	5	5	5	5
+6	6	6	6	6
+7	7	7	7	7
+8	8	8	8	8
+9	9	9	9	9
+10	10	10	10	10
+11	11	11	11	11
+12	12	12	12	12
+13	13	13	13	13
+14	14	14	14	14
+15	15	15	15	15
+16	16	16	16	16
+17	17	17	17	17
+18	18	18	18	18
+19	19	19	19	19
+0	0	0	0	0
+1	1	1	1	1
+2	2	2	2	2
+3	3	3	3	3
+4	4	4	4	4
+5	5	5	5	5
+6	6	6	6	6
+7	7	7	7	7
+8	8	8	8	8
+9	9	9	9	9
+10	10	10	10	10
+11	11	11	11	11
+12	12	12	12	12
+13	13	13	13	13
+14	14	14	14	14
+15	15	15	15	15
+16	16	16	16	16
+17	17	17	17	17
+18	18	18	18	18
+19	19	19	19	19
+-10	-10	-10	-10	-10
+-9	-9	-9	-9	-9
+-8	-8	-8	-8	-8
+-7	-7	-7	-7	-7
+-6	-6	-6	-6	-6
+-5	-5	-5	-5	-5
+-4	-4	-4	-4	-4
+-3	-3	-3	-3	-3
+-2	-2	-2	-2	-2
+-1	-1	-1	-1	-1
+0	0	0	0	0
+1	1	1	1	1
+2	2	2	2	2
+3	3	3	3	3
+4	4	4	4	4
+5	5	5	5	5
+6	6	6	6	6
+7	7	7	7	7
+8	8	8	8	8
+9	9	9	9	9
+-10	-10	-10	-10	-10
+-9	-9	-9	-9	-9
+-8	-8	-8	-8	-8
+-7	-7	-7	-7	-7
+-6	-6	-6	-6	-6
+-5	-5	-5	-5	-5
+-4	-4	-4	-4	-4
+-3	-3	-3	-3	-3
+-2	-2	-2	-2	-2
+-1	-1	-1	-1	-1
+0	0	0	0	0
+1	1	1	1	1
+2	2	2	2	2
+3	3	3	3	3
+4	4	4	4	4
+5	5	5	5	5
+6	6	6	6	6
+7	7	7	7	7
+8	8	8	8	8
+9	9	9	9	9
+-10	-10	-10	-10	-10
+-9	-9	-9	-9	-9
+-8	-8	-8	-8	-8
+-7	-7	-7	-7	-7
+-6	-6	-6	-6	-6
+-5	-5	-5	-5	-5
+-4	-4	-4	-4	-4
+-3	-3	-3	-3	-3
+-2	-2	-2	-2	-2
+-1	-1	-1	-1	-1
+0	0	0	0	0
+1	1	1	1	1
+2	2	2	2	2
+3	3	3	3	3
+4	4	4	4	4
+5	5	5	5	5
+6	6	6	6	6
+7	7	7	7	7
+8	8	8	8	8
+9	9	9	9	9
+-10	-10	-10	-10	-10
+-9	-9	-9	-9	-9
+-8	-8	-8	-8	-8
+-7	-7	-7	-7	-7
+-6	-6	-6	-6	-6
+-5	-5	-5	-5	-5
+-4	-4	-4	-4	-4
+-3	-3	-3	-3	-3
+-2	-2	-2	-2	-2
+-1	-1	-1	-1	-1
+0	0	0	0	0
+1	1	1	1	1
+2	2	2	2	2
+3	3	3	3	3
+4	4	4	4	4
+5	5	5	5	5
+6	6	6	6	6
+7	7	7	7	7
+8	8	8	8	8
+9	9	9	9	9
+-10	-10	-10	-10	-10
+-9	-9	-9	-9	-9
+-8	-8	-8	-8	-8
+-7	-7	-7	-7	-7
+-6	-6	-6	-6	-6
+-5	-5	-5	-5	-5
+-4	-4	-4	-4	-4
+-3	-3	-3	-3	-3
+-2	-2	-2	-2	-2
+-1	-1	-1	-1	-1
+0	0	0	0	0
+1	1	1	1	1
+2	2	2	2	2
+3	3	3	3	3
+4	4	4	4	4
+5	5	5	5	5
+6	6	6	6	6
+7	7	7	7	7
+8	8	8	8	8
+9	9	9	9	9
+-10	-10	-10	-10	-10
+-9	-9	-9	-9	-9
+-8	-8	-8	-8	-8
+-7	-7	-7	-7	-7
+-6	-6	-6	-6	-6
+-5	-5	-5	-5	-5
+-4	-4	-4	-4	-4
+-3	-3	-3	-3	-3
+-2	-2	-2	-2	-2
+-1	-1	-1	-1	-1
+0	0	0	0	0
+1	1	1	1	1
+2	2	2	2	2
+3	3	3	3	3
+4	4	4	4	4
+5	5	5	5	5
+6	6	6	6	6
+7	7	7	7	7
+8	8	8	8	8
+9	9	9	9	9
+-1	-1	-1	-1	-1
+-0.9	-1	-1	-0	-0
+-0.8	-1	-1	-0	-0
+-0.7	-1	-1	-0	-0
+-0.6	-1	-1	-0	-0
+-0.5	-0	-1	-0	-0
+-0.4	-0	-1	-0	-0
+-0.3	-0	-1	-0	-0
+-0.2	-0	-1	-0	-0
+-0.1	-0	-1	-0	-0
+0	0	0	0	0
+0.1	0	0	1	0
+0.2	0	0	1	0
+0.3	0	0	1	0
+0.4	0	0	1	0
+0.5	0	0	1	0
+0.6	1	0	1	0
+0.7	1	0	1	0
+0.8	1	0	1	0
+0.9	1	0	1	0
+-1	-1	-1	-1	-1
+-0.9	-1	-1	-0	-0
+-0.8	-1	-1	-0	-0
+-0.7	-1	-1	-0	-0
+-0.6	-1	-1	-0	-0
+-0.5	-0	-1	-0	-0
+-0.4	-0	-1	-0	-0
+-0.3	-0	-1	-0	-0
+-0.2	-0	-1	-0	-0
+-0.1	-0	-1	-0	-0
+0	0	0	0	0
+0.1	0	0	1	0
+0.2	0	0	1	0
+0.3	0	0	1	0
+0.4	0	0	1	0
+0.5	0	0	1	0
+0.6	1	0	1	0
+0.7	1	0	1	0
+0.8	1	0	1	0
+0.9	1	0	1	0
+-1	-1	-1	-1	-1
+-0.9	-0.9	-0.9	-0.9	-0.9
+-0.8	-0.8	-0.8	-0.8	-0.8
+-0.7	-0.7	-0.7	-0.7	-0.7
+-0.6	-0.6	-0.6	-0.6	-0.6
+-0.5	-0.5	-0.5	-0.5	-0.5
+-0.4	-0.4	-0.4	-0.4	-0.4
+-0.3	-0.3	-0.3	-0.3	-0.3
+-0.2	-0.2	-0.2	-0.2	-0.2
+-0.1	-0.1	-0.1	-0.1	-0.1
+0	0	0	0	0
+0.1	0.1	0.1	0.1	0.1
+0.2	0.2	0.2	0.2	0.2
+0.3	0.3	0.3	0.3	0.3
+0.4	0.4	0.4	0.4	0.4
+0.5	0.5	0.5	0.5	0.5
+0.6	0.6	0.6	0.6	0.6
+0.7	0.7	0.7	0.7	0.7
+0.8	0.8	0.8	0.8	0.8
+0.9	0.9	0.9	0.9	0.9
+-1	-1	-1	-1	-1
+-0.9	-0.9	-0.9	-0.9	-0.9
+-0.8	-0.8	-0.8	-0.8	-0.8
+-0.7	-0.7	-0.7	-0.7	-0.7
+-0.6	-0.6	-0.6	-0.6	-0.6
+-0.5	-0.5	-0.5	-0.5	-0.5
+-0.4	-0.4	-0.4	-0.4	-0.4
+-0.3	-0.3	-0.3	-0.3	-0.3
+-0.2	-0.2	-0.2	-0.2	-0.2
+-0.1	-0.1	-0.1	-0.1	-0.1
+0	0	0	0	0
+0.1	0.1	0.1	0.1	0.1
+0.2	0.2	0.2	0.2	0.2
+0.3	0.3	0.3	0.3	0.3
+0.4	0.4	0.4	0.4	0.4
+0.5	0.5	0.5	0.5	0.5
+0.6	0.6	0.6	0.6	0.6
+0.7	0.7	0.7	0.7	0.7
+0.8	0.8	0.8	0.8	0.8
+0.9	0.9	0.9	0.9	0.9
+0	0	0	0	0
+1	0	0	10	0
+2	0	0	10	0
+3	0	0	10	0
+4	0	0	10	0
+5	10	0	10	0
+6	10	0	10	0
+7	10	0	10	0
+8	10	0	10	0
+9	10	0	10	0
+10	10	10	10	10
+11	10	10	20	10
+12	10	10	20	10
+13	10	10	20	10
+14	10	10	20	10
+15	20	10	20	10
+16	20	10	20	10
+17	20	10	20	10
+18	20	10	20	10
+19	20	10	20	10
+0	0	0	0	0
+1	0	0	10	0
+2	0	0	10	0
+3	0	0	10	0
+4	0	0	10	0
+5	10	0	10	0
+6	10	0	10	0
+7	10	0	10	0
+8	10	0	10	0
+9	10	0	10	0
+10	10	10	10	10
+11	10	10	20	10
+12	10	10	20	10
+13	10	10	20	10
+14	10	10	20	10
+15	20	10	20	10
+16	20	10	20	10
+17	20	10	20	10
+18	20	10	20	10
+19	20	10	20	10
+0	0	0	0	0
+1	0	0	10	0
+2	0	0	10	0
+3	0	0	10	0
+4	0	0	10	0
+5	10	0	10	0
+6	10	0	10	0
+7	10	0	10	0
+8	10	0	10	0
+9	10	0	10	0
+10	10	10	10	10
+11	10	10	20	10
+12	10	10	20	10
+13	10	10	20	10
+14	10	10	20	10
+15	20	10	20	10
+16	20	10	20	10
+17	20	10	20	10
+18	20	10	20	10
+19	20	10	20	10
+0	0	0	0	0
+1	0	0	10	0
+2	0	0	10	0
+3	0	0	10	0
+4	0	0	10	0
+5	10	0	10	0
+6	10	0	10	0
+7	10	0	10	0
+8	10	0	10	0
+9	10	0	10	0
+10	10	10	10	10
+11	10	10	20	10
+12	10	10	20	10
+13	10	10	20	10
+14	10	10	20	10
+15	20	10	20	10
+16	20	10	20	10
+17	20	10	20	10
+18	20	10	20	10
+19	20	10	20	10
+-10	-10	-10	-10	-10
+-9	-10	-10	0	0
+-8	-10	-10	0	0
+-7	-10	-10	0	0
+-6	-10	-10	0	0
+-5	-10	-10	0	0
+-4	0	-10	0	0
+-3	0	-10	0	0
+-2	0	-10	0	0
+-1	0	-10	0	0
+0	0	0	0	0
+1	0	0	10	0
+2	0	0	10	0
+3	0	0	10	0
+4	0	0	10	0
+5	10	0	10	0
+6	10	0	10	0
+7	10	0	10	0
+8	10	0	10	0
+9	10	0	10	0
+-10	-10	-10	-10	-10
+-9	-10	-10	0	0
+-8	-10	-10	0	0
+-7	-10	-10	0	0
+-6	-10	-10	0	0
+-5	-10	-10	0	0
+-4	0	-10	0	0
+-3	0	-10	0	0
+-2	0	-10	0	0
+-1	0	-10	0	0
+0	0	0	0	0
+1	0	0	10	0
+2	0	0	10	0
+3	0	0	10	0
+4	0	0	10	0
+5	10	0	10	0
+6	10	0	10	0
+7	10	0	10	0
+8	10	0	10	0
+9	10	0	10	0
+-10	-10	-10	-10	-10
+-9	-10	-10	0	0
+-8	-10	-10	0	0
+-7	-10	-10	0	0
+-6	-10	-10	0	0
+-5	-10	-10	0	0
+-4	0	-10	0	0
+-3	0	-10	0	0
+-2	0	-10	0	0
+-1	0	-10	0	0
+0	0	0	0	0
+1	0	0	10	0
+2	0	0	10	0
+3	0	0	10	0
+4	0	0	10	0
+5	10	0	10	0
+6	10	0	10	0
+7	10	0	10	0
+8	10	0	10	0
+9	10	0	10	0
+-10	-10	-10	-10	-10
+-9	-10	-10	0	0
+-8	-10	-10	0	0
+-7	-10	-10	0	0
+-6	-10	-10	0	0
+-5	-10	-10	0	0
+-4	0	-10	0	0
+-3	0	-10	0	0
+-2	0	-10	0	0
+-1	0	-10	0	0
+0	0	0	0	0
+1	0	0	10	0
+2	0	0	10	0
+3	0	0	10	0
+4	0	0	10	0
+5	10	0	10	0
+6	10	0	10	0
+7	10	0	10	0
+8	10	0	10	0
+9	10	0	10	0
+-10	-10	-10	-10	-10
+-9	-10	-10	-0	-0
+-8	-10	-10	-0	-0
+-7	-10	-10	-0	-0
+-6	-10	-10	-0	-0
+-5	-0	-10	-0	-0
+-4	-0	-10	-0	-0
+-3	-0	-10	-0	-0
+-2	-0	-10	-0	-0
+-1	-0	-10	-0	-0
+0	0	0	0	0
+1	0	0	10	0
+2	0	0	10	0
+3	0	0	10	0
+4	0	0	10	0
+5	0	0	10	0
+6	10	0	10	0
+7	10	0	10	0
+8	10	0	10	0
+9	10	0	10	0
+-10	-10	-10	-10	-10
+-9	-10	-10	-0	-0
+-8	-10	-10	-0	-0
+-7	-10	-10	-0	-0
+-6	-10	-10	-0	-0
+-5	-0	-10	-0	-0
+-4	-0	-10	-0	-0
+-3	-0	-10	-0	-0
+-2	-0	-10	-0	-0
+-1	-0	-10	-0	-0
+0	0	0	0	0
+1	0	0	10	0
+2	0	0	10	0
+3	0	0	10	0
+4	0	0	10	0
+5	0	0	10	0
+6	10	0	10	0
+7	10	0	10	0
+8	10	0	10	0
+9	10	0	10	0
+0	0	0	0	0
+1	0	0	100	0
+2	0	0	100	0
+3	0	0	100	0
+4	0	0	100	0
+5	0	0	100	0
+6	0	0	100	0
+7	0	0	100	0
+8	0	0	100	0
+9	0	0	100	0
+10	0	0	100	0
+11	0	0	100	0
+12	0	0	100	0
+13	0	0	100	0
+14	0	0	100	0
+15	0	0	100	0
+16	0	0	100	0
+17	0	0	100	0
+18	0	0	100	0
+19	0	0	100	0
+0	0	0	0	0
+1	0	0	100	0
+2	0	0	100	0
+3	0	0	100	0
+4	0	0	100	0
+5	0	0	100	0
+6	0	0	100	0
+7	0	0	100	0
+8	0	0	100	0
+9	0	0	100	0
+10	0	0	100	0
+11	0	0	100	0
+12	0	0	100	0
+13	0	0	100	0
+14	0	0	100	0
+15	0	0	100	0
+16	0	0	100	0
+17	0	0	100	0
+18	0	0	100	0
+19	0	0	100	0
+0	0	0	0	0
+1	0	0	100	0
+2	0	0	100	0
+3	0	0	100	0
+4	0	0	100	0
+5	0	0	100	0
+6	0	0	100	0
+7	0	0	100	0
+8	0	0	100	0
+9	0	0	100	0
+10	0	0	100	0
+11	0	0	100	0
+12	0	0	100	0
+13	0	0	100	0
+14	0	0	100	0
+15	0	0	100	0
+16	0	0	100	0
+17	0	0	100	0
+18	0	0	100	0
+19	0	0	100	0
+0	0	0	0	0
+1	0	0	100	0
+2	0	0	100	0
+3	0	0	100	0
+4	0	0	100	0
+5	0	0	100	0
+6	0	0	100	0
+7	0	0	100	0
+8	0	0	100	0
+9	0	0	100	0
+10	0	0	100	0
+11	0	0	100	0
+12	0	0	100	0
+13	0	0	100	0
+14	0	0	100	0
+15	0	0	100	0
+16	0	0	100	0
+17	0	0	100	0
+18	0	0	100	0
+19	0	0	100	0
+-10	0	-100	0	0
+-9	0	-100	0	0
+-8	0	-100	0	0
+-7	0	-100	0	0
+-6	0	-100	0	0
+-5	0	-100	0	0
+-4	0	-100	0	0
+-3	0	-100	0	0
+-2	0	-100	0	0
+-1	0	-100	0	0
+0	0	0	0	0
+1	0	0	100	0
+2	0	0	100	0
+3	0	0	100	0
+4	0	0	100	0
+5	0	0	100	0
+6	0	0	100	0
+7	0	0	100	0
+8	0	0	100	0
+9	0	0	100	0
+-10	0	-100	0	0
+-9	0	-100	0	0
+-8	0	-100	0	0
+-7	0	-100	0	0
+-6	0	-100	0	0
+-5	0	-100	0	0
+-4	0	-100	0	0
+-3	0	-100	0	0
+-2	0	-100	0	0
+-1	0	-100	0	0
+0	0	0	0	0
+1	0	0	100	0
+2	0	0	100	0
+3	0	0	100	0
+4	0	0	100	0
+5	0	0	100	0
+6	0	0	100	0
+7	0	0	100	0
+8	0	0	100	0
+9	0	0	100	0
+-10	0	-100	0	0
+-9	0	-100	0	0
+-8	0	-100	0	0
+-7	0	-100	0	0
+-6	0	-100	0	0
+-5	0	-100	0	0
+-4	0	-100	0	0
+-3	0	-100	0	0
+-2	0	-100	0	0
+-1	0	-100	0	0
+0	0	0	0	0
+1	0	0	100	0
+2	0	0	100	0
+3	0	0	100	0
+4	0	0	100	0
+5	0	0	100	0
+6	0	0	100	0
+7	0	0	100	0
+8	0	0	100	0
+9	0	0	100	0
+-10	0	-100	0	0
+-9	0	-100	0	0
+-8	0	-100	0	0
+-7	0	-100	0	0
+-6	0	-100	0	0
+-5	0	-100	0	0
+-4	0	-100	0	0
+-3	0	-100	0	0
+-2	0	-100	0	0
+-1	0	-100	0	0
+0	0	0	0	0
+1	0	0	100	0
+2	0	0	100	0
+3	0	0	100	0
+4	0	0	100	0
+5	0	0	100	0
+6	0	0	100	0
+7	0	0	100	0
+8	0	0	100	0
+9	0	0	100	0
+-10	-0	-100	-0	-0
+-9	-0	-100	-0	-0
+-8	-0	-100	-0	-0
+-7	-0	-100	-0	-0
+-6	-0	-100	-0	-0
+-5	-0	-100	-0	-0
+-4	-0	-100	-0	-0
+-3	-0	-100	-0	-0
+-2	-0	-100	-0	-0
+-1	-0	-100	-0	-0
+0	0	0	0	0
+1	0	0	100	0
+2	0	0	100	0
+3	0	0	100	0
+4	0	0	100	0
+5	0	0	100	0
+6	0	0	100	0
+7	0	0	100	0
+8	0	0	100	0
+9	0	0	100	0
+-10	-0	-100	-0	-0
+-9	-0	-100	-0	-0
+-8	-0	-100	-0	-0
+-7	-0	-100	-0	-0
+-6	-0	-100	-0	-0
+-5	-0	-100	-0	-0
+-4	-0	-100	-0	-0
+-3	-0	-100	-0	-0
+-2	-0	-100	-0	-0
+-1	-0	-100	-0	-0
+0	0	0	0	0
+1	0	0	100	0
+2	0	0	100	0
+3	0	0	100	0
+4	0	0	100	0
+5	0	0	100	0
+6	0	0	100	0
+7	0	0	100	0
+8	0	0	100	0
+9	0	0	100	0
+123456789	123456780	123456700	123456000	123450000	123400000	123000000	120000000	100000000	0	0
+12345.6789	12340	12300	12000	10000	0	12345.6	12345.67	12345.678	12345.6789	12345.6789
+64	64	2	0	0
+0.5	0	-0.5	-0.5	-0.125
diff --git a/dbms/tests/queries/0_stateless/00161_rounding_functions.sql b/dbms/tests/queries/0_stateless/00161_rounding_functions.sql
index d3b4d19c3c9..4930d9d0ace 100644
--- a/dbms/tests/queries/0_stateless/00161_rounding_functions.sql
+++ b/dbms/tests/queries/0_stateless/00161_rounding_functions.sql
@@ -1,954 +1,45 @@
-/* Без дополнительного параметра */
-
-SELECT round(0), ceil(0), floor(0);
-
-SELECT round(toUInt8(13)), ceil(toUInt8(13)), floor(toUInt8(13));
-SELECT round(toUInt16(13)), ceil(toUInt16(13)), floor(toUInt16(13));
-SELECT round(toUInt32(13)), ceil(toUInt32(13)), floor(toUInt32(13));
-SELECT round(toUInt64(13)), ceil(toUInt64(13)), floor(toUInt64(13));
-SELECT round(toInt8(13)), ceil(toInt8(13)), floor(toInt8(13));
-SELECT round(toInt16(13)), ceil(toInt16(13)), floor(toInt16(13));
-SELECT round(toInt32(13)), ceil(toInt32(13)), floor(toInt32(13));
-SELECT round(toInt64(13)), ceil(toInt64(13)), floor(toInt64(13));
-SELECT round(toFloat32(13)), ceil(toFloat32(13)), floor(toFloat32(13));
-SELECT round(toFloat64(13)), ceil(toFloat64(13)), floor(toFloat64(13));
-
-SELECT round(toInt8(-13)), ceil(toInt8(-13)), floor(toInt8(-13));
-SELECT round(toInt16(-13)), ceil(toInt16(-13)), floor(toInt16(-13));
-SELECT round(toInt32(-13)), ceil(toInt32(-13)), floor(toInt32(-13));
-SELECT round(toInt64(-13)), ceil(toInt64(-13)), floor(toInt64(-13));
-SELECT round(toFloat32(-13)), ceil(toFloat32(-13)), floor(toFloat32(-13));
-SELECT round(toFloat64(-13)), ceil(toFloat64(-13)), floor(toFloat64(-13));
-
-SELECT round(2.7), ceil(2.7), floor(2.7);
-SELECT round(2.1), ceil(2,1), floor(2.1);
-
-SELECT round(-2.7), ceil(-2.7), floor(-2.7);
-SELECT round(-2.1), ceil(-2,1), floor(-2.1);
-
-/* UInt8 */
-
-SELECT round(toUInt8(13), toUInt8(2)), ceil(toUInt8(13), toUInt8(2)), floor(toUInt8(13), toUInt8(2));
-SELECT round(toUInt8(13), toUInt16(2)), ceil(toUInt8(13), toUInt16(2)), floor(toUInt8(13), toUInt16(2));
-SELECT round(toUInt8(13), toUInt32(2)), ceil(toUInt8(13), toUInt32(2)), floor(toUInt8(13), toUInt32(2));
-SELECT round(toUInt8(13), toUInt64(2)), ceil(toUInt8(13), toUInt64(2)), floor(toUInt8(13), toUInt64(2));
-SELECT round(toUInt8(13), toInt8(2)), ceil(toUInt8(13), toInt8(2)), floor(toUInt8(13), toInt8(2));
-SELECT round(toUInt8(13), toInt16(2)), ceil(toUInt8(13), toInt16(2)), floor(toUInt8(13), toInt16(2));
-SELECT round(toUInt8(13), toInt32(2)), ceil(toUInt8(13), toInt32(2)), floor(toUInt8(13), toInt32(2));
-SELECT round(toUInt8(13), toInt64(2)), ceil(toUInt8(13), toInt64(2)), floor(toUInt8(13), toInt64(2));
-SELECT round(toUInt8(13), toFloat32(2.1)), ceil(toUInt8(13), toFloat32(2.1)), floor(toUInt8(13), toFloat32(2.1));
-SELECT round(toUInt8(13), toFloat64(2.1)), ceil(toUInt8(13), toFloat64(2.1)), floor(toUInt8(13), toFloat64(2.1));
-
-SELECT round(toUInt8(13), toUInt8(1)), ceil(toUInt8(13), toUInt8(1)), floor(toUInt8(13), toUInt8(1));
-SELECT round(toUInt8(13), toUInt16(1)), ceil(toUInt8(13), toUInt16(1)), floor(toUInt8(13), toUInt16(1));
-SELECT round(toUInt8(13), toUInt32(1)), ceil(toUInt8(13), toUInt32(1)), floor(toUInt8(13), toUInt32(1));
-SELECT round(toUInt8(13), toUInt64(1)), ceil(toUInt8(13), toUInt64(1)), floor(toUInt8(13), toUInt64(1));
-SELECT round(toUInt8(13), toInt8(1)), ceil(toUInt8(13), toInt8(1)), floor(toUInt8(13), toInt8(1));
-SELECT round(toUInt8(13), toInt16(1)), ceil(toUInt8(13), toInt16(1)), floor(toUInt8(13), toInt16(1));
-SELECT round(toUInt8(13), toInt32(1)), ceil(toUInt8(13), toInt32(1)), floor(toUInt8(13), toInt32(1));
-SELECT round(toUInt8(13), toInt64(1)), ceil(toUInt8(13), toInt64(1)), floor(toUInt8(13), toInt64(1));
-SELECT round(toUInt8(13), toFloat32(1.1)), ceil(toUInt8(13), toFloat32(1.1)), floor(toUInt8(13), toFloat32(1.1));
-SELECT round(toUInt8(13), toFloat64(1.1)), ceil(toUInt8(13), toFloat64(1.1)), floor(toUInt8(13), toFloat64(1.1));
-
-SELECT round(toUInt8(13), toUInt16(0)), ceil(toUInt8(13), toUInt16(0)), floor(toUInt8(13), toUInt16(0));
-SELECT round(toUInt8(13), toUInt32(0)), ceil(toUInt8(13), toUInt32(0)), floor(toUInt8(13), toUInt32(0));
-SELECT round(toUInt8(13), toUInt64(0)), ceil(toUInt8(13), toUInt64(0)), floor(toUInt8(13), toUInt64(0));
-SELECT round(toUInt8(13), toInt8(0)), ceil(toUInt8(13), toInt8(0)), floor(toUInt8(13), toInt8(0));
-SELECT round(toUInt8(13), toInt16(0)), ceil(toUInt8(13), toInt16(0)), floor(toUInt8(13), toInt16(0));
-SELECT round(toUInt8(13), toInt32(0)), ceil(toUInt8(13), toInt32(0)), floor(toUInt8(13), toInt32(0));
-SELECT round(toUInt8(13), toInt64(0)), ceil(toUInt8(13), toInt64(0)), floor(toUInt8(13), toInt64(0));
-SELECT round(toUInt8(13), toFloat32(0.1)), ceil(toUInt8(13), toFloat32(0.1)), floor(toUInt8(13), toFloat32(0.1));
-SELECT round(toUInt8(13), toFloat64(0.1)), ceil(toUInt8(13), toFloat64(0.1)), floor(toUInt8(13), toFloat64(0.1));
-
-SELECT round(toUInt8(13), toInt8(-1)), ceil(toUInt8(13), toInt8(-1)), floor(toUInt8(13), toInt8(-1));
-SELECT round(toUInt8(13), toInt16(-1)), ceil(toUInt8(13), toInt16(-1)), floor(toUInt8(13), toInt16(-1));
-SELECT round(toUInt8(13), toInt32(-1)), ceil(toUInt8(13), toInt32(-1)), floor(toUInt8(13), toInt32(-1));
-SELECT round(toUInt8(13), toInt64(-1)), ceil(toUInt8(13), toInt64(-1)), floor(toUInt8(13), toInt64(-1));
-SELECT round(toUInt8(13), toFloat32(1.1)), ceil(toUInt8(13), toFloat32(-1.1)), floor(toUInt8(13), toFloat32(-1.1));
-SELECT round(toUInt8(13), toFloat64(1.1)), ceil(toUInt8(13), toFloat64(-1.1)), floor(toUInt8(13), toFloat64(-1.1));
-
-SELECT round(toUInt8(13), toInt8(-2)), ceil(toUInt8(13), toInt8(-2)), floor(toUInt8(13), toInt8(-2));
-SELECT round(toUInt8(13), toInt16(-2)), ceil(toUInt8(13), toInt16(-2)), floor(toUInt8(13), toInt16(-2));
-SELECT round(toUInt8(13), toInt32(-2)), ceil(toUInt8(13), toInt32(-2)), floor(toUInt8(13), toInt32(-2));
-SELECT round(toUInt8(13), toInt64(-2)), ceil(toUInt8(13), toInt64(-2)), floor(toUInt8(13), toInt64(-2));
-SELECT round(toUInt8(13), toFloat32(-2.1)), ceil(toUInt8(13), toFloat32(-2.1)), floor(toUInt8(13), toFloat32(-2.1));
-SELECT round(toUInt8(13), toFloat64(-2.1)), ceil(toUInt8(13), toFloat64(-2.1)), floor(toUInt8(13), toFloat64(-2.1));
-
-/* UInt16 */
-
-SELECT round(toUInt16(13), toUInt8(2)), ceil(toUInt16(13), toUInt8(2)), floor(toUInt16(13), toUInt8(2));
-SELECT round(toUInt16(13), toUInt16(2)), ceil(toUInt16(13), toUInt16(2)), floor(toUInt16(13), toUInt16(2));
-SELECT round(toUInt16(13), toUInt32(2)), ceil(toUInt16(13), toUInt32(2)), floor(toUInt16(13), toUInt32(2));
-SELECT round(toUInt16(13), toUInt64(2)), ceil(toUInt16(13), toUInt64(2)), floor(toUInt16(13), toUInt64(2));
-SELECT round(toUInt16(13), toInt8(2)), ceil(toUInt16(13), toInt8(2)), floor(toUInt16(13), toInt8(2));
-SELECT round(toUInt16(13), toInt16(2)), ceil(toUInt16(13), toInt16(2)), floor(toUInt16(13), toInt16(2));
-SELECT round(toUInt16(13), toInt32(2)), ceil(toUInt16(13), toInt32(2)), floor(toUInt16(13), toInt32(2));
-SELECT round(toUInt16(13), toInt64(2)), ceil(toUInt16(13), toInt64(2)), floor(toUInt16(13), toInt64(2));
-SELECT round(toUInt16(13), toFloat32(2.1)), ceil(toUInt16(13), toFloat32(2.1)), floor(toUInt16(13), toFloat32(2.1));
-SELECT round(toUInt16(13), toFloat64(2.1)), ceil(toUInt16(13), toFloat64(2.1)), floor(toUInt16(13), toFloat64(2.1));
-
-SELECT round(toUInt16(13), toUInt8(1)), ceil(toUInt16(13), toUInt8(1)), floor(toUInt16(13), toUInt8(1));
-SELECT round(toUInt16(13), toUInt16(1)), ceil(toUInt16(13), toUInt16(1)), floor(toUInt16(13), toUInt16(1));
-SELECT round(toUInt16(13), toUInt32(1)), ceil(toUInt16(13), toUInt32(1)), floor(toUInt16(13), toUInt32(1));
-SELECT round(toUInt16(13), toUInt64(1)), ceil(toUInt16(13), toUInt64(1)), floor(toUInt16(13), toUInt64(1));
-SELECT round(toUInt16(13), toInt8(1)), ceil(toUInt16(13), toInt8(1)), floor(toUInt16(13), toInt8(1));
-SELECT round(toUInt16(13), toInt16(1)), ceil(toUInt16(13), toInt16(1)), floor(toUInt16(13), toInt16(1));
-SELECT round(toUInt16(13), toInt32(1)), ceil(toUInt16(13), toInt32(1)), floor(toUInt16(13), toInt32(1));
-SELECT round(toUInt16(13), toInt64(1)), ceil(toUInt16(13), toInt64(1)), floor(toUInt16(13), toInt64(1));
-SELECT round(toUInt16(13), toFloat32(1.1)), ceil(toUInt16(13), toFloat32(1.1)), floor(toUInt16(13), toFloat32(1.1));
-SELECT round(toUInt16(13), toFloat64(1.1)), ceil(toUInt16(13), toFloat64(1.1)), floor(toUInt16(13), toFloat64(1.1));
-
-SELECT round(toUInt16(13), toUInt16(0)), ceil(toUInt16(13), toUInt16(0)), floor(toUInt16(13), toUInt16(0));
-SELECT round(toUInt16(13), toUInt32(0)), ceil(toUInt16(13), toUInt32(0)), floor(toUInt16(13), toUInt32(0));
-SELECT round(toUInt16(13), toUInt64(0)), ceil(toUInt16(13), toUInt64(0)), floor(toUInt16(13), toUInt64(0));
-SELECT round(toUInt16(13), toInt8(0)), ceil(toUInt16(13), toInt8(0)), floor(toUInt16(13), toInt8(0));
-SELECT round(toUInt16(13), toInt16(0)), ceil(toUInt16(13), toInt16(0)), floor(toUInt16(13), toInt16(0));
-SELECT round(toUInt16(13), toInt32(0)), ceil(toUInt16(13), toInt32(0)), floor(toUInt16(13), toInt32(0));
-SELECT round(toUInt16(13), toInt64(0)), ceil(toUInt16(13), toInt64(0)), floor(toUInt16(13), toInt64(0));
-SELECT round(toUInt16(13), toFloat32(0.1)), ceil(toUInt16(13), toFloat32(0.1)), floor(toUInt16(13), toFloat32(0.1));
-SELECT round(toUInt16(13), toFloat64(0.1)), ceil(toUInt16(13), toFloat64(0.1)), floor(toUInt16(13), toFloat64(0.1));
-
-SELECT round(toUInt16(13), toInt8(-1)), ceil(toUInt16(13), toInt8(-1)), floor(toUInt16(13), toInt8(-1));
-SELECT round(toUInt16(13), toInt16(-1)), ceil(toUInt16(13), toInt16(-1)), floor(toUInt16(13), toInt16(-1));
-SELECT round(toUInt16(13), toInt32(-1)), ceil(toUInt16(13), toInt32(-1)), floor(toUInt16(13), toInt32(-1));
-SELECT round(toUInt16(13), toInt64(-1)), ceil(toUInt16(13), toInt64(-1)), floor(toUInt16(13), toInt64(-1));
-SELECT round(toUInt16(13), toFloat32(1.1)), ceil(toUInt16(13), toFloat32(-1.1)), floor(toUInt16(13), toFloat32(-1.1));
-SELECT round(toUInt16(13), toFloat64(1.1)), ceil(toUInt16(13), toFloat64(-1.1)), floor(toUInt16(13), toFloat64(-1.1));
-
-SELECT round(toUInt16(13), toInt8(-2)), ceil(toUInt16(13), toInt8(-2)), floor(toUInt16(13), toInt8(-2));
-SELECT round(toUInt16(13), toInt16(-2)), ceil(toUInt16(13), toInt16(-2)), floor(toUInt16(13), toInt16(-2));
-SELECT round(toUInt16(13), toInt32(-2)), ceil(toUInt16(13), toInt32(-2)), floor(toUInt16(13), toInt32(-2));
-SELECT round(toUInt16(13), toInt64(-2)), ceil(toUInt16(13), toInt64(-2)), floor(toUInt16(13), toInt64(-2));
-SELECT round(toUInt16(13), toFloat32(-2.1)), ceil(toUInt16(13), toFloat32(-2.1)), floor(toUInt16(13), toFloat32(-2.1));
-SELECT round(toUInt16(13), toFloat64(-2.1)), ceil(toUInt16(13), toFloat64(-2.1)), floor(toUInt16(13), toFloat64(-2.1));
-
-/* UInt32 */
-
-SELECT round(toUInt32(13), toUInt8(2)), ceil(toUInt32(13), toUInt8(2)), floor(toUInt32(13), toUInt8(2));
-SELECT round(toUInt32(13), toUInt16(2)), ceil(toUInt32(13), toUInt16(2)), floor(toUInt32(13), toUInt16(2));
-SELECT round(toUInt32(13), toUInt32(2)), ceil(toUInt32(13), toUInt32(2)), floor(toUInt32(13), toUInt32(2));
-SELECT round(toUInt32(13), toUInt64(2)), ceil(toUInt32(13), toUInt64(2)), floor(toUInt32(13), toUInt64(2));
-SELECT round(toUInt32(13), toInt8(2)), ceil(toUInt32(13), toInt8(2)), floor(toUInt32(13), toInt8(2));
-SELECT round(toUInt32(13), toInt16(2)), ceil(toUInt32(13), toInt16(2)), floor(toUInt32(13), toInt16(2));
-SELECT round(toUInt32(13), toInt32(2)), ceil(toUInt32(13), toInt32(2)), floor(toUInt32(13), toInt32(2));
-SELECT round(toUInt32(13), toInt64(2)), ceil(toUInt32(13), toInt64(2)), floor(toUInt32(13), toInt64(2));
-SELECT round(toUInt32(13), toFloat32(2.1)), ceil(toUInt32(13), toFloat32(2.1)), floor(toUInt32(13), toFloat32(2.1));
-SELECT round(toUInt32(13), toFloat64(2.1)), ceil(toUInt32(13), toFloat64(2.1)), floor(toUInt32(13), toFloat64(2.1));
-
-SELECT round(toUInt32(13), toUInt8(1)), ceil(toUInt32(13), toUInt8(1)), floor(toUInt32(13), toUInt8(1));
-SELECT round(toUInt32(13), toUInt16(1)), ceil(toUInt32(13), toUInt16(1)), floor(toUInt32(13), toUInt16(1));
-SELECT round(toUInt32(13), toUInt32(1)), ceil(toUInt32(13), toUInt32(1)), floor(toUInt32(13), toUInt32(1));
-SELECT round(toUInt32(13), toUInt64(1)), ceil(toUInt32(13), toUInt64(1)), floor(toUInt32(13), toUInt64(1));
-SELECT round(toUInt32(13), toInt8(1)), ceil(toUInt32(13), toInt8(1)), floor(toUInt32(13), toInt8(1));
-SELECT round(toUInt32(13), toInt16(1)), ceil(toUInt32(13), toInt16(1)), floor(toUInt32(13), toInt16(1));
-SELECT round(toUInt32(13), toInt32(1)), ceil(toUInt32(13), toInt32(1)), floor(toUInt32(13), toInt32(1));
-SELECT round(toUInt32(13), toInt64(1)), ceil(toUInt32(13), toInt64(1)), floor(toUInt32(13), toInt64(1));
-SELECT round(toUInt32(13), toFloat32(1.1)), ceil(toUInt32(13), toFloat32(1.1)), floor(toUInt32(13), toFloat32(1.1));
-SELECT round(toUInt32(13), toFloat64(1.1)), ceil(toUInt32(13), toFloat64(1.1)), floor(toUInt32(13), toFloat64(1.1));
-
-SELECT round(toUInt32(13), toUInt16(0)), ceil(toUInt32(13), toUInt16(0)), floor(toUInt32(13), toUInt16(0));
-SELECT round(toUInt32(13), toUInt32(0)), ceil(toUInt32(13), toUInt32(0)), floor(toUInt32(13), toUInt32(0));
-SELECT round(toUInt32(13), toUInt64(0)), ceil(toUInt32(13), toUInt64(0)), floor(toUInt32(13), toUInt64(0));
-SELECT round(toUInt32(13), toInt8(0)), ceil(toUInt32(13), toInt8(0)), floor(toUInt32(13), toInt8(0));
-SELECT round(toUInt32(13), toInt16(0)), ceil(toUInt32(13), toInt16(0)), floor(toUInt32(13), toInt16(0));
-SELECT round(toUInt32(13), toInt32(0)), ceil(toUInt32(13), toInt32(0)), floor(toUInt32(13), toInt32(0));
-SELECT round(toUInt32(13), toInt64(0)), ceil(toUInt32(13), toInt64(0)), floor(toUInt32(13), toInt64(0));
-SELECT round(toUInt32(13), toFloat32(0.1)), ceil(toUInt32(13), toFloat32(0.1)), floor(toUInt32(13), toFloat32(0.1));
-SELECT round(toUInt32(13), toFloat64(0.1)), ceil(toUInt32(13), toFloat64(0.1)), floor(toUInt32(13), toFloat64(0.1));
-
-SELECT round(toUInt32(13), toInt8(-1)), ceil(toUInt32(13), toInt8(-1)), floor(toUInt32(13), toInt8(-1));
-SELECT round(toUInt32(13), toInt16(-1)), ceil(toUInt32(13), toInt16(-1)), floor(toUInt32(13), toInt16(-1));
-SELECT round(toUInt32(13), toInt32(-1)), ceil(toUInt32(13), toInt32(-1)), floor(toUInt32(13), toInt32(-1));
-SELECT round(toUInt32(13), toInt64(-1)), ceil(toUInt32(13), toInt64(-1)), floor(toUInt32(13), toInt64(-1));
-SELECT round(toUInt32(13), toFloat32(1.1)), ceil(toUInt32(13), toFloat32(-1.1)), floor(toUInt32(13), toFloat32(-1.1));
-SELECT round(toUInt32(13), toFloat64(1.1)), ceil(toUInt32(13), toFloat64(-1.1)), floor(toUInt32(13), toFloat64(-1.1));
-
-SELECT round(toUInt32(13), toInt8(-2)), ceil(toUInt32(13), toInt8(-2)), floor(toUInt32(13), toInt8(-2));
-SELECT round(toUInt32(13), toInt16(-2)), ceil(toUInt32(13), toInt16(-2)), floor(toUInt32(13), toInt16(-2));
-SELECT round(toUInt32(13), toInt32(-2)), ceil(toUInt32(13), toInt32(-2)), floor(toUInt32(13), toInt32(-2));
-SELECT round(toUInt32(13), toInt64(-2)), ceil(toUInt32(13), toInt64(-2)), floor(toUInt32(13), toInt64(-2));
-SELECT round(toUInt32(13), toFloat32(-2.1)), ceil(toUInt32(13), toFloat32(-2.1)), floor(toUInt32(13), toFloat32(-2.1));
-SELECT round(toUInt32(13), toFloat64(-2.1)), ceil(toUInt32(13), toFloat64(-2.1)), floor(toUInt32(13), toFloat64(-2.1));
-
-/* UInt64 */
-
-SELECT round(toUInt64(13), toUInt8(2)), ceil(toUInt64(13), toUInt8(2)), floor(toUInt64(13), toUInt8(2));
-SELECT round(toUInt64(13), toUInt16(2)), ceil(toUInt64(13), toUInt16(2)), floor(toUInt64(13), toUInt16(2));
-SELECT round(toUInt64(13), toUInt32(2)), ceil(toUInt64(13), toUInt32(2)), floor(toUInt64(13), toUInt32(2));
-SELECT round(toUInt64(13), toUInt64(2)), ceil(toUInt64(13), toUInt64(2)), floor(toUInt64(13), toUInt64(2));
-SELECT round(toUInt64(13), toInt8(2)), ceil(toUInt64(13), toInt8(2)), floor(toUInt64(13), toInt8(2));
-SELECT round(toUInt64(13), toInt16(2)), ceil(toUInt64(13), toInt16(2)), floor(toUInt64(13), toInt16(2));
-SELECT round(toUInt64(13), toInt32(2)), ceil(toUInt64(13), toInt32(2)), floor(toUInt64(13), toInt32(2));
-SELECT round(toUInt64(13), toInt64(2)), ceil(toUInt64(13), toInt64(2)), floor(toUInt64(13), toInt64(2));
-SELECT round(toUInt64(13), toFloat32(2.1)), ceil(toUInt64(13), toFloat32(2.1)), floor(toUInt64(13), toFloat32(2.1));
-SELECT round(toUInt64(13), toFloat64(2.1)), ceil(toUInt64(13), toFloat64(2.1)), floor(toUInt64(13), toFloat64(2.1));
-
-SELECT round(toUInt64(13), toUInt8(1)), ceil(toUInt64(13), toUInt8(1)), floor(toUInt64(13), toUInt8(1));
-SELECT round(toUInt64(13), toUInt16(1)), ceil(toUInt64(13), toUInt16(1)), floor(toUInt64(13), toUInt16(1));
-SELECT round(toUInt64(13), toUInt32(1)), ceil(toUInt64(13), toUInt32(1)), floor(toUInt64(13), toUInt32(1));
-SELECT round(toUInt64(13), toUInt64(1)), ceil(toUInt64(13), toUInt64(1)), floor(toUInt64(13), toUInt64(1));
-SELECT round(toUInt64(13), toInt8(1)), ceil(toUInt64(13), toInt8(1)), floor(toUInt64(13), toInt8(1));
-SELECT round(toUInt64(13), toInt16(1)), ceil(toUInt64(13), toInt16(1)), floor(toUInt64(13), toInt16(1));
-SELECT round(toUInt64(13), toInt32(1)), ceil(toUInt64(13), toInt32(1)), floor(toUInt64(13), toInt32(1));
-SELECT round(toUInt64(13), toInt64(1)), ceil(toUInt64(13), toInt64(1)), floor(toUInt64(13), toInt64(1));
-SELECT round(toUInt64(13), toFloat32(1.1)), ceil(toUInt64(13), toFloat32(1.1)), floor(toUInt64(13), toFloat32(1.1));
-SELECT round(toUInt64(13), toFloat64(1.1)), ceil(toUInt64(13), toFloat64(1.1)), floor(toUInt64(13), toFloat64(1.1));
-
-SELECT round(toUInt64(13), toUInt16(0)), ceil(toUInt64(13), toUInt16(0)), floor(toUInt64(13), toUInt16(0));
-SELECT round(toUInt64(13), toUInt32(0)), ceil(toUInt64(13), toUInt32(0)), floor(toUInt64(13), toUInt32(0));
-SELECT round(toUInt64(13), toUInt64(0)), ceil(toUInt64(13), toUInt64(0)), floor(toUInt64(13), toUInt64(0));
-SELECT round(toUInt64(13), toInt8(0)), ceil(toUInt64(13), toInt8(0)), floor(toUInt64(13), toInt8(0));
-SELECT round(toUInt64(13), toInt16(0)), ceil(toUInt64(13), toInt16(0)), floor(toUInt64(13), toInt16(0));
-SELECT round(toUInt64(13), toInt32(0)), ceil(toUInt64(13), toInt32(0)), floor(toUInt64(13), toInt32(0));
-SELECT round(toUInt64(13), toInt64(0)), ceil(toUInt64(13), toInt64(0)), floor(toUInt64(13), toInt64(0));
-SELECT round(toUInt64(13), toFloat32(0.1)), ceil(toUInt64(13), toFloat32(0.1)), floor(toUInt64(13), toFloat32(0.1));
-SELECT round(toUInt64(13), toFloat64(0.1)), ceil(toUInt64(13), toFloat64(0.1)), floor(toUInt64(13), toFloat64(0.1));
-
-SELECT round(toUInt64(13), toInt8(-1)), ceil(toUInt64(13), toInt8(-1)), floor(toUInt64(13), toInt8(-1));
-SELECT round(toUInt64(13), toInt16(-1)), ceil(toUInt64(13), toInt16(-1)), floor(toUInt64(13), toInt16(-1));
-SELECT round(toUInt64(13), toInt32(-1)), ceil(toUInt64(13), toInt32(-1)), floor(toUInt64(13), toInt32(-1));
-SELECT round(toUInt64(13), toInt64(-1)), ceil(toUInt64(13), toInt64(-1)), floor(toUInt64(13), toInt64(-1));
-SELECT round(toUInt64(13), toFloat32(1.1)), ceil(toUInt64(13), toFloat32(-1.1)), floor(toUInt64(13), toFloat32(-1.1));
-SELECT round(toUInt64(13), toFloat64(1.1)), ceil(toUInt64(13), toFloat64(-1.1)), floor(toUInt64(13), toFloat64(-1.1));
-
-SELECT round(toUInt64(13), toInt8(-2)), ceil(toUInt64(13), toInt8(-2)), floor(toUInt64(13), toInt8(-2));
-SELECT round(toUInt64(13), toInt16(-2)), ceil(toUInt64(13), toInt16(-2)), floor(toUInt64(13), toInt16(-2));
-SELECT round(toUInt64(13), toInt32(-2)), ceil(toUInt64(13), toInt32(-2)), floor(toUInt64(13), toInt32(-2));
-SELECT round(toUInt64(13), toInt64(-2)), ceil(toUInt64(13), toInt64(-2)), floor(toUInt64(13), toInt64(-2));
-SELECT round(toUInt64(13), toFloat32(-2.1)), ceil(toUInt64(13), toFloat32(-2.1)), floor(toUInt64(13), toFloat32(-2.1));
-SELECT round(toUInt64(13), toFloat64(-2.1)), ceil(toUInt64(13), toFloat64(-2.1)), floor(toUInt64(13), toFloat64(-2.1));
-
-/* Int8 */
-
-SELECT round(toInt8(13), toUInt8(2)), ceil(toInt8(13), toUInt8(2)), floor(toInt8(13), toUInt8(2));
-SELECT round(toInt8(13), toUInt16(2)), ceil(toInt8(13), toUInt16(2)), floor(toInt8(13), toUInt16(2));
-SELECT round(toInt8(13), toUInt32(2)), ceil(toInt8(13), toUInt32(2)), floor(toInt8(13), toUInt32(2));
-SELECT round(toInt8(13), toUInt64(2)), ceil(toInt8(13), toUInt64(2)), floor(toInt8(13), toUInt64(2));
-SELECT round(toInt8(13), toInt8(2)), ceil(toInt8(13), toInt8(2)), floor(toInt8(13), toInt8(2));
-SELECT round(toInt8(13), toInt16(2)), ceil(toInt8(13), toInt16(2)), floor(toInt8(13), toInt16(2));
-SELECT round(toInt8(13), toInt32(2)), ceil(toInt8(13), toInt32(2)), floor(toInt8(13), toInt32(2));
-SELECT round(toInt8(13), toInt64(2)), ceil(toInt8(13), toInt64(2)), floor(toInt8(13), toInt64(2));
-SELECT round(toInt8(13), toFloat32(2.1)), ceil(toInt8(13), toFloat32(2.1)), floor(toInt8(13), toFloat32(2.1));
-SELECT round(toInt8(13), toFloat64(2.1)), ceil(toInt8(13), toFloat64(2.1)), floor(toInt8(13), toFloat64(2.1));
-
-SELECT round(toInt8(13), toUInt8(1)), ceil(toInt8(13), toUInt8(1)), floor(toInt8(13), toUInt8(1));
-SELECT round(toInt8(13), toUInt16(1)), ceil(toInt8(13), toUInt16(1)), floor(toInt8(13), toUInt16(1));
-SELECT round(toInt8(13), toUInt32(1)), ceil(toInt8(13), toUInt32(1)), floor(toInt8(13), toUInt32(1));
-SELECT round(toInt8(13), toUInt64(1)), ceil(toInt8(13), toUInt64(1)), floor(toInt8(13), toUInt64(1));
-SELECT round(toInt8(13), toInt8(1)), ceil(toInt8(13), toInt8(1)), floor(toInt8(13), toInt8(1));
-SELECT round(toInt8(13), toInt16(1)), ceil(toInt8(13), toInt16(1)), floor(toInt8(13), toInt16(1));
-SELECT round(toInt8(13), toInt32(1)), ceil(toInt8(13), toInt32(1)), floor(toInt8(13), toInt32(1));
-SELECT round(toInt8(13), toInt64(1)), ceil(toInt8(13), toInt64(1)), floor(toInt8(13), toInt64(1));
-SELECT round(toInt8(13), toFloat32(1.1)), ceil(toInt8(13), toFloat32(1.1)), floor(toInt8(13), toFloat32(1.1));
-SELECT round(toInt8(13), toFloat64(1.1)), ceil(toInt8(13), toFloat64(1.1)), floor(toInt8(13), toFloat64(1.1));
-
-SELECT round(toInt8(13), toUInt16(0)), ceil(toInt8(13), toUInt16(0)), floor(toInt8(13), toUInt16(0));
-SELECT round(toInt8(13), toUInt32(0)), ceil(toInt8(13), toUInt32(0)), floor(toInt8(13), toUInt32(0));
-SELECT round(toInt8(13), toUInt64(0)), ceil(toInt8(13), toUInt64(0)), floor(toInt8(13), toUInt64(0));
-SELECT round(toInt8(13), toInt8(0)), ceil(toInt8(13), toInt8(0)), floor(toInt8(13), toInt8(0));
-SELECT round(toInt8(13), toInt16(0)), ceil(toInt8(13), toInt16(0)), floor(toInt8(13), toInt16(0));
-SELECT round(toInt8(13), toInt32(0)), ceil(toInt8(13), toInt32(0)), floor(toInt8(13), toInt32(0));
-SELECT round(toInt8(13), toInt64(0)), ceil(toInt8(13), toInt64(0)), floor(toInt8(13), toInt64(0));
-SELECT round(toInt8(13), toFloat32(0.1)), ceil(toInt8(13), toFloat32(0.1)), floor(toInt8(13), toFloat32(0.1));
-SELECT round(toInt8(13), toFloat64(0.1)), ceil(toInt8(13), toFloat64(0.1)), floor(toInt8(13), toFloat64(0.1));
-
-SELECT round(toInt8(13), toInt8(-1)), ceil(toInt8(13), toInt8(-1)), floor(toInt8(13), toInt8(-1));
-SELECT round(toInt8(13), toInt16(-1)), ceil(toInt8(13), toInt16(-1)), floor(toInt8(13), toInt16(-1));
-SELECT round(toInt8(13), toInt32(-1)), ceil(toInt8(13), toInt32(-1)), floor(toInt8(13), toInt32(-1));
-SELECT round(toInt8(13), toInt64(-1)), ceil(toInt8(13), toInt64(-1)), floor(toInt8(13), toInt64(-1));
-SELECT round(toInt8(13), toFloat32(1.1)), ceil(toInt8(13), toFloat32(-1.1)), floor(toInt8(13), toFloat32(-1.1));
-SELECT round(toInt8(13), toFloat64(1.1)), ceil(toInt8(13), toFloat64(-1.1)), floor(toInt8(13), toFloat64(-1.1));
-
-SELECT round(toInt8(13), toInt8(-2)), ceil(toInt8(13), toInt8(-2)), floor(toInt8(13), toInt8(-2));
-SELECT round(toInt8(13), toInt16(-2)), ceil(toInt8(13), toInt16(-2)), floor(toInt8(13), toInt16(-2));
-SELECT round(toInt8(13), toInt32(-2)), ceil(toInt8(13), toInt32(-2)), floor(toInt8(13), toInt32(-2));
-SELECT round(toInt8(13), toInt64(-2)), ceil(toInt8(13), toInt64(-2)), floor(toInt8(13), toInt64(-2));
-SELECT round(toInt8(13), toFloat32(-2.1)), ceil(toInt8(13), toFloat32(-2.1)), floor(toInt8(13), toFloat32(-2.1));
-SELECT round(toInt8(13), toFloat64(-2.1)), ceil(toInt8(13), toFloat64(-2.1)), floor(toInt8(13), toFloat64(-2.1));
-
-/* Int16 */
-
-SELECT round(toInt16(13), toUInt8(2)), ceil(toInt16(13), toUInt8(2)), floor(toInt16(13), toUInt8(2));
-SELECT round(toInt16(13), toUInt16(2)), ceil(toInt16(13), toUInt16(2)), floor(toInt16(13), toUInt16(2));
-SELECT round(toInt16(13), toUInt32(2)), ceil(toInt16(13), toUInt32(2)), floor(toInt16(13), toUInt32(2));
-SELECT round(toInt16(13), toUInt64(2)), ceil(toInt16(13), toUInt64(2)), floor(toInt16(13), toUInt64(2));
-SELECT round(toInt16(13), toInt8(2)), ceil(toInt16(13), toInt8(2)), floor(toInt16(13), toInt8(2));
-SELECT round(toInt16(13), toInt16(2)), ceil(toInt16(13), toInt16(2)), floor(toInt16(13), toInt16(2));
-SELECT round(toInt16(13), toInt32(2)), ceil(toInt16(13), toInt32(2)), floor(toInt16(13), toInt32(2));
-SELECT round(toInt16(13), toInt64(2)), ceil(toInt16(13), toInt64(2)), floor(toInt16(13), toInt64(2));
-SELECT round(toInt16(13), toFloat32(2.1)), ceil(toInt16(13), toFloat32(2.1)), floor(toInt16(13), toFloat32(2.1));
-SELECT round(toInt16(13), toFloat64(2.1)), ceil(toInt16(13), toFloat64(2.1)), floor(toInt16(13), toFloat64(2.1));
-
-SELECT round(toInt16(13), toUInt8(1)), ceil(toInt16(13), toUInt8(1)), floor(toInt16(13), toUInt8(1));
-SELECT round(toInt16(13), toUInt16(1)), ceil(toInt16(13), toUInt16(1)), floor(toInt16(13), toUInt16(1));
-SELECT round(toInt16(13), toUInt32(1)), ceil(toInt16(13), toUInt32(1)), floor(toInt16(13), toUInt32(1));
-SELECT round(toInt16(13), toUInt64(1)), ceil(toInt16(13), toUInt64(1)), floor(toInt16(13), toUInt64(1));
-SELECT round(toInt16(13), toInt8(1)), ceil(toInt16(13), toInt8(1)), floor(toInt16(13), toInt8(1));
-SELECT round(toInt16(13), toInt16(1)), ceil(toInt16(13), toInt16(1)), floor(toInt16(13), toInt16(1));
-SELECT round(toInt16(13), toInt32(1)), ceil(toInt16(13), toInt32(1)), floor(toInt16(13), toInt32(1));
-SELECT round(toInt16(13), toInt64(1)), ceil(toInt16(13), toInt64(1)), floor(toInt16(13), toInt64(1));
-SELECT round(toInt16(13), toFloat32(1.1)), ceil(toInt16(13), toFloat32(1.1)), floor(toInt16(13), toFloat32(1.1));
-SELECT round(toInt16(13), toFloat64(1.1)), ceil(toInt16(13), toFloat64(1.1)), floor(toInt16(13), toFloat64(1.1));
-
-SELECT round(toInt16(13), toUInt16(0)), ceil(toInt16(13), toUInt16(0)), floor(toInt16(13), toUInt16(0));
-SELECT round(toInt16(13), toUInt32(0)), ceil(toInt16(13), toUInt32(0)), floor(toInt16(13), toUInt32(0));
-SELECT round(toInt16(13), toUInt64(0)), ceil(toInt16(13), toUInt64(0)), floor(toInt16(13), toUInt64(0));
-SELECT round(toInt16(13), toInt8(0)), ceil(toInt16(13), toInt8(0)), floor(toInt16(13), toInt8(0));
-SELECT round(toInt16(13), toInt16(0)), ceil(toInt16(13), toInt16(0)), floor(toInt16(13), toInt16(0));
-SELECT round(toInt16(13), toInt32(0)), ceil(toInt16(13), toInt32(0)), floor(toInt16(13), toInt32(0));
-SELECT round(toInt16(13), toInt64(0)), ceil(toInt16(13), toInt64(0)), floor(toInt16(13), toInt64(0));
-SELECT round(toInt16(13), toFloat32(0.1)), ceil(toInt16(13), toFloat32(0.1)), floor(toInt16(13), toFloat32(0.1));
-SELECT round(toInt16(13), toFloat64(0.1)), ceil(toInt16(13), toFloat64(0.1)), floor(toInt16(13), toFloat64(0.1));
-
-SELECT round(toInt16(13), toInt8(-1)), ceil(toInt16(13), toInt8(-1)), floor(toInt16(13), toInt8(-1));
-SELECT round(toInt16(13), toInt16(-1)), ceil(toInt16(13), toInt16(-1)), floor(toInt16(13), toInt16(-1));
-SELECT round(toInt16(13), toInt32(-1)), ceil(toInt16(13), toInt32(-1)), floor(toInt16(13), toInt32(-1));
-SELECT round(toInt16(13), toInt64(-1)), ceil(toInt16(13), toInt64(-1)), floor(toInt16(13), toInt64(-1));
-SELECT round(toInt16(13), toFloat32(1.1)), ceil(toInt16(13), toFloat32(-1.1)), floor(toInt16(13), toFloat32(-1.1));
-SELECT round(toInt16(13), toFloat64(1.1)), ceil(toInt16(13), toFloat64(-1.1)), floor(toInt16(13), toFloat64(-1.1));
-
-SELECT round(toInt16(13), toInt8(-2)), ceil(toInt16(13), toInt8(-2)), floor(toInt16(13), toInt8(-2));
-SELECT round(toInt16(13), toInt16(-2)), ceil(toInt16(13), toInt16(-2)), floor(toInt16(13), toInt16(-2));
-SELECT round(toInt16(13), toInt32(-2)), ceil(toInt16(13), toInt32(-2)), floor(toInt16(13), toInt32(-2));
-SELECT round(toInt16(13), toInt64(-2)), ceil(toInt16(13), toInt64(-2)), floor(toInt16(13), toInt64(-2));
-SELECT round(toInt16(13), toFloat32(-2.1)), ceil(toInt16(13), toFloat32(-2.1)), floor(toInt16(13), toFloat32(-2.1));
-SELECT round(toInt16(13), toFloat64(-2.1)), ceil(toInt16(13), toFloat64(-2.1)), floor(toInt16(13), toFloat64(-2.1));
-
-/* Int32 */
-
-SELECT round(toInt32(13), toUInt8(2)), ceil(toInt32(13), toUInt8(2)), floor(toInt32(13), toUInt8(2));
-SELECT round(toInt32(13), toUInt16(2)), ceil(toInt32(13), toUInt16(2)), floor(toInt32(13), toUInt16(2));
-SELECT round(toInt32(13), toUInt32(2)), ceil(toInt32(13), toUInt32(2)), floor(toInt32(13), toUInt32(2));
-SELECT round(toInt32(13), toUInt64(2)), ceil(toInt32(13), toUInt64(2)), floor(toInt32(13), toUInt64(2));
-SELECT round(toInt32(13), toInt8(2)), ceil(toInt32(13), toInt8(2)), floor(toInt32(13), toInt8(2));
-SELECT round(toInt32(13), toInt16(2)), ceil(toInt32(13), toInt16(2)), floor(toInt32(13), toInt16(2));
-SELECT round(toInt32(13), toInt32(2)), ceil(toInt32(13), toInt32(2)), floor(toInt32(13), toInt32(2));
-SELECT round(toInt32(13), toInt64(2)), ceil(toInt32(13), toInt64(2)), floor(toInt32(13), toInt64(2));
-SELECT round(toInt32(13), toFloat32(2.1)), ceil(toInt32(13), toFloat32(2.1)), floor(toInt32(13), toFloat32(2.1));
-SELECT round(toInt32(13), toFloat64(2.1)), ceil(toInt32(13), toFloat64(2.1)), floor(toInt32(13), toFloat64(2.1));
-
-SELECT round(toInt32(13), toUInt8(1)), ceil(toInt32(13), toUInt8(1)), floor(toInt32(13), toUInt8(1));
-SELECT round(toInt32(13), toUInt16(1)), ceil(toInt32(13), toUInt16(1)), floor(toInt32(13), toUInt16(1));
-SELECT round(toInt32(13), toUInt32(1)), ceil(toInt32(13), toUInt32(1)), floor(toInt32(13), toUInt32(1));
-SELECT round(toInt32(13), toUInt64(1)), ceil(toInt32(13), toUInt64(1)), floor(toInt32(13), toUInt64(1));
-SELECT round(toInt32(13), toInt8(1)), ceil(toInt32(13), toInt8(1)), floor(toInt32(13), toInt8(1));
-SELECT round(toInt32(13), toInt16(1)), ceil(toInt32(13), toInt16(1)), floor(toInt32(13), toInt16(1));
-SELECT round(toInt32(13), toInt32(1)), ceil(toInt32(13), toInt32(1)), floor(toInt32(13), toInt32(1));
-SELECT round(toInt32(13), toInt64(1)), ceil(toInt32(13), toInt64(1)), floor(toInt32(13), toInt64(1));
-SELECT round(toInt32(13), toFloat32(1.1)), ceil(toInt32(13), toFloat32(1.1)), floor(toInt32(13), toFloat32(1.1));
-SELECT round(toInt32(13), toFloat64(1.1)), ceil(toInt32(13), toFloat64(1.1)), floor(toInt32(13), toFloat64(1.1));
-
-SELECT round(toInt32(13), toUInt16(0)), ceil(toInt32(13), toUInt16(0)), floor(toInt32(13), toUInt16(0));
-SELECT round(toInt32(13), toUInt32(0)), ceil(toInt32(13), toUInt32(0)), floor(toInt32(13), toUInt32(0));
-SELECT round(toInt32(13), toUInt64(0)), ceil(toInt32(13), toUInt64(0)), floor(toInt32(13), toUInt64(0));
-SELECT round(toInt32(13), toInt8(0)), ceil(toInt32(13), toInt8(0)), floor(toInt32(13), toInt8(0));
-SELECT round(toInt32(13), toInt16(0)), ceil(toInt32(13), toInt16(0)), floor(toInt32(13), toInt16(0));
-SELECT round(toInt32(13), toInt32(0)), ceil(toInt32(13), toInt32(0)), floor(toInt32(13), toInt32(0));
-SELECT round(toInt32(13), toInt64(0)), ceil(toInt32(13), toInt64(0)), floor(toInt32(13), toInt64(0));
-SELECT round(toInt32(13), toFloat32(0.1)), ceil(toInt32(13), toFloat32(0.1)), floor(toInt32(13), toFloat32(0.1));
-SELECT round(toInt32(13), toFloat64(0.1)), ceil(toInt32(13), toFloat64(0.1)), floor(toInt32(13), toFloat64(0.1));
-
-SELECT round(toInt32(13), toInt8(-1)), ceil(toInt32(13), toInt8(-1)), floor(toInt32(13), toInt8(-1));
-SELECT round(toInt32(13), toInt16(-1)), ceil(toInt32(13), toInt16(-1)), floor(toInt32(13), toInt16(-1));
-SELECT round(toInt32(13), toInt32(-1)), ceil(toInt32(13), toInt32(-1)), floor(toInt32(13), toInt32(-1));
-SELECT round(toInt32(13), toInt64(-1)), ceil(toInt32(13), toInt64(-1)), floor(toInt32(13), toInt64(-1));
-SELECT round(toInt32(13), toFloat32(1.1)), ceil(toInt32(13), toFloat32(-1.1)), floor(toInt32(13), toFloat32(-1.1));
-SELECT round(toInt32(13), toFloat64(1.1)), ceil(toInt32(13), toFloat64(-1.1)), floor(toInt32(13), toFloat64(-1.1));
-
-SELECT round(toInt32(13), toInt8(-2)), ceil(toInt32(13), toInt8(-2)), floor(toInt32(13), toInt8(-2));
-SELECT round(toInt32(13), toInt16(-2)), ceil(toInt32(13), toInt16(-2)), floor(toInt32(13), toInt16(-2));
-SELECT round(toInt32(13), toInt32(-2)), ceil(toInt32(13), toInt32(-2)), floor(toInt32(13), toInt32(-2));
-SELECT round(toInt32(13), toInt64(-2)), ceil(toInt32(13), toInt64(-2)), floor(toInt32(13), toInt64(-2));
-SELECT round(toInt32(13), toFloat32(-2.1)), ceil(toInt32(13), toFloat32(-2.1)), floor(toInt32(13), toFloat32(-2.1));
-SELECT round(toInt32(13), toFloat64(-2.1)), ceil(toInt32(13), toFloat64(-2.1)), floor(toInt32(13), toFloat64(-2.1));
-
-/* Int64 */
-
-SELECT round(toInt64(13), toUInt8(2)), ceil(toInt64(13), toUInt8(2)), floor(toInt64(13), toUInt8(2));
-SELECT round(toInt64(13), toUInt16(2)), ceil(toInt64(13), toUInt16(2)), floor(toInt64(13), toUInt16(2));
-SELECT round(toInt64(13), toUInt32(2)), ceil(toInt64(13), toUInt32(2)), floor(toInt64(13), toUInt32(2));
-SELECT round(toInt64(13), toUInt64(2)), ceil(toInt64(13), toUInt64(2)), floor(toInt64(13), toUInt64(2));
-SELECT round(toInt64(13), toInt8(2)), ceil(toInt64(13), toInt8(2)), floor(toInt64(13), toInt8(2));
-SELECT round(toInt64(13), toInt16(2)), ceil(toInt64(13), toInt16(2)), floor(toInt64(13), toInt16(2));
-SELECT round(toInt64(13), toInt32(2)), ceil(toInt64(13), toInt32(2)), floor(toInt64(13), toInt32(2));
-SELECT round(toInt64(13), toInt64(2)), ceil(toInt64(13), toInt64(2)), floor(toInt64(13), toInt64(2));
-SELECT round(toInt64(13), toFloat32(2.1)), ceil(toInt64(13), toFloat32(2.1)), floor(toInt64(13), toFloat32(2.1));
-SELECT round(toInt64(13), toFloat64(2.1)), ceil(toInt64(13), toFloat64(2.1)), floor(toInt64(13), toFloat64(2.1));
-
-SELECT round(toInt64(13), toUInt8(1)), ceil(toInt64(13), toUInt8(1)), floor(toInt64(13), toUInt8(1));
-SELECT round(toInt64(13), toUInt16(1)), ceil(toInt64(13), toUInt16(1)), floor(toInt64(13), toUInt16(1));
-SELECT round(toInt64(13), toUInt32(1)), ceil(toInt64(13), toUInt32(1)), floor(toInt64(13), toUInt32(1));
-SELECT round(toInt64(13), toUInt64(1)), ceil(toInt64(13), toUInt64(1)), floor(toInt64(13), toUInt64(1));
-SELECT round(toInt64(13), toInt8(1)), ceil(toInt64(13), toInt8(1)), floor(toInt64(13), toInt8(1));
-SELECT round(toInt64(13), toInt16(1)), ceil(toInt64(13), toInt16(1)), floor(toInt64(13), toInt16(1));
-SELECT round(toInt64(13), toInt32(1)), ceil(toInt64(13), toInt32(1)), floor(toInt64(13), toInt32(1));
-SELECT round(toInt64(13), toInt64(1)), ceil(toInt64(13), toInt64(1)), floor(toInt64(13), toInt64(1));
-SELECT round(toInt64(13), toFloat32(1.1)), ceil(toInt64(13), toFloat32(1.1)), floor(toInt64(13), toFloat32(1.1));
-SELECT round(toInt64(13), toFloat64(1.1)), ceil(toInt64(13), toFloat64(1.1)), floor(toInt64(13), toFloat64(1.1));
-
-SELECT round(toInt64(13), toUInt16(0)), ceil(toInt64(13), toUInt16(0)), floor(toInt64(13), toUInt16(0));
-SELECT round(toInt64(13), toUInt32(0)), ceil(toInt64(13), toUInt32(0)), floor(toInt64(13), toUInt32(0));
-SELECT round(toInt64(13), toUInt64(0)), ceil(toInt64(13), toUInt64(0)), floor(toInt64(13), toUInt64(0));
-SELECT round(toInt64(13), toInt8(0)), ceil(toInt64(13), toInt8(0)), floor(toInt64(13), toInt8(0));
-SELECT round(toInt64(13), toInt16(0)), ceil(toInt64(13), toInt16(0)), floor(toInt64(13), toInt16(0));
-SELECT round(toInt64(13), toInt32(0)), ceil(toInt64(13), toInt32(0)), floor(toInt64(13), toInt32(0));
-SELECT round(toInt64(13), toInt64(0)), ceil(toInt64(13), toInt64(0)), floor(toInt64(13), toInt64(0));
-SELECT round(toInt64(13), toFloat32(0.1)), ceil(toInt64(13), toFloat32(0.1)), floor(toInt64(13), toFloat32(0.1));
-SELECT round(toInt64(13), toFloat64(0.1)), ceil(toInt64(13), toFloat64(0.1)), floor(toInt64(13), toFloat64(0.1));
-
-SELECT round(toInt64(13), toInt8(-1)), ceil(toInt64(13), toInt8(-1)), floor(toInt64(13), toInt8(-1));
-SELECT round(toInt64(13), toInt16(-1)), ceil(toInt64(13), toInt16(-1)), floor(toInt64(13), toInt16(-1));
-SELECT round(toInt64(13), toInt32(-1)), ceil(toInt64(13), toInt32(-1)), floor(toInt64(13), toInt32(-1));
-SELECT round(toInt64(13), toInt64(-1)), ceil(toInt64(13), toInt64(-1)), floor(toInt64(13), toInt64(-1));
-SELECT round(toInt64(13), toFloat32(1.1)), ceil(toInt64(13), toFloat32(-1.1)), floor(toInt64(13), toFloat32(-1.1));
-SELECT round(toInt64(13), toFloat64(1.1)), ceil(toInt64(13), toFloat64(-1.1)), floor(toInt64(13), toFloat64(-1.1));
-
-SELECT round(toInt64(13), toInt8(-2)), ceil(toInt64(13), toInt8(-2)), floor(toInt64(13), toInt8(-2));
-SELECT round(toInt64(13), toInt16(-2)), ceil(toInt64(13), toInt16(-2)), floor(toInt64(13), toInt16(-2));
-SELECT round(toInt64(13), toInt32(-2)), ceil(toInt64(13), toInt32(-2)), floor(toInt64(13), toInt32(-2));
-SELECT round(toInt64(13), toInt64(-2)), ceil(toInt64(13), toInt64(-2)), floor(toInt64(13), toInt64(-2));
-SELECT round(toInt64(13), toFloat32(-2.1)), ceil(toInt64(13), toFloat32(-2.1)), floor(toInt64(13), toFloat32(-2.1));
-SELECT round(toInt64(13), toFloat64(-2.1)), ceil(toInt64(13), toFloat64(-2.1)), floor(toInt64(13), toFloat64(-2.1));
-
-/* Float32 */
-
-SELECT round(toFloat32(13), toUInt8(2)), ceil(toFloat32(13), toUInt8(2)), floor(toFloat32(13), toUInt8(2));
-SELECT round(toFloat32(13), toUInt16(2)), ceil(toFloat32(13), toUInt16(2)), floor(toFloat32(13), toUInt16(2));
-SELECT round(toFloat32(13), toUInt32(2)), ceil(toFloat32(13), toUInt32(2)), floor(toFloat32(13), toUInt32(2));
-SELECT round(toFloat32(13), toUInt64(2)), ceil(toFloat32(13), toUInt64(2)), floor(toFloat32(13), toUInt64(2));
-SELECT round(toFloat32(13), toInt8(2)), ceil(toFloat32(13), toInt8(2)), floor(toFloat32(13), toInt8(2));
-SELECT round(toFloat32(13), toInt16(2)), ceil(toFloat32(13), toInt16(2)), floor(toFloat32(13), toInt16(2));
-SELECT round(toFloat32(13), toInt32(2)), ceil(toFloat32(13), toInt32(2)), floor(toFloat32(13), toInt32(2));
-SELECT round(toFloat32(13), toInt64(2)), ceil(toFloat32(13), toInt64(2)), floor(toFloat32(13), toInt64(2));
-SELECT round(toFloat32(13), toFloat32(2.1)), ceil(toFloat32(13), toFloat32(2.1)), floor(toFloat32(13), toFloat32(2.1));
-SELECT round(toFloat32(13), toFloat64(2.1)), ceil(toFloat32(13), toFloat64(2.1)), floor(toFloat32(13), toFloat64(2.1));
-
-SELECT round(toFloat32(13), toUInt8(1)), ceil(toFloat32(13), toUInt8(1)), floor(toFloat32(13), toUInt8(1));
-SELECT round(toFloat32(13), toUInt16(1)), ceil(toFloat32(13), toUInt16(1)), floor(toFloat32(13), toUInt16(1));
-SELECT round(toFloat32(13), toUInt32(1)), ceil(toFloat32(13), toUInt32(1)), floor(toFloat32(13), toUInt32(1));
-SELECT round(toFloat32(13), toUInt64(1)), ceil(toFloat32(13), toUInt64(1)), floor(toFloat32(13), toUInt64(1));
-SELECT round(toFloat32(13), toInt8(1)), ceil(toFloat32(13), toInt8(1)), floor(toFloat32(13), toInt8(1));
-SELECT round(toFloat32(13), toInt16(1)), ceil(toFloat32(13), toInt16(1)), floor(toFloat32(13), toInt16(1));
-SELECT round(toFloat32(13), toInt32(1)), ceil(toFloat32(13), toInt32(1)), floor(toFloat32(13), toInt32(1));
-SELECT round(toFloat32(13), toInt64(1)), ceil(toFloat32(13), toInt64(1)), floor(toFloat32(13), toInt64(1));
-SELECT round(toFloat32(13), toFloat32(1.1)), ceil(toFloat32(13), toFloat32(1.1)), floor(toFloat32(13), toFloat32(1.1));
-SELECT round(toFloat32(13), toFloat64(1.1)), ceil(toFloat32(13), toFloat64(1.1)), floor(toFloat32(13), toFloat64(1.1));
-
-SELECT round(toFloat32(13), toUInt16(0)), ceil(toFloat32(13), toUInt16(0)), floor(toFloat32(13), toUInt16(0));
-SELECT round(toFloat32(13), toUInt32(0)), ceil(toFloat32(13), toUInt32(0)), floor(toFloat32(13), toUInt32(0));
-SELECT round(toFloat32(13), toUInt64(0)), ceil(toFloat32(13), toUInt64(0)), floor(toFloat32(13), toUInt64(0));
-SELECT round(toFloat32(13), toInt8(0)), ceil(toFloat32(13), toInt8(0)), floor(toFloat32(13), toInt8(0));
-SELECT round(toFloat32(13), toInt16(0)), ceil(toFloat32(13), toInt16(0)), floor(toFloat32(13), toInt16(0));
-SELECT round(toFloat32(13), toInt32(0)), ceil(toFloat32(13), toInt32(0)), floor(toFloat32(13), toInt32(0));
-SELECT round(toFloat32(13), toInt64(0)), ceil(toFloat32(13), toInt64(0)), floor(toFloat32(13), toInt64(0));
-SELECT round(toFloat32(13), toFloat32(0.1)), ceil(toFloat32(13), toFloat32(0.1)), floor(toFloat32(13), toFloat32(0.1));
-SELECT round(toFloat32(13), toFloat64(0.1)), ceil(toFloat32(13), toFloat64(0.1)), floor(toFloat32(13), toFloat64(0.1));
-
-SELECT round(toFloat32(13), toInt8(-1)), ceil(toFloat32(13), toInt8(-1)), floor(toFloat32(13), toInt8(-1));
-SELECT round(toFloat32(13), toInt16(-1)), ceil(toFloat32(13), toInt16(-1)), floor(toFloat32(13), toInt16(-1));
-SELECT round(toFloat32(13), toInt32(-1)), ceil(toFloat32(13), toInt32(-1)), floor(toFloat32(13), toInt32(-1));
-SELECT round(toFloat32(13), toInt64(-1)), ceil(toFloat32(13), toInt64(-1)), floor(toFloat32(13), toInt64(-1));
-SELECT round(toFloat32(13), toFloat32(1.1)), ceil(toFloat32(13), toFloat32(-1.1)), floor(toFloat32(13), toFloat32(-1.1));
-SELECT round(toFloat32(13), toFloat64(1.1)), ceil(toFloat32(13), toFloat64(-1.1)), floor(toFloat32(13), toFloat64(-1.1));
-
-SELECT round(toFloat32(13), toInt8(-2)), ceil(toFloat32(13), toInt8(-2)), floor(toFloat32(13), toInt8(-2));
-SELECT round(toFloat32(13), toInt16(-2)), ceil(toFloat32(13), toInt16(-2)), floor(toFloat32(13), toInt16(-2));
-SELECT round(toFloat32(13), toInt32(-2)), ceil(toFloat32(13), toInt32(-2)), floor(toFloat32(13), toInt32(-2));
-SELECT round(toFloat32(13), toInt64(-2)), ceil(toFloat32(13), toInt64(-2)), floor(toFloat32(13), toInt64(-2));
-SELECT round(toFloat32(13), toFloat32(-2.1)), ceil(toFloat32(13), toFloat32(-2.1)), floor(toFloat32(13), toFloat32(-2.1));
-SELECT round(toFloat32(13), toFloat64(-2.1)), ceil(toFloat32(13), toFloat64(-2.1)), floor(toFloat32(13), toFloat64(-2.1));
-
-/* Float64 */
-
-SELECT round(toFloat64(13), toUInt8(2)), ceil(toFloat64(13), toUInt8(2)), floor(toFloat64(13), toUInt8(2));
-SELECT round(toFloat64(13), toUInt16(2)), ceil(toFloat64(13), toUInt16(2)), floor(toFloat64(13), toUInt16(2));
-SELECT round(toFloat64(13), toUInt32(2)), ceil(toFloat64(13), toUInt32(2)), floor(toFloat64(13), toUInt32(2));
-SELECT round(toFloat64(13), toUInt64(2)), ceil(toFloat64(13), toUInt64(2)), floor(toFloat64(13), toUInt64(2));
-SELECT round(toFloat64(13), toInt8(2)), ceil(toFloat64(13), toInt8(2)), floor(toFloat64(13), toInt8(2));
-SELECT round(toFloat64(13), toInt16(2)), ceil(toFloat64(13), toInt16(2)), floor(toFloat64(13), toInt16(2));
-SELECT round(toFloat64(13), toInt32(2)), ceil(toFloat64(13), toInt32(2)), floor(toFloat64(13), toInt32(2));
-SELECT round(toFloat64(13), toInt64(2)), ceil(toFloat64(13), toInt64(2)), floor(toFloat64(13), toInt64(2));
-SELECT round(toFloat64(13), toFloat32(2.1)), ceil(toFloat64(13), toFloat32(2.1)), floor(toFloat64(13), toFloat32(2.1));
-SELECT round(toFloat64(13), toFloat64(2.1)), ceil(toFloat64(13), toFloat64(2.1)), floor(toFloat64(13), toFloat64(2.1));
-
-SELECT round(toFloat64(13), toUInt8(1)), ceil(toFloat64(13), toUInt8(1)), floor(toFloat64(13), toUInt8(1));
-SELECT round(toFloat64(13), toUInt16(1)), ceil(toFloat64(13), toUInt16(1)), floor(toFloat64(13), toUInt16(1));
-SELECT round(toFloat64(13), toUInt32(1)), ceil(toFloat64(13), toUInt32(1)), floor(toFloat64(13), toUInt32(1));
-SELECT round(toFloat64(13), toUInt64(1)), ceil(toFloat64(13), toUInt64(1)), floor(toFloat64(13), toUInt64(1));
-SELECT round(toFloat64(13), toInt8(1)), ceil(toFloat64(13), toInt8(1)), floor(toFloat64(13), toInt8(1));
-SELECT round(toFloat64(13), toInt16(1)), ceil(toFloat64(13), toInt16(1)), floor(toFloat64(13), toInt16(1));
-SELECT round(toFloat64(13), toInt32(1)), ceil(toFloat64(13), toInt32(1)), floor(toFloat64(13), toInt32(1));
-SELECT round(toFloat64(13), toInt64(1)), ceil(toFloat64(13), toInt64(1)), floor(toFloat64(13), toInt64(1));
-SELECT round(toFloat64(13), toFloat32(1.1)), ceil(toFloat64(13), toFloat32(1.1)), floor(toFloat64(13), toFloat32(1.1));
-SELECT round(toFloat64(13), toFloat64(1.1)), ceil(toFloat64(13), toFloat64(1.1)), floor(toFloat64(13), toFloat64(1.1));
-
-SELECT round(toFloat64(13), toUInt16(0)), ceil(toFloat64(13), toUInt16(0)), floor(toFloat64(13), toUInt16(0));
-SELECT round(toFloat64(13), toUInt32(0)), ceil(toFloat64(13), toUInt32(0)), floor(toFloat64(13), toUInt32(0));
-SELECT round(toFloat64(13), toUInt64(0)), ceil(toFloat64(13), toUInt64(0)), floor(toFloat64(13), toUInt64(0));
-SELECT round(toFloat64(13), toInt8(0)), ceil(toFloat64(13), toInt8(0)), floor(toFloat64(13), toInt8(0));
-SELECT round(toFloat64(13), toInt16(0)), ceil(toFloat64(13), toInt16(0)), floor(toFloat64(13), toInt16(0));
-SELECT round(toFloat64(13), toInt32(0)), ceil(toFloat64(13), toInt32(0)), floor(toFloat64(13), toInt32(0));
-SELECT round(toFloat64(13), toInt64(0)), ceil(toFloat64(13), toInt64(0)), floor(toFloat64(13), toInt64(0));
-SELECT round(toFloat64(13), toFloat32(0.1)), ceil(toFloat64(13), toFloat32(0.1)), floor(toFloat64(13), toFloat32(0.1));
-SELECT round(toFloat64(13), toFloat64(0.1)), ceil(toFloat64(13), toFloat64(0.1)), floor(toFloat64(13), toFloat64(0.1));
-
-SELECT round(toFloat64(13), toInt8(-1)), ceil(toFloat64(13), toInt8(-1)), floor(toFloat64(13), toInt8(-1));
-SELECT round(toFloat64(13), toInt16(-1)), ceil(toFloat64(13), toInt16(-1)), floor(toFloat64(13), toInt16(-1));
-SELECT round(toFloat64(13), toInt32(-1)), ceil(toFloat64(13), toInt32(-1)), floor(toFloat64(13), toInt32(-1));
-SELECT round(toFloat64(13), toInt64(-1)), ceil(toFloat64(13), toInt64(-1)), floor(toFloat64(13), toInt64(-1));
-SELECT round(toFloat64(13), toFloat32(1.1)), ceil(toFloat64(13), toFloat32(-1.1)), floor(toFloat64(13), toFloat32(-1.1));
-SELECT round(toFloat64(13), toFloat64(1.1)), ceil(toFloat64(13), toFloat64(-1.1)), floor(toFloat64(13), toFloat64(-1.1));
-
-SELECT round(toFloat64(13), toInt8(-2)), ceil(toFloat64(13), toInt8(-2)), floor(toFloat64(13), toInt8(-2));
-SELECT round(toFloat64(13), toInt16(-2)), ceil(toFloat64(13), toInt16(-2)), floor(toFloat64(13), toInt16(-2));
-SELECT round(toFloat64(13), toInt32(-2)), ceil(toFloat64(13), toInt32(-2)), floor(toFloat64(13), toInt32(-2));
-SELECT round(toFloat64(13), toInt64(-2)), ceil(toFloat64(13), toInt64(-2)), floor(toFloat64(13), toInt64(-2));
-SELECT round(toFloat64(13), toFloat32(-2.1)), ceil(toFloat64(13), toFloat32(-2.1)), floor(toFloat64(13), toFloat32(-2.1));
-SELECT round(toFloat64(13), toFloat64(-2.1)), ceil(toFloat64(13), toFloat64(-2.1)), floor(toFloat64(13), toFloat64(-2.1));
-
-/* Отрицательное значение */
-
-/* Int8 */
-
-SELECT round(toInt8(-13), toUInt8(2)), ceil(toInt8(-13), toUInt8(2)), floor(toInt8(-13), toUInt8(2));
-SELECT round(toInt8(-13), toUInt16(2)), ceil(toInt8(-13), toUInt16(2)), floor(toInt8(-13), toUInt16(2));
-SELECT round(toInt8(-13), toUInt32(2)), ceil(toInt8(-13), toUInt32(2)), floor(toInt8(-13), toUInt32(2));
-SELECT round(toInt8(-13), toUInt64(2)), ceil(toInt8(-13), toUInt64(2)), floor(toInt8(-13), toUInt64(2));
-SELECT round(toInt8(-13), toInt8(2)), ceil(toInt8(-13), toInt8(2)), floor(toInt8(-13), toInt8(2));
-SELECT round(toInt8(-13), toInt16(2)), ceil(toInt8(-13), toInt16(2)), floor(toInt8(-13), toInt16(2));
-SELECT round(toInt8(-13), toInt32(2)), ceil(toInt8(-13), toInt32(2)), floor(toInt8(-13), toInt32(2));
-SELECT round(toInt8(-13), toInt64(2)), ceil(toInt8(-13), toInt64(2)), floor(toInt8(-13), toInt64(2));
-SELECT round(toInt8(-13), toFloat32(2.1)), ceil(toInt8(-13), toFloat32(2.1)), floor(toInt8(-13), toFloat32(2.1));
-SELECT round(toInt8(-13), toFloat64(2.1)), ceil(toInt8(-13), toFloat64(2.1)), floor(toInt8(-13), toFloat64(2.1));
-
-SELECT round(toInt8(-13), toUInt8(1)), ceil(toInt8(-13), toUInt8(1)), floor(toInt8(-13), toUInt8(1));
-SELECT round(toInt8(-13), toUInt16(1)), ceil(toInt8(-13), toUInt16(1)), floor(toInt8(-13), toUInt16(1));
-SELECT round(toInt8(-13), toUInt32(1)), ceil(toInt8(-13), toUInt32(1)), floor(toInt8(-13), toUInt32(1));
-SELECT round(toInt8(-13), toUInt64(1)), ceil(toInt8(-13), toUInt64(1)), floor(toInt8(-13), toUInt64(1));
-SELECT round(toInt8(-13), toInt8(1)), ceil(toInt8(-13), toInt8(1)), floor(toInt8(-13), toInt8(1));
-SELECT round(toInt8(-13), toInt16(1)), ceil(toInt8(-13), toInt16(1)), floor(toInt8(-13), toInt16(1));
-SELECT round(toInt8(-13), toInt32(1)), ceil(toInt8(-13), toInt32(1)), floor(toInt8(-13), toInt32(1));
-SELECT round(toInt8(-13), toInt64(1)), ceil(toInt8(-13), toInt64(1)), floor(toInt8(-13), toInt64(1));
-SELECT round(toInt8(-13), toFloat32(1.1)), ceil(toInt8(-13), toFloat32(1.1)), floor(toInt8(-13), toFloat32(1.1));
-SELECT round(toInt8(-13), toFloat64(1.1)), ceil(toInt8(-13), toFloat64(1.1)), floor(toInt8(-13), toFloat64(1.1));
-
-SELECT round(toInt8(-13), toUInt16(0)), ceil(toInt8(-13), toUInt16(0)), floor(toInt8(-13), toUInt16(0));
-SELECT round(toInt8(-13), toUInt32(0)), ceil(toInt8(-13), toUInt32(0)), floor(toInt8(-13), toUInt32(0));
-SELECT round(toInt8(-13), toUInt64(0)), ceil(toInt8(-13), toUInt64(0)), floor(toInt8(-13), toUInt64(0));
-SELECT round(toInt8(-13), toInt8(0)), ceil(toInt8(-13), toInt8(0)), floor(toInt8(-13), toInt8(0));
-SELECT round(toInt8(-13), toInt16(0)), ceil(toInt8(-13), toInt16(0)), floor(toInt8(-13), toInt16(0));
-SELECT round(toInt8(-13), toInt32(0)), ceil(toInt8(-13), toInt32(0)), floor(toInt8(-13), toInt32(0));
-SELECT round(toInt8(-13), toInt64(0)), ceil(toInt8(-13), toInt64(0)), floor(toInt8(-13), toInt64(0));
-SELECT round(toInt8(-13), toFloat32(0.1)), ceil(toInt8(-13), toFloat32(0.1)), floor(toInt8(-13), toFloat32(0.1));
-SELECT round(toInt8(-13), toFloat64(0.1)), ceil(toInt8(-13), toFloat64(0.1)), floor(toInt8(-13), toFloat64(0.1));
-
-SELECT round(toInt8(-13), toInt8(-1)), ceil(toInt8(-13), toInt8(-1)), floor(toInt8(-13), toInt8(-1));
-SELECT round(toInt8(-13), toInt16(-1)), ceil(toInt8(-13), toInt16(-1)), floor(toInt8(-13), toInt16(-1));
-SELECT round(toInt8(-13), toInt32(-1)), ceil(toInt8(-13), toInt32(-1)), floor(toInt8(-13), toInt32(-1));
-SELECT round(toInt8(-13), toInt64(-1)), ceil(toInt8(-13), toInt64(-1)), floor(toInt8(-13), toInt64(-1));
-SELECT round(toInt8(-13), toFloat32(1.1)), ceil(toInt8(-13), toFloat32(-1.1)), floor(toInt8(-13), toFloat32(-1.1));
-SELECT round(toInt8(-13), toFloat64(1.1)), ceil(toInt8(-13), toFloat64(-1.1)), floor(toInt8(-13), toFloat64(-1.1));
-
-SELECT round(toInt8(-13), toInt8(-2)), ceil(toInt8(-13), toInt8(-2)), floor(toInt8(-13), toInt8(-2));
-SELECT round(toInt8(-13), toInt16(-2)), ceil(toInt8(-13), toInt16(-2)), floor(toInt8(-13), toInt16(-2));
-SELECT round(toInt8(-13), toInt32(-2)), ceil(toInt8(-13), toInt32(-2)), floor(toInt8(-13), toInt32(-2));
-SELECT round(toInt8(-13), toInt64(-2)), ceil(toInt8(-13), toInt64(-2)), floor(toInt8(-13), toInt64(-2));
-SELECT round(toInt8(-13), toFloat32(-2.1)), ceil(toInt8(-13), toFloat32(-2.1)), floor(toInt8(-13), toFloat32(-2.1));
-SELECT round(toInt8(-13), toFloat64(-2.1)), ceil(toInt8(-13), toFloat64(-2.1)), floor(toInt8(-13), toFloat64(-2.1));
-
-/* Int16 */
-
-SELECT round(toInt16(-13), toUInt8(2)), ceil(toInt16(-13), toUInt8(2)), floor(toInt16(-13), toUInt8(2));
-SELECT round(toInt16(-13), toUInt16(2)), ceil(toInt16(-13), toUInt16(2)), floor(toInt16(-13), toUInt16(2));
-SELECT round(toInt16(-13), toUInt32(2)), ceil(toInt16(-13), toUInt32(2)), floor(toInt16(-13), toUInt32(2));
-SELECT round(toInt16(-13), toUInt64(2)), ceil(toInt16(-13), toUInt64(2)), floor(toInt16(-13), toUInt64(2));
-SELECT round(toInt16(-13), toInt8(2)), ceil(toInt16(-13), toInt8(2)), floor(toInt16(-13), toInt8(2));
-SELECT round(toInt16(-13), toInt16(2)), ceil(toInt16(-13), toInt16(2)), floor(toInt16(-13), toInt16(2));
-SELECT round(toInt16(-13), toInt32(2)), ceil(toInt16(-13), toInt32(2)), floor(toInt16(-13), toInt32(2));
-SELECT round(toInt16(-13), toInt64(2)), ceil(toInt16(-13), toInt64(2)), floor(toInt16(-13), toInt64(2));
-SELECT round(toInt16(-13), toFloat32(2.1)), ceil(toInt16(-13), toFloat32(2.1)), floor(toInt16(-13), toFloat32(2.1));
-SELECT round(toInt16(-13), toFloat64(2.1)), ceil(toInt16(-13), toFloat64(2.1)), floor(toInt16(-13), toFloat64(2.1));
-
-SELECT round(toInt16(-13), toUInt8(1)), ceil(toInt16(-13), toUInt8(1)), floor(toInt16(-13), toUInt8(1));
-SELECT round(toInt16(-13), toUInt16(1)), ceil(toInt16(-13), toUInt16(1)), floor(toInt16(-13), toUInt16(1));
-SELECT round(toInt16(-13), toUInt32(1)), ceil(toInt16(-13), toUInt32(1)), floor(toInt16(-13), toUInt32(1));
-SELECT round(toInt16(-13), toUInt64(1)), ceil(toInt16(-13), toUInt64(1)), floor(toInt16(-13), toUInt64(1));
-SELECT round(toInt16(-13), toInt8(1)), ceil(toInt16(-13), toInt8(1)), floor(toInt16(-13), toInt8(1));
-SELECT round(toInt16(-13), toInt16(1)), ceil(toInt16(-13), toInt16(1)), floor(toInt16(-13), toInt16(1));
-SELECT round(toInt16(-13), toInt32(1)), ceil(toInt16(-13), toInt32(1)), floor(toInt16(-13), toInt32(1));
-SELECT round(toInt16(-13), toInt64(1)), ceil(toInt16(-13), toInt64(1)), floor(toInt16(-13), toInt64(1));
-SELECT round(toInt16(-13), toFloat32(1.1)), ceil(toInt16(-13), toFloat32(1.1)), floor(toInt16(-13), toFloat32(1.1));
-SELECT round(toInt16(-13), toFloat64(1.1)), ceil(toInt16(-13), toFloat64(1.1)), floor(toInt16(-13), toFloat64(1.1));
-
-SELECT round(toInt16(-13), toUInt16(0)), ceil(toInt16(-13), toUInt16(0)), floor(toInt16(-13), toUInt16(0));
-SELECT round(toInt16(-13), toUInt32(0)), ceil(toInt16(-13), toUInt32(0)), floor(toInt16(-13), toUInt32(0));
-SELECT round(toInt16(-13), toUInt64(0)), ceil(toInt16(-13), toUInt64(0)), floor(toInt16(-13), toUInt64(0));
-SELECT round(toInt16(-13), toInt8(0)), ceil(toInt16(-13), toInt8(0)), floor(toInt16(-13), toInt8(0));
-SELECT round(toInt16(-13), toInt16(0)), ceil(toInt16(-13), toInt16(0)), floor(toInt16(-13), toInt16(0));
-SELECT round(toInt16(-13), toInt32(0)), ceil(toInt16(-13), toInt32(0)), floor(toInt16(-13), toInt32(0));
-SELECT round(toInt16(-13), toInt64(0)), ceil(toInt16(-13), toInt64(0)), floor(toInt16(-13), toInt64(0));
-SELECT round(toInt16(-13), toFloat32(0.1)), ceil(toInt16(-13), toFloat32(0.1)), floor(toInt16(-13), toFloat32(0.1));
-SELECT round(toInt16(-13), toFloat64(0.1)), ceil(toInt16(-13), toFloat64(0.1)), floor(toInt16(-13), toFloat64(0.1));
-
-SELECT round(toInt16(-13), toInt8(-1)), ceil(toInt16(-13), toInt8(-1)), floor(toInt16(-13), toInt8(-1));
-SELECT round(toInt16(-13), toInt16(-1)), ceil(toInt16(-13), toInt16(-1)), floor(toInt16(-13), toInt16(-1));
-SELECT round(toInt16(-13), toInt32(-1)), ceil(toInt16(-13), toInt32(-1)), floor(toInt16(-13), toInt32(-1));
-SELECT round(toInt16(-13), toInt64(-1)), ceil(toInt16(-13), toInt64(-1)), floor(toInt16(-13), toInt64(-1));
-SELECT round(toInt16(-13), toFloat32(1.1)), ceil(toInt16(-13), toFloat32(-1.1)), floor(toInt16(-13), toFloat32(-1.1));
-SELECT round(toInt16(-13), toFloat64(1.1)), ceil(toInt16(-13), toFloat64(-1.1)), floor(toInt16(-13), toFloat64(-1.1));
-
-SELECT round(toInt16(-13), toInt8(-2)), ceil(toInt16(-13), toInt8(-2)), floor(toInt16(-13), toInt8(-2));
-SELECT round(toInt16(-13), toInt16(-2)), ceil(toInt16(-13), toInt16(-2)), floor(toInt16(-13), toInt16(-2));
-SELECT round(toInt16(-13), toInt32(-2)), ceil(toInt16(-13), toInt32(-2)), floor(toInt16(-13), toInt32(-2));
-SELECT round(toInt16(-13), toInt64(-2)), ceil(toInt16(-13), toInt64(-2)), floor(toInt16(-13), toInt64(-2));
-SELECT round(toInt16(-13), toFloat32(-2.1)), ceil(toInt16(-13), toFloat32(-2.1)), floor(toInt16(-13), toFloat32(-2.1));
-SELECT round(toInt16(-13), toFloat64(-2.1)), ceil(toInt16(-13), toFloat64(-2.1)), floor(toInt16(-13), toFloat64(-2.1));
-
-/* Int32 */
-
-SELECT round(toInt32(-13), toUInt8(2)), ceil(toInt32(-13), toUInt8(2)), floor(toInt32(-13), toUInt8(2));
-SELECT round(toInt32(-13), toUInt16(2)), ceil(toInt32(-13), toUInt16(2)), floor(toInt32(-13), toUInt16(2));
-SELECT round(toInt32(-13), toUInt32(2)), ceil(toInt32(-13), toUInt32(2)), floor(toInt32(-13), toUInt32(2));
-SELECT round(toInt32(-13), toUInt64(2)), ceil(toInt32(-13), toUInt64(2)), floor(toInt32(-13), toUInt64(2));
-SELECT round(toInt32(-13), toInt8(2)), ceil(toInt32(-13), toInt8(2)), floor(toInt32(-13), toInt8(2));
-SELECT round(toInt32(-13), toInt16(2)), ceil(toInt32(-13), toInt16(2)), floor(toInt32(-13), toInt16(2));
-SELECT round(toInt32(-13), toInt32(2)), ceil(toInt32(-13), toInt32(2)), floor(toInt32(-13), toInt32(2));
-SELECT round(toInt32(-13), toInt64(2)), ceil(toInt32(-13), toInt64(2)), floor(toInt32(-13), toInt64(2));
-SELECT round(toInt32(-13), toFloat32(2.1)), ceil(toInt32(-13), toFloat32(2.1)), floor(toInt32(-13), toFloat32(2.1));
-SELECT round(toInt32(-13), toFloat64(2.1)), ceil(toInt32(-13), toFloat64(2.1)), floor(toInt32(-13), toFloat64(2.1));
-
-SELECT round(toInt32(-13), toUInt8(1)), ceil(toInt32(-13), toUInt8(1)), floor(toInt32(-13), toUInt8(1));
-SELECT round(toInt32(-13), toUInt16(1)), ceil(toInt32(-13), toUInt16(1)), floor(toInt32(-13), toUInt16(1));
-SELECT round(toInt32(-13), toUInt32(1)), ceil(toInt32(-13), toUInt32(1)), floor(toInt32(-13), toUInt32(1));
-SELECT round(toInt32(-13), toUInt64(1)), ceil(toInt32(-13), toUInt64(1)), floor(toInt32(-13), toUInt64(1));
-SELECT round(toInt32(-13), toInt8(1)), ceil(toInt32(-13), toInt8(1)), floor(toInt32(-13), toInt8(1));
-SELECT round(toInt32(-13), toInt16(1)), ceil(toInt32(-13), toInt16(1)), floor(toInt32(-13), toInt16(1));
-SELECT round(toInt32(-13), toInt32(1)), ceil(toInt32(-13), toInt32(1)), floor(toInt32(-13), toInt32(1));
-SELECT round(toInt32(-13), toInt64(1)), ceil(toInt32(-13), toInt64(1)), floor(toInt32(-13), toInt64(1));
-SELECT round(toInt32(-13), toFloat32(1.1)), ceil(toInt32(-13), toFloat32(1.1)), floor(toInt32(-13), toFloat32(1.1));
-SELECT round(toInt32(-13), toFloat64(1.1)), ceil(toInt32(-13), toFloat64(1.1)), floor(toInt32(-13), toFloat64(1.1));
-
-SELECT round(toInt32(-13), toUInt16(0)), ceil(toInt32(-13), toUInt16(0)), floor(toInt32(-13), toUInt16(0));
-SELECT round(toInt32(-13), toUInt32(0)), ceil(toInt32(-13), toUInt32(0)), floor(toInt32(-13), toUInt32(0));
-SELECT round(toInt32(-13), toUInt64(0)), ceil(toInt32(-13), toUInt64(0)), floor(toInt32(-13), toUInt64(0));
-SELECT round(toInt32(-13), toInt8(0)), ceil(toInt32(-13), toInt8(0)), floor(toInt32(-13), toInt8(0));
-SELECT round(toInt32(-13), toInt16(0)), ceil(toInt32(-13), toInt16(0)), floor(toInt32(-13), toInt16(0));
-SELECT round(toInt32(-13), toInt32(0)), ceil(toInt32(-13), toInt32(0)), floor(toInt32(-13), toInt32(0));
-SELECT round(toInt32(-13), toInt64(0)), ceil(toInt32(-13), toInt64(0)), floor(toInt32(-13), toInt64(0));
-SELECT round(toInt32(-13), toFloat32(0.1)), ceil(toInt32(-13), toFloat32(0.1)), floor(toInt32(-13), toFloat32(0.1));
-SELECT round(toInt32(-13), toFloat64(0.1)), ceil(toInt32(-13), toFloat64(0.1)), floor(toInt32(-13), toFloat64(0.1));
-
-SELECT round(toInt32(-13), toInt8(-1)), ceil(toInt32(-13), toInt8(-1)), floor(toInt32(-13), toInt8(-1));
-SELECT round(toInt32(-13), toInt16(-1)), ceil(toInt32(-13), toInt16(-1)), floor(toInt32(-13), toInt16(-1));
-SELECT round(toInt32(-13), toInt32(-1)), ceil(toInt32(-13), toInt32(-1)), floor(toInt32(-13), toInt32(-1));
-SELECT round(toInt32(-13), toInt64(-1)), ceil(toInt32(-13), toInt64(-1)), floor(toInt32(-13), toInt64(-1));
-SELECT round(toInt32(-13), toFloat32(1.1)), ceil(toInt32(-13), toFloat32(-1.1)), floor(toInt32(-13), toFloat32(-1.1));
-SELECT round(toInt32(-13), toFloat64(1.1)), ceil(toInt32(-13), toFloat64(-1.1)), floor(toInt32(-13), toFloat64(-1.1));
-
-SELECT round(toInt32(-13), toInt8(-2)), ceil(toInt32(-13), toInt8(-2)), floor(toInt32(-13), toInt8(-2));
-SELECT round(toInt32(-13), toInt16(-2)), ceil(toInt32(-13), toInt16(-2)), floor(toInt32(-13), toInt16(-2));
-SELECT round(toInt32(-13), toInt32(-2)), ceil(toInt32(-13), toInt32(-2)), floor(toInt32(-13), toInt32(-2));
-SELECT round(toInt32(-13), toInt64(-2)), ceil(toInt32(-13), toInt64(-2)), floor(toInt32(-13), toInt64(-2));
-SELECT round(toInt32(-13), toFloat32(-2.1)), ceil(toInt32(-13), toFloat32(-2.1)), floor(toInt32(-13), toFloat32(-2.1));
-SELECT round(toInt32(-13), toFloat64(-2.1)), ceil(toInt32(-13), toFloat64(-2.1)), floor(toInt32(-13), toFloat64(-2.1));
-
-/* Int64 */
-
-SELECT round(toInt64(-13), toUInt8(2)), ceil(toInt64(-13), toUInt8(2)), floor(toInt64(-13), toUInt8(2));
-SELECT round(toInt64(-13), toUInt16(2)), ceil(toInt64(-13), toUInt16(2)), floor(toInt64(-13), toUInt16(2));
-SELECT round(toInt64(-13), toUInt32(2)), ceil(toInt64(-13), toUInt32(2)), floor(toInt64(-13), toUInt32(2));
-SELECT round(toInt64(-13), toUInt64(2)), ceil(toInt64(-13), toUInt64(2)), floor(toInt64(-13), toUInt64(2));
-SELECT round(toInt64(-13), toInt8(2)), ceil(toInt64(-13), toInt8(2)), floor(toInt64(-13), toInt8(2));
-SELECT round(toInt64(-13), toInt16(2)), ceil(toInt64(-13), toInt16(2)), floor(toInt64(-13), toInt16(2));
-SELECT round(toInt64(-13), toInt32(2)), ceil(toInt64(-13), toInt32(2)), floor(toInt64(-13), toInt32(2));
-SELECT round(toInt64(-13), toInt64(2)), ceil(toInt64(-13), toInt64(2)), floor(toInt64(-13), toInt64(2));
-SELECT round(toInt64(-13), toFloat32(2.1)), ceil(toInt64(-13), toFloat32(2.1)), floor(toInt64(-13), toFloat32(2.1));
-SELECT round(toInt64(-13), toFloat64(2.1)), ceil(toInt64(-13), toFloat64(2.1)), floor(toInt64(-13), toFloat64(2.1));
-
-SELECT round(toInt64(-13), toUInt8(1)), ceil(toInt64(-13), toUInt8(1)), floor(toInt64(-13), toUInt8(1));
-SELECT round(toInt64(-13), toUInt16(1)), ceil(toInt64(-13), toUInt16(1)), floor(toInt64(-13), toUInt16(1));
-SELECT round(toInt64(-13), toUInt32(1)), ceil(toInt64(-13), toUInt32(1)), floor(toInt64(-13), toUInt32(1));
-SELECT round(toInt64(-13), toUInt64(1)), ceil(toInt64(-13), toUInt64(1)), floor(toInt64(-13), toUInt64(1));
-SELECT round(toInt64(-13), toInt8(1)), ceil(toInt64(-13), toInt8(1)), floor(toInt64(-13), toInt8(1));
-SELECT round(toInt64(-13), toInt16(1)), ceil(toInt64(-13), toInt16(1)), floor(toInt64(-13), toInt16(1));
-SELECT round(toInt64(-13), toInt32(1)), ceil(toInt64(-13), toInt32(1)), floor(toInt64(-13), toInt32(1));
-SELECT round(toInt64(-13), toInt64(1)), ceil(toInt64(-13), toInt64(1)), floor(toInt64(-13), toInt64(1));
-SELECT round(toInt64(-13), toFloat32(1.1)), ceil(toInt64(-13), toFloat32(1.1)), floor(toInt64(-13), toFloat32(1.1));
-SELECT round(toInt64(-13), toFloat64(1.1)), ceil(toInt64(-13), toFloat64(1.1)), floor(toInt64(-13), toFloat64(1.1));
-
-SELECT round(toInt64(-13), toUInt16(0)), ceil(toInt64(-13), toUInt16(0)), floor(toInt64(-13), toUInt16(0));
-SELECT round(toInt64(-13), toUInt32(0)), ceil(toInt64(-13), toUInt32(0)), floor(toInt64(-13), toUInt32(0));
-SELECT round(toInt64(-13), toUInt64(0)), ceil(toInt64(-13), toUInt64(0)), floor(toInt64(-13), toUInt64(0));
-SELECT round(toInt64(-13), toInt8(0)), ceil(toInt64(-13), toInt8(0)), floor(toInt64(-13), toInt8(0));
-SELECT round(toInt64(-13), toInt16(0)), ceil(toInt64(-13), toInt16(0)), floor(toInt64(-13), toInt16(0));
-SELECT round(toInt64(-13), toInt32(0)), ceil(toInt64(-13), toInt32(0)), floor(toInt64(-13), toInt32(0));
-SELECT round(toInt64(-13), toInt64(0)), ceil(toInt64(-13), toInt64(0)), floor(toInt64(-13), toInt64(0));
-SELECT round(toInt64(-13), toFloat32(0.1)), ceil(toInt64(-13), toFloat32(0.1)), floor(toInt64(-13), toFloat32(0.1));
-SELECT round(toInt64(-13), toFloat64(0.1)), ceil(toInt64(-13), toFloat64(0.1)), floor(toInt64(-13), toFloat64(0.1));
-
-SELECT round(toInt64(-13), toInt8(-1)), ceil(toInt64(-13), toInt8(-1)), floor(toInt64(-13), toInt8(-1));
-SELECT round(toInt64(-13), toInt16(-1)), ceil(toInt64(-13), toInt16(-1)), floor(toInt64(-13), toInt16(-1));
-SELECT round(toInt64(-13), toInt32(-1)), ceil(toInt64(-13), toInt32(-1)), floor(toInt64(-13), toInt32(-1));
-SELECT round(toInt64(-13), toInt64(-1)), ceil(toInt64(-13), toInt64(-1)), floor(toInt64(-13), toInt64(-1));
-SELECT round(toInt64(-13), toFloat32(1.1)), ceil(toInt64(-13), toFloat32(-1.1)), floor(toInt64(-13), toFloat32(-1.1));
-SELECT round(toInt64(-13), toFloat64(1.1)), ceil(toInt64(-13), toFloat64(-1.1)), floor(toInt64(-13), toFloat64(-1.1));
-
-SELECT round(toInt64(-13), toInt8(-2)), ceil(toInt64(-13), toInt8(-2)), floor(toInt64(-13), toInt8(-2));
-SELECT round(toInt64(-13), toInt16(-2)), ceil(toInt64(-13), toInt16(-2)), floor(toInt64(-13), toInt16(-2));
-SELECT round(toInt64(-13), toInt32(-2)), ceil(toInt64(-13), toInt32(-2)), floor(toInt64(-13), toInt32(-2));
-SELECT round(toInt64(-13), toInt64(-2)), ceil(toInt64(-13), toInt64(-2)), floor(toInt64(-13), toInt64(-2));
-SELECT round(toInt64(-13), toFloat32(-2.1)), ceil(toInt64(-13), toFloat32(-2.1)), floor(toInt64(-13), toFloat32(-2.1));
-SELECT round(toInt64(-13), toFloat64(-2.1)), ceil(toInt64(-13), toFloat64(-2.1)), floor(toInt64(-13), toFloat64(-2.1));
-
-/* Float32 */
-
-SELECT round(toFloat32(-13), toUInt8(2)), ceil(toFloat32(-13), toUInt8(2)), floor(toFloat32(-13), toUInt8(2));
-SELECT round(toFloat32(-13), toUInt16(2)), ceil(toFloat32(-13), toUInt16(2)), floor(toFloat32(-13), toUInt16(2));
-SELECT round(toFloat32(-13), toUInt32(2)), ceil(toFloat32(-13), toUInt32(2)), floor(toFloat32(-13), toUInt32(2));
-SELECT round(toFloat32(-13), toUInt64(2)), ceil(toFloat32(-13), toUInt64(2)), floor(toFloat32(-13), toUInt64(2));
-SELECT round(toFloat32(-13), toInt8(2)), ceil(toFloat32(-13), toInt8(2)), floor(toFloat32(-13), toInt8(2));
-SELECT round(toFloat32(-13), toInt16(2)), ceil(toFloat32(-13), toInt16(2)), floor(toFloat32(-13), toInt16(2));
-SELECT round(toFloat32(-13), toInt32(2)), ceil(toFloat32(-13), toInt32(2)), floor(toFloat32(-13), toInt32(2));
-SELECT round(toFloat32(-13), toInt64(2)), ceil(toFloat32(-13), toInt64(2)), floor(toFloat32(-13), toInt64(2));
-SELECT round(toFloat32(-13), toFloat32(2.1)), ceil(toFloat32(-13), toFloat32(2.1)), floor(toFloat32(-13), toFloat32(2.1));
-SELECT round(toFloat32(-13), toFloat64(2.1)), ceil(toFloat32(-13), toFloat64(2.1)), floor(toFloat32(-13), toFloat64(2.1));
-
-SELECT round(toFloat32(-13), toUInt8(1)), ceil(toFloat32(-13), toUInt8(1)), floor(toFloat32(-13), toUInt8(1));
-SELECT round(toFloat32(-13), toUInt16(1)), ceil(toFloat32(-13), toUInt16(1)), floor(toFloat32(-13), toUInt16(1));
-SELECT round(toFloat32(-13), toUInt32(1)), ceil(toFloat32(-13), toUInt32(1)), floor(toFloat32(-13), toUInt32(1));
-SELECT round(toFloat32(-13), toUInt64(1)), ceil(toFloat32(-13), toUInt64(1)), floor(toFloat32(-13), toUInt64(1));
-SELECT round(toFloat32(-13), toInt8(1)), ceil(toFloat32(-13), toInt8(1)), floor(toFloat32(-13), toInt8(1));
-SELECT round(toFloat32(-13), toInt16(1)), ceil(toFloat32(-13), toInt16(1)), floor(toFloat32(-13), toInt16(1));
-SELECT round(toFloat32(-13), toInt32(1)), ceil(toFloat32(-13), toInt32(1)), floor(toFloat32(-13), toInt32(1));
-SELECT round(toFloat32(-13), toInt64(1)), ceil(toFloat32(-13), toInt64(1)), floor(toFloat32(-13), toInt64(1));
-SELECT round(toFloat32(-13), toFloat32(1.1)), ceil(toFloat32(-13), toFloat32(1.1)), floor(toFloat32(-13), toFloat32(1.1));
-SELECT round(toFloat32(-13), toFloat64(1.1)), ceil(toFloat32(-13), toFloat64(1.1)), floor(toFloat32(-13), toFloat64(1.1));
-
-SELECT round(toFloat32(-13), toUInt16(0)), ceil(toFloat32(-13), toUInt16(0)), floor(toFloat32(-13), toUInt16(0));
-SELECT round(toFloat32(-13), toUInt32(0)), ceil(toFloat32(-13), toUInt32(0)), floor(toFloat32(-13), toUInt32(0));
-SELECT round(toFloat32(-13), toUInt64(0)), ceil(toFloat32(-13), toUInt64(0)), floor(toFloat32(-13), toUInt64(0));
-SELECT round(toFloat32(-13), toInt8(0)), ceil(toFloat32(-13), toInt8(0)), floor(toFloat32(-13), toInt8(0));
-SELECT round(toFloat32(-13), toInt16(0)), ceil(toFloat32(-13), toInt16(0)), floor(toFloat32(-13), toInt16(0));
-SELECT round(toFloat32(-13), toInt32(0)), ceil(toFloat32(-13), toInt32(0)), floor(toFloat32(-13), toInt32(0));
-SELECT round(toFloat32(-13), toInt64(0)), ceil(toFloat32(-13), toInt64(0)), floor(toFloat32(-13), toInt64(0));
-SELECT round(toFloat32(-13), toFloat32(0.1)), ceil(toFloat32(-13), toFloat32(0.1)), floor(toFloat32(-13), toFloat32(0.1));
-SELECT round(toFloat32(-13), toFloat64(0.1)), ceil(toFloat32(-13), toFloat64(0.1)), floor(toFloat32(-13), toFloat64(0.1));
-
-SELECT round(toFloat32(-13), toInt8(-1)), ceil(toFloat32(-13), toInt8(-1)), floor(toFloat32(-13), toInt8(-1));
-SELECT round(toFloat32(-13), toInt16(-1)), ceil(toFloat32(-13), toInt16(-1)), floor(toFloat32(-13), toInt16(-1));
-SELECT round(toFloat32(-13), toInt32(-1)), ceil(toFloat32(-13), toInt32(-1)), floor(toFloat32(-13), toInt32(-1));
-SELECT round(toFloat32(-13), toInt64(-1)), ceil(toFloat32(-13), toInt64(-1)), floor(toFloat32(-13), toInt64(-1));
-SELECT round(toFloat32(-13), toFloat32(1.1)), ceil(toFloat32(-13), toFloat32(-1.1)), floor(toFloat32(-13), toFloat32(-1.1));
-SELECT round(toFloat32(-13), toFloat64(1.1)), ceil(toFloat32(-13), toFloat64(-1.1)), floor(toFloat32(-13), toFloat64(-1.1));
-
-SELECT round(toFloat32(-13), toInt8(-2)), ceil(toFloat32(-13), toInt8(-2)), floor(toFloat32(-13), toInt8(-2));
-SELECT round(toFloat32(-13), toInt16(-2)), ceil(toFloat32(-13), toInt16(-2)), floor(toFloat32(-13), toInt16(-2));
-SELECT round(toFloat32(-13), toInt32(-2)), ceil(toFloat32(-13), toInt32(-2)), floor(toFloat32(-13), toInt32(-2));
-SELECT round(toFloat32(-13), toInt64(-2)), ceil(toFloat32(-13), toInt64(-2)), floor(toFloat32(-13), toInt64(-2));
-SELECT round(toFloat32(-13), toFloat32(-2.1)), ceil(toFloat32(-13), toFloat32(-2.1)), floor(toFloat32(-13), toFloat32(-2.1));
-SELECT round(toFloat32(-13), toFloat64(-2.1)), ceil(toFloat32(-13), toFloat64(-2.1)), floor(toFloat32(-13), toFloat64(-2.1));
-
-/* Float64 */
-
-SELECT round(toFloat64(-13), toUInt8(2)), ceil(toFloat64(-13), toUInt8(2)), floor(toFloat64(-13), toUInt8(2));
-SELECT round(toFloat64(-13), toUInt16(2)), ceil(toFloat64(-13), toUInt16(2)), floor(toFloat64(-13), toUInt16(2));
-SELECT round(toFloat64(-13), toUInt32(2)), ceil(toFloat64(-13), toUInt32(2)), floor(toFloat64(-13), toUInt32(2));
-SELECT round(toFloat64(-13), toUInt64(2)), ceil(toFloat64(-13), toUInt64(2)), floor(toFloat64(-13), toUInt64(2));
-SELECT round(toFloat64(-13), toInt8(2)), ceil(toFloat64(-13), toInt8(2)), floor(toFloat64(-13), toInt8(2));
-SELECT round(toFloat64(-13), toInt16(2)), ceil(toFloat64(-13), toInt16(2)), floor(toFloat64(-13), toInt16(2));
-SELECT round(toFloat64(-13), toInt32(2)), ceil(toFloat64(-13), toInt32(2)), floor(toFloat64(-13), toInt32(2));
-SELECT round(toFloat64(-13), toInt64(2)), ceil(toFloat64(-13), toInt64(2)), floor(toFloat64(-13), toInt64(2));
-SELECT round(toFloat64(-13), toFloat32(2.1)), ceil(toFloat64(-13), toFloat32(2.1)), floor(toFloat64(-13), toFloat32(2.1));
-SELECT round(toFloat64(-13), toFloat64(2.1)), ceil(toFloat64(-13), toFloat64(2.1)), floor(toFloat64(-13), toFloat64(2.1));
-
-SELECT round(toFloat64(-13), toUInt8(1)), ceil(toFloat64(-13), toUInt8(1)), floor(toFloat64(-13), toUInt8(1));
-SELECT round(toFloat64(-13), toUInt16(1)), ceil(toFloat64(-13), toUInt16(1)), floor(toFloat64(-13), toUInt16(1));
-SELECT round(toFloat64(-13), toUInt32(1)), ceil(toFloat64(-13), toUInt32(1)), floor(toFloat64(-13), toUInt32(1));
-SELECT round(toFloat64(-13), toUInt64(1)), ceil(toFloat64(-13), toUInt64(1)), floor(toFloat64(-13), toUInt64(1));
-SELECT round(toFloat64(-13), toInt8(1)), ceil(toFloat64(-13), toInt8(1)), floor(toFloat64(-13), toInt8(1));
-SELECT round(toFloat64(-13), toInt16(1)), ceil(toFloat64(-13), toInt16(1)), floor(toFloat64(-13), toInt16(1));
-SELECT round(toFloat64(-13), toInt32(1)), ceil(toFloat64(-13), toInt32(1)), floor(toFloat64(-13), toInt32(1));
-SELECT round(toFloat64(-13), toInt64(1)), ceil(toFloat64(-13), toInt64(1)), floor(toFloat64(-13), toInt64(1));
-SELECT round(toFloat64(-13), toFloat32(1.1)), ceil(toFloat64(-13), toFloat32(1.1)), floor(toFloat64(-13), toFloat32(1.1));
-SELECT round(toFloat64(-13), toFloat64(1.1)), ceil(toFloat64(-13), toFloat64(1.1)), floor(toFloat64(-13), toFloat64(1.1));
-
-SELECT round(toFloat64(-13), toUInt16(0)), ceil(toFloat64(-13), toUInt16(0)), floor(toFloat64(-13), toUInt16(0));
-SELECT round(toFloat64(-13), toUInt32(0)), ceil(toFloat64(-13), toUInt32(0)), floor(toFloat64(-13), toUInt32(0));
-SELECT round(toFloat64(-13), toUInt64(0)), ceil(toFloat64(-13), toUInt64(0)), floor(toFloat64(-13), toUInt64(0));
-SELECT round(toFloat64(-13), toInt8(0)), ceil(toFloat64(-13), toInt8(0)), floor(toFloat64(-13), toInt8(0));
-SELECT round(toFloat64(-13), toInt16(0)), ceil(toFloat64(-13), toInt16(0)), floor(toFloat64(-13), toInt16(0));
-SELECT round(toFloat64(-13), toInt32(0)), ceil(toFloat64(-13), toInt32(0)), floor(toFloat64(-13), toInt32(0));
-SELECT round(toFloat64(-13), toInt64(0)), ceil(toFloat64(-13), toInt64(0)), floor(toFloat64(-13), toInt64(0));
-SELECT round(toFloat64(-13), toFloat32(0.1)), ceil(toFloat64(-13), toFloat32(0.1)), floor(toFloat64(-13), toFloat32(0.1));
-SELECT round(toFloat64(-13), toFloat64(0.1)), ceil(toFloat64(-13), toFloat64(0.1)), floor(toFloat64(-13), toFloat64(0.1));
-
-SELECT round(toFloat64(-13), toInt8(-1)), ceil(toFloat64(-13), toInt8(-1)), floor(toFloat64(-13), toInt8(-1));
-SELECT round(toFloat64(-13), toInt16(-1)), ceil(toFloat64(-13), toInt16(-1)), floor(toFloat64(-13), toInt16(-1));
-SELECT round(toFloat64(-13), toInt32(-1)), ceil(toFloat64(-13), toInt32(-1)), floor(toFloat64(-13), toInt32(-1));
-SELECT round(toFloat64(-13), toInt64(-1)), ceil(toFloat64(-13), toInt64(-1)), floor(toFloat64(-13), toInt64(-1));
-SELECT round(toFloat64(-13), toFloat32(1.1)), ceil(toFloat64(-13), toFloat32(-1.1)), floor(toFloat64(-13), toFloat32(-1.1));
-SELECT round(toFloat64(-13), toFloat64(1.1)), ceil(toFloat64(-13), toFloat64(-1.1)), floor(toFloat64(-13), toFloat64(-1.1));
-
-SELECT round(toFloat64(-13), toInt8(-2)), ceil(toFloat64(-13), toInt8(-2)), floor(toFloat64(-13), toInt8(-2));
-SELECT round(toFloat64(-13), toInt16(-2)), ceil(toFloat64(-13), toInt16(-2)), floor(toFloat64(-13), toInt16(-2));
-SELECT round(toFloat64(-13), toInt32(-2)), ceil(toFloat64(-13), toInt32(-2)), floor(toFloat64(-13), toInt32(-2));
-SELECT round(toFloat64(-13), toInt64(-2)), ceil(toFloat64(-13), toInt64(-2)), floor(toFloat64(-13), toInt64(-2));
-SELECT round(toFloat64(-13), toFloat32(-2.1)), ceil(toFloat64(-13), toFloat32(-2.1)), floor(toFloat64(-13), toFloat32(-2.1));
-SELECT round(toFloat64(-13), toFloat64(-2.1)), ceil(toFloat64(-13), toFloat64(-2.1)), floor(toFloat64(-13), toFloat64(-2.1));
-
-/* Положительное число с плавающей точкой */
-
-SELECT round(toFloat64(2.718281828459), toUInt8(2)), ceil(toFloat64(2.718281828459), toUInt8(2)), floor(toFloat64(2.718281828459), toUInt8(2));
-SELECT round(toFloat64(2.718281828459), toUInt16(2)), ceil(toFloat64(2.718281828459), toUInt16(2)), floor(toFloat64(2.718281828459), toUInt16(2));
-SELECT round(toFloat64(2.718281828459), toUInt32(2)), ceil(toFloat64(2.718281828459), toUInt32(2)), floor(toFloat64(2.718281828459), toUInt32(2));
-SELECT round(toFloat64(2.718281828459), toUInt64(2)), ceil(toFloat64(2.718281828459), toUInt64(2)), floor(toFloat64(2.718281828459), toUInt64(2));
-SELECT round(toFloat64(2.718281828459), toInt8(2)), ceil(toFloat64(2.718281828459), toInt8(2)), floor(toFloat64(2.718281828459), toInt8(2));
-SELECT round(toFloat64(2.718281828459), toInt16(2)), ceil(toFloat64(2.718281828459), toInt16(2)), floor(toFloat64(2.718281828459), toInt16(2));
-SELECT round(toFloat64(2.718281828459), toInt32(2)), ceil(toFloat64(2.718281828459), toInt32(2)), floor(toFloat64(2.718281828459), toInt32(2));
-SELECT round(toFloat64(2.718281828459), toInt64(2)), ceil(toFloat64(2.718281828459), toInt64(2)), floor(toFloat64(2.718281828459), toInt64(2));
-SELECT round(toFloat64(2.718281828459), toFloat32(2.1)), ceil(toFloat64(2.718281828459), toFloat32(2.1)), floor(toFloat64(2.718281828459), toFloat32(2.1));
-SELECT round(toFloat64(2.718281828459), toFloat64(2.1)), ceil(toFloat64(2.718281828459), toFloat64(2.1)), floor(toFloat64(2.718281828459), toFloat64(2.1));
-
-SELECT round(toFloat64(2.718281828459), toUInt8(1)), ceil(toFloat64(2.718281828459), toUInt8(1)), floor(toFloat64(2.718281828459), toUInt8(1));
-SELECT round(toFloat64(2.718281828459), toUInt16(1)), ceil(toFloat64(2.718281828459), toUInt16(1)), floor(toFloat64(2.718281828459), toUInt16(1));
-SELECT round(toFloat64(2.718281828459), toUInt32(1)), ceil(toFloat64(2.718281828459), toUInt32(1)), floor(toFloat64(2.718281828459), toUInt32(1));
-SELECT round(toFloat64(2.718281828459), toUInt64(1)), ceil(toFloat64(2.718281828459), toUInt64(1)), floor(toFloat64(2.718281828459), toUInt64(1));
-SELECT round(toFloat64(2.718281828459), toInt8(1)), ceil(toFloat64(2.718281828459), toInt8(1)), floor(toFloat64(2.718281828459), toInt8(1));
-SELECT round(toFloat64(2.718281828459), toInt16(1)), ceil(toFloat64(2.718281828459), toInt16(1)), floor(toFloat64(2.718281828459), toInt16(1));
-SELECT round(toFloat64(2.718281828459), toInt32(1)), ceil(toFloat64(2.718281828459), toInt32(1)), floor(toFloat64(2.718281828459), toInt32(1));
-SELECT round(toFloat64(2.718281828459), toInt64(1)), ceil(toFloat64(2.718281828459), toInt64(1)), floor(toFloat64(2.718281828459), toInt64(1));
-SELECT round(toFloat64(2.718281828459), toFloat32(1.1)), ceil(toFloat64(2.718281828459), toFloat32(1.1)), floor(toFloat64(2.718281828459), toFloat32(1.1));
-SELECT round(toFloat64(2.718281828459), toFloat64(1.1)), ceil(toFloat64(2.718281828459), toFloat64(1.1)), floor(toFloat64(2.718281828459), toFloat64(1.1));
-
-SELECT round(toFloat64(2.718281828459), toUInt16(0)), ceil(toFloat64(2.718281828459), toUInt16(0)), floor(toFloat64(2.718281828459), toUInt16(0));
-SELECT round(toFloat64(2.718281828459), toUInt32(0)), ceil(toFloat64(2.718281828459), toUInt32(0)), floor(toFloat64(2.718281828459), toUInt32(0));
-SELECT round(toFloat64(2.718281828459), toUInt64(0)), ceil(toFloat64(2.718281828459), toUInt64(0)), floor(toFloat64(2.718281828459), toUInt64(0));
-SELECT round(toFloat64(2.718281828459), toInt8(0)), ceil(toFloat64(2.718281828459), toInt8(0)), floor(toFloat64(2.718281828459), toInt8(0));
-SELECT round(toFloat64(2.718281828459), toInt16(0)), ceil(toFloat64(2.718281828459), toInt16(0)), floor(toFloat64(2.718281828459), toInt16(0));
-SELECT round(toFloat64(2.718281828459), toInt32(0)), ceil(toFloat64(2.718281828459), toInt32(0)), floor(toFloat64(2.718281828459), toInt32(0));
-SELECT round(toFloat64(2.718281828459), toInt64(0)), ceil(toFloat64(2.718281828459), toInt64(0)), floor(toFloat64(2.718281828459), toInt64(0));
-SELECT round(toFloat64(2.718281828459), toFloat32(0.1)), ceil(toFloat64(2.718281828459), toFloat32(0.1)), floor(toFloat64(2.718281828459), toFloat32(0.1));
-SELECT round(toFloat64(2.718281828459), toFloat64(0.1)), ceil(toFloat64(2.718281828459), toFloat64(0.1)), floor(toFloat64(2.718281828459), toFloat64(0.1));
-
-SELECT round(toFloat64(2.718281828459), toInt8(-1)), ceil(toFloat64(2.718281828459), toInt8(-1)), floor(toFloat64(2.718281828459), toInt8(-1));
-SELECT round(toFloat64(2.718281828459), toInt16(-1)), ceil(toFloat64(2.718281828459), toInt16(-1)), floor(toFloat64(2.718281828459), toInt16(-1));
-SELECT round(toFloat64(2.718281828459), toInt32(-1)), ceil(toFloat64(2.718281828459), toInt32(-1)), floor(toFloat64(2.718281828459), toInt32(-1));
-SELECT round(toFloat64(2.718281828459), toInt64(-1)), ceil(toFloat64(2.718281828459), toInt64(-1)), floor(toFloat64(2.718281828459), toInt64(-1));
-SELECT round(toFloat64(2.718281828459), toFloat32(1.1)), ceil(toFloat64(2.718281828459), toFloat32(-1.1)), floor(toFloat64(2.718281828459), toFloat32(-1.1));
-SELECT round(toFloat64(2.718281828459), toFloat64(1.1)), ceil(toFloat64(2.718281828459), toFloat64(-1.1)), floor(toFloat64(2.718281828459), toFloat64(-1.1));
-
-SELECT round(toFloat64(2.718281828459), toInt8(-2)), ceil(toFloat64(2.718281828459), toInt8(-2)), floor(toFloat64(2.718281828459), toInt8(-2));
-SELECT round(toFloat64(2.718281828459), toInt16(-2)), ceil(toFloat64(2.718281828459), toInt16(-2)), floor(toFloat64(2.718281828459), toInt16(-2));
-SELECT round(toFloat64(2.718281828459), toInt32(-2)), ceil(toFloat64(2.718281828459), toInt32(-2)), floor(toFloat64(2.718281828459), toInt32(-2));
-SELECT round(toFloat64(2.718281828459), toInt64(-2)), ceil(toFloat64(2.718281828459), toInt64(-2)), floor(toFloat64(2.718281828459), toInt64(-2));
-SELECT round(toFloat64(2.718281828459), toFloat32(-2.1)), ceil(toFloat64(2.718281828459), toFloat32(-2.1)), floor(toFloat64(2.718281828459), toFloat32(-2.1));
-SELECT round(toFloat64(2.718281828459), toFloat64(-2.1)), ceil(toFloat64(2.718281828459), toFloat64(-2.1)), floor(toFloat64(2.718281828459), toFloat64(-2.1));
-
-/* Отрицательное число с плавающей точкой */
-
-SELECT round(toFloat64(-2.718281828459), toUInt8(2)), ceil(toFloat64(-2.718281828459), toUInt8(2)), floor(toFloat64(-2.718281828459), toUInt8(2));
-SELECT round(toFloat64(-2.718281828459), toUInt16(2)), ceil(toFloat64(-2.718281828459), toUInt16(2)), floor(toFloat64(-2.718281828459), toUInt16(2));
-SELECT round(toFloat64(-2.718281828459), toUInt32(2)), ceil(toFloat64(-2.718281828459), toUInt32(2)), floor(toFloat64(-2.718281828459), toUInt32(2));
-SELECT round(toFloat64(-2.718281828459), toUInt64(2)), ceil(toFloat64(-2.718281828459), toUInt64(2)), floor(toFloat64(-2.718281828459), toUInt64(2));
-SELECT round(toFloat64(-2.718281828459), toInt8(2)), ceil(toFloat64(-2.718281828459), toInt8(2)), floor(toFloat64(-2.718281828459), toInt8(2));
-SELECT round(toFloat64(-2.718281828459), toInt16(2)), ceil(toFloat64(-2.718281828459), toInt16(2)), floor(toFloat64(-2.718281828459), toInt16(2));
-SELECT round(toFloat64(-2.718281828459), toInt32(2)), ceil(toFloat64(-2.718281828459), toInt32(2)), floor(toFloat64(-2.718281828459), toInt32(2));
-SELECT round(toFloat64(-2.718281828459), toInt64(2)), ceil(toFloat64(-2.718281828459), toInt64(2)), floor(toFloat64(-2.718281828459), toInt64(2));
-SELECT round(toFloat64(-2.718281828459), toFloat32(2.1)), ceil(toFloat64(-2.718281828459), toFloat32(2.1)), floor(toFloat64(-2.718281828459), toFloat32(2.1));
-SELECT round(toFloat64(-2.718281828459), toFloat64(2.1)), ceil(toFloat64(-2.718281828459), toFloat64(2.1)), floor(toFloat64(-2.718281828459), toFloat64(2.1));
-
-SELECT round(toFloat64(-2.718281828459), toUInt8(1)), ceil(toFloat64(-2.718281828459), toUInt8(1)), floor(toFloat64(-2.718281828459), toUInt8(1));
-SELECT round(toFloat64(-2.718281828459), toUInt16(1)), ceil(toFloat64(-2.718281828459), toUInt16(1)), floor(toFloat64(-2.718281828459), toUInt16(1));
-SELECT round(toFloat64(-2.718281828459), toUInt32(1)), ceil(toFloat64(-2.718281828459), toUInt32(1)), floor(toFloat64(-2.718281828459), toUInt32(1));
-SELECT round(toFloat64(-2.718281828459), toUInt64(1)), ceil(toFloat64(-2.718281828459), toUInt64(1)), floor(toFloat64(-2.718281828459), toUInt64(1));
-SELECT round(toFloat64(-2.718281828459), toInt8(1)), ceil(toFloat64(-2.718281828459), toInt8(1)), floor(toFloat64(-2.718281828459), toInt8(1));
-SELECT round(toFloat64(-2.718281828459), toInt16(1)), ceil(toFloat64(-2.718281828459), toInt16(1)), floor(toFloat64(-2.718281828459), toInt16(1));
-SELECT round(toFloat64(-2.718281828459), toInt32(1)), ceil(toFloat64(-2.718281828459), toInt32(1)), floor(toFloat64(-2.718281828459), toInt32(1));
-SELECT round(toFloat64(-2.718281828459), toInt64(1)), ceil(toFloat64(-2.718281828459), toInt64(1)), floor(toFloat64(-2.718281828459), toInt64(1));
-SELECT round(toFloat64(-2.718281828459), toFloat32(1.1)), ceil(toFloat64(-2.718281828459), toFloat32(1.1)), floor(toFloat64(-2.718281828459), toFloat32(1.1));
-SELECT round(toFloat64(-2.718281828459), toFloat64(1.1)), ceil(toFloat64(-2.718281828459), toFloat64(1.1)), floor(toFloat64(-2.718281828459), toFloat64(1.1));
-
-SELECT round(toFloat64(-2.718281828459), toUInt16(0)), ceil(toFloat64(-2.718281828459), toUInt16(0)), floor(toFloat64(-2.718281828459), toUInt16(0));
-SELECT round(toFloat64(-2.718281828459), toUInt32(0)), ceil(toFloat64(-2.718281828459), toUInt32(0)), floor(toFloat64(-2.718281828459), toUInt32(0));
-SELECT round(toFloat64(-2.718281828459), toUInt64(0)), ceil(toFloat64(-2.718281828459), toUInt64(0)), floor(toFloat64(-2.718281828459), toUInt64(0));
-SELECT round(toFloat64(-2.718281828459), toInt8(0)), ceil(toFloat64(-2.718281828459), toInt8(0)), floor(toFloat64(-2.718281828459), toInt8(0));
-SELECT round(toFloat64(-2.718281828459), toInt16(0)), ceil(toFloat64(-2.718281828459), toInt16(0)), floor(toFloat64(-2.718281828459), toInt16(0));
-SELECT round(toFloat64(-2.718281828459), toInt32(0)), ceil(toFloat64(-2.718281828459), toInt32(0)), floor(toFloat64(-2.718281828459), toInt32(0));
-SELECT round(toFloat64(-2.718281828459), toInt64(0)), ceil(toFloat64(-2.718281828459), toInt64(0)), floor(toFloat64(-2.718281828459), toInt64(0));
-SELECT round(toFloat64(-2.718281828459), toFloat32(0.1)), ceil(toFloat64(-2.718281828459), toFloat32(0.1)), floor(toFloat64(-2.718281828459), toFloat32(0.1));
-SELECT round(toFloat64(-2.718281828459), toFloat64(0.1)), ceil(toFloat64(-2.718281828459), toFloat64(0.1)), floor(toFloat64(-2.718281828459), toFloat64(0.1));
-
-SELECT round(toFloat64(-2.718281828459), toInt8(-1)), ceil(toFloat64(-2.718281828459), toInt8(-1)), floor(toFloat64(-2.718281828459), toInt8(-1));
-SELECT round(toFloat64(-2.718281828459), toInt16(-1)), ceil(toFloat64(-2.718281828459), toInt16(-1)), floor(toFloat64(-2.718281828459), toInt16(-1));
-SELECT round(toFloat64(-2.718281828459), toInt32(-1)), ceil(toFloat64(-2.718281828459), toInt32(-1)), floor(toFloat64(-2.718281828459), toInt32(-1));
-SELECT round(toFloat64(-2.718281828459), toInt64(-1)), ceil(toFloat64(-2.718281828459), toInt64(-1)), floor(toFloat64(-2.718281828459), toInt64(-1));
-SELECT round(toFloat64(-2.718281828459), toFloat32(1.1)), ceil(toFloat64(-2.718281828459), toFloat32(-1.1)), floor(toFloat64(-2.718281828459), toFloat32(-1.1));
-SELECT round(toFloat64(-2.718281828459), toFloat64(1.1)), ceil(toFloat64(-2.718281828459), toFloat64(-1.1)), floor(toFloat64(-2.718281828459), toFloat64(-1.1));
-
-SELECT round(toFloat64(-2.718281828459), toInt8(-2)), ceil(toFloat64(-2.718281828459), toInt8(-2)), floor(toFloat64(-2.718281828459), toInt8(-2));
-SELECT round(toFloat64(-2.718281828459), toInt16(-2)), ceil(toFloat64(-2.718281828459), toInt16(-2)), floor(toFloat64(-2.718281828459), toInt16(-2));
-SELECT round(toFloat64(-2.718281828459), toInt32(-2)), ceil(toFloat64(-2.718281828459), toInt32(-2)), floor(toFloat64(-2.718281828459), toInt32(-2));
-SELECT round(toFloat64(-2.718281828459), toInt64(-2)), ceil(toFloat64(-2.718281828459), toInt64(-2)), floor(toFloat64(-2.718281828459), toInt64(-2));
-SELECT round(toFloat64(-2.718281828459), toFloat32(-2.1)), ceil(toFloat64(-2.718281828459), toFloat32(-2.1)), floor(toFloat64(-2.718281828459), toFloat32(-2.1));
-SELECT round(toFloat64(-2.718281828459), toFloat64(-2.1)), ceil(toFloat64(-2.718281828459), toFloat64(-2.1)), floor(toFloat64(-2.718281828459), toFloat64(-2.1));
-
-/* Misc. */
-
-SELECT round(13112221, -1), ceil(13112221, -1), floor(13112221, -1);
-SELECT round(13112221, -2), ceil(13112221, -2), floor(13112221, -2);
-SELECT round(13112221, -3), ceil(13112221, -3), floor(13112221, -3);
-SELECT round(13112221, -4), ceil(13112221, -4), floor(13112221, -4);
-SELECT round(13112221, -5), ceil(13112221, -5), floor(13112221, -5);
-SELECT round(13112221, -6), ceil(13112221, -6), floor(13112221, -6);
-SELECT round(13112221, -7), ceil(13112221, -7), floor(13112221, -7);
-SELECT round(13112221, -8), ceil(13112221, -8), floor(13112221, -8);
-SELECT round(13112221, -9), ceil(13112221, -9), floor(13112221, -9);
-SELECT round(13112221, -10), ceil(13112221, -10), floor(13112221, -10);
-SELECT round(13112221, -11), ceil(13112221, -11), floor(13112221, -11);
-SELECT round(13112221, -12), ceil(13112221, -12), floor(13112221, -12);
-SELECT round(13112221, -13), ceil(13112221, -13), floor(13112221, -13);
-SELECT round(13112221, -14), ceil(13112221, -14), floor(13112221, -14);
-SELECT round(13112221, -15), ceil(13112221, -15), floor(13112221, -15);
-SELECT round(13112221, -16), ceil(13112221, -16), floor(13112221, -16);
-SELECT round(13112221, -17), ceil(13112221, -17), floor(13112221, -17);
-SELECT round(13112221, -18), ceil(13112221, -18), floor(13112221, -18);
-SELECT round(13112221, -19), ceil(13112221, -19), floor(13112221, -19);
-SELECT round(13112221, -20), ceil(13112221, -20), floor(13112221, -20);
-
-SELECT round(2.718281828459045, 1), ceil(2.718281828459045, 1), floor(2.718281828459045, 1);
-SELECT round(2.718281828459045, 2), ceil(2.718281828459045, 2), floor(2.718281828459045, 2);
-SELECT round(2.718281828459045, 3), ceil(2.718281828459045, 3), floor(2.718281828459045, 3);
-SELECT round(2.718281828459045, 4), ceil(2.718281828459045, 4), floor(2.718281828459045, 4);
-SELECT round(2.718281828459045, 5), ceil(2.718281828459045, 5), floor(2.718281828459045, 5);
-SELECT round(2.718281828459045, 6), ceil(2.718281828459045, 6), floor(2.718281828459045, 6);
-SELECT round(2.718281828459045, 7), ceil(2.718281828459045, 7), floor(2.718281828459045, 7);
-SELECT round(2.718281828459045, 8), ceil(2.718281828459045, 8), floor(2.718281828459045, 8);
-SELECT round(2.718281828459045, 9), ceil(2.718281828459045, 9), floor(2.718281828459045, 9);
-SELECT round(2.718281828459045, 10), ceil(2.718281828459045, 10), floor(2.718281828459045, 10);
-SELECT round(2.718281828459045, 11), ceil(2.718281828459045, 11), floor(2.718281828459045, 11);
-SELECT round(2.718281828459045, 12), ceil(2.718281828459045, 12), floor(2.718281828459045, 12);
-SELECT round(2.718281828459045, 13), ceil(2.718281828459045, 13), floor(2.718281828459045, 13);
-SELECT round(2.718281828459045, 14), ceil(2.718281828459045, 14), floor(2.718281828459045, 14);
-SELECT round(2.718281828459045, 15), ceil(2.718281828459045, 15), floor(2.718281828459045, 15);
-SELECT round(2.718281828459045, 16), ceil(2.718281828459045, 16), floor(2.718281828459045, 16);
-SELECT round(2.718281828459045, 17), ceil(2.718281828459045, 17), floor(2.718281828459045, 17);
-SELECT round(2.718281828459045, 18), ceil(2.718281828459045, 18), floor(2.718281828459045, 18);
-SELECT round(2.718281828459045, 19), ceil(2.718281828459045, 19), floor(2.718281828459045, 19);
-SELECT round(2.718281828459045, 20), ceil(2.718281828459045, 20), floor(2.718281828459045, 20);
-
-SELECT round(y,3) FROM (SELECT 2.718281828459045 + 1/(1+x*x) AS y FROM system.one ARRAY JOIN range(1) AS x);
-SELECT round(y,3) FROM (SELECT 2.718281828459045 + 1/(1+x*x) AS y FROM system.one ARRAY JOIN range(2) AS x);
-SELECT round(y,3) FROM (SELECT 2.718281828459045 + 1/(1+x*x) AS y FROM system.one ARRAY JOIN range(3) AS x);
-SELECT round(y,3) FROM (SELECT 2.718281828459045 + 1/(1+x*x) AS y FROM system.one ARRAY JOIN range(4) AS x);
-SELECT round(y,3) FROM (SELECT 2.718281828459045 + 1/(1+x*x) AS y FROM system.one ARRAY JOIN range(5) AS x);
-SELECT round(y,3) FROM (SELECT 2.718281828459045 + 1/(1+x*x) AS y FROM system.one ARRAY JOIN range(6) AS x);
-SELECT round(y,3) FROM (SELECT 2.718281828459045 + 1/(1+x*x) AS y FROM system.one ARRAY JOIN range(7) AS x);
-SELECT round(y,3) FROM (SELECT 2.718281828459045 + 1/(1+x*x) AS y FROM system.one ARRAY JOIN range(8) AS x);
-SELECT round(y,3) FROM (SELECT 2.718281828459045 + 1/(1+x*x) AS y FROM system.one ARRAY JOIN range(9) AS x);
-SELECT round(y,3) FROM (SELECT 2.718281828459045 + 1/(1+x*x) AS y FROM system.one ARRAY JOIN range(10) AS x);
-
-/* Negative zeroes. */
-
-SELECT round(-0.002);
-SELECT round(-0.002, -1);
-SELECT round(-0.002, 1);
+SELECT toUInt8(number) AS x, round(x), floor(x), ceil(x), trunc(x) FROM system.numbers LIMIT 20;
+SELECT toUInt16(number) AS x, round(x), floor(x), ceil(x), trunc(x) FROM system.numbers LIMIT 20;
+SELECT toUInt32(number) AS x, round(x), floor(x), ceil(x), trunc(x) FROM system.numbers LIMIT 20;
+SELECT toUInt64(number) AS x, round(x), floor(x), ceil(x), trunc(x) FROM system.numbers LIMIT 20;
+SELECT toInt8(number - 10) AS x, round(x), floor(x), ceil(x), trunc(x) FROM system.numbers LIMIT 20;
+SELECT toInt16(number - 10) AS x, round(x), floor(x), ceil(x), trunc(x) FROM system.numbers LIMIT 20;
+SELECT toInt32(number - 10) AS x, round(x), floor(x), ceil(x), trunc(x) FROM system.numbers LIMIT 20;
+SELECT toInt64(number - 10) AS x, round(x), floor(x), ceil(x), trunc(x) FROM system.numbers LIMIT 20;
+SELECT toFloat32(number - 10) AS x, round(x), floor(x), ceil(x), trunc(x) FROM system.numbers LIMIT 20;
+SELECT toFloat64(number - 10) AS x, round(x), floor(x), ceil(x), trunc(x) FROM system.numbers LIMIT 20;
+
+SELECT toFloat32((number - 10) / 10) AS x, round(x), floor(x), ceil(x), trunc(x) FROM system.numbers LIMIT 20;
+SELECT toFloat64((number - 10) / 10) AS x, round(x), floor(x), ceil(x), trunc(x) FROM system.numbers LIMIT 20;
+
+SELECT toFloat32((number - 10) / 10) AS x, round(x, 1), floor(x, 1), ceil(x, 1), trunc(x, 1) FROM system.numbers LIMIT 20;
+SELECT toFloat64((number - 10) / 10) AS x, round(x, 1), floor(x, 1), ceil(x, 1), trunc(x, 1) FROM system.numbers LIMIT 20;
+
+SELECT toUInt8(number) AS x, round(x, -1), floor(x, -1), ceil(x, -1), trunc(x, -1) FROM system.numbers LIMIT 20;
+SELECT toUInt16(number) AS x, round(x, -1), floor(x, -1), ceil(x, -1), trunc(x, -1) FROM system.numbers LIMIT 20;
+SELECT toUInt32(number) AS x, round(x, -1), floor(x, -1), ceil(x, -1), trunc(x, -1) FROM system.numbers LIMIT 20;
+SELECT toUInt64(number) AS x, round(x, -1), floor(x, -1), ceil(x, -1), trunc(x, -1) FROM system.numbers LIMIT 20;
+SELECT toInt8(number - 10) AS x, round(x, -1), floor(x, -1), ceil(x, -1), trunc(x, -1) FROM system.numbers LIMIT 20;
+SELECT toInt16(number - 10) AS x, round(x, -1), floor(x, -1), ceil(x, -1), trunc(x, -1) FROM system.numbers LIMIT 20;
+SELECT toInt32(number - 10) AS x, round(x, -1), floor(x, -1), ceil(x, -1), trunc(x, -1) FROM system.numbers LIMIT 20;
+SELECT toInt64(number - 10) AS x, round(x, -1), floor(x, -1), ceil(x, -1), trunc(x, -1) FROM system.numbers LIMIT 20;
+SELECT toFloat32(number - 10) AS x, round(x, -1), floor(x, -1), ceil(x, -1), trunc(x, -1) FROM system.numbers LIMIT 20;
+SELECT toFloat64(number - 10) AS x, round(x, -1), floor(x, -1), ceil(x, -1), trunc(x, -1) FROM system.numbers LIMIT 20;
+
+SELECT toUInt8(number) AS x, round(x, -2), floor(x, -2), ceil(x, -2), trunc(x, -2) FROM system.numbers LIMIT 20;
+SELECT toUInt16(number) AS x, round(x, -2), floor(x, -2), ceil(x, -2), trunc(x, -2) FROM system.numbers LIMIT 20;
+SELECT toUInt32(number) AS x, round(x, -2), floor(x, -2), ceil(x, -2), trunc(x, -2) FROM system.numbers LIMIT 20;
+SELECT toUInt64(number) AS x, round(x, -2), floor(x, -2), ceil(x, -2), trunc(x, -2) FROM system.numbers LIMIT 20;
+SELECT toInt8(number - 10) AS x, round(x, -2), floor(x, -2), ceil(x, -2), trunc(x, -2) FROM system.numbers LIMIT 20;
+SELECT toInt16(number - 10) AS x, round(x, -2), floor(x, -2), ceil(x, -2), trunc(x, -2) FROM system.numbers LIMIT 20;
+SELECT toInt32(number - 10) AS x, round(x, -2), floor(x, -2), ceil(x, -2), trunc(x, -2) FROM system.numbers LIMIT 20;
+SELECT toInt64(number - 10) AS x, round(x, -2), floor(x, -2), ceil(x, -2), trunc(x, -2) FROM system.numbers LIMIT 20;
+SELECT toFloat32(number - 10) AS x, round(x, -2), floor(x, -2), ceil(x, -2), trunc(x, -2) FROM system.numbers LIMIT 20;
+SELECT toFloat64(number - 10) AS x, round(x, -2), floor(x, -2), ceil(x, -2), trunc(x, -2) FROM system.numbers LIMIT 20;
+
+SELECT 123456789 AS x, floor(x, -1), floor(x, -2), floor(x, -3), floor(x, -4), floor(x, -5), floor(x, -6), floor(x, -7), floor(x, -8), floor(x, -9), floor(x, -10);
+SELECT 12345.6789 AS x, floor(x, -1), floor(x, -2), floor(x, -3), floor(x, -4), floor(x, -5), floor(x, 1), floor(x, 2), floor(x, 3), floor(x, 4), floor(x, 5);
+
+
+SELECT roundToExp2(100), roundToExp2(64), roundToExp2(3), roundToExp2(0), roundToExp2(-1);
+SELECT roundToExp2(0.9), roundToExp2(0), roundToExp2(-0.5), roundToExp2(-0.6), roundToExp2(-0.2);

From 4df44cfeb4848d831d2cac0826cc226b7f22e93a Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 17 Sep 2017 21:00:27 +0300
Subject: [PATCH 263/266] Modified comment [#CLICKHOUSE-2].

---
 dbms/src/Interpreters/SpecializedAggregator.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dbms/src/Interpreters/SpecializedAggregator.h b/dbms/src/Interpreters/SpecializedAggregator.h
index 56a1d803a90..bcf768ae02d 100644
--- a/dbms/src/Interpreters/SpecializedAggregator.h
+++ b/dbms/src/Interpreters/SpecializedAggregator.h
@@ -263,8 +263,8 @@ void NO_INLINE Aggregator::executeSpecializedWithoutKey(
 }
 
 
-/** The main code is compiled with gcc 5.
-  * But SpecializedAggregator is compiled using clang 3.6 into the .so file.
+/** The main code is compiled with gcc 7.
+  * But SpecializedAggregator is compiled using clang 6 into the .so file.
   * This is done because gcc can not get functions inlined,
   *  which were de-virtualized, in a particular case, and the performance is lower.
   * And also it's easier to distribute clang for deploy to the servers.

From dd3e74c0eb8cb7346a253a9d5fa72d2968575173 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 17 Sep 2017 21:17:04 +0300
Subject: [PATCH 264/266] Fixed weird translation [#CLICKHOUSE-2].

---
 .../AggregateFunctionDebug.cpp                | 92 -------------------
 dbms/src/Interpreters/SpecializedAggregator.h |  4 +-
 2 files changed, 2 insertions(+), 94 deletions(-)
 delete mode 100644 dbms/src/AggregateFunctions/AggregateFunctionDebug.cpp

diff --git a/dbms/src/AggregateFunctions/AggregateFunctionDebug.cpp b/dbms/src/AggregateFunctions/AggregateFunctionDebug.cpp
deleted file mode 100644
index c17030b5115..00000000000
--- a/dbms/src/AggregateFunctions/AggregateFunctionDebug.cpp
+++ /dev/null
@@ -1,92 +0,0 @@
-#include <AggregateFunctions/INullaryAggregateFunction.h>
-#include <AggregateFunctions/AggregateFunctionFactory.h>
-#include <DataTypes/DataTypesNumber.h>
-#include <Columns/ColumnsNumber.h>
-#include <IO/ReadHelpers.h>
-#include <IO/WriteHelpers.h>
-
-
-namespace DB
-{
-
-
-/** State management of aggregate functions is done in a non-trivial way:
-  * - the memory for them needs to be allocated in the pool,
-  *   pointers to these states can be passed between different data structures,
-  *   herewith, you can not make RAII wrappers for each individual state.
-  * For more information, see Aggregator.h.
-  *
-  * In this regard, there are difficult-debugging bugs.
-  * To simplify the playback of bugs, an aggregate `debug` function was written,
-  *  and its source code is decided not to delete after debugging.
-  *
-  * This aggregate function takes zero arguments and does nothing.
-  * But it has a state that is non-trivially created and destroyed.
-  */
-
-
-struct AggregateFunctionDebugData
-{
-    std::unique_ptr<size_t> ptr { new size_t(0xABCDEF01DEADBEEF) };
-    AggregateFunctionDebugData() {}
-    ~AggregateFunctionDebugData()
-    {
-        if (*ptr != 0xABCDEF01DEADBEEF)
-        {
-            std::cerr << "Bug!";
-            abort();
-        }
-
-        ptr.reset();
-    }
-};
-
-
-class AggregateFunctionDebug final : public INullaryAggregateFunction<AggregateFunctionDebugData, AggregateFunctionDebug>
-{
-public:
-    String getName() const override { return "debug"; }
-
-    DataTypePtr getReturnType() const override
-    {
-        return std::make_shared<DataTypeUInt8>();
-    }
-
-    void addImpl(AggregateDataPtr place) const
-    {
-    }
-
-    void merge(AggregateDataPtr place, ConstAggregateDataPtr rhs, Arena * arena) const override
-    {
-    }
-
-    void serialize(ConstAggregateDataPtr place, WriteBuffer & buf) const override
-    {
-        writeBinary(UInt8(0), buf);
-    }
-
-    void deserialize(AggregateDataPtr place, ReadBuffer & buf, Arena *) const override
-    {
-        UInt8 tmp;
-        readBinary(tmp, buf);
-    }
-
-    void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
-    {
-        static_cast<ColumnUInt8 &>(to).getData().push_back(0);
-    }
-};
-
-
-AggregateFunctionPtr createAggregateFunctionDebug(const std::string & name, const DataTypes & argument_types, const Array & parameters)
-{
-    return std::make_shared<AggregateFunctionDebug>();
-}
-
-
-void registerAggregateFunctionDebug(AggregateFunctionFactory & factory)
-{
-    factory.registerFunction("debug", createAggregateFunctionDebug);
-}
-
-}
diff --git a/dbms/src/Interpreters/SpecializedAggregator.h b/dbms/src/Interpreters/SpecializedAggregator.h
index bcf768ae02d..8ea63b577b6 100644
--- a/dbms/src/Interpreters/SpecializedAggregator.h
+++ b/dbms/src/Interpreters/SpecializedAggregator.h
@@ -32,8 +32,8 @@ namespace DB
 {
 
 
-/** An aggregation cycle template that allows you to generate a custom variant for a specific combination of aggregate functions.
-  * It differs from the usual one in that calls to aggregate functions should be inlined, and the update cycle of the aggregate functions should be unfold.
+/** An aggregation loop template that allows you to generate a custom variant for a specific combination of aggregate functions.
+  * It differs from the usual one in that calls to aggregate functions should be inlined, and the update loop of the aggregate functions should be unrolled.
   *
   * Since there are too many possible combinations, it is not possible to generate them all in advance.
   * This template is intended to instantiate it in runtime,

From 156d48f3ee5a460a860dcbd753f1e163594c33c7 Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 17 Sep 2017 23:12:02 +0300
Subject: [PATCH 265/266] Removed aggregate function "debug" [#CLICKHOUSE-2].

---
 dbms/src/AggregateFunctions/registerAggregateFunctions.cpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/dbms/src/AggregateFunctions/registerAggregateFunctions.cpp b/dbms/src/AggregateFunctions/registerAggregateFunctions.cpp
index e37ddeade76..69f07a38754 100644
--- a/dbms/src/AggregateFunctions/registerAggregateFunctions.cpp
+++ b/dbms/src/AggregateFunctions/registerAggregateFunctions.cpp
@@ -24,7 +24,6 @@ void registerAggregateFunctionsUniq(AggregateFunctionFactory & factory);
 void registerAggregateFunctionUniqUpTo(AggregateFunctionFactory & factory);
 void registerAggregateFunctionTopK(AggregateFunctionFactory & factory);
 void registerAggregateFunctionsBitwise(AggregateFunctionFactory & factory);
-void registerAggregateFunctionDebug(AggregateFunctionFactory & factory);
 
 
 void registerAggregateFunctions()
@@ -50,7 +49,6 @@ void registerAggregateFunctions()
     registerAggregateFunctionUniqUpTo(factory);
     registerAggregateFunctionTopK(factory);
     registerAggregateFunctionsBitwise(factory);
-    registerAggregateFunctionDebug(factory);
 }
 
 }

From ff1598c8d12970c9bb76d3f0fd6bb8a22471b7ae Mon Sep 17 00:00:00 2001
From: Alexey Milovidov <milovidov@yandex-team.ru>
Date: Sun, 17 Sep 2017 23:22:39 +0300
Subject: [PATCH 266/266] Improved performance of dynamic compilation
 [#CLICKHOUSE-2].

---
 copy_headers.sh                               | 18 ++++++++-----
 .../AggregateFunctionArgMinMax.h              |  2 ++
 .../AggregateFunctionArray.h                  |  2 ++
 .../AggregateFunctions/AggregateFunctionAvg.h |  2 ++
 .../AggregateFunctionBitwise.h                |  2 ++
 .../AggregateFunctionCount.h                  |  6 +++++
 .../AggregateFunctionForEach.h                |  2 ++
 .../AggregateFunctionGroupArray.h             |  4 +++
 .../AggregateFunctionGroupArrayInsertAt.h     |  2 ++
 .../AggregateFunctionGroupUniqArray.h         |  4 +++
 .../AggregateFunctions/AggregateFunctionIf.h  |  2 ++
 .../AggregateFunctionMerge.h                  |  2 ++
 .../AggregateFunctionMinMaxAny.h              |  2 ++
 .../AggregateFunctionNull.h                   |  2 ++
 .../AggregateFunctionQuantile.h               |  4 +++
 .../AggregateFunctionQuantileDeterministic.h  |  4 +++
 .../AggregateFunctionQuantileExact.h          |  4 +++
 .../AggregateFunctionQuantileExactWeighted.h  |  4 +++
 .../AggregateFunctionQuantileTDigest.h        |  8 ++++++
 .../AggregateFunctionQuantileTiming.h         |  8 ++++++
 .../AggregateFunctionSequenceMatch.h          |  2 ++
 .../AggregateFunctionState.h                  |  2 ++
 .../AggregateFunctionStatistics.h             |  4 +++
 .../AggregateFunctions/AggregateFunctionSum.h |  2 ++
 .../AggregateFunctionTopK.h                   |  4 +++
 .../AggregateFunctionUniq.h                   | 16 ++++++-----
 .../AggregateFunctionUniqUpTo.h               |  4 +++
 .../AggregateFunctions/IAggregateFunction.h   |  7 ++++-
 dbms/src/Interpreters/Aggregator.cpp          | 18 +++++++++++--
 dbms/src/Interpreters/Compiler.cpp            |  3 ++-
 dbms/src/Interpreters/SpecializedAggregator.h | 27 +------------------
 dbms/src/Parsers/ASTSystemQuery.h             |  2 +-
 32 files changed, 132 insertions(+), 43 deletions(-)

diff --git a/copy_headers.sh b/copy_headers.sh
index 69a1d366180..cafd6cc9baa 100755
--- a/copy_headers.sh
+++ b/copy_headers.sh
@@ -16,7 +16,8 @@
 # sudo ./copy_headers.sh . /usr/share/clickhouse/headers/
 
 SOURCE_PATH=${1:-.}
-DST=${2:-$SOURCE_PATH/../headers};
+DST=${2:-$SOURCE_PATH/../headers}
+BUILD_PATH=${3:-$SOURCE_PATH/build}
 
 PATH="/usr/local/bin:/usr/local/sbin:/usr/bin:$PATH"
 
@@ -24,14 +25,19 @@ if [[ -z $CLANG ]]; then
     CLANG="clang"
 fi
 
+START_HEADERS=$(echo \
+    $BUILD_PATH/dbms/src/Common/config_version.h \
+    $SOURCE_PATH/dbms/src/Interpreters/SpecializedAggregator.h \
+    $SOURCE_PATH/dbms/src/AggregateFunctions/AggregateFunction*.h)
+
 # Опция -mcx16 для того, чтобы выбиралось больше заголовочных файлов (с запасом).
 
-for src_file in $($CLANG -M -xc++ -std=gnu++1z -Wall -Werror -msse4 -mcx16 -mpopcnt -O3 -g -fPIC \
-    $(cat "$SOURCE_PATH/build/include_directories.txt") \
-    "$SOURCE_PATH/build/dbms/src/Common/config_version.h" \
-    "$SOURCE_PATH/dbms/src/Interpreters/SpecializedAggregator.h" |
+for src_file in $(echo | $CLANG -M -xc++ -std=gnu++1z -Wall -Werror -msse4 -mcx16 -mpopcnt -O3 -g -fPIC \
+    $(cat "$BUILD_PATH/include_directories.txt") \
+    $(echo $START_HEADERS | sed -r -e 's/[^ ]+/-include \0/g') \
+    - |
     tr -d '\\' |
-    sed -r -e 's/^\w+\.o://');
+    sed -r -e 's/^-\.o://');
 do
     dst_file=$src_file;
     dst_file=$(echo $dst_file | sed -r -e 's/build\///')    # for simplicity reasons, will put generated headers near the rest.
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionArgMinMax.h b/dbms/src/AggregateFunctions/AggregateFunctionArgMinMax.h
index d893bae6ea2..1a1dfb8de4d 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionArgMinMax.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionArgMinMax.h
@@ -69,6 +69,8 @@ public:
     {
         this->data(place).result.insertResultInto(to);
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 }
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionArray.h b/dbms/src/AggregateFunctions/AggregateFunctionArray.h
index ab5f3a75baa..98dc4d18b7e 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionArray.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionArray.h
@@ -132,6 +132,8 @@ public:
     }
 
     IAggregateFunction::AddFunc getAddressOfAddFunction() const override final { return &addFree; }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 }
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionAvg.h b/dbms/src/AggregateFunctions/AggregateFunctionAvg.h
index a073b279583..44fee37959f 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionAvg.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionAvg.h
@@ -70,6 +70,8 @@ public:
         static_cast<ColumnFloat64 &>(to).getData().push_back(
             static_cast<Float64>(this->data(place).sum) / this->data(place).count);
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionBitwise.h b/dbms/src/AggregateFunctions/AggregateFunctionBitwise.h
index 281a7c122ea..ffb7b994e75 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionBitwise.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionBitwise.h
@@ -81,6 +81,8 @@ public:
     {
         static_cast<ColumnVector<T> &>(to).getData().push_back(this->data(place).value);
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionCount.h b/dbms/src/AggregateFunctions/AggregateFunctionCount.h
index 1ebfb3c97cb..6e6729314c0 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionCount.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionCount.h
@@ -70,6 +70,8 @@ public:
     {
         data(place).count += x;
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
@@ -114,6 +116,8 @@ public:
     {
         static_cast<ColumnUInt64 &>(to).getData().push_back(data(place).count);
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
@@ -183,6 +187,8 @@ public:
         static_cast<ColumnUInt64 &>(to).getData().push_back(data(place).count);
     }
 
+    const char * getHeaderFilePath() const override { return __FILE__; }
+
 private:
     enum { MAX_ARGS = 8 };
     size_t number_of_arguments = 0;
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionForEach.h b/dbms/src/AggregateFunctions/AggregateFunctionForEach.h
index ae5e984a580..0106ef09351 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionForEach.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionForEach.h
@@ -245,6 +245,8 @@ public:
     }
 
     IAggregateFunction::AddFunc getAddressOfAddFunction() const override final { return &addFree; }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionGroupArray.h b/dbms/src/AggregateFunctions/AggregateFunctionGroupArray.h
index 398abc3038a..67a9b044784 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionGroupArray.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionGroupArray.h
@@ -137,6 +137,8 @@ public:
     {
         return true;
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
@@ -408,6 +410,8 @@ public:
     {
         return true;
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 #undef AGGREGATE_FUNCTION_GROUP_ARRAY_MAX_ARRAY_SIZE
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionGroupArrayInsertAt.h b/dbms/src/AggregateFunctions/AggregateFunctionGroupArrayInsertAt.h
index 6a48e621444..d4e2f3d87a0 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionGroupArrayInsertAt.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionGroupArrayInsertAt.h
@@ -202,6 +202,8 @@ public:
 
         to_offsets.push_back((to_offsets.empty() ? 0 : to_offsets.back()) + result_array_size);
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h b/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
index fd2640c64cb..2ed54c34bdb 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionGroupUniqArray.h
@@ -98,6 +98,8 @@ public:
         for (auto it = set.begin(); it != set.end(); ++it, ++i)
             data_to[old_size + i] = *it;
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
@@ -219,6 +221,8 @@ public:
             deserializeAndInsert(elem, data_to);
         }
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionIf.h b/dbms/src/AggregateFunctions/AggregateFunctionIf.h
index 2e90df38dbc..78f4c4fcd82 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionIf.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionIf.h
@@ -121,6 +121,8 @@ public:
     }
 
     IAggregateFunction::AddFunc getAddressOfAddFunction() const override final { return &addFree; }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 }
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionMerge.h b/dbms/src/AggregateFunctions/AggregateFunctionMerge.h
index d7b99f44b41..103ee56c87e 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionMerge.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionMerge.h
@@ -121,6 +121,8 @@ public:
     }
 
     IAggregateFunction::AddFunc getAddressOfAddFunction() const override final { return &addFree; }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 }
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionMinMaxAny.h b/dbms/src/AggregateFunctions/AggregateFunctionMinMaxAny.h
index 42b2760e1f7..2a68ff23569 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionMinMaxAny.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionMinMaxAny.h
@@ -726,6 +726,8 @@ public:
     {
         this->data(place).insertResultInto(to);
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 }
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionNull.h b/dbms/src/AggregateFunctions/AggregateFunctionNull.h
index 5c0bba68184..4d0c5e5f746 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionNull.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionNull.h
@@ -157,6 +157,8 @@ public:
     {
         return nested_function->isState();
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionQuantile.h b/dbms/src/AggregateFunctions/AggregateFunctionQuantile.h
index 32f4650a55b..78887ef39bc 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionQuantile.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionQuantile.h
@@ -99,6 +99,8 @@ public:
         else
             static_cast<ColumnVector<ArgumentFieldType> &>(to).getData().push_back(sample.quantileInterpolated(level));
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
@@ -192,6 +194,8 @@ public:
                 data_to.push_back(sample.quantileInterpolated(levels[i]));
         }
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 }
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionQuantileDeterministic.h b/dbms/src/AggregateFunctions/AggregateFunctionQuantileDeterministic.h
index 145ff2c1970..0e0997d9c74 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionQuantileDeterministic.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionQuantileDeterministic.h
@@ -105,6 +105,8 @@ public:
         else
             static_cast<ColumnVector<ArgumentFieldType> &>(to).getData().push_back(sample.quantileInterpolated(level));
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
@@ -204,6 +206,8 @@ public:
                 data_to.push_back(sample.quantileInterpolated(levels[i]));
         }
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 }
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionQuantileExact.h b/dbms/src/AggregateFunctions/AggregateFunctionQuantileExact.h
index 30717dd9c37..8d1233ef6b9 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionQuantileExact.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionQuantileExact.h
@@ -117,6 +117,8 @@ public:
 
         static_cast<ColumnVector<T> &>(to).getData().push_back(quantile);
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
@@ -217,6 +219,8 @@ public:
                 data_to[old_size + i] = T();
         }
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 }
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionQuantileExactWeighted.h b/dbms/src/AggregateFunctions/AggregateFunctionQuantileExactWeighted.h
index e5ca9f8acc1..d0a2d6a4a00 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionQuantileExactWeighted.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionQuantileExactWeighted.h
@@ -154,6 +154,8 @@ public:
 
         static_cast<ColumnVector<ValueType> &>(to).getData().push_back(it->first);
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
@@ -296,6 +298,8 @@ public:
             ++level_index;
         }
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 }
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionQuantileTDigest.h b/dbms/src/AggregateFunctions/AggregateFunctionQuantileTDigest.h
index f00ea788249..b32d02c9600 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionQuantileTDigest.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionQuantileTDigest.h
@@ -411,6 +411,8 @@ public:
         else
             static_cast<ColumnVector<T> &>(to).getData().push_back(quantile);
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
@@ -480,6 +482,8 @@ public:
         else
             static_cast<ColumnVector<T> &>(to).getData().push_back(quantile);
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
@@ -563,6 +567,8 @@ public:
                 params, &levels.levels[0], &levels.permutation[0], size, &data_to[old_size]);
         }
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
@@ -648,6 +654,8 @@ public:
                 params, &levels.levels[0], &levels.permutation[0], size, &data_to[old_size]);
         }
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 }
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionQuantileTiming.h b/dbms/src/AggregateFunctions/AggregateFunctionQuantileTiming.h
index 86f9eaadf7f..c617d216443 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionQuantileTiming.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionQuantileTiming.h
@@ -843,6 +843,8 @@ public:
     {
         static_cast<ColumnFloat32 &>(to).getData().push_back(this->data(place).getFloat(level));
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
@@ -903,6 +905,8 @@ public:
     {
         static_cast<ColumnFloat32 &>(to).getData().push_back(this->data(place).getFloat(level));
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
@@ -971,6 +975,8 @@ public:
 
         this->data(place).getManyFloat(&levels.levels[0], &levels.permutation[0], size, &data_to[old_size]);
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
@@ -1037,6 +1043,8 @@ public:
 
         this->data(place).getManyFloat(&levels.levels[0], &levels.permutation[0], size, &data_to[old_size]);
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionSequenceMatch.h b/dbms/src/AggregateFunctions/AggregateFunctionSequenceMatch.h
index b941b2fb99b..3f99999f12d 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionSequenceMatch.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionSequenceMatch.h
@@ -238,6 +238,8 @@ public:
 
     IAggregateFunction::AddFunc getAddressOfAddFunction() const override final { return &addFree; }
 
+    const char * getHeaderFilePath() const override { return __FILE__; }
+
 private:
     enum class PatternActionType
     {
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionState.h b/dbms/src/AggregateFunctions/AggregateFunctionState.h
index 86511be93d0..55ab4c6150a 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionState.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionState.h
@@ -111,6 +111,8 @@ public:
     }
 
     IAggregateFunction::AddFunc getAddressOfAddFunction() const override final { return &addFree; }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 }
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionStatistics.h b/dbms/src/AggregateFunctions/AggregateFunctionStatistics.h
index f20fb333497..be9445cb8dc 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionStatistics.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionStatistics.h
@@ -153,6 +153,8 @@ public:
     {
         this->data(place).publish(to);
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 /** Implementing the varSamp function.
@@ -416,6 +418,8 @@ public:
     {
         this->data(place).publish(to);
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 /** Implementing the covarSamp function.
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionSum.h b/dbms/src/AggregateFunctions/AggregateFunctionSum.h
index 4bb6a711c4f..f7acddafd3c 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionSum.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionSum.h
@@ -63,6 +63,8 @@ public:
     {
         static_cast<ColumnVector<typename NearestFieldType<T>::Type> &>(to).getData().push_back(this->data(place).sum);
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionTopK.h b/dbms/src/AggregateFunctions/AggregateFunctionTopK.h
index a8b8eddfa88..64938d97f38 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionTopK.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionTopK.h
@@ -120,6 +120,8 @@ public:
         for (auto it = resultVec.begin(); it != resultVec.end(); ++it, ++i)
             data_to[old_size + i] = it->key;
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
@@ -236,6 +238,8 @@ public:
             deserializeAndInsert(elem.key, data_to);
         }
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionUniq.h b/dbms/src/AggregateFunctions/AggregateFunctionUniq.h
index 9c36b12a2cc..2a0e982403b 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionUniq.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionUniq.h
@@ -255,7 +255,7 @@ struct OneAdder<T, Data, typename std::enable_if<
     std::is_same<Data, AggregateFunctionUniqHLL12Data<T>>::value>::type>
 {
     template <typename T2 = T>
-    static void addImpl(Data & data, const IColumn & column, size_t row_num,
+    static void ALWAYS_INLINE addImpl(Data & data, const IColumn & column, size_t row_num,
         typename std::enable_if<!std::is_same<T2, String>::value>::type * = nullptr)
     {
         const auto & value = static_cast<const ColumnVector<T2> &>(column).getData()[row_num];
@@ -263,7 +263,7 @@ struct OneAdder<T, Data, typename std::enable_if<
     }
 
     template <typename T2 = T>
-    static void addImpl(Data & data, const IColumn & column,    size_t row_num,
+    static void ALWAYS_INLINE addImpl(Data & data, const IColumn & column,    size_t row_num,
         typename std::enable_if<std::is_same<T2, String>::value>::type * = nullptr)
     {
         StringRef value = column.getDataAt(row_num);
@@ -279,7 +279,7 @@ struct OneAdder<T, Data, typename std::enable_if<
     std::is_same<Data, AggregateFunctionUniqCombinedData<T>>::value>::type>
 {
     template <typename T2 = T>
-    static void addImpl(Data & data, const IColumn & column, size_t row_num,
+    static void ALWAYS_INLINE addImpl(Data & data, const IColumn & column, size_t row_num,
         typename std::enable_if<!std::is_same<T2, String>::value>::type * = nullptr)
     {
         const auto & value = static_cast<const ColumnVector<T2> &>(column).getData()[row_num];
@@ -287,7 +287,7 @@ struct OneAdder<T, Data, typename std::enable_if<
     }
 
     template <typename T2 = T>
-    static void addImpl(Data & data, const IColumn & column,    size_t row_num,
+    static void ALWAYS_INLINE addImpl(Data & data, const IColumn & column,    size_t row_num,
         typename std::enable_if<std::is_same<T2, String>::value>::type * = nullptr)
     {
         StringRef value = column.getDataAt(row_num);
@@ -300,14 +300,14 @@ struct OneAdder<T, Data, typename std::enable_if<
     std::is_same<Data, AggregateFunctionUniqExactData<T>>::value>::type>
 {
     template <typename T2 = T>
-    static void addImpl(Data & data, const IColumn & column, size_t row_num,
+    static void ALWAYS_INLINE addImpl(Data & data, const IColumn & column, size_t row_num,
         typename std::enable_if<!std::is_same<T2, String>::value>::type * = nullptr)
     {
         data.set.insert(static_cast<const ColumnVector<T2> &>(column).getData()[row_num]);
     }
 
     template <typename T2 = T>
-    static void addImpl(Data & data, const IColumn & column, size_t row_num,
+    static void ALWAYS_INLINE addImpl(Data & data, const IColumn & column, size_t row_num,
         typename std::enable_if<std::is_same<T2, String>::value>::type * = nullptr)
     {
         StringRef value = column.getDataAt(row_num);
@@ -364,6 +364,8 @@ public:
     {
         static_cast<ColumnUInt64 &>(to).getData().push_back(this->data(place).set.size());
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
@@ -426,6 +428,8 @@ public:
     }
 
     IAggregateFunction::AddFunc getAddressOfAddFunction() const override final { return &addFree; }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
diff --git a/dbms/src/AggregateFunctions/AggregateFunctionUniqUpTo.h b/dbms/src/AggregateFunctions/AggregateFunctionUniqUpTo.h
index 3c40ad98c51..bb4d7e2bbc9 100644
--- a/dbms/src/AggregateFunctions/AggregateFunctionUniqUpTo.h
+++ b/dbms/src/AggregateFunctions/AggregateFunctionUniqUpTo.h
@@ -176,6 +176,8 @@ public:
     {
         static_cast<ColumnUInt64 &>(to).getData().push_back(this->data(place).size());
     }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
@@ -256,6 +258,8 @@ public:
     }
 
     IAggregateFunction::AddFunc getAddressOfAddFunction() const override final { return &addFree; }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
 };
 
 
diff --git a/dbms/src/AggregateFunctions/IAggregateFunction.h b/dbms/src/AggregateFunctions/IAggregateFunction.h
index 98ad8fe396e..d9b728cbaa7 100644
--- a/dbms/src/AggregateFunctions/IAggregateFunction.h
+++ b/dbms/src/AggregateFunctions/IAggregateFunction.h
@@ -121,7 +121,6 @@ public:
       */
     virtual bool isState() const { return false; }
 
-
     /** The inner loop that uses the function pointer is better than using the virtual function.
       * The reason is that in the case of virtual functions GCC 5.1.2 generates code,
       *  which, at each iteration of the loop, reloads the function address (the offset value in the virtual function table) from memory to the register.
@@ -130,6 +129,12 @@ public:
       */
     using AddFunc = void (*)(const IAggregateFunction *, AggregateDataPtr, const IColumn **, size_t, Arena *);
     virtual AddFunc getAddressOfAddFunction() const = 0;
+
+    /** This is used for runtime code generation to determine, which header files to include in generated source.
+      * Always implement it as
+      * const char * getHeaderFilePath() const override { return __FILE__; }
+      */
+    virtual const char * getHeaderFilePath() const = 0;
 };
 
 
diff --git a/dbms/src/Interpreters/Aggregator.cpp b/dbms/src/Interpreters/Aggregator.cpp
index cf97941c8c2..789f712344f 100644
--- a/dbms/src/Interpreters/Aggregator.cpp
+++ b/dbms/src/Interpreters/Aggregator.cpp
@@ -223,6 +223,7 @@ void Aggregator::compileIfPossible(AggregatedDataVariants::Type type)
 
     /// List of types of aggregate functions.
     std::stringstream aggregate_functions_typenames_str;
+    std::stringstream aggregate_functions_headers_args;
     for (size_t i = 0; i < params.aggregates_size; ++i)
     {
         IAggregateFunction & func = *aggregate_functions[i];
@@ -237,8 +238,21 @@ void Aggregator::compileIfPossible(AggregatedDataVariants::Type type)
                 + ", status: " + toString(status), ErrorCodes::CANNOT_COMPILE_CODE);
 
         aggregate_functions_typenames_str << ((i != 0) ? ", " : "") << type_name;
+
+        std::string header_path = func.getHeaderFilePath();
+        auto pos = header_path.find("/AggregateFunctions/");
+
+        if (pos == std::string::npos)
+            throw Exception("Cannot compile code: unusual path of header file for aggregate function: " + header_path,
+                ErrorCodes::CANNOT_COMPILE_CODE);
+
+        aggregate_functions_headers_args << "-include '" INTERNAL_COMPILER_HEADERS "/dbms/src";
+        aggregate_functions_headers_args.write(&header_path[pos], header_path.size() - pos);
+        aggregate_functions_headers_args << "' ";
     }
 
+    aggregate_functions_headers_args << "-include '" INTERNAL_COMPILER_HEADERS "/dbms/src/Interpreters/SpecializedAggregator.h'";
+
     std::string aggregate_functions_typenames = aggregate_functions_typenames_str.str();
 
     std::stringstream key_str;
@@ -355,9 +369,9 @@ void Aggregator::compileIfPossible(AggregatedDataVariants::Type type)
       * If the counter has reached the value min_count_to_compile, then the compilation starts asynchronously (in a separate thread)
       *  at the end of which `on_ready` callback is called.
       */
+    aggregate_functions_headers_args << " -Wno-unused-function";
     SharedLibraryPtr lib = params.compiler->getOrCount(key, params.min_count_to_compile,
-        "-include " INTERNAL_COMPILER_HEADERS "/dbms/src/Interpreters/SpecializedAggregator.h "
-        "-Wno-unused-function",
+        aggregate_functions_headers_args.str(),
         get_code, on_ready);
 
     /// If the result is already ready.
diff --git a/dbms/src/Interpreters/Compiler.cpp b/dbms/src/Interpreters/Compiler.cpp
index c6283ebf8d3..4f5dcfc3308 100644
--- a/dbms/src/Interpreters/Compiler.cpp
+++ b/dbms/src/Interpreters/Compiler.cpp
@@ -215,7 +215,7 @@ void Compiler::compile(
 
     std::stringstream command;
 
-    /// Slightly uncomfortable.
+    /// Slightly unconvenient.
     command <<
         "LD_LIBRARY_PATH=" PATH_SHARE "/clickhouse/bin/"
         " " INTERNAL_COMPILER_EXECUTABLE
@@ -231,6 +231,7 @@ void Compiler::compile(
 #endif
         " -I " INTERNAL_COMPILER_HEADERS "/dbms/src/"
         " -I " INTERNAL_COMPILER_HEADERS "/contrib/libcityhash/include/"
+        " -I " INTERNAL_COMPILER_HEADERS "/contrib/libpcg-random/include/"
         " -I " INTERNAL_DOUBLE_CONVERSION_INCLUDE_DIR
         " -I " INTERNAL_Poco_Foundation_INCLUDE_DIR
         " -I " INTERNAL_Boost_INCLUDE_DIRS
diff --git a/dbms/src/Interpreters/SpecializedAggregator.h b/dbms/src/Interpreters/SpecializedAggregator.h
index 8ea63b577b6..228977e4910 100644
--- a/dbms/src/Interpreters/SpecializedAggregator.h
+++ b/dbms/src/Interpreters/SpecializedAggregator.h
@@ -1,32 +1,7 @@
 #include <Common/TypeList.h>
+#include <Common/typeid_cast.h>
 #include <Interpreters/Aggregator.h>
 
-#include <AggregateFunctions/AggregateFunctionArgMinMax.h>
-#include <AggregateFunctions/AggregateFunctionArray.h>
-#include <AggregateFunctions/AggregateFunctionAvg.h>
-#include <AggregateFunctions/AggregateFunctionCount.h>
-#include <AggregateFunctions/AggregateFunctionForEach.h>
-#include <AggregateFunctions/AggregateFunctionGroupArray.h>
-#include <AggregateFunctions/AggregateFunctionGroupArrayInsertAt.h>
-#include <AggregateFunctions/AggregateFunctionGroupUniqArray.h>
-#include <AggregateFunctions/AggregateFunctionIf.h>
-#include <AggregateFunctions/AggregateFunctionMerge.h>
-#include <AggregateFunctions/AggregateFunctionMinMaxAny.h>
-#include <AggregateFunctions/AggregateFunctionNull.h>
-#include <AggregateFunctions/AggregateFunctionQuantileDeterministic.h>
-#include <AggregateFunctions/AggregateFunctionQuantileExact.h>
-#include <AggregateFunctions/AggregateFunctionQuantileExactWeighted.h>
-#include <AggregateFunctions/AggregateFunctionQuantile.h>
-#include <AggregateFunctions/AggregateFunctionQuantileTDigest.h>
-#include <AggregateFunctions/AggregateFunctionQuantileTiming.h>
-#include <AggregateFunctions/AggregateFunctionSequenceMatch.h>
-#include <AggregateFunctions/AggregateFunctionState.h>
-#include <AggregateFunctions/AggregateFunctionStatistics.h>
-#include <AggregateFunctions/AggregateFunctionSum.h>
-#include <AggregateFunctions/AggregateFunctionTopK.h>
-#include <AggregateFunctions/AggregateFunctionUniq.h>
-#include <AggregateFunctions/AggregateFunctionUniqUpTo.h>
-
 
 namespace DB
 {
diff --git a/dbms/src/Parsers/ASTSystemQuery.h b/dbms/src/Parsers/ASTSystemQuery.h
index 31f40193ec3..8f9a4bf2208 100644
--- a/dbms/src/Parsers/ASTSystemQuery.h
+++ b/dbms/src/Parsers/ASTSystemQuery.h
@@ -1,6 +1,6 @@
 #pragma once
+
 #include <Parsers/IAST.h>
-#include <AggregateFunctions/AggregateFunctionCount.h>
 
 
 namespace DB